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

Comparing deliantra/server/common/map.C (file contents):
Revision 1.137 by root, Wed Apr 30 16:26:28 2008 UTC vs.
Revision 1.163 by root, Thu Oct 15 21:40:42 2009 UTC

 /*
  * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  *
- * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
+ * Copyright (©) 2005,2006,2007,2008,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
  * Copyright (©) 2001-2003,2007 Mark Wedel & Crossfire Development Team
  * Copyright (©) 1992,2007 Frank Tore Johansen
  *
- * Deliantra is free software: you can redistribute it and/or modify
+ * Deliantra is free software: you can redistribute it and/or modify it under
- * it under the terms of the GNU General Public License as published by
+ * the terms of the Affero GNU General Public License as published by the
- * the Free Software Foundation, either version 3 of the License, or
+ * Free Software Foundation, either version 3 of the License, or (at your
- * (at your option) any later version.
+ * 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
+ * You should have received a copy of the Affero GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ * and 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 <support@deliantra.net>
  */
 #include <unistd.h>
 #include "global.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
  * by the caller.
  */
 int
 blocked_link (object *ob, maptile *m, int sx, int sy)
 {
-  object *tmp;
-  int mflags, blocked;
   /* Make sure the coordinates are valid - they should be, as caller should
    * have already checked this.
    */
   if (OUT_OF_REAL_MAP (m, sx, sy))
     {
     }
   /* Save some cycles - instead of calling get_map_flags(), just get the value
    * directly.
    */
-  mflags = m->at (sx, sy).flags ();
+  mapspace &ms = m->at (sx, sy);
-  blocked = GET_MAP_MOVE_BLOCK (m, sx, sy);
+  int mflags  = ms.flags ();
+  int blocked = ms.move_block;
   /* If space is currently not blocked by anything, no need to
    * go further.  Not true for players - all sorts of special
    * things we need to do for players.
    */
   if (ob->type != PLAYER && !(mflags & P_IS_ALIVE) && (blocked == 0))
     return 0;
-  /* if there isn't anytyhing alive on this space, and this space isn't
+  /* if there isn't anything alive on this space, and this space isn't
    * otherwise blocked, we can return now.  Only if there is a living
    * creature do we need to investigate if it is part of this creature
    * or another.  Likewise, only if something is blocking us do we
    * need to investigate if there is a special circumstance that would
    * let the player through (inventory checkers for example)
   /* We basically go through the stack of objects, and if there is
    * some other object that has NO_PASS or FLAG_ALIVE set, return
    * true.  If we get through the entire stack, that must mean
    * ob is blocking it, so return 0.
    */
-  for (tmp = GET_MAP_OB (m, sx, sy); tmp; tmp = tmp->above)
+  for (object *tmp = ms.bot; tmp; tmp = tmp->above)
     {
+      bool block = OB_MOVE_BLOCK (ob, tmp);
       /* This must be before the checks below.  Code for inventory checkers. */
-      if (tmp->type == CHECK_INV && OB_MOVE_BLOCK (ob, tmp))
+      if (block && tmp->type == CHECK_INV)
         {
+          bool have = check_inv_recursive (ob, tmp);
           /* If last_sp is set, the player/monster needs an object,
            * so we check for it.  If they don't have it, they can't
            * pass through this space.
            */
           if (tmp->last_sp)
             {
-              if (check_inv_recursive (ob, tmp) == NULL)
+              if (!have)
                 return 1;
-              else
-                continue;
             }
           else
             {
               /* In this case, the player must not have the object -
                * if they do, they can't pass through.
                */
-              if (check_inv_recursive (ob, tmp) != NULL)        /* player has object */
+              if (have)
                 return 1;
-              else
-                continue;
             }
-        }                       /* if check_inv */
+        }
+      else if (block && tmp->type == T_MATCH)
+        {
+          //TODO
+        }
       else
         {
           /* Broke apart a big nasty if into several here to make
            * this more readable.  first check - if the space blocks
            * movement, can't move here.
            * second - if a monster, can't move there, unless it is a
-           * hidden dm
+           * dm.
            */
-          if (OB_MOVE_BLOCK (ob, tmp))
+          if (block)
             return 1;
           if (tmp->flag [FLAG_ALIVE]
               && tmp->head_ () != ob
               && tmp != ob
               && tmp->type != DOOR
-              && !(tmp->flag [FLAG_WIZ] && tmp->contr->hidden))
+              && !tmp->flag [FLAG_WIZ])
             return 1;
         }
     }
   return 0;
 }
 /*
  * Returns qthe blocking object if the given object can't fit in the given
   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
  * they are saved).
  */
                 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
