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.4 by root, Sun Sep 3 00:18:43 2006 UTC vs.
Revision 1.20 by root, Fri Dec 15 19:59:20 2006 UTC

1/*
2 * static char *rcsid_sock_info_c =
3 * "$Id: info.C,v 1.4 2006/09/03 00:18:43 root Exp $";
4 */
5 1
6/* 2/*
7 CrossFire, A Multiplayer game for X-windows 3 CrossFire, A Multiplayer game for X-windows
8 4
9 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
… …
21 17
22 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
23 along with this program; if not, write to the Free Software 19 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 21
26 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>
27*/ 23*/
28 24
29/** 25/**
30 * \file 26 * \file
31 * Basic client output functions. 27 * Basic client output functions.
… …
46 * Draws a normal message on the client. It is pretty 42 * Draws a normal message on the client. It is pretty
47 * 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
48 * parameter. the esrv_drawinfo functions should probably be 44 * parameter. the esrv_drawinfo functions should probably be
49 * replaced with this, just using black as the color. 45 * replaced with this, just using black as the color.
50 */ 46 */
47static void
51static void esrv_print_msg(NewSocket *ns,int color, const char *str) 48esrv_print_msg (client * ns, int color, const char *str)
52{ 49{
53 char buf[HUGE_BUF]; 50 packet sl;
54
55 if (ns->status == Ns_Old) {
56 snprintf(buf,HUGE_BUF,"%s\n", str);
57 } else {
58 snprintf(buf,HUGE_BUF, "drawinfo %d %s", color, str); 51 sl.printf ("drawinfo %d %s", color, str);
59 } 52 ns->send_packet (sl);
60/* LOG(llevDebug,"sending %s to socket, len=%d\n", buf, strlen(buf));*/
61 Write_String_To_Socket(ns, buf, strlen(buf));
62} 53}
63 54
64/** 55/**
65 * Draws an extended message on the client. 56 * Draws an extended message on the client.
66 * ns the socket to send message to 57 * ns the socket to send message to
… …
68 * type, 59 * type,
69 * subtype type and subtype of text message 60 * subtype type and subtype of text message
70 * intro Intro message to send with main message if client does not support the message type 61 * intro Intro message to send with main message if client does not support the message type
71 * message The main message 62 * message The main message
72 */ 63 */
64static void
73static void esrv_print_ext_msg(NewSocket *ns,int color,uint8 type, uint8 subtype, const char *message) 65esrv_print_ext_msg (client * ns, int color, uint8 type, uint8 subtype, const char *message)
74{ 66{
75 char buf[HUGE_BUF]; 67 packet sl;
68
76 snprintf(buf,HUGE_BUF, "drawextinfo %d %hhu %hhu %s", color, type, subtype, message); 69 sl.printf ("drawextinfo %d %hhu %hhu %s", color, type, subtype, message);
77 Write_String_To_Socket(ns, buf, strlen(buf)); 70 ns->send_packet (sl);
78/* LOG(llevDebug,"sending %s to socket, len=%d", buf, strlen(buf));*/
79
80} 71}
81 72
82/** 73/**
83 * Frontend for esrv_print_msg 74 * Frontend for esrv_print_msg
84 * \param colr message color 75 * \param colr message color
… …
88 * If pl is NULL or without contr set, writes message to log. 79 * If pl is NULL or without contr set, writes message to log.
89 * 80 *
90 * Else sends message to player via esrv_print_msg 81 * Else sends message to player via esrv_print_msg
91 */ 82 */
92 83
84static void
93static void print_message(int colr, const object *pl, const char *tmp) { 85print_message (int colr, const object *pl, const char *tmp)
86{
94 87
95 if(tmp == (char *) NULL) { 88 if (!tmp)
96 tmp="[NULL]"; 89 tmp = "[NULL]";
97 }
98 90
99 if (!pl || (pl->type == PLAYER && pl->contr == NULL)) 91 if (!pl || (pl->type == PLAYER && pl->contr == NULL))
100 return; 92 return;
101 93
102 if (pl->type == PLAYER) { 94 if (pl->type == PLAYER)
103 esrv_print_msg(&pl->contr->socket,colr,(char*) tmp); 95 esrv_print_msg (pl->contr->socket, colr, (char *) tmp);
104 return;
105 }
106} 96}
107
108 97
109/** 98/**
110 * Prints out the contents of specified buffer structures, 99 * Prints out the contents of specified buffer structures,
111 * and clears the string. 100 * and clears the string.
112 */ 101 */
113 102
103void
114void flush_output_element(const object *pl, Output_Buf *outputs) 104flush_output_element (const object *pl, Output_Buf * outputs)
115{ 105{
116 char tbuf[MAX_BUF]; 106 char tbuf[MAX_BUF];
117 107
118 if (outputs->buf==NULL) return; 108 if (outputs->buf == NULL)
109 return;
119 if (outputs->count > 1) { 110 if (outputs->count > 1)
111 {
120 snprintf(tbuf,MAX_BUF, "%d times %s", outputs->count, &outputs->buf); 112 snprintf (tbuf, MAX_BUF, "%d times %s", outputs->count, &outputs->buf);
121 print_message(NDI_BLACK, pl, tbuf); 113 print_message (NDI_BLACK, pl, tbuf);
114 }
122 } else 115 else
123 print_message(NDI_BLACK, pl, &outputs->buf); 116 print_message (NDI_BLACK, pl, &outputs->buf);
124 117
125 outputs->buf=NULL; 118 outputs->buf = NULL;
126 outputs->first_update=0; /* This way, it will be reused */ 119 outputs->first_update = 0; /* This way, it will be reused */
127} 120}
128 121
129/** 122/**
130 * Sends message to player through output buffers. 123 * Sends message to player through output buffers.
131 * \param pl player to send message 124 * \param pl player to send message
… …
139 * 132 *
140 * If message not already in buffers, flushes olders buffer, 133 * If message not already in buffers, flushes olders buffer,
141 * and adds message to queue. 134 * and adds message to queue.
142 */ 135 */
143 136
137static void
144static void check_output_buffers(const object *pl, const char *buf) 138check_output_buffers (const object *pl, const char *buf)
145{ 139{
146 int i, oldest=0; 140 int i, oldest = 0;
147 141
148 if (pl->contr->outputs_count<2) { 142 if (pl->contr->outputs_count < 2)
143 {
149 print_message(NDI_BLACK, pl, buf); 144 print_message (NDI_BLACK, pl, buf);
150 return; 145 return;
146 }
147 else
151 } 148 {
152 else {
153 for (i=0; i<NUM_OUTPUT_BUFS; i++) { 149 for (i = 0; i < NUM_OUTPUT_BUFS; i++)
154 if (pl->contr->outputs[i].buf &&
155 !strcmp(buf, pl->contr->outputs[i].buf)) break;
156 else if (pl->contr->outputs[i].first_update <
157 pl->contr->outputs[oldest].first_update)
158 oldest=i;
159 } 150 {
151 if (pl->contr->outputs[i].buf && !strcmp (buf, pl->contr->outputs[i].buf))
152 break;
153 else if (pl->contr->outputs[i].first_update < pl->contr->outputs[oldest].first_update)
154 oldest = i;
155 }
160 /* We found a match */ 156 /* We found a match */
161 if (i<NUM_OUTPUT_BUFS) { 157 if (i < NUM_OUTPUT_BUFS)
158 {
162 pl->contr->outputs[i].count++; 159 pl->contr->outputs[i].count++;
163 if (pl->contr->outputs[i].count>=pl->contr->outputs_count) { 160 if (pl->contr->outputs[i].count >= pl->contr->outputs_count)
161 {
164 flush_output_element(pl, &pl->contr->outputs[i]); 162 flush_output_element (pl, &pl->contr->outputs[i]);
165 } 163 }
166 } 164 }
167 /* No match - flush the oldest, and put the new one in */ 165 /* No match - flush the oldest, and put the new one in */
168 else { 166 else
167 {
169 flush_output_element(pl, &pl->contr->outputs[oldest]); 168 flush_output_element (pl, &pl->contr->outputs[oldest]);
170 169
171 pl->contr->outputs[oldest].first_update = pticks; 170 pl->contr->outputs[oldest].first_update = pticks;
172 pl->contr->outputs[oldest].count = 1; 171 pl->contr->outputs[oldest].count = 1;
173 pl->contr->outputs[oldest].buf = buf; 172 pl->contr->outputs[oldest].buf = buf;
174 }
175 }
176}
177 173 }
174 }
175}
176
178 177
179 178
180/** 179/**
181 * Sends message to player(s). 180 * Sends message to player(s).
182 * 181 *
… …
192 * 191 *
193 * If message is black, and not NDI_UNIQUE, gets sent through output buffers. 192 * If message is black, and not NDI_UNIQUE, gets sent through output buffers.
194 * 193 *
195 */ 194 */
196 195
196void
197void new_draw_info(int flags, int pri, const object *pl, const char *buf) 197new_draw_info (int flags, int pri, const object *pl, const char *buf)
198{ 198{
199 199
200 if (flags & NDI_ALL) { 200 if (flags & NDI_ALL)
201 {
201 player *tmppl; 202 player *tmppl;
202 int i;
203 203
204 for (tmppl=first_player; tmppl!=NULL; tmppl=tmppl->next) 204 for (tmppl = first_player; tmppl != NULL; tmppl = tmppl->next)
205 new_draw_info((flags & ~NDI_ALL), pri, tmppl->ob, buf); 205 new_draw_info ((flags & ~NDI_ALL), pri, tmppl->ob, buf);
206 206
207 for (i=1; i<socket_info.allocated_sockets; i++) {
208 if (init_sockets[i].status == Ns_Old && init_sockets[i].old_mode != Old_Listen && pri< 10) {
209 cs_write_string(&init_sockets[i], buf, strlen(buf));
210 /* Most messages don't have a newline, so add one */
211 cs_write_string(&init_sockets[i], "\n", 1);
212 }
213 }
214
215 return; 207 return;
216 } 208 }
209
217 if(!pl || (pl->type==PLAYER && pl->contr==NULL)) { 210 if (!pl || (pl->type == PLAYER && pl->contr == NULL))
211 {
218 /* Write to the socket? */ 212 /* Write to the socket? */
219 print_message(0, NULL, buf); 213 print_message (0, NULL, buf);
220 return; 214 return;
221 } 215 }
216
222 if (pl->type!=PLAYER) return; 217 if (pl->type != PLAYER)
218 return;
219
223 if (pri>=pl->contr->listening) return; 220 if (pri >= pl->contr->listening)
221 return;
224 222
225 if ((flags&NDI_COLOR_MASK)==NDI_BLACK && !(flags &NDI_UNIQUE)) { 223 if ((flags & NDI_COLOR_MASK) == NDI_BLACK && !(flags & NDI_UNIQUE))
226 /* following prints stuff out, as appropriate */ 224 /* following prints stuff out, as appropriate */
227 check_output_buffers(pl, buf); 225 check_output_buffers (pl, buf);
228 }
229 else { 226 else
230 print_message(flags&NDI_COLOR_MASK, pl, buf); 227 print_message (flags & NDI_COLOR_MASK, pl, buf);
231 }
232} 228}
233 229
234/** 230/**
235 * Wrapper for new_draw_info printf-like. 231 * Wrapper for new_draw_info printf-like.
236 * 232 *
… …
238 * formatting, so instead of the calling function having to do it, we do 234 * formatting, so instead of the calling function having to do it, we do
239 * it here. It may also have advantages in the future for reduction of 235 * it here. It may also have advantages in the future for reduction of
240 * client/server bandwidth (client could keep track of various strings 236 * client/server bandwidth (client could keep track of various strings
241 */ 237 */
242 238
239void
243void new_draw_info_format(int flags, int pri, const object *pl, const char *format, ...) 240new_draw_info_format (int flags, int pri, const object *pl, const char *format, ...)
244{ 241{
245 char buf[HUGE_BUF]; 242 char buf[HUGE_BUF];
246 243
247 va_list ap; 244 va_list ap;
245
248 va_start(ap, format); 246 va_start (ap, format);
249 247
250 vsnprintf(buf, HUGE_BUF, format, ap); 248 vsnprintf (buf, HUGE_BUF, format, ap);
251 249
252 va_end(ap); 250 va_end (ap);
253 251
254 new_draw_info(flags, pri, pl, buf); 252 new_draw_info (flags, pri, pl, buf);
255} 253}
256 254
257 255
258void draw_ext_info( 256void
259 int flags, int pri, const object *pl, uint8 type, 257draw_ext_info (int flags, int pri, const object *pl, uint8 type, uint8 subtype, const char *message, const char *oldmessage)
260 uint8 subtype, const char* message, const char* oldmessage){ 258{
261 259
262 if(!pl || (pl->type!=PLAYER) || (pl->contr==NULL)) 260 if (!pl || (pl->type != PLAYER) || (pl->contr == NULL))
263 return; 261 return;
264 262
265 if (pri>=pl->contr->listening) return; 263 if (pri >= pl->contr->listening)
264 return;
265
266 if (!CLIENT_SUPPORT_READABLES(&pl->contr->socket,type)){ 266 if (!CLIENT_SUPPORT_READABLES (pl->contr->socket, type))
267 {
267 char *buf = (char*)malloc(strlen(oldmessage==NULL?message:oldmessage)+1); 268 char *buf = (char *) malloc (strlen (oldmessage == NULL ? message : oldmessage) + 1);
269
268 if (buf==NULL) 270 if (buf == NULL)
269 LOG(llevError,"info::draw_ext_info -> Out of memory!"); 271 LOG (llevError, "info::draw_ext_info -> Out of memory!");
270 else{ 272 else
273 {
271 strcpy(buf,oldmessage==NULL?message:oldmessage); 274 strcpy (buf, oldmessage == NULL ? message : oldmessage);
272 strip_media_tag(buf); 275 strip_media_tag (buf);
273 new_draw_info(flags, pri, pl, buf); 276 new_draw_info (flags, pri, pl, buf);
274 free(buf); 277 free (buf);
275 } 278 }
279 }
276 }else{ 280 else
277 esrv_print_ext_msg(&pl->contr->socket,flags&NDI_COLOR_MASK,type,subtype,message); 281 esrv_print_ext_msg (pl->contr->socket, flags & NDI_COLOR_MASK, type, subtype, message);
278 }
279} 282}
280 283
281void draw_ext_info_format( 284void
282 int flags, int pri, const object *pl, uint8 type, 285draw_ext_info_format (int flags, int pri, const object *pl, uint8 type, uint8 subtype, const char *old_format, char *new_format, ...)
283 uint8 subtype, const char* old_format, 286{
284 char* new_format, ...){ 287
285
286 char buf[HUGE_BUF]; 288 char buf[HUGE_BUF];
289
287 if(!pl || (pl->type!=PLAYER) || (pl->contr==NULL)) 290 if (!pl || (pl->type != PLAYER) || (pl->contr == NULL))
288 return; 291 return;
289 292
290 if (pri>=pl->contr->listening) return; 293 if (pri >= pl->contr->listening)
294 return;
295
291 if (!CLIENT_SUPPORT_READABLES(&pl->contr->socket,type)){ 296 if (!CLIENT_SUPPORT_READABLES (pl->contr->socket, type))
297 {
292 va_list ap; 298 va_list ap;
299
293 LOG(llevDebug,"Non supported extension text type for client.\n"); 300 LOG (llevDebug, "Non supported extension text type for client.\n");
294 va_start(ap, new_format); 301 va_start (ap, new_format);
295 vsnprintf(buf, HUGE_BUF, old_format, ap); 302 vsnprintf (buf, HUGE_BUF, old_format, ap);
296 va_end(ap); 303 va_end (ap);
297 new_draw_info(flags, pri, pl, buf); 304 new_draw_info (flags, pri, pl, buf);
298 return; 305 return;
299 }else{ 306 }
307 else
308 {
300 va_list ap; 309 va_list ap;
310
301 va_start(ap, new_format); 311 va_start (ap, new_format);
302 vsnprintf(buf, HUGE_BUF, new_format, ap); 312 vsnprintf (buf, HUGE_BUF, new_format, ap);
303 va_end(ap); 313 va_end (ap);
304 strip_media_tag(buf); 314 strip_media_tag (buf);
305 esrv_print_ext_msg(&pl->contr->socket,flags&NDI_COLOR_MASK,type,subtype,buf); 315 esrv_print_ext_msg (pl->contr->socket, flags & NDI_COLOR_MASK, type, subtype, buf);
306 } 316 }
307} 317}
318
308/** 319/**
309 * Writes to everyone on the map *except* op. This is useful for emotions. 320 * Writes to everyone on the map *except* op. This is useful for emotions.
310 */ 321 */
311 322
323void
312void new_info_map_except(int color, mapstruct *map, object *op, const char *str) { 324new_info_map_except (int color, maptile * map, object *op, const char *str)
325{
313 player *pl; 326 player *pl;
314 327
315 for(pl = first_player; pl != NULL; pl = pl->next) 328 for (pl = first_player; pl != NULL; pl = pl->next)
316 if(pl->ob != NULL && pl->ob->map == map && pl->ob != op) { 329 if (pl->ob != NULL && pl->ob->map == map && pl->ob != op)
330 {
317 new_draw_info(color, 0, pl->ob, str); 331 new_draw_info (color, 0, pl->ob, str);
318 } 332 }
319} 333}
320 334
321/** 335/**
322 * Writes to everyone on the map except op1 and op2 336 * Writes to everyone on the map except op1 and op2
323 */ 337 */
324 338
339void
325void new_info_map_except2(int color, mapstruct *map, object *op1, object *op2, 340new_info_map_except2 (int color, maptile * map, object *op1, object *op2, const char *str)
326 const char *str) { 341{
327 player *pl; 342 player *pl;
328 343
329 for(pl = first_player; pl != NULL; pl = pl->next) 344 for (pl = first_player; pl != NULL; pl = pl->next)
330 if(pl->ob != NULL && pl->ob->map == map 345 if (pl->ob != NULL && pl->ob->map == map && pl->ob != op1 && pl->ob != op2)
331 && pl->ob != op1 && pl->ob != op2) { 346 {
332 new_draw_info(color, 0, pl->ob, str); 347 new_draw_info (color, 0, pl->ob, str);
333 } 348 }
334} 349}
335 350
336/** 351/**
337 * Writes to everyone on the specified map 352 * Writes to everyone on the specified map
338 */ 353 */
339 354
355void
340void new_info_map(int color, mapstruct *map, const char *str) { 356new_info_map (int color, maptile * map, const char *str)
357{
341 player *pl; 358 player *pl;
342 359
343 for(pl = first_player; pl != NULL; pl = pl->next) 360 for (pl = first_player; pl != NULL; pl = pl->next)
344 if(pl->ob != NULL && pl->ob->map == map) { 361 if (pl->ob != NULL && pl->ob->map == map)
362 {
345 new_draw_info(color, 0, pl->ob, str); 363 new_draw_info (color, 0, pl->ob, str);
346 } 364 }
347} 365}
348 366
349 367
350/** 368/**
351 * This does nothing now. However, in theory, we should probably send 369 * This does nothing now. However, in theory, we should probably send
352 * something to the client and let the client figure out how it might want 370 * something to the client and let the client figure out how it might want
353 * to handle this 371 * to handle this
354 */ 372 */
373void
355void clear_win_info(object *op) 374clear_win_info (object *op)
356{ 375{
357} 376}
358 377
359/** 378/**
360 * Get player's current range attack in obuf. 379 * Get player's current range attack in obuf.
361 */ 380 */
381void
362void rangetostring(object *pl,char *obuf) 382rangetostring (object *pl, char *obuf)
363{ 383{
364 switch(pl->contr->shoottype) { 384 switch (pl->contr->shoottype)
385 {
365 case range_none: 386 case range_none:
366 strcpy(obuf,"Range: nothing"); 387 strcpy (obuf, "Range: nothing");
388 break;
389
390 case range_bow:
391 {
392 object *op;
393
394 for (op = pl->inv; op; op = op->below)
395 if (op->type == BOW && QUERY_FLAG (op, FLAG_APPLIED))
396 break;
397
398 if (op == NULL)
367 break; 399 break;
368 400
369 case range_bow: 401 sprintf (obuf, "Range: %s (%s)", query_base_name (op, 0), op->race ? (const char *) op->race : "nothing");
370 {
371 object *op;
372
373 for (op = pl->inv; op; op=op->below)
374 if (op->type == BOW && QUERY_FLAG (op, FLAG_APPLIED))
375 break;
376 if(op==NULL) break;
377
378 sprintf (obuf, "Range: %s (%s)", query_base_name(op, 0),
379 op->race ? (const char *)op->race : "nothing");
380 } 402 }
381 break; 403 break;
382 404
383 case range_magic: 405 case range_magic:
384 if (settings.casting_time == TRUE) { 406 if (settings.casting_time == TRUE)
407 {
385 if (pl->casting_time > -1) { 408 if (pl->casting_time > -1)
409 {
386 if (pl->casting_time == 0) 410 if (pl->casting_time == 0)
387 sprintf(obuf,"Range: Holding spell (%s)", 411 sprintf (obuf, "Range: Holding spell (%s)", &pl->spell->name);
388 (const char *)pl->spell->name);
389 else
390 sprintf(obuf,"Range: Casting spell (%s)",
391 (const char *)pl->spell->name);
392 } else 412 else
393 sprintf(obuf,"Range: spell (%s)", &pl->contr->ranges[range_magic]->name); 413 sprintf (obuf, "Range: Casting spell (%s)", &pl->spell->name);
414 }
394 } else 415 else
395 sprintf(obuf,"Range: spell (%s)", &pl->contr->ranges[range_magic]->name); 416 sprintf (obuf, "Range: spell (%s)", &pl->contr->ranges[range_magic]->name);
417 }
418 else
419 sprintf (obuf, "Range: spell (%s)", &pl->contr->ranges[range_magic]->name);
396 break; 420 break;
397 421
398 case range_misc: 422 case range_misc:
399 sprintf(obuf,"Range: %s", pl->contr->ranges[range_misc] ? 423 sprintf (obuf, "Range: %s", pl->contr->ranges[range_misc] ? query_base_name (pl->contr->ranges[range_misc], 0) : "none");
400 query_base_name(pl->contr->ranges[range_misc],0) : "none");
401 break; 424 break;
402 425
403 /* range_scroll is only used for controlling golems. If the 426 /* range_scroll is only used for controlling golems. If the
404 * the player does not have a golem, reset some things. 427 * the player does not have a golem, reset some things.
405 */ 428 */
406 case range_golem: 429 case range_golem:
407 if (pl->contr->ranges[range_golem]!=NULL) 430 if (pl->contr->ranges[range_golem] != NULL)
408 sprintf(obuf,"Range: golem (%s)", &pl->contr->ranges[range_golem]->name); 431 sprintf (obuf, "Range: golem (%s)", &pl->contr->ranges[range_golem]->name);
409 else { 432 else
433 {
410 pl->contr->shoottype = range_none; 434 pl->contr->shoottype = range_none;
411 strcpy(obuf,"Range: nothing"); 435 strcpy (obuf, "Range: nothing");
412 } 436 }
413 break;
414
415 case range_skill:
416 sprintf(obuf,"Skill: %s", pl->chosen_skill!=NULL ?
417 (const char *)pl->chosen_skill->name : "none");
418 break;
419
420 case range_builder:
421 sprintf( obuf, "Builder: %s", query_base_name( pl->contr->ranges[ range_builder ], 0 ) );
422 break; 437 break;
423 438
439 case range_skill:
440 sprintf (obuf, "Skill: %s", pl->chosen_skill != NULL ? (const char *) pl->chosen_skill->name : "none");
441 break;
442
443 case range_builder:
444 sprintf (obuf, "Builder: %s", query_base_name (pl->contr->ranges[range_builder], 0));
445 break;
446
424 default: 447 default:
425 strcpy(obuf,"Range: illegal"); 448 strcpy (obuf, "Range: illegal");
426 } 449 }
427} 450}
428 451
429/** 452/**
430 * Sets player title. 453 * Sets player title.
431 */ 454 */
455void
432void set_title(object *pl, char *buf) 456set_title (object *pl, char *buf)
433{ 457{
434 /* Eneq(@csd.uu.se): Let players define their own titles. */ 458 /* Eneq(@csd.uu.se): Let players define their own titles. */
435 if (pl->contr->own_title[0]=='\0') 459 if (pl->contr->own_title[0] == '\0')
436 sprintf(buf,"Player: %s the %s",(const char *)pl->name,(const char *)pl->contr->title); 460 sprintf (buf, "Player: %s the %s", (const char *) pl->name, (const char *) pl->contr->title);
437 else 461 else
438 sprintf(buf,"Player: %s %s",(const char *)pl->name,(const char *)pl->contr->own_title); 462 sprintf (buf, "Player: %s %s", (const char *) pl->name, (const char *) pl->contr->own_title);
439} 463}
440 464
441 465
442/** 466/**
443 * Helper for magic map creation. 467 * Helper for magic map creation.
… …
448 * 472 *
449 * This function examines all the adjacant spaces next to px, py. 473 * This function examines all the adjacant spaces next to px, py.
450 * It updates the map_mark arrow with the color and high bits set 474 * It updates the map_mark arrow with the color and high bits set
451 * for various code values. 475 * for various code values.
452 */ 476 */
477static void
453static void magic_mapping_mark_recursive(object *pl, char *map_mark, int px, int py) 478magic_mapping_mark_recursive (object *pl, char *map_mark, int px, int py)
454{ 479{
455 int x, y, dx, dy,mflags; 480 int x, y, dx, dy, mflags;
456 sint16 nx, ny; 481 sint16 nx, ny;
457 mapstruct *mp; 482 maptile *mp;
458 New_Face *f; 483 New_Face *f;
459 484
460 for (dx = -1; dx <= 1; dx++) { 485 for (dx = -1; dx <= 1; dx++)
486 {
461 for (dy = -1; dy <= 1; dy++) { 487 for (dy = -1; dy <= 1; dy++)
488 {
462 x = px + dx; 489 x = px + dx;
463 y = py + dy; 490 y = py + dy;
464 491
465 if (FABS(x) >= MAGIC_MAP_HALF || FABS(y) >= MAGIC_MAP_HALF) continue; 492 if (FABS (x) >= MAGIC_MAP_HALF || FABS (y) >= MAGIC_MAP_HALF)
493 continue;
466 494
467 mp = pl->map; 495 mp = pl->map;
468 nx = pl->x + x; 496 nx = pl->x + x;
469 ny = pl->y + y; 497 ny = pl->y + y;
470 498
471 mflags = get_map_flags(pl->map, &mp, nx, ny, &nx, &ny); 499 mflags = get_map_flags (pl->map, &mp, nx, ny, &nx, &ny);
472 if (mflags & P_OUT_OF_MAP) continue; 500 if (mflags & P_OUT_OF_MAP)
501 continue;
473 502
474 if (map_mark[MAGIC_MAP_HALF + x + MAGIC_MAP_SIZE* (MAGIC_MAP_HALF + y)] == 0) { 503 if (map_mark[MAGIC_MAP_HALF + x + MAGIC_MAP_SIZE * (MAGIC_MAP_HALF + y)] == 0)
504 {
475 f= GET_MAP_FACE(mp, nx, ny, 0); 505 f = GET_MAP_FACE (mp, nx, ny, 0);
476 if (f == blank_face) 506 if (f == blank_face)
477 f= GET_MAP_FACE(mp, nx, ny, 1); 507 f = GET_MAP_FACE (mp, nx, ny, 1);
478 if (f == blank_face) 508 if (f == blank_face)
479 f= GET_MAP_FACE(mp, nx, ny, 2); 509 f = GET_MAP_FACE (mp, nx, ny, 2);
480 510
481 /* Should probably have P_NO_MAGIC here also, but then shops don't 511 /* Should probably have P_NO_MAGIC here also, but then shops don't
482 * work. 512 * work.
483 */ 513 */
484 if (mflags & P_BLOCKSVIEW) 514 if (mflags & P_BLOCKSVIEW)
485 map_mark[MAGIC_MAP_HALF + x + MAGIC_MAP_SIZE* (MAGIC_MAP_HALF + y)] = FACE_WALL | (f?f->magicmap:0); 515 map_mark[MAGIC_MAP_HALF + x + MAGIC_MAP_SIZE * (MAGIC_MAP_HALF + y)] = FACE_WALL | (f ? f->magicmap : 0);
486 else { 516 else
517 {
487 map_mark[MAGIC_MAP_HALF + x + MAGIC_MAP_SIZE* (MAGIC_MAP_HALF + y)] = FACE_FLOOR | (f?f->magicmap:0); 518 map_mark[MAGIC_MAP_HALF + x + MAGIC_MAP_SIZE * (MAGIC_MAP_HALF + y)] = FACE_FLOOR | (f ? f->magicmap : 0);
488 magic_mapping_mark_recursive(pl, map_mark, x, y); 519 magic_mapping_mark_recursive (pl, map_mark, x, y);
489 } 520 }
490 } 521 }
491 } 522 }
492 } 523 }
493} 524}
… …
507 * to zero before this is called. 538 * to zero before this is called.
508 * strength is an initial strength*2 rectangular area that we automatically 539 * strength is an initial strength*2 rectangular area that we automatically
509 * see in/penetrate through. 540 * see in/penetrate through.
510 */ 541 */
511 542
543void
512void magic_mapping_mark(object *pl, char *map_mark, int strength) 544magic_mapping_mark (object *pl, char *map_mark, int strength)
513{ 545{
514 int x, y, mflags; 546 int x, y, mflags;
515 sint16 nx, ny; 547 sint16 nx, ny;
516 mapstruct *mp; 548 maptile *mp;
517 New_Face *f; 549 New_Face *f;
518 550
519 for (x = -strength; x <strength; x++) { 551 for (x = -strength; x < strength; x++)
552 {
520 for (y = -strength; y <strength; y++) { 553 for (y = -strength; y < strength; y++)
554 {
521 mp = pl->map; 555 mp = pl->map;
522 nx = pl->x + x; 556 nx = pl->x + x;
523 ny = pl->y + y; 557 ny = pl->y + y;
524 mflags = get_map_flags(pl->map, &mp, nx, ny, &nx, &ny); 558 mflags = get_map_flags (pl->map, &mp, nx, ny, &nx, &ny);
525 if (mflags & P_OUT_OF_MAP) 559 if (mflags & P_OUT_OF_MAP)
526 continue; 560 continue;
527 else { 561 else
562 {
528 f= GET_MAP_FACE(mp, nx, ny, 0); 563 f = GET_MAP_FACE (mp, nx, ny, 0);
529 if (f == blank_face) 564 if (f == blank_face)
530 f= GET_MAP_FACE(mp, nx, ny, 1); 565 f = GET_MAP_FACE (mp, nx, ny, 1);
531 if (f == blank_face) 566 if (f == blank_face)
532 f= GET_MAP_FACE(mp, nx, ny, 2); 567 f = GET_MAP_FACE (mp, nx, ny, 2);
533 } 568 }
534 569
535 if (mflags & P_BLOCKSVIEW) 570 if (mflags & P_BLOCKSVIEW)
536 map_mark[MAGIC_MAP_HALF + x + MAGIC_MAP_SIZE* (MAGIC_MAP_HALF + y)] = FACE_WALL | (f?f->magicmap:0); 571 map_mark[MAGIC_MAP_HALF + x + MAGIC_MAP_SIZE * (MAGIC_MAP_HALF + y)] = FACE_WALL | (f ? f->magicmap : 0);
537 else { 572 else
573 {
538 map_mark[MAGIC_MAP_HALF + x + MAGIC_MAP_SIZE* (MAGIC_MAP_HALF + y)] = FACE_FLOOR | (f?f->magicmap:0); 574 map_mark[MAGIC_MAP_HALF + x + MAGIC_MAP_SIZE * (MAGIC_MAP_HALF + y)] = FACE_FLOOR | (f ? f->magicmap : 0);
539 magic_mapping_mark_recursive(pl, map_mark, x, y); 575 magic_mapping_mark_recursive (pl, map_mark, x, y);
540 } 576 }
541 } 577 }
542 } 578 }
543} 579}
544 580
… …
550 * but there is no real easy solution. 586 * but there is no real easy solution.
551 * 587 *
552 * Mark Wedel 588 * Mark Wedel
553 */ 589 */
554 590
591void
555void draw_magic_map(object *pl) 592draw_magic_map (object *pl)
556{ 593{
557 int x,y;
558 char *map_mark = (char *) calloc(MAGIC_MAP_SIZE*MAGIC_MAP_SIZE, 1); 594 char *map_mark = (char *)calloc (MAGIC_MAP_SIZE * MAGIC_MAP_SIZE, 1);
559 int xmin, xmax, ymin, ymax; 595 int xmin, xmax, ymin, ymax;
560 SockList sl;
561 596
562 if (pl->type!=PLAYER) { 597 if (pl->type != PLAYER)
598 {
563 LOG(llevError,"Non player object called draw_map.\n"); 599 LOG (llevError, "Non player object called draw_map.\n");
564 return; 600 return;
565 }
566 601 }
602
567 /* First, we figure out what spaces are 'reachable' by the player */ 603 /* First, we figure out what spaces are 'reachable' by the player */
568 magic_mapping_mark(pl, map_mark, 3); 604 magic_mapping_mark (pl, map_mark, 3);
569 605
570 /* We now go through and figure out what spaces have been 606 /* We now go through and figure out what spaces have been
571 * marked, and thus figure out rectangular region we send 607 * marked, and thus figure out rectangular region we send
572 * to the client (eg, if only a 10x10 area is visible, we only 608 * to the client (eg, if only a 10x10 area is visible, we only
573 * want to send those 100 spaces.) 609 * want to send those 100 spaces.)
574 */ 610 */
575 xmin = MAGIC_MAP_SIZE; 611 xmin = MAGIC_MAP_SIZE;
576 ymin = MAGIC_MAP_SIZE; 612 ymin = MAGIC_MAP_SIZE;
577 xmax = 0; 613 xmax = 0;
578 ymax = 0; 614 ymax = 0;
615
579 for(x = 0; x < MAGIC_MAP_SIZE ; x++) { 616 for (int x = 0; x < MAGIC_MAP_SIZE; x++)
580 for(y = 0; y < MAGIC_MAP_SIZE; y++) { 617 for (int y = 0; y < MAGIC_MAP_SIZE; y++)
581 if (map_mark[x + MAP_WIDTH(pl->map) * y] | FACE_FLOOR) { 618 if (map_mark[x + MAP_WIDTH (pl->map) * y] | FACE_FLOOR)
619 {
582 xmin = x < xmin ? x : xmin; 620 xmin = x < xmin ? x : xmin;
583 xmax = x > xmax ? x : xmax; 621 xmax = x > xmax ? x : xmax;
584 ymin = y < ymin ? y : ymin; 622 ymin = y < ymin ? y : ymin;
585 ymax = y > ymax ? y : ymax; 623 ymax = y > ymax ? y : ymax;
586 } 624 }
587 }
588 }
589 625
590 sl.buf= (unsigned char*) malloc(MAXSOCKBUF); 626 packet sl;
591 snprintf((char*)sl.buf, MAXSOCKBUF, "magicmap %d %d %d %d ", (xmax-xmin+1), (ymax-ymin+1), 627 sl.printf ("magicmap %d %d %d %d ", (xmax - xmin + 1), (ymax - ymin + 1),
592 MAGIC_MAP_HALF - xmin, MAGIC_MAP_HALF - ymin); 628 MAGIC_MAP_HALF - xmin, MAGIC_MAP_HALF - ymin);
593 sl.len=strlen((char*)sl.buf); 629
594
595 for (y = ymin; y <= ymax; y++) { 630 for (int y = ymin; y <= ymax; y++)
596 for (x = xmin; x <= xmax; x++) { 631 for (int x = xmin; x <= xmax; x++)
597 sl.buf[sl.len++]= map_mark[x+MAGIC_MAP_SIZE*y] & ~FACE_FLOOR; 632 sl << uint8 (map_mark[x + MAGIC_MAP_SIZE * y] & ~FACE_FLOOR);
598 } /* x loop */ 633
599 } /* y loop */ 634 pl->contr->socket->send_packet (sl);
600 635
601 Send_With_Handling(&pl->contr->socket, &sl);
602 free(sl.buf);
603 free(map_mark); 636 free (map_mark);
604} 637}
605 638
606 639
607/** 640/**
608 * Send a kill log record to sockets 641 * Send a kill log record to sockets
609 */ 642 */
610 643
611void Log_Kill(const char *Who, 644void
612 const char *What, int WhatType, 645Log_Kill (const char *Who, const char *What, int WhatType, const char *With, int WithType)
613 const char *With, int WithType)
614{ 646{
615 int i;
616 size_t len; 647 size_t len;
617 char buf[MAX_BUF]; 648 char buf[MAX_BUF];
618 649
619 if (With!=NULL) { 650 if (With != NULL)
620 snprintf(buf, MAX_BUF, "%s\t%s\t%d\t%s\t%d\n",Who,What,WhatType,With,WithType); 651 snprintf (buf, MAX_BUF, "%s\t%s\t%d\t%s\t%d\n", Who, What, WhatType, With, WithType);
621 }
622 else { 652 else
623 snprintf(buf,MAX_BUF, "%s\t%s\t%d\n",Who,What,WhatType); 653 snprintf (buf, MAX_BUF, "%s\t%s\t%d\n", Who, What, WhatType);
624 } 654
625 len=strlen(buf); 655 len = strlen (buf);
626 for(i=1; i<socket_info.allocated_sockets; i++) {
627 if (init_sockets[i].old_mode == Old_Listen) {
628 cs_write_string(&init_sockets[i], buf, len);
629 }
630 }
631} 656}

Diff Legend

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