xref: /src/games/phantasia/misc.c

/*	$NetBSD: misc.c,v 1.2 1995/03/24 03:59:03 cgd Exp $	*/

/*
 * misc.c  Phantasia miscellaneous support routines
 */

#include "include.h"


/************************************************************************
/
/ FUNCTION NAME: movelevel()
/
/ FUNCTION: move player to new level
/
/ AUTHOR: E. A. Estes, 12/4/85
/
/ ARGUMENTS: none
/
/ RETURN VALUE: none
/
/ MODULES CALLED: death(), floor(), wmove(), drandom(), waddstr(), explevel()
/
/ GLOBAL INPUTS: Player, *stdscr, *Statptr, Stattable[]
/
/ GLOBAL OUTPUTS: Player, Changed
/
/ DESCRIPTION:
/	Use lookup table to increment important statistics when
/	progressing to new experience level.
/	Players are rested to maximum as a bonus for making a new
/	level.
/	Check for council of wise, and being too big to be king.
/
/************************************************************************/

movelevel()
{
register struct charstats	*statptr;	/* for pointing into Stattable */
double	new;			/* new level */
double	inc;			/* increment between new and old levels */

    Changed = TRUE;

    if (Player.p_type == C_EXPER)
	/* roll a type to use for increment */
	statptr = &Stattable[(int) ROLL(C_MAGIC, C_HALFLING - C_MAGIC + 1)];
    else
	statptr = Statptr;

    new = explevel(Player.p_experience);
    inc = new - Player.p_level;
    Player.p_level = new;

    /* add increments to statistics */
    Player.p_strength += statptr->c_strength.increase * inc;
    Player.p_mana += statptr->c_mana.increase * inc;
    Player.p_brains += statptr->c_brains.increase * inc;
    Player.p_magiclvl += statptr->c_magiclvl.increase * inc;
    Player.p_maxenergy += statptr->c_energy.increase * inc;

    /* rest to maximum upon reaching new level */
    Player.p_energy = Player.p_maxenergy + Player.p_shield;

    if (Player.p_crowns > 0 && Player.p_level >= 1000.0)
	/* no longer able to be king -- turn crowns into cash */
	{
	Player.p_gold += ((double) Player.p_crowns) * 5000.0;
	Player.p_crowns = 0;
	}

    if (Player.p_level >= 3000.0 && Player.p_specialtype < SC_COUNCIL)
	/* make a member of the council */
	{
	mvaddstr(6, 0, "You have made it to the Council of the Wise.\n");
	addstr("Good Luck on your search for the Holy Grail.\n");

	Player.p_specialtype = SC_COUNCIL;

	/* no rings for council and above */
	Player.p_ring.ring_type = R_NONE;
	Player.p_ring.ring_duration = 0;

	Player.p_lives = 3;		/* three extra lives */
	}

    if (Player.p_level > 9999.0 && Player.p_specialtype != SC_VALAR)
	death("Old age");
}
/**/
/************************************************************************
/
/ FUNCTION NAME: descrlocation()
/
/ FUNCTION: return a formatted description of location
/
/ AUTHOR: E. A. Estes, 12/4/85
/
/ ARGUMENTS:
/	struct player playerp - pointer to player structure
/	bool shortflag - set if short form is desired
/
/ RETURN VALUE: pointer to string containing result
/
/ MODULES CALLED: fabs(), floor(), sprintf(), distance()
/
/ GLOBAL INPUTS: Databuf[]
/
/ GLOBAL OUTPUTS: none
/
/ DESCRIPTION:
/	Look at coordinates and return an appropriately formatted
/	string.
/
/************************************************************************/

char	*
descrlocation(playerp, shortflag)
struct player	*playerp;
bool	shortflag;
{
double	circle;			/* corresponding circle for coordinates */
register int	quadrant;	/* quandrant of grid */
register char	*label;		/* pointer to place name */
static char	*nametable[4][4] =   /* names of places */
	{
	"Anorien",	"Ithilien",	"Rohan",	"Lorien",
	"Gondor",	"Mordor",	"Dunland",	"Rovanion",
	"South Gondor", "Khand",	"Eriador",	"The Iron Hills",
	"Far Harad",	"Near Harad",	"The Northern Waste", "Rhun"
	};

    if (playerp->p_specialtype == SC_VALAR)
	return(" is in Valhala");
    else if ((circle = CIRCLE(playerp->p_x, playerp->p_y)) >= 1000.0)
	{
	if (MAX(fabs(playerp->p_x), fabs(playerp->p_y)) > D_BEYOND)
	    label = "The Point of No Return";
	else
	    label = "The Ashen Mountains";
	}
    else if (circle >= 55)
	label = "Morannon";
    else if (circle >= 35)
	label = "Kennaquahair";
    else if (circle >= 20)
	label = "The Dead Marshes";
    else if (circle >= 9)
	label = "The Outer Waste";
    else if (circle >= 5)
	label = "The Moors Adventurous";
    else
	{
	if (playerp->p_x == 0.0 && playerp->p_y == 0.0)
	    label = "The Lord's Chamber";
	else
	    {
	    /* this expression is split to prevent compiler loop with some compilers */
	    quadrant = ((playerp->p_x > 0.0) ? 1 : 0);
	    quadrant += ((playerp->p_y >= 0.0) ? 2 : 0);
	    label = nametable[((int) circle) - 1][quadrant];
	    }
	}

    if (shortflag)
	sprintf(Databuf, "%.29s", label);
    else
	sprintf(Databuf, " is in %s  (%.0f,%.0f)", label, playerp->p_x, playerp->p_y);

    return(Databuf);
}
/**/
/************************************************************************
/
/ FUNCTION NAME: tradingpost()
/
/ FUNCTION: do trading post stuff
/
/ AUTHOR: E. A. Estes, 12/4/85
/
/ ARGUMENTS: none
/
/ RETURN VALUE: none
/
/ MODULES CALLED: writerecord(), adjuststats(), fabs(), more(), sqrt(),
/	sleep(), floor(), wmove(), drandom(), wclear(), printw(),
/	altercoordinates(), infloat(), waddstr(), wrefresh(), mvprintw(), getanswer(),
/	wclrtoeol(), wclrtobot()
/
/ GLOBAL INPUTS: Menu[], Circle, Player, *stdscr, Fileloc, Nobetter[]
/
/ GLOBAL OUTPUTS: Player
/
/ DESCRIPTION:
/	Different trading posts have different items.
/	Merchants cannot be cheated, but they can be dishonest
/	themselves.
/
/	Shields, swords, and quicksilver are not cumulative.  This is
/	one major area of complaint, but there are two reasons for this:
/		1) It becomes MUCH too easy to make very large versions
/		   of these items.
/		2) In the real world, one cannot simply weld two swords
/		   together to make a bigger one.
/
/	At one time, it was possible to sell old weapons at half the purchase
/	price.  This resulted in huge amounts of gold floating around,
/	and the game lost much of its challenge.
/
/	Also, purchasing gems defeats the whole purpose of gold.  Gold
/	is small change for lower level players.  They really shouldn't
/	be able to accumulate more than enough gold for a small sword or
/	a few books.  Higher level players shouldn't even bother to pick
/	up gold, except maybe to buy mana once in a while.
/
/************************************************************************/

