예제 #1
0
class BattleshipCLI(Cmd):
    prompt = 'battleship> '
    intro = "{} \n Welcome to Battleship CLI! Type ? to list commands \n ".format(HEADER)

    logger = get_logger()

    ALL_SHIPS = list(Ship.get_ship_map().keys())
    ALL_ALIGMENTS = ShipPosition.ALL
    ALL_COLS = GameBoard.COLS_NAMES
    ALL_ROWS = GameBoard.ROWS_NAMES

    def do_exit(self, inp):
        '''exit the application.'''
        self.logger.info("Bye! Thanks for playing!")
        return True

    def do_basic(self, _):
        print(GAMEPLAY)

    def help_basic(self, _):
        print("Battleship Gameplay")

    def do_intro(self, _):
        print(INSTRUCTIONS)

    def help_intro(self, _):
        print("Battleship CLI Instructions.")

    def do_p1(self, name):
        if not name:
            self.logger.error("Name cannot be empty.".format(name))
            return None
        try:
            if str(self.player_2.name).lower() == str(name).lower():
                self.logger.error("Name '{}' already taken for the Player 2".format(name))
                return None
        except AttributeError:
            pass

        self.player_1 = Player(name=name)

    def help_p1(self):
        print("Set Player 1")

    def do_p2(self, name):
        if not name:
            self.logger.error("Name cannot be empty.".format(name))
            return None
        try:
            if str(self.player_1.name).lower() == str(name).lower():
                self.logger.error("Name '{}' already taken for the Player 1".format(name))
                return None
        except AttributeError:
            pass

        self.player_2 = Player(name=name)

    def help_p2(self):
        print("Set Player 2")

    def do_start(self, _):
        try:
            self.game = Game(
                player_1=self.player_1,
                player_2=self.player_2,
            )
        except AttributeError as exc:
            if 'player_1' in str(exc):
                self.logger.error("Game cannot start: You need to create the Player 1: p1 <name> .")

            elif 'player_2' in str(exc):
                self.logger.error("Game cannot start: You need to create the Player 2: p2 <name> .")

        except Exception as exc:
            self.logger.error("Error: {}".format(str(exc)))

    def help_start(self):
        print("Start game")

    def do_place_ship_p1(self, row_col_ship_aligment):
        row, col, ship, aligment = row_col_ship_aligment.split(' ')
        try:
            self.game.place_ships_for_player_1([
                ShipPosition(
                    row=row,
                    col=col,
                    ship=Ship.get_ship(ship),
                    aligment=ShipPosition.get_aligment(aligment)
                ),
            ])
        except AttributeError as exc:
            self.logger.error("Error: Game not started. Details: {}".format(str(exc)))
        except Exception as exc:
            self.logger.error("Error: {}".format(str(exc)))

    def help_place_ship_p1(self):
        print(
            (
                "Place ships for Player 1: Format: row col ship aligment "
                "Example: place_ship_p1 A 1 carrier h"
            )
        )

    def do_place_ship_p2(self, row_col_ship_aligment):
        row, col, ship, aligment = row_col_ship_aligment.split(' ')
        try:
            self.game.place_ships_for_player_2([
                ShipPosition(
                    row=row,
                    col=col,
                    ship=Ship.get_ship(ship),
                    aligment=ShipPosition.get_aligment(aligment)
                ),
            ])
        except AttributeError as exc:
            self.logger.error("Error: Game not started. Details: {}".format(str(exc)))
        except Exception as exc:
            self.logger.error("Error: {}".format(str(exc)))

    def help_place_ship_p2(self):
        print(
            (
                "Place ships for Player 2: Format: row col ship aligment "
                "Example: place_ship_p1 A 1 carrier h"
            )
        )

    def do_play(self, _):
        try:
            self.game.play()
        except AttributeError as exc:
            self.logger.error("Error: Game not started. Details: {}".format(str(exc)))
        except Exception as exc:
            self.logger.error("Error: {}".format(str(exc)))

    def help_play(self):
        print("Start shooting!")

    def do_shoot(self, row_col):
        row, col = row_col.split(' ')
        try:
            self.game.shoot(row, col)
        except AttributeError as exc:
            self.logger.error("Error: Game not started. Details: {}".format(str(exc)))
        except Exception as exc:
            self.logger.error("Error: {}".format(str(exc)))

    def help_shoot(self):
        print(
            (
                "Shoot ships according to the turn. Format: row col "
                "Example: shoot A 1"
            )
        )

    def do_ls(self, resource):
        resource_map = {
            'ships': self.ALL_SHIPS,
            's': self.ALL_SHIPS,
            'aligments': self.ALL_ALIGMENTS,
            'a': self.ALL_ALIGMENTS,
            'rows': self.ALL_ROWS,
            'r': self.ALL_ROWS,
            'cols': self.ALL_COLS,
            'c': self.ALL_COLS,
        }
        try:
            print(resource_map[str(resource).lower()])
        except KeyError as exc:
            self.logger.error("Resource not found: {}".format(str(exc)))
        except Exception as exc:
            self.logger.error("Error: {}".format(str(exc)))

    def help_ls(self):
        print(
            (
                "List resource: Format: ls <resource> "
                "Example: ls ships"
            )
        )

    def do_stats(self, _):
        try:
            self.game.display_stats()
        except AttributeError as exc:
            self.logger.error("Error: Game not started. Details: {}".format(str(exc)))
        except Exception as exc:
            self.logger.error("Error: {}".format(str(exc)))

    def help_stats(self):
        print("Display game stats")

    def do_restart(self, _):
        try:
            self.game.restart()
        except AttributeError as exc:
            self.logger.error("Error: Game not started. Details: {}".format(str(exc)))
        except Exception as exc:
            self.logger.error("Error: {}".format(str(exc)))

    def help_restart(self):
        print("Restart the game, Using the same players.")
