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.27 by root, Tue Dec 26 17:11:40 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 for_all_players (pl)
227 int i;
228
229 for (tmppl = first_player; tmppl != NULL; tmppl = tmppl->next)
230 new_draw_info ((flags & ~NDI_ALL), pri, tmppl->ob, buf); 191 new_draw_info (flags & ~NDI_ALL, pri, pl->ob, buf);
231
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 192
242 return; 193 return;
243 } 194 }
195
244 if (!pl || (pl->type == PLAYER && pl->contr == NULL)) 196 if (!pl || (pl->type == PLAYER && pl->contr == NULL))
245 { 197 {
246 /* Write to the socket? */ 198 /* Write to the socket? */
247 print_message (0, NULL, buf); 199 print_message (0, NULL, buf);
248 return; 200 return;
249 } 201 }
202
250 if (pl->type != PLAYER) 203 if (pl->type != PLAYER)
251 return; 204 return;
205
252 if (pri >= pl->contr->listening) 206 if (pri >= pl->contr->listening)
253 return; 207 return;
254 208
255 if ((flags & NDI_COLOR_MASK) == NDI_BLACK && !(flags & NDI_UNIQUE)) 209 if ((flags & NDI_COLOR_MASK) == NDI_BLACK && !(flags & NDI_UNIQUE))
256 {
257 /* following prints stuff out, as appropriate */ 210 /* following prints stuff out, as appropriate */
258 check_output_buffers (pl, buf); 211 check_output_buffers (pl, buf);
259 }
260 else 212 else
261 {
262 print_message (flags & NDI_COLOR_MASK, pl, buf); 213 print_message (flags & NDI_COLOR_MASK, pl, buf);
263 }
264} 214}
265 215
266/** 216/**
267 * Wrapper for new_draw_info printf-like. 217 * Wrapper for new_draw_info printf-like.
268 * 218 *
269 * This is a pretty trivial function, but it allows us to use printf style 219 * 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 220 * 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 221 * it here. It may also have advantages in the future for reduction of
272 * client/server bandwidth (client could keep track of various strings 222 * client/server bandwidth (client could keep track of various strings
273 */ 223 */
274
275void 224void
276new_draw_info_format (int flags, int pri, const object *pl, const char *format, ...) 225new_draw_info_format (int flags, int pri, const object *pl, const char *format, ...)
277{ 226{
278 char buf[HUGE_BUF]; 227 char buf[HUGE_BUF];
279 228
… …
286 va_end (ap); 235 va_end (ap);
287 236
288 new_draw_info (flags, pri, pl, buf); 237 new_draw_info (flags, pri, pl, buf);
289} 238}
290 239
291
292void 240void
293draw_ext_info (int flags, int pri, const object *pl, uint8 type, uint8 subtype, const char *message, const char *oldmessage) 241draw_ext_info (int flags, int pri, const object *pl, uint8 type, uint8 subtype, const char *message, const char *oldmessage)
294{ 242{
295 243
296 if (!pl || (pl->type != PLAYER) || (pl->contr == NULL)) 244 if (!pl || (pl->type != PLAYER) || (pl->contr == NULL))
297 return; 245 return;
298 246
299 if (pri >= pl->contr->listening) 247 if (pri >= pl->contr->listening)
300 return; 248 return;
249
301 if (!CLIENT_SUPPORT_READABLES (&pl->contr->socket, type)) 250 if (!CLIENT_SUPPORT_READABLES (pl->contr->ns, type))
302 { 251 {
303 char *buf = (char *) malloc (strlen (oldmessage == NULL ? message : oldmessage) + 1); 252 char *buf = (char *) malloc (strlen (oldmessage == NULL ? message : oldmessage) + 1);
304 253
305 if (buf == NULL) 254 if (buf == NULL)
306 LOG (llevError, "info::draw_ext_info -> Out of memory!"); 255 LOG (llevError, "info::draw_ext_info -> Out of memory!");
… …
311 new_draw_info (flags, pri, pl, buf); 260 new_draw_info (flags, pri, pl, buf);
312 free (buf); 261 free (buf);
313 } 262 }
314 } 263 }
315 else 264 else
316 {
317 esrv_print_ext_msg (&pl->contr->socket, flags & NDI_COLOR_MASK, type, subtype, message); 265 esrv_print_ext_msg (pl->contr->ns, flags & NDI_COLOR_MASK, type, subtype, message);
318 }
319} 266}
320 267
321void 268void
322draw_ext_info_format (int flags, int pri, const object *pl, uint8 type, uint8 subtype, const char *old_format, char *new_format, ...) 269draw_ext_info_format (int flags, int pri, const object *pl, uint8 type, uint8 subtype, const char *old_format, char *new_format, ...)
323{ 270{
… …
327 if (!pl || (pl->type != PLAYER) || (pl->contr == NULL)) 274 if (!pl || (pl->type != PLAYER) || (pl->contr == NULL))
328 return; 275 return;
329 276
330 if (pri >= pl->contr->listening) 277 if (pri >= pl->contr->listening)
331 return; 278 return;
279
332 if (!CLIENT_SUPPORT_READABLES (&pl->contr->socket, type)) 280 if (!CLIENT_SUPPORT_READABLES (pl->contr->ns, type))
333 { 281 {
334 va_list ap; 282 va_list ap;
335 283
336 LOG (llevDebug, "Non supported extension text type for client.\n"); 284 LOG (llevDebug, "Non supported extension text type for client.\n");
337 va_start (ap, new_format); 285 va_start (ap, new_format);
… …
346 294
347 va_start (ap, new_format); 295 va_start (ap, new_format);
348 vsnprintf (buf, HUGE_BUF, new_format, ap); 296 vsnprintf (buf, HUGE_BUF, new_format, ap);
349 va_end (ap); 297 va_end (ap);
350 strip_media_tag (buf); 298 strip_media_tag (buf);
351 esrv_print_ext_msg (&pl->contr->socket, flags & NDI_COLOR_MASK, type, subtype, buf); 299 esrv_print_ext_msg (pl->contr->ns, flags & NDI_COLOR_MASK, type, subtype, buf);
352 } 300 }
353} 301}
354 302
355/** 303/**
356 * Writes to everyone on the map *except* op. This is useful for emotions. 304 * Writes to everyone on the map *except* op. This is useful for emotions.
357 */ 305 */
358 306
359void 307void
360new_info_map_except (int color, mapstruct *map, object *op, const char *str) 308new_info_map_except (int color, maptile * map, object *op, const char *str)
361{ 309{
362 player *pl; 310 player *pl;
363 311
364 for (pl = first_player; pl != NULL; pl = pl->next) 312 for_all_players (pl)
365 if (pl->ob != NULL && pl->ob->map == map && pl->ob != op) 313 if (pl->ob != NULL && pl->ob->map == map && pl->ob != op)
366 { 314 {
367 new_draw_info (color, 0, pl->ob, str); 315 new_draw_info (color, 0, pl->ob, str);
368 } 316 }
369} 317}
… …
371/** 319/**
372 * Writes to everyone on the map except op1 and op2 320 * Writes to everyone on the map except op1 and op2
373 */ 321 */
374 322
375void 323void
376new_info_map_except2 (int color, mapstruct *map, object *op1, object *op2, const char *str) 324new_info_map_except2 (int color, maptile * map, object *op1, object *op2, const char *str)
377{ 325{
378 player *pl; 326 player *pl;
379 327
380 for (pl = first_player; pl != NULL; pl = pl->next) 328 for_all_players (pl)
381 if (pl->ob != NULL && pl->ob->map == map && pl->ob != op1 && pl->ob != op2) 329 if (pl->ob != NULL && pl->ob->map == map && pl->ob != op1 && pl->ob != op2)
382 { 330 {
383 new_draw_info (color, 0, pl->ob, str); 331 new_draw_info (color, 0, pl->ob, str);
384 } 332 }
385} 333}
… …
387/** 335/**
388 * Writes to everyone on the specified map 336 * Writes to everyone on the specified map
389 */ 337 */
390 338
391void 339void
392new_info_map (int color, mapstruct *map, const char *str) 340new_info_map (int color, maptile * map, const char *str)
393{ 341{
394 player *pl; 342 player *pl;
395 343
396 for (pl = first_player; pl != NULL; pl = pl->next) 344 for_all_players (pl)
397 if (pl->ob != NULL && pl->ob->map == map) 345 if (pl->ob != NULL && pl->ob->map == map)
398 { 346 {
399 new_draw_info (color, 0, pl->ob, str); 347 new_draw_info (color, 0, pl->ob, str);
400 } 348 }
401} 349}
… …
417void 365void
418rangetostring (object *pl, char *obuf) 366rangetostring (object *pl, char *obuf)
419{ 367{
420 switch (pl->contr->shoottype) 368 switch (pl->contr->shoottype)
421 { 369 {
422 case range_none: 370 case range_none:
423 strcpy (obuf, "Range: nothing"); 371 strcpy (obuf, "Range: nothing");
424 break; 372 break;
425 373
426 case range_bow: 374 case range_bow:
375 {
376 object *op;
377
378 for (op = pl->inv; op; op = op->below)
379 if (op->type == BOW && QUERY_FLAG (op, FLAG_APPLIED))
380 break;
381
382 if (op == NULL)
383 break;
384
385 sprintf (obuf, "Range: %s (%s)", query_base_name (op, 0), op->race ? (const char *) op->race : "nothing");
386 }
387 break;
388
389 case range_magic:
390 if (settings.casting_time == TRUE)
427 { 391 {
428 object *op; 392 if (pl->casting_time > -1)
429 393 {
430 for (op = pl->inv; op; op = op->below) 394 if (pl->casting_time == 0)
431 if (op->type == BOW && QUERY_FLAG (op, FLAG_APPLIED)) 395 sprintf (obuf, "Range: Holding spell (%s)", &pl->spell->name);
432 break; 396 else
433 if (op == NULL) 397 sprintf (obuf, "Range: Casting spell (%s)", &pl->spell->name);
434 break; 398 }
435 399 else
436 sprintf (obuf, "Range: %s (%s)", query_base_name (op, 0), op->race ? (const char *) op->race : "nothing"); 400 sprintf (obuf, "Range: spell (%s)", &pl->contr->ranges[range_magic]->name);
437 } 401 }
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 402 else
454 sprintf (obuf, "Range: spell (%s)", &pl->contr->ranges[range_magic]->name); 403 sprintf (obuf, "Range: spell (%s)", &pl->contr->ranges[range_magic]->name);
455 break; 404 break;
456 405
457 case range_misc: 406 case range_misc:
458 sprintf (obuf, "Range: %s", pl->contr->ranges[range_misc] ? query_base_name (pl->contr->ranges[range_misc], 0) : "none"); 407 sprintf (obuf, "Range: %s", pl->contr->ranges[range_misc] ? query_base_name (pl->contr->ranges[range_misc], 0) : "none");
459 break; 408 break;
460 409
461 /* range_scroll is only used for controlling golems. If the 410 /* range_scroll is only used for controlling golems. If the
462 * the player does not have a golem, reset some things. 411 * the player does not have a golem, reset some things.
463 */ 412 */
464 case range_golem: 413 case range_golem:
465 if (pl->contr->ranges[range_golem] != NULL) 414 if (pl->contr->ranges[range_golem] != NULL)
466 sprintf (obuf, "Range: golem (%s)", &pl->contr->ranges[range_golem]->name); 415 sprintf (obuf, "Range: golem (%s)", &pl->contr->ranges[range_golem]->name);
467 else 416 else
468 { 417 {
469 pl->contr->shoottype = range_none; 418 pl->contr->shoottype = range_none;
470 strcpy (obuf, "Range: nothing"); 419 strcpy (obuf, "Range: nothing");
471 } 420 }
472 break; 421 break;
473 422
474 case range_skill: 423 case range_skill:
475 sprintf (obuf, "Skill: %s", pl->chosen_skill != NULL ? (const char *) pl->chosen_skill->name : "none"); 424 sprintf (obuf, "Skill: %s", pl->chosen_skill != NULL ? (const char *) pl->chosen_skill->name : "none");
476 break; 425 break;
477 426
478 case range_builder: 427 case range_builder:
479 sprintf (obuf, "Builder: %s", query_base_name (pl->contr->ranges[range_builder], 0)); 428 sprintf (obuf, "Builder: %s", query_base_name (pl->contr->ranges[range_builder], 0));
480 break; 429 break;
481 430
482 default: 431 default:
483 strcpy (obuf, "Range: illegal"); 432 strcpy (obuf, "Range: illegal");
484 } 433 }
485} 434}
486 435
487/** 436/**
488 * Sets player title. 437 * Sets player title.
… …
512static void 461static void
513magic_mapping_mark_recursive (object *pl, char *map_mark, int px, int py) 462magic_mapping_mark_recursive (object *pl, char *map_mark, int px, int py)
514{ 463{
515 int x, y, dx, dy, mflags; 464 int x, y, dx, dy, mflags;
516 sint16 nx, ny; 465 sint16 nx, ny;
517 mapstruct *mp; 466 maptile *mp;
518 New_Face *f; 467 New_Face *f;
519 468
520 for (dx = -1; dx <= 1; dx++) 469 for (dx = -1; dx <= 1; dx++)
521 { 470 {
522 for (dy = -1; dy <= 1; dy++) 471 for (dy = -1; dy <= 1; dy++)
… …
578void 527void
579magic_mapping_mark (object *pl, char *map_mark, int strength) 528magic_mapping_mark (object *pl, char *map_mark, int strength)
580{ 529{
581 int x, y, mflags; 530 int x, y, mflags;
582 sint16 nx, ny; 531 sint16 nx, ny;
583 mapstruct *mp; 532 maptile *mp;
584 New_Face *f; 533 New_Face *f;
585 534
586 for (x = -strength; x < strength; x++) 535 for (x = -strength; x < strength; x++)
587 { 536 {
588 for (y = -strength; y < strength; y++) 537 for (y = -strength; y < strength; y++)
… …
611 } 560 }
612 } 561 }
613 } 562 }
614} 563}
615 564
616
617/** 565/**
618 * Creates and sends magic map to player. 566 * Creates and sends magic map to player.
619 * 567 *
620 * The following function is a lot messier than it really should be, 568 * The following function is a lot messier than it really should be,
621 * but there is no real easy solution. 569 * but there is no real easy solution.
… …
624 */ 572 */
625 573
626void 574void
627draw_magic_map (object *pl) 575draw_magic_map (object *pl)
628{ 576{
629 int x, y;
630 char *map_mark = (char *) calloc (MAGIC_MAP_SIZE * MAGIC_MAP_SIZE, 1); 577 char *map_mark = (char *)calloc (MAGIC_MAP_SIZE * MAGIC_MAP_SIZE, 1);
631 int xmin, xmax, ymin, ymax; 578 int xmin, xmax, ymin, ymax;
632 SockList sl;
633 579
634 if (pl->type != PLAYER) 580 if (pl->type != PLAYER)
635 { 581 {
636 LOG (llevError, "Non player object called draw_map.\n"); 582 LOG (llevError, "Non player object called draw_map.\n");
637 return; 583 return;
… …
647 */ 593 */
648 xmin = MAGIC_MAP_SIZE; 594 xmin = MAGIC_MAP_SIZE;
649 ymin = MAGIC_MAP_SIZE; 595 ymin = MAGIC_MAP_SIZE;
650 xmax = 0; 596 xmax = 0;
651 ymax = 0; 597 ymax = 0;
598
652 for (x = 0; x < MAGIC_MAP_SIZE; x++) 599 for (int x = 0; x < MAGIC_MAP_SIZE; x++)
653 {
654 for (y = 0; y < MAGIC_MAP_SIZE; y++) 600 for (int y = 0; y < MAGIC_MAP_SIZE; y++)
655 {
656 if (map_mark[x + MAP_WIDTH (pl->map) * y] | FACE_FLOOR) 601 if (map_mark[x + pl->map->width * y] | FACE_FLOOR)
657 { 602 {
658 xmin = x < xmin ? x : xmin; 603 xmin = x < xmin ? x : xmin;
659 xmax = x > xmax ? x : xmax; 604 xmax = x > xmax ? x : xmax;
660 ymin = y < ymin ? y : ymin; 605 ymin = y < ymin ? y : ymin;
661 ymax = y > ymax ? y : ymax; 606 ymax = y > ymax ? y : ymax;
662 } 607 }
663 }
664 }
665 608
666 sl.buf = (unsigned char *) malloc (MAXSOCKBUF); 609 packet sl;
667 snprintf ((char *) sl.buf, MAXSOCKBUF, "magicmap %d %d %d %d ", (xmax - xmin + 1), (ymax - ymin + 1), 610 sl.printf ("magicmap %d %d %d %d ", (xmax - xmin + 1), (ymax - ymin + 1),
668 MAGIC_MAP_HALF - xmin, MAGIC_MAP_HALF - ymin); 611 MAGIC_MAP_HALF - xmin, MAGIC_MAP_HALF - ymin);
669 sl.len = strlen ((char *) sl.buf);
670 612
671 for (y = ymin; y <= ymax; y++) 613 for (int y = ymin; y <= ymax; y++)
672 {
673 for (x = xmin; x <= xmax; x++) 614 for (int x = xmin; x <= xmax; x++)
674 {
675 sl.buf[sl.len++] = map_mark[x + MAGIC_MAP_SIZE * y] & ~FACE_FLOOR; 615 sl << uint8 (map_mark[x + MAGIC_MAP_SIZE * y] & ~FACE_FLOOR);
676 } /* x loop */
677 } /* y loop */
678 616
679 Send_With_Handling (&pl->contr->socket, &sl); 617 pl->contr->ns->send_packet (sl);
680 free (sl.buf); 618
681 free (map_mark); 619 free (map_mark);
682} 620}
683 621
684
685/** 622/**
686 * Send a kill log record to sockets 623 * Send a kill log record to sockets
687 */ 624 */
688
689void 625void
690Log_Kill (const char *Who, const char *What, int WhatType, const char *With, int WithType) 626Log_Kill (const char *Who, const char *What, int WhatType, const char *With, int WithType)
691{ 627{
692 int i;
693 size_t len; 628 size_t len;
694 char buf[MAX_BUF]; 629 char buf[MAX_BUF];
695 630
696 if (With != NULL) 631 if (With != NULL)
697 {
698 snprintf (buf, MAX_BUF, "%s\t%s\t%d\t%s\t%d\n", Who, What, WhatType, With, WithType); 632 snprintf (buf, MAX_BUF, "%s\t%s\t%d\t%s\t%d\n", Who, What, WhatType, With, WithType);
699 }
700 else 633 else
701 {
702 snprintf (buf, MAX_BUF, "%s\t%s\t%d\n", Who, What, WhatType); 634 snprintf (buf, MAX_BUF, "%s\t%s\t%d\n", Who, What, WhatType);
703 } 635
704 len = strlen (buf); 636 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} 637}
638

Diff Legend

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