public static TileData[,] Rotate(this TileData[,] matrix, int rotation) { rotation = rotation % 360; int width = matrix.GetLength(0); int height = matrix.GetLength(1); switch (rotation) { case 0: break; case 90: matrix = Apply(matrix, height, false, width, true, (mat, y, x) => mat[x, y]); break; case 180: matrix = Apply(matrix, width, true, height, true, (mat, x, y) => mat[x, y]); break; case 270: matrix = Apply(matrix, height, true, width, false, (mat, y, x) => mat[x, y]); break; default: Debug.LogError("The rotation should be at a right angle"); break; } return(matrix); }
//Generates a randomized 2D int Array, containing numbers 1-5. private static int[,] generateWeight(int seed, TileData[,] tiles) { int length = tiles.GetLength(0); int height = tiles.GetLength(1); System.Random random = new System.Random(seed); int[,] weights = new int[length, height]; for (int i = 0; i < length; i++) { for (int j = 0; j < height; j++) { if (tiles[i, j] == null) { weights[i, j] = random.Next(2, 8); } else if (tiles[i, j].isBorder) { //Don't go through borders, if possible. weights[i, j] = 5; } else { //If this is part of a Room, then set its weight to one, to prefer already existing paths. weights[i, j] = 1; } } } return(weights); }
public void TestGetTileDataArray() { TileData[,] tileDataArray = _tileMapData.GetTileData(); Assert.AreEqual(MAP_SQUARE_SIZE, tileDataArray.GetLength(0)); Assert.AreEqual(MAP_SQUARE_SIZE, tileDataArray.GetLength(1)); }
public void SetTile(int column, int row, TileData T) { if (column >= 0 && row >= 0 && column < data.GetLength(0) && row < data.GetLength(1)) { data[column, row] = T; } }
public TileData getTileData(int i, int j) { if (i < 0 || j < 0 || i >= grid.GetLength(0) || j >= grid.GetLength(1)) { return(null); } return(grid[i, j]); }
public void AddModifiedTiles(TileData[,] tile) { for (int x = 0; x < tile.GetLength(0); x++) { for (int y = 0; y < tile.GetLength(1); y++) { myModifiedTiles.Add(new Tuple <float, float, float>(tile[x, y].GetPosition().X, tile[x, y].GetPosition().Y, tile[x, y].GetPosition().Z), tile[x, y]); } } }
/// <summary> /// Determine if tile is in range /// </summary> /// <param name="p"></param> /// <returns></returns> public bool IsValidTile(int x, int y) { if (x >= 0 && x < tileMap.GetLength(0) && y >= 0 && y < tileMap.GetLength(1) && tileMap[x, y].GetTileType() != TileType.impassableTile) { return(true); } return(false); }
/// <summary> /// /// </summary> /// <param name="data">x.length this width y.length this height</param> /// <param name="startWorldPos">left and down tile position</param> public Chunk(TileData[,] data, Vector2Int startWorldPos, World world) { Data = data; Bounds = new ChunkBound(startWorldPos, startWorldPos + new Vector2Int( data.GetLength(0) - 1, data.GetLength(1) - 1)); for (var x = 0; x < data.GetLength(0); x++) { for (var y = 0; y < data.GetLength(1); y++) { var tileData = data[x, y]; tileData.TargetBlock.Position = new Vector2Int(x, y) + startWorldPos; } } }
private void DrawTiles() { //Draw downtiles for (int x = newTileGrid.GetLength(0) - 1; x >= 0; x--) { for (int y = newTileGrid.GetLength(1) - 1; y >= 0; y--) { if (newTileGrid[x, y] != null) { TileDrawer.DrawTileAt(spriteBatch, newTileGrid[x, y].type, new Point(x, y)); } } } //Drawuptiles for (int x = newTileGrid.GetLength(0) - 1; x >= 0; x--) { for (int y = newTileGrid.GetLength(1) - 1; y >= 0; y--) { if (newTileGrid[x, y] != null) { TileDrawer.DrawTileRoofingAt(spriteBatch, newTileGrid[x, y].type, new Point(x, y)); } } } }
public Zone(Area area) { Random r = new Random(); this.Grass = new TileData(); this.Water = new TileData(); Grass.Sprite = new Graphics.Sprite("grass"); Water.Sprite = new Graphics.Sprite("water"); this.area = area; this.World = area.World; tileMap = new TileData[(int)area.ZoneSize.X, (int)area.ZoneSize.Y]; for (int y = 0; y < tileMap.GetLength(0); ++y) { for (int x = 0; x < tileMap.GetLength(1); ++x) { tileMap[y, x] = (x == 0) ? this.Grass : this.Water; } } }
public static TileData[,] Mirror(this TileData[,] matrix, int axis) { int width = matrix.GetLength(0); int height = matrix.GetLength(1); switch (axis) { case 0: matrix = Apply(matrix, width, true, height, false, (mat, x, y) => mat[x, y]); break; case 1: matrix = Apply(matrix, width, false, height, true, (mat, x, y) => mat[x, y]); break; default: Debug.LogError("The axis should be 0 or 1 : " + axis); break; } return(matrix); }
private void GenerateViews() { TileData[,] dataArray = _file.Data.TileArray; int xLength = dataArray.GetLength(0); int yLength = dataArray.GetLength(1); #region Define Grid GridLength rowHeight = new GridLength(50); GridLength colWidth = new GridLength(50); for (int y = 0; y < yLength; y++) { RowDefinition rowDef = new RowDefinition() { Height = rowHeight }; WorldGrid.RowDefinitions.Add(rowDef); } for (int x = 0; x < xLength; x++) { ColumnDefinition colDef = new ColumnDefinition() { Width = colWidth }; WorldGrid.ColumnDefinitions.Add(colDef); } #endregion for (int y = 0; y < yLength; y++) { for (int x = 0; x < xLength; x++) { TileData data = dataArray[x, y]; WorldTileControl tileControl = new WorldTileControl(data); Grid.SetColumn(tileControl, x); Grid.SetRow(tileControl, y); WorldGrid.Children.Add(tileControl); tileControl.MouseLeftButtonDown += TileControl_MouseDown; } } }
/// <summary> /// Reparent tile game objects into world space so that their transforms can be /// maintained when they are placed into their new chunks. /// </summary> /// <param name="map">New tile map.</param> private void ReparentTileGameObjectsIntoWorldSpace(TileData[,] map) { int mapRows = map.GetLength(0); int mapColumns = map.GetLength(1); for (int row = 0; row < mapRows; ++row) { this.taskProgress += this.taskIncrement; InternalUtility.ProgressHandler("Rebuilding Tile System", "Clearing existing chunks.", this.taskProgress); for (int column = 0; column < mapColumns; ++column) { var tile = map[row, column]; if (tile == null || tile.Empty || tile.gameObject == null) { continue; } tile.gameObject.transform.SetParent(null); } } }
public void CreateBoard(int width, int height) { Assert.IsTrue(oldTiles.GetLength(0) == oldBalls.GetLength(0) && oldTiles.GetLength(1) == oldBalls.GetLength(1)); tiles = new TileData[width, height]; balls = new BallData[width, height]; for (int i = 0; i < width; i++) { for (int j = 0; j < height; j++) { if (oldBalls.GetLength(0) > i && oldBalls.GetLength(1) > j) { tiles[i, j] = oldTiles[i, j]; balls[i, j] = oldBalls[i, j]; } else { tiles[i, j] = TileData.GetNormalTile(); balls[i, j] = BallData.GetEmptyBall(); } } } UpdateModel(); }
private static void defaultRoomGen(Area area, int seed, ref TileData[,] tiles, ref List <Room> rooms) { System.Random random = new System.Random(seed); //Determine number of Rooms to make. int numOfRooms = random.Next(5, 10); int currentRoom = 0; int failures = 0; //While we still need more Rooms, and we've failed to make a room less than 5 times in a row. while (currentRoom < numOfRooms && failures < 6) { //Create random sized room. int xSize = random.Next(4, 8); int ySize = random.Next(4, 8); //Create random botLeft Point to place the Room. Point placement = new Point(random.Next(1, tiles.GetLength(0) - xSize - 1), random.Next(1, tiles.GetLength(1) - ySize - 1)); Room newRoom = new Room(area, placement, new Point(placement.x + xSize, placement.y + ySize)); bool roomFailed = false; //Test to ensure this Room doesn't overlap other rooms. foreach (Room r in rooms) { if (newRoom.intersects(r)) { roomFailed = true; break; } } if (!roomFailed) { //Place the Room as Tiles in the Area. placeRoom(ref tiles, newRoom); rooms.Add(newRoom); //Reset the failure count, since this was a success! failures = 0; currentRoom++; } else { failures++; } } }
public override bool IsValid() { if (balls.GetLength(0) != tiles.GetLength(0) || balls.GetLength(1) != tiles.GetLength(1)) { return(false); } else { return(CheckObjectives()); } }
public TileData GetTileUnderPointer() { if (mycam == null) { mycam = Camera.main; } Vector3 pos = mycam.ScreenToWorldPoint(SmartInput.inputPos); int x = (int)pos.x; int y = (int)pos.y; if (x >= 0 && x < myTiles.GetLength(0) && y >= 0 && y < myTiles.GetLength(1)) { return(myTiles[x, y]); } else { return(null); } }
// en faire une pour le terrain et une pour temperature / humidity ou whatever ? // pour pouvoir en afficher plusieurs d'un coup public static Texture2D GetTexture(TileData[,] tileDataMap, DrawMap drawMap, bool drawUnderwaterSteps, Biome[] biomes) { //TileData[,] tileDataMap = mapData.tileDataMap; int width = tileDataMap.GetLength(0); int height = tileDataMap.GetLength(1); Color biomeBorderColor = Color.black; // à mettre avec la suivante en public inspector terrain setting Color edgeColor = Color.white; Color cityColor = Color.magenta; // en fonction du thème couleur de la ville ? var texture = new Texture2D(width, height); Color[] pixels = new Color[width * height]; for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { // moyen de generaliser le drawing des edges et borders ici switch (drawMap) { case DrawMap.Height: //Set color range, 0 = black, 1 = white if (tileDataMap[x, y].isEdge) { pixels[x + y * width] = edgeColor; } else { pixels[x + y * width] = Color.Lerp(Color.black, Color.white, tileDataMap[x, y].terrainHeight); } break; case DrawMap.HeightType: if (tileDataMap[x, y].isBiomeBorder) { pixels[x + y * width] = biomeBorderColor; } else if (tileDataMap[x, y].isEdge && drawUnderwaterSteps) { pixels[x + y * width] = edgeColor; } else { pixels[x + y * width] = tileDataMap[x, y].terrainType.color; } break; // sur les trois qui suivent c chiant de pas voir les heights faut refaire des f° case DrawMap.Humidity: if (tileDataMap[x, y].isBiomeBorder) { pixels[x + y * width] = biomeBorderColor; } else if (tileDataMap[x, y].isEdge && drawUnderwaterSteps) { pixels[x + y * width] = edgeColor; } else { pixels[x + y * width] = tileDataMap[x, y].humidityType.color; } break; case DrawMap.Temperature: if (tileDataMap[x, y].isBiomeBorder) { pixels[x + y * width] = biomeBorderColor; } else if (tileDataMap[x, y].isEdge && drawUnderwaterSteps) { pixels[x + y * width] = edgeColor; } else { pixels[x + y * width] = tileDataMap[x, y].temperatureType.color; } break; case DrawMap.Biome: if (tileDataMap[x, y].isBiomeBorder) { pixels[x + y * width] = biomeBorderColor; } else if (tileDataMap[x, y].isEdge && drawUnderwaterSteps) { pixels[x + y * width] = edgeColor; } else { for (int i = 0; i < biomes.Length; i++) { if (biomes[i].biomeType == tileDataMap[x, y].biomeType) { pixels[x + y * width] = biomes[i].pixelColor; break; } } if (tileDataMap[x, y].terrainType.terrainTypeName == TerrainTypeName.DeepWater) { pixels[x + y * width] = tileDataMap[x, y].terrainType.color; } else if (tileDataMap[x, y].terrainType.terrainTypeName == TerrainTypeName.ShallowWater) { pixels[x + y * width] = tileDataMap[x, y].terrainType.color; } } break; case DrawMap.City: if (tileDataMap[x, y].isBiomeBorder) { pixels[x + y * width] = biomeBorderColor; } else if (tileDataMap[x, y].isEdge && drawUnderwaterSteps) { pixels[x + y * width] = edgeColor; } else if (tileDataMap[x, y].isCity) { pixels[x + y * width] = cityColor; } else { for (int i = 0; i < biomes.Length; i++) { if (biomes[i].biomeType == tileDataMap[x, y].biomeType) { pixels[x + y * width] = biomes[i].pixelColor; break; } } if (tileDataMap[x, y].terrainType.terrainTypeName == TerrainTypeName.DeepWater) { pixels[x + y * width] = tileDataMap[x, y].terrainType.color; } else if (tileDataMap[x, y].terrainType.terrainTypeName == TerrainTypeName.ShallowWater) { pixels[x + y * width] = tileDataMap[x, y].terrainType.color; } } break; } } } texture.SetPixels(pixels); texture.wrapMode = TextureWrapMode.Clamp; texture.Apply(); return(texture); }
public void LoadRegionsBasedOnPosition(Vector2 myPlayerVector) { float DisplayedRegionX = myDrawRegions.GetLength(0); float DisplayedRegionY = myDrawRegions.GetLength(1); }
private void CreateDetails() { for (int x = 0; x < tiles.GetLength(0); x++) { for (int y = 0; y < tiles.GetLength(1); y++) { Vector2Int pos = new Vector2Int(x, y); IList <Vector2Int> immediateTiles = new List <Vector2Int>(Utils.GetAdjCoordsArr(pos)) { pos }; if (SurroundedBy(immediateTiles, IsSandTile)) { if (Utils.r.Next(100) < 10) { SetDetail(pos, Detail.Palm, false); TileRegistry.GetInstance().SetPalmTile(pos); } else if (Utils.r.Next(100) < 1) { SetDetail(pos, Detail.DessertRock, false); TileRegistry.GetInstance().SetRockBeachTile(pos); } } else if (SurroundedBy(immediateTiles, IsGrassTile) || SurroundedBy(immediateTiles, IsCliffTile)) { if (Utils.r.Next(100) < 10) { SetDetail(pos, Detail.Tree, false); TileRegistry.GetInstance().SetTreeTile(pos); } else if (Utils.r.Next(100) < 1) { SetDetail(pos, Detail.Rock, false); TileRegistry.GetInstance().SetRockTile(pos); } } } } }
//Creates GameObjects of the 2D array, and displays them. Or if they're already created, just display them. public void showArea() { // Debug.Log("HERE"); if (!isCity) { //Don't make GameObjects, if this area is already created. if (!isCreated) { //Ensure that this area has been generated. If not, do the generation now. if (!isGenerated) { generateArea(); } //Determine the TileSet to be used. TileSet mySet; switch (group.biome) { //In the case of any of these Biomes, use the grassyPath Tile set, until we get new tile sets. case (Biome.C): case (Biome.HTML): case (Biome.PYTHON): mySet = LoadResources.Instance.grassyPath.GetComponent <TileSet>(); break; default: throw new System.MissingFieldException("Area does not have an Area Group!"); } objects = new List <Tile>(); portals = new List <Tile>(); GameObject parent = new GameObject(); parent.name = "Area Parent"; //Create the GameObjects by iterating through the information. for (int i = 0; i < tiles.GetLength(0); i++) { for (int j = 0; j < tiles.GetLength(1); j++) { //Do GameObject creation here. if (tiles[i, j] != null) { if (tiles[i, j].isTile) { //Create Tile Object Tile temp = (Tile)GameObject.Instantiate(mySet.tiles[0], new Vector3(i * 10, mySet.tiles[0].y, j * 10), Quaternion.identity); temp.transform.parent = parent.transform; temp.x = i; temp.y = j; objects.Add(temp); } else if (tiles[i, j].isBorder) { //Create Wall Object Tile temp = (Tile)GameObject.Instantiate(mySet.tiles[1], new Vector3(i * 10, mySet.tiles[1].y, j * 10), Quaternion.identity); temp.transform.parent = parent.transform; temp.x = i; temp.y = j; objects.Add(temp); } else if (tiles[i, j].isPortal) { //Create Portal Object. Tile temp = (Tile)GameObject.Instantiate(LoadResources.Instance.portal, new Vector3(i * 10, LoadResources.Instance.portal.y, j * 10), Quaternion.identity); switch (tiles[i, j].portalDirection) { case (Direction.UP): break; case (Direction.LEFT): temp.transform.eulerAngles = new Vector3(0, 270, 0); break; case (Direction.DOWN): temp.transform.eulerAngles = new Vector3(0, 180, 0); break; case (Direction.RIGHT): temp.transform.eulerAngles = new Vector3(0, 90, 0); break; } temp.gameObject.GetComponent <Portal>().dir = tiles[i, j].portalDirection; temp.x = i; temp.y = j; objects.Add(temp); portals.Add(temp); } } } } isHidden = false; } } else //else this is a city, so instantiate THE CITY PREFAB! MUAHAHA! { portals = new List <Tile>(); //TODO: Add the portals to the portal List here! GameObject temp = (GameObject)GameObject.Instantiate(LoadResources.Instance.city, new Vector3(0, 0, 0), Quaternion.identity); city = temp; GameObject portalParent = temp.transform.GetChild(0).gameObject; if (portalParent.name == "portals") { foreach (Tile p in portalParent.transform.GetComponentsInChildren <Tile>()) { portals.Add(p); } } isGenerated = true; isHidden = false; } /*if (isHidden) * {*/ //Go through each room in the area and spawn any objects in it System.Random random = new System.Random(areaSeed); foreach (Room r in rooms) { r.showRoom(random); } /* isHidden = false; * }*/ }
//Creates corridors from room to room,and returns the list of corridors. (Rooms tiles are not included in corridors). private static List <TileData> defaultConnect(int seed, ref TileData[,] tiles, ref List <Room> rooms) { //Generate the weight map for A*. int[,] weights = generateWeight(seed, tiles); List <TileData> corridors = new List <TileData>(); //Connect first Room to all others. for (int i = 1; i < rooms.Count; i++) { //Get starting point. (middle of start Room) Point start = rooms[0].getTopRight(); start = new Point(start.x - rooms[0].length / 2, start.y - rooms[0].height / 2); //Get ending point. (middle of other Room) Point end = rooms[i].getTopRight(); end = new Point(end.x - rooms[i].length / 2, end.y - rooms[i].height / 2); //Plan: //Add starting point to Open List. //Sort Open list by F value, which is the distance from the end (found by heuristic) + currentCost. //While Open List is NOT empty //Get next Point to calculate, and put it on closed list. //foreach neighbor to this nextPoint //If neighbor point is the final point, make connections and break. //If neighbor point is not walkable, continue. //If neighbor point is NOT on the open List, calc ALL it's moveCost values F,G,H, and set the next Point //as it's cameFrom point. //If neighbor point is ON the open List (and maybe the closed), //if this REALcost (G, not heuristic) from this nextPoint is better than //the one it already has, replace its cameFrom with next point, and re-calc its F,G,H //OpenList sorted by F values. PriorityQueue <int, path> openList = new PriorityQueue <int, path>(); pathMap map = new pathMap(tiles.GetLength(0), tiles.GetLength(1)); path startPath = map.getPath(start); startPath.cameFrom = null; //Starting point came From null. (this is a flag for later) startPath.openList = true; startPath.setValues(0, 0, 0); //Start point doesn't need values. openList.Enqueue(0, startPath); bool isFinished = false; while (!openList.IsEmpty && !isFinished) { path next = openList.DequeueValue(); next.closedList = true; foreach (path neighbor in next.getNeighbors()) { if (neighbor.position.Equals(end)) { //Do ending stuff! isFinished = true; neighbor.cameFrom = next; //Start function to get the path, and put the path into corridors, and put the corridors on the tile map. corridors.AddRange(getFinishedPath(neighbor, ref tiles)); break; } //If not walkable, then check for that here. (currently not possible) if (!neighbor.openList) { //PUT on open List. neighbor.openList = true; neighbor.cameFrom = next; neighbor.setValues(next.cost + weights[neighbor.position.x, neighbor.position.y], neighbor.position.tileDiff(end)); openList.Enqueue(neighbor.probableCost, neighbor); } else if (!neighbor.closedList) { //Compare its current values, and change em if need be. int newCost = next.cost + weights[neighbor.position.x, neighbor.position.y]; if (newCost < neighbor.cost) { //May not actually work... KeyValuePair <int, path> oldPair = new KeyValuePair <int, path>(neighbor.probableCost, neighbor); openList.Remove(oldPair); neighbor.setValues(newCost, neighbor.position.tileDiff(end)); openList.Enqueue(neighbor.probableCost, neighbor); } } } } //End of While Loop } //End of For Loop return(corridors); }