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.109 by root, Sun Dec 31 22:23:12 2006 UTC vs.
Revision 1.112 by root, Mon Jan 1 13:31:47 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;
… …
277 284
278package cf::path; 285package cf::path;
279 286
280sub new { 287sub new {
281 my ($class, $path, $base) = @_; 288 my ($class, $path, $base) = @_;
289
290 $path = $path->as_string if ref $path;
282 291
283 my $self = bless { }, $class; 292 my $self = bless { }, $class;
284 293
285 if ($path =~ s{^\?random/}{}) { 294 if ($path =~ s{^\?random/}{}) {
286 Coro::AIO::aio_load "$cf::RANDOM_MAPS/$path.meta", my $data; 295 Coro::AIO::aio_load "$cf::RANDOM_MAPS/$path.meta", my $data;
… …
1029 $self->send ("ext " . to_json \%msg); 1038 $self->send ("ext " . to_json \%msg);
1030} 1039}
1031 1040
1032=back 1041=back
1033 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 reset {
1268 my ($self) = @_;
1269
1270 return if $self->players;
1271 return if $self->{path}{user_rel};#d#
1272
1273 warn "resetting map ", $self->path;#d#
1274
1275 delete $cf::MAP{$self->path};
1276
1277 $_->clear_links_to ($self) for values %cf::MAP;
1278
1279 $self->unlink_save;
1280 $self->destroy;
1281}
1282
1283sub customise_for {
1284 my ($map, $ob) = @_;
1285
1286 if ($map->per_player) {
1287 return cf::map::find_map "~" . $ob->name . "/" . $map->{path}{path};
1288 }
1289
1290 $map
1291}
1292
1293sub emergency_save {
1294 local $cf::FREEZE = 1;
1295
1296 warn "enter emergency map save\n";
1297
1298 cf::sync_job {
1299 warn "begin emergency map save\n";
1300 $_->save for values %cf::MAP;
1301 };
1302
1303 warn "end emergency map save\n";
1304}
1305
1306package cf;
1307
1308=back
1309
1310
1034=head3 cf::object::player 1311=head3 cf::object::player
1035 1312
1036=over 4 1313=over 4
1037 1314
1038=item $player_object->reply ($npc, $msg[, $flags]) 1315=item $player_object->reply ($npc, $msg[, $flags])
… …
1071 1348
1072 $self->flag (cf::FLAG_WIZ) || 1349 $self->flag (cf::FLAG_WIZ) ||
1073 (ref $cf::CFG{"may_$access"} 1350 (ref $cf::CFG{"may_$access"}
1074 ? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}} 1351 ? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}
1075 : $cf::CFG{"may_$access"}) 1352 : $cf::CFG{"may_$access"})
1353}
1354
1355sub cf::object::player::enter_link {
1356 my ($self) = @_;
1357
1358 return if $self->map == $LINK_MAP;
1359
1360 $self->{_link_pos} = [$self->map->{path}, $self->x, $self->y]
1361 if $self->map;
1362
1363 $self->enter_map ($LINK_MAP, 20, 20);
1364 $self->deactivate_recursive;
1365}
1366
1367sub cf::object::player::leave_link {
1368 my ($self, $map, $x, $y) = @_;
1369
1370 my $link_pos = delete $self->{_link_pos};
1371
1372 unless ($map) {
1373 $self->message ("The exit is closed", cf::NDI_UNIQUE | cf::NDI_RED);
1374
1375 # restore original map position
1376 ($map, $x, $y) = @{ $link_pos || [] };
1377 $map = cf::map::find_map $map;
1378
1379 unless ($map) {
1380 ($map, $x, $y) = @$EMERGENCY_POSITION;
1381 $map = cf::map::find_map $map
1382 or die "FATAL: cannot load emergency map\n";
1383 }
1384 }
1385
1386 ($x, $y) = (-1, -1)
1387 unless (defined $x) && (defined $y);
1388
1389 # use -1 or undef as default coordinates, not 0, 0
1390 ($x, $y) = ($map->enter_x, $map->enter_y)
1391 if $x <=0 && $y <= 0;
1392
1393 $map->load;
1394
1395 $self->activate_recursive;
1396 $self->enter_map ($map, $x, $y);
1397}
1398
1399=item $player_object->goto_map ($map, $x, $y)
1400
1401=cut
1402
1403sub cf::object::player::goto_map {
1404 my ($self, $path, $x, $y) = @_;
1405
1406 $self->enter_link;
1407
1408 (Coro::async {
1409 $path = new cf::path $path;
1410
1411 my $map = cf::map::find_map $path->as_string;
1412 $map = $map->customise_for ($self) if $map;
1413
1414 warn "entering ", $map->path, " at ($x, $y)\n"
1415 if $map;
1416
1417 $self->leave_link ($map, $x, $y);
1418 })->prio (1);
1419}
1420
1421=item $player_object->enter_exit ($exit_object)
1422
1423=cut
1424
1425sub parse_random_map_params {
1426 my ($spec) = @_;
1427
1428 my $rmp = { # defaults
1429 xsize => 10,
1430 ysize => 10,
1431 };
1432
1433 for (split /\n/, $spec) {
1434 my ($k, $v) = split /\s+/, $_, 2;
1435
1436 $rmp->{lc $k} = $v if (length $k) && (length $v);
1437 }
1438
1439 $rmp
1440}
1441
1442sub prepare_random_map {
1443 my ($exit) = @_;
1444
1445 # all this does is basically replace the /! path by
1446 # a new random map path (?random/...) with a seed
1447 # that depends on the exit object
1448
1449 my $rmp = parse_random_map_params $exit->msg;
1450
1451 if ($exit->map) {
1452 $rmp->{region} = $exit->map->region_name;
1453 $rmp->{origin_map} = $exit->map->path;
1454 $rmp->{origin_x} = $exit->x;
1455 $rmp->{origin_y} = $exit->y;
1456 }
1457
1458 $rmp->{random_seed} ||= $exit->random_seed;
1459
1460 my $data = cf::to_json $rmp;
1461 my $md5 = Digest::MD5::md5_hex $data;
1462
1463 if (my $fh = aio_open "$cf::RANDOM_MAPS/$md5.meta", O_WRONLY | O_CREAT, 0666) {
1464 aio_write $fh, 0, (length $data), $data, 0;
1465
1466 $exit->slaying ("?random/$md5");
1467 $exit->msg (undef);
1468 }
1469}
1470
1471sub cf::object::player::enter_exit {
1472 my ($self, $exit) = @_;
1473
1474 return unless $self->type == cf::PLAYER;
1475
1476 $self->enter_link;
1477
1478 (Coro::async {
1479 unless (eval {
1480
1481 prepare_random_map $exit
1482 if $exit->slaying eq "/!";
1483
1484 my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;
1485 $self->goto_map ($path, $exit->stats->hp, $exit->stats->sp);
1486
1487 1;
1488 }) {
1489 $self->message ("Something went wrong deep within the crossfire server. "
1490 . "I'll try to bring you back to the map you were before. "
1491 . "Please report this to the dungeon master",
1492 cf::NDI_UNIQUE | cf::NDI_RED);
1493
1494 warn "ERROR in enter_exit: $@";
1495 $self->leave_link;
1496 }
1497 })->prio (1);
1076} 1498}
1077 1499
1078=head3 cf::client 1500=head3 cf::client
1079 1501
1080=over 4 1502=over 4
… …
1424} 1846}
1425 1847
1426############################################################################# 1848#############################################################################
1427# initialisation 1849# initialisation
1428 1850
1429sub perl_reload() { 1851sub reload() {
1430 # can/must only be called in main 1852 # can/must only be called in main
1431 if ($Coro::current != $Coro::main) { 1853 if ($Coro::current != $Coro::main) {
1432 warn "can only reload from main coroutine\n"; 1854 warn "can only reload from main coroutine\n";
1433 return; 1855 return;
1434 } 1856 }
… …
1527 $LINK_MAP->height (41); 1949 $LINK_MAP->height (41);
1528 $LINK_MAP->alloc; 1950 $LINK_MAP->alloc;
1529 $LINK_MAP->path ("{link}"); 1951 $LINK_MAP->path ("{link}");
1530 $LINK_MAP->{path} = bless { path => "{link}" }, "cf::path"; 1952 $LINK_MAP->{path} = bless { path => "{link}" }, "cf::path";
1531 $LINK_MAP->in_memory (MAP_IN_MEMORY); 1953 $LINK_MAP->in_memory (MAP_IN_MEMORY);
1954
1955 # dirty hack because... archetypes are not yet loaded
1956 Event->timer (
1957 after => 2,
1958 cb => sub {
1959 $_[0]->w->cancel;
1960
1961 # provide some exits "home"
1962 my $exit = cf::object::new "exit";
1963
1964 $exit->slaying ($EMERGENCY_POSITION->[0]);
1965 $exit->stats->hp ($EMERGENCY_POSITION->[1]);
1966 $exit->stats->sp ($EMERGENCY_POSITION->[2]);
1967
1968 $LINK_MAP->insert ($exit->clone, 19, 19);
1969 $LINK_MAP->insert ($exit->clone, 19, 20);
1970 $LINK_MAP->insert ($exit->clone, 19, 21);
1971 $LINK_MAP->insert ($exit->clone, 20, 19);
1972 $LINK_MAP->insert ($exit->clone, 20, 21);
1973 $LINK_MAP->insert ($exit->clone, 21, 19);
1974 $LINK_MAP->insert ($exit->clone, 21, 20);
1975 $LINK_MAP->insert ($exit->clone, 21, 21);
1976
1977 $exit->destroy;
1978 });
1979
1980 $LINK_MAP->{deny_save} = 1;
1981 $LINK_MAP->{deny_reset} = 1;
1982
1983 $cf::MAP{$LINK_MAP->path} = $LINK_MAP;
1532} 1984}
1533 1985
1534register "<global>", __PACKAGE__; 1986register "<global>", __PACKAGE__;
1535 1987
1536register_command "perl-reload" => sub { 1988register_command "reload" => sub {
1537 my ($who, $arg) = @_; 1989 my ($who, $arg) = @_;
1538 1990
1539 if ($who->flag (FLAG_WIZ)) { 1991 if ($who->flag (FLAG_WIZ)) {
1540 $who->message ("start of reload."); 1992 $who->message ("start of reload.");
1541 perl_reload; 1993 reload;
1542 $who->message ("end of reload."); 1994 $who->message ("end of reload.");
1543 } 1995 }
1544}; 1996};
1545 1997
1546unshift @INC, $LIBDIR; 1998unshift @INC, $LIBDIR;

Diff Legend

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