Add Bone Quest anatomy quiz for CoCo
This commit is contained in:
commit
3cc37be5fb
50 files changed
+10146
No files matched your search
@@ -0,0 +1,25 @@
|
||||
"""Validate exact generated anatomy/data and compact rendering ownership."""
|
||||
import hashlib,json,re,runpy
|
||||
from pathlib import Path
|
||||
ROOT=Path(__file__).resolve().parents[1]
|
||||
module=runpy.run_path(str(ROOT/'tools/prepare_questions.py'));assert module['generated']()==(ROOT/'src/bones.c').read_text()
|
||||
receipt=json.loads((ROOT/'assets/source-receipt.json').read_text());assert hashlib.sha256((ROOT/'assets/skeleton-source.svg').read_bytes()).hexdigest()==receipt['sha256']
|
||||
source=(ROOT/'src/map_data.c').read_text();manifest=json.loads((ROOT/'data/geometry-manifest.json').read_text())
|
||||
# Parse every span/offset pair independently of the conversion dependency stack.
|
||||
arrays={name:[int(v) for v in re.findall(r'\d+',body)] for name,body in re.findall(r'(?:unsigned char|unsigned)\s+(\w+)\s*\[[^]]*\]\s*=\s*\{([^{}]*)\}',source)}
|
||||
view_names=re.search(r'bone_view_spans\[[^]]*\]\s*=\s*\{([^}]+)\}',source)[1]
|
||||
view_names=re.findall(r'[A-Za-z_]\w*',view_names)
|
||||
widths=arrays['bone_view_widths'];heights=arrays['bone_view_heights'];assert len(view_names)==len(widths)==len(heights)==6
|
||||
pairs=[]
|
||||
for name,data in arrays.items():
|
||||
if name.endswith('_spans'):
|
||||
view=view_names.index(name);off=arrays.get(name[:-6]+'_offsets');assert off is not None,(name,'offsets missing');assert len(off)==26 and off[0]==0 and off[-1]==len(data);occupied=set()
|
||||
for bone in range(25):
|
||||
assert off[bone]%3==off[bone+1]%3==0
|
||||
if name=='bone_spans':assert off[bone+1]>off[bone],bone
|
||||
for k in range(off[bone],off[bone+1],3):
|
||||
y,x,n=data[k:k+3];assert n>0 and 0<=y<heights[view] and 0<=x<x+n<=widths[view]
|
||||
for xx in range(x,x+n):assert (xx,y) not in occupied,(name,xx,y);occupied.add((xx,y))
|
||||
pairs.append(name)
|
||||
assert len(pairs)==6,pairs
|
||||
print('PASS authored bank/C identity, source SVG hash, six bounded disjoint views, 25 nonempty overview masks.')
|
||||
@@ -0,0 +1,147 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Developer qualification using the installed app's isolated playtest helper.
|
||||
Requires explicitly supplied private ROMs; does not operate the personal emulator.
|
||||
"""
|
||||
import argparse,ast,base64,hashlib,json,re,struct,subprocess,zlib
|
||||
from pathlib import Path
|
||||
ROOT=Path(__file__).resolve().parents[1]
|
||||
|
||||
def png(path):
|
||||
b=Path(path).read_bytes();p=8;data=b''
|
||||
while p<len(b):
|
||||
n=int.from_bytes(b[p:p+4],'big');kind=b[p+4:p+8];v=b[p+8:p+8+n];p+=n+12
|
||||
if kind==b'IHDR':w,h,depth,ct,*_=struct.unpack('>IIBBBBB',v)
|
||||
if kind==b'IDAT':data+=v
|
||||
assert depth==8 and ct in (2,6)
|
||||
ch=3 if ct==2 else 4;stride=w*ch;raw=zlib.decompress(data);prior=bytearray(stride);rows=[];p=0
|
||||
for _ in range(h):
|
||||
f=raw[p];p+=1;row=bytearray(raw[p:p+stride]);p+=stride
|
||||
for i in range(stride):
|
||||
a=row[i-ch] if i>=ch else 0;b=prior[i];c=prior[i-ch] if i>=ch else 0
|
||||
if f==1:pred=a
|
||||
elif f==2:pred=b
|
||||
elif f==3:pred=(a+b)//2
|
||||
elif f==4:
|
||||
v=a+b-c;pa=abs(v-a);pb=abs(v-b);pc=abs(v-c);pred=a if pa<=pb and pa<=pc else b if pb<=pc else c
|
||||
else:pred=0
|
||||
row[i]=(row[i]+pred)&255
|
||||
rows.append(row);prior=row
|
||||
return w,h,ch,rows
|
||||
|
||||
class Screen:
|
||||
def __init__(self,path,font):self.w,self.h,self.ch,self.rows=png(path);self.font=font
|
||||
def guest(self,x,y):return tuple(self.rows[50+y*2][x*2*self.ch:x*2*self.ch+3])
|
||||
def text(self,x,y,n):
|
||||
bg=self.guest(x+5,y);out=''
|
||||
for j in range(n):
|
||||
bits=[self.guest(x+j*6+c,y+r)!=bg for r in range(8) for c in range(5)]
|
||||
scores=[]
|
||||
for k in range(32,127):
|
||||
expected=[not(self.font[(k-32)*8+r]&(128>>c)) for r in range(8) for c in range(5)]
|
||||
scores.append((sum(a!=b for a,b in zip(bits,expected)),k))
|
||||
d,k=min(scores);out+=chr(k) if d==0 else '?'
|
||||
return out.rstrip()
|
||||
|
||||
def main():
|
||||
p=argparse.ArgumentParser(description=__doc__)
|
||||
p.add_argument('--app',type=Path,default=Path('/Applications/VCC Plus.app'))
|
||||
p.add_argument('--rom',type=Path,required=True);p.add_argument('--disk-rom',type=Path,required=True)
|
||||
p.add_argument('--evidence',type=Path,default=ROOT/'test-output/playtest')
|
||||
p.add_argument('--cpu',choices=['6809','6309','both'],default='both');args=p.parse_args();out=args.evidence.resolve();out.mkdir(parents=True,exist_ok=True)
|
||||
rows=json.loads((ROOT/'data/bones.json').read_text());binary=ROOT/'build/BONEQ.bin';disk=ROOT/'build/BONEQ.dsk';sha=hashlib.sha256(disk.read_bytes()).hexdigest()
|
||||
mp=binary.with_suffix('.map').read_text();symbols={n:int(a,16) for n,a in re.findall(r'Symbol: _(\w+) .*?= ([0-9A-Fa-f]+)',mp)}
|
||||
blob=binary.read_bytes();memory={};i=0
|
||||
while i<len(blob):
|
||||
kind=blob[i];n,a=struct.unpack('>HH',blob[i+1:i+5]);i+=5
|
||||
if kind==255:break
|
||||
memory.update((a+j,b) for j,b in enumerate(blob[i:i+n]));i+=n
|
||||
font=bytes(memory[symbols['font5x8']+i] for i in range(768))
|
||||
src=(ROOT/'src/map_data.c').read_text();arrays={name:[int(v) for v in re.findall(r'\d+',body)] for name,body in re.findall(r'(?:unsigned char|unsigned)\s+(\w+)\s*\[[^]]*\]\s*=\s*\{([^{}]*)\}',src)}
|
||||
spans=arrays['bone_spans'];offsets=arrays['bone_offsets'];colors={3:(85,170,170),4:(85,85,170),5:(255,85,85),6:(255,255,0)}
|
||||
b64=lambda path:base64.b64encode(path.read_bytes()).decode();reports=[]
|
||||
for cpu in (('6809','6309') if args.cpu=='both' else (args.cpu,)):
|
||||
proc=subprocess.Popen([str(args.app/'Contents/Helpers/vcc-playtest')],stdin=subprocess.PIPE,stdout=subprocess.PIPE,text=True)
|
||||
def call(op,**kw):
|
||||
proc.stdin.write(json.dumps(dict(op=op,**kw))+'\n');proc.stdin.flush();r=json.loads(proc.stdout.readline());assert 'error' not in r,r;return r['result']
|
||||
def read(name,n=1):return call('read_memory',address=symbols[name],count=n)['bytes']
|
||||
def step(n=600):return call('input',steps=[dict(mask=0,fields=n)])
|
||||
def press(mask,settle=600,hold=8):return call('input',steps=[dict(mask=mask,fields=hold),dict(mask=0,fields=settle)])
|
||||
def key(bit,settle=600,hold=8):return press(1<<bit,settle,hold)
|
||||
def type_text(s):
|
||||
steps=[]
|
||||
for c in s:
|
||||
bit=31 if c==' ' else 46 if c=='.' else 45 if c=='-' else ord(c.lower())-97+1
|
||||
mask=(1<<bit)|((1<<55) if c.isupper() else 0)
|
||||
steps.extend([dict(mask=mask,fields=8),dict(mask=0,fields=16)])
|
||||
for i in range(0,len(steps),60):call('input',steps=steps[i:i+60])
|
||||
def capture(name):
|
||||
r=call('capture');path=out/(cpu+'-'+name+'.png');path.write_bytes(base64.b64decode(r.pop('png_base64')))
|
||||
(out/(cpu+'-'+name+'.json')).write_text(json.dumps(r,indent=2)+'\n');return Screen(path,font)
|
||||
def check_map(s,current,outcomes):
|
||||
checked=0
|
||||
for bone in range(25):
|
||||
col=6 if bone==current else 4 if outcomes.get(bone) is True else 5 if bone in outcomes else 3
|
||||
for j in range(offsets[bone],offsets[bone+1],3):
|
||||
y,x,n=spans[j:j+3]
|
||||
for xx in range(x,x+n):
|
||||
assert s.guest(22+xx,30+y)==colors[col],(cpu,bone,current,xx,y,s.guest(22+xx,30+y),colors[col]);checked+=1
|
||||
assert checked>1000
|
||||
def sound(name):
|
||||
r=call('audio_capture',fields=120);wav=base64.b64decode(r['audio_wav_base64']);(out/(cpu+'-'+name+'.wav')).write_bytes(wav)
|
||||
assert any(wav[44:]),'No guest audio samples'
|
||||
call('init',system_rom=b64(args.rom),disk_rom=b64(args.disk_rom),disk=b64(disk),cpu=cpu,boot_keys=[1<<b for b in (4,15,19,48)])
|
||||
step();check_map(capture('title'),None,{})
|
||||
key(3);s=capture('credits');assert s.text(8,42,45)=='Skeleton: Mariana Ruiz Villarreal';key(31);key(33)
|
||||
outcomes={};slots=[];visited=[]
|
||||
for q in range(25):
|
||||
assert read('phase')==[1] and read('question')==[q]
|
||||
bone=read('current_bone')[0];s=capture('mc-%02d-%s'%(q+1,rows[bone]['code']));check_map(s,bone,outcomes)
|
||||
assert s.text(8,19,45)==f'Question {q+1}/25 Score {sum(outcomes.values())}'
|
||||
opts=[s.text(112,132+i*11,34)[2:] for i in range(4)];assert len(set(opts))==4 and rows[bone]['name'] in opts,(q,opts)
|
||||
slot=opts.index(rows[bone]['name']);assert not slots or slot!=slots[-1];slots.append(slot);visited.append(bone)
|
||||
right=q%5!=0;selection=slot if right else (slot+1)%4
|
||||
if q==0:
|
||||
# Hold through feedback and the next question; only one answer.
|
||||
press(1<<(33+selection),600,600);assert read('question')==[1];step(16)
|
||||
else:key(33+selection)
|
||||
outcomes[bone]=right
|
||||
if q%5==0:print(cpu,'multiple choice',q+1,flush=True)
|
||||
assert len(set(visited))==25 and read('phase')==[4]
|
||||
s=capture('mc-results');check_map(s,None,outcomes);assert s.text(112,55,34)=='20 / 25 correct 80%'
|
||||
key(18);s=capture('mc-review');assert s.text(8,39,45)==rows[visited[0]]['name'];key(14);capture('mc-review-next');key(2);key(16);check_map(capture('replay-title'),None,{})
|
||||
key(34);press((1<<55)|(1<<32),16);outcomes={};typed=[];corrections=0
|
||||
for q in range(25):
|
||||
assert read('phase')==[1] and read('question')==[q]
|
||||
bone=read('current_bone')[0];name=rows[bone]['name'];s=capture('typed-%02d-%s'%(q+1,rows[bone]['code']));check_map(s,bone,outcomes)
|
||||
right=q not in (2,3,4,5,6)
|
||||
if q==0:
|
||||
typo=name[0]+name[2]+name[1]+name[3:];type_text(typo);key(48);assert read('phase')==[2],(name,typo,read('phase'))
|
||||
capture('spelling-retry');key(18)
|
||||
for _ in typo:key(29,16)
|
||||
type_text(name);corrections=1
|
||||
elif q==1:
|
||||
type_text(rows[bone]['aliases'][0] if rows[bone]['aliases'] else name);capture('typed-alias')
|
||||
elif q==3:
|
||||
key(50)
|
||||
elif q==4:
|
||||
type_text('X'*33);type_text('XXXXXX');step();s=capture('input-limit');assert s.text(112,132,34)=='X'*33+'_'
|
||||
elif q==5:pass
|
||||
elif q in (2,6):
|
||||
other=rows[(bone+1)%25];type_text(other['aliases'][0] if q==6 and other['aliases'] else other['name'])
|
||||
else:
|
||||
text=' '.join(name.split());text=(' '+text.replace(' ',' ')+' ') if q%3==0 else text.lower() if q%3==1 else text.upper();type_text(text)
|
||||
if q!=3:key(48)
|
||||
s=capture('typed-feedback-%02d'%(q+1));assert read('phase')==[3]
|
||||
assert s.text(112,134,30)==('CORRECT!' if right else 'NOT THIS TIME.'),(q,name,s.text(112,134,30))
|
||||
outcomes[bone]=right;typed.append(bone);assert read('score')==[sum(outcomes.values())]
|
||||
key(31)
|
||||
if q%5==0:print(cpu,'typed',q+1,flush=True)
|
||||
assert len(set(typed))==25 and read('phase')==[4]
|
||||
s=capture('typed-results');check_map(s,None,outcomes);assert s.text(112,55,34)=='20 / 25 correct 80%';assert s.text(112,77,34)=='1 spelling corrections'
|
||||
key(18);s=capture('typed-review');assert s.text(8,39,45)==rows[typed[2]]['name'];key(2);key(17)
|
||||
s=capture('exit');r=call('capture');assert 'THANKS FOR PLAYING BONE QUEST!' in r.get('screen_text','')
|
||||
final=call('stop');final.pop('disk_base64',None);proc.wait(timeout=10)
|
||||
assert final['disk_writes']==0 and final['disk_sha256']==sha
|
||||
reports.append(dict(cpu=cpu,ramKB=512,multipleChoice=25,typed=25,score=20,spellingCorrections=1,mapPixelsChecked=True,noRepeatedCorrectSlots=True,heldKey=True,review=True,replay=True,exit=True,diskSHA256=sha,diskWrites=0))
|
||||
(out/'report.json').write_text(json.dumps(reports,indent=2)+'\n');print('PASS',cpu,'complete quizzes, map/colors/choices/input/review/replay/exit',flush=True)
|
||||
if __name__=='__main__':main()
|
||||
@@ -0,0 +1,42 @@
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include "quiz.h"
|
||||
static void aliases(U8 bone,U8 target)
|
||||
{
|
||||
const char *p=bones[bone].aliases;char word[ANSWER_SIZE];unsigned n;
|
||||
while(*p){n=0;while(*p && *p!='|'){assert(n<ANSWER_SIZE-1);word[n++]=*p++;}word[n]=0;assert(classify(target,word)==(bone==target?2:0));if(*p)++p;}
|
||||
}
|
||||
int main(void)
|
||||
{
|
||||
unsigned seed,i,j,k,p,slot,previous,positions[4]={0},transitions[4][4]={{0}};
|
||||
char name[ANSWER_SIZE],normalized[ANSWER_SIZE];U8 first[4];
|
||||
for(seed=1;seed<=2000;++seed){
|
||||
U8 seen[BONE_COUNT]={0};quiz_start(seed);previous=4;
|
||||
for(i=0;i<BONE_COUNT;++i){
|
||||
assert(order[i]<BONE_COUNT && !seen[order[i]]);seen[order[i]]=1;quiz_options(order[i]);p=0;slot=4;
|
||||
for(j=0;j<4;++j){assert(options[j]<BONE_COUNT);if(options[j]==order[i]){++p;slot=j;}for(k=0;k<j;++k)assert(options[k]!=options[j]);}
|
||||
assert(p==1 && slot!=previous);++positions[slot];if(i)++transitions[previous][slot];previous=slot;
|
||||
}
|
||||
}
|
||||
for(i=0;i<4;++i){assert(positions[i]>10000);for(j=0;j<4;++j)assert(i==j?transitions[i][j]==0:transitions[i][j]>3000);}
|
||||
for(seed=1;seed<=32;++seed){quiz_start(seed);quiz_options(order[0]);memcpy(first,options,4);for(i=1;i<BONE_COUNT;++i)quiz_options(order[i]);quiz_start(seed);quiz_options(order[0]);assert(!memcmp(first,options,4));}
|
||||
for(i=0;i<BONE_COUNT;++i){
|
||||
strcpy(name,bones[i].name);assert(classify(i,name)==2);
|
||||
for(j=0;name[j];++j)if(name[j]>='a' && name[j]<='z')name[j]-=32;
|
||||
assert(classify(i,name)==2);aliases(i,i);
|
||||
for(j=0;j<BONE_COUNT;++j)if(j!=i){assert(classify(i,bones[j].name)==0);aliases(j,i);}
|
||||
assert(classify(i,"")==0 && classify(i,"not a bone")==0);
|
||||
}
|
||||
assert(classify(12,"Humeruz")==1);assert(classify(18,"Femru")==1);
|
||||
assert(classify(17,"phalanges")!=2 && classify(24,"phalanges")!=2);
|
||||
assert(classify(2," COLLAR BONE ")==2);
|
||||
normalize(" \t Lumbar VERTEBRAE ",normalized);assert(!strcmp(normalized,"lumbar vertebrae"));
|
||||
quiz_start(2709);
|
||||
for(i=0;i<BONE_COUNT;++i){quiz_record(order[i],i%2?"wrong":bones[order[i]].name,!(i%2),!(i%4));quiz_record(order[i],"duplicate",1,1);}
|
||||
assert(score==13 && corrections==7);
|
||||
for(i=0;i<BONE_COUNT;++i)assert(answered[i]);
|
||||
quiz_start(2710);assert(!score && !corrections);
|
||||
for(i=0;i<BONE_COUNT;++i)assert(!answered[i] && !responses[i][0]);
|
||||
puts("PASS: 50000 unique option sets, no repeated correct slot, all permitted transitions, aliases/wrong-name guards, spelling, score and reset.");return 0;
|
||||
}
|
||||
Reference in new issue
Block a user