コード例 #1
0
 def _ReadOverworldData(self) -> None:
     self.overworld_caves = []
     for cave_type in Range.VALID_CAVE_TYPES:
         cave_num = cave_type - 0x10
         if cave_type == CaveType.ARMOS_ITEM_VIRTUAL_CAVE:
             self.overworld_caves.append(
                 Cave([0x3F, Item.POWER_BRACELET, 0x7F, 0x00, 0x00, 0x00]))
         elif cave_type == CaveType.COAST_ITEM_VIRTUAL_CAVE:
             self.overworld_caves.append(
                 Cave([0x3F, Item.HEART_CONTAINER, 0x7F, 0x00, 0x00, 0x00]))
         else:
             assert cave_type in Range.VALID_CAVE_TYPES  # Not needed?
             cave_data: List[int] = []
             for position_num in range(0, 3):
                 cave_data.append(self.overworld_raw_data[
                     self._GetOverworldCaveDataIndex(cave_type,
                                                     position_num,
                                                     is_second_byte=False)])
             for position_num in range(0, 3):
                 cave_data.append(self.overworld_raw_data[
                     self._GetOverworldCaveDataIndex(cave_type,
                                                     position_num,
                                                     is_second_byte=True)])
             self.overworld_caves.append(Cave(cave_data))
     assert len(
         self.overworld_caves
     ) == 22  # 0-19 are actual caves, 20-21 are for the armos/coast
コード例 #2
0
    def init_game(self):
        self.cave = Cave(self.screen, CAVE_HEIGHT)

        self.heli = HelicopterSprite(HELICOPTER_IMG, (250, SCREEN_HEIGHT / 2))
        self.heli_group = pygame.sprite.RenderPlain(self.heli)

        self.score = 0
        self.frame_counter = 0
        self.has_crashed = False
コード例 #3
0
    def create_caves(self):
        """
        Create all the caves for the game.
        """
        random.shuffle(CAVE_NAMES)
        caves = [Cave(name) for name in CAVE_NAMES]
        for connections in CAVE_CONNECTIONS:
            start = connections[0]
            for destination in connections[1:]:
                caves[start].add_connection(caves[destination])

        self.caves = caves
        self.current_cave = caves[0]
コード例 #4
0
def run():
    data = load_data("Day15.txt")
    cave = Cave(data, 3)
    cave.show()
    outcome, elf_deaths = cave.run()
    print(f"The outcome is {outcome}")
    # part 2
    elf_ap = 4
    elf_deaths = 1
    while elf_deaths:
        cave = Cave(data, elf_ap)
        outcome, elf_deaths = cave.run()
        print(f"The elf ap of {elf_ap} leaves {elf_deaths} elves dead")
        elf_ap += 1
    print(f"The outcome is {outcome}")
コード例 #5
0
ファイル: world.py プロジェクト: DenisVasenin/Labs
 def updateWorld(self, caveRow, caveCol, isGold, isHole, isWind, isBones,
                 allowDirects, monstersCount, arrowsCount, legsCount):
     self.__isKilledMonster = (monstersCount < self.__monstersCount)
     self.__monstersCount = monstersCount
     caveId = self.getCaveIdFromPos(caveRow, caveCol)
     cave = self.__cavesDict.get(caveId)
     # добавить пещеру в словарь если её там нет
     if (cave == None):
         cave = Cave(self, caveRow, caveCol, isGold, isHole, isWind,
                     isBones, allowDirects)
         self.__cavesDict[caveId] = cave
     # установить пещеру как текущую
     self.__currCave = cave
     # обновить стоимость всех известных пещер
     for caveId in self.__cavesDict.keys():
         self.__cavesDict[caveId].updateCost(monstersCount, arrowsCount,
                                             legsCount)
     # print('World was updated') # !!! TEST !!!
     return
