def __init__(self, parent, position, walking_task): self.walking_task = walking_task (w, l) = walking_task.leg_length / 5.0, walking_task.leg_length mass = w * l * 0.2 # Upper leg upperleg = pymunk.Body(mass, pymunk.moment_for_box(mass, w, l)) upperleg.position = pymunk.Vec2d(parent.position) + pymunk.Vec2d(position) + pymunk.Vec2d(0, l/2.0 - w/2.0) shape = pymunk.Poly.create_box(upperleg, (w,l)) shape.group = 1 shape.friction = 2.0 # Joints pos = pymunk.Vec2d(parent.position) + pymunk.Vec2d(position) hip = Joint(parent, upperleg, pos, (-0.1*pi, 0.9*pi), self.walking_task.max_rate) walking_task.space.add(hip.pivot, hip.motor, hip.limit, upperleg, shape) # Lower leg lowerleg = pymunk.Body(mass, pymunk.moment_for_box(mass, w, l * 1.2)) lowerleg.position = pymunk.Vec2d(upperleg.position) + pymunk.Vec2d(0, l - w/2.0) shape = pymunk.Poly.create_box(lowerleg, (w, l * 1.2)) shape.group = 1 shape.friction = 2.0 # Joints pos = pymunk.Vec2d(upperleg.position) + pymunk.Vec2d(0, l/2.0 - w/2.0) knee = Joint(upperleg, lowerleg, pos, (-0.9*pi, 0.1*pi), self.walking_task.max_rate) walking_task.space.add(knee.pivot, knee.motor, knee.limit, lowerleg, shape) self.upperleg = upperleg self.lowerleg = lowerleg self.hip = hip self.knee = knee
def __init__(self, name, width = 0, height = 0, oType = 'loi'): self.name = name self.type = oType if width == 0 or height == 0: mass = 1 radius = 0.5 inertia = pymunk.moment_for_circle(mass, 0, radius) self.body = pymunk.Body(mass, inertia) self.shape = pymunk.Circle(self.body, radius) self.dim = (1,1) else: mass = 1 radius = 0.5 inertia = pymunk.moment_for_box(mass, width, height) self.body = pymunk.Body(mass, inertia) verts = [(-width/2,-height/2), (width/2,-height/2), (width/2, height/2), (-width/2,height/2)] self.shape = pymunk.Poly(self.body,verts) self.shape.friction = 0.01 self.shape.elasticity = 0.0 self.dim = (width,height)
def __init__(self, world, position, width=1.6, length=4.0, tire_width=.25, tire_length=.8, skidmarks=None, body_density=1.0): mass = width * length * body_density inertia = moment_for_box(mass, width, length) self.world = world body = Body(mass, inertia, ) body.position = position shape = Poly.create_box(body, size=(width, length)) super(Car, self).__init__(world, body, shape) slot_density = .01 slot_radius = .1 slot_mass = slot_density * (slot_radius ** 2) * pi slot_inertia = moment_for_circle(slot_mass, 0.0, slot_radius) #self.slot = Body(slot_mass, slot_inertia) flpos = position[0] - width / 2.0 - tire_width * 2, position[1] + length / 2.0 self.front_left = Tire(self, flpos, tire_width, tire_length, skidmarks=skidmarks, powered=False, density=body_density) frpos = position[0] + width / 2.0 + tire_width * 2, position[1] + length / 2.0 self.front_right = Tire(self, frpos, tire_width, tire_length, skidmarks=skidmarks, powered=False, density=body_density) rlpos = position[0] - width / 2.0 - tire_width * 2, position[1] - length / 2.0 self.rear_left = Tire(self, rlpos, tire_width * 1.5, tire_length, steerable=False, skidmarks=skidmarks, density=body_density) rrpos = position[0] + width / 2.0 + tire_width * 2, position[1] - length / 2.0 self.rear_right = Tire(self, rrpos, tire_width * 1.5, tire_length, steerable=False, skidmarks=skidmarks, density=body_density) self.tires = [self.front_left, self.front_right, self.rear_left, self.rear_right]
def handle_hanging(self, shape): logger.info('loading hanging %s', shape) # assert(not shape.body.is_static) shape.cache_bb() bb = shape.bb rect = pygame.Rect((bb.left, bb.top, bb.right - bb.left, bb.top - bb.bottom)) rect.normalize() shape.layers = 3 shape.collision_type = 0 # shape.body.velocity_func = ignore_gravity shape.body.mass = 1 shape.body.moment = pymunk.moment_for_box(1, rect.width, rect.height) anchor1 = shape.body.position - (0, 0) joint = pymunk.PivotJoint(self.space.static_body, shape.body, anchor1, (0, 0)) self.space.add(joint) s = pygame.Surface((rect.width, rect.height)) s.fill((255, 255, 255)) spr = sprite.BoxSprite(shape) spr.original_surface = resources.images['hanging'] m = models.BasicModel() m.sprite = spr
def __init__(self, space, field_friction, field_observation, initial_pos, size=8, motor_torque=6, friction_scale=0.2, angular_damping=0.9, force_global=False): self.field_friction = field_friction self.field_observation = field_observation self.size = size self.friction_scale = friction_scale self.motor_torque = motor_torque self.angular_damping = angular_damping self.force_global = force_global mass = size ** 2 * 0.2 self.body = body = pymunk.Body(mass, pymunk.moment_for_box(mass, size, size)) body.position = pymunk.Vec2d(initial_pos[0], initial_pos[1]) body.angle = initial_pos[2] self.shape = shape = pymunk.Poly.create_box(body, (size, size)) shape.group = 1 shape.collision_type = 1 space.add(body, shape) self.sensors = [(r, theta) for r in np.linspace(1,4,3) * size * 0.75 for theta in np.linspace(-0.5 * np.pi, 0.5 * np.pi, 5)] self.l = self.r = 0
def _createPhysicsObject(self): """Return a new physics object""" if self.geometry_type == 'circle': inertia = pymunk.moment_for_circle(self.mass, 0, self.radius, (0,0)) else: inertia = pymunk.moment_for_box(self.mass, self.width, self.height) # body = pymunk.Body(self.mass, inertia) body.velocity = self.velocity body.force = self.force # if self.geometry_type == 'circle': shape = pymunk.Circle(body, self.radius, (0,0)) else: #shape = pymunk.Poly(body, [(0, 0), (self.width, 0), # (self.width, self.height), (0, self.height)]) w2, h2 = self.width/2, self.height/2 shape = pymunk.Poly(body, [(-w2,-h2), (+w2, -h2), (+w2, +h2), (-w2, +h2)]) # shape.elasticity = self.elasticity shape.collision_type = 2 shape.group = self.group shape.layers = self.layers shape.friction = self.friction self.shape = shape self.body = body
def car(self, space): pos = Vec2d(100,100) wheel_color = .2,.86,.47 shovel_color = .86,.47,.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 __init__(self, gun_type="pistol"): from time import time # set gun attributes attrs = self._gun_types[gun_type] l = self.length = attrs["length"] t = self.thickness = attrs["thickness"] m = self.mass = attrs["mass"] mo = self.moment = pymunk.moment_for_box(m, l, t) f = self.force = attrs["force"] h = self.handle = attrs["handle"] b = self.bullet = attrs["bullet"] c = self.cooldown = attrs["cooldown"] self.cooldown_timer = time() # timer between shots self.cooldown_timer_end = self.cooldown_timer + self.cooldown # pygame init pygame.sprite.Sprite.__init__(self) self.image = pygame.Surface([l, t]) self.rect = self.image.get_rect() # pymunk init self.body = pymunk.Body(m, mo) self.body_shape = pymunk.Poly(self.body, [(0,0), (0,-t), (l,-t), (l,0)]) self.body_shape.color = pygame.color.THECOLORS["black"] self.body_shape.group = COLLISION_GROUP["character"] self.constraints = []
def addBox(self, actorID, **kwargs): '''Create a box shape and body''' if kwargs['moment'] == -1: kwargs['moment'] = pymunk.moment_for_box(kwargs['mass'], kwargs['size'][0], kwargs['size'][1]) body = self.createBody(kwargs['isStatic'], kwargs['mass'], kwargs['moment'], kwargs['pos']) shape = pymunk.Poly.create_box(body, kwargs['size']) self.addShape(actorID, body, shape, kwargs['elasticity'], kwargs['collisionType'])
def __init__(self, space, name, initpos): self.name = name self.space = space self.body = munk.Body(Block.MASS, munk.moment_for_box(Block.MASS, Block.WIDTH, Block.WIDTH)) w2 = Block.WIDTH / 2 self.verts = [(-w2, -w2), (-w2, w2), (w2, w2), (w2, -w2)] self.shape = munk.Poly(self.body, self.verts) self.space.add(self.body, self.shape) self.body.position = initpos
def __init__(self, space, pos, size): self.points = [] self.points.append(tuple(pos)) self.points.append((pos[0], pos[1] + size[1])) self.points.append((pos[0]+ size[0], pos[1]+size[1])) self.points.append((pos[0]+ size[0], pos[1])) inertia = pymunk.moment_for_box(1, size[0], size[1]) pymunk.Body.__init__(self, 1, inertia) self.shape = pymunk.Poly(self, self.points, util.vectorMult(size, -0.5)) space.add(self, self.shape)
def testGeneral(self): p.version p.inf p.chipmunk_version m = p.moment_for_box(1, 2, 3) self.assertAlmostEqual(m, 1.08333333333) m = p.moment_for_segment(1, Vec2d(-1,0), Vec2d(1,0)) self.assertAlmostEqual(m, 0.33333333333)
def add_box(self, mass=1): radius = 24 inertia = pymunk.moment_for_box(mass, 0, radius) body = pymunk.Body(mass, inertia) x = random.randint(20,600) y = random.randint(20,400) body.position = x, y shape = PymunkShape.square(body, radius) self.space.add(body, shape) return shape
def box(space): global box_y mass = 10 moment = pymunk.moment_for_box(mass, (40,20)) b = pymunk.Body(mass, moment) s = pymunk.Poly.create_box(b, (40,20)) s.friction = 1 b.position = 600,box_y box_y -= 30 space.add(b,s)
def __init__(self, space, position, size, hinge_pos, padding, ang_vel, start, end, image): self.padding = padding padding_left = self.padding[0] padding_bottom = self.padding[1] padding_right = self.padding[2] padding_top = self.padding[3] self.ang_vel = abs(ang_vel) # Refrain from using negative angular velocities, as it may give unexpected results. self.start = start + 57 self.end = end + 57 self.size = size #self.force = force self.space = space mass = 3 self.inertia = pymunk.moment_for_box(mass, size[0], size[1]) self.body = pymunk.Body(mass, self.inertia) self.body.angle = math.radians(start) self.body.position = (position[0]-hinge_pos[0], position[1]-hinge_pos[1]) self.shape = pymunk.Poly.create_box(self.body, size) self.shape.friction = 1 self.shape.group = 2 self.space.add(self.body, self.shape) self.hinge_body = pymunk.Body() self.hinge_body.angle = math.radians(start) + math.radians(57) self.hinge_body.position = self.body.position[0] + hinge_pos[0], self.body.position[1] + hinge_pos[1] pivot = pymunk.constraint.PivotJoint(self.body, self.hinge_body, (hinge_pos), (0,0)) self.space.add(pivot) gear = pymunk.constraint.GearJoint(self.body, self.hinge_body, 1.0, 1.0) self.space.add(gear) self.left = (position[0] - padding_left, position[1] + padding_top) self.bottom = (position[0] - padding_left, position[1]- padding_bottom) self.right = (position[0] + padding_right, position[1]- padding_bottom) self.top = (position[0] + padding_right, position[1] + padding_top) self.bb = pymunk.BB(position[0] - padding_left, #- hinge_pos[0], # left position[1] - padding_bottom, # - hinge_pos[1], # bottom position[0] + padding_right, # - hinge_pos[0], # right position[1] + padding_top, ) # - hinge_pos[1]) # top alpha = 100 self.color = (200,0,0,alpha) self.color2 = (0,200,0,alpha) self.color3 = (200,200,0,alpha) self.sprite = loaders.spriteloader(image, size = size, anchor = ('center','center'), linear_interpolation = True)
def testMomentHelpers(self): m = p.moment_for_circle(1,2,3,(1,2)) self.assertAlmostEqual(m, 11.5) m = p.moment_for_segment(1, (-10,0), (10,0), 1) self.assertAlmostEqual(m, 40.6666666666) m = p.moment_for_poly(1, [(0,0), (10,10), (10,0)], (1,2), 3) self.assertAlmostEqual(m, 98.3333333333) m = p.moment_for_box(1, (2, 3)) self.assertAlmostEqual(m, 1.08333333333)
def car(space): pos = Vec2d(100,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) )
def box(self, space): mass = 10 moment = pymunk.moment_for_box(mass, (40,20)) b = pymunk.Body(mass, moment) s = pymunk.Poly.create_box(b, (40,20)) s.friction = 1 b.position = 600, self.box_y self.box_y += 30 space.add(b,s) with self.canvas: Color(0.2,0.2,0.2) s.ky = Quad(points=self.points_from_poly(s))
def __init__(self, mass, size): super(Box, self).__init__() self.size = size inertia = pymunk.moment_for_box(mass, (size, size)) self.body = pymunk.Body(mass, inertia) shape = pymunk.Poly.create_box(self.body, (size,size)) shape.elasticity = 0.2 shape.friction = 0.7 space.add(self.body, shape) p = self.size / 2 self.vertex_list = pyglet.graphics.vertex_list(4, ("v2f\static", (-p,p, p,p, p,-p, -p,-p))) self.forces = []
def addPhysicsTo(self, actor): """Add physics of a polygon""" w, h = actor.width, actor.height # # Scale the polygon points actual_points = [(px * w - w / 2.0, py * h - h / 2.0) for px, py in self.points] if self.mass: self.body = pymunk.Body(self.mass, moment=pymunk.moment_for_box(self.mass, w, h)) else: self.body = pymunk.Body() self.shape = pymunk.Poly(self.body, actual_points) # super(PolygonSpritePhysics, self).addPhysicsTo(actor)
def __init__(self, space, name, initpos): self.space = space self.name = name self.body = munk.Body(Splinter.MASS, munk.moment_for_box(Splinter.MASS, Splinter.LENGTH, Splinter.BASELINE)) l2 = Splinter.LENGTH / 2 b2 = Splinter.BASELINE / 2 self.verts = [(-l2, -b2), (-l2, b2), (l2, b2), (l2, -b2)] self.shape = munk.Poly(self.body, self.verts) self.space.add(self.body, self.shape) self.body.position = initpos self.lrps = 0. self.rrps = 0.
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 = pymunk.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 add_rectangle(self, x, y, width, height, color=(1, 0, 0)): moment = cy.moment_for_box(100., width, height) body = cy.Body(100, moment) body.position = x, y box = cy.Poly.create_box(body, size=(width, height)) box.elasticity = 0. self.space.add(box, body) widget = ScatterPlane(pos=(0., 0.), size=(width, height)) with widget.canvas: Color(*color) rect = Rectangle(pos=(0, 0), size=(width, height)) self.rects.append((body, widget, rect)) self.add_widget(widget)
def create_entity(self, x, y, pos): entity = self.manager.create_entity() inertia = pm.moment_for_box(constants.PADDLE_MASS, x, y) body = pm.Body(constants.PADDLE_MASS, inertia) body.position.x = pos[0] body.position.y = pos[1] body.angular_velocity_limit = 0 self.manager.add_component(entity, body) shape = pm.Poly.create_box(body, (x, y)) shape.elasticity = 1.3 shape.friction = 0 shape.collision_type = constants.PADDLE_COLLISION_TYPE self.manager.add_component(entity, shape) self.space.add(body, shape) return entity
def __init__(self, space): mass = 20 radius = 24 self.width = radius * 5 self.height = radius inertia = pymunk.moment_for_box(mass, 0, radius) body = pymunk.Body(mass, inertia) x = random.randint(20,600) y = random.randint(20,400) body.position = x, y shape = PymunkShape.rectangle(body, self.width, self.height) space.add(body, shape) self.shape = shape self.body = body self.jetoffset = (12, 12) self.jetspeed = 16
def __init__(self): # load images base_path = "images/blocks/{}.png".format(self.image) self.img = load_image(base_path, self.image_anchor) # create collision object w = h = BLOCK_SIZE inertia = pymunk.moment_for_box(1, w, h) self._body = pymunk.Body(1, inertia) self._body.position = Vec2d(0, 0) self._shape = pymunk.Poly.create_box(self._body, (w, h), radius=0.2) self._shape.collision_type = COLLISION_TYPES['ghost'] self._shape.sensor = True self._shape._get_block = ref(self) SPACE.add(self._body, self._shape) # what can it connect to? self.valid_welds = []
def __init__(self, pos): super(Block, self).__init__() #Import the block image. self.block_img = cocos.sprite.Sprite('brick.png') #Pymunk physics variables. self.verts = [(-15, -15), (-15, 15), (15, 15), (15, -15)] self.mass = 0.1 self.moment = pymunk.moment_for_box(self.mass, 32, 32) self.body = pymunk.Body(self.mass, self.moment) self.body.position = pos self.shape = pymunk.Poly(self.body, self.verts) self.shape.layers = 1 self.shape.collision_type = 4 self.shape.friction = 1
def load_box(tmxobject, map_height, static_body, defaults): """ Creates a pymunk.Poly in the shape of a box from a TiledObject instance and orients it relative to the height of a TiledMap. :param TiledObject tmxobject: A TiledObject instance that represents a box. :param int map_height: The height of the TiledMap that the TiledObject \ was loaded from in pixels. :rtype: pymunk.Poly :return: A pymunk.Poly shape instance. """ box_defaults = defaults["pymunktmx_box"] shape_attrs = get_shape_attrs(tmxobject, box_defaults) body_attrs = get_body_attrs(tmxobject, box_defaults) offset = body_attrs[u"offset"] radius = shape_attrs[u"radius"] shape = None if body_attrs[u"static"]: tl = tmxobject.x, float(map_height) - tmxobject.y tr = tmxobject.x + tmxobject.width, tl[1] bl = tl[0], float(map_height) - (tmxobject.y + tmxobject.height) br = tr[0], bl[1] verts = [tl, bl, br, tr] shape = pymunk.Poly(static_body, verts, offset, radius) else: x = float(tmxobject.x) y = float(float(map_height) - tmxobject.y) mass = body_attrs[u"mass"] tl = 0.0, 0.0 tr = float(tmxobject.width), 0.0 bl = 0, -float(tmxobject.height) br = tr[0], bl[1] verts = [tl, bl, br, tr] moment = pymunk.moment_for_box( mass, tmxobject.height, tmxobject.width) body = pymunk.Body(mass, moment) body.position = (x, y) set_attrs(body_attrs, body, skip_keys=[u"position", u"mass", u"static"]) shape = pymunk.Poly(body, verts, offset, radius) set_attrs(shape_attrs, shape, skip_keys=[u"radius"]) return [shape]
def __init__(self, space, collision_type = 0, group = 0, friction = pymunk.inf, mass = pymunk.inf, width = 0, height = 0, x = 0, y = 0, angle = 0, static = False, *args, **kwargs): super(Entity, self).__init__(*args, **kwargs) # Physics setup self.space = space self._mass = mass self._moment = pymunk.moment_for_box(mass, width, height) # body body = pymunk.Body(self._mass, self._moment) body.position = x, y body.angle = angle # shape hw = width // 2 hh = height // 2 vs = [(-hw, hh), (hw, hh), (hw, -hh), (-hw, -hh)] shape = pymunk.Poly(body, vs) shape.friction = friction shape.collision_type = collision_type space.add(shape) self.pymunk_shape = shape self.pymunk_body = body if static: self._set_static() # force static state update if not static self._static = True self.static = static # allow access the the entity from the shape for body self.pymunk_body.entity = self self.pymunk_shape.entity = self
def __init__(self, run_path, space, screen): self.area = screen.get_rect() self.step = 1 self.direction = utils.Direction.right #self.jumping = False self.walking = False inertia = pymunk.moment_for_box(self.MASS, self.WIDTH, self.HEIGHT) self.body = pymunk.Body(self.MASS, inertia) self.body.position = 100, FLOOR_Y vertices = [(0, 0), (self.WIDTH, 0), (self.WIDTH, self.HEIGHT), (0, self.HEIGHT)] shape = pymunk.Poly(self.body, vertices, offset=(0, 0)) shape.friction = 0.55 space.add(self.body, shape) self.rect = Rect(self.body.position.x, self.body.position.y, self.WIDTH, self.HEIGHT) AnimatedSprite.__init__(self, 'rabbit_sprite.png') # call Sprite intializer
def __init__(self): self.ctx = ModernGL.create_context() ctx = self.ctx self.prog = ctx.program([ ctx.vertex_shader(''' #version 330 uniform vec4 Camera; // Per vertex in vec2 in_vert; in vec2 in_texture; // Per instance in vec3 in_pos; in vec2 in_size; in vec4 in_tint; out vec2 v_vert; out vec2 v_texture; out vec4 v_tint; void main() { mat2 rotate = mat2( cos(in_pos.z), sin(in_pos.z), -sin(in_pos.z), cos(in_pos.z) ); v_vert = rotate * (in_vert * in_size) + in_pos.xy; gl_Position = vec4((v_vert - Camera.xy) / Camera.zw, 0.0, 1.0); v_texture = in_texture; v_tint = in_tint; } '''), ctx.fragment_shader(''' #version 330 uniform sampler2D Texture; in vec2 v_vert; in vec2 v_texture; in vec4 v_tint; out vec4 f_color; void main() { vec4 tex = texture(Texture, v_texture); vec3 color = tex.rgb * (1.0 - v_tint.a) + v_tint.rgb * v_tint.a; f_color = vec4(color, tex.a); } '''), ]) img = Image.open('data/crate.png').convert('RGBA') self.tex1 = ctx.texture(img.size, 4, img.tobytes()) self.tex1.use(0) img = Image.open('data/ball.png').convert('RGBA') self.tex2 = ctx.texture(img.size, 4, img.tobytes()) self.tex2.use(1) vbo1 = ctx.buffer( struct.pack( '16f', -1.0, -1.0, 0.0, 0.0, -1.0, 1.0, 0.0, 1.0, 1.0, -1.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, )) self.vbo2 = ctx.buffer(reserve=1024 * 1024) vao_content = [ (vbo1, '2f2f', ['in_vert', 'in_texture']), (self.vbo2, '3f2f4f/i', ['in_pos', 'in_size', 'in_tint']), ] self.vao = ctx.vertex_array(self.prog, vao_content) self.space = pymunk.Space() self.space.gravity = (0.0, -900.0) shape = pymunk.Segment(self.space.static_body, (5, 100), (595, 100), 1.0) shape.friction = 1.0 self.space.add(shape) x = Vec2d(-270, 7.5) + (300, 100) y = Vec2d(0, 0) deltaX = Vec2d(0.5625, 1.1) * 20 deltaY = Vec2d(1.125, 0.0) * 20 self.bodies = [] self.balls = [] for x in range(5): for y in range(10): size = 20 mass = 10.0 moment = pymunk.moment_for_box(mass, (size, size)) body = pymunk.Body(mass, moment) body.position = Vec2d(300 + x * 50, 105 + y * (size + .1)) shape = pymunk.Poly.create_box(body, (size, size)) shape.friction = 0.3 self.space.add(body, shape) self.bodies.append(body)
def __init__(self, width, height, title): super().__init__(width, height, title) # Set the working directory (where we expect to find files) to the same # directory this .py file is in. You can leave this out of your own # code, but it is needed to easily run the examples using "python -m" # as mentioned at the top of this program. file_path = os.path.dirname(os.path.abspath(__file__)) os.chdir(file_path) arcade.set_background_color(arcade.color.DARK_SLATE_GRAY) # -- Pymunk self.space = pymunk.Space() self.space.iterations = 35 self.space.gravity = (0.0, -900.0) # Lists of sprites or lines self.sprite_list: arcade.SpriteList[PhysicsSprite] = arcade.SpriteList( ) self.static_lines = [] # Used for dragging shapes around with the mouse self.shape_being_dragged = None self.last_mouse_position = 0, 0 self.draw_time = 0 self.processing_time = 0 # Create the floor floor_height = 80 body = pymunk.Body(body_type=pymunk.Body.STATIC) shape = pymunk.Segment(body, [0, floor_height], [SCREEN_WIDTH, floor_height], 0.0) shape.friction = 0.2 shape.elasticity = 0.7 self.space.add(shape) self.static_lines.append(shape) # Create the stacks of boxes for row in range(10): for column in range(10): size = 32 mass = 1.0 x = 500 + column * 32 y = (floor_height + size / 2) + row * size moment = pymunk.moment_for_box(mass, (size, size)) body = pymunk.Body(mass, moment) body.position = pymunk.Vec2d(x, y) shape = pymunk.Poly.create_box(body, (size, size)) shape.elasticity = 0.7 shape.friction = 0.2 self.space.add(body, shape) # body.sleep() sprite = BoxSprite( shape, ":resources:images/tiles/boxCrate_double.png", width=size, height=size) self.sprite_list.append(sprite)
def evaluate(self, network, draw=False): """ Evaluate the efficiency of the given network. Returns the distance that the walker ran in the given time (max_steps). """ if not isinstance(network, NeuralNetwork): network = NeuralNetwork(network) if draw: import pygame pygame.init() screen = pygame.display.set_mode((self.track_length, 200)) pygame.display.set_caption("Simulation") clock = pygame.time.Clock() running = True font = pygame.font.Font(pygame.font.get_default_font(), 8) # Initialize pymunk self.space = space = pymunk.Space() space.gravity = (0.0, 900.0) space.damping = 0.7 self.touching_floor = False # Create objects # Floor floor = pymunk.Body() floor.position = pymunk.Vec2d(self.track_length / 2.0, 210) sfloor = pymunk.Poly.create_box(floor, (self.track_length, 40)) sfloor.friction = 1.0 sfloor.collision_type = 1 space.add_static(sfloor) # Torso torsolength = 20 + (self.num_legs // 2 - 1) * self.leg_spacing mass = torsolength * self.torso_height * self.torso_density torso = pymunk.Body( mass, pymunk.moment_for_box(mass, torsolength, self.torso_height)) torso.position = pymunk.Vec2d( 200, 200 - self.leg_length * 2 - self.torso_height) storso = pymunk.Poly.create_box(torso, (torsolength, self.torso_height)) storso.group = 1 storso.collision_type = 1 storso.friction = 2.0 # space.add_static(storso) space.add(torso, storso) # Legs legs = [] for i in range(self.num_legs // 2): x = 10 - torsolength / 2.0 + i * self.leg_spacing y = self.torso_height / 2.0 - 10 legs.append(Leg(torso, (x, y), self)) legs.append(Leg(torso, (x, y), self)) # Collision callback def oncollide(space, arb): self.touching_floor = True space.add_collision_handler(1, 1, post_solve=oncollide) for step in range(self.max_steps): # Query network input_width = max(len(legs), 4) net_input = np.zeros((3, input_width)) torso_y = torso.position.y torso_a = torso.angle sine = np.sin(step / 10.0) hip_angles = [leg.hip.angle() for leg in legs] knee_angles = [leg.knee.angle() for leg in legs] other = [torso_y, torso_a, sine, 1.0] # Build a 2d input grid, # as in Clune 2009 Evolving Quadruped Gaits, p4 net_input[0, :len(legs)] = hip_angles net_input[1, :len(legs)] = knee_angles net_input[2, :4] = other act = network.feed(net_input, add_bias=False) output = np.clip(act[-self.num_legs * 2:] * self.max_rate, -1.0, 1.0) / 2.0 + 0.5 for i, leg in enumerate(legs): leg.hip.set_target(output[i * 2]) leg.knee.set_target(output[i * 2 + 1]) # Advance simulation space.step(1 / 50.0) # Check for success/failure if torso.position.x < 0: break if torso.position.x > self.track_length - 50: break if self.touching_floor: break # Draw if draw: print(act) # Clear screen.fill((255, 255, 255)) # Do all drawing txt = font.render('%d' % step, False, (0, 0, 0)) screen.blit(txt, (0, 0)) # Draw objects for o in space.shapes + space.static_shapes: if isinstance(o, pymunk.Circle): pygame.draw.circle( screen, (0, 0, 0), (int(o.body.position.x), int(o.body.position.y)), int(o.radius)) else: pygame.draw.lines(screen, (0, 0, 0), True, [(int(p.x), int(p.y)) for p in o.get_points()]) # Flip buffers pygame.display.flip() clock.tick(50) if draw: pygame.quit() distance = torso.position.x # print "Travelled %.2f in %d steps." % (distance, step) return {'fitness': distance}
def __init__(self, body_type=BODY_TYPE_DYNAMIC, mass=1, width=10, height=10, center_of_grav=None, corner_radius=0, transform=None, rotation_lock=False, rotation=(0, 0), density=None, friction=None, elasticity=None, color=None, scene=None, resource_ref_name=None, prefix=None): self.corner_radius = corner_radius * .75 QtGui.QGraphicsRectItem.__init__(self, 0 - self.corner_radius, 0 - self.corner_radius, width + self.corner_radius, height + self.corner_radius, scene=scene) #QtGui.QGraphicsRectItem.__init__(self,-width/2,-height/2,width/2,height/2,scene=scene) #self.graphic=QtGui.QGraphicsPixmapItem(QtGui.QPixmap('./resources/images/car_bod2.png','.png'),scene=scene) #self.graphic.setOffset(0,-40) self.__rotation_lock = rotation_lock self.__rotation_min, self.__rotation_max = rotation self.__color = [0, 0, 0, 255] self.__collison_box_visible = True self.__animator_visible = True bp.blueprint.__init__(self, prefix or 'ch_obj_box') self.__eventManager = bp.eventManager() self.eventManager = self.getEventManager inertia = pm.moment_for_box(mass, (width, height)) self.chipBody = ChipBody(mass, inertia, body_type) pm.Poly.__init__(self, self.chipBody, self.__generate_coords(width, height), transform=transform, radius=corner_radius) self.cog = None if type(center_of_grav) == tuple: self.cog = pm.Vec2d(center_of_grav) else: self.cog = pm.Vec2d(self.center_of_gravity) self.cx, self.cy = self.cog if density: self.density = density if friction: self.friction = friction if elasticity: self.elasticity = elasticity if color: self.__color = color self.setBrushColor(color=color) self.setPenColor(color=color) else: self.setBrushColor(color=self.__color) self.setPenColor(color=self.__color) self.set_ref_name(resource_ref_name) self.add_self_to_catalog() self.animator = animationManager(self, scene) self.hide() self.animator.hide() self.updateChipObject()
def __init__(self, filename, center_x=0, center_y=0, scale=SPRITE_SCALING, mass=DEFAULT_MASS * 2, moment=None, friction=PLAYER_FRICTION, # seeing if its better to use non-default value body_type=pymunk.Body.DYNAMIC): super().__init__(filename, scale=scale, center_x=center_x, center_y=center_y) width = self.texture.width * scale height = self.texture.height * scale if moment is None: moment = pymunk.moment_for_box(mass, (width, height)) self.body = pymunk.Body(mass, moment, body_type=body_type) self.body.position = pymunk.Vec2d(center_x, center_y) self.shape = pymunk.Poly.create_box(self.body, (width * 0.90, height * 0.90,), radius=0.8) # was 0.8 self.shape.friction = friction self.shape.HITCOUNT = -100 self.shape.name = "Player" self.punching = False self.set_hit_box([[-22, -60], [22, -60], [22, 50], [-22, 50]]) # self._collision_radius = 0.5 # Load in monkey textures try: self.textures = [] # TEXTURE_LEFT texture = arcade.load_texture("./images/Char_Monkey_Free_Images/Animations/monkey_walk_1.png", mirrored=True) self.textures.append(texture) # TEXTURE_RIGHT texture = arcade.load_texture("./images/Char_Monkey_Free_Images/Animations/monkey_walk_1.png") self.textures.append(texture) texture = arcade.load_texture("./images/Char_Monkey_Free_Images/Animations/monkey_jump_4.png") self.textures.append(texture) texture = arcade.load_texture("./images/Char_Monkey_Free_Images/Animations/monkey_jump_4.png", mirrored=True) self.textures.append(texture) texture = arcade.load_texture("./images/Char_Monkey_Free_Images/Animations/monkey_armsup.png") self.textures.append(texture) texture = arcade.load_texture("./images/Char_Monkey_Free_Images/Animations/monkey_faceforward.png") self.textures.append(texture) texture = arcade.load_texture("./images/Char_Monkey_Free_Images/Animations/monkey_jump_swing_2.png", mirrored=True) self.textures.append(texture) texture = arcade.load_texture("./images/Char_Monkey_Free_Images/Animations/monkey_jump_swing_2.png") self.textures.append(texture) texture = arcade.load_texture("./images/Char_Monkey_Free_Images/Animations/monkey_armsup_happy.png") self.textures.append(texture) # TEXTURE_LEFT_2 texture = arcade.load_texture("./images/Char_Monkey_Free_Images/Animations/monkey_walk_2.png", mirrored=True) self.textures.append(texture) # TEXTURE_RIGHT_2 texture = arcade.load_texture("./images/Char_Monkey_Free_Images/Animations/monkey_walk_2.png") self.textures.append(texture) # TEXTURE_LEFT_3 texture = arcade.load_texture("./images/Char_Monkey_Free_Images/Animations/monkey_walk_3.png", mirrored=True) self.textures.append(texture) # TEXTURE_RIGHT_3 texture = arcade.load_texture("./images/Char_Monkey_Free_Images/Animations/monkey_walk_3.png") self.textures.append(texture) # TEXTURE_LEFT_4 texture = arcade.load_texture("./images/Char_Monkey_Free_Images/Animations/monkey_walk_4.png", mirrored=True) self.textures.append(texture) # TEXTURE_RIGHT_4 texture = arcade.load_texture("./images/Char_Monkey_Free_Images/Animations/monkey_walk_4.png") self.textures.append(texture) except: logging.error("Unable to load textures") quit(1) self.scale = SPRITE_SCALING
def main(): pygame.init() screen = pygame.display.set_mode((1000, 750)) pygame.display.set_caption("KDC HW2 Parts 5 and 6") clock = pygame.time.Clock() space = pymunk.Space() space.gravity = (0.0, -2000.0) # add floor body = pymunk.Body(body_type=pymunk.Body.STATIC) body.position = (0, 100) floor = pymunk.Segment(body, (-1000, 100), (1000, 100), 1) floor.filter = pymunk.ShapeFilter(mask=pymunk.ShapeFilter.ALL_MASKS ^ 0x1) floor.friction = 1 space.add(floor) # add cart cart_mass = 1 cart_size = (200, 40) cart_moment = pymunk.moment_for_box(cart_mass, cart_size) cart_body = pymunk.Body(cart_mass, cart_moment) cart_body.position = (500, 300) cart_shape = pymunk.Poly.create_box(cart_body, cart_size) cart_shape.color = pygame.color.THECOLORS["red"] cart_shape.filter = pymunk.ShapeFilter(group=1) #add wheels wheel_mass = 0.5 wheel_size = 20 wheel_moment = pymunk.moment_for_circle(wheel_mass, 0, wheel_size) front_wheel_body = pymunk.Body(wheel_mass, wheel_moment) back_wheel_body = pymunk.Body(wheel_mass, wheel_moment) front_wheel_body.position = (575, 260) back_wheel_body.position = (425, 260) front_wheel_shape = pymunk.Circle(front_wheel_body, wheel_size) back_wheel_shape = pymunk.Circle(back_wheel_body, wheel_size) front_wheel_shape.friction = 1 back_wheel_shape.friction = 1 front_wheel_shape.color = pygame.color.THECOLORS["black"] back_wheel_shape.color = pygame.color.THECOLORS["black"] front_wheel_shape.filter = pymunk.ShapeFilter(group=1) back_wheel_shape.filter = pymunk.ShapeFilter(group=1) #add pole pole_mass = 0.1 pole_size = (1, 200) pole_moment = pymunk.moment_for_box(pole_mass, pole_size) pole_body = pymunk.Body(pole_mass, pole_moment) pole_body.position = (500, 220) pole_shape = pymunk.Poly.create_box(pole_body, pole_size) pole_shape.color = pygame.color.THECOLORS["black"] pole_shape.filter = pymunk.ShapeFilter(categories=0x1, group=1) #create joints front_joint = pymunk.constraint.PivotJoint(front_wheel_body, cart_body, (575, 260)) back_joint = pymunk.constraint.PivotJoint(back_wheel_body, cart_body, (425, 260)) pole_joint = pymunk.constraint.PivotJoint(pole_body, cart_body, (500, 320)) #add everything to the world space.add(cart_body, cart_shape, front_wheel_body, front_wheel_shape, back_wheel_body, back_wheel_shape, pole_body, pole_shape, front_joint, back_joint, pole_joint) draw_options = pymunk.pygame_util.DrawOptions(screen) ticks = 0 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) screen.fill((255, 255, 255)) space.debug_draw(draw_options) space.step(1 / 50.0) pygame.display.flip() if ticks == 0: pole_body.apply_impulse_at_local_point((1, 0), (0, 0)) # do control here p = (pole_body.position.x - cart_body.position.x) v = pole_body.velocity_at_local_point((0, 0)).x theta = pole_body.angle dtheta = pole_body.angular_velocity enerr = (0.0125 * (dtheta * dtheta)) - (0.4905 * (1 + math.cos(theta))) a = 7.5 b = 0.25 c = 7.5 d = 1 k = 20 if theta > (math.pi - 0.5) and theta < (math.pi + 0.5): f = (a * p) + (b * v) + (c * (math.pi - theta)) + (d * dtheta) else: f = k * enerr * math.cos(theta) * dtheta cart_body.apply_impulse_at_local_point((f, 0), (0, 0)) ticks += 1 clock.tick(50)
def create_rover(space, x, y): pos = Vec2d(x, y) wheel_color = 0, 0, 0 # first wheel mass = 10 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) sprites.append((wheel1_b, wheel1_s)) # second wheel mass = 10 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) sprites.append((wheel2_b, wheel2_s)) # third wheel mass = 10 radius = 25 moment = pymunk.moment_for_circle(mass, 20, radius) wheel3_b = pymunk.Body(mass, moment) wheel3_s = pymunk.Circle(wheel3_b, radius) wheel3_s.friction = 1.5 wheel3_s.color = wheel_color space.add(wheel3_b, wheel3_s) sprites.append((wheel3_b, wheel3_s)) # chassis mass = 100 size = (50, 30) moment = pymunk.moment_for_box(mass, size) chassis_b = pymunk.Body(mass, moment) chassis_s = pymunk.Poly.create_box(chassis_b, size) space.add(chassis_b, chassis_s) sprites.append((chassis_b, chassis_s)) # plow mass = 50 vertices = [(0, 0), (0, 50), (25, 0)] moment = pymunk.moment_for_poly(mass, vertices) plow_b = pymunk.Body(mass, moment) plow_s = pymunk.Poly(plow_b, vertices) space.add(plow_b, plow_s) sprites.append((plow_b, plow_s)) wheel1_b.position = pos + (-55, 0) wheel2_b.position = pos + (55, 0) wheel3_b.position = pos + (0, 90) chassis_b.position = pos + (0, 30) plow_b.position = pos + (95, -20) space.add(pymunk.PinJoint(wheel1_b, chassis_b, (0, 0), (-25, -15)), pymunk.PinJoint(wheel1_b, chassis_b, (0, 0), (-25, 15)), pymunk.PinJoint(wheel2_b, chassis_b, (0, 0), (25, -15)), pymunk.PinJoint(wheel2_b, chassis_b, (0, 0), (25, 15)), pymunk.PinJoint(wheel3_b, chassis_b, (0, 0), (-25, 15)), pymunk.PinJoint(wheel3_b, chassis_b, (0, 0), (25, 15)), pymunk.PinJoint(chassis_b, plow_b, (25, 25), (0, 50)), pymunk.PinJoint(wheel2_b, plow_b, (0, 0), (0, 0)), pymunk.PinJoint(wheel2_b, plow_b, (0, 0), (0, 50))) speed = 0 motors = [ pymunk.SimpleMotor(wheel1_b, chassis_b, speed), pymunk.SimpleMotor(wheel2_b, chassis_b, speed), pymunk.SimpleMotor(wheel3_b, chassis_b, speed) ] space.add(*motors) return motors, chassis_b
def create_pogo1(space, x, y): pos = Vec2d(x, y) # carriage mass = 100 size = (50, 30) moment = pymunk.moment_for_box(mass, size) carriage_b = pymunk.Body(mass, moment) carriage_s = pymunk.Poly.create_box(carriage_b, size) carriage_s.color = 255, 0, 0 space.add(carriage_b, carriage_s) sprites.append((carriage_b, carriage_s)) # left leg mass = 20 left_leg_b = pymunk.Body(mass) size = (10, 100) left_leg_s = pymunk.Poly.create_box(left_leg_b, size) left_leg_s.color = 255, 0, 0 space.add(left_leg_b, left_leg_s) sprites.append((left_leg_b, left_leg_s)) # right leg mass = 20 right_leg_b = pymunk.Body(mass) size = (10, 100) right_leg_s = pymunk.Poly.create_box(right_leg_b, size) right_leg_s.color = 255, 0, 0 space.add(right_leg_b, right_leg_s) sprites.append((right_leg_b, right_leg_s)) # left wheel mass = 10 radius = 10 moment = pymunk.moment_for_circle(mass, 0, radius) wheel1_b = pymunk.Body(mass, moment) wheel1_s = pymunk.Circle(wheel1_b, radius) wheel1_s.friction = 1.0 wheel1_s.color = 0, 0, 0 space.add(wheel1_b, wheel1_s) sprites.append((wheel1_b, wheel1_s)) # right wheel mass = 10 radius = 10 moment = pymunk.moment_for_circle(mass, 0, radius) wheel2_b = pymunk.Body(mass, moment) wheel2_s = pymunk.Circle(wheel2_b, radius) wheel2_s.friction = 1.0 wheel2_s.color = 0, 0, 0 space.add(wheel2_b, wheel2_s) sprites.append((wheel2_b, wheel2_s)) # stick mass = 20 size = (40, 150) stick_b = pymunk.Body(mass) stick_s = pymunk.Poly.create_box(stick_b, size) stick_s.color = 0, 0, 255 space.add(stick_b, stick_s) sprites.append((stick_b, stick_s)) carriage_b.position = pos + (0, 100) left_leg_b.position = pos + (-25, 50) right_leg_b.position = pos + (25, 50) wheel1_b.position = pos + (-25, -50) wheel2_b.position = pos + (25, -50) stick_b.position = pos + (0, -50) space.add([ pymunk.PinJoint(carriage_b, left_leg_b, (0, 0), (0, 100)), pymunk.PinJoint(carriage_b, left_leg_b, (25, 0), (0, 100)), pymunk.PinJoint(carriage_b, right_leg_b, (0, 0), (0, 100)), pymunk.PinJoint(carriage_b, right_leg_b, (25, 0), (0, 100)), pymunk.PinJoint(left_leg_b, wheel1_b, (5, 0), (0, 0)), pymunk.PinJoint(right_leg_b, wheel2_b, (5, 0), (0, 0)) ]) return carriage_b
def get_moment(self, model): return pymunk.moment_for_box(model.mass, (model.width, model.height))
# setup the space space = pymunk.Space(threaded=True) space.gravity = 0, -9.8 fil = pymunk.ShapeFilter(group=1) # ground ground = pymunk.Segment(space.static_body, (-4, -0.1), (4, -0.1), 0.1) ground.friction = 0.1 ground.filter = fil space.add(ground) # cart cart_mass = 0.5 cart_size = 0.3, 0.2 cart_moment = pymunk.moment_for_box(cart_mass, cart_size) cart_body = pymunk.Body(mass=cart_mass, moment=cart_moment) cart_body.position = 0.0, cart_size[1] / 2 cart_shape = pymunk.Poly.create_box(cart_body, cart_size) cart_shape.friction = ground.friction space.add(cart_body, cart_shape) # pendulum pend_length = 0.6 # to center of mass pend_size = 0.1, pend_length * 2 # to get CoM at 0.6 m pend_mass = 0.2 pend_moment = 0.001 pend_body = pymunk.Body(mass=pend_mass, moment=pend_moment) pend_body.position = cart_body.position[ 0], cart_body.position[1] + cart_size[1] / 2 + pend_length pend_shape = pymunk.Poly.create_box(pend_body, pend_size)
def __init__(self, FPS=60.0, KP=200, KI=50, KD=25): #----------------------------------------------------------------------------------------------------------------------------------- self.FPS = 60.0 # 60 quadros por segundo #----------------------------------------------------------------------------------------------------------------------------------- ambiente = pymunk.Space() ambiente.gravity = 0, -98.1 ##x,y #-------------------------------------------------------------------------------------------------------------------------------piso piso_ponto_A = 0, 0 piso_ponto_B = 640, 0 piso_shape = pymunk.Segment(None, (piso_ponto_A), (piso_ponto_B), 2) piso_momento = pymunk.moment_for_segment(1000, (piso_ponto_A), (piso_ponto_B), 2) piso_fisica = pymunk.Body(1, piso_momento, pymunk.Body.KINEMATIC) piso_shape.body = piso_fisica piso_shape.friction = 0.62 ambiente.add(piso_fisica, piso_shape) #-----------------------------------------------------------------------------------------------------------------------------chassi chassi_posicao = 100, 35 chassi_tamanho = 80, 20 chassi_massa = 30 #gramas chassi_shape = pymunk.Poly.create_box(None, size=chassi_tamanho) chassi_momento = pymunk.moment_for_box(chassi_massa, chassi_tamanho) chassi_fisica = pymunk.Body(chassi_massa, chassi_momento, pymunk.Body.DYNAMIC) chassi_shape.body = chassi_fisica chassi_fisica.position = chassi_posicao chassi_shape.friction = 0.4 ambiente.add(chassi_shape, chassi_fisica) #-------------------------------------------------------------------------------------------------------------------------R_traseira R_traseira_posicao = (chassi_posicao[0] - (chassi_tamanho[0] / 2)) - 20, ( chassi_posicao[1] - 20) R_traseira_massa = 10 R_traseira_raio_in = 10 R_traseira_raio_out = 10 R_traseira_momento = pymunk.moment_for_circle(R_traseira_massa, R_traseira_raio_in, R_traseira_raio_out) R_traseira_fisica = pymunk.Body(R_traseira_massa, R_traseira_momento, pymunk.Body.DYNAMIC) R_traseira_shape = pymunk.Circle(R_traseira_fisica, R_traseira_raio_out) R_traseira_fisica.position = R_traseira_posicao R_traseira_shape.friction = 0.6 ambiente.add(R_traseira_shape, R_traseira_fisica) #------------------------------------------------------------------------------------------------------------------------R_dianteira R_dianteira_posicao = (chassi_posicao[0] + (chassi_tamanho[0] / 2)) + 20, ( chassi_posicao[1] - 20) R_dianteira_massa = 10 R_dianteira_raio_in = 10 R_dianteira_raio_out = 10 R_dianteira_momento = pymunk.moment_for_circle(R_dianteira_massa, R_dianteira_raio_in, R_dianteira_raio_out) R_dianteira_fisica = pymunk.Body(R_dianteira_massa, R_dianteira_momento, pymunk.Body.DYNAMIC) R_dianteira_shape = pymunk.Circle(R_dianteira_fisica, R_dianteira_raio_out) R_dianteira_fisica.position = R_dianteira_posicao R_dianteira_shape.friction = 0.6 ambiente.add(R_dianteira_fisica, R_dianteira_shape) #----------------------------------------------------------------------------------------------------------------------------Pendulo pendulo_posicao = chassi_posicao[0], chassi_posicao[1] + 70 pendulo_massa = 10 pendulo_raio_in = 5 pendulo_raio_out = 5 pendulo_momento = pymunk.moment_for_circle(pendulo_massa, pendulo_raio_in, pendulo_raio_out) pendulo_fisica = pymunk.Body(pendulo_massa, pendulo_momento, pymunk.Body.DYNAMIC) pendulo_shape = pymunk.Circle(pendulo_fisica, pendulo_raio_out) pendulo_fisica.position = pendulo_posicao pendulo_shape.friction = 0.6 pendulo_shape.color = (255, 0, 0, 255) ##RGBA Vermelho junta_pendulo = pymunk.PinJoint(pendulo_fisica, chassi_fisica, (0, 0), (0, 10)) # filtro de colisão - permite contato apenas com o chão chassi_shape.filter = pymunk.ShapeFilter(group=1) pendulo_shape.filter = chassi_shape.filter R_traseira_shape.filter = chassi_shape.filter R_dianteira_shape.filter = chassi_shape.filter ambiente.add(pendulo_fisica, pendulo_shape, junta_pendulo) #-----------------------------------------------------------------------------------------------------------------------------juntas ambiente.add( pymunk.PinJoint(R_traseira_fisica, chassi_fisica, (0, 0), (-40, 10)), pymunk.PinJoint(R_dianteira_fisica, chassi_fisica, (0, 0), (40, 10)), pymunk.PinJoint(R_dianteira_fisica, chassi_fisica, (0, 0), (40, -10)), pymunk.PinJoint(R_traseira_fisica, chassi_fisica, (0, 0), (-40, -10))) #------------------------------------------------------------------------------------------------------------------------------Motor velocidade = 0 M_traseiro = pymunk.SimpleMotor(R_traseira_fisica, chassi_fisica, velocidade) M_dianteiro = pymunk.SimpleMotor(R_dianteira_fisica, chassi_fisica, velocidade) ambiente.add(M_traseiro, M_dianteiro) self.ambiente = ambiente self.pendulo_fisica = pendulo_fisica self.chassi_fisica = chassi_fisica self.M_dianteiro = M_dianteiro self.M_traseiro = M_traseiro self.rodas_controle = PIDControl(1.0 / FPS, KP, KI, KD) # PID self.r = math.pi / 2 # referência a ser seguida
def setup_physics_model(self): if self.dirty and self.token.position: # if token is on board # mass if self.mass != "inf": mass = self.mass else: mass = pymunk.inf # Sets the body type: # dynamic: Influenced by physic (e.g. actors) # static: not influenced by physics (e.g. plattforms) # kinematic: e.g. moving plattforms if self.can_move and not self.stable: body_type = pymunk_engine.Body.DYNAMIC elif self.can_move and self.stable: if self.gravity: body_type = pymunk_engine.Body.DYNAMIC else: body_type = pymunk_engine.Body.KINEMATIC else: body_type = pymunk_engine.Body.STATIC # Sets the moment # if stable: pymunk.inf: Object won't be rotated by an impulse if self.stable: moment = pymunk.inf elif self.shape_type == "rect": moment = pymunk_engine.moment_for_box( mass, ( self.size[0] * self.token.width, self.size[1] * self.token.height, ), ) elif self.shape_type == "circle": moment = pymunk_engine.moment_for_circle( mass, 0, self.size[0] * self.token.width / 2, (0, 0)) elif self.shape_type == "line": moment = pymunk_engine.moment_for_segment( mass, pymunk.pygame_util.from_pygame(self.token.start_position, self.token.board.image), pymunk.pygame_util.from_pygame(self.token.end_position, self.token.board.image), self.token.thickness, ) else: moment = pymunk_engine.moment_for_box( mass=mass, size=(self.size[0] * self.token.width, self.size[1] * self.token.height)) # create body self.body = pymunk_engine.Body(mass=mass, moment=moment, body_type=body_type) if not self.gravity: self.body.velocity_func = lambda body, gravity, damping, dt: None # Sets the shape-type if self.shape_type.lower() == "rect": shape = pymunk.Poly.create_box( self.body, (self.size[0] * self.token.width, self.size[1] * self.token.height), ) elif self.shape_type.lower() == "circle": shape = pymunk.Circle( self.body, self.size[0] * self.token.width / 2, (0, 0), ) elif self.shape_type.lower() == "line": try: start_x, start_y = self.token.start_position[ 0], self.token.start_position[1] end_x, end_y = self.token.end_position[ 0], self.token.end_position[1] shape = pymunk.Segment( self.body, pymunk.pygame_util.from_pygame((start_x, start_y), self.token.board.image), pymunk.pygame_util.from_pygame((end_x, end_y), self.token.board.image), self.token.thickness, ) except AttributeError: raise AttributeError("ERROR: token.board is not set.") # Adds object to space self.shape = shape PhysicsProperty.space.add(self.body, self.shape) if self.token.costume: self.body.position = pymunk.pygame_util.from_pygame( self.token.center, self.token.board.image) self.body.size = (self.token.width, self.token.height) #self.body.angle = math.radians( # self.token.direction_at_unit_circle - self.token.costume.orientation ) if self.shape_type.lower() != "line": PhysicsProperty.space.reindex_shapes_for_body(self.body) self.shape.friction = self.friction shape.elasticity = self.elasticity shape.token = self.token self.shape.collision_type = self.token.__class__.class_id self.dirty = 0 self.model_setup_complete = True
def __init__(self, space, maps, wheel_radius = 30): momentum = 1 body_size = (200, 40) moment = pymunk.moment_for_box(momentum, body_size) self.body = pymunk.Body(momentum, moment) self.shape = pymunk.Poly.create_box(self.body, body_size) self.shape.mass = 5 self.body.position = (200, 200) self.shape.body = self.body self.shape.color = (0, 0, 0, 255) human_moment = pymunk.moment_for_box(momentum, (30, 50)) self.human_body = pymunk.Body(momentum, human_moment) self.human_shape = pymunk.Poly.create_box(self.human_body, (30, 50)) self.human_body.position = (self.body.position.x, self.body.position.y+70) self.human_shape.body = self.human_body self.human_shape.color = (255, 0, 0, 255) self.human_joint = pymunk.PivotJoint(self.human_body, self.body, (-15, -20), (-15, 20)) self.human_joint2 = pymunk.PivotJoint(self.human_body, self.body, (15, -20), (15, 20)) head_moment = pymunk.moment_for_circle(momentum, 1, 1) self.head_body = pymunk.Body(momentum, head_moment) self.head_body.position = (self.human_body.position.x, self.human_body.position.y+70) self.head_shape = pymunk.Circle(self.head_body, 30) self.head_joint = pymunk.PivotJoint(self.head_body, self.human_body, (-10, -30), (-10, 20)) self.head_joint2 = pymunk.PivotJoint(self.head_body, self.human_body, (10, -30), (10, 20)) self.head_shape.collision_type = 1 momentum = 100 wheel_moment = pymunk.moment_for_circle(momentum, 10, wheel_radius) self.wheel1_body = pymunk.Body(momentum, wheel_moment) self.wheel1_body.position = self.body.position + (-60, -20) self.wheel1_shape = pymunk.Circle(self.wheel1_body, wheel_radius) self.wheel2_body = pymunk.Body(momentum, wheel_moment) self.wheel2_body.position = self.body.position + (60, -20) self.wheel2_shape = pymunk.Circle(self.wheel2_body, wheel_radius) self.wheel1_joint = pymunk.PivotJoint(self.body, self.wheel1_body, (-60, -20), (0, 0)) self.wheel1_motor = pymunk.SimpleMotor(self.wheel1_body, self.body, 0) self.wheel2_joint = pymunk.PivotJoint(self.body, self.wheel2_body, (60, -20), (0, 0)) self.wheel1_shape.friction = 1 self.wheel1_shape.color = (200, 200, 200) self.wheel2_shape.friction = 1 self.wheel2_shape.color = (200, 200, 200) space.add(self.body, self.shape) space.add(self.human_body, self.human_shape, self.human_joint, self.human_joint2) space.add(self.head_body, self.head_shape, self.head_joint, self.head_joint2) space.add(self.wheel1_body, self.wheel1_shape, self.wheel1_joint, self.wheel1_motor) space.add(self.wheel2_body, self.wheel2_shape, self.wheel2_joint) shape_filter = pymunk.ShapeFilter(group=1) self.shape.filter = shape_filter self.human_shape.filter = shape_filter self.head_shape.filter = shape_filter self.wheel1_shape.filter = shape_filter self.wheel1_motor.filter = shape_filter self.wheel2_shape.filter = shape_filter self.is_dead = False self.tick = 0 self.prev_dist = 9999 self.speed = 0 self.face = pygame.image.load("normal.png") self.face = pygame.transform.scale(self.face, (90, 90)) self.check = 0 self.prev_check = 0 self.timer = 0 self.total_reward = 0 self.maps = maps self.c_handler = space.add_collision_handler(1, 2) self.c_handler.begin = self.collision_handler
def __init__(self, **kwargs): super().__init__(**kwargs) self.prog = self.ctx.program( vertex_shader=''' #version 330 uniform vec4 Camera; // Per vertex in vec2 in_vert; in vec2 in_texture; // Per instance in vec3 in_pos; in vec2 in_size; in vec4 in_tint; out vec2 v_vert; out vec2 v_texture; out vec4 v_tint; void main() { mat2 rotate = mat2( cos(in_pos.z), sin(in_pos.z), -sin(in_pos.z), cos(in_pos.z) ); v_vert = rotate * (in_vert * in_size) + in_pos.xy; gl_Position = vec4((v_vert - Camera.xy) / Camera.zw, 0.0, 1.0); v_texture = in_texture; v_tint = in_tint; } ''', fragment_shader=''' #version 330 uniform sampler2D Texture; in vec2 v_vert; in vec2 v_texture; in vec4 v_tint; out vec4 f_color; void main() { vec4 tex = texture(Texture, v_texture); vec3 color = tex.rgb * (1.0 - v_tint.a) + v_tint.rgb * v_tint.a; f_color = vec4(color, tex.a); } ''', ) self.tex1 = self.load_texture_2d('crate.png') self.tex1.use(0) self.tex2 = self.load_texture_2d('ball.png') self.tex2.use(1) vertices = np.array([ -1.0, -1.0, 0.0, 0.0, -1.0, 1.0, 0.0, 1.0, 1.0, -1.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, ]) vbo1 = self.ctx.buffer(vertices.astype('f4')) self.vbo2 = self.ctx.buffer(reserve=1024 * 1024) vao_content = [ (vbo1, '2f 2f', 'in_vert', 'in_texture'), (self.vbo2, '3f 2f 4f/i', 'in_pos', 'in_size', 'in_tint'), ] self.vao = self.ctx.vertex_array(self.prog, vao_content) self.space = pymunk.Space() self.space.gravity = (0.0, -900.0) shape = pymunk.Segment(self.space.static_body, (5, 100), (595, 100), 1.0) shape.friction = 1.0 self.space.add(shape) self.bodies = [] self.balls = [] for x in range(5): for y in range(10): size = 20 mass = 10.0 moment = pymunk.moment_for_box(mass, (size, size)) body = pymunk.Body(mass, moment) body.position = Vec2d(300 + x * 50, 105 + y * (size + 0.1)) shape = pymunk.Poly.create_box(body, (size, size)) shape.friction = 0.3 self.space.add(body, shape) self.bodies.append(body)
def construct(self): space = pymunk.Space() space.gravity = 0, -9820 ground = space.static_body grd_seg = pymunk.Segment(ground, (-10000, -2000), (10000, -2000), 0) grd_seg.friction = 0.8 space.add(grd_seg) #space.add(ground, grd_box) mass = 10 size = (1000, 1000) moment = pymunk.moment_for_box(mass, size) body = pymunk.Body(mass, moment) body.angle = 0.1 body.position = 0, 3000 box = pymunk.Poly.create_box(body, size) box.elasticity = 0 box.friction = 0.5 space.add(body, box) shape = Square() shape.stretch_to_fit_height(1) shape.stretch_to_fit_width(1) body2 = pymunk.Body(mass, moment) body2.angle = -0.1 body2.position = 800, 4500 box2 = pymunk.Poly.create_box(body2, size) box2.elasticity = 0 box2.friction = 0.5 space.add(body2, box2) shape = Square() shape.stretch_to_fit_height(1) shape.stretch_to_fit_width(1) shape.set_fill(DARK_BLUE, opacity=1) shape2 = Square() shape2.stretch_to_fit_height(1) shape2.stretch_to_fit_width(1) shape2.set_fill(DARK_BROWN, opacity=1) self.add(shape) self.add(shape2) self.add( Line(FRAME_X_RADIUS * LEFT, FRAME_X_RADIUS * RIGHT).shift(2 * DOWN)) run_time = 5 last_t = 0 shape_cons = [] shape2_cons = [] step = 1 / self.camera.frame_rate for t in range(int(run_time / step)): space.step(step) shape_cons.append((body.position / 1000, body.angle)) shape2_cons.append((body2.position / 1000, body2.angle)) self.play(PhysicsBody(shape, shape_cons), PhysicsBody(shape2, shape2_cons), run_time=run_time)