ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/ext/00_map_handling.ext
(Generate patch)

Comparing deliantra/server/ext/00_map_handling.ext (file contents):
Revision 1.8 by root, Sun Dec 31 10:28:36 2006 UTC vs.
Revision 1.14 by root, Mon Jan 1 00:41:03 2007 UTC

… …
7use Coro; 7use Coro;
8use Coro::AIO; 8use Coro::AIO;
9 9
10our $emergency_position = $cf::CFG{emergency_position} || ["/world/world_105_115", 5, 37]; 10our $emergency_position = $cf::CFG{emergency_position} || ["/world/world_105_115", 5, 37];
11 11
12our $DEACTIVATE_TIMEOUT = 60; # number of seconds after which maps get deactivated to save cpu 12our $DEACTIVATE_TIMEOUT = 60; # number of seconds after which maps get deactivated to save cpu
13our $SWAP_TIMEOUT = 600; # number of seconds after which maps inactive get swapped out 13our $SWAP_TIMEOUT = 600; # number of seconds after which maps inactive get swapped out
14our $SCHEDULE_INTERVAL = 8; # time the map scheduler sleeps between runs 14our $SCHEDULE_INTERVAL = 8; # time the map scheduler sleeps between runs
15our $SAVE_TIMEOUT = 60; # save maps every n seconds 15our $SAVE_TIMEOUT = 60; # save maps every n seconds
16our $SAVE_INTERVAL = 0.4; # save at max. one map every $SAVE_HOLD 16our $SAVE_INTERVAL = 0.4; # save at max. one map every $SAVE_HOLD
17our $MAX_RESET = 7200; 17our $MAX_RESET = 7200;
18 18
19$DEACTIVATE_TIMEOUT = 3;#d# 19$DEACTIVATE_TIMEOUT = 3;#d#
20$SWAP_TIMEOUT = 5;#d# 20$SWAP_TIMEOUT = 5;#d#
21$SCHEDULE_INTERVAL = 1; 21$SCHEDULE_INTERVAL = 1;
22 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
113sub 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::async {
136 unless (write_runtime) {
137 warn "unable to write runtime file: $!";
138 exit 1;
139 }
140})->prio (Coro::PRIO_MAX);
141
142our $SCHEDULER = cf::coro { 23our $SCHEDULER = cf::coro {
143 Coro::Timer::sleep 3600;#d#TODO#for debugging only
144 while () { 24 while () {
145 Coro::Timer::sleep $SCHEDULE_INTERVAL; 25 Coro::Timer::sleep $SCHEDULE_INTERVAL;
146
147 write_runtime
148 or warn "unable to write runtime file: $!";
149 26
150 for my $map (values %cf::MAP) { 27 for my $map (values %cf::MAP) {
151 eval { 28 eval {
152 next if $map->in_memory != cf::MAP_IN_MEMORY; 29 next if $map->in_memory != cf::MAP_IN_MEMORY;
153 next if $map->players; 30 next if $map->players;
… …
176$SCHEDULER->prio (-2); 53$SCHEDULER->prio (-2);
177 54
178sub generate_random_map { 55sub generate_random_map {
179 my ($path, $rmp) = @_; 56 my ($path, $rmp) = @_;
180 57
181 # mit "rum" bekleckert, nicht 58 # mit "rum" bekleckern, nicht
182 cf::map::_create_random_map 59 cf::map::_create_random_map
183 $path, 60 $path,
184 $rmp->{wallstyle}, $rmp->{wall_name}, $rmp->{floorstyle}, $rmp->{monsterstyle}, 61 $rmp->{wallstyle}, $rmp->{wall_name}, $rmp->{floorstyle}, $rmp->{monsterstyle},
185 $rmp->{treasurestyle}, $rmp->{layoutstyle}, $rmp->{doorstyle}, $rmp->{decorstyle}, 62 $rmp->{treasurestyle}, $rmp->{layoutstyle}, $rmp->{doorstyle}, $rmp->{decorstyle},
186 $rmp->{origin_map}, $rmp->{final_map}, $rmp->{exitstyle}, $rmp->{this_map}, 63 $rmp->{origin_map}, $rmp->{final_map}, $rmp->{exitstyle}, $rmp->{this_map},
… …
189 $rmp->{expand2x}, $rmp->{layoutoptions1}, $rmp->{layoutoptions2}, $rmp->{layoutoptions3}, 66 $rmp->{expand2x}, $rmp->{layoutoptions1}, $rmp->{layoutoptions2}, $rmp->{layoutoptions3},
190 $rmp->{symmetry}, $rmp->{difficulty}, $rmp->{difficulty_given}, $rmp->{difficulty_increase}, 67 $rmp->{symmetry}, $rmp->{difficulty}, $rmp->{difficulty_given}, $rmp->{difficulty_increase},
191 $rmp->{dungeon_level}, $rmp->{dungeon_depth}, $rmp->{decoroptions}, $rmp->{orientation}, 68 $rmp->{dungeon_level}, $rmp->{dungeon_depth}, $rmp->{decoroptions}, $rmp->{orientation},
192 $rmp->{origin_y}, $rmp->{origin_x}, $rmp->{random_seed}, $rmp->{total_map_hp}, 69 $rmp->{origin_y}, $rmp->{origin_x}, $rmp->{random_seed}, $rmp->{total_map_hp},
193 $rmp->{map_layout_style}, $rmp->{treasureoptions}, $rmp->{symmetry_used}, 70 $rmp->{map_layout_style}, $rmp->{treasureoptions}, $rmp->{symmetry_used},
194 $rmp->{region} 71 (cf::region::find $rmp->{region})
195} 72}
196 73
197sub parse_random_map_params { 74sub parse_random_map_params {
198 my ($spec) = @_; 75 my ($spec) = @_;
199 76
200 my $rmp; 77 my $rmp = { # defaults
78 xsize => 10,
79 ysize => 10,
80 };
201 81
202 for (split /\n/, $spec) { 82 for (split /\n/, $spec) {
203 my ($k, $v) = split /\s+/, $_, 2; 83 my ($k, $v) = split /\s+/, $_, 2;
204 84
205 $rmp->{lc $k} = $v if (length $k) && (length $v); 85 $rmp->{lc $k} = $v if (length $k) && (length $v);
… …
209} 89}
210 90
211sub prepare_random_map { 91sub prepare_random_map {
212 my ($exit) = @_; 92 my ($exit) = @_;
213 93
94 # all this does is basically replace the /! path by
95 # a new random map path (?random/...) with a seed
96 # that depends on the exit object
97
214 my $rmp = parse_random_map_params $exit->msg; 98 my $rmp = parse_random_map_params $exit->msg;
215 use Data::Dumper;
216 die Dumper $rmp;
217}
218 99
219sub sync_job(&) { 100 if ($exit->map) {
220 my ($job) = @_; 101 $rmp->{region} = $exit->map->region_name;
221 102 $rmp->{origin_map} = $exit->map->path;
222 my $done; 103 $rmp->{origin_x} = $exit->x;
223 my @res; 104 $rmp->{origin_y} = $exit->y;
224
225 Carp::confess "nested sync_job" if $cf::FREEZE;
226
227 local $cf::FREEZE = 1;
228
229 (Coro::async {
230 @res = eval { $job->() };
231 warn $@ if $@;
232 $done = 1;
233 })->prio (Coro::PRIO_MAX);
234
235 while (!$done) {
236 Coro::cede_notself;
237 Event::one_event unless Coro::nready;
238 } 105 }
239 106
240 warn "sync<@res>\n";#d# 107 $rmp->{random_seed} ||= $exit->random_seed;
241 wantarray ? @res : $res[0] 108
109 my $data = cf::to_json $rmp;
110 my $md5 = Digest::MD5::md5_hex $data;
111
112 if (my $fh = aio_open "$cf::RANDOM_MAPS/$md5.meta", O_WRONLY | O_CREAT, 0666) {
113 aio_write $fh, 0, (length $data), $data, 0;
114
115 $exit->slaying ("?random/$md5");
116 $exit->msg (undef);
117 }
242} 118}
243 119
244# and all this just because we cannot iterate over 120# and all this just because we cannot iterate over
245# all maps in C++... 121# all maps in C++...
246sub cf::map::change_all_map_light { 122sub cf::map::change_all_map_light {
… …
260 or return; 136 or return;
261 137
262 $map->load_header ($path) 138 $map->load_header ($path)
263 or return; 139 or return;
264 140
265 $map->reset_time (0) if $map->reset_time > $cf::RUNTIME;
266 $map->reset_timeout (10);#d#
267
268 $map->{load_path} = $path; 141 $map->{load_path} = $path;
142 use Data::Dumper; warn Dumper $map;#d#
269 143
270 $map 144 $map
271} 145}
272 146
273sub cf::map::find_map { 147sub cf::map::find_map {
274 my ($path, $origin) = @_; 148 my ($path, $origin) = @_;
275 149
276 warn "find_map<$path,$origin>\n";#d# 150 #warn "find_map<$path,$origin>\n";#d#
277 151
278 $path = ref $path ? $path : new cf::path $path, $origin && $origin->path; 152 $path = ref $path ? $path : new cf::path $path, $origin && $origin->path;
279 my $key = $path->as_string; 153 my $key = $path->as_string;
280 154
281 $cf::MAP{$key} || do { 155 $cf::MAP{$key} || do {
282 # do it the slow way 156 # do it the slow way
283 my $map = try_load_header $path->save_path; 157 my $map = try_load_header $path->save_path;
284 158
285 if (!$map) { 159 if ($map) {
160 # safety
161 $map->{reset_time} = $cf::RUNTIME + $MAX_RESET
162 if $map->{reset_time} > $cf::RUNTIME + $MAX_RESET;
163 } else {
164 if (my $rmp = $path->random_map_params) {
165 $map = generate_random_map $key, $rmp;
166 } else {
286 $map = try_load_header $path->load_path 167 $map = try_load_header $path->load_path;
168 }
169
287 or return; 170 $map or return;
288 171
172 $map->{reset_time} = $cf::RUNTIME + ($map->reset_timeout || 3600);
289 $map->instantiate; 173 $map->instantiate;
290 174
291 # per-player maps become, after loading, normal maps 175 # per-player maps become, after loading, normal maps
292 $map->per_player (0) if $path->{user_rel}; 176 $map->per_player (0) if $path->{user_rel};
293 } 177 }
294 178
295 $map->path ($key); 179 $map->path ($key);
296 $map->{path} = $path; 180 $map->{path} = $path;
181 $map->last_access ($cf::RUNTIME);
297 182
298 $map->reset if $map->should_reset; 183 $map->reset if $map->should_reset;
299 184
300 $cf::MAP{$key} = $map 185 $cf::MAP{$key} = $map
301 } 186 }
… …
322 } 207 }
323 } 208 }
324 209
325 # now do the right thing for maps 210 # now do the right thing for maps
326 $self->link_multipart_objects; 211 $self->link_multipart_objects;
212
213 unless ($self->{path}->is_style_map) {
327 $self->fix_auto_apply; 214 $self->fix_auto_apply;
328 $self->decay_objects; 215 $self->decay_objects;
329 $self->update_buttons; 216 $self->update_buttons;
330 $self->set_darkness_map; 217 $self->set_darkness_map;
331 $self->difficulty ($self->estimate_difficulty) 218 $self->difficulty ($self->estimate_difficulty)
332 unless $self->difficulty; 219 unless $self->difficulty;
333 $self->activate; 220 $self->activate;
221 }
334 222
335 $self->in_memory (cf::MAP_IN_MEMORY); 223 $self->in_memory (cf::MAP_IN_MEMORY);
336} 224}
337 225
338sub cf::map::load_map_sync { 226sub cf::map::load_map_sync {
339 my ($path, $origin) = @_; 227 my ($path, $origin) = @_;
340 228
341 warn "load_map_sync<$path, $origin>\n";#d# 229 #warn "load_map_sync<$path, $origin>\n";#d#
342 230
343 sync_job { 231 cf::sync_job {
344 my $map = cf::map::find_map $path, $origin 232 my $map = cf::map::find_map $path, $origin
345 or return; 233 or return;
346 $map->load; 234 $map->load;
347 $map 235 $map
348 } 236 }
349} 237}
350 238
351sub cf::map::save { 239sub cf::map::save {
352 my ($self) = @_; 240 my ($self) = @_;
353 241
354 warn "saving map ", $self->path;
355
356 my $save = $self->{path}->save_path; utf8::encode $save; 242 my $save = $self->{path}->save_path; utf8::encode $save;
357 my $uniq = $self->{path}->uniq_path; utf8::encode $uniq; 243 my $uniq = $self->{path}->uniq_path; utf8::encode $uniq;
244
245 $self->{last_save} = $cf::RUNTIME;
246
247 return unless $self->dirty;
248
249 $self->{load_path} = $save;
250
251 return if $self->{path}->is_style_map;
252
253 warn "saving map ", $self->path;
358 254
359 if ($uniq) { 255 if ($uniq) {
360 $self->save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS); 256 $self->save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS);
361 $self->save_objects ($uniq, cf::IO_UNIQUES); 257 $self->save_objects ($uniq, cf::IO_UNIQUES);
362 } else { 258 } else {
363 $self->save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS | cf::IO_UNIQUES); 259 $self->save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS | cf::IO_UNIQUES);
364 } 260 }
365
366 $self->{load_path} = $save;
367 $self->{last_save} = $cf::RUNTIME;
368} 261}
369 262
370sub cf::map::swap_out { 263sub cf::map::swap_out {
371 my ($self) = @_; 264 my ($self) = @_;
372 265
… …
381sub cf::map::should_reset { 274sub cf::map::should_reset {
382 my ($map) = @_; 275 my ($map) = @_;
383 276
384 # TODO: safety, remove and allow resettable per-player maps 277 # TODO: safety, remove and allow resettable per-player maps
385 return if $map->{path}{user_rel};#d# 278 return if $map->{path}{user_rel};#d#
386 return unless $map->reset_timeout; 279 #return unless $map->reset_timeout;
387 280
388 my $time = $map->fixed_resettime ? $map->reset_time : $map->last_access; 281 my $time = $map->fixed_resettime ? $map->{reset_time} : $map->last_access;
389 282
390 $time + $map->reset_timeout < $cf::RUNTIME 283 $time < $cf::RUNTIME
391} 284}
392 285
393sub cf::map::reset { 286sub cf::map::reset {
394 my ($self) = @_; 287 my ($self) = @_;
395 288
396 return if $self->players; 289 return if $self->players;
397 return if $self->{path}{user_rel};#d# 290 return if $self->{path}{user_rel};#d#
398 291
399 warn "resetting map ", $self->path;#d# 292 warn "resetting map ", $self->path;#d#
293 return;#d#
400 294
401 utf8::encode (my $save = $self->{path}->save_path); 295 utf8::encode (my $save = $self->{path}->save_path);
402 aioreq_pri 3; IO::AIO::aio_unlink $save; 296 aioreq_pri 3; IO::AIO::aio_unlink $save;
403 aioreq_pri 3; IO::AIO::aio_unlink "$save.pst"; 297 aioreq_pri 3; IO::AIO::aio_unlink "$save.pst";
404 298
… …
412 306
413 return unless $ob->type == cf::PLAYER; 307 return unless $ob->type == cf::PLAYER;
414 308
415 my ($oldmap, $oldx, $oldy) = ($ob->map, $ob->x, $ob->y); 309 my ($oldmap, $oldx, $oldy) = ($ob->map, $ob->x, $ob->y);
416 310
417 #TODO: do this in the background, freeze the player if required 311 $ob->enter_map ($LINK_MAP, 20, 20);
418 sync_job { 312 $ob->deactivate_recursive;
313
314 (Coro::async {
419 my ($map, $x, $y); 315 my ($map, $x, $y);
316 unless (eval {
420 317
421 if ($exit->slaying eq "/!") {
422 prepare_random_map $exit; 318 prepare_random_map $exit
319 if $exit->slaying eq "/!";
320
321 my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;
322
323 $map = cf::map::find_map $path->as_string;
324 $map = $map->customise_for ($ob) if $map;
325 ($x, $y) = ($exit->stats->hp, $exit->stats->sp);
326
327 unless ($map) {
328 $ob->message ("The exit is closed", cf::NDI_UNIQUE | cf::NDI_RED);
329
330 # restore original map position
331 ($map, $x, $y) = ($oldmap, $oldx, $oldy);
332
333 unless ($map) {
334 $map = cf::map::find_map $emergency_position->[0]
335 or die "FATAL: cannot load emergency map\n";
336 $x = $emergency_position->[1];
337 $y = $emergency_position->[2];
338 }
339 }
340
341 # use -1, -1 as default coordinates, not 0, 0
342 ($x, $y) = ($map->enter_x, $map->enter_y)
343 if $x <=0 && $y <= 0;
344
345 warn "entering ", $map->path, " at ($x, $y)\n";#d#
346 $map->load;
347 1;
348 }) {
349 ($map, $x, $y) = ($oldmap, $oldx, $oldy);
350
351 $ob->message ("Something went wrong deep within the crossfire server. "
352 . "I'll try to bring you back to the map you were before. "
353 . "Please report this to the dungeon master",
354 cf::NDI_UNIQUE | cf::NDI_RED);
355
356 warn "ERROR in enter_exit: $@";
423 } 357 }
424 358 $ob->activate_recursive;
425 my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;
426
427 $map = cf::map::find_map $path->as_string;
428 $map = $map->customise_for ($ob) if $map;
429 ($x, $y) = ($exit->stats->hp, $exit->stats->sp);
430
431 unless ($map) {
432 $ob->message ("The exit is closed", cf::NDI_UNIQUE | cf::NDI_RED);
433
434 # restore original map position
435 ($map, $x, $y) = ($oldmap, $oldx, $oldy);
436
437 unless ($map) {
438 $map = cf::map::find_map $emergency_position->[0]
439 or die "FATAL: cannot load emergency map\n";
440 $x = $emergency_position->[1];
441 $y = $emergency_position->[2];
442 }
443 }
444
445 # use -1, -1 as default coordinates, not 0, 0
446 ($x, $y) = ($map->enter_x, $map->enter_y)
447 if $x <=0 && $y <= 0;
448
449 warn "entering ", $map->path, " at ($x, $y)\n";#d#
450 $map->load;
451 $ob->enter_map ($map, $x, $y); 359 $ob->enter_map ($map, $x, $y);
452 } 360 })->prio (1);
453} 361}
454 362
455sub cf::map::customise_for { 363sub cf::map::customise_for {
456 my ($map, $ob) = @_; 364 my ($map, $ob) = @_;
457 365
… …
465sub cf::map::emergency_save { 373sub cf::map::emergency_save {
466 local $cf::FREEZE = 1; 374 local $cf::FREEZE = 1;
467 375
468 warn "enter emergency map save\n"; 376 warn "enter emergency map save\n";
469 377
470 my $saver = async { 378 cf::sync_job {
471 warn "begin emergency map save\n"; 379 warn "begin emergency map save\n";
472 $_->save for values %cf::MAP; 380 $_->save for values %cf::MAP;
473 }; 381 };
474 $saver->prio (Coro::PRIO_MAX);
475 $saver->join;
476 382
477 warn "emergency map save drain\n";
478 Event::one_event while IO::AIO::nreqs;
479 warn "end emergency map save\n"; 383 warn "end emergency map save\n";
480} 384}
481 385

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines