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, 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 createCircle(position, r=0.3, bDynamic=True, bCollideNoOne=False, density=1, damping=0.05, restitution=0.1, friction=200, name="",categoryBits=0x0001,maskBits=0x0009):
global world, fig, ax
bodyDef = Box2D.b2BodyDef()
bodyDef.position = position
if bDynamic:
bodyDef.type = Box2D.b2_dynamicBody
else:
bodyDef.type = Box2D.b2_staticBody
if(abs(world.gravity[1]) > 1):
bodyDef.linearDamping = damping
bodyDef.angularDamping = damping
else:
bodyDef.linearDamping = 70
bodyDef.angularDamping = 30
body = world.CreateBody(bodyDef)
shape = Box2D.b2CircleShape(radius=r)
mask=maskBits
if(bCollideNoOne):
mask = 0x0000
fixture = body.CreateFixture(maskBits=mask, shape=shape, density=density, restitution=restitution, friction=friction,categoryBits=categoryBits)
body.userData = {"name": name}
return body
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 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 _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, world, name, pos, radius=0.022, density=1.0):
self.name = name
self.body = world.CreateDynamicBody(position=pos, linearDamping=1,
angulardamping=1)
ps = b2.b2CircleShape(radius=radius)
self.body.CreateFixture(shape=ps, density=density)
self.radius = radius
self.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 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 __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 __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 __crear_fixture(self):
fixture = box2d.b2FixtureDef(shape=box2d.b2CircleShape(radius=self._radio),
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 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 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 __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 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
pisoDef.position = (0, 0)
pisoDef.angle = -10 * math.pi / 180
pisoDef.type = b2.b2_staticBody
# Criar o corpo com a definição
piso = cenario.CreateBody(pisoDef)
# Criar o corpo com a definição
corpo = cenario.CreateBody(corpoDef)
# Definição do Fixture
fixDef = b2.b2FixtureDef()
fixDef.restitution = 0.9
fixDef.friction = 0.6
fixDef.density = 3
fixDef.shape = b2.b2CircleShape(radius=1)
# Definição do Fixture Piso
pisoFixDef = b2.b2FixtureDef()
pisoFixDef.restitution = 0.5
pisoFixDef.friction = 0.6
pisoFixDef.density = 1
pisoFixDef.shape = b2.b2PolygonShape(box=(50, 2))
# Associa o Fixture ao corpo
corpo.CreateFixture(fixDef)
piso.CreateFixture(pisoFixDef)
while True:
# Calcula regras
cenario.Step(1.0 / 30.0, 8, 3)
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 add_fixture(b2_world_body, jsw, jsw_fixture):
"""add a fixture to a body
:param b2_world_body: a body
:type b2_world_body: b2Body
:param jsw: dictionary defining all the gropups of data
in the json file
:type jsw: dict(sting: variant)
:param jsw_fixture: a fixture
:type jsw_fixture: b2Fixture
"""
# 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 list(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 list(jsw_fixture.keys()):
setAttr(jsw_fixture, "filter-maskBits", fixtureDef, "maskBits")
else:
fixtureDef.maskBits = 65535
setAttr(jsw_fixture, "density", fixtureDef)
setAttr(jsw_fixture, "group_index", 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 list(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 list(jsw_fixture.keys()): # works ok
polygon_vertices = rubeVecArrToB2Vec2Arr(
jsw_fixture["polygon"]["vertices"])
fixtureDef.shape = b2.b2PolygonShape(vertices=polygon_vertices)
if "chain" in list(jsw_fixture.keys()): # works ok
chain_vertices = rubeVecArrToB2Vec2Arr(
jsw_fixture["chain"]["vertices"])
if len(chain_vertices) >= 3:
# closed-loop b2LoopShape
# Done
if "hasNextVertex" in list(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 create(self,
world,
TERRAIN_HEIGHT,
module=None,
node=None,
connection_site=None,
p_c=None,
module_list=None,
position=None):
# get module height and width
if p_c is not None and connection_site is None:
raise (
"When you want to attach a new component to a parent component, you have to supply",
"a connection_site object with it. This connection_site object defines where to anchor",
"the joint in between to components")
n_radius = self.radius
angle = 0
pos = [7, 10, 0]
if position is not None:
pos = position
if (p_c is not None):
local_pos_x = math.cos(connection_site.orientation.x +
math.pi / 2) * n_radius
local_pos_y = math.sin(connection_site.orientation.x +
math.pi / 2) * n_radius
pos[0] = (local_pos_x) + connection_site.position.x
pos[1] = (local_pos_y) + connection_site.position.y
# This module will create one component that will be temporarily stored in ncomponent
new_component = None
# This module will create one joint (if a parent component is present) that will be temporarily stored in njoint
njoint = None
components = []
joints = []
if connection_site:
angle += connection_site.orientation.x
if (pos[1] - n_radius < TERRAIN_HEIGHT
): #TODO CHANGE TO TERRAIN_HEIGT OR DO CHECK ELSEWHERE
if node is not None:
node.component = None
return components, joints
else:
fixture = fixtureDef(shape=B2D.b2CircleShape(radius=n_radius),
density=1,
friction=0.1,
restitution=0.0,
categoryBits=0x0020,
maskBits=0x001)
new_component = world.CreateDynamicBody(position=(pos[0], pos[1]),
angle=angle,
fixtures=fixture)
color = [255, 255, 255]
if node is not None and module_list is not None:
color = world.cmap(node.type / len(module_list))
elif node is not None and module_list is None:
print(
"Note: cannot assign a color to the module since the 'module_list' is not passed as an argument"
)
# move to component creator
new_component.color1 = (color[0], color[1], color[2])
new_component.color2 = (color[0], color[1], color[2])
components.append(new_component)
if node is not None:
node.component = [new_component]
if connection_site is not None:
joint = mu.create_joint(world, p_c, new_component, connection_site,
angle, self.torque)
joints.append(joint)
return components, joints
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
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 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
IUP = 10
P1HP = IUP
P1Scr = 0
sSpd1 = 0
Xmov = 300 * 1000
Sdamp = 11
Ship1Def = b2.b2BodyDef()
Ship1Def.linearDamping = Sdamp
Ship1Def.position = (53, 58.1)
Ship1Def.type = b2.b2_dynamicBody
ship1 = world.CreateBody(Ship1Def)
shipFixture = b2.b2FixtureDef()
shipFixture.friction = 0
shipFixture.restitution = 4
shipFixture.density = 1000
shipFixture.shape = b2.b2CircleShape(radius=5)
ship1.CreateFixture(shipFixture)
# Define Player 1
def draw_ship(ship1):
global ship1X, ship1Y, ship1Pos
shape = ship1.fixtures[0].shape
if shape.type == b2.b2Shape.e_circle:
ship1Pos = ship1.position
ship1X = int(ship1Pos[0] * PPM)
ship1Y = int(ship1Pos[1] * PPM)
screen.blit(S1, (ship1X - 50, ship1Y - 50))
# Player 2
