public void CancelBuildingUpgrade(BuildingIdentity id)
{
BuildingLogicData data = this.GetBuildingObject(id);
this.m_BuildingModule.CancelBuildingUpgrade(id);
this.ReturnResource(data.UpgradeGold, data.UpgradeFood, data.UpgradeOil, data.UpgradeGem);
}
public void FinishBuildingUpgrade(BuildingIdentity id)
{
BuildingLogicData building = this.m_BuildingModule.GetBuildingObject(id);
BuildingConfigData oldData = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(id.buildingType, building.Level);
BuildingConfigData newData = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(id.buildingType, building.Level + oldData.UpgradeStep);
if (!newData.CanProduceGold)
{
this.m_PlayerModule.AddGoldCapacity(newData.StoreGoldCapacity, oldData.StoreGoldCapacity);
}
if (!newData.CanProduceFood)
{
this.m_PlayerModule.AddFoodCapacity(newData.StoreFoodCapacity, oldData.StoreFoodCapacity);
}
if (!newData.CanProduceOil)
{
this.m_PlayerModule.AddOilCapacity(newData.StoreOilCapacity, oldData.StoreOilCapacity);
}
if (newData.CanStoreProps)
{
this.m_PlayerModule.AddPropsCapacity(newData.StorePropsCapacity, oldData.StorePropsCapacity);
}
this.m_BuildingModule.FinishBuildingUpgrade(id);
this.RewardResource(oldData.UpgradeRewardGold, oldData.UpgradeRewardFood, oldData.UpgradeRewardOil, oldData.UpgradeRewardGem,
oldData.UpgradeRewardExp);
this.TaskManager.OnUpgradeBuilding(id.buildingType, this.m_BuildingModule.GetBuildingObject(id).Level);
}
public void UpgradeBuilding(BuildingIdentity id, int builderBuildingNO)
{
BuildingLogicData data = this.GetBuildingObject(id);
this.ConsumeResource(data.UpgradeGold, data.UpgradeFood, data.UpgradeOil, data.UpgradeGem);
this.m_BuildingModule.UpgradeBuilding(id, builderBuildingNO);
//ActorDirector.Instance.SendBuilderToBuild(builderBuildingNO, this.GetBuildingObject(id));
}
public void RecalculateStorage()
{
this.m_MaxCapacity = new Dictionary <ResourceType, int>()
{
{ ResourceType.Gold, LogicController.Instance.PlayerData.GoldMaxCapacity },
{ ResourceType.Food, LogicController.Instance.PlayerData.FoodMaxCapacity },
{ ResourceType.Oil, LogicController.Instance.PlayerData.OilMaxCapacity }
};
this.m_CapacityDict = new Dictionary <ResourceType, Dictionary <BuildingIdentity, int> >()
{
{ ResourceType.Gold, new Dictionary <BuildingIdentity, int>() },
{ ResourceType.Food, new Dictionary <BuildingIdentity, int>() },
{ ResourceType.Oil, new Dictionary <BuildingIdentity, int>() }
};
foreach (KeyValuePair <ResourceType, List <BuildingIdentity> > storage in this.m_StorageDict)
{
foreach (BuildingIdentity id in storage.Value)
{
BuildingLogicData building = this.m_BuildingModule.GetBuildingObject(id);
int capacity = storage.Key == ResourceType.Gold ? building.StoreGoldCapacity :
storage.Key == ResourceType.Food ? building.StoreFoodCapacity : building.StoreOilCapacity;
this.m_CapacityDict[storage.Key][id] = capacity;
}
}
Dictionary <ResourceType, Dictionary <BuildingIdentity, int> > result = this.CalculateStorage(LogicController.Instance.PlayerData.CurrentStoreGold,
LogicController.Instance.PlayerData.CurrentStoreFood, LogicController.Instance.PlayerData.CurrentStoreOil);
foreach (KeyValuePair <ResourceType, Dictionary <BuildingIdentity, int> > storage in result)
{
foreach (KeyValuePair <BuildingIdentity, int> calculatedStorage in storage.Value)
{
BuildingLogicData building = this.m_BuildingModule.GetBuildingObject(calculatedStorage.Key);
int?newGold = null;
if (storage.Key == ResourceType.Gold)
{
newGold = calculatedStorage.Value;
}
int?newFood = null;
if (storage.Key == ResourceType.Food)
{
newFood = calculatedStorage.Value;
}
int?newOil = null;
if (storage.Key == ResourceType.Oil)
{
newOil = calculatedStorage.Value;
}
this.m_BuildingModule.ModifyResourceStoreage(building.BuildingIdentity, newGold, newFood, newOil);
}
}
}
public void FinishBuild()
{
BuildingLogicData logicData = LogicController.Instance.GetBuildingObject(
new BuildingIdentity(BuildingType.BuilderHut, this.BuilderNO));
TilePosition targetPosition = BorderPointHelper.FindValidInflateOneBorderPoint(logicData);
BuilderReturnState returnState = new BuilderReturnState(this.MapData, targetPosition, this, logicData);
this.ChangeState(returnState);
}
public void SendBuilder(int builderNO, IObstacleInfo targetInfo)
{
BuildingLogicData builderHutData = LogicController.Instance.GetBuildingObject(
new BuildingIdentity(ConfigUtilities.Enums.BuildingType.BuilderHut, builderNO));
int builderLevel = builderHutData.Level;
BuildingSceneDirector.Instance.SendBuilderToBuild(builderNO, builderLevel, builderHutData.BuildingPosition,
targetInfo, SceneManager.Instance);
this.AddBusyBuilder(builderNO, targetInfo);
}
public Nullable <bool> FindNeighourWallNotNull(BuildingObstacleDirection wallDirection, int index)
{
TilePosition tilePosition = null;
BuildingLogicData buildingLogicData = null;
switch (wallDirection)
{
case BuildingObstacleDirection.Top:
tilePosition = new TilePosition(this.BuildingLogicData.BuildingPosition.Column, this.BuildingLogicData.BuildingPosition.Row + index);
break;
case BuildingObstacleDirection.Bottom:
tilePosition = new TilePosition(this.BuildingLogicData.BuildingPosition.Column, this.BuildingLogicData.BuildingPosition.Row - index);
break;
case BuildingObstacleDirection.Left:
tilePosition = new TilePosition(this.BuildingLogicData.BuildingPosition.Column - index, this.BuildingLogicData.BuildingPosition.Row);
break;
case BuildingObstacleDirection.Right:
tilePosition = new TilePosition(this.BuildingLogicData.BuildingPosition.Column + index, this.BuildingLogicData.BuildingPosition.Row);
break;
}
IObstacleInfo obstacleInfo = SceneManager.Instance.GetBuildingInfoFormBuildingObstacleMap(tilePosition.Row, tilePosition.Column);
if (obstacleInfo == null)
{
return(null);
}
else
{
buildingLogicData = obstacleInfo as BuildingLogicData;
if (buildingLogicData != null)
{
if (buildingLogicData.BuildingIdentity.buildingType == BuildingType.Wall)
{
return(true);
}
else
{
return(null);
}
}
return(null);
}
}
protected override void Initialize()
{
this.m_MapData = SceneManager.Instance;
this.m_SceneHelper = this.GetComponent <BuildingSceneHelper>();
List <BuildingLogicData> buildings = LogicController.Instance.AllBuildings;
List <RemovableObjectLogicData> objects = LogicController.Instance.AllRemovableObjects;
foreach (RemovableObjectLogicData removableObject in objects)
{
if (removableObject.CurrentAttachedBuilderNO >= 0)
{
int builderNO = removableObject.CurrentAttachedBuilderNO;
int builderLevel = LogicController.Instance.GetBuildingObject
(new BuildingIdentity(BuildingType.BuilderHut, builderNO)).Level;
this.SendBuilderBuild(builderNO, builderLevel, removableObject, this.m_MapData);
}
}
foreach (BuildingLogicData building in buildings)
{
ArmyIdentity[] armies = building.Armies;
if (armies != null)
{
foreach (ArmyIdentity army in armies)
{
this.GenerateArmyInCamp(army.armyType, LogicController.Instance.GetArmyLevel(army.armyType), building);
}
}
MercenaryIdentity[] mercenaries = building.Mercenaries;
if (mercenaries != null)
{
foreach (MercenaryIdentity mercenary in mercenaries)
{
BuildingIdentity campID = LogicController.Instance.GetMercenaryData(mercenary).CampID;
BuildingLogicData camp = LogicController.Instance.GetBuildingObject(campID);
this.GenerateMercenaryInCamp(mercenary.mercenaryType, camp);
}
}
int builderNO = building.CurrentAttachedBuilderNO;
if (builderNO >= 0)
{
int builderLevel = LogicController.Instance.GetBuildingObject
(new BuildingIdentity(BuildingType.BuilderHut, builderNO)).Level;
this.SendBuilderBuild(building.CurrentAttachedBuilderNO, builderLevel, building, this.m_MapData);
}
}
}
protected override Nullable <ArmyIdentity> GetFinishedHeadProduct(BuildingIdentity id)
{
BuildingLogicData factory = LogicController.Instance.GetBuildingObject(id);
if (factory.ArmyProducts == null || factory.ArmyProducts.Count == 0)
{
return(null);
}
ArmyLogicData army = LogicController.Instance.GetArmyObjectData(factory.ArmyProducts[0].Value[0]);
if (!army.LogicProduceRemainingWorkload.IsZero())
{
return(null);
}
return(army.Identity);
}
protected override Nullable <ItemIdentity> GetFinishedHeadProduct(BuildingIdentity id)
{
BuildingLogicData factory = LogicController.Instance.GetBuildingObject(id);
if (factory.ItemProducts == null)
{
return(null);
}
ItemLogicObject item = LogicController.Instance.GetItemObject(factory.ItemProducts[0].Value[0]);
if (!item.LogicProduceRemainingWorkload.IsZero())
{
return(null);
}
return(item.Identity);
}
public void BuyUpgradeWall(int wallNO)
{
BuildingIdentity id = new BuildingIdentity(BuildingType.Wall, wallNO);
BuildingLogicData buildingData = this.GetBuildingObject(id);
RewardConfigData rewardData = new RewardConfigData()
{
RewardGold = buildingData.UpgradeRewardGold,
RewardFood = buildingData.UpgradeRewardFood, RewardOil = buildingData.UpgradeRewardOil,
RewardGem = buildingData.UpgradeRewardGem, RewardExp = buildingData.UpgradeRewardExp
};
this.ConsumeResource(buildingData.UpgradeGold, buildingData.UpgradeFood, buildingData.UpgradeOil, buildingData.UpgradeGem);
this.m_BuildingModule.BuyWallUpgrade(wallNO);
this.m_ShopModule.BuyWallUpgrade(wallNO);
this.RewardResource(rewardData.RewardGold, rewardData.RewardFood, rewardData.RewardOil, rewardData.RewardGem, rewardData.RewardExp);
this.m_TaskModule.OnUpgradeBuilding(BuildingType.Wall, buildingData.Level);
}
public void FinishUpgradeArmyInstantly(BuildingIdentity laboratoryID)
{
BuildingLogicData data = this.GetBuildingObject(laboratoryID);
if (data.ArmyUpgrade.HasValue)
{
ArmyType armyType = data.ArmyUpgrade.Value;
int remainingTime = data.ArmyUpgradeRemainingTime;
int costGem = MarketCalculator.GetUpdateTimeCost(remainingTime);
this.m_PlayerModule.Consume(0, 0, 0, costGem);
this.m_BuildingModule.FinishArmyUpgradeInstantly(laboratoryID);
this.m_ArmyModule.FinishUpgrade(armyType);
this.m_PlayerModule.UpgradeArmy(armyType);
this.m_TaskModule.OnUpgradeArmy(armyType, this.m_PlayerModule.Data.GetArmyLevel(armyType));
}
}
public BuildingIdentity?FindCamp(T type)
{
int capacityCost = this.GetCapacityCost(type);
if (capacityCost + this.CampsTotalAlreadyCapacity > this.CampsTotalCapacity)
{
return(null);
}
foreach (BuildingIdentity id in this.m_Camps)
{
BuildingLogicData building = LogicController.Instance.GetBuildingObject(id);
if (this.GetAlreadyCapacity(building) < this.GetTotalCapacity(building))
{
return(id);
}
}
return(null);
}
public BuildingIdentity?FindMercenaryCamp(MercenaryType type)
{
int capacityCost = ConfigInterface.Instance.MercenaryConfigHelper.GetMercenaryData(type).CapcityCost;
if (capacityCost + this.CampsTotalAlreadyCapacity > this.CampsTotalCapacity)
{
return(null);
}
foreach (BuildingIdentity id in this.m_Camps)
{
BuildingLogicData building = LogicController.Instance.GetBuildingObject(id);
if (this.GetAlreadyCapacity(building) < this.GetTotalCapacity(building))
{
return(id);
}
}
return(null);
}
public void FinishBuildingUpgradeInstantly(BuildingIdentity id)
{
BuildingLogicData data = this.GetBuildingObject(id);
if (data.AttachedBuilderEfficiency > 0)
{
int remainingTime = Mathf.CeilToInt(data.UpgradeRemainingWorkload / data.AttachedBuilderEfficiency);
int costGem = MarketCalculator.GetUpdateTimeCost(remainingTime);
this.m_PlayerModule.Consume(0, 0, 0, costGem);
this.m_BuildingModule.FinishBuildingUpgradeInstantly(id, costGem);
if (data.Level == 0)
{
this.FinishBuildingConstruct(id);
}
else
{
this.FinishBuildingUpgrade(id);
}
}
}
protected abstract int GetTotalCapacity(BuildingLogicData building);
protected override int GetTotalCapacity(BuildingLogicData building)
{
return(building.ItemProduceCapacity);
}
protected override int GetAlreadyCapacity(BuildingLogicData building)
{
return(building.AlreadyProduceItemCapacity);
}
private void FreeBuilder(BuildingIdentity id)
{
BuildingLogicData building = this.m_Buildings[id.buildingType][id.buildingNO].BuildingLogicData;
this.m_BuilderManager.RecycleBuilder(building.CurrentAttachedBuilderNO);
}
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();
}
protected abstract int GetAlreadyCapacity(BuildingLogicData building);
protected override int GetTotalCapacity(BuildingLogicData building)
{
return(building.ArmyCapacity);
}
public BuildingLogicObject(BuildingData data, int functionMask, bool isNeedCommunicate)
{
this.m_CommunicationHelper = isNeedCommunicate ?
new BuildingObjectCommunicationHelper() : null;
this.m_Data = data;
this.m_BuildingLogicData = new BuildingLogicData(data, this);
if (data.AvailableArmy != null && (functionMask & ((int)BuildingFunction.StoreArmy)) != 0)
{
foreach (ArmyIdentity army in data.AvailableArmy)
{
this.m_AlreadyArmyCapacity += LogicController.Instance.GetArmyObjectData(army).CapacityCost;
}
}
if (data.AvailableMercenary != null && (functionMask & ((int)BuildingFunction.StoreArmy)) != 0)
{
foreach (MercenaryIdentity mercenary in data.AvailableMercenary)
{
this.m_AlreadyArmyCapacity += LogicController.Instance.GetMercenaryData(mercenary).CapacityCost;
}
}
if (data.ProduceArmy != null && (functionMask & ((int)BuildingFunction.ProduceArmy)) != 0)
{
foreach (KeyValuePair <ArmyType, List <ArmyIdentity> > product in data.ProduceArmy)
{
foreach (ArmyIdentity id in product.Value)
{
this.m_AlreadyProduceArmyCapacity += LogicController.Instance.GetArmyObjectData(id).CapacityCost;
}
}
}
if (data.AvailableItem != null && (functionMask & ((int)BuildingFunction.StoreItem)) != 0)
{
this.m_AlreadyItemCapacity = data.AvailableItem.Count;
}
if (data.ProduceItem != null && (functionMask & ((int)BuildingFunction.ProduceItem)) != 0)
{
foreach (KeyValuePair <ItemType, List <ItemIdentity> > product in data.ProduceItem)
{
this.m_AlreadyProduceArmyCapacity += product.Value.Count;
}
}
if ((functionMask & ((int)BuildingFunction.Update)) != 0)
{
BuildingUpgradeLogicComponent upgradeComponent = new BuildingUpgradeLogicComponent();
this.InitialComponent(upgradeComponent);
upgradeComponent.UpgradeTimeUp += this.BuildingUpgradeTimeUp;
}
this.AddComponentAccordingToConfigData(data.ConfigData, functionMask);
if (data.RemainResourceAccelerateTime.HasValue && (functionMask & ((int)BuildingFunction.AccelerateResource)) != 0)
{
this.AddResourceAccelerateWithoutCommunication();
}
if (data.RemainArmyAccelerateTime.HasValue && (functionMask & ((int)BuildingFunction.AccelerateArmy)) != 0)
{
this.AddArmyAccelerateWithoutCommunication();
}
if (data.RemainItemAccelerateTime.HasValue && (functionMask & ((int)BuildingFunction.AccelerateItem)) != 0)
{
this.AddItemAccelerateWithoutCommunication();
}
}
