/* * 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; }