/*      $NetBSD: hack.zap.c,v 1.10 2021/05/02 12:50:44 rillig Exp $     */

/*
* Copyright (c) 1985, Stichting Centrum voor Wiskunde en Informatica,
* Amsterdam
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* - Neither the name of the Stichting Centrum voor Wiskunde en
* Informatica, nor the names of its contributors may be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

/*
* Copyright (c) 1982 Jay Fenlason <[email protected]>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
*    derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
* THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include <sys/cdefs.h>
#ifndef lint
__RCSID("$NetBSD: hack.zap.c,v 1.10 2021/05/02 12:50:44 rillig Exp $");
#endif                          /* not lint */

#include "hack.h"
#include "extern.h"

static const char *const fl[] = {
       "magic missile",
       "bolt of fire",
       "sleep ray",
       "bolt of cold",
       "death ray"
};

static void bhitm(struct monst *, struct obj *);
static int bhito(struct obj *, struct obj *);
static char dirlet(int, int);
static int zhit(struct monst *, int);
static int revive(struct obj *);
static void rloco(struct obj *);
static void burn_scrolls(void);

/* Routines for IMMEDIATE wands. */
/* bhitm: monster mtmp was hit by the effect of wand otmp */
static void
bhitm(struct monst *mtmp, struct obj *otmp)
{
       wakeup(mtmp);
       switch (otmp->otyp) {
       case WAN_STRIKING:
               if (u.uswallow || rnd(20) < 10 + mtmp->data->ac) {
                       int             tmp = d(2, 12);
                       hit("wand", mtmp, exclam(tmp));
                       mtmp->mhp -= tmp;
                       if (mtmp->mhp < 1)
                               killed(mtmp);
               } else
                       miss("wand", mtmp);
               break;
       case WAN_SLOW_MONSTER:
               mtmp->mspeed = MSLOW;
               break;
       case WAN_SPEED_MONSTER:
               mtmp->mspeed = MFAST;
               break;
       case WAN_UNDEAD_TURNING:
               if (strchr(UNDEAD, mtmp->data->mlet)) {
                       mtmp->mhp -= rnd(8);
                       if (mtmp->mhp < 1)
                               killed(mtmp);
                       else
                               mtmp->mflee = 1;
               }
               break;
       case WAN_POLYMORPH:
               if (newcham(mtmp, &mons[rn2(CMNUM)]))
                       objects[otmp->otyp].oc_name_known = 1;
               break;
       case WAN_CANCELLATION:
               mtmp->mcan = 1;
               break;
       case WAN_TELEPORTATION:
               rloc(mtmp);
               break;
       case WAN_MAKE_INVISIBLE:
               mtmp->minvis = 1;
               break;
#ifdef WAN_PROBING
       case WAN_PROBING:
               mstatusline(mtmp);
               break;
#endif  /* WAN_PROBING */
       default:
               impossible("What an interesting wand (%u)", otmp->otyp);
       }
}

/*
* object obj was hit by the effect of wand otmp
* returns TRUE if sth was done
*/
static int
bhito(struct obj *obj, struct obj *otmp)
{
       int             res = TRUE;

       if (obj == uball || obj == uchain)
               res = FALSE;
       else
               switch (otmp->otyp) {
               case WAN_POLYMORPH:
                       /*
                        * preserve symbol and quantity, but turn rocks into
                        * gems
                        */
                       mkobj_at((obj->otyp == ROCK || obj->otyp == ENORMOUS_ROCK)
                                ? GEM_SYM : obj->olet,
                                obj->ox, obj->oy)->quan = obj->quan;
                       delobj(obj);
                       break;
               case WAN_STRIKING:
                       if (obj->otyp == ENORMOUS_ROCK)
                               fracture_rock(obj);
                       else
                               res = FALSE;
                       break;
               case WAN_CANCELLATION:
                       if (obj->spe && obj->olet != AMULET_SYM) {
                               obj->known = 0;
                               obj->spe = 0;
                       }
                       break;
               case WAN_TELEPORTATION:
                       rloco(obj);
                       break;
               case WAN_MAKE_INVISIBLE:
                       obj->oinvis = 1;
                       break;
               case WAN_UNDEAD_TURNING:
                       res = revive(obj);
                       break;
               case WAN_SLOW_MONSTER:  /* no effect on objects */
               case WAN_SPEED_MONSTER:
#ifdef WAN_PROBING
               case WAN_PROBING:
#endif  /* WAN_PROBING */
                       res = FALSE;
                       break;
               default:
                       impossible("What an interesting wand (%u)", otmp->otyp);
               }
       return (res);
}

