farpatch-ui/lib/zork/jszm.js

682 lines
21 KiB
JavaScript
Raw Normal View History

/*
JSZM - JavaScript implementation of Z-machine
This program is in public domain.
Documentation:
The exported function called JSZM is the constructor, which takes a
Uint8Array as input. You can also use JSZM.Version for the version
number which is object with properties: major, minor, subminor,
timestamp. Properties of JSZM instances are:
.highlight(fixpitch) = A generator function you define, which will be
called to update the highlighting mode, which is fixpitch (if the
argument is true) or normal (if argument is false). (You don't have to
set it if you aren't implementing variable pitch by default.)
.isTandy = A boolean, normally false. Set it to true to tell the game
that it is a Tandy computer; this affects some games.
.print(text,scripting) = A generator function that you must define, and
will be called to print text. You must implement wrapping and buffering
and scripting yourself. The second argument is true if it should be
copied to the transcript or false if it should not be.
.read(maxlen) = A generator function which you must define yourself, and
which should return a string containing the player's input. Called when
a READ instruction is executed; the argument is the maximum number of
characters that are allowed (if you return a longer string, it will be
truncated).
.restarted() = A generator function you can optionally define. When the
game starts or if restarted (with the RESTART instruction), it will be
called after memory is initialized but before executing any more.
.restore() = A generator function you can define yourself, which is
called when restoring a saved game. Return a Uint8Array with the same
contents passed to save() if successful, or you can return false or null
or undefined if it failed.
.run() = A generator function. Call it to run the program from the
beginning, and call the next() method of the returned object to begin
and to continue. This generator may call your own generator functions
which may yield; it doesn't otherwise yield by itself. You must set up
the other methods before calling run so that it can properly set up the
contents of the Z-machine mode byte. This generator only finishes when a
QUIT instruction is executed.
.save(buf) = A generator function you can define yourself, and is called
when saving the game. The argument is a Uint8Array, and you should
attempt to save its contents somewhere, and then return true if
successful or false if it failed.
.serial = The serial number of the story file, as six ASCII characters.
.screen(window) = Normally null. You can set it to a generator function
which will be called when the SCREEN opcode is executed if you want to
implement split screen.
.split(height) = Normally null. You can set it to a generator function
which will be called when the SPLIT opcode is executed if you want to
implement split screen.
.statusType = False for score/moves and true for hours/minutes. Use this
to determine the meaning of arguments to updateStatusLine.
.updateStatusLine(text,v18,v17) = Normally null, but can be a generator
function if you are implementing the status line. It is called when a
READ or USL instruction is executed. See statusType for the meaning of
v18 and v17. Return value is unused.
.verify() = A normal function. Calling it will attempt to verify the
story file, and returns true if successful or false on error. You can
override it with your own verification function if you want to.
.zorkid = The ZORKID of the story file. This is what is normally
displayed as the release number.
*/
"use strict";
const JSZM_Version={major:2,minor:0,subminor:2,timestamp:1480624305074};
function JSZM(arr) {
var mem;
mem=this.memInit=new Uint8Array(arr);
if(mem[0]!=3) throw new Error("Unsupported Z-code version.");
this.byteSwapped=!!(mem[1]&1);
this.statusType=!!(mem[1]&2);
this.serial=String.fromCharCode(...mem.slice(18,24));
this.zorkid=(mem[2]<<(this.byteSwapped?0:8))|(mem[3]<<(this.byteSwapped?8:0));
}
JSZM.prototype={
byteSwapped: false,
constructor: JSZM,
deserialize: function(ar) {
var e,i,j,ds,cs,pc,vi,purbot;
var g8,g16s,g16,g24,g32;
g8=()=>ar[e++];
g16s=()=>(e+=2,vi.getInt16(e-2));
g16=()=>(e+=2,vi.getUint16(e-2));
g24=()=>(e+=3,vi.getUint32(e-4)&0xFFFFFF);
g32=()=>(e+=4,vi.getUint32(e-4));
try {
e=purbot=this.getu(14);
vi=new DataView(ar.buffer);
if(ar[2]!=this.mem[2] || ar[3]!=this.mem[3]) return null; // ZORKID does not match
pc=g32();
cs=new Array(g16());
ds=Array.from({length:g16()},g16s);
for(i=0;i<cs.length;i++) {
cs[i]={};
cs[i].local=new Int16Array(g8());
cs[i].pc=g24();
cs[i].ds=Array.from({length:g16()},g16s);
for(j=0;j<cs[i].local.length;j++) cs[i].local[j]=g16s();
}
this.mem.set(new Uint8Array(ar.buffer,0,purbot));
return [ds,cs,pc];
} catch(e) {
return null;
}
},
endText: 0,
fwords: null,
genPrint: function*(text) {
var x=this.get(16);
if(x!=this.savedFlags) {
this.savedFlags=x;
yield*this.highlight(!!(x&2));
}
yield*this.print(text,!!(x&1));
},
get: function(x) { return this.view.getInt16(x,this.byteSwapped); },
getText: function(addr) {
var d; // function to parse each Z-character
var o=""; // output
var ps=0; // permanent shift
var ts=0; // temporary shift
var w; // read each 16-bits data
var y; // auxiliary data for parsing state
d=v => {
if(ts==3) {
y=v<<5;
ts=4;
} else if(ts==4) {
y+=v;
if(y==13) o+="\n";
else if(y) o+=String.fromCharCode(y);
ts=ps;
} else if(ts==5) {
o+=this.getText(this.getu(this.fwords+(y+v)*2)*2);
ts=ps;
} else if(v==0) {
o+=" ";
} else if(v<4) {
ts=5;
y=(v-1)*32;
} else if(v<6) {
if(!ts) ts=v-3;
else if(ts==v-3) ps=ts;
else ps=ts=0;
} else if(v==6 && ts==2) {
ts=3;
} else {
o+="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ*\n0123456789.,!?_#'\"/\\-:()"[ts*26+v-6];
ts=ps;
}
};
for(;;) {
w=this.getu(addr);
addr+=2;
d((w>>10)&31);
d((w>>5)&31);
d(w&31);
if(w&32768) break;
}
this.endText=addr;
return o;
},
getu: function(x) { return this.view.getUint16(x,this.byteSwapped); },
handleInput: function(str,t1,t2) {
var i,br,w;
// Put text
str=str.toLowerCase().slice(0,this.mem[t1]-1);
for(i=0;i<str.length;i++) this.mem[t1+i+1]=str.charCodeAt(i);
this.mem[t1+str.length+1]=0;
// Lex text
w=x=>(i=0,x.split("").filter(y => (i+=/[a-z]/.test(y)?1:/[0-9.,!?_#'"\/\\:\-()]/.test(y)?2:4)<7).join(""));
br=JSON.parse("["+str.replace(this.regBreak,(m,o)=>",["+(m.length)+","+(this.vocabulary.get(w(m))||0)+","+(o+1)+"]").slice(1)+"]");
i=this.mem[t2+1]=br.length;
while(i--) {
this.putu(t2+i*4+2,br[i][1]);
this.mem[t2+i*4+4]=br[i][0];
this.mem[t2+i*4+5]=br[i][2];
}
},
highlight: ()=>[],
isTandy: false,
mem: null,
memInit: null,
parseVocab: function(s) {
this.vocabulary=new Map();
if (s === 0) { // If the story file does not contain a dictionary..
this.regBreak=new RegExp("[^ \\n\\t]+","g"); // use the default word separators
return; // and early exit.
}
var e;
var n;
n=this.mem[s++];
e=this.selfInsertingBreaks=String.fromCharCode(...this.mem.slice(s,s+n));
e=e.split("").map(x=>(x.toUpperCase()==x.toLowerCase()?"":"\\")+x).join("")+"]";
this.regBreak=new RegExp("["+e+"|[^ \\n\\t"+e+"+","g");
s+=n;
e=this.mem[s++];
n=this.get(s);
s+=2;
while(n--) {
this.vocabulary.set(this.getText(s),s);
s+=e;
}
},
print: ()=>[],
put: function(x,y) { return this.view.setInt16(x,y,this.byteSwapped); },
putu: function(x,y) { return this.view.setUint16(x,y&65535,this.byteSwapped); },
read: ()=>[],
regBreak: null,
restarted: ()=>[],
restore: ()=>[],
run: function*() {
var mem,pc,cs,ds,op0,op1,op2,op3,opc,inst,x,y,z;
var globals,objects,fwords,defprop;
var addr,fetch,flagset,init,move,opfetch,pcfetch,pcget,pcgetb,pcgetu,predicate,propfind,ret,store,xfetch,xstore;
// Functions
addr=(x) => (x&65535)<<1;
fetch=(x) => {
if(x==0) return ds.pop();
if(x<16) return cs[0].local[x-1];
return this.get(globals+2*x);
};
flagset=() => {
op3=1<<(15&~op1);
op2=objects+op0*9+(op1&16?2:0);
opc=this.get(op2);
};
const initRng = () => {
this.seed = (Math.random() * 0xFFFFFFFF) >>> 0;
};
init=() => {
mem=this.mem=new Uint8Array(this.memInit);
this.view=new DataView(mem.buffer);
mem[1]&=3;
if(this.isTandy) mem[1]|=8;
if(!this.updateStatusLine) mem[1]|=16;
if(this.screen && this.split) mem[1]|=32;
this.put(16,this.savedFlags);
if(!this.vocabulary) this.parseVocab(this.getu(8));
defprop=this.getu(10)-2;
globals=this.getu(12)-32;
this.fwords=fwords=this.getu(24);
cs=[];
ds=[];
pc=this.getu(6);
objects=defprop+55;
initRng();
};
move=(x,y) => {
var w,z;
// Remove from old FIRST-NEXT chain
if(z=mem[objects+x*9+4]) {
if(mem[objects+z*9+6]==x) { // is x.loc.first=x?
mem[objects+z*9+6]=mem[objects+x*9+5]; // x.loc.first=x.next
} else {
z=mem[objects+z*9+6]; // z=x.loc.first
while(z!=x) {
w=z;
z=mem[objects+z*9+5]; // z=z.next
}
mem[objects+w*9+5]=mem[objects+x*9+5]; // w.next=x.next
}
}
// Insert at beginning of new FIRST-NEXT chain
if(mem[objects+x*9+4]=y) { // x.loc=y
mem[objects+x*9+5]=mem[objects+y*9+6]; // x.next=y.first
mem[objects+y*9+6]=x; // y.first=x
} else {
mem[objects+x*9+5]=0; // x.next=0
}
};
opfetch=(x,y) => {
if((x&=3)==3) return;
opc=y;
return [pcget,pcgetb,pcfetch][x]();
};
pcfetch=(x) => fetch(mem[pc++]);
pcget=() => {
pc+=2;
return this.get(pc-2);
};
pcgetb=() => mem[pc++];
pcgetu=() => {
pc+=2;
return this.getu(pc-2);
};
predicate=(p) => {
var x=pcgetb();
if(x&128) p=!p;
if(x&64) x&=63; else x=((x&63)<<8)|pcgetb();
if(p) return;
if(x==0 || x==1) return ret(x);
if(x&0x2000) x-=0x4000;
pc+=x-2;
};
propfind=() => {
var z=this.getu(objects+op0*9+7);
z+=mem[z]*2+1;
while(mem[z]) {
if((mem[z]&31)==op1) {
op3=z+1;
return true;
} else {
z+=(mem[z]>>5)+2;
}
}
op3=0;
return false;
};
ret=(x) => {
ds=cs[0].ds;
pc=cs[0].pc;
cs.shift();
store(x);
};
store=(y) => {
var x=pcgetb();
if(x==0) ds.push(y);
else if(x<16) cs[0].local[x-1]=y;
else this.put(globals+2*x,y);
};
xfetch=(x) => {
if(x==0) return ds[ds.length-1];
if(x<16) return cs[0].local[x-1];
return this.get(globals+2*x);
};
xstore=(x,y) => {
if(x==0) ds[ds.length-1]=y;
else if(x<16) cs[0].local[x-1]=y;
else this.put(globals+2*x,y);
};
// Initializations
init();
yield*this.restarted();
yield*this.highlight(!!(this.savedFlags&2));
// Main loop
main: for(;;) {
inst=pcgetb();
if(inst<128) {
// 2OP
if(inst&64) op0=pcfetch(); else op0=pcgetb();
if(inst&32) op1=pcfetch(); else op1=pcgetb();
inst&=31;
opc=2;
} else if(inst<176) {
// 1OP
x=(inst>>4)&3;
inst&=143;
if(x==0) op0=pcget();
else if(x==1) op0=pcgetb();
else if(x==2) op0=pcfetch();
} else if(inst>=192) {
// EXT
x=pcgetb();
op0=opfetch(x>>6,1);
op1=opfetch(x>>4,2);
op2=opfetch(x>>2,3);
op3=opfetch(x>>0,4);
if(inst<224) inst&=31;
}
switch(inst) {
case 1: // EQUAL?
predicate(op0==op1 || (opc>2 && op0==op2) || (opc==4 && op0==op3));
break;
case 2: // LESS?
predicate(op0<op1);
break;
case 3: // GRTR?
predicate(op0>op1);
break;
case 4: // DLESS?
xstore(op0,x=xfetch(op0)-1);
predicate(x<op1);
break;
case 5: // IGRTR?
xstore(op0,x=xfetch(op0)+1);
predicate(x>op1);
break;
case 6: // IN?
predicate(mem[objects+op0*9+4]==op1);
break;
case 7: // BTST
predicate((op0&op1)==op1);
break;
case 8: // BOR
store(op0|op1);
break;
case 9: // BAND
store(op0&op1);
break;
case 10: // FSET?
flagset();
predicate(opc&op3);
break;
case 11: // FSET
flagset();
this.put(op2,opc|op3);
break;
case 12: // FCLEAR
flagset();
this.put(op2,opc&~op3);
break;
case 13: // SET
xstore(op0,op1);
break;
case 14: // MOVE
move(op0,op1);
break;
case 15: // GET
store(this.get((op0+op1*2)&65535));
break;
case 16: // GETB
store(mem[(op0+op1)&65535]);
break;
case 17: // GETP
if(propfind()) store(mem[op3-1]&32?this.get(op3):mem[op3]);
else store(this.get(defprop+2*op1));
break;
case 18: // GETPT
propfind();
store(op3);
break;
case 19: // NEXTP
if(op1) {
// Return next property
propfind();
store(mem[op3+(mem[op3-1]>>5)+1]&31);
} else {
// Return first property
x=this.getu(objects+op0*9+7);
store(mem[x+mem[x]*2+1]&31);
}
break;
case 20: // ADD
store(op0+op1);
break;
case 21: // SUB
store(op0-op1);
break;
case 22: // MUL
store(Math.imul(op0,op1));
break;
case 23: // DIV
store(Math.trunc(op0/op1));
break;
case 24: // MOD
store(op0%op1);
break;
case 128: // ZERO?
predicate(!op0);
break;
case 129: // NEXT?
store(x=mem[objects+op0*9+5]);
predicate(x);
break;
case 130: // FIRST?
store(x=mem[objects+op0*9+6]);
predicate(x);
break;
case 131: // LOC
store(mem[objects+op0*9+4]);
break;
case 132: // PTSIZE
store((mem[(op0-1)&65535]>>5)+1);
break;
case 133: // INC
x=xfetch(op0);
xstore(op0,x+1);
break;
case 134: // DEC
x=xfetch(op0);
xstore(op0,x-1);
break;
case 135: // PRINTB
yield*this.genPrint(this.getText(op0&65535));
break;
case 137: // REMOVE
move(op0,0);
break;
case 138: // PRINTD
yield*this.genPrint(this.getText(this.getu(objects+op0*9+7)+1));
break;
case 139: // RETURN
ret(op0);
break;
case 140: // JUMP
pc+=op0-2;
break;
case 141: // PRINT
yield*this.genPrint(this.getText(addr(op0)));
break;
case 142: // VALUE
store(xfetch(op0));
break;
case 143: // BCOM
store(~op0);
break;
case 176: // RTRUE
ret(1);
break;
case 177: // RFALSE
ret(0);
break;
case 178: // PRINTI
yield*this.genPrint(this.getText(pc));
pc=this.endText;
break;
case 179: // PRINTR
yield*this.genPrint(this.getText(pc)+"\n");
ret(1);
break;
case 180: // NOOP
break;
case 181: // SAVE
this.savedFlags=this.get(16);
predicate(yield*this.save(this.serialize(ds,cs,pc)));
break;
case 182: // RESTORE
this.savedFlags=this.get(16);
if(z=yield*this.restore()) z=this.deserialize(z);
this.put(16,this.savedFlags);
if(z) ds=z[0],cs=z[1],pc=z[2];
predicate(z);
break;
case 183: // RESTART
init();
yield*this.restarted();
break;
case 184: // RSTACK
ret(ds[ds.length-1]);
break;
case 185: // FSTACK
ds.pop();
break;
case 186: // QUIT
return;
case 187: // CRLF
yield*this.genPrint("\n");
break;
case 188: // USL
if(this.updateStatusLine) yield*this.updateStatusLine(this.getText(this.getu(objects+xfetch(16)*9+7)+1),xfetch(18),xfetch(17));
break;
case 189: // VERIFY
predicate(this.verify());
break;
case 224: // CALL
if(op0) {
x=mem[op0=addr(op0)];
cs.unshift({ds:ds,pc:pc,local:new Int16Array(x)});
ds=[];
pc=op0+1;
for(x=0;x<mem[op0];x++) cs[0].local[x]=pcget();
if(opc>1 && mem[op0]>0) cs[0].local[0]=op1;
if(opc>2 && mem[op0]>1) cs[0].local[1]=op2;
if(opc>3 && mem[op0]>2) cs[0].local[2]=op3;
} else {
store(0);
}
break;
case 225: // PUT
this.put((op0+op1*2)&65535,op2);
break;
case 226: // PUTB
mem[(op0+op1)&65535]=op2;
break;
case 227: // PUTP
propfind();
if(mem[op3-1]&32) this.put(op3,op2);
else mem[op3]=op2;
break;
case 228: // READ
yield*this.genPrint("");
if(this.updateStatusLine) yield*this.updateStatusLine(this.getText(this.getu(objects+xfetch(16)*9+7)+1),xfetch(18),xfetch(17));
this.handleInput(yield*this.read(mem[op0&65535]),op0&65535,op1&65535);
break;
case 229: // PRINTC
yield*this.genPrint(op0==13?"\n":op0?String.fromCharCode(op0):"");
break;
case 230: // PRINTN
yield*this.genPrint(String(op0));
break;
case 231: // RANDOM
if (op0 <= 0) { // If 'op0' is non-positive, reseed the PRNG.
if (op0 === 0) {
initRng(); // If 0, seed using Math.random().
} else {
this.seed = (op0 >>> 0); // If negative, seed with the specified value.
}
store(0); // Reseeding always returns 0.
break;
}
this.seed = (1664525 * this.seed + 1013904223) >>> 0; // Linear congruential generator
store(Math.floor((this.seed / 0xFFFFFFFF) * op0) + 1); // Return integer in range [1..op0] (inclusive).
break;
case 232: // PUSH
ds.push(op0);
break;
case 233: // POP
xstore(op0,ds.pop());
break;
case 234: // SPLIT
if(this.split) yield*this.split(op0);
break;
case 235: // SCREEN
if(this.screen) yield*this.screen(op0);
break;
default:
throw new Error("JSZM: Invalid Z-machine opcode");
}
}
},
save: ()=>[],
savedFlags: 0,
selfInsertingBreaks: null,
serial: null,
serialize: function(ds,cs,pc) {
var i,j,e,ar,vi;
e=this.getu(14); // PURBOT
i=e+cs.reduce((p,c)=>p+2*(c.ds.length+c.local.length)+6,0)+2*ds.length+8;
ar=new Uint8Array(i);
ar.set(new Uint8Array(this.mem.buffer,0,e));
vi=new DataView(ar.buffer);
vi.setUint32(e,pc);
vi.setUint16(e+4,cs.length);
vi.setUint16(e+6,ds.length);
for(i=0;i<ds.length;i++) vi.setInt16(e+i*2+8,ds[i]);
e+=ds.length*2+8;
for(i=0;i<cs.length;i++) {
vi.setUint32(e,cs[i].pc);
vi.setUint8(e,cs[i].local.length);
vi.setUint16(e+4,cs[i].ds.length);
for(j=0;j<cs[i].ds.length;j++) vi.setInt16(e+j*2+6,cs[i].ds[j]);
for(j=0;j<cs[i].local.length;j++) vi.setInt16(e+cs[i].ds.length*2+j*2+6,cs[i].local[j]);
e+=(cs[i].ds.length+cs[i].local.length)*2+6;
}
return ar;
},
screen: null,
split: null,
statusType: null,
updateStatusLine: null,
verify: function() {
var plenth=this.getu(26);
var pchksm=this.getu(28);
var i=64;
while(i<plenth*2) pchksm=(pchksm-this.memInit[i++])&65535;
return !pchksm;
},
view: null,
vocabulary: null,
zorkid: null,
};
JSZM.version=JSZM_Version;
try {
if(module && module.exports) module.exports=JSZM;
} catch(e) {}