--- deliantra/server/common/player.C 2006/09/14 22:34:00 1.5 +++ deliantra/server/common/player.C 2008/09/08 11:30:53 1.42 @@ -1,64 +1,27 @@ /* - 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 -*/ + * This file is part of Deliantra, the Roguelike Realtime MMORPG. + * + * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team + * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team + * Copyright (©) 1992,2007 Frank Tore Johansen + * + * Deliantra 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 . + * + * The authors can be reached via e-mail to + */ #include -#include - -void -free_player (player *pl) -{ - - if (first_player != pl) - { - player *prev = first_player; - - while (prev != NULL && prev->next != NULL && prev->next != pl) - prev = prev->next; - if (prev->next != pl) - { - LOG (llevError, "Free_player: Can't find previous player.\n"); - exit (1); - } - prev->next = pl->next; - } - else - first_player = pl->next; - - if (pl->ob != NULL) - { - if (!QUERY_FLAG (pl->ob, FLAG_REMOVED)) - remove_ob (pl->ob); - free_object (pl->ob); - } - /* Clear item stack */ - if (pl->stack_items) - free (pl->stack_items); - - free (pl->socket.faces_sent); - - delete pl; -} - /* Determine if the attacktype represented by the * specified attack-number is enabled for dragon players. @@ -71,6 +34,7 @@ if (attacknr == ATNR_MAGIC || attacknr == ATNR_FIRE || attacknr == ATNR_ELECTRICITY || attacknr == ATNR_COLD || attacknr == ATNR_ACID || attacknr == ATNR_POISON) return 1; + return 0; } @@ -81,7 +45,409 @@ int is_dragon_pl (const object *op) { - if (op != NULL && op->type == PLAYER && op->arch != NULL && op->arch->clone.race != NULL && strcmp (op->arch->clone.race, "dragon") == 0) + 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 (hintmode); + PL_OUT (gen_hp); + PL_OUT (gen_sp); + PL_OUT (gen_grace); + 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_hintmode: f.get (pl->hintmode); break; + case KW_listening: /*TODO*/; 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; +} + +const char * +player::killer_name () const +{ + static char buf [2048]; + + if (!killer) + return "a dungeon collapse"; + else if (killer->contr) + snprintf (buf, sizeof (buf), "%s the %s", &killer->name, + *killer->contr->own_title ? killer->contr->own_title : killer->contr->title); + else if (killer->type == DEEP_SWAMP) + snprintf (buf, sizeof (buf), "drowning in a %s", &killer->name); + else if (killer->owner) + snprintf (buf, sizeof (buf), "%s's %s", &killer->outer_owner ()->name, &killer->name); + else + return &killer->name; + + return buf; +} + +// expand one level of cfpod +// end == -1, till eos +// end == 0, one level of '>' +// end >= 1, this many levels of " >>>" +static const char * +expand_cfpod (const player *pl, dynbuf_text &buf, const char *cfpod, int end) +{ + static dynbuf_text nest(128, 128); + + for (;;) + switch (char ch = *cfpod++) + { + case 0: + return cfpod - 1; + + case ' ': + if (end <= 0) + goto passthrough; + + for (int i = 0; i < end; ++i) + if (cfpod [i] != '>') + goto passthrough; + + return cfpod + end; + + case '>': + if (end) + { + buf << ">"; + break; + } + + return cfpod; + + case '&': + buf << "&"; + break; + + case '<': + buf << "<"; + break; + + case '\r': + buf << '\n'; + break; + + case '\n': + if (*cfpod == ' ') + goto passthrough; + else if (*cfpod == '\n') + { + --cfpod; + do + buf << *cfpod++; + while (*cfpod == '\n'); + } + else + buf << ' '; + + break; + + case 'B': case 'C': case 'E': case 'G': + case 'H': case 'I': case 'T': case 'U': + case 'Z': + { + int len = 0; + + while (cfpod [len] == '<') + ++len; + + if (!len) + goto passthrough; + + if (len == 1 || cfpod [len] != ' ') + { + len = 0; + ++cfpod; + } + else + cfpod += len + 1; + + const char *pfx, *sfx; + + switch (ch) + { + case 'B': pfx = "" ; sfx = "" ; break; + case 'C': pfx = "" ; sfx = "" ; break; + case 'E': pfx = "&" ; sfx = ";" ; break; + case 'I': pfx = "" ; sfx = "" ; break; + case 'U': pfx = "" ; sfx = "" ; break; + case 'T': pfx = ""; sfx = ""; break; + + case 'H': // hint + { + if (pl->hintmode) + { + cfpod = expand_cfpod (pl, nest, cfpod, len); + nest.clear (); + + if (pl->hintmode == 1) + buf << "[Hint suppressed, see hintmode]"; + else + while (*cfpod == ' ') // eat trailing whitespace + ++cfpod; + + goto skip; + } + else + { + pfx = "["; + sfx = " (Use hintmode to suppress hints)]"; + } + } + break; + + case 'G': // gender + { + expand_cfpod (pl, nest, cfpod, len); + nest << '\0'; // zero-terminate + + const char *str = nest.linearise (); + const char *sep = strchr (str, '|'); + + if (sep) + { + if (pl->gender || 1) + buf.add (sep + 1, nest.size () - (sep - str) - 2); + else + buf.add (str, sep - str); + } + + nest.clear (); + + goto skip; + } + } + + buf << pfx; + cfpod = expand_cfpod (pl, buf, cfpod, len); + buf << sfx; + } + + break; + + default: + passthrough: + buf << ch; + skip: + break; + } +} + +dynbuf_text * +player::expand_cfpod (const char *cfpod) const +{ + static dynbuf_text buf(1024, 1024); + buf.clear (); + + ::expand_cfpod (this, buf, cfpod, -1); + + return &buf; +} +