chickenbstrips/TheTree_mock
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

P23-03: 生活の観察

Browse Source
This commit is contained in:
Agent Control Runner
2026-10-15 18:01:00 +09:00
parent 49445d4a4d
commit 19fc3f50c7
8 changed files with 1888 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tools/check_p23_life_observation_evidence.py
+372 -44
View File
@@ -329,6 +329,8 @@ def drawing_rectangle_rows(report):
actor(a)
if a['staff'] and a['key'].removeprefix('staff/') in report['resting_staff']:
actor(a, 'rest')
for i, b in enumerate(report.get('actor_aggregations', [])):
badge('aggregation', str(i), b)
for i, b in enumerate(report['badges']):
badge('goods' if b['kind'] == 'supply' else 'business', str(i), b)
for row in report.get('traffic', []):
@@ -337,7 +339,77 @@ def drawing_rectangle_rows(report):
return expected
def validate_drawing_rows(report, audit, root=ROOT):
PIXEL_PEOPLE_CORE_SHA256 = 'a171703083aa2d00f8be2b63e1daef9c41717c8fe59d8056878bc4b7df1e0b0c'
def actor_identity_core(actor):
"""Grid identity bounds from the pinned PixelPeople pose, including bob.
Standard-room breathing extends the upper edge, not the lower edge.
Arms, legs, props and the sleep symbol are outside the identity core.
"""
key, at, scale = actor['key'], actor['at'], actor['scale']
require(len(at) == 2 and all(type(v) in (int, float) and math.isfinite(v) for v in at)
and type(scale) in (int, float) and math.isfinite(scale) and scale > 0,
'invalid actor footprint: ' + key)
require(isinstance(actor.get('mode'), str) and type(actor.get('frame')) is int
and type(actor.get('flip')) is bool, 'missing actor pose: ' + key)
mode, phase = actor['mode'], actor['frame'] % 8
if mode in ('sleep', 'collapsed', 'standard_room_sleep'):
breathing = -1 if mode == 'standard_room_sleep' and phase in (2, 3, 4) else 0
x, y, w, h = 2, 11 + breathing, 13, 5 - breathing
else:
bob = -1 if mode in ('walk', 'carry_walk') and phase in (2, 6) else 0
x, y, w, h = 6, 1 + bob, 6, 12
if actor['flip']:
x = 16 - x - w
return [at[0] + x * scale, at[1] + y * scale, w * scale, h * scale]
def validate_actor_nonoverlap(report, root=ROOT, transit_keys=()):
"""Recompute identity cores from drawing inputs, including cabin passengers.
Do not consume audit eligibility or boolean judgments: neither an off-screen
label nor a claimed pass exempts a submitted actor from this invariant.
Transparent margins may overlap. No asserted transit flag grants exemption.
"""
require(hashlib.sha256((root / 'scripts/ui/pixel_people.gd').read_bytes()).hexdigest()
== PIXEL_PEOPLE_CORE_SHA256, 'PixelPeople core source SHA256')
actors = list(report['actor_drawings']) + [
actor for cabin in report['cabins'] for actor in cabin['passengers']]
rects = []
keys = set()
for actor in actors:
key = actor['key']
require(key not in keys, 'duplicate actor drawing: ' + key)
keys.add(key)
rect = actor_identity_core(actor)
if key in transit_keys:
continue
for other_key, other in rects:
intersects = (rect[0] < other[0] + other[2] and other[0] < rect[0] + rect[2]
and rect[1] < other[1] + other[3] and other[1] < rect[1] + rect[3])
require(not intersects, 'actor-actor core overlap: ' + other_key + ' / ' + key)
rects.append((key, rect))
def validate_drawing_rows(report, audit, root=ROOT, state=None, rest_audit=None):
# Without raw inputs this is deliberately conservative: NO transit exemption.
# With inputs, use the same state-derived classification and fit proof as the
# stream checker, never a drawing's region/in_transit assertion.
if state is None:
validate_actor_nonoverlap(report, root)
else:
require(isinstance(state, dict) and isinstance(state.get('systems', {}).get('runtime'), dict),
'malformed raw state context')
if report['resting_staff']:
require(rest_audit is not None, 'missing rest authority for drawing geometry')
if rest_audit is not None:
require(isinstance(rest_audit, dict) and isinstance(rest_audit.get('staff'), list),
'malformed rest authority')
compare_rest(state, report, rest_audit, root)
compare_cabin_geometry(state, report)
compare_actor_geometry(state, report)
expected = drawing_rectangle_rows(report)
require(len(audit['rows']) == len(expected), 'offline rectangle coverage')
for row, (category, identifier, rect, source, text) in zip(audit['rows'], expected):
@@ -367,15 +439,17 @@ def encode_png(rows):
+ chunk(b'IDAT', zlib.compress(raw)) + chunk(b'IEND', b''))
def frame_rows(report, audit, request, receipt, images, clicks, root=ROOT):
def frame_rows(report, audit, request, receipt, images, clicks, root=ROOT, state=None, rest_audit=None):
"""One mechanical path for frozen diagnostics and actual OS frames.
Errors are retained as failures, including incomplete frozen audits. Every
supplied row is accounted for; no palette value is an image oracle.
"""
errors, rows = [], []
transit_authority = ('raw state, track, time and pause' if state is not None
else 'absent: fail closed, no transit exemptions')
try:
validate_drawing_rows(report, audit, root)
validate_drawing_rows(report, audit, root, state, rest_audit)
except (ValueError, KeyError, TypeError) as exc:
errors.append(str(exc))
calibration = screenshot_transform(receipt['calibration'], request, images[0][:2], clicks)
@@ -415,6 +489,9 @@ def frame_rows(report, audit, request, receipt, images, clicks, root=ROOT):
if row['category'] == 'queue':
badge = report['landing_badges'][int(row['id'])]
state = {k: badge[k] for k in ('members', 'visible_count', 'overflow')}
if row['category'] == 'aggregation':
badge = report['actor_aggregations'][int(row['id'])]
state = {k: badge[k] for k in ('members', 'drawn_keys')}
if row['category'] == 'EV':
cabin = next(c for c in report['cabins'] if c['shaft_id'] == row['id'])
state = {k: cabin[k] for k in ('operational', 'doors_open')}
@@ -448,7 +525,8 @@ def frame_rows(report, audit, request, receipt, images, clicks, root=ROOT):
result['failures'] = failures
rows.append(result)
return dict(rows=rows, errors=errors, mechanical_pass=not errors and all(r['mechanical_pass'] for r in rows),
expected_row_count=len(drawing_rectangle_rows(report)))
expected_row_count=len(drawing_rectangle_rows(report)),
transit_authority=transit_authority)
def write_frame_review(directory, frame, provenance):
@@ -551,7 +629,14 @@ def inspect_offline_mirror(directory):
for original in (str(Path(index['source'])/conversion_path.relative_to(directory)),
conversion['png_path']):
inspected.append(by_original[original])
frame = frame_rows(report, audit, request, receipt, images, clicks, ROOT)
stream = pair/'writer-stream'
captures = [row for row in map(json.loads, (stream/'manifest.jsonl').read_text().splitlines())
if row.get('label') == name and 'report' in row]
require(len(captures) == 1, 'offline raw-state capture coverage')
capture = captures[0]
state, rest_audit = drawing_context(stream, capture, report)
frame = frame_rows(report, audit, request, receipt, images, clicks, ROOT,
state, rest_audit)
provenance = []
for number, suffix in enumerate(('', '-after')):
conversion_path = folder/('root-early-conversion'+suffix+'.json')
@@ -720,9 +805,56 @@ def compare_traffic(snapshot, report):
if cell[2] != report['layer']:
continue
x, y, w, h = transform.rect(cell)
rect = [x + 2, y + 2, w - 4, h - 4]
thickness = max(2, min(5, (h - 4) * .16))
band = [rect[0] + rect[2] * .12, y + h - 2 * (w / 16) - thickness / 2,
rect[2] * .76, thickness]
rows.append(dict(cell=cell, traffic={k: v for k, v in saved.items() if k != 'cell'},
rect=[x + 2, y + 2, w - 4, h - 4]))
rect=rect, band_rect=band))
close(report['traffic'], rows, 'traffic and cell rect')
validate_life_overlay(report)
def validate_life_overlay(report, root=ROOT):
"""Check consumed frame and source wiring, not merely reported order flags."""
serial = report.get('observation_serial')
require(type(serial) is int and serial > 0
and type(report.get('overlay_consumed_serial')) is int
and report['overlay_consumed_serial'] == serial, 'stale LifeOverlay serial')
require(report.get('overlay_passes') == ['traffic', 'actors'], 'LifeOverlay pass order')
indices = report.get('overlay_child_indices', [])
require(len(indices) == 3 and all(type(i) is int and i >= 0 for i in indices)
and indices[0] < indices[1] < indices[2], 'LifeOverlay child order')
source = (root / 'scenes/main/world_preview.gd').read_text()
def body(name):
match = re.search(r'^func ' + name + r'\([^\n]*\n(.*?)(?=^func |\Z)', source, re.M | re.S)
require(match is not None, 'missing overlay source function: ' + name)
return match[1]
ready, draw, overlay = body('_ready'), body('_draw_contents'), body('_draw_life_overlay')
ordered = [ready.find('add_child(' + node + ')')
for node in ('_inactive_layer_art', '_life_overlay', '_layer_lens')]
require(all(i >= 0 for i in ordered) and ordered == sorted(set(ordered)), 'LifeOverlay source child order')
require('_life_overlay.draw.connect(_draw_life_overlay)' in ready
and '_life_overlay.queue_redraw()' in draw, 'LifeOverlay source connection')
require('_draw_congestion_overlay(' not in draw and '_draw_actors(' not in draw
and '_draw_observed_actor(' not in body('_draw_elevators'), 'actor or band drawn in parent')
require(0 <= overlay.find('_draw_congestion_overlay(_life_overlay)')
< overlay.find('_draw_observed_actor(actor, _life_overlay)')
< overlay.find('_draw_actors(_life_overlay)'), 'LifeOverlay source pass order')
actors = list(report['actor_drawings']) + [a for c in report['cabins'] for a in c['passengers']]
for row in report.get('traffic', []):
x, y, w, h = row['rect']
thickness = max(2, min(5, h * .16))
expected = [x + w * .12, y + h + 2 - 2 * ((w + 4) / 16) - thickness / 2,
w * .76, thickness]
close(row['band_rect'], expected, 'traffic band rectangle')
if row['traffic']['current_density'] <= 0 and not row['traffic']['temporary_block']:
continue
for actor in actors:
core = actor_identity_core(actor)
intersects = (core[0] < expected[0] + expected[2] and expected[0] < core[0] + core[2]
and core[1] < expected[1] + expected[3] and expected[1] < core[1] + core[3])
require(not intersects, 'traffic band covers actor core: ' + actor['key'])
def compare_queues(snapshot, report):
@@ -935,27 +1067,12 @@ def compare_rest(state, report, audit, root=ROOT):
if selected.get('resting'):
resting[sid] = selected['facility_id']
close(report['resting_staff'], resting, 'draw resting_staff')
transform = Transform(runtime, report)
drawings = {r['key']: r for r in report['actor_drawings']}
for sid, fid in resting.items():
member = next(m for m in members if m['staff_id'] == sid)
if member['current_cell'][2] != report['layer'] or sid in report['carried_patients']:
continue
room = report['rooms'].get(fid, {})
cells = next((r['cells'] for r in runtime['world']['occupancies'] if r['entity_id'] == fid), [])
if not cells:
continue # renderer uses its ordinary tracked fallback
require(sid in room.get('people', []), 'rest room occupant missing')
slot = room['people'].index(sid)
anchors = room_slots(transform.room(cells), transform.dim[0] / 16)
key = 'staff/' + sid
if key in report['boarded'] or key in report['queue_hidden']:
require(key not in drawings, 'hidden resting drawing')
elif slot >= len(anchors):
require(key not in drawings, 'rest slot overflow drawing')
else:
close(drawings[key]['center'], [anchors[slot][0], anchors[slot][1] - transform.dim[1] * .5],
'resting staff position')
# Fitting is cross-kind, and queue precedence applies to resting staff too.
# Reconstruct the complete group and independently prove p=1 no-fit before
# allowing an identity to appear only in an aggregation's member list.
if any(r['cells'] for r in runtime['world']['occupancies']
if r['entity_id'] in resting.values()):
compare_actor_geometry(state, report)
return selections
@@ -1129,8 +1246,105 @@ def compare_motion(state, report, audit):
return ['motion_history', 'interpolation', 'pause']
def fitted_actor_layout(members, world_pixel, height):
"""Independent interval solver. Inputs are reconstructed preferred rows/bounds."""
def scaled(member, scale):
row = copy.deepcopy(member['row'])
row['scale'] = min(row['scale'], scale)
s = row['scale']
row['at'] = [math.copysign(math.floor(abs(v)+.5), v) for v in
(row['center'][0]-8*s, row['center'][1]+height/2-3*world_pixel-17*s)]
return row
def pack(group, scale):
trial = [scaled(m, scale) for m in group]
right = -math.inf
for member, row in zip(group, trial):
x, y, w, h = actor_identity_core(row)
left = max(x, member['bounds'][0], right)
row['at'][0] += left-x
right = left+w
left = math.inf
for member, row in reversed(list(zip(group, trial))):
x, y, w, h = actor_identity_core(row)
bx, by, bw, bh = member['bounds']
target = min(x, bx+bw-w, left-w)
row['at'][0] += target-x
left = target
if target < bx or y < by or y+h > by+bh:
return None
return trial
active = copy.deepcopy([m for m in members if not m['transit']])
# A smaller sprite keeps its feet, so its vertical interval moves. Rebuild
# components after EVERY trial, including unsuccessful trials. Scale ceilings
# only decrease, making termination independent of an arbitrary iteration cap.
while True:
groups, bottom = [], -math.inf
for member in active:
member['row'] = scaled(member, member['row']['scale'])
for member in sorted(active, key=lambda m: (actor_identity_core(m['row'])[1], m['row']['key'])):
x, y, w, h = actor_identity_core(member['row'])
if y >= bottom:
groups.append([])
bottom = y+h
else:
bottom = max(bottom, y+h)
groups[-1].append(member)
reduced = False
for group in groups:
group.sort(key=lambda m: (m['row']['center'][0], m['row']['key']))
ceiling = max(1, *(m['row']['scale'] for m in group))
if pack(group, ceiling) is None and ceiling > 1:
for member in group:
member['row'] = scaled(member, max(1, int(ceiling)-1))
reduced = True
if not reduced:
break
result = {m['row']['key']: copy.deepcopy(m['row']) for m in members if m['transit']}
aggregations = []
for group in groups:
group.sort(key=lambda m: (m['row']['center'][0], m['row']['key']))
base = max(1, *(m['row']['scale'] for m in group))
fitted = pack(group, base)
if fitted is None:
retained, fitted, identities = [], [], []
for member in group:
row = member['row']
identities.append(dict(key=row['key'], id=row['key'].split('/', 1)[1],
state=row['state'], cell=row['cell'], mode=row['mode']))
attempt = pack(retained+[member], 1)
if attempt is not None:
retained.append(member)
fitted = attempt
aggregations.append(dict(members=identities, drawn_keys=[r['key'] for r in fitted],
at=group[0]['bounds'][:2], text='+'+str(len(group)-len(fitted))))
result.update({row['key']: row for row in fitted})
return result, aggregations
def actor_track_transit(report, key, cell):
"""Track endpoint is bound to raw state by the caller, not to a draw flag."""
require(type(report['paused']) is bool, 'actor pause must be boolean')
track = report['actor_tracks'][key]
close(track['cell'], cell, 'actor authoritative cell')
origin = track['from']
require(isinstance(origin, list) and len(origin) == 3
and all(type(v) is int for v in origin)
and origin[2] == cell[2]
and abs(origin[0]-cell[0])+abs(origin[1]-cell[1]) <= 1,
'actor track is not a source-valid adjacent step')
now, started = report['animation_time'], track['at']
require(all(type(v) in (int, float) and math.isfinite(v) for v in (now, started))
and now >= started, 'invalid or future actor track time')
return not report['paused'] and origin != cell and now-started < .42
def compare_actor_geometry(state, report):
runtime = state['systems']['runtime']
compare_queues(state, report)
compare_room_services(state, report)
boarded = {actor.replace('staff:', 'staff/', 1).replace('guest:', 'guest/', 1): True
for shaft in elevator_report(state)['shafts'] for actor in shaft['boarded']}
close(report['boarded'], boarded, 'boarded actor coverage')
transform = Transform(runtime, report)
p, height = transform.dim[0]/16, transform.dim[1]
facilities = codec.indexed(runtime['facilities']['instances'], 'instance_id')
@@ -1139,7 +1353,7 @@ def compare_actor_geometry(state, report):
counts, expected = {}, []
def track_position(key, cell):
track = report['actor_tracks'][key]
close(track['cell'], cell, 'actor authoritative cell')
actor_track_transit(report, key, cell)
t = 1 if report['paused'] else max(0, min(1, (report['animation_time']-track['at'])/.42))
a, b = transform.center(track['from']), transform.center(cell)
return [a[i]+(b[i]-a[i])*t for i in (0, 1)]
@@ -1182,7 +1396,10 @@ def compare_actor_geometry(state, report):
continue
center = track_position(key, cell)
special = True
if sid in report['carried_patients']:
if key in report['queue_positions']:
special = False
center = report['queue_positions'][key]
elif sid in report['carried_patients']:
carrier = staff.get(report['carried_patients'][sid])
if carrier:
center = track_position('staff/'+carrier['staff_id'], carrier['current_cell'])
@@ -1206,31 +1423,127 @@ def compare_actor_geometry(state, report):
center = report['queue_positions'].get(key, center)
if center is not None:
expected.append((key, center, True, False, bool(member['carried_inventory_id']) and not special, False))
require([r['key'] for r in report['actor_drawings']] == [r[0] for r in expected], 'actor drawing coverage/order')
pairs = list(zip(report['actor_drawings'], expected))
floor_keys = [r[0] for r in expected]
cabin_bounds = {}
shafts = {s['shaft_id']: s for s in elevator_report(state)['shafts']}
for cabin in report['cabins']:
shaft = shafts[cabin['shaft_id']]
x,y,w,h = cabin['rect']
columns = max(int((w/p-4)/8), 1)
passengers = shaft['boarded'][:columns*2]
require(len(cabin['passengers']) == len(passengers), 'passenger coverage')
for i, (actor_id, row) in enumerate(zip(passengers, cabin['passengers'])):
passengers = shaft['boarded']
for i, actor_id in enumerate(passengers):
key = actor_id.replace('staff:', 'staff/', 1).replace('guest:', 'guest/', 1)
is_staff = key.startswith('staff/')
center = [x+(2+(i%columns+.5)*8)*p, y+h-(2+(i//columns)*9)*p+3*p-height*.5]
center = [x+(2+(i%columns+.5)*8)*p, y+h-(2+((i//columns)%2)*9)*p+3*p-height*.5]
carried = bool(staff.get(key.removeprefix('staff/'), {}).get('carried_inventory_id')) if is_staff else False
pairs.append((row, (key, center, is_staff, False, carried, True)))
for row, (key, center, is_staff, receiving, carrying, riding) in pairs:
close(row['center'], center, 'actor center/interpolation')
expected.append((key, center, is_staff, False, carried, True))
cabin_bounds[key] = cabin['rect']
people = {'guest/'+r['guest_id']: r for r in runtime['guests']['guests']}
people.update({'staff/'+sid: r for sid, r in staff.items()})
def tracked_bounds(key, cell):
track = report['actor_tracks'][key]
transit = actor_track_transit(report, key, cell)
rect = transform.rect(cell)
if transit:
other = transform.rect(track['from'])
x, y = min(rect[0], other[0]), min(rect[1], other[1])
rect = [x, y, max(rect[0]+rect[2], other[0]+other[2])-x,
max(rect[1]+rect[3], other[1]+other[3])-y]
return rect, transit
members = []
for key, center, is_staff, receiving, carrying, riding in expected:
person = people[key]
cell = person['current_cell']
track = report['actor_tracks'].get(key, {})
region, transit = (cabin_bounds[key], False) if riding else tracked_bounds(key, cell)
fid = ''
if not riding:
if key in report['queue_positions']:
cx, cy = report['queue_positions'][key]
region, transit = [cx-transform.dim[0]/2, cy-height/2, transform.dim[0], height], False
elif not is_staff:
target = person['target_facility_id']
if receiving and target in facilities and key.split('/', 1)[1] in report['rooms'].get(target, {}).get('people', []):
fid = target
else:
sid = person['staff_id']
if sid in report['carried_patients']:
carrier = staff[report['carried_patients'][sid]]
region, transit = tracked_bounds('staff/'+carrier['staff_id'], carrier['current_cell'])
region[1] -= 12*p
elif sid in report['resting_staff']:
fid = report['resting_staff'][sid]
elif sid in report['treated_patients']:
fid = report['treated_patients'][sid]
else:
target = person['assigned_facility_id']
cells = occupancy.get(target, [])
workers = report['rooms'].get(target, {}).get('staff', [])
if person['state'] in ('WORKING', 'AVAILABLE') and target in facilities and cell in cells and sid in workers:
rect = transform.room(cells)
columns = max(int(rect[2]/(16*p)), 1)
slot = workers.index(sid)
if rect[3] >= 40*p and slot < columns:
region, transit = [rect[0]+slot*rect[2]/columns, rect[1], rect[2]/columns, rect[3]], False
if fid and occupancy.get(fid):
region, transit = transform.room(occupancy[fid]), False
scale = .5 if riding else .75
scale = max(math.floor(p*scale), 1) if p >= 2 else p*scale
close(row['scale'], scale, 'actor scale')
at = [center[0]-8*scale, center[1]+height*.5-3*p-17*scale]
rounded = [math.copysign(math.floor(abs(v)+.5), v) for v in at]
close(row['at'], rounded, 'actor drawing position')
require((row['key'], row['staff'], row['receiving'], row['carrying'], row['riding']) ==
(key, is_staff, receiving, carrying, riding), 'actor drawing attributes')
hashed = 5381
for char in key:
hashed = (hashed*33+ord(char)) & 0xffffffff
variant = hashed % 15
frame = int(report['animation_time']*12)+variant
activity = facilities.get(person.get('target_facility_id'), {}).get('definition_id', '') if not is_staff else 'work'
if is_staff and person['role_id'] == 'cleaner':
activity = 'idle'
task = next((t for t in runtime['staff']['tasks'] if t['task_id'] == person['current_task_id']), None)
room = facilities.get(person['assigned_facility_id'], {})
if (person['state'] == 'WORKING' and person['health'] > 0 and not person['is_retiring']
and room.get('definition_id') == 'cleaning_room' and room.get('state') in ('OPEN', 'DEGRADED')
and not room.get('suspension_reason') and task and task['task_type'] == 'facility_clean'
and task['state'] == 'WORKING' and task['assigned_staff_id'] == person['staff_id']
and cell == task['target_cell'] and any(r['cell'] == cell for r in runtime['path']['cell_traffic'])
and not any(t['actor_id'] == 'staff:'+person['staff_id'] for t in runtime['elevators']['trips'])
and task['target_entity_id'] in facilities
and any(r['id'] == task['target_entity_id'] for r in runtime['facility_cleanliness']['facilities'])):
activity = 'clean'
moving = (not receiving and key not in report['queue_positions'] and not riding
and not report['paused'] and track.get('cell') != track.get('from')
and report['animation_time']-track.get('at', 0) < .42)
mode = 'idle'
if is_staff and person['state'] == 'INCAPACITATED':
mode = 'collapsed'
elif receiving and activity in ('standard_room', 'premium_room'):
mode = 'standard_room_sleep' if activity == 'standard_room' else 'sleep'
elif moving:
mode = 'carry_walk' if carrying else 'walk'
elif carrying:
mode = 'carry'
elif is_staff and person['state'] == 'WORKING' and not riding:
mode = activity if activity in ('clean', 'idle', 'work') else 'work'
elif receiving and activity in ('cafeteria', 'tavern'):
mode = 'eat'
elif key in report['queue_positions'] or (not is_staff and person['state'] == 'QUEUING'):
mode = 'wait'
states = enum_names(ROOT, 'scripts/staff/staff_runtime.gd' if is_staff else 'scripts/guest/guest_runtime.gd', 'State')
row = dict(key=key, center=center, at=rounded, scale=scale, cell=cell, mode=mode,
frame=frame, variant=variant, flip=track.get('direction', 1) < 0,
staff=is_staff, state=states.index(person['state']), receiving=receiving,
carrying=carrying, riding=riding)
members.append(dict(row=row, bounds=[region[0]+p, region[1]+p, region[2]-2*p, region[3]-2*p], transit=transit))
fitted, aggregations = fitted_actor_layout(members, p, height)
close(report.get('actor_aggregations'), aggregations, 'actor aggregation/no-fit')
require([r['key'] for r in report['actor_drawings']] == [k for k in floor_keys if k in fitted], 'actor drawing coverage/order')
actual = list(report['actor_drawings']) + [r for c in report['cabins'] for r in c['passengers']]
require(len(actual) == len(fitted) and {r['key'] for r in actual} == set(fitted), 'missing or duplicate actor')
for row in actual:
for field, value in fitted[row['key']].items():
close(row[field], value, 'actor fitted '+field)
exemptions = {m['row']['key'] for m in members if m['transit']}
validate_actor_nonoverlap(report, transit_keys=exemptions)
return ['actor_geometry', 'passenger_geometry']
@@ -1270,6 +1583,20 @@ def compare_layouts(a, b):
return dict(metric=declaration['metric'], A=metrics[0], B=metrics[1])
def drawing_context(stream, capture, report):
"""Shared OS/offline binding: a missing stream never grants exemptions."""
require(isinstance(capture, dict) and all(k in capture for k in ('report', 'state', 'rest_audit')),
'missing raw drawing context')
close(read_object(stream, capture['report']), report, 'raw-state report binding')
state = read_object(stream, capture['state'])
rest = read_object(stream, capture['rest_audit'])
require(isinstance(state, dict) and isinstance(state.get('systems', {}).get('runtime'), dict),
'malformed raw state context')
require(isinstance(rest, dict) and isinstance(rest.get('staff'), list)
and 'path_service_sha256' in rest, 'malformed rest authority')
return state, rest
def read_object(directory, digest):
require(isinstance(digest, str) and re.fullmatch('[0-9a-f]{64}', digest), 'invalid object digest')
path = directory / 'objects' / (digest + '.json')
@@ -1458,7 +1785,7 @@ def inspect_os_requests(directory, layout, role, pid, root=ROOT):
require(request['ctrl'] is False and any(e.get('ctrl') is False and e.get('pressed') for e in observed['events']), 'ordinary wheel evidence')
report = decode(request['report'])
capture = captures[request_path.parent.name]
close(read_object(stream, capture['report']), report, 'request draw report binding')
state, rest_audit = drawing_context(stream, capture, report)
for number, shot in enumerate(cua['screenshots']):
matches = [b for b in bindings if b['request'] == str(request_path.relative_to(directory)) and b['screenshot_index'] == number]
require(len(matches) == 1, 'screenshot binding coverage')
@@ -1485,7 +1812,8 @@ def inspect_os_requests(directory, layout, role, pid, root=ROOT):
if request['action'] == 'screenshot':
clicks = [document(json.loads(path(name).read_bytes())['input_receipt'])
for name in listing['requests']]
frame = frame_rows(report, decode(request['rectangles']), request, cua, [image], clicks, root)
frame = frame_rows(report, decode(request['rectangles']), request, cua, [image], clicks, root,
state, rest_audit)
review_dir = request_path.parent/('review-image-' + str(number))
manifest, manifest_sha = write_frame_review(review_dir, frame, [dict(
whole_image_sha256=binding['png_sha256'], raw_sha256=shot['raw_sha256'],
tools/test_p23_life_observation_evidence.py
+727 -3
View File
@@ -18,6 +18,165 @@ sys.dont_write_bytecode = True
import check_p23_life_observation_evidence as check
class ActorNonoverlapTests(unittest.TestCase):
def report(self, second_at):
return dict(actor_drawings=[
dict(key='guest/a', at=[0, 0], scale=1, mode='idle', frame=0, flip=False),
dict(key='staff/b', at=second_at, scale=1, mode='idle', frame=0, flip=False)], cabins=[])
def test_edge_contact_is_not_overlap(self):
for at in ([6, 0], [0, 12], [-6, 0], [0, -12]):
with self.subTest(at=at):
check.validate_actor_nonoverlap(self.report(at))
def test_overlap_ignores_asserted_verdicts_and_offscreen_labels(self):
report = self.report([5, 11])
for actor in report['actor_drawings']:
actor.update(mechanical_pass=True, eligibility='offscreen', rect=[999, 999, 1, 1])
with self.assertRaisesRegex(ValueError, 'actor-actor core overlap: guest/a / staff/b'):
check.validate_actor_nonoverlap(report)
def test_cabin_passenger_is_checked_against_floor_actor(self):
report = self.report([0, 0])
report['cabins'] = [dict(passengers=[report['actor_drawings'].pop()])]
with self.assertRaisesRegex(ValueError, 'actor-actor core overlap'):
check.validate_actor_nonoverlap(report)
def test_invalid_footprints_are_not_silently_skipped(self):
for scale in (0, -1, float('nan'), float('inf'), True):
report = self.report([100, 100])
report['actor_drawings'][0]['scale'] = scale
with self.subTest(scale=scale), self.assertRaisesRegex(ValueError, 'invalid actor footprint'):
check.validate_actor_nonoverlap(report)
def test_r13_false_row_11_overlaps_staff_row_29(self):
fixture = json.loads((check.ROOT / 'tests/fixtures/p23-03/r13_actor_overlap.json').read_text())
self.assertEqual(fixture['independent_judgment'], [11, False, False, False])
with self.assertRaisesRegex(ValueError,
'actor-actor core overlap: guest/guest-auto-00000041 / staff/staff_gina'):
check.validate_actor_nonoverlap(fixture['report_inputs'])
# Exercise the actual offline evidence gate, before any audit assertions.
with self.assertRaisesRegex(ValueError, 'actor-actor core overlap'):
check.validate_drawing_rows(fixture['report_inputs'], {'rows': []})
def test_overlapping_full_boxes_with_disjoint_cores_pass(self):
# Both 16x18 boxes overlap by 9x18, but their six-pixel cores do not.
check.validate_actor_nonoverlap(self.report([7, 0]))
def test_walk_bob_is_part_of_core(self):
report = self.report([0, 12])
report['actor_drawings'][1].update(mode='walk', frame=2)
with self.assertRaisesRegex(ValueError, 'actor-actor core overlap'):
check.validate_actor_nonoverlap(report)
report['actor_drawings'][1]['frame'] = 3
check.validate_actor_nonoverlap(report)
def test_flipped_core_and_lying_breathing_bounds(self):
actor = self.report([0, 0])['actor_drawings'][0]
actor.update(flip=True, scale=3)
self.assertEqual(check.actor_identity_core(actor), [12, 3, 18, 36])
actor.update(mode='standard_room_sleep', frame=2)
self.assertEqual(check.actor_identity_core(actor), [3, 30, 39, 18])
actor['frame'] = 5
self.assertEqual(check.actor_identity_core(actor), [3, 33, 39, 15])
actor.update(mode='collapsed', flip=False)
self.assertEqual(check.actor_identity_core(actor), [6, 33, 39, 15])
def test_missing_pose_is_rejected(self):
report = self.report([100, 0])
del report['actor_drawings'][0]['frame']
with self.assertRaisesRegex(ValueError, 'missing actor pose'):
check.validate_actor_nonoverlap(report)
def test_duplicate_actor_is_rejected(self):
report = self.report([100, 0])
report['actor_drawings'][1]['key'] = 'guest/a'
with self.assertRaisesRegex(ValueError, 'duplicate actor drawing'):
check.validate_actor_nonoverlap(report)
def test_forged_transit_flag_does_not_exempt_overlap(self):
report = self.report([0, 0])
report['actor_drawings'][1]['in_transit'] = True
with self.assertRaisesRegex(ValueError, 'actor-actor core overlap'):
check.validate_actor_nonoverlap(report)
def test_core_table_requires_exact_art_source(self):
with mock.patch.object(check, 'PIXEL_PEOPLE_CORE_SHA256', '0' * 64):
with self.assertRaisesRegex(ValueError, 'PixelPeople core source SHA256'):
check.validate_actor_nonoverlap(self.report([100, 0]))
def test_recorded_service_region_and_logical_cell_have_no_common_area(self):
# Diagnostic of the unresolved simultaneous-bounds requirement, not
# permission to hide these occupants or bypass containment checks.
fixture = json.loads((check.ROOT / 'tests/fixtures/p23-03/r13_service_region_gap.json').read_text())
for guest in fixture['guests']:
traffic = next(r for r in fixture['traffic'] if r['cell'] == guest['cell'])
x, y, w, h = traffic['rect']
cell = [x - 2, y - 2, w + 4, h + 4] # get_cell_rect(...).grow(-2)
pixel = cell[2] / 16
x, y, w, h = fixture['room_rects'][guest['target']]
region = [x + pixel, y + pixel, w - 2 * pixel, h - 2 * pixel]
with self.subTest(guest=guest['id']):
self.assertLessEqual(min(cell[0] + cell[2], region[0] + region[2])
- max(cell[0], region[0]), 0)
class LifeOverlayTests(unittest.TestCase):
def report(self):
return dict(observation_serial=7, overlay_consumed_serial=7,
overlay_passes=['traffic', 'actors'], overlay_child_indices=[0, 1, 2],
actor_drawings=[dict(key='guest/a', at=[20, 30], scale=3,
mode='idle', frame=0, flip=False)], cabins=[],
traffic=[dict(rect=[2, 2, 60, 92], band_rect=[9.2, 85.5, 45.6, 5],
traffic=dict(current_density=1, temporary_block=False))])
def test_front_and_back_valid_consumed_band(self):
for layer in (0, 1):
report = self.report()
report['layer'] = layer
check.validate_life_overlay(report)
def test_stale_serial_fails(self):
report = self.report()
report['overlay_consumed_serial'] = 6
with self.assertRaisesRegex(ValueError, 'stale LifeOverlay serial'):
check.validate_life_overlay(report)
def test_band_after_actors_fails(self):
report = self.report()
report['overlay_passes'].reverse()
with self.assertRaisesRegex(ValueError, 'LifeOverlay pass order'):
check.validate_life_overlay(report)
def test_overlay_below_inactive_art_fails(self):
report = self.report()
report['overlay_child_indices'] = [1, 0, 2]
with self.assertRaisesRegex(ValueError, 'LifeOverlay child order'):
check.validate_life_overlay(report)
def test_core_crossed_by_actual_band_fails(self):
report = self.report()
report['actor_drawings'][0]['at'][1] = 60
with self.assertRaisesRegex(ValueError, 'traffic band covers actor core'):
check.validate_life_overlay(report)
def test_forged_band_geometry_fails(self):
report = self.report()
report['traffic'][0]['band_rect'][1] = 50
with self.assertRaisesRegex(ValueError, 'traffic band rectangle'):
check.validate_life_overlay(report)
def test_report_cannot_excuse_wrong_source_order(self):
source = (check.ROOT / 'scenes/main/world_preview.gd').read_text()
# Claimed pass order stays valid; actual callback source is inverted.
broken = source.replace('_draw_congestion_overlay(_life_overlay)', 'SWAP')
broken = broken.replace('_draw_actors(_life_overlay)', '_draw_congestion_overlay(_life_overlay)')
broken = broken.replace('SWAP', '_draw_actors(_life_overlay)')
with mock.patch.object(Path, 'read_text', return_value=broken):
with self.assertRaisesRegex(ValueError, 'LifeOverlay source pass order'):
check.validate_life_overlay(self.report())
class SetupBudgetTests(unittest.TestCase):
def setUp(self):
self.source = (check.ROOT / 'tests/fixtures/p23-03/observation.gd').read_text()
@@ -452,6 +611,83 @@ class SemanticTests(unittest.TestCase):
self.assertEqual(before, self.snapshot)
class PackingTests(unittest.TestCase):
def test_scale_trial_rebuilds_vertical_groups(self):
members = self.members(2)
for member, y in zip(members, (118, 144)):
member['row'].update(center=[108, y], at=[84, y-15])
member['bounds'] = [80, 74, 20, 130]
# At p=3 the vertical intervals intersect; at p=2 they separate.
# Keeping the stale component would incorrectly force both down to p=1.
rows, badges = check.fitted_actor_layout(members, 4, 96)
self.assertEqual(badges, [])
self.assertEqual([rows['guest/'+str(i)]['scale'] for i in range(2)], [2, 2])
self.assertEqual([rows['guest/'+str(i)]['at'] for i in range(2)], [[76, 120], [76, 146]])
check.validate_actor_nonoverlap(dict(actor_drawings=list(rows.values()), cabins=[]))
def members(self, count=4):
# R13 cell dimensions and the actual _actor_offset sequence; no transit.
offsets = [0, 16, -16, 8, -8, 24, -24]
return [dict(row=dict(key='guest/'+str(i), center=[108+offsets[i % 7], 118-4*(i % 2)],
at=[84+offsets[i % 7], 103-4*(i % 2)], scale=3,
mode='idle', frame=0, flip=False, state=3, cell=[1, 1, 0]),
bounds=[80, 74, 56, 88], transit=False) for i in range(count)]
def test_four_movers_fit_at_two_not_three(self):
rows, badges = check.fitted_actor_layout(self.members(), 4, 96)
self.assertEqual(badges, [])
self.assertEqual([rows['guest/'+str(i)]['scale'] for i in range(4)], [2]*4)
self.assertEqual([rows['guest/'+str(i)]['at'] for i in range(4)],
[[88, 120], [112, 116], [76, 120], [100, 116]])
check.validate_actor_nonoverlap(dict(actor_drawings=list(rows.values()), cabins=[]))
def test_cross_kind_group_and_passenger(self):
members = self.members()
members[1]['row']['key'] = 'staff/worker'
members[2]['row']['key'] = 'guest/passenger'
members[2]['row']['scale'] = 2
members[2]['row']['at'] = [76, 120]
rows, badges = check.fitted_actor_layout(members, 4, 96)
self.assertEqual(badges, [])
self.assertEqual(len(rows), 4)
check.validate_actor_nonoverlap(dict(actor_drawings=list(rows.values()), cabins=[]))
def test_saturation_keeps_all_identities(self):
rows, badges = check.fitted_actor_layout(self.members(12), 4, 96)
self.assertEqual(len(rows), 9)
self.assertEqual(len(badges), 1)
self.assertEqual(len(badges[0]['members']), 12)
self.assertEqual(badges[0]['text'], '+3')
self.assertEqual(set(badges[0]['drawn_keys']), set(rows))
self.assertTrue(all(r['scale'] == 1 for r in rows.values()))
check.validate_actor_nonoverlap(dict(actor_drawings=list(rows.values()), cabins=[]))
def test_each_actor_keeps_own_bounds(self):
members = self.members(2)
members[0]['bounds'] = [80, 74, 12, 88]
members[1]['bounds'] = [124, 74, 12, 88]
rows, badges = check.fitted_actor_layout(members, 4, 96)
self.assertEqual(badges, [])
self.assertEqual(check.actor_identity_core(rows['guest/0'])[0:3:2], [80, 12])
self.assertEqual(check.actor_identity_core(rows['guest/1'])[0:3:2], [124, 12])
def test_receiving_cafeteria_uses_r13_room_not_access_cell(self):
fixture = json.loads((check.ROOT/'tests/fixtures/p23-03/r13_service_region_gap.json').read_text())
guest = fixture['guests'][0]
rect = fixture['room_rects'][guest['target']]
anchor = check.room_slots(rect, 4, 'cafeteria')[0]
center = [anchor[0], anchor[1]+12-48]
member = dict(row=dict(key='guest/'+guest['id'], center=center,
at=[center[0]-24, center[1]-15], scale=3,
mode='eat', frame=0, flip=False, state=5, cell=guest['cell']),
bounds=[rect[0]+4, rect[1]+4, rect[2]-8, rect[3]-8], transit=False)
rows, badges = check.fitted_actor_layout([member], 4, 96)
self.assertFalse(badges)
core = check.actor_identity_core(next(iter(rows.values())))
self.assertGreaterEqual(core[0], 1031)
self.assertEqual(next(iter(rows.values()))['cell'], [5, 0, 0])
class SpatialTests(unittest.TestCase):
def setUp(self):
self.runtime = dict(world=dict(bounds=dict(min_x=0, max_x=1, min_y=0, max_y=0),
@@ -464,11 +700,178 @@ class SpatialTests(unittest.TestCase):
self.snapshot = dict(systems=dict(runtime=self.runtime))
self.report = dict(viewport=[184, 164], zoom=1, pan=[0, 0], layer=0,
traffic=[dict(cell=[0, 0, 0], rect=[78, 72, 12, 20],
band_rect=[79.44, 90.4, 9.12, 3.2],
traffic=dict(base_capacity=2, current_density=3,
dynamic_cost=0, temporary_block=False))],
queue_positions={}, queue_hidden={}, landing_badges=[], rooms={},
treated_patients={}, carried_patients={}, resting_staff={},
goods=dict(requests=[], deliveries=[]))
goods=dict(requests=[], deliveries=[]), actor_drawings=[], cabins=[],
observation_serial=1, overlay_consumed_serial=1,
overlay_passes=['traffic', 'actors'], overlay_child_indices=[0, 1, 2])
def four_movers(self):
self.runtime['world'].update(bounds=dict(min_x=1, max_x=1, min_y=1, max_y=1), walkable_cells=[[1, 1, 0]])
self.report.update(viewport=[216, 236], paused=True, animation_time=0,
actor_tracks={}, boarded={}, actor_aggregations=[])
for i, (center, at) in enumerate(zip([[108,118], [124,114], [92,118], [116,114]],
[[88,120], [112,116], [76,120], [100,116]])):
key = 'guest/'+str(i)
self.runtime['guests']['guests'].append(dict(guest_id=str(i), current_cell=[1,1,0],
current_service_id='', target_facility_id='', state='MOVING'))
self.report['actor_tracks'][key] = dict(cell=[1,1,0], **{'from':[1,1,0]}, at=0, direction=1)
hashed = 5381
for char in key:
hashed = (hashed*33+ord(char)) & 0xffffffff
self.report['actor_drawings'].append(dict(key=key, center=center, at=at, scale=2,
cell=[1,1,0], mode='idle', frame=hashed%15, variant=hashed%15, flip=False,
staff=False, state=3, receiving=False, carrying=False, riding=False))
def test_four_movers_complete_geometry(self):
self.four_movers()
check.compare_actor_geometry(self.snapshot, self.report)
def moving_four(self):
self.four_movers()
self.report.update(paused=False, animation_time=.21, badges=[])
for row in self.report['actor_drawings']:
self.report['actor_tracks'][row['key']]['from'] = [0, 1, 0]
row['center'][0] -= 32
row.update(scale=3, mode='walk', frame=row['variant']+2)
row['at'] = [row['center'][0]-24, row['center'][1]-15]
def drawing_audit(self):
rows = []
for category, identifier, rect, source, text in check.drawing_rectangle_rows(self.report):
self.assertIsNone(text)
colors = list(dict.fromkeys(check.re.findall(r'Color\("([0-9a-fA-F]{6})"',
(check.ROOT/source).read_text())))
rows.append(dict(category=category, id=identifier, rect=rect,
style_source=source, style_colors=colors))
return dict(rows=rows)
def test_transit_raw_state_in_full_and_standalone_paths(self):
self.moving_four()
check.compare_actor_geometry(self.snapshot, self.report)
check.validate_drawing_rows(self.report, self.drawing_audit(), state=self.snapshot)
# Without authoritative context the overlapping moving cores fail closed.
with self.assertRaisesRegex(ValueError, 'core overlap'):
check.validate_drawing_rows(self.report, self.drawing_audit())
def test_transit_cannot_be_claimed_by_flags_or_invalid_tracks(self):
self.moving_four()
mutations = {
'paused': lambda r: r.update(paused=True),
'expired': lambda r: r.update(animation_time=.42),
'nonboolean_pause': lambda r: r.update(paused=0),
'future': lambda r: r['actor_tracks']['guest/0'].update(at=1),
'nonfinite': lambda r: r.update(animation_time=float('nan')),
'wrong_endpoint': lambda r: r['actor_tracks']['guest/0'].update(cell=[0, 1, 0]),
'teleport_origin': lambda r: r['actor_tracks']['guest/0'].update({'from': [-9, 1, 0]}),
}
for name, mutate in mutations.items():
report = copy.deepcopy(self.report)
mutate(report)
for row in report['actor_drawings']:
row.update(in_transit=True, region='transit')
with self.subTest(name=name), self.assertRaises(ValueError):
check.validate_drawing_rows(report, self.drawing_audit(), state=self.snapshot)
def test_staff_and_guests_share_complete_geometry_front_and_back(self):
self.four_movers()
self.runtime['guests']['guests'].pop()
self.runtime['staff']['staff'] = [dict(staff_id='3', current_cell=[1, 1, 0],
state='AVAILABLE', assigned_facility_id='', carried_inventory_id='', role_id='guard')]
self.report['actor_tracks']['staff/3'] = self.report['actor_tracks'].pop('guest/3')
row = self.report['actor_drawings'][-1]
hashed = 5381
for char in 'staff/3':
hashed = (hashed*33+ord(char)) & 0xffffffff
row.update(key='staff/3', staff=True, state=2, variant=hashed%15, frame=hashed%15)
for layer in (0, 1):
self.report['layer'] = layer
for member in self.runtime['guests']['guests'] + self.runtime['staff']['staff']:
member['current_cell'][2] = layer
for track in self.report['actor_tracks'].values():
track['cell'][2] = layer
track['from'][2] = layer
for drawing in self.report['actor_drawings']:
drawing['cell'][2] = layer
with self.subTest(layer=layer):
check.compare_actor_geometry(self.snapshot, self.report)
def test_spoofed_region_does_not_allow_core_outside_own_cell(self):
self.four_movers()
self.report['actor_drawings'][0].update(region='facility', in_transit=True, at=[500, 120])
with self.assertRaises(ValueError):
check.compare_actor_geometry(self.snapshot, self.report)
def test_aggregation_badge_is_required_in_drawing_audit(self):
self.four_movers()
self.report['badges'] = []
audit = self.drawing_audit()
self.report['actor_aggregations'] = [dict(at=[80, 74], text='+1',
members=[], drawn_keys=[])]
# This low-level test covers badge provenance only. Full geometry already
# rejects the unnecessary aggregate in test_fitted_geometry_rejects_tampering.
with self.assertRaisesRegex(ValueError, 'offline rectangle coverage'):
check.validate_drawing_rows(self.report, audit)
def test_low_world_pixel_complete_geometry_keeps_fractional_base(self):
self.four_movers()
self.runtime['guests']['guests'] = self.runtime['guests']['guests'][:1]
self.report.update(viewport=[156, 146], actor_drawings=self.report['actor_drawings'][:1])
self.report['actor_drawings'][0].update(center=[78, 73], at=[77, 72], scale=.1875)
check.compare_actor_geometry(self.snapshot, self.report)
def test_saturated_complete_geometry_keeps_every_identity(self):
self.four_movers()
prototype = copy.deepcopy(self.report['actor_drawings'][0])
self.runtime['guests']['guests'] = []
self.report['actor_drawings'] = []
# 10 upright cores need 60px at p=1, but the interval is only 56px.
# The first nine in preferred-x/key order occupy x82..136; guest/5
# cannot be retained. This expected layout is independent of the solver.
order = [6, 2, 9, 4, 0, 7, 3, 1, 8, 5]
identities = {}
for i in range(10):
key = 'guest/'+str(i)
cell = [1, 1, 0]
self.runtime['guests']['guests'].append(dict(guest_id=str(i), current_cell=cell,
current_service_id='', target_facility_id='', state='MOVING'))
self.report['actor_tracks'][key] = dict(cell=cell, **{'from': cell}, at=0, direction=1)
identities[i] = dict(key=key, id=str(i), cell=cell, state=3, mode='idle')
if i == 5:
continue
hashed = 5381
for char in key:
hashed = (hashed*33+ord(char)) & 0xffffffff
center = [108+[0,16,-16,8,-8,24,-24][i%7], 118-4*(i%2)]
self.report['actor_drawings'].append(dict(prototype, key=key, center=center,
at=[76+6*order.index(i), center[1]+19], scale=1, frame=hashed%15, variant=hashed%15))
self.report['actor_aggregations'] = [dict(members=[identities[i] for i in order],
drawn_keys=['guest/'+str(i) for i in order[:-1]], at=[80,74], text='+1')]
check.compare_actor_geometry(self.snapshot, self.report)
self.report['actor_aggregations'][0]['members'].pop()
with self.assertRaisesRegex(ValueError, 'aggregation/no-fit'):
check.compare_actor_geometry(self.snapshot, self.report)
def test_fitted_geometry_rejects_tampering(self):
self.four_movers()
for field, value in [('cell', [0,1,0]), ('state', 4), ('scale', 3), ('at', [999,120])]:
report = copy.deepcopy(self.report)
report['actor_drawings'][0][field] = value
with self.subTest(field=field), self.assertRaises(ValueError):
check.compare_actor_geometry(self.snapshot, report)
for mutation in ('missing', 'duplicate', 'aggregate'):
report = copy.deepcopy(self.report)
if mutation == 'missing':
report['actor_drawings'].pop()
elif mutation == 'duplicate':
report['actor_drawings'].append(copy.deepcopy(report['actor_drawings'][0]))
else:
report['actor_aggregations'] = [dict(drawn_keys=[], text='+4')]
with self.subTest(mutation=mutation), self.assertRaises(ValueError):
check.compare_actor_geometry(self.snapshot, report)
def test_density_and_pan_are_independently_recomputed(self):
check.compare_traffic(self.snapshot, self.report)
@@ -537,6 +940,247 @@ class SpatialTests(unittest.TestCase):
check.compare_cabin_geometry(self.snapshot, changed)
class AnchoredGeometryTests(unittest.TestCase):
"""Whole state classification fixtures, with independently chosen draw rows."""
def setUp(self):
SpatialTests.setUp(self)
self.runtime['world'].update(bounds=dict(min_x=0, max_x=3, min_y=0, max_y=1),
walkable_cells=[[x, y, 0] for y in range(2) for x in range(4)])
self.report.update(viewport=[408, 332], paused=True, animation_time=0,
actor_tracks={}, boarded={}, actor_aggregations=[], badges=[], traffic=[])
self.runtime.update(defense=dict(raids=[]), events=dict(actor_locks={}))
def person(self, key, cell, state='MOVING', **fields):
kind, identifier = key.split('/')
if kind == 'guest':
person = dict(guest_id=identifier, current_cell=cell, state=state,
current_service_id='', target_facility_id='')
self.runtime['guests']['guests'].append(person)
else:
person = dict(staff_id=identifier, current_cell=cell, state=state, health=100,
assigned_facility_id='', current_task_id='', carried_inventory_id='', role_id='guard')
self.runtime['staff']['staff'].append(person)
person.update(fields)
self.report['actor_tracks'][key] = dict(cell=cell[:], **{'from': cell[:]}, at=0, direction=1)
return person
def drawing(self, key, center, mode='idle', scale=3, receiving=False, riding=False, at=None):
kind, identifier = key.split('/')
source = self.runtime['staff']['staff'] if kind == 'staff' else self.runtime['guests']['guests']
person = next(r for r in source if r[kind+'_id'] == identifier)
hashed = 5381
for char in key:
hashed = (hashed*33+ord(char)) & 0xffffffff
row = dict(key=key, center=center, at=at or [center[0]-8*scale, center[1]+36-17*scale],
scale=scale, mode=mode, frame=hashed%15, variant=hashed%15, flip=False,
staff=kind == 'staff', state=check.enum_names(check.ROOT,
'scripts/'+kind+'/'+kind+'_runtime.gd', 'State').index(person['state']),
cell=person['current_cell'][:], receiving=receiving, carrying=False, riding=riding)
if not riding:
self.report['actor_drawings'].append(row)
return row
def room(self, fid, definition, cells, users=(), workers=()):
facility = dict(instance_id=fid, definition_id=definition, origin=cells[0], occupied_cells=cells,
state='OPEN', state_reasons=[], suspension_reason='', customer_capacity=10,
active_services=[dict(guest_ids=list(users))] if users else [], active_staff_ids=list(workers), queue_entries=[])
self.runtime['facilities']['instances'].append(facility)
self.runtime['world']['occupancies'].append(dict(entity_id=fid, cells=cells))
self.report['rooms'][fid] = dict(people=list(users), count=len(users), staff=list(workers),
state=check.enum_names(check.ROOT, 'scripts/facility/facility_instance.gd', 'State').index('OPEN'),
state_name='OPEN', reasons=[], operation=1, limit=10, suspension='', definition_id=definition,
rect=check.Transform(self.runtime, self.report).room(cells))
return facility
def queue_work(self):
facility = self.room('work', 'cafeteria', [[x,y,0] for y in (0,1) for x in (2,3)], workers=['w'])
for key in ('a', 'b'):
self.person('guest/'+key, [1,1,0], 'QUEUING', current_service_id='service', target_facility_id='work')
# Queue takes precedence even over a nonempty current_service_id.
facility['active_services'] = [dict(guest_ids=['a','b'])]
self.report['rooms']['work'].update(people=['a','b'], count=2)
facility['queue_entries'] = ['request']
self.runtime['facilities']['requests'] = [dict(request_id='request', guest_ids=['a','b'])]
self.person('staff/w', [2,1,0], 'WORKING', assigned_facility_id='work')
self.report['queue_positions'] = {'guest/a':[172,118], 'guest/b':[108,118]}
self.report['landing_badges'] = [dict(at=[140,54], text='待ち2人', cell=[1,1,0],
members=['guest/a','guest/b'], visible_count=2, overflow=0)]
self.drawing('guest/a', [172,118], 'eat', receiving=True)
self.drawing('guest/b', [108,118], 'eat', receiving=True)
self.drawing('staff/w', [236,126], 'work')
def test_queue_lane_and_work_staff(self):
self.queue_work()
check.compare_actor_geometry(self.snapshot, self.report)
def test_queue_precedence_order_and_category_forgeries(self):
self.queue_work()
for mutation in ('precedence', 'order', 'category', 'feet', 'pose'):
report = copy.deepcopy(self.report)
if mutation == 'precedence': report['actor_drawings'][0].update(center=[268,210], at=[244,195])
if mutation == 'order':
report['queue_positions']['guest/a'], report['queue_positions']['guest/b'] = report['queue_positions']['guest/b'], report['queue_positions']['guest/a']
if mutation == 'category': report['actor_drawings'][0].update(staff=True, region='work', in_transit=True)
if mutation == 'feet': report['actor_drawings'][0]['at'][1] -= 17
if mutation == 'pose': report['actor_drawings'][0]['mode'] = 'wait'
with self.subTest(mutation=mutation), self.assertRaises(ValueError):
check.compare_actor_geometry(self.snapshot, report)
def test_receiving_r13_guest_cannot_be_forced_into_access_cell(self):
fixture = json.loads((check.ROOT/'tests/fixtures/p23-03/r13_service_region_gap.json').read_text())
guest = fixture['guests'][0]
self.runtime['world']['bounds'].update(max_x=9)
self.report.update(viewport=[792,332], pan=[567,318])
fid = guest['target']
self.room(fid, 'cafeteria', [[x,y,0] for y in (0,1) for x in range(6,10)], users=[guest['id']])
self.person('guest/'+guest['id'], guest['cell'], 'RECEIVING_SERVICE', current_service_id='service', target_facility_id=fid)
# Exact historical room x1027..1283; access cell x963..1027.
self.assertEqual(self.report['rooms'][fid]['rect'], fixture['room_rects'][fid])
row = self.drawing('guest/'+guest['id'], [1069+2/3,528], 'eat', receiving=True, at=[1046,513])
check.compare_actor_geometry(self.snapshot, self.report)
row.update(center=[995,532], at=[971,517], region='floor')
with self.assertRaises(ValueError): check.compare_actor_geometry(self.snapshot, self.report)
def test_carried_patient_and_treated_staff(self):
self.person('staff/carrier', [0,0,0], 'AVAILABLE')
self.person('staff/patient', [0,0,0], 'INCAPACITATED')
self.person('staff/treated', [2,0,0], 'INCAPACITATED')
self.room('clinic', 'infirmary', [[2,0,0]])
self.runtime['staff']['tasks'] = [dict(task_type='rescue_transport', state=phase,
assigned_staff_id='carrier', target_entity_id=patient, rescue_facility_id='clinic')
for patient, phase in [('patient','MOVING'), ('treated','WORKING')]]
self.report.update(carried_patients={'patient':'carrier'}, treated_patients={'treated':'clinic'})
self.report['rooms']['clinic'].update(people=['treated'], count=1)
self.drawing('staff/carrier', [108,214])
self.drawing('staff/patient', [108,166], 'collapsed')
row = self.drawing('staff/treated', [236,190], 'collapsed')
check.compare_actor_geometry(self.snapshot, self.report)
self.report['actor_drawings'][1]['center'][1] += 4
self.report['actor_drawings'][1]['at'][1] += 4
with self.assertRaises(ValueError): check.compare_actor_geometry(self.snapshot, self.report)
def cabin(self, count):
shaft = json.loads((check.ROOT/'tests/fixtures/p23-03/queued_elevator.json').read_text())['saved']['shafts'][0]
shaft.update(current_floor=0, phase='IDLE', boarded=['guest:p%02d'%i for i in range(count)])
# Synthetic saved configuration, not a production definition or capacity edit.
shaft['config']['capacity'] = max(4, count)
self.runtime['elevators']['shafts'] = [shaft]
sid = shaft['config']['shaft_id']
self.report['elevator_tracks'] = {sid: dict(floor=0, **{'from':0}, at=0)}
cabin = dict(shaft_id=sid, rect=[92,174,96,76], pixel=4, operational=True, doors_open=True,
badge_at=[92,160], badge=('満員 ' if count >= 4 else '')+f'{count}/{max(4,count)}人', passengers=[])
self.report['cabins'] = [cabin]
for i in range(count):
key = 'guest/p%02d'%i
self.person(key, [0,0,0])
self.report['boarded'][key] = True
cabin['passengers'].append(self.drawing(key, [116+32*(i%2),206-36*((i//2)%2)], scale=2, riding=True))
return cabin
def occupied_rest(self):
state, _, audit = RestAuditTests().fixture()
old = state['systems']['runtime']
self.runtime['path'] = old['path']
self.person('staff/s', [0,0,0], 'OFF_DUTY')
self.room('a', 'staff_waiting_room', [[0,0,0]])
self.room('b', 'staff_waiting_room', [[0,0,0]])
for facility in self.runtime['facilities']['instances']:
facility['occupied_cells'] = [] # Public selector falls back to origin.
self.report['resting_staff'] = {'s':'a'}
self.report['rooms']['a'].update(people=['s'], count=1)
self.drawing('staff/s', [108,198])
return audit
def test_compare_rest_with_actual_occupied_facility(self):
audit = self.occupied_rest()
self.assertTrue(check.compare_rest(self.snapshot, self.report, audit)['s']['resting'])
self.report['actor_drawings'][0]['at'][1] += 1
with self.assertRaises(ValueError): check.compare_rest(self.snapshot, self.report, audit)
def test_compare_rest_independently_proves_no_fit(self):
audit = self.occupied_rest()
rest = self.report['actor_drawings'].pop()
rest.update(scale=1, at=[100,217])
order = [6,2,9,4,0,7,3,1,8,5]
identities = {}
for i in range(10):
key = 'guest/'+str(i)
self.person(key, [0,0,0])
center = [108+[0,16,-16,8,-8,24,-24][i%7],214-4*(i%2)]
row = self.drawing(key, center, scale=1, at=[76+6*order.index(i),center[1]+19])
identities[i] = dict(key=key, id=str(i), state=3, cell=[0,0,0], mode='idle')
self.report['actor_drawings'] = [r for r in self.report['actor_drawings'] if r['key'] != 'guest/5']+[rest]
self.report['actor_aggregations'] = [dict(members=[identities[i] for i in order],
drawn_keys=['guest/'+str(i) for i in order[:9]], at=[80,170], text='+1')]
check.compare_rest(self.snapshot, self.report, audit)
stale = copy.deepcopy(self.report)
stale['actor_aggregations'][0]['members'].append(dict(key='staff/s', id='s', state=0, cell=[0,0,0], mode='idle'))
with self.assertRaises(ValueError): check.compare_rest(self.snapshot, stale, audit)
self.report['actor_aggregations'][0]['members'].pop()
with self.assertRaises(ValueError): check.compare_rest(self.snapshot, self.report, audit)
def test_compare_rest_with_queued_staff(self):
audit = self.occupied_rest()
self.person('staff/q', [0,0,0], 'OFF_DUTY')
saved = json.loads((check.ROOT/'tests/fixtures/p23-03/queued_elevator.json').read_text())['saved']
saved['trips'][0]['actor_id'] = 'staff:q'
self.runtime['elevators'] = saved
self.runtime['world']['walkable_cells'].append([-1,0,0])
self.report['queue_positions'] = {'staff/q':[44,214]}
self.report['landing_badges'] = [dict(at=[-4,150], text='待ち1人', cell=[0,0,0],
members=['staff/q'], visible_count=1, overflow=0)]
queued = copy.deepcopy(audit['staff'][0])
queued.update(staff_id='q', in_transit=True)
queued['comparison_only'].update(resting=False, label='休憩先へ移動中')
audit['staff'].append(queued)
self.drawing('staff/q', [44,214], 'wait')
result = check.compare_rest(self.snapshot, self.report, audit)
self.assertTrue(result['s']['resting'])
self.assertFalse(result['q']['resting'])
self.report['actor_drawings'][-1].update(center=[108,198], at=[84,183])
with self.assertRaises(ValueError): check.compare_rest(self.snapshot, self.report, audit)
def test_passenger_and_floor_actor_front_and_back(self):
cabin = self.cabin(1)
self.person('guest/floor', [0,0,0])
self.drawing('guest/floor', [108,214])
cabin['passengers'][0]['at'][0] = 108
for layer in (0,1):
self.report['layer'] = layer
for guest in self.runtime['guests']['guests']: guest['current_cell'][2] = layer
for cell in self.runtime['elevators']['shafts'][0]['config']['stops']: cell[2] = layer
for row in self.report['actor_drawings']+cabin['passengers']: row['cell'][2] = layer
for track in self.report['actor_tracks'].values():
track['cell'][2] = track['from'][2] = layer
with self.subTest(layer=layer):
check.compare_cabin_geometry(self.snapshot, self.report)
check.compare_actor_geometry(self.snapshot, self.report)
def test_cabin_aggregation_retains_full_boarded_membership(self):
cabin = self.cabin(40)
originals = copy.deepcopy(cabin['passengers'])
retained = {}
for y in (170,206):
group = sorted([r for r in originals if r['center'][1] == y], key=lambda r:(r['center'][0],r['key']))
drawn = group[:14] # 88px holds fourteen 6px cores, never fifteen.
for i, row in enumerate(drawn):
row.update(scale=1, at=[94+6*i,y+19])
retained[row['key']] = row
self.report['actor_aggregations'].append(dict(
members=[dict(key=r['key'], id=r['key'][6:], state=r['state'], cell=r['cell'], mode=r['mode']) for r in group],
drawn_keys=[r['key'] for r in drawn], at=[96,178], text='+6'))
cabin['passengers'] = [retained[r['key']] for r in originals if r['key'] in retained]
check.compare_cabin_geometry(self.snapshot, self.report)
check.compare_actor_geometry(self.snapshot, self.report)
self.assertEqual(sum(len(a['members']) for a in self.report['actor_aggregations']), 40)
for mutation in ('lost_identity','badge'):
report = copy.deepcopy(self.report)
if mutation == 'lost_identity': report['actor_aggregations'][0]['members'].pop()
else: report['actor_aggregations'][0]['at'][0] += 1
with self.subTest(mutation=mutation), self.assertRaises(ValueError):
check.compare_actor_geometry(self.snapshot, report)
class ComparisonTests(unittest.TestCase):
def pair(self):
declaration = dict(metric='sum_destination_arrival_minutes_entire_cohort',
@@ -647,7 +1291,8 @@ class OfflineGeometryTests(unittest.TestCase):
def test_report_positions_and_source_provenance_are_recomputed(self):
source = 'scripts/ui/pixel_people.gd'
report = dict(rooms={}, landing_badges=[], cabins=[], resting_staff={}, badges=[],
actor_drawings=[dict(key='staff/s', staff=True, at=[1, 1], scale=1)])
actor_drawings=[dict(key='staff/s', staff=True, at=[1, 1], scale=1,
mode='idle', frame=0, flip=False)])
colors = list(dict.fromkeys(check.re.findall(r'Color\("([0-9a-fA-F]{6})"',
(check.ROOT/source).read_text())))
audit = dict(rows=[dict(category='staff', id='staff/s', rect=[1, 1, 16, 18],
@@ -664,6 +1309,79 @@ class OfflineGeometryTests(unittest.TestCase):
class FrameReviewTests(unittest.TestCase):
def test_frame_raw_context_valid_malformed_and_missing_rest(self):
fixture = SpatialTests()
fixture.setUp()
fixture.moving_four()
fixture.report.update(viewport=[216,236], traffic=[])
audit = fixture.drawing_audit()
for row in audit['rows']:
row.update(viewport_rect=row['rect'][:], screen_rect=row['rect'][:])
for context, rest, passes in ((fixture.snapshot,None,True), ({},None,False)):
result = check.frame_rows(fixture.report, audit, self.request, dict(calibration=self.calibration),
[self.image], self.clicks, state=context, rest_audit=rest)
self.assertEqual(not result['errors'], passes)
fixture.report['resting_staff'] = {'s':'a'}
for rest in (None, [], {}):
result = check.frame_rows(fixture.report, audit, self.request, dict(calibration=self.calibration),
[self.image], self.clicks, state=fixture.snapshot, rest_audit=rest)
self.assertFalse(result['mechanical_pass'])
fixture.report['resting_staff'] = {}
result = check.frame_rows(fixture.report, audit, self.request, dict(calibration=self.calibration),
[self.image], self.clicks)
self.assertFalse(result['mechanical_pass'])
self.assertIn('core overlap', str(result['errors']))
def test_frame_with_valid_occupied_rest_authority(self):
fixture = AnchoredGeometryTests()
fixture.setUp()
rest = fixture.occupied_rest()
rows = []
for category, identifier, rect, source, text in check.drawing_rectangle_rows(fixture.report):
self.assertIsNone(text)
colors = list(dict.fromkeys(check.re.findall(r'Color\("([0-9a-fA-F]{6})"', (check.ROOT/source).read_text())))
rows.append(dict(category=category, id=identifier, rect=rect, viewport_rect=rect[:],
screen_rect=rect[:], style_source=source, style_colors=colors))
result = check.frame_rows(fixture.report, dict(rows=rows), self.request, dict(calibration=self.calibration),
[self.image], self.clicks, state=fixture.snapshot, rest_audit=rest)
self.assertEqual(result['errors'], [])
rest['path_service_sha256'] = '0'*64
result = check.frame_rows(fixture.report, dict(rows=rows), self.request, dict(calibration=self.calibration),
[self.image], self.clicks, state=fixture.snapshot, rest_audit=rest)
self.assertFalse(result['mechanical_pass'])
self.assertIn('rest PathService source pin', result['errors'])
def test_os_offline_raw_context_binding_and_hashes(self):
def typed(value):
if isinstance(value, dict): return dict(type='Dictionary', entries=[[typed(k),typed(v)] for k,v in value.items()])
if isinstance(value, list): return dict(type='Array', items=[typed(v) for v in value])
return dict(type={str:'String',int:'int'}[type(value)], text=json.dumps(value))
with tempfile.TemporaryDirectory() as temporary:
stream = Path(temporary)
(stream/'objects').mkdir()
def put(value):
raw = json.dumps(typed(value)).encode()
digest = hashlib.sha256(raw).hexdigest()
(stream/'objects'/(digest+'.json')).write_bytes(raw)
return digest
report = {'actor_drawings':[]}
state = {'systems':{'runtime':{}}}
rest = {'staff':[], 'path_service_sha256':check.sha(check.ROOT/'scripts/world/path_service.gd')}
capture = dict(report=put(report), state=put(state), rest_audit=put(rest))
self.assertEqual(check.drawing_context(stream, capture, report), (state,rest))
for field in ('state','rest_audit','report'):
missing = dict(capture)
del missing[field]
with self.assertRaises(ValueError): check.drawing_context(stream, missing, report)
for field in ('state','rest_audit'):
bad = dict(capture, **{field:put({})})
with self.assertRaises(ValueError): check.drawing_context(stream, bad, report)
with self.assertRaises(ValueError): check.drawing_context(stream, capture, {'wrong':1})
with self.assertRaises(FileNotFoundError):
check.drawing_context(stream, dict(capture, state='0'*64), report)
(stream/'objects'/(capture['state']+'.json')).write_text('{}')
with self.assertRaisesRegex(ValueError, 'object hash'): check.drawing_context(stream, capture, report)
def setUp(self):
OfflineGeometryTests.setUp(self)
self.request.update(local_to_viewport=[1, 0, 0, 1, 0, 0],
@@ -671,7 +1389,8 @@ class FrameReviewTests(unittest.TestCase):
local_to_screen=[1, 0, 0, 1, 0, 0])
self.report = dict(layer=0, viewport=[100, 80], rooms={}, cabins=[],
landing_badges=[], badges=[], resting_staff={}, traffic=[],
actor_drawings=[dict(key='staff/s', staff=True, at=[1, 1], scale=1, state=0)])
actor_drawings=[dict(key='staff/s', staff=True, at=[1, 1], scale=1, state=0,
mode='idle', frame=0, flip=False)])
source = 'scripts/ui/pixel_people.gd'
colors = list(dict.fromkeys(check.re.findall(r'Color\("([0-9a-fA-F]{6})"',
(check.ROOT/source).read_text())))
@@ -684,6 +1403,11 @@ class FrameReviewTests(unittest.TestCase):
return check.frame_rows(self.report, self.audit, self.request,
dict(calibration=self.calibration), [self.image], self.clicks)
def test_frame_without_raw_state_explicitly_denies_transit_exemptions(self):
self.report['actor_drawings'][0]['in_transit'] = True
self.assertEqual(self.frame()['transit_authority'],
'absent: fail closed, no transit exemptions')
def test_blank_crop_fails_without_threshold(self):
self.image = (200, 190, [[(0, 0, 0)] * 200 for _ in range(190)])
result = self.frame()