ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/socket/request.C
(Generate patch)

Comparing deliantra/server/socket/request.C (file contents):
Revision 1.132 by elmex, Sun Jun 15 19:34:31 2008 UTC vs.
Revision 1.146 by root, Sat Dec 27 01:25:00 2008 UTC

… …
98 */ 98 */
99 mx = ns->mapx; 99 mx = ns->mapx;
100 my = ns->mapy; 100 my = ns->mapy;
101 101
102 /* the x and y here are coordinates for the new map, i.e. if we moved 102 /* the x and y here are coordinates for the new map, i.e. if we moved
103 * (dx,dy), newmap[x][y] = oldmap[x-dx][y-dy]. For this reason, 103 * (dx,dy), newmap[x][y] = oldmap[x-dx][y-dy]. For this reason,
104 * if the destination x or y coordinate is outside the viewable 104 * if the destination x or y coordinate is outside the viewable
105 * area, we clear the values - otherwise, the old values 105 * area, we clear the values - otherwise, the old values
106 * are preserved, and the check_head thinks it needs to clear them. 106 * are preserved, and the check_head thinks it needs to clear them.
107 */ 107 */
108 for (x = 0; x < mx; x++) 108 for (x = 0; x < mx; x++)
109 {
110 for (y = 0; y < my; y++) 109 for (y = 0; y < my; y++)
111 {
112 if (x >= ns->mapx || y >= ns->mapy) 110 if (x >= ns->mapx || y >= ns->mapy)
113 /* clear cells outside the viewable area */ 111 /* clear cells outside the viewable area */
114 memset (&newmap.cells[x][y], 0, sizeof (struct MapCell)); 112 memset (&newmap.cells[x][y], 0, sizeof (struct MapCell));
115 else if ((x + dx) < 0 || (x + dx) >= ns->mapx || (y + dy) < 0 || (y + dy) >= ns->mapy) 113 else if ((x + dx) < 0 || (x + dx) >= ns->mapx || (y + dy) < 0 || (y + dy) >= ns->mapy)
116 /* clear newly visible tiles within the viewable area */ 114 /* clear newly visible tiles within the viewable area */
117 memset (&(newmap.cells[x][y]), 0, sizeof (struct MapCell)); 115 memset (&(newmap.cells[x][y]), 0, sizeof (struct MapCell));
118 else 116 else
119 memcpy (&(newmap.cells[x][y]), &(ns->lastmap.cells[x + dx][y + dy]), sizeof (struct MapCell)); 117 memcpy (&(newmap.cells[x][y]), &(ns->lastmap.cells[x + dx][y + dy]), sizeof (struct MapCell));
120 }
121 }
122 118
123 memcpy (&(ns->lastmap), &newmap, sizeof (struct Map)); 119 memcpy (&(ns->lastmap), &newmap, sizeof (struct Map));
124 120
125 /* Make sure that the next "map1" command will be sent (even if it is 121 /* Make sure that the next "map1" command will be sent (even if it is
126 * empty). 122 * empty).
… …
212 else if (socket.current_x != ob->x || socket.current_y != ob->y) 208 else if (socket.current_x != ob->x || socket.current_y != ob->y)
213 { 209 {
214 int dx = ob->x - socket.current_x; 210 int dx = ob->x - socket.current_x;
215 int dy = ob->y - socket.current_y; 211 int dy = ob->y - socket.current_y;
216 212
217 if (socket.buggy_mapscroll && (abs (dx) > 8 || abs (dy) > 8))
218 clear_map (pl); // current (<= 1.9.1) clients have unchecked buffer overflows
219 else
220 {
221 socket_map_scroll (&socket, ob->x - socket.current_x, ob->y - socket.current_y); 213 socket_map_scroll (&socket, ob->x - socket.current_x, ob->y - socket.current_y);
222 socket.floorbox_reset (); 214 socket.floorbox_reset ();
223 }
224 } 215 }
225 216
226 socket.current_x = ob->x; 217 socket.current_x = ob->x;
227 socket.current_y = ob->y; 218 socket.current_y = ob->y;
228} 219}
… …
406 */ 397 */
407void 398void
408AddMeCmd (char *buf, int len, client *ns) 399AddMeCmd (char *buf, int len, client *ns)
409{ 400{
410 INVOKE_CLIENT (ADDME, ns, ARG_DATA (buf, len)); 401 INVOKE_CLIENT (ADDME, ns, ARG_DATA (buf, len));
411}
412
413/** Reply to ExtendedInfos command */
414void
415ToggleExtendedInfos (char *buf, int len, client * ns)
416{
417 char cmdback[MAX_BUF];
418 char command[50];
419 int info, nextinfo;
420
421 cmdback[0] = '\0';
422 nextinfo = 0;
423
424 while (1)
425 {
426 /* 1. Extract an info */
427 info = nextinfo;
428
429 while ((info < len) && (buf[info] == ' '))
430 info++;
431
432 if (info >= len)
433 break;
434
435 nextinfo = info + 1;
436
437 while ((nextinfo < len) && (buf[nextinfo] != ' '))
438 nextinfo++;
439
440 if (nextinfo - info >= 49) /*Erroneous info asked */
441 continue;
442
443 strncpy (command, &(buf[info]), nextinfo - info);
444
445 /* 2. Interpret info */
446 if (!strcmp ("smooth", command))
447 /* Toggle smoothing */
448 ns->EMI_smooth = !ns->EMI_smooth;
449 else
450 /*bad value */;
451
452 /*3. Next info */
453 }
454
455 strcpy (cmdback, "ExtendedInfoSet");
456
457 if (ns->EMI_smooth)
458 {
459 strcat (cmdback, " ");
460 strcat (cmdback, "smoothing");
461 }
462
463 ns->send_packet (cmdback);
464} 402}
465 403
466/* 404/*
467#define MSG_TYPE_BOOK 1 405#define MSG_TYPE_BOOK 1
468#define MSG_TYPE_CARD 2 406#define MSG_TYPE_CARD 2
… …
833 AddIfShort (ns->last_stats.Wis, ob->stats.Wis, CS_STAT_WIS); 771 AddIfShort (ns->last_stats.Wis, ob->stats.Wis, CS_STAT_WIS);
834 AddIfShort (ns->last_stats.Pow, ob->stats.Pow, CS_STAT_POW); 772 AddIfShort (ns->last_stats.Pow, ob->stats.Pow, CS_STAT_POW);
835 AddIfShort (ns->last_stats.Cha, ob->stats.Cha, CS_STAT_CHA); 773 AddIfShort (ns->last_stats.Cha, ob->stats.Cha, CS_STAT_CHA);
836 774
837 for (int s = 0; s < NUM_SKILLS; s++) 775 for (int s = 0; s < NUM_SKILLS; s++)
838 if (object *skill = opl->last_skill_ob[s]) 776 if (object *skill = opl->last_skill_ob [s])
839 if (skill->stats.exp != ns->last_skill_exp [s]) 777 if (skill->stats.exp != ns->last_skill_exp [s])
840 { 778 {
841 ns->last_skill_exp [s] = skill->stats.exp; 779 ns->last_skill_exp [s] = skill->stats.exp;
842 780
843 /* Always send along the level if exp changes. This is only 781 /* Always send along the level if exp changes. This is only
… …
912 << uint32 (pl->ob->face) 850 << uint32 (pl->ob->face)
913 << data8 (pl->ob->name); 851 << data8 (pl->ob->name);
914 852
915 pl->ns->last_weight = weight; 853 pl->ns->last_weight = weight;
916 pl->ns->send_packet (sl); 854 pl->ns->send_packet (sl);
917 SET_FLAG (pl->ob, FLAG_CLIENT_SENT);
918} 855}
919 856
920/****************************************************************************** 857/******************************************************************************
921 * 858 *
922 * Start of map related commands. 859 * Start of map related commands.
… …
989 926
990 /* Nothing changed */ 927 /* Nothing changed */
991 return 0; 928 return 0;
992} 929}
993 930
994/**
995 * Returns the size of a data for a map square as returned by
996 * mapextended. There are CLIENTMAPX*CLIENTMAPY*LAYERS entries
997 * available.
998 */
999int
1000getExtendedMapInfoSize (client * ns)
1001{
1002 int result = 0;
1003
1004 if (ns->ext_mapinfos)
1005 {
1006 if (ns->EMI_smooth)
1007 result += 1; /*One byte for smoothlevel */
1008 }
1009
1010 return result;
1011}
1012
1013// prefetch (and touch) all maps within a specific distancd 931// prefetch (and touch) all maps within a specific distancd
1014static void 932static void
1015prefetch_surrounding_maps (maptile *map, int distance) 933prefetch_surrounding_maps (maptile *map, int distance)
1016{ 934{
1017 map->last_access = runtime; 935 map->last_access = runtime;
… …
1040{ 958{
1041 object *ob = pl->observe; 959 object *ob = pl->observe;
1042 if (!ob->active) 960 if (!ob->active)
1043 return; 961 return;
1044 962
1045 maptile *plmap = ob->map;
1046
1047 /* If player is just joining the game, he isn't here yet, so the map 963 /* If player is just joining the game, he isn't here yet, so the map
1048 * can get swapped out. If so, don't try to send them a map. All will 964 * can get swapped out. If so, don't try to send them a map. All will
1049 * be OK once they really log in. 965 * be OK once they really log in.
1050 */ 966 */
1051 if (!plmap || plmap->in_memory != MAP_ACTIVE) 967 if (!ob->map || ob->map->in_memory != MAP_ACTIVE)
1052 return; 968 return;
1053 969
1054 int x, y, ax, ay, startlen, max_x, max_y, oldlen;
1055 int estartlen, eoldlen; 970 int startlen, oldlen;
1056 uint8 eentrysize;
1057 uint16 ewhatstart, ewhatflag;
1058 uint8 extendedinfos;
1059 971
1060 check_map_change (pl); 972 check_map_change (pl);
1061 prefetch_surrounding_maps (pl->ob); 973 prefetch_surrounding_maps (pl->ob);
1062 974
1063 /* do LOS after calls to update_position */ 975 /* do LOS after calls to update_position */
1064 if (ob != pl->ob) 976 /* unfortunately, we need to udpate los when observing, currently */
1065 clear_los (pl); 977 if (pl->do_los || pl->observe != pl->ob)
1066 else if (pl->do_los)
1067 { 978 {
1068 update_los (ob);
1069 pl->do_los = 0; 979 pl->do_los = 0;
980 pl->update_los ();
1070 } 981 }
1071 982
1072 /** 983 /**
1073 * This function uses the new map1 protocol command to send the map 984 * This function uses the new map1 protocol command to send the map
1074 * to the client. It is necessary because the old map command supports 985 * to the client. It is necessary because the old map command supports
… …
1093 */ 1004 */
1094 1005
1095 client &socket = *pl->ns; 1006 client &socket = *pl->ns;
1096 1007
1097 packet sl (socket.mapmode == Map1Cmd ? "map1" : "map1a"); 1008 packet sl (socket.mapmode == Map1Cmd ? "map1" : "map1a");
1098 packet esl;
1099 1009
1100 startlen = sl.length (); 1010 startlen = sl.length ();
1101 1011
1102 /*Extendedmapinfo structure initialisation */ 1012 int hx = socket.mapx / 2;
1103 if (socket.ext_mapinfos) 1013 int hy = socket.mapy / 2;
1104 {
1105 extendedinfos = EMI_NOREDRAW;
1106 1014
1107 if (socket.EMI_smooth) 1015 ordered_mapwalk_begin (ob, -hx, -hy, hx, hy)
1108 extendedinfos |= EMI_SMOOTH; 1016 int ax = dx + hx;
1017 int ay = dy + hy;
1109 1018
1110 ewhatstart = esl.length (); 1019 int mask = (ax << 10) | (ay << 4);
1111 ewhatflag = extendedinfos; /*The EMI_NOREDRAW bit
1112 could need to be taken away */
1113 eentrysize = getExtendedMapInfoSize (&socket);
1114 esl << "mapextended "
1115 << uint8 (extendedinfos)
1116 << uint8 (eentrysize);
1117
1118 estartlen = esl.length ();
1119 }
1120
1121 /* x,y are the real map locations. ax, ay are viewport relative
1122 * locations.
1123 */
1124 ay = 0;
1125
1126 /* We could do this logic as conditionals in the if statement,
1127 * but that started to get a bit messy to look at.
1128 */
1129 max_x = ob->x + (socket.mapx + 1) / 2;
1130 max_y = ob->y + (socket.mapy + 1) / 2;
1131
1132 for (y = ob->y - socket.mapy / 2; y < max_y; y++, ay++)
1133 {
1134 sint16 nx, ny;
1135 maptile *m = 0;
1136
1137 ax = 0;
1138 for (x = ob->x - socket.mapx / 2; x < max_x; x++, ax++)
1139 {
1140 // check to see if we can simply go one right quickly
1141 ++nx;
1142 if (m && nx >= m->width)
1143 m = 0;
1144
1145 if (!m)
1146 {
1147 nx = x; ny = y; m = plmap;
1148
1149 if (xy_normalise (m, nx, ny))
1150 m->touch ();
1151 else
1152 m = 0;
1153 }
1154
1155 int emask, mask;
1156 emask = mask = (ax & 0x3f) << 10 | (ay & 0x3f) << 4;
1157
1158 MapCell &lastcell = socket.lastmap.cells[ax][ay]; 1020 MapCell &lastcell = socket.lastmap.cells[ax][ay];
1159 1021
1160 /* If the coordinates are not valid, or it is too dark to see, 1022 /* If the coordinates are not valid, or it is too dark to see,
1161 * we tell the client as such 1023 * we tell the client as such
1162 */ 1024 */
1163 if (!m) 1025 if (!m)
1164 { 1026 {
1165 /* space is out of map. Update space and clear values 1027 /* space is out of map. Update space and clear values
1166 * if this hasn't already been done. If the space is out 1028 * if this hasn't already been done. If the space is out
1167 * of the map, it shouldn't have a head 1029 * of the map, it shouldn't have a head.
1168 */ 1030 */
1169 if (lastcell.count != -1) 1031 if (lastcell.count != -1)
1032 {
1033 sl << uint16 (mask);
1034 map_clearcell (&lastcell, -1);
1035 }
1036
1037 continue;
1038 }
1039
1040 int d = pl->blocked_los_uc (dx, dy);
1041
1042 if (d > 3)
1043 {
1044 /* This block deals with spaces that are not visible for whatever
1045 * reason. Still may need to send the head for this space.
1046 */
1047 if (lastcell.count != -1
1048 || lastcell.faces[0]
1049 || lastcell.faces[1]
1050 || lastcell.faces[2]
1051 || lastcell.stat_hp
1052 || lastcell.flags
1053 || lastcell.player)
1054 sl << uint16 (mask);
1055
1056 /* properly clear a previously sent big face */
1057 map_clearcell (&lastcell, -1);
1058 }
1059 else
1060 {
1061 /* In this block, the space is visible.
1062 */
1063
1064 /* Rather than try to figure out what everything that we might
1065 * need to send is, then form the packet after that,
1066 * we presume that we will in fact form a packet, and update
1067 * the bits by what we do actually send. If we send nothing,
1068 * we just back out sl.length () to the old value, and no harm
1069 * is done.
1070 * I think this is simpler than doing a bunch of checks to see
1071 * what if anything we need to send, setting the bits, then
1072 * doing those checks again to add the real data.
1073 */
1074 oldlen = sl.length ();
1075
1076 sl << uint16 (mask);
1077
1078 unsigned char dummy;
1079 unsigned char *last_ext = &dummy;
1080
1081 /* Darkness changed */
1082 if (lastcell.count != d)
1083 {
1084 mask |= 0x8;
1085
1086 if (socket.extmap)
1087 {
1088 *last_ext |= 0x80;
1089 last_ext = &sl[sl.length ()];
1090 sl << uint8 (d);
1091 }
1092 else
1093 sl << uint8 (255 - 64 * d);
1094 }
1095
1096 lastcell.count = d;
1097
1098 mapspace &ms = m->at (nx, ny);
1099 ms.update ();
1100
1101 if (expect_true (socket.extmap))
1102 {
1103 uint8 stat_hp = 0;
1104 uint8 stat_width = 0;
1105 uint8 flags = 0;
1106 tag_t player = 0;
1107
1108 // send hp information, if applicable
1109 if (object *op = ms.faces_obj [0])
1110 if (op->is_head () && !op->invisible)
1170 { 1111 {
1171 sl << uint16 (mask); 1112 if (op->stats.maxhp > op->stats.hp
1172 map_clearcell (&lastcell, -1); 1113 && op->stats.maxhp > 0
1114 && (op->type == PLAYER
1115 || op->type == DOOR // does not work, have maxhp 0
1116 || QUERY_FLAG (op, FLAG_MONSTER)
1117 || QUERY_FLAG (op, FLAG_ALIVE)
1118 || QUERY_FLAG (op, FLAG_GENERATOR)))
1119 {
1120 stat_hp = 255 - (op->stats.hp * 255 + 254) / op->stats.maxhp;
1121 stat_width = op->arch->max_x - op->arch->x; //TODO: should be upper-left edge
1122 }
1123
1124 if (expect_false (op->has_dialogue ()))
1125 flags |= 1;
1126
1127 if (expect_false (op->type == PLAYER))
1128 player = op == ob ? pl->ob->count
1129 : op == pl->ob ? ob->count
1130 : op->count;
1173 } 1131 }
1174 1132
1175 continue; 1133 if (expect_false (lastcell.stat_hp != stat_hp))
1176 }
1177
1178 int d = pl->blocked_los[ax][ay];
1179
1180 if (d > 3)
1181 {
1182
1183 int need_send = 0, count;
1184
1185 /* This block deals with spaces that are not visible for whatever
1186 * reason. Still may need to send the head for this space.
1187 */
1188
1189 oldlen = sl.length ();
1190
1191 sl << uint16 (mask);
1192
1193 if (lastcell.count != -1)
1194 need_send = 1;
1195
1196 count = -1;
1197
1198 /* properly clear a previously sent big face */
1199 if (lastcell.faces[0] || lastcell.faces[1] || lastcell.faces[2]
1200 || lastcell.stat_hp || lastcell.flags || lastcell.player)
1201 need_send = 1;
1202
1203 map_clearcell (&lastcell, count);
1204
1205 if ((mask & 0xf) || need_send)
1206 sl[oldlen + 1] = mask & 0xff;
1207 else
1208 sl.reset (oldlen);
1209 }
1210 else
1211 {
1212 /* In this block, the space is visible.
1213 */
1214
1215 /* Rather than try to figure out what everything that we might
1216 * need to send is, then form the packet after that,
1217 * we presume that we will in fact form a packet, and update
1218 * the bits by what we do actually send. If we send nothing,
1219 * we just back out sl.length () to the old value, and no harm
1220 * is done.
1221 * I think this is simpler than doing a bunch of checks to see
1222 * what if anything we need to send, setting the bits, then
1223 * doing those checks again to add the real data.
1224 */
1225 oldlen = sl.length ();
1226 eoldlen = esl.length ();
1227
1228 sl << uint16 (mask);
1229
1230 unsigned char dummy;
1231 unsigned char *last_ext = &dummy;
1232
1233 /* Darkness changed */
1234 if (lastcell.count != d && socket.darkness)
1235 { 1134 {
1135 lastcell.stat_hp = stat_hp;
1136
1236 mask |= 0x8; 1137 mask |= 0x8;
1138 *last_ext |= 0x80;
1139 last_ext = &sl[sl.length ()];
1237 1140
1238 if (socket.extmap) 1141 sl << uint8 (5) << uint8 (stat_hp);
1142
1143 if (stat_width > 1)
1239 { 1144 {
1240 *last_ext |= 0x80; 1145 *last_ext |= 0x80;
1241 last_ext = &sl[sl.length ()]; 1146 last_ext = &sl[sl.length ()];
1242 sl << uint8 (d);
1243 }
1244 else
1245 sl << uint8 (255 - 64 * d);
1246 }
1247 1147
1248 lastcell.count = d;
1249
1250 mapspace &ms = m->at (nx, ny);
1251 ms.update ();
1252
1253 if (socket.extmap)
1254 {
1255 uint8 stat_hp = 0;
1256 uint8 stat_width = 0;
1257 uint8 flags = 0;
1258 tag_t player = 0;
1259
1260 // send hp information, if applicable
1261 if (object *op = ms.faces_obj [0])
1262 if (op->is_head () && !op->invisible)
1263 {
1264 if (op->stats.maxhp > op->stats.hp
1265 && op->stats.maxhp > 0
1266 && (op->type == PLAYER
1267 || op->type == DOOR // does not work, have maxhp 0
1268 || QUERY_FLAG (op, FLAG_MONSTER) || QUERY_FLAG (op, FLAG_ALIVE) || QUERY_FLAG (op, FLAG_GENERATOR)))
1269 {
1270 stat_hp = 255 - (op->stats.hp * 255 + 254) / op->stats.maxhp;
1271 stat_width = op->arch->max_x - op->arch->x; //TODO: should be upper-left edge
1272 }
1273
1274 if (op->msg && op->msg[0] == '@')
1275 flags |= 1;
1276
1277 if (op->type == PLAYER && op != ob)
1278 player = op->count;
1279 }
1280
1281 if (lastcell.stat_hp != stat_hp)
1282 {
1283 lastcell.stat_hp = stat_hp;
1284
1285 mask |= 0x8;
1286 *last_ext |= 0x80;
1287 last_ext = &sl[sl.length ()];
1288
1289 sl << uint8 (5) << uint8 (stat_hp);
1290
1291 if (stat_width > 1)
1292 {
1293 *last_ext |= 0x80;
1294 last_ext = &sl[sl.length ()];
1295
1296 sl << uint8 (6) << uint8 (stat_width); 1148 sl << uint8 (6) << uint8 (stat_width);
1297 }
1298 } 1149 }
1299
1300 if (lastcell.player != player)
1301 {
1302 lastcell.player = player;
1303
1304 mask |= 0x8;
1305 *last_ext |= 0x80;
1306 last_ext = &sl[sl.length ()];
1307
1308 sl << uint8 (0x47) << uint8 (4) << (uint32)player;
1309 }
1310
1311 if (lastcell.flags != flags)
1312 {
1313 lastcell.flags = flags;
1314
1315 mask |= 0x8;
1316 *last_ext |= 0x80;
1317 last_ext = &sl[sl.length ()];
1318
1319 sl << uint8 (8) << uint8 (flags);
1320 }
1321 } 1150 }
1322 1151
1323 /* Floor face */ 1152 if (expect_false (lastcell.player != player))
1324 if (update_space (sl, socket, ms, lastcell, 2)) 1153 {
1154 lastcell.player = player;
1155
1325 mask |= 0x4; 1156 mask |= 0x8;
1157 *last_ext |= 0x80;
1158 last_ext = &sl[sl.length ()];
1326 1159
1327 /* Middle face */ 1160 sl << uint8 (0x47) << uint8 (4) << (uint32)player;
1328 if (update_space (sl, socket, ms, lastcell, 1)) 1161 }
1162
1163 if (expect_false (lastcell.flags != flags))
1164 {
1165 lastcell.flags = flags;
1166
1329 mask |= 0x2; 1167 mask |= 0x8;
1168 *last_ext |= 0x80;
1169 last_ext = &sl[sl.length ()];
1330 1170
1331 if (ms.player () == ob 1171 sl << uint8 (8) << uint8 (flags);
1332 && (ob->invisible & (ob->invisible < 50 ? 1 : 7)))
1333 { 1172 }
1173 }
1174
1175 /* Floor face */
1176 if (update_space (sl, socket, ms, lastcell, 2))
1177 mask |= 0x4;
1178
1179 /* Middle face */
1180 if (update_space (sl, socket, ms, lastcell, 1))
1181 mask |= 0x2;
1182
1183 if (expect_false (ob->invisible)
1184 && ob->invisible & (ob->invisible < 50 ? 1 : 7)
1185 && ms.player () == ob)
1186 {
1334 // force player to be visible to himself if invisible 1187 // force player to be visible to himself if invisible
1335 if (lastcell.faces[0] != ob->face) 1188 if (lastcell.faces[0] != ob->face)
1336 { 1189 {
1337 lastcell.faces[0] = ob->face; 1190 lastcell.faces[0] = ob->face;
1338 1191
1339 mask |= 0x1;
1340 sl << uint16 (ob->face);
1341
1342 socket.send_faces (ob);
1343 }
1344 }
1345 /* Top face */
1346 else if (update_space (sl, socket, ms, lastcell, 0))
1347 mask |= 0x1; 1192 mask |= 0x1;
1193 sl << uint16 (ob->face);
1348 1194
1195 socket.send_faces (ob);
1196 }
1197 }
1198 /* Top face */
1199 else if (update_space (sl, socket, ms, lastcell, 0))
1200 mask |= 0x1;
1201
1349 /* Check to see if we are in fact sending anything for this 1202 /* Check to see if we are in fact sending anything for this
1350 * space by checking the mask. If so, update the mask. 1203 * space by checking the mask. If so, update the mask.
1351 * if not, reset the len to that from before adding the mask 1204 * if not, reset the len to that from before adding the mask
1352 * value, so we don't send those bits. 1205 * value, so we don't send those bits.
1353 */ 1206 */
1354 if (mask & 0xf) 1207 if (mask & 0xf)
1355 sl[oldlen + 1] = mask & 0xff; 1208 sl[oldlen + 1] = mask & 0xff;
1356 else 1209 else
1357 sl.reset (oldlen); 1210 sl.reset (oldlen);
1358
1359 if (socket.ext_mapinfos)
1360 esl << uint16 (emask);
1361
1362 if (socket.EMI_smooth)
1363 {
1364 for (int layer = 2+1; layer--; )
1365 {
1366 object *ob = ms.faces_obj [layer];
1367
1368 // If there is no object for this space, or if the face for the object
1369 // is the blank face, set the smoothlevel to zero.
1370 int smoothlevel = ob && ob->face != blank_face ? ob->smoothlevel : 0;
1371
1372 // We've gotten what face we want to use for the object. Now see if
1373 // if it has changed since we last sent it to the client.
1374 if (lastcell.smooth[layer] != smoothlevel)
1375 {
1376 lastcell.smooth[layer] = smoothlevel;
1377 esl << uint8 (smoothlevel);
1378 emask |= 1 << layer;
1379 }
1380 }
1381
1382 if (emask & 0xf)
1383 esl[eoldlen + 1] = emask & 0xff;
1384 else
1385 esl.reset (eoldlen);
1386 }
1387 } /* else this is a viewable space */ 1211 } /* else this is a viewable space */
1388 } /* for x loop */ 1212 ordered_mapwalk_end
1389 } /* for y loop */
1390 1213
1391 socket.flush_fx (); 1214 socket.flush_fx ();
1392
1393 /* Verify that we in fact do need to send this */
1394 if (socket.ext_mapinfos)
1395 {
1396 if (!(sl.length () > startlen || socket.sent_scroll))
1397 {
1398 /* No map data will follow, so don't say the client
1399 * it doesn't need draw!
1400 */
1401 ewhatflag &= ~EMI_NOREDRAW;
1402 esl[ewhatstart + 1] = ewhatflag & 0xff;
1403 }
1404
1405 if (esl.length () > estartlen)
1406 socket.send_packet (esl);
1407 }
1408 1215
1409 if (sl.length () > startlen || socket.sent_scroll) 1216 if (sl.length () > startlen || socket.sent_scroll)
1410 { 1217 {
1411 socket.send_packet (sl); 1218 socket.send_packet (sl);
1412 socket.sent_scroll = 0; 1219 socket.sent_scroll = 0;
… …
1433{ 1240{
1434 packet sl; 1241 packet sl;
1435 sl << "replyinfo skill_info\n"; 1242 sl << "replyinfo skill_info\n";
1436 1243
1437 for (int i = 1; i < NUM_SKILLS; i++) 1244 for (int i = 1; i < NUM_SKILLS; i++)
1438 sl.printf ("%d:%s\n", i + CS_STAT_SKILLINFO, &skill_names[i]); 1245 sl.printf ("%d:%s\n", i + CS_STAT_SKILLINFO, &skill_names [i]);
1439 1246
1440 if (sl.length () > MAXSOCKBUF) 1247 if (sl.length () > MAXSOCKBUF)
1441 { 1248 {
1442 LOG (llevError, "Buffer overflow in send_skill_info!\n"); 1249 LOG (llevError, "Buffer overflow in send_skill_info!\n");
1443 fatal (0); 1250 fatal (0);
… …
1561 spell->cached_grace = SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE); 1368 spell->cached_grace = SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE);
1562 spell->cached_eat = spell->stats.dam + SP_level_dam_adjust (pl->ob, spell); 1369 spell->cached_eat = spell->stats.dam + SP_level_dam_adjust (pl->ob, spell);
1563 1370
1564 /* figure out which skill it uses, if it uses one */ 1371 /* figure out which skill it uses, if it uses one */
1565 if (spell->skill) 1372 if (spell->skill)
1566 { 1373 if (object *tmp = pl->find_skill (spell->skill))
1567 for (i = 1; i < NUM_SKILLS; i++)
1568 if (!strcmp (spell->skill, skill_names[i]))
1569 {
1570 skill = i + CS_STAT_SKILLINFO; 1374 skill = tmp->subtype + CS_STAT_SKILLINFO;
1571 break;
1572 }
1573 }
1574 1375
1575 // spells better have a face 1376 // spells better have a face
1576 if (!spell->face) 1377 if (!spell->face)
1577 { 1378 {
1578 LOG (llevError, "%s: spell has no face, but face is mandatory.\n", &spell->name); 1379 LOG (llevError, "%s: spell has no face, but face is mandatory.\n", &spell->name);

Diff Legend

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