def run_game(player_one, player_two):
print 'Starting Game'
game = GameBoard()
turn = 0
while game.winner is None:
#player one plays even turns
if turn % 2 == 0:
current_player = player_one
#player two plays odd turns
else:
current_player = player_two
# get player input
print game
print ' '.join(str(number) for number in range(game.columns))
column = raw_input('{} which column to place {}? '.format(
current_player.name, current_player.piece))
# try to insert piece into board, retry turn if failure
if not game.insert_piece(column, current_player.piece):
print 'Column either full or invalid, please make another move'
continue
turn += 1
print game
print '{} wins in {} turns'.format(current_player.name, turn)
def __init__(self, size):
self.player = 0
self.playerA = 'human'
self.playerB = 'minimax'
self.depth = 5
self.useDecisionTree = 1
self.dynamicDepth = 1
self.board = GameBoard(size, size, self.playerA, self.playerB,
self.depth, self.useDecisionTree,
self.dynamicDepth)
self.bars = {}
self.width, self.height = self.board.width, self.board.height
self.board_state_size = (self.width - 1) * self.height * 2
self.state_to_move = {}
self.move_to_state = {}
for dot in cartesian(range(self.width), range(self.height)):
if dot[0] < self.width - 1:
move = (dot, right(dot))
ind = self.__convert_move_to_state(move)
self.state_to_move[ind] = move
self.move_to_state[move] = ind
self.bars[move] = None
if dot[1] < self.height - 1:
move = (dot, upper(dot))
ind = self.__convert_move_to_state(move)
self.state_to_move[ind] = move
self.move_to_state[move] = ind
self.bars[move] = None
self.board.move_to_state = self.move_to_state
def test_vertical_win():
game = GameBoard()
game.insert_piece(0, 'X')
game.insert_piece(0, 'X')
game.insert_piece(0, 'X')
assert game.winner is None
game.insert_piece(0, 'X')
assert game.winner == 'X'
def test_horizontal_win():
game = GameBoard()
game.insert_piece(0, 'X')
game.insert_piece(1, 'X')
game.insert_piece(2, 'X')
assert game.winner is None
game.insert_piece(3, 'X')
assert game.winner == 'X'
def reset(self):
size = self.width
self.board = GameBoard(size, size, self.playerA, self.playerB,
self.depth, self.useDecisionTree,
self.dynamicDepth)
self.board.move_to_state = self.move_to_state
return self.board.board_state
def __init__(self, player_1, player_2):
self.logger = get_logger()
self.logger.info("Starting game...")
# Players
self.player_1 = player_1
self.player_2 = player_2
# Boards
self.logger.info("Creating boards...")
self.board_1 = GameBoard(player=self.player_1,
color=self.PLAYER_1_COLOR)
self.board_2 = GameBoard(player=self.player_2,
color=self.PLAYER_2_COLOR)
# Set the opponents
self.logger.info("Assingning opponents...")
self.player_1.set_opponent_board(self.board_2)
self.player_2.set_opponent_board(self.board_1)
self.logger.info('Game started. Start placing ships!')
self.status = self.GAME_STARTED
def _gtest(width, height):
"""A small driver to make sure that the board works. It's not
safe to use this test function in production, because it uses
input()."""
print("Running _gtest... ")
board = GameBoard(width, height)
board.turn = 1
board.scores = [0, 0]
gui = GameGUI(board)
def _newgame(self):
self.board = GameBoard(self.board.width, self.board.height)
self.board.turn = 1
self.board.scores = [0, 0]
for square in self.squares:
self.cv.itemconfig(self.squares[square], fill='lightyellow')
for bar in self.bars:
self.cv.itemconfig(self.bars[bar], fill='lightgray')
self.cv.update()
def __init__(self, armies, level=4, mode=DEFAULT_MODE, game_board=None):
self._armies = armies
if game_board is None:
self._game_board = GameBoard(
generate_base.generate_random_base_by_level(level=level))
else:
self._game_board = game_board
self._sim = Simulator(self._game_board)
self._mode = mode
self.calc_fitness()
def resetGame(self): #Reset Game (could probably do this more graciously)
self.ATT_CAPTURED = 0
self.DEF_CAPTURED = 0
self.att_reward_total = 0
self.def_reward_total = 0
self.captured = []
self.done = False
self._board = GameBoard()
self.action_space = []
self._turns = 0
self._state = Const.ATT_TURN
self.action_space = self.newMovements(Const.ATT_SIDE_MARK)
self.n_actions = len(self.action_space)
def __init__(self, board=None, nnet=None, mcts=None, batch_size=10):
"""Pass the baord class (defaults to GameBoard), the neural net instance
and the MCTS instance
"""
logging.basicConfig(filename="dojo.log", level=logging.DEBUG,
filemode='w')
self.board = board or GameBoard()
self.nnet = nnet or neural_net.NeuralNet()
self.tree = mcts or MCTS(3)
self.training_examples = []
self.batch_size = batch_size
def test_diagonal_win():
game = GameBoard()
game.insert_piece(0, 'X')
game.insert_piece(1, 'Y')
game.insert_piece(1, 'X')
game.insert_piece(2, 'Y')
game.insert_piece(2, 'Y')
game.insert_piece(2, 'X')
game.insert_piece(3, 'Y')
game.insert_piece(3, 'Y')
game.insert_piece(3, 'Y')
assert game.winner is None
game.insert_piece(3, 'X')
assert game.winner == 'X'
def __init__(self, level=4, mode=DEFAULT_MODE, game_board=None):
self._army, titles = generate_army.generate_army_by_level(
townhall_level=level)
if game_board is None:
self._game_board = GameBoard(
generate_base.generate_base_by_level(level))
else:
self._game_board = game_board
self._sim = Simulator(self._game_board)
self._fit = 0
self._mode = mode
# calculate fitness once when created
self.calc_fitness()
def _run(width,
height,
playerA,
playerB,
depth=3,
useDecisionTree=True,
dynamicDepth=False):
print "Running... "
board = GameBoard(width, height, playerA, playerB, depth, useDecisionTree,
dynamicDepth)
board.turn = 1
board.scores = [0, 0]
try:
gui = GameGUI(board)
print "Hello"
except Exception as e:
pass
def __init__(self):
"""Initializing the application."""
self.master = tk.Tk()
self.master.title("Five Wins Game")
self.master.geometry("800x600+50+50")
self.master.config(bg="dodger blue")
self.master.attributes("-alpha", 0.9)
self.menubar = tk.Menu(self.master)
file_menu = tk.Menu(self.menubar, tearoff=0)
file_menu.add_command(label="Quit", command=self.quit_application)
self.menubar.add_cascade(label="File", menu=file_menu)
self.main_window = MainWindow(self.master)
self.main_window.add(GameBoard(self.main_window), text="Game Board")
self.master.config(menu=self.menubar)
def evaluate(self, num_games=20, max_turn_time=.2):
"""This function will play two neural nets against
each other num_games times. It returs the ratio in
which the first player won
"""
logging.info("== Starting evaluation round ==")
p1_wins = 0
for i in range(num_games):
players = [(self.p1, MCTS(.5)), (self.p2, MCTS(.5))]
board = GameBoard()
shuffle(players)
turn = cycle(players)
game_start = time.time()
while not board.game_over():
player = next(turn)
start_turn = time.time()
while (time.time() - start_turn) < max_turn_time:
player[1].search(board, player[0])
pv = player[1].prob_vec(board)
choose = np.random.choice(len(pv), p=pv)
board.place_token(choose)
if player[0] is self.p1:
p1_wins += 1
logging.info(
f"player 1 wins game {i+1} ({p1_wins} total wins)")
else:
logging.info(
f"player 2 wins game {i+1} ({i-p1_wins+1} total wins)")
logging.debug(
f"game {i} took {time.time()-game_start:.1f}s, {board.total_moves} moves\n{board}"
)
if p1_wins / num_games >= 0.55: # end early if p1 has majority
return 1
elif (i - p1_wins + 1) / num_games >= 0.55:
return 0
return p1_wins / num_games
def __init__(self):
super(Tablut, self).__init__()
self.att_reward_total = 0 #Following variable are used in printStats()
self.def_reward_total = 0
self.ATT_WIN_COUNT = 0
self.DEF_WIN_COUNT = 0
self.DEF_CAPTURED = 0
self.ATT_CAPTURED = 0
self._turns = 0
self._state = Const.ATT_TURN #See rule #3 of game rules
self.done = False #Used to stop game
self.captured = [] #Keep track of captured pieces
self._board = GameBoard() #Instantiate board
self.action_space = self.newMovements(
Const.ATT_SIDE_MARK) #Holds all possible moves for either side
self.n_actions = len(
self.action_space) #Used for QLearningTable algorithm
def _runStats(width,
height,
playerA,
playerB,
depth=3,
useDecisionTree=True,
dynamicDepth=False):
line = "%d, %d, %s, %s, %d, %d, %d\n" % (
width, height, playerA, playerB, depth, useDecisionTree, dynamicDepth)
writeToStats(line, useDecisionTree)
start = time.clock()
board = GameBoard(width, height, playerA, playerB, depth, useDecisionTree,
dynamicDepth)
board.turn = 1
board.scores = [0, 0]
try:
gui = GameGUI(board)
except Exception as e:
pass
end = time.clock()
line = "%f\n\n" % (end - start)
writeToStats(line, useDecisionTree)
def run_simulation():
print 'Game Start'
game = GameBoard()
game.insert_piece(0,'X')
print game
print '#'* 10, 'winner: {}'.format(game.winner), '#'* 10
game.insert_piece(1, 'Y')
print game
print '#'* 10, 'winner: {}'.format(game.winner), '#'* 10
game.insert_piece(0,'X')
print game
print '#'* 10, 'winner: {}'.format(game.winner), '#'* 10
game.insert_piece(2, 'Y')
print game
print '#'* 10, 'winner: {}'.format(game.winner), '#'* 10
game.insert_piece(0,'X')
print game
print '#'* 10, 'winner: {}'.format(game.winner), '#'* 10
game.insert_piece(2, 'Y')
print game
print '#'* 10, 'winner: {}'.format(game.winner), '#'* 10
game.insert_piece(0,'X')
print game
print '#'* 10, 'winner: {}'.format(game.winner), '#'* 10
def setup_game_board(self):
game_board = GameBoard(self)
game_board.setup(self.ui.game_board)
return game_board
from board import GameBoard
from players import Human_Player, AI_Player
import time
players = []
size = 11
depth = 2
Reverse = False
for i in range(len(sys.argv)):
if sys.argv[i] == ‘-l’
Reverse = True
if sys.argv[i] == ‘-n’
size = int(sys.argv[i+1])
end
board = GameBoard(size)
if not Reverse:
players.append(Human_Player("human", board, 0, depth))
players.append(AI_Player("COM", board, 1, depth))
else:
players.append(Human_Player("COM", board, 0, depth))
players.append(AI_Player("human", board, 1, depth))
playing = True
while playing:
# print "\nMATCH: %s vs %s." % (players[0].get_name(), players[1].get_name())
print board
moves = 0
current_player_id = 0
active_turn = True
def __init__(self, board=None, pipe=None, mode=None):
global ori_board
if board is None:
self.game_board = GameBoard()
else:
self.game_board = board
self.s = pipe
self.turn = 1
self.win = tk.Tk()
###
if pipe is None:
self.win.title("Surakarta")
else:
self.win.title(self_user_name)
###
self.buffer = []
ori_board = cv2.imread('resources/pictures/board.jpeg')
ori_board = ori_board[..., ::-1]
ori_board = cv2.resize(ori_board, (600, 600),
interpolation=cv2.INTER_NEAREST)
ori_board = ImageTk.PhotoImage(Image.fromarray(ori_board))
self.board_frame = tk.Frame(self.win)
self.control_panel = tk.Frame(self.win,
bg='WHITE',
bd=0,
height=600,
width=200)
self.display_canvas = tk.Canvas(self.board_frame,
bg='WHITE',
bd=0,
heigh=600,
width=600)
self.display_canvas.create_image(0, 0, anchor='nw', image=ori_board)
self.r = 15
self.a = None
self.b = None
self.x = None
self.y = None
self.p = None
self.history = []
self.mode = mode
self.display_posi = []
self.my_turn_flag = None
for i in range(15):
line_display_posi = [] # 初始化 显示位置矩阵
for j in range(15):
x = 39.2 * j + 25
y = 39.2 * i + 25
line_display_posi.append(Position(x, y))
self.display_posi.append(line_display_posi)
if self.s is not None:
while self.my_turn_flag is None:
try:
print('try receiving1')
info = self.receive()
print(info)
info = info.split('.')
if info[1] == 'first':
self.my_turn_flag = True
t = Thread(target=self.receive_position)
t.start()
elif info[1] == 'second':
self.my_turn_flag = False
t = Thread(target=self.receive_position)
t.start()
except IndexError:
pass
def test_insert_piece_failure():
# ensure incorrectly inserting piece results in failure return
game = GameBoard()
assert game.insert_piece('test', 'X') is False
def test_insert_piece_success():
# ensure correctly inserting piece results in successful return
game = GameBoard()
assert game.insert_piece(0, 'X') is True
def test_good_string_entry():
# ensure board state changes upon correct string entry
game = GameBoard()
empty_board = str(game)
game.insert_piece('0', 'X')
assert str(game) != empty_board
def test_bad_string_entry():
# ensure board state remains unchanged upon bad string entry
game = GameBoard()
empty_board = str(game)
game.insert_piece('test', 'X')
assert str(game) == empty_board
def test_bad_int_entry():
# ensure board state remains unchanged upon bad int entry
game = GameBoard()
empty_board = str(game)
game.insert_piece(12315, 'X')
assert str(game) == empty_board
from board import GameBoard g = GameBoard(3) g[3] = 'X' g[4] = 'O' g['A3'] = 'X' g['C3'] = 'X' print(g._matrix) print(g)
print >> f, name1
print >> f, name2
def run_round(cmd1, cmd2, board, name1="Contestant 1", name2="Contestant 2", verbose=False, interactive=False, ansi=False, ruby_vis=None, js_vis=None, **kwargs):
delay = 1.0/FPS
try:
p1 = Player(cmd1, name1)
except Exception, e:
raise PlayerFailedException(name1, "Couldn't start process: "+str(e))
try:
p2 = Player(cmd2, name2)
except Exception, e:
raise PlayerFailedException(name2, "Couldn't start process: "+str(e))
gameboard = GameBoard(board)
if js_vis:
print >> js_vis, "+OK"
print >> js_vis, gameboard.width
print >> js_vis, gameboard.height
for line in gameboard.board:
print >> js_vis, ''.join(line).translate(P1BOARD)
print >> js_vis, name1
print >> js_vis, name2
result = None
try:
while True:
if verbose:
print_board(gameboard, name1, name2, ansi)
# main file for user interaction
from board import GameBoard
from settings import DOWN_MOVE, UP_MOVE, LEFT_MOVE, RIGHT_MOVE
game_board = GameBoard()
game_board.print_board()
while game_board.check_valid_move_remaining(
) and not game_board.check_win_condition():
user_move = input(
f"Enter move ({LEFT_MOVE}/{DOWN_MOVE}/{UP_MOVE}/{RIGHT_MOVE}) : ")
while not game_board.check_valid(user_move):
user_move = input(
f"Move invalid. Enter new move ({LEFT_MOVE}/{DOWN_MOVE}/{UP_MOVE}/{RIGHT_MOVE}) : "
)
game_board.move(user_move)
game_board.print_board()
if game_board.check_win_condition():
print("congratulations you Won!")
else:
print("No Moves Left.")
