Beispiel #1
0
 def open_tilemap(self, h=3, w=3, l=1, t_id=0, xml=None):
     """
     Creates a TileMap object from @xml_tilemap and sets selected_layer to
     zero.
     """
     self.selected_layer = 0
     self.tilemap = Tilemap(h, w, l, t_id, xml)
def main():
    # Initialisieren aller Pygame-Module und
    # Fenster erstellen (wir bekommen eine Surface, die den Bildschirm repräsentiert).
    pygame.init()
    screen = pygame.display.set_mode((800, 600))

    # Titel des Fensters setzen, Mauszeiger nicht verstecken und Tastendrücke wiederholt senden.
    pygame.display.set_caption("Pygame-Tutorial: Tilemap")
    pygame.mouse.set_visible(1)
    pygame.key.set_repeat(1, 30)

    # Clock Objekt erstellen, das wir benötigen, um die Framerate zu begrenzen.
    clock = pygame.time.Clock()

    # Wir erstellen eine Tilemap.
    map = Tilemap.Tilemap()

    # Die Schleife, und damit unser Spiel, läuft solange running == True.
    running = True
    while running:
        # Framerate auf 30 Frames pro Sekunde beschränken.

        # Pygame wartet, falls das Programm schneller läuft.
        clock.tick(30)

        # screen Surface mit Schwarz (RGB = 0, 0, 0) füllen.
        screen.fill((0, 0, 0))

        # Alle aufgelaufenen Events holen und abarbeiten.
        for event in pygame.event.get():
            # Spiel beenden, wenn wir ein QUIT-Event finden.
            if event.type == pygame.QUIT:
                running = False

            # Wir interessieren uns auch für "Taste gedrückt"-Events.
            if event.type == pygame.KEYDOWN:
                # Wenn Escape gedrückt wird posten wir ein QUIT-Event in Pygames Event-Warteschlange.
                if event.key == pygame.K_ESCAPE:
                    pygame.event.post(pygame.event.Event(pygame.QUIT))

                # Alle Tastendrücke auch der Tilemap mitteilen.
                map.handle_input(event.key)

        # Die Tilemap auf die screen-Surface rendern.
        map.render(screen)

        # Inhalt von screen anzeigen
        pygame.display.flip()
Beispiel #3
0
def main():
    # Initialisieren aller Pygame-Module und 
    # Fenster erstellen (wir bekommen eine Surface, die den Bildschirm repräsentiert).
    pygame.init()

    mouseon = 1
    keyson = 0
    screenbreite = 800
    screenhoehe = 672
    screen = pygame.display.set_mode((screenbreite, screenhoehe))
    
    # Titel des Fensters setzen, Mauszeiger nicht verstecken und Tastendrücke wiederholt senden.
    pygame.display.set_caption("Brawo: Neurofeedback Game")
    pygame.mouse.set_visible(mouseon)
    pygame.key.set_repeat(1, 30)

    # Clock Objekt erstellen, das wir benötigen, um die Framerate zu begrenzen.
    clock = pygame.time.Clock()
    
    # Wir erstellen eine Tilemap.
    global map
    map = Tilemap.Tilemap()

    pygame.mouse.set_pos(128,112)  #(screenbreite/3.0,screenhoehe/3.0)

    logging.basicConfig()
    ###counter=0
    ###sizerandom = 0
    ###with rsb.createRemoteServer('/example/serverr') as server:
    with rsb.createListener("/example/informer") as listener:

        listener.addHandler(handle)
        # Die Schleife, und damit unser Spiel, läuft solange running == True.
        running = True
        while running:
            # Framerate auf 30 Frames pro Sekunde beschränken.
            # Pygame wartet, falls das Programm schneller läuft.
            clock.tick(30)
            ###if counter%30 == 29:
            ###    counter = 0
                ###print 'server replied to synchronous call: "%s"' % server.echo('bla')
                ###sizerandom = sizerandom + 1
                ###map.changeSize(server.echo(sizerandom))
            ###counter = counter+1

            #print counter

            # screen Surface mit Schwarz (RGB = 0, 0, 0) füllen.
            screen.fill((0, 0, 0))

            # Alle aufgelaufenen Events holen und abarbeiten.
            for event in pygame.event.get():
                # Spiel beenden, wenn wir ein QUIT-Event finden.
                if event.type == pygame.QUIT:
                    running = False

                # Wir interessieren uns auch für "Taste gedrückt"-Events.
                if event.type == pygame.KEYDOWN:
                    # Wenn Escape gedrückt wird posten wir ein QUIT-Event in Pygames Event-Warteschlange.
                    if event.key == pygame.K_ESCAPE:
                        pygame.event.post(pygame.event.Event(pygame.QUIT))

                    # Alle Tastendrücke auch der Tilemap mitteilen.
                    map.handleInput(event.key,keyson)

                if event.type == MOUSEMOTION and mouseon == 1:
                    # If the mouse moves, move the player where the cursor is.
                    map.handleMouse(event.pos[0],event.pos[1])

            map.moveScript()

            # Die Tilemap auf die screen-Surface rendern.
            map.render(screen)

            # Inhalt von screen anzeigen
            pygame.display.flip()
