Exemple #1
0
 def __play_music_game(self, widget=False):
     self.__stop_player()
     self._player = Player()
     self._player.load(os.path.join(BASE, "Audio", "musica02.ogg"))
     self._player.play()
     self._player.set_volumen(self._music_vol)
     self._player.connect("endfile", self.__play_music_game)
def test_add_lose():
    player = Player('1', 'Player')
    player.add_lose()
    player.add_lose()

    losses = player.record[player.LOSSES]
    assert (losses == 2)
Exemple #3
0
def play_web_game(is_stop, player1: Player, player2: Player, turn_to, send_board_step,
                  send_player1_running, send_player2_running, wait_human_action, game_over):
    board = Board()
    while not is_stop():
        turn_to(board.current_player)

        if board.current_player == BOARD.o:
            if isinstance(player1, Human):
                action = wait_human_action(1, is_stop)
                if is_stop():
                    return
                board.step(action)
            else:
                action = player1.take_action(board, is_output_action=False,
                                             running_output_function=send_player1_running, is_stop=is_stop)
            send_board_step(1, action)
        else:
            if isinstance(player2, Human):
                action = wait_human_action(2, is_stop)
                if is_stop():
                    return
                board.step(action)
            else:
                action = player2.take_action(board, is_output_action=False,
                                             running_output_function=send_player2_running, is_stop=is_stop)
            send_board_step(2, action)

        is_over, winner = board.result()
        if is_over:
            game_over(winner)
            return
def start_until_game_over(player1: Player,
                          player2: Player,
                          board_renderer: BoardRenderer = None):
    """
    Player player1 and player2 play on the board until the game is over, and output the winner.
    :param player1: Player 1.
    :param player2: Player 2.
    :param board_renderer: The board renderer.
    :return: <int> board The winner returned by board.
    """
    board = Board()
    while True:
        # Render.
        if board_renderer is not None:
            board.render(board_renderer)

        # Take action.
        if board.current_player == BOARD.o:
            player1.take_action(board,
                                is_output_action=board_renderer is not None)
        else:
            player2.take_action(board,
                                is_output_action=board_renderer is not None)

        # Game over?
        is_over, winner = board.result()
        if is_over:
            if board_renderer is not None:
                board.render(board_renderer)
            return winner
Exemple #5
0
def start_until_game_over(player1: Player,
                          player2: Player,
                          board_renderer: BoardRenderer = None):
    """
    玩家 player1 和玩家 player2 在 board 上进行游戏直到游戏结束,并输出获胜者。
    Player player1 and player2 play on the board until the game is over, and output the winner.
    :param player1: 玩家 1。 Player 1.
    :param player2: 玩家 2。 Player 2.
    :param board_renderer: 棋盘渲染器。 The board renderer.
    :return: <int> board 返回的获胜者。 The winner returned by board.
    """
    board = Board()
    while True:
        # 渲染。 Render.
        if board_renderer is not None:
            board.render(board_renderer)

        # 执行动作。 Take action.
        if board.current_player == BOARD.o:
            player1.take_action(board,
                                is_output_action=board_renderer is not None)
        else:
            player2.take_action(board,
                                is_output_action=board_renderer is not None)

        # 游戏是否结束。 Game over?
        is_over, winner = board.result()
        if is_over:
            if board_renderer is not None:
                board.render(board_renderer)
            return winner
Exemple #6
0
 def h_vs_h(self, player_type1, player_type2):
     """
         input : player_type1 and player_type2 are string
         function: Sets the game to play human vs human 
         output: a list with two human players
     """
     players = list()
     P1name = self.view.input_option("Enter " + player_type1 + "'s name: ")
     players.append(Player('1', P1name))
     P2name = self.view.input_option("Enter " + player_type2 + "'s name: ")
     players.append(Player('2', P2name))
     return players
Exemple #7
0
 def __init__(self,character, name ,percent_first_move, 
              percent_second_move, percent_third_move, percent_fourth_move):
     Player.__init__(self, character, name)
     self.percent_first_move = percent_first_move
     self.percent_second_move = percent_second_move
     self.percent_third_move = percent_third_move
     self.percent_fourth_move =percent_fourth_move
     self.win_checker = Win_Checker()
     self.block_checker = Block_Checker()
     self.biggest_percent = 1
     self.test=False
     self.ranges = self.create_ranges(percent_first_move, percent_second_move, 
                        percent_third_move, percent_fourth_move)
 def test_levelup_by_one(self):
     '''
     tests that player.levelup() increases level by one 
     for randomly chosen level.
     '''
     p1 = Player('p1','elf')
     
     # set p1 to random level
     for i in range(randrange(max_level-1)):
         p1.level_up()
     l = p1.level
     p1.level_up()
     self.assertEqual(p1.level - l, 1)
Exemple #9
0
    def __init__(self):
        # Create the game camera
        self.tileSize = Vector2(40, 40)
        self.screenSize = Vector2(800, 800)
        pygame.font.init()

        self.font_renderer = pygame.font.Font(
            os.path.join("fonts", 'Millennium-Regular_0.ttf'), 24)
        self.window = Window(self.screenSize, "Robot Clergy", self.tileSize,
                             self.font_renderer)
        self.camera = Camera(Vector2(20, 20), self.tileSize, self.screenSize)
        self.mapHolder = MapHolder(["Church"], self.tileSize,
                                   self.window.tileLoader)

        # Timing and delta time stuff
        self.clock = pygame.time.Clock()
        self.deltaTime = 0

        self.taskList = TaskList()
        self.timedEventHandler = TimedEvents()

        for i in range(0, 100):
            randomNode = self.mapHolder.loadedMap.getRandomEmptyNode()
            task = Task(randomNode.pos, self.taskListEventCallback, 200, 1,
                        eSkills.CONVINCING)
            randomNode.addUserAction(UserAction("Go Here", task))

        # Init the player class
        playerImage = self.window.tileLoader.getImageByName("player", 0, 0)
        self.player = Player(playerImage, self.screenSize, self.taskList,
                             self.tileSize)

        self.humanSpawner = HumanFactory(
            self.mapHolder.getCurrentMap().gridSize, self.window.tileLoader,
            self.tileSize)
        self.humans = []
        self.timedEventHandler.addTimedEvent(1000,
                                             self.peopleStartComingForService)
        self.nmbrOfCreatures = 4
        self.AICreatures = [
            ClergyRobot(i,
                        random() * 8 * self.tileSize.y,
                        random() * 8 * self.tileSize.y, self.window.tileLoader,
                        self.tileSize, self.taskList)
            for i in range(self.nmbrOfCreatures)
        ]
        self.movingCreaturesGroup = pygame.sprite.Group()
        self.movingCreaturesGroup.add(self.humans)
        self.movingCreaturesGroup.add(self.AICreatures)

        self.timedEventHandler.addTimedEvent(10000, self.addToTimedEvent)
