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

Diff Legend

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