def __init__(self, background=(240, 240, 240), resizable=False, vsync=False, debug=False, style=pyglet.window.Window.WINDOW_STYLE_DEFAULT): # type: (str) -> None pyglet.window.Window.__init__(self, resizable=resizable, vsync=vsync, style=style) self.debug = debug self.background = background self._resizeable = resizable self._vsync = vsync self._style = style self._title = "" self._icon = None self._fullscreen = False self._min_size = (0, 0) self._max_size = (0, 0) if self.debug: from pymunk.pyglet_util import DrawOptions self.options = DrawOptions() pyglet.gl.glClearColor(int(background[0]) / 255, int(background[1]) / 255, int(background[2]) / 255, 1) Globals.WINDOW = self self.keys = pyglet.window.key.KeyStateHandler() self.push_handlers(self.keys) self._loop = True self._middle = [self.width / 2, self.height / 2] self._mouse_x = 0 self._mouse_y = 0 self.scene_list = [] self.active_scene = 0 self.icon(pyglet.image.load(os.path.join(os.path.dirname(__file__), "swine.png"))) self.clock = pyglet.clock.get_default() if Globals.FPS_LIMIT != -1: self.clock.set_fps_limit(Globals.FPS_LIMIT) if Globals.GUI_FPS != -1: self.clock.schedule_interval(self.gui_update, 1 / Globals.GUI_FPS) else: self.clock.schedule(self.gui_update) if Globals.PHYSICS_FPS != -1: self.clock.schedule_interval(self.physics_update, 1 / Globals.PHYSICS_FPS) else: self.clock.schedule(self.physics_update) self._benchmark_timer = 0 self._benchmark_list = [] self.register_event_type("on_update")
def __init__(self, window, debug=False): self.window = window self.background_colour = pyglet.image.SolidColorImagePattern((143, 187, 247, 255)).\ create_image(window_width, window_height) self.world_batch = pyglet.graphics.Batch() self.background = pyglet.graphics.OrderedGroup(0) label_y_position = window_height - 35 self.score_label = pyglet.text.Label(text="Score: 0", x=10, y=label_y_position, font_size=24, bold=True, color=(255, 255, 255, 255)) self.lives_label = pyglet.text.Label(text="Lives: 0", x=200, y=label_y_position, font_size=24, bold=True, color=(255, 255, 255, 255)) self.level_label = pyglet.text.Label(text="Level: 0", x=340, y=label_y_position, font_size=24, bold=True, color=(255, 255, 255, 255)) self.fps_display = FPSDisplay(window) self.levels = [Level1(self), Level2(self)] self.on_new_level() self.draw_options = DrawOptions() self.debug = debug
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.keysDown = [] self.label = pyglet.text.Label("test", font_name='Times New Roman', font_size=36, x=self.width // 2, y=self.height // 2, anchor_x='center', anchor_y='center') self.space = pymunk.Space() self.options = DrawOptions() self.score = 0 self.playerCar = car.Car(self.space) self.course = walls.Walls(self.space) self.coins = coins.Coins(self.space) self.fps = FPSDisplay(self) self.nearestCoinPos = self.coins.usedCoinPos[0] handler = self.space.add_collision_handler(1, 2) handler.begin = self.hitWall coinHandler = self.space.add_collision_handler(1, 3) coinHandler.begin = self.collectCoin
def __init__(self, space, update): super().__init__(*WINDOW_SIZE) self.space = space self.draw_option = DrawOptions() self.set_caption(CAPTION) self.set_fullscreen(FULLSCREEN) self.set_mouse_visible(MOUSE_VISIBLE) pyglet.clock.schedule_interval(update, 1 / FPS_MAX)
def __init__(self): self.width = 1280 self.height = 720 self.window = pyglet.window.Window(self.width, self.height, "Car Simulator", resizable=False) self.draw_options = DrawOptions() self.seed() self.action_space = spaces.Discrete(3) self.observation_space = spaces.Box(low=0.0, high=1.0, shape=(3, ), dtype=np.float32) self.space = pymunk.Space() self.space.gravity = Vec2d(0.0, 0.0) self._create_boundaries() self.car = Car(self.space) Obstacle(self.space, (300, 300), 50) Obstacle(self.space, (250, 630), 80) Obstacle(self.space, (1200, 600), 90) FourLegsObstacle(self.space, (700, 400), 200, 200, 15) FourLegsObstacle(self.space, (800, 50), 100, 100, 10) FourLegsObstacle(self.space, (920, 50), 100, 100, 10) FourLegsObstacle(self.space, (1040, 50), 100, 100, 10) def on_key_press(symbol, modifiers): #if symbol == pyglet.window.key.LEFT: # self.car.cmd(0) #elif symbol == pyglet.window.key.RIGHT: # self.car.cmd(1) #elif symbol == pyglet.window.key.UP: # self.car.cmd(2) if symbol == pyglet.window.key.ESCAPE: pyglet.app.exit() quit() #update(0.2) #def on_draw(): # self.window.clear() # self.space.debug_draw(self.draw_options) #def update(dt): # self.car.sensors[0]._clear_rays() # self.space.step(dt) # print(self.car.read_sensors()) # if self.car.is_crashed: # self.reset_sim() self.window.push_handlers(on_key_press) #,on_draw)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.set_location(300, 50) self.fps = FPSDisplay(self) self.space = pymunk.Space() self.options = DrawOptions() self.player = Player(self.space) self.ball = Ball(self.space, self.player.position) self.walls = Walls(self.space) self.bricks = Bricks(self.space)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.set_location(500, 50) self.fps = FPSDisplay(self) self.space = pymunk.Space() self.options = DrawOptions() self.player = Player(self.space) self.puck = Puck(self.space) self.rail = Rail(self.space)
def __init__(self,*args,**kwargs): super().__init__(*args,**kwargs) self.space=pymunk.Space() self.set_caption("Bouncy Stack") self.space.gravity=0,-500 self.add=False self.draw_options=DrawOptions() self.ground=Base(self.space) self.ground.draw() self.game_complete=False self.counter=0 self.comp_lbl=pyglet.text.Label(text="Game Completed",font_size=40,bold=True,italic=True,color=(100,100,100,100),x=400,y=400,anchor_x='center',anchor_y='center')
def __init__(self): self.width = 1280 self.height = 720 self.window = pyglet.window.Window(self.width, self.height, "Car Simulator", resizable=False) self.draw_options = DrawOptions() self.space = pymunk.Space() self.space.gravity = Vec2d(0.0, 0.0) self._create_boundaries() self.car = Car(self.space) Obstacle(self.space, (300, 300), 50) Obstacle(self.space, (250, 630), 80) Obstacle(self.space, (1200, 600), 90) FourLegsObstacle(self.space, (700, 400), 200, 200, 15) FourLegsObstacle(self.space, (800, 50), 100, 100, 10) FourLegsObstacle(self.space, (920, 50), 100, 100, 10) FourLegsObstacle(self.space, (1040, 50), 100, 100, 10) def on_draw(): self.window.clear() self.space.debug_draw(self.draw_options) def on_key_press(symbol, modifiers): if symbol == pyglet.window.key.LEFT: self.car.cmd(0) elif symbol == pyglet.window.key.RIGHT: self.car.cmd(1) elif symbol == pyglet.window.key.UP: self.car.cmd(2) #update(0.2) def update(dt): self.car.sensors[0]._clear_rays() self.space.step(dt) dists = [] for sensor in self.car.sensors: dists.append(sensor.sense()) print(dists) if self.car.is_crashed: self.reset_sim() self.window.push_handlers(on_key_press, on_draw) pyglet.clock.schedule_interval(update, 1.0 / 30.0) pyglet.app.run()
def __init__(self, *args, **kwargs): #arguments and keyword arguments super().__init__(*args, **kwargs) pyg.gl.glClearColor(1000,1000,1000,1000) #background colour self.set_location(30, 50) #window position self.fps = FPSDisplay(self) self.space = pym.Space() #pymunk space self.options = DrawOptions() #pymunk + pyglet integration self.player = Player_Object(self.space, *object_types[0]) self.ground = Game_Object(self.space, *object_types[2]) self.enemy_list = [] self.player_sprite_walking = Sprites(*sprite_types[0]) self.player_sprite_jumping = Sprites(*sprite_types[1]) self.player_sprite_ducking = Sprites(*sprite_types[2]) self.player_sprite_dead = Sprites(*sprite_types[3]) self.sleep = 30 #30 frames untill first enemy self.randomsleep_down = 90 self.randomsleep_up = 150 self.state = None #the players state self.running = True ground_handler = self.space.add_collision_handler(1, 2) #collision handler to know when player is on the ground ground_handler.begin = self.coll_ground end_handler = self.space.add_collision_handler(2, 3) end_handler.begin = self.coll_enemy self.counter_vel = 2 self.enemy_velocity = -250 self.points = 0 self.scoreLabel = pyg.text.Label('', font_name='Press Start 2P', font_size=20, color=(83, 83, 83, 255), x=1180, y=700, anchor_x='center', anchor_y='center') self.highscoreLabel = pyg.text.Label('HI', font_name='Press Start 2P', font_size=20, color=(115, 115, 115, 255), x=980, y=700, anchor_x='center', anchor_y='center') self.counter_score = 0.1 self.value_holder = 0.1 self.speedup_score = 3 self.highscore = self.load()
def __init__(self, aspect_ratio, dt_for_physicx): self.aspect_ratio = aspect_ratio self.dt_for_physicx = dt_for_physicx self.space = pymunk.Space() self.options = DrawOptions() self.nb_balls = 2 self.nb_balls_in_game = self.nb_balls self._init_dynamic_body() self._add_collision_handler_for_paddle_ball() # self.walls = Walls(self.space, CollisionType.BALL, CollisionType.BOTTOM, self.loose_ball, aspect_ratio) self.bricks = Bricks(self.space, CollisionType.BRICK, CollisionType.BALL, aspect_ratio)
def __init__(self, cfg): # Set the window width and height from the config file self.winwidth = int(cfg['winwidth']) self.winheight = int(cfg['winheight']) # Boilerplate pyglet stuff, intialize the environment pyglet.window.Window.__init__(self, self.winheight, self.winwidth, fullscreen=False) self.options = DrawOptions() # Create the underlying pymunk engine self.pmSpace = norender.PymunkSpace(cfg) # Solid white background background = pyglet.image.SolidColorImagePattern( (255, 255, 255, 255)).create_image(self.winheight, self.winwidth) self.background_sprite = pyglet.sprite.Sprite(background, x=0, y=0) # At every 1.0/60 interval, call the update function (essentially render at 60 FPS) pyglet.clock.schedule_interval(self.update, 1.0 / 60) # This keeps track of if the agent is in the middle of a shot; the engine will not take another job off the job_queue until it finishes whatever it is doing self.doingAction = False # Load the net and ball images hoop_img = pyglet.image.load(dirname + "/../resource/hoop_resized.png") hoop_img.anchor_x = hoop_img.width // 2 - 1 hoop_img.anchor_y = hoop_img.height // 2 - 1 self.hoop_sprite = pyglet.sprite.Sprite(hoop_img, x=0, y=0) # Reset the pymunk space self.reset_space(True) basketball_img = pyglet.image.load( dirname + "/../resource/basketball_resized.png") basketball_img.anchor_x = basketball_img.width // 2 - 1 basketball_img.anchor_y = basketball_img.height // 2 - 1 self.basketball_sprite = pyglet.sprite.Sprite( basketball_img, x=self.pmSpace.basketball_body.position.x, y=self.pmSpace.basketball_body.position.y) done_queue.put(True)
def __init__(self, game): super(CarScreen, self).__init__(game) pyglet.clock.schedule_interval(self.update, 1 / 60) #Pymunk specifications self.options = DrawOptions() self.options.collision_point_color = (0, 0, 0, 255) self.space = pymunk.Space() self.space.gravity = 0, 0 self.space.idle_speed_threshold = 10 self.space.sleep_time_threshold = 50 # Pymunk Space self.car = Poly(100, ((0, 0), (80, 0), (80, 35), (65, 60), (15, 60), (0, 35)), (game.width / 4, game.height / 2)) self.car.body.elasticity = 0.1 self.car.body.friction = 1 self.space.add(self.car.existence) self.roda_traseira = Ball(30, 50, (game.width / 4 - 30, game.height / 2 - 30)) self.roda_traseira.shape.elasticity = 0.1 self.roda_dianteira = Ball( 30, 50, (game.width / 4 + 110, game.height / 2 - 30)) self.roda_dianteira.shape.elasticity = 0.1 self.pino1 = pymunk.PinJoint(self.car.body, self.roda_traseira.body, (0, 0), (0, 0)) self.guia1 = pymunk.SlideJoint(self.car.body, self.roda_traseira.body, (0, 30), (0, 0), 45, 59) self.mola1 = pymunk.DampedSpring(self.car.body, self.roda_traseira.body, (0, 30), (0, 0), 100, 1000, 65) self.pino2 = pymunk.PinJoint(self.car.body, self.roda_dianteira.body, (80, 0), (0, 0)) self.guia2 = pymunk.SlideJoint(self.car.body, self.roda_dianteira.body, (80, 30), (0, 0), 45, 59) self.mola2 = pymunk.DampedSpring(self.car.body, self.roda_dianteira.body, (80, 30), (0, 0), 100, 1000, 65) self.space.add(self.roda_dianteira.existence, self.roda_traseira.existence) self.space.add(self.pino1, self.guia1, self.mola1, self.pino2, self.guia2, self.mola2) # ELEMENTOS ESTÁTICOS: self.segment1 = Segment((0, 4), (game.width, 4), 10) # Limite de tela inferior self.segment1.shape.friction = 1 # Elasticidade borda inferior - Solo self.segment2 = Segment((0, 0), (0, game.height), 10) # Limite de tela lateral esquerdo self.segment2.shape.friction = 0 # Elasticidade borda lateral esquerda self.segment3 = Segment((0, game.height), (game.width, game.height), 10) # Limite de tela superior self.segment3.shape.friction = 0 # Elasticidade borda superior self.segment4 = Segment((game.width, 0), (game.width, game.height), 10) # Limite de tela lateral direito self.segment4.shape.friction = 0 # Elasticidade borda lateral direita self.space.add(self.segment1.shape, self.segment2.shape, self.segment3.shape, self.segment4.shape)
def __init__(self, width=800, height=600, *args, **kwargs): super().__init__(self.SCREEN_WIDTH, self.SCREEN_HEIGHT, self.SCREEN_TITLE, resizable=False, fullscreen=False, *args, **kwargs) self.x, self.y = 0, 0 # Pyglet #style=pyglet.window.Window.WINDOW_STYLE_TOOL style=pyglet.window.Window.WINDOW_STYLE_BORDERLESS) self.options = DrawOptions() # Pymunk self.space = pymunk.Space() # type float in the range [0.0, 1.0], corresponding to the RGBA sequence (red, green, blue, and alpha). self.background_color = (.1, .5, .1, 1) # green grass self.background_color2 = (.2, .75, .5, 1) # light green grass # sets the background color glClearColor(*self.background_color) # Instances of classes self.population = Population() self.track_builder = TrackBuilder() self.track_settings = TrackSettings() self.track_creation_label = pyglet.text.Label( self.TRACK_MSG.format(len(self.track)), font_name='Times New Roman', font_size=20, x=self.SCREEN_WIDTH // 2, y=self.SCREEN_HEIGHT - 20, color=(255, 255, 0, 255), anchor_x='center', anchor_y='center') self.epoch_label = pyglet.text.Label(self.EPOCH_MSG.format( self.epoch, self.time_step), font_name='Times New Roman', font_size=16, x=0.8 * self.SCREEN_WIDTH // 10, y=self.SCREEN_HEIGHT - 20, color=(255, 255, 255, 255), anchor_x='center', anchor_y='center') self.best_car_info_label = pyglet.text.Label( self.COUNTER_MSG.format(self.time_counter), font_name='Times New Roman', font_size=16, x=4.4 * self.SCREEN_WIDTH // 10, y=self.SCREEN_HEIGHT - 20, color=(255, 255, 0, 255), anchor_x='center', anchor_y='center') self.current_best_car_info_label = pyglet.text.Label( self.CURRENT_BEST_CAR.format("None", "0"), font_name='Times New Roman', font_size=16, x=8.3 * self.SCREEN_WIDTH // 10, y=self.SCREEN_HEIGHT - 20, color=(255, 255, 0, 255), anchor_x='center', anchor_y='center')
from simulator_tools import * from input_tools import * Tau = 2 * np.pi Phi = 1.61803398874989 ### # pyglet setup and calls ### window_sx = 1000 window_sy = 1000 window = pyglet.window.Window(window_sx, window_sy, "Window", resizable=False) pyglet.gl.glClearColor(0.0, 43 / 255.0, 54 / 255.0, 1) options = DrawOptions() options.flags = pymunk.SpaceDebugDrawOptions.DRAW_SHAPES #options.flags |= pymunk.SpaceDebugDrawOptions.DRAW_COLLISION_POINTS scale_wi = 0.2 # setup the reference lines ''' cross_lines = pyglet.graphics.vertex_list(4, ('v2f', (400, 100, 400, 500, 100, 300, 700, 300)), ('c3B', (147, 161, 161, 147, 161, 161, 147, 161, 161, 147, 161, 161)) ) ''' bounding_hull = []
def on_draw(self) -> None: super().clear() self.universe.space.debug_draw(DrawOptions()) self.label.draw()
#%% import pymunk as pm from pymunk.pyglet_util import DrawOptions import numpy as np import math from numba import njit import cell_geometry from Cell import Cell import cell_physics import matplotlib.pyplot as plt import cell_drawing ## DEFINE SPACE space = pm.Space() space.iterations = 100 options = DrawOptions() options.collision_point_color = (0, 0, 0, 0) space.debug_draw(options) space.gravity = 0, 0 ## ADD INITIAL CELLS cell_1 = Cell(length=15, width=7.5, x_pos=0, y_pos=0, angle=0, colour=(1, 0, 0, 1), perm_colour=(1, 0, 0, 1), space=space) cell_2 = Cell(length=15, width=7.5,
def __init__(self, game): super(AnotherScreen, self).__init__(game) pyglet.clock.schedule_interval(self.update, 1 / 60) #Pymunk specifications self.options = DrawOptions() self.options.collision_point_color = (0, 0, 0, 255) self.space = pymunk.Space() self.space.gravity = 0, -100 self.space.idle_speed_threshold = 10 self.space.sleep_time_threshold = 500 # Pymunk Space self.player = Player(1350, ((0, 0), (171 / 5, 0), (171 / 10, 300 / 5)), (game.width / 2, game.height / 2)) self.player.body.center_of_gravity = ((0 + 171 / 5 + 171 / 10) / 3, 300 / 15) self.player.body.elasticity = 0 self.player.body.friction = 1 self.player_image = pyglet.image.load("nave.png") self.player_sprite = pyglet.sprite.Sprite( self.player_image, x=self.player.body.position[0], y=self.player.body.position[1]) self.player.combustivel = 3000 self.space.add(self.player.existence) # ELEMENTOS ESTÁTICOS: # Limite da tela inferior self.segment1 = Segment((0, 4), (game.width, 4), 10) self.segment1.shape.friction = 1 self.segment1.shape.elasticity = 0 # Limite da tela lateral esquerda self.segment2 = Segment((0, 0), (0, game.height), 10) self.segment2.shape.friction = 0 self.segment2.shape.elasticity = 0 # Limite da tela superior self.segment3 = Segment((0, game.height), (game.width, game.height), 10) self.segment3.shape.friction = 0 self.segment3.shape.elasticity = 0 # Limite da tela lateral direita self.segment4 = Segment((game.width, 0), (game.width, game.height), 10) self.segment4.shape.friction = 0 self.segment4.shape.elasticity = 0 # Roxa esquerda self.triangulo1_r1 = Poly(1000, ((0, 0), (41, 0), (41, 105)), (52, 113)) self.triangulo1_r1.body.body_type = pymunk.Body.STATIC self.triangulo1_r1.shape.elasticity = 0 self.triangulo2_r1 = Poly(1000, ((0, 0), (90, 0), (0, 55)), (129, 0)) self.triangulo2_r1.body.body_type = pymunk.Body.STATIC self.triangulo2_r1.shape.elasticity = 0 self.triangulo3_r1 = Poly(1000, ((0, 0), (19, 0), (9, 10)), (98, 218)) self.triangulo3_r1.body.body_type = pymunk.Body.STATIC self.triangulo3_r1.shape.elasticity = 0 self.retangulo1_r1 = Poly(1000, ((0, 0), (96, 0), (96, 116), (0, 116)), (33, 0)) self.retangulo1_r1.body.body_type = pymunk.Body.STATIC self.retangulo1_r1.shape.elasticity = 0 self.retangulo2_r1 = Poly(1000, ((0, 0), (48, 0), (48, 73), (0, 73)), (81, 113)) self.retangulo2_r1.body.body_type = pymunk.Body.STATIC self.retangulo2_r1.shape.elasticity = 0 self.retangulo3_r1 = Poly(1000, ((0, 0), (28, 0), (28, 32), (0, 32)), (93, 186)) self.retangulo3_r1.body.body_type = pymunk.Body.STATIC self.retangulo3_r1.shape.elasticity = 0 # Roxa direita self.triangulo1_r2 = Poly(1000, ((0, 0), (29, 0), (29, 205)), (1210, 0)) self.triangulo1_r2.body.body_type = pymunk.Body.STATIC self.triangulo1_r2.shape.elasticity = 0 self.triangulo2_r2 = Poly(1000, ((0, 0), (58, 0), (0, 193)), (1263, 0)) self.triangulo2_r2.body.body_type = pymunk.Body.STATIC self.triangulo2_r2.shape.elasticity = 0 self.triangulo3_r2 = Poly(1000, ((0, 0), (39, 0), (0, 60)), (1277, 81)) self.triangulo3_r2.body.body_type = pymunk.Body.STATIC self.triangulo3_r2.shape.elasticity = 0 self.retangulo1_r2 = Poly(1000, ((0, 0), (26, 0), (26, 203), (0, 203)), (1238, 0)) self.retangulo1_r2.body.body_type = pymunk.Body.STATIC self.retangulo1_r2.shape.elasticity = 0 self.retangulo2_r2 = Poly(1000, ((0, 0), (39, 0), (39, 82), (0, 82)), (1277, 0)) self.retangulo2_r2.body.body_type = pymunk.Body.STATIC self.retangulo2_r2.shape.elasticity = 0 # Adicionando formas geométricas self.space.add( self.segment1.shape, self.segment2.shape, self.segment3.shape, self.segment4.shape, self.triangulo1_r1.existence, self.triangulo2_r1.existence, self.triangulo3_r1.existence, self.retangulo1_r1.existence, self.retangulo2_r1.existence, self.retangulo3_r1.existence, self.triangulo1_r2.existence, self.triangulo2_r2.existence, self.triangulo3_r2.existence, self.retangulo1_r2.existence, self.retangulo2_r2.existence) # IMAGENS self.background = pyglet.resource.image("Plano_Game1.png") self.solo = pyglet.resource.image("Solo.png") self.moldura = pyglet.resource.image("moldura.png") # TEXTOS self.texts = [ self.player.body.position[0], self.player.body.position[1], self.player.body.velocity[0], self.player.body.velocity[1], self.player.combustivel ] self.status = [0] * len(self.texts) for i in range(len(self.texts)): self.status[i] = pyglet.text.Label("{}".format(self.texts[i]), font_name="Arial", font_size=10, color=(100, 255, 0, 255), x=game.width - 200, y=game.height - 50 - (15 * i), anchor_x="left", anchor_y="center", align="left") self.handler = self.space.add_default_collision_handler() self.handler.begin = self.coll_begin self.handler.pre_solve = self.coll_pre self.handler.post_solve = self.coll_post self.handler.separate = self.coll_separate self.player.vida = 1000
#!/usr/bin/env python # Imports import math import time import pyglet import pymunk from pymunk.pyglet_util import DrawOptions import numpy as np import matplotlib.pyplot as plt options = DrawOptions() # Initialise DrawOptions for Pymunk key = pyglet.window.key # Physical dimensions of swing rod1_length = 400 rod2_length = 50 rod3_length = 20 seat_length = 30 torso_length = 100 legs_length = 60 ##################### ### PYMUNK ##################### class Angle: ''' The 'Angle' class which converts an angle in degrees to absolute world positions for the swing simulation. '''
def visualize(self, genome, game_id: int): """ Visualize the performance of a single genome. :param genome: Tuple (genome_id, genome_class) :param game_id: ID of the game that will be used for evaluation """ # Create the requested game game: Game = get_game(game_id, cfg=self.game_config) game.player.set_active_sensors( set(genome.get_used_connections().keys())) # Create space in which game will be played window = pyglet.window.Window( game.game_config.x_axis * game.game_config.p2m, game.game_config.y_axis * game.game_config.p2m, "Robot Simulator - Game {id:03d}".format(id=game_id), resizable=False, visible=True) window.set_location(100, 100) pyglet.gl.glClearColor(1, 1, 1, 1) # Setup the requested game self.state = game.reset()[D_SENSOR_LIST] self.finished = False # Make the network used during visualization net = self.make_net( genome=genome, genome_config=self.pop_config.genome, game_config=self.game_config, bs=1, initial_read=self.state, ) # Create the visualize-environment space = pymunk.Space() options = DrawOptions() # Draw static objects - walls for wall in game.walls: wall_shape = pymunk.Segment(space.static_body, a=wall.x * game.game_config.p2m, b=wall.y * game.game_config.p2m, radius=0.05 * game.game_config.p2m) # 5cm walls wall_shape.color = (0, 0, 0) space.add(wall_shape) # Draw static objects - target target_body = pymunk.Body(body_type=pymunk.Body.KINEMATIC) target_body.position = game.target * game.game_config.p2m target_shape = pymunk.Circle(body=target_body, radius=game.bot_config.radius * game.game_config.p2m) target_shape.sensor = True target_shape.color = (0, 128, 0) space.add(target_body, target_shape) # Init player² m = pymunk.moment_for_circle(mass=2, inner_radius=0, outer_radius=game.bot_config.radius * game.game_config.p2m) player_body = pymunk.Body(mass=1, moment=m) player_body.position = game.player.pos * game.game_config.p2m player_body.angle = game.player.angle player_shape = pymunk.Circle(body=player_body, radius=game.bot_config.radius * game.game_config.p2m) player_shape.color = (255, 0, 0) space.add(player_body, player_shape) label = pyglet.text.Label( f'{self.time}', # TODO: Creates error in WeakMethod after run (during termination) font_size=16, color=(100, 100, 100, 100), x=window.width - 20, y=window.height - 20, anchor_x='center', anchor_y='center') # Draw the robot's sensors def draw_sensors(): [ space.remove(s) for s in space.shapes if s.sensor and type(s) == pymunk.Segment ] for key in game.player.active_sensors: s = game.player.sensors[key] if type(s) == ProximitySensor: line = pymunk.Segment(space.static_body, a=s.start_pos * game.game_config.p2m, b=s.end_pos * game.game_config.p2m, radius=0.5) line.sensor = True touch = ((s.start_pos - s.end_pos).get_length() < game.bot_config.ray_distance - 0.05) line.color = (100, 100, 100) if touch else ( 200, 200, 200) # Brighten up ray if it makes contact space.add(line) @window.event def on_draw(): window.clear() draw_sensors() label.draw() space.debug_draw(options=options) def update_method(_): # Input dt ignored dt = 1 / game.game_config.fps self.time += dt label.text = str(int(self.time)) # Stop when target is reached if not self.finished: # Query the game for the next action action = self.query_net(net, [self.state]) if self.debug: print("Passed time:", round(dt, 3)) print("Location: x={}, y={}".format( round(player_body.position.x / game.game_config.p2m, 2), round(player_body.position.y / game.game_config.p2m, 2))) print("Action: lw={l}, rw={r}".format( l=round(action[0][0], 3), r=round(action[0][1], 3))) print("Observation:", [round(s, 3) for s in self.state]) # Progress game by one step obs = game.step_dt(dt=dt, l=action[0][0], r=action[0][1]) self.finished = obs[D_DONE] self.state = obs[D_SENSOR_LIST] # Update space's player coordinates and angle player_body.position = game.player.pos * game.game_config.p2m player_body.angle = game.player.angle space.step(dt) # Run the game pyglet.clock.schedule_interval( update_method, 1.0 / (game.game_config.fps * self.speedup)) pyglet.app.run()
def live_visualisation(agent: Agent = Empty(), game: Game = None): """Visualise the performance of the given agent.""" if not game: game = Game() # Regularly used constants width = game.width * game.pixels height = game.height * game.pixels # Initialise the Pyglet instance window = pyglet.window.Window(width, height, "PySnake", resizable=False, visible=True) window.set_location(100, 100) pyglet.gl.glClearColor(1, 1, 1, 1) # Draw the environment space = pymunk.Space() options = DrawOptions() # Label for the score label = pyglet.text.Label(f'{game.score}', font_size=12, color=(100, 100, 100, 100), x=window.width - 30, y=window.height - 30, anchor_x='center', anchor_y='center') # Draw a square in the environment def draw_segment(pos, i=None, color=(0, 128, 0)): """Draw square segment at position p.""" target_body = pymunk.Body(body_type=pymunk.Body.KINEMATIC) target_body.position = (pos[0] * game.pixels + game.pixels / 2, pos[1] * game.pixels + game.pixels / 2) target_shape = pymunk.Poly.create_box(body=target_body, size=(game.pixels * 0.9, game.pixels * 0.9)) target_shape.sensor = True if i is not None: target_shape.id = i target_shape.color = color space.add(target_body, target_shape) # Draw the walls for i in range(game.height): draw_segment((0, i), color=(0, 0, 0)) draw_segment((game.width - 1, i), color=(0, 0, 0)) for i in range(game.width): draw_segment((i, 0), color=(0, 0, 0)) draw_segment((i, game.height - 1), color=(0, 0, 0)) # Draw the apple draw_segment(game.apple, i=-1, color=(128, 0, 0)) # Create the Snake instance snake_i = IntegerGenerator() # Iterator for the snake segments agent.training = False agent.reset(n_envs=1, sample_game=game) def draw_snake(init=False): """Draw the snake.""" if init: for p in reversed(game.snake.body): draw_segment(p, i=snake_i()) else: draw_segment(game.snake.body[0], i=snake_i()) # Initialise the snake draw_snake(init=True) @window.event def on_draw(): window.clear() label.text = str(game.score) label.draw() space.debug_draw(options=options) # Make game keyboard sensitive if type(agent) == Empty: @window.event def on_key_press(key, _): """Called whenever a key is pressed to record manual input.""" if key == arcade.key.LEFT and game.snake.direction != RIGHT: game.snake.direction = LEFT elif key == arcade.key.RIGHT and game.snake.direction != LEFT: game.snake.direction = RIGHT elif key == arcade.key.UP and game.snake.direction != DOWN: game.snake.direction = UP elif key == arcade.key.DOWN and game.snake.direction != UP: game.snake.direction = DOWN def update_method(dt): """Update the game environment.""" # Query brain to get action for current state a = agent([game])[0] # Progress the game score_pre = game.score alive = game.step(a=a) if not alive: pyglet.app.exit() score_post = game.score eaten = score_pre != score_post # Remove the oldest added shape for shape in space.shapes: if hasattr(shape, 'id') and shape.id <= len(snake_i) - ( game.snake.length - 1): if eaten: space.remove(shape.body, shape) draw_segment(game.apple, i=-1, color=(128, 0, 0)) elif shape.id >= 0: space.remove(shape.body, shape) # Proceed the snake draw_snake() # Perform required action space.step(dt) # Run the game pyglet.clock.schedule_interval(update_method, .1) pyglet.app.run()
#print_options = pymunk.SpaceDebugDrawOptions() # For easy printing #while True: # Infinite loop simulation #space.step(0.02) # Step the simulation one step forward #space.debug_draw(print_options) # Print the state of the simulation import pyglet import pymunk from pymunk.pyglet_util import DrawOptions import time #seting up pyglet window = pyglet.window.Window(1280, 720, "MyMunk", resizable=True) option = DrawOptions() space = pymunk.Space() space.gravity = 0, -1000 body = pymunk.Body(1, 1666) body.position = 600, 700 poly = pymunk.Poly.create_box_bb(body, bb, radius=25) space.add(body, poly) @window.event def on_draw(): window.clear() space.debug_draw(option) def update(dt): #dt==date_time
# -*- coding: utf-8 -*- """ Created on Thu Jan 14 01:49:25 2021 @author: ACER """ import pyglet import pymunk from pymunk.pyglet_util import DrawOptions window = pyglet.window.Window( 1280, 720, "Pymunk Tester", resizable=False) # width,height,title,not resizble options = DrawOptions() space = pymunk.Space() space.gravity = 0, 0 #gravity for x and y directions '''Body types: (default is DYNAMIC) DYNAMIC: affected by gravity and other forces (ball,player,enemies etc) KINEMATIC: Not affected by gravity or other forces, but can be moved (platforms,doors) STATIC: Not affected by gravity or other forces, and cannot be moved (ground,building, immovable object) Moment of Inertia: How much a body will resist rotation. Large value: resists rotation/angular acceleration more''' poly = pymunk.Poly.create_box(None, size=(50, 50)) moment = pymunk.moment_for_poly(1, vertices=poly.get_vertices()) body = pymunk.Body(1, moment, pymunk.Body.DYNAMIC ) #rigid body (without shape right now); params: mass, MOI poly.body = body body.position = 640, 700
def visualize(self, genome, game_id: int): """ Visualize the performance of a single genome. :param genome: Tuple (genome_id, genome_class) :param game_id: ID of the game that will be used for evaluation """ # Create the requested game game: Game = get_game(game_id, cfg=self.game_config) self.p2m = game.game_config.p2m # Create space in which game will be played window = pyglet.window.Window( game.x_axis * self.p2m, game.y_axis * self.p2m, "Robot Simulator - Game {id:03d}".format(id=game_id), resizable=False, visible=True) window.set_location(100, 100) pyglet.gl.glClearColor(1, 1, 1, 1) # Setup the requested game self.state = game.reset()[D_SENSOR_LIST] self.finished = False self.score = 0 # Make the network used during visualization net = make_net( genome=genome, genome_config=self.pop_config.genome, batch_size=1, initial_read=self.state, ) # Create the visualize-environment space = pymunk.Space() options = DrawOptions() # Draw static objects - walls if game.wall_bound: x_axis = game.x_axis y_axis = game.y_axis corners = [(0, 0), (0, y_axis * self.p2m), (x_axis * self.p2m, y_axis * self.p2m), (x_axis * self.p2m, 0)] for c in range(4): wall_shape = pymunk.Segment(space.static_body, a=corners[c], b=corners[(c + 1) % 4], radius=0.1 * self.p2m) # 5cm walls wall_shape.color = (0, 0, 0) space.add(wall_shape) # Draw static objects - target target_body = pymunk.Body(body_type=pymunk.Body.KINEMATIC) target_body.position = game.target * self.p2m target_shape = pymunk.Circle(body=target_body, radius=game.bot_config.radius * self.p2m * 3) # TODO: Thick boi target_shape.sensor = True target_shape.color = (0, 128, 0) space.add(target_body, target_shape) # Init player m = pymunk.moment_for_circle(mass=2, inner_radius=0, outer_radius=game.bot_config.radius * self.p2m) player_body = pymunk.Body(mass=1, moment=m) player_body.position = game.player.pos * self.p2m player_body.angle = game.player.angle player_shape = pymunk.Circle(body=player_body, radius=game.bot_config.radius * self.p2m * 3) # TODO: Thick boi player_shape.color = (255, 0, 0) space.add(player_body, player_shape) label = pyglet.text.Label(f'{self.time}', font_size=16, color=(100, 100, 100, 100), x=window.width - 20, y=window.height - 20, anchor_x='center', anchor_y='center') @window.event def on_draw(): window.clear() label.draw() space.debug_draw(options=options) if self.mouse_enabled: @window.event def on_mouse_press(x, y, *_): # Add new circle on mouse-clicked position game.target.x = x / game.game_config.p2m game.target.y = y / game.game_config.p2m target_body.position = game.target * self.p2m def update_method(_): # Input dt ignored dt = 1 / game.game_config.fps self.time += dt label.text = str(int(self.time)) # Stop when target is reached if not self.finished: # Query the game for the next action action = net(np.asarray([self.state])) if self.debug: print(f"Passed time: {round(dt, 3)}") print( f"Location: x={round(player_body.position.x / self.p2m, 2)}, " f"y={round(player_body.position.y / self.p2m, 2)}") print(f"Orientation: {round(player_body.angle, 2)}") print("Action: lw={l}, rw={r}".format( l=round(action[0][0], 3), r=round(action[0][1], 3))) print("Observation:", [round(s, 3) for s in self.state]) # Progress game by one step obs = game.step_dt(dt=dt, l=action[0][0], r=action[0][1]) self.finished = obs[D_DONE] self.state = obs[D_SENSOR_LIST] # Update space's player coordinates and angle player_body.position = game.player.pos * self.p2m player_body.angle = game.player.angle # Check if score has increased if game.score > self.score: self.score = game.score target_body.position = game.target * self.p2m space.step(dt) # Run the game time.sleep(5) # TODO: Waiting time to start recording pyglet.clock.schedule_interval( update_method, 1.0 / (game.game_config.fps * self.speedup)) pyglet.app.run()