/* File: spells.pkg */ /* * Purpose: Lua interface defitions for spells. * To be processed by tolua to generate C source code. */ $#include "angband.h" $#include "lua.h" /** @typedef *mcptr * @note String */ typedef char *mcptr; /** @typedef cptr * @note String */ typedef const char* cptr; /** @typedef errr * @note Number */ typedef int errr; /** @typedef bool * @note Boolean */ typedef unsigned char bool; /** @typedef byte * @note Number */ typedef unsigned char byte; /** @typedef s16b * @note Number */ typedef signed short s16b; /** @typedef u16b * @note Number */ typedef unsigned short u16b; /** @typedef s32b * @note Number */ typedef signed int s32b; /** @typedef u32b * @note Number */ typedef unsigned int u32b; /** @def DEFAULT_RADIUS */ #define DEFAULT_RADIUS 25 /** @name Spell Damage Types * @brief Type of damage caused by spell * @{ */ /** @def GF_ELEC */ #define GF_ELEC 1 /** @def GF_POIS */ #define GF_POIS 2 /** @def GF_ACID */ #define GF_ACID 3 /** @def GF_COLD */ #define GF_COLD 4 /** @def GF_FIRE */ #define GF_FIRE 5 /** @def GF_UNBREATH */ #define GF_UNBREATH 6 /** @def GF_CORPSE_EXPL */ #define GF_CORPSE_EXPL 7 /** @def GF_MISSILE */ #define GF_MISSILE 10 /** @def GF_ARROW */ #define GF_ARROW 11 /** @def GF_PLASMA */ #define GF_PLASMA 12 /** @def GF_WAVE */ #define GF_WAVE 13 /** @def GF_WATER */ #define GF_WATER 14 /** @def GF_LITE */ #define GF_LITE 15 /** @def GF_DARK */ #define GF_DARK 16 /** @def GF_LITE_WEAK */ #define GF_LITE_WEAK 17 /** @def GF_DARK_WEAK */ #define GF_DARK_WEAK 18 /** @def GF_SHARDS */ #define GF_SHARDS 20 /** @def GF_SOUND */ #define GF_SOUND 21 /** @def GF_CONFUSION */ #define GF_CONFUSION 22 /** @def GF_FORCE */ #define GF_FORCE 23 /** @def GF_INERTIA */ #define GF_INERTIA 24 /** @def GF_MANA */ #define GF_MANA 26 /** @def GF_METEOR */ #define GF_METEOR 27 /** @def GF_ICE */ #define GF_ICE 28 /** @def GF_CHAOS */ #define GF_CHAOS 30 /** @def GF_NETHER */ #define GF_NETHER 31 /** @def GF_DISENCHANT */ #define GF_DISENCHANT 32 /** @def GF_NEXUS */ #define GF_NEXUS 33 /** @def GF_TIME */ #define GF_TIME 34 /** @def GF_GRAVITY */ #define GF_GRAVITY 35 /** @def GF_KILL_WALL */ #define GF_KILL_WALL 40 /** @def GF_KILL_DOOR */ #define GF_KILL_DOOR 41 /** @def GF_KILL_TRAP */ #define GF_KILL_TRAP 42 /** @def GF_MAKE_WALL */ #define GF_MAKE_WALL 45 /** @def GF_MAKE_DOOR */ #define GF_MAKE_DOOR 46 /** @def GF_MAKE_TRAP */ #define GF_MAKE_TRAP 47 /** @def GF_OLD_CLONE */ #define GF_OLD_CLONE 51 /** @def GF_OLD_POLY */ #define GF_OLD_POLY 52 /** @def GF_OLD_HEAL */ #define GF_OLD_HEAL 53 /** @def GF_OLD_SPEED */ #define GF_OLD_SPEED 54 /** @def GF_OLD_SLOW */ #define GF_OLD_SLOW 55 /** @def GF_OLD_CONF */ #define GF_OLD_CONF 56 /** @def GF_OLD_SLEEP */ #define GF_OLD_SLEEP 57 /** @def GF_OLD_DRAIN */ #define GF_OLD_DRAIN 58 /** @def GF_AWAY_UNDEAD */ #define GF_AWAY_UNDEAD 61 /** @def GF_AWAY_EVIL */ #define GF_AWAY_EVIL 62 /** @def GF_AWAY_ALL */ #define GF_AWAY_ALL 63 /** @def GF_TURN_UNDEAD */ #define GF_TURN_UNDEAD 64 /** @def GF_TURN_EVIL */ #define GF_TURN_EVIL 65 /** @def GF_TURN_ALL */ #define GF_TURN_ALL 66 /** @def GF_DISP_UNDEAD */ #define GF_DISP_UNDEAD 67 /** @def GF_DISP_EVIL */ #define GF_DISP_EVIL 68 /** @def GF_DISP_ALL */ #define GF_DISP_ALL 69 /* New types for Zangband begin here... */ /** @def GF_DISP_DEMON */ #define GF_DISP_DEMON 70 /** @def GF_DISP_LIVING */ #define GF_DISP_LIVING 71 /** @def GF_ROCKET */ #define GF_ROCKET 72 /** @def GF_NUKE */ #define GF_NUKE 73 /** @def GF_MAKE_GLYPH */ #define GF_MAKE_GLYPH 74 /** @def GF_STASIS */ #define GF_STASIS 75 /** @def GF_STONE_WALL */ #define GF_STONE_WALL 76 /** @def GF_DEATH_RAY */ #define GF_DEATH_RAY 77 /** @def GF_STUN */ #define GF_STUN 78 /** @def GF_HOLY_FIRE */ #define GF_HOLY_FIRE 79 /** @def GF_HELL_FIRE */ #define GF_HELL_FIRE 80 /** @def GF_DISINTEGRATE */ #define GF_DISINTEGRATE 81 /** @def GF_CHARM */ #define GF_CHARM 82 /** @def GF_CONTROL_UNDEAD */ #define GF_CONTROL_UNDEAD 83 /** @def GF_CONTROL_ANIMAL */ #define GF_CONTROL_ANIMAL 84 /** @def GF_PSI */ #define GF_PSI 85 /** @def GF_PSI_DRAIN */ #define GF_PSI_DRAIN 86 /** @def GF_TELEKINESIS */ #define GF_TELEKINESIS 87 /** @def GF_JAM_DOOR */ #define GF_JAM_DOOR 88 /** @def GF_DOMINATION */ #define GF_DOMINATION 89 /** @def GF_DISP_GOOD */ #define GF_DISP_GOOD 90 /** @def GF_IDENTIFY */ #define GF_IDENTIFY 91 /** @def GF_RAISE */ #define GF_RAISE 92 /** @def GF_STAR_IDENTIFY */ #define GF_STAR_IDENTIFY 93 /** @def GF_DESTRUCTION */ #define GF_DESTRUCTION 94 /** @def GF_STUN_CONF */ #define GF_STUN_CONF 95 /** @def GF_STUN_DAM */ #define GF_STUN_DAM 96 /** @def GF_CONF_DAM */ #define GF_CONF_DAM 98 /** @def GF_STAR_CHARM */ #define GF_STAR_CHARM 99 /** @def GF_IMPLOSION */ #define GF_IMPLOSION 100 /** @def GF_LAVA_FLOW */ #define GF_LAVA_FLOW 101 /** @def GF_FEAR */ #define GF_FEAR 102 /** @def GF_BETWEEN_GATE */ #define GF_BETWEEN_GATE 103 /** @def GF_WINDS_MANA */ #define GF_WINDS_MANA 104 /** @def GF_DEATH */ #define GF_DEATH 105 /** @def GF_CONTROL_DEMON */ #define GF_CONTROL_DEMON 106 /** @def GF_RAISE_DEMON */ #define GF_RAISE_DEMON 107 /** @def GF_TRAP_DEMONSOUL */ #define GF_TRAP_DEMONSOUL 108 /** @def GF_ATTACK */ #define GF_ATTACK 109 /** @def GF_CHARM_UNMOVING */ #define GF_CHARM_UNMOVING 110 /** @def GF_INSTA_DEATH */ #define GF_INSTA_DEATH 111 /** @def GF_ELEMENTAL_WALL */ #define GF_ELEMENTAL_WALL 112 /** @def GF_ELEMENTAL_GROWTH */ #define GF_ELEMENTAL_GROWTH 113 /** @def MAX_GF */ #define MAX_GF 114 /** @} */ /** @name Spell Projection Flags * @brief Area affected by spell * @{ */ /** @def PROJECT_JUMP * @note Jump directly to the target location (this is a hack) */ #define PROJECT_JUMP 0x00000001 /** @def PROJECT_BEAM * @note Work as a beam weapon (affect every grid passed through) */ #define PROJECT_BEAM 0x00000002 /** @def PROJECT_THRU * @note Continue "through" the target (used for "bolts"/"beams") */ #define PROJECT_THRU 0x00000004 /** @def PROJECT_STOP * @note Stop as soon as we hit a monster (used for "bolts") */ #define PROJECT_STOP 0x00000008 /** @def PROJECT_GRID * @note Affect each grid in the "blast area" in some way */ #define PROJECT_GRID 0x00000010 /** @def PROJECT_ITEM * @note Affect each object in the "blast area" in some way */ #define PROJECT_ITEM 0x00000020 /** @def PROJECT_KILL * @note Affect each monster in the "blast area" in some way */ #define PROJECT_KILL 0x00000040 /** @def PROJECT_HIDE * @note Hack -- disable "visual" feedback from projection */ #define PROJECT_HIDE 0x00000080 /** @def PROJECT_VIEWABLE * @note Affect monsters in LOS */ #define PROJECT_VIEWABLE 0x00000100 /** @def PROJECT_METEOR_SHOWER * @note Affect random grids */ #define PROJECT_METEOR_SHOWER 0x00000200 /** @def PROJECT_BLAST * @note Like Mega_blast, but will only affect viewable grids */ #define PROJECT_BLAST 0x00000400 /** @def PROJECT_PANEL * @note Affect everything in the panel. */ #define PROJECT_PANEL 0x00000800 /** @def PROJECT_ALL * @note Affect every single grid. */ #define PROJECT_ALL 0x00001000 /** @def PROJECT_WALL * @note Continue "through" the walls */ #define PROJECT_WALL 0x00002000 /** @def PROJECT_MANA_PATH * @note Follow a mana path. */ #define PROJECT_MANA_PATH 0x00004000 /** @def PROJECT_ABSORB_MANA * @note The spell increase in power as it absord grid's mana. */ #define PROJECT_ABSORB_MANA 0x00008000 /** @def PROJECT_STAY */ #define PROJECT_STAY 0x00010000 /** @} */ /** @var project_time * @brief Number * @note The length of time a spell effect exists. */ extern int project_time; /** @fn teleport_player_directed(int rad, int dir) * @brief Teleport a player up to "rad" grids away roughly in "dir" * direction.\n * @param rad Number \n rad must not exceed 200. The distance teleported is * at least a quarter of rad. * @brief Distance * @param dir Number \n dir must be a value from 0 to 9. * @brief Direction * @note * Teleport player, using a distance and a direction as a rough guide.\n\n * This function is not at all obsessive about correctness.\n * This function allows teleporting into vaults (!) * @note (see file spells1.c) */ extern void teleport_player_directed(int rad, int dir); /** @fn teleport_away(int m_idx, int dis) * @brief Teleport monster indicated by "m_idx" up to "dis" grids away.\n * @param m_idx Number \n m_idx is the index of the monster in m_list[]. * @brief Monster index * @param dis Number \n dis must not exceed 200. The distance teleported * is a minimum of a quarter of "dis". * @brief Distance * @note * Teleport a monster, normally up to "dis" grids away.\n\n * Attempt to move the monster at least "dis/2" grids away.\n\n * But allow variation to prevent infinite loops. * @note (see file spells1.c) */ extern void teleport_away(int m_idx, int dis); /** @fn teleport_player(int dis) * @brief Teleport player up to "dis" grids away.\n * @param dis Number \n dis must not exceed 200. The distance teleported * is a minimum of a quarter of dis. * @brief Distance * @note * Teleport the player to a location up to "dis" grids away.\n\n * If no such spaces are readily available, the distance may increase.\n * Try very hard to move the player at least a quarter that distance. * @note (see file spells1.c) */ extern void teleport_player(int dis); /** @fn teleport_monster_to(int m_idx, int ny, int nx) * @brief Teleport monster indicated by "m_idx" to a grid near coordinate * ("ny", "nx").\n * @param m_idx Number \n m_idx is the index of the monster in m_list[]. * @brief Monster index * @param ny Number \n ny is the y co-ordinate of the location. * @brief Y coordinate * @param nx Number \n nx is the x co-ordinate of the location. * @brief X coordinate * @note * Teleport a monster to a grid near the given location\n\n * This function is slightly obsessive about correctness.\n\n * If the location is empty, the monster goes there, otherwise they go to * a grid as close as possible to the location. * @note (see file spells1.c) */ extern void teleport_monster_to(int m_idx, int ny, int nx); /** @fn teleport_monster(int dir) * @brief Teleport away all monsters in direction "dir".\n * @param dir Number \n dir must be a value from 0 to 9. * @brief Direction * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note * All monsters in direction "dir" are teleported away and sustain * MAX_SIGHT (20) x 5 damage.\n\n * If direction is 5 and a target has been selected, then the target is used. * Otherwise, a target is calculated based on a distance of 999 grids away * from the player in direction "dir". * @note (see file spells2.c) */ extern bool teleport_monster(int dir); /** @fn teleport_player_level(void) * @brief Teleport the player one level up or down at random. * @note * Teleport the player one level up or down (random when legal) * @note (see file spells1.c) */ extern void teleport_player_level(void); /** @fn fetch(int dir, int wgt, bool require_los) * @brief Fetch an item in direction "dir" with weight "wgt" possibly not in * line of sight.\n * @param dir Number \n dir must be a value from 0 to 9. * @brief Direction * @param wgt Number \n maximum weight of object. * @brief Weight * @param require_los Boolean \n TRUE if line of sight is required, otherwise * FALSE. * @brief Require-line-of-sight flag * @note * Fetch an item (teleport it right underneath the caster)\n\n * If direction is 5 and a target has been selected, then the target is used. * Otherwise, a target is calculated based on a distance of 999 grids away * from the player in direction "dir". * Fetch will fail if player is standing on something, or if the object is * too far away, or if require_los is TRUE and player does not have line * of sight to the object, or the object is too heavy. Otherwise the * object appears at the player's feet (same grid as player). * @note (see file cmd5.c) */ extern void fetch(int dir, int wgt, bool require_los); /** @fn recall_player(int d, int f) * @brief Recall the player to town (if in dungeon) or dungeon (if in town).\n * @param d Number \n Random time interval * @brief Dice * @param f Number \n Fixed time interval * @brief Fixed * @note (see file spells1.c) */ extern void recall_player(int d, int f); /** @fn take_hit(int damage, cptr kb_str) * @brief Reduce player hit points by "damage" inflicted by "kb_str".\n * @param damage Number \n damage is the number of hit points of damage. * @brief Damage * @param kb_str String \n kb_str describes what killed the player * (in the event the player dies) * @brief Killed by * @note * Decreases players hit points and sets death flag if necessary\n\n * XXX XXX XXX Invulnerability needs to be changed into a "shield"\n\n * XXX XXX XXX Hack -- this function allows the user to save (or quit) * the game when he dies, since the "You die." message is shown before * setting the player to "dead". * @note (see file spells1.c) */ extern void take_hit(int damage, cptr kb_str); /** @fn take_sanity_hit(int damage, cptr hit_from) * @brief Reduce player sanity points by "damage" inflicted by "hit_from".\n * @param damage Number \n damage is the number of sanity points of damage. * @brief Damage * @param hit_from String \n hit_from describes what caused the damage. * @brief Hit from * @note * Decrease player's sanity. This is a copy of the function above.\n\n * Reduce the player's current sanity points by "damage" points. If the * player dies, "hit_from" is used to record what the player was killed * by (see high-score table). * @note (see file spells1.c) */ extern void take_sanity_hit(int damage, cptr hit_from); /** @fn project(int who, int rad, int y, int x, int dam, int typ, int flg) * @brief Generate a beam/bolt/ball with properties "flg" starting from "who" * with a radius of "rad" at target grid "y,x" for "dam" points of "typ" * damage.\n * @param who Number \n who is > 0 (index of monster in m_list[]), < 0 and * not -100 or -101 (player), -100 or -101 (trap). * @brief Source * @param rad Number \n rad is 0 for a beam/bolt and 1-9 for a ball. * @brief Radius * @param y Number \n y is the y coordinate of the target grid. * @brief Y-coordinate * @param x Number \n x is the x co-ordinate of the target grid. * @brief X-coordinate * @param dam Number \n dam is the number of hit points of damage. * @brief Damage * @param typ Number \n typ is the type of damage (GF field). * @brief Type * @param flg Number \n flg is the projection effect (PROJECT field). * @brief Properties flag * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note * Generic "beam"/"bolt"/"ball" projection routine.\n\n * Input:\n * who: Index of "source" monster (negative for "player")\n * jk -- -2 for traps, only used with project_jump\n * rad: Radius of explosion (0 = beam/bolt, 1 to 9 = ball)\n * y,x: Target location (or location to travel "towards")\n * dam: Base damage roll to apply to affected monsters (or player)\n * typ: Type of damage to apply to monsters (and objects)\n * flg: Extra bit flags (see PROJECT_xxxx in "defines.h")\n\n * Return:\n * TRUE if any "effects" of the projection were observed, else FALSE\n\n * Allows a monster (or player) to project a beam/bolt/ball of a given kind * towards a given location (optionally passing over the heads of interposing * monsters), and have it do a given amount of damage to the monsters (and * optionally objects) within the given radius of the final location.\n\n * A "bolt" travels from source to target and affects only the target grid.\n * A "beam" travels from source to target, affecting all grids passed through.\n * A "ball" travels from source to the target, exploding at the target, and * affecting everything within the given radius of the target location.\n\n * Traditionally, a "bolt" does not affect anything on the ground, and does * not pass over the heads of interposing monsters, much like a traditional * missile, and will "stop" abruptly at the "target" even if no monster is * positioned there, while a "ball", on the other hand, passes over the heads * of monsters between the source and target, and affects everything except * the source monster which lies within the final radius, while a "beam" * affects every monster between the source and target, except for the casting * monster (or player), and rarely affects things on the ground.\n\n * Two special flags allow us to use this function in special ways, the * "PROJECT_HIDE" flag allows us to perform "invisible" projections, while * the "PROJECT_JUMP" flag allows us to affect a specific grid, without * actually projecting from the source monster (or player).\n\n * The player will only get "experience" for monsters killed by himself * Unique monsters can only be destroyed by attacks from the player\n\n * Only 256 grids can be affected per projection, limiting the effective * "radius" of standard ball attacks to nine units (diameter nineteen).\n\n * One can project in a given "direction" by combining PROJECT_THRU with small * offsets to the initial location (see "line_spell()"), or by calculating * "virtual targets" far away from the player.\n\n * One can also use PROJECT_THRU to send a beam/bolt along an angled path, * continuing until it actually hits something (useful for "stone to mud").\n\n * Bolts and Beams explode INSIDE walls, so that they can destroy doors.\n\n * Balls must explode BEFORE hitting walls, or they would affect monsters * on both sides of a wall. Some bug reports indicate that this is still * happening in 2.7.8 for Windows, though it appears to be impossible.\n\n * We "pre-calculate" the blast area only in part for efficiency. * More importantly, this lets us do "explosions" from the "inside" out. * This results in a more logical distribution of "blast" treasure. * It also produces a better (in my opinion) animation of the explosion. * It could be (but is not) used to have the treasure dropped by monsters * in the middle of the explosion fall "outwards", and then be damaged by * the blast as it spreads outwards towards the treasure drop location.\n\n * Walls and doors are included in the blast area, so that they can be * "burned" or "melted" in later versions.\n\n * This algorithm is intended to maximise simplicity, not necessarily * efficiency, since this function is not a bottleneck in the code.\n\n * We apply the blast effect from ground zero outwards, in several passes, * first affecting features, then objects, then monsters, then the player. * This allows walls to be removed before checking the object or monster * in the wall, and protects objects which are dropped by monsters killed * in the blast, and allows the player to see all affects before he is * killed or teleported away. The semantics of this method are open to * various interpretations, but they seem to work well in practice.\n\n * We process the blast area from ground-zero outwards to allow for better * distribution of treasure dropped by monsters, and because it provides a * pleasing visual effect at low cost.\n\n * Note that the damage done by "ball" explosions decreases with distance. * This decrease is rapid, grids at radius "dist" take "1/dist" damage.\n\n * Notice the "napalm" effect of "beam" weapons. First they "project" to * the target, and then the damage "flows" along this beam of destruction. * The damage at every grid is the same as at the "centre" of a "ball" * explosion, since the "beam" grids are treated as if they ARE at the * centre of a "ball" explosion.\n\n * Currently, specifying "beam" plus "ball" means that locations which are * covered by the initial "beam", and also covered by the final "ball", except * for the final grid (the epicentre of the ball), will be "hit twice", once * by the initial beam, and once by the exploding ball. For the grid right * next to the epicentre, this results in 150% damage being done. The centre * does not have this problem, for the same reason the final grid in a "beam" * plus "bolt" does not -- it is explicitly removed. Simply removing "beam" * grids which are covered by the "ball" will NOT work, as then they will * receive LESS damage than they should. Do not combine "beam" with "ball".\n\n * The array "gy[],gx[]" with current size "grids" is used to hold the * collected locations of all grids in the "blast area" plus "beam path".\n\n * Note the rather complex usage of the "gm[]" array. First, gm[0] is always * zero. Second, for N>1, gm[N] is always the index (in gy[],gx[]) of the * first blast grid (see above) with radius "N" from the blast centre. Note * that only the first gm[1] grids in the blast area thus take full damage. * Also, note that gm[rad+1] is always equal to "grids", which is the total * number of blast grids.\n\n * Note that once the projection is complete, (y2,x2) holds the final location * of bolts/beams, and the "epicentre" of balls.\n\n * Note also that "rad" specifies the "inclusive" radius of projection blast, * so that a "rad" of "one" actually covers 5 or 9 grids, depending on the * implementation of the "distance" function. Also, a bolt can be properly * viewed as a "ball" with a "rad" of "zero".\n\n * Note that if no "target" is reached before the beam/bolt/ball travels the * maximum distance allowed (MAX_RANGE), no "blast" will be induced. This * may be relevant even for bolts, since they have a "1x1" mini-blast.\n\n * Note that for consistency, we "pretend" that the bolt actually takes "time" * to move from point A to point B, even if the player cannot see part of the * projection path. Note that in general, the player will *always* see part * of the path, since it either starts at the player or ends on the player.\n\n * Hack -- we assume that every "projection" is "self-illuminating".\n\n * Hack -- when only a single monster is affected, we automatically track * (and recall) that monster, unless "PROJECT_JUMP" is used.\n\n * Note that all projections now "explode" at their final destination, even * if they were being projected at a more distant destination. This means * that "ball" spells will *always* explode.\n\n * Note that we must call "handle_stuff()" after affecting terrain features * in the blast radius, in case the "illumination" of the grid was changed, * and "update_view()" and "update_monsters()" need to be called. * @note (see file spells1.c) */ extern bool project(int who, int rad, int y, int x, int dam, int typ, int flg); /** @fn corrupt_player(void) * @brief Swap two of the player's stats at random. * @note (see file spells1.c) */ extern void corrupt_player(void); /** @fn grow_grass(int rad) * @brief Grow grass within "rad" distance of the player.\n * @param rad Number \n rad is the radius of the area where grass may grow. * @brief Radius * @note * Grow grass\n\n * Up to (rad * (rad + 11)) grass can be grown around the player. The * grids must support growth. * @note (see file spells2.c) */ extern void grow_grass(int rad); /** @fn grow_trees(int rad) * @brief Grow trees within "rad" distance of the player.\n * @param rad Number \n rad is the radius of the area where trees may grow. * @brief Radius * @note * Grow trees\n\n * Up to (rad * (rad + 11)) trees can be grown around the player. The * grids must support growth. * @note (see file spells2.c) */ extern void grow_trees(int rad); /** @fn hp_player(int num) * @brief Add "num" points to the player's current hit points.\n * @param num Number \n num is the number of points to add. * @brief Number * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note * Increase players hit points, notice effects\n\n * The total can not exceed the maximum. * @note (see file spells2.c) */ extern bool hp_player(int num); /** @fn heal_insanity(int val) * @brief Add "val" points to the player's current sanity points.\n * @param val Number \n val is the number of points to add. * @brief Value * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note * Heal insanity.\n\n * The total can not exceed the maximum. * @note (see file spells2.c) */ extern bool heal_insanity(int val); /** @fn warding_glyph(void) * @brief Place a glyph at the player's location. * @note * Leave a "glyph of warding" which prevents monster movement\n\n * The location must be bare. * @note (see file spells2.c) */ extern void warding_glyph(void); /** @fn explosive_rune(void) * @brief Place a minor glyph (explosive rune) at the player's location. * @note * The location must be bare. * @note (see file spells2.c) */ extern void explosive_rune(void); /** @fn do_dec_stat(int stat, int mode) * @brief Attempt to reduce the player's "stat" statistic by a point.\n * @param stat Number \n stat is the statistic * @brief Statistic * @param mode Number \n mode is the type of decrease: temporary, normal, * or permanent * @brief Mode * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note * Lose a "point" * @note (see file spells2.c) */ extern bool do_dec_stat(int stat, int mode); /** @fn do_res_stat(int stat, bool full) * @brief Restore the player's "stat" statistic.\n * @param stat Number \n stat is the statistic. * @brief Statistic * @param full Boolean \n TRUE if full restore is required, otherwise FALSE. * @brief Full restore flag * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note * Restore lost "points" in a stat * @note (see file spells2.c) */ extern bool do_res_stat(int stat, bool full); /** @fn do_inc_stat(int stat) * @brief Increase the player's "stat" statistic by a point.\n * @param stat Number \n stat is the statistic. * @brief Statistic * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note * Gain a "point" in a stat * @note (see file spells2.c) */ extern bool do_inc_stat(int stat); /** @fn identify_pack(void) * @brief Identify all items in the inventory. * @note * Identify everything being carried.\n * Done by a potion of "self knowledge". * @note (see file spells2.c) */ extern bool identify_pack(void); /** @fn remove_curse(void) * @brief Remove all curses except for heavy curses. * @return Boolean \n TRUE if at least one item was uncursed, otherwise FALSE. * @note * Remove most curses\n\n * There is a 1 in (55 - level) chance of reversing the curse effects for * items which are not artifacts. For example, a Ring of Damage (-15) will * become a Ring of Damage (+15). * @note (see file spells2.c) */ extern bool remove_curse(void); /** @fn remove_all_curse(void) * @brief Remove all curses including heavy curses. * @return Boolean \n TRUE if at least one item was uncursed, otherwise FALSE. * @note * Remove all curses\n\n * There is a 1 in (55 - level) chance of reversing the curse effects for * items which are not artifacts. For example, a Ring of Damage (-15) will * become a Ring of Damage (+15). * @note (see file spells2.c) */ extern bool remove_all_curse(void); /** @fn restore_level(void) * @brief Restore all drained experience points (if any). * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note * Restores any drained experience * @note (see file spells2.c) */ extern bool restore_level(void); /** @fn self_knowledge(FILE *fff=NULL) * @brief Show all attributes including racial powers, mutations, and * equipment effects.\n * @param *fff FILE \n write info to screen if fff is NULL, * otherwise write info to file fff. * @brief Output file * @note * self-knowledge... idea from nethack. Useful for determining powers and * resistances of items. It saves the screen, clears it, then starts listing * attributes, a screenful at a time. (There are a LOT of attributes to * list. It will probably take 2 or 3 screens for a powerful character whose * using several artifacts...) -CFT\n\n * It is now a lot more efficient. -BEN-\n\n * See also "identify_fully()".\n\n * XXX XXX XXX Use the "show_file()" method, perhaps. * @note (see file spells2.c) */ extern void self_knowledge(FILE *fff=NULL); /** @fn lose_all_info(void) * @brief Forget about objects and the map. * @return Boolean \n TRUE (always). * @note * Forget everything * @note (see file spells2.c) */ extern bool lose_all_info(void); /** @fn detect_traps(int rad) * @brief Detect all traps within radius "rad" of the player.\n * @param rad Number \n rad is the radius of circle of detection. * @brief Radius * @return Boolean \n TRUE (always). * @note * All grids within the radius are searched.\n * A message is displayed if traps are detected. * @note (see file spells2.c) */ extern bool detect_traps(int rad); /** @fn detect_doors(int rad) * @brief Detect all doors within radius "rad" of the player.\n * @param rad Number \n rad is the radius of circle of detection. * @brief Radius * @return Boolean \n TRUE if doors were detected, otherwise FALSE. * @note * All grids within the radius are searched.\n * A message is displayed if doors are detected. * @note (see file spells2.c) */ extern bool detect_doors(int rad); /** @fn detect_stairs(int rad) * @brief Detect all exits within radius "rad" of the player.\n * @param rad Number \n rad is the radius of circle of detection. * @brief Radius * @return Boolean \n TRUE if exits were detected, otherwise FALSE. * @note * All grids within the radius are searched.\n * A message is displayed if exits are detected. Exits can be stairs, * shafts, and ways out. * @note (see file spells2.c) */ extern bool detect_stairs(int rad); /** @fn detect_treasure(int rad) * @brief Detect all buried treasure within radius "rad" of the player.\n * @param rad Number \n rad is the radius of circle of detection. * @brief Radius * @return Boolean \n TRUE if buried treasure was detected, otherwise FALSE. * @note * All grids within the radius are searched.\n * A message is displayed if buried treasure is detected. Treasure can be * buried in magma, quartz, or sandwall. * @note (see file spells2.c) */ extern bool detect_treasure(int rad); /** @var hack_no_detect_message * @brief Boolean * @note Suppress messages generated by "detect" spells? */ extern bool hack_no_detect_message; /** @fn detect_objects_gold(int rad) * @brief Detect all gold within radius "rad" of the player.\n * @param rad Number \n rad is the radius of circle of detection. * @brief Radius * @return Boolean \n TRUE if gold was detected, otherwise FALSE. * @note * All grids within the radius are searched.\n * A message is displayed if gold is detected. Gold can be coins or mimics. * Monsters of type "$" are detected but not shown or reported. * @note (see file spells2.c) */ extern bool detect_objects_gold(int rad); /** @fn detect_objects_normal(int rad) * @brief Detect all normal (not gold) items within radius "rad" of the player.\n * @param rad Number \n rad is the radius of circle of detection. * @brief Radius * @return Boolean \n TRUE if normal items were detected, otherwise FALSE. * @note * All grids within the radius are searched.\n * A message is displayed if normal items are detected. Items include mimics. * Monsters of type "!=?|" are detected but not shown or reported. * @note (see file spells2.c) */ extern bool detect_objects_normal(int rad); /** @fn detect_objects_magic(int rad) * @brief Detect all magic (not gold) items within radius "rad" of the player.\n * @param rad Number \n rad is the radius of circle of detection. * @brief Radius * @return Boolean \n TRUE if magic items were detected, otherwise FALSE. * @note * This will light up all spaces with "magic" items, including artifacts, * ego-items, potions, scrolls, books, rods, wands, staves, amulets, rings, * and "enchanted" items of the "good" variety.\n\n * It can probably be argued that this function is now too powerful.\n\n * All grids within the radius are searched.\n * A message is displayed if magic items are detected. Items include mimics. * @note (see file spells2.c) */ extern bool detect_objects_magic(int rad); /** @fn detect_monsters_normal(int rad) * @brief Detect all non-invisible monsters within radius "rad" of the player.\n * @param rad Number \n rad is the radius of circle of detection. * @brief Radius * @return Boolean \n TRUE if non-invisible monsters were detected, * otherwise FALSE. * @note * A non-invisible monster is one which is visible, or one which is invisible * but the player can see invisible monsters. * @note (see file spells2.c) */ extern bool detect_monsters_normal(int rad); /** @fn detect_monsters_invis(int rad) * @brief Detect all invisible monsters within radius "rad" of the player.\n * @param rad Number \n rad is the radius of circle of detection. * @brief Radius * @return Boolean \n TRUE if invisible monsters were detected, * otherwise FALSE. * @note (see file spells2.c) */ extern bool detect_monsters_invis(int rad); /** @fn detect_monsters_evil(int rad) * @brief Detect all evil monsters within radius "rad" of the player.\n * @param rad Number \n rad is the radius of circle of detection. * @brief Radius * @return Boolean \n TRUE if evil monsters were detected, otherwise FALSE. * @note (see file spells2.c) */ extern bool detect_monsters_evil(int rad); /** @fn detect_monsters_good(int rad) * @brief Detect all good monsters within radius "rad" of the player.\n * @param rad Number \n rad is the radius of circle of detection. * @brief Radius * @return Boolean \n TRUE if good monsters were detected, otherwise FALSE. * @note (see file spells2.c) */ extern bool detect_monsters_good(int rad); /** @fn detect_monsters_xxx(u32b match_flag, int rad) * @brief Detect all monsters with flag "match_flag" within radius "rad" of the * player.\n * @param match_flag Number \n match_flag is the type of monster. It must be * a RF3_ flag (see defines.h). * @brief Match flag * @param rad Number \n rad is the radius of circle of detection. * @brief Radius * @return Boolean \n TRUE if monsters were detected, otherwise FALSE. * @note * A "generic" detect monsters routine, tagged to flags3\n\n * This routine will work with ANY RF3 flag, but messages will only be * printed if the following monsters are detected: demon, undead, good. * @note (see file spells2.c) */ extern bool detect_monsters_xxx(u32b match_flag, int rad); /** @fn detect_monsters_string(cptr chars, int rad) * @brief Detect all monsters whose monster symbol is in "chars" within * radius "rad" of the player.\n * @param chars String \n chars is the string of monster types. For * available characters, see the "symbol" field of the graphics (G) * line of r_info.txt. * @brief Symbols * @param rad Number \n rad is the radius of circle of detection. * @brief Radius * @return Boolean \n TRUE if monsters were detected, otherwise FALSE. * @note (see file spells2.c) */ extern bool detect_monsters_string(cptr chars, int rad); /** @fn detect_monsters_nonliving(int rad) * @brief Detect all nonliving monsters within radius "rad" of the player.\n * @param rad Number \n rad is the radius of circle of detection. * @brief Radius * @return Boolean \n TRUE if nonliving monsters were detected, * otherwise FALSE. * @note * Detect all "nonliving", "undead" or "demonic" monsters on current panel\n\n * Nonliving monsters are either RF3_NONLIVING, RF3_UNDEAD, or RF3_DEMON. * @note (see file spells2.c) */ extern bool detect_monsters_nonliving(int rad); /** @fn detect_all(int rad) * @brief Detect everything within radius "rad" of the player.\n * @param rad Number \n rad is the radius of circle of detection. * @brief Radius * @return Boolean \n TRUE if something was detected, otherwise FALSE. * @note * Detect everything\n\n * Detects traps, doors, stairs, treasure, gold objects, normal objects, * invisible monsters, non-invisible monsters. */ extern bool detect_all(int rad); /** @fn stair_creation(void) * @brief Create stairs at the player location * @note * This is not allowed if the grid is not empty, the player is not in a * dungeon, the player is on a special level, the player is in an arena * or quest. If the player is in the town or wilderness the stairs will * go down. If the player is on a quest level or at the bottom of a * dungeon, the stairs will go up. Otherwise there is an even chance the * stairs will go up or down. */ extern void stair_creation(void); /** @fn tgt_pt (int *x=0, int *y=0) * @brief Set a target point\n * @param *x Number * @brief X-coordinate * @param *y Number * @brief Y-coordinate * @return *x Number \n X-coordinate of target. * @return *y Number \n Y-coordinate of target. * @return Boolean \n True if a target was selected, otherwise FALSE. * @note * Allow the user to move the cursor around the screen to select a target. * The user must press the space key to set the target. * @note (see file xtra2.c) */ extern bool tgt_pt (int *x=0, int *y=0); /** @fn wall_stone(int y, int x) * @brief Create a stone wall at dungeon grid ("y", "x").\n * @param y Number \n Y-coordinate of dungeon grid. * @brief Y-coordinate * @param x Number \n X-coordinate of dungeon grid. * @brief X-coordinate * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note (see file spells2.c) */ extern bool wall_stone(int y, int x); /** @fn create_artifact(object_type *o_ptr, bool a_scroll, bool get_name) * @brief Create an artifact from object "o_ptr".\n * @param *o_ptr object_type \n object to become an artifact * @brief Object * @param a_scroll Boolean \n Is a scroll used to create the artifact?\n * TRUE if the artifact is created by reading a scroll. * @brief Use scroll? * @param get_name Boolean \n Get a name for the artifact?\n * TRUE if the artifact is to be named by the player (if a_scroll is true) or * created randomly (a_scroll is false), or FALSE if an inscription is used. * @brief Get name? * @return *o_ptr object_type \n The artifact. * @return Boolean \n TRUE (always). * @note (see file randart.c) */ extern bool create_artifact(object_type *o_ptr, bool a_scroll, bool get_name); /** @fn wall_to_mud(int dir) * @brief Cast a wall-to-mud spell in direction "dir".\n * @param dir Number \n dir must be a value from 0 to 9. * @brief Direction * @return Boolean \n TRUE if player notices, otherwise FALSE. * If direction is 5 and a target has been selected, then the target is used. * Otherwise, a target is calculated based on a distance of 999 grids away * from the player in direction "dir". * @note (see file spells2.c) */ extern bool wall_to_mud(int dir); /** @fn ident_spell(void) * @brief Identify an object in the inventory (or on the floor). * @return Boolean \n TRUE if object is identified, otherwise FALSE. * @note * Identify an object in the inventory (or on the floor). * This routine does *not* automatically combine objects. * @note (see file spells2.c) */ extern bool ident_spell(void); /** @fn identify_fully(void) * @brief Fully "identify" an object in the inventory (or on the floor). * @return Boolean \n TRUE if object is identified, otherwise FALSE. * @note * Fully "identify" an object in the inventory -BEN- * @note (see file spells2.c) */ extern bool identify_fully(void); /** @fn recharge(int num) * @brief Recharge an object in the inventory (or on the floor) with "num" * power.\n * @param num Number \n num is the power used in recharging. It is compared * to the object's level to determine whether the item is recharged * successfully or destroyed. If it is recharged, it also determines * how many charges are added, or how much recharge time is reduced. * @brief Power * @return Boolean \n TRUE if something was recharged, otherwise FALSE. * @note * Recharge a wand/staff/rod from the pack or on the floor.\n * This function has been rewritten in Oangband. -LM-\n\n * Mage -- Recharge I --> recharge(90)\n * Mage -- Recharge II --> recharge(150)\n * Mage -- Recharge III --> recharge(220)\n\n * Priest or Necromancer -- Recharge --> recharge(140)\n * Scroll of recharging --> recharge(130)\n * Scroll of *recharging* --> recharge(200)\n\n * It is harder to recharge high level, and highly charged wands, * staffs, and rods. The more wands in a stack, the more easily and * strongly they recharge. Staffs, however, each get fewer charges if * stacked.\n\n * XXX XXX XXX Beware of "sliding index errors". * @note (see file spells2.c) */ extern bool recharge(int num); /** @fn aggravate_monsters(int who) * @brief Aggravate monsters, originating from "who".\n * @param who Number \n who is the index of monster in m_list[] * (1 if it is the player) which triggers the aggravation. * @brief Source * @note * Wake up all monsters, and speed up "los" monsters. * @note (see file spells2.c) */ extern void aggravate_monsters(int who); /** @fn genocide_aux(bool player_cast, char typ) * @brief Genocide a monster race.\n * @param player_cast Boolean \n player_cast is true if the player cast the * spell so the player can take damage. * @param typ Char \n typ is the letetr of the genocided monsters * @return Boolean \n TRUE if genocide was cast, otherwise FALSE. * @note * Genocide will not work on DF2_NO_GENO dungeon levels, or on "fated to * die" levels. * The player gets 4 points of damage per monster genocided. * @note (see file spells2.c) */ extern bool genocide_aux(bool player_cast, char typ); /** @fn genocide(bool player_cast) * @brief Genocide a monster race.\n * @param player_cast Boolean \n player_cast is true if the player cast the * spell so the player can take damage. * @brief Player cast spell? * @return Boolean \n TRUE if genocide was cast, otherwise FALSE. * @note * Genocide will not work on DF2_NO_GENO dungeon levels, or on "fated to * die" levels. * The player gets 4 points of damage per monster genocided. * @note (see file spells2.c) */ extern bool genocide(bool player_cast); /** @fn mass_genocide(bool player_cast) * @brief Delete all nearby (non-unique) monsters.\n * @param player_cast Boolean \n player_cast is true if the player cast the * spell so the player can take damage. * @brief Player cast spell? * @return Boolean \n TRUE (always). * @note * Genocide will not work on DF2_NO_GENO dungeon levels, or on "fated to * die" levels.\n * The player gets 3 points of damage per monster genocided. * @note (see file spells2.c) */ extern bool mass_genocide(bool player_cast); /** @fn probing(void) * @brief Probe all nearby monsters. * @return Boolean \n TRUE if probe was successful, otherwise FALSE. * @note (see file spells2.c) */ extern bool probing(void); /** @fn banish_evil(int dist) * @brief Banish nearby evil monsters doing "dist" points of GF_AWAY_EVIL * damage.\n * @param dist Number \n dist is the number of hit points of damage. * @brief Damage * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note (see file spells2.c) */ extern bool banish_evil(int dist); /** @fn dispel_evil(int dam) * @brief Dispel nearby evil monsters doing "dam" points of GF_DISP_EVIL * damage.\n * @param dam Number \n dam is the number of hit points of damage. * @brief Damage * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note (see file spells2.c) */ extern bool dispel_evil(int dam); /** @fn dispel_good(int dam) * @brief Dispel nearby good monsters doing "dam" points of GF_DISP_GOOD * damage.\n * @param dam Number \n dam is the number of hit points of damage. * @brief Damage * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note (see file spells2.c) */ extern bool dispel_good(int dam); /** @fn dispel_undead(int dam) * @brief Dispel nearby undead monsters doing "dam" points of GF_DISP_UNDEAD * damage.\n * @param dam Number \n dam is the number of hit points of damage. * @brief Damage * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note (see file spells2.c) */ extern bool dispel_undead(int dam); /** @fn dispel_monsters(int dam) * @brief Dispel all nearby monsters doing "dam" points of GF_DISP_ALL * damage.\n * @param dam Number \n dam is the number of hit points of damage. * @brief Damage * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note (see file spells2.c) */ extern bool dispel_monsters(int dam); /** @fn dispel_living(int dam) * @brief Dispel nearby living monsters doing "dam" points of GF_DISP_LIVING * damage.\n * @param dam Number \n dam is the number of hit points of damage. * @brief Damage * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note (see file spells2.c) */ extern bool dispel_living(int dam); /** @fn dispel_demons(int dam) * @brief Dispel nearby demon monsters doing "dam" points of GF_DISP_DEMON * damage.\n * @param dam Number \n dam is the number of hit points of damage. * @brief Damage * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note (see file spells2.c) */ extern bool dispel_demons(int dam); /** @fn turn_undead(void) * @brief Turn nearby undead monsters doing a point of GF_TURN_UNDEAD damage * for each player level. * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note (see file spells2.c) */ extern bool turn_undead(void); /** @fn door_creation(void) * @brief Create doors in all grids adjacent to the player. * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note (see file spells2.c) */ extern bool door_creation(void); /** @fn trap_creation(void) * @brief Create traps in all grids adjacent to the player. * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note (see file spells2.c) */ extern bool trap_creation(void); /** @fn glyph_creation(void) * @brief Create glyphs in all grids adjacent to the player. * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note (see file spells2.c) */ extern bool glyph_creation(void); /** @fn wipe(int y1, int x1, int r) * @brief Delete monsters and objects from an area of the dungeon centred at * grid "y1,x1" for a radius "r".\n * @param y1 Number \n Y-coordinate of dungeon grid. * @brief Y-coordinate * @param x1 Number \n X-coordinate of dungeon grid. * @brief X-coordinate * @param r Number \n rad is the radius of circle of detection. * @brief Radius * @note * Wipe -- Empties a part of the dungeon\n\n * This does not work on special levels or quests. The player may become * blinded. The player forgets the affected area and it becomes dark. * All grids become floor. * @note (see file spells2.c) */ extern void wipe(int y1, int x1, int r); /** @fn destroy_area(int y1, int x1, int r, bool full, bool bypass) * @brief Delete monsters and objects from an area of the dungeon centred at * grid "y1,x1" for a radius "r".\n * @param y1 Number \n Y-coordinate of dungeon grid. * @brief Y-coordinate * @param x1 Number \n X-coordinate of dungeon grid. * @brief X-coordinate * @param r Number \n rad is the radius of circle of detection. * @brief Radius * @param full Boolean \n unused * @brief *Unused* * @param bypass Boolean \n TRUE if quest levels are not destroyed, otherwise * FALSE. * @brief Exempt quest levels? * @note * The spell of destruction\n\n * This spell "deletes" monsters (instead of "killing" them).\n\n * Later we may use one function for both "destruction" and * "earthquake" by using the "full" to select "destruction".\n\n * This does not work on special levels. This does not work on quests if the * bypass flag is set. The epicentre is NOT affected. The player may become * blinded. The player forgets the affected area and it becomes dark. The * grids can become granite, quartz, magma, or floor. * @note (see file spells2.c) */ extern void destroy_area(int y1, int x1, int r, bool full, bool bypass); /** @fn earthquake(int cy, int cx, int r) * @brief Create an earthquake centred on grid "cy,cx" with a radius of "r".\n * @param cy Number \n Y-coordinate of dungeon grid. * @brief Y-coordinate * @param cx Number \n X-coordinate of dungeon grid. * @brief X-coordinate * @param r Number \n rad is the radius of circle of detection. * @brief Radius * @note * Induce an "earthquake" of the given radius at the given location.\n\n * This will turn some walls into floors and some floors into walls.\n\n * The player will take damage and "jump" into a safe grid if possible, * otherwise, he will "tunnel" through the rubble instantaneously.\n\n * Monsters will take damage, and "jump" into a safe grid if possible, * otherwise they will be "buried" in the rubble, disappearing from * the level in the same way that they do when genocided.\n\n * Note that thus the player and monsters (except eaters of walls and * passers through walls) will never occupy the same grid as a wall. * Note that as of now (2.7.8) no monster may occupy a "wall" grid, even * for a single turn, unless that monster can pass_walls or kill_walls. * This has allowed massive simplification of the "monster" code.\n\n * This does not work on quest levels. The epicentre is NOT affected. * Only about 15% of the grids are affected. The player takes 300 points * of damage if they can't be moved to a safe grid, otherwise damage is * from 10 to 40 points. The player forgets the affected area and it * becomes dark. The grids can become granite, quartz, magma, or floor. * @note (see file spells2.c) */ extern void earthquake(int cy, int cx, int r); /** @fn lite_room(int y1, int x1) * @brief Lite room containing grid "y1,x1".\n * @param y1 Number \n Y-coordinate of dungeon grid. * @brief Y-coordinate * @param x1 Number \n X-coordinate of dungeon grid. * @brief X-coordinate * @note * Illuminate any room containing the given location. * @note (see file spells2.c) */ extern void lite_room(int y1, int x1); /** @fn unlite_room(int y1, int x1) * @brief Unlite room containing grid "y1,x1".\n * @param y1 Number \n Y-coordinate of dungeon grid. * @brief Y-coordinate * @param x1 Number \n X-coordinate of dungeon grid. * @brief X-coordinate * @note * Darken all rooms containing the given location. * @note (see file spells2.c) */ extern void unlite_room(int y1, int x1); /** @fn lite_area(int dam, int rad) * @brief Lite area around player of radius "rad" causing "dam" points of * damage to monsters. * @param dam Number \n dam is the number of hit points of damage. * @brief Damage * @param rad Number \n rad is the radius of circle of lite. * @brief Radius * @return Boolean \n TRUE (always). * @note * Hack -- call light around the player\n * Affect all monsters in the projection radius\n\n * Generate a ball of spell type GF_LITE_WEAK.\n * @note (see file spells2.c) */ extern bool lite_area(int dam, int rad); /** @fn unlite_area(int dam, int rad) * @brief Unlite area around player of radius "rad" causing "dam" points of * damage to monsters. * @param dam Number \n dam is the number of hit points of damage. * @brief Damage * @param rad Number \n rad is the radius of circle of lite. * @brief Radius * @return Boolean \n TRUE (always). * @note * Hack -- call darkness around the player\n * Affect all monsters in the projection radius\n\n * Generate a ball of spell type GF_DARK_WEAK.\n * @note (see file spells2.c) */ extern bool unlite_area(int dam, int rad); /** @fn fire_ball_beam(int typ, int dir, int dam, int rad) * @brief Generate a ball spell of type "typ" with radius "rad" aimed in * direction "dir" for "dam" damage.\n * @param typ Number \n typ is the type of damage (GF field). * @brief Type * @param dir Number \n dir must be a value from 0 to 9. * @brief Direction * @param dam Number \n dam is the number of hit points of damage. * @brief Damage * @param rad Number \n rad is 0 for a beam/bolt and 1-16 for a ball. * @brief Radius * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note * Cast a ball-beamed spell\n * Stop if we hit a monster, act as a "ball"\n * Allow "target" mode to pass over monsters\n * Affect grids, objects, and monsters\n\n * If direction is 5 and a target has been selected, then the target is used. * Otherwise, a target is calculated based on a distance of 999 grids away * from the player in direction "dir".\n\n * Any radius >16 is treated as 16. * @note (see file spells2.c) */ extern bool fire_ball_beam(int typ, int dir, int dam, int rad); /** @fn make_wish(void) * @brief Allow the player to make a wish. * @note (see file xtra2.c) */ extern void make_wish(void); /** @fn fire_wave(int typ, int dir, int dam, int rad, int time, s32b eff) * @brief Generate a ball spell of type "typ" with radius "rad" and effect * "eff" lasting "time" turns aimed in direction "dir" for "dam" damage.\n * @param typ Number \n typ is the type of damage (GF field). * @brief Type * @param dir Number \n dir must be a value from 0 to 9. * @brief Direction * @param dam Number \n dam is the number of hit points of damage. * @brief Damage * @param rad Number \n rad is 0 for a beam/bolt and 1-16 for a ball. * @brief Radius * @param time Number \n time is the number of turns the spell lasts. * @brief Duration * @param eff Number \n eff is the spell effect (EFF field) * @brief Effect * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note * Cast a wave spell\n * Stop if we hit a monster, act as a "ball"\n * Allow "target" mode to pass over monsters\n * Affect grids, objects, and monsters\n\n * If direction is 5 and a target has been selected, then the target is used. * Otherwise, a target is calculated based on a distance of 999 grids away * from the player in direction "dir".\n\n * Any radius >16 is treated as 16. * @note (see file spells2.c) */ extern bool fire_wave(int typ, int dir, int dam, int rad, int time, s32b eff); /** @name Spell Effect Flags * @brief Effect of spell * @{ */ /** @def EFF_WAVE * @note A circle whose radius increase */ #define EFF_WAVE 0x00000001 /** @def EFF_LAST * @note The wave lasts */ #define EFF_LAST 0x00000002 /** @def EFF_STORM * @note the effect follows the player */ #define EFF_STORM 0x00000004 /** @name Spell Effect Direction Flags * @brief Direction of the spell * @{ */ #define EFF_DIR1 0x00000008 /* Directed effect */ #define EFF_DIR2 0x00000010 /* Directed effect */ #define EFF_DIR3 0x00000020 /* Directed effect */ #define EFF_DIR4 0x00000040 /* Directed effect */ #define EFF_DIR6 0x00000080 /* Directed effect */ #define EFF_DIR7 0x00000100 /* Directed effect */ #define EFF_DIR8 0x00000200 /* Directed effect */ #define EFF_DIR9 0x00000400 /* Directed effect */ /** @} */ /** @} */ /** @fn fire_cloud(int typ, int dir, int dam, int rad, int time) * @brief Generate a ball spell of type "typ" with radius "rad" lasting * "time" turns aimed in direction "dir" for "dam" damage.\n * @param typ Number \n typ is the type of damage (GF field). * @brief Type * @param dir Number \n dir must be a value from 0 to 9. * @brief Direction * @param dam Number \n dam is the number of hit points of damage. * @brief Damage * @param rad Number \n rad is 0 for a beam/bolt and 1-16 for a ball. * @brief Radius * @param time Number \n time is the number of turns the spell lasts. * @brief Duration * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note * Cast a cloud spell\n * Stop if we hit a monster, act as a "ball"\n * Allow "target" mode to pass over monsters\n * Affect grids, objects, and monsters\n\n * If direction is 5 and a target has been selected, then the target is used. * Otherwise, a target is calculated based on a distance of 999 grids away * from the player in direction "dir".\n\n * Any radius >16 is treated as 16. * @note (see file spells2.c) */ extern bool fire_cloud(int typ, int dir, int dam, int rad, int time); /** @fn fire_wall(int typ, int dir, int dam, int time) * @brief Generate a beam spell of type "typ" lasting "time" turns aimed in * direction "dir" for "dam" damage.\n * @param typ Number \n typ is the type of damage (GF field). * @brief Type * @param dir Number \n dir must be a value from 0 to 9. * @brief Direction * @param dam Number \n dam is the number of hit points of damage. * @brief Damage * @param time Number \n time is the number of turns the spell lasts. * @brief Duration * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note * Cast a persistant beam spell\n * Pass through monsters, as a "beam"\n * Affect monsters (not grids or objects)\n\n * If direction is 5 and a target has been selected, then the target is used. * Otherwise, a target is calculated based on a distance of 999 grids away * from the player in direction "dir". * @note (see file spells2.c) */ extern bool fire_wall(int typ, int dir, int dam, int time); /** @fn fire_ball(int typ, int dir, int dam, int rad) * @brief Generate a ball spell of type "typ" with radius "rad" aimed in * direction "dir" for "dam" damage.\n * @param typ Number \n typ is the type of damage (GF field). * @brief Type * @param dir Number \n dir must be a value from 0 to 9. * @brief Direction * @param dam Number \n dam is the number of hit points of damage. * @brief Damage * @param rad Number \n rad is 0 for a beam/bolt and 1-16 for a ball. * @brief Radius * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note * Cast a ball spell\n * Stop if we hit a monster, act as a "ball"\n * Allow "target" mode to pass over monsters\n * Affect grids, objects, and monsters\n\n * If direction is 5 and a target has been selected, then the target is used. * Otherwise, a target is calculated based on a distance of 999 grids away * from the player in direction "dir". * @note (see file spells2.c) */ extern bool fire_ball(int typ, int dir, int dam, int rad); /** @fn fire_bolt(int typ, int dir, int dam) * @brief Generate a bolt spell of type "typ" aimed in direction "dir" * for "dam" damage.\n * @param typ Number \n typ is the type of damage (GF field). * @brief Type * @param dir Number \n dir must be a value from 0 to 9. * @brief Direction * @param dam Number \n dam is the number of hit points of damage. * @brief Damage * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note * Cast a bolt spell\n * Stop if we hit a monster, as a "bolt"\n * Affect monsters (not grids or objects)\n\n * If direction is 5 and a target has been selected, then the target is used. * Otherwise, a target is calculated based on a distance of 999 grids away * from the player in direction "dir". * @note (see file spells2.c) */ extern bool fire_bolt(int typ, int dir, int dam); /** @fn fire_beam(int typ, int dir, int dam) * @brief Generate a beam spell of type "typ" aimed in direction "dir" * for "dam" damage.\n * @param typ Number \n typ is the type of damage (GF field). * @brief Type * @param dir Number \n dir must be a value from 0 to 9. * @brief Direction * @param dam Number \n dam is the number of hit points of damage. * @brief Damage * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note * Cast a beam spell\n * Pass through monsters, as a "beam"\n * Affect monsters (not grids or objects)\n\n * If direction is 5 and a target has been selected, then the target is used. * Otherwise, a target is calculated based on a distance of 999 grids away * from the player in direction "dir". * @note (see file spells2.c) */ extern bool fire_beam(int typ, int dir, int dam); /** @fn fire_druid_ball(int typ, int dir, int dam, int rad) * @brief Generate a druid ball spell of type "typ" with radius "rad" aimed in * direction "dir" for "dam" damage.\n * @param typ Number \n typ is the type of damage (GF field). * @brief Type * @param dir Number \n dir must be a value from 0 to 9. * @brief Direction * @param dam Number \n dam is the number of hit points of damage. * @brief Damage * @param rad Number \n rad is 0 for a beam/bolt and 1-16 for a ball. * @brief Radius * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note * Cast a druidistic ball spell\n * Stop if we hit a monster, act as a "ball"\n * Allow "target" mode to pass over monsters\n * Affect grids, objects, and monsters\n\n * If direction is 5 and a target has been selected, then the target is used. * Otherwise, a target is calculated based on a distance of 999 grids away * from the player in direction "dir".\n\n * The spells follows a mana path\n\n * WARNING: This routine has been deprecated. * @note (see file spells2.c) */ extern bool fire_druid_ball(int typ, int dir, int dam, int rad); /** @fn fire_druid_bolt(int typ, int dir, int dam) * @brief Generate a druid bolt spell of type "typ" aimed in direction "dir" * for "dam" damage.\n * @param typ Number \n typ is the type of damage (GF field). * @brief Type * @param dir Number \n dir must be a value from 0 to 9. * @brief Direction * @param dam Number \n dam is the number of hit points of damage. * @brief Damage * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note * Cast a druidistic bolt spell\n * Stop if we hit a monster, as a "bolt"\n * Affect monsters (not grids or objects)\n\n * If direction is 5 and a target has been selected, then the target is used. * Otherwise, a target is calculated based on a distance of 999 grids away * from the player in direction "dir".\n\n * The spells follows a mana path\n\n * WARNING: This routine has been deprecated. * @note (see file spells2.c) */ extern bool fire_druid_bolt(int typ, int dir, int dam); /** @fn fire_druid_beam(int typ, int dir, int dam) * @brief Generate a druid beam spell of type "typ" aimed in direction "dir" * for "dam" damage.\n * @param typ Number \n typ is the type of damage (GF field). * @brief Type * @param dir Number \n dir must be a value from 0 to 9. * @brief Direction * @param dam Number \n dam is the number of hit points of damage. * @brief Damage * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note * Cast a druidistic beam spell\n * Pass through monsters, as a "beam"\n * Affect monsters (not grids or objects)\n\n * If direction is 5 and a target has been selected, then the target is used. * Otherwise, a target is calculated based on a distance of 999 grids away * from the player in direction "dir".\n\n * The spells follows a mana path\n\n * WARNING: This routine has been deprecated. * @note (see file spells2.c) */ extern bool fire_druid_beam(int typ, int dir, int dam); /** @fn fire_bolt_or_beam(int prob, int typ, int dir, int dam) * @brief Generate a bolt spell of type "typ" aimed in direction "dir" * for "dam" damage with "prob" percent chance of a beam.\n * @param prob Number \n prob is the percentage chance the spell will be a * beam instead of a bolt. * @brief Beam probability percentage * @param typ Number \n typ is the type of damage (GF field). * @brief Type * @param dir Number \n dir must be a value from 0 to 9. * @brief Direction * @param dam Number \n dam is the number of hit points of damage. * @brief Damage * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note * Cast a bolt spell, or rarely, a beam spell\n\n * If direction is 5 and a target has been selected, then the target is used. * Otherwise, a target is calculated based on a distance of 999 grids away * from the player in direction "dir".\n\n * @note (see file spells2.c) */ extern bool fire_bolt_or_beam(int prob, int typ, int dir, int dam); /** @fn alchemy(void) * @brief Turns an object into gold, gain some of its value in a shop * @return Boolean \n TRUE if object turns to gold, otherwise FALSE. * @note * The player selects an object (and quantity if it applies) from the * inventory or the floor and attempts to turn it into gold. If the * price of the item is < 0 then the player gains nothing (fool's gold), * otherwise the player gets a third of the price in gold. Artifacts are * not affected. * @note (see file spells2.c) */ extern bool alchemy(void); /** @fn alter_reality(void) * @brief The player leaves the level immediately. * @note (see file spells2.c) */ extern void alter_reality(void); /** @fn swap_position(int lty, int ltx) * @brief Swap the position of the player with whatever is in grid "lty,ltx".\n * @param lty Number \n Y-coordinate of target location. * @brief Y-coordinate * @param ltx Number \n X-coordinate of target location. * @brief X-coordinate * @note * Player moves to target location. If there is a monster at the target * location, it is moved to the player location. This is not allowed if * the space-time continuum can not be disrupted. * @note (see file spells2.c) */ extern void swap_position(int lty, int ltx); /** @fn teleport_swap(int dir) * @brief Player swaps places with target in direction "dir".\n * @param dir Number \n dir must be a value from 0 to 9. * @brief Direction * @note * If direction is 5 and a target has been selected, then the target is used. * Otherwise, the target is the grid adjacent to the player in direction * "dir".\n\n * The target must be a monster. It will not work if the space-time continuum * can not be disrupted or if the monster resists teleportation. * @note (see file spells2.c) */ extern void teleport_swap(int dir); /** @fn project_meteor(int radius, int typ, int dam, u32b flg) * @brief Generate from "radius" to ("radius" x2) ball spells with properties * "flg" of type "typ" for "dam" damage.\n * @param radius Number \n rad is the minimum number of balls created. * rad + randint("rad") balls are created. * @brief Balls * @param typ Number \n typ is the type of damage (GF field). * @brief Type * @param dam Number \n dam is the number of hit points of damage. * @brief Damage * @param flg Number \n flg is the projection effect (PROJECT field). * @brief Properties flag * @note * Apply a "project()" a la meteor shower\n\n * Each ball has a radius of 2 grids. Each target grid is within 5 grids of * the player. * @note (see file spells2.c) */ extern void project_meteor(int radius, int typ, int dam, u32b flg); /** @fn passwall(int dir, bool safe) * @brief Move the player through walls in direction "dir", to a "safe" * location.\n * @param dir Number \n dir must be a value from 0 to 9. It can not be 5. * @brief Direction * @param safe Boolean \n TRUE if location must be a safe one, otherwise FALSE. * @brief Safe location? * @return Boolean \n TRUE if move was successful, otherwise FALSE. * @note * Send the player shooting through walls in the given direction until * they reach a non-wall space, or a monster, or a permanent wall.\n\n * If the player ends up in a wall, they take 10d8 damage and the wall is * replaced by a floor.\n\n * This does not work in the wilderness, on quest levels, or if teleport is * not allowed. Stopping on monsters or inside vaults is not allowed. * @note (see file spells2.c) */ extern bool passwall(int dir, bool safe); /** @fn project_hook(int typ, int dir, int dam, int flg) * @brief Generate a bolt/beam with properties "flg" in direction "dir" for * "dam" points of "typ" damage.\n * @param typ Number \n typ is the type of damage (GF field). * @brief Type * @param dir Number \n dir must be a value from 0 to 9. * @brief Direction * @param dam Number \n dam is the number of hit points of damage. * @brief Damage * @param flg Number \n flg is the projection effect (PROJECT field). * @brief Properties flag * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note * Hack -- apply a "projection()" in a direction (or at the target)\n\n * If direction is 5 and a target has been selected, then the target is used. * Otherwise, a target is calculated based on a distance of 999 grids away * from the player in direction "dir". * @note (see file spells2.c) */ extern bool project_hook(int typ, int dir, int dam, int flg); /** @fn wizard_lock(int dir) * @brief Cast a wizard_lock spell in direction "dir".\n * @param dir Number \n dir must be a value from 0 to 9. * @brief Direction * @return Boolean \n TRUE if player notices, otherwise FALSE. * If direction is 5 and a target has been selected, then the target is used. * Otherwise, a target is calculated based on a distance of 999 grids away * from the player in direction "dir". * @note (see file spells2.c) */ extern bool wizard_lock(int dir); /** @fn reset_recall(bool no_trepas_max_depth) * @brief Ask the user to set a recall level in a dungeon, possibly no * deeper than maximum dungeon depth.\n * @param no_trepas_max_depth Boolean \n TRUE if user can select maximum * dungeon depth, FALSE if user can select up to player's maximum depth * in the dungeon so far. * @brief Allow maximum dungeon depth? * @return Boolean \n TRUE of recall level was reset, otherwise FALSE. * @note * Ask the user for a dungeon and appropriate level within the dungeon.\n * The user can not specify a dungeon the player has not gone to yet.\n * If the depth is <1, reset fails. If depth is 99 or 100, the level is set * to 98. * @note (see file spells2.c) */ extern bool reset_recall(bool no_trepas_max_depth); /** @fn get_aim_dir(int *dp=0) * @brief Get an aiming direction from the user and store it in "dp".\n * @param *dp Number * @brief Direction * @return *dp Number \n Aiming direction. * @return Boolean \n TRUE if a valid direction was returned, otherwise FALSE. * @note * Get an "aiming direction" from the user.\n\n * The "dir" is loaded with 1,2,3,4,6,7,8,9 for "actual direction", and * "0" for "current target", and "-1" for "entry aborted".\n\n * Note that "Force Target", if set, will pre-empt user interaction, * if there is a usable target already set.\n\n * Note that confusion over-rides any (explicit?) user choice. * @note (see file xtra2.c) */ extern bool get_aim_dir(int *dp=0); /** @fn get_rep_dir(int *dp=0) * @brief Get a movement direction from the user and store it in "dp".\n * @param *dp Number * @brief Direction * @return *dp Number \n Movement direction. * @return Boolean \n TRUE if a valid direction was returned, otherwise FALSE. * @note * Request a "movement" direction (1,2,3,4,6,7,8,9) from the user, * and place it into "command_dir", unless we already have one.\n\n * This function should be used for all "repeatable" commands, such as * run, walk, open, close, bash, disarm, spike, tunnel, etc, as well * as all commands which must reference a grid adjacent to the player, * and which may not reference the grid under the player. Note that, * for example, it is no longer possible to "disarm" or "open" chests * in the same grid as the player.\n\n * Direction "5" is illegal and will (cleanly) abort the command.\n\n * This function tracks and uses the "global direction", and uses * that as the "desired direction", to which "confusion" is applied. * @note (see file xtra2.c) */ extern bool get_rep_dir(int *dp=0); /** @fn project_los(int typ, int dam); * @brief Generate a bolt/beam for "dam" points of "typ" damage to all * viewable monsters in line of sight.\n * @param typ Number \n typ is the type of damage (GF field). * @brief Type * @param dam Number \n dam is the number of hit points of damage. * @brief Damage * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note * Apply a "project()" directly to all viewable monsters\n\n * Note that affected monsters are NOT auto-tracked by this usage. * @note (see file spells2.c) */ extern bool project_hack @ project_los(int typ, int dam); /** @fn map_area(void) * @brief Map current area. * @note * Hack -- map the current panel (plus some) ala "magic mapping"\n\n * Up to 10 grids above and below, and up to 20 grids either side of the * panel are mapped. * @note (see file cave.c) */ extern void map_area(void); /** @fn wiz_lite(void) * @brief Lite level using "clairvoyance". * @note * This function "illuminates" every grid in the dungeon, memorizes all * "objects", memorizes all grids as with magic mapping, and, under the * standard option settings (view_perma_grids but not view_torch_grids) * memorizes all floor grids too.\n\n * Note that if "view_perma_grids" is not set, we do not memorize floor * grids, since this would defeat the purpose of "view_perma_grids", not * that anyone seems to play without this option.\n\n * Note that if "view_torch_grids" is set, we do not memorize floor grids, * since this would prevent the use of "view_torch_grids" as a method to * keep track of what grids have been observed directly. * @note (see file cave.c) */ extern void wiz_lite(void); /** @fn wiz_lite_extra(void) * @brief Lite and memorize level. * @note (see file cave.c) */ extern void wiz_lite_extra(void); /** @fn wiz_dark(void) * @brief Forget all grids and objects. * @note * Forget the dungeon map (ala "Thinking of Maud..."). * @note (see file cave.c) */ extern void wiz_dark(void); /** @fn create_between_gate(int dist, int y, int x) * @brief Create a between gate at grid "y,x" or at a target grid within * distance "dist" of the player.\n * @param dist Number \n dist is the maximum distance from the player of the * between gate. * @brief Distance * @param y Number \n Y-coordinate of dungeon grid. * @brief Y-coordinate * @param x Number \n X-coordinate of dungeon grid. * @brief X-coordinate * @note * Creates a between gate\n\n * This will fail if teleporting is not allowed on the level.\n\n * If the coordinates are given, a between gate is created under the player * and at the given coordinate.\n\n * If there are no coordinates, a target is selected. The gate will not be * created if the grid is not empty, or the grid is in a vault, or the grid * is too far away. There is always a chance (1 in (Conveyance Skill * * Conveyance Skill / 2)) the gate will not be created. * @note (see file spells2.c) */ extern void create_between_gate(int dist, int y, int x); /** @fn destroy_doors_touch(void) * @brief Destroy all doors adjacent to the player. * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note (see file spells2.c) */ extern bool destroy_doors_touch(void); /** @fn destroy_traps_touch(void) * @brief Destroy all traps adjacent to the player. * @return Boolean \n TRUE if player notices, otherwise FALSE. * @note (see file spells2.c) */ extern bool destroy_traps_touch(void); /** @struct magic_power * @brief Innate powers */ struct magic_power { /** @structvar min_lev * @brief Number */ int min_lev; /** @structvar mana_cost * @brief Number */ int mana_cost; /** @structvar fail * @brief Number */ int fail; /** @structvar name * @brief String */ cptr name; /** @structvar desc * @brief String */ cptr desc; }; /** @fn get_magic_power(magic_power *m_ptr, int num); * @dgonly * @brief Get magic power number "num" from array "m_ptr" of magic powers.\n * @param *m_ptr magic_power \n m_ptr is the array of magic powers. * @brief Powers * @param num Number \n num is the index to the array. * @brief Index * @return magic_power \n A magic power. * @note * Note: do not call this function.\n * By order of DG. * @note (see file lua_bind.c) */ extern magic_power *grab_magic_power @ get_magic_power(magic_power *m_ptr, int num); extern s16b can_spell_random(s16b spell_idx); /* Schools */ /** @struct school_spell_type * @brief Spell * @note The spell function must provide the desc */ struct spell_type@school_spell_type { /** @structvar name * @brief String */ cptr name; /** @structvar skill_level * @brief Number * @note Required level (to learn) */ byte skill_level; }; /** Get level of device */ extern s32b get_level_device(s32b s, s32b max, s32b min); /** Get level of spell */ extern s32b get_level(s32b s, s32b max, s32b min); /** @fn lua_spell_device_chance(s32b chance, int level, int base_level) * @dgonly * @brief Get the chance a device will fail.\n * @param chance Number \n chance is the inital chance a spell will work. * @brief Initial chance * @param level Number \n level represents the level of player skill. * @brief Player skill level * @param base_level Number \n *unused* * @brief *Unused* * @return Number \n Chance of failure. * @note * Note: do not call this function directly.\n * By order of DG. * @note (see file lua_bind.c) */ extern s32b lua_spell_device_chance(s32b chance, int level, int base_level); /** @fn get_school_spell(cptr do_what, cptr check_fct, s16b force_book) * @brief Get a spell from a book.\n * @param do_what String \n what the player wants to do with the spell, * for example "cast" or "copy". * @brief Action * @param check_fct String \n check_fct is the name of a function which checks * if the player has access to the spell. * @brief Check function * @param force_book Number \n If it is different from 0 it for'ces the use of * a spellbook, bypassing spellbook selection * @brief Bypass book selection * @return Number \n Spell number. * @note * Get a spell from a book\n\n * The player must have a book to select a spell. When a book is chosen, the * player is given a choice of spells to select. The player must be able to * access the spell.\n\n * If no spell is chosen, -1 is returned. * @note (see file cmd5.c) */ extern s32b get_school_spell(cptr do_what, s16b force_book); /** @fn get_pos_player(int dis, int *ny=0, int *nx=0) * @brief Get a grid near the player.\n * @param dis Number \n is the maximum distance away from the player. * This is limited to 200. * @brief Distance from player * @return y Number \n Y-coordinate of grid. * @return x Number \n X-coordinate of grid. * @note * This function is slightly obsessive about correctness.\n\n * Minimum distance is half the maximum distance. The function attempts to * find a valid grid up to 500 times. If no valid grid is found, the maximum * distance is doubled (though no more than 200) and the minimum distance is * halved. The function does this 100 times. * @note (see file spells1.c) */ extern void get_pos_player(int dis, int *ny=0, int *nx=0); /** * spells4.c */ void init_school_books(); extern s32b SCHOOL_AIR; extern s32b SCHOOL_AULE; extern s32b SCHOOL_CONVEYANCE; extern s32b SCHOOL_DEMON; extern s32b SCHOOL_DEVICE; extern s32b SCHOOL_DIVINATION; extern s32b SCHOOL_EARTH; extern s32b SCHOOL_ERU; extern s32b SCHOOL_FIRE; extern s32b SCHOOL_GEOMANCY; extern s32b SCHOOL_MANA; extern s32b SCHOOL_MANDOS; extern s32b SCHOOL_MANWE; extern s32b SCHOOL_MELKOR; extern s32b SCHOOL_META; extern s32b SCHOOL_MIND; extern s32b SCHOOL_MUSIC; extern s32b SCHOOL_NATURE; extern s32b SCHOOL_TEMPORAL; extern s32b SCHOOL_TULKAS; extern s32b SCHOOL_UDUN; extern s32b SCHOOL_ULMO; extern s32b SCHOOL_VARDA; extern s32b SCHOOL_WATER; extern s32b SCHOOL_YAVANNA; void lua_cast_school_spell @ cast_school_spell(s32b spell_idx, bool no_cost = FALSE); void spell_description_add_line(s32b spell_idx, cptr line); /** * spells5.c */ void school_spells_init(); s16b get_random_spell(s16b random_type, int lev); /** * spells6.c */ void schools_init();