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))
