def test_draw_tiles_1(self):
# moving where one player has the dragon tile before
# and no one gets any new tiles
server = Server.reset_get_instance()
deck = Deck()
board = Board()
tile_1 = init_tile_1()
tile_3 = init_tile_3()
tile_4 = init_tile_4()
tile_5 = init_tile_5()
tile_6 = init_tile_6()
tile_7 = init_tile_7()
player_1 = SPlayer(1, True, (1, 0, 2))
player_2 = SPlayer(2, True, (6, 6, 0))
player_4 = SPlayer(4, True, (2, 5, 2))
player_1.add_hand(tile_3)
player_2.add_hand(tile_1)
player_4.add_hand(tile_4)
active_players = [player_1, player_2, player_4]
players_last_out = []
server.dragon_owner = player_1
deck.own_dragon = False
self.assertEqual(server.dragon_owner, player_1)
self.assertFalse(deck.has_dragon())
self.assertEqual(player_1.hand.get_num(), 1)
self.assertEqual(player_2.hand.get_num(), 1)
self.assertEqual(player_4.hand.get_num(), 1)
d, sa, so, b, res = server.play_a_turn(deck, copy(active_players),
copy(players_last_out), board,
tile_3)
self.assertEqual(d.get_num(), 0)
self.assertEqual(d.tiles, [])
self.assertEqual(sa, [player_2, player_4, player_1])
self.assertEqual(so, players_last_out)
self.assertEqual(player_1.get_location().into_tuple(), (1, 1, 2))
self.assertEqual(b.num_tiles, 1)
self.assertEqual(b.get_tile_by_loc(Tile_location((1, 1))), tile_3)
self.assertEqual(b.get_splayer_by_loc(Player_location((1, 1, 2))),
player_1)
self.assertFalse(res)
self.assertEqual(server.dragon_owner, player_1)
self.assertFalse(deck.has_dragon())
self.assertEqual(player_1.hand.get_num(), 0)
self.assertEqual(player_2.hand.get_num(), 1)
self.assertEqual(player_4.hand.get_num(), 1)
def __init__(self):
"""Erstellt ein neues Spielfeld für das aktuelle Spiel"""
self._board = Board.Board()
self._phaseOfPlayer1 = 1
self._phaseOfPlayer2 = 1
self._playerOnTurn = True
self._status = ""
self._previousClickedStone = None
self._player1stonesToSet = 9
self._player2stonesToSet = 9
self._numberOfTurnsWithoutMill = 0
def __init__(self, board_size, parent=None):
super(Game, self).__init__(parent)
self.setWindowTitle('2048')
self.board_size = board_size
self.board = Board.Board(self.board_size)
self.tiles = [[0] * self.board_size for i in range(self.board_size)]
self.setGeometry(
GetSystemMetrics(0) / 2 - 60 * self.board_size / 2,
GetSystemMetrics(1) / 2 - 60 * self.board_size / 2,
60 * self.board_size, 60 * self.board_size + 21)
self.centralwidget = QtWidgets.QWidget(self)
self.centralwidget.setObjectName("centralwidget")
self.setCentralWidget(self.centralwidget)
self.menubar = QtWidgets.QMenuBar(self)
self.menubar.setGeometry(QtCore.QRect(0, 0, 800, 21))
self.menubar.setObjectName("menubar")
self.menuGame = QtWidgets.QMenu(self.menubar)
self.menuGame.setObjectName("menuGame")
self.setMenuBar(self.menubar)
self.statusbar = QtWidgets.QStatusBar(self)
self.statusbar.setObjectName("statusbar")
self.setStatusBar(self.statusbar)
self.actionNew_Game = QtWidgets.QAction(self)
self.actionNew_Game.setObjectName("actionNew_Game")
self.actionSave_Game = QtWidgets.QAction(self)
self.actionSave_Game.setObjectName("actionSave_Game")
self.actionLoad_Game = QtWidgets.QAction(self)
self.actionLoad_Game.setObjectName("actionLoad_Game")
self.actionQuit = QtWidgets.QAction(self)
self.actionQuit.setObjectName("actionQuit")
self.menuGame.addAction(self.actionNew_Game)
self.menuGame.addAction(self.actionSave_Game)
self.menuGame.addAction(self.actionLoad_Game)
self.menuGame.addSeparator()
self.menuGame.addAction(self.actionQuit)
self.menubar.addAction(self.menuGame.menuAction())
self.actionNew_Game.triggered.connect(lambda: self.settings_game())
self.actionSave_Game.triggered.connect(lambda: self.save_game())
self.actionLoad_Game.triggered.connect(lambda: self.load_game())
self.actionQuit.triggered.connect(lambda: self.close())
self.retranslateUi(self)
QtCore.QMetaObject.connectSlotsByName(self)
for i in range(self.board_size):
for j in range(self.board_size):
label = QtWidgets.QLabel(
str(self.board.board_tiles[i][j].value), self)
label.setStyleSheet(
"text-align: center; border :1px solid ; font-size: 15px; background-color: {}"
.format(self.board.board_tiles[i][j].getColor()))
label.setAlignment(QtCore.Qt.AlignCenter)
label.setGeometry((j * 60), (i * 60) + 21, 60, 60)
self.tiles[i][j] = label
def next_LEVEL():
''' level increment '''
Config.ENEMYPUT = True
Config.CONSWALL = True
getch = Getch._Getch()
board = Board.Board()
bomber = Bomberman.Bomber()
for i in range(Config.LEVEL + 4):
Config.ENEMIES.append(Enemy.Enemy())
Config.ENEMIES[i].setposition(Config.ENEMYSET[i][0],
Config.ENEMYSET[i][1])
def main():
'''
INPUT: Takes no input.
OUTPUT: Plays a game of Connect Four, depending on user input.
'''
"""Human versus AI game. No code to write here!"""
k = int(input("Enter ply (level from 0 to 5): "))
px = "human"
po = Player("O", "LEFT", k)
b = Board(7, 6)
playGame(b, px, po)
def test_features():
board = Board(5)
moves = [(0, 0, 1), (0, 0, 0), (0, 1, 1), (1, 0, 0), (2, 2, 0), (2, 2, 1),
(3, 2, 0), (2, 3, 0), (2, 4, 1), (3, 3, 0), (2, 3, 1)]
for (x, y, d) in moves:
board.make_move(x, y, d, board.color_to_play)
f_planes = make_feature_planes_1(board, Color.Black)
board.show()
for i in range(9):
print(f_planes[:, :, i])
def __init__(self, filename):
self.filename = filename
parser = SGFParser(filename)
self.initial_stones = []
self.moves = []
self.black_rank = None
self.white_rank = None
self.result = None
self.board = None
self.komi = None
for property_name, property_data in parser:
if property_name == "SZ": # board size
self.board = Board(int(property_data))
elif property_name == "AB": # black initial stones
for vertex_str in property_data:
self.initial_stones.append(
(parse_vertex(vertex_str), Color.Black))
elif property_name == "AW": # white initial stones
for vertex_str in property_data:
self.initial_stones.append(
(parse_vertex(vertex_str), Color.White))
elif property_name == "B": # black plays
self.moves.append((parse_vertex(property_data), Color.Black))
elif property_name == "W": # white plays
self.moves.append((parse_vertex(property_data), Color.White))
elif property_name == "BR": # black rank
self.black_rank = property_data
elif property_name == "WR": # white rank
self.white_rank = property_data
elif property_name == "RE": # result
self.result = property_data
elif property_name == "KM": # komi
self.komi = property_data
if not self.board:
self.board = Board(19) # assume 19x19 if we didn't see a size
for (x, y), color in self.initial_stones:
self.board.play_stone(x, y, color)
self.moves_played = 0
def test_BoardMoveWinVertical(self):
#Arrange
myBoardSize = 3
myBoard = Board.Board(myBoardSize)
myBoard.takeTurn(0, 0, "X")
myBoard.takeTurn(1, 0, "X")
#Act
result = myBoard.makeMoveWin()
#Assert
self.assertEqual(result, [2, 0])
def test_BoardMoveWinHorizontal(self):
#Arrange
myBoardSize = 3
myBoard = Board.Board(myBoardSize)
myBoard.takeTurn(0, 0, "X")
myBoard.takeTurn(0, 1, "X")
#Act
result = myBoard.makeMoveWin()
#Assert
self.assertEqual(result, [0, 2])
def __init__(self,
episodes=200000,
n_threshold=10,
lr_constant=30000,
discount_factor=0.98):
self.board = Board.Board()
self.q_table = dict()
self.n_table = dict()
self.episodes = episodes
self.n_threshold = n_threshold
self.lr_constant = lr_constant
self.discount_factor = discount_factor
def _writeToBoard(self):
board = Board.Board()
for r in self.Sequence:
for c in self.Sequence:
for v in self.Sequence:
e = self.choices[(self.choices['vals'] == int(v))
& (self.choices['cols'] == int(c)) &
(self.choices['rows']
== int(r))]['choice'].tolist()
if value(e[0]) == 1.0:
board.setValue(int(r) - 1, int(c) - 1, v)
return board
def test_MoveLeftToRightUp(self):
#Arrage
myBoard = Board.Board(10,2)
expPlayerLoc = {0: 12,1: 0}
#Act
myBoard.makeMove(0,6)
myBoard.makeMove(0,6)
actPlayerLoc = myBoard.PlayerLoc
#Assert
self.assertEqual(expPlayerLoc,actPlayerLoc,"Player moving left to right then up is wrong")
def __init__(self, player1, player2):
self.player1 = player1
self.player2 = player2
self.board = Board()
self.player1.pieces = filter(
lambda x: isinstance(x, Piece) and x.color == 'white',
self.board.flatten())
self.player2.pieces = filter(
lambda x: isinstance(x, Piece) and x.color == 'black',
self.board.flatten())
self.player1.board = self.board
self.player2.board = self.board
def create_board(self):
settings = TkUtil.Settings.Data
columns = settings.get_int(BOARD, COLUMNS, Board.DEF_COLUMNS)
rows = settings.get_int(BOARD, ROWS, Board.DEF_ROWS)
maxColors = settings.get_int(BOARD, MAXCOLORS, Board.DEF_MAX_COLORS)
delay = settings.get_int(BOARD, DELAY, Board.DEF_DELAY)
self.board = Board.Board(self.master, self.zoom, self.shapeName,
self.set_status_text, self.scoreText, columns,
rows, maxColors, delay)
self.board.highScore = settings.get_int(BOARD, HIGHSCORE, 0)
self.board.update_score()
self.board.pack(fill=tk.BOTH, expand=True)
def __init__(self, players, size, screenSize):
self.board = Board.Board(size)
self.size = size
self.players = players
self.current = 0
self.pressedZone = None
self.multiBtn = Button.Button(screenSize - 3 * BUTTON_WIDTH, 0,
BUTTON_WIDTH, BANNER_HEIGHT,
BUTTON_COLOR, "1 v 1", CELL_COLOR)
self.arBtn = Button.Button(screenSize - 4.5 * BUTTON_WIDTH, 0,
1.2 * BUTTON_WIDTH, BANNER_HEIGHT,
BUTTON_COLOR, "1 v AI", CELL_COLOR)
def __init__(self, name, color):
self.name = name
if color in ["white", "black"]:
self.color = color
if self.color == "white":
self.o_color = "black"
else:
self.o_color = "white"
else:
print("invalid color, expected white/black")
self.board = Board(color)
print("create new agent; color: ", color, ",name: ", name)
def __init__(self):
pygame.init()
pygame.display.set_caption("2048 Game by ShubU")
self.score = "Score : "
self.board = Board()
self.gameDisplay = pygame.display.set_mode((800,600))
self.font = pygame.font.SysFont("monospace", 28)
self.clock = pygame.time.Clock()
self.over = False
self.doAI = False
self.prevMove = None
self.start()
def test_castling_queenside():
board = Board.Board()
# Kings are needed for check testing when calling valid_moves
wk = Piece.King([4, 0], "w")
bk = Piece.King([7, 7], "b")
board.add_piece(wk)
board.add_piece(bk)
wr = Piece.Rook([0, 0], "w")
board.add_piece(wr)
assert [2, 0] in wk.valid_moves(board)
def start_game():
board = Board.Board()
print(next_symbol('X'))
print("This is naughts & crosses AI")
choice = 'N'
while choice != 'X' and choice != 'O':
print("Please enter whether you would like to play as X or O:",
end=" ")
choice = input().upper()
play_game(board, choice)
def __init__(self, master):
self.board = Board.Board()
self.frameMain = tk.Frame(master, width=1920, height=1080, bd=1)
self.frameMain.pack(side=tk.LEFT)
self.canvasResult = tk.Canvas(self.frameMain, width=300, height=950)
self.canvasResult.pack(side=tk.LEFT, fill=tk.BOTH)
self.canvasBoard = tk.Canvas(self.frameMain, width=900, height=950)
self.canvasBoard.pack(side=tk.LEFT, fill=tk.BOTH)
self.controlFrame = tk.Frame(master, bd=2, relief=tk.RAISED)
self.controlFrame.pack(side=tk.RIGHT, fill=tk.BOTH)
self.tabControl = ttk.Notebook(self.controlFrame)
self.tab1 = ttk.Frame(self.tabControl)
self.tabControl.add(self.tab1, text='Control')
self.tab2 = ttk.Frame(self.tabControl)
self.tabControl.add(self.tab2, text='Settings')
self.tabControl.pack(expand=1, fill="both")
self.labelTop = tk.Label(self.tab1,
text="Select a Polyomino configuration")
self.labelTop.pack(side=tk.TOP)
self.tkvar = tk.StringVar(master)
self.choices = self.board.GetChoices()
self.tkvar.set(self.choices[0])
self.popupMenu = tk.OptionMenu(self.tab1, self.tkvar, *self.choices)
self.tkvar.trace('w', self.SetPolyomino)
self.popupMenu.pack(side=tk.TOP)
self.iterateButton = tk.Button(self.tab1,
text='Iterate',
command=self.Iterate)
self.iterateButton.pack(side=tk.BOTTOM)
#self.iterateButton = tk.Button(self.controlFrame, text='Results!', command=self.GenerateResults)
#self.iterateButton.pack(side=tk.BOTTOM)
self.slider = tk.Scale(self.tab1,
from_=0,
to=Board.MAX_MOVES,
orient=tk.VERTICAL,
resolution=1,
length=800,
sliderlength=20,
command=self.SetCurrentStep)
self.slider.pack(side=tk.BOTTOM)
# Settings Tab
self.axisButton = tk.Button(self.tab2,
text='Hide Axes',
command=self.ToggleShowAxes)
self.axisButton.pack(side=tk.TOP)
self.SetPolyomino()
def test_BoardSize(self):
#Arrange
expBoardSize = 10
#Act
myBoard = Board.Board(expBoardSize,2)
rowSize = len(myBoard.gameBoard)
colSize = len(myBoard.gameBoard[1])
#Assert
self.assertEqual(expBoardSize,rowSize,"Row Size not "+str(expBoardSize))
self.assertEqual(rowSize,colSize,"Row Size and Col Size not equal")
def test_openPoints(self):
test1 = Board()
test2 = [[i, j, k] for i in range(4) for j in range(4)
for k in range(4)]
self.assertEqual(test1.openPoints(), test2)
test1.move(1, [0, 0, 0])
test1.move(2, [0, 0, 1])
test1.move(2, [1, 0, 2])
test2 = test2[2:18] + test2[19:]
self.assertEqual(test1.openPoints(), test2)
def __init__(self, root):
a = 60
b = 80
l = 50
self.choose = False
self.choosed_chess = False
self.xing_qi = True
self.root = root
self.Board = Board.Board(root, a, b, l)
self.front_display()
self.Board.canvas.bind('<Button-1>', self.move)
def brute_force_algorithm(self):
matches = {}
permutations = itertools.permutations(range(len(self._picture.pieces)))
for indexes in permutations:
self.board = Board.Board(self._picture)
indexes = list(indexes)
for k in range(self.board.n):
for l in range(self.board.m):
self.board.add_piece_index_in_position((k, l), indexes[0])
indexes.pop(0)
matches[self.board.get_total_cost()] = self.board
return matches
def new_game(self): # новая игра
self.board = Board()
self.board.update_draw_array()
m.draw_buttons()
self.board.Logger.WriteGameInfo(self.board.draw_array)
self.l.config(text="White's turn")
self.l.pack()
self.counter1.config(text='white: ' + str(self.board.white))
self.counter2.config(text='black: ' + str(self.board.black))
self.counter1.pack()
self.counter2.pack()
def test_feature_planes():
board = Board(5)
moves = [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]
play_color = Color.Black
for x, y in moves:
board.show()
feature_planes = make_feature_planes(board, play_color)
move_arr = make_move_arr(x, y)
show_feature_planes_and_move(feature_planes, move_arr)
print
board.play_stone(x, y, play_color)
play_color = flipped_color[play_color]
def test_BoardSize(self):
#Arrange
myBoardSize = 3
#Act
myBoard = Board.Board(myBoardSize)
myBoardData = myBoard.gameBoard[0]
myBoardLength = len(myBoardData)
#Assert
self.assertEqual(myBoardLength, myBoardSize)
self.assertEqual(myBoardData, ['_'] * 3)
def start(self):
"""
Start the game, Initialize the board and start.
"""
image = self.pick_random_picture()
grid = self.grid
if os.path.exists(image):
self.board = Board.Board(parent=self.parent,
image=image,
grid=grid,
win=self.win)
self.board.pack()
def test_BoardMoveWinDiagonalLeft(self):
#Arrange
myBoardSize = 3
myBoard = Board.Board(myBoardSize)
myBoard.takeTurn(0, 2, "X")
myBoard.takeTurn(1, 1, "X")
#Act
result = myBoard.makeMoveWin()
#Assert
self.assertEqual(result, [2, 0])
def main():
this_board = Board()
for i in range(5):
this_board.print_board()
moves = this_board.get_possible_next_moves()
print("----current player {}-------".format(this_board.player_turn))
print("-----available moves-------")
print(moves)
print(this_board.current_state())
this_move = random.choice(moves)
print("step {} pick {}".format(i, this_move))
this_board.make_move(this_move)
