Example #1
0
    def mainMenu(self):
        self.header("Minesweeper")

        inputTool = InputTool({"2": "Play", "3": "Help", "4": "Settings", "5": "High Scores", "6": "Exit"})
        self.screen = inputTool.getInput()

        # set up and reset the game
        if (self.screen == "2"):
            self.firstTurn = True

            if (self.difficulty == "1"):
                self.num_rows = 9
                self.num_cols = 9
                self.num_mines = 10
                self.mines_remaining = 10
            elif (self.difficulty == "2"):
                self.num_rows = 12
                self.num_cols = 12
                self.num_mines = 24
                self.mines_remaining = 24
            elif (self.difficulty == "3"):
                self.num_rows = 16
                self.num_cols = 16
                self.num_mines = 40
                self.mines_remaining = 40

            self.game_board = GameBoard(self.num_rows, self.num_cols, self.num_mines)
            self.game_board.createBoard()
            self.game_board.placeMines()
            self.game_board.fillBoard()

            self.start_time = time.time()
Example #2
0
	def test_adding_piece_to_full_column_shoul_throw(self):
		g = GameBoard()

		while not g.column_full(3):
			g.add_piece(0, 3)

		self.assertRaises(IndexError, lambda: g.add_piece(0, 3))
Example #3
0
    def __init__(self):

        self.mw = tkinter.Tk()
        self._board = []

        self.default_image = tkinter.PhotoImage(file="empty2.gif")

        self.default_image_r = tkinter.PhotoImage(file="Red2.gif")
        self.default_image_y = tkinter.PhotoImage(file="Yellow2.gif")

        self.size = 7
        self.buttons_2d_list = []
        for i in range(self.size):
            self.row = [' '] * self.size
            self.buttons_2d_list.append(self.row)

        self.gboard = GameBoard(6)

        p1 = ComputerPlayer(
            "Y", self.buttons_2d_list
        )  #no input required from user, p1 and p2 are computer players, with given colours
        p2 = ComputerPlayer("R", self.buttons_2d_list)

        print("\tCLCIK ON ANY BUTTON ON THE GRID TO START"
              )  #the user must click on any button to start the sim

        self.players_lst = (p1, p2)
        self.currnt_player_index = 0
        self.winner = False
Example #4
0
 def __init__(self, method):
     super().__init__()
     self.cart_items = QLabel()
     self.ga_info = QLabel()
     self.table = GameBoard(20, 20, self, method)
     self.setLayout(self.init_ui())
     self.showMaximized()
Example #5
0
    def __init__(self):
        root = tk.Tk()
        root.title("Schaken")

        self.game = Game(root)
        self.game.setStartBoard()
        # self.game.setEnPassantBoard()
        # self.game.setRokadeBoard()
        # self.game.setCheckBoard()
        # self.game.setCheckmateBoard()
        # self.game.setPawnBoard()
        # self.game.setRookBoard()
        # self.game.setKnightBoard()
        # self.game.setBishopBoard()
        # self.game.setQueenBoard()
        # self.game.setKingBoard()
        # self.game.setPromoteBoard()

        board = GameBoard(root, self.game)
        board.pack(side="top", fill="both", expand="true", padx=4, pady=4)
        root.mainloop()

        # for piece in self.game.whitePiecesInGame + self.game.blackPiecesInGame:
        # for piece in self.game.blackPiecesInGame:
        # for piece in self.game.whitePiecesInGame:
        # if isinstance(piece, Rook):
        # 	print("--------")
        # r,c = self.game.getCurrentPosOfPiece(piece)
        # print("(r,c)=",(r,c))
        # print("possibleMoves=", piece.possibleMoves(r,c))
        # print("legalMovesAndNotBlockedInPath=", piece.legalMovesAndNotBlockedInPath((r,c), None, self.game.board))
        # print("takeableMoves=", piece.takeableMoves((r,c), None, self.game.board))
Example #6
0
 def make_move_ai(self, board):
     best_move = -1, -1
     if self.val == "O":
         best_val = -1000
         for cols in range(3):
             for rows in range(3):
                 if board.isValidMove(cols, rows):
                     temp_board = GameBoard()
                     temp_board.board = copy.deepcopy(board.board)
                     temp_board.playpiece(cols, rows, self.val)
                     move_val = self.minimax(temp_board, 0, False)
                     if move_val > best_val:
                         best_val = move_val
                         best_move = cols, rows
     else:
         best_val = 1000
         for cols in range(3):
             for rows in range(3):
                 if board.isValidMove(cols, rows):
                     temp_board = GameBoard()
                     temp_board.board = copy.deepcopy(board.board)
                     temp_board.playpiece(cols, rows, self.val)
                     move_val = self.minimax(temp_board, 0, True)
                     if move_val < best_val:
                         best_val = move_val
                         best_move = cols, rows
     print("Player " + self.val + ": Minimax Score = " + str(best_val) +
           " - Optimal move = " + str(best_move))
     board.playpiece(best_move[0], best_move[1], self.val)
