public void setConexionType(CANAL_CONEXION type, bool update = true)
 {
     conexionType = type;
     if (update)
     {
         updateRepresentation();
     }
 }
    public void updateCanals()
    {
        for (uint i = 0; i < _mapH; ++i)
        {
            for (uint j = 0; j < _mapW; ++j)
            {
                if (tileHasCanal(i, j))
                {
                    CANAL_CONEXION conexion = calculateCanalConexion(i, j);
                    _canalsMatrix [i, j].setHasWater(false, false);
                    _canalsMatrix [i, j].setConexionType(conexion, true);
                }
                else if (tileHasCanalTmp(i, j))
                {
                    CANAL_CONEXION conexion = calculateCanalConexion(i, j);
                    _canalsMatrixTmp [i, j].setHasWater(false, false);
                    _canalsMatrixTmp [i, j].setConexionType(conexion, true);
                }
            }
        }


        // Calculate Water
        bool[,] visited = new bool[_mapH, _mapW];
        Stack <uintPair> toVisit = new Stack <uintPair> (_waterSources);
        //_riceChunkHasWater.Clear ();
        List <int> riceChunkIDs = new List <int>(_riceChunkHasWater.Keys);

        foreach (int key in riceChunkIDs)
        {
            _riceChunkHasWater [key] = false;
        }

        while (toVisit.Count > 0)
        {
            uintPair pos = toVisit.Pop();
            if (visited [pos.First, pos.Second])
            {
                continue;
            }

            visited [pos.First, pos.Second] = true;
            if (tileHasCanal(pos.First, pos.Second))
            {
                _canalsMatrix [pos.First, pos.Second].setHasWater(true, false);
            }
            else if (tileHasCanalTmp(pos.First, pos.Second))
            {
                _canalsMatrixTmp [pos.First, pos.Second].setHasWater(true, false);
            }
            else if (tileHasRice(pos.First, pos.Second))
            {
                int riceChunkID = _riceChunkMatrix [pos.First, pos.Second];
                _riceChunkHasWater [riceChunkID] = true;
            }
            else
            {
                continue;
            }

            CANAL_CONEXION conexion = calculateCanalConexion(pos.First, pos.Second);
            int[,] dirs_matrix = new int[4, 2] {
                { -1, 0 },
                { 0, -1 }, { 0, +1 },
                { +1, 0 }
            };
            for (int k = 0; k < 4; ++k)
            {
                int tile_i = (int)pos.First + dirs_matrix [k, 0];
                int tile_j = (int)pos.Second + dirs_matrix [k, 1];

                bool tile_outside = tile_i < 0 || tile_j < 0 || tile_i >= _mapH || tile_j >= _mapW;
                if (!tile_outside && conexionMatrixs[conexion][1 + dirs_matrix [k, 0], 1 + dirs_matrix [k, 1]])
                {
                    toVisit.Push(new uintPair((uint)tile_i, (uint)tile_j));
                }
            }
        }


        for (uint i = 0; i < _mapH; ++i)
        {
            for (uint j = 0; j < _mapW; ++j)
            {
                if (tileHasCanal(i, j))
                {
                    _canalsMatrix [i, j].updateRepresentation();
                }
                else if (tileHasCanalTmp(i, j))
                {
                    _canalsMatrixTmp [i, j].updateRepresentation();
                }
            }
        }
    }