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

Comparing deliantra/server/common/los.C (file contents):
Revision 1.7 by root, Mon Dec 11 21:32:16 2006 UTC vs.
Revision 1.16 by pippijn, Sat Jan 6 14:42:29 2007 UTC

 /*
     CrossFire, A Multiplayer game for X-windows
+    Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
     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
       int dx = block[x][y].x[i], dy = block[x][y].y[i], ax, ay;
       /* ax, ay are the values as adjusted to be in the
        * socket look structure.
        */
-      ax = dx - (MAP_CLIENT_X - op->contr->socket.mapx) / 2;
+      ax = dx - (MAP_CLIENT_X - op->contr->ns->mapx) / 2;
-      ay = dy - (MAP_CLIENT_Y - op->contr->socket.mapy) / 2;
+      ay = dy - (MAP_CLIENT_Y - op->contr->ns->mapy) / 2;
-      if (ax < 0 || ax >= op->contr->socket.mapx || ay < 0 || ay >= op->contr->socket.mapy)
+      if (ax < 0 || ax >= op->contr->ns->mapx || ay < 0 || ay >= op->contr->ns->mapy)
         continue;
 #if 0
       LOG (llevDebug, "blocked %d %d -> %d %d\n", dx, dy, ax, ay);
 #endif
       /* we need to adjust to the fact that the socket
   if (!block[x][y].index)
     return;
   /* ax, ay are coordinates as indexed into the look window */
-  ax = x - (MAP_CLIENT_X - op->contr->socket.mapx) / 2;
+  ax = x - (MAP_CLIENT_X - op->contr->ns->mapx) / 2;
-  ay = y - (MAP_CLIENT_Y - op->contr->socket.mapy) / 2;
+  ay = y - (MAP_CLIENT_Y - op->contr->ns->mapy) / 2;
   /* If the converted coordinates are outside the viewable
    * area for the client, return now.
    */
-  if (ax < 0 || ay < 0 || ax >= op->contr->socket.mapx || ay >= op->contr->socket.mapy)
+  if (ax < 0 || ay < 0 || ax >= op->contr->ns->mapx || ay >= op->contr->ns->mapy)
     return;
 #if 0
   LOG (llevDebug, "check_wall, ax,ay=%d, %d  x,y = %d, %d  blocksview = %d, %d\n",
        ax, ay, x, y, op->x + x - MAP_CLIENT_X / 2, op->y + y - MAP_CLIENT_Y / 2);
  */
 void
 clear_los (object *op)
 {
-  /* This is safer than using the socket->mapx, mapy because
+  /* This is safer than using the ns->mapx, mapy because
    * we index the blocked_los as a 2 way array, so clearing
    * the first z spaces may not not cover the spaces we are
    * actually going to use
    */
   (void) memset ((void *) op->contr->blocked_los, 0, MAP_CLIENT_X * MAP_CLIENT_Y);
 static void
 expand_sight (object *op)
 {
   int i, x, y, dx, dy;
-  for (x = 1; x < op->contr->socket.mapx - 1; x++)      /* loop over inner squares */
+  for (x = 1; x < op->contr->ns->mapx - 1; x++)      /* loop over inner squares */
-    for (y = 1; y < op->contr->socket.mapy - 1; y++)
+    for (y = 1; y < op->contr->ns->mapy - 1; y++)
       {
         if (!op->contr->blocked_los[x][y] &&
             !(get_map_flags (op->map, NULL,
-                             op->x - op->contr->socket.mapx / 2 + x,
+                             op->x - op->contr->ns->mapx / 2 + x,
-                             op->y - op->contr->socket.mapy / 2 + y, NULL, NULL) & (P_BLOCKSVIEW | P_OUT_OF_MAP)))
+                             op->y - op->contr->ns->mapy / 2 + y, NULL, NULL) & (P_BLOCKSVIEW | P_OUT_OF_MAP)))
           {
             for (i = 1; i <= 8; i += 1)
               {                 /* mark all directions */
                 dx = x + freearr_x[i];
                   op->contr->blocked_los[dx][dy] = -1;
               }
           }
       }
