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)
