def __init__(self):
self.seed()
self.viewer = None
self.world = Box2D.b2World()
self.terrain = None
self.hull = None
self.prev_shaping = None
self.fd_polygon = fixtureDef(
shape = polygonShape(vertices=
[(0, 0),
(1, 0),
(1, -1),
(0, -1)]),
friction = FRICTION)
self.fd_edge = fixtureDef(
shape = edgeShape(vertices=
[(0, 0),
(1, 1)]),
friction = FRICTION,
categoryBits=0x0001,
)
self.reset()
high = np.array([np.inf]*24)
self.action_space = spaces.Box(np.array([-1,-1,-1,-1]), np.array([+1,+1,+1,+1]))
self.observation_space = spaces.Box(-high, high)
def __init__(self):
super(Pulley, self).__init__()
y, L, a, b = 16.0, 12.0, 1.0, 2.0
# The ground
ground = self.world.create_static_body(
shapes=[edgeShape(vertices=[(-40, 0), (40, 0)]),
circleShape(radius=2, pos=(-10.0, y + b + L)),
circleShape(radius=2, pos=(10.0, y + b + L))]
)
body_a = self.world.create_dynamic_body(
position=(-10, y),
fixtures=fixtureDef(shape=polygonShape(box=(a, b)), density=5.0),
)
body_b = self.world.create_dynamic_body(
position=(10, y),
fixtures=fixtureDef(shape=polygonShape(box=(a, b)), density=5.0),
)
self.pulley = self.world.CreatePulleyJoint(
body_a=body_a,
body_b=body_b,
anchorA=(-10.0, y + b),
anchorB=(10.0, y + b),
groundAnchorA=(-10.0, y + b + L),
groundAnchorB=(10.0, y + b + L),
ratio=1.5,
)
def __init__(self, world, init_angle, init_x, init_y):
self.world = world
self.hull = self.world.CreateDynamicBody(
position = (init_x, init_y),
angle = init_angle,
fixtures = [
fixtureDef(shape = polygonShape(vertices=[ (x*SIZE,y*SIZE) for x,y in HULL_POLY1 ]), density=1.0),
fixtureDef(shape = polygonShape(vertices=[ (x*SIZE,y*SIZE) for x,y in HULL_POLY2 ]), density=1.0),
fixtureDef(shape = polygonShape(vertices=[ (x*SIZE,y*SIZE) for x,y in HULL_POLY3 ]), density=1.0),
fixtureDef(shape = polygonShape(vertices=[ (x*SIZE,y*SIZE) for x,y in HULL_POLY4 ]), density=1.0)
]
)
self.hull.color = (0.8,0.0,0.0)
self.wheels = []
self.fuel_spent = 0.0
WHEEL_POLY = [
(-WHEEL_W,+WHEEL_R), (+WHEEL_W,+WHEEL_R),
(+WHEEL_W,-WHEEL_R), (-WHEEL_W,-WHEEL_R)
]
for wx,wy in WHEELPOS:
front_k = 1.0 if wy > 0 else 1.0
w = self.world.CreateDynamicBody(
position = (init_x+wx*SIZE, init_y+wy*SIZE),
angle = init_angle,
fixtures = fixtureDef(
shape=polygonShape(vertices=[ (x*front_k*SIZE,y*front_k*SIZE) for x,y in WHEEL_POLY ]),
density=0.1,
categoryBits=0x0020,
maskBits=0x001,
restitution=0.0)
)
w.wheel_rad = front_k*WHEEL_R*SIZE
w.color = WHEEL_COLOR
w.gas = 0.0
w.brake = 0.0
w.steer = 0.0
w.phase = 0.0 # wheel angle
w.omega = 0.0 # angular velocity
w.skid_start = None
w.skid_particle = None
rjd = revoluteJointDef(
bodyA=self.hull,
bodyB=w,
localAnchorA=(wx*SIZE,wy*SIZE),
localAnchorB=(0,0),
enableMotor=True,
enableLimit=True,
maxMotorTorque=180*900*SIZE*SIZE,
motorSpeed = 0,
lowerAngle = -0.4,
upperAngle = +0.4,
)
w.joint = self.world.CreateJoint(rjd)
w.tiles = set()
w.userData = w
self.wheels.append(w)
self.drawlist = self.wheels + [self.hull]
self.particles = []
def _create_lander(self, lander, number_of_landers):
initial_y = VIEWPORT_H/SCALE
body_xpos = (lander.player_id + 1) * VIEWPORT_W/SCALE / (number_of_landers + 1)
body_ypos = initial_y
body = self.world.CreateDynamicBody(
position = (body_xpos, body_ypos),
angle=0.0,
fixtures = fixtureDef(
shape=polygonShape(vertices=[ (x/SCALE,y/SCALE) for x,y in LANDER_POLY ]),
density=5.0,
friction=0.1,
categoryBits=0x0010,
maskBits=0x001, # collide only with ground
restitution=0.0) # 0.99 bouncy
)
body.color1 = (0.5,0.4,0.9)
body.color2 = (0.3,0.3,0.5)
body.ApplyForceToCenter( (
self.np_random.uniform(-INITIAL_RANDOM, INITIAL_RANDOM),
self.np_random.uniform(-INITIAL_RANDOM, INITIAL_RANDOM)
), True)
legs = []
for i in [-1,+1]:
leg = self.world.CreateDynamicBody(
position = (body_xpos - i*LEG_AWAY/SCALE, body_ypos),
angle = (i*0.05),
fixtures = fixtureDef(
shape=polygonShape(box=(LEG_W/SCALE, LEG_H/SCALE)),
density=1.0,
restitution=0.0,
categoryBits=0x0020,
maskBits=0x001)
)
leg.ground_contact = False
leg.color1 = (0.5,0.4,0.9)
leg.color2 = (0.3,0.3,0.5)
rjd = revoluteJointDef(
bodyA=body,
bodyB=leg,
localAnchorA=(0, 0),
localAnchorB=(i*LEG_AWAY/SCALE, LEG_DOWN/SCALE),
enableMotor=True,
enableLimit=True,
maxMotorTorque=LEG_SPRING_TORQUE,
motorSpeed=+0.3*i # low enough not to jump back into the sky
)
if i==-1:
rjd.lowerAngle = +0.9 - 0.5 # Yes, the most esoteric numbers here, angles legs have freedom to travel within
rjd.upperAngle = +0.9
else:
rjd.lowerAngle = -0.9
rjd.upperAngle = -0.9 + 0.5
leg.joint = self.world.CreateJoint(rjd)
legs.append(leg)
lander.body, lander.legs = body, legs
def __init__(self):
self.trackWidth = 5.0
self.cartWidth = 0.3
self.cartHeight = 0.2
self.cartMass = 10
self.poleMass = 1
self.force = 0.2
self.trackThickness = self.cartHeight
self.poleLength = 0.5
self.poleThickness = 0.04
self.screenSize = (640,480) #origin upper left
self.worldSize = (float(self.trackWidth),float(self.trackWidth)) #origin at center
self.world = b2.world(gravity=(0,-9.81),doSleep=True)
self.framesPerSecond = 10 # used for dynamics update and for graphics update
self.velocityIterations = 8
self.positionIterations = 6
# Make track bodies and fixtures
self.trackColor = (100,100,100)
poleCategory = 0x0002
f = b2.fixtureDef(shape=b2.polygonShape(box=(self.trackWidth/2,self.trackThickness/2)),
friction=0.000, categoryBits=0x0001, maskBits=(0xFFFF & ~poleCategory))
self.track = self.world.CreateStaticBody(position = (0,0),
fixtures=f, userData={'color': self.trackColor})
self.trackTop = self.world.CreateStaticBody(position = (0,self.trackThickness+self.cartHeight*1.1),
fixtures = f)
f = b2.fixtureDef(shape=b2.polygonShape(box=(self.trackThickness/2,self.trackThickness/2)),
friction=0.000, categoryBits=0x0001, maskBits=(0xFFFF & ~poleCategory))
self.wallLeft = self.world.CreateStaticBody(position = (-self.trackWidth/2+self.trackThickness/2, self.trackThickness),
fixtures=f, userData={'color': self.trackColor})
self.wallRight = self.world.CreateStaticBody(position = (self.trackWidth/2-self.trackThickness/2, self.trackThickness),
fixtures=f,userData={'color': self.trackColor})
# Make cart body and fixture
f = b2.fixtureDef(shape=b2.polygonShape(box=(self.cartWidth/2,self.cartHeight/2)),
density=self.cartMass, friction=0.000, restitution=0.5, categoryBits=0x0001,
maskBits=(0xFFFF & ~poleCategory))
self.cart = self.world.CreateDynamicBody(position=(0,self.trackThickness),
fixtures=f, userData={'color':(20,200,0)})
# Make pole pody and fixture
# Initially pole is hanging down, which defines the zero angle.
f = b2.fixtureDef(shape=b2.polygonShape(box=(self.poleThickness/2, self.poleLength/2)),
density=self.poleMass, categoryBits=poleCategory)
self.pole = self.world.CreateDynamicBody(position=(0,self.trackThickness+self.cartHeight/2+self.poleThickness-self.poleLength/2),
fixtures=f, userData={'color':(200,20,0)})
# Make pole-cart joint
rj = self.world.CreateRevoluteJoint(bodyA = self.pole, bodyB = self.cart,
anchor=(0,self.trackThickness+self.cartHeight/2+self.poleThickness))
def __init__(self):
super(Chain, self).__init__()
# The ground
ground = self.world.CreateBody(
shapes=edgeShape(vertices=[(-40, 0), (40, 0)])
)
plank = fixtureDef(
shape=polygonShape(box=(0.6, 0.125)),
density=20,
friction=0.2,
)
# Create one Chain (Only the left end is fixed)
prevBody = ground
y = 25
numPlanks = 30
for i in range(numPlanks):
body = self.world.CreateDynamicBody(
position=(0.5 + i, y),
fixtures=plank,
)
# You can try a WeldJoint for a slightly different effect.
# self.world.CreateWeldJoint(
self.world.CreateRevoluteJoint(
bodyA=prevBody,
bodyB=body,
anchor=(i, y),
)
prevBody = body
def _create_particle(self, mass, x, y):
p = self.world.CreateDynamicBody(
position = (x,y),
angle=0.0,
fixtures = fixtureDef(
shape=circleShape(radius=2/SCALE, pos=(0,0)),
density=mass,
friction=0.1,
categoryBits=0x0100,
maskBits=0x001, # collide only with ground
restitution=0.9)
)
p.ttl = 1
self.particles.append(p)
self._clean_particles(False)
return p
def reset(self):
self._destroy()
self.world.contactListener_keepref = ContactDetector(self)
self.world.contactListener = self.world.contactListener_keepref
self.game_over = False
self.prev_shaping = None
self.throttle = 0
self.gimbal = 0.0
self.landed_ticks = 0
self.stepnumber = 0
self.smoke = []
# self.terrainheigth = self.np_random.uniform(H / 20, H / 10)
self.terrainheigth = H / 20
self.shipheight = self.terrainheigth + SHIP_HEIGHT
# ship_pos = self.np_random.uniform(0, SHIP_WIDTH / SCALE) + SHIP_WIDTH / SCALE
ship_pos = W / 2
self.helipad_x1 = ship_pos - SHIP_WIDTH / 2
self.helipad_x2 = self.helipad_x1 + SHIP_WIDTH
self.helipad_y = self.terrainheigth + SHIP_HEIGHT
self.water = self.world.CreateStaticBody(
fixtures=fixtureDef(
shape=polygonShape(vertices=((0, 0), (W, 0), (W, self.terrainheigth), (0, self.terrainheigth))),
friction=0.1,
restitution=0.0)
)
self.water.color1 = rgb(70, 96, 176)
self.ship = self.world.CreateStaticBody(
fixtures=fixtureDef(
shape=polygonShape(
vertices=((self.helipad_x1, self.terrainheigth),
(self.helipad_x2, self.terrainheigth),
(self.helipad_x2, self.terrainheigth + SHIP_HEIGHT),
(self.helipad_x1, self.terrainheigth + SHIP_HEIGHT))),
friction=0.5,
restitution=0.0)
)
self.containers = []
for side in [-1, 1]:
self.containers.append(self.world.CreateStaticBody(
fixtures=fixtureDef(
shape=polygonShape(
vertices=((ship_pos + side * 0.95 * SHIP_WIDTH / 2, self.helipad_y),
(ship_pos + side * 0.95 * SHIP_WIDTH / 2, self.helipad_y + SHIP_HEIGHT),
(ship_pos + side * 0.95 * SHIP_WIDTH / 2 - side * SHIP_HEIGHT,
self.helipad_y + SHIP_HEIGHT),
(ship_pos + side * 0.95 * SHIP_WIDTH / 2 - side * SHIP_HEIGHT, self.helipad_y)
)),
friction=0.2,
restitution=0.0)
))
self.containers[-1].color1 = rgb(206, 206, 2)
self.ship.color1 = (0.2, 0.2, 0.2)
initial_x = W / 2 + W * np.random.uniform(-0.3, 0.3)
initial_y = H * 0.95
self.lander = self.world.CreateDynamicBody(
position=(initial_x, initial_y),
angle=0.0,
fixtures=fixtureDef(
shape=polygonShape(vertices=((-ROCKET_WIDTH / 2, 0),
(+ROCKET_WIDTH / 2, 0),
(ROCKET_WIDTH / 2, +ROCKET_HEIGHT),
(-ROCKET_WIDTH / 2, +ROCKET_HEIGHT))),
density=1.0,
friction=0.5,
categoryBits=0x0010,
maskBits=0x001,
restitution=0.0)
)
self.lander.color1 = rgb(230, 230, 230)
for i in [-1, +1]:
leg = self.world.CreateDynamicBody(
position=(initial_x - i * LEG_AWAY, initial_y + ROCKET_WIDTH * 0.2),
angle=(i * BASE_ANGLE),
fixtures=fixtureDef(
shape=polygonShape(
vertices=((0, 0), (0, LEG_LENGTH / 25), (i * LEG_LENGTH, 0), (i * LEG_LENGTH, -LEG_LENGTH / 20),
(i * LEG_LENGTH / 3, -LEG_LENGTH / 7))),
density=1,
restitution=0.0,
friction=0.2,
categoryBits=0x0020,
maskBits=0x001)
)
leg.ground_contact = False
leg.color1 = (0.25, 0.25, 0.25)
rjd = revoluteJointDef(
bodyA=self.lander,
bodyB=leg,
localAnchorA=(i * LEG_AWAY, ROCKET_WIDTH * 0.2),
localAnchorB=(0, 0),
enableLimit=True,
maxMotorTorque=2500.0,
motorSpeed=-0.05 * i,
enableMotor=True
)
djd = distanceJointDef(bodyA=self.lander,
bodyB=leg,
anchorA=(i * LEG_AWAY, ROCKET_HEIGHT / 8),
anchorB=leg.fixtures[0].body.transform * (i * LEG_LENGTH, 0),
collideConnected=False,
frequencyHz=0.01,
dampingRatio=0.9
)
if i == 1:
rjd.lowerAngle = -SPRING_ANGLE
rjd.upperAngle = 0
else:
rjd.lowerAngle = 0
rjd.upperAngle = + SPRING_ANGLE
leg.joint = self.world.CreateJoint(rjd)
leg.joint2 = self.world.CreateJoint(djd)
self.legs.append(leg)
self.lander.linearVelocity = (
-self.np_random.uniform(0, INITIAL_RANDOM) * START_SPEED * (initial_x - W / 2) / W,
-START_SPEED)
self.lander.angularVelocity = (1 + INITIAL_RANDOM) * np.random.uniform(-1, 1)
self.drawlist = self.legs + [self.water] + [self.ship] + self.containers + [self.lander]
if CONTINUOUS:
return self.step([0, 0, 0])[0]
else:
return self.step(6)[0]
LEG_W, LEG_H = 8/SCALE, 34/SCALE
VIEWPORT_W = 600
VIEWPORT_H = 400
TERRAIN_STEP = 14/SCALE
TERRAIN_LENGTH = 200 # in steps
TERRAIN_HEIGHT = VIEWPORT_H/SCALE/4
TERRAIN_GRASS = 10 # low long are grass spots, in steps
TERRAIN_STARTPAD = 20 # in steps
FRICTION = 2.5
HULL_FD = fixtureDef(
shape=polygonShape(vertices=[ (x/SCALE,y/SCALE) for x,y in HULL_POLY ]),
density=5.0,
friction=0.1,
categoryBits=0x0020,
maskBits=0x001, # collide only with ground
restitution=0.0) # 0.99 bouncy
LEG_FD = fixtureDef(
shape=polygonShape(box=(LEG_W/2, LEG_H/2)),
density=1.0,
restitution=0.0,
categoryBits=0x0020,
maskBits=0x001)
LOWER_FD = fixtureDef(
shape=polygonShape(box=(0.8*LEG_W/2, LEG_H/2)),
density=1.0,
restitution=0.0,
def reset(self):
if self.scores is None:
self.scores = deque(maxlen=10000)
else:
if self.achieve_goal:
self.scores.append(1)
else:
self.scores.append(0)
if self.verbose:
self.verbosing()
self.game_over = False
self.prev_shaping = None
self.achieve_goal = False
self.strike_by_obstacle = False
self.speed_table = np.zeros(len(OBSTACLE_POSITIONS))
# timer
self.energy = 1
# clean up objects in the Box 2D world
self._destroy()
# create lidar objects
self.lidar = [LidarCallback() for _ in range(self.num_beams)]
self.world.contactListener_keepref = ContactDetector(self)
self.world.contactListener = self.world.contactListener_keepref
# create new world
self.moon = self.world.CreateStaticBody(shapes=edgeShape(
vertices=[(0, 0), (W, 0)]))
p1 = (1, 1)
p2 = (W - 1, 1)
self.moon.CreateEdgeFixture(
vertices=[p1, p2],
density=100,
friction=0,
restitution=1.0,
)
self._build_wall()
self.moon.color1 = (0.0, 0.0, 0.0)
self.moon.color2 = (0.0, 0.0, 0.0)
# create obstacles
self._build_obstacles()
# create controller object
while True:
drone_pos = (int(np.random.randint(1, 10)),
int(np.random.randint(1, 5)))
self.drone = self.world.CreateDynamicBody(
position=drone_pos,
angle=0.0,
fixtures=fixtureDef(
shape=polygonShape(vertices=[(x / SCALE, y / SCALE)
for x, y in DRONE_POLY]),
density=5.0,
friction=0.1,
categoryBits=0x0010,
maskBits=0x003, # collide all but obs range object
restitution=0.0) # 0.99 bouncy
)
self.drone.color1 = (0.5, 0.4, 0.9)
self.drone.color2 = (0.3, 0.3, 0.5)
self.world.Step(1.0 / FPS, 6 * 30, 2 * 30)
if self.game_over:
self.world.DestroyBody(self.drone)
self.game_over = False
else:
break
# create goal
goal_pos = GOAL_POS[np.random.randint(len(GOAL_POS))]
self.goal = self.world.CreateStaticBody(
position=goal_pos,
angle=0.0,
fixtures=fixtureDef(
shape=polygonShape(vertices=[(x / SCALE, y / SCALE)
for x, y in DRONE_POLY]),
density=5.0,
friction=0.1,
categoryBits=0x002,
maskBits=0x0010, # collide only with control device
restitution=0.0) # 0.99 bouncy
)
self.goal.color1 = (0., 0.5, 0)
self.goal.color2 = (0., 0.5, 0)
self.obs_range_plt = self.world.CreateKinematicBody(
position=(self.drone.position[0], self.drone.position[1]),
angle=0.0,
fixtures=fixtureDef(
shape=circleShape(radius=np.float64(self.max_obs_range),
pos=(0, 0)),
density=0,
friction=0,
categoryBits=0x0100,
maskBits=0x000, # collide with nothing
restitution=0.3))
self.obs_range_plt.color1 = (0.2, 0.2, 0.4)
self.obs_range_plt.color2 = (0.6, 0.6, 0.6)
self.drawlist = [self.obs_range_plt, self.drone, self.goal
] + self.walls + self.obstacles
self._observe_lidar(drone_pos)
self.world.Step(1.0 / FPS, 6 * 30, 2 * 30)
return np.copy(self.array_observation())
def _generate_terrain(self, hardcore):
GRASS, STUMP, STAIRS, PIT, _STATES_ = range(5)
state = GRASS
velocity = 0.0
y = TERRAIN_HEIGHT
counter = TERRAIN_STARTPAD
oneshot = False
self.terrain = []
self.terrain_x = []
self.terrain_y = []
for i in range(self.terrain_length):
x = i * TERRAIN_STEP
self.terrain_x.append(x)
if state == GRASS and not oneshot:
velocity = 0.8 * velocity + 0.01 * np.sign(TERRAIN_HEIGHT - y)
if i > TERRAIN_STARTPAD:
velocity += self.np_random.uniform(-1, 1) / SCALE
y += velocity
elif state == PIT and oneshot:
counter = self.np_random.randint(3, 5)
poly = [
(x, y),
(x + TERRAIN_STEP, y),
(x + TERRAIN_STEP, y - 4 * TERRAIN_STEP),
(x, y - 4 * TERRAIN_STEP),
]
t = self.world.CreateStaticBody(fixtures=fixtureDef(
shape=polygonShape(vertices=poly), friction=FRICTION))
t.color1, t.color2 = (1, 1, 1), (0.6, 0.6, 0.6)
self.terrain.append(t)
t = self.world.CreateStaticBody(
fixtures=fixtureDef(shape=polygonShape(
vertices=[(p[0] + TERRAIN_STEP * counter, p[1])
for p in poly]),
friction=FRICTION))
t.color1, t.color2 = (1, 1, 1), (0.6, 0.6, 0.6)
self.terrain.append(t)
counter += 2
original_y = y
elif state == PIT and not oneshot:
y = original_y
if counter > 1:
y -= 4 * TERRAIN_STEP
elif state == STUMP and oneshot:
counter = self.np_random.randint(1, 3)
poly = [
(x, y),
(x + counter * TERRAIN_STEP, y),
(x + counter * TERRAIN_STEP, y + counter * TERRAIN_STEP),
(x, y + counter * TERRAIN_STEP),
]
t = self.world.CreateStaticBody(fixtures=fixtureDef(
shape=polygonShape(vertices=poly), friction=FRICTION))
t.color1, t.color2 = (1, 1, 1), (0.6, 0.6, 0.6)
self.terrain.append(t)
elif state == STAIRS and oneshot:
stair_height = +1 if self.np_random.rand() > 0.5 else -1
stair_width = self.np_random.randint(4, 5)
stair_steps = self.np_random.randint(3, 5)
original_y = y
for s in range(stair_steps):
poly = [
(x + (s * stair_width) * TERRAIN_STEP,
y + (s * stair_height) * TERRAIN_STEP),
(x + ((1 + s) * stair_width) * TERRAIN_STEP,
y + (s * stair_height) * TERRAIN_STEP),
(x + ((1 + s) * stair_width) * TERRAIN_STEP,
y + (-1 + s * stair_height) * TERRAIN_STEP),
(x + (s * stair_width) * TERRAIN_STEP,
y + (-1 + s * stair_height) * TERRAIN_STEP),
]
t = self.world.CreateStaticBody(fixtures=fixtureDef(
shape=polygonShape(vertices=poly), friction=FRICTION))
t.color1, t.color2 = (1, 1, 1), (0.6, 0.6, 0.6)
self.terrain.append(t)
counter = stair_steps * stair_width
elif state == STAIRS and not oneshot:
s = stair_steps * stair_width - counter - stair_height
n = s / stair_width
y = original_y + (n * stair_height) * TERRAIN_STEP
oneshot = False
self.terrain_y.append(y)
counter -= 1
if counter == 0:
counter = self.np_random.randint(TERRAIN_GRASS / 2,
TERRAIN_GRASS)
if state == GRASS and hardcore:
state = self.np_random.randint(1, _STATES_)
oneshot = True
else:
state = GRASS
oneshot = True
self.terrain_poly = []
for i in range(self.terrain_length - 1):
poly = [(self.terrain_x[i], self.terrain_y[i]),
(self.terrain_x[i + 1], self.terrain_y[i + 1])]
t = self.world.CreateStaticBody(fixtures=fixtureDef(
shape=edgeShape(vertices=poly),
friction=FRICTION,
categoryBits=0x0001,
))
color = (0.3, 1.0 if i % 2 == 0 else 0.8, 0.3)
t.color1 = color
t.color2 = color
self.terrain.append(t)
color = (0.4, 0.6, 0.3)
poly += [(poly[1][0], 0), (poly[0][0], 0)]
self.terrain_poly.append((poly, color))
self.terrain.reverse()
def _create_track(self):
# Creating Road Sections:
# See notes:
road_s1 = [(-ROAD_WIDTH, ROAD_WIDTH), (-ROAD_WIDTH, -ROAD_WIDTH),
(ROAD_WIDTH, -ROAD_WIDTH), (ROAD_WIDTH, ROAD_WIDTH)]
road_s2 = [(-PLAYFIELD, ROAD_WIDTH), (-PLAYFIELD, 0), (-ROAD_WIDTH, 0),
(-ROAD_WIDTH, ROAD_WIDTH)]
road_s3 = [(-PLAYFIELD, 0), (-PLAYFIELD, -ROAD_WIDTH),
(-ROAD_WIDTH, -ROAD_WIDTH), (-ROAD_WIDTH, 0)]
road_s4 = [(-ROAD_WIDTH, -ROAD_WIDTH), (-ROAD_WIDTH, -PLAYFIELD),
(0, -PLAYFIELD), (0, -ROAD_WIDTH)]
road_s5 = [(0, -ROAD_WIDTH), (0, -PLAYFIELD), (ROAD_WIDTH, -PLAYFIELD),
(ROAD_WIDTH, -ROAD_WIDTH)]
road_s6 = [(ROAD_WIDTH, 0), (ROAD_WIDTH, -ROAD_WIDTH),
(PLAYFIELD, -ROAD_WIDTH), (PLAYFIELD, 0)]
road_s7 = [(ROAD_WIDTH, ROAD_WIDTH), (ROAD_WIDTH, 0), (PLAYFIELD, 0),
(PLAYFIELD, ROAD_WIDTH)]
road_s8 = [(0, PLAYFIELD), (0, ROAD_WIDTH), (ROAD_WIDTH, ROAD_WIDTH),
(ROAD_WIDTH, PLAYFIELD)]
road_s9 = [(-ROAD_WIDTH, PLAYFIELD), (-ROAD_WIDTH, ROAD_WIDTH),
(0, ROAD_WIDTH), (0, PLAYFIELD)]
# Creating body of roads:
self.road_poly = road_s1 + road_s2 + road_s3 + road_s4 + road_s5 + road_s6 + road_s7
if self.track_form == 'X':
self.road_poly += road_s8 + road_s9
self.road = []
# Creating a static object - road with names for specific section + i need to define how to listen to it:
for i in range(0, len(self.road_poly), 4):
r = self.world.CreateStaticBody(
fixtures=fixtureDef(shape=polygonShape(
vertices=self.road_poly[i:i + 4]),
isSensor=True))
r.road_section = int(i / 4) + 1
r.name = 'road'
r.userData = r
self.road.append(r)
# Creating sidewalks:
sidewalk_h_nw = [(-PLAYFIELD, ROAD_WIDTH + SIDE_WALK),
(-PLAYFIELD, ROAD_WIDTH),
(-ROAD_WIDTH - SIDE_WALK * 2, ROAD_WIDTH),
(-ROAD_WIDTH - SIDE_WALK * 2, ROAD_WIDTH + SIDE_WALK)]
sidewalk_h_sw = [(x, y - 2 * ROAD_WIDTH - SIDE_WALK)
for x, y in sidewalk_h_nw]
sidewalk_h_ne = [(x + PLAYFIELD + 2 * SIDE_WALK + ROAD_WIDTH, y)
for x, y in sidewalk_h_nw]
sidewalk_h_se = [(x, y - 2 * ROAD_WIDTH - SIDE_WALK)
for x, y in sidewalk_h_ne]
sidewalk_v_nw = [(-ROAD_WIDTH - SIDE_WALK, PLAYFIELD),
(-ROAD_WIDTH - SIDE_WALK, ROAD_WIDTH + SIDE_WALK * 2),
(-ROAD_WIDTH, ROAD_WIDTH + SIDE_WALK * 2),
(-ROAD_WIDTH, PLAYFIELD)]
sidewalk_v_sw = [(x, y - PLAYFIELD - 2 * SIDE_WALK - ROAD_WIDTH)
for x, y in sidewalk_v_nw]
sidewalk_v_ne = [(x + 2 * ROAD_WIDTH + SIDE_WALK, y)
for x, y in sidewalk_v_nw]
sidewalk_v_se = [(x + 2 * ROAD_WIDTH + SIDE_WALK, y)
for x, y in sidewalk_v_sw]
# sidewalk_c_nw = [(-ROAD_WIDTH-2*SIDE_WALK+np.cos(rad)*1*SIDE_WALK, ROAD_WIDTH+2*SIDE_WALK+np.sin(rad)*1*SIDE_WALK)
# for rad in np.linspace(-np.pi/2, 0, 12)]
sidewalk_c_nw = sidewalk_v_nw[2:0:-1] + sidewalk_h_nw[3:1:-1] + [
(-ROAD_WIDTH, ROAD_WIDTH)
]
sidewalk_c_ne = sidewalk_h_ne[1::-1] + sidewalk_v_ne[2:0:-1] + [
(ROAD_WIDTH, ROAD_WIDTH)
]
sidewalk_c_sw = sidewalk_h_sw[3:1:-1] + sidewalk_v_sw[::3] + [
(-ROAD_WIDTH, -ROAD_WIDTH)
]
sidewalk_c_se = sidewalk_v_se[::3] + sidewalk_h_se[1::-1] + [
(ROAD_WIDTH, -ROAD_WIDTH)
]
self.all_sidewalks = [
sidewalk_h_nw, sidewalk_h_ne, sidewalk_h_se, sidewalk_h_sw,
sidewalk_v_nw, sidewalk_v_ne, sidewalk_v_se, sidewalk_v_sw,
sidewalk_c_nw, sidewalk_c_ne, sidewalk_c_se, sidewalk_c_sw
]
#Now let's see the static world:
sidewalk = self.world.CreateStaticBody(fixtures=[
fixtureDef(shape=polygonShape(vertices=sw), isSensor=True)
for sw in self.all_sidewalks
])
sidewalk.name = 'sidewalk'
sidewalk.userData = sidewalk
# remove===============================================================
# w = self.world.CreateStaticBody(fixtures = fixtureDef(shape=polygonShape(box=(10,10, (20,20), 0))))
# w.name = 'car'
# w.userData = w
return True
def draw(self, world, init_x, init_y, force_to_center):
''' Circular body
MAIN_BODY_FIXTURES = fixtureDef(
shape=circleShape(radius=0.4),
density=1.0,
restitution=0.0,
categoryBits=0x20,
maskBits=0x000F
)
'''
MAIN_BODY_FIXTURES = [
fixtureDef(
shape=polygonShape(vertices=[(x * self.body_scale / self.SCALE,
y * self.body_scale / self.SCALE)
for x, y in polygon]),
density=5.0,
friction=0.1,
categoryBits=0x20,
maskBits=0x000F) for polygon in MAIN_BODY_POLYGONS
]
LEG_FD = fixtureDef(shape=polygonShape(box=(self.LEG_W / 2,
self.LEG_H / 2)),
density=1.0,
restitution=0.0,
categoryBits=0x20,
maskBits=0x000F)
LOWER_FD = fixtureDef(shape=polygonShape(box=(0.8 * self.LEG_W / 2,
self.LEG_H / 2)),
density=1.0,
restitution=0.0,
categoryBits=0x20,
maskBits=0x000F)
main_body = world.CreateDynamicBody(position=(init_x, init_y),
fixtures=MAIN_BODY_FIXTURES)
basis_color1 = (0.6, 0.3, 0.5)
basis_color2 = (0.4, 0.2, 0.3)
main_body.color1 = tuple([c - 0.1 for c in basis_color1])
main_body.color2 = tuple([c - 0.1 for c in basis_color2])
leg_color1 = tuple([c + 0.1 for c in basis_color1])
leg_color2 = tuple([c + 0.1 for c in basis_color2])
main_body.ApplyForceToCenter((force_to_center, 0), True)
main_body.userData = CustomBodyUserData(True,
is_contact_critical=True,
name="main_body")
self.body_parts.append(main_body)
self.reference_head_object = main_body
for j in [[0, -1, 0], [0, 1, 0], [-1, 0, np.pi / 2], [1, 0,
np.pi / 2]]:
x_position = j[0] * (HULL_BOTTOM_WIDTH * self.body_scale /
self.SCALE / 2)
y_position = j[1] * (HULL_BOTTOM_WIDTH * self.body_scale /
self.SCALE / 2)
# for i in [-1, +1]:
leg_x = init_x + j[0] * (self.LEG_H / 2) + x_position
leg_y = init_y + j[1] * (self.LEG_H / 2) + y_position
leg = world.CreateDynamicBody(position=(leg_x, leg_y),
angle=(j[2]),
fixtures=LEG_FD)
leg.color1 = leg_color1
leg.color2 = leg_color2
rjd = revoluteJointDef(
bodyA=main_body,
bodyB=leg,
anchor=(init_x + x_position, init_y + y_position),
enableMotor=True,
enableLimit=True,
maxMotorTorque=self.MOTORS_TORQUE,
motorSpeed=1,
lowerAngle=-0.8,
upperAngle=1.1,
)
leg.userData = CustomBodyUserData(False, name="leg")
self.body_parts.append(leg)
joint_motor = world.CreateJoint(rjd)
joint_motor.userData = CustomMotorUserData(SPEED_HIP, False)
self.motors.append(joint_motor)
lower = world.CreateDynamicBody(
position=(leg_x + j[0] * (self.LEG_H),
leg_y + j[1] * (self.LEG_H)),
angle=(j[2]),
fixtures=LOWER_FD)
lower.color1 = leg_color1
lower.color2 = leg_color2
rjd = revoluteJointDef(
bodyA=leg,
bodyB=lower,
anchor=(leg_x + j[0] * (self.LEG_H / 2),
leg_y + j[1] * (self.LEG_H / 2)),
enableMotor=True,
enableLimit=True,
maxMotorTorque=self.MOTORS_TORQUE,
motorSpeed=1,
lowerAngle=-1.6,
upperAngle=-0.1,
)
lower.userData = CustomBodyUserData(True, name="lower")
self.body_parts.append(lower)
joint_motor = world.CreateJoint(rjd)
joint_motor.userData = CustomMotorUserData(SPEED_KNEE,
True,
contact_body=lower,
angle_correction=1.0)
self.motors.append(joint_motor)
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 _create_rocket(self, initial_coordinates=(W / 2, H / 1.2)):
body_color = (1, 1, 1)
# ----------------------------------------------------------------------------------------
# LANDER
initial_x, initial_y = initial_coordinates
self.lander = self.world.CreateDynamicBody(
position=(initial_x, initial_y),
angle=0,
fixtures=fixtureDef(
shape=polygonShape(vertices=[(x / SCALE, y / SCALE)
for x, y in LANDER_POLY]),
density=5.0,
friction=0.1,
categoryBits=0x0010,
maskBits=0x001, # collide only with ground
restitution=0.0) # 0.99 bouncy
)
self.lander.color1 = body_color
self.lander.color2 = (0, 0, 0)
if isinstance(self.settings['Initial Force'], str):
self.lander.ApplyForceToCenter(
(self.np_random.uniform(-INITIAL_RANDOM * 0.3,
INITIAL_RANDOM * 0.3),
self.np_random.uniform(-1.3 * INITIAL_RANDOM,
-INITIAL_RANDOM)), True)
else:
self.lander.ApplyForceToCenter(self.settings['Initial Force'],
True)
# COG is set in the middle of the polygon by default. x = 0 = middle.
# self.lander.mass = 25
# self.lander.localCenter = (0, 3) # COG
# ----------------------------------------------------------------------------------------
# LEGS
self.legs = []
for i in [-1, +1]:
leg = self.world.CreateDynamicBody(
position=(initial_x - i * LEG_AWAY / SCALE, initial_y),
angle=(i * 0.05),
fixtures=fixtureDef(shape=polygonShape(box=(LEG_W / SCALE,
LEG_H / SCALE)),
density=5.0,
restitution=0.0,
categoryBits=0x0020,
maskBits=0x005))
leg.ground_contact = False
leg.color1 = body_color
leg.color2 = (0, 0, 0)
rjd = revoluteJointDef(
bodyA=self.lander,
bodyB=leg,
localAnchorA=(-i * 0.3 / LANDER_CONSTANT, 0),
localAnchorB=(i * 0.5 / LANDER_CONSTANT, LEG_DOWN),
enableMotor=True,
enableLimit=True,
maxMotorTorque=LEG_SPRING_TORQUE,
motorSpeed=+0.3 * i # low enough not to jump back into the sky
)
if i == -1:
rjd.lowerAngle = 40 * DEGTORAD
rjd.upperAngle = 45 * DEGTORAD
else:
rjd.lowerAngle = -45 * DEGTORAD
rjd.upperAngle = -40 * DEGTORAD
leg.joint = self.world.CreateJoint(rjd)
self.legs.append(leg)
# ----------------------------------------------------------------------------------------
# NOZZLE
self.nozzle = self.world.CreateDynamicBody(
position=(initial_x, initial_y),
angle=0.0,
fixtures=fixtureDef(
shape=polygonShape(vertices=[(x / SCALE, y / SCALE)
for x, y in NOZZLE_POLY]),
density=5.0,
friction=0.1,
categoryBits=0x0040,
maskBits=0x003, # collide only with ground
restitution=0.0) # 0.99 bouncy
)
self.nozzle.color1 = (0, 0, 0)
self.nozzle.color2 = (0, 0, 0)
rjd = revoluteJointDef(
bodyA=self.lander,
bodyB=self.nozzle,
localAnchorA=(0, 0),
localAnchorB=(0, 0.2),
enableMotor=True,
enableLimit=True,
maxMotorTorque=NOZZLE_TORQUE,
motorSpeed=0,
referenceAngle=0,
lowerAngle=-13 *
DEGTORAD, # +- 15 degrees limit applied in practice
upperAngle=13 * DEGTORAD)
# The default behaviour of a revolute joint is to rotate without resistance.
self.nozzle.joint = self.world.CreateJoint(rjd)
# ----------------------------------------------------------------------------------------
# self.drawlist = [self.nozzle] + [self.lander] + self.legs
self.drawlist = self.legs + [self.nozzle] + [self.lander]
self.initial_mass = self.lander.mass
self.remaining_fuel = INITIAL_FUEL_MASS_PERCENTAGE * self.initial_mass
return
def __init__(self):
EzPickle.__init__(self)
self.seed()
self.viewer = None
self.iterations = 0
self.current_state = [0]*24
self.action_mask = []
self.gait = 0
self.support_knee_angle = 0.1
self.moving_leg = None
self.supporting_leg = None
self.world = Box2D.b2World()
self.terrain = None
self.hull = None
self.prev_shaping = None
self.fd_polygon = fixtureDef(
shape = polygonShape(vertices=
[(0, 0),
(1, 0),
(1, -1),
(0, -1)]),
friction = FRICTION)
self.fd_edge = fixtureDef(
shape = edgeShape(vertices=
[(0, 0),
(1, 1)]),
friction = FRICTION,
categoryBits=0x0001,
)
self.reset()
high = np.array([np.inf] * 24)
self.action_space = spaces.Discrete(3)
self.observation_space = spaces.Box(-high, high, dtype=np.float32)
def _create_decoration():
objs = []
objs.append(
self.world.CreateStaticBody(
position=(W / 2, H / 2),
angle=0.0,
fixtures=fixtureDef(shape=circleShape(radius=100 / SCALE,
pos=(0, 0)),
categoryBits=0x0,
maskBits=0x0)))
objs[-1].color1 = (0.8, 0.8, 0.8)
objs[-1].color2 = (0.8, 0.8, 0.8)
# left goal
objs.append(
self.world.CreateStaticBody(
position=(W / 2 - 250 / SCALE, H / 2),
angle=0.0,
fixtures=fixtureDef(shape=circleShape(radius=GOAL_SIZE /
SCALE,
pos=(0, 0)),
categoryBits=0x0,
maskBits=0x0)))
orange = (239. / 255, 203. / 255, 138. / 255)
objs[-1].color1 = orange
objs[-1].color2 = orange
poly = [(0, 100), (100, 100), (100, -100), (0, -100)]
objs.append(
self.world.CreateStaticBody(
position=(W / 2 - 240 / SCALE, H / 2),
angle=0.0,
fixtures=fixtureDef(
shape=polygonShape(vertices=[(x / SCALE, y / SCALE)
for x, y in poly]),
categoryBits=0x0,
maskBits=0x0)))
objs[-1].color1 = (1, 1, 1)
objs[-1].color2 = (1, 1, 1)
# right goal
objs.append(
self.world.CreateStaticBody(
position=(W / 2 + 250 / SCALE, H / 2),
angle=0.0,
fixtures=fixtureDef(shape=circleShape(radius=GOAL_SIZE /
SCALE,
pos=(0, 0)),
categoryBits=0x0,
maskBits=0x0)))
objs[-1].color1 = orange
objs[-1].color2 = orange
poly = [(100, 100), (0, 100), (0, -100), (100, -100)]
objs.append(
self.world.CreateStaticBody(
position=(W / 2 + 140 / SCALE, H / 2),
angle=0.0,
fixtures=fixtureDef(
shape=polygonShape(vertices=[(x / SCALE, y / SCALE)
for x, y in poly]),
categoryBits=0x0,
maskBits=0x0)))
objs[-1].color1 = (1, 1, 1)
objs[-1].color2 = (1, 1, 1)
return objs
def _create_track(self):
CHECKPOINTS = 12 # 12 = nombre de virages (11) + le départ (1)
# Create checkpoints
checkpoints = []
self.obstacles_positions = []
for c in range(CHECKPOINTS):
noise = self.np_random.uniform(0, 2 * 3.14159 * 1 / CHECKPOINTS)
alpha = 2 * 3.14159 * c / CHECKPOINTS + noise
rad = self.np_random.uniform(TRACK_RAD / 3, TRACK_RAD)
if c == 0:
alpha = 0
rad = 1.5 * TRACK_RAD
if c == CHECKPOINTS - 1:
alpha = 2 * 3.14159 * c / CHECKPOINTS
self.start_alpha = 2 * 3.14159 * (-0.5) / CHECKPOINTS
rad = 1.5 * TRACK_RAD
checkpoints.append(
(alpha, rad * math.cos(alpha), rad * math.sin(alpha)))
self.road = []
# Go from one checkpoint to another to create track
x, y, beta = 1.5 * TRACK_RAD, 0, 0
dest_i = 0
laps = 0
track = []
no_freeze = 2500
visited_other_side = False
while True:
alpha = math.atan2(y, x)
if visited_other_side and alpha > 0:
laps += 1
visited_other_side = False
if alpha < 0:
visited_other_side = True
alpha += 2 * 3.14159
while True: # Find destination from checkpoints
failed = True
while True:
dest_alpha, dest_x, dest_y = checkpoints[dest_i %
len(checkpoints)]
if alpha <= dest_alpha:
failed = False
break
dest_i += 1
if dest_i % len(checkpoints) == 0:
break
if not failed:
break
alpha -= 2 * 3.14159
continue
r1x = math.cos(beta)
r1y = math.sin(beta)
p1x = -r1y
p1y = r1x
dest_dx = dest_x - x # vector towards destination
dest_dy = dest_y - y
# destination vector projected on rad:
proj = r1x * dest_dx + r1y * dest_dy
while beta - alpha > 1.5 * 3.14159:
beta -= 2 * 3.14159
while beta - alpha < -1.5 * 3.14159:
beta += 2 * 3.14159
prev_beta = beta
proj *= SCALE
if proj > 0.3:
beta -= min(TRACK_TURN_RATE, abs(0.001 * proj))
if proj < -0.3:
beta += min(TRACK_TURN_RATE, abs(0.001 * proj))
x += p1x * TRACK_DETAIL_STEP
y += p1y * TRACK_DETAIL_STEP
track.append((alpha, prev_beta * 0.5 + beta * 0.5, x, y))
if laps > 4:
break
no_freeze -= 1
if no_freeze == 0:
break
# Find closed loop range i1..i2, first loop should be ignored, second is OK
i1, i2 = -1, -1
i = len(track)
while True:
i -= 1
if i == 0:
return False # Failed
pass_through_start = track[i][0] > self.start_alpha and track[
i - 1][0] <= self.start_alpha
if pass_through_start and i2 == -1:
i2 = i
elif pass_through_start and i1 == -1:
i1 = i
break
if self.verbose == 1:
print("Track generation: %i..%i -> %i-tiles track" %
(i1, i2, i2 - i1))
assert i1 != -1
assert i2 != -1
track = track[i1:i2 - 1]
first_beta = track[0][1]
first_perp_x = math.cos(first_beta)
first_perp_y = math.sin(first_beta)
# Length of perpendicular jump to put together head and tail
well_glued_together = np.sqrt(
np.square(first_perp_x * (track[0][2] - track[-1][2])) +
np.square(first_perp_y * (track[0][3] - track[-1][3])))
if well_glued_together > TRACK_DETAIL_STEP:
return False
# Red-white border on hard turns
border = [False] * len(track)
for i in range(len(track)):
good = True
oneside = 0
for neg in range(BORDER_MIN_COUNT):
beta1 = track[i - neg - 0][1]
beta2 = track[i - neg - 1][1]
good &= abs(beta1 - beta2) > TRACK_TURN_RATE * 0.2
oneside += np.sign(beta1 - beta2)
good &= abs(oneside) == BORDER_MIN_COUNT
border[i] = good
for i in range(len(track)):
for neg in range(BORDER_MIN_COUNT):
border[i - neg] |= border[i]
# Create tiles and obstacles
last_obstacle = 15 # pour que le début de course se passe sans obstacle
for i in range(len(track)):
alpha1, beta1, x1, y1 = track[i]
alpha2, beta2, x2, y2 = track[i - 1]
road1_l = (x1 - TRACK_WIDTH * math.cos(beta1),
y1 - TRACK_WIDTH * math.sin(beta1))
road1_r = (x1 + TRACK_WIDTH * math.cos(beta1),
y1 + TRACK_WIDTH * math.sin(beta1))
road2_l = (x2 - TRACK_WIDTH * math.cos(beta2),
y2 - TRACK_WIDTH * math.sin(beta2))
road2_r = (x2 + TRACK_WIDTH * math.cos(beta2),
y2 + TRACK_WIDTH * math.sin(beta2))
vertices = [road1_l, road1_r, road2_r, road2_l]
self.fd_tile.shape.vertices = vertices
t = self.world.CreateStaticBody(fixtures=self.fd_tile)
t.userData = t
c = 0.01 * (i % 3)
t.color = [0, 0.128, 0.624, 0.019]
t.road_visited = False
t.road_friction = 1.0
t.fixtures[0].sensor = True
self.road_poly.append(([road1_l, road1_r, road2_r,
road2_l], t.color))
self.road.append(t)
if border[i]:
side = np.sign(beta2 - beta1)
b1_l = (x1 + side * TRACK_WIDTH * math.cos(beta1),
y1 + side * TRACK_WIDTH * math.sin(beta1))
b1_r = (x1 + side * (TRACK_WIDTH + BORDER) * math.cos(beta1),
y1 + side * (TRACK_WIDTH + BORDER) * math.sin(beta1))
b2_l = (x2 + side * TRACK_WIDTH * math.cos(beta2),
y2 + side * TRACK_WIDTH * math.sin(beta2))
b2_r = (x2 + side * (TRACK_WIDTH + BORDER) * math.cos(beta2),
y2 + side * (TRACK_WIDTH + BORDER) * math.sin(beta2))
self.road_poly.append(([b1_l, b1_r, b2_r,
b2_l], (1, 1, 1) if i % 2 == 0 else
(1, 0, 0)))
self.random_obs += 1
self.seed(self.random_obs)
if (self.np_random.uniform(0, 1) < OBSTACLE_PROB) and (
last_obstacle <=
0): # i > 15 pour que la course soit toujours faisable
last_obstacle = 8
deriv_left = self.np_random.uniform(TRACK_WIDTH)
deriv_right = TRACK_WIDTH - deriv_left
obs1_l = (x1 - (TRACK_WIDTH - deriv_left) * math.cos(beta1),
y1 - (TRACK_WIDTH - deriv_left) * math.sin(beta1))
obs1_r = (x1 + (TRACK_WIDTH - deriv_right) * math.cos(beta1),
y1 + (TRACK_WIDTH - deriv_right) * math.sin(beta1))
obs2_l = (x2 - (TRACK_WIDTH - deriv_left) * math.cos(beta2),
y2 - (TRACK_WIDTH - deriv_left) * math.sin(beta2))
obs2_r = (x2 + (TRACK_WIDTH - deriv_right) * math.cos(beta2),
y2 + (TRACK_WIDTH - deriv_right) * math.sin(beta2))
self.obstacles_positions.append(
(obs1_l, obs1_r, obs2_r, obs2_l))
vertices = [obs1_l, obs1_r, obs2_r, obs2_l]
obstacle = fixtureDef(shape=polygonShape(vertices=vertices))
obstacle.userData = obstacle
obstacle.color = [0.1568, 0.598, 0.2862, 0]
self.road_poly.append(([obs1_l, obs1_r, obs2_r,
obs2_l], obstacle.color))
last_obstacle -= 1
self.track = track
return True
def _create_track(self):
CHECKPOINTS = 12
# Create checkpoints
checkpoints = []
for c in range(CHECKPOINTS):
# alpha = 2*math.pi*c/CHECKPOINTS + \
# self.np_random.uniform(0, 2*math.pi*1/CHECKPOINTS)
# rad = self.np_random.uniform(TRACK_RAD/3, TRACK_RAD)
alpha = 2 * math.pi * c / CHECKPOINTS
rad = TRACK_RAD
if c == 0:
alpha = 0
rad = 1.5 * TRACK_RAD
if c == CHECKPOINTS - 1:
alpha = 2 * math.pi * c / CHECKPOINTS
self.start_alpha = 2 * math.pi * (-0.5) / CHECKPOINTS
rad = 1.5 * TRACK_RAD
checkpoints.append(
(alpha, rad * math.cos(alpha), rad * math.sin(alpha)))
# print "\n".join(str(h) for h in checkpoints)
# self.road_poly = [ ( # uncomment this to see checkpoints
# [ (tx,ty) for a,tx,ty in checkpoints ],
# (0.7,0.7,0.9) ) ]
self.road = []
# Go from one checkpoint to another to create track
x, y, beta = 1.5 * TRACK_RAD, 0, 0
dest_i = 0
laps = 0
track = []
no_freeze = 2500
visited_other_side = False
while True:
alpha = math.atan2(y, x)
if visited_other_side and alpha > 0:
laps += 1
visited_other_side = False
if alpha < 0:
visited_other_side = True
alpha += 2 * math.pi
while True: # Find destination from checkpoints
failed = True
while True:
dest_alpha, dest_x, dest_y = checkpoints[dest_i %
len(checkpoints)]
if alpha <= dest_alpha:
failed = False
break
dest_i += 1
if dest_i % len(checkpoints) == 0:
break
if not failed:
break
alpha -= 2 * math.pi
continue
r1x = math.cos(beta)
r1y = math.sin(beta)
p1x = -r1y
p1y = r1x
dest_dx = dest_x - x # vector towards destination
dest_dy = dest_y - y
proj = r1x * dest_dx + r1y * dest_dy # destination vector projected on rad
while beta - alpha > 1.5 * math.pi:
beta -= 2 * math.pi
while beta - alpha < -1.5 * math.pi:
beta += 2 * math.pi
prev_beta = beta
proj *= SCALE
if proj > 0.3:
beta -= min(TRACK_TURN_RATE, abs(0.001 * proj))
if proj < -0.3:
beta += min(TRACK_TURN_RATE, abs(0.001 * proj))
x += p1x * TRACK_DETAIL_STEP
y += p1y * TRACK_DETAIL_STEP
track.append((alpha, prev_beta * 0.5 + beta * 0.5, x, y))
if laps > 4:
break
no_freeze -= 1
if no_freeze == 0:
break
# print "\n".join([str(t) for t in enumerate(track)])
# Find closed loop range i1..i2, first loop should be ignored, second is OK
i1, i2 = -1, -1
i = len(track)
while True:
i -= 1
if i == 0:
return False # Failed
pass_through_start = track[i][0] > self.start_alpha and track[
i - 1][0] <= self.start_alpha
if pass_through_start and i2 == -1:
i2 = i
elif pass_through_start and i1 == -1:
i1 = i
break
if self.verbose == 1:
print("Track generation: %i..%i -> %i-tiles track" %
(i1, i2, i2 - i1))
assert i1 != -1
assert i2 != -1
track = track[i1:i2 - 1]
first_beta = track[0][1]
first_perp_x = math.cos(first_beta)
first_perp_y = math.sin(first_beta)
# Length of perpendicular jump to put together head and tail
well_glued_together = np.sqrt(
np.square(first_perp_x * (track[0][2] - track[-1][2])) +
np.square(first_perp_y * (track[0][3] - track[-1][3])))
if well_glued_together > TRACK_DETAIL_STEP:
return False
# Red-white border on hard turns
border = [False] * len(track)
for i in range(len(track)):
good = True
oneside = 0
for neg in range(BORDER_MIN_COUNT):
beta1 = track[i - neg - 0][1]
beta2 = track[i - neg - 1][1]
good &= abs(beta1 - beta2) > TRACK_TURN_RATE * 0.2
oneside += np.sign(beta1 - beta2)
good &= abs(oneside) == BORDER_MIN_COUNT
border[i] = good
for i in range(len(track)):
for neg in range(BORDER_MIN_COUNT):
border[i - neg] |= border[i]
length_of_track = len(track)
# CHECKPOINTS
num_checkpoints = NUM_CHECKPOINTS
# old version
# tiles_per_checkpoint = length_of_track // num_checkpoints
# idx_checkpoints = [idx for idx in range(
# len(track)) if idx % tiles_per_checkpoint == 5]
# remaining_idx = [idx for idx in range(
# len(track)) if idx not in idx_checkpoints]
# new version
quarter_length = length_of_track // 4
half_length = length_of_track // 2
assert num_checkpoints < 4
idx_checkpoints = [
10 + i * half_length for i in range(num_checkpoints)
]
remaining_idx = [
idx for idx in range(len(track)) if idx not in idx_checkpoints
]
self.checkpoint_bodies = []
self.checkpoints = []
# FULLY ICY TILES
num_fully_icy_tiles = NUM_FULLY_ICY_TILES
# old version
idx_fully_icy_tiles = []
for t in range(num_fully_icy_tiles):
idx = self.np_random.choice(remaining_idx)
length = self.np_random.randint(ICY_TILES_MIN_LENGTH,
ICY_TILES_MAX_LENGTH + 1)
for i in range(idx, idx + length):
if i in remaining_idx:
idx_fully_icy_tiles.append(i)
remaining_idx = [
j for j in remaining_idx if j not in idx_fully_icy_tiles
]
# new version
# start_idx = self.np_random.randint(20)
# idx_fully_icy_tiles = [
# start_idx + quarter_length + i for i in range(icy_tiles_length)]
# remaining_idx = [
# idx for idx in remaining_idx if idx not in idx_fully_icy_tiles]
# PARTIALLY ICY TILES
num_partially_icy_tiles = NUM_PARTIALLY_ICY_TILES
idx_partially_icy_tiles = []
eta1s = {}
eta2s = {}
for t in range(num_partially_icy_tiles):
idx = self.np_random.choice(remaining_idx)
eta1 = self.np_random.uniform(0, 1)
eta2 = self.np_random.uniform(eta1, 1)
length = self.np_random.randint(PARTIAL_ICY_TILES_MIN_LENGTH,
PARTIAL_ICY_TILES_MAX_LENGTH + 1)
for i in range(idx, idx + length):
if i in remaining_idx:
idx_partially_icy_tiles.append(i)
eta1s[i] = eta1
eta2s[i] = eta2
remaining_idx = [
j for j in remaining_idx
if j not in idx_partially_icy_tiles
]
# Create tiles
for i in range(len(track)):
alpha1, beta1, x1, y1 = track[i]
alpha2, beta2, x2, y2 = track[i - 1]
if i in idx_checkpoints:
# Add checkpoint
checkpoint = self.world.CreateStaticBody(fixtures=[
fixtureDef(shape=polygonShape(box=(0.05, 0.05, (x1, y1),
0)))
])
checkpoint.fixtures[0].sensor = True
checkpoint.color = (0, 0, 1)
self.checkpoint_bodies.append(checkpoint)
betaavg = (beta1 + beta2) / 2
self.checkpoints.append((x1, y1, betaavg))
road1_l = np.array((x1 - TRACK_WIDTH * math.cos(beta1),
y1 - TRACK_WIDTH * math.sin(beta1)))
road1_r = np.array((x1 + TRACK_WIDTH * math.cos(beta1),
y1 + TRACK_WIDTH * math.sin(beta1)))
road2_l = np.array((x2 - TRACK_WIDTH * math.cos(beta2),
y2 - TRACK_WIDTH * math.sin(beta2)))
road2_r = np.array((x2 + TRACK_WIDTH * math.cos(beta2),
y2 + TRACK_WIDTH * math.sin(beta2)))
vertices = [
tuple(road1_l),
tuple(road1_r),
tuple(road2_r),
tuple(road2_l)
]
# Create left boundary tile
gamma1 = road1_r - road1_l
gamma2 = road2_r - road2_l
vertices_left_boundary = [
tuple(road1_l - 0.4 * gamma1),
tuple(road1_l - 0.3 * gamma1),
tuple(road2_l - 0.3 * gamma2),
tuple(road2_l - 0.4 * gamma2)
]
self.boundary_tile.shape.vertices = vertices_left_boundary
if not self.no_boundary:
if i not in np.arange(284, 299) and i not in np.arange(13, 26):
t = self.world.CreateStaticBody(
fixtures=self.boundary_tile)
t.color = [1, 1, 1]
self.boundary_tiles.append(t)
# Create right boundary tile
vertices_right_boundary = [
tuple(road1_r + 0.3 * gamma1),
tuple(road1_r + 0.4 * gamma1),
tuple(road2_r + 0.4 * gamma2),
tuple(road2_r + 0.3 * gamma2)
]
self.boundary_tile.shape.vertices = vertices_right_boundary
if not self.no_boundary:
t = self.world.CreateStaticBody(fixtures=self.boundary_tile)
t.color = [1, 1, 1]
self.boundary_tiles.append(t)
# Create the road tile
self.fd_tile.shape.vertices = vertices
t = self.world.CreateStaticBody(fixtures=self.fd_tile)
t.userData = t
c = 0.01 * (i % 3)
if i not in idx_fully_icy_tiles:
# Road tile
t.color = [
ROAD_COLOR[0] + c, ROAD_COLOR[1] + c, ROAD_COLOR[2] + c
]
t.road_friction = 1.0
if i in idx_partially_icy_tiles:
eta1, eta2 = eta1s[i], eta2s[i]
gamma1 = road1_r - road1_l
gamma2 = road2_r - road2_l
ice_vertices = [
tuple(road1_l + eta1 * gamma1),
tuple(road1_l + eta2 * gamma1),
tuple(road2_l + eta2 * gamma2),
tuple(road2_l + eta1 * gamma2)
]
self.fd_tile.shape.vertices = ice_vertices
ice_t = self.world.CreateStaticBody(fixtures=self.fd_tile)
ice_t.userData = ice_t
ice_t.color = self.ice_color
ice_t.road_friction = self.ice_friction
ice_t.road_visited = False
ice_t.fixtures[0].sensor = True
else:
# Fully Icy tile
t.color = self.ice_color
t.road_friction = self.ice_friction
t.road_visited = False
t.fixtures[0].sensor = True
# Add discrete poly
self.add_to_discrete_poly([road1_l, road1_r, road2_r, road2_l])
self.road_poly.append(([road1_l, road1_r, road2_r,
road2_l], t.color))
self.road.append(t)
if i in idx_partially_icy_tiles:
self.road_poly.append((ice_vertices, ice_t.color))
self.road.append(ice_t)
if border[i]:
side = np.sign(beta2 - beta1)
b1_l = (x1 + side * TRACK_WIDTH * math.cos(beta1),
y1 + side * TRACK_WIDTH * math.sin(beta1))
b1_r = (x1 + side * (TRACK_WIDTH + BORDER) * math.cos(beta1),
y1 + side * (TRACK_WIDTH + BORDER) * math.sin(beta1))
b2_l = (x2 + side * TRACK_WIDTH * math.cos(beta2),
y2 + side * TRACK_WIDTH * math.sin(beta2))
b2_r = (x2 + side * (TRACK_WIDTH + BORDER) * math.cos(beta2),
y2 + side * (TRACK_WIDTH + BORDER) * math.sin(beta2))
self.road_poly.append(([b1_l, b1_r, b2_r,
b2_l], (1, 1, 1) if i % 2 == 0 else
(1, 0, 0)))
self.track = track
return True
def _reset(self):
self._destroy()
self.world.contactListener_bug_workaround = ContactDetector(self)
self.world.contactListener = self.world.contactListener_bug_workaround
self.game_over = False
self.prev_shaping = None
self.scroll = 0.0
self.lidar_render = 0
W = VIEWPORT_W / SCALE
H = VIEWPORT_H / SCALE
self._generate_terrain(self.hardcore)
self._generate_clouds()
init_x = TERRAIN_STEP * TERRAIN_STARTPAD / 2
init_y = TERRAIN_HEIGHT + 2 * LEG_H
self.hull = self.world.CreateDynamicBody(
position=(init_x, init_y),
fixtures=fixtureDef(
shape=polygonShape(vertices=[(x / SCALE, y / SCALE)
for x, y in HULL_POLY]),
density=5.0,
friction=0.1,
categoryBits=0x0020,
maskBits=0x001, # collide only with ground
restitution=0.0) # 0.99 bouncy
)
self.hull.color1 = (0.5, 0.4, 0.9)
self.hull.color2 = (0.3, 0.3, 0.5)
self.hull.ApplyForceToCenter(
(self.np_random.uniform(-INITIAL_RANDOM, INITIAL_RANDOM), 0), True)
self.legs = []
self.joints = []
# i=-1, up => joint[0], i=-1 => joint[1], i=+1 => joint[2]
for i in [-1, +1]: #i=1 => front leg (on the right) (green)
leg = self.world.CreateDynamicBody(
position=(init_x, init_y - LEG_H / 2 - LEG_DOWN),
angle=(i * 0.05),
fixtures=fixtureDef(shape=polygonShape(box=(LEG_W / 2,
LEG_H / 2)),
density=1.0,
restitution=0.0,
categoryBits=0x0020,
maskBits=0x001))
if i == -1: # R G B
leg.color1 = (1., 0., 0.) #inside of leg
leg.color2 = (0.8, 0., 0.) #boundary line of leg
else:
leg.color1 = (0., 1., 0.)
leg.color2 = (0., 0.8, 0.)
# Different limit angles for each joint -----MODIF
LOWER_ANGLE = 0.
UPPER_ANGLE = 0.
if i == (+1):
#LOWER_ANGLE = -0.8
#UPPER_ANGLE = 0
LOWER_ANGLE = -0.8
UPPER_ANGLE = 1.1
else:
#LOWER_ANGLE = -0.8
#UPPER_ANGLE = 0
LOWER_ANGLE = -0.8
UPPER_ANGLE = 1.1
rjd = revoluteJointDef(
bodyA=self.hull,
bodyB=leg,
#localAnchorA=(0, LEG_DOWN), #-----MODIF
localAnchorA=(-float(i) / 4, LEG_DOWN),
localAnchorB=(0, LEG_H / 2),
enableMotor=True,
enableLimit=True,
maxMotorTorque=MOTORS_TORQUE,
motorSpeed=i,
#lowerAngle = -0.8, -----MODIF
#upperAngle = 1.1,
lowerAngle=LOWER_ANGLE,
upperAngle=UPPER_ANGLE,
)
self.legs.append(leg)
self.joints.append(self.world.CreateJoint(rjd))
lower = self.world.CreateDynamicBody(
position=(init_x, init_y - LEG_H * 3 / 2 - LEG_DOWN),
angle=(i * 0.05),
fixtures=fixtureDef(shape=polygonShape(box=(0.8 * LEG_W / 2,
LEG_H / 2)),
density=1.0,
restitution=0.0,
categoryBits=0x0020,
maskBits=0x001))
if i == -1: # R G B
lower.color1 = (1., 0., 0.)
lower.color2 = (0.8, 0., 0.)
else:
lower.color1 = (0., 1., 0.)
lower.color2 = (0., 0.8, 0.)
#lower.color1 = (0.6-i/10., 0.3-i/10., 0.5-i/10.)
#lower.color2 = (0.4-i/10., 0.2-i/10., 0.3-i/10.)
# Different limit angles for each joint
LOWER_ANGLE = 0.
UPPER_ANGLE = 0.
if i == (+1):
LOWER_ANGLE = -0.8
UPPER_ANGLE = 0
#LOWER_ANGLE = -1.6
#UPPER_ANGLE = -0.1
else:
LOWER_ANGLE = -0.8
UPPER_ANGLE = 0
#LOWER_ANGLE = -1.6
#UPPER_ANGLE = -0.1
rjd = revoluteJointDef(
bodyA=leg,
bodyB=lower,
localAnchorA=(0, -LEG_H / 2),
localAnchorB=(0, LEG_H / 2),
enableMotor=True,
enableLimit=True,
maxMotorTorque=MOTORS_TORQUE,
motorSpeed=1,
#lowerAngle = -1.6,
#upperAngle = -0.1,
lowerAngle=LOWER_ANGLE,
upperAngle=UPPER_ANGLE,
)
lower.ground_contact = False
self.legs.append(lower)
self.joints.append(self.world.CreateJoint(rjd))
self.drawlist = self.terrain + self.legs + [self.hull]
class LidarCallback(Box2D.b2.rayCastCallback):
def ReportFixture(self, fixture, point, normal, fraction):
if (fixture.filterData.categoryBits & 1) == 0:
return 1
self.p2 = point
self.fraction = fraction
return 0
self.lidar = [LidarCallback() for _ in range(10)]
return self._step(np.array([0, 0, 0, 0]))[0]
def __init__(self, world, init_angle, init_x, init_y, draw_car=False):
self.world = world
self.hull = self.world.CreateDynamicBody(
position=(init_x, init_y),
angle=init_angle,
fixtures=[
fixtureDef(
shape=polygonShape(vertices=[(x * SIZE, y * SIZE)
for x, y in HULL_POLY1]),
density=1.0),
fixtureDef(
shape=polygonShape(vertices=[(x * SIZE, y * SIZE)
for x, y in HULL_POLY2]),
density=1.0),
fixtureDef(
shape=polygonShape(vertices=[(x * SIZE, y * SIZE)
for x, y in HULL_POLY3]),
density=1.0),
fixtureDef(
shape=polygonShape(vertices=[(x * SIZE, y * SIZE)
for x, y in HULL_POLY4]),
density=1.0)
])
self.hull.color = (0.8, 0.0, 0.0)
self.wheels = []
self.fuel_spent = 0.0
WHEEL_POLY = [(-WHEEL_W, +WHEEL_R), (+WHEEL_W, +WHEEL_R),
(+WHEEL_W, -WHEEL_R), (-WHEEL_W, -WHEEL_R)]
for wx, wy in WHEELPOS:
front_k = 1.0 if wy > 0 else 1.0
w = self.world.CreateDynamicBody(
position=(init_x + wx * SIZE, init_y + wy * SIZE),
angle=init_angle,
fixtures=fixtureDef(
shape=polygonShape(vertices=[(x * front_k * SIZE,
y * front_k * SIZE)
for x, y in WHEEL_POLY]),
density=0.1,
categoryBits=0x0020,
maskBits=0x001,
restitution=0.0))
w.wheel_rad = front_k * WHEEL_R * SIZE
w.color = WHEEL_COLOR
w.gas = 0.0
w.brake = 0.0
w.steer = 0.0
w.phase = 0.0 # wheel angle
w.omega = 0.0 # angular velocity
w.skid_start = None
w.skid_particle = None
rjd = revoluteJointDef(
bodyA=self.hull,
bodyB=w,
localAnchorA=(wx * SIZE, wy * SIZE),
localAnchorB=(0, 0),
enableMotor=True,
enableLimit=True,
maxMotorTorque=180 * 900 * SIZE * SIZE,
motorSpeed=0,
lowerAngle=-0.4,
upperAngle=+0.4,
)
w.joint = self.world.CreateJoint(rjd)
w.tiles = set()
w.userData = w
self.wheels.append(w)
if not draw_car:
# Only draw ugly hull when not drawing beautiful car
self.drawlist = self.wheels + [self.hull]
else:
self.drawlist = self.wheels
self.particles = []
self.draw_car = draw_car
# self.file_name = "square.png"
self.file_name = "Prince_Of_Speed.png"
self.img_path = self.get_image_path(self.file_name)
self.sprite_geom = None
self.car_scale_x = None
self.car_scale_y = None
def _reset(self):
self._destroy()
self.world.contactListener_bug_workaround = ContactDetector(self)
self.world.contactListener = self.world.contactListener_bug_workaround
self.game_over = False
self.prev_shaping = None
self.scroll = 0.0
self.lidar_render = 0
W = VIEWPORT_W / SCALE
H = VIEWPORT_H / SCALE
self._generate_terrain(self.hardcore)
self._generate_clouds()
self.hull = self.world.CreateDynamicBody(
position=(hull_x, hull_y),
fixtures=fixtureDef(
shape=polygonShape(vertices=[(x / SCALE, y / SCALE)
for x, y in HULL_POLY]),
density=5.0,
friction=0.1,
categoryBits=0x0020,
maskBits=0x001, # collide only with ground
restitution=0.0) # 0.99 bouncy
)
self.hull.color1 = (0.5, 0.4, 0.9)
self.hull.color2 = (0.3, 0.3, 0.5)
#self.hull.ApplyForceToCenter((self.np_random.uniform(-INITIAL_RANDOM, INITIAL_RANDOM), 0), True)
#self.hull.ApplyForceToCenter((0, 10*10.0*5.0*(20/SCALE)**2), False)
self.legs = []
self.joints = []
for i in [-1, +1]:
leg = self.world.CreateDynamicBody(
position=(leg_x, leg_y),
angle=gamma_i,
fixtures=fixtureDef(shape=polygonShape(box=(LEG_W / 2,
LEG_H / 2)),
density=1.0,
restitution=0.0,
categoryBits=0x0020,
maskBits=0x001))
leg.color1 = (0.6 - i / 10., 0.3 - i / 10., 0.5 - i / 10.)
leg.color2 = (0.4 - i / 10., 0.2 - i / 10., 0.3 - i / 10.)
rjd = revoluteJointDef(
bodyA=self.hull,
bodyB=leg,
localAnchorA=(0, 0),
localAnchorB=(0, LEG_H / 2),
enableMotor=True,
enableLimit=True,
maxMotorTorque=MOTORS_TORQUE,
motorSpeed=0.0,
referenceAngle=0.0,
lowerAngle=-1.4, # -80 degree
upperAngle=1.4, # 80 degree
)
self.legs.append(leg)
self.joints.append(self.world.CreateJoint(rjd))
lower = self.world.CreateDynamicBody(
position=(lower_x, lower_y),
angle=(-math.pi / 2 + a_i),
fixtures=fixtureDef(shape=polygonShape(box=(LEG_W / 2,
LEG_H / 2)),
density=1.0,
restitution=0.0,
categoryBits=0x0020,
maskBits=0x001))
lower.color1 = (0.6 - i / 10., 0.3 - i / 10., 0.5 - i / 10.)
lower.color2 = (0.4 - i / 10., 0.2 - i / 10., 0.3 - i / 10.)
rjd = revoluteJointDef(
bodyA=leg,
bodyB=lower,
localAnchorA=(0, -LEG_H / 2),
localAnchorB=(0, LEG_H / 2),
enableMotor=True,
enableLimit=True,
maxMotorTorque=MOTORS_TORQUE,
motorSpeed=0.0,
referenceAngle=-1 * math.pi,
lowerAngle=0.35, # 20 degree
upperAngle=3.14, # 180 degree
)
lower.ground_contact = False
self.legs.append(lower)
self.joints.append(self.world.CreateJoint(rjd))
self.drawlist = self.terrain + self.legs + [self.hull]
class LidarCallback(Box2D.b2.rayCastCallback):
def ReportFixture(self, fixture, point, normal, fraction):
if (fixture.filterData.categoryBits & 1) == 0:
return 1
self.p2 = point
self.fraction = fraction
return 0
self.lidar = [LidarCallback() for _ in range(10)]
#self.hull.ApplyForceToCenter((0, 10.0 * (5.0 * (20 / SCALE) ** 2)), True)
#self.legs[0].ApplyForceToCenter((0, 10.0 * 1.0 * LEG_H * LEG_W), True)
#self.legs[1].ApplyForceToCenter((0, 10.0 * 1.0 * LEG_H * LEG_W), True)
#self.legs[2].ApplyForceToCenter((0, 10.0 * 1.0 * LEG_H * LEG_W), True)
#self.legs[3].ApplyForceToCenter((0, 10.0 * 1.0 * LEG_H * LEG_W), True)
return self._step(np.array([0.0, 0.0, 0.0, 0.0]))[0]
def __init__(self,
world,
init_angle,
init_x,
init_y,
color=(0.8, 0.0, 0.0)):
self.world = world
self.hull = self.world.CreateDynamicBody(
position=(init_x, init_y),
angle=init_angle,
fixtures=[
# fixtureDef(shape = polygonShape(vertices=[ (x*SIZE,y*SIZE) for x,y in HULL_POLY1 ]), density=1.0),
# fixtureDef(shape = polygonShape(vertices=[ (x*SIZE,y*SIZE) for x,y in HULL_POLY2 ]), density=1.0),
# fixtureDef(shape = polygonShape(vertices=[ (x*SIZE,y*SIZE) for x,y in HULL_POLY3 ]), density=1.0),
fixtureDef(
shape=polygonShape(vertices=[(x * SIZE, y * SIZE)
for x, y in HULL_POLY4]),
density=1.0)
])
self.hull.color = color
self.wheels = []
self.fuel_spent = 0.0
WHEEL_POLY = [(-WHEEL_W, +WHEEL_R), (+WHEEL_W, +WHEEL_R),
(+WHEEL_W, -WHEEL_R), (-WHEEL_W, -WHEEL_R)]
for wx, wy in WHEELPOS:
front_k = 1.0 if wy > 0 else 1.0
w = self.world.CreateDynamicBody(
position=(init_x + wx * SIZE, init_y + wy * SIZE),
angle=init_angle,
fixtures=fixtureDef(
shape=polygonShape(vertices=[(x * front_k * SIZE,
y * front_k * SIZE)
for x, y in WHEEL_POLY]),
density=0.1,
categoryBits=0x0020,
maskBits=0x001,
restitution=0.0))
w.wheel_rad = front_k * WHEEL_R * SIZE
w.color = WHEEL_COLOR
w.gas = 0.0
w.brake = 0.0
w.steer = 0.0
w.phase = 0.0 # wheel angle
w.omega = 0.0 # angular velocity
w.skid_start = None
w.skid_particle = None
rjd = revoluteJointDef(
bodyA=self.hull,
bodyB=w,
localAnchorA=(wx * SIZE, wy * SIZE),
localAnchorB=(0, 0),
enableMotor=True,
enableLimit=True,
maxMotorTorque=180 * 900 * SIZE * SIZE,
motorSpeed=0,
lowerAngle=-0.4,
upperAngle=+0.4,
)
w.joint = self.world.CreateJoint(rjd)
w.tiles = set()
w.userData = w
self.wheels.append(w)
self.drawlist = self.wheels + [self.hull]
self.particles = []
def reset(self):
self.obj_type = 5
self.timer = 0
self.trigger = 'stop'
self.curr_grab = 1000
self.curr_right = 0
self.consecutive_wait = 0
self.dist_from_obj = 0
self.dist_from_pos = 0
self.colour_list = []
self.obj_type = 5
self.lift_reward = [0.1] * 10
self.max_height = 200
for i_body in range(len(self.body_list)):
if i_body != 0:
self.world.DestroyBody(self.body_list[i_body])
self.body_list = []
self.ground_body = self.world.CreateStaticBody(
position=(160, 0), shapes=polygonShape(box=(160, 7.5)), angle=0)
self.wall_body1 = self.world.CreateStaticBody(
position=(320, 80), shapes=polygonShape(box=(7.5, 320)), angle=0)
self.wall_body2 = self.world.CreateStaticBody(
position=(0, 80), shapes=polygonShape(box=(7.5, 320)), angle=0)
self.wall_body3 = self.world.CreateStaticBody(
position=(100000, 0), shapes=polygonShape(box=(5, 70)), angle=0)
self.roof = self.world.CreateStaticBody(position=(160, 320),
shapes=polygonShape(box=(160,
7.5)),
angle=0)
pos1 = np.random.uniform(15, 130)
pos2 = np.random.uniform(280, 310)
self.arm = self.world.CreateDynamicBody(position=(pos1, 315),
shapes=polygonShape(box=(6,
12)),
angle=0)
self.grab = self.world.CreateDynamicBody(
position=(pos1, pos2),
shapes=polygonShape(box=(6, 6)),
angle=0,
fixedRotation=True,
)
self.grab.CreatePolygonFixture(box=(6, 6), density=0.1, friction=0)
self.stick = self.world.CreateDynamicBody(
position=(pos1, pos2),
shapes=polygonShape(box=(40, 6)),
angle=0,
)
self.stick.CreatePolygonFixture(box=(40, 3), density=0.1, friction=0)
offset = 2.5
DENSITY_2 = 0.1
FRICTION = 10
if self.obj_type == 5:
OBJ_2 = [(-40, 30), (-10, 30), (-10, 20), (-40, 20)]
OBJ_3 = [(-40, -20), (-10, -20), (-10, -30), (-40, -30)]
else:
OBJ_2 = [(-40, 30), (-10, 30), (-10, 10), (-40, 10)]
OBJ_3 = [(-40, -10), (-10, -10), (-10, -30), (-40, -30)]
OBJ_1 = [(-10, 30), (10, 30), (10, -30), (-10, -30)]
OBJ_4 = [(10, 10), (40, 10), (40, -10), (10, -10)]
OBJ_5 = [(-40, -5), (-10, -5), (-10, 5), (-40, 5)]
definedFixturesObj_1 = fixtureDef(
shape=polygonShape(vertices=[(x / SCALE, y / SCALE)
for x, y in OBJ_1]),
density=DENSITY_2,
friction=FRICTION,
restitution=0.0)
definedFixturesObj_2 = fixtureDef(
shape=polygonShape(vertices=[(x / SCALE, y / SCALE)
for x, y in OBJ_2]),
density=DENSITY_2,
friction=FRICTION,
restitution=0.0)
definedFixturesObj_3 = fixtureDef(
shape=polygonShape(vertices=[(x / SCALE, y / SCALE)
for x, y in OBJ_3]),
density=DENSITY_2,
friction=FRICTION,
restitution=0.0)
definedFixturesObj_4 = fixtureDef(
shape=polygonShape(vertices=[(x / SCALE, y / SCALE)
for x, y in OBJ_4]),
density=DENSITY_2,
friction=FRICTION,
restitution=0.0)
definedFixturesObj_5 = fixtureDef(
shape=polygonShape(vertices=[(x / SCALE, y / SCALE)
for x, y in OBJ_5]),
density=DENSITY_2,
friction=FRICTION,
restitution=0.0)
if self.obj_type == 1:
fixturesListObj = [
definedFixturesObj_1, definedFixturesObj_2,
definedFixturesObj_3, definedFixturesObj_4
]
elif self.obj_type == 2:
fixturesListObj = [
definedFixturesObj_1, definedFixturesObj_3,
definedFixturesObj_4
]
elif self.obj_type == 3:
fixturesListObj = [
definedFixturesObj_1, definedFixturesObj_2,
definedFixturesObj_4
]
elif self.obj_type == 4:
fixturesListObj = [
definedFixturesObj_1, definedFixturesObj_2,
definedFixturesObj_3
]
elif self.obj_type == 5:
fixturesListObj = [
definedFixturesObj_1, definedFixturesObj_2,
definedFixturesObj_3, definedFixturesObj_5
]
self.object = self.world.CreateDynamicBody(position=(random.randint(
140, 280), 40),
angle=0,
angularDamping=10,
linearDamping=1,
fixtures=fixturesListObj)
self.object.mass = 1000
self.prev_grab_pos = self.grab.position.copy()
self.h_pj = self.world.CreatePrismaticJoint(
bodyA=self.wall_body2,
bodyB=self.arm,
anchor=(self.wall_body2.worldCenter[0],
self.wall_body2.worldCenter[1]),
axis=(1, 0),
lowerTranslation=-100000,
upperTranslation=1000000,
enableLimit=True,
motorSpeed=0,
maxMotorForce=5000000000000000000000,
enableMotor=True,
)
self.v_pj = self.world.CreatePrismaticJoint(
bodyA=self.arm,
bodyB=self.grab,
anchor=(self.grab.worldCenter[0], self.grab.worldCenter[1]),
axis=(0, 1),
lowerTranslation=-100000,
upperTranslation=0,
enableLimit=True,
motorSpeed=0,
maxMotorForce=5000000000000000000000,
enableMotor=True,
)
self.a_rj = self.world.CreateRevoluteJoint(
bodyA=self.grab,
bodyB=self.stick,
anchor=self.stick.worldCenter,
maxMotorTorque=100000000,
motorSpeed=0,
enableMotor=True,
collideConnected=False,
)
self.colour_list.append((255, 255, 255, 255))
self.colour_list.append((255, 255, 255, 255))
self.colour_list.append((255, 255, 255, 255))
self.colour_list.append((255, 255, 255, 255))
self.colour_list.append((255, 255, 255, 255))
self.colour_list.append((150, 200, 150, 200))
self.colour_list.append((200, 150, 200, 150))
self.colour_list.append((200, 150, 200, 150))
self.body_list = [
self.ground_body, self.wall_body1, self.wall_body2, self.roof,
self.arm, self.grab, self.object, self.stick
]
self.reward_list = [1] * len(self.body_list)
self.update_screen()
self.state1 = get_game_screen(screen)
return self.state1
def _reset(self):
self._destroy()
self.world.contactListener_bug_workaround = ContactDetector(self)
self.world.contactListener = self.world.contactListener_bug_workaround
self.game_over = False
self.prev_shaping = None
self.scroll = 0.0
self.lidar_render = 0
W = VIEWPORT_W/SCALE
H = VIEWPORT_H/SCALE
self._generate_terrain()
self._generate_clouds()
init_x = TERRAIN_STEP*TERRAIN_STARTPAD/2
init_y = TERRAIN_HEIGHT+3*LEG_H
self.body = self.world.CreateDynamicBody(
position = (init_x, init_y),
fixtures = fixtureDef(
shape=polygonShape(vertices=[ (x/SCALE,y/SCALE) for x,y in BODY_SHAPE[-1] ]),
density=0.5,
friction=0.1,
categoryBits=0x0020,
maskBits=0x001, # collide only with ground
restitution=0.0) # 0.99 bouncy
)
for shape in BODY_SHAPE[:-1]:
self.body.CreateFixture(fixtureDef(
shape=polygonShape(vertices=[ (x/SCALE,y/SCALE) for x,y in shape ]),
density=0.5,
friction=0.1,
categoryBits=0x0020,
maskBits=0x001, # collide only with ground
restitution=0.0) # 0.99 bouncy
)
self.body.color1 = (0.9,0.9,0.9)
self.body.color2 = (0.9,0.9,0.9)
self.body.ApplyForceToCenter((self.np_random.uniform(-INITIAL_RANDOM, INITIAL_RANDOM), 0), True)
self.details = []
detailsJoints = []
for color1, color2, shapes in BODY_DETAILS:
detail = self.world.CreateDynamicBody(
position = (init_x,init_y),
fixtures=fixtureDef(
shape=polygonShape(vertices=[ (x/SCALE,y/SCALE) for x,y in shapes[0] ]),
density=0.0001,
categoryBits=0x0020,
maskBits=0x001,
restitution=0.0
)
)
for shape in shapes:
another = detail.CreateFixture(fixtureDef(
shape=polygonShape(vertices=[ (x/SCALE,y/SCALE) for x,y in shape ]),
density=0.0001,
categoryBits=0x0020,
maskBits=0x001,
restitution=0.0
))
detail.color1 = color1
detail.color2 = color2
self.details.append(detail)
joint = weldJointDef(
bodyA=detail,
bodyB=self.body,
localAnchorA=(0,0),
localAnchorB=(0,0),
)
detailsJoints.append(self.world.CreateJoint(joint))
self.legs = []
self.joints = []
for i in [-1,+1]:
leg_upper = self.world.CreateDynamicBody(
position = (init_x, init_y - LEG_H/2 - LEG_DOWN),
angle = (i*0.05),
fixtures = fixtureDef(
shape=polygonShape(vertices=[ (x/SCALE,y/SCALE) for x,y in LEG_UPPER_SHAPE ]),
density=0.5,
restitution=0.0,
categoryBits=0x0020,
maskBits=0x001)
)
leg_upper.color1 = (0.9,0.9,0.9)
leg_upper.color2 = (0.9,0.9,0.9)
rjd = revoluteJointDef(
bodyA=self.body,
bodyB=leg_upper,
localAnchorA=(0, LEG_DOWN),
localAnchorB=(0, LEG_H/2),
enableMotor=True,
enableLimit=True,
maxMotorTorque=MOTORS_TORQUE,
motorSpeed = 2*i,
lowerAngle = -0.8,
upperAngle = 1.1,
)
self.joints.append(self.world.CreateJoint(rjd))
leg_lower = self.world.CreateDynamicBody(
position = (init_x, init_y - LEG_H*3/2 - LEG_DOWN),
angle = (i*0.05),
fixtures = fixtureDef(
shape=polygonShape(vertices=[ (x/SCALE,y/SCALE) for x,y in LEG_LOWER_SHAPE ]),
density=0.5,
restitution=0.0,
categoryBits=0x0020,
maskBits=0x001)
)
leg_lower.color1 = (0.9,0.9,0.9)
leg_lower.color2 = (0.9,0.9,0.9)
rjd = revoluteJointDef(
bodyA=leg_upper,
bodyB=leg_lower,
localAnchorA=(0, -LEG_H/3),
localAnchorB=(0, LEG_H/3),
enableMotor=True,
enableLimit=True,
maxMotorTorque=MOTORS_TORQUE,
motorSpeed = 1,
lowerAngle = -1.6,
upperAngle = -0.1,
)
leg_lower.ground_contact = False
self.joints.append(self.world.CreateJoint(rjd))
detail_upper = self.world.CreateDynamicBody(
position = (init_x, init_y - LEG_H/2 - LEG_DOWN),
fixtures=fixtureDef(
shape=polygonShape(vertices=[ (x/SCALE,y/SCALE) for x,y in LEG_UPPER_DETAILS[0] ]),
density=0.0001,
categoryBits=0x0020,
maskBits=0x001,
restitution=0.0
)
)
for shape in LEG_UPPER_DETAILS[1:]:
another = detail_upper.CreateFixture(fixtureDef(
shape=polygonShape(vertices=[ (x/SCALE,y/SCALE) for x,y in shape ]),
density=0.0001,
categoryBits=0x0020,
maskBits=0x001,
restitution=0.0
))
detail_upper.color1 = (0,0,0)
detail_upper.color2 = (0,0,0)
joint = weldJointDef(
bodyA=detail_upper,
bodyB=leg_upper,
localAnchorA=(0,0),
localAnchorB=(0,0),
)
detailsJoints.append(self.world.CreateJoint(joint))
detail_lower = self.world.CreateDynamicBody(
position = (init_x, init_y - LEG_H/2 - LEG_DOWN),
fixtures=fixtureDef(
shape=polygonShape(vertices=[ (x/SCALE,y/SCALE) for x,y in LEG_LOWER_DETAILS[0] ]),
density=0.0001,
categoryBits=0x0020,
maskBits=0x001,
restitution=0.0
)
)
for shape in LEG_LOWER_DETAILS[1:]:
another = detail_lower.CreateFixture(fixtureDef(
shape=polygonShape(vertices=[ (x/SCALE,y/SCALE) for x,y in shape ]),
density=0.0001,
categoryBits=0x0020,
maskBits=0x001,
restitution=0.0
))
detail_lower.color1 = (0,0,0)
detail_lower.color2 = (0,0,0)
joint = weldJointDef(
bodyA=detail_lower,
bodyB=leg_lower,
localAnchorA=(0,0),
localAnchorB=(0,0),
)
detailsJoints.append(self.world.CreateJoint(joint))
self.details.append(detail_lower)
self.details.append(detail_upper)
self.legs.append(leg_upper)
self.legs.append(leg_lower)
self.joints.extend(detailsJoints)
self.drawlist = self.terrain + self.legs[::-1] + [self.body] + self.details
class LidarCallback(Box2D.b2.rayCastCallback):
def ReportFixture(self, fixture, point, normal, fraction):
if (fixture.filterData.categoryBits & 1) == 0:
return 1
self.p2 = point
self.fraction = fraction
return 0
self.lidar = [LidarCallback() for _ in range(10)]
return self._step(np.array([0,0,0,0]))[0]
def reset(self):
self._destroy()
self.world.contactListener_keepref = ContactDetector(self)
self.world.contactListener = self.world.contactListener_keepref
self.game_over = False
self.prev_shaping = None
self.create_terrain()
initial_y = VIEWPORT_H / SCALE
self.lander = self.world.CreateDynamicBody(
position=(VIEWPORT_W / SCALE / 2, initial_y),
angle=0.0,
fixtures=fixtureDef(
shape=polygonShape(vertices=[(x / SCALE, y / SCALE)
for x, y in LANDER_POLY]),
density=5.0,
friction=0.1,
categoryBits=0x0010,
maskBits=0x001, # collide only with ground
restitution=0.0) # 0.99 bouncy
)
self.lander.color1 = (0.5, 0.4, 0.9)
self.lander.color2 = (0.3, 0.3, 0.5)
self.lander.ApplyForceToCenter(
(self.initial_center_x, self.initial_center_y), True)
self.legs = []
for i in [-1, +1]:
leg = self.world.CreateDynamicBody(
position=(VIEWPORT_W / SCALE / 2 - i * LEG_AWAY / SCALE,
initial_y),
angle=(i * 0.05),
fixtures=fixtureDef(shape=polygonShape(box=(LEG_W / SCALE,
LEG_H / SCALE)),
density=1.0,
restitution=0.0,
categoryBits=0x0020,
maskBits=0x001))
leg.ground_contact = False
leg.color1 = (0.5, 0.4, 0.9)
leg.color2 = (0.3, 0.3, 0.5)
rjd = revoluteJointDef(
bodyA=self.lander,
bodyB=leg,
localAnchorA=(0, 0),
localAnchorB=(i * LEG_AWAY / SCALE, LEG_DOWN / SCALE),
enableMotor=True,
enableLimit=True,
maxMotorTorque=LEG_SPRING_TORQUE,
motorSpeed=+0.3 * i # low enough not to jump back into the sky
)
if i == -1:
rjd.lowerAngle = +0.9 - 0.5 # The most esoteric numbers here, angled legs have freedom to travel within
rjd.upperAngle = +0.9
else:
rjd.lowerAngle = -0.9
rjd.upperAngle = -0.9 + 0.5
leg.joint = self.world.CreateJoint(rjd)
self.legs.append(leg)
self.drawlist = [self.lander] + self.legs
return self.step(np.array([0, 0]) if self.continuous else 0)[0]
def _create_tiles(self):
self.tiles = []
self.tiles_poly = []
w, s = 1, 4 # width and step of tiles:
if self.agent:
TILES = {
'2': [(-ROAD_WIDTH / 2 - (i + 1) * w, ROAD_WIDTH / 2)
for i in range(int(ROAD_WIDTH), int(PLAYFIELD), s)],
'3': [(-ROAD_WIDTH / 2 - (i + 1) * w, -ROAD_WIDTH / 2)
for i in range(int(ROAD_WIDTH), int(PLAYFIELD), s)],
'4': [(-ROAD_WIDTH / 2, -ROAD_WIDTH / 2 - (i + 1) * w)
for i in range(int(ROAD_WIDTH), int(PLAYFIELD), s)],
'5': [(ROAD_WIDTH / 2, -ROAD_WIDTH / 2 - (i + 1) * w)
for i in range(int(ROAD_WIDTH), int(PLAYFIELD), s)],
'6': [(ROAD_WIDTH / 2 + (i + 1) * w, -ROAD_WIDTH / 2)
for i in range(int(ROAD_WIDTH), int(PLAYFIELD), s)],
'7': [(ROAD_WIDTH / 2 + (i + 1) * w, ROAD_WIDTH / 2)
for i in range(int(ROAD_WIDTH), int(PLAYFIELD), s)],
'8': [(ROAD_WIDTH / 2, ROAD_WIDTH / 2 + (i + 1) * w)
for i in range(int(ROAD_WIDTH), int(PLAYFIELD), s)],
'9': [(-ROAD_WIDTH / 2, ROAD_WIDTH / 2 + (i + 1) * w)
for i in range(int(ROAD_WIDTH), int(PLAYFIELD), s)],
'34': [(START_2[0] + math.cos(rad) * SMALL_TURN,
START_2[1] + math.sin(rad) * SMALL_TURN)
for rad in np.linspace(np.pi / 2, 0, 6)],
'36': [(-ROAD_WIDTH + rad, -ROAD_WIDTH // 2)
for rad in np.linspace(0, 2 * ROAD_WIDTH, 6)],
'38': [(START_1[0] + math.cos(rad) * BIG_TURN,
START_1[1] + math.sin(rad) * BIG_TURN)
for rad in np.linspace(-np.pi / 2, 0, 6)] + [TARGET_8],
'56': [(START_3[0] + math.cos(rad) * SMALL_TURN,
START_3[1] + math.sin(rad) * SMALL_TURN)
for rad in np.linspace(np.pi, np.pi / 2, 6)],
'58': [(ROAD_WIDTH // 2, -ROAD_WIDTH + rad)
for rad in np.linspace(0, 2 * ROAD_WIDTH, 6)],
'52': [(START_2[0] + math.cos(rad) * BIG_TURN,
START_2[1] + math.sin(rad) * BIG_TURN)
for rad in np.linspace(0, np.pi / 2, 6)] + [TARGET_2],
'78': [(START_4[0] + math.cos(rad) * SMALL_TURN,
START_4[1] + math.sin(rad) * SMALL_TURN)
for rad in np.linspace(-np.pi / 2, -np.pi, 6)],
'72': [(ROAD_WIDTH - rad, ROAD_WIDTH // 2)
for rad in np.linspace(0, 2 * ROAD_WIDTH, 6)],
'74':
[(START_3[0] + math.cos(rad) * BIG_TURN,
START_3[1] + math.sin(rad) * BIG_TURN)
for rad in np.linspace(np.pi / 2, np.pi, 6)] + [TARGET_4],
'92': [(START_1[0] + math.cos(rad) * SMALL_TURN,
START_1[1] + math.sin(rad) * SMALL_TURN)
for rad in np.linspace(0, -np.pi / 2, 6)],
'94': [(-ROAD_WIDTH // 2, ROAD_WIDTH - rad)
for rad in np.linspace(0, 2 * ROAD_WIDTH, 6)],
'96': [(START_4[0] + math.cos(rad) * BIG_TURN,
START_4[1] + math.sin(rad) * BIG_TURN)
for rad in np.linspace(-np.pi, -np.pi / 2, 6)],
}
self.tiles_poly = TILES[self.car.hull.path[0]] + TILES[
self.car.hull.path] + TILES[self.car.hull.path[1]]
for tile in self.tiles_poly:
t = self.world.CreateStaticBody(
position=tile,
fixtures=fixtureDef(shape=circleShape(radius=0.5),
isSensor=True))
t.road_visited = False
t.name = 'tile'
t.userData = t
self.tiles.append(t)
def create(self,world,TERRAIN_HEIGHT,module=None,node=None,connection_site=None, p_c=None, module_list = None,position = None):
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_height = 0.5
n_width = 0.5
angle = 0
#if p_c is not None:
# parent_angle = p_c.angle
if node is not None:
if node.module_ is not None:
n_height = node.module_.height
n_width = node.module_.width
#angle = node.module_.get_angle(con = node.parent_connection_coordinates)
else:
n_height = module_list[node.type].height
n_width = module_list[node.type].width
#angle = module_list[node.type].get_angle(con = node.parent_connection_coordinates)
elif module is not None:
n_height = module.height
n_width = module.width
angle = module.get_angle(0)
pos = [7,7,0]
if position is not None:
pos = position
if (p_c is not None):
# The local position should be based on how much the module is rotated from the connection site.
# - math.pi to compensate for y directionality of the angle (TODO: should be removed)
local_pos_x =math.cos(connection_site.orientation.x + angle + math.pi/2) * n_height/2
local_pos_y =math.sin(connection_site.orientation.x + angle + math.pi/2) * n_height/2
pos[0] = (local_pos_x) + connection_site.position.x
pos[1] = (local_pos_y) + connection_site.position.y
components = []
joints = []
# below is a quick hack formula. Should check based on lowest point in space.
if (pos[1] - math.sqrt(math.pow(n_width,2) + math.pow(n_height,2)) < TERRAIN_HEIGHT): # TODO CHANGE 5 TO TERRAIN_HEIGHT
if node is not None:
node.component = None
return components,joints
# if connection_site is not None:
# We remove -math.pi/2 since we want the y vector to face in the correct direction
# angle = connection_site.orientation.x -math.pi/2
# 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
# get parent node
par = None
if connection_site:
angle += connection_site.orientation.x
fixture = fixtureDef(
shape=polygonShape(box=(n_width/2, n_height/2)),
density=1.0,
friction=0.1,
restitution=0.0,
categoryBits=0x0020,
maskBits=0x001
)
new_component = world.CreateDynamicBody(
position=(pos[0],pos[1]),
angle = angle ,
fixtures = fixture)
color = (125,125,125)
if node is not None:
color = world.cmap(node.type/len(module_list))
#new_component.color1 = (int(color[0]*255),int(color[1]*255),int(color[2]*255))
#new_component.color2 = (int(color[0]*255),int(color[1]*255),int(color[2]*255))
new_component.color1 = (color[0],color[1],color[2])
new_component.color2 = (color[0],color[1],color[2])
#components.append(new_component)
components.append(new_component)
if node is not None:
node.component = [new_component]
if connection_site is not None:
joint = self.create_joint(world, p_c,new_component,connection_site)
joints.append(joint)
return components,joints
LEG_W, LEG_H = 8/SCALE, 34/SCALE
VIEWPORT_W = 600
VIEWPORT_H = 400
TERRAIN_STEP = 14/SCALE
TERRAIN_LENGTH = 200 # in steps
TERRAIN_HEIGHT = VIEWPORT_H/SCALE/4
TERRAIN_GRASS = 10 # low long are grass spots, in steps
TERRAIN_STARTPAD = 20 # in steps
FRICTION = 2.5
HULL_FD = fixtureDef(
shape=polygonShape(vertices=[ (x/SCALE,y/SCALE) for x,y in HULL_POLY ]),
density=5.0,
friction=0.1,
categoryBits=0x0020,
maskBits=0x001, # collide only with ground
restitution=0.0) # 0.99 bouncy
LEG_FD = fixtureDef(
shape=polygonShape(box=(LEG_W/2, LEG_H/2)),
density=1.0,
restitution=0.0,
categoryBits=0x0020,
maskBits=0x001)
LOWER_FD = fixtureDef(
shape=polygonShape(box=(0.8*LEG_W/2, LEG_H/2)),
density=1.0,
restitution=0.0,
def _reset(self):
self._destroy()
self.game_over = False
self.prev_shaping = None
W = VIEWPORT_W/SCALE
H = VIEWPORT_H/SCALE
# terrain
CHUNKS = 11
height = np.random.uniform(0, H/2, size=(CHUNKS+1,) )
chunk_x = [W/(CHUNKS-1)*i for i in xrange(CHUNKS)]
self.helipad_x1 = chunk_x[CHUNKS//2-1]
self.helipad_x2 = chunk_x[CHUNKS//2+1]
self.helipad_y = H/4
height[CHUNKS//2-2] = self.helipad_y
height[CHUNKS//2-1] = self.helipad_y
height[CHUNKS//2+0] = self.helipad_y
height[CHUNKS//2+1] = self.helipad_y
height[CHUNKS//2+2] = self.helipad_y
smooth_y = [0.33*(height[i-1] + height[i+0] + height[i+1]) for i in xrange(CHUNKS)]
self.moon = self.world.CreateStaticBody( shapes=edgeShape(vertices=[(0, 0), (W, 0)]) )
self.sky_polys = []
for i in xrange(CHUNKS-1):
p1 = (chunk_x[i], smooth_y[i])
p2 = (chunk_x[i+1], smooth_y[i+1])
self.moon.CreateEdgeFixture(
vertices=[p1,p2],
density=0,
friction=0.1)
self.sky_polys.append( [p1, p2, (p2[0],H), (p1[0],H)] )
self.moon.color1 = (0.0,0.0,0.0)
self.moon.color2 = (0.0,0.0,0.0)
initial_y = VIEWPORT_H/SCALE
self.lander = self.world.CreateDynamicBody(
position = (VIEWPORT_W/SCALE/2, initial_y),
angle=0.0,
fixtures = fixtureDef(
shape=polygonShape(vertices=[ (x/SCALE,y/SCALE) for x,y in LANDER_POLY ]),
density=5.0,
friction=0.1,
categoryBits=0x0010,
maskBits=0x001, # collide only with ground
restitution=0.0) # 0.99 bouncy
)
self.lander.color1 = (0.5,0.4,0.9)
self.lander.color2 = (0.3,0.3,0.5)
self.lander.ApplyForceToCenter( (
np.random.uniform(-INITIAL_RANDOM, INITIAL_RANDOM),
np.random.uniform(-INITIAL_RANDOM, INITIAL_RANDOM)
), True)
self.legs = []
for i in [-1,+1]:
leg = self.world.CreateDynamicBody(
position = (VIEWPORT_W/SCALE/2 - i*LEG_AWAY/SCALE, initial_y),
angle = (i*0.05),
fixtures = fixtureDef(
shape=polygonShape(box=(LEG_W/SCALE, LEG_H/SCALE)),
density=1.0,
restitution=0.0,
categoryBits=0x0020,
maskBits=0x001)
)
leg.color1 = (0.5,0.4,0.9)
leg.color2 = (0.3,0.3,0.5)
rjd = revoluteJointDef(
bodyA=self.lander,
bodyB=leg,
localAnchorA=(0, 0),
localAnchorB=(i*LEG_AWAY/SCALE, LEG_DOWN/SCALE),
enableMotor=True,
enableLimit=True,
maxMotorTorque=LEG_SPRING_TORQUE,
motorSpeed=+0.3*i # low enough not to jump back into the sky
)
if i==-1:
rjd.lowerAngle = +0.9 - 0.5 # Yes, the most esoteric numbers here, angles legs have freedom to travel within
rjd.upperAngle = +0.9
else:
rjd.lowerAngle = -0.9
rjd.upperAngle = -0.9 + 0.5
leg.joint = self.world.CreateJoint(rjd)
self.legs.append(leg)
self.drawlist = [self.lander] + self.legs
return self._step(0)[0]
def _reset(self):
self._destroy()
init_x = self.init_x
init_y = self.init_y
self.hull = self.world.CreateDynamicBody(
position=(init_x, init_y),
fixtures=fixtureDef(
shape=polygonShape(vertices=[(x / SCALE, y / SCALE)
for x, y in HULL_POLY]),
density=5.0,
friction=0.1,
categoryBits=0x002,
# maskBits=(0x001 & 0x002), # collide only with ground
restitution=0.0) # 0.99 bouncy
)
self.hull.color1 = (0.5, 0.4, 0.9)
self.hull.color2 = (0.3, 0.3, 0.5)
self.hull.ApplyForceToCenter(
(self.np_random.uniform(-INITIAL_RANDOM, INITIAL_RANDOM), 0), True)
self.legs = []
self.joints = []
for i in [-1, +1]:
leg = self.world.CreateDynamicBody(
position=(init_x, init_y - LEG_H / 2 - LEG_DOWN),
angle=(i * 0.05),
fixtures=fixtureDef(shape=polygonShape(box=(LEG_W / 2,
LEG_H / 2)),
density=1.0,
restitution=0.0,
categoryBits=0x002,
maskBits=0x001) # collide with ground only
)
leg.color1 = (0.6 - i / 10., 0.3 - i / 10., 0.5 - i / 10.)
leg.color2 = (0.4 - i / 10., 0.2 - i / 10., 0.3 - i / 10.)
rjd = revoluteJointDef(
bodyA=self.hull,
bodyB=leg,
localAnchorA=(0, LEG_DOWN),
localAnchorB=(0, LEG_H / 2),
enableMotor=True,
enableLimit=True,
maxMotorTorque=MOTORS_TORQUE,
motorSpeed=i,
lowerAngle=-0.8,
upperAngle=1.1,
)
self.legs.append(leg)
self.joints.append(self.world.CreateJoint(rjd))
lower = self.world.CreateDynamicBody(
position=(init_x, init_y - LEG_H * 3 / 2 - LEG_DOWN),
angle=(i * 0.05),
fixtures=fixtureDef(shape=polygonShape(box=(0.8 * LEG_W / 2,
LEG_H / 2)),
density=1.0,
restitution=0.0,
categoryBits=0x0020,
maskBits=0x001))
lower.color1 = (0.6 - i / 10., 0.3 - i / 10., 0.5 - i / 10.)
lower.color2 = (0.4 - i / 10., 0.2 - i / 10., 0.3 - i / 10.)
rjd = revoluteJointDef(
bodyA=leg,
bodyB=lower,
localAnchorA=(0, -LEG_H / 2),
localAnchorB=(0, LEG_H / 2),
enableMotor=True,
enableLimit=True,
maxMotorTorque=MOTORS_TORQUE,
motorSpeed=1,
lowerAngle=-1.6,
upperAngle=-0.1,
)
lower.ground_contact = False
self.legs.append(lower)
self.joints.append(self.world.CreateJoint(rjd))
self.drawlist = self.legs + [self.hull]
class LidarCallback(Box2D.b2.rayCastCallback):
def ReportFixture(self, fixture, point, normal, fraction):
if (fixture.filterData.categoryBits & 1) == 0:
return -1
self.p2 = point
self.fraction = fraction
return fraction
self.lidar = [LidarCallback() for _ in range(10)]
def _reset(self):
self._destroy()
self.world.contactListener = ContactDetector(self)
self.game_over = False
self.prev_shaping = None
self.scroll = 0.0
self.lidar_render = 0
W = VIEWPORT_W/SCALE
H = VIEWPORT_H/SCALE
self._generate_terrain(self.hardcore)
self._generate_clouds()
init_x = TERRAIN_STEP*TERRAIN_STARTPAD/2
init_y = TERRAIN_HEIGHT+2*LEG_H
self.hull = self.world.CreateDynamicBody(
position = (init_x, init_y),
fixtures = fixtureDef(
shape=polygonShape(vertices=[ (x/SCALE,y/SCALE) for x,y in HULL_POLY ]),
density=5.0,
friction=0.1,
categoryBits=0x0020,
maskBits=0x001, # collide only with ground
restitution=0.0) # 0.99 bouncy
)
self.hull.color1 = (0.5,0.4,0.9)
self.hull.color2 = (0.3,0.3,0.5)
self.hull.ApplyForceToCenter((np.random.uniform(-INITIAL_RANDOM, INITIAL_RANDOM), 0), True)
self.legs = []
self.joints = []
for i in [-1,+1]:
leg = self.world.CreateDynamicBody(
position = (init_x, init_y - LEG_H/2 - LEG_DOWN),
angle = (i*0.05),
fixtures = fixtureDef(
shape=polygonShape(box=(LEG_W/2, LEG_H/2)),
density=1.0,
restitution=0.0,
categoryBits=0x0020,
maskBits=0x001)
)
leg.color1 = (0.6-i/10., 0.3-i/10., 0.5-i/10.)
leg.color2 = (0.4-i/10., 0.2-i/10., 0.3-i/10.)
rjd = revoluteJointDef(
bodyA=self.hull,
bodyB=leg,
localAnchorA=(0, LEG_DOWN),
localAnchorB=(0, LEG_H/2),
enableMotor=True,
enableLimit=True,
maxMotorTorque=MOTORS_TORQUE,
motorSpeed = i,
lowerAngle = -0.8,
upperAngle = 1.1,
)
self.legs.append(leg)
self.joints.append(self.world.CreateJoint(rjd))
lower = self.world.CreateDynamicBody(
position = (init_x, init_y - LEG_H*3/2 - LEG_DOWN),
angle = (i*0.05),
fixtures = fixtureDef(
shape=polygonShape(box=(0.8*LEG_W/2, LEG_H/2)),
density=1.0,
restitution=0.0,
categoryBits=0x0020,
maskBits=0x001)
)
lower.color1 = (0.6-i/10., 0.3-i/10., 0.5-i/10.)
lower.color2 = (0.4-i/10., 0.2-i/10., 0.3-i/10.)
rjd = revoluteJointDef(
bodyA=leg,
bodyB=lower,
localAnchorA=(0, -LEG_H/2),
localAnchorB=(0, LEG_H/2),
enableMotor=True,
enableLimit=True,
maxMotorTorque=MOTORS_TORQUE,
motorSpeed = 1,
lowerAngle = -1.6,
upperAngle = -0.1,
)
lower.ground_contact = False
self.legs.append(lower)
self.joints.append(self.world.CreateJoint(rjd))
self.drawlist = self.terrain + self.legs + [self.hull]
class LidarCallback(Box2D.b2.rayCastCallback):
def ReportFixture(self, fixture, point, normal, fraction):
if (fixture.filterData.categoryBits & 1) == 0:
return 1
self.p2 = point
self.fraction = fraction
return 0
self.lidar = [LidarCallback() for _ in range(10)]
return self._step(np.array([0,0,0,0]))[0]
def _create_track(self):
CHECKPOINTS = 12
# Create checkpoints
checkpoints = []
for c in range(CHECKPOINTS):
alpha = 2*math.pi*c/CHECKPOINTS + self.np_random.uniform(0, 2*math.pi*1/CHECKPOINTS)
rad = self.np_random.uniform(TRACK_RAD/3, TRACK_RAD)
if c==0:
alpha = 0
rad = 1.5*TRACK_RAD
if c==CHECKPOINTS-1:
alpha = 2*math.pi*c/CHECKPOINTS
self.start_alpha = 2*math.pi*(-0.5)/CHECKPOINTS
rad = 1.5*TRACK_RAD
checkpoints.append( (alpha, rad*math.cos(alpha), rad*math.sin(alpha)) )
#print "\n".join(str(h) for h in checkpoints)
#self.road_poly = [ ( # uncomment this to see checkpoints
# [ (tx,ty) for a,tx,ty in checkpoints ],
# (0.7,0.7,0.9) ) ]
self.road = []
# Go from one checkpoint to another to create track
x, y, beta = 1.5*TRACK_RAD, 0, 0
dest_i = 0
laps = 0
track = []
no_freeze = 2500
visited_other_side = False
while 1:
alpha = math.atan2(y, x)
if visited_other_side and alpha > 0:
laps += 1
visited_other_side = False
if alpha < 0:
visited_other_side = True
alpha += 2*math.pi
while True: # Find destination from checkpoints
failed = True
while True:
dest_alpha, dest_x, dest_y = checkpoints[dest_i % len(checkpoints)]
if alpha <= dest_alpha:
failed = False
break
dest_i += 1
if dest_i % len(checkpoints) == 0: break
if not failed: break
alpha -= 2*math.pi
continue
r1x = math.cos(beta)
r1y = math.sin(beta)
p1x = -r1y
p1y = r1x
dest_dx = dest_x - x # vector towards destination
dest_dy = dest_y - y
proj = r1x*dest_dx + r1y*dest_dy # destination vector projected on rad
while beta - alpha > 1.5*math.pi: beta -= 2*math.pi
while beta - alpha < -1.5*math.pi: beta += 2*math.pi
prev_beta = beta
proj *= SCALE
if proj > 0.3: beta -= min(TRACK_TURN_RATE, abs(0.001*proj))
if proj < -0.3: beta += min(TRACK_TURN_RATE, abs(0.001*proj))
x += p1x*TRACK_DETAIL_STEP
y += p1y*TRACK_DETAIL_STEP
track.append( (alpha,prev_beta*0.5 + beta*0.5,x,y) )
if laps > 4: break
no_freeze -= 1
if no_freeze==0: break
#print "\n".join([str(t) for t in enumerate(track)])
# Find closed loop range i1..i2, first loop should be ignored, second is OK
i1, i2 = -1, -1
i = len(track)
while True:
i -= 1
if i==0: return False # Failed
pass_through_start = track[i][0] > self.start_alpha and track[i-1][0] <= self.start_alpha
if pass_through_start and i2==-1:
i2 = i
elif pass_through_start and i1==-1:
i1 = i
break
print("Track generation: %i..%i -> %i-tiles track" % (i1, i2, i2-i1))
assert i1!=-1
assert i2!=-1
track = track[i1:i2-1]
first_beta = track[0][1]
first_perp_x = math.cos(first_beta)
first_perp_y = math.sin(first_beta)
# Length of perpendicular jump to put together head and tail
well_glued_together = np.sqrt(
np.square( first_perp_x*(track[0][2] - track[-1][2]) ) +
np.square( first_perp_y*(track[0][3] - track[-1][3]) ))
if well_glued_together > TRACK_DETAIL_STEP:
return False
# Red-white border on hard turns
border = [False]*len(track)
for i in range(len(track)):
good = True
oneside = 0
for neg in range(BORDER_MIN_COUNT):
beta1 = track[i-neg-0][1]
beta2 = track[i-neg-1][1]
good &= abs(beta1 - beta2) > TRACK_TURN_RATE*0.2
oneside += np.sign(beta1 - beta2)
good &= abs(oneside) == BORDER_MIN_COUNT
border[i] = good
for i in range(len(track)):
for neg in range(BORDER_MIN_COUNT):
border[i-neg] |= border[i]
# Create tiles
for i in range(len(track)):
alpha1, beta1, x1, y1 = track[i]
alpha2, beta2, x2, y2 = track[i-1]
road1_l = (x1 - TRACK_WIDTH*math.cos(beta1), y1 - TRACK_WIDTH*math.sin(beta1))
road1_r = (x1 + TRACK_WIDTH*math.cos(beta1), y1 + TRACK_WIDTH*math.sin(beta1))
road2_l = (x2 - TRACK_WIDTH*math.cos(beta2), y2 - TRACK_WIDTH*math.sin(beta2))
road2_r = (x2 + TRACK_WIDTH*math.cos(beta2), y2 + TRACK_WIDTH*math.sin(beta2))
t = self.world.CreateStaticBody( fixtures = fixtureDef(
shape=polygonShape(vertices=[road1_l, road1_r, road2_r, road2_l])
))
t.userData = t
c = 0.01*(i%3)
t.color = [ROAD_COLOR[0] + c, ROAD_COLOR[1] + c, ROAD_COLOR[2] + c]
t.road_visited = False
t.road_friction = 1.0
t.fixtures[0].sensor = True
self.road_poly.append(( [road1_l, road1_r, road2_r, road2_l], t.color ))
self.road.append(t)
if border[i]:
side = np.sign(beta2 - beta1)
b1_l = (x1 + side* TRACK_WIDTH *math.cos(beta1), y1 + side* TRACK_WIDTH *math.sin(beta1))
b1_r = (x1 + side*(TRACK_WIDTH+BORDER)*math.cos(beta1), y1 + side*(TRACK_WIDTH+BORDER)*math.sin(beta1))
b2_l = (x2 + side* TRACK_WIDTH *math.cos(beta2), y2 + side* TRACK_WIDTH *math.sin(beta2))
b2_r = (x2 + side*(TRACK_WIDTH+BORDER)*math.cos(beta2), y2 + side*(TRACK_WIDTH+BORDER)*math.sin(beta2))
self.road_poly.append(( [b1_l, b1_r, b2_r, b2_l], (1,1,1) if i%2==0 else (1,0,0) ))
self.track = track
return True
def _reset(self):
self._destroy()
self.world.contactListener_keepref = ContactDetector(self)
self.world.contactListener = self.world.contactListener_keepref
self.game_over = False
self.prev_shaping = None
W = VIEWPORT_W / SCALE
H = VIEWPORT_H / SCALE
# create the sea surface into which the flacon might draw (with no collision)
f = fixtureDef(shape=polygonShape(box=(W, SEA_LEVEL), radius=0.0),
density=0.5,
friction=0.03)
self.sea_surface = self.world.CreateStaticBody(position=(0, SEA_LEVEL),
angle=0,
fixtures=f)
# Create the floating drone ship
f = fixtureDef(shape=polygonShape(box=(DRONE_SHIP_W, DRONE_SHIP_H),
radius=0.0),
density=0.4,
friction=0.05,
categoryBits=0x0020,
maskBits=0x001) #, userData=self.logo_img)
self.floating_drone_ship = self.world.CreateDynamicBody(
position=(DRONE_SHIP_W / SCALE, SEA_LEVEL),
angle=0,
linearDamping=0.7,
angularDamping=0.3,
fixtures=f)
self.floating_drone_ship.color1 = (0.1, 0.1, 0.1)
self.floating_drone_ship.color2 = (0, 0, 0)
self.sea_surface.color1 = (0.5, 0.4, 0.9)
self.sea_surface.color2 = (0.3, 0.3, 0.5)
initial_y = VIEWPORT_H / SCALE
# create the falcon lander
self.falcon_rocket = self.world.CreateDynamicBody(
position=(VIEWPORT_W / SCALE / 2, initial_y),
angle=0.0,
fixtures=fixtureDef(
shape=polygonShape(vertices=[(x / SCALE, y / SCALE)
for x, y in FALCON_POLY]),
density=5.0, # 5.0
friction=0.1,
categoryBits=0x001,
maskBits=0x0020, # collide only with floating_drone_ship
restitution=0.0) #, userData=self.logo_img) # 0.99 bouncy
)
self.falcon_rocket.color1 = (1.0, 1.0, 1.0)
self.falcon_rocket.color2 = (0, 0, 0)
self.falcon_rocket.ApplyForceToCenter(
(self.np_random.uniform(-INITIAL_RANDOM, INITIAL_RANDOM),
self.np_random.uniform(-INITIAL_RANDOM, INITIAL_RANDOM)), True)
# create the legs of the falcon rocket
self.legs = []
for i in [-1, +1]:
leg = self.world.CreateDynamicBody(
position=(VIEWPORT_W / SCALE / 2 - i * LEG_AWAY / SCALE,
initial_y),
angle=(i * 0.05),
fixtures=fixtureDef(shape=polygonShape(box=(LEG_W / SCALE,
LEG_H / SCALE)),
density=1.0,
restitution=0.0,
categoryBits=0x001,
maskBits=0x0020))
leg.ground_contact = False
leg.color1 = (0, 0, 0)
leg.color2 = (0, 0, 0)
rjd = revoluteJointDef(
bodyA=self.falcon_rocket,
bodyB=leg,
localAnchorA=(0, 0),
localAnchorB=(i * LEG_AWAY / SCALE, LEG_DOWN / SCALE),
enableMotor=True,
enableLimit=True,
maxMotorTorque=LEG_SPRING_TORQUE,
motorSpeed=+0.3 * i # low enough not to jump back into the sky
)
if i == -1:
rjd.lowerAngle = +0.9 - 0.5 # Yes, the most esoteric numbers here, angles legs have freedom to travel within
rjd.upperAngle = +0.9
else:
rjd.lowerAngle = -0.9
rjd.upperAngle = -0.9 + 0.5
leg.joint = self.world.CreateJoint(rjd)
self.legs.append(leg)
self.drawlist = [self.falcon_rocket] + self.legs + [
self.floating_drone_ship
] + [self.sea_surface]
return self._step(np.array([0, 0]) if self.continuous else 0)[0]
def reset(self):
self._destroy()
self.world.contactListener_keepref = ContactDetector(self)
self.world.contactListener = self.world.contactListener_keepref
self.game_over = False
self.prev_shaping = None
W = VIEWPORT_W / SCALE
H = VIEWPORT_H / SCALE
# terrain
CHUNKS = 11
height = self.np_random.uniform(0, H / 2, size=(CHUNKS + 1, ))
chunk_x = [W / (CHUNKS - 1) * i for i in range(CHUNKS)]
self.helipad_x1 = chunk_x[CHUNKS // 2 - 1]
self.helipad_x2 = chunk_x[CHUNKS // 2 + 1]
self.helipad_y = H / 4
height[CHUNKS // 2 - 2] = self.helipad_y
height[CHUNKS // 2 - 1] = self.helipad_y
height[CHUNKS // 2 + 0] = self.helipad_y
height[CHUNKS // 2 + 1] = self.helipad_y
height[CHUNKS // 2 + 2] = self.helipad_y
smooth_y = [
0.33 * (height[i - 1] + height[i + 0] + height[i + 1])
for i in range(CHUNKS)
]
self.moon = self.world.CreateStaticBody(shapes=edgeShape(
vertices=[(0, 0), (W, 0)]))
self.sky_polys = []
for i in range(CHUNKS - 1):
p1 = (chunk_x[i], smooth_y[i])
p2 = (chunk_x[i + 1], smooth_y[i + 1])
self.moon.CreateEdgeFixture(vertices=[p1, p2],
density=0,
friction=0.1)
self.sky_polys.append([p1, p2, (p2[0], H), (p1[0], H)])
self.moon.color1 = (0.0, 0.0, 0.0)
self.moon.color2 = (0.0, 0.0, 0.0)
initial_y = VIEWPORT_H / SCALE
self.lander = self.world.CreateDynamicBody(
position=(VIEWPORT_W / SCALE / 2, initial_y),
angle=0.0,
fixtures=fixtureDef(
shape=polygonShape(vertices=[(x / SCALE, y / SCALE)
for x, y in LANDER_POLY]),
density=5.0,
friction=0.1,
categoryBits=0x0010,
maskBits=0x001, # collide only with ground
restitution=0.0) # 0.99 bouncy
)
self.lander.color1 = (0.5, 0.4, 0.9)
self.lander.color2 = (0.3, 0.3, 0.5)
self.lander.ApplyForceToCenter(
(self.np_random.uniform(-INITIAL_RANDOM, INITIAL_RANDOM),
self.np_random.uniform(-INITIAL_RANDOM, INITIAL_RANDOM)), True)
self.legs = []
for i in [-1, +1]:
leg = self.world.CreateDynamicBody(
position=(VIEWPORT_W / SCALE / 2 - i * LEG_AWAY / SCALE,
initial_y),
angle=(i * 0.05),
fixtures=fixtureDef(shape=polygonShape(box=(LEG_W / SCALE,
LEG_H / SCALE)),
density=1.0,
restitution=0.0,
categoryBits=0x0020,
maskBits=0x001))
leg.ground_contact = False
leg.color1 = (0.5, 0.4, 0.9)
leg.color2 = (0.3, 0.3, 0.5)
rjd = revoluteJointDef(
bodyA=self.lander,
bodyB=leg,
localAnchorA=(0, 0),
localAnchorB=(i * LEG_AWAY / SCALE, LEG_DOWN / SCALE),
enableMotor=True,
enableLimit=True,
maxMotorTorque=LEG_SPRING_TORQUE,
motorSpeed=+0.3 * i # low enough not to jump back into the sky
)
if i == -1:
rjd.lowerAngle = +0.9 - 0.5 # The most esoteric numbers here, angled legs have freedom to travel within
rjd.upperAngle = +0.9
else:
rjd.lowerAngle = -0.9
rjd.upperAngle = -0.9 + 0.5
leg.joint = self.world.CreateJoint(rjd)
self.legs.append(leg)
self.drawlist = [self.lander] + self.legs
return self.step(np.array([0, 0]) if self.continuous else 0)[0]
def __init__(self):
# Holds the score for the game.
self.score = 0
self.scoreCount = 0
# Dimensions for the parts of the game.
self.trackWidth = 5.0
self.cartWidth = 0.3
self.cartHeight = 0.2
self.cartMass = 1
self.poleMass = 0.1
self.trackThickness = 0.01
self.poleLength = self.cartHeight * 4
self.poleThickness = 0.05
self.force = 0.125
self.end = False
# Size of the screen, and Box2D world.
self.screenSize = (640, 480)
self.worldSize = (float(self.trackWidth), float(self.trackWidth))
# Initialize the Box2D world.
self.world = b2.world(gravity=(0, -5), doSleep=True)
# Used for dynamics update and for graphics update.
self.framesPerSecond = 30
self.velocityIterations = 8
self.positionIterations = 6
# Colours and fonts.
self.trackColor = (100, 100, 100)
self.arrowColor = (50, 50, 250)
self.font = pygame.font.SysFont("monospace", 30)
####################################
# Now build the world.
poleCategory = 0x0002
f = b2.fixtureDef(shape=b2.polygonShape(box=(self.trackWidth / 2,
self.trackThickness / 2)),
friction=0.001,
categoryBits=0x0001,
maskBits=(0xFFFF & ~poleCategory))
self.track = self.world.CreateStaticBody(
position=(0, 0), fixtures=f, userData={'color': self.trackColor})
self.trackTop = self.world.CreateStaticBody(
position=(0, self.trackThickness + self.cartHeight * 1.1),
fixtures=f)
f = b2.fixtureDef(shape=b2.polygonShape(box=(self.trackThickness / 2,
self.trackThickness / 2)),
friction=0.001,
categoryBits=0x0001,
maskBits=(0xFFFF & ~poleCategory))
# Make the cart body and fixture.
f = b2.fixtureDef(shape=b2.polygonShape(box=(self.cartWidth / 2,
self.cartHeight / 2)),
density=self.cartMass,
friction=0.001,
restitution=0.5,
categoryBits=0x0001,
maskBits=(0xFFFF & ~poleCategory))
self.cart = self.world.CreateDynamicBody(
position=(0, self.trackThickness),
fixtures=f,
userData={'color': (0, 0, 0)})
# Make the pole body and fixture. Initially the pole is hanging
# down, which defines the zero angle.
f = b2.fixtureDef(shape=b2.polygonShape(box=(self.poleThickness / 2,
self.poleLength / 2)),
density=self.poleMass,
categoryBits=poleCategory)
self.pole = self.world.CreateDynamicBody(
position=(0, self.trackThickness + self.cartHeight / 2 +
self.poleThickness + self.poleLength / 2),
fixtures=f,
userData={'color': (222, 184, 135)})
# Make the pole-cart joint.
self.world.CreateRevoluteJoint(
bodyA=self.pole,
bodyB=self.cart,
anchor=(0, self.trackThickness + self.cartHeight / 2 +
self.poleThickness))
def _reset(self):
self._destroy()
self.world.contactListener = ContactDetector(self)
self.game_over = False
self.prev_shaping = None
self.scroll = 0.0
self.lidar_render = 0
W = VIEWPORT_W/SCALE
H = VIEWPORT_H/SCALE
self._generate_terrain(self.hardcore)
self._generate_clouds()
init_x = TERRAIN_STEP*TERRAIN_STARTPAD/2
init_y = TERRAIN_HEIGHT+2*LEG_H
self.hull = self.world.CreateDynamicBody(
position = (init_x, init_y),
fixtures = fixtureDef(
shape=polygonShape(vertices=[ (x/SCALE,y/SCALE) for x,y in HULL_POLY ]),
density=5.0,
friction=0.1,
categoryBits=0x0020,
maskBits=0x001, # collide only with ground
restitution=0.0) # 0.99 bouncy
)
self.hull.color1 = (0.5,0.4,0.9)
self.hull.color2 = (0.3,0.3,0.5)
self.hull.ApplyForceToCenter((np.random.uniform(-INITIAL_RANDOM, INITIAL_RANDOM), 0), True)
self.legs = []
self.joints = []
for i in [-1,+1]:
leg = self.world.CreateDynamicBody(
position = (init_x, init_y - LEG_H/2 - LEG_DOWN),
angle = (i*0.05),
fixtures = fixtureDef(
shape=polygonShape(box=(LEG_W/2, LEG_H/2)),
density=1.0,
restitution=0.0,
categoryBits=0x0020,
maskBits=0x001)
)
leg.color1 = (0.6-i/10., 0.3-i/10., 0.5-i/10.)
leg.color2 = (0.4-i/10., 0.2-i/10., 0.3-i/10.)
rjd = revoluteJointDef(
bodyA=self.hull,
bodyB=leg,
localAnchorA=(0, LEG_DOWN),
localAnchorB=(0, LEG_H/2),
enableMotor=True,
enableLimit=True,
maxMotorTorque=MOTORS_TORQUE,
motorSpeed = i,
lowerAngle = -0.8,
upperAngle = 1.1,
)
self.legs.append(leg)
self.joints.append(self.world.CreateJoint(rjd))
lower = self.world.CreateDynamicBody(
position = (init_x, init_y - LEG_H*3/2 - LEG_DOWN),
angle = (i*0.05),
fixtures = fixtureDef(
shape=polygonShape(box=(0.8*LEG_W/2, LEG_H/2)),
density=1.0,
restitution=0.0,
categoryBits=0x0020,
maskBits=0x001)
)
lower.color1 = (0.6-i/10., 0.3-i/10., 0.5-i/10.)
lower.color2 = (0.4-i/10., 0.2-i/10., 0.3-i/10.)
rjd = revoluteJointDef(
bodyA=leg,
bodyB=lower,
localAnchorA=(0, -LEG_H/2),
localAnchorB=(0, LEG_H/2),
enableMotor=True,
enableLimit=True,
maxMotorTorque=MOTORS_TORQUE,
motorSpeed = 1,
lowerAngle = -1.6,
upperAngle = -0.1,
)
lower.ground_contact = False
self.legs.append(lower)
self.joints.append(self.world.CreateJoint(rjd))
self.drawlist = self.terrain + self.legs + [self.hull]
class LidarCallback(Box2D.b2.rayCastCallback):
def ReportFixture(self, fixture, point, normal, fraction):
if (fixture.filterData.categoryBits & 1) == 0:
return 1
self.p2 = point
self.fraction = fraction
return 0
self.lidar = [LidarCallback() for _ in range(10)]
return self._step(np.array([0,0,0,0]))[0]
def __init__(self,
world,
init_coord,
penalty_sec=set(),
color=None,
bot=False):
""" Constructor to define Car.
Parameters
----------
world : Box2D World
init_coord : tuple
(angle, x, y)
penalty_sec : set
Numbers from 2..9 which define sections where car can't be
so penalty can be assigned
color : tuple
Selfexplanatory
"""
init_angle, init_x, init_y = init_coord
SENSOR = SENSOR_BOT if bot else SENSOR_SHAPE
self.world = world
# # make two sensor dots close and far...
# additional_fixture = [fixtureDef(shape=polygonShape(vertices=[(x*SIZE, y*SIZE) for x, y in SENSOR_ADD]),
# isSensor=True, userData='sensor')] if bot else []
self.hull = self.world.CreateDynamicBody(
position=(init_x, init_y),
angle=init_angle,
fixtures=[
fixtureDef(
shape=polygonShape(vertices=[(x * SIZE, y * SIZE)
for x, y in HULL_POLY4]),
density=1.0,
userData='body'),
fixtureDef(shape=polygonShape(vertices=[(x * SIZE, y * SIZE)
for x, y in SENSOR]),
isSensor=True,
userData='sensor')
]) # + additional_fixture)
self.hull.color = color or ((0.2, 0.8, 1) if bot else (0.8, 0.0, 0.0))
self.hull.name = 'bot_car' if bot else 'car'
self.hull.cross_time = float('inf')
self.hull.stop = False
self.hull.collision = False
self.hull.penalty = False
self.hull.penalty_sec = penalty_sec
self.hull.path = ''
self.hull.userData = self.hull
self.wheels = []
self.fuel_spent = 0.0
WHEEL_POLY = [(-WHEEL_W, +WHEEL_R), (+WHEEL_W, +WHEEL_R),
(+WHEEL_W, -WHEEL_R), (-WHEEL_W, -WHEEL_R)]
for wx, wy in WHEELPOS:
front_k = 1.0 if wy > 0 else 1.0
w = self.world.CreateDynamicBody(
position=(init_x + wx * SIZE, init_y + wy * SIZE),
angle=init_angle,
fixtures=fixtureDef(
shape=polygonShape(vertices=[(x * front_k * SIZE,
y * front_k * SIZE)
for x, y in WHEEL_POLY]),
density=0.1,
categoryBits=0x0020,
maskBits=0x001,
restitution=0.0))
w.wheel_rad = front_k * WHEEL_R * SIZE
w.color = WHEEL_COLOR
w.gas = 0.0
w.brake = 0.0
w.steer = 0.0
w.phase = 0.0 # wheel angle
w.omega = 0.0 # angular velocity
rjd = revoluteJointDef(
bodyA=self.hull,
bodyB=w,
localAnchorA=(wx * SIZE, wy * SIZE),
localAnchorB=(0, 0),
enableMotor=True,
enableLimit=True,
maxMotorTorque=180 * 900 * SIZE * SIZE,
motorSpeed=0,
lowerAngle=-0.4,
upperAngle=+0.4,
)
w.joint = self.world.CreateJoint(rjd)
w.tiles = set()
w.name = 'wheel'
w.collision = False
w.penalty = False
w.penalty_sec = penalty_sec
w.userData = w
self.wheels.append(w)
self.drawlist = self.wheels + [self.hull]
self.target = (0, 0)
def _generate_terrain(self, hardcore):
GRASS, STUMP, STAIRS, PIT, _STATES_ = range(5)
state = GRASS
velocity = 0.0
y = TERRAIN_HEIGHT
counter = TERRAIN_STARTPAD
oneshot = False
self.terrain = []
self.terrain_x = []
self.terrain_y = []
for i in range(TERRAIN_LENGTH):
x = i*TERRAIN_STEP
self.terrain_x.append(x)
if state==GRASS and not oneshot:
velocity = 0.8*velocity + 0.01*np.sign(TERRAIN_HEIGHT - y)
if i > TERRAIN_STARTPAD: velocity += np.random.uniform(-1, 1)/SCALE #1
y += velocity
elif state==PIT and oneshot:
counter = np.random.randint(3, 5)
poly = [
(x, y),
(x+TERRAIN_STEP, y),
(x+TERRAIN_STEP, y-4*TERRAIN_STEP),
(x, y-4*TERRAIN_STEP),
]
t = self.world.CreateStaticBody(
fixtures = fixtureDef(
shape=polygonShape(vertices=poly),
friction = FRICTION
))
t.color1, t.color2 = (1,1,1), (0.6,0.6,0.6)
self.terrain.append(t)
t = self.world.CreateStaticBody(
fixtures = fixtureDef(
shape=polygonShape(vertices=[(p[0]+TERRAIN_STEP*counter,p[1]) for p in poly]),
friction = FRICTION
))
t.color1, t.color2 = (1,1,1), (0.6,0.6,0.6)
self.terrain.append(t)
counter += 2
original_y = y
elif state==PIT and not oneshot:
y = original_y
if counter > 1:
y -= 4*TERRAIN_STEP
elif state==STUMP and oneshot:
counter = np.random.randint(1, 3)
poly = [
(x, y),
(x+counter*TERRAIN_STEP, y),
(x+counter*TERRAIN_STEP, y+counter*TERRAIN_STEP),
(x, y+counter*TERRAIN_STEP),
]
t = self.world.CreateStaticBody(
fixtures = fixtureDef(
shape=polygonShape(vertices=poly),
friction = FRICTION
))
t.color1, t.color2 = (1,1,1), (0.6,0.6,0.6)
self.terrain.append(t)
elif state==STAIRS and oneshot:
stair_height = +1 if np.random.ranf() > 0.5 else -1
stair_width = np.random.randint(4, 5)
stair_steps = np.random.randint(3, 5)
original_y = y
for s in range(stair_steps):
poly = [
(x+( s*stair_width)*TERRAIN_STEP, y+( s*stair_height)*TERRAIN_STEP),
(x+((1+s)*stair_width)*TERRAIN_STEP, y+( s*stair_height)*TERRAIN_STEP),
(x+((1+s)*stair_width)*TERRAIN_STEP, y+(-1+s*stair_height)*TERRAIN_STEP),
(x+( s*stair_width)*TERRAIN_STEP, y+(-1+s*stair_height)*TERRAIN_STEP),
]
t = self.world.CreateStaticBody(
fixtures = fixtureDef(
shape=polygonShape(vertices=poly),
friction = FRICTION
))
t.color1, t.color2 = (1,1,1), (0.6,0.6,0.6)
self.terrain.append(t)
counter = stair_steps*stair_width
elif state==STAIRS and not oneshot:
s = stair_steps*stair_width - counter - stair_height
n = s/stair_width
y = original_y + (n*stair_height)*TERRAIN_STEP
oneshot = False
self.terrain_y.append(y)
counter -= 1
if counter==0:
counter = np.random.randint(TERRAIN_GRASS/2, TERRAIN_GRASS)
if state==GRASS and hardcore:
state = np.random.randint(1, _STATES_)
oneshot = True
else:
state = GRASS
oneshot = True
self.terrain_poly = []
for i in range(TERRAIN_LENGTH-1):
poly = [
(self.terrain_x[i], self.terrain_y[i]),
(self.terrain_x[i+1], self.terrain_y[i+1])
]
t = self.world.CreateStaticBody(
fixtures = fixtureDef(
shape=edgeShape(vertices=poly),
friction = FRICTION,
categoryBits=0x0001,
))
color = (0.3, 1.0 if i%2==0 else 0.8, 0.3)
t.color1 = color
t.color2 = color
self.terrain.append(t)
color = (0.4, 0.6, 0.3)
poly += [ (poly[1][0], 0), (poly[0][0], 0) ]
self.terrain_poly.append( (poly, color) )
self.terrain.reverse()
def draw(self, world, init_x, init_y, force_to_center):
HULL_FIXTURES = [
fixtureDef(
shape=polygonShape(vertices=[(x / self.SCALE, y / self.SCALE) for x, y in polygon]),
density=5.0,
friction=0.1,
categoryBits=0x20,
maskBits=0x000F) # 0.99 bouncy
for polygon in HULL_POLYGONS
]
LEG_FD = fixtureDef(
shape=polygonShape(box=(self.LEG_W / 2, self.LEG_H / 2)),
density=1.0,
restitution=0.0,
categoryBits=0x20,
maskBits=0x000F)
LOWER_FD = fixtureDef(
shape=polygonShape(box=(0.8 * self.LEG_W / 2, self.LEG_H / 2)),
density=1.0,
restitution=0.0,
categoryBits=0x20,
maskBits=0x000F)
hull = world.CreateDynamicBody(
position=(init_x, init_y),
fixtures=HULL_FIXTURES
)
hull.color1 = (0.5, 0.4, 0.9)
hull.color2 = (0.3, 0.3, 0.5)
hull.ApplyForceToCenter((force_to_center, 0), True)
hull.userData = CustomBodyUserData(True, is_contact_critical=self.reset_on_hull_critical_contact, name="hull")
self.body_parts.append(hull)
self.reference_head_object = hull
for i in [-1, +1]:
leg = world.CreateDynamicBody(
position=(init_x, init_y - self.LEG_H / 2 - self.LEG_DOWN),
#angle=(i * 0.05),
fixtures=LEG_FD
)
leg.color1 = (0.6 - i / 10., 0.3 - i / 10., 0.5 - i / 10.)
leg.color2 = (0.4 - i / 10., 0.2 - i / 10., 0.3 - i / 10.)
rjd = revoluteJointDef(
bodyA=hull,
bodyB=leg,
anchor=(init_x, init_y - self.LEG_DOWN),
enableMotor=True,
enableLimit=True,
maxMotorTorque=self.MOTORS_TORQUE,
motorSpeed=i,
lowerAngle=-0.8,
upperAngle=1.1,
)
leg.userData = CustomBodyUserData(False, name="leg")
self.body_parts.append(leg)
joint_motor = world.CreateJoint(rjd)
joint_motor.userData = CustomMotorUserData(SPEED_HIP, False)
self.motors.append(joint_motor)
lower = world.CreateDynamicBody(
position=(init_x, init_y - self.LEG_H * 3 / 2 - self.LEG_DOWN),
#angle=(i * 0.05),
fixtures=LOWER_FD
)
lower.color1 = (0.6 - i / 10., 0.3 - i / 10., 0.5 - i / 10.)
lower.color2 = (0.4 - i / 10., 0.2 - i / 10., 0.3 - i / 10.)
rjd = revoluteJointDef(
bodyA=leg,
bodyB=lower,
anchor=(init_x, init_y - self.LEG_DOWN - self.LEG_H),
enableMotor=True,
enableLimit=True,
maxMotorTorque=self.MOTORS_TORQUE,
motorSpeed=1,
lowerAngle=-1.6,
upperAngle=-0.1,
)
lower.userData = CustomBodyUserData(True, name="lower")
self.body_parts.append(lower)
joint_motor = world.CreateJoint(rjd)
joint_motor.userData = CustomMotorUserData(
SPEED_KNEE,
True,
contact_body=lower,
angle_correction=1.0)
self.motors.append(joint_motor)
def _create_track(self):
CHECKPOINTS = 12
# Create checkpoints
checkpoints = []
for c in range(CHECKPOINTS):
alpha = 2*math.pi*c/CHECKPOINTS + self.np_random.uniform(0, 2*math.pi*1/CHECKPOINTS)
rad = self.np_random.uniform(TRACK_RAD/3, TRACK_RAD)
if c==0:
alpha = 0
rad = 1.5*TRACK_RAD
if c==CHECKPOINTS-1:
alpha = 2*math.pi*c/CHECKPOINTS
self.start_alpha = 2*math.pi*(-0.5)/CHECKPOINTS
rad = 1.5*TRACK_RAD
checkpoints.append( (alpha, rad*math.cos(alpha), rad*math.sin(alpha)) )
#print "\n".join(str(h) for h in checkpoints)
#self.road_poly = [ ( # uncomment this to see checkpoints
# [ (tx,ty) for a,tx,ty in checkpoints ],
# (0.7,0.7,0.9) ) ]
self.road = []
# Go from one checkpoint to another to create track
x, y, beta = 1.5*TRACK_RAD, 0, 0
dest_i = 0
laps = 0
track = []
no_freeze = 2500
visited_other_side = False
while 1:
alpha = math.atan2(y, x)
if visited_other_side and alpha > 0:
laps += 1
visited_other_side = False
if alpha < 0:
visited_other_side = True
alpha += 2*math.pi
while True: # Find destination from checkpoints
failed = True
while True:
dest_alpha, dest_x, dest_y = checkpoints[dest_i % len(checkpoints)]
if alpha <= dest_alpha:
failed = False
break
dest_i += 1
if dest_i % len(checkpoints) == 0: break
if not failed: break
alpha -= 2*math.pi
continue
r1x = math.cos(beta)
r1y = math.sin(beta)
p1x = -r1y
p1y = r1x
dest_dx = dest_x - x # vector towards destination
dest_dy = dest_y - y
proj = r1x*dest_dx + r1y*dest_dy # destination vector projected on rad
while beta - alpha > 1.5*math.pi: beta -= 2*math.pi
while beta - alpha < -1.5*math.pi: beta += 2*math.pi
prev_beta = beta
proj *= SCALE
if proj > 0.3: beta -= min(TRACK_TURN_RATE, abs(0.001*proj))
if proj < -0.3: beta += min(TRACK_TURN_RATE, abs(0.001*proj))
x += p1x*TRACK_DETAIL_STEP
y += p1y*TRACK_DETAIL_STEP
track.append( (alpha,prev_beta*0.5 + beta*0.5,x,y) )
if laps > 4: break
no_freeze -= 1
if no_freeze==0: break
#print "\n".join([str(t) for t in enumerate(track)])
# Find closed loop range i1..i2, first loop should be ignored, second is OK
i1, i2 = -1, -1
i = len(track)
while True:
i -= 1
if i==0: return False # Failed
pass_through_start = track[i][0] > self.start_alpha and track[i-1][0] <= self.start_alpha
if pass_through_start and i2==-1:
i2 = i
elif pass_through_start and i1==-1:
i1 = i
break
if self.verbose == 1:
print("Track generation: %i..%i -> %i-tiles track" % (i1, i2, i2-i1))
assert i1!=-1
assert i2!=-1
track = track[i1:i2-1]
first_beta = track[0][1]
first_perp_x = math.cos(first_beta)
first_perp_y = math.sin(first_beta)
# Length of perpendicular jump to put together head and tail
well_glued_together = np.sqrt(
np.square( first_perp_x*(track[0][2] - track[-1][2]) ) +
np.square( first_perp_y*(track[0][3] - track[-1][3]) ))
if well_glued_together > TRACK_DETAIL_STEP:
return False
# Red-white border on hard turns
border = [False]*len(track)
for i in range(len(track)):
good = True
oneside = 0
for neg in range(BORDER_MIN_COUNT):
beta1 = track[i-neg-0][1]
beta2 = track[i-neg-1][1]
good &= abs(beta1 - beta2) > TRACK_TURN_RATE*0.2
oneside += np.sign(beta1 - beta2)
good &= abs(oneside) == BORDER_MIN_COUNT
border[i] = good
for i in range(len(track)):
for neg in range(BORDER_MIN_COUNT):
border[i-neg] |= border[i]
# Create tiles
for i in range(len(track)):
alpha1, beta1, x1, y1 = track[i]
alpha2, beta2, x2, y2 = track[i-1]
road1_l = (x1 - TRACK_WIDTH*math.cos(beta1), y1 - TRACK_WIDTH*math.sin(beta1))
road1_r = (x1 + TRACK_WIDTH*math.cos(beta1), y1 + TRACK_WIDTH*math.sin(beta1))
road2_l = (x2 - TRACK_WIDTH*math.cos(beta2), y2 - TRACK_WIDTH*math.sin(beta2))
road2_r = (x2 + TRACK_WIDTH*math.cos(beta2), y2 + TRACK_WIDTH*math.sin(beta2))
t = self.world.CreateStaticBody( fixtures = fixtureDef(
shape=polygonShape(vertices=[road1_l, road1_r, road2_r, road2_l])
))
t.userData = t
c = 0.01*(i%3)
t.color = [ROAD_COLOR[0] + c, ROAD_COLOR[1] + c, ROAD_COLOR[2] + c]
t.road_visited = False
t.road_friction = 1.0
t.fixtures[0].sensor = True
self.road_poly.append(( [road1_l, road1_r, road2_r, road2_l], t.color ))
self.road.append(t)
if border[i]:
side = np.sign(beta2 - beta1)
b1_l = (x1 + side* TRACK_WIDTH *math.cos(beta1), y1 + side* TRACK_WIDTH *math.sin(beta1))
b1_r = (x1 + side*(TRACK_WIDTH+BORDER)*math.cos(beta1), y1 + side*(TRACK_WIDTH+BORDER)*math.sin(beta1))
b2_l = (x2 + side* TRACK_WIDTH *math.cos(beta2), y2 + side* TRACK_WIDTH *math.sin(beta2))
b2_r = (x2 + side*(TRACK_WIDTH+BORDER)*math.cos(beta2), y2 + side*(TRACK_WIDTH+BORDER)*math.sin(beta2))
self.road_poly.append(( [b1_l, b1_r, b2_r, b2_l], (1,1,1) if i%2==0 else (1,0,0) ))
self.track = track
return True
def draw(self, world, init_x, init_y, force_to_center):
init_y = init_y + 1
#### HULL ####
HULL_FD = fixtureDef(
shape=polygonShape(vertices=[(x / self.SCALE, y / self.SCALE)
for x, y in HULL_POLYGONS]),
density=self.DENSITY,
friction=0.1,
categoryBits=0x20,
maskBits=0x000F) # 0.99 bouncy
hull = world.CreateDynamicBody(position=(init_x, init_y),
fixtures=HULL_FD)
hull.color1 = (0.5, 0.4, 0.9)
hull.color2 = (0.3, 0.3, 0.5)
# hull.ApplyForceToCenter((force_to_center, 0), True)
hull.userData = CustomBodyUserData(True,
is_contact_critical=False,
name="head")
self.body_parts.append(hull)
self.reference_head_object = hull
#### P1 ####
body_p1_x = init_x - 35 / 2 / self.SCALE - 16 / 2 / self.SCALE
BODY_P1_FD = fixtureDef(
shape=polygonShape(vertices=[(x / self.SCALE, y / self.SCALE)
for x, y in BODY_P1]),
density=self.DENSITY,
restitution=0.0,
categoryBits=0x20,
maskBits=0x000F)
body_p1 = world.CreateDynamicBody(position=(body_p1_x, init_y),
fixtures=BODY_P1_FD)
body_p1.color1 = (0.5, 0.4, 0.9)
body_p1.color2 = (0.3, 0.3, 0.5)
rjd = revoluteJointDef(
bodyA=hull,
bodyB=body_p1,
anchor=(init_x - 35 / 2 / self.SCALE, init_y),
enableMotor=True,
enableLimit=True,
maxMotorTorque=self.MOTORS_TORQUE,
motorSpeed=1,
lowerAngle=-0.1 * np.pi,
upperAngle=0.2 * np.pi,
)
body_p1.userData = CustomBodyUserData(True, name="body")
self.body_parts.append(body_p1)
joint_motor = world.CreateJoint(rjd)
joint_motor.userData = CustomMotorUserData(SPEED_KNEE,
True,
contact_body=body_p1)
self.motors.append(joint_motor)
#### P2 ####
body_p2_x = body_p1_x - 16 / 2 / self.SCALE - 16 / 2 / self.SCALE
BODY_P2_FD = fixtureDef(
shape=polygonShape(vertices=[(x / self.SCALE, y / self.SCALE)
for x, y in BODY_P2]),
density=self.DENSITY,
restitution=0.0,
categoryBits=0x20,
maskBits=0x000F)
body_p2 = world.CreateDynamicBody(position=(body_p2_x, init_y),
fixtures=BODY_P2_FD)
body_p2.color1 = (0.5, 0.4, 0.9)
body_p2.color2 = (0.3, 0.3, 0.5)
rjd = revoluteJointDef(
bodyA=body_p1,
bodyB=body_p2,
anchor=(body_p1_x - 16 / 2 / self.SCALE, init_y),
enableMotor=True,
enableLimit=True,
maxMotorTorque=self.MOTORS_TORQUE,
motorSpeed=1,
lowerAngle=-0.15 * np.pi,
upperAngle=0.15 * np.pi,
)
body_p2.userData = CustomBodyUserData(True, name="body")
self.body_parts.append(body_p2)
joint_motor = world.CreateJoint(rjd)
joint_motor.userData = CustomMotorUserData(SPEED_KNEE,
True,
contact_body=body_p2)
self.motors.append(joint_motor)
#### P3 ####
body_p3_x = body_p2_x - 16 / 2 / self.SCALE - 8 / 2 / self.SCALE
BODY_P3_FD = fixtureDef(
shape=polygonShape(vertices=[(x / self.SCALE, y / self.SCALE)
for x, y in BODY_P3]),
density=self.DENSITY,
restitution=0.0,
categoryBits=0x20,
maskBits=0x000F)
body_p3 = world.CreateDynamicBody(position=(body_p3_x, init_y),
fixtures=BODY_P3_FD)
body_p3.color1 = (0.5, 0.4, 0.9)
body_p3.color2 = (0.3, 0.3, 0.5)
rjd = revoluteJointDef(
bodyA=body_p2,
bodyB=body_p3,
anchor=(body_p2_x - 16 / 2 / self.SCALE, init_y),
enableMotor=True,
enableLimit=True,
maxMotorTorque=self.MOTORS_TORQUE,
motorSpeed=1,
lowerAngle=-0.3 * np.pi,
upperAngle=0.3 * np.pi,
)
body_p3.userData = CustomBodyUserData(True, name="body")
self.body_parts.append(body_p3)
self.tail = body_p3
joint_motor = world.CreateJoint(rjd)
joint_motor.userData = CustomMotorUserData(SPEED_KNEE,
True,
contact_body=body_p3)
self.motors.append(joint_motor)
#### FIN ####
FIN_FD = fixtureDef(shape=polygonShape(vertices=[(x / self.SCALE,
y / self.SCALE)
for x, y in FIN]),
density=self.DENSITY,
restitution=0.0,
categoryBits=0x20,
maskBits=0x000F)
fin_positions = [
# [init_x + 35 / 2 / self.SCALE / 2, init_y],
# [init_x - 35 / 2 / self.SCALE / 2, init_y],
[init_x, init_y - 22 / 2 / self.SCALE + 0.2],
# [init_x - 35 / 2 / self.SCALE / 2, init_y - 22 / 2 / self.SCALE + 0.1],
]
fin_angle = -0.2 * np.pi
middle_fin_x_distance = np.sin(fin_angle) * 20 / 2 / self.SCALE
middle_fin_y_distance = np.cos(fin_angle) * 20 / 2 / self.SCALE
for fin_pos in fin_positions:
current_fin_x = fin_pos[0] + middle_fin_x_distance
current_fin_y = fin_pos[1] - middle_fin_y_distance
fin = world.CreateDynamicBody(position=(current_fin_x,
current_fin_y),
fixtures=FIN_FD,
angle=fin_angle)
fin.color1 = (0.5, 0.4, 0.9)
fin.color2 = (0.3, 0.3, 0.5)
rjd = revoluteJointDef(
bodyA=hull,
bodyB=fin,
anchor=(fin_pos[0], fin_pos[1]),
enableMotor=True,
enableLimit=True,
maxMotorTorque=self.MOTORS_TORQUE,
motorSpeed=1,
lowerAngle=-0.3 * np.pi,
upperAngle=0.2 * np.pi,
)
fin.userData = CustomBodyUserData(True, name="fin")
self.body_parts.append(fin)
self.fins.append(fin)
joint_motor = world.CreateJoint(rjd)
joint_motor.userData = CustomMotorUserData(SPEED_KNEE,
True,
contact_body=fin)
self.motors.append(joint_motor)
