static size_t obj_desc_pval(const object_type *o_ptr, char *buf, size_t max,
size_t end, bool spoil)
{
bitflag f[OF_SIZE], f2[OF_SIZE];
int i;
bool any = FALSE;
object_flags(o_ptr, f);
create_mask(f2, FALSE, OFT_PVAL, OFT_STAT, OFT_MAX);
if (!of_is_inter(f, f2)) return end;
strnfcat(buf, max, &end, " <");
for (i = 0; i < o_ptr->num_pvals; i++) {
if (spoil || object_this_pval_is_visible(o_ptr, i)) {
if (any)
strnfcat(buf, max, &end, ", ");
strnfcat(buf, max, &end, "%+d", o_ptr->pval[i]);
any = TRUE;
}
}
strnfcat(buf, max, &end, ">");
return end;
}
static size_t obj_desc_inscrip(const object_type *o_ptr, char *buf, size_t max, size_t end)
{
const char *u[4] = { 0, 0, 0, 0 };
int n = 0;
int feel = object_pseudo(o_ptr);
bitflag flags_known[OF_SIZE];
object_flags_known(o_ptr, flags_known);
/* Get inscription */
if (o_ptr->note)
u[n++] = quark_str(o_ptr->note);
/* Use special inscription, if any */
if (!object_is_known(o_ptr) && feel)
{
/* cannot tell excellent vs strange vs splendid until wield */
if (!object_was_worn(o_ptr) && ego_item_p(o_ptr))
u[n++] = "ego";
else
u[n++] = inscrip_text[feel];
}
else if ((o_ptr->ident & IDENT_EMPTY) && !object_is_known(o_ptr))
u[n++] = "empty";
else if (!object_is_known(o_ptr) && object_was_worn(o_ptr))
{
if (wield_slot(o_ptr) == INVEN_WIELD || wield_slot(o_ptr) == INVEN_BOW)
u[n++] = "wielded";
else u[n++] = "worn";
}
else if (!object_is_known(o_ptr) && object_was_fired(o_ptr))
u[n++] = "fired";
else if (!object_flavor_is_aware(o_ptr) && object_flavor_was_tried(o_ptr))
u[n++] = "tried";
/* Note curses */
if (flags_test(flags_known, OF_SIZE, OF_CURSE_MASK, FLAG_END))
u[n++] = "cursed";
/* Note squelch */
if (squelch_item_ok(o_ptr))
u[n++] = "squelch";
if (n)
{
int i;
for (i = 0; i < n; i++)
{
if (i == 0)
strnfcat(buf, max, &end, " {");
strnfcat(buf, max, &end, "%s", u[i]);
if (i < n-1)
strnfcat(buf, max, &end, ", ");
}
strnfcat(buf, max, &end, "}");
}
return end;
}
static void path_process(char *buf, size_t len, size_t *cur_len, const char *path)
{
#if defined(SET_UID) || defined(USE_PRIVATE_PATHS)
/* Home directory on Unixes */
if (path[0] == '~')
{
const char *s;
const char *username = path + 1;
struct passwd *pw;
char user[128];
/* Look for non-user portion of the file */
s = strstr(username, PATH_SEP);
if (s)
{
int i;
/* Keep username a decent length */
if (s >= username + sizeof(user)) return;
for (i = 0; username < s; ++i) user[i] = *username++;
user[i] = '\0';
username = user;
}
#ifndef MACH_O_CARBON
/* Look up a user (or "current" user) */
pw = username[0] ? getpwnam(username) : getpwuid(getuid());
#else /* MACH_O_CARBON */
/* On Macs getlogin() can incorrectly return root, so get the username via system frameworks */
CFStringRef cfusername = CSCopyUserName(TRUE);
CFIndex cfbufferlength = CFStringGetMaximumSizeForEncoding(CFStringGetLength(cfusername), kCFStringEncodingUTF8) + 1;
char *macusername = mem_alloc(cfbufferlength);
CFStringGetCString(cfusername, macusername, cfbufferlength, kCFStringEncodingUTF8);
CFRelease(cfusername);
/* Look up the user */
pw = getpwnam(macusername);
mem_free(macusername);
#endif /* !MACH_O_CARBON */
if (!pw) return;
/* Copy across */
strnfcat(buf, len, cur_len, "%s%s", pw->pw_dir, PATH_SEP);
if (s) strnfcat(buf, len, cur_len, "%s", s);
}
else
#endif
{
strnfcat(buf, len, cur_len, "%s", path);
}
}
/**
* Describe charges or charging status for re-usable items with magic effects
*/
static size_t obj_desc_charges(const struct object *obj, char *buf, size_t max,
size_t end, int mode)
{
bool aware = object_flavor_is_aware(obj) || (mode & ODESC_STORE);
/* Wands and Staffs have charges */
if (aware && tval_can_have_charges(obj))
strnfcat(buf, max, &end, " (%d charge%s)", obj->pval,
PLURAL(obj->pval));
/* Charging things */
else if (obj->timeout > 0)
{
if (tval_is_rod(obj) && obj->number > 1)
{
strnfcat(buf, max, &end, " (%d charging)", number_charging(obj));
}
/* Artifacts, single rods */
else if (!(tval_is_light(obj) && !obj->artifact))
{
strnfcat(buf, max, &end, " (charging)");
}
}
return end;
}
/**
* Add player-defined inscriptions or game-defined descriptions
*/
static size_t obj_desc_inscrip(const struct object *obj, char *buf,
size_t max, size_t end)
{
const char *u[4] = { 0, 0, 0, 0 };
int n = 0;
int feel = object_pseudo(obj);
bitflag flags_known[OF_SIZE], f2[OF_SIZE];
object_flags_known(obj, flags_known);
/* Get inscription */
if (obj->note)
u[n++] = quark_str(obj->note);
/* Use special inscription, if any */
if (!object_is_known(obj)) {
if (feel) {
/* cannot tell excellent vs strange vs splendid until wield */
if (!object_was_worn(obj) && obj->ego)
u[n++] = "ego";
else
u[n++] = inscrip_text[feel];
}
else if (tval_can_have_charges(obj) && (obj->pval == 0))
u[n++] = "empty";
else if (object_was_worn(obj))
u[n++] = (tval_is_weapon(obj)) ? "wielded" : "worn";
else if (!object_flavor_is_aware(obj) &&
object_flavor_was_tried(obj))
u[n++] = "tried";
}
/* Note curses */
create_mask(f2, FALSE, OFT_CURSE, OFT_MAX);
if (of_is_inter(flags_known, f2))
u[n++] = "cursed";
/* Note ignore */
if (ignore_item_ok(obj))
u[n++] = "ignore";
if (n)
{
int i;
for (i = 0; i < n; i++)
{
if (i == 0)
strnfcat(buf, max, &end, " {");
strnfcat(buf, max, &end, "%s", u[i]);
if (i < n-1)
strnfcat(buf, max, &end, ", ");
}
strnfcat(buf, max, &end, "}");
}
return end;
}
/**
* ------------------------------------------------------------------------
* The rolling bit of the roller.
* ------------------------------------------------------------------------ */
static enum birth_stage roller_command(bool first_call)
{
char prompt[80] = "";
size_t promptlen = 0;
struct keypress ch;
enum birth_stage next = BIRTH_ROLLER;
/* Used to keep track of whether we've rolled a character before or not. */
static bool prev_roll = FALSE;
/* Display the player - a bit cheaty, but never mind. */
display_player(0);
if (first_call)
prev_roll = FALSE;
/* Prepare a prompt (must squeeze everything in) */
strnfcat(prompt, sizeof (prompt), &promptlen, "['r' to reroll");
if (prev_roll)
strnfcat(prompt, sizeof(prompt), &promptlen, ", 'p' for previous roll");
strnfcat(prompt, sizeof (prompt), &promptlen, " or 'Enter' to accept]");
/* Prompt for it */
prt(prompt, Term->hgt - 1, Term->wid / 2 - promptlen / 2);
/* Prompt and get a command */
ch = inkey();
/* Analyse the command */
if (ch.code == ESCAPE) {
/* Back out */
next = BIRTH_BACK;
} else if (ch.code == KC_ENTER) {
/* 'Enter' accepts the roll */
next = BIRTH_NAME_CHOICE;
} else if ((ch.code == ' ') || (ch.code == 'r')) {
/* Reroll this character */
cmdq_push(CMD_ROLL_STATS);
prev_roll = TRUE;
} else if (prev_roll && (ch.code == 'p')) {
/* Previous character */
cmdq_push(CMD_PREV_STATS);
} else if (ch.code == KTRL('X')) {
/* Quit */
quit(NULL);
} else if (ch.code == '?') {
/* Help XXX */
do_cmd_help();
} else {
/* Nothing handled directly here */
bell("Illegal roller command!");
}
return next;
}
/*
* Print an artifact activation message.
*
* In order to support randarts, with scrambled names, we re-write
* the message to replace instances of {name} with the artifact name
* and instances of {kind} with the type of object.
*
* This code deals with plural and singular forms of verbs correctly
* when encountering {s}, though in fact both names and kinds are
* always singular in the current code (gloves are "Set of" and boots
* are "Pair of")
*/
static void activation_message(object_type *o_ptr, const char *message)
{
char buf[1024] = "\0";
const char *next;
const char *s;
const char *tag;
const char *in_cursor;
size_t end = 0;
in_cursor = message;
next = strchr(in_cursor, '{');
while (next)
{
/* Copy the text leading up to this { */
strnfcat(buf, 1024, &end, "%.*s", next - in_cursor, in_cursor);
s = next + 1;
while (*s && isalpha((unsigned char) *s)) s++;
if (*s == '}') /* Valid tag */
{
tag = next + 1; /* Start the tag after the { */
in_cursor = s + 1;
switch(art_tag_lookup(tag))
{
case ART_TAG_NAME:
end += object_desc(buf, 1024, o_ptr, ODESC_PREFIX | ODESC_BASE);
break;
case ART_TAG_KIND:
object_kind_name(&buf[end], 1024-end, o_ptr->kind, TRUE);
end += strlen(&buf[end]);
break;
case ART_TAG_VERB:
strnfcat(buf, 1024, &end, "s");
break;
case ART_TAG_VERB_IS:
if((end > 2) && (buf[end-2] == 's'))
strnfcat(buf, 1024, &end, "are");
else
strnfcat(buf, 1024, &end, "is");
default:
break;
}
}
else /* An invalid tag, skip it */
{
in_cursor = next + 1;
}
next = strchr(in_cursor, '{');
}
strnfcat(buf, 1024, &end, in_cursor);
msg("%s", buf);
}
static size_t obj_desc_combat(const object_type *o_ptr, char *buf, size_t max,
size_t end, bool spoil)
{
bitflag flags[OF_SIZE];
bitflag flags_known[OF_SIZE];
object_flags(o_ptr, flags);
object_flags_known(o_ptr, flags_known);
if (of_has(flags, OF_SHOW_DICE)) {
/* Only display the real damage dice if the combat stats are known */
if (spoil || object_attack_plusses_are_visible(o_ptr))
strnfcat(buf, max, &end, " (%dd%d)", o_ptr->dd, o_ptr->ds);
else
strnfcat(buf, max, &end, " (%dd%d)", o_ptr->kind->dd, o_ptr->kind->ds);
}
if (of_has(flags, OF_SHOW_MULT)) {
/* Display shooting power as part of the multiplier */
if (of_has(flags, OF_MIGHT) &&
(spoil || object_flag_is_known(o_ptr, OF_MIGHT)))
strnfcat(buf, max, &end, " (x%d)", (o_ptr->sval % 10) + o_ptr->pval[which_pval(o_ptr, OF_MIGHT)]);
else
strnfcat(buf, max, &end, " (x%d)", o_ptr->sval % 10);
}
/* Show weapon bonuses */
if (spoil || object_attack_plusses_are_visible(o_ptr)) {
if (wield_slot(o_ptr) == INVEN_WIELD || wield_slot(o_ptr) == INVEN_BOW
|| obj_is_ammo(o_ptr) || o_ptr->to_d || o_ptr->to_h) {
/* Make an exception for body armor with only a to-hit penalty */
if (o_ptr->to_h < 0 && o_ptr->to_d == 0 &&
(o_ptr->tval == TV_SOFT_ARMOR ||
o_ptr->tval == TV_HARD_ARMOR ||
o_ptr->tval == TV_DRAG_ARMOR))
strnfcat(buf, max, &end, " (%+d)", o_ptr->to_h);
/* Otherwise, always use the full tuple */
else
strnfcat(buf, max, &end, " (%+d,%+d)", o_ptr->to_h, o_ptr->to_d);
}
}
/* Show armor bonuses */
if (spoil || object_defence_plusses_are_visible(o_ptr)) {
if (obj_desc_show_armor(o_ptr))
strnfcat(buf, max, &end, " [%d,%+d]", o_ptr->ac, o_ptr->to_a);
else if (o_ptr->to_a)
strnfcat(buf, max, &end, " [%+d]", o_ptr->to_a);
}
else if (obj_desc_show_armor(o_ptr))
strnfcat(buf, max, &end, " [%d]", object_was_sensed(o_ptr) ? o_ptr->ac : o_ptr->kind->ac);
return end;
}
/**
* Describe combat properties of an item - damage dice, to-hit, to-dam, armor
* class, missile multipler
*/
static size_t obj_desc_combat(const struct object *obj, char *buf, size_t max,
size_t end, bool spoil)
{
bitflag flags_known[OF_SIZE];
object_flags_known(obj, flags_known);
if (kf_has(obj->kind->kind_flags, KF_SHOW_DICE)) {
/* Only display the real damage dice if the combat stats are known */
if (spoil || object_attack_plusses_are_visible(obj))
strnfcat(buf, max, &end, " (%dd%d)", obj->dd, obj->ds);
else
strnfcat(buf, max, &end, " (%dd%d)", obj->kind->dd,
obj->kind->ds);
}
if (kf_has(obj->kind->kind_flags, KF_SHOW_MULT)) {
/* Display shooting power as part of the multiplier */
if ((obj->modifiers[OBJ_MOD_MIGHT] > 0) &&
(spoil || object_this_mod_is_visible(obj, OBJ_MOD_MIGHT)))
strnfcat(buf, max, &end, " (x%d)",
obj->pval + obj->modifiers[OBJ_MOD_MIGHT]);
else
strnfcat(buf, max, &end, " (x%d)", obj->pval);
}
/* Show weapon bonuses */
if (spoil || object_attack_plusses_are_visible(obj)) {
if (tval_is_weapon(obj) || obj->to_d || obj->to_h) {
/* Make an exception for body armor with only a to-hit penalty */
if (obj->to_h < 0 && obj->to_d == 0 &&
tval_is_body_armor(obj))
strnfcat(buf, max, &end, " (%+d)", obj->to_h);
/* Otherwise, always use the full tuple */
else
strnfcat(buf, max, &end, " (%+d,%+d)", obj->to_h,
obj->to_d);
}
}
/* Show armor bonuses */
if (spoil || object_defence_plusses_are_visible(obj)) {
if (obj_desc_show_armor(obj))
strnfcat(buf, max, &end, " [%d,%+d]", obj->ac, obj->to_a);
else if (obj->to_a)
strnfcat(buf, max, &end, " [%+d]", obj->to_a);
}
else if (obj_desc_show_armor(obj))
strnfcat(buf, max, &end, " [%d]",
object_was_sensed(obj) ? obj->ac : obj->kind->ac);
return end;
}
/**
* Add "unseen" to the end of unaware items in stores
*/
static size_t obj_desc_aware(const struct object *obj, char *buf, size_t max,
size_t end)
{
if (!object_flavor_is_aware(obj))
strnfcat(buf, max, &end, " {unseen}");
return end;
}
/* Add "unseen" to the end of unaware items in stores */
static size_t obj_desc_aware(const object_type *o_ptr, char *buf, size_t max,
size_t end)
{
if (!object_flavor_is_aware(o_ptr))
strnfcat(buf, max, &end, " {unseen}");
return end;
}
static size_t obj_desc_light(const object_type *o_ptr, char *buf, size_t max, size_t end)
{
/* Fuelled light sources get number of remaining turns appended */
if (fuelable_lite_p(o_ptr))
strnfcat(buf, max, &end, " (%d turns)", o_ptr->timeout);
return end;
}
static size_t obj_desc_pval(const object_type *o_ptr, char *buf, size_t max, size_t end)
{
u32b f1, f2, f3, fn;
object_flags(o_ptr, &f1, &f2, &f3, &fn);
if (!(f1 & TR1_PVAL_MASK)) return end;
strnfcat(buf, max, &end, " (%+d", o_ptr->pval);
if (!(f3 & TR3_HIDE_TYPE))
{
if (f1 & TR1_STEALTH)
strnfcat(buf, max, &end, " stealth");
else if (f1 & TR1_SEARCH)
strnfcat(buf, max, &end, " searching");
else if (f1 & TR1_INFRA)
strnfcat(buf, max, &end, " infravision");
else if (f1 & TR1_SPEED)
strnfcat(buf, max, &end, " speed");
else if (f1 & TR1_BLOWS)
strnfcat(buf, max, &end, " attack%s", PLURAL(o_ptr->pval));
}
strnfcat(buf, max, &end, ")");
return end;
}
static size_t obj_desc_pval(const object_type *o_ptr, char *buf, size_t max, size_t end)
{
bitflag f[OF_SIZE];
object_flags(o_ptr, f);
if (!flags_test(f, OF_SIZE, OF_PVAL_MASK, FLAG_END)) return end;
strnfcat(buf, max, &end, " (%+d", o_ptr->pval);
if (!of_has(f, OF_HIDE_TYPE))
{
if (of_has(f, OF_STEALTH))
strnfcat(buf, max, &end, " stealth");
else if (of_has(f, OF_SEARCH))
strnfcat(buf, max, &end, " searching");
else if (of_has(f, OF_INFRA))
strnfcat(buf, max, &end, " infravision");
else if (of_has(f, OF_SPEED))
strnfcat(buf, max, &end, " speed");
else if (of_has(f, OF_BLOWS))
strnfcat(buf, max, &end, " attack%s", PLURAL(o_ptr->pval));
}
strnfcat(buf, max, &end, ")");
return end;
}
static size_t obj_desc_light(const object_type * o_ptr, char *buf, size_t max,
size_t end)
{
/* Fuelled light sources get number of remaining turns appended */
if ((o_ptr->tval == TV_LIGHT) && !artifact_p(o_ptr))
strnfcat(buf, max, &end, " (%d turns)", o_ptr->pval);
return end;
}
/**
* Describe remaining light for refuellable lights
*/
static size_t obj_desc_light(const struct object *obj, char *buf, size_t max,
size_t end)
{
/* Fuelled light sources get number of remaining turns appended */
if (tval_is_light(obj) && !of_has(obj->flags, OF_NO_FUEL))
strnfcat(buf, max, &end, " (%d turns)", obj->timeout);
return end;
}
static size_t obj_desc_charges(const object_type * o_ptr, char *buf, size_t max,
size_t end)
{
object_kind *k_ptr = &k_info[o_ptr->k_idx];
bool aware = object_aware_p(o_ptr);
/* Wands and Staffs have charges */
if (aware && (o_ptr->tval == TV_STAFF || o_ptr->tval == TV_WAND))
strnfcat(buf, max, &end, " (%d charge%s)", o_ptr->pval,
PLURAL(o_ptr->pval));
/* Charging things */
else if (o_ptr->timeout > 0) {
if (o_ptr->tval == TV_ROD && o_ptr->number > 1) {
int power;
int time_base = randcalc(k_ptr->time, 0, MINIMISE);
if (!time_base)
time_base = 1;
/*
* Find out how many rods are charging, by dividing
* current timeout by each rod's maximum timeout.
* Ensure that any remainder is rounded up. Display
* very discharged stacks as merely fully discharged.
*/
power = (o_ptr->timeout + (time_base - 1)) / time_base;
if (power > o_ptr->number)
power = o_ptr->number;
/* Display prettily */
strnfcat(buf, max, &end, " (%d charging)", power);
}
/* Artifacts, single rods */
else if (!(o_ptr->tval == TV_LIGHT && !artifact_p(o_ptr))) {
strnfcat(buf, max, &end, " (charging)");
}
}
return end;
}
/**
* Format object obj's name into 'buf'.
*/
static size_t obj_desc_name(char *buf, size_t max, size_t end,
const struct object *obj, bool prefix, int mode, bool spoil, bool terse)
{
bool known = object_is_known(obj) || spoil;
bool aware = object_flavor_is_aware(obj) || (mode & ODESC_STORE) || spoil;
const char *basename = obj_desc_get_basename(obj, aware, terse, mode);
const char *modstr = obj_desc_get_modstr(obj->kind);
if (aware && !obj->kind->everseen && !spoil)
obj->kind->everseen = TRUE;
if (prefix)
end = obj_desc_name_prefix(buf, max, end, obj, known,
basename, modstr, terse);
/* Pluralize if (not forced singular) and
* (not a known/visible artifact) and
* (not one in stack or forced plural) */
end = obj_desc_name_format(buf, max, end, basename, modstr,
!(mode & ODESC_SINGULAR) &&
!(obj->artifact &&
(object_name_is_visible(obj) || known)) &&
(obj->number != 1 || (mode & ODESC_PLURAL)));
/** Append extra names of various kinds **/
if ((object_name_is_visible(obj) || known) && obj->artifact)
strnfcat(buf, max, &end, " %s", obj->artifact->name);
else if (((spoil && obj->ego) || object_ego_is_visible(obj)) &&
!(mode & ODESC_NOEGO))
strnfcat(buf, max, &end, " %s", obj->ego->name);
else if (aware && !obj->artifact &&
(obj->kind->flavor || obj->kind->tval == TV_SCROLL)) {
if (terse)
strnfcat(buf, max, &end, " '%s'", obj->kind->name);
else
strnfcat(buf, max, &end, " of %s", obj->kind->name);
}
return end;
}
/**
* Print a message when an object flag is identified by use.
*
* \param flag is the flag being noticed
* \param name is the object name
*/
void flag_message(int flag, char *name)
{
struct obj_property *prop = lookup_obj_property(OBJ_PROPERTY_FLAG, flag);
char buf[1024] = "\0";
const char *next;
const char *s;
const char *tag;
const char *in_cursor;
size_t end = 0;
/* See if we have a message */
if (!prop->msg) return;
in_cursor = prop->msg;
next = strchr(in_cursor, '{');
while (next) {
/* Copy the text leading up to this { */
strnfcat(buf, 1024, &end, "%.*s", next - in_cursor, in_cursor);
s = next + 1;
while (*s && isalpha((unsigned char) *s)) s++;
/* Valid tag */
if (*s == '}') {
/* Start the tag after the { */
tag = next + 1;
in_cursor = s + 1;
if (strncmp(tag, "name", 4) == 0) {
strnfcat(buf, 1024, &end, "%s", name);
}
} else {
/* An invalid tag, skip it */
in_cursor = next + 1;
}
next = strchr(in_cursor, '{');
}
strnfcat(buf, 1024, &end, in_cursor);
msg("%s", buf);
}
static size_t obj_desc_inscrip(const object_type * o_ptr, char *buf, size_t max,
size_t end)
{
const char *u[4] = { 0, 0, 0, 0 };
int n = 0;
/* Get inscription */
if (o_ptr->note)
u[n++] = quark_str(o_ptr->note);
/* Use special inscription, if any */
if (o_ptr->feel) {
u[n++] = feel_text[o_ptr->feel];
} else if ((o_ptr->ident & IDENT_EMPTY) && !object_known_p(o_ptr))
u[n++] = "empty";
else if (!object_aware_p(o_ptr) && object_tried_p(o_ptr))
u[n++] = "tried";
/* Use the discount, if any. No annoying inscription for homemade
* branded items. */
if ((o_ptr->discount > 0) && (o_ptr->discount != 80))
u[n++] = format("%d%% off", o_ptr->discount);
/* Note squelch */
if (squelch_item_ok(o_ptr))
u[n++] = "squelch";
if (n) {
int i;
for (i = 0; i < n; i++) {
if (i == 0)
strnfcat(buf, max, &end, " {");
strnfcat(buf, max, &end, "%s", u[i]);
if (i < n - 1)
strnfcat(buf, max, &end, ", ");
}
strnfcat(buf, max, &end, "}");
}
return end;
}
static void path_process(char *buf, size_t len, size_t *cur_len, const char *path)
{
#if defined(UNIX)
/* Home directory on Unixes */
if (path[0] == '~')
{
const char *s;
const char *username = path + 1;
struct passwd *pw;
char user[128];
/* Look for non-user portion of the file */
s = strstr(username, PATH_SEP);
if (s)
{
int i;
/* Keep username a decent length */
if (s >= username + sizeof(user)) return;
for (i = 0; username < s; ++i) user[i] = *username++;
user[i] = '\0';
username = user;
}
/* Look up a user (or "current" user) */
pw = username[0] ? getpwnam(username) : getpwuid(getuid());
if (!pw) return;
/* Copy across */
strnfcat(buf, len, cur_len, "%s%s", pw->pw_dir, PATH_SEP);
if (s) strnfcat(buf, len, cur_len, "%s", s);
}
else
#endif /* defined(UNIX) */
strnfcat(buf, len, cur_len, "%s", path);
}
static size_t obj_desc_light(const object_type *o_ptr, char *buf, size_t max, size_t end)
{
bitflag f[OF_SIZE];
object_flags(o_ptr, f);
/* Fuelled light sources get number of remaining turns appended */
if ((o_ptr->tval == TV_LIGHT) && !of_has(f, OF_NO_FUEL))
strnfcat(buf, max, &end, " (%d turns)", o_ptr->timeout);
return end;
}
void get_table_name(char *out_string, bool quotes)
{
int testcounter = 2;
int len = 0;
/* Empty string */
out_string[0] = 0;
if (quotes)
{
strnfcat(out_string, 18, &len, "'");
}
if (one_in_(3))
{
while (testcounter--)
strnfcat(out_string, 18, &len, syllables[randint0(MAX_SYLLABLES)]);
}
else
{
char Syllable[80];
while (testcounter--)
{
(void)get_rnd_line("elvish.txt", 0, Syllable);
strnfcat(out_string, 18, &len, "%s", Syllable);
}
}
if (quotes)
{
out_string[1] = toupper(out_string[1]);
strnfcat(out_string, 18, &len, "'");
}
else
{
out_string[0] = toupper(out_string[0]);
}
}
/**
* Start to description, indicating number/uniqueness (a, the, no more, 7, etc)
*/
static size_t obj_desc_name_prefix(char *buf, size_t max, size_t end,
const struct object *obj, bool known, const char *basename,
const char *modstr, bool terse)
{
if (obj->number == 0)
strnfcat(buf, max, &end, "no more ");
else if (obj->number > 1)
strnfcat(buf, max, &end, "%d ", obj->number);
else if ((object_name_is_visible(obj) || known) && obj->artifact)
strnfcat(buf, max, &end, "the ");
else if (*basename == '&')
{
bool an = FALSE;
const char *lookahead = basename + 1;
while (*lookahead == ' ') lookahead++;
if (*lookahead == '#')
{
if (modstr && is_a_vowel(*modstr))
an = TRUE;
}
else if (is_a_vowel(*lookahead))
{
an = TRUE;
}
if (!terse)
{
if (an)
strnfcat(buf, max, &end, "an ");
else
strnfcat(buf, max, &end, "a ");
}
}
return end;
}
/**
* Describe numerical modifiers to stats and other player qualities which
* allow numerical bonuses - speed, stealth, etc
*/
static size_t obj_desc_mods(const struct object *obj, char *buf, size_t max,
size_t end, bool spoil)
{
int i, j, num_mods = 0;
int mods[OBJ_MOD_MAX] = { 0 };
/* Run through possible modifiers and store distinct ones */
for (i = 0; i < OBJ_MOD_MAX; i++) {
/* Check for known non-zero mods */
if ((spoil || object_this_mod_is_visible(obj, i))
&& (obj->modifiers[i] != 0)) {
/* If no mods stored yet, store and move on */
if (!num_mods) {
mods[num_mods++] = obj->modifiers[i];
continue;
}
/* Run through the existing mods, quit on duplicates */
for (j = 0; j < num_mods; j++)
if (mods[j] == obj->modifiers[i]) break;
/* Add another mod if needed */
if (j == num_mods)
mods[num_mods++] = obj->modifiers[i];
}
}
if (!num_mods) return end;
/* Print the modifiers */
strnfcat(buf, max, &end, " <");
for (j = 0; j < num_mods; j++) {
if (j) strnfcat(buf, max, &end, ", ");
strnfcat(buf, max, &end, "%+d", mods[j]);
}
strnfcat(buf, max, &end, ">");
return end;
}
/*
* Function used to print a flag in coloured binary.
*/
void binary_fmt(char *buf, uint max, cptr fmt, va_list *vp)
{
uint i;
u32b mask = 1;
int len = 0;
u32b arg;
/* Unused parameter */
(void)fmt;
/* Pre-terminate buffer */
buf[0] = '\0';
/* Get the argument */
arg = va_arg(*vp, u32b);
/* Scan the flags */
for (i = 1; ((i <= 32) && (i < max)); i++)
{
/* Dump set bits */
if (arg & mask)
{
strnfcat(buf, max, &len, CLR_BLUE "*");
}
/* Dump unset bits */
else
{
strnfcat(buf, max, &len, CLR_WHITE "-");
}
mask *= 2;
}
}
/**
* Create a new path string by appending a 'leaf' to 'base'.
*
* On Unixes, we convert a tidle at the beginning of a basename to mean the
* directory, complicating things a little, but better now than later.
*
* Remember to free the return value.
*/
size_t path_build(char *buf, size_t len, const char *base, const char *leaf)
{
size_t cur_len = 0;
int starts_with_separator;
buf[0] = '\0';
if (!leaf || !leaf[0]) {
if (base && base[0])
path_process(buf, len, &cur_len, base);
return cur_len;
}
/*
* If the leafname starts with the seperator,
* or with the tilde (on Unix),
* or there's no base path,
* We use the leafname only.
*/
starts_with_separator = (!base || !base[0]) || prefix(leaf, PATH_SEP);
#if defined(UNIX)
starts_with_separator = starts_with_separator || leaf[0] == '~';
#endif
if (starts_with_separator) {
path_process(buf, len, &cur_len, leaf);
return cur_len;
}
/* There is both a relative leafname and a base path from which it is
* relative */
path_process(buf, len, &cur_len, base);
strnfcat(buf, len, &cur_len, "%s", PATH_SEP);
path_process(buf, len, &cur_len, leaf);
return cur_len;
}
/*
* Create a new path string by appending a 'leaf' to 'base'.
*
* On Unixes, we convert a tidle at the beginning of a basename to mean the
* directory, complicating things a little, but better now than later.
*
* Remember to free the return value.
*/
size_t path_build(char *buf, size_t len, const char *base, const char *leaf)
{
size_t cur_len = 0;
buf[0] = '\0';
if (!leaf || !leaf[0])
{
if (base && base[0])
path_process(buf, len, &cur_len, base);
return cur_len;
}
/*
* If the leafname starts with the seperator,
* or with the tilde (on Unix),
* or there's no base path,
* We use the leafname only.
*/
#if defined(SET_UID) || defined(USE_PRIVATE_PATHS)
if ((!base || !base[0]) || prefix(leaf, PATH_SEP) || leaf[0] == '~')
#else
if ((!base || !base[0]) || prefix(leaf, PATH_SEP))
#endif
{
path_process(buf, len, &cur_len, leaf);
return cur_len;
}
/* There is both a relative leafname and a base path from which it is relative */
path_process(buf, len, &cur_len, base);
strnfcat(buf, len, &cur_len, "%s", PATH_SEP);
path_process(buf, len, &cur_len, leaf);
return cur_len;
}
static size_t obj_desc_inscrip(const object_type *o_ptr, char *buf, size_t max, size_t end)
{
const char *u[6] = { 0, 0, 0, 0, 0, 0};
int n = 0;
/* See if the object is "known" */
bool known = (object_known_p(o_ptr) ? TRUE : FALSE);
bool aware = (object_aware_p(o_ptr) ? TRUE : FALSE);
u32b f1, f2, f3, fn;
object_flags(o_ptr, &f1, &f2, &f3, &fn);
/* Get inscription, pdeudo-id, or store discount */
if (o_ptr->obj_note) u[n++] = quark_str(o_ptr->obj_note);
if (o_ptr->discount >= INSCRIP_NULL)
{
u[n++] = inscrip_text[o_ptr->discount - INSCRIP_NULL];
}
else if (cursed_p(o_ptr) && known)
{
u[n++] = "cursed";
}
else if ((o_ptr->ident & IDENT_EMPTY) && (!known))
{
u[n++] = "empty";
}
else if ((!aware) && object_tried_p(o_ptr))
{
u[n++] = "tried";
}
else if (o_ptr->discount > 0)
{
char buf[80];
my_strcpy(buf, format("%d%% off", o_ptr->discount), sizeof(buf));
u[n++] = buf;
}
/* Use the "unknown" inscription */
else if (!known && can_be_pseudo_ided(o_ptr) &&
(o_ptr->discount < INSCRIP_NULL))
{
u[n++] = "unknown";
}
if (n)
{
int i;
for (i = 0; i < n; i++)
{
if (i == 0)
strnfcat(buf, max, &end, " {");
strnfcat(buf, max, &end, "%s", u[i]);
if (i < n-1)
strnfcat(buf, max, &end, ", ");
}
strnfcat(buf, max, &end, "}");
}
return end;
}
static size_t obj_desc_charges(const object_type *o_ptr, char *buf, size_t max, size_t end)
{
object_kind *k_ptr = &k_info[o_ptr->k_idx];
bool aware = object_flavor_is_aware(o_ptr) || (o_ptr->ident & IDENT_STORE);
/* See if the object is "known" */
bool known = (object_known_p(o_ptr) ? TRUE : FALSE);
/* Wands and Staffs have charges */
if (aware && known && (o_ptr->tval == TV_STAFF || o_ptr->tval == TV_WAND))
strnfcat(buf, max, &end, " (%d charge%s)", o_ptr->pval, PLURAL(o_ptr->pval));
/* Charging things */
else if (o_ptr->timeout > 0)
{
/* Hack -- Rods have a "charging" indicator */
if (known && (o_ptr->tval == TV_ROD))
{
/* Hack -- Dump " (# charging)" if relevant */
if (o_ptr->timeout >= 1)
{
/* Stacks of rods display an exact count of charging rods. */
if (o_ptr->number > 1)
{
int power;
/* Paranoia. */
if (k_ptr->pval == 0) k_ptr->pval = 1;
/* Find out how many rods are charging, by dividing
* current timeout by each rod's maximum timeout.
* Ensure that any remainder is rounded up. Display
* very discharged stacks as merely fully discharged.
*/
power = (o_ptr->timeout + (k_ptr->pval - 1)) / k_ptr->pval;
if (power > o_ptr->number) power = o_ptr->number;
/* Display prettily */
strnfcat(buf, max, &end, " (%d charging)", power);
}
/* Display prettily */
else strnfcat(buf, max, &end, " (charging)");
}
}
/* Indicate "charging" objects, but not rods or lites */
if (known && o_ptr->timeout && o_ptr->tval != TV_ROD
&& !fuelable_lite_p(o_ptr))
{
/* Hack -- Dump " (charging)" if relevant */
strnfcat(buf, max, &end, " (charging)");
}
}
return end;
}
