/** * Set object names and get their maximum length. * Only makes sense after building the object list. */ static void set_obj_names(bool terse) { int i; struct object *obj; /* Calculate name offset and max name length */ for (i = 0; i < num_obj; i++) { obj = items[i].object; /* Null objects are used to skip lines, or display only a label */ if (!obj) { if ((i < num_head) || !strcmp(items[i].label, "In quiver")) strnfmt(items[i].o_name, sizeof(items[i].o_name), ""); else strnfmt(items[i].o_name, sizeof(items[i].o_name), "(nothing)"); } else { if (terse) object_desc(items[i].o_name, sizeof(items[i].o_name), obj, ODESC_PREFIX | ODESC_FULL | ODESC_TERSE); else object_desc(items[i].o_name, sizeof(items[i].o_name), obj, ODESC_PREFIX | ODESC_FULL); } /* Max length of label + object name */ max_len = MAX(max_len, strlen(items[i].label) + strlen(items[i].equip_label) + strlen(items[i].o_name)); } }
void object_notice_attack_plusses(object_type *o_ptr) { if (!o_ptr->k_idx) return; if (object_attack_plusses_are_visible(o_ptr)) return; if (object_add_ident_flags(o_ptr, IDENT_ATTACK)) object_check_for_ident(o_ptr); if (wield_slot(o_ptr) == INVEN_WIELD) { char o_name[80]; object_desc(o_name, sizeof(o_name), o_ptr, ODESC_BASE); message_format(MSG_PSEUDOID, 0, "You know more about the %s you are using.", o_name); } else if ((o_ptr->to_d || o_ptr->to_h) && !((o_ptr->tval == TV_HARD_ARMOR || o_ptr->tval == TV_SOFT_ARMOR) && (o_ptr->to_h < 0))) { char o_name[80]; object_desc(o_name, sizeof(o_name), o_ptr, ODESC_BASE); message_format(MSG_PSEUDOID, 0, "Your %s glows.", o_name); } p_ptr->update |= (PU_BONUS); event_signal(EVENT_INVENTORY); event_signal(EVENT_EQUIPMENT); }
/** * Remove an amount of an object from the inventory or quiver, returning * a detached object which can be used. * * Optionally describe what remains. */ struct object *gear_object_for_use(struct object *obj, int num, bool message) { struct object *usable; char name[80]; char label = gear_to_label(obj); bool artifact = obj->artifact && (object_is_known(obj) || object_name_is_visible(obj)); /* Bounds check */ num = MIN(num, obj->number); /* Prepare a name if necessary */ if (message) { /* Artifacts */ if (artifact) object_desc(name, sizeof(name), obj, ODESC_FULL | ODESC_SINGULAR); else { /* Describe as if it's already reduced */ obj->number -= num; object_desc(name, sizeof(name), obj, ODESC_PREFIX | ODESC_FULL); obj->number += num; } } /* Split off a usable object if necessary */ if (obj->number > num) { usable = object_split(obj, num); } else { /* We're using the entire stack */ usable = obj; gear_excise_object(usable); /* Stop tracking item */ if (tracked_object_is(player->upkeep, obj)) track_object(player->upkeep, NULL); /* Inventory has changed, so disable repeat command */ cmd_disable_repeat(); } /* Change the weight */ player->upkeep->total_weight -= (num * obj->weight); /* Housekeeping */ player->upkeep->update |= (PU_BONUS); player->upkeep->notice |= (PN_COMBINE); player->upkeep->redraw |= (PR_INVEN | PR_EQUIP); /* Print a message if desired */ if (message) { if (artifact) msg("You no longer have the %s (%c).", name, label); else msg("You have %s (%c).", name, label); } return usable; }
/** * Melee effect handler: Eat the player's food. */ static void melee_effect_handler_EAT_FOOD(melee_effect_handler_context_t *context) { /* Steal some food */ int tries; /* Take damage */ take_hit(context->p, context->damage, context->ddesc); /* Player is dead */ if (context->p->is_dead) return; for (tries = 0; tries < 10; tries++) { /* Pick an item from the pack */ int index = randint0(z_info->pack_size); struct object *obj, *eaten; char o_name[80]; bool none_left = false; /* Get the item */ obj = context->p->upkeep->inven[index]; /* Skip non-objects */ if (obj == NULL) continue; /* Skip non-food objects */ if (!tval_is_edible(obj)) continue; if (obj->number == 1) { object_desc(o_name, sizeof(o_name), obj, ODESC_BASE); msg("Your %s (%c) was eaten!", o_name, I2A(index)); } else { object_desc(o_name, sizeof(o_name), obj, ODESC_PREFIX | ODESC_BASE); msg("One of your %s (%c) was eaten!", o_name, I2A(index)); } /* Steal and eat */ eaten = gear_object_for_use(obj, 1, false, &none_left); if (eaten->known) object_delete(&eaten->known); object_delete(&eaten); /* Obvious */ context->obvious = true; /* Done */ break; } }
/** * Notice any slays on a particular object which are in mask. * * \param o_ptr is the object on which we are noticing slays * \param mask is the flagset within which we are noticing them */ void object_notice_slays(object_type *o_ptr, const bitflag mask[OF_SIZE]) { bool learned; bitflag f[OF_SIZE]; char o_name[40]; int i; /* We are only interested in the flags specified in mask */ object_flags(o_ptr, f); of_inter(f, mask); /* if you learn a slay, learn the ego and print a message */ for (i = 0; i < SL_MAX; i++) { const struct slay *s_ptr = &slay_table[i]; if (of_has(f, s_ptr->object_flag)) { learned = object_notice_flag(o_ptr, s_ptr->object_flag); if (EASY_LEARN && learned) { object_notice_ego(o_ptr); object_desc(o_name, sizeof(o_name), o_ptr, ODESC_BASE | ODESC_SINGULAR); msg("Your %s %s!", o_name, s_ptr->active_verb); } } } object_check_for_ident(o_ptr); }
/** * 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; }
/** * Build an "artifact name" and transfer it into a buffer. */ static void get_art_name(char *buf, int a_idx) { int i; object_type localObject; object_type *o_ptr; artifact_type *a_ptr = &a_info[a_idx]; /* Get local object */ o_ptr = &localObject; /* Wipe the object */ object_wipe(o_ptr); /* Acquire the "kind" index */ i = lookup_kind(a_ptr->tval, a_ptr->sval); /* Oops */ if (!i) return; /* Create the base object */ object_prep(o_ptr, i, RANDOMISE); /* Mark it as an artifact */ o_ptr->name1 = a_idx; /* Make it known to us */ o_ptr->ident |= IDENT_KNOWN; /* Create the artifact description */ object_desc(buf, 60, o_ptr, ODESC_SINGULAR | ODESC_SPOIL); }
/* * Menu command: examine items in the inventory. */ static void death_examine(const char *title, int row) { int item; const char *q, *s; /* Get an item */ q = "Examine which item? "; s = "You have nothing to examine."; while (get_item(&item, q, s, 0, (USE_INVEN | USE_EQUIP | IS_HARMLESS))) { char header[120]; textblock *tb; region area = { 0, 0, 0, 0 }; object_type *o_ptr = &p_ptr->inventory[item]; tb = object_info(o_ptr, OINFO_FULL); object_desc(header, sizeof(header), o_ptr, ODESC_PREFIX | ODESC_FULL); textui_textblock_show(tb, area, format("%^s", header)); textblock_free(tb); } }
/* Examine an object */ void textui_obj_examine(void) { char header[120]; textblock *tb; region area = { 0, 0, 0, 0 }; object_type *o_ptr; int item; /* Select item */ if (!get_item(&item, "Examine which item?", "You have nothing to examine.", CMD_NULL, (USE_EQUIP | USE_INVEN | USE_FLOOR | IS_HARMLESS))) return; /* Track object for object recall */ track_object(item); /* Display info */ o_ptr = object_from_item_idx(item); tb = object_info(o_ptr, OINFO_NONE); object_desc(header, sizeof(header), o_ptr, ODESC_PREFIX | ODESC_FULL); textui_textblock_show(tb, area, format("%^s", header)); textblock_free(tb); }
/* * 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); } }
void kamaenaoshi(int item) { object_type *o_ptr, *new_o_ptr; char o_name[MAX_NLEN]; if (item == INVEN_RARM) { if (buki_motteruka(INVEN_LARM)) { o_ptr = &inventory[INVEN_LARM]; object_desc(o_name, o_ptr, 0); if (!object_is_cursed(o_ptr)) { new_o_ptr = &inventory[INVEN_RARM]; object_copy(new_o_ptr, o_ptr); p_ptr->total_weight += o_ptr->weight; inven_item_increase(INVEN_LARM, -((int)o_ptr->number)); inven_item_optimize(INVEN_LARM); if (object_allow_two_hands_wielding(o_ptr) && CAN_TWO_HANDS_WIELDING()) #ifdef JP msg_format("%sを両手で構えた。", o_name); #else msg_format("You are wielding %s with both hands.", o_name); #endif else #ifdef JP msg_format("%sを%sで構えた。", o_name, (left_hander ? "左手" : "右手")); #else msg_format("You are wielding %s in your %s hand.", o_name, (left_hander ? "left":"right")); #endif } else { if (object_allow_two_hands_wielding(o_ptr) && CAN_TWO_HANDS_WIELDING())
/* * Verify the choice of an item. * * The item can be negative to mean "item on floor". */ bool verify_item(const char *prompt, int item) { char o_name[80]; char out_val[160]; object_type *o_ptr; /* Inventory */ if (item >= 0) { o_ptr = &p_ptr->inventory[item]; } /* Floor */ else { o_ptr = object_byid(0 - item); } /* Describe */ object_desc(o_name, sizeof(o_name), o_ptr, ODESC_PREFIX | ODESC_FULL); /* Prompt */ strnfmt(out_val, sizeof(out_val), "%s %s? ", prompt, o_name); /* Query */ return (get_check(out_val)); }
/** * 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; }
/* Destroy an item */ void do_cmd_destroy(cmd_code code, cmd_arg args[]) { object_type *o_ptr; int item = args[0].item; if (!item_is_available(item, NULL, USE_INVEN | USE_EQUIP | USE_FLOOR)) { msg("You do not have that item to ignore it."); return; } o_ptr = object_from_item_idx(item); if ((item >= INVEN_WIELD) && cursed_p(o_ptr->flags)) { msg("You cannot ignore cursed items."); } else { char o_name[80]; object_desc(o_name, sizeof o_name, o_ptr, ODESC_PREFIX | ODESC_FULL); msgt(MSG_DESTROY, "Ignoring %s.", o_name); o_ptr->ignore = TRUE; p_ptr->notice |= PN_SQUELCH; } }
static bool _destroy_object(obj_ptr obj) { if (obj->tval == TV_LIFE_BOOK || obj->tval == TV_CRUSADE_BOOK) { char name[MAX_NLEN]; int sp = 0; int osp = p_ptr->csp; switch (obj->sval) { case 0: sp = 10; break; case 1: sp = 25; break; case 2: sp = 100; break; case 3: sp = 666; break; } sp_player(sp); object_desc(name, obj, OD_COLOR_CODED); msg_format("You gleefully destroy %s!", name); if (p_ptr->csp > osp) msg_print("You feel your head clear."); return TRUE; } return FALSE; }
/** * Let an object fall to the ground at or near a location. * * The initial location is assumed to be "square_in_bounds_fully(cave, )". * * This function takes a parameter "chance". This is the percentage * chance that the item will "disappear" instead of drop. If the object * has been thrown, then this is the chance of disappearance on contact. * * This function will produce a description of a drop event under the player * when "verbose" is true. * * The calling function needs to deal with the consequences of the dropped * object being destroyed or absorbed into an existing pile. */ void drop_near(struct chunk *c, struct object **dropped, int chance, int y, int x, bool verbose) { char o_name[80]; int best_y = y; int best_x = x; /* Only called in the current level */ assert(c == cave); /* Describe object */ object_desc(o_name, sizeof(o_name), *dropped, ODESC_BASE); /* Handle normal breakage */ if (!((*dropped)->artifact) && (randint0(100) < chance)) { floor_carry_fail(*dropped, true); return; } /* Find the best grid and drop the item, destroying if there's no space */ drop_find_grid(*dropped, &best_y, &best_x); if (floor_carry(c, best_y, best_x, *dropped, false)) { sound(MSG_DROP); if (verbose && (c->squares[best_y][best_x].mon < 0) && c->objects[(*dropped)->oidx] && !ignore_item_ok(*dropped)) msg("You feel something roll beneath your feet."); } else { floor_carry_fail(*dropped, false); } }
/** * Cheat -- describe a created object for the user */ static void object_mention(object_type * o_ptr) { char o_name[120]; /* Describe */ object_desc(o_name, sizeof(o_name), o_ptr, ODESC_BASE | ODESC_SPOIL); /* Artifact */ if (artifact_p(o_ptr)) { /* Silly message */ msg("Artifact (%s)", o_name); } /* Ego-item */ else if (ego_item_p(o_ptr)) { /* Silly message */ msg("Ego-item (%s)", o_name); } /* Normal item */ else { /* Silly message */ msg("Object (%s)", o_name); } }
/** * Take off a non-cursed equipment item * * Note that taking off an item when "full" may cause that item * to fall to the ground. * * Note also that this function does not try to combine the taken off item * with other inventory items - that must be done by the calling function. */ void inven_takeoff(struct object *obj) { int slot = equipped_item_slot(player->body, obj); const char *act; char o_name[80]; /* Paranoia */ if (slot == player->body.count) return; /* Describe the object */ object_desc(o_name, sizeof(o_name), obj, ODESC_PREFIX | ODESC_FULL); /* Describe removal by slot */ if (slot_type_is(slot, EQUIP_WEAPON)) act = "You were wielding"; else if (slot_type_is(slot, EQUIP_BOW)) act = "You were holding"; else if (slot_type_is(slot, EQUIP_LIGHT)) act = "You were holding"; else act = "You were wearing"; /* De-equip the object */ player->body.slots[slot].obj = NULL; player->upkeep->equip_cnt--; /* Message */ msgt(MSG_WIELD, "%s %s (%c).", act, o_name, I2A(slot)); player->upkeep->update |= (PU_BONUS | PU_INVEN); player->upkeep->notice |= (PN_IGNORE); return; }
/** * Examine an object */ void textui_obj_examine(void) { char header[120]; textblock *tb; region area = { 0, 0, 0, 0 }; struct object *obj; /* Select item */ if (!get_item(&obj, "Examine which item?", "You have nothing to examine.", CMD_NULL, NULL, (USE_EQUIP | USE_INVEN | USE_QUIVER | USE_FLOOR | IS_HARMLESS))) return; /* Track object for object recall */ track_object(player->upkeep, obj); /* Display info */ tb = object_info(obj, OINFO_NONE); object_desc(header, sizeof(header), obj, ODESC_PREFIX | ODESC_FULL | ODESC_CAPITAL); textui_textblock_show(tb, area, header); textblock_free(tb); }
/*! * @brief 装備への呪い付加判定と付加処理 / * @param chance 呪いの基本確率 * @param heavy_chance 重い呪いを選択肢に入れるか否か。 * @return なし */ void curse_equipment(int chance, int heavy_chance) { bool changed = FALSE; int curse_power = 0; u32b new_curse; u32b oflgs[TR_FLAG_SIZE]; object_type *o_ptr = &inventory[INVEN_RARM + randint0(12)]; char o_name[MAX_NLEN]; if (randint1(100) > chance) return; if (!o_ptr->k_idx) return; object_flags(o_ptr, oflgs); object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY)); /* Extra, biased saving throw for blessed items */ if (have_flag(oflgs, TR_BLESSED) && (randint1(888) > chance)) { #ifdef JP msg_format("%sは呪いを跳ね返した!", o_name, #else msg_format("Your %s resist%s cursing!", o_name, #endif ((o_ptr->number > 1) ? "" : "s")); /* Hmmm -- can we wear multiple items? If not, this is unnecessary */ return; }
/* 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; }
/* * Show artifact lore */ static void desc_art_fake(int a_idx) { object_type *o_ptr; object_type object_type_body = { 0 }; char header[120]; textblock *tb; region area = { 0, 0, 0, 0 }; o_ptr = find_artifact(a_idx); /* If it's been lost, make a fake artifact for it */ if (!o_ptr) { o_ptr = &object_type_body; make_fake_artifact(o_ptr, a_idx); /* Check the history entry, to see if it was fully known * before it was lost */ if (history_is_artifact_known(a_idx)) { o_ptr->ident |= IDENT_KNOWN; } } /* Hack -- Handle stuff */ handle_stuff(p_ptr); tb = object_info(o_ptr, OINFO_NONE); object_desc(header, sizeof(header), o_ptr, ODESC_PREFIX | ODESC_FULL | ODESC_CAPITAL); textui_textblock_show(tb, area, format("%s", header)); textblock_free(tb); }
/* * Carry an object and delete it. */ static void py_pickup_aux(int o_idx, bool domsg) { int slot, quiver_slot = 0; char o_name[80]; object_type *o_ptr = object_byid(o_idx); /* Carry the object */ slot = inven_carry(p_ptr, o_ptr); /* Handle errors (paranoia) */ if (slot < 0) return; /* If we have picked up ammo which matches something in the quiver, note * that it so that we can wield it later (and suppress pick up message) */ if (obj_is_ammo(o_ptr)) { int i; for (i = QUIVER_START; i < QUIVER_END; i++) { if (!p_ptr->inventory[i].kind) continue; if (!object_similar(&p_ptr->inventory[i], o_ptr, OSTACK_QUIVER)) continue; quiver_slot = i; break; } } /* Get the new object */ o_ptr = &p_ptr->inventory[slot]; /* Set squelch status */ p_ptr->notice |= PN_SQUELCH; /* Automatically sense artifacts */ object_notice_artifact(o_ptr); /* Optionally, display a message */ if (domsg && !quiver_slot) { /* Describe the object */ object_desc(o_name, sizeof(o_name), o_ptr, ODESC_PREFIX | ODESC_FULL); /* Message */ msg("You have %s (%c).", o_name, index_to_label(slot)); } /* Update object_idx if necessary */ if (p_ptr->object_idx == (0 - o_idx)) { track_object(slot); } /* Delete the object */ delete_object_idx(o_idx); /* If we have a quiver slot that this ammo matches, use it */ if (quiver_slot) wield_item(o_ptr, slot, quiver_slot); }
/* * 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); }
/** * Label an item as an ego item if it has the required flags */ void label_as_ego(object_type * o_ptr, int item) { char o_name[120]; int j; int temp_flag; ego_item_type *e_ptr = &e_info[o_ptr->name2]; /* All ego object flags now known */ of_union(o_ptr->id_obj, e_ptr->flags_obj); /* All shown curses are now known */ if (of_has(e_ptr->flags_obj, OF_SHOW_CURSE)) cf_union(o_ptr->id_curse, e_ptr->flags_curse); /* Know all ego resists */ for (j = 0; j < MAX_P_RES; j++) { temp_flag = OBJECT_ID_BASE_RESIST + j; if (e_ptr->percent_res[j] != RES_LEVEL_BASE) if_on(o_ptr->id_other, temp_flag); } /* Know all ego slays */ for (j = 0; j < MAX_P_SLAY; j++) { temp_flag = OBJECT_ID_BASE_SLAY + j; if (e_ptr->multiple_slay[j] != MULTIPLE_BASE) if_on(o_ptr->id_other, temp_flag); } /* Know all ego brands */ for (j = 0; j < MAX_P_BRAND; j++) { temp_flag = OBJECT_ID_BASE_BRAND + j; if (e_ptr->multiple_brand[j] != MULTIPLE_BASE) if_on(o_ptr->id_other, temp_flag); } /* Combine / Reorder the pack (later) */ p_ptr->notice |= (PN_COMBINE | PN_REORDER); /* Redraw stuff */ p_ptr->redraw |= (PR_INVEN | PR_EQUIP | PR_BASIC | PR_EXTRA); /* Handle stuff */ handle_stuff(p_ptr); /* Description */ object_desc(o_name, sizeof(o_name), o_ptr, ODESC_PREFIX | ODESC_FULL); /* Describe */ if (item - 1 >= INVEN_WIELD) { char *m = format("%s: %s (%c).", describe_use(item - 1), o_name, index_to_label(item - 1)); my_strcap(m); msg(m); } else if (item - 1 >= 0) { msg("In your pack: %s (%c).", o_name, index_to_label(item)); } }
/** * Remove an amount of an object from the floor, returning a detached object * which can be used - it is assumed that the object is on the player grid. * * Optionally describe what remains. */ struct object *floor_object_for_use(struct object *obj, int num, bool message, bool *none_left) { struct object *usable; char name[80]; /* Bounds check */ num = MIN(num, obj->number); /* Split off a usable object if necessary */ if (obj->number > num) { usable = object_split(obj, num); } else { usable = obj; square_excise_object(player->cave, usable->iy, usable->ix, usable->known); delist_object(player->cave, usable->known); square_excise_object(cave, usable->iy, usable->ix, usable); delist_object(cave, usable); *none_left = true; /* Stop tracking item */ if (tracked_object_is(player->upkeep, obj)) track_object(player->upkeep, NULL); /* Inventory has changed, so disable repeat command */ cmd_disable_repeat(); } /* Object no longer has a location */ usable->known->iy = 0; usable->known->ix = 0; usable->iy = 0; usable->ix = 0; /* Housekeeping */ player->upkeep->update |= (PU_BONUS | PU_INVEN); player->upkeep->notice |= (PN_COMBINE); player->upkeep->redraw |= (PR_INVEN | PR_EQUIP); /* Print a message if requested and there is anything left */ if (message) { if (usable == obj) obj->number = 0; /* Get a description */ object_desc(name, sizeof(name), obj, ODESC_PREFIX | ODESC_FULL); if (usable == obj) obj->number = num; /* Print a message */ msg("You see %s.", name); } return usable; }
static void get_artifact_display_name(char *o_name, size_t namelen, int a_idx) { object_type object_type_body = { 0 }; object_type *o_ptr = &object_type_body; make_fake_artifact(o_ptr, a_idx); object_desc(o_name, namelen, o_ptr, ODESC_PREFIX | ODESC_BASE | ODESC_SPOIL); }
void sword_absorb_object(object_type *o_ptr) { if (object_is_melee_weapon(o_ptr)) { char o_name[MAX_NLEN]; object_desc(o_name, o_ptr, OD_NAME_ONLY); msg_format("You attempt to drain power from %s.", o_name); _absorb(o_ptr); } }
/** * Notice things about an object that would be noticed in time. */ static void object_notice_after_time(void) { int i; int flag; object_type *o_ptr; char o_name[80]; bitflag f[OF_SIZE], timed_mask[OF_SIZE]; flags_init(timed_mask, OF_SIZE, OF_NOTICE_TIMED_MASK, FLAG_END); /* Check every item the player is wearing */ for (i = INVEN_WIELD; i < ALL_INVEN_TOTAL; i++) { o_ptr = &p_ptr->inventory[i]; if (!o_ptr->k_idx || object_is_known(o_ptr)) continue; /* Check for timed notice flags */ object_desc(o_name, sizeof(o_name), o_ptr, ODESC_BASE); object_flags(o_ptr, f); of_inter(f, timed_mask); for (flag = of_next(f, FLAG_START); flag != FLAG_END; flag = of_next(f, flag + 1)) { if (!of_has(o_ptr->known_flags, flag)) { /* Message */ if (!streq(msgs[flag], "")) msg_format(msgs[flag], o_name); /* Notice the flag */ object_notice_flag(o_ptr, flag); if (object_is_jewelry(o_ptr) && (!object_effect(o_ptr) || object_effect_is_known(o_ptr))) { /* XXX this is a small hack, but jewelry with anything noticeable really is obvious */ /* XXX except, wait until learn activation if that is only clue */ object_flavor_aware(o_ptr); object_check_for_ident(o_ptr); } } else { /* Notice the flag is absent */ object_notice_flag(o_ptr, flag); } } /* XXX Is this necessary? */ object_check_for_ident(o_ptr); } }
/** * Drop (some of) a non-cursed inventory/equipment item "near" the current * location * * There are two cases here - a single object or entire stack is being dropped, * or part of a stack is being split off and dropped */ void inven_drop(struct object *obj, int amt) { int py = player->py; int px = player->px; struct object *dropped; char o_name[80]; /* Error check */ if (amt <= 0) return; /* This should not happen - ask for report */ if (!pile_contains(player->gear, obj)) { /* Describe the dropped object */ object_desc(o_name, sizeof(o_name), obj, ODESC_PREFIX | ODESC_FULL); msg("Bug - attempt to drop %s when not held!", o_name); return; } /* Not too many */ if (amt > obj->number) amt = obj->number; /* Take off equipment */ if (object_is_equipped(player->body, obj)) inven_takeoff(obj); /* Get the object */ dropped = gear_object_for_use(obj, amt, TRUE); /* Describe the dropped object */ object_desc(o_name, sizeof(o_name), dropped, ODESC_PREFIX | ODESC_FULL); /* Message */ msg("You drop %s (%c).", o_name, gear_to_label(obj)); /* Drop it near the player */ drop_near(cave, dropped, 0, py, px, FALSE); event_signal(EVENT_INVENTORY); }