-  if (MAP_DARKNESS (op->map) > 0)       /* player is on a dark map */
+  if (op->map->darkness > 0)       /* player is on a dark map */
     expand_lighted_sight (op);
   /* clear mark squares */
-  for (x = 0; x < op->contr->socket.mapx; x++)
+  for (x = 0; x < op->contr->ns->mapx; x++)
-    for (y = 0; y < op->contr->socket.mapy; y++)
+    for (y = 0; y < op->contr->ns->mapy; y++)
       if (op->contr->blocked_los[x][y] < 0)
         op->contr->blocked_los[x][y] = 0;
 }
 {
   int x, y, darklevel, ax, ay, basex, basey, mflags, light, x1, y1;
   maptile *m = op->map;
   sint16 nx, ny;
-  darklevel = MAP_DARKNESS (m);
+  darklevel = m->darkness;
   /* If the player can see in the dark, lower the darklevel for him */
   if (QUERY_FLAG (op, FLAG_SEE_IN_DARK))
     darklevel -= 2;
   /* Do a sanity check.  If not valid, some code below may do odd
    * things.
    */
   if (darklevel > MAX_DARKNESS)
     {
-      LOG (llevError, "Map darkness for %s on %s is too high (%d)\n", &op->name, op->map->path, darklevel);
+      LOG (llevError, "Map darkness for %s on %s is too high (%d)\n", &op->name, &op->map->path, darklevel);
       darklevel = MAX_DARKNESS;
     }
   /* First, limit player furthest (unlighted) vision */
-  for (x = 0; x < op->contr->socket.mapx; x++)
+  for (x = 0; x < op->contr->ns->mapx; x++)
-    for (y = 0; y < op->contr->socket.mapy; y++)
+    for (y = 0; y < op->contr->ns->mapy; y++)
       if (op->contr->blocked_los[x][y] != 100)
         op->contr->blocked_los[x][y] = MAX_LIGHT_RADII;
   /* the spaces[] darkness value contains the information we need.
    * Only process the area of interest.
    * the basex, basey values represent the position in the op->contr->blocked_los
    * array.  Its easier to just increment them here (and start with the right
    * value) than to recalculate them down below.
    */
-  for (x = (op->x - op->contr->socket.mapx / 2 - MAX_LIGHT_RADII), basex = -MAX_LIGHT_RADII;
+  for (x = (op->x - op->contr->ns->mapx / 2 - MAX_LIGHT_RADII), basex = -MAX_LIGHT_RADII;
-       x <= (op->x + op->contr->socket.mapx / 2 + MAX_LIGHT_RADII); x++, basex++)
+       x <= (op->x + op->contr->ns->mapx / 2 + MAX_LIGHT_RADII); x++, basex++)
     {
-      for (y = (op->y - op->contr->socket.mapy / 2 - MAX_LIGHT_RADII), basey = -MAX_LIGHT_RADII;
+      for (y = (op->y - op->contr->ns->mapy / 2 - MAX_LIGHT_RADII), basey = -MAX_LIGHT_RADII;
-           y <= (op->y + op->contr->socket.mapy / 2 + MAX_LIGHT_RADII); y++, basey++)
+           y <= (op->y + op->contr->ns->mapy / 2 + MAX_LIGHT_RADII); y++, basey++)
         {
           m = op->map;
           nx = x;
           ny = y;
 #if 0
               LOG (llevDebug, "expand_lighted_sight: Found light at x=%d, y=%d, basex=%d, basey=%d\n", x, y, basex, basey);
 #endif
               for (ax = basex - light; ax <= basex + light; ax++)
                 {
-                  if (ax < 0 || ax >= op->contr->socket.mapx)
+                  if (ax < 0 || ax >= op->contr->ns->mapx)
                     continue;
                   for (ay = basey - light; ay <= basey + light; ay++)
                     {
-                      if (ay < 0 || ay >= op->contr->socket.mapy)
+                      if (ay < 0 || ay >= op->contr->ns->mapy)
                         continue;
                       /* If the space is fully blocked, do nothing.  Otherwise, we
                        * brighten the space.  The further the light is away from the
                        * source (basex-x), the less effect it has.  Though light used
   /* Outdoor should never really be completely pitch black dark like
    * a dungeon, so let the player at least see a little around themselves
    */
   if (op->map->outdoor && darklevel > (MAX_DARKNESS - 3))
     {
-      if (op->contr->blocked_los[op->contr->socket.mapx / 2][op->contr->socket.mapy / 2] > (MAX_DARKNESS - 3))
+      if (op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] > (MAX_DARKNESS - 3))
-        op->contr->blocked_los[op->contr->socket.mapx / 2][op->contr->socket.mapy / 2] = MAX_DARKNESS - 3;
+        op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] = MAX_DARKNESS - 3;
       for (x = -1; x <= 1; x++)
         for (y = -1; y <= 1; y++)
           {
-            if (op->contr->blocked_los[x + op->contr->socket.mapx / 2][y + op->contr->socket.mapy / 2] > (MAX_DARKNESS - 2))
+            if (op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] > (MAX_DARKNESS - 2))
-              op->contr->blocked_los[x + op->contr->socket.mapx / 2][y + op->contr->socket.mapy / 2] = MAX_DARKNESS - 2;
+              op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] = MAX_DARKNESS - 2;
           }
     }
   /*  grant some vision to the player, based on the darklevel */
   for (x = darklevel - MAX_DARKNESS; x < MAX_DARKNESS + 1 - darklevel; x++)
     for (y = darklevel - MAX_DARKNESS; y < MAX_DARKNESS + 1 - darklevel; y++)
-      if (!(op->contr->blocked_los[x + op->contr->socket.mapx / 2][y + op->contr->socket.mapy / 2] == 100))
+      if (!(op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] == 100))
-        op->contr->blocked_los[x + op->contr->socket.mapx / 2][y + op->contr->socket.mapy / 2] -=
+        op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] -=
           MAX (0, 6 - darklevel - MAX (abs (x), abs (y)));
 }
 /* blinded_sight() - sets all veiwable squares to blocked except
  * for the one the central one that the player occupies.  A little
 static void
 blinded_sight (object *op)
 {
   int x, y;
-  for (x = 0; x < op->contr->socket.mapx; x++)
+  for (x = 0; x < op->contr->ns->mapx; x++)
-    for (y = 0; y < op->contr->socket.mapy; y++)
+    for (y = 0; y < op->contr->ns->mapy; y++)
       op->contr->blocked_los[x][y] = 100;
-  op->contr->blocked_los[op->contr->socket.mapx / 2][op->contr->socket.mapy / 2] = 0;
+  op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] = 0;
 }
 /*
  * update_los() recalculates the array which specifies what is
  * visible for the given player-object.
  */
 void
 update_los (object *op)
 {
-  int dx = op->contr->socket.mapx / 2, dy = op->contr->socket.mapy / 2, x, y;
+  int dx = op->contr->ns->mapx / 2, dy = op->contr->ns->mapy / 2, x, y;
   if (QUERY_FLAG (op, FLAG_REMOVED))
     return;
   clear_los (op);
   /* For larger maps, this is more efficient than the old way which
    * used the chaining of the block array.  Since many space views could
    * be blocked by different spaces in front, this mean that a lot of spaces
    * could be examined multile times, as each path would be looked at.
    */
-  for (x = (MAP_CLIENT_X - op->contr->socket.mapx) / 2 - 1; x < (MAP_CLIENT_X + op->contr->socket.mapx) / 2 + 1; x++)
+  for (x = (MAP_CLIENT_X - op->contr->ns->mapx) / 2 - 1; x < (MAP_CLIENT_X + op->contr->ns->mapx) / 2 + 1; x++)
-    for (y = (MAP_CLIENT_Y - op->contr->socket.mapy) / 2 - 1; y < (MAP_CLIENT_Y + op->contr->socket.mapy) / 2 + 1; y++)
+    for (y = (MAP_CLIENT_Y - op->contr->ns->mapy) / 2 - 1; y < (MAP_CLIENT_Y + op->contr->ns->mapy) / 2 + 1; y++)
       check_wall (op, x, y);
   /* do the los of the player. 3 (potential) cases */
   if (QUERY_FLAG (op, FLAG_BLIND))      /* player is blind */
     }
 }
 /* update all_map_los is like update_all_los below,
  * but updates everyone on the map, no matter where they
- * are.  This generally should not be used, as a per
+ * are. This generally should not be used, as a per
  * specific map change doesn't make much sense when tiling
  * is considered (lowering darkness would certainly be a
  * strange effect if done on a tile map, as it makes
  * the distinction between maps much more obvious to the
  * players, which is should not be.
  * change_map_light function
  */
 void
 update_all_map_los (maptile *map)
 {
-  player *pl;
+  for_all_players (pl)
-  for (pl = first_player; pl != NULL; pl = pl->next)
-    {
-      if (pl->ob->map == map)
+    if (pl->ob && pl->ob->map == map)
-        pl->do_los = 1;
+      pl->do_los = 1;
-    }
 }
 /*
  * This function makes sure that update_los() will be called for all
  * players on the given map within the next frame.
  * It is triggered by removal or inserting of objects which blocks
  * means that just being on the same map is not sufficient - the
  * space that changes must be withing your viewable area.
  *
  * map is the map that changed, x and y are the coordinates.
  */
 void
 update_all_los (const maptile *map, int x, int y)
 {
-  player *pl;
+  for_all_players (pl)
-  for (pl = first_player; pl != NULL; pl = pl->next)
     {
       /* Player should not have a null map, but do this
        * check as a safety
        */
-      if (!pl->ob->map)
+      if (!pl->ob || !pl->ob->map || !pl->ns)
         continue;
       /* Same map is simple case - see if pl is close enough.
        * Note in all cases, we did the check for same map first,
        * and then see if the player is close enough and update
        * so by setting it up this way, we trim processing
        * some.
        */
       if (pl->ob->map == map)
         {
-          if ((abs (pl->ob->x - x) <= pl->socket.mapx / 2) && (abs (pl->ob->y - y) <= pl->socket.mapy / 2))
+          if ((abs (pl->ob->x - x) <= pl->ns->mapx / 2) && (abs (pl->ob->y - y) <= pl->ns->mapy / 2))
             pl->do_los = 1;
         }
       /* Now we check to see if player is on adjacent
        * maps to the one that changed and also within
        * view.  The tile_maps[] could be null, but in that
        * case it should never match the pl->ob->map, so
        * we want ever try to dereference any of the data in it.
-       */
+       *
-      /* The logic for 0 and 3 is to see how far the player is
+       * The logic for 0 and 3 is to see how far the player is
        * from the edge of the map (height/width) - pl->ob->(x,y)
        * and to add current position on this map - that gives a
        * distance.
        * For 1 and 2, we check to see how far the given
        * coordinate (x,y) is from the corresponding edge,
        * and then add the players location, which gives
        * a distance.
        */
       else if (pl->ob->map == map->tile_map[0])
         {
-          if ((abs (pl->ob->x - x) <= pl->socket.mapx / 2) && (abs (y + MAP_HEIGHT (map->tile_map[0]) - pl->ob->y) <= pl->socket.mapy / 2))
+          if ((abs (pl->ob->x - x) <= pl->ns->mapx / 2) && (abs (y + map->tile_map[0]->height - pl->ob->y) <= pl->ns->mapy / 2))
             pl->do_los = 1;
         }
       else if (pl->ob->map == map->tile_map[2])
         {
-          if ((abs (pl->ob->x - x) <= pl->socket.mapx / 2) && (abs (pl->ob->y + MAP_HEIGHT (map) - y) <= pl->socket.mapy / 2))
+          if ((abs (pl->ob->x - x) <= pl->ns->mapx / 2) && (abs (pl->ob->y + map->height - y) <= pl->ns->mapy / 2))
             pl->do_los = 1;
         }
       else if (pl->ob->map == map->tile_map[1])
         {
-          if ((abs (pl->ob->x + MAP_WIDTH (map) - x) <= pl->socket.mapx / 2) && (abs (pl->ob->y - y) <= pl->socket.mapy / 2))
+          if ((abs (pl->ob->x + map->width - x) <= pl->ns->mapx / 2) && (abs (pl->ob->y - y) <= pl->ns->mapy / 2))
             pl->do_los = 1;
         }
       else if (pl->ob->map == map->tile_map[3])
         {
-          if ((abs (x + MAP_WIDTH (map->tile_map[3]) - pl->ob->x) <= pl->socket.mapx / 2) && (abs (pl->ob->y - y) <= pl->socket.mapy / 2))
+          if ((abs (x + map->tile_map[3]->width - pl->ob->x) <= pl->ns->mapx / 2) && (abs (pl->ob->y - y) <= pl->ns->mapy / 2))
             pl->do_los = 1;
         }
     }
 }
 /*
  * Debug-routine which dumps the array which specifies the visible
  * area of a player.  Triggered by the z key in DM mode.
  */
 void
 print_los (object *op)
 {
   int x, y;
   char buf[50], buf2[10];
   strcpy (buf, "   ");
-  for (x = 0; x < op->contr->socket.mapx; x++)
+  for (x = 0; x < op->contr->ns->mapx; x++)
     {
       sprintf (buf2, "%2d", x);
       strcat (buf, buf2);
     }
   new_draw_info (NDI_UNIQUE, 0, op, buf);
-  for (y = 0; y < op->contr->socket.mapy; y++)
+  for (y = 0; y < op->contr->ns->mapy; y++)
     {
       sprintf (buf, "%2d:", y);
-      for (x = 0; x < op->contr->socket.mapx; x++)
+      for (x = 0; x < op->contr->ns->mapx; x++)
         {
           sprintf (buf2, " %1d", op->contr->blocked_los[x][y]);
           strcat (buf, buf2);
         }
       new_draw_info (NDI_UNIQUE, 0, op, buf);
     }
 }
 /*
  */
 void
 make_sure_seen (const object *op)
 {
-  player *pl;
+  for_all_players (pl)
-  for (pl = first_player; pl; pl = pl->next)
     if (pl->ob->map == op->map &&
-        pl->ob->y - pl->socket.mapy / 2 <= op->y &&
+        pl->ob->y - pl->ns->mapy / 2 <= op->y &&
-        pl->ob->y + pl->socket.mapy / 2 >= op->y && pl->ob->x - pl->socket.mapx / 2 <= op->x && pl->ob->x + pl->socket.mapx / 2 >= op->x)
+        pl->ob->y + pl->ns->mapy / 2 >= op->y && pl->ob->x - pl->ns->mapx / 2 <= op->x && pl->ob->x + pl->ns->mapx / 2 >= op->x)
-      pl->blocked_los[pl->socket.mapx / 2 + op->x - pl->ob->x][pl->socket.mapy / 2 + op->y - pl->ob->y] = 0;
+      pl->blocked_los[pl->ns->mapx / 2 + op->x - pl->ob->x][pl->ns->mapy / 2 + op->y - pl->ob->y] = 0;
 }
 /*
  * make_sure_not_seen: The object which is supposed to be visible through
  * walls has just been removed from the map, so update the los of any
  */
 void
 make_sure_not_seen (const object *op)
 {
-  player *pl;
+  for_all_players (pl)
-  for (pl = first_player; pl; pl = pl->next)
     if (pl->ob->map == op->map &&
-        pl->ob->y - pl->socket.mapy / 2 <= op->y &&
+        pl->ob->y - pl->ns->mapy / 2 <= op->y &&
-        pl->ob->y + pl->socket.mapy / 2 >= op->y && pl->ob->x - pl->socket.mapx / 2 <= op->x && pl->ob->x + pl->socket.mapx / 2 >= op->x)
+        pl->ob->y + pl->ns->mapy / 2 >= op->y && pl->ob->x - pl->ns->mapx / 2 <= op->x && pl->ob->x + pl->ns->mapx / 2 >= op->x)
       pl->do_los = 1;
 }

Diff Legend

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

Comparing deliantra/server/common/los.C (file contents): Revision 1.7 by root, Mon Dec 11 21:32:16 2006 UTC vs. Revision 1.16 by pippijn, Sat Jan 6 14:42:29 2007 UTC

Diff Legend

Comparing deliantra/server/common/los.C (file contents):
Revision 1.7 by root, Mon Dec 11 21:32:16 2006 UTC vs.
Revision 1.16 by pippijn, Sat Jan 6 14:42:29 2007 UTC