tradingpost()
{
double	numitems;	/* number of items to purchase */
double	cost;		/* cost of purchase */
double	blessingcost;	/* cost of blessing */
int	ch;		/* input */
register int	size;	/* size of the trading post */
register int	loop;	/* loop counter */
int	cheat = 0;	/* number of times player has tried to cheat */
bool	dishonest = FALSE;/* set when merchant is dishonest */

    Player.p_status = S_TRADING;
    writerecord(&Player, Fileloc);

    clear();
    addstr("You are at a trading post. All purchases must be made with gold.");

    size = sqrt(fabs(Player.p_x / 100)) + 1;
    size = MIN(7, size);

    /* set up cost of blessing */
    blessingcost = 1000.0 * (Player.p_level + 5.0);

    /* print Menu */
    move(7, 0);
    for (loop = 0; loop < size; ++loop)
	/* print Menu */
	{
	if (loop == 6)
	    cost = blessingcost;
	else
	    cost = Menu[loop].cost;
	printw("(%d) %-12s: %6.0f\n", loop + 1, Menu[loop].item, cost);
	}

    mvprintw(5, 0, "L:Leave  P:Purchase  S:Sell Gems ? ");

    for (;;)
	{
	adjuststats();	/* truncate any bad values */

	/* print some important statistics */
	mvprintw(1, 0, "Gold:   %9.0f  Gems:  %9.0f  Level:   %6.0f  Charms: %6d\n",
	    Player.p_gold, Player.p_gems, Player.p_level, Player.p_charms);
	printw("Shield: %9.0f  Sword: %9.0f  Quicksilver:%3.0f  Blessed: %s\n",
	    Player.p_shield, Player.p_sword, Player.p_quksilver,
	    (Player.p_blessing ? " True" : "False"));
	printw("Brains: %9.0f  Mana:  %9.0f", Player.p_brains, Player.p_mana);

	move(5, 36);
	ch = getanswer("LPS", FALSE);
	move(15, 0);
	clrtobot();
	switch(ch)
	    {
	    case 'L':		/* leave */
	    case '\n':
		altercoordinates(0.0, 0.0, A_NEAR);
		return;

	    case 'P':		/* make purchase */
		mvaddstr(15, 0, "What what would you like to buy ? ");
		ch = getanswer(" 1234567", FALSE);
		move(15, 0);
		clrtoeol();

		if (ch - '0' > size)
		    addstr("Sorry, this merchant doesn't have that.");
		else
		    switch (ch)
			{
			case '1':
			    printw("Mana is one per %.0f gold piece.  How many do you want (%.0f max) ? ",
				Menu[0].cost, floor(Player.p_gold / Menu[0].cost));
			    cost = (numitems = floor(infloat())) * Menu[0].cost;

			    if (cost > Player.p_gold || numitems < 0)
				++cheat;
			    else
				{
				cheat = 0;
				Player.p_gold -= cost;
				if (drandom() < 0.02)
				    dishonest = TRUE;
				else
				    Player.p_mana += numitems;
				}
			    break;

			case '2':
			    printw("Shields are %.0f per +1.  How many do you want (%.0f max) ? ",
				Menu[1].cost, floor(Player.p_gold / Menu[1].cost));
			    cost = (numitems = floor(infloat())) * Menu[1].cost;

			    if (numitems == 0.0)
				break;
			    else if (cost > Player.p_gold || numitems < 0)
				++cheat;
			    else if (numitems < Player.p_shield)
				NOBETTER();
			    else
				{
				cheat = 0;
				Player.p_gold -= cost;
				if (drandom() < 0.02)
				    dishonest = TRUE;
				else
				    Player.p_shield = numitems;
				}
			    break;

			case '3':
			    printw("A book costs %.0f gp.  How many do you want (%.0f max) ? ",
				Menu[2].cost, floor(Player.p_gold / Menu[2].cost));
			    cost = (numitems = floor(infloat())) * Menu[2].cost;

			    if (cost > Player.p_gold || numitems < 0)
				++cheat;
			    else
				{
				cheat = 0;
				Player.p_gold -= cost;
				if (drandom() < 0.02)
				    dishonest = TRUE;
				else if (drandom() * numitems > Player.p_level / 10.0
				    && numitems != 1)
				    {
				    printw("\nYou blew your mind!\n");
				    Player.p_brains /= 5;
				    }
				else
				    {
				    Player.p_brains += floor(numitems) * ROLL(20, 8);
				    }
				}
			    break;

			case '4':
			    printw("Swords are %.0f gp per +1.  How many + do you want (%.0f max) ? ",
				Menu[3].cost, floor(Player.p_gold / Menu[3].cost));
			    cost = (numitems = floor(infloat())) * Menu[3].cost;

			    if (numitems == 0.0)
				break;
			    else if (cost > Player.p_gold || numitems < 0)
				++cheat;
			    else if (numitems < Player.p_sword)
				NOBETTER();
			    else
				{
				cheat = 0;
				Player.p_gold -= cost;
				if (drandom() < 0.02)
				    dishonest = TRUE;
				else
				    Player.p_sword = numitems;
				}
			    break;

			case '5':
			    printw("A charm costs %.0f gp.  How many do you want (%.0f max) ? ",
				Menu[4].cost, floor(Player.p_gold / Menu[4].cost));
			    cost = (numitems = floor(infloat())) * Menu[4].cost;

			    if (cost > Player.p_gold || numitems < 0)
				++cheat;
			    else
				{
				cheat = 0;
				Player.p_gold -= cost;
				if (drandom() < 0.02)
				    dishonest = TRUE;
				else
				    Player.p_charms += numitems;
				}
			    break;

			case '6':
			    printw("Quicksilver is %.0f gp per +1.  How many + do you want (%.0f max) ? ",
				Menu[5].cost, floor(Player.p_gold / Menu[5].cost));
			    cost = (numitems = floor(infloat())) * Menu[5].cost;

			    if (numitems == 0.0)
				break;
			    else if (cost > Player.p_gold || numitems < 0)
				++cheat;
			    else if (numitems < Player.p_quksilver)
				NOBETTER();
			    else
				{
				cheat = 0;
				Player.p_gold -= cost;
				if (drandom() < 0.02)
				    dishonest = TRUE;
				else
				    Player.p_quksilver = numitems;
				}
			    break;

			case '7':
			    if (Player.p_blessing)
				{
				addstr("You already have a blessing.");
				break;
				}

			    printw("A blessing requires a %.0f gp donation.  Still want one ? ", blessingcost);
			    ch = getanswer("NY", FALSE);

			    if (ch == 'Y')
				if (Player.p_gold < blessingcost)
				    ++cheat;
				else
				    {
				    cheat = 0;
				    Player.p_gold -= blessingcost;
				    if (drandom() < 0.02)
					dishonest = TRUE;
				    else
					Player.p_blessing = TRUE;
				    }
			    break;
			}
	    break;

	    case 'S':		/* sell gems */
		mvprintw(15, 0, "A gem is worth %.0f gp.  How many do you want to sell (%.0f max) ? ",
		    (double) N_GEMVALUE, Player.p_gems);
		numitems = floor(infloat());

		if (numitems > Player.p_gems || numitems < 0)
		    ++cheat;
		else
		    {
		    cheat = 0;
		    Player.p_gems -= numitems;
		    Player.p_gold += numitems * N_GEMVALUE;
		    }
	    }

	if (cheat == 1)
	    mvaddstr(17, 0, "Come on, merchants aren't stupid.  Stop cheating.\n");
	else if (cheat == 2)
	    {
	    mvaddstr(17, 0, "You had your chance.  This merchant happens to be\n");
	    printw("a %.0f level magic user, and you made %s mad!\n",
		ROLL(Circle * 20.0, 40.0), (drandom() < 0.5) ? "him" : "her");
	    altercoordinates(0.0, 0.0, A_FAR);
	    Player.p_energy /= 2.0;
	    ++Player.p_sin;
	    more(23);
	    return;
	    }
	else if (dishonest)
	    {
	    mvaddstr(17, 0, "The merchant stole your money!");
	    refresh();
	    altercoordinates(Player.p_x - Player.p_x / 10.0,
		Player.p_y - Player.p_y / 10.0, A_SPECIFIC);
	    sleep(2);
	    return;
	    }
	}
}
/**/
/************************************************************************
/
/ FUNCTION NAME: displaystats()
/
/ FUNCTION: print out important player statistics
/
/ AUTHOR: E. A. Estes, 12/4/85
/
/ ARGUMENTS: none
/
/ RETURN VALUE: none
/
/ MODULES CALLED: descrstatus(), descrlocation(), mvprintw()
/
/ GLOBAL INPUTS: Users, Player
/
/ GLOBAL OUTPUTS: none
/
/ DESCRIPTION:
/	Important player statistics are printed on the screen.
/
/************************************************************************/

