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 CancelArmyUpgrade(BuildingIdentity laboratoryID)
{
BuildingLogicObject laboratory = this.m_Buildings[laboratoryID.buildingType][laboratoryID.buildingNO];
laboratory.CancelUpgradeArmy();
this.ReCalculateResource();
}
void OnClick()
{
//ArmyIdentity id = new ArmyIdentity(ArmyType.Berserker, 1);
BuildingIdentity id = new BuildingIdentity(BuildingType.Barracks, 0);
LogicController.Instance.CancelProduceArmy(ArmyType.Berserker, id);
}
public void ProduceArmy(ArmyIdentity armyID, BuildingIdentity factoryID)
{
BuildingLogicObject factory = this.m_Buildings[factoryID.buildingType][factoryID.buildingNO];
factory.ProduceArmy(armyID);
this.ReCalculateResource();
}
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 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();
}
}
public void FinishBuildingUpgradeInstantly(BuildingIdentity id, int costGem)
{
this.FreeBuilder(id);
BuildingLogicObject building = this.m_Buildings[id.buildingType][id.buildingNO];
building.FinishUpgradeInstantly(costGem);
}
protected virtual void Collect(BuildingIdentity id, ResourceType type, CollectMethod collectMethod = CollectMethod.Button)
{
if (SceneManager.Instance.SceneMode == SceneMode.SceneVisit || this.m_CurrentState != BuildingEditorState.Normal || !this.BuildingBehavior.CheckBuildingCreateStack())
{
return;
}
if (this.m_CurrentState == BuildingEditorState.Normal)
{
switch (collectMethod)
{
case CollectMethod.Building:
if (SystemFunction.CheckCollectValidity(this.BuildingLogicData, type) > 0)
{
SceneManager.Instance.CreateCollectFX(this.BuildingBehavior, type, LogicController.Instance.Collect(id, type), this.BuildingLogicData);
}
//this.CreateCollectFX(type, LogicController.Instance.Collect(id, type));
break;
case CollectMethod.Button:
if (SystemFunction.CheckCollectValidityByButton(this.BuildingLogicData, type))
{
SceneManager.Instance.CreateCollectFX(this.BuildingBehavior, type, LogicController.Instance.Collect(id, type), this.BuildingLogicData);
}
//this.CreateCollectFX(type, LogicController.Instance.Collect(id, type));
break;
}
}
}
public void FinishBuildingConstruct(BuildingIdentity id)
{
int initialLevel = ConfigInterface.Instance.BuildingConfigHelper.GetInitialLevel(id.buildingType);
BuildingConfigData configData = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(id.buildingType, initialLevel);
if (!configData.CanProduceGold)
{
this.m_PlayerModule.AddGoldCapacity(configData.StoreGoldCapacity);
}
if (!configData.CanProduceFood)
{
this.m_PlayerModule.AddFoodCapacity(configData.StoreFoodCapacity);
}
if (!configData.CanProduceOil)
{
this.m_PlayerModule.AddOilCapacity(configData.StoreOilCapacity);
}
if (configData.CanStoreProps)
{
this.m_PlayerModule.AddPropsCapacity(configData.StorePropsCapacity);
}
this.m_BuildingModule.FinishBuildingConstruct(id);
BuildingConfigData initialConfigData = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(id.buildingType, 0);
this.RewardResource(initialConfigData.UpgradeRewardGold, initialConfigData.UpgradeRewardFood, initialConfigData.UpgradeRewardOil, initialConfigData.UpgradeRewardGem, initialConfigData.UpgradeRewardExp);
this.m_TaskModule.OnConstructBuilding(id.buildingType);
}
public void AddResourceAccelerate(BuildingIdentity id)
{
int costGem = MarketCalculator.GetResourceAccelerateCostGem(id.buildingType, this.GetBuildingObject(id).Level);
this.m_PlayerModule.Consume(0, 0, 0, costGem);
this.m_BuildingModule.AddResourceAccelerate(id);
}
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 AddItemAccelerate(BuildingIdentity id)
{
int costGem = ConfigInterface.Instance.SystemConfig.ProduceItemAccelerateCostGem;
this.m_PlayerModule.Consume(0, 0, 0, costGem);
this.m_BuildingModule.AddItemAccelerate(id);
}
public Dictionary <ResourceType, Dictionary <BuildingIdentity, int> > CalculateStorage(int totalGold, int totalFood, int totalOil)
{
Dictionary <ResourceType, Dictionary <BuildingIdentity, int> > result = new Dictionary <ResourceType, Dictionary <BuildingIdentity, int> >();
Dictionary <ResourceType, int> total = new Dictionary <ResourceType, int>()
{
{ ResourceType.Gold, totalGold },
{ ResourceType.Food, totalFood },
{ ResourceType.Oil, totalOil }
};
foreach (KeyValuePair <ResourceType, List <BuildingIdentity> > storage in this.m_StorageDict)
{
result.Add(storage.Key, new Dictionary <BuildingIdentity, int>());
int sumValue = 0;
for (int i = 0; i < storage.Value.Count; i++)
{
BuildingIdentity id = storage.Value[i];
int newValue = 0;
if (i != storage.Value.Count - 1)
{
int capacity = this.m_CapacityDict[storage.Key][id];
float percentage = ((float)capacity) / this.m_MaxCapacity[storage.Key];
newValue = Mathf.FloorToInt(total[storage.Key] * percentage);
sumValue += newValue;
}
else
{
newValue = total[storage.Key] - sumValue;
}
result[storage.Key][id] = newValue;
}
}
return(result);
}
public void BuyWall()
{
BuildingIdentity buildingIdentity = LogicController.Instance.BuyWall(this.BuildingBehavior.FirstZoneIndex);
this.BuildingLogicData = LogicController.Instance.GetBuildingObject(buildingIdentity);
SceneManager.Instance.EnableCreateWallContinuation = true;
this.ConstructBuilding();
SceneManager.Instance.LastWallTilePosition = this.BuildingBehavior.FirstZoneIndex;
//if (this.BuildingLogicData.BuildingType == BuildingType.Wall)
// {
int upperLimitCount = ConfigInterface.Instance.BuildingNumberRestrictionsConfigHelper.GetBuildingNumberRestrictions(LogicController.Instance.CurrentCityHallLevel).RestrictionDict[this.BuildingLogicData.BuildingType];
int hasCount = LogicController.Instance.GetBuildingCount(this.BuildingLogicData.BuildingType);
if (hasCount < upperLimitCount)
{
int initialLevel = ConfigInterface.Instance.BuildingConfigHelper.GetInitialLevel(this.BuildingLogicData.BuildingType);
BuildingConfigData buildingConfigData = ConfigInterface.Instance.BuildingConfigHelper.GetBuildingData(this.BuildingLogicData.BuildingType, initialLevel);
SceneManager.Instance.ConstructBuilding(buildingConfigData, this.BuildingLogicData.BuildingType, false);
}
else
{
UIErrorMessage.Instance.ErrorMessage(2);
}
// }
}
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));
}
void OnClick()
{
BuildingIdentity id = new BuildingIdentity();
id.buildingType = ConfigUtilities.Enums.BuildingType.GoldMine;
id.buildingNO = 0;
//LogicController.Instance.Collect(id,ResourceType.Gold, 200);
}
private MercenaryData GenerateMercenaryData(MercenaryParameter param, BuildingIdentity campID)
{
MercenaryData mercenaryData = new MercenaryData();
mercenaryData.CampID = campID;
mercenaryData.ConfigData = ConfigInterface.Instance.MercenaryConfigHelper.GetMercenaryData(param.MercenaryType);
return(mercenaryData);
}
public void CancelUpgradeArmy(ArmyType type, BuildingIdentity laboratoryID)
{
int currentLevel = this.m_PlayerModule.Data.GetArmyLevel(type);
CostConfigData cost = ConfigInterface.Instance.ArmyConfigHelper.GetUpgradeCostData(type, currentLevel);
this.m_PlayerModule.Receive(cost.CostGold, cost.CostFood, cost.CostOil, cost.CostGem);
this.m_BuildingModule.CancelArmyUpgrade(laboratoryID);
}
public void FinishProduceArmyInstantly(BuildingIdentity factoryID)
{
int remainingTime = this.GetBuildingObject(factoryID).ArmyProductsRemainingTime;
int costGem = MarketCalculator.GetProduceTimeCost(remainingTime);
this.m_PlayerModule.Consume(0, 0, 0, costGem);
this.m_BuildingModule.FinishArmyProduceInstantly(factoryID);
}
public void CancelProduceArmy(ArmyType type, BuildingIdentity factoryID)
{
CostConfigData cost = ConfigInterface.Instance.ArmyConfigHelper.GetProduceCostData(type, this.PlayerData.GetArmyLevel(type));
this.m_PlayerModule.Receive(cost.CostGold, cost.CostFood, cost.CostOil, cost.CostGem);
this.m_BuildingModule.CancelArmyProduce(type, factoryID);
this.m_BuildingModule.ReCalculateResource();
}
public void OnClick()
{
BuildingIdentity id = new BuildingIdentity();
id.buildingType = ConfigUtilities.Enums.BuildingType.GoldMine;
id.buildingNO = 0;
LogicController.Instance.CancelBuildingConstruct(id);
Debug.Log("################################!");
}
public void SendUpgradeItemRequest(ItemType type, BuildingIdentity laboratoryID)
{
ItemUpgradeRequestParameter request = new ItemUpgradeRequestParameter();
request.ItemType = type;
request.LaboratoryBuildingType = laboratoryID.buildingType;
request.LaboratoryBuildingNO = laboratoryID.buildingNO;
CommunicationUtility.Instance.UpgradeItem(request);
}
public void SendCancelUpgradeBuildingRequest(BuildingIdentity id)
{
CancelBuildingRequestParameter request = new CancelBuildingRequestParameter();
request.BuildingType = id.buildingType;
request.BuildingNO = id.buildingNO;
request.OperateTick = LogicTimer.Instance.GetServerTick();
CommunicationUtility.Instance.CancelBuildingUpgrade(request);
}
public void SendUpgradeFinishRequest(BuildingIdentity id)
{
UpgradeBuildingSuccessRequestParameter request = new UpgradeBuildingSuccessRequestParameter();
request.BuildingType = id.buildingType;
request.BuildingNO = id.buildingNO;
request.OperateTick = LogicTimer.Instance.GetServerTick();
CommunicationUtility.Instance.FinishBuildingUpgrade(request);
}
public void UpgradeBuilding(BuildingIdentity id, int builderBuildingNO)
{
int builderLevel = this.m_Buildings[BuildingType.BuilderHut][builderBuildingNO].BuildingLogicData.Level;
float efficiency = ConfigInterface.Instance.BuilderConfigHelper.GetBuilderData(builderLevel).BuildEfficiency;
this.m_Buildings[id.buildingType][id.buildingNO].UpgradeBuilding(builderBuildingNO, efficiency);
this.m_BuilderManager.SendBuilder(builderBuildingNO, this.GetBuildingObject(id));
this.ReCalculateResource();
}
public void SendTimeUpUpgradeBuildingRequest(BuildingIdentity id, float remainingSecond)
{
UpgradeBuildingTimeUpRequestParameter request = new UpgradeBuildingTimeUpRequestParameter();
request.BuildingID = new BuildingIDParameter();
request.BuildingID.BuildingType = id.buildingType;
request.BuildingID.BuildingNO = id.buildingNO;
request.OperateTick = LogicTimer.Instance.GetServerTick(remainingSecond);
CommunicationUtility.Instance.TimeUpBuildingUpgrade(request);
}
public void SendMoveBuildingRequest(BuildingIdentity id, TilePosition newPosition)
{
MoveBuildingRequestParameter request = new MoveBuildingRequestParameter();
request.BuildingType = id.buildingType;
request.BuildingNO = id.buildingNO;
request.DestinationPositionRow = (byte)newPosition.Row;
request.DestinationPositionColumn = (byte)newPosition.Column;
CommunicationUtility.Instance.MoveBuilding(request);
}
public void SendFinishProduceItemRequest(ItemIdentity itemID, BuildingIdentity campID)
{
ItemProduceSuccessRequestParameter request = new ItemProduceSuccessRequestParameter();
request.ItemType = itemID.itemType;
request.ItemNO = itemID.itemNO;
request.OwnerBuildingType = campID.buildingType;
request.OwnerBuildingNO = campID.buildingNO;
CommunicationUtility.Instance.FinishProduceItem(request);
}
public BuildingIdentity ConstructBuilding(BuildingType type, int builderBuildingNO, TilePosition position)
{
this.ConsumeBuildingConstructResource(type);
BuildingIdentity result = this.m_BuildingModule.ConstructBuilding(type, builderBuildingNO, position);
return(result);
//return new BuildingIdentity(BuildingType.GoldMine, 0);
}
public void SendUpgradeBuildingRequest(BuildingIdentity id, int builderBuildingNO)
{
UpgradeBuildingRequestParameter request = new UpgradeBuildingRequestParameter();
request.BuildingType = id.buildingType;
request.BuildingNO = id.buildingNO;
request.BuilderBuildingNO = builderBuildingNO;
request.OperateTick = LogicTimer.Instance.GetServerTick();
CommunicationUtility.Instance.UpgradeBuilding(request);
}
