def place_types(self):
"""
Places available types for each team in the teams respective half of the board
:return: tuple of list of places with fixed position and a list of pieces with random position
"""
known_place = []
# place flags at last row
for team in (0, 1):
flag_pos_list = [(i, j) for i in range(0 + team * 4, 1 + team * 4)
for j in range(5)]
index = np.random.choice(range(len(flag_pos_list)),
len(flag_pos_list),
replace=False)
flag_pos = flag_pos_list[index[0]]
known_place.append(pieces.Piece(0, team, flag_pos))
setup_pos = [(i, j) for i in range(0 + team * 3, 2 + team * 3)
for j in range(5)]
setup_pos.remove(flag_pos)
index = np.random.choice(range(len(setup_pos)),
len(setup_pos),
replace=False)
for i, piece_type in enumerate(self.types_available):
known_place.append(
pieces.Piece(piece_type, team, setup_pos[index[i]]))
random_place = [] # random_place is across whole board
return known_place, random_place
def draw_random_setup(types_available, team, game_dim):
"""
Draw a random setup from the set of types types_available after placing the flag
somewhere in the last row of the board of the side of 'team', or behind the obstacle.
:param types_available: list of types to draw from, integers
:param team: boolean, 1 or 0 depending on the team
:return: the setup, in numpy array form
"""
nr_pieces = len(types_available) - 1
types_available = [type_ for type_ in types_available if not type_ == 0]
if game_dim == 5:
row_offset = 2
elif game_dim == 7:
row_offset = 3
else:
row_offset = 4
setup_agent = np.empty((row_offset, game_dim), dtype=object)
if team == 0:
flag_positions = [(game_dim - 1, j) for j in range(game_dim)]
flag_choice = np.random.choice(range(len(flag_positions)), 1)[0]
flag_pos = game_dim - 1 - flag_positions[flag_choice][
0], game_dim - 1 - flag_positions[flag_choice][1]
setup_agent[flag_pos] = pieces.Piece(0, 0, flag_positions[flag_choice])
types_draw = np.random.choice(types_available,
nr_pieces,
replace=False)
positions_agent_0 = [(i, j)
for i in range(game_dim - row_offset, game_dim)
for j in range(game_dim)]
positions_agent_0.remove(flag_positions[flag_choice])
for idx in range(nr_pieces):
pos = positions_agent_0[idx]
setup_agent[(game_dim - 1 - pos[0], game_dim - 1 -
pos[1])] = pieces.Piece(types_draw[idx], 0, pos)
elif team == 1:
flag_positions = [(0, j) for j in range(game_dim)]
flag_choice = np.random.choice(range(len(flag_positions)), 1)[0]
setup_agent[flag_positions[flag_choice]] = pieces.Piece(
0, 1, flag_positions[flag_choice])
types_draw = np.random.choice(types_available,
nr_pieces,
replace=False)
positions_agent_1 = [(i, j) for i in range(row_offset)
for j in range(game_dim)]
positions_agent_1.remove(flag_positions[flag_choice])
for idx in range(nr_pieces):
pos = positions_agent_1[idx]
setup_agent[pos] = pieces.Piece(types_draw[idx], 1, pos)
return setup_agent
def main():
white_pawn = pieces.Piece("pawn", "white", (0, 2), moves.move_pawn)
white_pieces = [white_pawn]
black_pawn = pieces.Piece("pawn", "black", (1, 2), moves.move_pawn)
black_pieces = [black_pawn]
chess_board = Board(white_pieces, black_pieces)
chess_board.print_board()
print()
white_pawn.make_move(chess_board)
chess_board.print_board()
print()
black_pawn.make_move(chess_board)
chess_board.print_board()
def __init__(self):
self.board = []
self.w_player = player.Player("white")
self.b_player = player.Player("black")
self.turn = "white"
self.empty = pieces.Piece(-1, -1, "empty")
self.init_board()
def __init__(self, width, height, record):
self.width = width
self.height = height
self.start_pos = [height - 2, round(width / 2) - 1]
self.grid = [[0 for i in range(width)] for j in range(height)]
if not config.is_simulation:
self.BLOCK_LIST = [
FilledSquare(config.block_width, config.block_height,
COLOR_ARRAY[0]),
FilledSquare(config.block_width, config.block_height,
COLOR_ARRAY[1]),
FilledSquare(config.block_width, config.block_height,
COLOR_ARRAY[2]),
FilledSquare(config.block_width, config.block_height,
COLOR_ARRAY[3]),
FilledSquare(config.block_width, config.block_height,
COLOR_ARRAY[4]),
FilledSquare(config.block_width, config.block_height,
COLOR_ARRAY[5]),
FilledSquare(config.block_width, config.block_height,
COLOR_ARRAY[6]),
FilledSquare(config.block_width, config.block_height,
COLOR_ARRAY[7])
]
self.objectGrid = [[self.BLOCK_LIST[0] for i in range(width)]
for j in range(height)]
self.score = 0
self.record = record
self.list_form_idx = 0
self.curr_move_list = []
self.curr_piece = pieces.Piece(self.grid, self.start_pos,
self.getNextForm())
self.updateGrid()
def test_scan(self):
# Define position of pawn
pos = [12, 1]
# Generate empty chess board
test_board = board
test_board.grid = []
for i in range(16):
test_board.grid.append([])
for j in range(16):
test_board.grid[i].append(
Square(False, "b", pieces.Piece("none", "none"), i, j))
standard_moves = [[pos[0] - 1, pos[1]]]
other_moves = [[pos[0] - 1, pos[1]], [pos[0] - 2, pos[1]]]
test_board.grid[pos[0]][pos[1]].piece = pieces.Pawn("W", "Pawn")
test_board.grid[pos[0]][pos[1]].piece.row = pos[0]
test_board.grid[pos[0]][pos[1]].piece.col = pos[1]
#test_board.grid[pos[0]][pos[1]].piece.firstMove = True
found_moves = test_board.grid[pos[0]][pos[1]].piece.scan()
#print(found_moves[0].row, ", ", found_moves[0].col)
assert (pos[0] == found_moves[0].row + 1)
assert (pos[1] == found_moves[0].col)
def test_scan(self):
# King position
b = board
b.grid = []
for i in range(16):
b.grid[i].append(
Square(False, "b", pieces.Piece("none", "none"), i, j))
for j in range(16):
b.grid[i].append(
Square(False, "b", pieces.Piece("none", "none"), i, j))
#king moves
king_moves = [[0, 1], [0, -1], [1, 0], [-1, 0], [-1, 1], [1, -1],
[1, 1], [-1, -1]]
# Create the king w/ all possible moves
b.Grid(3, 3).piece = pieces.King(False, "King")
b.Grid(3, 3).piece.row = 3
b.Grid(3, 3).piece.col = 3
# relative moves
possible_moves = []
for i in range(8):
possible_moves.append([3, 3])
possible_moves[i][0] += king_moves[i][0]
possible_moves[i][1] += king_moves[i][1]
# fetch movies
availMoves = b.Grid(3, 3).piece.scan()
given_moves = []
for move in availMoves:
given_moves.append([move.row, move.col])
A = set(map(tuple, possible_moves))
B = set(map(tuple, given_moves))
self.assertTrue(A.issubset(B))
self.assertTrue(B.issubset(A))
print("F**k")
def test_init():
#setup
piece = pieces.Piece("pawn", "white", (0, 0), None)
white_pieces = [piece]
black_pieces = []
#invoke
chess_board = board.Board(white_pieces, black_pieces)
#analyze
assert chess_board
def lvl20(): # Level 20 -> 8 moves for perfect score
board = [
".",
"=",
"=",
".",
"t",
".",
".",
".",
"P",
"=",
"=",
"p",
"T",
".",
".",
".",
]
pcs = [pieces.Piece("p", 2, 3, 2, 0), pieces.Piece("t", 1, 0, 3, 0)]
return (board, pcs)
def lvl7():
board = [
"T",
".",
"=",
"=",
"P",
".",
"t",
"p",
".",
"=",
"=",
"=",
".",
"=",
".",
"=",
]
pcs = [pieces.Piece("p", 1, 3, 1, 0), pieces.Piece("t", 1, 2, 0, 0)]
return (board, pcs)
def lvl5():
board = [
"=",
"t",
"=",
"P",
"=",
"p",
"T",
".",
"=",
".",
".",
"=",
".",
"=",
"=",
".",
]
pcs = [pieces.Piece("p", 1, 1, 0, 3), pieces.Piece("t", 0, 1, 1, 2)]
return (board, pcs)
def lvl14():
board = [
"T",
"=",
"=",
"=",
".",
"t",
"=",
"=",
".",
".",
".",
"=",
"p",
"=",
".",
"P",
]
pcs = [pieces.Piece("p", 3, 0, 3, 3), pieces.Piece("t", 1, 1, 0, 0)]
return (board, pcs)
def lvl11():
board = [
"=",
"P",
"=",
"T",
".",
"t",
".",
".",
".",
".",
"=",
"p",
"=",
".",
"=",
"=",
]
pcs = [pieces.Piece("p", 2, 3, 0, 1), pieces.Piece("t", 1, 1, 0, 3)]
return (board, pcs)
def lvl25():
board = [
".",
"t",
"p",
".",
".",
".",
"=",
"=",
".",
".",
".",
".",
"P",
"T",
".",
"=",
]
pcs = [pieces.Piece("p", 0, 2, 3, 0), pieces.Piece("t", 0, 1, 3, 1)]
return (board, pcs)
def lvl3():
board = [
".",
".",
".",
"P",
".",
".",
"T",
"=",
"p",
".",
".",
"=",
".",
".",
".",
"t",
]
pcs = [pieces.Piece("p", 2, 0, 0, 3), pieces.Piece("t", 3, 3, 1, 2)]
return (board, pcs)
def lvl22(): # Level 22 -> 9 moves for perfect score
board = [
".",
"p",
".",
"=",
"=",
"t",
".",
"T",
"=",
".",
"=",
"P",
"=",
".",
"=",
"=",
]
pcs = [pieces.Piece("p", 0, 1, 2, 3), pieces.Piece("t", 1, 1, 1, 3)]
return (board, pcs)
def lvl21(): # Level 21 -> 9 moves for perfect score
board = [
"T",
".",
"p",
"t",
"=",
".",
"=",
"P",
"=",
"=",
".",
".",
".",
".",
"=",
"=",
]
pcs = [pieces.Piece("p", 0, 2, 1, 3), pieces.Piece("t", 0, 3, 0, 0)]
return (board, pcs)
def lvl15():
board = [
"t",
".",
".",
".",
".",
".",
".",
"p",
"P",
".",
".",
".",
".",
"=",
"=",
"T",
]
pcs = [pieces.Piece("p", 1, 3, 2, 0), pieces.Piece("t", 0, 0, 3, 3)]
return (board, pcs)
def lvl19(): # Level 19 -> 8 moves for perfect score
board = [
".",
"T",
"=",
".",
"p",
".",
"P",
".",
".",
".",
".",
".",
"=",
".",
"t",
".",
]
pcs = [pieces.Piece("p", 1, 0, 1, 2), pieces.Piece("t", 3, 2, 0, 1)]
return (board, pcs)
def lvl18():
board = [
".",
".",
".",
".",
".",
".",
"t",
"T",
".",
".",
".",
"=",
"=",
".",
"P",
"p",
]
pcs = [pieces.Piece("p", 3, 3, 3, 2), pieces.Piece("t", 1, 2, 1, 3)]
return (board, pcs)
def lvl4():
board = [
"P",
".",
"p",
"=",
"=",
"=",
".",
"=",
"=",
".",
".",
".",
"t",
".",
"T",
"=",
]
pcs = [pieces.Piece("p", 0, 2, 0, 0), pieces.Piece("t", 3, 0, 3, 2)]
return (board, pcs)
def test_move_white_pawn(monkeypatch):
#setup
pawn = pieces.Piece("pawn", "white", (1, 0), moves.move_pawn)
monkeypatch.setattr("sys.stdin", io.StringIO("0 0"))
white_pieces = [pawn]
chess_board = board.Board(white_pieces, [])
expected = (0, 0)
#invoke
actual = moves.move_pawn(pawn, chess_board)
#analyze
assert expected == actual
def test_move_knight(monkeypatch):
#setup
monkeypatch.setattr("sys.stdin", io.StringIO("1 3"))
knight = pieces.Piece("knight", "black", (1, 0), moves.move_piece)
white_pieces = [knight]
chess_board = board.Board(white_pieces, [])
expected = (3, 1)
#invoke
actual = moves.move_piece(knight, chess_board)
#analyze
assert expected == actual
def test_queen_vertical(monkeypatch):
#setup
queen = pieces.Piece("queen", "white", (1, 0), moves.move_queen)
monkeypatch.setattr("sys.stdin", io.StringIO("0 4"))
white_pieces = [queen]
chess_board = board.Board(white_pieces, [])
expected = (4, 0)
#invoke
actual = moves.move_queen(queen, chess_board)
#analyze
assert expected == actual
def test_choose_piece(monkeypatch):
#setup
monkeypatch.setattr("sys.stdin", io.StringIO("0 0"))
piece = pieces.Piece("pawn", "white", (0, 0), moves.move_pawn)
white_pieces = [piece]
black_pieces = []
chess_board = board.Board(white_pieces, black_pieces)
#invoke
result = player.choose_piece(chess_board)
#analyze
assert piece == result
def __init__(self, surface, size):
self.surface = surface
self.size = size
self.game_over = False
self.board = board.Board(size)
self.pieces = []
# the code below is for creating pieces, was most pythonic way of doing it I could think of, still somewhat repetitive
piece_sprite_dir = Path('piece_sprites/orig')
for p in piece_sprite_dir.iterdir():
p = str(p)
coords = []
img_file = ''
if 'white_rook' in p:
coords = ['a1', 'h1']
img_file = p
if 'white_knight' in p:
coords = ['b1', 'g1']
img_file = p
if 'white_bishop' in p:
coords = ['c1', 'f1']
img_file = p
if 'white_queen' in p:
coords = ['d1']
img_file = p
if 'white_king' in p:
coords = ['e1']
img_file = p
if 'white_pawn' in p:
coords = ['a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2', 'h2']
img_file = p
if 'black_rook' in p:
coords = ['a8', 'h8']
img_file = p
if 'black_knight' in p:
coords = ['b8', 'g8']
img_file = p
if 'black_bishop' in p:
coords = ['c8', 'f8']
img_file = p
if 'black_queen' in p:
coords = ['d8']
img_file = p
if 'black_king' in p:
coords = ['e8']
img_file = p
if 'black_pawn' in p:
coords = ['a7', 'b7', 'c7', 'd7', 'e7', 'f7', 'g7', 'h7']
img_file = p
for c in coords:
self.pieces.append(pieces.Piece(c, img_file, self.board.locations, board.Square.size))
'''
def generate_pieces_objects(self):
logging.info("Initializing... peer lists")
hashes = self.torrent_dict['info']['pieces']
piece_length = self.torrent_dict['info']['piece length']
if 'files' in self.torrent_dict['info']:
files = self.torrent_dict['info']['files']
totalLength = sum([file['length'] for file in files])
self.num_of_pieces = int(math.ceil(float(totalLength) / piece_length))
else:
totalLength = self.torrent_dict['info']['length']
self.num_of_pieces = int(math.ceil(float(totalLength) / piece_length))
counter = totalLength
self.total_torrent_length = totalLength
for i in range(self.num_of_pieces):
if i == self.num_of_pieces - 1:
self.pieces.append(pieces.Piece(i, counter, hashes[0:20]))
else:
self.pieces.append(pieces.Piece(i, piece_length, hashes[0:20]))
counter -= piece_length
hashes = hashes[20:]
self.current_piece = self.pieces.popleft()
def generatePieces(self):
logging.info("Initalizing... ")
pieceHashes = self.tracker['info']['pieces']
pieceLength = self.tracker['info']['piece length']
if 'files' in self.tracker['info']:
files = self.tracker['info']['files']
totalLength = sum([file['length'] for file in files])
self.numPieces = int(math.ceil(float(totalLength) / pieceLength))
else:
totalLength = self.tracker['info']['length']
self.numPieces = int(math.ceil(float(totalLength) / pieceLength))
counter = totalLength
self.totalLength = totalLength
for i in range(self.numPieces):
if i == self.numPieces - 1:
self.pieces.append(pieces.Piece(i, counter, pieceHashes[0:20]))
else:
self.pieces.append(
pieces.Piece(i, pieceLength, pieceHashes[0:20]))
counter -= pieceLength
pieceHashes = pieceHashes[20:]
self.curPiece = self.pieces.popleft()
def testScan(self):
# Generate empty chess board
b = board
b.grid = []
for i in range(16):
b.grid.append([])
for j in range(16):
b.grid[i].append(
Square(False, "b", pieces.Piece("none", "none"), i, j))
# Create a rook at location 3,3
# This should allow the rook all of its possible moves
b.Grid(0, 0).piece = pieces.Rook(False, "Rook")
b.Grid(0, 0).piece.row = 0
b.Grid(0, 0).piece.col = 0
availMoves = b.Grid(0, 0).piece.scan()
self.assertTrue(availMoves == [] or availMoves != [])
def __init__(self, agent0, agent1, game_size="big"):
self.game_size = game_size
self.agents = (agent0, agent1)
if game_size == "small":
self.types_available = np.array([0, 1] + [2]*3 + [3]*2 + [10] + [11]*2)
obstacle_positions = [(2, 2)]
self.game_dim = 5
elif game_size == "medium":
obstacle_positions = [(3, 1), (3, 5)]
self.types_available = np.array([0, 1] + [2]*5 + [3]*3 + [4]*3 + [5]*2 + [6] + [10] + [11]*4)
self.game_dim = 7
else:
obstacle_positions = [(4, 2), (5, 2), (4, 3), (5, 3), (4, 6), (5, 6), (4, 7), (5, 7)]
self.types_available = np.array([0, 1] + [2]*8 + [3]*5 + [4]*4 + [5]*4 + [6]*4 +
[7]*3 + [8]*2 + [9]*1 + [10] + [11]*6)
self.game_dim = 10
self.board = np.empty((self.game_dim, self.game_dim), dtype=object)
setup0, setup1 = agent0.setup, agent1.setup
for idx, piece in np.ndenumerate(setup0):
if piece is not None:
piece.hidden = False
self.board[piece.position] = piece
for idx, piece in np.ndenumerate(setup1):
if piece is not None:
piece.hidden = False
self.board[piece.position] = piece
for pos in obstacle_positions:
obs = pieces.Piece(99, 99, pos)
obs.hidden = False
self.board[pos] = obs
agent0.install_board(self.board, reset=True)
agent1.install_board(self.board, reset=True)
self.move_count = 1 # agent 1 starts
self.deadPieces = []
dead_piecesdict = dict()
for type_ in set(self.types_available):
dead_piecesdict[type_] = 0
self.deadPieces.append(dead_piecesdict)
self.deadPieces.append(copy.deepcopy(dead_piecesdict))
self.battleMatrix = helpers.get_battle_matrix()
