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;
 }

 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 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;
        }

        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 TemplateOveridingDefinitionTile(string name, ITemplate template, ITile extends,
                                    IEnumerable<TileAttribute> attributes)
     : base(name, template, attributes)
 {
     _extends = extends;
     Attributes.MergeTileLazy(_extends);
 }

 public override void Move(ITile destination)
 {
     if (!this.CheckMove(destination))
         return;
     this.Mvt--;
     base.Move(destination);
 }

        /// <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 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 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 SpriteEntity(ITile location, Texture2D texture, Color color,
     bool isBlocked, float layerDepth)
     : base(location)
 {
     this.Rotation = Vector2.Zero.ToRotation();
     this.DrawEnding += _OnDrawEnding;
 }

        public TileManager(IEntity entity, ITile current)
        {
            this.entity = entity;
            this.currentTile = current;
            this.previousTile = null;

            this.currentTile.AddEntity(this.entity);
        }

 /// <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 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 PathingNode(ITile tile)
 {
     this.tile = tile;
     this.next = null;
     this.cost = 0f;
     this.order = 0f;
     this.isOpen = false;
     this.isClosed = false;
 }

        /// <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 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 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 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;
        }