--- deliantra/server/socket/request.C	2006/12/16 03:08:26	1.42
+++ deliantra/server/socket/request.C	2007/01/01 12:28:47	1.56
@@ -40,9 +40,6 @@
  * 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.
  *
- * mapcellchanged, compactlayer, compactstack, perform the map compressing
- * operations
- *
  */
 
 #include <global.h>
@@ -88,7 +85,7 @@
 };
 
 static void
-socket_map_scroll (client * ns, int dx, int dy)
+socket_map_scroll (client *ns, int dx, int dy)
 {
   struct Map newmap;
   int x, y, mx, my;
@@ -143,22 +140,19 @@
 static void
 clear_map (player *pl)
 {
-  client &socket = *pl->socket;
-
-  memset (&socket.lastmap, 0, sizeof (socket.lastmap));
+  memset (&pl->ns->lastmap, 0, sizeof (pl->ns->lastmap));
 
-  if (socket.newmapcmd == 1)
-    socket.send_packet ("newmap");
+  if (pl->ns->newmapcmd == 1)
+    pl->ns->send_packet ("newmap");
 
-  socket.update_look = 1;
-  socket.look_position = 0;
+  pl->ns->floorbox_reset ();
 }
 
 /** check for map change and send new map data */
 static void
 check_map_change (player *pl)
 {
-  client &socket = *pl->socket;
+  client &socket = *pl->ns;
   object *ob = pl->ob;
   char buf[MAX_BUF];            /* eauugggh */
 
@@ -184,7 +178,7 @@
                 flags |= 8;
 
               snprintf (buf, MAX_BUF, "mapinfo - spatial %d %d %d %d %d %s",
-                        flags, socket.mapx / 2 - ob->x, socket.mapy / 2 - ob->y, ob->map->width, ob->map->height, ob->map->path);
+                        flags, socket.mapx / 2 - ob->x, socket.mapy / 2 - ob->y, ob->map->width, ob->map->height, &ob->map->path);
             }
           else
             snprintf (buf, MAX_BUF, "mapinfo current");
@@ -202,8 +196,7 @@
       else
         {
           socket_map_scroll (&socket, ob->x - socket.current_x, ob->y - socket.current_y);
-          socket.update_look = 1;
-          socket.look_position = 0;
+          socket.floorbox_reset ();
         }
     }
 
@@ -262,6 +255,12 @@
 }
 
 void
+ExtiCmd (char *buf, int len, client *ns)
+{
+  INVOKE_CLIENT (EXTICMD, ns, ARG_DATA (buf, len));
+}
+
+void
 MapInfoCmd (char *buf, int len, player *pl)
 {
   // <mapinfo tag spatial tile-path
@@ -283,8 +282,8 @@
       // initial map and its origin
       maptile *map = pl->ob->map;
       sint16 dx, dy;
-      int mapx = pl->socket->mapx / 2 - pl->ob->x;
-      int mapy = pl->socket->mapy / 2 - pl->ob->y;
+      int mapx = pl->ns->mapx / 2 - pl->ob->x;
+      int mapy = pl->ns->mapy / 2 - pl->ob->y;
       int max_distance = 8;     // limit maximum path length to something generous
 
       while (*buf && map && max_distance)
@@ -337,7 +336,7 @@
           if (map->tile_path[3])
             flags |= 8;
 
-          snprintf (bigbuf, MAX_BUF, "mapinfo %s spatial %d %d %d %d %d %s", token, flags, mapx, mapy, map->width, map->height, map->path);
+          snprintf (bigbuf, MAX_BUF, "mapinfo %s spatial %d %d %d %d %d %s", token, flags, mapx, mapy, map->width, map->height, &map->path);
         }
       else
         snprintf (bigbuf, MAX_BUF, "mapinfo %s nomap", token);
@@ -345,7 +344,7 @@
   else
     snprintf (bigbuf, MAX_BUF, "mapinfo %s unsupported", token);
 
-  pl->socket->send_packet (bigbuf);
+  pl->ns->send_packet (bigbuf);
 }
 
 /** This is the Setup cmd - easy first implementation */
@@ -402,10 +401,7 @@
           safe_strcat (cmdback, param, &slen, HUGE_BUF);
         }
       else if (!strcmp (cmd, "exp64"))
