public override int Execute(LogicLevel level)
{
LogicGameObject gameObject = level.GetGameObjectManager().GetGameObjectByID(this.m_gameObjectId);
if (gameObject != null)
{
if (gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
LogicBuilding building = (LogicBuilding)gameObject;
if (!LogicDataTables.GetGlobals().AllowCancelBuildingConstruction() &&
building.GetUpgradeLevel() == 0 &&
building.IsConstructing())
{
if (!building.IsUpgrading())
{
return(-2);
}
}
if (building.IsConstructing())
{
building.GetListener().CancelNotification();
building.CancelConstruction();
return(0);
}
}
else if (gameObject.GetGameObjectType() == LogicGameObjectType.OBSTACLE)
{
LogicObstacle obstacle = (LogicObstacle)gameObject;
if (obstacle.IsClearingOnGoing())
{
LogicObstacleData data = obstacle.GetObstacleData();
LogicClientAvatar playerAvatar = level.GetPlayerAvatar();
playerAvatar.CommodityCountChangeHelper(0, data.GetClearResourceData(), data.GetClearCost());
obstacle.CancelClearing();
return(0);
}
}
else if (gameObject.GetGameObjectType() == LogicGameObjectType.TRAP)
{
LogicTrap trap = (LogicTrap)gameObject;
if (trap.IsConstructing())
{
trap.GetListener().CancelNotification();
trap.CancelConstruction();
return(0);
}
}
}
return(-1);
}
public bool FinishTaskOfOneWorker()
{
LogicGameObject gameObject = this.GetShortestTaskGO();
if (gameObject != null)
{
switch (gameObject.GetGameObjectType())
{
case LogicGameObjectType.BUILDING:
LogicBuilding building = (LogicBuilding)gameObject;
if (building.IsConstructing())
{
return(building.SpeedUpConstruction());
}
if (building.GetHeroBaseComponent() != null)
{
return(building.GetHeroBaseComponent().SpeedUp());
}
break;
case LogicGameObjectType.OBSTACLE:
LogicObstacle obstacle = (LogicObstacle)gameObject;
if (obstacle.IsClearingOnGoing())
{
return(obstacle.SpeedUpClearing());
}
break;
case LogicGameObjectType.TRAP:
LogicTrap trap = (LogicTrap)gameObject;
if (trap.IsConstructing())
{
return(trap.SpeedUpConstruction());
}
break;
case LogicGameObjectType.VILLAGE_OBJECT:
LogicVillageObject villageObject = (LogicVillageObject)gameObject;
if (villageObject.IsConstructing())
{
return(villageObject.SpeedUpCostruction());
}
break;
}
}
return(false);
}
public override int Execute(LogicLevel level)
{
LogicClientAvatar playerAvatar = level.GetPlayerAvatar();
LogicGameObjectManager gameObjectManager = level.GetGameObjectManager();
LogicResourceData repairResourceData = null;
int repairCost = 0;
for (int i = 0; i < this.m_gameObjectIds.Size(); i++)
{
LogicGameObject gameObject = gameObjectManager.GetGameObjectByID(this.m_gameObjectIds[i]);
if (gameObject != null && gameObject.GetGameObjectType() == LogicGameObjectType.TRAP)
{
LogicTrap trap = (LogicTrap)gameObject;
if (trap.IsDisarmed() && !trap.IsConstructing())
{
LogicTrapData data = trap.GetTrapData();
repairResourceData = data.GetBuildResource();
repairCost += data.GetRearmCost(trap.GetUpgradeLevel());
}
}
}
if (repairResourceData != null && repairCost != 0)
{
if (playerAvatar.HasEnoughResources(repairResourceData, repairCost, true, this, false))
{
playerAvatar.CommodityCountChangeHelper(0, repairResourceData, -repairCost);
for (int i = 0; i < this.m_gameObjectIds.Size(); i++)
{
LogicGameObject gameObject = gameObjectManager.GetGameObjectByID(this.m_gameObjectIds[i]);
if (gameObject != null && gameObject.GetGameObjectType() == LogicGameObjectType.TRAP)
{
LogicTrap trap = (LogicTrap)gameObject;
if (trap.IsDisarmed() && !trap.IsConstructing())
{
trap.RepairTrap();
}
}
}
return(0);
}
return(-2);
}
return(-1);
}
public override int Execute(LogicLevel level)
{
LogicGameObject gameObject = level.GetGameObjectManager().GetGameObjectByID(this.m_gameObjectId);
if (gameObject != null)
{
if (gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
LogicBuilding building = (LogicBuilding)gameObject;
LogicBuildingData buildingData = building.GetBuildingData();
if (buildingData.GetGearUpBuildingData() == null || building.GetGearLevel() != 0)
{
if (building.GetAttackerItemData().HasAlternativeAttackMode())
{
LogicCombatComponent combatComponent = building.GetCombatComponent(false);
if (combatComponent != null)
{
combatComponent.ToggleAttackMode(this.m_layout, this.m_draftMode);
if (this.m_updateListener)
{
}
return(0);
}
}
return(-1);
}
return(-95);
}
if (gameObject.GetGameObjectType() == LogicGameObjectType.TRAP)
{
LogicTrap trap = (LogicTrap)gameObject;
if (trap.HasAirMode())
{
trap.ToggleAirMode(this.m_layout, this.m_draftMode);
if (this.m_updateListener)
{
}
return(0);
}
}
}
return(-1);
}
public override int Execute(LogicLevel level)
{
LogicGameObject gameObject = level.GetGameObjectManager().GetGameObjectByID(this.m_gameObjectId);
if (gameObject != null)
{
if (gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
LogicBuilding building = (LogicBuilding)gameObject;
LogicBuildingData buildingData = building.GetBuildingData();
LogicCombatComponent combatComponent = building.GetCombatComponent(false);
if (combatComponent != null && combatComponent.GetAttackerItemData().GetTargetingConeAngle() != 0)
{
if (this.m_baseLayout == -1)
{
combatComponent.ToggleAimAngle(buildingData.GetAimRotateStep(), this.m_layout, this.m_draftLayout);
}
else
{
int draftAngle = combatComponent.GetAimAngle(this.m_baseLayout, this.m_baseDraftLayout);
int currentAngle = combatComponent.GetAimAngle(this.m_layout, this.m_draftLayout);
combatComponent.ToggleAimAngle(draftAngle - currentAngle, this.m_layout, this.m_draftLayout);
}
return(0);
}
}
else if (gameObject.GetGameObjectType() == LogicGameObjectType.TRAP)
{
LogicTrap trap = (LogicTrap)gameObject;
if (trap.GetTrapData().GetDirectionCount() > 0)
{
if (this.m_baseLayout == -1)
{
trap.ToggleDirection(this.m_layout, this.m_draftLayout);
}
else
{
trap.SetDirection(this.m_layout, this.m_draftLayout, trap.GetDirection(this.m_baseLayout, this.m_baseDraftLayout));
}
return(0);
}
return(-21);
}
}
return(-1);
}
/// <summary>
/// Finishes the task of one worker.
/// </summary>
public bool FinishTaskOfOneWorker()
{
LogicGameObject gameObject = this.GetShortestTaskGO();
if (gameObject != null)
{
switch (gameObject.GetGameObjectType())
{
case 0:
LogicBuilding building = (LogicBuilding)gameObject;
if (building.IsConstructing())
{
return(building.SpeedUpConstruction());
}
if (building.GetHeroBaseComponent() != null)
{
// TODO: Implement LogicHeroBaseComponent::speedUpUpgrade.
}
break;
case 3:
LogicObstacle obstacle = (LogicObstacle)gameObject;
if (obstacle.IsClearingOnGoing())
{
return(obstacle.SpeedUpClearing());
}
break;
case 4:
LogicTrap trap = (LogicTrap)gameObject;
if (trap.IsConstructing())
{
return(trap.SpeedUpConstruction());
}
break;
case 8:
LogicVillageObject villageObject = (LogicVillageObject)gameObject;
break;
}
}
return(false);
}
public override int Execute(LogicLevel level)
{
if (level != null)
{
LogicGameObject gameObject;
if (level.GetState() == 5)
{
gameObject = LogicGameObjectFactory.CreateGameObject(this.m_data, level, level.GetVillageType());
gameObject.Load(this.m_json);
level.GetGameObjectManager().AddGameObject(gameObject, -1);
}
else
{
gameObject = level.GetGameObjectManager().GetGameObjectByID(this.m_id);
}
if (gameObject != null)
{
if (gameObject.GetGameObjectType() == LogicGameObjectType.TRAP)
{
LogicTrap trap = (LogicTrap)gameObject;
LogicGameObjectManagerListener listener = level.GetGameObjectManager().GetListener();
listener.AddGameObject(gameObject);
gameObject.LoadingFinished();
gameObject.GetListener().RefreshState();
LogicTriggerComponent triggerComponent = trap.GetTriggerComponent();
if (triggerComponent != null)
{
triggerComponent.SetTriggered();
}
}
return(0);
}
Debugger.Warning("PGO == NULL in LogicTriggerComponentTriggeredCommand");
return(-2);
}
return(-1);
}
public static float GetDefenseStrength(LogicArrayList <LogicGameObject> buildings, LogicArrayList <LogicGameObject> traps, LogicArrayList <LogicHeroData> heroes,
int[] heroUpgLevel)
{
float heroStrength = 0f;
float buildingStrength = 0f;
float trapStrength = 0;
for (int i = 0; i < heroes.Size(); i++)
{
heroStrength += LogicStrengthUtil.GetHeroStrength(heroes[i], heroUpgLevel[i], true);
}
for (int i = 0; i < buildings.Size(); i++)
{
LogicBuilding building = (LogicBuilding)buildings[i];
if (!building.IsLocked())
{
if (!building.IsConstructing() || building.IsUpgrading())
{
buildingStrength += LogicStrengthUtil.GetBuildingStrength(building.GetBuildingData(), building.GetUpgradeLevel());
}
}
}
for (int i = 0; i < traps.Size(); i++)
{
LogicTrap trap = (LogicTrap)traps[i];
if (!trap.IsConstructing() || trap.IsUpgrading())
{
trapStrength += LogicStrengthUtil.GetTrapStrength(trap.GetTrapData(), trap.GetUpgradeLevel());
}
}
return(buildingStrength + trapStrength + heroStrength);
}
/// <summary>
/// Executes this command.
/// </summary>
public override int Execute(LogicLevel level)
{
if (this._trapData != null)
{
if (this._trapData.GetVillageType() == level.GetVillageType())
{
if (level.IsValidPlaceForBuilding(this._x, this._y, this._trapData.GetWidth(), this._trapData.GetHeight(), null))
{
LogicClientAvatar playerAvatar = level.GetPlayerAvatar();
LogicResourceData buildResourceData = this._trapData.GetBuildResource();
int buildCost = this._trapData.GetBuildCost(0);
if (playerAvatar.HasEnoughResources(buildResourceData, buildCost, true, this, false) && !level.IsTrapCapReached(this._trapData, true))
{
if (buildResourceData.PremiumCurrency)
{
playerAvatar.UseDiamonds(buildCost);
}
else
{
playerAvatar.CommodityCountChangeHelper(0, buildResourceData, -buildCost);
}
LogicTrap trap = (LogicTrap)LogicGameObjectFactory.CreateGameObject(this._trapData, level, level.GetVillageType());
if (this._trapData.GetBuildTime(0) == 0)
{
trap.FinishConstruction(false);
}
trap.SetInitialPosition(this._x << 9, this._y << 9);
level.GetGameObjectManager().AddGameObject(trap, -1);
if (level.IsTrapCapReached(this._trapData, false))
{
level.GetGameListener().TrapCapReached(this._trapData);
}
if (trap.GetVillageType() != 0)
{
int x = trap.GetTileX();
int y = trap.GetTileY();
int width = trap.GetWidthInTiles();
int height = trap.GetHeightInTiles();
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
LogicObstacle tallGrass = level.GetTileMap().GetTile(x + i, y + j).GetTallGrass();
if (tallGrass != null)
{
level.GetGameObjectManager().RemoveGameObject(tallGrass);
}
}
}
}
return(0);
}
}
return(-1);
}
return(-32);
}
return(-1);
}
/// <summary>
/// Gets the shortest task.
/// </summary>
public LogicGameObject GetShortestTaskGO()
{
LogicGameObject gameObject = null;
for (int i = 0, minRemaining = -1, tmpRemaining = 0; i < this._constructions.Count; i++, tmpRemaining = 0)
{
LogicGameObject tmp = this._constructions[i];
switch (this._constructions[i].GetGameObjectType())
{
case 0:
LogicBuilding building = (LogicBuilding)tmp;
if (building.IsConstructing())
{
tmpRemaining = building.GetRemainingConstructionTime();
}
else
{
LogicHeroBaseComponent heroBaseComponent = building.GetHeroBaseComponent();
if (heroBaseComponent == null)
{
Debugger.Warning("LogicWorkerManager - Worker allocated to altar/herobase without hero upgrading");
}
else
{
if (heroBaseComponent.IsUpgrading())
{
tmpRemaining = heroBaseComponent.GetRemainingUpgradeSeconds();
}
else
{
Debugger.Warning("LogicWorkerManager - Worker allocated to building with remaining construction time 0");
}
}
}
break;
case 3:
LogicObstacle obstacle = (LogicObstacle)tmp;
if (obstacle.IsClearingOnGoing())
{
tmpRemaining = obstacle.GetRemainingClearingTime();
}
else
{
Debugger.Warning("LogicWorkerManager - Worker allocated to obstacle with remaining clearing time 0");
}
break;
case 4:
LogicTrap trap = (LogicTrap)tmp;
if (trap.IsConstructing())
{
tmpRemaining = trap.GetRemainingConstructionTime();
}
else
{
Debugger.Warning("LogicWorkerManager - Worker allocated to trap with remaining construction time 0");
}
break;
case 8:
break;
}
if (gameObject == null || minRemaining > tmpRemaining)
{
gameObject = tmp;
minRemaining = tmpRemaining;
}
}
return(gameObject);
}
public override int Execute(LogicLevel level)
{
if (this.m_inputLayoutId != 6)
{
if (this.m_outputLayoutId != 6)
{
if (this.m_inputLayoutId != 7)
{
if (this.m_outputLayoutId != 7)
{
int townHallLevel = level.GetTownHallLevel(level.GetVillageType());
if (townHallLevel >= level.GetRequiredTownHallLevelForLayout(this.m_inputLayoutId, -1) &&
townHallLevel >= level.GetRequiredTownHallLevelForLayout(this.m_outputLayoutId, -1))
{
LogicGameObjectFilter filter = new LogicGameObjectFilter();
LogicArrayList <LogicGameObject> gameObjects = new LogicArrayList <LogicGameObject>(500);
filter.AddGameObjectType(LogicGameObjectType.BUILDING);
filter.AddGameObjectType(LogicGameObjectType.TRAP);
filter.AddGameObjectType(LogicGameObjectType.DECO);
level.GetGameObjectManager().GetGameObjects(gameObjects, filter);
if (this.m_outputLayoutId == level.GetActiveLayout())
{
LogicMoveMultipleBuildingsCommand moveMultipleBuildingsCommand = new LogicMoveMultipleBuildingsCommand();
for (int i = 0; i < gameObjects.Size(); i++)
{
LogicGameObject gameObject = gameObjects[i];
LogicVector2 position = gameObject.GetPositionLayout(this.m_inputLayoutId, false);
moveMultipleBuildingsCommand.AddNewMove(gameObject.GetGlobalID(), position.m_x, position.m_y);
}
int result = moveMultipleBuildingsCommand.Execute(level);
moveMultipleBuildingsCommand.Destruct();
if (result != 0)
{
filter.Destruct();
return(-2);
}
}
for (int i = 0; i < gameObjects.Size(); i++)
{
LogicGameObject gameObject = gameObjects[i];
LogicVector2 layoutPosition = gameObject.GetPositionLayout(this.m_inputLayoutId, false);
LogicVector2 editModePosition = gameObject.GetPositionLayout(this.m_inputLayoutId, true);
gameObject.SetPositionLayoutXY(layoutPosition.m_x, layoutPosition.m_y, this.m_outputLayoutId, false);
gameObject.SetPositionLayoutXY(editModePosition.m_x, editModePosition.m_y, this.m_outputLayoutId, true);
if (gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
LogicCombatComponent combatComponent = gameObject.GetCombatComponent(false);
if (combatComponent != null)
{
if (combatComponent.HasAltAttackMode())
{
if (combatComponent.UseAltAttackMode(this.m_inputLayoutId, false) ^ combatComponent.UseAltAttackMode(this.m_outputLayoutId, false))
{
combatComponent.ToggleAttackMode(this.m_outputLayoutId, false);
}
if (combatComponent.UseAltAttackMode(this.m_inputLayoutId, true) ^ combatComponent.UseAltAttackMode(this.m_outputLayoutId, true))
{
combatComponent.ToggleAttackMode(this.m_outputLayoutId, true);
}
}
if (combatComponent.GetAttackerItemData().GetTargetingConeAngle() != 0)
{
int aimAngle1 = combatComponent.GetAimAngle(this.m_inputLayoutId, false);
int aimAngle2 = combatComponent.GetAimAngle(this.m_outputLayoutId, false);
if (aimAngle1 != aimAngle2)
{
combatComponent.ToggleAimAngle(aimAngle1 - aimAngle2, this.m_outputLayoutId, false);
}
}
}
}
else if (gameObject.GetGameObjectType() == LogicGameObjectType.TRAP)
{
LogicTrap trap = (LogicTrap)gameObject;
if (trap.HasAirMode())
{
if (trap.IsAirMode(this.m_inputLayoutId, false) ^ trap.IsAirMode(this.m_outputLayoutId, false))
{
trap.ToggleAirMode(this.m_outputLayoutId, false);
}
if (trap.IsAirMode(this.m_inputLayoutId, true) ^ trap.IsAirMode(this.m_outputLayoutId, true))
{
trap.ToggleAirMode(this.m_outputLayoutId, true);
}
}
}
}
filter.Destruct();
level.SetLayoutState(this.m_outputLayoutId, level.GetVillageType(), level.GetLayoutState(this.m_inputLayoutId, level.GetVillageType()));
LogicAvatar homeOwnerAvatar = level.GetHomeOwnerAvatar();
if (homeOwnerAvatar.GetTownHallLevel() >= LogicDataTables.GetGlobals().GetChallengeBaseCooldownEnabledTownHall())
{
level.SetLayoutCooldownSecs(this.m_outputLayoutId, level.GetLayoutCooldown(this.m_inputLayoutId) / 15);
}
return(0);
}
return(-1);
}
return(-8);
}
return(-7);
}
return(-6);
}
return(-5);
}
/// <summary>
/// Executes this command.
/// </summary>
public override int Execute(LogicLevel level)
{
LogicGameObject gameObject = level.GetGameObjectManager().GetGameObjectByID(this._gameObjectId);
if (gameObject != null)
{
if (gameObject.GetGameObjectType() == 0)
{
LogicBuilding building = (LogicBuilding)gameObject;
LogicBuildingData buildingData = building.GetBuildingData();
if (buildingData.IsTownHallVillage2())
{
if (!this.UnlockVillage2())
{
return(-76);
}
}
if (buildingData.GetVillageType() == level.GetVillageType())
{
if (building.GetWallIndex() == 0)
{
if (building.CanUpgrade(true))
{
int nextUpgradeLevel = building.GetUpgradeLevel() + 1;
int buildCost = buildingData.GetBuildCost(nextUpgradeLevel, level);
LogicResourceData buildResourceData = this._useAltResources ? buildingData.GetAltBuildResource(nextUpgradeLevel) : buildingData.GetBuildResource(nextUpgradeLevel);
if (buildResourceData != null)
{
LogicClientAvatar playerAvatar = level.GetPlayerAvatar();
if (playerAvatar.HasEnoughResources(buildResourceData, buildCost, true, this, false))
{
int constructionTime = buildingData.GetConstructionTime(nextUpgradeLevel, level, 0);
if (constructionTime != 0 || LogicDataTables.GetGlobals().WorkerForZeroBuilTime())
{
if (!level.HasFreeWorkers(this, -1))
{
return(-1);
}
}
playerAvatar.CommodityCountChangeHelper(0, buildResourceData, -buildCost);
building.StartUpgrading(true, false);
return(0);
}
}
}
return(-1);
}
return(-35);
}
return(-32);
}
else if (gameObject.GetGameObjectType() == 4)
{
LogicTrap trap = (LogicTrap)gameObject;
if (trap.CanUpgrade(true))
{
LogicTrapData data = trap.GetTrapData();
LogicResourceData buildResourceData = data.GetBuildResource();
LogicClientAvatar playerAvatar = level.GetPlayerAvatar();
int buildCost = data.GetBuildCost(trap.GetUpgradeLevel() + 1);
if (playerAvatar.HasEnoughResources(buildResourceData, buildCost, true, this, false))
{
int constructionTime = data.GetBuildTime(trap.GetUpgradeLevel() + 1);
if (constructionTime != 0 || LogicDataTables.GetGlobals().WorkerForZeroBuilTime())
{
if (!level.HasFreeWorkers(this, -1))
{
return(-1);
}
playerAvatar.CommodityCountChangeHelper(0, buildResourceData, -buildCost);
trap.StartUpgrading();
return(0);
}
}
}
}
else if (gameObject.GetGameObjectType() == 8)
{
if (!this._useAltResources)
{
LogicVillageObject villageObject = (LogicVillageObject)gameObject;
// TODO: Implement upgrade vObjs.
}
return(-31);
}
}
return(-1);
}
public override int Execute(LogicLevel level)
{
if (this.m_gameObjectData != null && level.GetUnplacedObjectCount(this.m_gameObjectData) > 0)
{
if (level.GetVillageType() == this.m_gameObjectData.GetVillageType())
{
LogicDataType dataType = this.m_gameObjectData.GetDataType();
if (dataType == LogicDataType.BUILDING)
{
LogicBuildingData buildingData = (LogicBuildingData)this.m_gameObjectData;
if (level.IsValidPlaceForBuilding(this.m_x, this.m_y, buildingData.GetWidth(), buildingData.GetHeight(), null))
{
if (!level.RemoveUnplacedObject(this.m_gameObjectData, this.m_upgradeLevel))
{
return(-63);
}
LogicBuilding building = (LogicBuilding)LogicGameObjectFactory.CreateGameObject(this.m_gameObjectData, level, level.GetVillageType());
building.SetPositionXY(this.m_x << 9, this.m_y << 9);
level.GetGameObjectManager().AddGameObject(building, -1);
building.FinishConstruction(false, true);
building.SetUpgradeLevel(this.m_upgradeLevel);
}
return(0);
}
if (dataType == LogicDataType.TRAP)
{
LogicTrapData trapData = (LogicTrapData)this.m_gameObjectData;
if (level.IsValidPlaceForBuilding(this.m_x, this.m_y, trapData.GetWidth(), trapData.GetHeight(), null))
{
if (!level.RemoveUnplacedObject(this.m_gameObjectData, this.m_upgradeLevel))
{
return(-64);
}
LogicTrap trap = (LogicTrap)LogicGameObjectFactory.CreateGameObject(this.m_gameObjectData, level, level.GetVillageType());
trap.SetPositionXY(this.m_x << 9, this.m_y << 9);
trap.FinishConstruction(false);
trap.SetUpgradeLevel(this.m_upgradeLevel);
level.GetGameObjectManager().AddGameObject(trap, -1);
}
return(0);
}
if (dataType == LogicDataType.DECO)
{
LogicDecoData decoData = (LogicDecoData)this.m_gameObjectData;
if (level.IsValidPlaceForBuilding(this.m_x, this.m_y, decoData.GetWidth(), decoData.GetHeight(), null))
{
if (!level.RemoveUnplacedObject(this.m_gameObjectData, this.m_upgradeLevel))
{
return(-65);
}
LogicDeco deco = (LogicDeco)LogicGameObjectFactory.CreateGameObject(this.m_gameObjectData, level, level.GetVillageType());
deco.SetPositionXY(this.m_x << 9, this.m_y << 9);
level.RemoveUnplacedObject(this.m_gameObjectData, this.m_upgradeLevel);
level.GetGameObjectManager().AddGameObject(deco, -1);
}
return(0);
}
return(-3);
}
return(-35);
}
return(0);
}
public static void SetBuildingUpgradeLevel(LogicLevel level, int gameObjectId, int upgLevel, int villageType)
{
LogicGameObject gameObject = level.GetGameObjectManagerAt(villageType).GetGameObjectByID(gameObjectId);
if (gameObject != null)
{
if (gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
LogicBuilding building = (LogicBuilding)gameObject;
LogicBuildingData buildingData = building.GetBuildingData();
if (building.GetGearLevel() > 0 || building.IsGearing())
{
if (buildingData.GetMinUpgradeLevelForGearUp() > upgLevel)
{
Debugger.HudPrint("Can't downgrade geared up building below gear up limit!");
upgLevel = buildingData.GetMinUpgradeLevelForGearUp();
}
}
if (buildingData.IsTownHall())
{
level.GetPlayerAvatar().SetTownHallLevel(upgLevel);
}
building.SetUpgradeLevel(LogicMath.Max(upgLevel - 1, 0));
building.FinishConstruction(false, true);
building.SetUpgradeLevel(upgLevel);
if (building.GetListener() != null)
{
building.GetListener().RefreshState();
}
if (buildingData.IsTownHall() || buildingData.IsTownHallVillage2())
{
level.RefreshNewShopUnlocks(buildingData.GetVillageType());
}
}
else if (gameObject.GetGameObjectType() == LogicGameObjectType.TRAP)
{
LogicTrap trap = (LogicTrap)gameObject;
trap.SetUpgradeLevel(LogicMath.Max(upgLevel - 1, 0));
trap.FinishConstruction(false);
trap.SetUpgradeLevel(upgLevel);
trap.RepairTrap();
if (trap.GetListener() != null)
{
trap.GetListener().RefreshState();
}
}
else if (gameObject.GetGameObjectType() == LogicGameObjectType.VILLAGE_OBJECT)
{
LogicVillageObject villageObject = (LogicVillageObject)gameObject;
villageObject.SetUpgradeLevel(LogicMath.Max(upgLevel - 1, 0));
villageObject.SetUpgradeLevel(upgLevel);
if (villageObject.GetListener() != null)
{
villageObject.GetListener().RefreshState();
}
}
}
}
public override int Execute(LogicLevel level)
{
LogicGameObject gameObject = level.GetGameObjectManager().GetGameObjectByID(this.m_gameObjectId);
if (gameObject != null)
{
if (gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
LogicBuilding building = (LogicBuilding)gameObject;
LogicBuildingData buildingData = building.GetBuildingData();
if (buildingData.IsTownHallVillage2())
{
if (!LogicUpgradeBuildingCommand.CanUpgradeTHV2(level))
{
return(-76);
}
}
if (buildingData.GetVillageType() == level.GetVillageType())
{
if (level.GetGameObjectManager().GetAvailableBuildingUpgradeCount(building) <= 0)
{
return(-34);
}
if (building.GetWallIndex() == 0)
{
if (building.CanUpgrade(true))
{
int nextUpgradeLevel = building.GetUpgradeLevel() + 1;
int buildCost = buildingData.GetBuildCost(nextUpgradeLevel, level);
LogicResourceData buildResourceData = this.m_useAltResource
? buildingData.GetAltBuildResource(nextUpgradeLevel)
: buildingData.GetBuildResource(nextUpgradeLevel);
if (buildResourceData != null)
{
LogicClientAvatar playerAvatar = level.GetPlayerAvatar();
if (playerAvatar.HasEnoughResources(buildResourceData, buildCost, true, this, false))
{
if (buildingData.GetConstructionTime(nextUpgradeLevel, level, 0) != 0 || LogicDataTables.GetGlobals().WorkerForZeroBuilTime())
{
if (!level.HasFreeWorkers(this, -1))
{
return(-1);
}
}
playerAvatar.CommodityCountChangeHelper(0, buildResourceData, -buildCost);
building.StartUpgrading(true, false);
return(0);
}
}
}
return(-1);
}
return(-35);
}
return(-32);
}
if (gameObject.GetGameObjectType() == LogicGameObjectType.TRAP)
{
LogicTrap trap = (LogicTrap)gameObject;
if (trap.CanUpgrade(true))
{
LogicTrapData data = trap.GetTrapData();
LogicResourceData buildResourceData = data.GetBuildResource();
LogicClientAvatar playerAvatar = level.GetPlayerAvatar();
int buildCost = data.GetBuildCost(trap.GetUpgradeLevel() + 1);
if (playerAvatar.HasEnoughResources(buildResourceData, buildCost, true, this, false))
{
if (data.GetBuildTime(trap.GetUpgradeLevel() + 1) != 0 || LogicDataTables.GetGlobals().WorkerForZeroBuilTime())
{
if (!level.HasFreeWorkers(this, -1))
{
return(-1);
}
}
playerAvatar.CommodityCountChangeHelper(0, buildResourceData, -buildCost);
trap.StartUpgrading();
return(0);
}
}
}
else if (gameObject.GetGameObjectType() == LogicGameObjectType.VILLAGE_OBJECT)
{
if (!this.m_useAltResource)
{
LogicVillageObject villageObject = (LogicVillageObject)gameObject;
if (villageObject.CanUpgrade(true))
{
LogicVillageObjectData data = villageObject.GetVillageObjectData();
LogicResourceData buildResourceData = data.GetBuildResource();
int buildCost = data.GetBuildCost(villageObject.GetUpgradeLevel() + 1);
if (buildResourceData != null)
{
LogicClientAvatar playerAvatar = level.GetPlayerAvatar();
if (playerAvatar.HasEnoughResources(buildResourceData, buildCost, true, this, false))
{
if (data.GetBuildTime(villageObject.GetUpgradeLevel() + 1) != 0 || LogicDataTables.GetGlobals().WorkerForZeroBuilTime())
{
if (!level.HasFreeWorkers(this, -1))
{
return(-1);
}
}
playerAvatar.CommodityCountChangeHelper(0, buildResourceData, -buildCost);
villageObject.StartUpgrading(true);
return(0);
}
}
}
return(-1);
}
return(-31);
}
}
return(-1);
}
public static LogicClientHome GenerateBase(LogicGameObjectData gameObjectData)
{
LogicClientHome logicClientHome = new LogicClientHome();
LogicGameMode logicGameMode = new LogicGameMode();
LogicLevel logicLevel = logicGameMode.GetLevel();
LogicGameObjectManager logicGameObjectManager = logicLevel.GetGameObjectManagerAt(0);
logicLevel.SetLoadingVillageType(-1);
logicLevel.SetVillageType(0);
logicLevel.SetExperienceVersion(1);
logicLevel.SetHomeOwnerAvatar(GameBaseGenerator.HomeOwnerAvatar);
LogicBuilding townHall = new LogicBuilding(LogicDataTables.GetTownHallData(), logicLevel, 0);
townHall.SetInitialPosition((LogicLevel.TILEMAP_SIZE_X / 2 - townHall.GetWidthInTiles() / 2) << 9, (LogicLevel.TILEMAP_SIZE_Y / 2 - townHall.GetHeightInTiles() / 2) << 9);
townHall.SetUpgradeLevel(townHall.GetBuildingData().GetUpgradeLevelCount() - 1);
logicGameObjectManager.AddGameObject(townHall, -1);
LogicTownhallLevelData townhallLevelData = LogicDataTables.GetTownHallLevel(townHall.GetUpgradeLevel());
if (gameObjectData == null)
{
LogicArrayList <LogicGameObject> scrambler = new LogicArrayList <LogicGameObject>();
for (int i = 0; i < GameBaseGenerator.m_defenseBuildingArray.Size(); i++)
{
LogicBuildingData buildingData = GameBaseGenerator.m_defenseBuildingArray[i];
for (int j = townhallLevelData.GetUnlockedBuildingCount(buildingData); j > 0; j--)
{
LogicBuilding logicBuilding =
(LogicBuilding)GameBaseGenerator.CreateAndPlaceRandomlyGameObject(buildingData, logicLevel, buildingData.GetWidth(), buildingData.GetHeight(), 0);
if (logicBuilding != null)
{
logicBuilding.SetLocked(false);
logicBuilding.SetUpgradeLevel(buildingData.GetUpgradeLevelCount() - 1);
scrambler.Add(logicBuilding);
int upgradeLevel = buildingData.GetUpgradeLevelCount() - 1;
int minUpgradeLevelForGearUp = buildingData.GetMinUpgradeLevelForGearUp();
if (minUpgradeLevelForGearUp > -1 && upgradeLevel >= minUpgradeLevelForGearUp)
{
if (GameBaseGenerator.m_random.Rand(100) >= 50)
{
logicBuilding.SetGearLevel(1);
}
}
if (buildingData.GetAttackerItemData(upgradeLevel).GetTargetingConeAngle() != 0)
{
logicBuilding.GetCombatComponent().ToggleAimAngle(buildingData.GetAimRotateStep() * GameBaseGenerator.m_random.Rand(360 / buildingData.GetAimRotateStep()), 0, false);
}
if (buildingData.GetAttackerItemData(upgradeLevel).HasAlternativeAttackMode())
{
if (minUpgradeLevelForGearUp > -1 && logicBuilding.GetGearLevel() != 1)
{
continue;
}
if (GameBaseGenerator.m_random.Rand(100) >= 50)
{
logicBuilding.GetCombatComponent().ToggleAttackMode(0, false);
}
}
}
}
}
for (int i = 0; i < GameBaseGenerator.m_otherBuildingArray.Size(); i++)
{
LogicBuildingData buildingData = GameBaseGenerator.m_otherBuildingArray[i];
for (int j = townhallLevelData.GetUnlockedBuildingCount(buildingData); j > 0; j--)
{
LogicBuilding logicBuilding =
(LogicBuilding)GameBaseGenerator.CreateAndPlaceRandomlyGameObject(buildingData, logicLevel, buildingData.GetWidth(), buildingData.GetHeight(), 0);
if (logicBuilding != null)
{
logicBuilding.SetLocked(false);
logicBuilding.SetUpgradeLevel(buildingData.GetUpgradeLevelCount() - 1);
scrambler.Add(logicBuilding);
}
}
}
for (int i = 0; i < GameBaseGenerator.m_trapArray.Size(); i++)
{
LogicTrapData trapData = (LogicTrapData)GameBaseGenerator.m_trapArray[i];
for (int j = townhallLevelData.GetUnlockedTrapCount(trapData); j > 0; j--)
{
LogicTrap trap = (LogicTrap)GameBaseGenerator.CreateAndPlaceRandomlyGameObject(trapData, logicLevel, trapData.GetWidth(), trapData.GetHeight(), 0);
if (trap != null)
{
trap.SetUpgradeLevel(trapData.GetUpgradeLevelCount() - 1);
scrambler.Add(trap);
}
}
}
for (int i = 0; i < scrambler.Size(); i++)
{
LogicGameObject gameObject = scrambler[i];
LogicData data = gameObject.GetData();
int width = gameObject.GetWidthInTiles();
int height = gameObject.GetHeightInTiles();
int x = gameObject.GetX();
int y = gameObject.GetY();
LogicArrayList <LogicGameObject> available = new LogicArrayList <LogicGameObject>();
for (int j = i + 1; j < scrambler.Size(); j++)
{
if (data != scrambler[j].GetData())
{
if (scrambler[j].GetWidthInTiles() == width && scrambler[j].GetHeightInTiles() == height)
{
available.Add(scrambler[j]);
}
}
}
if (available.Size() != 0)
{
LogicGameObject swapObj = available[GameBaseGenerator.m_random.Rand(available.Size())];
gameObject.SetInitialPosition(swapObj.GetX(), swapObj.GetY());
swapObj.SetInitialPosition(x, y);
}
}
}
else
{
int maxUpgradeLevel = 0;
int width = 1;
int height = 1;
switch (gameObjectData.GetDataType())
{
case LogicDataType.BUILDING:
{
LogicBuildingData logicBuildingData = (LogicBuildingData)gameObjectData;
maxUpgradeLevel = logicBuildingData.GetUpgradeLevelCount();
width = logicBuildingData.GetWidth();
height = logicBuildingData.GetHeight();
break;
}
case LogicDataType.TRAP:
LogicTrapData logicTrapData = (LogicTrapData)gameObjectData;
maxUpgradeLevel = logicTrapData.GetUpgradeLevelCount();
width = logicTrapData.GetWidth();
height = logicTrapData.GetHeight();
break;
}
int upgLevel = maxUpgradeLevel - 1;
int x = 0;
int y = 0;
while (true)
{
LogicBuilding building =
(LogicBuilding)GameBaseGenerator.CreateGameObjectIfAnyPlaceExist(gameObjectData, logicLevel, width, height, 0, x, y);
if (building == null)
{
break;
}
building.SetLocked(false);
building.SetUpgradeLevel(upgLevel != -1 ? upgLevel : GameBaseGenerator.m_random.Rand(building.GetUpgradeLevel()));
x = building.GetTileX();
y = building.GetTileY();
}
}
for (int i = 0; i < 10; i++)
{
logicGameObjectManager.Village1CreateObstacle();
}
LogicJSONObject jsonObject = new LogicJSONObject();
logicGameMode.SaveToJSON(jsonObject);
logicGameMode.Destruct();
logicClientHome.SetHomeJSON(LogicJSONParser.CreateJSONString(jsonObject, 2048));
CompressibleStringHelper.Compress(logicClientHome.GetCompressibleHomeJSON());
return(logicClientHome);
}
