예제 #1
0
	def __init__(self):
		self._master = Tk()
	
		# frame
		frame = Frame(self._master)
		#frame.bind("<Key>", self.key_pressed)
		# keys to end game
		frame.bind("<Escape>", self.end)
		frame.bind("<Return>", self.end)
		frame.bind("<space>", self.end)
		frame.focus_set() # this is very important
		frame.grid()
		frame.master.title("Settlers of Catan: W****s and Wenches (custom expansion)")
		frame.pack()
		
		# keeps index of turn
		self._turn = 0
		
		# now to get a grid
		for i in range(6):
			frame.master.columnconfigure(i, weight=1)
		frame.master.rowconfigure(0, weight=1)

		frame1 = frame
		self._frame = frame

		# canvas
		w = Canvas(frame1, width=CatanApp.width, height=CatanApp.height)
		w.pack()
		
		# create the board
		self._map = MapGen()
		self._map.create_players(self.players)
		self._map.gen()
		self.set_vertices(self._map.get_map())
		self._map.prepare()
		
		self.draw_board(w)
		
		#self.play_game()
		self.draw_status_area()
		self._roll_var = StringVar()
		
		self._roll_button = Button(
			frame1, 
			text="End turn", 
			command=self.roll,
			state=DISABLED # initially hide it
		)
		#self._roll_button.place(x=600, y=20)
		#self._roll_button.pack()
		
		self._canvas.create_window(60, self.height + 10, window=self._roll_button, anchor=S)
		
		l = Label(frame1, textvar=self._roll_var)
		l.place(x=600, y=120)
		l.pack()
		
		self.create_build_buttons()
		
		self._canvas.create_window(170, self.height + 10, window=self._build_buttons["settlement"], anchor=S)
		
		self.draw_robber()
		# bind events to the robber
		self._canvas.tag_bind("robber", "<ButtonPress-1>", self.grab_robber)
		self._canvas.tag_bind("robber", "<B1-Motion>", self.move_robber)
		self._canvas.tag_bind("robber", "<ButtonRelease-1>", self.release_robber)
		
		
		self.automate_setup()
