server/common/player.C

/*
 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
 * 
 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
 * Copyright (©) 1992,2007 Frank Tore Johansen
 * 
 * Crossfire TRT 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 3 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, see <http://www.gnu.org/licenses/>.
 * 
 * The authors can be reached via e-mail to <crossfire@schmorp.de>
 */

#include <global.h>
#include <funcpoint.h>

/* Determine if the attacktype represented by the
 * specified attack-number is enabled for dragon players.
 * A dragon player (quetzal) can gain resistances for
 * all enabled attacktypes.
 */
int
atnr_is_dragon_enabled (int attacknr)
{
  if (attacknr == ATNR_MAGIC || attacknr == ATNR_FIRE ||
      attacknr == ATNR_ELECTRICITY || attacknr == ATNR_COLD || attacknr == ATNR_ACID || attacknr == ATNR_POISON)
    return 1;

  return 0;
}

/*
 * returns true if the adressed object 'ob' is a player
 * of the dragon race.
 */
int
is_dragon_pl (const object *op)
{
  if (op
      && op->type == PLAYER
      && op->arch
      && op->arch->race
      && !strcmp (op->arch->race, "dragon"))
    return 1;

  return 0;
}

/*
 * If final is set, it a clean/final save, not a backup, ie dont remove objects from inventory
 */
bool
player::save_pl (object_freezer &freezer)
{
  INVOKE_PLAYER (SAVE, ob->contr);

  int wiz = ob->flag [FLAG_WIZ];

  /* Eneq(@csd.uu.se): If we have an open container hide it. */
  object *container = ob->container;
  ob->container = 0;

  if (ob->map)
    maplevel = ob->map->path;

#define PL_OUT(k)    freezer.put (KW_ ## k, k)
#define PL_OUT2(k,v) freezer.put (KW_ ## k, v)

  PL_OUT  (password);
  PL_OUT2 (title, own_title);
  PL_OUT  (gender);
  PL_OUT  (gen_hp);
  PL_OUT  (gen_sp);
  PL_OUT  (gen_grace);
  PL_OUT  (listening);
  PL_OUT  (bowtype);
  PL_OUT  (petmode);
  PL_OUT  (peaceful);
  PL_OUT  (digestion);
  PL_OUT2 (pickup, mode);
  PL_OUT  (outputs_sync);
  PL_OUT  (outputs_count);

  freezer.put (KW_usekeys, usekeys == key_inventory    ? "key_inventory"    : (usekeys == keyrings      ? "keyrings"      : "containers"));
  freezer.put (KW_unapply, unapply == unapply_nochoice ? "unapply_nochoice" : (unapply == unapply_never ? "unapply_never" : "unapply_always"));

  PL_OUT2 (map, maplevel);
  PL_OUT  (savebed_map);
  PL_OUT  (bed_x);
  PL_OUT  (bed_y);
  PL_OUT  (weapon_sp);
  PL_OUT  (weapon_sp_left);
  PL_OUT2 (Str, orig_stats.Str);
  PL_OUT2 (Dex, orig_stats.Dex);
  PL_OUT2 (Con, orig_stats.Con);
  PL_OUT2 (Int, orig_stats.Int);
  PL_OUT2 (Pow, orig_stats.Pow);
  PL_OUT2 (Wis, orig_stats.Wis);
  PL_OUT2 (Cha, orig_stats.Cha);

  PL_OUT2 (lev_array, 10);

  for (int i = 1; i <= 10; i++)
    {
      freezer.add (levhp   [i]); freezer.add ('\n');
      freezer.add (levsp   [i]); freezer.add ('\n');
      freezer.add (levgrace[i]); freezer.add ('\n');
    }

  freezer.put (ob->contr);
  freezer.put (KW_endplst);

  SET_FLAG (ob, FLAG_NO_FIX_PLAYER);
  CLEAR_FLAG (ob, FLAG_WIZ);
  ob->write (freezer);

  CLEAR_FLAG (ob, FLAG_NO_FIX_PLAYER);

  /* Eneq(@csd.uu.se): Reveal the container if we have one. */
  ob->container = container;

  ob->flag [FLAG_WIZ] = wiz;

  INVOKE_PLAYER (SAVE_DONE, ob->contr);

  return true;
}

