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 void UpdateHeroHealthToAvatar(int hitpoint)
{
LogicAvatar avatar = this.m_team == 1 ? this.m_parent.GetLevel().GetHomeOwnerAvatar() : this.m_parent.GetLevel().GetVisitorAvatar();
LogicHeroData data = null;
int upgLevel = 0;
if (this.m_parent.IsHero())
{
LogicCharacter character = (LogicCharacter)this.m_parent;
data = (LogicHeroData)character.GetCharacterData();
upgLevel = character.GetUpgradeLevel();
}
else if (this.m_parent.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
LogicBuilding building = (LogicBuilding)this.m_parent;
LogicHeroBaseComponent heroBaseComponent = building.GetHeroBaseComponent();
if (heroBaseComponent == null)
{
return;
}
LogicBuildingData buildingData = building.GetBuildingData();
if (!buildingData.GetShareHeroCombatData())
{
return;
}
LogicCombatComponent combatComponent = building.GetCombatComponent();
if (combatComponent == null || !combatComponent.IsEnabled())
{
return;
}
data = buildingData.GetHeroData();
upgLevel = avatar.GetUnitUpgradeLevel(data);
}
if (data != null)
{
int secs = LogicMath.Min(data.GetSecondsToFullHealth(hitpoint, upgLevel), data.GetFullRegenerationTimeSec(upgLevel));
if (avatar != null)
{
avatar.GetChangeListener().CommodityCountChanged(0, data, secs);
avatar.SetHeroHealth(data, secs);
}
}
}
public override int Execute(LogicLevel level)
{
if (this.m_gameObjectIds.Size() > 0)
{
LogicResourceData ammoResourceData = null;
int ammoCost = 0;
int idx = 0;
do
{
LogicGameObject gameObject = level.GetGameObjectManager().GetGameObjectByID(this.m_gameObjectIds[idx]);
if (gameObject != null && gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
LogicBuilding building = (LogicBuilding)gameObject;
if (building.GetData().GetVillageType() == level.GetVillageType())
{
LogicCombatComponent combatComponent = building.GetCombatComponent(false);
if (combatComponent != null && combatComponent.UseAmmo())
{
if (combatComponent.GetAmmoCount() < combatComponent.GetMaxAmmo() && !building.IsUpgrading())
{
LogicBuildingData buildingData = building.GetBuildingData();
ammoResourceData = buildingData.GetAmmoResourceData(0);
ammoCost += buildingData.GetAmmoCost(building.GetUpgradeLevel(), combatComponent.GetMaxAmmo() - combatComponent.GetAmmoCount());
}
}
}
else
{
return(-32);
}
}
} while (++idx < this.m_gameObjectIds.Size());
if (ammoResourceData != null && ammoCost > 0)
{
LogicClientAvatar playerAvatar = level.GetPlayerAvatar();
if (playerAvatar.HasEnoughResources(ammoResourceData, ammoCost, true, this, false))
{
for (int i = 0; i < this.m_gameObjectIds.Size(); i++)
{
LogicGameObject gameObject = level.GetGameObjectManager().GetGameObjectByID(this.m_gameObjectIds[i]);
if (gameObject != null && gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
LogicBuilding building = (LogicBuilding)gameObject;
LogicCombatComponent combatComponent = building.GetCombatComponent(false);
if (combatComponent != null && combatComponent.UseAmmo())
{
if (combatComponent.GetAmmoCount() < combatComponent.GetMaxAmmo())
{
int upgradeLevel = building.GetUpgradeLevel();
LogicBuildingData buildingData = building.GetBuildingData();
LogicResourceData loadAmmoResourceData = buildingData.GetAmmoResourceData(upgradeLevel);
int loadAmmoCost = buildingData.GetAmmoCost(upgradeLevel, combatComponent.GetMaxAmmo() - combatComponent.GetAmmoCount());
if (playerAvatar.HasEnoughResources(loadAmmoResourceData, loadAmmoCost, true, this, false))
{
playerAvatar.CommodityCountChangeHelper(0, loadAmmoResourceData, -loadAmmoCost);
combatComponent.LoadAmmo();
continue;
}
}
}
}
break;
}
return(0);
}
return(-2);
}
}
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);
}