public void Init()
 {
     // We create the first three base tiles positions
     suburbs_pos = new TilePosition(0, 0);
     park_pos = new TilePosition(0, 2);
     heavy_factory_pos = new TilePosition(0, 4);
 }

        public override void Execute(TileManager tileManager, Tile tile, TilePosition pos)
        {
            pos += delta;

            if (tileManager.IsValidTile(pos))
                tileManager.DamageTile(pos, damage);
        }

    public void TestEquality()
    {
        TilePosition suburbs_pos_idem = new TilePosition(0, 0);
        Assert.AreEqual(suburbs_pos, suburbs_pos_idem);

        Assert.AreNotEqual(suburbs_pos, park_pos);
    }

        public override void Execute(TileManager tileManager, Tile tile, TilePosition pos)
        {
            pos += delta;

            if (tileManager.IsValidTile(pos))
                tileManager.world.gameplay.CreateItem(itemDefinition, Graphics.TilePositionToVector3(pos));
        }

    public static FreePositionView InstantiateWithParent(TilePosition p_position, Transform p_parent, Player p_owner)
    {
        try {
            // Creation of the new instance.
            GameObject _new_instance = UnityEngine.Object.Instantiate (RESOURCE) as GameObject;
            _new_instance.transform.parent = p_parent;

            // Get the script associated with the new tile.
            FreePositionView _this = _new_instance.AddComponent<FreePositionView> ();

            // Set the common properties
            _this.m_position = p_position;
            _this.m_player = p_owner;
            if(_this.m_position != null)
            {
                // TODO Rework this Duplicate from TileView.
                Vector3 position = new Vector3(_this.m_position.x * 1.5f * TileView.OffsetX, 0, (_this.m_position.y + 1 ) * TileView.OffsetY);
                _this.transform.position = p_parent.TransformPoint(position);
            }
            else
            {
                Debug.LogError("Position for FreePositionView null !");
            }

            return _this;

        } catch (Exception) {
            Debug.LogError ("Error while instantiating FreePosition! Prefab not found !");
            return null;
        }
    }

        public override void Execute(TileManager tileManager, Tile tile, TilePosition pos)
        {
            pos += delta;

            if (tileManager.IsValidTile(pos))
                tileManager.SetTileType(pos, tileType);
        }

        public override void Load(System.IO.BinaryReader br)
        {
            base.Load(br);

            resetPosition = SerializationUtils.ReadTilePosition(br);
            inventory.Load(br);
        }

        public override bool Generate(CubeWorld world)
        {
            int fromY = fromYRV.EvaluateInt(world);
            int toY = toYRV.EvaluateInt(world);

			TileManager tileManager = world.tileManager;
			
            Random rnd = new Random();

            for (int x = 0; x < tileManager.sizeX; x++)
                for (int z = 0; z < tileManager.sizeZ; z++)
                    for (int y = fromY; y < toY; y++)
                    {
                        TilePosition pos = new TilePosition(x, y, z);
                        if (tileManager.GetTileType(pos) == TileDefinition.EMPTY_TILE_TYPE)
                        {
                            int n = rnd.Next(0, probabilityRange);
                            foreach (TileTypeProbability s in probabilities)
                            {
                                if (n < s.probability)
                                {
                                    tileManager.SetTileType(pos, s.tileType);
                                    break;
                                }
                            }
                        }
                    }

            return true;
        }

 public void removeTile(TilePosition tilePosition)
 {
     GameTile tile = tiles[tilePosition];
     levelData.tiles.Remove (tile.myData);
     tiles.Remove (tilePosition);
     Destroy (tile.gameObject);
 }

    public void TestAssignOwner()
    {
        TileInstance instance = new TileInstance();
        TilePosition position = new TilePosition(0, 0);
        Player player = new Player();

        Assert.AreEqual(0, player.tiles.Count);

        instance.owner = player;
        instance.position = position;
        Assert.AreEqual(player, instance.owner);
        Assert.AreEqual(1, player.tiles.Count);
        Assert.AreEqual(true, player.tiles.Contains(instance));

        // And now the other way around
        instance = new TileInstance();
        player = new Player();
        instance.position = position;

        Assert.AreEqual(0, player.tiles.Count);

        player.AddTileInstance(instance);
        Assert.AreEqual(player, instance.owner);
        Assert.AreEqual(1, player.tiles.Count);
        Assert.AreEqual(true, player.tiles.Contains(instance));
    }

        public override void Execute(TileManager tileManager, Tile tile, TilePosition center)
        {
            for (int d = 1; d <= radius; d++)
            {
	            int rDamage = damage * (radius - d + 1) / radius;
				
				TilePosition[] tiles = Manhattan.GetTilesAtDistance(d);
				
				for(int i = 0; i < tiles.Length; i++)
				{
					TilePosition p = center + tiles[i];
					
	                if (tileManager.IsValidTile(p))
						if (tileManager.DamageTile(p, rDamage) == false)
							if (setOnFire && tileManager.GetTileDefinition(tileManager.GetTileType(p)).burns)
		                        tileManager.SetTileOnFire(p, true);
				}
            }
			
			if (setOnFire)
			{
				TilePosition[] tiles = Manhattan.GetTilesAtDistance(radius + 1);
				
				for(int i = 0; i < tiles.Length; i++)
				{
					TilePosition p = center + tiles[i];
					
	                if (tileManager.IsValidTile(p))
						if (setOnFire && tileManager.GetTileDefinition(tileManager.GetTileType(p)).burns)
	                        tileManager.SetTileOnFire(p, true);
				}
			}
        }

        public bool CheckConditions(TileManager tileManager, Tile tile, TilePosition pos)
        {
            if (condition != null)
                return condition.Validate(tileManager, tile, pos);

            return true;
        }

        public override void Execute(TileManager tileManager, Tile tile, TilePosition pos)
        {
            pos += delta;

            if (tileManager.IsValidTile(pos))
                tileManager.EnqueueInvalidatedTile(pos);
        }

 public Tile this[TilePosition p]
 {
     get
     {
         return this[p.Column, p.Row];
     }
 }

    /// <summary>
    /// Find the shortest path using the A* algorithm and a Euclidean distance heuristic
    /// </summary>
    public TilePath Plan(TilePosition start, TileRect end)
    {
        heap.Clear();
        searchedTilesOverlay.Clear();
        var startNode = heap.NodeAt(start);
        startNode.Predecessor = null;
        heap.DecreaseKey(startNode, 0, 0);
        var currentNode = startNode;
        while (!heap.IsEmpty && !end.Contains((currentNode = heap.ExtractMin()).Position))
        {
            searchedTilesOverlay.Add(currentNode.Position);
            foreach (var n in currentNode.Neighbors)
            {
                float newDistanceFromStart = currentNode.DistanceFromStart                           // Cost so far
                                 + TilePosition.EuclideanDistance(currentNode.Position, n.Position)  // Edge cost
                                 + TilePosition.EuclideanDistance(n.Position, end);                  // Estimated cost to end

                if (n.DistanceFromStart > newDistanceFromStart)
                {
                    n.Predecessor = currentNode;
                    heap.DecreaseKey(n, newDistanceFromStart, newDistanceFromStart);
                }
            }
        }
        heap.SetOverlayToComputedPath(this.computedPathOverlay, currentNode);

        searchedTilesOverlay.Clear();
        searchedTilesOverlay.SetRect(end);

        if (!end.Contains(currentNode.Position))
            return null;

        return this.MakePath(currentNode);
    }

        public override void Execute(TileManager tileManager, Tile tile, TilePosition pos)
        {
            TileDefinition tileDefinition = tileManager.GetTileDefinition(tile.tileType);

            ItemDefinition itemDefinition = tileManager.world.itemManager.GetItemDefinitionById(tileDefinition.id);

            tileManager.world.gameplay.CreateItem(itemDefinition, Graphics.TilePositionToVector3(pos));
        }

 public RoguelikeWorldGenerator(CubeWorld world)
 {
     playerStartPosition =
         new TilePosition(
             LEVEL_HEIGHT / 2,
             world.sizeY - LEVEL_HEIGHT + 3,
             LEVEL_HEIGHT / 2);
 }

 public static TilePosition ReadTilePosition(BinaryReader br)
 {
     TilePosition v = new TilePosition();
     v.x = br.ReadInt32();
     v.y = br.ReadInt32();
     v.z = br.ReadInt32();
     return v;
 }

        public Sector GetSectorTile(TilePosition pos)
        {
            pos.x >>= SECTOR_SIZE_BITS;
            pos.y >>= SECTOR_SIZE_BITS;
            pos.z >>= SECTOR_SIZE_BITS;

            return sectors[pos.x | (pos.y << xSectorsBits) | (pos.z << xySectorsBits)];
        }

 public TileRuleSetDynamic(TilePosition delta, bool value, bool gravity, int timeout, TileRuleCondition condition)
     : base(condition)
 {
     this.delta = delta;
     this.value = value;
     this.gravity = gravity;
     this.timeout = timeout;
 }