def __init__(self, p, *args, d=2, color=None, friction=1): p = Vec2d(p) for v in args: shape = pymunk.Segment(b0, p, p + v, d) shape.color = LIGHTGRAY shape.elasticity = 1 shape.friction = friction if color != None: shape.color = color p = p + v space.add(shape)
def reset_bodies(space): for body in space.bodies: body.position = Vec2d(*body.start_position) body.force = 0, 0 body.torque = 0 body.velocity = 0, 0 body.angular_velocity = 0 color = pygame.Color(random.randint(1, 255), random.randint(1, 255), random.randint(1, 255)) for shape in space.shapes: shape.color = color
def on_touch_down(self, touch): cpos = Vec2d(touch.x, touch.y) space = self.game.get_space() shape = space.point_query_first(cpos) if shape is not None: body = shape.body x1, y1 = cpos.int_tuple x2, y2 = body.position.int_tuple self.delta = (x1 - x2, y1 - y2) self.current_body = body
def create_sonar(self): self.sonar_body = pymunk.Body(body_type=pymunk.Body.KINEMATIC) vertex = self.get_car_contour_vertices() offset = Vec2d(5, 0).rotated(self.car_body.angle) self.sonar_body.position = (vertex[1] + vertex[0]) / 2 - offset self.sonar_shape = pymunk.Circle(self.sonar_body, self.car_sonar_size) self.sonar_shape.collision_type = self.body_collision_type self.sonar_shape.color = cyan self.space.add(self.sonar_shape, self.sonar_body)
def transform(self, x, y): W = pyxel.width H = pyxel.height s = self.scale x_ = (x - self.x) * s + W / 2 y_ = H / 2 - (y - self.y) * s cos, sin = self._cos, self._sin xt = cos * x_ - sin * y_ yt = sin * x_ + cos * y_ return Vec2d(xt, yt)
def target_force(position, other_position, repulse=True): # specify a potential field v = Vec2d(tuple(other_position - position)) l = v.normalize_return_length() if repulse: v *= (-50.0 / l) else: v *= (l / 50.0) return v
def _add_walls(self) -> None: static_lines = [ pymunk.Segment(self._space.static_body, Vec2d(50, 50), Vec2d(950, 50), 2), pymunk.Segment(self._space.static_body, Vec2d(50, 50), Vec2d(50, 350), 2), pymunk.Segment(self._space.static_body, Vec2d(50, 350), Vec2d(950, 350), 2), pymunk.Segment(self._space.static_body, Vec2d(950, 350), Vec2d(950, 50), 2) ] static_lines[0].friction = 1.0 self.space.add(static_lines)
def __init__(self, a, b, anchor_a, anchor_b, stiffness=1000, damping=10, rest_length=None, **parameters): super().__init__(a, b, **parameters) self.anchor_a = Vec2d(anchor_a) self.anchor_b = Vec2d(anchor_b) if rest_length is None: world_pos_a = a.position + anchor_a world_pos_b = b.position + anchor_b rest_length = (world_pos_a - world_pos_b).get_length() self._rest_length = rest_length self.original_rest_length = rest_length self.stiffness = stiffness self.damping = damping
def create_poly(self, points, mass=5.0, pos=(0, 0)): moment = pm.moment_for_poly(mass, points) # moment = 1000 body = pm.Body(mass, moment) body.position = Vec2d(pos) shape = pm.Poly(body, points) shape.friction = 0.5 shape.collision_type = COLLTYPE_DEFAULT self.space.add(body, shape) return shape
def create_ball(self, point, mass=1.0, radius=15.0): moment = pm.moment_for_circle(mass, 0.0, radius) ball_body = pm.Body(mass, moment) ball_body.position = Vec2d(point) ball_shape = pm.Circle(ball_body, radius) ball_shape.friction = 1.5 ball_shape.collision_type = COLLTYPE_DEFAULT self.space.add(ball_body, ball_shape) return ball_shape
def scenario7(self): self.createObservedBall(25, 1, 150, 150, 1.0, 400, -100) # Create Initial Lines lines = [[750, 750, 750, 50], [50, 50, 50, 750], [750, 750, 50, 750], [50, 50, 750, 50]] for line in lines: self.createBoundaries(line) h = 5 sizes = 27 for y in range(1, h + 1): x = 50 s = 20 p = Vec2d(100, 100) + Vec2d(x + y * s * 4, 0) verts = [(random.randint(-sizes, 0), random.randint(0, sizes)), (random.randint(0, sizes), random.randint(-sizes, 0)), (random.randint(-sizes, 0), random.randint(0, sizes)), (random.randint(0, sizes), random.randint(-sizes, 0))] self.create_poly(verts, 1, p, random.randint(-500, 500), random.randint(-500, 500)) self.seconds = 50
def put_box(self, layer_num, x_pos, y_pos, rect_width): # print('layer_num: {}, x_pos: {}, y_pos: {}, rect_width: {} in put_box: '.format(layer_num, x_pos, y_pos, rect_width)) mass = 50.0 moment = pymunk.moment_for_box(mass, (rect_width, self.rect_height)) body = pymunk.Body(mass, moment) body.position = Vec2d(x_pos, y_pos) shape = pymunk.Poly.create_box(body, (rect_width, self.rect_height)) shape.friction = 0.3 # print('shape.body.area: {}, shape.body.area/rect_height: {}, rect_width: {}'.format(shape.area, shape.area/self.rect_height, rect_width)) self.space.add(body, shape) self.boxes[layer_num].append(shape)
def make_emitter(): return arcade.Emitter( pos=Vec2d(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2), # pos=Vec2d.zero(), emit_controller=arcade.EmitterIntervalWithTime(0.0004, 15.0), particle_factory=lambda emitter: arcade.LifetimeParticle( filename_or_texture=TEXTURE, vel=arcade.rand_in_circle(Vec2d.zero(), 5.0), lifetime=1.0, scale=0.5, alpha=128))
def curriculum_speed_factory( min_speed=3, max_speed=45, min_turn_rate_multiplier=0, max_turn_rate_multiplier=2, total_length=10000, random_seed=2, ) -> Callable[['TrajectoryTrackingProcess'], Tuple[List[Tuple[Vec2d, float]], bool]]: r = random.Random(random_seed) speed = (max_speed + min_speed) / 2 # start with a straight line waypoints = [(Vec2d(0, 0), speed), (Vec2d(.001, 0), speed)] length = 0.0 angle = 0.0 def add_segment(segment_length, segment_angle): nonlocal angle, length, speed angle += segment_angle length += segment_length delta = Vec2d(segment_length, 0.0) delta.rotate(angle) waypoints.append((waypoints[-1][0] + delta, speed)) while length < total_length: d = length / total_length segment_length = 100 max_delta_speed = d * .5 * (max_speed - min_speed) speed = min(max_speed, max(min_speed, speed + r.uniform(-max_delta_speed, max_delta_speed))) add_segment(segment_length, 0) def curriculum_angled_path_generator(process: 'TrajectoryTrackingProcess') -> Tuple[List[Tuple[Vec2d, float]], bool]: return deepcopy(waypoints), False return curriculum_angled_path_generator
def MakeSwitches(): switches.append( ScoreZone(SWITCH_NAME, context, Vec2d((15, 21)), True, False, False, context.switchColor[0], radius=3, retKey=SWITCH_RETKEY)) switches.append( ScoreZone(SWITCH_NAME, context, Vec2d((15, 8)), True, False, False, context.switchColor[1], radius=3, retKey=SWITCH_RETKEY)) switches.append( ScoreZone(SWITCH_NAME, context, Vec2d((41, 21)), True, False, False, context.switchColor[0], radius=3, retKey=SWITCH_RETKEY)) switches.append( ScoreZone(SWITCH_NAME, context, Vec2d((41, 8)), True, False, False, context.switchColor[1], radius=3, retKey=SWITCH_RETKEY))
def path_center_of_mass(seq): """ Center of mass of a path. """ M = 0.0 cm = Vec2d(0, 0) for a, b in zip(seq[:-1], seq[1:]): a, b = map(Vec2d, (a, b)) m = (b - a).length M += m cm += (m / 2) * (a + b) return cm / M
def __init__(self, pos, radius=.4, mass=50): self.mass = mass self.radius = radius self.pos = Vec2d(pos) self.body = None self.shape = None self.scene: Scene = None self.keys_down = set() self.is_jump = False self.is_pick = False self.is_put = False self.pick_dir = (1, 0)
def emitter_37(): """Rotating emitter. Particles initial velocity is relative to emitter's angle.""" e = arcade.Emitter(pos=CENTER_POS, emit_controller=arcade.EmitterIntervalWithTime( DEFAULT_EMIT_INTERVAL, DEFAULT_EMIT_DURATION), particle_factory=lambda emitter: arcade. LifetimeParticle(filename_or_texture=TEXTURE, vel=Vec2d(0.0, 2.0), lifetime=2.0, scale=DEFAULT_SCALE)) e.change_angle = 10.0 return emitter_37.__doc__, e
def emitter_22(): """Interval, emit from center, velocity in fixed angle and speed""" e = arcade.Emitter(pos=CENTER_POS, emit_controller=arcade.EmitterIntervalWithTime( 0.2, DEFAULT_EMIT_DURATION), particle_factory=lambda emitter: arcade. LifetimeParticle(filename_or_texture=TEXTURE, vel=Vec2d(1.0, 1.0), lifetime=DEFAULT_PARTICLE_LIFETIME, scale=DEFAULT_SCALE, alpha=128)) return emitter_22.__doc__, e
def try_spawn_vehicle(self, offset: float = 0) -> bool: # print('try_spawn_vehicle') velocity = Vec2d( random.gauss(self.speed_mean, self.speed_standard_deviation), 0) position, angle = self.road.road_to_global( Vec2d(offset, (self.road.lane_center_offsets[random.randrange( 0, self.road.num_lanes)]))) vehicle = VehicleLaneFollower(self, (64, 64, 200), position, velocity, velocity.length, angle) if not self.can_place_entity(vehicle, 10): # print('remove ', position, angle) vehicle.discard() # print('try_spawn_vehicle remove ', vehicle.id) return False # print('try_spawn_vehicle add ', vehicle.id, vehicle.position, vehicle.velocity) # vehicle.handle_collision = self.num_vehicles = self.num_vehicles + 1 return True
def create_bananas(space): mass = 10 size = 50 points = [(-size, -size), (-size, size), (size, size), (size, -size)] moment = pymunk.moment_for_poly(mass, points, (0, 0)) body = pymunk.Body(mass, moment) x = random.randint(0, 500) body.position = Vec2d(x, x) banana = pymunk.Poly(body, points, (0, 0)) banana.elasticity = 0.95 space.add(body, banana) return banana
def wander(self, t): """Return a small lissajous wander.""" xperiod = 0.3 sx = sin(xperiod * t) px = sx * abs(sx) vx = cos(xperiod * t) self.sprite._scale_x = copysign(max(0.3, abs(vx)), vx) return Vec2d( 1.5 * px, 0.2 * sin(0.2 * t), )
def pre_solve(arbiter, space, data): set_ = arbiter.contact_point_set if len(set_.points) > 0: player_shape = arbiter.shapes[0] w_ = (player_shape.b - player_shape.a).x delta = (player_shape.body.position - set_.points[0].point_a.x).x normal = Vec2d(0, 1).rotated(delta / w_ / 2) set_.normal = normal set_.points[0].distance = 0 arbiter.contact_point_set = set_ return True
def MakeScales(): scales.append( ScoreZone(SCALE_NAME, context, Vec2d((28, 20)), True, False, False, context.scaleColor[0], radius=3.5, retKey=SCALE_RETKEY)) scales.append( ScoreZone(SCALE_NAME, context, Vec2d((28, 9)), True, False, False, context.scaleColor[1], radius=3.5, retKey=SCALE_RETKEY))
def __init__(self, pos, angle, length, space, mass=5.0): ''' parater angle is clockwise value ''' radius = 3 moment = 1000 body = pm.Body(mass, moment) body.position = Vec2d(pos) power = mass * 2000 impulse = power * Vec2d(0, 1) # the angle of rotated function is counter-clockwise, need to reverse it angle = -angle body.apply_impulse_at_local_point(impulse.rotated(angle)) shape = pm.Circle(body, radius, (0, 0)) shape.friction = 1 shape.collision_type = COLLISION_EXPLODE space.add(body, shape) self.body = body self.shape = shape self.orig_pos = pos self.length = length
def create_palm(self, point, radius): moment = pm.moment_for_circle(10000, 0.0, radius) palm_body = pm.Body(10000, moment) palm_body.position = Vec2d(point) palm_body.velocity_func = maintain_velocity palm_shape = pm.Circle(palm_body, radius) palm_shape.friction = 20 palm_shape.collision_type = COLLTYPE_FINGERTIP palm_shape.elasticity = .5 self.space.add(palm_body, palm_shape) return palm_shape
def create_fingertip(self, point, mass=1000.0, radius=TIP_RADIUS): moment = pm.moment_for_circle(mass, 0.0, radius) fingertip_body = pm.Body(mass, moment) fingertip_body.position = Vec2d(point) fingertip_body.velocity_func = maintain_velocity fingertip_shape = pm.Circle(fingertip_body, radius) fingertip_shape.friction = 20 fingertip_shape.collision_type = COLLTYPE_FINGERTIP fingertip_shape.elasticity = .9999 self.space.add(fingertip_body, fingertip_shape) return fingertip_shape
def draw(self): p2 = self.body.position p1 = Vec2d(self.Collection, FLOOR_LEVEL) distance = int(euclidean_distance(p1, p2)) midpt = midpoint(p1, p2) + Vec2d(15, 15) p1 = flip_vec(p1) p2 = flip_vec(p2) pygame.draw.line(self.screen, THECOLORS[self.Color], p1, p2, 1) font = pygame.font.Font(pygame.font.match_font("freemonobold"), 25) line = str(distance) text = font.render(line, 0, THECOLORS[self.Color]) self.screen.blit(text, flip_vec(midpt)) # sprite r = self.object.radius v = self.body.position rot = self.body.angle p = Vec2d(int(v.x), int(flipy(v.y))) self.sprite.move(p) self.sprite.rotate(rot) self.sprites.update() self.sprites.draw(self.screen)
def create_ball(self, point, mass=4.0, radius=BALL_DEFAULT_RADIUS): moment = pm.moment_for_circle(mass, 0.0, radius) ball_body = pm.Body(mass, moment) ball_body.position = Vec2d(point) ball_shape = pm.Circle(ball_body, radius) ball_shape.friction = .5 ball_shape.elasticity = .9999 ball_shape.collision_type = COLLTYPE_DEFAULT self.space.add(ball_body, ball_shape) return ball_shape
def on_new_level(self): # Physics stuff self.space = pymunk.Space() self.space.gravity = Vec2d(0.0, -1200.0) self.player = Player(x=100, y=600, group=self.background, space=self.space, game=self) self.window.push_handlers(self.player.key_handler) self.current_level().create(self.space, self.background)