Example #7
0
    def __init__(self,
                 players,
                 display=True,
                 bot_time_limit_ms=5000,
                 disable_time_limit=False,
                 pieces=None,
                 cols=7,
                 rows=17):
        self.display = display

        self._running = True
        self._display_surf = None
        self.size = self.weight, self.height = 640, 400
        self.bot_time_limit = bot_time_limit_ms
        self.disable_time_limit = disable_time_limit

        self.hex_radius = 20
        self.hex_size = hex_coords.Point(self.hex_radius, self.hex_radius)

        self.piece_radius = 9

        self.layout = Layout(hex_coords.layout_flat, self.hex_size,
                             hex_coords.Point(50, 50))

        self.controllers = []
        for i in range(len(players)):
            p = players[i]
            if p == PlayerType.HUMAN:
                self.controllers.append(None)
            elif p == PlayerType.RANDOM:
                from bots.randombot import RandomBot
                self.controllers.append(RandomBot())
            elif p == PlayerType.TRIVIAL_MCTS:
                from bots.trivial_mcts import MctsPlayer
                self.controllers.append(MctsPlayer(i, bot_time_limit_ms))
            elif p == PlayerType.EBL_MCTS:
                import bots.ebl_mcts as ebl_mcts
                self.controllers.append(ebl_mcts.Player(i))
            elif p == PlayerType.K2BD_MCTS:
                from bots.k2bd_mcts import KevBot
                self.controllers.append(KevBot(i, bot_time_limit_ms))
            elif p == PlayerType.MJ:
                from bots.mj import PengWin
                self.controllers.append(PengWin(i, bot_time_limit_ms))
            elif p == PlayerType.WARIO:
                from bots.wariobot import WarioBot
                self.controllers.append(WarioBot(i))

        self.board = GameBoard(len(players),
                               pieces=pieces,
                               cols=cols,
                               rows=rows)

        self.pending_action = None

        self.score_pos = (300, 30)
        self.score_spacing = 30

        self.selected_piece = None
Example #8
0
	def test_getting_the_piece_at_a_given_location(self):
		g = GameBoard()

		g.add_piece(0, 3)
		g.add_piece(1, 4)

		self.assertEquals(g.get_piece_at(3,0), 0)
		self.assertEquals(g.get_piece_at(4,0), 1)
		self.assertEquals(g.get_piece_at(5,0), None)
Example #9
0
 def initGameObjects(self):
     self.prevGameState = self.gameState
     self.inp = Input()
     self.gameBoard = GameBoard(self)
     self.shipMan = ShipManager(self.screen, GameBoard.BOTTOM)
     self.hitMan = HitManager(self.screen)
     self.opponent = Opponent(self.screen, OpponentType.AI)
     self.helpergui = Helpergui(self)
     self.sound = Sound(self.screen)
Example #10
0
def two_players_menu():
    player1 = input("Enter player 1's name: ")
    player2 = input("Enter player 2's name: ")
    gameboard1 = GameBoard(player1)
    gameboard2 = GameBoard(player2)
    setUpMenu(gameboard1, gameboard2)
    gameboard1_attack = GameBoard(player1)
    gameboard2_attack = GameBoard(player2)
    attackPhaseMenu(False, gameboard1, gameboard2, gameboard1_attack,
                    gameboard2_attack)
    os.system('clear')
    print("Winner: " + winner)
def performanceSystem(first_strategy, board=None, 
                      second_strategy=DEFAULT_STRATEGY):
  if not board:
		board = GameBoard()
  i = len(board.trace)
	while not board.gameEnded():
		player, strategy = GameBoard.X, second_strategy
		if i % 2:
			player, strategy = GameBoard.O, first_strategy
		x, y = board.chooseMove(strategy, player)
		board.addMove(player, x, y)
		i += 1
Example #12
0
    def __init__(self):

        self.mw = tkinter.Tk(
        )  #assigning the GUI method Tk to variable self.mw

        # default image = black hole/empty space
        self.default_image = tkinter.PhotoImage(
            file="empty2.gif"
        )  #all buttons will start with this deafult image when game starts and need to make instance so tkinter does keeps image
        # red and yellow represent the disc colours
        self.default_image_r = tkinter.PhotoImage(
            file="Red2.gif"
        )  #IMPORTANT TO MAKE INSTANCE OF ALL IMAGES IN __INIT__ METHOD TO PREVENT IMAGES FROM DISAPPAERING
        self.default_image_y = tkinter.PhotoImage(file="Yellow2.gif")

        self.size = 7
        self.buttons_2d_list = []
        for i in range(self.size):
            self.row = [' '] * self.size
            self.buttons_2d_list.append(
                self.row
            )  #creating a button list in order to configure mechanics of the game nad game GUI

        self.gboard = GameBoard(6)  #gameboard reference

        print("\tYELLOW or RED")
        colour = input("Please Select Your Colour(y/r): "
                       )  #giving user option to select colour
        colour = colour.lower()
        if colour == "y":
            p1 = HumanPlayer("Y")  #assigning colours to variables p1 and p2
            p2 = ComputerPlayer("R", self.buttons_2d_list)
            opnt = input("\t Do you want to play against a computer(y/n)? ")
            if opnt == "y":
                p2 = ComputerPlayer("R", self.buttons_2d_list)

            else:
                p2 = HumanPlayer("R")

        else:
            p1 = HumanPlayer("R")
            p2 = ComputerPlayer("Y", self.buttons_2d_list)
            opnt = input("\t Do you want to play against a computer(y/n)? ")
            if opnt == "y":
                p2 = ComputerPlayer("Y", self.buttons_2d_list)

            else:
                p2 = HumanPlayer("Y")

        self.players_lst = (p1, p2)  # creating a list of the players
        self.currnt_player_index = 0  #initilise the current player to zero
        self.winner = False  #initilise winner to false
Example #13
0
 def testWidth(self):
     
     self.input_file = os.path.join('./Test_Files/', 'Wrong Size.txt')
     
     gb = GameBoard()
     
     raised = False
     try:
         game = gb.readMapData(self.input_file)
     except CorruptedMapFileError:
         raised = True
     
     self.assertTrue(raised, 'Exception raised')
Example #14
0
 def initVars(self):
     self.winner = False
     self.tie = False
     self.first_player = self.LETTERS[randint(0, 1)]
     self.last_player = None
     self.turn_nr = 0
     self.board = GameBoard()
     kwargs = {
         'difficulty': self.difficulty,
         'board': self.board,
         'letter': self.pc_letter,
         'user_letter': self.user_letter
     }
     self.pc_player = PCPlayer(**kwargs)
Example #15
0
 def start_new_game(self):
     """
     Initialisation of the game.
     Prints introduction.
     Asks about being first player.
     """
     # Game introduction
     print('Tic-Tac-Toe!')
     self._player_first = input("Do you want to be the first player? (Y/N): "
                                ).strip().upper() == 'Y'
     self._player_char = self.CHARS[not self._player_first]
     print('Your char is: {}'.format(self._player_char))
     self._computer_char = self.CHARS[self._player_first]
     self._board = GameBoard()
