server/include/player.h

/*
 * CrossFire, A Multiplayer game
 * 
 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
 * 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@schmorp.de
 */

enum bowtype_t
{
  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
};

enum petmode_t
{
  pet_normal = 0,
  pet_sad    = 1,
  pet_defend = 2,
  pet_arena  = 3,
};

enum usekeytype
{
  key_inventory = 0,
  keyrings      = 1,
  containers    = 2,
};

/* This is used to control what to do when we need to unapply
 * an object before we can apply another one.
 */
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. */
};

/* not really the player, but tied pretty closely */
INTERFACE_CLASS (partylist)
struct partylist
{
  char *ACC (RW, partyleader);
  char ACC (RW, passwd)[9];
  partylist *ACC (RW, next);
  char *ACC (RW, partyname);

  struct party_kill
  {
    char killer[MAX_NAME + 1], dead[MAX_NAME + 1];
    sint64 exp;
  } party_kills[PARTY_KILL_LOG];

  sint64 ACC (RW, total_exp);
  uint32 ACC (RW, kills);
};

INTERFACE_CLASS (player)
struct player : zero_initialised, attachable
{
  client *ACC (RO, ns);               /* Socket information for this player */
  object *ACC (RW, ob);               /* The object representing the player */
  int ACC (RO, active);

  bowtype_t ACC (RW, bowtype);        /* which firemode? */
  petmode_t ACC (RW, petmode);        /* which petmode? */
  usekeytype ACC (RW, usekeys);       /* Method for finding keys for doors */
  unapplymode ACC (RW, unapply);      /* Method for auto unapply */
  uint32 ACC (RW, count);             /* Any numbers typed before a command */
  uint32 ACC (RW, mode);              /* Mode of player for pickup. */

  sint8 ACC (RW, digestion);          /* Any bonuses/penalties to digestion */
  sint8 ACC (RW, gen_hp);             /* Bonuses to regeneration speed of hp */
  sint8 ACC (RW, gen_sp);             /* Bonuses to regeneration speed of sp */
  sint8 ACC (RW, gen_sp_armour);      /* Penalty to sp regen from armour */
  sint8 ACC (RW, gen_grace);          /* Bonuses to regeneration speed of grace */
  sint16 ACC (RW, item_power);        /* Total item power of objects equipped */
  uint8 ACC (RW, listening);          /* Which priority will be used in info_all */

  /* Try to put all the bitfields together - saves some small amount of memory */
  bool ACC (RW, braced);              /* Will not move if braced, only attack */
  bool ACC (RW, tmp_invis);           /* Will invis go away when we attack ? */
  bool ACC (RW, do_los);              /* If true, need to call update_los() in draw(), and clear */
  bool ACC (RW, fire_on);             /* Player should fire object, not move */
  bool ACC (RW, run_on);              /* Player should keep moving in dir until run is off */
  bool ACC (RW, has_hit);             /* If set, weapon_sp instead of speed will count */
  bool ACC (RW, peaceful);            /* If set, won't attack friendly creatures */
  bool ACC (RW, hidden);              /* If True, player (DM) is hidden from view */

  float ACC (RW, weapon_sp);              /* Penalties to speed when fighting w speed >ws/10 */
  living ACC (RO, orig_stats);            /* Permanent real stats of player */
  object_ptr last_skill_ob[NUM_SKILLS];   /* the exp object */
  object_ptr ACC (RW, last_used);            /* Pointer to object last picked or applied */

  object_ptr ACC (RW, combat_skill);  // which skill to use for direct attacks
  object_ptr ACC (RW, combat_ob);     // which weapon to use
  object_ptr ACC (RW, ranged_skill);  // which skill to use for ranged attacks
  object_ptr ACC (RW, ranged_ob);     // bow/spell
  object_ptr ACC (RW, golem);         // the currently controlled golem

  sint16 ACC (RW, bed_x), ACC (RW, bed_y);          /* x,y - coordinates of respawn (savebed) */
  shstr ACC (RW, savebed_map);    /* map where player will respawn after death */
  shstr ACC (RW, maplevel);       /* On which level is the player? */
  char ACC (RW, spellparam)[MAX_BUF];     /* What param to add to spells */

  char ACC (RW, own_title)[MAX_NAME];     /* Title the player has chosen for themself */
  /* Note that for dragon players, this is filled in for them */
  char ACC (RW, title)[64];         /* Default title, like fighter, wizard, etc */

