def __init__(self, x0, target, render): # TODO: try to pass the initial point as shift so that it will not affect the original code self.render = render if self.render: super(VehicleWorld, self).__init__() else: self.world = b2.b2World(gravity=(0, -10), doSleep=True) self.world.gravity = (0.0, 0.0) self.initial_position = (x0[0], x0[1]) self.initial_angle = x0[2] self.initial_linear_velocity = (x0[3], x0[4]) self.initial_angular_velocity = x0[5] # ?? how to assign the parameter setting to dynamic body itself? self.wheelbase = BUS_LENGTH self.lr = BUS_LENGTH/2 ground = self.world.CreateBody(position=(0,0)) # set the initial position of the body ground.CreateEdgeChain( [(-GROUND_EDGE, -GROUND_EDGE), (-GROUND_EDGE, GROUND_EDGE), (GROUND_EDGE, GROUND_EDGE), (GROUND_EDGE, -GROUND_EDGE), (-GROUND_EDGE, -GROUND_EDGE)] ) # ground.CreateEdgeChain( # [(0, 0), (0, GROUND_EDGE), (GROUND_EDGE, GROUND_EDGE), (GROUND_EDGE, 0),(0, 0)]) # self.introduce_roads() # Initialize the rectangular bus rectangle_fixture = b2.b2FixtureDef( shape=b2.b2PolygonShape(box=(BUS_LENGTH/2, BUS_WIDTH/2)), density=1.5, friction=1., ) square_fixture = b2.b2FixtureDef( shape=b2.b2PolygonShape(box=(0.5, 0.5)), density=10, friction=5., ) self.body = self.world.CreateDynamicBody( position=self.initial_position, angle=self.initial_angle, linearVelocity=self.initial_linear_velocity, angularVelocity=self.initial_angular_velocity, fixtures=rectangle_fixture, ) self.target = self.world.CreateStaticBody( position=target[:2], # angle=target[2], # linearVelocity=target[3:5], # angularVelocity=target[5], angle=self.initial_angle, linearVelocity=self.initial_linear_velocity, angularVelocity=self.initial_angular_velocity, fixtures = rectangle_fixture, ) self.target.active = False
def __init__(self, xpos, ypos, dimensionX, dimensionY, isDynamic): # Creating the body definition self.bodyDef = Box2D.b2BodyDef() if isDynamic: self.bodyDef.type = Box2D.b2_dynamicBody else: self.bodyDef.type = Box2D.b2_staticBody # put object to "Sleep" to spare CPU self.bodyDef.awake = False self.bodyDef.position = (xpos, ypos) # platform body in world self.body = world.CreateBody(self.bodyDef) self.body.mass = 0.001 # platform box shape self.objectBox = Box2D.b2PolygonShape(box=(dimensionX / 2, dimensionY / 2)) # fixture definition if isDynamic: self.objectBoxFixture = Box2D.b2FixtureDef(shape=self.objectBox) else: self.objectBoxFixture = Box2D.b2FixtureDef(shape=self.objectBox, density=1, friction=0.3) self.body.CreateFixture(self.objectBoxFixture) # the boundaries # The boundaries ground = world.CreateBody(position=(400, 0)) ground.CreateEdgeChain([(-1200, -1200), (-1200, 1200), (2000, 2000), (2000, -1200), (-1200, -1200)]) world.CreateFrictionJoint(bodyA=ground, bodyB=self.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, 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, plataforma=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) try: fixture = box2d.b2FixtureDef( shape=shape, density=densidad, friction=friccion, restitution=restitucion) except TypeError: 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 if plataforma: self._cuerpo = self.fisica.mundo.CreateStaticBody(position=(x, y), fixtures=fixture) self.dinamica = False else: self._cuerpo = self.fisica.mundo.CreateDynamicBody(position=(x, y), fixtures=fixture) self.dinamica = dinamica self.sin_rotacion = sin_rotacion self.sensor = sensor if not dinamica: self._cuerpo.mass = 1000000
def __init__(self, fisica, pilas, x, y, radio, dinamica=True, densidad=1.0, restitucion=0.56, friccion=10.5, amortiguacion=0.1, sin_rotacion=False, sensor=False): Figura.__init__(self, fisica, pilas) if x is None: x = pilas.azar(10000, 10000 + 100000) if y is None: y = pilas.azar(10000, 10000 + 100000) x = utils.convertir_a_metros(x) y = utils.convertir_a_metros(y) self._radio = utils.convertir_a_metros(radio) self._escala = 1 self.fisica = fisica if not self.fisica: self.fisica = pilas.escena_actual().fisica if not dinamica: densidad = 0 try: fixture = box2d.b2FixtureDef( shape=box2d.b2CircleShape(radius=self._radio), density=densidad, friction=friccion, restitution=restitucion) except TypeError: fixture = box2d.b2FixtureDef( shape=box2d.b2CircleShape(radius=self._radio), 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 _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, verbose=1): self.contactListener_keep_ref = FrictionDetector(self) self.world = Box2D.b2World( (0, 0), contactListener=self.contactListener_keep_ref) 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 self.verbose = verbose self.fd_tile = Box2D.b2FixtureDef(shape=Box2D.b2PolygonShape( vertices=[(0, 0), (1, 0), (1, -1), (0, -1)])) self.state_temp = None # Yonv1943 self.tile_visited_count = 0 self.road_poly = [] self.transform = None self.t = None self.num_step = 0 self.env_name = 'CarRacingFix' self.state_dim = (STATE_W, STATE_H, 3 * 2) self.action_dim = 6 self.if_discrete = False self.max_step = 512 self.target_return = 950 self.action_max = 1
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 __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 transfer(self): to_transfer = {'fixedRotation': 'fixedRotation', 'userData': 'userData', 'sleepingAllowed': 'allowSleep'} transfer_dict = {} for old_name, new_name in to_transfer.items(): transfer_dict[new_name] = eval('self.b2body.'+old_name) new_b2body = self.world.CreateDynamicBody(**transfer_dict) for fixture in self.b2body.fixtures: to_transfer = {'filterData': 'filter', 'friction': 'friction', 'sensor': 'isSensor', 'userData': 'userData', 'shape': 'shape'} transfer_dict = {} for old_name, new_name in to_transfer.items(): transfer_dict[new_name] = eval('fixture.'+old_name) def_fix = b2.b2FixtureDef(**transfer_dict) new_fixture = new_b2body.CreateFixture(def_fix) handlers = self.b2body.cool_world.true_listener.getHandlers(fixture) if handlers: self.b2body.cool_world.true_listener.removeEventHandler(fixture) self.world.addEventHandler(new_fixture, *handlers) self.b2body.cool_world.destroy_body(self.b2body) self.b2body = new_b2body
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 _create_balls(self, balls_pose): """ Creates the balls in the simulation at the given positions :param balls_pose: Initial pose of the ball in table RF :return: """ ## List of balls in simulation self.balls = [] for idx, pose in enumerate(balls_pose): pose = pose + self.tw_transform ## move balls in world RF ball = self.world.CreateDynamicBody( position=pose, bullet=True, allowSleep=False, userData={'name': 'ball{}'.format(idx)}, linearDamping=1.1, angularDamping=2, fixtures=b2.b2FixtureDef( shape=b2.b2CircleShape(radius=self.params.BALL_RADIUS), density=1, friction=self.params.BALL_FRICTION, restitution=self.params.BALL_ELASTICITY, )) self.balls.append(ball)
def createBoxFixture(pos=(0, 0), width=1.0, height=1.0, bDynamic=True, density=1, collisionGroup=None, restitution=None): global world boxShape = Box2D.b2PolygonShape() boxShape.SetAsBox(width, height, pos, 0) # width, height, position (x,y), angle fixtureDef = Box2D.b2FixtureDef() fixtureDef.shape = boxShape fixtureDef.friction = 0.3 if (abs(world.gravity[1]) > 1): fixtureDef.restitution = 0.6 if (restitution != None): fixtureDef.restitution = restitution if (collisionGroup != None): fixtureDef.filter.groupIndex = collisionGroup if bDynamic: fixtureDef.density = density else: fixtureDef.density = 0 return fixtureDef
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 _poly(self, pos, vertices, dynamic=True, density=1.0, restitution=0.16, friction=0.5): # add a centered poly at pos without correcting any settings # meaning, pos and vertices are in meters 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 polyDef = box2d.b2FixtureDef() polygonShape = box2d.b2PolygonShape() polygonShape.vertices = vertices polyDef.shape = polygonShape polyDef.density = density polyDef.restitution = restitution polyDef.friction = friction body.CreateFixture(polyDef) return body
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 randomize(self, N, x0, x1, rng): # randomize how hilly the terrain is. lower number = softer hills terrain_freq = 10 + 14 * rng.rand() # construct random terrain using frequency domain low-freq noise modulus = np.exp(-np.arange(N) / terrain_freq) * rng.randn(N) argument = rng.randn(N) freqspace = modulus * np.cos(argument) + 1j * modulus * np.sin( argument) z = np.fft.fft(freqspace).real zmin = np.min(z) zmax = np.max(z) self.z = (TERRAIN_Z_RANGE / (zmax - zmin)) * (z - zmin) self.x = np.linspace(x0, x1, N) # construct box2d world for lidar. self.world = Box2D.b2World() verts = zip(self.x, self.z) nverts = len(verts) for i in range(nverts - 1): p0, p1 = verts[i], verts[i + 1] edge = Box2D.b2EdgeShape(vertices=[p0, p1]) body = Box2D.b2BodyDef( type=Box2D.b2_staticBody, fixtures=Box2D.b2FixtureDef(shape=edge, friction=0), ) self.world.CreateBody(body)
def __init__(self, fisica, pilas, x=0, y=0, radio=20, dinamica=True, densidad=1.0, restitucion=0.56, friccion=10.5, amortiguacion=0.1, sin_rotacion=False, sensor=False, interactivo=True): Figura.__init__(self, fisica, pilas) if x is None: x = pilas.azar(10000, 10000 + 100000) if y is None: y = pilas.azar(10000, 10000 + 100000) x = utils.convertir_a_metros(x) y = utils.convertir_a_metros(y) self._radio = utils.convertir_a_metros(radio) self._escala = 1 self.interactivo = interactivo self.fisica = fisica if not self.fisica: self.fisica = pilas.escena_actual().fisica if not dinamica: densidad = 0 fixture = box2d.b2FixtureDef( shape=box2d.b2CircleShape(radius=self._radio), 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 setup_b2body(self): super(Actor, self).setup_b2body() pix_to_tile = pixels_to_tiles rx, ry = pix_to_tile((self.cshape.rx, self.cshape.ry)) self.b2body.CreateFixture( b2.b2FixtureDef( shape=b2.b2PolygonShape( vertices=[(-rx, ry), (-rx, -ry + 0.1), (-rx + 0.1, -ry), (rx - 0.1, -ry), (rx, -ry + 0.1), (rx, ry)] ) ) ) self.b2body.fixtures[-1].filterData.categoryBits = B2SMTH | B2ACTOR self.b2body.CreateFixture( b2.b2FixtureDef(shape=b2.b2EdgeShape(vertex1=(-rx, -ry), vertex2=(rx, -ry)), isSensor=True) ) self.b2body.fixtures[-1].filterData.categoryBits = B2GNDSENS self.b2body.fixtures[-1].filterData.maskBits = B2LEVEL | B2ACTOR self.world.addEventHandler(self.b2body.fixtures[-1], self.on_ground_begin, self.on_ground_end)
def create_bumper(bumper_def): bumper = world.CreateBody(bumper_def) bumperFixture = b2.b2FixtureDef() bumperFixture.friction = 0 bumperFixture.restitution = 0 bumperFixture.density = 1000000 * 1000000 bumperFixture.shape = b2.b2CircleShape(radius=6.5) bumper.CreateFixture(bumperFixture) return bumper
def setup_b2body(self): super(Hit_Zone, self).setup_b2body() cshape = self.cshape hit_shape = self.hit_shape img = self.image if hit_shape is RECTANGLE: rx, ry = pixels_to_tiles((cshape.rx, cshape.ry)) self.b2body.CreateFixture(b2.b2FixtureDef(shape=b2.b2PolygonShape(box=(rx, ry)), isSensor=True, userData=self)) elif hit_shape is LINE: r = pixels_to_tiles(img.width/2.0) self.b2body.CreateFixture(b2.b2FixtureDef(shape=b2.b2PolygonShape(box=(r, 0)), isSensor=True, userData=self)) self.b2body.gravityScale = 0 self.b2body.fixtures[-1].filterData.categoryBits = B2HITZONE self.b2body.fixtures[-1].filterData.maskBits = B2HITZONE | \ B2SWING | B2LEVEL | B2BODYPART self.world.addEventHandler(self.b2body.fixtures[-1], self.on_begin_contact, self.on_end_contact)
def b2drop(self): self.cshape.center = eu.Vector2(self.position[0], self.position[1]) rx, ry = pixels_to_tiles((self.cshape.rx, self.cshape.ry)) self.b2body.CreateFixture(b2.b2FixtureDef(shape=b2.b2PolygonShape(box=(rx, ry)), userData=self)) self.b2body.fixtures[-1].filterData.categoryBits = B2ITEM self.b2body.fixtures[-1].filterData.maskBits = B2LEVEL self.b2body.fixtures[-1].friction = 10 x, y = pixels_to_tiles((self.cshape.center.x, self.cshape.center.y)) self.b2body.position = (x, y) self.b2body.linearVelocity.x = self.master.b2body.linearVelocity.x + pixels_to_tiles(randint(-500, 500)) self.b2body.linearVelocity.y = self.master.b2body.linearVelocity.y + pixels_to_tiles(randint(-100, 100))
def __init__(self, **kwargs): super(Circle, self).__init__(**kwargs) self.hue = random() # Ball self._body = self.world.CreateDynamicBody( fixtures=b2d.b2FixtureDef( shape=b2d.b2CircleShape(radius=self.radius), density=1.0, friction=0.3), bullet=True, position=self.pos)
def add_circle(self, pos, vel): pos = self.renderer.to_world_frame(pos) vel = (self.renderer.pixels_to_meters(vel[0]), -self.renderer.pixels_to_meters(vel[1])) circle = self.world.CreateDynamicBody(position=pos) fixture_def = Box2D.b2FixtureDef(shape=(Box2D.b2CircleShape(radius=5)), density=1, friction=0, restitution=1) circle.CreateFixture(fixture_def) circle.linearVelocity = vel circle.userData = BouncingBalls.BodyData("circle")
def create_polygon(vertices, world): body = world.CreateBody(Box2D.b2BodyDef()) box = Box2D.b2ChainShape(vertices_loop=vertices) fixture = Box2D.b2FixtureDef() fixture.shape = box fixture.density = 2 fixture.friction = .3 fixture.restitution = .5 fixture = body.CreateFixture(fixture) return body, [fixture]
def __init__(self, x0, target, render): self.render = render if self.render: super(PointMassWorld, self).__init__() else: self.world = b2.b2World(gravity=(0, -10), doSleep=True) x0 = np.asfarray(x0) target = np.asfarray(target) 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[:2], 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, fisica, pilas, x, y, ancho, alto, dinamica=True, densidad=1.0, restitucion=0.5, friccion=.2, amortiguacion=0.1, sin_rotacion=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.dinamica = dinamica self.fisica = fisica self.sin_rotacion = sin_rotacion if not self.fisica: self.fisica = pilas.escena_actual().fisica if not self.dinamica: densidad = 0 fixture = box2d.b2FixtureDef( shape=box2d.b2PolygonShape(box=(self._ancho / 2, self._alto / 2)), density=densidad, linearDamping=amortiguacion, friction=friccion, restitution=restitucion) # Agregamos un identificador para controlarlo posteriormente en las # colisiones. self.userData = {'id': self.id} fixture.userData = self.userData if self.dinamica: self._cuerpo = self.fisica.mundo.CreateDynamicBody( position=(x, y), fixtures=fixture) else: self._cuerpo = self.fisica.mundo.CreateKinematicBody( position=(x, y), fixtures=fixture) self._cuerpo.fixedRotation = self.sin_rotacion
def aball(world, x, y, r): sd = box2d.b2PolygonShape() sd.SetAsBox(r, r) sd.restitution = 0.05 bd = box2d.b2BodyDef() bd.position = (x, y) body = world.CreateDynamicBody(position=(x, y)) # body = world.CreateBody(bd) groundBoxFixture = box2d.b2FixtureDef(shape=sd) body.CreateFixture(groundBoxFixture) # body.ResetMassData() return body
def aball(world, x, y, r): sd=box2d.b2PolygonShape() sd.SetAsBox(r, r) sd.restitution = 0.05 bd=box2d.b2BodyDef() bd.position = (x, y) body = world.CreateDynamicBody(position=(x,y)) # body = world.CreateBody(bd) groundBoxFixture=box2d.b2FixtureDef(shape=sd) body.CreateFixture(groundBoxFixture) # body.ResetMassData() return body
def recreate(self, radius, n): self.radius = radius if n < 3: n = 3 self.n = n for f in self.body.fixtures: self.body.DestroyFixture(f) for vertices in self._polyhedron_full(r=radius, n=n): fixture = B2.b2FixtureDef( shape=B2.b2PolygonShape(vertices=vertices), density=50, friction=5, ) self.body.CreateFixture(fixture)
def addSensor(self, world, cfg): sensorFov = b2.b2PolygonShape() # Define sensor shape w, h = cfg.fov.width, cfg.fov.height self.fov = (w,h) fov = np.array([(-0.5*w,-0.5*h),(0.5*w,-0.5*h), (0.5*w,0.5*h),(-0.5*w, 0.5*h)]) # Move sensor relative to the body relpos = np.array([cfg.relpos.x, cfg.relpos.y]) sensorFov.vertices = (fov+relpos).tolist() sensorFixtureDef = b2.b2FixtureDef() sensorFixtureDef.isSensor = True sensorFixtureDef.shape = sensorFov self.sensor = self.body.CreateFixture(sensorFixtureDef)
def _init_box2d(self): assert (self.x is not None) assert (self.z is not None) # construct box2d world for lidar. self.world = Box2D.b2World() verts = zip(self.x, self.z) nverts = len(verts) for i in range(nverts - 1): p0, p1 = verts[i], verts[i + 1] edge = Box2D.b2EdgeShape(vertices=[p0, p1]) body = Box2D.b2BodyDef( type=Box2D.b2_staticBody, fixtures=Box2D.b2FixtureDef(shape=edge, friction=0), ) self.world.CreateBody(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, plataforma=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 if plataforma: self._cuerpo = self.fisica.mundo.CreateStaticBody(position=(x, y), fixtures=fixture) self.dinamica = False else: self._cuerpo = self.fisica.mundo.CreateDynamicBody(position=(x, y), fixtures=fixture) self.dinamica = dinamica self.sin_rotacion = sin_rotacion self.sensor = sensor if not dinamica: self._cuerpo.mass = 1000000
def abox(world, x, y, w, h): sd = box2d.b2PolygonShape() sd.SetAsBox(w, h) sd.density = 2.0 sd.friction = 0.3 sd.restitution = 0.2 bd = box2d.b2BodyDef() bd.position = (x, y) body = world.CreateDynamicBody(position=(x, y)) # body = world.CreateBody(bd) groundBoxFixture = box2d.b2FixtureDef(shape=sd) body.CreateFixture(groundBoxFixture) body.ResetMassData() body.inertia = .02 body.mass = 1 return body
def abox(world, x, y, w, h): sd=box2d.b2PolygonShape() sd.SetAsBox(w, h) sd.density = 2.0 sd.friction = 0.3 sd.restitution = 0.2 bd=box2d.b2BodyDef() bd.position = (x, y) body = world.CreateDynamicBody(position=(x,y)) # body = world.CreateBody(bd) groundBoxFixture=box2d.b2FixtureDef(shape=sd) body.CreateFixture(groundBoxFixture) body.ResetMassData() body.inertia = .02 body.mass = 1 return body
def __crear_fixture(self): fixture = box2d.b2FixtureDef(shape=box2d.b2PolygonShape(box=(self._ancho/2, self._alto/2)), density=self._cuerpo.fixtures[0].density, linearDamping=self._cuerpo.fixtures[0].body.linearDamping, friction=self._cuerpo.fixtures[0].friction, restitution=self._cuerpo.fixtures[0].restitution) fixture.userData = self.userData self.fisica.mundo.DestroyBody(self._cuerpo) if self.dinamica: self._cuerpo = self.fisica.mundo.CreateDynamicBody(position=(self._cuerpo.position.x, self._cuerpo.position.y), angle=self._cuerpo.angle, linearVelocity=self._cuerpo.linearVelocity, fixtures=fixture) else: self._cuerpo = self.fisica.mundo.CreateKinematicBody(position=(self._cuerpo.position.x, self._cuerpo.position.y), angle=self._cuerpo.angle, fixtures=fixture) self._cuerpo.fixedRotation = self.sin_rotacion
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 geraBody(world, obj): bodyDef = b2.b2BodyDef() bodyDef.position = obj["pos"] bodyDef.type = obj["type"] bodyDef.angle = obj["angle"] body = world.CreateBody(bodyDef) fixDef = b2.b2FixtureDef() fixDef.shape = obj["shape"] fixDef.restitution = obj["restitution"] fixDef.friction = obj["friction"] fixDef.density = obj["density"] body.CreateFixture(fixDef) body.userData = obj return body
def createBoxFixture(body, pos = (0,0), width=1.0, height=1.0, dynamic=True, collisionGroup = None, restitution=None): global world boxShape = Box2D.b2PolygonShape() boxShape.SetAsBox(width, height, pos, 0) # width, height, position (x,y), angle fixtureDef = Box2D.b2FixtureDef() fixtureDef.shape = boxShape fixtureDef.friction = 0.3 if(abs(world.gravity[1]) > 1): fixtureDef.restitution = 0.6 if(restitution != None): fixtureDef.restitution = restitution if(collisionGroup!=None): fixtureDef.filter.groupIndex = collisionGroup if dynamic: fixtureDef.density = 1 else: fixtureDef.density = 0 return fixtureDef
def create_obstacle(self, obstacle_spec): obstacle_body_def = Box2D.b2BodyDef() obstacle_body_def.position = (0, 0) obstacle_body = self.world.CreateBody(obstacle_body_def) v = [] for vertex in obstacle_spec["geometry"]['coordinates']: v.append((vertex[0], vertex[1])) obstacle_box = Box2D.b2PolygonShape(vertices=v) obstacle_box_fixture = Box2D.b2FixtureDef(shape=obstacle_box) if "properties" in obstacle_spec: if obstacle_spec["properties"]['collisionGroup']: obstacle_box_fixture.filter.groupIndex = obstacle_spec["properties"]['collisionGroup'] obstacle_body.CreateFixture(obstacle_box_fixture)
def definir_escala(self, escala): self._escala = escala 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=self._cuerpo.fixtures[0].density, linearDamping=self._cuerpo.fixtures[0].body.linearDamping, friction=self._cuerpo.fixtures[0].friction, restitution=self._cuerpo.fixtures[0].restitution) fixture.userData = self.userData self.fisica.mundo.DestroyBody(self._cuerpo) if self.dinamica: self._cuerpo = self.fisica.mundo.CreateDynamicBody(position=(self._cuerpo.position.x, self._cuerpo.position.y), angle=self._cuerpo.angle, linearVelocity=self._cuerpo.linearVelocity, fixtures=fixture) else: self._cuerpo = self.fisica.mundo.CreateKinematicBody(position=(self._cuerpo.position.x, self._cuerpo.position.y), angle=self._cuerpo.angle, fixtures=fixture) self._cuerpo.fixedRotation = self.sin_rotacion
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 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 test_helloworld(self): gravity = Box2D.b2Vec2(0, -10) doSleep = True world = Box2D.b2World(gravity, doSleep) groundBodyDef = Box2D.b2BodyDef() groundBodyDef.position = [0, -10] groundBody = world.CreateBody(groundBodyDef) groundBox = Box2D.b2PolygonShape() groundBox.SetAsBox(50, 10) groundBody.CreateFixturesFromShapes(groundBox) bodyDef = Box2D.b2BodyDef() bodyDef.type = Box2D.b2_dynamicBody bodyDef.position = (0, 4) body = world.CreateBody(bodyDef) dynamicBox = Box2D.b2PolygonShape() dynamicBox.SetAsBox(1, 1) fixtureDef = Box2D.b2FixtureDef() fixtureDef.shape = dynamicBox fixtureDef.density = 1 fixtureDef.friction = 0.3 body.CreateFixture(fixtureDef) timeStep = 1.0 / 60 vel_iters, pos_iters = 6, 2 for i in range(60): world.Step(timeStep, vel_iters, pos_iters) world.ClearForces()
def test_helloworld(self): gravity = Box2D.b2Vec2(0, -10) doSleep = True world = Box2D.b2World(gravity, doSleep) groundBodyDef = Box2D.b2BodyDef() groundBodyDef.position = [0, -10] groundBody = world.CreateBody(groundBodyDef) groundBox = Box2D.b2PolygonShape() groundBox.SetAsBox(50, 10) groundBody.CreateFixturesFromShapes(groundBox) bodyDef = Box2D.b2BodyDef() bodyDef.type = Box2D.b2_dynamicBody bodyDef.position = (0, 4) body = world.CreateBody(bodyDef) dynamicBox = Box2D.b2PolygonShape() dynamicBox.SetAsBox(1, 1) fixtureDef = Box2D.b2FixtureDef() fixtureDef.shape = dynamicBox fixtureDef.density = 1 fixtureDef.friction = 0.3 body.CreateFixture(fixtureDef) timeStep = 1.0 / 60 vel_iters, pos_iters = 6, 2 for i in range(60): world.Step(timeStep, vel_iters, pos_iters) world.ClearForces()
def __init__(self, x, y, ancho, alto, dinamica=True, densidad=1.0, restitucion=0.5, friccion=.2, amortiguacion=0.1, fisica=None, sin_rotacion=False): Figura.__init__(self) x = convertir_a_metros(x) y = convertir_a_metros(y) self._ancho = convertir_a_metros(ancho) self._alto = convertir_a_metros(alto) self._escala = 1 self.dinamica = dinamica self.fisica = fisica self.sin_rotacion = sin_rotacion if not self.fisica: self.fisica = pilas.escena_actual().fisica if not self.dinamica: densidad = 0 fixture = box2d.b2FixtureDef(shape=box2d.b2PolygonShape(box=(self._ancho/2, self._alto/2)), density=densidad, linearDamping=amortiguacion, friction=friccion, restitution=restitucion) # Agregamos un identificador para controlarlo posteriormente en las # colisiones. self.userData = { 'id' : self.id } fixture.userData = self.userData if self.dinamica: self._cuerpo = self.fisica.mundo.CreateDynamicBody(position=(x, y), fixtures=fixture) else: self._cuerpo = self.fisica.mundo.CreateKinematicBody(position=(x, y), fixtures=fixture) self._cuerpo.fixedRotation = self.sin_rotacion
def __init__(self, fisica, pilas, x, y, radio, dinamica=True, densidad=1.0, restitucion=0.56, friccion=10.5, amortiguacion=0.1, sin_rotacion=False): Figura.__init__(self, fisica, pilas) x = utils.convertir_a_metros(x) y = utils.convertir_a_metros(y) self._radio = utils.convertir_a_metros(radio) self._escala = 1 self.dinamica = dinamica self.fisica = fisica self.sin_rotacion = sin_rotacion if not self.fisica: self.fisica = pilas.escena_actual().fisica if not self.dinamica: densidad = 0 fixture = box2d.b2FixtureDef(shape=box2d.b2CircleShape(radius=self._radio), density=densidad, linearDamping=amortiguacion, friction=friccion, restitution=restitucion) # Agregamos un identificador para controlarlo posteriormente en las # colisiones. self.userData = { 'id' : self.id } fixture.userData = self.userData if self.dinamica: self._cuerpo = self.fisica.mundo.CreateDynamicBody(position=(x, y), fixtures=fixture) else: self._cuerpo = self.fisica.mundo.CreateKinematicBody(position=(x, y), fixtures=fixture) self._cuerpo.fixedRotation = self.sin_rotacion
def createTri(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 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) if(bMatplotlib): createGlobalFigure() fixture.userData = drawTri(ax,position,r) return body
def _create_fixtures(left_border : float, right_border : float, bottom_border : float, top_border : float): # create in clockwise rotation so the edges face inwards vertices = ( (left_border, bottom_border), (left_border, top_border), (right_border, top_border), (right_border, bottom_border) ) fixture_defs = [] for i, _ in enumerate(vertices): next_i = (i + 1) % 4 side_border_shape = Box2D.b2EdgeShape() side_border_shape.vertex1 = vertices[i] side_border_shape.vertex2 = vertices[next_i] border_fixture_def = Box2D.b2FixtureDef() border_fixture_def.shape = side_border_shape border_fixture_def.friction = 0 border_fixture_def.density = 0 border_fixture_def.filter.categoryBits = CollisionFilterCategory.BORDER fixture_defs.append(border_fixture_def) return fixture_defs
def runsim(GD, locs, seed, mapgen, vel, frames, slowmo = 1): random.seed(seed) # Define the size of the world. Simulation will still work # if bodies reach the end of the world, but it will be slower. worldAABB=box2d.b2AABB() worldAABB.lowerBound = (-100, -100) worldAABB.upperBound = ( 100, 100) # Define the gravity vector. gravity = box2d.b2Vec2(0, -10) # Do we want to let bodies sleep? doSleep = False # Construct a world object, which will hold and simulate the rigid bodies. world = box2d.b2World(gravity, doSleep) if 1: sd=box2d.b2PolygonShape() sd.SetAsBox(50.0, 10.0) bd=box2d.b2BodyDef() bd.position = (0.0, -10.05) ground = world.CreateBody(bd) groundBoxFixture=box2d.b2FixtureDef(shape=sd) ground.CreateFixture(groundBoxFixture) else: # Define the ground body. groundBodyDef = box2d.b2BodyDef() groundBodyDef.position = [0, -10] # Call the body factory which allocates memory for the ground body # from a pool and creates the ground box shape (also from a pool). # The body is also added to the world. groundBody = world.CreateBody(groundBodyDef) # Define the ground box shape. groundShapeDef = box2d.b2PolygonShape() # The extents are the half-widths of the box. groundShapeDef.SetAsBox(50, 10) # Add the ground shape to the ground body. help(groundBody) groundBody.CreateShape(groundShapeDef) bodies = [b for b in mapgen(world)] # Prepare for simulation. Typically we use a time step of 1/60 of a # second (60Hz) and 10 velocity/8 position iterations. This provides a # high quality simulation in most game scenarios. timeStep = 1.0 / 60 vel_iters, pos_iters = 10, 8 vel_iters, pos_iters = 1000, 1000 # class MyContactListener(box2d.b2ContactListener): # def __init__(self): # self.contact = False # super(MyContactListener, self).__init__() # def Add(self, point): # if box2d.b2CircleShape in (type(point.shape1), type(point.shape2)): # self.contact = True # contactListener = MyContactListener() # world.SetContactListener(contactListener) def bodxy(b): x,y = int((220 + 60 * (b.position.x + ox))), int((270 - 60 * (b.position.y + oy))) return x - 16,y-16 bullet = None yground = 265 time = 0.0 for f in range(800): t = min(1, f / 400.) xorg = -900 + 900 * smoothstep(t) # GD.scrollxy(xorg, 0) # COMM+0 SCROLL_X for top section # COMM+2 SCROLL_Y for top section # COMM+4 Y-coordinate of start of middle section # COMM+6 SCROLL_X for middle section # COMM+8 SCROLL_Y for middle section # COMM+10 Y-coordinate of start of bottom section # COMM+12 SCROLL_X for bottom section # COMM+14 SCROLL_Y for bottom section GD.wrstr(gd.COMM, array.array('H', [ int(xorg / 4) & 511, 0, 90, int(xorg / 2) & 511,0, 34 * 8, int(xorg) & 511,0])) world.Step(timeStep, vel_iters, pos_iters) for i,b in enumerate(bodies): (ox, oy) = (0,0) x,y = bodxy(b) a = (f/4) % 120 a = int(30 * b.angle / (math.pi / 2)) % 120 fr = a % 30 rot = (a/30) % 4 tab = ([0,1,2,3], [1,3,0,2], [3,2,1,0], [2,0,3,1])[rot] for j in range(4): frame,pal = locs[4*fr+tab[j]] GD.sprite(4 * i + j, x + (16 * (j % 2)) - xorg, y + 16 * (j / 2), frame, pal, [0,3,6,5][rot]) if bullet: x,y = bodxy(bullet) GD.sprite(255, x + 8, y + 8, 63, 0) GD.sync_spr() GD.wait() time += timeStep if f == 400: GD.pause() bullet = aball(world, -4, 0, .1) bullet.mass = 9 bullet.linearVelocity = box2d.b2Vec2(8,4) * 1
def json_load(self, path, serialized=False): import json self.world.groundBody.userData = {"saveid": 0} f = open(path, 'r') worldmodel = json.loads(f.read()) f.close() # clean world for joint in self.world.joints: self.world.DestroyJoint(joint) for body in self.world.bodies: if body != self.world.groundBody: self.world.DestroyBody(body) # load bodies for body in worldmodel['bodylist']: bodyDef = box2d.b2BodyDef() if body['dynamic']: bodyDef.type = box2d.b2_dynamicBody bodyDef.position = body['position'] bodyDef.userData = body['userData'] bodyDef.angle = body['angle'] newBody = self.world.CreateBody(bodyDef) # _logger.debug(newBody) newBody.angularVelocity = body['angularVelocity'] newBody.linearVelocity = body['linearVelocity'] if 'shapes' in body: for shape in body['shapes']: if shape['type'] == 'polygon': polyDef = box2d.b2FixtureDef() polyShape = box2d.b2PolygonShape() polyShape.vertices = shape['vertices'] polyDef.shape = polyShape polyDef.density = shape['density'] polyDef.restitution = shape['restitution'] polyDef.friction = shape['friction'] newBody.CreateFixture(polyDef) if shape['type'] == 'circle': circleDef = box2d.b2FixtureDef() circleShape = box2d.b2CircleShape() circleShape.radius = shape['radius'] circleShape.pos = shape['localPosition'] circleDef.shape = circleShape circleDef.density = shape['density'] circleDef.restitution = shape['restitution'] circleDef.friction = shape['friction'] newBody.CreateFixture(circleDef) for joint in worldmodel['jointlist']: if joint['type'] == 'distance': jointDef = box2d.b2DistanceJointDef() body1 = self.getBodyWithSaveId(joint['body1']) anch1 = joint['anchor1'] body2 = self.getBodyWithSaveId(joint['body2']) anch2 = joint['anchor2'] jointDef.collideConnected = joint['collideConnected'] jointDef.Initialize(body1, body2, anch1, anch2) jointDef.userData = joint['userData'] self.world.CreateJoint(jointDef) if joint['type'] == 'revolute': jointDef = box2d.b2RevoluteJointDef() body1 = self.getBodyWithSaveId(joint['body1']) body2 = self.getBodyWithSaveId(joint['body2']) anchor = joint['anchor'] jointDef.Initialize(body1, body2, anchor) jointDef.userData = joint['userData'] jointDef.motorEnabled = joint['enableMotor'] jointDef.motorSpeed = joint['motorSpeed'] jointDef.maxMotorTorque = joint['maxMotorTorque'] self.world.CreateJoint(jointDef) self.additional_vars = {} addvars = {} for (k, v) in list(worldmodel['additional_vars'].items()): addvars[k] = v if serialized and 'trackinfo' in addvars: trackinfo = addvars['trackinfo'] for key, info in trackinfo.items(): if not info[3]: addvars['trackinfo'][key][0] = \ self.getBodyWithSaveId(info[0]) addvars['trackinfo'][key][1] = \ self.getBodyWithSaveId(info[1]) else: addvars['trackinfo'][key][0] = None addvars['trackinfo'][key][1] = None self.additional_vars = addvars for body in self.world.bodies: del body.userData['saveid'] # remove temporary data
#for val1,val2 in tail: # print val1,val2 tailm = [(val1 / PPM, val2 / PPM) for val1, val2 in tail] bottomm = [(val1 / PPM, val2 / PPM) for val1, val2 in bottom] topm = [(val1 / PPM, val2 / PPM) for val1, val2 in top] nosem = [(val1 / PPM, val2 / PPM) for val1, val2 in nose] #print tailm #print bottomm body = world.CreateDynamicBody( position=(10, 10), angle=pi, angularDamping=5, linearDamping=0.1, shapes=[Box2D.b2PolygonShape(vertices=tailm)], #Box2D.b2PolygonShape(vertices=restm) ], shapeFixture=Box2D.b2FixtureDef(density=20.0), ) #body=world.CreateDynamicBody(position=(13,10), angle=0) #crusaderTail=body.CreatePolygonFixture( # Box2D.b2PolygonShape(vertices=[(-1,0), (1,0), (0,.5)]) # , density=1, friction=0.3) #body=world.CreateDynamicBody(position=(13,14), angle=0) #crusaderTail=body.CreatePolygonFixture(rest, density=1, friction=0.3) colors = { staticBody: (255, 255, 255, 255), dynamicBody: (127, 127, 127, 255), } strips = getSpriteStrips()
def add_fixture( b2_world_body, jsw, jsw_fixture, ): # create and fill fixture definition fixtureDef = b2.b2FixtureDef() # Done with issues: ### missing pybox2d "filter" b2BodyDef property # special case for rube documentation of #"filter-categoryBits": 1, //if not present, interpret as 1 if "filter-categoryBits" in jsw_fixture.keys(): setAttr(jsw_fixture, "filter-categoryBits", fixtureDef, "categoryBits") else: fixtureDef.categoryBits = 1 # special case for Rube Json property #"filter-maskBits": 1, //if not present, interpret as 65535 if "filter-maskBits" in jsw_fixture.keys(): setAttr(jsw_fixture, "filter-maskBits", fixtureDef, "maskBits") else: fixtureDef.maskBits = 65535 setAttr(jsw_fixture, "density", fixtureDef) setAttr(jsw_fixture, "filter-groupIndex", fixtureDef, "groupIndex") setAttr(jsw_fixture, "friction", fixtureDef) setAttr(jsw_fixture, "sensor", fixtureDef, "isSensor") setAttr(jsw_fixture, "restitution", fixtureDef) # fixture has one shape that is # polygon, circle or chain in json # chain may be open or loop, or edge in pyBox2D if "circle" in jsw_fixture.keys(): # works ok if jsw_fixture["circle"]["center"] == 0: center_b2Vec2 = b2.b2Vec2(0, 0) else: center_b2Vec2 = rubeVecToB2Vec2( jsw_fixture["circle"]["center"] ) fixtureDef.shape = b2.b2CircleShape( pos=center_b2Vec2, radius=jsw_fixture["circle"]["radius"], ) if "polygon" in jsw_fixture.keys(): # works ok polygon_vertices = rubeVecArrToB2Vec2Arr( jsw_fixture["polygon"]["vertices"] ) fixtureDef.shape = b2.b2PolygonShape(vertices=polygon_vertices) if "chain" in jsw_fixture.keys(): # works ok chain_vertices = rubeVecArrToB2Vec2Arr( jsw_fixture["chain"]["vertices"] ) if len(chain_vertices) >= 3: # closed-loop b2LoopShape # Done if "hasNextVertex" in jsw_fixture["chain"].keys(): # del last vertice to prevent crash from first and last # vertices being to close del chain_vertices[-1] fixtureDef.shape = b2.b2LoopShape( vertices_loop=chain_vertices, count=len(chain_vertices), ) setAttr( jsw_fixture["chain"], "hasNextVertex", fixtureDef.shape, "m_hasNextVertex", ) setB2Vec2Attr( jsw_fixture["chain"], "nextVertex", fixtureDef, "m_nextVertex", ) setAttr( jsw_fixture["chain"], "hasPrevVertex", fixtureDef.shape, "m_hasPrevVertex", ) setB2Vec2Attr( jsw_fixture["chain"], "prevVertex", fixtureDef.shape, "m_prevVertex" ) else: # open-ended ChainShape # Done fixtureDef.shape = b2.b2ChainShape( vertices_chain=chain_vertices, count=len(chain_vertices), ) # json chain is b2EdgeShape # Done if len(chain_vertices) < 3: fixtureDef.shape = b2.b2EdgeShape( vertices=chain_vertices, ) # create fixture b2_world_body.CreateFixture(fixtureDef)
def __init__(self, x0, target): super(Arm3World, self).__init__() self.world.gravity = (0.0, 0.0) fixture_length = 5.0 self.x0 = x0 rectangle_fixture = b2.b2FixtureDef( shape=b2.b2PolygonShape(box=(.5, fixture_length)), density=.5, friction=1, ) square_fixture = b2.b2FixtureDef( shape=b2.b2PolygonShape(box=(1, 1)), density=100.0, friction=1, ) self.base = self.world.CreateBody( position=(0, 15), fixtures=square_fixture, ) self.body1 = self.world.CreateDynamicBody( position=(0, 2), fixtures=rectangle_fixture, angle=b2.b2_pi, ) self.body2 = self.world.CreateDynamicBody( fixtures=rectangle_fixture, position=(0, 2), angle=b2.b2_pi, ) self.body3 = self.world.CreateDynamicBody( fixtures=rectangle_fixture, position=(0, 2), angle=b2.b2_pi, ) self.target1 = self.world.CreateDynamicBody( fixtures=rectangle_fixture, position=(0, 0), angle=b2.b2_pi, ) self.target2 = self.world.CreateDynamicBody( fixtures=rectangle_fixture, position=(0, 0), angle=b2.b2_pi, ) self.target3 = self.world.CreateDynamicBody( fixtures=rectangle_fixture, position=(0, 0), angle=b2.b2_pi, ) self.joint1 = self.world.CreateRevoluteJoint( bodyA=self.base, bodyB=self.body1, localAnchorA=(0, 0), localAnchorB=(0, fixture_length), enableMotor=True, maxMotorTorque=400, enableLimit=False, ) self.joint2 = self.world.CreateRevoluteJoint( bodyA=self.body1, bodyB=self.body2, localAnchorA=(0, -(fixture_length - 0.5)), localAnchorB=(0, fixture_length - 0.5), enableMotor=True, maxMotorTorque=400, enableLimit=False, ) self.joint3 = self.world.CreateRevoluteJoint( bodyA=self.body2, bodyB=self.body3, localAnchorA=(0, -(fixture_length - 0.5)), localAnchorB=(0, fixture_length - 0.5), enableMotor=True, maxMotorTorque=400, enableLimit=False, ) self.set_joint_angles(self.body1, self.body2, self.body3, x0[0], x0[1], x0[2] ) self.set_joint_angles(self.target1, self.target2, self.target3, target[0], target[1], target[2] ) self.target1.active = False self.target2.active = False self.joint1.motorSpeed = x0[3] self.joint2.motorSpeed = x0[4] self.joint3.motorSpeed = x0[5]
def concavePoly(self, vertices, dynamic=True, density=1.0, restitution=0.16, friction=0.5, screenCoord=True): # 1. Step: Reduce # Detect if the polygon is closed or open if vertices[0] != vertices[-1]: is_closed = False else: is_closed = True # Continue reducing the vertecs x, y = c = tools_poly.calc_center(vertices) vertices = tools_poly.poly_center_vertices(vertices) # Bring coordinates into the world coordinate system (flip, camera # offset, ...) if screenCoord: x, y = self.parent.to_world(c) else: x, y = c # If required, translate pixel -> meters if self.parent.input == INPUT_PIXELS: # translate pixel -> meters x /= self.parent.ppm y /= self.parent.ppm # Let's add the body 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 # Create the reusable Box2D polygon and circle definitions polyDef = box2d.b2PolygonShape() polyDef.vertexCount = 4 # rectangle polyDef.density = density polyDef.restitution = restitution polyDef.friction = friction circleShape = box2d.b2CircleShape() circleShape.radius = radius circleDef = box2d.b2FixtureDef() circleDef.shape = circleShape circleDef.density = density circleDef.restitution = restitution circleDef.friction = friction # Set the scale factor factor = 8.0 v2 = box2d.b2Vec2(*vertices[0]) for v in vertices[1:]: v1 = v2.copy() v2 = box2d.b2Vec2(*v) vdir = v2 - v1 # (v2x-v1x, v2y-v1y) vdir.Normalize() # we need a little size for the end part vn = box2d.b2Vec2(-vdir.y * factor, vdir.x * factor) v = [v1 + vn, v1 - vn, v2 - vn, v2 + vn] # Create a line (rect) for each part of the polygon, # and attach it to the body polyDef.setVertices([vi / self.parent.ppm for vi in v]) try: polyDef.checkValues() except ValueError: print "concavePoly: Created an invalid polygon!" return None body.CreateFixture(polyDef) # Now add a circle to the points between the rects # to avoid sharp edges and gaps if not is_closed and v2.tuple() == vertices[-1]: # Don't add a circle at the end break circleDef.localPosition = v2 / self.parent.ppm body.CreateFixture(circleDef) # Return hard and soft reduced vertices return body
def __init__(self, player, level, level_width, level_height): worldAABB = b2.b2AABB() worldAABB.upperBound = (.5, .5) worldAABB.lowerBound = (level_width, level_height) gravity = (0, 0) doSleep = True self.world = b2.b2World(gravity, doSleep) wall_shape = b2.b2PolygonShape() wall_shape.SetAsBox(.5, .5) wall_fixture = b2.b2FixtureDef() wall_fixture.shape = wall_shape wall_fixture.density = 5.0 wall_fixture.friction = 0.5 wall_fixture.reistitution = 0 wall_body = b2.b2BodyDef() wall_body.type = b2.b2_staticBody wall_body.angle = 0 wall_body.allowSleep = True wall_body.awake = False wall_body.fixedRotation = True wall_body.fixtures = [wall_fixture] for x in range(level_width): for y in range(level_height): if level[(x, y)].blocked: wall_body.position = (x+0.5, y+.5) level[(x, y)].body = self.world.CreateBody(wall_body) player_shape = b2.b2CircleShape() player_shape.radius = 0.3 player_fixture = b2.b2FixtureDef() player_fixture.shape = player_shape player_fixture.density = 1 player_fixture.friction = 0.5 player_fixture.reistitution = 5 player_body = b2.b2BodyDef() player_body.type = b2.b2_dynamicBody player_body.angle = radians(player.heading) player_body.position = (player.ux, player.uy) player_body.allowSleep = True player_body.awake = True player_body.fixtures = [player_fixture] player_body.linearDamping = 3.5 player.body = self.world.CreateBody(player_body) mob_shape = b2.b2CircleShape() mob_shape.radius = 0.5 mob_fixture = b2.b2FixtureDef() mob_fixture.shape = mob_shape mob_fixture.density = 1 mob_fixture.friction = 0.5 mob_fixture.reistitution = 5 self.mob_body = b2.b2BodyDef() self.mob_body.type = b2.b2_dynamicBody # self.mob_body.type = b2.b2_staticBody self.mob_body.linearDamping = 3.5/2 self.mob_body.allowSleep = True self.mob_body.awake = True self.mob_body.fixtures = [mob_fixture] self.mob_body.angle = radians(0)
def _create_robotarm(self, arm_position=None): """ Creates the robotic arm. :param arm_position: Initial angular position :return: """ arm_pose = self._calculate_arm_pose(arm_position) link0 = self.world.CreateDynamicBody( position=arm_pose['link0_center'], angle=arm_pose['link0_angle'], bullet=True, allowSleep=False, userData={'name': 'link0'}, fixtures=b2.b2FixtureDef( shape=b2.b2PolygonShape(box=(self.params.LINK_THICKNESS, self.params.LINK_0_LENGTH / 2)), density=5, friction=self.params.LINK_FRICTION, restitution=self.params.LINK_ELASTICITY)) # The -.1 in the position is so that the two links can overlap in order to create the joint link1 = self.world.CreateDynamicBody( position=arm_pose['link1_center'], angle=arm_pose['link1_angle'], bullet=True, allowSleep=False, userData={'name': 'link1'}, fixtures=b2.b2FixtureDef( shape=b2.b2PolygonShape(box=(self.params.LINK_THICKNESS, self.params.LINK_1_LENGTH / 2)), density=1, friction=self.params.LINK_FRICTION, restitution=self.params.LINK_ELASTICITY)) jointW0 = self.world.CreateRevoluteJoint( bodyA=self.walls[3], bodyB=link0, anchor=self.walls[3].worldCenter, lowerAngle=-.4 * b2.b2_pi - arm_pose['link0_angle'], upperAngle=.4 * b2.b2_pi - arm_pose['link0_angle'], enableLimit=True, maxMotorTorque=100.0, motorSpeed=0.0, enableMotor=True) joint01 = self.world.CreateRevoluteJoint( bodyA=link0, bodyB=link1, anchor=arm_pose['joint01_center'], lowerAngle=-b2.b2_pi * 0.9 + arm_pose['link0_angle'] - arm_pose['link1_angle'], upperAngle=b2.b2_pi * 0.9 + arm_pose['link0_angle'] - arm_pose['link1_angle'], enableLimit=True, maxMotorTorque=100.0, motorSpeed=0.0, enableMotor=True) ## Arm definition with links and joints self.arm = { 'link0': link0, 'link1': link1, 'joint01': joint01, 'jointW0': jointW0 }
def json_load(self, path, serialized=False): import json self.world.groundBody.userData = {"saveid": 0} f = open(path, 'r') worldmodel = json.loads(f.read()) f.close() # clean world for joint in self.world.joints: self.world.DestroyJoint(joint) for body in self.world.bodies: if body != self.world.groundBody: self.world.DestroyBody(body) # load bodies for body in worldmodel['bodylist']: bodyDef = box2d.b2BodyDef() if body['dynamic']: bodyDef.type = box2d.b2_dynamicBody bodyDef.position = body['position'] bodyDef.userData = body['userData'] bodyDef.angle = body['angle'] newBody = self.world.CreateBody(bodyDef) # _logger.debug(newBody) newBody.angularVelocity = body['angularVelocity'] newBody.linearVelocity = body['linearVelocity'] if 'shapes' in body: for shape in body['shapes']: if shape['type'] == 'polygon': polyDef = box2d.b2FixtureDef() polyShape = box2d.b2PolygonShape() polyShape.vertices = shape['vertices'] polyDef.shape = polyShape polyDef.density = shape['density'] polyDef.restitution = shape['restitution'] polyDef.friction = shape['friction'] newBody.CreateFixture(polyDef) if shape['type'] == 'circle': circleDef = box2d.b2FixtureDef() circleShape = box2d.b2CircleShape() circleShape.radius = shape['radius'] circleShape.pos = shape['localPosition'] circleDef.shape = circleShape circleDef.density = shape['density'] circleDef.restitution = shape['restitution'] circleDef.friction = shape['friction'] newBody.CreateFixture(circleDef) for joint in worldmodel['jointlist']: if joint['type'] == 'distance': jointDef = box2d.b2DistanceJointDef() body1 = self.getBodyWithSaveId(joint['body1']) anch1 = joint['anchor1'] body2 = self.getBodyWithSaveId(joint['body2']) anch2 = joint['anchor2'] jointDef.collideConnected = joint['collideConnected'] jointDef.Initialize(body1, body2, anch1, anch2) jointDef.userData = joint['userData'] self.world.CreateJoint(jointDef) if joint['type'] == 'revolute': jointDef = box2d.b2RevoluteJointDef() body1 = self.getBodyWithSaveId(joint['body1']) body2 = self.getBodyWithSaveId(joint['body2']) anchor = joint['anchor'] jointDef.Initialize(body1, body2, anchor) jointDef.userData = joint['userData'] jointDef.motorEnabled = joint['enableMotor'] jointDef.motorSpeed = joint['motorSpeed'] jointDef.maxMotorTorque = joint['maxMotorTorque'] self.world.CreateJoint(jointDef) self.additional_vars = {} addvars = {} for (k, v) in worldmodel['additional_vars'].items(): addvars[k] = v if serialized and 'trackinfo' in addvars: trackinfo = addvars['trackinfo'] for key, info in trackinfo.iteritems(): if not info[3]: addvars['trackinfo'][key][0] = \ self.getBodyWithSaveId(info[0]) addvars['trackinfo'][key][1] = \ self.getBodyWithSaveId(info[1]) else: addvars['trackinfo'][key][0] = None addvars['trackinfo'][key][1] = None self.additional_vars = addvars for body in self.world.bodies: del body.userData['saveid'] # remove temporary data