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