def setup_balls(space, px, py, offset, masses, radiuses, elasts):
width = offset * 2
height = offset * 2
balls = []
n_balls = len(radiuses)
step = 400 // n_balls + 1
for b_idx, x in enumerate(range(-50, 350, step)):
x += width / 2
offset_y = height
mass = masses[b_idx]
radius = radiuses[b_idx]
moment = pymunk.moment_for_circle(mass, 0, radius, (0, 0))
body = pymunk.Body(mass, moment)
body.position = x, -125 + offset_y
body.start_position = Vec2d(body.position)
shape = pymunk.Circle(body, radius, (0, 0))
shape.elasticity = elasts[b_idx]
space.add(body, shape)
balls.append(body)
pj = pymunk.PinJoint(balls[0], balls[1], (0, 0), (0, 0))
space.add(pj)
pj = pymunk.PinJoint(balls[1], balls[2], (0, 0), (0, 0))
space.add(pj)
pj = pymunk.PinJoint(balls[2], balls[3], (0, 0), (0, 0))
space.add(pj)
return balls
def add_lines(space):
rotation_center_body = pymunk.Body(body_type=pymunk.Body.STATIC)
rotation_center_body.position = (223, 10)
body = pymunk.Body(100000, 100000)
body.position = (223, 10)
largeur_trait = 1.0
l1 = pymunk.Segment(body, (5.0, 75.0), (5.0, 515.0), largeur_trait)
l2 = pymunk.Segment(body, (25.0, 534.0), (110.0, 534.0), largeur_trait)
l3 = pymunk.Segment(body, (110.0, 534.0), (156.0, 550.0), largeur_trait)
l4 = pymunk.Segment(body, (156.0, 550.0), (300.0, 550.0), largeur_trait)
l5 = pymunk.Segment(body, (376.0, 480.0), (376.0, 67.0), largeur_trait)
l6 = pymunk.Segment(body, (330.0, 67.0), (376.0, 67.0), largeur_trait)
l7 = pymunk.Segment(body, (354.0, 400), (354.0, 67), 2.0)
l8 = pymunk.Segment(body, (355, 105), (375.0, 105), largeur_trait)
addSegment([(5, 312), (45, 238), (45, 232), (5, 210)], body, space,
largeur_trait, False)
addSegment([(352, 395), (306, 314), (338, 275), (326, 256), (352, 208)],
body, space, largeur_trait, False)
addSegment([(27, 482), (27, 337), (72, 276), (144, 311), (144, 390),
(155, 418), (155, 471), (133, 455), (133, 331), (48, 331),
(41, 338), (41, 471), (33, 482), (27, 482)], body, space,
largeur_trait, True)
addSegment([(108, 356), (72, 356), (60, 366), (60, 464), (62, 468),
(94, 499), (100, 499), (122, 487), (126, 478), (126, 474),
(114, 461), (113, 360)], body, space, largeur_trait, True)
l9 = pymunk.Segment(body, (174, 370), (174, 331), 4.0) #******#
addSegment([(93, 64), (93, 59), (67, 59), (59, 51), (59, 62), (41, 62),
(41, 105), (34, 105), (34, 160), (39, 160), (39, 109),
(49, 109)], body, space, largeur_trait, False)
addSegment([(322, 146), (322, 103), (330, 94), (330, 67), (301, 67),
(301, 49), (284, 66), (259, 66), (312, 96), (312, 146)], body,
space, largeur_trait, False)
addSegment([(95, 97), (99, 97),
(102, 99), (102, 105), (80, 160), (80, 116), (77, 112),
(77, 107)], body, space, largeur_trait, True)
addSegment([(258, 98), (252, 103), (279, 160), (282, 160), (282, 110)],
body, space, largeur_trait, True)
addSegment([(309, 214), (317, 194), (317, 159), (315, 159), (296, 201),
(295, 206), (302, 214)], body, space, largeur_trait, True)
arcG((5.0, 75), (160, -5), (160, 185), body, space, largeur_trait)
arcG((190.0, -5.0), (330.0, 67.0), (190, 173), body, space, largeur_trait)
arcG((25, 534), (5, 515), (24.5, 514.5), body, space, largeur_trait)
arcG((376, 480), (300, 550), (303, 477), body, space, largeur_trait)
arcG((49, 109), (93, 64), (139, 157), body, space, largeur_trait)
arcG((322, 146), (312, 146), (317, 146), body, space, largeur_trait)
centreRotation = pymunk.PinJoint(body, rotation_center_body, (0, 0),
(0, 0))
centreRotation2 = pymunk.PinJoint(body, rotation_center_body, (390, 0),
(390, 0))
centreRotation3 = pymunk.PinJoint(body, rotation_center_body, (0, 580),
(0, 580))
centreRotation4 = pymunk.PinJoint(body, rotation_center_body, (390, 580),
(390, 580))
space.add(body, centreRotation, centreRotation2, centreRotation3,
centreRotation4)
space.add(l1, l2, l3, l4, l5, l6, l7, l8, l9)
def add_rot(self):
rotation_center_body = pymunk.Body(body_type=pymunk.Body.STATIC)
rotation_center_body.position = (500, 410)
# 1st rotation
body = pymunk.Body(10, 10000)
body.position = (500, 410)
l1 = pymunk.Segment(body, (-55, 0), (55.0, 0.0), 2.0)
# 2nd rotation
rotation_center_body2 = pymunk.Body(body_type=pymunk.Body.STATIC)
rotation_center_body2.position = (770, 410)
body2 = pymunk.Body(10, 10000)
body2.position = (770, 410)
l2 = pymunk.Segment(body2, (-55, 0), (55.0, 0.0), 2.0)
rotation_center_joint = pymunk.PinJoint(body, rotation_center_body,
(0, 0), (0, 0))
rotation_center_joint2 = pymunk.PinJoint(body2, rotation_center_body2,
(0, 0), (0, 0))
tw = pymunk.SimpleMotor(body, rotation_center_body, 0.7)
tw2 = pymunk.SimpleMotor(body2, rotation_center_body2, -0.7)
self.space.add(l1, l2, body, body2, rotation_center_joint,
rotation_center_joint2, tw, tw2)
return l1, l2
def generateSwing(self, config):
# specifies the top of the swing as defined by topPosition
top = pymunk.Body(10, 1000000, pymunk.Body.STATIC)
top.position = Vec2d(*config['topPosition'])
top_shape = pymunk.Poly.create_box(top, (20, 20))
self.space.add(top, top_shape)
joints = [] # list of [body, shape]
pivots = []
for i, j in zip(config['jointLocations'], config['jointMasses']):
'''
Iterate through the list of coordinates as specified by jointLocations,
relative to the top of the swing
'''
point = pymunk.Body(j, 100)
point.position = top.position + Vec2d(*i)
point_shape = pymunk.Segment(point, (0, 0), (0, 0), 5)
# if the first joint, join to the top, otherwise join to the preceding joint
if len(joints) == 0:
pivot = pymunk.PinJoint(top, point, (0, 0))
else:
pivot = pymunk.PinJoint(
joints[-1][0],
point) # selects the body component of the preceding joint
pivot.collide_bodies = False
joints.append([point, point_shape])
pivots.append(pivot)
self.space.add(point, point_shape)
self.space.add(pivot)
return {'rod': joints, 'top': [top, top_shape], 'pivots': pivots}
def genJunctions(self):
self.pin_ra_c = pymunk.PinJoint(self.right_arm.body, self.corpse.body,
(0, 0), (0, 30 * self.size))
self.pin_ra_c_r = pymunk.DampedRotarySpring(self.right_arm.body,
self.right_arm.body_joint,
-0.15, 20000000, 900000)
self.pin_ra_c.error_bias = pow(0.7, 60.0)
self.pin_la_c = pymunk.PinJoint(self.left_arm.body, self.corpse.body,
(0, 0), (0, 30 * self.size))
self.pin_la_c_r = pymunk.DampedRotarySpring(self.left_arm.body,
self.left_arm.body_joint,
-0.15, 20000000, 900000)
self.pin_la_c.error_bias = pow(0.7, 60.0)
self.pin_rl_c = pymunk.PinJoint(self.right_leg.body, self.corpse.body,
(0, 0), (0, 0))
self.pin_rl_c_r = pymunk.DampedRotarySpring(self.right_leg.body,
self.right_leg.body_joint,
-0.15, 20000000, 900000)
self.pin_rl_c.error_bias = pow(0.7, 60.0)
self.pin_ll_c = pymunk.PinJoint(self.left_leg.body, self.corpse.body,
(0, 0), (0, 0))
self.pin_ll_c_r = pymunk.DampedRotarySpring(self.left_leg.body,
self.left_leg.body_joint,
10, 1, 1)
self.pin_ll_c.error_bias = pow(0.7, 60.0)
def car(self, space):
pos = Vec2d(100, 100)
wheel_color = 0.2, 0.86, 0.47
shovel_color = 0.86, 0.47, 0.2
mass = 100
radius = 25
moment = pymunk.moment_for_circle(mass, 20, radius)
wheel1_b = pymunk.Body(mass, moment)
wheel1_s = pymunk.Circle(wheel1_b, radius)
wheel1_s.friction = 1.5
wheel1_s.color = wheel_color
space.add(wheel1_b, wheel1_s)
mass = 100
radius = 25
moment = pymunk.moment_for_circle(mass, 20, radius)
wheel2_b = pymunk.Body(mass, moment)
wheel2_s = pymunk.Circle(wheel2_b, radius)
wheel2_s.friction = 1.5
wheel2_s.color = wheel_color
space.add(wheel2_b, wheel2_s)
mass = 100
size = (50, 30)
moment = pymunk.moment_for_box(mass, size)
chassi_b = pymunk.Body(mass, moment)
chassi_s = pymunk.Poly.create_box(chassi_b, size)
space.add(chassi_b, chassi_s)
vs = [(0, 0), (0, -45), (25, -45)]
shovel_s = pymunk.Poly(chassi_b, vs, transform=pymunk.Transform(tx=85))
shovel_s.friction = 0.5
shovel_s.color = shovel_color
space.add(shovel_s)
wheel1_b.position = pos - (55, 0)
wheel2_b.position = pos + (55, 0)
chassi_b.position = pos + (0, 25)
space.add(
pymunk.PinJoint(wheel1_b, chassi_b, (0, 0), (-25, -15)),
pymunk.PinJoint(wheel1_b, chassi_b, (0, 0), (-25, 15)),
pymunk.PinJoint(wheel2_b, chassi_b, (0, 0), (25, -15)),
pymunk.PinJoint(wheel2_b, chassi_b, (0, 0), (25, 15)),
)
speed = -4
space.add(
pymunk.SimpleMotor(wheel1_b, chassi_b, speed),
pymunk.SimpleMotor(wheel2_b, chassi_b, speed),
)
with self.canvas:
Color(*wheel_color)
wheel1_s.ky = self.ellipse_from_circle(wheel1_s)
Color(*wheel_color)
wheel2_s.ky = self.ellipse_from_circle(wheel2_s)
Color(*shovel_color)
chassi_s.ky = Quad(points=self.points_from_poly(chassi_s))
shovel_s.ky = Triangle(points=self.points_from_poly(shovel_s))
def _agent_grasps(self, arbiter, space, data):
agent = self._get_agent_from_shape(arbiter.shapes[0])
body_part = agent.get_bodypart_from_shape(arbiter.shapes[0])
interacting_entity = self._get_scene_element_from_shape(
arbiter.shapes[1])
if interacting_entity is None:
return True
if body_part.is_grasping and not body_part.is_holding:
body_part.is_holding = True
j_1 = pymunk.PinJoint(body_part.pm_body,
interacting_entity.pm_body, (0, 5), (0, 0))
j_2 = pymunk.PinJoint(body_part.pm_body,
interacting_entity.pm_body, (0, -5), (0, 0))
motor = pymunk.SimpleMotor(body_part.pm_body,
interacting_entity.pm_body, 0)
self.space.add(j_1, j_2, motor)
body_part.grasped = [j_1, j_2, motor]
self._grasped_scene_elements[interacting_entity] = body_part
return True
def car(space):
import pymunk
from pymunk.vec2d import Vec2d
space.gravity = 0, -9.8
pos = Vec2d(300, 200)
wheel_color = 52, 219, 119
shovel_color = 219, 119, 52
mass = 100
radius = 25
moment = pymunk.moment_for_circle(mass, 20, radius)
wheel1_b = pymunk.Body(mass, moment)
wheel1_s = pymunk.Circle(wheel1_b, radius)
wheel1_s.friction = 1.5
wheel1_s.color = wheel_color
space.add(wheel1_b, wheel1_s)
mass = 100
radius = 25
moment = pymunk.moment_for_circle(mass, 20, radius)
wheel2_b = pymunk.Body(mass, moment)
wheel2_s = pymunk.Circle(wheel2_b, radius)
wheel2_s.friction = 1.5
wheel2_s.color = wheel_color
space.add(wheel2_b, wheel2_s)
mass = 100
size = (50, 30)
moment = pymunk.moment_for_box(mass, size)
chassi_b = pymunk.Body(mass, moment)
chassi_s = pymunk.Poly.create_box(chassi_b, size)
space.add(chassi_b, chassi_s)
vs = [(0, 0), (25, -45), (0, -45)]
shovel_s = pymunk.Poly(chassi_b, vs, transform=pymunk.Transform(tx=85))
shovel_s.friction = 0.5
shovel_s.color = shovel_color
space.add(shovel_s)
wheel1_b.position = pos - (55, 0)
wheel2_b.position = pos + (55, 0)
chassi_b.position = pos + (0, 25)
space.add(pymunk.PinJoint(wheel1_b, chassi_b, (0, 0), (-25, -15)),
pymunk.PinJoint(wheel1_b, chassi_b, (0, 0), (-25, 15)),
pymunk.PinJoint(wheel2_b, chassi_b, (0, 0), (25, -15)),
pymunk.PinJoint(wheel2_b, chassi_b, (0, 0), (25, 15)))
speed = 4
space.add(pymunk.SimpleMotor(wheel1_b, chassi_b, speed),
pymunk.SimpleMotor(wheel2_b, chassi_b, speed))
floor = pymunk.Segment(space.static_body, (-100, 100), (1000, 100), 5)
floor.friction = 1.0
space.add(floor)
def mount(self, mountee):
self.mountee = mountee
mount_width = self.chassis.width
mount_height = self.chassis.height
point = (0, CHASSIS_HEIGHT/2)
mountee.on_mount(self.chassis, point)
p5 = pymunk.PinJoint(mountee.body, self.chassis.body, (0,0), (0,CHASSIS_HEIGHT/2))
p6 = pymunk.PinJoint(mountee.body, self.chassis.body, (0,0), (0,CHASSIS_HEIGHT/2))
self.mountee_pins.extend([p5, p6])
badwing.app.physics_engine.space.add(p5, p6)
def car(space):
pos = Vec2d(100, 200)
wheel_color = 52, 219, 119, 255
shovel_color = 219, 119, 52, 255
mass = 100
radius = 25
moment = pymunk.moment_for_circle(mass, 20, radius)
wheel1_b = pymunk.Body(mass, moment)
wheel1_s = pymunk.Circle(wheel1_b, radius)
wheel1_s.friction = 1.5
wheel1_s.color = wheel_color
space.add(wheel1_b, wheel1_s)
mass = 100
radius = 25
moment = pymunk.moment_for_circle(mass, 20, radius)
wheel2_b = pymunk.Body(mass, moment)
wheel2_s = pymunk.Circle(wheel2_b, radius)
wheel2_s.friction = 1.5
wheel2_s.color = wheel_color
space.add(wheel2_b, wheel2_s)
mass = 100
size = (50, 30)
moment = pymunk.moment_for_box(mass, size)
chassi_b = pymunk.Body(mass, moment)
chassi_s = pymunk.Poly.create_box(chassi_b, size)
space.add(chassi_b, chassi_s)
vs = [(0, 0), (25, 45), (0, 45)]
shovel_s = pymunk.Poly(chassi_b, vs, transform=pymunk.Transform(tx=85))
shovel_s.friction = 0.5
shovel_s.color = shovel_color
space.add(shovel_s)
wheel1_b.position = pos - (55, 0)
wheel2_b.position = pos + (55, 0)
chassi_b.position = pos + (0, -25)
space.add(
pymunk.PinJoint(wheel1_b, chassi_b, (0, 0), (-25, -15)),
pymunk.PinJoint(wheel1_b, chassi_b, (0, 0), (-25, 15)),
pymunk.PinJoint(wheel2_b, chassi_b, (0, 0), (25, -15)),
pymunk.PinJoint(wheel2_b, chassi_b, (0, 0), (25, 15)),
)
speed = 4
space.add(
pymunk.SimpleMotor(wheel1_b, chassi_b, speed),
pymunk.SimpleMotor(wheel2_b, chassi_b, speed),
)
def _create_player(self, posx, posy, col):
mass = 10
radius_top = 70
radius_bottom = 50
body_top = pymunk.Body(mass, np.inf)
body_top.position = posx, posy
body_top.max_velocity = 500
shape = pymunk.Circle(body_top, radius_top, (0, 0))
shape.elasticity = 1
shape.friction = 0
self._space.add(body_top, shape)
body_bottom = pymunk.Body(mass, np.inf)
body_bottom.position = posx, posy + (radius_top + radius_bottom) / 2
body_bottom.max_velocity = 500
shape = pymunk.Circle(body_bottom, radius_bottom, (0, 0))
shape.elasticity = 0
shape.friction = 0.2
shape.collision_type = int(col)
self._space.add(body_bottom, shape)
j1 = pymunk.PinJoint(body_top, body_bottom, (20, 0), (-20, 0))
j2 = pymunk.PinJoint(body_top, body_bottom, (-20, 0), (20, 0))
j1.collide_bodies = False
j2.collide_bodies = False
self._space.add(j1, j2)
body_bottom.can_jump = False
body_top.can_jump = False
handler = self._space.add_collision_handler(col, Collision.FLOOR)
def tch_begin(arbiter, space, data):
body_bottom.can_jump = body_top.can_jump = True
return True
def tch_end(arbiter, space, data):
body_bottom.can_jump = body_top.can_jump = False
return True
handler.begin = tch_begin
handler.separate = tch_end
def limit_velocity(body, gravity, damping, dt):
pymunk.Body.update_velocity(body, gravity, damping, dt)
if body.velocity[0] >= 0:
body.velocity = (min(body.max_velocity,
body.velocity[0]), body.velocity[1])
else:
body.velocity = (max(-body.max_velocity,
body.velocity[0]), body.velocity[1])
body_bottom.velocity_func = limit_velocity
body_top.velocity_func = limit_velocity
return {"top": body_top, "bottom": body_bottom}
def do_setup(self):
super().do_setup()
p1 = pymunk.PinJoint(self.back_wheel.body, self.chassis.body, (0,0), (-CHASSIS_WIDTH/2,0))
p2 = pymunk.PinJoint(self.back_wheel.body, self.chassis.body, (0,0), (0,-CHASSIS_HEIGHT/2))
p3 = pymunk.PinJoint(self.front_wheel.body, self.chassis.body, (0,0), (CHASSIS_WIDTH/2,0))
p4 = pymunk.PinJoint(self.front_wheel.body, self.chassis.body, (0,0), (0,-CHASSIS_HEIGHT/2))
self.front_motor = m1 = pymunk.constraint.SimpleMotor(self.front_wheel.body, self.chassis.body, -self.speed)
m1.max_force = 200000
self.back_motor = self.motor = m2 = pymunk.constraint.SimpleMotor(self.back_wheel.body, self.chassis.body, -self.speed)
m2.max_force = 200000
badwing.app.physics_engine.space.add(p1, p2, p3, p4, m1, m2)
def __init__(self, space, base_body, body_pos, length, angle, mass=1, thickness=5):
b = body_pos
dif = (math.sin(angle) * length, math.cos(angle) * length)
v = b + dif
base_dif = body_pos - base_body.position
link_body = pymunk.Body(mass, mass * length * length / 3)
link_body.position = body_pos
self.link = pymunk.Segment(link_body, (0,0), dif, thickness)
self.link.filter = pymunk.ShapeFilter(categories=0b1, mask=0b0)
link_body.moment = pymunk.moment_for_segment(mass, self.link.a, self.link.b, thickness)
link_body.center_of_gravity = (self.link.a + self.link.b)/2.0
base_motor = pymunk.SimpleMotor(base_body, link_body, 0)
base_joint = pymunk.PinJoint(base_body, link_body, base_dif, (0,0))
base_joint.error_bias = 0.0001
base_clamp = pymunk.RotaryLimitJoint(base_body, link_body, (-3*math.pi/4), (3*math.pi/4))
space.add(self.link, link_body, base_motor, base_joint, base_clamp)
print("Body pos: " + str(link_body.position))
print("COG pos: " + str(link_body.center_of_gravity))
print("a" + str(self.link.a))
print("b" + str(self.link.b))
self.motor = base_motor
self.body = link_body
self.start_tip = v
def findJoints(space, beams, numBeams):
foundJoint = False
for bn in range(0, numBeams):
bsx = int(beams[bn].body.position.x)
bex = int(bsx + (math.cos(beams[bn].angle) * beams[bn].length))
for bbn in range(bn+1, numBeams):
if bn == bbn:
continue
bbsx = int(beams[bbn].body.position.x)
bbex = int(bbsx + (math.cos(beams[bbn].angle) * beams[bbn].length))
for bnx in range(bsx, bex):
for bbnx in range(bbsx, bbex):
if bnx == bbnx:
bsy = int(beams[bn].body.position.y)
bey = int(bsy + (math.sin(beams[bn].angle) * beams[bn].length))
bbsy = int(beams[bbn].body.position.y)
bbey = int(bbsy + (math.sin(beams[bbn].angle) * beams[bbn].length))
for bny in range(bey, bsy):
for bbny in range(bbey, bbsy):
if bny == bbny:
space.add(pymunk.PinJoint(beams[bn].body, beams[bbn].body, (bnx, bny), (bnx, bny)))
foundJoint = True
break
if foundJoint:
break
if foundJoint:
break
if foundJoint:
break
if foundJoint:
continue
def on_touch_up(self, touch):
shape = self.space.point_query_first(Vec2d(touch.x, touch.y))
if shape is None:
# print "lel u iz mudi egent or wat? i wll roit ur houze fr da lulz."+\
# " heuhuehhue"
self.clean_up()
else:
self.final_pos = (touch.x, touch.y)
self.body2 = shape.body
if self.init_pos is None:
self.clean_up()
return
if utils.distance(self.init_pos, self.final_pos) < 10:
self.clean_up()
return
if self.body1 is self.body2:
self.clean_up()
return
ix, iy = self.init_pos
fx, fy = self.final_pos
x1, y1 = self.body1.position.x, self.body1.position.y
x2, y2 = self.body2.position.x, self.body2.position.y
anchr1 = (ix - x1, iy - y1)
anchr2 = (fx - x2, fy - y2)
joint = cymunk.PinJoint(self.body1, self.body2, anchr1, anchr2)
joint.color = self.color
self.space.add(joint)
self.clean_up()
def add_arm(self, segment_lengths, anchor_position):
anchor = pymunk.Body(body_type=pymunk.Body.STATIC)
anchor.position = anchor_position
self.space.add(anchor)
segment_anchor = anchor
next_anchor_pos = anchor_position
for i, segment_length in enumerate(segment_lengths):
segment_size = segment_length, 10
segment_body = pymunk.Body(10, pymunk.moment_for_box(10, segment_size))
end_effector_shape = pymunk.Poly.create_box(segment_body, segment_size)
end_effector_shape.collision_type = NO_COLLISION_TYPE
end_effector_shape.friction = 1.0
end_effector_shape.elasticity = 0.1
alpha = random.random() * math.pi * 2
dx = np.cos(alpha) * segment_length / 2
dy = np.sin(alpha) * segment_length / 2
segment_body.position = next_anchor_pos[0] - dx, next_anchor_pos[1] - dy
next_anchor_pos = (next_anchor_pos[0] - 2 * dx, next_anchor_pos[1] - 2 * dy)
segment_body.angle = alpha
anchor_pin_pos = (0 if i == 0 else -segment_lengths[i - 1] / 2, 0)
pin = pymunk.PinJoint(segment_anchor, segment_body, anchor_pin_pos, (segment_length / 2, 0))
self.space.add(pin)
self.space.add(segment_body, end_effector_shape)
motor = pymunk.SimpleMotor(segment_anchor, segment_body, 0)
motor.max_force = self.max_motor_force
self.space.add(motor)
self.motors.append(motor)
self.segment_bodies.append(segment_body)
segment_anchor = segment_body
return segment_anchor, next_anchor_pos
def create_joints(self, space):
self.joints = [
pymunk.PinJoint(self.wheel1_body, self.chassi_body, (0, 0),
(-15, -5)),
pymunk.PinJoint(self.wheel1_body, self.chassi_body, (0, 0),
(0, -5)),
pymunk.PinJoint(self.wheel2_body, self.chassi_body, (0, 0),
(0, -5)),
pymunk.PinJoint(self.wheel2_body, self.chassi_body, (0, 0),
(15, -5)),
pymunk.PivotJoint(self.chassi_body, self.turret_body, (0, 10),
(0, 0))
]
for joint in self.joints:
joint.collide_bodies = False
space.add(joint)
def add_L(space):
#Create the rotation center body to act as a static point in the joint
#so that the line can rotate around it. NO SHAPE/Collision hull added to it
rotation_center_body = pymunk.Body(body_type=pymunk.Body.STATIC)
rotation_center_body.position = (250, 250)
#Create a static body to limit the motion
rotation_limit_body = pymunk.Body(body_type=pymunk.Body.STATIC)
rotation_limit_body.position = (100, 250)
#The L shape to be added to the screen is not static anymore
#mass 10 and random moment wrt the rotation center
body = pymunk.Body(10, 10000)
body.position = (250, 250)
#Create the lines
l1 = pymunk.Segment(body, (-150, 0), (100, 0), 5)
l2 = pymunk.Segment(body, (-150, 0), (-150, 50), 5)
#Joint functions take in
#1st body, 2nd body, 1st body joint location, 2nd_body joint location
#Create a pinjoint between body and rotation_center_body
rotation_center_joint = pymunk.PinJoint(body, rotation_center_body, (0, 0),
(0, 0))
#Create a slidejoint between body and rotation_center_body
#joint_limit defines the min and max the body will slide wrt to each other
joint_limit = 50
rotation_limit_joint = pymunk.SlideJoint(body, rotation_limit_body,
(-150, 0), (0, 0), 0, joint_limit)
space.add(l1, l2, body, rotation_center_joint, rotation_limit_joint)
return l1, l2
def generateSwing(self, config):
###################### Top of the swing ##############################
top = pymunk.Body(10, 1000000, pymunk.Body.STATIC)
top.position = Vec2d(
*config['topPosition']
) #specifies the top of the swing as defined by topPosition from the config file
top_shape = pymunk.Poly.create_box(
top, (20, 20)) #position of the centre of the top of the swing
self.space.add(top, top_shape)
for i, j in zip(config['jointLocations'], config['jointMasses']):
'''
Takes the coordinates as specified by jointLocation and mass from jointMasses
'''
###################### Connecting joint between swing and seat ##############################
point = pymunk.Body(j, 1000)
point.position = top.position + Vec2d(*i)
point_shape = pymunk.Segment(point, (0, 0), (0, 0), 0)
pivot = pymunk.PinJoint(top, point, (0, 0))
self.space.add(point, point_shape)
self.space.add(pivot)
return {
'rod': [point, point_shape],
'top': [top, top_shape],
'pivots': [pivot]
}
def generatePerson(self):
body = pymunk.Body(
0.75 * self.mass, 100000000000000
) # assumes the body from the quads up make up 75% of mass
body.position = self.pos
legs = pymunk.Body(0.25 * self.mass, 100)
legs.position = self.pos
torso_shape = pymunk.Segment(body, (0, 0), (0, -30), 3)
bottom_shape = pymunk.Segment(body, (0, 0), (20, 0), 3)
legs_shape = pymunk.Segment(legs, (20, 0), (20, 20), 3)
knee_joint = pymunk.PinJoint(legs, body, (20, 0), (20, 0))
knee_motor = pymunk.SimpleMotor(legs, body, 0)
knee_joint.collide_bodies = False
self.space.add(body, torso_shape, bottom_shape, legs, legs_shape,
knee_joint, knee_motor)
return {
'body': [(body, torso_shape, legs_shape), (legs, legs_shape)],
'pivots': [knee_joint, knee_motor]
}
def create_world(self):
fp = [(self.tray_width / 2, -self.tray_height / 2),
(-self.tray_width / 2, self.tray_height / 2),
(self.tray_width / 2, self.tray_height / 2),
(-self.tray_width / 2, -self.tray_height / 2),
(-self.tray_width / 2, -self.tray_height / 2)]
mass = 100
moment = pymunk.moment_for_poly(mass, fp[0:2])
self.trayBody = pymunk.Body(mass, moment)
self.trayBody.position = self.tray_x_pos, self.tray_y_pos
self.trayBody.angle = self.tray_angle
trayShape = pymunk.Poly(self.trayBody, fp)
if self.tray_has_ends:
side1 = [(self.tray_width / 2, self.tray_height / 2),
(self.tray_width / 2, self.tray_height * 4),
(self.tray_width / 2 - 1, self.tray_height * 4),
(self.tray_width / 2 - 1, self.tray_height / 2)]
side2 = [(-self.tray_width / 2, self.tray_height / 2),
(-self.tray_width / 2, self.tray_height * 4),
(-self.tray_width / 2 + 1, self.tray_height * 4),
(-self.tray_width / 2 + 1, -self.tray_height / 2)]
self.side1_shape = pymunk.Poly(self.trayBody, side1)
self.side2_shape = pymunk.Poly(self.trayBody, side2)
self.space.add(self.side1_shape, self.side2_shape)
self.space.add(self.trayBody, trayShape)
trayJointBody = pymunk.Body(body_type=pymunk.Body.KINEMATIC)
trayJointBody.position = self.trayBody.position
j = pymunk.PinJoint(self.trayBody, trayJointBody, (0, 0), (0, 0))
self.space.add(j)
self.__add_ball()
def add_L(space):
"""Add a inverted L shape with two joints"""
plate_body = pymunk.Body(10, 10000)
plate_body.position = (300,300)
plate = pymunk.Segment(plate_body, (-150, 0), (150.0, 0.0), 3.0)
beam_body = pymunk.Body(10, 10000)
beam_body.position = (200,250)
beam = pymunk.Segment(beam_body, (0, -50), (0, 50), 1.0)
# l1 = pymunk.Segment(body, (-150, 0), (255.0, 0.0), 3.0)
# l2 = pymunk.Segment(body, (-150.0, 0), (-150.0, 50.0), 3.0)
# beam_center_body = pymunk.Body(body_type = pymunk.Body.STATIC)
# beam_center_body.position = (200,300)
# beam_center_joint = pymunk.PinJoint(plate_body, beam_body, (0,0), (0,0))
rotation_center_body = pymunk.Body(body_type = pymunk.Body.STATIC)
rotation_center_body.position = (300,300)
rotation_center_joint = pymunk.PinJoint(plate_body, rotation_center_body, (0,0), (0,0))
# rotation_limit_body = pymunk.Body(body_type = pymunk.Body.STATIC)
# rotation_limit_body.position = (200,300)
# joint_limit = 25
# rotation_limit_joint = pymunk.SlideJoint(body, rotation_limit_body, (-100,0), (0,0), 0, joint_limit)
space.add(plate, plate_body, beam, beam_body, rotation_center_body)
return plate_body
def __init__(self,
arm_anchor_point,
arm_segment_lengths,
target_position,
do_render=False,
sparse=True,
sparse_distance=SPARSE_DISTANCE):
super().__init__(do_render, sparse, MAX_MOTOR_FORCE)
self.sparse_distance = sparse_distance
self.target_position = target_position
self.space.gravity = (0.0, 0.0)
self.end_effector_body = None
end_anchor, end_pos = self.add_arm(arm_segment_lengths,
arm_anchor_point)
self.end_effector_body = pymunk.Body(1, 1)
self.end_effector_body.position = end_pos[0], end_pos[1]
end_effector_shape = Circle(self.end_effector_body, 8)
end_effector_shape.collision_type = NO_COLLISION_TYPE
self.space.add(self.end_effector_body, end_effector_shape)
pin = pymunk.PinJoint(end_anchor, self.end_effector_body,
(-arm_segment_lengths[-1] / 2, 0), (0, 0))
self.space.add(pin)
def add_L(space):
"""Add a inverted L shape with two joints"""
rotation_center_body = pymunk.Body(body_type=pymunk.Body.STATIC)
rotation_center_body.position = (300, 300)
rotation_limit_body = pymunk.Body(body_type=pymunk.Body.STATIC)
rotation_limit_body.position = (200, 300)
body = pymunk.Body(10, 10000)
body.position = (300, 300)
l1 = pymunk.Segment(body, (-150, 0), (255.0, 0.0), 5.0)
l2 = pymunk.Segment(body, (-150.0, 0), (-150.0, -50.0), 5.0)
l1.friction = 1
l2.friction = 1
l1.mass = 1
l2.mass = 1
rotation_center_joint = pymunk.PinJoint(body, rotation_center_body, (0, 0),
(0, 0))
joint_limit = 25
rotation_limit_joint = pymunk.SlideJoint(body, rotation_limit_body,
(-100, 0), (0, 0), 0, joint_limit)
space.add(l1, l2, body, rotation_center_joint) #, rotation_limit_joint)
return l1, l2
def spider_create(space):
pos = Vec2d(100, 200)
first_arm_color = 0, 0, 0
second_arm_color = 50, 50, 50
wheel_color = 52, 219, 119
mass = 100
radius = 10
moment = pymunk.moment_for_circle(mass, 20, radius)
wheel1_b = pymunk.Body(mass, moment)
wheel1_s = pymunk.Circle(wheel1_b, radius)
wheel1_s.friction = 1.5
wheel1_s.color = wheel_color
space.add(wheel1_b, wheel1_s)
mass = 100
radius = 10
moment = pymunk.moment_for_circle(mass, 20, radius)
wheel2_b = pymunk.Body(mass, moment)
wheel2_s = pymunk.Circle(wheel2_b, radius)
wheel2_s.friction = 1.5
wheel2_s.color = wheel_color
space.add(wheel2_b, wheel2_s)
mass = 100
size = (50, 30)
moment = pymunk.moment_for_box(mass, size)
chassi_b = pymunk.Body(mass, moment)
chassi_s = pymunk.Poly.create_box(chassi_b, size)
space.add(chassi_b, chassi_s)
wheel1_b.position = pos - (55, 0)
wheel2_b.position = pos + (55, 0)
chassi_b.position = pos + (0, -25)
space.add(pymunk.PinJoint(wheel1_b, chassi_b, (0, 0), (-25, -15)),
pymunk.PinJoint(wheel1_b, chassi_b, (0, 0), (-25, 15)),
pymunk.PinJoint(wheel2_b, chassi_b, (0, 0), (25, -15)),
pymunk.PinJoint(wheel2_b, chassi_b, (0, 0), (25, 15)))
first_arm = pymunk.Segment(chassi_b, (25, -15), (30, -40), 2)
space.add(first_arm)
speed = 4
space.add(pymunk.SimpleMotor(wheel1_b, chassi_b, speed),
pymunk.SimpleMotor(wheel2_b, chassi_b, speed))
def __init__(self,
mass=DEFAULT_MASS,
position=(G_SCREEN_WIDTH / 2, G_SCREEN_HEIGHT / 4)):
self._fuel = 500
self.force = DEFAULT_FORCE
self.wheels = []
self.flying_missiles = []
# Anti-spacecraft wheels
self.wheel1_b, self.wheel1_s = self.create_body(
mass,
(position[0] - ANTI_SPACECRAFT_CHASSIS[0] / 1.5, position[1]),
ANTI_SPACECRAFT_WHEEL_SIZE)
self.wheel2_b, self.wheel2_s = self.create_body(
mass,
(position[0] + ANTI_SPACECRAFT_CHASSIS[0] / 1.5, position[1]),
ANTI_SPACECRAFT_WHEEL_SIZE)
self.wheels.extend((self.wheel1_b, self.wheel2_b))
# Anti-spacecraft chassis
self.chassis_b, self.chassis_s = self.create_body(
mass / 5, position, ANTI_SPACECRAFT_CHASSIS)
self.chassis_s.color = 255, 155, 0
# Create cannon
self.cannon_b, self.cannon_s = self.create_body(
0.01, (position[0] - ANTI_SPACECRAFT_CHASSIS[0] / 2,
position[1] + ANTI_SPACECRAFT_CHASSIS[1] / 2),
ANTI_SPACECRAFT_CANNON)
# Create missiles
self.missile_body, self.missile_shape = self.create_missile()
# Anti-spacecraft joints
# TODO: Use for-loop (?)
self.pin1 = pymunk.PinJoint(self.wheel1_b, self.chassis_b, (0, 0),
(-ANTI_SPACECRAFT_CHASSIS[0] / 2, 0))
self.pin2 = pymunk.PinJoint(self.wheel2_b, self.chassis_b, (0, 0),
(ANTI_SPACECRAFT_CHASSIS[0] / 2, 0))
self.pin3 = pymunk.PinJoint(self.wheel1_b, self.chassis_b, (0, 0),
(0, ANTI_SPACECRAFT_CHASSIS[1] / 2))
self.pin4 = pymunk.PinJoint(self.wheel2_b, self.chassis_b, (0, 0),
(0, ANTI_SPACECRAFT_CHASSIS[1] / 2))
self.pin5 = pymunk.PinJoint(self.wheel1_b, self.chassis_b, (0, 0),
(0, -ANTI_SPACECRAFT_CHASSIS[1] / 2))
self.pin6 = pymunk.PinJoint(self.wheel2_b, self.chassis_b, (0, 0),
(0, -ANTI_SPACECRAFT_CHASSIS[1] / 2))
self.pin7 = pymunk.PinJoint(self.wheel2_b, self.chassis_b, (0, 0),
(0, -ANTI_SPACECRAFT_CHASSIS[1] / 2))
self.pin8 = pymunk.PinJoint(self.cannon_b, self.chassis_b,
(ANTI_SPACECRAFT_CANNON[0] / 2, 0),
(0, ANTI_SPACECRAFT_CHASSIS[1] / 2))
self.cannon_mt = pymunk.SimpleMotor(self.cannon_b, self.chassis_b, 0)
self.cannon_mt.collide_bodies = False
def __init__(self):
moment = pymunk.moment_for_box(100, (100, 30))
self.body = pymunk.Body(100, moment)
self.shape = pymunk.Poly.create_box(self.body, (100, 30))
self.body.position = (1200, 200)
self.shape.body = self.body
self.shape.color = (150, 150, 0, 255)
space.add(self.body, self.shape)
wheel_moment = pymunk.moment_for_circle(100, 20, 25)
self.wheel1_body = pymunk.Body(100, wheel_moment)
self.wheel1_body.position = self.body.position + (-80, -20)
self.wheel1_shape = pymunk.Circle(self.wheel1_body, 25)
self.wheel1_shape.friction = 1.5
self.wheel1_shape.color = (200, 200, 200)
self.wheel1_joint = pymunk.PinJoint(self.body, self.wheel1_body,
(-50, 0), (0, 0))
self.wheel1_joint2 = pymunk.PinJoint(self.body, self.wheel1_body,
(-50, -15), (0, 0))
self.wheel1_motor = pymunk.SimpleMotor(self.wheel1_body, self.body, -5)
space.add(self.wheel1_body, self.wheel1_shape, self.wheel1_joint,
self.wheel1_joint2, self.wheel1_motor)
wheel_moment = pymunk.moment_for_circle(100, 20, 25)
self.wheel2_body = pymunk.Body(100, wheel_moment)
self.wheel2_body.position = self.body.position + (80, -20)
self.wheel2_shape = pymunk.Circle(self.wheel2_body, 25)
self.wheel2_shape.friction = 1.5
self.wheel2_shape.color = (200, 200, 200)
self.wheel2_joint = pymunk.PinJoint(self.body, self.wheel2_body,
(50, 0), (0, 0))
self.wheel2_joint2 = pymunk.PinJoint(self.body, self.wheel2_body,
(50, -15), (0, 0))
self.wheel2_motor = pymunk.SimpleMotor(self.wheel2_body, self.body, -5)
space.add(self.wheel2_body, self.wheel2_shape, self.wheel2_joint,
self.wheel2_joint2, self.wheel2_motor)
self.human = pygame.image.load('human.png')
self.human = pygame.transform.scale(self.human, (100, 150))
self.huk = pygame.image.load('huk.png')
self.huk = pygame.transform.scale(self.huk, (100, 150))
self.is_dead = False
self.catch = 0
def __init__(self):
c1 = Circle((100, 100), 30)
c2 = Circle((300, 100), 30)
b = Rectangle((200, 150), size=(100, 60), color=GREEN)
j0 = pymunk.PinJoint(c1.body, b.body, (0, 0), (-50, -30))
j0.color = RED
j1 = pymunk.PinJoint(c1.body, b.body, (0, 0), (-50, 30))
j1.color = BLUE
j2 = pymunk.PinJoint(c2.body, b.body, (0, 0), (50, -30))
j3 = pymunk.PinJoint(c2.body, b.body, (0, 0), (50, 30))
App.current.space.add(j0, j1, j2, j3)
speed = -1
App.current.space.add(pymunk.SimpleMotor(c1.body, b.body, speed),
pymunk.SimpleMotor(c2.body, b.body, speed))
def grasp(self, grasped_element: SceneElement):
j_1 = pymunk.PinJoint(self.part.pm_body, grasped_element.pm_body,
(0, 0), (0, 20))
j_2 = pymunk.PinJoint(self.part.pm_body, grasped_element.pm_body,
(0, 0), (0, -20))
j_3 = pymunk.PinJoint(self.part.pm_body, grasped_element.pm_body,
(0, 20), (0, 0))
j_4 = pymunk.PinJoint(self.part.pm_body, grasped_element.pm_body,
(0, -20), (0, 0))
self._grasp_joints = [j_1, j_2, j_3, j_4]
self.part.pm_body.space.add(*self._grasp_joints)
self.grasped_element = grasped_element
grasped_element.held_by = self
def main():
pygame.init()
screen = pygame.display.set_mode((1000, 1000))
pygame.display.set_caption("Ball moving")
clock = pygame.time.Clock()
space = pymunk.Space()
space.gravity = (0.0, 0.0)
objects = []
draw_options = pymunk.pygame_util.DrawOptions(screen)
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(300,700)
y_pos = random.randint(300,700)
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)
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)
space.step(1/50.0)
screen.fill((255,255,255))
# 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)
space.debug_draw(draw_options)
pygame.display.flip()
clock.tick(50)
