def LaunchBomb(self, position, velocity): """ A bomb is a simple circle which has the specified position and velocity. position and velocity must be b2Vec2's. """ if self.bomb: self.world.DestroyBody(self.bomb) self.bomb = None bd = box2d.b2BodyDef() bd.allowSleep = True bd.position = position bd.isBullet = True self.bomb = self.world.CreateBody(bd) self.bomb.SetLinearVelocity(velocity) sd = box2d.b2CircleDef() sd.radius = 0.3 sd.density = 20.0 sd.restitution = 0.1 minV = position - (0.3,0.3) maxV = position + (0.3,0.3) aabb = box2d.b2AABB() aabb.lowerBound = minV aabb.upperBound = maxV if self.world.InRange(aabb): self.bomb.CreateShape(sd) self.bomb.SetMassFromShapes()
def makeping(self, rname, rnd): tank = self.tanks[rname] body = tank.turret segmentLength = 65.0 blocalpos = box2d.b2Vec2(1.12, 0) segment = box2d.b2Segment() laserStart = (1.12, 0) laserDir = (segmentLength, 0.0) segment.p1 = body.GetWorldPoint(laserStart) segment.p2 = body.GetWorldVector(laserDir) segment.p2+=segment.p1 lambda_, normal, shape = self.w.RaycastOne(segment, False, None) hitp = (1 - lambda_) * segment.p1 + lambda_ * segment.p2 angle = tank.get_turretangle() dist = box2d.b2Distance(segment.p1, hitp) if shape is not None: hitbody = shape.GetBody() kind = hitbody.userData['kind'] if kind == 'tank': actor = hitbody.userData['actor'] if actor._pinged != rnd - 1: actor._pinged = rnd return kind, angle, dist else: return 'w', angle, 0
def createCircle(position, r=0.3, dynamic=True, bMatplotlib = True): global world, fig, ax bodyDef = Box2D.b2BodyDef() fixtureDef = Box2D.b2FixtureDef() if dynamic: bodyDef.type = Box2D.b2_dynamicBody fixtureDef.density = 1 else: bodyDef.type = Box2D.b2_staticBody fixtureDef.density = 0 bodyDef.position = position if(abs(world.gravity[1]) > 1): bodyDef.linearDamping = 0.1 bodyDef.angularDamping = 0.1 else: bodyDef.linearDamping = 70 bodyDef.angularDamping = 30 body = world.CreateBody(bodyDef) fixture = body.CreateFixture(shape=Box2D.b2CircleShape(radius=r), density=1.0, friction=0.3) if(bMatplotlib): createGlobalFigure() fixture.userData = drawCircle(ax,position,r) return body
def __init__(self, env, size, pos, world): # static rectangle shaped prop # pars: # size - array [width, height] # position - array [x, y], in world meters, of center self.env = env self.size = size self.pos = pos # initialize body bdef = Box2D.b2BodyDef() bdef.position = Box2D.b2Vec2(self.pos[0], self.pos[1]) bdef.angle = 0 bdef.fixedRotation = True self.body = world.CreateBody(bdef) # strange rect due to Box2D's way of representing objects self.rect = pygame.rect.Rect(self.pos[0] - self.size[0]/2, self.pos[1] - self.size[1]/2, self.size[0], self.size[1]) # initialize shape fixdef = Box2D.b2FixtureDef() fixdef.shape = Box2D.b2PolygonShape() fixdef.shape.SetAsBox(self.size[0]/2, self.size[1]/2) fixdef.restitution = 0.4 self.body.CreateFixture(fixdef)
def __init__(self): self.count = 1000 self.force = 10 self.robots = {} self.bullets = [] self.sprites = {} self.to_destroy = [] halfx = 30 self.ahalfx = 20 halfy = 25 self.ahalfy = 20 gravity = (0, 0) doSleep = True self.timeStep = 1.0 / 60.0 self.velIterations = 10 self.posIterations = 8 aabb = box2d.b2AABB() aabb.lowerBound = (-halfx, -halfy) aabb.upperBound = (halfx, halfy) self.w = box2d.b2World(gravity, doSleep) self.makearena()
def __init__(self): self.count = 1000 self.force = 10 self.tanks = {} self.bullets = [] self.sprites = {} self.to_destroy = [] halfx = 30 self.ahalfx = 20 halfy = 25 self.ahalfy = 20 gravity = (0, 0) doSleep = True self.timeStep = 1.0 / 60.0 self.velIterations = 10 self.posIterations = 8 aabb = box2d.b2AABB() aabb.lowerBound = (-halfx, -halfy) aabb.upperBound = (halfx, halfy) self.w = box2d.b2World(aabb, gravity, doSleep) self.w.GetGroundBody().SetUserData({'actor': None}) self.makearena()
def __init__(self, **kw): super(Framework, self).__init__(**kw) # Initialize the text display group self.textGroup = grText(self) # Load the font and record the screen dimensions self.font = pyglet.font.load(self.fontname, self.fontsize) self.screenSize = box2d.b2Vec2(self.width, self.height) # Box2D Initialization self.worldAABB = box2d.b2AABB() self.worldAABB.lowerBound = (-200.0, -100.0) self.worldAABB.upperBound = ( 200.0, 200.0) gravity = (0.0, -10.0) doSleep = True self.world = box2d.b2World(self.worldAABB, gravity, doSleep) self.destructionListener = fwDestructionListener() self.boundaryListener = fwBoundaryListener() self.contactListener = fwContactListener() self.debugDraw = fwDebugDraw() self.debugDraw.surface = self.screen self.destructionListener.test = self self.boundaryListener.test = self self.contactListener.test = self self.world.SetDestructionListener(self.destructionListener) self.world.SetBoundaryListener(self.boundaryListener) self.world.SetContactListener(self.contactListener) self.world.SetDebugDraw(self.debugDraw) self._viewCenter = box2d.b2Vec2(0,10.0)
def __init__(self, x, y, puntos, dinamica=True, densidad=1.0, restitucion=0.56, friccion=10.5, amortiguacion=0.1, fisica=None, sin_rotacion=False): Figura.__init__(self) self._escala = 1 self.puntos = puntos self.dinamica = dinamica self.fisica = fisica self.sin_rotacion = sin_rotacion if not self.fisica: self.fisica = pilas.escena_actual().fisica self.vertices = [(convertir_a_metros(x1) * self._escala, convertir_a_metros(y1) * self._escala) for (x1, y1) in self.puntos] fixture = box2d.b2FixtureDef(shape=box2d.b2PolygonShape(vertices=self.vertices), density=densidad, linearDamping=amortiguacion, friction=friccion, restitution=restitucion) self.userData = { 'id' : self.id } fixture.userData = self.userData if self.dinamica: self._cuerpo = self.fisica.mundo.CreateDynamicBody(position=(0, 0), fixtures=fixture) else: self._cuerpo = self.fisica.mundo.CreateKinematicBody(position=(0, 0), fixtures=fixture) self._cuerpo.fixedRotation = self.sin_rotacion
def __init__(self, world, x0, y0, theta0): # constants self.radius = 0.5 # coordinates for drawing self.theta = theta0 self.x = x0 self.y = y0 # first define a body bodyDef = physics.b2BodyDef() bodyDef.position = (self.x, self.y) # create body in our world self.body = world.CreateBody(bodyDef) # then define the attached shape # (it's a circle) shapeDef = physics.b2CircleDef() shapeDef.radius = self.radius shapeDef.density = 3 # create the shape self.shape = self.body.CreateShape(shapeDef) # attach a mass self.body.SetMassFromShapes() # fixtures self.shape.friction = 1.0 self.shape.restitution = 0.1 # initial angular velocity self.body.angularVelocity = -30.0
def LaunchRandomBomb(self): """ Create a new bomb and launch it at the testbed. """ p = box2d.b2Vec2( box2d.b2Random(-15.0, 15.0), 30.0 ) v = -5.0 * p self.LaunchBomb(p, v)
def __init__(self,world,top,size): scenter=(top[0]+(size[0]/2), top[1]+(size[1]/2)) wcenter=world.s2wPos(scenter) extends=world.s2wScale(size) #print 'top: '+str(top) #print 'scenter: '+str(scenter) #print 'wcenter: '+str(wcenter) #print world.w2sPos(wcenter) #print 'size: '+str(size) #print 'extends: '+str(extends) #print world.w2sScale(extends) # Physics walldef=Box2D.b2BodyDef() walldef.position=Box2D.b2Vec2(wcenter[0],wcenter[1]) walldef.userData={} wallbody=world.world.CreateBody(walldef) wallbody.iswall=True wallshape=Box2D.b2PolygonDef() width, height = extends wallshape.SetAsBox(width/2, height/2) wallbody.CreateShape(wallshape) # Display self.image=pygame.Surface(size) self.image.fill((56,71,216)) self.rect = self.image.get_rect() self.rect.topleft=top
def perform(self, time): """ Morph line into real collideable figure. """ #Define geometry and time data actor = self.master.owner v1 = actor.b2body.GetLocalPoint(pixels_to_tiles((self.start.x, self.start.y))) v2 = actor.b2body.GetLocalPoint(pixels_to_tiles((self.end.x, self.end.y))) if v2.x <= v1.x: v1, v2 = v2, v1 vlen = math.sqrt((v2.x-v1.x)*(v2.x-v1.x)+(v2.y-v1.y)*(v2.y-v1.y)) vcent = ((v1.x+v2.x)/2.0, (v1.y+v2.y)/2.0) vangle = math.asin((v2.y-v1.y)/vlen) v = self.end - self.start start = gm.Point2(self.start.x, self.start.y) self.trace = gm.LineSegment2(start, v) self.cshape = shape_to_cshape(self.trace) self.set_time_to_complete(time) self.b2fixture = actor.b2body.CreateFixture(b2.b2FixtureDef(shape=b2.b2PolygonShape(box=(vlen, 0, vcent, vangle)), isSensor=True, userData=self)) self.b2fixture.filterData.categoryBits = B2SWING self.b2fixture.filterData.maskBits = B2HITZONE | B2SWING | B2BODYPART actor.world.addEventHandler(self.b2fixture, self.on_begin_contact, self.on_end_contact) self.schedule(self.update)
def makeping(self, rname, rnd): robot = self.robots[rname] body = robot.turret segmentLength = 65.0 blocalpos = box2d.b2Vec2(1.12, 0) segment = box2d.b2Segment() laserStart = (1.12, 0) laserDir = (segmentLength, 0.0) segment.p1 = body.GetWorldPoint(laserStart) segment.p2 = body.GetWorldVector(laserDir) segment.p2+=segment.p1 lambda_, normal, shape = self.w.RaycastOne(segment, False, None) hitp = (1 - lambda_) * segment.p1 + lambda_ * segment.p2 angle = robot.get_turretangle() dist = box2d.b2Distance(segment.p1, hitp) if shape is not None: hitbody = shape.GetBody() kind = hitbody.userData['kind'] if kind == 'robot': actor = hitbody.userData['actor'] if actor._pinged != rnd - 1: actor._pinged = rnd return kind, angle, dist else: # Not sure why shape returns None here. Seems to be when the # robot is pressed right up against a wall, though. return 'w', angle, 0
def __init__(self,centre,radius,tc = None,angle=0): self.dead = False self.tc = tc if tc != None: self.InitPolygons(tc) self.visible = True else: self.visible = False self.bodydef = box2d.b2BodyDef() #This is inefficient, but it doesn't want to grab properly otherwise. Shitty hack but whatever self.bodydef.allowSleep = False self.midpoint = radius*math.sqrt(2)*globals.physics.scale_factor self.bodydef.position = box2d.b2Vec2(*(centre*globals.physics.scale_factor)) self.bodydef.angle = angle self.shape = self.CreateShape(radius) self.shape.isSensor = self.is_sensor if not self.static: self.shape.userData = self if self.filter_group != None: self.shape.filter.groupIndex = self.filter_group self.bodydef.isBullet = self.isBullet self.body = globals.physics.world.CreateBody(self.bodydef) self.shape.density = self.mass self.shape.friction = 0.7 self.shapeI = self.body.CreateShape(self.shape) self.child_joint = None self.parent_joint = None self.ExtraShapes() self.PhysUpdate([]) self.health = Gobject.initial_health
def create_mouse_joint(self, x, y): """ create a mouse joint to the body on world coordinates x, y """ if self.mouse_joint: return world_coord = box2d.b2Vec2(self.debugDraw.screen_to_world((x, y))) aabb = box2d.b2AABB() aabb.lowerBound = world_coord - (0.001, 0.001) aabb.upperBound = world_coord + (0.001, 0.001) max_count = 10 count, shapes = self.world.Query(aabb, max_count) body = (body for shape, body in ((shape, shape.GetBody()) for shape in shapes) if not body.IsStatic() and body.GetMass() > 0.0 and shape.TestPoint(body.GetXForm(), world_coord)) body = list(itertools.islice(body, 1)) body = body[0] if len(body) == 1 else None if body: md = box2d.b2MouseJointDef() md.body1 = self.world.GetGroundBody() md.body2 = body md.target = world_coord md.maxForce = 1000 * body.GetMass() self.mouse_joint = self.world.CreateJoint(md) body.WakeUp()
def setup_world(self): self.worldAABB = box2d.b2AABB() self.worldAABB.lowerBound = (-2000.0, -2000.0) self.worldAABB.upperBound = (2000.0, 2000.0) self.gravity = (0.0, -9.81) doSleep = False self.world = box2d.b2World(self.worldAABB, self.gravity, doSleep)
def tryStop(self, horiz=True, vert=False): #print "trying to stop" self.curVel = self.body.GetLinearVelocity() if horiz: self.body.ApplyForce(Box2D.b2Vec2(FPS*(-self.curVel.x)*self.body.GetMass(),0), self.body.GetWorldCenter()) if vert: self.body.ApplyForce(Box2D.b2Vec2(0,FPS*(-self.curVel.y)*self.body.GetMass()), self.body.GetWorldCenter())
def load(self, angle, radius, length): _x, _y=length*math.cos(angle),length*math.sin(angle) position= self.parent.body.position.x+_x, self.parent.body.position.y+_y bd=box2d.b2BodyDef() bd.fixedRotation=False bd.position=position sd=box2d.b2CircleDef() sd.radius=radius sd.density=1.0 sd.filter.categoryBits= PistonBall.catBits self.body=WorldConfig.world.CreateBody(bd) self.body.CreateShape(sd) self.body.SetMassFromShapes() self.body.userData=self pjd=box2d.b2PrismaticJointDef() pjd.Initialize(self.parent.body, self.body, self.parent.body.position, (math.cos(angle), math.sin(angle))) pjd.motorSpeed = 30.0 pjd.maxMotorForce = 1000.0 pjd.enableMotor = True pjd.lowerTranslation = 0.0 pjd.upperTranslation = 10.0 pjd.enableLimit = True self.joint=WorldConfig.world.CreateJoint(pjd).getAsType()
def load(self): bodyDef = box2d.b2BodyDef() if self.shape.type == WorldConfig.BOX: bodyDef.position = self.shape.center[0], self.shape.center[1] body = WorldConfig.world.CreateBody(bodyDef) shapeDef = box2d.b2PolygonDef() shapeDef.SetAsBox(self.shape.width / 2, self.shape.height / 2) elif self.shape.type == WorldConfig.POLYGON: body = WorldConfig.world.CreateBody(bodyDef) shapeDef = box2d.b2PolygonDef() shapeDef.setVertices(self.shape.points) elif self.shape.type == WorldConfig.CIRCLE: bodyDef.position = self.shape.x, self.shape.y body = WorldConfig.world.CreateBody(bodyDef) shapeDef = box2d.b2CircleDef() shapeDef.radius = self.shape.radius else: raise 'unknown shape' return # shapeDef.density = 1 # shapeDef.friction = 0.1 # shapeDef.restitution = 1.0 shapeDef.filter.categoryBits = Wall.catBits # shapeDef.filter.maskBits = Wall.maskBits body.CreateShape(shapeDef) body.SetMassFromShapes() body.userData = self self.body = body
def load(self, size): bd=box2d.b2BodyDef() bd.position=self.shape.center[0], self.shape.center[1] sd=box2d.b2PolygonDef() sd.SetAsBox(size[0]/2.0, size[1]/2.0) sd.filter.categoryBits= BallGen.catBits self.body=WorldConfig.world.CreateBody(bd) self.body.CreateShape(sd) self.body.SetMassFromShapes() self.body.userData = self sd.density=2.0 sd.SetAsBox(0.1, 1.8) bd.isBullet=True bd.position=self.body.position.x+1, self.body.position.y+4 body_bar=WorldConfig.world.CreateBody(bd) body_bar.CreateShape(sd) body_bar.SetMassFromShapes() jd= box2d.b2RevoluteJointDef() jd.Initialize(self.body, body_bar, (self.body.position.x+1, self.body.position.y+size[1]/2.0)) jd.maxMotorTorque= 30000.0 jd.motorSpeed = 2* box2d.b2_pi jd.enableMotor = True WorldConfig.world.CreateJoint(jd).getAsType() self.body_bar=body_bar
def __init__(self, screen_size, gravity=( 0.0, -9.0), ppm=100.0, renderer='pygame'): """ Init the world with boundaries and gravity, and init colors. Parameters: screen_size .. (w, h) -- screen size in pixels [int] gravity ...... (x, y) in m/s^2 [float] default: (0.0, -9.0) ppm .......... pixels per meter [float] default: 100.0 renderer ..... which drawing method to use (str) default: 'pygame' Return: class Elements() """ self.set_screenSize(screen_size) self.set_drawingMethod(renderer) # Create Subclasses self.add = add_objects.Add(self) self.callbacks = callbacks.CallbackHandler(self) self.camera = camera.Camera(self) # Gravity + Bodies will sleep on outside self.gravity = gravity self.doSleep = True # Create the World self.world = box2d.b2World(self.gravity, self.doSleep) bodyDef = box2d.b2BodyDef() self.world.groundBody = self.world.CreateBody(bodyDef) # Init Colors self.init_colors() # Set Pixels per Meter self.ppm = ppm
def MouseDown(self, p): """ Indicates that there was a left click at point p (world coordinates) """ if self.mouseJoint != None: return # Make a small box. aabb = box2d.b2AABB() d = box2d.b2Vec2(0.001, 0.001) aabb.lowerBound = p - d aabb.upperBound = p + d # Query the world for overlapping shapes. body = None k_maxCount = 10 (count, shapes) = self.world.Query(aabb, k_maxCount) for shape in shapes: shapeBody = shape.GetBody() if shapeBody.IsStatic() == False and shapeBody.GetMass() > 0.0: if shape.TestPoint(shapeBody.GetXForm(), p): # is it inside? body = shapeBody break if body: md = box2d.b2MouseJointDef() md.body1 = self.world.GetGroundBody() md.body2 = body md.target = p md.maxForce= 1000.0 * body.GetMass() self.mouseJoint = self.world.CreateJoint(md) body.WakeUp()
def create_body(world, shape_type, position = (0, 0), angle = 0, friction = None, restitution = None, density = None, linear_damping = None, is_sensor = False, fixed_rotation = False, body_type = Box2D.b2_dynamicBody, user_data = None, **kwargs): """Creates a body. All parameters should be self-explanatory with a quick skim of the Box2D manual. **kwargs will be set on the shape type after its construction.""" shape = shape_type() for i, j in kwargs.iteritems(): setattr(shape, i, j) fixture_def = Box2D.b2FixtureDef() if friction is not None: fixture_def.friction = friction if restitution is not None: fixture_def.restitution = restitution if density is not None: fixture_def.density = density fixture_def.shape = shape fixture_def.isSensor = is_sensor body_def = Box2D.b2BodyDef() body_def.type = body_type body_def.position = position body_def.angle = angle body = world.CreateBody(body_def) body.CreateFixture(fixture_def) body.userData = user_data if linear_damping: body.linearDamping = linear_damping body.fixedRotation = fixed_rotation return body
def handle_enter(self, parameters): self.next_state = parameters['next_state'] self.next_state_parameters = parameters.setdefault('parameters', {}) self.next_state_parameters={'totalScore':parameters['totalScore'],'edit':parameters['edit']} self.delay = parameters.setdefault('delay', 2000) self.time_passed = 0 self.background = None self.shader = None self.screenFont = pygame.font.Font("data/font/fsex2p00_public.ttf", 70) text = u"Тоглоом дууслаа" self.message = self.screenFont.render(text, True, (255,255,255)) bodyDef = box2d.b2BodyDef() bodyDef.position = (8, -2) bodyDef.angle = -0.5 bodyDef.userData = self self.message_body = self.world.CreateBody(bodyDef) shapeDef = box2d.b2PolygonDef() shapeDef.density = 0.5 shapeDef.friction = 0.95 shapeDef.restitution = 0.5 shapeDef.SetAsBox(self.message.get_width()/2.0/self.pixels_per_unit, self.message.get_height()/2.0/self.pixels_per_unit) self.message_body.CreateShape(shapeDef) self.message_body.SetMassFromShapes() self.message_body.SetLinearVelocity = box2d.b2Vec2(100.0,0)
def Grapple(self,pos): if self.joint: self.UnGrapple() return diff = pos - self.GetPos() distance,angle = cmath.polar(complex(diff.x,diff.y)) angle = (angle - (math.pi/2) - self.GetAngle())%(math.pi*2) #0 = pi*2 is straight ahead, pi is behind. #so 0.75 pi to 1.25 pi is allowed if not (angle <= self.min_shoot and angle >= self.max_shoot): return if distance > self.max_grapple: return #We need to determine if this point is in any objects... #We'll create a small AABB around the point, and get the list of potentially intersecting shapes, #then test each one to see if the point is inside it aabb = box2d.b2AABB() phys_pos = pos*self.physics.scale_factor #First of all make sure it's not inside us trans = box2d.b2XForm() trans.SetIdentity() p = phys_pos - Point(*self.body.position) if self.shapeI.TestPoint(trans,tuple(p)): return aabb.lowerBound.Set(phys_pos.x-0.1,phys_pos.y-0.1) aabb.upperBound.Set(phys_pos.x+0.1,phys_pos.y+0.1) (count,shapes) = self.physics.world.Query(aabb,10) for shape in shapes: trans = box2d.b2XForm() trans.SetIdentity() p = phys_pos - Point(*shape.GetBody().position) if shape.TestPoint(trans,tuple(p)): self.touching = shape self.contact = p break else: self.touching = None self.contact = None if not self.touching: return globals.sounds.grapple.play() #Tell the other body that it's in a joint with us so that target = self.touching.userData if target == None: self.touching = None self.contact = None return target.parent_joint = self self.child_joint = target joint = box2d.b2DistanceJointDef() joint.Initialize(self.body,self.touching.GetBody(),self.body.GetWorldCenter(),tuple(phys_pos)) joint.collideConnected = True self.joint = self.physics.world.CreateJoint(joint) self.grappled = True self.grapple_quad.Enable()
def SetProjectileBLPosition(self, dx, dy): projectile_start_pos = box2d.b2Vec2(dx,dy) projectile_start_pos.Normalize() projectile_start_pos.mul_float(self.midpoint.x + 30) projectile_start_pos.add_vector(box2d.b2Vec2(self.body.GetWorldCenter()[0] / globals.physics.scale_factor, self.body.GetWorldCenter()[1] / globals.physics.scale_factor)) self.projectile_position = Point(projectile_start_pos[0], projectile_start_pos[1])
def create_physics_world(self, size): # create world worldAABB = box2d.b2AABB() worldAABB.lowerBound = (-10, -10) worldAABB.upperBound = (size[0] + 10, size[1] + 10) gravity = box2d.b2Vec2(0.0, 0.0) doSleep = True world = box2d.b2World(worldAABB, gravity, doSleep) return world
def __init__(self, world, x, y): bodyDef = b2.b2BodyDef() bodyDef.position = (x, y) self.body = world.CreateBody(bodyDef) shapeDef = b2.b2CircleDef() shapeDef.radius = 0.25 shapeDef.isSensor = True self.body.CreateShape(shapeDef) self.body.userData = self
def update_shapes(world): # Check to see if any objects are sleeping or coming to a stop. # Then give them a little push. for body in world.bodyList: v = body.GetLinearVelocity() if body.IsSleeping() or v.LengthSquared() < 0.2: i = body.GetWorldVector((box2d.b2Random(-200,200), box2d.b2Random(-200,200))) p = body.GetWorldPoint((0.0, 0.0)) body.ApplyImpulse(i, p)
def test_b2EdgeShape(self): world = b2.b2World() v1=(-10.0, 0.0) v2=(-7.0, -1.0) v3=(-4.0, 0.0) ground=world.CreateStaticBody(shapes= [b2.b2EdgeShape(vertices=[None, v1, v2, v3])])
def _rect( self, pos, width, height, angle=0, dynamic=True, density=1.0, restitution=0.16, friction=0.5): # Add a rect without correcting any settings # meaning, pos and vertices are in meters # angle is now in radians ((degrees * pi) / 180)) x, y = pos bodyDef = box2d.b2BodyDef() bodyDef.position = (x, y) userData = {'color': self.parent.get_color()} bodyDef.userData = userData # Create the Body if not dynamic: density = 0 else: bodyDef.type = box2d.b2_dynamicBody body = self.parent.world.CreateBody(bodyDef) self.parent.element_count += 1 # Add a shape to the Body boxDef = box2d.b2FixtureDef() polygonShape = box2d.b2PolygonShape() polygonShape.SetAsBox(width, height, (0, 0), angle) boxDef.shape = polygonShape boxDef.density = density boxDef.restitution = restitution boxDef.friction = friction body.CreateFixture(boxDef) return body
def __init__(self, fisica, pilas, x, y, ancho, alto, dinamica=True, densidad=1.0, restitucion=0.56, friccion=10.5, amortiguacion=0.1, sin_rotacion=False, sensor=False): Figura.__init__(self, fisica, pilas) x = utils.convertir_a_metros(x) y = utils.convertir_a_metros(y) self._ancho = utils.convertir_a_metros(ancho) self._alto = utils.convertir_a_metros(alto) self._escala = 1 self.fisica = fisica if not self.fisica: self.fisica = pilas.escena_actual().fisica if not dinamica: densidad = 0 shape = box2d.b2PolygonShape(box=(self._ancho/2, self._alto/2)) shape.SetAsBox(self._ancho/2.0, self._alto/2.0) fixture = box2d.b2FixtureDef(shape=shape, density=densidad, linearDamping=amortiguacion, friction=friccion, restitution=restitucion) # Agregamos un identificador para controlarlo posteriormente en # las colisiones. self.userData = {'id': self.id, 'figura': self} fixture.userData = self.userData self._cuerpo = self.fisica.mundo.CreateDynamicBody(position=(x, y), fixtures=fixture) self.sin_rotacion = sin_rotacion self.sensor = sensor self.dinamica = dinamica if not dinamica: self._cuerpo.mass = 1000000
def attachRobotBody(self, world, **kargs): robotBody = world.CreateDynamicBody(**kargs) robotBody.CreateFixture(shape=Box2D.b2CircleShape(pos=(0, 0), radius=self.radius), density=1.0, **kargs) for i, angle in enumerate( numpy.linspace(0, math.pi * 2, self.nbumpers + 1)[:-1]): c = numpy.array( (self.radius * math.sin(angle), self.radius * math.cos(angle))) robotBody.CreateFixture( shape=Box2D.b2PolygonShape(box=(self.bumper_w / 2, self.bumper_h / 2, (c[0], c[1]), angle)), density=0.01, isSensor=True, userData='b' + str(i)) self.robotBody = robotBody return robotBody
def createTri(position, r=0.3, dynamic=True): global world, fig, ax bodyDef = Box2D.b2BodyDef() fixtureDef = Box2D.b2FixtureDef() if dynamic: bodyDef.type = Box2D.b2_dynamicBody fixtureDef.density = 1 else: bodyDef.type = Box2D.b2_staticBody fixtureDef.density = 0 bodyDef.position = position bodyDef.linearDamping = 70 bodyDef.angularDamping = 50 body = world.CreateBody(bodyDef) v = [(-r,-r),(0,r),(r,-r)] fixture = body.CreateFixture(shape=Box2D.b2PolygonShape(vertices=v), density=1.0, friction=0.3) body.userData = {"name":"tri"} return body
def update(self): if self.body.linearVelocity.LengthSquared() < 0.01: self.body.PutToSleep() if self.kill: self.body.PutToSleep() if self.number > 0: world = self.body.GetWorld() world.DestroyBody(self.body) else: self.body.position = b2.b2Vec2(4, 4) self.kill = False
def introduce_roads(): # Introduce traffic map self.traffic = Traffic() self.map_scale = OBS_SCALE # map px per meters. set it to OBS_SCALE so no resizing necessary when getting observation contours = self.loadMap() num_contour = len(contours) print("num", num_contour) obstacles = [] for contour in contours: vertices = [] for item in contour: new_vec = b2.b2Vec2(float(item[0][0]/BOX_SCALE), float(item[0][1]/BOX_SCALE)) vertices.append(new_vec) print("vertices") print(vertices) contour_shape = b2.b2PolygonShape(vertices=vertices) obstacle = self.world.CreateStaticBody(position=(0,0), shapes=contour_shape) obstacles.append(obstacle)
def add_asteroid_play_space(world: Box2D.b2World, left_border: float, right_border: float, bottom_border: float, top_border: float): fixture_shape = Box2D.b2PolygonShape() width = right_border - left_border + PLAYSPACE_PADDING height = top_border - bottom_border + PLAYSPACE_PADDING fixture_shape.SetAsBox( width, height, Box2D.b2Vec2(left_border + width / 2, bottom_border + height / 2), 0) fixture_def = Box2D.b2FixtureDef() fixture_def.shape = fixture_shape fixture_def.isSensor = True play_space_body_def = Box2D.b2BodyDef() play_space_body_def.fixtures = [fixture_def] play_space_body_def.type = Box2D.b2_staticBody play_space_body_def.position = (0, 0) return world.CreateBody(play_space_body_def)
def NNSD2D(): a = 1 b = np.sqrt(np.pi / 3) parameters = Box2D.Parameters(a, b) title = "2D box\n" + str(parameters) spectrum = Box2D.CalculateSpectrum(parameters, 1000000) unfolded = StretchSpectrum(spectrum) spacings = LevelSpacing(unfolded) PlotLevelDensity(spectrum, lambda x: Box2D.LevelDensity(parameters, x), extraTitle=title) PlotCummulativeLevelDensity( spectrum, lambda x: Box2D.CummulativeLevelDensity(parameters, x), extraTitle=title) PlotNNSD(spacings, Poisson, extraTitle=title)
def add_line(self, p1, p2): p1 = self.renderer.to_world_frame(p1) p2 = self.renderer.to_world_frame(p2) m = ((p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2) p1 = (p1[0] - m[0], p1[1] - m[1]) # compute p1 coordinates wrt m p2 = (p2[0] - m[0], p2[1] - m[1]) # compute p2 coordinates wrt m line = self.world.CreateStaticBody( position=m, shapes=[Box2D.b2EdgeShape(vertices=[p1, p2])]) line.active = False line.userData = BouncingBalls.BodyData("line", visible=False) print("Warning line rendering disabled!")
def __init__(self): self.action_space = spaces.Box( np.array([-1,0,0]), np.array([+1,+1,+1]) ) # steer, gas, brake self.observation_space = spaces.Box(low=0, high=255, shape=(STATE_H, STATE_W, 3)) self.world = Box2D.b2World((0,0), contactListener=FrictionDetector(self)) self.viewer = None self.invisible_state_window = None self.invisible_video_window = None self.road = None self.car = None self.reward = 0.0 self.prev_reward = 0.0
def __init__(self): self._seed() self.viewer = None self.world = Box2D.b2World() self.moon = None self.lander = None self.particles = [] self.prev_reward = None self._reset()
def __init__(self): self._seed() self.world = Box2D.b2World((0, 0), contactListener=FrictionDetector(self)) self.viewer = None self.invisible_state_window = None self.invisible_video_window = None self.road = None self.car = None self.reward = 0.0 self.prev_reward = 0.0
def PreSolve(self, contact, old_manifold): """ This is a critical function when there are many contacts in the world. It should be optimized as much as possible. """ if not (self.settings.drawContactPoints or self.settings.drawContactNormals or self.using_contacts): return elif len(self.points) > self.settings.maxContactPoints: return manifold = contact.manifold if manifold.pointCount == 0: return _, state2 = b2.b2GetPointStates(old_manifold, manifold) if not state2: return worldManifold = contact.worldManifold for i, _ in enumerate(state2): point = worldManifold.points[0] bodyA = contact.fixtureA.body bodyB = contact.fixtureB.body vA = bodyA.GetLinearVelocityFromWorldPoint(point) vB = bodyB.GetLinearVelocityFromWorldPoint(point) approachVelocity = b2.b2Dot(vB - vA, worldManifold.normal) # print("approachVelocity", approachVelocity) if abs(approachVelocity) > 1.0: self.collision = True self.points.append({ 'fixtureA': contact.fixtureA, 'fixtureB': contact.fixtureB, 'bodyA': bodyA, 'bodyB': bodyB, 'position': worldManifold.points[i], 'normal': worldManifold.normal, 'state': state2[i] })
def __init__(self, world, number, x, y): self.kill = False self.number = number if number > 8: self.color = self.colors[number - 8] self.stripe = True else: self.color = self.colors[number] self.stripe = False bodyDef = b2.b2BodyDef() bodyDef.position = (x, y) bodyDef.linearDamping = 0.9 self.body = world.CreateBody(bodyDef) shapeDef = b2.b2CircleDef() shapeDef.radius = 0.3 shapeDef.density = 1.7 shapeDef.friction = 0.03 shapeDef.restitution = 0.95 self.body.CreateShape(shapeDef) self.body.SetMassFromShapes() self.body.userData = self
def rubeVecToB2Vec2(rube_vec): """converter from rube json vector to b2Vec2 array :param rube_vec: a 2D vector in rube syntax :type rube_vec: a dict with x an y keys and a single item :return: a 2D point :rtype: b2Vec2 """ # converter from rube json vector to b2Vec2 return b2.b2Vec2(rube_vec["x"], rube_vec["y"])
def test_world(self): try: world = Box2D.b2World(Box2D.b2Vec2(0.0, -10.0), True) world = Box2D.b2World((0.0, -10.0), True) world = Box2D.b2World([0.0, -10.0], False) world = Box2D.b2World([0.0, -10.0]) world = Box2D.b2World() world = Box2D.b2World(gravity=[0.0, -10.0]) except Exception: self.fail("Failed to create world (%s)" % sys.exc_info()[1])
def __init__(self, agent = True, num_bots = 1, track_form = 'X', \ write = False, data_path = 'car_racing_positions.csv', \ start_file = True, training_epoch = False): EzPickle.__init__(self) self.seed() self.contactListener_keepref = MyContactListener(self) self.world = Box2D.b2World( (0, 0), contactListener=self.contactListener_keepref) self.viewer = None self.invisible_state_window = None self.invisible_video_window = None self.road = None self.agent = agent self.car = None self.bot_cars = None self.reward = 0.0 self.prev_reward = 0.0 self.track_form = track_form self.data_path = data_path self.write = write self.training_epoch = training_epoch if write: car_title = ['car_angle', 'car_pos_x', 'car_pos_y'] bots_title = [] for i in range(num_bots): bots_title.extend([ f'car_bot{i+1}_angle', f'car_bot{i+1}_pos_x', f'car_bot{i+1}_pos_y' ]) with open(data_path, 'w') as f: f.write(','.join(car_title + bots_title)) f.write('\n') # check the target position: self.moved_distance = deque(maxlen=1000) self.target = (0, 0) self.num_bots = num_bots self.start_file = start_file if start_file: with open("start_file.csv", 'r') as f: lines = f.readlines() self.start_positions = lines[15].strip().split(",") self.num_bots = len(self.start_positions) - 1 self.action_space = spaces.Box(np.array([-1, 0, 0]), np.array([+1, +1, +1]), dtype=np.float32) # steer, gas, brake self.observation_space = spaces.Box(low=0, high=255, shape=(STATE_H, STATE_W, 3), dtype=np.uint8)
def separate(verticesVec): # create an img vec = np.asarray(verticesVec) img = np.zeros((500, 500, 3)) convex_polygon_list = [] vec = vec[::-1] # reverse the order, converting CCW to figsVec = calcShapes(vec) for i in range(len(vec)): verticesVec = [] # list of type b2Vec2 vec = figsVec[i] for j in range(len(vec)): verticesVec.append(b2.b2Vec2(vec[j][0] / scale, vec[j][1] / scale))
def __init__(self): self.seed() self.world = Box2D.b2World(gravity=(0, 0)) self.pusher = None self.box = None #Actions: x-movement, y-movement (clipped -1 to 1) self.action_space = spaces.Box(np.ones(2) * -1, \ np.ones(2), dtype=np.float32) #State: x-pusher, y-pusher, x-box, y-box, x-goal, y-goal self.observation_space = spaces.Box(np.ones(6) * MIN_COORD, \ np.ones(6) * MAX_COORD, dtype=np.float32) self.reset()
def motor(self, body, pt, torque=900, speed=-10): # Revolute joint to the background with motor torque applied b1 = self.parent.world.groundBody pt = self.to_b2vec(pt) jointDef = box2d.b2RevoluteJointDef() jointDef.Initialize(b1, body, pt) jointDef.maxMotorTorque = torque jointDef.motorSpeed = speed jointDef.enableMotor = True self.parent.world.CreateJoint(jointDef)
def _ball( self, pos, radius, dynamic=True, density=1.0, restitution=0.16, friction=0.5): # Add a ball without correcting any settings # meaning, pos and vertices are in meters # Define the body x, y = pos bodyDef = box2d.b2BodyDef() bodyDef.position = (x, y) userData = {'color': self.parent.get_color()} bodyDef.userData = userData # Create the Body if not dynamic: density = 0 else: bodyDef.type = box2d.b2_dynamicBody body = self.parent.world.CreateBody(bodyDef) self.parent.element_count += 1 # Add a shape to the Body circleShape = box2d.b2CircleShape() circleShape.radius = radius circleDef = box2d.b2FixtureDef() circleDef.shape = circleShape circleDef.density = density circleDef.restitution = restitution circleDef.friction = friction body.CreateFixture(circleDef) return body
def __init__(self): self._player_maximum_thrust = 2 self._physics_world = Box2D.b2World(gravity=(0,0), doSleep=False, contactListener=ContactDamageInflicter(self)) self._asteroid_shape = Box2D.b2CircleShape() self._asteroid_shape.radius = ASTEROID_RADIUS self._asteroid_fixture = Box2D.b2FixtureDef() self._asteroid_fixture.shape = self._asteroid_shape self._asteroid_fixture.density = 10 self._asteroid_fixture.restitution = 1 self._asteroid_fixture.friction = 1 self._asteroid_fixture.filter.categoryBits = CollisionFilterCategory.ASTEROID self._asteroid_fixture.filter.maskBits = CollisionFilterCategory.ASTEROID | CollisionFilterCategory.PLAYER self._ship_shape = Box2D.b2CircleShape() self._ship_shape.radius = PLAYER_RADIUS ship_fixture = Box2D.b2FixtureDef() ship_fixture.shape = self._ship_shape ship_fixture.density = 5 ship_fixture.restitution = 1 ship_fixture.friction = 1 ship_fixture.filter.categoryBits = CollisionFilterCategory.PLAYER ship_fixture.filter.maskBits = CollisionFilterCategory.ASTEROID | CollisionFilterCategory.BORDER self._player_base_friction = 0.02 self._player_thrust_extra_friction = 0.02 self._player_maximum_turn_thrust = 1 self._thrust_extra_turn_thrust = -0.3 self._base_rotational_friction = 0.1 self._thrust_extra_rotational_friction = 0.05 ship_body_def = Box2D.b2BodyDef() ship_body_def.position = ( 5 + random() * (RIGHT_BORDER_X - 10), 5 + random() * (TOP_BORDER_Y - 10) ) ship_body_def.angle = random() * pi * 2 ship_body_def.linearVelocity = (0,0) ship_body_def.linearDamping = self._player_base_friction ship_body_def.angularVelocity = 0 ship_body_def.angularDamping = self._base_rotational_friction ship_body_def.fixtures = [ship_fixture] ship_body_def.type = Box2D.b2_dynamicBody ship_body_def.allowSleep = False self._player_ship = self._physics_world.CreateBody(ship_body_def) self._asteroids = self._create_starting_asteroids() self._asteroids_to_kill = [] self._asteroid_extra_spawn_accumulator = 0 self._asteroids_avoided_count = 0 self._borders = borders.add_borders(self._physics_world, LEFT_BORDER_X, RIGHT_BORDER_X, BOTTOM_BORDER_Y, TOP_BORDER_Y) self._asteroid_play_space = asteroid_play_space.add_asteroid_play_space(self._physics_world, LEFT_BORDER_X, RIGHT_BORDER_X, BOTTOM_BORDER_Y, TOP_BORDER_Y) self.player_current_health = MAX_PLAYER_HEALTH
def __init__(self, x0, target): super(PointMassWorld, self).__init__() self.world.gravity = (0.0, 0.0) self.initial_position = (x0[0], x0[1]) self.initial_angle = b2.b2_pi self.initial_linear_velocity = (x0[2], x0[3]) self.initial_angular_velocity = 0 ground = self.world.CreateBody(position=(0, 20)) ground.CreateEdgeChain([(-20, -20), (-20, 20), (20, 20), (20, -20), (-20, -20)]) xf1 = b2.b2Transform() xf1.angle = 0.3524 * b2.b2_pi xf1.position = b2.b2Mul(xf1.R, (1.0, 0.0)) xf2 = b2.b2Transform() xf2.angle = -0.3524 * b2.b2_pi xf2.position = b2.b2Mul(xf2.R, (-1.0, 0.0)) self.body = self.world.CreateDynamicBody( position=self.initial_position, angle=self.initial_angle, linearVelocity=self.initial_linear_velocity, angularVelocity=self.initial_angular_velocity, angularDamping=5, linearDamping=0.1, shapes=[ b2.b2PolygonShape( vertices=[xf1 * (-1, 0), xf1 * (1, 0), xf1 * (0, .5)]), b2.b2PolygonShape( vertices=[xf2 * (-1, 0), xf2 * (1, 0), xf2 * (0, .5)]) ], shapeFixture=b2.b2FixtureDef(density=1.0), ) self.target = self.world.CreateStaticBody( position=target, angle=self.initial_angle, shapes=[ b2.b2PolygonShape( vertices=[xf1 * (-1, 0), xf1 * (1, 0), xf1 * (0, .5)]), b2.b2PolygonShape( vertices=[xf2 * (-1, 0), xf2 * (1, 0), xf2 * (0, .5)]) ], ) self.target.active = False
def __init__(self, screen_size, gravity=(0.0, -9.0), ppm=100.0, renderer='pygame'): """ Init the world with boundaries and gravity, and init colors. Parameters: screen_size .. (w, h) -- screen size in pixels [int] gravity ...... (x, y) in m/s^2 [float] default: (0.0, -9.0) ppm .......... pixels per meter [float] default: 100.0 renderer ..... which drawing method to use (str) default: 'pygame' Return: class Elements() """ self.set_screenSize(screen_size) self.set_drawingMethod(renderer) # Create Subclasses self.add = add_objects.Add(self) self.callbacks = callbacks.CallbackHandler(self) self.camera = camera.Camera(self) # Set Boundaries self.worldAABB = box2d.b2AABB() self.worldAABB.lowerBound = (-100.0, -100.0) self.worldAABB.upperBound = (100.0, 100.0) # Gravity + Bodies will sleep on outside self.gravity = gravity self.doSleep = True # Create the World self.world = box2d.b2World(self.worldAABB, self.gravity, self.doSleep) # Init Colors self.init_colors() # Set Pixels per Meter self.ppm = ppm
def __init__(self, n_walkers=2, position_noise=1e-3, angle_noise=1e-3, reward_mech='local', forward_reward=1.0, fall_reward=-100.0, drop_reward=-100.0, terminate_on_fall=True): EzPickle.__init__(self, n_walkers, position_noise, angle_noise, reward_mech, forward_reward, fall_reward, drop_reward, terminate_on_fall) self.seed() self.viewer = None self.world = Box2D.b2World() self.terrain = None self.n_walkers = n_walkers init_x = TERRAIN_STEP * TERRAIN_STARTPAD / 2 init_y = TERRAIN_HEIGHT + 2 * LEG_H self.start_x = [ init_x + WALKER_SEPERATION * i * TERRAIN_STEP for i in xrange(self.n_walkers) ] self.walkers = [ BipedalWalker(self.world, init_x=sx, init_y=init_y) for sx in self.start_x ] self.package_scale = n_walkers / 1.75 self.package_length = PACKAGE_LENGTH / SCALE * self.package_scale self.total_agents = n_walkers self.prev_shaping = np.zeros(self.n_walkers) self.prev_package_shaping = 0.0 self.position_noise = position_noise self.angle_noise = angle_noise self._reward_mech = reward_mech self.terrain_length = int(TERRAIN_LENGTH * n_walkers * 1 / 8.) self.forward_reward = forward_reward self.fall_reward = fall_reward self.drop_reward = drop_reward self.terminate_on_fall = terminate_on_fall self.reset()
def createBox(position, w=1.0, h=1.0, wdiv=1, hdiv=1, bDynamic=True, density=1, friction=0.3, damping=0, collisionGroup=None, restitution=None, bCollideNoOne=False, name="", angle=0): global world bodyDef = Box2D.b2BodyDef() bodyDef.position = position if (abs(world.gravity[1]) > 1): bodyDef.linearDamping = damping bodyDef.angularDamping = 0 else: bodyDef.linearDamping = 70 bodyDef.angularDamping = 50 if bDynamic: bodyDef.type = Box2D.b2_dynamicBody else: bodyDef.type = Box2D.b2_staticBody body = world.CreateBody(bodyDef) body.userData = {"name": name} dw = w / float(wdiv) dh = h / float(hdiv) for i in range(hdiv): for j in range(wdiv): x = 2 * j * dw + (1 - wdiv) * dw y = 2 * i * dh + (1 - hdiv) * dh fixtureDef = createBoxFixture((x, y), width=dw, height=dh, bDynamic=bDynamic, density=density, friction=friction, collisionGroup=collisionGroup, restitution=restitution, angle=angle) if (bCollideNoOne): fixtureDef.filter.maskBits = 0x0000 fixture = body.CreateFixture(fixtureDef) return body
def __init__(self): self._seed() self.viewer = None self.world = Box2D.b2World() self.objects = [] self.joints = [] high = np.array([1] * 16) self.action_space = spaces.Box(-1, +1, (10,)) self.observation_space = spaces.Box(-high, high) self._reset()
def __init__(self, control_noise=0.): self.control_noise = control_noise self.seed() self.world = Box2D.b2World(gravity=(0, 0)) self.pusher = None self.box = None # Actions: x-movement, y-movement (clipped -1 to 1) self.action_space = spaces.Box(np.ones(2) * -1, np.ones(2), dtype=np.float32) # State: pusher xy position, box xy position, pusher xy velocity, box xy velocity, goal xy position self.observation_space = spaces.Box(np.ones(10) * MIN_COORD, np.ones(10) * MAX_COORD, dtype=np.float32) self.reset() self.drawer = OpencvDrawFuncs(w=240, h=180, ppm=40) self.drawer.install()
def __init__(self, world: Box2D.b2World, position=None, orientation=None): if self.__class__ == Body: raise NotImplementedError( 'Abstract class Body cannot be instantiated.') self._color = np.array((93, 133, 195)) self._highlight_color = np.array((238, 80, 62)) if position is None: position = [.0, .0] position = np.asarray(position) if orientation is None: orientation = .0 self._world = world self._body: Box2D.b2Body = world.CreateDynamicBody( position=Box2D.b2Vec2(*(_world_scale * position)), angle=orientation, linearDamping=self._linear_damping, angularDamping=self._angular_damping) self._body.linearVelocity = Box2D.b2Vec2(*[.0, .0]) self._body.angularVelocity = .0
def createCircle(position, r=0.3, bDynamic=True, bCollideNoOne=False, density=1, damping=0.1, restitution=1, friction=200, name=""): global world, fig, ax bodyDef = Box2D.b2BodyDef() bodyDef.position = position if bDynamic: bodyDef.type = Box2D.b2_dynamicBody else: bodyDef.type = Box2D.b2_staticBody if (abs(world.gravity[1]) > 1): bodyDef.linearDamping = damping bodyDef.angularDamping = damping else: bodyDef.linearDamping = 70 bodyDef.angularDamping = 30 body = world.CreateBody(bodyDef) shape = Box2D.b2CircleShape(radius=r) mask = 0x0009 if (bCollideNoOne): mask = 0x0000 fixture = body.CreateFixture(maskBits=mask, shape=shape, density=density, restitution=restitution, friction=friction) body.userData = {"name": name} return body