diff --git a/README.md b/README.md
index b6903e4..4cd288f 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,11 @@
-# resistance
-Online multiplayer implementation of resistance game
+# Resistance
+Browser-based implementation of *The Resistance*, a great game for
+playing in groups of five to ten people. One round lasts about 15 to 30 minutes.
+More information about game-play can be found at
+[this link](https://en.wikipedia.org/wiki/The_Resistance_(game)#Gameplay).
+
+## Disclaimer
+*The Resistance* is designed by Don Eskridge (the Designer) and published by
+Indie Boards & Cards (the Publisher). This software is an unofficial fan
+project. The developers of this software are in no way affiliated with, and this
+software is in no way endorsed by, the Designer or the Publisher.
diff --git a/components/Create.js b/components/Create.js
new file mode 100644
index 0000000..541dda2
--- /dev/null
+++ b/components/Create.js
@@ -0,0 +1,66 @@
+'use strict'
+
+import React from 'react'
+import Overlay from './Overlay.js'
+import Spinner from './Spinner.js'
+import { Form, FormGroup, Button, Input, Label, Row, Col } from 'reactstrap'
+import FontAwesomerIcon from './FontAwesomerIcon.js'
+import { faArrowLeft, faArrowRight } from '@fortawesome/free-solid-svg-icons'
+
+export default class Create extends React.Component {
+ constructor (props) {
+ super(props)
+ this.state = {
+ loading: false
+ }
+ this.submit = this.submit.bind(this)
+ }
+ async submit (event) {
+ this.setState({
+ loading: true
+ })
+ if (!(await this.props.onSubmit(event))) {
+ this.setState({
+ loading: false
+ })
+ }
+ }
+ render () {
+ const { children, onSubmit, onClickBack, ...rest } = this.props
+ return (
+
+
+
+ { this.state.loading &&
+
+ Creating game...
+
+ }
+
+ )
+ }
+}
diff --git a/components/FontAwesomerIcon.js b/components/FontAwesomerIcon.js
new file mode 100644
index 0000000..705d2ee
--- /dev/null
+++ b/components/FontAwesomerIcon.js
@@ -0,0 +1,25 @@
+'use strict'
+
+import React from 'react'
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome'
+
+export default class FontAwesomerIcon extends React.Component {
+ constructor (props) {
+ super(props)
+ this.state = {
+ icon: null
+ }
+ }
+ componentDidMount () {
+ this.setState({
+ icon:
+ { this.state.icon }
+
+ )
+ }
+}
diff --git a/components/GameInProgress.js b/components/GameInProgress.js
new file mode 100644
index 0000000..e93616b
--- /dev/null
+++ b/components/GameInProgress.js
@@ -0,0 +1,97 @@
+'use strict'
+
+/* global confirm */
+
+import React from 'react'
+import TeamInfo from './TeamInfo.js'
+import Mission from './Mission.js'
+import Vote from './Vote.js'
+import Scores from './Scores.js'
+import MissionReference from './MissionReference.js'
+import VoteResults from './VoteResults.js'
+import FontAwesomerIcon from './FontAwesomerIcon.js'
+import { faTrashAlt } from '@fortawesome/free-solid-svg-icons'
+import { Row, Col, Button } from 'reactstrap'
+
+export default class GameInProgress extends React.Component {
+ constructor (props) {
+ super(props)
+ this.endRound = this.endRound.bind(this)
+ }
+ endRound () {
+ if (this.props.gameStatus.winner ||
+ confirm('Are you sure you want to end the round?')) {
+ this.props.socketEmmitter('endRound', null, 'Ending round')
+ }
+ }
+ render () {
+ const {
+ gameStatus,
+ canHideTeam,
+ myPlayer,
+ socketEmmitter,
+ draftProposal,
+ ...rest
+ } = this.props
+ const voting = gameStatus.voting
+
+ return (
+
+ { process.env.NODE_ENV !== 'production' &&
+
Player name: {myPlayer.name}
+ }
+
+
+
+
+
+ { voting && !gameStatus.winner &&
+
+
+ }
+ { canHideTeam && !gameStatus.winner &&
+
+
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ )
+ }
+}
diff --git a/components/Join.js b/components/Join.js
new file mode 100644
index 0000000..a84c8e4
--- /dev/null
+++ b/components/Join.js
@@ -0,0 +1,71 @@
+'use strict'
+
+import React from 'react'
+import Overlay from './Overlay.js'
+import Spinner from './Spinner.js'
+import { Form, FormGroup, Button, Input, Label, Row, Col } from 'reactstrap'
+import FontAwesomerIcon from './FontAwesomerIcon.js'
+import { faArrowLeft, faArrowRight } from '@fortawesome/free-solid-svg-icons'
+
+export default class Create extends React.Component {
+ constructor (props) {
+ super(props)
+ this.state = {
+ loading: false
+ }
+ this.submit = this.submit.bind(this)
+ }
+ async submit (event) {
+ this.setState({
+ loading: true
+ })
+ if (!(await this.props.onSubmit(event))) {
+ this.setState({
+ loading: false
+ })
+ }
+ }
+ render () {
+ const { children, onSubmit, onClickBack, ...rest } = this.props
+ return (
+
+
+
+ { this.state.loading &&
+
+ Joining game...
+
+ }
+
+ )
+ }
+}
diff --git a/components/Mission.js b/components/Mission.js
new file mode 100644
index 0000000..33c86db
--- /dev/null
+++ b/components/Mission.js
@@ -0,0 +1,95 @@
+'use strict'
+
+import React from 'react'
+import { Card, CardBody, CardTitle } from 'reactstrap'
+import FontAwesomerIcon from './FontAwesomerIcon.js'
+import { faUserSecret } from '@fortawesome/free-solid-svg-icons'
+import ProposeMissionForm from './ProposeMissionForm.js'
+import MissionDraftProposal from './MissionDraftProposal.js'
+import NextMissionLeaders from './NextMissionLeaders'
+
+export default class Mission extends React.Component {
+ render () {
+ const {
+ myPlayer,
+ gameStatus,
+ socketEmmitter,
+ draftProposal,
+ voting,
+ children,
+ ...rest
+ } = this.props
+ const {
+ players,
+ missions,
+ missionChooserIndex,
+ missionFailIndex,
+ missionNumber
+ } = gameStatus
+ const missionChooser = players[missionChooserIndex].name
+ const mustPass = (missionChooserIndex === missionFailIndex)
+ const missionSize = missions.order[missionNumber]
+ const starRound = (missions.includesStarRound && missionNumber === 3)
+
+ return (
+
+
+ Mission #{ missionNumber + 1 }
+ { mustPass &&
+
+
+ }
+
+ { starRound &&
+
+ 2 must sabotage for mission to fail!
+ }
+
+ { missionSize } players
+ Me
+ : missionChooser
+ }
+
+
+
+ )
+ }
+}
diff --git a/components/MissionDraftProposal.js b/components/MissionDraftProposal.js
new file mode 100644
index 0000000..15ca19c
--- /dev/null
+++ b/components/MissionDraftProposal.js
@@ -0,0 +1,22 @@
+'use strict'
+
+import React from 'react'
+
+export default class MissionDraftProposal extends React.Component {
+ render () {
+ const { myPlayer, draftProposal, children, ...rest } = this.props
+ return (
+
+
Draft Proposal
+
+ { draftProposal.includes(myPlayer.name) &&
+ Me { playerName }
+ ))}
+
+
+
+ Game Reference
+
+ Players: {numPlayers}, including {numSpies} spies.
+
+
+ Mission Order:
+ { missions.order.map((numPlayers, missionNum) => (
+
+ { numPlayers }
+ { missionNum === 3 && missions.includesStarRound && '*' }
+ { missionNum !== missions.order.length - 1 && ', '}
+
+ )) }
+
+ { missions.includesStarRound &&
+
+ *In order for the spies to win this round, 2 spies must sabotage.
+
+ }
+
+
+ )
+ }
+}
diff --git a/components/NextMissionLeaders.js b/components/NextMissionLeaders.js
new file mode 100644
index 0000000..d0d526b
--- /dev/null
+++ b/components/NextMissionLeaders.js
@@ -0,0 +1,48 @@
+'use strict'
+
+import React from 'react'
+import FontAwesomerIcon from './FontAwesomerIcon.js'
+import { faUserSecret } from '@fortawesome/free-solid-svg-icons'
+
+export default class NextMissionLeaders extends React.Component {
+ render () {
+ const listSize = 3
+ const {
+ players,
+ myPlayer,
+ missionChooserIndex,
+ missionFailIndex,
+ children,
+ ...rest
+ } = this.props
+ const nextLeaders = []
+ let playerIndex = missionChooserIndex
+ for (let i = 0; i < listSize; i++) {
+ playerIndex = (playerIndex + 1) % players.length
+ nextLeaders.push({
+ name: players[playerIndex].name,
+ mustPass: (playerIndex === missionFailIndex)
+ })
+ }
+ return (
+
+
Next mission leaders
+
+ { nextLeaders.map(leader => (
+
+ {leader.name === myPlayer.name
+ ? Me : leader.name + ' '}
+ {leader.mustPass &&
+
+ ))}
+
+
+
+
+ { children }
+
+
{title}
+
+ { children }
+
+
+
+ )
+ }
+}
diff --git a/components/PlayerLobby.js b/components/PlayerLobby.js
new file mode 100644
index 0000000..4d4bde5
--- /dev/null
+++ b/components/PlayerLobby.js
@@ -0,0 +1,134 @@
+'use strict'
+
+/* global confirm */
+
+import React from 'react'
+import { Table, Button, Row, Col } from 'reactstrap'
+import FontAwesomerIcon from './FontAwesomerIcon.js'
+import { faTimes,
+ faPencilAlt,
+ faTrashAlt,
+ faArrowRight } from '@fortawesome/free-solid-svg-icons'
+
+export default class PlayerLobby extends React.Component {
+ constructor (props) {
+ super(props)
+ this.handleEditClick = this.handleEditClick.bind(this)
+ this.handleRemoveClick = this.handleRemoveClick.bind(this)
+ this.handleEndGameClick = this.handleEndGameClick.bind(this)
+ this.handleRoundStart = this.handleRoundStart.bind(this)
+ }
+ handleRoundStart () {
+ this.props.socketEmmitter('startRound', null, 'Starting game')
+ }
+ handleEndGameClick () {
+ const confirmed = confirm('Are you sure you want to end the game?')
+ if (confirmed) {
+ this.props.socketEmmitter('deleteGame', null, 'Ending game')
+ }
+ }
+ handleEditClick () {
+ let newName = ''
+ do {
+ newName = window.prompt('Enter a new name:')
+ } while (newName !== null &&
+ (newName === '' || newName === this.props.myPlayer.name))
+
+ if (newName != null) {
+ this.props.socketEmmitter('changeName', {
+ newName: newName
+ }, 'Changing name')
+ }
+ }
+ handleRemoveClick (playerToRemove) {
+ this.props.socketEmmitter('removalRequest', playerToRemove,
+ 'Removing player')
+ }
+ render () {
+ const gameCodeLength = process.env.GAME_CODE_LENGTH
+ const {
+ children,
+ gameCode,
+ players,
+ myPlayer,
+ nameChanger,
+ socketEmmitter,
+ ...rest
+ } = this.props
+ let displayCode = gameCode + ''
+ while (displayCode.length < gameCodeLength) {
+ displayCode = '0' + displayCode
+ }
+ return (
+
+
Game code: { displayCode }
+ { players.length === 1
+ ?
1 player joined
+ :
{players.length} players joined
+ }
+
+
+
+ Name
+ Actions
+
+
+
+ { players.map(player =>
+
+
+ {
+ player.name === myPlayer.name
+ ? {player.name} (me)
+ : player.name
+ }
+
+
+ { player.name === myPlayer.name &&
+
+
+
+
+ }
+ this.handleRemoveClick(player)
+ }>
+
+
+
+ ) }
+
+
+
+
+
+
+ Start game
+
+
+
+
+
+ {(() => {
+ switch (gameStatus.winner) {
+ case 'spies':
+ return (
+
+ Spies win! { spyIcon }
+
+ )
+ case 'resistance':
+ return (
+
+ Resistance wins! { resistanceIcon }
+
+ )
+ default:
+ return (
+
+
+ { resistanceIcon } { scores.resistance }
+
+ {' - '}
+
+ { scores.spies } { spyIcon }
+
+
+ )
+ }
+ })()}
+
+
+
+ )
+ }
+}
diff --git a/components/Spinner.js b/components/Spinner.js
new file mode 100644
index 0000000..52c65c1
--- /dev/null
+++ b/components/Spinner.js
@@ -0,0 +1,61 @@
+'use strict'
+
+import React from 'react'
+
+export default class Spinner extends React.Component {
+ render () {
+ const {
+ size = '100px',
+ children,
+ color = '#333333',
+ centered = true,
+ ...rest
+ } = this.props
+
+ const containerClasses = `spinner-container ${centered && 'centered'}`
+
+ return (
+
+ )
+ }
+}
diff --git a/components/TeamInfo.js b/components/TeamInfo.js
new file mode 100644
index 0000000..dca806b
--- /dev/null
+++ b/components/TeamInfo.js
@@ -0,0 +1,79 @@
+'use strict'
+
+import React from 'react'
+import {
+ Card,
+ CardBody,
+ CardTitle,
+ Button,
+ Row,
+ Col } from 'reactstrap'
+import FontAwesomerIcon from './FontAwesomerIcon.js'
+import { faFistRaised, faUserSecret } from '@fortawesome/free-solid-svg-icons'
+
+export default class TeamInfo extends React.Component {
+ constructor (props) {
+ super(props)
+ this.state = {
+ showing: true
+ }
+ this.toggle = this.toggle.bind(this)
+ }
+ toggle () {
+ this.setState({
+ showing: !this.state.showing
+ })
+ }
+ render () {
+ const { myPlayer, canHideTeam, gameStatus, ...rest } = this.props
+ return (
+
+
+ { (this.state.showing || !canHideTeam) &&
+
+
+ { myPlayer.isSpy
+ ? (
+
+ You are a
+ Spy
+
+ )
+ : (
+
+ You are in the
+ Resistance
+
+ )
+ }
+
+ { myPlayer.isSpy &&
+
+ { gameStatus.spies.length > 2
+ ? 'The other spies are:' : 'The other spy is:'}
+
+ { gameStatus.spies.map(name => (
+ name !== myPlayer.name && { name }
+ )) }
+
+
+ }
+
+
+ { this.state.showing ? 'Hide' : 'Show' } player info
+
+
+
+
+
+ )
+ }
+}
diff --git a/components/Vote.js b/components/Vote.js
new file mode 100644
index 0000000..2a0c544
--- /dev/null
+++ b/components/Vote.js
@@ -0,0 +1,135 @@
+'use strict'
+
+/* global confirm */
+
+import React from 'react'
+import { Card, CardTitle, CardBody, Button, Row, Col } from 'reactstrap'
+import Spinner from './Spinner.js'
+import FontAwesomerIcon from './FontAwesomerIcon.js'
+import { faFistRaised,
+ faUserSecret,
+ faThumbsUp,
+ faThumbsDown } from '@fortawesome/free-solid-svg-icons'
+
+export default class Vote extends React.Component {
+ constructor (props) {
+ super(props)
+ this.state = {
+ voted: false
+ }
+ }
+
+ vote (votedYes) {
+ if (this.props.voting.isProposal || votedYes || this.props.myPlayer.isSpy) {
+ let vote
+ if (this.props.voting.isProposal) {
+ if (votedYes) {
+ vote = 'UPVOTE'
+ } else {
+ vote = 'DOWNVOTE'
+ }
+ } else {
+ if (votedYes) {
+ vote = 'COMPLETE MISSION'
+ } else {
+ vote = 'SABOTAGE'
+ }
+ }
+ if (confirm('Confirm vote: ' + vote)) {
+ this.props.socketEmmitter('submitVote', votedYes)
+ this.setState({
+ voted: true
+ })
+ }
+ }
+ }
+
+ componentDidUpdate (prevProps) {
+ if (this.props.voting.voteId !== prevProps.voting.voteId) {
+ this.setState({
+ voted: false
+ })
+ }
+ }
+
+ render () {
+ const { voting, socketEmmitter, children, myPlayer, ...rest } = this.props
+
+ const buttonContent = {
+ proposal: {
+ yes: Upvote ,
+ no: Downvote
+ },
+ missionVote: {
+ yes: (
+
+ Complete Mission
+ ),
+ no: Sabotage
+ }
+ }
+
+ return (
+
+
+ { (voting.isProposal || voting.missionList.includes(myPlayer.name)) &&
+ !this.state.voted
+ ? (
+
+
Vote
+ { voting.isProposal ? 'Mission proposal:' : 'Mission:' }
+
+
+ { voting.missionList.includes(myPlayer.name) &&
+ Me { player }
+ ))}
+
+
+
+ this.vote(true)}>
+ { voting.isProposal
+ ? buttonContent.proposal.yes
+ : buttonContent.missionVote.yes
+ }
+
+ this.vote(false)}>
+ { voting.isProposal
+ ? buttonContent.proposal.no
+ : buttonContent.missionVote.no
+ }
+
+
+
+ Your vote is { voting.isProposal ? 'public' : 'private'}.
+
+
+
+
+
+ Waiting for votes...
+
+
+
+ )
+ }
+}
diff --git a/components/VoteResults.js b/components/VoteResults.js
new file mode 100644
index 0000000..29a8e1e
--- /dev/null
+++ b/components/VoteResults.js
@@ -0,0 +1,163 @@
+'use strict'
+
+import React from 'react'
+import { Alert, Row, Col } from 'reactstrap'
+import FontAwesomerIcon from './FontAwesomerIcon.js'
+import { faFistRaised, faUserSecret } from '@fortawesome/free-solid-svg-icons'
+
+export default class VoteResults extends React.Component {
+ constructor (props) {
+ super(props)
+ this.state = {
+ proposalVisible: true,
+ missionVisible: true
+ }
+ this.dismissProposal = this.dismissProposal.bind(this)
+ this.dismissMission = this.dismissMission.bind(this)
+ }
+
+ dismissProposal () {
+ this.setState({
+ proposalVisible: false
+ })
+ }
+
+ dismissMission () {
+ this.setState({
+ missionVisible: false
+ })
+ }
+
+ componentDidUpdate (prevProps) {
+ const prevResults = prevProps.voteResults
+ const newResults = this.props.voteResults
+ const newResultsContainProposal = (
+ newResults != null && newResults.proposal != null
+ )
+ const proposalResultsChanged = (
+ newResultsContainProposal && (
+ prevResults == null ||
+ prevResults.proposal == null ||
+ prevResults.proposal.voteId !== newResults.proposal.voteId
+ )
+ )
+ const newResultsContainMission = (
+ newResults != null && newResults.mission != null
+ )
+ const missionResultsChanged = (
+ newResultsContainMission && (
+ prevResults == null ||
+ prevResults.mission == null ||
+ prevResults.mission.voteId !== newResults.mission.voteId
+ )
+ )
+ if (proposalResultsChanged) {
+ this.setState({
+ proposalVisible: true
+ })
+ }
+ if (missionResultsChanged) {
+ this.setState({
+ missionVisible: true
+ })
+ }
+ }
+
+ render () {
+ const {
+ voteResults: { proposal, mission },
+ myPlayer,
+ children,
+ ...rest
+ } = this.props
+ return (
+
+ { proposal &&
+
+
+ Proposal { proposal.passed
+ ? `passes ${proposal.tally.yes}-${proposal.tally.no}.`
+ : `fails ${proposal.tally.no}-${proposal.tally.yes}.`
+ }
+
+
+ Mission list: { proposal.missionList.map((name, index) => (
+
+ {name === myPlayer.name ? Me : name}
+ {index !== proposal.missionList.length - 1 && ', '}
+
+ ))}
+
+ { proposal.tally.yes !== 0 && proposal.tally.no !== 0 &&
+
+ Voted yes:
+
+ { proposal.votes.map(vote => (
+ vote.vote === true &&
+
+ { vote.name === myPlayer.name
+ ? Me
+ : vote.name
+ }
+
+ ))}
+
+
+ Voted no:
+
+ { proposal.votes.map(vote => (
+ vote.vote === false &&
+
+ { vote.name === myPlayer.name
+ ? Me
+ : vote.name
+ }
+
+ ))}
+
+
+
+ }
+
+ }
+ { mission &&
+
+
+ Mission #{mission.missionNumber + 1} { mission.passed
+ ? (
+
+ accomplished!
+ )
+ : (
+
+ failed.
+ )
+ }
+
+
+ Mission list: { proposal.missionList.map((name, index) => (
+
+ {name === myPlayer.name ? Me : name}
+ {index !== proposal.missionList.length - 1 && ', '}
+
+ ))}
+
+ { mission.tally.no > 0 &&
+
+ {mission.tally.no} {
+ mission.tally.no === 1 ? 'spy' : 'spies'
+ } sabotaged this mission.
+
+ }
+
+ }
+
Waiting for players ,
+ show: [],
+ gameInProgress: false,
+ gameCode: '',
+ gameStatus: {},
+ loadMessage: '',
+ draftProposal: [],
+ player: {},
+ canHideTeam: true
+ }
+ this.socketEmmitter = this.socketEmmitter.bind(this)
+ }
+ handleUnload (e) {
+ e.preventDefault()
+ e.returnValue = ''
+ }
+ socketEmmitter (event, message, loadMessage) {
+ this.socket.emit(event, message)
+ if (loadMessage) {
+ this.setState({
+ loadMessage: loadMessage + '...'
+ })
+ }
+ }
+ componentDidMount () {
+ const noTeamHidingTime = 3000
+ if (sessionStorage.authKey) {
+ const player = JSON.parse(sessionStorage.authKey)
+ this.setState({
+ player: player,
+ gameCode: player.gameCode
+ })
+
+ this.socket = io()
+
+ this.socket.on('connect', () => {
+ this.socket.emit('authRequest', this.state.player)
+ })
+
+ this.socket.on('disconnect', () => {
+ this.setState({
+ loadMessage: 'Offline. Attemting to reconnect...'
+ })
+ })
+
+ this.socket.on('myError', error => {
+ console.error(error)
+ this.setState({
+ loadMessage: ''
+ })
+ alert(error.message)
+ if (error.type === 'authError') {
+ sessionStorage.removeItem('authKey')
+ Router.push('/')
+ }
+ })
+
+ this.socket.on('draftProposal', playerList => {
+ this.setState({
+ draftProposal: playerList
+ })
+ })
+
+ this.socket.on('gameStatus', status => {
+ if (status.playing) {
+ console.log(status.spies)
+ this.setState(prevState => ({
+ gameInProgress: true,
+ gameStatus: status,
+ draftProposal: [],
+ player: {
+ ...prevState.player,
+ isSpy: (status.spies != null)
+ }
+ }))
+ } else {
+ this.setState({
+ gameStatus: status,
+ gameInProgress: false
+ })
+ }
+ })
+
+ this.socket.on('gameStarted', () => {
+ this.setState({ canHideTeam: false })
+ setTimeout(() => {
+ this.setState({ canHideTeam: true })
+ }, noTeamHidingTime)
+ })
+
+ this.socket.on('loading', loadMessage => {
+ this.setState({
+ loadMessage: loadMessage + '...'
+ })
+ })
+
+ this.socket.on('actionCompleted', () => this.setState({
+ loadMessage: ''
+ }))
+
+ this.socket.on('nameChanged', msg => {
+ this.setState(prevState => ({
+ player: {
+ ...prevState.player,
+ name: msg.newName
+ }
+ }))
+ sessionStorage.authKey = JSON.stringify(this.state.player)
+ })
+
+ this.socket.on('kicked', () => {
+ sessionStorage.removeItem('authKey')
+ Router.push('/')
+ })
+
+ window.addEventListener('beforeunload', this.handleUnload)
+ } else {
+ Router.push('/')
+ }
+ }
+ componentWillUnmount () {
+ if (this.socket) {
+ this.socket.disconnect()
+ delete this.socket
+ }
+ window.removeEventListener('beforeunload', this.handleUnload)
+ }
+ render () {
+ return (
+
+ { !this.state.gameInProgress
+ ? (
+
+
{this.state.header}
+
+
+ { this.state.loadMessage }
+
+ }
+
+
+ )
+ }
+}
diff --git a/pages/index.js b/pages/index.js
new file mode 100644
index 0000000..9b30fc4
--- /dev/null
+++ b/pages/index.js
@@ -0,0 +1,106 @@
+'use strict'
+
+/* global fetch, sessionStorage, alert */
+
+import React from 'react'
+import Router from 'next/router'
+import PageLayout from '../components/PageLayout.js'
+import PageHeader from '../components/PageHeader.js'
+import Home from '../components/Home.js'
+import Create from '../components/Create.js'
+import Join from '../components/Join.js'
+
+export default class Index extends React.Component {
+ constructor (props) {
+ super(props)
+ this.state = {
+ header: 'Resistance',
+ show: ['home']
+ }
+ this.handleCreate = this.handleCreate.bind(this)
+ this.handleJoin = this.handleJoin.bind(this)
+ this.backToHome = this.backToHome.bind(this)
+ }
+ showing (componentName) {
+ return this.state.show.includes(componentName)
+ }
+ handleCreate () {
+ this.setState({
+ show: ['create'],
+ header: 'Create Game'
+ })
+ }
+ handleJoin () {
+ this.setState({
+ show: ['join'],
+ header: 'Join Game'
+ })
+ }
+ async handleCreateJoinSubmit (event) {
+ try {
+ event.preventDefault()
+ const form = event.target
+ const data = { playerName: form.name.value }
+ if (form.code && (form.code.value >= 1000000 || form.code.value < 0)) {
+ throw new Error(
+ 'Game must be 6 digits or less, and cannot be negative.'
+ )
+ } else if (form.code) {
+ data.gameCode = form.code.value
+ }
+ const response = await fetch('/join', {
+ method: 'post',
+ headers: {
+ 'Content-type': 'application/json; charset=UTF-8'
+ },
+ body: JSON.stringify(data)
+ })
+ const responseData = await response.json()
+
+ if (responseData.error) {
+ throw responseData.error
+ }
+ sessionStorage.authKey = JSON.stringify(responseData)
+ Router.push('/game')
+ return true
+ } catch (e) {
+ alert('Error: ' + e.message)
+ if (e.name !== 'UserException') {
+ console.error(e)
+ }
+ return false
+ }
+ }
+ backToHome () {
+ this.setState({
+ header: 'Resistance',
+ show: ['home']
+ })
+ }
+ render () {
+ return (
+
+
+ { this.state.header }
+
+ { this.showing('home') &&
+
+ )
+ }
+}
diff --git a/server.js b/server.js
index cbf60b5..eea6247 100644
--- a/server.js
+++ b/server.js
@@ -1,25 +1,30 @@
'use strict'
-const express = require('express')
-const next = require('next')
+const server = require('express')()
+const http = require('http').createServer(server)
+const io = require('socket.io')(http)
+const initDb = require('./server_modules/db.js').initDb
+const handleExpressRequests =
+ require('./server_modules/handleExpressRequests')
+const handleSocketConnections =
+ require('./server_modules/handleSocketConnections.js')
-const dev = process.env.NODE_ENV !== 'production'
-const app = next({ dev })
-const handle = app.getRequestHandler()
-
-async function runApp() {
+async function runApp () {
try {
- await app.prepare()
- const server = express()
- server.get('*', (req, res) => {
- return handle(req, res)
- })
- server.listen(process.env.PORT || 3000, (err) => {
+ await initDb()
+
+ await handleExpressRequests(server)
+
+ handleSocketConnections(io)
+
+ http.listen(process.env.PORT || 3000, err => {
if (err) throw err
console.log('> Ready on http://localhost:3000')
})
- } catch (err) {
- console.error(err.stack)
+ } catch (e) {
+ console.error(e.stack)
process.exit(1)
}
}
+
+runApp()
diff --git a/server_modules/UserException.js b/server_modules/UserException.js
new file mode 100644
index 0000000..aee15bc
--- /dev/null
+++ b/server_modules/UserException.js
@@ -0,0 +1,22 @@
+'use strict'
+
+class UserException extends Error {
+ constructor (message, type) {
+ super(message)
+ this.message = message
+ this.name = 'UserException'
+ this.type = type || ''
+ }
+ toString () {
+ return `Error: ${this.message}`
+ }
+ toJSON () {
+ return {
+ name: this.name,
+ message: this.message,
+ type: this.type
+ }
+ }
+}
+
+module.exports = UserException
diff --git a/server_modules/authUser.js b/server_modules/authUser.js
new file mode 100644
index 0000000..49f75ad
--- /dev/null
+++ b/server_modules/authUser.js
@@ -0,0 +1,45 @@
+'use strict'
+
+const crypto = require('crypto')
+const UserException = require('./UserException.js')
+const getGamesCollection = require('./db.js').getGamesCollection
+
+async function authUser (gameDb, socketClientId, authKey) {
+ const gamesCollection = getGamesCollection()
+
+ let query = { code: parseInt(authKey.gameCode) }
+ if (!(await gamesCollection.findOne(query))) {
+ throw new UserException(
+ 'The game you are trying to enter does not exist',
+ 'authError'
+ )
+ }
+ query = {
+ name: authKey.name
+ }
+ const player = await gameDb.collection('players').findOne(query)
+ if (!player) {
+ throw new UserException(
+ 'You have not yet joined the game properly',
+ 'authError'
+ )
+ }
+ await gameDb.collection('players').updateOne(query, {
+ $set: {
+ hasConnected: true
+ }
+ })
+ const hash = crypto.createHash('sha256')
+ hash.update(authKey.key)
+ if (hash.digest('hex') === player.hashedKey) {
+ return {
+ authenticated: true,
+ name: authKey.name,
+ hasConnected: player.hasConnected
+ }
+ } else {
+ throw new UserException('Unauthorized', 'authError')
+ }
+}
+
+module.exports = authUser
diff --git a/server_modules/changeName.js b/server_modules/changeName.js
new file mode 100644
index 0000000..74d2be0
--- /dev/null
+++ b/server_modules/changeName.js
@@ -0,0 +1,28 @@
+'use strict'
+
+const UserException = require('./UserException.js')
+
+async function changeName (gameDb, currentName, newName) {
+ if (currentName === newName) {
+ throw new UserException('You entered the same name as your current name')
+ } else if (newName === '') {
+ throw new UserException('You cannot have a blank name')
+ }
+ const status = await gameDb.collection('status').findOne({})
+ if (status.playing) {
+ throw new UserException('Cannot changle player name while game in progress')
+ }
+ const query = { name: currentName }
+ const mongoPlayer = await gameDb.collection('players').findOne(query)
+ if (!mongoPlayer) {
+ throw new UserException('Your current player does not exist')
+ }
+ await gameDb.collection('players').updateOne(query, {
+ $set: {
+ name: newName
+ }
+ })
+ return newName
+}
+
+module.exports = changeName
diff --git a/server_modules/createGame.js b/server_modules/createGame.js
new file mode 100644
index 0000000..bdf2790
--- /dev/null
+++ b/server_modules/createGame.js
@@ -0,0 +1,27 @@
+'use strict'
+
+const constants = require('../constants.js')
+
+async function createGame (db, gamesCollection) {
+ // Creates game and returns the code
+ const gameCodeLength = constants.GAME_CODE_LENGTH
+ if (await gamesCollection.countDocuments() > 100000) {
+ throw new Error('There are too many games in progress to start a new one.')
+ }
+ let gameCode
+ do {
+ gameCode = Math.floor(Math.random() * (10 ** gameCodeLength))
+ } while (await gamesCollection.findOne({ code: gameCode }))
+ await Promise.all([
+ db.db('game-' + gameCode).collection('status').insertOne({
+ playing: false,
+ lastGameStart: new Date()
+ }),
+ gamesCollection.insertOne({
+ code: gameCode
+ })
+ ])
+ return gameCode
+}
+
+module.exports = createGame
diff --git a/server_modules/db.js b/server_modules/db.js
new file mode 100644
index 0000000..a4f194c
--- /dev/null
+++ b/server_modules/db.js
@@ -0,0 +1,33 @@
+'use strict'
+
+const assert = require('assert')
+const constants = require('../constants.js')
+const MongoClient = require('mongodb').MongoClient
+
+let db, gamesCollection
+
+async function initDb () {
+ if (db) {
+ console.warn('Attempting to init DB again')
+ return db
+ }
+ db = await MongoClient.connect(constants.MONGO_URL, {
+ useNewUrlParser: true
+ })
+ gamesCollection = db.db('games').collection('games')
+}
+
+function getDb () {
+ assert.ok(db, 'Must init DB before trying to get DB')
+ return db
+}
+
+function getGamesCollection () {
+ assert.ok(gamesCollection,
+ 'Must init DB before trying to get games collection')
+ return gamesCollection
+}
+
+exports.initDb = initDb
+exports.getDb = getDb
+exports.getGamesCollection = getGamesCollection
diff --git a/server_modules/emitStatusToTeams.js b/server_modules/emitStatusToTeams.js
new file mode 100644
index 0000000..71f26af
--- /dev/null
+++ b/server_modules/emitStatusToTeams.js
@@ -0,0 +1,15 @@
+'use strict'
+
+async function emitStatusToTeams (sockets, status) {
+ const resistanceSockets = Object.assign({}, sockets)
+ for (const spy of status.spies) {
+ sockets[spy].emit('gameStatus', status)
+ delete resistanceSockets[spy]
+ }
+ delete status.spies
+ for (const player in resistanceSockets) {
+ sockets[player].emit('gameStatus', status)
+ }
+}
+
+module.exports = emitStatusToTeams
diff --git a/server_modules/endRound.js b/server_modules/endRound.js
new file mode 100644
index 0000000..e188521
--- /dev/null
+++ b/server_modules/endRound.js
@@ -0,0 +1,30 @@
+'use strict'
+
+const UserException = require('./UserException.js')
+
+async function endRound (gameDb) {
+ const gameStatus = await gameDb.collection('status').findOne({})
+ if (!gameStatus.playing) {
+ throw new UserException('Cannot end round. No round is in progress.')
+ }
+ await Promise.all([
+ gameDb.collection('status').updateOne({}, {
+ $set: { playing: false },
+ $unset: {
+ voting: '',
+ missionChooserIndex: '',
+ missionFailIndex: '',
+ missions: '',
+ numPlayers: '',
+ scores: '',
+ missionNumber: '',
+ winner: '',
+ voteResults: '',
+ numSpies: ''
+ }
+ }),
+ gameDb.collection('teams').drop()
+ ])
+}
+
+module.exports = endRound
diff --git a/server_modules/endVote.js b/server_modules/endVote.js
new file mode 100644
index 0000000..9586b0f
--- /dev/null
+++ b/server_modules/endVote.js
@@ -0,0 +1,91 @@
+'use strict'
+
+const UserException = require('./UserException.js')
+const startVote = require('./startVote.js')
+const startNextMission = require('./startNextMission.js')
+
+async function endVote (gameDb) {
+ const [ status, votes ] = await Promise.all([
+ gameDb.collection('status').findOne({}),
+ gameDb.collection('votes').find({}).toArray()
+ ])
+ if (!status.voting) {
+ throw new UserException('Cannot end vote. The vote is not in progress.')
+ }
+ const noVotes = votes.filter(vote => vote.vote === false).length
+ const yesVotes = votes.length - noVotes
+ const voteData = {
+ missionNumber: status.missionNumber,
+ tally: {
+ yes: yesVotes,
+ no: noVotes
+ },
+ ...status.voting
+ }
+ let mongoCommands = []
+ if (status.voting.isProposal) {
+ if (yesVotes > noVotes) {
+ const newVote = Object.assign({}, status.voting)
+ newVote.isProposal = false
+ mongoCommands.push(startVote(gameDb, newVote, true))
+ } else if (status.missionChooserIndex === status.missionFailIndex) {
+ const newScores = {
+ resistance: status.scores.resistance,
+ spies: status.scores.spies + 1
+ }
+ await gameDb.collection('status').updateOne({}, {
+ $set: { scores: newScores },
+ $unset: { voting: '' }
+ })
+ mongoCommands.push(startNextMission(gameDb, status, newScores))
+ } else {
+ const newIndex = (status.missionChooserIndex + 1) % status.numPlayers
+ mongoCommands.push(gameDb.collection('status').updateOne({}, {
+ $set: { missionChooserIndex: newIndex },
+ $unset: { voting: '' }
+ }))
+ }
+ mongoCommands.push(
+ gameDb.collection('status').updateOne({}, {
+ $set: {
+ 'voteResults.proposal': {
+ votes: votes,
+ passed: yesVotes > noVotes,
+ ...voteData
+ }
+ }
+ })
+ )
+ } else {
+ delete voteData.votes
+ const isStarRound = (
+ status.missionNumber === 3 && status.missions.includesStarRound === true
+ )
+ const failed = (!isStarRound && noVotes > 0) || noVotes > 1
+ let newScores
+ if (failed) {
+ newScores = {
+ resistance: status.scores.resistance,
+ spies: status.scores.spies + 1
+ }
+ } else {
+ newScores = {
+ resistance: status.scores.resistance + 1,
+ spies: status.scores.spies
+ }
+ }
+ mongoCommands.push(
+ gameDb.collection('status').updateOne({}, {
+ $set: {
+ scores: newScores,
+ 'voteResults.mission': { passed: !failed, ...voteData }
+ },
+ $unset: { voting: '' }
+ }),
+ startNextMission(gameDb, status, newScores)
+ )
+ }
+ await Promise.all(mongoCommands)
+}
+
+module.exports = endVote
diff --git a/server_modules/getGameStatus.js b/server_modules/getGameStatus.js
new file mode 100644
index 0000000..8bd7032
--- /dev/null
+++ b/server_modules/getGameStatus.js
@@ -0,0 +1,49 @@
+'use strict'
+
+function cleanPlayers (players) {
+ // return only player properties safe to share with client
+ return players.map(player => ({
+ name: player.name,
+ order: player.order,
+ gameCode: player.gameCode
+ }))
+}
+
+async function getGameStatus (gameDb, player) {
+ try {
+ const [gameStatus, players, teams] = await Promise.all([
+ gameDb.collection('status').findOne({}),
+ gameDb.collection('players').find({}).toArray(),
+ gameDb.collection('teams').findOne({})
+ ])
+ const cleanedPlayers = cleanPlayers(players)
+ if (gameStatus.playing) {
+ // TODO: add actions for mission proposal, voting, etc.
+ const { lastGameStart, ...cleanedStatus } = gameStatus
+ if (player != null && teams.resistance.includes(player)) {
+ return {
+ players: cleanedPlayers,
+ ...cleanedStatus
+ }
+ } else {
+ return {
+ spies: teams.spies,
+ players: cleanedPlayers,
+ ...cleanedStatus
+ }
+ }
+ } else {
+ return {
+ playing: false,
+ players: cleanedPlayers
+ }
+ }
+ } catch (e) {
+ console.error(e)
+ return {
+ error: new Error('An unexpected error occurred')
+ }
+ }
+}
+
+module.exports = getGameStatus
diff --git a/server_modules/handleExpressRequests.js b/server_modules/handleExpressRequests.js
new file mode 100644
index 0000000..fd523c0
--- /dev/null
+++ b/server_modules/handleExpressRequests.js
@@ -0,0 +1,51 @@
+'use strict'
+
+const bodyParser = require('body-parser')
+const next = require('next')
+const getDb = require('./db.js').getDb
+const joinGame = require('./joinGame.js')
+const UserException = require('./UserException.js')
+
+const dev = process.env.NODE_ENV !== 'production'
+const app = next({ dev })
+const handle = app.getRequestHandler()
+
+async function handleExpressRequests (server) {
+ const db = getDb()
+
+ await app.prepare()
+
+ server.use(bodyParser.urlencoded({ extended: false }))
+ server.use(bodyParser.json())
+
+ server.get('*', (req, res) => {
+ return handle(req, res)
+ })
+
+ // create or join game
+ server.post('/join', async (req, res) => {
+ try {
+ const { playerName } = req.body
+ let { gameCode } = req.body
+
+ // Join game, send name and key to client
+ res.json(await joinGame(db, playerName, gameCode))
+ } catch (e) {
+ if (e instanceof UserException || dev) {
+ res.json({ error: e })
+ if (!(e instanceof UserException)) {
+ console.error(e)
+ }
+ } else {
+ res.status(500).json({
+ error: new Error(
+ 'An unexpected error occurred while processing your request'
+ )
+ })
+ console.error(e)
+ }
+ }
+ })
+}
+
+module.exports = handleExpressRequests
diff --git a/server_modules/handleSocketConnections.js b/server_modules/handleSocketConnections.js
new file mode 100644
index 0000000..60f6239
--- /dev/null
+++ b/server_modules/handleSocketConnections.js
@@ -0,0 +1,206 @@
+'use strict'
+
+const UserException = require('./UserException.js')
+const getDb = require('./db.js').getDb
+const getGamesCollection = require('./db.js').getGamesCollection
+const authUser = require('./authUser.js')
+const getGameStatus = require('./getGameStatus.js')
+const changeName = require('./changeName.js')
+const removePlayer = require('./removePlayer.js')
+const handleSocketError = require('./handleSocketError.js')
+const startRound = require('./startRound.js')
+const startVote = require('./startVote.js')
+const submitVote = require('./submitVote.js')
+const endRound = require('./endRound.js')
+const emitStatusToTeams = require('./emitStatusToTeams.js')
+const periodicallyDeleteGames = require('./periodicallyDeleteGames.js')
+
+function handleSocketConnections (io) {
+ const db = getDb()
+ const gamesCollection = getGamesCollection()
+
+ const sockets = {}
+ const missionChoosers = {}
+ io.on('connection', socket => {
+ let player = {
+ authenticated: false
+ }
+ let gameDb, roomAll, gameCode, gameDashCode
+
+ socket.on('authRequest', async authKey => {
+ try {
+ gameCode = authKey.gameCode
+ gameDashCode = 'game-' + gameCode
+ gameDb = db.db(gameDashCode)
+ player = await authUser(gameDb, socket.client.id, authKey)
+ socket.join(gameDashCode)
+ roomAll = gameDashCode
+ if (!sockets[gameCode]) {
+ sockets[gameCode] = {}
+ }
+ sockets[gameCode][player.name] = socket
+ if (player.hasConnected) {
+ socket.emit('gameStatus', await getGameStatus(gameDb, player.name))
+ } else {
+ io.to(roomAll).emit('gameStatus', await getGameStatus(gameDb))
+ }
+ socket.emit('actionCompleted')
+ } catch (e) {
+ handleSocketError(e, socket)
+ }
+ })
+
+ socket.on('changeName', async msg => {
+ if (player.authenticated) {
+ try {
+ const oldName = player.name
+ player.name = await changeName(gameDb, player.name, msg.newName)
+ sockets[gameCode][player.name] = socket
+ delete sockets[gameCode][oldName]
+ socket.emit('nameChanged', msg)
+ io.to(roomAll).emit('gameStatus', await getGameStatus(gameDb))
+ socket.emit('actionCompleted')
+ } catch (e) {
+ handleSocketError(e, socket)
+ }
+ }
+ })
+
+ socket.on('startRound', async () => {
+ if (player.authenticated) {
+ try {
+ socket.broadcast.to(roomAll).emit('loading', 'Starting game')
+ await startRound(gameDb)
+ const status = await getGameStatus(gameDb)
+ emitStatusToTeams(sockets[gameCode], status)
+ missionChoosers[gameCode] = status.players[status.missionChooserIndex]
+ io.to(roomAll).emit('gameStarted')
+ } catch (e) {
+ handleSocketError(e, socket)
+ } finally {
+ io.to(roomAll).emit('actionCompleted')
+ }
+ }
+ })
+
+ socket.on('draftProposal', async playerList => {
+ if (player.authenticated) {
+ try {
+ let isMissionChooser
+ if (missionChoosers[gameCode] &&
+ missionChoosers[gameCode].name === (player.name)) {
+ isMissionChooser = true
+ } else {
+ let status = await getGameStatus(gameDb)
+ const chooserName = status.players[status.missionChooserIndex].name
+ isMissionChooser = (chooserName === player.name)
+ }
+ if (isMissionChooser) {
+ socket.broadcast.to(roomAll).emit('draftProposal', playerList)
+ }
+ } catch (e) {
+ handleSocketError(e, socket)
+ }
+ }
+ })
+
+ socket.on('finalProposal', async playerList => {
+ if (player.authenticated) {
+ try {
+ let isMissionChooser
+ let status = await getGameStatus(gameDb)
+ const chooserName = status.players[status.missionChooserIndex].name
+ isMissionChooser = (chooserName === player.name)
+ if (!isMissionChooser) {
+ throw new UserException('You are not the mission chooser!')
+ }
+ await startVote(gameDb, {
+ isProposal: true,
+ missionList: playerList
+ })
+ const newStatus = await getGameStatus(gameDb)
+ emitStatusToTeams(sockets[gameCode], newStatus)
+ } catch (e) {
+ handleSocketError(e, socket)
+ }
+ }
+ })
+
+ socket.on('submitVote', async vote => {
+ // vote is true or false, indicating yes or no vote
+ if (player.authenticated) {
+ try {
+ await submitVote(gameDb, vote, player)
+ emitStatusToTeams(sockets[gameCode], await getGameStatus(gameDb))
+ } catch (e) {
+ handleSocketError(e, socket)
+ }
+ }
+ })
+
+ socket.on('endRound', async () => {
+ if (player.authenticated) {
+ try {
+ socket.broadcast.to(roomAll).emit('loading', 'Ending round')
+ await endRound(gameDb)
+ delete missionChoosers[gameCode]
+ io.to(roomAll).emit('gameStatus', await getGameStatus(gameDb))
+ } catch (e) {
+ handleSocketError(e, socket)
+ } finally {
+ io.to(roomAll).emit('actionCompleted')
+ }
+ }
+ })
+
+ socket.on('removalRequest', async playerToRemove => {
+ if (player.authenticated) {
+ try {
+ const result = await removePlayer(gameDb, playerToRemove)
+ io.to(roomAll).emit('removedPlayer', result.playerToRemove)
+ const removedSocket = sockets[gameCode][playerToRemove.name]
+ if (removedSocket) {
+ removedSocket.emit('kicked')
+ removedSocket.disconnect()
+ delete sockets[gameCode][playerToRemove.name]
+ }
+ if (Object.keys(sockets[gameCode]).length === 0) {
+ delete sockets[gameCode]
+ } else {
+ io.to(roomAll).emit('gameStatus', await getGameStatus(gameDb))
+ socket.emit('actionCompleted')
+ }
+ } catch (e) {
+ handleSocketError(e, socket)
+ }
+ }
+ })
+
+ socket.on('deleteGame', async () => {
+ if (player.authenticated) {
+ try {
+ await Promise.all([
+ gameDb.dropDatabase(),
+ gamesCollection.removeOne({ code: gameCode })
+ ])
+ io.to(roomAll).emit('kicked')
+ for (const playerName in sockets[gameCode]) {
+ sockets[gameCode][playerName].disconnect()
+ }
+ delete sockets[gameCode]
+ } catch (e) {
+ handleSocketError(e, socket)
+ }
+ }
+ })
+ })
+
+ periodicallyDeleteGames(deletedGames => {
+ for (const game of deletedGames) {
+ if (sockets[game]) delete sockets[game]
+ if (missionChoosers[game]) delete missionChoosers[game]
+ }
+ })
+}
+
+module.exports = handleSocketConnections
diff --git a/server_modules/handleSocketError.js b/server_modules/handleSocketError.js
new file mode 100644
index 0000000..072ca8e
--- /dev/null
+++ b/server_modules/handleSocketError.js
@@ -0,0 +1,17 @@
+'use strict'
+
+const UserException = require('./UserException.js')
+
+function handleSocketError (e, socket) {
+ if (e instanceof UserException) {
+ socket.emit('myError', e)
+ if (e.type === 'authError') {
+ socket.disconnect()
+ }
+ } else {
+ console.error(e)
+ socket.emit('myError', new UserException('An unexpected error occurred'))
+ }
+}
+
+module.exports = handleSocketError
diff --git a/server_modules/joinGame.js b/server_modules/joinGame.js
new file mode 100644
index 0000000..2bb07d3
--- /dev/null
+++ b/server_modules/joinGame.js
@@ -0,0 +1,82 @@
+'use strict'
+
+const crypto = require('crypto')
+const UserException = require('./UserException.js')
+const createGame = require('./createGame.js')
+const constants = require('../constants.js')
+const getGamesCollection = require('./db.js').getGamesCollection
+
+function randomBytesHexAsync (size) {
+ return new Promise((resolve, reject) => {
+ crypto.randomBytes(size, (err, buf) => {
+ if (err) {
+ reject(err)
+ } else {
+ resolve(buf.toString('hex'))
+ }
+ })
+ })
+}
+
+async function joinGame (db, name, gameCode) {
+ const gamesCollection = getGamesCollection()
+
+ // Validate name
+ if (name == null || name === '') {
+ throw new UserException('Must enter a name')
+ } else if (name.length > 20) {
+ throw new UserException('Max name length is 20 characters')
+ }
+
+ if (gameCode == null) {
+ // Create game if doesn't exist
+ gameCode = await createGame(db, gamesCollection)
+ } else {
+ // Validate gameCode
+ gameCode = +(gameCode.replace(' ', ''))
+ if (('' + gameCode).length > constants.GAME_CODE_LENGTH ||
+ !Number.isInteger(gameCode) || gameCode < 0) {
+ throw new UserException(
+ `Game code must be ${constants.GAME_CODE_LENGTH} digit number.`
+ )
+ }
+ }
+
+ const gameDb = db.db('game-' + gameCode)
+
+ const [gameExists, gameStatus, playerInGame, playerList] = await Promise.all([
+ gamesCollection.findOne({ code: gameCode }),
+ gameDb.collection('status').findOne({}),
+ gameDb.collection('players').findOne({ name: name }),
+ gameDb.collection('players').find({}).toArray()
+ ])
+ if (!gameExists) {
+ throw new UserException(`The game ${gameCode} does not exist.`)
+ } else if (gameStatus.playing !== false) {
+ throw new UserException('Cannot join game. It is currently in progress.')
+ } else if (playerInGame) {
+ throw new UserException(
+ 'Your chosen name is in use by another player. Please use another name.')
+ } else if (playerList.length >= 10) {
+ throw new UserException('There are already 10 players in this game')
+ }
+
+ const key = await randomBytesHexAsync(32)
+ const hash = crypto.createHash('sha256')
+ hash.update(key)
+ await gameDb.collection('players').insertOne({
+ name: name,
+ gameCode: gameCode,
+ hasConnected: false,
+ order: playerList.length,
+ hashedKey: hash.digest('hex')
+ })
+
+ return {
+ gameCode: gameCode,
+ name: name,
+ key: key
+ }
+}
+
+module.exports = joinGame
diff --git a/server_modules/periodicallyDeleteGames.js b/server_modules/periodicallyDeleteGames.js
new file mode 100644
index 0000000..d9b17a3
--- /dev/null
+++ b/server_modules/periodicallyDeleteGames.js
@@ -0,0 +1,49 @@
+'use strict'
+
+const constants = require('../constants.js')
+const getDb = require('./db.js').getDb
+const getGamesCollection = require('./db.js').getGamesCollection
+
+async function periodicallyDeleteGames (callback) {
+ const db = getDb()
+ const gamesCollection = getGamesCollection()
+
+ try {
+ const games = await gamesCollection.find({}).toArray()
+ const gameStatuses = await Promise.all(
+ Array.from(games, game => new Promise(async (resolve, reject) => {
+ try {
+ const statusCollection = (
+ await db.db('game-' + game.code).collection('status').findOne({})
+ )
+ resolve({
+ code: game.code,
+ status: statusCollection
+ })
+ } catch (e) {
+ reject(e)
+ }
+ }))
+ )
+ const dropCommands = []
+ const deletedGames = []
+ const currentDate = new Date()
+ gameStatuses.forEach(game => {
+ const shouldDie = (!game.status ||
+ currentDate - game.status.lastGameStart > constants.GAME_TTL)
+ if (shouldDie) {
+ deletedGames.push(game.code)
+ dropCommands.push(db.db('game-' + game.code).dropDatabase())
+ dropCommands.push(gamesCollection.deleteOne({ code: game.code }))
+ console.log('Deleted game ' + game.code)
+ }
+ })
+ await Promise.all(dropCommands)
+ callback(deletedGames)
+ } catch (e) {
+ console.error(e)
+ }
+ setTimeout(() => periodicallyDeleteGames(callback), constants.GAME_TTL)
+}
+
+module.exports = periodicallyDeleteGames
diff --git a/server_modules/removePlayer.js b/server_modules/removePlayer.js
new file mode 100644
index 0000000..a227a2a
--- /dev/null
+++ b/server_modules/removePlayer.js
@@ -0,0 +1,38 @@
+'use strict'
+
+const UserException = require('./UserException.js')
+const getGamesCollection = require('./db.js').getGamesCollection
+
+async function removePlayer (gameDb, playerToRemove) {
+ const gamesCollection = getGamesCollection()
+
+ const mongoCommands = await Promise.all([
+ gameDb.collection('status').findOne({}),
+ gameDb.collection('players').findOne({
+ name: playerToRemove.name
+ })
+ ])
+ const status = mongoCommands[0]
+ const playerToRemoveMongo = mongoCommands[1]
+ if (status.playing) {
+ throw new UserException('Cannot remove player while game in progress')
+ } else if (!playerToRemoveMongo) {
+ throw new UserException('The player you try to remove is not in game')
+ }
+ await gameDb.collection('players').deleteOne({ name: playerToRemove.name })
+ const players = await gameDb.collection('players').find({}).toArray()
+ if (players.length === 0) {
+ await Promise.all([
+ gameDb.dropDatabase(),
+ gamesCollection.deleteOne({
+ code: playerToRemove.gameCode
+ })
+ ])
+ }
+ return {
+ playerToRemove: playerToRemove,
+ socketClientId: playerToRemoveMongo.socketClientId
+ }
+}
+
+module.exports = removePlayer
diff --git a/server_modules/startNextMission.js b/server_modules/startNextMission.js
new file mode 100644
index 0000000..d19ef8c
--- /dev/null
+++ b/server_modules/startNextMission.js
@@ -0,0 +1,26 @@
+'use strict'
+
+async function startNextMission (gameDb, status, newScores) {
+ if (newScores.spies === 3) {
+ await gameDb.collection('status').updateOne({}, {
+ $set: { winner: 'spies' }
+ })
+ } else if (newScores.resistance === 3) {
+ await gameDb.collection('status').updateOne({}, {
+ $set: { winner: 'resistance' }
+ })
+ } else {
+ let { missionChooserIndex, numPlayers, missionNumber } = status
+ missionChooserIndex = (missionChooserIndex + 1) % numPlayers
+ const missionFailIndex = (missionChooserIndex + 2) % numPlayers
+ await gameDb.collection('status').updateOne({}, {
+ $set: {
+ missionChooserIndex: missionChooserIndex,
+ missionFailIndex: missionFailIndex,
+ missionNumber: missionNumber + 1
+ }
+ })
+ }
+}
+
+module.exports = startNextMission
diff --git a/server_modules/startRound.js b/server_modules/startRound.js
new file mode 100644
index 0000000..b5157d6
--- /dev/null
+++ b/server_modules/startRound.js
@@ -0,0 +1,71 @@
+'use strict'
+
+const UserException = require('./UserException.js')
+
+async function startRound (gameDb) {
+ const [gameStatus, playerList] = await Promise.all([
+ gameDb.collection('status').findOne({}),
+ gameDb.collection('players').find({}).toArray()
+ ])
+ if (gameStatus.playing) {
+ throw new UserException('Cannot start game. Game is in progress.')
+ }
+
+ const numPlayers = playerList.length
+ const missions = {
+ order: [],
+ includesStarRound: false // Star rounds always occur in mission no. 3.
+ }
+ switch (numPlayers) {
+ case 5:
+ missions.order = [2, 3, 2, 3, 3]
+ break
+ case 6:
+ missions.order = [2, 3, 4, 3, 4]
+ break
+ case 7:
+ missions.order = [2, 3, 3, 4, 4]
+ missions.includesStarRound = true
+ break
+ case 8:
+ case 9:
+ case 10:
+ missions.order = [3, 4, 4, 5, 5]
+ missions.includesStarRound = true
+ break
+ default:
+ throw new UserException('Cannot start game. There must by 5-10 players.')
+ }
+
+ const numSpies = Math.ceil(numPlayers / 3)
+ const playerNameList = playerList.map(player => player.name)
+ const teams = {
+ resistance: playerNameList,
+ spies: []
+ }
+ for (let i = 0; i < numSpies; i++) {
+ let randIndex = Math.floor(Math.random() * teams.resistance.length)
+ teams.spies.push(...teams.resistance.splice(randIndex, 1))
+ }
+ const missionChooserIndex = Math.floor(Math.random() * numPlayers)
+ const newStatus = {
+ playing: true,
+ lastGameStart: new Date(),
+ numPlayers: numPlayers,
+ numSpies: numSpies,
+ missionChooserIndex: missionChooserIndex,
+ missionFailIndex: (missionChooserIndex + 2) % numPlayers,
+ missionNumber: 0,
+ missions: missions,
+ scores: {
+ resistance: 0,
+ spies: 0
+ }
+ }
+ await Promise.all([
+ gameDb.collection('teams').insertOne(teams),
+ gameDb.collection('status').updateOne({}, { $set: newStatus })
+ ])
+}
+
+module.exports = startRound
diff --git a/server_modules/startVote.js b/server_modules/startVote.js
new file mode 100644
index 0000000..0b383a7
--- /dev/null
+++ b/server_modules/startVote.js
@@ -0,0 +1,31 @@
+'use strict'
+
+const UserException = require('./UserException.js')
+
+async function startVote (gameDb, vote, skipVotingCheck) {
+ const [status, numPlayers] = await Promise.all([
+ gameDb.collection('status').findOne({}),
+ gameDb.collection('players').countDocuments({})
+ ])
+ if (status.voting && skipVotingCheck !== true) {
+ throw new UserException('Voting is already in progress!')
+ }
+ if (vote.isProposal) {
+ vote.numVotesNeeded = numPlayers
+ } else {
+ vote.numVotesNeeded = vote.missionList.length
+ }
+ await Promise.all([
+ gameDb.collection('status').updateOne({}, {
+ $set: {
+ voting: {
+ ...vote,
+ voteId: Math.random().toString(16).substring(2)
+ }
+ }
+ }),
+ gameDb.collection('votes').deleteMany({})
+ ])
+}
+
+module.exports = startVote
diff --git a/server_modules/submitVote.js b/server_modules/submitVote.js
new file mode 100644
index 0000000..6b9d297
--- /dev/null
+++ b/server_modules/submitVote.js
@@ -0,0 +1,29 @@
+'use strict'
+
+const UserException = require('./UserException.js')
+const endVote = require('./endVote.js')
+
+async function submitVote (gameDb, vote, player) {
+ const [ status, votes ] = await Promise.all([
+ gameDb.collection('status').findOne({}),
+ gameDb.collection('votes').find({}).toArray()
+ ])
+ if (!status.voting) {
+ throw new UserException('Voting is currently not in progress!')
+ } else if (votes.some(vote => vote.name === player.name)) {
+ throw new UserException('You have already voted!')
+ } else if (!status.voting.isProposal &&
+ !status.voting.missionList.includes(player.name)) {
+ throw new UserException('You are not authorized to vote.')
+ }
+ await gameDb.collection('votes').insertOne({
+ vote: vote,
+ name: player.name
+ })
+ const numVotes = await gameDb.collection('votes').countDocuments({})
+ if (numVotes === status.voting.numVotesNeeded) {
+ await endVote(gameDb)
+ }
+}
+
+module.exports = submitVote