displaystats()
{
    mvprintw(0, 0, "%s%s\n", Player.p_name, descrlocation(&Player, FALSE));
    mvprintw(1, 0, "Level :%7.0f   Energy  :%9.0f(%9.0f)  Mana :%9.0f  Users:%3d\n",
	Player.p_level, Player.p_energy, Player.p_maxenergy + Player.p_shield,
	Player.p_mana, Users);
    mvprintw(2, 0, "Quick :%3.0f(%3.0f)  Strength:%9.0f(%9.0f)  Gold :%9.0f  %s\n",
	Player.p_speed, Player.p_quickness + Player.p_quksilver, Player.p_might,
	Player.p_strength + Player.p_sword, Player.p_gold, descrstatus(&Player));
}
/**/
/************************************************************************
/
/ FUNCTION NAME: allstatslist()
/
/ FUNCTION: show player items
/
/ AUTHOR: E. A. Estes, 12/4/85
/
/ ARGUMENTS: none
/
/ RETURN VALUE: none
/
/ MODULES CALLED: mvprintw(), descrtype()
/
/ GLOBAL INPUTS: Player
/
/ GLOBAL OUTPUTS: none
/
/ DESCRIPTION:
/	Print out some player statistics of lesser importance.
/
/************************************************************************/

allstatslist()
{
static	char	*flags[] =	/* to print value of some bools */
	    {
	    "False",
	    " True"
	    };

    mvprintw( 8,  0, "Type: %s\n",  descrtype(&Player,  FALSE));

    mvprintw(10,  0, "Experience: %9.0f", Player.p_experience);
    mvprintw(11,  0, "Brains    : %9.0f", Player.p_brains);
    mvprintw(12,  0, "Magic Lvl : %9.0f", Player.p_magiclvl);
    mvprintw(13,  0, "Sin       : %9.5f", Player.p_sin);
    mvprintw(14,  0, "Poison    : %9.5f", Player.p_poison);
    mvprintw(15,  0, "Gems      : %9.0f", Player.p_gems);
    mvprintw(16,  0, "Age       : %9d", Player.p_age);
    mvprintw(10, 40, "Holy Water: %9d", Player.p_holywater);
    mvprintw(11, 40, "Amulets   : %9d", Player.p_amulets);
    mvprintw(12, 40, "Charms    : %9d", Player.p_charms);
    mvprintw(13, 40, "Crowns    : %9d", Player.p_crowns);
    mvprintw(14, 40, "Shield    : %9.0f", Player.p_shield);
    mvprintw(15, 40, "Sword     : %9.0f", Player.p_sword);
    mvprintw(16, 40, "Quickslver: %9.0f", Player.p_quksilver);

    mvprintw(18,  0, "Blessing: %s   Ring: %s   Virgin: %s   Palantir: %s",
	flags[Player.p_blessing], flags[Player.p_ring.ring_type != R_NONE],
	flags[Player.p_virgin], flags[Player.p_palantir]);
}
/**/
/************************************************************************
/
/ FUNCTION NAME: descrtype()
/
/ FUNCTION: return a string specifying player type
/
/ AUTHOR: E. A. Estes, 12/4/85
/
/ ARGUMENTS:
/	struct player playerp - pointer to structure for player
/	bool shortflag - set if short form is desired
/
/ RETURN VALUE: pointer to string describing player type
/
/ MODULES CALLED: strcpy()
/
/ GLOBAL INPUTS: Databuf[]
/
/ GLOBAL OUTPUTS: Databuf[]
/
/ DESCRIPTION:
/	Return a string describing the player type.
/	King, council, valar, supercedes other types.
/	The first character of the string is '*' if the player
/	has a crown.
/	If 'shortflag' is TRUE, return a 3 character string.
/
/************************************************************************/

