server/ext/map-random.ext

#! perl # MANDATORY

cf::map->register (qr{^\?random/([0-9a-f]{32})});

sub init {
   my ($self) = @_;

   $self->{random_id} = $1;

   if (0 < Coro::AIO::aio_load "$cf::RANDOMDIR/$self->{random_id}.meta", my $data) {
      $self->{random} = cf::from_json $data;
      $self->{random}{custom} ||= "$self->{random}{origin_map}+$self->{random}{origin_x}+$self->{random}{origin_y}";
   } else {
      warn "unable to read meta file for $self->{random_id}\n";
      return 0;
   }

   1
}

sub thawer_merge {
   # we have to keep some variables in memory intact
   local $_[0]{random_id};
   local $_[0]{random};

   $_[0]->SUPER::thawer_merge ($_[1]);
}

sub visible_name {
   my ($self) = @_;

   my $rmp = $self->{random};
   "random map at $rmp->{custom}, level $rmp->{dungeon_level}"
}

sub save_path {
   my ($self) = @_;

   sprintf "%s/%s.map", $cf::RANDOMDIR, $self->{random_id}
}

sub uniq_path {
   undef
}

sub load_header_orig {
   my ($self) = @_;

   return unless $self->{random};

   $self->generate_random_map ($self->{random});
   $self->activate;

   1
}

sub clean_random_maps {
   my $files = Coro::AIO::aio_readdir $cf::RANDOMDIR
      or return;

   my $META_TIMEOUT = $cf::CFG{map_random_meta_timeout} || 86400 * 7;
   my $MAP_TIMEOUT  = $cf::CFG{map_random_map_timeout}  || 3600 * 6;

   for my $file (@$files) {
      next if $file =~ /\.pst$/;

      Coro::AIO::aio_stat "$cf::RANDOMDIR/$file"
         and next;

      my $age = $cf::NOW - (stat _)[8];

      if ($file =~ /\.meta$/) {
         if ($age > $META_TIMEOUT) {
            warn "resetting random meta data for $file";
            IO::AIO::aio_unlink "$cf::RANDOMDIR/$file";
         }
      } else {
         if ($age > $MAP_TIMEOUT) {
            warn "resetting random map $file";
            IO::AIO::aioreq_pri 4; IO::AIO::aio_unlink "$cf::RANDOMDIR/$file";
            IO::AIO::aioreq_pri 4; IO::AIO::aio_unlink "$cf::RANDOMDIR/$file.pst";
         }
      }
   }
}

# clean up old temp maps regularly
Event->timer (
   reentrant => 0,
   data      => cf::WF_AUTOCANCEL,
   interval  => 3600,
   after     => 60,
   cb        => Coro::unblock_sub { clean_random_maps },
);

# map generator stresstest, never enable under normal circumstances
if (0) {
   cf::async {
      my $seed = 0;
      while () {
         my $map = cf::map::new;
         $map->generate_random_map ({
            region => "scorn",
            random_seed => $seed++,
            xsize => 12,
            ysize => 12,
         });
         warn sprintf "%d: %d %d\n", $seed, $map->width, $map->height;#d#
         $map->destroy;
      }
   };
}

1

Revision:	1.15
Committed:	Sat Apr 21 17:34:24 2007 UTC (17 years, 1 month ago) by root
Branch:	MAIN
CVS Tags:	rel-2_1
Changes since 1.14:	+1 -0 lines
Log Message:	slight revert, and more fixes
#	User	Rev	Content
1	root	1.5	#! perl # MANDATORY
2	root	1.1
3	root	1.5	cf::map->register (qr{^\?random/([0-9a-f]{32})});
4	root	1.1
5			sub init {
6			my ($self) = @_;
7
8	root	1.5	$self->{random_id} = $1;
9
10	root	1.14	if (0 < Coro::AIO::aio_load "$cf::RANDOMDIR/$self->{random_id}.meta", my $data) {
11	root	1.3	$self->{random} = cf::from_json $data;
12			$self->{random}{custom} \|\|= "$self->{random}{origin_map}+$self->{random}{origin_x}+$self->{random}{origin_y}";
13	root	1.7	} else {
14			warn "unable to read meta file for $self->{random_id}\n";
15			return 0;
16	root	1.3	}
17	root	1.5
18			1
19	root	1.1	}
20
21	root	1.6	sub thawer_merge {
22			# we have to keep some variables in memory intact
23			local $_[0]{random_id};
24			local $_[0]{random};
25
26			$_[0]->SUPER::thawer_merge ($_[1]);
27			}
28
29	root	1.1	sub visible_name {
30			my ($self) = @_;
31
32	root	1.2	my $rmp = $self->{random};
33	root	1.4	"random map at $rmp->{custom}, level $rmp->{dungeon_level}"
34	root	1.1	}
35
36			sub save_path {
37			my ($self) = @_;
38
39	root	1.14	sprintf "%s/%s.map", $cf::RANDOMDIR, $self->{random_id}
40	root	1.1	}
41
42			sub uniq_path {
43			undef
44			}
45
46	root	1.8	sub load_header_orig {
47	root	1.1	my ($self) = @_;
48
49	root	1.5	return unless $self->{random};
50
51			$self->generate_random_map ($self->{random});
52	root	1.15	$self->activate;
53	root	1.5
54			1
55	root	1.1	}
56
57	root	1.3	sub clean_random_maps {
58	root	1.14	my $files = Coro::AIO::aio_readdir $cf::RANDOMDIR
59	root	1.10	or return;
60
61			my $META_TIMEOUT = $cf::CFG{map_random_meta_timeout} \|\| 86400 * 7;
62			my $MAP_TIMEOUT = $cf::CFG{map_random_map_timeout} \|\| 3600 * 6;
63
64			for my $file (@$files) {
65			next if $file =~ /\.pst$/;
66
67	root	1.14	Coro::AIO::aio_stat "$cf::RANDOMDIR/$file"
68	root	1.10	and next;
69
70			my $age = $cf::NOW - (stat _)[8];
71
72			if ($file =~ /\.meta$/) {
73			if ($age > $META_TIMEOUT) {
74			warn "resetting random meta data for $file";
75	root	1.14	IO::AIO::aio_unlink "$cf::RANDOMDIR/$file";
76	root	1.10	}
77			} else {
78			if ($age > $MAP_TIMEOUT) {
79			warn "resetting random map $file";
80	root	1.14	IO::AIO::aioreq_pri 4; IO::AIO::aio_unlink "$cf::RANDOMDIR/$file";
81			IO::AIO::aioreq_pri 4; IO::AIO::aio_unlink "$cf::RANDOMDIR/$file.pst";
82	root	1.3	}
83			}
84	root	1.10	}
85	root	1.3	}
86
87			# clean up old temp maps regularly
88			Event->timer (
89	root	1.9	reentrant => 0,
90			data => cf::WF_AUTOCANCEL,
91			interval => 3600,
92			after => 60,
93	root	1.10	cb => Coro::unblock_sub { clean_random_maps },
94	root	1.3	);
95
96	root	1.11	# map generator stresstest, never enable under normal circumstances
97	root	1.13	if (0) {
98	root	1.11	cf::async {
99			my $seed = 0;
100			while () {
101			my $map = cf::map::new;
102			$map->generate_random_map ({
103			region => "scorn",
104			random_seed => $seed++,
105			xsize => 12,
106			ysize => 12,
107			});
108	root	1.12	warn sprintf "%d: %d %d\n", $seed, $map->width, $map->height;#d#
109	root	1.11	$map->destroy;
110			}
111			};
112			}
113
114	root	1.1	1
115