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

Diff Legend

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