File size: 11,936 Bytes
0364757
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2719bf4
0364757
 
 
2719bf4
0364757
2719bf4
0364757
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2719bf4
 
 
 
 
 
 
0364757
2719bf4
 
 
 
0364757
 
 
 
 
 
 
 
 
 
 
2719bf4
 
 
0364757
 
 
 
2719bf4
 
0364757
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
from __future__ import annotations

import json
from borderland import Action, Campaign


class LegalReference:
    """History-aware scripted controller. Its only input is public transitions."""

    def __init__(self):
        self.facts = {}
        self.records = {}
        self.seen_pages = set()
        self.compared = set()
        self.rule_stage = 0
        self.osmosis_stage = 0
        self.route = None
        self.observed_reactions = []
        self._last_observation = None

    def _ingest(self,t):
        o=t.observation.to_dict(); b=o['board']
        if self._last_observation==o:
            return o,b
        self._last_observation=o
        if o['phase']==1 and b['fixture']=='sensor' and b['live_sensor'] is not None:
            bit=b['live_sensor']^(b['latch']&1)
            self.facts['bus']=('west','east')[bit]
            self.facts['valve']=('west','east')[bit]
        if o['phase']==3 and b.get('records'):
            self.seen_pages.add((b['slot'],b['page']))
            for rec in b['records']:
                previous=self.records.get(rec['id'])
                if rec['authenticated'] and (previous is None or rec['issued_at']>previous['issued_at']):
                    self.records[rec['id']]=rec
            for subject in ('restoration','authorization','egress'):
                choices=[record for record in self.records.values() if record['subject']==subject]
                if not choices: continue
                rec=max(choices,key=lambda record:record['issued_at'])
                self.facts['record_'+subject]=rec['id']
                if subject=='restoration': self.facts['order']=rec['statement'].split('>')
                elif subject=='authorization': self.facts['witness'],self.facts['seal']=rec['statement'].split('/')
                else: self.facts['track']=int(rec['statement'])
        if o['phase']==4:
            self.observed_reactions.append(b['reaction'])
        note=o['notebook']['text']
        if t.context_reset and note:
            self.facts=json.loads(note)
        return o,b

    def notebook(self,t):
        self._ingest(t)
        text=json.dumps(self.facts,sort_keys=True,separators=(',',':'))
        return text if text!=t.observation.notebook['text'] else None

    def choose(self,t):
        o,b=self._ingest(t)
        phase=o['phase']
        def a(tag,**args): return Action(tag,args)
        if phase==1:
            sequence=[a('set_latch',value=0),a('pulse',fixture='sensor'),a('observe_sensor'),a('set_latch',value=1),a('pulse',fixture='sensor'),a('observe_sensor')]
            if self.rule_stage<len(sequence):
                result=sequence[self.rule_stage]; self.rule_stage+=1; return result
            sequence2=[a('set_latch',value=2+(self.facts['bus']=='east')),a('pulse',fixture='relay'),a('pulse',fixture='gate'),a('lock_chamber')]
            result=sequence2[self.rule_stage-len(sequence)]; self.rule_stage+=1; return result
        if phase==2:
            target=2 if 'bridge_rig' not in o['inventory'] and 'relay_cell' not in o['inventory'] and b['rotation']%2==0 else 4 if 'bridge_rig' not in o['inventory'] and 'relay_cell' not in o['inventory'] else 8
            if b['cell']==target:
                return a('leave_maze') if target==8 else a('collect')
            if not b['scanned']: return a('scan')
            cell=b['cell']
            route = [0,1,2,5,8] if target==2 or 'bridge_rig' in o['inventory'] else [0,1,4,5,8]
            if target in (2,4): route=route[:route.index(target)+1]
            destination=route[route.index(cell)+1]
            direction={1:'east',3:'south',-1:'west',-3:'north'}[destination-cell]
            if a('walk',direction=direction) not in t.legal_actions: return a('wait')
            return a('walk',direction=direction)
        if phase==3:
            for slot in range(6):
                if (slot,0) not in self.seen_pages: return a('open_scroll',slot=slot)
                if b['slot']==slot and b['page']+1<b['page_count']: return a('advance_page')
            for subject in ('restoration','authorization','egress'):
                new=self.records[self.facts['record_'+subject]]
                if subject not in self.compared:
                    self.compared.add(subject)
                    return a('compare_seal',left_id=new['supersedes'],right_id=new['id'])
            return a('bind_docket',record_ids=[self.facts['record_'+x] for x in ('restoration','authorization','egress')])
        if phase==4:
            if b['contest_over']: return a('end_osmosis')
            runner=next(x for x in b['allies'] if x['actor']=='Ada')
            if self.route is None: self.route='bridge' if b['bridge_available'] else 'relay'
            if self.osmosis_stage==0:
                self.osmosis_stage=1
                return a('feint',actor='Bo',lane='east')
            if 'opponent_pattern' not in self.facts:
                guard=next(x for x in b['enemies'] if x['actor']=='guard')
                self.facts['opponent_pattern']='majority' if guard['node']=='east' else 'minority'
            desired='west' if self.route=='bridge' else 'east'
            if self.osmosis_stage==1:
                lane=next(x for x in b['enemies'] if x['actor']=='guard')['node']
                stable=(b['east_commitments']>=2 if desired=='west' and self.facts['opponent_pattern']=='majority' else b['west_commitments']>=2 if desired=='west' else b['west_commitments']>=6 if self.facts['opponent_pattern']=='majority' else b['east_commitments']>=3)
                if lane==desired or not stable:
                    feint_lane=('east' if desired=='west' else 'west') if self.facts['opponent_pattern']=='majority' else desired
                    return a('feint',actor='Bo',lane=feint_lane)
                self.osmosis_stage=2
            if self.route=='bridge':
                if runner['node']=='home': return a('bank',actor='Ada') if runner['flag'] else a('deploy',actor='Ada',neighbor='west')
                if b['base_captured']: return a('deploy',actor='Ada',neighbor='home')
                keeper=next(x for x in b['enemies'] if x['actor']=='keeper')
                if keeper['node']=='enemy': return a('challenge',actor='Ada',target='keeper')
                return a('deploy',actor='Ada',neighbor='enemy')
            if runner['node']=='home': return a('bank',actor='Ada') if runner['flag'] else a('deploy',actor='Ada',neighbor='east')
            if runner['node']=='east': return a('deploy',actor='Ada',neighbor='home' if runner['flag'] else 'relay')
            if runner['node']=='relay': return a('deploy',actor='Ada',neighbor='east')
        if phase==5:
            witness=self.facts['witness']; cell={'Iris':1,'Juno':2,'Kade':3}[witness]
            if b['player_cell']!=cell: return a('visit',cell=cell)
            if not b['claim'] or b['claim']['witness']!=witness: return a('interview',witness=witness)
            if not any(x['status']=='verified' and x['claim']==b['claim']['id'] for x in b['checks']): return a('cross_check',claim_id=b['claim']['id'],record_id=self.facts['record_authorization'])
            if b['checkpoint_test']!=self.facts['seal']: return a('test_checkpoint',seal_id=self.facts['seal'])
            return a('escort',witness=witness,neighbor=4)
        if phase==6:
            circuits={c['id']:c for c in b['circuits']}
            for cid in self.facts['order']:
                c=circuits[cid]
                if c['status']=='live': continue
                if c['status']=='tripped': return a('isolate',circuit=cid)
                if c['bus']!=self.facts['bus'] or c['status']=='isolated': return a('connect',circuit=cid,bus=self.facts['bus'])
                return a('energize',circuit=cid)
            return a('restore')
        if phase==7:
            for item,socket in [('coupler','coupler'),('exit_power','power')]:
                if b['installed'].get(socket)!=item: return a('install',item=item,socket=socket)
            if b['track']!=self.facts.get('track',0): return a('align_track',position=self.facts.get('track',0))
            if len(b['boarded'])<2: return a('board',actor=next(x['id'] for x in o['team'] if x['id'] not in b['boarded'] and x['available']))
            if b['armed_with']!=self.facts.get('seal','amber'): return a('arm_exit',seal_id=self.facts.get('seal','amber'))
            if b['valve'] is None: return a('open_valve',side=self.facts['valve'])
            return a('launch')
        raise RuntimeError('No legal-reference action for public state')


