public override int Execute(LogicLevel level)
{
if (this.m_layoutId != 6)
{
if (this.m_layoutId != 7)
{
LogicGameObjectFilter filter = new LogicGameObjectFilter();
LogicArrayList <LogicGameObject> gameObjects = new LogicArrayList <LogicGameObject>(500);
int moved = 0;
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++)
{
LogicGameObject gameObject = gameObjects[i];
LogicVector2 position = gameObjects[i].GetPositionLayout(this.m_layoutId, true);
int x = position.m_x;
int y = position.m_y;
if (x != -1 && y != -1)
{
int tmp1 = x + gameObject.GetWidthInTiles();
int tmp2 = y + gameObject.GetHeightInTiles();
for (int j = 0; j < gameObjects.Size(); j++)
{
LogicGameObject tmp = gameObjects[j];
if (tmp != gameObject)
{
LogicVector2 position2 = tmp.GetPositionLayout(this.m_layoutId, true);
int x2 = position2.m_x;
int y2 = position2.m_y;
if (x2 != -1 && y2 != -1)
{
int tmp3 = x2 + tmp.GetWidthInTiles();
int tmp4 = y2 + tmp.GetHeightInTiles();
if (tmp1 > x2 && tmp2 > y2 && x < tmp3 && y < tmp4)
{
Debugger.Warning("LogicSaveBaseLayoutCommand: overlap");
return(-1);
}
}
}
}
}
}
for (int i = 0; i < gameObjects.Size(); i++)
{
LogicGameObject gameObject = gameObjects[i];
LogicVector2 editModePosition = gameObject.GetPositionLayout(this.m_layoutId, true);
LogicVector2 layoutPosition = gameObject.GetPositionLayout(this.m_layoutId, false);
if (gameObject.GetGameObjectType() != LogicGameObjectType.DECO)
{
if (layoutPosition.m_x != editModePosition.m_x || layoutPosition.m_y != editModePosition.m_y)
{
++moved;
}
}
gameObject.SetPositionLayoutXY(editModePosition.m_x, editModePosition.m_y, this.m_layoutId, false);
}
filter.Destruct();
if (moved > 0)
{
LogicAvatar homeOwnerAvatar = level.GetHomeOwnerAvatar();
if (homeOwnerAvatar.GetTownHallLevel() >= LogicDataTables.GetGlobals().GetChallengeBaseCooldownEnabledTownHall())
{
level.SetLayoutCooldownSecs(this.m_layoutId, LogicDataTables.GetGlobals().GetChallengeBaseSaveCooldown());
}
}
return(0);
}
return(-11);
}
return(10);
}
public override int Execute(LogicLevel level)
{
LogicRect playArea = level.GetPlayArea();
LogicArrayList <LogicGameObject> gameObjects = new LogicArrayList <LogicGameObject>();
LogicArrayList <LogicGameObject> staticObjects = new LogicArrayList <LogicGameObject>();
LogicGameObjectFilter filter = new LogicGameObjectFilter();
filter.AddGameObjectType(LogicGameObjectType.BUILDING);
filter.AddGameObjectType(LogicGameObjectType.TRAP);
filter.AddGameObjectType(LogicGameObjectType.DECO);
LogicArrayList <LogicGameObject> buildings = level.GetGameObjectManager().GetGameObjects(LogicGameObjectType.BUILDING);
LogicArrayList <LogicGameObject> obstacles = level.GetGameObjectManager().GetGameObjects(LogicGameObjectType.OBSTACLE);
staticObjects.AddAll(obstacles);
for (int i = 0; i < buildings.Size(); i++)
{
LogicBuilding building = (LogicBuilding)buildings[i];
if (building.IsLocked())
{
filter.AddIgnoreObject(building);
staticObjects.Add(building);
}
}
level.GetGameObjectManager().GetGameObjects(gameObjects, filter);
for (int i = 0; i < gameObjects.Size(); i++)
{
LogicGameObject gameObject = gameObjects[i];
LogicVector2 editModePosition = gameObject.GetPositionLayout(this.m_layoutId, true);
if (editModePosition.m_x != -1 && editModePosition.m_y != -1)
{
int newX = editModePosition.m_x + this.m_x;
int newY = editModePosition.m_y + this.m_y;
int width = gameObject.GetWidthInTiles();
int height = gameObject.GetHeightInTiles();
if (newX < playArea.GetStartX() ||
newY < playArea.GetStartY() ||
newX + width > playArea.GetEndX() ||
newY + height > playArea.GetEndY())
{
return(-1);
}
if (this.m_layoutId <= 3 && this.m_layoutId != 1)
{
for (int j = 0; j < staticObjects.Size(); j++)
{
LogicGameObject staticObject = staticObjects[j];
if (staticObject != gameObject)
{
int staticX = staticObject.GetTileX();
int staticY = staticObject.GetTileY();
int staticWidth = staticObject.GetWidthInTiles();
int staticHeight = staticObject.GetHeightInTiles();
if (staticX != -1 && staticY != -1)
{
if (newX + width > staticX &&
newY + height > staticY &&
newX < staticX + staticWidth &&
newY < staticY + staticHeight)
{
return(-1);
}
}
}
}
}
}
}
for (int i = 0; i < gameObjects.Size(); i++)
{
LogicGameObject gameObject = gameObjects[i];
LogicVector2 editModePosition = gameObject.GetPositionLayout(this.m_layoutId, true);
if (editModePosition.m_x != -1 && editModePosition.m_y != -1)
{
gameObject.SetPositionLayoutXY(editModePosition.m_x + this.m_x, editModePosition.m_y + this.m_y, this.m_layoutId, true);
}
}
filter.Destruct();
return(0);
}
public override int Execute(LogicLevel level)
{
if (this.m_inputLayoutId != 6)
{
if (this.m_outputLayoutId != 6)
{
if (this.m_inputLayoutId != 7)
{
if (this.m_outputLayoutId != 7)
{
int townHallLevel = level.GetTownHallLevel(level.GetVillageType());
if (townHallLevel >= level.GetRequiredTownHallLevelForLayout(this.m_inputLayoutId, -1) &&
townHallLevel >= level.GetRequiredTownHallLevelForLayout(this.m_outputLayoutId, -1))
{
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);
if (this.m_outputLayoutId == level.GetActiveLayout())
{
LogicMoveMultipleBuildingsCommand moveMultipleBuildingsCommand = new LogicMoveMultipleBuildingsCommand();
for (int i = 0; i < gameObjects.Size(); i++)
{
LogicGameObject gameObject = gameObjects[i];
LogicVector2 position = gameObject.GetPositionLayout(this.m_inputLayoutId, false);
moveMultipleBuildingsCommand.AddNewMove(gameObject.GetGlobalID(), position.m_x, position.m_y);
}
int result = moveMultipleBuildingsCommand.Execute(level);
moveMultipleBuildingsCommand.Destruct();
if (result != 0)
{
filter.Destruct();
return(-2);
}
}
for (int i = 0; i < gameObjects.Size(); i++)
{
LogicGameObject gameObject = gameObjects[i];
LogicVector2 layoutPosition = gameObject.GetPositionLayout(this.m_inputLayoutId, false);
LogicVector2 editModePosition = gameObject.GetPositionLayout(this.m_inputLayoutId, true);
gameObject.SetPositionLayoutXY(layoutPosition.m_x, layoutPosition.m_y, this.m_outputLayoutId, false);
gameObject.SetPositionLayoutXY(editModePosition.m_x, editModePosition.m_y, this.m_outputLayoutId, true);
if (gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
LogicCombatComponent combatComponent = gameObject.GetCombatComponent(false);
if (combatComponent != null)
{
if (combatComponent.HasAltAttackMode())
{
if (combatComponent.UseAltAttackMode(this.m_inputLayoutId, false) ^ combatComponent.UseAltAttackMode(this.m_outputLayoutId, false))
{
combatComponent.ToggleAttackMode(this.m_outputLayoutId, false);
}
if (combatComponent.UseAltAttackMode(this.m_inputLayoutId, true) ^ combatComponent.UseAltAttackMode(this.m_outputLayoutId, true))
{
combatComponent.ToggleAttackMode(this.m_outputLayoutId, true);
}
}
if (combatComponent.GetAttackerItemData().GetTargetingConeAngle() != 0)
{
int aimAngle1 = combatComponent.GetAimAngle(this.m_inputLayoutId, false);
int aimAngle2 = combatComponent.GetAimAngle(this.m_outputLayoutId, false);
if (aimAngle1 != aimAngle2)
{
combatComponent.ToggleAimAngle(aimAngle1 - aimAngle2, this.m_outputLayoutId, false);
}
}
}
}
else if (gameObject.GetGameObjectType() == LogicGameObjectType.TRAP)
{
LogicTrap trap = (LogicTrap)gameObject;
if (trap.HasAirMode())
{
if (trap.IsAirMode(this.m_inputLayoutId, false) ^ trap.IsAirMode(this.m_outputLayoutId, false))
{
trap.ToggleAirMode(this.m_outputLayoutId, false);
}
if (trap.IsAirMode(this.m_inputLayoutId, true) ^ trap.IsAirMode(this.m_outputLayoutId, true))
{
trap.ToggleAirMode(this.m_outputLayoutId, true);
}
}
}
}
filter.Destruct();
level.SetLayoutState(this.m_outputLayoutId, level.GetVillageType(), level.GetLayoutState(this.m_inputLayoutId, level.GetVillageType()));
LogicAvatar homeOwnerAvatar = level.GetHomeOwnerAvatar();
if (homeOwnerAvatar.GetTownHallLevel() >= LogicDataTables.GetGlobals().GetChallengeBaseCooldownEnabledTownHall())
{
level.SetLayoutCooldownSecs(this.m_outputLayoutId, level.GetLayoutCooldown(this.m_inputLayoutId) / 15);
}
return(0);
}
return(-1);
}
return(-8);
}
return(-7);
}
return(-6);
}
return(-5);
}
public override int Execute(LogicLevel level)
{
if (this.m_layoutId != 6)
{
if (this.m_layoutId != 7)
{
LogicGameObject gameObject = level.GetGameObjectManager().GetGameObjectByID(this.m_gameObjectId);
if (gameObject != null)
{
LogicGameObjectType gameObjectType = gameObject.GetGameObjectType();
if (gameObjectType == LogicGameObjectType.BUILDING ||
gameObjectType == LogicGameObjectType.TRAP ||
gameObjectType == LogicGameObjectType.DECO)
{
LogicRect playArea = level.GetPlayArea();
if (playArea.IsInside(this.m_x, this.m_y) && playArea.IsInside(this.m_x + gameObject.GetWidthInTiles(), this.m_y + gameObject.GetHeightInTiles()) ||
this.m_x == -1 ||
this.m_y == -1)
{
if (gameObjectType == LogicGameObjectType.BUILDING)
{
LogicBuilding building = (LogicBuilding)gameObject;
if (building.GetWallIndex() != 0)
{
return(-23);
}
}
gameObject.SetPositionLayoutXY(this.m_x, this.m_y, this.m_layoutId, true);
LogicGlobals globals = LogicDataTables.GetGlobals();
if (!globals.NoCooldownFromMoveEditModeActive())
{
if (level.GetActiveLayout(level.GetVillageType()) == this.m_layoutId)
{
LogicAvatar homeOwnerAvatar = level.GetHomeOwnerAvatar();
if (homeOwnerAvatar.GetExpLevel() >= globals.GetChallengeBaseCooldownEnabledTownHall())
{
level.SetLayoutCooldownSecs(this.m_layoutId, globals.GetChallengeBaseSaveCooldown());
}
}
}
return(0);
}
return(-2); // EditModeOutsideMap
}
return(-1);
}
return(-3);
}
return(-6);
}
return(-5);
}
public override int Execute(LogicLevel level)
{
int count = this.m_gameObjectIds.Size();
if (count > 0)
{
bool validGameObjects = true;
if (this.m_xPositions.Size() == count && this.m_xPositions.Size() == count && count <= 500)
{
LogicGameObject[] gameObjects = new LogicGameObject[count];
for (int i = 0; i < count; i++)
{
LogicGameObject gameObject = level.GetGameObjectManager().GetGameObjectByID(this.m_gameObjectIds[i]);
if (gameObject != null)
{
LogicGameObjectType gameObjectType = gameObject.GetGameObjectType();
if (gameObjectType != LogicGameObjectType.BUILDING &&
gameObjectType != LogicGameObjectType.TRAP &&
gameObjectType != LogicGameObjectType.DECO)
{
validGameObjects = false;
}
gameObjects[i] = gameObject;
}
else
{
validGameObjects = false;
}
}
if (validGameObjects)
{
for (int i = 0; i < count; i++)
{
LogicGameObject gameObject = gameObjects[i];
if (gameObject.GetGameObjectType() == LogicGameObjectType.BUILDING && validGameObjects)
{
LogicBuilding baseWallBlock = (LogicBuilding)gameObject;
if (baseWallBlock.GetWallIndex() != 0)
{
int x = this.m_xPositions[i];
int y = this.m_yPositions[i];
int minX = 0;
int minY = 0;
int maxX = 0;
int maxY = 0;
int minWallBlockX = 0;
int minWallBlockY = 0;
int maxWallBlockX = 0;
int maxWallBlockY = 0;
int wallBlockCnt = 0;
bool success = true;
for (int j = 0; j < count; j++)
{
LogicGameObject obj = gameObjects[j];
if (obj.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
LogicBuilding wallBlock = (LogicBuilding)obj;
if (wallBlock.GetWallIndex() == baseWallBlock.GetWallIndex())
{
int tmp1 = x - this.m_xPositions[j];
int tmp2 = y - this.m_yPositions[j];
if ((x & this.m_xPositions[j]) != -1)
{
success = false;
}
minX = LogicMath.Min(minX, tmp1);
minY = LogicMath.Min(minY, tmp2);
maxX = LogicMath.Max(maxX, tmp1);
maxY = LogicMath.Max(maxY, tmp2);
int wallBlockX = wallBlock.GetBuildingData().GetWallBlockX(wallBlockCnt);
int wallBlockY = wallBlock.GetBuildingData().GetWallBlockY(wallBlockCnt);
minWallBlockX = LogicMath.Min(minWallBlockX, wallBlockX);
minWallBlockY = LogicMath.Min(minWallBlockY, wallBlockY);
maxWallBlockX = LogicMath.Max(maxWallBlockX, wallBlockX);
maxWallBlockY = LogicMath.Max(maxWallBlockY, wallBlockY);
++wallBlockCnt;
}
}
}
if (baseWallBlock.GetBuildingData().GetWallBlockCount() == wallBlockCnt)
{
int wallBlockSizeX = maxWallBlockX - minWallBlockX;
int wallBlockSizeY = maxWallBlockY - minWallBlockY;
int lengthX = maxX - minX;
int lengthY = maxY - minY;
if (wallBlockSizeX != lengthX || wallBlockSizeY != lengthY)
{
if (!success && wallBlockSizeX != lengthX != (wallBlockSizeY != lengthY))
{
validGameObjects = false;
}
}
}
}
}
}
}
if (validGameObjects)
{
for (int i = 0; i < count; i++)
{
int x = this.m_xPositions[i];
int y = this.m_yPositions[i];
LogicGameObject gameObject = gameObjects[i];
int width = gameObject.GetWidthInTiles();
int height = gameObject.GetHeightInTiles();
int tmp1 = x + width;
int tmp2 = y + height;
for (int j = 0; j < count; j++)
{
LogicGameObject gameObject2 = gameObjects[j];
if (gameObject2 != gameObject)
{
int x2 = this.m_xPositions[j];
int y2 = this.m_yPositions[j];
if (x2 != -1 && y2 != -1)
{
int width2 = gameObject2.GetWidthInTiles();
int height2 = gameObject2.GetHeightInTiles();
int tmp3 = x2 + width2;
int tmp4 = y2 + height2;
if (tmp1 > x2 && tmp2 > y2 && x < tmp3 && y < tmp4)
{
return(0);
}
}
}
}
}
bool moved = false;
for (int i = 0; i < count; i++)
{
int x = this.m_xPositions[i];
int y = this.m_yPositions[i];
LogicGameObject gameObject = gameObjects[i];
LogicVector2 position = gameObject.GetPositionLayout(this.m_layoutId, true);
if (position.m_x != -1 && position.m_y != -1)
{
if (x != position.m_x && y != position.m_y)
{
moved = true;
}
}
gameObject.SetPositionLayoutXY(x, y, this.m_layoutId, true);
LogicGlobals globals = LogicDataTables.GetGlobals();
if (!globals.NoCooldownFromMoveEditModeActive())
{
if (level.GetActiveLayout(level.GetVillageType()) == this.m_layoutId)
{
LogicAvatar homeOwnerAvatar = level.GetHomeOwnerAvatar();
if (homeOwnerAvatar.GetExpLevel() >= globals.GetChallengeBaseCooldownEnabledTownHall())
{
level.SetLayoutCooldownSecs(this.m_layoutId, globals.GetChallengeBaseSaveCooldown());
}
}
}
}
if (moved)
{
LogicAvatar homeOwnerAvatar = level.GetHomeOwnerAvatar();
if (homeOwnerAvatar.GetExpLevel() >= LogicDataTables.GetGlobals().GetChallengeBaseCooldownEnabledTownHall())
{
level.SetLayoutCooldownSecs(this.m_layoutId, LogicDataTables.GetGlobals().GetChallengeBaseSaveCooldown());
}
}
return(0);
}
}
}
return(-1);
}
public override int Execute(LogicLevel level)
{
if (LogicDataTables.GetGlobals().UseSwapBuildings())
{
if (this.m_gameObject1 != this.m_gameObject2)
{
LogicGameObject gameObject1 = level.GetGameObjectManager().GetGameObjectByID(this.m_gameObject1);
LogicGameObject gameObject2 = level.GetGameObjectManager().GetGameObjectByID(this.m_gameObject2);
if (gameObject1 != null)
{
if (gameObject2 != null)
{
LogicGameObjectType gameObjectType1 = gameObject1.GetGameObjectType();
if (gameObjectType1 == LogicGameObjectType.BUILDING || gameObjectType1 == LogicGameObjectType.TRAP ||
gameObjectType1 == LogicGameObjectType.DECO)
{
LogicGameObjectType gameObjectType2 = gameObject2.GetGameObjectType();
if (gameObjectType2 == LogicGameObjectType.BUILDING || gameObjectType2 == LogicGameObjectType.TRAP ||
gameObjectType2 == LogicGameObjectType.DECO)
{
int width1 = gameObject1.GetWidthInTiles();
int width2 = gameObject2.GetWidthInTiles();
int height1 = gameObject1.GetHeightInTiles();
int height2 = gameObject2.GetHeightInTiles();
if (width1 == width2 && height1 == height2)
{
if (gameObject1.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
LogicBuilding building = (LogicBuilding)gameObject1;
if (building.IsLocked())
{
return(-6);
}
if (building.IsWall())
{
return(-7);
}
}
if (gameObject2.GetGameObjectType() == LogicGameObjectType.BUILDING)
{
LogicBuilding building = (LogicBuilding)gameObject2;
if (building.IsLocked())
{
return(-8);
}
if (building.IsWall())
{
return(-9);
}
}
int x1 = gameObject1.GetPositionLayout(this.m_layoutId, true).m_x;
int y1 = gameObject1.GetPositionLayout(this.m_layoutId, true).m_y;
int x2 = gameObject2.GetPositionLayout(this.m_layoutId, true).m_x;
int y2 = gameObject2.GetPositionLayout(this.m_layoutId, true).m_y;
gameObject1.SetPositionLayoutXY(x2, y2, this.m_layoutId, true);
gameObject2.SetPositionLayoutXY(x1, y1, this.m_layoutId, true);
return(0);
}
return(-5);
}
return(-4);
}
return(-3);
}
return(-2);
}
return(-1);
}
return(-98);
}
return(-99);
}
