/**
* Register an object kind autoinscription
*/
int add_autoinscription(s16b kind, const char *inscription, bool aware)
{
struct object_kind *k = objkind_byid(kind);
if (!k)
return 0;
if (!inscription)
return remove_autoinscription(kind);
if (aware)
k->note_aware = quark_add(inscription);
else
k->note_unaware = quark_add(inscription);
return 1;
}
int test_alloc(void *state) {
quark_t q1 = quark_add("0-foo");
quark_t q2 = quark_add("0-bar");
quark_t q3 = quark_add("0-baz");
require(quark_str(q1));
require(quark_str(q2));
require(quark_str(q3));
require(!strcmp(quark_str(q1), "0-foo"));
require(!strcmp(quark_str(q2), "0-bar"));
require(!strcmp(quark_str(q3), "0-baz"));
ok;
}
/**
* Drop all {ignore}able items.
*/
void ignore_drop(void)
{
struct object *obj;
/* Scan through the slots backwards */
for (obj = gear_last_item(); obj; obj = obj->prev) {
/* Skip non-objects and unignoreable objects */
assert(obj->kind);
if (!ignore_item_ok(obj)) continue;
/* Check for !d (no drop) inscription */
if (!check_for_inscrip(obj, "!d") && !check_for_inscrip(obj, "!*")) {
/* Confirm the drop if the item is equipped. */
if (object_is_equipped(player->body, obj)) {
if (!verify_object("Really take off and drop", obj)) {
/* Hack - inscribe the item with !d to prevent repeated
* confirmations. */
const char *inscription = quark_str(obj->note);
if (inscription == NULL) {
obj->note = quark_add("!d");
} else {
char buffer[1024];
my_strcpy(buffer, inscription, sizeof(buffer));
my_strcat(buffer, "!d", sizeof(buffer));
obj->note = quark_add(buffer);
}
continue;
}
}
/* We're allowed to drop it. */
if (!square_isshop(cave, player->py, player->px)) {
player->upkeep->dropping = true;
cmdq_push(CMD_DROP);
cmd_set_arg_item(cmdq_peek(), "item", obj);
cmd_set_arg_number(cmdq_peek(), "quantity", obj->number);
}
}
}
/* Update the gear */
player->upkeep->update |= (PU_INVEN);
/* Combine/reorder the pack */
player->upkeep->notice |= (PN_COMBINE);
}
int test_dedup(void *state) {
quark_t q1 = quark_add("1-foo");
quark_t q2 = quark_add("1-foo");
quark_t q3 = quark_add("1-bar");
require(quark_str(q1));
require(quark_str(q2));
require(quark_str(q3));
require(q1 == q2);
require(quark_str(q1) == quark_str(q2));
require(q1 != q3);
require(quark_str(q1) != quark_str(q3));
ok;
}
/**
* Put the autoinscription on an object
*/
int apply_autoinscription(object_type * o_ptr)
{
char o_name[80];
const char *note = get_autoinscription(o_ptr->k_idx);
const char *existing_inscription = quark_str(o_ptr->note);
/* Don't inscribe unaware objects */
if (!note || !object_aware_p(o_ptr))
return 0;
/* Don't re-inscribe if it's already correctly inscribed */
if (existing_inscription && streq(note, existing_inscription))
return 0;
/* Get an object description */
object_desc(o_name, sizeof(o_name), o_ptr, ODESC_PREFIX | ODESC_FULL);
if (note[0] != 0)
o_ptr->note = quark_add(note);
else
o_ptr->note = 0;
msg("You autoinscribe %s.", o_name);
return 1;
}
int add_autoinscription(s16b kind, const char *inscription)
{
int index;
/* Paranoia */
if (kind == 0)
return 0;
/* If there's no inscription, remove it */
if (!inscription || (inscription[0] == 0))
return remove_autoinscription(kind);
index = get_autoinscription_index(kind);
if (index == -1)
index = inscriptions_count;
if (index >= AUTOINSCRIPTIONS_MAX) {
msg("This inscription (%s) cannot be added because the inscription array is full!", inscription);
return 0;
}
inscriptions[index].kind_idx = kind;
inscriptions[index].inscription_idx = quark_add(inscription);
/* Only increment count if inscription added to end of array */
if (index == inscriptions_count)
inscriptions_count++;
return 1;
}
/*
* Squelch on identify function
*/
void do_squelch_item(int item, object_type *o_ptr)
{
/* Either delete the item... */
if (strong_squelch)
{
if (item >= 0)
{
inven_item_increase(item, -o_ptr->number);
inven_item_optimize(item);
}
else
{
floor_item_increase(0 - item, -o_ptr->number);
floor_item_optimize(0 - item);
}
}
/* ...or mark it for manual deletion. */
else
{
o_ptr->note = 0;
o_ptr->note = quark_add("SQUELCH");
}
return;
}
/*
* The "Squelch on walk-on" function.
*/
void do_squelch_pile(int y, int x)
{
s16b o_idx, next_o_idx;
object_type *o_ptr;
bool sq_flag = FALSE;
for (o_idx = cave_o_idx[y][x]; o_idx; o_idx = next_o_idx)
{
o_ptr = &(o_list[o_idx]);
next_o_idx = o_ptr->next_o_idx;
/* Always squelch "¬hing" */
if (!o_ptr->k_idx) sq_flag = TRUE;
/* Hack - never squelch artifacts */
else if (artifact_p(o_ptr)) sq_flag = FALSE;
/* Squelch it? */
else sq_flag = (k_info[o_ptr->k_idx].squelch & k_info[o_ptr->k_idx].aware);
/* Unwanted and unloved */
if (sq_flag)
{
/* Actual Squelch */
if (strong_squelch) delete_object_idx(o_idx);
/* Or inscription */
else o_ptr->note = quark_add("SQUELCH");
}
}
}
/**
* Put an autoinscription on an object
*/
int apply_autoinscription(struct object *obj)
{
char o_name[80];
const char *note = obj ? get_autoinscription(obj->kind) : NULL;
/* Don't inscribe unaware objects */
if (!note || !object_flavor_is_aware(obj))
return 0;
/* Don't re-inscribe if it's already inscribed */
if (obj->note)
return 0;
/* Don't inscribe unless the player is carrying it */
if (!object_is_carried(player, obj))
return 0;
/* Don't inscribe if ignored */
if (ignore_item_ok(obj))
return 0;
/* Get an object description */
object_desc(o_name, sizeof(o_name), obj, ODESC_PREFIX | ODESC_FULL);
if (note[0] != 0)
obj->note = quark_add(note);
else
obj->note = 0;
msg("You autoinscribe %s.", o_name);
return 1;
}
/*
* Inscribe an object with a comment
*/
void do_cmd_inscribe(void)
{
int item;
object_type *o_ptr;
char o_name[80];
char tmp[80];
cptr q, s;
/* Get an item */
q = "Inscribe which item? ";
s = "You have nothing to inscribe.";
if (!get_item(&item, q, s, (USE_EQUIP | USE_INVEN | USE_FLOOR))) return;
/* Get the item (in the pack) */
if (item >= 0)
{
o_ptr = &inventory[item];
}
/* Get the item (on the floor) */
else
{
o_ptr = &o_list[0 - item];
}
/* Describe the activity */
object_desc(o_name, o_ptr, TRUE, 3);
/* Message */
msg_format("Inscribing %s.", o_name);
message_flush();
/* Start with nothing */
strcpy(tmp, "");
/* Use old inscription */
if (o_ptr->note)
{
/* Start with the old inscription */
strnfmt(tmp, 80, "%s", quark_str(o_ptr->note));
}
/* Get a new inscription (possibly empty) */
if (get_string("Inscription: ", tmp, 80))
{
/* Save the inscription */
o_ptr->note = quark_add(tmp);
/* Combine the pack */
p_ptr->notice |= (PN_COMBINE);
/* Window stuff */
p_ptr->window |= (PW_INVEN | PW_EQUIP);
}
}
/* Put the autoinscription on an object */
int apply_autoinscription(object_type *o_ptr)
{
char o_name[80];
const char *note = get_autoinscription(o_ptr->kind);
/* Don't inscribe unaware objects */
if (!note || !object_flavor_is_aware(o_ptr))
return 0;
/* Don't re-inscribe if it's already inscribed */
if (o_ptr->note)
return 0;
/* Get an object description */
object_desc(o_name, sizeof(o_name), o_ptr, ODESC_PREFIX | ODESC_FULL);
if (note[0] != 0)
o_ptr->note = quark_add(note);
else
o_ptr->note = 0;
msg("You autoinscribe %s.", o_name);
return 1;
}
/*
* 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;
}
/* Add inscription */
void do_cmd_inscribe(cmd_code code, cmd_arg args[])
{
object_type *o_ptr = object_from_item_idx(args[0].item);
o_ptr->note = quark_add(args[1].string);
p_ptr->notice |= (PN_COMBINE | PN_SQUELCH | PN_SORT_QUIVER);
p_ptr->redraw |= (PR_INVEN | PR_EQUIP);
}
int add_autoinscription(s16b kind, const char *inscription)
{
struct object_kind *k = objkind_byid(kind);
if (!k)
return 0;
if (!inscription)
return remove_autoinscription(kind);
k->note = quark_add(inscription);
return 1;
}
/**
* Make or extend a rune autoinscription
*/
static void rune_add_autoinscription(struct object *obj, int i)
{
char current_note[80] = "";
/* No autoinscription, or already there, don't bother */
if (!rune_note(i)) return;
if (obj->note && strstr(quark_str(obj->note), quark_str(rune_note(i))))
return;
/* Extend any current note */
if (obj->note)
my_strcpy(current_note, quark_str(obj->note), sizeof(current_note));
my_strcat(current_note, quark_str(rune_note(i)), sizeof(current_note));
/* Add the inscription */
obj->note = quark_add(current_note);
}
/**
* Put an autoinscription on an object
*/
int apply_autoinscription(struct object *obj)
{
char o_name[80];
bool aware = obj->kind->aware;
const char *note = obj ? get_autoinscription(obj->kind, aware) : NULL;
/* Remove unaware inscription if aware */
if (aware && quark_str(obj->note) && quark_str(obj->kind->note_unaware) &&
streq(quark_str(obj->note), quark_str(obj->kind->note_unaware)))
obj->note = 0;
/* Make rune autoinscription go first, for now */
runes_autoinscribe(obj);
/* No note - don't inscribe */
if (!note)
return 0;
/* Don't re-inscribe if it's already inscribed */
if (obj->note)
return 0;
/* Don't inscribe unless the player is carrying it */
if (!object_is_carried(player, obj))
return 0;
/* Don't inscribe if ignored */
if (ignore_item_ok(obj))
return 0;
/* Get an object description */
object_desc(o_name, sizeof(o_name), obj, ODESC_PREFIX | ODESC_FULL);
if (note[0] != 0)
obj->note = quark_add(note);
else
obj->note = 0;
msg("You autoinscribe %s.", o_name);
return 1;
}
bool quest_poison_quest_hook(char *fmt)
{
object_type forge, *q_ptr;
s32b q_idx;
q_idx = get_next_arg(fmt);
if (q_idx != QUEST_POISON) return FALSE;
q_ptr = &forge;
object_prep(q_ptr, lookup_kind(TV_POTION2, SV_POTION2_CURE_WATER));
q_ptr->number = 99;
object_aware(q_ptr);
object_known(q_ptr);
q_ptr->ident |= IDENT_STOREB;
q_ptr->note = quark_add("quest");
(void)inven_carry(q_ptr, FALSE);
del_hook(HOOK_INIT_QUEST, quest_poison_quest_hook);
process_hooks_restart = TRUE;
return FALSE;
}
/*
* Read the "extra" information
*/
static errr rd_extra(void)
{
int i;
byte tmp8u;
u16b tmp16u;
u16b file_e_max;
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);
}
/* 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);
}
/* Player gender */
rd_byte(&p_ptr->psex);
strip_bytes(1);
/* 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]);
for (i = 0; i < A_MAX; ++i) rd_s16b(&p_ptr->stat_quest_add[i]);
rd_s16b(&p_ptr->ht_birth);
rd_s16b(&p_ptr->wt_birth);
rd_s16b(&p_ptr->sc_birth);
rd_s32b(&p_ptr->au_birth);
strip_bytes(24); /* oops */
rd_u16b(&p_ptr->q_fame);
rd_u16b(&p_ptr->deferred_rewards);
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 > z_info->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);
rd_s16b(&p_ptr->recall_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;
/* Hack -- Repair recall dungeon level */
if (p_ptr->recall_depth < 0) p_ptr->recall_depth = 1;
rd_s16b(&p_ptr->quest_depth);
/* Hack -- Repair max quest level */
if ((p_ptr->max_depth > 1) &&
(p_ptr->max_depth > p_ptr->quest_depth))
{
p_ptr->quest_depth = p_ptr->max_depth;
}
/* More info */
strip_bytes(6);
rd_s16b(&p_ptr->sc);
strip_bytes(2);
/* Read the flags */
strip_bytes(2); /* Old "rest" */
rd_s16b(&p_ptr->food);
strip_bytes(4); /* Old "food_digested" / "protection" */
rd_s16b(&p_ptr->p_energy);
rd_s16b(&p_ptr->word_recall);
rd_s16b(&p_ptr->state.see_infra);
rd_byte(&p_ptr->confusing);
rd_byte(&tmp8u);
rd_byte(&p_ptr->searching);
rd_byte(&tmp8u); /* oops */
rd_byte(&tmp8u); /* oops */
rd_byte(&tmp8u); /* oops */
/* 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]);
}
else
{
s16b dummy2;
/* Probably in trouble anyway */
for (i = 0; i < TMD_MAX; i++) rd_s16b(&dummy2);
/* Discard unused entries */
note("Discarding unsupported timed effects");
}
rd_s16b(&p_ptr->base_wakeup_chance);
rd_s16b(&total_wakeup_chance);
/* Read item-quality squelch sub-menu */
for (i = 0; i < SQUELCH_BYTES; i++) rd_byte(&squelch_level[i]);
/* Load the name of the current greater vault */
rd_string(g_vault_name, sizeof(g_vault_name));
/* Read the number of saved ego-item types */
rd_u16b(&file_e_max);
/* Read ego-item squelch settings */
for (i = 0; i < z_info->e_max; i++)
{
ego_item_type *e_ptr = &e_info[i];
tmp8u = 0;
if (i < file_e_max) rd_byte(&tmp8u);
e_ptr->squelch |= (tmp8u & 0x01);
e_ptr->everseen |= (tmp8u & 0x02);
/* Hack - Repair the savefile */
if (!e_ptr->everseen) e_ptr->squelch = FALSE;
}
/* Read possible extra elements */
while (i < file_e_max)
{
rd_byte(&tmp8u);
i++;
}
/*Read the current number of auto-inscriptions*/
rd_u16b(&inscriptionsCount);
/*Read the autoinscriptions array*/
for(i = 0; i < inscriptionsCount; i++)
{
char tmp[80];
rd_s16b(&inscriptions[i].kindIdx);
rd_string(tmp, 80);
inscriptions[i].inscriptionIdx = quark_add(tmp);
}
/*
* The number of the bone file (if any) that player ghosts should use to
* derive the ghost name, sex, class, race, and level.
*/
rd_s16b(&player_ghost_num);
/* Find out how many thefts have recently occurred. */
strip_bytes(1);
/* Read number of monster traps on level. */
rd_byte(&num_trap_on_level);
/* Future use */
strip_bytes(13);
/* Read the summon spells that have already failed on the level */
rd_u32b(&dungeon_summon_mask_f7);
/* Read the randart seed */
rd_u32b(&seed_randart);
/* Skip the flags */
strip_bytes(12);
/* Hack -- the three "special seeds" */
rd_u32b(&seed_flavor);
rd_u32b(&seed_town);
rd_u32b(&seed_ghost);
/* 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;
/*read the level feeling*/
rd_byte(&tmp8u);
do_feeling = tmp8u;
/* Current turn */
rd_s32b(&turn);
/*Current Player Turn*/
rd_s32b(&p_ptr->p_turn);
/* Turn count for quest indicator */
rd_u16b(&quest_indicator_timer);
/* Check if the quest indicator must flash the victory sign */
if (quest_indicator_timer & (QUEST_INDICATOR_COMPLETE_BIT))
{
/* We won the quest */
quest_indicator_complete = TRUE;
/* Clear the mark from the timer */
quest_indicator_timer &= ~(QUEST_INDICATOR_COMPLETE_BIT);
}
/* Panel change offsets */
rd_u16b(&panel_change_offset_y);
rd_u16b(&panel_change_offset_x);
/* Check bounds */
if (panel_change_offset_y < MIN_PANEL_CHANGE_OFFSET_Y)
{
panel_change_offset_y = MIN_PANEL_CHANGE_OFFSET_Y;
}
if (panel_change_offset_x < MIN_PANEL_CHANGE_OFFSET_X)
{
panel_change_offset_x = MIN_PANEL_CHANGE_OFFSET_X;
}
/* Read the player_hp array */
rd_u16b(&tmp16u);
/* Incompatible save files */
if (tmp16u > z_info->max_level)
{
note(format("Too many (%u) hitpoint entries!", tmp16u));
return (-1);
}
/* Read the player_hp array */
for (i = 0; i < tmp16u; i++)
{
rd_s16b(&p_ptr->player_hp[i]);
}
/* Read the player spells */
if (rd_player_spells()) return (-1);
return (0);
}
/*
* Actually read the savefile
*
*/
static errr rd_savefile_new_aux(player_type *p_ptr)
{
int i;
u16b tmp16u;
u32b tmp32u;
bool clear = FALSE;
bool had_header = FALSE;
char stat_order_hack[6];
start_section_read("mangband_player_save");
start_section_read("version");
read_int("major");
read_int("minor");
read_int("patch");
end_section_read("version");
if (section_exists("header"))
{
start_section_read("header");
had_header = TRUE;
read_str("playername",p_ptr->name); /* 32 */
skip_value("pass");
p_ptr->prace = read_int("prace");
p_ptr->pclass = read_int("pclass");
p_ptr->male = read_int("male");
read_binary("stat_order", stat_order_hack, 6);
for (i = 0; i < 6; i++)
p_ptr->stat_order[i] = stat_order_hack[i];
end_section_read("header");
}
/* Operating system info */
sf_xtra = read_uint("sf_xtra");
/* Time of savefile creation */
sf_when = read_uint("sf_when");
/* Number of resurrections */
sf_lives = read_int("sf_lives");
/* Number of times played */
sf_saves = read_int("sf_saves");
/* Skip the turn info - if present */
skip_value("turn");
/* Turn this character was born on */
if(value_exists("birth_turn"))
read_hturn("birth_turn", &p_ptr->birth_turn);
else
/* Disable character event logging if no birth turn */
ht_clr(&p_ptr->birth_turn);
/* Player turns (actually time spent playing) */
if(value_exists("player_turn"))
read_hturn("player_turn", &p_ptr->turn);
else
ht_clr(&p_ptr->turn);
/* Read birth options */
if (rd_birthoptions(p_ptr))
{
return (28);
}
/* Monster Memory */
if (section_exists("monster_lore")) {
start_section_read("monster_lore");
tmp16u = read_int("max_r_idx");
/* Incompatible save files */
if (tmp16u > z_info->r_max)
{
note(format("Too many (%u) monster races!", tmp16u));
return (21);
}
/* Read the available records */
for (i = 0; i < tmp16u; i++)
{
/* Read the lore */
rd_lore(p_ptr, i);
}
end_section_read("monster_lore");
}
/* Object Memory */
start_section_read("object_memory");
tmp16u = read_int("max_k_idx");
/* Incompatible save files */
if (tmp16u > z_info->k_max)
{
note(format("Too many (%u) object kinds!", tmp16u));
return (22);
}
/* Read the object memory */
for (i = 0; i < tmp16u; i++)
{
byte tmp8u;
tmp8u = read_int("flags");
p_ptr->obj_aware[i] = (tmp8u & 0x01) ? TRUE : FALSE;
p_ptr->obj_tried[i] = (tmp8u & 0x02) ? TRUE : FALSE;
}
end_section_read("object_memory");
/*if (arg_fiddle) note("Loaded Object Memory");*/
/* Read the extra stuff */
rd_extra(p_ptr, had_header);
/*if (arg_fiddle) note("Loaded extra information");*/
/* Read the player_hp array */
start_section_read("hp");
tmp16u = read_int("py_max_level");
/* Read the player_hp array */
for (i = 0; i < tmp16u; i++)
{
p_ptr->player_hp[i] = read_int("hp");
}
end_section_read("hp");
/* Important -- Initialize the race/class */
p_ptr->rp_ptr = &p_info[p_ptr->prace];
p_ptr->cp_ptr = &c_info[p_ptr->pclass];
/* Important -- Choose the magic info */
p_ptr->mp_ptr = &c_info[p_ptr->pclass].spells;
/* Read spell info */
if (section_exists("spell_flags"))
{
start_section_read("spell_flags");
for (i = 0; i < PY_MAX_SPELLS; i++)
{
p_ptr->spell_flags[i] = read_int("flag");
}
end_section_read("spell_flags");
}
else
{
/* Port spell flags from old format */
u32b spell_learned1, spell_learned2;
u32b spell_worked1, spell_worked2;
u32b spell_forgotten1, spell_forgotten2;
spell_learned1 = read_uint("spell_learned1");
spell_learned2 = read_uint("spell_learned2");
spell_worked1 = read_uint("spell_worked1");
spell_worked2 = read_uint("spell_worked2");
spell_forgotten1 = read_uint("spell_forgotten1");
spell_forgotten2 = read_uint("spell_forgotten2");
for (i = 0; i < PY_MAX_SPELLS; i++)
{
if ((i < 32) ?
(spell_forgotten1 & (1L << i)) :
(spell_forgotten2 & (1L << (i - 32))))
{
p_ptr->spell_flags[i] |= PY_SPELL_FORGOTTEN;
}
if ((i < 32) ?
(spell_learned1 & (1L << i)) :
(spell_learned2 & (1L << (i - 32))))
{
p_ptr->spell_flags[i] |= PY_SPELL_LEARNED;
}
if ((i < 32) ?
(spell_worked1 & (1L << i)) :
(spell_worked2 & (1L << (i - 32))))
{
p_ptr->spell_flags[i] |= PY_SPELL_WORKED;
}
}
}
start_section_read("spell_order");
for (i = 0; i < PY_MAX_SPELLS; i++)
{
p_ptr->spell_order[i] = read_int("order");
}
end_section_read("spell_order");
/* Read the inventory */
if (rd_inventory(p_ptr))
{
/*note("Unable to read inventory");*/
return (21);
}
/* Read hostility information if new enough */
if (rd_hostilities(p_ptr))
{
return (22);
}
rd_cave_memory(p_ptr);
/* read the wilderness map */
start_section_read("wilderness");
/* get the map size */
tmp32u = read_int("max_wild");
/* if too many map entries */
if (tmp32u > MAX_WILD)
{
return 23;
}
/* read in the map */
for (i = 0; i < tmp32u; i++)
{
p_ptr->wild_map[i] = read_int("wild_map");
}
end_section_read("wilderness");
/* Read the character event history */
if(section_exists("event_history"))
{
char buf[160];
cptr msg;
history_event evt;
history_event *last = NULL;
start_section_read("event_history");
while(value_exists("hist"))
{
int depth, level;
history_event *n_evt = NULL;
read_str("hist", buf);
if (sscanf(buf, "%02i:%02i:%02i %4ift %2i ", &evt.days, &evt.hours, &evt.mins,
&depth, &level) == 5)
{
msg = &buf[25];/* skip 25 characters ^ */
evt.depth = depth / 50;
evt.message = quark_add(msg);
}
/* Allocate */
MAKE(n_evt, history_event);
n_evt->days = evt.days; n_evt->hours = evt.hours; n_evt->mins = evt.mins;
n_evt->depth = evt.depth; n_evt->level = level;
n_evt->message = evt.message;
/* Add to chain */
if (!last)
{
p_ptr->charhist = n_evt;
last = n_evt;
}
else
{
last->next = n_evt;
last = n_evt;
}
}
end_section_read("event_history");
}
/* Read the characters quest list */
if(section_exists("quests"))
{
start_section_read("quests");
tmp16u = read_int("max_q_idx");
for(i = 0; i < MAX_Q_IDX; i++)
{
tmp16u = read_int("level");
p_ptr->q_list[i].level = tmp16u;
}
end_section_read("quests");
}
/* Read the characters sold artifact list */
if(section_exists("found_artifacts"))
{
start_section_read("found_artifacts");
tmp16u = read_int("max_a_idx");
tmp32u = tmp16u;
/* If we have an unexpected number of arts, just reset our list
* of sold artifacts. It's not so important we want to break
* save file compatability for it. */
if( tmp16u != z_info->a_max )
{
clear = TRUE;
tmp16u = 0;
}
for(i = 0; i < z_info->a_max; i++)
{
if(i < tmp32u)
{
if(!clear) tmp16u = read_int("a_info");
}
p_ptr->a_info[i] = tmp16u;
}
end_section_read("found_artifacts");
}
/* Hack -- no ghosts */
/* r_info[z_info->r_max - 1].max_num = 0; */
end_section_read("mangband_player_save");
/* Success */
return (0);
}
/* For wilderness levels, dun_depth has been changed from 1 to 4 bytes. */
static void rd_item(object_type *o_ptr)
{
byte old_dd;
byte old_ds;
u32b f1, f2, f3;
object_kind *k_ptr;
char note[128];
start_section_read("item");
/* Hack -- wipe */
WIPE(o_ptr, object_type);
/* Skip name */
skip_value("name");
/* Kind */
o_ptr->k_idx = read_int("k_idx");
/* Location */
o_ptr->iy = read_int("iy");
o_ptr->ix = read_int("ix");
o_ptr->dun_depth = read_int("dun_depth");
/* Type/Subtype */
o_ptr->tval = read_int("tval");
o_ptr->sval = read_int("sval");
/* Base pval */
o_ptr->bpval = read_int("bpval");
/* Special pval */
o_ptr->pval = read_int("pval");
o_ptr->discount = read_int("discount");
o_ptr->number = read_int("number");
o_ptr->weight = read_int("weight");
o_ptr->name1 = read_int("name1");
o_ptr->name2 = read_int("name2");
o_ptr->name3 = read_int("name3");
o_ptr->timeout = read_int("timeout");
o_ptr->to_h = read_int("to_h");
o_ptr->to_d = read_int("to_d");
o_ptr->to_a = read_int("to_a");
o_ptr->ac = read_int("ac");
old_dd = read_int("dd");
old_ds = read_int("ds");
o_ptr->ident = read_int("ident");
/* Special powers */
o_ptr->xtra1 = read_int("xtra1");
o_ptr->xtra2 = read_int("xtra2");
/* Inscription */
read_str("inscription",note);
/* Save the inscription */
if (note[0]) o_ptr->note = quark_add(note);
/* Owner information */
if (value_exists("owner_name"))
{
/* Name */
read_str("owner_name",note);
/* Save */
if (!STRZERO(note)) o_ptr->owner_name = quark_add(note);
/* Id */
o_ptr->owner_id = read_int("owner_id");
}
/* Monster holding object */
o_ptr->held_m_idx = read_int("held_m_idx");
end_section_read("item");
/* Mega-Hack -- handle "dungeon objects" later */
if ((o_ptr->k_idx >= 445) && (o_ptr->k_idx <= 479)) return;
/* Obtain the "kind" template */
k_ptr = &k_info[o_ptr->k_idx];
/* Obtain tval/sval from k_info */
o_ptr->tval = k_ptr->tval;
o_ptr->sval = k_ptr->sval;
/* Hack -- notice "broken" items */
if (k_ptr->cost <= 0) o_ptr->ident |= ID_BROKEN;
/* Repair non "wearable" items */
if (!wearable_p(o_ptr))
{
/* Acquire correct fields */
o_ptr->to_h = k_ptr->to_h;
o_ptr->to_d = k_ptr->to_d;
o_ptr->to_a = k_ptr->to_a;
/* Acquire correct fields */
o_ptr->ac = k_ptr->ac;
o_ptr->dd = k_ptr->dd;
o_ptr->ds = k_ptr->ds;
/* Acquire correct weight */
o_ptr->weight = k_ptr->weight;
/* Paranoia */
o_ptr->name1 = o_ptr->name2 = 0;
/* All done */
return;
}
/* Extract the flags */
object_flags(o_ptr, &f1, &f2, &f3);
/* Paranoia */
if (true_artifact_p(o_ptr))
{
artifact_type *a_ptr;
/* Obtain the artifact info */
a_ptr = &a_info[o_ptr->name1];
/* Verify that artifact */
if (!a_ptr->name) o_ptr->name1 = 0;
}
/* Paranoia */
if (o_ptr->name2)
{
ego_item_type *e_ptr;
/* Obtain the ego-item info */
e_ptr = &e_info[o_ptr->name2];
/* Verify that ego-item */
if (!e_ptr->name) o_ptr->name2 = 0;
}
/* Acquire standard fields */
o_ptr->ac = k_ptr->ac;
o_ptr->dd = k_ptr->dd;
o_ptr->ds = k_ptr->ds;
/* Acquire standard weight */
o_ptr->weight = k_ptr->weight;
/* Hack -- extract the "broken" flag */
if (o_ptr->pval < 0) o_ptr->ident |= ID_BROKEN;
/* Artifacts */
if (artifact_p(o_ptr))
{
artifact_type *a_ptr;
/* Obtain the artifact info */
#if defined(RANDART)
if (o_ptr->name1 == ART_RANDART)
{
a_ptr = randart_make(o_ptr);
}
else
{
#endif
a_ptr = &a_info[o_ptr->name1];
#if defined(RANDART)
}
#endif
/* Acquire new artifact "pval" */
o_ptr->pval = a_ptr->pval;
/* Acquire new artifact fields */
o_ptr->ac = a_ptr->ac;
o_ptr->dd = a_ptr->dd;
o_ptr->ds = a_ptr->ds;
/* Acquire new artifact weight */
o_ptr->weight = a_ptr->weight;
/* Hack -- extract the "broken" flag */
if (!a_ptr->cost) o_ptr->ident |= ID_BROKEN;
}
/* Ego items */
if (o_ptr->name2)
{
ego_item_type *e_ptr;
/* Obtain the ego-item info */
e_ptr = &e_info[o_ptr->name2];
/* Hack -- keep some old fields */
if ((o_ptr->dd < old_dd) && (o_ptr->ds == old_ds))
{
/* Keep old boosted damage dice */
o_ptr->dd = old_dd;
}
/* Hack -- extract the "broken" flag */
if (!e_ptr->cost) o_ptr->ident |= ID_BROKEN;
/* Mega-Hack - Enforce the special broken items */
if ((o_ptr->name2 == EGO_BLASTED) ||
(o_ptr->name2 == EGO_SHATTERED))
{
/* These were set to k_info values by preceding code */
o_ptr->ac = 0;
o_ptr->dd = 0;
o_ptr->ds = 0;
}
}
}
/*
* Inscribe an object with a comment
*/
void do_cmd_inscribe(void)
{
int item;
object_type *o_ptr;
char o_name[80];
char tmp[80];
cptr q, s;
/* Get an item */
q = "Inscribe which item? ";
s = "You have nothing to inscribe.";
if (!get_item(&item, q, s, (USE_EQUIP | USE_INVEN | USE_FLOOR))) return;
/* Get the item (in the pack) */
if (item >= 0)
{
o_ptr = &inventory[item];
}
/* Get the item (on the floor) */
else
{
o_ptr = &o_list[0 - item];
}
/* Describe the activity */
object_desc(o_name, sizeof(o_name), o_ptr, TRUE, 3);
/* Message */
msg_format("Inscribing %s.", o_name);
message_flush();
/* Start with nothing */
my_strcpy(tmp, "", sizeof(tmp));
/* Use old inscription */
if (o_ptr->obj_note)
{
/* Start with the old inscription */
strnfmt(tmp, sizeof(tmp), "%s", quark_str(o_ptr->obj_note));
}
/* Get a new inscription (possibly empty) */
if (term_get_string("Inscription: ", tmp, sizeof(tmp)))
{
char tmp_val[160];
char o_name2[80];
/*make a fake object so we can give a proper message*/
object_type *i_ptr;
object_type object_type_body;
// if given an empty inscription, then uninscribe instead
if (strlen(tmp) == 0)
{
uninscribe(o_ptr);
return;
}
/* Save the inscription */
o_ptr->obj_note = quark_add(tmp);
/* Add an autoinscription? */
// Sil-y: removed restriction to known items (through 'object_aware')
if (!(k_info[o_ptr->k_idx].flags3 & (TR3_INSTA_ART)))
{
/* Get local object */
i_ptr = &object_type_body;
/* Wipe the object */
object_wipe(i_ptr);
/* Create the object */
object_prep(i_ptr, o_ptr->k_idx);
/*make it plural*/
i_ptr->number = 2;
/*now describe with correct amount*/
object_desc(o_name2, sizeof(o_name2), i_ptr, FALSE, 0);
/* Prompt */
strnfmt(tmp_val, sizeof(tmp_val), "Automatically inscribe all %s with '%s'? ",
o_name2, tmp);
/* Auto-Inscribe if they want that */
if (get_check(tmp_val)) add_autoinscription(o_ptr->k_idx, tmp);
}
/* Combine the pack */
p_ptr->notice |= (PN_COMBINE);
/* Window stuff */
p_ptr->window |= (PW_INVEN | PW_EQUIP);
}
}
/*
* Read an object
*
* This function attempts to "repair" old savefiles, and to extract
* the most up to date values for various object fields.
*
* Note that Angband 2.7.9 introduced a new method for object "flags"
* in which the "flags" on an object are actually extracted when they
* are needed from the object kind, artifact index, ego-item index,
* and two special "xtra" fields which are used to encode any "extra"
* power of certain ego-items. This had the side effect that items
* imported from pre-2.7.9 savefiles will lose any "extra" powers they
* may have had, and also, all "uncursed" items will become "cursed"
* again, including Calris, even if it is being worn at the time. As
* a complete hack, items which are inscribed with "uncursed" will be
* "uncursed" when imported from pre-2.7.9 savefiles.
*/
static void rd_item(object_type *o_ptr)
{
char buf[128];
/* Kind */
rd_s16b(&o_ptr->k_idx);
/* Location */
rd_byte(&o_ptr->iy);
rd_byte(&o_ptr->ix);
/* Type/Subtype */
rd_byte(&o_ptr->tval);
rd_byte(&o_ptr->sval);
rd_s32b(&o_ptr->pval);
rd_byte(&o_ptr->discount);
rd_byte(&o_ptr->number);
rd_s16b(&o_ptr->weight);
rd_byte(&o_ptr->name1);
rd_byte(&o_ptr->name2);
rd_s32b(&o_ptr->timeout);
rd_s16b(&o_ptr->to_h);
rd_s16b(&o_ptr->to_d);
rd_s16b(&o_ptr->to_a);
rd_s16b(&o_ptr->ac);
rd_byte(&o_ptr->dd);
rd_byte(&o_ptr->ds);
rd_byte(&o_ptr->ident);
rd_byte(&o_ptr->marked);
/* Old flags */
rd_u32b(&o_ptr->art_flags1);
rd_u32b(&o_ptr->art_flags2);
rd_u32b(&o_ptr->art_flags3);
/* Monster holding object */
rd_s16b(&o_ptr->held_m_idx);
/* Special powers */
rd_byte(&o_ptr->xtra1);
rd_byte(&o_ptr->xtra2);
rd_s16b(&o_ptr->xtra3);
/* Feeling - from 2.3.1, "savefile version 1" */
rd_byte(&o_ptr->feeling);
/* Inscription */
rd_string(buf, sizeof(buf));
/* If this savefile is old, maybe we need to translate the feeling */
if (sf_version < 1)
{
byte i;
for (i = 0; i <= FEEL_MAX; i++)
{
if (game_inscriptions[i] == NULL)
{
continue;
}
if (streq(buf, game_inscriptions[i]))
{
o_ptr->feeling = i;
buf[0] = 0;
break;
}
}
}
/* Save the inscription */
if (buf[0]) o_ptr->inscription = quark_add(buf);
/* Random artifact */
rd_string(buf, sizeof(buf));
if (buf[0]) o_ptr->art_name = quark_add(buf);
/* Named ego */
rd_string(buf, sizeof(buf));
if (buf[0]) o_ptr->ego_name = quark_add(buf);
/* The Python object - old */
{
s32b tmp32s;
rd_s32b(&tmp32s);
strip_bytes(tmp32s);
}
#if 0
/* Mega-Hack -- handle "dungeon objects" later */
if ((o_ptr->k_idx >= 445) && (o_ptr->k_idx <= 479)) return;
#endif
/* Paranoia */
if (o_ptr->name1)
{
artifact_type *a_ptr;
/* Obtain the artifact info */
a_ptr = &a_info[o_ptr->name1];
/* Verify that artifact */
if (!a_ptr->name) o_ptr->name1 = 0;
}
/* Paranoia */
if (o_ptr->name2)
{
ego_item_type *e_ptr;
/* Obtain the ego-item info */
e_ptr = &e_info[o_ptr->name2];
/* Verify that ego-item */
if (!e_ptr->name) o_ptr->name2 = 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_item(object_type *o_ptr)
{
u32b f1, f2, f3;
object_kind *k_ptr;
char buf[128];
int i;
/* Kind */
rd_s16b(&o_ptr->k_idx);
/* Paranoia */
if ((o_ptr->k_idx < 0) || (o_ptr->k_idx >= z_info->k_max))
{
return (-1);
}
/* Hallucinatory Kind */
rd_s16b(&o_ptr->image_k_idx);
/* Location */
rd_byte(&o_ptr->iy);
rd_byte(&o_ptr->ix);
/* Type/Subtype */
rd_byte(&o_ptr->tval);
rd_byte(&o_ptr->sval);
/* Special pval */
rd_s16b(&o_ptr->pval);
rd_byte(&o_ptr->discount);
rd_byte(&o_ptr->number);
rd_s16b(&o_ptr->weight);
rd_byte(&o_ptr->name1);
rd_byte(&o_ptr->name2);
rd_s16b(&o_ptr->timeout);
rd_s16b(&o_ptr->att);
rd_byte(&o_ptr->dd);
rd_byte(&o_ptr->ds);
rd_s16b(&o_ptr->evn);
rd_byte(&o_ptr->pd);
rd_byte(&o_ptr->ps);
rd_byte(&o_ptr->pickup);
rd_u32b(&o_ptr->ident);
rd_byte(&o_ptr->marked);
/* Monster holding object */
rd_s16b(&o_ptr->held_m_idx);
/* Special powers */
rd_byte(&o_ptr->xtra1);
// granted abilities
rd_byte(&o_ptr->abilities);
for (i = 0; i < 8; i++)
{
rd_byte(&o_ptr->skilltype[i]);
rd_byte(&o_ptr->abilitynum[i]);
}
// 8 spare bytes
strip_bytes(8);
/* Inscription */
rd_string(buf, sizeof(buf));
/* Save the inscription */
if (buf[0]) o_ptr->obj_note = quark_add(buf);
/* Obtain the "kind" template */
k_ptr = &k_info[o_ptr->k_idx];
/* Obtain tval/sval from k_info */
o_ptr->tval = k_ptr->tval;
o_ptr->sval = k_ptr->sval;
/* Hack -- notice "broken" items */
if (k_ptr->cost <= 0) o_ptr->ident |= (IDENT_BROKEN);
/* Repair non "wearable" items */
if (!wearable_p(o_ptr))
{
/* Get the correct fields */
o_ptr->att = k_ptr->att;
o_ptr->evn = k_ptr->evn;
/* Get the correct fields */
o_ptr->dd = k_ptr->dd;
o_ptr->ds = k_ptr->ds;
o_ptr->pd = k_ptr->pd;
o_ptr->ps = k_ptr->ps;
/* Get the correct weight */
o_ptr->weight = k_ptr->weight;
/* Paranoia */
o_ptr->name1 = o_ptr->name2 = 0;
/* All done */
return (0);
}
/* Extract the flags */
object_flags(o_ptr, &f1, &f2, &f3);
/* Paranoia */
if (o_ptr->name1)
{
artefact_type *a_ptr;
/*hack - adjust if new artefact*/
if (o_ptr->name1 >= art_norm_count)
{
o_ptr->name1 += new_artefacts;
}
/* Paranoia */
if (o_ptr->name1 >= z_info->art_max)
{
return (-1);
}
/* Obtain the artefact info */
a_ptr = &a_info[o_ptr->name1];
/* Verify that artefact */
if (a_ptr->tval + a_ptr->sval == 0)
{
o_ptr->name1 = 0;
}
}
/* Paranoia */
if (o_ptr->name2)
{
ego_item_type *e_ptr;
/* Paranoia */
if (o_ptr->name2 >= z_info->e_max)
{
return (-1);
}
/* Obtain the special item info */
e_ptr = &e_info[o_ptr->name2];
/* Verify that special item */
if (!e_ptr->name) o_ptr->name2 = 0;
}
/* Hack -- extract the "broken" flag */
if (o_ptr->pval < 0) o_ptr->ident |= (IDENT_BROKEN);
/* Artefacts */
if (o_ptr->name1)
{
artefact_type *a_ptr;
/* Obtain the artefact info */
a_ptr = &a_info[o_ptr->name1];
/* Get the new artefact "pval" */
o_ptr->pval = a_ptr->pval;
/* Get the new artefact fields */
o_ptr->dd = a_ptr->dd;
o_ptr->ds = a_ptr->ds;
o_ptr->pd = a_ptr->pd;
o_ptr->ps = a_ptr->ps;
o_ptr->evn = a_ptr->evn;
/* Get the new artefact weight */
o_ptr->weight = a_ptr->weight;
/* Hack -- extract the "broken" flag */
if (!a_ptr->cost) o_ptr->ident |= (IDENT_BROKEN);
}
/* Ego items */
if (o_ptr->name2)
{
ego_item_type *e_ptr;
/* Obtain the special item info */
e_ptr = &e_info[o_ptr->name2];
/* Hack -- extract the "broken" flag */
if (!e_ptr->cost) o_ptr->ident |= (IDENT_BROKEN);
/* Hack -- enforce legal pval */
if (e_ptr->flags1 & (TR1_PVAL_MASK))
{
/* Force a meaningful pval */
if (!o_ptr->pval) o_ptr->pval = 1;
}
}
/* Used to add back boosted damage dice and sides */
/* No longer needed as we don't repair non-artefacts anymore */
/* Success */
return (0);
}
/*
* Read the "extra" information
*/
static errr rd_extra(void)
{
int i, j;
byte tmp8u;
u16b file_e_max;
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);
}
/* Player house */
rd_byte(&p_ptr->phouse);
/* Verify player house */
if (p_ptr->phouse >= z_info->c_max)
{
note(format("Invalid player house (%d).", p_ptr->phouse));
return (-1);
}
/* Player sex */
rd_byte(&p_ptr->psex);
/* Tutorial? */
rd_s16b(&p_ptr->game_type);
/* 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_base[i]);
for (i = 0; i < A_MAX; i++) rd_s16b(&p_ptr->stat_drain[i]);
/* Read the skill info */
for (i = 0; i < S_MAX; i++) rd_s16b(&p_ptr->skill_base[i]);
/* Read the abilities info */
for (i = 0; i < S_MAX; i++)
{
for (j = 0; j < ABILITIES_MAX; j++)
{
rd_byte(&p_ptr->innate_ability[i][j]);
rd_byte(&p_ptr->active_ability[i][j]);
}
}
rd_s16b(&p_ptr->last_attack_m_idx);
rd_s16b(&p_ptr->consecutive_attacks);
rd_s16b(&p_ptr->bane_type);
for (i = 0; i < ACTION_MAX; ++i)
{
rd_byte(&(p_ptr->previous_action[i]));
}
rd_byte(&p_ptr->focused);
rd_s32b(&p_ptr->new_exp);
rd_s32b(&p_ptr->exp);
rd_s32b(&p_ptr->encounter_exp);
rd_s32b(&p_ptr->kill_exp);
rd_s32b(&p_ptr->descent_exp);
rd_s32b(&p_ptr->ident_exp);
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_depth);
/* Hack -- Repair maximum dungeon level */
if (p_ptr->max_depth < 0) p_ptr->max_depth = 1;
rd_u16b(&p_ptr->staircasiness);
/* More info */
rd_s16b(&p_ptr->sc);
/* Read the flags */
rd_byte(&p_ptr->song1);
rd_byte(&p_ptr->song2);
rd_s16b(&p_ptr->song_duration);
rd_s16b(&p_ptr->wrath);
rd_s16b(&p_ptr->blind);
rd_s16b(&p_ptr->entranced);
rd_s16b(&p_ptr->confused);
rd_s16b(&p_ptr->food);
rd_u16b(&p_ptr->stairs_taken);
rd_u16b(&p_ptr->forge_drought);
rd_u16b(&p_ptr->forge_count);
rd_s16b(&p_ptr->energy);
rd_s16b(&p_ptr->fast);
rd_s16b(&p_ptr->slow);
rd_s16b(&p_ptr->afraid);
rd_s16b(&p_ptr->cut);
rd_s16b(&p_ptr->stun);
rd_s16b(&p_ptr->poisoned);
rd_s16b(&p_ptr->image);
rd_s16b(&p_ptr->rage);
rd_s16b(&p_ptr->tmp_str);
rd_s16b(&p_ptr->tmp_dex);
rd_s16b(&p_ptr->tmp_con);
rd_s16b(&p_ptr->tmp_gra);
rd_s16b(&p_ptr->tim_invis);
rd_s16b(&p_ptr->word_recall);
rd_s16b(&p_ptr->darkened);
rd_s16b(&p_ptr->oppose_fire);
rd_s16b(&p_ptr->oppose_cold);
rd_s16b(&p_ptr->oppose_pois);
rd_byte(&p_ptr->stealth_mode);
rd_byte(&p_ptr->self_made_arts);
// 20 spare bytes
strip_bytes(20);
/* Read item-quality squelch sub-menu */
for (i = 0; i < SQUELCH_BYTES; i++) rd_byte(&squelch_level[i]);
/* Load the name of the current greater vault */
rd_string(g_vault_name, sizeof(g_vault_name));
/* Read the number of saved special item types */
rd_u16b(&file_e_max);
/* Read special item squelch settings */
for (i = 0; i < z_info->e_max; i++)
{
ego_item_type *e_ptr = &e_info[i];
tmp8u = 0;
if (i < file_e_max) rd_byte(&tmp8u);
e_ptr->squelch |= (tmp8u & 0x01);
e_ptr->everseen |= (tmp8u & 0x02);
e_ptr->aware |= (tmp8u & 0x04);
/* Hack - Repair the savefile */
if (!e_ptr->everseen) e_ptr->squelch = FALSE;
}
/* Read possible extra elements */
while (i < file_e_max)
{
rd_byte(&tmp8u);
i++;
}
/*Write the current number of auto-inscriptions*/
rd_u16b(&inscriptionsCount);
/*Write the autoinscriptions array*/
for(i = 0; i < inscriptionsCount; i++)
{
char tmp[80];
rd_s16b(&inscriptions[i].kindIdx);
rd_string(tmp, 80);
inscriptions[i].inscriptionIdx = quark_add(tmp);
}
for (i = 0; i < MAX_GREATER_VAULTS; i++)
{
s16b n;
rd_s16b(&n);
p_ptr->greater_vaults[i] = n;
}
/* Read the randart version */
rd_u32b(&randart_version);
/* Read the randart seed */
rd_u32b(&seed_randart);
/* Hack -- the two "special seeds" */
rd_u32b(&seed_flavor);
/* Special stuff */
rd_u16b(&p_ptr->panic_save);
rd_byte(&p_ptr->truce);
rd_byte(&p_ptr->morgoth_hits);
rd_byte(&p_ptr->crown_hint);
rd_byte(&p_ptr->crown_shatter);
rd_byte(&p_ptr->cursed);
rd_byte(&p_ptr->on_the_run);
rd_byte(&p_ptr->morgoth_slain);
rd_u16b(&p_ptr->escaped);
rd_u16b(&p_ptr->noscore);
rd_s16b(&p_ptr->smithing_leftover);
rd_byte(&tmp8u);
p_ptr->unique_forge_made = tmp8u;
rd_byte(&tmp8u);
p_ptr->unique_forge_seen = tmp8u;
/* Read "death" */
rd_byte(&tmp8u);
p_ptr->is_dead = tmp8u;
/* Read "feeling" */
rd_byte(&tmp8u);
feeling = tmp8u;
/*read the level feeling*/
rd_byte(&tmp8u);
do_feeling = tmp8u;
/* Current turn */
rd_s32b(&turn);
/* Current player turn */
rd_s32b(&playerturn);
return (0);
}
/**
* Read an object.
*/
static struct object *rd_item(void)
{
struct object *obj = object_new();
byte tmp8u;
u16b tmp16u;
byte effect;
size_t i;
char buf[128];
byte ver = 1;
rd_u16b(&tmp16u);
rd_byte(&ver);
if (tmp16u != 0xffff)
return NULL;
rd_u16b(&obj->oidx);
/* Location */
rd_byte(&obj->iy);
rd_byte(&obj->ix);
/* Type/Subtype */
rd_string(buf, sizeof(buf));
if (buf[0]) {
obj->tval = tval_find_idx(buf);
}
rd_string(buf, sizeof(buf));
if (buf[0]) {
obj->sval = lookup_sval(obj->tval, buf);
}
rd_s16b(&obj->pval);
rd_byte(&obj->number);
rd_s16b(&obj->weight);
rd_string(buf, sizeof(buf));
if (buf[0]) {
obj->artifact = lookup_artifact_name(buf);
if (!obj->artifact) {
note(format("Couldn't find artifact %s!", buf));
return NULL;
}
}
rd_string(buf, sizeof(buf));
if (buf[0]) {
obj->ego = lookup_ego_item(buf, obj->tval, obj->sval);
if (!obj->ego) {
note(format("Couldn't find ego item %s!", buf));
return NULL;
}
}
rd_byte(&effect);
rd_s16b(&obj->timeout);
rd_s16b(&obj->to_h);
rd_s16b(&obj->to_d);
rd_s16b(&obj->to_a);
rd_s16b(&obj->ac);
rd_byte(&obj->dd);
rd_byte(&obj->ds);
rd_byte(&obj->origin);
rd_byte(&obj->origin_depth);
rd_string(buf, sizeof(buf));
if (buf[0]) {
obj->origin_race = lookup_monster(buf);
}
rd_byte(&obj->notice);
for (i = 0; i < of_size; i++)
rd_byte(&obj->flags[i]);
for (i = 0; i < obj_mod_max; i++) {
rd_s16b(&obj->modifiers[i]);
}
/* Read brands */
rd_byte(&tmp8u);
if (tmp8u) {
obj->brands = mem_zalloc(z_info->brand_max * sizeof(bool));
for (i = 0; i < brand_max; i++) {
rd_byte(&tmp8u);
obj->brands[i] = tmp8u ? true : false;
}
}
/* Read slays */
rd_byte(&tmp8u);
if (tmp8u) {
obj->slays = mem_zalloc(z_info->slay_max * sizeof(bool));
for (i = 0; i < slay_max; i++) {
rd_byte(&tmp8u);
obj->slays[i] = tmp8u ? true : false;
}
}
/* Read curses */
rd_byte(&tmp8u);
if (tmp8u) {
obj->curses = mem_zalloc(z_info->curse_max * sizeof(struct curse_data));
for (i = 0; i < curse_max; i++) {
rd_byte(&tmp8u);
obj->curses[i].power = tmp8u;
rd_u16b(&tmp16u);
obj->curses[i].timeout = tmp16u;
}
}
for (i = 0; i < elem_max; i++) {
rd_s16b(&obj->el_info[i].res_level);
rd_byte(&obj->el_info[i].flags);
}
/* Monster holding object */
rd_s16b(&obj->held_m_idx);
rd_s16b(&obj->mimicking_m_idx);
/* Activation */
rd_u16b(&tmp16u);
if (tmp16u)
obj->activation = &activations[tmp16u];
rd_u16b(&tmp16u);
obj->time.base = tmp16u;
rd_u16b(&tmp16u);
obj->time.dice = tmp16u;
rd_u16b(&tmp16u);
obj->time.sides = tmp16u;
/* Save the inscription */
rd_string(buf, sizeof(buf));
if (buf[0]) obj->note = quark_add(buf);
/* Lookup item kind */
obj->kind = lookup_kind(obj->tval, obj->sval);
/* Check we have a kind */
if ((!obj->tval && !obj->sval) || !obj->kind) {
object_delete(&obj);
return NULL;
}
/* Set effect */
if (effect && obj->ego)
obj->effect = obj->ego->effect;
if (effect && !obj->effect)
obj->effect = obj->kind->effect;
/* Success */
return obj;
}
/*
* Read an object
*
* This function attempts to "repair" old savefiles, and to extract
* the most up to date values for various object fields.
*/
static int rd_item(object_type *o_ptr)
{
byte old_dd;
byte old_ds;
byte tmp8u;
size_t i;
object_kind *k_ptr;
char buf[128];
/* Kind */
rd_s16b(&o_ptr->k_idx);
/* Paranoia */
if ((o_ptr->k_idx < 0) || (o_ptr->k_idx >= z_info->k_max))
return (-1);
/* Location */
rd_byte(&o_ptr->iy);
rd_byte(&o_ptr->ix);
/* Type/Subtype */
rd_byte(&o_ptr->tval);
rd_byte(&o_ptr->sval);
rd_s16b(&o_ptr->pval);
/* Pseudo-ID bit */
rd_byte(&tmp8u);
rd_byte(&o_ptr->number);
rd_s16b(&o_ptr->weight);
rd_byte(&o_ptr->name1);
rd_byte(&o_ptr->name2);
rd_s16b(&o_ptr->timeout);
rd_s16b(&o_ptr->to_h);
rd_s16b(&o_ptr->to_d);
rd_s16b(&o_ptr->to_a);
rd_s16b(&o_ptr->ac);
rd_byte(&old_dd);
rd_byte(&old_ds);
rd_byte(&tmp8u);
rd_byte(&o_ptr->marked);
rd_byte(&o_ptr->origin);
rd_byte(&o_ptr->origin_depth);
rd_u16b(&o_ptr->origin_xtra);
/* Hack - XXX - MarbleDice - Maximum saveable flags = 96 */
for (i = 0; i < 12 && i < OF_SIZE; i++)
rd_byte(&o_ptr->flags[i]);
if (i < 12) strip_bytes(OF_SIZE - i);
/* Monster holding object */
rd_s16b(&o_ptr->held_m_idx);
rd_string(buf, sizeof(buf));
/* Save the inscription */
if (buf[0]) o_ptr->note = quark_add(buf);
/* Lookup item kind */
o_ptr->k_idx = lookup_kind(o_ptr->tval, o_ptr->sval);
k_ptr = &k_info[o_ptr->k_idx];
/* Return now in case of "blank" or "empty" objects */
if (!k_ptr->name || !o_ptr->k_idx)
{
o_ptr->k_idx = 0;
return 0;
}
/* Repair non "wearable" items */
if (!wearable_p(o_ptr))
{
/* Get the correct fields */
if (!randcalc_valid(k_ptr->to_h, o_ptr->to_h))
o_ptr->to_h = randcalc(k_ptr->to_h, o_ptr->origin_depth, RANDOMISE);
if (!randcalc_valid(k_ptr->to_d, o_ptr->to_d))
o_ptr->to_d = randcalc(k_ptr->to_d, o_ptr->origin_depth, RANDOMISE);
if (!randcalc_valid(k_ptr->to_a, o_ptr->to_a))
o_ptr->to_a = randcalc(k_ptr->to_a, o_ptr->origin_depth, RANDOMISE);
/* Get the correct fields */
o_ptr->ac = k_ptr->ac;
o_ptr->dd = k_ptr->dd;
o_ptr->ds = k_ptr->ds;
/* Get the correct weight */
o_ptr->weight = k_ptr->weight;
/* Paranoia */
o_ptr->name1 = o_ptr->name2 = 0;
/* All done */
return (0);
}
/* Paranoia */
if (o_ptr->name1)
{
artifact_type *a_ptr;
/* Paranoia */
if (o_ptr->name1 >= z_info->a_max) return (-1);
/* Obtain the artifact info */
a_ptr = &a_info[o_ptr->name1];
/* Verify that artifact */
if (!a_ptr->name) o_ptr->name1 = 0;
}
/* Paranoia */
if (o_ptr->name2)
{
ego_item_type *e_ptr;
/* Paranoia */
if (o_ptr->name2 >= z_info->e_max) return (-1);
/* Obtain the ego-item info */
e_ptr = &e_info[o_ptr->name2];
/* Verify that ego-item */
if (!e_ptr->name) o_ptr->name2 = 0;
}
/* Get the standard fields */
o_ptr->ac = k_ptr->ac;
o_ptr->dd = k_ptr->dd;
o_ptr->ds = k_ptr->ds;
/* Get the standard weight */
o_ptr->weight = k_ptr->weight;
/* Artifacts */
if (o_ptr->name1)
{
artifact_type *a_ptr;
/* Obtain the artifact info */
a_ptr = &a_info[o_ptr->name1];
/* Get the new artifact "pval" */
o_ptr->pval = a_ptr->pval;
/* Get the new artifact fields */
o_ptr->ac = a_ptr->ac;
o_ptr->dd = a_ptr->dd;
o_ptr->ds = a_ptr->ds;
/* Get the new artifact weight */
o_ptr->weight = a_ptr->weight;
}
/* Ego items */
if (o_ptr->name2)
{
ego_item_type *e_ptr;
/* Obtain the ego-item info */
e_ptr = &e_info[o_ptr->name2];
/* Hack -- keep some old fields */
if ((o_ptr->dd < old_dd) && (o_ptr->ds == old_ds))
{
/* Keep old boosted damage dice */
o_ptr->dd = old_dd;
}
/* Hack -- enforce legal pval */
if (flags_test(e_ptr->flags, OF_SIZE, OF_PVAL_MASK, FLAG_END))
{
/* Force a meaningful pval */
if (!o_ptr->pval) o_ptr->pval = 1;
}
}
/* 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_item(object_type *o_ptr)
{
byte old_dd;
byte old_ds;
u32b f1, f2, f3;
object_kind *k_ptr;
char buf[128];
/* Kind */
rd_s16b(&o_ptr->k_idx);
/* Paranoia */
if ((o_ptr->k_idx < 0) || (o_ptr->k_idx >= z_info->k_max))
return (-1);
/* Location */
rd_byte(&o_ptr->iy);
rd_byte(&o_ptr->ix);
/* Type/Subtype */
rd_byte(&o_ptr->tval);
rd_byte(&o_ptr->sval);
/* Special pval */
rd_s16b(&o_ptr->pval);
/* Special stack counter */
if ((variant_pval_stacks)||(variant_time_stacks)) rd_byte(&o_ptr->stackc);
rd_byte(&o_ptr->discount);
rd_byte(&o_ptr->number);
rd_s16b(&o_ptr->weight);
rd_byte(&o_ptr->name1);
rd_byte(&o_ptr->name2);
rd_s16b(&o_ptr->timeout);
rd_s16b(&o_ptr->to_h);
rd_s16b(&o_ptr->to_d);
rd_s16b(&o_ptr->to_a);
rd_s16b(&o_ptr->ac);
rd_byte(&old_dd);
rd_byte(&old_ds);
rd_byte(&o_ptr->ident);
rd_byte(&o_ptr->marked);
/* Hack -- fix rod/ring/dragon armor pval so that timeout set correctly in future */
if ((o_ptr->tval == TV_ROD) || (o_ptr->tval == TV_DRAG_ARMOR) || ((o_ptr->tval == TV_RING) &&
((o_ptr->sval == SV_RING_FLAMES) || (o_ptr->sval == SV_RING_ACID) || (o_ptr->sval == SV_RING_ICE) ||
(o_ptr->sval == SV_RING_LIGHTNING))))
{
o_ptr->pval = k_info[o_ptr->k_idx].pval;
}
/* Hack -- remove chests */
if (o_ptr->tval == TV_CHEST) o_ptr->k_idx = 0;
/* Old flags */
strip_bytes(12);
/* Monster holding object */
rd_s16b(&o_ptr->held_m_idx);
/* Special powers */
rd_byte(&o_ptr->xtra1);
rd_byte(&o_ptr->xtra2);
/* Flags we have learnt about an item */
if (variant_learn_id)
{
/* Knowledge */
rd_u32b(&o_ptr->can_flags1);
rd_u32b(&o_ptr->can_flags2);
rd_u32b(&o_ptr->can_flags3);
rd_u32b(&o_ptr->may_flags1);
rd_u32b(&o_ptr->may_flags2);
rd_u32b(&o_ptr->may_flags3);
rd_u32b(&o_ptr->not_flags1);
rd_u32b(&o_ptr->not_flags2);
rd_u32b(&o_ptr->not_flags3);
}
/* Times we have used an item */
if (variant_usage_id) rd_s16b(&o_ptr->usage);
/* Guessed an item as */
if (variant_guess_id)
{
rd_byte(&o_ptr->guess1);
rd_byte(&o_ptr->guess2);
}
/* Item has a monster 'flavor' */
if (variant_drop_body)
{
rd_s16b(&o_ptr->name3);
}
/* Inscription */
rd_string(buf, 128);
/* Save the inscription */
if (buf[0]) o_ptr->note = quark_add(buf);
/* Obtain the "kind" template */
k_ptr = &k_info[o_ptr->k_idx];
/* Obtain tval/sval from k_info */
o_ptr->tval = k_ptr->tval;
o_ptr->sval = k_ptr->sval;
/* Hack -- notice "broken" items */
if (k_ptr->cost <= 0) o_ptr->ident |= (IDENT_BROKEN);
/* Repair non "wearable" items */
if (!wearable_p(o_ptr))
{
/* Get the correct fields */
o_ptr->to_h = k_ptr->to_h;
o_ptr->to_d = k_ptr->to_d;
o_ptr->to_a = k_ptr->to_a;
/* Get the correct fields */
o_ptr->ac = k_ptr->ac;
o_ptr->dd = k_ptr->dd;
o_ptr->ds = k_ptr->ds;
/* Get the correct weight */
o_ptr->weight = k_ptr->weight;
/* Paranoia */
o_ptr->name1 = o_ptr->name2 = 0;
/* All done */
return (0);
}
/* Extract the flags */
object_flags(o_ptr, &f1, &f2, &f3);
/* Paranoia */
if (o_ptr->name1)
{
artifact_type *a_ptr;
/* Paranoia */
if (o_ptr->name1 >= 256) return (-1);
/* Obtain the artifact info */
a_ptr = &a_info[o_ptr->name1];
/* Verify that artifact */
if (!a_ptr->name) o_ptr->name1 = 0;
}
/* Paranoia */
if (o_ptr->name2)
{
ego_item_type *e_ptr;
/* Paranoia */
if (o_ptr->name2 >= z_info->e_max) return (-1);
/* Obtain the ego-item info */
e_ptr = &e_info[o_ptr->name2];
/* Verify that ego-item */
if (!e_ptr->name) o_ptr->name2 = 0;
}
/* Get the standard fields */
o_ptr->ac = k_ptr->ac;
o_ptr->dd = k_ptr->dd;
o_ptr->ds = k_ptr->ds;
/* Get the standard weight */
o_ptr->weight = k_ptr->weight;
/* Hack -- extract the "broken" flag */
if (o_ptr->pval < 0) o_ptr->ident |= (IDENT_BROKEN);
/* Artifacts */
if (o_ptr->name1)
{
artifact_type *a_ptr;
/* Obtain the artifact info */
a_ptr = &a_info[o_ptr->name1];
/* Get the new artifact "pval" */
o_ptr->pval = a_ptr->pval;
/* Get the new artifact fields */
o_ptr->ac = a_ptr->ac;
o_ptr->dd = a_ptr->dd;
o_ptr->ds = a_ptr->ds;
/* Get the new artifact weight */
o_ptr->weight = a_ptr->weight;
/* Hack -- extract the "broken" flag */
if (!a_ptr->cost) o_ptr->ident |= (IDENT_BROKEN);
}
/* Ego items */
if (o_ptr->name2)
{
ego_item_type *e_ptr;
/* Obtain the ego-item info */
e_ptr = &e_info[o_ptr->name2];
/* Hack -- keep some old fields */
if ((o_ptr->dd < old_dd) && (o_ptr->ds == old_ds))
{
/* Keep old boosted damage dice */
o_ptr->dd = old_dd;
}
/* Hack -- extract the "broken" flag */
if (!e_ptr->cost) o_ptr->ident |= (IDENT_BROKEN);
/* Hack -- enforce legal pval */
if (e_ptr->flags1 & (TR1_PVAL_MASK))
{
/* Force a meaningful pval */
if (!o_ptr->pval) o_ptr->pval = 1;
}
/* Mega-Hack - Enforce the special broken items */
if ((o_ptr->name2 == EGO_BLASTED) ||
(o_ptr->name2 == EGO_SHATTERED))
{
/* These were set to k_info values by preceding code */
o_ptr->ac = 0;
o_ptr->dd = 0;
o_ptr->ds = 0;
}
}
/* 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_item(object_type *o_ptr)
{
byte old_dd;
byte old_ds;
u32b f1, f2, f3, fn;
object_kind *k_ptr;
char buf[128];
/* Kind */
rd_s16b(&o_ptr->k_idx);
/* Paranoia */
if ((o_ptr->k_idx < 0) || (o_ptr->k_idx >= z_info->k_max))
{
return (-1);
}
/* Location */
rd_byte(&o_ptr->iy);
rd_byte(&o_ptr->ix);
/* Type/Subtype */
rd_byte(&o_ptr->tval);
rd_byte(&o_ptr->sval);
/* Special pval */
rd_s16b(&o_ptr->pval);
rd_byte(&o_ptr->discount);
rd_byte(&o_ptr->number);
rd_s16b(&o_ptr->weight);
rd_byte(&o_ptr->art_num);
rd_byte(&o_ptr->ego_num);
rd_s16b(&o_ptr->timeout);
rd_s16b(&o_ptr->to_h);
rd_s16b(&o_ptr->to_d);
rd_s16b(&o_ptr->to_a);
rd_s16b(&o_ptr->ac);
rd_byte(&old_dd);
rd_byte(&old_ds);
rd_u32b(&o_ptr->ident);
rd_byte(&o_ptr->marked);
rd_s16b(&o_ptr->mimic_r_idx);
/* Old flags */
strip_bytes(12);
/* Monster holding object */
rd_s16b(&o_ptr->held_m_idx);
/* Special powers */
rd_byte(&o_ptr->xtra1);
rd_u32b(&o_ptr->xtra2);
/* Inscription */
rd_string(buf, sizeof(buf));
/* Save the inscription */
if (buf[0]) o_ptr->obj_note = quark_add(buf);
/* Object history */
rd_byte(&o_ptr->origin_nature);
rd_s16b(&o_ptr->origin_dlvl);
rd_s16b(&o_ptr->origin_r_idx);
rd_string(buf, sizeof(buf));
if (buf[0]) o_ptr->origin_m_name = quark_add(buf);
/* Obtain the "kind" template */
k_ptr = &k_info[o_ptr->k_idx];
/* Obtain tval/sval from k_info */
o_ptr->tval = k_ptr->tval;
o_ptr->sval = k_ptr->sval;
/* Hack -- notice "broken" items */
if (k_ptr->cost <= 0) o_ptr->ident |= (IDENT_BROKEN);
/* Ensure that rods and wands get the appropriate pvals,
* and transfer rod charges to timeout.
* this test should only be passed once, the first
* time the file is open with ROD/WAND stacking code
* It could change the timeout improperly if the PVAL (time a rod
* takes to charge after use) is changed in object.txt.
* But this is nothing a little resting won't solve.
*
* -JG-
*/
if ((o_ptr->tval == TV_ROD) && (o_ptr->pval - (k_ptr->pval * o_ptr->number) != 0))
{
o_ptr->timeout = o_ptr->pval;
o_ptr->pval = k_ptr->pval * o_ptr->number;
}
/* Repair non "wearable" items */
if (!wearable_p(o_ptr))
{
/* Get the correct fields */
o_ptr->to_h = k_ptr->to_h;
o_ptr->to_d = k_ptr->to_d;
o_ptr->to_a = k_ptr->to_a;
/* Get the correct fields */
o_ptr->ac = k_ptr->ac;
o_ptr->dd = k_ptr->dd;
o_ptr->ds = k_ptr->ds;
/* Get the correct weight */
o_ptr->weight = k_ptr->weight;
if ((o_ptr->tval != TV_MAGIC_BOOK) &&
(o_ptr->tval != TV_PRAYER_BOOK) &&
(o_ptr->tval != TV_DRUID_BOOK))
{
/* Paranoia */
o_ptr->art_num = o_ptr->ego_num = 0;
/* All done */
return (0);
}
/*spellbooks can now have an ego-item*/
else o_ptr->art_num = 0;
}
/* Extract the flags */
object_flags(o_ptr, &f1, &f2, &f3, &fn);
/* Paranoia */
if (o_ptr->art_num)
{
artifact_type *a_ptr;
/*hack - adjust if new artifact*/
if (o_ptr->art_num >= art_norm_count)
{
o_ptr->art_num += new_artifacts;
}
/* Paranoia */
if (o_ptr->art_num >= z_info->art_max)
{
return (-1);
}
/* Obtain the artifact info */
a_ptr = &a_info[o_ptr->art_num];
/* Verify that artifact */
if (a_ptr->tval + a_ptr->sval == 0)
{
o_ptr->art_num = 0;
}
}
/* Paranoia */
if (o_ptr->ego_num)
{
ego_item_type *e_ptr;
/* Paranoia */
if (o_ptr->ego_num >= z_info->e_max)
{
return (-1);
}
/* Obtain the ego-item info */
e_ptr = &e_info[o_ptr->ego_num];
/* Verify that ego-item */
if (!e_ptr->name) o_ptr->ego_num = 0;
}
/* Get the standard fields */
o_ptr->ac = k_ptr->ac;
o_ptr->dd = k_ptr->dd;
o_ptr->ds = k_ptr->ds;
/* Get the standard weight */
o_ptr->weight = k_ptr->weight;
/* Hack -- extract the "broken" flag */
if (o_ptr->pval < 0) o_ptr->ident |= (IDENT_BROKEN);
/* Artifacts */
if (o_ptr->art_num)
{
artifact_type *a_ptr;
/* Obtain the artifact info */
a_ptr = &a_info[o_ptr->art_num];
/* Get the new artifact "pval" */
o_ptr->pval = a_ptr->pval;
/* Get the new artifact fields */
o_ptr->ac = a_ptr->ac;
o_ptr->dd = a_ptr->dd;
o_ptr->ds = a_ptr->ds;
/* Get the new artifact weight */
o_ptr->weight = a_ptr->weight;
/* Hack -- extract the "broken" flag */
if (!a_ptr->cost) o_ptr->ident |= (IDENT_BROKEN);
}
/* Ego items */
if (o_ptr->ego_num)
{
ego_item_type *e_ptr;
/* Obtain the ego-item info */
e_ptr = &e_info[o_ptr->ego_num];
/* Hack -- extract the "broken" flag */
if (!e_ptr->cost) o_ptr->ident |= (IDENT_BROKEN);
/* Hack -- enforce legal pval */
if (e_ptr->flags1 & (TR1_PVAL_MASK))
{
/* Force a meaningful pval */
if (!o_ptr->pval) o_ptr->pval = 1;
}
/* Mega-Hack - Enforce the special broken items */
if ((o_ptr->ego_num == EGO_BLASTED) ||
(o_ptr->ego_num == EGO_SHATTERED))
{
/* These were set to k_info values by preceding code */
o_ptr->ac = 0;
o_ptr->dd = 0;
o_ptr->ds = 0;
}
}
/* Hack -- keep boosted damage dice and sides */
if (o_ptr->dd < old_dd) o_ptr->dd = old_dd;
if (o_ptr->ds < old_ds) o_ptr->ds = old_ds;
/* Hack -- *Identified* artifacts are known in future games */
if ((o_ptr->ident & (IDENT_MENTAL)) && ARTIFACT_EASY_MENTAL(o_ptr))
{
/* Mark as *identified* */
a_l_list[o_ptr->art_num].was_fully_identified = TRUE;
}
/* Success */
return (0);
}
/*
* Inscribe an object with a comment
*/
void do_cmd_inscribe(void)
{
int item;
object_type *o_ptr;
char o_name[MAX_NLEN];
char out_val[80];
cptr q, s;
item_tester_no_ryoute = TRUE;
/* Get an item */
q = "Inscribe which item? ";
s = "You have nothing to inscribe.";
if (!get_item(&item, q, s, (USE_EQUIP | USE_INVEN | USE_FLOOR))) return;
/* Get the item (in the pack) */
if (item >= 0)
{
o_ptr = &inventory[item];
}
/* Get the item (on the floor) */
else
{
o_ptr = &o_list[0 - item];
}
/* Describe the activity */
object_desc(o_name, o_ptr, OD_OMIT_INSCRIPTION);
/* Message */
msg_format("Inscribing %s.", o_name);
msg_print(NULL);
/* Start with nothing */
strcpy(out_val, "");
/* Use old inscription */
if (o_ptr->inscription)
{
/* Start with the old inscription */
strcpy(out_val, quark_str(o_ptr->inscription));
}
/* Get a new inscription (possibly empty) */
if (get_string("Inscription: ", out_val, 80))
{
/* Save the inscription */
o_ptr->inscription = quark_add(out_val);
/* Combine the pack */
p_ptr->notice |= (PN_COMBINE);
/* Window stuff */
p_ptr->window |= (PW_INVEN | PW_EQUIP);
p_ptr->update |= (PU_BONUS);
}
}
/*
* Inscribe an object with a comment
*/
void do_cmd_inscribe(void)
{
int item;
object_type *o_ptr;
char o_name[MAX_NLEN];
char out_val[80];
cptr q, s;
/* Get an item */
#ifdef JP
q = "どのアイテムに銘を刻みますか? ";
s = "銘を刻めるアイテムがない。";
#else
q = "Inscribe which item? ";
s = "You have nothing to inscribe.";
#endif
if (!get_item(&item, q, s, (USE_EQUIP | USE_INVEN | USE_FLOOR))) return;
/* Get the item (in the pack) */
if (item >= 0)
{
o_ptr = &inventory[item];
}
/* Get the item (on the floor) */
else
{
o_ptr = &o_list[0 - item];
}
/* Describe the activity */
object_desc(o_name, o_ptr, 0);
/* Message */
#ifdef JP
msg_format("%sに銘を刻む。", o_name);
#else
msg_format("Inscribing %s.", o_name);
#endif
msg_print(NULL);
/* Start with nothing */
strcpy(out_val, "");
/* Use old inscription */
if (o_ptr->inscription)
{
/* Start with the old inscription */
strcpy(out_val, quark_str(o_ptr->inscription));
}
/* Get a new inscription (possibly empty) */
#ifdef JP
if (get_string("銘: ", out_val, 80))
#else
if (get_string("Inscription: ", out_val, 80))
#endif
{
/* Auto flag inscription */
o_ptr->inscription = quark_add(out_val);
/* Combine the pack */
p_ptr->notice |= (PN_COMBINE);
/* Window stuff */
p_ptr->window |= (PW_INVEN | PW_EQUIP);
/* Updare stuff */
p_ptr->update |= (PU_BONUS);
}
}