コード例 #6
0
ファイル: cpagent.py プロジェクト: atila29/02285_vAIkings
    def find_wanted_passages_and_cave(self):

        if len(self.current_plan) < 2:
            return [], []

        wanted_passages = []
        wanted_cave = []
        index = 1

        next_action = self.current_plan[0]
        if self.will_move_block_passage_entrance(next_action):

            row, col = next_action.required_free

            explored_entrances = [(row, col)]
            passages_to_explore = [(p, (row, col))
                                   for p in LEVEL.map_of_passages[row][col]]

            while len(passages_to_explore) > 0:

                passage, enter = passages_to_explore.pop()

                next_on_path, new_index = self.is_passage_next_on_path(
                    passage, index)

                #Do I want to enter one of them? -> add to list
                if next_on_path:
                    wanted_passages.append((passage, enter))
                    if new_index is not None:
                        index = new_index + 1
                        entrance = self.current_plan[new_index].required_free

                        if entrance not in explored_entrances:
                            new_passages = [(p, entrance)
                                            for p in LEVEL.map_of_passages[
                                                entrance[0]][entrance[1]]
                                            if p != passage]
                            explored_entrances.append(entrance)
                            passages_to_explore = passages_to_explore + new_passages

        if len(wanted_passages) > 0:
            last_passage, enter = wanted_passages[-1]
            for entrance in last_passage.entrances:
                if entrance == enter:
                    continue
                exit_location = entrance
        else:
            exit_location = next_action.required_free
        caves_to_explore = LEVEL.map_of_caves[exit_location[0]][
            exit_location[1]]
        if caves_to_explore is not None:
            for cave in caves_to_explore:
                if self.is_cave_next_on_path(cave, index)[0]:
                    #log("Agent {} thinks cave {} is the next on the path. index: {}, action self.current_plan[index]: {}".format(self.id_, cave, index, self.current_plan[index]), "TEST", False)
                    wanted_cave.append((cave, exit_location))

        if len(wanted_cave) == 0 and len(wanted_passages) > 0:
            #check if the wanted goal is in the last passage
            last_passage, entrance = wanted_passages[-1]
            location = None

            #get goal location
            if isinstance(self.intentions, Contract):
                if isinstance(self.intentions.performative,
                              CfpMoveSpecificBoxTo):
                    box = self.intentions.performative.box
                    location = self.intentions.performative.location
                else:
                    raise NotImplementedError("Unrecognized performative")
            elif isinstance(self.intentions, AgentGoal):
                location = (self.intentions.row, self.intentions.col)
            elif self.intentions is not None and not isinstance(
                    self.intentions, Request):
                box, goal = self.intentions
                location = (goal.row, goal.col)

            #Check if goal in passage
            if location is not None and location in last_passage.locations:
                #create artificial cave
                artificial_cave = Cave(None, location)
                artificial_cave.entrance = entrance
                end = entrance
                for pos in last_passage.locations:
                    if pos == location:
                        break
                    if is_adjacent(pos, end):
                        end = pos
                        artificial_cave.locations.insert(1, end)
                        if pos in LEVEL.goals_by_pos:
                            artificial_cave.goals.append(
                                LEVEL.goals_by_pos[pos])
                artificial_cave.update_status(self.beliefs)
                wanted_cave = [(artificial_cave, entrance)]
                wanted_passages = wanted_passages[:-1]

        return wanted_passages, wanted_cave
コード例 #7
0

