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, x0, target, render):
self.render = render
if self.render:
super(CarWorld, self).__init__()
else:
self.world = b2.b2World(gravity=(0, 0), doSleep=True)
self.world.gravity = (0.0, 0.0)
self.initial_position = (x0[0], x0[1])
self.initial_angle = 0
ground = self.world.CreateBody(position=(0, 20))
ground.CreateEdgeChain(
[(-10, -30),
(-10, 5),
(-30, 30),]
)
ground.CreateEdgeChain(
[(10, -30),
(10, 5),
(-10, 30),]
)
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.car = TDCar(self.world, position=self.initial_position, angle=self.initial_angle)
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
self.start = self.world.CreateStaticBody(
position=self.initial_position,
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.start.active = False
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 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 __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 _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 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 __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 __init__(self, seg_vertices=None, **kwargs):
super().__init__(**kwargs)
# TODO: right now this assumes that all subpolygons have the same number of edges
# TODO: rewrite such that arbitrary subpolygons can be used here
vertices = seg_vertices
centroid = np.zeros(2)
area = .0
for vs in vertices:
# compute centroid of circle_to_polygon
r0 = np.roll(vs[:, 0], 1)
r1 = np.roll(vs[:, 1], 1)
a = 0.5 * np.abs(np.dot(vs[:, 0], r1) - np.dot(vs[:, 1], r0))
area += a
# FIXME This changed in refactoring. It is wrong probably.
# Find a way to use compute_centroid(points) function
centroid += np.mean(vs, axis=0) * a
centroid /= area
self.__local_vertices = vertices - centroid
self.__local_vertices.setflags(write=False)
for v in self.__local_vertices:
self._body.CreatePolygonFixture(
shape=Box2D.b2PolygonShape(vertices=v.tolist()),
density=self.physics_pars['density'],
friction=self.physics_pars['friction'],
restitution=self.physics_pars['restitution'],
# radius=.00000001
)
self._fixtures = self._body.fixtures
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, 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, game, position=(0, 0), angle=0, additive=(0, 0), name='', speed=100, is_inside=True,
is_you=False, body=None, orientation=0):
Composite.__init__(self, game=game, position=position, angle=angle, is_inside=is_inside, body=body)
self.is_you = is_you
self.name = name
self.speed = speed
self.additive = additive
self.orientation = orientation
for fixture in self.body.body.fixtures:
fixture.filterData.maskBits = Bits.PERSONAGE_MASK
fixture.filterData.categoryBits = Bits.PERSONAGE_BITS
if self.is_you:
self.center_box = self.game.world.CreateDynamicBody(position=self.get_position(),
shapes=B2.b2PolygonShape(box=(0.5, 0.5)))
for item in self.center_box.fixtures:
item.filterData.maskBits = Bits.NOTHING_MASK
item.filterData.categoryBits = Bits.NOTHING_BITS
self.game.world.CreatePrismaticJoint(bodyA=self.game.maw.center_box,
bodyB=self.center_box,
axis=(0, -1))
self.game.world.CreateRevoluteJoint(bodyA=self.center_box,
bodyB=self.body.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 __init__(self, world, ID, body_position, heading=0):
self.ID = ID
self.body = world.CreateDynamicBody(position=body_position)
ps = b2.b2PolygonShape()
ps.SetAsBox(self.width/2, self.height/2)
ps1 = b2.b2PolygonShape()
ps1.SetAsBox(self.grabber_width/2, self.grabber_height/2,
b2.b2Vec2((-self.width/2 - self.grabber_width/2),
(self.height/2 - self.grabber_height/2)),0)
ps2 = b2.b2PolygonShape()
ps2.SetAsBox(self.grabber_width/2, self.grabber_height/2,
b2.b2Vec2((-self.width/2 - self.grabber_width/2),
(self.grabber_height/2 - self.height/2)),0)
self.body.CreateFixture(shape=ps, density=self.density)
self.body.CreateFixture(shape=ps1, density=self.grabber_density)
self.body.CreateFixture(shape=ps2, density=self.grabber_density)
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 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 __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 create_body(self, _x, _y):
self.x = float(self.node.attrib["x"])
self.y = float(self.node.attrib["y"])
self.width = float(self.node.attrib["width"])
self.height = float(self.node.attrib["height"])
self.body = self.map.world.CreateStaticBody(
position=(self.x + self.width / 2, self.y + self.height / 2),
shapes=Box2D.b2PolygonShape(box=(self.width / 2, self.height / 2)),
userData=self,
)
def createGround(position=[0, -20]):
global world
groundBodyDef = Box2D.b2BodyDef()
groundBodyDef.position = Box2D.b2Vec2(0, -20)
groundBody = world.CreateBody(groundBodyDef)
groundBox = Box2D.b2PolygonShape()
groundBox.SetAsBox(100, 10)
fixture = groundBody.CreateFixturesFromShapes(groundBox, friction=100)
return groundBody
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 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,
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 __init__(self, level):
self.jump = False
self.jump_sound = pygame.mixer.Sound(
link_file('jump.wav', DATA_FILE))
self.moving_left = False
self.moving_right = False
self.animations_right = [
load_image('walk1.png', DATA_FILE, -1), # add animations
load_image('walk2.png', DATA_FILE, -1),
load_image('walk3.png', DATA_FILE, -1),
load_image('walk2.png', DATA_FILE, -1),
load_image('walk1.png', DATA_FILE, -1),
load_image('walk2.png', DATA_FILE, -1),
load_image('walk3.png', DATA_FILE, -1),
load_image('walk2.png', DATA_FILE, -1),
load_image('walk1.png', DATA_FILE, -1),
load_image('walk2.png', DATA_FILE, -1),
load_image('walk3.png', DATA_FILE, -1),
load_image('walk2.png', DATA_FILE, -1)
]
self.animations_left = [
load_image('walk-1.png', DATA_FILE, -1),
load_image('walk-2.png', DATA_FILE, -1),
load_image('walk-3.png', DATA_FILE, -1),
load_image('walk-2.png', DATA_FILE, -1),
load_image('walk-1.png', DATA_FILE, -1),
load_image('walk-2.png', DATA_FILE, -1),
load_image('walk-3.png', DATA_FILE, -1),
load_image('walk-2.png', DATA_FILE, -1),
load_image('walk-1.png', DATA_FILE, -1),
load_image('walk-2.png', DATA_FILE, -1),
load_image('walk-3.png', DATA_FILE, -1),
load_image('walk-2.png', DATA_FILE, -1)
]
self.sprite = load_image('stand1.png', DATA_FILE, -1)
self.start_pos = (10, HEIGHT - self.sprite.get_height() - 48)
self.player_location = [self.start_pos[0], self.start_pos[1]]
self.body = level.CreateDynamicBody( # box2d collision create
angle=0,
position=(self.get_box2d_coordinates()),
shapes=b.b2PolygonShape(
box=(self.get_box2d_size()))) # 1 = 20 pixel
self.start_box2d = self.get_box2d_coordinates()
self.x, self.y = 0, 0
self.check_jump = 0
self.anim_count = 0
self.stand = True
self.dir = 1 # 1 right. -1 left
self.run = False
self.j_check = False
self.start = True
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 _create_table(self):
"""
Creates the walls of the table
:return:
"""
## Walls in world RF
left_wall_body = self.world.CreateStaticBody(
position=(0, self.params.TABLE_CENTER[1]),
userData={'name': 'left wall'},
shapes=b2.b2PolygonShape(box=(self.params.WALL_THICKNESS / 2,
self.params.TABLE_SIZE[1] / 2)))
right_wall_body = self.world.CreateStaticBody(
position=(self.params.TABLE_SIZE[0], self.params.TABLE_CENTER[1]),
userData={'name': 'right wall'},
shapes=b2.b2PolygonShape(box=(self.params.WALL_THICKNESS / 2,
self.params.TABLE_SIZE[1] / 2)))
upper_wall_body = self.world.CreateStaticBody(
position=(self.params.TABLE_CENTER[0], self.params.TABLE_SIZE[1]),
userData={'name': 'upper wall'},
shapes=b2.b2PolygonShape(box=(self.params.TABLE_SIZE[0] / 2,
self.params.WALL_THICKNESS / 2)))
bottom_wall_body = self.world.CreateStaticBody(
position=(self.params.TABLE_CENTER[0], 0),
userData={'name': 'bottom wall'},
shapes=b2.b2PolygonShape(box=(self.params.TABLE_SIZE[0] / 2,
self.params.WALL_THICKNESS / 2)))
self.walls = [
left_wall_body, upper_wall_body, right_wall_body, bottom_wall_body
]
## world RF -> table RF
self.wt_transform = -self.params.TABLE_CENTER
## table RF -> world RF
self.tw_transform = self.params.TABLE_CENTER
def __init__(self, w, pos, size):
walldef = box2d.b2BodyDef()
walldef.position = pos
walldef.userData = {}
wallbod = w.CreateBody(walldef)
wallbod.userData['actor'] = None
wallbod.userData['kind'] = 'wall'
wallbod.iswall = True
wallshp = box2d.b2PolygonShape()
width, height = size
wallshp.SetAsBox(width, height)
wallbod.CreatePolygonFixture(box=(width, height), density=1, friction=0.3)
v = view.Wall(pos, size)
self.v = v
def createBody(self, b2world, w, h):
bodyDef = Box2D.b2BodyDef()
bodyDef.type = Box2D.b2_dynamicBody
bodyDef.fixedRotation = True
bodyDef.position = (Settings.B2SCALE * self.rect.left, Settings.B2SCALE * self.rect.top)
bodyDef.bullet = True
bodyDef.linearDamping = 6.0
self.body = b2world.CreateBody(bodyDef)
w /= 2
h /= 2
poly = Box2D.b2PolygonShape( box=(Settings.B2SCALE*w, Settings.B2SCALE*h, (Settings.B2SCALE*w,Settings.B2SCALE*h), 0) )
self.body.CreateFixture(shape=poly, density=1, friction=0)
return self.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 create_dynamic_polygon(vertices, world):
body = world.CreateDynamicBody()
# box2d cannot create polygons with 16 or more vertices so triangulate them
if len(vertices) >= 16:
fixtures = triangulate(vertices, body)
return body, fixtures
box = Box2D.b2PolygonShape(vertices=vertices)
# this means we have a concave shape
if len(box.vertices) < len(vertices) - 1:
fixtures = triangulate(vertices, body)
return body, fixtures
box = body.CreatePolygonFixture(vertices=vertices, density=1, friction=.1, restitution=.5)
return body, [box]
def __init__(self, game, position=(0, 0), angle=0, is_inside=True, name='', body=None):
self.name = name
self._is_inside = is_inside
self.game = game
self.parts = []
self.joints = []
self.old_angle = angle
if body:
self.body = body
else:
self.body = self.game.world.CreateDynamicBody(
position=position,
shapes=B2.b2PolygonShape(box=(0.5, 0.5)))
for item in self.body.fixtures:
item.filterData.maskBits = Bits.NOTHING_MASK
item.filterData.categoryBits = Bits.NOTHING_BITS
self.add_part(self.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 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, game, position=(0, 0), angle=0, radius=10, n=3):
GameObject.__init__(self, game, position, angle, image='images/default.png')
self.center_box = self.game.world.CreateStaticBody(
position=position,
shapes=B2.b2PolygonShape(box=(0.5, 0.5))
)
for item in self.center_box.fixtures:
item.filterData.maskBits = Bits.NOTHING_MASK
item.filterData.categoryBits = Bits.NOTHING_BITS
self.game.world.CreateRevoluteJoint(bodyA=self.body,
bodyB=self.center_box,
anchor=position)
self.recreate(radius, n)
for item in self.body.fixtures:
item.filterData.maskBits = Bits.FULL_MASK
item.filterData.categoryBits = Bits.FULL_BITS
def createGround(position=[0,-20], bMatplotlib = True):
global world, fig, ax
groundBodyDef = Box2D.b2BodyDef()
groundBodyDef.position = Box2D.b2Vec2(0,-20)
groundBody = world.CreateBody(groundBodyDef)
groundBox = Box2D.b2PolygonShape()
groundBox.SetAsBox(100, 10)
fixture = groundBody.CreateFixturesFromShapes(groundBox)
if(bMatplotlib):
createGlobalFigure()
shape = fixture.shape
vertices=[groundBody.transform*v for v in shape.vertices]
poly = plt.Polygon(vertices, lw=5, edgecolor='b')
ax.add_patch( poly )
return groundBody
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 __init__(self, pos, world, tile, width, height, tilew=1, tileh=1 ):
self.rect = pygame.Rect(pos, (width, height)) # HUOM: width ja height tileissa
self.tilew = tilew
self.tileh = tileh
self.world = world
self.image = world.tileset.getTile(tile, tilew, tileh)
w = width * TILESIZE * B2SCALE * 0.5
h = height * TILESIZE * B2SCALE * 0.5
bodyDef = Box2D.b2BodyDef()
bodyDef.type = Box2D.b2_staticBody
bodyDef.position = (B2SCALE * self.rect.left, B2SCALE * self.rect.top)
self.body = world.b2World.CreateBody(bodyDef)
bshape = Box2D.b2PolygonShape( box=(w, h, (w, h), 0) )
self.body.CreateFixture(shape=bshape, density=1)
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 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 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 _create_b2_tile_map(self, rect_map):
def try_create_and_append_block(cells_in_block, mode):
if cells_in_block and mode == 0:
cells_in_block.pop()
if cells_in_block:
height = len(cells_in_block) if not mode else 1
width = len(cells_in_block) if mode else 1
half_height = height/2.0
half_width = width/2.0
lowest_cell = cells_in_block[0]
cx = lowest_cell.i + half_width
cy = lowest_cell.j + half_height
shape.SetAsBox(half_width, half_height, (cx, cy), NO_ROTATION)
self.b2level.CreateFixture(shape=shape, userData=cell)
self.b2level.fixtures[-1].filterData.categoryBits = B2SMTH | B2LEVEL
self.b2level.fixtures[-1].filterData.maskBits = B2EVERY
cells = rect_map.cells
m = len(cells)
n = len(cells[0])
shape = b2.b2PolygonShape()
for cell_column in cells:
cells_in_vertical_block = []
for cell in cell_column:
if cell.get('top'):
cells_in_vertical_block.append(cell)
else:
try_create_and_append_block(cells_in_vertical_block, 0)
cells_in_vertical_block = []
try_create_and_append_block(cells_in_vertical_block, 0)
for j in xrange(n):
cells_in_horizontal_block = []
for i in xrange(m):
cell = cells[i][j]
if cell.get('top'):
cells_in_horizontal_block.append(cell)
else:
try_create_and_append_block(cells_in_horizontal_block, 1)
cells_in_horizontal_block = []
try_create_and_append_block(cells_in_horizontal_block, 1)
def rescale_shape(self):
scale = self.object.scale
bs = self._basic_shape
if scale != self._old_scale:
self._old_scale = scale
if isinstance(bs, B2D.b2PolygonShape):
vertices = []
c = bs.centroid
for v in bs.vertices:
dv = c-B2D.b2Vec2(*v)
dv.x *= scale[0]
dv.y *= scale[1]
vertices.append((c+dv).tuple)
self.rescaled_shape = B2D.b2PolygonShape(vertices=vertices)
else:
c_scale = max(scale[0], scale[1])
self.rescaled_shape = B2D.b2CircleShape(pos=bs.pos,
radius=c_scale*bs.radius)
return self.rescaled_shape
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 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 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 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 __init__(self, width: float, height: float, **kwargs):
super().__init__(**kwargs)
self._width = width
self._height = height
# TODO: right now this assumes that all subpolygons have the same number of edges
# TODO: rewrite such that arbitrary subpolygons can be used here
vertices = self._shape_vertices()
v_size = np.amax(vertices, (0, 1)) - np.amin(vertices, (0, 1))
vertices /= v_size
vertices *= np.array((width, height))
centroid = np.zeros(2)
area = .0
for vs in vertices:
# compute centroid of polygon
a = 0.5 * np.abs(
np.dot(vs[:, 0], np.roll(vs[:, 1], 1)) -
np.dot(vs[:, 1], np.roll(vs[:, 0], 1)))
area += a
centroid += vs.mean(axis=0) * a
centroid /= area
self.__local_vertices = vertices - centroid
self.__local_vertices.setflags(write=False)
for v in self.__local_vertices:
self._body.CreatePolygonFixture(
shape=Box2D.b2PolygonShape(vertices=(v *
_world_scale).tolist()),
density=self._density,
friction=self._friction,
restitution=self._restitution,
# radius=.00000001
)
self._fixture = self._body.fixtures
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
quakeFreq = 10
quakeVertical = False
quakeActive = False
###
pygame.init()
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT), 0, 32)
pygame.display.set_caption('GraviTask')
clock = pygame.time.Clock()
world = world(gravity=(0, -10), doSleep=True)
ground_shape = Box2D.b2PolygonShape(vertices = [(0 , 10),
(2 , 1),
(98 , 1),
(100 , 10),
(100 , 0),
(0 , 0)])
ground_body = world.CreateStaticBody(
position=(0, 0),
shapes=(polygonShape(box=(100, 5))),
)
quakeFloor = world.CreateKinematicBody(position=(1 , 6))
quakeFloor.CreateFixture(shape=Box2D.b2PolygonShape(vertices=[(0 , 0),
(0 , 1),
(40 , 1),
(40 , 0)])
,friction=4)
import Box2D
# Part of this game
from dwarf import Dwarf
from block import Wood, Stone, Dirt
import ai
# Lets assume a conversion of 35 pixels/meter
# This means dwarves are about 2 meters tall
pxPerM = 35.0 # px/m
worldWidth = 640 # px
worldHeight = 480 # px
world = Box2D.b2World(gravity=(0, -10), doSleep=True)
groundBody = world.CreateStaticBody( \
position=(worldWidth*pxPerM/2,worldHeight*pxPerM+5), \
shapes=Box2D.b2PolygonShape(box=(worldWidth*pxPerM,10)))
screen = pygame.display.set_mode((worldWidth, worldHeight))
dwarfSkin = pygame.image.load('images/dwarf.png').convert()
dwarfSkin.set_colorkey((255, 0, 255))
background = 255, 255, 255
# Create the world
worldBlocks = pygame.sprite.Group()
for x in range(0, 640, 10):
for y in range(50, 100, 10):
newBlock = Dirt((x, y))
worldBlocks.add(newBlock)
for y in range(100, 400, 10):
newBlock = Stone((x, y))
###nose = [cV[15],cV[5],cV[6]]
#print nose
#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),
}
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]