char	*
descrtype(playerp, shortflag)
struct player *playerp;
bool	shortflag;
{
register int type;	/* for caluculating result subscript */
static char	*results[] =	/* description table */
			{
			" Magic User", " MU",
			" Fighter", " F ",
			" Elf", " E ",
			" Dwarf", " D ",
			" Halfling", " H ",
			" Experimento", " EX",
			" Super", " S ",
			" King", " K ",
			" Council of Wise", " CW",
			" Ex-Valar", " EV",
			" Valar", " V ",
			" ? ", " ? "
			};

    type = playerp->p_type;

    switch (playerp->p_specialtype)
	{
	case SC_NONE:
	    type = playerp->p_type;
	    break;

	case SC_KING:
	    type = 7;
	    break;

	case SC_COUNCIL:
	    type = 8;
	    break;

	case SC_EXVALAR:
	    type = 9;
	    break;

	case SC_VALAR:
	    type = 10;
	    break;
	}

    type *= 2;		/* calculate offset */

    if (type > 20)
	/* error */
	type = 22;

    if (shortflag)
	/* use short descriptions */
	++type;

    if (playerp->p_crowns > 0)
	{
	strcpy(Databuf, results[type]);
	Databuf[0] = '*';
	return(Databuf);
	}
    else
	return(results[type]);
}
/**/
/************************************************************************
/
/ FUNCTION NAME: findname()
/
/ FUNCTION: find location in player file of given name
/
/ AUTHOR: E. A. Estes, 12/4/85
/
/ ARGUMENTS:
/	char *name - name of character to look for
/	struct player *playerp - pointer of structure to fill
/
/ RETURN VALUE: location of player if found, -1 otherwise
/
/ MODULES CALLED: fread(), fseek(), strcmp()
/
/ GLOBAL INPUTS: Wizard, *Playersfp
/
/ GLOBAL OUTPUTS: none
/
/ DESCRIPTION:
/	Search the player file for the player of the given name.
/	If player is found, fill structure with player data.
/
/************************************************************************/

long
findname(name, playerp)
register char	*name;
register struct player *playerp;
{
long	loc = 0;			/* location in the file */

    fseek(Playersfp, 0L, 0);
    while (fread((char *) playerp, SZ_PLAYERSTRUCT, 1, Playersfp) == 1)
	{
	if (strcmp(playerp->p_name, name) == 0)
	    {
	    if (playerp->p_status != S_NOTUSED || Wizard)
		/* found it */
		return(loc);
	    }
	loc += SZ_PLAYERSTRUCT;
	}

    return(-1);
}
/**/
/************************************************************************
/
/ FUNCTION NAME: allocrecord()
/
/ FUNCTION: find space in the player file for a new character
/
/ AUTHOR: E. A. Estes, 12/4/85
/
/ ARGUMENTS: none
/
/ RETURN VALUE: location of free space in file
/
/ MODULES CALLED: initplayer(), writerecord(), fread(), fseek()
/
/ GLOBAL INPUTS: Other, *Playersfp
/
/ GLOBAL OUTPUTS: Player
/
/ DESCRIPTION:
/	Search the player file for an unused entry.  If none are found,
/	make one at the end of the file.
/
/************************************************************************/

long
allocrecord()
{
long	loc = 0L;		/* location in file */

    fseek(Playersfp, 0L, 0);
    while (fread((char *) &Other, SZ_PLAYERSTRUCT, 1, Playersfp) == 1)
	{
	if (Other.p_status == S_NOTUSED)
	    /* found an empty record */
	    return(loc);
	else
	    loc += SZ_PLAYERSTRUCT;
	}

    /* make a new record */
    initplayer(&Other);
    Player.p_status = S_OFF;
    writerecord(&Other, loc);

    return(loc);
}
/**/
/************************************************************************
/
/ FUNCTION NAME: freerecord()
/
/ FUNCTION: free up a record on the player file
/
/ AUTHOR: E. A. Estes, 2/7/86
/
/ ARGUMENTS:
/	struct player playerp - pointer to structure to free
/	long loc - location in file to free
/
/ RETURN VALUE: none
/
/ MODULES CALLED: writerecord()
/
/ GLOBAL INPUTS: none
/
/ GLOBAL OUTPUTS: none
/
/ DESCRIPTION:
/	Mark structure as not used, and update player file.
/
/************************************************************************/

freerecord(playerp, loc)
struct player	*playerp;
long	loc;
{
    playerp->p_name[0] = CH_MARKDELETE;
    playerp->p_status = S_NOTUSED;
    writerecord(playerp, loc);
}
/**/
/************************************************************************
/
/ FUNCTION NAME: leavegame()
/
/ FUNCTION: leave game
/
/ AUTHOR: E. A. Estes, 12/4/85
/
/ ARGUMENTS: none
/
/ RETURN VALUE: none
/
/ MODULES CALLED: freerecord(), writerecord(), cleanup()
/
/ GLOBAL INPUTS: Player, Fileloc
/
/ GLOBAL OUTPUTS: Player
/
/ DESCRIPTION:
/	Mark player as inactive, and cleanup.
/	Do not save players below level 1.
/
/************************************************************************/

