def __init__(self, screen_size, gravity=(
0.0, -9.0), ppm=100.0, renderer='pygame'):
""" Init the world with boundaries and gravity, and init colors.
Parameters:
screen_size .. (w, h) -- screen size in pixels [int]
gravity ...... (x, y) in m/s^2 [float] default: (0.0, -9.0)
ppm .......... pixels per meter [float] default: 100.0
renderer ..... which drawing method to use (str) default: 'pygame'
Return: class Elements()
"""
self.set_screenSize(screen_size)
self.set_drawingMethod(renderer)
# Create Subclasses
self.add = add_objects.Add(self)
self.callbacks = callbacks.CallbackHandler(self)
self.camera = camera.Camera(self)
# Gravity + Bodies will sleep on outside
self.gravity = gravity
self.doSleep = True
# Create the World
self.world = box2d.b2World(self.gravity, self.doSleep)
bodyDef = box2d.b2BodyDef()
self.world.groundBody = self.world.CreateBody(bodyDef)
# Init Colors
self.init_colors()
# Set Pixels per Meter
self.ppm = ppm
def __init__(self):
self.count = 1000
self.force = 10
self.robots = {}
self.bullets = []
self.sprites = {}
self.to_destroy = []
halfx = 30
self.ahalfx = 20
halfy = 25
self.ahalfy = 20
gravity = (0, 0)
doSleep = True
self.timeStep = 1.0 / 60.0
self.velIterations = 10
self.posIterations = 8
aabb = box2d.b2AABB()
aabb.lowerBound = (-halfx, -halfy)
aabb.upperBound = (halfx, halfy)
self.w = box2d.b2World(gravity, doSleep)
self.makearena()
def __init__(self, **kw):
super(Framework, self).__init__(**kw)
# Initialize the text display group
self.textGroup = grText(self)
# Load the font and record the screen dimensions
self.font = pyglet.font.load(self.fontname, self.fontsize)
self.screenSize = box2d.b2Vec2(self.width, self.height)
# Box2D Initialization
self.worldAABB = box2d.b2AABB()
self.worldAABB.lowerBound = (-200.0, -100.0)
self.worldAABB.upperBound = ( 200.0, 200.0)
gravity = (0.0, -10.0)
doSleep = True
self.world = box2d.b2World(self.worldAABB, gravity, doSleep)
self.destructionListener = fwDestructionListener()
self.boundaryListener = fwBoundaryListener()
self.contactListener = fwContactListener()
self.debugDraw = fwDebugDraw()
self.debugDraw.surface = self.screen
self.destructionListener.test = self
self.boundaryListener.test = self
self.contactListener.test = self
self.world.SetDestructionListener(self.destructionListener)
self.world.SetBoundaryListener(self.boundaryListener)
self.world.SetContactListener(self.contactListener)
self.world.SetDebugDraw(self.debugDraw)
self._viewCenter = box2d.b2Vec2(0,10.0)
def setup(self):
self.viewer = None
self.world = Box2D.b2World()
self.terrain = None
init_x = TERRAIN_STEP * TERRAIN_STARTPAD / 2
init_y = TERRAIN_HEIGHT + 2 * LEG_H
self.start_x = [
init_x + WALKER_SEPERATION * i * TERRAIN_STEP for i in range(self.n_walkers)
]
self.walkers = [
BipedalWalker(self.world, init_x=sx,
init_y=init_y, seed=self.seed_val)
for sx in self.start_x
]
self.num_agents = len(self.walkers)
self.observation_space = [
agent.observation_space for agent in self.walkers]
self.action_space = [agent.action_space for agent in self.walkers]
self.package_scale = self.n_walkers / 1.75
self.package_length = PACKAGE_LENGTH / SCALE * self.package_scale
self.total_agents = self.n_walkers
self.prev_shaping = np.zeros(self.n_walkers)
self.prev_package_shaping = 0.0
self.terrain_length = int(TERRAIN_LENGTH * self.n_walkers * 1 / 8.)
self.reset()
def __init__(self):
self.count = 1000
self.force = 10
self.tanks = {}
self.bullets = []
self.sprites = {}
self.to_destroy = []
halfx = 30
self.ahalfx = 20
halfy = 25
self.ahalfy = 20
gravity = (0, 0)
doSleep = True
self.timeStep = 1.0 / 60.0
self.velIterations = 10
self.posIterations = 8
aabb = box2d.b2AABB()
aabb.lowerBound = (-halfx, -halfy)
aabb.upperBound = (halfx, halfy)
self.w = box2d.b2World(aabb, gravity, doSleep)
self.w.GetGroundBody().SetUserData({'actor': None})
self.makearena()
def __init__(self, force_ground, scroller):
layer.ScrollableLayer.__init__(self)
self.scroller = scroller
self.force_ground = force_ground
self.b2world = b2.b2World(gravity=(0, -GRAVITY),
contactListener=b2Listener())
self.b2level = self.b2world.CreateStaticBody()
self._create_b2_tile_map(force_ground)
#FROM TILEMAP TESTER
self.camera_pos = [16*25, 16*25]
self.keys = {key.LEFT: False,
key.RIGHT: False,
key.UP: False,
key.DOWN: False}
movable_object.Movable_Object.tilemap = self.force_ground
movable_object.Movable_Object.world = self.b2world
self.unit = Actor(Human)
#print self.unit.cshape
self.unit.move_to(60, 1716)
self.add(self.unit, z=100)
self.unit.do(Brain())
self.cellmap = force_ground
#self.counter = 0
self.path = None
self.counter = 0
self.fr = None
self.schedule(self.update)
def setup_world(self):
self.worldAABB = box2d.b2AABB()
self.worldAABB.lowerBound = (-2000.0, -2000.0)
self.worldAABB.upperBound = (2000.0, 2000.0)
self.gravity = (0.0, -9.81)
doSleep = False
self.world = box2d.b2World(self.worldAABB, self.gravity, doSleep)
def __init__(self, verbose=1):
EzPickle.__init__(self)
self.seed()
self.contactListener_keepref = FrictionDetector(self)
self.world = Box2D.b2World(
(0, 0), contactListener=self.contactListener_keepref)
self.viewer = None
self.invisible_state_window = None
self.invisible_video_window = None
self.road = None
self.grass = []
self.on_grass_idx = set()
self.car = None
self.reward = 0.0
self.prev_reward = 0.0
self.verbose = verbose
self.poly = {'grass': [], 'road': [], 'other': []}
self.action_space = spaces.Box(np.array([-1, 0, 0]),
np.array([+1, +1, +1]),
dtype=np.float32) # steer, gas, brake
self.observation_space = spaces.Box(low=0,
high=255,
shape=(STATE_H, STATE_W, 3),
dtype=np.uint8)
self.timer = 0
def __init__(self, verbose=1):
EzPickle.__init__(self)
self.seed()
self.contactListener_keepref = FrictionDetector(self)
self.world = Box2D.b2World(
(0, 0), contactListener=self.contactListener_keepref)
self.viewer = None
self.invisible_state_window = None
self.invisible_video_window = None
self.road = None
self.car = None
self.reward = 0.0
self.prev_reward = 0.0
self.verbose = verbose
self.fd_tile = fixtureDef(shape=polygonShape(
vertices=[(0, 0), (1, 0), (1, -1), (0, -1)]))
self.action_space = spaces.Box(np.array([-1, 0, 0]),
np.array([+1, +1, +1]),
dtype=np.float32) # steer, gas, brake
self.observation_space = spaces.Box(low=0,
high=255,
shape=(STATE_H, STATE_W, 3),
dtype=np.uint8)
def __init__(self, level_number=0, continuous=True, speed_threshold=1):
self.level_number = level_number
self._seed()
self.viewer = None
self.episode_number = 0
self.world = Box2D.b2World()
self.water = None
self.lander = None
self.engine = None
self.ship = None
self.legs = []
self.state = []
self.continuous = continuous
self.landed = False
self.landed_fraction = []
self.good_landings = 0
self.speed_threshold = speed_threshold
almost_inf = 9999
high = np.array(
[1, 1, 1, 1, 1, 1, 1, almost_inf, almost_inf, almost_inf], dtype=np.float32
)
low = -high
if not VEL_STATE:
high = high[0:7]
low = low[0:7]
self.observation_space = spaces.Box(low, high, dtype=np.float32)
if self.continuous:
self.action_space = spaces.Box(-1, +1, (3,), dtype=np.float32)
else:
self.action_space = spaces.Discrete(7)
self.reset()
def __init__(self):
self.viewer = rendering.Viewer(self.VIEWPORT_W, self.VIEWPORT_H)
self.viewer.set_bounds(0, self.VIEWPORT_W / self.SCALE, 0,
self.VIEWPORT_H / self.SCALE)
self.world = Box2D.b2World()
self.lander = self.world.CreateDynamicBody(fixtures=[
fixtureDef(shape=polygonShape(vertices=[(x / self.SCALE,
y / self.SCALE)
for x, y in poly]),
density=0.0) for poly in [
self.HULL_POLY,
self._leg_poly(-1),
self._leg_poly(+1),
self._motor_poly(+1),
self._motor_poly(-1),
self._blade_poly(+1, -1),
self._blade_poly(+1, +1),
self._blade_poly(-1, -1),
self._blade_poly(-1, +1)
]
])
# By showing props periodically, we can emulate prop rotation
self.props_visible = 0
def __init__(self):
self.seed()
self.contactListener_keepref = FrictionDetector(self)
self.world = Box2D.b2World(
(0, 0), contactListener=self.contactListener_keepref)
self.viewer = None
self.invisible_state_window = None
self.invisible_video_window = None
self.road = None
self.car = None
self.reward = 0.0
self.prev_reward = 0.0
self.action_space = spaces.Box(np.array([-1, 0, 0]),
np.array([+1, +1,
+1])) # steer, gas, brake
self.observation_space = spaces.Box(low=0,
high=255,
shape=(STATE_H, STATE_W, 3),
dtype=np.uint8)
#VBO stuff
self.vertex_vbo_id = gl.GLuint()
self.color_vbo_id = gl.GLuint()
gl.glGenBuffers(1, self.vertex_vbo_id)
gl.glGenBuffers(1, self.color_vbo_id)
self.initialized = 0
def __init__(self, stochasticity=INITIAL_RANDOM):
EzPickle.__init__(self)
self.seed()
self.viewer = None
self.world = Box2D.b2World()
self.moon = None
self.lander = None
self.particles = []
self.stochasticity = stochasticity
self.prev_reward = None
# useful range is -1 .. +1, but spikes can be higher
self.observation_space = spaces.Box(-np.inf, np.inf, shape=(8,), dtype=np.float32)
if self.continuous:
# Action is two floats [main engine, left-right engines].
# Main engine: -1..0 off, 0..+1 throttle from 50% to 100% power. Engine can't work with less than 50% power.
# Left-right: -1.0..-0.5 fire left engine, +0.5..+1.0 fire right engine, -0.5..0.5 off
self.action_space = spaces.Box(-1, +1, (2,), dtype=np.float32)
else:
# Nop, fire left engine, main engine, right engine
self.action_space = spaces.Discrete(4)
self.ignore_reset = False
self.reset()
def __setstate__(self, state):
self.initial_center_x, self.initial_center_y, self.terrain_heights = state
self.seed()
self.viewer = None
self.world = Box2D.b2World()
self.moon = None
self.lander = None
self.particles = []
self.prev_reward = None
# useful range is -1 .. +1, but spikes can be higher
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(8, ),
dtype=np.float64)
if self.continuous:
# Action is two floats [main engine, left-right engines].
# Main engine: -1..0 off, 0..+1 throttle from 50% to 100% power. Engine can't work with less than 50% power.
# Left-right: -1.0..-0.5 fire left engine, +0.5..+1.0 fire right engine, -0.5..0.5 off
self.action_space = spaces.Box(-1, +1, (2, ), dtype=np.float64)
else:
# Nop, fire left engine, main engine, right engine
self.action_space = spaces.Discrete(4)
def __init__(self):
self._seed()
self.viewer = None
self.episode_number = 0
self.maxstep = 2000
self.ypos = 0.95
self.world = Box2D.b2World()
self.water = None
self.lander = None
self.engine = None
self.ship = None
self.legs = []
high = np.array([1, 1, 1, 1, 1, 1, 1, np.inf, np.inf, np.inf],
dtype=np.float32)
low = -high
if not VEL_STATE:
high = high[0:7]
low = low[0:7]
self.observation_space = spaces.Box(low, high, dtype=np.float32)
if CONTINUOUS:
self.action_space = spaces.Box(-1.0, +1.0, (3, ), dtype=np.float32)
else:
self.action_space = spaces.Discrete(7)
self.reset()
def __init__(self, verbose=1):
EzPickle.__init__(self)
self.WHEEL_COLOR = (0.0,0.0,0.0)
self.WHEEL_WHITE = (0.3,0.3,0.3)
self.MUD_COLOR = (0.4,0.4,0.0)
self.HULL_COLOR = (0.9,0.0,0.0)
self.TILE_WHITE_COLOR = (1., 1., 1.)
self.TILE_RED_COLOR = (1., 0., 0.)
self.BACK_COLOR1 = (0., 1., 0.)
self.BACK_COLOR2 = (0., 0.8, 0.2)
self.seed()
self.contactListener_keepref = FrictionDetector(self)
self.world = Box2D.b2World((0,0), contactListener=self.contactListener_keepref)
self.viewer = None
self.invisible_state_window = None
self.invisible_video_window = None
self.road = None
self.car = None
self.reward = 0.0
self.prev_reward = 0.0
self.verbose = verbose
self.fd_tile = fixtureDef(
shape = polygonShape(vertices=
[(0, 0),(1, 0),(1, -1),(0, -1)]))
self.action_space = spaces.Box( np.array([-1,0,0]), np.array([+1,+1,+1]), dtype=np.float32) # steer, gas, brake
self.observation_space = spaces.Box(low=0, high=255, shape=(STATE_H, STATE_W, 3), dtype=np.uint8)
self.road_color = [0.4, 0.4, 0.4]
def __init__(self, verbose=1):
EzPickle.__init__(self)
self.seed_value = 0
self.seed()
self.contactListener_keepref = FrictionDetector(self)
self.world = Box2D.b2World(
(0, 0), contactListener=self.contactListener_keepref)
self.viewer = None
self.invisible_state_window = None
self.invisible_video_window = None
self.road = None
self.car = None
self.reward = 0.0
self.prev_reward = 0.0
self.verbose = verbose
self.wheels_on_road = 0
self.new_step = False
self.sem = 0
self.wheel_reward = 1
self.wheels = {}
self.action_space = spaces.Box(np.array([-1, 0, 0]),
np.array([+1, +1, +1]),
dtype=np.float32) # steer, gas, brake
self.observation_space = spaces.Box(low=0,
high=255,
shape=(STATE_H, STATE_W, 3),
dtype=np.uint8)
def __init__(self):
self._player_maximum_thrust = 2
self._physics_world = Box2D.b2World(gravity=(0,0), doSleep=False, contactListener=ContactDamageInflicter(self))
self._asteroid_shape = Box2D.b2CircleShape()
self._asteroid_shape.radius = ASTEROID_RADIUS
self._asteroid_fixture = Box2D.b2FixtureDef()
self._asteroid_fixture.shape = self._asteroid_shape
self._asteroid_fixture.density = 10
self._asteroid_fixture.restitution = 1
self._asteroid_fixture.friction = 1
self._asteroid_fixture.filter.categoryBits = CollisionFilterCategory.ASTEROID
self._asteroid_fixture.filter.maskBits = CollisionFilterCategory.ASTEROID | CollisionFilterCategory.PLAYER
self._ship_shape = Box2D.b2CircleShape()
self._ship_shape.radius = PLAYER_RADIUS
ship_fixture = Box2D.b2FixtureDef()
ship_fixture.shape = self._ship_shape
ship_fixture.density = 5
ship_fixture.restitution = 1
ship_fixture.friction = 1
ship_fixture.filter.categoryBits = CollisionFilterCategory.PLAYER
ship_fixture.filter.maskBits = CollisionFilterCategory.ASTEROID | CollisionFilterCategory.BORDER
self._player_base_friction = 0.02
self._player_thrust_extra_friction = 0.02
self._player_maximum_turn_thrust = 1
self._thrust_extra_turn_thrust = -0.3
self._base_rotational_friction = 0.1
self._thrust_extra_rotational_friction = 0.05
ship_body_def = Box2D.b2BodyDef()
ship_body_def.position = (
5 + random() * (RIGHT_BORDER_X - 10),
5 + random() * (TOP_BORDER_Y - 10)
)
ship_body_def.angle = random() * pi * 2
ship_body_def.linearVelocity = (0,0)
ship_body_def.linearDamping = self._player_base_friction
ship_body_def.angularVelocity = 0
ship_body_def.angularDamping = self._base_rotational_friction
ship_body_def.fixtures = [ship_fixture]
ship_body_def.type = Box2D.b2_dynamicBody
ship_body_def.allowSleep = False
self._player_ship = self._physics_world.CreateBody(ship_body_def)
self._asteroids = self._create_starting_asteroids()
self._asteroids_to_kill = []
self._asteroid_extra_spawn_accumulator = 0
self._asteroids_avoided_count = 0
self._borders = borders.add_borders(self._physics_world, LEFT_BORDER_X, RIGHT_BORDER_X, BOTTOM_BORDER_Y, TOP_BORDER_Y)
self._asteroid_play_space = asteroid_play_space.add_asteroid_play_space(self._physics_world, LEFT_BORDER_X, RIGHT_BORDER_X, BOTTOM_BORDER_Y, TOP_BORDER_Y)
self.player_current_health = MAX_PLAYER_HEALTH
def __init__(self):
self._seed()
self.viewer = None
self.world = Box2D.b2World()
self.moon = None
self.lander = None
self.particles = []
self.prev_reward = None
high = np.array([np.inf]*8) # useful range is -1 .. +1, but spikes can be higher
self.observation_space = spaces.Box(-high, high)
if self.continuous:
# Action is two floats [main engine, left-right engines].
# Main engine: -1..0 off, 0..+1 throttle from 50% to 100% power. Engine can't work with less than 50% power.
# Left-right: -1.0..-0.5 fire left engine, +0.5..+1.0 fire right engine, -0.5..0.5 off
self.action_space = spaces.Box(-1, +1, (2,))
else:
# Nop, fire left engine, main engine, right engine
self.action_space = spaces.Discrete(4)
self._reset()
def __init__(self, total_episode_steps=1000 ,verbose=1):
EzPickle.__init__(self)
self.seed()
self.contactListener_keepref = FrictionDetector(self)
self.world = Box2D.b2World((0,0), contactListener=self.contactListener_keepref)
self.viewer = None
self.invisible_state_window = None
self.invisible_video_window = None
self.road = None
self.car = None
self.reward = 0.0
self.prev_reward = 0.0
self.verbose = verbose
self.fd_tile = fixtureDef(
shape = polygonShape(vertices=
[(0, 0),(1, 0),(1, -1),(0, -1)]))
# discrete car racer
self.action_space = spaces.Box( np.array([-1,0,0]), np.array([+1,+1,+1]), dtype=np.float32) # steer, gas, brake
# self.action_space = spaces.Discrete(5)
# self.actions = [np.array([-1,0,0], dtype=np.float32),
# np.array([1,0,0], dtype=np.float32),
# np.array([0,1,0], dtype=np.float32),
# np.array([0,0,0.8], dtype=np.float32),
# np.array([0,0,0], dtype=np.float32)] # left right, gas, brake, nothing
self.total_episode_steps = total_episode_steps
self.current_steps = 0
self.observation_space = spaces.Box(low=0, high=255, shape=(STATE_W, STATE_H, 3), dtype=np.uint8)
def __init__(self, hist_len=0, block_high=0.5):
self.seed()
self.viewer = None
self.world = Box2D.b2World()
self.moon = None
self.lander = None
self.particles = []
self.hist_len = hist_len
self.block_high = block_high
self.prev_reward = None
# We assume this env is always partially observable
# if hist_len != 0:
high = np.array([np.inf] * (1 + self.hist_len) * (9 + 2))
t_high = np.array([np.inf] * ((1 + self.hist_len) * (9 + 2) + 9))
self.history = np.zeros([(self.hist_len + 1) * (9 + 2)])
self.observation_space = spaces.Box(-high, high)
# TODO: change the following line into (-t_high, t_high) for guided case
self.total_space = spaces.Box(-high, high)
# We assume this environment is continuous
# Action is two floats [main engine, left-right engines].
# Main engine: -1..0 off, 0..+1 throttle from 50% to 100% power. Engine can't work with less than 50% power.
# Left-right: -1.0..-0.5 fire left engine, +0.5..+1.0 fire right engine, -0.5..0.5 off
self.action_space = spaces.Box(-1, +1, (2, ))
self.prev_obs = None
def __init__(self, verbose=1, **kwargs):
EzPickle.__init__(self)
self.seed()
self.road_color = ROAD_COLOR[:]
self.grass_color = [0.4, 0.8, 0.4, 1]
if 'modification' in kwargs:
self._modification_type = kwargs['modification']
else:
self._modification_type = ''
self.contactListener_keepref = FrictionDetector(self)
self.world = Box2D.b2World(
(0, 0), contactListener=self.contactListener_keepref)
self.viewer = None
self.invisible_state_window = None
self.invisible_video_window = None
self.road = None
self.car = None
self.reward = 0.0
self.prev_reward = 0.0
self.verbose = verbose
self.fd_tile = fixtureDef(shape=polygonShape(
vertices=[(0, 0), (1, 0), (1, -1), (0, -1)]))
self.action_space = spaces.Box(np.array([-1, 0, 0]),
np.array([+1, +1, +1]),
dtype=np.float32) # steer, gas, brake
self.observation_space = spaces.Box(low=0,
high=255,
shape=(STATE_H, STATE_W, 3),
dtype=np.uint8)
self.step_cnt = 0
def __init__(self, max_skew: float, seed=None):
self.rand_state = np.random.RandomState(seed=seed) if seed else None
self.VIEWPORT_H = skew_by(val=self.VIEWPORT_H, max_skew=max_skew, rand_state=self.rand_state)
self.VIEWPORT_W = skew_by(val=self.VIEWPORT_W, max_skew=max_skew, rand_state=self.rand_state)
self.max_skew = max_skew
super(NoisyLander, self).__init__()
EzPickle.__init__(self)
self.seed()
self.viewer = None
self.world = Box2D.b2World()
self.moon = None
self.lander = None
self.particles = []
self.prev_reward = None
# useful range is -1 .. +1, but spikes can be higher
self.observation_space = spaces.Box(-np.inf, np.inf, shape=(8,), dtype=np.float32)
if self.continuous:
# Action is two floats [main engine, left-right engines].
# Main engine: -1..0 off, 0..+1 throttle from 50% to 100% power. Engine can't work with less than 50% power.
# Left-right: -1.0..-0.5 fire left engine, +0.5..+1.0 fire right engine, -0.5..0.5 off
self.action_space = spaces.Box(-1, +1, (2,), dtype=np.float32)
else:
# Nop, fire left engine, main engine, right engine
self.action_space = spaces.Discrete(4)
self.reset()
def __init__(self):
EzPickle.__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]),
dtype=np.float32)
self.observation_space = spaces.Box(-high, high, dtype=np.float32)
def __init__(self):
# load ROS params
global WINDOW_W
global WINDOW_H
global VIDEO_W
global VIDEO_H
WINDOW_W = rospy.get_param('/car_racing/window_w', 1200)
WINDOW_H = rospy.get_param('/car_racing/window_h', 1000)
VIDEO_W = rospy.get_param('/car_racing/video_w', 600)
VIDEO_H = rospy.get_param('/car_racing/video_h', 400)
self._seed()
self.contactListener_keepref = FrictionDetector(self)
self.world = Box2D.b2World((0,0), contactListener=self.contactListener_keepref)
self.viewer = None
self.invisible_state_window = None
self.invisible_video_window = None
self.road = None
self.car = None
self.reward = 0.0
self.prev_reward = 0.0
self.action_space = spaces.Box( np.array([-1,0,0]), np.array([+1,+1,+1])) # steer, gas, brake
self.observation_space = spaces.Box(low=0, high=255, shape=(STATE_H, STATE_W, 3))
def __init__(self):
# load ROS params
global WINDOW_W
global WINDOW_H
global VIDEO_W
global VIDEO_H
WINDOW_W = rospy.get_param('/car_racing/window_w', 1200)
WINDOW_H = rospy.get_param('/car_racing/window_h', 1000)
VIDEO_W = rospy.get_param('/car_racing/video_w', 600)
VIDEO_H = rospy.get_param('/car_racing/video_h', 400)
self._seed()
self.contactListener_keepref = FrictionDetector(self)
self.world = Box2D.b2World(
(0, 0), contactListener=self.contactListener_keepref)
self.viewer = None
self.invisible_state_window = None
self.invisible_video_window = None
self.road = None
self.car = None
self.reward = 0.0
self.prev_reward = 0.0
self.action_space = spaces.Box(np.array([-1, 0, 0]),
np.array([+1, +1,
+1])) # steer, gas, brake
self.observation_space = spaces.Box(low=0,
high=255,
shape=(STATE_H, STATE_W, 3))
def reset(self, tree=None, module_list=None):
self.wod = WallOfDeath(WOD_SPEED)
self.wod.position = 0.0
self.tree_morphology = copy.deepcopy(tree)
self._destroy()
# Creating the world since not all objects were properly deleted. TODO need to debug this
self.world = Box2D.b2World()
self.world.cmap = plt.get_cmap('viridis')
self.game_over = False
self.scroll = 0.0
self.scroll_y = 0.0
# smooth scroll
self.prevscroll = 0.0
self.prevscroll_y = 0.0
self.scroll_y
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
# will check if the robot position needs to be shifted upward
lowestY = init_y
# Fetch the nodes from the tree phenotype
if (self.tree_morphology is not None):
nodes = self.tree_morphology.getNodes()
# create a robot from these nodes
self.create_robot(nodes, module_list)
self.drawlist = self.terrain + self.robot.components + self.robot.joints
else:
self.drawlist = self.terrain
return
def __init__(self, obstacle_prob, verbose=1, sensors_activated=True):
EzPickle.__init__(self)
self.obstacles_positions = [
] # sera rempli de 4-tuples contenant la position de chaque mur
self.seed()
self.contactListener_keepref = FrictionDetector(self)
self.world = Box2D.b2World(
(0, 0), contactListener=self.contactListener_keepref)
self.viewer = None
self.invisible_state_window = None
self.invisible_video_window = None
self.road = None
self.car = None
self.reward = 0.0
self.prev_reward = 0.0
self.times_succeeded = 0
self.verbose = verbose
self.sensors_activated = sensors_activated
self.fd_tile = fixtureDef(shape=polygonShape(
vertices=[(0, 0), (1, 0), (1, -1), (0, -1)]))
self.action_space = spaces.Box(np.array([-1, 0, 0]),
np.array([+1, +1, +1]),
dtype=np.float32) # steer, gas, brake
self.observation_space = spaces.Box(low=0,
high=255,
shape=(STATE_H, STATE_W, 3),
dtype=np.uint8)
self.random_obs = 0
global OBSTACLE_PROB
OBSTACLE_PROB = obstacle_prob
def load(self):
# Load world map
# fp = file(worldCfgFilename, 'r')
# self.worldCfg = bunch.bunchify(json.load(fp))
# fp.close()
# # Configure the simulation parameters
# self.timestep = self.worldCfg.solver.timestep
# self.velocityIterations = self.worldCfg.solver.velocityIterations
# self.positionIterations = self.worldCfg.solver.positionIterations
# Load world geometry
fp = file(self.worldCfg.geometryFilename, 'rb')
geometry = np.load(fp).transpose()
fp.close()
# Set world parameters
self.width, self.height = geometry.shape
# Create the dynamics world
self.world = b2.b2World((0,0))
# Load static objects
for name, objCfg in self.worldCfg.objects.static.items():
self.staticObjects[name] = staticobject.StaticObject()
self.staticObjects[name].configure(objCfg)
self.loadStaticObject(geometry, self.staticObjects[name])
# Load dynamics objects
# for name, objCfg in self.worldCfg.objects.dynamic.items():
# self.dynamicObjects[name] = dynamicobject.DynamicObject(name, objCfg)
# self.loadDynamicObject(geometry, self.dynamicObjects[name])
for name, agentCfg in self.worldCfg.objects.agents.items():
self.agents[name] = agent.Agent(name)
self.agents[name].construct(self.world, agentCfg)
# Set up collision handling
self.contactListener = WorldContactListener()
self.world.contactListener = self.contactListener
return True
def __init__(self, random_seed=None):
self.robot_components = []
self.drawlist = []
EzPickle.__init__(self)
self.seed(random_seed)
self.viewer = None
self.tree_morphology = None
self.scroll = 0 # 12-VIEWPORT_W/SCALE/5
self.scroll_y = 0
self.robot = None
self.world = Box2D.b2World()
self.terrain = None
self.hull = None
self.wod = 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,
)
high = np.array([np.inf] * 24)
self.action_space = spaces.Box(np.array([-1, -1, -1, -1]),
np.array([1, 1, 1, 1]),
dtype=np.float32)
self.observation_space = spaces.Box(-high, high, dtype=np.float32)
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):
# initiate a 2dbox world
self.world = b2.b2World(gravity=(0, -10), doSleep=True)
# self.world.contactListener = self
# # Introduce traffic map
# self.map_scale = OBS_SCALE # map px per meters. set it to OBS_SCALE so no resizing necessary when getting observation
# contours = self.loadMap()
# num_contour = len(contours)
# print("num", num_contour)
# obstacles = []
# for contour in contours:
# vertices = []
# for item in contour:
# new_vec = b2.b2Vec2(float(item[0][0]), float(item[0][1]))
# vertices.append(new_vec)
# print("vertices")
# print(vertices)
# contour_shape = b2.b2PolygonShape(vertices=vertices)
# obstacle = self.world.CreateStaticBody(position=(0,0), shapes=contour_shape)
# obstacles.append(obstacle)
ground = self.world.CreateBody(position=(0, 0))
ground.CreateEdgeChain([(-GROUND_EDGE, -GROUND_EDGE),
(-GROUND_EDGE, GROUND_EDGE),
(GROUND_EDGE, GROUND_EDGE),
(GROUND_EDGE, -GROUND_EDGE),
(-GROUND_EDGE, -GROUND_EDGE)])
'''s
def __init__(self):
self.seed()
self.viewer = None
self.world = Box2D.b2World(gravity=Box2D.b2Vec2(0,0))
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,
)
high = np.array([np.inf]*24)
self.observation_space = spaces.Box(-high, high)
self.reset()
self.action_space = spaces.Box(
np.array([-1]*len(self.joints)), np.array([+1]*len(self.joints)))
def __init__(self, frame_skip, verbose=False):
EzPickle.__init__(self)
if frame_skip < 1:
raise ValueError("The value of frame_skip must be at least 1")
self.seed()
self.contactListener_keepref = FrictionDetector(self)
self.world = Box2D.b2World((0,0), contactListener=self.contactListener_keepref)
self.viewer = None
self.invisible_state_window = None
self.invisible_video_window = None
self.road = None
self.car = None
self.reward = 0.0
self.prev_reward = 0.0
self.verbose = verbose
self.fd_tile = fixtureDef(
shape=polygonShape(vertices=[(0, 0), (1, 0), (1, -1), (0, -1)]))
self.action_space = spaces.Box(np.array([-1, 0, 0], dtype=np.float32),
np.array([+1, +1, +1], dtype=np.float32),
dtype=np.float32) # steer, gas, brake
self.observation_space = spaces.Box(low=0, high=255, shape=(STATE_H, STATE_W, 3), dtype=np.float32)
self.state = np.zeros([STATE_H, STATE_W, 3], dtype=np.float32)
self.frame_skip = frame_skip
def __init__(self):
EzPickle.__init__(self)
self.seed(101)
self.viewer = None
self.world = Box2D.b2World()
self.terrain = None
self.hull = None
self.prev_shaping = None
self.counter = self.np_random.randint(1, 3)
self.velocity_ = self.np_random.uniform(-1, 1)
self.counter2 = self.np_random.randint(3, 5)
self.counter3 = self.np_random.randint(TERRAIN_GRASS / 2,
TERRAIN_GRASS)
self.init_force = self.np_random.uniform(-INITIAL_RANDOM,
INITIAL_RANDOM)
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]),
dtype=np.float32)
self.observation_space = spaces.Box(-high, high, dtype=np.float32)
def __init__(self):
EzPickle.__init__(self)
self.seed()
self.viewer = None
self.world = Box2D.b2World()
self.moon = None
self.lander = None
self.particles = []
self.terrain_y_values = np.array(
[1, 2, 3, 2, 5, 1, 2, 4, 5, 3, 1, 1, 3,
6]) # self.np_random.uniform(0, 400/60, size=(12,) )
self.goal_x = 8 # len(self.terrain_y_values)//2
self.prev_reward = None
# useful range is -1 .. +1, but spikes can be higher
self.observation_space = spaces.Box(-np.inf,
np.inf,
shape=(8, ),
dtype=np.float32)
if self.continuous:
# Action is two floats [main engine, left-right engines].
# Main engine: -1..0 off, 0..+1 throttle from 50% to 100% power. Engine can't work with less than 50% power.
# Left-right: -1.0..-0.5 fire left engine, +0.5..+1.0 fire right engine, -0.5..0.5 off
self.action_space = spaces.Box(-1, +1, (2, ), dtype=np.float32)
else:
# Nop, fire left engine, main engine, right engine
self.action_space = spaces.Discrete(4)
self.reset()
def __init__(self, env_config):
self.spec = None
self.set_env_config(env_config)
self.env_seed = None
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, hardcore: bool = False):
EzPickle.__init__(self)
self.screen = None
self.clock = None
self.isopen = True
self.world = Box2D.b2World()
self.terrain = None
self.hull = None
self.prev_shaping = None
self.hardcore = hardcore
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,
)
high = np.array([np.inf] * 24).astype(np.float32)
self.action_space = spaces.Box(
np.array([-1, -1, -1, -1]).astype(np.float32),
np.array([1, 1, 1, 1]).astype(np.float32),
)
self.observation_space = spaces.Box(-high, high)
def __init__(self):
EzPickle.__init__(self)
self.seed()
self.viewer = None
self.world = Box2D.b2World()
self.moon = None
self.lander = None
self.particles = []
self.prev_reward = None
# useful range is -1 .. +1, but spikes can be higher
self.observation_space = spaces.Box(-np.inf, np.inf, shape=(8,), dtype=np.float32)
if self.continuous:
# Action is two floats [main engine, left-right engines].
# Main engine: -1..0 off, 0..+1 throttle from 50% to 100% power. Engine can't work with less than 50% power.
# Left-right: -1.0..-0.5 fire left engine, +0.5..+1.0 fire right engine, -0.5..0.5 off
self.action_space = spaces.Box(-1, +1, (2,), dtype=np.float32)
else:
# Nop, fire left engine, main engine, right engine
self.action_space = spaces.Discrete(4)
self.reset()
def __init__(self):
EzPickle.__init__(self)
self.seed()
self.__contactListener_keepref = ContactListener(self)
self.__world = Box2D.b2World(
(0, 0), contactListener=self.__contactListener_keepref)
self.viewer = None
self.__robots = []
self.__robot_name = [ID_R1, ID_B1, ID_R2, ID_B2]
self.__obstacle = None
self.__area_buff = None
self.__projectile = None
#self.__area_supply = None
self.__callback_autoaim = callback_capture()
self.reward = 0.0
self.prev_reward = 0.0
self.actions = None
self.action = [Action(), Action()]
self.state = None
self.step_reward = 0
self.conflict = False
self.o_ang = 0
self.o_dis = 8.0
self.control = False
def loadLevel(self, filename):
self.tileset = Tileset()
self.tileset.load("media/Tiles.png")
self.b2World = Box2D.b2World( gravity=(0,40), doSleep=True)
#self.player = player.Player( self.b2World, self.em, (100,100) )
self.player = player.Player( self.b2World, self.em, (game.WIDTH /2, game.HEIGHT - 100))
self.createChunks(2)
def initWorld(): w = Box2D.b2World(gravity=(0,0), contactListener=listeners.ContactListener(), doSleep=True) Box2D.b2.circleShape.draw = debugRenderer.my_draw_circle Box2D.b2.polygonShape.draw = debugRenderer.my_draw_polygon return w
def create_physics_world(self, size):
# create world
worldAABB = box2d.b2AABB()
worldAABB.lowerBound = (-10, -10)
worldAABB.upperBound = (size[0] + 10, size[1] + 10)
gravity = box2d.b2Vec2(0.0, 0.0)
doSleep = True
world = box2d.b2World(worldAABB, gravity, doSleep)
return world
def to_box2d(self):
world = Box2D.b2World(allow_sleeping=False)
if self.gravity:
world.gravity = self.gravity
for body in self.bodies:
body.to_box2d(world, self)
for joint in self.joints:
joint.to_box2d(world, self)
return world
def __init__(self):
EzPickle.__init__(self)
self.seed()
self.viewer = None
self.world = Box2D.b2World()
self.moon = None
self.landers = None
self.particles = []
def test_b2EdgeShape(self):
world = b2.b2World()
v1=(-10.0, 0.0)
v2=(-7.0, -1.0)
v3=(-4.0, 0.0)
ground=world.CreateStaticBody(shapes=
[b2.b2EdgeShape(vertices=[None, v1, v2, v3])])
def __init__(self):
# Box2D Initialization
self.worldAABB=box2d.b2AABB()
self.worldAABB.lowerBound = (-200.0, -100.0)
self.worldAABB.upperBound = ( 200.0, 200.0)
gravity = (0.0, -10.0)
doSleep = True
self.world = box2d.b2World(self.worldAABB, gravity, doSleep)
self.destructionListener = fwDestructionListener()
self.boundaryListener = fwBoundaryListener()
self.contactListener = fwContactListener()
self.debugDraw = fwDebugDraw()
self.destructionListener.test = self
self.boundaryListener.test = self
self.contactListener.test = self
self.world.SetDestructionListener(self.destructionListener)
self.world.SetBoundaryListener(self.boundaryListener)
self.world.SetContactListener(self.contactListener)
self.world.SetDebugDraw(self.debugDraw)
# Pygame Initialization
if fwSettings.onlyInit: # testing mode doesn't initialize pygame
return
pygame.init()
self.screen = pygame.display.set_mode( (640,480) )
self.debugDraw.surface = self.screen
self.screenSize = box2d.b2Vec2(*self.screen.get_size())
caption= "TEST (%3d X %3d) " % (self.screenSize.x, self.screenSize.y)
pygame.display.set_caption(caption)
try:
self.font = pygame.font.Font(None, 15)
except IOError:
try:
self.font = pygame.font.Font("freesansbold.ttf", 15)
except IOError:
print "Unable to load default font or 'freesansbold.ttf'"
print "Disabling text drawing."
self.DrawString = lambda x,y,z: 0
# GUI Initialization
self.gui_app = gui.App()
self.gui_table=fwGUI(self.settings)
container = gui.Container(align=1,valign=-1)
container.add(self.gui_table,0,0)
self.gui_app.init(container)
self.viewCenter = (0,10.0*20.0)
def constructWorld(self):
doSleep = False
worldAABB=b2d.b2AABB()
worldAABB.lowerBound = (-20, -20)
worldAABB.upperBound = (self.size[0]+20, self.size[1]+20)
self.world = b2d.b2World(worldAABB, self.original_gravity, doSleep)
self.contactListener = ContactListener(self)
self.world.SetContactListener(self.contactListener)
def __init__(self):
self._seed()
self.world = Box2D.b2World((0,0), contactListener=FrictionDetector(self))
self.viewer = None
self.invisible_state_window = None
self.invisible_video_window = None
self.road = None
self.car = None
self.reward = 0.0
self.prev_reward = 0.0
def __init__(self):
self._seed()
self.viewer = None
self.world = Box2D.b2World()
self.terrain = None
self.hull = None
self.prev_shaping = None
self._reset()
def create_world(
jsw, # json world
):
return b2.b2World(
autoClearForces=jsw["autoClearForces"],
continuousPhysics=jsw["continuousPhysics"],
gravity=rubeVecToB2Vec2(jsw["gravity"]),
subStepping=jsw["subStepping"],
warmStarting=jsw["warmStarting"],
)
def __init__(self, x0, target, render):
self.render = render
if self.render:
super(CarWorld, self).__init__()
else:
self.world = b2.b2World(gravity=(0, 0), doSleep=True)
self.world.gravity = (0.0, 0.0)
self.initial_position = (x0[0], x0[1])
self.initial_angle = 0
ground = self.world.CreateBody(position=(0, 20))
ground.CreateEdgeChain(
[(-10, -30),
(-10, 5),
(-30, 30),]
)
ground.CreateEdgeChain(
[(10, -30),
(10, 5),
(-10, 30),]
)
xf1 = b2.b2Transform()
xf1.angle = 0.3524 * b2.b2_pi
xf1.position = b2.b2Mul(xf1.R, (1.0, 0.0))
xf2 = b2.b2Transform()
xf2.angle = -0.3524 * b2.b2_pi
xf2.position = b2.b2Mul(xf2.R, (-1.0, 0.0))
self.car = TDCar(self.world, position=self.initial_position, angle=self.initial_angle)
self.target = self.world.CreateStaticBody(
position=target[:2],
angle=self.initial_angle,
shapes=[b2.b2PolygonShape(vertices=[xf1*(-1, 0), xf1*(1, 0),
xf1*(0, .5)]),
b2.b2PolygonShape(vertices=[xf2*(-1, 0), xf2*(1, 0),
xf2*(0, .5)])],
)
self.target.active = False
self.start = self.world.CreateStaticBody(
position=self.initial_position,
angle=self.initial_angle,
shapes=[b2.b2PolygonShape(vertices=[xf1*(-1, 0), xf1*(1, 0),
xf1*(0, .5)]),
b2.b2PolygonShape(vertices=[xf2*(-1, 0), xf2*(1, 0),
xf2*(0, .5)])],
)
self.start.active = False
def __init__(self):
self.action_space = spaces.Box( np.array([-1,0,0]), np.array([+1,+1,+1]) ) # steer, gas, brake
self.observation_space = spaces.Box(low=0, high=255, shape=(STATE_H, STATE_W, 3))
self.world = Box2D.b2World((0,0), contactListener=FrictionDetector(self))
self.viewer = None
self.invisible_state_window = None
self.invisible_video_window = None
self.road = None
self.car = None
self.reward = 0.0
self.prev_reward = 0.0
def __init__(self):
self._seed()
self.viewer = None
self.world = Box2D.b2World()
self.moon = None
self.lander = None
self.particles = []
self.prev_reward = None
self._reset()
def __init__(self):
self.viewer = None
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)
self.world = Box2D.b2World()
self.terrain = None
self.hull = None
self.prev_shaping = None
self._reset()
def init(width=Game.WINDOW_WIDTH, height=Game.WINDOW_HEIGHT, window_per_world=20.0):
WorldConfig.WINDOW_PER_WORLD = window_per_world
worldAABB = box2d.b2AABB()
worldAABB.lowerBound.Set(0, 0)
WorldConfig.WORLD_WIDTH= width / window_per_world
WorldConfig.WORLD_HEIGHT=height/ window_per_world
worldAABB.upperBound.Set(WorldConfig.WORLD_WIDTH, WorldConfig.WORLD_HEIGHT)
WorldConfig.world = box2d.b2World(worldAABB, WorldConfig.gravity, WorldConfig.doSleep)
WorldConfig.contactListener = fwContactListener()
WorldConfig.world.SetContactListener(WorldConfig.contactListener)
def __init__(self):
self.viewer = None
high = np.array([np.inf, np.inf, np.inf, np.inf, np.inf]) # useful range is -1 .. +1
self.action_space = spaces.Discrete(4) # nop, fire left engine, main engine, right engine
self.observation_space = spaces.Box(-high, high)
self.world = Box2D.b2World(contactListener=ContactDetector(self))
self.moon = None
self.lander = None
self.particles = []
self.prev_reward = None
self._reset()
def __init__(self):
worldAABB=box2d.b2AABB()
worldAABB.lowerBound = (-8, -8)
worldAABB.upperBound = (30, 30)
self.world = box2d.b2World(worldAABB, self.gravity, self.doSleep)
floor_bodyDef = box2d.b2BodyDef()
floor_bodyDef.position = (14, 8)
floor_bodyDef.userData = self
floor_body = self.world.CreateBody(floor_bodyDef)
floor_shapeDef = box2d.b2PolygonDef()
floor_shapeDef.SetAsBox(16, 1)
floor_body.CreateShape(floor_shapeDef)
def init_physics(self):
# Box2D Initialization
self.worldAABB = box2d.b2AABB()
self.worldAABB.lowerBound = (-self.window.width*4, -self.window.height*4)
self.worldAABB.upperBound = (self.window.width*8, self.window.height*8)
gravity = (0.0, -21.0)
doSleep = True
self.contact_listener = ContactListener()
self.world = box2d.b2World(self.worldAABB, gravity, doSleep)
self.world.SetContactListener(self.contact_listener)
self.build_map_container()
self.build_ground()
self.build_objects()
self.weather = Weather(self)
def __init__(self):
EzPickle.__init__(self)
self.seed()
self.contactListener_keepref = FrictionDetector(self)
self.world = Box2D.b2World((0,0), contactListener=self.contactListener_keepref)
self.viewer = None
self.invisible_state_window = None
self.invisible_video_window = None
self.road = None
self.car = None
self.reward = 0.0
self.prev_reward = 0.0
self.action_space = spaces.Box( np.array([-1,0,0]), np.array([+1,+1,+1]), dtype=np.float32) # steer, gas, brake
self.observation_space = spaces.Box(low=0, high=255, shape=(STATE_H, STATE_W, 3), dtype=np.uint8)
