/*
* Read and discard all fields of an unknown extension.
*/
static errr rd_unknown_extension(void)
{
byte tmp8u;
u16b tmp16u;
s16b tmp16s;
u32b tmp32u;
s32b tmp32s;
char string[1024];
while (TRUE)
{
/* Read field type */
rd_byte(&tmp8u);
/* End mark? */
if (tmp8u == EXTENSION_TYPE_END) break;
/* Discard field depending on type */
switch(tmp8u)
{
case EXTENSION_TYPE_U32B: rd_u32b(&tmp32u); break;
case EXTENSION_TYPE_S32B: rd_s32b(&tmp32s); break;
case EXTENSION_TYPE_U16B: rd_u16b(&tmp16u); break;
case EXTENSION_TYPE_S16B: rd_s16b(&tmp16s); break;
case EXTENSION_TYPE_STRING: rd_string(string, sizeof(string)); break;
case EXTENSION_TYPE_BYTE: rd_byte(&tmp8u); break;
/* Garbage? */
default: return (-1);
}
}
/* Success */
return (0);
}
/*
* Read a monster
*/
static void rd_monster(monster_type *m_ptr)
{
byte tmp8u;
/* Read the monster race */
rd_s16b(&m_ptr->r_idx);
/* Read the other information */
rd_byte(&m_ptr->fy);
rd_byte(&m_ptr->fx);
rd_s16b(&m_ptr->hp);
rd_s16b(&m_ptr->maxhp);
rd_s16b(&m_ptr->csleep);
rd_byte(&m_ptr->mspeed);
rd_s16b(&m_ptr->energy_need);
rd_byte(&m_ptr->hasted);
rd_byte(&m_ptr->slowed);
rd_byte(&m_ptr->stunned);
rd_byte(&m_ptr->confused);
rd_byte(&m_ptr->monfear);
rd_byte(&m_ptr->invulner);
rd_u32b(&m_ptr->smart);
rd_s16b(&m_ptr->target_y);
rd_s16b(&m_ptr->target_x);
rd_u32b(&m_ptr->flags);
rd_byte(&tmp8u);
}
static int rd_quests(void)
{
int i;
u16b tmp16u;
/* Load the Quests */
rd_u16b(&tmp16u);
/* Incompatible save files */
if (tmp16u > MAX_Q_IDX)
{
note(format("Too many (%u) quests!", tmp16u));
return (-1);
}
/* Load the Quests */
for (i = 0; i < tmp16u; i++)
{
byte tmp8u;
rd_byte(&tmp8u);
q_list[i].level = tmp8u;
rd_byte(&tmp8u);
rd_byte(&tmp8u);
rd_byte(&tmp8u);
}
return 0;
}
static int rd_player_spells(void)
{
int i;
u16b tmp16u;
int cnt;
/* Read the number of spells */
rd_u16b(&tmp16u);
if (tmp16u > PY_MAX_SPELLS)
{
note(format("Too many player spells (%d).", tmp16u));
return (-1);
}
/* Read the spell flags */
for (i = 0; i < tmp16u; i++)
rd_byte(&p_ptr->spell_flags[i]);
/* Read the spell order */
for (i = 0, cnt = 0; i < tmp16u; i++, cnt++)
rd_byte(&p_ptr->spell_order[cnt]);
/* Success */
return (0);
}
/*
* Read squelch and autoinscription submenu for all known objects
*/
static int rd_squelch(void)
{
size_t i;
byte tmp8u = 24;
/* Read how many squelch bytes we have */
rd_byte(&tmp8u);
/* Check against current number */
if (tmp8u != squelch_size)
{
strip_bytes(tmp8u);
}
else
{
for (i = 0; i < squelch_size; i++)
rd_byte(&squelch_level[i]);
}
/* Handle ego-item squelch */
if ((sf_major == 3) && (sf_minor == 0) && (sf_patch != 9))
{
u16b file_e_max;
/* Read the number of saved ego-item */
rd_u16b(&file_e_max);
for (i = 0; i < file_e_max; i++)
{
if (i < z_info->e_max)
{
byte flags;
/* Read and extract the flag */
rd_byte(&flags);
e_info[i].everseen |= (flags & 0x02);
}
}
}
else
{
}
/* Read the current number of auto-inscriptions */
rd_u16b(&inscriptions_count);
/* Write the autoinscriptions array*/
for (i = 0; i < inscriptions_count; i++)
{
char tmp[80];
rd_s16b(&inscriptions[i].kind_idx);
rd_string(tmp, sizeof(tmp));
inscriptions[i].inscription_idx = quark_add(tmp);
}
return 0;
}
int SPI_TFT_ILI9341::Read_ID(void){
int r;
r = rd_byte(0x0A);
r = rd_byte(0x0A);
r = rd_byte(0x0A);
r = rd_byte(0x0A);
return(r);
}
/*
* Read a store
*/
static errr rd_store(int n)
{
store_type *st_ptr = &store[n];
int j;
byte own, num;
/* Read the basic info */
rd_s32b(&st_ptr->store_open);
rd_s16b(&st_ptr->insult_cur);
rd_byte(&own);
rd_byte(&num);
rd_s16b(&st_ptr->good_buy);
rd_s16b(&st_ptr->bad_buy);
/* Paranoia */
if (own >= z_info->b_max)
{
note("Illegal store owner!");
return (-1);
}
st_ptr->owner = own;
/* Read the items */
for (j = 0; j < num; j++)
{
object_type *i_ptr;
object_type object_type_body;
/* Get local object */
i_ptr = &object_type_body;
/* Wipe the object */
object_wipe(i_ptr);
/* Read the item */
if (rd_item(i_ptr))
{
note("Error reading item");
return (-1);
}
/* Accept any valid items */
if (st_ptr->stock_num < STORE_INVEN_MAX)
{
int k = st_ptr->stock_num++;
/* Accept the item */
object_copy(&st_ptr->stock[k], i_ptr);
}
}
/* Success */
return (0);
}
/*
* Read an object
*
* This function attempts to "repair" old savefiles, and to extract
* the most up to date values for various object fields.
*/
static errr rd_effect(void)
{
int x_idx;
byte type;
u16b f_idx;
byte y;
byte x;
byte countdown;
byte repeats;
u16b power;
s16b source;
u16b flags;
x_idx = x_pop();
/*something is wrong*/
if (!x_idx) return (-1);
/*Read the effect*/
rd_byte(&type);
rd_u16b(&f_idx);
rd_byte(&y);
rd_byte(&x);
rd_byte(&countdown);
rd_byte(&repeats);
rd_u16b(&power);
rd_s16b(&source);
rd_u16b(&flags);
/*Write it, unless it is an empty effect*/
if (type) effect_prep(x_idx, type, f_idx, y, x, countdown, repeats, power, source, flags);
/* Read a new field, a monster race for inscriptions */
if (!older_than(0,4,8))
{
s16b r_idx;
rd_s16b(&r_idx);
x_list[x_idx].x_r_idx = (type ? r_idx: 0);
}
/* Success */
return (0);
}
/*
* Read a store
*/
static errr rd_store(int town_number, int store_number)
{
store_type *st_ptr = &town[town_number].store[store_number];
int j;
byte num;
s16b tmp16s;
/* Read the basic info */
rd_s32b(&st_ptr->store_open);
rd_s16b(&tmp16s);
rd_byte(&st_ptr->owner);
rd_byte(&num);
rd_s16b(&tmp16s);
rd_s16b(&tmp16s);
/* Read last visit */
rd_s32b(&st_ptr->last_visit);
/* Read the items */
for (j = 0; j < num; j++)
{
object_type forge;
object_type *q_ptr;
/* Get local object */
q_ptr = &forge;
/* Wipe the object */
object_wipe(q_ptr);
/* Read the item */
rd_item(q_ptr);
/* Acquire valid items */
if (st_ptr->stock_num < (store_number == STORE_HOME ? (STORE_INVEN_MAX) * 10 : STORE_INVEN_MAX))
{
int k = st_ptr->stock_num;
if (q_ptr->k_idx != 0)
{
/* Acquire the item */
object_copy(&st_ptr->stock[k], q_ptr);
st_ptr->stock_num++;
}
}
}
/* Success */
return (0);
}
/*
* Hack -- strip some bytes
*/
static void strip_bytes(int n)
{
byte tmp8u;
/* Strip the bytes */
while (n--) rd_byte(&tmp8u);
}
static int rd_history(void)
{
u32b tmp32u;
size_t i;
history_clear();
rd_u32b(&tmp32u);
for (i = 0; i < tmp32u; i++)
{
s32b turn;
s16b dlev, clev;
u16b type;
byte art_name;
char text[80];
rd_u16b(&type);
rd_s32b(&turn);
rd_s16b(&dlev);
rd_s16b(&clev);
rd_byte(&art_name);
rd_string(text, sizeof(text));
history_add_full(type, art_name, dlev, clev, turn, text);
}
return 0;
}
static int rd_object_memory(void)
{
int i;
u16b tmp16u;
/* Object Memory */
rd_u16b(&tmp16u);
/* Incompatible save files */
if (tmp16u > z_info->k_max)
{
note(format("Too many (%u) object kinds!", tmp16u));
return (-1);
}
/* Read the object memory */
for (i = 0; i < tmp16u; i++)
{
byte tmp8u;
object_kind *k_ptr = &k_info[i];
rd_byte(&tmp8u);
k_ptr->aware = (tmp8u & 0x01) ? TRUE : FALSE;
k_ptr->tried = (tmp8u & 0x02) ? TRUE : FALSE;
k_ptr->everseen = (tmp8u & 0x08) ? TRUE : FALSE;
if (tmp8u & 0x04) kind_squelch_when_aware(k_ptr);
if (tmp8u & 0x10) kind_squelch_when_unaware(k_ptr);
}
return 0;
}
/*
* Read artifact lore
*/
static errr rd_artifact_lore(int a_idx)
{
byte tmp8u;
/* Read flags */
rd_byte(&tmp8u);
/* The artifact was fully identified */
a_l_list[a_idx].was_fully_identified = ((tmp8u & 0x01) != 0);
/* For future use */
rd_byte(&tmp8u);
rd_byte(&tmp8u);
rd_byte(&tmp8u);
return (0);
}
/*
* Save quick start data
*/
static void load_quick_start(void)
{
byte tmp8u;
int i;
rd_byte(&previous_char.psex);
rd_byte(&previous_char.prace);
rd_byte(&previous_char.pclass);
rd_byte(&previous_char.realm1);
rd_byte(&previous_char.realm2);
rd_s16b(&previous_char.age);
rd_s16b(&previous_char.ht);
rd_s16b(&previous_char.wt);
rd_s16b(&previous_char.sc);
rd_s32b(&previous_char.au);
for (i = 0; i < 6; i++) rd_s16b(&previous_char.stat_max[i]);
for (i = 0; i < PY_MAX_LEVEL; i++) rd_s16b(&previous_char.player_hp[i]);
rd_s16b(&previous_char.valar_patron);
for (i = 0; i < 4; i++) rd_string(previous_char.history[i], sizeof(previous_char.history[i]));
rd_byte(&previous_char.quests);
rd_byte(&tmp8u);
previous_char.quick_ok = (bool)tmp8u;
}
/*
* Hack -- read a string
*/
static void rd_string(char *str, int max)
{
int i;
/* Read the string */
for (i = 0; TRUE; i++)
{
byte tmp8u;
/* Read a byte */
rd_byte(&tmp8u);
/* Collect string while legal */
if (i < max) str[i] = tmp8u;
/* End of string */
if (!tmp8u) break;
}
/* Terminate */
str[max-1] = '\0';
#ifdef JP
/* Convert Kanji code */
switch (kanji_code)
{
#ifdef SJIS
case 2:
/* EUC to SJIS */
euc2sjis(str);
break;
#endif
#ifdef EUC
case 3:
/* SJIS to EUC */
sjis2euc(str);
break;
#endif
case 0:
{
/* 不明の漢字コードからシステムの漢字コードに変換 */
byte code = codeconv(str);
/* 漢字コードが判明したら、それを記録 */
if (code) kanji_code = code;
break;
}
default:
/* No conversion needed */
break;
}
#endif
}
/**
* Read a trap record
*/
static void rd_trap(struct trap *trap)
{
int i;
char buf[80];
rd_string(buf, sizeof(buf));
if (buf[0]) {
trap->kind = lookup_trap(buf);
trap->t_idx = trap->kind->tidx;
}
rd_byte(&trap->fy);
rd_byte(&trap->fx);
rd_byte(&trap->power);
rd_byte(&trap->timeout);
for (i = 0; i < trf_size; i++)
rd_byte(&trap->flags[i]);
}
static int rd_misc(void)
{
byte tmp8u;
/* Read the randart version */
rd_u32b(&randart_version);
/* Read the randart seed */
rd_u32b(&seed_randart);
/* Skip the flags */
strip_bytes(12);
/* Hack -- the two "special seeds" */
rd_u32b(&seed_flavor);
rd_u32b(&seed_town);
/* Special stuff */
rd_u16b(&p_ptr->panic_save);
rd_u16b(&p_ptr->total_winner);
rd_u16b(&p_ptr->noscore);
/* Read "death" */
rd_byte(&tmp8u);
p_ptr->is_dead = tmp8u;
/* Read "feeling" */
rd_byte(&tmp8u);
feeling = tmp8u;
/* Turn of last "feeling" */
rd_s32b(&old_turn);
/* Current turn */
rd_s32b(&turn);
return 0;
}
void rd_string(char *str, int max)
{
byte tmp8u;
int i = 0;
do {
rd_byte(&tmp8u);
if (i < max) str[i] = tmp8u;
if (!tmp8u) break;
} while (++i);
str[max - 1] = '\0';
}
/**
* Read options.
*/
int rd_options(void)
{
byte b;
u16b tmp16u;
/*** Special info */
/* Read "delay_factor" */
rd_byte(&b);
player->opts.delay_factor = b;
/* Read "hitpoint_warn" */
rd_byte(&b);
player->opts.hitpoint_warn = b;
/* Read lazy movement delay */
rd_u16b(&tmp16u);
player->opts.lazymove_delay = (tmp16u < 1000) ? tmp16u : 0;
/* Read options */
while (1) {
byte value;
char name[40];
rd_string(name, sizeof name);
if (!name[0])
break;
rd_byte(&value);
option_set(name, !!value);
}
return 0;
}
/**
* Read monster memory.
*/
int rd_monster_memory(void)
{
u16b tmp16u;
char buf[128];
int i;
/* Monster temporary flags */
rd_byte(&mflag_size);
/* Incompatible save files */
if (mflag_size > MFLAG_SIZE) {
note(format("Too many (%u) monster temporary flags!", mflag_size));
return (-1);
}
/* Reset maximum numbers per level */
for (i = 1; z_info && i < z_info->r_max; i++) {
struct monster_race *race = &r_info[i];
race->max_num = 100;
if (rf_has(race->flags, RF_UNIQUE))
race->max_num = 1;
}
rd_string(buf, sizeof(buf));
while (!streq(buf, "No more monsters")) {
struct monster_race *race = lookup_monster(buf);
/* Get the kill count, skip if monster invalid */
rd_u16b(&tmp16u);
if (!race) continue;
/* Store the kill count, ensure dead uniques stay dead */
l_list[race->ridx].pkills = tmp16u;
if (rf_has(race->flags, RF_UNIQUE) && tmp16u)
race->max_num = 0;
/* Look for the next monster */
rd_string(buf, sizeof(buf));
}
return 0;
}
/*
* Hack -- read a string
*/
static void rd_string(char *str, int max)
{
int i;
/* Read the string */
for (i = 0; TRUE; i++)
{
byte tmp8u;
/* Read a byte */
rd_byte(&tmp8u);
/* Collect string while legal */
if (i < max) str[i] = tmp8u;
/* End of string */
if (!tmp8u) break;
}
/* Terminate */
str[max-1] = '\0';
}
/*
* Read a monster
*/
static void rd_monster(monster_type *m_ptr)
{
byte num;
int i;
/* Read the monster race */
rd_s16b(&m_ptr->r_idx);
/* Read the other information */
rd_byte(&m_ptr->fy);
rd_byte(&m_ptr->fx);
rd_s16b(&m_ptr->hp);
rd_s16b(&m_ptr->maxhp);
rd_byte(&m_ptr->m_speed);
rd_s16b(&m_ptr->m_energy);
/* Find the number of monster timed effects */
rd_byte(&num);
if (num == MON_TMD_MAX)
{
/* Read all the effects */
for (i = 0; i < num; i++) rd_s16b(&m_ptr->m_timed[i]);
}
else
{
s16b dummy;
/* Probably in trouble anyway */
for (i = 0; i < num; i++) rd_s16b(&dummy);
note("Discarding unsupported monster timed effects");
}
rd_u32b(&m_ptr->mflag);
rd_u32b(&m_ptr->smart);
rd_byte(&m_ptr->target_y);
rd_byte(&m_ptr->target_x);
rd_byte(&m_ptr->mana);
strip_bytes(1);
}
int rd_quests(void)
{
int i;
u16b tmp16u;
/* Load the Quests */
rd_u16b(&tmp16u);
if (tmp16u > z_info->quest_max) {
note(format("Too many (%u) quests!", tmp16u));
return (-1);
}
/* Load the Quests */
player_quests_reset(player);
for (i = 0; i < tmp16u; i++) {
u16b cur_num;
rd_byte(&player->quests[i].level);
rd_u16b(&cur_num);
player->quests[i].cur_num = cur_num;
}
return 0;
}
/*
* Read the monster lore
*/
static void rd_lore(int r_idx)
{
int i;
monster_race *r_ptr = &r_info[r_idx];
monster_lore *l_ptr = &l_list[r_idx];
/* Count deaths/sights/kills */
rd_s16b(&l_ptr->deaths);
rd_s16b(&l_ptr->psights);
rd_s16b(&l_ptr->tsights);
rd_s16b(&l_ptr->pkills);
rd_s16b(&l_ptr->tkills);
/* Count notices and ignores */
rd_byte(&l_ptr->notice);
rd_byte(&l_ptr->ignore);
rd_byte(&l_ptr->drop_item);
rd_byte(&l_ptr->ranged);
/* Count blows of each type */
for (i = 0; i < MONSTER_BLOW_MAX; i++)
rd_byte(&l_ptr->blows[i]);
/* Memorize flags */
rd_u32b(&l_ptr->flags1);
rd_u32b(&l_ptr->flags2);
rd_u32b(&l_ptr->flags3);
rd_u32b(&l_ptr->flags4);
/* Read the "Racial" monster limit per level */
rd_byte(&r_ptr->max_num);
// 8 spare bytes
strip_bytes(8);
/* Repair the lore flags */
l_ptr->flags1 &= r_ptr->flags1;
l_ptr->flags2 &= r_ptr->flags2;
l_ptr->flags3 &= r_ptr->flags3;
l_ptr->flags4 &= r_ptr->flags4;
}
void strip_bytes(int n)
{
byte tmp8u;
while (n--) rd_byte(&tmp8u);
}
/*
* Read a Win32 BMP file.
*
* Assumes that the bitmap has a size such that no padding is needed in
* various places. Currently only handles bitmaps with 3 to 256 colors.
*/
static byte *ReadBMP(char *Name, int *bw, int *bh)
{
FILE *f;
BITMAPFILEHEADER fileheader;
BITMAPINFOHEADER infoheader;
byte *Data;
int ncol;
int total;
int i;
u16b x, y;
/* Open the BMP file */
f = fopen(Name, "r");
/* No such file */
if (!f)
{
quit ("No bitmap to load!");
}
/* Read the "BITMAPFILEHEADER" */
rd_u16b(f, &(fileheader.bfType));
rd_u32b(f, &(fileheader.bfSize));
rd_u16b(f, &(fileheader.bfReserved1));
rd_u16b(f, &(fileheader.bfReserved2));
rd_u32b(f, &(fileheader.bfOffBits));
/* Read the "BITMAPINFOHEADER" */
rd_u32b(f, &(infoheader.biSize));
rd_u32b(f, &(infoheader.biWidth));
rd_u32b(f, &(infoheader.biHeight));
rd_u16b(f, &(infoheader.biPlanes));
rd_u16b(f, &(infoheader.biBitCount));
rd_u32b(f, &(infoheader.biCompresion));
rd_u32b(f, &(infoheader.biSizeImage));
rd_u32b(f, &(infoheader.biXPelsPerMeter));
rd_u32b(f, &(infoheader.biYPelsPerMeter));
rd_u32b(f, &(infoheader.biClrUsed));
rd_u32b(f, &(infoheader.biClrImportand));
/* Verify the header */
if (feof(f) ||
(fileheader.bfType != 19778) ||
(infoheader.biSize != 40))
{
quit_fmt("Incorrect BMP file format %s", Name);
}
/* The two headers above occupy 54 bytes total */
/* The "bfOffBits" field says where the data starts */
/* The "biClrUsed" field does not seem to be reliable */
/* Compute number of colors recorded */
ncol = (fileheader.bfOffBits - 54) / 4;
for (i = 0; i < ncol; i++)
{
RGBQUAD clrg;
/* Read an "RGBQUAD" */
rd_byte(f, &(clrg.b));
rd_byte(f, &(clrg.g));
rd_byte(f, &(clrg.r));
rd_byte(f, &(clrg.filler));
/* Analyze the color */
pal[i * 3] = clrg.b;
pal[i * 3 + 1] = clrg.g;
pal[i * 3 + 2] = clrg.r;
}
/* Look for illegal bitdepths. */
if ((infoheader.biBitCount == 1) || (infoheader.biBitCount == 24))
{
quit_fmt("Illegal biBitCount %d in %s",
infoheader.biBitCount, Name);
}
/* Determine total bytes needed for image */
total = infoheader.biWidth * (infoheader.biHeight + 2);
/* Allocate image memory */
C_MAKE(Data, total, byte);
for (y = 0; y < infoheader.biHeight; y++)
{
int y2 = infoheader.biHeight - y - 1;
for (x = 0; x < infoheader.biWidth; x++)
{
int ch = getc(f);
/* Verify not at end of file XXX XXX */
if (feof(f)) quit_fmt("Unexpected end of file in %s", Name);
if (infoheader.biBitCount == 8)
{
Data[x + y2 * infoheader.biWidth] = ch;
}
else if (infoheader.biBitCount == 4)
{
Data[x + y2 * infoheader.biWidth] = ch / 16;
x++;
Data[x + y2 * infoheader.biWidth] = ch % 16;
}
}
}
fclose(f);
/* Save the size for later */
*bw = infoheader.biWidth;
*bh = infoheader.biHeight;
return (Data);
}
/*
* Read the "extra" information
*/
static int rd_player(void)
{
int i;
byte num;
rd_string(op_ptr->full_name, sizeof(op_ptr->full_name));
rd_string(p_ptr->died_from, 80);
rd_string(p_ptr->history, 250);
/* Player race */
rd_byte(&p_ptr->prace);
/* Verify player race */
if (p_ptr->prace >= z_info->p_max)
{
note(format("Invalid player race (%d).", p_ptr->prace));
return (-1);
}
rp_ptr = &p_info[p_ptr->prace];
/* Player class */
rd_byte(&p_ptr->pclass);
/* Verify player class */
if (p_ptr->pclass >= z_info->c_max)
{
note(format("Invalid player class (%d).", p_ptr->pclass));
return (-1);
}
cp_ptr = &c_info[p_ptr->pclass];
mp_ptr = &cp_ptr->spells;
/* Player gender */
rd_byte(&p_ptr->psex);
sp_ptr = &sex_info[p_ptr->psex];
/* Numeric name suffix */
rd_byte(&op_ptr->name_suffix);
/* Special Race/Class info */
rd_byte(&p_ptr->hitdie);
rd_byte(&p_ptr->expfact);
/* Age/Height/Weight */
rd_s16b(&p_ptr->age);
rd_s16b(&p_ptr->ht);
rd_s16b(&p_ptr->wt);
/* Read the stat info */
for (i = 0; i < A_MAX; i++) rd_s16b(&p_ptr->stat_max[i]);
for (i = 0; i < A_MAX; i++) rd_s16b(&p_ptr->stat_cur[i]);
for (i = 0; i < A_MAX; i++) rd_s16b(&p_ptr->stat_birth[i]);
rd_s16b(&p_ptr->ht_birth);
rd_s16b(&p_ptr->wt_birth);
rd_s32b(&p_ptr->au_birth);
strip_bytes(4);
rd_s32b(&p_ptr->au);
rd_s32b(&p_ptr->max_exp);
rd_s32b(&p_ptr->exp);
rd_u16b(&p_ptr->exp_frac);
rd_s16b(&p_ptr->lev);
/* Verify player level */
if ((p_ptr->lev < 1) || (p_ptr->lev > PY_MAX_LEVEL))
{
note(format("Invalid player level (%d).", p_ptr->lev));
return (-1);
}
rd_s16b(&p_ptr->mhp);
rd_s16b(&p_ptr->chp);
rd_u16b(&p_ptr->chp_frac);
rd_s16b(&p_ptr->msp);
rd_s16b(&p_ptr->csp);
rd_u16b(&p_ptr->csp_frac);
rd_s16b(&p_ptr->max_lev);
rd_s16b(&p_ptr->max_depth);
/* Hack -- Repair maximum player level */
if (p_ptr->max_lev < p_ptr->lev) p_ptr->max_lev = p_ptr->lev;
/* Hack -- Repair maximum dungeon level */
if (p_ptr->max_depth < 0) p_ptr->max_depth = 1;
/* More info */
strip_bytes(8);
rd_s16b(&p_ptr->sc);
strip_bytes(2);
/* Read the flags */
rd_s16b(&p_ptr->food);
rd_s16b(&p_ptr->energy);
rd_s16b(&p_ptr->word_recall);
rd_s16b(&p_ptr->state.see_infra);
rd_byte(&p_ptr->confusing);
rd_byte(&p_ptr->searching);
/* Find the number of timed effects */
rd_byte(&num);
if (num <= TMD_MAX)
{
/* Read all the effects */
for (i = 0; i < num; i++)
rd_s16b(&p_ptr->timed[i]);
/* Initialize any entries not read */
if (num < TMD_MAX)
C_WIPE(p_ptr->timed + num, TMD_MAX - num, s16b);
}
else
{
/* Probably in trouble anyway */
for (i = 0; i < TMD_MAX; i++)
rd_s16b(&p_ptr->timed[i]);
/* Discard unused entries */
strip_bytes(2 * (num - TMD_MAX));
note("Discarded unsupported timed effects");
}
/* Future use */
strip_bytes(40);
return 0;
}
static int rd_artifacts(void)
{
int i;
u16b tmp16u;
/* Load the Artifacts */
rd_u16b(&tmp16u);
/* Incompatible save files */
if (tmp16u > z_info->a_max)
{
note(format("Too many (%u) artifacts!", tmp16u));
return (-1);
}
/* Read the artifact flags */
for (i = 0; i < tmp16u; i++)
{
byte tmp8u;
rd_byte(&tmp8u);
a_info[i].created = tmp8u;
rd_byte(&tmp8u);
rd_byte(&tmp8u);
rd_byte(&tmp8u);
}
/* For old versions, we need to go through objects and update */
{
size_t i;
object_type *o_ptr = NULL;
bool *anywhere;
anywhere = C_ZNEW(z_info->a_max, bool);
/* All inventory/home artifacts need to be marked as seen */
for (i = 0; i < INVEN_TOTAL; i++)
{
o_ptr = &o_list[i];
if (object_is_known_artifact(o_ptr))
artifact_of(o_ptr)->seen = TRUE;
anywhere[o_ptr->name1] = TRUE;
}
for (i = 0; i < (size_t)o_max; i++)
{
o_ptr = &o_list[i];
if (object_is_known_artifact(o_ptr))
artifact_of(o_ptr)->seen = TRUE;
anywhere[o_ptr->name1] = TRUE;
}
for (i = 0; i < MAX_STORES; i++)
{
int j = 0;
for (j = 0; j < store[i].stock_num; j++)
{
o_ptr = &store[i].stock[j];
if (object_is_known_artifact(o_ptr))
artifact_of(o_ptr)->seen = TRUE;
anywhere[o_ptr->name1] = TRUE;
}
}
/* Now update the seen flags correctly */
for (i = 0; i < z_info->a_max; i++)
{
artifact_type *a_ptr = &a_info[i];
/* If it isn't present anywhere, but has been created,
* then it has been lost, and thus seen */
if (a_ptr->created && !anywhere[i])
a_ptr->seen = TRUE;
}
FREE(anywhere);
}
return 0;
}
static int rd_monster_memory(void)
{
int r_idx;
u16b tmp16u;
/* Monster Memory */
rd_u16b(&tmp16u);
/* Incompatible save files */
if (tmp16u > z_info->r_max)
{
note(format("Too many (%u) monster races!", tmp16u));
return (-1);
}
/* Read the available records */
for (r_idx = 0; r_idx < tmp16u; r_idx++)
{
size_t i;
monster_race *r_ptr = &r_info[r_idx];
monster_lore *l_ptr = &l_list[r_idx];
/* Count sights/deaths/kills */
rd_s16b(&l_ptr->sights);
rd_s16b(&l_ptr->deaths);
rd_s16b(&l_ptr->pkills);
rd_s16b(&l_ptr->tkills);
/* Count wakes and ignores */
rd_byte(&l_ptr->wake);
rd_byte(&l_ptr->ignore);
/* Count drops */
rd_byte(&l_ptr->drop_gold);
rd_byte(&l_ptr->drop_item);
/* Count spells */
rd_byte(&l_ptr->cast_innate);
rd_byte(&l_ptr->cast_spell);
/* Count blows of each type */
for (i = 0; i < MONSTER_BLOW_MAX; i++)
rd_byte(&l_ptr->blows[i]);
/* Memorize flags */
/* Hack - XXX - MarbleDice - Maximum saveable flags = 96 */
for (i = 0; i < 12 && i < RF_SIZE; i++)
rd_byte(&l_ptr->flags[i]);
if (i < 12) strip_bytes(RF_SIZE - i);
/* Hack - XXX - MarbleDice - Maximum saveable flags = 96 */
for (i = 0; i < 12 && i < RSF_SIZE; i++)
rd_byte(&l_ptr->spell_flags[i]);
if (i < 12) strip_bytes(12 - i);
/* Read the "Racial" monster limit per level */
rd_byte(&r_ptr->max_num);
/* XXX */
strip_bytes(3);
/* Repair the spell lore flags */
rsf_inter(l_ptr->spell_flags, r_ptr->spell_flags);
}
return 0;
}
/*
* Read options
*
* Note that the normal options are stored as a set of 256 bit flags,
* plus a set of 256 bit masks to indicate which bit flags were defined
* at the time the savefile was created. This will allow new options
* to be added, and old options to be removed, at any time, without
* hurting old savefiles.
*
* The window options are stored in the same way, but note that each
* window gets 32 options, and their order is fixed by certain defines.
*/
static int rd_options(void)
{
int i, n;
byte b;
u16b tmp16u;
u32b flag[8];
u32b mask[8];
u32b window_flag[REPOSBAND_TERM_MAX];
u32b window_mask[REPOSBAND_TERM_MAX];
/*** Oops ***/
/* Ignore old options */
strip_bytes(16);
/*** Special info */
/* Read "delay_factor" */
rd_byte(&b);
op_ptr->delay_factor = b;
/* Read "hitpoint_warn" */
rd_byte(&b);
op_ptr->hitpoint_warn = b;
/* Read lazy movement delay */
rd_u16b(&tmp16u);
lazymove_delay = (tmp16u < 1000) ? tmp16u : 0;
/*** Normal Options ***/
/* Read the option flags */
for (n = 0; n < 8; n++) rd_u32b(&flag[n]);
/* Read the option masks */
for (n = 0; n < 8; n++) rd_u32b(&mask[n]);
/* Analyze the options */
for (i = 0; i < OPT_MAX; i++)
{
int os = i / 32;
int ob = i % 32;
/* Process saved entries */
if (mask[os] & (1L << ob))
{
/* Set flag */
if (flag[os] & (1L << ob))
op_ptr->opt[i] = TRUE;
/* Clear flag */
else
op_ptr->opt[i] = FALSE;
}
}
/*** Window Options ***/
/* Read the window flags */
for (n = 0; n < REPOSBAND_TERM_MAX; n++)
{
rd_u32b(&window_flag[n]);
}
/* Read the window masks */
for (n = 0; n < REPOSBAND_TERM_MAX; n++)
{
rd_u32b(&window_mask[n]);
}
/* Analyze the options */
for (n = 0; n < REPOSBAND_TERM_MAX; n++)
{
/* Analyze the options */
for (i = 0; i < 32; i++)
{
/* Process valid flags */
if (window_flag_desc[i])
{
/* Blank invalid flags */
if (!(window_mask[n] & (1L << i)))
{
window_flag[n] &= ~(1L << i);
}
}
}
}
/* Set up the subwindows */
subwindows_set_flags(window_flag, REPOSBAND_TERM_MAX);
return 0;
}