[ViewVC] Diff of: cvs/deliantra/server/server/player.C

Comparing deliantra/server/server/player.C (file contents):
Revision 1.235 by root, Wed Nov 4 17:24:00 2009 UTC vs.
Revision 1.243 by root, Sat Nov 7 18:30:06 2009 UTC

  * <http://www.gnu.org/licenses/>.
  *
  * The authors can be reached via e-mail to <support@deliantra.net>
  */
+//+GPL
 #include <global.h>
 #include <sproto.h>
 #include <sounds.h>
 #include <living.h>
 #include <object.h>
   observe = viewpoint = ob;
   deactivate ();
 }
+//-GPL
 // the need for this function can be explained
 // by load_object not returning the object
 void
 player::set_object (object *op)
 {
 {
   viewpoint = op ? op : (object *)observe;
   do_los = 1;
 }
+//+GPL
 player::player ()
 {
   /* There are some elements we want initialised to non zero value -
    * we deal with that below this point.
    */
 {
   /* Clear item stack */
   free (stack_items);
 }
+/*
+ * get_player_archetype() return next player archetype from archetype
+ * list. Not very efficient routine, but used only creating new players.
+ * Note: there MUST be at least one player archetype!
+ */
+static archetype *
+get_player_archetype (archetype *at)
+{
+  // archetypes could have been reloaded
+  archetype *nat = at ? archetype::find (at->archname) : archetypes [0];
+  if (!nat)
+    return at;
+  archvec::iterator i = archetypes.find (nat);
+  for (;;)
+    {
+      if (++i == archetypes.end ())
+        i = archetypes.begin ();
+      else if (*i == at)
+        cleanup ("not a single player archetype found");
+      if ((*i)->type == PLAYER)
+        return *i;
+    }
+}
 /* Tries to add player on the connection passed in ns.
  * All we can really get in this is some settings like host and display
  * mode.
  */
 player *
   pl->ob->run_away = 25;            /* Then we panick... */
   set_first_map (pl->ob);
   return pl;
-}
-/*
- * get_player_archetype() return next player archetype from archetype
- * list. Not very efficient routine, but used only creating new players.
- * Note: there MUST be at least one player archetype!
- */
-archetype *
-get_player_archetype (archetype *at)
-{
-  // archetypes could have been reloaded
-  archetype *nat = at ? archetype::find (at->archname) : archetypes [0];
-  if (!nat)
-    return at;
-  archvec::iterator i = archetypes.find (nat);
-  for (;;)
-    {
-      if (++i == archetypes.end ())
-        i = archetypes.begin ();
-      else if (*i == at)
-        cleanup ("not a single player archetype found");
-      if ((*i)->type == PLAYER)
-        return *i;
-    }
 }
 object *
 get_nearest_player (object *mon)
 {
 player::chargen_race_done ()
 {
   /* this must before then initial items are given */
   esrv_new_player (ob->contr);
-  treasurelist *tl = treasurelist::find ("starting_wealth");
+  treasurelist *tl = treasurelist::find (shstr_starting_wealth);
   if (tl)
     create_treasure (tl, ob, 0, 0, 0);
   INVOKE_PLAYER (BIRTH, ob->contr);
   INVOKE_PLAYER (LOGIN, ob->contr);
   ob->stats.hp = ob->stats.maxhp;
   ob->stats.sp = ob->stats.maxsp;
   ob->stats.grace = 0;
 }
-void
+static void
 flee_player (object *op)
 {
   int dir, diff;
   rv_vector rv;
       if (op->contr->mode & PU_DEBUG)
         {
           /* some debugging code to figure out item information */
           const char *str = tmp->name
             ? format ("item name: %s    item type: %d    weight/value: %d",
-                      &tmp->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))))
+                      &tmp->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * max (tmp->nrof, 1))))
             : format ("item name: %s    item type: %d    weight/value: %d",
-                      &tmp->arch->archname, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))));
+                      &tmp->arch->archname, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * max (tmp->nrof, 1))));
           new_draw_info (NDI_UNIQUE, 0, op, str);
         }
       if (op->contr->mode & PU_INHIBIT)
                   fprintf (stderr, "%s", tmp->name);
                 }
               else
                 fprintf (stderr, "%s", tmp->arch->archname);
               fprintf (stderr, ",%d] = ", tmp->type);
