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.134 by root, Mon Jul 14 23:57:46 2008 UTC vs.
Revision 1.196 by root, Sun Nov 18 00:37:11 2018 UTC

1/* 1/*
2 * This file is part of Deliantra, the Roguelike Realtime MMORPG. 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (©) 2017,2018 Marc Alexander Lehmann / the Deliantra team
4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 5 * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2001,2007 Mark Wedel 6 * Copyright (©) 2001 Mark Wedel
6 * Copyright (©) 1992,2007 Frank Tore Johansen 7 * Copyright (©) 1992 Frank Tore Johansen
7 * 8 *
8 * Deliantra is free software: you can redistribute it and/or modify 9 * Deliantra is free software: you can redistribute it and/or modify it under
9 * it under the terms of the GNU General Public License as published by 10 * the terms of the Affero GNU General Public License as published by the
10 * the Free Software Foundation, either version 3 of the License, or 11 * Free Software Foundation, either version 3 of the License, or (at your
11 * (at your option) any later version. 12 * option) any later version.
12 * 13 *
13 * This program is distributed in the hope that it will be useful, 14 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details. 17 * GNU General Public License for more details.
17 * 18 *
18 * You should have received a copy of the GNU General Public License 19 * You should have received a copy of the Affero GNU General Public License
19 * along with this program. If not, see <http://www.gnu.org/licenses/>. 20 * and the GNU General Public License along with this program. If not, see
21 * <http://www.gnu.org/licenses/>.
20 * 22 *
21 * The authors can be reached via e-mail to <support@deliantra.net> 23 * The authors can be reached via e-mail to <support@deliantra.net>
22 */ 24 */
25
26//+GPL
23 27
24/** 28/**
25 * \file 29 * \file
26 * Client handling. 30 * Client handling.
27 * 31 *
28 * \date 2003-12-02 32 * \date 2003-12-02
29 * 33 *
30 * This file implements all of the goo on the server side for handling 34 * This file implements all of the goo on the server side for handling
31 * clients. It's got a bunch of global variables for keeping track of 35 * clients. It's got a bunch of global variables for keeping track of
32 * each of the clients. 36 * each of the clients.
33 * 37 *
34 * Note: All functions that are used to process data from the client 38 * Note: All functions that are used to process data from the client
35 * have the prototype of (char *data, int datalen, int client_num). This 39 * have the prototype of (char *data, int datalen, int client_num). This
36 * way, we can use one dispatch table. 40 * way, we can use one dispatch table.
37 * 41 *
… …
41 45
42#include <global.h> 46#include <global.h>
43#include <sproto.h> 47#include <sproto.h>
44 48
45#include <living.h> 49#include <living.h>
46#include <commands.h>
47 50
48/* This block is basically taken from socket.c - I assume if it works there, 51/* This block is basically taken from socket.c - I assume if it works there,
49 * it should work here. 52 * it should work here.
50 */ 53 */
51#include <sys/types.h> 54#include <sys/types.h>
… …
63 * This table translates the attack numbers as used within the 66 * This table translates the attack numbers as used within the
64 * program to the value we use when sending STATS command to the 67 * program to the value we use when sending STATS command to the
65 * client. If a value is -1, then we don't send that to the 68 * client. If a value is -1, then we don't send that to the
66 * client. 69 * client.
67 */ 70 */
68short atnr_cs_stat[NROFATTACKS] = { CS_STAT_RES_PHYS, 71static short atnr_cs_stat[NROFATTACKS] =
69 CS_STAT_RES_MAG, CS_STAT_RES_FIRE, CS_STAT_RES_ELEC, 72{
70 CS_STAT_RES_COLD, CS_STAT_RES_CONF, CS_STAT_RES_ACID, 73 CS_STAT_RES_PHYS,
71 CS_STAT_RES_DRAIN, -1 /* weaponmagic */ , 74 CS_STAT_RES_MAG,
72 CS_STAT_RES_GHOSTHIT, CS_STAT_RES_POISON, 75 CS_STAT_RES_FIRE,
73 CS_STAT_RES_SLOW, CS_STAT_RES_PARA, CS_STAT_TURN_UNDEAD, 76 CS_STAT_RES_ELEC,
74 CS_STAT_RES_FEAR, -1 /* Cancellation */ , 77 CS_STAT_RES_COLD,
75 CS_STAT_RES_DEPLETE, CS_STAT_RES_DEATH, 78 CS_STAT_RES_CONF,
76 -1 /* Chaos */ , -1 /* Counterspell */ , 79 CS_STAT_RES_ACID,
77 -1 /* Godpower */ , CS_STAT_RES_HOLYWORD, 80 CS_STAT_RES_DRAIN,
81 -1 /* weaponmagic */,
82 CS_STAT_RES_GHOSTHIT,
83 CS_STAT_RES_POISON,
84 CS_STAT_RES_SLOW,
85 CS_STAT_RES_PARA,
86 CS_STAT_TURN_UNDEAD,
87 CS_STAT_RES_FEAR,
88 -1 /* Cancellation */,
89 CS_STAT_RES_DEPLETE,
90 CS_STAT_RES_DEATH,
91 -1 /* Chaos */,
92 -1 /* Counterspell */,
93 -1 /* Godpower */,
94 CS_STAT_RES_HOLYWORD,
78 CS_STAT_RES_BLIND, 95 CS_STAT_RES_BLIND,
79 -1, /* Internal */ 96 -1, /* Internal */
80 -1, /* life stealing */ 97 -1, /* life stealing */
81 -1 /* Disease - not fully done yet */ 98 -1 /* Disease - not fully done yet */
82}; 99};
… …
98 */ 115 */
99 mx = ns->mapx; 116 mx = ns->mapx;
100 my = ns->mapy; 117 my = ns->mapy;
101 118
102 /* the x and y here are coordinates for the new map, i.e. if we moved 119 /* the x and y here are coordinates for the new map, i.e. if we moved
103 * (dx,dy), newmap[x][y] = oldmap[x-dx][y-dy]. For this reason, 120 * (dx,dy), newmap[x][y] = oldmap[x-dx][y-dy]. For this reason,
104 * if the destination x or y coordinate is outside the viewable 121 * if the destination x or y coordinate is outside the viewable
105 * area, we clear the values - otherwise, the old values 122 * area, we clear the values - otherwise, the old values
106 * are preserved, and the check_head thinks it needs to clear them. 123 * are preserved, and the check_head thinks it needs to clear them.
107 */ 124 */
108 for (x = 0; x < mx; x++) 125 for (x = 0; x < mx; x++)
109 {
110 for (y = 0; y < my; y++) 126 for (y = 0; y < my; y++)
111 {
112 if (x >= ns->mapx || y >= ns->mapy) 127 if (x >= ns->mapx || y >= ns->mapy)
113 /* clear cells outside the viewable area */ 128 /* clear cells outside the viewable area */
114 memset (&newmap.cells[x][y], 0, sizeof (struct MapCell)); 129 memset (&newmap.cells[x][y], 0, sizeof (struct MapCell));
115 else if ((x + dx) < 0 || (x + dx) >= ns->mapx || (y + dy) < 0 || (y + dy) >= ns->mapy) 130 else if ((x + dx) < 0 || (x + dx) >= ns->mapx || (y + dy) < 0 || (y + dy) >= ns->mapy)
116 /* clear newly visible tiles within the viewable area */ 131 /* clear newly visible tiles within the viewable area */
117 memset (&(newmap.cells[x][y]), 0, sizeof (struct MapCell)); 132 memset (&(newmap.cells[x][y]), 0, sizeof (struct MapCell));
118 else 133 else
119 memcpy (&(newmap.cells[x][y]), &(ns->lastmap.cells[x + dx][y + dy]), sizeof (struct MapCell)); 134 memcpy (&(newmap.cells[x][y]), &(ns->lastmap.cells[x + dx][y + dy]), sizeof (struct MapCell));
120 }
121 }
122 135
123 memcpy (&(ns->lastmap), &newmap, sizeof (struct Map)); 136 memcpy (&(ns->lastmap), &newmap, sizeof (struct Map));
124 137
125 /* Make sure that the next "map1" command will be sent (even if it is 138 /* Make sure that the next "map1" command will be sent (even if it is
126 * empty). 139 * empty).
… …
134 pl->ns->mapinfo_queue_clear (); 147 pl->ns->mapinfo_queue_clear ();
135 148
136 memset (&pl->ns->lastmap, 0, sizeof (pl->ns->lastmap)); 149 memset (&pl->ns->lastmap, 0, sizeof (pl->ns->lastmap));
137 150
138 pl->ns->force_newmap = false; 151 pl->ns->force_newmap = false;
139
140 if (pl->ns->newmapcmd == 1)
141 pl->ns->send_packet ("newmap"); 152 pl->ns->send_packet ("newmap");
142
143 pl->ns->floorbox_reset (); 153 pl->ns->floorbox_reset ();
144} 154}
145 155
146static void 156static void
147send_map_info (player *pl) 157send_map_info (player *pl)
148{ 158{
149 client &socket = *pl->ns; 159 client &socket = *pl->ns;
150 object *ob = pl->observe; 160 object *ob = pl->viewpoint;
151 161
152 if (socket.mapinfocmd) 162 if (socket.mapinfocmd)
153 { 163 {
154 if (ob->map && ob->map->path[0]) 164 if (ob->map && ob->map->path)
155 { 165 {
156 int flags = 0; 166 int flags = 0;
157 167
168 // due to historical glitches, the bit ordering and map index ordering differs
158 if (ob->map->tile_path[0]) flags |= 1; 169 if (ob->map->tile_path [TILE_NORTH]) flags |= 0x01;
159 if (ob->map->tile_path[1]) flags |= 2; 170 if (ob->map->tile_path [TILE_EAST ]) flags |= 0x02;
160 if (ob->map->tile_path[2]) flags |= 4; 171 if (ob->map->tile_path [TILE_SOUTH]) flags |= 0x04;
161 if (ob->map->tile_path[3]) flags |= 8; 172 if (ob->map->tile_path [TILE_WEST ]) flags |= 0x08;
173 // these two are debatable
174 if (ob->map->tile_path [TILE_UP ]) flags |= 0x10;
175 if (ob->map->tile_path [TILE_DOWN ]) flags |= 0x20;
162 176
163 socket.send_packet_printf ("mapinfo - spatial %d %d %d %d %d %s", 177 socket.send_packet_printf ("mapinfo - spatial %d %d %d %d %d %s",
164 flags, socket.mapx / 2 - ob->x, socket.mapy / 2 - ob->y, 178 flags, socket.mapx / 2 - ob->x, socket.mapy / 2 - ob->y,
165 ob->map->width, ob->map->height, &ob->map->path); 179 ob->map->width, ob->map->height, &ob->map->path);
166 } 180 }
… …
172/** check for map/region change and send new map data */ 186/** check for map/region change and send new map data */
173static void 187static void
174check_map_change (player *pl) 188check_map_change (player *pl)
175{ 189{
176 client &socket = *pl->ns; 190 client &socket = *pl->ns;
177 object *ob = pl->observe; 191 object *ob = pl->viewpoint;
178 192
179 region *reg = ob->region (); 193 region *reg = ob->region ();
180 if (socket.current_region != reg) 194 if (socket.current_region != reg)
181 { 195 {
182 INVOKE_PLAYER (REGION_CHANGE, pl, ARG_REGION (reg), ARG_REGION (socket.current_region)); 196 INVOKE_PLAYER (REGION_CHANGE, pl, ARG_REGION (reg), ARG_REGION (socket.current_region));
183 socket.current_region = reg; 197 socket.current_region = reg;
184 } 198 }
185 199
186 // first try to aovid a full newmap on tiled map scrolls 200 // first try to avoid a full newmap on tiled map scrolls
187 if (socket.current_map != ob->map && !socket.force_newmap) 201 if (socket.current_map != ob->map && !socket.force_newmap)
188 { 202 {
189 rv_vector rv; 203 rv_vector rv;
190 204
191 get_rangevector_from_mapcoord (socket.current_map, socket.current_x, socket.current_y, ob, &rv, 0); 205 get_rangevector_from_mapcoord (socket.current_map, socket.current_x, socket.current_y, ob, &rv, 0);
… …
212 else if (socket.current_x != ob->x || socket.current_y != ob->y) 226 else if (socket.current_x != ob->x || socket.current_y != ob->y)
213 { 227 {
214 int dx = ob->x - socket.current_x; 228 int dx = ob->x - socket.current_x;
215 int dy = ob->y - socket.current_y; 229 int dy = ob->y - socket.current_y;
216 230
217 if (socket.buggy_mapscroll && (abs (dx) > 8 || abs (dy) > 8))
218 clear_map (pl); // current (<= 1.9.1) clients have unchecked buffer overflows
219 else
220 {
221 socket_map_scroll (&socket, ob->x - socket.current_x, ob->y - socket.current_y); 231 socket_map_scroll (&socket, ob->x - socket.current_x, ob->y - socket.current_y);
222 socket.floorbox_reset (); 232 socket.floorbox_reset ();
223 }
224 } 233 }
225 234
226 socket.current_x = ob->x; 235 socket.current_x = ob->x;
227 socket.current_y = ob->y; 236 socket.current_y = ob->y;
237}
238
239/**
240 * This sends the skill number to name mapping. We ignore
241 * the params - we always send the same info no matter what.
242 */
243static void
244send_skill_info (client *ns, char *params)
245{
246 packet sl;
247 sl << "replyinfo skill_info\n";
248
249 for (int i = 0; i < skillvec.size (); ++i)
250 sl.printf ("%d:%s\n", CS_STAT_SKILLINFO + i, &skillvec [i]->name);
251
252 if (sl.length () > MAXSOCKBUF)
253 cleanup ("buffer overflow in send_skill_info!");
254
255 ns->send_packet (sl);
256}
257
258/**
259 * This sends the spell path to name mapping. We ignore
260 * the params - we always send the same info no matter what.
261 */
262static void
263send_spell_paths (client * ns, char *params)
264{
265 packet sl;
266
267 sl << "replyinfo spell_paths\n";
268
269 for (int i = 0; i < NRSPELLPATHS; i++)
270 sl.printf ("%d:%s\n", 1 << i, spellpathnames[i]);
271
272 if (sl.length () > MAXSOCKBUF)
273 cleanup ("buffer overflow in send_spell_paths!");
274
275 ns->send_packet (sl);
228} 276}
229 277
230/** 278/**
231 * RequestInfo is sort of a meta command. There is some specific 279 * RequestInfo is sort of a meta command. There is some specific
232 * request of information, but we call other functions to provide 280 * request of information, but we call other functions to provide
233 * that information. 281 * that information.
282 * requestinfo is completely deprecated, use resource exti request
283 * and the fxix or http protocols.
234 */ 284 */
235void 285void
236RequestInfo (char *buf, int len, client *ns) 286RequestInfo (char *buf, int len, client *ns)
237{ 287{
238 char *params; 288 char *params;
… …
245 { 295 {
246 *params++ = 0; 296 *params++ = 0;
247 break; 297 break;
248 } 298 }
249 299
250 if (!strcmp (buf, "image_info"))
251 send_image_info (ns, params);
252 else if (!strcmp (buf, "image_sums"))
253 send_image_sums (ns, params);
254 else if (!strcmp (buf, "skill_info")) 300 if (!strcmp (buf, "skill_info"))
255 send_skill_info (ns, params); 301 send_skill_info (ns, params);
256 else if (!strcmp (buf, "spell_paths")) 302 else if (!strcmp (buf, "spell_paths"))
257 send_spell_paths (ns, params); 303 send_spell_paths (ns, params);
258 else 304 else
259 { 305 {
… …
275ExtiCmd (char *buf, int len, client *ns) 321ExtiCmd (char *buf, int len, client *ns)
276{ 322{
277 INVOKE_CLIENT (EXTICMD, ns, ARG_DATA (buf, len)); 323 INVOKE_CLIENT (EXTICMD, ns, ARG_DATA (buf, len));
278} 324}
279 325
326//-GPL
327
280void 328void
281client::mapinfo_queue_clear () 329client::mapinfo_queue_clear ()
282{ 330{
283 for (auto (i, mapinfo_queue.begin ()); i != mapinfo_queue.end (); ++i) 331 for (auto &&i : mapinfo_queue)
284 free (*i); 332 free (i);
285 333
286 mapinfo_queue.clear (); 334 mapinfo_queue.clear ();
287} 335}
288 336
289bool 337bool
… …
291{ 339{
292 char *token = buf; 340 char *token = buf;
293 buf += strlen (buf) + 9; 341 buf += strlen (buf) + 9;
294 342
295 // initial map and its origin 343 // initial map and its origin
296 maptile *map = pl->observe->map; 344 maptile *map = pl->viewpoint->map;
297 int mapx = pl->ns->mapx / 2 - pl->observe->x; 345 int mapx = pl->ns->mapx / 2 - pl->viewpoint->x;
298 int mapy = pl->ns->mapy / 2 - pl->observe->y; 346 int mapy = pl->ns->mapy / 2 - pl->viewpoint->y;
299 int max_distance = 8; // limit maximum path length to something generous 347 int max_distance = 8; // limit maximum path length to something generous
300 348
301 while (*buf && map && max_distance) 349 while (*buf && map && max_distance)
302 { 350 {
303 int dir = *buf++ - '1'; 351 int dir = *buf++ - '1';
304 352
305 if (dir >= 0 && dir <= 3) 353 // due to historical glitches, the mapinfo index and tile index differs
354 static unsigned char dirmap [] = { TILE_NORTH, TILE_EAST, TILE_SOUTH, TILE_WEST, TILE_UP, TILE_DOWN };
355
356 // maybe we should only allow the four flat directions
357 if (IN_RANGE_EXC (dir, 0, array_length (dirmap)))
306 { 358 {
359 dir = dirmap [dir];
360
307 if (!map->tile_path [dir]) 361 if (!map->tile_path [dir])
308 map = 0; 362 map = 0;
309 else if (map->tile_available (dir, false)) 363 else if (map->tile_available (dir, false))
310 { 364 {
311 maptile *neigh = map->tile_map [dir]; 365 maptile *neigh = map->tile_map [dir];
… …
334 send_packet_printf ("mapinfo %s nomap", token); 388 send_packet_printf ("mapinfo %s nomap", token);
335 else 389 else
336 { 390 {
337 int flags = 0; 391 int flags = 0;
338 392
393 // due to historical glitches, the bit ordering and map index ordering differs
339 if (map->tile_path[0]) flags |= 1; 394 if (map->tile_path [TILE_NORTH]) flags |= 0x01;
340 if (map->tile_path[1]) flags |= 2; 395 if (map->tile_path [TILE_EAST ]) flags |= 0x02;
341 if (map->tile_path[2]) flags |= 4; 396 if (map->tile_path [TILE_SOUTH]) flags |= 0x04;
342 if (map->tile_path[3]) flags |= 8; 397 if (map->tile_path [TILE_WEST ]) flags |= 0x08;
398 // these two are debatable
399 if (map->tile_path [TILE_UP ]) flags |= 0x10;
400 if (map->tile_path [TILE_DOWN ]) flags |= 0x20;
343 401
344 send_packet_printf ("mapinfo %s spatial %d %d %d %d %d %s", token, flags, mapx, mapy, map->width, map->height, &map->path); 402 send_packet_printf ("mapinfo %s spatial %d %d %d %d %d %s", token, flags, mapx, mapy, map->width, map->height, &map->path);
345 } 403 }
346 404
347 return 1; 405 return 1;
… …
408AddMeCmd (char *buf, int len, client *ns) 466AddMeCmd (char *buf, int len, client *ns)
409{ 467{
410 INVOKE_CLIENT (ADDME, ns, ARG_DATA (buf, len)); 468 INVOKE_CLIENT (ADDME, ns, ARG_DATA (buf, len));
411} 469}
412 470
413/** Reply to ExtendedInfos command */ 471//+GPL
414void
415ToggleExtendedInfos (char *buf, int len, client * ns)
416{
417 char cmdback[MAX_BUF];
418 char command[50];
419 int info, nextinfo;
420
421 cmdback[0] = '\0';
422 nextinfo = 0;
423
424 while (1)
425 {
426 /* 1. Extract an info */
427 info = nextinfo;
428
429 while ((info < len) && (buf[info] == ' '))
430 info++;
431
432 if (info >= len)
433 break;
434
435 nextinfo = info + 1;
436
437 while ((nextinfo < len) && (buf[nextinfo] != ' '))
438 nextinfo++;
439
440 if (nextinfo - info >= 49) /*Erroneous info asked */
441 continue;
442
443 strncpy (command, &(buf[info]), nextinfo - info);
444
445 /* 2. Interpret info */
446 if (!strcmp ("smooth", command))
447 /* Toggle smoothing */
448 ns->EMI_smooth = !ns->EMI_smooth;
449 else
450 /*bad value */;
451
452 /*3. Next info */
453 }
454
455 strcpy (cmdback, "ExtendedInfoSet");
456
457 if (ns->EMI_smooth)
458 {
459 strcat (cmdback, " ");
460 strcat (cmdback, "smoothing");
461 }
462
463 ns->send_packet (cmdback);
464}
465
466/*
467#define MSG_TYPE_BOOK 1
468#define MSG_TYPE_CARD 2
469#define MSG_TYPE_PAPER 3
470#define MSG_TYPE_SIGN 4
471#define MSG_TYPE_MONUMENT 5
472#define MSG_TYPE_SCRIPTED_DIALOG 6*/
473
474/** Reply to ExtendedInfos command */
475void
476ToggleExtendedText (char *buf, int len, client * ns)
477{
478 char cmdback[MAX_BUF];
479 char temp[10];
480 char command[50];
481 int info, nextinfo, i, flag;
482
483 cmdback[0] = '\0';
484
485 nextinfo = 0;
486 while (1)
487 {
488 /* 1. Extract an info */
489 info = nextinfo;
490
491 while ((info < len) && (buf[info] == ' '))
492 info++;
493
494 if (info >= len)
495 break;
496
497 nextinfo = info + 1;
498
499 while ((nextinfo < len) && (buf[nextinfo] != ' '))
500 nextinfo++;
501
502 if (nextinfo - info >= 49) /*Erroneous info asked */
503 continue;
504
505 strncpy (command, &(buf[info]), nextinfo - info);
506 command[nextinfo - info] = '\0';
507 /* 2. Interpret info */
508 i = sscanf (command, "%d", &flag);
509
510 if ((i == 1) && (flag > 0) && (flag <= MSG_TYPE_LAST))
511 ns->supported_readables |= (1 << flag);
512 /*3. Next info */
513 }
514
515 /* Send resulting state */
516 strcpy (cmdback, "ExtendedTextSet");
517
518 for (i = 0; i <= MSG_TYPE_LAST; i++)
519 if (ns->supported_readables & (1 << i))
520 {
521 strcat (cmdback, " ");
522 snprintf (temp, sizeof (temp), "%d", i);
523 strcat (cmdback, temp);
524 }
525
526 ns->send_packet (cmdback);
527}
528 472
529/** 473/**
530 * This handles the general commands from the client (ie, north, fire, cast, 474 * This handles the general commands from the client (ie, north, fire, cast,
531 * etc.) 475 * etc.)
532 */ 476 */
… …
545 return; 489 return;
546 490
547 buf++; 491 buf++;
548 } 492 }
549 493
550 execute_newserver_command (pl->ob, (char *) buf); 494 execute_newserver_command (pl->ob, (char *)buf);
551 495
552 /* Perhaps something better should be done with a left over count. 496 /* Perhaps something better should be done with a left over count.
553 * Cleaning up the input should probably be done first - all actions 497 * Cleaning up the input should probably be done first - all actions
554 * for the command that issued the count should be done before any other 498 * for the command that issued the count should be done before any other
555 * commands. 499 * commands.
556 */ 500 */
557 pl->count = 0; 501 pl->count = 0;
558}
559
560/**
561 * This handles the general commands from the client (ie, north, fire, cast,
562 * etc.). It is a lot like PlayerCmd above, but is called with the
563 * 'ncom' method which gives more information back to the client so it
564 * can throttle.
565 */
566void
567NewPlayerCmd (char *buf, int len, player *pl)
568{
569 if (len <= 6)
570 {
571 LOG (llevDebug, "%s: corrupt ncom command <%s>: not long enough (%d) - discarding\n", pl->ns->host, buf, len);
572 return;
573 }
574
575 uint16 cmdid = net_uint16 ((uint8 *)buf);
576 sint32 repeat = net_sint32 ((uint8 *)buf + 2);
577
578 /* -1 is special - no repeat, but don't update */
579 if (repeat != -1)
580 pl->count = repeat;
581
582 buf += 6; //len -= 6;
583
584 execute_newserver_command (pl->ob, buf);
585
586 /* Perhaps something better should be done with a left over count.
587 * Cleaning up the input should probably be done first - all actions
588 * for the command that issued the count should be done before any other
589 * commands.
590 */
591 pl->count = 0;
592
593 //TODO: schmorp thinks whatever this calculates, it makes no sense at all
594 int time = fabs (pl->ob->speed) < 0.001
595 ? time = MAX_TIME * 100
596 : time = (int) (MAX_TIME / fabs (pl->ob->speed));
597
598 /* Send confirmation of command execution now */
599 packet sl ("comc");
600 sl << uint16 (cmdid) << uint32 (time);
601 pl->ns->send_packet (sl);
602} 502}
603 503
604/** This is a reply to a previous query. */ 504/** This is a reply to a previous query. */
605void 505void
606ReplyCmd (char *buf, int len, client *ns) 506ReplyCmd (char *buf, int len, client *ns)
… …
643 LOG (llevError, "Unknown input state: %d\n", ns->state); 543 LOG (llevError, "Unknown input state: %d\n", ns->state);
644 } 544 }
645} 545}
646 546
647/** 547/**
648 * Client tells its version. If there is a mismatch, we close the 548 * Client tells its version info.
649 * socket. In real life, all we should care about is the client having
650 * something older than the server. If we assume the client will be
651 * backwards compatible, having it be a later version should not be a
652 * problem.
653 */ 549 */
654void 550void
655VersionCmd (char *buf, int len, client * ns) 551VersionCmd (char *buf, int len, client *ns)
656{ 552{
657 if (!buf) 553 INVOKE_CLIENT (VERSION, ns, ARG_DATA (buf, len));
658 {
659 LOG (llevError, "CS: received corrupted version command\n");
660 return;
661 }
662
663 ns->cs_version = atoi (buf);
664 ns->sc_version = ns->cs_version;
665
666 LOG (llevDebug, "connection from client <%s>\n", buf);
667
668 //TODO: should log here just for statistics
669
670 //if (VERSION_CS != ns->cs_version)
671 // unchecked;
672
673 char *cp = strchr (buf + 1, ' ');
674 if (!cp)
675 return;
676
677 ns->sc_version = atoi (cp);
678
679 //if (VERSION_SC != ns->sc_version)
680 // unchecked;
681
682 cp = strchr (cp + 1, ' ');
683
684 if (cp)
685 {
686 ns->version = cp + 1;
687
688 if (ns->sc_version < 1026)
689 ns->send_packet_printf ("drawinfo %d %s", NDI_RED,
690 "**** VERSION WARNING ****\n**** CLIENT IS TOO OLD!! UPDATE THE CLIENT!! ****");
691 }
692} 554}
693 555
694/** sound related functions. */ 556/** sound related functions. */
695void 557void
696SetSound (char *buf, int len, client * ns) 558SetSound (char *buf, int len, client * ns)
… …
747 * Get player's current range attack in obuf. 609 * Get player's current range attack in obuf.
748 */ 610 */
749static void 611static void
750rangetostring (player *pl, char *obuf) 612rangetostring (player *pl, char *obuf)
751{ 613{
752 dynbuf_text buf; 614 dynbuf_text &buf = msg_dynbuf; buf.clear ();
615
616#if 0
617 // print ranged/chosen_skill etc. objects every call
618 printf ("%s %s => %s (%s)\n",
619 pl->ranged_ob ? &pl->ranged_ob->name : "-",
620 pl->combat_ob ? &pl->combat_ob->name : "-",
621 pl->ob->current_weapon ? &pl->ob->current_weapon->name : "-",
622 pl->ob->chosen_skill ? &pl->ob->chosen_skill->name : "-"
623 );
624#endif
753 625
754 if (pl->ranged_ob) 626 if (pl->ranged_ob)
755 buf << " Range" << (pl->ob->current_weapon == pl->ranged_ob ? "*" : "") << ": " << pl->ranged_ob->name; 627 buf << " Range" << (pl->ob->current_weapon == pl->ranged_ob ? "*" : "") << ": " << pl->ranged_ob->name;
756 628
757 if (pl->combat_ob) 629 if (pl->combat_ob)
… …
803 * commands for now. 675 * commands for now.
804 */ 676 */
805void 677void
806esrv_update_stats (player *pl) 678esrv_update_stats (player *pl)
807{ 679{
808 char buf[MAX_BUF];
809 uint16 flags;
810
811 client *ns = pl->ns; 680 client *ns = pl->ns;
812 if (!ns) 681 if (!ns)
813 return; 682 return;
814 683
815 object *ob = pl->observe; 684 object *ob = pl->observe;
… …
832 AddIfShort (ns->last_stats.Int, ob->stats.Int, CS_STAT_INT); 701 AddIfShort (ns->last_stats.Int, ob->stats.Int, CS_STAT_INT);
833 AddIfShort (ns->last_stats.Wis, ob->stats.Wis, CS_STAT_WIS); 702 AddIfShort (ns->last_stats.Wis, ob->stats.Wis, CS_STAT_WIS);
834 AddIfShort (ns->last_stats.Pow, ob->stats.Pow, CS_STAT_POW); 703 AddIfShort (ns->last_stats.Pow, ob->stats.Pow, CS_STAT_POW);
835 AddIfShort (ns->last_stats.Cha, ob->stats.Cha, CS_STAT_CHA); 704 AddIfShort (ns->last_stats.Cha, ob->stats.Cha, CS_STAT_CHA);
836 705
837 for (int s = 0; s < NUM_SKILLS; s++) 706 for (int s = 0; s < CS_NUM_SKILLS; s++)
838 if (object *skill = opl->last_skill_ob[s]) 707 if (object *skill = opl->last_skill_ob [s])
839 if (skill->stats.exp != ns->last_skill_exp [s]) 708 if (skill->stats.exp != ns->last_skill_exp [s])
840 { 709 {
841 ns->last_skill_exp [s] = skill->stats.exp; 710 ns->last_skill_exp [s] = skill->stats.exp;
842 711
843 /* Always send along the level if exp changes. This is only 712 /* Always send along the level if exp changes. This is only
844 * 1 extra byte, but keeps processing simpler. 713 * 1 extra byte, but keeps processing simpler.
845 */ 714 */
846 sl << uint8 (s + CS_STAT_SKILLINFO) 715 sl << uint8 (CS_STAT_SKILLINFO + s)
847 << uint8 (skill->level) 716 << uint8 (skill->level)
848 << uint64 (skill->stats.exp); 717 << uint64 (skill->stats.exp);
849 } 718 }
850 719
851 AddIfInt64 (ns->last_stats.exp, ob->stats.exp, CS_STAT_EXP64); 720 AddIfInt64 (ns->last_stats.exp, ob->stats.exp, CS_STAT_EXP64);
852 AddIfShort (ns->last_level, ob->level, CS_STAT_LEVEL); 721 AddIfShort (ns->last_level, ob->level, CS_STAT_LEVEL);
853 AddIfShort (ns->last_stats.wc, ob->stats.wc, CS_STAT_WC); 722 AddIfShort (ns->last_stats.wc, ob->stats.wc, CS_STAT_WC);
854 AddIfShort (ns->last_stats.ac, ob->stats.ac, CS_STAT_AC); 723 AddIfShort (ns->last_stats.ac, ob->stats.ac, CS_STAT_AC);
855 AddIfShort (ns->last_stats.dam, ob->stats.dam, CS_STAT_DAM); 724 AddIfShort (ns->last_stats.dam, ob->stats.dam, CS_STAT_DAM);
856 AddIfFloat (ns->last_speed, ob->speed, CS_STAT_SPEED, 1.f/TICK); 725 AddIfFloat (ns->last_speed, ob->speed, CS_STAT_SPEED, 1.f / TICK);
857 AddIfShort (ns->last_stats.food, ob->stats.food, CS_STAT_FOOD); 726 AddIfShort (ns->last_stats.food, ob->stats.food, CS_STAT_FOOD);
858 AddIfFloat (ns->last_weapon_sp, pl->weapon_sp, CS_STAT_WEAP_SP, 1.f/TICK); 727 AddIfFloat (ns->last_weapon_sp, pl->weapon_sp, CS_STAT_WEAP_SP, 1.f / TICK);
859 AddIfInt (ns->last_weight_limit, weight_limit[ob->stats.Str], CS_STAT_WEIGHT_LIM); 728 AddIfInt (ns->last_weight_limit, weight_limit[ob->stats.Str], CS_STAT_WEIGHT_LIM);
860 729
861 flags = 0; 730 int flags = (opl->fire_on ? SF_FIREON : 0)
862 731 | (opl->run_on ? SF_RUNON : 0);
863 if (opl->fire_on)
864 flags |= SF_FIREON;
865
866 if (opl->run_on)
867 flags |= SF_RUNON;
868 732
869 AddIfShort (ns->last_flags, flags, CS_STAT_FLAGS); 733 AddIfShort (ns->last_flags, flags, CS_STAT_FLAGS);
870 734
871 if (ns->sc_version < 1025)
872 { AddIfShort (ns->last_resist[ATNR_PHYSICAL], ob->resist[ATNR_PHYSICAL], CS_STAT_ARMOUR) }
873 else
874 for (int i = 0; i < NROFATTACKS; i++) 735 for (int i = 0; i < NROFATTACKS; i++)
875 {
876 /* Skip ones we won't send */ 736 /* Skip ones we won't send */
877 if (atnr_cs_stat[i] == -1) 737 if (atnr_cs_stat[i] >= 0)
878 continue;
879
880 AddIfShort (ns->last_resist[i], ob->resist[i], atnr_cs_stat[i]); 738 AddIfShort (ns->last_resist[i], ob->resist[i], atnr_cs_stat[i]);
881 }
882 739
883 if (pl->ns->monitor_spells) 740 if (pl->ns->monitor_spells)
884 { 741 {
885 AddIfInt (ns->last_path_attuned, ob->path_attuned, CS_STAT_SPELL_ATTUNE); 742 AddIfInt (ns->last_path_attuned, ob->path_attuned, CS_STAT_SPELL_ATTUNE);
886 AddIfInt (ns->last_path_repelled, ob->path_repelled, CS_STAT_SPELL_REPEL); 743 AddIfInt (ns->last_path_repelled, ob->path_repelled, CS_STAT_SPELL_REPEL);
887 AddIfInt (ns->last_path_denied, ob->path_denied, CS_STAT_SPELL_DENY); 744 AddIfInt (ns->last_path_denied, ob->path_denied, CS_STAT_SPELL_DENY);
888 } 745 }
889 746
747 char buf[MAX_BUF];
890 rangetostring (opl, buf); /* we want use the new fire & run system in new client */ 748 rangetostring (opl, buf); /* we want use the new fire & run system in new client */
891 AddIfString (ns->stats.range, buf, CS_STAT_RANGE); 749 AddIfString (ns->stats.range, buf, CS_STAT_RANGE);
892 set_title (ob, buf); 750 set_title (ob, buf);
893 AddIfString (ns->stats.title, buf, CS_STAT_TITLE); 751 AddIfString (ns->stats.title, buf, CS_STAT_TITLE);
894 752
… …
912 << uint32 (pl->ob->face) 770 << uint32 (pl->ob->face)
913 << data8 (pl->ob->name); 771 << data8 (pl->ob->name);
914 772
915 pl->ns->last_weight = weight; 773 pl->ns->last_weight = weight;
916 pl->ns->send_packet (sl); 774 pl->ns->send_packet (sl);
917 SET_FLAG (pl->ob, FLAG_CLIENT_SENT);
918} 775}
919 776
920/****************************************************************************** 777/******************************************************************************
921 * 778 *
922 * Start of map related commands. 779 * Start of map related commands.
… …
990 /* Nothing changed */ 847 /* Nothing changed */
991 return 0; 848 return 0;
992} 849}
993 850
994/** 851/**
995 * Returns the size of a data for a map square as returned by
996 * mapextended. There are CLIENTMAPX*CLIENTMAPY*LAYERS entries
997 * available.
998 */
999int
1000getExtendedMapInfoSize (client * ns)
1001{
1002 int result = 0;
1003
1004 if (ns->ext_mapinfos)
1005 {
1006 if (ns->EMI_smooth)
1007 result += 1; /*One byte for smoothlevel */
1008 }
1009
1010 return result;
1011}
1012
1013// prefetch (and touch) all maps within a specific distancd
1014static void
1015prefetch_surrounding_maps (maptile *map, int distance)
1016{
1017 map->last_access = runtime;
1018
1019 if (--distance)
1020 for (int dir = 4; --dir; )
1021 if (const shstr &path = map->tile_path [dir])
1022 if (maptile *&neigh = map->tile_map [dir])
1023 prefetch_surrounding_maps (neigh, distance);
1024 else
1025 neigh = maptile::find_async (path, map);
1026}
1027
1028// prefetch a generous area around the player
1029static void
1030prefetch_surrounding_maps (object *op)
1031{
1032 prefetch_surrounding_maps (op->map, 3);
1033}
1034
1035/**
1036 * Draws client map. 852 * Draws client map.
1037 */ 853 */
1038void 854void
1039draw_client_map (player *pl) 855draw_client_map (player *pl)
1040{ 856{
1041 object *ob = pl->observe; 857 object *ob = pl->viewpoint;
1042 if (!ob->active) 858 if (!pl->observe->active)
1043 return; 859 return;
1044
1045 maptile *plmap = ob->map;
1046 860
1047 /* If player is just joining the game, he isn't here yet, so the map 861 /* If player is just joining the game, he isn't here yet, so the map
1048 * can get swapped out. If so, don't try to send them a map. All will 862 * can get swapped out. If so, don't try to send them a map. All will
1049 * be OK once they really log in. 863 * be OK once they really log in.
1050 */ 864 */
1051 if (!plmap || plmap->in_memory != MAP_ACTIVE) 865 if (!ob->map || ob->map->state != MAP_ACTIVE)
1052 return; 866 return;
1053 867
1054 int x, y, ax, ay, startlen, max_x, max_y, oldlen;
1055 int estartlen, eoldlen; 868 int startlen, oldlen;
1056 uint8 eentrysize;
1057 uint16 ewhatstart, ewhatflag;
1058 uint8 extendedinfos;
1059 869
1060 check_map_change (pl); 870 check_map_change (pl);
1061 prefetch_surrounding_maps (pl->ob); 871 pl->ob->prefetch_surrounding_maps ();
1062 872
1063 /* do LOS after calls to update_position */ 873 /* do LOS after calls to update_position */
1064 if (ob != pl->ob) 874 /* unfortunately, we need to udpate los when observing, currently */
1065 clear_los (pl); 875 if (pl->do_los || pl->viewpoint != pl->ob)
1066 else if (pl->do_los)
1067 { 876 {
1068 update_los (ob);
1069 pl->do_los = 0; 877 pl->do_los = 0;
878 pl->update_los ();
1070 } 879 }
1071 880
1072 /** 881 /**
1073 * This function uses the new map1 protocol command to send the map 882 * This function uses the new map1 protocol command to send the map
1074 * to the client. It is necessary because the old map command supports 883 * to the client. It is necessary because the old map command supports
… …
1092 * look like. 901 * look like.
1093 */ 902 */
1094 903
1095 client &socket = *pl->ns; 904 client &socket = *pl->ns;
1096 905
1097 packet sl (socket.mapmode == Map1Cmd ? "map1" : "map1a"); 906 packet sl ("map1a");
1098 packet esl;
1099 907
1100 startlen = sl.length (); 908 startlen = sl.length ();
1101 909
1102 /*Extendedmapinfo structure initialisation */ 910 int hx = socket.mapx / 2;
1103 if (socket.ext_mapinfos) 911 int hy = socket.mapy / 2;
1104 {
1105 extendedinfos = EMI_NOREDRAW;
1106 912
1107 if (socket.EMI_smooth) 913 ordered_mapwalk_begin (ob, -hx, -hy, hx, hy)
1108 extendedinfos |= EMI_SMOOTH; 914 int ax = dx + hx;
915 int ay = dy + hy;
1109 916
1110 ewhatstart = esl.length (); 917 int mask = (ax << 10) | (ay << 4);
1111 ewhatflag = extendedinfos; /*The EMI_NOREDRAW bit 918 MapCell &lastcell = socket.lastmap.cells[ax][ay];
1112 could need to be taken away */
1113 eentrysize = getExtendedMapInfoSize (&socket);
1114 esl << "mapextended "
1115 << uint8 (extendedinfos)
1116 << uint8 (eentrysize);
1117 919
1118 estartlen = esl.length (); 920 /* If the coordinates are not valid, or it is too dark to see,
1119 } 921 * we tell the client as such
1120
1121 /* x,y are the real map locations. ax, ay are viewport relative
1122 * locations.
1123 */ 922 */
1124 ay = 0; 923 if (!m)
1125
1126 /* We could do this logic as conditionals in the if statement,
1127 * but that started to get a bit messy to look at.
1128 */
1129 max_x = ob->x + (socket.mapx + 1) / 2;
1130 max_y = ob->y + (socket.mapy + 1) / 2;
1131
1132 for (y = ob->y - socket.mapy / 2; y < max_y; y++, ay++)
1133 { 924 {
1134 sint16 nx, ny; 925 /* space is out of map. Update space and clear values
1135 maptile *m = 0; 926 * if this hasn't already been done. If the space is out
1136 927 * of the map, it shouldn't have a head.
1137 ax = 0; 928 */
1138 for (x = ob->x - socket.mapx / 2; x < max_x; x++, ax++) 929 if (lastcell.count != -1)
1139 { 930 {
1140 // check to see if we can simply go one right quickly 931 sl << uint16 (mask);
932 map_clearcell (&lastcell, -1);
1141 ++nx; 933 }
1142 if (m && nx >= m->width) 934
935 continue;
936 }
937
938 int d = pl->blocked_los_uc (dx, dy);
939
940 if (d > 3)
941 {
942 /* This block deals with spaces that are not visible for whatever
943 * reason. Still may need to send the head for this space.
944 */
945 if (lastcell.count != -1
946 || lastcell.faces[0]
947 || lastcell.faces[1]
948 || lastcell.faces[2]
949 || lastcell.stat_hp
950 || lastcell.flags
951 || lastcell.player)
952 sl << uint16 (mask);
953
954 /* properly clear a previously sent big face */
955 map_clearcell (&lastcell, -1);
956 }
957 else
958 {
959 /* In this block, the space is visible.
960 */
961
962 /* Rather than try to figure out what everything that we might
963 * need to send is, then form the packet after that,
964 * we presume that we will in fact form a packet, and update
965 * the bits by what we do actually send. If we send nothing,
966 * we just back out sl.length () to the old value, and no harm
967 * is done.
968 * I think this is simpler than doing a bunch of checks to see
969 * what if anything we need to send, setting the bits, then
970 * doing those checks again to add the real data.
971 */
972 oldlen = sl.length ();
973
974 sl << uint16 (mask);
975
976 unsigned char dummy;
977 unsigned char *last_ext = &dummy;
978
979 /* Darkness changed */
980 if (lastcell.count != d)
981 {
1143 m = 0; 982 mask |= 0x8;
1144 983
1145 if (!m) 984 *last_ext |= 0x80;
985 last_ext = &sl[sl.length ()];
986 sl << uint8 (d);
987 }
988
989 lastcell.count = d;
990
991 mapspace &ms = m->at (nx, ny);
992 ms.update ();
993
994 // extmap handling
995 uint8 stat_hp = 0;
996 uint8 stat_width = 0;
997 uint8 flags = 0;
998 tag_t player = 0;
999
1000 // send hp information, if applicable
1001 if (object *op = ms.faces_obj [0])
1002 if (op->is_head () && !op->invisible)
1146 { 1003 {
1147 nx = x; ny = y; m = plmap; 1004 if (op->stats.maxhp > op->stats.hp
1148 1005 && op->stats.maxhp > 0
1149 if (xy_normalise (m, nx, ny)) 1006 && (op->type == PLAYER
1150 m->touch (); 1007 || op->type == DOOR // does not work, have maxhp 0
1151 else 1008 || op->flag [FLAG_MONSTER]
1009 || op->flag [FLAG_ALIVE]
1010 || op->flag [FLAG_GENERATOR]))
1152 m = 0; 1011 {
1012 stat_hp = 255 - (op->stats.hp * 255 + 254) / op->stats.maxhp;
1013 stat_width = op->arch->max_x - op->arch->x; //TODO: should be upper-left edge
1014 }
1015
1016 if (expect_false (op->has_dialogue ()))
1017 flags |= 1;
1018
1019 if (expect_false (op->type == PLAYER))
1020 player = op == ob ? pl->ob->count
1021 : op == pl->ob ? ob->count
1022 : op->count;
1153 } 1023 }
1154 1024
1155 int emask, mask; 1025 if (expect_false (lastcell.stat_hp != stat_hp))
1156 emask = mask = (ax & 0x3f) << 10 | (ay & 0x3f) << 4;
1157
1158 MapCell &lastcell = socket.lastmap.cells[ax][ay];
1159
1160 /* If the coordinates are not valid, or it is too dark to see,
1161 * we tell the client as such
1162 */
1163 if (!m)
1164 { 1026 {
1165 /* space is out of map. Update space and clear values 1027 lastcell.stat_hp = stat_hp;
1166 * if this hasn't already been done. If the space is out 1028
1167 * of the map, it shouldn't have a head 1029 mask |= 0x8;
1168 */ 1030 *last_ext |= 0x80;
1169 if (lastcell.count != -1) 1031 last_ext = &sl[sl.length ()];
1032
1033 sl << uint8 (5) << uint8 (stat_hp);
1034
1035 if (stat_width > 1)
1170 { 1036 {
1171 sl << uint16 (mask);
1172 map_clearcell (&lastcell, -1);
1173 }
1174
1175 continue;
1176 }
1177
1178 int d = pl->blocked_los[ax][ay];
1179
1180 if (d > 3)
1181 {
1182 int need_send = 0, count;
1183
1184 /* This block deals with spaces that are not visible for whatever
1185 * reason. Still may need to send the head for this space.
1186 */
1187
1188 oldlen = sl.length ();
1189
1190 sl << uint16 (mask);
1191
1192 if (lastcell.count != -1)
1193 need_send = 1;
1194
1195 count = -1;
1196
1197 if (lastcell.faces[0] || lastcell.faces[1] || lastcell.faces[2]
1198 || lastcell.stat_hp || lastcell.flags || lastcell.player)
1199 need_send = 1;
1200
1201 /* properly clear a previously sent big face */
1202 map_clearcell (&lastcell, count);
1203
1204 if ((mask & 0xf) || need_send)
1205 sl[oldlen + 1] = mask & 0xff;
1206 else
1207 sl.reset (oldlen);
1208 }
1209 else
1210 {
1211 /* In this block, the space is visible.
1212 */
1213
1214 /* Rather than try to figure out what everything that we might
1215 * need to send is, then form the packet after that,
1216 * we presume that we will in fact form a packet, and update
1217 * the bits by what we do actually send. If we send nothing,
1218 * we just back out sl.length () to the old value, and no harm
1219 * is done.
1220 * I think this is simpler than doing a bunch of checks to see
1221 * what if anything we need to send, setting the bits, then
1222 * doing those checks again to add the real data.
1223 */
1224 oldlen = sl.length ();
1225 eoldlen = esl.length ();
1226
1227 sl << uint16 (mask);
1228
1229 unsigned char dummy;
1230 unsigned char *last_ext = &dummy;
1231
1232 /* Darkness changed */
1233 if (lastcell.count != d && socket.darkness)
1234 {
1235 mask |= 0x8;
1236
1237 if (socket.extmap)
1238 {
1239 *last_ext |= 0x80; 1037 *last_ext |= 0x80;
1240 last_ext = &sl[sl.length ()]; 1038 last_ext = &sl[sl.length ()];
1241 sl << uint8 (d); 1039
1242 } 1040 sl << uint8 (6) << uint8 (stat_width);
1243 else
1244 sl << uint8 (255 - 64 * d);
1245 } 1041 }
1042 }
1246 1043
1247 lastcell.count = d; 1044 if (expect_false (lastcell.player != player))
1248
1249 mapspace &ms = m->at (nx, ny);
1250 ms.update ();
1251
1252 if (socket.extmap)
1253 { 1045 {
1254 uint8 stat_hp = 0; 1046 lastcell.player = player;
1255 uint8 stat_width = 0;
1256 uint8 flags = 0;
1257 tag_t player = 0;
1258 1047
1259 // send hp information, if applicable
1260 if (object *op = ms.faces_obj [0])
1261 if (op->is_head () && !op->invisible)
1262 {
1263 if (op->stats.maxhp > op->stats.hp
1264 && op->stats.maxhp > 0
1265 && (op->type == PLAYER
1266 || op->type == DOOR // does not work, have maxhp 0
1267 || QUERY_FLAG (op, FLAG_MONSTER) || QUERY_FLAG (op, FLAG_ALIVE) || QUERY_FLAG (op, FLAG_GENERATOR)))
1268 {
1269 stat_hp = 255 - (op->stats.hp * 255 + 254) / op->stats.maxhp;
1270 stat_width = op->arch->max_x - op->arch->x; //TODO: should be upper-left edge
1271 }
1272
1273 if (op->has_dialogue ())
1274 flags |= 1;
1275
1276 if (op->type == PLAYER)
1277 player = op->count;
1278 }
1279
1280 if (lastcell.stat_hp != stat_hp)
1281 {
1282 lastcell.stat_hp = stat_hp;
1283
1284 mask |= 0x8; 1048 mask |= 0x8;
1285 *last_ext |= 0x80; 1049 *last_ext |= 0x80;
1286 last_ext = &sl[sl.length ()]; 1050 last_ext = &sl[sl.length ()];
1287 1051
1288 sl << uint8 (5) << uint8 (stat_hp);
1289
1290 if (stat_width > 1)
1291 {
1292 *last_ext |= 0x80;
1293 last_ext = &sl[sl.length ()];
1294
1295 sl << uint8 (6) << uint8 (stat_width);
1296 }
1297 }
1298
1299 if (lastcell.player != player)
1300 {
1301 lastcell.player = player;
1302
1303 mask |= 0x8;
1304 *last_ext |= 0x80;
1305 last_ext = &sl[sl.length ()];
1306
1307 sl << uint8 (0x47) << uint8 (4) << (uint32)player; 1052 sl << uint8 (0x47) << uint8 (4) << (uint32)player;
1308 } 1053 }
1309 1054
1310 if (lastcell.flags != flags) 1055 if (expect_false (lastcell.flags != flags))
1311 { 1056 {
1312 lastcell.flags = flags; 1057 lastcell.flags = flags;
1313 1058
1314 mask |= 0x8; 1059 mask |= 0x8;
1315 *last_ext |= 0x80; 1060 *last_ext |= 0x80;
1316 last_ext = &sl[sl.length ()]; 1061 last_ext = &sl[sl.length ()];
1317 1062
1318 sl << uint8 (8) << uint8 (flags); 1063 sl << uint8 (8) << uint8 (flags);
1319 }
1320 } 1064 }
1321 1065
1066 // faces
1067
1322 /* Floor face */ 1068 /* Floor face */
1323 if (update_space (sl, socket, ms, lastcell, 2)) 1069 if (update_space (sl, socket, ms, lastcell, 2))
1324 mask |= 0x4; 1070 mask |= 0x4;
1325 1071
1326 /* Middle face */ 1072 /* Middle face */
1327 if (update_space (sl, socket, ms, lastcell, 1)) 1073 if (update_space (sl, socket, ms, lastcell, 1))
1328 mask |= 0x2; 1074 mask |= 0x2;
1329 1075
1076 if (expect_false (ob->invisible)
1077 && ob->invisible & (ob->invisible < 50 ? 1 : 7)
1330 if (ms.player () == ob 1078 && ms.player () == ob)
1331 && (ob->invisible & (ob->invisible < 50 ? 1 : 7)))
1332 { 1079 {
1333 // force player to be visible to himself if invisible 1080 // force player to be visible to himself if invisible
1334 if (lastcell.faces[0] != ob->face) 1081 if (lastcell.faces[0] != ob->face)
1335 { 1082 {
1336 lastcell.faces[0] = ob->face; 1083 lastcell.faces[0] = ob->face;
1337 1084
1338 mask |= 0x1;
1339 sl << uint16 (ob->face);
1340
1341 socket.send_faces (ob);
1342 }
1343 }
1344 /* Top face */
1345 else if (update_space (sl, socket, ms, lastcell, 0))
1346 mask |= 0x1; 1085 mask |= 0x1;
1086 sl << uint16 (ob->face);
1347 1087
1088 socket.send_faces (ob);
1089 }
1090 }
1091 /* Top face */
1092 else if (update_space (sl, socket, ms, lastcell, 0))
1093 mask |= 0x1;
1094
1348 /* Check to see if we are in fact sending anything for this 1095 /* Check to see if we are in fact sending anything for this
1349 * space by checking the mask. If so, update the mask. 1096 * space by checking the mask. If so, update the mask.
1350 * if not, reset the len to that from before adding the mask 1097 * if not, reset the len to that from before adding the mask
1351 * value, so we don't send those bits. 1098 * value, so we don't send those bits.
1352 */ 1099 */
1353 if (mask & 0xf) 1100 if (mask & 0xf)
1354 sl[oldlen + 1] = mask & 0xff; 1101 sl[oldlen + 1] = mask & 0xff;
1355 else 1102 else
1356 sl.reset (oldlen); 1103 sl.reset (oldlen);
1357
1358 if (socket.ext_mapinfos)
1359 esl << uint16 (emask);
1360
1361 if (socket.EMI_smooth)
1362 {
1363 for (int layer = 2+1; layer--; )
1364 {
1365 object *ob = ms.faces_obj [layer];
1366
1367 // If there is no object for this space, or if the face for the object
1368 // is the blank face, set the smoothlevel to zero.
1369 int smoothlevel = ob && ob->face != blank_face ? ob->smoothlevel : 0;
1370
1371 // We've gotten what face we want to use for the object. Now see if
1372 // if it has changed since we last sent it to the client.
1373 if (lastcell.smooth[layer] != smoothlevel)
1374 {
1375 lastcell.smooth[layer] = smoothlevel;
1376 esl << uint8 (smoothlevel);
1377 emask |= 1 << layer;
1378 }
1379 }
1380
1381 if (emask & 0xf)
1382 esl[eoldlen + 1] = emask & 0xff;
1383 else
1384 esl.reset (eoldlen);
1385 }
1386 } /* else this is a viewable space */ 1104 } /* else this is a viewable space */
1387 } /* for x loop */ 1105 ordered_mapwalk_end
1388 } /* for y loop */
1389 1106
1390 socket.flush_fx (); 1107 socket.flush_fx ();
1391
1392 /* Verify that we in fact do need to send this */
1393 if (socket.ext_mapinfos)
1394 {
1395 if (!(sl.length () > startlen || socket.sent_scroll))
1396 {
1397 /* No map data will follow, so don't say the client
1398 * it doesn't need draw!
1399 */
1400 ewhatflag &= ~EMI_NOREDRAW;
1401 esl[ewhatstart + 1] = ewhatflag & 0xff;
1402 }
1403
1404 if (esl.length () > estartlen)
1405 socket.send_packet (esl);
1406 }
1407 1108
1408 if (sl.length () > startlen || socket.sent_scroll) 1109 if (sl.length () > startlen || socket.sent_scroll)
1409 { 1110 {
1410 socket.send_packet (sl); 1111 socket.send_packet (sl);
1411 socket.sent_scroll = 0; 1112 socket.sent_scroll = 0;
1412 } 1113 }
1413} 1114}
1414 1115
1415/*****************************************************************************/
1416/* GROS: The following one is used to allow a plugin to send a generic cmd to*/
1417/* a player. Of course, the client need to know the command to be able to */
1418/* manage it ! */
1419/*****************************************************************************/
1420void
1421send_plugin_custom_message (object *pl, char *buf)
1422{
1423 pl->contr->ns->send_packet (buf);
1424}
1425
1426/**
1427 * This sends the skill number to name mapping. We ignore
1428 * the params - we always send the same info no matter what.
1429 */
1430void
1431send_skill_info (client *ns, char *params)
1432{
1433 packet sl;
1434 sl << "replyinfo skill_info\n";
1435
1436 for (int i = 1; i < NUM_SKILLS; i++)
1437 sl.printf ("%d:%s\n", i + CS_STAT_SKILLINFO, &skill_names[i]);
1438
1439 if (sl.length () > MAXSOCKBUF)
1440 {
1441 LOG (llevError, "Buffer overflow in send_skill_info!\n");
1442 fatal (0);
1443 }
1444
1445 ns->send_packet (sl);
1446}
1447
1448/**
1449 * This sends the spell path to name mapping. We ignore
1450 * the params - we always send the same info no matter what.
1451 */
1452void
1453send_spell_paths (client * ns, char *params)
1454{
1455 packet sl;
1456
1457 sl << "replyinfo spell_paths\n";
1458
1459 for (int i = 0; i < NRSPELLPATHS; i++)
1460 sl.printf ("%d:%s\n", 1 << i, spellpathnames[i]);
1461
1462 if (sl.length () > MAXSOCKBUF)
1463 {
1464 LOG (llevError, "Buffer overflow in send_spell_paths!\n");
1465 fatal (0);
1466 }
1467
1468 ns->send_packet (sl);
1469}
1470
1471/** 1116/**
1472 * This looks for any spells the player may have that have changed their stats. 1117 * This looks for any spells the player may have that have changed their stats.
1473 * it then sends an updspell packet for each spell that has changed in this way 1118 * it then sends an updspell packet for each spell that has changed in this way
1474 */ 1119 */
1475void 1120void
1476esrv_update_spells (player *pl) 1121esrv_update_spells (player *pl)
1477{ 1122{
1478 if (!pl->ns) 1123 if (!pl->ns)
1479 return; 1124 return;
1480 1125
1126 pl->ns->update_spells = false;
1127
1481 if (!pl->ns->monitor_spells) 1128 if (!pl->ns->monitor_spells)
1482 return; 1129 return;
1483 1130
1484 for (object *spell = pl->ob->inv; spell; spell = spell->below) 1131 for (object *spell = pl->ob->inv; spell; spell = spell->below)
1485 {
1486 if (spell->type == SPELL) 1132 if (spell->type == SPELL)
1487 { 1133 {
1488 int flags = 0; 1134 int flags = 0;
1135 int val;
1489 1136
1490 /* check if we need to update it */ 1137 /* check if we need to update it */
1491 if (spell->cached_sp != SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA)) 1138 val = SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA);
1139 if (spell->cached_sp != val)
1492 { 1140 {
1493 spell->cached_sp = SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA); 1141 spell->cached_sp = val;
1494 flags |= UPD_SP_MANA; 1142 flags |= UPD_SP_MANA;
1495 } 1143 }
1496 1144
1497 if (spell->cached_grace != SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE)) 1145 val = SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE);
1146 if (spell->cached_grace != val)
1498 { 1147 {
1499 spell->cached_grace = SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE); 1148 spell->cached_grace = val;
1500 flags |= UPD_SP_GRACE; 1149 flags |= UPD_SP_GRACE;
1501 } 1150 }
1502 1151
1503 if (spell->cached_eat != spell->stats.dam + SP_level_dam_adjust (pl->ob, spell)) 1152 val = casting_level (pl->ob, spell);
1153 if (spell->cached_eat != val)
1504 { 1154 {
1505 spell->cached_eat = spell->stats.dam + SP_level_dam_adjust (pl->ob, spell); 1155 spell->cached_eat = val;
1506 flags |= UPD_SP_DAMAGE; 1156 flags |= UPD_SP_LEVEL;
1507 } 1157 }
1508 1158
1509 if (flags) 1159 if (flags)
1510 { 1160 {
1511 packet sl; 1161 packet sl;
1512 1162
1513 sl << "updspell " 1163 sl << "updspell "
1514 << uint8 (flags) 1164 << uint8 (flags)
1515 << uint32 (spell->count); 1165 << uint32 (spell->count);
1516 1166
1517 if (flags & UPD_SP_MANA ) sl << uint16 (spell->cached_sp); 1167 if (flags & UPD_SP_MANA ) sl << uint16 (spell->cached_sp);
1518 if (flags & UPD_SP_GRACE ) sl << uint16 (spell->cached_grace); 1168 if (flags & UPD_SP_GRACE) sl << uint16 (spell->cached_grace);
1519 if (flags & UPD_SP_DAMAGE) sl << uint16 (spell->cached_eat); 1169 if (flags & UPD_SP_LEVEL) sl << uint16 (spell->cached_eat);
1520 1170
1521 pl->ns->send_packet (sl); 1171 pl->ns->send_packet (sl);
1522 } 1172 }
1523 } 1173 }
1524 }
1525} 1174}
1526 1175
1527void 1176void
1528esrv_remove_spell (player *pl, object *spell) 1177esrv_remove_spell (player *pl, object *spell)
1529{ 1178{
… …
1545 1194
1546/* appends the spell *spell to the Socklist we will send the data to. */ 1195/* appends the spell *spell to the Socklist we will send the data to. */
1547static void 1196static void
1548append_spell (player *pl, packet &sl, object *spell) 1197append_spell (player *pl, packet &sl, object *spell)
1549{ 1198{
1550 int i, skill = 0; 1199 int skill = 0;
1551 1200
1552 if (!(spell->name)) 1201 if (!(spell->name))
1553 { 1202 {
1554 LOG (llevError, "item number %d is a spell with no name.\n", spell->count); 1203 LOG (llevError, "item number %d is a spell with no name.\n", spell->count);
1555 return; 1204 return;
1556 } 1205 }
1557 1206
1558 /* store costs and damage in the object struct, to compare to later */ 1207 /* store costs and damage in the object struct, to compare to later */
1559 spell->cached_sp = SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA); 1208 spell->cached_sp = SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA);
1560 spell->cached_grace = SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE); 1209 spell->cached_grace = SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE);
1561 spell->cached_eat = spell->stats.dam + SP_level_dam_adjust (pl->ob, spell); 1210 spell->cached_eat = casting_level (pl->ob, spell);
1562 1211
1563 /* figure out which skill it uses, if it uses one */ 1212 /* figure out which skill it uses, if it uses one */
1564 if (spell->skill) 1213 if (spell->skill)
1565 { 1214 if (object *tmp = pl->find_skill (spell->skill))
1566 for (i = 1; i < NUM_SKILLS; i++) 1215 skill = CS_STAT_SKILLINFO + SKILL_INDEX (tmp);
1567 if (!strcmp (spell->skill, skill_names[i]))
1568 {
1569 skill = i + CS_STAT_SKILLINFO;
1570 break;
1571 }
1572 }
1573 1216
1574 // spells better have a face 1217 // spells better have a face
1575 if (!spell->face) 1218 if (!spell->face)
1576 { 1219 {
1577 LOG (llevError, "%s: spell has no face, but face is mandatory.\n", &spell->name); 1220 LOG (llevError, "%s: spell has no face, but face is mandatory.\n", &spell->name);
… …
1588 << uint16 (spell->cached_grace) 1231 << uint16 (spell->cached_grace)
1589 << uint16 (spell->cached_eat) 1232 << uint16 (spell->cached_eat)
1590 << uint8 (skill) 1233 << uint8 (skill)
1591 << uint32 (spell->path_attuned) 1234 << uint32 (spell->path_attuned)
1592 << uint32 (spell->face) 1235 << uint32 (spell->face)
1593 << data8 (spell->name) 1236 << data8 (spell->name);
1237
1238 if (pl->ns->monitor_spells < 2)
1594 << data16 (spell->msg); 1239 sl << data16 (spell->msg);
1595} 1240}
1596 1241
1597/** 1242/**
1598 * This tells the client to add the spell *ob, if *ob is NULL, then add 1243 * This tells the client to add the spell *ob, if *ob is NULL, then add
1599 * all spells in the player's inventory. 1244 * all spells in the player's inventory.
1600 */ 1245 */
1601void 1246void
1602esrv_add_spells (player *pl, object *spell) 1247esrv_add_spells (player *pl, object *spell)
1603{ 1248{
… …
1614 1259
1615 if (!spell) 1260 if (!spell)
1616 { 1261 {
1617 for (spell = pl->ob->inv; spell; spell = spell->below) 1262 for (spell = pl->ob->inv; spell; spell = spell->below)
1618 { 1263 {
1619 /* were we to simply keep appending data here, we could exceed 1264 /* were we to simply keep appending data here, we could exceed
1620 * MAXSOCKBUF if the player has enough spells to add, we know that 1265 * MAXSOCKBUF if the player has enough spells to add, we know that
1621 * append_spells will always append 19 data bytes, plus 4 length 1266 * append_spells will always append 19 data bytes, plus 4 length
1622 * bytes and 3 strings (because that is the spec) so we need to 1267 * bytes and 3 strings (because that is the spec) so we need to
1623 * check that the length of those 3 strings, plus the 23 bytes, 1268 * check that the length of those 3 strings, plus the 23 bytes,
1624 * won't take us over the length limit for the socket, if it does, 1269 * won't take us over the length limit for the socket, if it does,
1625 * we need to send what we already have, and restart packet formation 1270 * we need to send what we already have, and restart packet formation
1626 */ 1271 */
1627 if (spell->type != SPELL) 1272 if (spell->type != SPELL)
1628 continue; 1273 continue;
1629 1274
1630 /* Seeing crashes by overflowed buffers. Quick arithemetic seems 1275 /* Seeing crashes by overflowed buffers. Quick arithemetic seems
… …
1651 } 1296 }
1652 else 1297 else
1653 append_spell (pl, sl, spell); 1298 append_spell (pl, sl, spell);
1654 1299
1655 if (sl.length () > MAXSOCKBUF) 1300 if (sl.length () > MAXSOCKBUF)
1656 {
1657 LOG (llevError, "Buffer overflow in esrv_add_spells!\n"); 1301 cleanup ("buffer overflow in esrv_add_spells!");
1658 fatal (0);
1659 }
1660 1302
1661 /* finally, we can send the packet */ 1303 /* finally, we can send the packet */
1662 pl->ns->flush_fx (); 1304 pl->ns->flush_fx ();
1663 pl->ns->send_packet (sl); 1305 pl->ns->send_packet (sl);
1664} 1306}
1665 1307
1308//-GPL
1309

Diff Legend

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