Ejemplo n.º 1
0
        /// <summary>
        /// Constructs a cell.
        /// </summary>
        /// <param name="map">The map that this cell belongs to.</param>
        /// <param name="quadCoords">The coordinates of this cell inside it's parent quadratic tile.</param>
        public Cell(MapStructure map, QuadTile quadTile, RCIntVector quadCoords)
        {
            if (map == null)
            {
                throw new ArgumentNullException("map");
            }
            if (quadTile == null)
            {
                throw new ArgumentNullException("quadTile");
            }
            if (quadCoords == RCIntVector.Undefined)
            {
                throw new ArgumentNullException("quadCoords");
            }
            if (quadCoords.X < 0 || quadCoords.X >= MapStructure.NAVCELL_PER_QUAD || quadCoords.Y < 0 || quadCoords.Y >= MapStructure.NAVCELL_PER_QUAD)
            {
                throw new ArgumentOutOfRangeException("mapCoords");
            }

            this.parentMap          = map;
            this.parentQuadTile     = quadTile;
            this.quadCoords         = quadCoords;
            this.walkabilityFlag    = new Stack <bool>();
            this.buildabilityFlag   = new Stack <bool>();
            this.groundLevel        = new Stack <int>();
            this.isLocked           = false;
            this.mapCoords          = this.parentQuadTile.MapCoords * (new RCIntVector(MapStructure.NAVCELL_PER_QUAD, MapStructure.NAVCELL_PER_QUAD)) + this.quadCoords;
            this.neighbours         = new Cell[8];
            this.detachedNeighbours = new List <Tuple <Cell, MapDirection> >();
            this.parentIsoTile      = null;                  /// will be set later
            this.isoIndices         = RCIntVector.Undefined; /// will be set later
        }
Ejemplo n.º 2
0
 /// <summary>
 /// Sets the given quadratic tile as a cutting quadratic tile for this isometric tile.
 /// </summary>
 /// <param name="quadTile">The quadratic tile to set.</param>
 public void SetCuttingQuadTile(QuadTile quadTile)
 {
     if (quadTile == null)
     {
         throw new ArgumentNullException("quadTile");
     }
     this.cuttingQuadTiles.Add(quadTile);
 }
Ejemplo n.º 3
0
 /// <summary>
 /// Detaches the given terrain object from the map structure.
 /// </summary>
 /// <param name="terrainObj">The terrain object to be detached.</param>
 /// <exception cref="InvalidOperationException">If the given terrain object was not attached to this map.</exception>
 public void DetachTerrainObject(ITerrainObject terrainObj)
 {
     if (!this.terrainObjects.Remove(terrainObj))
     {
         throw new InvalidOperationException("The given terrain object was not attached to this map!");
     }
     for (int x = 0; x < terrainObj.Type.QuadraticSize.X; x++)
     {
         for (int y = 0; y < terrainObj.Type.QuadraticSize.Y; y++)
         {
             IQuadTile quadTile = terrainObj.GetQuadTile(new RCIntVector(x, y));
             if (quadTile != null)
             {
                 QuadTile quadTileObj = this.mapStructure.GetQuadTile(quadTile.MapCoords);
                 quadTileObj.DetachTerrainObject();
             }
         }
     }
 }
