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

Comparing deliantra/server/common/map.C (file contents):
Revision 1.129 by root, Wed Sep 12 11:10:09 2007 UTC vs.
Revision 1.153 by root, Tue Dec 23 06:58:23 2008 UTC

 /*
- * This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
+ * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  *
- * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
+ * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
  * Copyright (©) 2001-2003,2007 Mark Wedel & Crossfire Development Team
  * Copyright (©) 1992,2007 Frank Tore Johansen
  *
- * Crossfire TRT is free software: you can redistribute it and/or modify
+ * 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,
  * 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>
+ * The authors can be reached via e-mail to <support@deliantra.net>
  */
 #include <unistd.h>
 #include "global.h"
-#include "funcpoint.h"
 #include "loader.h"
 #include "path.h"
+sint8 maptile::outdoor_darkness;
 /* This rolls up wall, blocks_magic, blocks_view, etc, all into
  * one function that just returns a P_.. value (see map.h)
  * it will also do map translation for tiled maps, returning
  * new values into newmap, nx, and ny.  Any and all of those
       insert_ob_in_ob (tmp, container);
       tmp = next;
     }
-  /* sum_weight will go through and calculate what all the containers are
+  // go through and calculate what all the containers are carrying.
-   * carrying.
+  //TODO: remove
-   */
+  container->update_weight ();
-  sum_weight (container);
 }
 void
 maptile::set_object_flag (int flag, int value)
 {
     return;
   for (mapspace *ms = spaces + size (); ms-- > spaces; )
     for (object *tmp = ms->bot; tmp; tmp = tmp->above)
       tmp->flag [flag] = value;
+}
+void
+maptile::post_load_original ()
+{
+  if (!spaces)
+    return;
+  set_object_flag (FLAG_OBJ_ORIGINAL);
+  for (mapspace *ms = spaces + size (); ms-- > spaces; )
+    for (object *tmp = ms->bot; tmp; tmp = tmp->above)
+      INVOKE_OBJECT (RESET, tmp);
 }
 /* link_multipart_objects go through all the objects on the map looking
  * for objects whose arch says they are multipart yet according to the
  * info we have, they only have the head (as would be expected when
 bool
 maptile::_load_objects (object_thawer &f)
 {
   for (;;)
     {
-      coroapi::cede_to_tick_every (100); // cede once in a while
+      coroapi::cede_to_tick (); // cede once in a while
       switch (f.kw)
         {
           case KW_arch:
             if (object *op = object::read (f, this))
               {
+                // TODO: why?
                 if (op->inv)
-                  sum_weight (op);
+                  op->update_weight ();
-                insert_ob_in_map (op, this, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ON_TOP | INS_MAP_LOAD);
+                if (IN_RANGE_EXC (op->x, 0, width) && IN_RANGE_EXC (op->y, 0, height))
+                  {
+                    // we insert manually because
+                    // a) its way faster
+                    // b) we remove manually, too, and there are good reasons for that
+                    // c) its correct
+                    mapspace &ms = at (op->x, op->y);
+                    op->flag [FLAG_REMOVED] = false;
+                    op->above = 0;
+                    op->below = ms.top;
+                    if (ms.top)
+                      ms.top->above = op;
+                    else
+                      ms.bot = op;
+                    ms.top = op;
+                    ms.flags_ = 0;
+                  }
+                else
+                  {
+                    f.parse_warn (format ("object %s out of range", op->debug_desc ()));
+                    op->destroy ();
+                  }
               }
             continue;
           case KW_EOF:
           case KW_sky:        thawer.get (sky);        break;
           case KW_per_player: thawer.get (per_player); break;
           case KW_per_party:  thawer.get (per_party);  break;
           case KW_no_reset:   thawer.get (no_reset);   break;
+          case KW_no_drop:    thawer.get (no_drop);    break;
           case KW_region:     default_region = region::find (thawer.get_str ()); break;
           case KW_shopitems:  shopitems = parse_shop_string (thawer.get_str ()); break;
           //   old names            new names
           if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
             unique = 1;
           if (op->head_ () == op && (QUERY_FLAG (op, FLAG_UNIQUE) || unique))
-            {
-              op->destroy_inv (false);
-              op->destroy ();
+            op->destroy ();
-            }
           op = above;
         }
     }
 }
   MAP_OUT (swap_time);
   MAP_OUT (reset_time);
   MAP_OUT (reset_timeout);
   MAP_OUT (fixed_resettime);
   MAP_OUT (no_reset);
+  MAP_OUT (no_drop);
   MAP_OUT (difficulty);
   if (default_region) MAP_OUT2 (region, default_region->name);
   if (shopitems)
             op->flag [FLAG_REMOVED] = true;
             object *head = op->head_ ();
             if (op == head)
-              {
-                op->destroy_inv (false);
-                op->destroy ();
+              op->destroy ();
-              }
             else if (head->map != op->map)
               {
                 LOG (llevDebug, "bad luck for object crossing map borders: %s", head->debug_desc ());
                 head->destroy ();
               }
           }
-      sfree (spaces, size ()), spaces = 0;
+      sfree0 (spaces, size ());
     }
   if (buttons)
     free_objectlinkpt (buttons), buttons = 0;
-  sfree (regions, size ()); regions = 0;
+  sfree0 (regions, size ());
   delete [] regionmap; regionmap = 0;
 }
 void
 maptile::clear_header ()
 /*
  * This routine is supposed to find out the difficulty of the map.
  * difficulty does not have a lot to do with character level,
  * but does have a lot to do with treasure on the map.
  *
- * Difficulty can now be set by the map creature.  If the value stored
+ * Difficulty can now be set by the map creator. If the value stored
- * in the map is zero, then use this routine.  Maps should really
+ * in the map is zero, then use this routine. Maps should really
- * have a difficulty set than using this function - human calculation
+ * have a difficulty set rather than using this function - human calculation
- * is much better than this functions guesswork.
+ * is much better than this function's guesswork.
  */
 int
 maptile::estimate_difficulty () const
 {
   long monster_cnt = 0;
         if (QUERY_FLAG (op, FLAG_GENERATOR))
           {
             total_exp += op->stats.exp;
-            if (archetype *at = type_to_archetype (GENERATE_TYPE (op)))
+            if (archetype *at = op->other_arch)
+              {
-              total_exp += at->stats.exp * 8;
+                total_exp += at->stats.exp * 8;
-            monster_cnt++;
+                monster_cnt++;
+              }
+            for (object *inv = op->inv; inv; inv = inv->below)
+              {
+                total_exp += op->stats.exp * 8;
+                monster_cnt++;
+              }
           }
       }
   avgexp = (double) total_exp / monster_cnt;
   else
     darkness = new_level;
   /* All clients need to get re-updated for the change */
   update_all_map_los (this);
   return 1;
 }
 /*
  * This function updates various attributes about a specific space
  * through, etc)
  */
 void
 mapspace::update_ ()
 {
-  object *tmp, *last = 0;
+  object *last = 0;
-  uint8 flags = P_UPTODATE, light = 0, anywhere = 0;
+  uint8 flags = P_UPTODATE, anywhere = 0;
+  sint8 light = 0;
   MoveType move_block = 0, move_slow = 0, move_on = 0, move_off = 0, move_allow = 0;
   //object *middle = 0;
   //object *top    = 0;
   //object *floor  = 0;
   // this seems to generate better code than using locals, above
   object *&top    = faces_obj[0] = 0;
   object *&middle = faces_obj[1] = 0;
   object *&floor  = faces_obj[2] = 0;
-  for (tmp = bot; tmp; last = tmp, tmp = tmp->above)
+  for (object *tmp = bot; tmp; last = tmp, tmp = tmp->above)
     {
-      /* This could be made additive I guess (two lights better than
+      // Lights are additive, up to MAX_LIGHT_RADIUS, see los.C)
-       * one). But if so, it shouldn't be a simple additive - 2
-       * light bulbs do not illuminate twice as far as once since
-       * it is a dissapation factor that is cubed.
-       */
-      if (tmp->glow_radius > light)
-        light = tmp->glow_radius;
+      light += tmp->glow_radius;
       /* This call is needed in order to update objects the player
        * is standing in that have animations (ie, grass, fire, etc).
        * However, it also causes the look window to be re-drawn
        * 3 times each time the player moves, because many of the
           else if (QUERY_FLAG (tmp, FLAG_SEE_ANYWHERE))
             {
               middle = tmp;
               anywhere = 1;
             }
           /* Find the highest visible face around.  If equal
            * visibilities, we still want the one nearer to the
            * top
            */
           else if (!middle || (::faces [tmp->face].visibility > ::faces [middle->face].visibility && !anywhere))
       if (tmp->type == SAFE_GROUND)          flags |= P_SAFE;
       if (QUERY_FLAG (tmp, FLAG_ALIVE))      flags |= P_IS_ALIVE;
       if (QUERY_FLAG (tmp, FLAG_DAMNED))     flags |= P_NO_CLERIC;
     }
-  this->light      = light;
+  this->light      = min (light, MAX_LIGHT_RADIUS);
   this->flags_     = flags;
   this->move_block = move_block & ~move_allow;
   this->move_on    = move_on;
   this->move_off   = move_off;
   this->move_slow  = move_slow;
    * 1) top face is set, need middle to be set.
    * 2) middle is set, need to set top.
    * 3) neither middle or top is set - need to set both.
    */