Example #16
0
def main():

    # create a game board - with randomized colors (rgby)
    gb = GameBoard(NUM_OF_ROWS_COLUMNS, GAME_COLORS, COLORS_COLOR)

    steps_played = 0

    print("Welcome to the Coloring Game!")
    print(
        f"Please enter one of the possible colors to play this game: {GAME_COLORS}"
    )
    gb.print_board()

    # start listening on inputs from the user (the actual game)
    print(f"Available game colors: {GAME_COLORS}")
    print(f"Please select a color:")
    for line in sys.stdin:

        # game over if played too many steps
        if steps_played == ALLOWED_STEPS:
            print(
                f'Game over! Unfortunately you ran out of steps. (Allowed steps: {ALLOWED_STEPS})'
            )
            break

        steps_played += 1

        # remove the newline char from the input line
        line = line[:-1]

        # when quit/q - exit game
        if line in ["quit", "q"]:
            print("Exiting game!")
            return

        # when input is a color - paint the board accordingly
        if line in GAME_COLORS:

            # color with the selected color
            gb.color(line)

        if gb.is_game_finished():
            print("Congratulations! you finished the game")
            break

        # TODO: add an option to retry

        print("Current game board:")
        gb.print_board()

        print(
            f"Please select the next color: (Remaining steps: {ALLOWED_STEPS - steps_played})"
        )

    print("Goodbye! Hope to see you back soon!")
def experimentGenerator():
	"""returns random board with 2 pieces already on it"""
	board = GameBoard()
	x, y = choice(board.possibleMoves())
	board.addMove(GameBoard.O, x, y)
	x, y = choice(board.possibleMoves())
	board.addMove(GameBoard.X, x, y)
	return board
Example #18
0
def main():
    args = greeting()
    initialBoard = getFromFile(args.infile)

    print "You entered:\n\r"

    printBoard(initialBoard)

    g = GameBoard(initialBoard, args.toroidal)
    g.simulate(args.num_generations)

    print "\n\rAfter " + str(args.num_generations)\
        + " generations, the board will look like:\n\r"

    printBoard(g.board)
Example #19
0
    def __init__(self, colour, buttns_list):
        Player.__init__(self, colour)
        self.buttons_2d_list = buttns_list
        self.name = "Computer Player"
        self.__space = ' '

        self.gboard = GameBoard(6)
Example #20
0
def main():
    gb = GameBoard(3, 3)
    player_2 = AI()
    player_2.move(gb)
    player_2.move(gb)

    print gb.position
Example #21
0
def test_horizontal():
    """ Validate the rows members match what are in the data matrix. """
    g = GameBoard(width=5, height=5)
    for row in g.rows:
        # Convert the search string back into a list of characters
        row_list = list(row)
        assert row_list in g.data
Example #22
0
    def start(self):
        self.screen = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT), MODE)
        self.gameboard = GameBoard((GAME_SIZE, GAME_SIZE), self)
        self.scoreboard = ScoreBoard((WINDOW_WIDTH - GAME_SIZE, WINDOW_HEIGHT), self.score_manager)
        self.topmenu = TopMenu((GAME_SIZE, WINDOW_HEIGHT - GAME_SIZE))
        self.mainmenu = MainMenu((WINDOW_WIDTH, WINDOW_HEIGHT), self)
        self.gameovermenu = GameOverMenu((WINDOW_WIDTH, WINDOW_HEIGHT), self)

        while not self.done:
            key = pygame.key.get_pressed()
            left, right = self._get_movement(key)

            #if key[pygame.K_ESCAPE]:
            #    self.done = True

            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.done = True

            if self.state == GameState.Running:
                self._tick(left, right)
            elif self.state == GameState.MainMenu:
                self._main_menu_tick(left, right)
            elif self.state == GameState.GameOver:
                self._game_over_tick()


            pygame.display.flip()

            self.time_passed = self.clock.tick(FPS)

        pygame.quit()
Example #23
0
    def __init__(self):

        self.mw = tkinter.Tk()

        self.size = 3
        self.buttons_2d_list = []
        for i in range(self.size):
            self.row = [' '] * self.size
            self.buttons_2d_list.append(self.row)

        # place players 1 and 2 in tuple for turn based game.
        self.gboard = GameBoard(3)
        p1 = HumanPlayer("X")
        p2 = ComputerPlayer("O", self.buttons_2d_list)

        self.players_lst = (p1, p2)
        self.currnt_player_index = 0
        self.winner = False
Example #24
0
def traverse_by_cols():
    gb = GameBoard.get_board()
    max_rows = gb.get_row_count()
    max_cols = gb.get_column_count()

    for c in range(max_cols):
        for r in range(max_rows):
            cell = gb.get_cell(r,c)
            __blink_cell(cell)
Example #25
0
def __change_labels(label):
    gb = GameBoard.get_board()
    max_rows = gb.get_row_count()
    max_cols = gb.get_column_count()

    for r in range(max_rows):
        for c in range(max_cols):
            cell = gb.get_cell(r, c)
            cell.set_label(label)
Example #26
0
    def __init__(self, ship_owner, bomb_owner, board_size):
        #receive all data from the match
        self.board = GameBoard(board_size).set_up_board()
        self.ship_owner = ship_owner
        self.bomb_owner = bomb_owner

        self.ship_positions = ship_owner.board_positions
        self.bombs_positions = bomb_owner.bomb_position
        self.plot_ship()
 def __init__(self, mode, difficulty, screen, menu):
     self.mode = mode
     self.screen = screen
     self.current_player = None #x always goes first
     self.player = None    
     self.pc = None
     self.menu = menu
     self.gameBoard = GameBoard()
     self.AI = MoveGenerator(difficulty)
