+});
+
+const LetsPlay = React.memo(props => {
+
+ const quorum = Math.round((props.num_players + 1) / 2);
+ const max_votes = props.prompts.reduce(
+ (max_so_far, v) => Math.max(max_so_far, v.votes.length), 0);
+
+ if (max_votes < quorum)
+ return null;
+
+ const candidates = props.prompts.filter(p => p.votes.length >= quorum);
+ const index = Math.floor(Math.random() * candidates.length);
+ const winner = candidates[index];
+
+ return (
+ <div className="lets-play">
+ <h2>Let's Play</h2>
+ <p>
+ That should be enough voting. If you're not waiting for any
+ other players to join, then let's start.
+ </p>
+ <button
+ className="lets-play"
+ onClick={() => fetch_post_json(`start/${winner.id}`) }
+ >
+ Start Game
+ </button>
+ </div>
+ );
+});
+
+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(
+ `judged/${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 the results of your judging");
+ 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>Submission received</h2>
+ <p>
+ The following players have completed judging:
+ {[...this.props.players_judged].join(', ')}
+ </p>
+ <p>
+ 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>
+ );
+
+ 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>
+ );
+ }