ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/server/main.C
(Generate patch)

Comparing deliantra/server/server/main.C (file contents):
Revision 1.25 by root, Tue Sep 12 23:22:32 2006 UTC vs.
Revision 1.42 by root, Wed Dec 13 00:42:04 2006 UTC

… …
16 16
17 You should have received a copy of the GNU General Public License 17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software 18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 20
21 The authors can be reached via e-mail at crossfire-devel@real-time.com 21 The authors can be reached via e-mail at <crossfire@schmorp.de>
22*/ 22*/
23 23
24#include <global.h> 24#include <global.h>
25#include <object.h> 25#include <object.h>
26#include <tod.h> 26#include <tod.h>
… …
106 new_draw_info (NDI_UNIQUE, 0, op, "Images and art:"); 106 new_draw_info (NDI_UNIQUE, 0, op, "Images and art:");
107 new_draw_info (NDI_UNIQUE, 0, op, "Peter Gardner"); 107 new_draw_info (NDI_UNIQUE, 0, op, "Peter Gardner");
108 new_draw_info (NDI_UNIQUE, 0, op, "David Gervais [david_eg@mail.com]"); 108 new_draw_info (NDI_UNIQUE, 0, op, "David Gervais [david_eg@mail.com]");
109 new_draw_info (NDI_UNIQUE, 0, op, "Mitsuhiro Itakura [ita@gold.koma.jaeri.go.jp]"); 109 new_draw_info (NDI_UNIQUE, 0, op, "Mitsuhiro Itakura [ita@gold.koma.jaeri.go.jp]");
110 new_draw_info (NDI_UNIQUE, 0, op, "Hansjoerg Malthaner [hansjoerg.malthaner@danet.de]"); 110 new_draw_info (NDI_UNIQUE, 0, op, "Hansjoerg Malthaner [hansjoerg.malthaner@danet.de]");
111 new_draw_info (NDI_UNIQUE, 0, op, "Mårten Woxberg [maxmc@telia.com]"); 111 new_draw_info (NDI_UNIQUE, 0, op, "MÃ¥rten Woxberg [maxmc@telia.com]");
112 new_draw_info (NDI_UNIQUE, 0, op, "And many more!"); 112 new_draw_info (NDI_UNIQUE, 0, op, "And many more!");
113} 113}
114 114
115void 115void
116info_keys (object *op) 116info_keys (object *op)
… …
158 * simple case at top - no encryption - makes it easier to read. 158 * simple case at top - no encryption - makes it easier to read.
159 */ 159 */
160char * 160char *
161crypt_string (char *str, char *salt) 161crypt_string (char *str, char *salt)
162{ 162{
163#if defined(WIN32) || (defined(__FreeBSD__) && !defined(HAVE_LIBDES)) 163#if (defined(__FreeBSD__) && !defined(HAVE_LIBDES))
164 return (str); 164 return (str);
165#else 165#else
166 static char *c = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789./"; 166 static char *c = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789./";
167 char s[2]; 167 char s[2];
168 168
… …
191 * goes someplace. 191 * goes someplace.
192 */ 192 */
193void 193void
194enter_player_savebed (object *op) 194enter_player_savebed (object *op)
195{ 195{
196 mapstruct *oldmap = op->map; 196 maptile *oldmap = op->map;
197 object *tmp; 197 object *tmp;
198 198
199 tmp = get_object (); 199 tmp = object::create ();
200 200
201 EXIT_PATH (tmp) = op->contr->savebed_map; 201 EXIT_PATH (tmp) = op->contr->savebed_map;
202 EXIT_X (tmp) = op->contr->bed_x; 202 EXIT_X (tmp) = op->contr->bed_x;
203 EXIT_Y (tmp) = op->contr->bed_y; 203 EXIT_Y (tmp) = op->contr->bed_y;
204 enter_exit (op, tmp); 204 enter_exit (op, tmp);
… …
217 EXIT_PATH (tmp) = op->contr->savebed_map; 217 EXIT_PATH (tmp) = op->contr->savebed_map;
218 EXIT_X (tmp) = op->contr->bed_x; 218 EXIT_X (tmp) = op->contr->bed_x;
219 EXIT_Y (tmp) = op->contr->bed_y; 219 EXIT_Y (tmp) = op->contr->bed_y;
220 enter_exit (op, tmp); 220 enter_exit (op, tmp);
221 } 221 }
222 free_object (tmp); 222
223 tmp->destroy ();
223} 224}
224 225
225/* All this really is is a glorified remove_object that also updates 226/* All this really is is a glorified remove_object that also updates
226 * the counts on the map if needed. 227 * the counts on the map if needed.
227 */ 228 */
228void 229void
229leave_map (object *op) 230leave_map (object *op)
230{ 231{
231 mapstruct *oldmap = op->map; 232 maptile *oldmap = op->map;
232 233
233 remove_ob (op); 234 op->remove ();
234 235
235 if (oldmap) 236 if (oldmap)
236 { 237 {
237 if (!op->contr->hidden) 238 if (!op->contr->hidden)
238 oldmap->players--; 239 oldmap->players--;
240
239 if (oldmap->players <= 0) 241 if (oldmap->players <= 0)
240 { /* can be less than zero due to errors in tracking this */ 242 /* can be less than zero due to errors in tracking this */
241 set_map_timeout (oldmap); 243 set_map_timeout (oldmap);
242 }
243 } 244 }
244} 245}
245 246
246/* 247/*
247 * enter_map(): Moves the player and pets from current map (if any) to 248 * enter_map(): Moves the player and pets from current map (if any) to
… …
249 * player to - it could be the map he just came from if the load failed for 250 * player to - it could be the map he just came from if the load failed for
250 * whatever reason. If default map coordinates are to be used, then 251 * whatever reason. If default map coordinates are to be used, then
251 * the function that calls this should figure them out. 252 * the function that calls this should figure them out.
252 */ 253 */
253static void 254static void
254enter_map (object *op, mapstruct *newmap, int x, int y) 255enter_map (object *op, maptile *newmap, int x, int y)
255{ 256{
256 mapstruct *oldmap = op->map; 257 maptile *oldmap = op->map;
257 258
258 if (out_of_map (newmap, x, y)) 259 if (out_of_map (newmap, x, y))
259 { 260 {
260 LOG (llevError, "enter_map: supplied coordinates are not within the map! (%s: %d, %d)\n", newmap->path, x, y); 261 LOG (llevError, "enter_map: supplied coordinates are not within the map! (%s: %d, %d)\n", newmap->path, x, y);
261 x = MAP_ENTER_X (newmap); 262 x = MAP_ENTER_X (newmap);
… …
266 newmap->path, x, y, MAP_WIDTH (newmap), MAP_HEIGHT (newmap)); 267 newmap->path, x, y, MAP_WIDTH (newmap), MAP_HEIGHT (newmap));
267 new_draw_info (NDI_UNIQUE, 0, op, "The exit is closed"); 268 new_draw_info (NDI_UNIQUE, 0, op, "The exit is closed");
268 return; 269 return;
269 } 270 }
270 } 271 }
272
271 /* try to find a spot for the player */ 273 /* try to find a spot for the player */
272 if (ob_blocked (op, newmap, x, y)) 274 if (ob_blocked (op, newmap, x, y))
273 { /* First choice blocked */ 275 { /* First choice blocked */
274 /* We try to find a spot for the player, starting closest in. 276 /* We try to find a spot for the player, starting closest in.
275 * We could use find_first_free_spot, but that doesn't randomize it at all, 277 * We could use find_first_free_spot, but that doesn't randomize it at all,
… …
284 { 286 {
285 i = find_free_spot (op, newmap, x, y, 1, SIZEOFFREE2 + 1); 287 i = find_free_spot (op, newmap, x, y, 1, SIZEOFFREE2 + 1);
286 if (i == -1) 288 if (i == -1)
287 i = find_free_spot (op, newmap, x, y, 1, SIZEOFFREE); 289 i = find_free_spot (op, newmap, x, y, 1, SIZEOFFREE);
288 } 290 }
291
289 if (i != -1) 292 if (i != -1)
290 { 293 {
291 x += freearr_x[i]; 294 x += freearr_x[i];
292 y += freearr_y[i]; 295 y += freearr_y[i];
293 } 296 }
… …
296 /* not much we can do in this case. */ 299 /* not much we can do in this case. */
297 LOG (llevInfo, "enter_map: Could not find free spot for player - will dump on top of object (%s: %d, %d)\n", newmap->path, x, y); 300 LOG (llevInfo, "enter_map: Could not find free spot for player - will dump on top of object (%s: %d, %d)\n", newmap->path, x, y);
298 } 301 }
299 } /* end if looking for free spot */ 302 } /* end if looking for free spot */
300 303
301 if (op->map != NULL) 304 if (op->map)
302 {
303 INVOKE_PLAYER (MAP_CHANGE, op->contr, ARG_MAP (op->map), ARG_MAP (newmap));
304 INVOKE_MAP (LEAVE, op->map, ARG_PLAYER (op->contr)); 305 if (INVOKE_MAP (LEAVE, op->map, ARG_PLAYER (op->contr)))
305 } 306 return;
307
308 if (INVOKE_PLAYER (MAP_CHANGE, op->contr, ARG_MAP (newmap), ARG_INT (x), ARG_INT (y)))
309 return;
310
311 if (INVOKE_MAP (ENTER, newmap, ARG_PLAYER (op->contr), ARG_INT (x), ARG_INT (y)))
312 return;
306 313
307 /* If it is a player login, he has yet to be inserted anyplace. 314 /* If it is a player login, he has yet to be inserted anyplace.
308 * otherwise, we need to deal with removing the player here. 315 * otherwise, we need to deal with removing the player here.
309 */ 316 */
310 if (!QUERY_FLAG (op, FLAG_REMOVED)) 317 op->remove ();
311 remove_ob (op);
312 318
313 /* remove_ob clears these so they must be reset after the remove_ob call */ 319 /* remove_ob clears these so they must be reset after the remove_ob call */
314 op->x = x; 320 op->x = x;
315 op->y = y; 321 op->y = y;
316 op->map = newmap; 322 op->map = newmap;
323
317 insert_ob_in_map (op, op->map, NULL, INS_NO_WALK_ON); 324 insert_ob_in_map (op, op->map, NULL, INS_NO_WALK_ON);
318
319 INVOKE_MAP (ENTER, op->map, ARG_PLAYER (op->contr));
320 325
321 if (!op->contr->hidden) 326 if (!op->contr->hidden)
322 newmap->players++; 327 newmap->players++;
323 328
324 newmap->timeout = 0; 329 newmap->timeout = 0;
… …
334 if (op->type == PLAYER && op->contr->ranges[range_golem] != NULL) 339 if (op->type == PLAYER && op->contr->ranges[range_golem] != NULL)
335 { 340 {
336 int i = find_free_spot (op->contr->ranges[range_golem], newmap, 341 int i = find_free_spot (op->contr->ranges[range_golem], newmap,
337 x, y, 1, SIZEOFFREE); 342 x, y, 1, SIZEOFFREE);
338 343
339 remove_ob (op->contr->ranges[range_golem]); 344 op->contr->ranges[range_golem]->remove ();
345
340 if (i == -1) 346 if (i == -1)
341 { 347 {
342 remove_friendly_object (op->contr->ranges[range_golem]); 348 remove_friendly_object (op->contr->ranges[range_golem]);
343 free_object (op->contr->ranges[range_golem]); 349 op->contr->ranges[range_golem]->destroy ();
344 op->contr->ranges[range_golem] = NULL; 350 op->contr->ranges[range_golem] = 0;
345 op->contr->golem_count = 0;
346 } 351 }
347 else 352 else
348 { 353 {
349 object *tmp;
350
351 for (tmp = op->contr->ranges[range_golem]; tmp != NULL; tmp = tmp->more) 354 for (object *tmp = op->contr->ranges[range_golem]; tmp != NULL; tmp = tmp->more)
352 { 355 {
353 tmp->x = x + freearr_x[i] + (tmp->arch == NULL ? 0 : tmp->arch->clone.x); 356 tmp->x = x + freearr_x[i] + (tmp->arch == NULL ? 0 : tmp->arch->clone.x);
354 tmp->y = y + freearr_y[i] + (tmp->arch == NULL ? 0 : tmp->arch->clone.y); 357 tmp->y = y + freearr_y[i] + (tmp->arch == NULL ? 0 : tmp->arch->clone.y);
355 tmp->map = newmap; 358 tmp->map = newmap;
356 } 359 }
360
357 insert_ob_in_map (op->contr->ranges[range_golem], newmap, NULL, 0); 361 insert_ob_in_map (op->contr->ranges[range_golem], newmap, NULL, 0);
358 op->contr->ranges[range_golem]->direction = 362 op->contr->ranges[range_golem]->direction =
359 find_dir_2 (op->x - op->contr->ranges[range_golem]->x, op->y - op->contr->ranges[range_golem]->y); 363 find_dir_2 (op->x - op->contr->ranges[range_golem]->x, op->y - op->contr->ranges[range_golem]->y);
360 } 364 }
361 } 365 }
366
362 op->direction = 0; 367 op->direction = 0;
363 368
364 /* since the players map is already loaded, we don't need to worry 369 /* since the players map is already loaded, we don't need to worry
365 * about pending objects. 370 * about pending objects.
366 */ 371 */
… …
381 } 386 }
382 } 387 }
383} 388}
384 389
385void 390void
386set_map_timeout (mapstruct *oldmap) 391set_map_timeout (maptile *oldmap)
387{ 392{
388#if MAP_MAXTIMEOUT 393#if MAP_MAXTIMEOUT
389 oldmap->timeout = MAP_TIMEOUT (oldmap); 394 oldmap->timeout = MAP_TIMEOUT (oldmap);
390 /* Do MINTIMEOUT first, so that MAXTIMEOUT is used if that is 395 /* Do MINTIMEOUT first, so that MAXTIMEOUT is used if that is
391 * lower than the min value. 396 * lower than the min value.
392 */ 397 */
393# if MAP_MINTIMEOUT 398# if MAP_MINTIMEOUT
394 if (oldmap->timeout < MAP_MINTIMEOUT) 399 if (oldmap->timeout < MAP_MINTIMEOUT)
395 {
396 oldmap->timeout = MAP_MINTIMEOUT; 400 oldmap->timeout = MAP_MINTIMEOUT;
397 }
398# endif 401# endif
402
399 if (oldmap->timeout > MAP_MAXTIMEOUT) 403 if (oldmap->timeout > MAP_MAXTIMEOUT)
400 {
401 oldmap->timeout = MAP_MAXTIMEOUT; 404 oldmap->timeout = MAP_MAXTIMEOUT;
402 } 405
403#else 406#else
404 /* save out the map */ 407 /* save out the map */
405 swap_map (oldmap); 408 swap_map (oldmap);
406#endif /* MAP_MAXTIMEOUT */ 409#endif /* MAP_MAXTIMEOUT */
407} 410}
… …
452 */ 455 */
453 456
454static void 457static void
455enter_random_map (object *pl, object *exit_ob) 458enter_random_map (object *pl, object *exit_ob)
456{ 459{
457 mapstruct *new_map; 460 maptile *new_map;
458 char newmap_name[HUGE_BUF], *cp; 461 char newmap_name[HUGE_BUF], *cp;
459 static int reference_number = 0; 462 static int reference_number = 0;
460 RMParms rp; 463 RMParms rp;
461 464
462 memset (&rp, 0, sizeof (RMParms)); 465 memset (&rp, 0, sizeof (RMParms));
… …
522 */ 525 */
523 526
524static void 527static void
525enter_fixed_template_map (object *pl, object *exit_ob) 528enter_fixed_template_map (object *pl, object *exit_ob)
526{ 529{
527 mapstruct *new_map; 530 maptile *new_map;
528 char tmpnum[32], exitpath[HUGE_BUF], resultname[HUGE_BUF], tmpstring[HUGE_BUF], *sourcemap; 531 char tmpnum[32], exitpath[HUGE_BUF], resultname[HUGE_BUF], tmpstring[HUGE_BUF], *sourcemap;
529 const char *new_map_name; 532 const char *new_map_name;
530 533
531 /* Split the exit path string into two parts, one 534 /* Split the exit path string into two parts, one
532 * for where to store the map, and one for were 535 * for where to store the map, and one for were
… …
541 */ 544 */
542 LOG (llevError, "enter_fixed_template_map: Exit %s (%d,%d) on map %s has no source template.\n", 545 LOG (llevError, "enter_fixed_template_map: Exit %s (%d,%d) on map %s has no source template.\n",
543 &exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map->path); 546 &exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map->path);
544 return; 547 return;
545 } 548 }
549
546 *sourcemap++ = '\0'; 550 *sourcemap++ = '\0';
547 551
548 /* If we are not coming from a template map, we can use relative directories 552 /* If we are not coming from a template map, we can use relative directories
549 * for the map to generate from. 553 * for the map to generate from.
550 */ 554 */
551 if (!exit_ob->map->templatemap) 555 if (!exit_ob->map->templatemap)
552 {
553 sourcemap = path_combine_and_normalize (exit_ob->map->path, sourcemap); 556 sourcemap = path_combine_and_normalize (exit_ob->map->path, sourcemap);
554 }
555 557
556 /* Do replacement of %x, %y, and %n to the x coord of the exit, the y coord 558 /* Do replacement of %x, %y, and %n to the x coord of the exit, the y coord
557 * of the exit, and the name of the map the exit is on, respectively. 559 * of the exit, and the name of the map the exit is on, respectively.
558 */ 560 */
559 sprintf (tmpnum, "%d", exit_ob->x); 561 sprintf (tmpnum, "%d", exit_ob->x);
… …
568 570
569 /* If we are coming from another template map, use reletive paths unless 571 /* If we are coming from another template map, use reletive paths unless
570 * indicated otherwise. 572 * indicated otherwise.
571 */ 573 */
572 if (exit_ob->map->templatemap && (resultname[0] != '/')) 574 if (exit_ob->map->templatemap && (resultname[0] != '/'))
573 {
574 new_map_name = path_combine_and_normalize (exit_ob->map->path, resultname); 575 new_map_name = path_combine_and_normalize (exit_ob->map->path, resultname);
575 }
576 else 576 else
577 {
578 new_map_name = create_template_pathname (resultname); 577 new_map_name = create_template_pathname (resultname);
579 }
580 578
581 /* Attempt to load the map, if unable to, then 579 /* Attempt to load the map, if unable to, then
582 * create the map from the template. 580 * create the map from the template.
583 */ 581 */
584 new_map = ready_map_name (new_map_name, MAP_PLAYER_UNIQUE); 582 new_map = ready_map_name (new_map_name, MAP_PLAYER_UNIQUE);
… …
606 LOG (llevDebug, "enter_fixed_template_map: Exit %s (%d,%d) on map %s leads no where.\n", 604 LOG (llevDebug, "enter_fixed_template_map: Exit %s (%d,%d) on map %s leads no where.\n",
607 &exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map->path); 605 &exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map->path);
608 } 606 }
609} 607}
610 608
611
612/* The player is trying to enter a randomly generated template map. In this 609/* The player is trying to enter a randomly generated template map. In this
613 * case, generate the map as needed. 610 * case, generate the map as needed.
614 */ 611 */
615 612
616static void 613static void
617enter_random_template_map (object *pl, object *exit_ob) 614enter_random_template_map (object *pl, object *exit_ob)
618{ 615{
619 mapstruct *new_map; 616 maptile *new_map;
620 char tmpnum[32], resultname[HUGE_BUF], tmpstring[HUGE_BUF]; 617 char tmpnum[32], resultname[HUGE_BUF], tmpstring[HUGE_BUF];
621 const char *new_map_name; 618 const char *new_map_name;
622 RMParms rp; 619 RMParms rp;
623 620
624 /* Do replacement of %x, %y, and %n to the x coord of the exit, the y coord 621 /* Do replacement of %x, %y, and %n to the x coord of the exit, the y coord
… …
686 */ 683 */
687static void 684static void
688enter_unique_map (object *op, object *exit_ob) 685enter_unique_map (object *op, object *exit_ob)
689{ 686{
690 char apartment[HUGE_BUF]; 687 char apartment[HUGE_BUF];
691 mapstruct *newmap; 688 maptile *newmap;
692 689
693 if (EXIT_PATH (exit_ob)[0] == '/') 690 if (EXIT_PATH (exit_ob)[0] == '/')
694 { 691 {
695 sprintf (apartment, "%s/%s/%s/%s", settings.localdir, settings.playerdir, &op->name, clean_path (EXIT_PATH (exit_ob))); 692 sprintf (apartment, "%s/%s/%s/%s", settings.localdir, settings.playerdir, &op->name, clean_path (EXIT_PATH (exit_ob)));
696 newmap = ready_map_name (apartment, MAP_PLAYER_UNIQUE); 693 newmap = ready_map_name (apartment, MAP_PLAYER_UNIQUE);
… …
780#define PORTAL_DESTINATION_NAME "Town portal destination" /* this one should really be in a header file */ 777#define PORTAL_DESTINATION_NAME "Town portal destination" /* this one should really be in a header file */
781 object *tmp; 778 object *tmp;
782 779
783 /* It may be nice to support other creatures moving across 780 /* It may be nice to support other creatures moving across
784 * exits, but right now a lot of the code looks at op->contr, 781 * exits, but right now a lot of the code looks at op->contr,
785 * so thta is an RFE. 782 * so that is an RFE.
786 */ 783 */
787 if (op->type != PLAYER) 784 if (op->type != PLAYER)
788 return; 785 return;
789 786
790 /* First, lets figure out what map the player is going to go to */ 787 /* First, lets figure out what map the player is going to go to */
791 if (exit_ob) 788 if (exit_ob)
792 { 789 {
793
794 /* check to see if we make a template map */ 790 /* check to see if we make a template map */
795 if (EXIT_PATH (exit_ob) && EXIT_PATH (exit_ob)[1] == '@') 791 if (EXIT_PATH (exit_ob) && EXIT_PATH (exit_ob)[1] == '@')
796 { 792 {
797 if (EXIT_PATH (exit_ob)[2] == '!') 793 if (EXIT_PATH (exit_ob)[2] == '!')
798 { 794 {
… …
819 int x = EXIT_X (exit_ob), y = EXIT_Y (exit_ob); 815 int x = EXIT_X (exit_ob), y = EXIT_Y (exit_ob);
820 816
821 /* 'Normal' exits that do not do anything special 817 /* 'Normal' exits that do not do anything special
822 * Simple enough we don't need another routine for it. 818 * Simple enough we don't need another routine for it.
823 */ 819 */
824 mapstruct *newmap; 820 maptile *newmap;
825 821
826 if (exit_ob->map) 822 if (exit_ob->map)
827 { 823 {
828 newmap = ready_map_name (path_combine_and_normalize (exit_ob->map->path, EXIT_PATH (exit_ob)), 0); 824 newmap = ready_map_name (path_combine_and_normalize (exit_ob->map->path, EXIT_PATH (exit_ob)), 0);
829 /* Random map was previously generated, but is no longer about. Lets generate a new 825 /* Random map was previously generated, but is no longer about. Lets generate a new
… …
897 if (tmp->type == FORCE && tmp->slaying && !strcmp (tmp->slaying, PORTAL_DESTINATION_NAME)) 893 if (tmp->type == FORCE && tmp->slaying && !strcmp (tmp->slaying, PORTAL_DESTINATION_NAME))
898 break; 894 break;
899 } 895 }
900 if (tmp) 896 if (tmp)
901 { 897 {
902 remove_ob (tmp); 898 tmp->remove ();
903 free_object (tmp); 899 tmp->destroy ();
904 } 900 }
905 901
906 strcpy (op->contr->savebed_map, path_combine_and_normalize (exit_ob->map->path, EXIT_PATH (exit_ob))); 902 strcpy (op->contr->savebed_map, path_combine_and_normalize (exit_ob->map->path, EXIT_PATH (exit_ob)));
907 op->contr->bed_x = EXIT_X (exit_ob), op->contr->bed_y = EXIT_Y (exit_ob); 903 op->contr->bed_x = EXIT_X (exit_ob), op->contr->bed_y = EXIT_Y (exit_ob);
908 save_player (op, 1); 904 save_player (op, 1);
… …
918 hit_player (op, exit_ob->stats.dam, exit_ob, exit_ob->attacktype, 1); 914 hit_player (op, exit_ob->stats.dam, exit_ob, exit_ob->attacktype, 1);
919 } 915 }
920 else 916 else
921 { 917 {
922 int flags = 0; 918 int flags = 0;
923 mapstruct *newmap; 919 maptile *newmap;
924
925 920
926 /* Hypothetically, I guess its possible that a standard map matches 921 /* Hypothetically, I guess its possible that a standard map matches
927 * the localdir, but that seems pretty unlikely - unlikely enough that 922 * the localdir, but that seems pretty unlikely - unlikely enough that
928 * I'm not going to attempt to try to deal with that possibility. 923 * I'm not going to attempt to try to deal with that possibility.
929 * We use the fact that when a player saves on a unique map, it prepends 924 * We use the fact that when a player saves on a unique map, it prepends
… …
950 { 945 {
951 LOG (llevError, "enter_exit: could not load emergency map? Fatal error\n"); 946 LOG (llevError, "enter_exit: could not load emergency map? Fatal error\n");
952 abort (); 947 abort ();
953 } 948 }
954 } 949 }
950
955 enter_map (op, newmap, op->x, op->y); 951 enter_map (op, newmap, op->x, op->y);
956 } 952 }
957} 953}
958 954
959/* 955/*
… …
964 960
965#if 0 // dead code, schmorp 961#if 0 // dead code, schmorp
966void 962void
967process_active_maps () 963process_active_maps ()
968{ 964{
969 for (mapstruct *map = first_map; map != NULL; map = map->next) 965 for (maptile *map = first_map; map != NULL; map = map->next)
970 if (map->in_memory == MAP_IN_MEMORY) 966 if (map->in_memory == MAP_IN_MEMORY)
971 if (players_on_map (map, TRUE)) 967 if (players_on_map (map, TRUE))
972 process_events (map); 968 process_events (map);
973} 969}
974#endif 970#endif
… …
980 * objects have been updated, process_players2() does the processing that 976 * objects have been updated, process_players2() does the processing that
981 * is needed after the players have been updated. 977 * is needed after the players have been updated.
982 */ 978 */
983 979
984void 980void
985process_players1 (mapstruct *map) 981process_players1 (maptile *map)
986{ 982{
987 int flag; 983 int flag;
988 player *pl, *plnext; 984 player *pl, *plnext;
989 985
990 /* Basically, we keep looping until all the players have done their actions. */ 986 /* Basically, we keep looping until all the players have done their actions. */
… …
1057 /* draw(pl->ob); *//* updated in socket code */ 1053 /* draw(pl->ob); *//* updated in socket code */
1058 } 1054 }
1059} 1055}
1060 1056
1061void 1057void
1062process_players2 (mapstruct *map) 1058process_players2 (maptile *map)
1063{ 1059{
1064 player *pl; 1060 player *pl;
1065 1061
1066 /* Then check if any players should use weapon-speed instead of speed */ 1062 /* Then check if any players should use weapon-speed instead of speed */
1067 for (pl = first_player; pl != NULL; pl = pl->next) 1063 for (pl = first_player; pl != NULL; pl = pl->next)
… …
1097 pl->ob->speed_left = pl->ob->speed; 1093 pl->ob->speed_left = pl->ob->speed;
1098 } 1094 }
1099} 1095}
1100 1096
1101void 1097void
1102process_events (mapstruct *map) 1098process_events (maptile *map)
1103{ 1099{
1104 object *op; 1100 object *op;
1105 object *marker = get_object (); 1101
1106 tag_t tag; 1102 static object *marker;
1103
1104 if (!marker)
1105 marker = object::create ();
1107 1106
1108 process_players1 (map); 1107 process_players1 (map);
1109 1108
1110 marker->active_next = active_objects; 1109 marker->active_next = active_objects;
1111 1110
… …
1116 active_objects = marker; 1115 active_objects = marker;
1117 1116
1118 while (marker->active_next) 1117 while (marker->active_next)
1119 { 1118 {
1120 op = marker->active_next; 1119 op = marker->active_next;
1121 tag = op->count;
1122 1120
1123 /* Move marker forward - swap op and marker */ 1121 /* Move marker forward - swap op and marker */
1124 op->active_prev = marker->active_prev; 1122 op->active_prev = marker->active_prev;
1125 1123
1126 if (op->active_prev) 1124 if (op->active_prev)
… …
1156 * around. 1154 * around.
1157 */ 1155 */
1158 if (QUERY_FLAG (op, FLAG_REMOVED) && op->type != PLAYER && op->map && op->map->in_memory != MAP_IN_MEMORY) 1156 if (QUERY_FLAG (op, FLAG_REMOVED) && op->type != PLAYER && op->map && op->map->in_memory != MAP_IN_MEMORY)
1159 { 1157 {
1160 LOG (llevError, "BUG: process_events(): Removed object on list\n"); 1158 LOG (llevError, "BUG: process_events(): Removed object on list\n");
1161 dump_object (op); 1159 char *dump = dump_object (op);
1162 LOG (llevError, errmsg); 1160 LOG (llevError, dump);
1163 free_object (op); 1161 free (dump);
1162 op->destroy ();
1164 continue; 1163 continue;
1165 } 1164 }
1166 1165
1167 if (!op->speed) 1166 if (!op->speed)
1168 { 1167 {
… …
1213 LOG (llevDebug, "process_events: calling process_object with removed object %s\n", op->name ? op->name : "null"); 1212 LOG (llevDebug, "process_events: calling process_object with removed object %s\n", op->name ? op->name : "null");
1214 } 1213 }
1215#endif 1214#endif
1216 --op->speed_left; 1215 --op->speed_left;
1217 process_object (op); 1216 process_object (op);
1217
1218 if (was_destroyed (op, tag)) 1218 if (op->destroyed ())
1219 continue; 1219 continue;
1220 } 1220 }
1221
1221 if (settings.casting_time == TRUE && op->casting_time > 0) 1222 if (settings.casting_time == TRUE && op->casting_time > 0)
1222 op->casting_time--; 1223 op->casting_time--;
1224
1223 if (op->speed_left <= 0) 1225 if (op->speed_left <= 0)
1224 op->speed_left += FABS (op->speed); 1226 op->speed_left += FABS (op->speed);
1225 } 1227 }
1226 1228
1227 /* Remove marker object from active list */ 1229 /* Remove marker object from active list */
… …
1229 marker->active_prev->active_next = NULL; 1231 marker->active_prev->active_next = NULL;
1230 else 1232 else
1231 active_objects = NULL; 1233 active_objects = NULL;
1232 1234
1233 process_players2 (map); 1235 process_players2 (map);
1234
1235 free_object (marker);
1236} 1236}
1237 1237
1238void 1238void
1239clean_tmp_files (void) 1239clean_tmp_files (void)
1240{ 1240{
1241 mapstruct *m, *next; 1241 maptile *m, *next;
1242 1242
1243 LOG (llevInfo, "Cleaning up...\n"); 1243 LOG (llevInfo, "Cleaning up...\n");
1244 1244
1245 /* We save the maps - it may not be intuitive why, but if there are unique 1245 /* We save the maps - it may not be intuitive why, but if there are unique
1246 * items, we need to save the map so they get saved off. Perhaps we should 1246 * items, we need to save the map so they get saved off. Perhaps we should
… …
1274/* clean up everything before exiting */ 1274/* clean up everything before exiting */
1275void 1275void
1276cleanup (void) 1276cleanup (void)
1277{ 1277{
1278 LOG (llevDebug, "Cleanup called.\n"); 1278 LOG (llevDebug, "Cleanup called.\n");
1279
1280 for (player *pl = first_player; pl != NULL; pl = pl->next)
1281 save_player (pl->ob, 0);
1282
1283 for (player *pl = first_player; pl != NULL; pl = pl->next)
1284 if (!QUERY_FLAG (pl->ob, FLAG_REMOVED))
1285 leave_map (pl->ob);
1286
1287 clean_tmp_files ();
1279 write_book_archive (); 1288 write_book_archive ();
1280 1289
1281 INVOKE_GLOBAL (CLEANUP); 1290 INVOKE_GLOBAL (CLEANUP);
1282 1291
1283 _exit (0); 1292 _exit (0);
… …
1407 flush_old_maps (); /* Clears the tmp-files of maps which have reset */ 1416 flush_old_maps (); /* Clears the tmp-files of maps which have reset */
1408 1417
1409 if (!(pticks % 2503)) 1418 if (!(pticks % 2503))
1410 fix_weight (); /* Hack to fix weightproblems caused by bugs */ 1419 fix_weight (); /* Hack to fix weightproblems caused by bugs */
1411 1420
1412 if (!(pticks % 2521))
1413 metaserver_update (); /* 2500 ticks is about 5 minutes */
1414
1415 if (!(pticks % 5003)) 1421 if (!(pticks % 5003))
1416 write_book_archive (); 1422 write_book_archive ();
1417 1423
1418 if (!(pticks % 5009)) 1424 if (!(pticks % 5009))
1419 clean_friendly_list (); 1425 clean_friendly_list ();
… …
1445main (int argc, char **argv) 1451main (int argc, char **argv)
1446{ 1452{
1447 settings.argc = argc; 1453 settings.argc = argc;
1448 settings.argv = argv; 1454 settings.argv = argv;
1449 1455
1450 cfperl_init ();
1451
1452 init (argc, argv); 1456 init (argc, argv);
1453 1457
1454 initPlugins (); 1458 initPlugins ();
1455 1459
1456 for (;;) 1460 for (;;)

Diff Legend

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