int
dozap(void)
{
       struct obj     *obj;
       xchar           zx, zy;

       obj = getobj("/", "zap");
       if (!obj)
               return (0);
       if (obj->spe < 0 || (obj->spe == 0 && rn2(121))) {
               pline("Nothing Happens.");
               return (1);
       }
       if (obj->spe == 0)
               pline("You wrest one more spell from the worn-out wand.");
       if (!(objects[obj->otyp].bits & NODIR) && !getdir(1))
               return (1);     /* make him pay for knowing !NODIR */
       obj->spe--;
       if (objects[obj->otyp].bits & IMMEDIATE) {
               if (u.uswallow)
                       bhitm(u.ustuck, obj);
               else if (u.dz) {
                       if (u.dz > 0) {
                               struct obj     *otmp = o_at(u.ux, u.uy);
                               if (otmp)
                                       (void) bhito(otmp, obj);
                       }
               } else
                       (void) bhit(u.dx, u.dy, rn1(8, 6), 0, bhitm, bhito, obj);
       } else {
               switch (obj->otyp) {
               case WAN_LIGHT:
                       litroom(TRUE);
                       break;
               case WAN_SECRET_DOOR_DETECTION:
                       if (!findit())
                               return (1);
                       break;
               case WAN_CREATE_MONSTER:
                       {
                               int             cnt = 1;
                               if (!rn2(23))
                                       cnt += rn2(7) + 1;
                               while (cnt--)
                                       (void) makemon((struct permonst *) 0, u.ux, u.uy);
                       }
                       break;
               case WAN_WISHING:
                       {
                               char            buf[BUFSZ];
                               struct obj     *otmp;
                               if (u.uluck + rn2(5) < 0) {
                                       pline("Unfortunately, nothing happens.");
                                       break;
                               }
                               pline("You may wish for an object. What do you want? ");
                               getlin(buf);
                               if (buf[0] == '\033')
                                       buf[0] = 0;
                               otmp = readobjnam(buf);
                               otmp = addinv(otmp);
                               prinv(otmp);
                               break;
                       }
               case WAN_DIGGING:
                       /*
                        * Original effect (approximately): from CORR: dig
                        * until we pierce a wall from ROOM: piece wall and
                        * dig until we reach an ACCESSIBLE place. Currently:
                        * dig for digdepth positions; also down on request
                        * of Lennart Augustsson.
                        */
                       {
                               struct rm      *room;
                               int             digdepth;
                               if (u.uswallow) {
                                       struct monst   *mtmp = u.ustuck;

                                       pline("You pierce %s's stomach wall!",
                                             monnam(mtmp));
                                       mtmp->mhp = 1;  /* almost dead */
                                       unstuck(mtmp);
                                       mnexto(mtmp);
                                       break;
                               }
                               if (u.dz) {
                                       if (u.dz < 0) {
                                               pline("You loosen a rock from the ceiling.");
                                               pline("It falls on your head!");
                                               losehp(1, "falling rock");
                                               mksobj_at(ROCK, u.ux, u.uy);
                                               fobj->quan = 1;
                                               stackobj(fobj);
                                               if (Invisible)
                                                       newsym(u.ux, u.uy);
                                       } else {
                                               dighole();
                                       }
                                       break;
                               }
                               zx = u.ux + u.dx;
                               zy = u.uy + u.dy;
                               digdepth = 8 + rn2(18);
                               Tmp_at(-1, '*');        /* open call */
                               while (--digdepth >= 0) {
                                       if (!isok(zx, zy))
                                               break;
                                       room = &levl[zx][zy];
                                       Tmp_at(zx, zy);
                                       if (!xdnstair) {
                                               if (zx < 3 || zx > COLNO - 3 ||
                                                   zy < 3 || zy > ROWNO - 3)
                                                       break;
                                               if (room->typ == HWALL ||
                                                   room->typ == VWALL) {
                                                       room->typ = ROOM;
                                                       break;
                                               }
                                       } else if (room->typ == HWALL || room->typ == VWALL ||
                                                  room->typ == SDOOR || room->typ == LDOOR) {
                                               room->typ = DOOR;
                                               digdepth -= 2;
                                       } else if (room->typ == SCORR || !room->typ) {
                                               room->typ = CORR;
                                               digdepth--;
                                       }
                                       mnewsym(zx, zy);
                                       zx += u.dx;
                                       zy += u.dy;
                               }
                               mnewsym(zx, zy);        /* not always necessary */
                               Tmp_at(-1, -1); /* closing call */
                               break;
                       }
               default:
                       buzz((int) obj->otyp - WAN_MAGIC_MISSILE,
                            u.ux, u.uy, u.dx, u.dy);
                       break;
               }
               if (!objects[obj->otyp].oc_name_known) {
                       objects[obj->otyp].oc_name_known = 1;
                       more_experienced(0, 10);
               }
       }
       return (1);
}

