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

Diff Legend

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