--- deliantra/server/lib/cf.pm	2006/12/31 22:23:12	1.109
+++ deliantra/server/lib/cf.pm	2007/01/01 11:21:55	1.110
@@ -74,6 +74,8 @@
 # a special map that is always available
 our $LINK_MAP;
 
+our $EMERGENCY_POSITION = $cf::CFG{emergency_position} || ["/world/world_105_115", 5, 37];
+
 #############################################################################
 
 =head2 GLOBAL VARIABLES
@@ -200,9 +202,6 @@
    my $busy = 1;
    my @res;
 
-   # TODO: use suspend/resume instead
-   local $FREEZE = 1;
-
    my $coro = Coro::async {
       @res = eval { $job->() };
       warn $@ if $@;
@@ -210,6 +209,8 @@
    };
 
    if ($Coro::current == $Coro::main) {
+      # TODO: use suspend/resume instead
+      local $FREEZE = 1;
       $coro->prio (Coro::PRIO_MAX);
       while ($busy) {
          Coro::cede_notself;
@@ -280,6 +281,8 @@
 sub new {
    my ($class, $path, $base) = @_;
 
+   $path = $path->as_string if ref $path;
+
    my $self = bless { }, $class;
 
    if ($path =~ s{^\?random/}{}) {
@@ -1031,6 +1034,260 @@
 
 =back
 
+
+=head3 cf::map
+
+=over 4
+
+=cut
+
+package cf::map;
+
+use Fcntl;
+use Coro::AIO;
+
+our $MAX_RESET     = 7200;
+our $DEFAULT_RESET = 3600;
+$MAX_RESET     = 10;#d#
+$DEFAULT_RESET = 10;#d#
+
+sub generate_random_map {
+   my ($path, $rmp) = @_;
+
+   # mit "rum" bekleckern, nicht
+   cf::map::_create_random_map
+      $path,
+      $rmp->{wallstyle}, $rmp->{wall_name}, $rmp->{floorstyle}, $rmp->{monsterstyle},
+      $rmp->{treasurestyle}, $rmp->{layoutstyle}, $rmp->{doorstyle}, $rmp->{decorstyle},
+      $rmp->{origin_map}, $rmp->{final_map}, $rmp->{exitstyle}, $rmp->{this_map},
+      $rmp->{exit_on_final_map},
+      $rmp->{xsize}, $rmp->{ysize},
+      $rmp->{expand2x}, $rmp->{layoutoptions1}, $rmp->{layoutoptions2}, $rmp->{layoutoptions3},
+      $rmp->{symmetry}, $rmp->{difficulty}, $rmp->{difficulty_given}, $rmp->{difficulty_increase},
+      $rmp->{dungeon_level}, $rmp->{dungeon_depth}, $rmp->{decoroptions}, $rmp->{orientation},
+      $rmp->{origin_y}, $rmp->{origin_x}, $rmp->{random_seed}, $rmp->{total_map_hp},
+      $rmp->{map_layout_style}, $rmp->{treasureoptions}, $rmp->{symmetry_used},
+      (cf::region::find $rmp->{region})
+}
+
+# and all this just because we cannot iterate over
+# all maps in C++...
+sub change_all_map_light {
+   my ($change) = @_;
+
+   $_->change_map_light ($change) for values %cf::MAP;
+}
+
+sub try_load_header($) {
+   my ($path) = @_;
+
+   utf8::encode $path;
+   aio_open $path, O_RDONLY, 0
+      or return;
+
+   my $map = cf::map::new
+      or return;
+
+   $map->load_header ($path)
+     or return;
+
+   $map->{load_path} = $path;
+   use Data::Dumper; warn Dumper $map;#d#
+
+   $map
+}
+
+sub find_map {
+   my ($path, $origin) = @_;
+
+   #warn "find_map<$path,$origin>\n";#d#
+
+   $path = ref $path ? $path : new cf::path $path, $origin && $origin->path;
+   my $key = $path->as_string;
+
+   $cf::MAP{$key} || do {
+      # do it the slow way
+      my $map = try_load_header $path->save_path;
+
+      if ($map) {
+         # safety
+         $map->{instantiate_time} = $cf::RUNTIME
+            if $map->{instantiate_time} > $cf::RUNTIME;
+      } else {
+         if (my $rmp = $path->random_map_params) {
+            $map = generate_random_map $key, $rmp;
+         } else {
+            $map = try_load_header $path->load_path;
+         }
+
+         $map or return;
+
+         $map->{instantiate_time} = $cf::RUNTIME;
+         $map->instantiate;
+
+         # per-player maps become, after loading, normal maps
+         $map->per_player (0) if $path->{user_rel};
+      }
+
+      $map->path ($key);
+      $map->{path} = $path;
+      $map->last_access ($cf::RUNTIME);
+
+      $map->reset if $map->should_reset;
+
+      $cf::MAP{$key} = $map
+   }
+}
+
+sub load {
+   my ($self) = @_;
+
+   return if $self->in_memory != cf::MAP_SWAPPED;
+
+   $self->in_memory (cf::MAP_LOADING);
+
+   my $path = $self->{path};
+
+   $self->alloc;
+   $self->load_objects ($self->{load_path}, 1)
+      or return;
+
+   if (my $uniq = $path->uniq_path) {
+      utf8::encode $uniq;
+      if (aio_open $uniq, O_RDONLY, 0) {
+         $self->clear_unique_items;
+         $self->load_objects ($uniq, 0);
+      }
+   }
+
+   # now do the right thing for maps
+   $self->link_multipart_objects;
+
+   if ($self->{path}->is_style_map) {
+      $self->{deny_save}  = 1;
+      $self->{deny_reset} = 1;
+   } else {
+      $self->fix_auto_apply;
+      $self->decay_objects;
+      $self->update_buttons;
+      $self->set_darkness_map;
+      $self->difficulty ($self->estimate_difficulty)
+         unless $self->difficulty;
+      $self->activate;
+   }
+
+   $self->in_memory (cf::MAP_IN_MEMORY);
+}
+
+sub load_map_sync {
+   my ($path, $origin) = @_;
+
+   #warn "load_map_sync<$path, $origin>\n";#d#
+
+   cf::sync_job {
+      my $map = cf::map::find_map $path, $origin
+         or return;
+      $map->load;
+      $map
+   }
+}
+
+sub save {
+   my ($self) = @_;
+
+   my $save = $self->{path}->save_path; utf8::encode $save;
+   my $uniq = $self->{path}->uniq_path; utf8::encode $uniq;
+
+   $self->{last_save} = $cf::RUNTIME;
+
+   return unless $self->dirty;
+
+   $self->{load_path} = $save;
+
+   return if $self->{deny_save};
+
+   warn "saving map ", $self->path;
+
+   if ($uniq) {
+      $self->save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS);
+      $self->save_objects ($uniq, cf::IO_UNIQUES);
+   } else {
+      $self->save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS | cf::IO_UNIQUES);
+   }
+}
+
+sub swap_out {
+   my ($self) = @_;
+
+   return if $self->players;
+   return if $self->in_memory != cf::MAP_IN_MEMORY;
+   return if $self->{deny_save};
+
+   $self->save;
+   $self->clear;
+   $self->in_memory (cf::MAP_SWAPPED);
+}
+
+sub should_reset {
+   my ($map) = @_;
+
+   # TODO: safety, remove and allow resettable per-player maps
+   return if $map->{path}{user_rel};#d#
+   return if $map->{deny_reset};
+   #return unless $map->reset_timeout;
+
+   my $time = $map->fixed_resettime ? $map->{instantiate_time} : $map->last_access;
+
+   $time + ($map->reset_timeout || $DEFAULT_RESET) < $cf::RUNTIME
+}
+
+sub reset {
+   my ($self) = @_;
+
+   return if $self->players;
+   return if $self->{path}{user_rel};#d#
+
+   warn "resetting map ", $self->path;#d#
+
+   utf8::encode (my $save = $self->{path}->save_path);
+   aioreq_pri 3; IO::AIO::aio_unlink $save;
+   aioreq_pri 3; IO::AIO::aio_unlink "$save.pst";
+
+   $_->clear_links_to ($self) for values %cf::MAP;
+
+   $self->clear;
+   $self->in_memory (cf::MAP_SWAPPED);
+   utf8::encode ($self->{load_path} = $self->{path}->load_path);
+}
+
+sub customise_for {
+   my ($map, $ob) = @_;
+
+   if ($map->per_player) {
+      return cf::map::find_map "~" . $ob->name . "/" . $map->{path}{path};
+   }
+
+   $map
+}
+
+sub emergency_save {
+   local $cf::FREEZE = 1;
+
+   warn "enter emergency map save\n";
+
+   cf::sync_job {
+      warn "begin emergency map save\n";
+      $_->save for values %cf::MAP;
+   };
+
+   warn "end emergency map save\n";
+}
+
+package cf;
+
+=back
+
+
 =head3 cf::object::player
 
 =over 4
@@ -1075,6 +1332,151 @@
          : $cf::CFG{"may_$access"})
 }
 
