/*
* rest_worm()
*
* Restore the worm information from the save file. Called from restore.c
*/
void
rest_worm(struct memfile *mf, struct level *lev)
{
int i, j, count;
struct wseg *curr, *temp;
for (i = 1; i < MAX_NUM_WORMS; i++) {
count = mread32(mf);
if (!count)
continue; /* none */
/* Get the segments. */
for (curr = NULL, j = 0; j < count; j++) {
temp = malloc(sizeof (struct wseg));
temp->nseg = NULL;
temp->wx = mread8(mf);
temp->wy = mread8(mf);
if (curr)
curr->nseg = temp;
else
lev->wtails[i] = temp;
curr = temp;
}
lev->wgrowtime[i] = mread32(mf);
lev->wheads[i] = curr;
}
}
void restore_oracles(struct memfile *mf)
{
int i;
oracle_cnt = mread32(mf);
if (oracle_cnt) {
oracle_loc = malloc(oracle_cnt * sizeof(int));
for (i = 0; i < oracle_cnt; i++)
oracle_loc[i] = mread32(mf);
oracle_flg = 1; /* no need to call init_oracles() */
}
}
/* this used to be based on file date and somewhat OS-dependant,
but now examines the initial part of the file's contents */
boolean uptodate(struct memfile *mf, const char *name)
{
struct version_info vers_info;
boolean verbose = name ? TRUE : FALSE;
vers_info.incarnation = mread32(mf);
vers_info.feature_set = mread32(mf);
vers_info.entity_count = mread32(mf);
if (!check_version(&vers_info, name, verbose))
return FALSE;
return TRUE;
}
void
restore_history(struct memfile *mf)
{
int i, len;
mfmagic_check(mf, HISTORY_MAGIC);
histcount = mread32(mf);
histevents = malloc(histcount * sizeof (struct histevent));
for (i = 0; i < histcount; i++) {
histevents[i].when = mread32(mf);
histevents[i].hidden = mread32(mf);
len = mread32(mf);
mread(mf, histevents[i].what, len);
}
}
/*
* Pull in the structures from disk, but don't recalculate the object
* pointers.
*/
void
restore_light_sources(struct memfile *mf, struct level *lev)
{
int count;
intptr_t id;
/* we need to restore and preserve order *but* we don't need
* to preserve the absolute order, only the relative orders of all
* global lights and all local lights---this is because global
* lights are for stored on the level and moved around as you do.
* As a result, they are saved in different places, and consequently
* it will *not* cause a desync as long as relative order is preserved.
* So it doesn't actually matter that we retain relative order to other
* light sources on the level, only that we restore the light sources here
* in reverse order. Inserting immediately after the first light leads to
* the simplest code.
*/
light_source *ls, *prev = lev->lev_lights, *rest = prev ? prev->next : NULL;
/* restore elements */
count = mread32(mf);
while (count-- > 0) {
ls = malloc(sizeof (light_source));
ls->type = mread32(mf);
ls->range = mread16(mf);
ls->flags = mread16(mf);
id = mread32(mf);
ls->id = (void *)id;
ls->x = mread8(mf);
ls->y = mread8(mf);
ls->next = rest;
if (prev)
prev->next = ls;
else
lev->lev_lights = ls;
prev = ls;
}
}
/*
* Pull in the structures from disk, but don't recalculate the object
* pointers.
*/
void restore_light_sources(struct memfile *mf, struct level *lev)
{
int count;
long id;
light_source *ls;
/* restore elements */
count = mread32(mf);
while (count-- > 0) {
ls = malloc(sizeof(light_source));
ls->type = mread32(mf);
ls->range = mread16(mf);
ls->flags = mread16(mf);
id = mread32(mf); /* prevent: "cast to pointer from integer of different size" */
ls->id = (void*)id;
ls->x = mread8(mf);
ls->y = mread8(mf);
ls->next = lev->lev_lights;
lev->lev_lights = ls;
}
}
/*
* rest_rooms : That's for restoring rooms. Read the rooms structure from
* the disk.
*/
void
rest_rooms(struct memfile *mf, struct level *lev)
{
short i;
mfmagic_check(mf, ROOMS_MAGIC); /* "RDAT" */
lev->nroom = mread32(mf);
lev->nsubroom = 0;
for (i = 0; i < lev->nroom; i++) {
rest_room(mf, lev, &lev->rooms[i]);
lev->rooms[i].resident = NULL;
}
lev->rooms[lev->nroom].hx = -1; /* restore ending flags */
lev->subrooms[lev->nsubroom].hx = -1;
}
void restore_steal(struct memfile *mf)
{
stealoid = mread32(mf);
stealmid = mread32(mf);
}
struct obj *restore_obj(struct memfile *mf)
{
unsigned int oflags;
char namelen;
struct obj *otmp;
mfmagic_check(mf, OBJ_MAGIC);
namelen = mread32(mf);
otmp = newobj(namelen);
memset(otmp, 0, namelen + sizeof(struct obj));
otmp->o_id = mread32(mf);
otmp->owt = mread32(mf);
otmp->quan = mread32(mf);
otmp->corpsenm = mread32(mf);
otmp->oeaten = mread32(mf);
otmp->age = mread32(mf);
otmp->owornmask = mread32(mf);
oflags = mread32(mf);
otmp->otyp = mread16(mf);
otmp->ox = mread8(mf);
otmp->oy = mread8(mf);
otmp->spe = mread8(mf);
otmp->oclass = mread8(mf);
otmp->invlet = mread8(mf);
otmp->oartifact = mread8(mf);
otmp->where = mread8(mf);
otmp->timed = mread8(mf);
otmp->cobj = mread8(mf) ? (void*)1 : NULL; /* set the pointer to 1 if there will be contents */
otmp->onamelth = namelen;
otmp->cursed = (oflags >> 31) & 1;
otmp->blessed = (oflags >> 30) & 1;
otmp->unpaid = (oflags >> 29) & 1;
otmp->no_charge = (oflags >> 28) & 1;
otmp->known = (oflags >> 27) & 1;
otmp->dknown = (oflags >> 26) & 1;
otmp->bknown = (oflags >> 25) & 1;
otmp->rknown = (oflags >> 24) & 1;
otmp->oeroded = (oflags >> 22) & 3;
otmp->oeroded2 = (oflags >> 20) & 3;
otmp->oerodeproof = (oflags >> 19) & 1;
otmp->olocked = (oflags >> 18) & 1;
otmp->obroken = (oflags >> 17) & 1;
otmp->otrapped = (oflags >> 16) & 1;
otmp->recharged = (oflags >> 13) & 7;
otmp->lamplit = (oflags >> 12) & 1;
otmp->greased = (oflags >> 11) & 1;
otmp->oattached = (oflags >> 9) & 3;
otmp->in_use = (oflags >> 8) & 1;
otmp->was_thrown = (oflags >> 7) & 1;
otmp->bypass = (oflags >> 6) & 1;
if (otmp->onamelth)
mread(mf, ONAME(otmp), otmp->onamelth);
if (otmp->oattached == OATTACHED_MONST) {
struct monst *mtmp = restore_mon(mf);
int monlen = sizeof(struct monst) + mtmp->mnamelth + mtmp->mxlth;
otmp = realloc_obj(otmp, monlen, mtmp, otmp->onamelth, ONAME(otmp));
dealloc_monst(mtmp);
} else if (otmp->oattached == OATTACHED_M_ID) {
unsigned int mid = mread32(mf);
otmp = obj_attach_mid(otmp, mid);
}
return otmp;
}
void
rest_regions(struct memfile *mf, struct level *lev, boolean ghostly)
{ /* If a bones file restore */
int i, j;
unsigned len1, len2;
long tmstamp;
char *msg_buf;
struct region *r;
free_regions(lev); /* Just for security */
mfmagic_check(mf, REGION_MAGIC);
tmstamp = save_decode_32(mread32(mf), moves, moves);
if (ghostly)
tmstamp = 0;
else
tmstamp = (moves - tmstamp);
lev->n_regions = mread32(mf);
lev->max_regions = lev->n_regions;
if (lev->n_regions > 0)
lev->regions = malloc(sizeof (struct region *) * lev->n_regions);
for (i = 0; i < lev->n_regions; i++) {
lev->regions[i] = malloc(sizeof (struct region));
r = lev->regions[i];
memset(r, 0, sizeof (struct region));
r->lev = lev;
restore_rect(mf, &r->bounding_box);
r->attach_2_m = mread32(mf);
r->effect_id = mread32(mf);
r->arg = mread32(mf);
r->nrects = mread16(mf);
if (r->nrects > 0)
r->rects = malloc(sizeof (struct nhrect) * r->nrects);
for (j = 0; j < r->nrects; j++)
restore_rect(mf, &r->rects[j]);
r->ttl = mread16(mf);
r->expire_f = mread16(mf);
r->can_enter_f = mread16(mf);
r->enter_f = mread16(mf);
r->can_leave_f = mread16(mf);
r->leave_f = mread16(mf);
r->inside_f = mread16(mf);
r->n_monst = mread16(mf);
r->max_monst = r->n_monst;
r->player_flags = mread8(mf);
r->attach_2_u = mread8(mf);
r->visible = mread8(mf);
if (r->n_monst > 0)
r->monsters = malloc(sizeof (unsigned) * r->n_monst);
for (j = 0; j < r->n_monst; j++)
r->monsters[j] = mread32(mf);
len1 = mread16(mf);
len2 = mread16(mf);
if (len1 > 0) {
msg_buf = malloc(len1);
mread(mf, msg_buf, len1);
msg_buf[len1 - 1] = '\0';
r->enter_msg = msg_buf;
}
if (len2 > 0) {
msg_buf = malloc(len2);
mread(mf, msg_buf, len2);
msg_buf[len2 - 1] = '\0';
r->leave_msg = msg_buf;
}
/* check for expired region */
if (r->ttl >= 0)
r->ttl = (r->ttl > tmstamp) ? r->ttl - tmstamp : 0;
if (ghostly) { /* settings pertained to old player */
clear_hero_inside(r);
clear_heros_fault(r);
}
}
for (i = lev->n_regions - 1; i >= 0; i--)
if (ghostly && lev->regions[i]->n_monst > 0)
reset_region_mids(lev->regions[i]);
}
