server/ext/map-random.ext

#! perl # mandatory

use Coro::AIO;

CONF META_TIMEOUT : map_random_meta_timeout = 86400 * 7;

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::decode_json $data;
      $self->{random}{custom} ||= "$self->{random}{origin_map}+$self->{random}{origin_x}+$self->{random}{origin_y}";
   } else {
      cf::info "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 select_random_map {
   my ($maps, $difficulty) = @_;

   # because I am lazy, I ignore the weighting

   my @maps = keys %$maps;

   cf::map::find "/styles/$maps[cf::rmg_rndm scalar @maps]"
}

# called by the random map generator
sub find_style_;
sub find_style_($$$) {
   my ($path, $difficulty, $recurse) = @_;

   my $map;

   # see if there is a metafile
   if (0 < aio_load "$cf::MAPDIR/$path.rmg", my $meta) {
      $meta = cf::decode_json $meta;

      # only "maps" is supported
      if ($meta->{maps}) {
         $map = select_random_map $meta->{maps}, $difficulty;
      }
   }

   $map = cf::map::find $path
      unless aio_stat "$cf::MAPDIR/$path.map";

   unless ($map) {
      # search files and/or dirs
      if (my ($dirs, $nondirs) = aio_scandir "$cf::MAPDIR/$path/", 1) {
         my @entries = sort grep s/\.(?:map|rmg)$//, @$nondirs;

         if ($difficulty < 0) {
            # pick a fully random map, but only a map, do not recurse
            $map = cf::map::find "$path/$entries[cf::rmg_rndm scalar @entries]"
               if @entries;
         } else {
            # pick a map with nearest difficulty value ("mapname_<difficulty>.map")
            @entries = sort @$dirs
               unless @entries || !$recurse;

            my $min_diff = 1e99;

            for my $name (@entries) {
               if ($name =~ /_(\d+)$/) {
                  my $diff = abs $difficulty - $1 + 0.25 + 0.25 * cf::rmg_rndm; # prefer the more difficult version
                  ($map, $min_diff) = ($name, $diff) if $diff < $min_diff;
               }
            }

            unless ($map) {
               # no map with given pattern found, choose a random map
               $map = $entries[cf::rmg_rndm scalar @entries];
            }

            $map = find_style_ "$path/$map", $difficulty
               if $map;
         }
      }
   }

   $map
}

sub find_style($$$$) {
   my ($dir, $name, $difficulty, $recurse) = @_;

   cf::cede_to_tick;

   my $map;
   
   if ($name) {
      $map = find_style_ "$dir/$name", $difficulty, $recurse;
   } else {
      $map = (find_style_ "$dir/default", $difficulty, $recurse)
             || (find_style_ $dir, $difficulty, $recurse);
   }

   if ($map) {
      $map->load;
      $map->deactivate;
   }

   #warn "return $dir,$name,$difficulty => $map\n" if $difficulty >= 0;#d#
   $map
}

cf::async_ext {
   local $Coro::current->{desc} = "random map meta file cleaner";
   $Coro::current->nice (1);

   while () {
      Coro::AnyEvent::idle_upto $META_TIMEOUT / 10 * 2;

      my ($files) = Coro::AIO::aio_readdirx $cf::RANDOMDIR, IO::AIO::READDIR_STAT_ORDER
         or return;

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

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

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

         if ($age > $META_TIMEOUT) {
            cf::trace "resetting random meta data for $file";
            IO::AIO::aio_unlink "$cf::RANDOMDIR/$file";
         }
      }

      Coro::AnyEvent::sleep $META_TIMEOUT / 10;
   }
};

# map generator stresstest, NEVER enable under normal circumstances
if ($ENV{STRESSTEST}) {
   cf::async {
      my $seed = 0;
      while () {
         my $map = cf::map::new;
         $map->generate_random_map ({
            region => "scorn",
            random_seed => $seed++,
            xsize => (cf::rndm 1, 100),
            ysize => (cf::rndm 1, 100),
         });
         warn sprintf "%d: %dx%d o# %d\n", $seed, $map->width, $map->height, &cf::object::objects_size;#d#
         $map->destroy;
      }
   };
}