if __name__ == "__main__":
    # args
    parser = argparse.ArgumentParser()
    parser.add_argument("-m", "--model_path")
    parser.add_argument("-s", "--save", dest="save", action="store_true")
    parser.set_defaults(save=False)
    args = parser.parse_args()
    print('----------------------')
    print('space: moving up')
    print('q:     exit')
    print('----------------------')

    # environmet, agent
    env = Cave(time_limit=False)

    # variables
    past_time = 0
    state_t_1, reward_t, terminal = env.observe()
    action_t = 0

    # animate
    fig = plt.figure(figsize=(env.screen_n_rows / 10, env.screen_n_cols / 10))
    fig.canvas.set_window_title("{}".format(env.name))
    cid = fig.canvas.mpl_connect('key_press_event', onkey)
    cid = fig.canvas.mpl_connect('key_release_event', offkey)
    img = plt.imshow(state_t_1, interpolation="none", cmap="gray")
    ani = animation.FuncAnimation(fig,
                                  animate,
                                  init_func=init,
コード例 #8
0
class HelicopterGame(object):
    """ Wrapper class used for initializing Helicopter games and controlling state """

    def __init__(self, agent=None):
        pygame.init()
        self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT), DOUBLEBUF)
        self.clock = pygame.time.Clock()
        self.agent = agent

        self.init_game()

        if agent is None:
            self.has_started = False
            self.run_game()
        else:
            self.has_started = True

    def process_event(self, event):
        """ Process user interaction """
        if event.type == pygame.QUIT:
            pygame.quit()
        elif event.type == MOUSEBUTTONDOWN:
            self.heli.throttle = True
        elif event.type == MOUSEBUTTONUP:
            self.heli.throttle = False

        if not hasattr(event, "key"):
            return
        elif event.key == K_SPACE:
            if self.has_crashed:
                self.init_game()
            self.has_started = True
        elif event.key == K_UP:
            BG_COLOR = (random.randint(1, 255), random.randint(1, 255), random.randint(1, 255))

    def init_game(self):
        self.cave = Cave(self.screen, CAVE_HEIGHT)

        self.heli = HelicopterSprite(HELICOPTER_IMG, (250, SCREEN_HEIGHT / 2))
        self.heli_group = pygame.sprite.RenderPlain(self.heli)

        self.score = 0
        self.frame_counter = 0
        self.has_crashed = False

    def update_state(self):
        """ Update game state and redraw screen """
        if self.frame_counter % OBSTACLE_SPAWN_RATE == 0:
            midpoint = self.cave.sample_midpoint()
            self.cave.spawn_obstacle(midpoint[1] + OBSTACLE_HEIGHT / 2, midpoint[1] + CAVE_HEIGHT - OBSTACLE_HEIGHT / 2)

        self.heli_group.update(self.frame_counter)
        self.cave.update()

        if self.cave.check_collision(self.heli_group):
            self.has_crashed = True

        self.heli_group.draw(self.screen)

        self.score += 1
        self.frame_counter += 1
        self.display_score()

    def display_score(self):
        score_font = pygame.font.SysFont("arial", 20)
        score_surface = score_font.render("Score: {}".format(self.score), True, WHITE)
        score_rect = score_surface.get_rect()

        if self.has_crashed:
            score_rect.center = (SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2)
        else:
            score_rect.topleft = (30, SCREEN_HEIGHT - 50)
        self.screen.blit(score_surface, score_rect)

    def display_start_menu(self):
        title_font = pygame.font.SysFont("arial", 30)
        title_surface = title_font.render("Helicopter", True, WHITE)
        title_rect = title_surface.get_rect()
        title_rect.center = (SCREEN_WIDTH / 2, SCREEN_HEIGHT / 3)
        self.screen.blit(title_surface, title_rect)

    def display_game_over(self):
        msg_font = pygame.font.SysFont("arial", 30)
        msg_surface = msg_font.render("Game Over!", True, WHITE)
        msg_rect = msg_surface.get_rect()
        msg_rect.center = (SCREEN_WIDTH / 2, SCREEN_HEIGHT / 3)
        self.screen.blit(msg_surface, msg_rect)

        self.display_score()

    def get_state_vector(self):
        velocity = self.heli.speed
        heli_x, heli_y = self.heli.position

        cave_y = self.cave.get_ceiling_at(heli_y)
        obs_pos, ceil_pos = self.cave.next_obstacle_coords(heli_x)
        obs_pos2, ceil_pos2 = self.cave.next_obstacle_coords(obs_pos[0])

        W = float(self.screen.get_width())
        H = float(self.screen.get_height())

        state_vector = np.zeros((9, 1), dtype=np.float32)

        state_vector[0] = (heli_y - cave_y) * 1.0 / CAVE_HEIGHT
        state_vector[1] = cave_y / H * 2
        state_vector[2] = velocity / 10.0
        state_vector[3] = obs_pos[0] / (W * 1.5)
        state_vector[4] = obs_pos[1] / H
        state_vector[5] = ceil_pos[1] / H * 2
        state_vector[6] = obs_pos2[0] / (W * 1.5)
        state_vector[7] = obs_pos2[1] / H
        state_vector[8] = ceil_pos2[1] / H * 2

        return state_vector.T

    def get_current_screen(self, H=84, W=84):
        rgb = pygame.surfarray.array3d(self.screen)
        rgb = resize(rgb, (W, H))
        rgb = rgb.astype(np.float32)
        return rgb[:, :, 0] * 0.2126 + rgb[:, :, 1] * 0.7152 + rgb[:, :, 2] * 0.0722

    def get_current_state(self):
        velocity = self.heli.speed
        heli_x, heli_y = self.heli.position

        cave_y = self.cave.get_ceiling_at(heli_y)
        obs_pos, ceil_pos = self.cave.next_obstacle_coords(heli_x)

        H = self.screen.get_height()

        velocity_i = 0 if velocity > 0 else 1
        heli_y_k = int(10.0 * (heli_y - cave_y) / float(CAVE_HEIGHT))
        cave_y_k = int(10.0 * float(cave_y) / H)
        next_cave_y_k = int(10.0 * float(ceil_pos[1]) / H)
        next_obs_y_k = int(10.0 * (obs_pos[1] - ceil_pos[1]) / float(CAVE_HEIGHT))

        state_index = 0
        state_index += heli_y_k
        state_index += 10 * cave_y_k
        state_index += 100 * next_cave_y_k
        state_index += 1000 * next_obs_y_k

        if velocity > 0:
            state_index * 2

        return state_index

    def get_current_reward(self):
        if self.has_crashed:
            return -1
        else:
            return min(self.score / 100.0, 1.0)

    def run_game(self):
        if self.agent is not None:
            self.agent.start_new_game()

        prev_screen = None

        while True:
            delta_ms = self.clock.tick(FRAME_RATE)

            if self.agent is None:
                for event in pygame.event.get():
                    self.process_event(event)
            else:
                if type(self.agent) is ChainerAgent:
                    state = self.get_state_vector()
                elif type(self.agent) is ConvQAgent:
                    if prev_screen is None:
                        state = self.get_current_screen(W=84, H=84)
                    else:
                        state = prev_screen
                else:
                    state = self.get_current_state()

                agent_action = self.agent.act(state)
                if agent_action is not None:
                    self.heli.throttle = agent_action

            self.screen.fill(BG_COLOR)

            if not self.has_started:
                self.display_start_menu()
            elif self.has_crashed:
                self.display_game_over()
            else:
                self.update_state()

            if self.agent is not None:
                action = int(self.heli.throttle)
                reward = self.get_current_reward()

                if type(self.agent) is ChainerAgent:
                    new_state = self.get_state_vector()
                elif type(self.agent) is ConvQAgent:
                    new_state = self.get_current_screen(W=84, H=84)
                    prev_screen = new_state
                else:
                    new_state = self.get_current_state()

                    # self.agent.accept_reward(state, action, reward, new_state, self.has_crashed)

                if self.has_crashed:
                    return self.score

            pygame.display.flip()
