public Field(Tile[,] initialTiles, int marginFromLeft, int marginFromRight) { _tiles = initialTiles; leftBorder = _tiles.GetLowerBound(0) + marginFromLeft; rightBorder = _tiles.GetUpperBound(0) - marginFromRight; bottomBorder = _tiles.GetUpperBound(1) - 1; }
/// <summary> /// Pierce a 2D array at odd coordinates if it's not occupied by a room /// those coordinates are replaced by -1 /// </summary> /// <param name="map">the map to transform</param> /// <returns>the transformed map</returns> public static Tile[,] PierceArray(Tile[,] map) { for (int x = 1; x < map.GetUpperBound(0); x += 2) { for (int y = 1; y < map.GetUpperBound(1); y += 2) { map[x, y].Type = Type.Floor; } } return(map); }
private static void InitializeMap(Tile[,] tileMap) { // First, fill everything with grassland for (int x = 0; x <= tileMap.GetUpperBound(0); x++) { for (int y = 0; y <= tileMap.GetUpperBound(1); y++) { tileMap[x, y] = new Tile(x, y, tileSize); } } }
public Chunk(Vector2 position) { WorldPos = position; var(x, y) = position; ChunkId = new ChunkIdentifier((int)x, (int)y); for (var i = 255; i > Tiles.GetUpperBound(0); i--) { for (var j = 255; j > Tiles.GetUpperBound(1); j--) { Tiles[i, j] = null; } } }
private int[] FindTile(Tile t) { for (int i = 0; i < tiles.GetUpperBound(0); i++) { for (int j = 0; j < tiles.GetUpperBound(1); j++) { if (tiles[i, j] == t) { return(new int[] { i, j }); } } } return(null); }
public void UpdateAdjacencyFull(Layers layer) { Tile[,] map = Tiles[(int)layer]; for (int i = 0; i <= map.GetUpperBound(0); i++) { for (int j = 0; j <= map.GetUpperBound(1); j++) { if (map[i, j] != null && map[i, j] is Blob) { ((Blob)map[i, j]).UpdateAdjacency(map); } } } }
public void SetTileExplored(bool isExplored) { var matrixWidth = Tiles.GetUpperBound(0); var matrixHeight = Tiles.GetUpperBound(1); for (var rowIndex = 0; rowIndex < matrixHeight; rowIndex++) { for (var columnIndex = 0; columnIndex < matrixWidth; columnIndex++) { Tiles[columnIndex, rowIndex].IsExplored = false; Tiles[columnIndex, rowIndex].SetVisible(false); } } }
/// <summary> /// Generate a maze using the Recursive Backtracking's Algo /// the maze won't overlapse with rooms if they are present /// </summary> private void GenerateMaze() { Map = PierceArray(Map); // we first pierce the array with unvisited cell for (int x = 1; x < Map.GetUpperBound(0); x += 2) { for (int y = 1; y < Map.GetUpperBound(1); y += 2) { Tile t = Map[x, y]; if (Tile.Find(t) == t && !t.Room) { CarvePassageFrom(t); } } } }
public void CheckAllCells() { //Copy the tiles so we can change the Cell's tiles without screwing up the neighbor detection _tiles = Cells.CloneTiles(); for (int x = 0; x <= _tiles.GetUpperBound(0); x++) { for (int y = 0; y <= _tiles.GetUpperBound(0); y++) { short index = _tiles[x, y].Index; int neighborcount = GetNeighborsCount(x, y); //Toggle cell based on Life conditions if (index == ALIVE) { if (neighborcount < 2) { Cells.SetTile(x, y, --index); } else if (neighborcount > 3) { Cells.SetTile(x, y, --index); } } //Check to see if the cell is not alive or dead, //subtract its index if not to create the //death map else { if (index < ALIVE || index > DEAD) { index--; if (index < DEAD) { index = DEAD; } Cells.SetTile(x, y, index); } //Turn it on if it's alive if (neighborcount == 3) { Cells.SetTile(x, y, ALIVE); } } } } }
private static TileJson[,] ConvertToJsonMatrix(Tile[,] source) { var matrixWidth = source.GetUpperBound(0) + 1; var matrixHeight = source.GetUpperBound(1) + 1; var result = new TileJson[matrixWidth, matrixHeight]; for (var rowIndex = 0; rowIndex < matrixHeight; rowIndex++) { for (var columnIndex = 0; columnIndex < matrixWidth; columnIndex++) { result[columnIndex, rowIndex] = ConvertToTileJson(source[columnIndex, rowIndex], new VectorBase(columnIndex, rowIndex)); } } return(result); }
/// <summary> /// Get all the connectors in the map /// /// a connector is wall between a room and a wall or another room /// </summary> /// <param name="map">the map where to retrieve the connector</param> /// <returns>a List of tuple, containing coorinates for those connectors</returns> private static List <Tile> FindConnectors(Tile[,] map) { var connectors = new List <Tile>(); for (int x = 1; x < map.GetUpperBound(0) - 1; x++) { for (int y = 1; y < map.GetUpperBound(1) - 1; y++) { if (IsValidConnector(map, x, y)) { var connector = map[x, y]; connectors.Add(connector); } } } return(connectors); }
void doTick() { TtValue = 0; //TrValue = Math.Round( TValue/(50*50*0.4),5); TValue = new List <double>(); if (FrameBuffer.Instance.reset > 1) { frameBuffer = new FrameBuffer(0, 0, Console.WindowWidth, Console.WindowHeight - 1); } Tile[,] grid = Tile.grid; foreach (var item in grid) { if (item != null) { item.Update(); TValue.Add(item.Value); TtValue += item.Value; } } if (roc) { Random r = new Random(); int x = r.Next(grid.GetUpperBound(0) + 1); int y = r.Next(grid.GetUpperBound(1) + 1); Tile.grid[x, y].Value += r.Next(90) / (double)1; roc = false; } if (Console.KeyAvailable) { // Read one key ConsoleKeyInfo cki = Console.ReadKey(true); if (cki.Key == ConsoleKey.Spacebar || cki.Key == ConsoleKey.Enter) { Random r = new Random(); int x = r.Next(grid.GetUpperBound(0) + 1); int y = r.Next(grid.GetUpperBound(1) + 1); Tile.grid[x, y].Value += r.Next(90) / (double)10; //TrValue = Math.Round(TValue.Average(), 5); } } TrValue = Math.Round(TValue.Average(), 5); }
private static void PutTerrainSources(Tile[,] tileMap, string texture, int lowBound, int upBound, string[] forbiddenTextures) { int xStart = 0; int yStart = 0; // Put some random starting points for sources on the map for (int i = 0; i < random.Next(lowBound, upBound); i++) { xStart = random.Next(0, tileMap.GetUpperBound(0)); yStart = random.Next(0, tileMap.GetUpperBound(1)); if (tileMap[xStart, yStart].Type == TexturePackerMonoGameDefinitions.texturePackerSpriteAtlas.Grass1 && !forbiddenTextures.Contains(tileMap[xStart, yStart].Type)) { tileMap[xStart, yStart].IsClear = false; tileMap[xStart, yStart].Type = texture; } else { i--; } } }
private Adjacencies GetAdjacency(Tile[,] map) { Adjacencies adj = new Adjacencies(); adj.N = (GridPos.Y > 0) && map[GridPos.X, GridPos.Y - 1] is Blob && ((Blob)map[GridPos.X, GridPos.Y - 1])?.BlobGroup == BlobGroup; adj.E = (GridPos.X < map.GetUpperBound(0)) && map[GridPos.X - 1, GridPos.Y] is Blob && ((Blob)map[GridPos.X - 1, GridPos.Y])?.BlobGroup == BlobGroup; adj.W = (GridPos.X > 0) && map[GridPos.X + 1, GridPos.Y] is Blob && ((Blob)map[GridPos.X + 1, GridPos.Y])?.BlobGroup == BlobGroup; adj.S = (GridPos.Y < map.GetUpperBound(1)) && map[GridPos.X, GridPos.Y + 1] is Blob && ((Blob)map[GridPos.X, GridPos.Y + 1])?.BlobGroup == BlobGroup; return(adj); }
void GenTerrainChain(int amount, int chainLenght, bool walkableSet, string iconSet, ConsoleColor colorset) { Random r = new Random(); int[] genPos; for (int i = 0; i < amount; i++) { genPos = new int[2] { r.Next(1, width), r.Next(1, height) }; for (int j = 0; j < chainLenght; j++) { map[GetTile(genPos[0], genPos[1]).pos[0], GetTile(genPos[0], genPos[1]).pos[1]] = new Tile(new int[2] { genPos[0], genPos[1] }, walkableSet, iconSet, colorset); int dim = r.Next(2); genPos[dim] = Q.Clamp(1, map.GetUpperBound(dim) - 1, genPos[dim] + r.Next(-1, 2)); } } }
public Stage(Tile[,] tiles, Shadow[,] shadows, bool[,] explored, List <Item> items, List <Actor> actors, VectorBase lastHeroPosition, double abundance) { Tiles = tiles; Shadows = shadows; Explored = explored; var width = Tiles.GetUpperBound(0) + 1; var height = Tiles.GetUpperBound(1) + 1; _actorsByTile = new Actor[width, height]; foreach (var actor in actors) { AddActor(actor); } Items = items; LastHeroPosition = lastHeroPosition; Abundance = abundance; }
public void CheckAllCells() { //Copy the tiles so we can change the Cell's tiles without screwing up the neighbor detection _tiles = Cells.CloneTiles(); for (int x = 0; x <= _tiles.GetUpperBound(0); x++) { for (int y = 0; y <= _tiles.GetUpperBound(0); y++) { short index = _tiles[x, y].Index; int neighborcount = GetNeighborsCount(x, y); //Toggle cell based on Life conditions if (index == ALIVE) { if (neighborcount < 2) Cells.SetTile(x, y, --index); else if (neighborcount > 3) Cells.SetTile(x, y, --index); } //Check to see if the cell is not alive or dead, //subtract its index if not to create the //death map else { if (index < ALIVE || index > DEAD) { index--; if (index < DEAD) index = DEAD; Cells.SetTile(x, y, index); } //Turn it on if it's alive if (neighborcount == 3) Cells.SetTile(x, y, ALIVE); } } } }
/// <summary> /// Return the list of T's neighbors /// </summary> /// <param name="T"></param> /// <returns></returns> private static List <Tile> Neighbors(Tile T) { var res = new List <Tile>(); if (T.X + 1 <= _map.GetUpperBound(0) && _map[T.X + 1, T.Y].IsFloor()) { res.Add(_map[T.X + 1, T.Y]); } if (T.X - 1 >= _map.GetLowerBound(0) && _map[T.X - 1, T.Y].IsFloor()) { res.Add(_map[T.X - 1, T.Y]); } if (T.Y + 1 <= _map.GetUpperBound(1) && _map[T.X, T.Y + 1].IsFloor()) { res.Add(_map[T.X, T.Y + 1]); } if (T.Y - 1 >= _map.GetLowerBound(1) && _map[T.X, T.Y - 1].IsFloor()) { res.Add(_map[T.X, T.Y - 1]); } // diagonal if (T.X + 1 <= _map.GetUpperBound(0) && T.Y + 1 <= _map.GetUpperBound(1) && res.Contains(_map[T.X + 1, T.Y]) && res.Contains(_map[T.X, T.Y + 1]) && _map[T.X + 1, T.Y + 1].IsFloor()) { res.Add(_map[T.X + 1, T.Y + 1]); } if (T.X + 1 <= _map.GetUpperBound(0) && T.Y - 1 >= _map.GetLowerBound(1) && res.Contains(_map[T.X + 1, T.Y]) && res.Contains(_map[T.X, T.Y - 1]) && _map[T.X + 1, T.Y - 1].IsFloor()) { res.Add(_map[T.X + 1, T.Y - 1]); } if (T.X - 1 >= _map.GetLowerBound(0) && T.Y - 1 >= _map.GetLowerBound(1) && res.Contains(_map[T.X - 1, T.Y]) && res.Contains(_map[T.X, T.Y - 1]) && _map[T.X - 1, T.Y - 1].IsFloor()) { res.Add(_map[T.X - 1, T.Y - 1]); } if (T.X - 1 >= _map.GetLowerBound(0) && T.Y + 1 <= _map.GetUpperBound(1) && res.Contains(_map[T.X - 1, T.Y]) && res.Contains(_map[T.X, T.Y + 1]) && _map[T.X - 1, T.Y + 1].IsFloor()) { res.Add(_map[T.X - 1, T.Y + 1]); } return(res); }
/// <summary> /// Generates the grid. /// </summary> public void GenerateGrid() { _tiles = new Tile[Game1.MAXX, Game1.MAXY]; Vector2 spacing = new Vector2 (Tiles.GRIDWIDTH/ 2f, Tiles.GRIDHEIGHT / 2f); spacing.X = (float)Math.Round (spacing.X, 0); spacing.Y = (float)Math.Round (spacing.Y, 0); //Our point of influence to make the center of the city. _influencepoint = new Point (Assets.Random.Next (0, Game1.MAXX), Assets.Random.Next (0, Game1.MAXY)); List<Point> corners = new List<Point> () {new Point(0,0), new Point(0, _tiles.GetUpperBound(1)), new Point(_tiles.GetUpperBound(0), 0), new Point(_tiles.GetUpperBound(0), _tiles.GetUpperBound(1))}; int largest = 0; foreach (Point c in corners) { int distance = GetInfluenceDistance(c); if(distance > largest) largest = distance; } _largestinfluencedistance = largest; for (int x = 0; x < Game1.MAXX; x++) { for (int y = 0; y < Game1.MAXY; y++) { Tile t = new Tile(); t.SetIndex(Tiles.GRASS); t.DrawRect = GetTileDrawRect(x,y); t.ShowInfluence = InfluenceViewIsOn; t.InfluenceColor = new Color ( 1f * GetInfluencePercent(new Point(x,y)),1f - GetInfluencePercent (new Point(x, y)),1f - GetInfluencePercent (new Point(x, y))); _tiles[x,y] = t; } } }
public void CheckAllCells() { //Copy the tiles so we can change the Cell's tiles without screwing up the neighbor detection _tiles = Cells.CloneTiles(); List<Color> colorsToMix = new List<Color>(); for (int x = 0; x <= _tiles.GetUpperBound(0); x++) { for (int y = 0; y <= _tiles.GetUpperBound(0); y++) { colorsToMix.Clear(); Tile tile = _tiles[x, y]; short index = tile.Index; int neighborcount = GetNeighborsCount(x, y); //Toggle cell based on Life conditions if (index == ALIVE) { if (neighborcount < 2) Cells.SetTile(x, y, --index); else if (neighborcount > 3) Cells.SetTile(x, y, --index); } //Check to see if the cell is not alive or dead, //subtract its index if not to create the //death map else { if (index < ALIVE || index > DEAD) { index--; if (index < DEAD) index = DEAD; Cells.SetTile(x, y, index); } //Turn it on if it's alive if (neighborcount == 3) { Cells.SetTile(x, y, new Tile(ALIVE) { Color = new RGBColor(0, 0, 0, 1) }); } } if (Cells.GetTile(x, y).Index == ALIVE) { //Now we get neighbor colors, mix them by average hue, output a new color. colorsToMix = colorsToMix.Concat(GetNeighborColors(x, y)).ToList(); float newhue = 0f; //find lowest and highest bands float minhue = float.MaxValue; float maxhue = 0f; foreach (var color in colorsToMix) { float colorhue = color.ToHSVColor().H; minhue = Math.Min(minhue, colorhue); maxhue = Math.Max(maxhue, colorhue); } //Check if the tile was dead, and now is alive if (Cells.GetTile(x, y).Index == ALIVE && _tiles[x, y].Index != ALIVE) { foreach (var color in colorsToMix) { float colorhue = color.ToHSVColor().H; newhue = colorhue - minhue; //now that we have that, we will subtract each color from our min, average it, and get our new color. newhue /= colorsToMix.Count(); newhue += minhue; } Tile newtile = new Tile(ALIVE); newtile.Color = ColorMath.HSVtoRGB(new HSVColor(newhue, 1, 1, 1, ColorOutOfBoundsAction.WrapAround)); Cells.SetTile(x, y, newtile); } else if (Cells.GetTile(x, y).Index == ALIVE) { //Get our tile's color HSVColor tilecolor = ColorMath.RGBtoHSV(_tiles[x, y].Color); foreach (var color in colorsToMix) { float colorhue = color.ToHSVColor().H; //find out which direction is the closest route to the color. float route = (Math.Abs(colorhue - tilecolor.H) < Math.Abs(1 - colorhue - tilecolor.H)) ? colorhue - tilecolor.H : 1 - colorhue - tilecolor.H; newhue += route; } //TODO: Update color blending with Cie-LCH, for which you need to implment XYZ and Cie-Lab //now that we have that, we will subtract each color from our min, average it, and get our new color. newhue /= colorsToMix.Count(); newhue += tilecolor.H; Tile newtile = new Tile(ALIVE); newtile.Color = ColorMath.HSVtoRGB(new HSVColor(newhue, 1, 1, 1)); newtile.Color.Action = ColorOutOfBoundsAction.WrapAround; Cells.SetTile(x, y, newtile); } } } } }
public MoveInfo TryToMove(Direction direction, Tile[,] level) { int newX = Position.X; int newY = Position.Y; int maxX = level.GetUpperBound(0); int maxY = level.GetUpperBound(1); switch (direction) { case Direction.North: newY = Position.Y - 1; break; case Direction.South: newY = Position.Y + 1; break; case Direction.West: newX = Position.X - 1; break; case Direction.East: newX = Position.X + 1; break; case Direction.NorthWest: newX = Position.X - 1; newY = Position.Y - 1; break; case Direction.NorthEast: newX = Position.X + 1; newY = Position.Y - 1; break; case Direction.SouthWest: newX = Position.X - 1; newY = Position.Y + 1; break; case Direction.SouthEast: newX = Position.X - 1; newY = Position.Y + 1; break; } // Check level bounds so we don't try to walk off the level if (newX < 0 || newX > maxX || newY < 0 || newY > maxY) { return(MoveInfo.OutOfBounds); } else if (level[newX, newY].HasMonster) { return(MoveInfo.Occupied); } else if (level[newX, newY] is Wall) { return(MoveInfo.BlockedByWall); } else { Point newPos = new Point(newX, newY); Position = newPos; return(MoveInfo.Success); } }
public override void Update(GameTime gt) { base.Update(gt); GetDependency <Body>(DEPENDENCY_BODY).Width = TileSize.X * (_tiles.GetUpperBound(0) + 1); GetDependency <Body>(DEPENDENCY_BODY).Height = TileSize.Y * (_tiles.GetUpperBound(1) + 1); }