/*	$NetBSD: hack.mkshop.c,v 1.11 2011/08/07 06:03:45 dholland 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 <hack@gnu.org>
 * 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.mkshop.c,v 1.11 2011/08/07 06:03:45 dholland Exp $");
#endif				/* not lint */

#include <stdlib.h>
#ifndef QUEST
#include "hack.h"
#include "extern.h"
#include "def.mkroom.h"
#include "def.eshk.h"

#define	ESHK	((struct eshk *)(&(shk->mextra[0])))

/* their probabilities */
static const schar shprobs[] = {3, 3, 5, 5, 10, 10, 14, 50};

static const struct permonst *morguemon(void);
static int nexttodoor(int, int);
static int has_dnstairs(struct mkroom *);
static int has_upstairs(struct mkroom *);
static int isbig(struct mkroom *);
static int dist2(int, int, int, int);
static int sq(int);

void
mkshop(void)
{
	struct mkroom  *sroom;
	int             sh, sx, sy, i = -1;
	char            let;
	int             roomno;
	struct monst   *shk;
#ifdef WIZARD
	/* first determine shoptype */
	if (wizard) {
		char           *ep = getenv("SHOPTYPE");
		if (ep) {
			if (*ep == 'z' || *ep == 'Z') {
				mkzoo(ZOO);
				return;
			}
			if (*ep == 'm' || *ep == 'M') {
				mkzoo(MORGUE);
				return;
			}
			if (*ep == 'b' || *ep == 'B') {
				mkzoo(BEEHIVE);
				return;
			}
			if (*ep == 's' || *ep == 'S') {
				mkswamp();
				return;
			}
			for (i = 0; shtypes[i]; i++)
				if (*ep == shtypes[i])
					break;
			goto gottype;
		}
	}
gottype:
#endif	/* WIZARD */
	for (sroom = &rooms[0], roomno = 0;; sroom++, roomno++) {
		if (sroom->hx < 0)
			return;
		if (sroom - rooms >= nroom) {
			pline("rooms not closed by -1?");
			return;
		}
		if (sroom->rtype)
			continue;
		if (!sroom->rlit || has_dnstairs(sroom) || has_upstairs(sroom))
			continue;
		if (
#ifdef WIZARD
		    (wizard && getenv("SHOPTYPE") && sroom->doorct != 0) ||
#endif	/* WIZARD */
		    sroom->doorct == 1)
			break;
	}

	if (i < 0) {		/* shoptype not yet determined */
		int             j;

		for (j = rn2(100), i = 0; (j -= shprobs[i]) >= 0; i++)
			if (!shtypes[i])
				break;	/* superfluous */
		if (isbig(sroom) && i + SHOPBASE == WANDSHOP)
			i = GENERAL - SHOPBASE;
	}
	sroom->rtype = i + SHOPBASE;
	let = shtypes[i];
	sh = sroom->fdoor;
	sx = doors[sh].x;
	sy = doors[sh].y;
	if (sx == sroom->lx - 1)
		sx++;
	else if (sx == sroom->hx + 1)
		sx--;
	else if (sy == sroom->ly - 1)
		sy++;
	else if (sy == sroom->hy + 1)
		sy--;
	else {
#ifdef WIZARD
		/* This is said to happen sometimes, but I've never seen it. */
		if (wizard) {
			int             j = sroom->doorct;

			pline("Where is shopdoor?");
			pline("Room at (%d,%d),(%d,%d).", sroom->lx, sroom->ly,
			      sroom->hx, sroom->hy);
			pline("doormax=%d doorct=%d fdoor=%d",
			      doorindex, sroom->doorct, sh);
			while (j--) {
				pline("door [%d,%d]", doors[sh].x, doors[sh].y);
				sh++;
			}
			more();
		}
#endif	/* WIZARD */
		return;
	}
	if (!(shk = makemon(PM_SHK, sx, sy)))
		return;
	shk->isshk = shk->mpeaceful = 1;
	shk->msleep = 0;
	shk->mtrapseen = ~0U;	/* we know all the traps already */
	ESHK->shoproom = roomno;
	ESHK->shoplevel = dlevel;
	ESHK->shd = doors[sh];
	ESHK->shk.x = sx;
	ESHK->shk.y = sy;
	ESHK->robbed = 0;
	ESHK->visitct = 0;
	ESHK->following = 0;
	shk->mgold = 1000 + 30 * rnd(100);	/* initial capital */
	ESHK->billct = 0;
	findname(ESHK->shknam, let);
	for (sx = sroom->lx; sx <= sroom->hx; sx++)
		for (sy = sroom->ly; sy <= sroom->hy; sy++) {
			struct monst   *mtmp;
			if ((sx == sroom->lx && doors[sh].x == sx - 1) ||
			    (sx == sroom->hx && doors[sh].x == sx + 1) ||
			    (sy == sroom->ly && doors[sh].y == sy - 1) ||
			    (sy == sroom->hy && doors[sh].y == sy + 1))
				continue;
			if (rn2(100) < dlevel && !m_at(sx, sy) &&
			    (mtmp = makemon(PM_MIMIC, sx, sy))) {
				mtmp->mimic = 1;
				mtmp->mappearance =
					(let && rn2(10) < dlevel) ? let : ']';
				continue;
			}
			(void) mkobj_at(let, sx, sy);
		}
}

