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.3 by root, Thu Aug 31 17:54:15 2006 UTC vs.
Revision 1.9 by root, Tue Sep 19 10:12:41 2006 UTC

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

Diff Legend

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