X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=empathy.js;h=46d7f79ff876c3f1de89f75cb76b2ec9a22f3eac;hb=9334a439e495c088d088f986a2f73138530f1dbf;hp=5c2bd18d2b86ff6dd11f29778f4aca7925a28f03;hpb=04466f7f35cfe583ee872dd272ded15be2bf1e0b;p=lmno-server diff --git a/empathy.js b/empathy.js index 5c2bd18..46d7f79 100644 --- a/empathy.js +++ b/empathy.js @@ -3,6 +3,24 @@ const Game = require("./game.js"); const MAX_PROMPT_ITEMS = 20; +/* This time parameter specifies a time period in which a phase will + * not be considered idle in any circumstance. That is, this should be + * a reasonable time in which any "active" player should have at least + * started interacting with the current phase. + * + * Specified in seconds + */ +const PHASE_MINIMUM_TIME = 30; + +/* This parameter gives the amount of time that the game will wait to + * see activity from pending players. If this amount of time passes + * with no activity from any of them, the server will emit an "idle" + * event which will let clients issue a vote to end the current phase. + * + * Specified in seconds + */ +const PHASE_IDLE_TIMEOUT = 30; + class Empathy extends Game { constructor(id) { super(id); @@ -16,11 +34,15 @@ class Empathy extends Game { ambiguities: null, players_judged: [], players_judging: new Set(), + judging_idle: false, end_judging: new Set(), scores: null }; this.answers = []; this.answering_idle_timer = 0; + this.answering_start_time_ms = 0; + this.judging_idle_timer = 0; + this.judging_start_time_ms = 0; this.next_prompt_id = 1; this.equivalencies = {}; } @@ -55,13 +77,24 @@ class Empathy extends Game { this.state.players_answering = new Set(); this.state.answering_idle = false; this.state.end_answers = new Set(); - this.state.ambiguities = 0; + this.state.ambiguities = null; this.state.players_judged = []; this.state.players_judging = new Set(); + this.state.judging_idle = false; this.state.end_judging = new Set(); this.state.scores = null; this.answers = []; + if (this.answering_idle_timer) { + clearTimeout(this.answering_idle_timer); + } + this.answering_idle_timer = 0; + this.answering_start_time_ms = 0; + if (this.judging_idle_timer) { + clearTimeout(this.judging_idle_timer); + } + this.judging_idle_timer = 0; + this.judging_start_time_ms = 0; this.equivalencies = {}; this.broadcast_event_object('game-state', this.state); @@ -145,6 +178,20 @@ class Empathy extends Game { /* And notify all players that this player has answered. */ this.broadcast_event_object('player-answered', player.name); + /* If no players are left in the answering list then we don't need + * to wait for the answering_idle_timer to fire, because a person + * who isn't there obviously can't be typing. So we can broadcast + * the idle event right away. Note that we do this only if the + * answering phase has been going for a while to avoid the case of + * the first player being super fast and emptying the + * players_answering list before anyone else even got in. + */ + if (this.state.players_answering.size === 0 && + ((Date.now() - this.answering_start_time_ms) / 1000) > PHASE_MINIMUM_TIME) + { + this.broadcast_event_object('answering-idle', true); + } + return { valid: true }; } @@ -162,14 +209,18 @@ class Empathy extends Game { if (this.answering_idle_timer) { clearTimeout(this.answering_idle_timer); + this.ansering_idle_timer = 0; } if (! this.state.answering_idle) { this.answering_idle_timer = setTimeout(() => { - this.state_answering_idle = true; + this.state.answering_idle = true; this.broadcast_event_object('answering-idle', true); - }, 10 * 1000); + }, PHASE_IDLE_TIMEOUT * 1000); } + if (this.answering_start_time_ms === 0) + this.answering_start_time_ms = Date.now(); + /* Notify all players that this player is actively answering. */ this.state.players_answering.add(player.name); this.broadcast_event_object('player-answering', player.name); @@ -210,6 +261,10 @@ class Empathy extends Game { return a.toLowerCase().localeCompare(b.toLowerCase()); }); + if (this.judging_start_time_ms === 0) { + this.judging_start_time_ms = Date.now(); + } + this.broadcast_event_object('ambiguities', this.state.ambiguities); } @@ -267,10 +322,25 @@ class Empathy extends Game { /* And notify all players this this player has judged. */ this.broadcast_event_object('player-judged', player.name); + /* If no players are left in the judging list then we don't need + * to wait for the judging_idle_timer to fire, because a person + * who isn't there obviously can't be judging. So we can broadcast + * the idle event right away. Note that we do this only if the + * judging phase has been going for a while to avoid the case of + * the first player being super fast and emptying the + * players_judging list before anyone else even got in. + */ + if (this.state.players_judging.size === 0 && + ((Date.now() - this.judging_start_time_ms) / 1000) > PHASE_MINIMUM_TIME) + { + this.broadcast_event_object('judging-idle', true); + } + return { valid: true }; } receive_judging(prompt_id, session_id) { + const player = this.players_by_session[session_id]; if (! player) return { valid: false, message: "Player not found" }; @@ -282,6 +352,17 @@ class Empathy extends Game { if (prompt !== this.state.active_prompt) return { valid: false, message: "Prompt no longer active" }; + if (this.judging_idle_timer) { + clearTimeout(this.judging_idle_timer); + this.judging_idle_timer = 0; + } + if (! this.state.judging_idle) { + this.judging_idle_timer = setTimeout(() => { + this.state.judging_idle = true; + this.broadcast_event_object('judging-idle', true); + }, PHASE_IDLE_TIMEOUT * 1000); + } + /* Notify all players this this player is actively judging. */ this.state.players_judging.add(player.name); this.broadcast_event_object('player-judging', player.name); @@ -506,7 +587,12 @@ router.post('/end-answers/:prompt_id([0-9]+)', (request, response) => { else response.sendStatus(404); - if (game.state.end_answers.size > (game.state.players_answered.length / 2)) + /* The majority rule here includes all players that have answered as + * well as all that have started typing. */ + const players_involved = (game.state.players_answered.length + + game.state.players_answering.size); + + if (game.state.end_answers.size > players_involved / 2) game.perform_judging(); });