void far _ev_mousehandler(int msk,int btn,int mx,int my)
{
EventRecord *ep;
int moved = 0;
int diff;
if((diff = mx - ms_xmickey) != 0) {
ms_xmickey += diff;
ms_xpos += diff;
if((diff = ms_xpos / queue->evq_xspeed) != 0) {
ms_xpos %= queue->evq_xspeed;
if(IABS(diff) >= queue->evq_thresh) diff *= queue->evq_accel;
diff += queue->evq_xpos;
if(diff <= queue->evq_xmin) diff = queue->evq_xmin;
if(diff >= queue->evq_xmax) diff = queue->evq_xmax;
if(diff != queue->evq_xpos) {
queue->evq_xpos = diff;
queue->evq_moved = moved = 1;
}
}
}
if((diff = my - ms_ymickey) != 0) {
ms_ymickey += diff;
ms_ypos += diff;
if((diff = ms_ypos / queue->evq_yspeed) != 0) {
ms_ypos %= queue->evq_yspeed;
if(IABS(diff) >= queue->evq_thresh) diff *= queue->evq_accel;
diff += queue->evq_ypos;
if(diff <= queue->evq_ymin) diff = queue->evq_ymin;
if(diff >= queue->evq_ymax) diff = queue->evq_ymax;
if(diff != queue->evq_ypos) {
queue->evq_ypos = diff;
queue->evq_moved = moved = 1;
}
}
}
if((msk & ~1) && (queue->evq_enable & MS_ENABLE)) {
disable();
ep = &queue->evq_events[queue->evq_wrptr];
if(++queue->evq_wrptr == queue->evq_maxsize)
queue->evq_wrptr = 0;
if(queue->evq_cursize < queue->evq_maxsize)
queue->evq_cursize++;
else if(++queue->evq_rdptr == queue->evq_maxsize)
queue->evq_rdptr = 0;
enable();
_AX = 0x200;
geninterrupt(0x16);
ep->evt_kbstat = _AL;
ep->evt_type = EVENT_MOUSE;
ep->evt_mask = msk;
ep->evt_button = btn;
ep->evt_xpos = queue->evq_xpos;
ep->evt_ypos = queue->evq_ypos;
ep->evt_time = clock();
}
if(moved && queue->evq_drawmouse) (*mousedraw)();
}
/* like cpy2d_pair, but write output contiguously if possible */
void X(cpy2d_pair_co)(R *I0, R *I1, R *O0, R *O1,
INT n0, INT is0, INT os0,
INT n1, INT is1, INT os1)
{
if (IABS(os0) < IABS(os1)) /* inner loop is for n0 */
X(cpy2d_pair) (I0, I1, O0, O1, n0, is0, os0, n1, is1, os1);
else
X(cpy2d_pair) (I0, I1, O0, O1, n1, is1, os1, n0, is0, os0);
}
void print(int size, char c) //size是菱形的半径，直径为size * 2 + 1
{
int x, y;
for(y = -size; y <= size; y++){
for(x = -size; x <= size; x++){
if(IABS(x) + IABS(y) <= size)
putchar(c);
else
putchar(' ');
}
putchar('\n');
}
}
static void dobatch(const P *ego, R *ri, R *ii, R *ro, R *io,
R *buf, INT batchsz)
{
X(cpy2d_pair_ci)(ri, ii, buf, buf+1,
ego->n, WS(ego->is, 1), WS(ego->bufstride, 1),
batchsz, ego->ivs, 2);
if (IABS(WS(ego->os, 1)) < IABS(ego->ovs)) {
/* transform directly to output */
ego->k(buf, buf+1, ro, io,
ego->bufstride, ego->os, batchsz, 2, ego->ovs);
} else {
/* transform to buffer and copy back */
ego->k(buf, buf+1, buf, buf+1,
ego->bufstride, ego->bufstride, batchsz, 2, 2);
X(cpy2d_pair_co)(buf, buf+1, ro, io,
ego->n, WS(ego->bufstride, 1), WS(ego->os, 1),
batchsz, 2, ego->ovs);
}
}
static void dobatch_hc2r(const P *ego, R *I, R *O, R *buf, INT batchsz)
{
if (IABS(WS(ego->csr, 1)) < IABS(ego->ivs)) {
/* transform directly from input */
ego->k(buf, buf + WS(ego->bcsr /* hack */, 1),
I, I + ego->ioffset,
ego->brs, ego->csr, ego->csi,
batchsz, ego->ivs, 1);
} else {
/* copy into buffer and transform in place */
X(cpy2d_ci)(I, buf,
ego->n, WS(ego->csr, 1), WS(ego->bcsr, 1),
batchsz, ego->ivs, 1, 1);
ego->k(buf, buf + WS(ego->bcsr /* hack */, 1),
buf, buf + ego->bioffset,
ego->brs, ego->bcsr, ego->bcsi,
batchsz, 1, 1);
}
X(cpy2d_co)(buf, O,
ego->n, WS(ego->bcsr /* hack */, 1), ego->rs0,
batchsz, 1, ego->ovs, 1);
}
static void dobatch_r2hc(const P *ego, R *I, R *O, R *buf, INT batchsz)
{
X(cpy2d_ci)(I, buf,
ego->n, ego->rs0, WS(ego->bcsr /* hack */, 1),
batchsz, ego->ivs, 1, 1);
if (IABS(WS(ego->csr, 1)) < IABS(ego->ovs)) {
/* transform directly to output */
ego->k(buf, buf + WS(ego->bcsr /* hack */, 1),
O, O + ego->ioffset,
ego->brs, ego->csr, ego->csi,
batchsz, 1, ego->ovs);
} else {
/* transform to buffer and copy back */
ego->k(buf, buf + WS(ego->bcsr /* hack */, 1),
buf, buf + ego->bioffset,
ego->brs, ego->bcsr, ego->bcsi,
batchsz, 1, 1);
X(cpy2d_co)(buf, O,
ego->n, WS(ego->bcsr, 1), WS(ego->csr, 1),
batchsz, 1, ego->ovs, 1);
}
}
cell amx_exec_run(AMX *amx,cell *retval,unsigned char *data)
{
static const void * const amx_opcodelist[] = {
/* core set */
&&op_nop, &&op_load_pri, &&op_load_alt, &&op_load_s_pri,
&&op_load_s_alt, &&op_lref_s_pri, &&op_lref_s_alt, &&op_load_i,
&&op_lodb_i, &&op_const_pri, &&op_const_alt, &&op_addr_pri,
&&op_addr_alt, &&op_stor, &&op_stor_s, &&op_sref_s,
&&op_stor_i, &&op_strb_i, &&op_align_pri, &&op_lctrl,
&&op_sctrl, &&op_xchg, &&op_push_pri, &&op_push_alt,
&&op_pushr_pri, &&op_pop_pri, &&op_pop_alt, &&op_pick,
&&op_stack, &&op_heap, &&op_proc, &&op_ret,
&&op_retn, &&op_call, &&op_jump, &&op_jzer,
&&op_jnz, &&op_shl, &&op_shr, &&op_sshr,
&&op_shl_c_pri, &&op_shl_c_alt, &&op_smul, &&op_sdiv,
&&op_add, &&op_sub, &&op_and, &&op_or,
&&op_xor, &&op_not, &&op_neg, &&op_invert,
&&op_eq, &&op_neq, &&op_sless, &&op_sleq,
&&op_sgrtr, &&op_sgeq, &&op_inc_pri, &&op_inc_alt,
&&op_inc_i, &&op_dec_pri, &&op_dec_alt, &&op_dec_i,
&&op_movs, &&op_cmps, &&op_fill, &&op_halt,
&&op_bounds, &&op_sysreq, &&op_switch, &&op_swap_pri,
&&op_swap_alt, &&op_break, &&op_casetbl,
/* patched instructions */
/* if op_sysreq_d and/or op_sysreq_nd are not implemented, their entries
* in this table must be NULL
*/
&&op_sysreq_d, &&op_sysreq_nd,
/* overlay instructions */
&&op_call_ovl, &&op_retn_ovl, &&op_switch_ovl, &&op_casetbl_ovl,
/* supplemental and macro instructions */
#if !defined AMX_NO_MACRO_INSTR
&&op_lidx, &&op_lidx_b, &&op_idxaddr, &&op_idxaddr_b,
&&op_push_c, &&op_push, &&op_push_s, &&op_push_adr,
&&op_pushr_c, &&op_pushr_s, &&op_pushr_adr, &&op_jeq,
&&op_jneq, &&op_jsless, &&op_jsleq, &&op_jsgrtr,
&&op_jsgeq, &&op_sdiv_inv, &&op_sub_inv, &&op_add_c,
&&op_smul_c, &&op_zero_pri, &&op_zero_alt, &&op_zero,
&&op_zero_s, &&op_eq_c_pri, &&op_eq_c_alt, &&op_inc,
&&op_inc_s, &&op_dec, &&op_dec_s, &&op_sysreq_n,
&&op_pushm_c, &&op_pushm, &&op_pushm_s, &&op_pushm_adr,
&&op_pushrm_c, &&op_pushrm_s, &&op_pushrm_adr, &&op_load2,
&&op_load2_s, &&op_const, &&op_const_s,
#endif
#if !defined AMX_NO_PACKED_OPC
&&op_load_p_pri, &&op_load_p_alt, &&op_load_p_s_pri,&&op_load_p_s_alt,
&&op_lref_p_s_pri,&&op_lref_p_s_alt,&&op_lodb_p_i, &&op_const_p_pri,
&&op_const_p_alt, &&op_addr_p_pri, &&op_addr_p_alt, &&op_stor_p,
&&op_stor_p_s, &&op_sref_p_s, &&op_strb_p_i, &&op_lidx_p_b,
&&op_idxaddr_p_b, &&op_align_p_pri, &&op_push_p_c, &&op_push_p,
&&op_push_p_s, &&op_push_p_adr, &&op_pushr_p_c, &&op_pushr_p_s,
&&op_pushr_p_adr, &&op_pushm_p_c, &&op_pushm_p, &&op_pushm_p_s,
&&op_pushm_p_adr, &&op_pushrm_p_c, &&op_pushrm_p_s, &&op_pushrm_p_adr,
&&op_stack_p, &&op_heap_p, &&op_shl_p_c_pri, &&op_shl_p_c_alt,
&&op_add_p_c, &&op_smul_p_c, &&op_zero_p, &&op_zero_p_s,
&&op_eq_p_c_pri, &&op_eq_p_c_alt, &&op_inc_p, &&op_inc_p_s,
&&op_dec_p, &&op_dec_p_s, &&op_movs_p, &&op_cmps_p,
&&op_fill_p, &&op_halt_p, &&op_bounds_p,
#endif
};
AMX_HEADER *hdr;
cell pri,alt,stk,frm,hea;
cell reset_stk, reset_hea, *cip;
cell offs,val;
int num,i;
#if !defined AMX_NO_PACKED_OPC
int op;
#endif
assert(amx!=NULL);
/* HACK: return label table and opcode count (for VerifyPcode()) if amx
* structure has the flags set to all ones (see amx_exec_list() above)
*/
if (amx->flags==~0) {
assert(sizeof(cell)==sizeof(void *));
assert(data==NULL);
assert(retval!=NULL);
*retval=(cell)amx_opcodelist;
return sizearray(amx_opcodelist);
} /* if */
/* set up the registers */
hdr=(AMX_HEADER *)amx->base;
assert(hdr->magic==AMX_MAGIC);
assert(hdr->file_version>=11);
cip=(cell*)amx->cip;
hea=amx->hea;
stk=amx->stk;
reset_stk=stk;
reset_hea=hea;
alt=frm=pri=0;/* just to avoid compiler warnings */
num=0; /* just to avoid compiler warnings */
/* start running */
assert(amx->code!=NULL);
assert(data!=NULL);
cip=(cell *)(amx->code+(int)amx->cip);
NEXT(cip,op);
op_nop:
NEXT(cip,op);
op_load_pri:
GETPARAM(offs);
pri=_R(data,offs);
NEXT(cip,op);
op_load_alt:
GETPARAM(offs);
alt=_R(data,offs);
NEXT(cip,op);
op_load_s_pri:
GETPARAM(offs);
pri=_R(data,frm+offs);
NEXT(cip,op);
op_load_s_alt:
GETPARAM(offs);
alt=_R(data,frm+offs);
NEXT(cip,op);
op_lref_s_pri:
GETPARAM(offs);
offs=_R(data,frm+offs);
pri=_R(data,offs);
NEXT(cip,op);
op_lref_s_alt:
GETPARAM(offs);
offs=_R(data,frm+offs);
alt=_R(data,offs);
NEXT(cip,op);
op_load_i:
/* verify address */
if (pri>=hea && pri<stk || (ucell)pri>=(ucell)amx->stp)
ABORT(amx,AMX_ERR_MEMACCESS);
pri=_R(data,pri);
NEXT(cip,op);
op_lodb_i:
GETPARAM(offs);
__lodb_i:
/* verify address */
if (pri>=hea && pri<stk || (ucell)pri>=(ucell)amx->stp)
ABORT(amx,AMX_ERR_MEMACCESS);
switch (offs) {
case 1:
pri=_R8(data,pri);
break;
case 2:
pri=_R16(data,pri);
break;
case 4:
pri=_R32(data,pri);
break;
} /* switch */
NEXT(cip,op);
op_const_pri:
GETPARAM(pri);
NEXT(cip,op);
op_const_alt:
GETPARAM(alt);
NEXT(cip,op);
op_addr_pri:
GETPARAM(pri);
pri+=frm;
NEXT(cip,op);
op_addr_alt:
GETPARAM(alt);
alt+=frm;
NEXT(cip,op);
op_stor:
GETPARAM(offs);
_W(data,offs,pri);
NEXT(cip,op);
op_stor_s:
GETPARAM(offs);
_W(data,frm+offs,pri);
NEXT(cip,op);
op_sref_s:
GETPARAM(offs);
offs=_R(data,frm+offs);
_W(data,offs,pri);
NEXT(cip,op);
op_stor_i:
/* verify address */
if (alt>=hea && alt<stk || (ucell)alt>=(ucell)amx->stp)
ABORT(amx,AMX_ERR_MEMACCESS);
_W(data,alt,pri);
NEXT(cip,op);
op_strb_i:
GETPARAM(offs);
__strb_i:
/* verify address */
if (alt>=hea && alt<stk || (ucell)alt>=(ucell)amx->stp)
ABORT(amx,AMX_ERR_MEMACCESS);
switch (offs) {
case 1:
_W8(data,alt,pri);
break;
case 2:
_W16(data,alt,pri);
break;
case 4:
_W32(data,alt,pri);
break;
} /* switch */
NEXT(cip,op);
op_align_pri:
GETPARAM(offs);
#if BYTE_ORDER==LITTLE_ENDIAN
if (offs<(int)sizeof(cell))
pri ^= sizeof(cell)-offs;
#endif
NEXT(cip,op);
op_lctrl:
GETPARAM(offs);
switch (offs) {
case 0:
pri=hdr->cod;
break;
case 1:
pri=hdr->dat;
break;
case 2:
pri=hea;
break;
case 3:
pri=amx->stp;
break;
case 4:
pri=stk;
break;
case 5:
pri=frm;
break;
case 6:
pri=(cell)((unsigned char *)cip - amx->code);
break;
} /* switch */
NEXT(cip,op);
op_sctrl:
GETPARAM(offs);
switch (offs) {
case 0:
case 1:
case 3:
/* cannot change these parameters */
break;
case 2:
hea=pri;
break;
case 4:
stk=pri;
break;
case 5:
frm=pri;
break;
case 6:
cip=(cell *)(amx->code + (int)pri);
break;
} /* switch */
NEXT(cip,op);
op_xchg:
offs=pri; /* offs is a temporary variable */
pri=alt;
alt=offs;
NEXT(cip,op);
op_push_pri:
PUSH(pri);
NEXT(cip,op);
op_push_alt:
PUSH(alt);
NEXT(cip,op);
op_pushr_pri:
PUSH(data+pri);
NEXT(cip,op);
op_pop_pri:
POP(pri);
NEXT(cip,op);
op_pop_alt:
POP(alt);
NEXT(cip,op);
op_pick:
GETPARAM(offs);
pri=_R(data,stk+offs);
NEXT(cip,op);
op_stack:
GETPARAM(offs);
alt=stk;
stk+=offs;
CHKMARGIN();
CHKSTACK();
NEXT(cip,op);
op_heap:
GETPARAM(offs);
alt=hea;
hea+=offs;
CHKMARGIN();
CHKHEAP();
NEXT(cip,op);
op_proc:
PUSH(frm);
frm=stk;
CHKMARGIN();
NEXT(cip,op);
op_ret:
POP(frm);
POP(offs);
/* verify the return address */
if ((long)offs>=amx->codesize)
ABORT(amx,AMX_ERR_MEMACCESS);
cip=(cell *)(amx->code+(int)offs);
NEXT(cip,op);
op_retn:
POP(frm);
POP(offs);
/* verify the return address */
if ((long)offs>=amx->codesize)
ABORT(amx,AMX_ERR_MEMACCESS);
cip=(cell *)(amx->code+(int)offs);
stk+= _R(data,stk) + sizeof(cell); /* remove parameters from the stack */
NEXT(cip,op);
op_call:
PUSH(((unsigned char *)cip-amx->code)+sizeof(cell));/* push address behind instruction */
cip=JUMPREL(cip); /* jump to the address */
NEXT(cip,op);
op_jump:
/* since the GETPARAM() macro modifies cip, you cannot
* do GETPARAM(cip) directly */
cip=JUMPREL(cip);
NEXT(cip,op);
op_jzer:
if (pri==0)
cip=JUMPREL(cip);
else
SKIPPARAM(1);
NEXT(cip,op);
op_jnz:
if (pri!=0)
cip=JUMPREL(cip);
else
SKIPPARAM(1);
NEXT(cip,op);
op_shl:
pri<<=alt;
NEXT(cip,op);
op_shr:
pri=(ucell)pri >> (ucell)alt;
NEXT(cip,op);
op_sshr:
pri>>=alt;
NEXT(cip,op);
op_shl_c_pri:
GETPARAM(offs);
pri<<=offs;
NEXT(cip,op);
op_shl_c_alt:
GETPARAM(offs);
alt<<=offs;
NEXT(cip,op);
op_smul:
pri*=alt;
NEXT(cip,op);
op_sdiv:
if (pri==0)
ABORT(amx,AMX_ERR_DIVIDE);
/* use floored division and matching remainder */
offs=pri;
#if defined TRUNC_SDIV
pri=alt/offs;
alt=alt%offs;
#else
val=alt; /* portable routine for truncated division */
pri=IABS(alt)/IABS(offs);
if ((cell)(val ^ offs)<0)
pri=-pri;
alt=val-pri*offs; /* calculate the matching remainder */
#endif
/* now "fiddle" with the values to get floored division */
if (alt!=0 && (cell)(alt ^ offs)<0) {
pri--;
alt+=offs;
} /* if */
NEXT(cip,op);
op_add:
pri+=alt;
NEXT(cip,op);
op_sub:
pri=alt-pri;
NEXT(cip,op);
op_and:
pri&=alt;
NEXT(cip,op);
op_or:
pri|=alt;
NEXT(cip,op);
op_xor:
pri^=alt;
NEXT(cip,op);
op_not:
pri=!pri;
NEXT(cip,op);
op_neg:
pri=-pri;
NEXT(cip,op);
op_invert:
pri=~pri;
NEXT(cip,op);
op_eq:
pri= pri==alt ? 1 : 0;
NEXT(cip,op);
op_neq:
pri= pri!=alt ? 1 : 0;
NEXT(cip,op);
op_sless:
pri= pri<alt ? 1 : 0;
NEXT(cip,op);
op_sleq:
pri= pri<=alt ? 1 : 0;
NEXT(cip,op);
op_sgrtr:
pri= pri>alt ? 1 : 0;
NEXT(cip,op);
op_sgeq:
pri= pri>=alt ? 1 : 0;
NEXT(cip,op);
op_inc_pri:
pri++;
NEXT(cip,op);
op_inc_alt:
alt++;
NEXT(cip,op);
op_inc_i:
#if defined _R_DEFAULT
*(cell *)(data+(int)pri) += 1;
#else
val=_R(data,pri);
_W(data,pri,val+1);
#endif
NEXT(cip,op);
op_dec_pri:
pri--;
NEXT(cip,op);
op_dec_alt:
alt--;
NEXT(cip,op);
op_dec_i:
#if defined _R_DEFAULT
*(cell *)(data+(int)pri) -= 1;
#else
val=_R(data,pri);
_W(data,pri,val-1);
#endif
NEXT(cip,op);
op_movs:
GETPARAM(offs);
__movs:
/* verify top & bottom memory addresses, for both source and destination
* addresses
*/
if (pri>=hea && pri<stk || (ucell)pri>=(ucell)amx->stp)
ABORT(amx,AMX_ERR_MEMACCESS);
if ((pri+offs)>hea && (pri+offs)<stk || (ucell)(pri+offs)>(ucell)amx->stp)
ABORT(amx,AMX_ERR_MEMACCESS);
if (alt>=hea && alt<stk || (ucell)alt>=(ucell)amx->stp)
ABORT(amx,AMX_ERR_MEMACCESS);
if ((alt+offs)>hea && (alt+offs)<stk || (ucell)(alt+offs)>(ucell)amx->stp)
ABORT(amx,AMX_ERR_MEMACCESS);
#if defined _R_DEFAULT
memcpy(data+(int)alt, data+(int)pri, (int)offs);
#else
for (i=0; i+4<offs; i+=4) {
val=_R32(data,pri+i);
_W32(data,alt+i,val);
} /* for */
for ( ; i<offs; i++) {
val=_R8(data,pri+i);
_W8(data,alt+i,val);
} /* for */
#endif
NEXT(cip,op);
op_cmps:
GETPARAM(offs);
__cmps:
/* verify top & bottom memory addresses, for both source and destination
* addresses
*/
if (pri>=hea && pri<stk || (ucell)pri>=(ucell)amx->stp)
ABORT(amx,AMX_ERR_MEMACCESS);
if ((pri+offs)>hea && (pri+offs)<stk || (ucell)(pri+offs)>(ucell)amx->stp)
ABORT(amx,AMX_ERR_MEMACCESS);
if (alt>=hea && alt<stk || (ucell)alt>=(ucell)amx->stp)
ABORT(amx,AMX_ERR_MEMACCESS);
if ((alt+offs)>hea && (alt+offs)<stk || (ucell)(alt+offs)>(ucell)amx->stp)
ABORT(amx,AMX_ERR_MEMACCESS);
#if defined _R_DEFAULT
pri=memcmp(data+(int)alt, data+(int)pri, (int)offs);
#else
pri=0;
for (i=0; i+4<offs && pri==0; i+=4)
pri=_R32(data,alt+i)-_R32(data,pri+i);
for ( ; i<offs && pri==0; i++)
pri=_R8(data,alt+i)-_R8(data,pri+i);
#endif
NEXT(cip,op);
op_fill:
GETPARAM(offs);
__fill:
/* verify top & bottom memory addresses */
if (alt>=hea && alt<stk || (ucell)alt>=(ucell)amx->stp)
ABORT(amx,AMX_ERR_MEMACCESS);
if ((alt+offs)>hea && (alt+offs)<stk || (ucell)(alt+offs)>(ucell)amx->stp)
ABORT(amx,AMX_ERR_MEMACCESS);
for (i=(int)alt; offs>=(int)sizeof(cell); i+=sizeof(cell), offs-=sizeof(cell))
_W32(data,i,pri);
NEXT(cip,op);
op_halt:
GETPARAM(offs);
__halt:
if (retval!=NULL)
*retval=pri;
/* store complete status (stk and hea are already set in the ABORT macro) */
amx->frm=frm;
amx->pri=pri;
amx->alt=alt;
amx->cip=(cell)((unsigned char*)cip-amx->code);
if (offs==AMX_ERR_SLEEP) {
amx->stk=stk;
amx->hea=hea;
amx->reset_stk=reset_stk;
amx->reset_hea=reset_hea;
return (int)offs;
} /* if */
ABORT(amx,(int)offs);
op_bounds:
GETPARAM(offs);
if ((ucell)pri>(ucell)offs) {
amx->cip=(cell)((unsigned char *)cip-amx->code);
ABORT(amx,AMX_ERR_BOUNDS);
} /* if */
NEXT(cip,op);
op_sysreq:
GETPARAM(offs);
/* save a few registers */
amx->cip=(cell)((unsigned char *)cip-amx->code);
amx->hea=hea;
amx->frm=frm;
amx->stk=stk;
num=amx->callback(amx,offs,&pri,(cell *)(data+(int)stk));
if (num!=AMX_ERR_NONE) {
if (num==AMX_ERR_SLEEP) {
amx->pri=pri;
amx->alt=alt;
amx->reset_stk=reset_stk;
amx->reset_hea=reset_hea;
return num;
} /* if */
ABORT(amx,num);
} /* if */
NEXT(cip,op);
op_switch: {
cell *cptr=JUMPREL(cip)+1; /* +1, to skip the "casetbl" opcode */
cip=JUMPREL(cptr+1); /* preset to "none-matched" case */
num=(int)*cptr; /* number of records in the case table */
for (cptr+=2; num>0 && *cptr!=pri; num--,cptr+=2)
/* nothing */;
if (num>0)
cip=JUMPREL(cptr+1); /* case found */
NEXT(cip,op);
}
op_swap_pri:
offs=_R(data,stk);
_W(data,stk,pri);
pri=offs;
NEXT(cip,op);
op_swap_alt:
offs=_R(data,stk);
_W(data,stk,alt);
alt=offs;
NEXT(cip,op);
op_break:
assert((amx->flags & AMX_FLAG_VERIFY)==0);
if (amx->debug!=NULL) {
/* store status */
amx->frm=frm;
amx->stk=stk;
amx->hea=hea;
amx->cip=(cell)((unsigned char*)cip-amx->code);
num=amx->debug(amx);
if (num!=AMX_ERR_NONE) {
if (num==AMX_ERR_SLEEP) {
amx->pri=pri;
amx->alt=alt;
amx->reset_stk=reset_stk;
amx->reset_hea=reset_hea;
return num;
} /* if */
ABORT(amx,num);
} /* if */
} /* if */
NEXT(cip,op);
op_casetbl:
assert(0); /* this should not occur during execution */
ABORT(amx,AMX_ERR_INVINSTR);
op_sysreq_d: /* see op_sysreq */
#if !defined AMX_DONT_RELOCATE
GETPARAM(offs);
/* save a few registers */
amx->cip=(cell)((unsigned char *)cip-amx->code);
amx->hea=hea;
amx->frm=frm;
amx->stk=stk;
pri=((AMX_NATIVE)offs)(amx,(cell *)(data+(int)stk));
if (amx->error!=AMX_ERR_NONE) {
if (amx->error==AMX_ERR_SLEEP) {
amx->pri=pri;
amx->alt=alt;
amx->reset_stk=reset_stk;
amx->reset_hea=reset_hea;
return AMX_ERR_SLEEP;
} /* if */
ABORT(amx,amx->error);
} /* if */
NEXT(cip,op);
#else
ABORT(amx,AMX_ERR_INVINSTR);
#endif
op_sysreq_nd: /* see op_sysreq_n */
#if !defined AMX_NO_MACRO_INSTR && !defined AMX_DONT_RELOCATE
GETPARAM(offs);
GETPARAM(val);
PUSH(val);
/* save a few registers */
amx->cip=(cell)((unsigned char *)cip-amx->code);
amx->hea=hea;
amx->frm=frm;
amx->stk=stk;
pri=((AMX_NATIVE)offs)(amx,(cell *)(data+(int)stk));
stk+=val+4;
if (amx->error!=AMX_ERR_NONE) {
if (amx->error==AMX_ERR_SLEEP) {
amx->pri=pri;
amx->alt=alt;
amx->stk=stk;
amx->reset_stk=reset_stk;
amx->reset_hea=reset_hea;
return AMX_ERR_SLEEP;
} /* if */
ABORT(amx,amx->error);
} /* if */
NEXT(cip,op);
#else
ABORT(amx,AMX_ERR_INVINSTR);
#endif
/* overlay instructions */
#if !defined AMX_NO_OVERLAY
op_call_ovl:
offs=(unsigned char *)cip-amx->code+sizeof(cell); /* skip address */
assert(offs>=0 && offs<(1<<(sizeof(cell)*4)));
PUSH((offs<<(sizeof(cell)*4)) | amx->ovl_index);
amx->ovl_index=(int)*cip;
assert(amx->overlay!=NULL);
if ((num=amx->overlay(amx,amx->ovl_index))!=AMX_ERR_NONE)
ABORT(amx,num);
cip=(cell*)amx->code;
NEXT(cip,op);
op_retn_ovl:
assert(amx->overlay!=NULL);
POP(frm);
POP(offs);
amx->ovl_index=offs & (((ucell)~0)>>4*sizeof(cell));
offs=(ucell)offs >> (sizeof(cell)*4);
/* verify the index */
stk+=_R(data,stk)+sizeof(cell); /* remove parameters from the stack */
num=amx->overlay(amx,amx->ovl_index); /* reload overlay */
if (num!=AMX_ERR_NONE || (long)offs>=amx->codesize)
ABORT(amx,AMX_ERR_MEMACCESS);
cip=(cell *)(amx->code+(int)offs);
NEXT(cip,op);
op_switch_ovl: {
cell *cptr=JUMPREL(cip)+1; /* +1, to skip the "icasetbl" opcode */
amx->ovl_index=*(cptr+1); /* preset to "none-matched" case */
num=(int)*cptr; /* number of records in the case table */
for (cptr+=2; num>0 && *cptr!=pri; num--,cptr+=2)
/* nothing */;
if (num>0)
amx->ovl_index=*(cptr+1); /* case found */
assert(amx->overlay!=NULL);
if ((num=amx->overlay(amx,amx->ovl_index))!=AMX_ERR_NONE)
ABORT(amx,num);
cip=(cell*)amx->code;
NEXT(cip,op);
}
#else
op_call_ovl:
op_retn_ovl:
op_switch_ovl:
ABORT(amx,AMX_ERR_INVINSTR);
#endif
op_casetbl_ovl:
assert(0); /* this should not occur during execution */
ABORT(amx,AMX_ERR_INVINSTR);
/* supplemental and macro instructions */
#if !defined AMX_NO_MACRO_INSTR
op_lidx:
offs=pri*sizeof(cell)+alt; /* implicit shift value for a cell */
/* verify address */
if (offs>=hea && offs<stk || (ucell)offs>=(ucell)amx->stp)
ABORT(amx,AMX_ERR_MEMACCESS);
pri=_R(data,offs);
NEXT(cip,op);
op_lidx_b:
GETPARAM(offs);
offs=(pri << (int)offs)+alt;
/* verify address */
if (offs>=hea && offs<stk || (ucell)offs>=(ucell)amx->stp)
ABORT(amx,AMX_ERR_MEMACCESS);
pri=_R(data,offs);
NEXT(cip,op);
op_idxaddr:
pri=pri*sizeof(cell)+alt;
NEXT(cip,op);
op_idxaddr_b:
GETPARAM(offs);
pri=(pri << (int)offs)+alt;
NEXT(cip,op);
op_push_c:
GETPARAM(offs);
PUSH(offs);
NEXT(cip,op);
op_push:
GETPARAM(offs);
PUSH(_R(data,offs));
NEXT(cip,op);
op_push_s:
GETPARAM(offs);
PUSH(_R(data,frm+offs));
NEXT(cip,op);
op_push_adr:
GETPARAM(offs);
PUSH(frm+offs);
NEXT(cip,op);
op_pushr_c:
GETPARAM(offs);
PUSH(data+offs);
NEXT(cip,op);
op_pushr_s:
GETPARAM(offs);
PUSH(data+_R(data,frm+offs));
NEXT(cip,op);
op_pushr_adr:
GETPARAM(offs);
PUSH(data+frm+offs);
NEXT(cip,op);
op_jeq:
if (pri==alt)
cip=JUMPREL(cip);
else
SKIPPARAM(1);
NEXT(cip,op);
op_jneq:
if (pri!=alt)
cip=JUMPREL(cip);
else
SKIPPARAM(1);
NEXT(cip,op);
op_jsless:
if (pri<alt)
cip=JUMPREL(cip);
else
SKIPPARAM(1);
NEXT(cip,op);
op_jsleq:
if (pri<=alt)
cip=JUMPREL(cip);
else
SKIPPARAM(1);
NEXT(cip,op);
op_jsgrtr:
if (pri>alt)
cip=JUMPREL(cip);
else
SKIPPARAM(1);
NEXT(cip,op);
op_jsgeq:
if (pri>=alt)
cip=JUMPREL(cip);
else
SKIPPARAM(1);
NEXT(cip,op);
op_sdiv_inv:
if (alt==0)
ABORT(amx,AMX_ERR_DIVIDE);
/* use floored division and matching remainder */
offs=alt;
#if defined TRUNC_SDIV
pri=pri/offs;
alt=pri%offs;
#else
val=pri; /* portable routine for truncated division */
pri=IABS(pri)/IABS(offs);
if ((cell)(val ^ offs)<0)
pri=-pri;
alt=val-pri*offs; /* calculate the matching remainder */
#endif
/* now "fiddle" with the values to get floored division */
if (alt!=0 && (cell)(alt ^ offs)<0) {
pri--;
alt+=offs;
} /* if */
NEXT(cip,op);
op_sub_inv:
pri-=alt;
NEXT(cip,op);
op_add_c:
GETPARAM(offs);
pri+=offs;
NEXT(cip,op);
op_smul_c:
GETPARAM(offs);
pri*=offs;
NEXT(cip,op);
op_zero_pri:
pri=0;
NEXT(cip,op);
op_zero_alt:
alt=0;
NEXT(cip,op);
op_zero:
GETPARAM(offs);
_W(data,offs,0);
NEXT(cip,op);
op_zero_s:
GETPARAM(offs);
_W(data,frm+offs,0);
NEXT(cip,op);
op_eq_c_pri:
GETPARAM(offs);
pri= pri==offs ? 1 : 0;
NEXT(cip,op);
op_eq_c_alt:
GETPARAM(offs);
pri= alt==offs ? 1 : 0;
NEXT(cip,op);
op_inc:
GETPARAM(offs);
#if defined _R_DEFAULT
*(cell *)(data+(int)offs) += 1;
#else
val=_R(data,offs);
_W(data,offs,val+1);
#endif
NEXT(cip,op);
op_inc_s:
GETPARAM(offs);
#if defined _R_DEFAULT
*(cell *)(data+(int)(frm+offs)) += 1;
#else
val=_R(data,frm+offs);
_W(data,frm+offs,val+1);
#endif
NEXT(cip,op);
op_dec:
GETPARAM(offs);
#if defined _R_DEFAULT
*(cell *)(data+(int)offs) -= 1;
#else
val=_R(data,offs);
_W(data,offs,val-1);
#endif
NEXT(cip,op);
op_dec_s:
GETPARAM(offs);
#if defined _R_DEFAULT
*(cell *)(data+(int)(frm+offs)) -= 1;
#else
val=_R(data,frm+offs);
_W(data,frm+offs,val-1);
#endif
NEXT(cip,op);
op_sysreq_n:
GETPARAM(offs);
GETPARAM(val);
PUSH(val);
/* save a few registers */
amx->cip=(cell)((unsigned char *)cip-amx->code);
amx->hea=hea;
amx->frm=frm;
amx->stk=stk;
num=amx->callback(amx,offs,&pri,(cell *)(data+(int)stk));
stk+=val+4;
if (num!=AMX_ERR_NONE) {
if (num==AMX_ERR_SLEEP) {
amx->pri=pri;
amx->alt=alt;
amx->stk=stk;
amx->reset_stk=reset_stk;
amx->reset_hea=reset_hea;
return num;
} /* if */
ABORT(amx,num);
} /* if */
NEXT(cip,op);
op_pushm_c:
GETPARAM(val);
while (val--) {
GETPARAM(offs);
PUSH(offs);
} /* while */
NEXT(cip,op);
op_pushm:
GETPARAM(val);
while (val--) {
GETPARAM(offs);
PUSH(_R(data,offs));
} /* while */
NEXT(cip,op);
op_pushm_s:
GETPARAM(val);
while (val--) {
GETPARAM(offs);
PUSH(_R(data,frm+offs));
} /* while */
NEXT(cip,op);
op_pushm_adr:
GETPARAM(val);
while (val--) {
GETPARAM(offs);
PUSH(frm+offs);
} /* while */
NEXT(cip,op);
op_pushrm_c:
GETPARAM(val);
while (val--) {
GETPARAM(offs);
PUSH(data+offs);
} /* while */
NEXT(cip,op);
op_pushrm_s:
GETPARAM(val);
while (val--) {
GETPARAM(offs);
PUSH(data+_R(data,frm+offs));
} /* while */
NEXT(cip,op);
op_pushrm_adr:
GETPARAM(val);
while (val--) {
GETPARAM(offs);
PUSH(data+frm+offs);
} /* while */
NEXT(cip,op);
op_load2:
GETPARAM(offs);
pri=_R(data,offs);
GETPARAM(offs);
alt=_R(data,offs);
NEXT(cip,op);
op_load2_s:
GETPARAM(offs);
pri=_R(data,frm+offs);
GETPARAM(offs);
alt=_R(data,frm+offs);
NEXT(cip,op);
op_const:
GETPARAM(offs);
GETPARAM(val);
_W(data,offs,val);
NEXT(cip,op);
op_const_s:
GETPARAM(offs);
GETPARAM(val);
_W(data,frm+offs,val);
NEXT(cip,op);
#endif
#if !defined AMX_NO_PACKED_OPC
op_load_p_pri:
GETPARAM_P(offs,op);
pri=_R(data,offs);
NEXT(cip,op);
op_load_p_alt:
GETPARAM_P(offs,op);
alt=_R(data,offs);
NEXT(cip,op);
op_load_p_s_pri:
GETPARAM_P(offs,op);
pri=_R(data,frm+offs);
NEXT(cip,op);
op_load_p_s_alt:
GETPARAM_P(offs,op);
alt=_R(data,frm+offs);
NEXT(cip,op);
op_lref_p_s_pri:
GETPARAM_P(offs,op);
offs=_R(data,frm+offs);
pri=_R(data,offs);
NEXT(cip,op);
op_lref_p_s_alt:
GETPARAM_P(offs,op);
offs=_R(data,frm+offs);
alt=_R(data,offs);
NEXT(cip,op);
op_lodb_p_i:
GETPARAM_P(offs,op);
goto __lodb_i;
op_const_p_pri:
GETPARAM_P(pri,op);
NEXT(cip,op);
op_const_p_alt:
GETPARAM_P(alt,op);
NEXT(cip,op);
op_addr_p_pri:
GETPARAM_P(pri,op);
pri+=frm;
NEXT(cip,op);
op_addr_p_alt:
GETPARAM_P(alt,op);
alt+=frm;
NEXT(cip,op);
op_stor_p:
GETPARAM_P(offs,op);
_W(data,offs,pri);
NEXT(cip,op);
op_stor_p_s:
GETPARAM_P(offs,op);
_W(data,frm+offs,pri);
NEXT(cip,op);
op_sref_p_s:
GETPARAM_P(offs,op);
offs=_R(data,frm+offs);
_W(data,offs,pri);
NEXT(cip,op);
op_strb_p_i:
GETPARAM_P(offs,op);
goto __strb_i;
op_lidx_p_b:
GETPARAM_P(offs,op);
offs=(pri << (int)offs)+alt;
/* verify address */
if (offs>=hea && offs<stk || (ucell)offs>=(ucell)amx->stp)
ABORT(amx,AMX_ERR_MEMACCESS);
pri=_R(data,offs);
NEXT(cip,op);
op_idxaddr_p_b:
GETPARAM_P(offs,op);
pri=(pri << (int)offs)+alt;
NEXT(cip,op);
op_align_p_pri:
GETPARAM_P(offs,op);
#if BYTE_ORDER==LITTLE_ENDIAN
if ((size_t)offs<sizeof(cell))
pri ^= sizeof(cell)-offs;
#endif
NEXT(cip,op);
op_push_p_c:
GETPARAM_P(offs,op);
PUSH(offs);
NEXT(cip,op);
op_push_p:
GETPARAM_P(offs,op);
PUSH(_R(data,offs));
NEXT(cip,op);
op_push_p_s:
GETPARAM_P(offs,op);
PUSH(_R(data,frm+offs));
NEXT(cip,op);
op_push_p_adr:
GETPARAM_P(offs,op);
PUSH(frm+offs);
NEXT(cip,op);
op_pushr_p_c:
GETPARAM_P(offs,op);
PUSH(data+offs);
NEXT(cip,op);
op_pushr_p_s:
GETPARAM_P(offs,op);
PUSH(data+_R(data,frm+offs));
NEXT(cip,op);
op_pushr_p_adr:
GETPARAM_P(offs,op);
PUSH(data+frm+offs);
NEXT(cip,op);
op_pushm_p_c:
GETPARAM_P(val,op);
while (val--) {
GETPARAM(offs);
PUSH(offs);
} /* while */
NEXT(cip,op);
op_pushm_p:
GETPARAM_P(val,op);
while (val--) {
GETPARAM(offs);
PUSH(_R(data,offs));
} /* while */
NEXT(cip,op);
op_pushm_p_s:
GETPARAM_P(val,op);
while (val--) {
GETPARAM(offs);
PUSH(_R(data,frm+offs));
} /* while */
NEXT(cip,op);
op_pushm_p_adr:
GETPARAM_P(val,op);
while (val--) {
GETPARAM(offs);
PUSH(frm+offs);
} /* while */
NEXT(cip,op);
op_pushrm_p_c:
GETPARAM_P(val,op);
while (val--) {
GETPARAM(offs);
PUSH(data+offs);
} /* while */
NEXT(cip,op);
op_pushrm_p_s:
GETPARAM_P(val,op);
while (val--) {
GETPARAM(offs);
PUSH(data+_R(data,frm+offs));
} /* while */
NEXT(cip,op);
op_pushrm_p_adr:
GETPARAM_P(val,op);
while (val--) {
GETPARAM(offs);
PUSH(data+frm+offs);
} /* while */
NEXT(cip,op);
op_stack_p:
GETPARAM_P(offs,op);
alt=stk;
stk+=offs;
CHKMARGIN();
CHKSTACK();
NEXT(cip,op);
op_heap_p:
GETPARAM_P(offs,op);
alt=hea;
hea+=offs;
CHKMARGIN();
CHKHEAP();
NEXT(cip,op);
op_shl_p_c_pri:
GETPARAM_P(offs,op);
pri<<=offs;
NEXT(cip,op);
op_shl_p_c_alt:
GETPARAM_P(offs,op);
alt<<=offs;
NEXT(cip,op);
op_add_p_c:
GETPARAM_P(offs,op);
pri+=offs;
NEXT(cip,op);
op_smul_p_c:
GETPARAM_P(offs,op);
pri*=offs;
NEXT(cip,op);
op_zero_p:
GETPARAM_P(offs,op);
_W(data,offs,0);
NEXT(cip,op);
op_zero_p_s:
GETPARAM_P(offs,op);
_W(data,frm+offs,0);
NEXT(cip,op);
op_eq_p_c_pri:
GETPARAM_P(offs,op);
pri= pri==offs ? 1 : 0;
NEXT(cip,op);
op_eq_p_c_alt:
GETPARAM_P(offs,op);
pri= alt==offs ? 1 : 0;
NEXT(cip,op);
op_inc_p:
GETPARAM_P(offs,op);
#if defined _R_DEFAULT
*(cell *)(data+(int)offs) += 1;
#else
val=_R(data,offs);
_W(data,offs,val+1);
#endif
NEXT(cip,op);
op_inc_p_s:
GETPARAM_P(offs,op);
#if defined _R_DEFAULT
*(cell *)(data+(int)(frm+offs)) += 1;
#else
val=_R(data,frm+offs);
_W(data,frm+offs,val+1);
#endif
NEXT(cip,op);
op_dec_p:
GETPARAM_P(offs,op);
#if defined _R_DEFAULT
*(cell *)(data+(int)offs) -= 1;
#else
val=_R(data,offs);
_W(data,offs,val-1);
#endif
NEXT(cip,op);
op_dec_p_s:
GETPARAM_P(offs,op);
#if defined _R_DEFAULT
*(cell *)(data+(int)(frm+offs)) -= 1;
#else
val=_R(data,frm+offs);
_W(data,frm+offs,val-1);
#endif
NEXT(cip,op);
op_movs_p:
GETPARAM_P(offs,op);
goto __movs;
op_cmps_p:
GETPARAM_P(offs,op);
goto __cmps;
op_fill_p:
GETPARAM_P(offs,op);
goto __fill;
op_halt_p:
GETPARAM_P(offs,op);
goto __halt;
op_bounds_p:
GETPARAM_P(offs,op);
if ((ucell)pri>(ucell)offs) {
amx->cip=(cell)((unsigned char *)cip-amx->code);
ABORT(amx,AMX_ERR_BOUNDS);
} /* if */
NEXT(cip,op);
#endif
}
void amx_exec_list(const AMX *amx,const cell **opcodelist,int *numopcodes)
{
/* since the opcode list of the GNU GCC version of the abstract machine core
* must be a local variable (as it references code labels, which are local
* too), we use a trick to get the opcode list: call amx_Exec() while a
* special flags value is set in the AMX header.
*/
int orgflags;
AMX *amxptr=(AMX*)amx;
assert(amx!=NULL);
assert(opcodelist!=NULL);
assert(numopcodes!=NULL);
orgflags=amx->flags;
amxptr->flags=~0;
*numopcodes=amx_exec_run(amxptr, (cell*)opcodelist, NULL);
amxptr->flags=orgflags;
}
main() {
/* ADVENTURE (REV 2: 20 TREASURES) */
/* HISTORY: ORIGINAL IDEA & 5-TREASURE VERSION (ADVENTURES) BY WILLIE CROWTHER
* 15-TREASURE VERSION (ADVENTURE) BY DON WOODS, APRIL-JUNE 1977
* 20-TREASURE VERSION (REV 2) BY DON WOODS, AUGUST 1978
* ERRATA FIXED: 78/12/25 */
/* LOGICAL VARIABLES:
*
* CLOSED SAYS WHETHER WE'RE ALL THE WAY CLOSED
* CLOSNG SAYS WHETHER IT'S CLOSING TIME YET
* CLSHNT SAYS WHETHER HE'S READ THE CLUE IN THE ENDGAME
* LMWARN SAYS WHETHER HE'S BEEN WARNED ABOUT LAMP GOING DIM
* NOVICE SAYS WHETHER HE ASKED FOR INSTRUCTIONS AT START-UP
* PANIC SAYS WHETHER HE'S FOUND OUT HE'S TRAPPED IN THE CAVE
* WZDARK SAYS WHETHER THE LOC HE'S LEAVING WAS DARK */
#include "funcs.h"
/* READ THE DATABASE IF WE HAVE NOT YET DONE SO */
LINES = (long *)calloc(LINSIZ+1,sizeof(long));
if(!LINES){
printf("Not enough memory!\n");
exit(FALSE);
}
MAP2[1] = 0;
if(!SETUP)initialise();
if(SETUP > 0) goto L1;
/* UNLIKE EARLIER VERSIONS, ADVENTURE IS NO LONGER RESTARTABLE. (THIS
* LETS US GET AWAY WITH MODIFYING THINGS SUCH AS OBJSND(BIRD) WITHOUT
* HAVING TO BE ABLE TO UNDO THE CHANGES LATER.) IF A "USED" COPY IS
* RERUN, WE COME HERE AND TELL THE PLAYER TO RUN A FRESH COPY. */
RSPEAK(201);
exit(FALSE);
/* START-UP, DWARF STUFF */
L1: SETUP= -1;
I=RAN(-1);
ZZWORD=RNDVOC(3,0)+MESH*2;
NOVICE=YES(65,1,0);
NEWLOC=1;
LOC=1;
LIMIT=330;
if(NOVICE)LIMIT=1000;
/* CAN'T LEAVE CAVE ONCE IT'S CLOSING (EXCEPT BY MAIN OFFICE). */
L2: if(!OUTSID(NEWLOC) || NEWLOC == 0 || !CLOSNG) goto L71;
RSPEAK(130);
NEWLOC=LOC;
if(!PANIC)CLOCK2=15;
PANIC=TRUE;
/* SEE IF A DWARF HAS SEEN HIM AND HAS COME FROM WHERE HE WANTS TO GO. IF SO,
* THE DWARF'S BLOCKING HIS WAY. IF COMING FROM PLACE FORBIDDEN TO PIRATE
* (DWARVES ROOTED IN PLACE) LET HIM GET OUT (AND ATTACKED). */
L71: if(NEWLOC == LOC || FORCED(LOC) || CNDBIT(LOC,3)) goto L74;
/* 73 */ for (I=1; I<=5; I++) {
if(ODLOC[I] != NEWLOC || !DSEEN[I]) goto L73;
NEWLOC=LOC;
RSPEAK(2);
goto L74;
L73: /*etc*/ ;
} /* end loop */
L74: LOC=NEWLOC;
/* DWARF STUFF. SEE EARLIER COMMENTS FOR DESCRIPTION OF VARIABLES. REMEMBER
* SIXTH DWARF IS PIRATE AND IS THUS VERY DIFFERENT EXCEPT FOR MOTION RULES. */
/* FIRST OFF, DON'T LET THE DWARVES FOLLOW HIM INTO A PIT OR A WALL. ACTIVATE
* THE WHOLE MESS THE FIRST TIME HE GETS AS FAR AS THE HALL OF MISTS (LOC 15).
* IF NEWLOC IS FORBIDDEN TO PIRATE (IN PARTICULAR, IF IT'S BEYOND THE TROLL
* BRIDGE), BYPASS DWARF STUFF. THAT WAY PIRATE CAN'T STEAL RETURN TOLL, AND
* DWARVES CAN'T MEET THE BEAR. ALSO MEANS DWARVES WON'T FOLLOW HIM INTO DEAD
* END IN MAZE, BUT C'EST LA VIE. THEY'LL WAIT FOR HIM OUTSIDE THE DEAD END. */
if(LOC == 0 || FORCED(LOC) || CNDBIT(NEWLOC,3)) goto L2000;
if(DFLAG != 0) goto L6000;
if(INDEEP(LOC))DFLAG=1;
goto L2000;
/* WHEN WE ENCOUNTER THE FIRST DWARF, WE KILL 0, 1, OR 2 OF THE 5 DWARVES. IF
* ANY OF THE SURVIVORS IS AT LOC, REPLACE HIM WITH THE ALTERNATE. */
L6000: if(DFLAG != 1) goto L6010;
if(!INDEEP(LOC) || (PCT(95) && (!CNDBIT(LOC,4) || PCT(85)))) goto L2000;
DFLAG=2;
/* 6001 */ for (I=1; I<=2; I++) {
J=1+RAN(5);
L6001: if(PCT(50))DLOC[J]=0;
} /* end loop */
/* 6002 */ for (I=1; I<=5; I++) {
if(DLOC[I] == LOC)DLOC[I]=DALTLC;
L6002: ODLOC[I]=DLOC[I];
} /* end loop */
RSPEAK(3);
DROP(AXE,LOC);
goto L2000;
/* THINGS ARE IN FULL SWING. MOVE EACH DWARF AT RANDOM, EXCEPT IF HE'S SEEN US
* HE STICKS WITH US. DWARVES STAY DEEP INSIDE. IF WANDERING AT RANDOM,
* THEY DON'T BACK UP UNLESS THERE'S NO ALTERNATIVE. IF THEY DON'T HAVE TO
* MOVE, THEY ATTACK. AND, OF COURSE, DEAD DWARVES DON'T DO MUCH OF ANYTHING. */
L6010: DTOTAL=0;
ATTACK=0;
STICK=0;
/* 6030 */ for (I=1; I<=6; I++) {
if(DLOC[I] == 0) goto L6030;
/* FILL TK ARRAY WITH ALL THE PLACES THIS DWARF MIGHT GO. */
J=1;
KK=DLOC[I];
KK=KEY[KK];
if(KK == 0) goto L6016;
L6012: NEWLOC=MOD(IABS(TRAVEL[KK])/1000,1000);
{long x = J-1;
if(NEWLOC > 300 || !INDEEP(NEWLOC) || NEWLOC == ODLOC[I] || (J > 1 &&
NEWLOC == TK[x]) || J >= 20 || NEWLOC == DLOC[I] ||
FORCED(NEWLOC) || (I == 6 && CNDBIT(NEWLOC,3)) ||
IABS(TRAVEL[KK])/1000000 == 100) goto L6014;}
TK[J]=NEWLOC;
J=J+1;
L6014: KK=KK+1;
{long x = KK-1; if(TRAVEL[x] >= 0) goto L6012;}
L6016: TK[J]=ODLOC[I];
if(J >= 2)J=J-1;
J=1+RAN(J);
ODLOC[I]=DLOC[I];
DLOC[I]=TK[J];
DSEEN[I]=(DSEEN[I] && INDEEP(LOC)) || (DLOC[I] == LOC || ODLOC[I] == LOC);
if(!DSEEN[I]) goto L6030;
DLOC[I]=LOC;
if(I != 6) goto L6027;
/* THE PIRATE'S SPOTTED HIM. HE LEAVES HIM ALONE ONCE WE'VE FOUND CHEST. K
* COUNTS IF A TREASURE IS HERE. IF NOT, AND TALLY=1 FOR AN UNSEEN CHEST, LET
* THE PIRATE BE SPOTTED. NOTE THAT PLACE(CHEST)=0 MIGHT MEAN THAT HE'S
* THROWN IT TO THE TROLL, BUT IN THAT CASE HE'S SEEN THE CHEST (PROP=0). */
if(LOC == CHLOC || PROP[CHEST] >= 0) goto L6030;
K=0;
/* 6020 */ for (J=50; J<=MAXTRS; J++) {
/* PIRATE WON'T TAKE PYRAMID FROM PLOVER ROOM OR DARK ROOM (TOO EASY!). */
if(J == PYRAM && (LOC == PLAC[PYRAM] || LOC == PLAC[EMRALD])) goto L6020;
if(TOTING(J)) goto L6021;
L6020: if(HERE(J))K=1;
} /* end loop */
if(TALLY == 1 && K == 0 && PLACE[CHEST] == 0 && HERE(LAMP) && PROP[LAMP]
== 1) goto L6025;
if(ODLOC[6] != DLOC[6] && PCT(20))RSPEAK(127);
goto L6030;
L6021: if(PLACE[CHEST] != 0) goto L6022;
/* INSTALL CHEST ONLY ONCE, TO INSURE IT IS THE LAST TREASURE IN THE LIST. */
MOVE(CHEST,CHLOC);
MOVE(MESSAG,CHLOC2);
L6022: RSPEAK(128);
/* 6023 */ for (J=50; J<=MAXTRS; J++) {
if(J == PYRAM && (LOC == PLAC[PYRAM] || LOC == PLAC[EMRALD])) goto L6023;
if(AT(J) && FIXED[J] == 0)CARRY(J,LOC);
if(TOTING(J))DROP(J,CHLOC);
L6023: /*etc*/ ;
} /* end loop */
L6024: DLOC[6]=CHLOC;
ODLOC[6]=CHLOC;
DSEEN[6]=FALSE;
goto L6030;
L6025: RSPEAK(186);
MOVE(CHEST,CHLOC);
MOVE(MESSAG,CHLOC2);
goto L6024;
/* THIS THREATENING LITTLE DWARF IS IN THE ROOM WITH HIM! */
L6027: DTOTAL=DTOTAL+1;
if(ODLOC[I] != DLOC[I]) goto L6030;
ATTACK=ATTACK+1;
if(KNFLOC >= 0)KNFLOC=LOC;
if(RAN(1000) < 95*(DFLAG-2))STICK=STICK+1;
L6030: /*etc*/ ;
} /* end loop */
/* NOW WE KNOW WHAT'S HAPPENING. LET'S TELL THE POOR SUCKER ABOUT IT.
* NOTE THAT VARIOUS OF THE "KNIFE" MESSAGES MUST HAVE SPECIFIC RELATIVE
* POSITIONS IN THE RSPEAK DATABASE. */
if(DTOTAL == 0) goto L2000;
SETPRM(1,DTOTAL,0);
RSPEAK(4+1/DTOTAL);
if(ATTACK == 0) goto L2000;
if(DFLAG == 2)DFLAG=3;
SETPRM(1,ATTACK,0);
K=6;
if(ATTACK > 1)K=250;
RSPEAK(K);
SETPRM(1,STICK,0);
RSPEAK(K+1+2/(1+STICK));
if(STICK == 0) goto L2000;
OLDLC2=LOC;
goto L99;
/* DESCRIBE THE CURRENT LOCATION AND (MAYBE) GET NEXT COMMAND. */
/* PRINT TEXT FOR CURRENT LOC. */
L2000: if(LOC == 0) goto L99;
KK=STEXT[LOC];
if(MOD(ABB[LOC],ABBNUM) == 0 || KK == 0)KK=LTEXT[LOC];
if(FORCED(LOC) || !DARK(0)) goto L2001;
if(WZDARK && PCT(35)) goto L90;
KK=RTEXT[16];
L2001: if(TOTING(BEAR))RSPEAK(141);
SPEAK(KK);
K=1;
if(FORCED(LOC)) goto L8;
if(LOC == 33 && PCT(25) && !CLOSNG)RSPEAK(7);
/* PRINT OUT DESCRIPTIONS OF OBJECTS AT THIS LOCATION. IF NOT CLOSING AND
* PROPERTY VALUE IS NEGATIVE, TALLY OFF ANOTHER TREASURE. RUG IS SPECIAL
* CASE; ONCE SEEN, ITS PROP IS 1 (DRAGON ON IT) TILL DRAGON IS KILLED.
* SIMILARLY FOR CHAIN; PROP IS INITIALLY 1 (LOCKED TO BEAR). THESE HACKS
* ARE BECAUSE PROP=0 IS NEEDED TO GET FULL SCORE. */
if(DARK(0)) goto L2012;
ABB[LOC]=ABB[LOC]+1;
I=ATLOC[LOC];
L2004: if(I == 0) goto L2012;
OBJ=I;
if(OBJ > 100)OBJ=OBJ-100;
if(OBJ == STEPS && TOTING(NUGGET)) goto L2008;
if(PROP[OBJ] >= 0) goto L2006;
if(CLOSED) goto L2008;
PROP[OBJ]=0;
if(OBJ == RUG || OBJ == CHAIN)PROP[OBJ]=1;
TALLY=TALLY-1;
/* NOTE: THERE USED TO BE A TEST HERE TO SEE WHETHER THE PLAYER HAD BLOWN IT
* SO BADLY THAT HE COULD NEVER EVER SEE THE REMAINING TREASURES, AND IF SO
* THE LAMP WAS ZAPPED TO 35 TURNS. BUT THE TESTS WERE TOO SIMPLE-MINDED;
* THINGS LIKE KILLING THE BIRD BEFORE THE SNAKE WAS GONE (CAN NEVER SEE
* JEWELRY), AND DOING IT "RIGHT" WAS HOPELESS. E.G., COULD CROSS TROLL
* BRIDGE SEVERAL TIMES, USING UP ALL AVAILABLE TREASURES, BREAKING VASE,
* USING COINS TO BUY BATTERIES, ETC., AND EVENTUALLY NEVER BE ABLE TO GET
* ACROSS AGAIN. IF BOTTLE WERE LEFT ON FAR SIDE, COULD THEN NEVER GET EGGS
* OR TRIDENT, AND THE EFFECTS PROPAGATE. SO THE WHOLE THING WAS FLUSHED.
* ANYONE WHO MAKES SUCH A GROSS BLUNDER ISN'T LIKELY TO FIND EVERYTHING
* ELSE ANYWAY (SO GOES THE RATIONALISATION). */
L2006: KK=PROP[OBJ];
if(OBJ == STEPS && LOC == FIXED[STEPS])KK=1;
PSPEAK(OBJ,KK);
L2008: I=LINK[I];
goto L2004;
L2009: K=54;
L2010: SPK=K;
L2011: RSPEAK(SPK);
L2012: VERB=0;
OLDOBJ=OBJ;
OBJ=0;
/* CHECK IF THIS LOC IS ELIGIBLE FOR ANY HINTS. IF BEEN HERE LONG ENOUGH,
* BRANCH TO HELP SECTION (ON LATER PAGE). HINTS ALL COME BACK HERE EVENTUALLY
* TO FINISH THE LOOP. IGNORE "HINTS" < 4 (SPECIAL STUFF, SEE DATABASE NOTES).
*/
L2600: if(COND[LOC] < CONDS) goto L2603;
/* 2602 */ for (HINT=1; HINT<=HNTMAX; HINT++) {
if(HINTED[HINT]) goto L2602;
if(!CNDBIT(LOC,HINT+10))HINTLC[HINT]= -1;
HINTLC[HINT]=HINTLC[HINT]+1;
if(HINTLC[HINT] >= HINTS[HINT][1]) goto L40000;
L2602: /*etc*/ ;
} /* end loop */
/* KICK THE RANDOM NUMBER GENERATOR JUST TO ADD VARIETY TO THE CHASE. ALSO,
* IF CLOSING TIME, CHECK FOR ANY OBJECTS BEING TOTED WITH PROP < 0 AND SET
* THE PROP TO -1-PROP. THIS WAY OBJECTS WON'T BE DESCRIBED UNTIL THEY'VE
* BEEN PICKED UP AND PUT DOWN SEPARATE FROM THEIR RESPECTIVE PILES. DON'T
* TICK CLOCK1 UNLESS WELL INTO CAVE (AND NOT AT Y2). */
L2603: if(!CLOSED) goto L2605;
if(PROP[OYSTER] < 0 && TOTING(OYSTER))PSPEAK(OYSTER,1);
/* 2604 */ for (I=1; I<=100; I++) {
L2604: if(TOTING(I) && PROP[I] < 0)PROP[I]= -1-PROP[I];
} /* end loop */
L2605: WZDARK=DARK(0);
if(KNFLOC > 0 && KNFLOC != LOC)KNFLOC=0;
I=RAN(1);
GETIN(WD1,WD1X,WD2,WD2X);
/* EVERY INPUT, CHECK "FOOBAR" FLAG. IF ZERO, NOTHING'S GOING ON. IF POS,
* MAKE NEG. IF NEG, HE SKIPPED A WORD, SO MAKE IT ZERO. */
L2607: FOOBAR=(FOOBAR>0 ? -FOOBAR : 0);
TURNS=TURNS+1;
if(TURNS != THRESH) goto L2608;
SPEAK(TTEXT[TRNDEX]);
TRNLUZ=TRNLUZ+TRNVAL[TRNDEX]/100000;
TRNDEX=TRNDEX+1;
THRESH= -1;
if(TRNDEX <= TRNVLS)THRESH=MOD(TRNVAL[TRNDEX],100000)+1;
L2608: if(VERB == SAY && WD2 > 0)VERB=0;
if(VERB == SAY) goto L4090;
if(TALLY == 0 && INDEEP(LOC) && LOC != 33)CLOCK1=CLOCK1-1;
if(CLOCK1 == 0) goto L10000;
if(CLOCK1 < 0)CLOCK2=CLOCK2-1;
if(CLOCK2 == 0) goto L11000;
if(PROP[LAMP] == 1)LIMIT=LIMIT-1;
if(LIMIT <= 30 && HERE(BATTER) && PROP[BATTER] == 0 && HERE(LAMP)) goto
L12000;
if(LIMIT == 0) goto L12400;
if(LIMIT <= 30) goto L12200;
L19999: K=43;
if(LIQLOC(LOC) == WATER)K=70;
V1=VOCAB(WD1,-1);
V2=VOCAB(WD2,-1);
if(V1 == ENTER && (V2 == STREAM || V2 == 1000+WATER)) goto L2010;
if(V1 == ENTER && WD2 > 0) goto L2800;
if((V1 != 1000+WATER && V1 != 1000+OIL) || (V2 != 1000+PLANT && V2 !=
1000+DOOR)) goto L2610;
{long x = V2-1000; if(AT(x))WD2=MAKEWD(16152118);}
L2610: if(V1 == 1000+CAGE && V2 == 1000+BIRD && HERE(CAGE) &&
HERE(BIRD))WD1=MAKEWD(301200308);
L2620: if(WD1 != MAKEWD(23051920)) goto L2625;
IWEST=IWEST+1;
if(IWEST == 10)RSPEAK(17);
L2625: if(WD1 != MAKEWD( 715) || WD2 == 0) goto L2630;
IGO=IGO+1;
if(IGO == 10)RSPEAK(276);
L2630: I=VOCAB(WD1,-1);
if(I == -1) goto L3000;
K=MOD(I,1000);
KQ=I/1000+1;
switch (KQ-1) { case 0: goto L8; case 1: goto L5000; case 2: goto L4000;
case 3: goto L2010; }
BUG(22);
/* GET SECOND WORD FOR ANALYSIS. */
L2800: WD1=WD2;
WD1X=WD2X;
WD2=0;
goto L2620;
/* GEE, I DON'T UNDERSTAND. */
L3000: SETPRM(1,WD1,WD1X);
RSPEAK(254);
goto L2600;
/* VERB AND OBJECT ANALYSIS MOVED TO SEPARATE MODULE. */
L4000: I=4000; goto Laction;
L4090: I=4090; goto Laction;
L5000: I=5000;
Laction:
switch (action(I)) {
case 2: goto L2;
case 8: goto L8;
case 2000: goto L2000;
case 2009: goto L2009;
case 2010: goto L2010;
case 2011: goto L2011;
case 2012: goto L2012;
case 2600: goto L2600;
case 2607: goto L2607;
case 2630: goto L2630;
case 2800: goto L2800;
case 8000: goto L8000;
case 18999: goto L18999;
case 19000: goto L19000;
}
BUG(99);
/* RANDOM INTRANSITIVE VERBS COME HERE. CLEAR OBJ JUST IN CASE (SEE "ATTACK").
*/
L8000: SETPRM(1,WD1,WD1X);
RSPEAK(257);
OBJ=0;
goto L2600;
/* FIGURE OUT THE NEW LOCATION
*
* GIVEN THE CURRENT LOCATION IN "LOC", AND A MOTION VERB NUMBER IN "K", PUT
* THE NEW LOCATION IN "NEWLOC". THE CURRENT LOC IS SAVED IN "OLDLOC" IN CASE
* HE WANTS TO RETREAT. THE CURRENT OLDLOC IS SAVED IN OLDLC2, IN CASE HE
* DIES. (IF HE DOES, NEWLOC WILL BE LIMBO, AND OLDLOC WILL BE WHAT KILLED
* HIM, SO WE NEED OLDLC2, WHICH IS THE LAST PLACE HE WAS SAFE.) */
L8: KK=KEY[LOC];
NEWLOC=LOC;
if(KK == 0)BUG(26);
if(K == NUL) goto L2;
if(K == BACK) goto L20;
if(K == LOOK) goto L30;
if(K == CAVE) goto L40;
OLDLC2=OLDLOC;
OLDLOC=LOC;
L9: LL=IABS(TRAVEL[KK]);
if(MOD(LL,1000) == 1 || MOD(LL,1000) == K) goto L10;
if(TRAVEL[KK] < 0) goto L50;
KK=KK+1;
goto L9;
L10: LL=LL/1000;
L11: NEWLOC=LL/1000;
K=MOD(NEWLOC,100);
if(NEWLOC <= 300) goto L13;
if(PROP[K] != NEWLOC/100-3) goto L16;
L12: if(TRAVEL[KK] < 0)BUG(25);
KK=KK+1;
NEWLOC=IABS(TRAVEL[KK])/1000;
if(NEWLOC == LL) goto L12;
LL=NEWLOC;
goto L11;
L13: if(NEWLOC <= 100) goto L14;
if(TOTING(K) || (NEWLOC > 200 && AT(K))) goto L16;
goto L12;
L14: if(NEWLOC != 0 && !PCT(NEWLOC)) goto L12;
L16: NEWLOC=MOD(LL,1000);
if(NEWLOC <= 300) goto L2;
if(NEWLOC <= 500) goto L30000;
RSPEAK(NEWLOC-500);
NEWLOC=LOC;
goto L2;
/* SPECIAL MOTIONS COME HERE. LABELLING CONVENTION: STATEMENT NUMBERS NNNXX
* (XX=00-99) ARE USED FOR SPECIAL CASE NUMBER NNN (NNN=301-500). */
L30000: NEWLOC=NEWLOC-300;
switch (NEWLOC) { case 1: goto L30100; case 2: goto L30200; case 3: goto
L30300; }
BUG(20);
/* TRAVEL 301. PLOVER-ALCOVE PASSAGE. CAN CARRY ONLY EMERALD. NOTE: TRAVEL
* TABLE MUST INCLUDE "USELESS" ENTRIES GOING THROUGH PASSAGE, WHICH CAN NEVER
* BE USED FOR ACTUAL MOTION, BUT CAN BE SPOTTED BY "GO BACK". */
L30100: NEWLOC=99+100-LOC;
if(HOLDNG == 0 || (HOLDNG == 1 && TOTING(EMRALD))) goto L2;
NEWLOC=LOC;
RSPEAK(117);
goto L2;
/* TRAVEL 302. PLOVER TRANSPORT. DROP THE EMERALD (ONLY USE SPECIAL TRAVEL IF
* TOTING IT), SO HE'S FORCED TO USE THE PLOVER-PASSAGE TO GET IT OUT. HAVING
* DROPPED IT, GO BACK AND PRETEND HE WASN'T CARRYING IT AFTER ALL. */
L30200: DROP(EMRALD,LOC);
goto L12;
/* TRAVEL 303. TROLL BRIDGE. MUST BE DONE ONLY AS SPECIAL MOTION SO THAT
* DWARVES WON'T WANDER ACROSS AND ENCOUNTER THE BEAR. (THEY WON'T FOLLOW THE
* PLAYER THERE BECAUSE THAT REGION IS FORBIDDEN TO THE PIRATE.) IF
* PROP(TROLL)=1, HE'S CROSSED SINCE PAYING, SO STEP OUT AND BLOCK HIM.
* (STANDARD TRAVEL ENTRIES CHECK FOR PROP(TROLL)=0.) SPECIAL STUFF FOR BEAR. */
L30300: if(PROP[TROLL] != 1) goto L30310;
PSPEAK(TROLL,1);
PROP[TROLL]=0;
MOVE(TROLL2,0);
MOVE(TROLL2+100,0);
MOVE(TROLL,PLAC[TROLL]);
MOVE(TROLL+100,FIXD[TROLL]);
JUGGLE(CHASM);
NEWLOC=LOC;
goto L2;
L30310: NEWLOC=PLAC[TROLL]+FIXD[TROLL]-LOC;
if(PROP[TROLL] == 0)PROP[TROLL]=1;
if(!TOTING(BEAR)) goto L2;
RSPEAK(162);
PROP[CHASM]=1;
PROP[TROLL]=2;
DROP(BEAR,NEWLOC);
FIXED[BEAR]= -1;
PROP[BEAR]=3;
OLDLC2=NEWLOC;
goto L99;
/* END OF SPECIALS. */
/* HANDLE "GO BACK". LOOK FOR VERB WHICH GOES FROM LOC TO OLDLOC, OR TO OLDLC2
* IF OLDLOC HAS FORCED-MOTION. K2 SAVES ENTRY -> FORCED LOC -> PREVIOUS LOC. */
L20: K=OLDLOC;
if(FORCED(K))K=OLDLC2;
OLDLC2=OLDLOC;
OLDLOC=LOC;
K2=0;
if(K == LOC)K2=91;
if(CNDBIT(LOC,4))K2=274;
if(K2 == 0) goto L21;
RSPEAK(K2);
goto L2;
L21: LL=MOD((IABS(TRAVEL[KK])/1000),1000);
if(LL == K) goto L25;
if(LL > 300) goto L22;
J=KEY[LL];
if(FORCED(LL) && MOD((IABS(TRAVEL[J])/1000),1000) == K)K2=KK;
L22: if(TRAVEL[KK] < 0) goto L23;
KK=KK+1;
goto L21;
L23: KK=K2;
if(KK != 0) goto L25;
RSPEAK(140);
goto L2;
L25: K=MOD(IABS(TRAVEL[KK]),1000);
KK=KEY[LOC];
goto L9;
/* LOOK. CAN'T GIVE MORE DETAIL. PRETEND IT WASN'T DARK (THOUGH IT MAY "NOW"
* BE DARK) SO HE WON'T FALL INTO A PIT WHILE STARING INTO THE GLOOM. */
L30: if(DETAIL < 3)RSPEAK(15);
DETAIL=DETAIL+1;
WZDARK=FALSE;
ABB[LOC]=0;
goto L2;
/* CAVE. DIFFERENT MESSAGES DEPENDING ON WHETHER ABOVE GROUND. */
L40: K=58;
if(OUTSID(LOC) && LOC != 8)K=57;
RSPEAK(K);
goto L2;
/* NON-APPLICABLE MOTION. VARIOUS MESSAGES DEPENDING ON WORD GIVEN. */
L50: SPK=12;
if(K >= 43 && K <= 50)SPK=52;
if(K == 29 || K == 30)SPK=52;
if(K == 7 || K == 36 || K == 37)SPK=10;
if(K == 11 || K == 19)SPK=11;
if(VERB == FIND || VERB == INVENT)SPK=59;
if(K == 62 || K == 65)SPK=42;
if(K == 17)SPK=80;
RSPEAK(SPK);
goto L2;
/* "YOU'RE DEAD, JIM."
*
* IF THE CURRENT LOC IS ZERO, IT MEANS THE CLOWN GOT HIMSELF KILLED. WE'LL
* ALLOW THIS MAXDIE TIMES. MAXDIE IS AUTOMATICALLY SET BASED ON THE NUMBER OF
* SNIDE MESSAGES AVAILABLE. EACH DEATH RESULTS IN A MESSAGE (81, 83, ETC.)
* WHICH OFFERS REINCARNATION; IF ACCEPTED, THIS RESULTS IN MESSAGE 82, 84,
* ETC. THE LAST TIME, IF HE WANTS ANOTHER CHANCE, HE GETS A SNIDE REMARK AS
* WE EXIT. WHEN REINCARNATED, ALL OBJECTS BEING CARRIED GET DROPPED AT OLDLC2
* (PRESUMABLY THE LAST PLACE PRIOR TO BEING KILLED) WITHOUT CHANGE OF PROPS.
* THE LOOP RUNS BACKWARDS TO ASSURE THAT THE BIRD IS DROPPED BEFORE THE CAGE.
* (THIS KLUGE COULD BE CHANGED ONCE WE'RE SURE ALL REFERENCES TO BIRD AND CAGE
* ARE DONE BY KEYWORDS.) THE LAMP IS A SPECIAL CASE (IT WOULDN'T DO TO LEAVE
* IT IN THE CAVE). IT IS TURNED OFF AND LEFT OUTSIDE THE BUILDING (ONLY IF HE
* WAS CARRYING IT, OF COURSE). HE HIMSELF IS LEFT INSIDE THE BUILDING (AND
* HEAVEN HELP HIM IF HE TRIES TO XYZZY BACK INTO THE CAVE WITHOUT THE LAMP!).
* OLDLOC IS ZAPPED SO HE CAN'T JUST "RETREAT". */
/* THE EASIEST WAY TO GET KILLED IS TO FALL INTO A PIT IN PITCH DARKNESS. */
L90: RSPEAK(23);
OLDLC2=LOC;
/* OKAY, HE'S DEAD. LET'S GET ON WITH IT. */
L99: if(CLOSNG) goto L95;
NUMDIE=NUMDIE+1;
if(!YES(79+NUMDIE*2,80+NUMDIE*2,54)) score(0);
if(NUMDIE == MAXDIE) score(0);
PLACE[WATER]=0;
PLACE[OIL]=0;
if(TOTING(LAMP))PROP[LAMP]=0;
/* 98 */ for (J=1; J<=100; J++) {
I=101-J;
if(!TOTING(I)) goto L98;
K=OLDLC2;
if(I == LAMP)K=1;
DROP(I,K);
L98: /*etc*/ ;
} /* end loop */
LOC=3;
OLDLOC=LOC;
goto L2000;
/* HE DIED DURING CLOSING TIME. NO RESURRECTION. TALLY UP A DEATH AND EXIT. */
L95: RSPEAK(131);
NUMDIE=NUMDIE+1;
score(0);
/* HINTS */
/* COME HERE IF HE'S BEEN LONG ENOUGH AT REQUIRED LOC(S) FOR SOME UNUSED HINT.
* HINT NUMBER IS IN VARIABLE "HINT". BRANCH TO QUICK TEST FOR ADDITIONAL
* CONDITIONS, THEN COME BACK TO DO NEAT STUFF. GOTO 40010 IF CONDITIONS ARE
* MET AND WE WANT TO OFFER THE HINT. GOTO 40020 TO CLEAR HINTLC BACK TO ZERO,
* 40030 TO TAKE NO ACTION YET. */
L40000: switch (HINT-1) { case 0: goto L40100; case 1: goto L40200; case 2: goto
L40300; case 3: goto L40400; case 4: goto L40500; case 5: goto
L40600; case 6: goto L40700; case 7: goto L40800; case 8: goto
L40900; case 9: goto L41000; }
/* CAVE BIRD SNAKE MAZE DARK WITT URN WOODS OGRE
* JADE */
BUG(27);
L40010: HINTLC[HINT]=0;
if(!YES(HINTS[HINT][3],0,54)) goto L2602;
SETPRM(1,HINTS[HINT][2],HINTS[HINT][2]);
RSPEAK(261);
HINTED[HINT]=YES(175,HINTS[HINT][4],54);
if(HINTED[HINT] && LIMIT > 30)LIMIT=LIMIT+30*HINTS[HINT][2];
L40020: HINTLC[HINT]=0;
L40030: goto L2602;
/* NOW FOR THE QUICK TESTS. SEE DATABASE DESCRIPTION FOR ONE-LINE NOTES. */
L40100: if(PROP[GRATE] == 0 && !HERE(KEYS)) goto L40010;
goto L40020;
L40200: if(PLACE[BIRD] == LOC && TOTING(ROD) && OLDOBJ == BIRD) goto L40010;
goto L40030;
L40300: if(HERE(SNAKE) && !HERE(BIRD)) goto L40010;
goto L40020;
L40400: if(ATLOC[LOC] == 0 && ATLOC[OLDLOC] == 0 && ATLOC[OLDLC2] == 0 && HOLDNG >
1) goto L40010;
goto L40020;
L40500: if(PROP[EMRALD] != -1 && PROP[PYRAM] == -1) goto L40010;
goto L40020;
L40600: goto L40010;
L40700: if(DFLAG == 0) goto L40010;
goto L40020;
L40800: if(ATLOC[LOC] == 0 && ATLOC[OLDLOC] == 0 && ATLOC[OLDLC2] == 0) goto
L40010;
goto L40030;
L40900: I=ATDWRF(LOC);
if(I < 0) goto L40020;
if(HERE(OGRE) && I == 0) goto L40010;
goto L40030;
L41000: if(TALLY == 1 && PROP[JADE] < 0) goto L40010;
goto L40020;
/* CAVE CLOSING AND SCORING */
/* THESE SECTIONS HANDLE THE CLOSING OF THE CAVE. THE CAVE CLOSES "CLOCK1"
* TURNS AFTER THE LAST TREASURE HAS BEEN LOCATED (INCLUDING THE PIRATE'S
* CHEST, WHICH MAY OF COURSE NEVER SHOW UP). NOTE THAT THE TREASURES NEED NOT
* HAVE BEEN TAKEN YET, JUST LOCATED. HENCE CLOCK1 MUST BE LARGE ENOUGH TO GET
* OUT OF THE CAVE (IT ONLY TICKS WHILE INSIDE THE CAVE). WHEN IT HITS ZERO,
* WE BRANCH TO 10000 TO START CLOSING THE CAVE, AND THEN SIT BACK AND WAIT FOR
* HIM TO TRY TO GET OUT. IF HE DOESN'T WITHIN CLOCK2 TURNS, WE CLOSE THE
* CAVE; IF HE DOES TRY, WE ASSUME HE PANICS, AND GIVE HIM A FEW ADDITIONAL
* TURNS TO GET FRANTIC BEFORE WE CLOSE. WHEN CLOCK2 HITS ZERO, WE BRANCH TO
* 11000 TO TRANSPORT HIM INTO THE FINAL PUZZLE. NOTE THAT THE PUZZLE DEPENDS
* UPON ALL SORTS OF RANDOM THINGS. FOR INSTANCE, THERE MUST BE NO WATER OR
* OIL, SINCE THERE ARE BEANSTALKS WHICH WE DON'T WANT TO BE ABLE TO WATER,
* SINCE THE CODE CAN'T HANDLE IT. ALSO, WE CAN HAVE NO KEYS, SINCE THERE IS A
* GRATE (HAVING MOVED THE FIXED OBJECT!) THERE SEPARATING HIM FROM ALL THE
* TREASURES. MOST OF THESE PROBLEMS ARISE FROM THE USE OF NEGATIVE PROP
* NUMBERS TO SUPPRESS THE OBJECT DESCRIPTIONS UNTIL HE'S ACTUALLY MOVED THE
* OBJECTS. */
/* WHEN THE FIRST WARNING COMES, WE LOCK THE GRATE, DESTROY THE BRIDGE, KILL
* ALL THE DWARVES (AND THE PIRATE), REMOVE THE TROLL AND BEAR (UNLESS DEAD),
* AND SET "CLOSNG" TO TRUE. LEAVE THE DRAGON; TOO MUCH TROUBLE TO MOVE IT.
* FROM NOW UNTIL CLOCK2 RUNS OUT, HE CANNOT UNLOCK THE GRATE, MOVE TO ANY
* LOCATION OUTSIDE THE CAVE, OR CREATE THE BRIDGE. NOR CAN HE BE
* RESURRECTED IF HE DIES. NOTE THAT THE SNAKE IS ALREADY GONE, SINCE HE GOT
* TO THE TREASURE ACCESSIBLE ONLY VIA THE HALL OF THE MT. KING. ALSO, HE'S
* BEEN IN GIANT ROOM (TO GET EGGS), SO WE CAN REFER TO IT. ALSO ALSO, HE'S
* GOTTEN THE PEARL, SO WE KNOW THE BIVALVE IS AN OYSTER. *AND*, THE DWARVES
* MUST HAVE BEEN ACTIVATED, SINCE WE'VE FOUND CHEST. */
L10000: PROP[GRATE]=0;
PROP[FISSUR]=0;
/* 10010 */ for (I=1; I<=6; I++) {
DSEEN[I]=FALSE;
L10010: DLOC[I]=0;
} /* end loop */
MOVE(TROLL,0);
MOVE(TROLL+100,0);
MOVE(TROLL2,PLAC[TROLL]);
MOVE(TROLL2+100,FIXD[TROLL]);
JUGGLE(CHASM);
if(PROP[BEAR] != 3)DSTROY(BEAR);
PROP[CHAIN]=0;
FIXED[CHAIN]=0;
PROP[AXE]=0;
FIXED[AXE]=0;
RSPEAK(129);
CLOCK1= -1;
CLOSNG=TRUE;
goto L19999;
/* ONCE HE'S PANICKED, AND CLOCK2 HAS RUN OUT, WE COME HERE TO SET UP THE
* STORAGE ROOM. THE ROOM HAS TWO LOCS, HARDWIRED AS 115 (NE) AND 116 (SW).
* AT THE NE END, WE PLACE EMPTY BOTTLES, A NURSERY OF PLANTS, A BED OF
* OYSTERS, A PILE OF LAMPS, RODS WITH STARS, SLEEPING DWARVES, AND HIM. AT
* THE SW END WE PLACE GRATE OVER TREASURES, SNAKE PIT, COVEY OF CAGED BIRDS,
* MORE RODS, AND PILLOWS. A MIRROR STRETCHES ACROSS ONE WALL. MANY OF THE
* OBJECTS COME FROM KNOWN LOCATIONS AND/OR STATES (E.G. THE SNAKE IS KNOWN TO
* HAVE BEEN DESTROYED AND NEEDN'T BE CARRIED AWAY FROM ITS OLD "PLACE"),
* MAKING THE VARIOUS OBJECTS BE HANDLED DIFFERENTLY. WE ALSO DROP ALL OTHER
* OBJECTS HE MIGHT BE CARRYING (LEST HE HAVE SOME WHICH COULD CAUSE TROUBLE,
* SUCH AS THE KEYS). WE DESCRIBE THE FLASH OF LIGHT AND TRUNDLE BACK. */
L11000: PROP[BOTTLE]=PUT(BOTTLE,115,1);
PROP[PLANT]=PUT(PLANT,115,0);
PROP[OYSTER]=PUT(OYSTER,115,0);
OBJTXT[OYSTER]=3;
PROP[LAMP]=PUT(LAMP,115,0);
PROP[ROD]=PUT(ROD,115,0);
PROP[DWARF]=PUT(DWARF,115,0);
LOC=115;
OLDLOC=115;
NEWLOC=115;
/* LEAVE THE GRATE WITH NORMAL (NON-NEGATIVE) PROPERTY. REUSE SIGN. */
I=PUT(GRATE,116,0);
I=PUT(SIGN,116,0);
OBJTXT[SIGN]=OBJTXT[SIGN]+1;
PROP[SNAKE]=PUT(SNAKE,116,1);
PROP[BIRD]=PUT(BIRD,116,1);
PROP[CAGE]=PUT(CAGE,116,0);
PROP[ROD2]=PUT(ROD2,116,0);
PROP[PILLOW]=PUT(PILLOW,116,0);
PROP[MIRROR]=PUT(MIRROR,115,0);
FIXED[MIRROR]=116;
/* 11010 */ for (I=1; I<=100; I++) {
L11010: if(TOTING(I))DSTROY(I);
} /* end loop */
RSPEAK(132);
CLOSED=TRUE;
goto L2;
/* ANOTHER WAY WE CAN FORCE AN END TO THINGS IS BY HAVING THE LAMP GIVE OUT.
* WHEN IT GETS CLOSE, WE COME HERE TO WARN HIM. WE GO TO 12000 IF THE LAMP
* AND FRESH BATTERIES ARE HERE, IN WHICH CASE WE REPLACE THE BATTERIES AND
* CONTINUE. 12200 IS FOR OTHER CASES OF LAMP DYING. 12400 IS WHEN IT GOES
* OUT. EVEN THEN, HE CAN EXPLORE OUTSIDE FOR A WHILE IF DESIRED. */
L12000: RSPEAK(188);
PROP[BATTER]=1;
if(TOTING(BATTER))DROP(BATTER,LOC);
LIMIT=LIMIT+2500;
LMWARN=FALSE;
goto L19999;
L12200: if(LMWARN || !HERE(LAMP)) goto L19999;
LMWARN=TRUE;
SPK=187;
if(PLACE[BATTER] == 0)SPK=183;
if(PROP[BATTER] == 1)SPK=189;
RSPEAK(SPK);
goto L19999;
L12400: LIMIT= -1;
PROP[LAMP]=0;
if(HERE(LAMP))RSPEAK(184);
goto L19999;
/* OH DEAR, HE'S DISTURBED THE DWARVES. */
L18999: RSPEAK(SPK);
L19000: RSPEAK(136);
score(0);
}
static finish_init() {
/* 1101 */ for (I=1; I<=100; I++) {
PLACE[I]=0;
PROP[I]=0;
LINK[I]=0;
L1101: {long x = I+100; LINK[x]=0;}
} /* end loop */
/* 1102 */ for (I=1; I<=LOCSIZ; I++) {
ABB[I]=0;
if(LTEXT[I] == 0 || KEY[I] == 0) goto L1102;
K=KEY[I];
if(MOD(IABS(TRAVEL[K]),1000) == 1)COND[I]=2;
L1102: ATLOC[I]=0;
} /* end loop */
/* SET UP THE ATLOC AND LINK ARRAYS AS DESCRIBED ABOVE. WE'LL USE THE DROP
* SUBROUTINE, WHICH PREFACES NEW OBJECTS ON THE LISTS. SINCE WE WANT THINGS
* IN THE OTHER ORDER, WE'LL RUN THE LOOP BACKWARDS. IF THE OBJECT IS IN TWO
* LOCS, WE DROP IT TWICE. THIS ALSO SETS UP "PLACE" AND "FIXED" AS COPIES OF
* "PLAC" AND "FIXD". ALSO, SINCE TWO-PLACED OBJECTS ARE TYPICALLY BEST
* DESCRIBED LAST, WE'LL DROP THEM FIRST. */
/* 1106 */ for (I=1; I<=100; I++) {
K=101-I;
if(FIXD[K] <= 0) goto L1106;
DROP(K+100,FIXD[K]);
DROP(K,PLAC[K]);
L1106: /*etc*/ ;
} /* end loop */
/* 1107 */ for (I=1; I<=100; I++) {
K=101-I;
FIXED[K]=FIXD[K];
L1107: if(PLAC[K] != 0 && FIXD[K] <= 0)DROP(K,PLAC[K]);
} /* end loop */
/* TREASURES, AS NOTED EARLIER, ARE OBJECTS 50 THROUGH MAXTRS (CURRENTLY 79).
* THEIR PROPS ARE INITIALLY -1, AND ARE SET TO 0 THE FIRST TIME THEY ARE
* DESCRIBED. TALLY KEEPS TRACK OF HOW MANY ARE NOT YET FOUND, SO WE KNOW
* WHEN TO CLOSE THE CAVE. */
MAXTRS=79;
TALLY=0;
/* 1200 */ for (I=50; I<=MAXTRS; I++) {
if(PTEXT[I] != 0)PROP[I]= -1;
L1200: TALLY=TALLY-PROP[I];
} /* end loop */
/* CLEAR THE HINT STUFF. HINTLC(I) IS HOW LONG HE'S BEEN AT LOC WITH COND BIT
* I. HINTED(I) IS TRUE IFF HINT I HAS BEEN USED. */
/* 1300 */ for (I=1; I<=HNTMAX; I++) {
HINTED[I]=FALSE;
L1300: HINTLC[I]=0;
} /* end loop */
/* DEFINE SOME HANDY MNEMONICS. THESE CORRESPOND TO OBJECT NUMBERS. */
AXE=VOCWRD(12405,1);
BATTER=VOCWRD(201202005,1);
BEAR=VOCWRD(2050118,1);
BIRD=VOCWRD(2091804,1);
BLOOD=VOCWRD(212151504,1);
BOTTLE=VOCWRD(215202012,1);
CAGE=VOCWRD(3010705,1);
CAVITY=VOCWRD(301220920,1);
CHASM=VOCWRD(308011913,1);
CLAM=VOCWRD(3120113,1);
DOOR=VOCWRD(4151518,1);
DRAGON=VOCWRD(418010715,1);
DWARF=VOCWRD(423011806,1);
FISSUR=VOCWRD(609191921,1);
FOOD=VOCWRD(6151504,1);
GRATE=VOCWRD(718012005,1);
KEYS=VOCWRD(11052519,1);
KNIFE=VOCWRD(1114090605,1);
LAMP=VOCWRD(12011316,1);
MAGZIN=VOCWRD(1301070126,1);
MESSAG=VOCWRD(1305191901,1);
MIRROR=VOCWRD(1309181815,1);
OGRE=VOCWRD(15071805,1);
OIL=VOCWRD(150912,1);
OYSTER=VOCWRD(1525192005,1);
PILLOW=VOCWRD(1609121215,1);
PLANT=VOCWRD(1612011420,1);
PLANT2=PLANT+1;
RESER=VOCWRD(1805190518,1);
ROD=VOCWRD(181504,1);
ROD2=ROD+1;
SIGN=VOCWRD(19090714,1);
SNAKE=VOCWRD(1914011105,1);
STEPS=VOCWRD(1920051619,1);
TROLL=VOCWRD(2018151212,1);
TROLL2=TROLL+1;
URN=VOCWRD(211814,1);
VEND=VOCWRD(1755140409,1);
VOLCAN=VOCWRD(1765120301,1);
WATER=VOCWRD(1851200518,1);
/* OBJECTS FROM 50 THROUGH WHATEVER ARE TREASURES. HERE ARE A FEW. */
AMBER=VOCWRD(113020518,1);
CHAIN=VOCWRD(308010914,1);
CHEST=VOCWRD(308051920,1);
COINS=VOCWRD(315091419,1);
EGGS=VOCWRD(5070719,1);
EMRALD=VOCWRD(513051801,1);
JADE=VOCWRD(10010405,1);
NUGGET=VOCWRD(7151204,1);
PEARL=VOCWRD(1605011812,1);
PYRAM=VOCWRD(1625180113,1);
RUBY=VOCWRD(18210225,1);
RUG=VOCWRD(182107,1);
SAPPH=VOCWRD(1901161608,1);
TRIDNT=VOCWRD(2018090405,1);
VASE=VOCWRD(22011905,1);
/* THESE ARE MOTION-VERB NUMBERS. */
BACK=VOCWRD(2010311,0);
CAVE=VOCWRD(3012205,0);
DPRSSN=VOCWRD(405161805,0);
ENTER=VOCWRD(514200518,0);
ENTRNC=VOCWRD(514201801,0);
LOOK=VOCWRD(12151511,0);
NUL=VOCWRD(14211212,0);
STREAM=VOCWRD(1920180501,0);
/* AND SOME ACTION VERBS. */
FIND=VOCWRD(6091404,2);
INVENT=VOCWRD(914220514,2);
LOCK=VOCWRD(12150311,2);
SAY=VOCWRD(190125,2);
THROW=VOCWRD(2008181523,2);
/* INITIALISE THE DWARVES. DLOC IS LOC OF DWARVES, HARD-WIRED IN. ODLOC IS
* PRIOR LOC OF EACH DWARF, INITIALLY GARBAGE. DALTLC IS ALTERNATE INITIAL LOC
* FOR DWARF, IN CASE ONE OF THEM STARTS OUT ON TOP OF THE ADVENTURER. (NO 2
* OF THE 5 INITIAL LOCS ARE ADJACENT.) DSEEN IS TRUE IF DWARF HAS SEEN HIM.
* DFLAG CONTROLS THE LEVEL OF ACTIVATION OF ALL THIS:
* 0 NO DWARF STUFF YET (WAIT UNTIL REACHES HALL OF MISTS)
* 1 REACHED HALL OF MISTS, BUT HASN'T MET FIRST DWARF
* 2 MET FIRST DWARF, OTHERS START MOVING, NO KNIVES THROWN YET
* 3 A KNIFE HAS BEEN THROWN (FIRST SET ALWAYS MISSES)
* 3+ DWARVES ARE MAD (INCREASES THEIR ACCURACY)
* SIXTH DWARF IS SPECIAL (THE PIRATE). HE ALWAYS STARTS AT HIS CHEST'S
* EVENTUAL LOCATION INSIDE THE MAZE. THIS LOC IS SAVED IN CHLOC FOR REF.
* THE DEAD END IN THE OTHER MAZE HAS ITS LOC STORED IN CHLOC2. */
CHLOC=114;
CHLOC2=140;
/* 1700 */ for (I=1; I<=6; I++) {
L1700: DSEEN[I]=FALSE;
} /* end loop */
DFLAG=0;
DLOC[1]=19;
DLOC[2]=27;
DLOC[3]=33;
DLOC[4]=44;
DLOC[5]=64;
DLOC[6]=CHLOC;
DALTLC=18;
/* OTHER RANDOM FLAGS AND COUNTERS, AS FOLLOWS:
* ABBNUM HOW OFTEN WE SHOULD PRINT NON-ABBREVIATED DESCRIPTIONS
* BONUS USED TO DETERMINE AMOUNT OF BONUS IF HE REACHES CLOSING
* CLOCK1 NUMBER OF TURNS FROM FINDING LAST TREASURE TILL CLOSING
* CLOCK2 NUMBER OF TURNS FROM FIRST WARNING TILL BLINDING FLASH
* CONDS MIN VALUE FOR COND(LOC) IF LOC HAS ANY HINTS
* DETAIL HOW OFTEN WE'VE SAID "NOT ALLOWED TO GIVE MORE DETAIL"
* DKILL NUMBER OF DWARVES KILLED (UNUSED IN SCORING, NEEDED FOR MSG)
* FOOBAR CURRENT PROGRESS IN SAYING "FEE FIE FOE FOO".
* HOLDNG NUMBER OF OBJECTS BEING CARRIED
* IGO HOW MANY TIMES HE'S SAID "GO XXX" INSTEAD OF "XXX"
* IWEST HOW MANY TIMES HE'S SAID "WEST" INSTEAD OF "W"
* KNFLOC 0 IF NO KNIFE HERE, LOC IF KNIFE HERE, -1 AFTER CAVEAT
* LIMIT LIFETIME OF LAMP (NOT SET HERE)
* MAXDIE NUMBER OF REINCARNATION MESSAGES AVAILABLE (UP TO 5)
* NUMDIE NUMBER OF TIMES KILLED SO FAR
* THRESH NEXT #TURNS THRESHHOLD (-1 IF NONE)
* TRNDEX INDEX IN TRNVAL OF NEXT THRESHHOLD (SECTION 14 OF DATABASE)
* TRNLUZ # POINTS LOST SO FAR DUE TO NUMBER OF TURNS USED
* TURNS TALLIES HOW MANY COMMANDS HE'S GIVEN (IGNORES YES/NO)
* LOGICALS WERE EXPLAINED EARLIER */
TURNS=0;
TRNDEX=1;
THRESH= -1;
if(TRNVLS > 0)THRESH=MOD(TRNVAL[1],100000)+1;
TRNLUZ=0;
LMWARN=FALSE;
IGO=0;
IWEST=0;
KNFLOC=0;
DETAIL=0;
ABBNUM=5;
/* 1800 */ for (I=0; I<=4; I++) {
L1800: {long x = 2*I+81; if(RTEXT[x] != 0)MAXDIE=I+1;}
} /* end loop */
NUMDIE=0;
HOLDNG=0;
DKILL=0;
FOOBAR=0;
BONUS=0;
CLOCK1=30;
CLOCK2=50;
CONDS=SETBIT(11);
SAVED=0;
CLOSNG=FALSE;
PANIC=FALSE;
CLOSED=FALSE;
CLSHNT=FALSE;
NOVICE=FALSE;
SETUP=1;
/* if we can ever think of how, we should save it at this point */
return(0); /* then we won't actually return from initialisation */
}