void
mkzoo(int type)
{
	struct mkroom  *sroom;
	struct monst   *mon;
	int             sh, sx, sy, i;
	int             goldlim = 500 * dlevel;
	int             moct = 0;

	i = nroom;
	for (sroom = &rooms[rn2(nroom)];; sroom++) {
		if (sroom == &rooms[nroom])
			sroom = &rooms[0];
		if (!i-- || sroom->hx < 0)
			return;
		if (sroom->rtype)
			continue;
		if (type == MORGUE && sroom->rlit)
			continue;
		if (has_upstairs(sroom) || (has_dnstairs(sroom) && rn2(3)))
			continue;
		if (sroom->doorct == 1 || !rn2(5))
			break;
	}
	sroom->rtype = type;
	sh = sroom->fdoor;
	for (sx = sroom->lx; sx <= sroom->hx; sx++)
		for (sy = sroom->ly; sy <= sroom->hy; sy++) {
			if ((sx == sroom->lx && doors[sh].x == sx - 1) ||
			    (sx == sroom->hx && doors[sh].x == sx + 1) ||
			    (sy == sroom->ly && doors[sh].y == sy - 1) ||
			    (sy == sroom->hy && doors[sh].y == sy + 1))
				continue;
			mon = makemon(
				      (type == MORGUE) ? morguemon() :
				      (type == BEEHIVE) ? PM_KILLER_BEE : (struct permonst *) 0,
				      sx, sy);
			if (mon)
				mon->msleep = 1;
			switch (type) {
			case ZOO:
				i = sq(dist2(sx, sy, doors[sh].x, doors[sh].y));
				if (i >= goldlim)
					i = 5 * dlevel;
				goldlim -= i;
				mkgold((long) (10 + rn2(i)), sx, sy);
				break;
			case MORGUE:
				/*
				 * Usually there is one dead body in the
				 * morgue
				 */
				if (!moct && rn2(3)) {
					mksobj_at(CORPSE, sx, sy);
					moct++;
				}
				break;
			case BEEHIVE:
				if (!rn2(3))
					mksobj_at(LUMP_OF_ROYAL_JELLY, sx, sy);
				break;
			}
		}
}

static const struct permonst *
morguemon(void)
{
	int             i = rn2(100), hd = rn2(dlevel);

	if (hd > 10 && i < 10)
		return (PM_DEMON);
	if (hd > 8 && i > 85)
		return (PM_VAMPIRE);
	return ((i < 40) ? PM_GHOST : (i < 60) ? PM_WRAITH : PM_ZOMBIE);
}

void
mkswamp(void)
{				/* Michiel Huisjes & Fred de Wilde */
	struct mkroom  *sroom;
	int             sx, sy, i, eelct = 0;

	for (i = 0; i < 5; i++) {	/* 5 tries */
		sroom = &rooms[rn2(nroom)];
		if (sroom->hx < 0 || sroom->rtype ||
		    has_upstairs(sroom) || has_dnstairs(sroom))
			continue;

		/* satisfied; make a swamp */
		sroom->rtype = SWAMP;
		for (sx = sroom->lx; sx <= sroom->hx; sx++)
			for (sy = sroom->ly; sy <= sroom->hy; sy++)
				if ((sx + sy) % 2 && !o_at(sx, sy) && !t_at(sx, sy)
				  && !m_at(sx, sy) && !nexttodoor(sx, sy)) {
					levl[sx][sy].typ = POOL;
					levl[sx][sy].scrsym = POOL_SYM;
					if (!eelct || !rn2(4)) {
						(void) makemon(PM_EEL, sx, sy);
						eelct++;
					}
				}
	}
}

static int
nexttodoor(int sx, int sy)
{
	int		dx, dy;
	struct rm      *lev;
	for (dx = -1; dx <= 1; dx++)
		for (dy = -1; dy <= 1; dy++)
			if ((lev = &levl[sx + dx][sy + dy])->typ == DOOR ||
			    lev->typ == SDOOR || lev->typ == LDOOR)
				return (1);
	return (0);
}

static int
has_dnstairs(struct mkroom *sroom)
{
	return (sroom->lx <= xdnstair && xdnstair <= sroom->hx &&
		sroom->ly <= ydnstair && ydnstair <= sroom->hy);
}

static int
has_upstairs(struct mkroom *sroom)
{
	return (sroom->lx <= xupstair && xupstair <= sroom->hx &&
		sroom->ly <= yupstair && yupstair <= sroom->hy);
}

static int
isbig(struct mkroom *sroom)
{
	int             area = (sroom->hx - sroom->lx) * (sroom->hy - sroom->ly);
	return (area > 20);
}

static int
dist2(int x0, int y0, int x1, int y1)
{
	return ((x0 - x1) * (x0 - x1) + (y0 - y1) * (y0 - y1));
}

static int
sq(int a)
{
	return (a * a);
}
#endif	/* QUEST */