-        {
-          ns->exp64 = atoi (param);
-          safe_strcat (cmdback, param, &slen, HUGE_BUF);
-        }
+        safe_strcat (cmdback, param, &slen, HUGE_BUF);
       else if (!strcmp (cmd, "spellmon"))
         {
           ns->monitor_spells = atoi (param);
@@ -572,15 +568,7 @@
 void
 AddMeCmd (char *buf, int len, client * ns)
 {
-  Settings oldsettings;
-
-  oldsettings = settings;
-  if (ns->status != Ns_Add || add_player (ns))
-    ns->send_packet ("addme_failed");
-  else
-    ns->send_packet ("addme_success");
-
-  settings = oldsettings;
+  INVOKE_CLIENT (ADDME, ns, ARG_DATA (buf, len));
 }
 
 /** Reply to ExtendedInfos command */
@@ -707,7 +695,7 @@
  * client.
  */
 static void
-SendSmooth (client * ns, uint16 face)
+SendSmooth (client *ns, uint16 face)
 {
   uint16 smoothface;
 
@@ -727,10 +715,9 @@
 
   ns->faces_sent[face] |= NS_FACESENT_SMOOTH;
 
-  packet sl;
+  packet sl ("smooth");
 
-  sl << "smooth "
-     << uint16 (face)
+  sl << uint16 (face)
      << uint16 (smoothface);
 
   ns->send_packet (sl);
@@ -741,12 +728,9 @@
   * to smooth a picture number given as argument.
   */
 void
-AskSmooth (char *buf, int len, client * ns)
+AskSmooth (char *buf, int len, client *ns)
 {
-  uint16 facenbr;
-
-  facenbr = atoi (buf);
-  SendSmooth (ns, facenbr);
+  SendSmooth (ns, atoi (buf));
 }
 
 /**
@@ -756,48 +740,28 @@
 void
 PlayerCmd (char *buf, int len, player *pl)
 {
-
-  /* The following should never happen with a proper or honest client.
-   * Therefore, the error message doesn't have to be too clear - if 
-   * someone is playing with a hacked/non working client, this gives them
-   * an idea of the problem, but they deserve what they get
-   */
-  if (pl->state != ST_PLAYING)
-    {
-      new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "You can not issue commands - state is not ST_PLAYING (%s)", buf);
-      return;
-    }
   /* Check if there is a count.  In theory, a zero count could also be
    * sent, so check for that also.
    */
   if (atoi (buf) || buf[0] == '0')
     {
       pl->count = atoi ((char *) buf);
+
       buf = strchr (buf, ' ');  /* advance beyond the numbers */
       if (!buf)
-        {
-#ifdef ESRV_DEBUG
-          LOG (llevDebug, "PlayerCmd: Got count but no command.\n");
-#endif
-          return;
-        }
+        return;
+
       buf++;
     }
-  /* This should not happen anymore.    */
-  if (pl->ob->speed_left < -1.0)
-    {
-      LOG (llevError, "Player has negative time - shouldn't do command.\n");
-    }
-  /* In c_new.c */
+
   execute_newserver_command (pl->ob, (char *) buf);
+
   /* Perhaps something better should be done with a left over count.
    * Cleaning up the input should probably be done first - all actions
    * for the command that issued the count should be done before any other
    * commands.
    */
-
   pl->count = 0;
-
 }
 
 
@@ -810,35 +774,23 @@
 void
 NewPlayerCmd (char *buf, int len, player *pl)
 {
-  int time, repeat;
-  char command[MAX_BUF];
-  int pktlen;
-
-  if (len < 7)
+  if (len <= 6)
     {
       LOG (llevDebug, "Corrupt ncom command <%s> not long enough - discarding\n", buf);
       return;
     }
 
-  pktlen = net_uint16 ((uint8 *)buf);
-  repeat = net_uint32 ((uint8 *)buf + 2);
+  uint16 cmdid  = net_uint16 ((uint8 *)buf);
+  sint32 repeat = net_sint32 ((uint8 *)buf + 2);
 
   /* -1 is special - no repeat, but don't update */
   if (repeat != -1)
     pl->count = repeat;
 
-  if ((len - 4) >= MAX_BUF)
-    len = MAX_BUF - 5;
-
-  strncpy ((char *) command, (char *) buf + 6, len - 4);
-  command[len - 4] = 0;
+  buf += 6; //len -= 6;
 
-  /* This should not happen anymore.    */
-  if (pl->ob->speed_left < -1.0)
-    LOG (llevError, "Player has negative time - shouldn't do command.\n");
+  execute_newserver_command (pl->ob, buf);
 
-  /* In c_new.c */
-  execute_newserver_command (pl->ob, (char *) command);
   /* Perhaps something better should be done with a left over count.
    * Cleaning up the input should probably be done first - all actions
    * for the command that issued the count should be done before any other
@@ -846,25 +798,35 @@
    */
   pl->count = 0;
 
-  if (FABS (pl->ob->speed) < 0.001)
-    time = MAX_TIME * 100;
-  else
-    time = (int) (MAX_TIME / FABS (pl->ob->speed));
+  //TODO: schmorp thinks whatever this calculates, it makes no sense at all
+  int time = FABS (pl->ob->speed) < 0.001
+                ? time = MAX_TIME * 100
+                : time = (int) (MAX_TIME / FABS (pl->ob->speed));
 
   /* Send confirmation of command execution now */
-
-  packet sl;
-  sl << "comc " << uint16 (pktlen) << uint32 (time);
-  pl->socket->send_packet (sl);
+  packet sl ("comc");
+  sl << uint16 (cmdid) << uint32 (time);
+  pl->ns->send_packet (sl);
 }
 