leavegame()
{

    if (Player.p_level < 1.0)
	/* delete character */
	freerecord(&Player, Fileloc);
    else
	{
	Player.p_status = S_OFF;
	writerecord(&Player, Fileloc);
	}

    cleanup(TRUE);
    /*NOTREACHED*/
}
/**/
/************************************************************************
/
/ FUNCTION NAME: death()
/
/ FUNCTION: death routine
/
/ AUTHOR: E. A. Estes, 12/4/85
/
/ ARGUMENTS:
/	char *how - pointer to string describing cause of death
/
/ RETURN VALUE: none
/
/ MODULES CALLED: freerecord(), enterscore(), more(), exit(), fread(),
/	fseek(), execl(), fopen(), floor(), wmove(), drandom(), wclear(), strcmp(),
/	fwrite(), fflush(), printw(), strcpy(), fclose(), waddstr(), cleanup(),
/	fprintf(), wrefresh(), getanswer(), descrtype()
/
/ GLOBAL INPUTS: Curmonster, Wizard, Player, *stdscr, Fileloc, *Monstfp
/
/ GLOBAL OUTPUTS: Player
/
/ DESCRIPTION:
/	Kill off current player.
/	Handle rings, and multiple lives.
/	Print an appropriate message.
/	Update scoreboard, lastdead, and let other players know about
/	the demise of their comrade.
/
/************************************************************************/

death(how)
char	*how;
{
FILE	*fp;		/* for updating various files */
int	ch;		/* input */
static	char	*deathmesg[] =
	/* add more messages here, if desired */
	{
	"You have been wounded beyond repair.  ",
	"You have been disemboweled.  ",
	"You've been mashed, mauled, and spit upon.  (You're dead.)\n",
	"You died!  ",
	"You're a complete failure -- you've died!!\n",
	"You have been dealt a fatal blow!  "
	};

    clear();

    if (strcmp(how, "Stupidity") != 0)
	{
	if (Player.p_level > 9999.0)
	    /* old age */
	    addstr("Characters must be retired upon reaching level 10000.  Sorry.");
	else if (Player.p_lives > 0)
	    /* extra lives */
	    {
	    addstr("You should be more cautious.  You've been killed.\n");
	    printw("You only have %d more chance(s).\n", --Player.p_lives);
	    more(3);
	    Player.p_energy = Player.p_maxenergy;
	    return;
	    }
	else if (Player.p_specialtype == SC_VALAR)
	    {
	    addstr("You had your chances, but Valar aren't totally\n");
	    addstr("immortal.  You are now left to wither and die . . .\n");
	    more(3);
	    Player.p_brains = Player.p_level / 25.0;
	    Player.p_energy = Player.p_maxenergy /= 5.0;
	    Player.p_quksilver = Player.p_sword = 0.0;
	    Player.p_specialtype = SC_COUNCIL;
	    return;
	    }
	else if (Player.p_ring.ring_inuse &&
	    (Player.p_ring.ring_type == R_DLREG || Player.p_ring.ring_type == R_NAZREG))
	    /* good ring in use - saved from death */
	    {
	    mvaddstr(4, 0, "Your ring saved you from death!\n");
	    refresh();
	    Player.p_ring.ring_type = R_NONE;
	    Player.p_energy = Player.p_maxenergy / 12.0 + 1.0;
	    if (Player.p_crowns > 0)
		--Player.p_crowns;
	    return;
	    }
	else if (Player.p_ring.ring_type == R_BAD
	    || Player.p_ring.ring_type == R_SPOILED)
	    /* bad ring in possession; name idiot after player */
	    {
	    mvaddstr(4, 0,
		"Your ring has taken control of you and turned you into a monster!\n");
	    fseek(Monstfp, 13L * SZ_MONSTERSTRUCT, 0);
	    fread((char *) &Curmonster, SZ_MONSTERSTRUCT, 1, Monstfp);
	    strcpy(Curmonster.m_name, Player.p_name);
	    fseek(Monstfp, 13L * SZ_MONSTERSTRUCT, 0);
	    fwrite((char *) &Curmonster, SZ_MONSTERSTRUCT, 1, Monstfp);
	    fflush(Monstfp);
	    }
	}

    enterscore();		/* update score board */

    /* put info in last dead file */
    fp = fopen(_PATH_LASTDEAD, "w");
    fprintf(fp,"%s (%s, run by %s, level %.0f, killed by %s)",
	Player.p_name, descrtype(&Player, TRUE),
	Player.p_login, Player.p_level, how);
    fclose(fp);

    /* let other players know */
    fp = fopen(_PATH_MESS, "w");
    fprintf(fp, "%s was killed by %s.", Player.p_name, how);
    fclose(fp);

    freerecord(&Player, Fileloc);

    clear();
    move(10, 0);
    addstr(deathmesg[(int) ROLL(0.0, (double) sizeof(deathmesg) / sizeof(char *))]);
    addstr("Care to give it another try ? ");
    ch = getanswer("NY", FALSE);

    if (ch == 'Y')
	{
	cleanup(FALSE);
	execl(_PATH_GAMEPROG, "phantasia", "-s",
	    (Wizard ? "-S": (char *) NULL), 0);
	exit(0);
	/*NOTREACHED*/
	}

    cleanup(TRUE);
    /*NOTREACHED*/
}
/**/
/************************************************************************
/
/ FUNCTION NAME: writerecord()
/
/ FUNCTION: update structure in player file
/
/ AUTHOR: E. A. Estes, 12/4/85
/
/ ARGUMENTS:
/	struct player *playerp - pointer to structure to write out
/	long place - location in file to updata
/
/ RETURN VALUE: none
/
/ MODULES CALLED: fseek(), fwrite(), fflush()
/
/ GLOBAL INPUTS: *Playersfp
/
/ GLOBAL OUTPUTS: none
/
/ DESCRIPTION:
/	Update location in player file with given structure.
/
/************************************************************************/

writerecord(playerp, place)
register struct player	*playerp;
long	place;
{
    fseek(Playersfp, place, 0);
    fwrite((char *) playerp, SZ_PLAYERSTRUCT, 1, Playersfp);
    fflush(Playersfp);
}
/**/
/************************************************************************
/
/ FUNCTION NAME: explevel()
/
/ FUNCTION: calculate level based upon experience
/
/ AUTHOR: E. A. Estes, 12/4/85
/
/ ARGUMENTS:
/	double experience - experience to calculate experience level from
/
/ RETURN VALUE: experience level
/
/ MODULES CALLED: pow(), floor()
/
/ GLOBAL INPUTS: none
/
/ GLOBAL OUTPUTS: none
/
/ DESCRIPTION:
/	Experience level is a geometric progression.  This has been finely
/	tuned over the years, and probably should not be changed.
/
/************************************************************************/

