public CellState[,] ComputeNextGeneration() { _nextGenMatrix = (CellState[, ])_matrix.Clone(); ApplyRules(); return(_nextGenMatrix); }
public void NextTick() { CellState[,] newField = (CellState[, ])field.Clone(); RefreshAliveNeighbours(); Parallel.For(0, Rows, i => { Parallel.For(0, Columns, j => { int aliveNeighbours = this.aliveNeighbours[i, j]; if (field[i, j] == CellState.Dead && birthCount.Contains(aliveNeighbours)) { newField[i, j] = CellState.Alive; } if (field[i, j] == CellState.Alive && !stayAliveCount.Contains(aliveNeighbours)) { newField[i, j] = CellState.Dead; } }); }); previousField = (CellState[, ])field.Clone(); field = newField; }
private static CellState[,] StepForestFire(CellState[,] state, int f, int p) { /* Clone our old state, so we can write to our new state * without changing any values in the old state. */ var newState = (CellState[, ])state.Clone(); int height = state.GetLength(0); int width = state.GetLength(1); for (int i = 1; i < height - 1; i++) { for (int o = 1; o < width - 1; o++) { /* * Check the current cell. * * If it's empty, give it a 1/p chance of becoming a tree. * * If it's a tree, check to see if any neighbors are burning. * If so, set the cell's state to burning, otherwise give it * a 1/f chance of combusting. * * If it's burning, set it to empty. */ switch (state[i, o]) { case CellState.Empty: if (Random.Next(0, p) == 0) { newState[i, o] = CellState.Tree; } break; case CellState.Tree: if (IsNeighbor(state, i, o, CellState.Burning) || Random.Next(0, f) == 0) { newState[i, o] = CellState.Burning; } break; case CellState.Burning: newState[i, o] = CellState.Empty; break; } } } return(newState); }
private CellState[,] StepWires(CellState[,] state) { var newState = (CellState[, ])state.Clone(); int height = state.GetLength(0); int width = state.GetLength(1); for (int i = 1; i < height - 1; i++) { for (int o = 1; o < width - 1; o++) { switch (state[i, o]) { case CellState.Wire: int count = CountNeighbor(state, i, o, CellState.Head); if (count == 1 || count == 2) { newState[i, o] = CellState.Head; } break; case CellState.Head: newState[i, o] = CellState.Tail; break; case CellState.Tail: newState[i, o] = CellState.Wire; break; } } } sourceDelay--; if (sourceDelay < 0) { for (int i = 0; i < sources.Count; ++i) { newState[sources[i].y, sources[i].x] = CellState.Head; } sourceDelay = int.MaxValue; } return(newState); }
/// <summary> /// Returns a copy of this board. /// </summary> /// <returns>A copy of this board.</returns> public Board Copy() { // Use memberwise clone to do a shallow copy of our board // We will have to copy the reference types by hand below Board boardCopy = MemberwiseClone() as Board; // Copy the move sequence to an array Pos[] movesArray = moves.ToArray(); // Create a new move sequence in the copied board... boardCopy.moves = new Stack <Pos>(); // ...and push the moves in reverse order they appear in the array for (int i = movesArray.Length - 1; i >= 0; i--) { boardCopy.moves.Push(movesArray[i]); } // Copy the board's contents onto the new board object boardCopy.board = board.Clone() as CellState[, ]; // Return a copy of the board return(boardCopy); }
IEnumerator RecursiveMiniMaxing(CellState[,] state, CellState player, Action action, Score score) { Debug.Log("Player " + player + " simulating state: " + PrintState(state)); yield return(null); // If this is a terminal state, return the value. if (Wins(state, player)) { score.value = 10; yield break; } else if (Loses(state, player)) { score.value = -10; yield break; } else if (Draws(state, player)) { score.value = 0; yield break; } // Check if mini or maxi bool isMaximizing = player == aiPlayer; int bestScoreValue = 100000 * (isMaximizing ? -1 : 1); for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { // Valid action where empty if (state[i, j] == CellState.E) { // Test that action CellState[,] nextState = (CellState[, ])state.Clone(); nextState[i, j] = player; // Get the next score Score nextScore = new Score(); Action nextAction = new Action(); yield return(StartCoroutine(RecursiveMiniMaxing(nextState, (CellState)((int)player * -1), nextAction, nextScore))); nextScore.value *= -1; // Update the max if (nextScore.value * (isMaximizing ? 1 : -1) > bestScoreValue * (isMaximizing ? 1 : -1)) { bestScoreValue = nextScore.value; action.action_i = i; action.action_j = j; } } } } Debug.Log("MAX score: " + bestScoreValue + "\nBest action: " + action); score.value = bestScoreValue; }
private CellState[,] StepForestFire(CellState[,] state, int f, int p) { /* Clone our old state, so we can write to our new state * without changing any values in the old state. */ var newState = (CellState[, ])state.Clone(); int height = state.GetLength(0); int width = state.GetLength(1); bool playtick = false; bool playwrong = false; for (int i = 1; i < height - 1; i++) { for (int o = 1; o < width - 1; o++) { /* * Check the current cell. * * If it's empty, give it a 1/p chance of becoming a tree. * * If it's a tree, check to see if any neighbors are burning. * If so, set the cell's state to burning, otherwise give it * a 1/f chance of combusting. * * If it's burning, set it to empty. */ switch (state[i, o]) { case CellState.Empty: if (Random.Range(0, p) == 0) { newState[i, o] = CellState.Tree; playwrong = true; } if (IsNeighbor(state, i, o, CellState.Tree) && Random.Range(0, nearbyTreeChance) == 0) { newState[i, o] = CellState.Tree; playwrong = true; } break; case CellState.Tree: if (IsNeighbor(state, i, o, CellState.Burning) || Random.Range(0, f) == 0) { newState[i, o] = CellState.Burning; playtick = true; } break; case CellState.Burning: newState[i, o] = CellState.Empty; break; } } } if (playtick) { SHGUI.current.PlaySound(SHGUIsound.tick); } else if (playwrong) { SHGUI.current.PlaySound(SHGUIsound.wrong); } return(newState); }