-
 /** This is a reply to a previous query. */
 void
-ReplyCmd (char *buf, int len, player *pl)
+ReplyCmd (char *buf, int len, client *ns)
 {
+  if (ns->state == ST_CUSTOM)
+    {
+      INVOKE_CLIENT (REPLY, ns, ARG_DATA (buf, len));
+      return;
+    }
+
+  if (!ns->pl)
+    return; //TODO: depends on the exact reply we are after
+            //TODO: but right now, we always have a ns->pl
+
+  player *pl = ns->pl;
+
   /* This is to synthesize how the data would be stored if it
-   * was normally entered.  A bit of a hack, and should be cleaned up
+   * was normally entered. A bit of a hack, and should be cleaned up
    * once all the X11 code is removed from the server.
    *
    * We pass 13 to many of the functions because this way they
@@ -875,52 +837,26 @@
 
   /* this avoids any hacking here */
 
-  switch (pl->state)
+  switch (ns->state)
     {
-        case ST_PLAYING:
-          LOG (llevError, "Got reply message with ST_PLAYING input state\n");
-          break;
-
-        case ST_PLAY_AGAIN:
-          /* We can check this for return value (2==quit).  Maybe we
-           * should, and do something appropriate?
-           */
-          receive_play_again (pl->ob, buf[0]);
-          break;
+      case ST_PLAYING:
+        LOG (llevError, "Got reply message with ST_PLAYING input state\n");
+        break;
+
+      case ST_CHANGE_CLASS:
+        key_change_class (pl->ob, buf[0]);
+        break;
 
-        case ST_ROLL_STAT:
-          key_roll_stat (pl->ob, buf[0]);
-          break;
-
-        case ST_CHANGE_CLASS:
-
-          key_change_class (pl->ob, buf[0]);
-          break;
-
-        case ST_CONFIRM_QUIT:
-          key_confirm_quit (pl->ob, buf[0]);
-          break;
-
-        case ST_CONFIGURE:
-          LOG (llevError, "In client input handling, but into configure state\n");
-          pl->state = ST_PLAYING;
-          break;
-
-        case ST_GET_NAME:
-          receive_player_name (pl->ob, 13);
-          break;
-
-        case ST_GET_PASSWORD:
-        case ST_CONFIRM_PASSWORD:
-          receive_player_password (pl->ob, 13);
-          break;
-
-        case ST_GET_PARTY_PASSWORD:    /* Get password for party */
-          receive_party_password (pl->ob, 13);
-          break;
+      case ST_CONFIRM_QUIT:
+        key_confirm_quit (pl->ob, buf[0]);
+        break;
 
-        default:
-          LOG (llevError, "Unknown input state: %d\n", pl->state);
+      case ST_GET_PARTY_PASSWORD:    /* Get password for party */
+        receive_party_password (pl->ob, 13);
+        break;
+
+      default:
+        LOG (llevError, "Unknown input state: %d\n", ns->state);
     }
 }
 
