def render(self, mode='human', close=False):
if close:
# close any existic renderers
for i, viewer in enumerate(self.viewers):
if viewer is not None:
viewer.close()
self.viewers[i] = None
return []
if mode == 'human':
alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
message = ''
for agent in self.world.agents:
comm = []
for other in self.world.agents:
if other is agent: continue
if np.all(other.state.c == 0):
word = '_'
else:
word = alphabet[np.argmax(other.state.c)]
message += (other.name + ' to ' + agent.name + ': ' +
word + ' ')
# print(message)
for i in range(len(self.viewers)):
# create viewers (if necessary)
if self.viewers[i] is None:
# import rendering only if we need it (and don't import for headless machines)
#from gym.envs.classic_control import rendering
from multiagent import rendering
self.viewers[i] = rendering.Viewer(700, 700)
# create rendering geometry
if self.render_geoms is None:
# import rendering only if we need it (and don't import for headless machines)
#from gym.envs.classic_control import rendering
from multiagent import rendering
self.render_geoms = []
self.render_geoms_xform = []
self.comm_geoms = []
for entity in self.world.entities:
alpha = 0 if not entity.visible else 1
geom = rendering.make_circle(entity.size)
xform = rendering.Transform()
entity_comm_geoms = []
if 'agent' in entity.name:
geom.set_color(*entity.color, alpha=alpha * 0.5)
if not entity.silent:
dim_c = self.world.dim_c
# make circles to represent communication
for ci in range(dim_c):
comm = rendering.make_circle(entity.size / dim_c)
comm.set_color(1, 1, 1)
comm.add_attr(xform)
offset = rendering.Transform()
comm_size = (entity.size / dim_c)
offset.set_translation(
ci * comm_size * 2 - entity.size + comm_size,
0)
comm.add_attr(offset)
entity_comm_geoms.append(comm)
else:
geom.set_color(*entity.color, alpha=alpha)
geom.add_attr(xform)
self.render_geoms.append(geom)
self.render_geoms_xform.append(xform)
self.comm_geoms.append(entity_comm_geoms)
if hasattr(self.world, 'walls'):
for wall in self.world.walls:
corners = ((wall.axis_pos - 0.5 * wall.width,
wall.endpoints[0]),
(wall.axis_pos - 0.5 * wall.width,
wall.endpoints[1]),
(wall.axis_pos + 0.5 * wall.width,
wall.endpoints[1]),
(wall.axis_pos + 0.5 * wall.width,
wall.endpoints[0]))
if wall.orient == 'H':
corners = tuple(c[::-1] for c in corners)
geom = rendering.make_polygon(corners)
if wall.hard:
geom.set_color(*wall.color)
else:
geom.set_color(*wall.color, alpha=0.5)
self.render_geoms.append(geom)
# add geoms to viewer
for viewer in self.viewers:
viewer.geoms = []
for geom in self.render_geoms:
viewer.add_geom(geom)
for entity_comm_geoms in self.comm_geoms:
for geom in entity_comm_geoms:
viewer.add_geom(geom)
results = []
for i in range(len(self.viewers)):
from multiagent import rendering
# update bounds to center around agent
cam_range = 1
if self.shared_viewer:
pos = np.zeros(self.world.dim_p)
else:
pos = self.agents[i].state.p_pos
self.viewers[i].set_bounds(pos[0] - cam_range, pos[0] + cam_range,
pos[1] - cam_range, pos[1] + cam_range)
# update geometry positions
for e, entity in enumerate(self.world.entities):
alpha = 0 if not entity.visible else 1
self.render_geoms_xform[e].set_translation(*entity.state.p_pos)
if 'agent' in entity.name:
self.render_geoms[e].set_color(*entity.color,
alpha=alpha * 0.5)
if not entity.silent:
for ci in range(self.world.dim_c):
color = 1 - entity.state.c[ci]
self.comm_geoms[e][ci].set_color(
color, color, color)
else:
self.render_geoms[e].set_color(*entity.color, alpha=alpha)
# render to display or array
results.append(
self.viewers[i].render(return_rgb_array=mode == 'rgb_array'))
return results
def render(self, mode='human'):
if mode == 'human':
alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
message = ''
for agent in self.world.agents:
comm = []
for other in self.world.agents:
if other is agent: continue
if np.all(other.state.c == 0):
word = '_'
else:
word = alphabet[np.argmax(other.state.c)]
message += (other.name + ' to ' + agent.name + ': ' +
word + ' ')
if message != '':
print(message)
for i in range(len(self.viewers)):
# create viewers (if necessary)
if self.viewers[i] is None:
# import rendering only if we need it (and don't import for headless machines)
#from gym.envs.classic_control import rendering
from multiagent import rendering
self.viewers[i] = rendering.Viewer(700, 700)
# create rendering geometry
if self.render_geoms is None:
# import rendering only if we need it (and don't import for headless machines)
#from gym.envs.classic_control import rendering
from multiagent import rendering
self.render_geoms = []
self.render_geoms_xform = []
for entity in self.world.entities:
geom = rendering.make_circle(entity.size)
xform = rendering.Transform()
if 'agent' in entity.name:
geom.set_color(*entity.color, alpha=0.5)
elif 'border' in entity.name:
geom = rendering.make_polygon(entity.shape)
# print(entity.shape)
geom.set_color(*entity.color)
# print("border geom")
else:
geom.set_color(*entity.color)
geom.add_attr(xform)
self.render_geoms.append(geom)
self.render_geoms_xform.append(xform)
# add geoms to viewer
for viewer in self.viewers:
viewer.geoms = []
for geom in self.render_geoms:
viewer.add_geom(geom)
results = []
for i in range(len(self.viewers)):
from multiagent import rendering
# update bounds to center around agent
cam_range = 1
if self.shared_viewer:
pos = np.zeros(self.world.dim_p)
else:
pos = self.agents[i].state.p_pos
self.viewers[i].set_bounds(pos[0] - cam_range, pos[0] + cam_range,
pos[1] - cam_range, pos[1] + cam_range)
# update geometry positions
for e, entity in enumerate(self.world.entities):
self.render_geoms_xform[e].set_translation(*entity.state.p_pos)
# render to display or array
results.append(
self.viewers[i].render(return_rgb_array=mode == 'rgb_array'))
return results
def render(self, mode='human'):
if mode == 'human':
alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
message = ''
for agent in self.world.agents:
comm = []
for other in self.world.agents:
if other is agent: continue
if np.all(other.state.c == 0):
word = '_'
else:
word = alphabet[np.argmax(other.state.c)]
message += (other.name + ' to ' + agent.name + ': ' +
word + ' ')
print(message)
for i in range(len(self.viewers)):
# create viewers (if necessary)
if self.viewers[i] is None:
# import rendering only if we need it (and don't import for headless machines)
#from gym.envs.classic_control import rendering
from multiagent import rendering
self.viewers[i] = rendering.Viewer(700, 700)
# create rendering geometry
if self.render_geoms is None:
# import rendering only if we need it (and don't import for headless machines)
#from gym.envs.classic_control import rendering
from multiagent import rendering
self.render_geoms = []
self.render_geoms_xform = []
self.render_range_geoms = []
self.render_range_geoms_xform = []
for entity in self.world.entities:
geom = rendering.make_circle(entity.size)
xform = rendering.Transform()
if 'agent' in entity.name:
geom.set_color(*entity.color, alpha=0.3)
else:
geom.set_color(*entity.color)
geom.add_attr(xform)
self.render_geoms.append(geom)
self.render_geoms_xform.append(xform)
#if 'agent' in entity.name and entity.alive:
if 'agent' in entity.name:
range_geom = rendering.make_circle(
self.world.observable_range)
range_xform = rendering.Transform()
if entity.alive:
range_geom.set_color(1, 1, 1, alpha=0.6)
else:
range_geom.set_color(0.1, 0.1, 0.1, alpha=0)
range_geom.add_attr(range_xform)
self.render_range_geoms.append(range_geom)
self.render_range_geoms_xform.append(range_xform)
for wall in self.world.walls:
corners = ((wall.axis_pos - 0.5 * wall.width,
wall.endpoints[0]),
(wall.axis_pos - 0.5 * wall.width,
wall.endpoints[1]),
(wall.axis_pos + 0.5 * wall.width,
wall.endpoints[1]),
(wall.axis_pos + 0.5 * wall.width,
wall.endpoints[0]))
if wall.orient == 'H':
corners = tuple(c[::-1] for c in corners)
geom = rendering.make_polygon(corners)
if wall.hard:
geom.set_color(*wall.color)
else:
geom.set_color(*wall.color, alpha=0.5)
self.render_geoms.append(geom)
# add geoms to viewer
for viewer in self.viewers:
viewer.geoms = []
for geom in self.render_range_geoms:
viewer.add_geom(geom)
for geom in self.render_geoms:
viewer.add_geom(geom)
results = []
for i in range(len(self.viewers)):
from multiagent import rendering
# update bounds to center around agent
cam_range = 1
if self.shared_viewer:
pos = np.zeros(self.world.dim_p)
else:
pos = self.agents[i].state.p_pos
self.viewers[i].set_bounds(pos[0] - cam_range, pos[0] + cam_range,
pos[1] - cam_range, pos[1] + cam_range)
# update geometry color
from multiagent import rendering
for entity, g in zip(self.world.entities, self.render_geoms):
if 'agent' in entity.name:
if entity.hold > 0:
g.set_color(*entity.color, alpha=0.7)
else:
g.set_color(*entity.color, alpha=0.3)
# update geometry positions
for e, entity in enumerate(self.world.entities):
self.render_geoms_xform[e].set_translation(*entity.state.p_pos)
for a, agent in enumerate(self.world.agents):
if agent.alive:
self.render_range_geoms_xform[a].set_translation(
*agent.state.p_pos)
self.render_range_geoms[a].set_color(1, 1, 1, alpha=0.6)
else:
self.render_range_geoms[a].set_color(0.1,
0.1,
0.1,
alpha=0)
# render to display or array
results.append(
self.viewers[i].render(return_rgb_array=mode == 'rgb_array'))
return results
def render(self, mode='human'):
if mode == 'human':
alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
message = ''
for agent in self.world.agents:
comm = []
for other in self.world.agents:
if other is agent: continue
if np.all(other.state.c == 0):
word = '_'
else:
word = alphabet[np.argmax(other.state.c)]
message += (other.name + ' to ' + agent.name + ': ' +
word + ' ')
print(message)
for i in range(len(self.viewers)):
# create viewers (if necessary)
if self.viewers[i] is None:
# import rendering only if we need it (and don't import for headless machines)
#from gym.envs.classic_control import rendering
from multiagent import rendering
print("initialize viewer")
self.viewers[i] = rendering.Viewer(700, 700)
# create rendering geometry
if self.render_geoms is None or self.render_geoms is not None:
# import rendering only if we need it (and don't import for headless machines)
#from gym.envs.classic_control import rendering
from multiagent import rendering
self.render_geoms = []
self.render_geoms_attack = []
self.render_geoms_line = []
self.render_geoms_range = []
self.render_geoms_xform = []
self.render_geoms_attack_xform = []
self.render_geoms_line_xform = []
self.render_geoms_range_xform = []
for entity in self.world.entities:
if "agent" in entity.name:
geom = rendering.make_circle(entity.size)
else:
geom = rendering.make_polygon([[0.1, -0.1], [0.1, 0.1],
[-0.1, 0.1], [-0.1, -0.1]])
xform = rendering.Transform()
xform_atk = rendering.Transform()
x_form_line = rendering.Transform()
# xform_range = rendering.Transform()
geom_attack, geom_line, geom_range = None, None, None
if 'agent' in entity.name:
if entity.num_balloons != 0:
geom.set_color(*entity.color,
alpha=0.0 + 0.2 * entity.num_balloons)
if entity.action.a[0] and entity.action.a[1]:
geom_attack = rendering.make_circle(entity.size / 4)
geom_attack.add_attr(xform_atk)
geom_line = rendering.make_line(
(0, 0),
(entity.action.a[0] - entity.state.p_pos[0],
entity.action.a[1] - entity.state.p_pos[1]))
geom_line.add_attr(x_form_line)
else:
geom.set_color(*entity.color)
geom.add_attr(xform)
self.render_geoms_line.append(geom_line)
self.render_geoms_line_xform.append(x_form_line)
self.render_geoms_attack.append(geom_attack)
self.render_geoms_attack_xform.append(xform_atk)
self.render_geoms.append(geom)
self.render_geoms_xform.append(xform)
# add geoms to viewer
for viewer in self.viewers:
viewer.geoms = []
for geom in self.render_geoms:
viewer.add_geom(geom)
for atk_geom in self.render_geoms_attack:
if atk_geom:
viewer.add_geom(atk_geom)
for line_geom in self.render_geoms_line:
if line_geom:
viewer.add_geom(line_geom)
results = []
for i in range(len(self.viewers)):
from multiagent import rendering
# update bounds to center around agent
cam_range = 1
if self.shared_viewer:
pos = np.zeros(self.world.dim_p)
else:
pos = self.agents[i].state.p_pos
self.viewers[i].set_bounds(pos[0] - cam_range, pos[0] + cam_range,
pos[1] - cam_range, pos[1] + cam_range)
# update geometry positions
for e, entity in enumerate(self.world.entities):
self.render_geoms_xform[e].set_translation(*entity.state.p_pos)
for a, agent in enumerate(self.world.agents):
self.render_geoms_attack_xform[a].set_translation(
*agent.action.a)
for a, agent in enumerate(self.world.agents):
self.render_geoms_line_xform[a].set_translation(
*agent.state.p_pos)
# render to display or array
results.append(
self.viewers[i].render(return_rgb_array=mode == 'rgb_array'))
return results
def __init__(self,
world,
env_spec,
reset_callback=None,
reward_callback=None,
observation_callback=None,
info_callback=None,
done_callback=None,
shared_viewer=True):
self.world = world
self.env_spec = env_spec
self.agents = self.world.policy_agents
# set required vectorized gym env property
self.n = len(world.policy_agents)
# scenario callbacks
self.reset_callback = reset_callback
self.reward_callback = reward_callback
self.observation_callback = observation_callback
self.info_callback = info_callback
self.done_callback = done_callback
# environment parameters
self.discrete_action_space = True
# if true, action is a number 0...N, otherwise action is a one-hot N-dimensional vector
self.discrete_action_input = False
# if true, even the action is continuous, action will be performed discretely
self.force_discrete_action = world.discrete_action if hasattr(
world, 'discrete_action') else False
# if true, every agent has the same reward
self.shared_reward = world.collaborative if hasattr(
world, 'collaborative') else False
self.time = 0
# configure spaces
self.action_space = []
self.observation_space = []
for agent in self.agents:
total_action_space = []
# physical action space
if self.discrete_action_space:
u_action_space = spaces.Discrete(world.dim_p * 2 + 1)
else:
u_action_space = spaces.Box(low=-agent.u_range,
high=+agent.u_range,
shape=(world.dim_p, ),
dtype=np.float32)
if agent.movable:
total_action_space.append(u_action_space)
# communication action space
if self.discrete_action_space:
c_action_space = spaces.Discrete(world.dim_c)
else:
c_action_space = spaces.Box(low=0.0,
high=1.0,
shape=(world.dim_c, ),
dtype=np.float32)
if not agent.silent:
total_action_space.append(c_action_space)
# total action space
if len(total_action_space) > 1:
# all action spaces are discrete, so simplify to MultiDiscrete action space
if all([
isinstance(act_space, spaces.Discrete)
for act_space in total_action_space
]):
act_space = MultiDiscrete(
[[0, act_space.n - 1]
for act_space in total_action_space])
else:
act_space = spaces.Tuple(total_action_space)
self.action_space.append(act_space)
else:
self.action_space.append(total_action_space[0])
# observation space
obs_dim = len(observation_callback(agent, self.world))
self.observation_space.append(
spaces.Box(low=-np.inf,
high=+np.inf,
shape=(obs_dim, ),
dtype=np.float32))
agent.action.c = np.zeros(self.world.dim_c)
# rendering
self.shared_viewer = shared_viewer
# import rendering only if needed. TODO Add a global rendering flag
from multiagent import rendering
# TODO Create a debug flag for this
w = self.env_spec.width * 2 + 0.2
h = self.env_spec.height * 2 + 0.2
self.world_bound_geom = rendering.make_polygon([(0, 0), (w, 0), (w, h),
(0, h)], False)
self.world_bound_geom.set_color(0., 0., 0., alpha=0.3)
xform = rendering.Transform()
xform.set_translation(-w / 2, -h / 2)
self.world_bound_geom.add_attr(xform)
if self.shared_viewer:
self.viewers = [rendering.Viewer(700, 700)]
else:
self.viewers = [rendering.Viewer(700, 700) for i in self.n]
for i, viewer in enumerate(self.viewers):
viewer.cam_range = self.env_spec.zoom
self._reset_render()
def render(self, mode='human'):
for i in range(len(self.viewers)):
# create viewers (if necessary)
if self.viewers[i] is None:
# import rendering only if we need it (and don't import for headless machines)
#from gym.envs.classic_control import rendering
from multiagent import rendering
self.viewers[i] = rendering.Viewer(700, 700)
# create rendering geometry
if self.render_geoms is None:
# import rendering only if we need it (and don't import for headless machines)
#from gym.envs.classic_control import rendering
from multiagent import rendering
self.render_geoms = []
self.render_geoms_xform = []
for agent in self.world.agents:
geom = rendering.make_circle(agent.size)
if agent.armed:
# render arms
radius0 = agent.size * 1.3
radius1 = agent.size * 1.5
aim = rendering.make_polygon([
(np.cos(-.1) * radius1, np.sin(-.1) * radius0),
(radius0, 0),
(np.cos(.1) * radius1, np.sin(.1) * radius0)
])
geom = rendering.Compound([geom, aim])
xform = rendering.Transform()
geom.set_color(*agent.color)
geom.add_attr(xform)
self.render_geoms.append(geom)
self.render_geoms_xform.append(xform)
# add geoms to viewer
for viewer in self.viewers:
viewer.geoms = []
for geom in self.render_geoms:
viewer.add_geom(geom)
results = []
for i in range(len(self.viewers)):
from multiagent import rendering
# update bounds to center around agent
cam_range = 1
pos = np.zeros(self.world.dim_p)
self.viewers[i].set_bounds(pos[0] - cam_range, pos[0] + cam_range,
pos[1] - cam_range, pos[1] + cam_range)
# update geometry positions
for a, agent in enumerate(self.world.agents):
xform = self.render_geoms_xform[a]
xform.set_translation(*agent.state.p_pos)
if agent.state.aim_heading is not None:
xform.set_rotation(agent.state.aim_heading)
for projectile in self.world.projectiles:
geom = rendering.Line(start=tuple(projectile[:2]),
end=tuple(projectile[2:]))
for viewer in self.viewers:
viewer.add_onetime(geom)
# render to display or array
results.append(
self.viewers[i].render(return_rgb_array=mode == 'rgb_array'))
return results
def render(self, mode='human', VP_W=700, VP_H=700, print_text=False):
if print_text and mode == 'human':
alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
message = ''
message_constructed = False
for agent in self.world.agents:
comm = []
for other in self.world.agents:
if other is agent: continue
if np.all(other.state.c == 0):
word = '_'
else:
word = alphabet[np.argmax(other.state.c)]
message += (other.name + ' to ' + agent.name + ': ' +
word + ' ')
message_constructed = True
if message_constructed:
print(message)
for i in range(len(self.viewers)):
# create viewers (if necessary)
if self.viewers[i] is None:
# import rendering only if we need it (and don't import for headless machines)
#from gym.envs.classic_control import rendering
from multiagent import rendering
self.viewers[i] = rendering.Viewer(VP_W, VP_H)
# create rendering geometry
if self.render_geoms is None:
# import rendering only if we need it (and don't import for headless machines)
#from gym.envs.classic_control import rendering
from multiagent import rendering
self.render_geoms = []
self.render_geoms_xform = []
self.sensor_render_geoms = []
self.sensor_render_geoms_xform = []
for entity in self.world.entities:
geom = rendering.make_circle(entity.size)
xform = rendering.Transform()
geom.set_color(*entity.color)
geom.add_attr(xform)
self.render_geoms.append(geom)
self.render_geoms_xform.append(xform)
if entity.sensor is not None:
v = self._make_receptor_locations(
entity, self.world.position_scale)
sensor_geom = rendering.make_polygon(v=v, filled=True)
sensor_geom.set_color(*entity.color, alpha=0.2)
sensor_xform = rendering.Transform()
sensor_geom.add_attr(sensor_xform)
self.sensor_render_geoms.append(sensor_geom)
self.sensor_render_geoms_xform.append(sensor_xform)
# add geoms to viewer
for viewer in self.viewers:
viewer.geoms = []
viewer.sensor_geoms = []
for sensor_geom in self.sensor_render_geoms:
viewer.add_geom(sensor_geom)
for geom in self.render_geoms:
viewer.add_geom(geom)
results = []
for i in range(len(self.viewers)):
from multiagent import rendering
# update bounds to center around agent
cam_range = 1
if self.shared_viewer:
pos = np.zeros(self.world.dim_p)
else:
pos = self.agents[i].state.p_pos / self.world.position_scale
self.viewers[i].set_bounds(pos[0] - cam_range, pos[0] + cam_range,
pos[1] - cam_range, pos[1] + cam_range)
# update geometry positions
for e, entity in enumerate(self.world.entities):
self.render_geoms_xform[e].set_translation(
*(entity.state.p_pos / self.world.position_scale))
if (entity.rwr
is not None) and (len(entity.rwr.observers) > 0):
one_time_geom = self.viewers[i].draw_circle(
radius=entity.size * 1.5, res=30, filled=False)
xform = rendering.Transform()
xform.set_translation(*(entity.state.p_pos /
self.world.position_scale))
one_time_geom.add_attr(xform)
one_time_geom.set_color(0.75, 0.25, 0.25)
one_time_geom.set_linewidth(5.0)
if entity.sensor is not None:
self.sensor_render_geoms_xform[e].set_translation(
*(entity.state.p_pos / self.world.position_scale))
rotation = np.sign(entity.state.p_vel[1]) * np.arccos(
entity.state.p_vel[0] /
np.linalg.norm(entity.state.p_vel))
self.sensor_render_geoms_xform[e].set_rotation(rotation)
if len(entity.sensor.detections) > 0:
self.sensor_render_geoms[e].set_color(0.75,
0.25,
0.25,
alpha=0.2)
else:
self.sensor_render_geoms[e].set_color(*entity.color,
alpha=0.2)
if print_text:
print("Detecions for entity: ", entity.name,
entity.sensor.detections)
# render expendables
for missile in entity.state.missiles_in_flight:
one_time_geom = self.viewers[i].draw_circle(
radius=missile.size, res=30, filled=False)
xform = rendering.Transform()
xform.set_translation(*(missile.state.p_pos /
self.world.position_scale))
one_time_geom.add_attr(xform)
one_time_geom.set_color(*missile.color)
one_time_geom.set_linewidth(5.0)
# render to display or array
results.append(self.viewers[i].render(
return_rgb_array=mode == 'rgb_array', VP_W=VP_W, VP_H=VP_H))
return results
def render(self, mode='human'):
for i in range(len(self.viewers)):
# create viewers (if necessary)
if self.viewers[i] is None:
# import rendering only if we need it (and don't import for headless machines)
#from gym.envs.classic_control import rendering
from multiagent import rendering
self.viewers[i] = rendering.Viewer(700, 700)
# create rendering geometry
if self.render_geoms is None:
# import rendering only if we need it (and don't import for headless machines)
#from gym.envs.classic_control import rendering
from multiagent import rendering
self.render_geoms = []
self.render_geoms_xform = []
for entity in self.world.entities:
# xform = rendering.Transform()
# line = None
#! render landmark according to their position
if entity in self.world.landmarks:
w, h = entity.shape
w_half, h_half = w / 2, h / 2
geom = rendering.make_polygon([[w_half, -h_half],
[w_half, h_half],
[-w_half, h_half],
[-w_half, -h_half]])
else: #! render agents according to their position
geom = rendering.make_circle(entity.size)
#! render sensor readings
# sensor1, sensor2, sensor3, sensor4 = entity.sensors(self.world)
# sens1 = rendering.make_circle(entity.size/4, x=sensor1[0],y=sensor1[1])
# sens2 = rendering.make_circle(entity.size/4, x=sensor2[0],y=sensor2[1])
# sens3 = rendering.make_circle(entity.size/4, x=sensor3[0],y=sensor3[1])
# sens4 = rendering.make_circle(entity.size/4, x=sensor4[0],y=sensor4[1])
xform = rendering.Transform()
if 'agent' in entity.name:
geom.set_color(*entity.color, alpha=0.5)
# sens1.set_color(*entity.color, alpha=0.5)
# sens2.set_color(*entity.color, alpha=0.5)
# sens3.set_color(*entity.color, alpha=0.5)
# sens4.set_color(*entity.color, alpha=0.5)
else:
geom.set_color(*entity.color)
geom.add_attr(xform)
# sens1.add_attr(xform)
# sens2.add_attr(xform)
# sens3.add_attr(xform)
# sens4.add_attr(xform)
# if line:line.add_attr(xform)
self.render_geoms.append(geom)
# self.render_geoms.append(sens1)
# self.render_geoms.append(sens2)
# self.render_geoms.append(sens3)
# self.render_geoms.append(sens4)
# if line:self.render_geoms.append(line)
self.render_geoms_xform.append(xform)
# add geoms to viewer
for viewer in self.viewers:
viewer.geoms = []
for geom in self.render_geoms:
viewer.add_geom(geom)
results = []
for i in range(len(self.viewers)):
from multiagent import rendering
# update bounds to center around agent
cam_range = 1
if self.shared_viewer:
pos = np.zeros(self.world.dim_p)
else:
pos = self.agents[i].state.p_pos
self.viewers[i].set_bounds(pos[0] - cam_range, pos[0] + cam_range,
pos[1] - cam_range, pos[1] + cam_range)
#! update geometry positions
for e, entity in enumerate(self.world.entities):
self.render_geoms_xform[e].set_translation(*entity.state.p_pos)
#! render to display or array
results.append(
self.viewers[i].render(return_rgb_array=mode == 'rgb_array'))
return results
def render(self, mode='human'): #, close=False): #close is dummy
if mode == 'human':
alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
for i in range(len(self.viewers)):
# create viewers (if necessary)
if self.viewers[i] is None:
# import rendering only if we need it (and don't import for headless machines)
#from gym.envs.classic_control import rendering
from multiagent import rendering
self.viewers[i] = rendering.Viewer(700, 700)
# create rendering geometry
if self.world.goals is not None:
vis_entities = self.world.entities + self.world.goals
else:
vis_entities = self.world.entities
if self.render_geoms is None:
# import rendering only if we need it (and don't import for headless machines)
#from gym.envs.classic_control import rendering
from multiagent import rendering
self.render_geoms = []
self.render_geoms_xform = []
for entity in vis_entities:
if "border" in entity.name:
geom = rendering.make_polygon(entity.shape)
else:
geom = rendering.make_circle(entity.size)
xform = rendering.Transform()
if 'goal' in entity.name or "target" in entity.name or 'landmark' in entity.name:
geom.set_color(*entity.color, alpha=0.3)
else:
geom.set_color(*entity.color)
geom.add_attr(xform)
self.render_geoms.append(geom)
self.render_geoms_xform.append(xform)
# add geoms to viewer
for viewer in self.viewers:
viewer.geoms = []
for geom in self.render_geoms:
viewer.add_geom(geom)
results = []
for i in range(len(self.viewers)):
from multiagent import rendering
# update bounds to center around agent
cam_range = self.world.x_range[1] / 2.0 + 0.5
if self.shared_viewer:
if self.world.dim_p == 1:
pos = np.array([self.world.x_range[1] / 2.0, 0])
else:
pos = np.array([
self.world.x_range[1] / 2.0,
self.world.y_range[1] / 2.0
])
else:
pos = self.agents[i].state.p_pos
self.viewers[i].set_bounds(pos[0] - cam_range, pos[0] + cam_range,
pos[1] - cam_range, pos[1] + cam_range)
# update geometry positions
for e, entity in enumerate(vis_entities):
if self.world.dim_p == 1:
translation = np.concatenate(
(entity.state.p_pos, np.array([0])), axis=0)
self.render_geoms_xform[e].set_translation(*translation)
else:
self.render_geoms_xform[e].set_translation(
*entity.state.p_pos)
# render to display or array
results.append(
self.viewers[i].render(return_rgb_array=mode == 'rgb_array'))
return results
def render(self, mode='human'):
if mode == 'human':
alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
message = ''
for agent in self.world.agents:
comm = []
for other in self.world.agents:
if other is agent: continue
if np.all(other.state.c == 0):
word = '_'
else:
word = alphabet[np.argmax(other.state.c)]
message += (other.name + ' to ' + agent.name + ': ' +
word + ' ')
# print(message)
for i in range(len(self.viewers)):
# create viewers (if necessary)
if self.viewers[i] is None:
# import rendering only if we need it (and don't import for headless machines)
#from gym.envs.classic_control import rendering
# from multiagent import rendering
self.viewers[i] = rendering.Viewer(700, 700)
# create rendering geometry
if self.render_geoms is None:
self.render_geoms = []
self.render_geoms_xform = []
self.extra_geoms = []
# self.extra_geoms_xform = []
for entity in self.world.entities:
geom = rendering.make_circle(entity.size)
xform = rendering.Transform()
if 'agent' in entity.name:
geom.set_color(*entity.color, alpha=0.5)
else:
geom.set_color(*entity.color)
geom.add_attr(xform)
self.render_geoms.append(geom)
self.render_geoms_xform.append(xform)
if self.world.visualize_embedding and isinstance(
entity, Agent) and not entity.adversary:
# add embedding
angles = np.linspace(0,
2 * np.pi,
len(self.world.embedding),
endpoint=False)
# positions
points = [
0.25 *
np.array([np.cos(theta), np.sin(theta)])
for theta in angles
]
# print(ttt)
import matplotlib.pyplot as plt
palette = plt.get_cmap('coolwarm')
# add embedding points to visualization
for p, e in zip(points, self.world.embedding):
# print(p)
# print(e)
# print(palette(e))
color = palette(e)
geom = rendering.make_circle(0.05)
xform_2 = rendering.Transform(translation=tuple(p))
geom.set_color(color[0], color[1], color[2], alpha=1.0)
geom.add_attr(xform)
geom.add_attr(xform_2)
self.extra_geoms.append(geom)
for wall in self.world.walls:
corners = ((wall.axis_pos - 0.5 * wall.width,
wall.endpoints[0]),
(wall.axis_pos - 0.5 * wall.width,
wall.endpoints[1]),
(wall.axis_pos + 0.5 * wall.width,
wall.endpoints[1]),
(wall.axis_pos + 0.5 * wall.width,
wall.endpoints[0]))
if wall.orient == 'H':
corners = tuple(c[::-1] for c in corners)
geom = rendering.make_polygon(corners)
if wall.hard:
geom.set_color(*wall.color)
else:
geom.set_color(*wall.color, alpha=0.5)
self.render_geoms.append(geom)
# add geoms to viewer
for viewer in self.viewers:
viewer.geoms = []
for geom in self.render_geoms:
viewer.add_geom(geom)
for extra in self.extra_geoms:
viewer.add_geom(extra)
results = []
for i in range(len(self.viewers)):
# update bounds to center around agent
cam_range = self.world.size / 2
if self.shared_viewer:
if self.world.torus:
# coords in range [0, w]
pos = np.array([self.world.size / 2, self.world.size / 2])
else:
# coords in range [-w/2, w/2]
cam_range = self.world.size / 2 + 0.1
pos = np.zeros(self.world.dim_p)
else:
pos = self.agents[i].state.p_pos
self.viewers[i].set_bounds(pos[0] - cam_range, pos[0] + cam_range,
pos[1] - cam_range, pos[1] + cam_range)
# update geometry positions
for e, entity in enumerate(self.world.entities):
self.render_geoms_xform[e].set_translation(*entity.state.p_pos)
if isinstance(entity, Agent):
if entity.captured:
self.render_geoms[e].set_color(0.0, 0.0, 0.0, 1.0)
else:
self.render_geoms[e].set_color(*entity.color, 0.5)
if self.world.visualize_embedding and isinstance(
entity, Agent) and not entity.adversary:
# add embedding
angles = np.linspace(0,
2 * np.pi,
len(self.world.embedding),
endpoint=False)
# positions
points = [
0.25 * np.array([np.cos(theta),
np.sin(theta)])
for theta in angles
]
import matplotlib.pyplot as plt
palette = plt.get_cmap('coolwarm')
# print(self.world.embedding)
# add embedding points to visualization
for idx in range(len(self.extra_geoms)):
# print(p)
# print(e)
# print(palette(e))
color = palette(self.world.embedding[idx])
# geom = rendering.make_circle(0.05)
# xform_2 = rendering.Transform(translation=tuple(p))
self.extra_geoms[idx].set_color(color[0],
color[1],
color[2],
alpha=1.0)
# geom.add_attr(xform)
# geom.add_attr(xform_2)
# self.extra_geoms.append(geom)
# for g, geom in enumerate(self.extra_geoms):
# render to display or array
results.append(
self.viewers[i].render(return_rgb_array=mode == 'rgb_array'))
return results
def render(self, mode='human'):
if mode == 'human':
alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
message = ''
for agent in self.world.agents:
comm = []
for other in self.world.agents:
if other is agent: continue
if np.all(other.state.c == 0):
word = '_'
else:
word = alphabet[np.argmax(other.state.c)]
message += (other.name + ' to ' + agent.name + ': ' +
word + ' ')
# print(message)
# ipdb.set_trace()
for i in range(len(self.viewers)):
# create viewers (if necessary)
if self.viewers[i] is None:
# import rendering only if we need it (and don't import for headless machines)
# from gym.envs.classic_control import rendering
from multiagent import rendering
self.viewers[i] = rendering.Viewer(400, 400)
# create rendering geometry
# NOTE: this is true only for the first time render function is called
# to modify rendering (removing obstacles or robots), you need to remove
# geom from self.render_geoms
if self.render_geoms is None:
# import rendering only if we need it (and don't import for headless machines)
#from gym.envs.classic_control import rendering
from multiagent import rendering
self.render_geoms = []
self.render_geoms_xform = []
for entity in self.world.entities:
# ugly hack to determine obstacles
# NOTE: this if statement is never called as of now
if hasattr(entity, "vertices"):
geom = rendering.make_polygon(entity.vertices)
else:
geom = rendering.make_circle(entity.size)
xform = rendering.Transform()
if 'agent' in entity.name:
geom.set_color(*entity.color, alpha=1.0)
else:
geom.set_color(*entity.color)
geom.add_attr(xform)
self.render_geoms.append(geom)
self.render_geoms_xform.append(xform)
# add geoms to viewer
for viewer in self.viewers:
viewer.geoms = []
for geom in self.render_geoms:
viewer.add_geom(geom)
results = []
for i in range(len(self.viewers)):
from multiagent import rendering
# update bounds to center around agent
cam_range = 1
if self.shared_viewer:
pos = np.zeros(self.world.dim_p)
else:
pos = self.agents[i].state.p_pos
self.viewers[i].set_bounds(pos[0] - cam_range, pos[0] + cam_range,
pos[1] - cam_range, pos[1] + cam_range)
# update geometry positions
for e, entity in enumerate(self.world.entities):
self.render_geoms_xform[e].set_translation(*entity.state.p_pos)
# render to display or array
results.append(
self.viewers[i].render(return_rgb_array=mode == 'rgb_array'))
return results
