public GameGrid Clone() { return(new GameGrid(Width, Height) { gameArea = (Tile[, ])gameArea.Clone(), }); }
public void clear(Tile t) { oldGlyphs = (Tile[, ])glyphs.Clone(); cursorX = 0; cursorY = 0; for (int j = 0; j < height; j++) { for (int i = 0; i < width; i++) { glyphs[i, j] = t; } } }
void ShuffleGrid() { List <XY> xyList = new List <XY>(); Tile[,] tempGrid = (Tile[, ])Grid.Clone(); for (int x = 0; x < GridWidth; x++) { for (int y = 0; y < GridWidth; y++) { xyList.Add(new XY(x, y)); } } for (int x = 0; x < GridWidth; x++) { for (int y = 0; y < GridWidth; y++) { System.Random rnd = new System.Random(); int index = rnd.Next(xyList.Count); XY xy = xyList[index]; Grid[x, y].TileControl.Move(xy); //tiles for sure need to instantaneously switch, so i need a dummy grid tempGrid[xy.X, xy.Y] = Grid[x, y]; // xyList.RemoveAt(index); } } Grid = (Tile[, ])tempGrid.Clone(); //endlessly shuffling grid is f****n solved mate }
private void CycleArray(Tile[,] array, byte piecesIndex) { Tile[,] tempArray = (Tile[, ])array.Clone(); byte arrayIndex = piecesIndex; for (byte i = 0; i < tempArray.GetLength(0); i++) { for (byte j = 0; j < tempArray.GetLength(1); j++) { if (tempArray[i, j].placeble && !CheckForKills(tempArray, pieces[arrayIndex], new Vector2(i, j))) { tempArray[i, j].placeble = false; tempArray[i, j].pieceAttached = pieces[arrayIndex]; if (arrayIndex + 1 < pieces.Count) { CycleArray(PlacePieceOnBoard(tempArray, pieces[arrayIndex], new Vector2(i, j)), (byte)(arrayIndex + 1)); } else { Tile[,] addArray = (Tile[, ])tempArray.Clone(); possibilities.Add(addArray); } tempArray[i, j].placeble = true; tempArray[i, j].pieceAttached = null; } } } }
public GameState Duplicate() { GameState newGameState = new GameState(Tiles.Clone() as Tile[, ]); newGameState.Width = Width; newGameState.Height = Height; newGameState.Moves = new List <Move>(Moves); return(newGameState); }
private Tile[,] SetMovementPiecePlacement(List <Vector2> directions, Tile[,] tiles, Vector2 position) { Tile[,] tempTiles = (Tile[, ])tiles.Clone(); for (byte i = 0; i < directions.Count; i++) { Vector2 temp = position + directions[i]; if (temp.x >= 0 && temp.x < tempTiles.GetLength(0) && temp.y >= 0 && temp.y < tempTiles.GetLength(1)) { tempTiles[(int)temp.x, (int)temp.y].placeble = false; } } return(tempTiles); }
private Tile[,] PlacePieceOnBoard(Tile[,] tiles, ChessPieceClass piece, Vector2 position) { Tile[,] tempArray = (Tile[, ])tiles.Clone(); if (piece.pieceName == "King" || piece.pieceName == "Knight") { tempArray = SetMovementPiecePlacement(piece.moveDir, tempArray, position); } else { tempArray = DirectionalPiecePlacement(piece.moveDir, tempArray, position); } return(tempArray); }
public object Clone() { var result = (GameState)MemberwiseClone(); result.Map = (Tile[, ])Map.Clone(); result.Foods = new List <Food>(Foods.Select(f => (Food)f.Clone())); result.MyAnts = new List <MyAnt>(MyAnts.Select(a => (MyAnt)a.Clone())); result.MyAntPositions = new List <Location>(MyAntPositions.Select(ap => (Location)ap.Clone())); result.EnemyAnts = new List <Ant>(EnemyAnts.Select(a => (Ant)a.Clone())); result.Hills = new List <Hill>(Hills.Select(h => (Hill)h.Clone())); result.EnemyHills = new List <Hill>(EnemyHills.Select(h => (Hill)h.Clone())); return(result); }
public void embaralhar() { Tile[,] TilesCopia = (Tile[, ])tiles.Clone(); //aqui fez um clone da variavel de arrays tiles?sim // aqui o shuffle embaralha a matriz, dai tem q fazer a copia para embaralhar no mundo Utilities.Shuffle <Tile>(TilesCopia); //aqui o clone pode ou não estar vazio? //falta fazer //aqui os Tiles são GameObjects? for (int i = 0; i < tiles.GetLength(0); i++) { for (int j = 0; j < tiles.GetLength(1); j++) { if (TilesCopia != null) //este null quer dizer q a caixa tem lugar para guardar coisas? { if (TilesCopia.Length > 0) { tiles[i, j].transform.position = TilesCopia[i, j].transform.position; //para embaralhar neste caso pega o array matriz tiles e o iguala a sua copia? } } } } }
public void shuffle() { Tile[,] tilesCopia = (Tile[, ])tiles.Clone(); // aqui fez um clone do array Tile[,])tiles? Utilities.Shuffle <Tile>(tiles); /*for (int i = 0; i < tiles.GetLength(0); i++) * { * for (int j = 0; j < tiles.GetLength(1); j++) * { * if (tilesCopia != null) * { * if (tilesCopia.Length > 0) * { * tiles[i, j].transform.position = tilesCopia[i, j].transform.position; * } * } * } * }*/ }
public Game Move(Move move) { Tile[,] tiles = Tiles.Clone() as Tile[, ]; var game = new Game { Tiles = tiles }; if (move == null) { return(game); } if (move is Move) { var tile = game.GetTile(move.From); game.Set(move.From, Tile.Empty); game.Set(move.To, tile); } if (move is Eat) { foreach (var toEat in (move as Eat).Eaten) { game.Set(toEat, Tile.Empty); } } //Make a queen if (move.To.Row == 7 && game.GetTile(move.To) == Tile.White) { game.Set(move.To, Tile.QueenWhite); } if (move.To.Row == 0 && game.GetTile(move.To) == Tile.Black) { game.Set(move.To, Tile.QueenBlack); } return(game); }
private Tile[,] DirectionalPiecePlacement(List <Vector2> directions, Tile[,] tiles, Vector2 position) { Tile[,] tempTiles = (Tile[, ])tiles.Clone(); for (byte i = 0; i < directions.Count; i++) { bool outOfBounds = false; int multiplier = 1; while (!outOfBounds) { Vector2 temp = position + (directions[i] * multiplier); if (temp.x >= 0 && temp.x < tempTiles.GetLength(0) && temp.y >= 0 && temp.y < tempTiles.GetLength(1)) { tempTiles[(int)temp.x, (int)temp.y].placeble = false; multiplier++; } else { outOfBounds = true; } } } return(tempTiles); }
void AumentarIlhas() { //CLONAR O MUNDO PARA UM NOVO ARRAY Tile[,] mundoBack = (Tile[, ])mundo.Clone(); //LOOP PARA PERCORRER E ENCONTRAR APENAS AS ILHAS INICIAIS for (int x = 0; x < tamanho; x++) { for (int y = 0; y < tamanho; y++) { if (mundoBack[x, y].tipo == tilesTipos[1]) { //INICIAR O METODO RECURSIVO NUMA DAS ILHAS INICIAIS, PARA COM SORTE CRIAR OS CONTINENTES GRANDES //ESTA AQUI O UNICO SITIO ONDE COLOCAMOS O BOOL FORCE COMO TRUE PORQUE O METODO RECURSIVO //SO VERIFICA SE O TILE E AGUA, MAS AQUI FORÇAMOS A VERIFICAÇAO APESAR DE SER TILE DE TERRA mundo[x, y].AlterarTipo(this, x, y, tamanho, true); } } } }
/// <summary> /// Initializes a new map layer with an existing map /// </summary> /// <param name="map"></param> public MapLayer(TileMap parent, Tile[,] map) { this.parent = parent; this.map = (Tile[, ])map.Clone(); }
//read map file and init game class public void Load() { string[] line = File.ReadAllLines(@"Resources\map.txt"); H = line.Length; foreach (string str in line) { if (str.Length > W) W = str.Length; } map = new Tile[H, W]; for (int i = 0; i < H; i++) for (int j = 0; j < W; j++) map[i, j] = Tile.SPACE; for (int i = 0; i < line.Length; i++) for (int j = 0; j < line[i].Length; j++) { switch (line[i][j]) { case '#': map[i, j] = Tile.WALL; break; case '$': map[i, j] = Tile.BOX; break; case '.': map[i, j] = Tile.GOAL; break; case '@': map[i, j] = Tile.SPACE; px = ox = j; py = oy = i; break; } } initmap = (Tile[,]) map.Clone(); loadAtlas(); cha = char1[Move.STOP]; time = DateTime.Now; }
public Tile[,] GetDataClone() { return((Tile[, ])m_data.Clone()); }
/// <summary>constructs a tilemaps from a Tile[][].</summary> /// <param name="m"> a matrix of Tiles.</param> public TileMapImpl(Tile[,] m) { map = (Tile[, ])m.Clone(); }
public TileMap(int width, int height, Tile[,] tiles) { this.width = width; this.height = height; this.tiles = (Tile[, ])tiles.Clone(); }
/// <summary> /// Get a 2D byte array of 0s and 1s corresponding to floors and walls respectively. /// </summary> public byte[,] ToByteArray() { return((byte[, ])grid.Clone()); }
public MapLayer(Tile[,] map) { this.map = map.Clone() as Tile[, ]; }
public Tile[,] TilesClone() { return(tiles.Clone() as Tile[, ]); }
public MapLayer(Tile[,] map) { this.map = (Tile[, ])map.Clone(); }
/// <summary> /// Initializes a new instance of the <see cref="MapLayer"/> class. /// </summary> /// <param name="layerName"> The name of the layer. </param> /// <param name="map"> The map to make a layer from. </param> public MapLayer(string layerName, Tile[,] map) { this.LayerName = layerName; this.map = (Tile[, ])map.Clone(); }