home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Guide / c-cplusplus-interactive-guide.iso / c_ref / csource3 / 159_01 / verb.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-05-05  |  15.3 KB  |  1,048 lines
  1.  
  2.  /* VERB.C  no mods for V 1.43 */
  3.  
  4. #include "advent.h"
  5.  
  6. /*
  7.         Routine to process a transitive verb
  8. */
  9. VOID PASCAL trverb(VOID)
  10. {
  11.     switch (verb)
  12.     {
  13.     case CALM:
  14.     case WALK:
  15.     case QUIT:
  16.     case SCORE:
  17.     case FOO:
  18.     case BRIEF:
  19.     case SUSPEND:
  20.     case HOURS:
  21.     case LOG:
  22.         actspk(verb);
  23.         break;
  24.  
  25.     case TAKE:
  26.         vtake();
  27.         break;
  28.  
  29.     case DROP:
  30.         vdrop();
  31.         break;
  32.     case OPEN:
  33.     case LOCK:
  34.         vopen();
  35.         break;
  36.     case SAY:
  37.         vsay();
  38.         break;
  39.     case NOTHING:
  40.         rspeak(54);
  41.         break;
  42.     case ON:
  43.         von();
  44.         break;
  45.     case OFF:
  46.         voff();
  47.         break;
  48.     case WAVE:
  49.         vwave();
  50.         break;
  51.     case KILL:
  52.         vkill();
  53.         break;
  54.     case POUR:
  55.         vpour();
  56.         break;
  57.     case EAT:
  58.         veat();
  59.         break;
  60.     case DRINK:
  61.         vdrink();
  62.         break;
  63.     case RUB:
  64.         if (object != LAMP)
  65.         rspeak(76);
  66.         else
  67.         actspk(RUB);
  68.         break;
  69.     case THROW:
  70.         vthrow();
  71.         break;
  72.     case FEED:
  73.         vfeed();
  74.         break;
  75.     case FIND:
  76.     case INVENTORY:
  77.         vfind();
  78.         break;
  79.     case FILL:
  80.         vfill();
  81.         break;
  82.     case READ:
  83.         vread();
  84.         break;
  85.     case BLAST:
  86.         vblast();
  87.         break;
  88.     case BREAK:
  89.         vbreak();
  90.         break;
  91.     case WAKE:
  92.         vwake();
  93.         break;
  94.     case SAVE:
  95.         saveadv();
  96.         describe();
  97.         descitem();
  98.         break;
  99.     case RESTORE:
  100.         restore();
  101.         describe();
  102.         descitem();
  103.         break;
  104.     default:
  105.         printf("This verb is not implemented yet.\n");
  106.     }
  107.  
  108.     return;
  109. }
  110.  
  111. /*
  112.         CARRY TAKE etc.
  113. */
  114. VOID PASCAL vtake(VOID)
  115. {
  116.     auto     SHORT    msg;
  117.     auto     SHORT    i;
  118.  
  119.     if (toting(object))
  120.     {
  121.     actspk(verb);
  122.     return;
  123.     }
  124.  
  125.     /* special case objects and fixed objects */
  126.     msg = 25;
  127.     if (object == PLANT && prop[PLANT] <= 0)
  128.     msg = 115;
  129.     if (object == BEAR && prop[BEAR] == 1)
  130.     msg = 169;
  131.     if (object == CHAIN && prop[BEAR] != 0)
  132.     msg = 170;
  133.  
  134.     if (fixed[object])
  135.     {
  136.     rspeak(msg);
  137.     return;
  138.     }
  139.  
  140.     /* special case for liquids */
  141.     if (object == WATER || object == OIL)
  142.     {
  143.     if (!here(BOTTLE) || liq() != object)
  144.     {
  145.         object = BOTTLE;
  146.         if (toting(BOTTLE) && prop[BOTTLE] == 1)
  147.         {
  148.         vfill();
  149.         return;
  150.         }
  151.  
  152.         if (prop[BOTTLE] != 1)
  153.         msg = 105;
  154.         if (!toting(BOTTLE))
  155.         msg = 104;
  156.         rspeak(msg);
  157.         return;
  158.     }
  159.  
  160.     object = BOTTLE;
  161.     }
  162.  
  163.     if (holding >= 7)
  164.     {
  165.     rspeak(92);
  166.     return;
  167.     }
  168.  
  169.     /* special case for bird. */
  170.     if (object == BIRD && prop[BIRD] == 0)
  171.     {
  172.     if (toting(ROD))
  173.     {
  174.         rspeak(26);
  175.         return;
  176.     }
  177.  
  178.     if (!toting(CAGE))
  179.     {
  180.         rspeak(27);
  181.         return;
  182.     }
  183.  
  184.     prop[BIRD] = 1;
  185.     }
  186.  
  187.     if ((object == BIRD || object == CAGE) && prop[BIRD] != 0)
  188.     carry((BIRD + CAGE) - object, loc);
  189.  
  190.     carry(object, loc);
  191.  
  192.     /* handle liquid in bottle */
  193.     i = liq();
  194.     if (object == BOTTLE && i != 0)
  195.     place[i] = -1;
  196.     rspeak(54);
  197.  
  198.     return;
  199. }
  200.  
  201. /*
  202.         DROP etc.
  203. */
  204. VOID PASCAL vdrop(VOID)
  205. {
  206.     auto SHORT      i;
  207.  
  208.     /* check for dynamite */
  209.     if (toting(ROD2) && object == ROD && !toting(ROD))
  210.     object = ROD2;
  211.  
  212.     if (!toting(object))
  213.     {
  214.     actspk(verb);
  215.     return;
  216.     }
  217.  
  218.     /* snake and bird */
  219.     if (object == BIRD && here(SNAKE))
  220.     {
  221.     rspeak(30);
  222.     if (closed)
  223.         dwarfend();
  224.     dstroy(SNAKE);
  225.     prop[SNAKE] = -1;
  226.     }
  227.     else            /* coins and vending machine */
  228.     {
  229.     if (object == COINS && here(VEND))
  230.     {
  231.         dstroy(COINS);
  232.         drop(BATTERIES, loc);
  233.         pspeak(BATTERIES, 0);
  234.         return;
  235.     }
  236.     else            /* bird and dragon (ouch!!) */
  237.     {
  238.         if (object == BIRD && at(DRAGON) && prop[DRAGON] == 0)
  239.         {
  240.         rspeak(154);
  241.         dstroy(BIRD);
  242.         prop[BIRD] = 0;
  243.         if (place[SNAKE] != 0)
  244.             ++tally2;
  245.         return;
  246.         }
  247.     }
  248.     }
  249.  
  250.     /* Bear and troll */
  251.     if (object == BEAR && at(TROLL))
  252.     {
  253.     rspeak(163);
  254.     move(TROLL, 0);
  255.     move((TROLL + MAXOBJ), 0);
  256.     move(TROLL2, 117);
  257.     move((TROLL2 + MAXOBJ), 122);
  258.     juggle(CHASM);
  259.     prop[TROLL] = 2;
  260.     }
  261.     else            /* vase */
  262.     {
  263.     if (object == VASE)
  264.     {
  265.         if (loc == 96)
  266.         rspeak(54);
  267.         else
  268.         {
  269.         prop[VASE] = at(PILLOW) ? 0 : 2;
  270.         pspeak(VASE, prop[VASE] + 1);
  271.         if (prop[VASE] != 0)
  272.             fixed[VASE] = -1;
  273.         }
  274.     }
  275.     }
  276.  
  277.     /* handle liquid and bottle */
  278.     i = liq();
  279.     if (i == object)
  280.     object = BOTTLE;
  281.  
  282.     if (object == BOTTLE && i != 0)
  283.     place[i] = 0;
  284.  
  285.     /* handle bird and cage */
  286.     if (object == CAGE && prop[BIRD] != 0)
  287.     drop(BIRD, loc);
  288.     if (object == BIRD)
  289.     prop[BIRD] = 0;
  290.     drop(object, loc);
  291.  
  292.     return;
  293. }
  294.  
  295. /*
  296.         LOCK, UNLOCK, OPEN, CLOSE etc.
  297. */
  298. VOID PASCAL vopen(VOID)
  299. {
  300.     auto SHORT      msg, oyclam;
  301.  
  302.     switch (object)
  303.     {
  304.     case CLAM:
  305.     case OYSTER:
  306.         oyclam = (object == OYSTER ? 1 : 0);
  307.         if (verb == LOCK)
  308.         msg = 61;
  309.         else
  310.         {
  311.         if (!toting(TRIDENT))
  312.             msg = 122 + oyclam;
  313.         else
  314.         {
  315.             if (toting(object))
  316.             msg = 120 + oyclam;
  317.             else
  318.             {
  319.             msg = 124 + oyclam;
  320.             dstroy(CLAM);
  321.             drop(OYSTER, loc);
  322.             drop(PEARL, 105);
  323.             }
  324.         }
  325.         }
  326.         break;
  327.     case DOOR:
  328.         msg = (prop[DOOR] == 1 ? 54 : 111);
  329.         break;
  330.     case CAGE:
  331.         msg = 32;
  332.         break;
  333.     case KEYS:
  334.         msg = 55;
  335.         break;
  336.     case CHAIN:
  337.         if (!here(KEYS))
  338.         msg = 31;
  339.         else
  340.         {
  341.         if (verb == LOCK)
  342.         {
  343.             if (prop[CHAIN] != 0)
  344.             msg = 34;
  345.             else
  346.             if (loc != 130)
  347.             msg = 173;
  348.             else
  349.             {
  350.             prop[CHAIN] = 2;
  351.             if (toting(CHAIN))
  352.                 drop(CHAIN, loc);
  353.             fixed[CHAIN] = -1;
  354.             msg = 172;
  355.             }
  356.         }
  357.         else
  358.         {
  359.             if (prop[BEAR] == 0)
  360.             msg = 41;
  361.             else
  362.             {
  363.             if (prop[CHAIN] == 0)
  364.                 msg = 37;
  365.             else
  366.             {
  367.                 prop[CHAIN] = 0;
  368.                 fixed[CHAIN] = 0;
  369.                 if (prop[BEAR] != 3)
  370.                 prop[BEAR] = 2;
  371.                 fixed[BEAR] = 2 - prop[BEAR];
  372.                 msg = 171;
  373.             }
  374.             }
  375.         }
  376.         }
  377.         break;
  378.     case GRATE:
  379.         if (!here(KEYS))
  380.         msg = 31;
  381.         else
  382.         {
  383.         if (closing)
  384.         {
  385.             if (!panic)
  386.             {
  387.             clock2 = 15;
  388.             ++panic;
  389.             }
  390.             msg = 130;
  391.         }
  392.         else
  393.         {
  394.             msg = 34 + prop[GRATE];
  395.             prop[GRATE] = (verb == LOCK ? 0 : 1);
  396.             msg += 2 * prop[GRATE];
  397.         }
  398.         }
  399.         break;
  400.     default:
  401.         msg = 33;
  402.     }
  403.     rspeak(msg);
  404.     return;
  405. }
  406.  
  407. /*
  408.         SAY etc.
  409. */
  410. VOID PASCAL vsay(VOID)
  411. {
  412.     auto SHORT      wtype, wval;
  413.  
  414.     analyze(word1, &wtype, &wval);
  415.     printf("Okay.\n%s\n", wval == SAY ? word2 : word1);
  416.     return;
  417. }
  418.  
  419. /*
  420.         ON etc.
  421. */
  422. VOID PASCAL von(VOID)
  423. {
  424.     if (!here(LAMP))
  425.     actspk(verb);
  426.     else
  427.     {
  428.     if (limit < 0)
  429.         rspeak(184);
  430.     else
  431.     {
  432.         prop[LAMP] = 1;
  433.         rspeak(39);
  434.         if (wzdark)
  435.         {
  436.         wzdark = 0;
  437.         describe();
  438.         descitem();
  439.         }
  440.     }
  441.     }
  442.  
  443.     return;
  444. }
  445.  
  446. /*
  447.         OFF etc.
  448. */
  449. VOID PASCAL voff(VOID)
  450. {
  451.     if (!here(LAMP))
  452.     actspk(verb);
  453.     else
  454.     {
  455.     prop[LAMP] = 0;
  456.     rspeak(40);
  457.     }
  458.  
  459.     return;
  460. }
  461.  
  462. /*
  463.         WAVE etc.
  464. */
  465. VOID PASCAL vwave(VOID)
  466. {
  467.     if (!toting(object) && (object != ROD || !toting(ROD2)))
  468.     rspeak(29);
  469.     else
  470.     {
  471.     if (object != ROD || !at(FISSURE) || !toting(object) || closing)
  472.         actspk(verb);
  473.     else
  474.     {
  475.         prop[FISSURE] = 1 - prop[FISSURE];
  476.         pspeak(FISSURE, 2 - prop[FISSURE]);
  477.     }
  478.     }
  479. }
  480.  
  481. /*
  482.         ATTACK, KILL etc.
  483. */
  484. VOID PASCAL vkill(VOID)
  485. {
  486.     auto SHORT      msg;
  487.     auto SHORT      i;
  488.  
  489.     switch (object)
  490.     {
  491.     case BIRD:
  492.         if (closed)
  493.         msg = 137;
  494.         else
  495.         {
  496.         dstroy(BIRD);
  497.         prop[BIRD] = 0;
  498.         if (place[SNAKE] == 19)
  499.             ++tally2;
  500.         msg = 45;
  501.         }
  502.         break;
  503.     case 0:
  504.         msg = 44;
  505.         break;
  506.     case CLAM:
  507.     case OYSTER:
  508.         msg = 150;
  509.         break;
  510.     case SNAKE:
  511.         msg = 46;
  512.         break;
  513.     case DWARF:
  514.         if (closed)
  515.         dwarfend();
  516.         msg = 49;
  517.         break;
  518.     case TROLL:
  519.         msg = 157;
  520.         break;
  521.     case BEAR:
  522.         msg = 165 + (prop[BEAR] + 1) / 2;
  523.         break;
  524.     case DRAGON:
  525.         if (prop[DRAGON] != 0)
  526.         {
  527.         msg = 167;
  528.         break;
  529.         }
  530.         if (!yes(49, 0, 0))
  531.         break;
  532.         pspeak(DRAGON, 1);
  533.         prop[DRAGON] = 2;
  534.         prop[RUG] = 0;
  535.         move((DRAGON + MAXOBJ), -1);
  536.         move((RUG + MAXOBJ), 0);
  537.         move(DRAGON, 120);
  538.         move(RUG, 120);
  539.         for (i = 1; i < MAXOBJ; ++i)
  540.         if (place[i] == 119 || place[i] == 121)
  541.             move(i, 120);
  542.         newloc = 120;
  543.         return;
  544.     default:
  545.         actspk(verb);
  546.         return;
  547.     }
  548.     rspeak(msg);
  549. }
  550.  
  551. /*
  552.         POUR
  553. */
  554. VOID PASCAL vpour(VOID)
  555. {
  556.     if (object == BOTTLE || object == 0)
  557.     object = liq();
  558.  
  559.     if (object == 0)
  560.     {
  561.     needobj();
  562.     return;
  563.     }
  564.  
  565.     if (!toting(object))
  566.     {
  567.     actspk(verb);
  568.     return;
  569.     }
  570.  
  571.     if (object != OIL && object != WATER)
  572.     {
  573.     rspeak(78);
  574.     return;
  575.     }
  576.  
  577.     prop[BOTTLE] = 1;
  578.     place[object] = 0;
  579.  
  580.     if (at(PLANT))
  581.     {
  582.     if (object != WATER)
  583.         rspeak(112);
  584.     else
  585.     {
  586.         pspeak(PLANT, prop[PLANT] + 1);
  587.         prop[PLANT] = (prop[PLANT] + 2) % 6;
  588.         prop[PLANT2] = prop[PLANT] / 2;
  589.         describe();
  590.     }
  591.     }
  592.     else
  593.     {
  594.     if (at(DOOR))
  595.     {
  596.         prop[DOOR] = (object == OIL ? 1 : 0);
  597.         rspeak(113 + prop[DOOR]);
  598.     }
  599.     else
  600.         rspeak(77);
  601.     }
  602.  
  603.     return;
  604. }
  605.  
  606. /*
  607.         EAT
  608. */
  609. VOID PASCAL veat(VOID)
  610. {
  611.     auto SHORT      msg;
  612.  
  613.     switch (object)
  614.     {
  615.     case FOOD:
  616.         dstroy(FOOD);
  617.         msg = 72;
  618.         break;
  619.     case BIRD:
  620.     case SNAKE:
  621.     case CLAM:
  622.     case OYSTER:
  623.     case DWARF:
  624.     case DRAGON:
  625.     case TROLL:
  626.     case BEAR:
  627.         msg = 71;
  628.         break;
  629.     default:
  630.         actspk(verb);
  631.         return;
  632.     }
  633.     rspeak(msg);
  634.     return;
  635. }
  636.  
  637. /*
  638.         DRINK
  639. */
  640. VOID PASCAL vdrink(VOID)
  641. {
  642.     if (object != WATER)
  643.     rspeak(110);
  644.     else
  645.     {
  646.     if (liq() != WATER || !here(BOTTLE))
  647.         actspk(verb);
  648.     else
  649.     {
  650.         prop[BOTTLE] = 1;
  651.         place[WATER] = 0;
  652.         rspeak(74);
  653.     }
  654.     }
  655.  
  656.     return;
  657. }
  658.  
  659. /*
  660.         THROW etc.
  661. */
  662. VOID PASCAL vthrow(VOID)
  663. {
  664.     auto SHORT      msg;
  665.     auto SHORT      i;
  666.  
  667.     if (toting(ROD2) && object == ROD && !toting(ROD))
  668.     object = ROD2;
  669.  
  670.     if (!toting(object))
  671.     {
  672.     actspk(verb);
  673.     return;
  674.     }
  675.  
  676.     /* treasure to troll */
  677.     if (at(TROLL) && object >= 50 && object < MAXOBJ)
  678.     {
  679.     rspeak(159);
  680.     drop(object, 0);
  681.     move(TROLL, 0);
  682.     move((TROLL + MAXOBJ), 0);
  683.     drop(TROLL2, 117);
  684.     drop((TROLL2 + MAXOBJ), 122);
  685.     juggle(CHASM);
  686.     return;
  687.     }
  688.  
  689.     /* feed the bears... */
  690.     if (object == FOOD && here(BEAR))
  691.     {
  692.     object = BEAR;
  693.     vfeed();
  694.     return;
  695.     }
  696.  
  697.     /* if not axe, same as drop... */
  698.     if (object != AXE)
  699.     {
  700.     vdrop();
  701.     return;
  702.     }
  703.  
  704.     /* AXE is THROWN */
  705.     /* at a dwarf... */
  706.     if (i = dcheck())
  707.     {
  708.     msg = 48;
  709.     if (pct(33))
  710.     {
  711.         dseen[i] = dloc[i] = 0;
  712.         msg = 47;
  713.         ++dkill;
  714.         if (dkill == 1)
  715.         msg = 149;
  716.     }
  717.     }
  718.     else            /* at a dragon... */
  719.     {
  720.     if (at(DRAGON) && prop[DRAGON] == 0)
  721.         msg = 152;
  722.     else            /* at the troll... */
  723.     {
  724.         if (at(TROLL))
  725.         msg = 158;
  726.         else        /* at the bear... */
  727.         {
  728.         if (here(BEAR) && prop[BEAR] == 0)
  729.         {
  730.             rspeak(164);
  731.             drop(AXE, loc);
  732.             fixed[AXE] = -1;
  733.             prop[AXE]  = 1;
  734.             juggle(BEAR);
  735.             return;
  736.         }
  737.         else        /* otherwise it is an attack */
  738.         {
  739.             verb = KILL;
  740.             object = 0;
  741.             itverb();
  742.             return;
  743.         }
  744.         }
  745.     }
  746.     }
  747.  
  748.     /* handle the left over axe... */
  749.     rspeak(msg);
  750.     drop(AXE, loc);
  751.     describe();
  752.     return;
  753. }
  754.  
  755. /*
  756.         INVENTORY, FIND etc.
  757. */
  758. VOID PASCAL vfind(VOID)
  759. {
  760.     auto SHORT      msg;
  761.  
  762.     if (toting(object))
  763.     msg = 24;
  764.     else
  765.     {
  766.     if (closed)
  767.         msg = 138;
  768.     else
  769.     {
  770.         if (dcheck() && dflag >= 2 && object == DWARF)
  771.         msg = 94;
  772.         else
  773.         {
  774.         if (at(object) ||
  775.             (liq() == object && here(BOTTLE)) ||
  776.             object == liqloc(loc))
  777.             msg = 94;
  778.         else
  779.         {
  780.             actspk(verb);
  781.             return;
  782.         }
  783.         }
  784.     }
  785.     }
  786.     rspeak(msg);
  787.  
  788.     return;
  789. }
  790.  
  791. /*
  792.         FILL
  793. */
  794. VOID PASCAL vfill(VOID)
  795. {
  796.     auto SHORT      msg;
  797.     auto SHORT        i;
  798.  
  799.     switch (object)
  800.     {
  801.     case BOTTLE:
  802.         if (liq() != 0)
  803.         msg = 105;
  804.         else
  805.         {
  806.         if (liqloc(loc) == 0)
  807.             msg = 106;
  808.         else
  809.         {
  810.             prop[BOTTLE] = cond[loc] & WATOIL;
  811.             i = liq();
  812.             if (toting(BOTTLE))
  813.             place[i] = -1;
  814.             msg = (i == OIL ? 108 : 107);
  815.         }
  816.         }
  817.         break;
  818.     case VASE:
  819.         if (liqloc(loc) == 0)
  820.         {
  821.         msg = 144;
  822.         break;
  823.         }
  824.         if (!toting(VASE))
  825.         {
  826.         msg = 29;
  827.         break;
  828.         }
  829.         rspeak(145);
  830.         vdrop();
  831.         return;
  832.     default:
  833.         msg = 29;
  834.     }
  835.     rspeak(msg);
  836. }
  837.  
  838. /*
  839.         FEED
  840. */
  841. VOID PASCAL vfeed(VOID)
  842. {
  843.     auto SHORT      msg;
  844.  
  845.     switch (object)
  846.     {
  847.     case BIRD:
  848.         msg = 100;
  849.         break;
  850.     case DWARF:
  851.         if (!here(FOOD))
  852.         {
  853.         actspk(verb);
  854.         return;
  855.         }
  856.         ++dflag;
  857.         msg = 103;
  858.         break;
  859.     case BEAR:
  860.         if (!here(FOOD))
  861.         {
  862.         if (prop[BEAR] == 0)
  863.             msg = 102;
  864.         else
  865.         {
  866.             if (prop[BEAR] == 3)
  867.             msg = 110;
  868.             else
  869.             {
  870.             actspk(verb);
  871.             return;
  872.             }
  873.         }
  874.         break;
  875.         }
  876.         dstroy(FOOD);
  877.         prop[BEAR] = 1;
  878.         fixed[AXE] = 0;
  879.         prop[AXE] = 0;
  880.         msg = 168;
  881.         break;
  882.     case DRAGON:
  883.         msg = (prop[DRAGON] != 0 ? 110 : 102);
  884.         break;
  885.     case TROLL:
  886.         msg = 182;
  887.         break;
  888.     case SNAKE:
  889.         if (closed || !here(BIRD))
  890.         {
  891.         msg = 102;
  892.         break;
  893.         }
  894.         msg = 101;
  895.         dstroy(BIRD);
  896.         prop[BIRD] = 0;
  897.         ++tally2;
  898.         break;
  899.     default:
  900.         msg = 14;
  901.     }
  902.     rspeak(msg);
  903. }
  904.  
  905. /*
  906.         READ etc.
  907. */
  908. VOID PASCAL vread(VOID)
  909. {
  910.     auto SHORT      msg;
  911.  
  912.     msg = 0;
  913.     if (dark())
  914.     {
  915.     printf("I see no %s here.\n", probj(object));
  916.     return;
  917.     }
  918.     switch (object)
  919.     {
  920.     case MAGAZINE:
  921.         msg = 190;
  922.         break;
  923.     case TABLET:
  924.         msg = 196;
  925.         break;
  926.     case MESSAGE:
  927.         msg = 191;
  928.         break;
  929.     case OYSTER:
  930.         if (!toting(OYSTER) || !closed)
  931.         break;
  932.         yes(192, 193, 54);
  933.         return;
  934.     default:
  935.         ;
  936.     }
  937.     if (msg)
  938.     rspeak(msg);
  939.     else
  940.     actspk(verb);
  941.  
  942.     return;
  943. }
  944.  
  945. /*
  946.         BLAST etc.
  947. */
  948. VOID PASCAL vblast(VOID)
  949. {
  950.     if (prop[ROD2] < 0 || !closed)
  951.     actspk(verb);
  952.     else
  953.     {
  954.     bonus = 133;
  955.     if (loc == 115)
  956.         bonus = 134;
  957.     if (here(ROD2))
  958.         bonus = 135;
  959.     rspeak(bonus);
  960.     normend();
  961.     }
  962.  
  963.     return;
  964. }
  965.  
  966. /*
  967.         BREAK etc.
  968. */
  969. VOID PASCAL vbreak(VOID)
  970. {
  971.     auto SHORT      msg;
  972.  
  973.     if (object == MIRROR)
  974.     {
  975.     msg = 148;
  976.     if (closed)
  977.     {
  978.         rspeak(197);
  979.         dwarfend();
  980.     }
  981.     }
  982.     else
  983.     {
  984.     if (object == VASE && prop[VASE] == 0)
  985.     {
  986.         msg = 198;
  987.         if (toting(VASE))
  988.         drop(VASE, loc);
  989.         prop[VASE]    = 2;
  990.         fixed[VASE] = -1;
  991.     }
  992.     else
  993.     {
  994.         actspk(verb);
  995.         return;
  996.     }
  997.     }
  998.     rspeak(msg);
  999.  
  1000.     return;
  1001. }
  1002.  
  1003. /*
  1004.         WAKE etc.
  1005. */
  1006. VOID PASCAL vwake(VOID)
  1007. {
  1008.     if (object != DWARF || !closed)
  1009.     actspk(verb);
  1010.     else
  1011.     {
  1012.     rspeak(199);
  1013.     dwarfend();
  1014.     }
  1015.  
  1016.     return;
  1017. }
  1018.  
  1019. /*
  1020.         Routine to speak default verb message
  1021. */
  1022. VOID PASCAL actspk(SHORT verb)
  1023. {
  1024.     auto SHORT      i;
  1025.  
  1026.     if (verb < 1 || verb > 31)
  1027.     bug(39);
  1028.     i = actmsg[verb];
  1029.     if (i)
  1030.     rspeak(i);
  1031.  
  1032.     return;
  1033. }
  1034.  
  1035. /*
  1036.         Routine to indicate no reasonable
  1037.         object for verb found.  Used mostly by
  1038.         intransitive verbs.
  1039. */
  1040. VOID PASCAL needobj(VOID)
  1041. {
  1042.     auto SHORT      wtype, wval;
  1043.  
  1044.     analyze(word1, &wtype, &wval);
  1045.     printf("%s what?\n", wtype == 2 ? word1 : word2);
  1046.     return;
  1047. }
  1048.