def beneath(game):
vertex = [[(10, game.HEIGHT - game.HEIGHT / 10),
(10, game.HEIGHT - game.HEIGHT / 20)],
[(10, game.HEIGHT - game.HEIGHT / 20),
(game.WIDTH - game.WIDTH / 10, game.HEIGHT - game.HEIGHT / 20)],
[(game.WIDTH - game.WIDTH / 10, game.HEIGHT - game.HEIGHT / 20),
(game.WIDTH - game.WIDTH / 10, game.HEIGHT - game.HEIGHT / 10)]
]
vertex = [[game.to_world(pt) for pt in vert] for vert in vertex]
game.world.CreateStaticBody(
shapes=[B2.b2EdgeShape(vertices=vertex[0]),
B2.b2EdgeShape(vertices=vertex[1]),
B2.b2EdgeShape(vertices=vertex[2])],
position=(1, 0))
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 create_screen_bounding_box(self):
screen_center = (self.screenWidth_m / 2, self.screenHeight_m / 2)
bottom_left = (-screen_center[0], -screen_center[1])
bottom_right = (screen_center[0], -screen_center[1])
top_right = (screen_center[0], screen_center[1])
top_left = (-screen_center[0], screen_center[1])
self.bounding_box = self.world.CreateStaticBody(
position=screen_center,
shapes=[
Box2D.b2EdgeShape(vertices=[bottom_left, bottom_right]),
Box2D.b2EdgeShape(vertices=[bottom_right, top_right]),
Box2D.b2EdgeShape(vertices=[top_right, top_left]),
Box2D.b2EdgeShape(vertices=[top_left, bottom_left])
])
self.bounding_box.userData = BouncingBalls.BodyData(
"world_bounding_box", visible=False)
def test_b2EdgeShape(self):
world = b2.b2World()
v1=(-10.0, 0.0)
v2=(-7.0, -1.0)
v3=(-4.0, 0.0)
ground=world.CreateStaticBody(shapes=
[b2.b2EdgeShape(vertices=[None, v1, v2, v3])])
def add_line(self, p1, p2):
p1 = self.renderer.to_world_frame(p1)
p2 = self.renderer.to_world_frame(p2)
m = ((p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2)
p1 = (p1[0] - m[0], p1[1] - m[1]) # compute p1 coordinates wrt m
p2 = (p2[0] - m[0], p2[1] - m[1]) # compute p2 coordinates wrt m
line = self.world.CreateStaticBody(
position=m, shapes=[Box2D.b2EdgeShape(vertices=[p1, p2])])
line.active = False
line.userData = BouncingBalls.BodyData("line", visible=False)
print("Warning line rendering disabled!")
def _init_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 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 build(self):
root = Widget()
root.bind(on_touch_move=self.generate_one)
self.world = world = b2d.b2World(gravity=(0, -100))
# plane for the ground, all other the window.
# The ground
ground = self.world.CreateBody(
shapes=b2d.b2EdgeShape(vertices=[(0, 0), (1000, 0)])
)
# generate circles
self.circles = []
for x in xrange(5):
c = Circle(y=500 + x * 5, x=500+x, world=world)
self.circles.append(c)
root.add_widget(c)
Clock.schedule_interval(self._update_world, 1 / 60.)
return root
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 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 __init__(self,
world_size=50,
gravity=-1,
num_obstacles=3,
obstacle_sizes=3,
obstacle_noise=1,
xinit=None,
yinit=None,
rinit=None,
targetx=None,
targety=None):
# physics world
self.world = b2.b2World(gravity=(0, gravity))
# static objects in the scene that do not move
# for drawing purposes
# the drawer should scale these for visualization when drawing
# create a box around the working area
# vertices are in physics coords.
a = 1
box_vertices = [(a, a), (world_size - a, a),
(world_size - a, world_size - a), (a, world_size - a)]
self.time = 0
# a static body. A body is just a point with no shape
self._box = self.world.CreateStaticBody(shapes=b2.b2EdgeShape(
vertices=box_vertices))
# fixtures are added shapes to point-wise bodies.
# these determine the collisions and such while the bodies contain
# the speed and such
for i in range(4):
verts = [box_vertices[i], box_vertices[(i + 1) % 4]]
self._box.CreateEdgeFixture(vertices=verts, density=0, friction=0)
# for each obstacle
for i in range(num_obstacles):
# find a good obstacle position
while True:
# compute random obstacle position
x = random.uniform(0, world_size)
y = random.uniform(0, world_size)
# Euclidian distance to initial AUV position
d = math.sqrt((x - xinit)**2 + (y - yinit)**2)
# maximum obstacle radius
r = obstacle_sizes + obstacle_noise - obstacle_noise / 2
# minimum collision free distance
if d > rinit + r:
pass
else:
continue
# Euclidian distance to target position
d = math.sqrt((x - targetx)**2 + (y - targety)**2)
# minimum confliction free distance
if d > r + C.TARGET_AREA:
break
else:
continue
pos = [x, y]
verts = _make_random_obstacle(pos, obstacle_sizes, obstacle_noise)
obs = self.world.CreateStaticBody(shapes=b2.b2PolygonShape(
vertices=verts))
# static objects in the scene that do not move
# for drawing purposes
# the drawer should scale these for visualization when drawing
# create a simple line for the seafloor
floor_x = 0
floor_y = 1
floor_length = 100
# vertices are in physics coords.
floor_vertices = [(floor_x - floor_length, floor_y),
(floor_x + floor_length, floor_y)]
# a static body. A body is just a point with no shape
floor = world.CreateStaticBody(
shapes=b2.b2EdgeShape(
vertices=floor_vertices))
# fixtures are added shapes to point-wise bodies.
# these determine the collisions and such while the bodies contain
# the speed and such
floor.CreateEdgeFixture(vertices=floor_vertices,
density=0,
friction=0.1)
# auv starting position
auv_x = 5
auv_y = floor_y + 10
auv_l = 3
auv_h = 1
# CCW, centered on the rectangle center
auv_vertices = [
# top right
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)