@@ -934,9 +870,6 @@
 void
 VersionCmd (char *buf, int len, client * ns)
 {
-  char *cp;
-  char version_warning[256];
-
   if (!buf)
     {
       LOG (llevError, "CS: received corrupted version command\n");
@@ -945,36 +878,33 @@
 
   ns->cs_version = atoi (buf);
   ns->sc_version = ns->cs_version;
-  if (VERSION_CS != ns->cs_version)
-    {
-#ifdef ESRV_DEBUG
-      LOG (llevDebug, "CS: csversion mismatch (%d,%d)\n", VERSION_CS, ns->cs_version);
-#endif
-    }
-  cp = strchr (buf + 1, ' ');
+
+  LOG (llevDebug, "connection from client <%s>\n", buf);
+
+
+  //TODO: should log here just for statistics
+
+  //if (VERSION_CS != ns->cs_version)
+  //  unchecked;
+
+  char *cp = strchr (buf + 1, ' ');
   if (!cp)
     return;
+
   ns->sc_version = atoi (cp);
-  if (VERSION_SC != ns->sc_version)
-    {
-#ifdef ESRV_DEBUG
-      LOG (llevDebug, "CS: scversion mismatch (%d,%d)\n", VERSION_SC, ns->sc_version);
-#endif
-    }
+
+  //if (VERSION_SC != ns->sc_version)
+  //  unchecked;
+
   cp = strchr (cp + 1, ' ');
+
   if (cp)
     {
-      LOG (llevDebug, "CS: connection from client of type <%s>, ip %s\n", cp, ns->host);
-
       assign (ns->version, cp + 1);
 
       if (ns->sc_version < 1026)
-        {
-          sprintf (version_warning, "drawinfo %d %s", NDI_RED,
+        ns->send_packet_printf ("drawinfo %d %s", NDI_RED,
                    "**** VERSION WARNING ****\n**** CLIENT IS TOO OLD!! UPDATE THE CLIENT!! ****");
-          ns->send_packet (version_warning);
-        }
-
     }
 }
 
@@ -990,19 +920,11 @@
 void
 MapRedrawCmd (char *buf, int len, player *pl)
 {
-
 /* This function is currently disabled; just clearing the map state results in
  * display errors. It should clear the cache and send a newmap command.
  * Unfortunately this solution does not work because some client versions send
  * a mapredraw command after receiving a newmap command.
  */
-#if 0
-  /* Okay, this is MAJOR UGLY. but the only way I know how to
-   * clear the "cache"
-   */
-  memset (&pl->socket->lastmap, 0, sizeof (struct Map));
-  draw_client_map (pl->ob);
-#endif
 }
 
 /**
@@ -1015,28 +937,29 @@
   int vals[3], i;
 
   /* A little funky here.  We only cycle for 2 records, because
-   * we obviously am not going to find a space after the third
-   * record.  Perhaps we should just replace this with a
+   * we obviously are not going to find a space after the third
+   * record. Perhaps we should just replace this with a
    * sscanf?
    */
   for (i = 0; i < 2; i++)
     {
       vals[i] = atoi (buf);
+
       if (!(buf = strchr (buf, ' ')))
         {
           LOG (llevError, "Incomplete move command: %s\n", buf);
           return;
         }
+
       buf++;
     }
+
   vals[2] = atoi (buf);
 
 /*    LOG(llevDebug,"Move item %d (nrof=%d) to %d.\n", vals[1], vals[2], vals[0]);*/
   esrv_move_object (pl->ob, vals[0], vals[1], vals[2]);
 }
 
-
-
 /******************************************************************************
  *
  * Start of commands the server sends to the client.
@@ -1048,12 +971,9 @@
  * it needs to send something back (vs just printing out a message)
  */
 void
-send_query (client * ns, uint8 flags, char *text)
+send_query (client *ns, uint8 flags, char *text)
 {
-  char buf[MAX_BUF];
-
-  sprintf (buf, "query %d %s", flags, text ? text : "");
-  ns->send_packet (buf);
+  ns->send_packet_printf ("query %d %s", flags, text ? text : "");
 }
 
 #define AddIfInt64(Old,New,Type) if (Old != New) {\
@@ -1093,10 +1013,12 @@
   char buf[MAX_BUF];
   uint16 flags;
 
-  packet sl;
-  sl << "stats ";
+  if (!pl->ns)
+    return;
 
-  if (pl->ob != NULL)
+  packet sl ("stats");
+
+  if (pl->ob)
     {
       AddIfShort (pl->last_stats.hp, pl->ob->stats.hp, CS_STAT_HP);
       AddIfShort (pl->last_stats.maxhp, pl->ob->stats.maxhp, CS_STAT_MAXHP);
@@ -1105,39 +1027,28 @@
       AddIfShort (pl->last_stats.grace, pl->ob->stats.grace, CS_STAT_GRACE);
       AddIfShort (pl->last_stats.maxgrace, pl->ob->stats.maxgrace, CS_STAT_MAXGRACE);
       AddIfShort (pl->last_stats.Str, pl->ob->stats.Str, CS_STAT_STR);
-      AddIfShort (pl->last_stats.Int, pl->ob->stats.Int, CS_STAT_INT);
-      AddIfShort (pl->last_stats.Pow, pl->ob->stats.Pow, CS_STAT_POW);
-      AddIfShort (pl->last_stats.Wis, pl->ob->stats.Wis, CS_STAT_WIS);
       AddIfShort (pl->last_stats.Dex, pl->ob->stats.Dex, CS_STAT_DEX);
       AddIfShort (pl->last_stats.Con, pl->ob->stats.Con, CS_STAT_CON);
+      AddIfShort (pl->last_stats.Int, pl->ob->stats.Int, CS_STAT_INT);
+      AddIfShort (pl->last_stats.Wis, pl->ob->stats.Wis, CS_STAT_WIS);
+      AddIfShort (pl->last_stats.Pow, pl->ob->stats.Pow, CS_STAT_POW);
       AddIfShort (pl->last_stats.Cha, pl->ob->stats.Cha, CS_STAT_CHA);
     }
 
-  if (pl->socket->exp64)
-    {
-      uint8 s;
-
-      for (s = 0; s < NUM_SKILLS; s++)
-        {
-          if (pl->last_skill_ob[s] && pl->last_skill_exp[s] != pl->last_skill_ob[s]->stats.exp)
-            {
-              /* Always send along the level if exp changes.  This is only
-               * 1 extra byte, but keeps processing simpler.
-               */
-              sl << uint8 (s + CS_STAT_SKILLINFO)
-                 << uint8 (pl->last_skill_ob[s]->level)
-                 << uint64 (pl->last_skill_ob[s]->stats.exp);
-
-              pl->last_skill_exp[s] = pl->last_skill_ob[s]->stats.exp;
-            }
-        }
-    }
+  for (int s = 0; s < NUM_SKILLS; s++)
+    if (pl->last_skill_ob[s] && pl->last_skill_exp[s] != pl->last_skill_ob[s]->stats.exp)
+      {
+        /* Always send along the level if exp changes.  This is only
+         * 1 extra byte, but keeps processing simpler.
+         */
+        sl << uint8 (s + CS_STAT_SKILLINFO)
+           << uint8 (pl->last_skill_ob[s]->level)
+           << uint64 (pl->last_skill_ob[s]->stats.exp);
 
-  if (pl->socket->exp64)
-    { AddIfInt64 (pl->last_stats.exp, pl->ob->stats.exp, CS_STAT_EXP64) }
-  else
-    { AddIfInt (pl->last_stats.exp, (int) pl->ob->stats.exp, CS_STAT_EXP) }
+        pl->last_skill_exp[s] = pl->last_skill_ob[s]->stats.exp;
+      }
 
+  AddIfInt64 (pl->last_stats.exp, pl->ob->stats.exp, CS_STAT_EXP64);
   AddIfShort (pl->last_level, (char) pl->ob->level, CS_STAT_LEVEL);
   AddIfShort (pl->last_stats.wc, pl->ob->stats.wc, CS_STAT_WC);
   AddIfShort (pl->last_stats.ac, pl->ob->stats.ac, CS_STAT_AC);
@@ -1156,23 +1067,19 @@
 
   AddIfShort (pl->last_flags, flags, CS_STAT_FLAGS);
 
-  if (pl->socket->sc_version < 1025)
+  if (pl->ns->sc_version < 1025)
     { AddIfShort (pl->last_resist[ATNR_PHYSICAL], pl->ob->resist[ATNR_PHYSICAL], CS_STAT_ARMOUR) }
   else
-    {
-      int i;
-
-      for (i = 0; i < NROFATTACKS; i++)
-        {
-          /* Skip ones we won't send */
-          if (atnr_cs_stat[i] == -1)
-            continue;
+    for (int i = 0; i < NROFATTACKS; i++)
+      {
+        /* Skip ones we won't send */
+        if (atnr_cs_stat[i] == -1)
+          continue;
 
-          AddIfShort (pl->last_resist[i], pl->ob->resist[i], (char) atnr_cs_stat[i]);
-        }
-    }
+        AddIfShort (pl->last_resist[i], pl->ob->resist[i], (char) atnr_cs_stat[i]);
+      }
 
-  if (pl->socket->monitor_spells)
+  if (pl->ns->monitor_spells)
     {
       AddIfInt (pl->last_path_attuned, pl->ob->path_attuned, CS_STAT_SPELL_ATTUNE);
       AddIfInt (pl->last_path_repelled, pl->ob->path_repelled, CS_STAT_SPELL_REPEL);
@@ -1180,13 +1087,13 @@
     }
 
   rangetostring (pl->ob, buf);  /* we want use the new fire & run system in new client */
-  AddIfString (pl->socket->stats.range, buf, CS_STAT_RANGE);
+  AddIfString (pl->ns->stats.range, buf, CS_STAT_RANGE);
   set_title (pl->ob, buf);
-  AddIfString (pl->socket->stats.title, buf, CS_STAT_TITLE);
+  AddIfString (pl->ns->stats.title, buf, CS_STAT_TITLE);
 
   /* Only send it away if we have some actual data */
   if (sl.length () > 6)
-    pl->socket->send_packet (sl);
+    pl->ns->send_packet (sl);
 }
 
 /**
@@ -1197,15 +1104,14 @@
 {
   pl->last_weight = weight;
 
-  packet sl;
-  sl << "player ";
+  packet sl ("player");
 
   sl << uint32 (pl->ob->count)
      << uint32 (weight)
      << uint32 (pl->ob->face->number)
      << data8  (pl->ob->name);
 
-  pl->socket->send_packet (sl);
+  pl->ns->send_packet (sl);
   SET_FLAG (pl->ob, FLAG_CLIENT_SENT);
 }
 
@@ -1219,8 +1125,6 @@
 void
 esrv_send_animation (client * ns, short anim_num)
 {
-  int i;
-
   /* Do some checking on the anim_num we got.  Note that the animations
    * are added in contigous order, so if the number is in the valid
    * range, it must be a valid animation.
@@ -1231,19 +1135,19 @@
       return;
     }
 
-  packet sl;
+  packet sl ("anim");
 
-  sl << "anim "
-     << uint16 (anim_num)
+  sl << uint16 (anim_num)
      << uint16 (0); /* flags - not used right now */
 
   /* Build up the list of faces.  Also, send any information (ie, the
    * the face itself) down to the client.
    */
