/// <summary>
/// Public method used to reset this building slot, reinitializing to blank state
/// </summary>
public void ClearSlot()
{
mModule = null;
SpriteRenderer sr = GetComponent <SpriteRenderer>();
if (sr != null)
{
sr.sprite = null;
}
}
private void DrawFloors(ref Texture2D2 texture)
{
BuildingModule module = GameObject.FindObjectOfType <BuildingModule>();
for (int x = 0; x < this.dimension.x; x++)
{
for (int y = 0; y < this.dimension.y; y++)
{
MapGenerator.AddToTexture(ref texture, this.Position(Depth.World) + new Point(x, y), module.building_floor);
}
}
}
public void SetBuildingModule(BuildingModule module)
{
mModule = module;
SpriteRenderer sr = GetComponent <SpriteRenderer>();
if (sr != null)
{
sr.sprite = module.mSprite;
}
Debug.Log("Setting module to " + module);
}
public void ShouldUpdateBuilding()
{
MockedDatabase <Building> database;
BuildingModule module;
database = new MockedDatabase <Building>(false, 1, (t) => new Building()
{
BuildingID = t
});
module = new BuildingModule(NullLogger.Instance, database);
module.UpdateBuilding(0, 10);
Assert.AreEqual(1, database.UpdatedCount);
}
public void ShouldNotGetBuildingUsingCoordinates()
{
MockedDatabase <Building> database;
BuildingModule module;
Building result;
database = new MockedDatabase <Building>(false, 0, (t) => new Building()
{
BuildingID = t, X = 3, Y = 4
});
module = new BuildingModule(NullLogger.Instance, database);
result = module.GetBuilding(1, 4, 3);
Assert.IsNull(result);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
NinjectModule buildingModule = new BuildingModule();
NinjectModule serviceModule = new ServiceModule("DefaultConnection");
var kernel = new StandardKernel(buildingModule, serviceModule);
DependencyResolver.SetResolver(new NinjectDependencyResolver(kernel));
}
public void Destory()
{
this.m_BuilderModule = null;
this.m_BuildingModule = null;
this.m_PlayerModule = null;
this.m_ArmyModule = null;
this.m_ItemModule = null;
this.m_ShopModule = null;
this.m_RemovableModule = null;
this.m_TaskModule = null;
this.m_PropsModule = null;
this.m_DefenseModule = null;
this.m_AchievementBuildingModule = null;
this.m_CurrentFriend = null;
}
public void ShouldNotUpdateBuildingAndLogError()
{
MockedDatabase <Building> database;
BuildingModule module;
MemoryLogger logger;
logger = new MemoryLogger();
database = new MockedDatabase <Building>(true, 3, (t) => new Building()
{
BuildingID = t
});
module = new BuildingModule(logger, database);
Assert.ThrowsException <PIODataException>(() => module.UpdateBuilding(0, 1));
Assert.IsNotNull(logger.Logs.FirstOrDefault(item => (item.Level == LogLevels.Error) && (item.ComponentName == module.ModuleName)));
}
public void ShouldGetBuilding()
{
MockedDatabase <Building> database;
BuildingModule module;
Building result;
database = new MockedDatabase <Building>(false, 1, (t) => new Building()
{
BuildingID = t
});
module = new BuildingModule(NullLogger.Instance, database);
result = module.GetBuilding(1);
Assert.IsNotNull(result);
Assert.AreEqual(0, result.BuildingID);
}
public void ShouldGetBuildingUsingCoordinates()
{
MockedDatabase <Building> database;
BuildingModule module;
Building result;
database = new MockedDatabase <Building>(false, 1, (t) => new Building()
{
BuildingID = t, X = 3, Y = 4
});
module = new BuildingModule(NullLogger.Instance, database);
result = module.GetBuilding(1, 3, 4);
Assert.IsNotNull(result);
Assert.AreEqual(0, result.BuildingID);
Assert.AreEqual(3, result.X);
Assert.AreEqual(4, result.Y);
}
public void ShouldNotCreateBuildingAndLogError()
{
MockedDatabase <Building> database;
BuildingModule module;
MemoryLogger logger;
logger = new MemoryLogger();
database = new MockedDatabase <Building>(true, 1, (t) => new Building()
{
BuildingID = t
});
module = new BuildingModule(logger, database);
Assert.ThrowsException <PIODataException>(() => module.CreateBuilding(1, 7, 9, BuildingTypeIDs.Sawmill, 1, 10));
Assert.IsNotNull(logger.Logs.FirstOrDefault(item => (item.Level == LogLevels.Error) && (item.ComponentName == module.ModuleName)));
Assert.AreEqual(0, database.InsertedCount);
}
public void Initialize(UserData userData, List <BuildingData> buildingData, List <ArmyData> armyData, List <ItemData> itemData,
List <ObjectUpgrade <ArmyType> > armyUpgrade, List <ObjectUpgrade <ItemType> > itemUpgrade, List <RemovableObjectData> removableObjects,
List <TaskInformation> tasks, Dictionary <MercenaryIdentity, MercenaryData> mercenaries, Dictionary <int, PropsData> props, List <DefenseObjectData> defenseObjects,
int removableObjectStartNo, int propsStartNo, List <AchievementBuildingData> achievementBuildings, int achievementBuildingStartNo)
{
this.m_BuilderModule = new BuilderManager();
this.m_PlayerModule = new PlayerLogicObject();
this.m_BuildingModule = new BuildingModule(this.m_BuilderModule);
this.m_ArmyModule = new ArmyModule();
this.m_ItemModule = new ItemModule();
this.m_MercenaryModule = new MercenaryModule();
this.m_ShopModule = new ShopModule();
this.m_RemovableModule = new RemovableObjectModule(this.m_BuilderModule);
this.m_MercenaryModule.InitializeMercenaries(mercenaries);
this.m_ItemModule.InitializeItem(itemData, itemUpgrade);
this.m_ArmyModule.InitializeArmy(armyData, armyUpgrade);
this.m_PlayerModule.IntializePlayer(userData);
this.m_BuildingModule.IntializeBuilding(buildingData);
this.m_RemovableModule.InitialWithData(removableObjects, removableObjectStartNo);
this.m_BuildingModule.ItemUpgradeFinished += ItemUpgradeFinished;
this.m_BuildingModule.ArmyUpgradeFinished += ArmyUpgradeFinished;
this.m_IsNewPlayer = (removableObjects.Count == ClientSystemConstants.INITIAL_REMOVABLE_OBJECT_NUMBER) &&
(removableObjects[0].Position == null);
this.m_TaskModule = new TaskManager();
foreach (TaskInformation info in tasks)
{
TaskProgressFactory.PopulateTaskInformation(info);
}
this.m_TaskModule.InitialTask(tasks);
this.m_PropsModule = new PropsModule();
this.m_PropsModule.InitializeProps(props, propsStartNo);
this.m_DefenseModule = new DefenseObjectModule();
this.m_DefenseModule.InitialDefenseObject(defenseObjects);
this.m_AchievementBuildingModule = new AchievementBuildingModule();
this.m_AchievementBuildingModule.InitialAchievementBuilding(achievementBuildings, achievementBuildingStartNo);
}
private void DrawEntrance(Directional entrance, ref Texture2D2 texture)
{
BuildingModule module = GameObject.FindObjectOfType <BuildingModule>();
if (entrance.direction == Direction.North)
{
MapGenerator.AddToTexture(ref texture, entrance.Position(Depth.World), module.entrance_north);
}
else if (entrance.direction == Direction.East)
{
MapGenerator.AddToTexture(ref texture, entrance.Position(Depth.World), module.entrance_east);
}
else if (entrance.direction == Direction.South)
{
MapGenerator.AddToTexture(ref texture, entrance.Position(Depth.World), module.entrance_south);
}
else
{
MapGenerator.AddToTexture(ref texture, entrance.Position(Depth.World), module.entrance_west);
}
}
private void DrawWindow(Directional window, ref Texture2D2 texture)
{
BuildingModule module = GameObject.FindObjectOfType <BuildingModule>();
if (window.direction == Direction.North)
{
MapGenerator.AddToTexture(ref texture, window.Position(Depth.World), module.window_north);
}
else if (window.direction == Direction.East)
{
MapGenerator.AddToTexture(ref texture, window.Position(Depth.World), module.window_east);
}
else if (window.direction == Direction.South)
{
MapGenerator.AddToTexture(ref texture, window.Position(Depth.World), module.window_south);
}
else
{
MapGenerator.AddToTexture(ref texture, window.Position(Depth.World), module.window_west);
}
}
public void ShouldGetBuildings()
{
MockedDatabase <Building> database;
BuildingModule module;
Building[] results;
database = new MockedDatabase <Building>(false, 3, (t) => new Building()
{
BuildingID = t
});
module = new BuildingModule(NullLogger.Instance, database);
results = module.GetBuildings(1);
Assert.IsNotNull(results);
Assert.AreEqual(3, results.Length);
for (int t = 0; t < 3; t++)
{
Assert.IsNotNull(results[t]);
Assert.AreEqual(t, results[t].BuildingID);
}
}
public void ShouldCreateBuilding()
{
MockedDatabase <Building> database;
BuildingModule module;
Building result;
database = new MockedDatabase <Building>(false, 1, (t) => new Building()
{
BuildingID = t
});
module = new BuildingModule(NullLogger.Instance, database);
result = module.CreateBuilding(1, 7, 9, BuildingTypeIDs.Sawmill, 1, 10);
Assert.IsNotNull(result);
Assert.AreEqual(1, result.PlanetID);
Assert.AreEqual(1, result.RemainingBuildSteps);
Assert.AreEqual(7, result.X);
Assert.AreEqual(9, result.Y);
Assert.AreEqual(10, result.HealthPoints);
Assert.AreEqual(1, database.InsertedCount);
}
static void Main(string[] args)
{
ILogger logger;
VersionControlModule versionControlModule;
ServiceHostModule pioServiceHostModule;
ServiceHostModule taskCallbackServiceHostModule;
SchedulerModule schedulerModule;
IPIOService pioService;
ITaskCallbackService taskCallbackService;
IDatabase database;
IConnectionFactory connectionFactory;
ICommandBuilder commandBuilder;
IDatabaseCreator databaseCreator;
IPlanetGeneratorModule planetGeneratorModule;
IPhraseModule phraseModule;
IPlanetModule planetModule;
ICellModule cellModule;
IBuildingModule buildingModule;
IWorkerModule workerModule;
IBuilderModule factoryBuilderModule;
IStackModule stackModule;
IResourceTypeModule resourceTypeModule;
IBuildingTypeModule buildingTypeModule;
ITaskTypeModule taskTypeModule;
IMaterialModule materialModule;
IIngredientModule ingredientModule;
IProductModule productModule;
ITaskModule taskModule;
IIdlerModule idlerModule;
IResourceCheckerModule resourceCheckerModule;
ILocationCheckerModule locationCheckerModule;
IProducerModule producerModule;
IHarvesterModule harvesterModule;
IMoverModule moverModule;
ITakerModule takerModule;
IStorerModule storerModule;
quitEvent = new AutoResetEvent(false);
Console.CancelKeyPress += new ConsoleCancelEventHandler(Console_CancelKeyPress);
//logger = new ConsoleLogger(new DefaultLogFormatter());
logger = new UnicastLogger(IPAddress.Loopback, Properties.Settings.Default.UnicastPort);
//logger = new FileLogger(new DefaultLogFormatter(), "PIO.ServerHost.Log");
databaseCreator = new SqlDatabaseCreator(Properties.Settings.Default.Server, Properties.Settings.Default.DatabaseName);
connectionFactory = new SqlConnectionFactory(Properties.Settings.Default.Server, Properties.Settings.Default.DatabaseName);
commandBuilder = new SqlCommandBuilder();
database = new Database(connectionFactory, commandBuilder);
versionControlModule = new VersionControlModule(logger, databaseCreator, new PIOVersionControl(database));
if (!versionControlModule.InitializeDatabase(Properties.Settings.Default.DropDatabase))
{
return;
}
phraseModule = new PhraseModule(logger, database);
planetModule = new PlanetModule(logger, database);
cellModule = new CellModule(logger, database);
buildingModule = new BuildingModule(logger, database);
workerModule = new WorkerModule(logger, database);
stackModule = new StackModule(logger, database);
resourceTypeModule = new ResourceTypeModule(logger, database);
buildingTypeModule = new BuildingTypeModule(logger, database);
taskTypeModule = new TaskTypeModule(logger, database);
materialModule = new MaterialModule(logger, database);
ingredientModule = new IngredientModule(logger, database);
productModule = new ProductModule(logger, database);
taskModule = new TaskModule(logger, database);
factoryBuilderModule = new BuilderModule(logger, taskModule, workerModule, buildingModule, buildingTypeModule, stackModule, materialModule);;
idlerModule = new IdlerModule(logger, taskModule, workerModule);
resourceCheckerModule = new ResourceCheckerModule(logger, buildingModule, stackModule, ingredientModule, materialModule);
locationCheckerModule = new LocationCheckerModule(logger, workerModule, buildingModule);
producerModule = new ProducerModule(logger, taskModule, workerModule, buildingModule, buildingTypeModule, stackModule, ingredientModule, productModule);
harvesterModule = new HarvesterModule(logger, taskModule, workerModule, buildingModule, buildingTypeModule, stackModule, productModule);
moverModule = new MoverModule(logger, taskModule, workerModule, buildingModule);
takerModule = new TakerModule(logger, taskModule, workerModule, buildingModule, stackModule);
storerModule = new StorerModule(logger, taskModule, workerModule, buildingModule, stackModule);
planetGeneratorModule = new PlanetGeneratorModule(logger, phraseModule, resourceTypeModule, buildingTypeModule, taskTypeModule, materialModule, ingredientModule, productModule, planetModule, cellModule, buildingModule, workerModule);
if (!planetGeneratorModule.Generate())
{
return;
}
schedulerModule = new SchedulerModule(logger, taskModule, idlerModule, producerModule, harvesterModule, moverModule, takerModule, storerModule, factoryBuilderModule);
schedulerModule.Start();
pioService = new PIOService(
logger, phraseModule, planetModule, cellModule, buildingModule, workerModule,
stackModule, resourceTypeModule,
buildingTypeModule, taskTypeModule, materialModule, ingredientModule, productModule, taskModule,
schedulerModule,
resourceCheckerModule, locationCheckerModule, idlerModule, producerModule, harvesterModule, moverModule, takerModule, storerModule,
factoryBuilderModule);
pioServiceHostModule = new ServiceHostModule(logger, pioService);
pioServiceHostModule.Start();
taskCallbackService = new TaskCallbackService(logger, schedulerModule);
taskCallbackServiceHostModule = new ServiceHostModule(logger, taskCallbackService);
taskCallbackServiceHostModule.Start();
WaitHandle.WaitAny(new WaitHandle[] { quitEvent }, -1);
taskCallbackServiceHostModule.Stop();
pioServiceHostModule.Stop();
schedulerModule.Stop();
Console.CancelKeyPress -= new ConsoleCancelEventHandler(Console_CancelKeyPress);
}
/// ------------------------------------- PUBLIC METHODS ----------------------------------- ///
/// <summary>
/// Public method calls to have this building build a new module if not already full
/// </summary>
public void BuildNewModule()
{
if (mEmptySlots == 0)
{
Debug.Log("This building is full and can't build anymore modules");
return;
}
CameraShaker camShake = GetComponent <CameraShaker>();
AudioSource audio = GetComponent <AudioSource>();
// special case - if it's the first module, make it a door.
if (mEmptySlots == mBuildingWidth * mBuildingHeight)
{
int doorSlot = (int)(((mBuildingWidth * 0.5f) - 1));
mSlots[doorSlot].GetComponent <BuildingSlot>().SetBuildingModule(mModuleSet.mDoorModules[0]);
mSlots[doorSlot].GetComponent <BuildingSlot>().mIsDoor = true;
mLastModuleBuiltIndex = doorSlot;
mEmptySlots -= 1;
// add in little camera shake when building a new module
if (camShake)
{
camShake.ShakeCamera();
}
if (audio)
{
audio.Play();
}
return;
}
//Debug.Log("Building a new module in building " + gameObject);
// select which slot to fill next based on what module was built last
int nextSlot = SelectNextSlotToBuild();
if (nextSlot < 0)
{
Debug.LogError("Took too long choosing a random slot, didn't build anything. Try again.");
return;
}
NeighborState neighbors = CheckNeighborSlots(nextSlot);
BuildingModule firstModule = mModuleSet.GetModuleOfType(neighbors);
mSlots[nextSlot].GetComponent <BuildingSlot>().SetBuildingModule(firstModule);
mEmptySlots -= 1;
// add in little camera shake when building a new module
if (camShake)
{
camShake.ShakeCamera();
}
if (audio)
{
audio.Play();
}
// update neighbor state for all slots to adjust module types if needed
for (int i = 0; i < mSlots.Count; i++)
{
BuildingSlot slot = mSlots[i].GetComponent <BuildingSlot>();
// if this slot is still empty, don't care about its neighbors yet
if (slot.IsSlotEmpty())
{
continue;
}
NeighborState nState = CheckNeighborSlots(i);
// if this slot's neighbors haven't changed, no need to update
if (nState == slot.mModuleType)
{
continue;
}
if (slot.mModuleType != NeighborState.empty)
{
slot.mModuleType = nState;
BuildingModule module = mModuleSet.GetModuleOfType(slot.mModuleType);
if (slot.mIsDoor)
{
slot.SetBuildingModule(mModuleSet.mDoorModules[(int)slot.mModuleType]);
}
else
{
slot.SetBuildingModule(module);
}
}
}
}
public SelfResourceManager(BuildingModule module)
{
this.m_BuildingModule = module;
}
