def process(replay_gbx: Gbx, trace_offset: int):
'''
Processes a single replay using a given trace offset.
Args:
replay_gbx (pygbx.Gbx): the Gbx object to process
trace_offset (int): the trace offset to use for tracing out blocks
Returns:
list: the block tuples
'''
replays = replay_gbx.get_classes_by_ids(
[GbxType.REPLAY_RECORD, GbxType.REPLAY_RECORD_OLD])
ghosts = replay_gbx.get_classes_by_ids(
[GbxType.GAME_GHOST, GbxType.CTN_GHOST])
if not ghosts or not replays:
return None
ghost = ghosts[0]
replay = replays[0]
challenge = replay.track.get_class_by_id(GbxType.CHALLENGE)
if not challenge:
return None
filtered = []
for block in challenge.blocks:
t = block_to_tup(block)
if not t:
continue
filtered.append(t)
return process_blocks(filtered, ghost, trace_offset)
def get_steering_inputs(path: str):
""" Returns a tuple of steering inputs + timestamp from a given GBX file. """
try:
gbx_obj = Gbx(path)
except Exception as excp:
print(f'Error parsing: {excp}')
return None
ghosts = gbx_obj.get_classes_by_ids([GbxType.CTN_GHOST, GbxType.CTN_GHOST_OLD])
if not ghosts:
ghost = try_parse_old_ghost(gbx_obj)
if not ghost:
print('Error: no ghosts')
return None
if not ghost.control_entries:
print('Error: no control entries')
return None
else:
ghost = ghosts[0]
steering_inputs, timeline = get_steer_events(ghost.control_entries)
return steering_inputs, timeline
def analyze_replay(path: str):
try:
g = Gbx(path)
except Exception as e:
print(f'Error parsing: {e}')
return None
ghosts = g.get_classes_by_ids([GbxType.CTN_GHOST, GbxType.CTN_GHOST_OLD])
if not ghosts:
ghost = try_parse_old_ghost(g)
if not ghost:
print('Error: no ghosts')
return None
if not ghost.control_entries:
print('Error: no control entries')
return None
else:
ghost = ghosts[0]
ghost = ghosts[0]
results = {
'version': ghost.game_version,
'login': ghost.login,
'max_spikes': 0,
'spikes': 0
}
partitions = partition_steer_events(ghost.control_entries, TIME_PERIOD)
spikes = []
for partition in partitions:
spikes_num = -1
spike_dir = 0
for i in range(1, len(partition)):
diff = partition[i] - partition[i - 1]
if abs(diff) <= NOISE_THRESHOLD:
continue
if diff > 0 and spike_dir != 1:
spike_dir = 1
spikes_num += 1
elif diff < 0 and spike_dir != -1:
spike_dir = -1
spikes_num += 1
spikes_num = max(0, spikes_num)
spikes.append(spikes_num)
if len(spikes) == 0:
max_spikes = 0
else:
max_spikes = max(spikes)
results['max_spikes'] = max_spikes
results['spikes'] = spikes
return results
def process_path(path, write_func):
g = Gbx(path)
ghosts = g.get_classes_by_ids([GbxType.CTN_GHOST, GbxType.CTN_GHOST_OLD])
if not ghosts:
ghost = try_parse_old_ghost(g)
else:
ghost = ghosts[0]
if not ghost:
return
# if not ghost.control_entries:
# try_extract_2020(g)
print_inputs(ghost, write_func)
def uses_binary_input(path: str):
try:
g = Gbx(path)
except:
print(f'Error parsing: {e}')
ghosts = g.get_classes_by_ids([GbxType.CTN_GHOST, GbxType.CTN_GHOST_OLD])
if not ghosts:
ghost = try_parse_old_ghost(g)
if not ghost:
print('Error: no ghosts')
return None
if not ghost.control_entries:
print('Error: no control entries')
return None
else:
ghost = ghosts[0]
results = {
'version': ghost.game_version,
'login': ghost.login,
'max_taps': 0,
'taps': 0
}
ghost = ghosts[0]
if ghost.login != 'acceleracer_01':
return None
for entry in ghost.control_entries:
if entry.event_name == 'Steer':
return None
partitions = partition_binary_events(ghost.control_entries, TIME_PERIOD)
# print(partitions)
m = 0
for p in partitions:
m = max(m, len(p))
results['max_taps'] = m
results['taps'] = partitions
return results
def main():
path = sys.argv[1]
# login = sys.argv[2]
i = 0
reps = {}
for root, subdirs, files in os.walk(path):
for filename in files:
if filename.lower().endswith('.gbx'):
try:
g = Gbx(os.path.join(root, filename))
ghost = g.get_classes_by_ids(
[GbxType.CTN_GHOST, GbxType.CTN_GHOST_OLD])[0]
if ghost.login not in reps:
reps[ghost.login] = [filename]
else:
reps[ghost.login].append(filename)
except:
pass
i += 1
print(json.dumps(reps))
return 90
return 0
if len(sys.argv) <= 1:
track = pickle.load(open('data/train_data.pkl', 'rb+'))[0][1]
print('Visualizing first track from the training data.')
else:
try:
train_idx = int(sys.argv[1])
track = pickle.load(open('data/train_data.pkl', 'rb+'))[train_idx][1]
print(f'Visualizing track {train_idx} from the training data.')
except ValueError:
gfile = Gbx(sys.argv[1])
challenges = gfile.get_classes_by_ids(
[GbxType.CHALLENGE, GbxType.CHALLENGE_OLD])
if challenges:
challenge = challenges[0]
track = [block_to_tup(block) for block in challenge.blocks]
print('Visualizing track from the provided challenge file.')
else:
print('Cannot load track: invalid file')
quit()
print(track)
arr_img = pygame.image.load('block_images/arr.jpg')
arr_img = pygame.transform.scale(arr_img, (10, 10))
screen = pygame.display.set_mode((w, h))
images = []