const char           *
exclam(int force)
{
       /* force == 0 occurs e.g. with sleep ray */
       /*
        * note that large force is usual with wands so that !! would require
        * information about hand/weapon/wand
        */
       return ((force < 0) ? "?" : (force <= 4) ? "." : "!");
}

void
hit(const char *str, struct monst *mtmp, const char *force)
{
       /* force is usually either "." or "!" */

       if (!cansee(mtmp->mx, mtmp->my))
               pline("The %s hits it.", str);
       else
               pline("The %s hits %s%s", str, monnam(mtmp), force);
}

void
miss(const char *str, struct monst *mtmp)
{
       if (!cansee(mtmp->mx, mtmp->my))
               pline("The %s misses it.", str);
       else
               pline("The %s misses %s.", str, monnam(mtmp));
}

/*
* bhit: called when a weapon is thrown (sym = obj->olet) or when an
* IMMEDIATE wand is zapped (sym = 0); the weapon falls down at end of range
* or when a monster is hit; the monster is returned, and bhitpos is set to
* the final position of the weapon thrown; the ray of a wand may affect
* several objects and monsters on its path - for each of these an argument
* function is called.
*/
/* check !u.uswallow before calling bhit() */

struct monst   *
bhit(int ddx, int ddy, int range,       /* direction and range */
    int sym,                           /* symbol displayed on path */
                                       /* fns called when mon/obj hit */
    void (*fhitm)(struct monst *, struct obj *),
    int (*fhito)(struct obj *, struct obj *),
    struct obj *obj)                   /* 2nd arg to fhitm/fhito */
{
       struct monst   *mtmp;
       struct obj     *otmp;
       int             typ;

       bhitpos.x = u.ux;
       bhitpos.y = u.uy;

       if (sym)
               tmp_at(-1, sym);/* open call */
       while (range-- > 0) {
               bhitpos.x += ddx;
               bhitpos.y += ddy;
               typ = levl[bhitpos.x][bhitpos.y].typ;
               if ((mtmp = m_at(bhitpos.x, bhitpos.y)) != NULL) {
                       if (sym) {
                               tmp_at(-1, -1); /* close call */
                               return (mtmp);
                       }
                       (*fhitm) (mtmp, obj);
                       range -= 3;
               }
               if (fhito && (otmp = o_at(bhitpos.x, bhitpos.y))) {
                       if ((*fhito) (otmp, obj))
                               range--;
               }
               if (!ZAP_POS(typ)) {
                       bhitpos.x -= ddx;
                       bhitpos.y -= ddy;
                       break;
               }
               if (sym)
                       tmp_at(bhitpos.x, bhitpos.y);
       }

       /* leave last symbol unless in a pool */
       if (sym)
               tmp_at(-1, (levl[bhitpos.x][bhitpos.y].typ == POOL) ? -1 : 0);
       return (0);
}

struct monst   *
boomhit(int dx, int dy)
{
       int             i, ct;
       struct monst   *mtmp;
       char            sym = ')';

       bhitpos.x = u.ux;
       bhitpos.y = u.uy;

       for (i = 0; i < 8; i++)
               if (xdir[i] == dx && ydir[i] == dy)
                       break;
       tmp_at(-1, sym);        /* open call */
       for (ct = 0; ct < 10; ct++) {
               if (i == 8)
                       i = 0;
               sym = ')' + '(' - sym;
               tmp_at(-2, sym);/* change let call */
               dx = xdir[i];
               dy = ydir[i];
               bhitpos.x += dx;
               bhitpos.y += dy;
               if ((mtmp = m_at(bhitpos.x, bhitpos.y)) != NULL) {
                       tmp_at(-1, -1);
                       return (mtmp);
               }
               if (!ZAP_POS(levl[bhitpos.x][bhitpos.y].typ)) {
                       bhitpos.x -= dx;
                       bhitpos.y -= dy;
                       break;
               }
               if (bhitpos.x == u.ux && bhitpos.y == u.uy) {   /* ct == 9 */
                       if (rn2(20) >= 10 + u.ulevel) { /* we hit ourselves */
                               (void) thitu(10, rnd(10), "boomerang");
                               break;
                       } else {/* we catch it */
                               tmp_at(-1, -1);
                               pline("Skillfully, you catch the boomerang.");
                               return (&youmonst);
                       }
               }
               tmp_at(bhitpos.x, bhitpos.y);
               if (ct % 5 != 0)
                       i++;
       }
       tmp_at(-1, -1);         /* do not leave last symbol */
       return (0);
}

