| """Reference-style logs derived from independent UE input, without invented state.""" |
| from bisect import bisect_left,bisect_right |
| import json |
| import math |
|
|
| ACTION={'j':'Attack','k':'HeavyAttack','space':'Dodge','c':'Guard','f':'Riposte', |
| 't':'Heal','tab':'Lock','r':'Reset','shift':'Run','m':'Map'} |
| PHASE={'battle_round_start':'combat','battle_result':'result_pending', |
| 'precombat_roam_start':'roam','boss_approach_start':'approach', |
| 'natural_combat_entry':'combat', |
| 'full_map_exploration_start':'roam','full_map_result':'episode_complete', |
| 'return_to_arena_start':'return_to_arena','return_to_arena_complete':'reset_pending', |
| 'episode_boundary':'reset','encounter_round_complete':'episode_complete', |
| 'encounter_recording_complete':'episode_complete'} |
| MODE={'active':'combat','explore':'roam','result_hold':'result_pending', |
| 'roam_before_combat':'roam','approach_boss':'approach', |
| 'reset_key':'reset','settle':'reset_pending'} |
| STAGES={'startup':(0,'启动'),'episode_start':(0,'回合准备'),'roam':(1,'漫游'), |
| 'approach':(2,'接近Boss'),'combat':(3,'Boss战'),'result_pending':(4,'结果确认'), |
| 'return_to_arena':(5,'返回'),'episode_complete':(6,'流程完成'), |
| 'reset_pending':(7,'回合间等待'),'reset':(8,'回合重置')} |
|
|
|
|
| def timecode(frame,fps): |
| seconds,sub=divmod(frame,fps) |
| return f'{seconds//3600:02d}:{seconds//60%60:02d}:{seconds%60:02d}:{sub:02d}' |
|
|
|
|
| def export_reference_logs(output,summary,frames,engine,events,source_video=None): |
| if not frames:return dict(exported=False,reason='No video frames') |
| fps=int(summary.get('fps',summary.get('output_fps',16))) |
| if fps<=0 or fps!=summary.get('fps',summary.get('output_fps',16)): |
| raise ValueError('Reference timecode requires the actual positive integer video FPS') |
| ids=[int(f['engine_frame']) for f in frames] |
| if any(b<=a for a,b in zip(ids,ids[1:])):raise ValueError('Nonmonotonic video engine frames') |
| if any(int(b['engine_frame'])<int(a['engine_frame']) for a,b in zip(engine,engine[1:])): |
| raise ValueError('Nonmonotonic UE events') |
| if any(e['type'] not in ('key_down','key_up') for e in engine):raise ValueError('Unknown UE input event') |
| names=['输入日志.jsonl','输入日志.json','输入日志.vrising.json','事件日志.jsonl','session.json'] |
| if any((output/name).exists() for name in names):raise FileExistsError('Do not overwrite reference export evidence') |
| output.mkdir(parents=True,exist_ok=True) |
| native_path=output/'engine_session.jsonl' |
| native=[json.loads(line) for line in native_path.read_text(encoding='utf-8').splitlines() if line.strip()] if native_path.exists() else [] |
| spawns=[e for e in native if e['type']=='spawn_applied'] |
| spawn_frames=[int(e['engine_frame']) for e in spawns] |
| def aligned(event): |
| i=bisect_left(ids,int(event['engine_frame'])) |
| valid=i<len(frames) and int(event['engine_frame'])>=ids[0] |
| return dict(vt=float(frames[i]['video_t']) if valid else None, |
| 视频时间=timecode(i,fps) if valid else None,outside_video=not valid) |
| def key(event): |
| k=event['key'].lower() |
| return {'spacebar':'space','leftshift':'shift','two':'2'}.get(k,k) |
| changes=[e for e in events if 'engine_frame' in e and (e['type'] in PHASE or e['type']=='bot_mode')] |
| changes.sort(key=lambda e:e['engine_frame']) |
| has_precombat=any(e['type'] in ('precombat_roam_start','natural_combat_entry') for e in events) |
| def phase_for(e): |
| if e['type']=='battle_round_start' and has_precombat:return 'episode_start' |
| return MODE.get(e.get('mode'),e.get('mode',PHASE.get(e['type'],'unknown'))) |
| markers=[(int(e['engine_frame']),1,i,phase_for(e)) |
| for i,e in enumerate(changes)] |
| markers += [(int(e['engine_frame']),0,i,'reset') for i,e in enumerate(engine) |
| if e['type']=='key_down' and key(e)=='r'] |
| markers.sort() |
| cursor=phase_cursor=episode=0;phase='startup';held=set() |
| with (output/'输入日志.jsonl').open('w',encoding='utf-8') as stream: |
| for i,frame in enumerate(frames): |
| engine_frame=int(frame['engine_frame']) |
| while phase_cursor<len(markers) and markers[phase_cursor][0]<=engine_frame: |
| phase=markers[phase_cursor][3];phase_cursor+=1 |
| pressed=[];released=[];edges=[];discontinuity=False |
| while cursor<len(engine) and engine[cursor]['engine_frame']<=engine_frame: |
| event=engine[cursor];k=key(event);down=event['type']=='key_down' |
| if down:held.add(k) |
| else:held.discard(k) |
| if down and k=='r':episode+=1 |
| cursor+=1 |
| |
| |
| if event['engine_frame']<ids[0]:continue |
| if k in ACTION:(pressed if down else released).append(ACTION[k]) |
| if down and k=='r':discontinuity=True |
| edges.append(dict(key=k,state='down' if down else 'up', |
| engine_frame=event['engine_frame'],game_time=event['game_time'], |
| engine_real_time=event['engine_real_time'])) |
| x=int('d' in held)-int('a' in held);y=int('w' in held)-int('s' in held) |
| mag=math.hypot(x,y) |
| row=dict(type='input',vt=float(frame['video_t']),视频时间=timecode(i,fps), |
| frame=i,t=float(frame['game_t']),f=engine_frame,w=None, |
| engine_real_time=float(frame['engine_real_time']), |
| wall_relative=float(frame['engine_real_time'])-float(frames[0]['engine_real_time']), |
| episode=episode,phase=phase,discontinuity=discontinuity, |
| down=sorted(ACTION[k] for k in held if k in ACTION),pressed=pressed,released=released, |
| keys=sorted(held),mv=dict(keys='+'.join(sorted(k.upper() for k in held if k in 'wasd')), |
| x=x/mag if mag else 0,y=y/mag if mag else 0,mag=min(1.,mag), |
| deg=math.degrees(math.atan2(x,y))%360 if mag else None, |
| source='camera_relative_keyboard_input_not_measured_velocity'), |
| aim=None,edges=edges,input_source='independent_UE_received_keys') |
| if spawns: |
| spawn_i=bisect_right(spawn_frames,engine_frame)-1 |
| row['spawn_index']=spawns[spawn_i]['spawn_index'] if spawn_i>=0 else None |
| row['round']=spawns[spawn_i]['round'] if spawn_i>=0 else 0 |
| stream.write(json.dumps(row,ensure_ascii=False)+'\n') |
| marker_frames=[m[0] for m in markers] |
| def input_stage(e): |
| index=bisect_right(marker_frames,int(e['engine_frame']))-1 |
| phase=markers[index][3] if index>=0 else 'startup' |
| if e['type']=='key_down' and key(e)=='r':phase='reset' |
| number,name=STAGES.get(phase,(None,phase)) |
| return dict(阶段=number,阶段名=name,phase=phase) |
| human=[dict(时间戳=None,按键=key(e).upper(),状态='按下' if e['type']=='key_down' else '松开', |
| 来源='UE实际接收输入',engine_frame=e['engine_frame'],game_time=e['game_time'],engine_real_time=e['engine_real_time'], |
| **input_stage(e),**aligned(e)) for e in engine] |
| |
| |
| with (output/'输入日志.json').open('w',encoding='utf-8') as stream: |
| for row in human:stream.write(json.dumps(row,ensure_ascii=False)+'\n') |
| (output/'输入日志.vrising.json').write_text(json.dumps(human,ensure_ascii=False,indent=2),encoding='utf-8') |
| timeline=[dict(type='event',ev=e['type'],round=e.get('round'),f=e['engine_frame'], |
| phase=phase_for(e),**aligned(e)) for e in changes] |
| timeline += [dict(type='event',ev='reset_boundary',discontinuity=True,f=e['engine_frame'], |
| source='UE_R_key_down',**aligned(e)) for e in engine if e['type']=='key_down' and key(e)=='r'] |
| timeline += [dict(type='event',ev='spawn_applied',round=e['round'],spawn_index=e['spawn_index'], |
| position_cm=[e['x'],e['y'],e['z']],discontinuity=True,f=e['engine_frame'], |
| source='UE_after_native_reset',**aligned(e)) for e in spawns] |
| if native: |
| with (output/'玩家状态.jsonl').open('x',encoding='utf-8') as stream: |
| for e in native: |
| if e['type']!='player_state':continue |
| row=dict(type='s',e='player',round=e['round'],f=e['engine_frame'], |
| t=e['game_time']-float(frames[0]['game_time']), |
| engine_real_time=e['engine_real_time'],units='cm and cm/s', |
| **{k:e[k] for k in ('x','y','z','vx','vy','vz')},**aligned(e)) |
| row.update({k:e[k] for k in ('health','stamina','action','boss_known','boss_x','boss_y','boss_z','boss_health','boss_action','camera_yaw') if k in e}) |
| stream.write(json.dumps(row,ensure_ascii=False)+'\n') |
| names.append('玩家状态.jsonl') |
| with (output/'事件日志.jsonl').open('w',encoding='utf-8') as stream: |
| for event in sorted(timeline,key=lambda e:e['f']): |
| stream.write(json.dumps(event,ensure_ascii=False)+'\n') |
| session=dict(schema='gamebot.reference.v3',video_file=str(source_video) if source_video is not None else 'gameplay.mp4',fps=fps, |
| frame_count=len(frames),sessionId=summary.get('run_id',output.name),case_id=summary.get('case_id'), |
| clock='vt is MP4 playback seconds; t is relative UE game time; wall_relative is real elapsed time', |
| w=None,w_note='UTC for independent UE events was not recorded; do not infer a Unix timestamp', |
| source='Existing UE events and actual video frames, not model intentions', |
| state_fields_not_recorded=([] if native else ['world_position','actual_velocity'])+['aim','entity_id','boss_action'], |
| action_note='Action names map received keys to commands; they do not establish successful game actions', |
| reference_datasets=['yuzhewu207/EYBXBOSS','yuzhewu207/vrising4stage'], |
| reference_revisions={'yuzhewu207/EYBXBOSS':'371c8a04249901f58d5d794dc19f42c3787b3f92', |
| 'yuzhewu207/vrising4stage':'89051f72fb2ea1688c4fcb3e197d63c783406f69'}, |
| file_formats={'输入日志.json':'JSON Lines; one independent UE edge per line, not a JSON array', |
| '输入日志.vrising.json':'JSON array; the same UE edges and order, for vrising-style consumers', |
| '输入日志.jsonl':'JSON Lines; one row per actual video frame', |
| '事件日志.jsonl':'JSON Lines; controller phase and actual reset boundaries'}, |
| timecode_format='HH:MM:SS:frame (uses this video fps, not the reference game fps)', |
| action_mapping=ACTION, |
| stage_mapping={key:dict(code=value[0],name=value[1]) for key,value in STAGES.items()}, |
| stage_note='Codes describe this Bot workflow; they are not the reference game level IDs', |
| compatibility='Video/input/phase conventions only; not a complete engine-state schema clone') |
| if native: |
| session.update(native_player_state='玩家状态.jsonl: measured UE position and velocity in cm / cm per second', |
| spawn_cycle=summary.get('spawn_cycle'),recording_mode=summary.get('recording_mode'), |
| duration_policy='Exact distinct-frame budget; final unfinished round is preserved', |
| spawn_change='Explicit native R reset followed by authorized player spawn change; no combat-rule changes') |
| if any('boss_action' in e for e in native): |
| session['state_fields_not_recorded']=['aim','entity_id'] |
| session['native_action_note']='action/boss_action are the original UE reflected action states, not inferred from pressed keys' |
| (output/'session.json').write_text(json.dumps(session,ensure_ascii=False,indent=2),encoding='utf-8') |
| return dict(exported=True,frames=len(frames),ue_edges=len(engine),episodes=episode, |
| files=names) |
|
|
