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

Comparing deliantra/server/socket/request.C (file contents):
Revision 1.68 by root, Sun Mar 4 19:36:12 2007 UTC vs.
Revision 1.69 by root, Sun Mar 11 02:12:45 2007 UTC

 {
   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);
 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 */
             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->casting_time)
      << 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.68 by root, Sun Mar 4 19:36:12 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.68 by root, Sun Mar 4 19:36:12 2007 UTC vs.
Revision 1.69 by root, Sun Mar 11 02:12:45 2007 UTC