double
explevel(experience)
double	experience;
{
    if (experience < 1.1e7)
	return(floor(pow((experience / 1000.0), 0.4875)));
    else
	return(floor(pow((experience / 1250.0), 0.4865)));
}
/**/
/************************************************************************
/
/ FUNCTION NAME: truncstring()
/
/ FUNCTION: truncate trailing blanks off a string
/
/ AUTHOR: E. A. Estes, 12/4/85
/
/ ARGUMENTS:
/	char *string - pointer to null terminated string
/
/ RETURN VALUE: none
/
/ MODULES CALLED: strlen()
/
/ GLOBAL INPUTS: none
/
/ GLOBAL OUTPUTS: none
/
/ DESCRIPTION:
/	Put nul characters in place of spaces at the end of the string.
/
/************************************************************************/

truncstring(string)
register char	*string;
{
register int	length;		/* length of string */

    length = strlen(string);
    while (string[--length] == ' ')
	string[length] = '\0';
}
/**/
/************************************************************************
/
/ FUNCTION NAME: altercoordinates()
/
/ FUNCTION: Alter x, y coordinates and set/check location flags
/
/ AUTHOR: E. A. Estes, 12/16/85
/
/ ARGUMENTS:
/	double xnew, ynew - new x, y coordinates
/	int operation - operation to perform with coordinates
/
/ RETURN VALUE: none
/
/ MODULES CALLED: fabs(), floor(), drandom(), distance()
/
/ GLOBAL INPUTS: Circle, Beyond, Player
/
/ GLOBAL OUTPUTS: Marsh, Circle, Beyond, Throne, Player, Changed
/
/ DESCRIPTION:
/	This module is called whenever the player's coordinates are altered.
/	If the player is beyond the point of no return, he/she is forced
/	to stay there.
/
/************************************************************************/

altercoordinates(xnew, ynew, operation)
double	xnew;
double	ynew;
int	operation;
{
    switch (operation)
	{
	case A_FORCED:	/* move with no checks */
	    break;

	case A_NEAR:	/* pick random coordinates near */
	    xnew = Player.p_x + ROLL(1.0, 5.0);
	    ynew = Player.p_y - ROLL(1.0, 5.0);
	    /* fall through for check */

	case A_SPECIFIC:	/* just move player */
	    if (Beyond && fabs(xnew) < D_BEYOND && fabs(ynew) < D_BEYOND)
		/*
		 * cannot move back from point of no return
		 * pick the largest coordinate to remain unchanged
		 */
		{
		if (fabs(xnew) > fabs(ynew))
		    xnew = SGN(Player.p_x) * MAX(fabs(Player.p_x), D_BEYOND);
		else
		    ynew = SGN(Player.p_y) * MAX(fabs(Player.p_y), D_BEYOND);
		}
	    break;

	case A_FAR:	/* pick random coordinates far */
	    xnew = Player.p_x + SGN(Player.p_x) * ROLL(50 * Circle, 250 * Circle);
	    ynew = Player.p_y + SGN(Player.p_y) * ROLL(50 * Circle, 250 * Circle);
	    break;
	}

    /* now set location flags and adjust coordinates */
    Circle = CIRCLE(Player.p_x = floor(xnew), Player.p_y = floor(ynew));

    /* set up flags based upon location */
    Throne = Marsh = Beyond = FALSE;

    if (Player.p_x == 0.0 && Player.p_y == 0.0)
	Throne = TRUE;
    else if (Circle < 35 && Circle >= 20)
	Marsh = TRUE;
    else if (MAX(fabs(Player.p_x), fabs(Player.p_y)) >= D_BEYOND)
	Beyond = TRUE;

    Changed = TRUE;
}
/**/
/************************************************************************
/
/ FUNCTION NAME: readrecord()
/
/ FUNCTION: read a player structure from file
/
/ AUTHOR: E. A. Estes, 12/4/85
/
/ ARGUMENTS:
/	struct player *playerp - pointer to structure to fill
/	int loc - location of record to read
/
/ RETURN VALUE: none
/
/ MODULES CALLED: fread(), fseek()
/
/ GLOBAL INPUTS: *Playersfp
/
/ GLOBAL OUTPUTS: none
/
/ DESCRIPTION:
/	Read structure information from player file.
/
/************************************************************************/

readrecord(playerp, loc)
register struct player	*playerp;
long	loc;
{
    fseek(Playersfp, loc, 0);
    fread((char *) playerp, SZ_PLAYERSTRUCT, 1, Playersfp);
}
/**/
/************************************************************************
/
/ FUNCTION NAME: adjuststats()
/
/ FUNCTION: adjust player statistics
/
/ AUTHOR: E. A. Estes, 12/4/85
/
/ ARGUMENTS: none
/
/ RETURN VALUE: none
/
/ MODULES CALLED: death(), floor(), drandom(), explevel(), movelevel()
/
/ GLOBAL INPUTS: Player, *Statptr
/
/ GLOBAL OUTPUTS: Circle, Player, Timeout
/
/ DESCRIPTION:
/	Handle adjustment and maximums on various player characteristics.
/
/************************************************************************/