Exemple #10
0
def test_check_block_posibility_player2_col_2():
    win_checker = Win_Checker()
    connect4 = Connect4('clear')
    board = Board(6, 7)
    board.matrix = [[' ', ' ', ' ', ' ', ' ', ' ', ' '],
                    [' ', ' ', ' ', ' ', ' ', ' ', ' '],
                    ['2', ' ', ' ', ' ', ' ', ' ', ' '],
                    ['1', '1', '1', ' ', ' ', '2', ' '],
                    ['1', '1', '2', '2', '2', '1', ' '],
                    ['1', '1', '2', '2', '2', '1', '2']]
    players = [Player('1', "Player1"), Player('2', "Player2")]
    actual = 0  #Player1

    result = win_checker.check(connect4, board, players, actual)
    assert (result == 2)
Exemple #11
0
def test_check_normal_flow_empty_matrix_no_win_posibility():
    checker = Checker()
    connect4 = Connect4('clear')
    board = Board(6, 7)
    board.matrix = [[' ', ' ', ' ', ' ', ' ', ' ', ' '],
                    [' ', ' ', ' ', ' ', ' ', ' ', ' '],
                    [' ', ' ', ' ', ' ', ' ', ' ', ' '],
                    [' ', ' ', ' ', ' ', ' ', ' ', ' '],
                    [' ', ' ', ' ', ' ', ' ', ' ', ' '],
                    [' ', ' ', ' ', ' ', ' ', ' ', ' ']]
    players = [Player('1', "Player1"), Player('2', "Player2")]
    actual = 0  #Player1

    result = checker.check(connect4, board, players, actual)
    assert (result == -1)
Exemple #12
0
def test():
    map = Pyramid()
    player = Player()
    teste = GeoFriend2(map, player)

    run = True
    teste.reset_view()
    while run:
        teste.render()

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                run = False
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_LEFT:
                    teste.player_step(2)
                elif event.key == pygame.K_RIGHT:
                    teste.player_step(3)
                elif event.key == pygame.K_UP:
                    teste.player_step(1)
                elif event.key == pygame.K_DOWN:
                    teste.player_step(0)
                elif event.key == pygame.K_SPACE:
                    print("Space pressed")
                    map = Pyramid()
                    teste = GeoFriend2(map, player)
            # if event.type == pygame.MOUSEBUTTONUP:
            #     print("Mouse event")
            #     pos = pygame.mouse.get_pos()
            #     print(pos)


# test()
Exemple #13
0
    def __init__(self):
        self.actions_available = BASE_ACTIONS

        self.player = Player("NoName", "Male", "Human", None)

        self.config_loader = UnsuiConfigLoader()
        self.config_loader.generate()
    def test_print_record(self, mock_stdout):
        player = Player('1', 'Player')
        player.add_win()
        player.add_win()
        player.add_lose()

        player.print_record()

        console = "Player Record: Wins: 2 | Losses: 1 | draws: 0\n"
        assert (mock_stdout.getvalue() == console)
Exemple #15
0
def getPlayers():  #Gets player number and creates player objects
    numPlayers = int(input('How many players?'))

    playerList = []
    for player in range(numPlayers):
        playerList.append(Player())
        #TODO Get player names

    return playerList
Exemple #16
0
    def __init__(self):
        self.action_space = Discrete(4)
        self.maps = [Basic(), Pyramid()]  #, HighPlatform()

        low = [80, 80, 65, 65, 0]
        high = [1200, 720, 1215, 735, 1310]

        self.observation_space = Box(low=np.array(low), high=np.array(high))

        self.GeoFriend2 = None

        self.player = Player()
Exemple #17
0
 def h_vs_c(self, player_type1, player_type2):
     """
         input : player_type1 and player_type2 are string
         function: Sets the game to play human vs computer
         output: a list witha player and an agent 
     """
     players = list()
     P1name = self.view.input_option("Enter " + player_type1 + "'s name: ")
     players.append(Player('1', P1name))
     P2name = self.view.input_option("Enter " + player_type2 + "'s name: ")
     p = self.get_computer_parameters()
     players.append(Agent('2', P2name, p[0], p[1], p[2], p[3]))
     return players
 def test_level_growth(self):
     """ tests that all stats are >= those of previous level (for 1st n levels)"""
     n = 10 # number of levels to test
     
     p1 = Player('p1','elf')
     
     for level in range(n):
         h = p1.health
         hp= p1.max_hp
         a = p1.attack
         ba= p1.base_attack
         ar= p1.armour
         l = p1.level
         
         p1.level_up()
         
         self.assertTrue(p1.health >= h)
         self.assertTrue(p1.max_hp >= hp)
         self.assertTrue(p1.attack >= a)
         self.assertTrue(p1.base_attack >= ba)
         self.assertTrue(p1.armour >= ar)
         self.assertTrue(p1.level >= l)
def test_add_win():
    player = Player('1', 'Player')
    player.add_win()
    player.add_win()
    player.add_win()

    wins = player.record[player.WINS]
    assert (wins == 3)
