def getMove(self, currentState):
# Setup
if self.isFirstTurn:
self.firstTurn(currentState)
# Concede game if taking too long
elif self.turnsPlayed > STALEMATE_TURNS:
workers = getAntList(currentState, currentState.whoseTurn,
(WORKER, ))
for worker in workers:
if not worker.hasMoved:
return Move(
MOVE_ANT,
createPathToward(currentState, worker.coords,
self.enemyHill.coords,
UNIT_STATS[WORKER][MOVEMENT]))
return Move(END)
# Look ahead to each possible state and find the one with the lowest output
bestH = 100000000
bestMove = None
moves = listAllLegalMoves(currentState)
for move in moves:
features = self.extractFeatures(getNextState(currentState, move))
netH = self.network.eval(self.normalizeFeatures(features))[0]
if netH < bestH:
bestH = netH
bestMove = move
if ONLINE_LEARNING:
h = self.heuristicStepsToGoal(features)
self.network.adjustWeights((normalizeHeuristic(h), ))
if bestMove.moveType == END:
self.turnsPlayed += 1
return bestMove
def explore(motor, buzzer): ''' Function will initialize and execute a new "move" Args: motor(motor_obj): used to control robot movement buzzer(buzzer_obj): signals start of exploration ''' # Test output print "Exploring (moving to a new location) ..." # Beep to indicate begining of explore step buzzer.play(5) # Initialize new move object move = Move() # Vector of movement used move.get_move_vector() # Break down movement vector into motion primitives that robot can execute move.get_motion_plan() # Debug print move fields print(str(move)) # Execute motion from given move primitives for (direction, amount) in move.primitives: print "Moving " + str(direction) + " " + str(amount) motor.move_bot(direction, distance=amount)
def get_pawn_sq_moves(self, sq, color):
moves = []
attacks = Bitboard.pawn_attacks[color][sq]
while attacks:
end_sq = Bitboard.lsb(attacks)
# valid capture
if (abs(Bitboard.get_file(sq) - Bitboard.get_file(end_sq)) == 1
and self.get_square_piece(end_sq) != Piece.NONE
and self.get_square_color(end_sq) != color):
# promotion
if Bitboard.get_rank(end_sq) == 1 or Bitboard.get_rank(
end_sq) == 5:
moves.append(Move(sq, end_sq, Flags.KnightPromCap))
moves.append(Move(sq, end_sq, Flags.BishopPromCap))
moves.append(Move(sq, end_sq, Flags.RookPromCap))
moves.append(Move(sq, end_sq, Flags.QueenPromCap))
else:
moves.append(Move(sq, end_sq, Flags.Capture))
attacks = Bitboard.pop_lsb(attacks)
end_sq = sq + 5 if color == Color.White else sq - 5
if (Bitboard.is_valid_square(end_sq)
and self.get_square_piece(end_sq) == Piece.NONE):
if Bitboard.get_rank(end_sq) == 1 or Bitboard.get_rank(
end_sq) == 5:
moves.append(Move(sq, end_sq, Flags.KnightProm))
moves.append(Move(sq, end_sq, Flags.BishopProm))
moves.append(Move(sq, end_sq, Flags.RookProm))
moves.append(Move(sq, end_sq, Flags.QueenProm))
else:
moves.append(Move(sq, end_sq, Flags.Quiet))
return moves
def test_get_bar_moves(test_bar):
moves = [Move(0, 26, 24), Move(0, 26, 23)]
test_bar.dice.set_dice(1, 2)
assert test_bar.get_bar_moves() == moves
test_bar.dice.set_dice(6, 6)
assert test_bar.get_bar_moves() == []
def run(self):
self.connect()
while True:
turn = "white"
self.start_game()
while True:
if turn == self.color:
move = self.find_best_move()
print(
Move.write_move(move, turn == "black",
self.innerstate))
else:
movestring = input()
if movestring == "done":
break
else:
move = Move.parse_move(movestring, turn == "black",
self.innerstate)
if not self.innerstate.checkIfLegal(move):
print("uups") #error
self.innerstate.applyMove(move)
self.innerstate.rotateBoard()
turn = self.invert_turn(turn)
if self.innerstate.game_is_finished() != None:
self.end_game()
break
def test_scan_no_capture(self):
b = Board("""
1 W
.....
.....
..Qp.
.....
.....
.....
""")
startpos = (3,4)
# not capturing right
movelist = []
b.scan(movelist, startpos, 1, 0, no_capture=True)
expected = []
self.assertEqual(expected, movelist)
# to the top
movelist = []
b.scan(movelist, startpos, 0, 1, no_capture=True)
expected = []
expected.append(Move.from_string("c4-c5"))
expected.append(Move.from_string("c4-c6"))
self.assertEqual(expected, movelist)
def __init__(self, btn_list, init_table_chess, btn_miss_list):
self.session_player = constant.SESSION_PLAYER_1
self.btn_list = btn_list
self.init_table_chess = init_table_chess
self.btn_miss_list = btn_miss_list
self.lbl_miss = []
self.init_miss_chess = [["" for i in range(5)] for j in range(2)]
self.flag_click = 0
self.old_button = 0
self.flg_play = 'PvM'
self.radio_list = []
self.img_white = ImageTk.PhotoImage(Image.open("white.jpg"))
self.img_black = ImageTk.PhotoImage(Image.open("black.jpg"))
self.img_start = ImageTk.PhotoImage(Image.open("start.png"))
self.img_reset = ImageTk.PhotoImage(Image.open("reset.png"))
self.img_finish = ImageTk.PhotoImage(Image.open("finish.png"))
self.king_b = ImageTk.PhotoImage(Image.open("king_b.png"))
self.king_w = ImageTk.PhotoImage(Image.open("king_w.png"))
self.queen_b = ImageTk.PhotoImage(Image.open("queen_b.png"))
self.queen_w = ImageTk.PhotoImage(Image.open("queen_w.png"))
self.bishop_b = ImageTk.PhotoImage(Image.open("bishop_b.png"))
self.bishop_w = ImageTk.PhotoImage(Image.open("bishop_w.png"))
self.rook_b = ImageTk.PhotoImage(Image.open("rook_b.png"))
self.rook_w = ImageTk.PhotoImage(Image.open("rook_w.png"))
self.horse_b = ImageTk.PhotoImage(Image.open("horse_b.png"))
self.horse_w = ImageTk.PhotoImage(Image.open("horse_w.png"))
self.pawn_b = ImageTk.PhotoImage(Image.open("pawn_b.png"))
self.pawn_w = ImageTk.PhotoImage(Image.open("pawn_w.png"))
self.session_img = ImageTk.PhotoImage(Image.open("session_player.png"))
self.move = Move(init_table_chess, btn_list, self.old_button, self.btn_miss_list, self.init_miss_chess,
self.lbl_miss, self.session_player, self.session_img)
def readMoveFile(board):
with open(move_file) as fp:
line = fp.readline()
if line:
move = Move()
move.parseMove(line)
board.Click(move.x, move.y)
def test_scan_one_step(self):
b = Board("""
1 W
.....
.....
.....
.Kq..
.....
.....
""")
startpos = (2, 3)
# capturing right
movelist = []
b.scan(movelist, startpos, 1, 0, one_step=True)
expected = []
expected.append(Move.from_string("b3-c3"))
self.assertEqual(expected, movelist)
# to the top
movelist = []
b.scan(movelist, startpos, 0, 1, one_step=True)
expected = []
expected.append(Move.from_string("b3-b4"))
self.assertEqual(expected, movelist)
def getPossibleMoves(self, board, color, i, j):
ret_list = []
physical_moves = []
move = encoded(i, j, i - 1, j - 2)
physical_moves.append(move)
move = encoded(i, j, i - 2, j - 1)
physical_moves.append(move)
move = encoded(i, j, i + 1, j + 2)
physical_moves.append(move)
move = encoded(i, j, i + 2, j + 1)
physical_moves.append(move)
move = encoded(i, j, i - 1, j + 2)
physical_moves.append(move)
move = encoded(i, j, i - 2, j + 1)
physical_moves.append(move)
move = encoded(i, j, i + 1, j - 2)
physical_moves.append(move)
move = encoded(i, j, i + 2, j - 1)
physical_moves.append(move)
if color == 'B':
turn = 'BLACK'
else:
turn = 'WHITE'
for m in physical_moves:
from Move import Move
move = Move(m)
if move.isValidRule(board, turn):
ret_list.append(move.coded)
return ret_list
def test_legal_moves_combined(self):
b = Board("""
1 W
..k..
q..p.
.....
.P...
....r
N...K
""")
# get legal moves for all white pieces
legal_moves = b.legal_moves()
expected = []
# knight
expected.append(Move.from_string("a1-c2"))
# king
expected.append(Move.from_string("e1-e2"))
expected.append(Move.from_string("e1-d2"))
expected.append(Move.from_string("e1-d1"))
# pawn
expected.append(Move.from_string("b3-b4"))
self.assertEqual(len(expected), len(legal_moves))
for move in expected:
self.assertIn(move, legal_moves)
def test_scan_no_capture(self):
b = Board("""
1 W
.....
.....
..Qp.
.....
.....
.....
""")
startpos = (3, 4)
# not capturing right
movelist = []
b.scan(movelist, startpos, 1, 0, no_capture=True)
expected = []
self.assertEqual(expected, movelist)
# to the top
movelist = []
b.scan(movelist, startpos, 0, 1, no_capture=True)
expected = []
expected.append(Move.from_string("c4-c5"))
expected.append(Move.from_string("c4-c6"))
self.assertEqual(expected, movelist)
def make_move(self, move):
self.moves_stack.append(move)
if self.stacks[move.to_stack].is_valid(move.disk):
if self.stacks[move.from_stack].peek() == move.disk:
self.stacks[move.from_stack].pop()
self.stacks[move.to_stack].push(move.disk)
print(
f' Stack {move.from_stack} latest position is : {self.stacks[move.from_stack].show()}'
)
print(
f' Stack {move.to_stack} latest position is : {self.stacks[move.to_stack].show()}'
)
this_move = self.moves_stack.pop(len(self.moves_stack) - 1)
if len(self.moves_stack) > 0:
next_move = self.moves_stack.pop(len(self.moves_stack) - 1)
self.make_move(next_move)
else:
dest_stack = self.get_dest_stack(move)
src_stack = move.from_stack
move_disk = self.stacks[src_stack].get_disk_before(move.disk)
new_move = Move(move_disk, src_stack, dest_stack)
self.make_move(new_move)
else:
to_stack_top = self.stacks[move.to_stack].last_disk()
dest_stack = self.get_dest_stack(move)
src_stack = move.to_stack
shuffle_move = Move(to_stack_top, src_stack, dest_stack)
self.make_move(shuffle_move)
def getQueenMove(self, state):
myInv = getCurrPlayerInventory(state)
me = state.whoseTurn
queen = myInv.getQueen()
enemy = 1 - me
attackers = getAntList(state, enemy, [SOLDIER, R_SOLDIER, DRONE])
# if there are no attackers move to a default location
if len(attackers) == 0:
return Move(MOVE_ANT, createPathToward(state, queen.coords, (4, 3), UNIT_STATS[QUEEN][MOVEMENT]), None)
# find the most worrying attacker
dist = 99
closest = None
for ant in attackers:
tmp = (ant.coords[1] - 3) / UNIT_STATS[ant.type][MOVEMENT]
if tmp < dist:
dist = tmp
closest = ant
if closest.coords[1] <= 4:
path = createPathToward(state, queen.coords, (closest.coords[0], min(3, closest.coords[1])), UNIT_STATS[QUEEN][MOVEMENT])
elif closest.type == R_SOLDIER:
path = createPathToward(state, queen.coords, (closest.coords[0], 0), UNIT_STATS[QUEEN][MOVEMENT])
else:
path = createPathToward(state, queen.coords, (closest.coords[0], 2), UNIT_STATS[QUEEN][MOVEMENT])
return Move(MOVE_ANT, path, None)
def test_undo_last_move(self):
b = Board("""
1 W
...k.
..P..
.....
.....
.....
.....
""")
b2 = Board("""
1 W
...k.
..P..
.....
.....
.....
.....
""")
b.move(Move.from_string("c5-c6"))
b.undo_last_move()
self.assertEqual(b, b2)
b.move(Move.from_string("c5-d6"))
b.undo_last_move()
self.assertEqual(b, b2)
def test_negamax(self):
board = Board("""
1 W
..k..
.....
.....
.....
..Q..
...K.
""")
player = NegamaxPlayer()
best_value, best_move = player.negamax(board, 1)
self.assertEqual(Move.from_string("c2-c6"), best_move)
random.seed(0)
board = Board("""
1 W
kp...
.p...
.....
.....
.Q...
...K.
""")
player = NegamaxPlayer()
best_value, best_move = player.negamax(board, 3)
self.assertEqual(Move.from_string("b2-b4"), best_move)
def generate_king_moves(start_sq: int, piece: Piece, b: Board) -> [Move]:
"""Generates moves for Kings"""
moves = []
dire = [-7, -8, -9, -1, 1, 7, 8, 9]
for i in dire:
if not is_check(b, piece):
target_sq = start_sq + i
if target_sq > -1 and target_sq < 64:
if not is_same_colour(piece, b.square[target_sq]):
moves.append(
Move(start_sq, target_sq,
get_move_notation(piece, start_sq, target_sq, b)))
if castle(piece, True, deepcopy(b)):
moves.append(
Move(start_sq,
start_sq - 2,
get_move_notation(piece, start_sq, start_sq - 2, b),
special_turn=SpecialTurn.CastlingLong))
if castle(piece, False, deepcopy(b)):
moves.append(
Move(start_sq,
start_sq + 2,
get_move_notation(piece, start_sq, start_sq + 2, b),
special_turn=SpecialTurn.CastlingShort))
return moves
def test_scan_one_step(self):
b = Board("""
1 W
.....
.....
.....
.Kq..
.....
.....
""")
startpos = (2,3)
# capturing right
movelist = []
b.scan(movelist, startpos, 1, 0, one_step=True)
expected = []
expected.append(Move.from_string("b3-c3"))
self.assertEqual(expected, movelist)
# to the top
movelist = []
b.scan(movelist, startpos, 0, 1, one_step=True)
expected = []
expected.append(Move.from_string("b3-b4"))
self.assertEqual(expected, movelist)
class Remove: trashPath = 'Operate/TrashBox' # # [String] targetEntries : 作成するディレクトリ名 # def __init__(self, targetEntries): self.targetEntries = targetEntries self.move = None # # 実行 # def execute(self): self.move = None pairPaths = [] for targetEntry in self.targetEntries: entryName = targetEntry.rsplit(os.sep, 1)[1] inTrashPath = os.path.join(Remove.trashPath, entryName) pairPaths.append(PairPath(targetEntry, inTrashPath)) self.move = Move(pairPaths) self.move.execute() # # 実行取り消し # def unexecute(self): self.move.unexecute()
def test_negamax(self):
board = Board("""
1 W
..k..
.....
.....
.....
..Q..
...K.
""")
player = NegamaxPlayer()
best_value, best_move = player.negamax(board, 1)
self.assertEqual(Move.from_string("c2-c6"), best_move)
random.seed(0)
board = Board("""
1 W
kp...
.p...
.....
.....
.Q...
...K.
""")
player = NegamaxPlayer()
best_value, best_move = player.negamax(board, 3)
self.assertEqual(Move.from_string("b2-b4"), best_move)
def moveWorker(self, currentState, workerList):
inventory = getCurrPlayerInventory(currentState)
for ant in workerList:
if not ant.hasMoved:
if (
ant.carrying
): # has food, move toward hill/tunnell, whichever is closer
target = self.findClosestTo(
currentState, ant.coords,
((inventory.getAnthill()).coords,
(inventory.getTunnels())[0].coords))
path = createPathToward(currentState, ant.coords, target,
UNIT_STATS[WORKER][MOVEMENT])
return Move(MOVE_ANT, path, None)
else: # get food
foodCoords = []
for food in self.myFood:
foodCoords.append(food.coords)
target = self.findClosestTo(currentState, ant.coords,
foodCoords)
path = createPathToward(currentState, ant.coords, target,
UNIT_STATS[WORKER][MOVEMENT])
return Move(MOVE_ANT, path, None)
def getPossibleMoves(self, board, color, i, j):
ret_list = []
physical_moves = []
for k in [1, 2, 3, 4, 5, 6, 7]:
move = encoded(i, j, i - k, j - k)
physical_moves.append(move)
move = encoded(i, j, i + k, j + k)
physical_moves.append(move)
move = encoded(i, j, i - k, j + k)
physical_moves.append(move)
move = encoded(i, j, i + k, j - k)
physical_moves.append(move)
for k in range(8):
if k != i:
move = encoded(i, j, k, j)
physical_moves.append(move)
if k != j:
move = encoded(i, j, i, k)
physical_moves.append(move)
if color == 'B':
turn = 'BLACK'
else:
turn = 'WHITE'
for m in physical_moves:
from Move import Move
move = Move(m)
if move.isValidRule(board, turn):
ret_list.append(move.coded)
return ret_list
def test_legal_moves_combined(self):
b = Board("""
1 W
..k..
q..p.
.....
.P...
....r
N...K
""")
# get legal moves for all white pieces
legal_moves = b.legal_moves()
expected = []
# knight
expected.append(Move.from_string("a1-c2"))
# king
expected.append(Move.from_string("e1-e2"))
expected.append(Move.from_string("e1-d2"))
expected.append(Move.from_string("e1-d1"))
# pawn
expected.append(Move.from_string("b3-b4"))
self.assertEqual(len(expected), len(legal_moves))
for move in expected:
self.assertIn(move, legal_moves)
def spawnAnts(self, currentState, myInv, me):
legalBuilds = listAllBuildMoves(currentState)
if len(legalBuilds) < 1:
return
ants = getAntList(currentState, me,
(WORKER, DRONE, SOLDIER, R_SOLDIER))
antNums = {
"WORKER": [0, any(a.buildType == WORKER for a in legalBuilds)],
"DRONE": [0, any(a.buildType == DRONE for a in legalBuilds)],
"SOLDIER": [0, any(a.buildType == SOLDIER for a in legalBuilds)],
"R_SOLDIER":
[0, any(a.buildType == R_SOLDIER for a in legalBuilds)]
}
for ant in ants:
antNums[antTypeToStr(ant.type)][0] += 1
if (antNums["WORKER"][0] <
self.antList["WORKER"]) and antNums["WORKER"][1]:
return Move(BUILD, [myInv.getAnthill().coords], WORKER)
elif (antNums["DRONE"][0] <
self.antList["DRONE"]) and antNums["DRONE"][1]:
return Move(BUILD, [myInv.getAnthill().coords], DRONE)
elif (antNums["SOLDIER"][0] <
self.antList["SOLDIER"]) and antNums["SOLDIER"][1]:
return Move(BUILD, [myInv.getAnthill().coords], SOLDIER)
else:
return None
def test_undo_last_move(self):
b = Board("""
1 W
...k.
..P..
.....
.....
.....
.....
""")
b2 = Board("""
1 W
...k.
..P..
.....
.....
.....
.....
""")
b.move(Move.from_string("c5-c6"))
b.undo_last_move()
self.assertEqual(b, b2)
b.move(Move.from_string("c5-d6"))
b.undo_last_move()
self.assertEqual(b, b2)
def test_equal_operator(self):
b = Move.from_string("a1-a2")
c = Move.from_string("a1-a2")
self.assertEqual(b, c)
b = Move.from_string("e1-a2")
c = Move.from_string("a1-a4")
self.assertNotEqual(b, c)
def testConstruct(self):
row = 1
col = 2
mark = None
unit = Move(row, col, mark)
self.assertEqual(unit.getRow(), row)
self.assertEqual(unit.getCol(), col)
self.assertEqual(unit.getMark(), mark)
def test_equal_operator(self):
b = Move.from_string("a1-a2")
c = Move.from_string("a1-a2")
self.assertEqual(b, c)
b = Move.from_string("e1-a2")
c = Move.from_string("a1-a4")
self.assertNotEqual(b, c)
def Move(self, sReactor, sReactPosition):
"""Performs a move unit operation"""
pParams = {"ReactorID":sReactor,
"reactPosition":sReactPosition}
pMove = Move(self.__pSystemModel, pParams, username = "******", database = self.__pDatabase)
pMove.setDaemon(True)
pMove.start()
return pMove
def test_construct(self):
b = Move((1, 1), (1, 2))
self.assertEqual((1, 1), b.start)
self.assertEqual((1, 2), b.end)
b = Move.from_string("a1-a2")
self.assertEqual((1, 1), b.start)
self.assertEqual((1, 2), b.end)
def getValidMoves(self, player):
validMoves = []
for rowNumber in range(8):
for columnNumber in range(8):
move = Move(player.shape, rowNumber, columnNumber, self)
if move.isMoveValid():
validMoves.append(move)
return validMoves
def get_bar_moves(self):
bar_moves = []
move = Move(self.player.colour, 26, 25 - self.dice.die1)
if self.is_valid_move_from_bar(move):
bar_moves.append(move)
move = Move(self.player.colour, 26, 25 - self.dice.die2)
if self.is_valid_move_from_bar(move):
bar_moves.append(move)
return bar_moves
def move_from(self, x, y):
# Get possible moves
poss_moves = Move.get_poss_moves(self.board, self.turn, x, y, len(self.moves), scan_mode=self.scan_mode)
# Check if it is a valid selection, if not, exit the function
if not poss_moves:
return -1
# Create a new move and add to list and pass the len of move list as move id
self.moves.append(Move(self.board, x, y, len(self.moves), poss_moves, scan_mode=self.scan_mode))
class Player:
def __init__(self, color, board):
self.move = Move()
self.color = color
self.board = board
def askMove(self, otherPlayer):
self.move.makeMove(self.color, self.board)
otherPlayer.askMove(self)
def execute(self, userdata):
status = 'Success'
sm = smach.StateMachine(outcomes=['Success', 'Failure'])
if userdata.search_object == 'Gate':
with sm:
sm.userdata.type = 'depth'
sm.userdata.args = {
'depth': .65,
'x': 2,
'y': -.8,
'obj': 'Gate',
'bboxWidth': .07,
'hold': True
}
smach.StateMachine.add('MOVE_DOWN',
Move(),
transitions={
'Success': 'Success',
'Failure': 'Failure'
},
remapping={
'type': 'type',
'args': 'args'
})
smach.StateMachine.add('ALIGN',
Align(),
transitions={
'Success': 'Success',
'Failure': 'Failure'
})
smach.StateMachine.add('DISTANCE',
Distance(),
transitions={
'Success': 'Success',
'Failure': 'Failure'
},
remapping={
'type': 'type',
'args': 'args'
})
smach.StateMachine.add('MOVE_AWAY',
Move(),
transitions={
'Success': 'Success',
'Failure': 'Failure'
},
remapping={
'type': 'type',
'args': 'args'
})
status = sm.execute()
else:
Logger.loginfo('object does not exist')
status = 'Failure'
return status
def find_optimal_move(self):
"""
Applying minimax algorithm, determines the best move for a given board configuration
:return: (x, y) - the coordinates of the best move
"""
best_move = Move(0, 0)
best_move.val = self.minus_infinity
self.refresh_copy_board()
for y in range(1, self.board.width + 1):
for x in range(1, self.board.width + 1):
if self.board.get_cell(x, y) != 0:
continue
self.copy_board_mat[y][x] = 2
tried_move_val = self.minimax_simpler(False, 1, x, y)
if tried_move_val == self.plus_infinity:
best_move.x = x
best_move.y = y
best_move.val = tried_move_val
return best_move
if tried_move_val > best_move.val:
best_move.x = x
best_move.y = y
best_move.val = tried_move_val
self.copy_board_mat[y][x] = 0
return best_move
def reset(self):
self.move = Move()
time.sleep(self.secs)
self.buildGrid()
self.move = Move()
self.snake = Snake(self.width, self.height, self.border)
self.food = Food(self.width, self.height, self.snake)
self.score = 0
self.reseting = True
def test_next_move(monkeypatch, test_humanplayer):
board = Board()
dice = Dice()
dice.set_dice(2, 1)
monkeypatch.setattr('builtins.input', lambda x: '13 11')
assert test_humanplayer.next_move(board, dice) == Move(0, 13, 11)
monkeypatch.setattr('builtins.input', lambda x: '24 23')
assert test_humanplayer.next_move(board, dice) == Move(0, 24, 23)
monkeypatch.setattr('builtins.input', lambda x: '6 5')
assert test_humanplayer.next_move(board, dice) == Move(0, 6, 5)
def test_move_game_result(self):
# white win
b = Board("""
1 W
.k...
P....
.....
.....
.....
.....
""")
result = b.move(Move.from_string("a5-b6"))
self.assertEqual(result, 'W')
# black win
b = Board("""
1 B
..r..
.....
.....
.....
..K..
.....
""")
result = b.move(Move.from_string("c6-c2"))
self.assertEqual(result, 'B')
# undecided
b = Board("""
1 W
.....
P....
.....
.....
.....
.....
""")
result = b.move(Move.from_string("a5-a6"))
self.assertEqual(result, '?')
# draw
b = Board("""
40 B
.....
p....
.....
.....
.....
.....
""")
result = b.move(Move.from_string("a5-a4"))
self.assertEqual(result, '=')
def test_move_game_result(self):
# white win
b = Board("""
1 W
.k...
P....
.....
.....
.....
.....
""")
result = b.move(Move.from_string("a5-b6"))
self.assertEqual(result, 'W')
# black win
b = Board("""
1 B
..r..
.....
.....
.....
..K..
.....
""")
result = b.move(Move.from_string("c6-c2"))
self.assertEqual(result, 'B')
# undecided
b = Board("""
1 W
.....
P....
.....
.....
.....
.....
""")
result = b.move(Move.from_string("a5-a6"))
self.assertEqual(result, '?')
# draw
b = Board("""
40 B
.....
p....
.....
.....
.....
.....
""")
result = b.move(Move.from_string("a5-a4"))
self.assertEqual(result, '=')
def movesInDirectionFromPos(self, pos, direction, side) :
for dis in range(1, 8) :
movement = C(dis * direction[X], dis * direction[Y])
newPos = pos + movement
if self.board.isValidPos(newPos) :
pieceAtNewPos = self.board.pieceAtPosition(newPos)
if pieceAtNewPos is None :
yield Move(self, newPos)
elif pieceAtNewPos is not None :
if pieceAtNewPos.side != side :
yield Move(self, newPos, pieceToCapture = pieceAtNewPos)
return
def test_legal_moves_rook(self):
b = Board("""
1 W
.....
.....
..Rr.
.....
.....
.....
""")
# get legal moves for white rook 'R'
legal_moves = b.legal_moves()
expected = []
expected.append(Move.from_string("c4-d4"))
expected.append(Move.from_string("c4-c3"))
expected.append(Move.from_string("c4-c2"))
expected.append(Move.from_string("c4-c1"))
expected.append(Move.from_string("c4-b4"))
expected.append(Move.from_string("c4-a4"))
expected.append(Move.from_string("c4-c5"))
expected.append(Move.from_string("c4-c6"))
self.assertEqual(len(expected), len(legal_moves))
for move in expected:
self.assertIn(move, legal_moves)
def test_legal_moves_bishop(self):
b = Board("""
1 W
.....
.....
...p.
.p...
.B...
.....
""")
# get legal moves for white bishop 'B'
legal_moves = b.legal_moves()
expected = []
expected.append(Move.from_string("b2-a1"))
expected.append(Move.from_string("b2-c3"))
expected.append(Move.from_string("b2-d4"))
expected.append(Move.from_string("b2-a3"))
expected.append(Move.from_string("b2-c1"))
expected.append(Move.from_string("b2-b1"))
expected.append(Move.from_string("b2-a2"))
expected.append(Move.from_string("b2-c2"))
self.assertEqual(len(expected), len(legal_moves))
for move in expected:
self.assertIn(move, legal_moves)
def test_try_move_and_score(self):
b = Board("""
1 W
..k..
q..p.
.....
.P...
....r
N...K
""")
self.assertEqual(b.score_after(Move.from_string("b3-b4")), 1150) # score for black!
# moving pawn, no change in score, Black has advantage
b.move(Move.from_string("b3-b4"))
self.assertEqual(b.score_after(Move.from_string("e2-e1")), -100000) # score for white!
def test_scan_only_capture(self):
b = Board("""
1 W
.....
...p.
..P..
..K..
.....
.....
""")
startpos = (3,4)
# to the top
movelist = []
b.scan(movelist, startpos, 0, 1, only_capture=True)
expected = []
self.assertEqual(expected, movelist)
# capturing enemy
movelist = []
b.scan(movelist, startpos, 1, 1, only_capture=True)
expected = []
expected.append(Move.from_string("c4-d5"))
self.assertEqual(expected, movelist)
# not capturing own
movelist = []
b.scan(movelist, startpos, 0, -1, only_capture=True)
expected = []
self.assertEqual(expected, movelist)
def test_stab(self):
for i in range(0, 16):
a_type = Type(i)
dif_type = Type(i + 1)
atk = Move(self.valid_name, a_type, \
self.valid_accuracy, self.valid_power, self.valid_pp)
# Test results
self.assertEqual(atk.stab(a_type, a_type), 1.5)
self.assertEqual(atk.stab(a_type, dif_type), 1.5)
self.assertEqual(atk.stab(dif_type, a_type), 1.5)
self.assertEqual(atk.stab(dif_type, dif_type), 1)
# Test exceptions
self.assertRaises(TypeError, atk.stab, "fire")
self.assertRaises(TypeError, atk.stab, 0)
def test_construct(self):
b = Move((1, 1), (1, 2))
self.assertEqual((1, 1), b.start)
self.assertEqual((1, 2), b.end)
b = Move.from_string("a1-a2")
self.assertEqual((1, 1), b.start)
self.assertEqual((1, 2), b.end)
def test_scan_until_enemy(self):
b = Board("""
1 W
.....
.....
.....
..q..
.....
Q....
""")
startpos = (1,1)
movelist = []
b.scan(movelist, startpos, 1, 1)
expected = []
expected.append(Move.from_string("a1-b2"))
expected.append(Move.from_string("a1-c3"))
self.assertEqual(expected, movelist)
def test_move_promotion(self):
b1 = Board("""
1 W
.....
P....
.....
.....
.....
...kK
""")
b1.move(Move.from_string("a5-a6"))
b2 = Board("""
1 B
Q....
.....
.....
.....
.....
...kK
""")
self.assertEqual(b1, b2)
b3 = Board("""
1 B
k....
.....
.....
.....
..p..
...K.
""")
b3.move(Move.from_string("c2-d1"))
b4 = Board("""
2 W
k....
.....
.....
.....
.....
...q.
""")
self.assertEqual(b3, b4)
def generate_move(self, game):
print("getting move from skirmish:")
move = sys.stdin.readline()
try:
_, move = move.strip().split(" ")
except:
f = open("crap", "w")
f.write(move)
f.close()
return Move.from_string(move)
def execute(self): self.move = None pairPaths = [] for targetEntry in self.targetEntries: entryName = targetEntry.rsplit(os.sep, 1)[1] inTrashPath = os.path.join(Remove.trashPath, entryName) pairPaths.append(PairPath(targetEntry, inTrashPath)) self.move = Move(pairPaths) self.move.execute()
def test_legal_moves_knight(self):
b = Board("""
1 W
.....
.....
.....
.p...
.....
N....
""")
# get legal moves for white knight 'N'
legal_moves = b.legal_moves()
expected = []
expected.append(Move.from_string("a1-b3"))
expected.append(Move.from_string("a1-c2"))
self.assertEqual(len(expected), len(legal_moves))
for move in expected:
self.assertIn(move, legal_moves)
def test_is_own_piece(self):
b = Board()
# whites turn
self.assertTrue(b.is_own_piece('P'))
self.assertFalse(b.is_own_piece('p'))
b.move(Move.from_string("a1-a2"))
# blacks turn
self.assertFalse(b.is_own_piece('P'))
self.assertTrue(b.is_own_piece('p'))
def test_construct_from_other(self):
b = Board("""
11 W
..bn.
pp...
.....
PP...
..PPP
RNBQK
""")
b.move(Move.from_string("a1-a2"))
b2 = Board.from_other(b)
self.assertEqual(b, b2)
self.assertEqual(b.history, b2.history)
def generate_move(self, game):
"""
Generate and return a move for the current turn color.
The caller ensures that a legal move exists.
If server checks if the move was legal and calls the function again if not.
"""
while True:
a = input("Your move: ").strip()
try:
move = Move.from_string(a)
return move
except:
print("Wrong move syntax. Try something like this: a2-a3")
def test_scan_until_own(self):
b = Board("""
1 W
....Q
.....
..Q..
.....
.....
.....
""")
startpos = (3,4)
movelist = []
b.scan(movelist, startpos, 1, 1)
expected = []
expected.append(Move.from_string("c4-d5"))
self.assertEqual(expected, movelist)
def __init__(self, mode=1):
self._Height = 75
self._Length = 65
self._DefaultPulse = 375
self._Multiplier = 1
self._currentModeInt = mode
pulses = self.calculatePulse(self._Height, self._Length)
self._Legs = [
Leg([0x41, 0x41, 0x41], [0, 1, 2], [375, pulses[0], pulses[1]], [0, 0, 0]), #leg 1
Leg([0x40, 0x40, 0x40], [0, 1, 2], [375, pulses[0], pulses[1]], True, [0, 0, 0]), #leg 2
Leg([0x41, 0x41, 0x41], [4, 5, 6], [375, pulses[0], pulses[1]], [0, 0, 0]), #leg 3
Leg([0x40, 0x40, 0x40], [4, 5, 6], [375, pulses[0], pulses[1]], True, [0, 0, 0]), #leg 4
Leg([0x41, 0x41, 0x41], [8, 9, 10], [375, pulses[0], pulses[1]], [0, 0, 0]), #leg 5
Leg([0x40, 0x40, 0x40], [8, 9, 10], [375, pulses[0], pulses[1]], True, [0, 0, 0]), #leg 6
]
self._CurrentCommand = 10
self._Exit = False
self._Semaphore = threading.Semaphore(1)
self._ExitSemaphore = threading.Semaphore(1)
self.SleepTime = 0.0005
if mode == 1:
self._CurrentMode = Move(self)
if mode == 2:
self._CurrentMode = FingerControl(self)
if mode == 3:
self._CurrentMode = SpiderGap(self)
if mode == 4:
self._CurrentMode = Dance(self)
if mode == 5:
self._CurrentMode = BalloonRace(self)
if mode == 6:
self._CurrentMode = Move(self)
if mode == 7:
self._CurrentMode = Move(self)
if mode == 8:
self._CurrentMode = Dance2(self)
if mode == 9:
self._CurrentMode = SpiderGap2(self)
def getPossibleMoves(self):
currentPos = self.position
movements = [C(0, 1), C(0, -1), C(1, 0), C(-1, 0), C(1, 1), C(1, -1), C(-1, 1), C(-1, -1)]
for movement in movements:
newPos = currentPos + movement
if self.board.isValidPos(newPos):
pieceAtNewPos = self.board.pieceAtPosition(newPos)
if self.board.pieceAtPosition(newPos) is None:
yield Move(self, newPos)
elif pieceAtNewPos.side != self.side:
yield Move(self, newPos, pieceToCapture=pieceAtNewPos)
# Castling
if self.movesMade == 0:
inCheck = False
kingsideCastleBlocked = False
queensideCastleBlocked = False
kingsideCastleCheck = False
queensideCastleCheck = False
kingsideRookMoved = True
queensideRookMoved = True
kingsideCastlePositions = [self.position + C(1, 0), self.position + C(2, 0)]
for pos in kingsideCastlePositions:
if self.board.pieceAtPosition(pos):
kingsideCastleBlocked = True
queensideCastlePositions = [self.position - C(1, 0), self.position - C(2, 0), self.position - C(3, 0)]
for pos in queensideCastlePositions:
if self.board.pieceAtPosition(pos):
queensideCastleBlocked = True
if kingsideCastleBlocked and queensideCastleBlocked:
return
otherSideMoves = self.board.getAllMovesUnfiltered(not self.side, includeKing=False)
for move in otherSideMoves:
if move.newPos == self.position:
inCheck = True
break
if move.newPos == self.position + C(1, 0) or move.newPos == self.position + C(2, 0):
kingsideCastleCheck = True
if move.newPos == self.position - C(1, 0) or move.newPos == self.position - C(2, 0):
queensideCastleCheck = True
kingsideRookPos = self.position + C(3, 0)
kingsideRook = self.board.pieceAtPosition(kingsideRookPos) if self.board.isValidPos(kingsideRookPos) else None
if kingsideRook and kingsideRook.stringRep == 'R' and kingsideRook.movesMade == 0:
kingsideRookMoved = False
queensideRookPos = self.position - C(4, 0)
queensideRook = self.board.pieceAtPosition(queensideRookPos) if self.board.isValidPos(queensideRookPos) else None
if queensideRook and queensideRook.stringRep == 'R' and queensideRook.movesMade == 0:
queensideRookMoved = False
if not inCheck:
if not kingsideCastleBlocked and not kingsideCastleCheck and not kingsideRookMoved:
move = Move(self, self.position + C(2, 0))
rookMove = Move(self.position, self.position + C(1, 0))
move.specialMovePiece = self.board.pieceAtPosition(kingsideRookPos)
move.kingsideCastle = True
move.rookMove = rookMove
yield move
if not queensideCastleBlocked and not queensideCastleCheck and not queensideRookMoved:
move = Move(self, self.position - C(2, 0))
rookMove = Move(self.position, self.position - C(1, 0))
move.specialMovePiece = self.board.pieceAtPosition(queensideRookPos)
move.queensideCastle = True
move.rookMove = rookMove
yield move
def get_possible_moves(self):
pos = self.position
# Pawn moves one up
movement = C(0, 1) if self.side == WHITE else C(0, -1)
up_pos = pos + movement
if self.board.is_valid_pos(up_pos):
# Promotion moves
if self.board.get_piece_at_pos(up_pos) is None:
col = up_pos[1]
if col == 7 or col == 0:
piecesForPromotion = \
[Rook(self.board, self.side, up_pos),
Knight(self.board, self.side, up_pos),
Bishop(self.board, self.side, up_pos),
Queen(self.board, self.side, up_pos)]
for piece in piecesForPromotion:
move = Move(self, up_pos)
move.promotion = True
move.specialMovePiece = piece
yield move
else:
yield Move(self, up_pos)
# Pawn moves two up
if self.movesMade == 0:
movement = C(0, 2) if self.side == WHITE else C(0, -2)
up2_pos = pos + movement
if self.board.is_valid_pos(up2_pos):
if self.board.get_piece_at_pos(up2_pos) is None and \
self.board.get_piece_at_pos(up_pos) is None:
yield Move(self, up2_pos)
# Pawn takes
movements = [C(1, 1), C(-1, 1)] \
if self.side == WHITE else [C(1, -1), C(-1, -1)]
for movement in movements:
new_pos = self.position + movement
if self.board.is_valid_pos(new_pos):
pieceToTake = self.board.get_piece_at_pos(new_pos)
if pieceToTake and pieceToTake.side != self.side:
col = new_pos[1]
# Promotions
if col == 7 or col == 0:
piecesForPromotion = \
[Rook(self.board, self.side, new_pos),
Knight(self.board, self.side, new_pos),
Bishop(self.board, self.side, new_pos),
Queen(self.board, self.side, new_pos)]
for piece in piecesForPromotion:
move = Move(self, up_pos)
move.promotion = True
move.specialMovePiece = piece
yield move
else:
yield Move(self, new_pos,
piece_to_capture=pieceToTake)
# En pessant
movements = [C(1, 1), C(-1, 1)] \
if self.side == WHITE else [C(1, -1), C(-1, -1)]
for movement in movements:
posBesidePawn = self.position + C(movement[0], 0)
if self.board.is_valid_pos(posBesidePawn):
pieceBesidePawn = self.board.get_piece_at_pos(posBesidePawn)
lastPieceMoved = self.board.getLastPieceMoved()
lastMoveWasAdvanceTwo = False
lastMove = self.board.getLastMove()
if lastMove:
if lastMove.new_pos - lastMove.old_pos == C(0, 2) or \
lastMove.new_pos - lastMove.old_pos == C(0, -2):
lastMoveWasAdvanceTwo = True
if pieceBesidePawn and \
pieceBesidePawn.stringRep == 'p' and \
pieceBesidePawn.side != self.side and \
lastPieceMoved is pieceBesidePawn and \
lastMoveWasAdvanceTwo:
move = Move(self, self.position + movement,
piece_to_capture=pieceBesidePawn)
move.pessant = True
move.specialMovePiece = pieceBesidePawn
yield move
def attack(move, pokemon1, pokemon2):
# Creating an empty string to store the results of the attack function
tempMsg = ""
# Reading "Type Advantages.csv" file to determine type advantages and the damage modifier
# Stores the line number in the csv as the key and a list giving information about type advantage for the value
fin = open("Type Advantages.csv", "r")
typeDic = {}
for line in fin:
line = line.strip()
typeList = line.split(",")
typeDic[typeList[0]] = typeList
# This list contains a number in the first position, the attack type in the second, the defending type in the third,
# and the appropriate damage multiplier in the fourth
fin.close()
# Making the input string into an actual move object
move = Move(move)
# This modifier is used in damage calculations; it takes into account type advantage and STAB bonus
modifier = 1
# Calculating Type advantages using "Type Advantages.csv" file
for key in typeDic:
# If the attacking and defending types match up, multiply the modifier by the damage multiplier from the list
if typeDic[key][1] == move.type and typeDic[key][2] == pokemon2.type1:
modifier *= float(typeDic[key][3])
# Didn't use elif; Just in case you get a 4x or 0.25x modifier based on double type
if typeDic[key][1] == move.type and typeDic[key][2] == pokemon2.type2:
modifier *= float(typeDic[key][3])
# Calculating STAB (Same-type Attack Bonus)
if move.type == pokemon1.type1:
modifier *= Pokemon.STAB
elif move.type == pokemon1.type2:
modifier *= Pokemon.STAB
# Damage formula also has a random element
modifier *= random.uniform(0.85, 1.0)
print()
# Appending the useMove function to the output
tempMsg += pokemon1.useMove(move)
# ATK/DEF or SpATK/SpDEF or Status? Using the Pokemon damage formula
# If the move is "Physical", the damage formula will take into account attack and defense
if move.kind == "Physical":
damage = int(
(((2 * pokemon1.getLevel()) + 10) / 250 * (pokemon1.battleATK / pokemon2.battleDEF) * move.getPower() + 2)
* modifier
)
tempMsg += "\n" + pokemon2.loseHP(damage)
# If the move is "Special", the damage formula will take into account special attack and special defense
elif move.kind == "Special":
damage = int(
(
((2 * pokemon1.getLevel()) + 10) / 250 * (pokemon1.battleSpATK / pokemon2.battleSpDEF) * move.getPower()
+ 2
)
* modifier
)
tempMsg += "\n" + pokemon2.loseHP(damage)
# Stat Changing moves
else:
# If the move is stat-changing, it does 0 damage and the modifier is set to 1 (so it doesn't return super effective or not very effective)
damage = 0
modifier = 1
# Going through each kind of different stat change based on the move type
if move.kind == "a-":
pokemon2.atkStage -= 1
pokemon2.battleATK = pokemon2.originalATK * statMod(pokemon2.atkStage)
tempMsg += "\n" + pokemon2.name + "'s attack fell! "
elif move.kind == "a+":
pokemon1.atkStage += 1
pokemon1.battleATK = pokemon1.originalATK * statMod(pokemon1.atkStage)
tempMsg += "\n" + pokemon1.name + "'s attack rose! "
elif move.kind == "d+":
pokemon1.defStage += 1
pokemon1.battleDEF = pokemon1.originalDEF * statMod(pokemon1.defStage)
print(pokemon1.name + "'s defense rose! ")
tempMsg += "\n" + pokemon1.name + "'s defense rose! "
elif move.kind == "sa+":
pokemon1.spAtkStage += 1
pokemon1.battleSpATK = pokemon1.originalSpATK * statMod(pokemon1.spAtkStage)
print(pokemon1.name + "'s special attack rose! ")
tempMsg += "\n" + pokemon1.name + "'s special attack rose! "
elif move.kind == "sd+":
pokemon1.spDefStage += 1
pokemon1.battleSpDef = pokemon1.originalSpDEF * statMod(pokemon1.spDefStage)
tempMsg += "\n" + pokemon1.name + "'s special defense rose! "
elif move.kind == "s+":
pokemon1.speedStage += 1
pokemon1.battleSpeed = pokemon1.originalSpeed * statMod(pokemon1.speedStage)
tempMsg += "\n" + pokemon1.name + "'s speed fell! "
elif move.kind == "d-":
pokemon2.defStage -= 1
pokemon2.battleDEF = pokemon2.originalDEF * statMod(pokemon2.defStage)
tempMsg += "\n" + pokemon2.name + "'s defense fell! "
elif move.kind == "sa-":
pokemon2.spAtkStage -= 1
pokemon2.battleSpATK = pokemon2.originalSpATK * statMod(pokemon2.spAtkStage)
tempMsg += "\n" + pokemon2.name + "'s special attack fell! "
elif move.kind == "sd-":
pokemon2.spDefStage -= 1
pokemon2.battleSpDEF = pokemon2.originalSpDEF * statMod(pokemon2.spDefStage)
tempMsg += "\n" + pokemon2.name + "'s special defense fell! "
elif move.kind == "s-":
pokemon2.speedStage -= 1
pokemon2.battleSpeed = pokemon2.originalSpeed * statMod(pokemon2.speedStage)
tempMsg += "\n" + pokemon2.name + "'s speed fell! "
# Super effective, not very effective, or no effect?
# Appending the result to tempMsg
if modifier < 0.85 and modifier > 0:
tempMsg += "\nIt's not very effective..."
elif modifier > 1.5:
tempMsg += "\nIt's super effective!"
elif modifier == 0.0:
tempMsg += "\nIt doesn't affect " + pokemon2.name + "..."
# String containing useMove(), damage, and type effectiveness
return tempMsg
