def rollout(self,
drive,
reward_func,
max_step: float = 1200,
restart: bool = True):
"""
:param return_data: what data should we return? 'action', 'image', 'next_image', 'done', 'reward'
:return:
"""
import collections
Data = collections.namedtuple('Data',
'action image reward done next_image')
assert self.race is not None, "You need to start the case before the rollout"
if restart:
self.race.restart()
self.race.step()
action = pystk.Action()
result = []
state = pystk.WorldState()
state.update()
i = 1 * np.asarray(self.race.render_data[0].image)
total_reward = 0.
for it in range(max_step):
state = pystk.WorldState()
state.update()
a = drive(i)
self.race.step(a)
next_i = 1 * np.asarray(self.race.render_data[0].image)
d = (it + 1 == max_step) # Feel free to experiment with this
r = reward_func(state)
total_reward += r
result.append(
Data(image=i, action=a, reward=r, next_image=next_i, done=d))
i = next_i
if d:
break
return result, total_reward
def play(self, save=None, max_frames=50):
state = pystk.WorldState()
track = pystk.Track()
if save is not None:
import PIL.Image
import os
if not os.path.exists(save):
os.makedirs(save)
for t in range(max_frames):
print('\rframe %d' % t, end='\r')
state.update()
#print(state.soccer.ball.location)
#print(state.soccer.goal_line)
#goal_line = False
#opposing_goal = state.soccer.goal_line[:-1]
#goal_target = []
#if goal_line == True:
# goal_target = [statistics.mean([opposing_goal[0][0][0], opposing_goal[0][1][0]]), statistics.mean([opposing_goal[0][0][1], opposing_goal[0][1][1]]),statistics.mean([opposing_goal[0][0][2], opposing_goal[0][1][2]]), ]
list_actions = []
for i, p in enumerate(self.active_players):
kart = state.players[i].kart
aim_point_world = state.soccer.ball.location
proj = np.array(state.players[i].camera.projection).T
view = np.array(state.players[i].camera.view).T
aim_point_image = self._to_image(aim_point_world, proj, view)
player = state.players[i]
image = np.array(self.k.render_data[i].image)
action = pystk.Action()
player_action = p(image, player)
for a in player_action:
setattr(action, a, player_action[a])
list_actions.append(action)
if save is not None:
PIL.Image.fromarray(image).save(os.path.join(save, 'player%02d_%05d.png' % (i, t)))
dest = os.path.join(save, 'player%02d_%05d' % (i, t))
with open(dest + '.csv', 'w') as f:
f.write('%0.1f,%-0.1f' % tuple(aim_point_image))
s = self.k.step(list_actions)
if not s: # Game over
break
if save is not None:
import subprocess
for i, p in enumerate(self.active_players):
dest = os.path.join(save, 'player%02d' % i)
output = save + '_player%02d.mp4' % i
subprocess.call(['ffmpeg', '-y', '-framerate', '10', '-i', dest + '_%05d.png', output])
if hasattr(state, 'soccer'):
return state.soccer.score
return state.soccer_score
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 play(self, save=None, max_frames=50):
state = pystk.WorldState()
# soccer = pystk.Soccer()
# soccer_ball = pystk.SoccerBall()
if save is not None:
import PIL.Image
import os
if not os.path.exists(save):
os.makedirs(save)
time = datetime.now()
for t in range(max_frames):
# print('\rframe %d' % t, end='\r')
print('\rframe {} time {}'.format(t,
(datetime.now() - time).seconds),
end='\r')
state.update()
list_actions = []
for i, p in enumerate(self.active_players):
player = state.players[i]
image = np.array(self.k.render_data[i].image)
action = pystk.Action()
player_action = p(image, player)
for a in player_action:
setattr(action, a, player_action[a])
list_actions.append(action)
if save is not None:
PIL.Image.fromarray(image).save(
os.path.join(save, 'player%02d_%05d.png' % (i, t)))
s = self.k.step(list_actions)
if not s: # Game over
break
# print(state.soccer.score)
# print(state.soccer.ball.location)
# print(state.soccer.goal_line)
# print(state.karts[0].location)
# print(dir(state.karts[0]))
# print(t)
# print('end')
if save is not None:
import subprocess
for i, p in enumerate(self.active_players):
dest = os.path.join(save, 'player%02d' % i)
output = save + '_player%02d.mp4' % i
subprocess.call([
'ffmpeg', '-y', '-framerate', '10', '-i',
dest + '_%05d.png', output
])
if hasattr(state, 'soccer'):
return state.soccer.score
return state.soccer_score
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 play(self, save=None, max_frames=50):
state = pystk.WorldState()
if save is not None:
import PIL.Image
import os
if not os.path.exists(save):
os.makedirs(save)
for t in range(max_frames):
print('\rframe %d' % t, end='\r')
state.update()
list_info = []
list_actions = []
for i, p in enumerate(self.active_players):
player = state.players[i]
image = np.array(self.k.render_data[i].image)
action = pystk.Action()
player_action = p(image, player)
for a in player_action:
setattr(action, a, player_action[a])
list_actions.append(action)
if save is not None:
PIL.Image.fromarray(image).save(
os.path.join(save, 'player%02d_%05d.png' % (i, t)))
# self.uis[players.kart.player_id].show(self.k.render_data[players.kart.player_id])
# list_info = []
s = self.k.step(list_actions)
if not s: # Game over
break
# step 2 viz
# for ui, d in zip(self.uis, self.k.render_data):
# ui.show(d)
if save is not None:
import subprocess
for i, p in enumerate(self.active_players):
dest = os.path.join(save, 'player%02d' % i)
output = save + '_player%02d.mp4' % i
subprocess.call([
'ffmpeg', '-y', '-framerate', '10', '-i',
dest + '_%05d.png', output
])
if hasattr(state, 'soccer'):
return state.soccer.score
return state.soccer_score
def step(self, action):
self.curr_iter += 1
steer_dir = action[0]
gas = action[1]
brake = action[2]
fire = action[3]
#rescue = action[1]
action = pystk.Action(steer=steer_dir,
acceleration=gas,
brake=brake,
fire=fire) # , rescue=rescue)
self.race.step(action)
self.race.step(action)
self.race.step(action)
self.race.step(action)
self.race.step(action)
self.race.step(action)
self.race.step(action)
state = pystk.WorldState()
state.update()
scores = state.ffa.scores
kart = state.players[0].kart
rank = sorted(scores, reverse=True).index(scores[kart.id])
score = {0: 10, 1: 8, 2: 6}.get(rank, 7 - rank)
reward = score / 10
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
new_distance = state.karts[0].distance_down_track
delta = new_distance - self.prev_distance
is_stuck = (self.curr_iter > 10) and delta < 0.001
done = (self.curr_iter == self.max_step) or is_stuck
# if self.curr_iter % 6 == 0:
self.prev_distance = new_distance
# return <obs>, <reward: float>, <done: bool>, <info: dict>
return i, reward, done, {}
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 _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 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
if args.track is not None:
config.track = args.track
if args.track in soccer_tracks:
config.mode = config.RaceMode.SOCCER
if args.step_size is not None:
config.step_size = args.step_size
race = pystk.Race(config)
race.start()
uis = [gui.UI([gui.VT[x] for x in args.visualization]) for i in range(args.num_player)]
save_depth = "DEPTH" in args.visualization
save_labels = "SEMANTIC" in args.visualization or "INSTANCE" in args.visualization
state = pystk.WorldState()
t0 = time()
n = 0
while all(ui.visible for ui in uis):
if not all(ui.pause for ui in uis):
race.step(uis[0].current_action)
state.update()
if args.verbose and config.mode == config.RaceMode.SOCCER:
print('Score ', state.soccer.score)
print(' ', state.soccer.ball)
print(' ', state.soccer.goal_line)
for ui, d in zip(uis, race.render_data):
ui.show(d)
if args.save_dir:
def rollout(
self,
policy: policy.BasePolicy,
max_step: float = 100,
frame_skip: int = 0,
gamma: float = 1.0):
self.race.restart()
self.race.step(pystk.Action())
self.track.update()
result = list()
state = pystk.WorldState()
state.update()
r_total = 0
d = state.karts[0].distance_down_track
s = np.array(self.race.render_data[0].image)
off_track = deque(maxlen=20)
traveled = deque(maxlen=50)
for it in range(max_step):
# Early termination.
if it > 20 and (np.median(traveled) < 0.05 or all(off_track)):
break
v = np.linalg.norm(state.karts[0].velocity)
action, action_i, p_action = policy(s, v)
if isinstance(action, pystk.Action):
action_raw = [action.steer, action.acceleration, action.drift]
else:
action_raw = action
action = pystk.Action()
action.steer = action_raw[0]
action.acceleration = np.clip(action_raw[1] - v, 0, np.inf)
action.drift = action_raw[2] > 0.5
for _ in range(1 + frame_skip):
self.race.step(action)
self.track.update()
state = pystk.WorldState()
state.update()
s_p = np.array(self.race.render_data[0].image)
d_new = min(state.karts[0].distance_down_track, d + 5.0)
node_idx = np.searchsorted(
self.track.path_distance[:, 1],
d_new % self.track.path_distance[-1, 1]) % len(self.track.path_nodes)
a_b = self.track.path_nodes[node_idx]
distance = point_from_line(state.karts[0].location, a_b[0], a_b[1])
distance_traveled = get_distance(d_new, d, self.track.path_distance[-1, 1])
gain = distance_traveled if distance_traveled > 0 else 0
mult = int(distance < 6.0)
traveled.append(gain)
off_track.append(distance > 6.0)
r_total = max(r_total, d_new * mult)
r = np.clip(0.5 * max(mult * gain, 0) + 0.5 * mult, -1.0, 1.0)
result.append(
Data(
s.copy(),
np.float32(action_raw),
np.uint8([action_i]), np.float32([p_action]),
np.float32([r]), s_p.copy(),
np.float32([np.nan]),
np.float32([0])))
d = d_new
s = s_p
G = 0
# Ugly.
for i, data in enumerate(reversed(result)):
G = data.r + gamma * G
result[-(i + 1)] = Data(
data.s,
data.a, data.a_i, data.p_a,
data.r, data.sp,
np.float32([G]),
np.float32([i == 0]))
# HACK PLEASE REMEMBER THIS
return result[4:], r_total / self.track.path_distance[-1, 1]
def play(self, save=None, max_frames=50, save_callback=None):
global SAVE_COUNT, SAVE_AT
state = pystk.WorldState()
if save is not None:
import PIL.Image
if not os.path.exists(save):
os.makedirs(save)
# turn on interactive mode for controller visualization
plt.ion()
for t in range(max_frames):
print('\rframe %d' % t, end='\r')
state.update()
list_actions = []
for i, p in enumerate(self.active_players):
HACK_DICT['race'] = self.k
HACK_DICT['render_data'] = self.k.render_data[i]
HACK_DICT['kart'] = state.karts[i]
HACK_DICT['state'] = state
#print('kart: ', state.karts[i].name, '\t\t max_steer: ', "{:.4f}".format(state.karts[i].max_steer_angle))
player = state.players[i]
image = np.array(self.k.render_data[i].image)
action = pystk.Action()
player_action = p(image, player)
for a in player_action:
setattr(action, a, player_action[a])
list_actions.append(action)
if save is not None:
im = PIL.Image.fromarray(image)
#draw = ImageDraw.Draw(im)
#draw.text((0, 0),"Sample Text",(255,255,255))
im.save(os.path.join(save, 'player%02d_%05d.png' % (i, t)))
for i, action in enumerate(list_actions):
HACK_DICT['player_%d' % i] = {
'steer': action.steer,
'acceleration': action.acceleration
}
if save_callback is not None:
save_callback(self.k, state, t, HACK_DICT)
SAVE_COUNT += 1
s = self.k.step(list_actions)
if not s: # Game over
break
if save is not None:
import subprocess
for i, p in enumerate(self.active_players):
dest = os.path.join(save, 'player%02d' % i)
output = 'videos/_player%02d.mp4' % i
subprocess.call([
'ffmpeg', '-y', '-framerate', '10', '-i',
dest + '_%05d.png', output
])
if hasattr(state, 'soccer'):
return state.soccer.score
return state.soccer_score
def act(self, image, player_info):
world = pystk.WorldState()
world.update()
kart0 = world.karts[2]
pos_ball = to_numpy(world.soccer.ball.location)
pos_me1 = to_numpy(kart0.location)
"""
Set the action given the current image
:param image: numpy array of shape (300, 400, 3)
:param player_info: pystk.Player object for the current kart.
return: Dict describing the action
"""
# pos_me[1] is up and down
action = {
'acceleration': 0,
'brake': False,
'drift': False,
'nitro': False,
'rescue': False,
'steer': 0
}
angle_kart1 = quaternion_to_euler(kart0.rotation[0], kart0.rotation[1],
kart0.rotation[2], kart0.rotation[3])
angle_puck = math.degrees(
math.atan((pos_ball[0] - pos_me1[0]) / (pos_ball[1] - pos_me1[1])))
# print(pos_ball[0]-pos_me[0])
# print(pos_ball[1]-pos_me[1])
# print(pos_ball[1], pos_me[1], pos_ball[0], pos_me[0])
# print(angle_puck)
# print(angle_kart)
# print(pos_me1[1])
global forward
if pos_ball[1] - pos_me1[1] > 10 and abs(angle_kart1 -
angle_puck) < 20:
forward = 1
if pos_ball[1] - pos_me1[1] > 15 and abs(angle_kart1 -
angle_puck) < 40:
forward = 1
if pos_ball[1] - pos_me1[1] > 25 or abs(angle_kart1 - angle_puck) < 15:
forward = 1
if pos_ball[1] - pos_me1[
1] > 0 and angle_kart1 < angle_puck and forward == 1:
action['steer'] = 1
action['acceleration'] = 1
if pos_ball[1] - pos_me1[
1] > 0 and angle_kart1 > angle_puck and forward == 1:
action['steer'] = -1
action['acceleration'] = 1
if pos_ball[1] - pos_me1[1] < 0 and angle_kart1 > 0:
forward = 0
action['steer'] = 1
action['brake'] = True
action['acceleration'] = 0
if pos_ball[1] - pos_me1[1] < 0 and angle_kart1 < 0:
forward = 0
action['steer'] = -1
action['brake'] = True
action['acceleration'] = 0
if forward == 0 and angle_kart1 > 0:
action['steer'] = 1
action['brake'] = True
action['acceleration'] = 0
if forward == 0 and angle_kart1 < 0:
action['steer'] = -1
action['brake'] = True
action['acceleration'] = 0
# if angle_kart1 > 80:
# action['acceleration'] = .7
# if angle_kart1 < -80:
# action['acceleration'] = .7
# if world.karts[0].velocity == 0 and angle_kart1 < 0:
# action['steer'] = -1
# action['brake'] = True
# action['acceleration'] = 0
# if world.karts[0].velocity == 0 and angle_kart1 > 0:
# action['steer'] = 1
# action['brake'] = True
# action['acceleration'] = 0
# if angle_puck > 80:
# action['steer'] = 1
# action['brake'] = True
# action['acceleration'] = 0
# if angle_puck < -80:
# action['steer'] = -1
# action['brake'] = True
# action['acceleration'] = 0
"""
Your code here.
"""
return action
def play(self, save=None, max_frames=50):
state = pystk.WorldState()
import PIL.Image
import os
prev_score = [0, 0]
for t in range(max_frames):
#print('\rframe %d' % t, end='\r')
state.update()
#print some info
test = True
if test:
#print('soccer ball location', state.soccer.ball.location)
#print('soccer ball location', state.soccer.ball.location[1])
#print('soccer ball location', state.soccer.ball.location[2])
#print('kart 1 location', state.karts[0].location)
#print('kart 2 location', state.karts[1].location)
#print('kart 3 location', state.karts[2].location)
#print('kart 4 location', state.karts[3].location)
#print('score', state.soccer.score)
if prev_score != state.soccer.score:
print("Scored: ", state.soccer.score, " at frame ", t)
prev_score = state.soccer.score
"""
goal = state.soccer.goal_line[0][0]
print('Goal Poistion: ', goal[0],",", goal[1], ",",goal[2])
goal1 = state.soccer.goal_line[0][1]
print('Goal Poistion: ', goal1[0],",", goal1[1], ",",goal1[2])
"""
#for kart in state.karts:
#print(kart.location)
#print('goal line', state.soccer.goal_line[0][0])
#print('goal line', state.soccer.goal_line[0][0][0])
#print('goal line', state.soccer.goal_line[0][0][1])
#print('goal line', state.soccer.goal_line[0][0][2])
#print("Soccer location: ", state.soccer.ball.location)
#aim_point_car = self._to_kart(np.array(state.soccer.ball.location), state.karts[0])
#print("Soccer location to car: ", aim_point_car )
list_actions = []
for i, p in enumerate(self.active_players):
player = state.players[i]
image = np.array(self.k.render_data[i].image)
action = pystk.Action()
#print('soccer ball location', state.soccer.ball.location)
#player_action = p( state.soccer, player)
player_action = p(image, player, state.soccer.ball.location)
for a in player_action:
setattr(action, a, player_action[a])
list_actions.append(action)
proj = np.array(player.camera.projection).T
view = np.array(player.camera.view).T
# print(state.players)
#Generate labels for training sets
aim_point_world_soccer = state.soccer.ball.location
aps = self._to_image(aim_point_world_soccer, proj, view)
#print(state.soccer.goal_line )
list = [[
state.soccer.ball.size / 2, 0.18,
state.soccer.ball.size / 2
],
[
state.soccer.ball.size / 2, 0.18,
-state.soccer.ball.size / 2
],
[
state.soccer.ball.size / 2, -0.18,
state.soccer.ball.size / 2
],
[
state.soccer.ball.size / 2, -0.18,
-state.soccer.ball.size / 2
],
[
-state.soccer.ball.size / 2, 0.18,
state.soccer.ball.size / 2
],
[
-state.soccer.ball.size / 2, 0.18,
-state.soccer.ball.size / 2
],
[
-state.soccer.ball.size / 2, -0.18,
state.soccer.ball.size / 2
],
[
-state.soccer.ball.size / 2, -0.18,
-state.soccer.ball.size / 2
]]
width1 = 400
width2 = 0
height1 = 300
height2 = 0
for item in list:
aps_flex = self._to_image([
aim_point_world_soccer[0] + item[0],
aim_point_world_soccer[1] + item[1],
aim_point_world_soccer[2] + item[2]
], proj, view)
if width1 > aps_flex[0]:
width1 = aps_flex[0]
if width2 < aps_flex[0]:
width2 = aps_flex[0]
if height1 > aps_flex[1]:
height1 = aps_flex[1]
if height2 < aps_flex[1]:
height2 = aps_flex[1]
player_x = player.kart.location[0]
player_y = player.kart.location[2]
front_x = player.kart.front[0]
front_y = player.kart.front[2]
ball_x = aim_point_world_soccer[0]
ball_y = aim_point_world_soccer[2]
vector_self = [front_x - player_x, front_y - player_y]
vector_ball = [ball_x - player_x, ball_y - player_y]
dot_prod = vector_self[0] * vector_ball[0] + vector_self[
1] * vector_ball[1]
if dot_prod > 0 and 0 <= aps[
0] < self.graphics_config.screen_width and 0 <= aps[
1] < self.graphics_config.screen_height and -30 < player.kart.location[
0] < 30 and -55 < player.kart.location[2] < 55:
if (width2 - width1) * (height2 - height1) > 40:
# print([[width1, height1, width2, height2]])
PIL.Image.fromarray(image).save(
os.path.join('dense_data/train/',
'player%02d_%05d.png' % (i, t)))
np.savez(os.path.join('dense_data/train/',
'player%02d_%05d' % (i, t)) +
'.npz',
puck=[[width1, height1, width2, height2]])
'''
# with open(os.path.join(save, 'player%02d_%05d' % (i, t)) + '.csv', 'w') as f:
# f.write('%0.3f,%0.3f,%0.3f,%0.3f,%0.3f,%0.3f' % (
# state.soccer.ball.location[0],state.soccer.ball.location[1], state.soccer.ball.location[2],
# state.soccer.goal_line[0][0][0], state.soccer.goal_line[0][0][1], state.soccer.goal_line[0][0][2]
# ))
'''
'''
f.write('%0.3f %0.3f %0.3f %0.3f %0.3f %0.3f' %tuple(state.soccer.ball.location), tuple(state.soccer.goal_line[0][0])))
'''
s = self.k.step(list_actions)
if not s: # Game over
break
if save is not None:
import subprocess
for i, p in enumerate(self.active_players):
dest = os.path.join(save, 'player%02d' % i)
output = save + '_player%02d.mp4' % i
subprocess.call([
'ffmpeg', '-y', '-framerate', '10', '-i',
dest + '_%05d.png', output
])
if hasattr(state, 'soccer'):
return state.soccer.score
return state.soccer_score