-  for (i = 0; i < animations[anim_num].num_animations; i++)
+  for (int i = 0; i < animations[anim_num].num_animations; i++)
     {
       if (!(ns->faces_sent[animations[anim_num].faces[i]] & NS_FACESENT_FACE))
         esrv_send_face (ns, animations[anim_num].faces[i], 0);
+
       sl << uint16 (animations[anim_num].faces[i]);   /* flags - not used right now */
     }
 
@@ -1268,6 +1172,7 @@
 {
   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 ();
@@ -1280,113 +1185,6 @@
     esrv_send_face (ns, face_num, 0);
 }
 
-struct LayerCell
-{
-  uint16 xy;
-  short face;
-};
-
-struct MapLayer
-{
-  int count;
-  struct LayerCell lcells[MAP_CLIENT_X * MAP_CLIENT_Y];
-};
-
-/** Checkes if map cells have changed */
-static int
-mapcellchanged (client * ns, int i, int j, struct Map *newmap)
-{
-  int k;
-
-  if (ns->lastmap.cells[i][j].count != newmap->cells[i][j].count)
-    return 1;
-  for (k = 0; k < newmap->cells[i][j].count; k++)
-    {
-      if (ns->lastmap.cells[i][j].faces[k] != newmap->cells[i][j].faces[k])
-        {
-          return 1;
-        }
-    }
-  return 0;
-}
-
-/**
- * Basically, what this does is pack the data into layers.
- * cnum is the client number, cur is the the buffer we put all of
- * this data into.  we return the end of the data.  layers is
- * how many layers of data we should back.
- */
-static uint8 *
-compactlayer (client * ns, unsigned char *cur, int numlayers, struct Map *newmap)
-{
-  int x, y, k;
-  int face;
-  unsigned char *fcur;
-  struct MapLayer layers[MAP_LAYERS];
-
-  for (k = 0; k < MAP_LAYERS; k++)
-    layers[k].count = 0;
-  fcur = cur;
-  for (x = 0; x < ns->mapx; x++)
-    {
-      for (y = 0; y < ns->mapy; y++)
-        {
-          if (!mapcellchanged (ns, x, y, newmap))
-            continue;
-          if (newmap->cells[x][y].count == 0)
-            {
-              *cur = x * ns->mapy + y;  /* mark empty space */
-              cur++;
-              continue;
-            }
-          for (k = 0; k < newmap->cells[x][y].count; k++)
-            {
-              layers[k].lcells[layers[k].count].xy = x * ns->mapy + y;
-              layers[k].lcells[layers[k].count].face = newmap->cells[x][y].faces[k];
-              layers[k].count++;
-            }
-        }
-    }
-  /* If no data, return now. */
-  if (fcur == cur && layers[0].count == 0)
-    return cur;
-  *cur = 255;                   /* mark end of explicitly cleared cells */
-  cur++;
-  /* First pack by layers. */
-  for (k = 0; k < numlayers; k++)
-    {
-      if (layers[k].count == 0)
-        break;                  /* once a layer is entirely empty, no layer below it can
-                                   have anything in it either */
-      /* Pack by entries in thie layer */
-      for (x = 0; x < layers[k].count;)
-        {
-          fcur = cur;
-          *cur = layers[k].lcells[x].face >> 8;
-          cur++;
-          *cur = layers[k].lcells[x].face & 0xFF;
-          cur++;
-          face = layers[k].lcells[x].face;
-          /* Now, we back the redundant data into 1 byte xy pairings */
-          for (y = x; y < layers[k].count; y++)
-            {
-              if (layers[k].lcells[y].face == face)
-                {
-                  *cur = (uint8) layers[k].lcells[y].xy;
-                  cur++;
-                  layers[k].lcells[y].face = -1;
-                }
-            }
-          *(cur - 1) = *(cur - 1) | 128;        /* mark for end of xy's; 11*11 < 128 */
-          /* forward over the now redundant data */
-          while (x < layers[k].count && layers[k].lcells[x].face == -1)
-            x++;
-        }
-      *fcur = *fcur | 128;      /* mark for end of faces at this layer */
-    }
-  return cur;
-}
-
 /** Clears a map cell */
 static void
 map_clearcell (struct MapCell *cell, int face0, int face1, int face2, int count)