+sub cf::object::player::enter_link {
+   my ($self) = @_;
+
+   return if $self->map == $LINK_MAP;
+
+   $self->{_link_pos} = [$self->map->{path}, $self->x, $self->y]
+      if $self->map;
+
+   $self->enter_map ($LINK_MAP, 20, 20);
+   $self->deactivate_recursive;
+}
+
+sub cf::object::player::leave_link {
+   my ($self, $map, $x, $y) = @_;
+
+   my $link_pos = delete $self->{_link_pos};
+
+   unless ($map) {
+      $self->message ("The exit is closed", cf::NDI_UNIQUE | cf::NDI_RED);
+
+      # restore original map position
+      ($map, $x, $y) = @{ $link_pos || [] };
+      $map = cf::map::find_map $map;
+
+      unless ($map) {
+         ($map, $x, $y) = @$EMERGENCY_POSITION;
+         $map = cf::map::find_map $map
+            or die "FATAL: cannot load emergency map\n";
+      }
+   }
+
+   ($x, $y) = (-1, -1)
+      unless (defined $x) && (defined $y);
+
+   # use -1 or undef as default coordinates, not 0, 0
+   ($x, $y) = ($map->enter_x, $map->enter_y)
+      if $x <=0 && $y <= 0;
+
+   $map->load;
+
+   $self->activate_recursive;
+   $self->enter_map ($map, $x, $y);
+}
+
+=item $player_object->goto_map ($map, $x, $y)
+
+=cut
+
+sub cf::object::player::goto_map {
+   my ($self, $path, $x, $y) = @_;
+
+   $self->enter_link;
+
+   (Coro::async {
+      $path = new cf::path $path;
+
+      my $map = cf::map::find_map $path->as_string;
+      $map = $map->customise_for ($self) if $map;
+
+      warn "entering ", $map->path, " at ($x, $y)\n"
+         if $map;
+
+      $self->leave_link ($map, $x, $y);
+   })->prio (1);
+}
+
+=item $player_object->enter_exit ($exit_object)
+
+=cut
+
+sub parse_random_map_params {
+   my ($spec) = @_;
+
+   my $rmp = { # defaults
+      xsize => 10,
+      ysize => 10,
+   };
+
+   for (split /\n/, $spec) {
+      my ($k, $v) = split /\s+/, $_, 2;
+
+      $rmp->{lc $k} = $v if (length $k) && (length $v);
+   }
+
+   $rmp
+}
+
+sub prepare_random_map {
+   my ($exit) = @_;
+
+   # all this does is basically replace the /! path by
+   # a new random map path (?random/...) with a seed
+   # that depends on the exit object
+
+   my $rmp = parse_random_map_params $exit->msg;
+
+   if ($exit->map) {
+      $rmp->{region}     = $exit->map->region_name;
+      $rmp->{origin_map} = $exit->map->path;
+      $rmp->{origin_x}   = $exit->x;
+      $rmp->{origin_y}   = $exit->y;
+   }
+
+   $rmp->{random_seed} ||= $exit->random_seed;
+
+   my $data = cf::to_json $rmp;
+   my $md5 = Digest::MD5::md5_hex $data;
+
+   if (my $fh = aio_open "$cf::RANDOM_MAPS/$md5.meta", O_WRONLY | O_CREAT, 0666) {
+      aio_write $fh, 0, (length $data), $data, 0;
+
+      $exit->slaying ("?random/$md5");
+      $exit->msg (undef);
+   }
+}
+
+sub cf::object::player::enter_exit {
+   my ($self, $exit) = @_;
+
+   return unless $self->type == cf::PLAYER;
+
+   $self->enter_link;
+
+   (Coro::async {
+      unless (eval {
+
+         prepare_random_map $exit
+            if $exit->slaying eq "/!";
+
+         my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;
+         $self->goto_map ($path, $exit->stats->hp, $exit->stats->sp);
+
+         1;
+      }) {
+         $self->message ("Something went wrong deep within the crossfire server. "
+                     . "I'll try to bring you back to the map you were before. "
+                     . "Please report this to the dungeon master",
+                       cf::NDI_UNIQUE | cf::NDI_RED);
+
+         warn "ERROR in enter_exit: $@";
+         $self->leave_link;
+      }
+   })->prio (1);
+}
+
 =head3 cf::client
 
 =over 4
