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 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.
#	Content
1	/*
2	* CrossFire, A Multiplayer game
3	*
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
25	enum bowtype_t
26	{
27	bow_normal = 0,
28	bow_threewide = 1,
29	bow_spreadshot = 2,
30	bow_n = 3, /* must stay at 3 */
31	bow_ne = 4,
32	bow_e = 5,
33	bow_se = 6,
34	bow_s = 7,
35	bow_sw = 8,
36	bow_w = 9,
37	bow_nw = 10, /* must stay at 10 */
38	bow_bestarrow = 11
39	};
40
41	enum petmode_t
42	{
43	pet_normal = 0,
44	pet_sad = 1,
45	pet_defend = 2,
46	pet_arena = 3,
47	};
48
49	enum usekeytype
50	{
51	key_inventory = 0,
52	keyrings = 1,
53	containers = 2,
54	};
55
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	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	INTERFACE_CLASS (partylist)
71	struct partylist
72	{
73	char *ACC (RW, partyleader);
74	char ACC (RW, passwd)[9];
75	partylist *ACC (RW, next);
76	char *ACC (RW, partyname);
77
78	struct party_kill
79	{
80	char killer[MAX_NAME + 1], dead[MAX_NAME + 1];
81	sint64 exp;
82	} party_kills[PARTY_KILL_LOG];
83
84	sint64 ACC (RW, total_exp);
85	uint32 ACC (RW, kills);
86	};
87
88	INTERFACE_CLASS (player)
89	struct player : zero_initialised, attachable
90	{
91	client ACC (RO, ns); / Socket information for this player */
92	object ACC (RW, ob); / The object representing the player */
93	int ACC (RO, active);
94
95	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
110	/* Try to put all the bitfields together - saves some small amount of memory */
111	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
120	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	object_ptr last_skill_ob[NUM_SKILLS]; /* the exp object */
123	object_ptr ACC (RW, last_used); /* Pointer to object last picked or applied */
124
125	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	sint16 ACC (RW, bed_x), ACC (RW, bed_y); /* x,y - coordinates of respawn (savebed) */
132	shstr ACC (RW, savebed_map); /* map where player will respawn after death */
133	shstr ACC (RW, maplevel); /* On which level is the player? */
134	char ACC (RW, spellparam)[MAX_BUF]; /* What param to add to spells */
135
136	char ACC (RW, own_title)[MAX_NAME]; /* Title the player has chosen for themself */
137	/* Note that for dragon players, this is filled in for them */
138	char ACC (RW, title)[64]; /* Default title, like fighter, wizard, etc */
139
140	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
144	char ACC (RW, killer)[64]; /* Who killed this player. */
145
146	char write_buf[MAX_BUF]; /* Holds arbitrary input from client / / should go */
147	char ACC (RW, password)[16]; /* 2 (seed) + 11 (crypted) + 1 (EOS) + 2 (safety) = 16 */
148
149	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	/* but we will have to get password first */
152	/* so we have to remember which party to */
153	/* join */
154	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	/* Special DM fields */
160	tag_t stack_items; / Item stack for patch/dump/... commands */
161	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	/* the player can see. For maps smaller than */
164	/* MAP_CLIENT_.., the upper left is used */
165
166	shstr ACC (RW, invis_race); /* What race invisible to? */
167
168	MTH static player *create ();
169
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	void do_destroy ();
177	void gather_callbacks (AV *&callbacks, event_type event) const;
178
179	// 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	MTH void connect (client *ns);
184	MTH void disconnect ();
185
186	MTH void activate ();
187	MTH void deactivate ();
188
189	// enters the initial map, after login or creation
190	MTH void enter_map ();
191
192	MTH void chargen_race_done ();
193	MTH void chargen_race_next ();
194
195	~player ();
196
197	private:
198	void set_object (object *op);
199	player ();
200	};
201
202	typedef object_vector<player, &player::active> playervec;
203
204	extern playervec players;
205
206	#define for_all_players(var) \
207	for (unsigned _i = 0; _i < players.size (); ++_i) \
208	declvar (player *, var, players [_i])
209