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