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

Comparing deliantra/server/common/los.C (file contents):
Revision 1.36 by root, Mon Dec 8 15:40:13 2008 UTC vs.
Revision 1.37 by root, Thu Dec 18 02:49:22 2008 UTC

  * An object is 1.0 wide, so if set to 0.5, it means the object
  * that blocks half the view (0.0 is complete block) will
  * block view in our tables.
  * .4 or less lets you see through walls.  .5 is about right.
  */
 #define SPACE_BLOCK	0.5
 typedef struct blstr
 {
   int x[4], y[4];
 /* since we are only doing the upper left quadrant, only
  * these spaces could possibly get blocked, since these
  * are the only ones further out that are still possibly in the
  * sightline.
  */
 void
 init_block (void)
 {
-  int x, y, dx, dy, i;
   static int block_x[3] = { -1, -1, 0 },
              block_y[3] = { -1, 0, -1 };
-  for (x = 0; x < MAP_CLIENT_X; x++)
+  for (int x = 0; x < MAP_CLIENT_X; x++)
-    for (y = 0; y < MAP_CLIENT_Y; y++)
+    for (int y = 0; y < MAP_CLIENT_Y; y++)
       block[x][y].index = 0;
   /* The table should be symmetric, so only do the upper left
    * quadrant - makes the processing easier.
    */
-  for (x = 1; x <= MAP_CLIENT_X / 2; x++)
+  for (int x = 1; x <= MAP_CLIENT_X / 2; x++)
     {
-      for (y = 1; y <= MAP_CLIENT_Y / 2; y++)
+      for (int y = 1; y <= MAP_CLIENT_Y / 2; y++)
         {
-          for (i = 0; i < 3; i++)
+          for (int i = 0; i < 3; i++)
             {
-              dx = x + block_x[i];
+              int dx = x + block_x[i];
-              dy = y + block_y[i];
+              int dy = y + block_y[i];
               /* center space never blocks */
               if (x == MAP_CLIENT_X / 2 && y == MAP_CLIENT_Y / 2)
                 continue;
                 }
               else
                 {
                   float d1, r, s, l;
-                  /* We use the algorihm that found out how close the point
+                  /* We use the algorithm that found out how close the point
                    * (x,y) is to the line from dx,dy to the center of the viewable
-                   * area.  l is the distance from x,y to the line.
+                   * area. l is the distance from x,y to the line.
                    * r is more a curiosity - it lets us know what direction (left/right)
                    * the line is off
                    */
-                  d1 = (float) (pow (MAP_CLIENT_X / 2 - dx, 2.f) + pow (MAP_CLIENT_Y / 2 - dy, 2.f));
+                  d1 = (powf (MAP_CLIENT_X / 2 - dx, 2.f) + powf (MAP_CLIENT_Y / 2 - dy, 2.f));
-                  r = (float) ((dy - y) * (dy - MAP_CLIENT_Y / 2) - (dx - x) * (MAP_CLIENT_X / 2 - dx)) / d1;
+                  r = ((dy - y) * (dy - MAP_CLIENT_Y / 2) - (dx - x) * (MAP_CLIENT_X / 2 - dx)) / d1;
-                  s = (float) ((dy - y) * (MAP_CLIENT_X / 2 - dx) - (dx - x) * (MAP_CLIENT_Y / 2 - dy)) / d1;
+                  s = ((dy - y) * (MAP_CLIENT_X / 2 - dx) - (dx - x) * (MAP_CLIENT_Y / 2 - dy)) / d1;
-                  l = FABS (sqrt (d1) * s);
+                  l = fabs (sqrtf (d1) * s);
                   if (l <= SPACE_BLOCK)
                     {
                       /* For simplicity, we mirror the coordinates to block the other
                        * quadrants.
  * In this way, the chain of visibility is set.
  */
 static void
 set_wall (object *op, int x, int y)
 {
-  int i;
-  for (i = 0; i < block[x][y].index; i++)
+  for (int i = 0; i < block[x][y].index; i++)
     {
       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.
 /*
  * Used to initialise the array used by the LOS routines.
  * op is the object, x and y values based on MAP_CLIENT_X and Y.
  * this is because they index the blocked[][] arrays.
  */
 static void
 check_wall (object *op, int x, int y)
 {
   int ax, ay;
  * expand_sight goes through the array of what the given player is
  * able to see, and expands the visible area a bit, so the player will,
  * to a certain degree, be able to see into corners.
  * This is somewhat suboptimal, would be better to improve the formula.
  */
 static void
 expand_sight (object *op)
 {
-  int i, x, y, dx, dy;
-  for (x = 1; x < op->contr->ns->mapx - 1; x++)      /* loop over inner squares */
+  for (int x = 1; x < op->contr->ns->mapx - 1; x++)      /* loop over inner squares */
-    for (y = 1; y < op->contr->ns->mapy - 1; y++)
+    for (int y = 1; y < op->contr->ns->mapy - 1; y++)
-      {
-        if (!op->contr->blocked_los[x][y] &&
+      if (!op->contr->blocked_los[x][y] &&
-            !(get_map_flags (op->map, NULL,
+          !(get_map_flags (op->map, NULL,
-                             op->x - op->contr->ns->mapx / 2 + x,
+                           op->x - op->contr->ns->mapx / 2 + x,
-                             op->y - op->contr->ns->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)
+          for (int i = 1; i <= 8; i += 1)
-              {                 /* mark all directions */
+            {                 /* mark all directions */
-                dx = x + freearr_x[i];
+              int dx = x + freearr_x[i];
-                dy = y + freearr_y[i];
+              int dy = y + freearr_y[i];
-                if (op->contr->blocked_los[dx][dy] > 0) /* for any square blocked */
+              if (op->contr->blocked_los[dx][dy] > 0) /* for any square blocked */
-                  op->contr->blocked_los[dx][dy] = -1;
+                op->contr->blocked_los[dx][dy] = -1;
-              }
+            }
-          }
+        }
-      }
   if (op->map->darkness > 0)       /* player is on a dark map */
     expand_lighted_sight (op);
   /* clear mark squares */
-  for (x = 0; x < op->contr->ns->mapx; x++)
+  for (int x = 0; x < op->contr->ns->mapx; x++)
-    for (y = 0; y < op->contr->ns->mapy; y++)
+    for (int y = 0; y < op->contr->ns->mapy; y++)
       if (op->contr->blocked_los[x][y] < 0)
         op->contr->blocked_los[x][y] = 0;
 }
 /* returns true if op carries one or more lights
  * This is a trivial function now days, but it used to
  * be a bit longer.  Probably better for callers to just
  * check the op->glow_radius instead of calling this.
  */
 int
 has_carried_lights (const object *op)
 {
   /* op may glow! */
   if (op->glow_radius > 0)

Diff Legend

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

Comparing deliantra/server/common/los.C (file contents): Revision 1.36 by root, Mon Dec 8 15:40:13 2008 UTC vs. Revision 1.37 by root, Thu Dec 18 02:49:22 2008 UTC

Diff Legend

Comparing deliantra/server/common/los.C (file contents):
Revision 1.36 by root, Mon Dec 8 15:40:13 2008 UTC vs.
Revision 1.37 by root, Thu Dec 18 02:49:22 2008 UTC