@@ -1406,10 +1204,9 @@
 /* Using a global really isn't a good approach, but saves the over head of
  * allocating and deallocating such a block of data each time run through,
  * and saves the space of allocating this in the socket object when we only
- * need it for this cycle.  If the serve is ever threaded, this needs to be
+ * need it for this cycle.  If the server is ever threaded, this needs to be
  * re-examined.
  */
-
 static object *heads[MAX_HEAD_POS * MAX_HEAD_POS * MAX_LAYERS];
 
 /**
@@ -1420,10 +1217,10 @@
 static inline int
 have_head (int ax, int ay)
 {
-
   if (heads[(ay * MAX_HEAD_POS + ax) * MAX_LAYERS] ||
       heads[(ay * MAX_HEAD_POS + ax) * MAX_LAYERS + 1] || heads[(ay * MAX_HEAD_POS + ax) * MAX_LAYERS + 2])
     return 1;
+
   return 0;
 }
 
@@ -1431,7 +1228,7 @@
  * check_head is a bit simplistic version of update_space below.
  * basically, it only checks the that the head on space ax,ay at layer
  * needs to get sent - if so, it adds the data, sending the head
- * if needed, and returning 1.  If this no data needs to get
+ * if needed, and returning 1. If this no data needs to get
  * sent, it returns zero.
  */
 static int
