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.1 by elmex, Sun Aug 13 17:16:05 2006 UTC vs.
Revision 1.19 by root, Thu Dec 14 20:39:54 2006 UTC

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

Diff Legend

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