Example #28
0
    def game(self, stdscr):
        ''' Actual game'''

        self.level = GameBoard(self.screen_size)  #making gameboard

        #game loop
        while self.pressed_key != ord('q'):  #main while loop

            #PLAYER CONTROL SECTION
            self.pressed_key = self.level.board.getch(
            )  #getting key from player

            #CPUs SECTIONS
            for cpu in self.population.cpus:
                self.level.unprint(cpu)  #erasing all snakes

                cpu.move(self.morsel)  #generating moves

                if cpu.collides():  #collision checking
                    self.population.cpus.remove(cpu)
                    self.level.unprint(cpu)

                if cpu.eats(self.morsel):  #snake eats an apple
                    pass  #temporarly disabled

                if cpu.starved():  #if snake dies of
                    self.population.cpus.remove(cpu)  #starvation
                    self.level.unprint(cpu)  #it need to be killed

            #IS FUN OVER?
            if self.population.empty():  #checking if board has its winner
                self.level.unprint(self.population.cpus[0])
                self.population.new_generation()  #winner is having a child

            #SCREEN SECTION                           #printing everything out
            for cpu in self.population.cpus:  #printing every snake
                self.level.inprint(cpu)

            self.level.board.border()
            self.level.print_aux(
                self.morsel,  #print nesseceties
                self.population.generation)

            self.level.board.refresh()  #refreshing the screen
Example #29
0
class BoardWindow(QWidget):
    def __init__(self, method):
        super().__init__()
        self.cart_items = QLabel()
        self.ga_info = QLabel()
        self.table = GameBoard(20, 20, self, method)
        self.setLayout(self.init_ui())
        self.showMaximized()

    def init_ui(self):
        main_layout = QHBoxLayout()

        font = QFont("Sans", 12)

        self.cart_items.setText(f"\nAgent: Wózek widłowy\nPrzedmioty:")
        self.cart_items.setFont(font)
        self.cart_items.setAlignment(Qt.AlignTop)
        main_layout.addWidget(self.cart_items)

        for i in range(self.table.columnCount()):
            self.table.setColumnWidth(i, 55)

        for i in range(self.table.rowCount()):
            self.table.setRowHeight(i, 45)

        self.table.setIconSize(QSize(45, 45))

        main_layout.addWidget(self.table)

        ga_pic = QLabel()
        pic = QPixmap("images/dna.png")
        pic.setDevicePixelRatio(8)
        ga_pic.setPixmap(pic)
        self.ga_info.setFont(font)
        ga_title = QLabel("Algorytm genetyczny:")
        ga_title.setFont(font)

        ga_info = QFormLayout()
        ga_info.addRow(ga_pic, ga_title)
        ga_info.addRow(QLabel(""), self.ga_info)

        main_layout.addLayout(ga_info)

        return main_layout

    @pyqtSlot(str, name="Update cart items info")
    def update_items_info(self, info):
        self.cart_items.setText(
            f"\nAgent: Wózek widłowy\nPrzedmioty:\n\n{info}")

    @pyqtSlot(str, name="Update genetic algorithm info")
    def update_ga_info(self, info):
        self.ga_info.setText(info)
Example #30
0
 def __init__(self,Display):
     """ here we need a Display to show popup windows on screen
         play      : it says about game is paused or playing
         GameBoard : to play game and display it
         save      : it save text to display in popup
         yes       :           ''
         no        :           ''
         x         : cross mark in popup
     """
     self.Display=Display
     self.play=True
     self.GameBoard=GameBoard(self.Display)
     font=pygame.font.SysFont('comicsansms', 32)
     self.save=font.render('Save' , True, [200,200,200])
     font=pygame.font.SysFont('comicsansms', 25)
     self.yes=font.render('YES',True,[200,200,200])
     self.no=font.render('NO',True,[200,200,200])
     font=pygame.font.SysFont('comicsansms', 17)
     self.x=font.render('X',True,[0,0,0])
    def test_file_loading(self):
        board = GameBoard('./puzzles/only_18_steps.txt')

        self.assertEqual(board.shape, tuple([9, 6]))
        block_names = [
            'A', '*', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
            'N', 'O'
        ]
        for bn in block_names:
            self.assertTrue(bn in board.blocks)
Example #32
0
def main():
    """
    Main entry point for the script.
    :return: None
    """
    logging.basicConfig(stream=sys.stdout)
    logger = logging.getLogger()

    options = process_cli(logger)
    if options is None:
        exit(1)

    # Load in the dictionary
    dictionary = []
    with open(options.dictionary_file) as file:
        for word in file:
            dictionary.append(word.rstrip())

    logger.info('Generating game board...')
    game_board = GameBoard(height=options.board_height,
                           width=options.board_width)

    logger.debug('====================')
    logger.debug('Generated Game Board')
    logger.debug('====================')
    logger.debug(game_board)

    # Search the board
    results = game_board.search(word_list=dictionary)

    # Print results
    print('====================')
    print('      RESULTS       ')
    print('====================')
    print(f'Total words found: {len(results)}')
    grid_width = 6
    for i in range(0, len(results), grid_width):
        sublist = results[i:i + grid_width]
        print(''.join(f'{x:<10}' for x in sublist))

    print(f'Board creation time: {game_board.gen_time:.5f} seconds')
    print(f'Board search time: {game_board.search_time:.5f} seconds')
Example #33
0
def test_bad_args():
    """ Verify we handle dumb coding! """
    with pytest.raises(ValueError):
        GameBoard(width=-1, height=15)
    with pytest.raises(ValueError):
        GameBoard(width=1, height=0)

    g = GameBoard(width=1, height=1)
    with pytest.raises(ValueError):
        g.search(word_list=None)

    with pytest.raises(ValueError):
        g.search(word_list=[])
