--- deliantra/server/lib/cf.pm	2007/06/05 13:05:02	1.274
+++ deliantra/server/lib/cf.pm	2007/06/11 21:38:14	1.278
@@ -945,48 +945,76 @@
    },
 );
 
-sub load_extension {
-   my ($path) = @_;
+sub load_extensions {
+   cf::sync_job {
+      my %todo;
+
+      for my $path (<$LIBDIR/*.ext>) {
+         next unless -r $path;
 
-   $path =~ /([^\/\\]+)\.ext$/ or die "$path";
-   my $base = $1;
-   my $pkg = $1;
-   $pkg =~ s/[^[:word:]]/_/g;
-   $pkg = "ext::$pkg";
-
-   warn "... loading '$path' into '$pkg'\n";
-
-   open my $fh, "<:utf8", $path
-      or die "$path: $!";
-
-   my $source =
-      "package $pkg; use strict; use utf8;\n"
-      . "#line 1 \"$path\"\n{\n"
-      . (do { local $/; <$fh> })
-      . "\n};\n1";
-
-   unless (eval $source) {
-      my $msg = $@ ? "$path: $@\n"
-                   : "extension disabled.\n";
-      if ($source =~ /^#!.*perl.*#.*MANDATORY/m) { # ugly match
-         warn $@;
-         warn "mandatory extension failed to load, exiting.\n";
-         exit 1;
+         $path =~ /([^\/\\]+)\.ext$/ or die "$path";
+         my $base = $1;
+         my $pkg = $1;
+         $pkg =~ s/[^[:word:]]/_/g;
+         $pkg = "ext::$pkg";
+
+         open my $fh, "<:utf8", $path
+            or die "$path: $!";
+
+         my $source = do { local $/; <$fh> };
+
+         my %ext = (
+            path => $path,
+            base => $base,
+            pkg  => $pkg,
+         );
+
+         $ext{meta} = { map { split /=/, $_, 2 } split /\s+/, $1 }
+            if $source =~ /^#!.*?perl.*?#\s*(.*)$/;
+
+         $ext{source} =
+            "package $pkg; use strict; use utf8;\n"
+            . "#line 1 \"$path\"\n{\n"
+            . $source
+            . "\n};\n1";
+
+         $todo{$base} = \%ext;
       }
-      die $@;
-   }
 
-   push @EXTS, $pkg;
-}
+      my %done;
+      while (%todo) {
+         my $progress;
+
+         while (my ($k, $v) = each %todo) {
+            for (split /,\s*/, $ext{meta}{depends}) {
+               goto skip
+                  unless exists $done{$_};
+            }
+
+            warn "... loading '$k' into '$v->{pkg}'\n";
+
+            unless (eval $v->{source}) {
+               my $msg = $@ ? "$v->{path}: $@\n"
+                            : "extension disabled.\n";
+
+               if (exists $v->{meta}{mandatory}) {
+                  warn $msg;
+                  warn "mandatory extension failed to load, exiting.\n";
+                  exit 1;
+               }
+               
+               die $msg;
+            }
 
-sub load_extensions {
-   for my $ext (<$LIBDIR/*.ext>) {
-      next unless -r $ext;
-      eval {
-         load_extension $ext;
-         1
-      } or warn "$ext not loaded: $@";
-   }
+            $done{$k} = delete $todo{$k};
+            push @EXTS, $v->{pkg};
+         }
+
+         skip:
+         die "cannot load " . (join ", ", keys %todo) . ": unable to resolve dependencies\n"
+            unless $progress;
+      }
+   };
 }
 
 #############################################################################
@@ -1307,8 +1335,6 @@
    # we have to keep some variables in memory intact
    local $self->{path};
    local $self->{load_path};
-   local $self->{deny_save};
-   local $self->{deny_reset};
 
    $self->SUPER::thawer_merge ($merge);
 }
@@ -1418,6 +1444,14 @@
       for grep $_->outdoor, values %cf::MAP;
 }
 
+sub decay_objects {
+   my ($self) = @_;
+
+   return if $self->{deny_reset};
+
+   $self->do_decay_objects;
+}
+
 sub unlink_save {
    my ($self) = @_;
 
@@ -1483,6 +1517,9 @@
       $self->prepare_orig;
    }
 
+   $self->{deny_reset} = 1
+      if $self->no_reset;
+
    $self->default_region (cf::region::find_by_path $self->{path})
       unless $self->default_region;
 
@@ -1507,7 +1544,7 @@
       $map->load_header
          or return;
 
-      if ($map->should_reset && 0) {#d#TODO# disabled, crashy (locking issue?)
+      if ($map->should_reset) {#d#TODO# disabled, crashy (locking issue?)
          # doing this can freeze the server in a sync job, obviously
          #$cf::WAIT_FOR_TICK->wait;
          $map->reset;
@@ -1584,6 +1621,9 @@
    return find "~" . $ob->name . "/" . $self->{path}
       if $self->per_player;
 
+#   return find "?party/" . $ob->name . "/" . $self->{path}
+#      if $self->per_party;
+
    $self
 }
 
@@ -1703,7 +1743,6 @@
    my ($self) = @_;
 
    # TODO: safety, remove and allow resettable per-player maps
-   return 1e99 if $self->isa ("ext::map_per_player");#d#
    return 1e99 if $self->{deny_reset};
 
    my $time = $self->fixed_resettime ? $self->{instantiate_time} : $self->last_access;
@@ -1724,7 +1763,6 @@
    my $lock = cf::lock_acquire "map_data:$self->{path}";
 
    return if $self->players;
-   return if $self->isa ("ext::map_per_player");#d#
 
    warn "resetting map ", $self->path;
 
@@ -1768,28 +1806,58 @@
    $self->reset; # polite request, might not happen
 }
 
-=item cf::map::unique_maps
+=item $maps = cf::map::tmp_maps
 
-Returns an arrayref of paths of all shared maps that have
-instantiated unique items. May block.
+Returns an arrayref with all map paths of currently instantiated and saved
+maps. May block.
 
 =cut
 
-sub unique_maps() {
-   my $files = aio_readdir $UNIQUEDIR
-      or return;
+sub tmp_maps() {
+   [
+      map {
+         utf8::decode $_;
+         /\.map$/
+            ? normalise $_
+            : ()
+      } @{ aio_readdir $TMPDIR or [] }
+   ]
+}
 
-   my @paths;
+=item $maps = cf::map::random_maps
 
-   for (@$files) {
-      utf8::decode $_;
-      next if /\.pst$/;
-      next unless /^$PATH_SEP/o;
+Returns an arrayref with all map paths of currently instantiated and saved
+random maps. May block.
 
-      push @paths, cf::map::normalise $_;
-   }
+=cut
 
-   \@paths
+sub random_maps() {
+   [
+      map {
+         utf8::decode $_;
+         /\.map$/
+            ? normalise "?random/$_"
+            : ()
+      } @{ aio_readdir $RANDOMDIR or [] }
+   ]
+}
+
+=item cf::map::unique_maps
+
+Returns an arrayref of paths of all shared maps that have
+instantiated unique items. May block.
+
+=cut
+
+sub unique_maps() {
+   [
+      map {
+         utf8::decode $_;
+         /\.map$/
+            ? normalise $_
+            : ()
+      } @{ aio_readdir $UNIQUEDIR or [] }
+   ]
 }
 
 package cf;