Chest game public

chest game

import ipdb
import re
import sys
PROMPT_SIZE = "Board size: "
ERROR_SIZE = "Size must be an odd number between 5 and 9"
PROMPT_MOVE_X = "Player X, enter move: "  # Or player Y ...
PROMPT_MOVE_Y = "Player Y, enter move: "  # Or player Y ...
ERROR_MOVE_LENGTH = "Move must be 5 characters"
ERROR_MOVE_PIECE ="Error move piece" # e.g player X can not move piece "Y" or piece that was used by the opponent in his/her last move.
ERROR_MOVE_POSITION = "Invalid position" # you can't place your player on occupied position, or place S on "T", or go over the board 
ERROR_MOVE_FORMAT = "Invalid input format" # if you play, e.g., 3A:5A instead of A3:A5
ERROR_MOVE_ILLEGAL = "Illegal move" #the piece does not go as far as it can, or jumps over other pieces
WIN_X = "Win for player X!"   # Or player Y
WIN_Y = "Win for player Y!"   # Or player Y



def str_plus(string, number = 1):
	return chr((ord(to_position[0])+ number))

def get_char(number):
	return chr(number + 64)

def get_board_size():
	validate = False
	while (validate == False):
		try:
			user_input = int(raw_input(PROMPT_SIZE))
			if (user_input >= 5 and
					user_input <=9 and
					user_input % 2 == 1):
				validate = True
			else:
				print ERROR_SIZE
		except ValueError:
			print ERROR_SIZE
	return user_input

def make_board(board_size):
	board = []
	for row in range(1, board_size + 1):
		row_list = []
		for column in range(1, board_size + 1):
			if (row == 1):
				if (column != (board_size + 1) / 2):
					row_list.append('S')
				else:
					row_list.append('X')
			elif (row == board_size):
				if (column != (board_size + 1) / 2):
					row_list.append('S')
				else:
					row_list.append('Y')
			elif (row == (board_size + 1) / 2):
				if (column != (board_size + 1) / 2):
					row_list.append('.')
				else:
					row_list.append('T')
			else:
				row_list.append('.')
		board.append(row_list)
	return board


