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.17 by root, Tue Sep 12 19:20:09 2006 UTC vs.
Revision 1.26 by pippijn, Mon Dec 11 19:46:47 2006 UTC

1
2/*
3 * static char *rcsid_init_c =
4 * "$Id: request.C,v 1.17 2006/09/12 19:20:09 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
… …
1139 AddIfShort (pl->last_stats.Wis, pl->ob->stats.Wis, CS_STAT_WIS); 1123 AddIfShort (pl->last_stats.Wis, pl->ob->stats.Wis, CS_STAT_WIS);
1140 AddIfShort (pl->last_stats.Dex, pl->ob->stats.Dex, CS_STAT_DEX); 1124 AddIfShort (pl->last_stats.Dex, pl->ob->stats.Dex, CS_STAT_DEX);
1141 AddIfShort (pl->last_stats.Con, pl->ob->stats.Con, CS_STAT_CON); 1125 AddIfShort (pl->last_stats.Con, pl->ob->stats.Con, CS_STAT_CON);
1142 AddIfShort (pl->last_stats.Cha, pl->ob->stats.Cha, CS_STAT_CHA); 1126 AddIfShort (pl->last_stats.Cha, pl->ob->stats.Cha, CS_STAT_CHA);
1143 } 1127 }
1128
1144 if (pl->socket.exp64) 1129 if (pl->socket.exp64)
1145 { 1130 {
1146 uint8 s; 1131 uint8 s;
1147 1132
1148 for (s = 0; s < NUM_SKILLS; s++) 1133 for (s = 0; s < NUM_SKILLS; s++)
… …
1158 SockList_AddInt64 (&sl, pl->last_skill_ob[s]->stats.exp); 1143 SockList_AddInt64 (&sl, pl->last_skill_ob[s]->stats.exp);
1159 pl->last_skill_exp[s] = pl->last_skill_ob[s]->stats.exp; 1144 pl->last_skill_exp[s] = pl->last_skill_ob[s]->stats.exp;
1160 } 1145 }
1161 } 1146 }
1162 } 1147 }
1148
1163 if (pl->socket.exp64) 1149 if (pl->socket.exp64)
1164 {
1165 AddIfInt64 (pl->last_stats.exp, pl->ob->stats.exp, CS_STAT_EXP64); 1150 { AddIfInt64 (pl->last_stats.exp, pl->ob->stats.exp, CS_STAT_EXP64) }
1166 }
1167 else 1151 else
1168 {
1169 AddIfInt (pl->last_stats.exp, (int) pl->ob->stats.exp, CS_STAT_EXP); 1152 { AddIfInt (pl->last_stats.exp, (int) pl->ob->stats.exp, CS_STAT_EXP) }
1170 } 1153
1171 AddIfShort (pl->last_level, (char) pl->ob->level, CS_STAT_LEVEL); 1154 AddIfShort (pl->last_level, (char) pl->ob->level, CS_STAT_LEVEL);
1172 AddIfShort (pl->last_stats.wc, pl->ob->stats.wc, CS_STAT_WC); 1155 AddIfShort (pl->last_stats.wc, pl->ob->stats.wc, CS_STAT_WC);
1173 AddIfShort (pl->last_stats.ac, pl->ob->stats.ac, CS_STAT_AC); 1156 AddIfShort (pl->last_stats.ac, pl->ob->stats.ac, CS_STAT_AC);
1174 AddIfShort (pl->last_stats.dam, pl->ob->stats.dam, CS_STAT_DAM); 1157 AddIfShort (pl->last_stats.dam, pl->ob->stats.dam, CS_STAT_DAM);
1175 AddIfFloat (pl->last_speed, pl->ob->speed, CS_STAT_SPEED); 1158 AddIfFloat (pl->last_speed, pl->ob->speed, CS_STAT_SPEED);
1176 AddIfShort (pl->last_stats.food, pl->ob->stats.food, CS_STAT_FOOD); 1159 AddIfShort (pl->last_stats.food, pl->ob->stats.food, CS_STAT_FOOD);
1177 AddIfFloat (pl->last_weapon_sp, pl->weapon_sp, CS_STAT_WEAP_SP); 1160 AddIfFloat (pl->last_weapon_sp, pl->weapon_sp, CS_STAT_WEAP_SP);
1178 AddIfInt (pl->last_weight_limit, (sint32) weight_limit[pl->ob->stats.Str], CS_STAT_WEIGHT_LIM); 1161 AddIfInt (pl->last_weight_limit, (sint32) weight_limit[pl->ob->stats.Str], CS_STAT_WEIGHT_LIM);
1179 flags = 0; 1162 flags = 0;
1163
1180 if (pl->fire_on) 1164 if (pl->fire_on)
1181 flags |= SF_FIREON; 1165 flags |= SF_FIREON;
1166
1182 if (pl->run_on) 1167 if (pl->run_on)
1183 flags |= SF_RUNON; 1168 flags |= SF_RUNON;
1184 1169
1185 AddIfShort (pl->last_flags, flags, CS_STAT_FLAGS); 1170 AddIfShort (pl->last_flags, flags, CS_STAT_FLAGS);
1171
1186 if (pl->socket.sc_version < 1025) 1172 if (pl->socket.sc_version < 1025)
1187 {
1188 AddIfShort (pl->last_resist[ATNR_PHYSICAL], pl->ob->resist[ATNR_PHYSICAL], CS_STAT_ARMOUR); 1173 { AddIfShort (pl->last_resist[ATNR_PHYSICAL], pl->ob->resist[ATNR_PHYSICAL], CS_STAT_ARMOUR) }
1189 }
1190 else 1174 else
1191 { 1175 {
1192 int i; 1176 int i;
1193 1177
1194 for (i = 0; i < NROFATTACKS; i++) 1178 for (i = 0; i < NROFATTACKS; i++)
1195 { 1179 {
1196 /* Skip ones we won't send */ 1180 /* Skip ones we won't send */
1197 if (atnr_cs_stat[i] == -1) 1181 if (atnr_cs_stat[i] == -1)
1198 continue; 1182 continue;
1183
1199 AddIfShort (pl->last_resist[i], pl->ob->resist[i], (char) atnr_cs_stat[i]); 1184 AddIfShort (pl->last_resist[i], pl->ob->resist[i], (char) atnr_cs_stat[i]);
1200 } 1185 }
1201 } 1186 }
1187
1202 if (pl->socket.monitor_spells) 1188 if (pl->socket.monitor_spells)
1203 { 1189 {
1204 AddIfInt (pl->last_path_attuned, pl->ob->path_attuned, CS_STAT_SPELL_ATTUNE); 1190 AddIfInt (pl->last_path_attuned, pl->ob->path_attuned, CS_STAT_SPELL_ATTUNE);
1205 AddIfInt (pl->last_path_repelled, pl->ob->path_repelled, CS_STAT_SPELL_REPEL); 1191 AddIfInt (pl->last_path_repelled, pl->ob->path_repelled, CS_STAT_SPELL_REPEL);
1206 AddIfInt (pl->last_path_denied, pl->ob->path_denied, CS_STAT_SPELL_DENY); 1192 AddIfInt (pl->last_path_denied, pl->ob->path_denied, CS_STAT_SPELL_DENY);
1207 } 1193 }
1194
1208 rangetostring (pl->ob, buf); /* we want use the new fire & run system in new client */ 1195 rangetostring (pl->ob, buf); /* we want use the new fire & run system in new client */
1209 AddIfString (pl->socket.stats.range, buf, CS_STAT_RANGE); 1196 AddIfString (pl->socket.stats.range, buf, CS_STAT_RANGE);
1210 set_title (pl->ob, buf); 1197 set_title (pl->ob, buf);
1211 AddIfString (pl->socket.stats.title, buf, CS_STAT_TITLE); 1198 AddIfString (pl->socket.stats.title, buf, CS_STAT_TITLE);
1212 1199
… …
1216#ifdef ESRV_DEBUG 1203#ifdef ESRV_DEBUG
1217 LOG (llevDebug, "Sending stats command, %d bytes long.\n", sl.len); 1204 LOG (llevDebug, "Sending stats command, %d bytes long.\n", sl.len);
1218#endif 1205#endif
1219 Send_With_Handling (&pl->socket, &sl); 1206 Send_With_Handling (&pl->socket, &sl);
1220 } 1207 }
1208
1221 free (sl.buf); 1209 free (sl.buf);
1222} 1210}
1223
1224 1211
1225/** 1212/**
1226 * Tells the client that here is a player it should start using. 1213 * Tells the client that here is a player it should start using.
1227 */ 1214 */
1228void 1215void
… …
1246 1233
1247 Send_With_Handling (&pl->socket, &sl); 1234 Send_With_Handling (&pl->socket, &sl);
1248 free (sl.buf); 1235 free (sl.buf);
1249 SET_FLAG (pl->ob, FLAG_CLIENT_SENT); 1236 SET_FLAG (pl->ob, FLAG_CLIENT_SENT);
1250} 1237}
1251
1252 1238
1253/** 1239/**
1254 * Need to send an animation sequence to the client. 1240 * Need to send an animation sequence to the client.
1255 * We will send appropriate face commands to the client if we haven't 1241 * We will send appropriate face commands to the client if we haven't
1256 * sent them the face yet (this can become quite costly in terms of 1242 * sent them the face yet (this can become quite costly in terms of
… …
1444 1430
1445 if (sl.len > (int) strlen ("map ") || ns->sent_scroll) 1431 if (sl.len > (int) strlen ("map ") || ns->sent_scroll)
1446 { 1432 {
1447 /* All of this is just accounting stuff */ 1433 /* All of this is just accounting stuff */
1448 if (tframes > 100) 1434 if (tframes > 100)
1449 {
1450 tframes = tbytes = 0; 1435 tframes = tbytes = 0;
1451 } 1436
1452 tframes++; 1437 tframes++;
1453 frames++; 1438 frames++;
1454 tbytes += sl.len; 1439 tbytes += sl.len;
1455 bytes += sl.len; 1440 bytes += sl.len;
1456 memcpy (&ns->lastmap, newmap, sizeof (struct Map)); 1441 memcpy (&ns->lastmap, newmap, sizeof (struct Map));
1457 Send_With_Handling (ns, &sl); 1442 Send_With_Handling (ns, &sl);
1458 ns->sent_scroll = 0; 1443 ns->sent_scroll = 0;
1459 } 1444 }
1445
1460 free (sl.buf); 1446 free (sl.buf);
1461} 1447}
1462 1448
1463 1449
1464/** Clears a map cell */ 1450/** Clears a map cell */
… …
1466map_clearcell (struct MapCell *cell, int face0, int face1, int face2, int count) 1452map_clearcell (struct MapCell *cell, int face0, int face1, int face2, int count)
1467{ 1453{
1468 cell->faces[0] = face0; 1454 cell->faces[0] = face0;
1469 cell->faces[1] = face1; 1455 cell->faces[1] = face1;
1470 cell->faces[2] = face2; 1456 cell->faces[2] = face2;
1471 cell->count = count; 1457 cell->count = count;
1472 cell->stat_hp = 0; 1458 cell->stat_hp = 0;
1459 cell->flags = 0;
1473 cell->player = 0; 1460 cell->player = 0;
1474} 1461}
1475 1462
1476#define MAX_HEAD_POS MAX(MAX_CLIENT_X, MAX_CLIENT_Y) 1463#define MAX_HEAD_POS MAX(MAX_CLIENT_X, MAX_CLIENT_Y)
1477#define MAX_LAYERS 3 1464#define MAX_LAYERS 3
1478 1465
… …
1549 * the case, it seems to make more sense to have these layer values 1536 * the case, it seems to make more sense to have these layer values
1550 * actually match. 1537 * actually match.
1551 */ 1538 */
1552 1539
1553static int 1540static int
1554update_space (SockList * sl, NewSocket * ns, mapstruct *mp, int mx, int my, int sx, int sy, int layer) 1541update_space (SockList * sl, NewSocket * ns, maptile *mp, int mx, int my, int sx, int sy, int layer)
1555{ 1542{
1556 object *ob, *head; 1543 object *ob, *head;
1557 uint16 face_num; 1544 uint16 face_num;
1558 int bx, by, i; 1545 int bx, by, i;
1559 1546
… …
1773 * top layer (this matches what the GET_MAP_FACE and GET_MAP_FACE_OBJ 1760 * top layer (this matches what the GET_MAP_FACE and GET_MAP_FACE_OBJ
1774 * take. 1761 * take.
1775 */ 1762 */
1776 1763
1777static inline int 1764static inline int
1778update_smooth (SockList * sl, NewSocket * ns, mapstruct *mp, int mx, int my, int sx, int sy, int layer) 1765update_smooth (SockList * sl, NewSocket * ns, maptile *mp, int mx, int my, int sx, int sy, int layer)
1779{ 1766{
1780 object *ob; 1767 object *ob;
1781 int smoothlevel; /* old face_num; */ 1768 int smoothlevel; /* old face_num; */
1782 1769
1783 ob = GET_MAP_FACE_OBJ (mp, mx, my, layer); 1770 ob = GET_MAP_FACE_OBJ (mp, mx, my, layer);
… …
1861 SockList esl; /*For extended Map info */ 1848 SockList esl; /*For extended Map info */
1862 uint16 mask, emask; 1849 uint16 mask, emask;
1863 uint8 eentrysize; 1850 uint8 eentrysize;
1864 uint16 ewhatstart, ewhatflag; 1851 uint16 ewhatstart, ewhatflag;
1865 uint8 extendedinfos; 1852 uint8 extendedinfos;
1866 mapstruct *m; 1853 maptile *m;
1867 1854
1868 NewSocket & socket = pl->contr->socket; 1855 NewSocket & socket = pl->contr->socket;
1869 1856
1870 check_map_change (pl->contr); 1857 check_map_change (pl->contr);
1871 1858
… …
1874 strcpy ((char *) sl.buf, "map1 "); 1861 strcpy ((char *) sl.buf, "map1 ");
1875 else 1862 else
1876 strcpy ((char *) sl.buf, "map1a "); 1863 strcpy ((char *) sl.buf, "map1a ");
1877 sl.len = strlen ((char *) sl.buf); 1864 sl.len = strlen ((char *) sl.buf);
1878 startlen = sl.len; 1865 startlen = sl.len;
1866
1879 /*Extendedmapinfo structure initialisation */ 1867 /*Extendedmapinfo structure initialisation */
1880 if (socket.ext_mapinfos) 1868 if (socket.ext_mapinfos)
1881 { 1869 {
1882 esl.buf = (unsigned char *) malloc (MAXSOCKBUF); 1870 esl.buf = (unsigned char *) malloc (MAXSOCKBUF);
1883 strcpy ((char *) esl.buf, "mapextended "); 1871 strcpy ((char *) esl.buf, "mapextended ");
1884 esl.len = strlen ((char *) esl.buf); 1872 esl.len = strlen ((char *) esl.buf);
1885 extendedinfos = EMI_NOREDRAW; 1873 extendedinfos = EMI_NOREDRAW;
1874
1886 if (socket.EMI_smooth) 1875 if (socket.EMI_smooth)
1887 extendedinfos |= EMI_SMOOTH; 1876 extendedinfos |= EMI_SMOOTH;
1877
1888 ewhatstart = esl.len; 1878 ewhatstart = esl.len;
1889 ewhatflag = extendedinfos; /*The EMI_NOREDRAW bit 1879 ewhatflag = extendedinfos; /*The EMI_NOREDRAW bit
1890 could need to be taken away */ 1880 could need to be taken away */
1891 SockList_AddChar (&esl, extendedinfos); 1881 SockList_AddChar (&esl, extendedinfos);
1892 eentrysize = getExtendedMapInfoSize (&socket); 1882 eentrysize = getExtendedMapInfoSize (&socket);
… …
1898 /* suppress compiler warnings */ 1888 /* suppress compiler warnings */
1899 ewhatstart = 0; 1889 ewhatstart = 0;
1900 ewhatflag = 0; 1890 ewhatflag = 0;
1901 estartlen = 0; 1891 estartlen = 0;
1902 } 1892 }
1893
1903 /* Init data to zero */ 1894 /* Init data to zero */
1904 memset (heads, 0, sizeof (object *) * MAX_HEAD_POS * MAX_HEAD_POS * MAX_LAYERS); 1895 memset (heads, 0, sizeof (object *) * MAX_HEAD_POS * MAX_HEAD_POS * MAX_LAYERS);
1905 1896
1906 /* x,y are the real map locations. ax, ay are viewport relative 1897 /* x,y are the real map locations. ax, ay are viewport relative
1907 * locations. 1898 * locations.
… …
1911 /* We could do this logic as conditionals in the if statement, 1902 /* We could do this logic as conditionals in the if statement,
1912 * but that started to get a bit messy to look at. 1903 * but that started to get a bit messy to look at.
1913 */ 1904 */
1914 max_x = pl->x + (socket.mapx + 1) / 2; 1905 max_x = pl->x + (socket.mapx + 1) / 2;
1915 max_y = pl->y + (socket.mapy + 1) / 2; 1906 max_y = pl->y + (socket.mapy + 1) / 2;
1907
1916 if (socket.mapmode == Map1aCmd) 1908 if (socket.mapmode == Map1aCmd)
1917 { 1909 {
1918 max_x += MAX_HEAD_OFFSET; 1910 max_x += MAX_HEAD_OFFSET;
1919 max_y += MAX_HEAD_OFFSET; 1911 max_y += MAX_HEAD_OFFSET;
1920 } 1912 }
… …
1953 * with no faces tells the client to blank out the 1945 * with no faces tells the client to blank out the
1954 * space. 1946 * space.
1955 */ 1947 */
1956 got_one = 0; 1948 got_one = 0;
1957 for (i = oldlen + 2; i < sl.len; i++) 1949 for (i = oldlen + 2; i < sl.len; i++)
1958 {
1959 if (sl.buf[i]) 1950 if (sl.buf[i])
1960 got_one = 1; 1951 got_one = 1;
1961 }
1962 1952
1963 if (got_one && (mask & 0xf)) 1953 if (got_one && (mask & 0xf))
1964 {
1965 sl.buf[oldlen + 1] = mask & 0xff; 1954 sl.buf[oldlen + 1] = mask & 0xff;
1966 }
1967 else 1955 else
1968 { /*either all faces blank, either no face at all */ 1956 { /*either all faces blank, either no face at all */
1969 if (mask & 0xf) /*at least 1 face, we know it's blank, only send coordinates */ 1957 if (mask & 0xf) /*at least 1 face, we know it's blank, only send coordinates */
1970 sl.len = oldlen + 2; 1958 sl.len = oldlen + 2;
1971 else 1959 else
1972 sl.len = oldlen; 1960 sl.len = oldlen;
1973 } 1961 }
1962
1974 /*What concerns extendinfos, nothing to be done for now 1963 /*What concerns extendinfos, nothing to be done for now
1975 * (perhaps effects layer later) 1964 * (perhaps effects layer later)
1976 */ 1965 */
1977 continue; /* don't do processing below */ 1966 continue; /* don't do processing below */
1978 } 1967 }
1979 1968
1980 MapCell & lastcell = socket.lastmap.cells[ax][ay]; 1969 MapCell &lastcell = socket.lastmap.cells[ax][ay];
1981 1970
1982 d = pl->contr->blocked_los[ax][ay]; 1971 d = pl->contr->blocked_los[ax][ay];
1983 1972
1984 /* If the coordinates are not valid, or it is too dark to see, 1973 /* If the coordinates are not valid, or it is too dark to see,
1985 * we tell the client as such 1974 * we tell the client as such
1986 */ 1975 */
1987 nx = x; 1976 nx = x;
1988 ny = y; 1977 ny = y;
1989 m = get_map_from_coord (pl->map, &nx, &ny); 1978 m = get_map_from_coord (pl->map, &nx, &ny);
1979
1990 if (!m) 1980 if (!m)
1991 { 1981 {
1992 /* space is out of map. Update space and clear values 1982 /* space is out of map. Update space and clear values
1993 * if this hasn't already been done. If the space is out 1983 * if this hasn't already been done. If the space is out
1994 * of the map, it shouldn't have a head 1984 * of the map, it shouldn't have a head
… …
2008 */ 1998 */
2009 1999
2010 oldlen = sl.len; 2000 oldlen = sl.len;
2011 2001
2012 SockList_AddShort (&sl, mask); 2002 SockList_AddShort (&sl, mask);
2003
2013 if (lastcell.count != -1) 2004 if (lastcell.count != -1)
2014 need_send = 1; 2005 need_send = 1;
2006
2015 count = -1; 2007 count = -1;
2016 2008
2017 if (socket.mapmode == Map1aCmd && have_head (ax, ay)) 2009 if (socket.mapmode == Map1aCmd && have_head (ax, ay))
2018 { 2010 {
2019 /* Now check to see if any heads need to be sent */ 2011 /* Now check to see if any heads need to be sent */
… …
2024 mask |= 0x2; 2016 mask |= 0x2;
2025 if (check_head (sl, socket, ax, ay, 0)) 2017 if (check_head (sl, socket, ax, ay, 0))
2026 mask |= 0x1; 2018 mask |= 0x1;
2027 2019
2028 lastcell.count = count; 2020 lastcell.count = count;
2029
2030 } 2021 }
2031 else 2022 else
2032 { 2023 {
2033 struct MapCell *cell = &lastcell;
2034
2035 /* properly clear a previously sent big face */ 2024 /* properly clear a previously sent big face */
2036 if (cell->faces[0] != 0 || cell->faces[1] != 0 || cell->faces[2] != 0) 2025 if (lastcell.faces[0] != 0 || lastcell.faces[1] != 0 || lastcell.faces[2] != 0
2026 || lastcell.stat_hp || lastcell.flags || lastcell.player)
2037 need_send = 1; 2027 need_send = 1;
2028
2038 map_clearcell (&lastcell, 0, 0, 0, count); 2029 map_clearcell (&lastcell, 0, 0, 0, count);
2039 } 2030 }
2040 2031
2041 if ((mask & 0xf) || need_send) 2032 if ((mask & 0xf) || need_send)
2042 {
2043 sl.buf[oldlen + 1] = mask & 0xff; 2033 sl.buf[oldlen + 1] = mask & 0xff;
2044 }
2045 else 2034 else
2046 {
2047 sl.len = oldlen; 2035 sl.len = oldlen;
2048 }
2049 } 2036 }
2050 else 2037 else
2051 { 2038 {
2052 /* In this block, the space is visible or there are head objects 2039 /* In this block, the space is visible or there are head objects
2053 * we need to send. 2040 * we need to send.
… …
2094 2081
2095 if (socket.extmap) 2082 if (socket.extmap)
2096 { 2083 {
2097 uint8 stat_hp = 0; 2084 uint8 stat_hp = 0;
2098 uint8 stat_width = 0; 2085 uint8 stat_width = 0;
2086 uint8 flags = 0;
2099 tag_t player = 0; 2087 tag_t player = 0;
2100 2088
2101 // send hp information, if applicable 2089 // send hp information, if applicable
2102 if (object *op = GET_MAP_FACE_OBJ (m, nx, ny, 0)) 2090 if (object *op = GET_MAP_FACE_OBJ (m, nx, ny, 0))
2103 { 2091 {
… …
2111 stat_hp = 255 - (op->stats.hp * 255 + 254) / op->stats.maxhp; 2099 stat_hp = 255 - (op->stats.hp * 255 + 254) / op->stats.maxhp;
2112 stat_width = op->arch->tail_x; 2100 stat_width = op->arch->tail_x;
2113 } 2101 }
2114 } 2102 }
2115 2103
2104 if (op->msg && op->msg[0] == '@')
2105 flags |= 1;
2106
2116 if (op->type == PLAYER && op != pl) 2107 if (op->type == PLAYER && op != pl)
2117 player = op->count; 2108 player = op->count;
2118 } 2109 }
2119 2110
2120 if (lastcell.stat_hp != stat_hp) 2111 if (lastcell.stat_hp != stat_hp)
… …
2134 SockList_AddChar (&sl, 6); 2125 SockList_AddChar (&sl, 6);
2135 SockList_AddChar (&sl, stat_width); 2126 SockList_AddChar (&sl, stat_width);
2136 } 2127 }
2137 } 2128 }
2138 2129
2139 if (lastcell.player !=player) 2130 if (lastcell.player != player)
2140 { 2131 {
2141 lastcell.player = player; 2132 lastcell.player = player;
2142 2133
2143 mask |= 0x8; 2134 mask |= 0x8;
2144 *last_ext |= 0x80; 2135 *last_ext |= 0x80;
2145 last_ext = sl.buf + sl.len; 2136 last_ext = sl.buf + sl.len;
2146 SockList_AddChar (&sl, 0x47); 2137 SockList_AddChar (&sl, 0x47);
2147 SockList_AddChar (&sl, 4); 2138 SockList_AddChar (&sl, 4);
2148 SockList_AddInt (&sl, player); 2139 SockList_AddInt (&sl, player);
2149 } 2140 }
2141
2142 if (lastcell.flags != flags)
2143 {
2144 lastcell.flags = flags;
2145
2146 mask |= 0x8;
2147 *last_ext |= 0x80;
2148 last_ext = sl.buf + sl.len;
2149 SockList_AddChar (&sl, 8);
2150 SockList_AddChar (&sl, flags);
2151 }
2150 } 2152 }
2151 2153
2152 /* Floor face */ 2154 /* Floor face */
2153 if (update_space (&sl, &socket, m, nx, ny, ax, ay, 2)) 2155 if (update_space (&sl, &socket, m, nx, ny, ax, ay, 2))
2154 mask |= 0x4; 2156 mask |= 0x4;
… …
2169 { 2171 {
2170 if (lastcell.faces[0] != pl->face->number) 2172 if (lastcell.faces[0] != pl->face->number)
2171 { 2173 {
2172 lastcell.faces[0] = pl->face->number; 2174 lastcell.faces[0] = pl->face->number;
2173 mask |= 0x1; 2175 mask |= 0x1;
2176
2174 if (!(socket.faces_sent[pl->face->number] & NS_FACESENT_FACE)) 2177 if (!(socket.faces_sent[pl->face->number] & NS_FACESENT_FACE))
2175 esrv_send_face (&socket, pl->face->number, 0); 2178 esrv_send_face (&socket, pl->face->number, 0);
2179
2176 SockList_AddShort (&sl, pl->face->number); 2180 SockList_AddShort (&sl, pl->face->number);
2177 } 2181 }
2178 } 2182 }
2179 /* Top face */
2180 else 2183 else
2181 { 2184 {
2185 /* Top face */
2182 if (update_space (&sl, &socket, m, nx, ny, ax, ay, 0)) 2186 if (update_space (&sl, &socket, m, nx, ny, ax, ay, 0))
2183 mask |= 0x1; 2187 mask |= 0x1;
2188
2184 if (socket.EMI_smooth) 2189 if (socket.EMI_smooth)
2185 if (update_smooth (&esl, &socket, m, nx, ny, ax, ay, 0)) 2190 if (update_smooth (&esl, &socket, m, nx, ny, ax, ay, 0))
2186 {
2187 emask |= 0x1; 2191 emask |= 0x1;
2188 }
2189 } 2192 }
2193
2190 /* Check to see if we are in fact sending anything for this 2194 /* Check to see if we are in fact sending anything for this
2191 * space by checking the mask. If so, update the mask. 2195 * space by checking the mask. If so, update the mask.
2192 * if not, reset the len to that from before adding the mask 2196 * if not, reset the len to that from before adding the mask
2193 * value, so we don't send those bits. 2197 * value, so we don't send those bits.
2194 */ 2198 */
2195 if (mask & 0xf) 2199 if (mask & 0xf)
2196 {
2197 sl.buf[oldlen + 1] = mask & 0xff; 2200 sl.buf[oldlen + 1] = mask & 0xff;
2198 }
2199 else 2201 else
2200 {
2201 sl.len = oldlen; 2202 sl.len = oldlen;
2202 } 2203
2203 if (emask & 0xf) 2204 if (emask & 0xf)
2204 {
2205 esl.buf[eoldlen + 1] = emask & 0xff; 2205 esl.buf[eoldlen + 1] = emask & 0xff;
2206 }
2207 else 2206 else
2208 {
2209 esl.len = eoldlen; 2207 esl.len = eoldlen;
2210 }
2211 } /* else this is a viewable space */ 2208 } /* else this is a viewable space */
2212 } /* for x loop */ 2209 } /* for x loop */
2213 } /* for y loop */ 2210 } /* for y loop */
2214 2211
2215 /* Verify that we in fact do need to send this */ 2212 /* Verify that we in fact do need to send this */
… …
2221 * it doesn't need draw! 2218 * it doesn't need draw!
2222 */ 2219 */
2223 ewhatflag &= (~EMI_NOREDRAW); 2220 ewhatflag &= (~EMI_NOREDRAW);
2224 esl.buf[ewhatstart + 1] = ewhatflag & 0xff; 2221 esl.buf[ewhatstart + 1] = ewhatflag & 0xff;
2225 } 2222 }
2223
2226 if (esl.len > estartlen) 2224 if (esl.len > estartlen)
2227 {
2228 Send_With_Handling (&socket, &esl); 2225 Send_With_Handling (&socket, &esl);
2229 } 2226
2230 free (esl.buf); 2227 free (esl.buf);
2231 } 2228 }
2229
2232 if (sl.len > startlen || socket.sent_scroll) 2230 if (sl.len > startlen || socket.sent_scroll)
2233 { 2231 {
2234 Send_With_Handling (&socket, &sl); 2232 Send_With_Handling (&socket, &sl);
2235 socket.sent_scroll = 0; 2233 socket.sent_scroll = 0;
2236 } 2234 }
2235
2237 free (sl.buf); 2236 free (sl.buf);
2238} 2237}
2239 2238
2240/** 2239/**
2241 * Draws client map. 2240 * Draws client map.
… …
2247 sint16 ax, ay, nx, ny; /* ax and ay goes from 0 to max-size of arrays */ 2246 sint16 ax, ay, nx, ny; /* ax and ay goes from 0 to max-size of arrays */
2248 New_Face *face, *floor; 2247 New_Face *face, *floor;
2249 New_Face *floor2; 2248 New_Face *floor2;
2250 int d, mflags; 2249 int d, mflags;
2251 struct Map newmap; 2250 struct Map newmap;
2252 mapstruct *m, *pm; 2251 maptile *m, *pm;
2253 2252
2254 if (pl->type != PLAYER) 2253 if (pl->type != PLAYER)
2255 { 2254 {
2256 LOG (llevError, "draw_client_map called with non player/non eric-server\n"); 2255 LOG (llevError, "draw_client_map called with non player/non eric-server\n");
2257 return; 2256 return;

Diff Legend

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