class World(object):
def __init__(self):
self.items = []
self.words = []
self.springs = []
init_pymunk()
self.space = Space()
self.space.resize_static_hash()
self.space.resize_active_hash()
def add_item(self, item):
## self.items.append(item)
self.space.add(item.shape)
self.space.add(item.body)
def add_spring(self, spring):
self.springs.append(spring)
self.space.add(spring)
def add_word(self, word):
self.words.append(word)
def update(self):
self.space.step(1.0)
class PhysicsWorld(object):
def __init__(self):
self.space = None
def init(self):
init_pymunk()
self.space = Space()
self.space.gravity = (0, -0.002)
self.space.resize_static_hash()
self.space.resize_active_hash()
def add(self, item, position, static):
item.body.position = position
if static:
self.space.add_static(item.shape)
else:
self.space.add(item.body)
self.space.add(item.shape)
if item.rest_angle_spring:
self.space.add(item.rest_angle_spring)
def update(self, items):
for item in items.itervalues():
item.physics.update()
self.space.step(1)
class World(object):
def __init__(self, debug_draw=None):
self.space = Space()
self.debug_draw = debug_draw
def step(self, elapsed):
if self.debug_draw:
self.debug_draw.pre_world_step()
self.space.step(elapsed)
if self.debug_draw:
for shape in self.space.shapes:
if isinstance(shape, Poly):
self.debug_draw.DrawPolygon(shape)
for body in self.space.bodies:
body.reset_forces()
def add(self, body_or_joint, shape=None):
if shape is not None:
self.space.add(body_or_joint, shape)
else:
self.space.add(body_or_joint)
def render(self):
if self.debug_draw:
self.debug_draw.render()
def step(space: pymunk.Space, dt: float) -> None:
"""Step the space using a fixed timestep, even when ``dt`` varies.
:param space: The space to step forward
:param dt: A variable amount of time to move forward
"""
nonlocal unused_dt
steps, unused_dt = divmod(dt + unused_dt, fixed_timestep)
for _ in range(int(steps)):
space.step(fixed_timestep)
class World(object):
"Container for everything in the model, eg: Rooms and Chunks"
def __init__(self):
# pylint: disable-msg=W0212
# Access to a protected member '_space': ack
init_pymunk()
self.space = Space()
self.space.gravity = (0, 0)
self.space._space.contents.elasticIterations = 10
self.static_body = Body(inf, inf)
self.rooms = {}
self.ents = set()
self.chunks = set()
self.player = None
self.material = granite
def add_to_pymunk(self):
for room in self.rooms.itervalues():
room.add_to_body(self.space, self.static_body)
def add_chunk(self, chunk, position, angle=0):
chunk.add_to_space(self.space, position, angle)
self.chunks.add(chunk)
def add_ent(self, ent, position, angle=0.0):
ent.body.position = position
ent.body.angle = angle
self.space.add(ent.body)
for shape in ent.shapes:
self.space.add(shape)
self.ents.add(ent)
def tick(self, delta_t):
if hasattr(self, 'player'):
self.player.move()
self.space.step(delta_t)
class World(object):
def __init__(self):
self.items = []
self.words = []
self.springs = []
init_pymunk()
self.space = Space()
self.space.resize_static_hash()
self.space.resize_active_hash()
def add_item(self, item):
## self.items.append(item)
self.space.add(item.shape)
self.space.add(item.body)
def add_spring(self, spring):
self.springs.append(spring)
self.space.add(spring)
def add_word(self, word):
self.words.append(word)
def update(self):
self.space.step(1.0)
class World(object):
def __init__(self):
self.items = []
init_pymunk()
self.space = Space()
self.space.gravity = (0, -0.5)
self.space.resize_static_hash()
self.space.resize_active_hash()
self.leaves = []
self.end_game = False
def add_item(self, item):
if isinstance(item, Bough):
self.leaves.append(item)
self.items.append(item)
item.create_body()
item.add_to_space(self.space)
def remove_item(self, item):
self.items.remove(item)
item.remove_from_space(self.space)
def update(self):
self.space.step(0.5)
for item in self.items:
item.update()
def remove_collided(self):
for item in self.items:
if item.status == "Collided":
self.remove_item(item)
def tick(self):
max_limit = len(self.leaves) - 1
if len(self.leaves) == 0:
max_limit = 0
## print "End Level"
self.end_game = True
else:
## print max_limit
randno = random.randint(0, max_limit)
## print randno
leaf = self.leaves.pop(randno)
## print leaf
leaf.remove_from_tree(self.space)
def add_cherry(self, x, y):
cherry = Cherry(x, y)
self.add_item(cherry)
def add_owange(self, x, y):
owange = Owange(x, y)
self.add_item(owange)
def add_collision_handler( self,
col_typ1,
col_typ2,
begin=None,
pre_solve=None,
post_solve=None,
separate=None,
**kwargs
):
self.space.add_collision_handler(
col_typ1, col_typ2,
begin, pre_solve,
post_solve, separate,
**kwargs)
class World(PyxelWorld):
def __init__(self):
super().__init__()
self.space = Space(threaded=True)
self.space.collision_slop = 0.7
self.iter = 0
self.time = 0.0
self.on_reset = []
self.P, self.I, self.D = 4.25347222, 0.0001041666, -4.67881944
self.I = 0.0
y = 0
L = 500
self.ground = self.line(-L,
y,
L,
y,
static=True,
friction=0.75,
radius=5)
handler = self.space.add_wildcard_collision_handler(1)
handler.begin = self.on_collision
def update(self):
dt = 1 / 30
with LOCK:
self.space.step(dt)
self.time += dt
def on_collision(self, arbiter, space, data):
for fn in self.on_reset:
fn(self)
return True
def reset(self):
global segway
self.time = 0.0
self.iter += 1
self.clear()
ctrl.object = segway = self.segway()
def clear(self):
for shape in self.space.shapes:
if shape not in self.ground.shapes:
self.space.remove(shape)
for cons in self.space.constraints:
self.space.remove(cons)
for body in self.space.bodies:
if body is not self.ground:
self.space.remove(body)
def segway(self):
R = 12
L = 60
segway = self.circ(0, R, R, mass=1, moment=1, friction=2.0)
arm = self.line(0, R, 0, R + L, mass=2, moment=50)
head = self.circ(0,
R + L,
R,
mass=8,
moment=8,
velocity=(-1, 0),
friction=0.1)
self.pin([head, arm], collide=False)
next(iter(head.shapes)).collision_type = 1
self.pin([segway, arm], anchor=(0, -L / 2), collide=False)
segway.update = iter(self.pid(segway, arm)).__next__
segway.radius = R
segway.arm = arm
segway.head = head
return segway
def pid(self, wheel, arm):
P, I, D = self.P, self.I, self.D
cte = 100
R = wheel.radius
err_ = 0.0
err_i = 0.0
gamma = 0.02
while True:
err = arm.angle
err_i = err + 0.9 * err_i
err_d = err - err_
w = cte * (P * err - I * err_i - D * err_d)
if w == 0:
F = 0
else:
F = 100 * (1 if w > wheel.angular_velocity else -1)
F -= gamma * abs(F) * wheel.angular_velocity
wheel.apply_force_at_local_point((0, +F), (+R, 0))
wheel.apply_force_at_local_point((0, -F), (-R, 0))
err_ = err
yield
class PlatformerScene(Scene):
def __init__(self, game):
super().__init__(game)
self.player = None
self.active = True
self.geometry = list()
self.space = Space()
self.space.gravity = (0, 1000)
self.sprites = LayeredUpdates()
self.event_handler = event_handling.EventQueueHandler()
self.background = resources.gfx("background.png", convert=True)
self.load()
pygame.mixer.music.load(resources.music_path("zirkus.ogg"))
pygame.mixer.music.play(-1)
def add_static(self, vertices, rect):
body = pymunk.Body(body_type=pymunk.Body.STATIC)
body.position = rect.x, rect.y
shape = pymunk.Poly(body, vertices)
shape.friction = 1.0
shape.elasticity = 1.0
self.space.add(body, shape)
def load(self):
def box_vertices(x, y, w, h):
lt = x, y
rt = x + w, y
rb = x + w, y + h
lb = x, y + h
return lt, rt, rb, lb
filename = path_join("data", "maps", "untitled.tmx")
tmxdata = pytmx.util_pygame.load_pygame(filename)
for obj in tmxdata.objects:
if obj.type == map_fixed:
rect = Rect(obj.x, obj.y, obj.width, obj.height)
vertices = box_vertices(0, 0, obj.width, obj.height)
self.add_static(vertices, rect)
elif obj.type == map_yarn_spawn:
ball = sprite.Ball(Rect((obj.x, obj.y), (32, 32)))
model = BasicModel()
model.sprites = [ball]
model.pymunk_objects = ball.pymunk_shapes
self.add_model(model)
self.player = model
elif obj.type == map_player_spawn:
self.player = unicyclecat.build(self.space, self.sprites)
self.player.position = obj.x, obj.y
self.fsm = SimpleFSM(control, "idle")
def add_model(self, model):
self.sprites.add(*model.sprites)
self.space.add(model.pymunk_objects)
def remove_model(self, model):
self.sprites.remove(*model.sprites)
self.space.remove(model.pymunk_objects)
def render(self):
surface = self._game.screen
surface.blit(self.background, (0, 0))
self.sprites.draw(surface)
return [surface.get_rect()]
def tick(self, dt):
step_amount = (1 / 30.) / 30
for i in range(30):
self.space.step(step_amount)
self.sprites.update(dt)
def event(self, pg_event):
events = self.event_handler.process_event(pg_event)
position = self.player.position
for event in events:
try:
cmd, arg = self.fsm((event.button, event.held))
except ValueError as e:
continue
if cmd == "move":
resources.sfx("cat_wheel.ogg", False, True)
resources.sfx("cat_wheel.ogg", True)
self.player.accelerate(arg)
if cmd == "idle":
self.player.brake()
elif cmd == "jump":
resources.sfx("cat_jump.ogg", True)
self.player.main_body.apply_impulse_at_world_point((0, -600),
position)
class Main(Scene):
FADE_SPEED = 75
def load(self):
self.world_size = Size(3000, 3000)
self.camera = Camera(self.size, self.world_size, 1000, 10)
self._tool = None
self.tool = None
self.batch = graphics.Batch()
self.background = CameraGroup(graphics.OrderedGroup(0), self.camera)
self.foreground = CameraGroup(graphics.OrderedGroup(1), self.camera)
self.playerg = CameraGroup(graphics.OrderedGroup(2), self.camera)
self.world_ui = CameraGroup(graphics.OrderedGroup(3), self.camera)
self.ui = graphics.OrderedGroup(2)
self.space = Space()
self.space.gravity = (0.0, 0.0)
buffer = 100
borders = Body()
borders.position = (0, 0)
left = Segment(borders, (-buffer, -buffer), (-buffer, self.world_size.height+buffer), buffer)
bottom = Segment(borders, (-buffer, -buffer), (self.world_size.width+buffer, -buffer), buffer)
right = Segment(borders, (self.world_size.width+buffer, self.world_size.height+buffer),
(self.world_size.width+buffer, -buffer), buffer)
top = Segment(borders, (self.world_size.width+buffer, self.world_size.height+buffer),
(-buffer, self.world_size.height+buffer), buffer)
self.space.add_static(left, bottom, right, top)
self.stars = Stars(self.world_size, self.batch, self.background)
self.asteroids = Asteroid.populate(50, 100, self.world_size, self.batch, self.foreground, self.space)
if not self.asteroids:
print("None of a particular resource on this asteroid belt, that'd be unfair. Trying again.")
self.end(Main())
return
self.home_world = choice([asteroid for asteroid in self.asteroids if asteroid.position.y > self.world_size.height/4*3])
self.home_world.type = "home"
self.home_world.populated = True
x, y = self.home_world.position
self.camera.move(Vector(x-self.size.width/2, y-self.size.height/2))
# Let's make stuff a bit more interesting.
for asteroid in self.asteroids:
if not asteroid.type == "home":
asteroid.body.apply_impulse((triangular(-20000, 20000, 0), triangular(-20000, 20000, 0)))
x, y = self.home_world.position
self.player = Person(x+150, y+150, self.batch, self.playerg, self.space)
self.mouse = x+150, y+150
centre = Vector(self.size.width/2, self.size.height/2)
image = centre_image(resource.image("logo.png"))
self.logo = sprite.Sprite(image, centre.x, centre.y, batch=self.batch, group=self.ui)
self.logo.opacity = 255
self.fade = True
self.faded = False
planet = centre_image(resource.image("planet.png"))
x = self.world_size.width/2
y = planet.height/2
self.planet_sprite = sprite.Sprite(planet, x, y, batch=self.batch, group=self.world_ui)
self.win_box = BB(x-200, y-200, x+200, y+200)
#self.tools = sorted([tool(self.space) for tool in Tool.__subclasses__()], key=attrgetter("order"), reverse=True)
#self.buttons = {tool: Button(30, 30+number*50, tool.image, tool.description, self.use_tool(tool), self.ui, self.batch) for number, tool in enumerate(self.tools)}
self.constraints = set()
def use_tool(self, tool):
"""For callback usage."""
def f():
self.tool = tool
return f
@property
def tool(self):
return self._tool
@tool.setter
def tool(self, tool):
if tool:
if self._tool and not self._tool == tool:
self._tool.end_selecting()
self.buttons[self._tool].normal()
self.window.set_mouse_cursor(self.window.get_system_mouse_cursor(self.window.CURSOR_DEFAULT))
self.selecting = False
self.selection = []
self.window.set_mouse_cursor(self.window.get_system_mouse_cursor(self.window.CURSOR_CROSSHAIR))
self.selecting = True
self.buttons[tool].using()
else:
if self._tool:
self._tool.end_selecting()
self.buttons[self._tool].normal()
self.window.set_mouse_cursor(self.window.get_system_mouse_cursor(self.window.CURSOR_DEFAULT))
self.selecting = False
self.selection = []
self._tool = tool
def key_pressed(self, symbol, modifiers):
self.fade = True
#self.camera.key_pressed(symbol)
def key_released(self, symbol, modifiers):
pass
#self.camera.key_released(symbol)
def mouse_pressed(self, x, y, key, modifiers):
self.fade = True
#for button in self.buttons.values():
# if button.point_over(x, y):
# button.callback()
# return
if self.selecting:
for asteroid in self.asteroids:
clicked = self.camera.translate(x, y)
if asteroid.point_over(*clicked):
self.selection.append((asteroid, clicked))
self.tool = self.tool.selection(self.selection, self.constraints)
return
self.tool = None
return
def mouse_motion(self, x, y, dx, dy):
self.mouse = self.camera.translate(x, y)
#for button in self.buttons.values():
# if button.point_over(x, y):
# button.on_mouse_over()
# else:
# button.on_mouse_leave()
def mouse_drag(self, x, y, dx, dy, buttons, modifiers):
if buttons & window.mouse.RIGHT:
self.camera.mouse_dragged(dx, dy)
def update(self, frame_time):
self.constraints = {constraint for constraint in self.constraints if not constraint.update(self.batch, self.foreground)}
if self.fade and not self.faded:
self.logo.opacity -= Main.FADE_SPEED*frame_time
if self.logo.opacity < 0:
self.logo.opacity = 0
del self.logo
self.faded = True
self.player.target = self.mouse
self.player.update()
x, y = self.player.body.position
self.camera.x, self.camera.y = x-self.size.width/2, y-self.size.height/2
self.camera.update(frame_time)
self.space.step(1/60)
if self.win_box.contains_vect(self.player.body.position):
self.end(Win())
def draw(self):
self.batch.draw()
class PymunkSimulation:
def __init__(self, do_render, sparse, max_motor_force):
self.do_render = do_render
self.sparse = sparse
self.max_motor_force = max_motor_force
if self.do_render:
pygame.init()
self.screen = pygame.display.set_mode((ENV_SIZE, ENV_SIZE))
self.draw_options = pygame_util.DrawOptions(self.screen)
self.clock = pygame.time.Clock()
self.motors = []
self.segment_bodies = []
self.space = Space()
self.space.iterations = 20
no_collision = self.space.add_collision_handler(NO_COLLISION_TYPE, NO_COLLISION_TYPE)
no_collision.begin = lambda a, b, c: False
ghost_collision = self.space.add_wildcard_collision_handler(GHOST_TYPE)
ghost_collision.begin = lambda a, b, c: False
def set_motor_rates(self, motor_rates):
for i, motor in enumerate(self.motors):
motor.rate = motor_rates[i]
def set_motor_max_forces(self, motor_forces):
for i, motor in enumerate(self.motors):
motor.max_force = motor_forces[i]
def step(self):
dt = 0.03
steps = 30
for i in range(steps):
self.space.step(dt / steps)
def add_arm(self, segment_lengths, anchor_position):
anchor = pymunk.Body(body_type=pymunk.Body.STATIC)
anchor.position = anchor_position
self.space.add(anchor)
segment_anchor = anchor
next_anchor_pos = anchor_position
for i, segment_length in enumerate(segment_lengths):
segment_size = segment_length, 10
segment_body = pymunk.Body(10, pymunk.moment_for_box(10, segment_size))
end_effector_shape = pymunk.Poly.create_box(segment_body, segment_size)
end_effector_shape.collision_type = NO_COLLISION_TYPE
end_effector_shape.friction = 1.0
end_effector_shape.elasticity = 0.1
alpha = random.random() * math.pi * 2
dx = np.cos(alpha) * segment_length / 2
dy = np.sin(alpha) * segment_length / 2
segment_body.position = next_anchor_pos[0] - dx, next_anchor_pos[1] - dy
next_anchor_pos = (next_anchor_pos[0] - 2 * dx, next_anchor_pos[1] - 2 * dy)
segment_body.angle = alpha
anchor_pin_pos = (0 if i == 0 else -segment_lengths[i - 1] / 2, 0)
pin = pymunk.PinJoint(segment_anchor, segment_body, anchor_pin_pos, (segment_length / 2, 0))
self.space.add(pin)
self.space.add(segment_body, end_effector_shape)
motor = pymunk.SimpleMotor(segment_anchor, segment_body, 0)
motor.max_force = self.max_motor_force
self.space.add(motor)
self.motors.append(motor)
self.segment_bodies.append(segment_body)
segment_anchor = segment_body
return segment_anchor, next_anchor_pos
class VehicleSimulator(object):
COLLISION_TYPE = IntEnum("COLLISION_TYPE",
"OBJECT VEHICLE LEFT_SENSOR RIGHT_SENSOR FEED")
DISPLAY_MARGIN = 10
ARENA_SIZE = 600
# simulation setting parameters
VEHICLE_RADIUS = 20
SENSOR_ANGLE = np.pi * 45 / 180
SENSOR_RANGE = 80
SENSOR_NOISE = 0
MOTOR_NOISE = 1.0
FEED_COLOR = (0, 0, 0)
FEED_ACTIVE_COLOR = (255, 0, 0)
FEED_EATING_TIME = 200
def __init__(self,
width=600,
height=600,
obstacle_num=5,
obstacle_radius=30,
feed_num=0,
feed_radius=5):
import pyglet
from pymunk import Space, Segment, Body, Circle, moment_for_circle, pyglet_util
super(VehicleSimulator, self).__init__()
self.__left_sensor_val = 0
self.__right_sensor_val = 0
self.__feed_sensor_val = False
self.__feed_touch_counter = {}
self.__feed_bodies = []
self.__feed_radius = feed_radius
self.__window = pyglet.window.Window(
self.ARENA_SIZE + self.DISPLAY_MARGIN * 2,
self.ARENA_SIZE + self.DISPLAY_MARGIN * 2,
vsync=False)
self.__draw_options = pyglet_util.DrawOptions()
self.__closed = False
@self.__window.event
def on_draw():
pyglet.gl.glClearColor(255, 255, 255, 255)
self.__window.clear()
self.__simulation_space.debug_draw(self.__draw_options)
@self.__window.event
def on_close():
pyglet.app.EventLoop().exit()
self.__closed = True
self.__simulation_space = Space()
self.__simulation_space.gravity = 0, 0
# arena
walls = [
Segment(
self.__simulation_space.static_body,
(self.DISPLAY_MARGIN, self.DISPLAY_MARGIN),
(self.ARENA_SIZE + self.DISPLAY_MARGIN, self.DISPLAY_MARGIN),
0),
Segment(
self.__simulation_space.static_body,
(self.ARENA_SIZE + self.DISPLAY_MARGIN, self.DISPLAY_MARGIN),
(self.ARENA_SIZE + self.DISPLAY_MARGIN,
self.ARENA_SIZE + self.DISPLAY_MARGIN), 0),
Segment(
self.__simulation_space.static_body,
(self.ARENA_SIZE + self.DISPLAY_MARGIN,
self.ARENA_SIZE + self.DISPLAY_MARGIN),
(self.DISPLAY_MARGIN, self.ARENA_SIZE + self.DISPLAY_MARGIN),
0),
Segment(
self.__simulation_space.static_body,
(self.DISPLAY_MARGIN, self.ARENA_SIZE + self.DISPLAY_MARGIN),
(self.DISPLAY_MARGIN, self.DISPLAY_MARGIN), 0)
]
for w in walls:
w.collision_type = self.COLLISION_TYPE.OBJECT
w.friction = 0.2
self.__simulation_space.add(walls)
# vehicle
mass = 1
self.__vehicle_body = Body(
mass, moment_for_circle(mass, 0, self.VEHICLE_RADIUS))
self.__vehicle_shape = Circle(self.__vehicle_body, self.VEHICLE_RADIUS)
self.__vehicle_shape.friction = 0.2
self.__vehicle_shape.collision_type = self.COLLISION_TYPE.VEHICLE
self.__simulation_space.add(self.__vehicle_body, self.__vehicle_shape)
# left sensor
sensor_l_s = Segment(self.__vehicle_body, (0, 0),
(self.SENSOR_RANGE * np.cos(self.SENSOR_ANGLE),
self.SENSOR_RANGE * np.sin(self.SENSOR_ANGLE)),
0)
sensor_l_s.sensor = True
sensor_l_s.collision_type = self.COLLISION_TYPE.LEFT_SENSOR
handler_l = self.__simulation_space.add_collision_handler(
self.COLLISION_TYPE.LEFT_SENSOR, self.COLLISION_TYPE.OBJECT)
handler_l.pre_solve = self.__left_sensr_handler
handler_l.separate = self.__left_sensr_separate_handler
self.__simulation_space.add(sensor_l_s)
# right sensor
sensor_r_s = Segment(self.__vehicle_body, (0, 0),
(self.SENSOR_RANGE * np.cos(-self.SENSOR_ANGLE),
self.SENSOR_RANGE * np.sin(-self.SENSOR_ANGLE)),
0)
sensor_r_s.sensor = True
sensor_r_s.collision_type = self.COLLISION_TYPE.RIGHT_SENSOR
handler_r = self.__simulation_space.add_collision_handler(
self.COLLISION_TYPE.RIGHT_SENSOR, self.COLLISION_TYPE.OBJECT)
handler_r.pre_solve = self.__right_sensr_handler
handler_r.separate = self.__right_sensr_separate_handler
self.__simulation_space.add(sensor_r_s)
# obstacles
for a in (np.linspace(0, np.pi * 2, obstacle_num, endpoint=False) +
np.pi / 2):
body = Body(body_type=Body.STATIC)
body.position = (self.DISPLAY_MARGIN + self.ARENA_SIZE / 2 +
self.ARENA_SIZE * 0.3 * np.cos(a),
self.DISPLAY_MARGIN + self.ARENA_SIZE / 2 +
self.ARENA_SIZE * 0.3 * np.sin(a))
shape = Circle(body, obstacle_radius)
shape.friction = 0.2
shape.collision_type = self.COLLISION_TYPE.OBJECT
self.__simulation_space.add(shape)
for i in range(feed_num):
body = Body(1, 1)
self.__feed_bodies.append(body)
shape = Circle(body, self.__feed_radius)
shape.sensor = True
shape.color = self.FEED_COLOR
shape.collision_type = self.COLLISION_TYPE.FEED
handler = self.__simulation_space.add_collision_handler(
self.COLLISION_TYPE.VEHICLE, self.COLLISION_TYPE.FEED)
handler.pre_solve = self.__feed_touch_handler
handler.separate = self.__feed_separate_handler
self.__simulation_space.add(body, shape)
self.__feed_touch_counter[shape] = 0
self.reset()
def reset(self, random_seed=None):
np.random.seed(random_seed)
self.__vehicle_body.position = self.ARENA_SIZE / 2 + self.DISPLAY_MARGIN, self.ARENA_SIZE / 2 + self.DISPLAY_MARGIN
self.__vehicle_body.angle = 0
for b in self.__feed_bodies:
b.position = self.DISPLAY_MARGIN + self.__feed_radius + np.random.rand(
2) * (self.ARENA_SIZE - self.__feed_radius * 2)
def update(self, action):
self.__vehicle_body.velocity = (0, 0)
self.__vehicle_body.angular_velocity = 0
velocity_l, velocity_r = action[0], action[1]
velocity_l += self.MOTOR_NOISE * np.random.randn()
velocity_r += self.MOTOR_NOISE * np.random.randn()
self.__vehicle_body.apply_impulse_at_local_point(
(velocity_l * self.__vehicle_body.mass, 0),
(0, self.VEHICLE_RADIUS))
self.__vehicle_body.apply_impulse_at_local_point(
(velocity_r * self.__vehicle_body.mass, 0),
(0, -self.VEHICLE_RADIUS))
lf = self.__get_lateral_velocity() * self.__vehicle_body.mass
self.__vehicle_body.apply_impulse_at_local_point(-lf, (0, 0))
self.__simulation_space.step(1 / 100)
from pyglet import clock
clock.tick()
self.__window.switch_to()
self.__window.dispatch_events()
self.__window.dispatch_event('on_draw')
self.__window.flip()
def get_sensor_data(self):
sensor_data = {
"left_distance": self.__left_sensor_val,
"right_distance": self.__right_sensor_val,
"feed_touching": self.__feed_sensor_val
}
return sensor_data
def set_bodycolor(self, color):
assert len(color) == 3
self.__vehicle_shape.color = color
def __feed_touch_handler(self, arbiter, space, data):
feed = arbiter.shapes[1]
feed.color = self.FEED_ACTIVE_COLOR
self.__feed_touch_counter[feed] += 1
self.__feed_sensor_val = True
if (self.__feed_touch_counter[feed] > self.FEED_EATING_TIME):
feed.body.position = self.DISPLAY_MARGIN + feed.radius / 2 + np.random.rand(
2) * (self.ARENA_SIZE - feed.radius)
return True
def __feed_separate_handler(self, arbiter, space, data):
feed = arbiter.shapes[1]
feed.color = self.FEED_COLOR
self.__feed_touch_counter[feed] = 0
self.__feed_sensor_val = False
return True
def __left_sensr_handler(self, arbiter, space, data):
p = arbiter.contact_point_set.points[0]
distance = self.__vehicle_body.world_to_local(p.point_b).get_length()
self.__left_sensor_val = 1 - distance / self.SENSOR_RANGE
self.__left_sensor_val += self.SENSOR_NOISE * np.random.randn()
return True
def __left_sensr_separate_handler(self, arbiter, space, data):
self.__left_sensor_val = 0
return True
def __right_sensr_handler(self, arbiter, space, data):
p = arbiter.contact_point_set.points[0]
distance = self.__vehicle_body.world_to_local(p.point_b).get_length()
self.__right_sensor_val = 1 - distance / self.SENSOR_RANGE
self.__right_sensor_val += self.SENSOR_NOISE * np.random.randn()
return True
def __right_sensr_separate_handler(self, arbiter, space, data):
self.__right_sensor_val = 0
return True
def __get_lateral_velocity(self):
from pymunk.vec2d import Vec2d
v = self.__vehicle_body.world_to_local(self.__vehicle_body.velocity +
self.__vehicle_body.position)
rn = Vec2d(0, -1)
return v.dot(rn) * rn
def __bool__(self):
return not self.__closed
class World(object):
def __init__(self):
self.items = []
init_pymunk()
self.space = Space()
self.space.gravity = (0, -0.5)
self.space.resize_static_hash()
self.space.resize_active_hash()
self.leaves = []
self.end_game = False
def add_item(self, item):
if isinstance(item, Bough):
self.leaves.append(item)
self.items.append(item)
item.create_body()
item.add_to_space(self.space)
def remove_item(self, item):
self.items.remove(item)
item.remove_from_space(self.space)
def update(self):
self.space.step(0.5)
for item in self.items:
item.update()
def remove_collided(self):
for item in self.items:
if item.status == "Collided":
self.remove_item(item)
def tick(self):
max_limit = len(self.leaves) - 1
if len(self.leaves) == 0:
max_limit = 0
## print "End Level"
self.end_game = True
else:
## print max_limit
randno = random.randint(0, max_limit)
## print randno
leaf = self.leaves.pop(randno)
## print leaf
leaf.remove_from_tree(self.space)
def add_cherry(self, x, y):
cherry = Cherry(x, y)
self.add_item(cherry)
def add_owange(self, x, y):
owange = Owange(x, y)
self.add_item(owange)
def add_collision_handler(self,
col_typ1,
col_typ2,
begin=None,
pre_solve=None,
post_solve=None,
separate=None,
**kwargs):
self.space.add_collision_handler(col_typ1, col_typ2, begin, pre_solve,
post_solve, separate, **kwargs)
