def draw(self): t = self.time() for i, planet in enumerate(self.planets): self.Labels[i*5].grid_remove() self.Labels[i*5+1].grid_remove() self.Labels[i*5+2].grid_remove() self.Labels[i*5+3].grid_remove() self.Labels[i*5+4].grid_remove() if(self.active_planets[i].get()): self.Labels[i*5] = tk.Label(self, text = "U: "+ str(planet.u(t))) self.Labels[i*5].grid(column = 2, row = i*5) self.Labels[i*5+1] = tk.Label(self, text = "C: "+ str(planet.angular_momentum(t))) self.Labels[i*5+1].grid(column = 2, row = i*5+1) self.Labels[i*5+2] = tk.Label(self, text = "H: "+ str(planet.energy(t))) self.Labels[i*5+2].grid(column = 2, row = i*5+2) self.Labels[i*5+3] = tk.Label(self, text = "X: "+ str(planet.position(t))) self.Labels[i*5+3].grid(column = 2, row = i*5+3) self.Labels[i*5+4] = tk.Label(self, text = " ") self.Labels[i*5+4].grid(column = 2, row = i*5+4) graphics.draw(self.planets,self.active_planets, t) self.after(500,self.draw)
def draw(self): t = self.time() for i, planet in enumerate(self.planets): self.Labels[i * 5].grid_remove() self.Labels[i * 5 + 1].grid_remove() self.Labels[i * 5 + 2].grid_remove() self.Labels[i * 5 + 3].grid_remove() self.Labels[i * 5 + 4].grid_remove() if (self.active_planets[i].get()): self.Labels[i * 5] = tk.Label(self, text="U: " + str(planet.u(t))) self.Labels[i * 5].grid(column=2, row=i * 5) self.Labels[i * 5 + 1] = tk.Label( self, text="C: " + str(planet.angular_momentum(t))) self.Labels[i * 5 + 1].grid(column=2, row=i * 5 + 1) self.Labels[i * 5 + 2] = tk.Label(self, text="H: " + str(planet.energy(t))) self.Labels[i * 5 + 2].grid(column=2, row=i * 5 + 2) self.Labels[i * 5 + 3] = tk.Label(self, text="X: " + str(planet.position(t))) self.Labels[i * 5 + 3].grid(column=2, row=i * 5 + 3) self.Labels[i * 5 + 4] = tk.Label(self, text=" ") self.Labels[i * 5 + 4].grid(column=2, row=i * 5 + 4) graphics.draw(self.planets, self.active_planets, t) self.after(500, self.draw)
def graphics_update(): screen.fill(g.CYAN) e.event_log.act(pygame.mouse.get_pos()) qubit.draw(e.camera, g.WHITE, g.BLUE, g.RED, g.FOREST_GREEN, g.CYAN) g.draw(pygame.draw, screen) pygame.display.flip() gr.draw()
def main(resolution, fps): # initialse pygame pygame.init() # set up frame rate clock = pygame.time.Clock() dt = 1.0 / float(fps) timestep = 0 time = 0.0 # create the buffer and display buffer = pygame.display.set_mode(resolution) pygame.display.set_caption('Boids') pygame.display.set_icon(pygame.image.load('data/boid.png')) # enable smooth controls pygame.key.set_repeat(10, 10) # initialse the game universe = engine.Universe(resolution) # main game loop while universe.state is not engine.States.QUIT: universe.check_input() universe.update(resolution, fps, dt, timestep, time) graphics.draw(universe, buffer) pygame.display.flip() clock.tick(fps) timestep += 1 time += dt
def draw(mpos): glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glEnable(GL_DEPTH_TEST) # glEnable(GL_CULL_FACE) camera.look() glDisable(GL_LIGHTING) graphics.draw(graphics.stars, min(settings.sx * settings.sy / 2000000., 1)) glEnable(GL_LIGHTING) if hud.mode == "level" and hud.labels["leveltitle"]: lighting.setmoonlight(*info.moonlights[settings.level]) lighting.moon() glPushMatrix() r = info.Rs[settings.level] glScale(r, r, r) graphics.draw(graphics.moon) glPopMatrix() text.setup() hud.draw() # text.write(settings.gamename, "Homenaje", hud.f(4), (200, 200, 200), (settings.sx/2, settings.sy/2), (0, 0, 0)) if alpha < 1: graphics.fill(0, 0, 0, 1-alpha) glDisable(GL_TEXTURE_2D)
def start(): global boidflock seed(time.time()) graphics.init(width=640, height=480) graphics.bg_colour(graphics.BLACK) #splatter a flock in the space randomly def generate_boid(): x = randrange(0, 640) #random left-right y = randrange(0, 480) #random up-down position = pygame.math.Vector2(x, y) #splat a boid, add to flock list velocity = pygame.math.Vector2((random() * 2) - 1, (random() * 2) - 1) velocity.scale_to_length(50) boidflock.add(boids.Boid(position, velocity)) for _ in range(50): generate_boid() for b in boidflock: b.image = pygame.Surface((1, 1)) b.image.fill(graphics.WHITE) boidflock.draw(graphics.screen) graphics.draw()
def update(dt): boidflock.update(dt, 0, 640, 0, 480) graphics.bg_colour(graphics.BLACK) boidflock.draw(graphics.screen) graphics.draw()
def update(self, num, update_surf=True): if not isinstance(num, int): raise ValueError("Input to display must be type <int>.") graphics.draw(str(num)) if update_surf: pygame.display.flip()
def test_sh_player(): weights = { "unit_weight": 1.242, "node_weight": -0.4971, "occ_weight": 0, "occ_new_weight": 0.05953, "n_enemies_weight": 0.2306, "enemy_occ_nodes_weight": -1.126, "enemy_unit_weight": -0.2431, "empty_node_weight": -0.7042, "attacker_weight": -0.3131, "defender_weight": 0.06549, "occ_attacker_weight": -0.2173, "occ_defender_weight": 0.4239, "enemy_occ_attacker_weight": 0.3953, "enemy_occ_defender_weight": -0.02868, } nodes = [ GameNode(0, [], [1, 2]), GameNode(1, [], [0, 2]), GameNode(2, [], [0, 1, 3]), GameNode(3, [], [2, 4, 5]), GameNode(4, [], [3, 5]), GameNode(5, [], [3, 4]), ] players = [ ShortHorizonPlayer(0, [Unit(0, nodes[0])], [nodes[0]], nodes[0], **weights), ShortHorizonPlayer(1, [Unit(1, nodes[1])], [nodes[1]], nodes[1], **weights), ShortHorizonPlayer(2, [Unit(2, nodes[4])], [nodes[4]], nodes[4], **weights), ShortHorizonPlayer(3, [Unit(3, nodes[5])], [nodes[5]], nodes[5], **weights), ] nodes[0].add_unit(players[0].units[0]) nodes[1].add_unit(players[1].units[0]) nodes[4].add_unit(players[2].units[0]) nodes[5].add_unit(players[3].units[0]) graph = GameGraph(nodes) game = Game(players, graph) game.update_state([], False) def next_round(event): win = game.play_round() if win is None: graphics.draw(f, w, l, game.state) else: graphics.draw_winner(w, win) f, w, l = graphics.setup(game.state, next_round) graphics.draw(f, w, l, game.state) graphics.show()
def test_human_player(): nodes = [ GameNode(0, [], [1, 2]), GameNode(1, [], [0, 2]), GameNode(2, [], [0, 1, 3]), GameNode(3, [], [2, 4, 5]), GameNode(4, [], [3, 5]), GameNode(5, [], [3, 4]) ] players = [ HumanPlayer(0, [HumanInteractionUnit(0, nodes[0])], [nodes[0]], nodes[0]), HumanPlayer(1, [HumanInteractionUnit(1, nodes[1])], [nodes[1]], nodes[1]), HumanPlayer(2, [HumanInteractionUnit(2, nodes[4])], [nodes[4]], nodes[4]), HumanPlayer(3, [HumanInteractionUnit(3, nodes[5])], [nodes[5]], nodes[5]) ] nodes[0].add_unit(players[0].units[0]) nodes[1].add_unit(players[1].units[0]) nodes[4].add_unit(players[2].units[0]) nodes[5].add_unit(players[3].units[0]) graph = GameGraph(nodes) game = Game(players, graph) game.update_state([], False) def next_round(event): win = game.play_round() if win is None: graphics.draw(f, w, l, game.state) else: graphics.draw_winner(w, win) f, w, l = graphics.setup(game.state, next_round) for p in players: p.canvas = w graphics.draw(f, w, l, game.state) graphics.show()
def main(): running = True pygame.init() screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT)) while running: for event in pygame.event.get(): if event.type == QUIT: running = False # Calculate stats statsArr = processing.organiseXL2Array('scores.xls') # Display graphics graphics.draw(screen, statsArr) pygame.display.update()
def test_human_player(): nodes = [ GameNode(0, [], [1, 2]), GameNode(1, [], [0, 2]), GameNode(2, [], [0, 1, 3]), GameNode(3, [], [2, 4, 5]), GameNode(4, [], [3, 5]), GameNode(5, [], [3, 4]), ] players = [ HumanPlayer(0, [HumanInteractionUnit(0, nodes[0])], [nodes[0]], nodes[0]), HumanPlayer(1, [HumanInteractionUnit(1, nodes[1])], [nodes[1]], nodes[1]), HumanPlayer(2, [HumanInteractionUnit(2, nodes[4])], [nodes[4]], nodes[4]), HumanPlayer(3, [HumanInteractionUnit(3, nodes[5])], [nodes[5]], nodes[5]), ] nodes[0].add_unit(players[0].units[0]) nodes[1].add_unit(players[1].units[0]) nodes[4].add_unit(players[2].units[0]) nodes[5].add_unit(players[3].units[0]) graph = GameGraph(nodes) game = Game(players, graph) game.update_state([], False) def next_round(event): win = game.play_round() if win is None: graphics.draw(f, w, l, game.state) else: graphics.draw_winner(w, win) f, w, l = graphics.setup(game.state, next_round) for p in players: p.canvas = w graphics.draw(f, w, l, game.state) graphics.show()
def draw(mpos): glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glEnable(GL_DEPTH_TEST) camera.look() glDisable(GL_LIGHTING) graphics.draw(graphics.stars, min(settings.sx * settings.sy / 2000000., 1)) glEnable(GL_LIGHTING) text.setup() hud.dialoguebox.draw() if alpha < 1: glPushMatrix() graphics.fill(0, 0, 0, 1-alpha) glPopMatrix() glEnable(GL_TEXTURE_2D) glDisable(GL_TEXTURE_2D)
def tick(self): for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() return True if pygame.mouse.get_pressed()[0]: mx, my = pygame.mouse.get_pos() self.sun.x = mx self.sun.y = my self.sun.b = (self.size[1] - my) * 4 #This prolly needs tweaking graphics.firstDraw(self) pygame.display.update() elif pygame.mouse.get_pressed()[2]: self.sun.x, self.sun.y = pygame.mouse.get_pos() graphics.draw(self) pygame.display.update()
""" lines = [line.strip('\n') for line in file] for i in range(len(lines)): for j in range(len(lines[i])): if lines[i][j] == '.': nodes.append(Node(j, i, 1)) elif lines[i][j] == 'A': start = Node(j, i, 1) nodes.append(start) elif lines[i][j] == 'B': target = Node(j, i, 1) nodes.append(target) elif lines[i][j] == '#': nodes.append(Node(j, i, 1, True)) target.target = True start.start = True path = [] if astar(start, target, nodes, open_nodes, closed_nodes): node = target while node != start: path.append(node) node = node.parent path.append(start) else: print("No path from start to target found :(((") draw(nodes, path, open_nodes, closed_nodes, lines, './img/part1/' + board[9:-4] + '.png')
nodes.append(Node(j, i, 1, description='Road')) if lines[i][j] == '.': nodes.append(Node(j, i, 1)) if lines[i][j] == '#': nodes.append(Node(j, i, 1, obstacle=True)) elif lines[i][j] == 'A': start = Node(j, i, 1) nodes.append(start) elif lines[i][j] == 'B': target = Node(j, i, 1) nodes.append(target) target.target = True start.start = True path = [] if algorithm == 'astar' and astar(start, target, nodes, open_nodes, closed_nodes) or \ algorithm == 'dijkstra' and dijkstra(start, target, nodes, open_nodes, closed_nodes) or \ algorithm == 'bfs' and bfs(start, target, nodes, open_nodes, closed_nodes): node = target while node != start: path.append(node) node = node.parent path.append(start) else: print("No path from start to target found :(((") draw(nodes, path, open_nodes, closed_nodes, lines, './img/part3/' + board[9:-4] + algorithm + '.png')
screen = pygame.display.set_mode((400, 400), pygame.DOUBLEBUF | pygame.HWSURFACE) current_map = map.sample_map() graphics.set_map(current_map) slime = objects.Slime() slime.x = 128 slime.y = 128 # minotaur.move_to(20, 100) # minotaur.move_to(250, 100) # minotaur.move_to(100, 150) events.register(pygame.KEYDOWN, slime.key_handler) events.register(pygame.KEYUP, slime.key_handler) graphics.add_sprite(slime) clock = pygame.time.Clock() time_ms = 0 clock.tick() while run: time_ms += clock.tick(50) while time_ms > 20: slime.update() time_ms -= 20 graphics.draw(screen) events.handle() pygame.quit()
pygame.init() stageData = gameLogic.getStageData() inputData = {"grab": False, "run": True} run = True clock = pygame.time.Clock() #-------- MAIN LOOP ---------- while run: #EVENTS inputData = inputHandling.handleInput(inputData) run = inputData["run"] if len(stageData["candy"]) <= 0: run = False elif stageData["mainCh"].pos[0] < 0 or stageData["mainCh"].pos[0] > size[ 0] or stageData["mainCh"].pos[1] > size[1]: run = False #GAMELOGIC gameLogic.updateStageData(inputData, stageData) #DRAWING CODE screen.fill((0, 0, 0)) graphics.draw(screen, stageData) pygame.display.flip() #set update speed 60 frame/s clock.tick(60) pygame.quit()
if use_example: # [a, c, b, d, e] f_k = [2.0, 2.0, -2.0, -1.0, -4.0] else: # [a, c, b, d, e] f_k = [4.0, 1.0, 2.0, -2.0, -3.0] eps: float = 0.1 x, y = sp.symbols('x y') f: sp.Add = f_k[0]*x**2 + f_k[1]*y**2 + f_k[2]*x*y + f_k[3]*x + f_k[4]*y rules: List[sp.core.relational.Relational] if use_example: rules = [ -x <= 0, -y <= 0, x + y <= 2, x + 5*y <= 5, ] else: rules = [ x + 4 * y <= 16, 11 * x - 4 * y <= 44, -x - y <= -4, ] points: List[float] = cg.calculate(f, rules, eps=eps) print(f'Found minimum after {Fore.GREEN}{len(points) - 1}{Fore.RESET} iterations!') print(f'Last point is {Fore.MAGENTA}{points[-1]}{Fore.RESET}') gr.draw(f_k, rules, points)
def game(): clock = pygame.time.Clock() # Screen dimensions SCREEN_WIDTH = 700 SCREEN_HEIGHT = 500 # Create screen obj screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT)) piece_bag = [] piece_bag2 = [] hold_piece = None initialize_bag(piece_bag, piece_bag2) can_hold = True board = Board() active = extract_piece(piece_bag, piece_bag2) # Run until the user asks to quit running = True ticks = 0 auto_drop_event = pygame.USEREVENT + 1 # Even to auto drop piece once every second check_new_event = pygame.USEREVENT + 2 # Checks to see if the piece hasn't changed height and get's new piece auto_drop_freq = 1000 check_new_freq = 500 pygame.time.set_timer(auto_drop_event, auto_drop_freq) # set the event pygame.time.set_timer(check_new_event, check_new_freq) # set the event das = 0.070 # Delayed auto shift see: https://harddrop.com/wiki/DAS # Note ARR in this iteration of the game is always 0 see: https://harddrop.com/wiki/DAS # below are variables to handle DAS right_timer = None left_timer = None left_pressed = False right_pressed = False left_first = False right_first = False curr_row = 0 # curr_row, used by check_new_event score = 0 # the user's score print_message_1 = "" # print's singles, doubles, t-spins etc. if the user performs them print_message_2 = "" # print's combo 1, combo 2 etc if the user performs them game_over = False # checker to see if the game is over need_next = False # checker to see if we need another piece ticker = 0 # ticks every time the game loop runs while running: changed = False # nothing has changed from the last game loop if game_over: end_game(board) # turn all active blocks gray # draw this newly grayed board graphics.draw(screen, active, board, hold_piece, piece_bag, score, print_message_1, print_message_2) # soft_drop counting for scoring purposes if active.soft_drop(board): changed = True board.soft_drop += 1 for event in pygame.event.get(): if not game_over: # auto drops piece every second if event.type == auto_drop_event: changed = active.move(0, -1, board) board.soft_drop += 1 # if the piece has not moved down for the event period, then get the next piece if event.type == check_new_event: if active.get_row() == curr_row and not active.can_move( 0, -1, board): need_next = True # this is to prevent stalling, if a piece hasn't been plaed in 50 seconds, the next one auto appears elif ticker > 100: need_next = True active.quick_move(0, -1, board) else: ticker += 1 curr_row = active.get_row() # Did the user click the window close button? if event.type == pygame.QUIT: running = False # If not then handle everything else else: if event.type == pygame.KEYDOWN: # F4 is the reset button if event.key == pygame.K_F4: # essentially resetting every relevant var, see above for var descriptions board = Board() hold_piece = None score = 0 right_timer = None left_timer = None left_pressed = False right_pressed = False left_first = False right_first = False board.soft_drop = 0 print_message_1 = "" print_message_2 = "" can_hold = True initialize_bag(piece_bag, piece_bag2) active = extract_piece(piece_bag, piece_bag2) game_over = False graphics.draw(screen, active, board, hold_piece, piece_bag, score, print_message_1, print_message_2) # we don't want our user to keep playing if they've already lost if not game_over: # holding handling if event.key == pygame.K_LSHIFT: changed = True if can_hold: temp_piece = hold_piece if isinstance(active, oPiece): hold_piece = type(active)(5, 22) else: hold_piece = type(active)(4, 22) active = temp_piece if active is None: active = extract_piece( piece_bag, piece_bag2) can_hold = False board.soft_drop = 0 # handling pressing the right key, this is handled in the main # because key presses should transfer over to next pieces # ie if I hold the right key, and place a key, continue holding right, the next key should # almost instantly move to the right as well if event.key == pygame.K_RIGHT: right_timer = time.time() right_first = True left_first = False right_pressed = True # handling pressing the left key # handled in main for same reasons above, not unique to each piece if event.key == pygame.K_LEFT: left_timer = time.time() left_first = True right_first = False left_pressed = True # reset variables if the left or right arrow key is released if event.type == pygame.KEYUP: if event.key == pygame.K_RIGHT: right_pressed = False right_first = False if event.key == pygame.K_LEFT: left_pressed = False left_first = False # update piece based on event if game_over: continue # returns if anything happened, if not nothing changed booleans = active.update(event, board) if booleans[0]: changed = booleans[0] if not need_next: need_next = booleans[1] # if we need another piece, set the piece into the game board # then get the next piece from the piece_bag if need_next: can_hold = True for block in active.get_blocks(): board.add(block.get_col(), block.get_row(), block.get_color()) results = board.clear_line(active, isinstance(active, tPiece), isinstance(active, iPiece)) # updating print messages and score score += results[0] print_message_1 = results[1] print_message_2 = results[2] game_over = results[3] active = extract_piece(piece_bag, piece_bag2) curr_row = 0 need_next = False ticker = 0 # DAS handling temp_time = time.time() if left_pressed and (not right_pressed): if (temp_time - left_timer) > das: auto_repeat(active, board, False) changed = True elif right_pressed and (not left_pressed): if (temp_time - right_timer) > das: auto_repeat(active, board, True) changed = True elif right_pressed and left_pressed: if left_first: if (temp_time - left_timer) > das: auto_repeat(active, board, False) changed = True elif right_first: if (temp_time - right_timer) > das: auto_repeat(active, board, True) changed = True # Draw everything if something changed or if first frame pygame.display.flip() if changed or ticks == 0: graphics.draw(screen, active, board, hold_piece, piece_bag, score, print_message_1, print_message_2) # Flip the display test = AI_helper.get__hrt_advanced(board) # Limit 1000 fps note rendering only occurs when something changes so this is not cpu heavy at all # for most ticks, nothing even happens since no events are even pressed, very cpu light # for accurate DAS and ARR recommended tick at least 1000 clock.tick(300) # print fps if ticks == 300: print("fps: " + str(clock.get_fps())) ticks = 0 ticks += 1 # Done! Time to quit. pygame.quit()
# env.print_rewards() height = 30 width = 40 epochs = [256] random_start = [True] repetitions = 1 components = {} for epoch, rs in zip(epochs, random_start): components[f'epochs:{epoch}-randstart:{rs}'] = [] exploit = 0.05 for _ in tqdm( range(repetitions) ): # execute the algorithm multiple times just for experimenting it env = Environment(height, width) agent = Agent(env=env, discount=0.9) agent.learn(epochs=epoch, exploit=exploit, random_start=rs) policy = agent.policy() components[f'epochs:{epoch}-randstart:{rs}'].append( connected_components(policy)) for i in components: comp = components[i] print(f'{i}: {comp}') print(f'average:{sum(comp)/len(comp)}\n') # draw last policy draw(env, policy)
def test_sh_player(): weights = { "unit_weight": 1.242, "node_weight": -0.4971, "occ_weight": 0, "occ_new_weight": 0.05953, "n_enemies_weight": 0.2306, "enemy_occ_nodes_weight": -1.126, "enemy_unit_weight": -0.2431, "empty_node_weight": -0.7042, "attacker_weight": -0.3131, "defender_weight": 0.06549, "occ_attacker_weight": -0.2173, "occ_defender_weight": 0.4239, "enemy_occ_attacker_weight": 0.3953, "enemy_occ_defender_weight": -0.02868 } nodes = [ GameNode(0, [], [1, 2]), GameNode(1, [], [0, 2]), GameNode(2, [], [0, 1, 3]), GameNode(3, [], [2, 4, 5]), GameNode(4, [], [3, 5]), GameNode(5, [], [3, 4]) ] players = [ ShortHorizonPlayer(0, [Unit(0, nodes[0])], [nodes[0]], nodes[0], **weights), ShortHorizonPlayer(1, [Unit(1, nodes[1])], [nodes[1]], nodes[1], **weights), ShortHorizonPlayer(2, [Unit(2, nodes[4])], [nodes[4]], nodes[4], **weights), ShortHorizonPlayer(3, [Unit(3, nodes[5])], [nodes[5]], nodes[5], **weights) ] nodes[0].add_unit(players[0].units[0]) nodes[1].add_unit(players[1].units[0]) nodes[4].add_unit(players[2].units[0]) nodes[5].add_unit(players[3].units[0]) graph = GameGraph(nodes) game = Game(players, graph) game.update_state([], False) def next_round(event): win = game.play_round() if win is None: graphics.draw(f, w, l, game.state) else: graphics.draw_winner(w, win) f, w, l = graphics.setup(game.state, next_round) graphics.draw(f, w, l, game.state) graphics.show()
def eval_genome(genomes, config): pygame.init() ticks = 0 running = True # Screen dimensions SCREEN_WIDTH = 700 SCREEN_HEIGHT = 500 # Create screen obj screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT)) # instead of individual variables, everything is a list as the AI runs multiple games at once to train # since training off one game at a time is too slow piece_bags = [] piece_bags2 = [] hold_pieces = [] boards = [] actives = [] nets = [] ge = [] tickers = [] changes = [] piece_count = [] # initializer for all the arrays for genome_id, genome in genomes: genome.fitness = 0 net = neat.nn.FeedForwardNetwork.create(genome, config) nets.append(net) piece_bag = [] piece_bag2 = [] initialize_bag(piece_bag, piece_bag2) piece_bags.append(piece_bag) piece_bags2.append(piece_bag2) boards.append(Board()) actives.append(extract_piece(piece_bag, piece_bag2)) ge.append(genome) tickers.append(0) piece_count.append(1) changes.append(False) hold_pieces.append(None) # game loop very similar except every time the game loop runs, multiple games are played while running: # removes dead or stagnant genomes for x, active in enumerate(actives): changes[x] = False # if the instance of the game lost or if the piece_count is too high # remember: we also want our AI to be efficient, not just survive, so we cut it off after 150 pieces if boards[x].game_over or piece_count[x] > 150: # all of these basically remove them from the list of variables ge[x].fitness += boards[x].score ge[x].fitness = ge[x].fitness actives.pop(x) boards.pop(x) nets.pop(x) ge.pop(x) piece_bags.pop(x) piece_bags2.pop(x) tickers.pop(x) changes.pop(x) hold_pieces.pop(x) # if all the genomes have been terminated, end if len(actives) == 0: break for x, board in enumerate(boards): if actives[x].soft_drop(boards[x]): changes[x] = True boards[x].soft_drop += 1 # Did the user click the window close button? for event in pygame.event.get(): if event.type == pygame.QUIT: running = False # update piece based on genome # AI training main part: for x, active in enumerate(actives): # plus 0.1 fitness every tick it survives, nothing too much, just a little incentive to see what happens ge[x].fitness += 0.1 # if we need the next piece then none of this happens, we need to get that piece ASAP # this if statement should never be true, simply just an error catcher # so our training doesn't abruptly stop if boards[x].need_next: continue # gets all possible moves for current piece curr_possible_moves = AI_helper.get_possible_moves(boards[x], actives[x]) # gets all possible moves for the piece if "hold" is used if hold_pieces[x] is None: curr_possible_moves_hold = AI_helper.get_possible_moves(boards[x], pieces.get_piece(piece_bags[x][0], 0, 0)) else: curr_possible_moves_hold = AI_helper.get_possible_moves(boards[x], hold_pieces[x]) # best_move_ratings and best_possible_moves are not used in this iteration but are there for future use move_ratings = [] total_possible_moves = [] best_move_ratings = [] best_possible_moves = [] # for all possible moves, get the move_rating for i in range(len(curr_possible_moves)): # create a copy of the board temp_board = deepcopy(boards[x]) curr_piece = curr_possible_moves[i][1][1] # add the potential result of that move to the copy of the board for bl in curr_piece.get_blocks(): temp_board.add(bl.get_col(), bl.get_row(), bl.get_color()) # evaluate the board temp_nums = temp_board.clear_line(curr_piece, isinstance(curr_piece, tPiece), isinstance(curr_piece, iPiece)) # evaluate the board nums = AI_helper.get__hrt_advanced(temp_board) # those numbers into the neural network to evaluate the state move_rating = nets[x].activate((*nums, temp_nums[0], temp_nums[4], temp_nums[5]))[0] # add that evaluation to the list of all other evaluations move_ratings.append(move_rating) # add the possible move to the list of all other possible moves # move ratings and moves correspond (if not then nothing will work) total_possible_moves.append(curr_possible_moves[i]) # this adds to best_possible_moves and best_move_ratings # note these are not actually used in this iteration, simply for future use # if (nums[0] - boards[x].holes) <= 0: # best_possible_moves.append(curr_possible_moves[i]) # best_move_ratings.append(move_rating) # does the exact same thing as the above loop but for the piece you get if you used the "hold" command # adds results to the same list # differences are commented for i in range(len(curr_possible_moves_hold)): temp_board = deepcopy(boards[x]) curr_piece = curr_possible_moves_hold[i][1][1] for bl in curr_piece.get_blocks(): temp_board.add(bl.get_col(), bl.get_row(), bl.get_color()) temp_nums = temp_board.clear_line(curr_piece, isinstance(curr_piece, tPiece), isinstance(curr_piece, iPiece)) nums = AI_helper.get__hrt_advanced(temp_board) move_rating = nets[x].activate((*nums, temp_nums[0], temp_nums[4], temp_nums[5]))[0] move_ratings.append(move_rating) # because we have to hold first to access this piece, insert the corresponding number to move set # remember: 7 = hold curr_possible_moves_hold[i][1][0].insert(0, 7) total_possible_moves.append(curr_possible_moves_hold[i]) # if (nums[0] - boards[x].holes) <= 0: # best_possible_moves.append(curr_possible_moves_hold[i]) # best_move_ratings.append(move_rating) index = move_ratings.index(max(move_ratings)) final_move_set = total_possible_moves[index][1][0] # only if 0 holes: diff AI version, code commented out: # index = best_move_ratings.index(max(best_move_ratings)) # final_move_set = best_possible_moves[index][1][0] # given the best move: we loop through the move set and perform those moves to the piece # the moves should result in the board state that the neural network evaluated in the loops above for i in range(len(final_move_set)): if final_move_set[i] != 7: AI_helper.move_code(final_move_set[i], actives[x], boards[x]) else: if hold_pieces[x] is not None: temp_piece = actives[x] actives[x] = hold_pieces[x] hold_pieces[x] = temp_piece else: hold_pieces[x] = actives[x] actives[x] = extract_piece(piece_bags[x], piece_bags2[x]) # every move_set hsa a 1 at the end because in regular tetris # hard dropping means you get the next piece instantly, if you soft drop, you have to wait a bit if final_move_set[i] == 1: boards[x].need_next = True # draw the piece so we can see what's going on # this game loop pretty computationally heavy, the graphics will be really laggy graphics.draw(screen, actives[0], boards[0], hold_pieces[0], piece_bags[0], boards[0].score, "", "") # loop to get the next piece for x, active in enumerate(actives): if boards[x].need_next: # increment piece_count useful potentially in the future piece_count[x] += 1 boards[x].can_hold = True # add it to that piece's game board for block in actives[x].get_blocks(): boards[x].add(block.get_col(), block.get_row(), block.get_color()) # clear the line boards[x].clear_line(actives[x], isinstance(actives[x], tPiece), isinstance(actives[x], iPiece)) # get the next piece actives[x] = extract_piece(piece_bags[x], piece_bags2[x]) boards[x].curr_row = 0 # we don't need a next anymore boards[x].need_next = False tickers[x] = 0 # Draw everything if something changed or if first frame # We only draw the first in each genome, rendering all of them would be too much # Flip the display pygame.display.flip() graphics.draw(screen, actives[0], boards[0], hold_pieces[0], piece_bags[0], boards[0].score, "", "") # Done! Time to quit. ticks += 1
def next_round(event): win = game.play_round() if win is None: graphics.draw(f, w, l, game.state) else: graphics.draw_winner(w, win)
def main (): state = State.MAIN run = True draw(get_terminal_size(), state) while run: sleep(1)
def draw(mpos): glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glEnable(GL_DEPTH_TEST) # glEnable(GL_CULL_FACE) lighting.setdamagelight(state.t % 1) camera.look() glDisable(GL_LIGHTING) graphics.draw(graphics.stars, min(settings.sx * settings.sy / 2000000., 1)) glEnable(GL_LIGHTING) lighting.moon() glPushMatrix() glScale(state.R, state.R, state.R) graphics.draw(graphics.moon) glPopMatrix() lighting.normal() # wire thickness glLineWidth(int(math.ceil(camera.wthick()))) for obj in state.drawers(): glPushMatrix() obj.draw() glPopMatrix() for obj in state.drawers(): if not obj.fx: continue glPushMatrix() obj.drawfx() glPopMatrix() px, py = mpos p = camera.screentoworld((settings.sx - px, settings.sy - py)) cursor.pointingto = None warning = None if p and cursor.tobuild: phat = p.norm() f = camera.eye().rej(phat).norm() tower = cursor.tobuild(phat, f) tower.dummy = True tower.invalid = not state.canbuild(cursor.tobuild, p.norm()) glPushMatrix() tower.draw() glPopMatrix() for w in state.wiresto(tower): w.draw() err = state.builderror(cursor.tobuild) if err is not None: warning = "Unable to build:\n%s" % err if warning is None: if not state.willgetpower(cursor.tobuild, p.norm()): for p, ptype in zip(cursor.tobuild.pneeds, info.pnames): if p: warning = "Warning: structure will not function\nwithout a %s connection." % ptype if warning is None: jfail = state.overload(cursor.tobuild.pneeds) if jfail is not None: warning = "Warning: placing this structure will\noverload %s capacity." % info.pnames[jfail] elif p: cursor.pointingto = state.pointing(p) if warning is None and hud.launchpoint: err = state.launcherror(hud.launchpoint) if err: warning = "Unable to launch:\n" + err if warning is None: for j in range(3): if state.reserves[j] < 0: warning = "Warning! %s capacity exceeded!\nShutdown imminent!" % info.pnames[j] if warning is None: if state.nsat > state.satcon: warning = "Warning! Satellite control exceeded!\nDe-orbiting imminent!" hud.labels["powerwarning"].settext(warning) text.setup() hud.draw() if alpha < 1: glPushMatrix() graphics.fill(0, 0, 0, 1-alpha) glPopMatrix() glEnable(GL_TEXTURE_2D) if hud.endtitle: hud.endtitle.draw() # if state.t < 1: # text.write("Moony moony moons!", None, 54, (255, 255, 0), (settings.sx/2, 100), (0, 0, 0)) # text.write("Moony moony moons!", None, 54, (255, 255, 0), (settings.sx/2, 100), (0, 0, 0), alpha=0.3) # text.write("Moony moony moonzzzz!", None, 54, (255, 255, 0), (settings.sx/2, 200), (0, 0, 0)) # text.write("O", None, 8, (255, 0, 0), camera.worldtoscreen(vec(0, 0, state.R)), (0, 0, 0)) glDisable(GL_TEXTURE_2D)
def eval_genome(genome, config): pygame.init() clock = pygame.time.Clock() ticks = 0 running = True # Screen dimensions SCREEN_WIDTH = 700 SCREEN_HEIGHT = 500 # Create screen obj screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT)) net = neat.nn.FeedForwardNetwork.create(genome, config) piece_bag = [] piece_bag2 = [] initialize_bag(piece_bag, piece_bag2) board = Board() active = extract_piece(piece_bag, piece_bag2) ge = genome tickers = 0 piece_count = 0 hold_piece = None print_message_1 = "" print_message_2 = "" # game loop very similar except every time the game loop runs, multiple games are played while running: # removes dead or stagnant genomes if board.game_over: board = Board() hold_piece = None score = 0 board.soft_drop = 0 print_message_1 = "" print_message_2 = "" can_hold = True initialize_bag(piece_bag, piece_bag2) active = extract_piece(piece_bag, piece_bag2) game_over = False graphics.draw(screen, active, board, hold_piece, piece_bag, score, print_message_1, print_message_2) # Did the user click the window close button? for event in pygame.event.get(): if event.type == pygame.QUIT: running = False # update piece based on genome # AI training main part: # gets all possible moves for current piece curr_possible_moves = AI_helper.get_possible_moves(board, active) # gets all possible moves for the piece if "hold" is used if hold_piece is None: curr_possible_moves_hold = AI_helper.get_possible_moves(board, pieces.get_piece(piece_bag[0], 0, 0)) else: curr_possible_moves_hold = AI_helper.get_possible_moves(board, hold_piece) # best_move_ratings and best_possible_moves are not used in this iteration but are there for future use move_ratings = [] total_possible_moves = [] best_move_ratings = [] best_possible_moves = [] # for all possible moves, get the move_rating for i in range(len(curr_possible_moves)): # create a copy of the board temp_board = deepcopy(board) curr_piece = curr_possible_moves[i][1][1] # add the potential result of that move to the copy of the board for bl in curr_piece.get_blocks(): temp_board.add(bl.get_col(), bl.get_row(), bl.get_color()) # evaluate the board temp_nums = temp_board.clear_line(curr_piece, isinstance(curr_piece, tPiece), isinstance(curr_piece, iPiece)) # evaluate the board nums = AI_helper.get__hrt_advanced(temp_board) # feed those numbers into the neural network to evaluate the state move_rating = net.activate((*nums, temp_nums[0], temp_nums[4], temp_nums[5]))[0] # add that evaluation to the list of all other evaluations move_ratings.append(move_rating) # add the possible move to the list of all other possible moves # move ratings and moves correspond (if not then nothing will work) total_possible_moves.append(curr_possible_moves[i]) # this adds to best_possible_moves and best_move_ratings # note these are not actually used in this iteration, simply for future use if (nums[0] - board.holes) <= 0: best_possible_moves.append(curr_possible_moves[i]) best_move_ratings.append(move_rating) # does the exact same thing as the above loop but for the piece you get if you used the "hold" command # adds results to the same list # differences are commented for i in range(len(curr_possible_moves_hold)): temp_board = deepcopy(board) curr_piece = curr_possible_moves_hold[i][1][1] for bl in curr_piece.get_blocks(): temp_board.add(bl.get_col(), bl.get_row(), bl.get_color()) temp_nums = temp_board.clear_line(curr_piece, isinstance(curr_piece, tPiece), isinstance(curr_piece, iPiece)) nums = AI_helper.get__hrt_advanced(temp_board) move_rating = net.activate((*nums, temp_nums[0], temp_nums[4], temp_nums[5]))[0] move_ratings.append(move_rating) # because we have to hold first to access this piece, insert the corresponding number to move set # remember: 7 = hold curr_possible_moves_hold[i][1][0].insert(0, 7) total_possible_moves.append(curr_possible_moves_hold[i]) if (nums[0] - board.holes) <= 0: best_possible_moves.append(curr_possible_moves_hold[i]) best_move_ratings.append(move_rating) index = move_ratings.index(max(move_ratings)) final_move_set = total_possible_moves[index][1][0] # only if 0 holes: diff AI version, code commented out: # index = best_move_ratings.index(max(best_move_ratings)) # final_move_set = best_possible_moves[index][1][0] # given the best move: we loop through the move set and perform those moves to the piece # the moves should result in the board state that the neural network evaluated in the loops above for i in range(len(final_move_set)): if final_move_set[i] != 7: AI_helper.move_code(final_move_set[i], active, board) else: if hold_piece is not None: temp_piece = active active = hold_piece hold_piece = temp_piece else: hold_piece = active active = extract_piece(piece_bag, piece_bag2) # every move_set hsa a 1 at the end because in regular tetris # hard dropping means you get the next piece instantly, if you soft drop, you have to wait a bit if final_move_set[i] == 1: board.need_next = True # draw the piece so we can see what's going on # this game loop pretty computationally heavy, the graphics will be really laggy # loop to get the next piece if board.need_next: # increment piece_count useful potentially in the future piece_count += 1 board.can_hold = True # add it to that piece's game board for block in active.get_blocks(): board.add(block.get_col(), block.get_row(), block.get_color()) # clear the line messages = board.clear_line(active, isinstance(active, tPiece), isinstance(active, iPiece)) print_message_1 = messages[1] print_message_2 = messages[2] # get the next piece active = extract_piece(piece_bag, piece_bag2) board.curr_row = 0 # we don't need a next anymore board.need_next = False ticker = 0 # Draw everything if something changed or if first frame # We only draw the first in each genome, rendering all of them would be too much # Flip the display pygame.display.flip() pps = 2 # uncomment below line to limit pieces per second # clock.tick(pps) graphics.draw(screen, active, board, hold_piece, piece_bag, board.score, print_message_1, print_message_2) # Done! Time to quit. ticks += 1
def cycle(screen, world, tempdata): #render_land(screen) graphics.draw(screen, world, tempdata)
import pygame from Grid import Grid from graphics import draw from events import handle_events pygame.init() grid = Grid() while 1: events = pygame.event.get() # A False return value signifies quit. if not handle_events(events, grid): break draw(grid) # Sleep a bit every iteration to reduce CPU load. pygame.time.wait(35) # The current active block will fall one row downward every # 1/level seconds. if pygame.time.get_ticks() - grid.prev_advance >= 1000 / grid.level: grid.prev_advance = pygame.time.get_ticks() grid.advance() # The level will increase every 50 second if pygame.time.get_ticks() - grid.prev_level_up >= 50000: grid.level_up()