public void Populate() { //Setup Cells Grid and Paint Texture for (int y = 0; y < _controller.sizeY; y++) { for (int x = 0; x < sizeX; x++) { int range = Random.Range(0, 100); Cell.State state = Cell.State.Dead; if (range < 50) { state = Cell.State.Alive; texture2D.SetPixel(x, y, _controller.cellColor); } else { state = Cell.State.Dead; texture2D.SetPixel(x, y, Color.black); } cells[x, y] = new Cell(state, new Vector3Int(x, y, 0), texture2D, _controller.cellColor); } } for (int y = 0; y < _controller.sizeY; y++) { for (int x = 0; x < sizeX; x++) { cells[x, y].GetNeigbors(cells); } } texture2D.Apply(); }
private void setState(Cell.State state, Position position) { void Set(Cell.State s) { getCell(position).state = s; } var currentState = getState(position); switch (state) { case DUST when currentState == JEWEL: case JEWEL when currentState == DUST: Set(DUST_AND_JEWEL); break; case EMPTY: case DUST: case JEWEL: case DUST_AND_JEWEL: Set(state); break; default: throw new ArgumentOutOfRangeException(nameof(state), state, null); } }
public void Fill(Cell.State value) { for (int i = 0; i < m_grid.Length; ++i) { m_grid[i] = value; } }
public Cell Hunt() { for (int i = 0; i < m_grid.Length; ++i) { Cell curr = m_grid.GetCell(i); if (m_grid[i] != 0) { continue; } SetCurr(curr); m_owner.TakeSnapshot(); Cell next = m_grid.ChoiceNeighbor(curr, st => st != Cell.State.None); if (!next.IsValid()) { continue; } Cell.State dir = Cell.GetDir(curr, next); m_grid.AddState(curr, dir); m_grid.AddState(next, Cell.ToOppositeDir(dir)); curr.state = m_grid[curr]; m_owner.TakeSnapshot(); return(curr); } return(Cell.invalid); }
public override Grid Generate(int w, int h) { base.Generate(w, h); m_frontiers.Clear(); Mark(m_grid.GetRandom()); while (m_frontiers.Count > 0) { int index = m_frontiers[m_rnd.Next(m_frontiers.Count)]; m_frontiers.Remove(index); Cell curr = m_grid.GetCell(index); Cell next = m_grid.ChoiceNeighbor(curr, st => (st & Cell.State.Visited) != 0); if (next.IsValid()) { Cell.State dir = Cell.GetDir(curr, next); m_grid.AddState(curr, dir); m_grid.AddState(next, Cell.ToOppositeDir(dir)); m_owner.TakeSnapshot(); } Mark(curr); } SetCurr(Cell.invalid); m_owner.TakeSnapshot(); return(m_grid); }
//-------------private methods----------------// private bool CheckIfALineOfSameMarksIsCreated(IEnumerable <Cell> cells, Cell.State mark) { for (int i = 0; i < TicTacToeConstants.LINE_TABLE_DEF.GetLength(0); i++) { Cell[] cellsInOneLine = GetCellsInOneLine(cells, i); int sameCellsCount = 0; foreach (Cell cell in cellsInOneLine) { if (cell.CellState == mark) { sameCellsCount++; } else { break; } } if (sameCellsCount == 3) { return(true); } } return(false); }
public void CarvePassages(Cell curr) { SetCurr(curr); m_owner.TakeSnapshot(); Cell[] neighbors = m_grid.GetNeighbors(curr); if (neighbors.Length > 0) { for (int i = 0; i < neighbors.Length; ++i) { Cell next = neighbors[i]; if (m_grid[next] != 0) { continue; } Cell.State dir = Cell.GetDir(curr, next); m_grid.AddState(curr, dir); m_grid.AddState(next, Cell.ToOppositeDir(dir)); CarvePassages(next); } } }
// 周囲の生きているセルの数から次代の生死を判定する internal Cell.State GetNextState(Cell.State self, IList <Cell> neighbours) { int alives = neighbours.Count(cell => cell.Current == Cell.State.Alive); bool willBorn = alives == 3; bool isSurvive = alives == 2 && self == Cell.State.Alive; return((willBorn || isSurvive) ? Cell.State.Alive : Cell.State.Dead); }
private void display(Cell.State state, Position position, bool displayRobot = false) { var sprite = getSprite(state, position, displayRobot); Grid.SetColumn(sprite, position.x); Grid.SetRow(sprite, position.y); gridDisplay.Children.Add(sprite); }
private Cell InstantiateCell(Coords coords, Cell.State state) { var cellObject = Instantiate(config.cellPrefab, new Vector3(coords.x, 0, coords.z), Quaternion.identity, transform); cellObject.gameObject.SetActive(Cell.State.ALIVE.Equals(state)); return(new Cell(coords, state, cellObject)); }
// Génère et affiche un objet dans un endroit aléatoire de la grille. private void generate(Cell.State state) { Application.Current.Dispatcher.Invoke(() => { var randomPosition = new Position( random(MIN_X, MAX_X), random(MIN_Y, MAX_Y) ); setState(state, randomPosition); display(randomPosition); }); }
private Game.State ToggleGameStateForNextTurn(Cell.State mark) { if (mark == Cell.State.CROSS) { return(Game.State.NAUGHT_TURN); } else if (mark == Cell.State.NAUGHT) { return(Game.State.CROSS_TURN); } throw new TicTacToeStateException(mark); }
public Game.State GetGameStateWon(Cell.State mark) { if (mark == Cell.State.CROSS) { return(Game.State.CROSS_WON); } else if (mark == Cell.State.NAUGHT) { return(Game.State.NAUGHT_WON); } throw new TicTacToeStateException(mark); }
private Image getSprite(Cell.State state, Position position, bool displayRobot = false) { var image = new Image(); var bitmapImage = new BitmapImage(); var uri = getUri(state, position, displayRobot); bitmapImage.BeginInit(); bitmapImage.UriSource = new Uri(uri, UriKind.Relative); bitmapImage.EndInit(); image.Source = bitmapImage; return(image); }
public void MoveRow(int rowIndex) { RowData[] rowInfo = new RowData[(int)columns]; for (int j = 0; j < (int)columns; j++) { Cell.State st = cells[rowIndex, j].GetComponent <Cell>().state; Vector2 index = cells[rowIndex, j].GetComponent <Cell>().GetCellIndex; rowInfo[j] = new RowData(index, st); } for (int j = 0; j < (int)columns; j++) { if (rowInfo[j].state == Cell.State.NotAssigned) { if (rowIndex - 1 != -1) { if (cells[rowIndex - 1, j].GetComponent <Cell>().GetState == Cell.State.Assigned) { blocks[rowIndex - 1, j].GetComponent <Block>().ChangePosition(cells[rowIndex, j].transform.position, new Vector2(rowIndex, j)); blocks[rowIndex, j] = blocks[rowIndex - 1, j]; cells[rowIndex - 1, j].GetComponent <Cell>().state = Cell.State.NotAssigned; cells[rowIndex, j].GetComponent <Cell>().state = Cell.State.Assigned; //blocks[rowIndex - 1, j].GetComponent<Block>().ChangeState(Block.State.Moving); isDone = false; if (rowIndex == 9) { blocks[rowIndex, j].GetComponent <Block>().state = Block.State.Fallen; blocks[rowIndex, j].GetComponent <Block>().UnSubscribeInputController(); blocks[rowIndex, j].GetComponent <Block>().CheckCollision(); } else if (rowIndex != 9) { if (cells[rowIndex + 1, j].GetComponent <Cell>().GetState == Cell.State.Assigned && blocks[rowIndex + 1, j].GetComponent <Block>().state == Block.State.Fallen) { blocks[rowIndex, j].GetComponent <Block>().state = Block.State.Fallen; blocks[rowIndex, j].GetComponent <Block>().UnSubscribeInputController(); blocks[rowIndex, j].GetComponent <Block>().CheckCollision(); } } } } } else { blocks[rowIndex, j].GetComponent <Block>().state = Block.State.Fallen; blocks[rowIndex, j].GetComponent <Block>().UnSubscribeInputController(); blocks[rowIndex, j].GetComponent <Block>().CheckCollision(); } } }
private char EncodeState(Cell.State state) { switch (state) { case Cell.State.ALIVE: return(ALIVE); case Cell.State.DEAD: return(DEAD); default: return('x'); } }
public void SetState(Cell.State state) { this.state = state; switch (this.state) { case State.Dead: texture2D.SetPixel(gridPos.x, gridPos.y, deadColor); break; case State.Alive: texture2D.SetPixel(gridPos.x, gridPos.y, liveColor); break; default: break; } }
public void Walk(Cell curr) { Cell next = m_grid.ChoiceNeighbor(curr); while (next.IsValid()) { Cell.State dir = Cell.GetDir(curr, next); m_grid.AddState(curr, dir); m_grid.AddState(next, Cell.ToOppositeDir(dir)); curr = next; next = m_grid.ChoiceNeighbor(curr); SetCurr(curr); m_owner.TakeSnapshot(); } }
public Game.State CalculateGameState(TicTacToe ticTacToe, Cell.State mark) { if (mark == Cell.State.BLANK) { throw new TicTacToeStateException(mark); } bool isTicTacToeWon = CheckIfALineOfSameMarksIsCreated(ticTacToe.Cells, mark); if (isTicTacToeWon) { return(GetGameStateWon(mark)); } bool isDraw = CheckIfBoardIsAlreadyFull(ticTacToe.Cells); if (isDraw) { return(Game.State.DRAW); } return(ToggleGameStateForNextTurn(mark)); }
private string getUri(Cell.State state, Position pos, bool displayRobot = false) { // Est-ce que l'on souhaite afficher le sprite du robot en plus de la cellule courante ? bool DisplayRobot() { return(!displayRobot && pos.x == robotPosition.x && pos.y == robotPosition.y); } switch (state) { case DUST: return(DisplayRobot() ? "images/wall-e-and-dust.jpg" : "images/dust.jpg"); case JEWEL: return(DisplayRobot() ? "images/wall-e-and-jewels.jpg" : "images/jewels.jpg"); case DUST_AND_JEWEL: return(DisplayRobot() ? "images/wall-e-and-dust-and-jewels.jpg" : "images/dust-and-jewels.jpg"); case EMPTY: return(DisplayRobot() ? "images/wall-e.jpg" : "images/empty.png"); default: throw new ArgumentOutOfRangeException(nameof(state), state, null); } }
public static Cell.State[][] CreateBaseState(int w, int h) { var rng = new Random(Seeder); var source = new Cell.State[h][]; for (int y = 0; y < h; y++) { source[y] = new Cell.State[w]; Cell.State[] row = source[y]; for (int x = 0; x < row.Length; x++) { int max = (int)Cell.State.MAX; //if (x < 5 || x > 15 || // y < 5 || y > 15) // max = (int)Cell.State.Dead; row[x] = (Cell.State)rng.Next(max); } } return(source); }
public void SetState(Cell.State state) { CellState = state; }
public RowData(Vector2 index, Cell.State st) { cellIndex = index; state = st; }
public void SetState(int x, int y, Cell.State state) { m_grid[Cell.ToIndex(x, y, Width)] = state; }
public void AddState(Cell cell, Cell.State state) { m_grid[Cell.ToIndex(cell.x, cell.y, Width)] |= state; }
private bool Process_Group(Group group) { /* To describe this process, let's use the example group of size 10 with hint '4 3' * * What we want is to figure out all possible solutions, and then use that to determine * * */ /* Count how many sections we have * * Sections are 'on, on, on, on', 'off, on, on, on', 'off', 'off' * * if a section has an 'on' in it, it's an 'on section'. Otherwise it's an 'off section'. * * The only wiggle-room we have in this solution is where the two 'off' sections go. * */ // Count how many 'on' sections and 'off' sections we have in this group. int total_cell_count = group.Cells.Length; int on_section_count = group.Group_Clue.Group_Sizes.Length; int off_section_count = total_cell_count; int total_section_count; { for (int i = 0; i < on_section_count; i++) { off_section_count -= group.Group_Clue.Group_Sizes[i]; if (i > 0) { off_section_count -= 1; } } total_section_count = on_section_count + off_section_count; } // Build the list of possible permutations List <int[]> permutations = new List <int[]>(); { int[] permutation = new int[total_section_count]; for (int i = 0; i < permutation.Length; i++) { permutation[i] = (i < off_section_count ? 0 : 1); // TODO: make these 'on' and off' for code readability. } do { permutations.Add(permutation.Copy()); } while (permutation.Get_Next_Permutation()); } // convert each permutation back to a possibile solution for the group List <Cell.State[]> possibilities = new List <Cell.State[]>(); { foreach (int[] permutation in permutations) { Cell.State[] possibility = Convert_Permutation_To_Possibility( group.Group_Clue.Group_Sizes, permutation); // But only count possibilities that are valid given the current group state. if (Is_Valid_Possibility(possibility, group.Cells)) { possibilities.Add(possibility); } } } // Compute the union of all valid possibilities Cell.State[] union_of_possibilities = new Cell.State[total_cell_count]; { for (int cell_index = 0; cell_index < total_cell_count; cell_index++) { union_of_possibilities[cell_index] = Cell.State.maybe; bool cell_can_possibly_be_on = false; bool cell_can_possibly_be_off = false; foreach (Cell.State[] possibility in possibilities) { switch (possibility[cell_index]) { case Cell.State.on: cell_can_possibly_be_on = true; break; case Cell.State.off: cell_can_possibly_be_off = true; break; } } if (cell_can_possibly_be_on && !cell_can_possibly_be_off) { union_of_possibilities[cell_index] = Cell.State.on; } else if (cell_can_possibly_be_off && !cell_can_possibly_be_on) { union_of_possibilities[cell_index] = Cell.State.off; } else { union_of_possibilities[cell_index] = Cell.State.maybe; } } } // See if we can change anything in the group with our newfound knowledge bool changed_something = false; for (int cell_index = 0; cell_index < total_cell_count; cell_index++) { // TODO detect that the board is wrong! User made a mistake trying to solve something. if (union_of_possibilities[cell_index] != Cell.State.maybe && union_of_possibilities[cell_index] != group.Cells[cell_index].state) { group.Cells[cell_index].state = union_of_possibilities[cell_index]; changed_something = true; } } return(changed_something); /* * 1. Build list of all possibilities * * collect the cells into sections: * Say hint is '2 3' in a 10x10 grid * Sections would be: * 1 instance of: 'on,on' * 1 instance of: 'off,on,on,on' * 4 instances of: 'off' * So the question now comes down to where to put the 4 free-floating 'off's * * to represent this specific case, we're going to try to solve: * * list all permutations of '110000' * 1 = is one of the sections with an 'on' * These are all the same for the purposes of permutations * because we know their order already from the hints. * 0 = one of the 'off' sections * These are all the same because they're identical. * * So now we just need to list through the permutations of '110000' * Ex: 000011, 000101, 000110, 001001, 001010, 001100, 010001, etc * In C++, std::next_permutation does this! * https://helloacm.com/the-next-permutation-algorithm-in-c-stdnext_permutation/ * https://stackoverflow.com/questions/11483060/stdnext-permutation-implementation-explanation * * So implement that, and then transform back from the numbers to the final. * Ex: * We have a permutations: 000101 * Converted back to the sections: ['off', 'off', 'off', 'on,on', 'off', 'off,on,on,on'] * Final: off,off,off,on,on,off,off,on,on,on * * * 2. Throw out permutations that are impossible based on the current state of the board. * ex: permutation is 'off, on, on, off', but board is 'maybe, maybe, maybe, on' * These permutation isn't possible since the board has 'on' in the last spot. * * 3. Loop through remaining permutations to compute their 'union' * ex: if the two permutations were: * 'off, on, on, off' * 'off, off, on, on' * The union is: * 'off, maybe, on, maybe' * * 4. Any non-maybes in the 'union' get set into the board's cells. */ }
public override Grid Generate(int w, int h) { base.Generate(w, h); m_edges.Clear(); m_sets = new int[w * h]; for (int y = 0; y < h; ++y) { for (int x = 0; x < w; ++x) { int index = Cell.ToIndex(x, y, w); m_sets[index] = index; if (y > 0) { m_edges.Add(new Cell(x, y, Cell.State.N)); } if (x > 0) { m_edges.Add(new Cell(x, y, Cell.State.W)); } } } // shuffle for (int i = 0, count = m_edges.Count; i < count; ++i) { int index = m_rnd.Next(count - i); Cell temp = m_edges[i]; m_edges[i] = m_edges[index]; m_edges[index] = temp; } while (m_edges.Count > 0) { Cell curr = m_edges[0]; Cell next = Cell.invalid; switch (curr.state) { case Cell.State.N: next = new Cell(curr.x, curr.y - 1, Cell.State.None); break; case Cell.State.W: next = new Cell(curr.x - 1, curr.y, Cell.State.None); break; } int cSetId = m_sets[Cell.ToIndex(curr, w)]; int nSetId = m_sets[Cell.ToIndex(next, w)]; m_edges.RemoveAt(0); if (cSetId != nSetId) { // combine sets for (int i = 0; i < m_sets.Length; ++i) { if (m_sets[i] == nSetId) { m_sets[i] = cSetId; } } Cell.State dir = Cell.GetDir(curr, next); m_grid.AddState(curr, dir); m_grid.AddState(next, Cell.ToOppositeDir(dir)); SetCurr(curr); m_owner.TakeSnapshot(); } } SetCurr(Cell.invalid); m_owner.TakeSnapshot(); return(m_grid); }