260 lines
12 KiB
C
260 lines
12 KiB
C
/*
|
|
* static char *rcsid_player_h =
|
|
* "$Id: player.h 11578 2009-02-23 22:02:27Z lalo $";
|
|
*/
|
|
|
|
/*
|
|
CrossFire, A Multiplayer game for X-windows
|
|
|
|
Copyright (C) 2002 Mark Wedel & Crossfire Development Team
|
|
Copyright (C) 1992 Frank Tore Johansen
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
The authors can be reached via e-mail at crossfire-devel@real-time.com
|
|
*/
|
|
|
|
/**
|
|
* @file
|
|
* Player-specific structures.
|
|
*/
|
|
|
|
#ifndef PLAYER_H
|
|
#define PLAYER_H
|
|
|
|
/** How many output buffers a player has. */
|
|
#define NUM_OUTPUT_BUFS 5
|
|
/** One output buffer. */
|
|
typedef struct {
|
|
const char *buf; /**< Actual string pointer. */
|
|
uint32 first_update; /**< First time this message was stored. */
|
|
uint16 count; /**< How many times we got this message. */
|
|
} Output_Buf;
|
|
|
|
/**
|
|
* What range is currntly selected by the player.
|
|
*
|
|
* Wand/rod/horn rolled into range_misc. They all use the same body location
|
|
* anyways.
|
|
*/
|
|
typedef enum rangetype {
|
|
range_bottom = -1,
|
|
range_none = 0,
|
|
range_bow = 1,
|
|
range_magic = 2,
|
|
range_misc = 3,
|
|
range_golem = 4,
|
|
range_skill = 5,
|
|
range_builder = 6,
|
|
range_size = 7
|
|
} rangetype;
|
|
|
|
/** Bow firing mode. @todo document. */
|
|
typedef enum _bowtype {
|
|
bow_normal = 0,
|
|
bow_threewide = 1,
|
|
bow_spreadshot = 2,
|
|
bow_n = 3, /* must stay at 3 */
|
|
bow_ne = 4,
|
|
bow_e = 5,
|
|
bow_se = 6,
|
|
bow_s = 7,
|
|
bow_sw = 8,
|
|
bow_w = 9,
|
|
bow_nw = 10, /* must stay at 10 */
|
|
bow_bestarrow = 11,
|
|
bow_precise = 12
|
|
} bowtype_t;
|
|
|
|
/** Petmode. @todo document. */
|
|
typedef enum _petmode {
|
|
pet_normal = 0,
|
|
pet_sad = 1,
|
|
pet_defend = 2,
|
|
pet_arena = 3
|
|
} petmode_t;
|
|
|
|
/** How to use keys. @todo document. */
|
|
typedef enum usekeytype {
|
|
key_inventory = 0,
|
|
keyrings = 1,
|
|
containers = 2
|
|
} usekeytype;
|
|
|
|
/**
|
|
* This is used to control what to do when we need to unapply
|
|
* an object before we can apply another one.
|
|
*/
|
|
typedef enum unapplymode {
|
|
unapply_nochoice = 0, /**< Will unapply objects when there no choice to unapply. */
|
|
unapply_never = 1, /**< Will not unapply objects automatically. */
|
|
unapply_always = 2 /**< Will unapply whatever is necessary - this goes beyond
|
|
* no choice - if there are multiple ojbect of the same type
|
|
* that need to be unapplied, there is no way for the player
|
|
* to control which of these will be unapplied. */
|
|
} unapplymode;
|
|
|
|
/**
|
|
* This stores, for a spell a player knows, the last sp/gr/dam information sent to client.
|
|
*/
|
|
typedef struct client_spell {
|
|
object *spell;
|
|
sint16 last_sp;
|
|
sint16 last_grace;
|
|
sint16 last_dam;
|
|
struct client_spell *next;
|
|
} client_spell;
|
|
|
|
/** One party. First item is ::firstparty. */
|
|
typedef struct party_struct {
|
|
char *partyleader; /**< Who is the leader. */
|
|
char passwd[9]; /**< Party password. */
|
|
struct party_struct *next; /**< Next party in list. */
|
|
char *partyname; /**< Party name. */
|
|
|
|
#ifdef PARTY_KILL_LOG
|
|
struct party_kill {
|
|
char killer[MAX_NAME+1], dead[MAX_NAME+1];
|
|
sint64 exp;
|
|
} party_kills[PARTY_KILL_LOG];
|
|
#endif
|
|
sint64 total_exp;
|
|
uint32 kills;
|
|
} partylist;
|
|
|
|
/**
|
|
* Whether to rejoin party at login or not.
|
|
*/
|
|
typedef enum party_rejoin_mode {
|
|
party_rejoin_no = 0, /**< Don't rejoin. */
|
|
party_rejoin_if_exists = 1, /**< Rejoin if party exists. */
|
|
party_rejoin_always = 2 /**< If party doesn't exist, form it. */
|
|
} party_rejoin_mode;
|
|
|
|
/** One player. */
|
|
typedef struct pl {
|
|
struct pl *next; /**< Pointer to next player, NULL if this is last. */
|
|
socket_struct socket; /**< Socket information for this player. See the page on
|
|
* @ref page_connection "the login process" for a description of its use. */
|
|
char maplevel[MAX_BUF]; /**< On which level is the player? */
|
|
char savebed_map[MAX_BUF]; /**< Map where player will respawn after death. */
|
|
sint16 bed_x, bed_y; /**< x,y - coordinates of respawn (savebed). */
|
|
rangetype shoottype; /**< Which range-attack is being used by player. */
|
|
char spellparam[MAX_BUF]; /**< What param to add to spells. */
|
|
bowtype_t bowtype; /**< Which firemode? */
|
|
petmode_t petmode; /**< Which petmode? */
|
|
object *ranges[range_size]; /**< Object for each range. Set up in fix_object(). Note
|
|
* That not all are used, it is just nice to map this 1:1
|
|
* With the range names. */
|
|
uint32 golem_count; /**< To track the golem. */
|
|
usekeytype usekeys; /**< Method for finding keys for doors. */
|
|
unapplymode unapply; /**< Method for auto unapply. */
|
|
uint32 count; /**< Any numbers typed before a command. */
|
|
uint32 mode; /**< Mode of player for pickup. */
|
|
|
|
sint16 digestion; /**< Any bonuses/penalties to digestion. */
|
|
sint16 gen_hp; /**< Bonuses to regeneration speed of hp. */
|
|
sint16 gen_sp; /**< Bonuses to regeneration speed of sp. */
|
|
sint16 gen_sp_armour; /**< Penalty to sp regen from armour. */
|
|
sint16 gen_grace; /**< Bonuses to regeneration speed of grace. */
|
|
sint16 item_power; /**< Total item power of objects equipped. */
|
|
uint8 state; /**< Input state of the player (name, password, etc). See the page on
|
|
* @ref page_connection "the login process" for a description of its use. */
|
|
uint8 listening; /**< Which priority will be used in info_all. */
|
|
sint8 last_level; /**< Last level we sent to client. */
|
|
|
|
/* Try to put all the bitfields together - saves some small amount of memory */
|
|
uint32 braced:1; /**< Will not move if braced, only attack. */
|
|
uint32 tmp_invis:1; /**< Will invis go away when we attack? */
|
|
uint32 do_los:1; /**< If true, need to call update_los() in draw(), and clear. */
|
|
uint32 fire_on:1; /**< Player should fire object, not move. */
|
|
uint32 run_on:1; /**< Player should keep moving in dir until run is off. */
|
|
uint32 has_hit:1; /**< If set, weapon_sp instead of speed will count. */
|
|
uint32 name_changed:1; /**< If true, the player has set a name. */
|
|
uint32 peaceful:1; /**< If set, won't attack friendly creatures. */
|
|
uint32 hidden:1; /**< If True, player (DM) is hidden from view. */
|
|
uint32 explore:1; /**< if True, player is in explore mode. */
|
|
uint32 no_shout:1; /**< if True, player is *not *able to use shout command. */
|
|
const char *invis_race; /**< What race invisible to? */
|
|
|
|
object *last_skill_ob[NUM_SKILLS]; /**< Exp objects sent to client. */
|
|
sint64 last_skill_exp[NUM_SKILLS]; /**< Last exp sent to client. If != exp. obj update client. */
|
|
|
|
float weapon_sp; /**< Penalties to speed when fighting w speed >ws/10. */
|
|
float last_weapon_sp; /**< if diff than weapon_sp, update client. */
|
|
uint16 last_flags; /**< Fire/run on flags for last tick. */
|
|
sint32 last_weight; /**< Last weight as sent to client; -1 means do not send weight. */
|
|
sint32 last_weight_limit; /**< Last weight limit transmitted to client. */
|
|
uint32 last_path_attuned; /**< Last spell attunment sent to client. */
|
|
uint32 last_path_repelled; /**< Last spell repelled sent to client. */
|
|
uint32 last_path_denied; /**< Last spell denied sent to client. */
|
|
int Swap_First; /**< First stat player has selected to swap. */
|
|
living orig_stats; /**< Permanent real stats of player. */
|
|
living last_stats; /**< Last stats as sent to client. */
|
|
float last_speed; /**< Last speed as sent to client. */
|
|
sint16 last_resist[NROFATTACKS]; /**< last resist values sent to client. */
|
|
object *ob; /**< The object representing the player. */
|
|
object *last_used; /**< Pointer to object last picked or applied. */
|
|
uint32 last_used_id; /**< Safety measures to be sure it's the same. */
|
|
sint8 blocked_los[MAP_CLIENT_X][MAP_CLIENT_Y]; /**< Array showing what spaces
|
|
* the player can see. For maps smaller than
|
|
* MAP_CLIENT_.., the upper left is used. */
|
|
|
|
char own_title[MAX_NAME]; /**< Title the player has chosen for themself.
|
|
* Note that for dragon players, this is filled in for them. */
|
|
char title[BIG_NAME]; /**< Default title, like fighter, wizard, etc. */
|
|
|
|
sint8 levhp[11]; /**< What hp bonus the player gained on that level. */
|
|
sint8 levsp[11]; /**< What sp bonus the player gained on that level. */
|
|
sint8 levgrace[11]; /**< What grace bonus the player gained on that level. */
|
|
|
|
char killer[BIG_NAME]; /**< Who killed this player. */
|
|
char last_tell[MAX_NAME]; /**< last player that told you something [mids 01/14/2002]. */
|
|
|
|
char write_buf[MAX_BUF]; /**< Holds arbitrary input from client. */
|
|
char input_buf[MAX_BUF]; /**< Holds command to run. */
|
|
char password[16]; /**< 2 (seed) + 11 (crypted) + 1 (EOS) + 2 (safety) = 16 */
|
|
char new_password[16]; /**< 2 (seed) + 11 (crypted) + 1 (EOS) + 2 (safety) = 16 */
|
|
|
|
sint16 encumbrance; /**< How much our player is encumbered. */
|
|
#ifdef SAVE_INTERVAL
|
|
time_t last_save_time; /**< Last time the player was saved. */
|
|
#endif /* SAVE_INTERVAL */
|
|
#ifdef AUTOSAVE
|
|
uint32 last_save_tick; /**< Last tick the player was saved. */
|
|
#endif
|
|
partylist *party; /**< Party this player is part of. */
|
|
partylist *party_to_join; /**< Used when player wants to join a party
|
|
* but we will have to get password first
|
|
* so we have to remember which party to
|
|
* join. */
|
|
party_rejoin_mode rejoin_party; /**< Whether to rejoin or not party at login. */
|
|
char search_str[MAX_BUF]; /**< Item we are looking for. */
|
|
Output_Buf outputs[NUM_OUTPUT_BUFS]; /**< Holds output strings to send to client. */
|
|
uint16 outputs_sync; /**< How often to print, no matter what. */
|
|
uint16 outputs_count; /**< Print if this count is exceeded. */
|
|
uint32 mark_count; /**< Count of marked object. */
|
|
object *mark; /**< Marked object. */
|
|
object *transport; /**< Transport the player is in. */
|
|
client_spell *spell_state; /**< Spell information sent to client. */
|
|
/* Special DM fields */
|
|
tag_t *stack_items; /**< Item stack for patch/dump/... commands. */
|
|
sstring followed_player; /**< Player the DM is following. */
|
|
int stack_position; /**< Current stack position, 0 for no item. */
|
|
int language; /**< The language the player wishes to use. */
|
|
} player;
|
|
|
|
#endif /* PLAYER_H */
|