-  for (tmp = last; tmp; tmp = tmp->below)
+  for (object *tmp = last; tmp; tmp = tmp->below)
     {
       /* Once we get to a floor, stop, since we already have a floor object */
       if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
         break;
 maptile::tile_available (int dir, bool load)
 {
   if (!tile_path[dir])
     return 0;
-  if (tile_map[dir] && (!load || tile_map[dir]->in_memory == MAP_IN_MEMORY))
+  if (tile_map[dir] && (!load || tile_map[dir]->in_memory == MAP_ACTIVE))
     return 1;
   if ((tile_map[dir] = find_async (tile_path[dir], this, load)))
     return 1;
 }
 object *
 maptile::insert (object *op, int x, int y, object *originator, int flags)
 {
-  if (!op->flag [FLAG_REMOVED])
-    op->remove ();
   return insert_ob_in_map_at (op, this, originator, flags, x, y);
 }
 region *
 maptile::region (int x, int y) const
   return ::region::default_region ();
 }
 /* picks a random object from a style map.
- * Redone by MSW so it should be faster and not use static
- * variables to generate tables.
  */
 object *
-maptile::pick_random_object () const
+maptile::pick_random_object (rand_gen &gen) const
 {
   /* while returning a null object will result in a crash, that
    * is actually preferable to an infinite loop.  That is because
    * most servers will automatically restart in case of crash.
    * Change the logic on getting the random space - shouldn't make
    * any difference, but this seems clearer to me.
    */
   for (int i = 1000; --i;)
     {
-      object *pick = at (rndm (width), rndm (height)).bot;
+      object *pick = at (gen (width), gen (height)).bot;
       // do not prefer big monsters just because they are big.
-      if (pick && pick->head_ () == pick)
+      if (pick && pick->is_head ())
         return pick->head_ ();
     }
   // instead of crashing in the unlikely(?) case, try to return *something*
-  return get_archetype ("blocked");
+  return archetype::find ("bug");
 }
 void
 maptile::play_sound (faceidx sound, int x, int y) const
 {
   if (!sound)
     return;
-  for_all_players (pl)
+  for_all_players_on_map (pl, this)
-    if (pl->observe->map == this)
-      if (client *ns = pl->ns)
+    if (client *ns = pl->ns)
-        {
+      {
-          int dx = x - pl->observe->x;
+        int dx = x - pl->ob->x;
-          int dy = y - pl->observe->y;
+        int dy = y - pl->ob->y;
-          int distance = idistance (dx, dy);
+        int distance = idistance (dx, dy);
-          if (distance <= MAX_SOUND_DISTANCE)
+        if (distance <= MAX_SOUND_DISTANCE)
-            ns->play_sound (sound, dx, dy);
+          ns->play_sound (sound, dx, dy);
-        }
+      }
 }

Diff Legend

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

Comparing deliantra/server/common/map.C (file contents): Revision 1.129 by root, Wed Sep 12 11:10:09 2007 UTC vs. Revision 1.153 by root, Tue Dec 23 06:58:23 2008 UTC

Diff Legend

Comparing deliantra/server/common/map.C (file contents):
Revision 1.129 by root, Wed Sep 12 11:10:09 2007 UTC vs.
Revision 1.153 by root, Tue Dec 23 06:58:23 2008 UTC