Initial commit

Author: Thomas Renn

.gitignore

@@ -0,0 +1,10 @@
+# Git Ignore files #
+
+# Compiled files #
+##########################
+*.pyc
+
+# OS files #
+##########################
+.DS_Store
+

connect4.py

@@ -0,0 +1,125 @@
+#
+#	Overall Connect-4 game playing module
+# 	Author: Tom Renn
+#
+import gameboard as gb
+import nodeModule as nm
+import re
+import sys
+import cProfile
+
+# MiniMax algorithm
+#
+# node: Root node to calculate minimax on
+# depth: How far down into the node to search
+# returnNode: Optional parameter, True if this call is to return the resulting child node to pick
+#		otherwise miniMax returns the heuristic value of the node it is given
+def miniMax(node, depth, returnNode=False):
+	isLeaf = False
+	children = node.generateChildren()
+	availableMoves = node.getAvailableMoves()
+	result = 0;
+	resultNode = node
+
+	if len(availableMoves) == 0: 	# we're at a leaf
+		result = node.heuristic2()
+	elif  depth < 1: 				# reached max depth
+		result = node.heuristic2()
+	else:
+		# look at each child for the moves available
+		for nextMove in availableMoves:
+			child = nm.Node(node, nextMove)
+			# value of child node
+			result = miniMax(child, depth-1)
+
+			if node.player == nm.PLAYER_MAX:	# player is MAX
+				if result >= node.alpha: 
+					node.alpha = result
+					resultNode = child
+			else: 								# player is MIN	
+				if result <= node.beta:
+					node.beta = result
+					resultNode = child
+			
+			# determine if we need to stop searching children	
+			if node.alpha >= node.beta:
+				break
+				
+	if (returnNode):
+		# clear alpha-beta values from this traversal
+		resultNode.resetAlphaBeta()
+		return resultNode
+	else:
+		return result
+
+# Overall method that plays connect4
+def playGame():
+	state = nm.Node()
+	print 'Welcome to connect4. You are P, the player. C is the computer opponent'
+	print "Type 'quit' or 'q' to exit the game at any time"
+
+	if askPlayerPreference():	# player moves first if desired
+		move = getPlayerMove(state)
+		state = state.placeChipAt(move)
+	else:						# always have computer act as MAX player
+		state.setPlayerType(nm.PLAYER_MAX)
+
+	winningPlayer = 'initalization'
+	# Game continues until someone wins
+	while True: 
+		depth = 4
+		state = miniMax(state, depth, True)
+		state.gameboard.fancyPrint()
+
+		if state.isGameOver():
+			winningPlayer = 'Computer wins!'
+			break
+
+		move = getPlayerMove(state)
+		if move == -1:
+			winningPlayer = 'You quit, loser!'
+			break
+
+		state = state.placeChipAt(move)
+
+		if state.isGameOver():
+			# print winning gameboard
+			state.gameboard.fancyPrint() 
+			winningPlayer = 'You win!'
+			break
+
+	print winningPlayer
+
+# get the players next move for a particular node
+# continues until player enters an available move
+# or until player types quit, which case returns -1
+def getPlayerMove(node):
+	availableMoves = node.getAvailableMoves()
+	move = -1
+	while move == -1 or move not in availableMoves:
+		move = raw_input("Choose your next move (0-6): ")
+		if re.match('\d', move): # move is a digit
+			move = int(move)
+		elif re.match('quit|q', move):
+			move = -1
+			break
+	return move
+
+# ask the player if they would like to move first
+# returns True if player moves first
+def askPlayerPreference():
+	yes = ["yes", "y", "Y"]
+	no = ["no", "n", "N"]
+	userInput = raw_input("Would you like to move first? (y/n): ")
+	if userInput in yes:
+		return True
+	elif userInput in no:
+		return False
+	else:
+		print "Sorry that is not an acceptable answer"
+		return askPlayerPreference()
+
+
+playGame()
+
+

gameboard.py

@@ -0,0 +1,90 @@
+#
+#	GameBoard module
+#	-
+#	Represent a board to play on using a 2d array from NumPy
+# 	NumPy : http://sourceforge.net/projects/numpy/files/NumPy/1.7.1/
+#
+#	Author: Tom Renn
+#
+import numpy as np
+import nodeModule
+
+BOARD_WIDTH = 7
+BOARD_HEIGHT = 6
+EMPTY_SPOT = 0
+
+class GameBoard:
+
+	# Constructor
+	# If no board is given, create one containing all 0s
+	def __init__(self, baseBoard=None):
+		if baseBoard is None:
+			self.board = np.zeros( (BOARD_HEIGHT, BOARD_WIDTH), dtype=np.int16)
+		else:
+			self.board = baseBoard
+
+	# place chip in a given column index
+	# return (row, col) of newly placed chip, or (-1, -1) if unable to be placed
+	def moveAt(self, index, player):
+		if index not in range(BOARD_WIDTH):
+			return (-1, -1)
+		
+		# go from bottom of the board up
+		for i in reversed(range(BOARD_HEIGHT)):
+			row = self.board[i] 
+			if row[index] == EMPTY_SPOT:	# found empty row
+				row[index] = player
+				return (i, index)
+			else:							# row occupied 
+				continue
+
+		# if we got this far, the move is not able to be made
+		return (-1, -1)
+
+	# return the chip at the given row and column
+	# returns EMPTY_SPOT if board bounds are exceeded
+	def getChipAt(self, row, col):
+		if row >= 0 and row < BOARD_HEIGHT:
+			if col >= 0 and col < BOARD_WIDTH:
+				return self.board[row][col]
+		return EMPTY_SPOT
+
+	# return indexes of available moves
+	def getAvailableMoves(self):
+		movesAvailable = []
+		for i in range(BOARD_WIDTH):
+			if self.board[0][i] == EMPTY_SPOT:
+				movesAvailable.append(i)
+		return movesAvailable
+
+	# prints the gameboard in a nice format
+	def fancyPrint(self):
+		for row in range(BOARD_HEIGHT):
+			rowString = '|'
+			for col in range(BOARD_WIDTH):
+				pos = self.board[row][col]
+				if pos == EMPTY_SPOT:
+					# if bottom row and empty show _ 
+					if row == (BOARD_HEIGHT - 1):
+						pos = '_'
+					else:
+						pos = ' '
+				elif pos == nodeModule.PLAYER_MIN:
+					pos = 'P'
+				else:
+					pos = 'C'
+				rowString = rowString + pos + '|'
+			print rowString
+		# print index on bottom
+		rowString = '|'
+		for row in range(BOARD_WIDTH):
+			rowString = rowString + str(row) + '|'
+		print rowString
+
+	# number of available moves
+	def availableMoves(self):
+		count = 0
+		for i in range(BOARD_WIDTH):
+			if self.board[0][i] == EMPTY_SPOT:
+				count = count + 1
+		return count