X-Git-Url: https://git.cworth.org/git?p=lmno.games;a=blobdiff_plain;f=empathy%2Fempathy.jsx;h=dee5a677ff47da93c0307b84af7cec0be8399db6;hp=39461898cf5efd9d7478a2acd68a333c791be74c;hb=2f53ad28854b9d68fcbd19ca02002c5883234638;hpb=ff43730d806faf03b488ee59c49d576686696d6c

diff --git a/empathy/empathy.jsx b/empathy/empathy.jsx
index 3946189..dee5a67 100644
--- a/empathy/empathy.jsx
+++ b/empathy/empathy.jsx
@@ -1,3 +1,5 @@
+const MAX_PROMPT_ITEMS = 20;
+
 function undisplay(element) {
   element.style.display="none";
 }
@@ -55,11 +57,13 @@ events.addEventListener("player-update", event => {
 events.addEventListener("game-state", event => {
   const state = JSON.parse(event.data);
 
-  for (let prompt of state.prompts) {
-    window.game.add_or_update_prompt(prompt);
-  }
+  window.game.set_prompts(state.prompts);
 
   window.game.set_active_prompt(state.active_prompt);
+
+  window.game.set_scores(state.scores);
+
+  window.game.set_ambiguities(state.ambiguities);
 });
 
 events.addEventListener("prompt", event => {
@@ -74,6 +78,30 @@ events.addEventListener("start", event => {
   window.game.set_active_prompt(prompt);
 });
 
+events.addEventListener("answered", event => {
+  const players_answered = JSON.parse(event.data);
+
+  window.game.set_players_answered(players_answered);
+});
+
+events.addEventListener("ambiguities", event => {
+  const ambiguities = JSON.parse(event.data);
+
+  window.game.set_ambiguities(ambiguities);
+});
+
+events.addEventListener("judged", event => {
+  const players_judged = JSON.parse(event.data);
+
+  window.game.set_players_judged(players_judged);
+});
+
+events.addEventListener("scores", event => {
+  const scores = JSON.parse(event.data);
+
+  window.game.set_scores(scores);
+});
+
 /*********************************************************
  * Game and supporting classes                           *
  *********************************************************/
@@ -115,10 +143,12 @@ const PlayerInfo = React.memo(props => {
     <div className="player-info">
       <span className="players-header">Players: </span>
       {props.player.name}
+      {props.player.score > 0 ? ` (${props.player.score})` : ""}
       {props.other_players.map(other => (
         <span key={other.id}>
           {", "}
           {other.name}
+          {other.score > 0 ? ` (${other.score})` : ""}
         </span>
       ))}
     </div>
@@ -157,11 +187,15 @@ class CategoryRequest extends React.PureComponent {
     const category_input = this.category.current;
     const category = category_input.value;
 
-    if (/[0-9]/.test(category))
-      category_input.setCustomValidity("");
+    const match = category.match(/[0-9]+/);
+    if (match) {
+      const num_items = parseInt(match[0], 10);
+      if (num_items <= MAX_PROMPT_ITEMS)
+        category_input.setCustomValidity("");
+    }
   }
 
-  handle_submit(event) {
+  async handle_submit(event) {
     const form = event.currentTarget;
     const category_input = this.category.current;
     const category = category_input.value;
@@ -176,11 +210,30 @@ class CategoryRequest extends React.PureComponent {
       return;
     }
 
-    fetch_post_json("prompts", {
-      items: parseInt(match[0], 10),
+    const num_items = parseInt(match[0], 10);
+
+    if (num_items > MAX_PROMPT_ITEMS) {
+      category_input.setCustomValidity(`Maximum number of items is ${MAX_PROMPT_ITEMS}`);
+      form.reportValidity();
+      return;
+    }
+
+    const response = await fetch_post_json("prompts", {
+      items: num_items,
       prompt: category
     });
 
+    if (response.status === 200) {
+      const result = await response.json();
+      console.log(result);
+      if (! result.valid) {
+        add_message("danger", result.message);
+        return;
+      }
+    } else {
+      add_message("danger", "An error occurred submitting your category");
+    }
+
     form.reset();
   }
 
@@ -291,6 +344,152 @@ const LetsPlay = React.memo(props => {
   );
 });
 
+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_sets: word_sets,
+      submitted: false,
+      selected: null
+    };
+  }
+
+  async handle_submit() {
+    const response = await fetch_post_json(
+      `judging/${this.props.prompt.id}`,{
+        word_groups: this.state.word_sets.map(set => Array.from(set))
+      }
+    );
+
+    if (response.status === 200) {
+      const result = await response.json();
+      if (! result.valid) {
+        add_message("danger", result.message);
+        return;
+      }
+    } else {
+      add_message("danger", "An error occurred submitting your answers");
+      return;
+    }
+
+    this.setState({
+      submitted: true
+    });
+  }
+
+  handle_click(word) {
+    if (this.state.selected == word) {
+      /* Second click on same word removes the word from the group. */
+      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_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 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({
+        selected: word
+      });
+    }
+  }
+
+  render() {
+    if (this.state.submitted)
+      return (
+        <div className="please-wait">
+          <h2>{this.props.players_judged}/
+            {this.props.players_total} players have responded</h2>
+          <p>
+            Please wait for the rest of the players to complete judging.
+          </p>
+        </div>
+      );
+
+    const btn_class = "ambiguity-button";
+    const btn_selected_class = btn_class + " selected";
+
+    return (
+      <div className="ambiguities">
+        <h2>Judging Answers</h2>
+        <p>
+          Click on each pair of answers that should be scored as equivalent,
+          (and click any word twice to split it out from a group). Remember,
+          what goes around comes around, so it's best to be generous when
+          judging.
+        </p>
+        {this.state.word_sets.map(set => {
+          return (
+            <div
+              className="ambiguity-group"
+              key={Array.from(set)[0]}
+            >
+              {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>
+                );
+              })}
+            </div>
+          );
+        })}
+        <p>
+          Click here when done judging:<br/>
+          <button
+            onClick={() => this.handle_submit()}
+          >
+            Send
+          </button>
+        </p>
+      </div>
+    );
+  }
+}
+
 class ActivePrompt extends React.PureComponent {
 
   constructor(props) {
@@ -314,7 +513,7 @@ class ActivePrompt extends React.PureComponent {
     const response = await fetch_post_json(`answer/${this.props.prompt.id}`, {
       answers: this.answers.map(r => r.current.value)
     });
-    if (response.status == 200) {
+    if (response.status === 200) {
       const result = await response.json();
       if (! result.valid) {
         add_message("danger", result.message);
@@ -336,7 +535,8 @@ class ActivePrompt extends React.PureComponent {
     if (this.state.submitted)
       return (
         <div className="please-wait">
-          <h2>Answers submitted</h2>
+          <h2>{this.props.players_answered}/
+            {this.props.players_total} players have responded</h2>
           <p>
             Please wait for the rest of the players to submit their answers.
           </p>
@@ -353,7 +553,7 @@ class ActivePrompt extends React.PureComponent {
         </p>
         <h2>{this.props.prompt.prompt}</h2>
         <form onSubmit={this.handle_submit}>
-          {Array(this.props.prompt.items).fill(null).map((whocares,i) => {
+          {[...Array(this.props.prompt.items)].map((whocares,i) => {
             return (
               <div
                 key={i}
@@ -390,7 +590,11 @@ class Game extends React.PureComponent {
       game_info: {},
       player_info: {},
       other_players: [],
-      prompts: []
+      prompts: [],
+      active_prompt: null,
+      players_answered: 0,
+      ambiguities: null,
+      players_judged: 0
     };
   }
 
@@ -419,6 +623,12 @@ class Game extends React.PureComponent {
     });
   }
 
+  set_prompts(prompts) {
+    this.setState({
+      prompts: prompts
+    });
+  }
+
   add_or_update_prompt(prompt) {
     const prompts_copy = [...this.state.prompts];
     const idx = prompts_copy.findIndex(p => p.id === prompt.id);
@@ -438,12 +648,81 @@ class Game extends React.PureComponent {
     });
   }
 
+  set_players_answered(players_answered) {
+    this.setState({
+      players_answered: players_answered
+    });
+  }
+
+  set_ambiguities(ambiguities) {
+    this.setState({
+      ambiguities: ambiguities
+    });
+  }
+
+  set_players_judged(players_judged) {
+    this.setState({
+      players_judged: players_judged
+    });
+  }
+
+  set_scores(scores) {
+    this.setState({
+      scores: scores
+    });
+  }
+
   render() {
     const state = this.state;
+    const players_total = 1 + state.other_players.length;
+
+    if (state.scores) {
+      return (
+        <div className="scores">
+          <h2>Scores</h2>
+          <ul>
+            {state.scores.scores.map(score => {
+              return (
+                <li key={score.player}>
+                  {score.player}: {score.score}
+                </li>
+              );
+            })}
+          </ul>
+          <h2>Words submitted</h2>
+          <ul>
+            {state.scores.words.map(word => {
+              return (
+                <li key={word.word}>
+                  {`${word.word}: ${word.players.join(', ')}`}
+                </li>
+              );
+            })}
+          </ul>
+          <button
+            className="new-game"
+            onClick={() => fetch_post_json('reset') }
+          >
+            New Game
+          </button>
+        </div>
+      );
+    }
+
+    if (state.ambiguities){
+      return <Ambiguities
+               prompt={state.active_prompt}
+               words={state.ambiguities}
+               players_judged={state.players_judged}
+               players_total={players_total}
+             />;
+    }
 
     if (state.active_prompt) {
       return <ActivePrompt
                prompt={state.active_prompt}
+               players_answered={state.players_answered}
+               players_total={players_total}
              />;
     }