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

Diff Legend

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