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

Comparing deliantra/server/socket/request.C (file contents):
Revision 1.64 by pippijn, Sat Jan 20 13:47:17 2007 UTC vs.
Revision 1.69 by root, Sun Mar 11 02:12:45 2007 UTC

  * have the prototype of (char *data, int datalen, int client_num).  This
  * way, we can use one dispatch table.
  *
  * esrv_map_new starts updating the map
  *
- * esrv_map_setbelow allows filling in all of the faces for the map.
- * if a face has not already been sent to the client, it is sent now.
- *
  */
 #include <global.h>
 #include <sproto.h>
     pl->ns->send_packet ("newmap");
   pl->ns->floorbox_reset ();
 }
-/** check for map change and send new map data */
+/** check for map/region change and send new map data */
 static void
 check_map_change (player *pl)
 {
   client &socket = *pl->ns;
   object *ob = pl->ob;
         }
     }
   socket.current_x = ob->x;
   socket.current_y = ob->y;
+  region *reg = ob->region ();
+  if (socket.current_region != reg)
+    {
+      socket.current_region = reg;
+      socket.send_packet_printf ("drawinfo 0 You are now %s.\n(use whereami for more details)", &reg->longname);
+    }
 }
 /**
  * RequestInfo is sort of a meta command. There is some specific
  * request of information, but we call other functions to provide
   uint16 smoothface;
   /* If we can't find a face, return and set it so we won't try to send this
    * again.
    */
-  if ((!FindSmooth (face, &smoothface)) && (!FindSmooth (smooth_face->number, &smoothface)))
+  if (!FindSmooth (face, &smoothface))
     {
-      LOG (llevError, "could not findsmooth for %d. Neither default (%s)\n", face, &smooth_face->name);
+      LOG (llevError, "could not findsmooth for %d.\n", face);
       ns->faces_sent[face] |= NS_FACESENT_SMOOTH;
       return;
     }
   if (!(ns->faces_sent[smoothface] & NS_FACESENT_FACE))
      << uint16 (smoothface);
   ns->send_packet (sl);
 }
- /**
+/**
-  * Tells client the picture it has to use
+ * Tells client the picture it has to use
-  * to smooth a picture number given as argument.
+ * to smooth a picture number given as argument.
-  */
+ */
 void
 AskSmooth (char *buf, int len, client *ns)
 {
   SendSmooth (ns, atoi (buf));
 }
    * commands.
    */
   pl->count = 0;
   //TODO: schmorp thinks whatever this calculates, it makes no sense at all
-  int time = FABS (pl->ob->speed) < 0.001
+  int time = fabs (pl->ob->speed) < 0.001
                 ? time = MAX_TIME * 100
