private static LogicGameObject CreateGameObjectIfAnyPlaceExist(LogicGameObjectData data, LogicLevel level, int width, int height, int villageType, int x = 0, int y = 0)
{
int levelEndX = level.GetPlayArea().GetEndX();
int levelEndY = level.GetPlayArea().GetEndY();
if (x == 0 && y == 0)
{
x = level.GetPlayArea().GetStartX();
y = level.GetPlayArea().GetStartY();
}
while (true)
{
if (level.IsValidPlaceForBuilding(x, y, width, height, null))
{
LogicGameObject gameObject = LogicGameObjectFactory.CreateGameObject(data, level, villageType);
gameObject.SetInitialPosition(x << 9, y << 9);
level.GetGameObjectManagerAt(villageType).AddGameObject(gameObject, -1);
return(gameObject);
}
if (++x + width > levelEndX)
{
if (++y + height > levelEndY)
{
break;
}
x = level.GetPlayArea().GetStartX();
}
}
return(null);
}
private static LogicGameObject CreateAndPlaceRandomlyGameObject(LogicGameObjectData data, LogicLevel level, int width, int height, int villageType)
{
int levelEndX = level.GetPlayArea().GetEndX();
int levelEndY = level.GetPlayArea().GetEndY();
int midX = levelEndX / 2;
int midY = levelEndY / 2;
int passCount = 1;
while (true)
{
int startX = LogicMath.Max(midX - passCount, 0);
int startY = LogicMath.Max(midY - passCount, 0);
int endX = LogicMath.Min(midX + passCount, levelEndX);
int endY = LogicMath.Min(midY + passCount, levelEndY);
int possibility = LogicMath.Min((endX - startX) * (endY - startY), 20);
for (int i = 0; i < possibility; i++)
{
int x = startX + GameBaseGenerator.m_random.Rand(endX - startX);
int y = startY + GameBaseGenerator.m_random.Rand(endY - startY);
if (level.IsValidPlaceForBuilding(x, y, width, height, null))
{
LogicGameObject gameObject = LogicGameObjectFactory.CreateGameObject(data, level, villageType);
gameObject.SetInitialPosition(x << 9, y << 9);
level.GetGameObjectManagerAt(villageType).AddGameObject(gameObject, -1);
return(gameObject);
}
}
if (startX == 0 && startY == 0)
{
return(null);
}
passCount += 2;
}
}
private void Spawn()
{
int free = LogicMath.Min(LogicMath.Min(this.m_spawnCount, this.m_maxSpawned - this.m_spawned.Size()), this.m_maxLifetimeSpawns - this.m_lifeTimeSpawns);
if (free > 0)
{
int x = this.m_parent.GetX();
int y = this.m_parent.GetY();
int tileX = this.m_parent.GetTileX();
int tileY = this.m_parent.GetTileY();
int width = this.m_parent.GetWidthInTiles();
int height = this.m_parent.GetHeightInTiles();
int levelWidth = this.m_parent.GetLevel().GetWidthInTiles();
int levelHeight = this.m_parent.GetLevel().GetHeightInTiles();
int startTileX = LogicMath.Clamp(tileX - this.m_radius, 0, levelWidth);
int startTileY = LogicMath.Clamp(tileY - this.m_radius, 0, levelHeight);
int endTileX = LogicMath.Clamp(tileX + this.m_radius + width, 0, levelWidth);
int endTileY = LogicMath.Clamp(tileY + this.m_radius + height, 0, levelHeight);
int radius = (this.m_radius << 9) * (this.m_radius << 9);
int possibility = (endTileX - startTileX) * (endTileY - startTileY);
LogicArrayList <LogicTile> spawnPoints = new LogicArrayList <LogicTile>(possibility);
LogicTileMap tileMap = this.m_parent.GetLevel().GetTileMap();
int spawnPointUpStartX = x + (width << 9);
int spawnPointUpStartY = y + (height << 9);
int tmp4 = y - 256 - (startTileY << 9);
int startMidX = (startTileX << 9) | 256;
int startMidY = (startTileY << 9) | 256;
for (int i = startTileX, j = startMidX; i < endTileX; i++, j += 512)
{
int tmp1 = j >= spawnPointUpStartX ? -spawnPointUpStartX + j + 1 : 0;
int tmp2 = j >= x ? tmp1 : x - j;
tmp2 *= tmp2;
for (int k = startTileY, l = startMidY, m = tmp4; k < endTileY; k++, l += 512, m -= 512)
{
LogicTile tile = tileMap.GetTile(i, k);
if (tile.GetGameObjectCount() == 0)
{
int tmp3 = y <= l ? l < spawnPointUpStartY ? 0 : -spawnPointUpStartY + l + 1 : m;
tmp3 *= tmp3;
if (tmp2 + tmp3 <= radius)
{
spawnPoints.Add(tile);
}
}
}
}
for (int i = free; i > 0 && spawnPoints.Size() > 0; i--, ++this.m_lifeTimeSpawns)
{
int idx = this.m_randomizer.Rand(spawnPoints.Size());
LogicTile tile = spawnPoints[idx];
LogicGameObject gameObject = LogicGameObjectFactory.CreateGameObject(this.m_spawnData, this.m_parent.GetLevel(), this.m_parent.GetVillageType());
gameObject.SetInitialPosition(tile.GetX() << 9, tile.GetY() << 9);
this.m_parent.GetGameObjectManager().AddGameObject(gameObject, -1);
this.m_spawned.Add(gameObject.GetGlobalID());
spawnPoints.Remove(idx);
}
}
}
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);
}