static char
dirlet(int dx, int dy)
{
       return
               (dx == dy) ? '\\' : (dx && dy) ? '/' : dx ? '-' : '|';
}

/* type == -1: monster spitting fire at you */
/* type == -1,-2,-3: bolts sent out by wizard */
/* called with dx = dy = 0 with vertical bolts */
void
buzz(int type, xchar sx, xchar sy, int dx, int dy)
{
       int             abstype = abs(type);
       const char     *fltxt = (type == -1) ? "blaze of fire" : fl[abstype];
       struct rm      *lev;
       xchar           range;
       struct monst   *mon;

       if (u.uswallow) {
               int             tmp;

               if (type < 0)
                       return;
               tmp = zhit(u.ustuck, type);
               pline("The %s rips into %s%s",
                     fltxt, monnam(u.ustuck), exclam(tmp));
               return;
       }
       if (type < 0)
               pru();
       range = rn1(7, 7);
       Tmp_at(-1, dirlet(dx, dy));     /* open call */
       while (range-- > 0) {
               sx += dx;
               sy += dy;
               if ((lev = &levl[sx][sy])->typ)
                       Tmp_at(sx, sy);
               else {
                       int             bounce = 0;
                       if (cansee(sx - dx, sy - dy))
                               pline("The %s bounces!", fltxt);
                       if (ZAP_POS(levl[sx][sy - dy].typ))
                               bounce = 1;
                       if (ZAP_POS(levl[sx - dx][sy].typ)) {
                               if (!bounce || rn2(2))
                                       bounce = 2;
                       }
                       switch (bounce) {
                       case 0:
                               dx = -dx;
                               dy = -dy;
                               continue;
                       case 1:
                               dy = -dy;
                               sx -= dx;
                               break;
                       case 2:
                               dx = -dx;
                               sy -= dy;
                               break;
                       }
                       Tmp_at(-2, dirlet(dx, dy));
                       continue;
               }
               if (lev->typ == POOL && abstype == 1 /* fire */ ) {
                       range -= 3;
                       lev->typ = ROOM;
                       if (cansee(sx, sy)) {
                               mnewsym(sx, sy);
                               pline("The water evaporates.");
                       } else
                               pline("You hear a hissing sound.");
               }
               if ((mon = m_at(sx, sy)) &&
                   (type != -1 || mon->data->mlet != 'D')) {
                       wakeup(mon);
                       if (rnd(20) < 18 + mon->data->ac) {
                               int             tmp = zhit(mon, abstype);
                               if (mon->mhp < 1) {
                                       if (type < 0) {
                                               if (cansee(mon->mx, mon->my))
                                                       pline("%s is killed by the %s!",
                                                       Monnam(mon), fltxt);
                                               mondied(mon);
                                       } else
                                               killed(mon);
                               } else
                                       hit(fltxt, mon, exclam(tmp));
                               range -= 2;
                       } else
                               miss(fltxt, mon);
               } else if (sx == u.ux && sy == u.uy) {
                       nomul(0);
                       if (rnd(20) < 18 + u.uac) {
                               int             dam = 0;
                               range -= 2;
                               pline("The %s hits you!", fltxt);
                               switch (abstype) {
                               case 0:
                                       dam = d(2, 6);
                                       break;
                               case 1:
                                       if (Fire_resistance)
                                               pline("You don't feel hot!");
                                       else
                                               dam = d(6, 6);
                                       if (!rn2(3))
                                               burn_scrolls();
                                       break;
                               case 2:
                                       nomul(-rnd(25));        /* sleep ray */
                                       break;
                               case 3:
                                       if (Cold_resistance)
                                               pline("You don't feel cold!");
                                       else
                                               dam = d(6, 6);
                                       break;
                               case 4:
                                       u.uhp = -1;
                               }
                               losehp(dam, fltxt);
                       } else
                               pline("The %s whizzes by you!", fltxt);
                       stop_occupation();
               }
               if (!ZAP_POS(lev->typ)) {
                       int             bounce = 0, rmn;
                       if (cansee(sx, sy))
                               pline("The %s bounces!", fltxt);
                       range--;
                       if (!dx || !dy || !rn2(20)) {
                               dx = -dx;
                               dy = -dy;
                       } else {
                               if (ZAP_POS(rmn = levl[sx][sy - dy].typ) &&
                                   (IS_ROOM(rmn) || ZAP_POS(levl[sx + dx][sy - dy].typ)))
                                       bounce = 1;
                               if (ZAP_POS(rmn = levl[sx - dx][sy].typ) &&
                                   (IS_ROOM(rmn) || ZAP_POS(levl[sx - dx][sy + dy].typ)))
                                       if (!bounce || rn2(2))
                                               bounce = 2;

                               switch (bounce) {
                               case 0:
                                       dy = -dy;
                                       dx = -dx;
                                       break;
                               case 1:
                                       dy = -dy;
                                       break;
                               case 2:
                                       dx = -dx;
                                       break;
                               }
                               Tmp_at(-2, dirlet(dx, dy));
                       }
               }
       }
       Tmp_at(-1, -1);
}

