class Controller(object):
def __init__(self, genomes, config, gen):
pygame.init()
self.screen = pygame.display.set_mode(size)
self.score_text = pygame.font.SysFont('Comic Sans', 32)
self.birds = []
self.computer_player = []
self.gen = gen
self.genomes = []
if computer_playing:
for g_id, genome in genomes:
self.birds.append(Bird())
net = neat.nn.FeedForwardNetwork.create(genome,config)
self.computer_player.append(net)
self.genomes.append(genome)
#self.networks = self.computer_player.increment_gen()
self.scores = [0]*len(self.computer_player)
else:
self.birds = [Bird()]
self.num_alive = len(self.birds)
self.frame_score = 0
self.floor = Floor(size[1])
self.pipes = []
self.lay_pipe()
self.playing_game = True
def play_game(self):
time_since_pipe = 1
score = 0
collisions = [False] * len(self.birds)
if not computer_playing:
try:
#os.remove("./player_data.csv")
pass
except:
pass
self.data_to_write = []
while(self.playing_game):
if not computer_playing:
self.read_keyboard_input(self.birds[0])
else:
for i in range(len(self.birds)):
if self.birds[i].alive:
self.read_computer_input(self.birds[i], self.computer_player[i])
count = 0
for b in self.birds:
if b.alive and not collisions[count]:
b.move()
count += 1
self.draw_everything(score)
#COLLISIONS DETECTED
if not computer_playing and any(collisions):
self.playing_game = False
else:
col_count = 0
#CHECK ALL COLLISIONS
for i in range(len(collisions)-1, -1, -1):
if self.birds[i].alive:
if collisions[i]:
self.birds[i].alive = False
self.scores[i] = self.frame_score
self.num_alive -= 1
if self.num_alive == 0:
self.playing_game = False
self.save_best_score()
return self.scores
col_count = 0
for b in self.birds:
if b.alive:
collisions[col_count] = self.check_for_collision(b)
col_count += 1
if play_with_pipes:
self.update_pipes()
if time_since_pipe % 62 == 0 and play_with_pipes:
time_since_pipe = 1
self.lay_pipe()
pygame.display.update()
pygame.event.pump()
pygame.time.Clock().tick(fr)
time_since_pipe += 1
score = self.increment_score(score, self.birds[0])
self.increment_frame_score()
self.display_score()
self.quit_game()
def get_stimuli(self, bird):
#x distance to next pipe, y distance to center of pipe
stimuli = [999]
if bad_stimuli:
stimuli = [999, 999, 999, 999, 999]
next_pipe = None
for p in self.pipes:
if p.top_left[0] + p.pipe_width > bird.top_left[0]:
next_pipe = p
break
if next_pipe:
stimuli = [next_pipe.center - bird.top_left[1]]
if bad_stimuli:
stimuli.extend([next_pipe.top_left[0] - bird.top_left[0] + next_pipe.pipe_width, bird.y_velocity, bird.acceleration, next_pipe.center])
return stimuli
def increment_frame_score(self):
self.frame_score += 1
if self.frame_score == 700:
c = 0
for b in self.birds:
if b.alive:
break
c+=1
self.save_best_score(self.frame_score, self.genomes[c])
def save_best_score(self, frame_score = None, net = None):
global best_score_ever, best_per_gen_file, best_ever_file
best_score_in_gen = -1
best_in_gen = None
c = 0
if not frame_score:
for s in self.scores:
if s > best_score_in_gen:
best_in_gen = self.genomes[c]
best_score_in_gen = s
c = c + 1
else:
best_score_in_gen = frame_score
best_in_gen = net
best_in_gen = str(best_in_gen).replace('\n', '').replace('\r', '')
fhandler = open(best_per_gen_file, "a")
fhandler.writelines("Gen #%d scored %f pts: " % (GENERATION, best_score_in_gen) + str(
best_in_gen) + "\n")
fhandler.close()
if best_score_in_gen > best_score_ever:
fhandler = open(best_ever_file, "w")
fhandler.writelines("Gen #%d scored %f pts: " % (GENERATION, best_score_in_gen) + str(best_in_gen) + "\n")
fhandler.close()
best_score_ever = best_score_in_gen
def increment_score(self, score, bird):
for p in self.pipes:
if p.top_left[0] < bird.top_left[0] - p.pipe_width and not p.scored:
p.scored = True
score += 1
return score
def display_score(self):
pass
def quit_game(self):
pygame.quit()
def read_keyboard_input(self, bird):
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
bird.flap()
return "SPACE"
elif event.key == pygame.K_ESCAPE:
self.playing_game = False
return "NO_INPUT"
def read_computer_input(self, bird, nn):
s = self.get_stimuli(bird)
input = s
out = nn.activate(input)
if out[0] >= .5:
action = 'SPACE'
else:
action = 'NO_INPUT'
if action == "SPACE":
bird.flap()
def check_for_collision(self, bird):
if bird.top_left[1] < 0:
return True
if pygame.sprite.collide_rect(bird, self.floor):
if pygame.sprite.collide_mask(bird, self.floor):
return True
for p in self.pipes:
if p.top_left[0] < size[0]:
if p.check_for_collision(bird,pixel_collision=False):
return True
return False
def update_pipes(self):
for p in self.pipes:
if p.top_left[0] < -200:
self.pipes.remove(p)
break
for p in self.pipes:
p.move()
def lay_pipe(self):
p = Pipe(random.randint(round(256), round(size[1]-256)), size[1], size[0])
self.pipes.append(p)
def draw_everything(self, score):
self.draw_background()
self.draw_birds()
self.draw_pipe()
self.draw_floor()
self.draw_score(score)
if computer_playing:
self.draw_computer_info()
def draw_computer_info(self):
# cur_gen, best, avg, std = self.get_network_stats()
num_alive = len([b for b in self.birds if b.alive])
# num_per_gen = self.computer_player.num_per_gen
# best_ever = self.computer_player.best_score_ever
# if self.frame_score > best_ever:
# best_ever = self.frame_score
s = self.score_text.render("Frame Score: %d" % self.frame_score, False, (255, 255, 255))
na = self.score_text.render("Alive: %d / %d" % (num_alive, gen_size), False, (255, 255, 255))
g = self.score_text.render("Generation: %d" % self.gen, False, (255, 255, 255))
# b = self.score_text.render("Best Score: %d" % best_ever, False, (255, 255, 255))
self.screen.blit(g, (5, 5))
self.screen.blit(na, (5, 25))
self.screen.blit(s, (5, 45))
# self.screen.blit(b, (5, 65))
def draw_score(self, score):
t = self.score_text.render("%s" % score, False, (255, 255, 255))
self.screen.blit(t, (round(size[0]/2), 100))
def draw_birds(self):
for b in self.birds:
if b.alive:
b.draw(self.screen)
def draw_background(self):
self.screen.fill(bg_color)
def draw_pipe(self):
for p in self.pipes:
p.draw(self.screen)
def draw_floor(self):
self.floor.draw(self.screen)
class Engine():
def __init__(self, screen):
print("Initializing Lumidify Isometric Engine (LIE) Version 1.0 ...")
self.screen = screen
self.screen.blit(FONT.render("Loading...", True, (255, 255, 255)),
(0, 0))
self.screen.blit(
FONT.render("Remember - patience is a virtue.", True,
(255, 255, 255)), (0, 40))
pygame.display.update()
self.tiles, self.obstacles, self.characters, self.items, self.bullets = load_tiles(
)
self.floor = Floor(self.screen, self.tiles)
self.obstacles = Obstacles(self.screen, self.obstacles,
self.characters, self.items, self.bullets,
self)
temp = self.obstacles.characters["GUB"].copy()
temp["weapon"] = None
self.player = Montag(self.screen,
x=0,
y=0,
obstaclemap=self.obstacles,
**temp)
self.obstacles.player = self.player
self.game_variables = {}
self.active_layer = 0
self.screen_offset = [0, 0]
self.loaded_maps = {}
self.saved_maps = []
self.current_map = ""
self.wongame = False
self.lostgame = False
self.show_fps = True
def savegame(self):
if not os.path.isdir("save"):
os.mkdir("save")
for path, item in self.loaded_maps.items():
final_path = os.path.join("save", path)
if not os.path.exists(final_path):
os.makedirs(final_path)
self.obstacles.save(final_path,
item["characters"] + item["dead_characters"],
item["item_map"], item["triggers"],
item["obstacles"])
self.floor.save(os.path.join(final_path, "floor.py"),
item["floor"])
with open(os.path.join(final_path, "config.py"), "w") as f:
f.write("config = " + repr(item["config"]))
if not os.path.exists(os.path.join("save", self.current_map)):
os.makedirs(os.path.join("save", self.current_map))
self.obstacles.save(
os.path.join("save", self.current_map),
self.obstacles.charactermap + self.obstacles.dead_characters,
self.obstacles.item_map, self.obstacles.triggers,
self.obstacles.layers)
self.floor.save(os.path.join("save", self.current_map, "floor.py"),
self.floor.layers)
with open(os.path.join("save", self.current_map, "config.py"),
"w") as f:
f.write("config = " + repr(self.config))
player_config = {
"dead": self.player.dead,
"grid_pos": self.player.grid_pos.copy(),
"current_map": self.current_map,
"won": self.wongame,
"lost": self.lostgame,
"inventory": self.player.get_inventory(),
"health": self.player.health
}
with open(os.path.join("save", "config.py"), "w") as f:
f.write("player_config = " + repr(player_config))
def load_game(self):
if os.path.isdir("save"):
self.wongame = False
self.lostgame = False
player_config = load_module(os.path.join(
"save", "config.py")).player_config.copy()
self.player.reset()
self.player.dead = player_config["dead"]
self.player.load_inventory(player_config["inventory"])
self.saved_maps = os.listdir("save")
self.current_map = player_config["current_map"]
self.player.health = player_config["health"]
self.saved_maps = [
os.path.join("maps", x) for x in os.listdir("save/maps")
]
self.loaded_maps = {}
self.load_map(self.current_map,
spawn_pos=player_config["grid_pos"])
if player_config["won"]:
self.wingame()
elif player_config["lost"]:
self.losegame()
def load_map(self, path, **kwargs):
if path in self.saved_maps:
self.saved_maps.remove(path)
path = os.path.join("save", path)
self.current_map = None
if self.current_map:
self.loaded_maps[self.current_map] = {}
self.loaded_maps[
self.current_map]["floor"] = self.floor.layers.copy()
self.loaded_maps[
self.current_map]["obstacles"] = self.obstacles.layers.copy()
self.loaded_maps[self.current_map][
"characters"] = self.obstacles.charactermap.copy()
self.loaded_maps[self.current_map][
"dead_characters"] = self.obstacles.dead_characters.copy()
self.loaded_maps[
self.current_map]["item_map"] = self.obstacles.item_map.copy()
self.loaded_maps[
self.current_map]["bullets"] = self.obstacles.bullets.copy()
self.loaded_maps[
self.current_map]["triggers"] = self.obstacles.triggers.copy()
self.loaded_maps[self.current_map]["config"] = self.config.copy()
if path.startswith("save"):
self.current_map = path[5:]
else:
self.current_map = path
if path in self.loaded_maps:
self.floor.layers = self.loaded_maps[path]["floor"].copy()
self.obstacles.layers = self.loaded_maps[path]["obstacles"].copy()
self.obstacles.charactermap = self.loaded_maps[path][
"characters"].copy()
self.obstacles.dead_characters = self.loaded_maps[path][
"dead_characters"].copy()
self.obstacles.item_map = self.loaded_maps[path]["item_map"].copy()
self.obstacles.bullets = self.loaded_maps[path]["bullets"].copy()
self.obstacles.triggers = self.loaded_maps[path]["triggers"].copy()
self.config = self.loaded_maps[path]["config"].copy()
else:
self.floor.load_tilemap(os.path.join(path, "floor.py"))
self.obstacles.load_obstaclemap(os.path.join(path, "obstacles.py"))
self.obstacles.load_charactermap(
os.path.join(path, "characters.py"))
self.obstacles.load_item_map(os.path.join(path, "items.py"))
self.obstacles.load_triggermap(os.path.join(path, "triggers.py"))
self.obstacles.dead_characters = []
self.obstacles.bullets = []
self.config = load_module(os.path.join(path,
"config.py")).config.copy()
try:
pygame.mixer.music.load(self.config.get("music", "Betrayed.ogg"))
pygame.mixer.music.play(-1)
except:
pass
if kwargs.get("spawn_pos", None):
self.player.grid_pos = kwargs["spawn_pos"].copy()
else:
self.player.grid_pos = self.config.get("spawn_pos", [0, 0]).copy()
self.player.reset()
mapsize = self.config.get("level_dimensions", [50, 50])
self.obstacles.change_size(mapsize)
self.obstacles.refresh_trigger_quadtree()
self.obstacles.refresh_grid()
def update(self, event=None):
if not self.wongame:
screen_size = self.screen.get_size()
isox = (self.player.grid_pos[0] -
self.player.grid_pos[1]) * (ISOWIDTH // 2)
isoy = (self.player.grid_pos[0] +
self.player.grid_pos[1]) * (ISOHEIGHT // 2)
self.screen_offset = [
screen_size[0] // 2 - isox, screen_size[1] // 2 - isoy
]
current_time = pygame.time.get_ticks()
self.floor.update(current_time)
self.obstacles.update(current_time=current_time, event=event)
if event and event.type == KEYDOWN:
if event.key == K_F3:
self.savegame()
elif event.key == K_F4:
self.load_game()
elif event.key == K_F11:
self.show_fps = not self.show_fps
def wingame(self):
self.wongame = True
pygame.mixer.music.load("wingame.ogg")
pygame.mixer.music.play(-1)
def losegame(self):
self.lostgame = True
pygame.mixer.music.load("Sad_Piano_3.ogg")
pygame.mixer.music.play(-1)
def draw(self):
self.floor.draw(self.screen_offset)
self.obstacles.draw(self.screen_offset)
if self.wongame:
screen.blit(
FONT.render("Congratulations, you won!", True,
(255, 255, 255)), (0, 0))
elif self.lostgame:
screen.blit(
FONT.render("Shame be upon you! You lost!", True,
(255, 255, 255)), (0, 0))
self.screen.blit(
FONT.render("Health: " + str(self.player.health), True,
(255, 255, 255)), (self.screen.get_size()[0] - 200, 0))
if self.show_fps:
self.screen.blit(
FONT.render("FPS: " + str(round(clock.get_fps(), 2)), True,
(255, 255, 255)),
(self.screen.get_size()[0] - 400, 0))
class Engine():
def __init__(self, screen):
print("Initializing Lumidify Isometric Engine (LIE) Version 1.0 ...")
self.screen = screen
self.screen.blit(FONT.render("Loading...", True, (255, 255, 255)), (0, 0))
self.screen.blit(FONT.render("Patience is a virtue.", True, (255, 255, 255)), (0, 40))
pygame.display.update()
self.tiles, self.obstacles, self.characters, self.items, self.bullets = load_tiles()
self.floor = Floor(self.screen, self.tiles)
self.obstacles = Obstacles(self.screen, self.obstacles, self.characters, self.items, self.bullets, self)
temp = self.obstacles.characters["GUB"].copy()
temp["weapon"] = None
self.player = Montag(self.screen, x=0, y=0, obstaclemap=self.obstacles, **temp)
self.obstacles.player = self.player
self.game_variables = {}
self.active_layer = 0
self.screen_offset = [0, 0]
self.loaded_maps = {}
self.saved_maps = []
self.current_map = ""
self.wongame = False
self.lostgame = False
def savegame(self):
if not os.path.isdir("save"):
os.mkdir("save")
for path, item in self.loaded_maps.items():
final_path = os.path.join("save", path)
if not os.path.exists(final_path):
os.makedirs(final_path)
self.obstacles.save(final_path, item["characters"] + item["dead_characters"], item["item_map"], item["triggers"], item["obstacles"])
self.floor.save(os.path.join(final_path, "floor.py"), item["floor"])
with open(os.path.join(final_path, "config.py"), "w") as f:
f.write("config = " + repr(item["config"]))
if not os.path.exists(os.path.join("save", self.current_map)):
os.makedirs(os.path.join("save", self.current_map))
self.obstacles.save(os.path.join("save", self.current_map), self.obstacles.charactermap + self.obstacles.dead_characters, self.obstacles.item_map, self.obstacles.triggers, self.obstacles.layers)
self.floor.save(os.path.join("save", self.current_map, "floor.py"), self.floor.layers)
with open(os.path.join("save", self.current_map, "config.py"), "w") as f:
f.write("config = " + repr(self.config))
player_config = {"dead": self.player.dead, "grid_pos": self.player.grid_pos.copy(), "current_map": self.current_map, "won": self.wongame, "lost": self.lostgame, "inventory": self.player.get_inventory(), "health": self.player.health}
with open(os.path.join("save", "config.py"), "w") as f:
f.write("player_config = " + repr(player_config))
def load_game(self):
if os.path.isdir("save"):
player_config = load_module(os.path.join("save", "config.py")).player_config.copy()
self.player.reset()
self.player.dead = player_config["dead"]
self.player.load_inventory(player_config["inventory"])
self.saved_maps = os.listdir("save")
self.current_map = player_config["current_map"]
self.player.health = player_config["health"]
self.saved_maps = os.listdir("save")
self.load_map(self.current_map, spawn_pos=player_config["grid_pos"])
if player_config["won"]:
self.wingame()
elif player_config["lost"]:
self.losegame()
def load_map(self, path, **kwargs):
if path in self.saved_maps:
self.saved_maps.remove(path)
path = os.path.join("save", path)
if self.current_map:
self.loaded_maps[self.current_map] = {}
self.loaded_maps[self.current_map]["floor"] = self.floor.layers.copy()
self.loaded_maps[self.current_map]["obstacles"] = self.obstacles.layers.copy()
self.loaded_maps[self.current_map]["characters"] = self.obstacles.charactermap.copy()
self.loaded_maps[self.current_map]["dead_characters"] = self.obstacles.dead_characters.copy()
self.loaded_maps[self.current_map]["item_map"] = self.obstacles.item_map.copy()
self.loaded_maps[self.current_map]["bullets"] = self.obstacles.bullets.copy()
self.loaded_maps[self.current_map]["triggers"] = self.obstacles.triggers.copy()
self.loaded_maps[self.current_map]["config"] = self.config.copy()
if path.startswith("save"):
self.current_map = path[5:]
else:
self.current_map = path
if path in self.loaded_maps:
self.floor.layers = self.loaded_maps[path]["floor"].copy()
self.obstacles.layers = self.loaded_maps[path]["obstacles"].copy()
self.obstacles.charactermap = self.loaded_maps[path]["characters"].copy()
self.obstacles.dead_characters = self.loaded_maps[path]["dead_characters"].copy()
self.obstacles.item_map = self.loaded_maps[path]["item_map"].copy()
self.obstacles.bullets = self.loaded_maps[path]["bullets"].copy()
self.obstacles.triggers = self.loaded_maps[path]["triggers"].copy()
self.config = self.loaded_maps[path]["config"].copy()
else:
self.floor.load_tilemap(os.path.join(path, "floor.py"))
self.obstacles.load_obstaclemap(os.path.join(path, "obstacles.py"))
self.obstacles.load_charactermap(os.path.join(path, "characters.py"))
self.obstacles.load_item_map(os.path.join(path, "items.py"))
self.obstacles.load_triggermap(os.path.join(path, "triggers.py"))
self.obstacles.dead_characters = []
self.obstacles.bullets = []
self.config = load_module(os.path.join(path, "config.py")).config.copy()
try:
pygame.mixer.music.load(self.config.get("music", "Search_Art_S31_Undercover_Operative_0.ogg"))
pygame.mixer.music.play(-1)
except:
pass
if kwargs.get("spawn_pos", None):
self.player.grid_pos = kwargs["spawn_pos"].copy()
else:
self.player.grid_pos = self.config.get("spawn_pos", [0, 0]).copy()
self.player.reset()
mapsize = self.config.get("level_dimensions", [50, 50])
self.obstacles.change_size(mapsize)
self.obstacles.refresh_trigger_quadtree()
self.obstacles.refresh_grid()
def update(self, event=None):
if not self.wongame:
screen_size = self.screen.get_size()
isox = (self.player.grid_pos[0] - self.player.grid_pos[1]) * (ISOWIDTH // 2)
isoy = (self.player.grid_pos[0] + self.player.grid_pos[1]) * (ISOHEIGHT // 2)
self.screen_offset = [screen_size[0] // 2 - isox, screen_size[1] // 2 - isoy]
current_time = pygame.time.get_ticks()
self.floor.update(current_time)
self.obstacles.update(current_time=current_time, event=event)
if event and event.type == KEYDOWN:
if event.key == K_F3:
self.savegame()
elif event.key == K_F4:
self.load_game()
def wingame(self):
self.wongame = True
pygame.mixer.music.load("wingame.ogg")
pygame.mixer.music.play(-1)
def losegame(self):
self.lostgame = True
pygame.mixer.music.load("Sad_Piano_3.ogg")
pygame.mixer.music.play(-1)
def draw(self):
self.floor.draw(self.screen_offset)
self.obstacles.draw(self.screen_offset)
if self.wongame:
screen.blit(FONT.render("Congratulations, you won!", True, (255, 255, 255)), (0, 0))
elif self.lostgame:
screen.blit(FONT.render("Shame be upon you! You lost!", True, (255, 255, 255)), (0, 0))
self.screen.blit(FONT.render("Health: " + str(self.player.health), True, (255, 255, 255)), (self.screen.get_size()[0] - 200, 0))
class Controller(object):
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode(size)
self.score_text = pygame.font.SysFont('Comic Sans', 32)
self.birds = []
self.networks = []
if computer_playing:
self.computer_player = Neat_O_Player()
for i in range(self.computer_player.num_per_gen):
self.birds.append(Bird())
self.networks = self.computer_player.increment_gen()
self.scores = [0] * self.computer_player.num_per_gen
else:
self.birds = [Bird()]
self.num_alive = len(self.birds)
self.frame_score = 0
self.floor = Floor(size[1])
self.pipes = []
self.lay_pipe()
self.playing_game = True
self.play_game()
def play_game(self):
time_since_pipe = 1
score = 0
collisions = [False] * len(self.birds)
if not computer_playing:
try:
#os.remove("./player_data.csv")
pass
except:
pass
self.data_to_write = []
while (self.playing_game):
if not computer_playing:
self.read_keyboard_input(self.birds[0])
else:
for i in range(len(self.birds)):
if self.birds[i].alive:
self.read_computer_input(self.birds[i],
self.networks[i])
count = 0
for b in self.birds:
if b.alive and not collisions[count]:
b.move()
count += 1
self.draw_everything(score)
#COLLISIONS DETECTED
if not computer_playing and any(collisions):
self.playing_game = False
else:
col_count = 0
#CHECK ALL COLLISIONS
for i in range(len(collisions) - 1, -1, -1):
if self.birds[i].alive:
if collisions[i]:
self.birds[i].alive = False
self.scores[i] = self.frame_score
self.num_alive -= 1
self.computer_player.network_score(
self.networks[i], self.frame_score)
#IF NO BIRDS LEFT, RESET GAME AND CONTINUE
if self.num_alive == 0:
if self.computer_player.cur_gen < self.computer_player.max_gen:
self.reset_for_new_gen()
collisions = [False] * len(self.birds)
time_since_pipe = 1
score = 0
continue
else:
self.print_network_stats()
self.playing_game = False
col_count = 0
for b in self.birds:
if b.alive:
collisions[col_count] = self.check_for_collision(b)
col_count += 1
if play_with_pipes:
self.update_pipes()
if time_since_pipe % 62 == 0 and play_with_pipes:
time_since_pipe = 1
self.lay_pipe()
pygame.display.update()
pygame.event.pump()
pygame.time.Clock().tick(fr)
time_since_pipe += 1
score = self.increment_score(score, self.birds[0])
self.increment_frame_score()
self.display_score()
self.quit_game()
def reset_for_new_gen(self):
self.print_network_stats()
self.birds = []
self.pipes = []
for i in range(self.computer_player.num_per_gen):
self.birds.append(Bird())
self.networks = self.computer_player.increment_gen()
self.scores = [0] * self.computer_player.num_per_gen
self.num_alive = len(self.birds)
self.frame_score = 0
self.lay_pipe()
def get_stimuli(self, bird):
#x distance to next pipe, y distance to center of pipe
stimuli = [999]
if bad_stimuli:
stimuli = [999, 999, 999, 999, 999]
next_pipe = None
for p in self.pipes:
if p.top_left[0] + p.pipe_width > bird.top_left[0]:
next_pipe = p
break
if next_pipe:
stimuli = [next_pipe.center - bird.top_left[1]]
if bad_stimuli:
stimuli.extend([
next_pipe.top_left[0] - bird.top_left[0] +
next_pipe.pipe_width, bird.y_velocity, bird.acceleration,
next_pipe.center
])
return stimuli
def increment_frame_score(self):
self.frame_score += 1
if self.frame_score == 700:
c = 0
for b in self.birds:
if b.alive:
break
c = c + 1
self.computer_player.save_best_score(self.frame_score, c)
def get_network_stats(self):
cur_gen = self.computer_player.cur_gen
if len(self.computer_player.generations.generations[0].genomes) == 0:
return 1, 0, 0, 0
scores = [
g.score
for g in self.computer_player.generations.generations[-1].genomes
]
best = max(scores)
avg = np.mean(scores)
std = np.std(scores)
return cur_gen, best, avg, std
def print_network_stats(self):
cur_gen, best, avg, std = self.get_network_stats()
print("Generation # %d had a best score of %f, an average score of %f,"
"and a standard deviation of %f" % (cur_gen, best, avg, std))
def increment_score(self, score, bird):
for p in self.pipes:
if p.top_left[0] < bird.top_left[0] - p.pipe_width and not p.scored:
p.scored = True
score += 1
return score
def display_score(self):
pass
def quit_game(self):
pygame.quit()
def read_keyboard_input(self, bird):
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
bird.flap()
return "SPACE"
elif event.key == pygame.K_ESCAPE:
self.playing_game = False
return "NO_INPUT"
def read_computer_input(self, bird, nn):
s = [self.get_stimuli(bird)]
action = self.computer_player.make_decision(s, nn)
if action == "SPACE":
bird.flap()
def check_for_collision(self, bird):
if bird.top_left[1] < 0:
return True
if pygame.sprite.collide_rect(bird, self.floor):
if pygame.sprite.collide_mask(bird, self.floor):
return True
for p in self.pipes:
if p.top_left[0] < size[0]:
if p.check_for_collision(bird, pixel_collision=False):
return True
return False
def update_pipes(self):
for p in self.pipes:
if p.top_left[0] < -200:
self.pipes.remove(p)
break
for p in self.pipes:
p.move()
def lay_pipe(self):
p = Pipe(random.randint(round(256), round(size[1] - 256)), size[1],
size[0])
self.pipes.append(p)
def draw_everything(self, score):
self.draw_background()
self.draw_birds()
self.draw_pipe()
self.draw_floor()
self.draw_score(score)
if computer_playing:
self.draw_computer_info()
def draw_computer_info(self):
cur_gen, best, avg, std = self.get_network_stats()
num_alive = len([b for b in self.birds if b.alive])
num_per_gen = self.computer_player.num_per_gen
best_ever = self.computer_player.best_score_ever
if self.frame_score > best_ever:
best_ever = self.frame_score
s = self.score_text.render("Frame Score: %d" % self.frame_score, False,
(255, 255, 255))
na = self.score_text.render(
"Alive: %d / %d" % (num_alive, num_per_gen), False,
(255, 255, 255))
g = self.score_text.render("Generation: %d" % cur_gen, False,
(255, 255, 255))
b = self.score_text.render("Best Score: %d" % best_ever, False,
(255, 255, 255))
self.screen.blit(g, (5, 5))
self.screen.blit(na, (5, 25))
self.screen.blit(s, (5, 45))
self.screen.blit(b, (5, 65))
def draw_score(self, score):
t = self.score_text.render("%s" % score, False, (255, 255, 255))
self.screen.blit(t, (round(size[0] / 2), 100))
def draw_birds(self):
for b in self.birds:
if b.alive:
b.draw(self.screen)
def draw_background(self):
self.screen.fill(bg_color)
def draw_pipe(self):
for p in self.pipes:
p.draw(self.screen)
def draw_floor(self):
self.floor.draw(self.screen)
