#include <malloc.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include "kernel.h"
#include "stdinc.h"
#define get_newline(f) while (getc(f) != '\n')
#ifdef INTERMUD
extern int boot_intermud(FILE *f, char *fname);
#endif
/*
extern char *sys_errlist[];
*/
extern int errno;
extern char *Pflags[];
extern char *WizLevels[];
static void boot_world (void);
static int boot_players (void);
static int boot_mobiles (FILE * f, char *fname);
static int boot_levels (FILE * f, char *fname);
static int boot_locations (FILE * f, char *fname);
static int boot_objects (FILE * f, char *fname);
static int boot_pflags (FILE * f, char *fname);
static int boot_verbs (FILE * f, char *fname);
static int boot_zones (FILE * f, char *fname);
static int boot_id_counter (void);
static Boolean read_pflags (FILE * f, PFLAGS p[]);
static char *get_string (FILE * f);
#define ID_CNT_START 200000L
char *PFT[] =
{"PflagApprentice", "MaskApprentice",
"PflagEmeriti", "MaskEmeriti",
"PflagWizard", "MaskWizard",
"PflagSenior", "MaskSenior",
"PflagArchwizard", "MaskArchwizard",
"PflagHighArch", "MaskHighArch",
"PflagDemigod", "MaskDemigod",
"PflagHighDemi", "MaskHighDemi",
"PflagGod", "MaskGod",
"PflagMaster", "MaskMaster",
"Comment",
TABLE_END};
int
bootstrap (void)
{
FILE *bootf, *f;
int mem_used = 0;
int tot_used = 0;
char *y, x[128];
boot_world ();
boot_bboards ();
mem_used = boot_id_counter ();
printf ("Bootstrap... 'players' used %d bytes.\n",
tot_used = boot_players ());
if ((bootf = (FILE *) bopen (BOOTSTRAP)) == NULL)
{
mudlog ("bopen: Bootstrap failed for \"" BOOTSTRAP "\".\n");
mudlog ("bopen: %s.\n", sys_errlist[errno]);
return -1;
}
while (fgets (x, sizeof x, bootf))
{
if ((y = strchr (x, '\n')))
*y = '\0';
printf ("Bootstrap... %s ", x);
if ((y = strchr (x, ':')) == NULL)
{
printf ("\nInvalid bootstrap declaration\n");
return -1;
}
if ((f = (FILE *) bopen (++y)) == NULL)
{
printf ("---->Can't open %c file %s ", x[0], y);
}
switch (x[0])
{
case 'A':
mem_used = boot_extern (f, y);
break;
case 'C':
mem_used = boot_mobiles (f, y);
break;
case 'E':
mem_used = boot_levels (f, y);
break;
case 'H':
mem_used = boot_hours (f, y);
break;
#ifdef INTERMUD
case 'I': mem_used = boot_intermud(f, y); break;
#endif
case 'L':
mem_used = boot_locations (f, y);
break;
case 'O':
mem_used = boot_objects (f, y);
break;
case 'P':
mem_used = boot_pflags (f, y);
break;
case 'V':
mem_used = boot_verbs (f, y);
break;
case 'W':
set_wizfile (y);
mem_used = boot_wizlist (f, y);
break;
case 'Z':
mem_used = boot_zones (f, y);
break;
}
if (f != NULL)
bclose (f);
if (mem_used < 0)
{
fclose (bootf);
return mem_used;
}
printf ("used %d bytes.\n", mem_used);
tot_used += mem_used;
}
fclose (bootf);
printf ("\nA total of %d bytes used.\n", tot_used);
return tot_used;
}
static void
boot_world (void)
{
WORLD_REC *w = &the_world_rec;
w->w_weather = 0;
w->w_lock = 0;
w->w_mob_stop = 0;
w->w_peace = 0;
w->w_max_users = max_players;
w->w_tournament = 0;
last_healall = 0;
}
static int
boot_players (void)
{
int i;
PLAYER_REC *p = players = NEW (PLAYER_REC, max_players);
for (i = 0; i < max_players; i++, p++)
{
p->inp_handler = NULL;
p->iamon = False;
}
return sizeof (PLAYER_REC) * max_players;
}
static int
boot_mobiles (FILE * f, char *fname)
{
int mem_used = 0;
int new_mem;
int i;
int mobs_loaded;
if (f == NULL)
return -1;
numchars = max_players;
ublock = NEW (UBLOCK_REC, char_array_len = numchars + 150);
mem_used += sizeof (UBLOCK_REC) * char_array_len;
for (i = 0; i < max_players; i++)
{
setpname (i, "");
pnum (i) = -1;
}
if ((new_mem = load_mobiles (-1, f, &mobs_loaded, NULL)) < 0)
return -1;
num_const_chars = mobs_loaded + max_players;
return mem_used + new_mem;
}
/* Read mobile spesifications from a file and load them into the game in the
* zone specified. If it is -1, then use the zone specifications given in
* the file for each mobile sepeartely. Return the number of mobiles actually
* read, the total number of mobiles in the file,
* and the amount of any extra memory allocated as the function value.
* (-1 on error).
*/
int
load_mobiles (int zone, FILE * f, int *loaded, int *infile)
{
int ct, c, i;
int mem_used = 0;
int num_ld, num_infile;
char x[256];
char *p;
fgets (x, sizeof x, f);
if ((num_ld = num_infile = atoi (x)) <= 0)
return -1;
if (numchars + num_infile > char_array_len)
{
int oldlen = char_array_len;
if (numchars + num_infile > GLOBAL_MAX_MOBS)
return -1;
char_array_len = numchars + 75 + num_infile;
ublock = resize_array (ublock, sizeof (Mobile),
oldlen, char_array_len);
mem_used += sizeof (Mobile) * (char_array_len - oldlen);
}
for (ct = numchars; ct < numchars + num_ld; ct++)
{
ptemporary (ct) = False;
for (p = pname (ct), i = 0;
(c = getc (f)) != '^' && i < MNAME_LEN; *p++ = c, i++);
*p = '\0';
get_newline (f);
if (fscanf (f, "%ld %d %d %ld %d %d %d %d %d %d %d",
&mob_id (ct), &pnum (ct),
&pzone (ct),
&ploc_reset (ct), &pstr_reset (ct),
&pdam_reset (ct), &pagg_reset (ct), &parmor_reset (ct),
&pspeed_reset (ct), &pvis_reset (ct), &pwimpy_reset (ct))
!= 11)
return -1;
plev_reset (ct) = -1; /* Negative level for all mobiles. */
get_newline (f);
/* If the mobile is allready in the game, skip that record
*/
if (mob_id (ct) >= ID_CNT_START &&
!insert_entry (mob_id (ct), ct, &id_table))
{
get_newline (f);
get_newline (f);
for (i = 1; i <= 2; i++)
{
while (getc (f) != '^');
}
get_newline (f);
get_newline (f);
--ct;
--num_ld;
continue;
}
fscanf (f, "0x%8lx 0x%8lx:0x%8lx:0x%8lx",
&sflags_reset (ct),
&pflags_reset (ct).b3, &pflags_reset (ct).b2, &pflags_reset (ct).b1);
get_newline (f);
fscanf (f, "0x%8lx:0x%8lx",
&mflags_reset (ct).h, &mflags_reset (ct).l);
get_newline (f);
pname_reset (ct) = COPY (pname (ct));
pftxt (ct) = get_string (f);
mem_used += strlen (pftxt (ct)) + strlen (pname_reset (ct)) + 2;
if (EMPTY (pexam (ct) = get_string (f)))
{
free (pexam (ct));
pexam (ct) = NULL;
}
else
{
mem_used += strlen (pexam (ct));
}
get_newline (f);
init_intset (pinv (ct), 4);
mem_used += get_set_mem_usage (pinv (ct));
if (zone > -1)
pzone (ct) = zone;
zadd_mob (ct, pzone (ct));
}
numchars += num_ld;
if (loaded != NULL)
*loaded = num_ld;
if (infile != NULL)
*infile = num_infile;
return mem_used;
}
static int
boot_levels (FILE * f, char *fname)
{
int i, v, ct;
if (f == NULL)
return -1;
fscanf (f, "%d", &ct);
get_newline (f);
if (ct != LVL_APPREN)
{
printf ("Number of levels in levels file (%d) doesn't match LVL_APPREN "
"(%d).\n", ct, LVL_APPREN);
return -1;
}
for (i = 1; i <= ct; i++)
{
fscanf (f, "%d", &v);
get_newline (f);
levels[i] = v;
}
return 0;
}
static int
boot_locations (FILE * f, char *fname)
{
int mem_used = 0;
int new_mem;
if (f == NULL)
return -1;
numloc = 0;
room_data = NEW (Location, loc_array_len = 800);
mem_used += sizeof (Location) * loc_array_len;
if ((new_mem = load_locations (-1, f, &num_const_locs, NULL)) < 0)
return -1;
return mem_used + new_mem;
}
/* Load locations from file into the game. Return the number of rooms the
* file contained, and the number actually loaded. Return mem-used for value.
*/
int
load_locations (int zone, FILE * f, int *loaded, int *infile)
{
int ct, mem_used = 0;
int num_ld, num_infile;
Location *r;
char x[128];
int i;
fgets (x, sizeof x, f);
if ((num_ld = num_infile = atoi (x)) <= 0)
return -1;
if (numloc + num_infile > loc_array_len)
{
int oldlen = loc_array_len;
if (numloc + num_infile > GLOBAL_MAX_LOCS)
return -1;
loc_array_len = 100 + numloc + num_infile;
room_data = resize_array (room_data, sizeof (Location),
oldlen, loc_array_len);
mem_used += sizeof (Location) * (loc_array_len - oldlen);
}
for (r = room_data + numloc, ct = numloc;
ct < numloc + num_ld; ct++, r++)
{
if (fscanf (f, "%ld %d %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld",
&r->id,
&r->zone,
&r->r_exit_reset[0], &r->r_exit_reset[1],
&r->r_exit_reset[2], &r->r_exit_reset[3],
&r->r_exit_reset[4], &r->r_exit_reset[5],
&r->r_exit_reset[6], &r->r_exit_reset[7],
&r->r_exit_reset[8], &r->r_exit_reset[9])
!= 12)
return -1;
get_newline (f);
fscanf (f, "0x%8lx", &r->r_flags_reset);
get_newline (f);
if (r->id >= ID_CNT_START &&
!insert_entry (r->id, convroom (ct), &id_table))
{
for (i = 1; i <= 2; i++)
{
while (getc (f) != '^');
}
get_newline (f);
--r;
--ct;
--num_ld;
continue;
}
r->temporary = False;
r->touched = True;
r->r_short = get_string (f);
r->r_long = get_string (f);
mem_used += strlen (r->r_short) + strlen (r->r_long) + 2;
init_intset (&r->objects, 5);
init_intset (&r->mobiles, 3);
init_intset (&r->exits_to_me, 3);
if (zone > -1)
r->zone = zone;
zadd_loc (convroom (ct), r->zone);
mem_used += get_set_mem_usage (&r->objects)
+ get_set_mem_usage (&r->mobiles)
+ get_set_mem_usage (&r->exits_to_me);
}
numloc += num_ld;
if (loaded != NULL)
*loaded = num_ld;
if (infile != NULL)
*infile = num_infile;
return mem_used;
}
static int
boot_objects (FILE * f, char *fname)
{
int mem_used = 0;
int new_mem;
if (f == NULL)
return -1;
numobs = 0;
objects = NEW (Object, obj_array_len = 500);
mem_used += sizeof (Object) * 500;
if ((new_mem = load_objects (-1, f, &num_const_obs, NULL)) < 0)
{
return -1;
}
return mem_used + new_mem;
}
/* Read object spesifications from a file and load them into the game in the
* zone specified. If it is -1, then use the zone specifications given in
* the file for each object sepeartely. Return the number of objects actually
* read, the total number of objects in the file,
* and the amount of any extra memory allocated as the function value.
* (-1 on error).
*/
int
load_objects (int zone, FILE * f, int *loaded, int *infile)
{
int j, ct, mem_used = 0;
int num_ld, num_infile;
char name[64], altname[64];
long int link;
j = fscanf (f, "%d", &num_infile);
if (j != 1 || (num_ld = num_infile) <= 0)
{
mudlog ("BOOTSTRAP ERROR: o.1");
return -1;
}
get_newline (f);
if (numobs + num_infile > obj_array_len)
{
int oldlen = obj_array_len;
if (numobs + num_infile > GLOBAL_MAX_OBJS)
return -1;
obj_array_len = 75 + numobs + num_infile;
objects = resize_array (objects, sizeof (Object),
oldlen, obj_array_len);
mem_used += sizeof (Object) * (obj_array_len - oldlen);
}
for (ct = numobs; ct < numobs + num_ld; ct++)
{
if (fscanf (f, "%s %s %d %ld %d %ld "
"%d %d %ld %d %d %d %ld %d %d %d %*d",
name, altname,
&ozone (ct), &obj_id (ct), &onum (ct),
&link,
&ovis_reset (ct), &ocarrf_reset (ct), &oloc_reset (ct),
&state_reset (ct), &odamage_reset (ct),
&oarmor_reset (ct), &obits_reset (ct),
&omaxstate (ct), &ovalue_reset (ct),
&osize_reset (ct))
!= 16)
{
mudlog ("BOOTSTRAP ERROR: o.2 [%s %s]", name, altname);
return -1;
}
get_newline (f);
/* If it allready existed, skip it.
*/
if (obj_id (ct) >= ID_CNT_START &&
!insert_entry (obj_id (ct), ct, &id_table))
{
for (j = 1; j <= 5; j++)
{
while (getc (f) != '^');
}
get_newline (f);
get_newline (f);
--ct, --num_ld;
continue;
}
oname (ct) = COPY (name);
oaltname (ct) = COPY (altname);
if (link <= -1)
olinked (ct) = -1;
else if (link < numobs + num_infile)
olinked (ct) = link;
else if ((link = lookup_entry (link, &id_table)) != NOT_IN_TABLE)
{
olinked (ct) = link;
olinked (link) = ct;
}
else
olinked (ct) = -1;
mem_used += strlen (name) + strlen (altname) + 2;
for (j = 0; j < 4; j++)
{
olongt (ct, j) = get_string (f);
mem_used += strlen (olongt (ct, j)) + 1;
}
if (zone == -1)
{
oexam_text (ct) = NULL;
oexamine (ct) = ftell (f);
for (j = 1; fgetc (f) != '^'; j++);
if (j == 1)
oexamine (ct) = 0;
}
else
{
oexam_text (ct) = get_string (f);
oexamine (ct) = 0;
}
otemporary (ct) = False;
init_intset (oinv (ct),
xtstbit (obits_reset (ct), OFL_CONTAINER) ? 10 : 0);
if (zone > -1)
ozone (ct) = zone;
zadd_obj (ct, ozone (ct));
mem_used += get_set_mem_usage (oinv (ct));
}
numobs += num_ld;
if (loaded != NULL)
*loaded = num_ld;
if (infile != NULL)
*infile = num_infile;
return mem_used;
}
static int
boot_pflags (FILE * f, char *fname)
{
WORLD_REC *w = &the_world_rec;
PFLAGS p[20];
int x, y;
if (f == NULL)
return -1;
if (!read_pflags (f, p))
{
printf ("\nIllegal syntax in %s.\n", fname);
return -1;
}
for (x = y = 0; x < 10; ++x)
{
w->w_pflags[x] = p[y++];
w->w_mask[x] = p[y++];
}
return 0;
}
static int
boot_verbs (FILE * f, char *fname)
{
int v, ct, mem_used;
char x[64];
if (f == NULL)
return -1;
fscanf (f, "%d", &v);
mem_used = sizeof (char *) * (v + 1);
mem_used = sizeof (int) * (v + 1);
verbtxt = NEW (char *, v + 1);
verbnum = NEW (int, v + 1);
for (ct = 0; ct < v; ct++)
{
fscanf (f, "%s %d", x, &verbnum[ct]);
verbtxt[ct] = COPY (x);
mem_used += strlen (x) + 1;
}
verbtxt[ct] = NULL;
return mem_used;
}
static int
boot_zones (FILE * f, char *fname)
{
int ct, mem_used;
char x[64];
if (f == NULL)
return -1;
fgets (x, sizeof x, f);
numzon = num_const_zon = atoi (x);
zon_array_len = num_const_zon + 20;
zoname = NEW (ZONE, zon_array_len);
mem_used = sizeof (ZONE) * zon_array_len;
for (ct = 0; ct < num_const_zon; ct++)
{
fscanf (f, "%s %*d", x);
zname (ct) = COPY (x);
init_intset (zlocs (ct), 15);
init_intset (zmobs (ct), 5);
init_intset (zobjs (ct), 10);
ztemporary (ct) = False;
mem_used += strlen (x) + 1;
/* add the space for the intsets later */
}
return mem_used;
}
static char *
id_counter_file ()
{
return ID_COUNTER;
}
/* Boot ID counter and initialize ID table.
*/
static int
boot_id_counter (void)
{
int mem_used = 0;
FILE *f = fopen (id_counter_file (), "r");
printf ("Bootstrap... ID-table & ID-counter ");
if (f == NULL)
{
printf ("(Creating %s)", id_counter_file ());
if ((f = fopen (id_counter_file (), "w")) == NULL)
{
printf ("fopen: Bootstrap failed for \"%s\".\n",
id_counter_file ());
perror ("fopen");
exit (1);
}
fprintf (f, "%ld", id_counter = ID_CNT_START);
}
else
{
int status = fscanf (f, "%ld", &id_counter);
if (status != 1 || id_counter < ID_CNT_START)
{
printf ("Erroneous contents in %s\n", id_counter_file ());
exit (1);
}
}
fclose (f);
init_inttable (&id_table, 1024);
printf ("used %d bytes.\n", mem_used = get_table_mem_usage (&id_table));
return mem_used;
}
Boolean
save_id_counter (void)
{
FILE *f;
int status;
if ((f = fopen (id_counter_file (), "w")) == NULL)
{
progerror (id_counter_file ());
return False;
}
status = fprintf (f, "%ld\n", id_counter);
fclose (f);
if (status == EOF)
{
progerror (id_counter_file ());
return False;
}
return True;
}
/* Is this a character legal in a Pflag ?
*/
static Boolean
islegal (int c)
{
return isalpha (c) || c == '/';
}
/*
* ** Read pflags.
*/
static Boolean
read_pflags (FILE * F, PFLAGS p[])
{
int x; /* 0 = PX, MX, PW, MW, PA, MA, PD, MD, PG, MG */
int y;
char *s;
PFLAGS f;
int k, v;
int c;
int w;
int i;
char b[2048];
f.b3 = f.b2 = f.b1 = 0;
w = -1;
for (i = 0; i < 20; i++)
{
p[i].b3 = p[i].b2 = p[i].b1 = 0;
}
for (k = getc (F); k != EOF; k = getc (F))
{
if (!islegal (k))
continue;
for (s = b; islegal (k); k = getc (F))
*s++ = k;
*s = 0;
if (k != ':' || (x = tlookup (b, PFT)) == -1)
return False;
if (x >= 20)
{
while ((k = getc (F)) != EOF && k != '\n');
if (k == EOF)
break;
continue;
}
if (x < w)
return False;
y = 0;
w = x;
while ((c = getc (F)) != ';')
{
if (c == EOF)
return False;
if (c == '+')
{
y = 1;
continue;
}
else if (c == '-')
{
y = -1;
continue;
}
else if (!islegal (c))
{
y = 0;
continue;
}
for (s = b; islegal (c); c = getc (F))
{
*s++ = c;
}
ungetc (c, F);
*s = 0;
if ((v = tlookup (b, Pflags)) == -1)
{
printf ("\nUnknown Pflag: %s.", b);
return False;
}
if (v >= 64)
{
k = 1 << (v-64);
if (y>0)
{
p[w].b3 |= k;
}
else if (y<0)
{
p[w].b3 &= ~k;
}
else
{
for (i=w; i <2*MAX_LEV_IMM; i += 2)
{
p[i].b3 |= k;
}
}
}
else if (v >= 32)
{
k = 1 << (v - 32);
if (y>0)
{
p[w].b2 |= k;
}
else if (y < 0)
{
p[w].b2 &= ~k;
}
else
{
for (i=w; i < 2*MAX_LEV_IMM; i += 2)
{
p[i].b2 |= k;
}
}
}
else
{
k = 1 << v;
if (y > 0)
{
p[w].b1 |= ~k;
}
else if (y < 0)
{
p[w].b1 &= ~k;
}
else
{
for (i = w; i < 2*MAX_LEV_IMM; i += 2)
{
p[i].b1 |= k;
}
}
}
y = 0;
}
}
return (w >= 0);
}
static char *
get_string (FILE * f)
{
char *y;
char x[2048];
for (y = x; (*y = fgetc (f)) != '^'; y++);
*y = 0;
get_newline (f);
return COPY (x);
}