games/hack/hack.eat.c

   1 /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
   2 /* hack.eat.c - version 1.0.3 */
   3 /* $FreeBSD: src/games/hack/hack.eat.c,v 1.4 1999/11/16 10:26:36 marcel Exp $ */
   4 /* $DragonFly: src/games/hack/hack.eat.c,v 1.5 2006/08/21 19:45:32 pavalos Exp $ */
   5
   6 #include        "hack.h"
   7 char POISONOUS[] = "ADKSVabhks";
   8
   9 static bool     opentin(void);
  10 static void     Meatdone(void);
  11 static void     unfaint(void);
  12 static void     newuhs(bool);
  13 static int      eatcorpse(struct obj *);
  14
  15 /* hunger texts used on bottom line (each 8 chars long) */
  16 #define SATIATED        0
  17 #define NOT_HUNGRY      1
  18 #define HUNGRY          2
  19 #define WEAK            3
  20 #define FAINTING        4
  21 #define FAINTED         5
  22 #define STARVED         6
  23
  24 const char *hu_stat[] = {
  25         "Satiated",
  26         "        ",
  27         "Hungry  ",
  28         "Weak    ",
  29         "Fainting",
  30         "Fainted ",
  31         "Starved "
  32 };
  33
  34 void
  35 init_uhunger(void)
  36 {
  37         u.uhunger = 900;
  38         u.uhs = NOT_HUNGRY;
  39 }
  40
  41 #define TTSZ    SIZE(tintxts)
  42 struct { const char *txt; int nut; } tintxts[] = {
  43         { "It contains first quality peaches - what a surprise!", 40 },
  44         { "It contains salmon - not bad!", 60 },
  45         { "It contains apple juice - perhaps not what you hoped for.", 20 },
  46         { "It contains some nondescript substance, tasting awfully.", 500 },
  47         { "It contains rotten meat. You vomit.", -50 },
  48         { "It turns out to be empty.", 0 }
  49 };
  50
  51 static struct {
  52         struct obj *tin;
  53         int usedtime, reqtime;
  54 } tin;
  55
  56 static bool
  57 opentin(void)
  58 {
  59         int r;
  60
  61         if(!carried(tin.tin))           /* perhaps it was stolen? */
  62                 return(0);              /* %% probably we should use tinoid */
  63         if(tin.usedtime++ >= 50) {
  64                 pline("You give up your attempt to open the tin.");
  65                 return(0);
  66         }
  67         if(tin.usedtime < tin.reqtime)
  68                 return(1);              /* still busy */
  69
  70         pline("You succeed in opening the tin.");
  71         useup(tin.tin);
  72         r = rn2(2*TTSZ);
  73         if(r < TTSZ){
  74             pline(tintxts[r].txt);
  75             lesshungry(tintxts[r].nut);
  76             if(r == 1)  /* SALMON */ {
  77                 Glib = rnd(15);
  78                 pline("Eating salmon made your fingers very slippery.");
  79             }
  80         } else {
  81             pline("It contains spinach - this makes you feel like Popeye!");
  82             lesshungry(600);
  83             if(u.ustr < 118)
  84                 u.ustr += rnd( ((u.ustr < 17) ? 19 : 118) - u.ustr);
  85             if(u.ustr > u.ustrmax) u.ustrmax = u.ustr;
  86             flags.botl = 1;
  87         }
  88         return(0);
  89 }
  90
  91 static void
  92 Meatdone(void)
  93 {
  94         u.usym = '@';
  95         prme();
  96 }
  97
  98 int
  99 doeat(void)
 100 {
 101         struct obj *otmp;
 102         struct objclass *ftmp;
 103         int tmp;
 104
 105         /* Is there some food (probably a heavy corpse) here on the ground? */
 106         if(!Levitation)
 107         for(otmp = fobj; otmp; otmp = otmp->nobj) {
 108                 if(otmp->ox == u.ux && otmp->oy == u.uy &&
 109                    otmp->olet == FOOD_SYM) {
 110                         pline("There %s %s here; eat %s? [ny] ",
 111                                 (otmp->quan == 1) ? "is" : "are",
 112                                 doname(otmp),
 113                                 (otmp->quan == 1) ? "it" : "one");
 114                         if(readchar() == 'y') {
 115                                 if(otmp->quan != 1)
 116                                         splitobj(otmp, 1);
 117                                 freeobj(otmp);
 118                                 otmp = addinv(otmp);
 119                                 addtobill(otmp);
 120                                 goto gotit;
 121                         }
 122                 }
 123         }
 124         otmp = getobj("%", "eat");
 125         if(!otmp) return(0);
 126 gotit:
 127         if(otmp->otyp == TIN){
 128                 if(uwep) {
 129                         switch(uwep->otyp) {
 130                         case CAN_OPENER:
 131                                 tmp = 1;
 132                                 break;
 133                         case DAGGER:
 134                         case CRYSKNIFE:
 135                                 tmp = 3;
 136                                 break;
 137                         case PICK_AXE:
 138                         case AXE:
 139                                 tmp = 6;
 140                                 break;
 141                         default:
 142                                 goto no_opener;
 143                         }
 144                         pline("Using your %s you try to open the tin.",
 145                                 aobjnam(uwep, (char *) 0));
 146                 } else {
 147                 no_opener:
 148                         pline("It is not so easy to open this tin.");
 149                         if(Glib) {
 150                                 pline("The tin slips out of your hands.");
 151                                 if(otmp->quan > 1) {
 152                                         struct obj *obj;
 153
 154                                         obj = splitobj(otmp, 1);
 155                                         if(otmp == uwep) setuwep(obj);
 156                                 }
 157                                 dropx(otmp);
 158                                 return(1);
 159                         }
 160                         tmp = 10 + rn2(1 + 500/((int)(u.ulevel + u.ustr)));
 161                 }
 162                 tin.reqtime = tmp;
 163                 tin.usedtime = 0;
 164                 tin.tin = otmp;
 165                 occupation = opentin;
 166                 occtxt = "opening the tin";
 167                 return(1);
 168         }
 169         ftmp = &objects[otmp->otyp];
 170         multi = -ftmp->oc_delay;
 171         if(otmp->otyp >= CORPSE && eatcorpse(otmp)) goto eatx;
 172         if(!rn2(7) && otmp->otyp != FORTUNE_COOKIE) {
 173                 pline("Blecch!  Rotten food!");
 174                 if(!rn2(4)) {
 175                         pline("You feel rather light headed.");
 176                         Confusion += d(2,4);
 177                 } else if(!rn2(4)&& !Blind) {
 178                         pline("Everything suddenly goes dark.");
 179                         Blind = d(2,10);
 180                         seeoff(0);
 181                 } else if(!rn2(3)) {
 182                         if(Blind)
 183                           pline("The world spins and you slap against the floor.");
 184                         else
 185                           pline("The world spins and goes dark.");
 186                         nomul(-rnd(10));
 187                         nomovemsg = "You are conscious again.";
 188                 }
 189                 lesshungry(ftmp->nutrition / 4);
 190         } else {
 191                 if(u.uhunger >= 1500) {
 192                         pline("You choke over your food.");
 193                         pline("You die...");
 194                         killer = ftmp->oc_name;
 195                         done("choked");
 196                 }
 197                 switch(otmp->otyp){
 198                 case FOOD_RATION:
 199                         if(u.uhunger <= 200)
 200                                 pline("That food really hit the spot!");
 201                         else if(u.uhunger <= 700)
 202                                 pline("That satiated your stomach!");
 203                         else {
 204         pline("You're having a hard time getting all that food down.");
 205                                 multi -= 2;
 206                         }
 207                         lesshungry(ftmp->nutrition);
 208                         if(multi < 0) nomovemsg = "You finished your meal.";
 209                         break;
 210                 case TRIPE_RATION:
 211                         pline("Yak - dog food!");
 212                         more_experienced(1,0);
 213                         flags.botl = 1;
 214                         if(rn2(2)){
 215                                 pline("You vomit.");
 216                                 morehungry(20);
 217                                 if(Sick) {
 218                                         Sick = 0;       /* David Neves */
 219                                         pline("What a relief!");
 220                                 }
 221                         } else  lesshungry(ftmp->nutrition);
 222                         break;
 223                 default:
 224                         if(otmp->otyp >= CORPSE)
 225                         pline("That %s tasted terrible!",ftmp->oc_name);
 226                         else
 227                         pline("That %s was delicious!",ftmp->oc_name);
 228                         lesshungry(ftmp->nutrition);
 229                         if(otmp->otyp == DEAD_LIZARD && (Confusion > 2))
 230                                 Confusion = 2;
 231                         else
 232 #ifdef QUEST
 233                         if(otmp->otyp == CARROT && !Blind){
 234                                 u.uhorizon++;
 235                                 setsee();
 236                                 pline("Your vision improves.");
 237                         } else
 238 #endif /* QUEST */
 239                         if(otmp->otyp == FORTUNE_COOKIE) {
 240                           if(Blind) {
 241                             pline("This cookie has a scrap of paper inside!");
 242                             pline("What a pity, that you cannot read it!");
 243                           } else
 244                             outrumor();
 245                         } else
 246                         if(otmp->otyp == LUMP_OF_ROYAL_JELLY) {
 247                                 /* This stuff seems to be VERY healthy! */
 248                                 if(u.ustrmax < 118) u.ustrmax++;
 249                                 if(u.ustr < u.ustrmax) u.ustr++;
 250                                 u.uhp += rnd(20);
 251                                 if(u.uhp > u.uhpmax) {
 252                                         if(!rn2(17)) u.uhpmax++;
 253                                         u.uhp = u.uhpmax;
 254                                 }
 255                                 heal_legs();
 256                         }
 257                         break;
 258                 }
 259         }
 260 eatx:
 261         if(multi<0 && !nomovemsg){
 262                 static char msgbuf[BUFSZ];
 263                 sprintf(msgbuf, "You finished eating the %s.",
 264                                 ftmp->oc_name);
 265                 nomovemsg = msgbuf;
 266         }
 267         useup(otmp);
 268         return(1);
 269 }
 270
 271 /* called in hack.main.c */
 272 void
 273 gethungry(void)
 274 {
 275         --u.uhunger;
 276         if(moves % 2) {
 277                 if(Regeneration) u.uhunger--;
 278                 if(Hunger) u.uhunger--;
 279                 /* a3:  if(Hunger & LEFT_RING) u.uhunger--;
 280                         if(Hunger & RIGHT_RING) u.uhunger--;
 281                    etc. */
 282         }
 283         if(moves % 20 == 0) {                   /* jimt@asgb */
 284                 if(uleft) u.uhunger--;
 285                 if(uright) u.uhunger--;
 286         }
 287         newuhs(TRUE);
 288 }
 289
 290 /* called after vomiting and after performing feats of magic */
 291 void
 292 morehungry(int num)
 293 {
 294         u.uhunger -= num;
 295         newuhs(TRUE);
 296 }
 297
 298 /* called after eating something (and after drinking fruit juice) */
 299 void
 300 lesshungry(int num)
 301 {
 302         u.uhunger += num;
 303         newuhs(FALSE);
 304 }
 305
 306 static void
 307 unfaint(void)
 308 {
 309         u.uhs = FAINTING;
 310         flags.botl = 1;
 311 }
 312
 313 static void
 314 newuhs(bool incr)
 315 {
 316         int newhs, h = u.uhunger;
 317
 318         newhs = (h > 1000) ? SATIATED :
 319                 (h > 150) ? NOT_HUNGRY :
 320                 (h > 50) ? HUNGRY :
 321                 (h > 0) ? WEAK : FAINTING;
 322
 323         if(newhs == FAINTING) {
 324                 if(u.uhs == FAINTED)
 325                         newhs = FAINTED;
 326                 if(u.uhs <= WEAK || rn2(20-u.uhunger/10) >= 19) {
 327                         if(u.uhs != FAINTED && multi >= 0 /* %% */) {
 328                                 pline("You faint from lack of food.");
 329                                 nomul(-10+(u.uhunger/10));
 330                                 nomovemsg = "You regain consciousness.";
 331                                 afternmv = unfaint;
 332                                 newhs = FAINTED;
 333                         }
 334                 } else
 335                 if(u.uhunger < -(int)(200 + 25*u.ulevel)) {
 336                         u.uhs = STARVED;
 337                         flags.botl = 1;
 338                         bot();
 339                         pline("You die from starvation.");
 340                         done("starved");
 341                 }
 342         }
 343
 344         if(newhs != u.uhs) {
 345                 if(newhs >= WEAK && u.uhs < WEAK)
 346                         losestr(1);     /* this may kill you -- see below */
 347                 else
 348                 if(newhs < WEAK && u.uhs >= WEAK && u.ustr < u.ustrmax)
 349                         losestr(-1);
 350                 switch(newhs){
 351                 case HUNGRY:
 352                         pline((!incr) ? "You only feel hungry now." :
 353                               (u.uhunger < 145) ? "You feel hungry." :
 354                                 "You are beginning to feel hungry.");
 355                         break;
 356                 case WEAK:
 357                         pline((!incr) ? "You feel weak now." :
 358                               (u.uhunger < 45) ? "You feel weak." :
 359                                 "You are beginning to feel weak.");
 360                         break;
 361                 }
 362                 u.uhs = newhs;
 363                 flags.botl = 1;
 364                 if(u.uhp < 1) {
 365                         pline("You die from hunger and exhaustion.");
 366                         killer = "exhaustion";
 367                         done("starved");
 368                 }
 369         }
 370 }
 371
 372 #define CORPSE_I_TO_C(otyp)     (char) ((otyp >= DEAD_ACID_BLOB)\
 373                      ?  'a' + (otyp - DEAD_ACID_BLOB)\
 374                      :  '@' + (otyp - DEAD_HUMAN))
 375 bool
 376 poisonous(struct obj *otmp)
 377 {
 378         return(index(POISONOUS, CORPSE_I_TO_C(otmp->otyp)) != 0);
 379 }
 380
 381 /* returns 1 if some text was printed */
 382 static int
 383 eatcorpse(struct obj *otmp)
 384 {
 385 char let = CORPSE_I_TO_C(otmp->otyp);
 386 int tp = 0;
 387         if(let != 'a' && moves > otmp->age + 50 + rn2(100)) {
 388                 tp++;
 389                 pline("Ulch -- that meat was tainted!");
 390                 pline("You get very sick.");
 391                 Sick = 10 + rn2(10);
 392                 u.usick_cause = objects[otmp->otyp].oc_name;
 393         } else if(index(POISONOUS, let) && rn2(5)){
 394                 tp++;
 395                 pline("Ecch -- that must have been poisonous!");
 396                 if(!Poison_resistance){
 397                         losestr(rnd(4));
 398                         losehp(rnd(15), "poisonous corpse");
 399                 } else
 400                         pline("You don't seem affected by the poison.");
 401         } else if(index("ELNOPQRUuxz", let) && rn2(5)){
 402                 tp++;
 403                 pline("You feel sick.");
 404                 losehp(rnd(8), "cadaver");
 405         }
 406         switch(let) {
 407         case 'L':
 408         case 'N':
 409         case 't':
 410                 Teleportation |= INTRINSIC;
 411                 break;
 412         case 'W':
 413                 pluslvl();
 414                 break;
 415         case 'n':
 416                 u.uhp = u.uhpmax;
 417                 flags.botl = 1;
 418                 /* fall into next case */
 419         case '@':
 420                 pline("You cannibal! You will be sorry for this!");
 421                 /* not tp++; */
 422                 /* fall into next case */
 423         case 'd':
 424                 Aggravate_monster |= INTRINSIC;
 425                 break;
 426         case 'I':
 427                 if(!Invis) {
 428                         Invis = 50+rn2(100);
 429                         if(!See_invisible)
 430                                 newsym(u.ux, u.uy);
 431                 } else {
 432                         Invis |= INTRINSIC;
 433                         See_invisible |= INTRINSIC;
 434                 }
 435                 /* fall into next case */
 436         case 'y':
 437 #ifdef QUEST
 438                 u.uhorizon++;
 439 #endif /* QUEST */
 440                 /* fall into next case */
 441         case 'B':
 442                 Confusion = 50;
 443                 break;
 444         case 'D':
 445                 Fire_resistance |= INTRINSIC;
 446                 break;
 447         case 'E':
 448                 Telepat |= INTRINSIC;
 449                 break;
 450         case 'F':
 451         case 'Y':
 452                 Cold_resistance |= INTRINSIC;
 453                 break;
 454         case 'k':
 455         case 's':
 456                 Poison_resistance |= INTRINSIC;
 457                 break;
 458         case 'c':
 459                 pline("You turn to stone.");
 460                 killer = "dead cockatrice";
 461                 done("died");
 462                 /* NOTREACHED */
 463         case 'a':
 464           if(Stoned) {
 465               pline("What a pity - you just destroyed a future piece of art!");
 466               tp++;
 467               Stoned = 0;
 468           }
 469           break;
 470         case 'M':
 471           pline("You cannot resist the temptation to mimic a treasure chest.");
 472           tp++;
 473           nomul(-30);
 474           afternmv = Meatdone;
 475           nomovemsg = "You now again prefer mimicking a human.";
 476           u.usym = '$';
 477           prme();
 478           break;
 479         }
 480         return(tp);
 481 }