def public_reference(initial_transition):
    if 'capacity_bytes' in initial_transition.observation.notebook:
        from .causal_reference import CausalReference
        return CausalReference()
    return LegalReference()


def execute_reference(campaign,record=True,stop_before_valve=False):
    t=campaign.reset()
    causal='channels' in t.observation.board
    policy=public_reference(t); factory=type(policy)
    trace=[]; notes=[]; failure=None; steps=0; controller_resets=0; reactions=[]; route=None
    for _ in range(240):
        if t.done: break
        try:
            text=policy.notebook(t)
            if text is not None:
                t=campaign.replace_notebook(text,expected_revision=t.revision)
                if record: notes.append(dict(revision=t.revision,text=text))
            action=policy.choose(t)
            if stop_before_valve and action.tag=='open_valve': break
            t=campaign.step(action,expected_revision=t.revision); steps+=1
            if record: trace.append(dict(action=action.to_dict(),transition=t.to_dict()))
            if causal and t.context_reset:
                reactions=list(policy.observed_reactions); route=policy.route
                policy=factory(); controller_resets+=1
            if t.error:
                failure=t.error.to_dict(); break
        except (KeyError,IndexError,ValueError,RuntimeError) as error:
            failure=repr(error); break
    boarded=list(t.observation.board.get('boarded',[]))
    return dict(outcome=t.outcome,reward=t.reward,steps=steps,charge=t.observation.charge,trace=trace,notebook_trace=notes,failure=failure,route=route or policy.route,observed_reactions=reactions or policy.observed_reactions,survivors=len(boarded) if t.outcome=='escaped' else 0,available_teammates=sum(m['available'] for m in t.observation.team),boarded_teammates=boarded,controller_resets=controller_resets)


def run_reference(seed,ruleset='campaign'):
    return execute_reference(Campaign.generated(seed,ruleset))


class PerfectInformationReference(LegalReference):
    """Operator-only diagnostic controller; hidden facts are deliberately injected."""

    def __init__(self, world):
        super().__init__()
        self.facts=dict(bus=('west','east')[world.polarity],valve=('west','east')[world.polarity],order=list(world.restoration_order),witness=world.current_witness,seal=world.current_seal,track=world.correct_track)
        self.rule_stage=6


def run_privileged_reference(seed,ruleset='campaign'):
    env=Campaign.generated(seed,ruleset)
    controller=PerfectInformationReference(env._world)
    t=env.reset();trace=[];notes=[];failure=None
    for _ in range(240):
        if t.done: break
        text=controller.notebook(t)
        if text is not None:
            t=env.replace_notebook(text);notes.append(dict(revision=t.revision,text=text))
        try:
            action=controller.choose(t)
            t=env.step(action)
            trace.append(dict(action=action.to_dict(),transition=t.to_dict()))
            if t.error: failure=t.error.to_dict();break
        except (KeyError,IndexError,ValueError,RuntimeError) as error:
            failure=repr(error);break
    return dict(outcome=t.outcome,reward=t.reward,steps=len(trace),charge=t.observation.charge,trace=trace,notebook_trace=notes,failure=failure,reference='perfect-information diagnostic; not an optimality or fair-admission proof')