actor.h Source File

00001 #ifndef ACTOR_H
00002 #define ACTOR_H
00003 
00004 #include "los_def.h"
00005 
00006 enum ev_ignore_type
00007 {
00008     EV_IGNORE_NONE       = 0,
00009     EV_IGNORE_HELPLESS   = 1,
00010     EV_IGNORE_PHASESHIFT = 2,
00011 };
00012 
00013 struct bolt;
00014 
00015 class actor
00016 {
00017 public:
00018     virtual ~actor();
00019 
00020     monster_type type;
00021     mid_t        mid;
00022     virtual int       mindex() const = 0;
00023     virtual actor_type atype() const = 0;
00024 
00025     virtual bool is_player() const
00026     {
00027         return atype() == ACT_PLAYER;
00028     }
00029     virtual monster* as_monster() = 0;
00030     virtual player* as_player() = 0;
00031     virtual const monster* as_monster() const = 0;
00032     virtual const player* as_player() const = 0;
00033 
00034     virtual kill_category kill_alignment() const = 0;
00035     virtual god_type  deity() const = 0;
00036 
00037     virtual bool      alive() const = 0;
00038 
00039     virtual bool is_summoned(int* duration = NULL,
00040                              int* summon_type = NULL) const = 0;
00041 
00042     // [ds] Low-level moveto() - moves the actor without updating relevant
00043     // grids, such as mgrd.
00044     virtual void moveto(const coord_def &c) = 0;
00045 
00046     // High-level actor movement. If in doubt, use this. Returns false if the
00047     // actor cannot be moved to the target, possibly because it is already
00048     // occupied.
00049     virtual bool move_to_pos(const coord_def &c) = 0;
00050 
00051     virtual void apply_location_effects(const coord_def &oldpos,
00052                                         killer_type killer = KILL_NONE,
00053                                         int killernum = -1) = 0;
00054 
00055     virtual void set_position(const coord_def &c);
00056     virtual const coord_def& pos() const { return position; }
00057 
00058     // Blink the actor to the destination. c should be a
00059     // valid target, though the method returns false
00060     // if the blink fails.
00061     virtual bool blink_to(const coord_def &c, bool quiet = false) = 0;
00062 
00063     virtual bool      swimming() const = 0;
00064     virtual bool      submerged() const = 0;
00065     virtual bool      floundering() const = 0;
00066 
00067     // Returns true if the actor is exceptionally well balanced.
00068     virtual bool      extra_balanced() const = 0;
00069 
00070     virtual int       get_experience_level() const = 0;
00071 
00072     virtual bool can_pass_through_feat(dungeon_feature_type grid) const = 0;
00073     virtual bool can_pass_through(int x, int y) const;
00074     virtual bool can_pass_through(const coord_def &c) const;
00075 
00076     virtual bool is_habitable_feat(dungeon_feature_type actual_grid) const = 0;
00077             bool is_habitable(const coord_def &pos) const;
00078 
00079     virtual size_type body_size(size_part_type psize = PSIZE_TORSO,
00080                                 bool base = false) const = 0;
00081     virtual int       body_weight(bool base = false) const;
00082     virtual int       total_weight() const = 0;
00083 
00084     virtual int       damage_brand(int which_attack = -1) = 0;
00085     virtual int       damage_type(int which_attack = -1) = 0;
00086     virtual item_def *weapon(int which_attack = -1) = 0;
00087     // Yay for broken overloading.
00088     const item_def *primary_weapon() const
00089     {
00090         return const_cast<actor*>(this)->weapon(0);
00091     }
00092     virtual item_def *shield() = 0;
00093     virtual item_def *slot_item(equipment_type eq,
00094                                 bool include_melded=false) = 0;
00095     // Just a wrapper; not to be overridden
00096     const item_def *slot_item(equipment_type eq,
00097                               bool include_melded=false) const
00098     {
00099         return const_cast<actor*>(this)->slot_item(eq, include_melded);
00100     }
00101     virtual bool has_equipped(equipment_type eq, int sub_type) const;
00102 
00103             bool can_wield(const item_def* item,
00104                            bool ignore_curse = false,
00105                            bool ignore_brand = false,
00106                            bool ignore_shield = false,
00107                            bool ignore_transform = false) const;
00108     virtual bool can_wield(const item_def &item,
00109                            bool ignore_curse = false,
00110                            bool ignore_brand = false,
00111                            bool ignore_shield = false,
00112                            bool ignore_transform = false) const = 0;
00113     virtual bool could_wield(const item_def &item,
00114                              bool ignore_brand = false,
00115                              bool ignore_transform = false) const = 0;
00116 
00117     virtual int hunger_level() const { return HS_ENGORGED; }
00118     virtual void make_hungry(int nutrition, bool silent = true)
00119     {
00120     }
00121 
00122     // Need not be implemented for the player - player action costs
00123     // are explicitly calculated.
00124     virtual void lose_energy(energy_use_type, int div = 1, int mult = 1)
00125     {
00126     }
00127 
00128     virtual std::string name(description_level_type type,
00129                              bool force_visible = false) const = 0;
00130     virtual std::string pronoun(pronoun_type which_pronoun,
00131                                 bool force_visible = false) const = 0;
00132     virtual std::string conj_verb(const std::string &verb) const = 0;
00133     virtual std::string hand_name(bool plural,
00134                                   bool *can_plural = NULL) const = 0;
00135     virtual std::string foot_name(bool plural,
00136                                   bool *can_plural = NULL) const = 0;
00137     virtual std::string arm_name(bool plural,
00138                                  bool *can_plural = NULL) const = 0;
00139 
00140     virtual bool fumbles_attack(bool verbose = true) = 0;
00141 
00142     // Returns true if the actor has no way to attack (plants, statues).
00143     // (statues have only indirect attacks).
00144     virtual bool cannot_fight() const = 0;
00145     virtual void attacking(actor *other) = 0;
00146     virtual bool can_go_berserk() const = 0;
00147     virtual void go_berserk(bool intentional, bool potion = false) = 0;
00148     virtual bool berserk() const = 0;
00149     virtual bool can_see_invisible() const = 0;
00150     virtual bool invisible() const = 0;
00151 
00152     // Would looker be able to see the actor when in LOS?
00153     virtual bool visible_to(const actor *looker) const = 0;
00154 
00155     // Is the given cell within LOS of the actor?
00156     virtual bool see_cell(const coord_def &c) const;
00157     virtual bool see_cell_no_trans(const coord_def &c) const;
00158 
00159     virtual const los_base* get_los();
00160     virtual const los_base* get_los_no_trans();
00161 
00162     // Can the actor actually see the target?
00163     virtual bool can_see(const actor *target) const;
00164 
00165     // Visibility as required by messaging. In usual play:
00166     //   Does the player know what's happening to the actor?
00167     virtual bool observable() const;
00168 
00169     virtual bool is_icy() const = 0;
00170     virtual bool is_fiery() const = 0;
00171     virtual bool is_skeletal() const = 0;
00172     virtual bool has_lifeforce() const = 0;
00173     virtual bool can_mutate() const = 0;
00174     virtual bool can_safely_mutate() const = 0;
00175     virtual bool can_bleed() const = 0;
00176     virtual bool mutate() = 0;
00177     virtual bool drain_exp(actor *agent, bool quiet = false, int pow = 3) = 0;
00178     virtual bool rot(actor *agent, int amount, int immediate = 0,
00179                      bool quiet = false) = 0;
00180     virtual int  hurt(const actor *attacker, int amount,
00181                       beam_type flavour = BEAM_MISSILE,
00182                       bool cleanup_dead = true) = 0;
00183     virtual bool heal(int amount, bool max_too = false) = 0;
00184     virtual void banish(const std::string &who = "") = 0;
00185     virtual void blink(bool allow_partial_control = true) = 0;
00186     virtual void teleport(bool right_now = false,
00187                           bool abyss_shift = false,
00188                           bool wizard_tele = false) = 0;
00189     virtual void poison(actor *attacker, int amount = 1, bool force = false) = 0;
00190     virtual bool sicken(int amount) = 0;
00191     virtual void paralyse(actor *attacker, int strength) = 0;
00192     virtual void petrify(actor *attacker, int strength) = 0;
00193     virtual void slow_down(actor *attacker, int strength) = 0;
00194     virtual void confuse(actor *attacker, int strength) = 0;
00195     virtual void put_to_sleep(actor *attacker, int strength) = 0;
00196     virtual void expose_to_element(beam_type element, int strength = 0) = 0;
00197     virtual void drain_stat(stat_type stat, int amount, actor* attacker) { }
00198     virtual bool can_hibernate(bool holi_only = false) const;
00199     virtual bool can_sleep() const;
00200     virtual void hibernate(int power = 0) = 0;
00201     virtual void check_awaken(int disturbance) = 0;
00202     virtual int beam_resists(bolt &beam, int hurted, bool doEffects,
00203                              std::string source = "") = 0;
00204 
00205     virtual int  skill(skill_type sk, bool skill_bump = false) const
00206     {
00207         return (0);
00208     }
00209 
00210     virtual int stat_hp() const = 0;
00211     virtual int stat_maxhp() const = 0;
00212 
00213     virtual bool can_throw_large_rocks() const = 0;
00214 
00215     virtual int armour_class() const = 0;
00216     virtual int melee_evasion(const actor *attacker,
00217                               ev_ignore_type ign = EV_IGNORE_NONE) const = 0;
00218     virtual int shield_bonus() const = 0;
00219     virtual int shield_block_penalty() const = 0;
00220     virtual int shield_bypass_ability(int tohit) const = 0;
00221 
00222     virtual void shield_block_succeeded(actor *foe);
00223 
00224     virtual int mons_species() const = 0;
00225 
00226     virtual mon_holy_type holiness() const = 0;
00227     virtual bool undead_or_demonic() const = 0;
00228     virtual bool is_holy() const = 0;
00229     virtual bool is_unholy() const = 0;
00230     virtual bool is_evil() const = 0;
00231     virtual bool is_chaotic() const = 0;
00232     virtual bool is_artificial() const = 0;
00233     virtual bool is_unbreathing() const = 0;
00234     virtual bool is_insubstantial() const = 0;
00235     virtual int res_acid() const = 0;
00236     virtual int res_fire() const = 0;
00237     virtual int res_holy_fire() const;
00238     virtual int res_steam() const = 0;
00239     virtual int res_cold() const = 0;
00240     virtual int res_elec() const = 0;
00241     virtual int res_poison(bool temp = true) const = 0;
00242     virtual int res_rotting(bool temp = true) const = 0;
00243     virtual int res_asphyx() const = 0;
00244     virtual int res_water_drowning() const = 0;
00245     virtual int res_sticky_flame() const = 0;
00246     virtual int res_holy_energy(const actor *attacker) const = 0;
00247     virtual int res_negative_energy() const = 0;
00248     virtual int res_torment() const = 0;
00249     virtual int res_wind() const = 0;
00250     virtual int res_magic() const = 0;
00251     virtual int check_res_magic(int power);
00252 
00253     virtual flight_type flight_mode() const = 0;
00254     virtual bool is_levitating() const = 0;
00255     virtual bool is_wall_clinging() const = 0;
00256     virtual bool can_cling_to(const coord_def& p) const = 0;
00257     virtual bool airborne() const;
00258 
00259     virtual bool paralysed() const = 0;
00260     virtual bool cannot_move() const = 0;
00261     virtual bool cannot_act() const = 0;
00262     virtual bool confused() const = 0;
00263     virtual bool caught() const = 0;
00264     virtual bool asleep() const { return (false); }
00265 
00266     // check_haloed: include halo
00267     // self_halo: include own halo (actually if self_halo = false
00268     //            and has a halo, returns false; so if you have a
00269     //            halo you're not affected by others' halos for this
00270     //            purpose)
00271     virtual bool backlit(bool check_haloed = true,
00272                          bool self_halo = true) const = 0;
00273     // Within any actor's halo?
00274     virtual bool haloed() const;
00275     // Squared halo radius.
00276     virtual int halo_radius2() const = 0;
00277     // Squared silence radius.
00278     virtual int silence_radius2() const = 0;
00279     // Squared liquefying radius
00280     virtual int liquefying_radius2 () const = 0;
00281     virtual bool glows_naturally() const = 0;
00282 
00283     virtual bool petrified() const = 0;
00284 
00285     virtual bool handle_trap();
00286 
00287     virtual void god_conduct(conduct_type thing_done, int level) { }
00288 
00289     virtual bool incapacitated() const
00290     {
00291         return cannot_move() || asleep() || confused() || caught();
00292     }
00293 
00294     virtual int warding() const
00295     {
00296         return (0);
00297     }
00298 
00299     virtual bool has_spell(spell_type spell) const = 0;
00300 
00301     virtual bool     will_trigger_shaft() const;
00302     virtual level_id shaft_dest(bool known) const;
00303     virtual bool     do_shaft() = 0;
00304 
00305     coord_def position;
00306 
00307 protected:
00308     // These are here for memory management reasons...
00309     los_glob los;
00310     los_glob los_no_trans;
00311 };
00312 
00313 // Identical to actor->kill_alignment(), but returns KC_OTHER if the actor
00314 // is NULL.
00315 kill_category actor_kill_alignment(const actor *actor);
00316 bool actor_slime_wall_immune(const actor *actor);
00317 
00318 #endif