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

Diff Legend

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