@@ -1477,7 +1274,6 @@
  * the case, it seems to make more sense to have these layer values
  * actually match.
  */
-
 static int
 update_space (packet &sl, client &ns, maptile *mp, int mx, int my, int sx, int sy, int layer)
 {
@@ -1712,7 +1508,7 @@
   /* If there is no object for this space, or if the face for the object
    * is the blank face, set the smoothlevel to zero.
    */
-  if (!ob || ob->face == blank_face || MAP_NOSMOOTH (mp))
+  if (!ob || ob->face == blank_face)
     smoothlevel = 0;
   else
     {
@@ -1755,6 +1551,7 @@
       if (ns->EMI_smooth)
         result += 1;            /*One byte for smoothlevel */
     }
+
   return result;
 }
 
@@ -1771,7 +1568,7 @@
  * and use the other 4 bits for other informatiion.   For full documentation
  * of what we send, see the doc/Protocol file.
  * I will describe internally what we do:
- * the socket->lastmap shows how the map last looked when sent to the client.
+ * the ns->lastmap shows how the map last looked when sent to the client.
  * in the lastmap structure, there is a cells array, which is set to the
  * maximum viewable size (As set in config.h).
  * in the cells, there are faces and a count value.
@@ -1792,14 +1589,13 @@
   uint8 extendedinfos;
   maptile *m;
 
-  client &socket = *pl->contr->socket;
+  client &socket = *pl->contr->ns;
 
   check_map_change (pl->contr);
 
-  packet sl;
+  packet sl (socket.mapmode == Map1Cmd ? "map1" : "map1a");
   packet esl;
 
-  sl << (socket.mapmode == Map1Cmd ? "map1 " : "map1a ");
   startlen = sl.length ();
 
   /*Extendedmapinfo structure initialisation */
