Пример #1
0
        public override string ToString()
        {
            // Initialize a stringbuilder
            StringBuilder sb = new StringBuilder();

            // For each row of the map
            for (int iRow = 0; iRow < Height; iRow++)
            {
                // For each column of the map
                for (int iColumn = 0; iColumn < Width; iColumn++)
                {
                    // Retrieve the data
                    MapLocationData data = _mapLocationData[iColumn][iRow];

                    // Are there items here?
                    if (data.Items.Count != 0)
                    {
                        // Draw the first item's character
                        ItemInfo info = ItemInfo.GetItemInfo(data.Items[0]);
                        sb.Append(info.Character);
                    }
                    else
                    {
                        // Draw the terrain character
                        sb.Append(TerrainFactory.TerrainToChar(_mapLocationData[iColumn][iRow].Terrain));
                    }
                }

                // Write CRLF to advance to next line
                sb.Append("\r\n");
            }
            return(sb.ToString());
        }
Пример #2
0
        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>	Inserts a single read row into the map. </summary>
        ///
        /// <remarks>	Darrellp, 9/16/2011. </remarks>
        ///
        /// <param name="map">			The map to modify. </param>
        /// <param name="currentLine">	The current line read from the stream. </param>
        /// <param name="iRow">			The row to modify. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////
        private static void InsertRow(IMap map, string currentLine, int iRow)
        {
            // For each character in the read line
            for (int iCol = 0; iCol < Math.Min(map.Width, currentLine.Length); iCol++)
            {
                // Produce the data for that character
                TerrainType terrain = TerrainFactory.ProduceTerrain(currentLine[iCol]);
                Item        item    = ItemInfo.NewItemFromChar(currentLine[iCol]);
                List <Item> items   = item == null ? null : new List <Item> {
                    item
                };
                MapLocationData data = new MapLocationData(terrain, items);

                // and place it in the map
                map[iCol, iRow] = data;
            }
        }
Пример #3
0
        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>	Converts this object to a generic room with no exits. </summary>
        ///
        /// <remarks>	Darrellp, 9/26/2011. </remarks>
        ///
        /// <returns>	This object as a GenericRoom. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////
        internal GenericRoom ToGeneric()
        {
            char[][] layout    = new char[Width][];
            char     floorChar = TerrainFactory.TerrainToChar(TerrainType.Floor);

            for (int iColumn = 0; iColumn < Width; iColumn++)
            {
                layout[iColumn] = new char[Height];
                for (int iRow = 0; iRow < Height; iRow++)
                {
                    bool fBorder = iRow == 0 || iRow == Height - 1 || iColumn == 0 || iColumn == Width - 1;
                    if (!fBorder)
                    {
                        layout[iColumn][iRow] = floorChar;
                    }
                }
            }
            return(new GenericRoom(layout, Location, new List <GenericRoom>()));
        }
Пример #4
0
        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>	Excavate a straight corridor run either vertically or horizontally. </summary>
        ///
        /// <remarks>
        /// Excavates from (startParallel, perpindicular) to (endParallel, perpindicular) inclusive if
        /// fVertical.  If not fVertical, swap coordinates.  start and end parallel coordinates do not
        /// have to be in numerical order.  This is a unidirectional function but, as usual, names are
        /// named as though dir was vertical.  Darrellp, 9/19/2011.
        /// </remarks>
        ///
        /// <param name="map">		The map to be excavated. </param>
        /// <param name="column">	The perpindicular coordinate. </param>
        /// <param name="endRow1">	The starting parallel coordinate. </param>
        /// <param name="endRow2">	The ending parallel coordinate. </param>
        /// <param name="groom">	The room being prepared for this corridor. </param>
        /// <param name="dir">		The direction of the corridor. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////
        private static void ExcavateCorridorRun(IRoomsMap map, int column, int endRow1, int endRow2, GenericRoom groom, Dir dir)
        {
            // We work with small and large coords rather than start and end
            int  startRow  = Math.Min(endRow1, endRow2);
            int  endRow    = Math.Max(endRow1, endRow2);
            char floorChar = TerrainFactory.TerrainToChar(TerrainType.Floor);

            // Create the starting location
            MapCoordinates currentLocation = MapCoordinates.CreateUndirectional(startRow, column, dir);

            // For each row in the run
            for (int iRow = startRow; iRow <= endRow; iRow++)
            {
                // Place our terrain
                currentLocation[dir]         = iRow;
                map[currentLocation].Terrain = TerrainType.Floor;
                groom[currentLocation]       = floorChar;
            }
        }
