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

Diff Legend

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