def double_player_game(): board = GameBoard() print("Player 1: Please type in your name: ") player_name_1 = input() print("Player 2: Please type in your name: ") player_name_2 = input() player1 = Human('X', player_name_1) player2 = Human('O', player_name_2) current_player = player1 other_player = player2 winner = None game_over = False while not game_over: print(current_player.name, "Please select the column: [1-7]") print(board) move_allowed = False while not move_allowed: move = current_player.get_move(board, other_player) move_allowed = board.try_place_piece(move, current_player.sign) game_over, winner = board.is_game_over(board.board, current_player.sign, other_player.sign) current_player, other_player = other_player, current_player print(board) if winner: print("Player", other_player.name, "just won! Game over") else: print("Tie!")
class Game: def __init__(self): self.gameboard = GameBoard() #self.gameboard.init_board() def wait_input(self): self.gameboard.print_board() while True: pos = input() x, y = pos.split(' ') self.gameboard.proceed_next_state(int(x), int(y)) self.gameboard.print_board() def input_pos(self, x, y): self.gameboard.proceed_next_state(int(x), int(y)) self.gameboard.get_new_row() #self.gameboard.print_board() def insert_row_to_board(self): self.gameboard.board.remove(self.gameboard.board[0]) self.gameboard.board.append(self.gameboard.new_row) self.gameboard.cursor_pos[0] -= 1 self.gameboard.height += 1
def single_player_game(): board = GameBoard() print("Player 1: Please type in your name: ") player_name = input() player1 = Human('X', player_name) player2 = Computer('O', 6) print("Please select the column: [1-7]") current_player = player1 other_player = player2 winner = None game_over = False while not game_over: print(board) move_allowed = False while not move_allowed: start = time.time() # Get the start time move = current_player.get_move(board, other_player) move_allowed = board.try_place_piece(move, current_player.sign) game_over, winner = board.is_game_over(board.board, current_player.sign, other_player.sign) end = time.time() # Testing end time difference = end - start # Get the time from start to end current_player, other_player = other_player, current_player print("Computing Time: ", difference) print(board) if winner: print("Computer Won! Game over") else: print("Tie!")
def main(): board = GameBoard() board.set_up() while True: board.print() cell_reference = input( "Enter cell to fire at (e.g. A1, B1, ...) or q to quit: ") if cell_reference == "q" or cell_reference == "Q": print("Bye!") return (row, column) = GameBoard.translate_cell_reference(cell_reference) if row == -1: print("'", cell_reference, "' is not a valid cell.", sep="") continue result = board.fire_missile(row, column) if result == FiringResult.HIT: print("Hit!") elif result == FiringResult.MISSED: print("Missed!") else: print("You've already been there!") if board.game_is_won: break board.print() print("Congratulations, you Won!")
def createGame(difficulty): global tileList, tileDictionary, gameBoard gameBoard = GameBoard() tileList = gameBoard.createBoard(difficulty) tileDictionary = copy.deepcopy(gameBoard.tileDictionary)
def update(self): # Main event loop for self.event in pygame.event.get(): if self.event.type == pygame.KEYDOWN: self.key_check() delay = 0.27 - self.level * 0.005 if self.gameboard.slow_time_on: delay *= 2 if time.perf_counter() - self.slow_activation_time > 6: self.gameboard.slow_time_on = False if self.gameboard.swap_shape: self.shape = self.next_shape self.next_shape = Shape() self.gameboard.swap_shape = False if time.perf_counter() - self.last_time > delay: self.last_time = time.perf_counter() self.shape.falling() if self.shape.active == False: self.gameboard.clear_full_rows() self.shape = self.next_shape self.next_shape = Shape() if self.gameboard.check_loss(): new_score = self.gameboard.score / 2 num_lines = self.gameboard.num_lines self.gameboard = GameBoard(WHITE, self.shape.block_list[0].size) self.gameboard.score = new_score self.gameboard.num_lines = num_lines self.shape = Shape() self.next_shape = Shape() if time.perf_counter() - self.start_time > 120: self.done_level = True
class GameManager: def __init__(self, player1, player2): self.size = (3, 3) self.board = GameBoard( size=self.size ) #, preset=[['X', 'O', 'X'],['O', ' ', 'X'],[' ', ' ', 'O']]) self.players = [player1, player2] self.turn_num = 0 self.current_player = 0 self.all_boards = [] def take_turn(self): print(self.board) self.all_boards.append(self.board) move = self.players[self.current_player].take_turn(self.board) self.board = self.board.insert_game_piece(move) # print(self.board) self.current_player = abs(self.current_player - 1) def is_game_over(self): # TODO: return winner object (or name) return self.board.is_game_over()
def default_policy(self, node): current_state = node.state # simulation_board = GameBoard(current_state.current_board, simulation = True) # depth = 0 # while not current_state.is_terminal() and depth < self.MAX_ROLLOUT_DEPTH: # # Pick one random action to play and get next state # current_state = current_state.get_next_state_with_random_choice(simulation_board) # depth += 1 # final_state_reward = simulation_board.score # return final_state_reward simulation_board = GameBoard(current_state.current_board, simulation=True) total_score = 0 for i in range(self.MAX_ROLLOUT_DEPTH): board = simulation_board.board available_choice = simulation_board.get_available_choices() choice = random.choice(available_choice) score = simulation_board.proceed_next_state(choice[0], choice[1]) total_score += self.gamma**i * score return total_score
def glider_demo(): a_game = GameBoard(8) a_game = add_glider(a_game) for i in range(50): print(a_game) sleep(1) a_game.progress()
def score_move(self, board: GameBoard, my_team_index=0, recursion_level=0): teams = ['O', 'X'] game_over, winner = board.is_game_over() if game_over: if winner == 'O': return None, 100 - recursion_level elif winner == 'X': return None, -100 + recursion_level else: return None, 0 else: # current board has no score so we score recursively move_scores = [] for move in self.find_available_moves(board): to_insert = {move: teams[my_team_index]} child_board = board.insert_game_piece(to_insert) score = self.score_move(child_board, my_team_index=abs(my_team_index - 1), recursion_level=recursion_level + 1)[1] move_scores.append((move, score)) min_max_score = move_scores[0] if recursion_level == 0: print(move_scores) print(min_max_score) for move_score in move_scores: # print(move_score, min_max_score, my_team_index == 0) if my_team_index == 0: # maximizing if move_score[1] > min_max_score[1]: min_max_score = move_score elif my_team_index == 1: # minimizing if move_score[1] < min_max_score[1]: min_max_score = move_score return min_max_score
def fancy_pattern_demo(): # https://de.wikipedia.org/wiki/Conways_Spiel_des_Lebens#Andere_Objekte a_game = GameBoard(33) a_game = fancy_pattern(a_game) for i in range(55): print(a_game) sleep(0.1) a_game.progress()
def __init__(self): pygame.init() self.screen = pygame.display.set_mode((800, 600)) self.clock = pygame.time.Clock() self.font = pygame.font.Font(r"C:\Windows\Fonts\consola.ttf", 24) self.going = True self.gameboard = GameBoard()
def __init__(self, game_mode): self.exit = False self.screen = pygame.display.get_surface() self.screen.fill((0, 0, 0)) self.drawableObjects = [] self.userBoard = GameBoard() self.shipBox = GameShipContainer() self.drawSelectedShip = False self.flyingDutch = Boat("./res/img/boat_one_mast.png", 0, 0, 0)
def __init__(self, num_level): self.level = num_level self.shape = Shape() self.next_shape = Shape() self.gameboard = GameBoard(WHITE, self.shape.block_list[0].size) self.last_time = time.perf_counter() self.slow_activation_time = time.perf_counter() self.done_level = False self.start_time = time.perf_counter()
def __init__(self): self.board = GameBoard() self.human = Human('O') difficulty = int( input( "Enter a difficulty from 1 to 6.\nYou can go higher, but performance will take longer.\n> " )) showScores = input("Show scores? (y/n)> ") self.ai = AI('X', difficulty, showScores)
def game_simulation(board): simulation_board = GameBoard(board) total_reward = 0 for i in range(MAX_ROUND_NUMBER): choice = greedy_policy(simulation_board.board, 0, [], target_net, best=True) choice2d = deflatten_action(choice) reward = simulation_board.proceed_next_state(choice2d[0], choice2d[1]) total_reward += reward * gamma_rate ** (i + 1) return simulation_board.board, total_reward
def __init__(self, player1, player2): self.size = (3, 3) self.board = GameBoard( size=self.size ) #, preset=[['X', 'O', 'X'],['O', ' ', 'X'],[' ', ' ', 'O']]) self.players = [player1, player2] self.turn_num = 0 self.current_player = 0 self.all_boards = []
def getSuccessorStates(self): """返回接下来的子状态列表, 和getActions[1]顺序是对应的""" successorStates = [] for row, col in self.board.getEmpty(): gb = GameBoard(anotherBoard=self.board) nextPlayer = 3 - self.player # 把player编号互换1和2 gb.addStone(self.player, row, col) nextState = State(gb, nextPlayer) successorStates.append(nextState) return successorStates
def __init__(self): self.stable_mode = True self.gameboard = GameBoard() pygame.init() self.testFont = pygame.font.Font('freesansbold.ttf', 20) self.screen = pygame.display.set_mode( ((self.gameboard.column_dim + 5) * cell_size, self.gameboard.row_dim * cell_size), 0, 32) ## round means how many bottom rows are added self.round = 0
def get_board_creations_per_second(self, num_boards): boards = [] board = GameBoard(self.num_columns, self.num_rows) t0 = time.time() for _ in range(num_boards): new_board = board.make_copy() boards.append(new_board) t1 = time.time() total_time = t1 - t0 return num_boards / total_time
def draw(self, keep=False): card = self.gb.drawCard() #print "\tGeniusAgent draw: {0}".format(card) prewin_tiles = GameBoard.PreWinTiles(self) if card in prewin_tiles: self.gb.win_agent = self self.win_card = card self.win_by_draw += 1 #print("\t[Test] Agent({0}) 自摸 {1}!".format(self.name, card)) return #print("\t[Test] {0} draw {1}...".format(self.name, card)) ctype = GameBoard.CardType(card) if ctype == 1: if self.wang_list.count(card) == 3: # 確認槓牌 self._kong(ctype, card) return self.draw() self.wang_list.append(card) self.wang_list.sort() self.card_count += 1 elif ctype == 2: if self.tube_list.count(card) == 3: # 確認槓牌 self._kong(ctype, card) return self.draw() self.tube_list.append(card) self.tube_list.sort() self.card_count += 1 elif ctype == 3: if self.bamb_list.count(card) == 3: # 確認槓牌 self._kong(ctype, card) return self.draw() self.bamb_list.append(card) self.bamb_list.sort() self.card_count += 1 elif ctype == 4: if self.word_list.count(card) == 3: # 確認槓牌 self._kong(ctype, card) return self.draw() self.word_list.append(card) self.word_list.sort() self.card_count += 1 elif ctype == 5: if self.wind_list.count(card) == 3: # 確認槓牌 self._kong(ctype, card) return self.draw() self.wind_list.append(card) self.wind_list.sort() self.card_count += 1 else: self.flow_list.append(card) self.flow_list.sort() return self.draw() dcard = self.drop() return dcard
def main(): game_board = GameBoard() graphics = Graphics((800, 800), game_board) while True: play_game(game_board, graphics) if players_are_bored(graphics): break game_board = GameBoard() graphics.game_board = game_board
def __init__(self, gameid, player1, player2): self.gameid = gameid self.game_over = False self.player1 = player1 self.player2 = player2 self.board = GameBoard() self.spectators = [] self.status = '' self.movecount = '0' self.player1.tcphandler.game = self self.player2.tcphandler.game = self self.player1.start_game(self.board, 'X', player2.name) self.player2.start_game(self.board, 'O', player1.name)
def __init__(self): # settings self.buttonSize = 25 self.defaultCanvasWidth = 500 self.defaultCanvasHeight = 500 self.padding = 20 self.buttonImagePadding = 10 self.adjBombTextSize = 25 # window self.window = Tk() self.window.title("BOMBMOPPER") # frames self.statusFrame = Frame(self.window) self.statusFrame.pack(side=TOP) self.gameFrame = Frame(self.window) self.gameFrame.pack(side=BOTTOM) # canvas self.canvasWidth = self.defaultCanvasWidth self.canvasHeight = self.defaultCanvasHeight self.canvas = Canvas(self.gameFrame) self.canvas.config(width=self.canvasWidth, height=self.canvasHeight, background='gray', highlightthickness=0) self.canvas.grid(column=0, row=0, sticky=(N, W, E, S)) # play button self.playButton = PlayButton(self) # difficulty buttons self.easyButton = DifficultyButton(self, 'easy') self.intermediateButton = DifficultyButton(self, 'intermediate') self.hardButton = DifficultyButton(self, 'hard') # initialize board self.board = GameBoard(self) # initialize status bar self.statusBar = StatusBar(self) self.statusBar.packContents() self.window.update() self.statusBar.deactivate() # allow quitting without errors self.window.protocol('WM_DELETE_WINDOW', self.setInactive) self.isActive = True
def reset_state(self) -> None: self.game_board = GameBoard(self.game_board.row_count, self.game_board.col_count, self.game_board.wall_count, self.game_board.box_count, self.game_board.term_count, self.original_player_loc) self.game_board.init_objects(self.original_walls_loc, Object.WALL) self.game_board.init_objects(self.original_boxes_loc, Object.BOX) self.game_board.init_objects(self.original_terminal_loc, Object.TERMINAL) self.game_board.init_objects([c for c in self.original_player_loc], Object.PLAYER) self.terminated = False
class GameClient: board = None human = None ai = None winnerFound = False humansTurn = True currentRound = 1 MAX_ROUNDS = 42 #max number of turns before game baord is full def __init__(self): self.board = GameBoard() self.human = Human('O') while True: # Integer Input Validation Loop try: difficulty = int( input( "Enter a difficulty from 1 to 6.\nYou can go higher, but performance will take longer.\n> " )) except ValueError: print("Invalid input!") continue else: break showScores = input("Show scores? (y/n)> ") self.ai = AI('X', difficulty, showScores) def play(self): print("Playing game...") self.board.printBoard() winner = "It's a DRAW!" while self.currentRound <= self.MAX_ROUNDS and not self.winnerFound: if self.humansTurn: print("Player's turn...") playedChip = self.human.playTurn(self.board) self.winnerFound = self.board.isWinner(self.human.chip) if self.winnerFound: winner = "PLAYER wins!" self.humansTurn = False print("Player played chip at column ", playedChip[1] + 1) else: print("AI's turn...") playedChip = self.ai.playTurn(self.board) self.winnerFound = self.board.isWinner(self.ai.chip) if self.winnerFound: winner = "AI wins!" self.humansTurn = True print("AI played chip at column ", playedChip[1] + 1) self.currentRound += 1 self.board.printBoard() return winner def reset(self): #reset variables self.currentRound = 1 self.winnerFound = False self.humansTurn = True self.board.resetBoard() difficulty = int( input( "Enter a difficulty from 1 to 6.\nYou can go higher, but performance will take longer.\n> " )) self.ai.setDifficulty(difficulty)
def default_policy(self, node): policy_probi, values = self.agent.inference(node.state.current_board) node.policy_probi = policy_probi current_state = node.state simulation_board = GameBoard(current_state.current_board, simulation=True) total_score = 0 for i in range(3): board = simulation_board.board choice = self.agent.best_move(board) score = simulation_board.proceed_next_state(choice[0], choice[1]) total_score += self.gamma**i * score #print(total_score) return total_score
class SnakeGame: def __init__(self): self.board = GameBoard() def start_game(self): pass def update_game(self, direction): self.board.update_game_board(direction) def finish_game(self): pass def get_board(self): return self.board
def draw(self, keep=False): """ Draw card. (Required API by Agent) Gameboard will call this API to informat agent to draw card. Here should be responsible for: 1. Call API:drawCard() from GameBoard object to draw card. 2. Add drawn card into hand. 3. Return card as dropped card. (In general, you will call API:drop() for dropped card) * Return: Dropped card.""" card = self.gb.drawCard() if GameBoard.GoalState(self, card): # Check goal state self.gb.win_agent = self self.win_card = card self.win_by_draw += 1 print("\t[Test] Agent({0}) 自摸 {1}!".format(self.name, card)) return #print("\t[Test] {0} draw {1}...".format(self.name, card)) ctype = GameBoard.CardType(card) if ctype == 1: self.wang_list.append(card) self.wang_list.sort() self.card_count += 1 elif ctype == 2: self.tube_list.append(card) self.tube_list.sort() self.card_count += 1 elif ctype == 3: self.bamb_list.append(card) self.bamb_list.sort() self.card_count += 1 elif ctype == 4: self.word_list.append(card) self.word_list.sort() self.card_count += 1 elif ctype == 5: self.wind_list.append(card) self.wind_list.sort() self.card_count += 1 else: self.flow_list.append(card) self.flow_list.sort() return self.draw() dcard = None if not keep: dcard = self.drop() #print("\t[Test] {0} drop {1}...".format(self.name, dcard)) #self.gb.disCard(self, dcard) return dcard
def default_policy(node): # Get the state of the game current_state = node.state #print(current_state.current_board) ############# ## Then add the inferencing score #big_score = big_inferencer.inference(current_state.current_board) # small_score = small_inferencer.inference(current_state.current_board) # return big_score + small_score ############# ############ simulation_board = GameBoard(current_state.current_board, simulation=True) while current_state.is_terminal(rollout=True) == False: # Pick one random action to play and get next state current_state = current_state.get_next_state_with_random_choice( simulation_board) final_state_reward = current_state.compute_reward(simulation_board) return final_state_reward #+ big_score
def run(self, player1 = "local_player", player2 = "local_player"): self.running = False self.clock = pygame.time.Clock() #to track FPS self.fps= 0 ChessBoardAssets.load_assets() self.board_pos_mouseover_label = render_text("0 / 0", (100, 100, 200)) self.game_board = GameBoard() self.white_pieces = [] self.black_pieces = [] self.captured_pieces = [] self.fill_board() self.turn = TURN.PLAYER_1 self.moves = [] if player1 == "local_player": self.player1 = Player("black", self.game_board, self.white_pieces, self.black_pieces) elif player1 == "ai_player": self.player1 = RandomAI("black", self.game_board, self.white_pieces, self.black_pieces) if player2 == "local_player": self.player2 = Player("white", self.game_board, self.white_pieces, self.black_pieces) elif player2 == "ai_player": self.player2 = RandomAI("white", self.game_board, self.white_pieces, self.black_pieces) self.mainLoop()
def __init__(self, players): self.board = GameBoard() self.players = [PlayerState(i) for i in range(0, players)] self.longestroad = None #int - PlayerId self.largestarmy = None #int - PlayerId self.turn = None #int - PlayerId #Phases: discard, buildsettle, buildroad, moverobber, respondtrade, chooseplayer, standard, ended, turnended self.phase = None self.phaseinfo = None self.lastroll = None #int - Roll value self.numturns = 0
def findSquares(board): """Find complete squares of 3x3 Return None if nothing is found Otherwise return a tuple. The first element is the number of squares found. The second is a copy of the board with each dead square marked.""" newBoard = GameBoard() newBoard.copy(board) squareCount = 0 # All setup, just mark those squares (if they exist) for j in range(newBoard.getHeight() - 3): for i in range(newBoard.getWidth() - 3): if newBoard.squareAt(i, j, 1): squareCount = squareCount + 1 # Marked, check things if squareCount > 0: return (squareCount, newBoard) else: return None
class Game: def __init__(self, board_size, row_size): self.result = "Neither" self.game_board = GameBoard(board_size) ''' Check if the specified pawn color has a winning position ''' def checkForWin(self, color): c = color # R, B ''' Rotate the game board 90 degrees clockwise ''' def rotateClockwise90(self): self.game_board.rotateClockwise90()
def slotNewGameAction(self): self.disconnect(self.options.boardSizeBox,QtCore.SIGNAL('valueChanged(int)'),self.slotBoardSize) #self.options.boardSizeBox.disconnect() self.gameBoard = GameBoard(self) self.setCentralWidget(self.gameBoard) self.gameBoard.initializeGameBoard() self.gameBoard.update() if(self.playerFirstMove == True): self.gameState = PlayerMoveState(self.gameBoard) else: self.gameState = AIMoveState(self.gameBoard) self.gameState.performAction()
def __init__(self): QtGui.QMainWindow.__init__(self) self.resize(500, 540) self.setMaximumSize(500,540) self.setMinimumSize(500,540) self.setWindowTitle('PSZT Gomoku Game') self.setWindowIcon(QtGui.QIcon('ico.png')) self.centerWindow() self.initializeGame() self.gameBoard = GameBoard(self) self.setCentralWidget(self.gameBoard) self.initializeState() self.initializeMenu() self.statusBar()
def gameSetup(self, gameInfo): log.msg('gameInfo: %s' % gameInfo) size = gameInfo['size'] toWin = gameInfo['toWin'] players = gameInfo['players'] maxPlayers = gameInfo['maxPlayers'] queue = gameInfo['queue'] board = gameInfo['board'] self.board = GameBoard(size=size, toWin=toWin, maxPlayers=maxPlayers) for player in players: self.addPlayer(player) self.board.addPlayer(player) self.showBoard() d = self.perspective.callRemote('takePlayerBoard', self) d.addCallback(self.whenReady)
class GameState(object): def __init__(self, players): self.board = GameBoard() self.players = [PlayerState(i) for i in range(0, players)] self.longestroad = None #int - PlayerId self.largestarmy = None #int - PlayerId self.turn = None #int - PlayerId #Phases: discard, buildsettle, buildroad, moverobber, respondtrade, chooseplayer, standard, ended, turnended self.phase = None self.phaseinfo = None self.lastroll = None #int - Roll value self.numturns = 0 def accept(self, v): v.visit(self) for p in self.players: p.accept(v) self.board.accept(v) def maxPlayerScore(self): return max([player.score for player in self.players]) def addResource(self, player, resource, amount): self.players[player].addResource(resource, amount) def removeResource(self, player, resource, amount): self.players[player].removeResource(resource, amount) def countResources(self, player): return self.players[player].resourceCount() def getRandomResource(self, player): return self.players[player].getRandomResource() def getSurroundingResources(self, nodeid): return self.board.getSurroundingResources(nodeid) def addCard(self, player, card): self.players[player].addCard(card) def removeCard(self, player, card): self.players[player].removeCard(card) def getBuildings(self, dieroll): return self.board.getBuildings(dieroll) def updateAllScores(self): for i in xrange(0,len(self.players)): self.updateScore(i) def updateScore(self, player): c = self.board.getCount(player, 'city') s = self.board.getCount(player, 'settlement') army = 2 if (player == self.largestarmy) else 0 road = 2 if (player == self.longestroad) else 0 vpcards = self.players[player].cards['vp'] self.players[player].score = c*2 + s + army + road def addBuilding(self, player, building, corner): self.board.addBuilding(corner, player, building) self.players[player].remBuildings[building] -= 1 if building == 'city': self.players[player].remBuildings['settlement'] += 1 def addRoad(self, player, corner1, corner2): self.board.addRoad(corner1,corner2,player) self.players[player].remBuildings["road"] -= 1 def getLongestRoads(self): return self.board.getLongestRoad() # This could be too slow!! Called when things are built def updateRemaining(self, player): c = self.board.getCount(player, 'city') startingCities = self.players[player].startingBuildings["city"] r = self.board.getCount(player, 'road') startingRoads = self.players[player].startingBuildings["road"] s = self.board.getCount(player, 'settlement') startingSettlement = self.players[player].startingBuildings["settlement"] self.players[player].remBuildings["city"] = startingCities - c self.players[player].remBuildings["road"] = startingRoads - r self.players[player].remBuildings["settlement"] = startingSettlement - s def getAdjacentPlayers(self, tile): return self.board.getAdjacentPlayers(tile) def setRobberTile(self, tile): self.board.setRobber(tile) def getRobberTile(self): return self.board.getRobberPos()
''' Created on May 11, 2015 @author: Jugal112 ''' from GameBoard import GameBoard board = GameBoard(); board.menu();
class TG(pb.Referenceable, Game.TwistedGame): def showBoard(self): size = self.board.size boardSize = self.boardSize px0 = self.px0 py0 = self.py0 boxSize = int(boardSize / size) for x in range(size): for y in range(size): pos = (x, y) px = px0 + x*boxSize py = py0 + y*boxSize s = Drawable.Square(side=boxSize-4, color=BLACK) s.set_position((px, py)) stat = Drawable.Stationary(sprite=s) stat.draw() if pos in self.board.board: name = self.board.board[pos] color = COLORS[self.players.index(name)] c = Drawable.Circle(radius=boxSize-10, color=color) c.set_position((px, py)) stat = Drawable.Stationary(sprite=c) stat.draw() def set_name(self): if len(sys.argv) > 1: name = sys.argv[1] else: try: name = os.getlogin() except: name = 'guest0' self.name = name def connect(self): print 'connecting as', self.name d = pb.connect("localhost", 8800, self.name, 'guest', "TwistTacToeService") d.addCallback(self.connected) d.addErrback(self.connectionFailed) def connectionFailed(self, msg): if self.name.startswith('guest'): n = int(self.name[-1]) if n < 3: n += 1 self.name = 'guest%s' % n self.connect() else: self.connectionReallyFailed() else: self.name = 'guest0' self.connect() def connectionReallyFailed(self): log.msg('Connection Failed') errMsg = Drawable.String(message='Connection Failed') errMsg.set_position((200, 200)) self.errMsg = Drawable.Stationary(sprite=errMsg) self.errMsg.draw() if not self.startedServer: print 'trying to start server' self.startedServer = 1 os.spawnlp(os.P_NOWAIT, 'python', 'python', 'GameServer.py') time.sleep(9) self.set_name() self.connect() def connected(self, perspective): print 'ok' if hasattr(self, 'errMsg'): self.errMsg.uclear() self.perspective = perspective d = self.perspective.callRemote('get_gameInfo') d.addCallback(self.gameSetup) def gameSetup(self, gameInfo): log.msg('gameInfo: %s' % gameInfo) size = gameInfo['size'] toWin = gameInfo['toWin'] players = gameInfo['players'] maxPlayers = gameInfo['maxPlayers'] queue = gameInfo['queue'] board = gameInfo['board'] self.board = GameBoard(size=size, toWin=toWin, maxPlayers=maxPlayers) for player in players: self.addPlayer(player) self.board.addPlayer(player) self.showBoard() d = self.perspective.callRemote('takePlayerBoard', self) d.addCallback(self.whenReady) def whenReady(self, one=None): restart = Widget.StationaryTextButton(self.window, text='START', group=self.events) restart.set_callback(self.reset) restart.set_position((conf.WINWIDTH/2, 5)) restart.draw() self.msg2 = restart def reset(self, pygameEvent): if hasattr(self, 'msg2'): self.msg2.clear() del(self.msg2) self.board.reset_board() self.showBoard() self.ready() def ready(self, one=None): self.perspective.callRemote('startGame') def remote_joined(self, playerName): self.board.addPlayer(playerName) self.addPlayer(playerName) def addPlayer(self, playerName): r = int(self.boardSize / (2 * self.board.maxPlayers)) #print r mx = conf.WINWIDTH - (2 * r) my = r self.players.append(playerName) log.msg('players: %s' % self.players) color = COLORS[self.players.index(playerName)] marker = Drawable.Circle(self.window, r, color=color) name = Drawable.String(self.window, playerName.center(9), fontSize=int(r/2)) stack = Drawable.StationaryStack(self.window) self.playerMarkers[playerName] = stack marker.set_position((mx, (2*r)*(len(self.players)-1) + r)) name.set_position((mx + (r/4), (2*r)*(len(self.players)-1) + r + my)) stack.push(marker) stack.push(name) def remote_start(self): self.board.startGame() self.start() def start(self): pass def remote_left(self, playerName): self.board.removePlayer(playerName) self.players.remove(playerName) self.removePlayer(playerName) def removePlayer(self, playerName): self.playerMarkers[playerName].empty() def remote_badMove(self): self.badMove() self.makeMove() def badMove(self): log.msg('errrk') def remote_sync(self, board): """This should not happen. XXX: If it does, this will not work anyhow. """ self.board.board = board def remote_showMove(self, playerName, position): self.board.move(playerName, position) self.showMove(playerName, position) def showMove(self, playerName, position): x, y = position px0 = self.px0 py0 = self.py0 boxSize = int(self.boardSize / self.board.size) markerSize = int(boxSize / 2) - 5 color = COLORS[self.players.index(playerName)] px = px0 + x*boxSize + 2 py = py0 + y*boxSize + 2 c = Drawable.Circle(self.window, markerSize, color=color) c.set_position((px, py)) stat = Drawable.Stationary(self.window, c) stat.draw() log.msg("%s moved %s" % (playerName, position)) def remote_go(self): if hasattr(self, 'msg'): self.msg.clear() goMsg = Drawable.String(self.window, 'YOUR TURN') goMsg.set_position((20, 5)) self.msg = Drawable.Stationary(self.window, goMsg) self.msg.draw() self.makeMove() def makeMove(self): #log.msg('Your turn: ') self.myTurn = 1 def move(self, position): if self.myTurn: self.myTurn = 0 self.perspective.callRemote('move', position) self.showMove(self.name, position) self.msg.clear() del(self.msg) def remote_wait(self, playerName): if hasattr(self, 'msg'): self.msg.clear() waitMsg = Drawable.String(message='%s TURN' % playerName) waitMsg.set_position((20, 5)) self.msg = Drawable.Stationary(sprite=waitMsg) self.msg.draw() self.wait(playerName) def wait(self, playerName): p = self.players.index(playerName) self.board.player = p #log.msg('%s turn' % playerName) def remote_gameOver(self, playerName): self.gameOver(playerName) def gameOver(self, playerName): log.msg('GAME OVER %s' % playerName) if hasattr(self, 'msg'): self.msg.clear() overMsg = Drawable.String(message='GAME OVER') overMsg.set_position((20, 5)) self.msg = Drawable.Stationary(sprite=overMsg) self.msg.draw() self.whenReady() def positionClicked(self, pygameEvent=None): if pygameEvent is None: #print 'no event' return pos = pygameEvent.pos px, py = pos #print 'pos', pos size = self.board.size boardSize = self.boardSize boxSize = int(boardSize / size) px0 = self.px0 py0 = self.py0 pxMax = px0 + size*boxSize pyMax = py0 + size*boxSize if px < px0 or px > pxMax or py < py0 or py > pyMax: return None else: x = -1 for xEdge in range(px0, pxMax, boxSize): if px > xEdge: x += 1 y = -1 for yEdge in range(py0, pyMax, boxSize): if py > yEdge: y += 1 self.move((x, y)) def initialize(self): self.set_background(tilename='bg9.png') self.boardSize = int(conf.WINHEIGHT * 0.8) self.px0 = self.py0 = int(conf.WINHEIGHT * 0.1) self.players = [] self.myTurn = 0 self.playerMarkers = {} self.set_name() self.connect() self.startedServer = 0 self.events.add(Event.MOUSEBUTTONDOWN_Event(button=1, callback=self.positionClicked))
class ChessGame: def __init__(self): pass def run(self, player1 = "local_player", player2 = "local_player"): self.running = False self.clock = pygame.time.Clock() #to track FPS self.fps= 0 ChessBoardAssets.load_assets() self.board_pos_mouseover_label = render_text("0 / 0", (100, 100, 200)) self.game_board = GameBoard() self.white_pieces = [] self.black_pieces = [] self.captured_pieces = [] self.fill_board() self.turn = TURN.PLAYER_1 self.moves = [] if player1 == "local_player": self.player1 = Player("black", self.game_board, self.white_pieces, self.black_pieces) elif player1 == "ai_player": self.player1 = RandomAI("black", self.game_board, self.white_pieces, self.black_pieces) if player2 == "local_player": self.player2 = Player("white", self.game_board, self.white_pieces, self.black_pieces) elif player2 == "ai_player": self.player2 = RandomAI("white", self.game_board, self.white_pieces, self.black_pieces) self.mainLoop() #wait until a key is pressed, then return def waitForKey(self): press=False while not press: for event in pygame.event.get(): if event.type == KEYUP: press = True #enter the main loop, possibly setting max FPS def mainLoop(self, fps=0): self.running = True self.fps= fps while self.running: pygame.display.set_caption("FPS: %i" % self.clock.get_fps()) events = pygame.event.get() self.player1.handleEvents(events, self.turn==TURN.PLAYER_1, self) self.player2.handleEvents(events, self.turn==TURN.PLAYER_2, self) self.update() self.draw() pygame.display.flip() self.clock.tick(self.fps) def update(self): self.game_board.update(self.white_pieces + self.black_pieces) self.player1.update(self.captured_pieces) self.player2.update(self.captured_pieces) if self.turn == TURN.PLAYER_1: move = self.player1.get_move() elif self.turn == TURN.PLAYER_2: move = self.player2.get_move() if move: # if received move, execute it move.execute(self.white_pieces, self.black_pieces, self.captured_pieces) self.moves.append(move) self.turn = (self.turn + 1) % 2 # wait for p1 move, execute - wait for p2 move, execute (with time limit?) def draw(self): self.game_board.draw() for piece in self.black_pieces: piece.draw() for piece in self.white_pieces: piece.draw() if Options.show_captured_pieces: # draw captured pieces on the side of the board xoffset = 10 for piece in self.captured_pieces: #Refactor: move this to piece class? piece.draw(xoffset) xoffset += 5 self.draw_color_helpers() screen.blit(self.board_pos_mouseover_label, (10, 450)) def draw_color_helpers(self): if self.turn == TURN.PLAYER_1 and self.player1.type == "local_player" and self.player1.selected_piece: if Options.highlight_selected: screen.blit(ChessBoardAssets.selected_piece, (self.player1.selected_piece.board_x * tile_size + offset[0], self.player1.selected_piece.board_y * tile_size + offset[1]))# draw selected for pos in self.player1.selected_piece.possible_moves: # draw possible captures & moves if Options.highlight_capturable and self.game_board.board[pos[0]][pos[1]].occupying_piece: screen.blit(ChessBoardAssets.possible_capture, (pos[0] * tile_size + offset[0], pos[1] * tile_size + offset[1])) # draw possible captures elif Options.highlight_possible_moves: screen.blit(ChessBoardAssets.possible_move, (pos[0] * tile_size + offset[0], pos[1] * tile_size + offset[1])) # draw possible moves elif self.turn == TURN.PLAYER_2 and self.player2.type == "local_player" and self.player2.selected_piece: if Options.highlight_selected: screen.blit(ChessBoardAssets.selected_piece, (self.player2.selected_piece.board_x * tile_size + offset[0], self.player2.selected_piece.board_y * tile_size + offset[1])) for pos in self.player2.selected_piece.possible_moves: if Options.highlight_capturable and self.game_board.board[pos[0]][pos[1]].occupying_piece: screen.blit(ChessBoardAssets.possible_capture, (pos[0] * tile_size + offset[0], pos[1] * tile_size + offset[1])) # draw possible captures elif Options.highlight_possible_moves: screen.blit(ChessBoardAssets.possible_move, (pos[0] * tile_size + offset[0], pos[1] * tile_size + offset[1])) # draw possible moves def fill_board(self): for i in range(8): self.black_pieces.append(Pawn("black", i, 6, tile_size, tile_size, ChessBoardAssets.black_pawn_surface)) self.white_pieces.append(Pawn("white", i, 1, tile_size, tile_size, ChessBoardAssets.white_pawn_surface)) # rooks self.black_pieces.append(Rook("black", 7, 7, tile_size, tile_size, ChessBoardAssets.black_rook_surface)) self.black_pieces.append(Rook("black", 0, 7, tile_size, tile_size, ChessBoardAssets.black_rook_surface)) self.white_pieces.append(Rook("white", 7, 0, tile_size, tile_size, ChessBoardAssets.white_rook_surface)) self.white_pieces.append(Rook("white", 0, 0, tile_size, tile_size, ChessBoardAssets.white_rook_surface)) # Bishop self.black_pieces.append(Bishop("black", 5, 7, tile_size, tile_size, ChessBoardAssets.black_bishop_surface)) self.black_pieces.append(Bishop("black", 2, 7, tile_size, tile_size, ChessBoardAssets.black_bishop_surface)) self.white_pieces.append(Bishop("white", 5, 0, tile_size, tile_size, ChessBoardAssets.white_bishop_surface)) self.white_pieces.append(Bishop("white", 2, 0, tile_size, tile_size, ChessBoardAssets.white_bishop_surface)) # knights self.black_pieces.append(Knight("black", 6, 7, tile_size, tile_size, ChessBoardAssets.black_knight_surface)) self.black_pieces.append(Knight("black", 1, 7, tile_size, tile_size, ChessBoardAssets.black_knight_surface)) self.white_pieces.append(Knight("white", 6, 0, tile_size, tile_size, ChessBoardAssets.white_knight_surface)) self.white_pieces.append(Knight("white", 1, 0, tile_size, tile_size, ChessBoardAssets.white_knight_surface)) # Queens self.black_pieces.append(Queen("black", 3, 7, tile_size, tile_size, ChessBoardAssets.black_queen_surface)) self.white_pieces.append(Queen("white", 3, 0, tile_size, tile_size, ChessBoardAssets.white_queen_surface)) # Kings self.black_pieces.append(King("black", 4, 7, tile_size, tile_size, ChessBoardAssets.black_king_surface)) self.white_pieces.append(King("white", 4, 0, tile_size, tile_size, ChessBoardAssets.white_king_surface)) def keyDown(self, key): pass def keyUp(self, key): pass def mouseUp(self, button, pos): pass def mouseMotion(self, buttons, pos, rel): pass
def test_basicMove(self): g = GameBoard() position = (17, 3) roll = 3 landings = g.move(position, roll, position) assert landings == ((16, 3), (18, 3), (17, 4), (17, 2), (16, 5), (18, 5), (17, 6))
def __init__(self, board_size, row_size): self.result = "Neither" self.game_board = GameBoard(board_size)
class GameWindow(QtGui.QMainWindow): def __init__(self): QtGui.QMainWindow.__init__(self) self.resize(500, 540) self.setMaximumSize(500,540) self.setMinimumSize(500,540) self.setWindowTitle('PSZT Gomoku Game') self.setWindowIcon(QtGui.QIcon('ico.png')) self.centerWindow() self.initializeGame() self.gameBoard = GameBoard(self) self.setCentralWidget(self.gameBoard) self.initializeState() self.initializeMenu() self.statusBar() # Method is used to initialize Menu def initializeMenu(self): self.newGame = QtGui.QAction(QtGui.QIcon('newGame.png'),'New game',self) self.newGame.setShortcut('Ctrl+N') self.newGame.setStatusTip('Star new game') self.connect(self.newGame,QtCore.SIGNAL('triggered()'),self.slotNewGameAction) self.options = QtGui.QAction(QtGui.QIcon('options.png'),'Options',self) self.options.setShortcut('Ctrl+O') self.options.setStatusTip('Configure options') self.connect(self.options, QtCore.SIGNAL('triggered()'), self.slotOptionsAction) self.exit = QtGui.QAction(QtGui.QIcon('exit.png'), 'Exit', self) self.exit.setShortcut('Ctrl+Q') self.exit.setStatusTip('Exit application') self.connect(self.exit, QtCore.SIGNAL('triggered()'), QtCore.SLOT('close()')) self.about = QtGui.QAction(QtGui.QIcon('about.png'),'About',self) self.about.setShortcut('Ctrl+A') self.about.setStatusTip('Read about Game and autors') self.connect(self.about,QtCore.SIGNAL('triggered()'),self.slotAboutAction) self.aboutPyQt = QtGui.QAction(QtGui.QIcon('aboutPyQt.png'),'About PyQt',self) self.aboutPyQt.setShortcut('Ctrl+T') self.aboutPyQt.setStatusTip('Read about PyQt') self.connect(self.aboutPyQt,QtCore.SIGNAL('triggered()'),self.slotAboutPyQtAction) menubar = self.menuBar() file = menubar.addMenu('&Game') file.addAction(self.newGame) file.addAction(self.options) file.addAction(self.exit) help = menubar.addMenu('&Help') help.addAction(self.about) help.addAction(self.aboutPyQt) self.initializeOptions() # Method is used to initialize Game Options Widget def initializeOptions(self): self.options = QtGui.QWidget() self.options.resize(400, 200) self.options.setMaximumSize(400,200) self.options.setMinimumSize(400,200) self.options.setWindowTitle('PSZT Gomoku Game - Options') self.options.setWindowIcon(QtGui.QIcon('options.png')) screen = QtGui.QDesktopWidget().screenGeometry() size = self.options.geometry() self.options.move((screen.width()-size.width())/2, (screen.height()-size.height())/2) # Init board size options self.options.setBoardSize = QtGui.QLabel("Set Board size:",self.options) self.options.setBoardSize.move(20,10) self.options.boardSizeBox = QtGui.QSpinBox(self.options) self.options.boardSizeBox.setGeometry(20,30,50,20) self.options.boardSizeBox.setMinimum(7) self.options.boardSizeBox.setMaximum(25) self.options.boardSizeBox.setValue(25) self.options.boardSizeBox.setSingleStep(2) self.options.sizeValue = 27 # Init alpha-beta options self.options.setABDepth = QtGui.QLabel("Set A-B depth:",self.options) self.options.setABDepth.move(150,10) self.options.depthBox = QtGui.QSpinBox(self.options) self.options.depthBox.setGeometry(150,30,50,20) self.options.depthBox.setMinimum(1) self.options.depthBox.setMaximum(10) self.options.depthBox.setValue(2) self.options.setMaxSearchTime = QtGui.QLabel("Set max. search time:",self.options) self.options.setMaxSearchTime.move(230,10) self.options.timeBox = QtGui.QDoubleSpinBox(self.options) self.options.timeBox.setGeometry(230,30,50,20) self.options.timeBox.setMinimum(0.1) self.options.timeBox.setMaximum(10.0) self.options.timeBox.setValue(3.0) self.options.timeBox.setSingleStep(0.1) # backup values self.options.depthValue = 2 self.options.timeValue = 3.0 self.connect(self.options.boardSizeBox,QtCore.SIGNAL('valueChanged(int)'),self.slotBoardSize) self.connect(self.options.timeBox,QtCore.SIGNAL('valueChanged(double)'),self.slotMaxTime) self.connect(self.options.depthBox,QtCore.SIGNAL('valueChanged(int)'),self.slotMaxDepth) self.options.abButtonGroup = QtGui.QButtonGroup() self.options.chooseABValue = QtGui.QLabel("Choose A-B value:",self.options) self.options.chooseABValue.move(180,80) self.options.useDepth = QtGui.QRadioButton("Use depth",self.options) self.options.useDepth.move(180,100) self.connect(self.options.useDepth, QtCore.SIGNAL('pressed()'), self.slotUseDepth) self.options.useTime = QtGui.QRadioButton("Use time",self.options) self.options.useTime.move(180,120) self.options.useTime.toggle() self.connect(self.options.useTime, QtCore.SIGNAL('pressed()'), self.slotUseTime) self.options.abButtonGroup.addButton(self.options.useDepth) self.options.abButtonGroup.addButton(self.options.useTime) # backup values self.options.useDepthValue = False self.options.useTimeValue = True # Init figure options self.options.figureButtonGroup = QtGui.QButtonGroup() self.options.choosePlayerFigure = QtGui.QLabel("Choose Player figure:",self.options) self.options.choosePlayerFigure.move(20,80) self.options.useWhite = QtGui.QRadioButton("Use white",self.options) self.options.useWhite.move(20,100) self.connect(self.options.useWhite, QtCore.SIGNAL('pressed()'), self.slotUseWhite) self.options.useBlack = QtGui.QRadioButton("Use black",self.options) self.options.useBlack.move(20,120) self.options.useBlack.toggle() self.connect(self.options.useBlack, QtCore.SIGNAL('pressed()'), self.slotUseBlack) self.options.figureButtonGroup.addButton(self.options.useBlack) self.options.figureButtonGroup.addButton(self.options.useWhite) # backup values self.options.playerFigureValue = 2 self.options.aiFigureValue = 1 self.options.playerFirstMoveValue = True self.options.okButton = QtGui.QPushButton("OK",self.options) self.options.okButton.move(20,160) self.options.cancelButton = QtGui.QPushButton("Cancel",self.options) self.options.cancelButton.move(180,160) self.connect(self.options.okButton, QtCore.SIGNAL('pressed()'), self.okClose) self.connect(self.options.cancelButton, QtCore.SIGNAL('pressed()'), self.options.close) # Method is used to confirm option changes and close options window. def okClose(self): self.boardSize = self.options.sizeValue self.gameBoard.boardSize = self.boardSize self.gameBoard.update() self.maxDepth = self.options.depthValue self.maxTime = self.options.timeValue self.useTime = self.options.useTimeValue self.useDepth = self.options.useDepthValue self.playerFigure = self.options.playerFigureValue self.aiFigure = self.options.aiFigureValue self.playerFirstMove =self.options.playerFirstMoveValue self.options.close() # Method is used to set game board size. def slotBoardSize(self,value): self.options.sizeValue = value +2 # Method is used to set max search depth of alpha-beta algorithm. def slotMaxDepth(self,value): self.options.depthValue = value # Method is used to set max search time of alpha-beta algorithm. def slotMaxTime(self,value): self.options.timeValue = value # Method is used to set that alpha-beta will use time bound. def slotUseTime(self): if(self.options.useTime.isDown): self.options.useTimeValue = True self.options.useDepthValue = False # Method is used to set that alpha-beta will use depth boudn. def slotUseDepth(self): if(self.options.useDepth.isDown): self.options.useTimeValue = False self.options.useDepthValue = True # Method is used to set that Player will use white figure and starts second. def slotUseWhite(self): if(self.options.useWhite.isDown): self.options.playerFigureValue = 1 self.options.aiFigureValue = 2 self.options.playerFirstMoveValue = False self.aiFigure = 2 # Method is used to set that Player will use black figure and starts first. def slotUseBlack(self): if(self.options.useBlack.isDown): self.options.playerFigureValue = 2 self.options.aiFigureValue = 1 self.options.playerFirstMoveValue = True self.aiFigure = 1 # Method is used to initialize game def initializeGame(self): self.boardSize = 27 self.maxDepth = 2 self.maxTime = 0.1 self.useTime = True self.useDepth = False self.playerFigure = 2 self.aiFigure = 1 self.playerFirstMove = True # Method is used to initialize game state. def initializeState(self): # set initial game state - Idle self.gameState = IdleState(self.gameBoard) self.gameState.performAction() # Method is used to center widnow on screen. def centerWindow(self): screen = QtGui.QDesktopWidget().screenGeometry() size = self.geometry() self.move((screen.width()-size.width())/2, (screen.height()-size.height())/2) # Method is used to catch key press event. def keyPressEvent(self, event): if event.key() == QtCore.Qt.Key_Escape: self.close() # Method is used to start game. def slotNewGameAction(self): self.disconnect(self.options.boardSizeBox,QtCore.SIGNAL('valueChanged(int)'),self.slotBoardSize) #self.options.boardSizeBox.disconnect() self.gameBoard = GameBoard(self) self.setCentralWidget(self.gameBoard) self.gameBoard.initializeGameBoard() self.gameBoard.update() if(self.playerFirstMove == True): self.gameState = PlayerMoveState(self.gameBoard) else: self.gameState = AIMoveState(self.gameBoard) self.gameState.performAction() # Method is used to show options. def slotOptionsAction(self): self.options.activateWindow() self.options.setVisible(True) # Method is used to execute about action. Show game rules and credits. def slotAboutAction(self): QtGui.QMessageBox.about(self,"Gomoku", "Game Gomoku with Alpha-beta AI algorithm " "developed by Michal Andrzejewski and Szymon Jablonski, students " "of Warsaw University of Technology for Basics of Artificial Intelligence course.") # Method is used to execute aboutPyQt action. Show information about Qt. def slotAboutPyQtAction(self): QtGui.QMessageBox.aboutQt(self) # Method is used to set game to gameOver state, show winner and close # application. def gameOver(self, winner): #enter idle state self.gameState = IdleState(self.gameBoard) self.gameState.performAction() self.over = QtGui.QWidget() self.over.resize(300, 200) self.over.setMaximumSize(300,200) self.over.setMinimumSize(300,200) self.over.setWindowTitle('PSZT Gomoku Game - Game Over!') self.over.setWindowIcon(QtGui.QIcon('options.png')) screen = QtGui.QDesktopWidget().screenGeometry() size = self.over.geometry() self.over.move((screen.width()-size.width())/2, (screen.height()-size.height())/2) if winner == self.aiFigure: self.over.winnerLabel = QtGui.QLabel("AI won!",self.over) elif winner == self.playerFigure: self.over.winnerLabel = QtGui.QLabel("Player won!",self.over) elif winner == 0: self.over.winnerLabel = QtGui.QLabel("Draw!",self.over) self.over.winnerLabel.move(110,40) self.over.exitButton = QtGui.QPushButton("Exit",self.over) self.over.exitButton.move(100,75) self.over.activateWindow() self.over.setVisible(True) self.connect(self.over.exitButton, QtCore.SIGNAL('pressed()'), self.exitSlot) # Method is used to close application. def exitSlot(self): self.over.close() self.close()