-                : time = (int) (MAX_TIME / FABS (pl->ob->speed));
+                : time = (int) (MAX_TIME / fabs (pl->ob->speed));
   /* Send confirmation of command execution now */
   packet sl ("comc");
   sl << uint16 (cmdid) << uint32 (time);
   pl->ns->send_packet (sl);
 {
   packet sl ("player");
   sl << uint32 (pl->ob->count)
      << uint32 (weight)
-     << uint32 (pl->ob->face->number)
+     << uint32 (pl->ob->face)
      << data8  (pl->ob->name);
   pl->ns->last_weight = weight;
   pl->ns->send_packet (sl);
   SET_FLAG (pl->ob, FLAG_CLIENT_SENT);
 /******************************************************************************
  *
  * Start of map related commands.
  *
  ******************************************************************************/
-/**
- * This adds face_num to a map cell at x,y.  If the client doesn't have
- * the face yet, we will also send it.
- */
-static void
-esrv_map_setbelow (client * ns, int x, int y, short face_num, struct Map *newmap)
-{
-  if (newmap->cells[x][y].count >= MAP_LAYERS)
-    {
-      //TODO: one or the other, can't both have abort and return, verify and act
-      LOG (llevError, "Too many faces in map cell %d %d\n", x, y);
-      return;
-      abort ();
-    }
-  newmap->cells[x][y].faces[newmap->cells[x][y].count] = face_num;
-  newmap->cells[x][y].count++;
-  if (!(ns->faces_sent[face_num] & NS_FACESENT_FACE))
-    esrv_send_face (ns, face_num, 0);
-}
 /** Clears a map cell */
 static void
 map_clearcell (struct MapCell *cell, int face0, int face1, int face2, int count)
 {
 check_head (packet &sl, client &ns, int ax, int ay, int layer)
 {
   short face_num;
   if (heads[(ay * MAX_HEAD_POS + ax) * MAX_LAYERS + layer])
-    face_num = heads[(ay * MAX_HEAD_POS + ax) * MAX_LAYERS + layer]->face->number;
+    face_num = heads[(ay * MAX_HEAD_POS + ax) * MAX_LAYERS + layer]->face;
   else
     face_num = 0;
   if (face_num != ns.lastmap.cells[ax][ay].faces[layer])
     {
   if (!ob || ob->face == blank_face)
     face_num = 0;
   else if (head)
     {
       /* if this is a head that had previously been stored */
-      face_num = ob->face->number;
+      face_num = ob->face;
     }
   else
     {
       /* if the faces for the different parts of a multipart object
        * are the same, we only want to send the bottom right most
           /* single part object, multipart object with non merged faces,
            * of multipart object already at lower right.
            */
           else if (bx == sx && by == sy)
             {
-              face_num = ob->face->number;
+              face_num = ob->face;
               /* if this face matches one stored away, clear that one away.
                * this code relies on the fact that the map1 commands
                * goes from 2 down to 0.
                */
               for (i = 0; i < MAP_LAYERS; i++)
                 if (heads[(sy * MAX_HEAD_POS + sx) * MAX_LAYERS + i] &&
-                    heads[(sy * MAX_HEAD_POS + sx) * MAX_LAYERS + i]->face->number == face_num)
+                    heads[(sy * MAX_HEAD_POS + sx) * MAX_LAYERS + i]->face == face_num)
                   heads[(sy * MAX_HEAD_POS + sx) * MAX_LAYERS + i] = NULL;
             }
           else
             {
               /* If this head is stored away, clear it - otherwise,
                * there can be cases where a object is on multiple layers -
                * we only want to send it once.
                */
-              face_num = head->face->number;
+              face_num = head->face;
               for (i = 0; i < MAP_LAYERS; i++)
                 if (heads[(by * MAX_HEAD_POS + bx) * MAX_LAYERS + i] &&
-                    heads[(by * MAX_HEAD_POS + bx) * MAX_LAYERS + i]->face->number == face_num)
+                    heads[(by * MAX_HEAD_POS + bx) * MAX_LAYERS + i]->face == face_num)
                   heads[(by * MAX_HEAD_POS + bx) * MAX_LAYERS + i] = NULL;
               /* First, try to put the new head on the same layer.  If that is used up,
                * then find another layer.
                */
       else
         {
           /* In this case, we are already at the lower right or single part object,
            * so nothing special
            */
-          face_num = ob->face->number;
+          face_num = ob->face;
           /* clear out any head entries that have the same face as this one */
           for (bx = 0; bx < layer; bx++)
             if (heads[(sy * MAX_HEAD_POS + sx) * MAX_LAYERS + bx] &&
-                heads[(sy * MAX_HEAD_POS + sx) * MAX_LAYERS + bx]->face->number == face_num)
+                heads[(sy * MAX_HEAD_POS + sx) * MAX_LAYERS + bx]->face == face_num)
               heads[(sy * MAX_HEAD_POS + sx) * MAX_LAYERS + bx] = NULL;
         }
     }                           /* else not already head object or blank face */
   /* This is a real hack.  Basically, if we have nothing to send for this layer,
    * of the same type, what happens then is it doesn't think it needs to send
    * This tends to make stacking also work/look better.
    */
   if (!face_num && layer > 0 && heads[(sy * MAX_HEAD_POS + sx) * MAX_LAYERS + layer - 1])
     {
-      face_num = heads[(sy * MAX_HEAD_POS + sx) * MAX_LAYERS + layer - 1]->face->number;
+      face_num = heads[(sy * MAX_HEAD_POS + sx) * MAX_LAYERS + layer - 1]->face;
       heads[(sy * MAX_HEAD_POS + sx) * MAX_LAYERS + layer - 1] = NULL;
     }
   /* Another hack - because of heads and whatnot, this face may match one
    * we already sent for a lower layer.  In that case, don't send
   if (!ob || ob->face == blank_face)
     smoothlevel = 0;
   else
     {
       smoothlevel = ob->smoothlevel;
-      if (smoothlevel && !(ns.faces_sent[ob->face->number] & NS_FACESENT_SMOOTH))
+      if (smoothlevel && !(ns.faces_sent[ob->face] & NS_FACESENT_SMOOTH))
-        SendSmooth (&ns, ob->face->number);
+        SendSmooth (&ns, ob->face);
     }                           /* else not already head object or blank face */
   /* We've gotten what face we want to use for the object.  Now see if
    * if it has changed since we last sent it to the client.
    */
                 if (update_smooth (esl, socket, m, nx, ny, ax, ay, 1))
                   emask |= 0x2;
               if (nx == pl->x && ny == pl->y && pl->invisible & (pl->invisible < 50 ? 4 : 1))
                 {
-                  if (lastcell.faces[0] != pl->face->number)
+                  if (lastcell.faces[0] != pl->face)
                     {
-                      lastcell.faces[0] = pl->face->number;
+                      lastcell.faces[0] = pl->face;
                       mask |= 0x1;
-                      if (!(socket.faces_sent[pl->face->number] & NS_FACESENT_FACE))
+                      if (!(socket.faces_sent[pl->face] & NS_FACESENT_FACE))
-                        esrv_send_face (&socket, pl->face->number, 0);
+                        esrv_send_face (&socket, pl->face, 0);
-                      sl << uint16 (pl->face->number);
+                      sl << uint16 (pl->face);
                     }
                 }
               else
                 {
                   /* Top face */
  */
 void
 draw_client_map (object *pl)
 {
   int i, j;
-  sint16 ax, ay, nx, ny;        /* ax and ay goes from 0 to max-size of arrays */
+  sint16 ax, ay;        /* ax and ay goes from 0 to max-size of arrays */
-  facetile *face, *floor;
-  facetile *floor2;
-  int d, mflags;
+  int mflags;
   struct Map newmap;
   maptile *m, *pm;
   if (pl->type != PLAYER)
     {
 /* appends the spell *spell to the Socklist we will send the data to. */
 static void
 append_spell (player *pl, packet &sl, object *spell)
 {
-  int len, i, skill = 0;
+  int i, skill = 0;
   if (!(spell->name))
     {
       LOG (llevError, "item number %d is a spell with no name.\n", spell->count);
       return;
         if (!strcmp (spell->skill, skill_names[i]))
           {
             skill = i + CS_STAT_SKILLINFO;
             break;
           }
+    }
+  // spells better have a face
+  if (!spell->face)
+    {
+      LOG (llevError, "%s: spell has no face, but face is mandatory.\n", &spell->name);
+      spell->face = face_find ("burnout.x11", blank_face);
     }
   /* send the current values */
   sl << uint32 (spell->count)
      << uint16 (spell->level)
      << uint16 (spell->last_sp)
      << uint16 (spell->last_grace)
      << uint16 (spell->last_eat)
      << uint8  (skill)
      << uint32 (spell->path_attuned)
-     << uint32 (spell->face ? spell->face->number : 0)
+     << uint32 (spell->face)
      << data8  (spell->name)
      << data16 (spell->msg);
 }
 /**
   packet sl ("addspell");
   if (!spell)
     {
-      for (spell = pl->ob->inv; spell != NULL; spell = spell->below)
+      for (spell = pl->ob->inv; spell; spell = spell->below)
         {
           /* were we to simply keep appending data here, we could exceed
            * MAXSOCKBUF if the player has enough spells to add, we know that
            * append_spells will always append 19 data bytes, plus 4 length
            * bytes and 3 strings (because that is the spec) so we need to

Diff Legend

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

Comparing deliantra/server/socket/request.C (file contents): Revision 1.64 by pippijn, Sat Jan 20 13:47:17 2007 UTC vs. Revision 1.69 by root, Sun Mar 11 02:12:45 2007 UTC

Diff Legend

Comparing deliantra/server/socket/request.C (file contents):
Revision 1.64 by pippijn, Sat Jan 20 13:47:17 2007 UTC vs.
Revision 1.69 by root, Sun Mar 11 02:12:45 2007 UTC