Beispiel #4
0
class TilemapEditor(object):
    """
    Contains all actions the user can make from GUI.
    """

    def __init__(self):
        """
        Creates a TileEditor.
        IMPORTANT: open_tilemap() and open_tileset() must both be called
        before close_tilemap, close_tileset(), and edit_tile() are used.
        """
        self.selected_layer = 0
        self.selected_texture_id = 0
        self.open_tilemap()
        self.tileset = None
        
    def get_layers(self):
        return self.tilemap.get_layers()

    def set_selected_layer(self, layer):
        """
        Sets self.selected_layer to layer.
        """
        self.selected_layer = layer

    def set_selected_texture_id(self, texture_id):
        """
        Sets selected_texture_id to @texture_id.
        """
        self.selected_texture_id = texture_id

    def get_selected_texture_id(self):
        """
        Returns selected texture_id.
        """
        return self.selected_texture_id

    def get_tilemap_data(self):
        """
        Returns 2d representation of underlying tilemap as tile ids.
        """
        return self.tilemap.texture_map

    def get_tileset_keys(self):
        """
        Returns a list of all tile keys.
        """
        return self.tileset.get_tileset_keys()

    def get_tileset_values(self):
        """
        Returns a list of all tile values.
        """
        if self.tileset == None:
            return list()
        else:
            return self.tileset.get_tileset_values()

    def get_tile_photoimage(self, layer, x, y):
        """
        Returns the PhotoImage mapped to tile_id.
        """
        if self.tileset == None:
            return PhotoImage()
        else:
            return self.tileset.get_tile(self.tilemap.get_tile(layer, x, y))

    def get_tilemap_height(self):
        """
        Returns height of tilemap.
        """
        return self.tilemap.height

    def get_tilemap_width(self):
        """
        Returns height of tilemap.
        """
        return self.tilemap.width

    def get_tile_width(self):
        """
        Returns the width of a tile in pixels.
        """
        if self.tileset == None:
            return 32
        else:
            return self.tileset.get_tile_width()

    def open_tilemap(self, h=3, w=3, l=1, t_id=0, xml=None):
        """
        Creates a TileMap object from @xml_tilemap and sets selected_layer to
        zero.
        """
        self.selected_layer = 0
        self.tilemap = Tilemap(h, w, l, t_id, xml)

    def save_tilemap(self, xml_tilemap=None):
        """
        Writes xml representation of tilemap to @xml_tilemap.
        """
        self.tilemap.parse_to_xml(xml_tilemap)

    def close_tilemap(self):
        """
        Assigns None to tilemap.
        """
        self.open_tilemap()

    def open_tileset(self, tileset_source, width, height, tile_width=32, tile_height=32):
        """
        Creates a TileSet object from @png_tileset and sets selected_texture_id
        to Zero.
        """
        self.selected_texture_id = 0
        self.tileset = Tileset(tileset_source, width, height, tile_width, tile_height)

    def close_tileset(self):
        """
        Assings None to tile_set.
        """
        self.tileset = None

    def edit_tile(self, x, y):
        """
        Edits replaces current texutre id at layer, x, y with selected_texture_id.
        """
        self.tilemap.edit_tile(self.selected_layer, self.selected_texture_id, x, y)
        