Exemple #20
0
def start_until_game_over(player1: Player, player2: Player, board_renderer: BoardRenderer = None):
    """

    :param player1:
    :param player2:
    :param board_renderer:
    :return:
    """
    board = Board()
    while True:
        if board_renderer is not None:
            board.render(board_renderer)

        if board.current_player == BOARD.o:
            player1.take_action(board, is_output_action=board_renderer is not None)
        else:
            player2.take_action(board, is_output_action=board_renderer is not None)

        is_over, winner = board.result()
        if is_over:
            if board_renderer is not None:
                board.render(board_renderer)
            return winner
 def __init__(self, load=False, input_func=user_input.default_input):
     if load == False:
         # define attributes: #
         self.player = Player("NoName", "Male", "Human", None)           
         self.parser = Parser()
         self.config_loader = UnsuiConfigLoader()
         self.GAME_START = datetime.now()
         self.commands_entered = 0
         self.actions_available = BASE_ACTIONS
                     
         # call set up functions: #
         self.config_loader.generate()    
         user_input.opening_setup(self,input=input_func)
         self.events_engine = EventsEngine.EventsEngine(getStartingEvents(self))
     else:
         self.load_game(load)
Exemple #22
0
    def __init__ui(self):
        self.resize(SCREEN_WIDTH, SCREEN_HEIGHT)
        self.setStyleSheet("background-color: black;")
        self.deus_machine = {}
        self.shields = []
        self.enemies = []
        self.lives = []
        self.players = []
        self.player_bullets = []
        self.enemy_bullets = {}
        self.scores = []
        self.level = Level(self)

        for i in range(self.players_count):
            self.players.append(Player(self, i + 1, self.players_count))
            self.scores.append(Score(self, i + 1))
            self.player_bullets.append([])
            self.lives.append([])

        self.start_game()
Exemple #23
0
class Gameloop:
    def __init__(self):
        # Create the game camera
        self.tileSize = Vector2(40, 40)
        self.screenSize = Vector2(800, 800)
        pygame.font.init()

        self.font_renderer = pygame.font.Font(
            os.path.join("fonts", 'Millennium-Regular_0.ttf'), 24)
        self.window = Window(self.screenSize, "Robot Clergy", self.tileSize,
                             self.font_renderer)
        self.camera = Camera(Vector2(20, 20), self.tileSize, self.screenSize)
        self.mapHolder = MapHolder(["Church"], self.tileSize,
                                   self.window.tileLoader)

        # Timing and delta time stuff
        self.clock = pygame.time.Clock()
        self.deltaTime = 0

        self.taskList = TaskList()
        self.timedEventHandler = TimedEvents()

        for i in range(0, 100):
            randomNode = self.mapHolder.loadedMap.getRandomEmptyNode()
            task = Task(randomNode.pos, self.taskListEventCallback, 200, 1,
                        eSkills.CONVINCING)
            randomNode.addUserAction(UserAction("Go Here", task))

        # Init the player class
        playerImage = self.window.tileLoader.getImageByName("player", 0, 0)
        self.player = Player(playerImage, self.screenSize, self.taskList,
                             self.tileSize)

        self.humanSpawner = HumanFactory(
            self.mapHolder.getCurrentMap().gridSize, self.window.tileLoader,
            self.tileSize)
        self.humans = []
        self.timedEventHandler.addTimedEvent(1000,
                                             self.peopleStartComingForService)
        self.nmbrOfCreatures = 4
        self.AICreatures = [
            ClergyRobot(i,
                        random() * 8 * self.tileSize.y,
                        random() * 8 * self.tileSize.y, self.window.tileLoader,
                        self.tileSize, self.taskList)
            for i in range(self.nmbrOfCreatures)
        ]
        self.movingCreaturesGroup = pygame.sprite.Group()
        self.movingCreaturesGroup.add(self.humans)
        self.movingCreaturesGroup.add(self.AICreatures)

        self.timedEventHandler.addTimedEvent(10000, self.addToTimedEvent)

    def getInputs(self):
        """Return the events corresponding to each button press"""
        events = pygame.event.get([pygame.KEYDOWN, pygame.KEYUP])
        return events

    def preach(self):
        self.timedEventHandler.addTimedEvent(10000,
                                             self.peopleStartComingForService)

    def peopleStartComingForService(self):
        task = Task(Vector2(11 * self.tileSize.x, 5 * self.tileSize.y),
                    self.preach, 250, 4, eSkills.CONVINCING, "Preach")
        self.taskList.enqueueTask(task)
        x = self.tileSize.x
        y = self.tileSize.y

        entranceLists = [Vector2(19 * x, 5 * y), Vector2(19 * x, 6 * y)]

        seating = [
            Vector2(18 * x, 1 * y),
            Vector2(18 * x, 2 * y),
            Vector2(18 * x, 3 * y),
            Vector2(18 * x, 4 * y),
            Vector2(18 * x, 7 * y),
            Vector2(18 * x, 8 * y),
            Vector2(18 * x, 9 * y),
            Vector2(18 * x, 10 * y),
            Vector2(16 * x, 1 * y),
            Vector2(16 * x, 2 * y),
            Vector2(16 * x, 3 * y),
            Vector2(16 * x, 4 * y),
            Vector2(16 * x, 7 * y),
            Vector2(16 * x, 8 * y),
            Vector2(16 * x, 9 * y),
            Vector2(16 * x, 10 * y),
            Vector2(14 * x, 1 * y),
            Vector2(14 * x, 2 * y),
            Vector2(14 * x, 3 * y),
            Vector2(14 * x, 4 * y),
            Vector2(14 * x, 7 * y),
            Vector2(14 * x, 8 * y),
            Vector2(14 * x, 9 * y),
            Vector2(14 * x, 10 * y),
        ]

        randomAmountOfHumans = int(random() * len(seating))
        for i in range(randomAmountOfHumans):
            chair = seating[int(random() * len(seating))]
            seating.remove(chair)
            humanWaitTask = WaitTask(chair, None, "Listen to preacher", task,
                                     eSkills.STUBBORNNESS)
            self.humans.append(
                self.humanSpawner.initCreatureAtPos(
                    entranceLists[int(random() * 2)], humanWaitTask))

    def handleEvents(self):
        """Handle the events thrown by the game"""
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                return
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_ESCAPE:
                    pygame.event.post(pygame.event.Event(pygame.QUIT))

    def taskListEventCallback(self):
        print("A task was just finished")

    def addToTimedEvent(self):
        taskPos = self.mapHolder.getCurrentMap().getRandomEmptyNode().pos
        self.taskList.enqueueTask(
            Task(taskPos, self.taskListEventCallback, 30, "RandomTask"))
        self.timedEventHandler.addTimedEvent(
            self.timedEventHandler.elapsedTime + 5000, self.addToTimedEvent)

    def startLoop(self):
        """The main function that runs the whole game."""
        # Game loop
        while pygame.display.get_init():
            currentMap = self.mapHolder.getCurrentMap()
            self.deltaTime = self.clock.get_time()
            self.timedEventHandler.updateTimer(self.deltaTime)
            self.player.updateMouse(currentMap)
            if len(self.humans) > 0:
                for human in self.humans:
                    if not human.alive:
                        self.humans.remove(human)
                    human.update(currentMap, self.deltaTime)
            for ai in self.AICreatures:
                ai.Update(currentMap, self.deltaTime,
                          self.movingCreaturesGroup)

            npcs = [human for human in self.humans]
            npcs.extend(self.AICreatures)

            self.camera.drawScreen(self.window.screen, currentMap, self.player,
                                   npcs)
            debugInfo = [len(self.taskList.listOfTasks)]
            debugArray = [task.taskName for task in self.taskList.listOfTasks]
            debugInfo.extend(debugArray)
            self.camera.drawDebug(self.window.screen, debugInfo)
            self.handleEvents()
            if pygame.display.get_init():
                pygame.event.pump()

            try:
                pygame.display.update()
            except:
                print("Display not initialised")

            self.clock.tick(60)
