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.32 by root, Fri Jan 19 17:50:11 2007 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
7/* 1/*
8 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
9 3
4 Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
10 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
11 Copyright (C) 1992 Frank Tore Johansen 6 Copyright (C) 1992 Frank Tore Johansen
12 7
13 This program is free software; you can redistribute it and/or modify 8 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by 9 it under the terms of the GNU General Public License as published by
… …
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{
324
325 char buf[HUGE_BUF]; 260 char buf[HUGE_BUF];
326 261
327 if (!pl || (pl->type != PLAYER) || (pl->contr == NULL)) 262 if (!pl || (pl->type != PLAYER) || (pl->contr == NULL))
328 return; 263 return;
329 264
330 if (pri >= pl->contr->listening) 265 if (pri >= pl->contr->listening)
331 return; 266 return;
267
332 if (!CLIENT_SUPPORT_READABLES (&pl->contr->socket, type)) 268 if (!CLIENT_SUPPORT_READABLES (pl->contr->ns, type))
333 { 269 {
334 va_list ap; 270 va_list ap;
335 271
336 LOG (llevDebug, "Non supported extension text type for client.\n"); 272 LOG (llevDebug, "Non supported extension text type for client.\n");
337 va_start (ap, new_format); 273 va_start (ap, new_format);
… …
346 282
347 va_start (ap, new_format); 283 va_start (ap, new_format);
348 vsnprintf (buf, HUGE_BUF, new_format, ap); 284 vsnprintf (buf, HUGE_BUF, new_format, ap);
349 va_end (ap); 285 va_end (ap);
350 strip_media_tag (buf); 286 strip_media_tag (buf);
351 esrv_print_ext_msg (&pl->contr->socket, flags & NDI_COLOR_MASK, type, subtype, buf); 287 esrv_print_ext_msg (pl->contr->ns, flags & NDI_COLOR_MASK, type, subtype, buf);
352 } 288 }
353} 289}
354 290
355/** 291/**
356 * Writes to everyone on the map *except* op. This is useful for emotions. 292 * Writes to everyone on the map *except* op. This is useful for emotions.
357 */ 293 */
358 294
359void 295void
360new_info_map_except (int color, mapstruct *map, object *op, const char *str) 296new_info_map_except (int color, maptile * map, object *op, const char *str)
361{ 297{
362 player *pl; 298 player *pl;
363 299
364 for (pl = first_player; pl != NULL; pl = pl->next) 300 for_all_players (pl)
365 if (pl->ob != NULL && pl->ob->map == map && pl->ob != op) 301 if (pl->ob != NULL && pl->ob->map == map && pl->ob != op)
366 {
367 new_draw_info (color, 0, pl->ob, str); 302 new_draw_info (color, 0, pl->ob, str);
368 }
369} 303}
370 304
371/** 305/**
372 * Writes to everyone on the map except op1 and op2 306 * Writes to everyone on the map except op1 and op2
373 */ 307 */
374 308
375void 309void
376new_info_map_except2 (int color, mapstruct *map, object *op1, object *op2, const char *str) 310new_info_map_except2 (int color, maptile * map, object *op1, object *op2, const char *str)
377{ 311{
378 player *pl; 312 player *pl;
379 313
380 for (pl = first_player; pl != NULL; pl = pl->next) 314 for_all_players (pl)
381 if (pl->ob != NULL && pl->ob->map == map && pl->ob != op1 && pl->ob != op2) 315 if (pl->ob != NULL && pl->ob->map == map && pl->ob != op1 && pl->ob != op2)
382 {
383 new_draw_info (color, 0, pl->ob, str); 316 new_draw_info (color, 0, pl->ob, str);
384 }
385} 317}
386 318
387/** 319/**
388 * Writes to everyone on the specified map 320 * Writes to everyone on the specified map
389 */ 321 */
390 322
391void 323void
392new_info_map (int color, mapstruct *map, const char *str) 324new_info_map (int color, maptile * map, const char *str)
393{ 325{
394 player *pl; 326 player *pl;
395 327
396 for (pl = first_player; pl != NULL; pl = pl->next) 328 for_all_players (pl)
397 if (pl->ob != NULL && pl->ob->map == map) 329 if (pl->ob != NULL && pl->ob->map == map)
398 {
399 new_draw_info (color, 0, pl->ob, str); 330 new_draw_info (color, 0, pl->ob, str);
400 }
401} 331}
402
403 332
404/** 333/**
405 * This does nothing now. However, in theory, we should probably send 334 * This does nothing now. However, in theory, we should probably send
406 * something to the client and let the client figure out how it might want 335 * something to the client and let the client figure out how it might want
407 * to handle this 336 * to handle this
… …
417void 346void
418rangetostring (object *pl, char *obuf) 347rangetostring (object *pl, char *obuf)
419{ 348{
420 switch (pl->contr->shoottype) 349 switch (pl->contr->shoottype)
421 { 350 {
422 case range_none: 351 case range_none:
423 strcpy (obuf, "Range: nothing"); 352 strcpy (obuf, "Range: nothing");
424 break; 353 break;
425 354
426 case range_bow: 355 case range_bow:
356 {
357 object *op;
358
359 for (op = pl->inv; op; op = op->below)
360 if (op->type == BOW && QUERY_FLAG (op, FLAG_APPLIED))
361 break;
362
363 if (op == NULL)
364 break;
365
366 sprintf (obuf, "Range: %s (%s)", query_base_name (op, 0), op->race ? (const char *) op->race : "nothing");
367 }
368 break;
369
370 case range_magic:
371 if (settings.casting_time == TRUE)
427 { 372 {
428 object *op; 373 if (pl->casting_time > -1)
429 374 {
430 for (op = pl->inv; op; op = op->below) 375 if (pl->casting_time == 0)
431 if (op->type == BOW && QUERY_FLAG (op, FLAG_APPLIED)) 376 sprintf (obuf, "Range: Holding spell (%s)", &pl->spell->name);
432 break; 377 else
433 if (op == NULL) 378 sprintf (obuf, "Range: Casting spell (%s)", &pl->spell->name);
434 break; 379 }
435 380 else
436 sprintf (obuf, "Range: %s (%s)", query_base_name (op, 0), op->race ? (const char *) op->race : "nothing"); 381 sprintf (obuf, "Range: spell (%s)", &pl->contr->ranges[range_magic]->name);
437 } 382 }
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 383 else
454 sprintf (obuf, "Range: spell (%s)", &pl->contr->ranges[range_magic]->name); 384 sprintf (obuf, "Range: spell (%s)", &pl->contr->ranges[range_magic]->name);
455 break; 385 break;
456 386
457 case range_misc: 387 case range_misc:
458 sprintf (obuf, "Range: %s", pl->contr->ranges[range_misc] ? query_base_name (pl->contr->ranges[range_misc], 0) : "none"); 388 sprintf (obuf, "Range: %s", pl->contr->ranges[range_misc] ? query_base_name (pl->contr->ranges[range_misc], 0) : "none");
459 break; 389 break;
460 390
461 /* range_scroll is only used for controlling golems. If the 391 /* range_scroll is only used for controlling golems. If the
462 * the player does not have a golem, reset some things. 392 * the player does not have a golem, reset some things.
463 */ 393 */
464 case range_golem: 394 case range_golem:
465 if (pl->contr->ranges[range_golem] != NULL) 395 if (pl->contr->ranges[range_golem] != NULL)
466 sprintf (obuf, "Range: golem (%s)", &pl->contr->ranges[range_golem]->name); 396 sprintf (obuf, "Range: golem (%s)", &pl->contr->ranges[range_golem]->name);
467 else 397 else
468 { 398 {
469 pl->contr->shoottype = range_none; 399 pl->contr->shoottype = range_none;
470 strcpy (obuf, "Range: nothing"); 400 strcpy (obuf, "Range: nothing");
471 } 401 }
472 break; 402 break;
473 403
474 case range_skill: 404 case range_skill:
475 sprintf (obuf, "Skill: %s", pl->chosen_skill != NULL ? (const char *) pl->chosen_skill->name : "none"); 405 sprintf (obuf, "Skill: %s", pl->chosen_skill != NULL ? (const char *) pl->chosen_skill->name : "none");
476 break; 406 break;
477 407
478 case range_builder: 408 case range_builder:
479 sprintf (obuf, "Builder: %s", query_base_name (pl->contr->ranges[range_builder], 0)); 409 sprintf (obuf, "Builder: %s", query_base_name (pl->contr->ranges[range_builder], 0));
480 break; 410 break;
481 411
482 default: 412 default:
483 strcpy (obuf, "Range: illegal"); 413 strcpy (obuf, "Range: illegal");
484 } 414 }
485} 415}
486 416
487/** 417/**
488 * Sets player title. 418 * Sets player title.
… …
512static void 442static void
513magic_mapping_mark_recursive (object *pl, char *map_mark, int px, int py) 443magic_mapping_mark_recursive (object *pl, char *map_mark, int px, int py)
514{ 444{
515 int x, y, dx, dy, mflags; 445 int x, y, dx, dy, mflags;
516 sint16 nx, ny; 446 sint16 nx, ny;
517 mapstruct *mp; 447 maptile *mp;
518 New_Face *f; 448 facetile *f;
519 449
520 for (dx = -1; dx <= 1; dx++) 450 for (dx = -1; dx <= 1; dx++)
521 { 451 {
522 for (dy = -1; dy <= 1; dy++) 452 for (dy = -1; dy <= 1; dy++)
523 { 453 {
… …
567 * being nonzero have been changed to check for 1. Also, since 497 * being nonzero have been changed to check for 1. Also, since
568 * map_mark is a char value, putting 2 in should cause no problems. 498 * map_mark is a char value, putting 2 in should cause no problems.
569 * 499 *
570 * This function examines the map the player is on, and determines what 500 * This function examines the map the player is on, and determines what
571 * is visible. 2 is set for walls or objects that blocks view. 1 501 * is visible. 2 is set for walls or objects that blocks view. 1
572 * is for open spaces. map_mark should already have been initialized 502 * is for open spaces. map_mark should already have been initialised
573 * to zero before this is called. 503 * to zero before this is called.
574 * strength is an initial strength*2 rectangular area that we automatically 504 * strength is an initial strength*2 rectangular area that we automatically
575 * see in/penetrate through. 505 * see in/penetrate through.
576 */ 506 */
577 507
578void 508void
579magic_mapping_mark (object *pl, char *map_mark, int strength) 509magic_mapping_mark (object *pl, char *map_mark, int strength)
580{ 510{
581 int x, y, mflags; 511 int x, y, mflags;
582 sint16 nx, ny; 512 sint16 nx, ny;
583 mapstruct *mp; 513 maptile *mp;
584 New_Face *f; 514 facetile *f;
585 515
586 for (x = -strength; x < strength; x++) 516 for (x = -strength; x < strength; x++)
587 { 517 {
588 for (y = -strength; y < strength; y++) 518 for (y = -strength; y < strength; y++)
589 { 519 {
… …
611 } 541 }
612 } 542 }
613 } 543 }
614} 544}
615 545
616
617/** 546/**
618 * Creates and sends magic map to player. 547 * Creates and sends magic map to player.
619 * 548 *
620 * The following function is a lot messier than it really should be, 549 * The following function is a lot messier than it really should be,
621 * but there is no real easy solution. 550 * but there is no real easy solution.
622 * 551 *
623 * Mark Wedel 552 * Mark Wedel
624 */ 553 */
625
626void 554void
627draw_magic_map (object *pl) 555draw_magic_map (object *pl)
628{ 556{
629 int x, y;
630 char *map_mark = (char *) calloc (MAGIC_MAP_SIZE * MAGIC_MAP_SIZE, 1); 557 char *map_mark = (char *)calloc (MAGIC_MAP_SIZE * MAGIC_MAP_SIZE, 1);
631 int xmin, xmax, ymin, ymax; 558 int xmin, xmax, ymin, ymax;
632 SockList sl;
633 559
634 if (pl->type != PLAYER) 560 if (pl->type != PLAYER)
635 { 561 {
636 LOG (llevError, "Non player object called draw_map.\n"); 562 LOG (llevError, "Non player object called draw_map.\n");
637 return; 563 return;
… …
647 */ 573 */
648 xmin = MAGIC_MAP_SIZE; 574 xmin = MAGIC_MAP_SIZE;
649 ymin = MAGIC_MAP_SIZE; 575 ymin = MAGIC_MAP_SIZE;
650 xmax = 0; 576 xmax = 0;
651 ymax = 0; 577 ymax = 0;
578
652 for (x = 0; x < MAGIC_MAP_SIZE; x++) 579 for (int x = 0; x < MAGIC_MAP_SIZE; x++)
653 {
654 for (y = 0; y < MAGIC_MAP_SIZE; y++) 580 for (int y = 0; y < MAGIC_MAP_SIZE; y++)
655 {
656 if (map_mark[x + MAP_WIDTH (pl->map) * y] | FACE_FLOOR) 581 if (map_mark[x + pl->map->width * y] | FACE_FLOOR)
657 { 582 {
658 xmin = x < xmin ? x : xmin; 583 xmin = x < xmin ? x : xmin;
659 xmax = x > xmax ? x : xmax; 584 xmax = x > xmax ? x : xmax;
660 ymin = y < ymin ? y : ymin; 585 ymin = y < ymin ? y : ymin;
661 ymax = y > ymax ? y : ymax; 586 ymax = y > ymax ? y : ymax;
662 } 587 }
663 }
664 }
665 588
666 sl.buf = (unsigned char *) malloc (MAXSOCKBUF); 589 packet sl;
667 snprintf ((char *) sl.buf, MAXSOCKBUF, "magicmap %d %d %d %d ", (xmax - xmin + 1), (ymax - ymin + 1), 590 sl.printf ("magicmap %d %d %d %d ", (xmax - xmin + 1), (ymax - ymin + 1),
668 MAGIC_MAP_HALF - xmin, MAGIC_MAP_HALF - ymin); 591 MAGIC_MAP_HALF - xmin, MAGIC_MAP_HALF - ymin);
669 sl.len = strlen ((char *) sl.buf);
670 592
671 for (y = ymin; y <= ymax; y++) 593 for (int y = ymin; y <= ymax; y++)
672 {
673 for (x = xmin; x <= xmax; x++) 594 for (int x = xmin; x <= xmax; x++)
674 {
675 sl.buf[sl.len++] = map_mark[x + MAGIC_MAP_SIZE * y] & ~FACE_FLOOR; 595 sl << uint8 (map_mark[x + MAGIC_MAP_SIZE * y] & ~FACE_FLOOR);
676 } /* x loop */
677 } /* y loop */
678 596
679 Send_With_Handling (&pl->contr->socket, &sl); 597 pl->contr->ns->send_packet (sl);
680 free (sl.buf); 598
681 free (map_mark); 599 free (map_mark);
682} 600}
683 601
684
685/** 602/**
686 * Send a kill log record to sockets 603 * Send a kill log record to sockets
687 */ 604 */
688
689void 605void
690Log_Kill (const char *Who, const char *What, int WhatType, const char *With, int WithType) 606Log_Kill (const char *Who, const char *What, int WhatType, const char *With, int WithType)
691{ 607{
692 int i;
693 size_t len; 608 size_t len;
694 char buf[MAX_BUF]; 609 char buf[MAX_BUF];
695 610
696 if (With != NULL) 611 if (With != NULL)
697 {
698 snprintf (buf, MAX_BUF, "%s\t%s\t%d\t%s\t%d\n", Who, What, WhatType, With, WithType); 612 snprintf (buf, MAX_BUF, "%s\t%s\t%d\t%s\t%d\n", Who, What, WhatType, With, WithType);
699 }
700 else 613 else
701 {
702 snprintf (buf, MAX_BUF, "%s\t%s\t%d\n", Who, What, WhatType); 614 snprintf (buf, MAX_BUF, "%s\t%s\t%d\n", Who, What, WhatType);
703 } 615
704 len = strlen (buf); 616 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} 617}
618

Diff Legend

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