def get_body_from_shape(object_shape, object_width, object_height, object_init):
from simulator_kilobots.kb_lib import Quad, Triangle, Circle, LForm, TForm, CForm
from Box2D import b2World
fake_world = b2World()
if object_shape.lower() in ['quad', 'rect', 'square']:
return Quad(width=object_width, height=object_height,
position=object_init[:2], orientation=object_init[2],
world=fake_world)
elif object_shape.lower() in ['corner_quad', 'corner-quad', 'corner_square', 'corner-square']:
return CornerQuad(width=object_width, height=object_height,
position=object_init[:2], orientation=object_init[2],
world=fake_world)
elif object_shape.lower() == 'triangle':
return Triangle(width=object_width, height=object_height,
position=object_init[:2], orientation=object_init[2],
world=fake_world)
elif object_shape.lower() == 'circle':
return Circle(radius=object_width, position=object_init[:2],
orientation=object_init[2], world=fake_world)
elif object_shape.lower() == 'l_shape':
return LForm(width=object_width, height=object_height,
position=object_init[:2], orientation=object_init[2],
world=fake_world)
elif object_shape.lower() == 't_shape':
return TForm(width=object_width, height=object_height,
position=object_init[:2], orientation=object_init[2],
world=fake_world)
elif object_shape.lower() == 'c_shape':
return CForm(width=object_width, height=object_height,
position=object_init[:2], orientation=object_init[2],
world=fake_world)
def __init__(self, import_file, world=None):
# hacky way of allowing xmlStr to be passed as arg
try:
with open(import_file, 'r') as content_file:
self.xmlStr = content_file.read()
self.file = os.path.basename(import_file)
self.file = os.path.splitext(self.file)
# we save the filename with the epoch after the final underscore
f = self.file[0]
self.epoch = int(
f[f.rfind("_") +
1:]) # rfind is lastIndexOf, [i:] slice str after i
self.cfgname = f[:f.rfind("_")]
except FileNotFoundError:
self.xmlStr = import_file
# epoch cannot be determined from content
self.epoch = None
if world is None:
self.world = b2World()
self.world.userData = SimData()
else:
self.world = world
# set the default options that we set to each world
GenWorld(self.world)
self.world.userData.step = self.epoch
n, t, dt = xml_2_b2world(self.xmlStr)
self.world.userData.name = n
self.world.userData.sim_t = t
self.world.userData.dt = dt
def __init__(self, bounds, controllers, debug=0):
self.scene = self.SCENE_TITLE
self.bounds = bounds
self.debug = debug
self.window_x = 0
self.window_y = 0
self.stage = None
self.physicsWorld = b2World(gravity=(0, 0),
contactListener=ContactListener())
# Physical bodies should be deleted outside the simulation step.
self.physics_to_delete = []
self.players = []
self.entities = []
def batch(iterable, n=1):
l = len(iterable)
for ndx in range(0, l, n):
yield iterable[ndx:min(ndx + n, l)]
self.asteroids = []
def __init__(self, **kwargs):
self.__sim_steps = 0
self.__reset_counter = 0
# create the Kilobots world in Box2D
self.world = b2World(gravity=(0, 0), doSleep=True)
self.table = self.world.CreateStaticBody(position=(.0, .0))
self.table.CreateFixture(
shape=b2ChainShape(vertices=[(_world_scale * self.world_x_range[0], _world_scale * self.world_y_range[1]),
(_world_scale * self.world_x_range[0], _world_scale * self.world_y_range[0]),
(_world_scale * self.world_x_range[1], _world_scale * self.world_y_range[0]),
(_world_scale * self.world_x_range[1], _world_scale * self.world_y_range[1])]))
self._real_time = False
# add kilobots
self._kilobots: [Kilobot] = []
# add objects
self._objects: [Body] = []
# add light
self._light: Light = None
self.__seed = 0
self._screen = None
self.render_mode = 'human'
self.video_path = None
self._configure_environment()
self._step_world()
def __init__(self):
self._seed()
self.viewer = None # to be used later for rendering
# Gravity set to 0; assuming that the plane is flat
self.world = b2World(gravity=[0, 0], doSleep=True)
self.exterior_box = None
self.object = None
self.first_link = None
self.second_link = None
self.actuator_mount = None
self.tip = None
# Observation Space
# [object posx, object posy, joint1 angle, joint2 angle, joint1 angular speed, joint2 angular speed]
# Note: potentially add 'ball in touch with end effector'
high = np.array([np.inf] * 6)
self.observation_space = spaces.Box(low=-high, high=high)
# Continuous action space; one for each joint
# action space represents angular velocity
self.action_space = spaces.Box(-1, 1, (2, ))
self.prev_shaping = None # for reward calculation
self.drawlist = [] # for rendering
self._reset()
def copyWorld(world):
copy = b2World(gravity=world.gravity, doSleep=world.allowSleeping)
copy.continuousPhysics = world.continuousPhysics
copy.velocityThreshold = world.velocityThreshold
copy.positionThreshold = world.positionThreshold
for body in world.bodies:
fixtures = []
for fixture in body.fixtures:
fixtures.append(
b2FixtureDef(shape=fixture.shape,
density=fixture.density,
restitution=fixture.restitution,
friction=fixture.friction))
copy.CreateBody(type=body.type,
fixtures=fixtures,
userData=body.userData,
position=b2Vec2(body.position.x, body.position.y),
angle=body.angle,
linearVelocity=b2Vec2(body.linearVelocity.x,
body.linearVelocity.y),
angularVelocity=body.angularVelocity)
for body in copy.bodies:
body.sleepingAllowed = False
return copy
def __init__(self):
self._seed()
self.viewer = None # to be used later for rendering
self.count = 0
self.world = b2World(gravity=[0, GRAVITY], doSleep=True)
self.exterior_box = None
# Five linear actuators
self.actuator_list = []
# Object to be manipulated
self.object = None
# Linkages
if self.with_linkage:
self.link_left_list = [] # four links
self.link_right_list = [] # four links
self.prev_state = None
# Drawlist for rendering
self.drawlist = []
# Observation Space
# [object posx, object posy, actuator1 pos.y, ... , actuator5 pos.y, actuator1 speed.y, ... , actuator5 speed.y]
high = np.array([np.inf] * 14)
self.observation_space = spaces.Box(low=-high, high=high)
# Continuous action space; one for each linear actuator (5 total)
# action space represents velocity
self.action_space = spaces.Box(-1, 1, (5, ))
self.prev_shaping = None # for reward calculation
self._reset()
def setup_world():
world_bounds = b2AABB()
world_bounds.lowerBound = (-200, -1000)
world_bounds.upperBound = (200, 200)
world = b2World(
world_bounds,
b2Vec2(0, -30), # Gravity vector
True # Use "sleep" optimisation
)
wallsdef = b2BodyDef()
walls = world.CreateBody(wallsdef)
walls.userData = 'Blocks'
WALLS = [
(W, FLOOR * 0.5, (W / 2, FLOOR * 0.5), 0), # floor
(W / 2, 1, (W / 2, H + 1), 0), # ceiling
(1, 600, (-1, -500), 0), # left wall
(1, 600, (W + 1, -500), 0), # right wall
]
for wall in WALLS:
shape = b2PolygonDef()
shape.SetAsBox(*wall)
walls.CreateShape(shape)
return world
def __init__(self,new_display):
self.b2_game_world = b2World() # default gravity is (0,-10) and doSleep is True
self.groundBody = self.b2_game_world.CreateStaticBody(position=(0, -48),
shapes=b2PolygonShape(box=(80, 10)),
)
# Create a dynamic body at (0, 4)
self.game_display = new_display
def __init__(self, width, height):
self.render_list = []
aabb = b2AABB()
aabb.lowerBound = (-width, -height)
aabb.upperBound = (width, height)
gravity = (0, -10)
do_sleep = True
self.world = b2World(aabb, gravity, do_sleep)
def __init__(self, bounds, controllers, stage, debug=0):
self.scene = self.SCENE_TITLE
self.game_over_timer = 0
self.stage = stage
self.game_over_quad = QuadDrawable(
SCREEN_WIDTH / 2 - 496 / 2,
SCREEN_HEIGHT / 2 - 321 / 2,
496,
321,
)
self.game_over_quad.texture = Texture.load_from_file(
'resources/images/game_over.png')
self.bounds = bounds
self.debug = debug
self.window_x = 0
self.window_y = 0
self.physicsWorld = b2World(gravity=(0, 0),
contactListener=ContactListener())
# Physical bodies should be deleted outside the simulation step.
self.physics_to_delete = []
self._shapes = Shapes()
self.controllers = controllers
self.bullet_mgr = bullet_mgr = BulletManager(self)
self.players = []
self.entities = [bullet_mgr]
def batch(iterable, n=1):
l = len(iterable)
for ndx in range(0, l, n):
yield iterable[ndx:min(ndx + n, l)]
quadrant = 0
for cs in batch(controllers, 3):
x = 300 + (SCREEN_WIDTH -
600) * (quadrant & 1) + 100 * random.uniform(-1, 1)
y = 200 + (SCREEN_HEIGHT -
400) * (quadrant >> 1 & 1) + 50 * random.uniform(-1, 1)
ship = Ship(
self,
bullet_mgr,
controllers=cs,
x=x,
y=y,
# angle=math.degrees(math.atan2(y, x)) - 180
color=SHIP_TEXTURES[list(SHIP_TEXTURES.keys())[quadrant]],
)
self.players.append(ship)
self.entities.append(ship)
quadrant += 1
self.asteroids = []
def make_world():
"""
Creates a new physical world.
Returns:
The newly created world.
"""
world = b2World(gravity=(0, 0), doSleep=False)
return world
def make_world(): """ Creates a new physical world. Returns: The newly created world. """ world = b2World(gravity=(0,0), doSleep=False) return world
def setup_physics(self):
from threading import Timer
from Box2D import b2World
self.physics_update_time = 1 / 10.0
self.vel_iters = 6
self.pos_iters = 2
self.world = b2World(gravity=(0, 0), doSleep=True)
Timer(self.physics_update_time, self.update_physics)
def __init__(self):
pygame_sdl2.init()
pygame_sdl2.key.set_repeat(1, 10)
self.windowSurface = pygame_sdl2.display.set_mode((500, 400), 0, 32)
pygame_sdl2.display.set_caption('Swing Proto')
clock = pygame_sdl2.time.Clock()
clock.tick(self.FRAMES_PER_SECOND)
self.running = False
self.world = b2World(gravity=(0, -10), doSleep=True)
self.player = Player(self.world)
def init_physics(self):
self.world = b2World(gravity=(0, 0))
self.ball.register_in_world(self.world, self.friction)
for player in self.home_team.players:
player.register_in_world(self.world, self.friction)
for player in self.away_team.players:
player.register_in_world(self.world, self.friction)
self.field.register_in_world(self.world)
def __init__(self):
super(FrameworkBase, self).__init__()
self.__reset()
# Box2D Initialization
self.world = b2World(gravity=(0, -10), doSleep=True)
self.destructionListener = fwDestructionListener(test=self)
self.world.destructionListener = self.destructionListener
self.world.contactListener = self
self.t_steps, self.t_draws = [], []
def __init__(self):
pygame_sdl2.init()
pygame_sdl2.key.set_repeat(1, 10)
self.windowSurface = pygame_sdl2.display.set_mode((500, 400), 0, 32)
pygame_sdl2.display.set_caption('Swing Proto')
clock = pygame_sdl2.time.Clock()
clock.tick(self.FRAMES_PER_SECOND)
self.running = False
self.world = b2World(gravity=(0, -10), doSleep=True)
self.player = Player(self.world)
def init_helper(env_obj):
env_obj.world = b2World(gravity=[0, GRAVITY], doSleep=True)
env_obj.exterior_box = None
# Five linear actuators
env_obj.actuator_list = []
# Linkages
env_obj.link_left_list = [] # four links
env_obj.link_right_list = [] # four links
# Drawlist for rendering
env_obj.drawlist = []
def __init__(self):
super(FrameworkBase, self).__init__()
self.__reset()
# Box2D Initialization
self.world = b2World(gravity=(0, -10), doSleep=True)
self.destructionListener = fwDestructionListener(test=self)
self.world.destructionListener = self.destructionListener
self.world.contactListener = self
self.t_steps, self.t_draws = [], []
def __init__(self, do_gui=False):
self.world = b2World(gravity=(0.0, 0.0), doSleep=True)
self.do_gui = do_gui
self.TARGET_FPS = 100
self.TIME_STEP = 1.0 / self.TARGET_FPS
self.VEL_ITERS, self.POS_ITERS = 10, 10
self.bodies = []
if do_gui:
self.gui_world = GuiWorld(self.TARGET_FPS)
# raw_input()
else:
self.gui_world = None
def __init__(self, camera, luObserver, fxObserver, lvl):
self.mSwitch = True
self.mTimer = 0.0
self.mLevelDone = False
self.mCamera = camera
self.mLuObs = luObserver
self.mFxObs = fxObserver
self.contactListener = ContactListener()
self.gravity = Gravity()
self.physWorld = b2World(gravity=(0,0),doSleep=True, contactListener=self.contactListener)
self.level = Level(self.physWorld, self.gravity, lvl)
self.player = Player(self.level.mStartPos, self.physWorld, self.gravity)
self.mEntityToFollow = self.player
def __init__(self, title):
pygame.init()
pygame.display.set_caption(title)
self.running = False
self.clock = pygame.time.Clock()
self.renderer = Renderer()
self.world = b2World(gravity=(0, -10), doSleep=True)
self.renderer.setupDebugDraw(self.world)
self.gameObjects = []
body = self.world.CreateDynamicBody(position=(10, -10))
box = body.CreatePolygonFixture(box=(1, 1), density=1, friction=0.3)
self.player = self.createObject(physics=box)
def __init__(self, title):
pygame.init()
pygame.display.set_caption(title)
self.running = False
self.clock = pygame.time.Clock()
self.renderer = Renderer()
self.world = b2World(gravity=(0,-10), doSleep=True)
self.renderer.setupDebugDraw(self.world)
self.gameObjects = []
body = self.world.CreateDynamicBody(position=(10,-10))
box = body.CreatePolygonFixture(box=(1,1), density=1, friction=0.3)
self.player = self.createObject(physics=box)
def buildWorld(self):
SCALE = ControlSystem.MODEL_SCALE
world = b2World(gravity=b2Vec2(0.0, -9.81) * SCALE,
doSleep=True,
contactListener=self)
bodies = []
''' STATICS '''
self.ground_body = world.CreateStaticBody(position=b2Vec2(1, .050) *
SCALE)
self.ground_body.CreatePolygonFixture(box=b2Vec2(1, 0.025) * SCALE,
friction=5.)
bodies.append(self.ground_body)
self.platform = world.CreateStaticBody(position=b2Vec2(1.25, .2) *
SCALE)
self.platform.CreatePolygonFixture(
box=b2Vec2(ControlSystem.objDim.x, 0.025) * SCALE, friction=5.)
bodies.append(self.platform)
self.obstacle = world.CreateStaticBody(position=b2Vec2(.8, .2) * SCALE)
self.obstacle.CreatePolygonFixture(box=b2Vec2(.025, 0.025) * SCALE,
friction=5.)
bodies.append(self.obstacle)
''' FINGERS '''
self.fLeft = world.CreateDynamicBody(position=self.refL,
angle=0,
linearVelocity=b2Vec2(0, 0))
self.fLeft.fixedRotation = True
self.fLeft.CreatePolygonFixture(box=b2Vec2(.02, .05) * SCALE,
**ControlSystem.fingerDyn)
bodies.append(self.fLeft)
self.fRight = world.CreateDynamicBody(position=self.refR,
angle=0,
linearVelocity=b2Vec2(0, 0))
self.fRight.fixedRotation = True
self.fRight.CreatePolygonFixture(box=b2Vec2(.02, .05) * SCALE,
**ControlSystem.fingerDyn)
bodies.append(self.fRight)
''' OBJECT '''
self.object = world.CreateDynamicBody(position=b2Vec2(.5, .1) * SCALE,
angle=0,
linearVelocity=b2Vec2(0, 0))
self.object.CreatePolygonFixture(box=ControlSystem.objDim * SCALE,
**self.objDynProps)
self.object.linearDamping = 0.0
self.object.angularDamping = 0.01
bodies.append(self.object)
print "mass %f" % self.object.mass
self.bodies = bodies
return world
def __init__(self,
boxes,
boxes_density,
boxes_restitution,
boxes_friction,
boxes_pos,
boxes_angle,
grip_strength,
gravity = (0, -9.81),
timestep = 1.0/10,
vel_iters = 10,
pos_iters = 8):
# init box2d world
self.world = b2World(gravity = gravity, doSleep = True)
# gripper max force
self.grip_strength = grip_strength
# set simulation parameters
self.timestep = timestep
self.vel_iters = vel_iters
self.pos_iters = pos_iters
# initialize all the boxes
self.box_bodies = []
self.box_fixtures = []
for b, d, r, f, p, a in zip(boxes,
boxes_density,
boxes_restitution,
boxes_friction,
boxes_pos,
boxes_angle):
self.box_bodies.append(self.world.CreateDynamicBody(position = p,
angle = a))
fixture = self.box_bodies[-1].CreatePolygonFixture(box=b,
density = d,
friction = f,
restitution = r)
self.box_fixtures.append(fixture)
# initialize the floor
self.floor_body = self.world.CreateStaticBody(
position = (0,0),
shape = b2PolygonShape(box = (50,2))
)
def __init__(self, root_layer, camera_config, gravity=(0, 0, 0)):
self._camera = Camera(
target=camera_config['target'],
width=camera_config['width'],
rect=camera_config['rect'],
limits=camera_config['limits'],
)
self._root_layer = root_layer
self._chunks = []
worldAABB = b2AABB()
worldAABB.lowerBound = (-1000, -1000)
worldAABB.upperBound = (1000, 1000)
gravity_x, gravity_y = gravity
gravity = b2Vec2(gravity_x, gravity_y)
self._box2d_world = b2World(worldAABB, gravity, True)
self._contact_listener = ContactListener()
self._box2d_world.SetContactListener(self._contact_listener)
self._remove_list = []
def createPlanarWorld(gravity):
"""
world, bodies = create_planar_world(gravity = 9.81)
"""
world = b2World(gravity=(0, -gravity), doSleep=False)
world.warmStarting = True
world.continuousPhysics = True
world.subStepping = False
# And a static body to hold the ground shape
ground_body = world.CreateStaticBody(
position=(0, 0),
shapes=b2PolygonShape(box=(50, 1)),
)
ground_body.userData = 'ground'
goal_upper = world.CreateStaticBody(
position=(0, 0),
shapes=b2PolygonShape(box=(5, .001)),
)
goal_upper.userData = 'boundsU'
goal_lower = world.CreateStaticBody(
position=(0, 0),
shapes=b2PolygonShape(box=(5, .001)),
)
goal_lower.userData = 'boundsL'
# Create a ball to bounce
ball = world.CreateDynamicBody(position=(0, 0), angle=0)
ball.CreateCircleFixture(radius=.5, density=.1, friction=0.)
ball.userData = 'ball'
# Construct the robot paddle
robot = world.CreateDynamicBody(position=(0, 0), angle=0)
robot.CreatePolygonFixture(box=(5, .1), density=1., friction=0.)
robot.userData = 'robot'
bodies = {}
for body in world.bodies:
bodies[body.userData] = body
return world, bodies
def setupPlayground(self):
# libavg setup
self.display = avg.DivNode(parent=self._parentNode, size=self._parentNode.size)
self.renderer = Renderer()
background = avg.ImageNode(parent=self.display)
background.setBitmap(self.backgroundpic)
self.display.player = None
(displayWidth, displayHeight) = self.display.size
widthThird = (int)(displayWidth / 3)
fieldSize = (widthThird, displayHeight)
self.field1 = avg.DivNode(parent=self.display, size=fieldSize)
self.field2 = avg.DivNode(parent=self.display, size=fieldSize, pos=(displayWidth - widthThird, 0))
avg.LineNode(parent=self.display, pos1=(0, 1), pos2=(displayWidth, 1))
avg.LineNode(parent=self.display, pos1=(0, displayHeight), pos2=(displayWidth, displayHeight))
self.lines.createImageNode('layer1', dict(parent=self.display, pos=(widthThird, 0)), (2, displayHeight))
self.lines.createImageNode('layer1', dict(parent=self.display, pos=(displayWidth - widthThird, 0)), (2, displayHeight))
# pybox2d setup
self.world = b2World(gravity=(0, 0), doSleep=True)
self.hitset = set()
self.listener = ContactListener(self.hitset)
self.world.contactListener = self.listener
self.running = True
pointsToWin = 999 if self.tutorialMode else config.pointsToWin
self.leftPlayer, self.rightPlayer = Player(self, self.field1, pointsToWin), Player(self, self.field2, pointsToWin)
self.leftPlayer.other, self.rightPlayer.other = self.rightPlayer, self.leftPlayer
# horizontal lines
BorderLine(self.world, a2w((0, 1)), a2w((displayWidth, 1)), 1, False, 'redball')
BorderLine(self.world, a2w((0, displayHeight)), a2w((displayWidth, displayHeight)), 1, False, 'redball')
# vertical ghost lines
maxWallHeight = brickSize * brickLines * PPM
BorderLine(self.world, a2w((maxWallHeight, 0)), a2w((maxWallHeight, displayHeight)), 1, False, 'redball', 'ball')
BorderLine(self.world, a2w((displayWidth - maxWallHeight - 1, 0)), a2w((displayWidth - maxWallHeight - 1, displayHeight)), 1, False, 'redball', 'ball')
self.middleX, self.middleY = self.display.size / 2
self.middle = a2w((self.middleX, self.middleY))
BatManager(self.field1, self.world, self.renderer)
BatManager(self.field2, self.world, self.renderer)
self.bonus = None
self.balls = []
self.redballs = []
self.towers = []
self.ghosts = []
self.mainLoop = g_player.setOnFrameHandler(self.step)
def __init__(self):
# Called once per game, when game starts
self.world = b2World(
) # default gravity is (0,-10) and doSleep is True
# terrain_locations = [(1, 0),
# (2, 0),
# (5, 0,),
# (10, 0)]
#
# self.terrain = shapes.create_terrain('water', terrain_locations, self.world)
# Create an object that moves in the box2d world and can be rendered to the screen
#self.many_shapes = [ shapes.LLeftShape(self.world, (random()*100 - 50, random()*30)) for x in range(1,100) ]
self.demo_shape = shapes.LLeftShape(self.world, (5, 5))
# A box2d object that doesn't move and isn't rendered to screen
body_bottom_wall = self.world.CreateStaticBody(
position=(0, -10),
shapes=b2PolygonShape(box=(SCREEN_WIDTH / 2, 5)))
def eval_genome(genome, config):
net = neat.nn.FeedForwardNetwork.create(genome, config)
controller = NeuralNetworkController(net)
fitnesses = []
eps = 0.00000001
for runs in range(runs_per_net):
system = cart_pendulum_demo.CartPendulumSystem(b2World(),
controller,
initial_rotation=0)
system.print_state = False
steps = 0
f2_fitnesses = []
while steps < simulation_steps:
system.step(True)
if not system.in_legal_state():
break
f2_fitnesses.append(
1.0 / (abs(system.x) + abs(system.theta) + abs(system.dx) +
abs(system.dtheta) + eps))
steps += 1
# two tier fitness scheme to make sure we at least get to having long-term balancers
if steps >= simulation_steps:
fitness = steps + sum(f2_fitnesses)
else:
fitness = steps
fitnesses.append(fitness)
# The genome's fitness is its worst performance across all runs.
return min(fitnesses)
def setup_world():
global buoyancy
world_bounds = b2AABB()
world_bounds.lowerBound = (-200, -100)
world_bounds.upperBound = (1000, 1000)
world = b2World(
world_bounds,
b2Vec2(0, -30), # Gravity vector
True # Use "sleep" optimisation
)
wallsdef = b2BodyDef()
walls = world.CreateBody(wallsdef)
walls.userData = 'Blocks'
WALLS = [
#(W, FLOOR * 0.5, (W / 2, FLOOR * 0.5), 0), # floor
#(W / 2, 1, (W / 2, H + 1), 0), # ceiling
(1, 600, (-1, -500), 0), # left wall
#(1, 600, (W + 1, -500), 0), # right wall
]
for wall in WALLS:
shape = b2PolygonDef()
shape.SetAsBox(*wall)
walls.CreateShape(shape)
for shape in read_shapes_from_svg('shapes/ground.svg'):
walls.CreateShape(shape)
buoyancydef = b2BuoyancyControllerDef()
buoyancydef.normal = b2Vec2(0, 1)
buoyancydef.offset = WATER_LEVEL
buoyancydef.density = 2.5
buoyancydef.angularDrag = 0.5
buoyancydef.linearDrag = 3
buoyancy = world.CreateController(buoyancydef)
return world
def __init__(self, verbose=False):
EzPickle.__init__(self)
# General and utils variables
self.verbose = verbose
self.np_random = None
self.seed()
# Box2D variables
self.time = -1.0 # Set time to -1.0 to indicate that models is not ready yet
self.car = None
self.contact_listener = ContactListener(self)
self.world = b2World((0, 0), contactListener=self.contact_listener)
self.ground = None
self.track_tiles_coordinates = None # For easy access in StateTransformer
self.track_tiles = []
self.cones = []
self.tile_visited_count = 0
# PyGLet variables
self.viewer = None
self.invisible_state_window = None
self.invisible_video_window = None
self.score_label = None
self.transform = None
# RL-related variables
# action_space has the following structure (steer, gas, brake). -1, +1 is for left and right steering
self.state = None
self.done = False
self.action_space = spaces.Box(np.array([-1, 0, 0]),
np.array([+1, +1, +1]),
dtype=np.float32)
self.observation_space = spaces.Box(low=0,
high=255,
shape=(STATE_H, STATE_W, 3),
dtype=np.uint8)
self.reward = 0.0
self.prev_reward = 0.0
def __init__(self, net=False, physics=False):
self.entities = {}
self.groups = {}
self.updates = []
self.renders = []
self.time = 0
self.camera = Camera()
self.window = None
self.keys = None
self.net = net
if self.net:
from client import Client
self.client = Client()
self.net_data = []
self.physics = physics
if self.physics:
from Box2D import b2World
self.world = b2World(gravity=(0, 0), doSleep=True)
self.running = False
TIME_STEP=1.0/FPS
SCREEN_WIDTH, SCREEN_HEIGHT=640 ,480
# Box2D Iterations
VELOCITY_ITERATION = 10
POSITION_ITERATION = 10
# --- pygame setup ---
pygame.init()
screen=pygame.display.set_mode((SCREEN_WIDTH,SCREEN_HEIGHT),0, 32)
pygame.display.set_caption('Dinosaurs In Space!')
# --- pybox2d world setup ---
# Create the world
GRAVITY = -10
world=b2World(gravity=(0,GRAVITY),doSleep=False)
# --- pygame.mixer setup ---
pygame.mixer.init()
#TODO: Tweak for latency vs channels and verify this works - CP
pygame.mixer.set_num_channels(10)
# TODO: These function have, by far, the shittiest, most f*****g confusing names - CP
def pixelsToWorld(pixels):
worldPosition = (pixels[0] / PPM, (SCREEN_HEIGHT - pixels[1]) / PPM)
return worldPosition
def pixelsToVelocity(pixels):
worldPosition = (pixels[0] / PPM, pixels[1] / PPM)
return worldPosition
import math
from random import randint
import sys
from Box2D import b2Shape, b2World
from pygame import init, display, draw, event, locals, Color
from pygame.time import Clock
w_width, w_height = 800, 600
black = Color(0, 0, 0)
world = b2World(gravity=(0, 9.8))
actors, colors = [], []
PPM = 64.0 # Pixels per Meter
def add_rect_body(kind, x, y, width, height, angle=0.0, mass=1.0, rest=0.0,
frict=0.75):
body_factory = {
'static': world.CreateStaticBody,
'dynamic': world.CreateDynamicBody,
}[kind]
body = body_factory(position=(x/PPM, y/PPM), angle=angle, mass=mass)
body.CreatePolygonFixture(box=(width/PPM, height/PPM), density=1,
friction=frict, restitution=rest)
return body
def ground_arc(radius, segments, centerX, centerY):
angle_incr = math.pi/(2.0*segments)
for i in range(segments):
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
This is a simple example of building and running a simulation using Box2D. Here
we create a large ground box and a small dynamic box.
** NOTE **
There is no graphical output for this simple example, only text.
"""
from Box2D import b2PolygonShape, b2World
world = b2World() # default gravity is (0,-10) and doSleep is True
groundBody = world.CreateStaticBody(position=(0, -10), shapes=b2PolygonShape(box=(50, 10)))
# Create a dynamic body at (0, 4)
body = world.CreateDynamicBody(position=(0, 4))
# And add a box fixture onto it (with a nonzero density, so it will move)
box = body.CreatePolygonFixture(box=(1, 1), density=1, friction=0.3)
# Prepare for simulation. Typically we use a time step of 1/60 of a second
# (60Hz) and 6 velocity/2 position iterations. This provides a high quality
# simulation in most game scenarios.
timeStep = 1.0 / 60
vel_iters, pos_iters = 6, 2
# This is our little game loop.
for i in range(60):
# Instruct the world to perform a single step of simulation. It is
r = (1, 1)
# Timestep
timeStep = 1.0 / 100
# Iteration limits
velocityIterations = 5000
positionIterations = 2500
# Iteration thresholds
velocityThreshold = 6*10**-5
positionThreshold = 2*10**-5
# Number of steps
steps = 600
# Create world in case model needs it
world = b2World()
# Fill world with static box and circles
new_confined_clustered_circles_world(world, nBodies, b2Vec2(xlow, ylow), b2Vec2(xhi, yhi), r, sigma_coef, seed)
# Choose a model
model = None
#model = BuiltinWarmStartModel()
#model = BadModel()
#model = RandomModel(0)
#model = ParallelWorldModel(world)
#model = CopyWorldModel()
#model = IdentityGridModel((xlow, ylow), (xhi, yhi), 0.25, 0.25, 1)
#model = NNModel(CNN({}))
# Iteration counter plots
from .dataframes import dataframes_from_b2World
# Number of worlds to generate
nWorlds = 25
# Number of bodies in world
nBodies = 50
# Something about spread of bodies?
sigma_coef = 1.2
# Dimension of static box
p_ll = (0, 0)
p_ur = (10, 10)
# Radius of bodies
r = (0.5, 0.5)
# Create worlds
worlds = [b2World() for _ in range(nWorlds)]
# Fill worlds with static box and circles
for i in range(nWorlds):
new_confined_clustered_circles_world(worlds[i], nBodies, b2Vec2(p_ll),
b2Vec2(p_ur), r, sigma_coef, i)
# Simulate 200 steps for worlds
for w in worlds:
for j in range(200):
w.Step(0.01, 10, 10)
# Determine original totals - change attribute here if wanted
originals = []
for w in worlds:
original = 0
for b in w.bodies:
original += b.mass
def __init__(self, obstacles, **kargs):
# --------------------------------------------------- #
# set parameters
# --------------------------------------------------- #
robot_pos = kargs.get('robot_pos', (0, 0))
robot_angle = kargs.get('robot_angle', 0)
robot = kargs.get('robot', DefaultRobot())
robot_linear_damping = kargs.get('robot_linear_damping', 0.9)
robot_angluar_damping = kargs.get('robot_angluar_damping', 0.99)
robot_restitution = kargs.get('robot_restitution', 0.1)
# world limit should be a list with two tuple. The coordinates
# of the bottom left limit and of the top right limit
world_limits = kargs.get('world_limit', None)
# Parameters for the Simulation, avoid changing these while the
# simulation is running.
# Simulated elapsed time per step, increasing this sacrifices accuracy
# for more performance
self.timestep = kargs.get('timestep', 1 / 10)
# number of iterations of the solvers, lowering this sacrifices accuracy
# for more performance
self.vel_iters = kargs.get('vel_iters', 10)
self.pos_iters = kargs.get('pos_iters', 8)
# --------------------------------------------------- #
# initialize an empty world
if isinstance(robot, b2ContactListener):
self.world = b2World(contactListener=robot,
gravity=(0, 0),
doSleep=True)
else:
self.world = b2World(gravity=(0, 0), doSleep=True)
# create obstacle shapes from list of vertex list
self.__obstacle_vertices = obstacles
shapes = [b2ChainShape(vertices_loop=v) for v in obstacles]
# if limits were specified, create obstacle boundary
if world_limits != None:
v = [
world_limits[0], (world_limits[1][0], world_limits[0][1]),
world_limits[1], (world_limits[0][0], world_limits[1][1])
]
shapes.append(b2ChainShape(vertices_loop=v))
# create an unmovable entity. This will represent all obstacles
self.obstaclebody = self.world.CreateStaticBody(shapes=shapes)
# package the robot physical properties (for collisions)
# The robot constructor can choose to ignore them
param = {
'position': robot_pos,
'angle': robot_angle,
'linearDamping': robot_linear_damping,
'angularDamping': robot_angluar_damping,
'restitution': robot_restitution
}
# create the robot entity
self.robotbody = robot.attachRobotBody(self.world, **param)
self.robot = robot
self.inputs = robot.getDefaultInput()
def draw_line(surface, x1, y1, x2, y2):
color = sdl2.ext.Color(255, 255, 255)
sdl2.ext.line(surface, color, (x1, y1, x2, y2))
def draw_rect(surface, x, y, width, height):
color = sdl2.ext.Color(255, 0, 0)
sdl2.ext.fill(surface, color,
((x - width / 2) * 10,
(y - height / 2) * 10, width * 10, height * 10))
contact_listener = ContactListener()
physicsWorld = b2World(gravity=(0, 0), contactListener=contact_listener)
pShip = PhysicsShip(object(), physicsWorld, 50, 50)
pShip2 = PhysicsShip(object(), physicsWorld, 80, 80)
pShield = PhysicsShield(object(), physicsWorld, Vector2(60, 60), 20)
# pBullet = PhysicsBullet(object(), physicsWorld, 10, 20, 8, 13)
pAsteroid = PhysicsAsteroid(object(), physicsWorld, 100, 100)
sdl2.ext.init()
window = sdl2.ext.Window("2D drawing primitives", size=(1920, 1080))
window.show()
windowsurface = window.get_surface()
def draw_polygon(screen, body, polygon):
def init_physics():
defines.world = b2World(gravity=(0,0), doSleep=True) # default gravity is (0,-10) and doSleep is True
defines.world.using_contacts = True
def __init__(self, terrain=None, car=None):
self.world = world = b2World()
world.CreateStaticBody(shapes=terrain)
self.car, wheels, springs = create_vehicle(world, *car)
def __init__(self, obstacles, **kargs):
# --------------------------------------------------- #
# set parameters
# --------------------------------------------------- #
robot_pos = kargs.get('robot_pos', (0,0))
robot_angle = kargs.get('robot_angle', 0)
robot = kargs.get('robot', DefaultRobot())
robot_linear_damping = kargs.get('robot_linear_damping', 0.9)
robot_angluar_damping = kargs.get('robot_angluar_damping', 0.99)
robot_restitution = kargs.get('robot_restitution', 0.1)
# world limit should be a list with two tuple. The coordinates
# of the bottom left limit and of the top right limit
world_limits = kargs.get('world_limit', None)
# Parameters for the Simulation, avoid changing these while the
# simulation is running.
# Simulated elapsed time per step, increasing this sacrifices accuracy
# for more performance
self.timestep = kargs.get('timestep', 1/10)
# number of iterations of the solvers, lowering this sacrifices accuracy
# for more performance
self.vel_iters = kargs.get('vel_iters', 10)
self.pos_iters = kargs.get('pos_iters', 8)
# --------------------------------------------------- #
# initialize an empty world
if isinstance(robot, b2ContactListener):
self.world = b2World(contactListener = robot,
gravity = (0,0),
doSleep = True)
else:
self.world = b2World(gravity = (0,0), doSleep = True)
# create obstacle shapes from list of vertex list
self.__obstacle_vertices = obstacles
shapes = [ b2ChainShape(vertices_loop = v) for v in obstacles]
# if limits were specified, create obstacle boundary
if world_limits != None:
v= [world_limits[0], (world_limits[1][0], world_limits[0][1]),
world_limits[1], (world_limits[0][0], world_limits[1][1])]
shapes.append(b2ChainShape(vertices_loop = v))
# create an unmovable entity. This will represent all obstacles
self.obstaclebody = self.world.CreateStaticBody(shapes = shapes)
# package the robot physical properties (for collisions)
# The robot constructor can choose to ignore them
param = {'position': robot_pos,
'angle': robot_angle,
'linearDamping': robot_linear_damping,
'angularDamping': robot_angluar_damping,
'restitution': robot_restitution}
# create the robot entity
self.robotbody = robot.attachRobotBody(self.world, **param)
self.robot = robot
self.inputs = robot.getDefaultInput()
def init_world(g=(0, -10), sleep=True):
global world
world = b2World(gravity=g, doSleep=sleep)
return world
import math
from Box2D import b2World
from cart_pendulum_demo import load_winner_net_controller, CartPendulumSystem
from plot_winner_output import plot_net_output
from settings import fwSettings
if __name__ == "__main__":
controller = load_winner_net_controller()
initial_position = 2.3
initial_rotation = 0.0
sim = CartPendulumSystem(b2World(), controller, initial_position,
initial_rotation)
print()
print("Initial conditions:")
print(" x = {0:.4f}".format(sim.x))
print(" x_dot = {0:.4f}".format(sim.dx))
print(" theta = {0:.4f}".format(sim.theta))
print("theta_dot = {0:.4f}".format(sim.dtheta))
print()
# Run the given simulation for up to 120 seconds.
balance_time = 0.0
times = []
positions = []
rotations = []
steps = 3000
step = 0
import game from Box2D import b2World game.init(world=b2World(gravity=(0, 0), doSleep=True)) #import rule_connect #rule_connect.add() from camera import Camera Camera().add() import camera_control camera_control.add() import b2draw b2draw.init() '''from firefly import Firefly import random for _ in range(100): Firefly(random.randint(-40, 40), random.randint(-30, 30)).add()''' from tilemap import TileMap, SolidBlock tilemap = TileMap((0, 0), (10, 10)) tilemap.add() game.start()
def setup_box2D():
'''Create Box2D world.'''
world = b2World(gravity=(0, 0), doSleep=True, contactListener=ContactListener())
b2PolygonShape.draw = draw_polygon
b2CircleShape.draw = draw_circle
return world
