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

Diff Legend

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