public void Swap(IList<ITile> tiles, ITile first, ITile second)
{
int firstIndex = tiles.IndexOf(first);
int secondIndex = tiles.IndexOf(second);
if (firstIndex == -1 || secondIndex == -1)
return;
tiles[firstIndex] = second;
tiles[secondIndex] = first;
}
/// <summary>
/// A Gaul can move twice if it crosses a Plain
/// Cannot cross Water
/// </summary>
/// <param name="destination"></param>
/// <returns></returns>
public override bool CheckMove(ITile destination)
{
if (!destination.IsAdjacent(this.Position) || destination.Type == TileType.Water)
return false;
return base.CheckMove(destination); ;
}
public override void Move(ITile destination)
{
if (!this.CheckMove(destination))
return;
this.Mvt--;
base.Move(destination);
}
public TemplateOveridingDefinitionTile(string name, ITemplate template, ITile extends,
IEnumerable<TileAttribute> attributes)
: base(name, template, attributes)
{
_extends = extends;
Attributes.MergeTileLazy(_extends);
}
public EntityManager(ITile parent, List<IEntity> entityList)
{
this.entityList = entityList ?? new List<IEntity>();
this.newEntityList = new List<IEntity>();
this.oldEntityList = new List<IEntity>();
this.drawEntityList = new List<IDrawableEntity>();
}
public SpriteEntity(ITile location, Texture2D texture, Color color,
bool isBlocked, float layerDepth)
: base(location)
{
this.Rotation = Vector2.Zero.ToRotation();
this.DrawEnding += _OnDrawEnding;
}
public TowerEntity(ITile location, Texture2D texture, Color color,
bool isBlocked, float layerDepth, IEntity owner)
: base(location)
{
this.destinationRectangle = new Rectangle
{
X = location.Rectangle.X,
Y = location.Rectangle.Y,
Height = location.Rectangle.Height,
Width = location.Rectangle.Width
};
this.enabled = true;
this.isBlocked = true;
this.texture = texture;
this.color = color;
this.layerDepth = layerDepth;
this.owner = owner;
this.timer = 5.0f;
this.IsEnemy = false;
this.Intensity = 70.0f;
this.HP = 150;
this.Damage = 100;
this.attackRate = 50;
}
public static bool IsTileTheSame(ITile tile1, ITile tile2)
{
if (tile1.Active != tile2.Active)
return false;
if (tile1.Active)
{
if (tile1.Type != tile2.Type)
return false;
if (Main.tileFrameImportant[(int)tile1.Type])
{
if ((tile1.FrameX != tile2.FrameX) || (tile1.FrameY != tile2.FrameY))
return false;
}
}
return
tile1.Wall == tile2.Wall
&&
tile1.Liquid == tile2.Liquid
&&
tile1.Lava == tile2.Lava
&&
tile1.Wire == tile2.Wire;
}
public static void Load()
{
prevVisitedTiles = new List<KeyValuePair<int, int>>();
tileList = TileLoader.Load("Tiles");
player = new PlayerCharacter();
tile = tileList[new KeyValuePair<int,int>(1,1)];
}
public HardZombieEntity(ITile location, Texture2D texture, Color color,
bool isBlocked, float layerDepth)
{
this.destinationRectangle = new Rectangle
{
X = location.Rectangle.X,
Y = location.Rectangle.Y,
Height = location.Rectangle.Height,
Width = location.Rectangle.Width
};
this.enabled = true;
this.isBlocked = isBlocked;
this.texture = texture;
this.color = color;
this.layerDepth = layerDepth;
this.MoveRate = 100;
this.Tile = location;
this.IsEnemy = true;
this.Intensity = 0.1f;
this.HP = 10000;
this.Damage = 200;
this.attackRate = 200;
this.moveTask = new MoveTask(this, location);
this.rand = new Random((int)this.Position.X + DateTime.Now.Second);
//this.Memory = new Memory_Tile[Tile_Engine.Map.Width, Tile_Engine.Map.Height];
//this.Map.Add(this.Tile.Clone());
Tile_Engine.Map.Enemies.Add(this);
}
public void TransferToTile(ITile next)
{
this.currentTile.RemoveEntity(this.entity);
this.previousTile = this.currentTile;
this.currentTile = next;
this.currentTile.AddEntity(this.entity);
}
public LavaEntity(ITile tile, Texture2D texture, Color color,
bool isBlocked, float layerDepth, int damage, IEntity parent,
IDefendable defender, Vector2 target)
: base(tile)
{
this.destinationRectangle = new Rectangle
{
X = tile.Rectangle.Center.X,
Y = tile.Rectangle.Center.Y,
Height = texture.Height,
Width = texture.Width
};
this.enabled = true;
this.isBlocked = isBlocked;
this.texture = texture;
this.color = Color.White;
this.layerDepth = layerDepth;
this.MoveRate = 5000;
this.tile = tile;
this.parent = parent;
this.Damage = damage;
this.target = target;
this.defender = defender;
this.Position = new Vector2(parent.Rectangle.Center.X, parent.Rectangle.Center.Y);
this.IsFlying = true;
this.isTileMovement = false;
}
/// <summary>
/// Checks if the unit can move during this round to a certain destination.
/// The destination must be next to the current position,
/// the unit must have some movement points left,
/// the tile can't be a sea.
/// </summary>
/// <param name="currentPosition">The current position.</param>
/// <param name="currentTile">The current type of tile.</param>
/// <param name="destination">The destination to reach.</param>
/// <param name="tile">The type of tile the destination is.</param>
/// <returns>True if the unit can move to the destination.</returns>
public override bool CanMove(IPoint currentPosition, ITile currentTile, IPoint destination, ITile tile, bool occupied)
{
return !(tile is ISea)
&& destination.IsNext(currentPosition)
&& (remainingMovementPoints >= MOVEMENT_COST
// Special case for movement to lowland.
|| ((tile is ILowland) && remainingMovementPoints >= MOVEMENT_COST / 2));
}
public void AddTile(ITile tile)
{
if (cache.ContainsKey(tile.Name))
{
throw TileException.DoubleDefinition(tile.Name);
}
cache.Add(tile.Name, tile);
}
public TileManager(IEntity entity, ITile current)
{
this.entity = entity;
this.currentTile = current;
this.previousTile = null;
this.currentTile.AddEntity(this.entity);
}
/// <summary>
/// The method overrides default Equals method.
/// </summary>
/// <param name="other">Object to compare with.</param>
/// <returns>Returns true or false.</returns>
public bool Equals(ITile other)
{
if (other == null)
{
return false;
}
return this.Id == other.Id;
}
public Robber(ITile initialTile)
{
if (initialTile == null)
throw new ArgumentNullException(nameof(initialTile));
if (initialTile.Rawmaterial != MaterialType.Unsourced)
throw new ArgumentException("Robber should always start on the desert!");
CurrentTile = initialTile;
}
public PathingNode(ITile tile)
{
this.tile = tile;
this.next = null;
this.cost = 0f;
this.order = 0f;
this.isOpen = false;
this.isClosed = false;
}
public void TestGetPoints()
{
ITile[] neighbours = new ITile[] {new Lowland(), new Lowland(), new Lowland(), new Lowland()};
Assert.AreEqual(1, gaulois.GetPoints(new Forest(), neighbours));
Assert.AreEqual(0, gaulois.GetPoints(new Sea(), neighbours));
Assert.AreEqual(2, gaulois.GetPoints(new Lowland(), neighbours));
Assert.AreEqual(1, gaulois.GetPoints(new Desert(), neighbours));
Assert.AreEqual(0, gaulois.GetPoints(new Mountain(), neighbours));
}
public void Create_ReturnsAUnitWithALocationAndAnOwner(ITile location, Player owner, ICityFactory<City> factory)
{
// :::: ACT ::::
var city = factory.Create(location, owner);
// :::: ASSERT ::::
city.Location.Should().Be(location);
city.Owner.Should().Be(owner);
}
public TileMemory(ITile source)
{
this.id = source.ID;
this.rectangle = source.Rectangle.Clone();
this.adjacentTiles = new ITile[8];
this.enabled = false;
this.entityManager = new EntityManager(this);
}
public EntityManager(ITile parent, IDictionary<Guid, IEntity> entityList)
{
this.parentTile = parent;
this.entityList = entityList ?? new Dictionary<Guid, IEntity>();
this.newEntityQueue = new Queue<IEntity>();
this.oldEntityQueue = new Queue<IEntity>();
this.drawEntityList = new List<IDrawableEntity>();
this.transferTemp = new Guid[8];
}
/// <summary>
/// Computes the distance from this tile to another tile.
/// </summary>
/// <param name="destination">The destination tile to which the distance is computed.</param>
public int DistanceTo(ITile destination)
{
var squareTileDestination = destination as SquareTile;
if (squareTileDestination == null) throw new NotSupportedException();
var destinationRow = squareTileDestination.Row;
var destinationColumn = squareTileDestination.Column;
return Math.Max(Math.Abs(Row - destinationRow), Math.Abs(Column - destinationColumn));
}
/// <summary>
/// Computes the points won by the unit.
/// </summary>
/// <remarks>
/// Dwarfs win twice the points when they are on a forest;
/// they don't win any if they are on a sea or on a lowland tile.
/// </remarks>
/// <param name="tile">The type of tile the unit is currently on.</param>
/// <param name="neighbours">The neighbour tiles (array of 4 tiles or null if out bounds).</param>
/// <returns>The number of points won by the unit depending on the tile she's on.</returns>
public override int GetPoints(ITile tile, ITile[] neighbours)
{
if(tile is IForest) {
return 2;
} else if(tile is ISea || tile is ILowland) {
return 0;
} else {
return 1;
}
}
/// <summary>
/// Reshuffles all the tiles in a random order
/// </summary>
public void ResetCommand()
{
if (_selectedTile != null)
{
_selectedTile.IsChecked = false;
_selectedTile = null;
}
_tileService.Reset(Tiles);
CheckIfTilesAreOrdered();
}
public void TestInitialize()
{
this.Tile = new Tile
{
Id = "ce402b30-3611-4b26-a6a2-750a46a9f3e0",
EmbedUrl = "https://msit.powerbi.com/embed?dashboardId=86ffe081-a67a-4337-b141-62344e514af5&tileId=cbc13590-7b9b-4f00-b2af-d562534ac674"
};
this.viewModel = new TileViewModel { Tile = this.Tile };
this.htmlHelper = TestHelper.CreateHtmlHelper(new ViewDataDictionary<TileViewModel>(this.viewModel));
}
public BasicTileMap(int width = 27, int height = 15)
{
Metadata = new MapMetadata
{
MapName = "Test Map",
Width = width,
Height = height
};
TileMap = new ITile[height, width];
}
public MinecraftMap()
{
Metadata = new MapMetadata
{
MapName = "World 1",
Width = 256,
Height = 256, //256 x 256 cube
};
TileMap = new ITile[Metadata.Height, Metadata.Width];
}
public MoveTask(IEntity entity, ITile destination)
{
this.isActive = true;
this.Destination = destination;
this.Entity = entity;
this.Path = new List<PathingNode>();
this.isEnabled = false;
this.insanityCheck = 0;
}
public void Move_UpdatesTheLocationOfTheUnitAccordingly(IUnit<Archer> unit, ITile destination)
{
// :::: ARRANGE ::::
var movableUnit = new Movability<Archer>(unit);
// :::: ACT ::::
movableUnit.MoveTo(destination);
// :::: ASSERT ::::
unit.Location.Should().Be(destination);
}
public override void OnMouseDown(MouseButtonDownEventArgs e)
{
if (e.Button != (int)MouseButton.Left || Ui.UIHovering)
{
return;
}
ITile tile = Input.GetTileUnderCursor();
if (tile == null)
{
return;
}
IntRect rect = GetBuildingRectangle(tile, BuildingType);
if (BuildingType.CanBuild(rect.TopLeft(), Input.Player, Level))
{
IBuilding building = Level.BuildBuilding(BuildingType, rect.TopLeft(), Quaternion.Identity, Input.Player);
Tree tree = (Tree)building.BuildingPlugin;
tree.SetSize((sizeSlider.Value / sizeSlider.Range) + startSize);
}
}
internal void Initialize(string Name, int X, int Y, int Width, int Height, ITile[,] CopyFrom, int Layer = 0)
{
this.Index = Index;
this.Name = Name;
this.Data = new StructTile[Width, Height];
this.X = X;
this.Y = Y;
this.Width = Width;
this.Height = Height;
this.Layer = Layer;
for (int i = 0; i < Width; i++)
{
for (int j = 0; j < Height; j++)
{
ITile t = CopyFrom[i, j];
if (t != null)
{
this[i, j].CopyFrom(t);
}
}
}
}
private void PlaceFood()
{
while (!IsFoodPlaced)
{
int yPos;
int xPos;
lock (RandomNumberLock)
{
yPos = RandomNumberGenerator.GetNextNumber(0, Map.Height - 1);
xPos = RandomNumberGenerator.GetNextNumber(0, Map.Width - 1);
}
ITile tile = Map.GetTile(xPos, yPos);
if (tile.Value == TileValues.Empty)
{
tile.SetValue(TileValues.Food);
IsFoodPlaced = true;
FoodXPos = xPos;
FoodYPos = yPos;
}
}
}
public static CutterWrapper CreateNewCutter(ILevelManager level, AggressivePlayer player)
{
foreach (var position in PossiblePositions)
{
ITile tile = GetTileRelativeToKeepCenter(position, player);
if (player.takenPositions.Contains(position) ||
!player.type.TreeCutter.CanBuild(tile.MapLocation, player.Player, level))
{
continue;
}
IBuilding newBuilding = level.BuildBuilding(player.type.TreeCutter.MyTypeInstance,
tile.MapLocation,
Quaternion.Identity,
player.Player);
if (newBuilding != null)
{
player.takenPositions.Add(position);
return(new CutterWrapper(newBuilding, player, position));
}
}
return(null);
}
public int calculate(ITile currentTile, bool gameover)
{
int points = 0;
List <ITile> surroundingTiles = TileUtils.GetAllSurroundingTiles(currentTile);
var churchTile = (Church)currentTile;
if (gameover)
{
points = surroundingTiles.Count;
}
else
{
if (surroundingTiles.Count == 8 && surroundingTiles.All(e => e != null))
{
if (churchTile.CenterFigure != null)
{
points = 9;
}
}
}
return(points);
}
public static bool HasWire(this ITile tile, WireColor color = WireColor.None)
{
if (color == WireColor.None)
{
return(tile.wire() || tile.wire2() || tile.wire3() /* || tile.wire4()*/);
}
if (color == WireColor.Red)
{
return(tile.wire());
}
if (color == WireColor.Blue)
{
return(tile.wire2());
}
if (color == WireColor.Green)
{
return(tile.wire3());
}
//if (color == WireColor.Yellow)
// return tile.wire4();
return(false);
}
public override void Paint(Graphics graphics, IDrawingSurface layer, ITile iTile, int offsetX, int offsetY)
{
if (!m_enabled)
{
return;
}
//LibSys.StatusBar.Trace("LabeledPoint::Paint() - " + Location + " : " + m_doName + m_labelBoundingRect);
int x, y, w, h;
x = m_imageBoundingRect.X + 1 + offsetX;
y = m_imageBoundingRect.Y + 1 + offsetY;
w = m_imageBoundingRect.Width - 2;
h = m_imageBoundingRect.Height - 2;
graphics.DrawEllipse(penMain, x, y, w, h);
// debug only - show bounding rectangles:
//graphics.DrawRectangle(Project.debugPen, m_boundingRect); // red
//graphics.DrawRectangle(Project.debug2Pen, m_imageBoundingRect); // green
//graphics.DrawRectangle(Project.debug3Pen, m_labelBoundingRect); // yellow
}
public ITilesCollection WorldMapTiles()
{
ITile[] tiles = new ITile[]
{
new Tile("Graphics/Maps/WorldMap/Overlay/Land/Grass"),
new Tile("Graphics/Maps/WorldMap/Overlay/Land/Sand"),
new Tile("Graphics/Maps/WorldMap/Overlay/Water/Shallow"),
new Tile("Graphics/Maps/WorldMap/Overlay/Water/Ocean"),
new Tile("Graphics/Maps/WorldMap/Overlay/Water/DeepOcean"),
new Tile("Graphics/Maps/WorldMap/Overlay/City/CityGround"),
new Tile("Graphics/Maps/WorldMap/Overlay/City/CityWall"),
new Tile("Graphics/Maps/WorldMap/Overlay/City/Harbour"),
new Tile("Graphics/Maps/WorldMap/Overlay/City/House/Roof/RoofStoneUp"),
new Tile("Graphics/Maps/WorldMap/Overlay/City/House/Roof/RoofStoneDown"),
new Tile("Graphics/Maps/WorldMap/Overlay/City/House/Roof/RoofStoneRight"),
new Tile("Graphics/Maps/WorldMap/Overlay/City/House/Roof/RoofStoneLeft"),
new Tile("Graphics/Maps/WorldMap/Overlay/City/House/Roof/RoofStoneCornerUpRight"),
new Tile("Graphics/Maps/WorldMap/Overlay/City/House/Roof/RoofMiddleVertical"),
new Tile("Graphics/Maps/WorldMap/Overlay/City/House/Roof/RoofMiddleHorisontal"),
new Tile("Graphics/Maps/WorldMap/Overlay/City/House/Roof/RoofMiddleCornerUpRight")
};
return(new TileCollection(Content, tiles));
}
void UpdateHighlight()
{
ITile endTile = input.GetTileUnderCursor();
if (endTile == null)
{
Level.Map.DisableHighlight();
}
if (endTile != line[line.Count - 1])
{
line = GetLine(line[0], endTile);
}
Level.Map.HighlightTileList(line,
line.All((tile) =>
BuildingType.CanBuild(GetBuildingRectangle(tile, BuildingType).TopLeft(),
input.Player,
Level)) &&
cost.HasResources(input.Player, line.Count)
? AbleColor
: UnableColor);
}
internal void TransferRunOnToSuccessors(ITile runOn)
{
ParanoidAssertValid();
bool done;
do
{
var item = (WordItem)_headItems[_selectedIndex + 1];
var selected = CreateHeadWordItem(item.Content);
_headItems[_selectedIndex + 1] = selected;
SetSelectedIndex(_selectedIndex + 1);
AddSequenceTail(Context, PersistedSequenceWeight);
done = ReferenceEquals(item, runOn);
}while (!done);
ContinueRunOnSuggestions();
ParanoidAssertValid();
}
internal void UpdateResources(ITile tile, bool ownerCities = true)
{
for (int relY = -3; relY <= 3; relY++)
{
for (int relX = -3; relX <= 3; relX++)
{
if (tile[relX, relY] == null)
{
continue;
}
City city = tile[relX, relY].City;
if (city == null)
{
continue;
}
if (!ownerCities && CurrentPlayer == city.Owner)
{
continue;
}
city.UpdateResources();
}
}
}
private void CreateMaze(IReadOnlyList <string> mazeData, ITileType pellet)
{
Height = mazeData.Count;
Width = mazeData[0].Length;
MazeArray = new ITile[Height, Width];
var x = 0;
foreach (var lineData in mazeData)
{
var y = 0;
foreach (var tileType in lineData.Select(Parser.GetTileType))
{
MazeArray[x, y] = new Tile(tileType);
if (tileType.Display == pellet.Display)
{
Pellets++;
}
y++;
}
x++;
}
}
public override void Apply(T map)
{
for (int xx = 0; xx < map.Width - 1; xx++)
{
for (int yy = 0; yy < map.Height - 1; yy++)
{
ITile a1 = map.GetTile(new Loc(xx, yy));
ITile b1 = map.GetTile(new Loc(xx + 1, yy));
ITile a2 = map.GetTile(new Loc(xx, yy + 1));
ITile b2 = map.GetTile(new Loc(xx + 1, yy + 1));
int dropType = map.Rand.Next(3);
if (a1.TileEquivalent(this.Terrain) && b1.TileEquivalent(map.WallTerrain) && a2.TileEquivalent(map.WallTerrain) && b2.TileEquivalent(this.Terrain))
{
if (dropType % 2 == 0)
{
map.TrySetTile(new Loc(xx + 1, yy), this.Terrain.Copy());
}
if (dropType < 2)
{
map.TrySetTile(new Loc(xx, yy + 1), this.Terrain.Copy());
}
}
else if (a1.TileEquivalent(map.WallTerrain) && b1.TileEquivalent(this.Terrain) && a2.TileEquivalent(this.Terrain) && b2.TileEquivalent(map.WallTerrain))
{
if (dropType % 2 == 0)
{
map.TrySetTile(new Loc(xx, yy), this.Terrain.Copy());
}
if (dropType < 2)
{
map.TrySetTile(new Loc(xx + 1, yy + 1), this.Terrain.Copy());
}
}
}
}
}
private static void DrawOceanBorderEast(ref Picture output, ITile tile)
{
if (tile.GetBorderType(Direction.East) == Terrain.Ocean)
{
return;
}
if (tile.GetBorderType(Direction.North) == Terrain.Ocean)
{
if (tile.GetBorderType(Direction.NorthEast) == Terrain.Ocean)
{
output.AddLayer(Res.GetPart("TER257", 72, 176, 8, 8), 8, 0);
}
else
{
output.AddLayer(Res.GetPart("TER257", 104, 176, 8, 8), 8, 0);
}
}
else
{
output.AddLayer(Res.GetPart("TER257", 88, 176, 8, 8), 8, 0);
}
if (tile.GetBorderType(Direction.South) == Terrain.Ocean)
{
if (tile.GetBorderType(Direction.SouthEast) == Terrain.Ocean)
{
output.AddLayer(Res.GetPart("TER257", 24, 184, 8, 8), 8, 8);
}
else
{
output.AddLayer(Res.GetPart("TER257", 56, 184, 8, 8), 8, 8);
}
}
else
{
output.AddLayer(Res.GetPart("TER257", 88, 184, 8, 8), 8, 8);
}
}
public void Update(float dt)
{
this.tile = this.getCurrentTile();
var bb = this.tile.CollisionBox;
if (this.LookAt.X > 0)
{
bb = MathUtil.FlipHorizontal(bb, (int)this.tile.Size.X);
}
this.BoundingBox = new Rectangle(
(int)this.Positon.X + bb.X,
(int)this.Positon.Y + bb.Y,
bb.Width,
bb.Height);
var pos = this.Positon;
foreach (var force in this.forces.Values)
{
force.vel += force.acc * dt;
pos += force.vel;
}
this.Velocity = pos - this.Positon;
var collResult = GameState.Collision.Move(this, pos);
if (collResult != null)
{
this.Positon = collResult.AvailablePosition;
this.LastCollisionResult = collResult;
}
this.ResetForces(this.LastCollisionResult);
}
private static void DrawOceanBorderWest(ref Picture output, ITile tile)
{
if (tile.GetBorderType(Direction.West) == Terrain.Ocean)
{
return;
}
if (tile.GetBorderType(Direction.North) == Terrain.Ocean)
{
if (tile.GetBorderType(Direction.NorthWest) == Terrain.Ocean)
{
output.AddLayer(Res.GetPart("TER257", 16, 176, 8, 8), 0, 0);
}
else
{
output.AddLayer(Res.GetPart("TER257", 48, 176, 8, 8), 0, 0);
}
}
else
{
output.AddLayer(Res.GetPart("TER257", 80, 176, 8, 8), 0, 0);
}
if (tile.GetBorderType(Direction.South) == Terrain.Ocean)
{
if (tile.GetBorderType(Direction.SouthWest) == Terrain.Ocean)
{
output.AddLayer(Res.GetPart("TER257", 64, 184, 8, 8), 0, 8);
}
else
{
output.AddLayer(Res.GetPart("TER257", 96, 184, 8, 8), 0, 8);
}
}
else
{
output.AddLayer(Res.GetPart("TER257", 80, 184, 8, 8), 0, 8);
}
}
private void PostProcessing(Object tiles)
{
List <ITile> Tiles = (List <ITile>)tiles;
for (int i = 0; i < Tiles.Count; i++)
{
//ITile tile = map.Tiles[Tiles[i]];
ITile tile = Tiles[i];
if (tile.Height <= firstLevel)
{
tile.color = blue;
}
else if (tile.Height > firstLevel && tile.Height <= secondLevel)
{
tile.color = green;
}
else if (tile.Height > secondLevel && tile.Height <= thirdLevel)
{
tile.color = tree;
}
else if (tile.Height > thirdLevel && tile.Height <= fourthLevel)
{
tile.color = brown;
}
else if (tile.Height > fourthLevel)
{
tile.color = red;
}
}
//List<int> tileQueue = (List<int>)tiles;
//Console.WriteLine("Clearing "+ tileQueue.Count+ " Tiles");
//tileQueue.Clear();
}
public void OnNeighborChanged(ITile neighbor)
{
int dx = neighbor.GetCoordinate().x - GetCoordinate().x;
int dz = neighbor.GetCoordinate().z - GetCoordinate().z;
bool isRight = (dx == 1 && dz == 0);
bool isLeft = (dx == -1 && dz == 0);
bool isForward = (dx == 0 && dz == 1);
bool isBackward = (dx == 0 && dz == -1);
IAttachment attachment = GetAttachment();
IAttachment neighborAttachment = neighbor.GetAttachment();
if (attachment is Road)
{
Road road = (Road)attachment;
bool isNeighborRoad = (neighborAttachment is Road);
if (isNeighborRoad && isRight)
{
road.connectRight = true;
}
if (isNeighborRoad && isLeft)
{
road.connectLeft = true;
}
if (isNeighborRoad && isForward)
{
road.connectForward = true;
}
if (isNeighborRoad && isBackward)
{
road.connectBackward = true;
}
}
}
public bool Lock(ITile tile, bool blocking)
{
var startTime = DateTime.Now;
var result = AttemptLock(tile);
if (result)
{
return(true);
}
if (!blocking)
{
return(false);
}
while (result != true)
{
if (DateTime.Now - startTime > Timeout)
{
throw new Exception(string.Format("You appear to have a stuck lock. You may wish to remove the lock named:\n{0}", this.GetLockName(tile)));
}
Thread.Sleep(TimeSpan.FromSeconds(0.25));
result = AttemptLock(tile);
}
return(true);
}
protected override bool Confront(int relX, int relY)
{
ITile moveTarget = Map[X, Y][relX, relY];
City city = moveTarget.City;
if (city == null || city == Home || (city.Owner == Owner && Home != null && moveTarget.DistanceTo(Home) < 10))
{
MovementTo(relX, relY);
return(true);
}
if (city.Owner != Owner)
{
EstablishTradeRoute(moveTarget.City);
return(true);
}
if (Game.Human == Owner)
{
GameTask.Enqueue(Show.CaravanChoice(this, city));
}
return(true);
}
public void Run()
{
// Not using Flyweight
for (int i = 0; i < 20; i++)
{
ITile ceramicTile = new CeramicTile(GetRandomNumber(), GetRandomNumber(), GetRandomNumber(), GetRandomNumber());
ceramicTile.Draw("CeramicTile");
ITile stoneTile = new StoneTile(GetRandomNumber(), GetRandomNumber(), GetRandomNumber(), GetRandomNumber());
stoneTile.Draw("StoneTile");
}
Console.WriteLine($"Total of files created not using Flyweight pattern and TileFactory factory : {CeramicTile.objectCounter} + {StoneTile.objectCounter} created");
// Using Flyweight
for (int i = 0; i < 20; i++)
{
ITile ceramicTile = TileFactory.GetTile("Ceramic");
ceramicTile.Draw("CeramicTile", GetRandomNumber(), GetRandomNumber(), GetRandomNumber(), GetRandomNumber());
ITile stoneTile = TileFactory.GetTile("Stone");
stoneTile.Draw("StoneTile", GetRandomNumber(), GetRandomNumber(), GetRandomNumber(), GetRandomNumber());
}
Console.WriteLine($"Total of files created using Flyweight pattern using TileFactory factory : {CeramicTile.objectCounter} + {StoneTile.objectCounter} created");
Console.ReadKey();
}
protected override void MovementDone(ITile previousTile)
{
base.MovementDone(previousTile);
if (MovesLeft > 0)
{
return;
}
// Check if the Trireme is at open sea
if (Tile.GetBorderTiles().Any(t => !(t is Ocean)))
{
return;
}
// The Trireme unit is surrounded by oceans, there's a 50% chance it will be lost at sea
if (Common.Random.Next(0, 100) < 50)
{
return;
}
Game.DisbandUnit(this);
GameTask.Enqueue(Message.Error("-- Civilization Note --", TextFile.Instance.GetGameText("ERROR/TRIREME")));
}
private static void DrawDiagonalCoast(ref Picture output, ITile tile)
{
bool north = (tile.GetBorderType(Direction.North) == Terrain.Ocean);
bool east = (tile.GetBorderType(Direction.East) == Terrain.Ocean);
bool south = (tile.GetBorderType(Direction.South) == Terrain.Ocean);
bool west = (tile.GetBorderType(Direction.West) == Terrain.Ocean);
if (north && west && (tile.GetBorderType(Direction.NorthWest) != Terrain.Ocean))
{
output.AddLayer(Res.GetPart("TER257", 32, 176, 8, 8), 0, 0);
}
if (north && east && (tile.GetBorderType(Direction.NorthEast) != Terrain.Ocean))
{
output.AddLayer(Res.GetPart("TER257", 40, 176, 8, 8), 8, 0);
}
if (south && west && (tile.GetBorderType(Direction.SouthWest) != Terrain.Ocean))
{
output.AddLayer(Res.GetPart("TER257", 32, 184, 8, 8), 0, 8);
}
if (south && east && (tile.GetBorderType(Direction.SouthEast) != Terrain.Ocean))
{
output.AddLayer(Res.GetPart("TER257", 40, 184, 8, 8), 8, 8);
}
}
private Point[] GetLinePoints(ITile tile, Point[] hexagonPoints)
{
Point[] points = new Point[2];
if (tile.Coordinate.Direction == EnumHarbourDirection.topright)
{
points[0] = hexagonPoints[0];
points[1] = hexagonPoints[1];
}
if (tile.Coordinate.Direction == EnumHarbourDirection.right)
{
points[0] = hexagonPoints[1];
points[1] = hexagonPoints[2];
}
if (tile.Coordinate.Direction == EnumHarbourDirection.downright)
{
points[0] = hexagonPoints[2];
points[1] = hexagonPoints[3];
}
if (tile.Coordinate.Direction == EnumHarbourDirection.downleft)
{
points[0] = hexagonPoints[3];
points[1] = hexagonPoints[4];
}
if (tile.Coordinate.Direction == EnumHarbourDirection.left)
{
points[0] = hexagonPoints[4];
points[1] = hexagonPoints[5];
}
if (tile.Coordinate.Direction == EnumHarbourDirection.topleft)
{
points[0] = hexagonPoints[5];
points[1] = hexagonPoints[6];
}
return(points);
}
public bool CanMoveTo(int relX, int relY)
{
// Issue #93: fix problems with zone-of-control.
// refactored out for unit testability
ITile moveTarget = Map[X, Y][relX, relY];
if (moveTarget == null)
{
return(false);
}
var thisUnits = Map[X, Y].GetBorderTiles().SelectMany(t => t.Units);
var destUnits = moveTarget.GetBorderTiles().SelectMany(t => t.Units);
// Any enemy units around my position OR the target position?
bool thisBlocked = thisUnits.Any(u => u.Owner != Owner);
bool destBlocked = destUnits.Any(u => u.Owner != Owner);
bool destOK = moveTarget.Units.Any(u => u.Owner == Owner) || moveTarget.HasCity;
// Cannot move from a square adjacent to enemy unit to a square adjacent to enemy unit
// but _can_ move to square occupied by own units or to any undefended city square
return(destOK || !thisBlocked || !destBlocked);
}
protected void CalculatePossibleMoves(Vector2 playerPosition)
{
int x = (int)playerPosition.x;
int y = (int)playerPosition.y;
//Tile playerTile = Tile.GetTile(x, y);
ITile playerTile = board[x, y];
for (int i = 0; i < Board.DIM; i++)
{
for (int j = 0; j < Board.DIM; j++)
{
if (i == x && j == y)
{
possibleMoves[i, j] = false;
}
else if (Math.Abs(x - i) <= 1 && Math.Abs(j - y) <= 1)
{
//Tile tile = Tile.GetTile(i, j);
ITile tile = board[i, j];
if (tile.HasPlayer() || tile.Height == Height.ROOF || (playerTile.Height + 1).CompareTo(tile.Height) < 0)
{
possibleMoves[i, j] = false;
}
else
{
possibleMoves[i, j] = true;
}
}
else
{
possibleMoves[i, j] = false;
}
}
}
}
public static void CheckModifiedTiles(int i, int j, Stream stream)
{
if (modifiedTile.Where(t => t.i == i && t.j == j).ToArray().Length != 0)
{
return;
}
ITile tile = Main.tile[i, j];
stream.Seek(0, SeekOrigin.Begin);
var newTile = new NetTile(stream);
byte Slope = 0;
if (newTile.Slope)
{
Slope += 1;
}
if (newTile.Slope2)
{
Slope += 2;
}
if (newTile.Slope3)
{
Slope += 4;
}
modifiedTile.Add(new TileData()
{
i = i,
j = j,
type = tile.type,
slope = Slope,
active = tile.active(),
halfBrick = newTile.IsHalf,
wall = tile.wall
});
}
public override byte[] Render(ITile tile)
{
if (MetaTile)
{
MetaTile metatile = GetMetaTile(tile);
try
{
Cache.Lock(metatile);
return(Cache.Get(tile) ?? RenderMetaTile(metatile, tile));
}
finally
{
Cache.Unlock(metatile);
}
}
else
{
if (!string.IsNullOrEmpty(WatermarkImage))
{
return(Watermark(RenderTile(tile)).GetBytes());
}
return(RenderTile(tile));
}
}
/// <summary>
/// METHOD: MakeGrid, this method initialises and returns a 2D array of tiles
/// which will be the "boards" for the game. 10x10 as per spec
/// </summary>
/// <returns> Return the initialised 2D array of tiles</returns>
private ITile[,] MakeGrid()
{
// Use 2 * (10*10)2D Arrays to create two tile grids. 1. For the player
// to place their ships on
// 2. For the player to visibly see where they have fired shots to, what was
// a miss and what was a hit
ITile[,] grid = new ITile[10, 10];
// FOR LOOP for the X acis
for (int x = 0; x < 10; x++)
{
// FOR LOOP for the Y axis
for (int y = 0; y < 10; y++)
{
// INITIALISE a new tile at grid position X and Y, pass in
// the string found at y - 1 in the in to string array and then the x value
grid[x, y] = new Tile((_intToCharDict[y + 1].ToString()) + x);
}
}
// RETURN the 2D array of ITiles called grid
return(grid);
}
public static bool AllowIrrigation(this ITile tile)
{
if (tile.Irrigation)
{
return(false);
}
// TODO fire-eggs: this should be a flag in ITile or Terrain
switch (tile.Type)
{
case Terrain.Desert:
case Terrain.Grassland1:
case Terrain.Grassland2:
case Terrain.Hills:
case Terrain.Plains:
case Terrain.River:
break;
default:
return(false);
}
//if (!(tile is Desert || tile is Grassland || tile is Hills || tile is Plains || tile is River)) return false;
// fire-eggs 20190810 irrigation is NOT allowed e.g. to left of city
return(CrossTiles(tile).Any(x => (x.Irrigation || x.Type == Terrain.River || x.IsOcean) && !x.HasCity));
}
