/// <summary>
/// Executes this command.
/// </summary>
public override int Execute(LogicLevel level)
{
if (LogicDataTables.GetGlobals().UseNewTraining())
{
if (level.GetVillageType() == 0)
{
LogicClientAvatar playerAvatar = level.GetPlayerAvatar();
LogicUnitProduction unitProduction = this._productionType == 1
? level.GetGameObjectManager().GetSpellProduction()
: level.GetGameObjectManager().GetUnitProduction();
if (unitProduction.CanBeBoosted())
{
int cost = unitProduction.GetBoostCost();
if (playerAvatar.HasEnoughDiamonds(cost, true, level))
{
playerAvatar.UseDiamonds(cost);
unitProduction.Boost();
return(0);
}
return(-2);
}
return(-1);
}
return(-32);
}
return(-99);
}
public override int Execute(LogicLevel level)
{
if (this.m_decoData != null)
{
if (this.m_decoData.GetVillageType() == level.GetVillageType())
{
if (level.IsValidPlaceForBuilding(this.m_x, this.m_y, this.m_decoData.GetWidth(), this.m_decoData.GetHeight(), null))
{
LogicClientAvatar playerAvatar = level.GetPlayerAvatar();
LogicResourceData buildResourceData = this.m_decoData.GetBuildResource();
int buildCost = this.m_decoData.GetBuildCost();
if (playerAvatar.HasEnoughResources(buildResourceData, buildCost, true, this, false) && !level.IsDecoCapReached(this.m_decoData, true))
{
if (buildResourceData.IsPremiumCurrency())
{
playerAvatar.UseDiamonds(buildCost);
playerAvatar.GetChangeListener().DiamondPurchaseMade(1, this.m_decoData.GetGlobalID(), 0, buildCost, level.GetVillageType());
}
else
{
playerAvatar.CommodityCountChangeHelper(0, buildResourceData, -buildCost);
}
LogicDeco deco = (LogicDeco)LogicGameObjectFactory.CreateGameObject(this.m_decoData, level, level.GetVillageType());
deco.SetInitialPosition(this.m_x << 9, this.m_y << 9);
level.GetGameObjectManager().AddGameObject(deco, -1);
int width = deco.GetWidthInTiles();
int height = deco.GetHeightInTiles();
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
LogicObstacle tallGrass = level.GetTileMap().GetTile(this.m_x + i, this.m_y + j).GetTallGrass();
if (tallGrass != null)
{
level.GetGameObjectManager().RemoveGameObject(tallGrass);
}
}
}
return(0);
}
}
return(-1);
}
return(-32);
}
return(-1);
}
public override int Execute(LogicLevel level)
{
LogicGameObject gameObject = level.GetGameObjectManager().GetGameObjectByID(this.m_gameObjectId);
if (gameObject != null)
{
LogicClientAvatar playerAvatar = level.GetPlayerAvatar();
if (gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
LogicBuilding building = (LogicBuilding)gameObject;
if (building.CanSell())
{
playerAvatar.CommodityCountChangeHelper(0, building.GetSellResource(), building.GetSellPrice());
building.OnSell();
level.GetGameObjectManager().RemoveGameObject(building);
return(0);
}
}
else if (gameObject.GetGameObjectType() == LogicGameObjectType.DECO)
{
LogicDeco deco = (LogicDeco)gameObject;
LogicDecoData data = deco.GetDecoData();
LogicResourceData buildResourceData = data.GetBuildResource();
int sellPrice = data.GetSellPrice();
if (buildResourceData.IsPremiumCurrency())
{
playerAvatar.SetDiamonds(playerAvatar.GetDiamonds() + sellPrice);
playerAvatar.SetFreeDiamonds(playerAvatar.GetFreeDiamonds() + sellPrice);
playerAvatar.GetChangeListener().FreeDiamondsAdded(sellPrice, 6);
}
else
{
playerAvatar.CommodityCountChangeHelper(0, buildResourceData, sellPrice);
}
level.GetGameObjectManager().RemoveGameObject(deco);
return(0);
}
}
return(-1);
}
/// <summary>
/// Trains the unit with new training.
/// </summary>
public int NewTrainingUnit(LogicLevel level)
{
if (LogicDataTables.GetGlobals().UseNewTraining())
{
if (this._unitData != null)
{
LogicUnitProduction unitProduction = this._unitData.GetCombatItemType() == 1
? level.GetGameObjectManager().GetSpellProduction()
: level.GetGameObjectManager().GetUnitProduction();
if (!unitProduction.IsLocked())
{
if (this._unitCount > 0)
{
if (this._unitData.GetDataType() == unitProduction.GetUnitProductionType())
{
LogicClientAvatar playerAvatar = level.GetPlayerAvatar();
LogicResourceData trainingResourceData = this._unitData.GetTrainingResource();
Int32 trainingCost = level.GetGameMode().GetCalendar().GetUnitTrainingCost(this._unitData, playerAvatar.GetUnitUpgradeLevel(this._unitData));
Int32 refundCount = LogicMath.Max(trainingCost * (this._unitData.GetDataType() != 3
? LogicDataTables.GetGlobals().GetSpellCancelMultiplier()
: LogicDataTables.GetGlobals().GetTrainCancelMultiplier()) / 100, 0);
while (unitProduction.RemoveUnit(this._unitData, this._slotId))
{
playerAvatar.CommodityCountChangeHelper(0, trainingResourceData, refundCount);
if (--this._unitCount <= 0)
{
break;
}
}
return(0);
}
}
return(-1);
}
return(-23);
}
return(-1);
}
return(-99);
}
public static LogicCharacter PlaceHero(LogicHeroData data, LogicLevel level, int x, int y, int hitpoints, int upgLevel)
{
LogicCharacter character = (LogicCharacter)LogicGameObjectFactory.CreateGameObject(data, level, level.GetVillageType());
character.SetUpgradeLevel(upgLevel);
character.GetHitpointComponent().SetHitpoints(hitpoints);
character.SetInitialPosition(x, y);
if (data.IsJumper())
{
character.GetMovementComponent().EnableJump(3600000);
character.GetCombatComponent().RefreshTarget(true);
}
level.GetGameObjectManager().AddGameObject(character, -1);
level.GetGameListener().AttackerPlaced(data);
LogicBattleLog battleLog = level.GetBattleLog();
if (battleLog != null)
{
battleLog.IncrementDeployedAttackerUnits(data, 1);
battleLog.SetCombatItemLevel(data, upgLevel);
}
return(character);
}
public int SpeedUpNewTrainingUnit(LogicLevel level)
{
if (LogicDataTables.GetGlobals().UseNewTraining())
{
LogicUnitProduction unitProduction = this.m_spellProduction ? level.GetGameObjectManager().GetSpellProduction() : level.GetGameObjectManager().GetUnitProduction();
LogicClientAvatar playerAvatar = level.GetPlayerAvatar();
int remainingSecs = unitProduction.GetTotalRemainingSeconds();
int speedUpCost = LogicGamePlayUtil.GetSpeedUpCost(remainingSecs, this.m_spellProduction ? 1 : 4, level.GetVillageType());
if (!level.GetMissionManager().IsTutorialFinished())
{
if (speedUpCost > 0 && LogicDataTables.GetGlobals().GetTutorialTrainingSpeedUpCost() >= 0)
{
speedUpCost = LogicDataTables.GetGlobals().GetTutorialTrainingSpeedUpCost();
}
}
if (playerAvatar.HasEnoughDiamonds(speedUpCost, true, level))
{
playerAvatar.UseDiamonds(speedUpCost);
unitProduction.SpeedUp();
playerAvatar.GetChangeListener().DiamondPurchaseMade(unitProduction.GetUnitProductionType() == LogicDataType.CHARACTER ? 2 : 7, 0, 0, speedUpCost, level.GetVillageType());
return(0);
}
return(-1);
}
return(-99);
}
public static LogicSpell CastSpell(LogicAvatar avatar, LogicSpellData spellData, bool allianceSpell, int upgLevel, LogicLevel level, int x, int y)
{
if (allianceSpell)
{
avatar.RemoveAllianceUnit(spellData, upgLevel);
}
else
{
avatar.CommodityCountChangeHelper(0, spellData, -1);
}
if (!allianceSpell)
{
upgLevel = avatar.GetUnitUpgradeLevel(spellData);
}
LogicSpell spell = (LogicSpell)LogicGameObjectFactory.CreateGameObject(spellData, level, level.GetVillageType());
spell.SetUpgradeLevel(upgLevel);
spell.SetInitialPosition(x, y);
level.GetGameObjectManager().AddGameObject(spell, -1);
level.GetGameListener().AttackerPlaced(spellData);
LogicBattleLog battleLog = level.GetBattleLog();
if (battleLog != null)
{
battleLog.IncrementCastedSpells(spellData, 1);
battleLog.SetCombatItemLevel(spellData, upgLevel);
}
return(spell);
}
public int ChangeVillage(LogicLevel level, bool force)
{
if (this.m_villageType != 0 && !force)
{
LogicVillageObject ship = level.GetGameObjectManagerAt(0).GetShipyard();
if (ship == null || ship.GetUpgradeLevel() <= 0)
{
return(-23);
}
}
if (level.GetGameObjectManagerAt(1).GetTownHall() != null)
{
level.SetVillageType(this.m_villageType);
if (level.GetState() == 1)
{
level.GetPlayerAvatar().SetVariableByName("VillageToGoTo", this.m_villageType);
}
level.GetGameObjectManager().RespawnObstacles();
}
return(0);
}
public override int Execute(LogicLevel level)
{
LogicGameObject gameObject = level.GetGameObjectManager().GetGameObjectByID(this.m_gameObjectId);
if (gameObject != null && gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
LogicBuilding building = (LogicBuilding)gameObject;
if (this.m_unitData != null)
{
LogicUnitUpgradeComponent unitUpgradeComponent = building.GetUnitUpgradeComponent();
if (unitUpgradeComponent != null && unitUpgradeComponent.CanStartUpgrading(this.m_unitData))
{
LogicClientAvatar playerAvatar = level.GetPlayerAvatar();
int upgradeLevel = playerAvatar.GetUnitUpgradeLevel(this.m_unitData);
int upgradeCost = this.m_unitData.GetUpgradeCost(upgradeLevel);
LogicResourceData upgradeResourceData = this.m_unitData.GetUpgradeResource(upgradeLevel);
if (playerAvatar.HasEnoughResources(upgradeResourceData, upgradeCost, true, this, false))
{
playerAvatar.CommodityCountChangeHelper(0, upgradeResourceData, -upgradeCost);
unitUpgradeComponent.StartUpgrading(this.m_unitData);
return(0);
}
}
}
}
return(-1);
}
public override int Execute(LogicLevel level)
{
LogicGameObject gameObject = level.GetGameObjectManager().GetGameObjectByID(this.m_gameObjectId);
if (gameObject != null && gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
LogicBuilding building = (LogicBuilding)gameObject;
if (building.IsLocked())
{
if (building.GetUpgradeLevel() == 0 && building.CanUnlock(true))
{
LogicBuildingData buildingData = building.GetBuildingData();
if (buildingData.GetConstructionTime(0, level, 0) == 0 || level.HasFreeWorkers(this, -1))
{
LogicClientAvatar playerAvatar = level.GetPlayerAvatar();
LogicResourceData buildResource = buildingData.GetBuildResource(0);
int buildCost = buildingData.GetBuildCost(0, level);
if (playerAvatar.HasEnoughResources(buildResource, buildCost, true, this, false))
{
playerAvatar.CommodityCountChangeHelper(0, buildResource, -buildCost);
building.StartConstructing(true);
building.GetListener().RefreshState();
return(0);
}
}
}
}
}
return(-1);
}
/// <summary>
/// Trains the unit with new training.
/// </summary>
public int NewTrainingUnit(LogicLevel level)
{
if (LogicDataTables.GetGlobals().UseNewTraining())
{
LogicUnitProduction unitProduction = this._spellProduction ? level.GetGameObjectManager().GetSpellProduction() : level.GetGameObjectManager().GetUnitProduction();
LogicClientAvatar playerAvatar = level.GetPlayerAvatar();
Int32 remainingSecs = unitProduction.GetTotalRemainingSeconds();
Int32 speedUpCost = LogicGamePlayUtil.GetSpeedUpCost(remainingSecs, this._spellProduction ? 1 : 4, level.GetVillageType());
if (!level.GetMissionManager().IsTutorialFinished())
{
if (speedUpCost > 0 && LogicDataTables.GetGlobals().GetTutorialTrainingSpeedUpCost() > 0)
{
speedUpCost = LogicDataTables.GetGlobals().GetTutorialTrainingSpeedUpCost();
}
}
if (playerAvatar.HasEnoughDiamonds(speedUpCost, true, level))
{
playerAvatar.UseDiamonds(speedUpCost);
unitProduction.SpeedUp();
return(0);
}
return(-1);
}
return(-99);
}
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 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 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 && gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
if (gameObject.IsHidden())
{
LogicBuilding building = (LogicBuilding)gameObject;
LogicGameObjectManagerListener listener = level.GetGameObjectManager().GetListener();
listener.AddGameObject(gameObject);
gameObject.LoadingFinished();
gameObject.GetListener().RefreshState();
building.Trigger();
return(0);
}
Debugger.Warning("PGO building not hidden");
return(-3);
}
Debugger.Warning("PGO == NULL in LogicTriggerTeslaCommand");
return(-2);
}
return(-1);
}
public override int Execute(LogicLevel level)
{
LogicGameObject gameObject = level.GetGameObjectManager().GetGameObjectByID(this.m_gameObjectId);
if (gameObject != null && gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
if (gameObject.GetVillageType() == level.GetVillageType())
{
LogicResourceProductionComponent resourceProductionComponent = gameObject.GetResourceProductionComponent();
if (resourceProductionComponent != null)
{
if (LogicDataTables.GetGlobals().CollectAllResourcesAtOnce())
{
int baseAvailableResources = resourceProductionComponent.GetResourceCount();
int baseCollectedResources = resourceProductionComponent.CollectResources(true);
bool storageIsFull = baseAvailableResources > 0 && baseCollectedResources == 0;
LogicArrayList <LogicComponent> components = level.GetComponentManager().GetComponents(resourceProductionComponent.GetComponentType());
for (int i = 0; i < components.Size(); i++)
{
LogicResourceProductionComponent component = (LogicResourceProductionComponent)components[i];
if (resourceProductionComponent != component && resourceProductionComponent.GetResourceData() == component.GetResourceData())
{
int availableResources = component.GetResourceCount();
int collectedResources = component.CollectResources(!storageIsFull);
if (availableResources > 0)
{
if (collectedResources == 0)
{
storageIsFull = true;
}
}
}
}
}
else
{
resourceProductionComponent.CollectResources(true);
}
return(0);
}
return(-1);
}
return(-3);
}
return(-2);
}
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 && gameObject.GetGameObjectType() == LogicGameObjectType.OBSTACLE)
{
return(((LogicObstacle)gameObject).SpeedUpClearing() ? 0 : -2);
}
return(-1);
}
/// <summary>
/// Executes this command.
/// </summary>
public override int Execute(LogicLevel level)
{
int villageType = level.GetVillageType();
if (this._buildingData.GetVillageType() == villageType)
{
if (this._buildingData.GetBuildingClass().CanBuy)
{
if (level.IsValidPlaceForBuilding(this._x, this._y, this._buildingData.GetWidth(), this._buildingData.GetHeight(), null))
{
if (!level.IsBuildingCapReached(this._buildingData, true))
{
LogicClientAvatar playerAvatar = level.GetPlayerAvatar();
LogicResourceData buildResourceData = this._buildingData.GetBuildResource(0);
int buildResourceCost = this._buildingData.GetBuildCost(0, level);
if (playerAvatar.HasEnoughResources(buildResourceData, buildResourceCost, true, this, false))
{
if (this._buildingData.IsWorkerBuilding() || this._buildingData.GetConstructionTime(0, level, 0) <= 0 && !LogicDataTables.GetGlobals().WorkerForZeroBuilTime() || level.HasFreeWorkers(this, -1))
{
if (buildResourceData.PremiumCurrency)
{
playerAvatar.UseDiamonds(buildResourceCost);
}
else
{
playerAvatar.CommodityCountChangeHelper(0, buildResourceData, -buildResourceCost);
}
LogicBuilding building = (LogicBuilding)LogicGameObjectFactory.CreateGameObject(this._buildingData, level, villageType);
building.SetPositionXY(this._x << 9, this._y << 9);
level.GetGameObjectManager().AddGameObject(building, -1);
building.StartConstructing(false);
if (this._buildingData.IsWall() && level.IsBuildingCapReached(this._buildingData, false))
{
level.GetGameListener().BuildingCapReached(this._buildingData);
}
}
}
return(0);
}
}
}
return(-33);
}
return(-32);
}
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);
}
public override int Execute(LogicLevel level)
{
if (LogicDataTables.GetGlobals().UseNewTraining())
{
LogicUnitProduction unitProduction = this.m_gameObjectId == -2
? level.GetGameObjectManager().GetUnitProduction()
: this.m_gameObjectId == -1
? level.GetGameObjectManager().GetSpellProduction()
: null;
if (unitProduction != null)
{
unitProduction.SetBoostPause(false);
this.UpdateProductionHouseListeners(level);
}
return(0);
}
LogicGameObject gameObject = level.GetGameObjectManager().GetGameObjectByID(this.m_gameObjectId);
if (gameObject != null &&
gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING &&
gameObject.IsBoostPaused())
{
LogicBuilding building = (LogicBuilding)gameObject;
if (building.CanStopBoost())
{
building.SetBoostPause(false);
building.GetListener().RefreshState();
return(0);
}
}
return(-1);
}
public void UpdateProductionHouseListeners(LogicLevel level)
{
LogicArrayList <LogicGameObject> gameObjects = level.GetGameObjectManager().GetGameObjects(LogicGameObjectType.BUILDING);
for (int i = 0; i < gameObjects.Size(); i++)
{
LogicBuilding building = (LogicBuilding)gameObjects[i];
if (building.GetBuildingData().GetUnitProduction(0) > 0)
{
building.GetListener().RefreshState();
}
}
}
public override int Execute(LogicLevel level)
{
LogicGameObject gameObject = level.GetGameObjectManager().GetGameObjectByID(this.m_gameObjectId);
if (gameObject != null && gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
LogicBuilding building = (LogicBuilding)gameObject;
LogicHeroBaseComponent heroBaseComponent = building.GetHeroBaseComponent();
if (heroBaseComponent != null && (uint)this.m_mode <= 1)
{
return(heroBaseComponent.SetHeroMode(this.m_mode) ? 0 : -2);
}
}
return(-1);
}
public override int Execute(LogicLevel level)
{
LogicGameObject gameObject = level.GetGameObjectManager().GetGameObjectByID(this.m_gameObjectId);
if (gameObject != null && gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
LogicBuilding building = (LogicBuilding)gameObject;
LogicUnitUpgradeComponent unitUpgradeComponent = building.GetUnitUpgradeComponent();
if (unitUpgradeComponent.GetCurrentlyUpgradedUnit() != null)
{
return(unitUpgradeComponent.SpeedUp() ? 0 : -2);
}
}
return(-1);
}
public override int Execute(LogicLevel level)
{
LogicGameObject gameObject = level.GetGameObjectManager().GetGameObjectByID(this.m_gameObjectId);
if (gameObject != null && gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
LogicBuilding building = (LogicBuilding)gameObject;
LogicHeroBaseComponent heroBaseComponent = building.GetHeroBaseComponent();
if (heroBaseComponent != null)
{
heroBaseComponent.CancelUpgrade();
return(0);
}
}
return(-1);
}
public override int Execute(LogicLevel level)
{
LogicGameObject gameObject = this.m_villageType <= 1 && level.GetGameObjectManagerAt(this.m_villageType) != null
? level.GetGameObjectManagerAt(this.m_villageType).GetGameObjectByID(this.m_gameObjectId)
: level.GetGameObjectManager().GetGameObjectByID(this.m_gameObjectId);
if (gameObject != null && gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
LogicBuilding building = (LogicBuilding)gameObject;
LogicHeroBaseComponent heroBaseComponent = building.GetHeroBaseComponent();
if (heroBaseComponent != null)
{
return(heroBaseComponent.SpeedUp() ? 0 : -2);
}
}
return(-1);
}
public override int Execute(LogicLevel level)
{
LogicGameObject gameObject = level.GetGameObjectManager().GetGameObjectByID(this.m_gameObjectId);
if (gameObject != null && gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
LogicBuilding building = (LogicBuilding)gameObject;
bool success = building.SpeedUpBoostCooldown();
if (building.GetBuildingData().IsClockTower())
{
building.GetListener().RefreshState();
}
return(success ? 0 : -2);
}
return(-1);
}
public static LogicCharacter PlaceAttacker(LogicAvatar avatar, LogicCharacterData characterData, LogicLevel level, int x, int y)
{
avatar.CommodityCountChangeHelper(level.GetVillageType() == 1 ? 7 : 0, characterData, -1);
LogicCharacter character = (LogicCharacter)LogicGameObjectFactory.CreateGameObject(characterData, level, level.GetVillageType());
int upgradeLevel = avatar.GetUnitUpgradeLevel(characterData);
if (level.GetMissionManager().GetMissionByCategory(2) != null && level.GetVillageType() == 1 && level.GetHomeOwnerAvatar() != null)
{
LogicAvatar homeOwnerAvatar = level.GetHomeOwnerAvatar();
if (homeOwnerAvatar.IsNpcAvatar())
{
upgradeLevel = LogicMath.Clamp(LogicDataTables.GetGlobals().GetVillage2StartUnitLevel(), 0, characterData.GetUpgradeLevelCount() - 1);
}
}
character.SetUpgradeLevel(upgradeLevel);
character.SetInitialPosition(x, y);
if (characterData.IsJumper())
{
character.GetMovementComponent().EnableJump(3600000);
character.GetCombatComponent().RefreshTarget(true);
}
level.GetGameObjectManager().AddGameObject(character, -1);
level.GetGameListener().AttackerPlaced(characterData);
LogicBattleLog battleLog = level.GetBattleLog();
if (battleLog != null)
{
battleLog.IncrementDeployedAttackerUnits(characterData, 1);
battleLog.SetCombatItemLevel(characterData, upgradeLevel);
}
character.UpdateAutoMerge();
return(character);
}
public override int Execute(LogicLevel level)
{
LogicArrayList <LogicGameObject> gameObjects = level.GetGameObjectManager().GetGameObjects(LogicGameObjectType.CHARACTER);
for (int i = 0; i < gameObjects.Size(); i++)
{
LogicCharacter character = (LogicCharacter)gameObjects[i];
if (character.GetHitpointComponent().GetTeam() == 0 && character.IsHero() && character.GetData() == this.m_data && character.GetHitpointComponent().GetHitpoints() > 0)
{
if (this.m_data.HasAbility(character.GetUpgradeLevel()))
{
if (!this.m_data.HasOnceAbility() && character.GetAbilityCooldown() == 0 || this.m_data.HasOnceAbility() && !character.IsAbilityUsed())
{
character.StartAbility();
}
}
}
}
return(0);
}
public override int Execute(LogicLevel level)
{
if (this.m_layoutId != 6)
{
if (this.m_layoutId != 7)
{
if (this.m_state == 0)
{
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);
for (int i = 0; i < gameObjects.Size(); i++)
{
gameObjects[i].SetPositionLayoutXY(-1, -1, this.m_layoutId, true);
}
filter.Destruct();
}
level.SetLayoutState(this.m_layoutId, level.GetVillageType(), this.m_state);
if (this.m_updateListener)
{
}
return(0);
}
return(-11);
}
return(-10);
}