/*
* Using k_info[], init rarity data for the entire dungeon.
*/
bool init_obj_alloc(void)
{
int k_max = z_info->k_max;
int item, lev;
/* Free obj_allocs if allocated */
FREE(obj_alloc);
/* Allocate and wipe */
obj_alloc = C_ZNEW((MAX_O_DEPTH + 1) * k_max, byte);
obj_alloc_great = C_ZNEW((MAX_O_DEPTH + 1) * k_max, byte);
/* Wipe the totals */
C_WIPE(obj_total, MAX_O_DEPTH + 1, u32b);
C_WIPE(obj_total_great, MAX_O_DEPTH + 1, u32b);
/* Init allocation data */
for (item = 1; item < k_max; item++)
{
const object_kind *kind = &k_info[item];
int min = kind->alloc_min;
int max = kind->alloc_max;
/* If an item doesn't have a rarity, move on */
if (!kind->alloc_prob) continue;
/* Go through all the dungeon levels */
for (lev = 0; lev <= MAX_O_DEPTH; lev++)
{
int rarity = kind->alloc_prob;
/* Save the probability in the standard table */
if ((lev < min) || (lev > max)) rarity = 0;
obj_total[lev] += rarity;
obj_alloc[(lev * k_max) + item] = rarity;
/* Save the probability in the "great" table if relevant */
if (!kind_is_good(kind)) rarity = 0;
obj_total_great[lev] += rarity;
obj_alloc_great[(lev * k_max) + item] = rarity;
}
}
return TRUE;
}
/*
* Hack -- read the next "block" from the savefile
*/
static errr rd_block(void)
{
errr err;
byte fake[4];
/* Read the head data */
err = fd_read(data_fd, (char*)&fake, sizeof(fake));
/* Extract the type and size */
data_type = (fake[0] | ((u16b)fake[1] << 8));
data_size = (fake[2] | ((u16b)fake[3] << 8));
/* Wipe the data block */
C_WIPE(data_head, 65535, byte);
/* Read the actual data */
err = fd_read(data_fd, (char*)data_head, data_size);
/* Read the tail data */
err = fd_read(data_fd, (char*)&fake, sizeof(fake));
/* XXX XXX XXX Verify */
/* Hack -- reset */
data_next = data_head;
/* Success */
return (0);
}
void object_kind::object_kind_wipe()
{
k_name.clear();
k_text.clear();
tval = sval = pval = 0;
to_h = to_d = to_a = 0;
ac = dd = ds = weight = cost = 0;
k_flags1 = k_flags2 = k_flags3 = k_native = k_store = 0;
effect = 0;
C_WIPE(locale, 4, byte);
C_WIPE(chance, 4, byte);
k_level = extra = 0;
color_num = 0;
d_color = QColor("black");
d_char = QChar(' ');
autoinscribe.clear();
flavor = squelch = 0;
aware = tried = everseen = FALSE;
C_WIPE(use_verify, VERIFY_MAX, byte);
}
/*
* Read in a highscore file.
*/
static size_t highscore_read(high_score scores[], size_t sz)
{
char fname[1024];
ang_file *scorefile;
size_t i;
/* Wipe current scores */
C_WIPE(scores, sz, high_score);
path_build(fname, sizeof(fname), ANGBAND_DIR_APEX, "scores.raw");
scorefile = file_open(fname, MODE_READ, -1);
if (!scorefile) return TRUE;
for (i = 0; i < sz &&
file_read(scorefile, (char *)&scores[i], sizeof(high_score)) > 0;
i++)
;
file_close(scorefile);
return i;
}
/*
* Hack -- write the current "block" to the savefile
*/
static errr wr_block(void)
{
errr err;
byte fake[4];
/* Save the type and size */
fake[0] = (byte)(data_type);
fake[1] = (byte)(data_type >> 8);
fake[2] = (byte)(data_size);
fake[3] = (byte)(data_size >> 8);
/* Dump the head */
err = fd_write(data_fd, (cptr)&fake, sizeof(fake));
/* Dump the actual data */
err = fd_write(data_fd, (cptr)data_head, data_size);
/* XXX XXX XXX */
fake[0] = 0;
fake[1] = 0;
fake[2] = 0;
fake[3] = 0;
/* Dump the tail */
err = fd_write(data_fd, (cptr)&fake, sizeof(fake));
/* Hack -- reset */
data_next = data_head;
/* Wipe the data block */
C_WIPE(data_head, 65535, byte);
/* Success */
return (0);
}
/*
* Generates a random dungeon level -RAK-
*
* Hack -- regenerate any "overflow" levels
*
* Hack -- allow auto-scumming via a gameplay option.
*/
void generate_cave(void)
{
int y, x, num;
/* Hack - Reset the object theme */
dun_theme.treasure = 20;
dun_theme.combat = 20;
dun_theme.magic = 20;
dun_theme.tools = 20;
/* Build the wilderness */
if (!p_ptr->depth)
{
/* Hack XXX XXX */
/* Exit, information is already in other data type. */
p_ptr->px = (s16b)p_ptr->wilderness_x;
p_ptr->py = (s16b)p_ptr->wilderness_y;
/* The "dungeon" is ready */
character_dungeon = TRUE;
/* Reset map panels */
map_panel_size();
/* Add monsters to the wilderness */
repopulate_wilderness();
return;
}
/* The dungeon is not ready */
character_dungeon = FALSE;
/* Generate */
for (num = 0; TRUE; num++)
{
bool okay = TRUE;
cptr why = NULL;
/*
* Start with a blank cave
*/
for (y = 0; y < MAX_HGT; y++)
{
(void) C_WIPE(cave[y], MAX_WID, cave_type);
}
/*
* XXX XXX XXX XXX
* Perhaps we should simply check for no monsters / objects
* and complain if any exist. That way these two lines
* could eventually be removed.
*/
o_max = 1;
m_max = 1;
/* Set the base level */
base_level = p_ptr->depth;
/* Reset the monster generation level */
monster_level = base_level;
/* Reset the object generation level */
object_level = base_level;
/* Nothing special here yet */
good_item_flag = FALSE;
/* Nothing good here yet */
rating = 0;
#ifdef USE_SCRIPT
if (!generate_level_callback(p_ptr->depth))
#endif /* USE_SCRIPT */
{
okay = level_gen(&why);
}
/* Extract the feeling */
feeling = extract_feeling();
/* Prevent object over-flow */
if (o_max >= max_o_idx)
{
/* Message */
why = "too many objects";
/* Message */
okay = FALSE;
}
/* Prevent monster over-flow */
else if (m_max >= max_m_idx)
{
/* Message */
why = "too many monsters";
/* Message */
okay = FALSE;
}
/* Mega-Hack -- "auto-scum" */
else if ((auto_scum || ironman_autoscum) && (num < 100) &&
!p_ptr->inside_quest)
{
/* Require "goodness" */
if ((feeling > 9) ||
((p_ptr->depth >= 7) && (feeling > 8)) ||
((p_ptr->depth >= 15) && (feeling > 7)) ||
((p_ptr->depth >= 35) && (feeling > 6)) ||
((p_ptr->depth >= 70) && (feeling > 5)))
{
/* Give message to cheaters */
if (cheat_room || cheat_hear ||
cheat_peek || cheat_xtra)
{
/* Message */
why = "boring level";
}
/* Try again */
okay = FALSE;
}
}
/* Accept */
if (okay) break;
/* Message */
if (why) msg_format("Generation restarted (%s)", why);
/* Wipe the objects */
wipe_o_list();
/* Wipe the monsters */
wipe_m_list();
/* Wipe the fields */
wipe_f_list();
}
/* The dungeon is ready */
character_dungeon = TRUE;
/* Reset map panels */
map_panel_size();
/* Verify the panel */
verify_panel();
/* Remove the CAVE_ROOM flags... reused as CAVE_MNLT */
for (x = min_wid; x < max_wid; x++)
{
for (y = min_hgt; y < max_hgt; y++)
{
/* Clear the flag */
cave[y][x].info &= ~(CAVE_ROOM);
}
}
/* Remember when this level was "created" */
old_turn = turn;
}
static void init_ego_allocs(void) {
struct alloc_entry *table;
int i;
ego_item_type *e_ptr;
s16b num[MAX_DEPTH];
s16b aux[MAX_DEPTH];
/* Clear the "aux" array */
(void)C_WIPE(aux, MAX_DEPTH, s16b);
/* Clear the "num" array */
(void)C_WIPE(num, MAX_DEPTH, s16b);
/* Size of "alloc_ego_table" */
alloc_ego_size = 0;
/* Scan the ego items */
for (i = 1; i < z_info->e_max; i++)
{
/* Get the i'th ego item */
e_ptr = &e_info[i];
/* Legal items */
if (e_ptr->rarity)
{
/* Count the entries */
alloc_ego_size++;
/* Group by level */
num[e_ptr->level]++;
}
}
/* Collect the level indexes */
for (i = 1; i < MAX_DEPTH; i++)
{
/* Group by level */
num[i] += num[i-1];
}
/*** Initialize ego-item allocation info ***/
/* Allocate the alloc_ego_table */
alloc_ego_table = C_ZNEW(alloc_ego_size, alloc_entry);
/* Get the table entry */
table = alloc_ego_table;
/* Scan the ego-items */
for (i = 1; i < z_info->e_max; i++)
{
/* Get the i'th ego item */
e_ptr = &e_info[i];
/* Count valid pairs */
if (e_ptr->rarity)
{
int p, x, y, z;
/* Extract the base level */
x = e_ptr->level;
/* Extract the base probability */
p = (100 / e_ptr->rarity);
/* Skip entries preceding our locale */
y = (x > 0) ? num[x-1] : 0;
/* Skip previous entries at this locale */
z = y + aux[x];
/* Load the entry */
table[z].index = i;
table[z].level = x;
table[z].prob1 = p;
table[z].prob2 = p;
table[z].prob3 = p;
/* Another entry complete for this locale */
aux[x]++;
}
}
}
/*!
* @brief アイテムの階層毎生成率を表示する / Output a rarity graph for a type of object.
* @param tval ベースアイテムの大項目ID
* @param sval ベースアイテムの小項目ID
* @param row 表示列
* @param col 表示行
* @return なし
*/
static void prt_alloc(byte tval, byte sval, int row, int col)
{
int i, j;
int home = 0;
u32b rarity[K_MAX_DEPTH];
u32b total[K_MAX_DEPTH];
s32b display[22];
cptr r = "+---Rate---+";
object_kind *k_ptr;
/* Get the entry */
alloc_entry *table = alloc_kind_table;
/* Wipe the tables */
(void)C_WIPE(rarity, K_MAX_DEPTH, u32b);
(void)C_WIPE(total, K_MAX_DEPTH, u32b);
(void)C_WIPE(display, 22, s32b);
/* Scan all entries */
for (i = 0; i < K_MAX_DEPTH; i++)
{
int total_frac = 0;
for (j = 0; j < alloc_kind_size; j++)
{
int prob = 0;
if (table[j].level <= i)
{
prob = table[j].prob1 * GREAT_OBJ * K_MAX_DEPTH;
}
else if (table[j].level - 1 > 0)
{
prob = table[j].prob1 * i * K_MAX_DEPTH / (table[j].level - 1);
}
/* Acquire this kind */
k_ptr = &k_info[table[j].index];
/* Accumulate probabilities */
total[i] += prob / (GREAT_OBJ * K_MAX_DEPTH);
total_frac += prob % (GREAT_OBJ * K_MAX_DEPTH);
/* Accumulate probabilities */
if ((k_ptr->tval == tval) && (k_ptr->sval == sval))
{
home = k_ptr->level;
rarity[i] += prob / (GREAT_OBJ * K_MAX_DEPTH);
}
}
total[i] += total_frac / (GREAT_OBJ * K_MAX_DEPTH);
}
/* Calculate probabilities for each range */
for (i = 0; i < 22; i++)
{
/* Shift the values into view */
int possibility = 0;
for (j = i * K_MAX_DEPTH / 22; j < (i + 1) * K_MAX_DEPTH / 22; j++)
possibility += rarity[j] * 100000 / total[j];
display[i] = possibility / 5;
}
/* Graph the rarities */
for (i = 0; i < 22; i++)
{
Term_putch(col, row + i + 1, TERM_WHITE, '|');
prt(format("%2dF", (i * 5)), row + i + 1, col);
/* Note the level */
if ((i * K_MAX_DEPTH / 22 <= home) && (home < (i + 1) * K_MAX_DEPTH / 22))
{
c_prt(TERM_RED, format("%3d.%04d%%", display[i] / 1000, display[i] % 1000), row + i + 1, col + 3);
}
else
{
c_prt(TERM_WHITE, format("%3d.%04d%%", display[i] / 1000, display[i] % 1000), row + i + 1, col + 3);
}
}
/* Make it look nice */
prt(r, row, col);
}
/*!
* @brief フロアの全情報を初期化する / Clear and empty the cave
* @return なし
*/
void clear_cave(void)
{
int x, y, i;
/* Very simplified version of wipe_o_list() */
(void)C_WIPE(o_list, o_max, object_type);
o_max = 1;
o_cnt = 0;
/* Very simplified version of wipe_m_list() */
for (i = 1; i < max_r_idx; i++)
r_info[i].cur_num = 0;
(void)C_WIPE(m_list, m_max, monster_type);
m_max = 1;
m_cnt = 0;
for (i = 0; i < MAX_MTIMED; i++) mproc_max[i] = 0;
/* Pre-calc cur_num of pets in party_mon[] */
precalc_cur_num_of_pet();
/* Start with a blank cave */
for (y = 0; y < MAX_HGT; y++)
{
for (x = 0; x < MAX_WID; x++)
{
cave_type *c_ptr = &cave[y][x];
/* No flags */
c_ptr->info = 0;
/* No features */
c_ptr->feat = 0;
/* No objects */
c_ptr->o_idx = 0;
/* No monsters */
c_ptr->m_idx = 0;
/* No special */
c_ptr->special = 0;
/* No mimic */
c_ptr->mimic = 0;
/* No flow */
c_ptr->cost = 0;
c_ptr->dist = 0;
c_ptr->when = 0;
}
}
/* Mega-Hack -- no player yet */
p_ptr->x = p_ptr->y = 0;
/* Set the base level */
base_level = dun_level;
/* Reset the monster generation level */
monster_level = base_level;
/* Reset the object generation level */
object_level = base_level;
}
/*!
* @brief 移動先のフロアに伴ったペットを配置する / Place preserved pet monsters on new floor
* @return なし
*/
static void place_pet(void)
{
int i;
int max_num = p_ptr->wild_mode ? 1 : MAX_PARTY_MON;
for (i = 0; i < max_num; i++)
{
POSITION cy = 0, cx = 0;
MONSTER_IDX m_idx;
if (!(party_mon[i].r_idx)) continue;
if (i == 0)
{
m_idx = m_pop();
p_ptr->riding = m_idx;
if (m_idx)
{
cy = p_ptr->y;
cx = p_ptr->x;
}
}
else
{
int j;
POSITION d;
for (d = 1; d < 6; d++)
{
for (j = 1000; j > 0; j--)
{
scatter(&cy, &cx, p_ptr->y, p_ptr->x, d, 0);
if (monster_can_enter(cy, cx, &r_info[party_mon[i].r_idx], 0)) break;
}
if (j) break;
}
m_idx = (d == 6) ? 0 : m_pop();
}
if (m_idx)
{
monster_type *m_ptr = &m_list[m_idx];
monster_race *r_ptr;
cave[cy][cx].m_idx = m_idx;
m_ptr->r_idx = party_mon[i].r_idx;
/* Copy all member of the structure */
*m_ptr = party_mon[i];
r_ptr = real_r_ptr(m_ptr);
m_ptr->fy = cy;
m_ptr->fx = cx;
m_ptr->ml = TRUE;
m_ptr->mtimed[MTIMED_CSLEEP] = 0;
/* Paranoia */
m_ptr->hold_o_idx = 0;
m_ptr->target_y = 0;
if ((r_ptr->flags1 & RF1_FORCE_SLEEP) && !ironman_nightmare)
{
/* Monster is still being nice */
m_ptr->mflag |= (MFLAG_NICE);
/* Must repair monsters */
repair_monsters = TRUE;
}
/* Update the monster */
update_mon(m_idx, TRUE);
lite_spot(cy, cx);
/* Pre-calculated in precalc_cur_num_of_pet() */
/* r_ptr->cur_num++; */
/* Hack -- Count the number of "reproducers" */
if (r_ptr->flags2 & RF2_MULTIPLY) num_repro++;
/* Hack -- Notice new multi-hued monsters */
{
monster_race *ap_r_ptr = &r_info[m_ptr->ap_r_idx];
if (ap_r_ptr->flags1 & (RF1_ATTR_MULTI | RF1_SHAPECHANGER))
shimmer_monsters = TRUE;
}
}
else
{
monster_type *m_ptr = &party_mon[i];
monster_race *r_ptr = real_r_ptr(m_ptr);
char m_name[80];
monster_desc(m_name, m_ptr, 0);
#ifdef JP
msg_format("%sとはぐれてしまった。", m_name);
#else
msg_format("You have lost sight of %s.", m_name);
#endif
if (record_named_pet && m_ptr->nickname)
{
monster_desc(m_name, m_ptr, MD_INDEF_VISIBLE);
do_cmd_write_nikki(NIKKI_NAMED_PET, RECORD_NAMED_PET_LOST_SIGHT, m_name);
}
/* Pre-calculated in precalc_cur_num_of_pet(), but need to decrease */
if (r_ptr->cur_num) r_ptr->cur_num--;
}
}
/* For accuracy of precalc_cur_num_of_pet() */
(void)C_WIPE(party_mon, MAX_PARTY_MON, monster_type);
}
static void init_race_allocs(void) {
int i;
monster_race *r_ptr;
alloc_entry *table;
s16b num[MAX_DEPTH];
s16b aux[MAX_DEPTH];
/* Clear the "aux" array */
(void)C_WIPE(aux, MAX_DEPTH, s16b);
/* Clear the "num" array */
(void)C_WIPE(num, MAX_DEPTH, s16b);
/* Size of "alloc_race_table" */
alloc_race_size = 0;
/* Scan the monsters (not the ghost) */
for (i = 1; i < z_info->r_max - 1; i++)
{
/* Get the i'th race */
r_ptr = &r_info[i];
/* Legal monsters */
if (r_ptr->rarity)
{
/* Count the entries */
alloc_race_size++;
/* Group by level */
num[r_ptr->level]++;
}
}
/* Collect the level indexes */
for (i = 1; i < MAX_DEPTH; i++)
{
/* Group by level */
num[i] += num[i-1];
}
/* Paranoia */
if (!num[0]) quit("No town monsters!");
/*** Initialize monster allocation info ***/
/* Allocate the alloc_race_table */
alloc_race_table = C_ZNEW(alloc_race_size, alloc_entry);
/* Get the table entry */
table = alloc_race_table;
/* Scan the monsters (not the ghost) */
for (i = 1; i < z_info->r_max - 1; i++)
{
/* Get the i'th race */
r_ptr = &r_info[i];
/* Count valid pairs */
if (r_ptr->rarity)
{
int p, x, y, z;
/* Extract the base level */
x = r_ptr->level;
/* Extract the base probability */
p = (100 / r_ptr->rarity);
/* Skip entries preceding our locale */
y = (x > 0) ? num[x-1] : 0;
/* Skip previous entries at this locale */
z = y + aux[x];
/* Load the entry */
table[z].index = i;
table[z].level = x;
table[z].prob1 = p;
table[z].prob2 = p;
table[z].prob3 = p;
/* Another entry complete for this locale */
aux[x]++;
}
}
}
/*
* Initialize some other arrays
*/
static errr init_alloc(void)
{
int i, j;
object_kind *k_ptr;
feature_type *f_ptr;
monster_race *r_ptr;
ego_item_type *e_ptr;
alloc_entry *table;
s16b num[MAX_DEPTH_ALL];
s16b aux[MAX_DEPTH_ALL];
/*** Analyze object allocation info ***/
/* Clear the "aux" array */
(void)C_WIPE(aux, MAX_DEPTH_ALL, s16b);
/* Clear the "num" array */
(void)C_WIPE(num, MAX_DEPTH_ALL, s16b);
/* Size of "alloc_kind_table" */
alloc_kind_size = 0;
/* Scan the objects */
for (i = 1; i < z_info->k_max; i++)
{
k_ptr = &k_info[i];
/* Scan allocation pairs */
for (j = 0; j < 4; j++)
{
/* Count the "legal" entries */
if (k_ptr->chance[j])
{
/* Count the entries */
alloc_kind_size++;
/* Group by level */
num[k_ptr->locale[j]]++;
}
}
}
/* Collect the level indexes */
for (i = 1; i < MAX_DEPTH_ALL; i++)
{
/* Group by level */
num[i] += num[i-1];
}
/* Paranoia */
if (!num[0]) quit("No town objects!");
/*** Initialize object allocation info ***/
/* Allocate the alloc_kind_table */
alloc_kind_table = C_ZNEW(alloc_kind_size, alloc_entry);
/* Get the table entry */
table = alloc_kind_table;
/* Scan the objects */
for (i = 1; i < z_info->k_max; i++)
{
k_ptr = &k_info[i];
/* Scan allocation pairs */
for (j = 0; j < 4; j++)
{
/* Count the "legal" entries */
if (k_ptr->chance[j])
{
int p, x, y, z;
/* Extract the base level */
x = k_ptr->locale[j];
/* Extract the base probability */
p = (100 / k_ptr->chance[j]);
/* Skip entries preceding our locale */
y = (x > 0) ? num[x-1] : 0;
/* Skip previous entries at this locale */
z = y + aux[x];
/* Load the entry */
table[z].index = i;
table[z].level = x;
table[z].prob1 = p;
table[z].prob2 = p;
table[z].prob3 = p;
/* Another entry complete for this locale */
aux[x]++;
}
}
}
/*** Analyze feature allocation info ***/
/* Clear the "aux" array */
(void)C_WIPE(&aux, MAX_DEPTH_ALL, s16b);
/* Clear the "num" array */
(void)C_WIPE(&num, MAX_DEPTH_ALL, s16b);
/* Size of "alloc_feat_table" */
alloc_feat_size = 0;
/* Scan the features */
for (i = 1; i < z_info->f_max; i++)
{
/* Get the i'th race */
f_ptr = &f_info[i];
/* Legal features */
if (f_ptr->f_rarity)
{
/* Count the entries */
alloc_feat_size++;
/* Group by level */
num[f_ptr->f_level]++;
}
}
/* Collect the level indexes */
for (i = 1; i < MAX_DEPTH_ALL; i++)
{
/* Group by level */
num[i] += num[i-1];
}
/* Paranoia - not really necessary */
if (!num[0]) quit("No town features!");
/*** Initialize feature allocation info ***/
/* Allocate the alloc_feat_table */
alloc_feat_table = C_ZNEW(alloc_feat_size, alloc_entry);
/* Get the table entry */
table = alloc_feat_table;
/* Scan the features */
for (i = 1; i < z_info->f_max; i++)
{
/* Get the i'th feature */
f_ptr = &f_info[i];
/* Count valid pairs */
if (f_ptr->f_rarity)
{
int p, x, y, z;
/* Extract the base level */
x = f_ptr->f_level;
/* Extract the base probability */
p = (100 / f_ptr->f_rarity);
/* Skip entries preceding our locale */
y = (x > 0) ? num[x-1] : 0;
/* Skip previous entries at this locale */
z = y + aux[x];
/* Load the entry */
table[z].index = i;
table[z].level = x;
table[z].prob1 = p;
table[z].prob2 = p;
table[z].prob3 = p;
/* Another entry complete for this locale */
aux[x]++;
}
}
/*** Analyze monster allocation info ***/
/* Clear the "aux" array */
(void)C_WIPE(aux, MAX_DEPTH_ALL, s16b);
/* Clear the "num" array */
(void)C_WIPE(num, MAX_DEPTH_ALL, s16b);
/* Size of "alloc_race_table" */
alloc_race_size = 0;
/* Scan the monsters*/
for (i = 1; i < z_info->r_max; i++)
{
/* Get the i'th race */
r_ptr = &r_info[i];
/* Legal monsters */
if (r_ptr->rarity)
{
/* Count the entries */
alloc_race_size++;
/* Group by level */
num[r_ptr->level]++;
}
}
/* Collect the level indexes */
for (i = 1; i < MAX_DEPTH_ALL; i++)
{
/* Group by level */
num[i] += num[i-1];
}
/* Paranoia */
if (!num[0]) quit("No town monsters!");
/*** Initialize monster allocation info ***/
/* Allocate the alloc_race_table */
alloc_race_table = C_ZNEW(alloc_race_size, alloc_entry);
/* Get the table entry */
table = alloc_race_table;
/* Scan the monsters*/
for (i = 1; i < z_info->r_max; i++)
{
/* Get the i'th race */
r_ptr = &r_info[i];
/* Count valid pairs */
if (r_ptr->rarity)
{
int p, x, y, z;
/* Extract the base level */
x = r_ptr->level;
/* Extract the base probability */
p = (100 / r_ptr->rarity);
/* Skip entries preceding our locale */
y = (x > 0) ? num[x-1] : 0;
/* Skip previous entries at this locale */
z = y + aux[x];
/* Load the entry */
table[z].index = i;
table[z].level = x;
table[z].prob1 = p;
table[z].prob2 = p;
table[z].prob3 = p;
/* Another entry complete for this locale */
aux[x]++;
}
}
/*** Analyze ego_item allocation info ***/
/* Clear the "aux" array */
(void)C_WIPE(aux, MAX_DEPTH_ALL, s16b);
/* Clear the "num" array */
(void)C_WIPE(num, MAX_DEPTH_ALL, s16b);
/* Size of "alloc_ego_table" */
alloc_ego_size = 0;
/* Scan the ego items */
for (i = 1; i < z_info->e_max; i++)
{
/* Get the i'th ego item */
e_ptr = &e_info[i];
/* Legal items */
if (e_ptr->rarity)
{
/* Count the entries */
alloc_ego_size++;
/* Group by level */
num[e_ptr->level]++;
}
}
/* Collect the level indexes */
for (i = 1; i < MAX_DEPTH_ALL; i++)
{
/* Group by level */
num[i] += num[i-1];
}
/*** Initialize ego-item allocation info ***/
/* Allocate the alloc_ego_table */
alloc_ego_table = C_ZNEW(alloc_ego_size, alloc_entry);
/* Get the table entry */
table = alloc_ego_table;
/* Scan the ego-items */
for (i = 1; i < z_info->e_max; i++)
{
/* Get the i'th ego item */
e_ptr = &e_info[i];
/* Count valid pairs */
if (e_ptr->rarity)
{
int p, x, y, z;
/* Extract the base level */
x = e_ptr->level;
/* Extract the base probability */
p = (100 / e_ptr->rarity);
/* Skip entries preceding our locale */
y = (x > 0) ? num[x-1] : 0;
/* Skip previous entries at this locale */
z = y + aux[x];
/* Load the entry */
table[z].index = i;
table[z].level = x;
table[z].prob1 = p;
table[z].prob2 = p;
table[z].prob3 = p;
/* Another entry complete for this locale */
aux[x]++;
}
}
/* Success */
return (0);
}
/*
* Clear and empty the cave
*/
void clear_cave(void)
{
int x, y;
/* Very simplified version of wipe_o_list() */
C_WIPE(o_list, o_max, object_type);
o_max = 1;
o_cnt = 0;
unique_count = 0;
/* Note, when I replaced the above with wipe_o_list(), artifacts started spawning
multiple times!
wipe_o_list();*/
wipe_m_list();
/* Pre-calc cur_num of pets in party_mon[] */
precalc_cur_num_of_pet();
/* Start with a blank cave */
for (y = 0; y < MAX_HGT; y++)
{
for (x = 0; x < MAX_WID; x++)
{
cave_type *c_ptr = &cave[y][x];
/* No flags */
c_ptr->info = 0;
/* No features */
c_ptr->feat = 0;
/* No objects */
c_ptr->o_idx = 0;
/* No monsters */
c_ptr->m_idx = 0;
/* No special */
c_ptr->special = 0;
/* No mimic */
c_ptr->mimic = 0;
/* No flow */
c_ptr->cost = 0;
c_ptr->dist = 0;
c_ptr->when = 0;
}
}
/* Mega-Hack -- no player yet */
px = py = 0;
/* Set the base level */
base_level = dun_level;
/* Reset the monster generation level */
monster_level = base_level;
/* Reset the object generation level */
object_level = base_level;
}
/*
* Output a rarity graph for a type of object.
*
* Use a monte-carlo method to calculate the probabilities.
*/
static void prt_alloc(const object_type *o_ptr, int row, int col, u32b monte)
{
u32b i, j;
u32b maxd = 1, maxr = 1, maxt = 1;
u32b rarity[MAX_DEPTH];
u32b total[MAX_DEPTH];
u32b display[20];
byte c = TERM_WHITE;
cptr r = "+--common--+";
u16b kind = o_ptr->k_idx;
u16b home = k_info[kind].level;
/* Wipe the tables */
(void)C_WIPE(rarity, MAX_DEPTH, u32b);
(void)C_WIPE(total, MAX_DEPTH, u32b);
(void)C_WIPE(display, 20, u32b);
msg_print(NULL);
prt("Calculating probability distribution - please wait.", 0, 0);
/* Refresh */
Term_fresh();
/* Scan all entries */
for (i = 0; i < MAX_DEPTH; i++)
{
for (j = 0; j < monte; j++)
{
if (get_obj_num(i, 0) == kind) rarity[i]++;
}
total[i] = monte;
}
/* Find maxima */
for (i = 0; i < MAX_DEPTH; i++)
{
if (rarity[i] > maxr) maxr = rarity[i];
if (total[i] > maxt) maxt = total[i];
}
/* Simulate a log graph */
if (maxt / maxr > 32)
{
c = TERM_L_WHITE;
r = "+-uncommon-+";
}
if (maxt / maxr > 1024)
{
c = TERM_SLATE;
r = "+---rare---+";
}
if (maxt / maxr > 32768L)
{
c = TERM_L_DARK;
r = "+--unique--+";
}
/* Calculate probabilities for each range */
for (i = 0; i < 20; i++)
{
/* Shift the values into view */
for (j = i * MAX_DEPTH / 20; j < (i + 1) * MAX_DEPTH / 20; j++)
{
display[i] += rarity[j] * maxt * 10 / total[j];
}
/* Correct proportions */
display[i] /= maxr;
/* Track maximum */
if (display[i] > maxd) maxd = display[i];
}
/* Normalize */
for (i = 0; i < 20; i++)
{
display[i] = display[i] * 10 / maxd;
}
/* Graph the rarities */
for (i = 0; i < 20; i++)
{
Term_putch(col, row + i + 1, TERM_WHITE, '|');
/* Note the level */
if ((i * MAX_DEPTH / 20 <= home) && (home < (i + 1) * MAX_DEPTH / 20))
{
c_prt(TERM_RED, format("%.*s", display[i], "**********"), row + i + 1, col + 1);
}
else
{
c_prt(c, format("%.*s", display[i], "**********"), row + i + 1, col + 1);
}
}
/* Make it look nice */
prt(r, row, col);
Term_putch(col, row + 2, TERM_WHITE, '6');
Term_putch(col, row + 8, TERM_WHITE, 'A');
Term_putch(col, row + 9, TERM_WHITE, 'L');
Term_putch(col, row + 10, TERM_WHITE, 'L');
Term_putch(col, row + 11, TERM_WHITE, 'O');
Term_putch(col, row + 12, TERM_WHITE, 'C');
prt("+", row + 21, col);
}
/*
* Output a rarity graph for a type of object.
*/
static void prt_alloc(byte tval, byte sval, int row, int col)
{
int i, j;
int home = 0;
u32b maxr = 1, maxt = 1, ratio;
u32b rarity[K_MAX_DEPTH];
u32b total[K_MAX_DEPTH];
s32b maxd = 1, display[22];
byte c = TERM_WHITE;
cptr r = "+--common--+";
object_kind *k_ptr;
/* Get the entry */
alloc_entry *table = alloc_kind_table;
/* Wipe the tables */
(void)C_WIPE(rarity, K_MAX_DEPTH, u32b);
(void)C_WIPE(total, K_MAX_DEPTH, u32b);
(void)C_WIPE(display, 22, s32b);
/* Scan all entries */
for (i = 0; i < K_MAX_DEPTH; i++)
{
int total_frac = 0;
for (j = 0; j < alloc_kind_size; j++)
{
int prob = 0;
if (table[j].level <= i)
{
prob = table[j].prob1 * GREAT_OBJ * K_MAX_DEPTH;
}
else if (table[j].level - 1 > 0)
{
prob = table[j].prob1 * i * K_MAX_DEPTH / (table[j].level - 1);
}
/* Acquire this kind */
k_ptr = &k_info[table[j].index];
/* Accumulate probabilities */
total[i] += prob / (GREAT_OBJ * K_MAX_DEPTH);
total_frac += prob % (GREAT_OBJ * K_MAX_DEPTH);
/* Accumulate probabilities */
if ((k_ptr->tval == tval) && (k_ptr->sval == sval))
{
home = k_ptr->level;
rarity[i] += prob;
}
}
total[i] += total_frac / (GREAT_OBJ * K_MAX_DEPTH);
}
/* Find maxima */
for (i = 0; i < K_MAX_DEPTH; i++)
{
if (rarity[i] > maxr) maxr = rarity[i];
if (total[i] > maxt) maxt = total[i];
}
if (maxr / (GREAT_OBJ * K_MAX_DEPTH) != 0)
ratio = maxt / (maxr / (GREAT_OBJ * K_MAX_DEPTH));
else
ratio = 99999L;
/* Simulate a log graph */
if (ratio > 1000)
{
c = TERM_L_WHITE;
r = "+-uncommon-+";
}
if (ratio > 3000)
{
c = TERM_SLATE;
r = "+---rare---+";
}
if (ratio > 32768L)
{
c = TERM_L_DARK;
r = "+-VeryRare-+";
}
/* Calculate probabilities for each range */
for (i = 0; i < 22; i++)
{
/* Shift the values into view */
int possibility = 0;
for (j = i * K_MAX_DEPTH / 22; j < (i + 1) * K_MAX_DEPTH / 22; j++)
possibility += rarity[j] * (100 * maxt / total[j]);
possibility = possibility / maxr;
/* display[i] = log_{sqrt(2)}(possibility) */
display[i] = 0;
while (possibility)
{
display[i]++;
possibility = possibility * 1000 / 1414;
}
/* Track maximum */
if (display[i] > maxd) maxd = display[i];
}
/* Normalize */
if (maxd > 10) for (i = 0; i < 22; i++)
{
display[i] = display[i] - maxd + 10;
}
/* Graph the rarities */
for (i = 0; i < 22; i++)
{
Term_putch(col, row + i + 1, TERM_WHITE, '|');
prt(format("%d", (i * K_MAX_DEPTH / 220) % 10), row + i + 1, col);
if (display[i] <= 0)
continue;
/* Note the level */
if ((i * K_MAX_DEPTH / 22 <= home) && (home < (i + 1) * K_MAX_DEPTH / 22))
{
c_prt(TERM_RED, format("%.*s", display[i], "**********"), row + i + 1, col + 1);
}
else
{
c_prt(c, format("%.*s", display[i], "**********"), row + i + 1, col + 1);
}
}
/* Make it look nice */
prt(r, row, col);
}
/*
* 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;
}
/**
* Hack -- change name
*/
void do_cmd_change_name(void)
{
ui_event ke;
int col = 0;
int last_line = 0;
int top_line = 0;
const char *p;
/* Prompt */
p = "['c' change name, 'f' to file, scroll, or ESC]";
/* Save screen */
screen_save();
/* Adjust the buttons */
button_backup_all();
button_kill_all();
button_add("ESC", ESCAPE);
button_add("Spc", ' ');
button_add("-", '-');
button_add("c", 'c');
button_add("f", 'f');
button_add("->", ARROW_RIGHT);
button_add("<-", ARROW_LEFT);
p_ptr->redraw |= PR_BUTTONS;
/* Make the array of lines */
C_WIPE(dumpline, DUMP_MAX_LINES, char_attr_line);
last_line = make_dump(dumpline, 2);
/* Forever */
while (1)
{
/* Display the player */
display_dump(dumpline, top_line, top_line + Term->hgt - 1, col);
redraw_stuff(p_ptr);
/* Clear the bottom line */
prt("", Term->hgt - 1, 0);
/* Prompt */
Term_putstr(0, Term->hgt - 1, -1, TERM_WHITE, p);
/* Query */
ke = inkey_ex();
/* Exit */
if (ke.key.code == ESCAPE) break;
/* Change name */
if (ke.key.code == 'c')
{
char namebuf[32] = "";
if (get_name(namebuf, sizeof namebuf))
{
/* Set player name */
my_strcpy(op_ptr->full_name, namebuf,
sizeof(op_ptr->full_name));
/* Don't change savefile name. */
process_player_name(FALSE);
}
//(void) get_name(namebuf, sizeof namebuf);
(void) make_dump(dumpline, 2);
}
/* File dump */
else if (ke.key.code == 'f')
{
char ftmp[80];
strnfmt(ftmp, sizeof ftmp, "%s.txt", op_ptr->base_name);
if (get_string("File name: ", ftmp, 80))
{
if (ftmp[0] && (ftmp[0] != ' '))
{
if (file_character(ftmp, dumpline, last_line))
msg("Character dump failed!");
else
msg("Character dump successful.");
}
}
}
/* Scroll down */
else if (ke.key.code == ARROW_DOWN)
{
if (top_line + Term->hgt - 2 < last_line)
top_line++;
}
/* Page down */
else if (ke.key.code == ' ')
{
top_line = MIN(last_line - Term->hgt + 2,
top_line + (Term->hgt - 2));
}
/* Scroll up */
else if (ke.key.code == ARROW_UP)
{
if (top_line)
top_line--;
}
/* Page up */
else if (ke.key.code == '-')
{
top_line -= (Term->hgt - 2) / 2;
if (top_line < 0) top_line = 0;
}
/* Scroll left */
else if (ke.key.code == ARROW_LEFT)
{
if (col)
col--;
}
/* Scroll right */
else if (ke.key.code == ARROW_RIGHT)
{
if (col < 32)
col++;
}
/* Oops */
else
{
bell(NULL);
}
/* Flush messages */
message_flush();
}
/* Adjust the buttons */
button_restore();
/* Load screen */
screen_load();
}
