--- deliantra/server/lib/cf.pm	2007/06/07 19:12:22	1.275
+++ deliantra/server/lib/cf.pm	2007/06/11 22:16:53	1.279
@@ -945,48 +945,77 @@
    },
 );
 
-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)[0, 1] } split /\s+/, $1 }
+            if $source =~ /\A#!.*?perl.*?#\s*(.*)$/m;
+
+         $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*/, $v->{meta}{depends}) {
+               goto skip
+                  unless exists $done{$_};
+            }
+
+            warn "... loading '$k' into '$v->{pkg}'\n";
+
+            unless (eval $v->{source}) {
+               my $msg = $@ ? "$v->{path}: $@\n"
+                            : "$v->{base}: extension inactive.\n";
+
+               if (exists $v->{meta}{mandatory}) {
+                  warn $msg;
+                  warn "mandatory extension failed to load, exiting.\n";
+                  exit 1;
+               }
+               
+               warn $msg;
+            }
+
+            $done{$k} = delete $todo{$k};
+            push @EXTS, $v->{pkg};
+            $progress = 1;
+         }
 
-sub load_extensions {
-   for my $ext (<$LIBDIR/*.ext>) {
-      next unless -r $ext;
-      eval {
-         load_extension $ext;
-         1
-      } or warn "$ext not loaded: $@";
-   }
+         skip:
+         die "cannot load " . (join ", ", keys %todo) . ": unable to resolve dependencies\n"
+            unless $progress;
+      }
+   };
 }
 
 #############################################################################
@@ -1778,28 +1807,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;