static int
zhit(struct monst *mon, int type)               /* returns damage to mon */
{
       int             tmp = 0;

       switch (type) {
       case 0:         /* magic missile */
               tmp = d(2, 6);
               break;
       case -1:                /* Dragon blazing fire */
       case 1:         /* fire */
               if (strchr("Dg", mon->data->mlet))
                       break;
               tmp = d(6, 6);
               if (strchr("YF", mon->data->mlet))
                       tmp += 7;
               break;
       case 2:         /* sleep */
               mon->mfroz = 1;
               break;
       case 3:         /* cold */
               if (strchr("YFgf", mon->data->mlet))
                       break;
               tmp = d(6, 6);
               if (mon->data->mlet == 'D')
                       tmp += 7;
               break;
       case 4:         /* death */
               if (strchr(UNDEAD, mon->data->mlet))
                       break;
               tmp = mon->mhp + 1;
               break;
       }
       mon->mhp -= tmp;
       return (tmp);
}

#define CORPSE_I_TO_C(otyp)     (char) ((otyp >= DEAD_ACID_BLOB)\
                    ?  'a' + (otyp - DEAD_ACID_BLOB)\
                    :  '@' + (otyp - DEAD_HUMAN))
static int
revive(struct obj *obj)
{
       struct monst   *mtmp = NULL;

       if (obj->olet == FOOD_SYM && obj->otyp > CORPSE) {
               /* do not (yet) revive shopkeepers */
               /*
                * Note: this might conceivably produce two monsters at the
                * same position - strange, but harmless
                */
               mtmp = mkmon_at(CORPSE_I_TO_C(obj->otyp), obj->ox, obj->oy);
               delobj(obj);
       }
       return (!!mtmp);        /* TRUE if some monster created */
}

static void
rloco(struct obj *obj)
{
       int tx, ty, otx, oty;

       otx = obj->ox;
       oty = obj->oy;
       do {
               tx = rn1(COLNO - 3, 2);
               ty = rn2(ROWNO);
       } while (!goodpos(tx, ty));
       obj->ox = tx;
       obj->oy = ty;
       if (cansee(otx, oty))
               newsym(otx, oty);
}

/* fractured by pick-axe or wand of striking */
/* no texts here! */
void
fracture_rock(struct obj *obj)
{
       /* unpobj(obj); */
       obj->otyp = ROCK;
       obj->quan = 7 + rn2(60);
       obj->owt = weight(obj);
       obj->olet = WEAPON_SYM;
       if (cansee(obj->ox, obj->oy))
               prl(obj->ox, obj->oy);
}

static void
burn_scrolls(void)
{
       struct obj     *obj, *obj2;
       int             cnt = 0;

       for (obj = invent; obj; obj = obj2) {
               obj2 = obj->nobj;
               if (obj->olet == SCROLL_SYM) {
                       cnt++;
                       useup(obj);
               }
       }
       if (cnt > 1) {
               pline("Your scrolls catch fire!");
               losehp(cnt, "burning scrolls");
       } else if (cnt) {
               pline("Your scroll catches fire!");
               losehp(1, "burning scroll");
       }
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.