+                    // c) it's 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;
+                    *(ms.top ? &ms.top->above : &ms.bot) = op;
-                    else
-                      ms.bot = op;
                     ms.top = op;
                     ms.flags_ = 0;
                   }
                 else
           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 ();
               }
           op->destroy ();
       }
 }
 /*
- * Updates every button on the map (by calling update_button() for them).
- */
-void
-maptile::update_buttons ()
-{
-  for (oblinkpt *obp = buttons; obp; obp = obp->next)
-    for (objectlink *ol = obp->link; ol; ol = ol->next)
-      {
-        if (!ol->ob)
-          {
-            LOG (llevError, "Internal error in update_button (%s (%dx%d), connected %ld).\n",
-                 ol->ob ? (const char *) ol->ob->name : "null", ol->ob ? ol->ob->x : -1, ol->ob ? ol->ob->y : -1, obp->value);
-            continue;
-          }
-        if (ol->ob->type == BUTTON || ol->ob->type == PEDESTAL)
-          {
-            update_button (ol->ob);
-            break;
-          }
-      }
-}
-/*
  * 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;
  * postive values make it darker, negative make it brighter
  */
 int
 maptile::change_map_light (int change)
 {
-  int new_level = darkness + change;
   /* Nothing to do */
-  if (!change || (new_level <= 0 && darkness == 0) || (new_level >= MAX_DARKNESS && darkness >= MAX_DARKNESS))
+  if (!change)
     return 0;
   /* inform all players on the map */
   if (change > 0)
     new_info_map (NDI_BLACK | NDI_UNIQUE, this, "It becomes darker.");
   else
     new_info_map (NDI_BLACK | NDI_UNIQUE, this, "It becomes brighter.");
-  /* Do extra checking.  since darkness is a unsigned value,
+  darkness = clamp (darkness + change, -MAX_DARKNESS, MAX_DARKNESS);
-   * we need to be extra careful about negative values.
-   * In general, the checks below are only needed if change
-   * is not +/-1
-   */
-  if (new_level < 0)
-    darkness = 0;
-  else if (new_level >= MAX_DARKNESS)
-    darkness = MAX_DARKNESS;
-  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;
     vol += op->volume ();
   return vol;
 }
