def __init__(self, **kwargs): super().__init__(**kwargs) self.prog = self.ctx.program( vertex_shader=''' #version 330 uniform vec4 Camera; // Per vertex in vec2 in_vert; in vec2 in_texture; // Per instance in vec3 in_pos; in vec2 in_size; in vec4 in_tint; out vec2 v_vert; out vec2 v_texture; out vec4 v_tint; void main() { mat2 rotate = mat2( cos(in_pos.z), sin(in_pos.z), -sin(in_pos.z), cos(in_pos.z) ); v_vert = rotate * (in_vert * in_size) + in_pos.xy; gl_Position = vec4((v_vert - Camera.xy) / Camera.zw, 0.0, 1.0); v_texture = in_texture; v_tint = in_tint; } ''', fragment_shader=''' #version 330 uniform sampler2D Texture; in vec2 v_vert; in vec2 v_texture; in vec4 v_tint; out vec4 f_color; void main() { vec4 tex = texture(Texture, v_texture); vec3 color = tex.rgb * (1.0 - v_tint.a) + v_tint.rgb * v_tint.a; f_color = vec4(color, tex.a); } ''', ) self.tex1 = self.load_texture_2d('crate.png') self.tex1.use(0) self.tex2 = self.load_texture_2d('ball.png') self.tex2.use(1) vertices = np.array([ -1.0, -1.0, 0.0, 0.0, -1.0, 1.0, 0.0, 1.0, 1.0, -1.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, ]) vbo1 = self.ctx.buffer(vertices.astype('f4')) self.vbo2 = self.ctx.buffer(reserve=1024 * 1024) vao_content = [ (vbo1, '2f 2f', 'in_vert', 'in_texture'), (self.vbo2, '3f 2f 4f/i', 'in_pos', 'in_size', 'in_tint'), ] self.vao = self.ctx.vertex_array(self.prog, vao_content) self.space = pymunk.Space() self.space.gravity = (0.0, -900.0) shape = pymunk.Segment(self.space.static_body, (5, 100), (595, 100), 1.0) shape.friction = 1.0 self.space.add(shape) self.bodies = [] self.balls = [] for x in range(5): for y in range(10): size = 20 mass = 10.0 moment = pymunk.moment_for_box(mass, (size, size)) body = pymunk.Body(mass, moment) body.position = Vec2d(300 + x * 50, 105 + y * (size + 0.1)) shape = pymunk.Poly.create_box(body, (size, size)) shape.friction = 0.3 self.space.add(body, shape) self.bodies.append(body)
def main(): pygame.init() pygame.display.set_caption("Damped Rotary Spring Pointer") screen = pygame.display.set_mode((600, 600)) clock = pygame.time.Clock() running = True ### Physics stuff space = pymunk.Space() draw_options = pymunk.pygame_util.DrawOptions(screen) pointer_body = pymunk.Body(body_type=pymunk.Body.KINEMATIC) ps = [(80, 0), (0, 20), (0, -20)] moment = pymunk.moment_for_poly(1, ps) gun_body = pymunk.Body(1, moment) gun_body.position = 300, 300 gun_shape = pymunk.Poly(gun_body, ps) rest_angle = 0 stiffness = 125000. damping = 6000. rotary_spring = pymunk.constraint.DampedRotarySpring( pointer_body, gun_body, rest_angle, stiffness, damping) space.add(gun_body, gun_shape, rotary_spring) while running: for event in pygame.event.get(): if event.type == QUIT: running = False elif event.type == KEYDOWN and event.key == K_ESCAPE: running = False elif event.type == KEYDOWN and event.key == K_p: pygame.image.save(screen, "damped_rotary_sprint_pointer.png") elif event.type == pygame.MOUSEMOTION: mouse_pos = pymunk.pygame_util.get_mouse_pos(screen) pointer_body.position = mouse_pos pointer_body.angle = (pointer_body.position - gun_body.position).angle # to easily find good values for the damped rortary spring # as with most simulations done with pymunk, the imporant thing # is that it looks good, not the exact parameters elif event.type == KEYDOWN and event.key == K_q: rotary_spring.stiffness *= .5 print(rotary_spring.stiffness, rotary_spring.damping) elif event.type == KEYDOWN and event.key == K_w: rotary_spring.stiffness *= 2 print(rotary_spring.stiffness, rotary_spring.damping) elif event.type == KEYDOWN and event.key == K_a: rotary_spring.damping *= .5 print(rotary_spring.stiffness, rotary_spring.damping) elif event.type == KEYDOWN and event.key == K_s: rotary_spring.damping *= 2 print(rotary_spring.stiffness, rotary_spring.damping) ### Clear screen screen.fill(THECOLORS["white"]) ### Draw stuff space.debug_draw(draw_options) ### Update physics dt = 1.0 / 60.0 for x in range(1): space.step(dt) ### Flip screen pygame.display.flip() clock.tick(50)
point_1 = body.position + line.a.rotated(body.angle) point_2 = body.position + line.b.rotated(body.angle) return to_pygame(point_1), to_pygame(point_2) ###options#### screen_x = 600 screen_y = 400 num_balls = 10 pygame.init() screen = pygame.display.set_mode((screen_x, screen_y)) clock = pygame.time.Clock() running = True space = pymunk.Space() space.gravity = (0.0, -200.0) #create the base segment base = pymunk.Segment(pymunk.Body(), (0, 50), (screen_x, 0), 0) base.elasticity = 0.90 space.add(base) #create the spinner spinner_points = [(0, 0), (100, -50), (-100, -50)] spinner_body = pymunk.Body(100000, 100000) spinner_body.position = 300, 200 spinner_shape = pymunk.Poly(spinner_body, spinner_points) spinner_shape.elasticity = 0.5 spinner_joint_body = pymunk.Body() spinner_joint_body.position = spinner_body.position
def main(): sys.setrecursionlimit(10000) width, height = 690,600 ### PyGame init pygame.init() screen = pygame.display.set_mode((width,height)) clock = pygame.time.Clock() running = True font = pygame.font.SysFont("Arial", 16) ### Physics stuff space = pymunk.Space() draw_options = pymunk.pygame_util.DrawOptions(screen) env_xml = EnvironmentXml("/home/dseredyn/ws_stero/src/multilevel_planning/data/environments/env_push.xml") models = env_xml.getModels() for model in models: model.addToSpace(space) damped_objects_list = [] for model in models: if not model.damping is None: damped_objects_list.append( (model.body, model.damping[0], model.damping[1]) ) # cab = ModelCabinet(200, 100, Vec2d(200,200), -0.05) # cab.addToSpace(space) # box = ModelBox(50, 10, Vec2d(200,200), 0*math.pi/4.0) # box.addToSpace( space ) # damped_objects_list.append( (box.body, 300.0, 3000.0) ) # robot # rob = ModelRobot( Vec2d(100,100), 0.0 ) # rob = ModelRobot( Vec2d(220,225), 0.0 ) # rob.addToSpace(space) for ob in models: if ob.name == "robot": rob = ob if ob.name == "box": box = ob control_mode = "target_pos" position_control = ManualPositionControl(1000.0, 500.0, 50000.0, 50000.0) control_mode = "auto" dest_point = Vec2d(550,270) # info_exp_motion = InformationExpectedMotion() # info_exp_motion.anchor = "instance_box" # info_exp_motion.target_point = Vec2d(500,500) move_command = InformationMoveObjectCommand("box", Vec2d(500,500)) # provide information information = [ #InformationSpatialMapRange( (0, width), 100, (0, height), 100 ), # range and resolution of spatial map InformationRobotPose( rob.robot_body.position, rob.robot_body.angle ), # current pose of robot InformationPerceptionSpace( space, models ), # percepted environment (exact, full perception) # InformationDestinationGeom( dest_point ), # target point for motion # InformationOpenDoorCommand(), # info_exp_motion, move_command, ] behaviors = [ BehaviorSpatialMapGeneration(models), # BehaviorSpaceDigging(env), BehaviorKeepContact(), BehaviorSpatialPathPlanner(), BehaviorMoveTowards(), BehaviorObstacleAvoidance(), BehaviorTightPassage(), # BehaviorDoorPerception(cab.left_door), # BehaviorOpenDoor(), BehaviorMoveObject(), BehaviorObjectPerception(),#box, "box"), BehaviorPushObject(), BehaviorPushExecution(), BehaviorRobotControl(), ] # behaviors[0].update(information) # behaviors[0].plotTriangulation() # behaviors[0].plotGraph() # plt.show() # behaviors[1].update(information) # behaviors[1].plotTriangulation() # behaviors[1].plotGraph() # behaviors[1].plotOccludedSimplices() # behaviors[1].plotBorder() # plt.show() # exit(0) generateBehaviorsDotGraph('/home/dseredyn/svn/phd/ds/doktorat/rozwazania_2018_04/img/zachowania.dot', behaviors) first_behavior_iteration = True iterations = 0 pause = False show_debug = False while running: iterations += 1 if iterations == 10: generateBehaviorsDotGraph('/home/dseredyn/svn/phd/ds/doktorat/rozwazania_2018_04/img/zachowania_2.dot', behaviors) for event in pygame.event.get(): if event.type == QUIT or \ event.type == KEYDOWN and (event.key in [K_ESCAPE, K_q]): running = False if event.type == KEYDOWN and event.key == K_SPACE: pause = not pause if event.type == KEYDOWN and event.key == K_d: show_debug = not show_debug if pause: time.sleep(0.1) continue debug_info = [] keys = pygame.key.get_pressed() active_behaviors = [] # manual control if control_mode == "force": manualForceControl(rob.robot_body, keys) elif control_mode == "target_pos": position_control.update( rob.robot_body, keys ) elif control_mode == "auto": position_control.update( rob.robot_body, keys ) joinInformation( information, [ InformationRobotPose( rob.robot_body.position, rob.robot_body.angle ) ] ) # current pose of robot for b in behaviors: new_inf = b.update( information ) joinInformation( information, new_inf ) if len(new_inf) > 0: active_behaviors.append( b.name ) #print new_inf[0].type inf_list = [] for inf in information: inf_list.append( inf.type ) if inf.type == "robot_total_control": lin_damping = 300.0 lin_stiffness = 5000.0 rot_damping = 5000.0 rot_stiffness = 5000.0 #print inf.force, inf.torque rob.robot_body.force = lin_stiffness*inf.force - lin_damping * rob.robot_body.velocity rob.robot_body.torque = rot_stiffness*inf.torque - rot_damping * rob.robot_body.angular_velocity #print inf.torque #print "data:", inf_list # TODO: fix removing old information wrt. behavior execution sequence clearObsoleteInformation( information ) #print active_behaviors # print "plan_idx", plan_idx #cab.debugVis(debug_info) #rob.debugVisQhull(debug_info) #rob.debugVisPushing(debug_info) applyDamping( damped_objects_list ) mouse_position = pymunk.pygame_util.from_pygame( Vec2d(pygame.mouse.get_pos()), screen ) mouse_position_munk = MunkToGame(mouse_position, height) move_command.dest_position = mouse_position ### Clear screen screen.fill(pygame.color.THECOLORS["black"]) ### Draw stuff space.debug_draw(draw_options) if control_mode == "target_pos": position_control.debugInfoDraw( debug_info ) elif control_mode == "auto": #behaviors[2].debugVisDraw(debug_info) #drawDebugCircle(debug_info, "green", 5, dest_point) vis_behaviors = ["keep_contact", "push_object", "spatial_path_planner", "obstacle_avoidance", "move_towards"] for b in behaviors: if b.name in vis_behaviors and b.name in active_behaviors: b.debugVisDraw(debug_info) # draw debug info if show_debug: drawDebugInfo(screen, height, debug_info) # Info and flip screen screen.blit(font.render("fps: " + str(clock.get_fps()), 1, THECOLORS["white"]), (0,0)) screen.blit(font.render("Mouse position (in world coordinates): " + str(mouse_position[0]) + "," + str(mouse_position[1]), 1, THECOLORS["darkgrey"]), (5,height - 35)) screen.blit(font.render("Press ESC or Q to quit", 1, THECOLORS["darkgrey"]), (5,height - 20)) pygame.display.flip() ### Update physics fps = 60 dt = 1./fps space.step(dt) clock.tick(fps)
def init(): space = pymunk.Space() space.iterations = 10 space.sleep_time_threshold = 0.5 static_body = space.static_body # Create segments around the edge of the screen. shape = pymunk.Segment(static_body, (1,1), (1,480), 1.0) space.add(shape) shape.elasticity = 1 shape.friction = 1 shape = pymunk.Segment(static_body, (640,1), (640,480), 1.0) space.add(shape) shape.elasticity = 1 shape.friction = 1 shape = pymunk.Segment(static_body, (1,1), (640,1), 1.0) space.add(shape) shape.elasticity = 1 shape.friction = 1 shape = pymunk.Segment(static_body, (1,480), (640,480), 1.0) space.add(shape) shape.elasticity = 1 shape.friction = 1 for _ in range(50): body = add_box(space, 20, 1) pivot = pymunk.PivotJoint(static_body, body, (0,0), (0,0)) space.add(pivot) pivot.max_bias = 0 # disable joint correction pivot.max_force = 1000 # emulate linear friction gear = pymunk.GearJoint(static_body, body, 0.0, 1.0) space.add(gear) gear.max_bias = 0 # disable joint correction gear.max_force = 5000 # emulate angular friction # We joint the tank to the control body and control the tank indirectly by modifying the control body. global tank_control_body tank_control_body = pymunk.Body(body_type=pymunk.Body.KINEMATIC) tank_control_body.position = 320, 240 space.add(tank_control_body) global tank_body tank_body = add_box(space, 30, 10) tank_body.position = 320, 240 for s in tank_body.shapes: s.color = (0,255,100,255) pivot = pymunk.PivotJoint(tank_control_body, tank_body, (0,0), (0,0)) space.add(pivot) pivot.max_bias = 0 # disable joint correction pivot.max_force = 10000 # emulate linear friction gear = pymunk.GearJoint(tank_control_body, tank_body, 0.0, 1.0) space.add(gear) gear.error_bias = 0 # attempt to fully correct the joint each step gear.max_bias = 1.2 # but limit it's angular correction rate gear.max_force = 50000 # emulate angular friction return space
def __init__(self, params, seed, fidelity=10, debug_options=None): """Constructor Args: params: dict of parameters that define how symbols behave and are rendered. See the detailed description for this class for supported parameters. seed: Seed for the RNG (int) fidelity: How many iterations to run in the physics simulator per step (int) debug_options: dict with options for visual debugging, or None if visual debugging should be turned off. The following key-value pairs are supported: - show_pymunk_debug, bool: Whether to use PyMunk's default drawing function - show_bounding_poly, bool: Whether to render PyMunk surface outlines - show_frame_number, bool: Whether to show the index of the frame - frame_number_font_size, int: Size of the frame index font - frame_rate, int: Frame rate of the debug visualization """ self.params = merge_dicts(MovingSymbolsEnvironment.DEFAULT_PARAMS, params) self.fidelity = fidelity self.debug_options = None if debug_options is None \ else merge_dicts(MovingSymbolsEnvironment.DEFAULT_DEBUG_OPTIONS, debug_options) self.video_size = self.params['video_size'] self._subscribers = [] self._init_messages = [] self._step_called = False self._add_init_message( dict(step=-1, type='params', meta=dict(self.params))) # Convert translation/rotation/scale period/speed limits to lists if isinstance(self.params['scale_period_limits'], tuple): self.params['scale_period_limits'] = [ self.params['scale_period_limits'] ] if isinstance(self.params['rotation_speed_limits'], tuple): self.params['rotation_speed_limits'] = [ self.params['rotation_speed_limits'] ] if isinstance(self.params['position_speed_limits'], tuple): self.params['position_speed_limits'] = [ self.params['position_speed_limits'] ] self.cur_rng_seed = seed np.random.seed(self.cur_rng_seed) if self.debug_options is not None: self._pg_screen = pg.display.set_mode(self.video_size) self._pg_draw_options = pmu.DrawOptions(self._pg_screen) pg.font.init() font_size = self.debug_options['frame_number_font_size'] self._pg_font = pg.font.SysFont(pg.font.get_default_font(), font_size) self._pg_clock = pg.time.Clock() self._add_init_message( dict(step=-1, type='debug_options', meta=dict(debug_options))) self._space = pm.Space() self.symbols = [] image_loader = ImageLoader( os.path.join(self.params['data_dir'], self.params['split']), 'tight_crop') if self.params['background_data_dir'] is None or self.params[ 'background_labels'] is None: bg_image_loader = None else: bg_image_loader = ImageLoader( os.path.join(self.params['background_data_dir'], self.params['split'])) for id in xrange(self.params['num_symbols']): label = self.params['symbol_labels'][np.random.randint( len(self.params['symbol_labels']))] image, image_path = image_loader.get_image(label) # Define the scale function period_limits_index = np.random.choice( len(self.params['scale_period_limits'])) period = np.random.uniform(*tuple( self.params['scale_period_limits'][period_limits_index])) amplitude = (self.params['scale_limits'][1] - self.params['scale_limits'][0]) / 2. x_offset = np.random.uniform(period) # Override offset if digits should not start at random scale if not self.params['rescale_at_start']: x_offset = 0 # Randomly shift offset (i.e. symbol can either grow or shrink at start) x_offset += (period / 2 if np.random.choice([True, False]) else 0) y_offset = (self.params['scale_limits'][1] + self.params['scale_limits'][0]) / 2. if self.params['scale_function_type'] == 'sine': scale_fn = create_sine_fn(period, amplitude, x_offset, y_offset) elif self.params['scale_function_type'] == 'triangle': scale_fn = create_triangle_fn(period, y_offset, self.params['movement']) elif self.params['scale_function_type'] == 'constant': scale = np.random.uniform(*self.params['scale_limits']) scale_fn = lambda x: scale else: raise ValueError('scale_function_type "%s" is unsupported' % self.params['scale_function_type']) symbol = Symbol(id, label, image, image_path, scale_fn) # Set the symbol's initial rotation and scale symbol.set_scale(0) start_angle = np.random.uniform(2 * math.pi) if self.params['rotate_at_start']: symbol.body.angle = start_angle # Compute the minimum possible margin between the symbol's center and the wall w_half = image.size[0] / 2. h_half = image.size[1] / 2. margin = math.sqrt(w_half**2 + h_half**2) * self.params['scale_limits'][1] # Set the symbol position at least one margin's distance from any wall x_limits = (margin + 1, self.video_size[0] - margin - 1) y_limits = (margin + 1, self.video_size[1] - margin - 1) symbol.body.position = (np.random.uniform(*x_limits), np.random.uniform(*y_limits)) # If symbols will interact with each other, make sure they don't overlap initially while self.params['interacting_symbols'] and len( self._space.shape_query(symbol.shape)) > 0: symbol.body.position = (np.random.uniform(*x_limits), np.random.uniform(*y_limits)) # Set angular velocity rotation_speed_limit_index = np.random.choice( len(self.params['rotation_speed_limits'])) symbol.body.angular_velocity = np.random.uniform( *tuple(self.params['rotation_speed_limits'] [rotation_speed_limit_index])) symbol.body.angular_velocity *= 1 if np.random.binomial(1, .5) else -1 symbol.angular_velocity = symbol.body.angular_velocity # Set translational velocity sampled_velocity = np.random.uniform(-1, 1, 2) if self.params['movement'] == 'Down': sampled_velocity = np.array([0, -1]) elif self.params['movement'] == 'Right': sampled_velocity = np.array([1, 0]) elif self.params['movement'] == 'Up': sampled_velocity = np.array([0, 1]) elif self.params['movement'] == 'Left': sampled_velocity = np.array([-1, 0]) elif self.params['movement'] == 'Horizontal': sampled_velocity = np.array([1, 0]) elif self.params['movement'] == 'Vertical': sampled_velocity = np.array([0, 1]) elif self.params['movement'] == 'Circle': x = np.linspace(-1.0, 1.0, 100) y = np.linspace(-1.0, 1.0, 100) X, Y = np.meshgrid(x, y) F = X**2 + Y**2 - 1 c = plt.contour(X, Y, F, [0]) dat0 = c.allsegs[0][0] self.dat1 = np.zeros((self.params['video_len'], 2)) indices = np.linspace(0, dat0.shape[0] - 1, self.params['video_len'], dtype='int') for i, j in enumerate(indices): self.dat1[i] = dat0[j] sampled_velocity = self.dat1[0] elif self.params['movement'] == 'Square': self.dat1 = np.zeros((self.params['video_len'], 2)) count = 0 for i in range(self.params['video_len']): if count < 5: self.dat1[i] = [0, -1] elif 5 <= count < 10: self.dat1[i] = [1, 0] elif 10 <= count < 15: self.dat1[i] = [0, 1] elif 15 <= count < 20: self.dat1[i] = [-1, 0] count += 1 sampled_velocity = self.dat1[0] elif self.params['movement'] == 'Triangle': self.dat1 = np.zeros((self.params['video_len'], 2)) count = 0 for i in range(self.params['video_len']): if count < 6: self.dat1[i] = [-1, -1] elif 6 <= count < 13: self.dat1[i] = [1, 0] elif 13 <= count < 20: self.dat1[i] = [-1, 1] count += 1 sampled_velocity = self.dat1[0] elif self.params['movement'] == 'Eight': x = np.linspace(-1.0, 1.0, 100) y = np.linspace(-1.0, 1.0, 100) X, Y = np.meshgrid(x, y) F = X**2 + Y**2 - 1 c = plt.contour(X, Y, F, [0]) dat = c.allsegs[0][0] dat0 = np.concatenate((dat, dat), axis=0) self.dat1 = np.zeros((self.params['video_len'], 2)) indices = np.linspace(0, dat0.shape[0] - 1, self.params['video_len'], dtype='int') count = 0 for i, j in enumerate(indices): if count < 5: self.dat1[i] = [dat0[j][1], dat0[j][0]] elif 5 <= count < 10: self.dat1[i] = [dat0[j][1], -dat0[j][0]] elif 10 <= count < 15: self.dat1[i] = [dat0[j][1], -dat0[j][0]] elif 15 <= count < 20: self.dat1[i] = [dat0[j][1], dat0[j][0]] count += 1 sampled_velocity = self.dat1[0] elif self.params['movement'] == 'Infinite': x = np.linspace(-1.0, 1.0, 100) y = np.linspace(-1.0, 1.0, 100) X, Y = np.meshgrid(x, y) F = X**2 + Y**2 - 1 c = plt.contour(X, Y, F, [0]) dat = c.allsegs[0][0] dat0 = np.concatenate((dat, dat), axis=0) self.dat1 = np.zeros((self.params['video_len'], 2)) indices = np.linspace(0, dat0.shape[0] - 1, self.params['video_len'], dtype='int') count = 0 for i, j in enumerate(indices): if count < 5: self.dat1[i] = [-dat0[j][0], dat0[j][1]] elif 5 <= count < 10: self.dat1[i] = [dat0[j][0], dat0[j][1]] elif 10 <= count < 15: self.dat1[i] = [dat0[j][0], dat0[j][1]] elif 15 <= count < 20: self.dat1[i] = [-dat0[j][0], dat0[j][1]] count += 1 sampled_velocity = self.dat1[0] symbol.body.velocity = sampled_velocity / np.linalg.norm( sampled_velocity) self.position_speed_limit_index = np.random.choice( len(self.params['position_speed_limits'])) symbol.body.velocity *= np.random.uniform( *tuple(self.params['position_speed_limits'][ self.position_speed_limit_index])) # Add symbol to the space and environment self._space.add(symbol.body, symbol.shape) self.symbols.append(symbol) # Publish message about the symbol # self._publish_message(symbol.get_init_message()) self._add_init_message(symbol.get_init_message()) # Add walls self._add_walls() # Add collision handlers self._add_collision_handlers( interacting_symbols=self.params['interacting_symbols']) # Init step count self._step_count = 0 # Set background image self.background = Image.fromarray( np.zeros((self.video_size[0], self.video_size[1], 3), dtype=np.uint8)) if bg_image_loader is not None: # Choose a category bg_labels = self.params['background_labels'] category_name = bg_labels[np.random.randint(len(bg_labels))] # Choose an image bg_image, full_image_path = bg_image_loader.get_image( category_name) self.background.paste(bg_image) # Publish information about the chosen background self._add_init_message( dict(step=-1, type='background', meta=dict(label=category_name, image=np.array(self.background), image_path=full_image_path)))
def create_world(self): self.space = pymunk.Space() self.space.gravity = Vec2d(0., -900.) self.space.sleep_time_threshold = 0.9 self.boxes = [ ] # 2d array box instances correspondingly for each layer self.predicted_stability = False self.removed_object = False # Create the ground line ground_line = pymunk.Segment( self.space.static_body, Vec2d(20, self.bottom_edge), Vec2d(self.window_width - 20, self.bottom_edge), 1) ground_line.friction = 0.9 self.space.add(ground_line) # With this model putting boxes and setting up number of boxes happens in parallel n = self.n layer_num = -1 # Represents the index of the current layer while n > 0: layer_num += 1 self.boxes.append([]) right_edge, left_edge = self.get_right_left_edge(layer_num - 1) if right_edge == left_edge: # The layer below has one element x_pos = random.randint( int(left_edge - self.rect_width_min / 2), int(left_edge + self.rect_width_min / 2)) rect_width = random.randint( self.rect_width_min, self.rect_width_min + self.rect_width_range) self.put_box(layer_num=layer_num, x_pos=x_pos, y_pos=self.bottom_edge + int(self.rect_height / 2) + self.rect_height * layer_num, rect_width=rect_width) n -= 1 continue # Start from the left_edge and put boxes towards right edge # Stop putting boxes if the number of objects required is reached # Move on to the next layer if the right edge is reached left_edge -= (layer_num > 0) * int(self.rect_width_average / 2) rect_width = random.randint( self.rect_width_min, self.rect_width_min + self.rect_width_range) left_edge += rect_width while left_edge - rect_width / 2 < right_edge and n > 0: self.put_box(layer_num=layer_num, x_pos=left_edge - rect_width / 2, y_pos=self.bottom_edge + self.rect_height / 2 + self.rect_height * layer_num, rect_width=rect_width) n -= 1 space_between = random.randint(0, self.max_space_rects) left_edge += space_between # Put a space between rectangles rect_width = random.randint( self.rect_width_min, self.rect_width_min + self.rect_width_range) left_edge += rect_width self.flat_boxes = [] for i in range(len(self.boxes)): for j in range(len(self.boxes[i])): self.flat_boxes.append(self.boxes[i][j]) print('len(flat_boxes): {}'.format(len(self.flat_boxes))) print('len(trajectories): {}'.format(len(self.trajectories))) if len(self.flat_boxes) == self.n: self.trajectories.append([])
def pymunk_setup(self, experiment): # Initialize space and set gravity for space to do simulation over self.width = 800 self.height = 600 self.ball_size = 60 self.speed = 200 # scales how fast balls are moving self.step_size = 1 / 50.0 self.step_max = 300 # step at which to stop the animation self.step = 0 # used to record when events happen self.space = pymunk.Space() self.events = { 'collisions': [], 'outcome': None, 'outcome_fine': None } # used to record events # containers for bodies and shapes self.bodies = collections.OrderedDict() self.shapes = collections.OrderedDict() self.sprites = collections.OrderedDict() self.collision_types = {'static': 0, 'dynamic': 1, 'teleport': 2} self.experiment = experiment if self.experiment == '3ball': self.target_ball = 'E' else: self.target_ball = 'B' # add walls self.add_wall(position=(400, 590), length=800, height=20, name='top_wall', space=self.space) self.add_wall(position=(400, 10), length=800, height=20, name='bottom_wall', space=self.space) self.add_wall(position=(10, 100), length=20, height=200, name='top_left_wall', space=self.space) self.add_wall(position=(10, 500), length=20, height=200, name='bottom_left_wall', space=self.space) # read in trial info self.read_trials() self.balls = self.trials[self.trial]['balls'] # add objects if self.experiment == 'teleport': self.objects = self.trials[self.trial]['objects'] for object in self.objects: if object['name'] == 'brick': body, shape = self.add_brick(position=object['position'], name=object['name'], rotation=object['rotation'], space=self.space) if object['name'] == 'teleport_entrance': body, shape = self.add_teleport_entrance( position=object['position'], name=object['name'], rotation=object['rotation'], status=object['status'], space=self.space) if object['name'] == 'teleport_exit': body, shape = self.add_teleport_exit( position=object['position'], name=object['name'], status=object['status'], space=self.space) self.bodies[object['name']] = body self.shapes[object['name']] = shape # add balls for ball in self.balls: body, shape = self.add_ball(position=ball['position'], name=ball['name'], velocity=ball['velocity'], size=self.ball_size, space=self.space) self.bodies[ball['name']] = body self.shapes[ball['name']] = shape
def main(): pygame.init() screen = pygame.display.set_mode((600, 600)) clock = pygame.time.Clock() running = True ### Physics stuff space = pymunk.Space() space.gravity = 0.0, -900.0 ## Balls balls = [] ### Mouse mouse_body = pymunk.Body(body_type=pymunk.Body.KINEMATIC) mouse_shape = pymunk.Circle(mouse_body, 3, (0, 0)) mouse_shape.collision_type = COLLTYPE_MOUSE space.add(mouse_body, mouse_shape) space.add_collision_handler( COLLTYPE_MOUSE, COLLTYPE_BALL ).pre_solve = mouse_coll_func ### Static line line_point1 = None static_lines = [] run_physics = True while running: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE: running = False elif event.type == pygame.KEYDOWN and event.key == pygame.K_p: pygame.image.save(screen, "balls_and_lines.png") elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1: p = event.pos[X], flipy(event.pos[Y]) body = pymunk.Body(10, 100) body.position = p shape = pymunk.Circle(body, 10, (0, 0)) shape.friction = 0.5 shape.collision_type = COLLTYPE_BALL space.add(body, shape) balls.append(shape) elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 3: if line_point1 is None: line_point1 = Vec2d(event.pos[X], flipy(event.pos[Y])) elif event.type == pygame.MOUSEBUTTONUP and event.button == 3: if line_point1 is not None: line_point2 = Vec2d(event.pos[X], flipy(event.pos[Y])) shape = pymunk.Segment( space.static_body, line_point1, line_point2, 0.0 ) shape.friction = 0.99 space.add(shape) static_lines.append(shape) line_point1 = None elif event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE: run_physics = not run_physics p = pygame.mouse.get_pos() mouse_pos = Vec2d(p[X], flipy(p[Y])) mouse_body.position = mouse_pos if pygame.key.get_mods() & pygame.KMOD_SHIFT and pygame.mouse.get_pressed()[0]: body = pymunk.Body(10, 10) body.position = mouse_pos shape = pymunk.Circle(body, 10, (0, 0)) shape.collision_type = COLLTYPE_BALL space.add(body, shape) balls.append(shape) ### Update physics if run_physics: dt = 1.0 / 60.0 for x in range(1): space.step(dt) ### Draw stuff screen.fill(pygame.Color("white")) # Display some text font = pygame.font.Font(None, 16) text = """LMB: Create ball LMB + Shift: Create many balls RMB: Drag to create wall, release to finish Space: Pause physics simulation""" y = 5 for line in text.splitlines(): text = font.render(line, True, pygame.Color("black")) screen.blit(text, (5, y)) y += 10 for ball in balls: r = ball.radius v = ball.body.position rot = ball.body.rotation_vector p = int(v.x), int(flipy(v.y)) p2 = p + Vec2d(rot.x, -rot.y) * r * 0.9 p2 = int(p2.x), int(p2.y) pygame.draw.circle(screen, pygame.Color("blue"), p, int(r), 2) pygame.draw.line(screen, pygame.Color("red"), p, p2) if line_point1 is not None: p1 = int(line_point1.x), int(flipy(line_point1.y)) p2 = mouse_pos.x, flipy(mouse_pos.y) pygame.draw.lines(screen, pygame.Color("black"), False, [p1, p2]) for line in static_lines: body = line.body pv1 = body.position + line.a.rotated(body.angle) pv2 = body.position + line.b.rotated(body.angle) p1 = int(pv1.x), int(flipy(pv1.y)) p2 = int(pv2.x), int(flipy(pv2.y)) pygame.draw.lines(screen, pygame.Color("lightgray"), False, [p1, p2]) ### Flip screen pygame.display.flip() clock.tick(50) pygame.display.set_caption("fps: " + str(clock.get_fps()))
def __init__(self, config_file, trial_number): # Use the base of the config file's name as the name of the output dir output_dir_base = str.split(config_file, '.')[0] self.output_dir = output_dir_base + '/' + str(trial_number) print(self.output_dir) config = ConfigSingleton.get_instance(config_file) # Load parameters from config file. self.width_cm = config.getint("AlvinSim", "width_cm") self.height_cm = config.getint("AlvinSim", "height_cm") self.width = int(self.width_cm * CM_TO_PIXELS) self.height = int(self.height_cm * CM_TO_PIXELS) #print "width, height: {}, {}".format(self.width, self.height); self.circ_border = config.getboolean("AlvinSim", "circ_border") self.number_robots = config.getint("AlvinSim", "number_robots") self.number_pucks = config.getint("AlvinSim", "number_pucks") self.number_puck_kinds = config.getint("AlvinSim", "number_puck_kinds") self.number_steps = config.getint("AlvinSim", "number_steps") self.puck_ring = config.getboolean("AlvinSim", "puck_ring") self.puck_ring_radius = config.getint("AlvinSim", "puck_ring_radius") self.canned_landmarks_name = config.get("AlvinSim", "canned_landmarks_name") self.puck_shape = config.get("AlvinSim", "puck_shape") self.lmark_pair_dist = config.getint("AlvinSim", "lmark_pair_dist") self.puck_kinds = list(range(self.number_puck_kinds)) self.wall_thickness = config.getint("AlvinSim", "wall_thickness") self.capture_interval = config.getint("AlvinSim", "capture_interval") self.analyze = config.getboolean("AlvinSim", "analyze") self.capture_screenshots = config.getboolean("AlvinSim", "capture_screenshots") self.visualize_probes = config.getboolean("AlvinSim", "visualize_probes") self.controller_name = config.get("AlvinSim", "controller_name") self.render_skip = config.getint("AlvinSim", "render_skip") # build simulation environment self.env = pymunk.Space() self.env.damping = 0.0001 # 9999% of velocity is lost per second # Seed random number generator. seed(trial_number) # Create the walls, robots, pucks, and landmarks if self.circ_border: self.create_circ_border() else: self.create_rect_border() #self.create_random_walls() #self.create_one_wall() self.robots = [] self.pucks = [] self.landmarks = [] self.probes = [] self.create_robots() if self.puck_ring: self.create_pucks_ring() else: self.create_pucks_random() #self.create_immobile_pucks() self.create_canned_landmarks() if self.visualize_probes: self.create_probe_grid() # Prepare output directory. shutil.rmtree(self.output_dir, ignore_errors=True) os.makedirs(self.output_dir) if self.analyze: #init(self.output_dir) self.analyzer = Analyzer(self.output_dir, self.landmarks) # Setup to handle collisions #self.env.add_default_collision_handler().begin = self.collision_handler self.avg_dt = None
def main(): # Setup Level common variables -------------------------------- ## force = 2300 # Force upon the ball when it is fired rampsize = 100 # end coordinate of the ball's ramp pygame.init() pygame.display.set_caption("Angry Clones") clock = pygame.time.Clock() # Set up static images, these never move greyed_out = Image("greyed_out.jpg") background = Image("machinarium_floor.jpg") trebuchet = Image("trebuchet.png", (20, 450)) global screen screen = pygame.display.set_mode(background.get_size()) space = pm.Space() space.gravity = (0.0, -300.0) body = pm.Body() # ground ground = pm.Segment(body, (0, 100), (1050, 100), .0) ground.friction = 6.0 space.add(ground) #left wall left_wall = pm.Segment(body, to_pygame((0, 0)), to_pygame((0, 2000)), .0) left_wall.friction = 6.0 space.add(left_wall) # ball area ball_area = pm.Segment(body, (0, 110), (60, 110), .0) space.add(ball_area) # Title Screen ------------------------------------------------- ## count = 0 while count < 70: for event in pygame.event.get(): if event.type == QUIT: pygame.quit() sys.exit(0) elif event.type == KEYDOWN: if event.key == K_ESCAPE: pygame.quit() sys.exit(0) # Space bar skips the title screen if event.key == 32: count = 71 greyed_out.display() Message("Angry Clones!", (220, 250), 95).display_shadow() pygame.display.flip() count += 1 # End Title Screen ---------------------------------------------- ## # Main Game loop ------------------------------------------------ ## game_complete = False level = 0 while not game_complete: # Record time now, to see how fast you complete the game start_game_timer = datetime.datetime.now() trying_again = True while trying_again: # Level setup ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ## if level == 0: balls = [] x, y = (2, 110) balls.append(Ball(space, x, y)) # Add crates crates = [] crates += [ Crate(space, (500, 85 + (23 + i * 51))) for i in range(3) ] crates += [ Crate(space, (600, 85 + (23 + i * 51))) for i in range(3) ] crates += [Crate(space, (505 + 46, 278), True)] # Add one snake snakes = [] snakes.append(Snake(space, to_pygame((551, 232)))) level_complete = False level_failed = False count = 0 if level == 1: # Remove all old crates etc from the playing area for crate in crates: crate.delete(space) for ball in balls: ball.delete(space) for snake in snakes: snake.delete(space) balls = [] x, y = (2, 110) balls.append(Ball(space, x, y)) # Map of intended level - Key #------------------------------------------------ # #T# S = Snake # S ### S # #T# #T# #T# #T# = TNT crate # ### ### ### ### # # # # # # # # # # # # # # # # A B C D E F G # Add crates crates = [] crates += [ Crate(space, (500, 85 + (23 + i * 51))) for i in range(3) ] #A crates += [ Crate(space, (600, 85 + (23 + i * 51))) for i in range(3) ] #C crates += [ Crate(space, (700, 85 + (23 + i * 51))) for i in range(3) ] #E crates += [ Crate(space, (800, 85 + (23 + i * 51))) for i in range(3) ] #G crates += [Crate(space, (505 + 46, 278), True)] #B crates += [Crate(space, (605 + 46, 278), True)] #D crates += [Crate(space, (705 + 46, 278), True)] #F crates += [Crate(space, (605 + 46, 378), True)] #D higher # Add snakes Snake.snakes_alive = 0 snakes = [] snakes.append(Snake(space, (551, 350))) snakes.append(Snake(space, (751, 350))) level_complete = False level_failed = False count = 0 start_timer = datetime.datetime.now() if level == 2: # Remove all old crates etc from the playing area for crate in crates: crate.delete(space) for ball in balls: ball.delete(space) for snake in snakes: snake.delete(space) balls = [] x, y = (2, 110) balls.append(Ball(space, x, y)) # Map of intended level - Key #------------------------------------------------ # S S = Snake # #T# # S ### #T# = TNT crate # #T# #T# ### # S ### ### # #T# #T# #T# # ### ### ### # A B C # Add crates crates = [] crates += [Crate(space, (305 + 46, 170), True)] #A crates += [Crate(space, (505 + 46, 170), True)] #B crates += [Crate(space, (505 + 46, 270), True)] # crates += [Crate(space, (705 + 46, 170), True)] #C crates += [Crate(space, (705 + 46, 270), True)] # crates += [Crate(space, (705 + 46, 370), True)] # # Add snakes Snake.snakes_alive = 0 snakes = [] snakes.append(Snake(space, (351, 310))) snakes.append(Snake(space, (551, 410))) snakes.append(Snake(space, (751, 510))) level_complete = False level_failed = False count = 0 start_timer = datetime.datetime.now() # End Level Setup ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ## # Game-play loop ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ## while not level_complete and not level_failed: space.step(1 / 30.0) clock.tick(30) for event in pygame.event.get(): if event.type == QUIT: pygame.quit() sys.exit(0) elif event.type == KEYDOWN: if event.key == K_ESCAPE: pygame.quit() sys.exit(0) # Spacebar is pressed if event.key == 32: # Reset the ball if lost balls[0].delete(space) balls = [] x, y = (2, 110) balls.append(Ball(space, x, y)) balls[0].random_colour() #Get ramp slope from mouse 'y' rampsize = to_pygame(pygame.mouse.get_pos())[1] slope = pm.Segment(body, (60, 110), (250, rampsize), .0) space.add(slope) background.display() trebuchet.display() balls[0].draw() if pygame.mouse.get_pressed()[0]: balls[0].fire(force / 3) for crate in crates: crate.draw() # Add variety to crate's looks if level == 0: crates[1].brake_crate() crates[5].brake_crate() crates[0].brake_crate() if level == 1: crates[3].brake_crate() crates[8].brake_crate() crates[1].brake_crate() crates[5].brake_crate() for snake in snakes: snake.draw() if snake.is_dead(): snake.kill_snake() #This doesn't make sense! Message("The Snake is Dead!", \ (600,600)).display_shadow() #If you kill all the snakes you win the level if Snake.all_snakes_dead(): level_complete = True level_failed = False pass #Draw Ramp pygame.draw.aaline(screen, THECOLORS['red'], \ to_pygame((60,110)), to_pygame((250,rampsize))) #Draw Ball Area pygame.draw.aaline(screen, THECOLORS['red'],\ to_pygame((0,110)), to_pygame((60,110))) #If mouse goes of screen to the right, bring it back if to_pygame(balls[0].get_position())[0] > 1024: balls[0].reposition(1, 110) #Display number of snakes left Message("{0}".format("Snakes Left: {0}"\ .format(Snake.snakes_alive)),(0,0), 30).display_shadow() #Time attack for levels 2 and 3 if level > 0: #Work out time remaining delta = datetime.datetime.now() - start_timer Message("{0}".format("Time Left: {0}"\ .format(30 - delta.seconds)),(830,0),30)\ .display_shadow() #If time has passed, you fail the level if 30 - delta.seconds <= 0: level_failed = True pygame.display.flip() count += 1 #del slope # End Game-play Loop ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ## # You have either completed the level or failed it # FAILED: Ask if you would like to try again --------------- ## if level_failed: count = 0 while count < 70: space.step(1 / 30.0) clock.tick(30) for event in pygame.event.get(): if event.type == QUIT: pygame.quit() sys.exit(0) elif event.type == KEYDOWN: if event.key == K_ESCAPE: pygame.quit() sys.exit(0) # Spacebar is pressed if event.key == 32: trying_again = True # End the loop and start next level count = 71 greyed_out.display() if count < 30: Message("Good Try!", (320, 250), 95).display_shadow() if count > 30: Message("Press SPACE to try again", (80,250), 80)\ .display_shadow() Message("Press ESC to quit", (300,400), 60)\ .display_shadow() pygame.display.flip() count += 1 # Trick to halt the game on message if count == 32: count = 31 # End Try again screen ------------------------------------ ## # You didn't fail, show next level screen ----------------- ## if level_complete: count = 0 while count < 70: for event in pygame.event.get(): if event.type == QUIT: pygame.quit() sys.exit(0) elif event.type == KEYDOWN: if event.key == K_ESCAPE: pygame.quit() sys.exit(0) if event.key == 32: want_to_try_again = True count = 71 greyed_out.display() # No need if you are on the last level, # Just go to final conratulations screen if level < 2: # Display this message first if count < 30: Message("Well Done", (320, 250), 95).display_shadow() # Then this if count > 30: next_lvl = level + 2 Message("Level {0}".format(next_lvl),\ (350,250), 95).display_shadow() else: count = 71 pygame.display.flip() count += 1 if level == 2: game_complete = True trying_again = False else: level += 1 # End next level screen -------------------------------------- ## # Completed the game # (can only try again or quit so must have won to get here) end_time = datetime.datetime.now() time_taken = end_time - start_game_timer count = 0 while count < 70: for event in pygame.event.get(): if event.type == QUIT: pygame.quit() sys.exit(0) elif event.type == KEYDOWN: if event.key == K_ESCAPE: pygame.quit() sys.exit(0) if event.key == 32: want_to_try_again = True count = 71 greyed_out.display() # Display this message first if count < 30: Message("Game Completed!", (130, 250), 95).display_shadow() # Then this if count > 30: Message("You completed the game", (190,250), 65)\ .display_shadow() Message("In: {0} seconds".format(time_taken.seconds),\ (230,350), 95).display_shadow() pygame.display.flip() count += 1
def main(): pygame.init() pygame.display.set_caption("Balls and Lines") screen = pygame.display.set_mode((600, 600)) clock = pygame.time.Clock() running = True ### Physics stuff space = pymunk.Space() space.gravity = 0.0, -900.0 ## Balls balls = [] ### Mouse mouse_body = pymunk.Body(body_type=pymunk.Body.KINEMATIC) mouse_shape = pymunk.Circle(mouse_body, 3, (0, 0)) mouse_shape.collision_type = COLLTYPE_MOUSE space.add(mouse_shape) ch = space.add_collision_handler(COLLTYPE_MOUSE, COLLTYPE_BALL) ch.data["surface"] = screen ch.pre_solve = mouse_coll_func ch.post_solve = draw_collision ### Static line line_point1 = None static_lines = [] run_physics = True isElastic = False while running: for event in pygame.event.get(): if event.type == QUIT: running = False pygame.quit() elif event.type == KEYDOWN and event.key == K_ESCAPE: running = False elif event.type == KEYDOWN and event.key == K_p: pygame.image.save(screen, "balls_and_lines.png") elif event.type == KEYDOWN and event.key == K_e: isElastic = not isElastic elif event.type == MOUSEBUTTONDOWN and event.button == 1: p = event.pos[X], flipy(event.pos[Y]) body = pymunk.Body(10, 100) body.position = p shape = pymunk.Circle(body, 10, (0, 0)) shape.elasticity = 0.85 if isElastic else 0.0 shape.friction = 0.5 shape.collision_type = COLLTYPE_BALL space.add(body, shape) balls.append(shape) elif event.type == MOUSEBUTTONDOWN and event.button == 3: if line_point1 is None: line_point1 = Vec2d(event.pos[X], flipy(event.pos[Y])) elif event.type == MOUSEBUTTONUP and event.button == 3: if line_point1 is not None: line_point2 = Vec2d(event.pos[X], flipy(event.pos[Y])) body = pymunk.Body(body_type=pymunk.Body.STATIC) shape = pymunk.Segment(body, line_point1, line_point2, 0.0) shape.friction = 0.99 space.add(shape) static_lines.append(shape) line_point1 = None elif event.type == KEYDOWN and event.key == K_SPACE: run_physics = not run_physics p = pygame.mouse.get_pos() mouse_pos = Vec2d(p[X], flipy(p[Y])) mouse_body.position = mouse_pos if pygame.key.get_mods() & KMOD_SHIFT and pygame.mouse.get_pressed( )[0]: body = pymunk.Body(10, 10) body.position = mouse_pos shape = pymunk.Circle(body, 10, (0, 0)) shape.collision_type = COLLTYPE_BALL space.add(body, shape) balls.append(shape) ### Update physics if run_physics: dt = 1.0 / 60.0 for x in range(1): space.step(dt) ### Draw stuff screen.fill(THECOLORS["white"]) # Display some text font = pygame.font.SysFont("Helvetica", 16) text = """LMB: Create ball LMB + Shift: Create many balls RMB: Drag to create wall, release to finish B: Toggle Elasticity Space: Pause physics simulation""" y = 5 for line in text.splitlines(): text = font.render(line, 1, THECOLORS["black"]) screen.blit(text, (5, y)) y += 15 for ball in balls: r = ball.radius v = ball.body.position rot = ball.body.rotation_vector p = int(v.x), int(flipy(v.y)) p2 = Vec2d(rot.x, -rot.y) * r * 0.9 pygame.draw.circle(screen, THECOLORS["blue"], p, int(r), 2) pygame.draw.line(screen, THECOLORS["red"], p, p + p2) if line_point1 is not None: p1 = line_point1.x, flipy(line_point1.y) p2 = mouse_pos.x, flipy(mouse_pos.y) pygame.draw.lines(screen, THECOLORS["black"], False, [p1, p2]) for line in static_lines: body = line.body line.elasticity = 0.95 pv1 = body.position + line.a.rotated(body.angle) pv2 = body.position + line.b.rotated(body.angle) p1 = pv1.x, flipy(pv1.y) p2 = pv2.x, flipy(pv2.y) pygame.draw.lines(screen, THECOLORS["black"], False, [p1, p2]) ### Flip screen pygame.display.flip() clock.tick(50)
def _initialize_space(self): space = pymunk.Space() space.gravity = (0.0, -900) return space
def main(win, width, height): pygame.init() space = pm.Space() space.gravity = (0.0, 0.0) clock = pygame.time.Clock() fps = 120 ROWS = 100 grid = make_grid(ROWS, width) start = None end = None run = True while run: draw(win, grid, ROWS, width, height) for event in pygame.event.get(): if event.type == pygame.QUIT: run = False if pygame.mouse.get_pressed()[0]: # LEFT pos = pygame.mouse.get_pos() row, col = get_clicked_pos(pos, ROWS, width) spot = grid[row][col] if not start and spot != end: start = spot start.make_start() elif not end and spot != start: end = spot end.make_end() elif spot != end and spot != start: spot.make_barrier() elif pygame.mouse.get_pressed()[2]: # RIGHT pos = pygame.mouse.get_pos() row, col = get_clicked_pos(pos, ROWS, width) spot = grid[row][col] spot.reset() if spot == start: start = None elif spot == end: end = None if event.type == pygame.KEYDOWN: if event.key == pygame.K_SPACE and start and end: for row in grid: for spot in row: spot.update_neighbors(grid) algorithm(lambda: draw(win, grid, ROWS, width, height), grid, start, end) if event.key == pygame.K_c: start = None end = None grid = make_grid(ROWS, width) space.step(1. / fps) clock.tick(fps) pygame.display.set_caption("fps: " + str(clock.get_fps())) pygame.quit()
def main(): if viz: pygame.init() screen = pygame.display.set_mode((1000, 1000)) pygame.display.set_caption("Ball moving") clock = pygame.time.Clock() print(clock) draw_options = pymunk.pygame_util.DrawOptions(screen) space = pymunk.Space() space.gravity = (0.0, 0.0) objects = [] # ticks_to_next_ball = 10 if simtype == 'inertial': x_pos = random.randint(200, 800) y_pos = random.randint(200, 800) x_vel = random.randint(-500, 500) y_vel = random.randint(-500, 500) shape = add_ball(space, 1, 20, (x_pos, y_pos), (x_vel, y_vel), 0) objects.append(shape) elif simtype == 'circular': rotation_center_body = pymunk.Body(body_type=pymunk.Body.STATIC) joint_x = random.randint(300, 700) joint_y = random.randint(300, 700) rotation_center_body.position = (joint_x, joint_y) x_pos = random.randint(200, 800) y_pos = random.randint(200, 800) vel = random.randint(200, 1200) string = (joint_x - x_pos, joint_y - y_pos) mag = math.sqrt(string[0]**2 + string[1]**2) velocity = (string[1] / mag * vel, string[0] / mag * vel) shape = add_ball(space, 1, 20, (x_pos, y_pos), velocity, 0) rotation_center_joint = pymunk.PinJoint(shape.body, rotation_center_body, (0, 0), (0, 0)) space.add(rotation_center_joint) objects.append(shape) elif simtype == 'harmonic': harmonic_center_body = pymunk.Body(body_type=pymunk.Body.STATIC) joint_x = random.randint(300, 700) joint_y = random.randint(300, 700) harmonic_center_body.position = (joint_x, joint_y) x_pos = random.randint(300, 700) y_pos = random.randint(300, 700) vel = random.randint(2, 20) string = (joint_x - x_pos, joint_y - y_pos) mag = math.sqrt(string[0]**2 + string[1]**2) velocity = (string[1] / mag * vel, string[0] / mag * vel) shape = add_ball(space, 1, 20, (x_pos, y_pos), velocity, 0) stiffness = random.randint(10, 120) harmonic_center_joint = pymunk.DampedSpring(shape.body, harmonic_center_body, (0, 0), (0, 0), 0, stiffness, 0) space.add(harmonic_center_joint) objects.append(shape) else: sys.exit("ERROR: non-valid simulation type") locations = [] timestep = 0 while True: if not viz and timestep >= 100: break timestep += 1 if viz: screen.fill((255, 255, 255)) for event in pygame.event.get(): if event.type == QUIT: sys.exit(0) elif event.type == KEYDOWN and event.key == K_ESCAPE: sys.exit(0) space.step(1 / 50.0) locations.append([obj.copy() for obj in objects]) # objects_to_remove = [] # for obj in objects: # print (obj) # if obj.body.position.y > 150: # objects_to_remove.append(obj) # for obj in objects_to_remove: # space.remove(obj, obj.body) # objects.remove(obj) if viz: space.debug_draw(draw_options) pygame.display.flip() clock.tick(50) with open(os.path.join(data_folder, simtype + '_' + str(now) + '.pkl'), 'wb') as f: pickle.dump(locations, f)
def __init__(self, display_hidden=False): # Load sprite sprite = pygame.image.load("../ar19_q.png") self.sprite_img = pygame.transform.scale(sprite, (50, 50)) self.sprites = [] # Hide display self.show_sensors = not display_hidden self.draw_screen = not display_hidden # Physics stuff. self.space = pymunk.Space() self.space.gravity = pymunk.Vec2d(0., 0.) # Create the car. self.create_car(150, coordfix(600), 1.57) # This is all a mess of markers o1 = self.create_marker(100, coordfix(500), 10, THECOLORS["blue"]) o2 = self.create_marker(200, coordfix(200), 10, THECOLORS["blue"]) o3 = self.create_marker(400, coordfix(100), 10, THECOLORS["blue"]) o4 = self.create_marker(600, coordfix(200), 10, THECOLORS["blue"]) o5 = self.create_marker(700, coordfix(500), 10, THECOLORS["blue"]) o6 = self.create_marker(950, coordfix(500), 10, THECOLORS["blue"]) o7 = self.create_marker(1000, coordfix(200), 10, THECOLORS["blue"]) o8 = self.create_marker(1400, coordfix(100), 10, THECOLORS["blue"]) o9 = self.create_marker(1800, coordfix(200), 10, THECOLORS["blue"]) o10 = self.create_marker(1800, coordfix(900), 10, THECOLORS["blue"]) o11 = self.create_marker(1650, coordfix(1000), 10, THECOLORS["blue"]) o12 = self.create_marker(1500, coordfix(900), 10, THECOLORS["blue"]) o13 = self.create_marker(1500, coordfix(500), 10, THECOLORS["blue"]) o14 = self.create_marker(1400, coordfix(400), 10, THECOLORS["blue"]) o15 = self.create_marker(1300, coordfix(500), 10, THECOLORS["blue"]) o16 = self.create_marker(1300, coordfix(700), 10, THECOLORS["blue"]) o17 = self.create_marker(1100, coordfix(800), 10, THECOLORS["blue"]) o18 = self.create_marker(825, coordfix(850), 10, THECOLORS["blue"]) o19 = self.create_marker(500, coordfix(850), 10, THECOLORS["blue"]) o20 = self.create_marker(100, coordfix(900), 10, THECOLORS["blue"]) i1 = self.create_marker(500, coordfix(700), 10, THECOLORS["yellow"]) i2 = self.create_marker(250, coordfix(700), 10, THECOLORS["yellow"]) i3 = self.create_marker(250, coordfix(500), 10, THECOLORS["yellow"]) i4 = self.create_marker(300, coordfix(300), 10, THECOLORS["yellow"]) i5 = self.create_marker(400, coordfix(250), 10, THECOLORS["yellow"]) i6 = self.create_marker(500, coordfix(300), 10, THECOLORS["yellow"]) i7 = self.create_marker(550, coordfix(600), 10, THECOLORS["yellow"]) i8 = self.create_marker(825, coordfix(700), 10, THECOLORS["yellow"]) i9 = self.create_marker(1150, coordfix(600), 10, THECOLORS["yellow"]) i10 = self.create_marker(1150, coordfix(300), 10, THECOLORS["yellow"]) i11 = self.create_marker(1400, coordfix(250), 10, THECOLORS["yellow"]) i12 = self.create_marker(1650, coordfix(300), 10, THECOLORS["yellow"]) i13 = self.create_marker(1650, coordfix(800), 10, THECOLORS["yellow"]) # Create lines self.static = [ # Walls pymunk.Segment(self.space.static_body, (0, 1), (0, height), 1), pymunk.Segment(self.space.static_body, (1, height), (width, height), 1), pymunk.Segment(self.space.static_body, (width - 1, height), (width - 1, 1), 1), pymunk.Segment(self.space.static_body, (1, 1), (width, 1), 1), # Outer boundary pymunk.Segment(self.space.static_body, (o1.position), (o2.position), 2), pymunk.Segment(self.space.static_body, (o2.position), (o3.position), 2), pymunk.Segment(self.space.static_body, (o3.position), (o4.position), 2), pymunk.Segment(self.space.static_body, (o4.position), (o5.position), 2), pymunk.Segment(self.space.static_body, (o5.position), (o6.position), 2), pymunk.Segment(self.space.static_body, (o6.position), (o7.position), 2), pymunk.Segment(self.space.static_body, (o7.position), (o8.position), 2), pymunk.Segment(self.space.static_body, (o8.position), (o9.position), 2), pymunk.Segment(self.space.static_body, (o9.position), (o10.position), 2), pymunk.Segment(self.space.static_body, (o10.position), (o11.position), 2), pymunk.Segment(self.space.static_body, (o11.position), (o12.position), 2), pymunk.Segment(self.space.static_body, (o12.position), (o13.position), 2), pymunk.Segment(self.space.static_body, (o13.position), (o14.position), 2), pymunk.Segment(self.space.static_body, (o14.position), (o15.position), 2), pymunk.Segment(self.space.static_body, (o15.position), (o16.position), 2), pymunk.Segment(self.space.static_body, (o16.position), (o17.position), 2), pymunk.Segment(self.space.static_body, (o17.position), (o18.position), 2), pymunk.Segment(self.space.static_body, (o18.position), (o19.position), 2), pymunk.Segment(self.space.static_body, (o19.position), (o20.position), 2), pymunk.Segment(self.space.static_body, (o20.position), (o1.position), 2), # Inner boundary pymunk.Segment(self.space.static_body, (i1.position), (i2.position), 2), pymunk.Segment(self.space.static_body, (i2.position), (i3.position), 2), pymunk.Segment(self.space.static_body, (i3.position), (i4.position), 2), pymunk.Segment(self.space.static_body, (i4.position), (i5.position), 2), pymunk.Segment(self.space.static_body, (i5.position), (i6.position), 2), pymunk.Segment(self.space.static_body, (i6.position), (i7.position), 2), pymunk.Segment(self.space.static_body, (i7.position), (i8.position), 2), pymunk.Segment(self.space.static_body, (i8.position), (i9.position), 2), pymunk.Segment(self.space.static_body, (i9.position), (i10.position), 2), pymunk.Segment(self.space.static_body, (i10.position), (i11.position), 2), pymunk.Segment(self.space.static_body, (i11.position), (i12.position), 2), pymunk.Segment(self.space.static_body, (i12.position), (i13.position), 2), pymunk.Segment(self.space.static_body, (i1.position), (i8.position), 2), ] for s in self.static: #s.sensor = 1 s.friction = 1 s.collision_type = 1 s.color = THECOLORS['red'] self.space.add(self.static) # Create checkpoints for scoring self.checkpoint = [ pymunk.Segment(self.space.static_body, (o1.position), (i3.position), 5), pymunk.Segment(self.space.static_body, (o2.position), (i4.position), 5), pymunk.Segment(self.space.static_body, (o3.position), (i5.position), 5), pymunk.Segment(self.space.static_body, (o4.position), (i6.position), 5), pymunk.Segment(self.space.static_body, (o5.position), (i7.position), 5), pymunk.Segment(self.space.static_body, (o6.position), (i9.position), 5), pymunk.Segment(self.space.static_body, (o7.position), (i10.position), 5), pymunk.Segment(self.space.static_body, (o8.position), (i11.position), 5), pymunk.Segment(self.space.static_body, (o9.position), (i12.position), 5), pymunk.Segment(self.space.static_body, (o10.position), (i13.position), 5), pymunk.Segment(self.space.static_body, (o11.position), (i13.position), 5), pymunk.Segment(self.space.static_body, (o12.position), (i13.position), 5), pymunk.Segment(self.space.static_body, (o13.position), (i12.position), 5), pymunk.Segment(self.space.static_body, (o14.position), (i11.position), 5), pymunk.Segment(self.space.static_body, (o15.position), (i10.position), 5), pymunk.Segment(self.space.static_body, (o16.position), (i9.position), 5), pymunk.Segment(self.space.static_body, (o18.position), (i8.position), 5), pymunk.Segment(self.space.static_body, (o19.position), (i1.position), 5), pymunk.Segment(self.space.static_body, (o20.position), (i2.position), 5), ] for c in self.checkpoint: c.sensor = 1 c.collision_type = 4 c.color = THECOLORS['green'] self.space.add(self.checkpoint[0]) self.score = 0 self.counter = 0 def checkpoint_hit(space, arbiter, data): # Do this if called by collision handler if self.counter < 18: # If less than 18, remove current and place next checkpoint self.space.remove(self.checkpoint[self.counter]) self.score += 1 self.counter += 1 self.space.add(self.checkpoint[self.counter]) else: # If less than 18, remove current and place next checkpoint self.space.remove(self.checkpoint[self.counter]) self.counter = 0 self.space.add(self.checkpoint[self.counter]) return True # Pymunk collision for car and checkpoints ht = self.space.add_collision_handler(2, 4) ht.pre_solve = checkpoint_hit
import pymunk from pymunk import Vec2d def to_pygame(p): """Small hack to convert pymunk to pygame coordinates""" return int(p.x), int(-p.y + 600) pygame.init() g_screen = pygame.display.set_mode((600, 600)) clock = pygame.time.Clock() running = True ### Physics stuff space = pymunk.Space(50) space.gravity = (0.0, -900.0) ## Balls balls = [] ### walls static_body = pymunk.Body() static_lines = [ pymunk.Segment(static_body, (150, 100.0), (50.0, 550.0), 1.0), pymunk.Segment(static_body, (450.0, 100.0), (550.0, 550.0), 1.0), pymunk.Segment(static_body, (50.0, 550.0), (300.0, 600.0), 1.0), pymunk.Segment(static_body, (300.0, 600.0), (550.0, 550.0), 1.0), pymunk.Segment(static_body, (300.0, 420.0), (400.0, 400.0), 1.0) ] for line in static_lines:
def main(): pygame.init() screen = pygame.display.set_mode(display_size, display_flags) width, height = screen.get_size() def to_pygame(p): """Small hack to convert pymunk to pygame coordinates""" return int(p.x), int(-p.y + height) def from_pygame(p): return to_pygame(p) clock = pygame.time.Clock() running = True font = pygame.font.Font(None, 16) ### Physics stuff space = pm.Space() space.gravity = (0.0, -1900.0) space.damping = 0.999 # to prevent it from blowing up. mouse_body = pm.Body(body_type=pm.Body.KINEMATIC) bodies = [] for x in range(-100, 150, 50): x += width / 2 offset_y = height / 2 mass = 10 radius = 25 moment = pm.moment_for_circle(mass, 0, radius, (0, 0)) body = pm.Body(mass, moment) body.position = (x, -125 + offset_y) body.start_position = Vec2d(body.position) shape = pm.Circle(body, radius) shape.elasticity = 0.9999999 space.add(body, shape) bodies.append(body) pj = pm.PinJoint(space.static_body, body, (x, 125 + offset_y), (0, 0)) space.add(pj) reset_bodies(space) selected = None if not is_interactive: pygame.time.set_timer(USEREVENT + 1, 70000) # apply force pygame.time.set_timer(USEREVENT + 2, 120000) # reset pygame.event.post(pygame.event.Event(USEREVENT + 1)) pygame.mouse.set_visible(False) while running: for event in pygame.event.get(): if event.type == QUIT: running = False elif event.type == KEYDOWN and event.key == K_p: pygame.image.save(screen, "newtons_cradle.png") if event.type == pygame.USEREVENT + 1: r = random.randint(1, 4) for body in bodies[0:r]: body.apply_impulse_at_local_point((-6000, 0)) if event.type == pygame.USEREVENT + 2: reset_bodies(space) elif event.type == KEYDOWN and event.key == K_r and is_interactive: reset_bodies(space) elif event.type == KEYDOWN and event.key == K_f and is_interactive: r = random.randint(1, 4) for body in bodies[0:r]: body.apply_impulse_at_local_point((-6000, 0)) elif event.type == MOUSEBUTTONDOWN and is_interactive: if selected != None: space.remove(selected) p = from_pygame(Vec2d(event.pos)) hit = space.point_query_nearest(p, 0, pm.ShapeFilter()) if hit != None: shape = hit.shape rest_length = mouse_body.position.get_distance( shape.body.position) ds = pm.DampedSpring(mouse_body, shape.body, (0, 0), (0, 0), rest_length, 1000, 10) space.add(ds) selected = ds elif event.type == MOUSEBUTTONUP and is_interactive: if selected != None: space.remove(selected) selected = None elif event.type == KEYDOWN: running = False elif event.type == MOUSEBUTTONDOWN: running = False mpos = pygame.mouse.get_pos() p = from_pygame(Vec2d(mpos)) mouse_body.position = p ### Clear screen screen.fill(THECOLORS["black"]) ### Draw stuff for c in space.constraints: pv1 = c.a.position + c.anchor_a pv2 = c.b.position + c.anchor_b p1 = to_pygame(pv1) p2 = to_pygame(pv2) pygame.draw.aalines(screen, THECOLORS["lightgray"], False, [p1, p2]) for ball in space.shapes: p = to_pygame(ball.body.position) drawcircle(screen, ball.color, p, int(ball.radius), 0) #pygame.draw.circle(screen, ball.color, p, int(ball.radius), 0) ### Update physics fps = 50 iterations = 25 dt = 1.0 / float(fps) / float(iterations) for x in range( iterations): # 10 iterations to get a more stable simulation space.step(dt) ### Flip screen if is_interactive: screen.blit( font.render("fps: " + str(clock.get_fps()), 1, THECOLORS["white"]), (0, 0)) screen.blit( font.render("Press left mouse button and drag to interact", 1, THECOLORS["darkgrey"]), (5, height - 35)) screen.blit( font.render("Press R to reset, any other key to quit", 1, THECOLORS["darkgrey"]), (5, height - 20)) pygame.display.flip() clock.tick(fps)
def __init__(self, window, level): super(Pymunk_Scene, self).__init__(window, level) self.screen_resolution = window.width, window.height self.window = window self.debug_batch = pyglet.graphics.Batch() self.normal_batch = pyglet.graphics.Batch() self.ui_batch = pyglet.graphics.Batch() # The common_group parent keeps groups from # overlapping on accident. Silly Pyglet! common_group = pyglet.graphics.OrderedGroup(1) self.ordered_group10 = pyglet.graphics.OrderedGroup( 10, parent=common_group) self.ordered_group9 = pyglet.graphics.OrderedGroup(9, parent=common_group) self.ordered_group8 = pyglet.graphics.OrderedGroup(8, parent=common_group) self.ordered_group7 = pyglet.graphics.OrderedGroup(7, parent=common_group) self.ordered_group6 = pyglet.graphics.OrderedGroup(6, parent=common_group) self.ordered_group5 = pyglet.graphics.OrderedGroup(5, parent=common_group) self.ordered_group4 = pyglet.graphics.OrderedGroup(4, parent=common_group) self.ordered_group3 = pyglet.graphics.OrderedGroup(3, parent=common_group) self.ordered_group2 = pyglet.graphics.OrderedGroup(2, parent=common_group) self.ordered_group1 = pyglet.graphics.OrderedGroup(1, parent=common_group) self.grav = (0, -600) self.space = pymunk.Space() self.space.sleep_time_threshold = 1 self.space.gravity = self.grav glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) glHint(GL_POINT_SMOOTH_HINT, GL_FASTEST) glPointSize(2) glLineWidth(1) #(1.25) self.camera = camera.Camera(self.screen_resolution, pos_rate=(1, 1, 1), target_rate=(1, 1, 1), angle_rate=5, fov_rate=1) #### Level #### self.level = level self.level.define_level(self) #### Level #### self.pymunk_util = pyglet_util.PymunkUtil2(self) self.pymunk_util.setup() self.keys_held = [] self.debug = True
def main(): # PyGame init pygame.init() started = False global numLives numLives = 2 gameOver = False screen = pygame.display.set_mode((width, height), RESIZABLE) clock = pygame.time.Clock() running = True # Display some text font = pygame.font.SysFont("Arial", 30) text = "" score = 0 # Physics stuff space = pymunk.Space() space.gravity = (0, -600) space.damping = 0.9 intro = pygame.Surface((680, 910)) intro.fill(transport_color) spring = add_spring(space) block_up = False global block block = spawn_block(space) rotary_spring, rotary_spring2 = add_paddles(space) image = pygame.image.load("background.jpg") # Start game global ballsinplay ballsinplay += 1 setup_level(space) global temp_ballbody temp_ballbody = spawn_ball(space, (600, 300), (0, 0)) while running: global score global gameOver check_powerup(space) check_block(temp_ballbody) for event in pygame.event.get(): if event.type == QUIT: running = False elif event.type == KEYDOWN and (event.key in [K_ESCAPE, K_q]): running = False elif event.type == KEYDOWN and event.key == K_SPACE: block_up = False spring.rest_length = 10 elif event.type == KEYUP and event.key == K_SPACE: spring.rest_length = 150 block_up = True if event.type == KEYDOWN and event.key == K_LEFT: rotary_spring.rest_angle = math.pi / 5 if event.type == KEYUP and event.key == K_LEFT: rotary_spring.rest_angle = 3 * math.pi / 5 if event.type == KEYDOWN and event.key == K_RIGHT: rotary_spring2.rest_angle = -6 * math.pi / 5 if event.type == KEYUP and event.key == K_RIGHT: rotary_spring2.rest_angle = -8 * math.pi / 5 if event.type == MOUSEBUTTONDOWN: started = True if gameOver: gameOver = False numLives = 2 space.add(lives[0]) space.add(lives[1]) space.add(lives[2]) score = 0 if numLives <= -1: gameOver = True # Clear screen screen.fill(screen_color) # Draw stuff # Update physics fps = 60 step = 1. / fps for x in range(5): space.step(step / 5) # Info and flip screen screen.blit(image, (0, 0)) largeText = pygame.font.Font('freesansbold.ttf', 205) screen.blit( font.render("fps: " + str(clock.get_fps()), 1, THECOLORS["white"]), (0, height - 25)) screen.blit(font.render("Score: " + str(score), 1, THECOLORS["white"]), (0, 0)) draw(space) if not started: screen.blit(intro, (0, 0)) screen.blit(font.render("Pinball ", 1, THECOLORS["white"]), (300, 455)) if gameOver: screen.blit(intro, (0, 0)) screen.blit(font.render("Game Over", 1, THECOLORS["white"]), (300, 455)) screen.blit( font.render("Score: " + str(score), 1, THECOLORS["white"]), (300, 490)) pygame.display.flip() clock.tick(fps)
def __init__(self, *args, **kwargs): self.space = pm.Space() super(SpaceWorld, self).__init__(*args, **kwargs)
def main(): global amountofballs global mass global radius global bodyheight global bodyradius amountofballs = 100 bodyradius = 50 bodyheight = 150 mass = 50 radius = 10 pygame.init() screen = pygame.display.set_mode((600, 600)) pygame.display.set_caption("Hourglass Simulation") clock = pygame.time.Clock() space = pymunk.Space() space.gravity = (0.0, -900.0) draw_options = pymunk.pygame_util.DrawOptions(screen) hg = add_hourglass(space) space.debug_draw(draw_options) balls = [] ballsxposition = [] ballsxposition.append(amountofballs * 325) ballstimeposition = [] ballstimeposition.append(0.0) temp = 0 balltimecount = 0 firsttime = 0 sleeptime = 5 for i in range(amountofballs): ball_shape = add_ball(space) balls.append(ball_shape) space.debug_draw(draw_options) while True: for event in pygame.event.get(): if event.type == QUIT: printballdata(ballsxposition, ballstimeposition) pygame.display.quit() pygame.quit() elif event.type == KEYDOWN: if event.key == K_ESCAPE: printballdata(ballsxposition, ballstimeposition) pygame.display.quit() pygame.quit() sleeptime -= 1 # body.position.x and .y give different results if sleeptime <= 0: for i in range(amountofballs): for j in range(amountofballs): temp += balls[j].body.position.x if firsttime == 0 or ballstimeposition[ balltimecount] != pygame.time.get_ticks(): ballsxposition.append(temp) ballstimeposition.append(pygame.time.get_ticks()) balltimecount += 1 firsttime += 1 temp = 0 sleeptime = 10 space.step(1 / 80) screen.fill((255, 255, 255)) space.debug_draw(draw_options) pygame.display.flip() clock.tick(25)
def do_init(self, 寬=common.WIN_WIDTH, 高=common.WIN_HEIGHT, title=common.TITLE): common.stage = self common.舞台 = self common.is_engine_created = True __main__.stage = self __main__.舞台 = self __main__.key = arcade.key self.pause_simulate = False self.slow_simulate = False if common.WIN_MIN_WIDTH < 寬 < common.WIN_MAX_WIDTH: self.win_width = round(寬, 0) elif 寬 < common.WIN_MIN_WIDTH: self.win_width = common.WIN_MIN_WIDTH elif 寬 > common.WIN_MAX_WIDTH: self.win_width = common.WIN_MAX_WIDTH if common.WIN_MIN_HEIGHT < 高 < common.WIN_MAX_HEIGHT: self.win_height = round(高, 0) elif 高 < common.WIN_MIN_HEIGHT: self.win_height = common.WIN_MIN_HEIGHT elif 高 > common.WIN_MAX_HEIGHT: self.win_height = common.WIN_MAX_HEIGHT #self.win_width = round(寬,0) if 寬 > common.MIN_WIDTH else common.MIN_WIDTH #self.win_height = round(高,0) if 高 > common.MIN_HEIGHT else common.MIN_HEIGHT #print('stage size: ', self.win_width, self.win_height) #__main__.中央座標 = (self.win_width, self.win_height//2) self.title = title self.set_update_rate(common.DT_UPDATE) self.circle_list = [] self.poly_list = [] self.segment_list = [] self.is_engine_running = False # status line self.font = ('C:/Windows/Fonts/msjh.ttc', 'arial') if hasattr(__main__, '__file__'): self.terrain_filename = __main__.__file__ + '.地形' else: # in shell , do not save terrain self.terrain_filename = None # retain mouse postion while mouse motion event self.mouse_x = 0 self.mouse_y = 0 # pymunk space self.space = pymunk.Space() self.space.gravity = common.GRAVITY self.sleep_time_threshold = 1 self.obj_filter = pymunk.ShapeFilter(mask=common.CATE_CIRCLE | common.CATE_BOX) # info # self.info = {} # self.info['gravity_x'] = 0 # self.info['gravity_y'] = 0 # self.info['mouse_x'] = 0 # self.info['mouse_y'] = 0 # self.info['obj_num'] = 0 # self.info_text = '' #self.info_update() # infomation update (can't to fast because text create burden) #arcade.schedule(self.info_update, 0.4) # assist self.dot_mark = DotMark() self.seg_add_assist = SegmentAddAssist() self.seg_remove_assist = SegmentRemoveAssist() self.arrow_assist = ArrowAssist() self.coor_assist = CoordinateAssist() hole_handler = self.space.add_collision_handler( COLLITYPE_DEFAULT, COLLITYPE_HOLE) hole_handler.begin = self.hole_begin_callback hole_handler.pre_solve = self.hole_pre_solve_callback hole_handler.post_solve = self.hole_post_solve_callback hole_handler.separate = self.hole_separate_callback # custom event handler self.user_mouse_press_handler = None self.user_mouse_release_handler = None self.user_key_press_handler = None self.user_key_release_handler = None self.user_arrow_launch_handler = None self.user_mouse_drag_handler = None self.user_object_click_handler = None # self.user_mouse_press_handler = lambda x, y : None # self.user_mouse_release_handler = lambda x, y: None # self.user_key_press_handler = lambda key: None # self.user_key_release_handler = lambda key: None # self.user_arrow_launch_handler = lambda vector,start_pos : None print(f"建立舞台(寬{self.win_width}x高{self.win_height})") if not self.terrain_filename or not self.load_terrain(): #default terrain self.新增線段((50, 50), (self.win_width - 50, 50), 6) print('使用預設地形')
def __init__( self, ind_reward=0.8, group_reward=0.1, other_group_reward=0.1, prospec_find_gold_reward=1, prospec_handoff_gold_reward=1, banker_receive_gold_reward=1, banker_deposit_gold_reward=1, max_frames=900, ): EzPickle.__init__(self, ind_reward, group_reward, other_group_reward, prospec_find_gold_reward, prospec_handoff_gold_reward, banker_receive_gold_reward, banker_deposit_gold_reward, max_frames) if ind_reward + group_reward + other_group_reward != 1.0: raise ValueError( "Individual reward, group reward, and other group reward should " "add up to 1.0") self.num_agents = const.NUM_AGENTS self.agents = [] self.sprite_list = [ "bankers/0.png", "bankers/1.png", "bankers/2.png", "prospector.png", ] self.max_frames = max_frames pg.init() self.seed() self.clock = pg.time.Clock() self.closed = False self.background = Background(self.rng) self.space = pm.Space() self.space.gravity = Vec2d(0.0, 0.0) self.space.damping = 0.0 self.all_sprites = pg.sprite.RenderUpdates() self.gold = [] self.water = Water(const.WATER_INFO[0], const.WATER_INFO[1], self.space, self.rng) # Generate random positions for each prospector agent prospector_info = [(i, utils.rand_pos("prospector", self.rng)) for i in range(const.NUM_PROSPECTORS)] self.prospectors = {} for num, pos in prospector_info: prospector = Prospector(pos, self.space, num, self.all_sprites) identifier = f"prospector_{num}" self.prospectors[identifier] = prospector self.agents.append(identifier) banker_info = [(i, utils.rand_pos("banker", self.rng)) for i in range(const.NUM_BANKERS)] self.bankers = {} for num, pos in banker_info: banker = Banker(pos, self.space, num, self.all_sprites) identifier = f"banker_{num}" self.bankers[identifier] = banker self.agents.append(identifier) self.banks = [] for pos, verts in const.BANK_INFO: self.banks.append(Bank(pos, verts, self.space, self.all_sprites)) self.fences = [] for w_type, s_pos, b_pos, verts in const.FENCE_INFO: f = Fence(w_type, s_pos, b_pos, verts, self.space) self.fences.append(f) self.metadata = {"render.modes": ["human"]} self.action_spaces = {} for p in self.prospectors: self.action_spaces[p] = spaces.Box(low=np.float32(-1.0), high=np.float32(1.0), shape=(3, )) for b in self.bankers: self.action_spaces[b] = spaces.Box(low=np.float32(-1.0), high=np.float32(1.0), shape=(2, )) self.observation_spaces = {} self.last_observation = {} for p in self.prospectors: self.last_observation[p] = None self.observation_spaces[p] = spaces.Box( low=0, high=255, shape=const.PROSPEC_OBSERV_SHAPE, dtype=np.uint8) for b in self.bankers: self.last_observation[b] = None self.observation_spaces[b] = spaces.Box( low=0, high=255, shape=const.BANKER_OBSERV_SHAPE, dtype=np.uint8) self._agent_selector = agent_selector(self.agents) self.agent_selection = self._agent_selector.next() self.reset() # Collision Handler Functions -------------------------------------------- # Water to Prospector def add_gold(arbiter, space, data): prospec_shape = arbiter.shapes[0] prospec_body = prospec_shape.body position = arbiter.contact_point_set.points[0].point_a normal = arbiter.contact_point_set.normal prospec_body.position = position - (24 * normal) prospec_body.velocity = (0, 0) for k, v in self.prospectors.items(): if v.body is prospec_body: self.rewards[k] += ind_reward * prospec_find_gold_reward else: self.rewards[k] += group_reward * prospec_find_gold_reward for k in self.bankers: self.rewards[ k] += other_group_reward * prospec_find_gold_reward if prospec_body.nugget is None: position = arbiter.contact_point_set.points[0].point_a gold = Gold(position, prospec_body, self.space, self.all_sprites) self.gold.append(gold) prospec_body.nugget = gold return True # Prospector to banker def handoff_gold_handler(arbiter, space, data): banker_shape, gold_shape = arbiter.shapes[0], arbiter.shapes[1] gold_sprite = None for g in self.gold: if g.id == gold_shape.id: gold_sprite = g # gold_sprite is None if gold was handed off to the bank right before # calling this collision handler # This collision handler is only for prospector -> banker gold handoffs if (gold_sprite is None or gold_sprite.parent_body.sprite_type != "prospector"): return False banker_body = banker_shape.body prospec_body = gold_sprite.parent_body for k, v in self.prospectors.items(): self.rewards[ k] += other_group_reward * banker_receive_gold_reward if v.body is prospec_body: self.rewards[k] += prospec_handoff_gold_reward else: self.rewards[ k] += group_reward * prospec_handoff_gold_reward for k, v in self.bankers.items(): self.rewards[ k] += other_group_reward * prospec_handoff_gold_reward if v.body is banker_body: self.rewards[k] += banker_receive_gold_reward else: self.rewards[ k] += group_reward * banker_receive_gold_reward normal = arbiter.contact_point_set.normal # Correct the angle because banker's head is rotated pi/2 corrected = utils.normalize_angle(banker_body.angle + (math.pi / 2)) normalized_normal = utils.normalize_angle(normal.angle) if (corrected - const.BANKER_HANDOFF_TOLERANCE <= normalized_normal <= corrected + const.BANKER_HANDOFF_TOLERANCE): gold_sprite.parent_body.nugget = None gold_sprite.parent_body = banker_body banker_body.nugget = gold_sprite banker_body.nugget_offset = normal.angle return True # Banker to bank def gold_score_handler(arbiter, space, data): gold_shape, _ = arbiter.shapes[0], arbiter.shapes[1] for g in self.gold: if g.id == gold_shape.id: gold_class = g if gold_class.parent_body.sprite_type == "banker": self.space.remove(gold_shape, gold_shape.body) gold_class.parent_body.nugget = None banker_body = gold_class.parent_body for k, v in self.bankers.items(): if v.body is banker_body: self.rewards[k] += banker_deposit_gold_reward else: self.rewards[ k] += group_reward * banker_deposit_gold_reward for k in self.prospectors: self.rewards[ k] += other_group_reward * banker_deposit_gold_reward self.gold.remove(gold_class) self.all_sprites.remove(gold_class) return False # Prevent prospector motion lag from colliding with gold nugget def prospec_gold_handler(arbiter, space, data): return False def boundary_collision_handler(arbiter, space, data): ps = arbiter.contact_point_set arbiter.shapes[0].body.position += ps.normal * ( ps.points[0].distance + 1) # Create the collision event generators gold_dispenser = self.space.add_collision_handler( CollisionTypes.PROSPECTOR, CollisionTypes.WATER) gold_dispenser.begin = add_gold handoff_gold = self.space.add_collision_handler( CollisionTypes.BANKER, CollisionTypes.GOLD) handoff_gold.begin = handoff_gold_handler gold_score = self.space.add_collision_handler(CollisionTypes.GOLD, CollisionTypes.BANK) gold_score.begin = gold_score_handler prospec_gold_collision = self.space.add_collision_handler( CollisionTypes.PROSPECTOR, CollisionTypes.GOLD) prospec_gold_collision.begin = prospec_gold_handler pros_bound_coll = self.space.add_wildcard_collision_handler( CollisionTypes.PROSPECTOR) pros_bound_coll.post_solve = boundary_collision_handler bank_bound_coll = self.space.add_wildcard_collision_handler( CollisionTypes.BANKER) bank_bound_coll.post_solve = boundary_collision_handler
key.UP: 'p2Up', key.DOWN: 'p2Down', key.F: 'p3Left', key.H: 'p3Right', key.T: 'p3Up', key.G: 'p3Down', key.J: 'p4Left', key.L: 'p4Right', key.I: 'p4Up', key.K: 'p4Down' } } space = pm.Space() #space.gravity = Vec2d(0.0, -900.0) batch = pyglet.graphics.Batch() # Controls movement upForce = 10 upSpeed = 5 sideForce = 10 sideSpeed = 5 sideDirectionMult = 10 upDirectionMult = 10 wallImpactForce = 200 #4500 playerImpactForceMult = 300 playerCrownScale = 1.5
def main(): pygame.joystick.init() controller = pygame.joystick.Joystick(0) controller.init() global restart restart = True while restart: restart = False pygame.font.init() myfont = pygame.font.SysFont('Comic Sans MS', 30) textsurface = myfont.render('Some Text', False, (0, 0, 0)) pygame.init() screen = pygame.display.set_mode((1200, 680)) pygame.display.set_caption("Joints. Just wait and the L will tip over") clock = pygame.time.Clock() space = pymunk.Space() global is_end is_end = False def set_tru(a, b, c): global is_end is_end = True def set_tru2(a, b, c): global restart restart = True space.add_collision_handler(1, 2).begin = set_tru space.add_collision_handler(1, 9).begin = set_tru2 space.gravity = (0.0, -900.0) space.sleep_time_threshold = 1 balls = [] draw_options = pymunk.pygame_util.DrawOptions(screen) body = pymunk.Body(mass=0, moment=0, body_type=pymunk.Body.STATIC) shape = pymunk.Segment(body, (0, 0), (2000, 0), 5) body.position = (0, 0) shape6 = pymunk.Segment(body, (500, 200), (900, 200), 5) shape6.friction = 0.9 space.add(shape6) shape6 = pymunk.Segment(body, (500, 200), (500, 690), 5) shape6.friction = 0.9 space.add(shape6) shape6 = pymunk.Segment(body, (1100, 0), (1200, 100), 5) shape6.friction = 0.9 #space.add(shape6) shape6.color = (250, 0, 0) shape6.collision_type = 9 shape6 = pymunk.Segment(body, (0, 0), (0, 800), 5) shape6.friction = 0.9 space.add(shape6) shape6 = pymunk.Segment(body, (0, 0), (1200, 0), 5) shape6.friction = 0.9 space.add(shape6) shape6 = pymunk.Segment(body, (1200, 0), (1200, 800), 5) shape6.friction = 0.9 space.add(shape6) shape6 = pymunk.Segment(body, (0, 800), (1200, 800), 5) shape6.friction = 0.9 space.add(shape6) segments = [(-10 / 2, 100 / 2), (10 / 2, 100 / 2), (-100 / 2, 0 / 2), (100 / 2, 0 / 2)] body1 = pymunk.Body(mass=0, moment=0, body_type=pymunk.Body.DYNAMIC) shape1 = pymunk.Poly(body1, segments) shape1.density = 1 shape1.collision_type = 1 body2 = pymunk.Body(mass=0, moment=0, body_type=pymunk.Body.DYNAMIC) shape2 = pymunk.Poly(body2, segments) shape2.density = 1 #shape2.color = (255, 0, 0) shape2.collision_type = 1 shape1.friction = 1 shape2.friction = 1 shape.friction = 1 body1.position = (200, 150) body2.position = (200, 100) body2.angle = 3.1415926535897932 space.add(body1, shape1) space.add(body2, shape2) def add_circle(x, y): body3 = pymunk.Body(mass=1, moment=1, body_type=pymunk.Body.STATIC) body3.position = (x, y) crl = pymunk.Circle(body3, 80) crl.collision_type = 2 space.add(body3, crl) add_circle(800, 400) #cs = pymunk.constraint.SlideJoint(body1, body2, (-10,0), (10,0), 0, 100) #cs4 = pymunk.constraint.SlideJoint(body1, body2, (10,0), (-10,0), 0, 100) spring_f = 100000 * 2 * 2 * 2 * 2 * 2 spring_d = 10000 * 2 cs2 = pymunk.constraint.DampedSpring(body1, body2, (-50, 0), (50, 0), 30, spring_f, spring_d) cs3 = pymunk.constraint.DampedSpring(body1, body2, (50, 0), (-50, 0), 30, spring_f, spring_d) cs5 = pymunk.constraint.GrooveJoint(body1, body2, (10, 0), (10, -100), (-10, 0)) cs6 = pymunk.constraint.GrooveJoint(body1, body2, (-10, 0), (-10, -100), (10, 0)) #space.add(cs, cs2) space.add(cs2, cs3, cs5, cs6) space.add(body, shape) ticks_to_next_ball = 10 max_jump = 150 start_time = time.time() game_time = 180 while True: for event in pygame.event.get(): if event.type == pc.QUIT: sys.exit(0) elif event.type == pc.KEYDOWN and event.key == pc.K_ESCAPE: sys.exit(0) elif event.type == pc.KEYDOWN and event.key == 97: cs2.rest_length = 15 elif event.type == pc.KEYDOWN and event.key == 100: cs3.rest_length = 15 elif event.type == pc.KEYUP and event.key == 97: cs2.rest_length = 50 + 10 elif event.type == pc.KEYUP and event.key == 100: cs3.rest_length = 50 + 10 elif event.type == pc.KEYDOWN and event.key == 98: cs3.rest_length = 50 + 30 cs2.rest_length = 50 + 30 elif event.type == pc.KEYDOWN and event.key == 114: restart = True break elif event.type == 7 and event.axis == 5: #right jv = 1 - (event.value + 1) / 2 cs2.rest_length = 15 + jv * 65 elif event.type == 7 and event.axis == 2: #left jv = 1 - (event.value + 1) / 2 cs3.rest_length = 15 + jv * 65 else: pass #print(event.type) #print(event.value) if restart: break #if event.type == pc #print(pc.JOYAXISMOTION) #print(event) #print(event.type) #print(event.value) #print(event.axis) #5/3 space.step(1 / 50.0) #space.step(1/500.0) cur_max = max(body1.position[1], body2.position[1]) #if cur_max > max_jump: #print("NEW MAX JUMP:", cur_max) #max_jump = cur_max screen.fill((255, 255, 255)) space.debug_draw(draw_options) finished_time = time.time() time_left = game_time - (finished_time - start_time) textsurface = myfont.render(f"TIME: {time_left:.3f}", False, (0, 0, 0)) screen.blit(textsurface, (0, 0)) pygame.display.flip() clock.tick(50) if is_end: print("end") break #finished_time = time.time() print("FINISHED FOR:", (finished_time - start_time))
def main(): ### PyGame init pygame.init() screen = pygame.display.set_mode((width, height)) clock = pygame.time.Clock() running = True font = pygame.font.SysFont("Arial", 16) ### Physics stuff space = pymunk.Space() space.gravity = 0, -1000 # walls - the left-top-right walls static = [ pymunk.Segment(space.static_body, (50, 50), (50, 550), 5), pymunk.Segment(space.static_body, (50, 550), (650, 550), 5), pymunk.Segment(space.static_body, (650, 550), (650, 50), 5), pymunk.Segment(space.static_body, (50, 50), (650, 50), 5) ] b2 = pymunk.Body() static.append(pymunk.Circle(b2, 30)) b2.position = 300, 400 for s in static: s.friction = 1. s.group = 1 space.add(static) # "Cannon" that can fire arrows cannon_body = pymunk.Body(pymunk.inf, pymunk.inf) cannon_shape = pymunk.Circle(cannon_body, 25) cannon_shape.sensor = True cannon_body.position = 100, 100 space.add(cannon_shape) arrow_body, arrow_shape = create_arrow() space.add(arrow_shape) space.add_collision_handler(0, 1, post_solve=post_solve_arrow_hit) flying_arrows = [] while running: for event in pygame.event.get(): if event.type == QUIT or \ event.type == KEYDOWN and (event.key in [K_ESCAPE, K_q]): running = False elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1: start_time = pygame.time.get_ticks() elif event.type == KEYDOWN and event.key == K_p: pygame.image.save(screen, "arrows.png") elif event.type == pygame.MOUSEBUTTONUP and event.button == 1: end_time = pygame.time.get_ticks() diff = end_time - start_time power = max(min(diff, 1000), 10) * 1.5 impulse = power * Vec2d(1, 0) arrow_body.apply_impulse(impulse.rotated(arrow_body.angle)) space.add(arrow_body) flying_arrows.append(arrow_body) arrow_body, arrow_shape = create_arrow() space.add(arrow_shape) keys = pygame.key.get_pressed() speed = 2.5 if (keys[K_UP]): cannon_body.position += Vec2d(0, 1) * speed if (keys[K_DOWN]): cannon_body.position += Vec2d(0, -1) * speed if (keys[K_LEFT]): cannon_body.position += Vec2d(-1, 0) * speed if (keys[K_RIGHT]): cannon_body.position += Vec2d(1, 0) * speed mouse_position = from_pygame(Vec2d(pygame.mouse.get_pos()), screen) cannon_body.angle = (mouse_position - cannon_body.position).angle # move the unfired arrow together with the cannon arrow_body.position = cannon_body.position + Vec2d( cannon_shape.radius + 40, 0).rotated(cannon_body.angle) arrow_body.angle = cannon_body.angle for flying_arrow in flying_arrows: drag_constant = 0.0002 pointing_direction = Vec2d(1, 0).rotated(flying_arrow.angle) flight_direction = Vec2d(flying_arrow.velocity) flight_speed = flight_direction.normalize_return_length() dot = flight_direction.dot(pointing_direction) # (1-abs(dot)) can be replaced with (1-dot) to make arrows turn around even when fired straight up. # Might not be as accurate, but maybe look better. drag_force_magnitude = ( 1 - abs(dot)) * flight_speed**2 * drag_constant * flying_arrow.mass arrow_tail_position = Vec2d(-50, 0).rotated(flying_arrow.angle) flying_arrow.apply_impulse( drag_force_magnitude * -flight_direction, arrow_tail_position) flying_arrow.angular_velocity *= 0.9 ### Clear screen screen.fill(pygame.color.THECOLORS["black"]) ### Draw stuff draw(screen, space) # Power meter if pygame.mouse.get_pressed()[0]: current_time = pygame.time.get_ticks() diff = current_time - start_time power = max(min(diff, 1000), 10) h = power / 2 pygame.draw.line(screen, pygame.color.THECOLORS["red"], (30, 550), (30, 550 - h), 10) # Info and flip screen screen.blit( font.render("fps: " + str(clock.get_fps()), 1, THECOLORS["white"]), (0, 0)) screen.blit( font.render("Aim with mouse, hold LMB to powerup, release to fire", 1, THECOLORS["darkgrey"]), (5, height - 35)) screen.blit( font.render("Press R to reset, ESC or Q to quit", 1, THECOLORS["darkgrey"]), (5, height - 20)) pygame.display.flip() ### Update physics fps = 60 dt = 1. / fps space.step(dt) clock.tick(fps)
def run_world(): pygame.init() screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT)) pygame.display.set_caption("Crude Oil Pretreatment Unit") clock = pygame.time.Clock() running = True # Create game space (world) and set gravity to normal space = pymunk.Space() #2 space.gravity = (0.0, -900.0) # When oil collides with tank_level, call level_reached space.add_collision_handler(tank_level_collision, ball_collision, begin=level_reached) # When oil touches the oil_spill marker, call oil_spilled space.add_collision_handler(oil_spill_collision, ball_collision, begin=oil_spilled) # When oil touches the oil_process marker, call oil_processed space.add_collision_handler(oil_processed_collision, ball_collision, begin=oil_processed) # Initial outlet valve condition is turned off space.add_collision_handler(outlet_valve_collision, ball_collision, begin=no_collision) # Initial sep valve condition is turned off space.add_collision_handler(sep_valve_collision, ball_collision, begin=no_collision) # Initial waste valve condition is turned off space.add_collision_handler(waste_valve_collision, ball_collision, begin=no_collision) # Add the objects to the game world pump = add_pump(space) lines = add_oil_unit(space) tank_level = tank_level_sensor(space) sep_valve_obj = sep_valve(space) oil_spill = oil_spill_sensor(space) oil_process = oil_processed_sensor(space) outlet = outlet_valve(space) waste_valve_obj = waste_valve(space) balls = [] ticks_to_next_ball = 1 # Set font settings fontBig = pygame.font.SysFont(None, 40) fontMedium = pygame.font.SysFont(None, 26) fontSmall = pygame.font.SysFont(None, 18) while running: # Advance the game clock clock.tick(FPS) for event in pygame.event.get(): if event.type == QUIT: running = False elif event.type == KEYDOWN and event.key == K_ESCAPE: running = False # Load the background picture for the pipe images bg = pygame.image.load("oil_unit.png") # Background color screen.fill(THECOLORS["grey"]) # If the feed pump is on if PLCGetTag(PLC_FEED_PUMP) == 1: # Draw the valve if the pump is on # If the oil reaches the level sensor at the top of the tank if (PLCGetTag(PLC_TANK_LEVEL) == 1): PLCSetTag(PLC_FEED_PUMP, 0) # Oil Tank outlet valve open/closed collision handler if PLCGetTag(PLC_OUTLET_VALVE) == 1: space.add_collision_handler(outlet_valve_collision, ball_collision, begin=outlet_valve_open) elif PLCGetTag(PLC_OUTLET_VALVE) == 0: # Valve is closed space.add_collision_handler(outlet_valve_collision, ball_collision, begin=outlet_valve_closed) # Separator valve open/closed collision handler if PLCGetTag(PLC_SEP_VALVE) == 1: space.add_collision_handler(sep_valve_collision, ball_collision, begin=sep_open) else: space.add_collision_handler(sep_valve_collision, ball_collision, begin=sep_closed) # Waste water valve open/closed collision handler if PLCGetTag(PLC_WASTE_VALVE) == 1: space.add_collision_handler(waste_valve_collision, ball_collision, begin=waste_valve_open) else: space.add_collision_handler(waste_valve_collision, ball_collision, begin=waste_valve_closed) ticks_to_next_ball -= 1 if ticks_to_next_ball <= 0 and PLCGetTag(PLC_FEED_PUMP) == 1: ticks_to_next_ball = 1 ball_shape = add_ball(space) balls.append(ball_shape) balls_to_remove = [] for ball in balls: if ball.body.position.y < 0 or ball.body.position.x > SCREEN_WIDTH+150: balls_to_remove.append(ball) draw_ball(bg, ball) for ball in balls_to_remove: space.remove(ball, ball.body) balls.remove(ball) draw_polygon(bg, pump) draw_lines(bg, lines) draw_ball(bg, tank_level, THECOLORS['black']) draw_line(bg, sep_valve_obj) draw_line(bg, outlet) draw_line(bg, waste_valve_obj) draw_line(bg, oil_spill, THECOLORS['red']) draw_line(bg, oil_process, THECOLORS['red']) #draw_ball(screen, separator_feed, THECOLORS['red']) title = fontMedium.render(str("Crude Oil Pretreatment Unit"), 1, THECOLORS['blue']) name = fontBig.render(str("VirtuaPlant"), 1, THECOLORS['gray20']) instructions = fontSmall.render(str("(press ESC to quit)"), 1, THECOLORS['gray']) feed_pump_label = fontMedium.render(str("Feed Pump"), 1, THECOLORS['blue']) oil_storage_label = fontMedium.render(str("Oil Storage Unit"), 1, THECOLORS['blue']) separator_label = fontMedium.render(str("Separator Vessel"), 1, THECOLORS['blue']) waste_water_label = fontMedium.render(str("Waste Water Treatment Unit"), 1, THECOLORS['blue']) tank_sensor = fontSmall.render(str("Tank Level Sensor"), 1, THECOLORS['blue']) separator_release = fontSmall.render(str("Separator Vessel Valve"), 1, THECOLORS['blue']) waste_sensor = fontSmall.render(str("Waste Water Valve"), 1, THECOLORS['blue']) outlet_sensor = fontSmall.render(str("Outlet Valve"), 1, THECOLORS['blue']) bg.blit(title, (300, 40)) bg.blit(name, (347, 10)) bg.blit(instructions, (SCREEN_WIDTH-115, 0)) bg.blit(feed_pump_label, (80, 0)) bg.blit(oil_storage_label, (125, 100)) bg.blit(separator_label, (385,275)) screen.blit(waste_water_label, (265, 490)) bg.blit(tank_sensor, (125, 50)) bg.blit(outlet_sensor, (90, 195)) bg.blit(separator_release, (350, 375)) bg.blit(waste_sensor, (90, 375)) screen.blit(bg, (0, 0)) space.step(1/FPS) pygame.display.flip() if reactor.running: reactor.callFromThread(reactor.stop)
def __init__(self, weights, indicator): # Global-ish. self.crashed = False # Physics stuff. self.space = pymunk.Space() self.space.gravity = pymunk.Vec2d(0., 0.) self.W = weights #weights for the reward function self.indicator = indicator #for the specific task # Create the car. self.create_car(150, 20, 15) # Record steps. self.num_steps = 0 self.num_obstacles_type = 4 # Create walls. static = [ pymunk.Segment( self.space.static_body, (0, 1), (0, height), 1), pymunk.Segment( self.space.static_body, (1, height), (width, height), 1), pymunk.Segment( self.space.static_body, (width-1, height), (width-1, 1), 1), pymunk.Segment( self.space.static_body, (1, 1), (width, 1), 1) ] for s in static: s.friction = 1. s.group = 1 s.collision_type = 1 s.color = THECOLORS['red'] self.space.add(static) # Create some obstacles, semi-randomly. # We'll create three and they'll move around to prevent over-fitting. self.obstacles = [] #self.obstacles.append(self.create_obstacle(380, 220, 70, "yellow")) #self.obstacles.append(self.create_obstacle(250, 500, 70, "yellow")) #self.obstacles.append(self.create_obstacle(780, 330, 70, "brown")) #self.obstacles.append(self.create_obstacle(530, 500, 70, "brown")) self.obstacles.append(self.create_obstacle([100, 100], [100, 585] , 7, "yellow")) self.obstacles.append(self.create_obstacle([450, 600], [100, 600] , 7, "yellow")) self.obstacles.append(self.create_obstacle([900, 100], [900, 585] , 7, "yellow")) self.obstacles.append(self.create_obstacle([900, 600], [550, 600] , 7, "yellow")) self.obstacles.append(self.create_obstacle([200, 100], [200, 480] , 7, "yellow")) self.obstacles.append(self.create_obstacle([450, 500], [200, 500] , 7, "yellow")) self.obstacles.append(self.create_obstacle([800, 100], [800, 480] , 7, "yellow")) self.obstacles.append(self.create_obstacle([800, 500], [550, 500] , 7, "yellow")) self.obstacles.append(self.create_obstacle([300, 100], [300, 350] , 7, "yellow")) self.obstacles.append(self.create_obstacle([700, 380], [300, 380] , 7, "yellow")) self.obstacles.append(self.create_obstacle([700, 100], [700, 350] , 7, "yellow")) self.obstacles.append(self.create_obstacle([400, 100], [600, 100] , 7, "brown")) self.obstacles.append(self.create_obstacle([400, 200], [600, 200] , 7, "brown")) self.obstacles.append(self.create_obstacle([400, 300], [600, 300] , 7, "brown")) self.obstacles.append(self.create_obstacle([700, 370], [300, 370] , 7, "brown")) self.obstacles.append(self.create_obstacle([310, 100], [310, 350] , 7, "brown")) self.obstacles.append(self.create_obstacle([690, 100], [690, 350] , 7, "brown"))
def main(): shadowCapture = VectorShadowCapture() pygame.init() screen = pygame.display.set_mode([1280, 960]) pygame.display.set_caption("Shadow Caster Level 2") clock = pygame.time.Clock() draw_options = pymunk.pygame_util.DrawOptions(screen) space = pymunk.Space(threaded=True) space.gravity = (0.0, -1500.0) static = [ pymunk.Segment(space.static_body, (0, 0), (1280, 0), 3), pymunk.Segment(space.static_body, (1280, 0), (1280, 960), 3), pymunk.Segment(space.static_body, (1280, 960), (0, 960), 3), pymunk.Segment(space.static_body, (0, 960), (0, 0), 3) ] for segment in static: segment.friction = 1. space.add(segment) #create pendulum mass = 1 radius = 60 inertia = pymunk.moment_for_circle(mass, 0, radius, (0, 0)) body = pymunk.Body(mass, inertia) body.position = (440, 430) body.start_position = Vec2d(body.position) objective = pymunk.Circle(body, radius) objective.elasticity = 0.75 space.add(body, objective) pj = pymunk.PinJoint(space.static_body, body, (640, 960), (0, 0)) space.add(pj) objectiveRegion = [1180, 960, 1280, 860] finished = False forbiddenRegion = [[800, 960], [1200, 960], [1300, 0], [700, 0]] cvForbiddenRegion = [[500, -100], [250, 480], [750, 480]] # Using 640x480 image at this point while not finished: finished = inRegion(objectiveRegion, objective.body) for event in pygame.event.get(): if event.type == QUIT: sys.exit(0) elif event.type == KEYDOWN and event.key == K_ESCAPE: sys.exit(0) elif event.type == KEYDOWN and event.key == K_SPACE: shadowCapture.resetBackground() surface = shadowCapture.updateWithBlocking( space, cvForbiddenRegion ) # Update the space with what's captured in the camera. Return a pygame image of the silhouette. screen.fill((255, 255, 255)) pygame.draw.polygon(surface, (93, 0, 166), [[1000, -100], [500, 960], [1500, 960]], 0) pygame.draw.circle(surface, (255, 0, 0), (1210, 70), 70, 3) screen.blit(surface, surface.get_rect()) space.debug_draw(draw_options) space.step(1 / 50.0) pygame.display.flip() clock.tick(50) #Final screen screen.fill((225, 255, 255)) font = pygame.font.SysFont("Arial", 32) screen.blit( font.render("Level 2 Complete! Esc to close window", 1, (0, 0, 0)), (480, 480)) pygame.display.flip() #Wait for them to close the game while True: for event in pygame.event.get(): if event.type == QUIT: sys.exit(0) elif event.type == KEYDOWN and event.key == K_ESCAPE: sys.exit(0)