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.2 by root, Tue Aug 29 08:01:38 2006 UTC vs.
Revision 1.6 by root, Thu Sep 14 22:34:05 2006 UTC

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

Diff Legend

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