-bool
+maptile *
 maptile::tile_available (int dir, bool load)
 {
-  if (!tile_path[dir])
+  if (tile_path[dir])
-    return 0;
+    {
-  if (tile_map[dir] && (!load || tile_map[dir]->in_memory == MAP_ACTIVE))
+      if (tile_map[dir] && (!load || tile_map[dir]->in_memory == MAP_ACTIVE))
-    return 1;
+        return tile_map[dir];
-  if ((tile_map[dir] = find_async (tile_path[dir], this, load)))
+      if ((tile_map[dir] = find_async (tile_path[dir], this, load)))
-    return 1;
+        return tile_map[dir];
+    }
   return 0;
 }
 /* this returns TRUE if the coordinates (x,y) are out of
   else
     {
       retval->distance_x += op2->x - x;
       retval->distance_y += op2->y - y;
-      retval->part = NULL;
+      retval->part = 0;
-      retval->distance = idistance (retval->distance_x, retval->distance_y);
+      retval->distance = upos_max (abs (retval->distance_x), abs (retval->distance_y));
       retval->direction = find_dir_2 (-retval->distance_x, -retval->distance_y);
     }
 }
 /* Returns true of op1 and op2 are effectively on the same map
 }
 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_on_map (pl, this)
+    if (client *ns = pl->ns)
+      {
+        int dx = x - pl->ob->x;
+        int dy = y - pl->ob->y;
+        int distance = idistance (dx, dy);
+        if (distance <= MAX_SOUND_DISTANCE)
+          ns->play_sound (sound, dx, dy);
+      }
+}
+void
+maptile::say_msg (const char *msg, int x, int y) const
+{
   for_all_players (pl)
-    if (pl->ob->map == this)
-      if (client *ns = pl->ns)
+    if (client *ns = pl->ns)
-        {
+      {
-          int dx = x - pl->ob->x;
+        int dx = x - pl->ob->x;
-          int dy = y - pl->ob->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->send_msg (NDI_GREY | NDI_DEF, SAY_CHANNEL, msg);
-        }
+      }
 }
+static void
+split_to_tiles (dynbuf &buf, maptile *m, int x0, int y0, int x1, int y1, int dx, int dy)
+{
+  // clip to map to the left
+  if (x0 < 0)
+    {
+      if (maptile *tile = m->tile_available (TILE_LEFT, 1))
+        split_to_tiles (buf, tile, x0 + tile->width, y0, min (x1 + tile->width, tile->width), y1, dx - tile->width, dy);
+      if (x1 < 0) // entirely to the left
+        return;
+      x0 = 0;
+    }
+  // clip to map to the right
+  if (x1 > m->width)
+    {
+      if (maptile *tile = m->tile_available (TILE_RIGHT, 1))
+        split_to_tiles (buf, tile, max (x0 - m->width, 0), y0, x1 - m->width, y1, dx + m->width, dy);
+      if (x0 > m->width) // entirely to the right
+        return;
+      x1 = m->width;
+    }
+  // clip to map above
+  if (y0 < 0)
+    {
+      if (maptile *tile = m->tile_available (TILE_UP, 1))
+        split_to_tiles (buf, tile, x0, y0 + tile->height, x1, min (y1 + tile->height, tile->height), dx, dy - tile->height);
+      if (y1 < 0) // entirely above
+        return;
+      y0 = 0;
+    }
+  // clip to map below
+  if (y1 > m->height)
+    {
+      if (maptile *tile = m->tile_available (TILE_DOWN, 1))
+        split_to_tiles (buf, tile, x0, max (y0 - m->height, 0), x1, y1 - m->height, dx, dy + m->height);
+      if (y0 > m->height) // entirely below
+        return;
+      y1 = m->height;
+    }
+  // if we get here, the rect is within the current map
+  maprect *r = (maprect *)buf.alloc (sizeof (maprect));
+  r->m  = m;
+  r->x0 = x0;
+  r->y0 = y0;
+  r->x1 = x1;
+  r->y1 = y1;
+  r->dx = dx;
+  r->dy = dy;
+}
+maprect *
+maptile::split_to_tiles (int x0, int y0, int x1, int y1)
+{
+  static dynbuf buf (sizeof (maprect) * 8, sizeof (maprect) * 8);
+  buf.clear ();
+  ::split_to_tiles (buf, this, x0, y0, x1, y1, 0, 0);
+  // add end marker
+  maprect *r = (maprect *)buf.alloc (sizeof (maprect));
+  r->m = 0;
+  return (maprect *)buf.linearise ();
+}

Diff Legend

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

Comparing deliantra/server/common/map.C (file contents): Revision 1.137 by root, Wed Apr 30 16:26:28 2008 UTC vs. Revision 1.163 by root, Thu Oct 15 21:40:42 2009 UTC

Diff Legend

Comparing deliantra/server/common/map.C (file contents):
Revision 1.137 by root, Wed Apr 30 16:26:28 2008 UTC vs.
Revision 1.163 by root, Thu Oct 15 21:40:42 2009 UTC