CS4386 Assignment 1 (Semester B, 2022-2023)

Name: LUO Peiyuan SID: 56642728

0. GAME DESCRIPTION

Wolves Eats Sheep is a folk board game from China, each player can only choose one role (one wolf or one sheep) to play in one round.

0.1 Chessboard

The chessboard has totally 5 ∗ 5 = 25 squares.

And it is divided into two parties: Sheep side: There are ten chess pieces called sheep. Wolf side: There are two chess pieces called wolves. The initial chessboard layout is shown in the figure 1 below:

0.2 Rules

Order: Wolves first, sheep second, then the game obeys this order iteratively until one of them wins. In a round, Wolves must choose a valid step or an eating step, and the sheep must choose a valid step.

A valid step: Both wolves or sheep can take one step on their turn to an empty square (from the current position to a nearby position. Only front, back, left, and right are legal directions, others are illegal. Also, please notice the chess bound.). Here are two examples (figure 2, 3):

Eating: Wolves can eat sheep when they are separated by only one empty square and in a

straight line (Only front, back, left, and right are legal directions, others are illegal). (e.g. figure 4,5). After eating, the eaten sheep will not appear on the board.

Besieging: In the same time, sheep can besiege wolves, which means wolves cannot find a legal step in their turn. For example, the wolf on the right top (Figure 6) is trapped by sheep (In this situation, the trapped wolf cannot move because there is no empty square for this wolf to walk.).

0.3 How to win?

For Wolves: All sheep are eaten or the resting sheep cannot trap them in finite steps (less or equal to two, figure 7 show the winning of wolves).

For sheep: All wolves are trapped and cannot move. (as shown in figure 8)

1. Utility Functions

1.1 Board Class

This class stores some utility function related to the game board checking as follows. And each board object stores the current player of the board, state matrix, and winner of this board(if applicable).

class Board:
    def __init__(self, player, state):

    def update_winner(self, winner):

    def makeMove(self, move):

    def currentPlayer(self):

    def check_total_distance_from_sheep_to_wolf(self):

    def check_num_of_ways_wolf_trapped_and_num_of_wolf_trapped(self):

    def check_num_of_sheep_and_num_of_to_be_killed(self):
        
    @staticmethod
    def calculate_shortened_distance_by_current_move(org_board, cur_board):
        
    def calculate_sheep_scores(self, num_of_sheep_killed, shortened_distance, num_of_trapped_ways, trapped_wolf_num,num_of_to_be_killed_sheep):
        def calculate_trapped_scores(num):
            
    def calculate_wolf_scores(self,num_of_sheep_killed, shorten_distance_from_sheep_to_wolf, num_of_trapped_ways, org_board,num_of_to_be_killed_sheep):
        
    def check_wolf_trapped_in_this_way(self, i, j):
        
    def game_ends(self):
        
    def getWolfMoves(self):
        
    def getSheepMoves(self):
       
    def evaluate(self, player, gameEnds, org_board):

1.2 makeMove function

This method would take the move as input, change the game state, update the next player and return a new board object.

def makeMove(self, move):
    '''
    This method would take the move as input, change the game state, update the next player and return a new board object.
    '''
    [start_row, start_col, end_row, end_col] = move
    matrix2 = copy.deepcopy(self.state)
    matrix2[end_row, end_col] = self.player
    matrix2[start_row, start_col] = 0
    nextPlayer = 2 if self.player == 1 else 2
    return Board(nextPlayer, matrix2)