adjuststats()
{
double	dtemp;				/* for temporary calculations */

    if (explevel(Player.p_experience) > Player.p_level)
	/* move one or more levels */
	{
	movelevel();
	if (Player.p_level > 5.0)
	    Timeout = TRUE;
	}

    if (Player.p_specialtype == SC_VALAR)
	/* valar */
	Circle = Player.p_level / 5.0;

    /* calculate effective quickness */
    dtemp = ((Player.p_gold + Player.p_gems / 2.0) - 1000.0) / Statptr->c_goldtote
	- Player.p_level;;
    dtemp = MAX(0.0, dtemp);		/* gold slows player down */
    Player.p_speed = Player.p_quickness + Player.p_quksilver - dtemp;

    /* calculate effective strength */
    if (Player.p_poison > 0.0)
	/* poison makes player weaker */
	{
	dtemp = 1.0 - Player.p_poison * Statptr->c_weakness / 800.0;
	dtemp = MAX(0.1, dtemp);
	}
    else
	dtemp = 1.0;
    Player.p_might = dtemp *  Player.p_strength + Player.p_sword;

    /* insure that important things are within limits */
    Player.p_quksilver = MIN(99.0, Player.p_quksilver);
    Player.p_mana = MIN(Player.p_mana,
	Player.p_level * Statptr->c_maxmana + 1000.0);
    Player.p_brains = MIN(Player.p_brains,
	Player.p_level * Statptr->c_maxbrains + 200.0);
    Player.p_charms = MIN(Player.p_charms, Player.p_level + 10.0);

    /*
     * some implementations have problems with floating point compare
     * we work around it with this stuff
     */
    Player.p_gold = floor(Player.p_gold) + 0.1;
    Player.p_gems = floor(Player.p_gems) + 0.1;
    Player.p_mana = floor(Player.p_mana) + 0.1;

    if (Player.p_ring.ring_type != R_NONE)
	/* do ring things */
	{
	/* rest to max */
	Player.p_energy = Player.p_maxenergy + Player.p_shield;

        if (Player.p_ring.ring_duration <= 0)
	    /* clean up expired rings */
	    switch (Player.p_ring.ring_type)
		{
		case R_BAD:	/* ring drives player crazy */
		    Player.p_ring.ring_type = R_SPOILED;
		    Player.p_ring.ring_duration = (short) ROLL(10.0, 25.0);
		    break;

		case R_NAZREG:	/* ring disappears */
		    Player.p_ring.ring_type = R_NONE;
		    break;

		case R_SPOILED:	/* ring kills player */
		    death("A cursed ring");
		    break;

		case R_DLREG:	/* this ring doesn't expire */
		    Player.p_ring.ring_duration = 0;
		    break;
		}
	}

    if (Player.p_age / N_AGE > Player.p_degenerated)
	/* age player slightly */
	{
	++Player.p_degenerated;
	if (Player.p_quickness > 23.0)
	    Player.p_quickness *= 0.99;
	Player.p_strength *= 0.97;
	Player.p_brains *= 0.95;
	Player.p_magiclvl *= 0.97;
	Player.p_maxenergy *= 0.95;
	Player.p_quksilver *= 0.95;
	Player.p_sword *= 0.93;
	Player.p_shield *= 0.93;
	}
}
/**/
/************************************************************************
/
/ FUNCTION NAME: initplayer()
/
/ FUNCTION: initialize a character
/
/ AUTHOR: E. A. Estes, 12/4/85
/
/ ARGUMENTS:
/	struct player *playerp - pointer to structure to init
/
/ RETURN VALUE: none
/
/ MODULES CALLED: floor(), drandom()
/
/ GLOBAL INPUTS: none
/
/ GLOBAL OUTPUTS: none
/
/ DESCRIPTION:
/	Put a bunch of default values in the given structure.
/
/************************************************************************/

initplayer(playerp)
register struct  player   *playerp;
{
    playerp->p_experience =
    playerp->p_level =
    playerp->p_strength =
    playerp->p_sword =
    playerp->p_might =
    playerp->p_energy =
    playerp->p_maxenergy =
    playerp->p_shield =
    playerp->p_quickness =
    playerp->p_quksilver =
    playerp->p_speed =
    playerp->p_magiclvl =
    playerp->p_mana =
    playerp->p_brains =
    playerp->p_poison =
    playerp->p_gems =
    playerp->p_sin =
    playerp->p_1scratch =
    playerp->p_2scratch = 0.0;

    playerp->p_gold = ROLL(50.0, 75.0) + 0.1;	/* give some gold */

    playerp->p_x = ROLL(-125.0, 251.0);
    playerp->p_y = ROLL(-125.0, 251.0);		/* give random x, y */

    /* clear ring */
    playerp->p_ring.ring_type = R_NONE;
    playerp->p_ring.ring_duration = 0;
    playerp->p_ring.ring_inuse = FALSE;

    playerp->p_age = 0L;

    playerp->p_degenerated = 1;			/* don't degenerate initially */

    playerp->p_type = C_FIGHTER;		/* default */
    playerp->p_specialtype = SC_NONE;
    playerp->p_lives =
    playerp->p_crowns =
    playerp->p_charms =
    playerp->p_amulets =
    playerp->p_holywater =
    playerp->p_lastused = 0;
    playerp->p_status = S_NOTUSED;
    playerp->p_tampered = T_OFF;
    playerp->p_istat = I_OFF;

    playerp->p_palantir =
    playerp->p_blessing =
    playerp->p_virgin =
    playerp->p_blindness = FALSE;

    playerp->p_name[0] =
    playerp->p_password[0] =
    playerp->p_login[0] = '\0';
}
/**/
/************************************************************************
/
/ FUNCTION NAME: readmessage()
/
/ FUNCTION: read message from other players
/
/ AUTHOR: E. A. Estes, 12/4/85
/
/ ARGUMENTS: none
/
/ RETURN VALUE: none
/
/ MODULES CALLED: fseek(), fgets(), wmove(), waddstr(), wclrtoeol()
/
/ GLOBAL INPUTS: *stdscr, Databuf[], *Messagefp
/
/ GLOBAL OUTPUTS: none
/
/ DESCRIPTION:
/	If there is a message from other players, print it.
/
/************************************************************************/

readmessage()
{
    move(3, 0);
    clrtoeol();
    fseek(Messagefp, 0L, 0);
    if (fgets(Databuf, SZ_DATABUF, Messagefp) != NULL)
	addstr(Databuf);
}
/**/
/************************************************************************
/
/ FUNCTION NAME: error()
/
/ FUNCTION: process evironment error
/
/ AUTHOR: E. A. Estes, 12/4/85
/
/ ARGUMENTS:
/	char *whichfile - pointer to name of file which caused error
/
/ RETURN VALUE: none
/
/ MODULES CALLED: wclear(), cleanup()
/
/ GLOBAL INPUTS: errno, *stdscr, printw(), printf(), Windows
/
/ GLOBAL OUTPUTS: none
/
/ DESCRIPTION:
/	Print message about offending file, and exit.
/
/************************************************************************/

