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

Diff Legend

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