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.25 by root, Thu Sep 21 14:51:16 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
… …
145 for (x = 0; x < mx; x++) 137 for (x = 0; x < mx; x++)
146 { 138 {
147 for (y = 0; y < my; y++) 139 for (y = 0; y < my; y++)
148 { 140 {
149 if (x >= ns->mapx || y >= ns->mapy) 141 if (x >= ns->mapx || y >= ns->mapy)
150 {
151 /* clear cells outside the viewable area */ 142 /* clear cells outside the viewable area */
152 memset (&newmap.cells[x][y], 0, sizeof (struct MapCell)); 143 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) 144 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 */ 145 /* clear newly visible tiles within the viewable area */
157 memset (&(newmap.cells[x][y]), 0, sizeof (struct MapCell)); 146 memset (&(newmap.cells[x][y]), 0, sizeof (struct MapCell));
158 }
159 else 147 else
160 {
161 memcpy (&(newmap.cells[x][y]), &(ns->lastmap.cells[x + dx][y + dy]), sizeof (struct MapCell)); 148 memcpy (&(newmap.cells[x][y]), &(ns->lastmap.cells[x + dx][y + dy]), sizeof (struct MapCell));
162 }
163 } 149 }
164 } 150 }
165 151
166 memcpy (&(ns->lastmap), &newmap, sizeof (struct Map)); 152 memcpy (&(ns->lastmap), &newmap, sizeof (struct Map));
167 153
… …
266 if (!strncmp (buf, "spatial ", 8)) 252 if (!strncmp (buf, "spatial ", 8))
267 { 253 {
268 buf += 8; 254 buf += 8;
269 255
270 // initial map and its origin 256 // initial map and its origin
271 mapstruct *map = pl->ob->map; 257 maptile *map = pl->ob->map;
272 sint16 dx, dy; 258 sint16 dx, dy;
273 int mapx = pl->socket.mapx / 2 - pl->ob->x; 259 int mapx = pl->socket.mapx / 2 - pl->ob->x;
274 int mapy = pl->socket.mapy / 2 - pl->ob->y; 260 int mapy = pl->socket.mapy / 2 - pl->ob->y;
275 int max_distance = 8; // limit maximum path length to something generous 261 int max_distance = 8; // limit maximum path length to something generous
276 262
… …
581 char command[50]; 567 char command[50];
582 int info, nextinfo; 568 int info, nextinfo;
583 569
584 cmdback[0] = '\0'; 570 cmdback[0] = '\0';
585 nextinfo = 0; 571 nextinfo = 0;
572
586 while (1) 573 while (1)
587 { 574 {
588 /* 1. Extract an info */ 575 /* 1. Extract an info */
589 info = nextinfo; 576 info = nextinfo;
577
590 while ((info < len) && (buf[info] == ' ')) 578 while ((info < len) && (buf[info] == ' '))
591 info++; 579 info++;
580
592 if (info >= len) 581 if (info >= len)
593 break; 582 break;
583
594 nextinfo = info + 1; 584 nextinfo = info + 1;
585
595 while ((nextinfo < len) && (buf[nextinfo] != ' ')) 586 while ((nextinfo < len) && (buf[nextinfo] != ' '))
596 nextinfo++; 587 nextinfo++;
588
597 if (nextinfo - info >= 49) /*Erroneous info asked */ 589 if (nextinfo - info >= 49) /*Erroneous info asked */
598 continue; 590 continue;
591
599 strncpy (command, &(buf[info]), nextinfo - info); 592 strncpy (command, &(buf[info]), nextinfo - info);
600 command[nextinfo - info] = '\0'; 593
601 /* 2. Interpret info */ 594 /* 2. Interpret info */
602 if (!strcmp ("smooth", command)) 595 if (!strcmp ("smooth", command))
603 {
604 /* Toggle smoothing */ 596 /* Toggle smoothing */
605 ns->EMI_smooth = !ns->EMI_smooth; 597 ns->EMI_smooth = !ns->EMI_smooth;
606 }
607 else 598 else
608 {
609 /*bad value */ 599 /*bad value */;
610 } 600
611 /*3. Next info */ 601 /*3. Next info */
612 } 602 }
603
613 strcpy (cmdback, "ExtendedInfoSet"); 604 strcpy (cmdback, "ExtendedInfoSet");
605
614 if (ns->EMI_smooth) 606 if (ns->EMI_smooth)
615 { 607 {
616 strcat (cmdback, " "); 608 strcat (cmdback, " ");
617 strcat (cmdback, "smoothing"); 609 strcat (cmdback, "smoothing");
618 } 610 }
611
619 Write_String_To_Socket (ns, cmdback, strlen (cmdback)); 612 Write_String_To_Socket (ns, cmdback, strlen (cmdback));
620} 613}
621 614
622/* 615/*
623#define MSG_TYPE_BOOK 1 616#define MSG_TYPE_BOOK 1
… …
635 char temp[10]; 628 char temp[10];
636 char command[50]; 629 char command[50];
637 int info, nextinfo, i, flag; 630 int info, nextinfo, i, flag;
638 631
639 cmdback[0] = '\0'; 632 cmdback[0] = '\0';
633
640 nextinfo = 0; 634 nextinfo = 0;
641 while (1) 635 while (1)
642 { 636 {
643 /* 1. Extract an info */ 637 /* 1. Extract an info */
644 info = nextinfo; 638 info = nextinfo;
639
645 while ((info < len) && (buf[info] == ' ')) 640 while ((info < len) && (buf[info] == ' '))
646 info++; 641 info++;
642
647 if (info >= len) 643 if (info >= len)
648 break; 644 break;
645
649 nextinfo = info + 1; 646 nextinfo = info + 1;
647
650 while ((nextinfo < len) && (buf[nextinfo] != ' ')) 648 while ((nextinfo < len) && (buf[nextinfo] != ' '))
651 nextinfo++; 649 nextinfo++;
650
652 if (nextinfo - info >= 49) /*Erroneous info asked */ 651 if (nextinfo - info >= 49) /*Erroneous info asked */
653 continue; 652 continue;
653
654 strncpy (command, &(buf[info]), nextinfo - info); 654 strncpy (command, &(buf[info]), nextinfo - info);
655 command[nextinfo - info] = '\0'; 655 command[nextinfo - info] = '\0';
656 /* 2. Interpret info */ 656 /* 2. Interpret info */
657 i = sscanf (command, "%d", &flag); 657 i = sscanf (command, "%d", &flag);
658
658 if ((i == 1) && (flag > 0) && (flag <= MSG_TYPE_LAST)) 659 if ((i == 1) && (flag > 0) && (flag <= MSG_TYPE_LAST))
659 ns->supported_readables |= (1 << flag); 660 ns->supported_readables |= (1 << flag);
660 /*3. Next info */ 661 /*3. Next info */
661 } 662 }
663
662 /* Send resulting state */ 664 /* Send resulting state */
663 strcpy (cmdback, "ExtendedTextSet"); 665 strcpy (cmdback, "ExtendedTextSet");
666
664 for (i = 0; i <= MSG_TYPE_LAST; i++) 667 for (i = 0; i <= MSG_TYPE_LAST; i++)
665 if (ns->supported_readables & (1 << i)) 668 if (ns->supported_readables & (1 << i))
666 { 669 {
667 strcat (cmdback, " "); 670 strcat (cmdback, " ");
668 snprintf (temp, sizeof (temp), "%d", i); 671 snprintf (temp, sizeof (temp), "%d", i);
669 strcat (cmdback, temp); 672 strcat (cmdback, temp);
670 } 673 }
674
671 Write_String_To_Socket (ns, cmdback, strlen (cmdback)); 675 Write_String_To_Socket (ns, cmdback, strlen (cmdback));
672} 676}
673 677
674/** 678/**
675 * A lot like the old AskSmooth (in fact, now called by AskSmooth). 679 * A lot like the old AskSmooth (in fact, now called by AskSmooth).
… …
1121 AddIfShort (pl->last_stats.Wis, pl->ob->stats.Wis, CS_STAT_WIS); 1125 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); 1126 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); 1127 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); 1128 AddIfShort (pl->last_stats.Cha, pl->ob->stats.Cha, CS_STAT_CHA);
1125 } 1129 }
1130
1126 if (pl->socket.exp64) 1131 if (pl->socket.exp64)
1127 { 1132 {
1128 uint8 s; 1133 uint8 s;
1129 1134
1130 for (s = 0; s < NUM_SKILLS; s++) 1135 for (s = 0; s < NUM_SKILLS; s++)
… …
1140 SockList_AddInt64 (&sl, pl->last_skill_ob[s]->stats.exp); 1145 SockList_AddInt64 (&sl, pl->last_skill_ob[s]->stats.exp);
1141 pl->last_skill_exp[s] = pl->last_skill_ob[s]->stats.exp; 1146 pl->last_skill_exp[s] = pl->last_skill_ob[s]->stats.exp;
1142 } 1147 }
1143 } 1148 }
1144 } 1149 }
1150
1145 if (pl->socket.exp64) 1151 if (pl->socket.exp64)
1146 {
1147 AddIfInt64 (pl->last_stats.exp, pl->ob->stats.exp, CS_STAT_EXP64); 1152 { AddIfInt64 (pl->last_stats.exp, pl->ob->stats.exp, CS_STAT_EXP64) }
1148 }
1149 else 1153 else
1150 {
1151 AddIfInt (pl->last_stats.exp, (int) pl->ob->stats.exp, CS_STAT_EXP); 1154 { AddIfInt (pl->last_stats.exp, (int) pl->ob->stats.exp, CS_STAT_EXP) }
1152 } 1155
1153 AddIfShort (pl->last_level, (char) pl->ob->level, CS_STAT_LEVEL); 1156 AddIfShort (pl->last_level, (char) pl->ob->level, CS_STAT_LEVEL);
1154 AddIfShort (pl->last_stats.wc, pl->ob->stats.wc, CS_STAT_WC); 1157 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); 1158 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); 1159 AddIfShort (pl->last_stats.dam, pl->ob->stats.dam, CS_STAT_DAM);
1157 AddIfFloat (pl->last_speed, pl->ob->speed, CS_STAT_SPEED); 1160 AddIfFloat (pl->last_speed, pl->ob->speed, CS_STAT_SPEED);
1158 AddIfShort (pl->last_stats.food, pl->ob->stats.food, CS_STAT_FOOD); 1161 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); 1162 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); 1163 AddIfInt (pl->last_weight_limit, (sint32) weight_limit[pl->ob->stats.Str], CS_STAT_WEIGHT_LIM);
1161 flags = 0; 1164 flags = 0;
1165
1162 if (pl->fire_on) 1166 if (pl->fire_on)
1163 flags |= SF_FIREON; 1167 flags |= SF_FIREON;
1168
1164 if (pl->run_on) 1169 if (pl->run_on)
1165 flags |= SF_RUNON; 1170 flags |= SF_RUNON;
1166 1171
1167 AddIfShort (pl->last_flags, flags, CS_STAT_FLAGS); 1172 AddIfShort (pl->last_flags, flags, CS_STAT_FLAGS);
1173
1168 if (pl->socket.sc_version < 1025) 1174 if (pl->socket.sc_version < 1025)
1169 {
1170 AddIfShort (pl->last_resist[ATNR_PHYSICAL], pl->ob->resist[ATNR_PHYSICAL], CS_STAT_ARMOUR); 1175 { AddIfShort (pl->last_resist[ATNR_PHYSICAL], pl->ob->resist[ATNR_PHYSICAL], CS_STAT_ARMOUR) }
1171 }
1172 else 1176 else
1173 { 1177 {
1174 int i; 1178 int i;
1175 1179
1176 for (i = 0; i < NROFATTACKS; i++) 1180 for (i = 0; i < NROFATTACKS; i++)
1177 { 1181 {
1178 /* Skip ones we won't send */ 1182 /* Skip ones we won't send */
1179 if (atnr_cs_stat[i] == -1) 1183 if (atnr_cs_stat[i] == -1)
1180 continue; 1184 continue;
1185
1181 AddIfShort (pl->last_resist[i], pl->ob->resist[i], (char) atnr_cs_stat[i]); 1186 AddIfShort (pl->last_resist[i], pl->ob->resist[i], (char) atnr_cs_stat[i]);
1182 } 1187 }
1183 } 1188 }
1189
1184 if (pl->socket.monitor_spells) 1190 if (pl->socket.monitor_spells)
1185 { 1191 {
1186 AddIfInt (pl->last_path_attuned, pl->ob->path_attuned, CS_STAT_SPELL_ATTUNE); 1192 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); 1193 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); 1194 AddIfInt (pl->last_path_denied, pl->ob->path_denied, CS_STAT_SPELL_DENY);
1189 } 1195 }
1196
1190 rangetostring (pl->ob, buf); /* we want use the new fire & run system in new client */ 1197 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); 1198 AddIfString (pl->socket.stats.range, buf, CS_STAT_RANGE);
1192 set_title (pl->ob, buf); 1199 set_title (pl->ob, buf);
1193 AddIfString (pl->socket.stats.title, buf, CS_STAT_TITLE); 1200 AddIfString (pl->socket.stats.title, buf, CS_STAT_TITLE);
1194 1201
… …
1198#ifdef ESRV_DEBUG 1205#ifdef ESRV_DEBUG
1199 LOG (llevDebug, "Sending stats command, %d bytes long.\n", sl.len); 1206 LOG (llevDebug, "Sending stats command, %d bytes long.\n", sl.len);
1200#endif 1207#endif
1201 Send_With_Handling (&pl->socket, &sl); 1208 Send_With_Handling (&pl->socket, &sl);
1202 } 1209 }
1210
1203 free (sl.buf); 1211 free (sl.buf);
1204} 1212}
1205
1206 1213
1207/** 1214/**
1208 * Tells the client that here is a player it should start using. 1215 * Tells the client that here is a player it should start using.
1209 */ 1216 */
1210void 1217void
… …
1228 1235
1229 Send_With_Handling (&pl->socket, &sl); 1236 Send_With_Handling (&pl->socket, &sl);
1230 free (sl.buf); 1237 free (sl.buf);
1231 SET_FLAG (pl->ob, FLAG_CLIENT_SENT); 1238 SET_FLAG (pl->ob, FLAG_CLIENT_SENT);
1232} 1239}
1233
1234 1240
1235/** 1241/**
1236 * Need to send an animation sequence to the client. 1242 * Need to send an animation sequence to the client.
1237 * We will send appropriate face commands to the client if we haven't 1243 * 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 1244 * sent them the face yet (this can become quite costly in terms of
… …
1426 1432
1427 if (sl.len > (int) strlen ("map ") || ns->sent_scroll) 1433 if (sl.len > (int) strlen ("map ") || ns->sent_scroll)
1428 { 1434 {
1429 /* All of this is just accounting stuff */ 1435 /* All of this is just accounting stuff */
1430 if (tframes > 100) 1436 if (tframes > 100)
1431 {
1432 tframes = tbytes = 0; 1437 tframes = tbytes = 0;
1433 } 1438
1434 tframes++; 1439 tframes++;
1435 frames++; 1440 frames++;
1436 tbytes += sl.len; 1441 tbytes += sl.len;
1437 bytes += sl.len; 1442 bytes += sl.len;
1438 memcpy (&ns->lastmap, newmap, sizeof (struct Map)); 1443 memcpy (&ns->lastmap, newmap, sizeof (struct Map));
1439 Send_With_Handling (ns, &sl); 1444 Send_With_Handling (ns, &sl);
1440 ns->sent_scroll = 0; 1445 ns->sent_scroll = 0;
1441 } 1446 }
1447
1442 free (sl.buf); 1448 free (sl.buf);
1443} 1449}
1444 1450
1445 1451
1446/** Clears a map cell */ 1452/** Clears a map cell */
… …
1448map_clearcell (struct MapCell *cell, int face0, int face1, int face2, int count) 1454map_clearcell (struct MapCell *cell, int face0, int face1, int face2, int count)
1449{ 1455{
1450 cell->faces[0] = face0; 1456 cell->faces[0] = face0;
1451 cell->faces[1] = face1; 1457 cell->faces[1] = face1;
1452 cell->faces[2] = face2; 1458 cell->faces[2] = face2;
1453 cell->count = count; 1459 cell->count = count;
1454 cell->stat_hp = 0; 1460 cell->stat_hp = 0;
1461 cell->flags = 0;
1455 cell->player = 0; 1462 cell->player = 0;
1456} 1463}
1457 1464
1458#define MAX_HEAD_POS MAX(MAX_CLIENT_X, MAX_CLIENT_Y) 1465#define MAX_HEAD_POS MAX(MAX_CLIENT_X, MAX_CLIENT_Y)
1459#define MAX_LAYERS 3 1466#define MAX_LAYERS 3
1460 1467
… …
1531 * the case, it seems to make more sense to have these layer values 1538 * the case, it seems to make more sense to have these layer values
1532 * actually match. 1539 * actually match.
1533 */ 1540 */
1534 1541
1535static int 1542static int
1536update_space (SockList * sl, NewSocket * ns, mapstruct *mp, int mx, int my, int sx, int sy, int layer) 1543update_space (SockList * sl, NewSocket * ns, maptile *mp, int mx, int my, int sx, int sy, int layer)
1537{ 1544{
1538 object *ob, *head; 1545 object *ob, *head;
1539 uint16 face_num; 1546 uint16 face_num;
1540 int bx, by, i; 1547 int bx, by, i;
1541 1548
… …
1755 * top layer (this matches what the GET_MAP_FACE and GET_MAP_FACE_OBJ 1762 * top layer (this matches what the GET_MAP_FACE and GET_MAP_FACE_OBJ
1756 * take. 1763 * take.
1757 */ 1764 */
1758 1765
1759static inline int 1766static inline int
1760update_smooth (SockList * sl, NewSocket * ns, mapstruct *mp, int mx, int my, int sx, int sy, int layer) 1767update_smooth (SockList * sl, NewSocket * ns, maptile *mp, int mx, int my, int sx, int sy, int layer)
1761{ 1768{
1762 object *ob; 1769 object *ob;
1763 int smoothlevel; /* old face_num; */ 1770 int smoothlevel; /* old face_num; */
1764 1771
1765 ob = GET_MAP_FACE_OBJ (mp, mx, my, layer); 1772 ob = GET_MAP_FACE_OBJ (mp, mx, my, layer);
… …
1843 SockList esl; /*For extended Map info */ 1850 SockList esl; /*For extended Map info */
1844 uint16 mask, emask; 1851 uint16 mask, emask;
1845 uint8 eentrysize; 1852 uint8 eentrysize;
1846 uint16 ewhatstart, ewhatflag; 1853 uint16 ewhatstart, ewhatflag;
1847 uint8 extendedinfos; 1854 uint8 extendedinfos;
1848 mapstruct *m; 1855 maptile *m;
1849 1856
1850 NewSocket & socket = pl->contr->socket; 1857 NewSocket & socket = pl->contr->socket;
1851 1858
1852 check_map_change (pl->contr); 1859 check_map_change (pl->contr);
1853 1860
… …
1856 strcpy ((char *) sl.buf, "map1 "); 1863 strcpy ((char *) sl.buf, "map1 ");
1857 else 1864 else
1858 strcpy ((char *) sl.buf, "map1a "); 1865 strcpy ((char *) sl.buf, "map1a ");
1859 sl.len = strlen ((char *) sl.buf); 1866 sl.len = strlen ((char *) sl.buf);
1860 startlen = sl.len; 1867 startlen = sl.len;
1868
1861 /*Extendedmapinfo structure initialisation */ 1869 /*Extendedmapinfo structure initialisation */
1862 if (socket.ext_mapinfos) 1870 if (socket.ext_mapinfos)
1863 { 1871 {
1864 esl.buf = (unsigned char *) malloc (MAXSOCKBUF); 1872 esl.buf = (unsigned char *) malloc (MAXSOCKBUF);
1865 strcpy ((char *) esl.buf, "mapextended "); 1873 strcpy ((char *) esl.buf, "mapextended ");
1866 esl.len = strlen ((char *) esl.buf); 1874 esl.len = strlen ((char *) esl.buf);
1867 extendedinfos = EMI_NOREDRAW; 1875 extendedinfos = EMI_NOREDRAW;
1876
1868 if (socket.EMI_smooth) 1877 if (socket.EMI_smooth)
1869 extendedinfos |= EMI_SMOOTH; 1878 extendedinfos |= EMI_SMOOTH;
1879
1870 ewhatstart = esl.len; 1880 ewhatstart = esl.len;
1871 ewhatflag = extendedinfos; /*The EMI_NOREDRAW bit 1881 ewhatflag = extendedinfos; /*The EMI_NOREDRAW bit
1872 could need to be taken away */ 1882 could need to be taken away */
1873 SockList_AddChar (&esl, extendedinfos); 1883 SockList_AddChar (&esl, extendedinfos);
1874 eentrysize = getExtendedMapInfoSize (&socket); 1884 eentrysize = getExtendedMapInfoSize (&socket);
… …
1880 /* suppress compiler warnings */ 1890 /* suppress compiler warnings */
1881 ewhatstart = 0; 1891 ewhatstart = 0;
1882 ewhatflag = 0; 1892 ewhatflag = 0;
1883 estartlen = 0; 1893 estartlen = 0;
1884 } 1894 }
1895
1885 /* Init data to zero */ 1896 /* Init data to zero */
1886 memset (heads, 0, sizeof (object *) * MAX_HEAD_POS * MAX_HEAD_POS * MAX_LAYERS); 1897 memset (heads, 0, sizeof (object *) * MAX_HEAD_POS * MAX_HEAD_POS * MAX_LAYERS);
1887 1898
1888 /* x,y are the real map locations. ax, ay are viewport relative 1899 /* x,y are the real map locations. ax, ay are viewport relative
1889 * locations. 1900 * locations.
… …
1893 /* We could do this logic as conditionals in the if statement, 1904 /* We could do this logic as conditionals in the if statement,
1894 * but that started to get a bit messy to look at. 1905 * but that started to get a bit messy to look at.
1895 */ 1906 */
1896 max_x = pl->x + (socket.mapx + 1) / 2; 1907 max_x = pl->x + (socket.mapx + 1) / 2;
1897 max_y = pl->y + (socket.mapy + 1) / 2; 1908 max_y = pl->y + (socket.mapy + 1) / 2;
1909
1898 if (socket.mapmode == Map1aCmd) 1910 if (socket.mapmode == Map1aCmd)
1899 { 1911 {
1900 max_x += MAX_HEAD_OFFSET; 1912 max_x += MAX_HEAD_OFFSET;
1901 max_y += MAX_HEAD_OFFSET; 1913 max_y += MAX_HEAD_OFFSET;
1902 } 1914 }
… …
1935 * with no faces tells the client to blank out the 1947 * with no faces tells the client to blank out the
1936 * space. 1948 * space.
1937 */ 1949 */
1938 got_one = 0; 1950 got_one = 0;
1939 for (i = oldlen + 2; i < sl.len; i++) 1951 for (i = oldlen + 2; i < sl.len; i++)
1940 {
1941 if (sl.buf[i]) 1952 if (sl.buf[i])
1942 got_one = 1; 1953 got_one = 1;
1943 }
1944 1954
1945 if (got_one && (mask & 0xf)) 1955 if (got_one && (mask & 0xf))
1946 {
1947 sl.buf[oldlen + 1] = mask & 0xff; 1956 sl.buf[oldlen + 1] = mask & 0xff;
1948 }
1949 else 1957 else
1950 { /*either all faces blank, either no face at all */ 1958 { /*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 */ 1959 if (mask & 0xf) /*at least 1 face, we know it's blank, only send coordinates */
1952 sl.len = oldlen + 2; 1960 sl.len = oldlen + 2;
1953 else 1961 else
1954 sl.len = oldlen; 1962 sl.len = oldlen;
1955 } 1963 }
1964
1956 /*What concerns extendinfos, nothing to be done for now 1965 /*What concerns extendinfos, nothing to be done for now
1957 * (perhaps effects layer later) 1966 * (perhaps effects layer later)
1958 */ 1967 */
1959 continue; /* don't do processing below */ 1968 continue; /* don't do processing below */
1960 } 1969 }
1961 1970
1962 MapCell & lastcell = socket.lastmap.cells[ax][ay]; 1971 MapCell &lastcell = socket.lastmap.cells[ax][ay];
1963 1972
1964 d = pl->contr->blocked_los[ax][ay]; 1973 d = pl->contr->blocked_los[ax][ay];
1965 1974
1966 /* If the coordinates are not valid, or it is too dark to see, 1975 /* If the coordinates are not valid, or it is too dark to see,
1967 * we tell the client as such 1976 * we tell the client as such
1968 */ 1977 */
1969 nx = x; 1978 nx = x;
1970 ny = y; 1979 ny = y;
1971 m = get_map_from_coord (pl->map, &nx, &ny); 1980 m = get_map_from_coord (pl->map, &nx, &ny);
1981
1972 if (!m) 1982 if (!m)
1973 { 1983 {
1974 /* space is out of map. Update space and clear values 1984 /* space is out of map. Update space and clear values
1975 * if this hasn't already been done. If the space is out 1985 * if this hasn't already been done. If the space is out
1976 * of the map, it shouldn't have a head 1986 * of the map, it shouldn't have a head
… …
1990 */ 2000 */
1991 2001
1992 oldlen = sl.len; 2002 oldlen = sl.len;
1993 2003
1994 SockList_AddShort (&sl, mask); 2004 SockList_AddShort (&sl, mask);
2005
1995 if (lastcell.count != -1) 2006 if (lastcell.count != -1)
1996 need_send = 1; 2007 need_send = 1;
2008
1997 count = -1; 2009 count = -1;
1998 2010
1999 if (socket.mapmode == Map1aCmd && have_head (ax, ay)) 2011 if (socket.mapmode == Map1aCmd && have_head (ax, ay))
2000 { 2012 {
2001 /* Now check to see if any heads need to be sent */ 2013 /* Now check to see if any heads need to be sent */
… …
2006 mask |= 0x2; 2018 mask |= 0x2;
2007 if (check_head (sl, socket, ax, ay, 0)) 2019 if (check_head (sl, socket, ax, ay, 0))
2008 mask |= 0x1; 2020 mask |= 0x1;
2009 2021
2010 lastcell.count = count; 2022 lastcell.count = count;
2011
2012 } 2023 }
2013 else 2024 else
2014 { 2025 {
2015 struct MapCell *cell = &lastcell;
2016
2017 /* properly clear a previously sent big face */ 2026 /* properly clear a previously sent big face */
2018 if (cell->faces[0] != 0 || cell->faces[1] != 0 || cell->faces[2] != 0) 2027 if (lastcell.faces[0] != 0 || lastcell.faces[1] != 0 || lastcell.faces[2] != 0
2028 || lastcell.stat_hp || lastcell.flags || lastcell.player)
2019 need_send = 1; 2029 need_send = 1;
2030
2020 map_clearcell (&lastcell, 0, 0, 0, count); 2031 map_clearcell (&lastcell, 0, 0, 0, count);
2021 } 2032 }
2022 2033
2023 if ((mask & 0xf) || need_send) 2034 if ((mask & 0xf) || need_send)
2024 {
2025 sl.buf[oldlen + 1] = mask & 0xff; 2035 sl.buf[oldlen + 1] = mask & 0xff;
2026 }
2027 else 2036 else
2028 {
2029 sl.len = oldlen; 2037 sl.len = oldlen;
2030 }
2031 } 2038 }
2032 else 2039 else
2033 { 2040 {
2034 /* In this block, the space is visible or there are head objects 2041 /* In this block, the space is visible or there are head objects
2035 * we need to send. 2042 * we need to send.
… …
2076 2083
2077 if (socket.extmap) 2084 if (socket.extmap)
2078 { 2085 {
2079 uint8 stat_hp = 0; 2086 uint8 stat_hp = 0;
2080 uint8 stat_width = 0; 2087 uint8 stat_width = 0;
2088 uint8 flags = 0;
2081 tag_t player = 0; 2089 tag_t player = 0;
2082 2090
2083 // send hp information, if applicable 2091 // send hp information, if applicable
2084 if (object *op = GET_MAP_FACE_OBJ (m, nx, ny, 0)) 2092 if (object *op = GET_MAP_FACE_OBJ (m, nx, ny, 0))
2085 { 2093 {
… …
2093 stat_hp = 255 - (op->stats.hp * 255 + 254) / op->stats.maxhp; 2101 stat_hp = 255 - (op->stats.hp * 255 + 254) / op->stats.maxhp;
2094 stat_width = op->arch->tail_x; 2102 stat_width = op->arch->tail_x;
2095 } 2103 }
2096 } 2104 }
2097 2105
2106 if (op->msg && op->msg[0] == '@')
2107 flags |= 1;
2108
2098 if (op->type == PLAYER && op != pl) 2109 if (op->type == PLAYER && op != pl)
2099 player = op->count; 2110 player = op->count;
2100 } 2111 }
2101 2112
2102 if (lastcell.stat_hp != stat_hp) 2113 if (lastcell.stat_hp != stat_hp)
… …
2116 SockList_AddChar (&sl, 6); 2127 SockList_AddChar (&sl, 6);
2117 SockList_AddChar (&sl, stat_width); 2128 SockList_AddChar (&sl, stat_width);
2118 } 2129 }
2119 } 2130 }
2120 2131
2121 if (lastcell.player !=player) 2132 if (lastcell.player != player)
2122 { 2133 {
2123 lastcell.player = player; 2134 lastcell.player = player;
2124 2135
2125 mask |= 0x8; 2136 mask |= 0x8;
2126 *last_ext |= 0x80; 2137 *last_ext |= 0x80;
2127 last_ext = sl.buf + sl.len; 2138 last_ext = sl.buf + sl.len;
2128 SockList_AddChar (&sl, 0x47); 2139 SockList_AddChar (&sl, 0x47);
2129 SockList_AddChar (&sl, 4); 2140 SockList_AddChar (&sl, 4);
2130 SockList_AddInt (&sl, player); 2141 SockList_AddInt (&sl, player);
2131 } 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 SockList_AddChar (&sl, 8);
2152 SockList_AddChar (&sl, flags);
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))
2136 mask |= 0x4; 2158 mask |= 0x4;
… …
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);
2181
2158 SockList_AddShort (&sl, pl->face->number); 2182 SockList_AddShort (&sl, 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;

Diff Legend

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