window.game.set_other_player_info(info);
});
+events.addEventListener("game-state", event => {
+ const state = JSON.parse(event.data);
+
+ 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 => {
+ const prompt = JSON.parse(event.data);
+
+ window.game.add_or_update_prompt(prompt);
+});
+
+events.addEventListener("start", event => {
+ const prompt = JSON.parse(event.data);
+
+ 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 *
*********************************************************/
document.body.removeChild(tmp);
}
-function GameInfo(props) {
+const GameInfo = React.memo(props => {
if (! props.id)
return null;
>Copy Link</button>
</div>
);
-}
+});
-function PlayerInfo(props) {
+const PlayerInfo = React.memo(props => {
if (! props.player.id)
return null;
<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>
);
-}
+});
function fetch_method_json(method, api = '', data = {}) {
const response = fetch(api, {
return fetch_method_json('PUT', api, data);
}
-class CategoryRequest extends React.Component {
+class CategoryRequest extends React.PureComponent {
constructor(props) {
super(props);
this.category = React.createRef();
}
handle_submit(event) {
+ const form = event.currentTarget;
const category_input = this.category.current;
const category = category_input.value;
/* Prevent the default page-changing form-submission behavior. */
event.preventDefault();
- if (! /[0-9]/.test(category)) {
+ const match = category.match(/[0-9]+/);
+ if (match === null) {
category_input.setCustomValidity("Category must include a number");
- event.currentTarget.reportValidity();
+ form.reportValidity();
return;
}
- console.log("Do something here with category: " + category);
+ fetch_post_json("prompts", {
+ items: parseInt(match[0], 10),
+ prompt: category
+ });
+
+ form.reset();
}
render() {
<div className="category-request">
<h2>Submit a Category</h2>
<p>
- Suggest a category to play with your friends. Don't forget to
- include the number of items for each person to submit.
+ Suggest a category to play. Don't forget to include the
+ number of items for each person to submit.
</p>
<form onSubmit={this.handle_submit} >
id="category"
placeholder="6 things at the beach"
required
+ autoComplete="off"
onChange={this.handle_change}
ref={this.category}
/>
}
}
-class Game extends React.Component {
+const PromptOptions = React.memo(props => {
+
+ if (props.prompts.length === 0)
+ return null;
+
+ return (
+ <div className="prompt-options">
+ <h2>Vote on Categories</h2>
+ <p>
+ Select any categories below that you'd like to play.
+ You can choose as many as you'd like.
+ </p>
+ {props.prompts.map(p => {
+ return (
+ <button
+ className="vote-button"
+ key={p.id}
+ onClick={() => fetch_post_json(`vote/${p.id}`) }
+ >
+ {p.prompt}
+ <div className="vote-choices">
+ {p.votes.map(v => {
+ return (
+ <div
+ key={v}
+ className="vote-choice"
+ >
+ {v}
+ </div>
+ );
+ })}
+ </div>
+ </button>
+ );
+ })}
+ </div>
+ );
+});
+
+const LetsPlay = React.memo(props => {
+
+ function handle_click(prompt_id) {
+ fetch_post_json
+ }
+
+ 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);
+
+ this.state = {
+ word_groups: props.words.map(word => [word]),
+ submitted: false,
+ selected: null
+ };
+ }
+
+ async handle_submit() {
+ const response = await fetch_post_json(
+ `judging/${this.props.prompt.id}`,{
+ word_groups: this.state.word_groups
+ }
+ );
+
+ 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 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);
+ }
+ );
+ this.setState({
+ selected: null,
+ word_groups: [...new_groups, [word]]
+ });
+ } 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
+ });
+ } 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_groups.map(word_group => {
+ return (
+ <div
+ className="ambiguity-group"
+ key={word_group[0]}
+ >
+ {word_group.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) {
+ super(props);
+ const items = props.prompt.items;
+
+ this.state = {
+ submitted: false
+ };
+
+ this.answers = [...Array(items)].map(() => React.createRef());
+ this.handle_submit = this.handle_submit.bind(this);
+ }
+
+ async handle_submit(event) {
+ const form = event.currentTarget;
+
+ /* Prevent the default page-changing form-submission behavior. */
+ event.preventDefault();
+
+ const response = await fetch_post_json(`answer/${this.props.prompt.id}`, {
+ answers: this.answers.map(r => r.current.value)
+ });
+ 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;
+ }
+
+ /* Everything worked. Server is happy with our answers. */
+ form.reset();
+ this.setState({
+ submitted: true
+ });
+ }
+
+ render() {
+ if (this.state.submitted)
+ return (
+ <div className="please-wait">
+ <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>
+ </div>
+ );
+
+ return (
+ <div className="active-prompt">
+ <h2>The Game of Empathy</h2>
+ <p>
+ Remember, you're trying to match your answers with
+ what the other players submit.
+ Give {this.props.prompt.items} answers for the following prompt:
+ </p>
+ <h2>{this.props.prompt.prompt}</h2>
+ <form onSubmit={this.handle_submit}>
+ {[...Array(this.props.prompt.items)].map((whocares,i) => {
+ return (
+ <div
+ key={i}
+ className="form-field large">
+ <input
+ type="text"
+ name={`answer_${i}`}
+ required
+ autoComplete="off"
+ ref={this.answers[i]}
+ />
+ </div>
+ );
+ })}
+
+ <div
+ key="submit-button"
+ className="form-field large">
+ <button type="submit">
+ Send
+ </button>
+ </div>
+
+ </form>
+ </div>
+ );
+ }
+}
+
+class Game extends React.PureComponent {
constructor(props) {
super(props);
this.state = {
game_info: {},
player_info: {},
other_players: [],
+ prompts: [],
+ active_prompt: null,
+ players_answered: 0,
+ ambiguities: null,
+ players_judged: 0
};
}
});
}
+ 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);
+ if (idx >= 0) {
+ prompts_copy[idx] = prompt;
+ } else {
+ prompts_copy.push(prompt);
+ }
+ this.setState({
+ prompts: prompts_copy
+ });
+ }
+
+ set_active_prompt(prompt) {
+ this.setState({
+ active_prompt: prompt
+ });
+ }
+
+ 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.map(p => {
+ return (
+ <span key={p}>{p}{" "}</span>
+ );
+ })}
+ </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}
+ />;
+ }
return [
<GameInfo
<p key="spacer"></p>,
<CategoryRequest
key="category-request"
+ />,
+ <PromptOptions
+ key="prompts"
+ prompts={state.prompts}
+ />,
+ <LetsPlay
+ key="lets-play"
+ num_players={1+state.other_players.length}
+ prompts={state.prompts}
/>
];
}