def main():
    # Initialisieren aller Pygame-Module und
    # Fenster erstellen (wir bekommen eine Surface, die den Bildschirm repräsentiert).
    pygame.init()

    agent = DQNAgent()
    counter_games = 0
    record = 0
    while counter_games < 150:
        screen = pygame.display.set_mode((800, 600))

        # Titel des Fensters setzen, Mauszeiger nicht verstecken und Tastendrücke wiederholt senden.
        pygame.display.set_caption("Pygame-Tutorial: Animation")
        pygame.mouse.set_visible(1)
        pygame.key.set_repeat(1, 30)
        pygame.font.init()  # you have to call this at the start,
        myfont = pygame.font.SysFont('Comic Sans MS', 30)

        # Clock-Objekt erstellen, das wir benötigen, um die Framerate zu begrenzen.
        clock = pygame.time.Clock()

        # Wir erstellen eine Tilemap.
        map = Tilemap.Tilemap()

        event = AutoInput.AutoInput()

        # Die Schleife, und damit unser Spiel, läuft solange running == True.
        running = True
        max_steps_reached = False
        max_steps = 100
        step = 0
        max_score = map.player.pos_x
        max_score_evolution = []
        while running and not max_steps_reached:
            agent.epsilon = 80 - counter_games
            #get old state
            state_old = agent.get_state(map)
            map.player.pos_x_old = map.player.pos_x

            #perform random actions based on agent.epsilon, or choose the action
            if randint(0, 200) < agent.epsilon:
                final_move = to_categorical(randint(0, 2), num_classes=3)
            else:
                # predict action based on the old state
                prediction = agent.model.predict(state_old.reshape((1, 7)))
                final_move = to_categorical(np.argmax(prediction[0]),
                                            num_classes=3)

            # Framerate auf 30 Frames pro Sekunde beschränken.
            # Pygame wartet, falls das Programm schneller läuft.
            clock.tick(30)

            # screen Surface mit Schwarz (RGB = 0, 0, 0) füllen.
            screen.fill((198, 209, 255))

            map.handle_input(final_move)

            #continue jump animation after
            if map.player.isjump:
                map.player.jump()

            # Die Tilemap auf die screen-Surface rendern.
            map.render(screen)
            textsurface = myfont.render(
                "Game " + str(counter_games) + " Step " + str(step) +
                " Max Score " + str(max_score), False, (0, 0, 0))
            screen.blit(textsurface, (50, 50))

            #Print Hindernis onto map and check if there should be a new one
            if not map.isThereHindernis:
                map.createNewHindernis()
                map.isThereHindernis = True

            map.hindernis.move()
            map.hindernis.render(screen)
            map.checkHindernisOnMap()

            state_new = agent.get_state(map)

            crash = map.collisionDetection()

            #set treward for the new state
            reward = agent.set_reward(map.player, crash)
            #train short memory base on the new action and state
            agent.train_short_memory(state_old, final_move, reward, state_new,
                                     running)

            # Inhalt von screen anzeigen
            pygame.display.flip()

            if map.player.pos_x > max_score:
                max_score = map.player.pos_x

            step += 1
            if step >= max_steps:
                max_steps_reached = True
                max_score_evolution.append(max_score)

        agent.remember(state_old, final_move, reward, state_new, running)
        #record = get_record(map.player.pos_x, record)
        #if display_option:
        #    #display(player1, food1, game, record)
        #    pygame.time.wait(speed)

        agent.replay_new(agent.memory)
        counter_games += 1

    agent.model.save_weights('weights.hdf5')
    sns.plot(max_score_evolution)