示例#1
0
class Hangman:

	'''
	This class provides the context for the
	graphics and logic modules, as well as
	handling input, menus, events and
	resources.

	The original intent was to let it serve
	as a model-view controller, where Logic
	represented the model and Graphics the
	main view.

	'''

	def __init__(self):

		'''
		Initializes window, canvas, gameplay options and menus,
		loads resources (settings, images, dictionaries)
		and sets up debugging.

		'''

		# Window
		self.size = Size(650, 650)
		self.root = self.createWindow(self.size)
		self.icon = self.loadIcon('icon.png')

		# Internal settings
		self.validState = False 						# Not ready to accept guesses
		self.DEBUG 		= tk.BooleanVar(value=False)	# Print debug messages
		self.VERBOSE 	= tk.BooleanVar(value=True)		# Print verbose debug messages

		# Logging
		self.messages 	= []
		self.logger = Logger('Hangman')

		# Resources
		self.dictData 	= self.loadDictionaries('data/dicts/dictionaries.json')
		self.dictNames 	= [name for name in self.dictData.keys()]
		self.flags 		= self.loadFlags()

		# Gameplay settings
		self.restartDelay   = 1500 	# Delay before new round begins (ms)
		self.revealWhenLost = False	# Reveal the word when the game is lost
		
		# TODO: Save reference to current dict (?)
		self.DICT 			= tk.StringVar(value=choice(self.dictNames)) 	# Select random dictionary
		self.characterSet 	= self.dictData[self.DICT.get()]['characters'] 	# TODO: Make this dictionary-dependent

		# Menus
		self.menubar = self.createMenus()

		# Events
		self.bindEvents()

		# Game play
		self.graphics = Graphics(self.root, *self.size, characterSet=self.characterSet)	# Renderer
		self.logic 	  = Logic(self.graphics.chances)									# Logic
		self.wordFeed = self.createWordFeed(self.DICT.get()) 							# Provides a stream of words and hints
		self.chances  = self.graphics.chances 											# Initial number of chances for each round

		self.word = None # Initialized later on
		self.hint = None # Initialized later on

		# Audio
		self.effects = self.loadAudio()


	def play(self):

		''' Starts the game '''

		self.restart()
		self.root.mainloop()


	def createWindow(self, size):

		''' As per the title '''

		root = tk.Tk()
		root.resizable(width=False, height=False)
		root.title('Hangman')

		return root


	def createMenus(self):

		''' As per the title '''

		# TODO: Nested dict or JSON menu definition (?)
		# TODO: Desperately needs a clean-up (...)

		menubar = tk.Menu(self.root)

		# New game
		menubar.add_command(label='New', command=self.restart)

		# Settings
		settings = tk.Menu(menubar, tearoff=0)
		settings.add_command(label='Difficulty', command=lambda: print('Moderate'))

		# Languages
		languages = tk.Menu(settings, tearoff=0)

		self.DICT.trace('w', lambda *args, var=self.DICT: self.setDictionary(var.get())) # TODO: Extract traces

		# TODO: Use appropriate flag
		for N, name in enumerate(self.dictData.keys()):
			code = self.dictData[name]['iso'] # Language code
			languages.add_radiobutton(label=name, image=self.flags[code], compound='left', var=self.DICT, value=name)
		else:
			self.logger.log('Found %d dictionaries.' % (N+1), kind='log')

		settings.add_cascade(label='Language', menu=languages)
		menubar.add_cascade(label='Settings', menu=settings)

		# About box
		menubar.add_command(label='About', command=self.about)
	
		# Dev menu
		debug = tk.Menu(menubar, tearoff=0)
		debug.add_checkbutton(label='Debug', onvalue=True, offvalue=False, variable=self.DEBUG)
		debug.add_checkbutton(label='Verbose', onvalue=True, offvalue=False, variable=self.VERBOSE)
		menubar.add_cascade(label='Dev', menu=debug)

		# Quit
		menubar.add_command(label='Quit', command=self.quit)

		# Attach to window
		self.root.config(menu=menubar)
		
		return menubar


	def bindEvents(self):
		''' Binds callbacks to events '''
		self.root.bind('<Escape>', lambda e: self.quit())
		self.root.bind('<Key>', lambda e: self.onKeyDown(e))


	def onKeyDown(self, event):

		''' Responds to key presses '''
		
		# TODO: Make sure guesses can't be made in a transitory state (✓)
		# TODO: Tidy up
		# TODO: Shortcuts, key bindings with JSON (?)
		# Validate the guess

		# Make sure the game is in a valid state (eg. not between to rounds)
		if not self.validState:
			self.logger.log('Cannot accept guesses right now', kind='log')
			return
		elif not self.validGuess(event.char):
			return
		else:
			self.guess(event.char)


	def about(self):
		''' Shows an about box '''
		messagebox.askokcancel('About', 'Hangman\nJonatan H Sundqvist\nJuly 2014')


	def loadAudio(self):
		''' Initializes mixer and loads sound effects '''
		mixer.init()
		files = ['strangled.wav', 'ding.wav']
		return namedtuple('Effects', ['lose', 'win'])(*map(lambda fn: mixer.Sound('data/audio/%s' % fn), files))


	def loadFlags(self):
		''' Loads all flag files and creates a map between those and their respective ISO language codes '''
		codes = [('en-uk', 'UK.png'), ('es-es', 'Spain.png'), ('in', 'India.png'), ('sv-sv', 'sv.png'), ('en-us', 'USA.png')] # Maps language codes to flags
		flags = {}
		for iso, fn in codes:
			image = Image.open('data/flags/%s' % fn)
			image.thumbnail((16,16), Image.ANTIALIAS)
			
			flags[iso] = ImageTk.PhotoImage(image)
		return flags


	def loadIcon(self, fn):
		''' Loads and sets the title bar icon '''
		icon = ImageTk.PhotoImage(Image.open(fn))
		self.root.call('wm', 'iconphoto', self.root._w, icon)
		return icon


	def loadDictionaries(self, fn):
		''' Loads JSON dictionary meta data '''
		# TODO: Dot notation
		# TODO: Load associated resources for convenience (?)
		with open(fn, 'r', encoding='utf-8') as dicts:
			return json.load(dicts)


	def setDictionary(self, name):
		''' Sets the dictionary specified by the name and restarts '''
		self.logger.log('Changing dictionary to %s' % name, kind='log')
		self.wordFeed = self.createWordFeed(name)
		self.characterSet = self.dictData[name]['characters']
		self.graphics.changeCharacterSet(self.characterSet)
		self.restart()


	# TODO: Research Python annotation syntax
	# TOOD: Check if ST3 has support for the same
	#def guess(self : str, letter : str) -> None:
	def guess(self, letter):
		
		''' Guesses one letter '''

		# TODO: Write a slightly more helpful docstring
		# TODO: Clean this up

		result = self.logic.guess(letter)
		
		self.logger.log('\'%s\' is a %s!' % (letter.upper(), result), kind='log')

		self.graphics.guess(letter, result in ('MATCH', 'WIN'), str(self.logic)), # TODO: Let Graphics take care of the representation for us (?)
		
		# TODO: Clean up the 'switch' logic
		#{'WIN': self.win, 'LOSE': self.lose}.get(result, lambda: None)()
		# return { ('MATCH', 'WIN'):  }
		
		if result == 'WIN':
			self.win()
		elif result == 'LOSE':
			self.lose()


	def validGuess(self, letter):
		''' Determines if a letter is a valid guess '''

		# TODO: Make this configurable (list of requirements?)

		# Normalize input
		letter = letter.upper()

		# Check all requirements
		if letter not in self.characterSet:
			# Make sure the character is a guessable letter
			self.logger.log('\'%s\' is not in the character set!' % letter, kind='log')
			return False
		elif len(letter) != 1:
			# Make sure the guess is only one letter
			self.logger.log('\'%s\' does not have exactly one letter!' % letter, kind='log')
			return False
		elif self.logic.hasGuessed(letter):
			# Make sure it's not a repeat guess
			self.logger.log('\'%s\' has already been guessed!' % letter, kind='log')
			return False
		else:
			return True


	def win(self):
		''' Victorious feedback, schedules the next round '''
		self.logger.log('Phew. You figured it out!', kind='log')
		self.effects.win.play()
		self.scheduleRestart()
	
	
	def lose(self):
		''' Failure feedback, schedules the next round '''
		# TODO: Show correct word before restarting (?)
		self.logger.log('You\'ve been hanged. Requiescat in pace!', kind='log')
		self.effects.lose.play()
		if self.revealWhenLost:
			self.graphics.setWord(self.word) # Reveal answer
		self.scheduleRestart()


	def scheduleRestart(self):
		''' Schedules a new round and disables guessing in the interim '''
		self.validState = False # Disable guessing between rounds
		self.root.after(self.restartDelay, self.restart)
		

	def restart(self):
		''' Starts a new game '''
		self.logger.log('\n{0}\n{1:^40}\n{0}\n'.format('-'*40, 'NEW GAME'), kind='log', identify=False) # TODO: Enable identify options in Logger.log

		self.word, self.hint = next(self.wordFeed)
		self.graphics.showHint(self.hint)

		self.logic.new(self.word)
		self.graphics.play(str(self.logic))

		self.validState = True # Ready to accept guesses again


	def quit(self, message=None, prompt=False):
		''' Exits the application '''
		# TODO: Find a way to close Python
		#print('\n'.join(self.messages))
		self.root.quit()


	def createWordFeed(self, name):
		''' Creates a word feed from the dictionary specified by the name '''
		# TODO: Give class a reference to words (?)
		# TODO: Wise to hard-code path (?)
		# TODO: Handle incorrectly structured dictionaries
		self.logger.log('Creating word feed from \'{name}\'.'.format(name=name), kind='log')
		fn = self.dictData[name]['file']
		with open('data/dicts/%s' %  fn, 'r', encoding='utf-8') as wordFile:
			words = wordFile.read().split('\n')
		while True:
			try:
				line = choice(words)
				word, hint = line.split('|') # Word|Hint
				yield word, hint
			except ValueError as e:
				words.remove(line) # Remove the culprit from the word feed
				self.logger.log('Removing invalid definition ({0}).'.format(line), kind='error')