def __init__(self,
map_size=(10, 4),
observe=True,
seed=0,
save=False,
path=None):
self.height = map_size[0]
self.width = map_size[1]
self.map = numpy.ones((self.height, self.width), dtype=int)
for i in range(1, self.height - 1):
self.map[i, 0] = 0
self.valid_actions = ['up', 'down', 'left', 'right']
self.start_point = [0, 0] # start point
self.end_point = [self.height - 1, 0] # end point
self.block_height, self.block_width = 30, 30
self.reset()
if save:
self.viewer = rendering.Viewer(self.height*self.block_height, \
self.width*self.block_width)
self.render(is_save=True, path=path)
self.viewer.window.close()
if observe:
self.viewer = rendering.Viewer(self.height*self.block_height, \
self.width*self.block_width)
def __init__(self,
map_size=(7, 7),
observe=True,
seed=0,
save=False,
path=None):
self.height = map_size[0]
self.width = map_size[1]
maze_generator = MazeGenerator(self.height / 2, self.width / 2, seed)
self.map = maze_generator.mazemap
self.valid_actions = ['up', 'down', 'left', 'right']
self.start_point = [1, 0] # start point
self.end_point = [self.height - 2, self.width - 1] # end point
self.block_height, self.block_width = 30, 30
self.reset()
if save:
self.viewer = rendering.Viewer(self.height*self.block_height, \
self.width*self.block_width)
self.render(is_save=True, path=path)
self.viewer.window.close()
if observe:
self.viewer = rendering.Viewer(self.height*self.block_height, \
self.width*self.block_width)
def render(self, mode='human'):
import rendering
if self.viewer is None:
self.viewer = rendering.Viewer(400, 800)
#self.viewer.set_bounds(-2.2, 2.2, -2.2, 2.2)
#point1 = rendering.Point
#self.point1.add_attr(self.circletrans)
#rod = rendering.make_capsule(1, .2)
#point1.set_color(.8, .3, .3)
#self.pole_transform = rendering.Transform()
#rod.add_attr(self.pole_transform)
#axle = rendering.make_circle(.05)
#axle.set_color(0, 0, 0)
#self.viewer.add_geom(axle)
self.line1 = rendering.Line((-1, 0), (3, 0))
self.line2 = rendering.Line((0, -4), (0, 4))
self.viewer.add_geom(self.line1)
self.viewer.add_geom(self.line2)
x = self.state
costs = 0.99 * x**5 - 5 * x**4 + 4.98 * x**3 + 5 * x**2 - 6 * x - 1
self.point1 = rendering.make_circle(100)
self.point1.set_color(0, 1, 1)
self.circletrans = rendering.Transform(translation=(x, costs))
self.point1.add_attr(self.circletrans)
self.viewer.add_geom(self.point1)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
if self.viewer is None:
# from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(500, 500)
self.viewer.set_bounds(-2.2, 2.2, -2.2, 2.2)
rod = rendering.make_capsule(1, .2)
rod.set_color(.8, .3, .3)
self.pole_transform = rendering.Transform()
rod.add_attr(self.pole_transform)
self.viewer.add_geom(rod)
axle = rendering.make_circle(.05)
axle.set_color(0, 0, 0)
self.viewer.add_geom(axle)
fname = path.join(path.dirname(__file__), "assets/clockwise.png")
self.img = rendering.Image(fname, 1., 1.)
self.imgtrans = rendering.Transform()
self.img.add_attr(self.imgtrans)
self.viewer.add_onetime(self.img)
theta = np.arctan2(self.x[0], self.x[1])
self.pole_transform.set_rotation(theta + np.pi / 2)
if self.u[0]:
self.imgtrans.scale = (-self.u[0] / 2, np.abs(self.u[0]) / 2)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
import rendering
s = self.state
if self.viewer is None:
self.viewer = rendering.Viewer(500, 500)
bound = self.LINK_LENGTH_1 + self.LINK_LENGTH_2 + 0.2 # 2.2 for default
self.viewer.set_bounds(-bound, bound, -bound, bound)
if s is None: return None
p1 = [-self.LINK_LENGTH_1 * cos(s[0]), self.LINK_LENGTH_1 * sin(s[0])]
p2 = [
p1[0] - self.LINK_LENGTH_2 * cos(s[0] + s[1]),
p1[1] + self.LINK_LENGTH_2 * sin(s[0] + s[1])
]
xys = np.array([[0, 0], p1, p2])[:, ::-1]
thetas = [s[0] - pi / 2, s[0] + s[1] - pi / 2]
link_lengths = [self.LINK_LENGTH_1, self.LINK_LENGTH_2]
self.viewer.draw_line((-2.2, 1), (2.2, 1))
for ((x, y), th, llen) in zip(xys, thetas, link_lengths):
l, r, t, b = 0, llen, .1, -.1
jtransform = rendering.Transform(rotation=th, translation=(x, y))
link = self.viewer.draw_polygon([(l, b), (l, t), (r, t), (r, b)])
link.add_attr(jtransform)
link.set_color(0, .8, .8)
circ = self.viewer.draw_circle(.1)
circ.set_color(.8, .8, 0)
circ.add_attr(jtransform)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
# DO NOT TRANSLATE TO OTHER LANGUAGES UNLESS YOU ARE BRAVE
screen_width = 600
screen_height = 400
world_width = self.max_position - self.min_position
scale = screen_width / world_width
carwidth = 40
carheight = 20
if self.viewer is None:
import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
xs = np.linspace(self.min_position, self.max_position, 100)
ys = self.height(xs)
xys = list(zip((xs - self.min_position) * scale, ys * scale))
self.track = rendering.make_polyline(xys)
self.track.set_linewidth(4)
self.viewer.add_geom(self.track)
clearance = 10
l, r, t, b = -carwidth / 2, carwidth / 2, carheight, 0
car = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
car.add_attr(rendering.Transform(translation=(0, clearance)))
self.cartrans = rendering.Transform()
car.add_attr(self.cartrans)
self.viewer.add_geom(car)
frontwheel = rendering.make_circle(carheight / 2.5)
frontwheel.set_color(.5, .5, .5)
frontwheel.add_attr(
rendering.Transform(translation=(carwidth / 4, clearance)))
frontwheel.add_attr(self.cartrans)
self.viewer.add_geom(frontwheel)
backwheel = rendering.make_circle(carheight / 2.5)
backwheel.add_attr(
rendering.Transform(translation=(-carwidth / 4, clearance)))
backwheel.add_attr(self.cartrans)
backwheel.set_color(.5, .5, .5)
self.viewer.add_geom(backwheel)
flagx = (self.goal_position - self.min_position) * scale
flagy1 = self.height(self.goal_position) * scale
flagy2 = flagy1 + 50
flagpole = rendering.Line((flagx, flagy1), (flagx, flagy2))
self.viewer.add_geom(flagpole)
flag = rendering.FilledPolygon([(flagx, flagy2),
(flagx, flagy2 - 10),
(flagx + 25, flagy2 - 5)])
flag.set_color(.8, .8, 0)
self.viewer.add_geom(flag)
pos = self.state[0]
self.cartrans.set_translation((pos - self.min_position) * scale,
self.height(pos) * scale)
self.cartrans.set_rotation(math.cos(3 * pos))
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def __init__(self, observe=True, save=False, path=None):
self.height = 30
self.width = 15
# 创建地图
self.map = numpy.zeros((self.height, self.width), dtype='int')
for i in range(0, self.height):
for j in range(3, 10):
self.map[i, j] = 1
for i in range(0, 6):
for j in range(3, self.width):
self.map[i, j] = 1
for i in range(1, self.height - 3):
self.map[i, 2] = 1
for i in range(3, self.height - 10):
self.map[i, 1] = 1
for i in range(4, 14):
self.map[i, 0] = 1
self.map[6, 10] = 1
# 起点
for i in range(3, 10):
self.map[self.height - 1, i] = 2
# 终点
for i in range(0, 6):
self.map[i, self.width - 1] = 3
self.valid_actions = ['up', 'down', 'left', 'right']
self.block_height, self.block_width = 20, 20
if save:
self.viewer = rendering.Viewer(self.height*self.block_height, \
self.width*self.block_width)
self.render(is_save=True, path=path)
self.viewer.window.close()
if observe:
self.viewer = rendering.Viewer(self.height*self.block_height, \
self.width*self.block_width)
def init_rendering(self): self.viewer = rendering.Viewer(self.width, self.height) boundary = rendering.PolyLine([(1, 0), (1, 499), (800, 499), (800, 0)], True) self.viewer.add_geom(boundary) health_bar_params = (20, 260) self.my_team.set_health_bar(UprightRectangle(Point(10, self.height / 2 - health_bar_params[1] / 2), \ health_bar_params[0], health_bar_params[1]), self.viewer) self.enemy_team.set_health_bar(UprightRectangle(Point(self.width - health_bar_params[0] - 10, \ self.height / 2 - health_bar_params[1] / 2), health_bar_params[0], health_bar_params[1]), self.viewer) for char in self.inactables(): geoms = char.render() for geom in geoms: self.viewer.add_geom(geom)
def render(self, mode='human'):
if self.viewer is None:
import rendering
self.viewer = rendering.Viewer(500, 500)
self.viewer.set_bounds(-2.2, 2.2, -2.2, 2.2)
rod = rendering.make_capsule(1, .2)
rod.set_color(.8, .3, .3)
self.pole_transform = rendering.Transform()
rod.add_attr(self.pole_transform)
self.viewer.add_geom(rod)
axle = rendering.make_circle(.05)
axle.set_color(0, 0, 0)
self.viewer.add_geom(axle)
self.pole_transform.set_rotation(self.state[0])
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
screen_width = 600
screen_height = 400
world_width = self.x_threshold * 2
scale = screen_width / world_width
carty = 100 # TOP OF CART
polewidth = 10.0
polelen = scale * 1.0
cartwidth = 50.0
cartheight = 30.0
if self.viewer is None:
import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
l, r, t, b = -cartwidth / 2, cartwidth / 2, cartheight / 2, -cartheight / 2
axleoffset = cartheight / 4.0
cart = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
self.carttrans = rendering.Transform()
cart.add_attr(self.carttrans)
self.viewer.add_geom(cart)
l, r, t, b = -polewidth / 2, polewidth / 2, polelen - polewidth / 2, -polewidth / 2
pole = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
pole.set_color(.8, .6, .4)
self.poletrans = rendering.Transform(translation=(0, axleoffset))
pole.add_attr(self.poletrans)
pole.add_attr(self.carttrans)
self.viewer.add_geom(pole)
self.axle = rendering.make_circle(polewidth / 2)
self.axle.add_attr(self.poletrans)
self.axle.add_attr(self.carttrans)
self.axle.set_color(.5, .5, .8)
self.viewer.add_geom(self.axle)
self.track = rendering.Line((0, carty), (screen_width, carty))
self.track.set_color(0, 0, 0)
self.viewer.add_geom(self.track)
if self.state is None: return None
x = self.state
cartx = x[0] * scale + screen_width / 2.0 # MIDDLE OF CART
self.carttrans.set_translation(cartx, carty)
self.poletrans.set_rotation(-x[2])
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
if self.viewer is None:
import rendering
block_size = self.window // (self.dim + 1)
border_size = (self.window - self.dim * block_size) // 2
self.viewer = rendering.Viewer(self.window, self.window)
border = rendering.Border(self.window, self.window, border_size,
BORDER_COLOR)
self.plotter = rendering.Plotter(self.window, self.window,
border_size, self.dim, self.dim)
self.viewer.add_geom(border)
self.viewer.add_geom(self.plotter)
self.transform = rendering.Transform()
return_rgb_array = (mode == 'rgb_array')
self.plotter.update_points(self.plot_sparse)
return self.viewer.render(return_rgb_array)
def render(self, mode="human"):
if self.viewer is None:
import rendering
self.viewer = rendering.Viewer(700, 700)
# create rendering geometry
if self.render_geoms is None or self.rebuild_geoms:
import rendering
self.viewer.clear_geoms()
# import rendering only if we need it (and don't import for headless machines)
# from gym.envs.classic_control import rendering
self.render_geoms = []
self.render_geoms_xform = []
for entity in self.get_entities():
geom = rendering.make_circle(entity.get_size())
xform = rendering.Transform()
geom.set_color(*entity.get_color(), alpha=0.5)
geom.add_attr(xform)
self.render_geoms.append(geom)
self.render_geoms_xform.append(xform)
# add geoms to viewer
for geom in self.render_geoms:
self.viewer.add_geom(geom)
results = []
# update bounds to center around agent
cam_range = 1
pos = np.zeros(2)
self.viewer.set_bounds(pos[0] - cam_range, pos[0] + cam_range, pos[1] - cam_range, pos[1] + cam_range)
# update geometry positions
for a, entity in enumerate(self.get_entities()):
self.render_geoms_xform[a].set_translation(*entity.get_pos())
# render to display or array
results.append(self.viewer.render(return_rgb_array=mode == 'rgb_array'))
return results
def render(self, mode='human'):
# global viewer
q_1, q_2, dq_1, dq_2 = self.state
if self.viewer is None:
self.viewer = rendering.Viewer(500, 500)
bound = self.l_1 + self.l_2 + 0.2
self.viewer.set_bounds(-bound, bound, -bound, bound)
# p1 = [-l_1[None] * np.cos(q_1[t]), l_1[None] * np.sin(q_1[t])]
p1 = [self.l_1 * np.cos(q_1), self.l_1 * np.sin(q_1)]
p2 = [
p1[0] - self.l_2 * np.cos(q_1 + q_2),
p1[1] + self.l_2 * np.sin(q_1 + q_2)
]
xys = np.array([[0, 0], p1, p2]) # [:,::-1]
thetas = [q_1, q_1 + q_2]
# thetas = [q_1[t] - np.pi/2, q_1[t] + q_2[t] - np.pi/2]
link_lengths = [self.l_1, self.l_2]
self.viewer.draw_line((-2.2, 1), (2.2, 1))
for ((x, y), th, llen) in zip(xys, thetas, link_lengths):
l, r, t, b = 0, llen, .1, -.1
jtransform = rendering.Transform(rotation=th, translation=(x, y))
link = self.viewer.draw_polygon([(l, b), (l, t), (r, t), (r, b)])
link.add_attr(jtransform)
link.set_color(0, .8, .8)
circ = self.viewer.draw_circle(.1)
circ.set_color(.8, .8, 0)
circ.add_attr(jtransform)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self):
screen_width = MAZE_W * UNIT
screen_height = MAZE_H * UNIT
offset = np.array([UNIT / 2, UNIT / 2])
if self.viewer is None:
import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
for c in range(0, MAZE_W * UNIT, UNIT):
x0, y0, x1, y1 = c, 0, c, MAZE_H * UNIT
self.viewer.add_geom(rendering.Line((x0, y0), (x1, y1)))
for r in range(0, MAZE_H * UNIT, UNIT):
x0, y0, x1, y1, = 0, r, MAZE_W * UNIT, r
self.viewer.add_geom(rendering.Line((x0, y0), (x1, y1)))
hell1_center = offset + self.hell1_coord * UNIT
hell1 = rendering.FilledPolygon([
(-BLOCK_SIZE / 2, -BLOCK_SIZE / 2),
(-BLOCK_SIZE / 2, BLOCK_SIZE / 2),
(BLOCK_SIZE / 2, BLOCK_SIZE / 2),
(BLOCK_SIZE / 2, -BLOCK_SIZE / 2)
])
hell1trans = rendering.Transform()
hell1.add_attr(hell1trans)
hell1trans.set_translation(hell1_center[0],
MAZE_H * UNIT - hell1_center[1])
self.viewer.add_geom(hell1)
# hell2_center = offset + self.hell2_coord * UNIT
# hell2 = rendering.FilledPolygon([(-BLOCK_SIZE/2, -BLOCK_SIZE/2), (-BLOCK_SIZE/2, BLOCK_SIZE/2), (BLOCK_SIZE/2, BLOCK_SIZE/2), (BLOCK_SIZE/2, -BLOCK_SIZE/2)])
# hell2trans = rendering.Transform()
# hell2.add_attr( hell2trans )
# hell2trans.set_translation( hell2_center[0], MAZE_H * UNIT - hell2_center[1] )
# self.viewer.add_geom( hell2 )
goal_center = offset + self.goal_coord * UNIT
goal = rendering.FilledPolygon([(-BLOCK_SIZE / 2, -BLOCK_SIZE / 2),
(-BLOCK_SIZE / 2, BLOCK_SIZE / 2),
(BLOCK_SIZE / 2, BLOCK_SIZE / 2),
(BLOCK_SIZE / 2, -BLOCK_SIZE / 2)])
goal.set_color(1., 1., 0.)
goaltrans = rendering.Transform()
goal.add_attr(goaltrans)
goaltrans.set_translation(goal_center[0],
MAZE_H * UNIT - goal_center[1])
self.viewer.add_geom(goal)
agent = rendering.FilledPolygon([
(-BLOCK_SIZE / 2, -BLOCK_SIZE / 2),
(-BLOCK_SIZE / 2, BLOCK_SIZE / 2),
(BLOCK_SIZE / 2, BLOCK_SIZE / 2),
(BLOCK_SIZE / 2, -BLOCK_SIZE / 2)
])
agent.set_color(1., 0., 0.)
self.agenttrans = rendering.Transform()
agent.add_attr(self.agenttrans)
self.viewer.add_geom(agent)
agent_center = offset + self.agent_coord * UNIT
self.agenttrans.set_translation(agent_center[0],
MAZE_H * UNIT - agent_center[1])
return self.viewer.render(return_rgb_array=False)
import rendering
roomw, roomh = 600, 400
scale = roomw / 5400
offx, offy = 100, 50
viewer = rendering.Viewer(roomw + 2 * offx, roomh + 2 * offy)
def int_scale(x):
return int(x * scale)
for x in range(0, roomw + 1, int_scale(1800)):
for y in range(0, roomh + 1, int_scale(1800)):
light = rendering.make_circle(x + offx, y + offy)
light.set_color(1,.8,0)
viewer.add_geom(light)
for _ in range(1000):
viewer.render()
def render(self, mode='human'):
l = self.l
if self.viewer is None:
self.viewer = rendering.Viewer(720,720)
a = 1.8
self.viewer.set_bounds(-(l*a),l*a,-(l*a),l*a)
rod = rendering.make_capsule(l, l/15.2)
rod.set_color(.04, .39, .12)
self.pole_transform = rendering.Transform()
rod.add_attr(self.pole_transform)
self.viewer.add_geom(rod)
axle = rendering.make_circle(.02)
axle.set_color(0,0,0)
self.viewer.add_geom(axle)
flywheel_diameter = self.flywheel_diameter
flywheel_rim = rendering.make_circle(flywheel_diameter/2,filled=False)
flywheel_rim.set_linewidth(7)
flywheel_rim.set_color(0.5,0.5,0.5)
self.flywheel_rim_transform = rendering.Transform()
flywheel_rim.add_attr(self.flywheel_rim_transform)
self.viewer.add_geom(flywheel_rim)
flywheel_cross = rendering.make_cross(flywheel_diameter,l/20)
flywheel_cross.set_color(0.5,0.5,0.5)
self.flywheel_cross_transform = rendering.Transform()
flywheel_cross.add_attr(self.flywheel_cross_transform)
self.viewer.add_geom(flywheel_cross)
fname = path.join(path.dirname(__file__), "assets/clockwise.png")
self.img = rendering.Image(fname, .3, .3)
self.imgtrans = rendering.Transform()
self.img.add_attr(self.imgtrans)
fname = path.join(path.dirname(__file__), "assets/gears.png")
self.sprocket = rendering.Image(fname, 1, 1)
self.sprocket_trans = rendering.Transform()
self.sprocket.add_attr(self.sprocket_trans)
self.viewer.add_geom(self.sprocket)
self.sprocket_trans.scale = (self.flywheel_diameter/1.6,self.flywheel_diameter/1.8)
# uncomment if you want to have an axle at the opposite end of the rod
# need to comment out equal lines above
#flywheel = rendering.make_circle(0.85,filled=False)
#flywheel.set_linewidth(5)
#flywheel.set_color(0.5,0.5,0.5)
#self.flywheel_transform = rendering.Transform()
#flywheel.add_attr(self.flywheel_transform)
#self.viewer.add_geom(flywheel)
self.viewer.add_onetime(self.img)
theta = self.state[0] + np.pi/2
self.pole_transform.set_rotation(theta)
sprocket_theta_offset = np.pi / 180
sprocket_length_offset = 0.05
self.sprocket_trans.set_translation((l+sprocket_length_offset) * np.cos(theta - sprocket_theta_offset+0.012),
(l+sprocket_length_offset) * np.sin(theta - sprocket_theta_offset))
self.sprocket_trans.set_rotation(theta + np.pi * (2.795))
flywheel_offset = 0
self.flywheel_rim_transform.set_translation(l * np.cos(theta - flywheel_offset), l * np.sin(theta - flywheel_offset))
self.flywheel_rim_transform.set_rotation(theta + np.pi/4)
self.flywheel_cross_transform.set_translation(l * np.cos(theta - flywheel_offset), l * np.sin(theta - flywheel_offset))
self.flywheel_cross_transform.set_rotation(theta + self.rotation_add)
img_offset = np.pi / 180
img_length_offset = 0.15
self.imgtrans.translation = ((l+img_length_offset) * np.cos(theta - img_offset+0.02), (l+img_length_offset) * np.sin(theta - img_offset))
if self.last_u:
self.imgtrans.scale = (-self.last_u/(self.max_torque/2), np.abs(self.last_u)/(self.max_torque/2))
return self.viewer.render(return_rgb_array = mode=='rgb_array')
def render(self, mode='human'):
screen_width = 800
screen_height = 500
world_width = self.width
scale = screen_width / world_width
# Function to make box obstacles
def make_obstacle(obstacle):
l, r, t, b = obstacle.l, obstacle.r, obstacle.t, obstacle.b
obstacle = rendering.FilledPolygon([(l, b), (l, t), (r, t),
(r, b)])
return obstacle
def make_zone(zone, color):
l, r, t, b = zone
zone = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
zone.set_color(color[0], color[1], color[2])
return zone
# Creates viewer object, robots, and obstacles
if self.viewer is None:
self.viewer = rendering.Viewer(screen_width, screen_height)
# Add starting zones
self.viewer.add_geom(make_zone(self.team1_start, [0, 0, 0.5]))
self.viewer.add_geom(make_zone(self.team2_start, [0.5, 0, 0]))
# Add bonus zone
self.viewer.add_geom(make_zone(self.bonus_bounds, [0.8, 0.8, 0]))
# Add robot geometry
l, r, t, b = -self.robot.width / 2, self.robot.width / 2, -self.robot.length / 2, self.robot.length / 2
robot = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
robot.set_color(0, 0, 1)
self.robot_trans = rendering.Transform()
robot.add_attr(self.robot_trans)
l, r, t, b = -self.robot.gun_width / 2, self.robot.gun_width / 2, -self.robot.gun_width / 2, self.robot.gun_length - self.robot.gun_width / 2
robot_gun = rendering.FilledPolygon([(l, b), (l, t), (r, t),
(r, b)])
self.robot_guntrans = rendering.Transform()
robot_gun.add_attr(self.robot_guntrans)
self.viewer.add_geom(robot)
self.viewer.add_geom(robot_gun)
# Add enemy geometry
l, r, t, b = -self.enemy.width / 2, self.enemy.width / 2, -self.enemy.length / 2, self.enemy.length / 2
enemy = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
enemy.set_color(1, 0, 0)
self.enemy_trans = rendering.Transform()
enemy.add_attr(self.enemy_trans)
l, r, t, b = -self.enemy.gun_width / 2, self.enemy.gun_width / 2, -self.enemy.gun_width / 2, self.enemy.gun_length - self.enemy.gun_width / 2
enemy_gun = rendering.FilledPolygon([(l, b), (l, t), (r, t),
(r, b)])
self.enemy_guntrans = rendering.Transform()
enemy_gun.add_attr(self.enemy_guntrans)
self.viewer.add_geom(enemy)
self.viewer.add_geom(enemy_gun)
# Add obstacles
for obstacle in self.obstacles:
self.viewer.add_geom(make_obstacle(obstacle))
if self.state is None: return None
x = self.state
# Render location for robot
robotx, roboty = x[0] * scale, x[1] * scale
gun_angle = x[2] * np.pi / 180
self.robot_trans.set_translation(robotx, roboty)
self.robot_trans.set_rotation((self.robot.angle - 90) * np.pi / 180)
self.robot_guntrans.set_translation(robotx, roboty)
self.robot_guntrans.set_rotation(gun_angle)
# Render location for enemy
enemyx, enemyy = x[3] * scale, x[4] * scale
enemy_gun_angle = x[5] * np.pi / 180
self.enemy_trans.set_translation(enemyx, enemyy)
self.enemy_guntrans.set_translation(enemyx, enemyy)
self.enemy_guntrans.set_rotation(enemy_gun_angle)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human', close=False):
scale = 6
screen_width = scale * self.width
screen_height = scale * self.height
if self.viewer is None:
#TODO: remove when it works
import importlib
import rendering
importlib.reload(rendering)
self.viewer = rendering.Viewer(screen_width, screen_height)
self.cases = []
for i in range(self.height):
self.cases.append([])
for j in range(self.width):
x0 = i * scale
y0 = j * scale
x1 = (i + 1) * scale
y1 = (j + 1) * scale
case = rendering.FilledPolygon([(y0, x0), (y0, x1),
(y1, x1), (y1, x0)])
self.cases[i].append(case)
self.viewer.add_geom(case)
circle = rendering.make_circle(radius=self.roomba.radius * scale)
circle.set_color(1, 0, 0)
self.circle = circle
direction_circle = rendering.make_circle(
radius=self.roomba.radius * scale / 2) #color?
direction_circle.add_attr(
rendering.Transform(translation=(self.roomba.radius * scale /
2, 0)))
tracker = rendering.Compound([circle, direction_circle])
self.tracker_trans = rendering.Transform()
tracker.add_attr(self.tracker_trans)
self.viewer.add_geom(tracker)
for i in range(self.height):
for j in range(self.width):
if self.room[i, j] == 0:
self.cases[i][j].set_color(1, 1, 1)
elif self.room[i, j] == 1:
self.cases[i][j].set_color(
1 - 0.5 * min(1, self.dirty[i, j]),
1 - 0.5 * min(1, self.dirty[i, j]),
1 - 0.5 * min(1, self.dirty[i, j]))
elif self.room[i, j] == 2:
self.cases[i][j].set_color(0, 0, 0)
elif self.room[i, j] == 3:
self.cases[i][j].set_color(0.5, 0.5, 0)
self.tracker_trans.set_translation(self.roomba.pos[1] * scale,
self.roomba.pos[0] * scale)
self.tracker_trans.set_rotation(self.roomba.direction)
self.circle.set_color(self.roomba.get_life(), 0, 0)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def __init__(self):
# Record time
self.game_time = 0
self.finished = False
self.characters = {
"obstacles": [],
"zones": [],
"robots": [],
"bullets": [],
}
# Initialize teams
BLUE = Team("BLUE")
RED = Team("RED")
BLUE.enemy, RED.enemy = RED, BLUE
self.my_team, self.enemy_team = BLUE, RED
# Initialize robots
myRobot = AttackRobot(self, BLUE, Point(170, 295), 0)
enemyRobot = ManualControlRobot("OSPWADBR", self, RED, Point(250, 110),
0)
myRobot.load(5)
enemyRobot.load(40)
self.characters['robots'] = [myRobot, enemyRobot]
for i in range(len(self.characters['robots'])):
self.characters['robots'][i].id = i
# Defining course obstacles
self.characters['obstacles'] = [
Obstacle(p[0], p[1], p[2])
for p in [(Point(325, 0), 25, 100), (
Point(450, 400), 25,
100), (Point(350, 238), 100,
25), (Point(580, 100), 100,
25), (Point(120, 375), 100,
25), (Point(140, 140), 25,
100), (Point(635, 260), 25, 100)]
]
# Team start areas
self.startingZones = [
StartingZone(p[0], p[1])
for p in [(Point(0, 0), BLUE), (Point(700, 0),
BLUE), (Point(0, 400),
RED), (Point(700, 400),
RED)]
]
self.defenseBuffZones = [
DefenseBuffZone(p[0], p[1])
for p in [(Point(120, 275), BLUE), (Point(580, 125), RED)]
]
self.loadingZones = [
LoadingZone(p[0], p[1])
for p in [(Point(350, 0), RED), (Point(350, 400), BLUE)]
]
self.characters['zones'] = self.startingZones + self.defenseBuffZones + \
self.loadingZones
# self.background = Rectangle(Point(0, 0), self.width, self.height, 0)
self.viewer = rendering.Viewer(self.width, self.height)
boundary = rendering.PolyLine([(1, 0), (1, 499), (800, 499), (800, 0)],
True)
boundary.set_color(COLOR_BLACK[0], COLOR_BLACK[1], COLOR_BLACK[2])
self.viewer.add_geom(boundary)
for char in self.characters['obstacles'] + self.characters['zones']:
geoms = char.render()
for geom in geoms:
self.viewer.add_geom(geom)
import rendering
ROOMW, ROOMH = 600, 400
SCALE = ROOMW / 5400
OFFX, OFFY = 100, 50
viewer = rendering.Viewer(ROOMW + 2 * OFFX, ROOMH + 2 * OFFY)
lights_p = [(0, 0, 0), (1800, 0, 1), (3600, 0, 2), (5400, 0, 3), (0, 1800, 4),
(1800, 1800, 5), (3600, 1800, 6), (5400, 1800, 7), (0, 3600, 8),
(1800, 3600, 9), (3600, 3600, 10), (5400, 3600, 11)]
init_cd = 0
desks_p = [(1000, 2150, 900, 0, (5, 4, 9, 8, 1, 0)),
(2200, 2150, 700, 1, (5, 6, 9, 10, 1, 2)),
(3400, 2150, 500, 2, (6, 5, 10, 9, 2, 1)),
(1000, 2850, 700, 3, (9, 8, 5, 4)),
(2200, 2850, 500, 4, (9, 5, 10, 6)),
(3400, 2850, 300, 5, (10, 6, 9, 5, 7, 11))]
def cd2lx3d(v1, v2, cd, h=2000):
dst = ((v1[0] - v2[0])**2 + (v1[1] - v2[1])**2 + h**2)**0.5
cos = h / dst
return cos * cd / dst**2 * 1000**2
class Light:
MAXCD = 2500 # Maximum value of candela
def __init__(self, pos, cd, _id):
self.cd = cd
self.rad = rad
self.shape = rendering.make_circle(cx, cy, radius=rad)
self.shape.set_color(*col)
class Shaft:
def __init__(self, start, end):
viewer.add_geom(rendering.Line(start, end))
def update(self, i):
x, y = self.start
self.end = (x + r * math.cos(math.pi * i / 8 * 0),
y + r * math.sin(math.pi * i / 8 * 0))
viewer = rendering.Viewer(ScrW, ScrH)
viewer.set_bgcolor(0, .5, .9)
ck1 = Clock(60, 100, rad=60)
ck2 = Clock(180, 100, rad=60)
ck3 = Clock(300, 100, rad=60)
ck4 = Clock(420, 100, rad=60)
ck5 = Clock(540, 100, rad=60)
viewer.add_geom(ck1.shape)
viewer.add_geom(ck2.shape)
viewer.add_geom(ck3.shape)
viewer.add_geom(ck4.shape)
viewer.add_geom(ck5.shape)
l1 = rendering.Line(ck1.start, ck1.end)
l2 = rendering.Line(ck2.start, ck2.end)
