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

Diff Legend

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