예제 #2
0
def main():
    print("Starting the game")
    game = Game()
    game.play()
    print("Game Over")
예제 #3
0
파일: perf_test.py 프로젝트: sutt/exercises
def select_function(s_function):
    ''' input: s_function (string)
        output: [optional] usually a GameLog but really completely dynamic
        This string choses a way to:
             init Game(), param's for play(), possible return value.'''

    if s_function == "baseline":

        game = Game(s_instructions=ss)
        game.play(king_in_check_on=False)

    if s_function == "naive_check":

        game = Game(s_instructions=ss)
        game.play()

    if s_function == "test_copy":

        game = Game(s_instructions=ss)
        game.play(king_in_check_on=False, king_in_check_test_copy=True)

    if s_function == "test_copy_apply":

        game = Game(s_instructions=ss)
        game.play(king_in_check_on=False, king_in_check_test_copy_apply=True)

    if s_function == "test_c_apply_2":

        game = Game(s_instructions=ss)
        game.play(king_in_check_on=False, king_in_check_test_copy_apply_2=True)

    if s_function == "test_c_apply_3":

        game = Game(s_instructions=ss)
        game.play(king_in_check_on=False, king_in_check_test_copy_apply_3=True)

    if s_function == "test_c_apply_4":

        game = Game(s_instructions=ss)
        game.play(king_in_check_on=False, king_in_check_test_copy_apply_4=True)

    if s_function == "baseline_tt":

        game = Game(s_instructions=ss,
                    b_log_turn_time=True,
                    b_log_num_available=True)
        game.play(king_in_check_on=False)
        return game.get_gamelog()

    if s_function == "naive_check_tt":

        game = Game(s_instructions=ss,
                    b_log_turn_time=True,
                    b_log_num_available=True)
        game.play(king_in_check_on=True)
        return game.get_gamelog()

    if s_function == "baseline_long":

        game = Game(s_instructions=ss_long,
                    b_log_turn_time=True,
                    b_log_num_available=True)
        game.play(king_in_check_on=False)
        return game.get_gamelog()

    if s_function == "naive_long":

        game = Game(s_instructions=ss_long,
                    b_log_turn_time=True,
                    b_log_num_available=True)
        game.play(king_in_check_on=True)
        return game.get_gamelog()

    if s_function == "optimal1_long":

        game = Game(s_instructions=ss_long,
                    b_log_turn_time=True,
                    b_log_num_available=True)
        game.play(king_in_check_on=False, king_in_check_optimal=True)
        return game.get_gamelog()

    if s_function == "optimal2_long":

        game = Game(s_instructions=ss_long,
                    b_log_turn_time=True,
                    b_log_num_available=True)
        game.play(king_in_check_on=False, king_in_check_optimal_2=True)
        return game.get_gamelog()

    if s_function == "check_optimal":

        game = Game(s_instructions=ss)
        game.play(king_in_check_on=False, king_in_check_optimal=True)

    if s_function == "check_optimal_2":

        game = Game(s_instructions=ss)
        game.play(king_in_check_on=False, king_in_check_optimal_2=True)

    return None  #to show that the function is no returning a test exit data
