public void CancelArmyUpgrade(BuildingIdentity laboratoryID)
{
BuildingLogicObject laboratory = this.m_Buildings[laboratoryID.buildingType][laboratoryID.buildingNO];
laboratory.CancelUpgradeArmy();
this.ReCalculateResource();
}
public void FinishBuildingUpgradeInstantly(BuildingIdentity id, int costGem)
{
this.FreeBuilder(id);
BuildingLogicObject building = this.m_Buildings[id.buildingType][id.buildingNO];
building.FinishUpgradeInstantly(costGem);
}
public void UpgradeArmy(ArmyType type, BuildingIdentity laboratoryID, int currentLevel)
{
BuildingLogicObject laboratory = this.m_Buildings[laboratoryID.buildingType][laboratoryID.buildingNO];
laboratory.UpgradeArmy(type, currentLevel);
this.ReCalculateResource();
}
public void ProduceArmy(ArmyIdentity armyID, BuildingIdentity factoryID)
{
BuildingLogicObject factory = this.m_Buildings[factoryID.buildingType][factoryID.buildingNO];
factory.ProduceArmy(armyID);
this.ReCalculateResource();
}
public void FinishBuildingUpgrade(BuildingIdentity id)
{
BuildingLogicObject building = this.m_Buildings[id.buildingType][id.buildingNO];
int oldArmyCapacity = building.BuildingLogicData.ArmyCapacity;
int oldItemCapacity = building.BuildingLogicData.StoreItemCapacity;
building.FinishUpgrade();
int newArmyCapacity = building.BuildingLogicData.ArmyCapacity;
int newItemCapacity = building.BuildingLogicData.StoreItemCapacity;
if (building.BuildingLogicData.BuildingType == BuildingType.Tavern &&
building.BuildingLogicData.Level != building.BuildingLogicData.InitialLevel)
{
building.ReloadNewMercenaryProduct(ConfigInterface.Instance.MercenaryConfigHelper.
GetAvailableMercenaries(building.BuildingLogicData.Level));
}
if (oldArmyCapacity != newArmyCapacity)
{
this.AssignArmies();
}
if (oldItemCapacity != newItemCapacity)
{
this.AssignItems();
}
}
private BuildingLogicObject ConstructBuildingLogicObject(BuildingData data)
{
BuildingLogicObject result = new BuildingLogicObject(data);
result.ArmyProduceFinished += FinishArmyProduced;
result.ItemProduceFinished += FinishItemProduced;
result.ArmyUpgradeFinished += FinishArmyUpgraded;
result.ItemUpgradeFinished += FinishItemUpgraded;
result.UpgradeTimeUp += (obj) => FreeBuilder(obj);
return(result);
}
public void FinishBuildingConstruct(BuildingIdentity id)
{
BuildingLogicObject building = this.m_Buildings[id.buildingType][id.buildingNO];
building.FinishUpgrade();
if (id.buildingType == BuildingType.BuilderHut)
{
this.m_BuilderManager.AddBuilder(id.buildingNO);
}
if (building.BuildingLogicData.CanStoreGold && building.BuildingLogicData.ProduceGoldEfficiency == 0)
{
this.m_ResourceManager.AddStorage(ResourceType.Gold, id,
building.BuildingLogicData.StoreGoldCapacity);
}
if (building.BuildingLogicData.CanStoreFood && building.BuildingLogicData.ProduceFoodEfficiency == 0)
{
this.m_ResourceManager.AddStorage(ResourceType.Food, id,
building.BuildingLogicData.StoreFoodCapacity);
}
if (building.BuildingLogicData.CanStoreOil && building.BuildingLogicData.ProduceOilEfficiency == 0)
{
this.m_ResourceManager.AddStorage(ResourceType.Oil, id,
building.BuildingLogicData.StoreOilCapacity);
}
this.ReCalculateResource();
if (building.BuildingLogicData.ArmyCapacity > 0)
{
this.m_ArmyCampManager.AddCamp(id);
this.AssignArmies();
}
if (building.BuildingLogicData.ArmyProduceCapacity > 0)
{
this.m_ArmyFactoryManager.AddFactory(id);
}
if (building.BuildingLogicData.StoreItemCapacity > 0)
{
this.AssignItems();
this.m_ItemCampManager.AddCamp(id);
}
if (building.BuildingLogicData.ItemProduceCapacity > 0)
{
this.m_ItemFactoryManager.AddFactory(id);
}
}
public void FinishArmyProduceInstantly(BuildingIdentity factoryID)
{
BuildingLogicObject factory = this.m_Buildings[factoryID.buildingType][factoryID.buildingNO];
List <BuildingIdentity> destinations = new List <BuildingIdentity>();
foreach (KeyValuePair <ArmyType, List <ArmyIdentity> > armies in factory.BuildingLogicData.ArmyProducts)
{
foreach (ArmyIdentity army in armies.Value)
{
BuildingIdentity? campID = this.m_ArmyCampManager.FindCamp(armies.Key);
BuildingLogicObject camp = this.m_Buildings[campID.Value.buildingType][campID.Value.buildingNO];
camp.AddArmyToCamp(army, factoryID);
destinations.Add(campID.Value);
LogicController.Instance.FinishArmyProduced(army.armyType);
}
}
factory.FinishProduceArmyInstantly(destinations);
}
public void FinishArmyUpgradeInstantly(BuildingIdentity laboratoryID)
{
BuildingLogicObject laboratory = this.m_Buildings[laboratoryID.buildingType][laboratoryID.buildingNO];
laboratory.FinishArmyUpgradeInstantly();
}
public void CancelArmyProduce(ArmyType type, BuildingIdentity factoryID)
{
BuildingLogicObject factory = this.m_Buildings[factoryID.buildingType][factoryID.buildingNO];
factory.CancelProduceArmy(type);
}
public void IntializeBuilding(List <BuildingData> buildings)
{
this.m_Buildings = new Dictionary <BuildingType, Dictionary <int, BuildingLogicObject> >();
List <int> alreadyWorkingBuilder = new List <int>();
List <BuildingIdentity> buildBuilding = new List <BuildingIdentity>();
foreach (BuildingData building in buildings)
{
if (!this.m_Buildings.ContainsKey(building.BuildingID.buildingType))
{
this.m_Buildings.Add(building.BuildingID.buildingType, new Dictionary <int, BuildingLogicObject>());
}
BuildingLogicObject buildingObject = this.ConstructBuildingLogicObject(building);
this.m_Buildings[building.BuildingID.buildingType].Add(building.BuildingID.buildingNO, buildingObject);
if (building.ConfigData.CanStoreArmy && building.Level > 0)
{
this.m_ArmyCampManager.AddCamp(building.BuildingID);
}
if (building.ConfigData.CanProduceArmy && building.Level > 0)
{
this.m_ArmyFactoryManager.AddFactory(building.BuildingID);
}
if (building.ConfigData.CanStoreItem && building.Level > 0)
{
this.m_ItemCampManager.AddCamp(building.BuildingID);
}
if (building.ConfigData.CanProduceItem && building.Level > 0)
{
this.m_ItemFactoryManager.AddFactory(building.BuildingID);
}
if (building.ConfigData.CanStoreGold && building.ConfigData.ProduceGoldEfficiency == 0 && building.Level > 0)
{
this.m_ResourceManager.AddStorage(ResourceType.Gold, building.BuildingID,
building.ConfigData.StoreGoldCapacity);
}
if (building.ConfigData.CanStoreFood && building.ConfigData.ProduceFoodEfficiency == 0 && building.Level > 0)
{
this.m_ResourceManager.AddStorage(ResourceType.Food, building.BuildingID,
building.ConfigData.StoreFoodCapacity);
}
if (building.ConfigData.CanStoreOil && building.ConfigData.ProduceOilEfficiency == 0 && building.Level > 0)
{
this.m_ResourceManager.AddStorage(ResourceType.Oil, building.BuildingID,
building.ConfigData.StoreOilCapacity);
}
if (building.BuildingID.buildingType == BuildingType.BuilderHut && !building.BuilderBuildingNO.HasValue)
{
this.m_BuilderManager.AddBuilder(building.BuildingID.buildingNO);
}
if (building.BuilderBuildingNO.HasValue)
{
alreadyWorkingBuilder.Add(building.BuilderBuildingNO.Value);
buildBuilding.Add(building.BuildingID);
}
/*
* if(building.AvailableArmy != null)
* {
* foreach (ArmyIdentity army in building.AvailableArmy)
* {
* BuildingSceneDirector.Instance.GenerateArmyInCamp(army.armyType,
* LogicController.Instance.GetArmyLevel(army.armyType), buildingObject.BuildingLogicData);
* }
* }
*/
}
for (int i = 0; i < alreadyWorkingBuilder.Count; i++)
{
int builderNO = alreadyWorkingBuilder[i];
BuildingIdentity buildingID = buildBuilding[i];
BuildingLogicData targetInfo = this.m_Buildings[buildingID.buildingType][buildingID.buildingNO].BuildingLogicData;
this.m_BuilderManager.AddBusyBuilder(builderNO, targetInfo);
}
this.m_ResourceManager.RecalculateStorage();
}
public BuildingLogicData(BuildingData data, BuildingLogicObject logicOject)
{
this.m_Data = data;
this.m_LogicObject = logicOject;
}