コード例 #9
0
def main():
  intro()
  global PK
  print ("Hello there! Welcome to the world of Bokémon! My name is Dr. Cottonwood! People call me the Bokémon Professor! This world is inhabited by creatures called Bokémon! For some people, Bokémon are pets. Others use them for fights. Myself...I study Bokémon as a profession.\n")
  time.sleep(2)
  art.bokesquare()
  art.cottonwood()
  time.sleep(4)
  PK = input ("What is your name?\n")
  print("Nice to meet you,",PK,'\n')
  time.sleep(1)
  print("What an interesting name")
  time.sleep(3)
  print("Im so sorry to jump right into it but your parents have disapeared\nthey were working at their laboratory at the dig site right out of town")
  time.sleep(4)
  print(" you see,")
  time.sleep(3)
  print("I tried to warn them that it was a bad idea to be working that late at night but they insisted")
  time.sleep(3)
  print("I am going to send you out on a journey to defeat the leader at the collesseum in this region, the Kantob region")
  time.sleep(3)
  print("You will catch bokémon and train them to battle the collisseum leader to get the badge")
  time.sleep(3)
  print("once you get a colosseum badge I will feel confident in sending you to the dig site to look for you parents")
  time.sleep(3)
  print("I have 3 bokémon and you can choose one of these bokémon as your companion")
  print('you will also run into other bokémon on your journey.\n sadly you can only carry 3 bokémon at a time')
  time.sleep(3)
  print("so you will send the rest back to me")
  time.sleep(3)
  print('take these 20 bokesquares. they can be used to capture wild bokémon')
  time.sleep(3)
  
  #choosing starter bokemon

  print('The time has come')
  time.sleep(4)
  print('Which bokémon do you want')
  print('you will type the corresponding letter ')
  print('CHOOSE YOUR BOKEMON')
  starter = input('(A): Kennen, the electic mouse bokémon\n(B): Belldolpine, the E-dolphin time bokémon\n(C): Meister beast, The monkey bokémon\n')
  while starter not in ("A","a","B","b","C","c"):
    starter = input('please input: A,B, or C\n')

  if starter == 'A' or starter == 'a':
    boke1 = Kennen()
    sboke = 'Kennen'
  elif starter == 'B' or starter == 'b':
    boke1 = Belldolpine()
    sboke = 'Belldolpine'
  elif starter == 'C' or starter == 'c':
    boke1 = MeisterBeast()
    sboke = 'MeisterBeast'


  print('I see you chose',sboke,'\n well then I will see you on your journey')

  #go to Paintbrush Town

  time.sleep(3)
  print(chr(27) + "[2J")
  journey1()
  time.sleep(3)
  PaintbrushTown.work()
  ColosseumFight.fight()
  print(chr(27) + "[2J")
  journey2()
  Cave.work()
  time.sleep(5)
  print(chr(27) + "[2J")
  art.bokesquare()
