public int ValueFromCellState(ECellState state) { var value = 0; switch (state) { case ECellState.Vide: value = 0; break; case ECellState.Occupe: value = 1; break; case ECellState.Plouf: value = 2; break; case ECellState.Touche: value = 3; break; case ECellState.Coule: value = 4; break; } return(value); }
private void DealWithHealthyHitCoordinates(ECellState[,] board, int x, int y, ICollection <Ship> ships) { foreach (var ship in ships) { if (ship.HealthyCoords.Any(p => p.SequenceEqual(new[] { x, y }))) { ship.HitCoords.Add(ship.HealthyCoords.Find(p => p.SequenceEqual(new[] { x, y }))); ship.HealthyCoords.Remove(ship.HealthyCoords.Find(p => p.SequenceEqual(new[] { x, y }))); if (ship.HealthyCoords.Count == 0) { foreach (var hitCoord in ship.HitCoords) { board[hitCoord[0], hitCoord[1]] = ECellState.Sunk; } LatestMoveResult = ECellState.Sunk; ship.IsSunk = true; } else { board[x, y] = ECellState.Hit; } break; } } }
/// <summary> /// Checks the neighbor states and calculates own state /// </summary> public void CheckNeighbors() { #region Debugging // Debug for checking correct neighbor assignments if (m_list_neighbors.Count != 8) { Debug.Log(m_ArrPos.x + " " + m_ArrPos.y); } #endregion int neighborsAlive = 0; // Total number of living neighbors // Calculate total number of living neighbors foreach (CCellBehaviour neighbor in m_list_neighbors) { if (neighbor.State == ECellState.ALIVE) { neighborsAlive += 1; } } if (State == ECellState.DEAD && neighborsAlive == m_settings.Resurrect) // Revive a if dead and rules are met { State = ECellState.ALIVE; } else if (neighborsAlive < m_settings.DieLowerLimit || neighborsAlive > m_settings.DieUpperLimit && State == ECellState.ALIVE) // Die according to set rules { State = ECellState.DEAD; } }
public void InsertBoat(ECellState shipType, int quantity) { for (int i = 0; i < quantity; i++) { BattleShip.Ships1.Add(shipType); BattleShip.Ships2.Add(shipType); } }
public Ship(ECellState shipType, int shipSize, List <int[]> healthyCoords) { ShipType = shipType; ShipSize = shipSize; IsSunk = false; HealthyCoords = healthyCoords; HitCoords = new List <int[]>(); }
private static string CellString(ECellState cellState) { return(cellState switch { ECellState.Empty => "~", ECellState.Bomb => "X", // ECellState.Boat => "B", _ => "-" });
private void SwitchFunc(ECellState[,] board, int x, int y, ICollection <Ship> ships) { switch (board[x, y]) { case ECellState.Carrier: LatestMoveResult = ECellState.Hit; DealWithHealthyHitCoordinates(board, x, y, ships); break; case ECellState.Battleship: LatestMoveResult = ECellState.Hit; DealWithHealthyHitCoordinates(board, x, y, ships); break; case ECellState.Submarine: LatestMoveResult = ECellState.Hit; DealWithHealthyHitCoordinates(board, x, y, ships); break; case ECellState.Cruiser: LatestMoveResult = ECellState.Hit; DealWithHealthyHitCoordinates(board, x, y, ships); break; case ECellState.Patrol: LatestMoveResult = ECellState.Hit; DealWithHealthyHitCoordinates(board, x, y, ships); break; case ECellState.Empty: board[x, y] = ECellState.Miss; LatestMoveResult = ECellState.Miss; break; case ECellState.Hit: LatestMoveResult = ECellState.Miss; break; case ECellState.Miss: LatestMoveResult = ECellState.Miss; break; case ECellState.Sunk: LatestMoveResult = ECellState.Miss; break; default: throw new ArgumentOutOfRangeException(); } }
/** <summary> Simulates the next step. </summary> */ private SimulationStep SimulateNextStep() { performance_stopwatch_.Start(); // Since the simulation is basically a function that outputs a new grid I need a new array to store the new states of the cell // in order to avoid interferences on the current state of the game grid if new cells spawn or some die. // This array will then become the new game grid. ECellState[, ] ret_next_step_game_grid = new ECellState[cell_grid_.GetLength(0), cell_grid_.GetLength(1)]; // Counts the neighbors of each cell and spawns or kills based on the rules of the game. byte local_neighbors_count; for (int cycle_row_index = 0; cycle_row_index < cell_grid_.GetLength(0); cycle_row_index++) { for (int cycle_column_index = 0; cycle_column_index < cell_grid_.GetLength(1); cycle_column_index++) { local_neighbors_count = getNeighborsCount(cycle_row_index, cycle_column_index); // Count == 3 => New cell // Count < 2 => Cell dies // Count > 3 => Cell dies // Else => The same value as the original step is applied. if (local_neighbors_count == 3) { ret_next_step_game_grid[cycle_row_index, cycle_column_index] = ECellState.ALIVE; } else if (local_neighbors_count < 2) { ret_next_step_game_grid[cycle_row_index, cycle_column_index] = ECellState.DEAD; } else if (local_neighbors_count > 3) { ret_next_step_game_grid[cycle_row_index, cycle_column_index] = ECellState.DEAD; } else { ret_next_step_game_grid[cycle_row_index, cycle_column_index] = cell_grid_[cycle_row_index, cycle_column_index]; } } } cell_grid_ = ret_next_step_game_grid; performance_stopwatch_.Stop(); float elapsed_time = performance_stopwatch_.ElapsedMilliseconds; performance_stopwatch_.Reset(); return(new SimulationStep(ret_next_step_game_grid, elapsed_time)); }
private void Awake() { m_settings = GetComponentInParent <CPlaygroundBehaviour>().Settings; m_Sprite = GetComponent <SpriteRenderer>(); if (Random.Range(0, 101) <= m_settings.AliveChance) // Randomly select start state by chance { State = ECellState.ALIVE; } else { State = ECellState.DEAD; } }
public void OnCellClicked() { Image cellImage = GetComponent<Image>(); switch (m_cellState) { case ECellState.Inactive: // do nothing break; case ECellState.Unchecked: // determine randomly to go to Empty or Mine state bool DidIWinThisGameOfMinesweepEr = (Random.Range(0, 2) == 0) ? (true) : (false); if (DidIWinThisGameOfMinesweepEr) // you won { m_cellState = ECellState.Empty; if (cellImage) { cellImage.sprite = EmptySprite; } } else // you lost { m_cellState = ECellState.Mine; if (cellImage) { cellImage.sprite = MineSprite; } } break; case ECellState.Empty: break; case ECellState.Mine: break; case ECellState.Flag: break; default: break; } }
private static string CellString(ECellState cellState) { return(cellState switch { ECellState.Empty => "~", ECellState.Bomb => "O", ECellState.Hit => "X", ECellState.Patrol => "P", ECellState.Cruiser => "C", ECellState.Submarine => "S", ECellState.Battleship => "B", ECellState.Carrier => "A", ECellState.Custom0 => "0", ECellState.Custom1 => "1", ECellState.Custom2 => "2", ECellState.Custom3 => "3", ECellState.Custom4 => "4", ECellState.Custom5 => "5", ECellState.Custom6 => "6", ECellState.Custom7 => "7", ECellState.Custom8 => "8", ECellState.Custom9 => "9", _ => "-" });
public CCellContent(bool alternatorInitialValue, ECellState state) { mAlternator = alternatorInitialValue; mState = state; }
//PLACING SHIPS public bool PlaceShip(int startRow, int endRow, int startCol, int endCol, ICollection <ECellState> playerShips, ECellState[,] board) { var lastRowIndex = _y - 1; var lastColIndex = _x - 1; var shipLength = (int)playerShips.ToArray()[0]; ECellState shipType = playerShips.ToArray()[0]; var desiredPlacementSize = 0; for (int i = startRow; i < endRow + 1; i++) { for (int j = startCol; j < endCol + 1; j++) { if (board[i, j] == ECellState.Empty) { desiredPlacementSize += 1; } } } List <int[]> shipCoords2 = new List <int[]>(); if (desiredPlacementSize.Equals(shipLength)) { var thCellInShip = 0; for (int i = startRow; i < endRow + 1; i++) { for (int j = startCol; j < endCol + 1; j++) { if (board[i, j] == ECellState.Empty) { var cellPositionOnBoard = CheckEdgeTouching(i, j, lastRowIndex, lastColIndex); var cellsTouched = 0; switch (thCellInShip) { case 0: { if (TouchingRule == ETouchingRule.CanNotTouch) { cellsTouched = SwitchTouchFunctionNoTouchAllowed(cellPositionOnBoard, board, i, j); } else if (TouchingRule == ETouchingRule.CornersCanTouch) { cellsTouched = SwitchTouchFunctionCornersTouchAllowedFirstCell(cellPositionOnBoard, board, i, j); } else if (TouchingRule == ETouchingRule.CanTouch) { cellsTouched = 0; } if (cellsTouched == 0) { board[i, j] = shipType; shipCoords2.Add(new[] { i, j }); thCellInShip++; } else { return(false); } break; } case > 0: { if (TouchingRule == ETouchingRule.CanTouch) { cellsTouched = 0; } else if (TouchingRule == ETouchingRule.CanNotTouch) { cellsTouched = SwitchTouchFunctionNoTouchAllowed(cellPositionOnBoard, board, i, j); } else if (TouchingRule == ETouchingRule.CornersCanTouch && thCellInShip == shipLength) { cellsTouched = SwitchTouchFunctionCornersTouchAllowedFirstCell(cellPositionOnBoard, board, i, j) + 1; } // this 2 is a bit fishy if (cellsTouched <= 1 || cellsTouched == 2) { //PLACE board[i, j] = shipType; shipCoords2.Add(new[] { i, j }); thCellInShip++; } else { foreach (var coord in shipCoords2) { board[coord[0], coord[1]] = ECellState.Empty; } shipCoords2.Clear(); return(false); } break; } default: return(false); } } thCellInShip++; } } if (Player1Ships.Count < ShipCountPerPlayer) { Ships1 = Ships1.Skip(1).ToArray(); Player1Ships.Add(new Ship(shipType, shipLength, shipCoords2)); return(true); } else { _nextMoveByPlayer2 = false; Ships2 = Ships2.Skip(1).ToArray(); Player2Ships.Add(new Ship(shipType, shipLength, shipCoords2)); return(true); } } return(false); }
public Cell() { CellState = ECellState.Dead; }
public void OnStatusClicked() { m_cellState = ECellState.Unchecked; Image cellImage = GetComponent<Image>(); if (cellImage) { cellImage.sprite = UncheckedSprite; } Button cellButton = GetComponent<Button>(); if (cellButton) { cellButton.interactable = true; } // TODO -- a game state class attached to a dummy object should also receive this information -- including for wins and losses }
/// <summary> /// Chỉ có thể thay đổi đc cell state thông qua hàm SetCellState /// </summary> /// <param name="cellState"></param> public void SetCellState(ECellState cellState) { this.State = cellState; }
public Ship(int width) { Width = width; CellState = GetCellState(width); Name = CreateName(width); }
// Use this for initialization void Start() { m_cellState = ECellState.Inactive; Button cellButton = GetComponent<Button>(); if (cellButton) { cellButton.interactable = false; } }