ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/socket/info.C
(Generate patch)

Comparing deliantra/server/socket/info.C (file contents):
Revision 1.5 by root, Sun Sep 10 13:43:33 2006 UTC vs.
Revision 1.25 by root, Mon Dec 25 14:43:23 2006 UTC

1
2/*
3 * static char *rcsid_sock_info_c =
4 * "$Id: info.C,v 1.5 2006/09/10 13:43:33 root Exp $";
5 */
6 1
7/* 2/*
8 CrossFire, A Multiplayer game for X-windows 3 CrossFire, A Multiplayer game for X-windows
9 4
10 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
… …
22 17
23 You should have received a copy of the GNU General Public License 18 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software 19 along with this program; if not, write to the Free Software
25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 21
27 The authors can be reached via e-mail at crossfire-devel@real-time.com 22 The authors can be reached via e-mail at <crossfire@schmorp.de>
28*/ 23*/
29 24
30/** 25/**
31 * \file 26 * \file
32 * Basic client output functions. 27 * Basic client output functions.
… …
48 * much the same thing as the draw_info above, but takes a color 43 * much the same thing as the draw_info above, but takes a color
49 * parameter. the esrv_drawinfo functions should probably be 44 * parameter. the esrv_drawinfo functions should probably be
50 * replaced with this, just using black as the color. 45 * replaced with this, just using black as the color.
51 */ 46 */
52static void 47static void
53esrv_print_msg (NewSocket * ns, int color, const char *str) 48esrv_print_msg (client *ns, int color, const char *str)
54{ 49{
55 char buf[HUGE_BUF]; 50 ns->send_packet_printf ("drawinfo %d %s", color, str);
56
57 if (ns->status == Ns_Old)
58 {
59 snprintf (buf, HUGE_BUF, "%s\n", str);
60 }
61 else
62 {
63 snprintf (buf, HUGE_BUF, "drawinfo %d %s", color, str);
64 }
65
66/* LOG(llevDebug,"sending %s to socket, len=%d\n", buf, strlen(buf));*/
67 Write_String_To_Socket (ns, buf, strlen (buf));
68} 51}
69 52
70/** 53/**
71 * Draws an extended message on the client. 54 * Draws an extended message on the client.
72 * ns the socket to send message to 55 * ns the socket to send message to
… …
75 * subtype type and subtype of text message 58 * subtype type and subtype of text message
76 * intro Intro message to send with main message if client does not support the message type 59 * intro Intro message to send with main message if client does not support the message type
77 * message The main message 60 * message The main message
78 */ 61 */
79static void 62static void
80esrv_print_ext_msg (NewSocket * ns, int color, uint8 type, uint8 subtype, const char *message) 63esrv_print_ext_msg (client *ns, int color, uint8 type, uint8 subtype, const char *message)
81{ 64{
82 char buf[HUGE_BUF];
83
84 snprintf (buf, HUGE_BUF, "drawextinfo %d %hhu %hhu %s", color, type, subtype, message); 65 ns->send_packet_printf ("drawextinfo %d %hhu %hhu %s", color, type, subtype, message);
85 Write_String_To_Socket (ns, buf, strlen (buf));
86
87/* LOG(llevDebug,"sending %s to socket, len=%d", buf, strlen(buf));*/
88
89} 66}
90 67
91/** 68/**
92 * Frontend for esrv_print_msg 69 * Frontend for esrv_print_msg
93 * \param colr message color 70 * \param colr message color
… …
96 * 73 *
97 * If pl is NULL or without contr set, writes message to log. 74 * If pl is NULL or without contr set, writes message to log.
98 * 75 *
99 * Else sends message to player via esrv_print_msg 76 * Else sends message to player via esrv_print_msg
100 */ 77 */
101
102static void 78static void
103print_message (int colr, const object *pl, const char *tmp) 79print_message (int colr, const object *pl, const char *tmp)
104{ 80{
105 81 if (!tmp)
106 if (tmp == (char *) NULL)
107 {
108 tmp = "[NULL]"; 82 tmp = "[NULL]";
109 }
110 83
111 if (!pl || (pl->type == PLAYER && pl->contr == NULL)) 84 if (!pl || (pl->type == PLAYER && pl->contr == NULL))
112 return; 85 return;
113 86
114 if (pl->type == PLAYER) 87 if (pl->type == PLAYER)
115 {
116 esrv_print_msg (&pl->contr->socket, colr, (char *) tmp); 88 esrv_print_msg (pl->contr->ns, colr, (char *) tmp);
117 return;
118 }
119} 89}
120
121 90
122/** 91/**
123 * Prints out the contents of specified buffer structures, 92 * Prints out the contents of specified buffer structures,
124 * and clears the string. 93 * and clears the string.
125 */ 94 */
126
127void 95void
128flush_output_element (const object *pl, Output_Buf * outputs) 96flush_output_element (const object *pl, Output_Buf * outputs)
129{ 97{
130 char tbuf[MAX_BUF]; 98 char tbuf[MAX_BUF];
131 99
… …
155 * If found, checks if message should be sent now. 123 * If found, checks if message should be sent now.
156 * 124 *
157 * If message not already in buffers, flushes olders buffer, 125 * If message not already in buffers, flushes olders buffer,
158 * and adds message to queue. 126 * and adds message to queue.
159 */ 127 */
160
161static void 128static void
162check_output_buffers (const object *pl, const char *buf) 129check_output_buffers (const object *pl, const char *buf)
163{ 130{
164 int i, oldest = 0; 131 int i, oldest = 0;
165 132
… …
196 pl->contr->outputs[oldest].buf = buf; 163 pl->contr->outputs[oldest].buf = buf;
197 } 164 }
198 } 165 }
199} 166}
200 167
201
202
203/** 168/**
204 * Sends message to player(s). 169 * Sends message to player(s).
205 * 170 *
206 * flags is various flags - mostly color, plus a few specials. 171 * flags is various flags - mostly color, plus a few specials.
207 * 172 *
… …
218 */ 183 */
219 184
220void 185void
221new_draw_info (int flags, int pri, const object *pl, const char *buf) 186new_draw_info (int flags, int pri, const object *pl, const char *buf)
222{ 187{
223
224 if (flags & NDI_ALL) 188 if (flags & NDI_ALL)
225 { 189 {
226 player *tmppl; 190 player *tmppl;
227 int i;
228 191
229 for (tmppl = first_player; tmppl != NULL; tmppl = tmppl->next) 192 for_all_players (pl)
230 new_draw_info ((flags & ~NDI_ALL), pri, tmppl->ob, buf); 193 new_draw_info ((flags & ~NDI_ALL), pri, tmppl->ob, buf);
231 194
232 for (i = 1; i < socket_info.allocated_sockets; i++)
233 {
234 if (init_sockets[i].status == Ns_Old && init_sockets[i].old_mode != Old_Listen && pri < 10)
235 {
236 cs_write_string (&init_sockets[i], buf, strlen (buf));
237 /* Most messages don't have a newline, so add one */
238 cs_write_string (&init_sockets[i], "\n", 1);
239 }
240 }
241
242 return; 195 return;
243 } 196 }
197
244 if (!pl || (pl->type == PLAYER && pl->contr == NULL)) 198 if (!pl || (pl->type == PLAYER && pl->contr == NULL))
245 { 199 {
246 /* Write to the socket? */ 200 /* Write to the socket? */
247 print_message (0, NULL, buf); 201 print_message (0, NULL, buf);
248 return; 202 return;
249 } 203 }
204
250 if (pl->type != PLAYER) 205 if (pl->type != PLAYER)
251 return; 206 return;
207
252 if (pri >= pl->contr->listening) 208 if (pri >= pl->contr->listening)
253 return; 209 return;
254 210
255 if ((flags & NDI_COLOR_MASK) == NDI_BLACK && !(flags & NDI_UNIQUE)) 211 if ((flags & NDI_COLOR_MASK) == NDI_BLACK && !(flags & NDI_UNIQUE))
256 {
257 /* following prints stuff out, as appropriate */ 212 /* following prints stuff out, as appropriate */
258 check_output_buffers (pl, buf); 213 check_output_buffers (pl, buf);
259 }
260 else 214 else
261 {
262 print_message (flags & NDI_COLOR_MASK, pl, buf); 215 print_message (flags & NDI_COLOR_MASK, pl, buf);
263 }
264} 216}
265 217
266/** 218/**
267 * Wrapper for new_draw_info printf-like. 219 * Wrapper for new_draw_info printf-like.
268 * 220 *
269 * This is a pretty trivial function, but it allows us to use printf style 221 * This is a pretty trivial function, but it allows us to use printf style
270 * formatting, so instead of the calling function having to do it, we do 222 * formatting, so instead of the calling function having to do it, we do
271 * it here. It may also have advantages in the future for reduction of 223 * it here. It may also have advantages in the future for reduction of
272 * client/server bandwidth (client could keep track of various strings 224 * client/server bandwidth (client could keep track of various strings
273 */ 225 */
274
275void 226void
276new_draw_info_format (int flags, int pri, const object *pl, const char *format, ...) 227new_draw_info_format (int flags, int pri, const object *pl, const char *format, ...)
277{ 228{
278 char buf[HUGE_BUF]; 229 char buf[HUGE_BUF];
279 230
… …
286 va_end (ap); 237 va_end (ap);
287 238
288 new_draw_info (flags, pri, pl, buf); 239 new_draw_info (flags, pri, pl, buf);
289} 240}
290 241
291
292void 242void
293draw_ext_info (int flags, int pri, const object *pl, uint8 type, uint8 subtype, const char *message, const char *oldmessage) 243draw_ext_info (int flags, int pri, const object *pl, uint8 type, uint8 subtype, const char *message, const char *oldmessage)
294{ 244{
295 245
296 if (!pl || (pl->type != PLAYER) || (pl->contr == NULL)) 246 if (!pl || (pl->type != PLAYER) || (pl->contr == NULL))
297 return; 247 return;
298 248
299 if (pri >= pl->contr->listening) 249 if (pri >= pl->contr->listening)
300 return; 250 return;
251
301 if (!CLIENT_SUPPORT_READABLES (&pl->contr->socket, type)) 252 if (!CLIENT_SUPPORT_READABLES (pl->contr->ns, type))
302 { 253 {
303 char *buf = (char *) malloc (strlen (oldmessage == NULL ? message : oldmessage) + 1); 254 char *buf = (char *) malloc (strlen (oldmessage == NULL ? message : oldmessage) + 1);
304 255
305 if (buf == NULL) 256 if (buf == NULL)
306 LOG (llevError, "info::draw_ext_info -> Out of memory!"); 257 LOG (llevError, "info::draw_ext_info -> Out of memory!");
… …
311 new_draw_info (flags, pri, pl, buf); 262 new_draw_info (flags, pri, pl, buf);
312 free (buf); 263 free (buf);
313 } 264 }
314 } 265 }
315 else 266 else
316 {
317 esrv_print_ext_msg (&pl->contr->socket, flags & NDI_COLOR_MASK, type, subtype, message); 267 esrv_print_ext_msg (pl->contr->ns, flags & NDI_COLOR_MASK, type, subtype, message);
318 }
319} 268}
320 269
321void 270void
322draw_ext_info_format (int flags, int pri, const object *pl, uint8 type, uint8 subtype, const char *old_format, char *new_format, ...) 271draw_ext_info_format (int flags, int pri, const object *pl, uint8 type, uint8 subtype, const char *old_format, char *new_format, ...)
323{ 272{
… …
327 if (!pl || (pl->type != PLAYER) || (pl->contr == NULL)) 276 if (!pl || (pl->type != PLAYER) || (pl->contr == NULL))
328 return; 277 return;
329 278
330 if (pri >= pl->contr->listening) 279 if (pri >= pl->contr->listening)
331 return; 280 return;
281
332 if (!CLIENT_SUPPORT_READABLES (&pl->contr->socket, type)) 282 if (!CLIENT_SUPPORT_READABLES (pl->contr->ns, type))
333 { 283 {
334 va_list ap; 284 va_list ap;
335 285
336 LOG (llevDebug, "Non supported extension text type for client.\n"); 286 LOG (llevDebug, "Non supported extension text type for client.\n");
337 va_start (ap, new_format); 287 va_start (ap, new_format);
… …
346 296
347 va_start (ap, new_format); 297 va_start (ap, new_format);
348 vsnprintf (buf, HUGE_BUF, new_format, ap); 298 vsnprintf (buf, HUGE_BUF, new_format, ap);
349 va_end (ap); 299 va_end (ap);
350 strip_media_tag (buf); 300 strip_media_tag (buf);
351 esrv_print_ext_msg (&pl->contr->socket, flags & NDI_COLOR_MASK, type, subtype, buf); 301 esrv_print_ext_msg (pl->contr->ns, flags & NDI_COLOR_MASK, type, subtype, buf);
352 } 302 }
353} 303}
354 304
355/** 305/**
356 * Writes to everyone on the map *except* op. This is useful for emotions. 306 * Writes to everyone on the map *except* op. This is useful for emotions.
357 */ 307 */
358 308
359void 309void
360new_info_map_except (int color, mapstruct *map, object *op, const char *str) 310new_info_map_except (int color, maptile * map, object *op, const char *str)
361{ 311{
362 player *pl; 312 player *pl;
363 313
364 for (pl = first_player; pl != NULL; pl = pl->next) 314 for_all_players (pl)
365 if (pl->ob != NULL && pl->ob->map == map && pl->ob != op) 315 if (pl->ob != NULL && pl->ob->map == map && pl->ob != op)
366 { 316 {
367 new_draw_info (color, 0, pl->ob, str); 317 new_draw_info (color, 0, pl->ob, str);
368 } 318 }
369} 319}
… …
371/** 321/**
372 * Writes to everyone on the map except op1 and op2 322 * Writes to everyone on the map except op1 and op2
373 */ 323 */
374 324
375void 325void
376new_info_map_except2 (int color, mapstruct *map, object *op1, object *op2, const char *str) 326new_info_map_except2 (int color, maptile * map, object *op1, object *op2, const char *str)
377{ 327{
378 player *pl; 328 player *pl;
379 329
380 for (pl = first_player; pl != NULL; pl = pl->next) 330 for_all_players (pl)
381 if (pl->ob != NULL && pl->ob->map == map && pl->ob != op1 && pl->ob != op2) 331 if (pl->ob != NULL && pl->ob->map == map && pl->ob != op1 && pl->ob != op2)
382 { 332 {
383 new_draw_info (color, 0, pl->ob, str); 333 new_draw_info (color, 0, pl->ob, str);
384 } 334 }
385} 335}
… …
387/** 337/**
388 * Writes to everyone on the specified map 338 * Writes to everyone on the specified map
389 */ 339 */
390 340
391void 341void
392new_info_map (int color, mapstruct *map, const char *str) 342new_info_map (int color, maptile * map, const char *str)
393{ 343{
394 player *pl; 344 player *pl;
395 345
396 for (pl = first_player; pl != NULL; pl = pl->next) 346 for_all_players (pl)
397 if (pl->ob != NULL && pl->ob->map == map) 347 if (pl->ob != NULL && pl->ob->map == map)
398 { 348 {
399 new_draw_info (color, 0, pl->ob, str); 349 new_draw_info (color, 0, pl->ob, str);
400 } 350 }
401} 351}
… …
417void 367void
418rangetostring (object *pl, char *obuf) 368rangetostring (object *pl, char *obuf)
419{ 369{
420 switch (pl->contr->shoottype) 370 switch (pl->contr->shoottype)
421 { 371 {
422 case range_none: 372 case range_none:
423 strcpy (obuf, "Range: nothing"); 373 strcpy (obuf, "Range: nothing");
424 break; 374 break;
425 375
426 case range_bow: 376 case range_bow:
377 {
378 object *op;
379
380 for (op = pl->inv; op; op = op->below)
381 if (op->type == BOW && QUERY_FLAG (op, FLAG_APPLIED))
382 break;
383
384 if (op == NULL)
385 break;
386
387 sprintf (obuf, "Range: %s (%s)", query_base_name (op, 0), op->race ? (const char *) op->race : "nothing");
388 }
389 break;
390
391 case range_magic:
392 if (settings.casting_time == TRUE)
427 { 393 {
428 object *op; 394 if (pl->casting_time > -1)
429 395 {
430 for (op = pl->inv; op; op = op->below) 396 if (pl->casting_time == 0)
431 if (op->type == BOW && QUERY_FLAG (op, FLAG_APPLIED)) 397 sprintf (obuf, "Range: Holding spell (%s)", &pl->spell->name);
432 break; 398 else
433 if (op == NULL) 399 sprintf (obuf, "Range: Casting spell (%s)", &pl->spell->name);
434 break; 400 }
435 401 else
436 sprintf (obuf, "Range: %s (%s)", query_base_name (op, 0), op->race ? (const char *) op->race : "nothing"); 402 sprintf (obuf, "Range: spell (%s)", &pl->contr->ranges[range_magic]->name);
437 } 403 }
438 break;
439
440 case range_magic:
441 if (settings.casting_time == TRUE)
442 {
443 if (pl->casting_time > -1)
444 {
445 if (pl->casting_time == 0)
446 sprintf (obuf, "Range: Holding spell (%s)", (const char *) pl->spell->name);
447 else
448 sprintf (obuf, "Range: Casting spell (%s)", (const char *) pl->spell->name);
449 }
450 else
451 sprintf (obuf, "Range: spell (%s)", &pl->contr->ranges[range_magic]->name);
452 }
453 else 404 else
454 sprintf (obuf, "Range: spell (%s)", &pl->contr->ranges[range_magic]->name); 405 sprintf (obuf, "Range: spell (%s)", &pl->contr->ranges[range_magic]->name);
455 break; 406 break;
456 407
457 case range_misc: 408 case range_misc:
458 sprintf (obuf, "Range: %s", pl->contr->ranges[range_misc] ? query_base_name (pl->contr->ranges[range_misc], 0) : "none"); 409 sprintf (obuf, "Range: %s", pl->contr->ranges[range_misc] ? query_base_name (pl->contr->ranges[range_misc], 0) : "none");
459 break; 410 break;
460 411
461 /* range_scroll is only used for controlling golems. If the 412 /* range_scroll is only used for controlling golems. If the
462 * the player does not have a golem, reset some things. 413 * the player does not have a golem, reset some things.
463 */ 414 */
464 case range_golem: 415 case range_golem:
465 if (pl->contr->ranges[range_golem] != NULL) 416 if (pl->contr->ranges[range_golem] != NULL)
466 sprintf (obuf, "Range: golem (%s)", &pl->contr->ranges[range_golem]->name); 417 sprintf (obuf, "Range: golem (%s)", &pl->contr->ranges[range_golem]->name);
467 else 418 else
468 { 419 {
469 pl->contr->shoottype = range_none; 420 pl->contr->shoottype = range_none;
470 strcpy (obuf, "Range: nothing"); 421 strcpy (obuf, "Range: nothing");
471 } 422 }
472 break; 423 break;
473 424
474 case range_skill: 425 case range_skill:
475 sprintf (obuf, "Skill: %s", pl->chosen_skill != NULL ? (const char *) pl->chosen_skill->name : "none"); 426 sprintf (obuf, "Skill: %s", pl->chosen_skill != NULL ? (const char *) pl->chosen_skill->name : "none");
476 break; 427 break;
477 428
478 case range_builder: 429 case range_builder:
479 sprintf (obuf, "Builder: %s", query_base_name (pl->contr->ranges[range_builder], 0)); 430 sprintf (obuf, "Builder: %s", query_base_name (pl->contr->ranges[range_builder], 0));
480 break; 431 break;
481 432
482 default: 433 default:
483 strcpy (obuf, "Range: illegal"); 434 strcpy (obuf, "Range: illegal");
484 } 435 }
485} 436}
486 437
487/** 438/**
488 * Sets player title. 439 * Sets player title.
… …
512static void 463static void
513magic_mapping_mark_recursive (object *pl, char *map_mark, int px, int py) 464magic_mapping_mark_recursive (object *pl, char *map_mark, int px, int py)
514{ 465{
515 int x, y, dx, dy, mflags; 466 int x, y, dx, dy, mflags;
516 sint16 nx, ny; 467 sint16 nx, ny;
517 mapstruct *mp; 468 maptile *mp;
518 New_Face *f; 469 New_Face *f;
519 470
520 for (dx = -1; dx <= 1; dx++) 471 for (dx = -1; dx <= 1; dx++)
521 { 472 {
522 for (dy = -1; dy <= 1; dy++) 473 for (dy = -1; dy <= 1; dy++)
… …
578void 529void
579magic_mapping_mark (object *pl, char *map_mark, int strength) 530magic_mapping_mark (object *pl, char *map_mark, int strength)
580{ 531{
581 int x, y, mflags; 532 int x, y, mflags;
582 sint16 nx, ny; 533 sint16 nx, ny;
583 mapstruct *mp; 534 maptile *mp;
584 New_Face *f; 535 New_Face *f;
585 536
586 for (x = -strength; x < strength; x++) 537 for (x = -strength; x < strength; x++)
587 { 538 {
588 for (y = -strength; y < strength; y++) 539 for (y = -strength; y < strength; y++)
… …
611 } 562 }
612 } 563 }
613 } 564 }
614} 565}
615 566
616
617/** 567/**
618 * Creates and sends magic map to player. 568 * Creates and sends magic map to player.
619 * 569 *
620 * The following function is a lot messier than it really should be, 570 * The following function is a lot messier than it really should be,
621 * but there is no real easy solution. 571 * but there is no real easy solution.
… …
624 */ 574 */
625 575
626void 576void
627draw_magic_map (object *pl) 577draw_magic_map (object *pl)
628{ 578{
629 int x, y;
630 char *map_mark = (char *) calloc (MAGIC_MAP_SIZE * MAGIC_MAP_SIZE, 1); 579 char *map_mark = (char *)calloc (MAGIC_MAP_SIZE * MAGIC_MAP_SIZE, 1);
631 int xmin, xmax, ymin, ymax; 580 int xmin, xmax, ymin, ymax;
632 SockList sl;
633 581
634 if (pl->type != PLAYER) 582 if (pl->type != PLAYER)
635 { 583 {
636 LOG (llevError, "Non player object called draw_map.\n"); 584 LOG (llevError, "Non player object called draw_map.\n");
637 return; 585 return;
… …
647 */ 595 */
648 xmin = MAGIC_MAP_SIZE; 596 xmin = MAGIC_MAP_SIZE;
649 ymin = MAGIC_MAP_SIZE; 597 ymin = MAGIC_MAP_SIZE;
650 xmax = 0; 598 xmax = 0;
651 ymax = 0; 599 ymax = 0;
600
652 for (x = 0; x < MAGIC_MAP_SIZE; x++) 601 for (int x = 0; x < MAGIC_MAP_SIZE; x++)
653 {
654 for (y = 0; y < MAGIC_MAP_SIZE; y++) 602 for (int y = 0; y < MAGIC_MAP_SIZE; y++)
655 {
656 if (map_mark[x + MAP_WIDTH (pl->map) * y] | FACE_FLOOR) 603 if (map_mark[x + pl->map->width * y] | FACE_FLOOR)
657 { 604 {
658 xmin = x < xmin ? x : xmin; 605 xmin = x < xmin ? x : xmin;
659 xmax = x > xmax ? x : xmax; 606 xmax = x > xmax ? x : xmax;
660 ymin = y < ymin ? y : ymin; 607 ymin = y < ymin ? y : ymin;
661 ymax = y > ymax ? y : ymax; 608 ymax = y > ymax ? y : ymax;
662 } 609 }
663 }
664 }
665 610
666 sl.buf = (unsigned char *) malloc (MAXSOCKBUF); 611 packet sl;
667 snprintf ((char *) sl.buf, MAXSOCKBUF, "magicmap %d %d %d %d ", (xmax - xmin + 1), (ymax - ymin + 1), 612 sl.printf ("magicmap %d %d %d %d ", (xmax - xmin + 1), (ymax - ymin + 1),
668 MAGIC_MAP_HALF - xmin, MAGIC_MAP_HALF - ymin); 613 MAGIC_MAP_HALF - xmin, MAGIC_MAP_HALF - ymin);
669 sl.len = strlen ((char *) sl.buf);
670 614
671 for (y = ymin; y <= ymax; y++) 615 for (int y = ymin; y <= ymax; y++)
672 {
673 for (x = xmin; x <= xmax; x++) 616 for (int x = xmin; x <= xmax; x++)
674 {
675 sl.buf[sl.len++] = map_mark[x + MAGIC_MAP_SIZE * y] & ~FACE_FLOOR; 617 sl << uint8 (map_mark[x + MAGIC_MAP_SIZE * y] & ~FACE_FLOOR);
676 } /* x loop */
677 } /* y loop */
678 618
679 Send_With_Handling (&pl->contr->socket, &sl); 619 pl->contr->ns->send_packet (sl);
680 free (sl.buf); 620
681 free (map_mark); 621 free (map_mark);
682} 622}
683 623
684
685/** 624/**
686 * Send a kill log record to sockets 625 * Send a kill log record to sockets
687 */ 626 */
688
689void 627void
690Log_Kill (const char *Who, const char *What, int WhatType, const char *With, int WithType) 628Log_Kill (const char *Who, const char *What, int WhatType, const char *With, int WithType)
691{ 629{
692 int i;
693 size_t len; 630 size_t len;
694 char buf[MAX_BUF]; 631 char buf[MAX_BUF];
695 632
696 if (With != NULL) 633 if (With != NULL)
697 {
698 snprintf (buf, MAX_BUF, "%s\t%s\t%d\t%s\t%d\n", Who, What, WhatType, With, WithType); 634 snprintf (buf, MAX_BUF, "%s\t%s\t%d\t%s\t%d\n", Who, What, WhatType, With, WithType);
699 }
700 else 635 else
701 {
702 snprintf (buf, MAX_BUF, "%s\t%s\t%d\n", Who, What, WhatType); 636 snprintf (buf, MAX_BUF, "%s\t%s\t%d\n", Who, What, WhatType);
703 } 637
704 len = strlen (buf); 638 len = strlen (buf);
705 for (i = 1; i < socket_info.allocated_sockets; i++)
706 {
707 if (init_sockets[i].old_mode == Old_Listen)
708 {
709 cs_write_string (&init_sockets[i], buf, len);
710 }
711 }
712} 639}
640

Diff Legend

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