class GameInstance(object):
    def __init__(self, load=False, input_func=user_input.default_input):
        if load == False:
            # define attributes: #
            self.player = Player("NoName", "Male", "Human", None)           
            self.parser = Parser()
            self.config_loader = UnsuiConfigLoader()
            self.GAME_START = datetime.now()
            self.commands_entered = 0
            self.actions_available = BASE_ACTIONS
                        
            # call set up functions: #
            self.config_loader.generate()    
            user_input.opening_setup(self,input=input_func)
            self.events_engine = EventsEngine.EventsEngine(getStartingEvents(self))
        else:
            self.load_game(load)

    #------- Actions Functions --------#
    def generate_rooms_dict(self):
        ''' this returns a list of all rooms in the area '''
        return self.config_loader.get_by_type('room')
        
    def check_events(self):
        '''
        Checks all events in the event list to see 
        if they have been triggered.
        '''
        self.events_engine.checkEvents()
                
    def load_game(self,fname):
        with open(fname, 'rb') as f:
            newgame = pickle.load(f)
            self.set(newgame)
            del newgame
        # Deprecated, replaced by Pickle. Leave here.
        #self.config_loader.generate(load)
        #self.player = self.config_loader.create_player()
        
    def set(self,game):
        '''sets all attributes in this game equal to those of given game'''
        self.player = game.player
        self.parser = game.parser
        self.config_loader = game.config_loader
        self.GAME_START = game.GAME_START
        self.commands_entered = game.commands_entered
        self.actions_available = game.actions_available
        self.events = game.events

    def save_game(self,fname=DEFAULT_SAVE_FILE):
        with open(fname,'wb') as f:
            pickle.dump(self,f,pickle.HIGHEST_PROTOCOL)
        # Deprecated, replaced by Pickle. Leave here.
        #self.config_loader.save_game(self.player)
        
    def exit_game(self,save=True):
        if save==True:
            self.save_game()
        sys.exit()

    def take_action(self, command, input=user_input.default_input):

        # This method now uses the Command object returned from the Parser
        # This means you can call commands with 2 words, e.g. 'look desk'

        # TODO:
        #   - Move this code to user_input maybe
        #     ^ Any thoughts on this? This code will become very large as we implement more verbs.
        #       Unless we can devise a smart way to handle them all.

        if command:
            if command.verb.name == 'exit':
                self.exit_game()

            if command.verb.name == 'look':
                # call look function of object of command
                if command.object == None:
                    print self.player.current_location.description
                    
                elif command.object.type == 'error':
                    invalid_input("I don't understand %s" % command.object.name,
                        input_string=command.raw,
                        tag='unknown object error',
                        game=self)
                elif 'in' in command.object.prepositional_modifiers:

                    self.config_loader.get_by_type_and_name('item', command.object.name).look_in()

                else:    # If there is no object of look it will print the current room's description
                    self.config_loader.get_by_type_and_name('item', command.object.name).look()

            if command.verb.name == 'go':
                if command.object != None:
                    try:
                        target_room = self.config_loader.get_by_type_and_name('room', command.object.name)
                        if target_room.name in self.player.current_location.exits:
                            self.player.current_location = target_room
                        else:
                            print 'Cannot go to '+Fore.GREEN+"{}".format(target_room.name)
                    except ValueError as err:
                        if err.message[0:16] == 'Cannot find room':
                            invalid_input(err.message,
                                input_string=command.raw,
                                tag='room not found',
                                game=self)
                        else:
                            raise
                else:
                    print self.player.current_location.exits
                    travel_location = input("Which Room?")
                    try:
                        self.player.current_location = self.config_loader.get_by_type_and_name('room', self.player.current_location.exits[int(travel_location)-1])
                    except ValueError:
                        try:
                            self.player.current_location = self.config_loader.get_by_type_and_name('room', travel_location)
                        except ValueError:
                            invalid_input('Place not recognized.',
                                input_string=travel_location,
                                tag='room specified not found',
                                game=self)
                            
            if command.verb.name == 'stats':
                print ' ### USER STATS ### '
                self.player.player_status()
                print ' ### GAME STATS ### '
                print 'game started : ', self.GAME_START
                print 'commands entered : ', self.commands_entered

            if command.verb.name == 'quests':
                user_input.get_events_list(self)

            if command.verb.name == 'help':
                user_input.help_info()

            if command.verb.name == 'location':
                self.player.player_location()

            if command.verb.name == 'inventory' or command.verb.name == 'bag':
                print self.player.inventory.list_of_items()

            if command.verb.name == 'save':
                self.save_game()

            if command.verb.name == 'name':
                print self.player.name

            else:
                print "I'm not sure what you mean."

            self.commands_entered += 1
        else:
            invalid_input('Command not recognized.',
                input_string=command.raw,
                tag='unknown command',
                game=self)