Example #34
0
	def __init__(self, boardSize, cellSize, setSize, numFeatures, handSize, numPlayers):
		self.boardSize = boardSize
		self.cellSize = cellSize
		self.setSize = setSize
		self.numFeatures = numFeatures
		self.gameboard = GameBoard(boardSize, cellSize)
		self.cardSet = Card.createCardSet(setSize,numFeatures)
		self.deck = set(self.cardSet)
		self.players = [Player(i, self.drawCardsFromDeck(handSize)) 
						for i in range(numPlayers)]
		self.numPlayers = numPlayers
Example #35
0
def reset():  # all functions whose names do not begin with underscore will appear as menu options under MyFuncs
    gb = GameBoard.get_board()
    max_rows = gb.get_row_count()
    max_cols = gb.get_column_count()

    for r in range(max_rows):
        for c in range(max_cols):
            cell = gb.get_cell(r, c)
            cell.set_color("GRAY")

    __change_labels('O')
Example #36
0
def main() -> None:
    """Creates board and runs the game"""
    parser = argparse.ArgumentParser(
        description='Conways Game of life that runs for as many generations as you like')

    parser.add_argument('x', type=int, help='Size of x-axis')
    parser.add_argument('y', type=int, help='Size of y-axis')
    args = parser.parse_args()

    # Create board
    board = GameBoard(args.x, args.y)

    # Program loop
    finished = "a"
    while finished != 'q':
        board.draw_board()
        finished = input(
            "Press enter continue and 'q' to quit\n> ")
        if finished.lower() == "q":
            print("Program terminated")
Example #37
0
 def testFlawlessMapFile(self):
     
     self.input_file = os.path.join('./Maps/', 'Test Map.txt')
     
     gb = GameBoard()
     
     game = None
     
     try:
         game = gb.readMapData(self.input_file)
     except CorruptedMapFileError:
         self.fail("Loading a correctly structured file caused an exception")
         
         
     self.assertEqual(gb.name, "Test Map", "Map name not correct")
     self.assertEqual(gb.width, 50, "Width not correc")
     self.assertEqual(gb.height, 20, "Height not correct")
     self.assertEqual(gb.startingLives, 10, "Lives not correct")
     self.assertEqual(gb.money, 100, "Money not correct")
     self.assertEqual(gb.getTowers(), ["t1", "t2"], "Towers not correct")
     self.assertEqual(gb.waves, [[50, ["e1","e2", "e1", "e1", "e1"]], [10, ["e1", "e1", "e2", "e1", "e1"]]], "Waves not correct")
Example #38
0
def search():
    gb = GameBoard.get_board()

    word = input("Enter word for which to search: ")

    h = gb.get_row_count()
    w = gb.get_column_count()

    done = False
    for row in range(h):
        for col in range(w):
            done = search_east(gb, row, col, word, 0)
            if done:
                return
Example #39
0
def word_search():
    gb = GameBoard.get_board()

    word = input("Enter word for which to search: ")

    h = gb.get_row_count()
    w = gb.get_column_count()

    for row in range(h):
        k = 0
        for col in range(w):
            letter = gb.get_label(row, col)
            if letter == word[k]:
                k += 1

            if k == len(word): #found word
                __highlight_row(row, col, len(word))
                break
Example #40
0
def init_game():
    file = open("Resources/Places.txt", "r")

    lines = []
    for line in file:
        line = line.strip()
        lines.append(line.split())

    h = len(lines)
    w = len(lines[0])

    gb = GameBoard.get_board()
    gb.set_size(h, w)

    for row in range(h):
        for col in range(w):
            letter = lines[row][col]
            gb.set_label(row, col, letter)
 def __init__(self, parent):
     super().__init__(parent) 
     self._gameBoard = GameBoard()
     self._parent = parent
     
     self._gameover = False
     
     self._isTowerSelected = False
     self._isTowerHovered = False
     self._towerBeingHovered = None
     self._selectedTower = None
     
     self._waveFinishTime = 0
     
     self._gameSpeed = self._parent.speed
     self._timePassed = 0
     self.timer = QBasicTimer()
     
     self._gameBoard.readMapData(os.path.join('./Maps/', self._parent.map))
     self.timer.start(self._gameSpeed, self)
     self.initUI()
Example #42
0
def demo():
    import random
    import time

    #get a reference to the GameBoard
    #you will use this reference to communicate with the gameboard
    gb = GameBoard.get_board()

    #resize it to the specified dimensions
    gb.set_size(6,8)

    row = 3
    col = 4

    #change the color of specified cell
    gb.set_color(row, col, "RED")

    #change the label of the specified cell
    gb.set_label(row, col, "X")

    #Retrieve the name of the color of the specified cell
    c = gb.get_color(row, col)
    print("Cell ", row, col, " is colored ", c)

    #Retrieve the label of the specified cell
    letter = gb.get_label(row, col)
    print("Cell ", row, col, " has label ", letter)

    #Retrieve the number of rows in the board
    max_rows = gb.get_row_count()

    #Retrieve the number of columns in the board
    max_cols = gb.get_column_count()

    #Iterate over the board and assign random letters to the cells
    for row in range(max_rows):
        for col in range(max_cols):
            letter = chr(random.randint(ord('A'), ord('Z')))
            gb.set_label(row, col, letter)
            time.sleep(0.1)
Example #43
0
 def __init__(self, **kwargs):
     super(FilGame, self).__init__(**kwargs)
     # define tile types
     self.tiles = [] # holds all tile widgets
     self.types = {
             #'arrow': {'id': 1, 'rot': True, 'mov': True},
             #'start': {'id': 2, 'rot': False, 'mov': False},
             'movchair': {'id': 1, 'rot': False, 'mov': True},
             'rotchair': {'id': 2, 'rot': True, 'mov': True},
             'couch3m': {'id': 4, 'rot': False, 'mov': False},
             }
     self.images = self.setup_images()
     # set background image
     self.bg = Image(source=os.path.join('assets', 'bg.png'), pos=(0,0),
             width=glo.const.WIDTH, height=glo.const.HEIGHT)
     self.bg.allow_stretch = True
     self.bg.keep_ratio = False
     self.add_widget(self.bg)
     # set up game board
     self.board = GameBoard()
     self.board.load()
     # place tiles for starting level
     self.setup()
