+ );
+}
+
function Square(props) {
let className = "square";
- if (props.value) {
+ if (props.value.symbol) {
className += " occupied";
} else if (props.active) {
className += " open";
}
+ if (props.value.glyph) {
+ if (props.value.symbol === '+')
+ className += " glyph-plus";
+ else
+ className += " glyph-o";
+ }
+
+ if (props.last_move) {
+ className += " last-move";
+ }
+
const onClick = props.active ? props.onClick : null;
return (
- {props.value}
+ {props.value.symbol}
);
}
@@ -168,17 +359,36 @@ function Square(props) {
function MiniGrid(props) {
function grid_square(j) {
const value = props.squares[j];
+ const last_move = props.last_moves.includes(j);
+
+ /* Even if the grid is active, the square is only active if
+ * unoccupied. */
+ const square_active = (props.active && (value.symbol === null));
+
return (
props.onClick(j)}
/>
);
}
+ /* Even if my parent thinks I'm active because of the last move, I
+ * might not _really_ be active if I'm full. */
+ let occupied = 0;
+ props.squares.forEach(element => {
+ if (element.symbol)
+ occupied++;
+ });
+
+ let class_name = "mini-grid";
+ if (props.active && occupied < 9)
+ class_name += " active";
+
return (
-
+
{grid_square(0)}
{grid_square(1)}
{grid_square(2)}
@@ -194,11 +404,54 @@ function MiniGrid(props) {
class Board extends React.Component {
mini_grid(i) {
+ /* This mini grid is active only if both:
+ *
+ * 1. It is our turn (this.props.active === true)
+ *
+ * 2. One of the following conditions is met:
+ *
+ * a. This is this players first turn (last_two_moves[0] === null)
+ * b. This mini grid corresponds to this players last turn
+ * c. The mini grid that corresponds to the players last turn is full
+ */
+ let grid_active = false;
+ if (this.props.active) {
+ grid_active = true;
+ if (this.props.last_two_moves.length > 1) {
+ /* First index (0) gives us our last move, (that is, of the
+ * last two moves, it's the first one, so two moves ago).
+ *
+ * Second index (1) gives us the second number from that move,
+ * (that is, the index within the mini-grid that we last
+ * played).
+ */
+ const target = this.props.last_two_moves[0][1];
+ let occupied = 0;
+ this.props.squares[target].forEach(element => {
+ if (element.symbol)
+ occupied++;
+ });
+ /* If the target mini-grid isn't full then this grid is
+ * only active if it is that target. */
+ if (occupied < 9)
+ grid_active = (i === target);
+ }
+ }
+
+ /* We want to highlight each of the last two moves (both "+" and
+ * "o"). So we filter the last two moves that have a first index
+ * that matches this mini_grid and pass down their second index
+ * be highlighted.
+ */
+ const last_moves = this.props.last_two_moves.filter(move => move[0] === i)
+ .map(move => move[1]);
+
const squares = this.props.squares[i];
return (
this.props.onClick(i,j)}
/>
);
@@ -249,9 +502,12 @@ class Game extends React.Component {
game_info: {},
player_info: {},
other_players: [],
- squares: Array(9).fill(null).map(() => Array(9).fill(null)),
- moves: 0,
- next_to_play: "+"
+ squares: [...Array(9)].map(() => Array(9).fill({
+ symbol: null,
+ glyph: false
+ })),
+ moves: [],
+ next_to_play: "+",
};
}
@@ -286,21 +542,59 @@ class Game extends React.Component {
});
}
+ find_connected(mini_grid_index, position) {
+ /* TODO: Implement actual finding of connected squares here. */
+ let connected = Array(9).fill(false);
+
+ return connected;
+ }
+
+ detect_glyph(connected) {
+ /* TODO: Implement actual glyph detection here. */
+ return false;
+ }
+
receive_move(move) {
- if (this.state.moves === 81) {
+ const mini_grid_index = move[0];
+ const position = move[1];
+
+ /* Don't allow any moves after the board is full */
+ if (this.state.moves.length === 81) {
return;
}
+
+ /* Set the team's symbol into the board state. */
const symbol = team_symbol(this.state.next_to_play);
const new_squares = this.state.squares.map(arr => arr.slice());
- new_squares[move[0]][move[1]] = symbol;
+ new_squares[mini_grid_index][position] = {
+ symbol: symbol,
+ glyph: false
+ };
+
+ /* With the symbol added to the squares, we need to see if this
+ * newly-placed move forms a glyph or not. */
+ const connected = this.find_connected(mini_grid_index, position);
+ const is_glyph = this.detect_glyph(connected);
+
+ for (let i = 0; i < 9; i++) {
+ if (connected[i])
+ new_squares[mini_grid_index][i].glyph = is_glyph;
+ }
+
+ /* And append the move to the list of moves. */
+ const new_moves = [...this.state.moves, move];
+
+ /* Finally, compute the next player to move. */
let next_to_play;
if (this.state.next_to_play === "+")
next_to_play = "o";
else
next_to_play = "+";
+
+ /* And shove all those state modifications toward React. */
this.setState({
squares: new_squares,
- moves: this.state.moves + 1,
+ moves: new_moves,
next_to_play: next_to_play
});
}
@@ -328,7 +622,7 @@ class Game extends React.Component {
render() {
const state = this.state;
- const first_move = state.moves === 0;
+ const first_move = state.moves.length === 0;
const my_team = state.player_info.team;
var board_active;
@@ -393,9 +687,23 @@ class Game extends React.Component {
this.handle_click(i, j, first_move)}
/>