Ejemplo n.º 4
0
        /// <summary>
        /// Sets the given quadratic tile as a neighbour of this quadratic tile in the given direction.
        /// </summary>
        /// <param name="neighbour">The quadratic tile to be set as a neighbour of this.</param>
        /// <param name="direction">The direction of the new neighbour.</param>
        public void SetNeighbour(QuadTile neighbour, MapDirection direction)
        {
            if (neighbour == null)
            {
                throw new ArgumentNullException("neighbour");
            }
            if (neighbour.parentMap != this.parentMap)
            {
                throw new InvalidOperationException("Neighbour quadratic tiles must have the same parent map!");
            }
            if (this.parentMap.Status != MapStructure.MapStatus.Initializing)
            {
                throw new InvalidOperationException(string.Format("Invalid operation! Map status: {0}", this.parentMap.Status));
            }
            if (this.neighbours[(int)direction] != null)
            {
                throw new InvalidOperationException(string.Format("Neighbour in direction {0} already set!", direction));
            }

            this.neighbours[(int)direction] = neighbour;
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Initializes the structure of this map.
        /// </summary>
        public void Initialize()
        {
            if (this.status != MapStatus.Initializing)
            {
                throw new InvalidOperationException(string.Format("Invalid operation! Map status: {0}", this.status));
            }

            /// Create the quadratic and isometric tiles.
            RCIntVector navCellPerQuadVect = new RCIntVector(NAVCELL_PER_QUAD, NAVCELL_PER_QUAD);

            for (int col = 0; col < MAX_MAPSIZE; col++)
            {
                for (int row = 0; row < MAX_MAPSIZE; row++)
                {
                    /// Calculate the coordinates of the isometric tiles that contain the corner cells of the current quadratic tile.
                    /// Order of the cornerIsoCoords array: NorthWest, NorthEast, SouthEast, SouthWest.
                    RCIntVector   quadTileCoords  = new RCIntVector(col, row);
                    RCIntVector[] cornerIsoCoords = new RCIntVector[4]
                    {
                        MapStructure.NavCellIsoTransform.TransformAB(quadTileCoords * navCellPerQuadVect + new RCIntVector(0, 0)).Round(),
                        MapStructure.NavCellIsoTransform.TransformAB(quadTileCoords * navCellPerQuadVect + new RCIntVector(NAVCELL_PER_QUAD - 1, 0)).Round(),
                        MapStructure.NavCellIsoTransform.TransformAB(quadTileCoords * navCellPerQuadVect + new RCIntVector(NAVCELL_PER_QUAD - 1, NAVCELL_PER_QUAD - 1)).Round(),
                        MapStructure.NavCellIsoTransform.TransformAB(quadTileCoords * navCellPerQuadVect + new RCIntVector(0, NAVCELL_PER_QUAD - 1)).Round()
                    };

                    /// Create the isometric tiles.
                    int     isoTileACount = 0, isoTileBCount = 0;
                    IsoTile isoTileA = null, isoTileB = null;
                    for (int cornerIdx = 0; cornerIdx < 4; cornerIdx++)
                    {
                        if (isoTileA == null)
                        {
                            isoTileA = this.isometricTiles.ContainsKey(cornerIsoCoords[cornerIdx])
                                     ? this.isometricTiles[cornerIsoCoords[cornerIdx]]
                                     : new IsoTile(this, cornerIsoCoords[cornerIdx]);
                            this.isometricTiles[cornerIsoCoords[cornerIdx]] = isoTileA;
                            isoTileACount++;
                        }
                        else if (cornerIsoCoords[cornerIdx] == isoTileA.MapCoords)
                        {
                            isoTileACount++;
                        }
                        else if (isoTileB == null)
                        {
                            isoTileB = this.isometricTiles.ContainsKey(cornerIsoCoords[cornerIdx])
                                     ? this.isometricTiles[cornerIsoCoords[cornerIdx]]
                                     : new IsoTile(this, cornerIsoCoords[cornerIdx]);
                            this.isometricTiles[cornerIsoCoords[cornerIdx]] = isoTileB;
                            isoTileBCount++;
                        }
                        else if (cornerIsoCoords[cornerIdx] == isoTileB.MapCoords)
                        {
                            isoTileBCount++;
                        }
                        else
                        {
                            throw new InvalidOperationException("Unexpected case!");
                        }
                    }

                    QuadTile quadTile = new QuadTile(this,
                                                     isoTileACount >= isoTileBCount ? isoTileA : isoTileB,
                                                     isoTileACount < isoTileBCount ? isoTileA : isoTileB,
                                                     quadTileCoords);
                    this.quadTiles[quadTileCoords.X, quadTileCoords.Y] = quadTile;
                }
            }

            /// Buildup the structure of the map.
            this.SetIsoNeighbours();
            this.SetQuadNeighbours();
            this.SetNavCellNeighbours();
            this.SetNavCellIsoIndices();
            this.status = MapStatus.Closed;
        }