public static void LoadDebugJSONArray(LogicLevel level, LogicJSONArray jsonArray, LogicGameObjectType gameObjectType, int villageType)
{
if (jsonArray != null)
{
LogicGameObjectManager gameObjectManager = level.GetGameObjectManagerAt(villageType);
LogicArrayList <LogicGameObject> prevGameObjects = new LogicArrayList <LogicGameObject>();
prevGameObjects.AddAll(gameObjectManager.GetGameObjects(gameObjectType));
for (int i = 0; i < prevGameObjects.Size(); i++)
{
gameObjectManager.RemoveGameObject(prevGameObjects[i]);
}
for (int i = 0; i < jsonArray.Size(); i++)
{
LogicJSONObject jsonObject = jsonArray.GetJSONObject(i);
LogicJSONNumber dataNumber = jsonObject.GetJSONNumber("data");
LogicJSONNumber lvlNumber = jsonObject.GetJSONNumber("lvl");
LogicJSONBoolean lockedBoolean = jsonObject.GetJSONBoolean("locked");
LogicJSONNumber xNumber = jsonObject.GetJSONNumber("x");
LogicJSONNumber yNumber = jsonObject.GetJSONNumber("y");
if (dataNumber != null && xNumber != null && yNumber != null)
{
LogicGameObjectData data = (LogicGameObjectData)LogicDataTables.GetDataById(dataNumber.GetIntValue());
if (data != null)
{
LogicGameObject gameObject = LogicGameObjectFactory.CreateGameObject(data, level, villageType);
if (gameObjectType == LogicGameObjectType.BUILDING)
{
((LogicBuilding)gameObject).StartConstructing(true);
}
if (lockedBoolean != null && lockedBoolean.IsTrue())
{
((LogicBuilding)gameObject).Lock();
}
gameObject.Load(jsonObject);
gameObjectManager.AddGameObject(gameObject, -1);
if (lvlNumber != null)
{
LogicDebugUtil.SetBuildingUpgradeLevel(level, gameObject.GetGlobalID(), lvlNumber.GetIntValue(), villageType);
}
}
}
}
}
}
public override int Execute(LogicLevel level)
{
if (level.GetVillageType() == 1)
{
if (this.m_buildingData != null && this.m_buildingData.GetBuildingClass().CanBuy() && this.m_buildingData.IsWall())
{
if (this.m_buildingData.GetWallBlockCount() != 0)
{
if (this.m_buildingData.GetWallBlockCount() == this.m_position.Size())
{
if (this.m_position.Size() <= 10)
{
for (int i = 0, nIdx = -1; i < this.m_position.Size(); i++)
{
LogicVector2 firstPosition = this.m_position[0];
LogicVector2 position = this.m_position[i];
if (i > 0)
{
int shapeIdx = this.m_buildingData.GetWallBlockIndex(position.m_x - firstPosition.m_x, position.m_y - firstPosition.m_y, i);
if (nIdx == -1)
{
nIdx = shapeIdx;
}
if (shapeIdx == -1 || shapeIdx != nIdx)
{
Debugger.Error("LogicBuyWallBlockCommand shape incorrect");
return(-4);
}
nIdx = shapeIdx;
}
if (!level.IsValidPlaceForBuilding(position.m_x, position.m_y, this.m_buildingData.GetWidth(), this.m_buildingData.GetHeight(), null))
{
Debugger.Error("LogicBuyWallBlockCommand invalid place.");
return(-5);
}
}
if (!level.IsBuildingCapReached(this.m_buildingData, true))
{
LogicClientAvatar playerAvatar = level.GetPlayerAvatar();
LogicResourceData buildResource = this.m_buildingData.GetBuildResource(0);
int buildCost = this.m_buildingData.GetBuildCost(0, level);
if (playerAvatar.HasEnoughResources(buildResource, buildCost, true, this, false))
{
if (this.m_buildingData.IsWorkerBuilding() ||
this.m_buildingData.GetConstructionTime(0, level, 0) <= 0 && !LogicDataTables.GetGlobals().WorkerForZeroBuilTime() ||
level.HasFreeWorkers(this, -1))
{
if (buildResource.IsPremiumCurrency())
{
playerAvatar.UseDiamonds(buildCost);
playerAvatar.GetChangeListener().DiamondPurchaseMade(1, this.m_buildingData.GetGlobalID(), 0, buildCost, level.GetVillageType());
}
else
{
playerAvatar.CommodityCountChangeHelper(0, buildResource, -buildCost);
}
LogicGameObjectManager gameObjectManager = level.GetGameObjectManager();
int wallIndex = gameObjectManager.GetHighestWallIndex(this.m_buildingData);
for (int i = 0; i < this.m_position.Size(); i++)
{
LogicVector2 position = this.m_position[i];
LogicBuilding building =
(LogicBuilding)LogicGameObjectFactory.CreateGameObject(this.m_buildingData, level, level.GetVillageType());
building.StartConstructing(false);
building.SetInitialPosition(position.m_x << 9, position.m_y << 9);
building.SetWallObjectId(wallIndex, i, i == 0);
gameObjectManager.AddGameObject(building, -1);
int width = building.GetWidthInTiles();
int height = building.GetHeightInTiles();
for (int j = 0; j < width; j++)
{
for (int k = 0; k < height; k++)
{
LogicObstacle tallGrass = level.GetTileMap().GetTile(position.m_x + j, position.m_y + k).GetTallGrass();
if (tallGrass != null)
{
level.GetGameObjectManager().RemoveGameObject(tallGrass);
}
}
}
}
}
}
}
return(0);
}
return(-3);
}
return(-2);
}
return(-1);
}
return(0);
}
return(-32);
}
public override int Execute(LogicLevel level)
{
if (level.IsReadyForAttack())
{
if (level.GetVillageType() == 0)
{
if (LogicDataTables.GetGlobals().AllowClanCastleDeployOnObstacles())
{
if (!level.GetTileMap().IsValidAttackPos(this.m_x >> 9, this.m_y >> 9))
{
return(-2);
}
}
else
{
LogicTile tile = level.GetTileMap().GetTile(this.m_x >> 9, this.m_y >> 9);
if (tile == null)
{
return(-4);
}
if (tile.GetPassableFlag() == 0)
{
return(-3);
}
}
LogicClientAvatar playerAvatar = level.GetPlayerAvatar();
if (playerAvatar != null)
{
if (this.m_data != null)
{
LogicGameObjectManager gameObjectManager = level.GetGameObjectManagerAt(0);
if (gameObjectManager.GetGameObjectCountByData(this.m_data) <= 0 && playerAvatar.GetAllianceCastleUsedCapacity() > 0)
{
LogicAlliancePortal alliancePortal = (LogicAlliancePortal)LogicGameObjectFactory.CreateGameObject(this.m_data, level, level.GetVillageType());
LogicBunkerComponent bunkerComponent = alliancePortal.GetBunkerComponent();
alliancePortal.SetInitialPosition(this.m_x, this.m_y);
if (bunkerComponent != null)
{
bunkerComponent.SetMaxCapacity(playerAvatar.GetAllianceCastleTotalCapacity());
if (level.GetBattleLog() != null)
{
if (!level.GetBattleLog().HasDeployedUnits() && level.GetTotalAttackerHeroPlaced() == 0)
{
level.UpdateLastUsedArmy();
}
}
if (level.GetGameMode().IsInAttackPreparationMode())
{
level.GetGameMode().EndAttackPreparation();
}
bunkerComponent.RemoveAllUnits();
LogicArrayList <LogicUnitSlot> allianceUnits = playerAvatar.GetAllianceUnits();
for (int i = 0; i < allianceUnits.Size(); i++)
{
LogicUnitSlot slot = allianceUnits[i];
LogicCombatItemData data = (LogicCombatItemData)slot.GetData();
if (data != null)
{
int count = slot.GetCount();
if (data.GetCombatItemType() == LogicCombatItemData.COMBAT_ITEM_TYPE_CHARACTER)
{
for (int j = 0; j < count; j++)
{
if (bunkerComponent.GetUnusedCapacity() >= data.GetHousingSpace())
{
bunkerComponent.AddUnitImpl(data, slot.GetLevel());
}
}
}
}
else
{
Debugger.Error("LogicPlaceAlliancePortalCommand::execute - NULL alliance character");
}
}
}
gameObjectManager.AddGameObject(alliancePortal, -1);
return(0);
}
}
}
return(-5);
}
}
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);
}