예제 #4
0
    lose_count = 0
    draw_count = 0
    x_axis = []
    y_axis = []

    # Training iterations
    for i in range(0, iterations):

        if adjust_learn_rate == 1:
            p1.v.set_learn_rate(1 - i / iterations)

        printIteration(i, p1.v.get_est_function(), p1.v.get_learn_rate())

        # Step 1: Create new game, p1 VS p2
        g = Game()
        boards = g.play(op, False, p1, p2)
        board_features = []

        # Step 2: Generate features for every board in the game
        for board in boards:
            board_features.append(f.get_features(board))

        # Step 3: Using current Vop from p, estimates values for every board in the game
        train_values = p1.v.assign_train_value(board_features)

        # Step Aux: Assign values to statistics
        (b, vtrain) = train_values[-1]
        if vtrain == 1:
            win_count = win_count + 1
        elif vtrain == -1:
            lose_count = lose_count + 1
예제 #5
0
파일: run.py 프로젝트: sutt/exercises
    run_type = str(sys.argv[1])
print '\nRunning: ', run_type, '\n'

# run_type = 'randomplay2'    #for debugging
# run_type = 'replay'    #for debugging
# run_type = 'manyrandom'    #for debugging

if run_type == "interactive":

    ''' Interactive Mode '''

    game = Game(manual_control = (1,0)
                    ,b_display_show_opponent = True
                    ,b_log_move = True
                    )
    game.play()


elif run_type == "randomplay":
    
    game = Game(manual_control = ()
                ,b_display_never_print = True
                ,b_log_move = False
                ,test_exit_moves = 1000
                )
    
    ret = game.play()
    
    if game.i_turn == 1000:
        print '1000 turn game'
    else:
