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

Diff Legend

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