예제 #2
0
class CatanApp():
	'''The Catan App (for now).
	For now side distances are determined statically. Can dynamically allocate them at a later point.'''
	
	height = 550
	width = 900
	minor_horiz_dist = 30
	major_horiz_dist = 60
	minor_vert_dist = 50
	render_start = (200, minor_vert_dist + 20)
	
	settlement_radius = 20
	city_radius = 22
	
	robber_height = 40
	robber_width = 40
	
	players = ["red", "gold2", "blue", "green"]
	
	def draw_robber(self):
		# the robber has an associated hex
		center = self._map.get_robber_hex().get_center()
		self._robber_sprite = self._canvas.create_oval(
			center[0] - self.robber_width / 2,
			center[1] - self.robber_height / 2,
			center[0] + self.robber_width / 2,
			center[1] + self.robber_height / 2,
			tag="robber",
			fill="black",
			activefill="yellow",
			state=DISABLED
		)
		
	def grab_robber(self, event):
		self._grab_item = {
			"x" : event.x,
			"y" : event.y,
			"item" : self._canvas.find_withtag("robber")
		}
		
	def move_robber(self, event):
		self._canvas.move(
			self._grab_item["item"],
			event.x - self._grab_item["x"], 
			event.y - self._grab_item["y"]
		)
		self._grab_item["x"] = event.x
		self._grab_item["y"] = event.y
		
	def release_robber(self, event):
		# get the closest hex...
		items = self._canvas.find_overlapping(event.x - 15, event.y - 15, event.x + 15, event.y + 15)
		
		for item in items:
			tags = self._canvas.gettags(item)
			if "hex" in tags:
				coord = tuple([int(i) for i in tags[1].replace("hex_", "").split("_")])
				
				if self._map.set_robber_hex(coord[0], coord[1]):
					center = self._map.get_robber_hex().get_center()
					self._canvas.move(
						self._robber_sprite,
						center[0] - self._grab_item["x"],
						center[1] - self._grab_item["y"]
					)
					
					# TODO - allow me to re-pickup the robber and move it again
					self.enable_stealing()
				else:
					print "ROBBER FAIL"
					self.move_robber_to_hex(self._map.get_robber_hex())
					return
			
	def enable_stealing(self):
		'''Enable stealing by the current player from all players adjoining the robber hex.'''
		
		# only allow stealing from players who are adjacent to that hex
		player_list = self._map.get_players_on_robber_hex()
		
		if len(player_list) == 0:
			# don't steal from anybody
			self.change_to_state("gameplay")
		elif len(player_list) == 1:
			# don't go through trouble of selection here, since there is only 1 choice
			self.steal_from_player(player_list[0])
			self.change_to_state("gameplay")
		else:
			for c in player_list:
				t = "player_hand_rect_%s" % c
				self._canvas.itemconfigure(self._canvas.find_withtag(t)[0], state=NORMAL)
			
	
	def _next_turn(self, decr=False):
		i=-1 if decr else 1
		self._turn = (self._turn + i) % 4
		
	def _get_turn(self):
		return self._turn
	
	def move_robber_to_hex(self, destination_hex):
		'''Move robber to the given hex. Here, hex is the Hex object.'''
		
		new_pos = destination_hex.get_center()
		old_pos = self._canvas.coords(self._robber_sprite)
		old_pos_c = ((old_pos[0] + old_pos[2]) / 2, (old_pos[1] + old_pos[3]) / 2)
		self._canvas.move(self._robber_sprite, new_pos[0] - old_pos_c[0], new_pos[1] - old_pos_c[1])
	
	def automate_robber(self):
		'''Automate the robber completely.'''
		
		self.automate_robber_movement()
		self.automate_robber_steal_picking()
		#self.change_to_state("gameplay")
	
	def automate_robber_steal_picking(self):
		'''Automate the process of picking a person to steal from, once robber has been placed.'''
		
		self.steal_from_player(self._map.ai.get_random_robber_pick())
	
	def automate_robber_movement(self):
		'''Choose a place to put the robber.'''
		
		good_placement = False
		
		color = self.players[self._turn]
		row, col = self._map.ai.get_smart_robber_placement(color)
		#destination_hex_sprite = self._canvas.find_withtag("hex_{}_{}".format(row, col))
		model_hex = self._map._board[row][col]
		
		if self._map.set_robber_hex(row, col):
			self.move_robber_to_hex(model_hex)
		else:
			print "AI picked same hex to put robber, skipping stealing..."
			#self.move_robber_to_hex(self._map.get_robber_hex())
	
	def automate_setup(self):
		'''Create a random setup of the first two roads and settlements.'''
		
		# do all 8
		for i in range(8):
			c = self.players[self._turn]
			v = self._map.ai.get_best_settlement()
			self.add_settlement(None, v)
			road = self._map.ai.get_random_road_from_settlement(v)
			
			if not road:
				print "ERROR! Could not find a place to put a road"
			else:
				v1, v2 = road
			
			if v1[0] > v2[0]:
				v1, v2 = v2, v1 # switch places to correspond with the way roads are indexed
			
