hack/hack.mkshop.c

   1 /*      $NetBSD: hack.mkshop.c,v 1.8 2003/04/02 18:36:38 jsm Exp $      */
   2
   3 /*
   4  * Copyright (c) 1985, Stichting Centrum voor Wiskunde en Informatica,
   5  * Amsterdam
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions are
  10  * met:
  11  *
  12  * - Redistributions of source code must retain the above copyright notice,
  13  * this list of conditions and the following disclaimer.
  14  *
  15  * - Redistributions in binary form must reproduce the above copyright
  16  * notice, this list of conditions and the following disclaimer in the
  17  * documentation and/or other materials provided with the distribution.
  18  *
  19  * - Neither the name of the Stichting Centrum voor Wiskunde en
  20  * Informatica, nor the names of its contributors may be used to endorse or
  21  * promote products derived from this software without specific prior
  22  * written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  25  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  26  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  27  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  28  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  29  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  30  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  31  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  32  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  33  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  34  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35  */
  36
  37 /*
  38  * Copyright (c) 1982 Jay Fenlason <hack@gnu.org>
  39  * All rights reserved.
  40  *
  41  * Redistribution and use in source and binary forms, with or without
  42  * modification, are permitted provided that the following conditions
  43  * are met:
  44  * 1. Redistributions of source code must retain the above copyright
  45  *    notice, this list of conditions and the following disclaimer.
  46  * 2. Redistributions in binary form must reproduce the above copyright
  47  *    notice, this list of conditions and the following disclaimer in the
  48  *    documentation and/or other materials provided with the distribution.
  49  * 3. The name of the author may not be used to endorse or promote products
  50  *    derived from this software without specific prior written permission.
  51  *
  52  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  53  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  54  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
  55  * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  56  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  57  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  58  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  59  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  60  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  61  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  62  */
  63
  64 #include <sys/cdefs.h>
  65 #ifndef lint
  66 __RCSID("$NetBSD: hack.mkshop.c,v 1.8 2003/04/02 18:36:38 jsm Exp $");
  67 #endif                          /* not lint */
  68
  69 #include <stdlib.h>
  70 #ifndef QUEST
  71 #include "hack.h"
  72 #include "extern.h"
  73 #include "def.mkroom.h"
  74 #include "def.eshk.h"
  75 #define ESHK    ((struct eshk *)(&(shk->mextra[0])))
  76 const schar shprobs[] = {3, 3, 5, 5, 10, 10, 14, 50}; /* their probabilities */
  77
  78 void
  79 mkshop()
  80 {
  81         struct mkroom  *sroom;
  82         int             sh, sx, sy, i = -1;
  83         char            let;
  84         int             roomno;
  85         struct monst   *shk;
  86 #ifdef WIZARD
  87         /* first determine shoptype */
  88         if (wizard) {
  89                 char           *ep = getenv("SHOPTYPE");
  90                 if (ep) {
  91                         if (*ep == 'z' || *ep == 'Z') {
  92                                 mkzoo(ZOO);
  93                                 return;
  94                         }
  95                         if (*ep == 'm' || *ep == 'M') {
  96                                 mkzoo(MORGUE);
  97                                 return;
  98                         }
  99                         if (*ep == 'b' || *ep == 'B') {
 100                                 mkzoo(BEEHIVE);
 101                                 return;
 102                         }
 103                         if (*ep == 's' || *ep == 'S') {
 104                                 mkswamp();
 105                                 return;
 106                         }
 107                         for (i = 0; shtypes[i]; i++)
 108                                 if (*ep == shtypes[i])
 109                                         break;
 110                         goto gottype;
 111                 }
 112         }
 113 gottype:
 114 #endif  /* WIZARD */
 115         for (sroom = &rooms[0], roomno = 0;; sroom++, roomno++) {
 116                 if (sroom->hx < 0)
 117                         return;
 118                 if (sroom - rooms >= nroom) {
 119                         pline("rooms not closed by -1?");
 120                         return;
 121                 }
 122                 if (sroom->rtype)
 123                         continue;
 124                 if (!sroom->rlit || has_dnstairs(sroom) || has_upstairs(sroom))
 125                         continue;
 126                 if (
 127 #ifdef WIZARD
 128                     (wizard && getenv("SHOPTYPE") && sroom->doorct != 0) ||
 129 #endif  /* WIZARD */
 130                     sroom->doorct == 1)
 131                         break;
 132         }
 133
 134         if (i < 0) {            /* shoptype not yet determined */
 135                 int             j;
 136
 137                 for (j = rn2(100), i = 0; (j -= shprobs[i]) >= 0; i++)
 138                         if (!shtypes[i])
 139                                 break;  /* superfluous */
 140                 if (isbig(sroom) && i + SHOPBASE == WANDSHOP)
 141                         i = GENERAL - SHOPBASE;
 142         }
 143         sroom->rtype = i + SHOPBASE;
 144         let = shtypes[i];
 145         sh = sroom->fdoor;
 146         sx = doors[sh].x;
 147         sy = doors[sh].y;
 148         if (sx == sroom->lx - 1)
 149                 sx++;
 150         else if (sx == sroom->hx + 1)
 151                 sx--;
 152         else if (sy == sroom->ly - 1)
 153                 sy++;
 154         else if (sy == sroom->hy + 1)
 155                 sy--;
 156         else {
 157 #ifdef WIZARD
 158                 /* This is said to happen sometimes, but I've never seen it. */
 159                 if (wizard) {
 160                         int             j = sroom->doorct;
 161
 162                         pline("Where is shopdoor?");
 163                         pline("Room at (%d,%d),(%d,%d).", sroom->lx, sroom->ly,
 164                               sroom->hx, sroom->hy);
 165                         pline("doormax=%d doorct=%d fdoor=%d",
 166                               doorindex, sroom->doorct, sh);
 167                         while (j--) {
 168                                 pline("door [%d,%d]", doors[sh].x, doors[sh].y);
 169                                 sh++;
 170                         }
 171                         more();
 172                 }
 173 #endif  /* WIZARD */
 174                 return;
 175         }
 176         if (!(shk = makemon(PM_SHK, sx, sy)))
 177                 return;
 178         shk->isshk = shk->mpeaceful = 1;
 179         shk->msleep = 0;
 180         shk->mtrapseen = ~0;    /* we know all the traps already */
 181         ESHK->shoproom = roomno;
 182         ESHK->shoplevel = dlevel;
 183         ESHK->shd = doors[sh];
 184         ESHK->shk.x = sx;
 185         ESHK->shk.y = sy;
 186         ESHK->robbed = 0;
 187         ESHK->visitct = 0;
 188         ESHK->following = 0;
 189         shk->mgold = 1000 + 30 * rnd(100);      /* initial capital */
 190         ESHK->billct = 0;
 191         findname(ESHK->shknam, let);
 192         for (sx = sroom->lx; sx <= sroom->hx; sx++)
 193                 for (sy = sroom->ly; sy <= sroom->hy; sy++) {
 194                         struct monst   *mtmp;
 195                         if ((sx == sroom->lx && doors[sh].x == sx - 1) ||
 196                             (sx == sroom->hx && doors[sh].x == sx + 1) ||
 197                             (sy == sroom->ly && doors[sh].y == sy - 1) ||
 198                             (sy == sroom->hy && doors[sh].y == sy + 1))
 199                                 continue;
 200                         if (rn2(100) < dlevel && !m_at(sx, sy) &&
 201                             (mtmp = makemon(PM_MIMIC, sx, sy))) {
 202                                 mtmp->mimic = 1;
 203                                 mtmp->mappearance =
 204                                         (let && rn2(10) < dlevel) ? let : ']';
 205                                 continue;
 206                         }
 207                         (void) mkobj_at(let, sx, sy);
 208                 }
 209 }
 210
 211 void
 212 mkzoo(type)
 213         int             type;
 214 {
 215         struct mkroom  *sroom;
 216         struct monst   *mon;
 217         int             sh, sx, sy, i;
 218         int             goldlim = 500 * dlevel;
 219         int             moct = 0;
 220
 221         i = nroom;
 222         for (sroom = &rooms[rn2(nroom)];; sroom++) {
 223                 if (sroom == &rooms[nroom])
 224                         sroom = &rooms[0];
 225                 if (!i-- || sroom->hx < 0)
 226                         return;
 227                 if (sroom->rtype)
 228                         continue;
 229                 if (type == MORGUE && sroom->rlit)
 230                         continue;
 231                 if (has_upstairs(sroom) || (has_dnstairs(sroom) && rn2(3)))
 232                         continue;
 233                 if (sroom->doorct == 1 || !rn2(5))
 234                         break;
 235         }
 236         sroom->rtype = type;
 237         sh = sroom->fdoor;
 238         for (sx = sroom->lx; sx <= sroom->hx; sx++)
 239                 for (sy = sroom->ly; sy <= sroom->hy; sy++) {
 240                         if ((sx == sroom->lx && doors[sh].x == sx - 1) ||
 241                             (sx == sroom->hx && doors[sh].x == sx + 1) ||
 242                             (sy == sroom->ly && doors[sh].y == sy - 1) ||
 243                             (sy == sroom->hy && doors[sh].y == sy + 1))
 244                                 continue;
 245                         mon = makemon(
 246                                       (type == MORGUE) ? morguemon() :
 247                                       (type == BEEHIVE) ? PM_KILLER_BEE : (struct permonst *) 0,
 248                                       sx, sy);
 249                         if (mon)
 250                                 mon->msleep = 1;
 251                         switch (type) {
 252                         case ZOO:
 253                                 i = sq(dist2(sx, sy, doors[sh].x, doors[sh].y));
 254                                 if (i >= goldlim)
 255                                         i = 5 * dlevel;
 256                                 goldlim -= i;
 257                                 mkgold((long) (10 + rn2(i)), sx, sy);
 258                                 break;
 259                         case MORGUE:
 260                                 /*
 261                                  * Usually there is one dead body in the
 262                                  * morgue
 263                                  */
 264                                 if (!moct && rn2(3)) {
 265                                         mksobj_at(CORPSE, sx, sy);
 266                                         moct++;
 267                                 }
 268                                 break;
 269                         case BEEHIVE:
 270                                 if (!rn2(3))
 271                                         mksobj_at(LUMP_OF_ROYAL_JELLY, sx, sy);
 272                                 break;
 273                         }
 274                 }
 275 }
 276
 277 const struct permonst *
 278 morguemon()
 279 {
 280         int             i = rn2(100), hd = rn2(dlevel);
 281
 282         if (hd > 10 && i < 10)
 283                 return (PM_DEMON);
 284         if (hd > 8 && i > 85)
 285                 return (PM_VAMPIRE);
 286         return ((i < 40) ? PM_GHOST : (i < 60) ? PM_WRAITH : PM_ZOMBIE);
 287 }
 288
 289 void
 290 mkswamp()
 291 {                               /* Michiel Huisjes & Fred de Wilde */
 292         struct mkroom  *sroom;
 293         int             sx, sy, i, eelct = 0;
 294
 295         for (i = 0; i < 5; i++) {       /* 5 tries */
 296                 sroom = &rooms[rn2(nroom)];
 297                 if (sroom->hx < 0 || sroom->rtype ||
 298                     has_upstairs(sroom) || has_dnstairs(sroom))
 299                         continue;
 300
 301                 /* satisfied; make a swamp */
 302                 sroom->rtype = SWAMP;
 303                 for (sx = sroom->lx; sx <= sroom->hx; sx++)
 304                         for (sy = sroom->ly; sy <= sroom->hy; sy++)
 305                                 if ((sx + sy) % 2 && !o_at(sx, sy) && !t_at(sx, sy)
 306                                   && !m_at(sx, sy) && !nexttodoor(sx, sy)) {
 307                                         levl[sx][sy].typ = POOL;
 308                                         levl[sx][sy].scrsym = POOL_SYM;
 309                                         if (!eelct || !rn2(4)) {
 310                                                 (void) makemon(PM_EEL, sx, sy);
 311                                                 eelct++;
 312                                         }
 313                                 }
 314         }
 315 }
 316
 317 int
 318 nexttodoor(sx, sy)
 319         int sx, sy;
 320 {
 321         int             dx, dy;
 322         struct rm      *lev;
 323         for (dx = -1; dx <= 1; dx++)
 324                 for (dy = -1; dy <= 1; dy++)
 325                         if ((lev = &levl[sx + dx][sy + dy])->typ == DOOR ||
 326                             lev->typ == SDOOR || lev->typ == LDOOR)
 327                                 return (1);
 328         return (0);
 329 }
 330
 331 int
 332 has_dnstairs(sroom)
 333         struct mkroom  *sroom;
 334 {
 335         return (sroom->lx <= xdnstair && xdnstair <= sroom->hx &&
 336                 sroom->ly <= ydnstair && ydnstair <= sroom->hy);
 337 }
 338
 339 int
 340 has_upstairs(sroom)
 341         struct mkroom  *sroom;
 342 {
 343         return (sroom->lx <= xupstair && xupstair <= sroom->hx &&
 344                 sroom->ly <= yupstair && yupstair <= sroom->hy);
 345 }
 346
 347 int
 348 isbig(sroom)
 349         struct mkroom  *sroom;
 350 {
 351         int             area = (sroom->hx - sroom->lx) * (sroom->hy - sroom->ly);
 352         return (area > 20);
 353 }
 354
 355 int
 356 dist2(x0, y0, x1, y1)
 357         int x0, y0, x1, y1;
 358 {
 359         return ((x0 - x1) * (x0 - x1) + (y0 - y1) * (y0 - y1));
 360 }
 361
 362 int
 363 sq(a)
 364         int             a;
 365 {
 366         return (a * a);
 367 }
 368 #endif  /* QUEST */