-              fprintf (stderr, "%d\n", (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))));
+              fprintf (stderr, "%d\n", (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * max (tmp->nrof, 1))));
 #endif
               CHK_PICK_PICKUP;
               continue;
             }
         }                       /* the new pickup model */
     }
   return !stop;
 }
+/* routine for both players and monsters. We call this when
+ * there is a possibility for our action distrubing our hiding
+ * place or invisiblity spell. Artefact invisiblity causes
+ * "noise" instead. If we arent invisible to begin with, we
+ * return 0.
+ */
+static int
+action_makes_visible (object *op)
+{
+  if (op->invisible && QUERY_FLAG (op, FLAG_ALIVE))
+    {
+      if (QUERY_FLAG (op, FLAG_MAKE_INVIS))
+        {
+          // artefact invisibility is permanent, but we still make noise
+          // this is important for game-balance.
+          if (op->contr)
+            op->make_noise ();
+          return 0;
+        }
+      if (op->contr && op->contr->tmp_invis == 0)
+        return 0;
+      /* If monsters, they should become visible */
+      if (op->flag [FLAG_HIDDEN] || !op->contr || (op->contr && op->contr->tmp_invis))
+        {
+          new_draw_info_format (NDI_UNIQUE, 0, op, "You become %s!", op->flag [FLAG_HIDDEN] ? "unhidden" : "visible");
+          return 1;
+        }
+    }
+  return 0;
+}
 /*
  *  Find an arrow in the inventory and after that
  *  in the right type container (quiver). Pointer to the
  *  found object is returned.
  */
-object *
+static object *
 find_arrow (object *op, const char *type)
 {
   for (object *tmp = op->inv; tmp; tmp = tmp->below)
     if (tmp->type == ARROW && !strcmp (&tmp->race, type))
       return splay (tmp);
  * Similar to find_arrow, but looks for (roughly) the best arrow to use
  * against the target.  A full test is not performed, simply a basic test
  * of resistances.  The archer is making a quick guess at what he sees down
  * the hall.  Failing that it does it's best to pick the highest plus arrow.
  */
-object *
+static object *
 find_better_arrow (object *op, object *target, shstr_cmp type, int *better)
 {
   object *tmp = NULL, *arrow, *ntmp;
   int attacknum, attacktype, betterby = 0, i;
  * find_better_arrow to find a decent arrow to use.
  * op = the shooter
  * type = bow->race
  * dir = fire direction
  */
-object *
+static object *
 pick_arrow_target (object *op, shstr_cmp type, int dir)
 {
   object *tmp = NULL;
   maptile *m;
   int i, mflags, found, number;
  * but monsters can't.  Putting that code here
  * makes the fire_bow code much cleaner.
  * this function should only be called if 'op' is a player,
  * hence the function name.
  */
-int
+static int
 player_fire_bow (object *op, int dir)
 {
   int ret;
   if (op->contr->bowtype == bow_bestarrow)
 }
 /* Fires a misc (wand/rod/horn) object in 'dir'.
  * Broken apart from 'fire' to keep it more readable.
  */
-void
+static void
 fire_misc_object (object *op, int dir)
 {
   object *item = op->contr->ranged_ob;
   if (!item)
           return;
         }
     }
   else if (item->type == ROD || item->type == HORN)
     {
-      sint16 spell_sp = MAX (item->inv->stats.sp, item->inv->stats.grace);
+      sint16 spell_sp = max (item->inv->stats.sp, item->inv->stats.grace);
       // using the maximum of the rods charge allows at least one spell cast
       // for a rod or horn, this fixes some broken rods.
-      if (item->stats.hp < MIN (spell_sp, item->stats.maxhp))
+      if (item->stats.hp < min (spell_sp, item->stats.maxhp))
         {
           op->contr->play_sound (sound_find ("wand_poof"));
           if (item->type == ROD)
             new_draw_info_format (NDI_UNIQUE, 0, op, "The %s whines for a while, but nothing happens.", query_base_name (item, 0));
     }
   return true;
 }
-/* find_key
+static object *
- * We try to find a key for the door as passed.  If we find a key
- * and successfully use it, we return the key, otherwise NULL
- * This function merges both normal and locked door, since the logic
- * for both is the same - just the specific key is different.
- * pl is the player,
- * inv is the objects inventory to searched
- * door is the door we are trying to match against.
- * This function can be called recursively to search containers.
- */
-object *
-find_key (object *pl, object *container, object *door)
+find_key_ (object *pl, object *container, object *door)
 {
   object *tmp, *key;
   /* Should not happen, but sanity checking is never bad */
   if (!container->inv)
   if (!tmp)
     {
       for (tmp = container->inv; tmp; tmp = tmp->below)
         /* No reason to search empty containers */
         if (tmp->type == CONTAINER && tmp->inv)
-          if ((key = find_key (pl, tmp, door)))
+          if ((key = find_key_ (pl, tmp, door)))
             return key;
       if (!tmp)
         return 0;
     }
        * inv must have been an container and must have been active.
        *
        * Change the color so that the message doesn't disappear with
        * all the others.
        */
-      if (pl->contr->usekeys == key_inventory ||
+      if (pl->contr->usekeys == key_inventory
-          !QUERY_FLAG (container, FLAG_APPLIED) ||
+          || !QUERY_FLAG (container, FLAG_APPLIED)
-          (pl->contr->usekeys == keyrings && container->race != shstr_keys))
+          || (pl->contr->usekeys == keyrings && container->race != shstr_keys))
         {
           new_draw_info_format (NDI_UNIQUE | NDI_BROWN, 0, pl,
                                 "The %s in your %s vibrates as you approach the door", query_name (tmp), query_name (container));
           return NULL;
         }
     }
   return tmp;
+}
+/* find_key
+ * We try to find a key for the door as passed.  If we find a key
+ * and successfully use it, we return the key, otherwise NULL
+ * This function merges both normal and locked door, since the logic
+ * for both is the same - just the specific key is different.
+ * pl is the player,
+ * inv is the objects inventory to searched
+ * door is the door we are trying to match against.
+ * This function can be called recursively to search containers.
+ */
+object *
+find_key (object *pl, object *container, object *door)
+{
+  if (door->slaying && is_match_expr (door->slaying))
+    {
+      // for match expressions, we try to find the key by applying the match
+      // to the op itself, which is supposed to find the "key", instead
+      // of searching through containers ourselves.
+      return match_one (door->slaying, container, door, pl, pl);
+    }
+  else
+    return find_key_ (pl, container, door);
 }
 /* moved door processing out of move_player_attack.
  * returns 1 if player has opened the door with a key
  * such that the caller should not do anything more,
 }
 bool
 move_player (object *op, int dir)
 {
-  int pick;
   if (!op->map || op->map->in_memory != MAP_ACTIVE)
     return 0;
   /* Sanity check: make sure dir is valid */
   if ((dir < 0) || (dir >= 9))
   if (op->flag [FLAG_HIDDEN])
     do_hidden_move (op);
   bool retval;
+  int pick = 0;
   if (INVOKE_PLAYER (MOVE, op->contr, ARG_INT (dir)))
     retval = RESULT_INT (0);
   else if (op->contr->fire_on)
     retval = fire (op, dir);
     return move_player (op, op->direction);
   return false;
 }