@@ -1853,7 +1649,6 @@
       ax = 0;
       for (x = pl->x - socket.mapx / 2; x < max_x; x++, ax++)
         {
-
           emask = mask = (ax & 0x3f) << 10 | (ay & 0x3f) << 4;
 
           /* If this space is out of the normal viewable area, we only check
@@ -1925,6 +1720,8 @@
             }
           else if (d > 3)
             {
+              m->touch ();
+
               int need_send = 0, count;
 
               /* This block deals with spaces that are not visible for whatever
@@ -1967,6 +1764,8 @@
             }
           else
             {
+              m->touch ();
+
               /* In this block, the space is visible or there are head objects
                * we need to send.
                */
@@ -2193,26 +1992,25 @@
 
   memset (&newmap, 0, sizeof (struct Map));
 
-  for (j = (pl->y - pl->contr->socket->mapy / 2); j < (pl->y + (pl->contr->socket->mapy + 1) / 2); j++)
-    {
-      for (i = (pl->x - pl->contr->socket->mapx / 2); i < (pl->x + (pl->contr->socket->mapx + 1) / 2); i++)
-        {
-          ax = i;
-          ay = j;
-          m = pm;
-          mflags = get_map_flags (m, &m, ax, ay, &ax, &ay);
-          if (mflags & P_OUT_OF_MAP)
-            continue;
-          if (mflags & P_NEED_UPDATE)
-            update_position (m, ax, ay);
-          /* If a map is visible to the player, we don't want to swap it out
-           * just to reload it.  This should really call something like
-           * swap_map, but this is much more efficient and 'good enough'
-           */
-          if (mflags & P_NEW_MAP)
-            m->timeout = 50;
-        }
-    }
+  for (j = (pl->y - pl->contr->ns->mapy / 2); j < (pl->y + (pl->contr->ns->mapy + 1) / 2); j++)
+    for (i = (pl->x - pl->contr->ns->mapx / 2); i < (pl->x + (pl->contr->ns->mapx + 1) / 2); i++)
+      {
+        ax = i;
+        ay = j;
+        m = pm;
+        mflags = get_map_flags (m, &m, ax, ay, &ax, &ay);
+
+        if (mflags & P_OUT_OF_MAP)
+          continue;
+
+        /* If a map is visible to the player, we don't want to swap it out
+         * just to reload it.  This should really call something like
+         * swap_map, but this is much more efficient and 'good enough'
+         */
+        if (mflags & P_NEW_MAP)
+          m->timeout = 50;
+      }
+
   /* do LOS after calls to update_position */
   if (pl->contr->do_los)
     {
@@ -2237,7 +2035,7 @@
 void
 send_plugin_custom_message (object *pl, char *buf)
 {
-  pl->contr->socket->send_packet (buf);
+  pl->contr->ns->send_packet (buf);
 }
 
 /**
@@ -2292,7 +2090,10 @@
 void
 esrv_update_spells (player *pl)
 {
-  if (!pl->socket->monitor_spells)
+  if (!pl->ns)
+    return;
+
+  if (!pl->ns->monitor_spells)
     return;
 
   for (object *spell = pl->ob->inv; spell; spell = spell->below)
@@ -2332,7 +2133,7 @@
               if (flags & UPD_SP_GRACE ) sl << uint16 (spell->last_grace);
               if (flags & UPD_SP_DAMAGE) sl << uint16 (spell->last_eat);
 
-              pl->socket->send_packet (sl);
+              pl->ns->send_packet (sl);
             }
         }
     }
@@ -2341,7 +2142,7 @@
 void
 esrv_remove_spell (player *pl, object *spell)
 {
-  if (!pl->socket->monitor_spells)
+  if (!pl->ns->monitor_spells)
     return;
 
   if (!pl || !spell || spell->env != pl->ob)
@@ -2350,12 +2151,11 @@
       return;
     }
 
-  packet sl;
+  packet sl ("delspell");
 
-  sl << "delspell "
-     << uint32 (spell->count);
+  sl << uint32 (spell->count);
 
-  pl->socket->send_packet (sl);
+  pl->ns->send_packet (sl);
 }
 
 /* appends the spell *spell to the Socklist we will send the data to. */
@@ -2413,12 +2213,10 @@
       return;
     }
 
-  if (!pl->socket->monitor_spells)
+  if (!pl->ns->monitor_spells)
     return;
 
-  packet sl;
-
-  sl << "addspell ";
+  packet sl ("addspell");
 
   if (!spell)
     {
@@ -2442,7 +2240,7 @@
 
           if (sl.length () >= (MAXSOCKBUF - (26 + strlen (spell->name) + (spell->msg ? strlen (spell->msg) : 0))))
             {
-              pl->socket->send_packet (sl);
+              pl->ns->send_packet (sl);
 
               sl.reset ();
               sl << "addspell ";
@@ -2466,6 +2264,6 @@
     }
 
   /* finally, we can send the packet */
-  pl->socket->send_packet (sl);
+  pl->ns->send_packet (sl);
 }