ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/lib/cf.pm
(Generate patch)

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.108 by root, Sun Dec 31 21:02:05 2006 UTC vs.
Revision 1.113 by root, Mon Jan 1 15:32:40 2007 UTC

… …
71mkdir cf::localdir . "/" . cf::uniquedir; 71mkdir cf::localdir . "/" . cf::uniquedir;
72mkdir $RANDOM_MAPS; 72mkdir $RANDOM_MAPS;
73 73
74# a special map that is always available 74# a special map that is always available
75our $LINK_MAP; 75our $LINK_MAP;
76
77our $EMERGENCY_POSITION = $cf::CFG{emergency_position} || ["/world/world_105_115", 5, 37];
76 78
77############################################################################# 79#############################################################################
78 80
79=head2 GLOBAL VARIABLES 81=head2 GLOBAL VARIABLES
80 82
… …
195=cut 197=cut
196 198
197sub sync_job(&) { 199sub sync_job(&) {
198 my ($job) = @_; 200 my ($job) = @_;
199 201
200 my $busy = 1;
201 my @res;
202
203 # TODO: use suspend/resume instead
204 local $FREEZE = 1;
205
206 my $coro = Coro::async {
207 @res = eval { $job->() };
208 warn $@ if $@;
209 undef $busy;
210 };
211
212 if ($Coro::current == $Coro::main) { 202 if ($Coro::current == $Coro::main) {
203 # this is the main coro, too bad, we have to block
204 # till the operation succeeds, freezing the server :/
205
206 # TODO: use suspend/resume instead
207 # (but this is cancel-safe)
208 local $FREEZE = 1;
209
210 my $busy = 1;
211 my @res;
212
213 (Coro::async {
214 @res = eval { $job->() };
215 warn $@ if $@;
216 undef $busy;
213 $coro->prio (Coro::PRIO_MAX); 217 })->prio (Coro::PRIO_MAX);
218
214 while ($busy) { 219 while ($busy) {
215 Coro::cede_notself; 220 Coro::cede_notself;
216 Event::one_event unless Coro::nready; 221 Event::one_event unless Coro::nready;
217 } 222 }
223
224 wantarray ? @res : $res[0]
218 } else { 225 } else {
219 $coro->join; 226 # we are in another coroutine, how wonderful, everything just works
227
228 $job->()
220 } 229 }
221
222 wantarray ? @res : $res[0]
223} 230}
224 231
225=item $coro = cf::coro { BLOCK } 232=item $coro = cf::coro { BLOCK }
226 233
227Creates and returns a new coro. This coro is automcatially being canceled 234Creates and returns a new coro. This coro is automcatially being canceled
… …
251 my $runtime = cf::localdir . "/runtime"; 258 my $runtime = cf::localdir . "/runtime";
252 259
253 my $fh = aio_open "$runtime~", O_WRONLY | O_CREAT, 0644 260 my $fh = aio_open "$runtime~", O_WRONLY | O_CREAT, 0644
254 or return; 261 or return;
255 262
256 my $value = $cf::RUNTIME; 263 my $value = $cf::RUNTIME + 1 + 10; # 10 is the runtime save interval, for a monotonic clock
257 (aio_write $fh, 0, (length $value), $value, 0) <= 0 264 (aio_write $fh, 0, (length $value), $value, 0) <= 0
258 and return; 265 and return;
259 266
260 aio_fsync $fh 267 aio_fsync $fh
261 and return; 268 and return;
… …
278package cf::path; 285package cf::path;
279 286
280sub new { 287sub new {
281 my ($class, $path, $base) = @_; 288 my ($class, $path, $base) = @_;
282 289
290 $path = $path->as_string if ref $path;
291
283 my $self = bless { }, $class; 292 my $self = bless { }, $class;
284 293
285 if ($path =~ s{^\?random/}{}) { 294 if ($path =~ s{^\?random/}{}) {
295 Coro::AIO::aio_load "$cf::RANDOM_MAPS/$path.meta", my $data;
286 $self->{random} = cf::from_json $path; 296 $self->{random} = cf::from_json $data;
287 } else { 297 } else {
288 if ($path =~ s{^~([^/]+)?}{}) { 298 if ($path =~ s{^~([^/]+)?}{}) {
289 $self->{user_rel} = 1; 299 $self->{user_rel} = 1;
290 300
291 if (defined $1) { 301 if (defined $1) {
… …
324 334
325# the displayed name, this is a one way mapping 335# the displayed name, this is a one way mapping
326sub visible_name { 336sub visible_name {
327 my ($self) = @_; 337 my ($self) = @_;
328 338
329 $self->{random} ? "?random/$self->{random}{origin_map}+$self->{random}{origin_x}+$self->{random}{origin_y}/$self->{random}{dungeon_level}" 339# if (my $rmp = $self->{random}) {
330 : $self->as_string 340# # todo: be more intelligent about this
341# "?random/$rmp->{origin_map}+$rmp->{origin_x}+$rmp->{origin_y}/$rmp->{dungeon_level}"
342# } else {
343 $self->as_string
344# }
331} 345}
332 346
333# escape the /'s in the path 347# escape the /'s in the path
334sub _escaped_path { 348sub _escaped_path {
335 # ∕ is U+2215 349 # ∕ is U+2215
… …
347# the temporary/swap location 361# the temporary/swap location
348sub save_path { 362sub save_path {
349 my ($self) = @_; 363 my ($self) = @_;
350 364
351 $self->{user_rel} ? sprintf "%s/%s/%s/%s", cf::localdir, cf::playerdir, $self->{user}, $self->_escaped_path 365 $self->{user_rel} ? sprintf "%s/%s/%s/%s", cf::localdir, cf::playerdir, $self->{user}, $self->_escaped_path
352 : $self->{random} ? sprintf "%s/%s", $RANDOM_MAPS, Digest::MD5::md5_hex $self->{path} 366 : $self->{random} ? sprintf "%s/%s", $RANDOM_MAPS, $self->{path}
353 : sprintf "%s/%s/%s", cf::localdir, cf::tmpdir, $self->_escaped_path 367 : sprintf "%s/%s/%s", cf::localdir, cf::tmpdir, $self->_escaped_path
354} 368}
355 369
356# the unique path, might be eq to save_path 370# the unique path, might be eq to save_path
357sub uniq_path { 371sub uniq_path {
… …
790 or return; 804 or return;
791 805
792 unless (aio_stat "$filename.pst") { 806 unless (aio_stat "$filename.pst") {
793 (aio_load "$filename.pst", $av) >= 0 807 (aio_load "$filename.pst", $av) >= 0
794 or return; 808 or return;
795 $av = eval { (Storable::thaw <$av>)->{objs} }; 809 $av = eval { (Storable::thaw $av)->{objs} };
796 } 810 }
797 811
798 return ($data, $av); 812 return ($data, $av);
799} 813}
800 814
… …
1024 $self->send ("ext " . to_json \%msg); 1038 $self->send ("ext " . to_json \%msg);
1025} 1039}
1026 1040
1027=back 1041=back
1028 1042
1043
1044=head3 cf::map
1045
1046=over 4
1047
1048=cut
1049
1050package cf::map;
1051
1052use Fcntl;
1053use Coro::AIO;
1054
1055our $MAX_RESET = 7200;
1056our $DEFAULT_RESET = 3600;
1057
1058sub generate_random_map {
1059 my ($path, $rmp) = @_;
1060
1061 # mit "rum" bekleckern, nicht
1062 cf::map::_create_random_map
1063 $path,
1064 $rmp->{wallstyle}, $rmp->{wall_name}, $rmp->{floorstyle}, $rmp->{monsterstyle},
1065 $rmp->{treasurestyle}, $rmp->{layoutstyle}, $rmp->{doorstyle}, $rmp->{decorstyle},
1066 $rmp->{origin_map}, $rmp->{final_map}, $rmp->{exitstyle}, $rmp->{this_map},
1067 $rmp->{exit_on_final_map},
1068 $rmp->{xsize}, $rmp->{ysize},
1069 $rmp->{expand2x}, $rmp->{layoutoptions1}, $rmp->{layoutoptions2}, $rmp->{layoutoptions3},
1070 $rmp->{symmetry}, $rmp->{difficulty}, $rmp->{difficulty_given}, $rmp->{difficulty_increase},
1071 $rmp->{dungeon_level}, $rmp->{dungeon_depth}, $rmp->{decoroptions}, $rmp->{orientation},
1072 $rmp->{origin_y}, $rmp->{origin_x}, $rmp->{random_seed}, $rmp->{total_map_hp},
1073 $rmp->{map_layout_style}, $rmp->{treasureoptions}, $rmp->{symmetry_used},
1074 (cf::region::find $rmp->{region})
1075}
1076
1077# and all this just because we cannot iterate over
1078# all maps in C++...
1079sub change_all_map_light {
1080 my ($change) = @_;
1081
1082 $_->change_map_light ($change) for values %cf::MAP;
1083}
1084
1085sub try_load_header($) {
1086 my ($path) = @_;
1087
1088 utf8::encode $path;
1089 aio_open $path, O_RDONLY, 0
1090 or return;
1091
1092 my $map = cf::map::new
1093 or return;
1094
1095 $map->load_header ($path)
1096 or return;
1097
1098 $map->{load_path} = $path;
1099
1100 $map
1101}
1102
1103sub find_map {
1104 my ($path, $origin) = @_;
1105
1106 #warn "find_map<$path,$origin>\n";#d#
1107
1108 $path = new cf::path $path, $origin && $origin->path;
1109 my $key = $path->as_string;
1110
1111 $cf::MAP{$key} || do {
1112 # do it the slow way
1113 my $map = try_load_header $path->save_path;
1114
1115 if ($map) {
1116 # safety
1117 $map->{instantiate_time} = $cf::RUNTIME
1118 if $map->{instantiate_time} > $cf::RUNTIME;
1119 } else {
1120 if (my $rmp = $path->random_map_params) {
1121 $map = generate_random_map $key, $rmp;
1122 } else {
1123 $map = try_load_header $path->load_path;
1124 }
1125
1126 $map or return;
1127
1128 $map->{load_original} = 1;
1129 $map->{instantiate_time} = $cf::RUNTIME;
1130 $map->instantiate;
1131
1132 # per-player maps become, after loading, normal maps
1133 $map->per_player (0) if $path->{user_rel};
1134 }
1135
1136 $map->path ($key);
1137 $map->{path} = $path;
1138 $map->last_access ($cf::RUNTIME);
1139
1140 if ($map->should_reset) {
1141 $map->reset;
1142 $map = find_map $path;
1143 }
1144
1145 $cf::MAP{$key} = $map
1146 }
1147}
1148
1149sub load {
1150 my ($self) = @_;
1151
1152 return if $self->in_memory != cf::MAP_SWAPPED;
1153
1154 $self->in_memory (cf::MAP_LOADING);
1155
1156 my $path = $self->{path};
1157
1158 $self->alloc;
1159 $self->load_objects ($self->{load_path}, 1)
1160 or return;
1161
1162 $self->set_object_flag (cf::FLAG_OBJ_ORIGINAL, 1)
1163 if delete $self->{load_original};
1164
1165 if (my $uniq = $path->uniq_path) {
1166 utf8::encode $uniq;
1167 if (aio_open $uniq, O_RDONLY, 0) {
1168 $self->clear_unique_items;
1169 $self->load_objects ($uniq, 0);
1170 }
1171 }
1172
1173 # now do the right thing for maps
1174 $self->link_multipart_objects;
1175
1176 if ($self->{path}->is_style_map) {
1177 $self->{deny_save} = 1;
1178 $self->{deny_reset} = 1;
1179 } else {
1180 $self->fix_auto_apply;
1181 $self->decay_objects;
1182 $self->update_buttons;
1183 $self->set_darkness_map;
1184 $self->difficulty ($self->estimate_difficulty)
1185 unless $self->difficulty;
1186 $self->activate;
1187 }
1188
1189 $self->in_memory (cf::MAP_IN_MEMORY);
1190}
1191
1192sub load_map_sync {
1193 my ($path, $origin) = @_;
1194
1195 #warn "load_map_sync<$path, $origin>\n";#d#
1196
1197 cf::sync_job {
1198 my $map = cf::map::find_map $path, $origin
1199 or return;
1200 $map->load;
1201 $map
1202 }
1203}
1204
1205sub save {
1206 my ($self) = @_;
1207
1208 my $save = $self->{path}->save_path; utf8::encode $save;
1209 my $uniq = $self->{path}->uniq_path; utf8::encode $uniq;
1210
1211 $self->{last_save} = $cf::RUNTIME;
1212
1213 return unless $self->dirty;
1214
1215 $self->{load_path} = $save;
1216
1217 return if $self->{deny_save};
1218
1219 if ($uniq) {
1220 $self->save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS);
1221 $self->save_objects ($uniq, cf::IO_UNIQUES);
1222 } else {
1223 $self->save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS | cf::IO_UNIQUES);
1224 }
1225}
1226
1227sub swap_out {
1228 my ($self) = @_;
1229
1230 return if $self->players;
1231 return if $self->in_memory != cf::MAP_IN_MEMORY;
1232 return if $self->{deny_save};
1233
1234 $self->save;
1235 $self->clear;
1236 $self->in_memory (cf::MAP_SWAPPED);
1237}
1238
1239sub reset_at {
1240 my ($self) = @_;
1241
1242 # TODO: safety, remove and allow resettable per-player maps
1243 return 1e100 if $self->{path}{user_rel};
1244 return 1e100 if $self->{deny_reset};
1245
1246 my $time = $self->fixed_resettime ? $self->{instantiate_time} : $self->last_access;
1247 my $to = $self->reset_timeout || $DEFAULT_RESET;
1248 $to = $MAX_RESET if $to > $MAX_RESET;
1249
1250 $time + $to
1251}
1252
1253sub should_reset {
1254 my ($self) = @_;
1255
1256 $self->reset_at <= $cf::RUNTIME
1257}
1258
1259sub unlink_save {
1260 my ($self) = @_;
1261
1262 utf8::encode (my $save = $self->{path}->save_path);
1263 aioreq_pri 3; IO::AIO::aio_unlink $save;
1264 aioreq_pri 3; IO::AIO::aio_unlink "$save.pst";
1265}
1266
1267sub rename {
1268 my ($self, $new_path) = @_;
1269
1270 $self->unlink_save;
1271
1272 delete $cf::MAP{$self->path};
1273 $self->{path} = new cf::path $new_path;
1274 $self->path ($self->{path}->path);
1275 $cf::MAP{$self->path} = $self;
1276
1277 $self->save;
1278}
1279
1280sub reset {
1281 my ($self) = @_;
1282
1283 return if $self->players;
1284 return if $self->{path}{user_rel};#d#
1285
1286 warn "resetting map ", $self->path;#d#
1287
1288 delete $cf::MAP{$self->path};
1289
1290 $_->clear_links_to ($self) for values %cf::MAP;
1291
1292 $self->unlink_save;
1293 $self->destroy;
1294}
1295
1296sub customise_for {
1297 my ($map, $ob) = @_;
1298
1299 if ($map->per_player) {
1300 return cf::map::find_map "~" . $ob->name . "/" . $map->{path}{path};
1301 }
1302
1303 $map
1304}
1305
1306sub emergency_save {
1307 local $cf::FREEZE = 1;
1308
1309 warn "enter emergency map save\n";
1310
1311 cf::sync_job {
1312 warn "begin emergency map save\n";
1313 $_->save for values %cf::MAP;
1314 };
1315
1316 warn "end emergency map save\n";
1317}
1318
1319package cf;
1320
1321=back
1322
1323
1029=head3 cf::object::player 1324=head3 cf::object::player
1030 1325
1031=over 4 1326=over 4
1032 1327
1033=item $player_object->reply ($npc, $msg[, $flags]) 1328=item $player_object->reply ($npc, $msg[, $flags])
… …
1066 1361
1067 $self->flag (cf::FLAG_WIZ) || 1362 $self->flag (cf::FLAG_WIZ) ||
1068 (ref $cf::CFG{"may_$access"} 1363 (ref $cf::CFG{"may_$access"}
1069 ? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}} 1364 ? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}
1070 : $cf::CFG{"may_$access"}) 1365 : $cf::CFG{"may_$access"})
1366}
1367
1368sub cf::object::player::enter_link {
1369 my ($self) = @_;
1370
1371 return if $self->map == $LINK_MAP;
1372
1373 $self->{_link_pos} = [$self->map->{path}, $self->x, $self->y]
1374 if $self->map;
1375
1376 $self->enter_map ($LINK_MAP, 20, 20);
1377 $self->deactivate_recursive;
1378}
1379
1380sub cf::object::player::leave_link {
1381 my ($self, $map, $x, $y) = @_;
1382
1383 my $link_pos = delete $self->{_link_pos};
1384
1385 unless ($map) {
1386 $self->message ("The exit is closed", cf::NDI_UNIQUE | cf::NDI_RED);
1387
1388 # restore original map position
1389 ($map, $x, $y) = @{ $link_pos || [] };
1390 $map = cf::map::find_map $map;
1391
1392 unless ($map) {
1393 ($map, $x, $y) = @$EMERGENCY_POSITION;
1394 $map = cf::map::find_map $map
1395 or die "FATAL: cannot load emergency map\n";
1396 }
1397 }
1398
1399 ($x, $y) = (-1, -1)
1400 unless (defined $x) && (defined $y);
1401
1402 # use -1 or undef as default coordinates, not 0, 0
1403 ($x, $y) = ($map->enter_x, $map->enter_y)
1404 if $x <=0 && $y <= 0;
1405
1406 $map->load;
1407
1408 $self->activate_recursive;
1409 $self->enter_map ($map, $x, $y);
1410}
1411
1412=item $player_object->goto_map ($map, $x, $y)
1413
1414=cut
1415
1416sub cf::object::player::goto_map {
1417 my ($self, $path, $x, $y) = @_;
1418
1419 $self->enter_link;
1420
1421 (Coro::async {
1422 $path = new cf::path $path;
1423
1424 my $map = cf::map::find_map $path->as_string;
1425 $map = $map->customise_for ($self) if $map;
1426
1427 warn "entering ", $map->path, " at ($x, $y)\n"
1428 if $map;
1429
1430 $self->leave_link ($map, $x, $y);
1431 })->prio (1);
1432}
1433
1434=item $player_object->enter_exit ($exit_object)
1435
1436=cut
1437
1438sub parse_random_map_params {
1439 my ($spec) = @_;
1440
1441 my $rmp = { # defaults
1442 xsize => 10,
1443 ysize => 10,
1444 };
1445
1446 for (split /\n/, $spec) {
1447 my ($k, $v) = split /\s+/, $_, 2;
1448
1449 $rmp->{lc $k} = $v if (length $k) && (length $v);
1450 }
1451
1452 $rmp
1453}
1454
1455sub prepare_random_map {
1456 my ($exit) = @_;
1457
1458 # all this does is basically replace the /! path by
1459 # a new random map path (?random/...) with a seed
1460 # that depends on the exit object
1461
1462 my $rmp = parse_random_map_params $exit->msg;
1463
1464 if ($exit->map) {
1465 $rmp->{region} = $exit->map->region_name;
1466 $rmp->{origin_map} = $exit->map->path;
1467 $rmp->{origin_x} = $exit->x;
1468 $rmp->{origin_y} = $exit->y;
1469 }
1470
1471 $rmp->{random_seed} ||= $exit->random_seed;
1472
1473 my $data = cf::to_json $rmp;
1474 my $md5 = Digest::MD5::md5_hex $data;
1475
1476 if (my $fh = aio_open "$cf::RANDOM_MAPS/$md5.meta", O_WRONLY | O_CREAT, 0666) {
1477 aio_write $fh, 0, (length $data), $data, 0;
1478
1479 $exit->slaying ("?random/$md5");
1480 $exit->msg (undef);
1481 }
1482}
1483
1484sub cf::object::player::enter_exit {
1485 my ($self, $exit) = @_;
1486
1487 return unless $self->type == cf::PLAYER;
1488
1489 $self->enter_link;
1490
1491 (Coro::async {
1492 unless (eval {
1493
1494 prepare_random_map $exit
1495 if $exit->slaying eq "/!";
1496
1497 my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;
1498 $self->goto_map ($path, $exit->stats->hp, $exit->stats->sp);
1499
1500 1;
1501 }) {
1502 $self->message ("Something went wrong deep within the crossfire server. "
1503 . "I'll try to bring you back to the map you were before. "
1504 . "Please report this to the dungeon master",
1505 cf::NDI_UNIQUE | cf::NDI_RED);
1506
1507 warn "ERROR in enter_exit: $@";
1508 $self->leave_link;
1509 }
1510 })->prio (1);
1071} 1511}
1072 1512
1073=head3 cf::client 1513=head3 cf::client
1074 1514
1075=over 4 1515=over 4
… …
1419} 1859}
1420 1860
1421############################################################################# 1861#############################################################################
1422# initialisation 1862# initialisation
1423 1863
1424sub perl_reload() { 1864sub reload() {
1425 # can/must only be called in main 1865 # can/must only be called in main
1426 if ($Coro::current != $Coro::main) { 1866 if ($Coro::current != $Coro::main) {
1427 warn "can only reload from main coroutine\n"; 1867 warn "can only reload from main coroutine\n";
1428 return; 1868 return;
1429 } 1869 }
… …
1522 $LINK_MAP->height (41); 1962 $LINK_MAP->height (41);
1523 $LINK_MAP->alloc; 1963 $LINK_MAP->alloc;
1524 $LINK_MAP->path ("{link}"); 1964 $LINK_MAP->path ("{link}");
1525 $LINK_MAP->{path} = bless { path => "{link}" }, "cf::path"; 1965 $LINK_MAP->{path} = bless { path => "{link}" }, "cf::path";
1526 $LINK_MAP->in_memory (MAP_IN_MEMORY); 1966 $LINK_MAP->in_memory (MAP_IN_MEMORY);
1967
1968 # dirty hack because... archetypes are not yet loaded
1969 Event->timer (
1970 after => 2,
1971 cb => sub {
1972 $_[0]->w->cancel;
1973
1974 # provide some exits "home"
1975 my $exit = cf::object::new "exit";
1976
1977 $exit->slaying ($EMERGENCY_POSITION->[0]);
1978 $exit->stats->hp ($EMERGENCY_POSITION->[1]);
1979 $exit->stats->sp ($EMERGENCY_POSITION->[2]);
1980
1981 $LINK_MAP->insert ($exit->clone, 19, 19);
1982 $LINK_MAP->insert ($exit->clone, 19, 20);
1983 $LINK_MAP->insert ($exit->clone, 19, 21);
1984 $LINK_MAP->insert ($exit->clone, 20, 19);
1985 $LINK_MAP->insert ($exit->clone, 20, 21);
1986 $LINK_MAP->insert ($exit->clone, 21, 19);
1987 $LINK_MAP->insert ($exit->clone, 21, 20);
1988 $LINK_MAP->insert ($exit->clone, 21, 21);
1989
1990 $exit->destroy;
1991 });
1992
1993 $LINK_MAP->{deny_save} = 1;
1994 $LINK_MAP->{deny_reset} = 1;
1995
1996 $cf::MAP{$LINK_MAP->path} = $LINK_MAP;
1527} 1997}
1528 1998
1529register "<global>", __PACKAGE__; 1999register "<global>", __PACKAGE__;
1530 2000
1531register_command "perl-reload" => sub { 2001register_command "reload" => sub {
1532 my ($who, $arg) = @_; 2002 my ($who, $arg) = @_;
1533 2003
1534 if ($who->flag (FLAG_WIZ)) { 2004 if ($who->flag (FLAG_WIZ)) {
1535 $who->message ("start of reload."); 2005 $who->message ("start of reload.");
1536 perl_reload; 2006 reload;
1537 $who->message ("end of reload."); 2007 $who->message ("end of reload.");
1538 } 2008 }
1539}; 2009};
1540 2010
1541unshift @INC, $LIBDIR; 2011unshift @INC, $LIBDIR;

Diff Legend

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