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.16 by root, Sun Sep 10 13:43:33 2006 UTC vs.
Revision 1.27 by root, Wed Dec 13 18:08:02 2006 UTC

1
2/*
3 * static char *rcsid_init_c =
4 * "$Id: request.C,v 1.16 2006/09/10 13:43:33 root Exp $";
5 */
6
7/* 1/*
8 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
9 3
10 Copyright (C) 2001 Mark Wedel 4 Copyright (C) 2001 Mark Wedel
11 Copyright (C) 1992 Frank Tore Johansen 5 Copyright (C) 1992 Frank Tore Johansen
… …
22 16
23 You should have received a copy of the GNU General Public License 17 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software 18 along with this program; if not, write to the Free Software
25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 20
27 The author can be reached via e-mail to crossfire-devel@real-time.com 21 The author can be reached via e-mail to <crossfire@schmorp.de>
28*/ 22*/
29 23
30/** 24/**
31 * \file 25 * \file
32 * Client handling. 26 * Client handling.
… …
50 * operations 44 * operations
51 * 45 *
52 * esrv_map_doneredraw finishes the map update, and ships across the 46 * esrv_map_doneredraw finishes the map update, and ships across the
53 * map updates. 47 * map updates.
54 * 48 *
55 * esrv_map_scroll tells the client to scroll the map, and does similarily
56 * for the locally cached copy.
57 */ 49 */
58 50
59#include <global.h> 51#include <global.h>
60#include <sproto.h> 52#include <sproto.h>
61 53
… …
65#include <commands.h> 57#include <commands.h>
66 58
67/* This block is basically taken from socket.c - I assume if it works there, 59/* This block is basically taken from socket.c - I assume if it works there,
68 * it should work here. 60 * it should work here.
69 */ 61 */
70#ifndef WIN32 /* ---win32 exclude unix headers */
71# include <sys/types.h> 62#include <sys/types.h>
72# include <sys/time.h> 63#include <sys/time.h>
73# include <sys/socket.h> 64#include <sys/socket.h>
74# include <netinet/in.h> 65#include <netinet/in.h>
75# include <netdb.h> 66#include <netdb.h>
76#endif /* win32 */
77 67
78#ifdef HAVE_UNISTD_H 68#ifdef HAVE_UNISTD_H
79# include <unistd.h> 69# include <unistd.h>
80#endif 70#endif
81 71
… …
145 for (x = 0; x < mx; x++) 135 for (x = 0; x < mx; x++)
146 { 136 {
147 for (y = 0; y < my; y++) 137 for (y = 0; y < my; y++)
148 { 138 {
149 if (x >= ns->mapx || y >= ns->mapy) 139 if (x >= ns->mapx || y >= ns->mapy)
150 {
151 /* clear cells outside the viewable area */ 140 /* clear cells outside the viewable area */
152 memset (&newmap.cells[x][y], 0, sizeof (struct MapCell)); 141 memset (&newmap.cells[x][y], 0, sizeof (struct MapCell));
153 }
154 else if ((x + dx) < 0 || (x + dx) >= ns->mapx || (y + dy) < 0 || (y + dy) >= ns->mapy) 142 else if ((x + dx) < 0 || (x + dx) >= ns->mapx || (y + dy) < 0 || (y + dy) >= ns->mapy)
155 {
156 /* clear newly visible tiles within the viewable area */ 143 /* clear newly visible tiles within the viewable area */
157 memset (&(newmap.cells[x][y]), 0, sizeof (struct MapCell)); 144 memset (&(newmap.cells[x][y]), 0, sizeof (struct MapCell));
158 }
159 else 145 else
160 {
161 memcpy (&(newmap.cells[x][y]), &(ns->lastmap.cells[x + dx][y + dy]), sizeof (struct MapCell)); 146 memcpy (&(newmap.cells[x][y]), &(ns->lastmap.cells[x + dx][y + dy]), sizeof (struct MapCell));
162 }
163 } 147 }
164 } 148 }
165 149
166 memcpy (&(ns->lastmap), &newmap, sizeof (struct Map)); 150 memcpy (&(ns->lastmap), &newmap, sizeof (struct Map));
167 151
… …
266 if (!strncmp (buf, "spatial ", 8)) 250 if (!strncmp (buf, "spatial ", 8))
267 { 251 {
268 buf += 8; 252 buf += 8;
269 253
270 // initial map and its origin 254 // initial map and its origin
271 mapstruct *map = pl->ob->map; 255 maptile *map = pl->ob->map;
272 sint16 dx, dy; 256 sint16 dx, dy;
273 int mapx = pl->socket.mapx / 2 - pl->ob->x; 257 int mapx = pl->socket.mapx / 2 - pl->ob->x;
274 int mapy = pl->socket.mapy / 2 - pl->ob->y; 258 int mapy = pl->socket.mapy / 2 - pl->ob->y;
275 int max_distance = 8; // limit maximum path length to something generous 259 int max_distance = 8; // limit maximum path length to something generous
276 260
… …
581 char command[50]; 565 char command[50];
582 int info, nextinfo; 566 int info, nextinfo;
583 567
584 cmdback[0] = '\0'; 568 cmdback[0] = '\0';
585 nextinfo = 0; 569 nextinfo = 0;
570
586 while (1) 571 while (1)
587 { 572 {
588 /* 1. Extract an info */ 573 /* 1. Extract an info */
589 info = nextinfo; 574 info = nextinfo;
575
590 while ((info < len) && (buf[info] == ' ')) 576 while ((info < len) && (buf[info] == ' '))
591 info++; 577 info++;
578
592 if (info >= len) 579 if (info >= len)
593 break; 580 break;
581
594 nextinfo = info + 1; 582 nextinfo = info + 1;
583
595 while ((nextinfo < len) && (buf[nextinfo] != ' ')) 584 while ((nextinfo < len) && (buf[nextinfo] != ' '))
596 nextinfo++; 585 nextinfo++;
586
597 if (nextinfo - info >= 49) /*Erroneous info asked */ 587 if (nextinfo - info >= 49) /*Erroneous info asked */
598 continue; 588 continue;
589
599 strncpy (command, &(buf[info]), nextinfo - info); 590 strncpy (command, &(buf[info]), nextinfo - info);
600 command[nextinfo - info] = '\0'; 591
601 /* 2. Interpret info */ 592 /* 2. Interpret info */
602 if (!strcmp ("smooth", command)) 593 if (!strcmp ("smooth", command))
603 {
604 /* Toggle smoothing */ 594 /* Toggle smoothing */
605 ns->EMI_smooth = !ns->EMI_smooth; 595 ns->EMI_smooth = !ns->EMI_smooth;
606 }
607 else 596 else
608 {
609 /*bad value */ 597 /*bad value */;
610 } 598
611 /*3. Next info */ 599 /*3. Next info */
612 } 600 }
601
613 strcpy (cmdback, "ExtendedInfoSet"); 602 strcpy (cmdback, "ExtendedInfoSet");
603
614 if (ns->EMI_smooth) 604 if (ns->EMI_smooth)
615 { 605 {
616 strcat (cmdback, " "); 606 strcat (cmdback, " ");
617 strcat (cmdback, "smoothing"); 607 strcat (cmdback, "smoothing");
618 } 608 }
609
619 Write_String_To_Socket (ns, cmdback, strlen (cmdback)); 610 Write_String_To_Socket (ns, cmdback, strlen (cmdback));
620} 611}
621 612
622/* 613/*
623#define MSG_TYPE_BOOK 1 614#define MSG_TYPE_BOOK 1
… …
635 char temp[10]; 626 char temp[10];
636 char command[50]; 627 char command[50];
637 int info, nextinfo, i, flag; 628 int info, nextinfo, i, flag;
638 629
639 cmdback[0] = '\0'; 630 cmdback[0] = '\0';
631
640 nextinfo = 0; 632 nextinfo = 0;
641 while (1) 633 while (1)
642 { 634 {
643 /* 1. Extract an info */ 635 /* 1. Extract an info */
644 info = nextinfo; 636 info = nextinfo;
637
645 while ((info < len) && (buf[info] == ' ')) 638 while ((info < len) && (buf[info] == ' '))
646 info++; 639 info++;
640
647 if (info >= len) 641 if (info >= len)
648 break; 642 break;
643
649 nextinfo = info + 1; 644 nextinfo = info + 1;
645
650 while ((nextinfo < len) && (buf[nextinfo] != ' ')) 646 while ((nextinfo < len) && (buf[nextinfo] != ' '))
651 nextinfo++; 647 nextinfo++;
648
652 if (nextinfo - info >= 49) /*Erroneous info asked */ 649 if (nextinfo - info >= 49) /*Erroneous info asked */
653 continue; 650 continue;
651
654 strncpy (command, &(buf[info]), nextinfo - info); 652 strncpy (command, &(buf[info]), nextinfo - info);
655 command[nextinfo - info] = '\0'; 653 command[nextinfo - info] = '\0';
656 /* 2. Interpret info */ 654 /* 2. Interpret info */
657 i = sscanf (command, "%d", &flag); 655 i = sscanf (command, "%d", &flag);
656
658 if ((i == 1) && (flag > 0) && (flag <= MSG_TYPE_LAST)) 657 if ((i == 1) && (flag > 0) && (flag <= MSG_TYPE_LAST))
659 ns->supported_readables |= (1 << flag); 658 ns->supported_readables |= (1 << flag);
660 /*3. Next info */ 659 /*3. Next info */
661 } 660 }
661
662 /* Send resulting state */ 662 /* Send resulting state */
663 strcpy (cmdback, "ExtendedTextSet"); 663 strcpy (cmdback, "ExtendedTextSet");
664
664 for (i = 0; i <= MSG_TYPE_LAST; i++) 665 for (i = 0; i <= MSG_TYPE_LAST; i++)
665 if (ns->supported_readables & (1 << i)) 666 if (ns->supported_readables & (1 << i))
666 { 667 {
667 strcat (cmdback, " "); 668 strcat (cmdback, " ");
668 snprintf (temp, sizeof (temp), "%d", i); 669 snprintf (temp, sizeof (temp), "%d", i);
669 strcat (cmdback, temp); 670 strcat (cmdback, temp);
670 } 671 }
672
671 Write_String_To_Socket (ns, cmdback, strlen (cmdback)); 673 Write_String_To_Socket (ns, cmdback, strlen (cmdback));
672} 674}
673 675
674/** 676/**
675 * A lot like the old AskSmooth (in fact, now called by AskSmooth). 677 * A lot like the old AskSmooth (in fact, now called by AskSmooth).
… …
702 ns->faces_sent[face] |= NS_FACESENT_SMOOTH; 704 ns->faces_sent[face] |= NS_FACESENT_SMOOTH;
703 705
704 sl.buf = reply; 706 sl.buf = reply;
705 strcpy ((char *) sl.buf, "smooth "); 707 strcpy ((char *) sl.buf, "smooth ");
706 sl.len = strlen ((char *) sl.buf); 708 sl.len = strlen ((char *) sl.buf);
707 SockList_AddShort (&sl, face); 709
708 SockList_AddShort (&sl, smoothface); 710 sl << uint16 (face) << uint16 (smoothface);
711
709 Send_With_Handling (ns, &sl); 712 Send_With_Handling (ns, &sl);
710} 713}
711 714
712 /** 715 /**
713 * Tells client the picture it has to use 716 * Tells client the picture it has to use
… …
838 841
839 /* Send confirmation of command execution now */ 842 /* Send confirmation of command execution now */
840 sl.buf = command; 843 sl.buf = command;
841 strcpy ((char *) sl.buf, "comc "); 844 strcpy ((char *) sl.buf, "comc ");
842 sl.len = 5; 845 sl.len = 5;
843 SockList_AddShort (&sl, packet); 846
844 if (FABS (pl->ob->speed) < 0.001) 847 if (FABS (pl->ob->speed) < 0.001)
845 time = MAX_TIME * 100; 848 time = MAX_TIME * 100;
846 else 849 else
847 time = (int) (MAX_TIME / FABS (pl->ob->speed)); 850 time = (int) (MAX_TIME / FABS (pl->ob->speed));
848 SockList_AddInt (&sl, time); 851
852 sl << uint16 (packet) << uint32 (time);
853
849 Send_With_Handling (&pl->socket, &sl); 854 Send_With_Handling (&pl->socket, &sl);
850} 855}
851 856
852 857
853/** This is a reply to a previous query. */ 858/** This is a reply to a previous query. */
… …
1121 AddIfShort (pl->last_stats.Wis, pl->ob->stats.Wis, CS_STAT_WIS); 1126 AddIfShort (pl->last_stats.Wis, pl->ob->stats.Wis, CS_STAT_WIS);
1122 AddIfShort (pl->last_stats.Dex, pl->ob->stats.Dex, CS_STAT_DEX); 1127 AddIfShort (pl->last_stats.Dex, pl->ob->stats.Dex, CS_STAT_DEX);
1123 AddIfShort (pl->last_stats.Con, pl->ob->stats.Con, CS_STAT_CON); 1128 AddIfShort (pl->last_stats.Con, pl->ob->stats.Con, CS_STAT_CON);
1124 AddIfShort (pl->last_stats.Cha, pl->ob->stats.Cha, CS_STAT_CHA); 1129 AddIfShort (pl->last_stats.Cha, pl->ob->stats.Cha, CS_STAT_CHA);
1125 } 1130 }
1131
1126 if (pl->socket.exp64) 1132 if (pl->socket.exp64)
1127 { 1133 {
1128 uint8 s; 1134 uint8 s;
1129 1135
1130 for (s = 0; s < NUM_SKILLS; s++) 1136 for (s = 0; s < NUM_SKILLS; s++)
… …
1140 SockList_AddInt64 (&sl, pl->last_skill_ob[s]->stats.exp); 1146 SockList_AddInt64 (&sl, pl->last_skill_ob[s]->stats.exp);
1141 pl->last_skill_exp[s] = pl->last_skill_ob[s]->stats.exp; 1147 pl->last_skill_exp[s] = pl->last_skill_ob[s]->stats.exp;
1142 } 1148 }
1143 } 1149 }
1144 } 1150 }
1151
1145 if (pl->socket.exp64) 1152 if (pl->socket.exp64)
1146 {
1147 AddIfInt64 (pl->last_stats.exp, pl->ob->stats.exp, CS_STAT_EXP64); 1153 { AddIfInt64 (pl->last_stats.exp, pl->ob->stats.exp, CS_STAT_EXP64) }
1148 }
1149 else 1154 else
1150 {
1151 AddIfInt (pl->last_stats.exp, (int) pl->ob->stats.exp, CS_STAT_EXP); 1155 { AddIfInt (pl->last_stats.exp, (int) pl->ob->stats.exp, CS_STAT_EXP) }
1152 } 1156
1153 AddIfShort (pl->last_level, (char) pl->ob->level, CS_STAT_LEVEL); 1157 AddIfShort (pl->last_level, (char) pl->ob->level, CS_STAT_LEVEL);
1154 AddIfShort (pl->last_stats.wc, pl->ob->stats.wc, CS_STAT_WC); 1158 AddIfShort (pl->last_stats.wc, pl->ob->stats.wc, CS_STAT_WC);
1155 AddIfShort (pl->last_stats.ac, pl->ob->stats.ac, CS_STAT_AC); 1159 AddIfShort (pl->last_stats.ac, pl->ob->stats.ac, CS_STAT_AC);
1156 AddIfShort (pl->last_stats.dam, pl->ob->stats.dam, CS_STAT_DAM); 1160 AddIfShort (pl->last_stats.dam, pl->ob->stats.dam, CS_STAT_DAM);
1157 AddIfFloat (pl->last_speed, pl->ob->speed, CS_STAT_SPEED); 1161 AddIfFloat (pl->last_speed, pl->ob->speed, CS_STAT_SPEED);
1158 AddIfShort (pl->last_stats.food, pl->ob->stats.food, CS_STAT_FOOD); 1162 AddIfShort (pl->last_stats.food, pl->ob->stats.food, CS_STAT_FOOD);
1159 AddIfFloat (pl->last_weapon_sp, pl->weapon_sp, CS_STAT_WEAP_SP); 1163 AddIfFloat (pl->last_weapon_sp, pl->weapon_sp, CS_STAT_WEAP_SP);
1160 AddIfInt (pl->last_weight_limit, (sint32) weight_limit[pl->ob->stats.Str], CS_STAT_WEIGHT_LIM); 1164 AddIfInt (pl->last_weight_limit, (sint32) weight_limit[pl->ob->stats.Str], CS_STAT_WEIGHT_LIM);
1161 flags = 0; 1165 flags = 0;
1166
1162 if (pl->fire_on) 1167 if (pl->fire_on)
1163 flags |= SF_FIREON; 1168 flags |= SF_FIREON;
1169
1164 if (pl->run_on) 1170 if (pl->run_on)
1165 flags |= SF_RUNON; 1171 flags |= SF_RUNON;
1166 1172
1167 AddIfShort (pl->last_flags, flags, CS_STAT_FLAGS); 1173 AddIfShort (pl->last_flags, flags, CS_STAT_FLAGS);
1174
1168 if (pl->socket.sc_version < 1025) 1175 if (pl->socket.sc_version < 1025)
1169 {
1170 AddIfShort (pl->last_resist[ATNR_PHYSICAL], pl->ob->resist[ATNR_PHYSICAL], CS_STAT_ARMOUR); 1176 { AddIfShort (pl->last_resist[ATNR_PHYSICAL], pl->ob->resist[ATNR_PHYSICAL], CS_STAT_ARMOUR) }
1171 }
1172 else 1177 else
1173 { 1178 {
1174 int i; 1179 int i;
1175 1180
1176 for (i = 0; i < NROFATTACKS; i++) 1181 for (i = 0; i < NROFATTACKS; i++)
1177 { 1182 {
1178 /* Skip ones we won't send */ 1183 /* Skip ones we won't send */
1179 if (atnr_cs_stat[i] == -1) 1184 if (atnr_cs_stat[i] == -1)
1180 continue; 1185 continue;
1186
1181 AddIfShort (pl->last_resist[i], pl->ob->resist[i], (char) atnr_cs_stat[i]); 1187 AddIfShort (pl->last_resist[i], pl->ob->resist[i], (char) atnr_cs_stat[i]);
1182 } 1188 }
1183 } 1189 }
1190
1184 if (pl->socket.monitor_spells) 1191 if (pl->socket.monitor_spells)
1185 { 1192 {
1186 AddIfInt (pl->last_path_attuned, pl->ob->path_attuned, CS_STAT_SPELL_ATTUNE); 1193 AddIfInt (pl->last_path_attuned, pl->ob->path_attuned, CS_STAT_SPELL_ATTUNE);
1187 AddIfInt (pl->last_path_repelled, pl->ob->path_repelled, CS_STAT_SPELL_REPEL); 1194 AddIfInt (pl->last_path_repelled, pl->ob->path_repelled, CS_STAT_SPELL_REPEL);
1188 AddIfInt (pl->last_path_denied, pl->ob->path_denied, CS_STAT_SPELL_DENY); 1195 AddIfInt (pl->last_path_denied, pl->ob->path_denied, CS_STAT_SPELL_DENY);
1189 } 1196 }
1197
1190 rangetostring (pl->ob, buf); /* we want use the new fire & run system in new client */ 1198 rangetostring (pl->ob, buf); /* we want use the new fire & run system in new client */
1191 AddIfString (pl->socket.stats.range, buf, CS_STAT_RANGE); 1199 AddIfString (pl->socket.stats.range, buf, CS_STAT_RANGE);
1192 set_title (pl->ob, buf); 1200 set_title (pl->ob, buf);
1193 AddIfString (pl->socket.stats.title, buf, CS_STAT_TITLE); 1201 AddIfString (pl->socket.stats.title, buf, CS_STAT_TITLE);
1194 1202
… …
1198#ifdef ESRV_DEBUG 1206#ifdef ESRV_DEBUG
1199 LOG (llevDebug, "Sending stats command, %d bytes long.\n", sl.len); 1207 LOG (llevDebug, "Sending stats command, %d bytes long.\n", sl.len);
1200#endif 1208#endif
1201 Send_With_Handling (&pl->socket, &sl); 1209 Send_With_Handling (&pl->socket, &sl);
1202 } 1210 }
1211
1203 free (sl.buf); 1212 free (sl.buf);
1204} 1213}
1205
1206 1214
1207/** 1215/**
1208 * Tells the client that here is a player it should start using. 1216 * Tells the client that here is a player it should start using.
1209 */ 1217 */
1210void 1218void
… …
1228 1236
1229 Send_With_Handling (&pl->socket, &sl); 1237 Send_With_Handling (&pl->socket, &sl);
1230 free (sl.buf); 1238 free (sl.buf);
1231 SET_FLAG (pl->ob, FLAG_CLIENT_SENT); 1239 SET_FLAG (pl->ob, FLAG_CLIENT_SENT);
1232} 1240}
1233
1234 1241
1235/** 1242/**
1236 * Need to send an animation sequence to the client. 1243 * Need to send an animation sequence to the client.
1237 * We will send appropriate face commands to the client if we haven't 1244 * We will send appropriate face commands to the client if we haven't
1238 * sent them the face yet (this can become quite costly in terms of 1245 * sent them the face yet (this can become quite costly in terms of
… …
1426 1433
1427 if (sl.len > (int) strlen ("map ") || ns->sent_scroll) 1434 if (sl.len > (int) strlen ("map ") || ns->sent_scroll)
1428 { 1435 {
1429 /* All of this is just accounting stuff */ 1436 /* All of this is just accounting stuff */
1430 if (tframes > 100) 1437 if (tframes > 100)
1431 {
1432 tframes = tbytes = 0; 1438 tframes = tbytes = 0;
1433 } 1439
1434 tframes++; 1440 tframes++;
1435 frames++; 1441 frames++;
1436 tbytes += sl.len; 1442 tbytes += sl.len;
1437 bytes += sl.len; 1443 bytes += sl.len;
1438 memcpy (&ns->lastmap, newmap, sizeof (struct Map)); 1444 memcpy (&ns->lastmap, newmap, sizeof (struct Map));
1439 Send_With_Handling (ns, &sl); 1445 Send_With_Handling (ns, &sl);
1440 ns->sent_scroll = 0; 1446 ns->sent_scroll = 0;
1441 } 1447 }
1448
1442 free (sl.buf); 1449 free (sl.buf);
1443} 1450}
1444 1451
1445 1452
1446/** Clears a map cell */ 1453/** Clears a map cell */
… …
1448map_clearcell (struct MapCell *cell, int face0, int face1, int face2, int count) 1455map_clearcell (struct MapCell *cell, int face0, int face1, int face2, int count)
1449{ 1456{
1450 cell->faces[0] = face0; 1457 cell->faces[0] = face0;
1451 cell->faces[1] = face1; 1458 cell->faces[1] = face1;
1452 cell->faces[2] = face2; 1459 cell->faces[2] = face2;
1453 cell->count = count; 1460 cell->count = count;
1454 cell->stat_hp = 0; 1461 cell->stat_hp = 0;
1462 cell->flags = 0;
1455 cell->player = 0; 1463 cell->player = 0;
1456} 1464}
1457 1465
1458#define MAX_HEAD_POS MAX(MAX_CLIENT_X, MAX_CLIENT_Y) 1466#define MAX_HEAD_POS MAX(MAX_CLIENT_X, MAX_CLIENT_Y)
1459#define MAX_LAYERS 3 1467#define MAX_LAYERS 3
1460 1468
… …
1531 * the case, it seems to make more sense to have these layer values 1539 * the case, it seems to make more sense to have these layer values
1532 * actually match. 1540 * actually match.
1533 */ 1541 */
1534 1542
1535static int 1543static int
1536update_space (SockList * sl, NewSocket * ns, mapstruct *mp, int mx, int my, int sx, int sy, int layer) 1544update_space (SockList * sl, NewSocket * ns, maptile *mp, int mx, int my, int sx, int sy, int layer)
1537{ 1545{
1538 object *ob, *head; 1546 object *ob, *head;
1539 uint16 face_num; 1547 uint16 face_num;
1540 int bx, by, i; 1548 int bx, by, i;
1541 1549
… …
1755 * top layer (this matches what the GET_MAP_FACE and GET_MAP_FACE_OBJ 1763 * top layer (this matches what the GET_MAP_FACE and GET_MAP_FACE_OBJ
1756 * take. 1764 * take.
1757 */ 1765 */
1758 1766
1759static inline int 1767static inline int
1760update_smooth (SockList * sl, NewSocket * ns, mapstruct *mp, int mx, int my, int sx, int sy, int layer) 1768update_smooth (SockList * sl, NewSocket * ns, maptile *mp, int mx, int my, int sx, int sy, int layer)
1761{ 1769{
1762 object *ob; 1770 object *ob;
1763 int smoothlevel; /* old face_num; */ 1771 int smoothlevel; /* old face_num; */
1764 1772
1765 ob = GET_MAP_FACE_OBJ (mp, mx, my, layer); 1773 ob = GET_MAP_FACE_OBJ (mp, mx, my, layer);
… …
1843 SockList esl; /*For extended Map info */ 1851 SockList esl; /*For extended Map info */
1844 uint16 mask, emask; 1852 uint16 mask, emask;
1845 uint8 eentrysize; 1853 uint8 eentrysize;
1846 uint16 ewhatstart, ewhatflag; 1854 uint16 ewhatstart, ewhatflag;
1847 uint8 extendedinfos; 1855 uint8 extendedinfos;
1848 mapstruct *m; 1856 maptile *m;
1849 1857
1850 NewSocket & socket = pl->contr->socket; 1858 NewSocket & socket = pl->contr->socket;
1851 1859
1852 check_map_change (pl->contr); 1860 check_map_change (pl->contr);
1853 1861
… …
1856 strcpy ((char *) sl.buf, "map1 "); 1864 strcpy ((char *) sl.buf, "map1 ");
1857 else 1865 else
1858 strcpy ((char *) sl.buf, "map1a "); 1866 strcpy ((char *) sl.buf, "map1a ");
1859 sl.len = strlen ((char *) sl.buf); 1867 sl.len = strlen ((char *) sl.buf);
1860 startlen = sl.len; 1868 startlen = sl.len;
1869
1861 /*Extendedmapinfo structure initialisation */ 1870 /*Extendedmapinfo structure initialisation */
1862 if (socket.ext_mapinfos) 1871 if (socket.ext_mapinfos)
1863 { 1872 {
1864 esl.buf = (unsigned char *) malloc (MAXSOCKBUF); 1873 esl.buf = (unsigned char *) malloc (MAXSOCKBUF);
1865 strcpy ((char *) esl.buf, "mapextended "); 1874 strcpy ((char *) esl.buf, "mapextended ");
1866 esl.len = strlen ((char *) esl.buf); 1875 esl.len = strlen ((char *) esl.buf);
1867 extendedinfos = EMI_NOREDRAW; 1876 extendedinfos = EMI_NOREDRAW;
1877
1868 if (socket.EMI_smooth) 1878 if (socket.EMI_smooth)
1869 extendedinfos |= EMI_SMOOTH; 1879 extendedinfos |= EMI_SMOOTH;
1880
1870 ewhatstart = esl.len; 1881 ewhatstart = esl.len;
1871 ewhatflag = extendedinfos; /*The EMI_NOREDRAW bit 1882 ewhatflag = extendedinfos; /*The EMI_NOREDRAW bit
1872 could need to be taken away */ 1883 could need to be taken away */
1873 SockList_AddChar (&esl, extendedinfos); 1884 SockList_AddChar (&esl, extendedinfos);
1874 eentrysize = getExtendedMapInfoSize (&socket); 1885 eentrysize = getExtendedMapInfoSize (&socket);
… …
1880 /* suppress compiler warnings */ 1891 /* suppress compiler warnings */
1881 ewhatstart = 0; 1892 ewhatstart = 0;
1882 ewhatflag = 0; 1893 ewhatflag = 0;
1883 estartlen = 0; 1894 estartlen = 0;
1884 } 1895 }
1896
1885 /* Init data to zero */ 1897 /* Init data to zero */
1886 memset (heads, 0, sizeof (object *) * MAX_HEAD_POS * MAX_HEAD_POS * MAX_LAYERS); 1898 memset (heads, 0, sizeof (object *) * MAX_HEAD_POS * MAX_HEAD_POS * MAX_LAYERS);
1887 1899
1888 /* x,y are the real map locations. ax, ay are viewport relative 1900 /* x,y are the real map locations. ax, ay are viewport relative
1889 * locations. 1901 * locations.
… …
1893 /* We could do this logic as conditionals in the if statement, 1905 /* We could do this logic as conditionals in the if statement,
1894 * but that started to get a bit messy to look at. 1906 * but that started to get a bit messy to look at.
1895 */ 1907 */
1896 max_x = pl->x + (socket.mapx + 1) / 2; 1908 max_x = pl->x + (socket.mapx + 1) / 2;
1897 max_y = pl->y + (socket.mapy + 1) / 2; 1909 max_y = pl->y + (socket.mapy + 1) / 2;
1910
1898 if (socket.mapmode == Map1aCmd) 1911 if (socket.mapmode == Map1aCmd)
1899 { 1912 {
1900 max_x += MAX_HEAD_OFFSET; 1913 max_x += MAX_HEAD_OFFSET;
1901 max_y += MAX_HEAD_OFFSET; 1914 max_y += MAX_HEAD_OFFSET;
1902 } 1915 }
… …
1935 * with no faces tells the client to blank out the 1948 * with no faces tells the client to blank out the
1936 * space. 1949 * space.
1937 */ 1950 */
1938 got_one = 0; 1951 got_one = 0;
1939 for (i = oldlen + 2; i < sl.len; i++) 1952 for (i = oldlen + 2; i < sl.len; i++)
1940 {
1941 if (sl.buf[i]) 1953 if (sl.buf[i])
1942 got_one = 1; 1954 got_one = 1;
1943 }
1944 1955
1945 if (got_one && (mask & 0xf)) 1956 if (got_one && (mask & 0xf))
1946 {
1947 sl.buf[oldlen + 1] = mask & 0xff; 1957 sl.buf[oldlen + 1] = mask & 0xff;
1948 }
1949 else 1958 else
1950 { /*either all faces blank, either no face at all */ 1959 { /*either all faces blank, either no face at all */
1951 if (mask & 0xf) /*at least 1 face, we know it's blank, only send coordinates */ 1960 if (mask & 0xf) /*at least 1 face, we know it's blank, only send coordinates */
1952 sl.len = oldlen + 2; 1961 sl.len = oldlen + 2;
1953 else 1962 else
1954 sl.len = oldlen; 1963 sl.len = oldlen;
1955 } 1964 }
1965
1956 /*What concerns extendinfos, nothing to be done for now 1966 /*What concerns extendinfos, nothing to be done for now
1957 * (perhaps effects layer later) 1967 * (perhaps effects layer later)
1958 */ 1968 */
1959 continue; /* don't do processing below */ 1969 continue; /* don't do processing below */
1960 } 1970 }
1961 1971
1962 MapCell & lastcell = socket.lastmap.cells[ax][ay]; 1972 MapCell &lastcell = socket.lastmap.cells[ax][ay];
1963 1973
1964 d = pl->contr->blocked_los[ax][ay]; 1974 d = pl->contr->blocked_los[ax][ay];
1965 1975
1966 /* If the coordinates are not valid, or it is too dark to see, 1976 /* If the coordinates are not valid, or it is too dark to see,
1967 * we tell the client as such 1977 * we tell the client as such
1968 */ 1978 */
1969 nx = x; 1979 nx = x;
1970 ny = y; 1980 ny = y;
1971 m = get_map_from_coord (pl->map, &nx, &ny); 1981 m = get_map_from_coord (pl->map, &nx, &ny);
1982
1972 if (!m) 1983 if (!m)
1973 { 1984 {
1974 /* space is out of map. Update space and clear values 1985 /* space is out of map. Update space and clear values
1975 * if this hasn't already been done. If the space is out 1986 * if this hasn't already been done. If the space is out
1976 * of the map, it shouldn't have a head 1987 * of the map, it shouldn't have a head
… …
1990 */ 2001 */
1991 2002
1992 oldlen = sl.len; 2003 oldlen = sl.len;
1993 2004
1994 SockList_AddShort (&sl, mask); 2005 SockList_AddShort (&sl, mask);
2006
1995 if (lastcell.count != -1) 2007 if (lastcell.count != -1)
1996 need_send = 1; 2008 need_send = 1;
2009
1997 count = -1; 2010 count = -1;
1998 2011
1999 if (socket.mapmode == Map1aCmd && have_head (ax, ay)) 2012 if (socket.mapmode == Map1aCmd && have_head (ax, ay))
2000 { 2013 {
2001 /* Now check to see if any heads need to be sent */ 2014 /* Now check to see if any heads need to be sent */
… …
2006 mask |= 0x2; 2019 mask |= 0x2;
2007 if (check_head (sl, socket, ax, ay, 0)) 2020 if (check_head (sl, socket, ax, ay, 0))
2008 mask |= 0x1; 2021 mask |= 0x1;
2009 2022
2010 lastcell.count = count; 2023 lastcell.count = count;
2011
2012 } 2024 }
2013 else 2025 else
2014 { 2026 {
2015 struct MapCell *cell = &lastcell;
2016
2017 /* properly clear a previously sent big face */ 2027 /* properly clear a previously sent big face */
2018 if (cell->faces[0] != 0 || cell->faces[1] != 0 || cell->faces[2] != 0) 2028 if (lastcell.faces[0] != 0 || lastcell.faces[1] != 0 || lastcell.faces[2] != 0
2029 || lastcell.stat_hp || lastcell.flags || lastcell.player)
2019 need_send = 1; 2030 need_send = 1;
2031
2020 map_clearcell (&lastcell, 0, 0, 0, count); 2032 map_clearcell (&lastcell, 0, 0, 0, count);
2021 } 2033 }
2022 2034
2023 if ((mask & 0xf) || need_send) 2035 if ((mask & 0xf) || need_send)
2024 {
2025 sl.buf[oldlen + 1] = mask & 0xff; 2036 sl.buf[oldlen + 1] = mask & 0xff;
2026 }
2027 else 2037 else
2028 {
2029 sl.len = oldlen; 2038 sl.len = oldlen;
2030 }
2031 } 2039 }
2032 else 2040 else
2033 { 2041 {
2034 /* In this block, the space is visible or there are head objects 2042 /* In this block, the space is visible or there are head objects
2035 * we need to send. 2043 * we need to send.
… …
2076 2084
2077 if (socket.extmap) 2085 if (socket.extmap)
2078 { 2086 {
2079 uint8 stat_hp = 0; 2087 uint8 stat_hp = 0;
2080 uint8 stat_width = 0; 2088 uint8 stat_width = 0;
2089 uint8 flags = 0;
2081 tag_t player = 0; 2090 UUID player = 0;
2082 2091
2083 // send hp information, if applicable 2092 // send hp information, if applicable
2084 if (object *op = GET_MAP_FACE_OBJ (m, nx, ny, 0)) 2093 if (object *op = GET_MAP_FACE_OBJ (m, nx, ny, 0))
2085 { 2094 {
2086 if (op->head || op->invisible) 2095 if (op->head || op->invisible)
… …
2093 stat_hp = 255 - (op->stats.hp * 255 + 254) / op->stats.maxhp; 2102 stat_hp = 255 - (op->stats.hp * 255 + 254) / op->stats.maxhp;
2094 stat_width = op->arch->tail_x; 2103 stat_width = op->arch->tail_x;
2095 } 2104 }
2096 } 2105 }
2097 2106
2107 if (op->msg && op->msg[0] == '@')
2108 flags |= 1;
2109
2098 if (op->type == PLAYER && op != pl) 2110 if (op->type == PLAYER && op != pl)
2099 player = op->count; 2111 player = op->count;
2100 } 2112 }
2101 2113
2102 if (lastcell.stat_hp != stat_hp) 2114 if (lastcell.stat_hp != stat_hp)
… …
2104 lastcell.stat_hp = stat_hp; 2116 lastcell.stat_hp = stat_hp;
2105 2117
2106 mask |= 0x8; 2118 mask |= 0x8;
2107 *last_ext |= 0x80; 2119 *last_ext |= 0x80;
2108 last_ext = sl.buf + sl.len; 2120 last_ext = sl.buf + sl.len;
2109 SockList_AddChar (&sl, 5); 2121
2110 SockList_AddChar (&sl, stat_hp); 2122 sl << uint8 (5) << uint8 (stat_hp);
2111 2123
2112 if (stat_width > 1) 2124 if (stat_width > 1)
2113 { 2125 {
2114 *last_ext |= 0x80; 2126 *last_ext |= 0x80;
2115 last_ext = sl.buf + sl.len; 2127 last_ext = sl.buf + sl.len;
2116 SockList_AddChar (&sl, 6); 2128
2117 SockList_AddChar (&sl, stat_width); 2129 sl << uint8 (6) << uint8 (stat_width);
2118 } 2130 }
2119 } 2131 }
2120 2132
2121 if (lastcell.player !=player) 2133 if (lastcell.player != player)
2122 { 2134 {
2123 lastcell.player = player; 2135 lastcell.player = player;
2124 2136
2125 mask |= 0x8; 2137 mask |= 0x8;
2126 *last_ext |= 0x80; 2138 *last_ext |= 0x80;
2127 last_ext = sl.buf + sl.len; 2139 last_ext = sl.buf + sl.len;
2128 SockList_AddChar (&sl, 0x47); 2140
2129 SockList_AddChar (&sl, 4); 2141 sl << uint8 (0x47) << uint8 (8) << (uint64)player;
2130 SockList_AddInt (&sl, player); 2142 }
2143
2144 if (lastcell.flags != flags)
2145 {
2146 lastcell.flags = flags;
2147
2148 mask |= 0x8;
2149 *last_ext |= 0x80;
2150 last_ext = sl.buf + sl.len;
2151
2152 sl << uint8 (8) << uint8 (flags);
2131 } 2153 }
2132 } 2154 }
2133 2155
2134 /* Floor face */ 2156 /* Floor face */
2135 if (update_space (&sl, &socket, m, nx, ny, ax, ay, 2)) 2157 if (update_space (&sl, &socket, m, nx, ny, ax, ay, 2))
… …
2151 { 2173 {
2152 if (lastcell.faces[0] != pl->face->number) 2174 if (lastcell.faces[0] != pl->face->number)
2153 { 2175 {
2154 lastcell.faces[0] = pl->face->number; 2176 lastcell.faces[0] = pl->face->number;
2155 mask |= 0x1; 2177 mask |= 0x1;
2178
2156 if (!(socket.faces_sent[pl->face->number] & NS_FACESENT_FACE)) 2179 if (!(socket.faces_sent[pl->face->number] & NS_FACESENT_FACE))
2157 esrv_send_face (&socket, pl->face->number, 0); 2180 esrv_send_face (&socket, pl->face->number, 0);
2158 SockList_AddShort (&sl, pl->face->number); 2181
2182 sl << uint16 (pl->face->number);
2159 } 2183 }
2160 } 2184 }
2161 /* Top face */
2162 else 2185 else
2163 { 2186 {
2187 /* Top face */
2164 if (update_space (&sl, &socket, m, nx, ny, ax, ay, 0)) 2188 if (update_space (&sl, &socket, m, nx, ny, ax, ay, 0))
2165 mask |= 0x1; 2189 mask |= 0x1;
2190
2166 if (socket.EMI_smooth) 2191 if (socket.EMI_smooth)
2167 if (update_smooth (&esl, &socket, m, nx, ny, ax, ay, 0)) 2192 if (update_smooth (&esl, &socket, m, nx, ny, ax, ay, 0))
2168 {
2169 emask |= 0x1; 2193 emask |= 0x1;
2170 }
2171 } 2194 }
2195
2172 /* Check to see if we are in fact sending anything for this 2196 /* Check to see if we are in fact sending anything for this
2173 * space by checking the mask. If so, update the mask. 2197 * space by checking the mask. If so, update the mask.
2174 * if not, reset the len to that from before adding the mask 2198 * if not, reset the len to that from before adding the mask
2175 * value, so we don't send those bits. 2199 * value, so we don't send those bits.
2176 */ 2200 */
2177 if (mask & 0xf) 2201 if (mask & 0xf)
2178 {
2179 sl.buf[oldlen + 1] = mask & 0xff; 2202 sl.buf[oldlen + 1] = mask & 0xff;
2180 }
2181 else 2203 else
2182 {
2183 sl.len = oldlen; 2204 sl.len = oldlen;
2184 } 2205
2185 if (emask & 0xf) 2206 if (emask & 0xf)
2186 {
2187 esl.buf[eoldlen + 1] = emask & 0xff; 2207 esl.buf[eoldlen + 1] = emask & 0xff;
2188 }
2189 else 2208 else
2190 {
2191 esl.len = eoldlen; 2209 esl.len = eoldlen;
2192 }
2193 } /* else this is a viewable space */ 2210 } /* else this is a viewable space */
2194 } /* for x loop */ 2211 } /* for x loop */
2195 } /* for y loop */ 2212 } /* for y loop */
2196 2213
2197 /* Verify that we in fact do need to send this */ 2214 /* Verify that we in fact do need to send this */
… …
2203 * it doesn't need draw! 2220 * it doesn't need draw!
2204 */ 2221 */
2205 ewhatflag &= (~EMI_NOREDRAW); 2222 ewhatflag &= (~EMI_NOREDRAW);
2206 esl.buf[ewhatstart + 1] = ewhatflag & 0xff; 2223 esl.buf[ewhatstart + 1] = ewhatflag & 0xff;
2207 } 2224 }
2225
2208 if (esl.len > estartlen) 2226 if (esl.len > estartlen)
2209 {
2210 Send_With_Handling (&socket, &esl); 2227 Send_With_Handling (&socket, &esl);
2211 } 2228
2212 free (esl.buf); 2229 free (esl.buf);
2213 } 2230 }
2231
2214 if (sl.len > startlen || socket.sent_scroll) 2232 if (sl.len > startlen || socket.sent_scroll)
2215 { 2233 {
2216 Send_With_Handling (&socket, &sl); 2234 Send_With_Handling (&socket, &sl);
2217 socket.sent_scroll = 0; 2235 socket.sent_scroll = 0;
2218 } 2236 }
2237
2219 free (sl.buf); 2238 free (sl.buf);
2220} 2239}
2221 2240
2222/** 2241/**
2223 * Draws client map. 2242 * Draws client map.
… …
2229 sint16 ax, ay, nx, ny; /* ax and ay goes from 0 to max-size of arrays */ 2248 sint16 ax, ay, nx, ny; /* ax and ay goes from 0 to max-size of arrays */
2230 New_Face *face, *floor; 2249 New_Face *face, *floor;
2231 New_Face *floor2; 2250 New_Face *floor2;
2232 int d, mflags; 2251 int d, mflags;
2233 struct Map newmap; 2252 struct Map newmap;
2234 mapstruct *m, *pm; 2253 maptile *m, *pm;
2235 2254
2236 if (pl->type != PLAYER) 2255 if (pl->type != PLAYER)
2237 { 2256 {
2238 LOG (llevError, "draw_client_map called with non player/non eric-server\n"); 2257 LOG (llevError, "draw_client_map called with non player/non eric-server\n");
2239 return; 2258 return;
… …
2447 if (flags != 0) 2466 if (flags != 0)
2448 { 2467 {
2449 sl.buf = (unsigned char *) malloc (MAXSOCKBUF); 2468 sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
2450 strcpy ((char *) sl.buf, "updspell "); 2469 strcpy ((char *) sl.buf, "updspell ");
2451 sl.len = strlen ((char *) sl.buf); 2470 sl.len = strlen ((char *) sl.buf);
2452 SockList_AddChar (&sl, flags); 2471
2453 SockList_AddInt (&sl, spell->count); 2472 sl << uint8 (flags) << uint32 (spell->count);
2454 if (flags & UPD_SP_MANA) 2473
2455 SockList_AddShort (&sl, spell->last_sp); 2474 if (flags & UPD_SP_MANA ) sl << uint16 (spell->last_sp);
2456 if (flags & UPD_SP_GRACE) 2475 if (flags & UPD_SP_GRACE ) sl << uint16 (spell->last_grace);
2457 SockList_AddShort (&sl, spell->last_grace); 2476 if (flags & UPD_SP_DAMAGE) sl << uint16 (spell->last_eat);
2458 if (flags & UPD_SP_DAMAGE) 2477
2459 SockList_AddShort (&sl, spell->last_eat);
2460 flags = 0; 2478 flags = 0;
2461 Send_With_Handling (&pl->socket, &sl); 2479 Send_With_Handling (&pl->socket, &sl);
2462 free (sl.buf); 2480 free (sl.buf);
2463 } 2481 }
2464 } 2482 }
… …
2478 return; 2496 return;
2479 } 2497 }
2480 sl.buf = (unsigned char *) malloc (MAXSOCKBUF); 2498 sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
2481 strcpy ((char *) sl.buf, "delspell "); 2499 strcpy ((char *) sl.buf, "delspell ");
2482 sl.len = strlen ((char *) sl.buf); 2500 sl.len = strlen ((char *) sl.buf);
2483 SockList_AddInt (&sl, spell->count); 2501
2502 sl << uint32 (spell->count);
2503
2484 Send_With_Handling (&pl->socket, &sl); 2504 Send_With_Handling (&pl->socket, &sl);
2485 free (sl.buf); 2505 free (sl.buf);
2486} 2506}
2487 2507
2488/* appends the spell *spell to the Socklist we will send the data to. */ 2508/* appends the spell *spell to the Socklist we will send the data to. */
2489static void 2509static void
2490append_spell (player *pl, SockList * sl, object *spell) 2510append_spell (player *pl, SockList &sl, object *spell)
2491{ 2511{
2492 int len, i, skill = 0; 2512 int len, i, skill = 0;
2493 2513
2494 if (!(spell->name)) 2514 if (!(spell->name))
2495 { 2515 {
2496 LOG (llevError, "item number %d is a spell with no name.\n", spell->count); 2516 LOG (llevError, "item number %d is a spell with no name.\n", spell->count);
2497 return; 2517 return;
2498 } 2518 }
2499 SockList_AddInt (sl, spell->count); 2519
2500 SockList_AddShort (sl, spell->level);
2501 SockList_AddShort (sl, spell->casting_time);
2502 /* store costs and damage in the object struct, to compare to later */ 2520 /* store costs and damage in the object struct, to compare to later */
2503 spell->last_sp = SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA); 2521 spell->last_sp = SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA);
2504 spell->last_grace = SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE); 2522 spell->last_grace = SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE);
2505 spell->last_eat = spell->stats.dam + SP_level_dam_adjust (pl->ob, spell); 2523 spell->last_eat = spell->stats.dam + SP_level_dam_adjust (pl->ob, spell);
2506 /* send the current values */
2507 SockList_AddShort (sl, spell->last_sp);
2508 SockList_AddShort (sl, spell->last_grace);
2509 SockList_AddShort (sl, spell->last_eat);
2510 2524
2511 /* figure out which skill it uses, if it uses one */ 2525 /* figure out which skill it uses, if it uses one */
2512 if (spell->skill) 2526 if (spell->skill)
2513 { 2527 {
2514 for (i = 1; i < NUM_SKILLS; i++) 2528 for (i = 1; i < NUM_SKILLS; i++)
… …
2516 { 2530 {
2517 skill = i + CS_STAT_SKILLINFO; 2531 skill = i + CS_STAT_SKILLINFO;
2518 break; 2532 break;
2519 } 2533 }
2520 } 2534 }
2521 SockList_AddChar (sl, skill);
2522 2535
2523 SockList_AddInt (sl, spell->path_attuned); 2536 /* send the current values */
2537 sl << uint32 (spell->count)
2538 << uint16 (spell->level)
2539 << uint16 (spell->casting_time)
2540 << uint16 (spell->last_sp)
2541 << uint16 (spell->last_grace)
2542 << uint16 (spell->last_eat)
2543 << uint8 (skill)
2544 << uint32 (spell->path_attuned)
2524 SockList_AddInt (sl, (spell->face) ? spell->face->number : 0); 2545 << uint32 (spell->face ? spell->face->number : 0)
2525 2546 << data8 (spell->name)
2526 len = strlen (spell->name); 2547 << data16 (spell->msg);
2527 SockList_AddChar (sl, (char) len);
2528 memcpy (sl->buf + sl->len, spell->name, len);
2529 sl->len += len;
2530
2531 if (!spell->msg)
2532 {
2533 SockList_AddShort (sl, 0);
2534 }
2535 else
2536 {
2537 len = strlen (spell->msg);
2538 SockList_AddShort (sl, len);
2539 memcpy (sl->buf + sl->len, spell->msg, len);
2540 sl->len += len;
2541 }
2542} 2548}
2543 2549
2544/** 2550/**
2545 * This tells the client to add the spell *ob, if *ob is NULL, then add 2551 * This tells the client to add the spell *ob, if *ob is NULL, then add
2546 * all spells in the player's inventory. 2552 * all spells in the player's inventory.
… …
2577 * is hundreds of bytes off, so correcting 22 vs 26 doesn't seem 2583 * is hundreds of bytes off, so correcting 22 vs 26 doesn't seem
2578 * like it will fix this 2584 * like it will fix this
2579 */ 2585 */
2580 if (spell->type != SPELL) 2586 if (spell->type != SPELL)
2581 continue; 2587 continue;
2588
2582 if (sl.len >= (MAXSOCKBUF - (26 + strlen (spell->name) + (spell->msg ? strlen (spell->msg) : 0)))) 2589 if (sl.len >= (MAXSOCKBUF - (26 + strlen (spell->name) + (spell->msg ? strlen (spell->msg) : 0))))
2583 { 2590 {
2584 Send_With_Handling (&pl->socket, &sl); 2591 Send_With_Handling (&pl->socket, &sl);
2585 strcpy ((char *) sl.buf, "addspell "); 2592 strcpy ((char *) sl.buf, "addspell ");
2586 sl.len = strlen ((char *) sl.buf); 2593 sl.len = strlen ((char *) sl.buf);
2587 } 2594 }
2595
2588 append_spell (pl, &sl, spell); 2596 append_spell (pl, sl, spell);
2589 } 2597 }
2590 } 2598 }
2591 else if (spell->type != SPELL) 2599 else if (spell->type != SPELL)
2592 { 2600 {
2593 LOG (llevError, "Asked to send a non-spell object as a spell"); 2601 LOG (llevError, "Asked to send a non-spell object as a spell");
2594 return; 2602 return;
2595 } 2603 }
2596 else 2604 else
2597 append_spell (pl, &sl, spell); 2605 append_spell (pl, sl, spell);
2606
2598 if (sl.len >= MAXSOCKBUF) 2607 if (sl.len >= MAXSOCKBUF)
2599 { 2608 {
2600 LOG (llevError, "Buffer overflow in esrv_add_spells!\n"); 2609 LOG (llevError, "Buffer overflow in esrv_add_spells!\n");
2601 fatal (0); 2610 fatal (0);
2602 } 2611 }
2612
2603 /* finally, we can send the packet */ 2613 /* finally, we can send the packet */
2604 Send_With_Handling (&pl->socket, &sl); 2614 Send_With_Handling (&pl->socket, &sl);
2605 free (sl.buf); 2615 free (sl.buf);
2606} 2616}

Diff Legend

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