--- deliantra/server/lib/cf.pm	2007/01/19 22:47:57	1.184
+++ deliantra/server/lib/cf.pm	2007/01/29 17:57:22	1.200
@@ -10,7 +10,7 @@
 use Safe;
 use Safe::Hole;
 
-use Coro 3.4 ();
+use Coro 3.5 ();
 use Coro::Event;
 use Coro::Timer;
 use Coro::Signal;
@@ -85,6 +85,8 @@
 
 our $EMERGENCY_POSITION;
 
+sub cf::map::normalise;
+
 #############################################################################
 
 =head2 GLOBAL VARIABLES
@@ -351,7 +353,10 @@
    my $fh = aio_open "$runtime~", O_WRONLY | O_CREAT, 0644
       or return;
 
-   my $value = $cf::RUNTIME + 1 + 10; # 10 is the runtime save interval, for a monotonic clock
+   my $value = $cf::RUNTIME + 90 + 10;
+   # 10 is the runtime save interval, for a monotonic clock
+   # 60 allows for the watchdog to kill the server.
+
    (aio_write $fh, 0, (length $value), $value, 0) <= 0
       and return;
 
@@ -773,6 +778,12 @@
          aio_unlink $filename;
          aio_unlink "$filename.pst";
       }
+
+      #d##TODO# nuke non .map-files if exist
+      if ($filename =~ s/\.map$//) {
+         aio_unlink $filename;
+         aio_unlink "$filename.pst";
+      }
    }
 }
 
@@ -789,6 +800,9 @@
 
    my ($data, $av);
 
+   #d#TODO remove .map if file does not exist
+   aio_stat $filename and $filename =~ s/\.map$//;
+
    (aio_load $filename, $data) >= 0
       or return;
 
@@ -1077,8 +1091,7 @@
       next if /\.(?:pl|pst)$/;
       next unless /^$PATH_SEP/o;
 
-      s/\.map$//;
-      push @paths, "~" . $pl->ob->name . "/" . $_;
+      push @paths, cf::map::normalise "~" . $pl->ob->name . "/" . $_;
    }
 
    \@paths
@@ -1139,18 +1152,26 @@
    )
 }
 
+=item cf::map->register ($regex, $prio)
+
+Register a handler for the map path matching the given regex at the
+givne priority (higher is better, built-in handlers have priority 0, the
+default).
+
+=cut
+
 sub register {
-   my (undef, $regex) = @_;
+   my (undef, $regex, $prio) = @_;
    my $pkg = caller;
 
    no strict;
    push @{"$pkg\::ISA"}, __PACKAGE__;
 
-   $EXT_MAP{$pkg} = qr<$regex>;
+   $EXT_MAP{$pkg} = [$prio, qr<$regex>];
 }
 
 # also paths starting with '/'
