#include "AppHdr.h"
#include "describe.h"
#include "database.h"
#include <stdio.h>
#include <string>
#include <sstream>
#include <iomanip>
#include <numeric>
#ifdef TARGET_OS_DOS
#include <conio.h>
#endif
#include "externs.h"
#include "species.h"
#include "abl-show.h"
#include "artefact.h"
#include "cio.h"
#include "debug.h"
#include "decks.h"
#include "fight.h"
#include "food.h"
#include "ghost.h"
#include "godabil.h"
#include "goditem.h"
#include "invent.h"
#include "itemname.h"
#include "itemprop.h"
#include "items.h"
#include "macro.h"
#include "mapmark.h"
#include "menu.h"
#include "message.h"
#include "monstuff.h"
#include "mon-util.h"
#include "newgame.h"
#include "jobs.h"
#include "player.h"
#include "random.h"
#include "religion.h"
#include "rng.h"
#include "skills2.h"
#include "spells3.h"
#include "spl-book.h"
#include "stuff.h"
#include "spl-cast.h"
#include "spl-util.h"
#include "transfor.h"
#include "tutorial.h"
#include "xom.h"
#define LONG_DESC_KEY "long_desc_key"
static void _append_value( std::string & description, int valu, bool plussed )
{
if (valu >= 0 && plussed == 1)
description += "+";
char value_str[80];
itoa( valu, value_str, 10 );
description += value_str;
}
int count_desc_lines(const std::string _desc, const int width)
{
std::string desc = get_linebreak_string(_desc, width);
int count = 0;
for (int i = 0, size = desc.size(); i < size; ++i)
{
const char ch = desc[i];
if (ch == '\n' || ch == '$')
count++;
}
return count;
}
void print_description(const std::string &body)
{
describe_info inf;
inf.body << body;
print_description(inf);
}
class default_desc_proc
{
public:
int width() { return get_number_of_cols() - 1; }
int height() { return get_number_of_lines(); }
void print(const std::string &str) { cprintf("%s", str.c_str()); }
void nextline() { cgotoxy(1, wherey() + 1); }
};
void print_description(const describe_info &inf)
{
clrscr();
textcolor(LIGHTGREY);
default_desc_proc proc;
process_description<default_desc_proc>(proc, inf);
}
const char* jewellery_base_ability_string(int subtype)
{
switch (subtype)
{
case RING_REGENERATION: return "Regen";
case RING_SUSTAIN_ABILITIES: return "SustAb";
case RING_SUSTENANCE: return "Hunger-";
case RING_WIZARDRY: return "Wiz";
case RING_FIRE: return "Fire";
case RING_ICE: return "Ice";
case RING_TELEPORT_CONTROL: return "cTele";
case AMU_RESIST_SLOW: return "rSlow";
case AMU_CLARITY: return "Clar";
case AMU_WARDING: return "Ward";
case AMU_RESIST_CORROSION: return "rCorr";
case AMU_THE_GOURMAND: return "Gourm";
case AMU_CONSERVATION: return "Cons";
case AMU_CONTROLLED_FLIGHT: return "cFly";
case AMU_RESIST_MUTATION: return "rMut";
case AMU_GUARDIAN_SPIRIT: return "Spirit";
}
return "";
}
#define known_proprt(prop) (proprt[(prop)] && known[(prop)])
struct property_annotators
{
const char* name;
artefact_prop_type prop;
int spell_out; };
static std::vector<std::string> _randart_propnames( const item_def& item )
{
artefact_properties_t proprt;
artefact_known_props_t known;
artefact_desc_properties( item, proprt, known, true );
std::vector<std::string> propnames;
const property_annotators propanns[] = {
{ "-CAST", ARTP_PREVENT_SPELLCASTING, 2 },
{ "-TELE", ARTP_PREVENT_TELEPORTATION, 2 },
{ "MUT", ARTP_MUTAGENIC, 2 }, { "*Rage", ARTP_ANGRY, 2 },
{ "*TELE", ARTP_CAUSE_TELEPORTATION, 2 },
{ "Hunger", ARTP_METABOLISM, 2 }, { "Noisy", ARTP_NOISES, 2 },
{ "+Blink", ARTP_BLINK, 2 },
{ "+Tele", ARTP_CAN_TELEPORT, 2 },
{ "+Rage", ARTP_BERSERK, 2 },
{ "+Inv", ARTP_INVISIBLE, 2 },
{ "+Lev", ARTP_LEVITATE, 2 },
{ "+Map", ARTP_MAPPING, 2 },
{ "rElec", ARTP_ELECTRICITY, 2 },
{ "rPois", ARTP_POISON, 2 },
{ "rF", ARTP_FIRE, 1 },
{ "rC", ARTP_COLD, 1 },
{ "rN", ARTP_NEGATIVE_ENERGY, 1 },
{ "MR", ARTP_MAGIC, 2 },
{ "Spirit", ARTP_SPIRIT_SHIELD, 2 },
{ "AC", ARTP_AC, 0 },
{ "EV", ARTP_EVASION, 0 },
{ "Str", ARTP_STRENGTH, 0 },
{ "Dex", ARTP_DEXTERITY, 0 },
{ "Int", ARTP_INTELLIGENCE, 0 },
{ "Acc", ARTP_ACCURACY, 0 },
{ "Dam", ARTP_DAMAGE, 0 },
{ "MP", ARTP_MAGICAL_POWER, 0 },
{ "SInv", ARTP_EYESIGHT, 2 },
{ "Stlth", ARTP_STEALTH, 2 }, { "Curse", ARTP_CURSED, 2 },
};
if (item.base_type == OBJ_JEWELLERY
&& item_ident(item, ISFLAG_KNOW_PROPERTIES))
{
const std::string type = jewellery_base_ability_string(item.sub_type);
if (!type.empty())
propnames.push_back(type);
}
else if (item.base_type == OBJ_WEAPONS
&& item_ident(item, ISFLAG_KNOW_TYPE))
{
std::string ego = weapon_brand_name(item, true);
if (!ego.empty())
{
ego = ego.substr(2, ego.length() - 3);
for (unsigned i = 0; i < ARRAYSZ(propanns); ++i)
if (known_proprt(propanns[i].prop)
&& propanns[i].prop != ARTP_BRAND)
{
ego += ",";
break;
}
propnames.push_back(ego);
}
}
for (unsigned i = 0; i < ARRAYSZ(propanns); ++i)
{
if (known_proprt(propanns[i].prop))
{
const int val = proprt[propanns[i].prop];
if (item.base_type == OBJ_JEWELLERY)
{
if (item.sub_type == RING_FIRE
&& (propanns[i].prop == ARTP_FIRE && val == 1
|| propanns[i].prop == ARTP_COLD && val == -1))
{
continue;
}
if (item.sub_type == RING_ICE
&& (propanns[i].prop == ARTP_COLD && val == 1
|| propanns[i].prop == ARTP_FIRE && val == -1))
{
continue;
}
}
std::ostringstream work;
switch (propanns[i].spell_out)
{
case 0: work << std::showpos << propanns[i].name << val;
break;
case 1: {
int sval = std::min(std::abs(val), 3);
work << propanns[i].name
<< std::string(sval, (val > 0 ? '+' : '-'));
break;
}
case 2: if (propanns[i].prop == ARTP_CURSED && val < 1)
continue;
work << propanns[i].name;
if (propanns[i].prop == ARTP_METABOLISM && val > 2
|| propanns[i].prop == ARTP_MUTAGENIC && val > 3
|| propanns[i].prop == ARTP_STEALTH && val > 20)
{
work << "+";
}
else if (propanns[i].prop == ARTP_STEALTH && val < 0)
{
if (val < -20)
work << "--";
else
work << "-";
}
break;
}
propnames.push_back(work.str());
}
}
return propnames;
}
static void _trim_randart_inscrip( item_def& item )
{
std::vector<std::string> propnames = _randart_propnames(item);
for (unsigned int i = 0; i < propnames.size(); ++i)
{
item.inscription = replace_all(item.inscription, propnames[i]+",", "");
item.inscription = replace_all(item.inscription, propnames[i], "");
}
trim_string(item.inscription);
}
std::string artefact_auto_inscription( const item_def& item )
{
if (item.base_type == OBJ_BOOKS)
return ("");
const std::vector<std::string> propnames = _randart_propnames(item);
return (comma_separated_line(propnames.begin(), propnames.end(),
" ", " "));
}
void add_autoinscription( item_def &item, std::string ainscrip)
{
_trim_randart_inscrip(item);
if (!item.inscription.empty())
{
if (ends_with(item.inscription, ","))
item.inscription += " ";
else
item.inscription += ", ";
}
item.inscription += ainscrip;
}
struct property_descriptor
{
artefact_prop_type property;
const char* desc; bool is_graded_resist;
};
static std::string _randart_descrip( const item_def &item )
{
std::string description;
artefact_properties_t proprt;
artefact_known_props_t known;
artefact_desc_properties( item, proprt, known );
const property_descriptor propdescs[] = {
{ ARTP_AC, "It affects your AC (%d).", false },
{ ARTP_EVASION, "It affects your evasion (%d).", false},
{ ARTP_STRENGTH, "It affects your strength (%d).", false},
{ ARTP_INTELLIGENCE, "It affects your intelligence (%d).", false},
{ ARTP_DEXTERITY, "It affects your dexterity (%d).", false},
{ ARTP_ACCURACY, "It affects your accuracy (%d).", false},
{ ARTP_DAMAGE, "It affects your damage-dealing abilities (%d).", false},
{ ARTP_FIRE, "fire", true},
{ ARTP_COLD, "cold", true},
{ ARTP_ELECTRICITY, "It insulates you from electricity.", false},
{ ARTP_POISON, "It protects you from poison.", false},
{ ARTP_NEGATIVE_ENERGY, "negative energy", true},
{ ARTP_MAGIC, "It increases your resistance to enchantments.", false},
{ ARTP_MAGICAL_POWER, "It affects your mana capacity (%d).", false},
{ ARTP_EYESIGHT, "It enhances your eyesight.", false},
{ ARTP_INVISIBLE, "It lets you turn invisible.", false},
{ ARTP_LEVITATE, "It lets you levitate.", false},
{ ARTP_BLINK, "It lets you blink.", false},
{ ARTP_CAN_TELEPORT, "It lets you teleport.", false},
{ ARTP_BERSERK, "It lets you go berserk.", false},
{ ARTP_MAPPING, "It lets you sense your surroundings.", false},
{ ARTP_SPIRIT_SHIELD, "It shields you from harm at the cost of magical power.", false},
{ ARTP_NOISES, "It makes noises.", false},
{ ARTP_PREVENT_SPELLCASTING, "It prevents spellcasting.", false},
{ ARTP_CAUSE_TELEPORTATION, "It causes teleportation.", false},
{ ARTP_PREVENT_TELEPORTATION, "It prevents most forms of teleportation.",
false},
{ ARTP_ANGRY, "It makes you angry.", false},
{ ARTP_CURSED, "It may recurse itself.", false}
};
for (unsigned i = 0; i < ARRAYSZ(propdescs); ++i)
{
if (known_proprt(propdescs[i].property))
{
if (propdescs[i].property == ARTP_CURSED
&& proprt[propdescs[i].property] < 1)
{
continue;
}
std::string sdesc = propdescs[i].desc;
char buf[80];
snprintf(buf, sizeof buf, "%+d", proprt[propdescs[i].property]);
sdesc = replace_all(sdesc, "%d", buf);
if (propdescs[i].is_graded_resist)
{
int idx = proprt[propdescs[i].property] + 3;
idx = std::min(idx, 6);
idx = std::max(idx, 0);
const char* prefixes[] = {
"It makes you extremely vulnerable to ",
"It makes you very vulnerable to ",
"It makes you vulnerable to ",
"Buggy descriptor!",
"It protects you from ",
"It greatly protects you from ",
"It renders you almost immune to "
};
sdesc = prefixes[idx] + sdesc + '.';
}
description += '$';
description += sdesc;
}
}
if (known_proprt( ARTP_METABOLISM ))
{
if (proprt[ ARTP_METABOLISM ] >= 3)
description += "$It greatly speeds your metabolism.";
else if (proprt[ ARTP_METABOLISM ])
description += "$It speeds your metabolism. ";
}
if (known_proprt( ARTP_STEALTH ))
{
const int stval = proprt[ARTP_STEALTH];
char buf[80];
snprintf(buf, sizeof buf, "$It makes you %s%s stealthy.",
(stval < -20 || stval > 20) ? "much " : "",
(stval < 0) ? "less" : "more");
description += buf;
}
if (known_proprt( ARTP_MUTAGENIC ))
{
if (proprt[ ARTP_MUTAGENIC ] > 3)
description += "$It glows with mutagenic radiation.";
else
description += "$It emits mutagenic radiation.";
}
return description;
}
#undef known_proprt
static const char *trap_names[] =
{
"dart", "arrow", "spear", "axe",
"teleport", "alarm", "blade",
"bolt", "net", "zot", "needle",
"shaft"
};
const char *trap_name(trap_type trap)
{
ASSERT(NUM_TRAPS == sizeof(trap_names) / sizeof(*trap_names));
if (trap >= TRAP_DART && trap < NUM_TRAPS)
return trap_names[trap];
return (NULL);
}
int str_to_trap(const std::string &s)
{
ASSERT(NUM_TRAPS == sizeof(trap_names) / sizeof(*trap_names));
if (s == "random" || s == "any")
return (TRAP_RANDOM);
else if (s == "suitable")
return (TRAP_INDEPTH);
else if (s == "nonteleport" || s == "noteleport"
|| s == "nontele" || s == "notele")
{
return (TRAP_NONTELEPORT);
}
for (int i = 0; i < NUM_TRAPS; ++i)
if (trap_names[i] == s)
return (i);
return (-1);
}
static std::string _describe_demon(const monsters &mons)
{
ASSERT(mons.ghost.get());
const ghost_demon &ghost = *mons.ghost;
const long seed =
std::accumulate(ghost.name.begin(), ghost.name.end(), 0L) *
ghost.name.length();
rng_save_excursion exc;
seed_rng( seed );
const char* body_descs[] = {
" huge, barrel-shaped ",
" wispy, insubstantial ",
" spindly ",
" skeletal ",
" horribly deformed ",
" spiny ",
" waif-like ",
" scaly ",
" sickeningly deformed ",
" bruised and bleeding ",
" sickly ",
" mass of writhing tentacles for a ",
" mass of ropey tendrils for a ",
" tree trunk-like ",
" hairy ",
" furry ",
" fuzzy ",
"n obese ",
" fat ",
" slimy ",
" wrinkled ",
" metallic ",
" glassy ",
" crystalline ",
" muscular ",
"n icky ",
" swollen ",
" lumpy ",
"n armoured ",
" carapaced ",
" slender "
};
const char* wing_names[] = {
" with small insectoid wings",
" with large insectoid wings",
" with moth-like wings",
" with butterfly wings",
" with huge, bat-like wings",
" with fleshy wings",
" with small, bat-like wings",
" with hairy wings",
" with great feathered wings",
" with shiny metal wings"
};
const char* lev_names[] = {
" which hovers in mid-air",
" with sacs of gas hanging from its back"
};
const char* nonfly_names[] = {
" covered in tiny crawling spiders",
" covered in tiny crawling insects",
" and the head of a crocodile",
" and the head of a hippopotamus",
" and a cruel curved beak for a mouth",
" and a straight sharp beak for a mouth",
" and no head at all",
" and a hideous tangle of tentacles for a mouth",
" and an elephantine trunk",
" and an evil-looking proboscis",
" and dozens of eyes",
" and two ugly heads",
" and a long serpentine tail",
" and a pair of huge tusks growing from its jaw",
" and a single huge eye, in the centre of its forehead",
" and spikes of black metal for teeth",
" and a disc-shaped sucker for a head",
" and huge, flapping ears",
" and a huge, toothy maw in the centre of its chest",
" and a giant snail shell on its back",
" and a dozen heads",
" and the head of a jackal",
" and the head of a baboon",
" and a huge, slobbery tongue",
" which is covered in oozing lacerations",
" and the head of a frog",
" and the head of a yak",
" and eyes out on stalks",
};
const char* misc_descs[] = {
" It seethes with hatred of the living.",
" Tiny orange flames dance around it.",
" Tiny purple flames dance around it.",
" It is surrounded by a weird haze.",
" It glows with a malevolent light.",
" It looks incredibly angry.",
" It oozes with slime.",
" It dribbles constantly.",
" Mould grows all over it.",
" It looks diseased.",
" It looks as frightened of you as you are of it.",
" It moves in a series of hideous convulsions.",
" It moves with an unearthly grace.",
" It hungers for your soul!",
" It leaves a glistening oily trail.",
" It shimmers before your eyes.",
" It is surrounded by a brilliant glow.",
" It radiates an aura of extreme power.",
};
std::ostringstream description;
description << "A powerful demon, " << ghost.name << " has a"
<< RANDOM_ELEMENT(body_descs) << "body";
switch (ghost.fly)
{
case FL_FLY:
description << RANDOM_ELEMENT(wing_names);
break;
case FL_LEVITATE:
description << RANDOM_ELEMENT(lev_names);
break;
case FL_NONE: if (!one_chance_in(4))
description << RANDOM_ELEMENT(nonfly_names);
break;
}
description << ".";
if (x_chance_in_y(3, 40))
{
if (player_can_smell())
{
switch (random2(3))
{
case 0:
description << " It stinks of brimstone.";
break;
case 1:
description << " It is surrounded by a sickening stench.";
break;
case 2:
description << " It smells like rotting flesh"
<< (player_mutation_level(MUT_SAPROVOROUS) == 3 ?
" - yum!" : ".");
break;
}
}
}
else if (coinflip())
description << RANDOM_ELEMENT(misc_descs);
return description.str();
}
void append_weapon_stats(std::string &description, const item_def &item)
{
description += "$Damage rating: ";
_append_value(description, property( item, PWPN_DAMAGE ), false);
description += " ";
description += "Accuracy rating: ";
_append_value(description, property( item, PWPN_HIT ), true);
description += " ";
description += "Base attack delay: ";
_append_value(description, property( item, PWPN_SPEED ) * 10, false);
description += "%";
}
static std::string _describe_weapon(const item_def &item, bool verbose)
{
std::string description;
description.reserve(200);
description = "";
if (verbose)
append_weapon_stats(description, item);
int spec_ench = get_weapon_brand( item );
if (!is_artefact( item ) && !verbose)
spec_ench = SPWPN_NORMAL;
if (spec_ench != SPWPN_NORMAL && item_type_known(item))
{
description += "$$";
switch (spec_ench)
{
case SPWPN_FLAMING:
description += "It emits flame when wielded, "
"causing extra injury to most foes "
"and up to double damage against "
"particularly susceptible opponents. "
"Big, fiery blades are also staple "
"armaments of hydra-hunters.";
break;
case SPWPN_FREEZING:
description += "It has been specially enchanted to "
"freeze those struck by it, causing "
"extra injury to most foes and "
"up to double damage against "
"particularly susceptible opponents. "
"It can also slow down cold-blooded creatures.";
break;
case SPWPN_HOLY_WRATH:
description += "It has been blessed by the Shining One "
"to cause great damage to the undead and demons.";
break;
case SPWPN_ELECTROCUTION:
description += "Occasionally upon striking a foe "
"it will discharge some electrical energy "
"and cause terrible harm.";
break;
case SPWPN_ORC_SLAYING:
description += "It is especially effective against "
"all of orcish descent.";
break;
case SPWPN_DRAGON_SLAYING:
description += "This legendary weapon is deadly to all "
"dragonkind. It also provides some protection from the "
"breath attacks of dragons and other creatures.";
break;
case SPWPN_VENOM:
if (is_range_weapon(item))
description += "It poisons the unbranded ammo it fires.";
else
description += "It poisons the flesh of those it strikes.";
break;
case SPWPN_PROTECTION:
description += "It protects the one who wields it against "
"injury (+5 to AC).";
break;
case SPWPN_DRAINING:
description += "A truly terrible weapon, "
"it drains the life of those it strikes.";
break;
case SPWPN_SPEED:
description += "Attacks with this weapon take half as long "
"as usual.";
break;
case SPWPN_VORPAL:
if (is_range_weapon(item))
{
description += "Any ";
description += ammo_name( item );
description += " fired from it inflicts extra damage.";
}
else
{
description += "It inflicts extra damage upon "
"your enemies.";
}
break;
case SPWPN_FLAME:
description += "It turns projectiles fired from it into "
"bolts of flame.";
break;
case SPWPN_FROST:
description += "It turns projectiles fired from it into "
"bolts of frost.";
break;
case SPWPN_CHAOS:
if (is_range_weapon(item))
{
description += "Each time it fires it turns the launched "
"projectile into a different, random type of bolt.";
}
else
{
description += "Each time it hits an enemy it has a "
"different, random effect.";
}
break;
case SPWPN_VAMPIRICISM:
description += "It inflicts no extra harm, "
"but heals its wielder somewhat when "
"it strikes a living foe.";
break;
case SPWPN_PAIN:
description += "In the hands of one skilled in "
"necromantic magic it inflicts "
"extra damage on living creatures.";
break;
case SPWPN_DISTORTION:
description += "It warps and distorts space around it. "
"Unwielding it can cause banishment or high damage.";
break;
case SPWPN_REACHING:
description += "It can be evoked to extend its reach.";
break;
case SPWPN_RETURNING:
description += "A skilled user can throw it in such a way "
"that it will return to its owner.";
break;
case SPWPN_PENETRATION:
description += "Ammo fired by it will pass through the "
"targets it hits, potentially hitting all targets in "
"its path until it reaches maximum range.";
break;
case SPWPN_REAPING:
description += "If ammo fired by it kills a monster, "
"causing it to leave a corpse, the corpse will be "
"animated as a zombie friendly to the one who fired it.";
break;
}
}
if (is_artefact( item ))
{
std::string rand_desc = _randart_descrip( item );
if (!rand_desc.empty())
{
description += "$$";
description += rand_desc;
}
if (!item_ident(item, ISFLAG_KNOW_PROPERTIES)
&& item_type_known(item))
{
description += "$This weapon may have some hidden properties.";
}
}
const bool launcher = is_range_weapon(item);
if (verbose)
{
description += "$$This weapon falls into the";
const skill_type skill =
is_range_weapon(item)? range_skill(item) : weapon_skill(item);
description +=
make_stringf(" '%s' category. ",
skill == SK_FIGHTING? "buggy" : skill_name(skill));
if (!launcher)
{
switch (hands_reqd(item, you.body_size()))
{
case HANDS_ONE:
description += "It is a one handed weapon";
break;
case HANDS_HALF:
description += "It can be used with one hand, or more "
"effectively with two (i.e. when not using a shield)";
break;
case HANDS_TWO:
description += "It is a two handed weapon";
break;
case HANDS_DOUBLE:
description += "It is a buggy weapon";
break;
}
const int str_weight = weapon_str_weight(item.base_type,
item.sub_type);
if (str_weight >= 8)
description += ", and it is best used by the strong";
else if (str_weight > 5)
description += ", and it is better for the strong";
else if (str_weight <= 2)
description += ", and it is best used by the dexterous";
else if (str_weight < 5)
description += ", and it is better for the dexterous";
description += ".";
}
if (!you.could_wield(item, true))
description += "$It is too large for you to wield.";
}
if (verbose)
{
if (is_demonic(item) && !launcher)
description += "$Demonspawn are more deadly with it.";
else if (get_equip_race(item) != ISFLAG_NO_RACE)
{
unsigned long race = get_equip_race(item);
if (race == ISFLAG_DWARVEN)
description += "$It is well-crafted and very durable.";
description += "$";
description += (race == ISFLAG_DWARVEN) ? "Dwarves" :
(race == ISFLAG_ELVEN) ? "Elves"
: "Orcs";
description += " are more deadly with it";
if (launcher)
{
description += ", and it is most deadly when used with ";
description += racial_description_string(item);
description += "ammunition";
}
description += ".";
}
}
if (!is_known_artefact(item))
{
if (item_ident( item, ISFLAG_KNOW_PLUSES )
&& item.plus >= MAX_WPN_ENCHANT && item.plus2 >= MAX_WPN_ENCHANT)
{
description += "$It is maximally enchanted.";
}
else
{
description += "$It can be maximally enchanted to +";
_append_value(description, MAX_WPN_ENCHANT, false);
description += ", +";
_append_value(description, MAX_WPN_ENCHANT, false);
description += ".";
}
}
return (description);
}
static std::string _describe_ammo( const item_def &item )
{
std::string description;
description.reserve(64);
if (item.sub_type == MI_THROWING_NET)
{
if (item.plus > 1 || item.plus < 0)
{
std::string how;
if (item.plus > 1)
how = "brand-new";
else if (item.plus < 0)
{
if (item.plus > -3)
how = "a little worn";
else if (item.plus > -5)
how = "slightly damaged";
else if (item.plus > -7)
how = "damaged";
else
how = "heavily frayed";
}
description += "It looks ";
description += how;
description += ".";
}
}
bool can_launch = has_launcher(item);
bool can_throw = is_throwable(&you, item, true);
bool need_new_line = true;
bool always_destroyed = false;
if (item.special && item_type_known(item))
{
description += "$$";
std::string bolt_name;
std::string threw_or_fired;
if (can_throw)
{
threw_or_fired += "threw";
if (can_launch)
threw_or_fired += " or ";
}
if (can_launch)
threw_or_fired += "fired";
switch (item.special)
{
case SPMSL_FLAME:
bolt_name = "flame";
case SPMSL_FROST:
if (bolt_name.empty())
bolt_name = "frost";
case SPMSL_CHAOS:
if (bolt_name.empty())
bolt_name = "a random type";
description += "When ";
if (can_throw)
{
description += "thrown, ";
if (can_launch)
description += "or ";
}
if (can_launch)
description += "fired from an appropriate launcher, ";
description += "it turns into a bolt of ";
description += bolt_name;
description += ".";
always_destroyed = true;
break;
case SPMSL_POISONED:
description += "It is coated with poison.";
break;
case SPMSL_CURARE:
description += "It is tipped with asphyxiating poison.";
break;
case SPMSL_RETURNING:
description += "A skilled user can throw it in such a way "
"that it will return to its owner.";
break;
case SPMSL_REAPING:
description += "If it kills a monster, causing it to leave "
"a corpse, the corpse will be animated as a zombie "
"friendly to the one who " + threw_or_fired + " it.";
break;
case SPMSL_PENETRATION:
description += "It will pass through any targets it hits, "
"potentially hitting all targets in its path until it "
"reaches maximum range.";
break;
case SPMSL_DISPERSAL:
description += "Any target it hits will blink, with a "
"tendency towards blinking further away from the one "
"who " + threw_or_fired + " it.";
break;
case SPMSL_EXPLODING:
description += "It will explode into fragments upon "
"hitting a target, hitting an obstruction, or reaching "
"the end of its range.";
always_destroyed = true;
break;
case SPMSL_STEEL:
description += "Compared to normal ammo, it does 50% more "
"damage, is destroyed upon impact only 1/10th of the "
"time, and weighs three three times as much.";
break;
case SPMSL_SILVER:
description += "Compared to normal ammo, it does twice as "
"much damage to the undead, demons and shapeshifters, "
"and weighs twice as much.";
break;
}
need_new_line = false;
}
if (get_equip_race(item) != ISFLAG_NO_RACE)
{
description += "$";
if (need_new_line)
description += "$";
if (can_throw)
{
unsigned long race = get_equip_race(item);
description += "It is more deadly when thrown by ";
description += (race == ISFLAG_DWARVEN) ? "dwarves" :
(race == ISFLAG_ELVEN) ? "elves"
: "orcs";
description += (can_launch) ? ", and it" : ".";
description += " ";
}
if (can_launch)
{
if (!can_throw)
description += "It ";
description += "is more effective in conjunction with ";
description += racial_description_string(item);
description += "launchers.";
}
}
if (always_destroyed)
description += "$It will always be destroyed upon impact.";
else if (item.sub_type != MI_THROWING_NET)
append_missile_info(description);
if (item_ident( item, ISFLAG_KNOW_PLUSES ) && item.plus >= MAX_WPN_ENCHANT)
description += "$It is maximally enchanted.";
else
{
description += "$It can be maximally enchanted to +";
_append_value(description, MAX_WPN_ENCHANT, false);
description += ".";
}
return (description);
}
void append_armour_stats(std::string &description, const item_def &item)
{
description += "$Armour rating: ";
_append_value(description, property( item, PARM_AC ), false);
description += " ";
description += "Evasion modifier: ";
_append_value(description, property( item, PARM_EVASION ), true);
}
void append_missile_info(std::string &description)
{
description += "$All pieces of ammunition may get destroyed upon impact. "
"Enchantment reduces the chances of such loss.";
}
static std::string _describe_armour( const item_def &item, bool verbose )
{
std::string description;
description.reserve(200);
if (verbose
&& item.sub_type != ARM_SHIELD
&& item.sub_type != ARM_BUCKLER
&& item.sub_type != ARM_LARGE_SHIELD)
{
append_armour_stats(description, item);
}
const int ego = get_armour_ego_type( item );
if (ego != SPARM_NORMAL && item_type_known(item) && verbose)
{
description += "$$";
switch (ego)
{
case SPARM_RUNNING:
description += "It allows its wearer to run at a great speed.";
break;
case SPARM_FIRE_RESISTANCE:
description += "It protects its wearer from heat and fire.";
break;
case SPARM_COLD_RESISTANCE:
description += "It protects its wearer from cold.";
break;
case SPARM_POISON_RESISTANCE:
description += "It protects its wearer from poison.";
break;
case SPARM_SEE_INVISIBLE:
description += "It allows its wearer to see invisible things.";
break;
case SPARM_DARKNESS:
description += "When activated it hides its wearer from "
"the sight of others, but also increases "
"their metabolic rate by a large amount.";
break;
case SPARM_STRENGTH:
description += "It increases the physical power of its wearer (+3 to strength).";
break;
case SPARM_DEXTERITY:
description += "It increases the dexterity of its wearer (+3 to dexterity).";
break;
case SPARM_INTELLIGENCE:
description += "It makes you more clever (+3 to intelligence).";
break;
case SPARM_PONDEROUSNESS:
description += "It is very cumbersome (-2 to EV, slows movement).";
break;
case SPARM_LEVITATION:
description += "It can be activated to allow its wearer to "
"float above the ground and remain so indefinitely.";
break;
case SPARM_MAGIC_RESISTANCE:
description += "It increases its wearer's resistance "
"to enchantments.";
break;
case SPARM_PROTECTION:
description += "It protects its wearer from harm (+3 to AC).";
break;
case SPARM_STEALTH:
description += "It enhances the stealth of its wearer.";
break;
case SPARM_RESISTANCE:
description += "It protects its wearer from the effects "
"of both cold and heat.";
break;
case SPARM_POSITIVE_ENERGY:
description += "It protects its wearer from "
"the effects of negative energy.";
break;
case SPARM_ARCHMAGI:
description += "It greatly increases the power of its "
"wearer's magical spells, but is only "
"intended for those who have very little left to learn.";
break;
case SPARM_PRESERVATION:
description += "It protects its wearer's possessions "
"from damage and destruction.";
break;
case SPARM_REFLECTION:
description += "It reflects blocked things back in the "
"direction they came from.";
break;
case SPARM_SPIRIT_SHIELD:
description += "It shields its wearer from harm at the cost "
"of magical power.";
break;
}
}
if (is_artefact( item ))
{
std::string rand_desc = _randart_descrip( item );
if (!rand_desc.empty())
{
description += "$$";
description += rand_desc;
}
if (!item_ident(item, ISFLAG_KNOW_PROPERTIES) && item_type_known(item))
description += "$This armour may have some hidden properties.";
}
else if (get_equip_race( item ) != ISFLAG_NO_RACE)
{
description += "$";
unsigned long race = get_equip_race(item);
if (race == ISFLAG_DWARVEN)
description += "$It is well-crafted and very durable.";
else if (race == ISFLAG_ELVEN)
{
description += "$It is well-crafted and unobstructive";
if (item.sub_type == ARM_CLOAK || item.sub_type == ARM_BOOTS)
description += ", and helps its wearer avoid being noticed";
description += ".";
}
description += "$It fits ";
description += (race == ISFLAG_DWARVEN) ? "dwarves" :
(race == ISFLAG_ELVEN) ? "elves"
: "orcs";
description += " well.";
}
if (verbose && get_armour_slot(item) == EQ_BODY_ARMOUR)
{
description += "$$";
if (is_light_armour(item))
{
description += "This is a light armour. Wearing it will "
"exercise Dodging and Stealth.";
}
else
{
description += "This is a heavy armour. Wearing it will "
"exercise Armour.";
}
}
if (!is_known_artefact(item))
{
const int max_ench = armour_max_enchant(item);
if (armour_is_hide(item))
{
description += "$Enchanting it will turn it into a suit of "
"magical armour.";
}
else if (item.plus < max_ench || !item_ident(item, ISFLAG_KNOW_PLUSES))
{
description += "$It can be maximally enchanted to +";
_append_value(description, max_ench, false);
description += ".";
}
else
description += "$It is maximally enchanted.";
}
return description;
}
static std::string _describe_jewellery( const item_def &item, bool verbose)
{
std::string description;
description.reserve(200);
if ((verbose || is_artefact( item ))
&& item_ident( item, ISFLAG_KNOW_PLUSES ))
{
if (item.plus != 0
|| item.sub_type == RING_SLAYING && item.plus2 != 0
|| is_artefact( item ))
{
switch (item.sub_type)
{
case RING_PROTECTION:
description += "$It affects your AC (";
_append_value( description, item.plus, true );
description += ").";
break;
case RING_EVASION:
description += "$It affects your evasion (";
_append_value( description, item.plus, true );
description += ").";
break;
case RING_STRENGTH:
description += "$It affects your strength (";
_append_value( description, item.plus, true );
description += ").";
break;
case RING_INTELLIGENCE:
description += "$It affects your intelligence (";
_append_value( description, item.plus, true );
description += ").";
break;
case RING_DEXTERITY:
description += "$It affects your dexterity (";
_append_value( description, item.plus, true );
description += ").";
break;
case RING_SLAYING:
if (item.plus != 0)
{
description += "$It affects your accuracy (";
_append_value( description, item.plus, true );
description += ").";
}
if (item.plus2 != 0)
{
description += "$It affects your damage-dealing abilities (";
_append_value( description, item.plus2, true );
description += ").";
}
if (item.plus == 0 && item.plus2 == 0)
{
description += "This buggy ring affects neither your "
"accuracy nor your damage-dealing "
"abilities.";
}
break;
default:
break;
}
}
}
if (is_artefact( item ))
{
std::string rand_desc = _randart_descrip( item );
if (!rand_desc.empty())
{
description += "$";
description += rand_desc;
}
if (!item_ident(item, ISFLAG_KNOW_PROPERTIES))
{
description += "$This ";
description += (jewellery_is_amulet(item) ? "amulet" : "ring");
description += " may have hidden properties.";
}
}
return (description);
}
static bool _compare_card_names(card_type a, card_type b)
{
return std::string(card_name(a)) < std::string(card_name(b));
}
static std::string _describe_deck( const item_def &item )
{
std::string description;
description.reserve(100);
description += "$";
const std::vector<card_type> drawn_cards = get_drawn_cards(item);
if (!drawn_cards.empty())
{
description += "Drawn card(s): ";
for (unsigned int i = 0; i < drawn_cards.size(); ++i)
{
if (i != 0)
description += ", ";
description += card_name(drawn_cards[i]);
}
description += "$";
}
const int num_cards = cards_in_deck(item);
int last_known_card = -1;
if (top_card_is_known(item))
{
description += "Next card(s): ";
for (int i = 0; i < num_cards; ++i)
{
unsigned char flags;
const card_type card = get_card_and_flags(item, -i-1, flags);
if (flags & CFLAG_MARKED)
{
if (i != 0)
description += ", ";
description += card_name(card);
last_known_card = i;
}
else
break;
}
description += "$";
}
std::vector<card_type> marked_cards;
for (int i = last_known_card + 1; i < num_cards; ++i)
{
unsigned char flags;
const card_type card = get_card_and_flags(item, -i-1, flags);
if (flags & CFLAG_MARKED)
marked_cards.push_back(card);
}
if (!marked_cards.empty())
{
std::sort(marked_cards.begin(), marked_cards.end(),
_compare_card_names);
description += "Marked card(s): ";
for (unsigned int i = 0; i < marked_cards.size(); ++i)
{
if (i != 0)
description += ", ";
description += card_name(marked_cards[i]);
}
description += "$";
}
std::vector<card_type> seen_cards;
for (int i = 0; i < num_cards; ++i)
{
unsigned char flags;
const card_type card = get_card_and_flags(item, -i-1, flags);
if ((flags & CFLAG_SEEN) && !(flags & CFLAG_MARKED))
seen_cards.push_back(card);
}
if (!seen_cards.empty())
{
std::sort(seen_cards.begin(), seen_cards.end(),
_compare_card_names);
description += "Seen card(s): ";
for (unsigned int i = 0; i < seen_cards.size(); ++i)
{
if (i != 0)
description += ", ";
description += card_name(seen_cards[i]);
}
description += "$";
}
return (description);
}
void append_spells(std::string &desc, const item_def &item)
{
if (!item.has_spells())
return;
desc += "$$Spells Type Level$";
for (int j = 0; j < SPELLBOOK_SIZE; ++j)
{
spell_type stype = which_spell_in_book(item, j);
if (stype == SPELL_NO_SPELL)
continue;
std::string name = (is_memorised(stype) ? "*" : "");
name += spell_title(stype);
desc += name;
for (unsigned int i = 0; i < 35 - name.length(); ++i)
desc += " ";
if (item.base_type == OBJ_STAVES)
desc += "Evocations";
else
desc += spell_schools_string(stype);
for (unsigned int i = 36; i < 65 - name.length(); ++i)
desc += " ";
char sval[3];
itoa( spell_difficulty( stype ), sval, 10 );
desc += sval;
desc += "$";
}
}
bool is_dumpable_artefact( const item_def &item, bool verbose)
{
bool ret = false;
if (is_known_artefact( item ))
{
ret = item_ident( item, ISFLAG_KNOW_PROPERTIES );
}
else if (verbose && item.base_type == OBJ_ARMOUR
&& item_type_known(item))
{
const int spec_ench = get_armour_ego_type( item );
ret = (spec_ench >= SPARM_RUNNING && spec_ench <= SPARM_PRESERVATION);
}
else if (verbose && item.base_type == OBJ_JEWELLERY
&& item_type_known(item))
{
ret = true;
}
return (ret);
}
std::string get_item_description( const item_def &item, bool verbose,
bool dump, bool noquote )
{
if (dump)
noquote = true;
std::ostringstream description;
if (!dump)
description << item.name(DESC_INVENTORY_EQUIP);
#if DEBUG_DIAGNOSTICS
if (!dump)
{
description << std::setfill('0');
description << "$$"
<< "base: " << static_cast<int>(item.base_type)
<< " sub: " << static_cast<int>(item.sub_type)
<< " plus: " << item.plus << " plus2: " << item.plus2
<< " special: " << item.special
<< "$"
<< "quant: " << item.quantity
<< " colour: " << static_cast<int>(item.colour)
<< " flags: " << std::hex << std::setw(8) << item.flags
<< std::dec << "$"
<< "x: " << item.pos.x << " y: " << item.pos.y
<< " link: " << item.link
<< " slot: " << item.slot
<< " ident_type: "
<< static_cast<int>(get_ident_type(item));
}
#endif
if (verbose || (item.base_type != OBJ_WEAPONS
&& item.base_type != OBJ_ARMOUR
&& item.base_type != OBJ_BOOKS))
{
description << "$$";
if (dump)
{
description << "["
<< item.name(DESC_DBNAME, true, false, false)
<< "]";
}
else if (is_unrandom_artefact(item)
&& (unrandart_descrip(0, item)[0] != '\0'
|| unrandart_descrip(1, item)[1] != '\0'))
{
const char *desc = unrandart_descrip( 0, item );
const char *desc_id = unrandart_descrip( 1, item );
if (item_type_known(item) && desc_id[0] != '\0')
description << desc_id << "$";
else if (desc[0] != '\0')
description << desc << "$";
}
else
{
std::string db_name = item.name(DESC_DBNAME, true, false, false);
std::string db_desc = getLongDescription(db_name);
if (!noquote && !is_known_artefact(item))
{
const unsigned int lineWidth = get_number_of_cols();
const int height = get_number_of_lines();
std::string quote = getQuoteString(db_name);
if (count_desc_lines(db_desc, lineWidth)
+ count_desc_lines(quote, lineWidth) <= height)
{
if (!db_desc.empty())
db_desc += "$";
db_desc += quote;
}
}
if (db_desc.empty())
{
if (item_type_known(item))
{
description << "[ERROR: no desc for item name '" << db_name
<< "']$";
}
else
{
description << article_a(item.name(DESC_CAP_A, true,
false, false), false);
description << ".$";
}
}
else
description << db_desc;
if (item.base_type == OBJ_WANDS
|| item.base_type == OBJ_MISSILES
|| item.base_type == OBJ_FOOD && item.sub_type == FOOD_CHUNK)
{
description.seekp(description.tellp() - (std::streamoff)2);
description << " ";
}
}
}
bool need_extra_line = true;
std::string desc;
switch (item.base_type)
{
case OBJ_WEAPONS:
desc = _describe_weapon( item, verbose );
if (desc.empty())
need_extra_line = false;
else
description << desc;
break;
case OBJ_ARMOUR:
desc = _describe_armour( item, verbose );
if (desc.empty())
need_extra_line = false;
else
description << desc;
break;
case OBJ_JEWELLERY:
desc = _describe_jewellery( item, verbose );
if (desc.empty())
need_extra_line = false;
else
description << desc;
break;
case OBJ_BOOKS:
if (!player_can_read_spellbook( item ))
{
description << "$This book is beyond your current level of "
"understanding.";
}
else if (!verbose
&& (Options.dump_book_spells || is_random_artefact(item)))
{
append_spells( desc, item );
if (desc.empty())
need_extra_line = false;
else
description << desc;
}
break;
case OBJ_MISSILES:
description << _describe_ammo( item );
break;
case OBJ_WANDS:
if (item_type_known(item))
{
const int max_charges = 3 * wand_charge_value(item.sub_type);
if (item.plus < max_charges
|| !item_ident(item, ISFLAG_KNOW_PLUSES))
{
description << "$It can have at most " << max_charges
<< " charges.";
}
else
description << "$It is fully charged.";
}
if (item_ident( item, ISFLAG_KNOW_PLUSES ) && item.plus == 0
|| item.plus2 == ZAPCOUNT_EMPTY)
{
description << "$Unfortunately, it has no charges left.";
}
description << "$";
break;
case OBJ_CORPSES:
if (item.sub_type == CORPSE_SKELETON)
break;
case OBJ_FOOD:
if (item.base_type == OBJ_CORPSES || item.sub_type == FOOD_CHUNK)
{
if (food_is_rotten(item))
{
if (player_mutation_level(MUT_SAPROVOROUS) == 3)
description << "It looks nice and ripe.";
else
{
description << "In fact, it is rotting away before your "
"eyes.";
if (!you.is_undead
&& !player_mutation_level(MUT_SAPROVOROUS))
{
description << " Eating it is completely out of the "
"question!";
}
}
}
else if (player_mutation_level(MUT_SAPROVOROUS) < 3)
description << "It looks rather unpleasant.";
switch (mons_corpse_effect(item.plus))
{
case CE_POISONOUS:
description << "$$This meat is poisonous.";
break;
case CE_MUTAGEN_RANDOM:
if (you.species != SP_GHOUL)
{
description << "$$Eating this meat will cause random "
"mutations.";
}
break;
case CE_HCL:
if (you.species != SP_GHOUL)
description << "$$Eating this meat will cause rotting.";
break;
case CE_CONTAMINATED:
if (player_mutation_level(MUT_SAPROVOROUS) < 3)
{
description << "$$Meat like this may occasionally cause "
"sickness.";
}
break;
default:
break;
}
if (god_hates_cannibalism(you.religion)
&& is_player_same_species(item.plus)
|| you.religion == GOD_ZIN
&& mons_class_intel(item.plus) >= I_NORMAL)
{
description << "$$" << god_name(you.religion) << " disapproves "
"of eating such meat.";
}
description << "$";
}
break;
case OBJ_STAVES:
if (item_is_rod( item ))
{
if (verbose)
{
description <<
"$It uses its own mana reservoir for casting spells, and "
"recharges automatically by channeling mana from its "
"wielder.";
const int max_charges = MAX_ROD_CHARGE;
if (item_ident(item, ISFLAG_KNOW_PLUSES))
{
const int num_charges = item.plus2 / ROD_CHARGE_MULT;
if (max_charges > num_charges)
{
description << "$It can currently hold " << num_charges
<< " charges. It can be magically recharged "
<< "to contain up to " << max_charges
<< " charges.";
}
else
description << "$It is fully charged.";
}
else
{
description << "$It can have at most " << max_charges
<< " charges.";
}
}
else if (Options.dump_book_spells)
{
append_spells( desc, item );
if (desc.empty())
need_extra_line = false;
else
description << desc;
}
}
else
{
description <<
"$Damage rating: 7 Accuracy rating: +6 "
"Attack delay: 120%";
description << "$$It falls into the 'Staves' category.";
}
break;
case OBJ_MISCELLANY:
if (is_deck(item))
description << _describe_deck( item );
break;
case OBJ_POTIONS:
#ifdef DEBUG_BLOOD_POTIONS
if (!dump && is_blood_potion(item))
{
item_def stack = static_cast<item_def>(item);
CrawlHashTable &props = stack.props;
ASSERT(props.exists("timer"));
CrawlVector &timer = props["timer"].get_vector();
ASSERT(!timer.empty());
description << "$Quantity: " << stack.quantity
<< " Timer size: " << (int) timer.size();
description << "$Timers:$";
for (int i = 0; i < timer.size(); ++i)
description << (timer[i].get_long()) << " ";
}
#endif
break;
case OBJ_SCROLLS:
case OBJ_ORBS:
case OBJ_GOLD:
break;
default:
DEBUGSTR("Bad item class");
description << "$This item should not exist. Mayday! Mayday!";
}
if (is_unrandom_artefact( item )
&& strlen(unrandart_descrip(2, item)) != 0)
{
description << "$$";
description << unrandart_descrip(2, item);
}
if (!verbose && item_known_cursed( item ))
description << "$It has a curse placed upon it.";
else
{
if (verbose)
{
if (need_extra_line)
description << "$";
description << "$It";
if (item_known_cursed( item ))
description << " has a curse placed upon it, and it";
const int mass = item_mass( item );
description << " weighs around " << (mass / 10)
<< "." << (mass % 10)
<< " aum. ";
if (is_dumpable_artefact(item, false))
{
if (item.base_type == OBJ_ARMOUR
|| item.base_type == OBJ_WEAPONS)
{
description << "$$This ancient artefact cannot be changed "
"by magic or mundane means.";
}
else
description << "$$It is an ancient artefact.";
}
}
}
if (good_god_hates_item_handling(item))
{
description << "$$" << god_name(you.religion) << " opposes the use of "
<< "such an evil item.";
}
else if (god_hates_item_handling(item))
{
description << "$$" << god_name(you.religion) << " disapproves of the "
<< "use of such an item.";
}
return description.str();
}
static std::string _get_feature_description_wide(int feat)
{
return std::string();
}
void get_feature_desc(const coord_def &pos, describe_info &inf)
{
const dungeon_feature_type feat = grd(pos);
std::string desc = feature_description(pos, false, DESC_CAP_A, false);
std::string db_name = grd(pos) == DNGN_ENTER_SHOP ? "A shop" : desc;
std::string long_desc = getLongDescription(db_name);
inf.body << desc << ".$$";
if (long_desc.empty())
{
db_name = feature_description(pos, false, DESC_CAP_A, false, true);
long_desc = getLongDescription(db_name);
}
bool custom_desc = false;
const std::string marker_desc =
env.markers.property_at(pos, MAT_ANY, "feature_description_long");
if (!marker_desc.empty())
{
long_desc = marker_desc;
custom_desc = true;
}
if (feat == DNGN_ENTER_PORTAL_VAULT && !custom_desc)
{
long_desc = "UNDESCRIBED PORTAL VAULT ENTRANCE.";
custom_desc = true;
}
const CrawlHashTable &props = env.properties;
if (!custom_desc && props.exists(LONG_DESC_KEY))
{
const CrawlHashTable &desc_table = props[LONG_DESC_KEY].get_table();
std::string key = raw_feature_description(feat);
if (!desc_table.exists(key))
key = raw_feature_description(feat, NUM_TRAPS, true);
if (desc_table.exists(key))
{
long_desc = desc_table[key].get_string();
custom_desc = true;
}
std::string quote = getQuoteString(key);
if (!quote.empty())
db_name = key;
}
inf.body << long_desc;
if (!custom_desc)
inf.body << _get_feature_description_wide(grd(pos));
inf.quote = getQuoteString(db_name);
}
void describe_feature_wide(const coord_def& pos)
{
describe_info inf;
get_feature_desc(pos, inf);
print_description(inf);
mouse_control mc(MOUSE_MODE_MORE);
if (Options.tutorial_left)
tutorial_describe_pos(pos.x, pos.y);
if (getch() == 0)
getch();
}
void set_feature_desc_long(const std::string &raw_name,
const std::string &desc)
{
ASSERT(!raw_name.empty());
CrawlHashTable &props = env.properties;
if (!props.exists(LONG_DESC_KEY))
props[LONG_DESC_KEY].new_table(SV_STR);
CrawlHashTable &desc_table = props[LONG_DESC_KEY].get_table();
if (desc.empty())
desc_table.erase(raw_name);
else
desc_table[raw_name] = desc;
}
void get_item_desc(const item_def &item, describe_info &inf, bool terse)
{
const bool verbose = !terse || !item.has_spells();
inf.body << get_item_description(item, verbose, false,
Options.tutorial_left);
}
static bool _show_item_description(const item_def &item)
{
const unsigned int lineWidth = get_number_of_cols() - 1;
const int height = get_number_of_lines();
std::string desc =
get_item_description(item, true, false, Options.tutorial_left);
int num_lines = count_desc_lines(desc, lineWidth) + 1;
if (height - num_lines <= 2)
desc = get_item_description(item, 1, false, true);
print_description(desc);
if (Options.tutorial_left)
tutorial_describe_item(item);
if (item.has_spells())
{
if (item.base_type == OBJ_BOOKS && !player_can_read_spellbook( item ))
return (false);
formatted_string fs;
item_def dup = item;
spellbook_contents( dup, item.base_type == OBJ_BOOKS ? RBOOK_READ_SPELL
: RBOOK_USE_STAFF,
&fs );
fs.display(2, -2);
return (true);
}
return (false);
}
static bool _describe_spells(const item_def &item)
{
int c = getch();
if (c < 'a' || c > 'h') {
mesclr( true );
return (false);
}
const int spell_index = letter_to_index(c);
spell_type nthing =
which_spell_in_book(item, spell_index);
if (nthing == SPELL_NO_SPELL)
return (false);
describe_spell( nthing, &item );
return (true);
}
void describe_item( item_def &item, bool allow_inscribe, bool shopping )
{
if (!is_valid_item(item))
return;
while (true)
{
if (you.turn_is_over && !shopping)
return;
const bool spells_shown = _show_item_description(item);
if (spells_shown)
{
cgotoxy(1, wherey());
textcolor(LIGHTGREY);
if (item.base_type == OBJ_BOOKS && in_inventory(item))
{
cprintf("Select a spell to read its description or to "
"memorise it.");
}
else
cprintf("Select a spell to read its description.");
if (_describe_spells(item))
continue;
return;
}
break;
}
if (allow_inscribe && wherey() <= get_number_of_lines() - 3)
{
cgotoxy(1, wherey() + 2);
inscribe_item(item, false);
}
else if (getch() == 0)
getch();
}
void inscribe_item(item_def &item, bool proper_prompt)
{
if (proper_prompt)
mpr(item.name(DESC_INVENTORY).c_str(), MSGCH_EQUIPMENT);
const bool is_inscribed = !item.inscription.empty();
std::string ainscrip;
bool need_autoinscribe = false;
if (is_artefact(item))
{
ainscrip = artefact_auto_inscription(item);
if (!ainscrip.empty()
&& (!is_inscribed
|| item.inscription.find(ainscrip) == std::string::npos))
{
need_autoinscribe = true;
}
}
std::string prompt;
int keyin;
bool did_prompt = false;
if (!proper_prompt || need_autoinscribe || is_inscribed)
{
if (!is_inscribed)
prompt = "Press (i) to inscribe";
else
prompt = "Press (i) to add to or (r) to replace the inscription";
if (need_autoinscribe || is_inscribed)
{
if (!need_autoinscribe || !is_inscribed)
prompt += ", or ";
else
prompt += ", ";
if (need_autoinscribe)
{
prompt += "(a) to autoinscribe";
if (is_inscribed)
prompt += ", or ";
}
if (is_inscribed)
prompt += "(c) to clear it";
}
prompt += ".";
if (proper_prompt)
mpr(prompt.c_str(), MSGCH_PROMPT);
else
{
prompt = "<cyan>" + prompt + "</cyan>";
formatted_string::parse_string(prompt).display();
if (Options.tutorial_left && wherey() <= get_number_of_lines() - 5)
tutorial_inscription_info(need_autoinscribe, prompt);
}
did_prompt = true;
}
keyin = (did_prompt ? tolower(c_getch()) : 'i');
switch (keyin)
{
case 'c':
item.inscription.clear();
break;
case 'a':
if (need_autoinscribe)
{
add_autoinscription(item, ainscrip);
break;
}
case 'i':
case 'r':
{
if (!is_inscribed)
prompt = "Inscribe with what? ";
else if (keyin == 'i')
prompt = "Add what to inscription? ";
else
prompt = "Replace inscription with what? ";
if (proper_prompt)
mpr(prompt.c_str(), MSGCH_PROMPT);
else
{
prompt = EOL "<cyan>" + prompt + "</cyan>";
formatted_string::parse_string(prompt).display();
}
char buf[79];
if (!cancelable_get_line(buf, sizeof buf))
{
for (int i = strlen(buf) - 1; i >= 0; --i)
{
if (isspace( buf[i] ))
buf[i] = 0;
else
break;
}
if (strlen(buf) > 0)
{
if (is_inscribed && keyin == 'r')
item.inscription = std::string(buf);
else
{
if (is_inscribed)
item.inscription += ", ";
item.inscription += std::string(buf);
}
}
}
else if (proper_prompt)
{
canned_msg(MSG_OK);
return;
}
break;
}
default:
if (proper_prompt)
canned_msg(MSG_OK);
return;
}
if (proper_prompt)
{
mpr(item.name(DESC_INVENTORY).c_str(), MSGCH_EQUIPMENT);
you.wield_change = true;
}
}
bool _get_spell_description(const spell_type spell, std::string &description,
const item_def* item = NULL)
{
description.reserve(500);
description = spell_title( spell );
description += "$$";
const std::string long_descrip = getLongDescription(spell_title(spell));
if (!long_descrip.empty())
description += long_descrip;
else
{
description += "This spell has no description. "
"Casting it may therefore be unwise. "
#ifdef DEBUG
"Instead, go fix it. ";
#else
"Please file a bug report.";
#endif
}
if (you_cannot_memorise(spell))
{
description += "$$";
description += "You cannot memorise or cast this spell because you "
"are a ";
description += lowercase_string(species_name(you.species, 0));
description += ".";
}
else if (item && item->base_type == OBJ_BOOKS && in_inventory(*item))
{
description += "$$";
description += "(M)emorise this spell.";
return (true);
}
#ifdef USE_TILE
else
{
const std::string schools = spell_schools_string(spell);
snprintf(info, INFO_SIZE,
"$Level: %d School%s: %s (%s)",
spell_difficulty(spell),
schools.find("/") != std::string::npos ? "s" : "",
schools.c_str(),
failure_rate_to_string(spell_fail(spell)));
description += info;
description += "$$Power : ";
description += spell_power_string(spell);
description += "$Range : ";
description += spell_range_string(spell);
description += "$Hunger: ";
description += spell_hunger_string(spell);
}
#endif
return (false);
}
void get_spell_desc(const spell_type spell, describe_info &inf)
{
std::string desc;
_get_spell_description(spell, desc);
inf.body << desc;
}
void describe_spell(spell_type spelled, const item_def* item)
{
std::string desc;
bool can_mem = _get_spell_description(spelled, desc, item);
print_description(desc);
mouse_control mc(MOUSE_MODE_MORE);
char ch;
if ((ch = getch()) == 0)
ch = getch();
if (can_mem && toupper(ch) == 'M')
{
if (!learn_spell(spelled, item->sub_type, false) || !you.turn_is_over)
more();
redraw_screen();
}
}
static std::string _describe_draconian_role(const monsters *mon)
{
switch (mon->type)
{
case MONS_DRACONIAN_SHIFTER:
return "It darts around disconcertingly without taking a step.";
case MONS_DRACONIAN_SCORCHER:
return "Its scales are sooty black from years of magical pyrotechnics.";
case MONS_DRACONIAN_ZEALOT:
return "In its gaze you see all the malefic power of its "
"terrible god.";
case MONS_DRACONIAN_ANNIHILATOR:
return "Crackling balls of pure energy hum and spark up and down its "
"scaled fists and arms.";
case MONS_DRACONIAN_CALLER:
return "It looks especially reptilian, and eager for company.";
case MONS_DRACONIAN_MONK:
return "It looks unnaturally strong and dangerous with its fists.";
case MONS_DRACONIAN_KNIGHT:
return "It wields a deadly weapon with menacing efficiency.";
default:
return ("");
}
}
static std::string _describe_draconian_colour(int species)
{
switch (species)
{
case MONS_BLACK_DRACONIAN:
return "Sparks crackle and flare out of its mouth and nostrils.";
case MONS_MOTTLED_DRACONIAN:
return "Liquid flames drip from its mouth.";
case MONS_YELLOW_DRACONIAN:
return "Acid fumes swirl around it.";
case MONS_GREEN_DRACONIAN:
return "Venom steams and drips from its jaws.";
case MONS_PURPLE_DRACONIAN:
return "Its outline shimmers with wild energies.";
case MONS_RED_DRACONIAN:
return "Smoke pours from its nostrils.";
case MONS_WHITE_DRACONIAN:
return "Frost pours from its nostrils.";
case MONS_PALE_DRACONIAN:
return "It is cloaked in a pall of superheated steam.";
}
return ("");
}
static std::string _describe_draconian(const monsters *mon)
{
std::string description;
const int subsp = draco_subspecies( mon );
if (subsp == MONS_DRACONIAN)
description += "A ";
else
description += "A muscular ";
switch (subsp)
{
case MONS_DRACONIAN: description += "brown-"; break;
case MONS_BLACK_DRACONIAN: description += "black-"; break;
case MONS_MOTTLED_DRACONIAN: description += "mottled-"; break;
case MONS_YELLOW_DRACONIAN: description += "yellow-"; break;
case MONS_GREEN_DRACONIAN: description += "green-"; break;
case MONS_PURPLE_DRACONIAN: description += "purple-"; break;
case MONS_RED_DRACONIAN: description += "red-"; break;
case MONS_WHITE_DRACONIAN: description += "white-"; break;
case MONS_PALE_DRACONIAN: description += "pale-"; break;
default:
break;
}
description += "scaled humanoid with wings.";
if (subsp != MONS_DRACONIAN)
{
const std::string drac_col = _describe_draconian_colour(subsp);
if (!drac_col.empty())
description += " " + drac_col;
}
if (subsp != mon->type)
{
const std::string drac_role = _describe_draconian_role(mon);
if (!drac_role.empty())
description += " " + drac_role;
}
return (description);
}
static const char* _get_resist_name(mon_resist_flags res_type)
{
switch (res_type)
{
case MR_RES_ELEC:
return "electricity";
case MR_RES_POISON:
return "poison";
case MR_RES_FIRE:
return "fire";
case MR_RES_STEAM:
return "steam";
case MR_RES_COLD:
return "cold";
case MR_RES_ACID:
return "acid";
default:
return "buggy resistance";
}
}
static std::string _monster_stat_description(const monsters& mon)
{
std::ostringstream result;
const mon_resist_def resist =
(mons_is_ghost_demon(mon.type)
&& mon.type != MONS_UGLY_THING
&& mon.type != MONS_VERY_UGLY_THING)
? get_mons_class_resists(mon.type) : get_mons_resists(&mon);
const mon_resist_flags resists[] = {
MR_RES_ELEC, MR_RES_POISON, MR_RES_FIRE,
MR_RES_STEAM, MR_RES_COLD, MR_RES_ACID
};
std::vector<std::string> extreme_resists;
std::vector<std::string> high_resists;
std::vector<std::string> base_resists;
std::vector<std::string> suscept;
for (unsigned int i = 0; i < ARRAYSZ(resists); ++i)
{
int level = resist.get_resist_level(resists[i]);
if (resists[i] == MR_RES_FIRE && resist.hellfire)
level = 3;
if (level != 0)
{
const char* attackname = _get_resist_name(resists[i]);
level = std::max(level, -1);
level = std::min(level, 3);
switch (level)
{
case -1:
suscept.push_back(attackname);
break;
case 1:
base_resists.push_back(attackname);
break;
case 2:
high_resists.push_back(attackname);
break;
case 3:
extreme_resists.push_back(attackname);
break;
}
}
}
std::vector<std::string> resist_descriptions;
if (!extreme_resists.empty())
{
const std::string tmp = "extremely resistant to "
+ comma_separated_line(extreme_resists.begin(),
extreme_resists.end());
resist_descriptions.push_back(tmp);
}
if (!high_resists.empty())
{
const std::string tmp = "very resistant to "
+ comma_separated_line(high_resists.begin(), high_resists.end());
resist_descriptions.push_back(tmp);
}
if (!base_resists.empty())
{
const std::string tmp = "resistant to "
+ comma_separated_line(base_resists.begin(), base_resists.end());
resist_descriptions.push_back(tmp);
}
const char* pronoun = mons_pronoun(static_cast<monster_type>(mon.type),
PRONOUN_CAP, true);
if (!resist_descriptions.empty())
{
result << pronoun << " is "
<< comma_separated_line(resist_descriptions.begin(),
resist_descriptions.end(),
"; and ", "; ")
<< ".$";
}
if (!suscept.empty())
{
result << pronoun << " is susceptible to "
<< comma_separated_line(suscept.begin(), suscept.end())
<< ".$";
}
if (mons_immune_magic(&mon))
result << pronoun << " is immune to magical enchantments.$";
if (mons_class_flag(mon.type, M_STATIONARY))
result << pronoun << " cannot move.$";
if (!mons_is_ghost_demon(mon.type))
{
if (mons_class_flag(mon.type, M_SEE_INVIS))
result << pronoun << " can see invisible.$";
else if (mons_class_flag(mon.type, M_SENSE_INVIS))
result << pronoun << " can sense the presence of invisible creatures.$";
const int speed = mons_base_speed(&mon);
if (speed != 10 && speed != 0)
{
result << pronoun << " is ";
if (speed < 7)
result << "very slow";
else if (speed < 10)
result << "slow";
else if (speed > 20)
result << "extremely fast";
else if (speed > 15)
result << "very fast";
else if (speed > 10)
result << "fast";
result << ".$";
}
}
const flight_type fly = mons_flies(&mon, false);
if (fly != FL_NONE)
{
result << pronoun << " can "
<< (fly == FL_FLY ? "fly" : "levitate") << ".$";
}
if (!mons_can_regenerate(&mon))
result << pronoun << " cannot regenerate.$";
else if (monster_descriptor(mon.type, MDSC_REGENERATES))
result << pronoun << " regenerates quickly.$";
return (result.str());
}
void get_monster_db_desc(const monsters& mons, describe_info &inf,
bool force_seen)
{
if (!force_seen && mons_is_unknown_mimic(&mons))
{
item_def item;
get_mimic_item(&mons, item);
get_item_desc(item, inf);
return;
}
if (inf.title.empty())
inf.title = mons.full_name(DESC_CAP_A, true);
std::string db_name = mons.base_name(DESC_DBNAME, force_seen);
if (mons_is_mimic(mons.type) && mons.type != MONS_GOLD_MIMIC)
{
db_name = "mimic";
if (inf.title.empty())
inf.title = "A mimic";
}
if (mons.type != MONS_PLAYER_GHOST)
inf.body << getLongDescription(db_name);
inf.quote = getQuoteString(db_name);
std::string symbol;
symbol += get_monster_data(mons.type)->showchar;
if (isupper(symbol[0]))
symbol = "cap-" + symbol;
std::string symbol_prefix = "__";
symbol_prefix += symbol;
symbol_prefix += "_prefix";
inf.prefix = getLongDescription(symbol_prefix);
std::string quote2 = getQuoteString(symbol_prefix);
if (!inf.quote.empty() && !quote2.empty())
inf.quote += "$";
inf.quote += quote2;
switch (mons.type)
{
case MONS_ROTTING_DEVIL:
if (player_can_smell())
{
if (player_mutation_level(MUT_SAPROVOROUS) == 3)
inf.body << "$It smells great!$";
else
inf.body << "$It stinks.$";
}
break;
case MONS_SWAMP_DRAKE:
if (player_can_smell())
inf.body << "$It smells horrible.$";
break;
case MONS_NAGA:
case MONS_NAGA_MAGE:
case MONS_NAGA_WARRIOR:
case MONS_GUARDIAN_NAGA:
case MONS_GREATER_NAGA:
if (you.species == SP_NAGA)
inf.body << "$It is particularly attractive.$";
else
inf.body << "$It is strange and repulsive.$";
break;
case MONS_VAMPIRE:
case MONS_VAMPIRE_KNIGHT:
case MONS_VAMPIRE_MAGE:
if (you.is_undead == US_ALIVE && !mons_wont_attack(&mons))
inf.body << "$It wants to drink your blood!$";
break;
case MONS_REAPER:
if (you.is_undead == US_ALIVE && !mons_wont_attack(&mons))
inf.body << "$It has come for your soul!$";
break;
case MONS_ELF:
inf.body << "$This one is remarkably plain looking.$";
break;
case MONS_DRACONIAN:
case MONS_RED_DRACONIAN:
case MONS_WHITE_DRACONIAN:
case MONS_GREEN_DRACONIAN:
case MONS_PALE_DRACONIAN:
case MONS_MOTTLED_DRACONIAN:
case MONS_BLACK_DRACONIAN:
case MONS_YELLOW_DRACONIAN:
case MONS_PURPLE_DRACONIAN:
case MONS_DRACONIAN_SHIFTER:
case MONS_DRACONIAN_SCORCHER:
case MONS_DRACONIAN_ZEALOT:
case MONS_DRACONIAN_ANNIHILATOR:
case MONS_DRACONIAN_CALLER:
case MONS_DRACONIAN_MONK:
case MONS_DRACONIAN_KNIGHT:
{
inf.body << "$" << _describe_draconian( &mons );
break;
}
case MONS_PLAYER_GHOST:
inf.body << "The apparition of " << get_ghost_description(mons) << ".$";
break;
case MONS_PANDEMONIUM_DEMON:
inf.body << _describe_demon(mons) << "$";
break;
case MONS_URUG:
if (player_can_smell())
inf.body << "$He smells terrible.$";
break;
case MONS_PROGRAM_BUG:
inf.body << "If this monster is a \"program bug\", then it's "
"recommended that you save your game and reload. Please report "
"monsters who masquerade as program bugs or run around the "
"dungeon without a proper description to the authorities.$";
break;
default:
break;
}
std::string result = _monster_stat_description(mons);
if (!result.empty())
inf.body << "$" << result;
if (!mons_can_use_stairs(&mons))
{
inf.body << "$" << mons_pronoun(static_cast<monster_type>(mons.type),
PRONOUN_CAP, true)
<< " is incapable of using stairs.$";
}
if (mons_is_summoned(&mons) && mons.type != MONS_RAKSHASA_FAKE)
{
inf.body << "$" << "This monster has been summoned, and is thus only "
"temporary. Killing it yields no experience, nutrition "
"or items.$";
}
std::string symbol_suffix = "__";
symbol_suffix += symbol;
symbol_suffix += "_suffix";
inf.suffix += getLongDescription(symbol_suffix);
inf.suffix += getLongDescription(symbol_suffix + "_examine");
quote2 = getQuoteString(symbol_suffix);
if (!inf.quote.empty() && !quote2.empty())
inf.quote += "$";
inf.quote += quote2;
#if DEBUG_DIAGNOSTICS
if (mons_class_flag( mons.type, M_SPELLCASTER ))
{
const monster_spells &hspell_pass = mons.spells;
bool found_spell = false;
for (int i = 0; i < NUM_MONSTER_SPELL_SLOTS; ++i)
{
if (hspell_pass[i] != SPELL_NO_SPELL)
{
if (!found_spell)
{
inf.body << "$$Monster Spells:$";
found_spell = true;
}
inf.body << " " << i << ": "
<< spell_title(hspell_pass[i])
<< " (" << static_cast<int>(hspell_pass[i])
<< ")$";
}
}
}
bool has_item = false;
for (int i = 0; i < NUM_MONSTER_SLOTS; ++i)
{
if (mons.inv[i] != NON_ITEM)
{
if (!has_item)
{
inf.body << "$Monster Inventory:$";
has_item = true;
}
inf.body << " " << i << ") "
<< mitm[mons.inv[i]].name(DESC_NOCAP_A, false, true);
}
}
#endif
}
void describe_monsters(const monsters& mons, bool force_seen)
{
describe_info inf;
get_monster_db_desc(mons, inf, force_seen);
print_description(inf);
mouse_control mc(MOUSE_MODE_MORE);
if (Options.tutorial_left)
tutorial_describe_monster(&mons);
if (getch() == 0)
getch();
}
std::string get_ghost_description(const monsters &mons, bool concise)
{
ASSERT(mons.ghost.get());
std::ostringstream gstr;
const ghost_demon &ghost = *(mons.ghost);
const species_type gspecies = ghost.species;
const int dex = 10;
int str = 5;
switch (gspecies)
{
case SP_MOUNTAIN_DWARF:
case SP_DEEP_DWARF:
case SP_TROLL:
case SP_OGRE:
case SP_MINOTAUR:
case SP_HILL_ORC:
case SP_CENTAUR:
case SP_NAGA:
case SP_MUMMY:
case SP_GHOUL:
str += 10;
break;
case SP_HUMAN:
case SP_DEMIGOD:
case SP_DEMONSPAWN:
str += 5;
break;
default:
break;
}
gstr << ghost.name << " the "
<< skill_title(ghost.best_skill,
(unsigned char)ghost.best_skill_level,
gspecies,
str, dex, ghost.religion)
<< ", a"
<< ((ghost.xl < 4) ? " weakling" :
(ghost.xl < 7) ? "n average" :
(ghost.xl < 11) ? "n experienced" :
(ghost.xl < 16) ? " powerful" :
(ghost.xl < 22) ? " mighty" :
(ghost.xl < 26) ? " great" :
(ghost.xl < 27) ? "n awesomely powerful"
: " legendary")
<< " ";
if (concise)
{
gstr << get_species_abbrev(gspecies)
<< get_class_abbrev(ghost.job);
}
else
{
gstr << species_name(gspecies,
ghost.xl)
<< " "
<< get_class_name(ghost.job);
}
if (ghost.religion != GOD_NO_GOD)
{
gstr << " of "
<< god_name(ghost.religion);
}
return (gstr.str());
}
extern ability_type god_abilities[MAX_NUM_GODS][MAX_GOD_ABILITIES];
static bool _print_final_god_abil_desc(int god, const std::string &final_msg,
const ability_type abil)
{
if (final_msg.empty())
return (false);
std::ostringstream buf;
buf << final_msg;
const std::string cost = "(" + make_cost_description(abil) + ")";
if (cost != "(None)")
{
const int spacesleft = 79 - buf.str().length();
buf << std::setw(spacesleft) << cost;
}
cprintf("%s\n", buf.str().c_str());
return (true);
}
static bool _print_god_abil_desc(int god, int numpower)
{
const char* pmsg = god_gain_power_messages[god][numpower];
if (!pmsg[0])
return (false);
std::string buf;
if (isupper(pmsg[0]))
buf = pmsg; else
{
buf = "You can ";
buf += pmsg;
buf += ".";
}
const ability_type abil = god_abilities[god][numpower];
_print_final_god_abil_desc(god, buf, abil);
return (true);
}
static std::string _describe_favour_generic(god_type which_god)
{
const std::string godname = god_name(which_god);
return (you.piety > 130) ? "A prized avatar of " + godname + ".":
(you.piety > 100) ? "A shining star in the eyes of " + godname + "." :
(you.piety > 70) ? "A rising star in the eyes of " + godname + "." :
(you.piety > 40) ? godname + " is most pleased with you." :
(you.piety > 20) ? godname + " has noted your presence." :
(you.piety > 5) ? godname + " is noncommittal."
: "You are beneath notice.";
}
std::string describe_favour(god_type which_god)
{
if (player_under_penance())
{
const int penance = you.penance[which_god];
return (penance >= 50) ? "Godly wrath is upon you!" :
(penance >= 20) ? "You've transgressed heavily! Be penitent!" :
(penance >= 5 ) ? "You are under penance."
: "You should show more discipline.";
}
return (which_god == GOD_XOM) ? describe_xom_favour(true)
: _describe_favour_generic(which_god);
}
static std::string _religion_help(god_type god)
{
std::string result = "";
switch (god)
{
case GOD_ZIN:
result += "You can pray at an altar to donate your money.";
if (!player_under_penance() && you.piety > 160
&& !you.num_gifts[god])
{
if (!result.empty())
result += " ";
result += "You can have all your mutations cured.";
}
break;
case GOD_SHINING_ONE:
result += "You can pray at an altar to sacrifice evil items.";
if (you.haloed())
{
int halo_size = halo_radius();
result += "You radiate a ";
if (halo_size > 6)
result += "large ";
else if (halo_size > 3)
result += "";
else
result += "small ";
result += "righteous aura, and all beings within it are "
"easier to hit.";
}
if (!player_under_penance() && you.piety > 160
&& !you.num_gifts[god])
{
if (!result.empty())
result += " ";
result += "You can pray at an altar to have your weapon "
"blessed, especially a long blade.";
}
break;
case GOD_LUGONU:
if (!player_under_penance() && you.piety > 160
&& !you.num_gifts[god])
{
result += "You can pray at an altar to have your weapon "
"blessed.";
}
break;
case GOD_BEOGH:
result += "You can pray to sacrifice all orcish remains on your "
"square. Inscribe orcish remains with !p, !* or =p to avoid "
"sacrificing them accidentally.";
break;
case GOD_NEMELEX_XOBEH:
result += "You can pray to sacrifice all items on your square. "
"Inscribe items with !p, !* or =p to avoid sacrificing "
"them accidentally.";
break;
case GOD_VEHUMET:
if (you.piety >= piety_breakpoint(1))
{
result += god_name(god) + " assists you in casting "
"Conjurations and Summonings.";
}
break;
default:
break;
}
if (god_likes_fresh_corpses(god))
{
if (!result.empty())
result += " ";
result += "You can pray to sacrifice all fresh corpses on your "
"square. Inscribe fresh corpses with !p, !* or =p to avoid "
"sacrificing them accidentally.";
}
return result;
}
const char *divine_title[NUM_GODS][8] =
{
{"Buglet", "Firebug", "Bogeybug", "Bugger",
"Bugbear", "Bugged One", "Giant Bug", "Lord of the Bugs"},
{"Sinner", "Anchorite", "Apologist", "Pious",
"Devout", "Orthodox", "Immaculate", "Bringer of Law"},
{"Sinner", "Acolyte", "Righteous", "Unflinching",
"Holy Warrior", "Exorcist", "Demon Slayer", "Bringer of Light"},
{"Sinner", "Purveyor of Pain", "Death's Scholar", "Merchant of Misery",
"Death's Artisan", "Dealer of Despair", "Black Sun", "Lord of Darkness"},
{"Sinner", "Zealot", "Exhumer", "Fey %s",
"Soul Tainter", "Sculptor of Flesh", "Harbinger of Death", "Grim Reaper"},
{"Toy", "Toy", "Toy", "Toy",
"Toy", "Toy", "Toy", "Toy"},
{"Meek", "Sorcerer's Apprentice", "Scholar of Destruction", "Caster of Ruination",
"Battle Magician", "Warlock", "Annihilator", "Luminary of Lethal Lore"},
{"Coward", "Struggler", "Combatant", "Warrior",
"Knight", "Warmonger", "Commander", "Victor of a Thousand Battles"},
{"Orderly", "Spawn of Chaos", "Disciple of Annihilation", "Fanfare of Bloodshed",
"Fiendish", "Demolition %s", "Pandemonic", "Champion of Chaos"},
{"Ignorant", "Disciple", "Student", "Adept",
"Scribe", "Scholar", "Sage", "Genius of the Arcane"},
{"Faithless", "Troglodyte", "Angry Troglodyte", "Frenzied",
"%s of Prey", "Rampant", "Wild %s", "Bane of Scribes"},
{"Unlucky %s", "Pannier", "Jester", "Fortune-Teller",
"Soothsayer", "Magus", "Cardsharp", "Hand of Fortune"},
{"Sinner", "Comforter", "Caregiver", "Practitioner",
"Pacifier", "Purifying %s", "Faith Healer", "Bringer of Life"},
{"Faithless", "Abyss-Baptised", "Unweaver", "Distorting %s",
"Agent of Entropy", "Schismatic", "Envoy of Void", "Corrupter of Planes"},
{"Apostate", "Messenger", "Proselytiser", "Priest",
"Missionary", "Evangelist", "Apostle", "Messiah"},
{"Scum", "Jelly", "Squelcher", "Dissolver",
"Putrid Slime", "Consuming %s", "Archjelly", "Royal Jelly"},
{"Walking Fertiliser", "Green %s", "Photosynthesist", "Planter",
"Nimbus", "Sporadic Warrior", "Green Death", "Force of Nature"},
{"Hurried", "Slacker", "Procrastinator", "Laid-Back",
"Ticktocktomancer", "Time Lord", "The End All And Be All", "Alpha Omega"}
};
static int _piety_level()
{
return ((you.piety > 160) ? 7 :
(you.piety >= 120) ? 6 :
(you.piety >= 100) ? 5 :
(you.piety >= 75) ? 4 :
(you.piety >= 50) ? 3 :
(you.piety >= 30) ? 2 :
(you.piety > 5) ? 1
: 0 );
}
std::string god_title(god_type which_god)
{
std::string title;
if (you.penance[which_god])
title = divine_title[which_god][0];
else
title = divine_title[which_god][_piety_level()];
title = replace_all(title, "%s",
species_name(you.species, 1, true, false));
return (title);
}
static void _detailed_god_description(god_type which_god)
{
clrscr();
const int width = std::min(80, get_number_of_cols());
std::string godname = god_name(which_god, true);
int len = get_number_of_cols() - godname.length();
textcolor(god_colour(which_god));
cprintf("%s%s" EOL, std::string(len / 2, ' ').c_str(), godname.c_str());
textcolor(LIGHTGREY);
cprintf(EOL);
std::string broken;
if (which_god != GOD_NEMELEX_XOBEH)
{
broken = get_god_powers(which_god);
if (!broken.empty())
{
linebreak_string2(broken, width);
formatted_string::parse_block(broken, false).display();
cprintf(EOL);
cprintf(EOL);
}
}
if (which_god != GOD_XOM)
{
broken = get_god_likes(which_god, true);
linebreak_string2(broken, width);
formatted_string::parse_block(broken, false).display();
broken = get_god_dislikes(which_god, true);
if (!broken.empty())
{
cprintf(EOL);
cprintf(EOL);
linebreak_string2(broken, width);
formatted_string::parse_block(broken, false).display();
}
broken = "";
switch (which_god)
{
case GOD_TROG:
broken = "Note that Trog does not demand training of the "
"Invocations skill. All abilities are purely based on "
"piety.";
break;
case GOD_ZIN:
broken = "Zin will feed starving followers upon <w>p</w>rayer.";
break;
case GOD_ELYVILON:
broken = "Using your healing abilities on monsters may pacify "
"hostile ones, turning them neutral. Pacification "
"works best on natural beasts, worse on humanoids of "
"your species, worse on other humanoids, and worst of "
"all on demons and undead. Whether it succeeds or not, "
"all costs are spent. If it does succeed, the monster "
"is healed and you gain half of its experience value "
"and possibly some piety. Otherwise, the monster is "
"unaffected and you gain nothing. Pacified monsters "
"try to leave the level.";
break;
case GOD_NEMELEX_XOBEH:
if (which_god == you.religion)
{
broken = "The piety increase when sacrificing mostly depends "
"on the value of the item. To prevent items from "
"being accidentally sacrificed, you can "
"<w>i</w>nscribe them with <w>!p</w> (protects the "
"whole stack), with <w>=p</w> (protects only the "
"item), or with <w>!D</w> (causes item to be ignored "
"in sacrifices)."
EOL EOL
"Nemelex Xobeh gifts various types of decks of cards. "
"Each deck type comes in three power levels: plain, "
"ornate, legendary. The latter contain very powerful "
"card effects, potentially hazardous. High piety and "
"Evocations skill help here, as the power of Nemelex' "
"abilities is governed by Evocations instead of "
"Invocations. The type of the deck gifts strongly "
"depends on the dominating item class sacrificed:" EOL
" decks of Escape -- armour" EOL
" decks of Destruction -- weapons and ammunition" EOL
" decks of Dungeons -- jewellery, books, "
"miscellaneous items" EOL
" decks of Summoning -- corpses, chunks, blood" EOL
" decks of Wonders -- consumables: food, potions, "
"scrolls, wands" EOL;
}
default:
break;
}
if (!broken.empty())
{
cprintf(EOL);
cprintf(EOL);
linebreak_string2(broken, width);
formatted_string::parse_block(broken, false).display();
}
}
const int bottom_line = std::min(30, get_number_of_lines());
cgotoxy(1, bottom_line);
formatted_string::parse_string(
#ifndef USE_TILE
"Press '<w>!</w>'"
#else
"<w>Right-click</w>"
#endif
" to toggle between the overview and the more detailed "
"description.").display();
mouse_control mc(MOUSE_MODE_MORE);
const int keyin = getch();
if (keyin == '!' || keyin == CK_MOUSE_CMD)
describe_god(which_god, true);
}
void describe_god( god_type which_god, bool give_title )
{
int colour;
clrscr();
if (give_title)
{
textcolor( WHITE );
cprintf( " Religion" EOL );
textcolor( LIGHTGREY );
}
if (which_god == GOD_NO_GOD) {
cprintf( EOL "You are not religious." );
get_ch();
return;
}
colour = god_colour(which_god);
textcolor(colour);
cprintf( "%s", god_name(which_god, true).c_str());
cprintf(EOL EOL);
textcolor(LIGHTGREY);
std::string god_desc = getLongDescription(god_name(which_god));
const int numcols = get_number_of_cols();
cprintf("%s", get_linebreak_string(god_desc.c_str(), numcols).c_str());
if (you.religion == which_god)
{
cprintf(EOL "Title - ");
textcolor(colour);
std::string title = god_title(which_god);
cprintf("%s", title.c_str());
}
textcolor(LIGHTGREY);
cprintf(EOL EOL "Favour - ");
textcolor(colour);
if (you.religion != which_god)
{
textcolor(colour);
int which_god_penance = you.penance[which_god];
if (which_god_penance > 0 && is_good_god(which_god))
{
if (is_good_god(you.religion))
which_god_penance = 0;
else if (!god_hates_your_god(which_god) && which_god_penance >= 5)
which_god_penance = 2; }
cprintf( (which_god == GOD_NEMELEX_XOBEH
&& which_god_penance > 0 && which_god_penance <= 100)
? "%s doesn't play fair with you." :
(which_god_penance >= 50) ? "%s's wrath is upon you!" :
(which_god_penance >= 20) ? "%s is annoyed with you." :
(which_god_penance >= 5) ? "%s well remembers your sins." :
(which_god_penance > 0) ? "%s is ready to forgive your sins." :
(you.worshipped[which_god]) ? "%s is ambivalent towards you."
: "%s is neutral towards you.",
god_name(which_god).c_str() );
}
else
{
cprintf(describe_favour(which_god).c_str());
textcolor(LIGHTGREY);
cprintf(EOL EOL "Granted powers: (Cost)" EOL);
textcolor(colour);
bool have_any = false;
if (harm_protection_type hpt =
god_protects_from_harm(which_god, false))
{
have_any = true;
int prayer_prot = 0;
if (hpt == HPT_PRAYING || hpt == HPT_PRAYING_PLUS_ANYTIME
|| hpt == HPT_RELIABLE_PRAYING_PLUS_ANYTIME)
{
prayer_prot = 100 - 3000/you.piety;
}
int prot_chance = 10 + you.piety/10 + prayer_prot;
const char *how = (prot_chance >= 85) ? "carefully" :
(prot_chance >= 55) ? "often" :
(prot_chance >= 25) ? "sometimes"
: "occasionally";
const char *when =
(hpt == HPT_PRAYING) ? " during prayer" :
(hpt == HPT_PRAYING_PLUS_ANYTIME) ? ", especially during prayer" :
(hpt == HPT_RELIABLE_PRAYING_PLUS_ANYTIME)
? ", and always does so during prayer"
: "";
std::string buf = god_name(which_god);
buf += " ";
buf += how;
buf += " watches over you";
buf += when;
buf += ".";
_print_final_god_abil_desc(which_god, buf,
(hpt == HPT_RELIABLE_PRAYING_PLUS_ANYTIME) ?
ABIL_HARM_PROTECTION_II : ABIL_HARM_PROTECTION);
}
if (which_god == GOD_ZIN)
{
if (zin_sustenance(false))
{
have_any = true;
std::string buf = "Praying to ";
buf += god_name(which_god);
buf += " will provide sustenance if starving.";
_print_final_god_abil_desc(which_god, buf,
ABIL_ZIN_SUSTENANCE);
}
const char *how = (you.piety >= 150) ? "carefully" : (you.piety >= 100) ? "often" :
(you.piety >= 50) ? "sometimes" :
"occasionally";
cprintf("%s %s shields you from mutagenic effects." EOL,
god_name(which_god).c_str(), how);
}
else if (which_god == GOD_SHINING_ONE)
{
have_any = true;
const char *how = (you.piety >= 150) ? "carefully" : (you.piety >= 100) ? "often" :
(you.piety >= 50) ? "sometimes" :
"occasionally";
cprintf("%s %s shields you from negative energy." EOL,
god_name(which_god).c_str(), how);
}
else if (which_god == GOD_TROG)
{
have_any = true;
std::string buf = "You can call upon ";
buf += god_name(which_god);
buf += " to burn spellbooks in your surroundings.";
_print_final_god_abil_desc(which_god, buf,
ABIL_TROG_BURN_SPELLBOOKS);
}
else if (which_god == GOD_ELYVILON)
{
have_any = true;
std::string buf = "You can destroy weapons on the ground in ";
buf += god_name(which_god);
buf += "'s name.";
_print_final_god_abil_desc(which_god, buf,
ABIL_ELYVILON_DESTROY_WEAPONS);
}
else if (which_god == GOD_YREDELEMNUL)
{
if (yred_injury_mirror(false))
{
have_any = true;
std::string buf = god_name(which_god);
buf += " mirrors your injuries on your foes during prayer.";
_print_final_god_abil_desc(which_god, buf,
ABIL_YRED_INJURY_MIRROR);
}
}
else if (which_god == GOD_JIYVA)
{
if (jiyva_grant_jelly(false))
{
have_any = true;
std::string buf = "You can pray to create a jelly shield.";
_print_final_god_abil_desc(which_god, buf,
ABIL_JIYVA_JELLY_SHIELD);
}
}
else if (which_god == GOD_FEAWN )
{
have_any = true;
std::string buf = "You can speed up decomposition.";
_print_final_god_abil_desc(which_god, buf,
ABIL_FEAWN_FUNGAL_BLOOM);
buf = "You can pass through plants during prayer.";
_print_final_god_abil_desc(which_god, buf,
ABIL_FEAWN_PLANTWALK);
}
if (!player_under_penance())
{
for (int i = 0; i < MAX_GOD_ABILITIES; ++i)
if (you.piety >= piety_breakpoint(i)
&& _print_god_abil_desc(which_god, i))
{
have_any = true;
}
}
if (!have_any)
cprintf( "None." EOL );
}
int bottom_line = get_number_of_lines();
if (bottom_line > 30)
bottom_line = 30;
if (which_god == you.religion)
{
std::string extra = get_linebreak_string(_religion_help(which_god),
numcols).c_str();
cgotoxy(1, bottom_line - std::count(extra.begin(), extra.end(), '\n')-1,
GOTO_CRT);
textcolor(LIGHTGREY);
cprintf( "%s", extra.c_str() );
}
cgotoxy(1, bottom_line);
textcolor(LIGHTGREY);
formatted_string::parse_string(
#ifndef USE_TILE
"Press '<w>!</w>'"
#else
"<w>Right-click</w>"
#endif
" to toggle between the overview and the more detailed "
"description.").display();
mouse_control mc(MOUSE_MODE_MORE);
const int keyin = getch();
if (keyin == '!' || keyin == CK_MOUSE_CMD)
_detailed_god_description(which_god);
}
std::string get_skill_description(int skill, bool need_title)
{
std::string lookup = skill_name(skill);
std::string result = "";
if (need_title)
{
result = lookup;
result += EOL EOL;
}
result += getLongDescription(lookup);
switch (skill)
{
case SK_UNARMED_COMBAT:
{
std::vector<std::string> unarmed_attacks;
if (you.attribute[ATTR_TRANSFORMATION] == TRAN_DRAGON
|| player_genus(GENPC_DRACONIAN)
|| you.species == SP_MERFOLK && player_is_swimming()
|| player_mutation_level( MUT_STINGER ))
{
if (you.religion != GOD_SHINING_ONE
|| !player_mutation_level(MUT_STINGER))
{
unarmed_attacks.push_back("slap with your tail");
}
}
if (player_mutation_level(MUT_FANGS)
|| you.attribute[ATTR_TRANSFORMATION] == TRAN_DRAGON)
{
unarmed_attacks.push_back("bite with your sharp teeth");
}
else if (player_mutation_level(MUT_BEAK))
unarmed_attacks.push_back("peck with your beak");
if (player_mutation_level(MUT_HORNS))
unarmed_attacks.push_back("headbutt with your horns");
else if (you.species == SP_NAGA)
unarmed_attacks.push_back("do a headbutt attack");
if (player_mutation_level(MUT_HOOVES))
unarmed_attacks.push_back("kick with your hooves");
else if (player_mutation_level(MUT_TALONS))
unarmed_attacks.push_back("claw with your talons");
else if (you.species != SP_NAGA
&& (you.species != SP_MERFOLK || !player_is_swimming()))
{
unarmed_attacks.push_back("deliver a kick");
}
if (you.equip[EQ_WEAPON] == -1)
unarmed_attacks.push_back("throw a punch");
else if (you.equip[EQ_SHIELD] == -1)
unarmed_attacks.push_back("punch with your free hand");
if (!unarmed_attacks.empty())
{
std::string broken = "For example, you could ";
broken += comma_separated_line(unarmed_attacks.begin(),
unarmed_attacks.end(),
" or ", ", ");
broken += ".";
linebreak_string2(broken, 72);
result += EOL;
result += broken;
}
break;
}
case SK_INVOCATIONS:
if (you.species == SP_DEMIGOD)
{
result += EOL;
result += "How on earth did you manage to pick this up?";
}
else if (you.religion == GOD_TROG)
{
result += EOL;
result += "Note that Trog doesn't use Invocations, its being too "
"closely connected to magic.";
}
else if (you.religion == GOD_NEMELEX_XOBEH)
{
result += EOL;
result += "Note that Nemelex uses Evocations rather than "
"Invocations.";
}
break;
case SK_EVOCATIONS:
if (you.religion == GOD_NEMELEX_XOBEH)
{
result += EOL;
result += "This is the skill all of Nemelex' abilities rely on.";
}
break;
case SK_SPELLCASTING:
if (you.religion == GOD_TROG)
{
result += EOL;
result += "Keep in mind, though, that Trog will greatly disapprove "
"of this.";
}
break;
default:
break;
}
return result;
}
void describe_skill(int skill)
{
std::ostringstream data;
data << get_skill_description(skill, true);
print_description(data.str());
if (getch() == 0)
getch();
}