-int
+static int
 save_life (object *op)
 {
   if (!QUERY_FLAG (op, FLAG_LIFESAVE))
     return 0;
 void
 object::drop_unpaid_items ()
 {
   if (!flag [FLAG_REMOVED])
     ::drop_unpaid_items (inv, this);
-}
-/*
- * Returns pointer a static string containing gravestone text
- * Moved from apply.c to player.c - player.c is what
- * actually uses this function.  player.c may not be quite the
- * best, a misc file for object actions is probably better,
- * but there isn't one in the server directory.
- */
-const char *
-gravestone_text (object *op)
-{
-  static dynbuf_text buf;
-  buf << "---- R.I.P. ----\n\n"
-      << op->name;
-  if (op->type == PLAYER)
-    buf << " the " << op->contr->title;
-  buf << "\n\n";
-  buf << "who was level ";
-  buf << (sint32)op->level << "\n\n" // OO breakdown
-      << " when " << (op->contr ? "killed" : "died") << "\n\n";
-  if (op->type == PLAYER)
-    buf << "by " << op->contr->killer_name () << ".\n\n";
-  {
-    static char buf2[128];
-    time_t now = time (NULL);
-    strftime (buf2, 128, "%b %d %Y\n\n", localtime (&now));
-    buf << buf2;
-  }
-  return buf;
 }
 void
 do_some_living (object *op)
 {
     return;
   dynbuf_text deathtab;
   /* restore player */
-  at = archetype::find ("poisoning");
+  at = archetype::find (shstr_poisoning);
   if (object *tmp = present_arch_in_ob (at, op))
     {
       tmp->destroy ();
       deathtab << "Your body feels cleansed...\r";
     }
-  at = archetype::find ("confusion");
+  at = archetype::find (shstr_confusion);
   if (object *tmp = present_arch_in_ob (at, op))
     {
       tmp->destroy ();
       deathtab << "Your mind feels clearer...\r";
     }
   if (op_on_battleground (op, &x, &y))
     {
       deathtab << "You almost died in combat, but local medics have saved your life...\r";
       /* create a bodypart-trophy to make the winner happy */
-      if (object *tmp = arch_to_object (archetype::find ("finger")))
+      if (object *tmp = arch_to_object (archetype::find (shstr_finger)))
         {
           tmp->name    = format ("%s's finger" , &op->name);
           tmp->name_pl = format ("%s's fingers", &op->name);
           tmp->msg = format (
              "This finger has been cut off of %s the %s, when he was defeated at level %d by %s.\n",
           lost_a_stat = 1;
         }
       else
         {
           /* deplete a stat */
-          archetype *deparch = archetype::find ("depletion");
+          archetype *deparch = archetype::find (shstr_depletion);
           object *dep;
           dep = present_arch_in_ob (deparch, op);
           if (!dep)
             {
 #endif
   /* Put a gravestone up where the character 'almost' died.  List the
    * exp loss on the stone.
    */
-  tmp = arch_to_object (archetype::find ("gravestone"));
+  tmp = arch_to_object (archetype::find (shstr_gravestone));
   tmp->name = format ("%s's gravestone", &op->name);
   tmp->name_pl = format ("%s's gravestones", &op->name);
   tmp->msg = format ("T<RIP>\n\nHere rests the hero %s the %s,\rwho was killed\rby %s.\n",
                      &op->name, op->contr->title, op->contr->killer_name ());
   tmp->x = op->x, tmp->y = op->y;
     }
   op->contr->infobox (MSG_CHANNEL ("death"), deathtab);
 }
-void
+static void
 loot_object (object *op)
 {                               /* Grab and destroy some treasure */
   object *tmp, *tmp2, *next;
   op->close_container (); /* close open sack first */
     }
   return 0;
 }
-/* routine for both players and monsters. We call this when
- * there is a possibility for our action distrubing our hiding
- * place or invisiblity spell. Artefact invisiblity causes
- * "noise" instead. If we arent invisible to begin with, we
- * return 0.
- */
-int
-action_makes_visible (object *op)
-{
-  if (op->invisible && QUERY_FLAG (op, FLAG_ALIVE))
-    {
-      if (QUERY_FLAG (op, FLAG_MAKE_INVIS))
-        {
-          // artefact invisibility is permanent, but we still make noise
-          // this is important for game-balance.
-          if (op->contr)
-            op->make_noise ();
-          return 0;
-        }
-      if (op->contr && op->contr->tmp_invis == 0)
-        return 0;
-      /* If monsters, they should become visible */
-      if (op->flag [FLAG_HIDDEN] || !op->contr || (op->contr && op->contr->tmp_invis))
-        {
-          new_draw_info_format (NDI_UNIQUE, 0, op, "You become %s!", op->flag [FLAG_HIDDEN] ? "unhidden" : "visible");
-          return 1;
-        }
-    }
-  return 0;
-}
 /* op_on_battleground - checks if the given object op (usually
  * a player) is standing on a valid battleground-tile,
  * function returns TRUE/FALSE. If true x, y returns the battleground
  * -exit-coord. (and if x, y not NULL)
  * 19 March 2005 - josh@woosworld.net modifed to check if the battleground also has slaying, maxhp, and maxsp set
   if (pl->ranged_ob == ob)
     pl->ranged_ob = 0;
 }
+//-GPL
 sint8
 player::darkness_at (maptile *map, int x, int y) const
 {
   if (!ns)
     return LOS_BLOCKED;

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing deliantra/server/server/player.C (file contents): Revision 1.235 by root, Wed Nov 4 17:24:00 2009 UTC vs. Revision 1.243 by root, Sat Nov 7 18:30:06 2009 UTC

Diff Legend

Comparing deliantra/server/server/player.C (file contents):
Revision 1.235 by root, Wed Nov 4 17:24:00 2009 UTC vs.
Revision 1.243 by root, Sat Nov 7 18:30:06 2009 UTC