bool
player::save_pl (const char *path)
{
  object_freezer freezer;

  if (!save_pl (freezer))
    return false;

  return freezer.save (path);
}

player *
player::load_pl (object_thawer &f)
{
  int maxerrs = 20;

  player *pl = new player;

  pl->savebed_map = first_map_path;

  /* Loop through the file, loading the rest of the values */
  for (;;)
    {
      switch (f.kw)
        {
          case KW_EOF:
            LOG (llevError, "%s: unexpected EOF while reading player header\n", f.name);
            goto failure;

          default:
            LOG (llevError, "%s: skipping unknown key in player header: %s\n", f.name, f.kw_str);
            if (!--maxerrs) goto failure;
            break;

          case KW_ERROR:
            LOG (llevError, "%s: parse error while reading player header, skipping (%s,%s).\n", f.name, f.kw_str, f.value);
            if (!--maxerrs) goto failure;
            break;

          case KW_endplst:
            f.next ();

            if (object *op = pl->ob->read (f))
              pl->set_object (op);
            else
              goto failure;

            INVOKE_PLAYER (LOAD, pl);

            return pl;

          case KW_oid:           f.get (pl, f.get_sint32 ()); break;
          case KW_password:      assign (pl->password , f.get_str ()); break;
          case KW_title:         assign (pl->own_title, f.get_str ()); break;
          case KW_bowtype:       pl->bowtype   = (bowtype_t) f.get_sint32 (); break;
          case KW_petmode:       pl->petmode   = (petmode_t) f.get_sint32 (); break;
          case KW_gender:        f.get (pl->gender); break;
          case KW_listening:     f.get (pl->listening); break;
          case KW_peaceful:      f.get (pl->peaceful); break;
          case KW_digestion:     f.get (pl->digestion); break;
          case KW_pickup:        f.get (pl->mode); break;
          case KW_outputs_sync:  f.get (pl->outputs_sync); break;
          case KW_outputs_count: f.get (pl->outputs_count); break;
          case KW_map:           f.get (pl->maplevel); break;
          case KW_savebed_map:   f.get (pl->savebed_map); break;
          case KW_bed_x:         f.get (pl->bed_x); break;
          case KW_bed_y:         f.get (pl->bed_y); break;
          case KW_weapon_sp:     f.get (pl->weapon_sp); break;
          case KW_weapon_sp_left:f.get (pl->weapon_sp_left); break;
          case KW_Str:           f.get (pl->orig_stats.Str); break;
          case KW_Dex:           f.get (pl->orig_stats.Dex); break;
          case KW_Con:           f.get (pl->orig_stats.Con); break;
          case KW_Int:           f.get (pl->orig_stats.Int); break;
          case KW_Pow:           f.get (pl->orig_stats.Pow); break;
          case KW_Wis:           f.get (pl->orig_stats.Wis); break;
          case KW_Cha:           f.get (pl->orig_stats.Cha); break;
          case KW_gen_hp:        f.get (pl->gen_hp); break;
          case KW_gen_sp:        f.get (pl->gen_sp); break;
          case KW_gen_grace:     f.get (pl->gen_grace); break;

          case KW_usekeys:
            if (!strcmp (f.get_str (), "key_inventory"))
              pl->usekeys = key_inventory;
            else if (!strcmp (f.get_str (), "keyrings"))
              pl->usekeys = keyrings;
            else if (!strcmp (f.get_str (), "containers"))
              pl->usekeys = containers;
            else
              LOG (llevDebug, "load_player: got unknown usekeys type: %s\n", f.get_str ());
            break;

          case KW_unapply:
            if (!strcmp (f.get_str (), "unapply_nochoice"))
              pl->unapply = unapply_nochoice;
            else if (!strcmp (f.get_str (), "unapply_never"))
              pl->unapply = unapply_never;
            else if (!strcmp (f.get_str (), "unapply_always"))
              pl->unapply = unapply_always;
            else
              LOG (llevDebug, "load_player: got unknown unapply type: %s\n", f.get_str ());
            break;

          case KW_lev_array:
            {
              int count = f.get_sint32 ();

              for (int i = 1; i <= count; i++)
                {
                  char line [32];

                  fgets (line, 32, f); pl->levhp   [i] = atoi (line);
                  fgets (line, 32, f); pl->levsp   [i] = atoi (line);
                  fgets (line, 32, f); pl->levgrace[i] = atoi (line);
                }
            }
            break;
        }

      f.next ();
    }

failure:
  LOG (llevError, "%s: too many or too grave errors, aborting player load.\n", f.name);

  if (pl->ob)
    pl->ob->destroy ();

  pl->destroy ();

  return 0;
}

