void GenerateTunnels(TILE tile, int numOfTunnels, int holeSize, int tMinSize, int tMaxSize, int minDepth, int maxDepth) { for (int i = 0; i < numOfTunnels; i++) { int xpos = 0; int ypos = 0; int tSize = Random.Range(tMinSize, tMaxSize); xpos = Random.Range(0, width); ypos = Random.Range(minDepth, maxDepth); for (int j = 0; j < tSize; j++) { for (int x = -holeSize; x <= holeSize; x++) { for (int y = -holeSize; y <= holeSize; y++) { xpos += x; ypos += y; if (xpos >= 0 && xpos < width && ypos >= minDepth && ypos < maxDepth) // Verify borders { data[xpos, ypos].type = tile; } } } xpos += Mathf.RoundToInt(GetNoise(i, j, 2f, 1f) * Random.Range(-1, 2)); ypos += Mathf.RoundToInt(GetNoise(i, j, 2f, 1f) * Random.Range(-1, 2)); } } }
void GenerateMinerals(TILE tile, int numOfMinerals, int mMinSize = 4, int mMaxSize = 4, int minDepth = 0, int maxDepth = 16) { for (int i = 0; i < numOfMinerals; i++) { { int xpos = 0; int ypos = 0; int mSize = Random.Range(mMinSize, mMaxSize); xpos = Random.Range(0, width); ypos = Random.Range(minDepth, maxDepth); for (int j = 0; j < mSize; j++) { { if (xpos >= 0 && xpos < width && ypos >= minDepth && ypos < maxDepth) // Verify borders { if (data[xpos, ypos].type != tile) // Verify data { data[xpos, ypos].type = tile; } } xpos += Random.Range(-1, 2); ypos += Random.Range(-1, 2); } } } } }
void GenerateMines(TILE tile, int numOfMines = 128, int mMinSize = 4, int mMaxSize = 256, int minDepth = 0, int maxDepth = 16) { int holeSize = 1; for (int i = 0; i < numOfMines; i++) { int mSize = Random.Range(mMinSize, mMaxSize); int xpos = Random.Range(0, width); int ypos = Random.Range(minDepth, maxDepth); for (int j = 0; j < mSize; j++) { for (int x = -holeSize; x <= holeSize; x++) { for (int y = -holeSize; y <= holeSize; y++) { if (!(x == 0 && y == 0)) { Vector2 tilePos = new Vector2(xpos + x, ypos + y); if (tilePos.x >= 0 && tilePos.x < width && tilePos.y >= minDepth && tilePos.y < maxDepth) { if (data[(int)tilePos.x, (int)tilePos.y].type != TILE.AIR) { data[(int)tilePos.x, (int)tilePos.y].type = tile; } } } } } xpos += Random.Range(-1, 2); ypos += Random.Range(-1, 2); } } }
private void DrawTile(Vector2 pos, TILE type) { if (type == TILE.NULL) { return; } GameObject tile = new GameObject($"Tile {pos.ToString()}"); var spriteRenderer = tile.AddComponent <SpriteRenderer>(); tile.transform.position = new Vector3(pos.x, pos.y, 5); tile.transform.localScale = new Vector3(0.9f, 0.9f); switch (type) { case TILE.EMPTY: case TILE.ENEMY: case TILE.PLAYER: spriteRenderer.sprite = tileSprite; spriteRenderer.color = new Color(1, 1, 1); tile.transform.parent = mapTiles.transform; break; case TILE.WALL: spriteRenderer.sprite = tileSprite; spriteRenderer.color = new Color(0.1f, 0.1f, 0.1f); tile.transform.parent = mapTiles.transform; break; default: break; } }
public Bitmap GetTileResource(TileState state, TileColor color) { TILE tileAdapt = TILE.NormalBlackTile; if (color == TileColor.Black) { switch (state) { case TileState.Normal: tileAdapt = TILE.NormalBlackTile; break; case TileState.Selected: tileAdapt = TILE.SelectBlackTile; break; case TileState.LastMove: tileAdapt = TILE.LastMoveBlackTile; break; case TileState.AvalableMove: tileAdapt = TILE.AvalBlackTile; break; } } else { switch (state) { case TileState.Normal: tileAdapt = TILE.NormalWhiteTile; break; case TileState.Selected: tileAdapt = TILE.SelectWhiteTile; break; case TileState.LastMove: tileAdapt = TILE.LastMoveWhiteTile; break; case TileState.AvalableMove: tileAdapt = TILE.AvalWhiteTile; break; } } return(this.tileStrategy.GetTile(tileAdapt)); }
void generatePlatform() { generateStart(); while (holesGenerated < numHoles) { TILE type = getRandomEnum <TILE> (); if (type == lastType) { continue; } switch (type) { case TILE.Hole: generateHole(); break; case TILE.Step: generateStep(); break; case TILE.Stair: generateStair(); break; default: generateFloor(); break; } lastType = type; } generateEnd(); }
public Bitmap GetTile(TILE type) { if (tiles.ContainsKey(type)) { return(tiles[type]); } return(null); }
private void GetCHKAll(BinaryWriter bw) { LoadString(); DDDTHG2.Clear(); MTXM = (ushort[])TILE.Clone(); //Doodad풀기 for (int i = 0; i < DD2.Count; i++) { CDD2 cDD2 = DD2[i]; DoodadPallet pallete = UseMapEditor.Global.WindowTool.MapViewer.tileSet.DoodadPallets[TILETYPE][cDD2.ID]; DD2ToMTXM(cDD2); CTHG2 cTHG2 = new CTHG2(); cTHG2.FLAG = pallete.dddFlags; cTHG2.X = cDD2.X; cTHG2.Y = cDD2.Y; cTHG2.ID = pallete.dddOverlayID; if (((cTHG2.FLAG & (0b1 << 12)) != 0) | ((cTHG2.FLAG & (0b1 << 13)) != 0)) { DDDTHG2.Add(cTHG2); } } TriggerSave(); //에디터로부터 CHK데이터를 가져오는 함수 for (int i = 0; i < cHKTokens.Count; i++) { if (cHKTokens[i].tokentype == TOKENTYPE.NULL) { GetCHK(bw, cHKTokens[i], TOKENTYPE.NULL); } } foreach (TOKENTYPE cHKTYPE in Enum.GetValues(typeof(TOKENTYPE))) { if (cHKTYPE != TOKENTYPE.NULL) { GetCHK(bw, new CHKToken(), cHKTYPE); } } }
// 특정한 타입의 타일 중 무작위로 하나를 고른다. // 적과 플레이어, 벽을 생성할 때 사용. public Vector2 GetRandomTilePos(TILE type) { List <Vector2> posArray = new List <Vector2>(); for (var i = 0; i < row; i++) { for (var j = 0; j < col; j++) { if (map[i, j] == type) { posArray.Add(new Vector2(i, j)); } } } int randPos = Random.Range(0, posArray.Count); return(posArray[randPos]); }
public void changeType(TILE type) { this.type = type; if (type == TILE.STONE) { texCoor = new int[] { 1, 0 }; hasCollider = true; } if (type == TILE.MOSSYSTONE) { texCoor = new int[] { 0, 0 }; hasCollider = true; } if (type == TILE.BLANK) { texCoor = new int[] { 63, 63 }; hasCollider = false; } if (type == TILE.STONEBG) { texCoor = new int[] { 1, 1 }; hasCollider = false; } if (type == TILE.MOSSYBG) { texCoor = new int[] { 0, 1 }; hasCollider = false; } if (type == TILE.BURNEDMOSSY) { texCoor = new int[] { 0, 2 }; hasCollider = true; } if (type == TILE.BURNEDSTONE) { texCoor = new int[] { 1, 2 }; hasCollider = true; } }
public ArrayList getPath(int fromX, int fromY, int toX, int toY) { bool localdebug = true; //don't forget to marry this up with the actors at some point :P // srcTile = getTile(fromX, fromY); if (localdebug) { printTile(srcTile); } if (srcTile.z == 0) { //this shouldn't happen after it's automated, only with bad user input... Console.WriteLine("Bad source tile, returning with no path..."); return myPath; } destTile = getTile(toX, toY); if (localdebug) { printTile(destTile); } if (destTile.z == 0) { //this means we have an object in the way (unless the coords are really bad, either way looking around for a good square can't hurt) //see if we can find a sqaure adjacent to this one that's open... TILE tempDest = getTile(toX, toY + 1); if (destTile.z == 0) { tempDest = getTile(toX, toY - 1); } if (destTile.z == 0) { tempDest = getTile(toX + 1, toY); } if (destTile.z == 0) { tempDest = getTile(toX - 1, toY); } if (destTile.z == 0) { tempDest = getTile(toX + 1, toY + 1); } if (destTile.z == 0) { tempDest = getTile(toX + 1, toY - 1); } if (destTile.z == 0) { tempDest = getTile(toX - 1, toY + 1); } if (destTile.z == 0) { tempDest = getTile(toX - 1, toY - 1); } if (destTile.z == 0) { Console.WriteLine("Bad destination tile, returning with no path..."); return myPath; } } for (int gridCount = 0; gridCount < myMapHeader.tile_map_x_len * myMapHeader.tile_map_y_len * 6 * 6; gridCount++) { TILE myTile = TILE_MAP[gridCount]; myTile.state = myStates.STATE_NONE; myTile.parentX = -1; myTile.parentY = -1; TILE_MAP[gridCount] = myTile; } pathCount = 0; addToOpenList(new TILE(), srcTile); bool pathFound = false; while (pathCount < MAXATTEMPTS) { TILE myTile = getNextOpenTile(); if (myTile.x == destTile.x && myTile.y == destTile.y) { pathFound = true; //Console.WriteLine("YAY, we found it!"); //Console.ReadLine(); break; } myPathTiles[pathCount] = myTile; addToOpenList(myTile, getTile(myTile.x, myTile.y + 1)); addToOpenList(myTile, getTile(myTile.x + 1, myTile.y + 1)); addToOpenList(myTile, getTile(myTile.x + 1, myTile.y)); addToOpenList(myTile, getTile(myTile.x + 1, myTile.y - 1)); addToOpenList(myTile, getTile(myTile.x, myTile.y - 1)); addToOpenList(myTile, getTile(myTile.x - 1, myTile.y - 1)); addToOpenList(myTile, getTile(myTile.x - 1, myTile.y)); addToOpenList(myTile, getTile(myTile.x - 1, myTile.y + 1)); pathCount++; } if (!pathFound || pathCount == 0) { myPath = new ArrayList(); Console.WriteLine("no path returned! :P"); } else { Console.WriteLine("path returned! :P" + "|" + pathCount); finishPath(); } Console.WriteLine("finshed path count:" + myPath.Count); return myPath; }
private void readHeightMap() { bool localdebug = false; // int tileCount = 0; int i; heightMap = myReader.ReadChars(myMapHeader.tile_map_x_len * myMapHeader.tile_map_y_len * 6 * 6); if (localdebug) { Console.WriteLine("height map read..." + heightMap.Length); Console.ReadLine(); } //insert the heights into mymap array for (int x = 0; x < myMapHeader.tile_map_x_len * 6; x++) { for (int y = 0; y < myMapHeader.tile_map_y_len * 6; y++) { i = y * myMapHeader.tile_map_x_len * 6 + x; TILE myTile = new TILE(); myTile.x = x; myTile.y = y; myTile.z = heightMap[i]; myTile.state = myStates.STATE_NONE; myTile.parentX = -1; myTile.parentY = -1; TILE_MAP[i] = myTile; TILE_MAPCount++; } } if (localdebug) { Console.WriteLine(TILE_MAPCount); Console.ReadLine(); } }
private TILE getNextOpenTile() { bool localdebug = false; if (localdebug) { // Console.WriteLine("before"); // printOpenTileList(); } //this will probably look ugly at first, the client code is very hard to understand here //so, going to copy it's logic as closely as possible, ignoring the fact that I haven't a clue what it's doing, lol TILE retTile = new TILE(); TILE tempTile = new TILE(); int i = 0, j = 0; bool done = false; if (OPEN_LISTCount == 0) { return new TILE(); } retTile = OPEN_LIST[1]; //swapping around tiles for some reason... heh retTile.state = myStates.PF_STATE_CLOSED; TILE myTempTile = TILE_MAP[retTile.y * myMapHeader.tile_map_x_len * 6 + retTile.x]; myTempTile.state = myStates.PF_STATE_CLOSED; TILE_MAP[retTile.y * myMapHeader.tile_map_x_len * 6 + retTile.x] = myTempTile; //this isn't working, let's see what we can replace it with OPEN_LIST[1] = OPEN_LIST[OPEN_LISTCount--]; j = 1; while (!done) { i = j; if (2 * i + 1 <= OPEN_LISTCount) { if (OPEN_LIST[i].f >= OPEN_LIST[2 * i].f) { j = 2 * i; } if (OPEN_LIST[j].f >= OPEN_LIST[2 * i + 1].f) { j = 2 * i + 1; } } else if (2 * i <= OPEN_LISTCount) { if (OPEN_LIST[i].f >= OPEN_LIST[2 * i].f) { j = 2 * i; } } if (i != j) { tempTile = OPEN_LIST[i]; OPEN_LIST[i] = OPEN_LIST[j]; OPEN_LIST[j] = tempTile; } else { done = true; } } if (localdebug) { // Console.WriteLine("after"); // printOpenTileList(); Console.Write("Choosing tile: "); printTile(retTile); Console.ReadLine(); } return retTile; }
private int distance(TILE thisGridMark, TILE thatGridMark) { //this is the heuristic function used to calculate distance int theDistance = 0; //PF_HEUR(a, b) ((PF_DIFF(a->x, b->x) + PF_DIFF(a->y, b->y)) * 10) //stolen from client code (same in redknight afaik...) theDistance = (difference(thisGridMark.x, thatGridMark.x) + difference(thisGridMark.y, thatGridMark.y)) * 10; return theDistance; }
private bool areDiagonal(TILE thisGridMark, TILE thatGridMark) { bool theyAreDiagonal = true; if ((thatGridMark.x == thisGridMark.x) || (thatGridMark.y == thisGridMark.y)) { theyAreDiagonal = false; } return theyAreDiagonal; }
private void addToOpenList(TILE current, TILE neighbor) { TILE nullTile = new TILE(); TILE tempTile = new TILE(); bool localdebug = false; if (localdebug) { printOpenTileList(); } if (neighbor.Equals(nullTile) || neighbor.z == 0 || (!current.Equals(nullTile) && difference(current.z, neighbor.z) > 2)) { return; } if (!current.Equals(nullTile)) { int myG = 0, myF = 0, myH = 0; bool diagonal = (neighbor.x != current.x && neighbor.y != current.y); myG = current.g + (diagonal ? 14 : 10); myH = distance(neighbor, destTile); myF = myG + myH; if (neighbor.state != myStates.STATE_NONE && myF >= neighbor.f) { return; } neighbor.f = myF; neighbor.g = myG; neighbor.parentX = current.x; neighbor.parentY = current.y; } else { neighbor.f = distance(srcTile, destTile); neighbor.g = 0; //can't just assign NULL here like the client is, and can't have pointers, so using -1,-1 to represent the NULL TILE neighbor.parentX = -1; neighbor.parentY = -1; } if (neighbor.state != myStates.PF_STATE_OPEN) { //adding state open here... neighbor.open_pos = ++OPEN_LISTCount; //neighbor.open_pos = OPEN_LIST.Count + 1; OPEN_LIST[neighbor.open_pos] = neighbor; } if (localdebug) { printOpenTileList(); } //sort them by their F value... while (neighbor.open_pos > 1) { //need to be updating the open_pos it appears... if (OPEN_LIST[neighbor.open_pos].f <= OPEN_LIST[neighbor.open_pos / 2].f) { tempTile = OPEN_LIST[neighbor.open_pos / 2]; OPEN_LIST[neighbor.open_pos / 2] = OPEN_LIST[neighbor.open_pos]; OPEN_LIST[neighbor.open_pos] = tempTile; neighbor.open_pos /= 2; } else { break; } } TILE myTempTIle = TILE_MAP[neighbor.y * myMapHeader.tile_map_x_len * 6 + neighbor.x]; myTempTIle.state = myStates.PF_STATE_OPEN; TILE_MAP[neighbor.y * myMapHeader.tile_map_x_len * 6 + neighbor.x] = myTempTIle; }
public Tile(TILE type, float x, float y, WALL wall) { this.type = type; this.wall = wall; switch (type) { case TILE.floor: anim = Animation.createSingleFrameAnimation("tiles/floor", new Vector2(x, y), 0.1f); break; case TILE.wall: switch (wall) { case WALL.bounce: anim = Animation.createSingleFrameAnimation("tiles/stickwall", new Vector2(x, y), 0.1f); break; case WALL.destr: anim = Animation.createSingleFrameAnimation("tiles/breakwall", new Vector2(x, y), 0.1f); break; case WALL.pass: anim = Animation.createSingleFrameAnimation("tiles/passwall", new Vector2(x, y), 1.0f); break; default: anim = Animation.createSingleFrameAnimation("tiles/wall", new Vector2(x, y), 0.1f); break; } break; } }
public TileData() { type = TILE.AIR; amount = 900; endurance = 0; }
public Tile(TILE type, float x, float y) { this.type = type; switch (type) { case TILE.floor: anim = Animation.createSingleFrameAnimation("tiles/floor", new Vector2(x, y), 0.1f); break; case TILE.wall: anim = Animation.createSingleFrameAnimation("tiles/wall", new Vector2(x, y), 0.1f); break; } }
//pathing methods public TILE getTile(int x, int y) { TILE myTile = new TILE(); if (x >= myMapHeader.tile_map_x_len * 6 || y >= myMapHeader.tile_map_y_len * 6 || x < 0 || y < 0) { //should probably tell the user about this... } else { myTile = (TILE)TILE_MAP[y * myMapHeader.tile_map_x_len * 6 + x]; } return myTile; }
public void Load(LitJson.JSONNode json) { int child = 0; int tileIndex = 0; foreach (LitJson.JSONNode node in json.Childs) { if (child == 0) { width = JsonReader.Int(node, "width"); height = JsonReader.Int(node, "height"); tiles = new TILE[width * height]; towerPositions = new List <COORD> (); } else { int y = child - 1; string line = node["line"]; for (int x = 0; x < width; ++x) { string c = line.Substring(x, 1); TILE t = ParseTile(c); tiles[tileIndex++] = t; if (t == TILE.START) { Assert.assert(startPosition == null); startPosition = new COORD(x, y); } if (t == TILE.A) { Assert.assert(extraPositionA == null); extraPositionA = new COORD(x, y); } if (t == TILE.B) { Assert.assert(extraPositionB == null); extraPositionB = new COORD(x, y); } if (t == TILE.C) { Assert.assert(extraPositionC == null); extraPositionC = new COORD(x, y); } if (t == TILE.D) { Assert.assert(extraPositionD == null); extraPositionD = new COORD(x, y); } if (t == TILE.TOWER) { towerPositions.Add(new COORD(x, y)); } } } ++child; } ValidatePositions(); }
public TileData(TileData tileData) { type = tileData.type; amount = tileData.amount; endurance = tileData.endurance; }
public void SetValues(TILE type, int amount, int endurance) { this.type = type; this.amount = amount; this.endurance = endurance; }
public void printTile(TILE myTile) { Console.WriteLine(myTile.x + "," + myTile.y + "," + myTile.f + "," + myTile.g + "," + myTile.parentX + "," + myTile.parentY); }
public Bitmap GetTile(TILE type) { return(commonTile.GetTile(type)); }