def run_game():
pygame.init()
dino_settings = Settings()
screen = pygame.display.set_mode((dino_settings.screen_width, dino_settings.screen_height))
pygame.display.set_caption("dino")
score = float(0)
while True:
ground = Ground(dino_settings, screen)
dinosaur = Dinosaur(dino_settings, screen)
clouds = Group()
birds = Group()
cactus = Group()
gf.create_clouds(dino_settings, screen, clouds)
gf.create_birds(dino_settings, screen, birds)
gf.create_cactus(dino_settings, screen, cactus)
sb = Scoreboard(dino_settings, screen)
while not dinosaur.dead:
gf.check_events(dinosaur)
ground.update()
dinosaur.update()
score += 3
dino_settings.score = int(score)
sb.prep_score()
gf.update_clouds(dino_settings, screen, clouds)
gf.update_birds(dino_settings, screen, birds, dinosaur)
gf.update_cactus(dino_settings, screen, cactus, dinosaur)
gf.update_screen(dino_settings, screen, ground, clouds, dinosaur, cactus, birds, sb)
while dinosaur.dead:
exit_game = False
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_x, mouse_y = pygame.mouse.get_pos()
if button.rect.collidepoint(mouse_x, mouse_y):
exit_game = True
if exit_game:
if dino_settings.score > dino_settings.high_score:
dino_settings.high_score = dino_settings.score
sb.prep_high_score()
dino_settings.score = 0
score = 0
break
button = Button(dino_settings, screen)
button.blitme()
pygame.display.flip()
def setup():
window = pygame.display.set_mode((WIDTH, HEIGHT))
player = Bird(200, 200)
base = Ground(HEIGHT - ground.GROUND_IMG.get_height() / 2)
pipes = [Pipe(700)]
running = True
simulation_speed = 30
clock = pygame.time.Clock()
add_pipe = False
while running:
clock.tick(simulation_speed)
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
pygame.quit()
quit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
player.jump()
player.update()
base.update()
for pipe in pipes:
if pipe.collide(player):
print("you lose") # no real game end
if not pipe.passed and pipe.x < player.x:
pipe.passed = True
add_pipe = True
if pipe.x + pipe.img.get_width() < 0:
pipes.remove(pipe)
if add_pipe:
pipes.append(Pipe(700))
add_pipe = False
pipe.update()
draw(window, player, base, pipes)
def gameplay():
global high_score
context.speed = 4
context.gameOver = False
context.gameQuit = False
start_time = time.time()
playersDino = [createDino() for i in range(50)]
playersDino.append(createDino(2))
print("--- %s seconds ---" % (time.time() - start_time))
new_ground = Ground(context)
scb = Scoreboard(context)
highsc = Scoreboard(context, width * 0.78)
counter = 0
cacti = pygame.sprite.Group()
pteras = pygame.sprite.Group()
clouds = pygame.sprite.Group()
context.last_obstacle = pygame.sprite.Group()
Cactus.containers = cacti
Ptera.containers = pteras
Cloud.containers = clouds
retbutton_image, _ = load_image('replay_button.png', 35, 31, -1)
gameover_image, _ = load_image('game_over.png', 190, 11, -1)
temp_images, temp_rect = load_sprite_sheet('numbers.png', 12, 1, 11,
int(11 * 6 / 5), -1)
HI_image = pygame.Surface((22, int(11 * 6 / 5)))
HI_rect = HI_image.get_rect()
HI_image.fill(vl.background_col)
HI_image.blit(temp_images[10], temp_rect)
temp_rect.left += temp_rect.width
HI_image.blit(temp_images[11], temp_rect)
HI_rect.top = height * 0.1
HI_rect.left = width * 0.73
while not context.gameQuit:
current_score = 0
while not context.gameOver:
if pygame.display.get_surface() == None:
print("Couldn't load display surface")
context.gameQuit = True
context.gameOver = True
else:
capture_event(context, playersDino)
for player in playersDino:
player.status()
# print(len(context.last_obstacle))
verificar_colizoes(playersDino, (cacti, pteras))
criar_obstatuclos(counter, cacti, pteras, clouds)
if len(playersDino) > 0:
current_score = playersDino[0].score
newPlyers = []
for player in playersDino:
player.update()
if (not player.isDead):
newPlyers.append(player)
playersDino = newPlyers
cacti.update()
pteras.update()
clouds.update()
new_ground.update()
scb.update(current_score)
highsc.update(high_score)
if pygame.display.get_surface() != None:
screen.fill(vl.background_col)
new_ground.draw()
clouds.draw(screen)
scb.draw()
if high_score != 0:
highsc.draw()
screen.blit(HI_image, HI_rect)
cacti.draw(screen)
pteras.draw(screen)
for player in playersDino:
player.draw()
pygame.display.update()
clock.tick(vl.FPS)
if len(playersDino) == 0:
context.gameOver = True
if current_score > high_score:
high_score = current_score
if counter % 700 == 599:
context.speed += 1
counter = (counter + 1)
if context.gameQuit:
break
while context.gameOver:
if pygame.display.get_surface() == None:
print("Couldn't load display surface")
context.gameQuit = True
context.gameOver = False
else:
for event in pygame.event.get():
if event.type == pygame.QUIT:
context.gameQuit = True
context.gameOver = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
context.gameQuit = True
context.gameOver = False
if event.key == pygame.K_RETURN or event.key == pygame.K_SPACE:
context.gameOver = False
gameplay()
highsc.update(high_score)
if pygame.display.get_surface() != None:
disp_gameOver_msg(retbutton_image, gameover_image)
if high_score != 0:
highsc.draw()
screen.blit(HI_image, HI_rect)
pygame.display.update()
clock.tick(vl.FPS)
pygame.quit()
quit()
class game:
def __init__(self):
pygame.init()
self.w = 576
self.h = 1024
self.clock = pygame.time.Clock()
self.win = pygame.display.set_mode((self.w, self.h))
self.gameOverBoucle = False
pygame.display.set_caption("Flappy Bird")
self.bg = pygame.image.load("assets/bg1.png").convert_alpha()
self.startingimage = pygame.image.load(
"assets/startingscreen.png").convert_alpha()
self.launch = False
self.list_pipes = []
self.bird = Bird(self.w // 6, 400 - 25)
self.ground = Ground()
self.score = Score()
def runSolo(self):
self.timeClock = 0
self.game = True
self.all_sprites_list = pygame.sprite.RenderUpdates()
self.all_sprites_list.add(self.bird)
self.all_sprites_list.add(self.ground)
self.win.blit(self.bg, (0, 0))
pygame.display.update()
while self.game:
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.game = False
sys.exit()
self.updateScore()
self.ground.update()
self.bird.updateImgs()
self.all_sprites_list.remove(self.bird)
self.all_sprites_list.add(self.bird)
keys = pygame.key.get_pressed()
if keys[pygame.K_SPACE] and not self.launch and self.timeClock > 5:
self.bird.jump()
self.launch = True
self.win.blit(self.bg, (0, 0))
self.list_pipes.append(Pipe())
self.all_sprites_list.add(self.list_pipes[-1])
if keys[pygame.
K_SPACE] and self.launch: # Le joueur appuie sur espace et la partie est lancée
self.bird.jump(
) # Utilise la méthode "Jump" de l'instance bird du jeu
if self.launch:
self.bird.affectGravity() # On affecte la gravité à l'oiseau
if self.list_pipes[-1].rect.x <= (
2 *
self.w) // 5: # Si le dernier Pipe a passé l'oiseau
self.list_pipes.append(Pipe(
)) # On créé un nouveau Pipe qui sera généré tout à droite
self.all_sprites_list.add(self.list_pipes[-1])
if self.list_pipes[0].rect.x <= -self.list_pipes[
0].w: # Si le Pipe sort de l'écran
self.all_sprites_list.remove(self.list_pipes[0])
self.list_pipes.pop(0) # Supprime le Pipe de la liste
for pipe in self.list_pipes: # Itère dans la liste de tous les Pipes
pipe.update(
) # Met à jour la position X des Pipes en utilsant leur méthode correspondante
if self.bird.collide(
pipe
): # Si la méthode collide de Bird renvoie True = L'oiseau entre en contact avec le Pipe
self.launch = False
self.game = False
self.gameOverScreen(
) # Arrete toutes les variables et lance l'écran de fin
return
else:
self.win.blit(self.startingimage, (117, 150))
self.all_sprites_list.remove(self.ground)
self.all_sprites_list.add(self.ground)
if self.game:
self.all_sprites_list.update()
self.all_sprites_list.clear(self.win, self.bg)
spriteslist = self.all_sprites_list.draw(self.win)
pygame.display.update(spriteslist)
self.score.draw(self.win)
self.timeClock += 1
self.clock.tick(30)
def runBot(self, genomes, config):
nets = []
ge = []
birds = []
for i, g in genomes:
net = neat.nn.FeedForwardNetwork.create(g, config)
nets.append(net)
birds.append(Bird(self.w // 6, 400 - 25))
g.fitness = 0
ge.append(g)
self.timeClock = 0
self.game = True
self.list_pipes.append(Pipe())
while self.game:
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.game = False
sys.exit()
pipe_ind = 0
if len(birds) > 0:
if len(self.list_pipes
) > 1 and birds[0].rect.x > self.list_pipes[
0].rect.x + self.list_pipes[0].rect.w:
pipe_ind = 1
else:
self.game = False
self.reset()
break
for x, bird in enumerate(birds):
bird.updateImgs()
bird.affectGravity()
for pipe in self.list_pipes:
if pipe.rect.x <= bird.rect.x and pipe.rect.x >= bird.rect.x + self.ground.xspeed:
bird.score += 1
ge[x].fitness += 0.01
# ici output est la valeur retournée par les gènes
output = nets[x].activate((
bird.rect.y, # Hauteur de l'oiseau
abs(bird.rect.y - (self.list_pipes[pipe_ind].y + 100)),
abs(bird.rect.y - (self.list_pipes[pipe_ind].y - 100))
)) # ^ Differences de hauteur avec le Pipe du Haut et du Bas
# Si la valeur est supérieure à 0.5
if output[0] > 0.5:
bird.jump() # L'oiseau saute
self.ground.update()
if self.list_pipes[-1].rect.x <= (2 * self.w) // 5:
self.list_pipes.append(Pipe())
if self.list_pipes[0].rect.x <= -self.list_pipes[0].w:
self.list_pipes.pop(0)
for pipe in self.list_pipes:
pipe.update()
for i, bird in enumerate(
birds): # pour tous les oiseaux encore vivants
if bird.collide(pipe): # Si l'oiseau percute un Pipe
ge[i].fitness -= 1 # Décrémente de 1 sa fitness
birds.pop(i) # Retire l'oiseau des oiseaux restants
nets.pop(i)
ge.pop(i)
# Si les oiseaux encore vivants passent un Pipe
if pipe.rect.x <= bird.rect.x and pipe.rect.x >= bird.rect.x + self.ground.xspeed:
for g in ge:
g.fitness += 5 # Augmente de 5 les fitness de tous les oiseaux encore vivants
if self.game:
self.win.blit(self.bg, (0, 0))
for pipe in self.list_pipes:
pipe.draw(self.win)
self.ground.draw(self.win)
for bird in birds:
bird.draw(self.win)
pygame.display.update()
self.timeClock += 1
self.clock.tick(30)
def reset(self):
self.score.reset()
self.bird.reset()
self.list_pipes = []
self.ground.reset()
self.win.blit(self.bg, (0, 0))
def updateScore(self):
for pipe in self.list_pipes:
if pipe.rect.x <= self.bird.rect.x and pipe.rect.x >= self.bird.rect.x + self.ground.xspeed:
self.score.addscore()
self.win.blit(self.bg, (0, 0))
def gameOverScreen(self):
self.gameOverBoucle = True
self.timeClock = 0
while self.gameOverBoucle:
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.gameOverBoucle = False
return
keys = pygame.key.get_pressed()
if keys[pygame.K_SPACE] and self.timeClock >= 20:
self.gameOverBoucle = False
for pipe in self.list_pipes:
self.all_sprites_list.remove(pipe)
self.reset()
self.runSolo()
return
self.score.updateNewHighscore(self.win)
self.all_sprites_list.clear(self.win, self.bg)
self.bird.draw(self.win)
for pipe in self.list_pipes:
pipe.draw(self.win)
self.ground.draw(self.win)
self.score.draw(self.win)
self.score.draw_panel(self.win)
pygame.display.update()
self.timeClock += 1
pygame.quit()
class DinoGameEnv:
def __init__(self):
self.crow_height_index = 0
self.i = 0
self.high_score = 0
self.nearest = 800
self.second_nearest = 1000
self.t_reward = 0
self.discrete_spaces = np.linspace(1, 8, num=25)
self.action_complete = True
self.old_states = []
self.new_states = []
self.allow_rendering = False
pygame.mixer.pre_init(44100, -16, 2, 2048) # fix audio delay
pygame.init()
self.scr_size = (self.width,self.height) = (600,150)
self.FPS = 60
# background_col = (235,235,235)
self.background_col = (255,255,255)
self.clock = pygame.time.Clock()
self.screen = pygame.display.set_mode(self.scr_size)
pygame.display.set_caption("T-Rex Rush")
temp_images,temp_rect = self.load_sprite_sheet('numbers.png',12,1,11,int(11*6/5),-1)
self.HI_image = pygame.Surface((22,int(11*6/5)))
self.HI_rect = self.HI_image.get_rect()
self.HI_image.fill(self.background_col)
self.HI_image.blit(temp_images[10],temp_rect)
temp_rect.left += temp_rect.width
self.HI_image.blit(temp_images[11],temp_rect)
self.HI_rect.top = self.height*0.1
self.HI_rect.left = self.width*0.73
def render(self):
if pygame.display.get_surface() != None:
self.screen.fill(self.background_col)
self.new_ground.draw()
# clouds.draw(screen)
self.scb.draw()
if self.high_score != 0:
self.highsc.draw()
self.screen.blit(self.HI_image,self.HI_rect)
self.cacti.draw(self.screen)
self.crows.draw(self.screen)
self.playerDino.draw()
pygame.display.update()
def load_sprite_sheet(
self,
sheetname,
nx,
ny,
scalex = -1,
scaley = -1,
colorkey = None,
):
fullname = os.path.join('sprites_copy',sheetname)
sheet = pygame.image.load(fullname)
sheet = sheet.convert()
sheet_rect = sheet.get_rect()
sprites = []
sizex = sheet_rect.width/nx
sizey = sheet_rect.height/ny
for i in range(0,ny):
for j in range(0,nx):
rect = pygame.Rect((j*sizex,i*sizey,sizex,sizey))
image = pygame.Surface(rect.size)
image = image.convert()
image.blit(sheet,(0,0),rect)
if colorkey is not None:
if colorkey is -1:
colorkey = image.get_at((0,0))
image.set_colorkey(colorkey,RLEACCEL)
if scalex != -1 or scaley != -1:
image = pygame.transform.scale(image,(scalex,scaley))
sprites.append(image)
sprite_rect = sprites[0].get_rect()
return sprites,sprite_rect
def reset(self):
self.gamespeed = 4
self.startMenu = False
self.gameOver = False
self.gameQuit = False
self.playerDino = Dino(44,47)
self.new_ground = Ground(-1*self.gamespeed)
self.scb = Scoreboard()
self.highsc = Scoreboard(self.width*0.78)
self.counter = 0
self.t_reward = 0
self.crow_height_index = 0
self.nearest = 800
self.second_nearest = 1000
self.action_complete = True
self.cacti = pygame.sprite.Group()
self.crows = pygame.sprite.Group()
self.last_obstacle = pygame.sprite.Group()
Cactus.containers = self.cacti
Crow.containers = self.crows
self.old_states = []
self.new_states = []
self.old_states.append(self.new_ground.speed/-4)
self.old_states.append(np.digitize(9.0, self.discrete_spaces))
self.old_states.append(np.digitize(9.0, self.discrete_spaces))
self.old_states.append(self.crow_height_index)
# self.old_states.append("Crouch" if self.playerDino.rect[2] != 44 else " standing")
self.old_states.append(0 if self.playerDino.rect[2] != 44 else 1)
self.play()
return np.array(self.old_states, dtype=np.float64)
def play(self):
for c in self.cacti:
c.movement[0] = -1*self.gamespeed
if pygame.sprite.collide_mask(self.playerDino,c):
self.playerDino.isDead = True
for p in self.crows:
p.movement[0] = -1*self.gamespeed
if pygame.sprite.collide_mask(self.playerDino,p):
self.playerDino.isDead = True
if len(self.cacti) < 2:
if len(self.cacti) == 0:
self.last_obstacle.empty()
self.last_obstacle.add(Cactus(self.gamespeed,40,40))
else:
for l in self.last_obstacle:
if l.rect.right < self.width*0.7 and random.randrange(0,200) == 10:
self.last_obstacle.empty()
self.last_obstacle.add(Cactus(self.gamespeed, 40, 40))
if len(self.crows) == 0 and random.randrange(0,200) == 30 and self.counter == 1:
for l in self.last_obstacle:
if l.rect.right < self.width*0.7:
self.last_obstacle.empty()
self.last_obstacle.add(Crow(self.gamespeed, 40, 40))
self.playerDino.update()
self.cacti.update()
# self.crows.update()
self.new_ground.update()
self.scb.update(self.playerDino.score)
all_loc = []
self.nearest = 1000
self.crow_height_index = 0
for c in self.cacti:
if c.rect.left > 80:
all_loc.append(c.rect.left)
if c.rect.left < self.nearest:
self.nearest = c.rect.left
for p in self.crows:
if p.rect.left > 80:
all_loc.append(p.rect.left)
if p.rect.left < self.nearest:
self.nearest = p.rect.left
self.crow_height_index = p.crow_height_index + 1
if len(all_loc) > 1:
all_loc.remove(min(all_loc))
self.second_nearest = min(all_loc)
else:
self.second_nearest += self.playerDino.rect.right
# print(nearest - self.playerDino.rect.right, second_nearest - self.playerDino.rect.right)
self.new_states = []
self.new_states.append(self.new_ground.speed/-4)
# self.new_states.append(np.digitize(self.nearest, self.discrete_spaces))
self.new_states.append(np.digitize(round(self.nearest / self.playerDino.rect.right,2), self.discrete_spaces))
self.new_states.append(np.digitize(round(self.second_nearest / self.playerDino.rect.right,2), self.discrete_spaces))
self.new_states.append(self.crow_height_index)
# self.new_states.append("Jump" if self.playerDino.rect[1] != 100 else "running")
# self.new_states.append("Crouch" if self.playerDino.rect[2] != 44 else " standing")
self.new_states.append(0 if self.playerDino.rect[2] != 44 else 1)
if(self.playerDino.rect[1] == 100 and (self.playerDino.rect[2] == 44 or self.playerDino.rect[2] == 59)):
self.i = 0
self.action_complete = True
if(self.playerDino.rect[1] != 100):
self.i += 1
self.highsc.update(self.high_score)
if self.allow_rendering:
self.render()
self.clock.tick(self.FPS)
if self.playerDino.isDead:
# print('Reward: -1000')
# print("final_ states: ", self.new_states)
# print("<<<<<<GAME OVER>>>>>>>")
self.gameOver = True
# self.reset()
if self.counter%700 == 699:
self.new_ground.speed -= 1
self.gamespeed += 1
self.t_reward += 99
self.counter = (self.counter + 1)
def step(self, action): ## 0 - stay, 1 - jump, 2 - crouch, 3 - standup
# while not self.gameQuit:
# while not self.gameOver:
self.t_reward = 0
if True:
if action == 0: ## event.key == pygame.K_SPACE
self.action_complete = False
if self.playerDino.rect.bottom == int(0.98*self.height):
self.playerDino.isJumping = True
# if pygame.mixer.get_init() != None:
# jump_sound.play()
self.playerDino.movement[1] = -1*self.playerDino.jumpSpeed
# self.t_reward -= 36
while True:
self.play()
if self.action_complete :
self.action_complete = False
break
if action == 1: ## event.key == pygame.K_DOWN
# if not (self.playerDino.isJumping and self.playerDino.isDead):
# self.playerDino.isDucking = True
self.play()
if action == 2:
self.playerDino.isDucking = False
self.play()
if action == 4:
self.close()
return 0, 0, True
else:
self.play()
self.t_reward += 1
if self.gameOver:
self.t_reward -= 101
return np.array(self.new_states), self.t_reward, self.gameOver
# self.close()
def close(self):
pygame.display.quit()
pygame.quit()
quit()
def gameplay():
global high_score
gamespeed = 4
startMenu = False
gameOver = False
gameQuit = False
playerDino = Dino(44,47)
new_ground = Ground(-1*gamespeed)
scb = Scoreboard()
highsc = Scoreboard(width*0.78)
counter = 0
cacti = pygame.sprite.Group()
pteras = pygame.sprite.Group()
clouds = pygame.sprite.Group()
last_obstacle = pygame.sprite.Group()
Cactus.containers = cacti
Ptera.containers = pteras
Cloud.containers = clouds
retbutton_image,retbutton_rect = load_image('replay_button.png',35,31,-1)
gameover_image,gameover_rect = load_image('game_over.png',190,11,-1)
temp_images,temp_rect = load_sprite_sheet('numbers.png',12,1,11,int(11*6/5),-1)
HI_image = pygame.Surface((22,int(11*6/5)))
HI_rect = HI_image.get_rect()
HI_image.fill(background_col)
HI_image.blit(temp_images[10],temp_rect)
temp_rect.left += temp_rect.width
HI_image.blit(temp_images[11],temp_rect)
HI_rect.top = height*0.1
HI_rect.left = width*0.73
while not gameQuit:
while startMenu:
pass
while not gameOver:
if pygame.display.get_surface() == None:
print("Couldn't load display surface")
gameQuit = True
gameOver = True
else:
for event in pygame.event.get():
if event.type == pygame.QUIT:
gameQuit = True
gameOver = True
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
if playerDino.rect.bottom == int(0.98*height):
playerDino.isJumping = True
if pygame.mixer.get_init() != None:
jump_sound.play()
playerDino.movement[1] = -1*playerDino.jumpSpeed
if event.key == pygame.K_DOWN:
if not (playerDino.isJumping and playerDino.isDead):
playerDino.isDucking = True
if event.type == pygame.KEYUP:
if event.key == pygame.K_DOWN:
playerDino.isDucking = False
for c in cacti:
c.movement[0] = -1*gamespeed
if pygame.sprite.collide_mask(playerDino,c):
playerDino.isDead = True
if pygame.mixer.get_init() != None:
die_sound.play()
for p in pteras:
p.movement[0] = -1*gamespeed
if pygame.sprite.collide_mask(playerDino,p):
playerDino.isDead = True
if pygame.mixer.get_init() != None:
die_sound.play()
if len(cacti) < 2:
if len(cacti) == 0:
last_obstacle.empty()
last_obstacle.add(Cactus(gamespeed,40,40))
else:
for l in last_obstacle:
if l.rect.right < width*0.7 and random.randrange(0,50) == 10:
last_obstacle.empty()
last_obstacle.add(Cactus(gamespeed, 40, 40))
if len(pteras) == 0 and random.randrange(0,200) == 10 and counter > 500:
for l in last_obstacle:
if l.rect.right < width*0.8:
last_obstacle.empty()
last_obstacle.add(Ptera(gamespeed, 46, 40))
if len(clouds) < 5 and random.randrange(0,300) == 10:
Cloud(width,random.randrange(height/5,height/2))
playerDino.update()
cacti.update()
pteras.update()
clouds.update()
new_ground.update()
scb.update(playerDino.score)
highsc.update(high_score)
if pygame.display.get_surface() != None:
screen.fill(background_col)
new_ground.draw(screen)
clouds.draw(screen)
scb.draw(screen)
if high_score != 0:
highsc.draw(screen)
screen.blit(HI_image,HI_rect)
cacti.draw(screen)
pteras.draw(screen)
playerDino.draw(screen)
pygame.display.update()
clock.tick(FPS)
if playerDino.isDead:
gameOver = True
if playerDino.score > high_score:
high_score = playerDino.score
if counter%700 == 699:
new_ground.speed -= 1
gamespeed += 1
counter = (counter + 1)
if gameQuit:
break
while gameOver:
if pygame.display.get_surface() == None:
print("Couldn't load display surface")
gameQuit = True
gameOver = False
else:
for event in pygame.event.get():
if event.type == pygame.QUIT:
gameQuit = True
gameOver = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
gameQuit = True
gameOver = False
if event.key == pygame.K_RETURN or event.key == pygame.K_SPACE:
gameOver = False
gameplay()
highsc.update(high_score)
if pygame.display.get_surface() != None:
disp_gameOver_msg(retbutton_image,gameover_image)
if high_score != 0:
highsc.draw(screen)
screen.blit(HI_image,HI_rect)
pygame.display.update()
clock.tick(FPS)
pygame.quit()
quit()
ground = Ground(Rect(0,500,800,300),5)
player_group = pygame.sprite.Group()
player_group.add(player)
running = True
while running:
for event in pygame.event.get():
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
running = False
elif event.type == QUIT:
running = False
elif event.type == ADDCLOUD:
new_cloud = Cloud()
clouds.add(new_cloud)
screen.blit(background, (0, 0))
pressed_keys = pygame.key.get_pressed()
player.update(pressed_keys)
clouds.update()
ground.update()
ground.draw(screen)
clouds.draw(screen)
player_group.draw(screen)
pygame.display.flip()
framelock.tick(60)
def train_model(genomes, config):
global generation
nets = []
ge = []
birds = []
generation += 1
for _, g in genomes:
net = neat.nn.FeedForwardNetwork.create(g, config)
nets.append(net)
birds.append(Bird(200, 200))
g.fitness = 0
ge.append(g)
window = pygame.display.set_mode((WIDTH, HEIGHT))
base = Ground(HEIGHT - ground.GROUND_IMG.get_height() / 2)
pipes = [Pipe(700)]
running = True
simulation_speed = 30
clock = pygame.time.Clock()
add_pipe = False
score = 0
while running:
clock.tick(simulation_speed)
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
pygame.quit()
quit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
player.jump()
pipe_index = 0
if len(birds) > 0:
if len(pipes) > 1 and birds[
0].x > pipes[0].x + pipes[0].img.get_width():
pipe_index = 1
else:
running = False
break #end generation
base.update()
for index, bird in enumerate(birds):
bird.update()
ge[index].fitness += 0.3
output = nets[index].activate(
(bird.y, abs(bird.y - pipes[pipe_index].height),
abs(bird.y - pipes[pipe_index].bottom)))
if output[0] > 0.5:
bird.jump()
for pipe in pipes:
for index, bird in enumerate(birds):
if pipe.collide(bird):
ge[index].fitness = -0.5
birds.pop(index)
nets.pop(index)
ge.pop(index)
if not pipe.passed and pipe.x < bird.x:
pipe.passed = True
add_pipe = True
if pipe.x + pipe.img.get_width() < 0:
pipes.remove(pipe)
if add_pipe:
score += 1
for g in ge:
g.fitness += 5
pipes.append(Pipe(700))
add_pipe = False
pipe.update()
for index, bird in enumerate(birds):
if bird.y + bird.img.get_height() >= HEIGHT - 100 or bird.y < 0:
bird.y = HEIGHT - bird.img.get_height() - 100
birds.pop(index)
nets.pop(index)
ge.pop(index)
draw(window, birds, base, pipes, score, generation)
def run(self):
while self.paused[0] == 1:
pass
sky = Sky(self.queue)
sun = Sun(self.queue, 300, 100)
moon = Moon(self.queue, 300, 100)
ground = Ground(self.queue)
time = 75
self.shared[0] = time
day = 0
seasons = ["spring", "summer", "fall", "winter"]
season = "spring"
self.shared[2] = seasons.index(season)
seasonStages = ["early", "mid", "mid", "late"]
seasonStage = "mid"
weatherOptions = ["clear", "clear", "clear", "clear", "cloudy", "cloudy", "overcast", "rain", "rain", "storm"]
weather = choice(weatherOptions)
self.shared[1] = weatherOptions.index(weather)
self.queue.put(QueueItem("cont"))
self.paused[0] = 1
self.paused[3] = 0
while self.paused[0] == 1:
pass
while True:
sky.update(time)
sun.update(time)
moon.update(time, day)
ground.update(time, season, seasonStage, seasons)
sun.draw()
moon.draw()
ground.draw()
time += 3
if time > 1600:
time = 0
day += 1
if day > 15:
day = 0
season = seasons[int(day/4)]
self.shared[2] = seasons.index(season)
seasonStage = seasonStages[day%len(seasonStages)]
if season == "winter" and seasonStage == "early":
weather = "rain"
else:
weather = choice(weatherOptions)
self.shared[0] = time
self.shared[1] = weatherOptions.index(weather)
self.queue.put(QueueItem("cont"))
self.paused[0] = 1
sleep(0.05)
while self.paused[0] == 1:
pass
class Game:
def __init__(self):
# initialize game window, etc
pygame.init()
pygame.mixer.init()
self.screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("GEO-Run")
self.clock = pygame.time.Clock()
self.speed = 100
self.gernation = 0
def eval_genomes(self, genomes, config):
"""
runs the simulation of the current population of
players and sets their fitness based on the distance they
reach in the game.
"""
self.gernation += 1
self.score = 0
self.ground = Ground(*GROUND)
self.obstacles = [Obstacle()]
# start by creating lists holding the genome itself, the
# neural network associated with the genome and the
# bird object that uses that network to play
# list with neural network of each genum
self.nets = []
# list with player
self.players = []
# list whit genums
self.myGenomes = []
for genome_id, genome in genomes: # len(genomes) == 30 because of POP_SITZE = 30
genome.fitness = 0 # start with fitness level of 0
# creat the first version of a neural network for each genum
net = neat.nn.FeedForwardNetwork.create(genome, config)
self.nets.append(net)
self.players.append(Player(self))
self.myGenomes.append(genome)
# start Game
self.run()
def run(self):
# Game Loop
self.playing = True
while self.playing and len(
self.players
) > 0: # only run the game is at least one player is alife
self.clock.tick(self.speed)
self.events()
self.update()
self.draw()
def update(self):
# Game Loop - Update
self.ground.update()
for player in self.players:
player.update()
for obs in self.obstacles:
obs.update()
# determine the next obstacle
for i, obs in enumerate(self.obstacles):
if obs.rect.right > PLAYER_X:
nextObstIndex = i
break
for x, player in enumerate(
self.players
): # give each player a fitness of 0.1 for each frame it stays alive
self.myGenomes[x].fitness += 0.1
# Var. for Input layer
self.nextObs_dis = player.rect.right - self.obstacles[
nextObstIndex].rect.left
self.nextObs_hight = self.obstacles[nextObstIndex].rect.height
self.nextObs_width = self.obstacles[nextObstIndex].rect.width
self.player_y = player.rect.bottom
# send player Y-location, next obstacle distance, next obstacle hight, next obstacle widht
# determine from network whether to jump or not
output = self.nets[x].activate(
(self.player_y, self.nextObs_dis, self.nextObs_hight,
self.nextObs_width))
if output[
0] > 0.5: # i use the tanh activation function so result will be between -1 and 1. if over 0.5 jump
player.jump()
# check if a player hits the ground - only if falling
for player in self.players:
if player.velocity.y > 0:
hits = pygame.sprite.collide_rect(player, self.ground)
# if player hits a ground, put him on the ground
if hits:
player.pos.y = self.ground.rect.y
player.velocity.y = 0
# ckeck if a player hits a obstacle
for obs in self.obstacles:
if obs.rect.left < PLAYER_X + 30:
for i, player in enumerate(self.players):
hits = pygame.sprite.collide_rect(player, obs)
# if a player collide with an obstacle -> fitness -= 1
# he is also deleted from all lists
# bad code!! because deleting something from a iterating list
if hits:
self.myGenomes[i].fitness -= 1
self.nets.pop(i)
self.myGenomes.pop(i)
self.players.pop(i)
# kill old obstacles and count up score
for i, obs in enumerate(self.obstacles):
if obs.rect.left < -60:
self.score += 10
self.obstacles.pop(i)
# gives an player reward for passing through a obstical (not required)
for genome in self.myGenomes:
genome.fitness += 5
# only spawn new obstacles when the last one is far enough away
if self.obstacles[-1].rect.x < 800:
self.obstacles.append(Obstacle())
def events(self):
# Game Loop - events
for event in pygame.event.get():
# check for closing window
if event.type == pygame.QUIT:
self.playing = False
pygame.quit()
quit()
def draw(self):
# Game Loop - draw
self.screen.fill(BLACK)
self.ground.draw(self.screen)
for player in self.players:
player.draw(self.screen)
for obs in self.obstacles:
obs.draw(self.screen)
# drawing important Informations
self.draw_text("Score: " + str(self.score), 48, WHITE, WIDTH / 2,
HEIGHT / 6)
self.draw_text("Generation: " + str(self.gernation), 30, WHITE,
WIDTH / 2, HEIGHT / 3.5)
self.draw_text("Alive: " + str(len(self.players)), 30, WHITE,
WIDTH / 2, HEIGHT / 3)
self.draw_text("NextObs_dis: " + str(self.nextObs_dis), 20, WHITE, 100,
20)
self.draw_text("NextObs_hight: " + str(self.nextObs_hight), 20, WHITE,
100, 40)
self.draw_text("NextObs_width: " + str(self.nextObs_width), 20, WHITE,
100, 60)
self.draw_text("Player_Y: " + str(self.player_y), 20, WHITE, 100, 80)
# *after* drawing everything, flip the display
pygame.display.flip()
# for easy text creating
def draw_text(self, text, size, color, x, y):
font = pygame.font.SysFont(None, size)
text_surface = font.render(text, True, color)
text_rect = text_surface.get_rect()
text_rect.midtop = (x, y)
self.screen.blit(text_surface, text_rect)
class FlappyUnicorn:
""" A general class to manage the game. """
def __init__(self):
""" Constructor """
pygame.init()
pygame.mixer.init()
# Load game icon
self.game_icon = pygame.image.load('images/game/icon.png')
pygame.display.set_icon(self.game_icon)
self.settings = Settings()
# Set screen dimensions.
self.SCREEN_HEIGHT, self.SCREEN_WIDTH = self.settings.screen_height, self.settings.screen_width
pygame.display.set_caption("Flappy Unicorn")
self.screen = pygame.display.set_mode(
(self.SCREEN_WIDTH, self.SCREEN_HEIGHT))
self.screen_rect = self.screen.get_rect()
self.game_active = False
self.game_over = False
self.pillar_time_elapsed = 0
self.cloud_time_elapsed = 0
self.clock_tick = 0
# Audio instance.
self.audio = Audio()
# Create start and game over screens.
self.start_screen = StartScreen(self)
self.game_over_screen = GameOver(self)
# Create an animated flying unicorn
self.unicorn = Unicorn(self)
self.unicorn_sprite = pygame.sprite.Group(self.unicorn)
# Create the background
self.background = Background(self)
# Create ground.
self.ground = Ground(self)
# Create cloud.
self.clouds = pygame.sprite.Group()
# Create pillar sprite group.
self.pillars = pygame.sprite.Group()
# Create the scoreboard.
self.scoreboard = Scoreboard(self)
def run(self):
""" Main game loop. """
# Create clock to track time.
clock = pygame.time.Clock()
while True:
# Check key pressed events.
self._check_key_events()
self._update_screen()
# Update clock and time elapsed.
self.pillar_time_elapsed += clock.get_time()
self.cloud_time_elapsed += clock.get_time()
clock.tick(60)
def _check_key_events(self):
""" Check for key pressed events. """
for event in pygame.event.get():
# Quit / Exit game.
if event.type == pygame.QUIT:
sys.exit(0)
# Key pressed event.
if event.type == pygame.KEYDOWN:
self._check_key_down_events(event)
# Mouse clicked event.
if event.type == pygame.MOUSEBUTTONDOWN:
mouse_position = pygame.mouse.get_pos()
self._check_button_clicked(mouse_position)
def _check_key_down_events(self, event):
""" Respond to a key pressed down event. """
if not self.game_over and not self.start_screen.screen_active:
if event.key == pygame.K_SPACE:
self.unicorn.jump_count = 0
self.audio.play_sound('wings')
elif event.key == pygame.K_q:
sys.exit(0)
elif event.key == pygame.K_p:
self.game_active = True
self.start_screen.screen_active = False
def _check_button_clicked(self, mouse_position):
""" Check if player clicked a button and process request. """
# Start game button
if self.start_screen.start_button.rect.collidepoint(mouse_position):
self.game_active = True
self.start_screen.screen_active = False
pygame.mouse.set_visible(False)
# Retry Button
if self.game_over_screen.retry_button.rect.collidepoint(
mouse_position):
self.restart()
def _check_unicorn_collision(self):
""" Respond to a collision event. """
for unicorn in self.unicorn_sprite:
if unicorn.rect.bottom >= self.settings.gnd_col_zone or unicorn.rect.top <= self.screen_rect.top:
self._game_over_loop()
self.audio.play_sound('hit')
return
obstacle_collision = pygame.sprite.groupcollide(
self.unicorn_sprite, self.pillars, False, False)
if obstacle_collision:
self._game_over_loop()
self.audio.play_sound('hit')
def _check_clouds(self):
""" Manage clouds on screen. """
if self.cloud_time_elapsed > self.settings.cloud_frequency and len(
self.clouds) < self.settings.cloud_qty:
self.cloud_time_elapsed = 0
new_cloud = Cloud(self)
self.clouds.add(new_cloud)
self._check_cloud_edges()
def _check_cloud_edges(self):
""" Loop through cloud sprites and check if cloud is still on screen.
Remove clouds that have scrolled off the display.
"""
for cloud in self.clouds:
if cloud.cloud_rect.right <= 0:
self.clouds.remove(cloud)
def _create_pillar(self):
""" Create a new pillar object and add to the pillar sprite group. """
top_pillar = PillarTop(self)
bottom_pillar = PillarBottom(self, top_pillar.rect)
pillars = [top_pillar, bottom_pillar]
self.pillars.add(*pillars)
def _check_pillars(self):
""" A method that manages the pillar obstacles. """
if self.pillar_time_elapsed > self.settings.pillar_frequency:
# If a certain time has elapsed (settings.pillar_frequency) create a new pillar.
self.pillar_time_elapsed = 0
self._create_pillar()
self._check_pillar_edges()
def _check_pillar_edges(self):
"""
Loop through the group of pillar sprites and check their right edge.
Remove pillar sprites that have left the screen.
"""
for pillar in self.pillars.copy():
if pillar.rect.right <= 0:
self.pillars.remove(pillar)
def _perform_checks(self):
""" Check sprite positions. """
self._check_pillars()
self._check_clouds()
self._check_unicorn_collision()
self.scoreboard.check_score_zone(self.unicorn_sprite, self.pillars)
def _update_screen(self):
""" Update surfaces and flip screen. """
# Update background image.
self.background.update()
if self.game_active:
self._perform_checks()
self.scoreboard.update()
# Draw the pillar sprites that have been added to the pillar sprite group.
for pillar in self.pillars.sprites():
pillar.draw_pillars()
# Update unicorn position and animation.
self.unicorn_sprite.update()
self.unicorn_sprite.draw(self.screen)
# Draw new clouds to screen.
for cloud in self.clouds.sprites():
cloud.draw_cloud()
if not self.game_over:
# Update scrolling ground position.
self.ground.update()
# Update clouds position
self.clouds.update()
# Update pillar position
self.pillars.update()
elif not self.game_over:
# Start Screen.
self.ground.blit_background(start_screen=True)
self.start_screen.blit_me()
else:
self._game_over_loop()
# Flip the new display to screen.
pygame.display.flip()
def _game_over_loop(self):
"""
Halt game blit game over and retry button to screen.
Enable mouse cursor.
"""
self.game_over = True
self.game_active = False
if self.unicorn.rect.bottom >= self.screen_rect.bottom:
self.unicorn.rect.bottom = self.screen_rect.bottom
self.unicorn_sprite.update(animation=False)
self.unicorn_sprite.draw(self.screen)
self.pillars.draw(self.screen)
self.ground.blit_background()
self.scoreboard.update()
self.game_over_screen.blit_me()
# Enable mouse cursor.
pygame.mouse.set_visible(True)
def restart(self):
""" Reset game attributes and start a new game. """
self.pillars.empty()
self.clouds.empty()
self.unicorn.reset_rect()
self.scoreboard.score = 0
self.pillar_time_elapsed = 0
self.cloud_time_elapsed = 0
self.game_over = False
self.game_active = True
pygame.mouse.set_visible(False)