class Chest(object):
	def __init__(self, board): #size of the chest board
		self.size = len(board) 
		self.generate_chest_postion(board)
		self.turn = 'X'
		self.user_input = None
		self.from_position = None
		self.to_position = None
		self.last_position = None
		self.result = None
		self.error = None 

	def __wall_generate(self):
		wall_set = set([])
		size = self.size
		for num in [0, size + 1]:
			for char in range(0, size + 2):
				wall_set.add(get_char(char) + str(num))
		for char in [0, size+1]:
			for num in range(1, size + 1):
				wall_set.add(get_char(char) + str(num))
		return wall_set


	def generate_chest_postion(self, board):
		size = self.size
		self.wall = self.__wall_generate()
		self.supporters = set([]) 
		for y in range(0, size):
			for x in range(0, size):
				position = get_char(x + 1) + str(y + 1)
				if(board[y][x] == 'S'):
					self.supporters.add(position)
				elif(board[y][x] == 'X'):
					self.player_x = position  
				elif(board[y][x] == 'Y'):
					self.player_y = position  
				elif(board[y][x] == 'T'):
					self.treasure = position

	def print_chest(self):
		size = self.size 
		for num in range(0, size + 1):
			for char in range(0, size + 1):
				str_char = get_char(char)
				str_num = str(num)
				position = str_char + str_num 
				if(position in self.supporters ):
					sys.stdout.write("S")
				elif(position == self.player_x):
					sys.stdout.write('X')
				elif(position == self.player_y):
					sys.stdout.write('Y')
				elif(position == self.treasure):
					sys.stdout.write('T')
				elif(position in self.wall):
					if(num == 0 and char == 0):
						sys.stdout.write(' ')
					elif(num == 0):
						sys.stdout.write(str_char)
					elif(char == 0):
						sys.stdout.write(str_num)
				else:
					sys.stdout.write(".")
			sys.stdout.write("\n")

	def __to_pos(self, x, y, next=0):
		return "{0:s}:{1:d}".format(chr(x + next ),y + next)	

	def validate_move_length(self):
		try:
			if len(self.user_input) == 5:
				return True
			else:
				self.error = ERROR_MOVE_LENGTH 
				return False
		except ValueError:
			self.error = ERROR_MOVE_LENGTH 
			return False

	def validate_move_format(self):
		pattern = re.compile('^[a-zA-z][0-9]:[a-zA-Z][0-9]$')
		if pattern.match(self.user_input):
			self.from_position, self.to_position = self.user_input.split(':')	
			self.last_position = self.to_position 
			return True
		else:
			self.error = ERROR_MOVE_FORMAT 
			return False

	def validate_move_piece(self):
		if (self.from_position in self.supporters or 
		(self.turn == 'X' and self.from_position == self.player_x) or 
		(self.turn == 'Y' and self.from_position == self.player_y) or 
		(self.last_position == self.from_position)):
			return True
		else:
			self.error = ERROR_MOVE_PIECE 
			return False
	def validate_move_position(self):
		if(self.to_position == self.player_x or
				self.to_position == self.player_y or
				self.to_position == self.treasure or
				self.to_position in self.supporters or
				ord(self.to_position[0]) - 64 > self.size or
				int(self.to_position[1]) > self.size):
			self.error = ERROR_MOVE_POSITION
			return False
		else:
			return True

	def validate_move_illegal(self):
		to_pos_x = ord(self.to_position[0])
		to_pos_y = int(self.to_position[1])
		from_pos_x = ord(self.from_position[0])
		from_pos_y = int(self.from_position[1])
		obstacles = set([])
		path = set([])		
		result = False
		obstacles.update(self.supporters)
		obstacles.update(self.wall)	
		obstacles.add(self.player_x)
		obstacles.add(self.player_y)
		delta_pos_x = to_pos_x - ord(self.from_position[0])
		delta_pos_y = to_pos_y - int(self.from_position[1])
		delta_pos = delta_pos_x if abs(delta_pos_x) != 0 else abs(delta_pos_y)
		if abs(delta_pos_x) == abs(delta_pos_y):
			if delta_pos_x > 0 and delta_pos_y > 0:
				if self.__to_pos(to_pos_x + 1, to_pos_y + 1) in obstacles:
					for increment in range(1, delta_pos):
						if self.__to_pos(from_pos_x + increment, from_pos_y + increment) in obstacles:
							result = False 
							break
						else:
							result = True	
			if delta_pos_x > 0 and delta_pos_y < 0:
				if self.__to_pos(to_pos_x + 1, to_pos_y - 1) in obstacles:
					for increment in range(1, delta_pos):
						if self.__to_pos(from_pos_x + increment, from_pos_y - increment) in obstacles:
							result = False 
							break
						else:
							result = True	
			if delta_pos_x < 0 and delta_pos_y > 0:
				if self.__to_pos(to_pos_x - 1, to_pos_y - 1) in obstacles:
					for increment in range(1, delta_pos):
						if self.__to_pos(from_pos_x + increment, from_pos_y - increment) in obstacles:
							result = False 
							break
						else:
							result = True	
			if delta_pos_x < 0 and delta_pos_y < 0:
				if self.__to_pos(to_pos_x - 1, to_pos_y - 1) in obstacles:
					for increment in range(1, delta_pos):
						if self.__to_pos(from_pos_x - increment, from_pos_y - increment) in obstacles:
							result = False 
							break
						else:
							result = True	
		self.error = None if result else ERROR_MOVE_ILLEGAL	
		return result
def start(board):
	chest = Chest(board)
	while chest.result == None:
		chest.print_chest()
		print chest.user_input
		if chest.error:
			print chest.error
			chest.error = None
		if chest.turn == 'X':
			chest.user_input = raw_input(PROMPT_MOVE_X).upper()
		elif (chest.turn == 'Y'):
			chest.user_input = raw_input(PROMPT_MOVE_Y).upper()
		if chest.validate_move_length():
			if chest.validate_move_format():
				if chest.validate_move_piece():
					if chest.validate_move_position():
						if chest.validate_move_illegal():
							pass

	if(chest.result == 'X'):
		print WIN_X
	elif(chest.result == 'Y'):
		print WIN_Y

def play(initial_board_config):
	if initial_board_config is None:
		board_size = get_board_size()
		board = make_board(board_size)
		start(board)
	else:
		board_size = len(initial_board_config)
		board = initial_board_config