seopardy/gamestate.py

from __future__ import print_function

import datetime
import os
import yaml
from collections import defaultdict

class GameState(object):
	""" Represent current gamestate.

	players: list of player names + current points
	savedir: dir to save gamestate into, should be overwritable
	board: dict of section with list of questions
	"""
	GAMESTATE = ["start", "playing", "end"]

	def __init__(self, savedir):
		self.savedir = savedir

		#self._board = defaultdict(lambda: [None]*5)
		self._board = defaultdict(_mk_empty_board_column)
		self._players = []
		self._state = self.GAMESTATE[0]

		if not os.path.exists(self.savedir):
			os.mkdir(self.savedir)
		elif not os.path.isdir(self.savedir):
			raise ValueError("'%s' is not a directory but something else!" % self.savedir)


	def set_state(self, state):
		if state not in self.GAMESTATE:
			raise ValueError("'%s' is not a valid gamestate, valid choices are %s" % (state, self.GAMESTATE))
		self._state = state

	def get_state(self):
		return self._state

	def set_answers(self, section, qnumber, answers):
		self._board[section][qnumber-1] = answers

	def get_answers(self, section, qnumber):
		return self._board[section][qnumber-1]

	def set_players(self, players):
		self._players = players

	def get_players(self):
		return self._players

	def _make_structure(self):
		return {
			"state": self._state,
			"players": self._players,
			"board": self._board
		}

	def save(self):
		fname = datetime.datetime.now().strftime("seopardy.%Y-%m-%d-_%H:%M:%S.save")
		fstream = open("%s/%s" % (self.savedir, fname), "w")
		yaml.dump(self._make_structure(), fstream)
		fstream.close()

	@classmethod
	def load(clazz, sstream, savedir):
		gs = clazz(savedir)
		data = yaml.load(sstream)
		gs._state = data["state"]
		gs._players = data["players"]
		gs._board = data["board"]

		return gs

def _mk_empty_board_column():
	""" We can't use a lambda here, as we want the default dict to be
		easily serializeable by yaml. """
	return [None]*5

class QuestionAnswers(object):
	def __init__(self, section, qnumber, dj_points=None):
		self.section = section
		self.qnumber = qnumber
		self.nobody_answered = False
		self.dj_points = dj_points

		self.tries = []

	def set_dj_points(self, points):
		self.dj_points = points

	def add_try(self, player, correct):
		self.tries.append((player, correct))

	def get_winner(self):
		for player, correct in self.tries:
			if correct:
				return player
		return None

	def points(self):
		return self.qnumber*100

	def get_dj_points(self):
		return self.dj_points

	def nobody_knew(self):
		self.nobody_answered = True

	def got_answered(self):
		return not self.nobody_answered

	def get_tries(self):
		return self.tries

	def is_answered(self):
		return self.nobody_answered or any([c for (u, c) in self.tries])