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

Diff Legend

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