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

Diff Legend

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