#			if (v1, v2) not in self._roads:
#				print "Tried to build road from {} to {}".format(v1, v2)
#				for k in self._roads.keys():
#					if k[0] == v1 or k[1] == v1:
#						print k
			
			self.add_road(None, v1, v2)
	
	def __init__(self):
		self._master = Tk()
	
		# frame
		frame = Frame(self._master)
		#frame.bind("<Key>", self.key_pressed)
		# keys to end game
		frame.bind("<Escape>", self.end)
		frame.bind("<Return>", self.end)
		frame.bind("<space>", self.end)
		frame.focus_set() # this is very important
		frame.grid()
		frame.master.title("Settlers of Catan: W****s and Wenches (custom expansion)")
		frame.pack()
		
		# keeps index of turn
		self._turn = 0
		
		# now to get a grid
		for i in range(6):
			frame.master.columnconfigure(i, weight=1)
		frame.master.rowconfigure(0, weight=1)

		frame1 = frame
		self._frame = frame

		# canvas
		w = Canvas(frame1, width=CatanApp.width, height=CatanApp.height)
		w.pack()
		
		# create the board
		self._map = MapGen()
		self._map.create_players(self.players)
		self._map.gen()
		self.set_vertices(self._map.get_map())
		self._map.prepare()
		
		self.draw_board(w)
		
		#self.play_game()
		self.draw_status_area()
		self._roll_var = StringVar()
		
		self._roll_button = Button(
			frame1, 
			text="End turn", 
			command=self.roll,
			state=DISABLED # initially hide it
		)
		#self._roll_button.place(x=600, y=20)
		#self._roll_button.pack()
		
		self._canvas.create_window(60, self.height + 10, window=self._roll_button, anchor=S)
		
		l = Label(frame1, textvar=self._roll_var)
		l.place(x=600, y=120)
		l.pack()
		
		self.create_build_buttons()
		
		self._canvas.create_window(170, self.height + 10, window=self._build_buttons["settlement"], anchor=S)
		
		self.draw_robber()
		# bind events to the robber
		self._canvas.tag_bind("robber", "<ButtonPress-1>", self.grab_robber)
		self._canvas.tag_bind("robber", "<B1-Motion>", self.move_robber)
		self._canvas.tag_bind("robber", "<ButtonRelease-1>", self.release_robber)
		
		
		self.automate_setup()
	
	def play_dev_card(self):
		print "Playing dev card..."
		
	def buy_dev_card(self):
		'''User-triggered action to buy a development card.'''
		
		color = self.players[self._turn]
		card = self._map.get_development_card(color)
		
		if card is None:
			self.post_status_note("You cannot afford to buy a development card", True)
		else:
			self.post_status_note("Successfully bought development card")
			self.update_hand(color)
			print "{} bought development card '{}'".format(color, card)
			self.update_dev_cards(color)
		
	def create_build_buttons(self):
		'''Create buttons to build various structures.'''
		
		self._build_buttons = {}
		
		for type in ["road", "settlement", "city"]:
			self.create_build_button(type)
			
		self._build_buttons["dev_card"] = Button(
			self._frame, 
			text="Buy development card", 
			state=DISABLED, 
			command=self.buy_dev_card
		)
		
		self._build_buttons["dev_card"].pack()
			
		f = lambda: self.change_to_state("gameplay")
			
		self._cancel_building_button = Button(
			self._frame,
			text="Cancel building",
			state=DISABLED,
			command=f
		)
		self._cancel_building_button.pack()
		
	def enable_building(self, type):
		'''Enable building of buildings of certain type.
		NOTE: player has not been charged by this point.'''
		
		color = self.players[self._turn]
		p = self._map.get_player(color)
		if p.can_deduct_resources(CatanConstants.building_costs[type]):
			if type == "city":
				for item in self._canvas.find_withtag("settlement"):
					self._canvas.itemconfigure(item, state=NORMAL)
				for item in self._canvas.find_withtag("settlement_placeholder"):
					self._canvas.itemconfigure(item, state=DISABLED)
			else:
				for item in self._canvas.find_withtag(type + "_placeholder"):
					self._canvas.itemconfigure(item, state=NORMAL)
			
			self.change_to_state("place additional building")
		else:
			self.post_status_note("{} does not have enough resources to build a {}".format(color, type), True)
		
	def create_build_button(self, type):
		'''Create button to build given structure.'''
		
		f = lambda: self.enable_building(type)
		
		self._build_buttons[type] = Button(
			self._frame, 
			text="Build {}".format(type), 
			command=f,
			state=DISABLED
		)
		
		self._build_buttons[type].pack()
		
	def roll(self, change_turn=True):
		'''End the previous turn, then roll the dice.'''
		
		if change_turn:
			self.change_status_turn()
		
		# roll the dice
		r1 = random.randint(1, 6)
		r2 = random.randint(1, 6)
		n = r1 + r2
		
		# display dice roll
		self._roll_var.set("Last roll: {}".format(n))
		self.post_status_note("Rolled %d" % n)
		
		if n == 7:
			# TODO discard cards first
			
			# 
			self.change_to_state("move robber")
			# starting from this player, each player must discard half their hand
			#discard_map = self._map.robber_discard()
			
			#for i in range(4):
			#	c = self.players[self._turn]
			#	# this player must discard <x> cards
			#	if c in discard_map:
			#		self.post_status_note("{} must discard {} cards".format(c.title(), discard_map[c]), True)
		else:
			# compute produced resources
			d = self._map.get_resources_produced(n)
		
			# update player hands on screen
			for c in self.players:
				self.update_hand(c)
			
	def update_hand(self, color):
		'''Update the hand displayed for player of the given color.'''
		
		self._canvas.itemconfigure(
			self._hands[color], 
			text=self._map.get_player(color).get_printable_hand().replace(",", "\n")
		)
		
	def update_dev_cards(self, color):
		'''Update development card display in GUI for player of given color.'''
		
		item = self._canvas.find_withtag("dev_area_section_%s" % color)
		self._canvas.itemconfigure(
			item, 
			text=self._map.get_player(color).get_printable_dev_cards().replace(",", "\n")
		)
		
	def act_on_start_state(self):
		'''Set the state notification to the correct value.'''
		
		# set the note
		self.post_status_note()
		
		if self._state in ["first settlement placement", "second settlement placement"]:
			# disable roads
			for road in self._canvas.find_withtag("road"):
				self._canvas.itemconfigure(road, state=DISABLED)
			# disable city upgrades
			for s in self._canvas.find_withtag("settlement"):
				self._canvas.itemconfigure(s, state=DISABLED)
			for s in self._canvas.find_withtag("settlement_placeholder"):
				self._canvas.itemconfigure(s, state=NORMAL)
		elif self._state in ["first road placement", "second road placement"]:
			for s in self._canvas.find_withtag("settlement"):
				self._canvas.itemconfigure(s, state=DISABLED)
			for city in self._canvas.find_withtag("city"):
				self._canvas.itemconfigure(city, state=DISABLED)
		elif self._state == "gameplay":
			# disable all buildings
			for b in self._canvas.find_withtag("building"):
				self._canvas.itemconfigure(b, state=DISABLED)
			# re-enable the roll button
			self._roll_button.config(state=NORMAL)
			for button in self._build_buttons.itervalues():
				button.config(state=NORMAL)
		elif self._state == "choose building":
			# hide the hand while building
			for item in self._canvas.find_withtag("hand_area_section"):
				self._canvas.itemconfigure(item, state=HIDDEN)
				
			for item in self._canvas.find_withtag("building_selection"):
				self._canvas.itemconfigure(item, state=NORMAL)
			
		elif self._state == "place additional building":
			# disable the buttons
			self._roll_button.config(state=DISABLED)
			for b in self._build_buttons.itervalues():
				b.config(state=DISABLED)
			self._cancel_building_button.config(state=NORMAL)
			
		elif self._state == "move robber":
			self._roll_button.config(state=DISABLED)
			self._build_buttons["settlement"].config(state=DISABLED)
			for s in self._canvas.find_withtag("building"):
				self._canvas.itemconfigure(s, state=DISABLED)
			self._canvas.itemconfigure(self._robber_sprite, state=NORMAL)
			
			# TODO for now
			self.automate_robber()
			#self.change_to_state("gameplay")
			
		elif self._state == "choose player":
			# enable the hand rectangles
			#for rect in self._canvas.find_withtag("player_hand_rect"):
			#	self._canvas.itemconfigure(rect, state=NORMAL)
			self.enable_stealing()
				
			# disable basically everything else
			for s in self._canvas.find_withtag("building"):
				self._canvas.itemconfigure(s, state=DISABLED)
			self._roll_button.config(state=DISABLED)
			self._build_buttons["settlement"].config(state=DISABLED)
				
	def post_status_note(self, msg=None, error=False):
		c = "red" if error else "black" 
		
		if msg:
			t = msg
		else:
			if "settlement placement" in self._state:
				t = "Place a settlement"
			elif "road placement" in self._state:
				t = "Place a road"
			elif self._state == "gameplay":
			#	t = "Done with initial placements!"
				t = None
			elif self._state == "move robber":
				t = "Move the robber"
			elif self._state == "choose player":
				t = "Choose a player to steal from"	
			elif self._state == "choose building":
				t = "Choose a building to build"
			elif self._state == "place additional building":
				t = "Place the building you just bought"
			
		if t is not None:
			self._canvas.itemconfigure(self._note, text=t, fill=c)
				
	def act_on_end_state(self):
		'''Perform state exit actions.'''
		
		if self._state in ["first settlement placement", "second settlement placement"]:
			for road in self._canvas.find_withtag("road"):
				self._canvas.itemconfigure(road, state=NORMAL)
			for city in self._canvas.find_withtag("city"):
				self._canvas.itemconfigure(city, state=NORMAL)
				
			if "second" in self._state:
				# note the turn hasn't changed
				c = self.players[self._turn]
				second_settlement =  self._map.get_player(c).get_settlement(1)
				self._map.produce(second_settlement)
				self.update_hand(c)
		elif self._state in ["first road placement", "second road placement"]:
			for s in self._canvas.find_withtag("settlement"):
				self._canvas.itemconfigure(s, state=NORMAL)
			for city in self._canvas.find_withtag("city"):
				self._canvas.itemconfigure(city, state=NORMAL)
				
			if "second" in self._state and self._turn == 0:
				self.roll(False)
		elif self._state == "gameplay":
			# re-enable all buildings
			for b in self._canvas.find_withtag("building"):
				self._canvas.itemconfigure(b, state=NORMAL)
			self._roll_button.config(state=DISABLED)
		elif self._state == "move robber":
			self._roll_button.config(state=NORMAL)
			self._build_buttons["settlement"].config(state=NORMAL)
			for s in self._canvas.find_withtag("building"):
				self._canvas.itemconfigure(s, state=DISABLED)
			# this is the main part
			self._canvas.itemconfigure(self._robber_sprite, state=DISABLED)
		elif self._state == "choose player":
			for rect in self._canvas.find_withtag("player_hand_rect"):
				self._canvas.itemconfigure(rect, state=DISABLED)
			# the usual stuff will be enabled when gameplay is resumed
		elif self._state == "choose building":
			# hide the hand while building
			for item in self._canvas.find_withtag("hand_area_section"):
				self._canvas.itemconfigure(item, state=NORMAL)
				
			for item in self._canvas.find_withtag("building_selection"):
				self._canvas.itemconfigure(item, state=HIDDEN)
		elif self._state == "place additional building":
			# re-enable the buttons
			self._roll_button.config(state=NORMAL)
			for b in self._build_buttons.itervalues():
				b.config(state=NORMAL)
				
			# disable the buildings
			for s in self._canvas.find_withtag("building"):
				self._canvas.itemconfigure(s, state=DISABLED)
			self._cancel_building_button.config(state=DISABLED)
			
			# update hand
			self.update_hand(self.players[self._turn])
			
			# post that the building is good
			self.post_status_note("Successfully built the building!", False)
		
	def draw_build_menu(self):
		'''Draw the build menu.'''
		
		x = 550
		y_start = 100
		y_incr = 70
		build_list = ["settlement", "city", "road"]
		
		for i in range(len(build_list)):
			l = Label(self._canvas, text=build_list[i], anchor=W, font=("Helvetica", 16))
			
			w = self._canvas.create_window(
				x, 
				y_start + i * y_incr, 
				window=l, 
				state=HIDDEN, 
				tag="building_selection",
				anchor=W
			)
			
			# TODO - create sprite for it
			
			#b = self._canvas.bbox(w)
			#self._canvas.itemconfigure(b, outline="black")
		
	def draw_status_area(self):
		'''Draw whose turn it is in top-left corner.'''
		
		self.draw_build_menu()
		
		# this is where the turn is
		self._canvas.create_text(50, 30, text="Current turn:")
		self._status_rect = self._canvas.create_rectangle(
			50, 40, 80, 70, 
			fill=self.players[self._turn], 
			tag="status_rect"
		)
		
		# this is the notifications area
		self._note = self._canvas.create_text(580, 30, width=180)
		self._state = "first settlement placement"
		self.act_on_start_state()
		
		self.draw_hand_area()
		
	def update_vp(self, color):
		'''Update the victory points for a player of the given color.'''
		
		item = self._canvas.find_withtag("player_hand_rect_%s_text" % color)
		self._canvas.itemconfigure(item, text=str(self._map.get_player_vp(color)))
		
	def draw_hand_area_section(self, c, i):
		f = lambda event : self.steal_from_player(c)
		t = "player_hand_rect_%s" % c
		
		self._canvas.create_rectangle(
			550, 
			120 * (i + 1) - 20, 
			580, 
			120 * (i + 1) + 10, 
			fill=c,
			outline="black",
			tag=("player_hand_rect", t, "hand_area_section"),
			state=DISABLED,
			activeoutline="gold4",
		)
		
		self._canvas.create_text(
			565,
			120 * (i + 1) - 5,
			text="0",
			tag=t + "_text",
			font=("Helvetica", 14),
			fill="white"
		)
		
		self._hands[c] = self._canvas.create_text(
			670, 
			120 * (i + 1), 
			text="", 
			width=150, 
			justify=RIGHT,
			tag="hand_area_section"
		)
		self._canvas.tag_bind(t, "<Button>", f)
		
		self._canvas.create_text(
			770,
			120 * (i + 1),
			text="NO  DEV CARDS",
			width = 150,
			justify=RIGHT,
			tag="dev_area_section_%s" % c
		)
		
		# create a box around the whole thing
		self._canvas.create_rectangle(
			530,
			120 * (i + 1) - 50,
			850,
			120 * (i + 1) + 50,
			fill="",
			outline=c,
			tag="hand_area_section",
			width=1.5
		)
			
	def draw_hand_area(self):
		'''Draw the area where the hands for the players are displayed.'''
		
		self._hands = {}
		
		# this is where the cards are
		for i, c in enumerate(self.players):
			self.draw_hand_area_section(c, i)
			
		# and a box around everything
		self._canvas.create_rectangle(
			525,
			65,
			855,
			535,
			fill="",
			outline="black",
			width=1.5,
			dash=(2, 4)
		)
		
	def steal_from_player(self, from_player):
		'''Steal from player of given player color.
		Called by selecting player color in robber motion.'''
		
		to_player = self.players[self._turn]
		r = self._map.robber_steal(from_player, to_player)
		self.update_hand(from_player)
		self.update_hand(to_player)
		print "Stole {} from {} and gave to {}".format(r, from_player, to_player)
		self.post_status_note("Stole from {}".format(from_player))
		self.change_to_state("gameplay")
		
	def change_status_turn(self, decr=False):
		self._next_turn(decr)
		self._canvas.itemconfigure(self._status_rect, fill=self.players[self._turn])
		
	def draw_board(self, canvas):
		'''Now we draw the board...'''
		
		for row_i, row in enumerate(self._map.get_map()):
			for col, hex in enumerate(row):
				draw_hex(canvas, hex, row_i, col)
				
		self._settlements = {}
		self._roads = {}
		self._canvas = canvas
		for r in self._map.get_roads():
			self.draw_road_placeholder(canvas, r[0], r[1])
			
		for v in self._map.get_nodes():
			self.draw_settlement_node(canvas, v)
		
	def get_roads(self):
		return self._road_set
	
	def _get_road_slope(self, v1, v2):
		'''Return float.'''
		
		return (v2[1] - v1[1]) * 1.0 / (v2[0] - v2[1])
	
	def _get_y_offset(self, v1, v2, x_offset):
		return self._get_road_slope(v1, v2) * x_offset
			
	def draw_road_placeholder(self, canvas, v1, v2):
		''' Create an invisible, clickable road placeholder between v1 and v2.
		When clicked, it will act like a button and trigger an add_road event here.'''
		
		tag = "road_placeholder_{}_{}_{}_{}".format(v1[0], v1[1], v2[0], v2[1])
		
		# make sure v1 is the left-most one
		if v1[0] > v2[0]:
			v1, v2 = v2, v1
			
		spacing = 10
		slope = self._get_road_slope(v1, v2)
		x_offsets = [10, v2[0] - v1[0] - 10] # 10 from left and 10 from right
		y_offsets = [self._get_y_offset(v1, v2, dx) for dx in x_offsets]
		
		if slope == 0:
			# have a horizontal offset but no vertical offset
			v = (
				(v1[0] + 5, v1[1] + 5),
				(v2[0] - 5, v1[1] + 5),
				(v2[0] - 5, v2[1] - 5),
				(v1[0] + 5, v2[1] - 5),
				)
		elif slope > 0: # this corresponds to neg. slope because of how Tkinter coords work
			
			v = (
				(v1[0] - 5, v1[1]),
				(v1[0] + 5, v1[1]),
				(v2[0] + 5, v2[1]),
				(v2[0] - 5, v2[1]),
				)
		else: # neg. slope in Tkinter == pos. slope in life
			v = (
				(v1[0] - 5, v1[1]),
				(v1[0] + 5, v1[1]),
				(v2[0] + 5, v2[1]),
				(v2[0] - 5, v2[1]),
				)
		
		self._roads[(v1, v2)] = canvas.create_polygon(
			*CatanUtils.get_tkinter_coords(v),
			tags=("road", tag, "building", "road_placeholder"),
			fill="", # transparent fill
		   	outline="" # no outline
		)
		
		f = lambda e: self.add_road(e, v1, v2)
		canvas.tag_bind(tag, "<Button>", func=f)
		
	def add_road(self, event, v1, v2):
		'''Build a road between two vertices in response to user click.'''
		
		color = self.players[self._turn]
		
		# here we update the model
		if self._map.add_road(v1, v2, color):
			print "Building {} road between {} and {}".format(color, v1, v2)
			tag = "road_placeholder_{}_{}_{}_{}".format(v1[0], v1[1], v2[0], v2[1])
			
			self._canvas.itemconfigure(self._roads[(v1, v2)], fill=color, outline="black")
			self._canvas.dtag(self._roads[(v1, v2)], tag)
			self._canvas.dtag(self._roads[(v1, v2)], "road_placeholder")
			
			if self._state == "first road placement":
				if self._turn == 3:
					self.change_to_state("second settlement placement")
				else:
					self.change_status_turn()
					self.change_to_state("first settlement placement")
			elif self._state == "second road placement":
				if self._turn == 0:
					self.change_to_state("gameplay")
				else:
					self.change_status_turn(True)
					self.change_to_state("second settlement placement")
			else:
				self.change_to_state("gameplay")
		else:
			msg = "Road must be attached to a settlement."
			print "Failed to build {} road between {} and {}.".format(color, v1, v2) + " " + msg
			self.post_status_note(msg, error=True)
			
	def cull_adjacent_settlement_nodes(self, canvas, v):
		'''Remove all settlement nodes which are adjacent to vertex v.'''
		
		# first, get adjacent vertices
		adjacent_v_set = self._map.get_adjacent_vertices(v)
		for adjacent_v in adjacent_v_set:
			s = self._settlements[adjacent_v] # these are ovals
			canvas.delete(s) # delete the oval
	
	def draw_settlement_node(self, canvas, v):
		'''Draw an invisible settlement node at the given vertex.
		When clicked, it will act like a button and trigger a draw_settlement event here.'''
		
		padding = CatanApp.settlement_radius / 2
		tag = "settlement_oval_{}_{}".format(*v)
		self._settlements[v] = canvas.create_oval(
		   v[0] - padding,
		   v[1] - padding,
		   v[0] + padding,
		   v[1] + padding, 
		   tags=("settlement", tag, "settlement_placeholder", "building"),
		   fill="", # transparent fill
		   outline="" # no outline
		)
		
		# curry the function
		f = lambda e: self.add_settlement(e, v)
		canvas.tag_bind(tag, "<Button>", func=f)
	
	def add_settlement(self, event, v):
		'''Add a settlement at the given vertex in response to user click.'''
		
		color = self.players[self._get_turn()]
		
		# reflect changes in the model
		result = self._map.add_settlement(v, color)
		if result:
			print "Building {} settlement at {}".format(color, v)
			
			# TODO change the color to reflect the color of the player
			# TODO use sprites instead of ovals
			# draw the settlement oval
			self._canvas.itemconfigure(self._settlements[v], fill=color)
			self._canvas.itemconfigure(self._settlements[v], outline="black")
			self._canvas.dtag(self._settlements[v], "settlement_placeholder")
			
			# create new callback
			f = lambda e: self.add_city(e, v, color)
			tag = "settlement_oval_{}_{}".format(*v)
			self._canvas.tag_bind(tag, "<Button>", func=f)
			
			self.update_vp(color)
			
			if self._state == "first settlement placement":
				self.change_to_state("first road placement")
			elif self._state == "second settlement placement":
				self.change_to_state("second road placement")
			else:# self._state == "additional settlement placement":
				self.change_to_state("gameplay")
		else:
			print "Failed to build {} settlement at {}".format(color, v)
			#TODO possibly other error, like not being connected to a road
			#TODO this is a good place to use an exception
			self.post_status_note("That building spot is too close to an existing settlement", error=True)
			
	def change_to_state(self, new_state):
		'''Move from state in self._state to new_state.'''
		
		self.act_on_end_state()
		self._state = new_state
		self.act_on_start_state()
		
	def add_city(self, event, v, color):
		'''Add a city on top of existing settlement in response to user click.'''
		
		print "Building {} city at {}".format(color, v)
		
		# destroy the oval
		self._canvas.delete(self._settlements[v])
		
		padding = CatanApp.city_radius / 2
		tag = "city_square_{}_{}".format(*v)
		
		self._settlements[v] = self._canvas.create_rectangle(
		   v[0] - padding,
		   v[1] - padding,
		   v[0] + padding,
		   v[1] + padding, 
		   tags=("city", tag, "building"),
		   fill=color, # transparent fill
		   outline="black" # no outline
		)
		
		# reflect changes in the model
		self._map.add_city(v, color)
		self.update_vp(color)
		self.change_to_state("gameplay")
		
	@staticmethod
	def set_vertices(map):
		''' match the board with the generated map 
		'''
		
		# latice AKA board
		# TODO maybe calculate vertices rather than generating them all at once
		hex_coord_latice = get_hex_latice(
			CatanApp.render_start[0], 
			CatanApp.render_start[1], 
			CatanApp.minor_horiz_dist, 
			CatanApp.major_horiz_dist, 
			CatanApp.minor_vert_dist
		)
		
		for row_i, row in enumerate(map):
			for col_i, col in enumerate(row):
				col.set_vertices(hex_coord_latice[row_i][col_i])
		
	def key_pressed(self, event):
		print repr(event.char)

	def end(self, event):
		print "exit event captured"
		self._master.destroy()
		#sys_exit(0)
	
	def run(self):
		#TODO and the window is stuck at the front >_<  
		self._master.attributes("-topmost", 1) # this raises window to front
		
		#TODO focus is still not on top window
		
		self._master.mainloop()