  sint8 ACC (RW, levhp[11]);              /* What the player gained on that level */
  sint8 ACC (RW, levsp[11]);              /* Same for sp */
  sint8 ACC (RW, levgrace[11]);           /* And same for grace */

  char ACC (RW, killer)[64];        /* Who killed this player. */

  char write_buf[MAX_BUF];      /* Holds arbitrary input from client */ /* should go */
  char ACC (RW, password)[16];            /* 2 (seed) + 11 (crypted) + 1 (EOS) + 2 (safety) = 16 */

  partylist *ACC (RW, party);             /* Party this player is part of */
  partylist *ACC (RW, 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 */
  char ACC (RW, search_str)[MAX_BUF];     /* Item we are looking for */
  sint16 ACC (RW, encumbrance);           /* How much our player is encumbered  */
  uint16 ACC (RW, outputs_sync);          /* How often to print, no matter what */
  uint16 ACC (RW, outputs_count);         /* Print if this count is exceeded */
  object_ptr ACC (RW, mark);                 /* marked object */
  /* Special DM fields */
  tag_t *stack_items;           /* Item stack for patch/dump/... commands */
  int ACC (RW, stack_position);           /* Current stack position, 0 for no item */
  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 */

  shstr ACC (RW, invis_race);             /* What race invisible to? */

  MTH static player *create ();

  static player *load_pl (object_thawer &thawer);
  MTH static player *load_pl (const char *path);

  bool save_pl (object_freezer &freezer);
  MTH bool save_pl (const char *path);

  void do_destroy ();
  void gather_callbacks (AV *&callbacks, event_type event) const;

  // wether the player can "see" this mapspace or not, decided by los
  // 0 - nothing see, 100 - fully visible
  MTH sint8 visibility_at (maptile *map, int x, int y) const;

  MTH void connect (client *ns);
  MTH void disconnect ();

  MTH void activate ();
  MTH void deactivate ();

  // enters the initial map, after login or creation
  MTH void enter_map ();

  MTH void chargen_race_done ();
  MTH void chargen_race_next ();

  ~player ();

private:
  void set_object (object *op);
  player ();
};

typedef object_vector<player, &player::active> playervec;

extern playervec players;

#define for_all_players(var)                    \
  for (unsigned _i = 0; _i < players.size (); ++_i)     \
    declvar (player *, var, players [_i])

Revision:	1.51
Committed:	Mon Apr 30 04:25:30 2007 UTC (17 years, 1 month ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.50:	+22 -39 lines
Log Message:	This is the first rough cut of the skill use system (use the STABLE tag). Details will likely change, and combat skills do not work very well, but it works quite well. Players no longer have a shoottype or range slots, instead, each player has these members: combat_skill/combat_ob the currently selected skill (and weapon) for direct attacks. ranged_skill/ranged_ob the currently selected ranged skill (and bow/spell/item) golem the currently-controlled golem, if any.
#	User	Rev	Content
1	root	1.1	/*
2	root	1.50	* CrossFire, A Multiplayer game
3	pippijn	1.45	*
4			* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
5			* Copyright (C) 2002 Mark Wedel & Crossfire Development Team
6			* Copyright (C) 1992 Frank Tore Johansen
7			*
8			* This program is free software; you can redistribute it and/or modify
9			* it under the terms of the GNU General Public License as published by
10			* the Free Software Foundation; either version 2 of the License, or
11			* (at your option) any later version.
12			*
13			* This program is distributed in the hope that it will be useful,
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16			* GNU General Public License for more details.
17			*
18			* You should have received a copy of the GNU General Public License
19			* along with this program; if not, write to the Free Software
20			* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21			*
22			* The authors can be reached via e-mail at crossfire@schmorp.de
23			*/
24	root	1.1
25	root	1.16	enum bowtype_t
26			{
27	root	1.50	bow_normal = 0,
28			bow_threewide = 1,
29	root	1.16	bow_spreadshot = 2,
30	root	1.50	bow_n = 3, /* must stay at 3 */
31	root	1.16	bow_ne = 4,
32	root	1.50	bow_e = 5,
33	root	1.16	bow_se = 6,
34	root	1.50	bow_s = 7,
35	root	1.16	bow_sw = 8,
36	root	1.50	bow_w = 9,
37	root	1.16	bow_nw = 10, /* must stay at 10 */
38			bow_bestarrow = 11
39			};
40
41			enum petmode_t
42			{
43			pet_normal = 0,
44	root	1.50	pet_sad = 1,
45	root	1.16	pet_defend = 2,
46	root	1.50	pet_arena = 3,
47	root	1.16	};
48
49			enum usekeytype
50			{
51			key_inventory = 0,
52	root	1.50	keyrings = 1,
53			containers = 2,
54	root	1.16	};
55	root	1.1
56			/* This is used to control what to do when we need to unapply
57			* an object before we can apply another one.
58			*/
59	root	1.16	enum unapplymode
60			{
61			unapply_nochoice = 0, /* Will unapply objects when there no choice to unapply */
62			unapply_never = 1, /* will not unapply objects automatically */
63			unapply_always = 2 /* Will unapply whatever is necessary - this goes beyond */
64			/* no choice - if there are multiple ojbect of the same type */
65			/* that need to be unapplied, there is no way for the player */
66			/* to control which of these will be unapplied. */
67			};
68
69			/* not really the player, but tied pretty closely */
70	root	1.38	INTERFACE_CLASS (partylist)
71	root	1.16	struct partylist
72			{
73	root	1.38	char *ACC (RW, partyleader);
74			char ACC (RW, passwd)[9];
75			partylist *ACC (RW, next);
76			char *ACC (RW, partyname);
77	root	1.1
78	root	1.16	struct party_kill
79			{
80			char killer[MAX_NAME + 1], dead[MAX_NAME + 1];
81			sint64 exp;
82			} party_kills[PARTY_KILL_LOG];
83	root	1.38
84			sint64 ACC (RW, total_exp);
85			uint32 ACC (RW, kills);
86	root	1.16	};
87	root	1.1
88	root	1.35	INTERFACE_CLASS (player)
89			struct player : zero_initialised, attachable
90	root	1.6	{
91	root	1.51	client ACC (RO, ns); / Socket information for this player */
92			object ACC (RW, ob); / The object representing the player */
93	root	1.43	int ACC (RO, active);
94
95	root	1.51	bowtype_t ACC (RW, bowtype); /* which firemode? */
96			petmode_t ACC (RW, petmode); /* which petmode? */
97			usekeytype ACC (RW, usekeys); /* Method for finding keys for doors */
98			unapplymode ACC (RW, unapply); /* Method for auto unapply */
99			uint32 ACC (RW, count); /* Any numbers typed before a command */
100			uint32 ACC (RW, mode); /* Mode of player for pickup. */
101
102			sint8 ACC (RW, digestion); /* Any bonuses/penalties to digestion */
103			sint8 ACC (RW, gen_hp); /* Bonuses to regeneration speed of hp */
104			sint8 ACC (RW, gen_sp); /* Bonuses to regeneration speed of sp */
105			sint8 ACC (RW, gen_sp_armour); /* Penalty to sp regen from armour */
106			sint8 ACC (RW, gen_grace); /* Bonuses to regeneration speed of grace */
107			sint16 ACC (RW, item_power); /* Total item power of objects equipped */
108			uint8 ACC (RW, listening); /* Which priority will be used in info_all */
109	root	1.16
110			/* Try to put all the bitfields together - saves some small amount of memory */
111	root	1.43	bool ACC (RW, braced); /* Will not move if braced, only attack */
112			bool ACC (RW, tmp_invis); /* Will invis go away when we attack ? */
113			bool ACC (RW, do_los); /* If true, need to call update_los() in draw(), and clear */
114			bool ACC (RW, fire_on); /* Player should fire object, not move */
115			bool ACC (RW, run_on); /* Player should keep moving in dir until run is off */
116			bool ACC (RW, has_hit); /* If set, weapon_sp instead of speed will count */
117			bool ACC (RW, peaceful); /* If set, won't attack friendly creatures */
118			bool ACC (RW, hidden); /* If True, player (DM) is hidden from view */
119	root	1.16
120	root	1.18	float ACC (RW, weapon_sp); /* Penalties to speed when fighting w speed >ws/10 */
121			living ACC (RO, orig_stats); /* Permanent real stats of player */
122	root	1.44	object_ptr last_skill_ob[NUM_SKILLS]; /* the exp object */
123	root	1.18	object_ptr ACC (RW, last_used); /* Pointer to object last picked or applied */
124	root	1.16
125	root	1.51	object_ptr ACC (RW, combat_skill); // which skill to use for direct attacks
126			object_ptr ACC (RW, combat_ob); // which weapon to use
127			object_ptr ACC (RW, ranged_skill); // which skill to use for ranged attacks
128			object_ptr ACC (RW, ranged_ob); // bow/spell
129			object_ptr ACC (RW, golem); // the currently controlled golem
130
131	root	1.18	sint16 ACC (RW, bed_x), ACC (RW, bed_y); /* x,y - coordinates of respawn (savebed) */
132	root	1.39	shstr ACC (RW, savebed_map); /* map where player will respawn after death */
133			shstr ACC (RW, maplevel); /* On which level is the player? */
134	root	1.18	char ACC (RW, spellparam)[MAX_BUF]; /* What param to add to spells */
135	root	1.16
136	root	1.18	char ACC (RW, own_title)[MAX_NAME]; /* Title the player has chosen for themself */
137	root	1.16	/* Note that for dragon players, this is filled in for them */
138	root	1.19	char ACC (RW, title)[64]; /* Default title, like fighter, wizard, etc */
139	root	1.16
140	root	1.34	sint8 ACC (RW, levhp[11]); /* What the player gained on that level */
141			sint8 ACC (RW, levsp[11]); /* Same for sp */
142			sint8 ACC (RW, levgrace[11]); /* And same for grace */
143	root	1.16
144	root	1.19	char ACC (RW, killer)[64]; /* Who killed this player. */
145	root	1.16
146	root	1.31	char write_buf[MAX_BUF]; /* Holds arbitrary input from client / / should go */
147	root	1.18	char ACC (RW, password)[16]; /* 2 (seed) + 11 (crypted) + 1 (EOS) + 2 (safety) = 16 */
148	root	1.1
149	root	1.18	partylist ACC (RW, party); / Party this player is part of */
150			partylist ACC (RW, party_to_join); / used when player wants to join a party */
151	root	1.16	/* but we will have to get password first */
152			/* so we have to remember which party to */
153			/* join */
154	root	1.18	char ACC (RW, search_str)[MAX_BUF]; /* Item we are looking for */
155			sint16 ACC (RW, encumbrance); /* How much our player is encumbered */
156			uint16 ACC (RW, outputs_sync); /* How often to print, no matter what */
157			uint16 ACC (RW, outputs_count); /* Print if this count is exceeded */
158			object_ptr ACC (RW, mark); /* marked object */
159	root	1.16	/* Special DM fields */
160			tag_t stack_items; / Item stack for patch/dump/... commands */
161	root	1.18	int ACC (RW, stack_position); /* Current stack position, 0 for no item */
162			sint8 blocked_los[MAP_CLIENT_X][MAP_CLIENT_Y]; /* array showing what spaces */
163	root	1.32	/* the player can see. For maps smaller than */
164			/* MAP_CLIENT_.., the upper left is used */
165	root	1.16
166	root	1.31	shstr ACC (RW, invis_race); /* What race invisible to? */
167	root	1.13
168	root	1.36	MTH static player *create ();
169	root	1.43
170			static player *load_pl (object_thawer &thawer);
171			MTH static player load_pl (const char path);
172
173			bool save_pl (object_freezer &freezer);
174			MTH bool save_pl (const char *path);
175
176	root	1.35	void do_destroy ();
177			void gather_callbacks (AV *&callbacks, event_type event) const;
178	root	1.31
179	root	1.46	// wether the player can "see" this mapspace or not, decided by los
180			// 0 - nothing see, 100 - fully visible
181			MTH sint8 visibility_at (maptile *map, int x, int y) const;
182
183	root	1.36	MTH void connect (client *ns);
184			MTH void disconnect ();
185	root	1.31
186	root	1.43	MTH void activate ();
187			MTH void deactivate ();
188
189	root	1.37	// enters the initial map, after login or creation
190			MTH void enter_map ();
191
192	root	1.48	MTH void chargen_race_done ();
193			MTH void chargen_race_next ();
194
195	root	1.31	~player ();
196
197			private:
198			void set_object (object *op);
199			player ();
200	root	1.16	};
201	root	1.13
202	root	1.43	typedef object_vector<player, &player::active> playervec;
203
204			extern playervec players;
205
206			#define for_all_players(var) \
207	pippijn	1.47	for (unsigned _i = 0; _i < players.size (); ++_i) \
208	root	1.43	declvar (player *, var, players [_i])
209