Example #44
0
__author__ = 'Alexis'

import getpass
import sys
from gameboard import GameBoard

if __name__ == '__main__':
    while True:
        words = getpass.getpass(prompt='Please enter words: ')
        words = words.lower()
        gameboard = GameBoard(words)
        gameboard.setupBoard()
        gameboard.board.append(["Letters guessed:"])
        letters_guessed = []
        gameboard.board.append(letters_guessed)
        while gameboard.guess_wrong < 6:
            guess = raw_input("What is your guess?")
            guess = guess.lower()
            letters_guessed.append(guess)
            gameboard.getGuess(guess)
            gameboard.guessWrong(guess)
            gameboard.printBoard()
            if gameboard.guess_right == len(set(words)) - (1 if ' ' in words else 0):
                print "You win!"
                play_again = raw_input("Would you like to play again? (Y/N)")
                if play_again == "Y":
                    break
                else:
                    print "Thanks for playing!"
                    sys.exit(0)
        if gameboard.guess_wrong >= 6:
Example #45
0
 def test1b(self):
     g = GameBoard(test1)
     g.simulate(2)
     #test in email
     self.assertEqual(test1bans, g.board)
Example #46
0
 def test8(self):
     g = GameBoard(test8)
     g.simulate(1)
     #single row
     self.assertEqual(test8ans, g.board)
Example #47
0
 def test7(self):
     g = GameBoard(test7)
     g.simulate(1)
     #diagnols
     self.assertEqual(test7ans, g.board)
Example #48
0
 def test6(self):
     g = GameBoard(test6)
     g.simulate(1)
     #all 1s
     self.assertEqual(test6ans, g.board)
Example #49
0
 def test5(self):
     g = GameBoard(test5)
     g.simulate(1)
     # different perimeters
     self.assertEqual(test5ans, g.board)
Example #50
0
 def test4(self):
     g = GameBoard(test4)
     g.simulate(1)
     #weird bounds
     self.assertEqual(test4ans, g.board)
Example #51
0
 def test3(self):
     g = GameBoard(test3)
     g.simulate(1)
     #single digit
     self.assertEqual(test3ans, g.board)
Example #52
0
 def test2(self):
     g = GameBoard(test2)
     g.simulate(1)
     #all zeroes
     self.assertEqual(test2, g.board)
Example #53
0
	def test_testing_for_a_full_column(self):
		g = GameBoard()
		for i in range(g.NUM_ROWS):
			g.add_piece(0, 3)

		self.assertTrue(g.column_full(3))
class UserInterface(QMainWindow):
    
    def __init__(self, parent):
        super().__init__(parent) 
        self._gameBoard = GameBoard()
        self._parent = parent
        
        self._gameover = False
        
        self._isTowerSelected = False
        self._isTowerHovered = False
        self._towerBeingHovered = None
        self._selectedTower = None
        
        self._waveFinishTime = 0
        
        self._gameSpeed = self._parent.speed
        self._timePassed = 0
        self.timer = QBasicTimer()
        
        self._gameBoard.readMapData(os.path.join('./Maps/', self._parent.map))
        self.timer.start(self._gameSpeed, self)
        self.initUI()
              

    def initUI(self):
        
        centralWidget = QWidget()
        self.setCentralWidget(centralWidget)
        self.setWindowTitle(self._gameBoard.name)
        self.setWindowIcon(QIcon(os.path.join('./Pictures/', 'berserker_icon.png'))) #Apparently this doens't work the same way on a mac.
        self.statusBar().showMessage('Ready!')
        vbox = QVBoxLayout()
        centralWidget.setLayout(vbox)
        self.gameStats = GameStats(self)
        self.mapView = MapView(self)
        self.bottomButtons = BottomButtons(self)
        vbox.addWidget(self.gameStats)
        vbox.addWidget(self.mapView)
        vbox.addWidget(self.bottomButtons)
        
        screen = QDesktopWidget().screenGeometry()
        self.setGeometry((screen.width() - (self.gameboard.width - 1) * 20) / 2, (screen.height() - self.gameboard.height * 20 - 200) / 2, 500, 400)
        
        self.show()
        
        
    def getGameboard(self):
        return self._gameBoard
    
    
    def getIsTowerSelected(self):
        return self._isTowerSelected
    
    
    def setIsTowerSelected(self, boolean):
        self._isTowerSelected = boolean
        
    
    def getSelectedTower(self):
        return self._selectedTower
    
    
    def setSelectedTower(self, towerType):
        self._selectedTower = towerType
    
    
    def getIsTowerBeingHovered(self):
        return self._isTowerHovered
    
    
    def setIsTowerBeingHovered(self, boolean, tower):
        self._isTowerHovered = boolean
        self._towerBeingHovered = tower
    
    
    def getTowerBeingHovered(self):
        return self._towerBeingHovered
    

    def getGameStats(self):
        return self.gameStats


    def getTimePassed(self):
        return self._timePassed
    
    
    def setWaveFinishTime(self, value):
        self._waveFinishTime = value
    
    
    def getGameOver(self):
        return self._gameover
    
    
    def timerEvent(self, event):
        # The time passed attribute helps with setting the enemy appearance interval and tower firerate.
        self._timePassed += 1
        self.mapView.summonEnemy()
        self.mapView.moveEnemies()
        self.mapView.checkShooting()
        self.mapView.moveProjectiles()
        self.mapView.update()
       
    
    def loseGame(self):
        self.bottomButtons.clockTimer.stop()
        self.timer.stop()
        self.statusBar().showMessage('Game has ended. You lost.')
        self._gameover = True
        
        self.popUp = QFrame()
        self.popUp.setGeometry(500, 500, 100, 100)
        
        vbox = QVBoxLayout()
        
        youLost = QLabel()
        youLost.setPixmap(QPixmap(os.path.join('./Pictures/', "game_over.png")))
        vbox.addWidget(youLost)
        
        done = QPushButton("Done")
        vbox.addWidget(done)

        self.popUp.setLayout(vbox)
        self.popUp.move(self.mapToGlobal(QPoint(0,0)).x() + self.gameboard.width*blockSize / 2 - 130, self.mapToGlobal(QPoint(0,0)).y() + self.gameboard.height*blockSize / 2)
        self.popUp.show()
        done.clicked.connect(self.backToMainMenu)
    
    
    def winGame(self):
        self.bottomButtons.clockTimer.stop()
        self.timer.stop()
        self.statusBar().showMessage('Game has ended. You won.')
        self._gameover = True
        
        self.popUp = QFrame()
        self.popUp.setGeometry(500, 500, 100, 100)
        
        vbox = QVBoxLayout()
        
        youLost = QLabel()
        youLost.setPixmap(QPixmap(os.path.join('./Pictures/', "victory.png")))
        vbox.addWidget(youLost)
        
        done = QPushButton("Done")
        vbox.addWidget(done)

        self.popUp.setLayout(vbox)
        self.popUp.move(self.mapToGlobal(QPoint(0,0)).x() + self.gameboard.width*blockSize / 2 - 130, self.mapToGlobal(QPoint(0,0)).y() + self.gameboard.height*blockSize / 2)
        self.popUp.show()
        done.clicked.connect(self.backToMainMenu)
        
        
    def backToMainMenu(self):
        self._parent.show()
        self.popUp.deleteLater()
        self.deleteLater()
    

    def getGameSpeed(self):
        return self._gameSpeed


    def setGameSpeed(self, value):
        self._gameSpeed = value
    

    def getWaveFinishTime(self):
        return self._waveFinishTime
    
    
    def getTimer(self):
        return self.timer
    

    isTowerSelected = property(getIsTowerSelected, setIsTowerSelected)
    selectedTower = property(getSelectedTower, setSelectedTower)
    isTowerHovered = property(getIsTowerBeingHovered)
    towerBeingHovered = property(getTowerBeingHovered)
    gamestats = property(getGameStats)
    gameboard = property(getGameboard)
    timePassed = property(getTimePassed)
    gameover = property(getGameOver)
    gameSpeed = property(getGameSpeed, setGameSpeed)
    waveFinishTime = property(getWaveFinishTime, setWaveFinishTime)
