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.11 by root, Wed Sep 20 21:53:50 2006 UTC

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

Diff Legend

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