예제 #6
0
class Rummy(tk.Tk):
    def __init__(self):
        super(Rummy, self).__init__()

        # Initialise a game

        self.game = Game()
        # Member Variables
        self.number = tk.IntVar(self)
        self.number.set(VALID_NUMBERS[0])
        self.colour = tk.StringVar(self)
        self.colour.set(VALID_COLOURS[0])
        self.title_size = 14
        # window dimensions
        self.geometry("1000x500")

        # Create title
        self.title("Rummy-O Calculator")

        # Create Menus
        root_menu = tk.Menu(self)
        self.config(menu=root_menu)

        file_menu = tk.Menu(root_menu)
        root_menu.add_cascade(label="File", menu=file_menu)
        file_menu.add_command(label="Reset Game", command=self.reset_game)
        file_menu.add_command(label="Refresh Screen", command=self.refresh)
        file_menu.add_command(label="Test Mode", command=self.test_mode)
        file_menu.add_command(label="Exit", command=self.quit)

        help_menu = tk.Menu(root_menu)
        root_menu.add_cascade(label="Help", menu=help_menu)
        help_menu.add_command(label="Open Instructions",
                              command=self.open_instructions)

        # Create Main Frames
        self.left_frame = tk.Frame(self, height=500)
        self.left_frame.pack(side=tk.LEFT, fill=tk.Y)

        self.right_frame = tk.Frame(self)
        self.right_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)

        ## Left side of the screen

        self.l1 = tk.Frame(self.left_frame,
                           height=150,
                           width=500,
                           highlightbackground="black",
                           highlightthickness=2)
        self.l1.pack(side=tk.TOP, anchor=tk.N, fill=tk.X)

        self.l2 = tk.Frame(self.left_frame, height=150, width=500)
        self.l2.pack(side=tk.TOP, anchor=tk.N, expand=True, fill=tk.BOTH)

        self.l3 = tk.Frame(self.left_frame, height=200, width=500)
        self.l3.pack(fill=tk.Y, expand=True)

        self.l1_left = tk.Frame(self.l1, height=150, width=300)
        self.l1_left.pack(side=tk.LEFT, fill=tk.X)

        self.l1_right = tk.Frame(self.l1, height=150, width=200)
        self.l1_right.pack(side=tk.LEFT, fill=tk.X, padx=10)

        # Frames for the Labels

        self.l1_left_left = tk.Frame(self.l1_left,
                                     height=150,
                                     width=100,
                                     padx=20)
        self.l1_left_left.pack(side=tk.LEFT)

        self.number_label = tk.Label(self.l1_left_left,
                                     text="Tile Number",
                                     font=("Helvetica", self.title_size))
        self.number_label.pack(side=tk.TOP)
        self.choose_number = tk.OptionMenu(self.l1_left_left, self.number,
                                           *VALID_NUMBERS)
        self.choose_number.config(width=10)
        self.choose_number.pack(side=tk.TOP)

        self.l1_left_right = tk.Frame(self.l1_left,
                                      height=150,
                                      width=100,
                                      padx=20)
        self.l1_left_right.pack(side=tk.LEFT)

        self.number_label = tk.Label(self.l1_left_right,
                                     text="Tile Colour",
                                     font=("Helvetica", self.title_size))
        self.number_label.pack(side=tk.TOP)
        self.choose_number = tk.OptionMenu(self.l1_left_right, self.colour,
                                           *VALID_COLOURS)
        self.choose_number.config(width=10)
        self.choose_number.pack(side=tk.LEFT)

        # Add the buttons to the right side of l1

        self.add_board_button = tk.Button(self.l1_right,
                                          text="Add to Board",
                                          font=("Helvetica", 12),
                                          command=self.add_to_board)
        self.add_board_button.pack(fill=tk.X, pady=5, expand=True)
        self.draw_button = tk.Button(self.l1_right,
                                     text="Add to Hand",
                                     command=self.draw,
                                     font=("Helvetica", 12))
        self.draw_button.pack(fill=tk.X, expand=True)
        self.play_button = tk.Button(self.l1_right,
                                     text="Play From Hand",
                                     command=self.play,
                                     font=("Helvetica", 12))
        self.play_button.pack(fill=tk.X, pady=5, expand=True)

        # Add row for remove from board

        self.l21 = tk.Frame(self.l1)
        self.l21.pack(side=tk.LEFT)

        self.remove_from_board_button = tk.Button(
            self.l21,
            text="Remove from Board",
            command=self.remove_from_board,
            font=("Helvetica", 12))
        self.remove_from_board_button.pack(padx=10, pady=10)
        self.remove_from_hand_button = tk.Button(self.l21,
                                                 text="Remove from "
                                                 "Hand",
                                                 command=self.remove_from_hand,
                                                 font=("Helvetica", 12))
        self.remove_from_hand_button.pack(padx=10, pady=10)

        # Players Hand Text

        self.players_hand_title = tk.Label(self.l2,
                                           text="Player's Hand",
                                           font=("Helvetica", self.title_size))
        self.players_hand_title.pack(fill=tk.X)
        self.players_hand = tk.Text(self.l2, height=3)
        self.players_hand.pack(fill=tk.BOTH, expand=True)

        # Board Text

        self.board_title = tk.Label(self.l3,
                                    text="Tiles on the Board",
                                    font=("Helvetica", self.title_size))
        self.board_title.pack(fill=tk.X)
        self.board = tk.Text(self.l3, height=5)
        self.board.pack(fill=tk.BOTH, expand=True)

        # Right side of the board

        self.r1 = tk.Frame(self.right_frame)
        self.r1.pack(fill=tk.X)

        self.r11 = tk.Frame(self.r1)
        self.r11.pack()

        # Best Move and possible moves
        self.best_move_button = tk.Button(self.r11,
                                          text="Best Move",
                                          command=self.best_move,
                                          font=("Helvetica", 12))
        self.best_move_button.pack(side=tk.LEFT, padx=10, pady=10)
        self.possible_sets_button = tk.Button(self.r11,
                                              text="All Possible "
                                              "Sets",
                                              command=self.best_move,
                                              font=("Helvetica", 12))
        self.possible_sets_button.pack(side=tk.LEFT, padx=10, pady=10)

        # Set Instructions
        self.set_instructions_title = tk.Label(self.right_frame,
                                               text="Set "
                                               "Instructions",
                                               font=("Helvetica",
                                                     self.title_size))
        self.set_instructions_title.pack(fill=tk.X)
        self.set_instructions = tk.Text(self.right_frame, height=5)
        self.set_instructions.pack(fill=tk.BOTH, expand=True)

        # Test mode buttons
        self.random_board_tile = tk.Button(self.l21,
                                           text="Rnd Tile Board",
                                           command=self.add_random_tile_board,
                                           font=("Helvetica", 12))
        self.random_player_tile = tk.Button(
            self.l21,
            text="Rnd Tile Player",
            command=self.add_random_tile_player,
            font=("Helvetica", 12))

        # Refresh all the screens for any pre-existing tiles
        self.refresh()

    def reset_game(self):
        """Resets the game. Nothing on the board and nothing in the players
        hand"""
        self.game = Game()
        self.refresh()

    @staticmethod
    def open_instructions():
        """Opens up the github page with the instructions for the program"""
        webbrowser.open('https://github.com/sbrn3/Rummy-O-Calculator')

    def add_to_board(self):
        """Adds the currently selected number and colour as a tile to the 
        board"""
        self.game.add_to_board(self.colour.get(), self.number.get())
        self.refresh()

    def draw(self):
        """Adds the currently input tile to the player's hand"""
        self.game.draw(self.colour.get(), self.number.get())
        self.refresh()

    def play(self):
        """Removes the tile from the players hand and adds it to the board"""
        self.game.play(self.colour.get(), self.number.get())
        self.refresh()

    def remove_from_board(self):
        """Removes the specified tile from the board"""
        self.game.remove_from_board(self.colour.get(), self.number.get())
        self.refresh()

    def remove_from_hand(self):
        self.game.remove_from_hand(self.colour.get(), self.number.get())
        self.refresh()

    def update_hand(self):
        hand = str(self.game.view_hand()).replace("[", "").replace("]", "")
        print("Hand: {0}".format(hand))
        self.players_hand.config(state=tk.NORMAL)
        self.players_hand.delete(1.0, tk.END)
        self.players_hand.insert(tk.END, hand)
        self.players_hand.config(state=tk.DISABLED)

    def update_board(self):
        hand = str(self.game.view_board()).replace("[", "").replace("]", "")
        self.board.config(state=tk.NORMAL)
        self.board.delete(1.0, tk.END)
        self.board.insert(tk.END, hand)
        self.board.config(state=tk.DISABLED)

    def refresh(self):
        print("Screen refreshed")
        self.update_board()
        self.update_hand()

    def loading(self):
        self.set_instructions.config(state=tk.NORMAL)
        self.set_instructions.delete(1.0, tk.END)
        self.set_instructions.insert(tk.END, "Loading.....")
        self.set_instructions.config(state=tk.DISABLED)

    def best_move(self):
        self.loading()
        try:
            hand, sets = self.game.best_move()
            output = "Tiles from hand:\n{0}\n".format(hand)
            output += "Form the following sets:\n"
            for i in range(len(sets)):
                output += str(sets[i])
                if i == len(sets) - 1:
                    continue
                else:
                    output += "\n"
        except TypeError:
            output = "There are no options. Draw a piece from the deck."

        self.set_instructions.config(state=tk.NORMAL)
        self.set_instructions.delete(1.0, tk.END)
        self.set_instructions.insert(tk.END, output)
        self.set_instructions.config(state=tk.DISABLED)

    def possible_sets(self):
        pass

    def test_mode(self):
        self.random_board_tile.pack()
        self.random_player_tile.pack()

        # Add test tiles to board
        self.game.add_to_board("black", 1)
        self.game.add_to_board("black", 2)
        self.game.add_to_board("black", 3)
        self.game.add_to_board("black", 7)
        self.game.add_to_board("red", 7)
        self.game.add_to_board("blue", 7)

        self.refresh()

    def add_random_tile_board(self):
        self.game.add_to_board(self.game.generate_random_tile())
        self.refresh()

    def add_random_tile_player(self):
        self.game.draw(self.game.generate_random_tile())
        self.refresh()