def test_stalemate(self):
"""Tests stalemate correctly determines if red and black are put into stalemate."""
# test red in stalemate
game = XiangqiGame()
board = game.get_board()
board.clear_board()
board.get_point_with_pos("e1").set_piece(General("red"))
board.get_point_with_pos("d10").set_piece(General("black"))
board.get_point_with_pos("f10").set_piece(Chariot("black"))
self.assertEqual(False, game.stalemate())
board.get_point_with_pos("a2").set_piece(Chariot("black"))
self.assertEqual(True, game.stalemate())
# test black in stalemate
game = XiangqiGame()
board = game.get_board()
board.clear_board()
board.get_point_with_pos("e1").set_piece(General("red"))
board.get_point_with_pos("d10").set_piece(General("black"))
game.make_move("e1", "f1")
self.assertEqual(False, game.stalemate())
board.get_point_with_pos("e9").set_piece(Chariot("red"))
board.get_point_with_pos("c9").set_piece(Chariot("red"))
self.assertEqual(True, game.stalemate())
def test_update_game_state_with_checkmate(self):
"""tests when checkmate happens game_state is correctly updated."""
# test red won with checkmate
game = XiangqiGame()
board = game.get_board()
board.clear_board()
board.get_point_with_pos("e1").set_piece(General("red"))
board.get_point_with_pos("d10").set_piece(General("black"))
board.get_point_with_pos("a1").set_piece(Chariot("red"))
self.assertEqual("UNFINISHED", game.get_game_state())
game.make_move("a1", "d1")
self.assertEqual("RED_WON", game.get_game_state())
# test black won with checkmate
game = XiangqiGame()
board = game.get_board()
board.clear_board()
board.get_point_with_pos("e1").set_piece(General("red"))
board.get_point_with_pos("d10").set_piece(General("black"))
game.make_move("e1", "f1")
board.get_point_with_pos("e10").set_piece(Chariot("black"))
board.get_point_with_pos("g10").set_piece(Chariot("black"))
self.assertEqual("UNFINISHED", game.get_game_state())
game.make_move("g10", "f10")
self.assertEqual("BLACK_WON", game.get_game_state())
def test_oppposing_player_color(self):
"""Tests opposing_player_color returns correct color."""
game = XiangqiGame()
self.assertEqual("black", game.opposing_player_color("red"))
self.assertEqual("red", game.opposing_player_color("black"))
def test_is_in_check(self):
"""Tests is_in_check correctly returns if the current player is in check for both red and black."""
game = XiangqiGame()
board = game.get_board()
board.clear_board()
board.get_point_with_pos("e1").set_piece(General("red"))
board.get_point_with_pos("d10").set_piece(General("black"))
# test where red and black are not in check
self.assertEqual(False, game.is_in_check("red"))
self.assertEqual(False, game.is_in_check("black"))
board.get_point_with_pos("e3").set_piece(Chariot("red"))
board.get_point_with_pos("d8").set_piece(Chariot("black"))
self.assertEqual(False, game.is_in_check("red"))
self.assertEqual(False, game.is_in_check("black"))
# test where black is in check
board.get_point_with_pos("d8").set_piece(Chariot("red"))
self.assertEqual(False, game.is_in_check("red"))
self.assertEqual(True, game.is_in_check("black"))
# test where red is in check
board.get_point_with_pos("d8").set_piece(None)
board.get_point_with_pos("e3").set_piece(Chariot("black"))
self.assertEqual(True, game.is_in_check("red"))
self.assertEqual(False, game.is_in_check("black"))
def test_red_wins_1(self):
game = XiangqiGame()
result_1 = game.make_move('h3', 'e3')
result_2 = game.make_move('h8', 'g8')
result_3 = game.make_move('h1', 'i3')
result_4 = game.make_move('i10', 'i9')
result_5 = game.make_move('i1', 'h1')
result_6 = game.make_move('h10', 'i8')
result_7 = game.make_move('e3', 'e7')
result_8 = game.make_move('i8', 'g9')
result_9 = game.make_move('b3', 'e3')
result_10 = game.make_move('g8', 'h8')
result_11 = game.make_move('h1', 'h8')
result_12 = game.make_move('b8', 'b6')
result_13 = game.make_move('h8', 'e8')
result_14 = game.is_in_check("black")
result_15 = game.make_move('f10', 'e9')
result_16 = game.make_move('e8', 'i8')
result_17 = game.make_move('c10', 'e8')
result_18 = game.make_move('i8', 'i9')
result_19 = game.make_move('b6', 'b2')
result_20 = game.make_move('i9', 'g9')
result_21 = game.make_move('c7', 'c6')
result_22 = game.make_move('g9', 'g10')
result_23 = game.get_game_state()
final_result = (result_1, result_2, result_3, result_4, result_5,
result_6, result_7, result_8, result_9, result_10,
result_11, result_12, result_13, result_14, result_15,
result_16, result_17, result_18, result_19, result_20,
result_21, result_22, result_23)
self.assertEqual(final_result,
(True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True,
True, True, True, True, "RED_WON"))
def test_is_valid_move_elephant(self):
game = XiangqiGame()
result_1 = game.is_valid_move_elephant("c1", "a3")
result_2 = game.is_valid_move_elephant("c1", "e3")
result_3 = game.is_valid_move_elephant("e1", "e2")
result_4 = game.is_valid_move_elephant("c10", "a8")
result_5 = game.is_valid_move_elephant("g10", "e8")
final_result = (result_1, result_2, result_3, result_4, result_5)
self.assertEqual(final_result, (True, True, True, True, True))
def test_elephant_moves(self):
"""Tests all types of Elephant moves that are valid."""
game = XiangqiGame()
board = game.get_board()
board.clear_board()
board.get_point_with_pos("e1").set_piece(General("red"))
board.get_point_with_pos("d10").set_piece(General("black"))
board.get_point_with_pos("c1").set_piece(Elephant("red"))
board.get_point_with_pos("g1").set_piece(Elephant("red"))
board.get_point_with_pos("c10").set_piece(Elephant("black"))
board.get_point_with_pos("g10").set_piece(Elephant("black"))
# test can only capture opposing color pieces
red_elephant_moves = game.get_valid_end_pos_array("c1", "E")
black_elephant_moves = game.get_valid_end_pos_array("c10", "E")
self.assertEqual(["e3", "a3"], red_elephant_moves)
self.assertEqual(["e8", "a8"], black_elephant_moves)
red_elephant_moves = game.get_valid_end_pos_array("g1", "E")
black_elephant_moves = game.get_valid_end_pos_array("g10", "E")
self.assertEqual(["i3", "e3"], red_elephant_moves)
self.assertEqual(["i8", "e8"], black_elephant_moves)
game.make_move("c1", "e3")
game.make_move("c10", "e8")
board.get_point_with_pos("c1").set_piece(Soldier("black"))
board.get_point_with_pos("c10").set_piece(Soldier("red"))
red_elephant_moves = game.get_valid_end_pos_array("e3", "E")
black_elephant_moves = game.get_valid_end_pos_array("e8", "E")
self.assertEqual(["g5", "c5", "c1"], red_elephant_moves)
self.assertEqual(["g6", "c10", "c6"], black_elephant_moves)
# test cannot jump over pieces and test can have no moves
board.get_point_with_pos("h2").set_piece(Soldier("red"))
board.get_point_with_pos("h9").set_piece(Soldier("red"))
red_elephant_moves = game.get_valid_end_pos_array("g1", "E")
black_elephant_moves = game.get_valid_end_pos_array("g10", "E")
self.assertEqual([], red_elephant_moves)
self.assertEqual([], black_elephant_moves)
# test cannot cross river
board.get_point_with_pos("c1").set_piece(None)
board.get_point_with_pos("c10").set_piece(None)
game.make_move("e3", "c5")
game.make_move("e8", "c6")
red_elephant_moves = game.get_valid_end_pos_array("c5", "E")
black_elephant_moves = game.get_valid_end_pos_array("c6", "E")
self.assertEqual(["e3", "a3"], red_elephant_moves)
self.assertEqual(["e8", "a8"], black_elephant_moves)
def test_readme_code(self):
game = XiangqiGame()
move_result = game.make_move('c1', 'e3')
self.assertTrue(move_result)
black_in_check = game.is_in_check('black')
self.assertFalse(black_in_check)
game.make_move('e7', 'e6')
state = game.get_game_state()
self.assertEqual(state, 'UNFINISHED')
def test_black_wins_1(self):
game = XiangqiGame()
result_1 = game.make_move('h3', 'f3')
result_2 = game.make_move('b8', 'e8')
result_3 = game.make_move('f3', 'f6')
result_4 = game.make_move('h10', 'g8')
result_5 = game.make_move('h1', 'g3')
result_6 = game.make_move('i10', 'h10')
result_7 = game.make_move('c4', 'c5')
result_8 = game.make_move('a10', 'a9')
result_9 = game.make_move('c5', 'c6')
result_10 = game.make_move('a9', 'f9')
result_11 = game.make_move('c6', 'c7')
result_12 = game.make_move('f9', 'f6')
result_13 = game.make_move('c7', 'd7')
result_14 = game.make_move('f6', 'd6')
result_15 = game.make_move('d7', 'e7')
result_16 = game.make_move('g8', 'e7')
result_17 = game.make_move('i1', 'h1')
result_18 = game.make_move('d6', 'd3')
result_19 = game.make_move('c1', 'e3')
result_20 = game.make_move('d3', 'b3')
result_21 = game.make_move('a1', 'a3')
result_22 = game.make_move('b3', 'b1')
result_23 = game.make_move('a3', 'd3')
result_24 = game.make_move('h8', 'h2')
result_25 = game.make_move('h1', 'h2')
result_26 = game.make_move('h10', 'h2')
result_27 = game.make_move('g3', 'e2')
result_28 = game.make_move('b10', 'c8')
result_29 = game.make_move('d3', 'c3')
result_30 = game.make_move('e7', 'd5')
result_31 = game.make_move('c3', 'c8')
result_32 = game.make_move('d5', 'f4')
result_33 = game.make_move('c8', 'e8')
result_34 = game.is_in_check("black")
result_35 = game.make_move('g10', 'e8')
result_36 = game.make_move('e4', 'e5')
result_37 = game.make_move('f4', 'd3')
result_38 = game.get_game_state()
final_result = (result_1, result_2, result_3, result_4, result_5,
result_6, result_7, result_8, result_9, result_10,
result_11, result_12, result_13, result_14, result_15,
result_16, result_17, result_18, result_19, result_20,
result_21, result_22, result_23, result_24, result_25,
result_26, result_27, result_28, result_29, result_30,
result_31, result_32, result_33, result_34, result_35,
result_36, result_37, result_38)
self.assertEqual(
final_result,
(True, True, True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True, True, True,
True, True, True, True, "BLACK_WON"))
def test_soldier_moves(self):
"""Tests all types of Soldier moves that are valid."""
game = XiangqiGame()
board = game.get_board()
board.clear_board()
board.get_point_with_pos("e1").set_piece(General("red"))
board.get_point_with_pos("d10").set_piece(General("black"))
board.get_point_with_pos("a4").set_piece(Soldier("red"))
board.get_point_with_pos("i7").set_piece(Soldier("black"))
# test can only move forward on own side
red_soldier_moves = game.get_valid_end_pos_array("a4", "S")
black_soldier_moves = game.get_valid_end_pos_array("i7", "S")
self.assertEqual(["a5"], red_soldier_moves)
self.assertEqual(["i6"], black_soldier_moves)
game.make_move("a4", "a5")
game.make_move("i7", "i6")
red_soldier_moves = game.get_valid_end_pos_array("a5", "S")
black_soldier_moves = game.get_valid_end_pos_array("i6", "S")
self.assertEqual(["a6"], red_soldier_moves)
self.assertEqual(["i5"], black_soldier_moves)
# test can move forward and sideways on opposing side
game.make_move("a5", "a6")
game.make_move("i6", "i5")
red_soldier_moves = game.get_valid_end_pos_array("a6", "S")
black_soldier_moves = game.get_valid_end_pos_array("i5", "S")
self.assertEqual(["b6", "a7"], red_soldier_moves)
self.assertEqual(["h5", "i4"], black_soldier_moves)
game.make_move("a6", "b6")
game.make_move("i5", "h5")
red_soldier_moves = game.get_valid_end_pos_array("b6", "S")
black_soldier_moves = game.get_valid_end_pos_array("h5", "S")
self.assertEqual(["c6", "a6", "b7"], red_soldier_moves)
self.assertEqual(["i5", "g5", "h4"], black_soldier_moves)
# test can only capture opposing color
board.get_point_with_pos("c6").set_piece(Soldier("red"))
board.get_point_with_pos("a6").set_piece(Soldier("black"))
board.get_point_with_pos("i5").set_piece(Soldier("red"))
board.get_point_with_pos("g5").set_piece(Soldier("black"))
red_soldier_moves = game.get_valid_end_pos_array("b6", "S")
black_soldier_moves = game.get_valid_end_pos_array("h5", "S")
self.assertEqual(["a6", "b7"], red_soldier_moves)
self.assertEqual(["i5", "h4"], black_soldier_moves)
def test_is_valid_move_horse(self):
game = XiangqiGame()
result_1 = game.is_valid_move_horse("b1", "a3")
result_2 = game.is_valid_move_horse("b1", "c3")
result_3 = game.is_valid_move_horse("b10", "c8")
result_4 = game.is_valid_move_horse("h10", "g8")
result_5 = game.is_valid_move_horse("h10", "i8")
result_6 = game.is_valid_move_horse("h1", "g3")
final_result = (result_1, result_2, result_3, result_4, result_5,
result_6)
self.assertEqual(final_result, (True, True, True, True, True, True))
def test_is_valid_move_chariot(self):
game = XiangqiGame()
result_1 = game.is_valid_move_chariot("a1", "a2")
result_2 = game.is_valid_move_chariot("a1", "a3")
result_3 = game.is_valid_move_chariot("i1", "i2")
result_4 = game.is_valid_move_chariot("a10", "a8")
result_5 = game.is_valid_move_chariot("a10", "a6")
result_6 = game.is_valid_move_chariot("i1", "i5")
final_result = (result_1, result_2, result_3, result_4, result_5,
result_6)
self.assertEqual(final_result, (True, True, True, True, False, False))
def test_is_valid_move_general(self):
game = XiangqiGame()
result_1 = game.is_valid_move_general("e1", "e2")
result_2 = game.is_valid_move_general("e1", "d1")
result_3 = game.is_valid_move_general("e1", "f1")
result_4 = game.is_valid_move_general("e10", "e9")
result_5 = game.is_valid_move_general("e10", "d10")
result_6 = game.is_valid_move_general("e10", "f10")
final_result = (result_1, result_2, result_3, result_4, result_5,
result_6)
self.assertEqual(final_result, (True, True, True, True, True, True))
def test_is_valid_move_cannon(self):
game = XiangqiGame()
result_1 = game.is_valid_move_cannon("b3", "b7")
result_2 = game.is_valid_move_cannon("h3", "e3")
result_3 = game.is_valid_move_cannon("b8", "d8")
result_4 = game.is_valid_move_cannon("h8", "h5")
result_5 = game.is_valid_move_cannon("h3", "a3")
result_6 = game.is_valid_move_cannon("b8", "b3")
final_result = (result_1, result_2, result_3, result_4, result_5,
result_6)
self.assertEqual(final_result, (True, True, True, True, False, False))
def test_checkmate_preventable(self):
"""
Tests that checkmate_preventable returns True if a move is possible that removes check from the player in check.
"""
game = XiangqiGame()
board = game.get_board()
board.clear_board()
board.get_point_with_pos("e1").set_piece(General("red"))
board.get_point_with_pos("d10").set_piece(General("black"))
# test red can prevent checkmate
self.assertEqual(True, game.checkmate_preventable())
game.make_move("e1", "e2")
# test black can prevent checkmate
self.assertEqual(True, game.checkmate_preventable())
game.make_move("d10", "d9")
# test black cant prevent checkmate
self.assertEqual(True, game.checkmate_preventable())
board.get_point_with_pos("d1").set_piece(Chariot("red"))
game.make_move("d1", "d2")
self.assertEqual(False, game.checkmate_preventable())
# test red cant prevent checkmate
game = XiangqiGame()
board = game.get_board()
board.clear_board()
board.get_point_with_pos("e1").set_piece(General("red"))
board.get_point_with_pos("d10").set_piece(General("black"))
board.get_point_with_pos("e10").set_piece(Chariot("black"))
board.get_point_with_pos("f10").set_piece(Chariot("black"))
self.assertEqual(False, game.checkmate_preventable())
def test_move_must_prevent_checkmate_if_in_check(self):
"""Tests that if player is in check, only moves that prevent checck are allowed."""
# test red must prevent checkmate
game = XiangqiGame()
board = game.get_board()
board.clear_board()
board.get_point_with_pos("f1").set_piece(General("red"))
board.get_point_with_pos("d10").set_piece(General("black"))
board.get_point_with_pos("e10").set_piece(Chariot("black"))
board.get_point_with_pos("i10").set_piece(Chariot("black"))
board.get_point_with_pos("a1").set_piece(Chariot("red"))
game.make_move("a1", "a2")
game.make_move("i10", "f10")
self.assertEqual(False, game.make_move("a2", "b2"))
self.assertEqual(False, game.make_move("f1", "e1"))
self.assertEqual(True, game.make_move("a2", "f2"))
# test black must prevent checkmate
game = XiangqiGame()
board = game.get_board()
board.clear_board()
board.get_point_with_pos("f1").set_piece(General("red"))
board.get_point_with_pos("d10").set_piece(General("black"))
board.get_point_with_pos("a9").set_piece(Chariot("black"))
board.get_point_with_pos("e4").set_piece(Chariot("red"))
board.get_point_with_pos("a2").set_piece(Chariot("red"))
game.make_move("a2", "d2")
self.assertEqual(False, game.make_move("d10", "d9"))
self.assertEqual(False, game.make_move("a9", "b9"))
self.assertEqual(True, game.make_move("a9", "d9"))
def test_black_wins_2(self):
game = XiangqiGame()
result_1 = game.make_move('b3', 'b10')
result_2 = game.make_move('a10', 'b10')
result_3 = game.make_move('h3', 'h10')
result_4 = game.make_move('i10', 'h10')
result_5 = game.make_move('a1', 'a3')
result_6 = game.make_move('b8', 'b6')
result_7 = game.make_move('a3', 'f3')
result_8 = game.make_move('b6', 'i6')
result_9 = game.get_game_state()
result_10 = game.is_in_check("red")
result_11 = game.is_in_check("black")
result_12 = game.make_move('f3', 'i3')
result_13 = game.make_move('i6', 'i3')
result_14 = game.make_move('h1', 'i3')
result_15 = game.make_move('b10', 'b1')
result_16 = game.make_move('d1', 'e2')
result_17 = game.make_move('b1', 'c1')
result_18 = game.make_move('e2', 'd1')
result_19 = game.make_move('c1', 'c4')
result_20 = game.make_move('a9', 'b8')
result_21 = game.make_move('g1', 'e3')
result_22 = game.make_move('c4', 'e4')
result_23 = game.get_game_state()
result_24 = game.make_move('i1', 'i2')
result_25 = game.make_move('e4', 'e3')
result_26 = game.is_in_check("red")
result_27 = game.is_in_check("black")
result_28 = game.make_move('d1', 'e2')
result_29 = game.make_move('h8', 'h1')
result_30 = game.get_game_state()
final_result = (result_1, result_2, result_3, result_4, result_5,
result_6, result_7, result_8, result_9, result_10,
result_11, result_12, result_13, result_14, result_15,
result_16, result_17, result_18, result_19, result_20,
result_21, result_22, result_23, result_24, result_25,
result_26, result_27, result_28, result_29, result_30)
self.assertEqual(
final_result,
(True, True, True, True, True, True, True, True, "UNFINISHED",
False, False, True, True, True, True, True, True, True, True,
False, True, True, "UNFINISHED", True, True, True, False, True,
True, "BLACK_WON"))
def test_general_moves(self):
"""Tests all types of General moves that are valid."""
game = XiangqiGame()
board = game.get_board()
board.clear_board()
board.get_point_with_pos("e1").set_piece(General("red"))
board.get_point_with_pos("d10").set_piece(General("black"))
# test flying general and cannot leave castle
red_general_moves = game.get_valid_end_pos_array("e1", "G")
black_general_moves = game.get_valid_end_pos_array("d10", "G")
self.assertEqual(["f1", "e2"], red_general_moves)
self.assertEqual(["d9"], black_general_moves)
game.make_move("e1", "e2")
game.make_move("d10", "d9")
red_general_moves = game.get_valid_end_pos_array("e2", "G")
black_general_moves = game.get_valid_end_pos_array("d9", "G")
self.assertEqual(["f2", "e3", "e1"], red_general_moves)
self.assertEqual(["d10", "d8"], black_general_moves)
game.make_move("e2", "e3")
game.make_move("d9", "d8")
red_general_moves = game.get_valid_end_pos_array("e3", "G")
black_general_moves = game.get_valid_end_pos_array("d8", "G")
self.assertEqual(["f3", "e2"], red_general_moves)
self.assertEqual(["d9"], black_general_moves)
# test can only capture opposing color pieces
board.get_point_with_pos("f3").set_piece(Advisor("red"))
board.get_point_with_pos("e2").set_piece(Soldier("black"))
red_general_moves = game.get_valid_end_pos_array("e3", "G")
self.assertEqual(["e2"], red_general_moves)
# test can have no moves
board.get_point_with_pos("e2").set_piece(Soldier("red"))
red_general_moves = game.get_valid_end_pos_array("e3", "G")
self.assertEqual([], red_general_moves)
def test_chariot_moves(self):
"""Tests all types of Chariot moves that are valid."""
game = XiangqiGame()
board = game.get_board()
board.clear_board()
board.get_point_with_pos("e1").set_piece(General("red"))
board.get_point_with_pos("d10").set_piece(General("black"))
board.get_point_with_pos("a1").set_piece(Chariot("red"))
board.get_point_with_pos("a10").set_piece(Chariot("black"))
# test can only capture opposing color and cannot jump
board.get_point_with_pos("a3").set_piece(Soldier("red"))
board.get_point_with_pos("a8").set_piece(Soldier("red"))
red_chariot_moves = game.get_valid_end_pos_array("a1", "R")
black_chariot_moves = game.get_valid_end_pos_array("a10", "R")
self.assertEqual(["b1", "c1", "d1", "a2"], red_chariot_moves)
self.assertEqual(["b10", "c10", "a9", "a8"], black_chariot_moves)
def test_horse_moves(self):
"""Tests all types of Horse moves that are valid."""
game = XiangqiGame()
board = game.get_board()
board.clear_board()
board.get_point_with_pos("e1").set_piece(General("red"))
board.get_point_with_pos("d10").set_piece(General("black"))
board.get_point_with_pos("b1").set_piece(Horse("red"))
board.get_point_with_pos("b10").set_piece(Horse("black"))
# test can only capture opposing color pieces
board.get_point_with_pos("c3").set_piece(Soldier("red"))
board.get_point_with_pos("c8").set_piece(Soldier("red"))
red_horse_moves = game.get_valid_end_pos_array("b1", "H")
black_horse_moves = game.get_valid_end_pos_array("b10", "H")
self.assertEqual(["d2", "a3"], red_horse_moves)
self.assertEqual(["a8", "c8", "d9"], black_horse_moves)
# test can be blocked
board.get_point_with_pos("c1").set_piece(Soldier("red"))
board.get_point_with_pos("c10").set_piece(Soldier("red"))
red_horse_moves = game.get_valid_end_pos_array("b1", "H")
black_horse_moves = game.get_valid_end_pos_array("b10", "H")
self.assertEqual(["a3"], red_horse_moves)
self.assertEqual(["a8", "c8"], black_horse_moves)
# test can have no moves
board.get_point_with_pos("b2").set_piece(Soldier("red"))
board.get_point_with_pos("b9").set_piece(Soldier("red"))
red_horse_moves = game.get_valid_end_pos_array("b1", "H")
black_horse_moves = game.get_valid_end_pos_array("b10", "H")
self.assertEqual([], red_horse_moves)
self.assertEqual([], black_horse_moves)
def test_red_wins_2(self):
game = XiangqiGame()
result_1 = game.make_move('b3', 'e3')
result_2 = game.make_move('h8', 'h9')
result_3 = game.make_move('h1', 'g3')
result_4 = game.make_move('g9', 'i7')
result_5 = game.get_game_state()
result_6 = game.make_move('h9', 'h5')
result_7 = game.make_move('b1', 'c3')
result_8 = game.make_move('h10', 'g8')
result_9 = game.make_move('a1', 'b1')
result_10 = game.get_game_state()
result_11 = game.make_move('g7', 'f5')
result_12 = game.make_move('h5', 'f5')
result_13 = game.make_move('b1', 'b8')
result_14 = game.make_move('e7', 'e6')
result_15 = game.make_move('e3', 'e6')
result_16 = game.make_move('d9', 'e8')
result_17 = game.make_move('f5', 'f6')
result_18 = game.make_move('h3', 'h5')
result_19 = game.get_game_state()
result_20 = game.make_move('g7', 'g6')
result_21 = game.make_move('h5', 'e5')
result_22 = game.is_in_check("red")
result_23 = game.is_in_check("black")
result_24 = game.get_game_state()
final_result = (result_1, result_2, result_3, result_4, result_5,
result_6, result_7, result_8, result_9, result_10,
result_11, result_12, result_13, result_14, result_15,
result_16, result_17, result_18, result_19, result_20,
result_21, result_22, result_23, result_24)
self.assertEqual(
final_result,
(True, True, True, False, "UNFINISHED", True, True, True, True,
"UNFINISHED", False, True, True, True, True, False, True, True,
"UNFINISHED", True, True, False, True, "RED_WON"))
from XiangqiGame import XiangqiGame
from XiangqiGame_single_module import XiangqiGame
from Board import Board
from Player import Player
from GeneralPiece import GeneralPiece
from ElephantPiece import ElephantPiece
from ChariotPiece import ChariotPiece
from SoldierPiece import SoldierPiece
from AdvisorPiece import AdvisorPiece
from HorsePiece import HorsePiece
from CannonPiece import CannonPiece
if __name__ == "__main__":
game = XiangqiGame()
board = game._board
red_pieces = game.get_player("red")._pieces
black_pieces = game.get_player("black")._pieces
# initialize empty board
board._board_state = [ # board state represented as a 2D array
[None for file in board._files]
for rank in board._ranks # initialize all positions to None
]
board._piece_state = {
} # dictionary of piece: pos pairs. When pieces are captured, value is set to None
for piece in black_pieces:
piece.set_pos(None)
for piece in red_pieces:
def setUp(self) -> None:
self.game = XiangqiGame()
self.game.new_game()
def test_cannon_moves(self):
"""Tests all types of Cannon moves that are valid."""
game = XiangqiGame()
board = game.get_board()
board.clear_board()
board.get_point_with_pos("e1").set_piece(General("red"))
board.get_point_with_pos("d10").set_piece(General("black"))
board.get_point_with_pos("b4").set_piece(Cannon("red"))
board.get_point_with_pos("b7").set_piece(Cannon("black"))
# test cannot capture own piece and must jump to capture
board.get_point_with_pos("b2").set_piece(Soldier("black"))
board.get_point_with_pos("b9").set_piece(Soldier("red"))
red_cannon_moves = game.get_valid_end_pos_array("b4", "C")
black_cannon_moves = game.get_valid_end_pos_array("b7", "C")
self.assertEqual(['c4', 'd4', 'e4', 'f4', 'g4', 'h4', 'i4', 'a4', 'b5', 'b6', 'b3'], red_cannon_moves)
self.assertEqual(['c7', 'd7', 'e7', 'f7', 'g7', 'h7', 'i7', 'a7', 'b8', 'b6', 'b5'], black_cannon_moves)
# test can capture opposing piece if jumping one piece of different color
board.get_point_with_pos("b2").set_piece(Soldier("red"))
board.get_point_with_pos("b9").set_piece(Soldier("black"))
red_cannon_moves = game.get_valid_end_pos_array("b4", "C")
black_cannon_moves = game.get_valid_end_pos_array("b7", "C")
self.assertEqual(['c4', 'd4', 'e4', 'f4', 'g4', 'h4', 'i4', 'a4', 'b5', 'b6', 'b9', 'b3'], red_cannon_moves)
self.assertEqual(['c7', 'd7', 'e7', 'f7', 'g7', 'h7', 'i7', 'a7', 'b8', 'b6', 'b5', 'b2'], black_cannon_moves)
# test cannot capture opposing piece if jumping more than two pieces
board.get_point_with_pos("b2").set_piece(Soldier("red"))
board.get_point_with_pos("b9").set_piece(Soldier("black"))
board.get_point_with_pos("b3").set_piece(Soldier("black"))
board.get_point_with_pos("b8").set_piece(Soldier("red"))
red_cannon_moves = game.get_valid_end_pos_array("b4", "C")
black_cannon_moves = game.get_valid_end_pos_array("b7", "C")
self.assertEqual(['c4', 'd4', 'e4', 'f4', 'g4', 'h4', 'i4', 'a4', 'b5', 'b6'], red_cannon_moves)
self.assertEqual(['c7', 'd7', 'e7', 'f7', 'g7', 'h7', 'i7', 'a7', 'b6', 'b5'], black_cannon_moves)
# test can capture opposing piece if jumping one piece of same color
board.get_point_with_pos("b3").set_piece(None)
board.get_point_with_pos("b8").set_piece(None)
board.get_point_with_pos("b4").set_piece(Cannon("black"))
black_cannon_moves = game.get_valid_end_pos_array("b7", "C")
self.assertEqual(['c7', 'd7', 'e7', 'f7', 'g7', 'h7', 'i7', 'a7', 'b8', 'b6', 'b5', 'b2'], black_cannon_moves)
board.get_point_with_pos("b4").set_piece(Cannon("red"))
board.get_point_with_pos("b7").set_piece(Cannon("red"))
red_cannon_moves = game.get_valid_end_pos_array("b4", "C")
self.assertEqual(['c4', 'd4', 'e4', 'f4', 'g4', 'h4', 'i4', 'a4', 'b5', 'b6', 'b9', 'b3'], red_cannon_moves)
board.get_point_with_pos("b7").set_piece(Cannon("black"))
def setUp(self):
self.game = XiangqiGame()
import unittest
from XiangqiGame import XiangqiGame
# 8 instances of the game board
test = XiangqiGame()
test2 = XiangqiGame()
test3 = XiangqiGame()
test4 = XiangqiGame()
test5 = XiangqiGame()
test6 = XiangqiGame()
test7 = XiangqiGame()
test8 = XiangqiGame()
test9 = XiangqiGame()
class ThirdXiangqiTest(unittest.TestCase):
def test_case_5(self):
'''check stalemate'''
test9.make_move('h3', 'h10')
test9.make_move('b8', 'b1')
test9.make_move('a1', 'b1')
test9.make_move('i10', 'h10')
test9.make_move('i1', 'i3')
test9.make_move('a10', 'a8')
test9.make_move('i3', 'h3')
test9.make_move('a8', 'b8')
test9.make_move('h3', 'h8')
test9.make_move('b8', 'b3')
test9.make_move('h8', 'h10')
test9.make_move('b3', 'b1')
test9.make_move('h10', 'g10')