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()
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()
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)