Add support for detecting glyph shapes
[lmno.games] / scribe / scribe.jsx
1 function team_symbol(team) {
2   if (team === "+")
3     return "+";
4   else
5     return "o";
6 }
7
8 function undisplay(element) {
9   element.style.display="none";
10 }
11
12 function add_message(severity, message) {
13   message = `<div class="message ${severity}" onclick="undisplay(this)">
14 <span class="hide-button" onclick="undisplay(this.parentElement)">&times;</span>
15 ${message}
16 </div>`;
17   const message_area = document.getElementById('message-area');
18   message_area.insertAdjacentHTML('beforeend', message);
19 }
20
21 /*********************************************************
22  * Handling server-sent event stream                     *
23  *********************************************************/
24
25 const events = new EventSource("events");
26
27 events.onerror = function(event) {
28   if (event.target.readyState === EventSource.CLOSED) {
29     setTimeout(() => {
30       add_message("danger", "Connection to server lost.");
31     }, 1000);
32   }
33 };
34
35 events.addEventListener("game-info", event => {
36   const info = JSON.parse(event.data);
37
38   window.game.set_game_info(info);
39 });
40
41 events.addEventListener("player-info", event => {
42   const info = JSON.parse(event.data);
43
44   window.game.set_player_info(info);
45 });
46
47 events.addEventListener("player-enter", event => {
48   const info = JSON.parse(event.data);
49
50   window.game.set_other_player_info(info);
51 });
52
53 events.addEventListener("player-update", event => {
54   const info = JSON.parse(event.data);
55
56   if (info.id === window.game.state.player_info.id)
57     window.game.set_player_info(info);
58   else
59     window.game.set_other_player_info(info);
60 });
61
62 events.addEventListener("move", event => {
63   const move = JSON.parse(event.data);
64
65   window.game.receive_move(move);
66 });
67
68 events.addEventListener("game-state", event => {
69   const state = JSON.parse(event.data);
70
71   window.game.reset_board();
72
73   for (let square of state.moves) {
74     window.game.receive_move(square);
75   }
76 });
77
78 /*********************************************************
79  * Game and supporting classes                           *
80  *********************************************************/
81
82 const scribe_glyphs = [
83   {
84     name: "Single",
85     squares: [1,0,0,
86               0,0,0,
87               0,0,0]
88   },
89   {
90     name: "Double",
91     squares: [1,1,0,
92               0,0,0,
93               0,0,0]
94   },
95   {
96     name: "Line",
97     squares: [1,1,1,
98               0,0,0,
99               0,0,0]
100   },
101   {
102     name: "Pipe",
103     squares: [0,0,1,
104               1,1,1,
105               0,0,0]
106   },
107   {
108     name: "Squat-T",
109     squares: [1,1,1,
110               0,1,0,
111               0,0,0]
112   },
113   {
114     name: "4-block",
115     squares: [1,1,0,
116               1,1,0,
117               0,0,0]
118   },
119   {
120     name: "T",
121     squares: [1,1,1,
122               0,1,0,
123               0,1,0]
124   },
125   {
126     name: "Cross",
127     squares: [0,1,0,
128               1,1,1,
129               0,1,0]
130   },
131   {
132     name: "6-block",
133     squares: [1,1,1,
134               1,1,1,
135               0,0,0]
136   },
137   {
138     name: "Bomber",
139     squares: [1,1,1,
140               0,1,1,
141               0,0,1]
142   },
143   {
144     name: "Chair",
145     squares: [0,0,1,
146               1,1,1,
147               1,0,1]
148   },
149   {
150     name: "J",
151     squares: [0,0,1,
152               1,0,1,
153               1,1,1]
154   },
155   {
156     name: "Earring",
157     squares: [0,1,1,
158               1,0,1,
159               1,1,1]
160   },
161   {
162     name: "House",
163     squares: [0,1,0,
164               1,1,1,
165               1,1,1]
166   },
167   {
168     name: "H",
169     squares: [1,0,1,
170               1,1,1,
171               1,0,1]
172   },
173   {
174     name: "U",
175     squares: [1,0,1,
176               1,0,1,
177               1,1,1]
178   },
179   {
180     name: "Ottoman",
181     squares: [1,1,1,
182               1,1,1,
183               1,0,1]
184   },
185   {
186     name: "O",
187     squares: [1,1,1,
188               1,0,1,
189               1,1,1]
190   },
191   {
192     name: "9-block",
193     squares: [1,1,1,
194               1,1,1,
195               1,1,1]
196   }
197 ];
198
199 function copy_to_clipboard(id)
200 {
201   const tmp = document.createElement("input");
202   tmp.setAttribute("value", document.getElementById(id).innerHTML);
203   document.body.appendChild(tmp);
204   tmp.select();
205   document.execCommand("copy");
206   document.body.removeChild(tmp);
207 }
208
209 function GameInfo(props) {
210   if (! props.id)
211     return null;
212
213   return (
214     <div className="game-info">
215       <span className="game-id">{props.id}</span>
216       {" "}
217       Share this link to invite a friend:{" "}
218       <span id="game-share-url">{props.url}</span>
219       {" "}
220       <button
221         className="inline"
222         onClick={() => copy_to_clipboard('game-share-url')}
223       >Copy Link</button>
224     </div>
225   );
226 }
227
228 function TeamButton(props) {
229   return <button className="inline"
230                  onClick={() => props.game.join_team(props.team)}>
231            {props.label}
232          </button>;
233 }
234
235 function TeamChoices(props) {
236   let other_team;
237   if (props.player.team === "+")
238     other_team = "o";
239   else
240     other_team = "+";
241
242   if (props.player.team === "") {
243     if (props.first_move) {
244       return null;
245     } else {
246       return [
247         <TeamButton key="+" game={props.game} team="+" label="Join 🞥" />,
248         " ",
249         <TeamButton key="o" game={props.game} team="o" label="Join 🞇" />
250       ];
251     }
252   } else {
253     return <TeamButton game={props.game} team={other_team} label="Switch" />;
254   }
255 }
256
257 function PlayerInfo(props) {
258   if (! props.player.id)
259     return null;
260
261   const choices = <TeamChoices
262                     game={props.game}
263                     first_move={props.first_move}
264                     player={props.player}
265                   />;
266
267   return (
268     <div className="player-info">
269       <span className="players-header">Players: </span>
270       {props.player.name}
271       {props.player.team ? ` (${props.player.team})` : ""}
272       {props.first_move ? "" : " "}
273       {choices}
274       {props.other_players.map(other => (
275         <span key={other.id}>
276           {", "}
277           {other.name}
278           {other.team ? ` (${other.team})` : ""}
279         </span>
280       ))}
281     </div>
282   );
283 }
284
285 function Glyph(props) {
286
287   const glyph_dots = [];
288
289   let last_square = 0;
290   for (let i = 0; i < 9; i++) {
291     if (props.squares[i])
292       last_square = i;
293   }
294
295   const height = Math.floor(20 * (Math.floor(last_square / 3) + 1));
296
297   const viewbox=`0 0 60 ${height}`;
298
299   for (let row = 0; row < 3; row++) {
300     for (let col = 0; col < 3; col++) {
301       if (props.squares[3 * row + col]) {
302         let cy = 10 + 20 * row;
303         let cx = 10 + 20 * col;
304         glyph_dots.push(
305           <circle
306             key={3 * row + col}
307             cx={cx}
308             cy={cy}
309             r="8"
310           />
311         );
312       }
313     }
314   }
315
316   return (<div className="glyph-and-name">
317             {props.name}
318             <div className="glyph">
319               <svg viewBox={viewbox}>
320                 <g fill="#287789">
321                   {glyph_dots}
322                 </g>
323               </svg>
324             </div>
325           </div>
326          );
327 }
328
329 function Square(props) {
330   let className = "square";
331
332   if (props.value.symbol) {
333     className += " occupied";
334   } else if (props.active) {
335     className += " open";
336   }
337
338   if (props.value.glyph) {
339     if (props.value.symbol === '+')
340       className += " glyph-plus";
341     else
342       className += " glyph-o";
343   }
344
345   if (props.last_move) {
346     className += " last-move";
347   }
348
349   const onClick = props.active ? props.onClick : null;
350
351   return (
352     <div className={className}
353          onClick={onClick}>
354       {props.value.symbol}
355     </div>
356   );
357 }
358
359 function MiniGrid(props) {
360   function grid_square(j) {
361     const value = props.squares[j];
362     const last_move = props.last_moves.includes(j);
363
364     /* Even if the grid is active, the square is only active if
365      * unoccupied. */
366     const square_active = (props.active && (value.symbol === null));
367
368     return (
369       <Square
370         value={value}
371         active={square_active}
372         last_move={last_move}
373         onClick={() => props.onClick(j)}
374       />
375     );
376   }
377
378   /* Even if my parent thinks I'm active because of the last move, I
379    * might not _really_ be active if I'm full. */
380   let occupied = 0;
381   props.squares.forEach(element => {
382     if (element.symbol)
383       occupied++;
384   });
385
386   let class_name = "mini-grid";
387   if (props.active && occupied < 9)
388     class_name += " active";
389
390   return (
391     <div className={class_name}>
392       {grid_square(0)}
393       {grid_square(1)}
394       {grid_square(2)}
395       {grid_square(3)}
396       {grid_square(4)}
397       {grid_square(5)}
398       {grid_square(6)}
399       {grid_square(7)}
400       {grid_square(8)}
401     </div>
402   );
403 }
404
405 class Board extends React.Component {
406   mini_grid(i) {
407     /* This mini grid is active only if both:
408      *
409      * 1. It is our turn (this.props.active === true)
410      *
411      * 2. One of the following conditions is met:
412      *
413      *    a. This is this players first turn (last_two_moves[0] === null)
414      *    b. This mini grid corresponds to this players last turn
415      *    c. The mini grid that corresponds to the players last turn is full
416      */
417     let grid_active = false;
418     if (this.props.active) {
419       grid_active = true;
420       if (this.props.last_two_moves.length > 1) {
421         /* First index (0) gives us our last move, (that is, of the
422          * last two moves, it's the first one, so two moves ago).
423          *
424          * Second index (1) gives us the second number from that move,
425          * (that is, the index within the mini-grid that we last
426          * played).
427          */
428         const target = this.props.last_two_moves[0][1];
429         let occupied = 0;
430         this.props.squares[target].forEach(element => {
431           if (element.symbol)
432             occupied++;
433         });
434         /* If the target mini-grid isn't full then this grid is
435          * only active if it is that target. */
436         if (occupied < 9)
437           grid_active = (i === target);
438       }
439     }
440
441     /* We want to highlight each of the last two moves (both "+" and
442      * "o"). So we filter the last two moves that have a first index
443      * that matches this mini_grid and pass down their second index
444      * be highlighted.
445      */
446     const last_moves = this.props.last_two_moves.filter(move => move[0] === i)
447           .map(move => move[1]);
448
449     const squares = this.props.squares[i];
450     return (
451       <MiniGrid
452         squares={squares}
453         active={grid_active}
454         last_moves={last_moves}
455         onClick={(j) => this.props.onClick(i,j)}
456       />
457     );
458   }
459
460   render() {
461     return (
462       <div className="board-container">
463         <div className="board">
464           {this.mini_grid(0)}
465           {this.mini_grid(1)}
466           {this.mini_grid(2)}
467           {this.mini_grid(3)}
468           {this.mini_grid(4)}
469           {this.mini_grid(5)}
470           {this.mini_grid(6)}
471           {this.mini_grid(7)}
472           {this.mini_grid(8)}
473         </div>
474       </div>
475     );
476   }
477 }
478
479 function fetch_method_json(method, api = '', data = {}) {
480   const response = fetch(api, {
481     method: method,
482     headers: {
483       'Content-Type': 'application/json'
484     },
485     body: JSON.stringify(data)
486   });
487   return response;
488 }
489
490 function fetch_post_json(api = '', data = {}) {
491   return fetch_method_json('POST', api, data);
492 }
493
494 async function fetch_put_json(api = '', data = {}) {
495   return fetch_method_json('PUT', api, data);
496 }
497
498 class Game extends React.Component {
499   constructor(props) {
500     super(props);
501     this.state = {
502       game_info: {},
503       player_info: {},
504       other_players: [],
505       squares: [...Array(9)].map(() => Array(9).fill({
506         symbol: null,
507         glyph: false
508       })),
509       moves: [],
510       next_to_play: "+",
511     };
512   }
513
514   set_game_info(info) {
515     this.setState({
516       game_info: info
517     });
518   }
519
520   set_player_info(info) {
521     this.setState({
522       player_info: info
523     });
524   }
525
526   set_other_player_info(info) {
527     const other_players_copy = [...this.state.other_players];
528     const idx = other_players_copy.findIndex(o => o.id === info.id);
529     if (idx >= 0) {
530       other_players_copy[idx] = info;
531     } else {
532       other_players_copy.push(info);
533     }
534     this.setState({
535       other_players: other_players_copy
536     });
537   }
538
539   reset_board() {
540     this.setState({
541       next_to_play: "+"
542     });
543   }
544
545   find_connected_recursive(recursion_state, position) {
546
547     if (position < 0 || position >= 9)
548       return;
549
550     if (recursion_state.visited[position])
551       return;
552
553     recursion_state.visited[position] = true;
554
555     if (recursion_state.mini_grid[position].symbol !== recursion_state.target)
556       return;
557
558     recursion_state.connected[position] = true;
559
560     /* Left */
561     if (position % 3 !== 0)
562       this.find_connected_recursive(recursion_state, position - 1);
563     /* Right */
564     if (position % 3 !== 2)
565       this.find_connected_recursive(recursion_state, position + 1);
566     /* Up */
567     this.find_connected_recursive(recursion_state, position - 3);
568     /* Down */
569     this.find_connected_recursive(recursion_state, position + 3);
570   }
571
572   /* Find all cells within a mini-grid that are 4-way connected to the
573    * given cell. */
574   find_connected(mini_grid, position) {
575     const connected = Array(9).fill(false);
576
577     /* If the given cell is empty then there is nothing connected. */
578     if (mini_grid[position] === null)
579       return connected;
580
581     const cell = mini_grid[position].symbol;
582
583     let recursion_state = {
584       mini_grid: mini_grid,
585       connected: connected,
586       visited: Array(9).fill(false),
587       target: cell,
588     };
589     this.find_connected_recursive(recursion_state, position);
590
591     return connected;
592   }
593
594   /* Determine whether a connected group of cells is a glyph.
595    *
596    * Here, 'connected' is a length-9 array of Booleans, true
597    * for the connected cells in a mini-grid.
598    */
599   is_glyph(connected) {
600
601     /* Now that we have a set of connected cells, let's collect some
602      * stats on them, (width, height, number of cells, configuration
603      * of corner cells, etc.).
604      */
605     let min_row = 2;
606     let min_col = 2;
607     let max_row = 0;
608     let max_col = 0;
609     let count = 0;
610
611     for (let i = 0; i < 9; i++) {
612       const row = Math.floor(i/3);
613       const col = i % 3;
614
615       if (! connected[i])
616         continue;
617
618       count++;
619
620       min_row = Math.min(row, min_row);
621       min_col = Math.min(col, min_col);
622       max_row = Math.max(row, max_row);
623       max_col = Math.max(col, max_col);
624     }
625
626     const width = max_col - min_col + 1;
627     const height = max_row - min_row + 1;
628
629     /* Corners, (top-left, top-right, bottom-left, and bottom-right) */
630     const tl = connected[3 * min_row + min_col];
631     const tr = connected[3 * min_row + max_col];
632     const bl = connected[3 * max_row + min_col];
633     const br = connected[3 * max_row + max_col];
634
635     const count_true = (acc, val) => acc + (val ? 1 : 0);
636     const corners_count = [tl, tr, bl, br].reduce(count_true, 0);
637     const top_corners_count = [tl, tr].reduce(count_true, 0);
638     const bottom_corners_count = [bl, br].reduce(count_true, 0);
639     const left_corners_count = [tl, bl].reduce(count_true, 0);
640     const right_corners_count = [tr, br].reduce(count_true, 0);
641
642     let two_corners_in_a_line = false;
643     if (top_corners_count    === 2 ||
644         bottom_corners_count === 2 ||
645         left_corners_count   === 2 ||
646         right_corners_count  === 2)
647     {
648       two_corners_in_a_line = true;
649     }
650
651     let zero_corners_in_a_line = false;
652     if (top_corners_count    === 0 ||
653         bottom_corners_count === 0 ||
654         left_corners_count   === 0 ||
655         right_corners_count  === 0)
656     {
657       zero_corners_in_a_line = true;
658     }
659
660     /* Now we have the information we need to determine glyphs. */
661     switch (count) {
662     case 1:
663       /* Single */
664       return true;
665     case 2:
666       /* Double */
667       return true;
668     case 3:
669       /* Line */
670       return (width === 3 || height === 3);
671     case 4:
672       /* Pipe, Squat-T, and 4-block, but not Tetris S */
673       return two_corners_in_a_line;
674     case 5:
675       if (width !== 3 || height !== 3 || ! connected[4])
676       {
677         /* Pentomino P and U are not glyphs (not 3x3) */
678         /* Pentomino V is not a glyph (center not connected) */
679         return false;
680       }
681       else if (corners_count === 0 || two_corners_in_a_line)
682       {
683         /* Pentomino X is glyph Cross (no corners) */
684         /* Pentomino T is glyph T (has a row or column with 2 corners) */
685         return true;
686       } else {
687         /* The corner counting above excludes pentomino F, W, and Z
688          * which are not glyphs. */
689         return false;
690       }
691       break;
692     case 6:
693       /* 6-Block has width or height of 2. */
694       /* Bomber, Chair, and J have 3 corners occupied. */
695       if (width === 2 || height === 2 || corners_count === 3)
696         return true;
697       return false;
698     case 7:
699       /* Earring and U have no center square occupied */
700       /* H has 4 corners occupied */
701       /* House has a row or column with 0 corners occupied */
702       if ((! connected[4]) || corners_count === 4 || zero_corners_in_a_line)
703         return true;
704       return false;
705     case 8:
706       /* Ottoman or O */
707       if (corners_count === 4)
708         return true;
709       return false;
710     case 9:
711       return true;
712     }
713
714     /* Should be unreachable */
715     return false;
716   }
717
718   receive_move(move) {
719     const mini_grid_index = move[0];
720     const position = move[1];
721
722     /* Don't allow any moves after the board is full */
723     if (this.state.moves.length === 81) {
724       return;
725     }
726
727     /* Set the team's symbol into the board state. */
728     const symbol = team_symbol(this.state.next_to_play);
729     const new_squares = this.state.squares.map(arr => arr.slice());
730     new_squares[mini_grid_index][position] = {
731       symbol: symbol,
732       glyph: false
733     };
734
735     /* With the symbol added to the squares, we need to see if this
736      * newly-placed move forms a glyph or not. */
737     const connected = this.find_connected(new_squares[mini_grid_index], position);
738     const is_glyph = this.is_glyph(connected);
739
740     for (let i = 0; i < 9; i++) {
741       if (connected[i])
742         new_squares[mini_grid_index][i].glyph = is_glyph;
743     }
744
745     /* And append the move to the list of moves. */
746     const new_moves = [...this.state.moves, move];
747
748     /* Finally, compute the next player to move. */
749     let next_to_play;
750     if (this.state.next_to_play === "+")
751       next_to_play = "o";
752     else
753       next_to_play = "+";
754
755     /* And shove all those state modifications toward React. */
756     this.setState({
757       squares: new_squares,
758       moves: new_moves,
759       next_to_play: next_to_play
760     });
761   }
762
763   async handle_click(i, j, first_move) {
764     let move = {
765       move: [i, j]
766     };
767     if (first_move) {
768       move.assert_first_move = true;
769     }
770     const response = await fetch_post_json("move", move);
771     if (response.status == 200) {
772       const result = await response.json();
773       if (! result.legal)
774         add_message("danger", result.message);
775     } else {
776       add_message("danger", `Error occurred sending move`);
777     }
778   }
779
780   join_team(team) {
781     fetch_put_json("player", {team: team});
782   }
783
784   render() {
785     const state = this.state;
786     const first_move = state.moves.length === 0;
787     const my_team = state.player_info.team;
788     var board_active;
789
790     let status;
791     if (this.state.moves.length === 81)
792     {
793       status = "Game over";
794       board_active = false;
795     }
796     else if (first_move)
797     {
798       if (state.other_players.length == 0) {
799         status = "You can move or wait for another player to join.";
800       } else {
801         let qualifier;
802         if (state.other_players.length == 1) {
803           qualifier = "Either";
804         } else {
805           qualifier = "Any";
806         }
807         status = `${qualifier} player can make the first move.`;
808       }
809       board_active = true;
810     }
811     else if (my_team === "")
812     {
813       status = "You're just watching the game.";
814       board_active = false;
815     }
816     else if (my_team === state.next_to_play)
817     {
818       status = "Your turn. Make a move.";
819       board_active = true;
820     }
821     else
822     {
823       status = "Waiting for another player to ";
824       if (state.other_players.length == 0) {
825         status += "join.";
826       } else {
827         status += "move.";
828       }
829       board_active = false;
830     }
831
832     return [
833       <GameInfo
834         key="game-info"
835         id={state.game_info.id}
836         url={state.game_info.url}
837       />,
838       <PlayerInfo
839         key="player-info"
840         game={this}
841         first_move={first_move}
842         player={state.player_info}
843         other_players={state.other_players}
844       />,
845       <div key="game" className="game">
846         <div>{status}</div>
847         <div className="game-board">
848           <Board
849             active={board_active}
850             squares={state.squares}
851             last_two_moves={state.moves.slice(-2)}
852             onClick={(i,j) => this.handle_click(i, j, first_move)}
853           />
854         </div>
855       </div>,
856       <div key="glyphs" className="glyphs">
857         {
858           scribe_glyphs.map(glyph => {
859             return (
860               <Glyph
861                 key={glyph.name}
862                 name={glyph.name}
863                 squares={glyph.squares}
864               />
865             );
866           })
867         }
868       </div>
869     ];
870   }
871 }
872
873 ReactDOM.render(<Game
874                   ref={(me) => window.game = me}
875                 />, document.getElementById("scribe"));