ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/ext/00_map_handling.ext
Revision: 1.2
Committed: Sat Dec 30 12:38:18 2006 UTC (17 years, 4 months ago) by root
Branch: MAIN
Changes since 1.1: +8 -8 lines
Log Message:
reformat

File Contents

# Content
1 #! perl
2
3 # why this is an extension is a good question. next question.
4
5 use Fcntl;
6
7 use Coro;
8 use Coro::AIO;
9
10 our $emergency_position = $cf::CFG{emergency_position} || ["/world/world_105_115", 5, 37];
11
12 our $DEACTIVATE_TIMEOUT = 60; # number of seconds after which maps get deactivated to save cpu
13 our $SWAP_TIMEOUT = 600; # number of seconds after which maps inactive get swapped out
14 our $SCHEDULE_INTERVAL = 8; # time the map scheduler sleeps between runs
15 our $SAVE_TIMEOUT = 60; # save maps every n seconds
16 our $SAVE_INTERVAL = 0.4; # save at max. one map every $SAVE_HOLD
17 our $MAX_RESET = 7200;
18
19 $DEACTIVATE_TIMEOUT = 3;#d#
20 $SWAP_TIMEOUT = 5;#d#
21 $SCHEDULE_INTERVAL = 1;
22
23 $cf::LINK_MAP ||= do {
24 my $map = cf::map::new;
25
26 $map->width (1);
27 $map->height (1);
28 $map->alloc;
29 $map->path ("{link}");
30 $map->{path} = bless { path => "{link}" }, "cf::path";
31 $map->in_memory (cf::MAP_IN_MEMORY);
32
33 $map
34 };
35
36 {
37 package cf::path;
38
39 sub new {
40 my ($class, $path, $base) = @_;
41
42 my %res;
43
44 if ($path =~ s{^~([^/]+)?}{}) {
45 $res{user_rel} = 1;
46
47 if (defined $1) {
48 $res{user} = $1;
49 } elsif ($base =~ m{^~([^/]+)/}) {
50 $res{user} = $1;
51 } else {
52 warn "cannot resolve user-relative path without user <$path,$base>\n";
53 }
54 } elsif ($path =~ /^\//) {
55 # already absolute
56 } else {
57 $base =~ s{[^/]+/?$}{};
58 return $class->new ("$base/$path");
59 }
60
61 for ($path) {
62 redo if s{/\.?/}{/};
63 redo if s{/[^/]+/\.\./}{/};
64 }
65
66 $res{path} = $path;
67
68 bless \%res, $class
69 }
70
71 # the name / primary key / in-game path
72 sub as_string {
73 my ($self) = @_;
74
75 $self->{user_rel}
76 ? "~$self->{user}$self->{path}"
77 : $self->{path}
78 }
79
80 # escape the /'s in the path
81 sub escaped_path {
82 # ∕ is U+2215
83 (my $path = $_[0]{path}) =~ s/\//∕/g;
84 $path
85 }
86
87 # the original (read-only) location
88 sub load_path {
89 my ($self) = @_;
90
91 sprintf "%s/%s/%s", cf::datadir, cf::mapdir, $self->{path}
92 }
93
94 # the temporary/swap location
95 sub save_path {
96 my ($self) = @_;
97
98 $self->{user_rel}
99 ? sprintf "%s/%s/%s/%s", cf::localdir, cf::playerdir, $self->{user}, $self->escaped_path
100 : sprintf "%s/%s/%s", cf::localdir, cf::tmpdir, $self->escaped_path
101 }
102
103 # the unique path, might be eq to save_path
104 sub uniq_path {
105 my ($self) = @_;
106
107 $self->{user_rel}
108 ? undef
109 : sprintf "%s/%s/%s", cf::localdir, cf::uniquedir, $self->escaped_path
110 }
111 }
112
113 sub write_runtime {
114 my $runtime = cf::localdir . "/runtime";
115
116 my $fh = aio_open "$runtime~", O_WRONLY | O_CREAT, 0644
117 or return;
118
119 my $value = $cf::RUNTIME;
120 (aio_write $fh, 0, (length $value), $value, 0) <= 0
121 and return;
122
123 aio_fsync $fh
124 and return;
125
126 close $fh
127 or return;
128
129 aio_rename "$runtime~", $runtime
130 and return;
131
132 1
133 }
134
135 (Coro::unblock_sub {
136 unless (write_runtime) {
137 warn "unable to write runtime file: $!";
138 exit 1;
139 }
140 })->();
141
142 our $SCHEDULER = cf::coro {
143 while () {
144 Coro::Timer::sleep $SCHEDULE_INTERVAL;
145
146 write_runtime
147 or warn "unable to write runtime file: $!";
148
149 for my $map (values %cf::MAP) {
150 eval {
151 next if $map->in_memory != cf::MAP_IN_MEMORY;
152 my $last_access = $map->last_access;
153 # not yet, because maps might become visible to players nearby
154 # we need a tiled meta map for this to work
155 # if ($last_access + $DEACTIVATE_TIMEOUT <= $cf::RUNTIME) {
156 # $map->deactivate;
157 # delete $map->{active};
158 # }
159 if ($map->should_reset) {
160 $map->reset;
161 } elsif ($last_access + $SWAP_TIMEOUT <= $cf::RUNTIME) {
162 $map->swap_out;
163 Coro::Timer::sleep $SAVE_INTERVAL;
164 } elsif ($map->{last_save} + $SAVE_TIMEOUT <= $cf::RUNTIME) {
165 $map->save;
166 Coro::Timer::sleep $SAVE_INTERVAL;
167 }
168 };
169 warn $@ if $@;
170 cede;
171 }
172 }
173 };
174 $SCHEDULER->prio (-2);
175
176 sub sync_job(&) {
177 my ($job) = @_;
178
179 my $done;
180 my @res;
181
182 Carp::confess "nested sync_job" if $cf::FREEZE;
183
184 local $cf::FREEZE = 1;
185
186 (async {
187 @res = eval { $job->() };
188 warn $@ if $@;
189 $done = 1;
190 })->prio (Coro::PRIO_MAX);
191
192 while (!$done) {
193 Coro::cede_notself;
194 Event::one_event unless Coro::nready;
195 }
196
197 warn "job done<@res>\n";#d#
198
199 wantarray ? @res : $res[0]
200 }
201
202 # and all this just because we cannot iterate over
203 # all maps in C++...
204 sub cf::map::change_all_map_light {
205 my ($change) = @_;
206
207 $_->change_map_light ($change) for values %cf::MAP;
208 }
209
210 sub try_load_header($) {
211 my ($path) = @_;
212
213 utf8::encode $path;
214 aio_open $path, O_RDONLY, 0
215 or return;
216
217 my $map = cf::map::new
218 or return;
219
220 $map->load_header ($path)
221 or return;
222
223 $map->reset_time (0) if $map->reset_time > $cf::RUNTIME;
224 $map->reset_timeout (10);#d#
225
226 $map->{load_path} = $path;
227 warn "load header from $path\n";#d#
228
229 $map
230 }
231
232 sub cf::map::find_map_nb {
233 my ($path, $origin) = @_;
234
235 $path = ref $path ? $path : new cf::path $path, $origin && $origin->path;
236 my $key = $path->as_string;
237
238 warn "find_map_nb<$path,$origin>\n";#d#
239
240 $cf::MAP{$key} || do {
241 # do it the slow way
242 my $map = try_load_header $path->save_path;
243
244 if (!$map) {
245 $map = try_load_header $path->load_path
246 or return;
247 }
248
249 $map or return;
250
251 $map->instantiate;
252 $map->path ($key);
253 $map->{path} = $path;
254
255 $map->reset if $map->should_reset;
256
257 $cf::MAP{$key} = $map
258 }
259 }
260
261 sub cf::map::find_map {
262 my ($path, $origin) = @_;
263
264 $path = new cf::path $path, $origin && $origin->path;
265 my $key = $path->as_string;
266
267 warn "find_map<$path,$origin>\n";#d#
268
269 $cf::MAP{$key} || sync_job {
270 cf::map::find_map_nb $path;
271 }
272 }
273
274 sub cf::map::do_load_nb {
275 my ($self) = @_;
276
277 return 0 unless $self->in_memory == cf::MAP_SWAPPED;
278
279 $self->in_memory (cf::MAP_LOADING);
280
281 my $path = $self->{path};
282
283 $self->alloc;
284 $self->load_objects ($self->{load_path}, 1)
285 or return;
286
287 if (my $uniq = $path->uniq_path) {
288 utf8::encode $uniq;
289 if (aio_open $uniq, O_RDONLY, 0) {
290 $self->clear_unique_items;
291 $self->load_objects ($uniq, 0);
292 }
293 }
294
295 # now do the right thing for maps
296 $self->link_multipart_objects;
297 $self->fix_auto_apply;
298 $self->decay_objects;
299 $self->update_buttons;
300 $self->set_darkness_map;
301 $self->difficulty ($self->estimate_difficulty)
302 unless $self->difficulty;
303
304 $self->in_memory (cf::MAP_IN_MEMORY);
305 }
306
307 sub cf::map::do_load {
308 my ($self) = @_;
309
310 warn "do_load<$self>\n";#d#
311
312 sync_job {
313 cf::map::do_load_nb $self;
314 };
315 }
316
317 sub cf::map::save {
318 my ($self) = @_;
319
320 warn "saving map ", $self->path;
321
322 my $save = $self->{path}->save_path; utf8::encode $save;
323 my $uniq = $self->{path}->uniq_path; utf8::encode $uniq;
324
325 if ($uniq) {
326 $self->save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS);
327 $self->save_objects ($uniq, cf::IO_UNIQUES);
328 } else {
329 $self->save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS | cf::IO_UNIQUES);
330 }
331
332 $self->{load_path} = $save;
333 $self->{last_save} = $cf::RUNTIME;
334 }
335
336 sub cf::map::swap_out {
337 my ($self) = @_;
338
339 $self->save;
340 $self->clear;
341 $self->in_memory (cf::MAP_SWAPPED);
342 }
343
344 sub cf::map::should_reset {
345 my ($map) = @_;
346
347 # TODO: safety, remove and allow resettable per-player maps
348 return if $map->{path}{user_rel};#d#
349 return if $map->per_player;
350 return unless $map->reset_timeout;
351
352 my $time = $map->fixed_resettime ? $map->reset_time : $map->last_access;
353
354 $time + $map->reset_timeout < $cf::RUNTIME
355 }
356
357 sub cf::map::reset {
358 my ($self) = @_;
359
360 return if $self->players;
361
362 warn "resetting map ", $self->path;#d#
363 return;#d#
364
365 $self->clear;
366 $self->in_memory (cf::MAP_SWAPPED);
367 $self->{load_path} = $self->{path}->load_path;
368 utf8::encode $self->{load_path};
369 }
370
371 sub cf::object::player::enter_exit {
372 my ($ob, $exit) = @_;
373
374 warn "enter_exit\n";#d#
375 sync_job {
376 warn "enter_exit<$ob,$exit>\n";#d#
377
378 if ($exit) {
379 my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;
380
381 my $map = cf::map::find_map_nb $path->as_string;
382 $map = $map->customise_for ($ob) if $map;
383
384 if ($map) {
385 $map->do_load_nb;
386 $ob->enter_map ($map, $exit->stats->hp, $exit->stats->sp);
387 } else {
388 $ob->message ("The exit is closed", cf::NDI_UNIQUE | cf::NDI_RED);
389 }
390 } else {
391 # used on login only(?)
392 my $map = cf::map::find_map_nb $ob->contr->maplevel;
393 my ($x, $y) = ($ob->x, $ob->y);
394
395 unless ($map) {
396 $map = cf::map::find_map_nb $emergency_position->[0]
397 or die "FATAL: cannot load emergency map\n";
398 $x = $emergency_position->[1];
399 $y = $emergency_position->[2];
400 }
401
402 $map->do_load_nb;
403 $ob->enter_map ($map, $x, $y);
404 }
405 }
406 }
407
408 sub cf::map::customise_for {
409 my ($map, $ob) = @_;
410
411 warn "customise_for<$map,$ob>\n";#d#
412
413 if ($map->per_player) {
414 return cf::map::find_map_nb "~" . $ob->name . "/" . $map->{path}{path};
415 }
416
417 $map
418 }
419
420 sub cf::map::emergency_save {
421 local $cf::FREEZE = 1;
422
423 warn "begin emergency map save\n";
424 $_->save for values %cf::MAP;
425 warn "emergency map save drain\n";
426
427 Event::one_event while IO::AIO::nreqs;
428 warn "end emergency map save\n";
429 }
430