def static_ball(space, pos):
body = pymunk.Body(body_type=pymunk.Body.STATIC)
body.position = pos
shape = pymunk.Circle(body, 5)
space.add(body, shape)
return shape
def start(self):
super(SphereCollider, self).start()
body = self.gameobject._body
shape = pymunk.Circle(body, self.radius)
self.add_shape_to_space(shape)
def create_apple(space):
body = pymunk.Body(1, 100, body_type=pymunk.Body.DYNAMIC)
body.position = (400, 0)
shape = pymunk.Circle(body, 80)
space.add(body, shape)
return shape
def run():
# setup visualization and user input
window = pyglet.window.Window(width=600, height=600, visible=False)
keyboard = key.KeyStateHandler()
window.push_handlers(keyboard)
# help text
label = pyglet.text.Label('ESC: quit, arrow-keys: move',
font_size=20,
x=window.width // 2,
y=window.height // 20,
anchor_x='center',
anchor_y='center')
# build simulation environment
env = pymunk.Space()
# build Rob the robot
rob_mass = 1 # 1 kg
rob_radius = 0.1 * M_TO_PIXELS # 0.1 meter radius, converted to pixels for display
rob_I = pymunk.moment_for_circle(rob_mass, 0,
rob_radius) # moment of inertia for disk
rob_body = pymunk.Body(rob_mass, rob_I)
rob_body.position = 300, 300
rob_shape = pymunk.Circle(rob_body, rob_radius)
rob_shape.color = 255, 0, 0 # red
# add Rob to the simulation
env.add(rob_body, rob_shape)
# define how to draw the visualization
@window.event
def on_draw():
# always clear and redraw for graphics programming
window.clear()
label.draw()
pymunk.pyglet_util.draw(rob_shape) # this is gold right here
# use keyboard to control Rob
def process_user_input(dt):
angular_vel = 0.2 * 2 * pi # rotations/sec -> radians/second
angular_delta = angular_vel * dt
linear_speed = 0.6 # m/s
distance = linear_speed * dt * M_TO_PIXELS # m/s * s -> pixels
# calculate linear displacement before updating rotation
heading = unit_direction_vector(rob_body.angle)
displacement = tuple([distance * x
for x in heading]) # a discrete "jump" in space
# direction
if keyboard[key.RIGHT]:
rob_body.angle -= angular_delta
if keyboard[key.LEFT]:
rob_body.angle += angular_delta
if keyboard[key.UP]:
rob_body.position += displacement
if keyboard[key.DOWN]:
rob_body.position -= displacement
# update simulation at regular interval
pyglet.clock.schedule_interval(env.step, 1.0 / 60)
# process input at regular interval
pyglet.clock.schedule_interval(process_user_input, 1.0 / 60)
# start simulation
window.set_visible(True)
pyglet.app.run()
screen = pygame.display.set_mode(SIZE) clock = pygame.time.Clock() space = pymunk.Space() space.gravity = 0, 0 space.damping = 0.5 options = DrawOptions(screen) mass = 1 radius = 30 circle_moment = pymunk.moment_for_circle(mass, 0, radius) circle_body = pymunk.Body(mass, circle_moment, body_type=pymunk.Body.KINEMATIC) circle_body.position = WIDTH // 5, 100 circle_shape = pymunk.Circle(circle_body, radius) space.add(circle_body, circle_shape) poly_shape = pymunk.Poly.create_box(None, size=(50, 50)) poly_moment = pymunk.moment_for_poly(mass, poly_shape.get_vertices()) poly_body = pymunk.Body(mass, poly_moment) poly_shape.body = poly_body poly_body.position = 2 * WIDTH // 5, 100 space.add(poly_body, poly_shape) segment_moment = pymunk.moment_for_segment(mass, (0, 0), (0, 400), 2) segment_body = pymunk.Body(mass, segment_moment) segment_shape = pymunk.Segment(segment_body, (0, 0), (0, 400), 2) segment_shape.sensor = True segment_body.position = 3 * WIDTH // 5, 100 space.add(segment_body, segment_shape)
def testArea(self):
c = p.Circle(None, 5)
self.assertEqual(c.area, 78.53981633974483)
config = pyglet.gl.Config(sample_buffers=1, samples=2, double_buffer=True)
window = pyglet.window.Window(config=config, vsync = False)
space = pymunk.Space()
space.gravity = 0,-900
space.damping = .999
c = Vec2d(window.width /2., window.height / 2.)
### WEB
web_group = 1
bs = []
dist = .3
cb = pymunk.Body(1,1)
cb.position = c
s = pymunk.Circle(cb, 15) # to have something to grab
s.filter = pymunk.ShapeFilter(group = web_group)
s.ignore_draw = True
space.add(cb, s)
#generate each crossing in the net
for x in range(0,101):
b = pymunk.Body(1, 1)
v = Vec2d.unit()
v.angle_degrees = x*18
scale = window.height / 2. / 6. * .5
dist += 1/18.
dist = dist ** 1.005
def testElasticity(self):
b1 = p.Body(1, 1)
c = p.Circle(b1, 1)
self.assertEqual(c.elasticity, 0)
c.elasticity = 1
self.assertEqual(c.elasticity, 1)
def testFriction(self):
b1 = p.Body(1, 1)
c = p.Circle(b1, 1)
self.assertEqual(c.friction, 0)
c.friction = 1
self.assertEqual(c.friction, 1)
pymunk.pygame_util.positive_y_is_up = True
background_image=pygame.image.load("../rsc/Backgrounds/Desert.png").convert()
background_image = pygame.transform.scale(background_image, size )
static_body = space.static_body
#Ball
mass = 10
radius = 25
inertia = pymunk.moment_for_circle(mass, 0, radius, (0, 0))
body = pymunk.Body(mass, inertia)
body.position = 50, size[1]-50
shape = pymunk.Circle(body, radius, (0, 0))
shape.elasticity = 0.95
shape.friction = 0.9
space.add(body, shape)
image = pygame.image.load("../Pilot/running/frame_0.png")
dt = 1.0 / 60.0
physics_steps_per_frame = 1
#Floor
static_line = pymunk.Segment(static_body, (0, 0), ( size[0],0), 2.0)
static_line.elasticity = 0.95
static_line.friction = 0.9
space.add(static_line)
def testSensor(self):
b1 = p.Body(1, 1)
c = p.Circle(b1, 1)
self.assertFalse(c.sensor)
c.sensor = True
self.assertTrue(c.sensor)
def fill_space(space, custom_color=(255, 255, 0, 255)):
captions = []
### Static
captions.append(((50, 680), "Static Shapes"))
#Static Segments
segments = [
pymunk.Segment(space.static_body, (10, 400), (10, 600), 0),
pymunk.Segment(space.static_body, (20, 400), (20, 600), 1),
pymunk.Segment(space.static_body, (30, 400), (30, 600), 3),
pymunk.Segment(space.static_body, (50, 400), (50, 600), 5)
]
space.add(segments)
b = pymunk.Body(body_type=pymunk.Body.STATIC)
b.position = (40, 630)
b.angle = 3.14 / 7
s = pymunk.Segment(b, (-30, 0), (30, 0), 2)
space.add(s)
# Static Circles
b = pymunk.Body(body_type=pymunk.Body.STATIC)
b.position = (120, 630)
s = pymunk.Circle(b, 10)
space.add(s)
b = pymunk.Body(body_type=pymunk.Body.STATIC)
b.position = (120, 630)
s = pymunk.Circle(b, 10, (-30, 0))
space.add(s)
b = pymunk.Body(body_type=pymunk.Body.STATIC)
b.position = (120, 560)
b.angle = 3.14 / 4
s = pymunk.Circle(b, 40)
space.add(s)
# Static Polys
b = pymunk.Body(body_type=pymunk.Body.STATIC)
b.position = (120, 460)
b.angle = 3.14 / 4
s = pymunk.Poly(b, [(0, -25), (30, 25), (-30, 25)])
space.add(s)
b = pymunk.Body(body_type=pymunk.Body.STATIC)
b.position = (120, 500)
t = pymunk.Transform(ty=-100)
s = pymunk.Poly(b, [(0, -25), (30, 25), (-30, 25)], t, radius=3)
space.add(s)
b = pymunk.Body(body_type=pymunk.Body.STATIC)
b.position = (50, 430)
t = pymunk.Transform(ty=-100)
s = pymunk.Poly(b,
[(0.0, -30.0), (19.0, -23.0), (30.0, -5.0), (26.0, 15.0),
(10.0, 28.0), (-10.0, 28.0), (-26.0, 15.0), (-30.0, -5.0),
(-19.0, -23.0)], t)
space.add(s)
### Kinematic
captions.append(((220, 680), "Kinematic Shapes"))
# Kinematic Segments
b = pymunk.Body(body_type=pymunk.Body.KINEMATIC)
segments = [
pymunk.Segment(b, (180, 400), (180, 600), 0),
pymunk.Segment(b, (190, 400), (190, 600), 1),
pymunk.Segment(b, (200, 400), (200, 600), 3),
pymunk.Segment(b, (220, 400), (220, 600), 5)
]
space.add(segments)
b = pymunk.Body(body_type=pymunk.Body.KINEMATIC)
b.position = (210, 630)
b.angle = 3.14 / 7
s = pymunk.Segment(b, (-30, 0), (30, 0), 2)
space.add(s)
# Kinematic Circles
b = pymunk.Body(body_type=pymunk.Body.KINEMATIC)
b.position = (290, 630)
s = pymunk.Circle(b, 10)
space.add(s)
b = pymunk.Body(body_type=pymunk.Body.KINEMATIC)
b.position = (290, 630)
s = pymunk.Circle(b, 10, (-30, 0))
space.add(s)
b = pymunk.Body(body_type=pymunk.Body.KINEMATIC)
b.position = (290, 560)
b.angle = 3.14 / 4
s = pymunk.Circle(b, 40)
space.add(s)
# Kinematic Polys
b = pymunk.Body(body_type=pymunk.Body.KINEMATIC)
b.position = (290, 460)
b.angle = 3.14 / 4
s = pymunk.Poly(b, [(0, -25), (30, 25), (-30, 25)])
space.add(s)
b = pymunk.Body(body_type=pymunk.Body.KINEMATIC)
b.position = (290, 500)
t = pymunk.Transform(ty=-100)
s = pymunk.Poly(b, [(0, -25), (30, 25), (-30, 25)], t, radius=3)
space.add(s)
b = pymunk.Body(body_type=pymunk.Body.KINEMATIC)
b.position = (230, 430)
t = pymunk.Transform(ty=-100)
s = pymunk.Poly(b, [(19.0, -50.0), (30.0, -5.0), (26.0, 15.0),
(10.0, 38.0), (-10.0, 38.0), (-26.0, 15.0),
(-30.0, -5.0), (-19.0, -50.0)], t)
space.add(s)
### Dynamic
captions.append(((390, 680), "Dynamic Shapes"))
#Dynamic Segments
b = pymunk.Body(1, 1)
segments = [
pymunk.Segment(b, (350, 400), (350, 600), 0),
pymunk.Segment(b, (360, 400), (360, 600), 1),
pymunk.Segment(b, (370, 400), (370, 600), 3),
pymunk.Segment(b, (390, 400), (390, 600), 5),
]
space.add(segments)
b = pymunk.Body(1, 1)
b.position = (380, 630)
b.angle = 3.14 / 7
s = pymunk.Segment(b, (-30, 0), (30, 0), 2)
space.add(s)
# Dynamic Circles
b = pymunk.Body(1, 1)
b.position = (460, 630)
s = pymunk.Circle(b, 10)
space.add(s)
b = pymunk.Body(1, 1)
b.position = (460, 630)
s = pymunk.Circle(b, 10, (-30, 0))
space.add(s)
b = pymunk.Body(1, 1)
b.position = (460, 560)
b.angle = 3.14 / 4
s = pymunk.Circle(b, 40)
space.add(s)
# Dynamic Polys
b = pymunk.Body(1, 1)
b.position = (460, 460)
b.angle = 3.14 / 4
s = pymunk.Poly(b, [(0, -25), (30, 25), (-30, 25)])
space.add(s)
b = pymunk.Body(1, 1)
b.position = (460, 500)
s = pymunk.Poly(b, [(0, -25), (30, 25), (-30, 25)],
pymunk.Transform(ty=-100),
radius=3)
space.add(s)
b = pymunk.Body(1, 1)
b.position = (400, 430)
s = pymunk.Poly(b, [(0, -50), (50, 0), (30, 50), (-30, 50), (-50, 0)],
pymunk.Transform(ty=-100))
space.add(s)
###Constraints
# PinJoints
captions.append(((560, 660), "Pin Joints"))
a = pymunk.Body(1, 1)
a.position = (550, 600)
sa = pymunk.Circle(a, 20)
b = pymunk.Body(1, 1)
b.position = (650, 620)
sb = pymunk.Circle(b, 20)
j = pymunk.PinJoint(a, b)
space.add(sa, sb, a, b, j)
a = pymunk.Body(1, 1)
a.position = (550, 550)
sa = pymunk.Circle(a, 20)
b = pymunk.Body(1, 1)
b.position = (650, 570)
sb = pymunk.Circle(b, 20)
j = pymunk.PinJoint(a, b, anchor_a=(0, 20), anchor_b=(0, -20))
space.add(sa, sb, a, b, j)
# SlideJoints
captions.append(((560, 490), "Slide Joint"))
a = pymunk.Body(1, 1)
a.position = (550, 430)
sa = pymunk.Circle(a, 20)
b = pymunk.Body(1, 1)
b.position = (650, 450)
sb = pymunk.Circle(b, 20)
j = pymunk.SlideJoint(a,
b,
anchor_a=(0, 20),
anchor_b=(0, -20),
min=10,
max=30)
space.add(sa, sb, a, b, j)
# PivotJoints
captions.append(((560, 390), "Pivot Joint"))
a = pymunk.Body(1, 1)
a.position = (550, 330)
sa = pymunk.Circle(a, 20)
b = pymunk.Body(1, 1)
b.position = (650, 350)
sb = pymunk.Circle(b, 20)
j = pymunk.PivotJoint(a, b, (600, 320))
space.add(sa, sb, a, b, j)
# GrooveJoints
captions.append(((760, 660), "Groove Joint"))
a = pymunk.Body(1, 1)
a.position = (750, 600)
sa = pymunk.Circle(a, 20)
b = pymunk.Body(1, 1)
b.position = (850, 620)
sb = pymunk.Circle(b, 20)
j = pymunk.GrooveJoint(a, b, (790, 610), (790, 620), (840, 620))
space.add(sa, sb, a, b, j)
# DampedSpring
captions.append(((760, 550), "Damped Spring"))
a = pymunk.Body(1, 1)
a.position = (750, 480)
sa = pymunk.Circle(a, 20)
b = pymunk.Body(1, 1)
b.position = (850, 500)
sb = pymunk.Circle(b, 20)
j = pymunk.DampedSpring(a, b, (0, 0), (0, 10), 100, 1, 1)
space.add(sa, sb, a, b, j)
# DampedRotarySpring
captions.append(((740, 430), "Damped Rotary Spring"))
a = pymunk.Body(1, 1)
a.position = (750, 350)
sa = pymunk.Circle(a, 20)
b = pymunk.Body(1, 1)
b.position = (850, 380)
sb = pymunk.Circle(b, 20)
j = pymunk.DampedRotarySpring(a, b, 10, 1, 1)
space.add(sa, sb, a, b, j)
# RotaryLimitJoint
captions.append(((740, 300), "Rotary Limit Joint"))
a = pymunk.Body(1, 1)
a.position = (750, 220)
sa = pymunk.Circle(a, 20)
b = pymunk.Body(1, 1)
b.position = (850, 250)
sb = pymunk.Circle(b, 20)
j = pymunk.RotaryLimitJoint(a, b, 1, 2)
b.angle = 3
space.add(sa, sb, a, b, j)
# RatchetJoint
captions.append(((740, 170), "Ratchet Joint"))
a = pymunk.Body(1, 1)
a.position = (750, 100)
sa = pymunk.Circle(a, 20)
b = pymunk.Body(1, 1)
b.position = (850, 120)
sb = pymunk.Circle(b, 20)
j = pymunk.RatchetJoint(a, b, 1, 0.1)
b.angle = 3
space.add(sa, sb, a, b, j)
# GearJoint and SimpleMotor omitted since they are similar to the already
# added joints
# TODO: more stuff here :)
### Other
# Objects in custom color
captions.append(((150, 150), "Custom Color (static & dynamic)"))
b = pymunk.Body(body_type=pymunk.Body.STATIC)
b.position = (200, 200)
s = pymunk.Circle(b, 40)
s.color = custom_color
space.add(s)
b = pymunk.Body(1, 1)
b.position = (300, 200)
s = pymunk.Circle(b, 40)
s.color = custom_color
space.add(s)
# Collision
captions.append(((450, 150), "Collisions"))
b = pymunk.Body(body_type=pymunk.Body.STATIC)
b.position = (470, 200)
s = pymunk.Circle(b, 40)
space.add(s)
b = pymunk.Body(1, 1)
b.position = (500, 250)
s = pymunk.Circle(b, 40)
space.add(s)
# Sleeping
captions.append(((50, 150), "Sleeping"))
b = pymunk.Body(1, 1)
b.position = (75, 200)
space.sleep_time_threshold = 0.01
s = pymunk.Circle(b, 40)
space.add(s, b)
b.sleep()
space.step(0.000001)
return captions
def setup(
self,
config: Dict[str, bool],
attack: ProgramType,
defend: ProgramType,
o_attack: ProgramType,
o_defend: ProgramType,
):
"""set up everything"""
# background
self.background: arcade.Texture = arcade.load_texture(
"images/field.jpg")
# pymunk space
self.space: pymunk.Space = pymunk.Space()
self.space.gravity = (0, 0)
# self.space.damping = 0.4
self.space.collision_slop = 0.1
# lists
self.dynamicSpriteList = arcade.SpriteList()
self.arrowsList = arcade.ShapeElementList()
# field elements
body = pymunk.Body(body_type=pymunk.Body.STATIC)
self.space.add(body)
# walls
walls = [
pymunk.Segment(body, (0, 0), (SCREEN_WIDTH, 0), 2.0),
pymunk.Segment(body, (0, 0), (0, SCREEN_HEIGHT), 2.0),
pymunk.Segment(body, (0, SCREEN_HEIGHT),
(SCREEN_WIDTH, SCREEN_HEIGHT), 2.0),
pymunk.Segment(body, (SCREEN_WIDTH, SCREEN_HEIGHT),
(SCREEN_WIDTH, 0), 2.0),
]
for line in walls:
line.friction = 0.7
line.elasticity = 0.6
line.filter = pymunk.ShapeFilter(categories=1)
self.space.add(*walls)
# goals
goals = [
pymunk.Segment(body, (180, 78), (SCREEN_WIDTH - 180, 78),
2.0), # yellow crossbar
pymunk.Segment(
body,
(180, SCREEN_HEIGHT - 78),
(SCREEN_WIDTH - 180, SCREEN_HEIGHT - 78),
2.0,
), # blue crossbar
pymunk.Segment(body, (180, 60), (SCREEN_WIDTH - 180, 60), 2.0),
pymunk.Segment(body, (180, 78), (180, 60), 2.0),
pymunk.Segment(body, (SCREEN_WIDTH - 180, 78),
(SCREEN_WIDTH - 180, 60), 2.0),
pymunk.Segment(
body,
(180, SCREEN_HEIGHT - 60),
(SCREEN_WIDTH - 180, SCREEN_HEIGHT - 60),
2.0,
),
pymunk.Segment(body, (180, SCREEN_HEIGHT - 78),
(180, SCREEN_HEIGHT - 60), 2.0),
pymunk.Segment(
body,
(SCREEN_WIDTH - 180, SCREEN_HEIGHT - 78),
(SCREEN_WIDTH - 180, SCREEN_HEIGHT - 60),
2.0,
),
]
for idx, line in enumerate(goals):
line.elasticity = 0.9
if idx < 2:
line.friction = 0.2
line.filter = pymunk.ShapeFilter(categories=2)
else:
line.friction = 1
line.filter = pymunk.ShapeFilter(categories=1)
self.space.add(*goals)
# white lines around the field
self.fieldLines = [
pymunk.Segment(body, (77, 77), (77, SCREEN_HEIGHT - 77), 4.0),
pymunk.Segment(
body,
(77, SCREEN_HEIGHT - 77),
(SCREEN_WIDTH - 77, SCREEN_HEIGHT - 77),
4.0,
),
pymunk.Segment(
body,
(SCREEN_WIDTH - 77, SCREEN_HEIGHT - 77),
(SCREEN_WIDTH - 77, 77),
4.0,
),
pymunk.Segment(body, (SCREEN_WIDTH - 77, 77), (77, 77), 4.0),
]
for line in self.fieldLines:
line.filter = pymunk.ShapeFilter(categories=4)
line.collision_type = 3
self.space.add(*self.fieldLines)
# penalty area lines
self.penaltyLines = [
pymunk.Circle(body, 40, (210, 110)),
pymunk.Circle(body, 40, (210, SCREEN_HEIGHT - 110)),
pymunk.Circle(body, 40, (SCREEN_WIDTH - 210, 110)),
pymunk.Circle(body, 40, (SCREEN_WIDTH - 210, SCREEN_HEIGHT - 110)),
pymunk.Segment(body, (171, 77), (171, 112), 4.0),
pymunk.Segment(body, (211, 152), (SCREEN_WIDTH - 211, 152), 4.0),
pymunk.Segment(body, (SCREEN_WIDTH - 171, 77),
(SCREEN_WIDTH - 171, 112), 4.0),
pymunk.Segment(body, (171, SCREEN_HEIGHT - 77),
(171, SCREEN_HEIGHT - 112), 4.0),
pymunk.Segment(
body,
(211, SCREEN_HEIGHT - 152),
(SCREEN_WIDTH - 211, SCREEN_HEIGHT - 152),
4.0,
),
pymunk.Segment(
body,
(SCREEN_WIDTH - 171, SCREEN_HEIGHT - 77),
(SCREEN_WIDTH - 171, SCREEN_HEIGHT - 112),
4.0,
),
]
for line in self.penaltyLines:
line.filter = pymunk.ShapeFilter(categories=4)
line.collision_type = 3
self.space.add(*self.penaltyLines)
# robots
self.robots = [
Robot(
"images/robot.png",
0.02176,
2.1,
SCREEN_WIDTH / 2,
SCREEN_HEIGHT * 17 / 40,
orientation=0,
),
Robot(
"images/robot.png",
0.02176,
2.1,
SCREEN_WIDTH / 2,
SCREEN_HEIGHT / 6,
orientation=0,
),
Robot(
"images/enemy.png",
0.01611170784103114930182599355532,
2.1,
SCREEN_WIDTH / 2,
SCREEN_HEIGHT * 7 / 10,
),
Robot(
"images/enemy.png",
0.01611170784103114930182599355532,
2.1,
SCREEN_WIDTH / 2,
SCREEN_HEIGHT * 5 / 6,
),
]
for i in range(4):
self.dynamicSpriteList.append(self.robots[i].sprite)
self.robots[i].sprite.shape.filter = pymunk.ShapeFilter(
categories=8, mask=pymunk.ShapeFilter.ALL_MASKS() ^ 0b100)
self.robots[i].sprite.shape.collision_type = 1
self.j1 = pymunk.constraints.PivotJoint(
self.robots[i].targetPointBody,
self.robots[i].sprite.body,
(0, 0),
(0, 0),
)
self.j1.max_force = 7000
self.j1.max_bias = 0
self.j2 = pymunk.constraints.GearJoint(
self.robots[i].targetPointBody, self.robots[i].sprite.body, 0,
1)
self.j2.max_force = 50000
self.space.add(
self.robots[i].sprite.body,
self.robots[i].sprite.shape,
self.j1,
self.j2,
)
# ball
self.ball = PymunkSprite(
"images/ball.png",
0.01897533206831119544592030360531,
0.07,
SCREEN_WIDTH / 2,
SCREEN_HEIGHT / 2,
)
self.dynamicSpriteList.append(self.ball)
self.ball.shape.filter = pymunk.ShapeFilter(
categories=16, mask=pymunk.ShapeFilter.ALL_MASKS() ^ 0b110)
self.ball.shape.collision_type = 2
self.space.add(self.ball.body, self.ball.shape)
self.ballAngle = 0
self.j1 = pymunk.constraints.PivotJoint(self.space.static_body,
self.ball.body, (0, 0), (0, 0))
self.j1.max_force = 10
self.j1.max_bias = 0
self.j2 = pymunk.constraints.GearJoint(self.space.static_body,
self.ball.body, 0, 1)
self.j2.max_force = 1000
self.space.add(self.j1, self.j2)
# programs
self.pconfig = config
self.attack = attack
self.defend = defend
self.o_attack = o_attack
self.o_defend = o_defend
def create_falling_balls(space, pos):
body = pymunk.Body(1, 100, body_type=pymunk.Body.DYNAMIC)
body.position = pos
shape = pymunk.Circle(body, 4)
space.add(body, shape)
return shape
def testMass(self):
c = p.Circle(None, 1)
self.assertEqual(c.mass, 0)
c.mass = 2
self.assertEqual(c.mass, 2)
def testSurfaceVelocity(self):
b1 = p.Body(1, 1)
c = p.Circle(b1, 1)
self.assertEqual(c.surface_velocity, (0, 0))
c.surface_velocity = (1, 2)
self.assertEqual(c.surface_velocity, (1, 2))
def testDensity(self):
c = p.Circle(None, 1)
self.assertEqual(c.density, 0)
c.density = 2
self.assertEqual(c.density, 2)
def testCollisionType(self):
b1 = p.Body(1, 1)
c = p.Circle(b1, 1)
self.assertEqual(c.collision_type, 0)
c.collision_type = 1
self.assertEqual(c.collision_type, 1)
def testNoBody(self):
c = p.Circle(None, 1)
self.assertEqual(c.body, None)
def testFilter(self):
b1 = p.Body(1, 1)
c = p.Circle(b1, 1)
self.assertEqual(c.filter, p.ShapeFilter(0, 0xffffffff, 0xffffffff))
c.filter = p.ShapeFilter(1, 0xfffffff2, 0xfffffff3)
self.assertEqual(c.filter, p.ShapeFilter(1, 0xfffffff2, 0xfffffff3))
def add_objects(space):
### Static
#Static Segments
segments = [ pymunk.Segment(space.static_body, (10, 50), (10, 500), 1)
,pymunk.Segment(space.static_body, (30, 50), (30, 500), 2)
,pymunk.Segment(space.static_body, (50, 50), (50, 500), 3)
,pymunk.Segment(space.static_body, (70, 50), (70, 500), 5)
]
space.add(segments)
b = pymunk.Body()
b.position = (40,530)
b.angle = 3.14/7
s = pymunk.Segment(b, (-30,0), (30,0), 2)
space.add(s)
# Static Circles
b = pymunk.Body()
b.position = (150,500)
s = pymunk.Circle(b, 10)
space.add(s)
b = pymunk.Body()
b.position = (150,500)
s = pymunk.Circle(b, 10,(0,-30))
space.add(s)
b = pymunk.Body()
b.position = (150,400)
b.angle = 3.14/4
s = pymunk.Circle(b, 40)
space.add(s)
# Static Polys
b = pymunk.Body()
b.position = (150,300)
b.angle = 3.14/4
s = pymunk.Poly(b, [(0, -50),(30, 50),(-30, 50)])
space.add(s)
b = pymunk.Body()
b.position = (150,300)
b.angle = 3.14/2
s = pymunk.Poly(b, [(0, -50),(30, 50),(-30, 50)], (-100,0), radius=3)
space.add(s)
b = pymunk.Body()
b.position = (150,200)
s = pymunk.Poly(b, [(0, -50), (50, 0), (30, 50),(-30, 50),(-50, 0)], (0,-100))
space.add(s)
### Dynamic
#Dynamic Segments
b = pymunk.Body(1,1)
segments = [ pymunk.Segment(b, (210, 50), (210, 500), 1)
,pymunk.Segment(b, (230, 50), (230, 500), 2)
,pymunk.Segment(b, (250, 50), (250, 500), 3)
,pymunk.Segment(b, (270, 50), (270, 500), 5)
]
space.add(segments)
b = pymunk.Body(1,1)
b.position = (240,530)
b.angle = 3.14/7
s = pymunk.Segment(b, (-30,0), (30,0), 2)
space.add(s)
# Dynamic Circles
b = pymunk.Body(1,1)
b.position = (350,500)
s = pymunk.Circle(b, 10)
space.add(s)
b = pymunk.Body(1,1)
b.position = (350,500)
s = pymunk.Circle(b, 10,(0,-30))
space.add(s)
b = pymunk.Body(1,1)
b.position = (350,400)
b.angle = 3.14/4
s = pymunk.Circle(b, 40)
space.add(s)
# Dynamic Polys
b = pymunk.Body(1,1)
b.position = (350,300)
b.angle = 3.14/4
s = pymunk.Poly(b, [(0, -50),(30, 50),(-30, 50)])
space.add(s)
b = pymunk.Body(1,1)
b.position = (350,300)
b.angle = 3.14/2
s = pymunk.Poly(b, [(0, -50),(30, 50),(-30, 50)], (-100,0), radius=3)
space.add(s)
b = pymunk.Body(1,1)
b.position = (350,200)
s = pymunk.Poly(b, [(0, -50), (50, 0), (30, 50),(-30, 50),(-50, 0)], (0,-100))
space.add(s)
###Constraints
# PinJoints
a = pymunk.Body(1,1)
a.position = (450,530)
b = pymunk.Body(1,1)
b.position = (550,530)
j = pymunk.PinJoint(a,b)
space.add(a,b,j)
a = pymunk.Body(1,1)
a.position = (450,480)
b = pymunk.Body(1,1)
b.position = (550,480)
j = pymunk.PinJoint(a,b, anchr1=(0,20), anchr2=(0,-20))
space.add(a,b,j)
# SlideJoints
a = pymunk.Body(1,1)
a.position = (450,430)
b = pymunk.Body(1,1)
b.position = (550,430)
j = pymunk.SlideJoint(a,b, anchr1=(0,20), anchr2=(0,-20), min=10,max=30)
space.add(a,b,j)
# TODO: more stuff here :)
### Other
# Object not drawn by draw_space
b = pymunk.Body()
b.position = (500,250)
s = pymunk.Circle(b, 40)
s.ignore_draw = True
space.add(s)
# Objects in custom color
b = pymunk.Body()
b.position = (500,200)
s = pymunk.Circle(b, 40)
s.color = (255, 255, 0)
space.add(s)
b = pymunk.Body(1, 1)
b.position = (500, 100)
s = pymunk.Circle(b, 30)
s.color = (255, 255, 0)
space.add(s)
def testOffset(self):
c = p.Circle(None, 5, (1, 2))
self.assertEqual(c.offset, (1, 2))
def init_coins(space, coords_black, coords_white, coord_red, passthrough):
# Adds coins to the board at the given coordinates
Coins = []
inertia = pymunk.moment_for_circle(Coin_Mass, 0, Coin_Radius, (0, 0))
for coord in coords_black:
# shape.elasticity=1
#body.position = i
body = pymunk.Body(Coin_Mass, inertia)
body.position = coord
shape = pymunk.Circle(body, Coin_Radius, (0, 0))
shape.elasticity = Coin_Elasticity
shape.color = Black_Coin_Color
mask = pymunk.ShapeFilter.ALL_MASKS ^ passthrough.filter.categories
sf = pymunk.ShapeFilter(mask=mask)
shape.filter = sf
shape.collision_type = 2
space.add(body, shape)
Coins.append(shape)
del body
del shape
# body.apply_force_at_world_point((-1000,-1000),body.position)
# shape.elasticity=1
#body.position = i
for coord in coords_white:
body = pymunk.Body(Coin_Mass, inertia)
body.position = coord
shape = pymunk.Circle(body, Coin_Radius, (0, 0))
shape.elasticity = Coin_Elasticity
shape.color = White_Coin_Color
mask = pymunk.ShapeFilter.ALL_MASKS ^ passthrough.filter.categories
sf = pymunk.ShapeFilter(mask=mask)
shape.filter = sf
shape.collision_type = 2
space.add(body, shape)
Coins.append(shape)
del body
del shape
# body.apply_force_at_world_point((-1000,-1000),body.position)
for coord in coord_red:
body = pymunk.Body(Coin_Mass, inertia)
body.position = coord
shape = pymunk.Circle(body, Coin_Radius, (0, 0))
shape.elasticity = Coin_Elasticity
shape.color = Red_Coin_Color
mask = pymunk.ShapeFilter.ALL_MASKS ^ passthrough.filter.categories
sf = pymunk.ShapeFilter(mask=mask)
shape.filter = sf
shape.collision_type = 2
space.add(body, shape)
Coins.append(shape)
del body
del shape
return Coins
def testOffsetUnsafe(self):
c = p.Circle(None, 5, (1, 2))
c.unsafe_set_offset((3, 4))
self.assertEqual(c.offset, (3, 4))
def __init__(self, **kwargs):
"""
Instantiate an obstacle with the following parameters
:param pos: 2d tuple or 'random', position of the fruit
:param environment: the environment calling the creation of the fruit
"""
super(Obstacle, self).__init__(**kwargs)
self.shape = kwargs['shape']
assert self.shape in ['circle', 'rectangle', 'composite'], "Unknown shape " + self.shape
# Define shape parameters
if self.shape == 'circle':
self.radius = kwargs['radius']
# Test the value of the radius. The diameter of the object has to be at least the maximum spread of
# the sensors otherwise the agents might oversee the object
assert self.radius >= 5, "The radius of an obstacle should be at least 5."
elif self.shape == 'rectangle':
self.width = kwargs['width']
self.length = kwargs['length']
# Test the value of the width and length. The width and length of the object have to be at least the
# maximum spread of the sensors otherwise the agents might oversee the object
assert self.width >= 10, "The width of an obstacle should be at least 10."
assert self.length >= 10, "The length of an obstacle should be at least 10."
elif self.shape == 'composite':
self.obstacles = []
for obstacle_parameters in kwargs['obstacles']:
obstacle_parameters = obstacle_parameters.copy()
obstacle_parameters['environment'] = self.env
obstacle_parameters['position'] = (
self.x + obstacle_parameters['position'][0],
self.y + obstacle_parameters['position'][1]
)
obstacle_parameters['angle'] += self.angle
self.obstacles.append(Obstacle(**obstacle_parameters))
# Create shape, the body is static
if self.shape == 'circle':
shape = pymunk.Circle(
self.env.space.static_body,
self.radius,
offset=(self.x, self.y)
)
shape.friction = 1.
shape.group = 1
shape.collision_type = 1
self.env.space.add(shape)
elif self.shape == 'rectangle':
shape = pymunk.Poly(
self.env.space.static_body,
[
(
self.x + .5 * (self.length * math.cos(self.angle) - self.width * math.sin(self.angle)),
self.y + .5 * (self.length * math.sin(self.angle) + self.width * math.cos(self.angle)),
),
(
self.x + .5 * (self.length * math.cos(self.angle) + self.width * math.sin(self.angle)),
self.y + .5 * (self.length * math.sin(self.angle) - self.width * math.cos(self.angle)),
),
(
self.x - .5 * (self.length * math.cos(self.angle) - self.width * math.sin(self.angle)),
self.y - .5 * (self.length * math.sin(self.angle) + self.width * math.cos(self.angle)),
),
(
self.x - .5 * (self.length * math.cos(self.angle) + self.width * math.sin(self.angle)),
self.y - .5 * (self.length * math.sin(self.angle) - self.width * math.cos(self.angle)),
),
]
)
shape.friction = 1.
shape.group = 1
shape.collision_type = 1
self.env.space.add(shape)
def testRadius(self):
c = p.Circle(None, 5)
self.assertEqual(c.radius, 5)
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 testRadiusUnsafe(self):
c = p.Circle(None, 5)
c.unsafe_set_radius(3)
self.assertEqual(c.radius, 3)
def testPointQueryNearestWithShapeFilter(self):
s = p.Space()
b1 = p.Body(1, 1)
s1 = p.Circle(b1, 10)
s.add(s1)
tests = [
{
"c1": 0b00,
"m1": 0b00,
"c2": 0b00,
"m2": 0b00,
"hit": 0
},
{
"c1": 0b01,
"m1": 0b01,
"c2": 0b01,
"m2": 0b01,
"hit": 1
},
{
"c1": 0b10,
"m1": 0b01,
"c2": 0b01,
"m2": 0b10,
"hit": 1
},
{
"c1": 0b01,
"m1": 0b01,
"c2": 0b11,
"m2": 0b11,
"hit": 1
},
{
"c1": 0b11,
"m1": 0b00,
"c2": 0b11,
"m2": 0b00,
"hit": 0
},
{
"c1": 0b00,
"m1": 0b11,
"c2": 0b00,
"m2": 0b11,
"hit": 0
},
{
"c1": 0b01,
"m1": 0b10,
"c2": 0b10,
"m2": 0b00,
"hit": 0
},
{
"c1": 0b01,
"m1": 0b10,
"c2": 0b10,
"m2": 0b10,
"hit": 0
},
{
"c1": 0b01,
"m1": 0b10,
"c2": 0b10,
"m2": 0b01,
"hit": 1
},
{
"c1": 0b01,
"m1": 0b11,
"c2": 0b00,
"m2": 0b10,
"hit": 0
},
]
for test in tests:
f1 = p.ShapeFilter(categories=test["c1"], mask=test["m1"])
f2 = p.ShapeFilter(categories=test["c2"], mask=test["m2"])
s1.filter = f1
hit = s.point_query_nearest((0, 0), 0, f2)
self.assertEqual(
hit != None, test["hit"],
"Got {}!=None, expected {} for test: {}".format(
hit, test["hit"], test))
for i in range(len(loaded) - 1):
p0 = plus(pos, loaded[i])
p1 = plus(pos, loaded[i + 1])
segment = pymunk.Segment(static, p0, p1, SEGMENT_THICKNESS)
segment.elasticity = 2 #TODO: how bouncy?
segment.friction = TERRAIN_FRICTION
segment.color = (40, 40, 150)
segment.collision_type = collision_types['water']
space.add(segment)
if type_ == 'MagnetNode':
body = pymunk.Body(body_type=pymunk.Body.KINEMATIC)
radius = loads_coord(node['radius'])
strength = loads_coord(node['strength'])
magnet = pymunk.Circle(body, radius, pos)
magnet.filter = pass_filter
magnet.sensor = True
magnet.color = (200, 200, 200)
magnet.collision_type = collision_types['magnet']
magnets.append((pos, radius, strength))
space.add(magnet)
if type_ == 'KillSawNode':
body = pymunk.Body(body_type=pymunk.Body.KINEMATIC)
radius = loads_coord(node['radius'])
saw = pymunk.Circle(body, radius, pos)
saw.filter = solid_filter
saw.elasticity = TERRAIN_ELASTICITY
saw.friction = TERRAIN_FRICTION
saw.color = (150, 150, 150)