error(whichfile)
	char	*whichfile;
{
	int	(*funcp) __P((const char *, ...));

    if (Windows)
	{
	funcp = printw;
	clear();
	}
    else
	funcp = printf;

    (*funcp)("An unrecoverable error has occurred reading %s.  (errno = %d)\n", whichfile, errno);
    (*funcp)("Please run 'setup' to determine the problem.\n");
    cleanup(TRUE);
    /*NOTREACHED*/
}
/**/
/************************************************************************
/
/ FUNCTION NAME: distance()
/
/ FUNCTION: calculate distance between two points
/
/ AUTHOR: E. A. Estes, 12/4/85
/
/ ARGUMENTS:
/	double x1, y1 - x, y coordinates of first point
/	double x2, y2 - x, y coordinates of second point
/
/ RETURN VALUE: distance between the two points
/
/ MODULES CALLED: sqrt()
/
/ GLOBAL INPUTS: none
/
/ GLOBAL OUTPUTS: none
/
/ DESCRIPTION:
/	This function is provided because someone's hypot() library function
/	fails if x1 == x2 && y1 == y2.
/
/************************************************************************/

double
distance(x1, x2, y1, y2)
double	x1, x2, y1, y2;
{
double	deltax, deltay;

    deltax = x1 - x2;
    deltay = y1 - y2;
    return(sqrt(deltax * deltax + deltay * deltay));
}

/**/
/************************************************************************
/
/ FUNCTION NAME: ill_sig()
/
/ FUNCTION: exit upon trapping an illegal signal
/
/ AUTHOR: E. A. Estes, 12/4/85
/
/ ARGUMENTS:
/	int whichsig - signal which occured to cause jump to here
/
/ RETURN VALUE: none
/
/ MODULES CALLED: wclear(), printw(), cleanup()
/
/ GLOBAL INPUTS: *stdscr
/
/ GLOBAL OUTPUTS: none
/
/ DESCRIPTION:
/	When an illegal signal is caught, print a message, and cleanup.
/
/************************************************************************/

ill_sig(whichsig)
int whichsig;
{
    clear();
    if (!(whichsig == SIGINT || whichsig == SIGQUIT))
	printw("Error: caught signal # %d.\n", whichsig);
    cleanup(TRUE);
    /*NOTREACHED*/
}
/**/
/************************************************************************
/
/ FUNCTION NAME: descrstatus()
/
/ FUNCTION: return a string describing the player status
/
/ AUTHOR: E. A. Estes, 3/3/86
/
/ ARGUMENTS:
/	struct player playerp - pointer to player structure to describe
/
/ RETURN VALUE: string describing player's status
/
/ MODULES CALLED: none
/
/ GLOBAL INPUTS: none
/
/ GLOBAL OUTPUTS: none
/
/ DESCRIPTION:
/	Return verbal description of player status.
/	If player status is S_PLAYING, check for low energy and blindness.
/
/************************************************************************/

char	*
descrstatus(playerp)
register struct player	*playerp;
{
    switch (playerp->p_status)
	{
	case S_PLAYING:
	    if (playerp->p_energy < 0.2 * (playerp->p_maxenergy + playerp->p_shield))
		return("Low Energy");
	    else if (playerp->p_blindness)
		return("Blind");
	    else
		return("In game");

	case S_CLOAKED:
	    return("Cloaked");

	case S_INBATTLE:
	    return("In Battle");

	case S_MONSTER:
	    return("Encounter");

	case S_TRADING:
	    return("Trading");

	case S_OFF:
	    return("Off");

	case S_HUNGUP:
	    return("Hung up");

	default:
	    return("");
	}
}
/**/
/************************************************************************
/
/ FUNCTION NAME: drandom()
/
/ FUNCTION: return a random floating point number from 0.0 < 1.0
/
/ AUTHOR: E. A. Estes, 2/7/86
/
/ ARGUMENTS: none
/
/ RETURN VALUE: none
/
/ MODULES CALLED: random()
/
/ GLOBAL INPUTS: none
/
/ GLOBAL OUTPUTS: none
/
/ DESCRIPTION:
/	Convert random integer from library routine into a floating
/	point number, and divide by the largest possible random number.
/	We mask large integers with 32767 to handle sites that return
/	31 bit random integers.
/
/************************************************************************/

double
drandom()
{
    if (sizeof(int) != 2)
	/* use only low bits */
	return((double) (random() & 0x7fff) / 32768.0);
    else
	return((double) random() / 32768.0);
}
/**/
/************************************************************************
/
/ FUNCTION NAME: collecttaxes()
/
/ FUNCTION: collect taxes from current player
/
/ AUTHOR: E. A. Estes, 2/7/86
/
/ ARGUMENTS:
/	double gold - amount of gold to tax
/	double gems - amount of gems to tax
/
/ RETURN VALUE: none
/
/ MODULES CALLED: fread(), fseek(), fopen(), floor(), fwrite(), fclose()
/
/ GLOBAL INPUTS: Player
/
/ GLOBAL OUTPUTS: Player
/
/ DESCRIPTION:
/	Pay taxes on gold and gems.  If the player does not have enough
/	gold to pay taxes on the added gems, convert some gems to gold.
/	Add taxes to tax data base; add remaining gold and gems to
/	player's cache.
/
/************************************************************************/

collecttaxes(gold, gems)
double	gold;
double	gems;
{
FILE	*fp;		/* to update Goldfile */
double	dtemp;		/* for temporary calculations */
double	taxes;		/* tax liability */

    /* add to cache */
    Player.p_gold += gold;
    Player.p_gems += gems;

    /* calculate tax liability */
    taxes = N_TAXAMOUNT / 100.0 * (N_GEMVALUE * gems + gold);

    if (Player.p_gold < taxes)
	/* not enough gold to pay taxes, must convert some gems to gold */
	{
	dtemp = floor(taxes / N_GEMVALUE + 1.0); /* number of gems to convert */

	if (Player.p_gems >= dtemp)
	    /* player has enough to convert */
	    {
	    Player.p_gems -= dtemp;
	    Player.p_gold += dtemp * N_GEMVALUE;
	    }
	else
	    /* take everything; this should never happen */
	    {
	    Player.p_gold += Player.p_gems * N_GEMVALUE;
	    Player.p_gems = 0.0;
	    taxes = Player.p_gold;
	    }
	}

    Player.p_gold -= taxes;

    if ((fp = fopen(_PATH_GOLD, "r+")) != NULL)
	/* update taxes */
	{
	dtemp = 0.0;
	fread((char *) &dtemp, sizeof(double), 1, fp);
	dtemp += floor(taxes);
	fseek(fp, 0L, 0);
	fwrite((char *) &dtemp, sizeof(double), 1, fp);
	fclose(fp);
	}
}