-$EXT_MAP{"cf::map"} = qr{^(?=/)};
+$EXT_MAP{"cf::map"} = [0, qr{^(?=/)}];
 
 sub thawer_merge {
    my ($self, $merge) = @_;
@@ -1167,6 +1188,10 @@
 sub normalise {
    my ($path, $base) = @_;
 
+   $path = "$path"; # make sure its a string
+
+   $path =~ s/\.map$//;
+
    # map plan:
    #
    # /!          non-realised random map exit (special hack!)
@@ -1203,8 +1228,8 @@
 
    $path = normalise $path, $base;
 
-   for my $pkg (keys %EXT_MAP) {
-      if ($path =~ $EXT_MAP{$pkg}) {
+   for my $pkg (sort { $EXT_MAP{$b}[0] <=> $EXT_MAP{$a}[0] } keys %EXT_MAP) {
+      if ($path =~ $EXT_MAP{$pkg}[1]) {
          my $self = bless cf::map::new, $pkg;
          $self->{path} = $path; $self->path ($path);
          $self->init; # pass $1 etc.
@@ -1212,7 +1237,7 @@
       }
    }
 
-   Carp::carp "unable to resolve path '$path'.";
+   Carp::carp "unable to resolve path '$path' (base '$base').";
    ()
 }
 
@@ -1237,7 +1262,7 @@
 sub load_path {
    my ($self) = @_;
 
-   sprintf "%s/%s/%s", cf::datadir, cf::mapdir, $self->{path}
+   sprintf "%s/%s/%s.map", cf::datadir, cf::mapdir, $self->{path}
 }
 
 # the temporary/swap location
@@ -1245,7 +1270,7 @@
    my ($self) = @_;
 
    (my $path = $_[0]{path}) =~ s/\//$PATH_SEP/g;
-   sprintf "%s/%s/%s", cf::localdir, cf::tmpdir, $path
+   sprintf "%s/%s/%s.map", cf::localdir, cf::tmpdir, $path
 }
 
 # the unique path, undef == no special unique path
@@ -1271,14 +1296,19 @@
    utf8::encode (my $save = $self->save_path);
    IO::AIO::aioreq_pri 4; Coro::AIO::aio_unlink $save;
    IO::AIO::aioreq_pri 4; Coro::AIO::aio_unlink "$save.pst";
+
+   #d#TODO remove .map and also nuke
+   $save =~ s/\.map// or return;#d#
+   IO::AIO::aioreq_pri 4; Coro::AIO::aio_unlink $save;#d#
+   IO::AIO::aioreq_pri 4; Coro::AIO::aio_unlink "$save.pst";#d#
 }
 
 sub load_header_from($) {
    my ($self, $path) = @_;
 
    utf8::encode $path;
-   aio_open $path, O_RDONLY, 0
-      or return;
+   #aio_open $path, O_RDONLY, 0
+   #   or return;
 
    $self->_load_header ($path)
       or return;
@@ -1288,35 +1318,46 @@
    1
 }
 
-sub load_orig {
+sub load_header_orig {
    my ($self) = @_;
 
    $self->load_header_from ($self->load_path)
 }
 
-sub load_temp {
+sub load_header_temp {
    my ($self) = @_;
 
    $self->load_header_from ($self->save_path)
 }
 
+sub prepare_temp {
+   my ($self) = @_;
+
+   $self->last_access ((delete $self->{last_access})
+                       || $cf::RUNTIME); #d#
+   # safety
+   $self->{instantiate_time} = $cf::RUNTIME
+      if $self->{instantiate_time} > $cf::RUNTIME;
+}
+
+sub prepare_orig {
+   my ($self) = @_;
+
+   $self->{load_original} = 1;
+   $self->{instantiate_time} = $cf::RUNTIME;
+   $self->last_access ($cf::RUNTIME);
+   $self->instantiate;
+}
+
 sub load_header {
    my ($self) = @_;
 
-   if ($self->load_temp) {
-      $self->last_access ((delete $self->{last_access})
-                          || $cf::RUNTIME); #d#
-      # safety
-      $self->{instantiate_time} = $cf::RUNTIME
-         if $self->{instantiate_time} > $cf::RUNTIME;
+   if ($self->load_header_temp) {
+      $self->prepare_temp;
    } else {
-      $self->load_orig
+      $self->load_header_orig
          or return;
-
-      $self->{load_original} = 1;
-      $self->{instantiate_time} = $cf::RUNTIME;
-      $self->last_access ($cf::RUNTIME);
-      $self->instantiate;
+      $self->prepare_orig;
    }
 
    1
@@ -1340,21 +1381,26 @@
       $map->load_header
          or return;
 
-      if ($map->should_reset) {
-         $cf::WAIT_FOR_TICK->wait;
+      if ($map->should_reset && 0) {#d#TODO# disabled, crashy (locking issue?)
+         # doing this can freeze the server in a sync job, obviously
+         #$cf::WAIT_FOR_TICK->wait;
          $map->reset;
          undef $guard;
-         $map = find $path
-            or return;
+         return find $path;
       }
 
       $cf::MAP{$path} = $map
    }
 }
 
+sub pre_load  { }
+sub post_load { }
+
 sub load {
    my ($self) = @_;
 
+   local $self->{deny_reset} = 1; # loading can take a long time
+
    my $path = $self->{path};
    my $guard = cf::lock_acquire "map_load:$path";
 
@@ -1363,6 +1409,9 @@
    $self->in_memory (cf::MAP_LOADING);
 
    $self->alloc;
+
+   $self->pre_load;
+
    $self->_load_objects ($self->{load_path}, 1)
       or return;
 
@@ -1394,6 +1443,8 @@
       $self->activate;
    }
 
+   $self->post_load;
+
    $self->in_memory (cf::MAP_IN_MEMORY);
 }
 
@@ -1467,6 +1518,7 @@
       }
       undef $MAP_PREFETCHER;
    };
+   $MAP_PREFETCHER->prio (6);
 
    ()
 }
@@ -1595,8 +1647,7 @@
       next if /\.pst$/;
       next unless /^$PATH_SEP/o;
 
-      s/\.map$//;
-      push @paths, $_;
+      push @paths, cf::map::normalise $_;
    }
 
    \@paths
