def rollout(device, vision, action, n_steps=200):
race_config = pystk.RaceConfig(num_kart=1,
track='icy_soccer_field',
mode=pystk.RaceConfig.RaceMode.SOCCER)
o = pystk.PlayerConfig(controller=pystk.PlayerConfig.Controller.AI_CONTROL,
team=0)
race_config.players.append(o)
k = pystk.Race(race_config)
k.start()
for i in range(5): #Skip the first 5 steps since its the game starting
k.step()
try:
data = []
for n in range(n_steps):
k.step()
la = k.last_action[0]
data.append(
(np.array(k.render_data[0].image), (la.steer, la.acceleration,
la.brake)
)) #TODO: remove /10 later 3 in this script and 1 in player
finally:
k.stop()
del k
return data
def reset(self):
self.curr_iter = 0
self.prev_distance = 0
#race_config = pystk.RaceConfig()
race_config = pystk.RaceConfig(
num_kart=6, mode=pystk.RaceConfig.RaceMode.FREE_FOR_ALL)
race_config.players[
0].controller = pystk.PlayerConfig.Controller.PLAYER_CONTROL
race_config.players[0].kart = "gnu"
race_config.track = 'battleisland'
race_config.step_size = 0.1
if self.race != None:
inst = np.asarray(self.race.render_data[0].instance) >> 24
img = np.asarray(self.race.render_data[0].image) / 255
#i = np.concatenate((img,inst[..., np.newaxis]), axis=2)
i = img
self.race.stop()
self.race = None
self.race = pystk.Race(race_config)
self.race.start()
self.race.step()
# return obs
inst = np.asarray(self.race.render_data[0].instance) >> 24
img = np.asarray(self.race.render_data[0].image) / 255
#i = np.concatenate((img,inst[..., np.newaxis]), axis=2)
i = img
return i
def rollout_agent(device, vision, action, n_steps=200):
race_config = pystk.RaceConfig(num_kart=1,
track='icy_soccer_field',
mode=pystk.RaceConfig.RaceMode.SOCCER)
k = pystk.Race(race_config)
k.start()
for i in range(5): #Skip the first 5 steps since its the game starting
k.step()
try:
data = []
for n in range(n_steps):
img = torch.tensor(np.array(k.render_data[0].image),
dtype=torch.float).to(device).permute(2, 0, 1)
# heatmap = vision(img)
# p = action(torch.sigmoid(heatmap))[0]
p = action(img)[0]
# print(p[0])
k.step(
pystk.Action(steer=float(p[0]),
acceleration=float(p[1]),
brake=float(p[2]) > 0.5)) #TODO: remove /10 later
# print(pystk.Action(acceleration=float(p[0]), steer=float(p[1]), brake=float(p[2])>0.5))
la = k.last_action[0]
# print((la.acceleration, la.steer, la.brake))
# print('end')
data.append((np.array(k.render_data[0].image),
(la.steer, la.acceleration,
la.brake))) #TODO: remove /10 later
finally:
k.stop()
del k
return data
def __init__(self,
players,
screen_width=400,
screen_height=300,
track='icy_soccer_field'):
assert Tournament._singleton is None, "Cannot create more than one Tournament object"
Tournament._singleton = self
self.graphics_config = pystk.GraphicsConfig.hd()
self.graphics_config.screen_width = screen_width
self.graphics_config.screen_height = screen_height
pystk.init(self.graphics_config)
self.race_config = pystk.RaceConfig(
num_kart=len(players),
track=track,
mode=pystk.RaceConfig.RaceMode.SOCCER)
self.race_config.players.pop()
self.active_players = []
for p in players:
if p is not None:
self.race_config.players.append(p.config)
self.active_players.append(p)
self.k = pystk.Race(self.race_config)
self.k.start()
self.k.step()
def rollout(num_players=4,
max_steps=1000,
track='icy_soccer_field',
save='train_data_temp'):
config = pystk.GraphicsConfig.hd()
config.screen_width = 400
config.screen_height = 300
pystk.init(config)
race_config = pystk.RaceConfig(num_kart=num_players,
track=track,
mode=pystk.RaceConfig.RaceMode.SOCCER)
race_config.players.pop()
if not os.path.exists(save):
os.makedirs(save)
for i in range(num_players):
o = pystk.PlayerConfig(
controller=pystk.PlayerConfig.Controller.AI_CONTROL,
team=int((i + 1) % 2.0))
race_config.players.append(o)
active_players = race_config.players
print('Number of Players', len(active_players))
k = pystk.Race(race_config)
k.start()
k.step()
# all_images = []
all_actions = []
state = pystk.WorldState()
for t in range(max_steps):
print('step:', t)
state.update()
s = k.step()
t_actions = []
for i in range(num_players):
la = k.last_action[i]
img = np.array(k.render_data[i].image)
a = (img, la.steer, la.acceleration, la.brake)
t_actions.append(a)
if save is not None:
PIL.Image.fromarray(img).save(
os.path.join(save, 'player%02d_%05d.png' % (i, t)))
with open(os.path.join(save, 'player%02d_%05d.csv' % (i, t)),
mode='w') as new_data:
writer = csv.writer(new_data)
writer.writerow(a[1:])
all_actions.append(t_actions)
if not s:
break
print('score', state.soccer.score)
return all_actions
def rollout(epoch=0, num_players=2, max_steps=1000, track='icy_soccer_field', save='train_data_two_players'):
race_config = pystk.RaceConfig(num_kart=num_players, track=track, mode=pystk.RaceConfig.RaceMode.SOCCER, difficulty=2)
race_config.players.pop()
if not os.path.exists(save):
os.makedirs(save)
for i in range(num_players):
o = pystk.PlayerConfig(controller = pystk.PlayerConfig.Controller.AI_CONTROL, team = int(i%2.0))
race_config.players.append(o)
active_players = race_config.players
print('Number of Players',len(active_players))
k = pystk.Race(race_config)
k.start()
try:
k.step()
# all_images = []
all_actions = []
state = pystk.WorldState()
state.update()
# print(dir(state.players[0].kart))
# input()
for t in range(max_steps):
# print('step:',t)
state.update()
s = k.step()
t_actions = []
for i in range(num_players):
la = k.last_action[i]
img = np.array(k.render_data[i].image)
a = [img, la.steer, la.acceleration, la.brake]
a.extend(state.players[0].kart.rotation)
a.extend(state.players[0].kart.velocity)
a.extend(state.players[0].kart.location)
t_actions.append(a)
if save is not None:
PIL.Image.fromarray(img).save(os.path.join(save, 'player_%05d_%02d_%05d.png' % (epoch, i, t)))
with open(os.path.join(save, 'player_%05d_%02d_%05d.csv' % (epoch, i, t)), mode='w') as new_data:
writer = csv.writer(new_data)
writer.writerow(a[1:])
all_actions.append(t_actions)
if not s:
break
print('epoch',e,'score',state.soccer.score)
finally:
k.stop()
del k
return all_actions
def _test(self, track, max_frames):
config = pystk.RaceConfig(num_kart=1, laps=1)
config.track = track
config.players[
0].controller = pystk.PlayerConfig.Controller.PLAYER_CONTROL
config.render = self.P is not None
k = pystk.Race(config)
try:
state = pystk.WorldState()
track = pystk.Track()
k.start()
k.step()
last_rescue = 0
for t in range(max_frames):
state.update()
track.update()
kart = state.players[0].kart
if kart.race_result:
break
if self.P is None:
aim_point_world = self._point_on_track(
kart.distance_down_track + TRACK_OFFSET, track)
else:
image = np.array(k.render_data[0].image)
aim_point_image = self.P(
TF.to_tensor(image)[None]).squeeze(0)
proj = np.array(state.players[0].camera.projection).T
view = np.array(state.players[0].camera.view).T
aim_point_world = self._to_world(aim_point_image, proj,
view, kart.location[1])
aim_point_car = self._to_kart(aim_point_world, kart)
current_vel = np.linalg.norm(kart.velocity)
action = self.C(aim_point_car, current_vel)
if current_vel <= 1.0 and t - last_rescue > RESCUE_TIMEOUT:
action.rescue = True
last_rescue = t
k.step(action)
finally:
k.stop()
del k
if kart.race_result:
return 1, '%0.1f s' % kart.finish_time
return kart.overall_distance / track.length, '%0.1f%% done' % (
100 * kart.overall_distance / track.length)
def main():
config = pystk.GraphicsConfig.hd()
config.screen_width = 800
config.screen_height = 600
pystk.init(config)
config = pystk.RaceConfig()
config.num_kart = 2
# config.track ='battleisland'
config.track = 'stadium'
config.players[0].controller = pystk.PlayerConfig.Controller.PLAYER_CONTROL
config.players[0].team = 0
# NOTE: Add 4 players
for _ in range(3):
config.players.append(
# pystk.PlayerConfig(args.kart, pystk.PlayerConfig.Controller.AI_CONTROL, (args.team + 1) % 2))
pystk.PlayerConfig('', pystk.PlayerConfig.Controller.AI_CONTROL,
1))
config.mode = config.RaceMode.THREE_STRIKES
# TODO: Look at step size?
# config.step_size = args.step_size
race = pystk.Race(config)
race.start()
race.step()
uis = [gui.UI(gui.VT['IMAGE']) for i in range(4)]
state = pystk.WorldState()
state.update()
t0 = time()
if not all(ui.pause for ui in uis):
race.step(uis[0].current_action)
state.update()
for ui, d in zip(uis, race.render_data):
ui.show(d)
input('press enter to continue')
race.stop()
del race
pystk.clean()
def _race(self, drive, track_name, time_limit=1200):
distance = 0.
total_length = 1.0
try:
config = pystk.RaceConfig(laps=1)
config.players[0].controller = pystk.PlayerConfig.Controller.PLAYER_CONTROL
config.track = track_name
config.step_size = 0.1
race = pystk.Race(config)
race.start()
race.step()
track = pystk.Track()
track.update()
total_length = track.length
for t in range(time_limit):
state = pystk.WorldState()
state.update()
kart = state.players[0].kart
if kart.race_result:
distance = total_length
break
distance = state.karts[0].distance_down_track
image = 1*np.asarray(race.render_data[0].image)
action = drive(image)
race.step(action)
finally:
race.stop()
del race
return distance / total_length
def __init__(self, track):
config = pystk.GraphicsConfig.ld()
config.screen_width = 64
config.screen_height = 64
config.render_window = False
pystk.init(config)
race_config = pystk.RaceConfig()
race_config.players[0].controller = pystk.PlayerConfig.Controller.PLAYER_CONTROL
race_config.track = track
race_config.step_size = 0.1
race_config.render = True
self.race = pystk.Race(race_config)
self.race.start()
self.race.step()
self.track = pystk.Track()
self.track.update()
def start(self, config: pystk.RaceConfig = None, track_name='lighthouse'):
if config is None:
config = pystk.RaceConfig()
config.players[
0].controller = pystk.PlayerConfig.Controller.PLAYER_CONTROL
config.track = track_name
config.step_size = 0.1
if self.race is not None:
self.race.stop()
del self.race
self.config = config
self.race = pystk.Race(config)
self.race.start()
self.track = pystk.Track()
self.track.update()
def _race(self, drive, track_name, time_limit=1200):
total_length = 1.0
score = 0.
try:
config = pystk.RaceConfig(
num_kart=6,
track=track_name,
mode=pystk.RaceConfig.RaceMode.FREE_FOR_ALL)
config.players[
0].controller = pystk.PlayerConfig.Controller.PLAYER_CONTROL
config.step_size = 0.1
race = pystk.Race(config)
race.start()
race.step()
for t in range(time_limit):
state = pystk.WorldState()
state.update()
scores = state.ffa.scores
kart = state.players[0].kart
action = drive(np.asarray(race.render_data[0].image), kart)
race.step(action)
rank = sorted(scores, reverse=True).index(scores[kart.id])
score = {0: 10, 1: 8, 2: 6}.get(rank, 7 - rank)
finally:
race.stop()
del race
return score / 10.
def __init__(self, track: str):
config = pystk.GraphicsConfig.ld()
config.screen_width = 64
config.screen_height = 64
config.render_window = False
pystk.init(config)
race_config = pystk.RaceConfig()
race_config.num_kart = 4
race_config.players[
0].controller = pystk.PlayerConfig.Controller.PLAYER_CONTROL
race_config.players[0].team = 0
race_config.players[
1].controller = pystk.PlayerConfig.Controller.PLAYER_CONTROL
race_config.players[1].team = 0
race_config.players[
2].controller = pystk.PlayerConfig.Controller.PLAYER_CONTROL
race_config.players[2].team = 1
race_config.players[
3].controller = pystk.PlayerConfig.Controller.PLAYER_CONTROL
race_config.players[2].team = 1
race_config.track = track
race_config.step_size = 0.1
race_config.render = False
race_config.mode = race_config.RaceMode.THREE_STRIKES
self.race = pystk.Race(race_config)
self.race.start()
self.race.step()
self.track = pystk.Track()
self.track.update()
def rollout(self,
track,
controller,
planner=None,
max_frames=1000,
verbose=False,
data_callback=None):
"""
Play a level (track) for a single round.
:param track: Name of the track
:param controller: low-level controller, see controller.py
:param planner: high-level planner, see planner.py
:param max_frames: Maximum number of frames to play for
:param verbose: Should we use matplotlib to show the agent drive?
:param data_callback: Rollout calls data_callback(time_step, image, 2d_aim_point) every step, used to store the
data
:return: Number of steps played
"""
do_render = verbose or planner is not None or data_callback is not None
if self.k is not None and self.k.config.track == track and do_render == self.k.config.render:
self.k.restart()
self.k.step()
else:
if self.k is not None:
self.k.stop()
del self.k
config = pystk.RaceConfig(num_kart=1,
laps=1,
render=do_render,
track=track)
config.players[
0].controller = pystk.PlayerConfig.Controller.PLAYER_CONTROL
self.k = pystk.Race(config)
self.k.start()
self.k.step()
state = pystk.WorldState()
track = pystk.Track()
last_rescue = 0
if verbose:
import matplotlib.pyplot as plt
fig, ax = plt.subplots(1, 1)
for t in range(max_frames):
state.update()
track.update()
kart = state.players[0].kart
if np.isclose(kart.overall_distance / track.length, 1.0,
atol=2e-3):
if verbose:
print("Finished at t=%d" % t)
break
proj = np.array(state.players[0].camera.projection).T
view = np.array(state.players[0].camera.view).T
if data_callback is not None:
aim_point_world = self._point_on_track(
kart.distance_down_track + 20, track)
ap = self._to_image(aim_point_world, proj, view)
if 0 <= ap[0] < self.config.screen_width and 0 <= ap[
1] < self.config.screen_height:
data_callback(t, np.array(self.k.render_data[0].image), ap)
if planner:
image = np.array(self.k.render_data[0].image)
aim_point_image = planner(TF.to_tensor(image)[None]).squeeze(0)
aim_point_world = self._to_world(aim_point_image, proj, view,
kart.location[1])
else:
aim_point_world = self._point_on_track(
kart.distance_down_track + TRACK_OFFSET, track)
aim_point_car = self._to_kart(aim_point_world, kart)
current_vel = np.linalg.norm(kart.velocity)
action = controller(aim_point_car, current_vel)
if current_vel < 1.0 and t - last_rescue > RESCUE_TIMEOUT:
last_rescue = t
action.rescue = True
if verbose:
ax.clear()
ax.imshow(self.k.render_data[0].image)
ax.add_artist(
plt.Circle(self._to_image(kart.location, proj, view),
2,
ec='b',
fill=False,
lw=1.5))
ax.add_artist(
plt.Circle(self._to_image(aim_point_world, proj, view),
2,
ec='r',
fill=False,
lw=1.5))
if planner:
ap = self._point_on_track(
kart.distance_down_track + TRACK_OFFSET, track)
ax.add_artist(
plt.Circle(self._to_image(ap, proj, view),
2,
ec='g',
fill=False,
lw=1.5))
plt.pause(1e-3)
self.k.step(action)
t += 1
return t
def rollout(self,
track,
controller,
planner=None,
max_frames=1000,
verbose=False,
data_callback=None):
"""
Play a level (track) for a single round.
:param track: Name of the track
:param controller: low-level controller, see controller.py
:param planner: high-level planner, see planner.py
:param max_frames: Maximum number of frames to play for
:param verbose: Should we use matplotlib to show the agent drive?
:param data_callback: Rollout calls data_callback(time_step, image, 2d_aim_point) every step, used to store the
data
:return: Number of steps played
"""
if self.k is not None and self.k.config.track == track:
self.k.restart()
self.k.step()
else:
if self.k is not None:
self.k.stop()
del self.k
config = pystk.RaceConfig(num_kart=1,
laps=1,
render=True,
track=track)
config.players[
0].controller = pystk.PlayerConfig.Controller.PLAYER_CONTROL
self.k = pystk.Race(config)
self.k.start()
self.k.step()
state = pystk.WorldState()
track = pystk.Track()
last_rescue = 0
if verbose and not ON_COLAB:
import matplotlib.pyplot as plt
fig, ax = plt.subplots(1, 1)
elif verbose and ON_COLAB:
global COLAB_IMAGES
COLAB_IMAGES = list()
for t in range(max_frames):
state.update()
track.update()
kart = state.players[0].kart
if np.isclose(kart.overall_distance / track.length, 1.0,
atol=2e-3):
if verbose:
print("Finished at t=%d" % t)
break
proj = np.array(state.players[0].camera.projection).T
view = np.array(state.players[0].camera.view).T
aim_point_world = self._point_on_track(
kart.distance_down_track + TRACK_OFFSET, track)
aim_point_image = self._to_image(aim_point_world, proj, view)
aim_point = aim_point_image
if data_callback is not None:
data_callback(t, np.array(self.k.render_data[0].image),
aim_point_image)
if planner:
image = np.array(self.k.render_data[0].image)
aim_point = planner(TF.to_tensor(image)[None]).squeeze(
0).cpu().detach().numpy()
current_vel = np.linalg.norm(kart.velocity)
action = controller(aim_point, current_vel)
if current_vel < 1.0 and t - last_rescue > RESCUE_TIMEOUT:
last_rescue = t
action.rescue = True
if verbose and not ON_COLAB:
ax.clear()
ax.imshow(self.k.render_data[0].image)
WH2 = np.array(
[self.config.screen_width, self.config.screen_height]) / 2
ax.add_artist(
plt.Circle(WH2 *
(1 + self._to_image(kart.location, proj, view)),
2,
ec='b',
fill=False,
lw=1.5))
ax.add_artist(
plt.Circle(
WH2 *
(1 + self._to_image(aim_point_world, proj, view)),
2,
ec='r',
fill=False,
lw=1.5))
if planner:
ap = self._point_on_track(
kart.distance_down_track + TRACK_OFFSET, track)
ax.add_artist(
plt.Circle(WH2 * (1 + aim_point_image),
2,
ec='g',
fill=False,
lw=1.5))
plt.pause(1e-3)
elif verbose and ON_COLAB:
from PIL import Image, ImageDraw
image = Image.fromarray(self.k.render_data[0].image)
draw = ImageDraw.Draw(image)
WH2 = np.array(
[self.config.screen_width, self.config.screen_height]) / 2
p = (aim_point_image + 1) * WH2
draw.ellipse((p[0] - 2, p[1] - 2, p[0] + 2, p[1] + 2),
fill=(255, 0, 0))
if planner:
p = (aim_point + 1) * WH2
draw.ellipse((p[0] - 2, p[1] - 2, p[0] + 2, p[1] + 2),
fill=(0, 255, 0))
COLAB_IMAGES.append(np.array(image))
self.k.step(action)
t += 1
if verbose and ON_COLAB:
show_on_colab()
return t, kart.overall_distance / track.length
parser.add_argument('-n', '--num_player', type=int, default=1)
args = parser.parse_args()
for config in [pystk.GraphicsConfig.ld(), pystk.GraphicsConfig.sd(), pystk.GraphicsConfig.hd(), None]:
print(config)
t0 = time()
render = True
if config is None:
config = pystk.GraphicsConfig.ld()
render = False
config.screen_width = 320
config.screen_height = 240
pystk.init(config)
init_time, t0 = time() - t0, time()
config = pystk.RaceConfig(render=render)
if args.kart != '':
config.players[0].kart = args.kart
if args.track is not None:
config.track = args.track
if args.step_size is not None:
config.step_size = args.step_size
for i in range(1, args.num_player):
config.players.append(pystk.PlayerConfig(args.kart, pystk.PlayerConfig.Controller.AI_CONTROL))
race = pystk.Race(config)
race_time, t0 = time() - t0, time()
race.start()
race.step()
start_time, t0 = time() - t0, time()
parser.add_argument('-n', '--num_player', type=int, default=1)
parser.add_argument('-v', '--visualization', type=str, choices=list(gui.VT.__members__), nargs='+',
default=['IMAGE'])
parser.add_argument('--verbose', action='store_true')
parser.add_argument('--save_dir', type=Path, required=False)
args = parser.parse_args()
if args.save_dir:
args.save_dir.mkdir(parents=True, exist_ok=True)
config = pystk.GraphicsConfig.hd()
config.screen_width = 400
config.screen_height = 300
pystk.init(config)
config = pystk.RaceConfig()
config.num_kart = 2
if args.kart is not None:
config.players[0].kart = args.kart
config.players[0].controller = pystk.PlayerConfig.Controller.PLAYER_CONTROL
config.players[0].team = args.team
for i in range(1, args.num_player):
config.players.append(
pystk.PlayerConfig(args.kart, pystk.PlayerConfig.Controller.AI_CONTROL, (args.team + 1) % 2))
if args.track is not None:
config.track = args.track
if args.track in soccer_tracks:
config.mode = config.RaceMode.SOCCER
import pystk
def test(o):
from pickle import dumps, loads
print(o)
s = dumps(o)
print(len(s))
print(loads(s))
test(pystk.GraphicsConfig.ld())
test(pystk.RaceConfig())
pystk.init(pystk.GraphicsConfig.ld())
config = pystk.RaceConfig()
k = pystk.Race(config)
k.start()
state = pystk.WorldState()
track = pystk.Track()
for it in range(10):
k.step()
state.update()
track.update()
test(state)
test(track)
test(k.last_action)
test(k.render_data)
