def __init__(self, initpos, initvel, rad, color, elast, pmsp=None, layer=None): initpos = pm.Vec2d(initpos) initvel = pm.Vec2d(initvel) self.body = pm.Body(1, pm.moment_for_circle(1, 0, rad)) self.circle = pm.Circle(self.body, rad) self.circle.elasticity = elast self.circle.collision_type = COLLTYPE_BALL self.body.position = initpos self.body.velocity = pm.Vec2d(initvel) if layer: if layer < 1 or layer > 31: print( "Layer must be between 1 and 31 - defaulting to all layers" ) else: self.circle.layers = 2**layer self.r = ptRect(initpos[0] - rad, initpos[1] - rad, 2 * rad, 2 * rad) self.sp = ref(pmsp) self.col = color self.bounces = 0 self.tsb = 0 # Time since last bounce self.attached = True
def __init__( self, anchor: Part, position_anchor: Tuple[float, float] = (0, 0), position_part: Tuple[float, float] = (0, 0), rotation_range: float = math.pi / 4, angle_offset: float = 0, can_absorb: bool = False, movable: bool = True, **kwargs, ): """ Args: anchor: position_anchor: position_part: rotation_range: angle_offset: can_absorb: movable: **kwargs: """ Part.__init__(self, can_absorb=can_absorb, movable=movable, **kwargs) self.anchor: Part = anchor self.angle_offset = angle_offset self.rotation_range = rotation_range self._rel_coord_anchor = pymunk.Vec2d(*position_anchor) self._rel_coord_part = pymunk.Vec2d(*position_part) self.set_relative_coordinates() self._attach_to_anchor()
def getDistanceToWorldPoint(self, point, offset=(0, 0)): offset = pm.Vec2d(offset) offset.rotate(self.angle) pos_offset = self.position + offset point = pm.Vec2d(point) ang = point - pos_offset return ang.length
def handle_state(self): if not self.game == None: pass if not self.menu == None: pass if not self.player == None and not self.player.dead: newdir = pm.Vec2d(self.joy.get_axis(self.config.axMovex), self.joy.get_axis(self.config.axMovey)) lengh = newdir.get_length_sqrd() if lengh > 0.1: self.player.dir = newdir.normalized() else: self.player.dir = [0, 0] newlookdir = pm.Vec2d(self.joy.get_axis(self.config.axLookx), self.joy.get_axis(self.config.axLooky)) if newlookdir.get_length_sqrd() > 0.2: self.player.set_shoot_dir(newlookdir.normalized()) elif lengh > 0.1: self.player.set_shoot_dir(self.player.dir) if self.joy.get_button(self.config.shoot): self.player.keep_shooting() if self.joy.get_button(self.config.bomb): self.player.arm_bomb()
def __init__(self, width, height, x=300, y=400): self.body = pymunk.Body(None, None) points = [(-width / 2, -height / 2), (-width / 2, height / 2), (width / 2, height / 2), (width / 2, -height / 2)] self.width = width self.height = height self.shape = pymunk.Poly(self.body, points, (0, 0)) self.body.position = pymunk.Vec2d(x, y) self.shapes = [self.shape] self.shape.friction = 0.5 self.shape.collision_type = 1 self.shape.owner = self topleft = self.body.position - framework.scrolling - pymunk.Vec2d( self.width / 2, self.height / 2) rect = pygame.Rect(topleft[0], topleft[1], self.width, self.height) framework.static_surface.fill(THECOLORS["darkgrey"], rect) pygame.gfxdraw.rectangle(framework.static_surface, rect, THECOLORS["orange"])
def __init__(self, space, chromosome=None): self.lifespan = 1000 self.is_alive = True self.checkpoint_index = 0 # Generate the chromosome for the car. self.chromosome = chromosome if self.chromosome is None: self.chromosome = Chromosome.generate_inital_chromosome() # Create a chassis. position_main = pymunk.Vec2d(START_POSITION) vs = self.chromosome.get_vertices() self.chassis = Chassis(space, position_main, vs) self.position = self.chassis.body.position # Create the wheels. self.wheels = [] genes = self.chromosome.get_genes() for position, [radius, speed] in genes: if radius == -1 or speed == -1: continue position = pymunk.Vec2d(position) + position_main wheel = Wheel(space, position, radius) c = pymunk.constraint.PivotJoint(self.chassis.body, wheel.body, position) c.collide_bodies = False m = pymunk.SimpleMotor(self.chassis.body, wheel.body, speed) space.add(c, m) self.wheels.append(wheel) self.__setup_draw()
def new_row(self, y): window = self.parent.scene.window items = [] for x in range((-window.width // 2) + 16, window.width // 2, 32): self.last_row = pymunk.Vec2d(x, y) snow = PrefabTileSnow(self.parent.scene) snow.get_component(Transform).position = self.last_row items.append(snow) random = randint(0, 100) obj = None if 21 < random < 29: obj = PrefabTree(self.parent.scene) elif 51 < random < 59: obj = PrefabTinyRock(self.parent.scene) if obj is not None: obj.get_component(Transform).position = pymunk.Vec2d(x, y) if obj is not None: items.append(obj) return items
def _symbol_wall_begin_handler(arbiter, space, data): """Log the point where an symbol first touches a wall. @param arbiter: @param space: @param data: @retval: """ symbol_id = data['body_symbol_map'][arbiter.shapes[0].body].id # Identify the wall that was hit based on the wall shape's normal wall_normal = arbiter.shapes[1].normal if wall_normal == pm.Vec2d(1, 0): wall_label = 'left' elif wall_normal == pm.Vec2d(-1, 0): wall_label = 'right' elif wall_normal == pm.Vec2d(0, -1): wall_label = 'top' elif wall_normal == pm.Vec2d(0, 1): wall_label = 'bottom' data['mie']._publish_message(dict( step=data['mie']._step_count, type='hit_wall', meta=dict( symbol_id=symbol_id, wall_label=wall_label ) )) return True
def __init__(self, name, space, p1, p2, width, density=DEFAULT_DENSITY, elasticity=DEFAULT_ELASTICITY, friction=DEFAULT_FRICTION, color=DEFAULT_COLOR): PGObject.__init__(self, name, "Segment", space, color, density, friction, elasticity) self.r = width / 2 area = areaForSegment(p1, p2, self.r) mass = density * area if mass == 0: self._cpShape = pm.Segment(space.static_body, p1, p2, self.r) self._cpShape.elasticity = elasticity self._cpShape.friction = friction self._cpShape.collision_type = COLTYPE_SOLID self._cpShape.name = name space.add(self._cpShape) else: pos = pm.Vec2d((p1[0] + p2[0]) / 2., (p1[1] + p2[1]) / 2.) v1 = pm.Vec2d(p1) - pos v2 = pm.Vec2d(p2) - pos imom = pm.moment_for_segment(mass, v1, v2, 0) self._cpBody = pm.Body(mass, imom) self._cpShape = pm.Segment(self._cpBody, v1, v2, self.r) self._cpShape.elasticity = elasticity self._cpShape.friction = friction self._cpShape.collision_type = COLTYPE_SOLID self._cpShape.name = name self._cpBody.position = pos space.add(self._cpBody, self._cpShape)
def get_render_image_and_position(self, screen_size): """ Get the PyGame Surface and center coordinate of the scaled, rotated symbol. Args: screen_size: (width, height) of the PyGame screen Returns: rotated_image: pygame.Surface of the scaled, rotated image pg_image_pos: PyGame coordinates of the scaled, rotated image """ # Get scaled image scaled_image = pg.transform.smoothscale( self.pg_image, tuple([int(x * self.scale) for x in self.image.size])) # Get body position in PyGame coordinates pg_body_pos = pm.Vec2d(self.body.position.x, -self.body.position.y + screen_size[1]) # Rotate image angle_deg = math.degrees(self.body.angle) rotated_image = pg.transform.rotate(scaled_image, angle_deg) # Offset image coordinates from body due to rotation offset = pm.Vec2d(rotated_image.get_size()) / 2. pg_image_pos = pg_body_pos - offset return rotated_image, pg_image_pos
def __init__(self, space, pos1, pos2, width): self.position1 = pymunk.Vec2d(pos1) self.position2 = pymunk.Vec2d(pos2) self.width = width self.body = pymunk.Body(body_type=pymunk.Body.STATIC) self.shape = pymunk.Segment(self.body, pos1, pos2, width) space.add(self.shape)
def check_teleport(self): ''' See if we need to warp back to start of level ''' # print(self.player.position) if self.player.position[ 0] > constants.WORLD_SIZE: # Need to teleport player self.player.body.position = pymunk.Vec2d( -constants.WORLD_SIZE, self.player.body.position[1]) if self.player.position[ 0] < -constants.WORLD_SIZE: # Need to teleport player self.player.body.position = pymunk.Vec2d( constants.WORLD_SIZE, self.player.body.position[1]) # Check if crates need warping for sprite in self.dynamic_sprite_list: if sprite.shape.name == "Pymunk" and sprite.body.position[ 0] > constants.WORLD_SIZE: sprite.body.position = pymunk.Vec2d( -constants.WORLD_SIZE, self.player.body.position[1]) # print("Sprite out of bounds") if sprite.shape.name == "Pymunk" and sprite.body.position[ 0] < -constants.WORLD_SIZE: sprite.body.position = pymunk.Vec2d( constants.WORLD_SIZE, self.player.body.position[1]) # print("Sprite out of bounds") if sprite.shape.name == "Pymunk" and sprite.body.position[1] < 0: # print("sprite fell off world, removing") self.space.remove(sprite.body, sprite.shape) sprite.remove_from_sprite_lists()
def bucket_touching_handler(arbiter, space, data): locations = arbiter.shapes[1].locations if arbiter.shapes[0].in_bucket: arbiter.shapes[0].body.position = locations[0][:] arbiter.shapes[0].body.velocity = pm.Vec2d(0., 0.) arbiter.shapes[0].body.force = pm.Vec2d(0., 0.) return False elif arbiter.shapes[0].collision_type == MOVING_OBJ_COLLISION_TYPE: d1 = dist(arbiter.shapes[0].body.position, locations[1]) d2 = dist(arbiter.shapes[0].body.position, locations[2]) d3 = dist(arbiter.shapes[0].body.position, locations[3]) d4 = dist(arbiter.shapes[0].body.position, locations[4]) if d1 < d2 and d1 < d3 and d4 < d2 and d4 < d3: new_pos = locations[0] obj = arbiter.shapes[0] obj.body.position = new_pos[:] obj.body.velocity = pm.Vec2d(0., 0.) obj.body.angular_velocity = 0. obj.body.force = pm.Vec2d(0., 0.) obj.body.torque = 0. obj.body.angle = 0. obj.in_bucket = True return False else: return True return True
def update(self, now, dt): if self.keys[KEY.LEFT]: self.body.angle += self.rotate_speed * dt elif self.keys[KEY.RIGHT]: self.body.angle -= self.rotate_speed * dt elif self.keys[KEY.UP]: self.engine.visible = True direction = pymunk.Vec2d(-math.cos(self.body.angle), -math.sin(self.body.angle)) self.body.velocity += direction * self.thrust * dt elif self.keys[KEY.DOWN]: self.body.velocity *= 1 - self.brake_damping if self.body.velocity.length < self.min_velocity: self.body.velocity = pymunk.Vec2d(0, 0) if not self.keys[KEY.UP]: self.engine.visible = False if self.keys[KEY.SPACE]: self.fire() self.update_engine()
def update(self): super(Ship, self).update() input = st.CURRENT_INPUT if input.mouse_began(1) or input.key_began(K_SPACE): # Create bullet bullet = Bullet() bullet.kill_time = 10 st.CURRENT_SCENE.objects.add(bullet) self.body.space.add(bullet.body, bullet.shapes) bullet.angle = self.angle force_pos = pymunk.Vec2d(0, 250) * self.scale bullet.body.velocity = self.body.velocity_at_local_point(force_pos) force_pos.rotate(self.body.angle) bullet.position = self.position + force_pos bullet.set_image(self.bullet_image) bullet.body.apply_force_at_local_point((0, self.bullet_force), (0, 0)) self.body.apply_force_at_local_point((0, -self.bullet_force), (0, 0)) force_list = [] if input.key_pressed(K_w) or input.key_pressed(K_UP): if not input.key_pressed(K_q): force_vector = pymunk.Vec2d(0, self.move_force) else: force_vector = pymunk.Vec2d(0, self.move_force * 2) force_pos = pymunk.Vec2d(0, -210) force_list.append((force_pos, force_vector)) if input.key_pressed(K_a) or input.key_pressed(K_LEFT): force_vector = pymunk.Vec2d(-self.rot_force, 0) force_pos = pymunk.Vec2d(67, 134) force_list.append((force_pos, force_vector)) force_pos = pymunk.Vec2d(-67, -140) force_vector = force_vector * -1 force_list.append((force_pos, force_vector)) elif input.key_pressed(K_d) or input.key_pressed(K_RIGHT): force_vector = pymunk.Vec2d(self.rot_force, 0) force_pos = pymunk.Vec2d(-67, 134) force_list.append((force_pos, force_vector)) force_pos = pymunk.Vec2d(67, -140) force_vector = force_vector * -1 force_list.append((force_pos, force_vector)) for force_pos, force_vector in force_list: force_pos *= self.scale self.body.apply_force_at_local_point(force_vector, force_pos) force_pos.rotate_degrees(self.angle) force_vector.rotate_degrees(self.angle) smoke = Particle() smoke.kill_time = 2 smoke.scale = force_vector.length / 2000. * 0.5 smoke.set_image(self.smoke_image) st.CURRENT_SCENE.objects.add(smoke) smoke.position = self.position + force_pos smoke.velocity = self.body.velocity + force_vector.normalized( ) * -500
def add_wall(line_end, line_start, space): line_point1 = pymunk.Vec2d(line_start) line_point2 = pymunk.Vec2d(line_end) 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) return shape
def setPosition(self, x_or_tuple, y=None, offset=(0, 0)): if type(x_or_tuple) == tuple: self.position = pm.Vec2d(x_or_tuple) + pm.Vec2d(offset) return True else: self.position = pm.Vec2d(x_or_tuple, y) + pm.Vec2d(offset) return True return False
def draw_map(screen, map_segment, map_width, map_offset): for fragment in map_segment: p1_translated = pymunk.pygame_util.to_pygame(fragment.a, screen) p2_translated = pymunk.pygame_util.to_pygame(fragment.b, screen) pygame.draw.line(screen, MAP_COLOR, p1_translated - pymunk.Vec2d(map_offset), p2_translated - pymunk.Vec2d(map_offset), 2 * map_width)
def check_velocity_restrictions(self): if abs(self.body.velocity.x) > self.max_velocity.x: self.body.velocity = pymunk.Vec2d(sign(self.body.velocity.x) * self.max_velocity.x, self.body.velocity.y) if abs(self.body.velocity.y) > self.max_velocity.y: self.body.velocity = pymunk.Vec2d(self.body.velocity.x, sign(self.body.velocity.y) * self.max_velocity.y) if abs(self.body.angular_velocity) > self.max_angular_velocity: self.body.angular_velocity = sign(self.body.angular_velocity) * self.max_angular_velocity
def getAngleToWorldPoint(self, point, offset=(0, 0), return_degrees=False): offset = pm.Vec2d(offset) offset.rotate(self.angle) pos_offset = self.position + offset point = pm.Vec2d(point) ang = point - pos_offset if return_degrees: return ang.angle_degrees return ang.angle
def reflect_vector_at(vector, segment): '''like light reflection''' dx = segment.a.x - segment.b.x dy = segment.a.y - segment.b.y n = pymunk.Vec2d(-dy, dx).normalized() s = pymunk.Vec2d(dx, dy).normalized() reflected = vector.dot(s) * s - vector.dot(n) * n # reverse part orthogonal to s (parallel to n), keep part parallel to s return reflected
def draw(self, screen): """Draw beams and columns""" poly = self.shape p = poly.body.position p = pymunk.Vec2d(self.to_pygame(p)) offset = pymunk.Vec2d(self.image.get_size()) / 2. p = p - offset np = p screen.blit(self.image, (np.x, np.y))
def _create_buildings(self): self.buildings = [ Obstacle(pymunk.Vec2d(365.0, 200.0), 400, 225), Obstacle(pymunk.Vec2d(365.0, 800.0), 400, 225), Obstacle(pymunk.Vec2d(1385.0, 200.0), 400, 225), Obstacle(pymunk.Vec2d(1385.0, 800.0), 400, 225), ] for building in self.buildings: self.space.add(building.shape.body, building.shape)
def __init__(self, width, height): pyglet.window.Window.__init__(self, vsync=False) self.draw_options = pymunk.pyglet_util.DrawOptions() pyglet.clock.schedule_interval(self.update, 1 / 60.0) # -- Pymunk space self.space = pymunk.Space() self.space.gravity = (0.0, -900.0) # Create the floor body = pymunk.Body(body_type=pymunk.Body.STATIC) self.floor = pymunk.Segment(body, [0, 10], [SCREEN_WIDTH, 10], 0.0) self.floor.friction = 10 self.space.add(self.floor) # Create the circle player_x = 300 player_y = 300 mass = 2 radius = 25 inertia = pymunk.moment_for_circle(mass, 0, radius, (0, 0)) circle_body = pymunk.Body(mass, inertia) circle_body.position = pymunk.Vec2d(player_x, player_y) self.circle_shape = pymunk.Circle(circle_body, radius, pymunk.Vec2d(0, 0)) self.circle_shape.friction = 1 self.space.add(circle_body, self.circle_shape) # Create the box size = BOX_SIZE mass = 5 moment = pymunk.moment_for_box(mass, (size, size)) moment = float("inf") body = pymunk.Body(mass, moment) body.position = pymunk.Vec2d(player_x, player_y + 49) self.box_shape = pymunk.Poly.create_box(body, (size, size)) self.box_shape.friction = 0.3 self.space.add(body, self.box_shape) # Create a joint between them constraint = pymunk.constraint.PinJoint(self.box_shape.body, self.circle_shape.body, (-20, 0), (0, 0)) self.space.add(constraint) constraint = pymunk.constraint.PinJoint(self.box_shape.body, self.circle_shape.body, (20, 0), (0, 0)) self.space.add(constraint) # Make the circle rotate constraint = pymunk.constraint.SimpleMotor(self.circle_shape.body, self.box_shape.body, -3) self.space.add(constraint)
def update(self, dt=None): speed = 300 # dt * swine.Globals.FPS force = pymunk.Vec2d(0, 0) if self.keys[key.LSHIFT]: speed *= 2 if self.keys[key.A]: # print("A") # self.body.force = pymunk.Vec2d(-speed, 0) force.x = -speed self.scale_x = -1 if self.keys[key.D]: # print("D") # self.body.force = pymunk.Vec2d(speed, 0) force.x = speed self.scale_x = 1 if self.keys[key.SPACE]: # print("W") # self.body.force = pymunk.Vec2d(0, 4000) if self.is_grounded: self.body.velocity = pymunk.Vec2d(force.x, speed) self.body.force = force if -4 < self.body.angle < -3 or 4 > self.body.angle > 3: # print("The pig has been flipped!") self.count_flip = True self.is_grounded = False else: self.count_flip = False self.flip_counter = 60 self.flip_direction = None if self.count_flip: self.flip_counter -= 1 if self.flip_counter <= 0: self.count_flip = False self.flip_counter = 60 self.body.velocity = pymunk.Vec2d(0, speed * 4) self.is_flipping = True if self.is_flipping: if self.body.angle < 0: self.body.angle += 0.05 elif self.body.angle > 0: self.body.angle -= 0.05
def draw(self, screen): """Draw beams and columns""" poly = self.shape p = poly.body.position p = pymunk.Vec2d(self.to_pygame(p)) angle_degrees = math.degrees(poly.body.angle) + 180 rotated_img = pygame.transform.rotozoom(self.image, angle_degrees, 1) offset = pymunk.Vec2d(self.image.get_size()) / 2. p = p - offset np = p screen.blit(rotated_img, (np.x, np.y))
def make_circle(self, x, y): size = 20 mass = 12.0 moment = pymunk.moment_for_circle(mass, 0, size, (0, 0)) body = pymunk.Body(mass, moment) body.position = pymunk.Vec2d(x, y) shape = pymunk.Circle(body, size, pymunk.Vec2d(0, 0)) shape.friction = 0.3 self.space.add(body, shape) sprite = CircleSprite(shape, "images/coin_01.png") self.sprite_list.append(sprite)
def __init__(self, anchor, position_anchor=(0, 0), position_part=(0, 0), rotation_range=math.pi/4, angle_offset=0, can_absorb=False, **kwargs, ): """ Args: anchor (:obj:`Part`): Body Part on which the Part is attached position_anchor: position_part: rotation_range: angle_offset: can_absorb: **kwargs: """ default_config = parse_configuration('agent_parts', self.entity_type) body_part_params = {**default_config, **kwargs} Entity.__init__(self, visible=True, movable=True, **body_part_params) self.pm_visible_shape.collision_type = CollisionTypes.AGENT self.can_absorb = can_absorb # Interactive parts self.is_eating = False self.is_activating = False self.can_grasp = False self.is_grasping = False self.is_holding = False self.grasped = [] # For parts attached self.anchor = anchor self.angle_offset = angle_offset self.rotation_range = rotation_range self.motor = None # If part is attached to another part: if self.anchor: self._rel_coord_anchor = pymunk.Vec2d(*position_anchor) self._rel_coord_part = pymunk.Vec2d(*position_part) self.set_relative_coordinates() self._attach_to_anchor()
def create_ball(self, center, mass=1.0, radius=10.0, elasticity=0.95): moment = pymunk.moment_for_circle(mass, radius, 0.0, pymunk.Vec2d(0, 0)) body = pymunk.Body(mass, moment) body.position = pymunk.Vec2d(center) shape = pymunk.Circle(body, radius, pymunk.Vec2d(0, 0)) shape.friction = 1.5 shape.collision_type = 0 shape.elasticity = elasticity self.space.add(body, shape) return shape
def forceImpulse(self): for x in range(8): for y in range(8): field = self.board.getPiece(x, y) if field is not None: for fig in self.pieceBodies: if fig.piece == field: fig.timeIdle = 0 vec1 = pymunk.Vec2d(fig.body.position) vec2 = pymunk.Vec2d(field.x * 64, field.y * 64) #amount of impulse force on move fig.body.force += (100000000 * (vec2 - vec1))