home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 2 BBS / 02-BBS.zip / OP2DEV.ZIP / TURN.C < prev    next >
C/C++ Source or Header  |  1990-05-10  |  17KB  |  896 lines
  1.  
  2. /*    program TURN.C                        *\
  3. \*    WARNING: "advent.c" allocates GLOBAL storage space by    *\
  4. \*        including "advdef.h".                *\
  5. \*        All other modules use "advdec.h".        */
  6.  
  7.  
  8. #include    "stdio.h"    /* drv = 1.1st file 2.def 3.A    */
  9. #include    "advent.h"
  10. #include    "advdec.h"
  11.  
  12. #define INCL_DOS
  13. #define INCL_SUB
  14. #include <os2.h>
  15.  
  16. #include "bbsexpan.h"
  17.  
  18. extern    int    printf();
  19.  
  20.  
  21. char *probj(int);
  22.  
  23. /*
  24.     Routine to take 1 turn
  25. */
  26. turn()
  27. {
  28.     char    i;
  29.     /*
  30.         if closing, then he can't leave except via
  31.         the main office.
  32.     */
  33.     if (newloc < 9 && newloc != 0 && closing) {
  34.         rspeak(130);
  35.         newloc = loc;
  36.         if (!panic)
  37.             clock2 = 15;
  38.         panic = 1;
  39.     }
  40.     /*
  41.         see if a dwarf has seen him and has come
  42.         from where he wants to go.
  43.     */
  44.     if (newloc != loc && !forced(loc) && cond[loc]&NOPIRAT  ==  0)
  45.         for (i = 1; i< (DWARFMAX-1); ++i)
  46.             if (odloc[i] == newloc && dseen[i]) {
  47.                 newloc  =  loc;
  48.                 rspeak(2);
  49.                 break;
  50.             }
  51.  
  52.     dwarves();    /* & special dwarf(pirate who steals)    */
  53.  
  54.     /* added by BDS C conversion */
  55.     if (loc != newloc) {
  56.         ++turns;
  57.         loc = newloc;
  58. /*    causes occasional "move" with two describe & descitem    */
  59. /*    }    */            /* if (loc != newloc)    */
  60.  
  61.     /* check for death */
  62.     if (loc == 0) {
  63.         death();
  64.         return(1);
  65.     }
  66.  
  67.     /* check for forced move */
  68.     if (forced (loc)) {
  69.         describe();
  70.         domove();
  71.         return(1);
  72.     }
  73.  
  74.     /* check for wandering in dark */
  75.     if (wzdark && dark() && pct(35)) {
  76.         rspeak(23);
  77.         oldloc2 = loc;
  78.         death();
  79.         return(1);
  80.     }
  81.  
  82.     /* describe his situation */
  83.     describe();
  84.     if (!dark ()) {
  85.         ++visited[loc];
  86.         descitem();
  87.     }
  88. /*    causes occasional "move" with no describe & descitem    */
  89.     }                /* if (loc != newloc)    */
  90.  
  91.     if (closed) {
  92.         if (prop[OYSTER] < 0 && toting (OYSTER))
  93.             pspeak(OYSTER, 1);
  94.         for (i = 1; i <= MAXOBJ; ++i)
  95.             if (toting (i) && prop[i] < 0)
  96.                 prop[i] = -1-prop[i];
  97.     }
  98.  
  99.     wzdark = dark();
  100.     if (knfloc > 0 && knfloc != loc)
  101.         knfloc  =  0;
  102.  
  103.     if (stimer())    /* as the grains of sand slip by    */
  104.         return(1);
  105.  
  106.     while (!english())    /* retrieve player instructions    */
  107.         ;
  108.  
  109.     if (dbugflg)
  110.         SerWritef(unhand,"loc = %d, verb = %d, object = %d, \
  111.         motion = %d\n\r", loc, verb, object, motion);
  112.  
  113.     if (motion)        /* execute player instructions    */
  114.         domove();
  115.     else if (object)
  116.         doobj();
  117.     else
  118.         itverb();
  119. }
  120.  
  121. /*
  122.     Routine to describe current location
  123. */
  124. describe()
  125. {
  126.     if (toting(BEAR))
  127.         rspeak(141);
  128.     if (dark())
  129.         rspeak(16);
  130.     else if (visited[loc])
  131.         descsh(loc);
  132.     else
  133.         desclg(loc);
  134.     if (loc == 33 && pct(25) && !closing)
  135.         rspeak(8);
  136. }
  137.  
  138. /*
  139.     Routine to describe visible items
  140. */
  141. descitem()
  142. {
  143.     int    i, state;
  144.  
  145.     for (i = 1;i<MAXOBJ; ++i) {
  146.         if (at(i)) {
  147.             if (i == STEPS && toting(NUGGET))
  148.                 continue;
  149.             if (prop[i]<0) {
  150.                 if (closed)
  151.                     continue;
  152.                 else {
  153.                     prop[i] = 0;
  154.                     if (i == RUG || i == CHAIN)
  155.                         ++prop[i];
  156.                     --tally;
  157.                 }
  158.             }
  159.             if (i == STEPS && loc == fixed[STEPS])
  160.                 state = 1;
  161.             else
  162.                 state = prop[i];
  163.             pspeak(i, state);
  164.         }
  165.     }
  166.     if (tally == tally2 && tally != 0 && limit > 35)
  167.         limit = 35;
  168. }
  169.  
  170. /*
  171.     Routine to handle motion requests
  172. */
  173. domove()
  174. {
  175.     gettrav(loc);
  176.     switch(motion) {
  177.     case NULLX:
  178.         break;
  179.     case BACK:
  180.         goback();
  181.         break;
  182.     case LOOK:
  183.         if (detail++<3)
  184.             rspeak(15);
  185.         wzdark = 0;
  186.         visited[loc] = 0;
  187.         newloc = loc;
  188.         loc = 0;
  189.         break;
  190.     case CAVE:
  191.         if (loc<8)
  192.             rspeak(57);
  193.         else
  194.             rspeak(58);
  195.         break;
  196.     default:
  197.         oldloc2 = oldloc;
  198.         oldloc = loc;
  199.         dotrav();
  200.     }
  201. }
  202.  
  203. /*
  204.     Routine to handle request to return
  205.     from whence we came!
  206. */
  207. goback()
  208. {
  209.     int    kk, k2, want, temp;
  210.     struct trav strav[MAXTRAV];
  211.  
  212.     if (forced(oldloc))
  213.         want = oldloc2;
  214.     else
  215.         want = oldloc;
  216.     oldloc2 = oldloc;
  217.     oldloc = loc;
  218.     k2 = 0;
  219.     if (want == loc) {
  220.         rspeak(91);
  221.         return(1);
  222.     }
  223.     copytrv(travel, strav);
  224.     for (kk = 0; travel[kk].tdest != -1; ++kk) {
  225.         if (!travel[kk].tcond && travel[kk].tdest == want) {
  226.             motion = travel[kk].tverb;
  227.             dotrav();
  228.             return(1);
  229.         }
  230.         if (!travel[kk].tcond) {
  231.             k2 = kk;
  232.             temp = travel[kk].tdest;
  233.             gettrav(temp);
  234.             if (forced(temp) && travel[0].tdest == want)
  235.                 k2 = temp;
  236.             copytrv(strav, travel);
  237.         }
  238.     }
  239.     if (k2) {
  240.         motion = travel[k2].tverb;
  241.         dotrav();
  242.     }
  243.     else
  244.         rspeak(140);
  245. }
  246.  
  247. /*
  248.     Routine to copy a travel array
  249. */
  250. copytrv(trav1, trav2)
  251. struct trav *trav1, *trav2;
  252. {
  253.     int    i;
  254.  
  255.     for (i = 0; i<MAXTRAV; ++i) {
  256.         trav2 -> tdest = trav1 -> tdest;
  257.         trav2 -> tverb = trav1 -> tverb;
  258.         trav2 -> tcond = trav1 -> tcond;
  259.     }
  260. }
  261.  
  262. /*
  263.     Routine to figure out a new location
  264.     given current location and a motion.
  265. */
  266. dotrav()
  267. {
  268.     char    mvflag, hitflag, kk;
  269.     int    rdest, rverb, rcond, robject;
  270.     int    pctt;
  271.  
  272.     newloc = loc;
  273.     mvflag = hitflag = 0;
  274.     pctt = rand()%100;
  275.  
  276.     for (kk = 0; travel[kk].tdest>=0 && !mvflag; ++kk) {
  277.         rdest = travel[kk].tdest;
  278.         rverb = travel[kk].tverb;
  279.         rcond = travel[kk].tcond;
  280.         robject = rcond%100;
  281.  
  282.         if (dbugflg)
  283.             SerWritef(unhand,"rdest = %d, rverb = %d, rcond = %d, \
  284.             robject = %d in dotrav\n\r", rdest, rverb, \
  285.             rcond, robject);
  286.         if ((rverb != 1) && (rverb != motion) && !hitflag)
  287.             continue;
  288.         ++hitflag;
  289.         switch(rcond/100) {
  290.         case 0:
  291.             if ((rcond == 0) || (pctt < rcond))
  292.                 ++mvflag;
  293.             if (rcond && dbugflg)
  294.                 SerWritef(unhand,"%% move %d %d\n\r",
  295.                     pctt, mvflag);
  296.             break;
  297.         case 1:
  298.             if (robject == 0)
  299.                 ++mvflag;
  300.             else if (toting(robject))
  301.                 ++mvflag;
  302.             break;
  303.         case 2:
  304.             if (toting(robject) || at(robject))
  305.                 ++mvflag;
  306.             break;
  307.         case 3:
  308.         case 4:
  309.         case 5:
  310.         case 7:
  311.             if (prop[robject] != (rcond/100)-3)
  312.                 ++mvflag;
  313.             break;
  314.         default:
  315.             bug(37);
  316.         }
  317.     }
  318.     if (!mvflag)
  319.         badmove();
  320.     else if (rdest>500)
  321.         rspeak(rdest-500);
  322.     else if (rdest>300)
  323.         spcmove(rdest);
  324.     else {
  325.         newloc = rdest;
  326.         if (dbugflg)
  327.             SerWritef(unhand,"newloc in dotrav = %d\n\r", newloc);
  328.     }
  329. }
  330.  
  331. /*
  332.     The player tried a poor move option.
  333. */
  334. badmove()
  335. {
  336.     int    msg;
  337.  
  338.     msg = 12;
  339.     if (motion >= 43 && motion <=50) msg = 9;
  340.     if (motion == 29 || motion == 30) msg = 9;
  341.     if (motion == 7 || motion == 36 || motion == 37) msg = 10;
  342.     if (motion == 11 || motion == 19) msg = 11;
  343.     if (verb == FIND || verb == INVENTORY) msg = 59;
  344.     if (motion == 62 || motion == 65) msg = 42;
  345.     if (motion == 17) msg = 80;
  346.     rspeak(msg);
  347. }
  348.  
  349. /*
  350.     Routine to handle very special movement.
  351. */
  352. spcmove(rdest)
  353. int    rdest;
  354. {
  355.     switch(rdest-300) {
  356.     case 1:  /* plover movement via alcove */
  357.         if (!holding || (holding == 1 && toting(EMERALD)))
  358.             newloc = (99+100)-loc;
  359.         else
  360.             rspeak(117);
  361.         break;
  362.     case 2:  /* trying to remove plover, bad route */
  363.         drop(EMERALD, loc);
  364.         break;
  365.     case 3:  /* troll bridge */
  366.         if (prop[TROLL] == 1) {
  367.             pspeak(TROLL, 1);
  368.             prop[TROLL] = 0;
  369.             move(TROLL2, 0);
  370.             move((TROLL2+MAXOBJ), 0);
  371.             move(TROLL, 117);
  372.             move((TROLL+MAXOBJ), 122);
  373.             juggle(CHASM);
  374.             newloc = loc;
  375.         }
  376.         else {
  377.             newloc = (loc == 117 ? 122 : 117);
  378.             if (prop[TROLL] == 0)
  379.                 ++prop[TROLL];
  380.             if (!toting (BEAR))
  381.                 return(1);
  382.             rspeak(162);
  383.             prop[CHASM] = 1;
  384.             prop[TROLL] = 2;
  385.             drop(BEAR, newloc);
  386.             fixed[BEAR] = -1;
  387.             prop[BEAR] = 3;
  388.             if (prop[SPICES]<0)
  389.                 ++tally2;
  390.             oldloc2 = newloc;
  391.             death();
  392.         }
  393.         break;
  394.     default:
  395.         bug(38);
  396.     }
  397. }
  398.  
  399.  
  400. /*
  401.     Routine to handle player's demise via
  402.     waking up the dwarves...
  403. */
  404. dwarfend()
  405. {
  406.     death();
  407.     normend();
  408. }
  409.  
  410. /*
  411.     normal end of game
  412. */
  413. normend()
  414. {
  415.     score();
  416.     exit();
  417. }
  418.  
  419. /*
  420.     scoring
  421. */
  422. score()
  423. {
  424.     int    t, i, k, s;
  425.     s = t = 0;
  426.     for (i = 50; i<=MAXTRS; ++i) {
  427.         if (i == CHEST)
  428.             k = 14;
  429.         else if (i > CHEST)
  430.             k = 16;
  431.         else 
  432.             k = 12;
  433.         if (prop[i] >= 0)
  434.             t += 2;
  435.         if (place[i] == 3 && prop[i] == 0)
  436.             t += k-2;
  437.     }
  438.  
  439.      COLOR(MAGENTA);
  440.      SerWrite("\n\r\n\rYour Score:\n\r\n\r",unhand);
  441.      COLOR(BRWHITE);
  442.      SerWritef(unhand,"%-20s","Treasures");
  443.      COLOR(BRYELLOW);
  444.     SerWritef(unhand,"%d\n\r",s = t);
  445.  
  446.     t = (MAXDIE - numdie)*10;
  447.     if (t) {
  448.           COLOR(BRWHITE);
  449.         SerWritef(unhand,"%-20s","Survival:");
  450.           COLOR(BRYELLOW);
  451.           SerWritef(unhand,"%d\n\r",t);
  452.      }     
  453.     s += t;
  454.     if (!gaveup)
  455.         s += 4;
  456.     t = dflag ? 25 : 0;
  457.     if (t) {
  458.           COLOR(BRWHITE);
  459.         SerWritef(unhand,"%-20s", "Getting well in:");
  460.           COLOR(BRYELLOW);
  461.           SerWritef(unhand,"%d\n\r",t);
  462.      }     
  463.     s += t;
  464.     t = closing ? 25 : 0;
  465.     if (t) {
  466.           COLOR(BRWHITE);
  467.         SerWritef(unhand,"%-20s", "Masters section:");
  468.           COLOR(BRYELLOW);
  469.           SerWritef(unhand,"%d\n\r",t);
  470.      }     
  471.     s += t;
  472.     if (closed) {
  473.         if (bonus == 0)
  474.             t = 10;
  475.         else if (bonus == 135)
  476.             t = 25;
  477.         else if (bonus == 134)
  478.             t = 30;
  479.         else if (bonus == 133)
  480.             t = 45;
  481.           COLOR(BRWHITE);
  482.         SerWritef(unhand,"%-20s", "Bonus:");
  483.           COLOR(BRYELLOW);
  484.           SerWritef(unhand,"%d\n\r",t);
  485.         s += t;
  486.     }
  487.     if (place[MAGAZINE] == 108)
  488.         s += 1;
  489.     s += 2;
  490.      COLOR(BRWHITE);
  491.     SerWritef(unhand,"%-20s", "Score:");
  492.      COLOR(BRRED);
  493.      SerWritef(unhand,"%d\n\r",s);
  494. }
  495.  
  496. /*
  497.     Routine to handle the passing on of one
  498.     of the player's incarnations...
  499. */
  500. death()
  501. {
  502.     char    yea, i, j, k;
  503.  
  504.     if (!closing) {
  505.         yea = yes(81+numdie*2, 82+numdie*2, 54);
  506.         if (++numdie >= MAXDIE || !yea)
  507.             normend();
  508.         place[WATER] = 0;
  509.         place[OIL] = 0;
  510.         if (toting(LAMP))
  511.             prop[LAMP] = 0;
  512.         for (j = 1; j<101; ++j) {
  513.             i = 101-j;
  514.             if (toting (i))
  515.                 drop(i, i == LAMP ? 1:oldloc2);
  516.         }
  517.         newloc = 3;
  518.         oldloc = loc;
  519.         return(1);
  520.     }
  521.     /*
  522.        closing -- no resurrection...
  523.     */
  524.     rspeak(131);
  525.     ++numdie;
  526.     normend();
  527. }
  528.  
  529. /*
  530.     Routine to process an object.
  531. */
  532. doobj()
  533. {
  534.     char    i;
  535.     /*
  536.        is object here?  if so, transitive
  537.     */
  538.     if (fixed[object] == loc || here(object))
  539.         trobj();
  540.     /*
  541.         did he give grate as destination?
  542.     */
  543.     else if (object == GRATE) {
  544.         if (loc == 1 || loc == 4 || loc == 7) {
  545.             motion = DEPRESSION;
  546.             domove();
  547.         }
  548.         else if (loc>9 && loc<15) {
  549.             motion = ENTRANCE;
  550.             domove();
  551.         }
  552.     }
  553.     /*
  554.         is it a dwarf he is after?
  555.     */
  556.     else if (dcheck() && dflag >= 2) {
  557.         object = DWARF;
  558.         trobj();
  559.     }
  560.     /*
  561.        is he trying to get/use a liquid?
  562.     */
  563.     else if ((liq() == object && here(BOTTLE)) ||
  564.          liqloc(loc) == object)
  565.         trobj();
  566.     else if (object == PLANT && at(PLANT2) &&
  567.         prop[PLANT2] == 0) {
  568.         object = PLANT2;
  569.         trobj();
  570.     }
  571.     /*
  572.        is he trying to grab a knife?
  573.     */
  574.     else if (object == KNIFE && knfloc == loc) {
  575.         rspeak(116);
  576.         knfloc = -1;
  577.     }
  578.     /*
  579.        is he trying to get at dynamite?
  580.     */
  581.     else if (object == ROD && here(ROD2)) {
  582.         object = ROD2;
  583.         trobj();
  584.     }
  585.     else
  586.         SerWritef(unhand,"I see no %s here.\n\r", probj(object));
  587. }
  588.  
  589. /*
  590.     Routine to process an object being
  591.     referred to.
  592. */
  593. trobj()
  594. {
  595.     if (verb)
  596.         trverb();
  597.     else
  598.         SerWritef(unhand,"What do you want to do with the %s?\n\r",
  599.             probj(object));
  600. }
  601.  
  602. /*
  603.     Routine to print word corresponding to object
  604. */
  605. char *probj(int object)
  606. {
  607.     int    wtype, wval;
  608.     analyze(word1, &wtype, &wval);
  609.     return (wtype == 1 ? word1 : word2);
  610. }
  611. /*
  612.     dwarf stuff.
  613. */
  614. dwarves()
  615. {
  616.     int    i, j, k, try, attack, stick, dtotal;
  617.     /*
  618.         see if dwarves allowed here
  619.     */
  620.     if (newloc == 0 || forced(newloc) || cond[newloc]&NOPIRAT)
  621.         return(1);
  622.     /*
  623.         see if dwarves are active.
  624.     */
  625.     if (!dflag) {
  626.         if (newloc > 15)
  627.             ++dflag;
  628.         return(1);
  629.     }
  630.     /*
  631.         if first close encounter (of 3rd kind)
  632.         kill 0, 1 or 2
  633.     */
  634.     if (dflag == 1) {
  635.         if (newloc < 15 || pct (95))
  636.             return(1);
  637.         ++dflag;
  638.         for (i = 1; i<3; ++i)
  639.             if (pct (50))
  640.                 dloc[rand()%5+1] = 0;
  641.         for (i = 1; i< (DWARFMAX-1); ++i) {
  642.             if (dloc[i] == newloc)
  643.                 dloc[i] = daltloc;
  644.             odloc[i] = dloc[i];
  645.         }
  646.         rspeak(3);
  647.         drop(AXE, newloc);
  648.         return(1);
  649.     }
  650.     dtotal = attack = stick = 0;
  651.     for (i = 1; i<DWARFMAX; ++i) {
  652.         if (dloc[i] == 0)
  653.             continue;
  654.         /*
  655.             move a dwarf at random.  we don't
  656.             have a matrix around to do it
  657.             as in the original version...
  658.         */
  659.         for (try = 1; try<20; ++try) {
  660.             j = rand()%106+15; /* allowed area */
  661.             if (j != odloc[i] && j != dloc[i] &&
  662.                 !(i == (DWARFMAX-1) && cond[j]&NOPIRAT == 1))
  663.                 break;
  664.         }
  665.         if (j == 0)
  666.             j = odloc[i];
  667.         odloc[i] = dloc[i];
  668.         dloc[i] = j;
  669.         if ((dseen[i] && newloc >= 15) ||
  670.             dloc[i] == newloc || odloc[i] == newloc)
  671.             dseen[i] = 1;
  672.         else
  673.             dseen[i] = 0;
  674.         if (!dseen[i])
  675.             continue;
  676.         dloc[i] = newloc;
  677.         if (i == 6)
  678.             dopirate();
  679.         else {
  680.             ++dtotal;
  681.             if (odloc[i] == dloc[i]) {
  682.                 ++attack;
  683.                 if (knfloc >= 0)
  684.                     knfloc = newloc;
  685.                 if (rand()%1000 < 95*(dflag-2))
  686.                     ++stick;
  687.             }
  688.         }
  689.     }
  690.     if (dtotal == 0)
  691.         return(1);
  692.     if (dtotal > 1)
  693.         SerWritef(unhand,"There are %d threatening little dwarves in the room with you!\n\r", dtotal);
  694.     else
  695.         rspeak(4);
  696.     if (attack == 0)
  697.         return(1);
  698.     if (dflag == 2)
  699.         ++dflag;
  700.     if (attack > 1) {
  701.         SerWritef(unhand,"%d of them throw knives at you!!\n\r", attack);
  702.         k = 6;
  703.     }
  704.     else {
  705.         rspeak(5);
  706.         k = 52;
  707.     }
  708.     if (stick <= 1) {
  709.         rspeak(stick+k);
  710.         if (stick == 0)
  711.             return(1);
  712.     }
  713.     else
  714.         SerWritef(unhand,"%d of them get you !!!\n\r", stick);
  715.     oldloc2 = newloc;
  716.     death();
  717. }
  718. /*
  719.     pirate stuff
  720. */
  721. dopirate()
  722. {
  723.     int    j, k;
  724.     if (newloc == chloc || prop[CHEST] >= 0)
  725.         return(1);
  726.     k = 0;
  727.     for (j = 50; j<=MAXTRS; ++j)
  728.         if (j != PYRAMID ||
  729.             (newloc != place[PYRAMID] &&
  730.              newloc != place[EMERALD])) {
  731.             if (toting(j))
  732.                 goto stealit;
  733.             if (here(j))
  734.                 ++k;
  735.         }
  736.     if (tally == tally2+1 && k == 0 && place[CHEST] == 0 &&
  737.         here(LAMP) && prop[LAMP] == 1) {
  738.         rspeak(186);
  739.         move(CHEST, chloc);
  740.         move(MESSAGE, chloc2);
  741.         dloc[6] = chloc;
  742.         odloc[6] = chloc;
  743.         dseen[6] = 0;
  744.         return(1);
  745.     }
  746.     if (odloc[6] != dloc[6] && pct(20)) {
  747.         rspeak(127);
  748.         return(1);
  749.     }
  750.     return(1);
  751.  
  752. stealit:
  753.  
  754.     rspeak(128);
  755.     if (place[MESSAGE] == 0)
  756.         move(CHEST, chloc);
  757.     move(MESSAGE, chloc2);
  758.     for (j = 50; j<=MAXTRS; ++j) {
  759.         if (j == PYRAMID &&
  760.             (newloc == place[PYRAMID] ||
  761.              newloc == place[EMERALD]))
  762.             continue;
  763.         if (at(j) && fixed[j] == 0)
  764.             carry(j, newloc);
  765.         if (toting(j))
  766.             drop(j, chloc);
  767.     }
  768.     dloc[6] = chloc;
  769.     odloc[6] = chloc;
  770.     dseen[6] = 0;
  771. }
  772. /*
  773.     special time limit stuff...
  774. */
  775. stimer()
  776. {
  777.     int    i;
  778.     foobar = foobar > 0 ?  -foobar : 0;
  779.     if (tally == 0 && loc >= 15 && loc != 33)
  780.         --clock1;
  781.     if (clock1 == 0) {
  782.         /*
  783.             start closing the cave
  784.         */
  785.         prop[GRATE] = 0;
  786.         prop[FISSURE] = 0;
  787.         for (i = 1; i<DWARFMAX; ++i)
  788.             dseen[i] = 0;
  789.         move(TROLL, 0);
  790.         move((TROLL+MAXOBJ), 0);
  791.         move(TROLL2, 117);
  792.         move((TROLL2+MAXOBJ), 122);
  793.         juggle(CHASM);
  794.         if (prop[BEAR] != 3)
  795.             dstroy(BEAR);
  796.         prop[CHAIN] = 0;
  797.         fixed[CHAIN] = 0;
  798.         prop[AXE] = 0;
  799.         fixed[AXE] = 0;
  800.         rspeak(129);
  801.         clock1 = -1;
  802.         closing = 1;
  803.         return(0);
  804.     }
  805.     if (clock1 < 0)
  806.         --clock2;
  807.     if (clock2 == 0) {
  808.         /*
  809.             set up storage room...
  810.             and close the cave...
  811.         */
  812.         prop[BOTTLE] = put(BOTTLE, 115, 1);
  813.         prop[PLANT] = put(PLANT, 115, 0);
  814.         prop[OYSTER] = put(OYSTER, 115, 0);
  815.         prop[LAMP] = put(LAMP, 115, 0);
  816.         prop[ROD] = put(ROD, 115, 0);
  817.         prop[DWARF] = put(DWARF, 115, 0);
  818.         loc = 115;
  819.         oldloc = 115;
  820.         newloc = 115;
  821.         put(GRATE, 116, 0);
  822.         prop[SNAKE] = put(SNAKE, 116, 1);
  823.         prop[BIRD] = put(BIRD, 116, 1);
  824.         prop[CAGE] = put(CAGE, 116, 0);
  825.         prop[ROD2] = put(ROD2, 116, 0);
  826.         prop[PILLOW] = put(PILLOW, 116, 0);
  827.         prop[MIRROR] = put(MIRROR, 115, 0);
  828.         fixed[MIRROR] = 116;
  829.         for (i = 1; i<= MAXOBJ; ++i)
  830.             if (toting(i))
  831.                 dstroy(i);
  832.         rspeak(132);
  833.         closed = 1;
  834.         return(1);
  835.     }
  836.     if (prop[LAMP] == 1)
  837.         --limit;
  838.     if (limit <= 30 &&
  839.         here(BATTERIES) && prop[BATTERIES] == 0 &&
  840.         here(LAMP)) {
  841.         rspeak(188);
  842.         prop[BATTERIES] = 1;
  843.         if (toting(BATTERIES))
  844.             drop(BATTERIES, loc);
  845.         limit += 2500;
  846.         lmwarn = 0;
  847.         return(0);
  848.     }
  849.     if (limit == 0) {
  850.         --limit;
  851.         prop[LAMP] = 0;
  852.         if (here(LAMP))
  853.             rspeak(184);
  854.         return(0);
  855.     }
  856.     if (limit < 0 && loc <= 8) {
  857.         rspeak(185);
  858.         gaveup = 1;
  859.         normend();
  860.     }
  861.     if (limit <= 30) {
  862.         if (lmwarn || !here(LAMP))
  863.             return(0);
  864.         lmwarn = 1;
  865.         i = 187;
  866.         if (place[BATTERIES] == 0)
  867.             i = 183;
  868.         if (prop[BATTERIES] == 1)
  869.             i = 189;
  870.         rspeak(i);
  871.         return(0);
  872.     }
  873.     return(0);
  874. }
  875.  
  876. /*
  877.     random number seed
  878. */
  879. static    long    rnum = 0;
  880.  
  881. srand(n)
  882. short    n;
  883. {
  884.     rnum = (long)n;
  885. }
  886.  
  887. /*
  888.     random number
  889. */
  890. rand()
  891. {
  892.     rnum = rnum * 0x41C64E6D + 0x3039;
  893.     return((short)(rnum >> 16) & 0x7FFF);
  894. }
  895.  
  896.