Пример #5
0
        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>	Excavate a merge between two rooms. </summary>
        ///
        /// <remarks>
        /// Names are named as though dir was vertical and dirOther horizontal. Darrellp, 9/22/2011.
        /// </remarks>
        ///
        /// <param name="map">			The map. </param>
        /// <param name="topRoom">		The top room. </param>
        /// <param name="bottomRoom">	The bottom room. </param>
        /// <param name="dir">			The dir. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////
        private void ExcavateMerge(IRoomsMap map, RectangularRoom topRoom, RectangularRoom bottomRoom, Dir dir)
        {
            // Get the opposite direction
            Dir dirOther = MapCoordinates.OtherDirection(dir);

            // Are the rooms unmergable?
            if (!CheckOverlap(topRoom, bottomRoom, dirOther))
            {
                // Should have caught this in MergeTwoRooms - throw exception
                throw new RogueException("Non-overlapping rooms made it to ExcavateMerge");
            }

            // Get the appropriate coordinates
            int topRoomsLeft     = topRoom.Location[dirOther];
            int topRoomsRight    = topRoomsLeft + topRoom.Size(dirOther) - 1;
            int bottomRoomsLeft  = bottomRoom.Location[dirOther];
            int bottomRoomsRight = bottomRoomsLeft + bottomRoom.Size(dirOther) - 1;

            // Get the high and low points of the overlap
            int overlapLeft  = Math.Max(topRoomsLeft, bottomRoomsLeft) + 1;
            int overlapRight = Math.Min(topRoomsRight, bottomRoomsRight) - 1;

            // Create our new merged generic room
            GenericRoom groomTop    = _mapRoomToGenericRooms[topRoom];
            GenericRoom groomBottom = _mapRoomToGenericRooms[bottomRoom];

            groomTop.CombineWith(groomBottom);

            // For each column in the grid
            foreach (RectangularRoom[] roomColumn in _rooms)
            {
                // For each row in the grid
                for (int iRow = 0; iRow < _rooms[0].Length; iRow++)
                {
                    // Get the rect room at that spot
                    RectangularRoom room = roomColumn[iRow];

                    // Is it mapped to our defunct bottom room?
                    if (_mapRoomToGenericRooms[room] == groomBottom)
                    {
                        // Map it to our shiny new top room
                        _mapRoomToGenericRooms[room] = groomTop;
                    }
                }
            }

            // Get the location we're going to start the clearing at
            int            topRoomsBottom  = topRoom.Location[dir] + topRoom.Size(dir) - 1;
            MapCoordinates currentLocation = MapCoordinates.CreateUndirectional(topRoomsBottom, overlapLeft, dir);
            char           floorChar       = TerrainFactory.TerrainToChar(TerrainType.Floor);

            // For each spot along the overlap
            for (int iCol = overlapLeft; iCol <= overlapRight; iCol++)
            {
                // Clear out the two walls of the abutting rooms
                currentLocation[dirOther]    = iCol;
                map[currentLocation].Terrain = TerrainType.Floor;
                groomTop[currentLocation]    = floorChar;
                currentLocation[dir]         = topRoomsBottom + 1;
                map[currentLocation].Terrain = TerrainType.Floor;
                groomTop[currentLocation]    = floorChar;
                currentLocation[dir]         = topRoomsBottom;
            }
            Debug.Assert(groomBottom == groomTop || !_mapRoomToGenericRooms.ContainsValue(groomBottom));
        }