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

Diff Legend

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