コード例 #10
0
# Main Menu Aspects
menu_bg = Background(0, 0, screen_height, screen_width,
                     'resources/menu/menu_bg.png')
start_button = Button(330, 270, 60, 240, 'start_button', 'resources/menu/')
exit_button = Button(330, 360, 60, 240, 'exit_button', 'resources/menu/')


def draw_menu():
    window.blit(menu_bg.image, (menu_bg.x, menu_bg.y))
    window.blit(start_button.image, (start_button.x, start_button.y))
    window.blit(exit_button.image, (exit_button.x, exit_button.y))
    pygame.display.update()


# Generate inital cave
cave = Cave(screen_height // 15, screen_width // 15)
bg = Background(0, 0, screen_height, screen_width)

# Character Creation
# Class definition in entity.py
entities = []
user = Player(450, 350, 13, 30, 100, 5, 3)
entities += [user]


# Main Draw function
def redraw():
    cells_to_redraw = []
    for entity in entities:
        cells_to_redraw += entity.get_cells(cave)
    for cell in cells_to_redraw:
コード例 #11
0
ファイル: wumpus.py プロジェクト: TomGarside/wumpus_py
class PlayGame:
    _game_over, _game_win = False, False
    _game_cave = []
    _game_adventurer = Adventurer()
    _user_input = ""
    _RAND_MAX = 20
    _RAND_MIN = 1

    def __init__(self):
        self._game_cave = Cave()

    def start_game(self):
        print("         WELCOME TO HUNT THE WUMPUS\n" +
              "YOU MUST FIND THE WUMPUS IN HIS DARK AND DANGEROUS LAIR!\n" +
              "YOU ARE EQUIPPED WITH A BOW AND FIVE ARROWS.")
        while not self._game_over:
            self._game_turn()
        if self._game_win:
            print("YOU SLEW THE FOUL WUMPUS!!!!")

    def _game_turn(self):

        current_room = self._game_cave.visit_room(self._game_adventurer.current_room)
        print("YOU ARE IN ROOM : "+str(self._game_adventurer.current_room))

        if current_room[0]:
            self._encountered_wumpus()

        elif current_room[1]:
            self._encountered_pit()

        elif current_room[2]:
            self._encountered_bats()

        if not self._game_over:
            self._check_connected_rooms()
            self._user_input = input(": ")
            self._interpret_command()

    def _interpret_command(self):

        goto_schemes = ("GO", "GOTO", "GO TO", "G")
        shoot_schemes = ("SHOOT", "S")
        look_schemes = ("LOOK", "L")
        quit_schemes = ("QUIT", "Q")

        if self._user_input.upper().startswith(goto_schemes):
            room = re.search("\d+", self._user_input).group()
            self._go_to_room(int(room))

        elif self._user_input.upper().startswith(shoot_schemes):
            room = re.search("\d+", self._user_input).group()
            self._shoot_arrow(int(room))

        elif self._user_input.upper().startswith(look_schemes):
            self._look()
        elif self._user_input.upper().startswith(quit_schemes):
            print("Goodbye....")
            self._game_over = True

        else:
            print("SORRY I DIDN'T UNDERSTAND THAT")

    def _go_to_room(self, room):

        if room in self._game_cave.cave_map[self._game_adventurer.current_room]:
            self._game_adventurer.set_current_room(room)
        else:
            print("YOU CANT GET THERE FROM HERE")

    def _shoot_arrow(self, room):
        print("TWWANG YOU LOOSE AN ARROW FROM YOUR MIGHTY YEW BOW!!")
        if room in self._game_cave.cave_map[self._game_adventurer.current_room]:
            if self._game_cave.visit_room(room)[0]:
                print("YOUR SWIFT ARROW PUNCTURES THE HEART OF THE STINKING BEAST!")
                self._game_win = True
                self._game_over = True
                return
        print("CRUNCH THE ARROW BREAKS AGAINST THE STONE WALL OF THE CAVE!")
        self._arrow_missed()

    def _look(self):
        rooms = self._game_cave.cave_map[self._game_adventurer.current_room]
        print("YOU SEE PATHS TO ROOMS "+str(rooms[0])+", "+str(rooms[1])+" and "+str(rooms[2]))

    def _check_connected_rooms(self):
        rooms = self._game_cave.cave_map[self._game_adventurer.current_room]
        for e in rooms:
            if self._game_cave.visit_room(e)[0]:
                print("YOU SMELL THE FOUL STENCH OF THE WUMPUS!")
            if self._game_cave.visit_room(e)[1]:
                print("YOU HEAR A RUSH OF WIND WHISTLING FROM A NEARBY CAVE!")
            if self._game_cave.visit_room(e)[2]:
                print("YOU HEAR A LEATHERY FLAPPING NOISE!")

    def _arrow_missed(self):
        if randint(0, 3) != 3:
            print("You woke the Wumpus!")
            self._game_cave.wumpus_move()

    def _encountered_wumpus(self):
        print("YOU ARE DEVOURED BY THE EVIL WUMPUS")
        self._game_over = True

    def _encountered_bats(self):
        print("OH NO YOU WERE GRABBED BY THE SUPER BATS")
        self._game_adventurer.current_room = randint(self._RAND_MIN, self._RAND_MAX)

    def _encountered_pit(self):
        print("YOU STUMBLE DOWN A BOTTOMLESS PIT!!")
        self._game_over = True
コード例 #12
0
ファイル: wumpus.py プロジェクト: TomGarside/wumpus_py
 def __init__(self):
     self._game_cave = Cave()