6c3cd116ff
There should only be two changes in behavior: arogue7/fight.c, arogue7/fight.c: a to-hit bonus is now correctly applied to characters who are not monks instead of monks who are not empty-handed. urogue/fight.c: fixed an interaction with the "debug" macro that could cause the wrong message to be displayed.
927 lines
24 KiB
C
927 lines
24 KiB
C
/*
|
||
* rip.c - File for the fun ends Death or a total win
|
||
*
|
||
* Advanced Rogue
|
||
* Copyright (C) 1984, 1985, 1986 Michael Morgan, Ken Dalka and AT&T
|
||
* All rights reserved.
|
||
*
|
||
* Based on "Rogue: Exploring the Dungeons of Doom"
|
||
* Copyright (C) 1980, 1981 Michael Toy, Ken Arnold and Glenn Wichman
|
||
* All rights reserved.
|
||
*
|
||
* See the file LICENSE.TXT for full copyright and licensing information.
|
||
*/
|
||
|
||
/* Print flags for scoring */
|
||
#define REALLIFE 1 /* Print out machine and logname */
|
||
#define EDITSCORE 2 /* Edit the current score file */
|
||
#define ADDSCORE 3 /* Add a new score */
|
||
|
||
#define NAMELEN 80
|
||
|
||
/*
|
||
* File for the fun ends
|
||
* Death or a total win
|
||
*
|
||
*/
|
||
|
||
#include "curses.h"
|
||
#ifdef BSD
|
||
#include <sys/time.h>
|
||
#else
|
||
#include <time.h>
|
||
#endif
|
||
#include <signal.h>
|
||
#include <ctype.h>
|
||
#include <string.h>
|
||
#include <stdlib.h>
|
||
#include <sys/types.h>
|
||
#include <fcntl.h>
|
||
#include "mach_dep.h"
|
||
#include "network.h"
|
||
#include "rogue.h"
|
||
#ifdef PC7300
|
||
#include "sys/window.h"
|
||
extern struct uwdata wdata, oldwin;
|
||
extern char oldtext[WTXTNUM][WTXTLEN];
|
||
#endif
|
||
|
||
#ifdef NUMNET
|
||
/* Network machines (for mutual score keeping) */
|
||
static struct network Network[NUMNET] = {
|
||
{ "ihwpt", "/t1/michael/bin/rg" },
|
||
};
|
||
#endif
|
||
|
||
/*
|
||
* If you change this structure, change the compatibility routines
|
||
* scoreout() and scorein() to reflect the change. Also update SCORELEN.
|
||
*/
|
||
struct sc_ent {
|
||
unsigned long sc_score;
|
||
char sc_name[NAMELEN];
|
||
char sc_system[SYSLEN];
|
||
char sc_login[LOGLEN];
|
||
short sc_flags;
|
||
short sc_level;
|
||
short sc_ctype;
|
||
short sc_monster;
|
||
short sc_quest;
|
||
};
|
||
#define SCORELEN \
|
||
(sizeof(unsigned long) + NAMELEN + SYSLEN + LOGLEN + 5*sizeof(short))
|
||
|
||
static char *rip[] = {
|
||
" __________",
|
||
" / \\",
|
||
" / REST \\",
|
||
" / IN \\",
|
||
" / PEACE \\",
|
||
" / \\",
|
||
" | |",
|
||
" | |",
|
||
" | killed by |",
|
||
" | |",
|
||
" | 1984 |",
|
||
" *| * * * | *",
|
||
" ________)/\\\\_//(\\/(/\\)/\\//\\/|_)_______",
|
||
0
|
||
};
|
||
|
||
char *killname(short monst);
|
||
void showpack(char *howso);
|
||
int update(struct sc_ent top_ten[], unsigned long amount, short quest,
|
||
char *whoami, short flags, short level, short monst, short ctype,
|
||
char *system, char *login);
|
||
|
||
|
||
void
|
||
byebye(int sig)
|
||
{
|
||
if (!isendwin()) {
|
||
clear();
|
||
endwin();
|
||
}
|
||
#ifdef PC7300
|
||
endhardwin();
|
||
#endif
|
||
printf("\n");
|
||
exit(0);
|
||
}
|
||
|
||
|
||
/*
|
||
* death:
|
||
* Do something really fun when he dies
|
||
*/
|
||
|
||
void
|
||
death(short monst)
|
||
{
|
||
register char **dp = rip, *killer;
|
||
register struct tm *lt;
|
||
time_t date;
|
||
char buf[LINELEN];
|
||
struct tm *localtime();
|
||
|
||
time(&date);
|
||
lt = localtime(&date);
|
||
clear();
|
||
move(8, 0);
|
||
while (*dp)
|
||
printw("%s\n", *dp++);
|
||
mvaddstr(14, 28-((strlen(whoami)+1)/2), whoami);
|
||
sprintf(buf, "%lu Points", pstats.s_exp );
|
||
mvaddstr(15, 28-((strlen(buf)+1)/2), buf);
|
||
killer = killname(monst);
|
||
mvaddstr(17, 28-((strlen(killer)+1)/2), killer);
|
||
mvaddstr(18, 26, (sprintf(prbuf, "%4d", 1900+lt->tm_year), prbuf));
|
||
move(lines-1, 0);
|
||
refresh();
|
||
writelog(pstats.s_exp, KILLED, monst);
|
||
score(pstats.s_exp, KILLED, monst);
|
||
endwin();
|
||
#ifdef PC7300
|
||
endhardwin();
|
||
#endif
|
||
exit(0);
|
||
}
|
||
|
||
#ifdef PC7300
|
||
/*
|
||
* Restore window characteristics on a hard window terminal (PC7300).
|
||
*/
|
||
void
|
||
endhardwin(void)
|
||
{
|
||
register int i;
|
||
struct utdata labelbuf;
|
||
|
||
/* Restore the old window size */
|
||
if (oldwin.uw_width) ioctl(1, WIOCSETD, &oldwin);
|
||
|
||
/* Restore the old window text */
|
||
for (i=0; i<WTXTNUM; i++) {
|
||
labelbuf.ut_num = i;
|
||
strcpy(labelbuf.ut_text, oldtext[i]);
|
||
ioctl(1, WIOCSETTEXT, &labelbuf);
|
||
}
|
||
}
|
||
#endif
|
||
|
||
char *
|
||
killname(short monst)
|
||
{
|
||
static char mons_name[LINELEN];
|
||
int i;
|
||
|
||
if (monst > NUMMONST) return("a strange monster");
|
||
|
||
if (monst >= 0) {
|
||
switch (monsters[monst].m_name[0]) {
|
||
case 'a':
|
||
case 'e':
|
||
case 'i':
|
||
case 'o':
|
||
case 'u':
|
||
sprintf(mons_name, "an %s", monsters[monst].m_name);
|
||
break;
|
||
default:
|
||
sprintf(mons_name, "a %s", monsters[monst].m_name);
|
||
}
|
||
return(mons_name);
|
||
}
|
||
for (i = 0; i< DEATHNUM; i++) {
|
||
if (deaths[i].reason == monst)
|
||
break;
|
||
}
|
||
if (i >= DEATHNUM)
|
||
return ("strange death");
|
||
return (deaths[i].name);
|
||
}
|
||
|
||
/* Writes an entry in the log file */
|
||
|
||
void
|
||
writelog(unsigned long amount, int flags, short monst)
|
||
{
|
||
char had_quest = '0';
|
||
char fate[LINELEN];
|
||
struct linked_list *item;
|
||
struct object *obj;
|
||
#ifdef LOGFILE
|
||
if (waswizard)
|
||
return;
|
||
if (logfile == NULL)
|
||
return;
|
||
/* Check for quest item */
|
||
for (item = pack; item != NULL; item = next(item)) {
|
||
obj = OBJPTR(item);
|
||
if (obj->o_type == RELIC && obj->o_which == quest_item)
|
||
had_quest = '1';
|
||
}
|
||
/* Describe what happened */
|
||
if (flags == KILLED) {
|
||
snprintf(fate, LINELEN, "killed by %s", killname(monst));
|
||
}
|
||
else if (flags == CHICKEN) {
|
||
strcpy(fate, "quit");
|
||
}
|
||
else if (flags == WINNER) {
|
||
strcpy(fate, "escaped");
|
||
}
|
||
else
|
||
return;
|
||
/* Write */
|
||
fprintf(logfile, "%ld %ld %s %d %s %d %d %d %c %s\n", time(NULL), amount,
|
||
whoami, pstats.s_lvl, char_class[char_type].name, level, max_level,
|
||
quest_item, had_quest, fate);
|
||
fclose(logfile);
|
||
#endif
|
||
return;
|
||
}
|
||
|
||
/*
|
||
* score -- figure score and post it.
|
||
*/
|
||
|
||
/* VARARGS2 */
|
||
void
|
||
score(unsigned long amount, int flags, short monst)
|
||
{
|
||
static struct sc_ent top_ten[NUMSCORE];
|
||
register struct sc_ent *scp;
|
||
register int i;
|
||
register struct sc_ent *sc2;
|
||
register char *killer;
|
||
register int prflags = 0;
|
||
short upquest, wintype, uplevel, uptype; /* For network updating */
|
||
char upsystem[SYSLEN], uplogin[LOGLEN];
|
||
char *thissys; /* Holds the name of this system */
|
||
char *compatstr=NULL; /* Holds scores for writing compatible score files */
|
||
char scoreline[100];
|
||
#define REASONLEN 3
|
||
static char *reason[] = {
|
||
"killed",
|
||
"quit",
|
||
"A total winner",
|
||
"somehow left",
|
||
};
|
||
char *packend;
|
||
|
||
signal(SIGINT, byebye);
|
||
if (flags != WINNER && flags != SCOREIT && flags != UPDATE) {
|
||
if (flags == CHICKEN)
|
||
packend = "when you quit";
|
||
else
|
||
{
|
||
packend = "at your untimely demise";
|
||
mvaddstr(lines - 1, 0, retstr);
|
||
refresh();
|
||
getstr(prbuf);
|
||
}
|
||
showpack(packend);
|
||
}
|
||
purse = 0; /* Steal all the gold */
|
||
|
||
/*
|
||
* Read list
|
||
*/
|
||
|
||
if (scoreboard == NULL) return;
|
||
|
||
#ifndef SYSTEM
|
||
thissys = md_gethostname();
|
||
#else
|
||
thissys = SYSTEM;
|
||
#endif
|
||
|
||
for (scp = top_ten; scp <= &top_ten[NUMSCORE-1]; scp++)
|
||
{
|
||
scp->sc_score = 0L;
|
||
for (i = 0; i < NAMELEN; i++)
|
||
scp->sc_name[i] = rnd(255);
|
||
scp->sc_quest= RN;
|
||
scp->sc_flags = RN;
|
||
scp->sc_level = RN;
|
||
scp->sc_monster = RN;
|
||
scp->sc_ctype = 0;
|
||
strncpy(scp->sc_system, thissys, SYSLEN);
|
||
scp->sc_login[0] = '\0';
|
||
}
|
||
|
||
/*
|
||
* If this is a SCOREIT optin (rogue -s), don't call byebye. The
|
||
* endwin() call in byebye() will result in a core dump.
|
||
*/
|
||
if (flags == SCOREIT) signal(SIGINT, SIG_DFL);
|
||
else signal(SIGINT, byebye);
|
||
|
||
if (flags != SCOREIT && flags != UPDATE)
|
||
{
|
||
mvaddstr(lines - 1, 0, retstr);
|
||
refresh();
|
||
fflush(stdout);
|
||
getstr(prbuf);
|
||
}
|
||
|
||
/* Check for special options */
|
||
if (strcmp(prbuf, "names") == 0)
|
||
prflags = REALLIFE;
|
||
#ifdef WIZARD
|
||
else if (wizard) {
|
||
if (strcmp(prbuf, "edit") == 0) prflags = EDITSCORE;
|
||
else if (strcmp(prbuf, "add") == 0) {
|
||
prflags = ADDSCORE;
|
||
waswizard = FALSE; /* We want the new score recorded */
|
||
}
|
||
}
|
||
#endif
|
||
|
||
/* Read the score and convert it to a compatible format */
|
||
for(i = 0; i < NUMSCORE; i++)
|
||
{
|
||
encread(top_ten[i].sc_name, NAMELEN, scoreboard);
|
||
encread(top_ten[i].sc_system, SYSLEN, scoreboard);
|
||
encread(top_ten[i].sc_login, LOGLEN, scoreboard);
|
||
encread(scoreline, 100, scoreboard);
|
||
sscanf(scoreline, " %lu %hd %hd %hd %hd %hd \n",
|
||
&top_ten[i].sc_score, &top_ten[i].sc_flags,
|
||
&top_ten[i].sc_level, &top_ten[i].sc_ctype,
|
||
&top_ten[i].sc_monster, &top_ten[i].sc_quest
|
||
);
|
||
}
|
||
|
||
/* Get some values if this is an update */
|
||
if (flags == UPDATE) {
|
||
unsigned long netread();
|
||
int errcheck, errors = 0;
|
||
|
||
upquest = (short) netread(&errcheck, sizeof(short), stdin);
|
||
if (errcheck) errors++;
|
||
|
||
if (fread(whoami, 1, NAMELEN, stdin) != NAMELEN) errors++;
|
||
|
||
wintype = (short) netread(&errcheck, sizeof(short), stdin);
|
||
if (errcheck) errors++;
|
||
|
||
uplevel = (short) netread(&errcheck, sizeof(short), stdin);
|
||
if (errcheck) errors++;
|
||
|
||
uptype = (short) netread(&errcheck, sizeof(short), stdin);
|
||
if (errcheck) errors++;
|
||
|
||
if (fread(upsystem, 1, SYSLEN, stdin) != SYSLEN)
|
||
errors++;
|
||
if (fread(uplogin, 1, LOGLEN, stdin) != LOGLEN)
|
||
errors++;
|
||
|
||
if (errors) {
|
||
fclose(scoreboard);
|
||
free(compatstr);
|
||
return;
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Insert player in list if need be
|
||
*/
|
||
if (!waswizard) {
|
||
char *login = "";
|
||
|
||
if (flags != UPDATE) {
|
||
login = md_getusername();
|
||
}
|
||
|
||
if (flags == UPDATE)
|
||
(void) update(top_ten, amount, upquest, whoami, wintype,
|
||
uplevel, monst, uptype, upsystem, uplogin);
|
||
else {
|
||
#ifdef WIZARD
|
||
if (prflags == ADDSCORE) { /* Overlay characteristic by new ones */
|
||
char buffer[LINELEN];
|
||
|
||
clear();
|
||
mvaddstr(1, 0, "Score: ");
|
||
mvaddstr(2, 0, "Quest (number): ");
|
||
mvaddstr(3, 0, "Name: ");
|
||
mvaddstr(4, 0, "System: ");
|
||
mvaddstr(5, 0, "Login: ");
|
||
mvaddstr(6, 0, "Level: ");
|
||
mvaddstr(7, 0, "Char type: ");
|
||
mvaddstr(8, 0, "Result: ");
|
||
|
||
/* Get the score */
|
||
move(1, 7);
|
||
get_str(buffer, stdscr);
|
||
amount = atol(buffer);
|
||
|
||
/* Get the character's quest -- must be a number */
|
||
move(2, 16);
|
||
get_str(buffer, stdscr);
|
||
quest_item = atoi(buffer);
|
||
|
||
/* Get the character's name */
|
||
move(3, 6);
|
||
get_str(buffer, stdscr);
|
||
strncpy(whoami, buffer, NAMELEN);
|
||
|
||
/* Get the system */
|
||
move(4, 8);
|
||
get_str(buffer, stdscr);
|
||
strncpy(thissys, buffer, SYSLEN);
|
||
|
||
/* Get the login */
|
||
move(5, 7);
|
||
get_str(buffer, stdscr);
|
||
strncpy(login, buffer, LOGLEN);
|
||
|
||
/* Get the level */
|
||
move(6, 7);
|
||
get_str(buffer, stdscr);
|
||
level = max_level = (short) atoi(buffer);
|
||
|
||
/* Get the character type */
|
||
move(7, 11);
|
||
get_str(buffer, stdscr);
|
||
for (i=0; i<NUM_CHARTYPES; i++) {
|
||
if (EQSTR(buffer, char_class[i].name, strlen(buffer)))
|
||
break;
|
||
}
|
||
player.t_ctype = i;
|
||
|
||
/* Get the win type */
|
||
move(8, 8);
|
||
get_str(buffer, stdscr);
|
||
switch (buffer[0]) {
|
||
case 'W':
|
||
case 'w':
|
||
case 'T':
|
||
case 't':
|
||
flags = WINNER;
|
||
break;
|
||
|
||
case 'Q':
|
||
case 'q':
|
||
flags = CHICKEN;
|
||
break;
|
||
|
||
case 'k':
|
||
case 'K':
|
||
default:
|
||
flags = KILLED;
|
||
break;
|
||
}
|
||
|
||
/* Get the monster if player was killed */
|
||
if (flags == KILLED) {
|
||
mvaddstr(9, 0, "Death type: ");
|
||
get_str(buffer, stdscr);
|
||
if (buffer[0] == 'M' || buffer[0] == 'm')
|
||
do {
|
||
monst = makemonster(TRUE, "Editing", "choose");
|
||
} while (monst < 0); /* Force a choice */
|
||
else monst = getdeath();
|
||
}
|
||
}
|
||
#endif
|
||
|
||
if (update(top_ten, amount, (short) quest_item, whoami, flags,
|
||
(flags == WINNER) ? (short) max_level : (short) level,
|
||
monst, player.t_ctype, thissys, login)
|
||
#ifdef NUMNET
|
||
&& fork() == 0 /* Spin off network process */
|
||
#endif
|
||
) {
|
||
#ifdef NUMNET
|
||
/* Send this update to the other systems in the network */
|
||
int i, j;
|
||
char cmd[256]; /* Command for remote execution */
|
||
FILE *rmf, *popen(); /* For input to remote command */
|
||
|
||
for (i=0; i<NUMNET; i++)
|
||
if (Network[i].system[0] != '!' &&
|
||
strcmp(Network[i].system, thissys)) {
|
||
sprintf(cmd, NETCOMMAND,
|
||
Network[i].system, Network[i].rogue);
|
||
|
||
/* Execute the command */
|
||
if ((rmf=popen(cmd, "w")) != NULL) {
|
||
unsigned long temp; /* Temporary value */
|
||
|
||
/* Write out the parameters */
|
||
(void) netwrite((unsigned long) amount,
|
||
sizeof(unsigned long), rmf);
|
||
|
||
(void) netwrite((unsigned long) monst,
|
||
sizeof(short), rmf);
|
||
|
||
(void) netwrite((unsigned long) quest_item,
|
||
sizeof(short), rmf);
|
||
|
||
(void) fwrite(whoami, 1, strlen(whoami), rmf);
|
||
for (j=strlen(whoami); j<NAMELEN; j++)
|
||
putc('\0', rmf);
|
||
|
||
(void) netwrite((unsigned long) flags,
|
||
sizeof(short), rmf);
|
||
|
||
temp = (unsigned long)
|
||
(flags==WINNER ? max_level : level);
|
||
(void) netwrite(temp, sizeof(short), rmf);
|
||
|
||
(void) netwrite((unsigned long) player.t_ctype,
|
||
sizeof(short), rmf);
|
||
|
||
(void) fwrite(thissys, 1,
|
||
strlen(thissys), rmf);
|
||
for (j=strlen(thissys); j<SYSLEN; j++)
|
||
putc('\0', rmf);
|
||
|
||
(void) fwrite(login, 1, strlen(login), rmf);
|
||
for (j=strlen(login); j<LOGLEN; j++)
|
||
putc('\0', rmf);
|
||
|
||
/* Close off the command */
|
||
(void) pclose(rmf);
|
||
}
|
||
}
|
||
_exit(0); /* Exit network process */
|
||
#endif
|
||
}
|
||
}
|
||
}
|
||
|
||
/*
|
||
* SCOREIT -- rogue -s option. Never started curses if this option.
|
||
* UPDATE -- network scoring update. Never started curses if this option.
|
||
* EDITSCORE -- want to delete or change a score.
|
||
*/
|
||
/* if (flags != SCOREIT && flags != UPDATE && prflags != EDITSCORE)
|
||
endwin(); */
|
||
|
||
if (flags != UPDATE) {
|
||
if (flags != SCOREIT) {
|
||
clear();
|
||
refresh();
|
||
endwin();
|
||
}
|
||
/*
|
||
* Print the list
|
||
*/
|
||
printf("\nTop %d Adventurers:\nRank Score\tName\n",
|
||
NUMSCORE);
|
||
for (scp = top_ten; scp <= &top_ten[NUMSCORE-1]; scp++) {
|
||
const char *class;
|
||
|
||
if (scp->sc_score != 0) {
|
||
class = char_class[scp->sc_ctype].name;
|
||
|
||
/* Make sure we have an in-bound reason */
|
||
if (scp->sc_flags > REASONLEN) scp->sc_flags = REASONLEN;
|
||
|
||
printf("%3d %10lu\t%s (%s)", (int) (scp - top_ten + 1),
|
||
scp->sc_score, scp->sc_name, class);
|
||
|
||
if (prflags == REALLIFE) printf(" [in real life %.*s!%.*s]",
|
||
SYSLEN, scp->sc_system, LOGLEN, scp->sc_login);
|
||
printf(":\n\t\t%s on level %d", reason[scp->sc_flags],
|
||
scp->sc_level);
|
||
|
||
switch (scp->sc_flags) {
|
||
case KILLED:
|
||
printf(" by");
|
||
killer = killname(scp->sc_monster);
|
||
printf(" %s", killer);
|
||
break;
|
||
|
||
case WINNER:
|
||
printf(" with the %s",
|
||
rel_magic[scp->sc_quest].mi_name);
|
||
break;
|
||
}
|
||
|
||
if (prflags == EDITSCORE)
|
||
{
|
||
fflush(stdout);
|
||
getstr(prbuf);
|
||
printf("\n");
|
||
if (prbuf[0] == 'd') {
|
||
for (sc2 = scp; sc2 < &top_ten[NUMSCORE-1]; sc2++)
|
||
*sc2 = *(sc2 + 1);
|
||
top_ten[NUMSCORE-1].sc_score = 0;
|
||
for (i = 0; i < NAMELEN; i++)
|
||
top_ten[NUMSCORE-1].sc_name[i] = rnd(255);
|
||
top_ten[NUMSCORE-1].sc_flags = RN;
|
||
top_ten[NUMSCORE-1].sc_level = RN;
|
||
top_ten[NUMSCORE-1].sc_monster = RN;
|
||
scp--;
|
||
}
|
||
else if (prbuf[0] == 'e') {
|
||
printf("Death type: ");
|
||
getstr(prbuf);
|
||
if (prbuf[0] == 'M' || prbuf[0] == 'm')
|
||
do {
|
||
scp->sc_monster =
|
||
makemonster(TRUE, "Editing", "choose");
|
||
} while (scp->sc_monster < 0); /* Force a choice */
|
||
else scp->sc_monster = getdeath();
|
||
clear();
|
||
refresh();
|
||
}
|
||
}
|
||
else printf("\n");
|
||
}
|
||
}
|
||
if ((flags != SCOREIT) && (flags != UPDATE)) {
|
||
printf("\n[Press return to exit]");
|
||
fflush(stdout);
|
||
fgets(prbuf,80,stdin);
|
||
}
|
||
/* if (prflags == EDITSCORE) endwin();*/ /* End editing windowing */
|
||
}
|
||
fseek(scoreboard, 0L, SEEK_SET);
|
||
/*
|
||
* Update the list file
|
||
*/
|
||
|
||
for(i = 0; i < NUMSCORE; i++)
|
||
{
|
||
memset(scoreline,0,100);
|
||
encwrite(top_ten[i].sc_name, NAMELEN, scoreboard);
|
||
encwrite(top_ten[i].sc_system, SYSLEN, scoreboard);
|
||
encwrite(top_ten[i].sc_login, LOGLEN, scoreboard);
|
||
sprintf(scoreline, " %lu %hd %hd %hd %hd %hd \n",
|
||
top_ten[i].sc_score, top_ten[i].sc_flags,
|
||
top_ten[i].sc_level, top_ten[i].sc_ctype,
|
||
top_ten[i].sc_monster, top_ten[i].sc_quest);
|
||
encwrite(scoreline,100,scoreboard);
|
||
}
|
||
|
||
fclose(scoreboard);
|
||
}
|
||
|
||
/*
|
||
* scorein:
|
||
* Convert a character string that has been translated from a
|
||
* score file by scoreout() back to a score file structure.
|
||
* num_bytes: Number of bytes of input that we want to convert
|
||
*/
|
||
void
|
||
scorein(unsigned char *input, struct sc_ent scores[], int num_bytes)
|
||
{
|
||
register int i, j;
|
||
unsigned long *lptr;
|
||
unsigned short *sptr;
|
||
unsigned char *cptr;
|
||
|
||
/* Convert a maximum of NUMSCORE entries */
|
||
for (i=0; num_bytes > 0 && i < NUMSCORE; num_bytes -= SCORELEN, i++) {
|
||
/* The long fields are first -- ordered low to high byte in input */
|
||
lptr = &scores[i].sc_score;
|
||
*lptr = ((unsigned long) *input++) & 0x000000ffL;
|
||
*lptr |= (((unsigned long) *input++) << 8) & 0x0000ff00L;
|
||
*lptr |= (((unsigned long) *input++) << 16) & 0x00ff0000L;
|
||
*lptr |= (((unsigned long) *input++) << 24) & 0xff000000L;
|
||
|
||
/* The short fields are next -- ordered low to high byte in input */
|
||
sptr = (unsigned short *) &scores[i].sc_flags;
|
||
*sptr = ((unsigned short) *input++) & 0xff;
|
||
*sptr |= (((unsigned short) *input++) << 8) & 0xff00;
|
||
|
||
sptr = (unsigned short *) &scores[i].sc_level;
|
||
*sptr = ((unsigned short) *input++) & 0xff;
|
||
*sptr |= (((unsigned short) *input++) << 8) & 0xff00;
|
||
|
||
sptr = (unsigned short *) &scores[i].sc_ctype;
|
||
*sptr = ((unsigned short) *input++) & 0xff;
|
||
*sptr |= (((unsigned short) *input++) << 8) & 0xff00;
|
||
|
||
sptr = (unsigned short *) &scores[i].sc_monster;
|
||
*sptr = ((unsigned short) *input++) & 0xff;
|
||
*sptr |= (((unsigned short) *input++) << 8) & 0xff00;
|
||
|
||
sptr = (unsigned short *) &scores[i].sc_quest;
|
||
*sptr = ((unsigned short) *input++) & 0xff;
|
||
*sptr |= (((unsigned short) *input++) << 8) & 0xff00;
|
||
|
||
/* Finally comes the char fields -- they're easy */
|
||
cptr = (unsigned char *) scores[i].sc_name;
|
||
for (j = 0; j < NAMELEN; j++) *cptr++ = *input++;
|
||
|
||
cptr = (unsigned char *) scores[i].sc_system;
|
||
for (j = 0; j < SYSLEN; j++) *cptr++ = *input++;
|
||
|
||
cptr = (unsigned char *) scores[i].sc_login;
|
||
for (j = 0; j < LOGLEN; j++) *cptr++ = *input++;
|
||
}
|
||
}
|
||
|
||
/*
|
||
* scoreout:
|
||
* Convert a score file structure to a character string. We do
|
||
* this for compatibility sake since some machines write out fields in
|
||
* different orders.
|
||
*/
|
||
void
|
||
scoreout(struct sc_ent scores[], unsigned char *output)
|
||
{
|
||
register int i, j;
|
||
unsigned long *lptr;
|
||
unsigned short *sptr;
|
||
unsigned char *cptr;
|
||
|
||
for (i=0; i<NUMSCORE; i++) {
|
||
/* The long fields are first -- ordered low to high byte in input */
|
||
lptr = &scores[i].sc_score;
|
||
for (j = 0; j < sizeof(unsigned long); j++)
|
||
*output++ = (unsigned char) ((*lptr >> 8*j) & 0xff);
|
||
|
||
/* The short fields are next -- ordered low to high byte in input */
|
||
sptr = (unsigned short *) &scores[i].sc_flags;
|
||
*output++ = (unsigned char) (*sptr & 0xff);
|
||
*output++ = (unsigned char) ((*sptr >> 8) & 0xff);
|
||
|
||
sptr = (unsigned short *) &scores[i].sc_level;
|
||
*output++ = (unsigned char) (*sptr & 0xff);
|
||
*output++ = (unsigned char) ((*sptr >> 8) & 0xff);
|
||
|
||
sptr = (unsigned short *) &scores[i].sc_ctype;
|
||
*output++ = (unsigned char) (*sptr & 0xff);
|
||
*output++ = (unsigned char) ((*sptr >> 8) & 0xff);
|
||
|
||
sptr = (unsigned short *) &scores[i].sc_monster;
|
||
*output++ = (unsigned char) (*sptr & 0xff);
|
||
*output++ = (unsigned char) ((*sptr >> 8) & 0xff);
|
||
|
||
sptr = (unsigned short *) &scores[i].sc_quest;
|
||
*output++ = (unsigned char) (*sptr & 0xff);
|
||
*output++ = (unsigned char) ((*sptr >> 8) & 0xff);
|
||
|
||
/* Finally comes the char fields -- they're easy */
|
||
cptr = (unsigned char *) scores[i].sc_name;
|
||
for (j = 0; j < NAMELEN; j++) *output++ = *cptr++;
|
||
|
||
cptr = (unsigned char *) scores[i].sc_system;
|
||
for (j = 0; j < SYSLEN; j++) *output++ = *cptr++;
|
||
|
||
cptr = (unsigned char *) scores[i].sc_login;
|
||
for (j = 0; j < LOGLEN; j++) *output++ = *cptr++;
|
||
}
|
||
}
|
||
|
||
/*
|
||
* showpack:
|
||
* Display the contents of the hero's pack
|
||
*/
|
||
void
|
||
showpack(char *howso)
|
||
{
|
||
reg char *iname;
|
||
reg int cnt, packnum;
|
||
reg struct linked_list *item;
|
||
reg struct object *obj;
|
||
|
||
idenpack();
|
||
cnt = 1;
|
||
clear();
|
||
mvprintw(0, 0, "Contents of your pack %s:\n",howso);
|
||
packnum = 'a';
|
||
for (item = pack; item != NULL; item = next(item)) {
|
||
obj = OBJPTR(item);
|
||
iname = inv_name(obj, FALSE);
|
||
mvprintw(cnt, 0, "%c) %s\n",packnum++,iname);
|
||
if (++cnt >= lines - 2 &&
|
||
next(item) != NULL) {
|
||
cnt = 1;
|
||
mvaddstr(lines - 1, 0, morestr);
|
||
refresh();
|
||
wait_for(' ');
|
||
clear();
|
||
}
|
||
}
|
||
mvprintw(cnt + 1,0,"--- %d Gold Pieces ---",purse);
|
||
refresh();
|
||
}
|
||
|
||
void
|
||
total_winner(void)
|
||
{
|
||
register struct linked_list *item;
|
||
register struct object *obj;
|
||
register int worth;
|
||
register char c;
|
||
register int oldpurse;
|
||
|
||
clear();
|
||
standout();
|
||
addstr(" \n");
|
||
addstr(" @ @ @ @ @ @@@ @ @ \n");
|
||
addstr(" @ @ @@ @@ @ @ @ @ \n");
|
||
addstr(" @ @ @@@ @ @ @ @ @ @@@ @@@@ @@@ @ @@@ @ \n");
|
||
addstr(" @@@@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ \n");
|
||
addstr(" @ @ @ @ @ @ @ @@@@ @ @ @@@@@ @ @ @ \n");
|
||
addstr(" @ @ @ @ @ @@ @ @ @ @ @ @ @ @ @ @ \n");
|
||
addstr(" @@@ @@@ @@ @ @ @ @@@@ @@@@ @@@ @@@ @@ @ \n");
|
||
addstr(" \n");
|
||
addstr(" Congratulations, you have made it to the light of day! \n");
|
||
standend();
|
||
addstr("\nYou have joined the elite ranks of those who have escaped the\n");
|
||
addstr("Dungeons of Doom alive. You journey home and sell all your loot at\n");
|
||
addstr("a great profit and are appointed leader of a ");
|
||
switch (player.t_ctype) {
|
||
case C_MAGICIAN:addstr("magician's guild.\n");
|
||
when C_FIGHTER: addstr("fighter's guild.\n");
|
||
when C_RANGER: addstr("ranger's guild.\n");
|
||
when C_CLERIC: addstr("monastery.\n");
|
||
when C_PALADIN: addstr("monastery.\n");
|
||
when C_MONK: addstr("monastery.\n");
|
||
when C_DRUID: addstr("monastery.\n");
|
||
when C_THIEF: addstr("thief's guild.\n");
|
||
when C_ASSASIN: addstr("assassin's guild.\n");
|
||
otherwise: addstr("tavern.\n");
|
||
}
|
||
mvaddstr(lines - 1, 0, spacemsg);
|
||
refresh();
|
||
wait_for(' ');
|
||
clear();
|
||
mvaddstr(0, 0, " Worth Item");
|
||
oldpurse = purse;
|
||
for (c = 'a', item = pack; item != NULL; c++, item = next(item))
|
||
{
|
||
obj = OBJPTR(item);
|
||
worth = get_worth(obj);
|
||
if (obj->o_group == 0)
|
||
worth *= obj->o_count;
|
||
whatis(item);
|
||
mvprintw(c - 'a' + 1, 0, "%c) %6d %s", c, worth, inv_name(obj, FALSE));
|
||
purse += worth;
|
||
}
|
||
mvprintw(c - 'a' + 1, 0," %5d Gold Pieces ", oldpurse);
|
||
refresh();
|
||
writelog(pstats.s_exp + (long) purse, WINNER, '\0');
|
||
score(pstats.s_exp + (long) purse, WINNER, '\0');
|
||
endwin();
|
||
#ifdef PC7300
|
||
endhardwin();
|
||
#endif
|
||
exit(0);
|
||
}
|
||
|
||
int
|
||
update(struct sc_ent top_ten[], unsigned long amount, short quest, char *whoami,
|
||
short flags, short level, short monst, short ctype, char *system,
|
||
char *login)
|
||
{
|
||
register struct sc_ent *scp, *sc2;
|
||
int retval=0; /* 1 if a change, 0 otherwise */
|
||
|
||
for (scp = top_ten; scp < &top_ten[NUMSCORE]; scp++) {
|
||
if (amount >= scp->sc_score)
|
||
break;
|
||
|
||
#ifdef LIMITSCORE /* Limits player to one entry per class per uid */
|
||
/* If this good score is the same class and uid, then forget it */
|
||
if (strncmp(scp->sc_login, login, LOGLEN) == 0 &&
|
||
scp->sc_ctype == ctype &&
|
||
strncmp(scp->sc_system, system, SYSLEN) == 0) return(0);
|
||
#endif
|
||
}
|
||
|
||
if (scp < &top_ten[NUMSCORE])
|
||
{
|
||
retval = 1;
|
||
|
||
#ifdef LIMITSCORE /* Limits player to one entry per class per uid */
|
||
/* If a lower scores exists for the same login and class, delete it */
|
||
for (sc2 = scp ;sc2 < &top_ten[NUMSCORE]; sc2++) {
|
||
if (sc2->sc_score == 0L) break; /* End of useful scores */
|
||
|
||
if (strncmp(sc2->sc_login, login, LOGLEN) == 0 &&
|
||
sc2->sc_ctype == ctype &&
|
||
strncmp(sc2->sc_system, system, SYSLEN) == 0) {
|
||
/* We want to delete this entry */
|
||
while (sc2 < &top_ten[NUMSCORE-1]) {
|
||
*sc2 = *(sc2+1);
|
||
sc2++;
|
||
}
|
||
sc2->sc_score = 0L;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
for (sc2 = &top_ten[NUMSCORE-1]; sc2 > scp; sc2--)
|
||
*sc2 = *(sc2-1);
|
||
scp->sc_score = amount;
|
||
scp->sc_quest = quest;
|
||
strncpy(scp->sc_name, whoami, NAMELEN);
|
||
scp->sc_flags = flags;
|
||
scp->sc_level = level;
|
||
scp->sc_monster = monst;
|
||
scp->sc_ctype = ctype;
|
||
strncpy(scp->sc_system, system, SYSLEN);
|
||
strncpy(scp->sc_login, login, LOGLEN);
|
||
}
|
||
|
||
return(retval);
|
||
}
|