class LocalGame:
    
    #Constructor params: 
    #@mode: 1 or 2, repping either 1 or 2 players
    #@difficulty = "Easy", "Normal" or "Hard"; only used if in 1P mode
    #@board_coordinates = starting (x,y) coordinate of the board
    #@screen = screen to blit to
    def __init__(self, mode, difficulty, screen, menu):
        self.mode = mode
        self.screen = screen
        self.current_player = None #x always goes first
        self.player = None    
        self.pc = None
        self.menu = menu
        self.gameBoard = GameBoard()
        self.AI = MoveGenerator(difficulty)
    
    def run_game(self):
        clock = pygame.time.Clock()
        #Determine whether AI or player goes first
        self.determine_turns()
        '''Game Loop'''
        while (not (self.check_game_over() or self.check_tie()) and (self.menu.current_state != 0)):
            #Event Processing
            mouse_click = (0,0)
            mouse_position = pygame.mouse.get_pos()
            for event in pygame.event.get(): 
                if event.type == pygame.QUIT: 
                    self.menu.current_state = -1
                    return
                if event.type == pygame.MOUSEBUTTONUP:
                    mouse_click = mouse_position
            #Logic
            if (self.mode == 1):
                if (self.current_player == self.player):
                    self.player_click(mouse_click[0], mouse_click[1])
                else:
                    self.pc_move()
            elif (self.mode == 2):
                try:
                    mouse_x = mouse_click[0]
                    mouse_y = mouse_click[1]
                    self.player_click(mouse_x, mouse_y)
                except:
                    pass
                    
            #Drawing
            self.draw_background()
            self.draw_buttons()
            self.draw_buttons_hover(mouse_position[0], mouse_position[1])
            self.draw_marker_hover(mouse_position[0], mouse_position[1])
            self.gameBoard.draw_markers(self.screen, constants.BOARD_COORDINATES)
            if (self.check_game_over()):
                self.switch_turns() #Turn is switched after move, so switch back to draw winner correctly
                if (self.current_player == "x"): 
                    l = self.gameBoard.x_list
                else:
                    l = self.gameBoard.o_list
                self.draw_win(l)
                
            pygame.display.flip()
            
            #If the game is over, pause for a moment to let player see that game is over
            if (self.check_game_over() or self.check_tie()):
                time.sleep(1)
            clock.tick(60)
    
    #For 1p, determine whether pc or player goes first. "x" always goes first
    def determine_turns(self):
        num = randint(1,10)
        if (num%2 == 0):
            self.player = "x"
            self.pc = "o"
            self.current_player = self.player
        else:
            self.player = "o"
            self.pc = "x"
            self.current_player = self.pc
            
    def check_game_over(self):
        if ((self.gameBoard.check_win(self.gameBoard.x_list, constants.WIN_POSITION_LIST)) or (self.gameBoard.check_win(self.gameBoard.o_list, constants.WIN_POSITION_LIST))):
            return True
        else:
            return False
    def check_tie(self):
        if (len(self.gameBoard.taken_positions_list) == 9) and (not (self.check_game_over())):
            return True
        else:
            return False
    
    def player_click(self, mouse_x, mouse_y):
        b_x = constants.BOARD_COORDINATES[0]
        b_y = constants.BOARD_COORDINATES[1]
        if b_x < mouse_x < (b_x + constants.TILE_DIMENSION):
            if (b_y < mouse_y < (b_y + constants.TILE_DIMENSION*3)) and ((((mouse_y - b_y) // 100)*3) not in self.gameBoard.taken_positions_list):
                position = ((mouse_y - b_y) // 100)*3
                self.gameBoard.update_player_list(self.current_player, position)
                self.switch_turns()
        elif b_x + constants.TILE_DIMENSION < mouse_x < (b_x + 2*constants.TILE_DIMENSION):
            if (b_y < mouse_y < (b_y + constants.TILE_DIMENSION*3)) and (((((mouse_y - b_y) // 100)*3+1) not in self.gameBoard.taken_positions_list)):
                position = ((mouse_y - b_y) // 100)*3+1
                self.gameBoard.update_player_list(self.current_player, position)
                self.switch_turns()       
        elif b_x + 2*constants.TILE_DIMENSION < mouse_x < (b_x + 3*constants.TILE_DIMENSION):
            if (b_y < mouse_y < (b_y + constants.TILE_DIMENSION*3)) and (((((mouse_y - b_y) // 100)*3+2) not in self.gameBoard.taken_positions_list)):
                position = ((mouse_y - b_y) // 100)*3+2
                self.gameBoard.update_player_list(self.current_player, position)
                self.switch_turns()
        elif (constants.GAME_BACK_ARROW_COOR[0] < mouse_x < constants.GAME_BACK_ARROW_COOR[0] + constants.BACK_ARROW.get_size()[0]):
            if (constants.GAME_BACK_ARROW_COOR[1] < mouse_y < constants.GAME_BACK_ARROW_COOR[1] + constants.BACK_ARROW.get_size()[1]):
                self.menu.current_state = 0
        if (constants.GAME_RESET_COOR[0] < mouse_x < constants.GAME_RESET_COOR[0] + constants.RESET.get_size()[0]):
            if (constants.GAME_RESET_COOR[1] < mouse_y < constants.GAME_RESET_COOR[1] + constants.RESET.get_size()[1]):
                self.reset_game()
            
    def pc_move(self):
        if self.current_player == "x":
            AI_list = self.gameBoard.x_list
            player_list = self.gameBoard.o_list
        else:
            AI_list = self.gameBoard.o_list
            player_list = self.gameBoard.x_list
            
        time.sleep(0.2)
        pc_move = self.AI.generate_move(AI_list, player_list, self.gameBoard.taken_positions_list)
        self.gameBoard.update_player_list(self.current_player, pc_move)
        self.switch_turns()
        
    def draw_background(self):
        self.screen.blit(constants.BACKGROUND, (0,0))
        self.screen.blit(constants.HEADING, constants.HEADING_COORDINATES)
        self.screen.blit(constants.TITLE, constants.TITLE_COORDINATES)
        self.screen.blit(constants.BOARD_SURFACE, constants.BOARD_COORDINATES)
        
    def draw_marker_hover(self, mouse_x, mouse_y):
        if (self.mode == 1):
            if (self.current_player == self.player):
                    self.draw_marker_hover_helper(mouse_x, mouse_y)
        else:
            self.draw_marker_hover_helper(mouse_x, mouse_y)
        
    def draw_marker_hover_helper(self, mouse_x, mouse_y):
        if (self.current_player == "x"):
            hover_marker = constants.HOVER_EX
        else:
            hover_marker = constants.HOVER_OH
        self.gameBoard.draw_hover(mouse_x, mouse_y, hover_marker, self.screen, constants.BOARD_COORDINATES)
                
    def draw_markers(self):
        self.gameBoard.draw_markers(self.screen, constants.BOARD_COORDINATES)
        
    def draw_buttons(self):
        self.screen.blit(constants.BACK_ARROW, constants.GAME_BACK_ARROW_COOR)
        self.screen.blit(constants.RESET, constants.GAME_RESET_COOR)
        
    def draw_buttons_hover(self, mouse_x, mouse_y):
        if (constants.GAME_BACK_ARROW_COOR[0] < mouse_x < constants.GAME_BACK_ARROW_COOR[0] + constants.BACK_ARROW.get_size()[0]):
            if (constants.GAME_BACK_ARROW_COOR[1] < mouse_y < constants.GAME_BACK_ARROW_COOR[1] + constants.BACK_ARROW.get_size()[1]):
                self.screen.blit(constants.BACK_ARROW_HOVER, constants.GAME_BACK_ARROW_COOR)
        if (constants.GAME_RESET_COOR[0] < mouse_x < constants.GAME_RESET_COOR[0] + constants.RESET.get_size()[0]):
            if (constants.GAME_RESET_COOR[1] < mouse_y < constants.GAME_RESET_COOR[1] + constants.RESET.get_size()[1]):
                self.screen.blit(constants.RESET_HOVER, constants.GAME_RESET_COOR)
    
    def draw_win (self, given_list):
        gset = set(given_list)
        for item in constants.WIN_POSITION_LIST:
            wset = set(item)
            intersection = wset.intersection(gset)
            if (len(intersection) == 3):
                if (self.current_player == "x"):
                    surface = constants.WINNING_EX
                else:
                    surface = constants.WINNING_OH
                for i in intersection:
                    
                    self.gameBoard.draw_marker(self.current_player, i, self.screen, constants.BOARD_COORDINATES, surface)
            
    def reset_game(self):
        self.gameBoard.x_list = []
        self.gameBoard.o_list = []
        self.gameBoard.taken_positions_list = []
        
    def switch_turns(self):
        if (self.current_player == self.player):
            self.current_player = self.pc
        else:
            self.current_player = self.player
            
    def change_difficulty(self, diff):
        self.AI.change_difficulty(diff)
Example #56
0
	def test_adding_piece_should_return_pieces_final_position(self):
		g = GameBoard()
		result = g.add_piece(0, 3)
		self.assertEqual(result, (3,0))
Example #57
0
	def test_adding_pieces_should_places_pieces_in_lowest_unoccupied_cell_in_column(self):
		g = GameBoard()
		g.add_piece(0, 3)
		result = g.add_piece(0, 3)

		self.assertEqual(result, (3, 1))
Example #58
0
	def __init__(self):
		self.__gameboard = GameBoard()