# prefetch test, load some ocean-maps
if (0) {
   cf::async {
      # 0.58
      Coro::Timer::sleep 2;
      for my $x (200..219) {
         for my $y (200..219) {
            (cf::map::find "/world/world_$x\_$y")->load;
         }
      }
   };
}

# save test
if (0) {
   cf::async {
      # 0.080
      Coro::Timer::sleep 2;
      my $map = cf::map::find "/mlab/citydeclouds2";
      $map->load_header;
      $map->load;
      $map->post_load_original;
      my $m=100;
      for (1..50) {
         my $t=AE::time;
         $map->_save_objects ("/tmp/x", cf::IO_HEADER | cf::IO_OBJECTS | cf::IO_UNIQUES);
         $t = AE::time-$t;
         $m=$t if $m>$t;
         warn $m;
      }
   };
}

Revision:	1.47
Committed:	Fri Feb 3 03:01:45 2012 UTC (14 years, 8 months ago) by root
Branch:	MAIN
CVS Tags:	rel-3_1, HEAD
Changes since 1.46:	+2 -2 lines
Log Message:	* empty log message *
#	Content
1	#! perl # mandatory
2
3	use Coro::AIO;
4
5	CONF META_TIMEOUT : map_random_meta_timeout = 86400 * 7;
6
7	cf::map->register (qr{^\?random/([0-9a-f]{32})});
8
9	sub init {
10	my ($self) = @_;
11
12	$self->{random_id} = $1;
13
14	if (0 < Coro::AIO::aio_load "$cf::RANDOMDIR/$self->{random_id}.meta", my $data) {
15	$self->{random} = cf::decode_json $data;
16	$self->{random}{custom} \|\|= "$self->{random}{origin_map}+$self->{random}{origin_x}+$self->{random}{origin_y}";
17	} else {
18	cf::info "unable to read meta file for $self->{random_id}\n";
19	return 0;
20	}
21
22	1
23	}
24
25	sub thawer_merge {
26	# we have to keep some variables in memory intact
27	local $_[0]{random_id};
28	local $_[0]{random};
29
30	$_[0]->SUPER::thawer_merge ($_[1]);
31	}
32
33	sub visible_name {
34	my ($self) = @_;
35
36	my $rmp = $self->{random};
37	"random map at $rmp->{custom}, level $rmp->{dungeon_level}"
38	}
39
40	sub save_path {
41	my ($self) = @_;
42
43	sprintf "%s/%s.map", $cf::RANDOMDIR, $self->{random_id}
44	}
45
46	sub uniq_path {
47	undef
48	}
49
50	sub load_header_orig {
51	my ($self) = @_;
52
53	return unless $self->{random};
54
55	$self->generate_random_map ($self->{random});
56	$self->activate;
57
58	1
59	}
60
61	sub select_random_map {
62	my ($maps, $difficulty) = @_;
63
64	# because I am lazy, I ignore the weighting
65
66	my @maps = keys %$maps;
67
68	cf::map::find "/styles/$maps[cf::rmg_rndm scalar @maps]"
69	}
70
71	# called by the random map generator
72	sub find_style_;
73	sub find_style_($$$) {
74	my ($path, $difficulty, $recurse) = @_;
75
76	my $map;
77
78	# see if there is a metafile
79	if (0 < aio_load "$cf::MAPDIR/$path.rmg", my $meta) {
80	$meta = cf::decode_json $meta;
81
82	# only "maps" is supported
83	if ($meta->{maps}) {
84	$map = select_random_map $meta->{maps}, $difficulty;
85	}
86	}
87
88	$map = cf::map::find $path
89	unless aio_stat "$cf::MAPDIR/$path.map";
90
91	unless ($map) {
92	# search files and/or dirs
93	if (my ($dirs, $nondirs) = aio_scandir "$cf::MAPDIR/$path/", 1) {
94	my @entries = sort grep s/\.(?:map\|rmg)$//, @$nondirs;
95
96	if ($difficulty < 0) {
97	# pick a fully random map, but only a map, do not recurse
98	$map = cf::map::find "$path/$entries[cf::rmg_rndm scalar @entries]"
99	if @entries;
100	} else {
101	# pick a map with nearest difficulty value ("mapname_<difficulty>.map")
102	@entries = sort @$dirs
103	unless @entries \|\| !$recurse;
104
105	my $min_diff = 1e99;
106
107	for my $name (@entries) {
108	if ($name =~ /_(\d+)$/) {
109	my $diff = abs $difficulty - $1 + 0.25 + 0.25 * cf::rmg_rndm; # prefer the more difficult version
110	($map, $min_diff) = ($name, $diff) if $diff < $min_diff;
111	}
112	}
113
114	unless ($map) {
115	# no map with given pattern found, choose a random map
116	$map = $entries[cf::rmg_rndm scalar @entries];
117	}
118
119	$map = find_style_ "$path/$map", $difficulty
120	if $map;
121	}
122	}
123	}
124
125	$map
126	}
127
128	sub find_style($$$$) {
129	my ($dir, $name, $difficulty, $recurse) = @_;
130
131	cf::cede_to_tick;
132
133	my $map;
134
135	if ($name) {
136	$map = find_style_ "$dir/$name", $difficulty, $recurse;
137	} else {
138	$map = (find_style_ "$dir/default", $difficulty, $recurse)
139	\|\| (find_style_ $dir, $difficulty, $recurse);
140	}
141
142	if ($map) {
143	$map->load;
144	$map->deactivate;
145	}
146
147	#warn "return $dir,$name,$difficulty => $map\n" if $difficulty >= 0;#d#
148	$map
149	}
150
151	cf::async_ext {
152	local $Coro::current->{desc} = "random map meta file cleaner";
153	$Coro::current->nice (1);
154
155	while () {
156	Coro::AnyEvent::idle_upto $META_TIMEOUT / 10 * 2;
157
158	my ($files) = Coro::AIO::aio_readdirx $cf::RANDOMDIR, IO::AIO::READDIR_STAT_ORDER
159	or return;
160
161	for my $file (@$files) {
162	next unless $file =~ /\.meta$/;
163
164	Coro::AIO::aio_stat "$cf::RANDOMDIR/$file"
165	and next;
166
167	my $age = $cf::NOW - (stat _)[8];
168
169	if ($age > $META_TIMEOUT) {
170	cf::trace "resetting random meta data for $file";
171	IO::AIO::aio_unlink "$cf::RANDOMDIR/$file";
172	}
173	}
174
175	Coro::AnyEvent::sleep $META_TIMEOUT / 10;
176	}
177	};
178
179	# map generator stresstest, NEVER enable under normal circumstances
180	if ($ENV{STRESSTEST}) {
181	cf::async {
182	my $seed = 0;
183	while () {
184	my $map = cf::map::new;
185	$map->generate_random_map ({
186	region => "scorn",
187	random_seed => $seed++,
188	xsize => (cf::rndm 1, 100),
189	ysize => (cf::rndm 1, 100),
190	});
191	warn sprintf "%d: %dx%d o# %d\n", $seed, $map->width, $map->height, &cf::object::objects_size;#d#
192	$map->destroy;
193	}
194	};
195	}
196
197	# prefetch test, load some ocean-maps
198	if (0) {
199	cf::async {
200	# 0.58
201	Coro::Timer::sleep 2;
202	for my $x (200..219) {
203	for my $y (200..219) {
204	(cf::map::find "/world/world_$x\_$y")->load;
205	}
206	}
207	};
208	}
209
210	# save test
211	if (0) {
212	cf::async {
213	# 0.080
214	Coro::Timer::sleep 2;
215	my $map = cf::map::find "/mlab/citydeclouds2";
216	$map->load_header;
217	$map->load;
218	$map->post_load_original;
219	my $m=100;
220	for (1..50) {
221	my $t=AE::time;
222	$map->_save_objects ("/tmp/x", cf::IO_HEADER \| cf::IO_OBJECTS \| cf::IO_UNIQUES);
223	$t = AE::time-$t;
224	$m=$t if $m>$t;
225	warn $m;
226	}
227	};
228	}
229