X-Git-Url: https://git.cworth.org/git?p=lmno.games;a=blobdiff_plain;f=empathy%2Fempathy.jsx;h=c4aafde512166824ab87651015b2dd8fccc5e01e;hp=3d7034527c0c8bd49dc8fea14dcf14af96b5520e;hb=84dc7d67e5ce98090b7790faab5543e2cf60653e;hpb=6baa178ee249fde9b660e91c6d6cc374b3d755ac

diff --git a/empathy/empathy.jsx b/empathy/empathy.jsx
index 3d70345..c4aafde 100644
--- a/empathy/empathy.jsx
+++ b/empathy/empathy.jsx
@@ -57,6 +57,8 @@ events.addEventListener("player-update", event => {
 events.addEventListener("game-state", event => {
   const state = JSON.parse(event.data);
 
+  window.game.reset_game_state();
+
   window.game.set_prompts(state.prompts);
 
   window.game.set_active_prompt(state.active_prompt);
@@ -78,10 +80,28 @@ events.addEventListener("start", event => {
   window.game.set_active_prompt(prompt);
 });
 
-events.addEventListener("answered", event => {
-  const players_answered = JSON.parse(event.data);
+events.addEventListener("player-answered", event => {
+  const player = JSON.parse(event.data);
+
+  window.game.set_player_answered(player);
+});
+
+events.addEventListener("player-answering", event => {
+  const player = JSON.parse(event.data);
 
-  window.game.set_players_answered(players_answered);
+  window.game.set_player_answering(player);
+});
+
+events.addEventListener("vote-end-answers", event => {
+  const player = JSON.parse(event.data);
+
+  window.game.set_player_vote_end_answers(player);
+});
+
+events.addEventListener("unvote-end-answers", event => {
+  const player = JSON.parse(event.data);
+
+  window.game.set_player_unvote_end_answers(player);
 });
 
 events.addEventListener("ambiguities", event => {
@@ -90,10 +110,28 @@ events.addEventListener("ambiguities", event => {
   window.game.set_ambiguities(ambiguities);
 });
 
-events.addEventListener("judged", event => {
-  const players_judged = JSON.parse(event.data);
+events.addEventListener("player-judged", event => {
+  const player = JSON.parse(event.data);
+
+  window.game.set_player_judged(player);
+});
+
+events.addEventListener("player-judging", event => {
+  const player = JSON.parse(event.data);
+
+  window.game.set_player_judging(player);
+});
+
+events.addEventListener("vote-end-judging", event => {
+  const player = JSON.parse(event.data);
+
+  window.game.set_player_vote_end_judging(player);
+});
+
+events.addEventListener("unvote-end-judging", event => {
+  const player = JSON.parse(event.data);
 
-  window.game.set_players_judged(players_judged);
+  window.game.set_player_unvote_end_judging(player);
 });
 
 events.addEventListener("scores", event => {
@@ -225,7 +263,6 @@ class CategoryRequest extends React.PureComponent {
 
     if (response.status === 200) {
       const result = await response.json();
-      console.log(result);
       if (! result.valid) {
         add_message("danger", result.message);
         return;
@@ -349,8 +386,14 @@ class Ambiguities extends React.PureComponent {
   constructor(props) {
     super(props);
 
+    const word_sets = props.words.map(word => {
+      const set = new Set();
+      set.add(word);
+      return set;
+    });
+
     this.state = {
-      word_groups: props.words.map(word => [word]),
+      word_sets: word_sets,
       submitted: false,
       selected: null
     };
@@ -358,8 +401,8 @@ class Ambiguities extends React.PureComponent {
 
   async handle_submit() {
     const response = await fetch_post_json(
-      `judging/${this.props.prompt.id}`,{
-        word_groups: this.state.word_groups
+      `judged/${this.props.prompt.id}`,{
+        word_groups: this.state.word_sets.map(set => Array.from(set))
       }
     );
 
@@ -382,35 +425,42 @@ class Ambiguities extends React.PureComponent {
   handle_click(word) {
     if (this.state.selected == word) {
       /* Second click on same word removes the word from the group. */
-      const new_groups = this.state.word_groups.filter(
-        group => (! group.includes(this.state.selected)) || (group.length > 1)).map(
-          group => {
-            return group.filter(w => w !== this.state.selected);
-          }
-        );
+      const idx = this.state.word_sets.findIndex(s => s.has(word));
+      const set = this.state.word_sets[idx];
+      if (set.size === 1)
+        return;
+      const new_set = new Set([...set].filter(w => w !== word));
       this.setState({
         selected: null,
-        word_groups: [...new_groups, [word]]
+        word_sets: [...this.state.word_sets.slice(0, idx),
+                    new_set,
+                    new Set().add(word),
+                    ...this.state.word_sets.slice(idx+1)]
       });
     } else if (this.state.selected) {
       /* Click of a second word groups the two together. */
-      const new_groups = this.state.word_groups.filter(
-        group => (! group.includes(word)) || (group.length > 1)).map(
-          group => {
-            if (group.includes(this.state.selected)) {
-              if (! group.includes(word))
-                return [...group, word];
-              else
-                return group;
-            } else {
-              return group.filter(w => w !== word);
-            }
-          }
-        );
-      this.setState({
-        selected: null,
-        word_groups: new_groups
-      });
+      const idx1 = this.state.word_sets.findIndex(s => s.has(this.state.selected));
+      const idx2 = this.state.word_sets.findIndex(s => s.has(word));
+      const set1 = this.state.word_sets[idx1];
+      const set2 = this.state.word_sets[idx2];
+      const new_set = new Set([...set2, ...set1]);
+      if (idx1 < idx2) {
+        this.setState({
+          selected: null,
+          word_sets: [...this.state.word_sets.slice(0, idx1),
+                      ...this.state.word_sets.slice(idx1 + 1, idx2),
+                      new_set,
+                      ...this.state.word_sets.slice(idx2 + 1)]
+        });
+      } else {
+        this.setState({
+          selected: null,
+          word_sets: [...this.state.word_sets.slice(0, idx2),
+                      new_set,
+                      ...this.state.word_sets.slice(idx2 + 1, idx1),
+                      ...this.state.word_sets.slice(idx1 + 1)]
+        });
+      }
     } else {
       /* First click of a word selects it. */
       this.setState({
@@ -423,11 +473,46 @@ class Ambiguities extends React.PureComponent {
     if (this.state.submitted)
       return (
         <div className="please-wait">
-          <h2>{this.props.players_judged}/
-            {this.props.players_total} players have responded</h2>
+          <h2>Submission received</h2>
+          <p>
+            The following players have completed judging:
+            {[...this.props.players_judged].join(', ')}
+          </p>
           <p>
-            Please wait for the rest of the players to complete judging.
+            Still waiting for the following players:
           </p>
+          <ul>
+            {Object.entries(this.props.players_judging).map(player => {
+              return (
+                <li
+                  key={player}
+                >
+                  {player}
+                  {this.props.players_judging[player] ?
+                   <span className="typing"/> : null }
+                </li>
+              );
+            })}
+          </ul>
+          <button
+            className="vote-button"
+            onClick={() => fetch_post_json(`end-judging/${this.props.prompt.id}`) }
+          >
+            Move On
+            <div className="vote-choices">
+              {[...this.props.votes].map(v => {
+                return (
+                  <div
+                    key={v}
+                    className="vote-choice"
+                  >
+                    {v}
+                  </div>
+                );
+              })}
+            </div>
+          </button>
+
         </div>
       );
 
@@ -443,24 +528,24 @@ class Ambiguities extends React.PureComponent {
           what goes around comes around, so it's best to be generous when
           judging.
         </p>
-        {this.state.word_groups.map(word_group => {
+        {this.state.word_sets.map(set => {
           return (
             <div
               className="ambiguity-group"
-              key={word_group[0]}
+              key={Array.from(set)[0]}
             >
-            {word_group.map(word => {
-              return (
-                <button
-                className={this.state.selected === word ?
-                           btn_selected_class : btn_class }
-                key={word}
-                onClick={() => this.handle_click(word)}
+              {Array.from(set).map(word => {
+                return (
+                  <button
+                    className={this.state.selected === word ?
+                               btn_selected_class : btn_class }
+                    key={word}
+                    onClick={() => this.handle_click(word)}
                   >
-                {word}
-                </button>
-              );
-            })}
+                    {word}
+                  </button>
+                );
+              })}
             </div>
           );
         })}
@@ -522,11 +607,46 @@ class ActivePrompt extends React.PureComponent {
     if (this.state.submitted)
       return (
         <div className="please-wait">
-          <h2>{this.props.players_answered}/
-            {this.props.players_total} players have responded</h2>
+          <h2>Submission received</h2>
+          <p>
+            The following players have submitted their answers:
+            {[...this.props.players_answered].join(', ')}
+          </p>
           <p>
-            Please wait for the rest of the players to submit their answers.
+          Still waiting for the following players:
           </p>
+          <ul>
+            {Object.entries(this.props.players_answering).map(player => {
+              return (
+                <li
+                  key={player}
+                >
+                  {player}
+                  {this.props.players_answering[player] ?
+                   <span className="typing"/> : null }
+                </li>
+              );
+            })}
+          </ul>
+          <button
+            className="vote-button"
+            onClick={() => fetch_post_json(`end-answers/${this.props.prompt.id}`) }
+          >
+            Move On
+            <div className="vote-choices">
+              {[...this.props.votes].map(v => {
+                return (
+                  <div
+                    key={v}
+                    className="vote-choice"
+                  >
+                    {v}
+                  </div>
+                );
+              })}
+            </div>
+          </button>
+
         </div>
       );
 
@@ -579,9 +699,14 @@ class Game extends React.PureComponent {
       other_players: [],
       prompts: [],
       active_prompt: null,
-      players_answered: 0,
+      players_answered: new Set(),
+      players_answering: {},
+      end_answers_votes: new Set(),
       ambiguities: null,
-      players_judged: 0
+      players_judged: new Set(),
+      players_judging: {},
+      end_judging_votes: new Set(),
+      scores: null
     };
   }
 
@@ -610,6 +735,21 @@ class Game extends React.PureComponent {
     });
   }
 
+  reset_game_state() {
+    this.setState({
+      prompts: [],
+      active_prompt: null,
+      players_answered: new Set(),
+      players_answering: {},
+      end_answers_votes: new Set(),
+      ambiguities: null,
+      players_judged: new Set(),
+      players_judging: {},
+      end_judging_votes: new Set(),
+      scores: null
+    });
+  }
+
   set_prompts(prompts) {
     this.setState({
       prompts: prompts
@@ -635,9 +775,34 @@ class Game extends React.PureComponent {
     });
   }
 
-  set_players_answered(players_answered) {
+  set_player_answered(player) {
+    const new_players_answering = {...this.state.players_answering};
+    delete new_players_answering[player];
+
+    this.setState({
+      players_answered: new Set([...this.state.players_answered, player]),
+      players_answering: new_players_answering
+    });
+  }
+
+  set_player_answering(player) {
     this.setState({
-      players_answered: players_answered
+      players_answering: {
+        ...this.state.players_answering,
+        [player]: {active: true}
+      }
+    });
+  }
+
+  set_player_vote_end_answers(player) {
+    this.setState({
+      end_answers_votes: new Set([...this.state.end_answers_votes, player])
+    });
+  }
+
+  set_player_unvote_end_answers(player) {
+    this.setState({
+      end_answers_votes: new Set([...this.state.end_answers_votes].filter(p => p !== player))
     });
   }
 
@@ -647,9 +812,35 @@ class Game extends React.PureComponent {
     });
   }
 
-  set_players_judged(players_judged) {
+  set_player_judged(player) {
+    const new_players_judging = {...this.state.players_judging};
+    delete new_players_judging[player];
+
+    this.setState({
+      players_judged: new Set([...this.state.players_judged, player]),
+      players_judging: new_players_judging
+    });
+  }
+
+  set_player_judging(player) {
+    this.setState({
+      players_judging: {
+        ...this.state.players_judging,
+        [player]: {active: true}
+      }
+    });
+  }
+
+
+  set_player_vote_end_judging(player) {
+    this.setState({
+      end_judging_votes: new Set([...this.state.end_judging_votes, player])
+    });
+  }
+
+  set_player_unvote_end_judging(player) {
     this.setState({
-      players_judged: players_judged
+      end_judging_votes: new Set([...this.state.end_judging_votes].filter(p => p !== player))
     });
   }
 
@@ -701,7 +892,8 @@ class Game extends React.PureComponent {
                prompt={state.active_prompt}
                words={state.ambiguities}
                players_judged={state.players_judged}
-               players_total={players_total}
+               players_judging={state.players_judging}
+               votes={state.end_judging_votes}
              />;
     }
 
@@ -709,7 +901,8 @@ class Game extends React.PureComponent {
       return <ActivePrompt
                prompt={state.active_prompt}
                players_answered={state.players_answered}
-               players_total={players_total}
+               players_answering={state.players_answering}
+               votes={state.end_answers_votes}
              />;
     }