/// <summary>
/// Executes this command.
/// </summary>
public override int Execute(LogicLevel level)
{
if (this._villageType <= 1)
{
if (level.GetGameObjectManagerAt(this._villageType) != null)
{
LogicGameObject gameObject = level.GetGameObjectManagerAt(this._villageType).GetGameObjectByID(this._gameObjectId);
if (gameObject != null)
{
if (gameObject.GetGameObjectType() == 0)
{
return(((LogicBuilding)gameObject).SpeedUpConstruction() ? 0 : -1);
}
if (gameObject.GetGameObjectType() == 4)
{
return(((LogicTrap)gameObject).SpeedUpConstruction() ? 0 : -1);
}
if (gameObject.GetGameObjectType() == 8)
{
return(-1);
}
}
}
return(-3);
}
return(-3);
}
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)
{
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);
}
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);
}
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 bool IsValidAttackPos(int x, int y)
{
for (int i = 0, posX = x - 1; i < 2; i++, posX++)
{
for (int j = 0, posY = y - 1; j < 2; j++, posY++)
{
LogicTile tile = this.GetTile(posX + i, posY + j);
if (tile != null)
{
for (int k = 0; k < tile.GetGameObjectCount(); k++)
{
LogicGameObject gameObject = tile.GetGameObject(k);
if (!gameObject.IsPassable())
{
if (gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
LogicBuilding building = (LogicBuilding)gameObject;
if (!building.GetBuildingData().IsHidden())
{
return(false);
}
}
}
}
}
}
}
return(true);
}
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);
}
public override int Execute(LogicLevel level)
{
if (this.m_villageType <= 1 && level.GetGameObjectManagerAt(this.m_villageType) != null)
{
LogicGameObject gameObject = level.GetGameObjectManagerAt(this.m_villageType).GetGameObjectByID(this.m_gameObjectId);
if (gameObject != null)
{
LogicGameObjectType gameObjectType = gameObject.GetGameObjectType();
if (gameObjectType == LogicGameObjectType.BUILDING)
{
return(((LogicBuilding)gameObject).SpeedUpConstruction() ? 0 : -1);
}
if (gameObjectType == LogicGameObjectType.TRAP)
{
return(((LogicTrap)gameObject).SpeedUpConstruction() ? 0 : -2);
}
if (gameObjectType == LogicGameObjectType.VILLAGE_OBJECT)
{
return(((LogicVillageObject)gameObject).SpeedUpCostruction() ? 0 : -1);
}
}
}
return(-3);
}
public void SetProductionType(LogicGameObject gameObject)
{
this.m_productionType = 0;
if (gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
this.m_productionType = ((LogicBuilding)gameObject).GetBuildingData().IsForgesSpells() ? 1 : 0;
}
}
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);
}
/// <summary>
/// Sets the storage type.
/// </summary>
public void SetStorageType(LogicGameObject gameObject)
{
this._storageType = 0;
if (gameObject.GetGameObjectType() == 0)
{
this._storageType = ((LogicBuilding)gameObject).GetBuildingData().ForgesSpells ? 1 : 0;
}
}
/// <summary>
/// Sets the production type.
/// </summary>
public void SetProductionType(LogicGameObject gameObject)
{
this._productionType = 0;
if (gameObject.GetGameObjectType() == 0)
{
this._productionType = ((LogicBuilding)gameObject).GetBuildingData().ForgesSpells ? 1 : 0;
}
}
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)
{
if (level.GetVillageType() == 1)
{
if (this.m_gameObjectId != 0)
{
LogicGameObjectManager gameObjectManager = level.GetGameObjectManagerAt(1);
LogicGameObject gameObject = gameObjectManager.GetGameObjectByID(this.m_gameObjectId);
if (gameObject != null && gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
LogicBuilding building = (LogicBuilding)gameObject;
if (this.m_unitData != null && level.GetGameMode().GetCalendar().IsProductionEnabled(this.m_unitData))
{
if (this.m_unitData.GetVillageType() == 1)
{
LogicVillage2UnitComponent village2UnitComponent = building.GetVillage2UnitComponent();
if (village2UnitComponent != null)
{
if (this.m_unitData.IsUnlockedForProductionHouseLevel(gameObjectManager.GetHighestBuildingLevel(this.m_unitData.GetProductionHouseData(), true))
)
{
LogicClientAvatar playerAvatar = level.GetPlayerAvatar();
LogicResourceData trainResource = this.m_unitData.GetTrainingResource();
int trainCost = this.m_unitData.GetTrainingCost(playerAvatar.GetUnitUpgradeLevel(this.m_unitData));
if (playerAvatar.HasEnoughResources(trainResource, trainCost, true, this, false))
{
village2UnitComponent.TrainUnit(this.m_unitData);
playerAvatar.CommodityCountChangeHelper(0, trainResource, -trainCost);
}
return(0);
}
return(-7);
}
return(-4);
}
return(-8);
}
}
return(-5);
}
return(-1);
}
return(-10);
}
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>
/// 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 void UpdatePushBack()
{
int startSpeed = this.m_pushTime * this.m_pushTime / this.m_pushInitTime;
int endSpeed = this.m_pushInitTime - startSpeed;
int pushBackX = (startSpeed * this.m_pushBackStartPosition.m_x + endSpeed * this.m_pushBackEndPosition.m_x) / this.m_pushInitTime;
int pushBackY = (startSpeed * this.m_pushBackStartPosition.m_y + endSpeed * this.m_pushBackEndPosition.m_y) / this.m_pushInitTime;
if (this.m_parent == null || this.m_parent.IsFlying() || this.m_parent.GetParent().GetLevel().GetTileMap().IsPassablePathFinder(pushBackX >> 8, pushBackY >> 8) ||
this.m_ignorePush)
{
this.SetPosition(pushBackX, pushBackY);
}
else
{
this.m_pushBackStartPosition.m_x = this.m_position.m_x;
this.m_pushBackStartPosition.m_y = this.m_position.m_y;
this.m_pushBackEndPosition.m_x = this.m_position.m_x;
this.m_pushBackEndPosition.m_y = this.m_position.m_y;
}
this.m_pushTime = LogicMath.Max(this.m_pushTime - 16, 0);
if (this.m_pushTime == 0)
{
LogicGameObject parent = this.m_parent.GetParent();
LogicCombatComponent combatComponent = parent.GetCombatComponent();
if (parent.GetGameObjectType() == LogicGameObjectType.CHARACTER)
{
LogicCharacter character = (LogicCharacter)parent;
if (character.GetCharacterData().GetPickNewTargetAfterPushback() || this.m_ignorePush)
{
if (combatComponent != null)
{
combatComponent.ForceNewTarget();
}
}
}
this.m_parent.NewTargetFound();
if (combatComponent != null)
{
combatComponent.StopAttack();
}
this.m_ignorePush = false;
}
}
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 && (uint)this.m_mode <= 1)
{
return(heroBaseComponent.SetHeroMode(this.m_mode) ? 0 : -2);
}
}
return(-1);
}
public override void Tick()
{
if (this.m_triggeredByRadius)
{
LogicLevel level = this.m_parent.GetLevel();
if (level.IsInCombatState())
{
if (!this.m_triggered)
{
if (((level.GetLogicTime().GetTick() / 4) & 7) == 0)
{
LogicArrayList <LogicComponent> components = this.m_parent.GetComponentManager().GetComponents(LogicComponentType.MOVEMENT);
for (int i = 0; i < components.Size(); i++)
{
LogicGameObject gameObject = components[i].GetParent();
if (gameObject.GetGameObjectType() == LogicGameObjectType.CHARACTER)
{
LogicCharacter character = (LogicCharacter)gameObject;
LogicMovementComponent movementComponent = character.GetMovementComponent();
bool triggerDisabled = false;
if (movementComponent != null)
{
LogicMovementSystem movementSystem = movementComponent.GetMovementSystem();
if (movementSystem != null && movementSystem.IsPushed())
{
triggerDisabled = movementSystem.IgnorePush();
}
}
if (!triggerDisabled && character.GetCharacterData().GetTriggersTraps())
{
this.ObjectClose(character);
}
}
}
}
}
}
}
}
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);
}
/// <summary>
/// Gets the tall grass object.
/// </summary>
public LogicObstacle GetTallGrass()
{
for (int i = 0; i < this._gameObjects.Count; i++)
{
LogicGameObject gameObject = this._gameObjects[i];
if (gameObject.GetGameObjectType() == 3)
{
LogicObstacle obstacle = (LogicObstacle)this._gameObjects[i];
if (obstacle.GetObstacleData().TallGrass)
{
return(obstacle);
}
}
}
return(null);
}
public LogicObstacle GetTallGrass()
{
for (int i = 0; i < this.m_gameObjects.Size(); i++)
{
LogicGameObject gameObject = this.m_gameObjects[i];
if (gameObject.GetGameObjectType() == LogicGameObjectType.OBSTACLE)
{
LogicObstacle obstacle = (LogicObstacle)this.m_gameObjects[i];
if (obstacle.GetObstacleData().IsTallGrass())
{
return(obstacle);
}
}
}
return(null);
}
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 void ObjectClose(LogicGameObject gameObject)
{
LogicHitpointComponent hitpointComponent = gameObject.GetHitpointComponent();
if (hitpointComponent == null || hitpointComponent.GetTeam() != 1)
{
if (gameObject.GetGameObjectType() == LogicGameObjectType.CHARACTER)
{
LogicCharacter character = (LogicCharacter)gameObject;
LogicCharacterData data = character.GetCharacterData();
if (data.GetHousingSpace() < this.m_minTriggerHousingLimit)
{
return;
}
}
LogicCombatComponent combatComponent = gameObject.GetCombatComponent();
if (combatComponent == null || combatComponent.GetUndergroundTime() <= 0)
{
if ((!gameObject.IsFlying() || this.m_airTrigger) && (gameObject.IsFlying() || this.m_groundTrigger))
{
if (this.m_healerTrigger || combatComponent == null || !combatComponent.IsHealer())
{
int distanceX = gameObject.GetX() - this.m_parent.GetMidX();
int distanceY = gameObject.GetY() - this.m_parent.GetMidY();
if (LogicMath.Abs(distanceX) <= this.m_triggerRadius &&
LogicMath.Abs(distanceY) <= this.m_triggerRadius &&
distanceX * distanceX + distanceY * distanceY < (uint)(this.m_triggerRadius * this.m_triggerRadius))
{
this.Trigger();
}
}
}
}
}
}
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 override int Execute(LogicLevel level)
{
LogicGameObjectManager gameObjectManager = level.GetGameObjectManager();
LogicGameObject gameObject = gameObjectManager.GetGameObjectByID(this.m_gameObjectId);
if (gameObject != null && gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
LogicBuilding building = (LogicBuilding)gameObject;
LogicVillage2UnitComponent village2UnitComponent = building.GetVillage2UnitComponent();
if (village2UnitComponent != null)
{
LogicClientAvatar playerAvatar = level.GetPlayerAvatar();
playerAvatar.CommodityCountChangeHelper(7, village2UnitComponent.GetUnitData(), -village2UnitComponent.GetUnitCount());
village2UnitComponent.RemoveUnits();
return(0);
}
}
return(-1);
}