player *
player::load_pl (const char *path)
{
  object_thawer f (path);

  if (!f)
    return 0;

  f.next ();

  return load_pl (f);
}

Revision:	1.33
Committed:	Sun Jul 1 05:00:17 2007 UTC (16 years, 10 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.32:	+11 -12 lines
Log Message:	- upgrade crossfire trt to the GPL version 3 (hopefully correctly). - add a single file covered by the GNU Affero General Public License (which is not yet released, so I used the current draft, which is legally a bit wavy, but its likely better than nothing as it expresses direct intent by the authors, and we can upgrade as soon as it has been released). * this should ensure availability of source code for the server at least and hopefully also archetypes and maps even when modified versions are not being distributed, in accordance of section 13 of the agplv3.
#	Content
1	/*
2	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
3	*
4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*
8	* Crossfire TRT 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 3 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, see <http://www.gnu.org/licenses/>.
20	*
21	* The authors can be reached via e-mail to <crossfire@schmorp.de>
22	*/
23
24	#include <global.h>
25	#include <funcpoint.h>
26
27	/* Determine if the attacktype represented by the
28	* specified attack-number is enabled for dragon players.
29	* A dragon player (quetzal) can gain resistances for
30	* all enabled attacktypes.
31	*/
32	int
33	atnr_is_dragon_enabled (int attacknr)
34	{
35	if (attacknr == ATNR_MAGIC \|\| attacknr == ATNR_FIRE \|\|
36	attacknr == ATNR_ELECTRICITY \|\| attacknr == ATNR_COLD \|\| attacknr == ATNR_ACID \|\| attacknr == ATNR_POISON)
37	return 1;
38
39	return 0;
40	}
41
42	/*
43	* returns true if the adressed object 'ob' is a player
44	* of the dragon race.
45	*/
46	int
47	is_dragon_pl (const object *op)
48	{
49	if (op
50	&& op->type == PLAYER
51	&& op->arch
52	&& op->arch->race
53	&& !strcmp (op->arch->race, "dragon"))
54	return 1;
55
56	return 0;
57	}
58
59	/*
60	* If final is set, it a clean/final save, not a backup, ie dont remove objects from inventory
61	*/
62	bool
63	player::save_pl (object_freezer &freezer)
64	{
65	INVOKE_PLAYER (SAVE, ob->contr);
66
67	int wiz = ob->flag [FLAG_WIZ];
68
69	/* Eneq(@csd.uu.se): If we have an open container hide it. */
70	object *container = ob->container;
71	ob->container = 0;
72
73	if (ob->map)
74	maplevel = ob->map->path;
75
76	#define PL_OUT(k) freezer.put (KW_ ## k, k)
77	#define PL_OUT2(k,v) freezer.put (KW_ ## k, v)
78
79	PL_OUT (password);
80	PL_OUT2 (title, own_title);
81	PL_OUT (gender);
82	PL_OUT (gen_hp);
83	PL_OUT (gen_sp);
84	PL_OUT (gen_grace);
85	PL_OUT (listening);
86	PL_OUT (bowtype);
87	PL_OUT (petmode);
88	PL_OUT (peaceful);
89	PL_OUT (digestion);
90	PL_OUT2 (pickup, mode);
91	PL_OUT (outputs_sync);
92	PL_OUT (outputs_count);
93
94	freezer.put (KW_usekeys, usekeys == key_inventory ? "key_inventory" : (usekeys == keyrings ? "keyrings" : "containers"));
95	freezer.put (KW_unapply, unapply == unapply_nochoice ? "unapply_nochoice" : (unapply == unapply_never ? "unapply_never" : "unapply_always"));
96
97	PL_OUT2 (map, maplevel);
98	PL_OUT (savebed_map);
99	PL_OUT (bed_x);
100	PL_OUT (bed_y);
101	PL_OUT (weapon_sp);
102	PL_OUT (weapon_sp_left);
103	PL_OUT2 (Str, orig_stats.Str);
104	PL_OUT2 (Dex, orig_stats.Dex);
105	PL_OUT2 (Con, orig_stats.Con);
106	PL_OUT2 (Int, orig_stats.Int);
107	PL_OUT2 (Pow, orig_stats.Pow);
108	PL_OUT2 (Wis, orig_stats.Wis);
109	PL_OUT2 (Cha, orig_stats.Cha);
110
111	PL_OUT2 (lev_array, 10);
112
113	for (int i = 1; i <= 10; i++)
114	{
115	freezer.add (levhp [i]); freezer.add ('\n');
116	freezer.add (levsp [i]); freezer.add ('\n');
117	freezer.add (levgrace[i]); freezer.add ('\n');
118	}
119
120	freezer.put (ob->contr);
121	freezer.put (KW_endplst);
122
123	SET_FLAG (ob, FLAG_NO_FIX_PLAYER);
124	CLEAR_FLAG (ob, FLAG_WIZ);
125	ob->write (freezer);
126
127	CLEAR_FLAG (ob, FLAG_NO_FIX_PLAYER);
128
129	/* Eneq(@csd.uu.se): Reveal the container if we have one. */
130	ob->container = container;
131
132	ob->flag [FLAG_WIZ] = wiz;
133
134	INVOKE_PLAYER (SAVE_DONE, ob->contr);
135
136	return true;
137	}
138
139	bool
140	player::save_pl (const char *path)
141	{
142	object_freezer freezer;
143
144	if (!save_pl (freezer))
145	return false;
146
147	return freezer.save (path);
148	}
149
150	player *
151	player::load_pl (object_thawer &f)
152	{
153	int maxerrs = 20;
154
155	player *pl = new player;
156
157	pl->savebed_map = first_map_path;
158
159	/* Loop through the file, loading the rest of the values */
160	for (;;)
161	{
162	switch (f.kw)
163	{
164	case KW_EOF:
165	LOG (llevError, "%s: unexpected EOF while reading player header\n", f.name);
166	goto failure;
167
168	default:
169	LOG (llevError, "%s: skipping unknown key in player header: %s\n", f.name, f.kw_str);
170	if (!--maxerrs) goto failure;
171	break;
172
173	case KW_ERROR:
174	LOG (llevError, "%s: parse error while reading player header, skipping (%s,%s).\n", f.name, f.kw_str, f.value);
175	if (!--maxerrs) goto failure;
176	break;
177
178	case KW_endplst:
179	f.next ();
180
181	if (object *op = pl->ob->read (f))
182	pl->set_object (op);
183	else
184	goto failure;
185
186	INVOKE_PLAYER (LOAD, pl);
187
188	return pl;
189
190	case KW_oid: f.get (pl, f.get_sint32 ()); break;
191	case KW_password: assign (pl->password , f.get_str ()); break;
192	case KW_title: assign (pl->own_title, f.get_str ()); break;
193	case KW_bowtype: pl->bowtype = (bowtype_t) f.get_sint32 (); break;
194	case KW_petmode: pl->petmode = (petmode_t) f.get_sint32 (); break;
195	case KW_gender: f.get (pl->gender); break;
196	case KW_listening: f.get (pl->listening); break;
197	case KW_peaceful: f.get (pl->peaceful); break;
198	case KW_digestion: f.get (pl->digestion); break;
199	case KW_pickup: f.get (pl->mode); break;
200	case KW_outputs_sync: f.get (pl->outputs_sync); break;
201	case KW_outputs_count: f.get (pl->outputs_count); break;
202	case KW_map: f.get (pl->maplevel); break;
203	case KW_savebed_map: f.get (pl->savebed_map); break;
204	case KW_bed_x: f.get (pl->bed_x); break;
205	case KW_bed_y: f.get (pl->bed_y); break;
206	case KW_weapon_sp: f.get (pl->weapon_sp); break;
207	case KW_weapon_sp_left:f.get (pl->weapon_sp_left); break;
208	case KW_Str: f.get (pl->orig_stats.Str); break;
209	case KW_Dex: f.get (pl->orig_stats.Dex); break;
210	case KW_Con: f.get (pl->orig_stats.Con); break;
211	case KW_Int: f.get (pl->orig_stats.Int); break;
212	case KW_Pow: f.get (pl->orig_stats.Pow); break;
213	case KW_Wis: f.get (pl->orig_stats.Wis); break;
214	case KW_Cha: f.get (pl->orig_stats.Cha); break;
215	case KW_gen_hp: f.get (pl->gen_hp); break;
216	case KW_gen_sp: f.get (pl->gen_sp); break;
217	case KW_gen_grace: f.get (pl->gen_grace); break;
218
219	case KW_usekeys:
220	if (!strcmp (f.get_str (), "key_inventory"))
221	pl->usekeys = key_inventory;
222	else if (!strcmp (f.get_str (), "keyrings"))
223	pl->usekeys = keyrings;
224	else if (!strcmp (f.get_str (), "containers"))
225	pl->usekeys = containers;
226	else
227	LOG (llevDebug, "load_player: got unknown usekeys type: %s\n", f.get_str ());
228	break;
229
230	case KW_unapply:
231	if (!strcmp (f.get_str (), "unapply_nochoice"))
232	pl->unapply = unapply_nochoice;
233	else if (!strcmp (f.get_str (), "unapply_never"))
234	pl->unapply = unapply_never;
235	else if (!strcmp (f.get_str (), "unapply_always"))
236	pl->unapply = unapply_always;
237	else
238	LOG (llevDebug, "load_player: got unknown unapply type: %s\n", f.get_str ());
239	break;
240
241	case KW_lev_array:
242	{
243	int count = f.get_sint32 ();
244
245	for (int i = 1; i <= count; i++)
246	{
247	char line [32];
248
249	fgets (line, 32, f); pl->levhp [i] = atoi (line);
250	fgets (line, 32, f); pl->levsp [i] = atoi (line);
251	fgets (line, 32, f); pl->levgrace[i] = atoi (line);
252	}
253	}
254	break;
255	}
256
257	f.next ();
258	}
259
260	failure:
261	LOG (llevError, "%s: too many or too grave errors, aborting player load.\n", f.name);
262
263	if (pl->ob)
264	pl->ob->destroy ();
265
266	pl->destroy ();
267
268	return 0;
269	}
270
271	player *
272	player::load_pl (const char *path)
273	{
274	object_thawer f (path);
275
276	if (!f)
277	return 0;
278
279	f.next ();
280
281	return load_pl (f);
282	}
283