def test_create_Player_1():
    Player('1', 'Player1')
Exemple #26
0
import sys
import signal
from parse import parse_arguments
from Player.Player import Player
from Player.Receiver import Receiver
from Player.protocol.protocol import get_socket


receiver = None


def signal_handler(sig, frame):
    receiver.__del__()
    print("force exit", file=sys.stderr)
    exit(84)


if __name__ == '__main__':
    args = parse_arguments()
    if args.name is None or args.port is None:
        sys.exit(84)
    signal.signal(signal.SIGINT, signal_handler)
    sock = get_socket(args.port, args.host)
    receiver = Receiver(sock)
    player = Player(receiver, args.name)
    player.update()
    receiver.set_receiving(False)
def test_add_draw():
    player = Player('1', 'Player')
    player.add_draw()

    draws = player.record[player.DRAWS]
    assert (draws == 1)
Exemple #28
0
class GameInstance(object):
    def __init__(self):
        self.actions_available = BASE_ACTIONS

        self.player = Player("NoName", "Male", "Human", None)

        self.config_loader = UnsuiConfigLoader()
        self.config_loader.generate()

    #------- Actions Functions --------#
    def generate_rooms_dict(self):
        ''' this returns a list of all rooms in the area '''
        return self.config_loader.get_by_type('room')
        
    def take_action(self,action,input=user_input.default_input):
        """
        This function takes an action specified by a string
         and completes that action.
        """
        # NOTE: currently there is no check to ensure that each action is available
        # TODO: check to see if action is available before trying... like:
        # if action in self.actions_available:

        # === Base Actions: ===
        room_dict = self.generate_rooms_dict()
        if action == "exit":
            sys.exit()
        elif action == "look":
            print self.player.current_location.description
        elif action == "enter":
            raise NotImplementedError('action_main call needs to be fixed') #action_main()
        elif action == "go":
            print self.player.current_location.exits
            travel_location = input("Which Room?")
            try:
                self.player.current_location = self.config_loader.get_by_type_and_name('room', self.player.current_location.exits[int(travel_location)-1])
            except ValueError:
                try:
                    self.player.current_location = self.config_loader.get_by_type_and_name('room', travel_location)
                except ValueError:
                    print 'Place not recognized.'
        elif action == "stats":
            self.player.player_status()
            return True
        elif action == "help":
            user_input.help_info()
            return True
        elif action == "location":
            self.player.player_location()
            return True

        # === iteminteractions ===
        elif action == "grab":
            self.player.inventory.add_item(user_input.choose_object(self.keys))

        # === monster interactions
        elif action == "fight":
            opponent_engine()
            return True
        else:
            print "That's not a valid command!!!"
 def handle_events(self, events):
     temp = (pg.time.get_ticks() // 400) % 2 == 0
     if temp != self.show_cursor:
         self.show_cursor = temp
         self.draw_text()
     for e in events:
         # Any mouse action
         if e.type == MOUSEBUTTONUP:
             pos = pg.mouse.get_pos()
             pos = [
                 pos[0] - self.rects["Main"].x,
                 pos[1] - self.rects["Main"].y
             ]
             # If it happened in this rect
             if self.rects["Scroll"].collidepoint(*pos):
                 # Scroll up
                 if e.button == BUTTON_WHEELUP:
                     self.scroll = max(0, self.scroll - SCROLL_AMNT)
                 # Scroll down
                 elif e.button == BUTTON_WHEELDOWN:
                     self.scroll = min(self.max_scroll,
                                       self.scroll + SCROLL_AMNT)
                 elif e.button == BUTTON_LEFT:
                     pos = [
                         pos[0] - self.rects["Scroll"].x,
                         pos[1] - self.rects["Scroll"].y
                     ]
                     idx = (pos[1] - self.scroll) // ITEM_H
                     if idx < len(
                             self.files) and pos[0] >= ITEM_W - BUTTON_W:
                         # Top button is play button
                         if (pos[1] - self.scroll) % ITEM_H < BUTTON_W:
                             if self.mode == PLAYER:
                                 from Player.Player import Player
                                 game_vars.player = Player(
                                     c.PlayerFile(name=self.files[idx]))
                                 game_vars.player.load()
                                 self.mode = UNIVERSE
                                 self.file = c.UniverseFolder()
                                 self.load_files()
                             else:
                                 return WorldSelector(self.files[idx]).run()
                         # Bottom button is delete button
                         else:
                             if YesNo("Delete " +
                                      add_spaces(self.files[idx]) + "?",
                                      redraw_back=self.draw()).run_now():
                                 if self.mode == PLAYER:
                                     remove(self.file.path +
                                            self.files[idx] +
                                            self.file.extension)
                                 elif self.mode == UNIVERSE:
                                     rmtree(self.file.path +
                                            self.files[idx] +
                                            self.file.extension)
                                 self.load_files()
             elif self.rects["New"].collidepoint(*pos) and self.file.valid:
                 pos = [
                     pos[0] - self.rects["New"].x,
                     pos[1] - self.rects["New"].y
                 ]
                 if self.rects["Create"].collidepoint(*pos):
                     self.create_new()
         # Key press
         elif e.type == KEYDOWN:
             if e.key == K_RETURN:
                 self.create_new()
             else:
                 self.file.type_char(e)
             self.draw_text()
    def create_player(self):
        name = self.config.get('player', 'name')
        race = self.config.get('player', 'race')
        sex = self.config.get('player', 'sex')
        current_location = self.get_by_type_and_name('room', self.config.get('player', 'current_location')) 
        loaded_player = Player(name, race, sex, current_location)
        loaded_player.inventory = Inventory()
        for item in self.config.getlist('player', 'inventory'):
            loaded_player.inventory.add_item(self.get_by_type_and_name('item', item))

        loaded_player.health = self.config.getint('player', 'health')
        loaded_player.max_hp = self.config.getint('player', 'max_hp')
        loaded_player.attack = self.config.getint('player', 'attack')
        loaded_player.base_attack = self.config.getint('player', 'base_attack')
        loaded_player.armour = self.config.getint('player', 'armour')
        loaded_player.xp = self.config.getint('player', 'xp')
        loaded_player.level = self.config.getint('player', 'level')
        loaded_player.status = self.config.get('player', 'status')
        loaded_player.base_xp = self.config.getint('player', 'base_xp')

        return loaded_player          
def test_get_Player_1_character():
    player1 = Player('1', 'Player1')
    character = player1.character
    assert (character == '1')
def test_get_Player_1_name():
    player1 = Player('1', 'Player1')
    name = player1.name
    assert (name == 'Player1')
def test_create_Player_2():
    Player('2', 'Player2')
Exemple #34
0
class JAMTank(gtk.Window):

    def __init__(self):

        gtk.Window.__init__(self)

        self.set_title("JAMTank")
        self.set_icon_from_file(os.path.join(BASE, "Iconos", "jamtank.svg"))
        self.fullscreen()

        self.screen_wh = (640, 480)
        self.gameres = (640, 480)
        self.handlers = {
            "selectmode": [],
            "createservermode": [],
            "createclientmode": [],
            "servermodel": [],
            "clientmodel": [],
            "connectingplayers": [],
            "singlemode": [],
            }
        self.selectmode = False
        self.servermodel = False
        self.clientmodel = False
        self.singlemode = False
        self.createservermode = False
        self.createclientmode = False
        self.connectingplayers = False
        self._statusgame = False
        self._player = False
        self._music_vol = 0.2
        self._efect_vol = 0.2

        self.connect("key-press-event", self.__key_press_event)
        self.connect("key-release-event", self.__key_release_event)
        self.connect("realize", self.__do_realize)
        self.connect("expose-event", self.__expose)

        self.show_all()
        print "JAMTank pid:", os.getpid()
        gobject.idle_add(self.__switch, False, 1)

    def __expose(self, widget, context):
        rect = self.get_allocation()
        path = os.path.join(BASE, "Mapas", "010.png")
        pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(path, rect.width, -1)
        h = pixbuf.get_height()
        if h < rect.height:
            pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(path,
                -1, rect.height)
        self.get_property("window").draw_pixbuf(None, pixbuf, 0, 0, 0, 0)
        return True

    def __do_realize(self, widget):
        screen = self.get_screen()
        self.screen_wh = (screen.get_width(), screen.get_height())
        self.gameres = (self.screen_wh[0] / 4 * 3, self.screen_wh[1])
        xid = self.get_property("window").xid
        #os.putenv("SDL_WINDOWID", str(xid))
        print "Resolución del Monitor:", self.screen_wh
        print "id de la ventana:", xid
        print "Geometria:"
        print "\tGame:", self.gameres
        print "\tStatusGame:", (self.screen_wh[0] / 4, self.screen_wh[1])

        path = os.path.join(BASE, "Iconos", "win01.png")
        pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(path,
            self.screen_wh[0], -1)
        h = pixbuf.get_height()
        if h < self.screen_wh[1]:
            pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(path,
                -1, self.screen_wh[1])
        pixmap, mask = pixbuf.render_pixmap_and_mask()
        style = self.style
        style.bg_pixmap[gtk.STATE_NORMAL] = pixmap
        self.set_style(style)

        self.__play_music_intro()

    def __set_volumen(self, widget, valor, text, model):
        if text == "musica":
            self._music_vol = valor
            self._player.set_volumen(self._music_vol)
        elif text == "efectos":
            self._efect_vol = valor
            model.juego._audio.set_volumen(self._efect_vol)

    def __play_music_intro(self, widget=False):
        self.__stop_player()
        self._player = Player()
        self._player.load(os.path.join(BASE, "Audio", "musica01.ogg"))
        self._player.play()
        self._player.set_volumen(self._music_vol)
        self._player.connect("endfile", self.__play_music_intro)

    def __play_music_game(self, widget=False):
        self.__stop_player()
        self._player = Player()
        self._player.load(os.path.join(BASE, "Audio", "musica02.ogg"))
        self._player.play()
        self._player.set_volumen(self._music_vol)
        self._player.connect("endfile", self.__play_music_game)

    def __stop_player(self):
        if self._player:
            self._player.stop()
            del(self._player)
            self._player = False

    def __reset(self):
        self.__expose(False, False)
        self.__kill_client_model()
        self.__kill_server_model()
        self.__kill_connectingplayers()
        self.__kill_create_mode()
        self.__kill_select_mode()

    def __select_mode(self, widget, valor):
        self.__reset()  # Necesario
        if valor == "solo":
            self.__switch(False, 2)
        elif valor == "red":
            self.__switch(False, 3)
        elif valor == "join":
            self.__switch(False, 4)
        elif valor == "creditos":
            self.__switch(False, 5)
        elif valor == "salir":
            self.__stop_player()
            self.destroy()

    def __switch(self, widget, valor):
        self.__reset()  # Necesario
        if valor == 1:
            # Selección de tipo de juego
            self.selectmode = SelectMode(self)
            _id = self.selectmode.connect("switch", self.__select_mode)
            self.handlers["selectmode"].append(_id)
        elif valor == 2:
            # Jugar Solo
            self.singlemode = SingleModelGame(self)
            xid = self.get_property("window").xid
            self.singlemode.rungame(xid, self.gameres)
            self.singlemode.juego._audio.set_volumen(self._efect_vol)
            self._statusgame = SingleStatusGame(self, self.screen_wh)
            self._statusgame.connect("volumen",
                self.__set_volumen, self.singlemode)
            self._statusgame.set_nivel(self.singlemode.index)
            self.singlemode.juego.connect("update", self._statusgame.update)
            _id = self.singlemode.connect("error", self.__switch, 1)
            self.handlers["singlemode"].append(_id)
            _id = self.singlemode.connect("end-game", self.__end_single_game)
            self.handlers["singlemode"].append(_id)
            self.__play_music_game()
        elif valor == 3:
            # Crear Juego en Red
            self.createservermode = CreateServerMode(self)
            _id = self.createservermode.connect("close", self.__switch, 1)
            self.handlers["createservermode"].append(_id)
            _id = self.createservermode.connect("accion",
                self.__accion_create_server)
            self.handlers["createservermode"].append(_id)
        elif valor == 4:
            # Unirse a Juego en Red
            self.createclientmode = CreateClientMode(self)
            _id = self.createclientmode.connect("close", self.__switch, 1)
            self.handlers["createclientmode"].append(_id)
            _id = self.createclientmode.connect("accion",
                self.__accion_create_client)
            self.handlers["createclientmode"].append(_id)
        elif valor == 5:
            dialog = Credits(self)
            dialog.run()
            dialog.destroy()
            self.__switch(False, 1)

    def __accion_create_client(self, mode_client, accion,
        server_dict, player_dict):
        self.__reset()
        if accion == "run":
            host = server_dict.get("ip", "localhost")
            nickh = server_dict.get("nick", "JAMTank")
            del(server_dict["ip"])
            del(server_dict["nick"])
            self.clientmodel = ClientModelGame(self, host, server_dict,
                player_dict.get("nick", "JAMTank"),
                player_dict.get("tanque", ""))
            _id = self.clientmodel.connect("error", self.__switch, 4)
            self.handlers["clientmodel"].append(_id)
            _id = self.clientmodel.connect("end-game", self.__end_multi_game)
            self.handlers["clientmodel"].append(_id)
            if self.clientmodel.client_run():
                self.connectingplayers = ConnectingPlayers(
                    self, nickh, server_dict)
                self.connectingplayers.internal_widget.jugar.hide()
                _id = self.connectingplayers.connect("close", self.__switch, 4)
                self.handlers["connectingplayers"].append(_id)
                _id = self.connectingplayers.connect("accion",
                    self.__accion_connecting_players_client)
                self.handlers["connectingplayers"].append(_id)
                _id = self.clientmodel.connect("players",
                    self.connectingplayers.update_playeres)
                self.handlers["clientmodel"].append(_id)
                _id = self.clientmodel.connect("play-run", self.__play_run)
                self.handlers["clientmodel"].append(_id)
                self.clientmodel.new_handler_registro(True)
            else:
                print "ERROR:", self.__accion_create_client
        elif accion == "salir":
            self.__switch(False, 1)

    def __accion_create_server(self, mode_server, accion, _dict):
        self.__reset()
        if accion == "run":
            new_dict = {
                "jugadores": int(_dict.get("enemigos", 1) + 1),
                #"jugadores": int(_dict.get("enemigos", 1)),
                "mapa": str(_dict.get("mapa", "")),
                "vidas": int(_dict.get("vidas", 5))
                }
            self.servermodel = ServerModelGame(self,
                _dict.get("server", "localhost"),
                new_dict, _dict.get("nick", "JAMTank"),
                _dict.get("tanque", ""))
            _id = self.servermodel.connect("error", self.__switch, 3)
            self.handlers["servermodel"].append(_id)
            _id = self.servermodel.connect("end-game", self.__end_multi_game)
            self.handlers["servermodel"].append(_id)
            if self.servermodel.server_run():
                self.connectingplayers = ConnectingPlayers(self,
                    _dict.get("nick", "JAMTank"), new_dict)
                _id = self.connectingplayers.connect("close", self.__switch, 3)
                self.handlers["connectingplayers"].append(_id)
                _id = self.connectingplayers.connect("accion",
                    self.__accion_connecting_players_server)
                self.handlers["connectingplayers"].append(_id)
                _id = self.servermodel.connect("players",
                    self.connectingplayers.update_playeres)
                self.handlers["servermodel"].append(_id)
                _id = self.servermodel.connect("play-enabled",
                    self.connectingplayers.play_enabled)
                self.handlers["servermodel"].append(_id)
                self.servermodel.new_handler_registro(True)
            else:
                print "ERROR:", self.__accion_create_server
        elif accion == "salir":
            self.__switch(False, 1)

    def __end_multi_game(self, modelgame, _dict):
        #self.servermodel.juego.disconnect_by_func(self._statusgame.update)
        self.__play_music_intro()
        dialog = MultiDialogoEndGame(parent=self, _dict=_dict)
        dialog.run()
        dialog.destroy()
        self._statusgame.destroy()
        self.__switch(False, 1)

    def __end_single_game(self, modelgame, _dict):
        DICT["puntos"] += _dict[0].get("puntos", 0)
        DICT["disparos"] += _dict[0].get("disparos", 0)
        DICT["aciertos"] += _dict[0].get("aciertos", 0)
        keys = sorted(_dict.keys())
        keys = keys[1:]
        vidas = False
        for k in keys:
            vidas = bool(_dict[k].get("vidas", 0))
            if vidas:
                break
        if _dict[0].get("vidas", 0) and not vidas:
            dialog = SingleDialogoEndGame(self,
                "Completado Nivel %s" % self.singlemode.index,
                _dict[0], dict(DICT))
            dialog.run()
            dialog.destroy()
            # Siguiente Nivel
            self.singlemode.index += 1
            xid = self.get_property("window").xid
            self.singlemode.rungame(xid, self.gameres)
            self._statusgame.set_nivel(self.singlemode.index)
            self._statusgame.connect("volumen",
                self.__set_volumen, self.singlemode)
            self.singlemode.juego.connect("update", self._statusgame.update)
        else:
            dialog = SingleDialogoEndGame(self,
                "Game Over", _dict[0], dict(DICT))
            dialog.run()
            dialog.destroy()
            # game over
            self.__play_music_intro()
            self._statusgame.destroy()
            self.__switch(False, 1)

    def __play_run(self, client_model):
        self.clientmodel.new_handler_registro(False)
        self.__kill_connectingplayers()
        xid = self.get_property("window").xid
        self.clientmodel.rungame(xid, self.gameres)
        self.clientmodel.juego._audio.set_volumen(self._efect_vol)
        vidas = int(int(self.clientmodel._dict["vidas"]))
        self._statusgame = MultiStatusGame(self, self.screen_wh,
            self.clientmodel.juego._ip, vidas)
        self._statusgame.connect("volumen",
            self.__set_volumen, self.clientmodel)
        self.clientmodel.juego.connect("update", self._statusgame.update)
        self.__play_music_game()

    def __accion_connecting_players_server(self, con_players, valor):
        if valor == "jugar":
            self.servermodel.new_handler_anuncio(False)
            self.servermodel.new_handler_registro(False)
            self.__kill_connectingplayers()
            xid = self.get_property("window").xid
            self.servermodel.rungame(xid, self.gameres)
            self.servermodel.juego._audio.set_volumen(self._efect_vol)
            vidas = int(int(self.servermodel._dict["vidas"]))
            self._statusgame = MultiStatusGame(self, self.screen_wh,
                self.servermodel.juego._ip, vidas)
            self._statusgame.connect("volumen",
                self.__set_volumen, self.servermodel)
            self.servermodel.juego.connect("update", self._statusgame.update)
            self.__play_music_game()
        elif valor == "cancelar":
            self.__switch(False, 3)

    def __accion_connecting_players_client(self, con_players, valor):
        if valor == "cancelar":
            self.__switch(False, 4)

    def __kill_client_model(self):
        if self.clientmodel:
            self.clientmodel.close_all_and_exit()
            for h in self.handlers.get("clientmodel", []):
                if self.clientmodel.handler_is_connected(h):
                    self.clientmodel.handler_disconnect(h)
            for h in self.handlers.get("clientmodel", []):
                del(h)
            try:
                self.clientmodel.destroy()
            except:
                pass
        self.handlers["clientmodel"] = []
        del(self.clientmodel)
        self.clientmodel = False

    def __kill_server_model(self):
        if self.servermodel:
            self.servermodel.close_all_and_exit()
            for h in self.handlers.get("servermodel", []):
                if self.servermodel.handler_is_connected(h):
                    self.servermodel.handler_disconnect(h)
            for h in self.handlers.get("servermodel", []):
                del(h)
            try:
                self.servermodel.destroy()
            except:
                pass
        self.handlers["servermodel"] = []
        del(self.servermodel)
        self.servermodel = False

    def __key_press_event(self, widget, event):
        if self.servermodel:
            self.servermodel.process_key_press(event)
        elif self.clientmodel:
            self.clientmodel.process_key_press(event)
        elif self.singlemode:
            self.singlemode.process_key_press(event)
        return False

    def __key_release_event(self, widget, event):
        if self.servermodel:
            self.servermodel.process_key_release(event)
        elif self.clientmodel:
            self.clientmodel.process_key_release(event)
        elif self.singlemode:
            self.singlemode.process_key_release(event)
        return False

    def __kill_create_mode(self):
        if self.createclientmode:
            for h in self.handlers.get("createclientmode", []):
                if self.createclientmode.handler_is_connected(h):
                    self.createclientmode.handler_disconnect(h)
            for h in self.handlers.get("createclientmode", []):
                del(h)
            self.createclientmode.kill_all()
            try:
                self.createclientmode.destroy()
            except:
                pass
        self.handlers["createclientmode"] = []
        del(self.createclientmode)
        self.createclientmode = False
        if self.createservermode:
            for h in self.handlers.get("createservermode", []):
                if self.createservermode.handler_is_connected(h):
                    self.createservermode.handler_disconnect(h)
            for h in self.handlers.get("createservermode", []):
                del(h)
            try:
                self.createservermode.destroy()
            except:
                pass
        self.handlers["createservermode"] = []
        del(self.createservermode)
        self.createservermode = False

    def __kill_select_mode(self):
        if self.selectmode:
            for h in self.handlers.get("selectmode", []):
                if self.selectmode.handler_is_connected(h):
                    self.selectmode.handler_disconnect(h)
            for h in self.handlers.get("selectmode", []):
                del(h)
            try:
                self.selectmode.destroy()
            except:
                pass
        self.handlers["clientmodel"] = []
        del(self.selectmode)
        self.selectmode = False

    def __kill_connectingplayers(self):
        if self.connectingplayers:
            for h in self.handlers.get("connectingplayers", []):
                if self.connectingplayers.handler_is_connected(h):
                    self.connectingplayers.handler_disconnect(h)
            for h in self.handlers.get("connectingplayers", []):
                del(h)
            try:
                self.connectingplayers.destroy()
            except:
                pass
        self.handlers["clientmodel"] = []
        del(self.connectingplayers)
        self.connectingplayers = False
def test_get_Player_2_character():
    player2 = Player('2', 'Player2')
    character = player2.character
    assert (character == '2')
def test_get_Player_2_name():
    player2 = Player('2', 'Player2')
    name = player2.name
    assert (name == 'Player2')
Exemple #37
0
    model = Model(inputs=input, outputs=output)
    print(model.summary())

    memory = SequentialMemory(limit=50000, window_length=1)
    policy = LinearAnnealedPolicy(EpsGreedyQPolicy(),
                                  attr='eps',
                                  value_max=1.,
                                  value_min=.1,
                                  value_test=.05,
                                  nb_steps=10000)
    # policy = BoltzmannQPolicy()
    dqn = DQNAgent(model=model,
                   nb_actions=num_actions,
                   memory=memory,
                   nb_steps_warmup=100,
                   target_model_update=1e-2,
                   policy=policy)
    dqn.compile(Adam(lr=1e-3), metrics=['mae'])

    return dqn


maps = [Basic()]
player = Player()
env = gym.make("geofriend2-v0", maps=[Basic()], player=player)
dqn = build_model(env, env.action_space.n)

# dqn.load_weights("saved-weights/1.264.h5f")

dqn.test(env, nb_episodes=10, visualize=True, verbose=0)