@@ -1529,6 +1931,36 @@
    $LINK_MAP->path ("{link}");
    $LINK_MAP->{path} = bless { path => "{link}" }, "cf::path";
    $LINK_MAP->in_memory (MAP_IN_MEMORY);
+
+   # dirty hack because... archetypes are not yet loaded
+   Event->timer (
+      after => 2,
+      cb    => sub {
+         $_[0]->w->cancel;
+
+         # provide some exits "home"
+         my $exit = cf::object::new "exit";
+
+         $exit->slaying   ($EMERGENCY_POSITION->[0]);
+         $exit->stats->hp ($EMERGENCY_POSITION->[1]);
+         $exit->stats->sp ($EMERGENCY_POSITION->[2]);
+
+         $LINK_MAP->insert ($exit->clone, 19, 19);
+         $LINK_MAP->insert ($exit->clone, 19, 20);
+         $LINK_MAP->insert ($exit->clone, 19, 21);
+         $LINK_MAP->insert ($exit->clone, 20, 19);
+         $LINK_MAP->insert ($exit->clone, 20, 21);
+         $LINK_MAP->insert ($exit->clone, 21, 19);
+         $LINK_MAP->insert ($exit->clone, 21, 20);
+         $LINK_MAP->insert ($exit->clone, 21, 21);
+
+         $exit->destroy;
+      });
+
+   $LINK_MAP->{deny_save}  = 1;
+   $LINK_MAP->{deny_reset} = 1;
+
+   $cf::MAP{$LINK_MAP->path} = $LINK_MAP;
 }
 
 register "<global>", __PACKAGE__;