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.56 by root, Mon Dec 25 11:25:49 2006 UTC vs.
Revision 1.62 by root, Sat Dec 30 10:16:11 2006 UTC

… …
128 new_draw_info (NDI_UNIQUE, 0, op, "Ctrl-R = refresh Ctrl-C = clear"); 128 new_draw_info (NDI_UNIQUE, 0, op, "Ctrl-R = refresh Ctrl-C = clear");
129 new_draw_info (NDI_UNIQUE, 0, op, "You can type a number before most commands."); 129 new_draw_info (NDI_UNIQUE, 0, op, "You can type a number before most commands.");
130 new_draw_info (NDI_UNIQUE, 0, op, "(For instance 3d drops 3 items.)"); 130 new_draw_info (NDI_UNIQUE, 0, op, "(For instance 3d drops 3 items.)");
131} 131}
132 132
133void
134start_info (object *op)
135{
136 char buf[MAX_BUF];
137
138 sprintf (buf, "Welcome to Crossfire v%s!", VERSION);
139 new_draw_info (NDI_UNIQUE, 0, op, buf);
140 new_draw_info (NDI_UNIQUE, 0, op, "Press `?' for help");
141 new_draw_info (NDI_UNIQUE, 0, op, " ");
142 new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, op, "%s entered the game.", &op->name);
143}
144
145/* This is a basic little function to put the player back to his 133/* This is a basic little function to put the player back to his
146 * savebed. We do some error checking - its possible that the 134 * savebed. We do some error checking - its possible that the
147 * savebed map may no longer exist, so we make sure the player 135 * savebed map may no longer exist, so we make sure the player
148 * goes someplace. 136 * goes someplace.
149 */ 137 */
… …
156 tmp = object::create (); 144 tmp = object::create ();
157 145
158 EXIT_PATH (tmp) = op->contr->savebed_map; 146 EXIT_PATH (tmp) = op->contr->savebed_map;
159 EXIT_X (tmp) = op->contr->bed_x; 147 EXIT_X (tmp) = op->contr->bed_x;
160 EXIT_Y (tmp) = op->contr->bed_y; 148 EXIT_Y (tmp) = op->contr->bed_y;
161 enter_exit (op, tmp); 149 op->enter_exit (tmp);
150
162 /* If the player has not changed maps and the name does not match 151 /* If the player has not changed maps and the name does not match
163 * that of the savebed, his savebed map is gone. Lets go back 152 * that of the savebed, his savebed map is gone. Lets go back
164 * to the emergency path. Update what the players savebed is 153 * to the emergency path. Update what the players savebed is
165 * while we're at it. 154 * while we're at it.
166 */ 155 */
156 //TODO: must go - move to interim map
167 if (oldmap == op->map && strcmp (op->contr->savebed_map, oldmap->path)) 157 if (oldmap == op->map && strcmp (op->contr->savebed_map, oldmap->path))
168 { 158 {
169 LOG (llevDebug, "Player %s savebed location %s is invalid - going to emergency location (%s)\n", 159 LOG (llevDebug, "Player %s savebed location %s is invalid - going to emergency location\n",
170 settings.emergency_mapname, &op->name, op->contr->savebed_map); 160 &op->name, op->contr->savebed_map);
171 strcpy (op->contr->savebed_map, settings.emergency_mapname); 161 strcpy (op->contr->savebed_map, "/world/world_105_115");
172 op->contr->bed_x = settings.emergency_x; 162 op->contr->bed_x = 5;
173 op->contr->bed_y = settings.emergency_y; 163 op->contr->bed_y = 37;
174 EXIT_PATH (tmp) = op->contr->savebed_map; 164 EXIT_PATH (tmp) = op->contr->savebed_map;
175 EXIT_X (tmp) = op->contr->bed_x; 165 EXIT_X (tmp) = op->contr->bed_x;
176 EXIT_Y (tmp) = op->contr->bed_y; 166 EXIT_Y (tmp) = op->contr->bed_y;
177 enter_exit (op, tmp); 167 op->enter_exit (tmp);
178 } 168 }
179 169
180 tmp->destroy (); 170 tmp->destroy ();
181} 171}
182 172
183/* All this really is is a glorified remove_object that also updates
184 * the counts on the map if needed.
185 */
186void
187leave_map (object *op)
188{
189 maptile *oldmap = op->map;
190
191 op->remove ();
192
193 if (oldmap)
194 {
195 if (!op->contr->hidden)
196 oldmap->players--;
197
198 if (oldmap->players <= 0)
199 /* can be less than zero due to errors in tracking this */
200 set_map_timeout (oldmap);
201 }
202}
203
204/* 173/*
205 * enter_map(): Moves the player and pets from current map (if any) to 174 * enter_map(): Moves the player and pets from current map (if any) to
206 * new map. map, x, y must be set. map is the map we are moving the 175 * new map. map, x, y must be set. map is the map we are moving the
207 * player to - it could be the map he just came from if the load failed for 176 * player to - it could be the map he just came from if the load failed for
208 * whatever reason. If default map coordinates are to be used, then 177 * whatever reason. If default map coordinates are to be used, then
209 * the function that calls this should figure them out. 178 * the function that calls this should figure them out.
210 */ 179 */
211static void 180void
212enter_map (object *op, maptile *newmap, int x, int y) 181object::enter_map (maptile *newmap, int x, int y)
213{ 182{
214 maptile *oldmap = op->map; 183 if (!newmap->load ())
184 return;
215 185
216 if (out_of_map (newmap, x, y)) 186 if (out_of_map (newmap, x, y))
217 { 187 {
218 LOG (llevError, "enter_map: supplied coordinates are not within the map! (%s: %d, %d)\n", newmap->path, x, y); 188 LOG (llevError, "enter_map: supplied coordinates are not within the map! (%s: %d, %d)\n", &newmap->path, x, y);
219 x = MAP_ENTER_X (newmap); 189 x = newmap->enter_x;
220 y = MAP_ENTER_Y (newmap); 190 y = newmap->enter_y;
221 if (out_of_map (newmap, x, y)) 191 if (out_of_map (newmap, x, y))
222 { 192 {
223 LOG (llevError, "enter_map: map %s provides invalid default enter location (%d, %d) > (%d, %d)\n", 193 LOG (llevError, "enter_map: map %s provides invalid default enter location (%d, %d) > (%d, %d)\n",
224 newmap->path, x, y, MAP_WIDTH (newmap), MAP_HEIGHT (newmap)); 194 &newmap->path, x, y, newmap->width, newmap->height);
225 new_draw_info (NDI_UNIQUE, 0, op, "The exit is closed"); 195 new_draw_info (NDI_UNIQUE, 0, this, "The exit is closed");
226 return; 196 return;
227 } 197 }
228 } 198 }
229 199
230 /* try to find a spot for the player */ 200 /* try to find a spot for the player */
231 if (ob_blocked (op, newmap, x, y)) 201 if (ob_blocked (this, newmap, x, y))
232 { /* First choice blocked */ 202 { /* First choice blocked */
233 /* We try to find a spot for the player, starting closest in. 203 /* We try to find a spot for the player, starting closest in.
234 * We could use find_first_free_spot, but that doesn't randomize it at all, 204 * We could use find_first_free_spot, but that doesn't randomize it at all,
235 * So for example, if the north space is free, you would always end up there even 205 * So for example, if the north space is free, you would always end up there even
236 * if other spaces around are available. 206 * if other spaces around are available.
237 * Note that for the second and third calls, we could start at a position other 207 * Note that for the second and third calls, we could start at a position other
238 * than one, but then we could end up on the other side of walls and so forth. 208 * than one, but then we could end up on the other side of walls and so forth.
239 */ 209 */
240 int i = find_free_spot (op, newmap, x, y, 1, SIZEOFFREE1 + 1); 210 int i = find_free_spot (this, newmap, x, y, 1, SIZEOFFREE1 + 1);
241 211
242 if (i == -1) 212 if (i == -1)
243 { 213 {
244 i = find_free_spot (op, newmap, x, y, 1, SIZEOFFREE2 + 1); 214 i = find_free_spot (this, newmap, x, y, 1, SIZEOFFREE2 + 1);
245 if (i == -1) 215 if (i == -1)
246 i = find_free_spot (op, newmap, x, y, 1, SIZEOFFREE); 216 i = find_free_spot (this, newmap, x, y, 1, SIZEOFFREE);
247 } 217 }
248 218
249 if (i != -1) 219 if (i != -1)
250 { 220 {
251 x += freearr_x[i]; 221 x += freearr_x[i];
252 y += freearr_y[i]; 222 y += freearr_y[i];
253 } 223 }
254 else 224 else
255 {
256 /* not much we can do in this case. */ 225 /* not much we can do in this case. */
257 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); 226 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);
258 } 227 }
259 } /* end if looking for free spot */
260 228
261 if (op->map) 229 if (map)
262 if (INVOKE_MAP (LEAVE, op->map, ARG_PLAYER (op->contr))) 230 if (INVOKE_MAP (LEAVE, map, ARG_PLAYER (contr)))
263 return; 231 return;
264 232
265 if (INVOKE_PLAYER (MAP_CHANGE, op->contr, ARG_MAP (newmap), ARG_INT (x), ARG_INT (y))) 233 if (INVOKE_PLAYER (MAP_CHANGE, contr, ARG_MAP (newmap), ARG_INT (x), ARG_INT (y)))
266 return; 234 return;
267 235
268 if (INVOKE_MAP (ENTER, newmap, ARG_PLAYER (op->contr), ARG_INT (x), ARG_INT (y))) 236 if (INVOKE_MAP (ENTER, newmap, ARG_PLAYER (contr), ARG_INT (x), ARG_INT (y)))
269 return; 237 return;
270 238
271 /* If it is a player login, he has yet to be inserted anyplace. 239 /* If it is a player login, he has yet to be inserted anyplace.
272 * otherwise, we need to deal with removing the player here. 240 * otherwise, we need to deal with removing the player here.
273 */ 241 */
274 op->remove (); 242 remove ();
275 243
276 /* remove_ob clears these so they must be reset after the remove_ob call */
277 op->x = x; 244 this->x = x;
278 op->y = y; 245 this->y = y;
279 op->map = newmap; 246 map = newmap;
280 247
281 insert_ob_in_map (op, op->map, NULL, INS_NO_WALK_ON); 248 insert_ob_in_map (this, map, 0, INS_NO_WALK_ON);
282
283 if (!op->contr->hidden)
284 newmap->players++;
285 249
286 newmap->timeout = 0; 250 newmap->timeout = 0;
287 op->enemy = NULL; 251 enemy = NULL;
288 252
289 if (op->contr) 253 if (contr)
290 { 254 {
291 strcpy (op->contr->maplevel, newmap->path); 255 strcpy (contr->maplevel, newmap->path);
292 op->contr->count = 0; 256 contr->count = 0;
293 } 257 }
294 258
295 /* Update any golems */ 259 /* Update any golems */
296 if (op->type == PLAYER && op->contr->ranges[range_golem] != NULL) 260 if (type == PLAYER && contr->ranges[range_golem])
297 { 261 {
298 int i = find_free_spot (op->contr->ranges[range_golem], newmap, 262 int i = find_free_spot (contr->ranges[range_golem], newmap,
299 x, y, 1, SIZEOFFREE); 263 x, y, 1, SIZEOFFREE);
300 264
301 op->contr->ranges[range_golem]->remove (); 265 contr->ranges[range_golem]->remove ();
302 266
303 if (i == -1) 267 if (i == -1)
304 { 268 {
305 remove_friendly_object (op->contr->ranges[range_golem]); 269 remove_friendly_object (contr->ranges[range_golem]);
306 op->contr->ranges[range_golem]->destroy (); 270 contr->ranges[range_golem]->destroy ();
307 op->contr->ranges[range_golem] = 0; 271 contr->ranges[range_golem] = 0;
308 } 272 }
309 else 273 else
310 { 274 {
311 for (object *tmp = op->contr->ranges[range_golem]; tmp != NULL; tmp = tmp->more) 275 for (object *tmp = contr->ranges[range_golem]; tmp != NULL; tmp = tmp->more)
312 { 276 {
313 tmp->x = x + freearr_x[i] + (tmp->arch == NULL ? 0 : tmp->arch->clone.x); 277 tmp->x = x + freearr_x[i] + (tmp->arch == NULL ? 0 : tmp->arch->clone.x);
314 tmp->y = y + freearr_y[i] + (tmp->arch == NULL ? 0 : tmp->arch->clone.y); 278 tmp->y = y + freearr_y[i] + (tmp->arch == NULL ? 0 : tmp->arch->clone.y);
315 tmp->map = newmap; 279 tmp->map = newmap;
316 } 280 }
317 281
318 insert_ob_in_map (op->contr->ranges[range_golem], newmap, NULL, 0); 282 insert_ob_in_map (contr->ranges[range_golem], newmap, NULL, 0);
319 op->contr->ranges[range_golem]->direction = 283 contr->ranges[range_golem]->direction =
320 find_dir_2 (op->x - op->contr->ranges[range_golem]->x, op->y - op->contr->ranges[range_golem]->y); 284 find_dir_2 (x - contr->ranges[range_golem]->x, y - contr->ranges[range_golem]->y);
321 } 285 }
322 } 286 }
323 287
324 op->direction = 0; 288 direction = 0;
325 289
326 /* since the players map is already loaded, we don't need to worry 290 /* since the players map is already loaded, we don't need to worry
327 * about pending objects. 291 * about pending objects.
328 */ 292 */
329 remove_all_pets (newmap); 293 remove_all_pets (newmap);
330
331 /* If the player is changing maps, we need to do some special things
332 * Do this after the player is on the new map - otherwise the force swap of the
333 * old map does not work.
334 */
335 if (oldmap != newmap)
336 {
337 if (oldmap) /* adjust old map */
338 {
339 oldmap->players--;
340
341 if (oldmap->players <= 0) /* can be less than zero due to errors in tracking this */
342 set_map_timeout (oldmap);
343 }
344 }
345} 294}
346
347void
348set_map_timeout (maptile *oldmap)
349{
350#if MAP_MAXTIMEOUT
351 oldmap->timeout = MAP_TIMEOUT (oldmap);
352 /* Do MINTIMEOUT first, so that MAXTIMEOUT is used if that is
353 * lower than the min value.
354 */
355# if MAP_MINTIMEOUT
356 if (oldmap->timeout < MAP_MINTIMEOUT)
357 oldmap->timeout = MAP_MINTIMEOUT;
358# endif
359
360 if (oldmap->timeout > MAP_MAXTIMEOUT)
361 oldmap->timeout = MAP_MAXTIMEOUT;
362
363#else
364 /* save out the map */
365 swap_map (oldmap);
366#endif /* MAP_MAXTIMEOUT */
367}
368
369 295
370/* clean_path takes a path and replaces all / with _ 296/* clean_path takes a path and replaces all / with _
371 * We do a strcpy so that we do not change the original string. 297 * We do a strcpy so that we do not change the original string.
372 */ 298 */
373char * 299char *
… …
380 if (*cp == '/') 306 if (*cp == '/')
381 *cp = '_'; 307 *cp = '_';
382 308
383 return newpath; 309 return newpath;
384} 310}
385
386 311
387/* unclean_path takes a path and replaces all _ with / 312/* unclean_path takes a path and replaces all _ with /
388 * This basically undoes clean path. 313 * This basically undoes clean path.
389 * We do a strcpy so that we do not change the original string. 314 * We do a strcpy so that we do not change the original string.
390 * We are smart enough to start after the last / in case we 315 * We are smart enough to start after the last / in case we
… …
402 for (cp = newpath; *cp != '\0'; cp++) 327 for (cp = newpath; *cp != '\0'; cp++)
403 if (*cp == '_') 328 if (*cp == '_')
404 *cp = '/'; 329 *cp = '/';
405 330
406 return newpath; 331 return newpath;
407}
408
409
410/* The player is trying to enter a randomly generated map. In this case, generate the
411 * random map as needed.
412 */
413
414static void
415enter_random_map (object *pl, object *exit_ob)
416{
417 maptile *new_map;
418 char newmap_name[HUGE_BUF], *cp;
419 static int reference_number = 0;
420 RMParms rp;
421
422 memset (&rp, 0, sizeof (RMParms));
423 rp.Xsize = -1;
424 rp.Ysize = -1;
425 rp.region = get_region_by_map (exit_ob->map);
426 if (exit_ob->msg)
427 set_random_map_variable (&rp, exit_ob->msg);
428 rp.origin_x = exit_ob->x;
429 rp.origin_y = exit_ob->y;
430 strcpy (rp.origin_map, pl->map->path);
431
432 /* If we have a final_map, use it as a base name to give some clue
433 * as where the player is. Otherwise, use the origin map.
434 */
435 sprintf (newmap_name, "/random%s+%04d",
436 *rp.final_map ? rp.final_map : rp.origin_map,
437 reference_number++);
438
439 /* now to generate the actual map. */
440 new_map = generate_random_map (newmap_name, &rp);
441
442 /* Update the exit_ob so it now points directly at the newly created
443 * random maps. Not that it is likely to happen, but it does mean that a
444 * exit in a unique map leading to a random map will not work properly.
445 * It also means that if the created random map gets reset before
446 * the exit leading to it, that the exit will no longer work.
447 */
448 if (new_map)
449 {
450 int x, y;
451
452 x = EXIT_X (exit_ob) = MAP_ENTER_X (new_map);
453 y = EXIT_Y (exit_ob) = MAP_ENTER_Y (new_map);
454 EXIT_PATH (exit_ob) = newmap_name;
455 strcpy (new_map->path, newmap_name);
456 enter_map (pl, new_map, x, y);
457 }
458}
459
460/* The player is trying to enter a non-randomly generated template map. In this
461 * case, use a map file for a template
462 */
463
464static void
465enter_fixed_template_map (object *pl, object *exit_ob)
466{
467 maptile *new_map;
468 char tmpnum[32], exitpath[HUGE_BUF], resultname[HUGE_BUF], tmpstring[HUGE_BUF], *sourcemap;
469 const char *new_map_name;
470
471 /* Split the exit path string into two parts, one
472 * for where to store the map, and one for were
473 * to generate the map from.
474 */
475 snprintf (exitpath, sizeof (exitpath), "%s", EXIT_PATH (exit_ob) + 2);
476 sourcemap = strchr (exitpath, '!');
477 if (!sourcemap)
478 {
479 new_draw_info_format (NDI_UNIQUE, 0, pl, "The %s is closed.", &exit_ob->name);
480 /* Should only occur when no source map is set.
481 */
482 LOG (llevError, "enter_fixed_template_map: Exit %s (%d,%d) on map %s has no source template.\n",
483 &exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map->path);
484 return;
485 }
486
487 *sourcemap++ = '\0';
488
489 /* If we are not coming from a template map, we can use relative directories
490 * for the map to generate from.
491 */
492 if (!exit_ob->map->templatemap)
493 sourcemap = path_combine_and_normalize (exit_ob->map->path, sourcemap);
494
495 /* Do replacement of %x, %y, and %n to the x coord of the exit, the y coord
496 * of the exit, and the name of the map the exit is on, respectively.
497 */
498 sprintf (tmpnum, "%d", exit_ob->x);
499 replace (exitpath, "%x", tmpnum, resultname, sizeof (resultname));
500
501 sprintf (tmpnum, "%d", exit_ob->y);
502 sprintf (tmpstring, "%s", resultname);
503 replace (tmpstring, "%y", tmpnum, resultname, sizeof (resultname));
504
505 sprintf (tmpstring, "%s", resultname);
506 replace (tmpstring, "%n", exit_ob->map->name, resultname, sizeof (resultname));
507
508 /* If we are coming from another template map, use reletive paths unless
509 * indicated otherwise.
510 */
511 if (exit_ob->map->templatemap && (resultname[0] != '/'))
512 new_map_name = path_combine_and_normalize (exit_ob->map->path, resultname);
513 else
514 new_map_name = create_template_pathname (resultname);
515
516 /* Attempt to load the map, if unable to, then
517 * create the map from the template.
518 */
519 new_map = ready_map_name (new_map_name, MAP_PLAYER_UNIQUE);
520 if (!new_map)
521 {
522 new_map = load_original_map (create_pathname (sourcemap), MAP_PLAYER_UNIQUE);
523 if (new_map)
524 fix_auto_apply (new_map);
525 }
526
527 if (new_map)
528 {
529 /* set the path of the map to where it should be
530 * so we don't just save over the source map.
531 */
532 strcpy (new_map->path, new_map_name);
533 new_map->templatemap = 1;
534 enter_map (pl, new_map, EXIT_X (exit_ob), EXIT_Y (exit_ob));
535 }
536 else
537 {
538 new_draw_info_format (NDI_UNIQUE, 0, pl, "The %s is closed.", &exit_ob->name);
539 /* Should only occur when an invalid source map is set.
540 */
541 LOG (llevDebug, "enter_fixed_template_map: Exit %s (%d,%d) on map %s leads no where.\n",
542 &exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map->path);
543 }
544}
545
546/* The player is trying to enter a randomly generated template map. In this
547 * case, generate the map as needed.
548 */
549
550static void
551enter_random_template_map (object *pl, object *exit_ob)
552{
553 maptile *new_map;
554 char tmpnum[32], resultname[HUGE_BUF], tmpstring[HUGE_BUF];
555 const char *new_map_name;
556 RMParms rp;
557
558 /* Do replacement of %x, %y, and %n to the x coord of the exit, the y coord
559 * of the exit, and the name of the map the exit is on, respectively.
560 */
561 sprintf (tmpnum, "%d", exit_ob->x);
562 replace (EXIT_PATH (exit_ob) + 3, "%x", tmpnum, resultname, sizeof (resultname));
563
564 sprintf (tmpnum, "%d", exit_ob->y);
565 sprintf (tmpstring, "%s", resultname);
566 replace (tmpstring, "%y", tmpnum, resultname, sizeof (resultname));
567
568 sprintf (tmpstring, "%s", resultname);
569 replace (tmpstring, "%n", exit_ob->map->name, resultname, sizeof (resultname));
570
571 /* If we are coming from another template map, use reletive paths unless
572 * indicated otherwise.
573 */
574 if (exit_ob->map->templatemap && (resultname[0] != '/'))
575 new_map_name = path_combine_and_normalize (exit_ob->map->path, resultname);
576 else
577 new_map_name = create_template_pathname (resultname);
578
579 new_map = ready_map_name (new_map_name, MAP_PLAYER_UNIQUE);
580 if (!new_map)
581 {
582 memset (&rp, 0, sizeof (RMParms));
583 rp.Xsize = -1;
584 rp.Ysize = -1;
585 rp.region = get_region_by_map (exit_ob->map);
586 if (exit_ob->msg)
587 set_random_map_variable (&rp, exit_ob->msg);
588 rp.origin_x = exit_ob->x;
589 rp.origin_y = exit_ob->y;
590 strcpy (rp.origin_map, pl->map->path);
591
592 /* now to generate the actual map. */
593 new_map = generate_random_map (new_map_name, &rp);
594 }
595
596
597 /* Update the exit_ob so it now points directly at the newly created
598 * random maps. Not that it is likely to happen, but it does mean that a
599 * exit in a unique map leading to a random map will not work properly.
600 * It also means that if the created random map gets reset before
601 * the exit leading to it, that the exit will no longer work.
602 */
603 if (new_map)
604 {
605 int x, y;
606
607 x = EXIT_X (exit_ob) = MAP_ENTER_X (new_map);
608 y = EXIT_Y (exit_ob) = MAP_ENTER_Y (new_map);
609 new_map->templatemap = 1;
610 enter_map (pl, new_map, x, y);
611 }
612}
613
614
615/* Code to enter/detect a character entering a unique map.
616 */
617static void
618enter_unique_map (object *op, object *exit_ob)
619{
620 char apartment[HUGE_BUF];
621 maptile *newmap;
622
623 if (EXIT_PATH (exit_ob)[0] == '/')
624 {
625 sprintf (apartment, "%s/%s/%s/%s", settings.localdir, settings.playerdir, &op->name, clean_path (EXIT_PATH (exit_ob)));
626 newmap = ready_map_name (apartment, MAP_PLAYER_UNIQUE);
627 if (!newmap)
628 {
629 newmap = load_original_map (create_pathname (EXIT_PATH (exit_ob)), MAP_PLAYER_UNIQUE);
630 if (newmap)
631 fix_auto_apply (newmap);
632 }
633 }
634 else
635 { /* relative directory */
636 char reldir[HUGE_BUF], tmpc[HUGE_BUF], *cp;
637
638 if (exit_ob->map->unique)
639 {
640
641 strcpy (reldir, unclean_path (exit_ob->map->path));
642
643 /* Need to copy this over, as clean_path only has one static return buffer */
644 strcpy (tmpc, clean_path (reldir));
645 /* Remove final component, if any */
646 if ((cp = strrchr (tmpc, '_')) != NULL)
647 *cp = 0;
648
649 sprintf (apartment, "%s/%s/%s/%s_%s", settings.localdir, settings.playerdir, &op->name, tmpc, clean_path (EXIT_PATH (exit_ob)));
650
651 newmap = ready_map_name (apartment, MAP_PLAYER_UNIQUE);
652 if (!newmap)
653 {
654 newmap = load_original_map (create_pathname (path_combine_and_normalize (reldir, EXIT_PATH (exit_ob))), MAP_PLAYER_UNIQUE);
655 if (newmap)
656 fix_auto_apply (newmap);
657 }
658 }
659 else
660 {
661 /* The exit is unique, but the map we are coming from is not unique. So
662 * use the basic logic - don't need to demangle the path name
663 */
664 sprintf (apartment, "%s/%s/%s/%s", settings.localdir,
665 settings.playerdir, &op->name, clean_path (path_combine_and_normalize (exit_ob->map->path, EXIT_PATH (exit_ob))));
666 newmap = ready_map_name (apartment, MAP_PLAYER_UNIQUE);
667 if (!newmap)
668 {
669 newmap = ready_map_name (path_combine_and_normalize (exit_ob->map->path, EXIT_PATH (exit_ob)), 0);
670 if (newmap)
671 fix_auto_apply (newmap);
672 }
673 }
674 }
675
676 if (newmap)
677 {
678 strcpy (newmap->path, apartment);
679 newmap->unique = 1;
680 enter_map (op, newmap, EXIT_X (exit_ob), EXIT_Y (exit_ob));
681 }
682 else
683 {
684 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s is closed.", &exit_ob->name);
685 /* Perhaps not critical, but I would think that the unique maps
686 * should be new enough this does not happen. This also creates
687 * a strange situation where some players could perhaps have visited
688 * such a map before it was removed, so they have the private
689 * map, but other players can't get it anymore.
690 */
691 LOG (llevDebug, "enter_unique_map: Exit %s (%d,%d) on map %s is leads no where.\n",
692 &exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map->path);
693 }
694
695}
696
697
698/* Tries to move 'op' to exit_ob. op is the character or monster that is
699 * using the exit, where exit_ob is the exit object (boat, door, teleporter,
700 * etc.) if exit_ob is null, then op->contr->maplevel contains that map to
701 * move the object to. This is used when loading the player.
702 *
703 * Largely redone by MSW 2001-01-21 - this function was overly complex
704 * and had some obscure bugs.
705 */
706
707void
708enter_exit (object *op, object *exit_ob)
709{
710#define PORTAL_DESTINATION_NAME "Town portal destination" /* this one should really be in a header file */
711 object *tmp;
712
713 /* It may be nice to support other creatures moving across
714 * exits, but right now a lot of the code looks at op->contr,
715 * so that is an RFE.
716 */
717 if (op->type != PLAYER)
718 return;
719
720 /* First, lets figure out what map the player is going to go to */
721 if (exit_ob)
722 {
723 /* check to see if we make a template map */
724 if (EXIT_PATH (exit_ob) && EXIT_PATH (exit_ob)[1] == '@')
725 {
726 if (EXIT_PATH (exit_ob)[2] == '!')
727 {
728 /* generate a template map randomly */
729 enter_random_template_map (op, exit_ob);
730 }
731 else
732 {
733 /* generate a template map from a fixed template */
734 enter_fixed_template_map (op, exit_ob);
735 }
736 }
737 /* check to see if we make a randomly generated map */
738 else if (EXIT_PATH (exit_ob) && EXIT_PATH (exit_ob)[1] == '!')
739 {
740 enter_random_map (op, exit_ob);
741 }
742 else if (QUERY_FLAG (exit_ob, FLAG_UNIQUE))
743 {
744 enter_unique_map (op, exit_ob);
745 }
746 else
747 {
748 int x = EXIT_X (exit_ob), y = EXIT_Y (exit_ob);
749
750 /* 'Normal' exits that do not do anything special
751 * Simple enough we don't need another routine for it.
752 */
753 maptile *newmap;
754
755 if (exit_ob->map)
756 {
757 newmap = ready_map_name (path_combine_and_normalize (exit_ob->map->path, EXIT_PATH (exit_ob)), 0);
758 /* Random map was previously generated, but is no longer about. Lets generate a new
759 * map.
760 */
761 if (!newmap && !strncmp (EXIT_PATH (exit_ob), "/random/", 8))
762 {
763 /* Maps that go down have a message set. However, maps that go
764 * up, don't. If the going home has reset, there isn't much
765 * point generating a random map, because it won't match the maps.
766 */
767 if (exit_ob->msg)
768 {
769 enter_random_map (op, exit_ob);
770 }
771 else
772 {
773 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s is closed.", &exit_ob->name);
774 return;
775 }
776
777 /* For exits that cause damages (like pits). Don't know if any
778 * random maps use this or not.
779 */
780 if (exit_ob->stats.dam && op->type == PLAYER)
781 hit_player (op, exit_ob->stats.dam, exit_ob, exit_ob->attacktype, 1);
782 return;
783 }
784 }
785 else
786 {
787 /* For word of recall and other force objects
788 * They contain the full pathname of the map to go back to,
789 * so we don't need to normalize it.
790 * But we do need to see if it is unique or not
791 */
792 if (!strncmp (EXIT_PATH (exit_ob), settings.localdir, strlen (settings.localdir)))
793 newmap = ready_map_name (EXIT_PATH (exit_ob), MAP_PLAYER_UNIQUE);
794 else
795 newmap = ready_map_name (EXIT_PATH (exit_ob), 0);
796 }
797 if (!newmap)
798 {
799 if (exit_ob->name)
800 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s is closed.", &exit_ob->name);
801 /* don't cry to momma if name is not set - as in tmp objects
802 * used by the savebed code and character creation */
803 return;
804 }
805
806 /* This supports the old behaviour, but it really should not be used.
807 * I will note for example that with this method, it is impossible to
808 * set 0,0 destination coordinates. Really, if we want to support
809 * using the new maps default coordinates, the exit ob should use
810 * something like -1, -1 so it is clear to do that.
811 */
812 if (x == 0 && y == 0)
813 {
814 x = MAP_ENTER_X (newmap);
815 y = MAP_ENTER_Y (newmap);
816 LOG (llevDebug, "enter_exit: Exit %s (%d,%d) on map %s is 0 destination coordinates\n",
817 &exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map ? exit_ob->map->path : "<nil>");
818 }
819
820 /* mids 02/13/2002 if exit is damned, update players death & WoR home-position and delete town portal */
821 if (QUERY_FLAG (exit_ob, FLAG_DAMNED))
822 {
823 /* remove an old force with a slaying field == PORTAL_DESTINATION_NAME */
824 for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
825 {
826 if (tmp->type == FORCE && tmp->slaying && !strcmp (tmp->slaying, PORTAL_DESTINATION_NAME))
827 break;
828 }
829 if (tmp)
830 {
831 tmp->remove ();
832 tmp->destroy ();
833 }
834
835 strcpy (op->contr->savebed_map, path_combine_and_normalize (exit_ob->map->path, EXIT_PATH (exit_ob)));
836 op->contr->bed_x = EXIT_X (exit_ob), op->contr->bed_y = EXIT_Y (exit_ob);
837 op->contr->save ();
838 /* LOG(llevDebug,"enter_exit: Taking damned exit %s to (%d,%d) on map %s\n",
839 * exit_ob->name?exit_ob->name:"(none)", exit_ob->x, exit_ob->y,
840 * path_combine_and_normalize(exit_ob->map->path, EXIT_PATH(exit_ob))); */
841 }
842
843 enter_map (op, newmap, x, y);
844 }
845 /* For exits that cause damages (like pits) */
846 if (exit_ob->stats.dam && op->type == PLAYER)
847 hit_player (op, exit_ob->stats.dam, exit_ob, exit_ob->attacktype, 1);
848 }
849 else
850 {
851 int flags = 0;
852 maptile *newmap;
853
854 /* Hypothetically, I guess its possible that a standard map matches
855 * the localdir, but that seems pretty unlikely - unlikely enough that
856 * I'm not going to attempt to try to deal with that possibility.
857 * We use the fact that when a player saves on a unique map, it prepends
858 * the localdir to that name. So its an easy way to see of the map is
859 * unique or not.
860 */
861 if (!strncmp (op->contr->maplevel, settings.localdir, strlen (settings.localdir)))
862 flags = MAP_PLAYER_UNIQUE;
863
864 /* newmap returns the map (if already loaded), or loads it for
865 * us.
866 */
867 newmap = ready_map_name (op->contr->maplevel, flags);
868 if (!newmap)
869 {
870 LOG (llevError, "enter_exit: Pathname to map does not exist! (%s)\n", op->contr->maplevel);
871 newmap = ready_map_name (settings.emergency_mapname, 0);
872 op->x = settings.emergency_x;
873 op->y = settings.emergency_y;
874 /* If we can't load the emergency map, something is probably really
875 * screwed up, so bail out now.
876 */
877 if (!newmap)
878 {
879 LOG (llevError, "enter_exit: could not load emergency map? Fatal error\n");
880 abort ();
881 }
882 }
883
884 enter_map (op, newmap, op->x, op->y);
885 }
886} 332}
887 333
888/* process_players1 and process_players2 do all the player related stuff. 334/* process_players1 and process_players2 do all the player related stuff.
889 * I moved it out of process events and process_map. This was to some 335 * I moved it out of process events and process_map. This was to some
890 * extent for debugging as well as to get a better idea of the time used 336 * extent for debugging as well as to get a better idea of the time used
… …
1027 473
1028 /* Now process op */ 474 /* Now process op */
1029 if (QUERY_FLAG (op, FLAG_FREED)) 475 if (QUERY_FLAG (op, FLAG_FREED))
1030 { 476 {
1031 LOG (llevError, "BUG: process_events(): Free object on list\n"); 477 LOG (llevError, "BUG: process_events(): Free object on list\n");
1032 op->speed = 0; 478 op->set_speed (0);
1033 update_ob_speed (op);
1034 continue; 479 continue;
1035 } 480 }
1036 481
1037 /* I've seen occasional crashes due to this - the object is removed, 482 /* I've seen occasional crashes due to this - the object is removed,
1038 * and thus the map it points to (last map it was on) may be bogus 483 * and thus the map it points to (last map it was on) may be bogus
… …
1056 501
1057 if (!op->speed) 502 if (!op->speed)
1058 { 503 {
1059 LOG (llevError, "BUG: process_events(): Object %s has no speed, " 504 LOG (llevError, "BUG: process_events(): Object %s has no speed, "
1060 "but is on active list\n", &op->arch->name); 505 "but is on active list\n", &op->arch->name);
1061 update_ob_speed (op); 506 op->set_speed (0);
1062 continue; 507 continue;
1063 } 508 }
1064 509
1065 if (op->map == NULL && op->env == NULL && op->name && op->type != MAP) 510 if (op->map == NULL && op->env == NULL && op->name && op->type != MAP)
1066 { 511 {
1067 LOG (llevError, "BUG: process_events(): Object without map or " 512 LOG (llevError, "BUG: process_events(): Object without map or "
1068 "inventory is on active list: %s (%d)\n", &op->name, op->count); 513 "inventory is on active list: %s (%d)\n", &op->name, op->count);
1069 op->speed = 0; 514 op->set_speed (0);
1070 update_ob_speed (op);
1071 continue; 515 continue;
1072 } 516 }
1073 517
1074 /* Animate the object. Bug or feature that anim_speed 518 /* Animate the object. Bug or feature that anim_speed
1075 * is based on ticks, and not the creatures speed? 519 * is based on ticks, and not the creatures speed?
… …
1123 active_objects = NULL; 567 active_objects = NULL;
1124 568
1125 process_players2 (); 569 process_players2 ();
1126} 570}
1127 571
1128void
1129clean_tmp_files (void)
1130{
1131 maptile *m, *next;
1132
1133 LOG (llevInfo, "Cleaning up...\n");
1134
1135 /* We save the maps - it may not be intuitive why, but if there are unique
1136 * items, we need to save the map so they get saved off. Perhaps we should
1137 * just make a special function that only saves the unique items.
1138 */
1139 for (m = first_map; m; m = next)
1140 {
1141 next = m->next;
1142
1143 if (m->in_memory == MAP_IN_MEMORY)
1144 {
1145 /* If we want to reuse the temp maps, swap it out (note that will also
1146 * update the log file.
1147 */
1148
1149 swap_map (m);
1150 }
1151 }
1152
1153 write_todclock (); /* lets just write the clock here */
1154}
1155
1156/* clean up everything before exiting */ 572/* clean up everything before exiting */
1157void 573void
574emergency_save ()
575{
576 LOG (llevDebug, "emergency save begin.\n");
577
578 LOG (llevDebug, "saving players.\n");
579 for_all_players (pl)
580 pl->save (1);
581
582// for_all_players (pl)
583// if (pl->ob)
584// pl->ob->remove ();
585
586 LOG (llevDebug, "saving maps.\n");
587 maptile::emergency_save ();
588
589 LOG (llevDebug, "saving book archive.\n");
590 write_book_archive ();
591
592 LOG (llevDebug, "emergency save done.\n");
593}
594
595/* clean up everything before exiting */
596void
1158cleanup (bool make_core) 597cleanup (bool make_core)
1159{ 598{
1160 LOG (llevDebug, "Cleanup called.\n"); 599 LOG (llevDebug, "cleanup begin.\n");
600
601 in_cleanup = true;
1161 602
1162 if (init_done) 603 if (init_done)
1163 { 604 emergency_save ();
1164 for_all_players (pl)
1165 pl->save (1);
1166 605
1167 for_all_players (pl) 606 LOG (llevDebug, "running cleanup handlers.\n");
1168 if (!QUERY_FLAG (pl->ob, FLAG_REMOVED))
1169 leave_map (pl->ob);
1170
1171 clean_tmp_files ();
1172 write_book_archive ();
1173
1174 INVOKE_GLOBAL (CLEANUP); 607 INVOKE_GLOBAL (CLEANUP);
1175 } 608
609 LOG (llevDebug, "cleanup done.\n");
1176 610
1177 if (make_core) 611 if (make_core)
1178 abort (); 612 abort ();
1179 else 613 else
1180 _exit (0); 614 _exit (0);
… …
1203 637
1204 sprintf (buf, "%s left the game.", &pl->ob->name); 638 sprintf (buf, "%s left the game.", &pl->ob->name);
1205 new_draw_info (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, 0, buf); 639 new_draw_info (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, 0, buf);
1206 } 640 }
1207 641
1208 if (!QUERY_FLAG (pl->ob, FLAG_REMOVED)) 642 pl->ob->remove ();
1209 leave_map (pl->ob);
1210
1211 pl->ob->type = DEAD_OBJECT; /* To avoid problems with inventory window */ 643 pl->ob->type = DEAD_OBJECT; /* To avoid problems with inventory window */
1212 } 644 }
1213 645
1214 /* We do this so that the socket handling routine can do the final 646 /* We do this so that the socket handling routine can do the final
1215 * cleanup. We also leave that loop to actually handle the freeing 647 * cleanup. We also leave that loop to actually handle the freeing
… …
1294 tick_the_clock (); 726 tick_the_clock ();
1295 727
1296 if (!(pticks % 7)) 728 if (!(pticks % 7))
1297 shstr::gc (); 729 shstr::gc ();
1298 730
1299 if (!(pticks % 79))
1300 flush_old_maps (); /* Clears the tmp-files of maps which have reset */
1301
1302 if (!(pticks % 2503)) 731 if (!(pticks % 2503))
1303 fix_weight (); /* Hack to fix weightproblems caused by bugs */ 732 fix_weight (); /* Hack to fix weightproblems caused by bugs */
1304 733
1305 if (!(pticks % 5003)) 734 if (!(pticks % 5003))
1306 write_book_archive (); 735 write_book_archive ();
… …
1316} 745}
1317 746
1318void 747void
1319server_tick () 748server_tick ()
1320{ 749{
1321 nroferrors = 0;
1322
1323 // first do the user visible stuff 750 // first do the user visible stuff
1324 doeric_server (); 751 doeric_server ();
1325 INVOKE_GLOBAL (CLOCK); 752 INVOKE_GLOBAL (CLOCK);
1326 process_events (); /* "do" something with objects with speed */ 753 process_events (); /* "do" something with objects with speed */
1327 flush_sockets (); 754 flush_sockets ();
1328 755
1329 // then do some bookkeeping, should not really be here 756 // then do some bookkeeping, should not really be here
1330 check_active_maps (); /* Removes unused maps after a certain timeout */
1331 do_specials (); /* Routines called from time to time. */ 757 do_specials (); /* Routines called from time to time. */
1332 attachable::check_mortals (); 758 attachable::check_mortals ();
1333 759
1334 ++pticks; 760 ++pticks;
1335} 761}
… …
1346 772
1347 for (;;) 773 for (;;)
1348 cfperl_main (); 774 cfperl_main ();
1349 775
1350 // unreached 776 // unreached
1351 emergency_save (0);
1352 cleanup (); 777 cleanup ();
1353 778
1354 return 0; 779 return 0;
1355} 780}

Diff Legend

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