@@ -1700,7 +1751,7 @@
 sub link_map {
    unless ($LINK_MAP) {
       $LINK_MAP = cf::map::find "{link}"
-         or do { warn "FATAL: unable to provide {link} map, exiting."; exit 1 };
+         or cf::cleanup "FATAL: unable to provide {link} map, exiting.";
       $LINK_MAP->load;
    }
 
@@ -1717,7 +1768,7 @@
    $self->{_link_pos} ||= [$self->map->{path}, $self->x, $self->y]
       if $self->map;
 
-   $self->enter_map ($LINK_MAP || link_map, 20, 20);
+   $self->enter_map ($LINK_MAP || link_map, 10, 10);
 }
 
 sub cf::object::player::leave_link {
@@ -1794,13 +1845,12 @@
    $self->enter_link;
 
    (async {
-      my $map = cf::map::find $path;
-      $map = $map->customise_for ($self) if $map;
-
-#      warn "entering ", $map->path, " at ($x, $y)\n"
-#         if $map;
-
-      $map or $self->message ("The exit to '" . ($path->visible_name) . "' is closed", cf::NDI_UNIQUE | cf::NDI_RED);
+      my $map = eval {
+         my $map = cf::map::find $path;
+         $map = $map->customise_for ($self) if $map;
+         $map
+      } or
+         $self->message ("The exit to '$path' is closed", cf::NDI_UNIQUE | cf::NDI_RED);
 
       $self->leave_link ($map, $x, $y);
    })->prio (1);
@@ -1841,7 +1891,7 @@
    my $rmp = parse_random_map_params $exit->msg;
 
    if ($exit->map) {
-      $rmp->{region}     = $exit->map->region_name;
+      $rmp->{region}     = $exit->region->name;
       $rmp->{origin_map} = $exit->map->path;
       $rmp->{origin_x}   = $exit->x;
       $rmp->{origin_y}   = $exit->y;
@@ -1868,16 +1918,21 @@
 
    return unless $self->type == cf::PLAYER;
 
+   if ($exit->slaying eq "/!") {
+      #TODO: this should de-fi-ni-te-ly not be a sync-job
+      cf::sync_job { prepare_random_map $exit };
+   }
+
+   my $slaying = cf::map::normalise $exit->slaying, $exit->map && $exit->map->path;
+   my $hp      = $exit->stats->hp;
+   my $sp      = $exit->stats->sp;
+
    $self->enter_link;
 
    (async {
       $self->deactivate_recursive; # just to be sure
       unless (eval {
-         prepare_random_map $exit
-            if $exit->slaying eq "/!";
-
-         my $path = new_from_path cf::map $exit->slaying, $exit->map && $exit->map->path;
-         $self->goto ($path, $exit->stats->hp, $exit->stats->sp);
+         $self->goto ($slaying, $hp, $sp);
 
          1;
       }) {
@@ -2176,9 +2231,14 @@
       undef $dirty;
    }
 
-   my $idle = Event->idle (min => 10, max => 20, repeat => 0, data => WF_AUTOCANCEL, cb => sub {
-      db_sync;
-   });
+   my $idle = Event->idle (
+      reentrant => 0,
+      min       => 10,
+      max       => 20,
+      repeat    => 0,
+      data      => WF_AUTOCANCEL,
+      cb        => \&db_sync,
+   );
 
    sub db_dirty() {
       $dirty = 1;
@@ -2256,9 +2316,11 @@
 BEGIN {
    for my $signal (qw(INT HUP TERM)) {
       Event->signal (
-         data   => WF_AUTOCANCEL,
-         signal => $signal,
-         cb     => sub {
+         reentrant => 0,
+         data      => WF_AUTOCANCEL,
+         signal    => $signal,
+         prio      => 0,
+         cb        => sub {
             cf::cleanup "SIG$signal";
          },
       );
@@ -2423,10 +2485,15 @@
       # doing reload synchronously and two reloads happen back-to-back,
       # coro crashes during coro_state_free->destroy here.
 
-      $RELOAD_WATCHER ||= Event->timer (after => 0, data => WF_AUTOCANCEL, cb => sub {
-         reload;
-         undef $RELOAD_WATCHER;
-      });
+      $RELOAD_WATCHER ||= Event->timer (
+         reentrant => 0,
+         after     => 0,
+         data      => WF_AUTOCANCEL,
+         cb => sub {
+            reload;
+            undef $RELOAD_WATCHER;
+         },
+      );
    }
 };
 
@@ -2456,6 +2523,12 @@
       $WAIT_FOR_TICK->broadcast;
       $WAIT_FOR_TICK_ONE->send if $WAIT_FOR_TICK_ONE->awaited;
 
+      Event::sweep;
+      Coro::cede_notself;
+      
+#      my $AFTER = Event::time;
+#      warn $AFTER - $NOW;#d#
+
       # if we are delayed by four ticks or more, skip them all
       $NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;
 
@@ -2464,21 +2537,25 @@
    },
 );
 
-IO::AIO::max_poll_time $TICK * 0.2;
+IO::AIO::max_poll_time $TICK * 0.1;
 
+undef $Coro::AIO::WATCHER;
 $AIO_POLL_WATCHER = Event->io (
-   fd   => IO::AIO::poll_fileno,
-   poll => 'r',
-   prio => 5,
-   data => WF_AUTOCANCEL,
-   cb   => \&IO::AIO::poll_cb,
+   reentrant => 0,
+   fd        => IO::AIO::poll_fileno,
+   poll      => 'r',
+   prio      => 6,
+   data      => WF_AUTOCANCEL,
+   cb        => \&IO::AIO::poll_cb,
 );
 
 $WRITE_RUNTIME_WATCHER = Event->timer (
-   data     => WF_AUTOCANCEL,
-   after    => 1,
-   interval => 10,
-   cb       => Coro::unblock_sub {
+   reentrant => 0,
+   data      => WF_AUTOCANCEL,
+   after     => 1,
+   interval  => 10,
+   prio      => 6,  # keep it lowest so it acts like a watchdog
+   cb        => Coro::unblock_sub {
       write_runtime
          or warn "ERROR: unable to write runtime file: $!";
    },