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

Diff Legend

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