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.110 by root, Mon Jan 1 11:21:55 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
… …
198 my ($job) = @_; 200 my ($job) = @_;
199 201
200 my $busy = 1; 202 my $busy = 1;
201 my @res; 203 my @res;
202 204
203 # TODO: use suspend/resume instead
204 local $FREEZE = 1;
205
206 my $coro = Coro::async { 205 my $coro = Coro::async {
207 @res = eval { $job->() }; 206 @res = eval { $job->() };
208 warn $@ if $@; 207 warn $@ if $@;
209 undef $busy; 208 undef $busy;
210 }; 209 };
211 210
212 if ($Coro::current == $Coro::main) { 211 if ($Coro::current == $Coro::main) {
212 # TODO: use suspend/resume instead
213 local $FREEZE = 1;
213 $coro->prio (Coro::PRIO_MAX); 214 $coro->prio (Coro::PRIO_MAX);
214 while ($busy) { 215 while ($busy) {
215 Coro::cede_notself; 216 Coro::cede_notself;
216 Event::one_event unless Coro::nready; 217 Event::one_event unless Coro::nready;
217 } 218 }
… …
277 278
278package cf::path; 279package cf::path;
279 280
280sub new { 281sub new {
281 my ($class, $path, $base) = @_; 282 my ($class, $path, $base) = @_;
283
284 $path = $path->as_string if ref $path;
282 285
283 my $self = bless { }, $class; 286 my $self = bless { }, $class;
284 287
285 if ($path =~ s{^\?random/}{}) { 288 if ($path =~ s{^\?random/}{}) {
286 Coro::AIO::aio_load "$cf::RANDOM_MAPS/$path.meta", my $data; 289 Coro::AIO::aio_load "$cf::RANDOM_MAPS/$path.meta", my $data;
… …
1029 $self->send ("ext " . to_json \%msg); 1032 $self->send ("ext " . to_json \%msg);
1030} 1033}
1031 1034
1032=back 1035=back
1033 1036
1037
1038=head3 cf::map
1039
1040=over 4
1041
1042=cut
1043
1044package cf::map;
1045
1046use Fcntl;
1047use Coro::AIO;
1048
1049our $MAX_RESET = 7200;
1050our $DEFAULT_RESET = 3600;
1051$MAX_RESET = 10;#d#
1052$DEFAULT_RESET = 10;#d#
1053
1054sub generate_random_map {
1055 my ($path, $rmp) = @_;
1056
1057 # mit "rum" bekleckern, nicht
1058 cf::map::_create_random_map
1059 $path,
1060 $rmp->{wallstyle}, $rmp->{wall_name}, $rmp->{floorstyle}, $rmp->{monsterstyle},
1061 $rmp->{treasurestyle}, $rmp->{layoutstyle}, $rmp->{doorstyle}, $rmp->{decorstyle},
1062 $rmp->{origin_map}, $rmp->{final_map}, $rmp->{exitstyle}, $rmp->{this_map},
1063 $rmp->{exit_on_final_map},
1064 $rmp->{xsize}, $rmp->{ysize},
1065 $rmp->{expand2x}, $rmp->{layoutoptions1}, $rmp->{layoutoptions2}, $rmp->{layoutoptions3},
1066 $rmp->{symmetry}, $rmp->{difficulty}, $rmp->{difficulty_given}, $rmp->{difficulty_increase},
1067 $rmp->{dungeon_level}, $rmp->{dungeon_depth}, $rmp->{decoroptions}, $rmp->{orientation},
1068 $rmp->{origin_y}, $rmp->{origin_x}, $rmp->{random_seed}, $rmp->{total_map_hp},
1069 $rmp->{map_layout_style}, $rmp->{treasureoptions}, $rmp->{symmetry_used},
1070 (cf::region::find $rmp->{region})
1071}
1072
1073# and all this just because we cannot iterate over
1074# all maps in C++...
1075sub change_all_map_light {
1076 my ($change) = @_;
1077
1078 $_->change_map_light ($change) for values %cf::MAP;
1079}
1080
1081sub try_load_header($) {
1082 my ($path) = @_;
1083
1084 utf8::encode $path;
1085 aio_open $path, O_RDONLY, 0
1086 or return;
1087
1088 my $map = cf::map::new
1089 or return;
1090
1091 $map->load_header ($path)
1092 or return;
1093
1094 $map->{load_path} = $path;
1095 use Data::Dumper; warn Dumper $map;#d#
1096
1097 $map
1098}
1099
1100sub find_map {
1101 my ($path, $origin) = @_;
1102
1103 #warn "find_map<$path,$origin>\n";#d#
1104
1105 $path = ref $path ? $path : new cf::path $path, $origin && $origin->path;
1106 my $key = $path->as_string;
1107
1108 $cf::MAP{$key} || do {
1109 # do it the slow way
1110 my $map = try_load_header $path->save_path;
1111
1112 if ($map) {
1113 # safety
1114 $map->{instantiate_time} = $cf::RUNTIME
1115 if $map->{instantiate_time} > $cf::RUNTIME;
1116 } else {
1117 if (my $rmp = $path->random_map_params) {
1118 $map = generate_random_map $key, $rmp;
1119 } else {
1120 $map = try_load_header $path->load_path;
1121 }
1122
1123 $map or return;
1124
1125 $map->{instantiate_time} = $cf::RUNTIME;
1126 $map->instantiate;
1127
1128 # per-player maps become, after loading, normal maps
1129 $map->per_player (0) if $path->{user_rel};
1130 }
1131
1132 $map->path ($key);
1133 $map->{path} = $path;
1134 $map->last_access ($cf::RUNTIME);
1135
1136 $map->reset if $map->should_reset;
1137
1138 $cf::MAP{$key} = $map
1139 }
1140}
1141
1142sub load {
1143 my ($self) = @_;
1144
1145 return if $self->in_memory != cf::MAP_SWAPPED;
1146
1147 $self->in_memory (cf::MAP_LOADING);
1148
1149 my $path = $self->{path};
1150
1151 $self->alloc;
1152 $self->load_objects ($self->{load_path}, 1)
1153 or return;
1154
1155 if (my $uniq = $path->uniq_path) {
1156 utf8::encode $uniq;
1157 if (aio_open $uniq, O_RDONLY, 0) {
1158 $self->clear_unique_items;
1159 $self->load_objects ($uniq, 0);
1160 }
1161 }
1162
1163 # now do the right thing for maps
1164 $self->link_multipart_objects;
1165
1166 if ($self->{path}->is_style_map) {
1167 $self->{deny_save} = 1;
1168 $self->{deny_reset} = 1;
1169 } else {
1170 $self->fix_auto_apply;
1171 $self->decay_objects;
1172 $self->update_buttons;
1173 $self->set_darkness_map;
1174 $self->difficulty ($self->estimate_difficulty)
1175 unless $self->difficulty;
1176 $self->activate;
1177 }
1178
1179 $self->in_memory (cf::MAP_IN_MEMORY);
1180}
1181
1182sub load_map_sync {
1183 my ($path, $origin) = @_;
1184
1185 #warn "load_map_sync<$path, $origin>\n";#d#
1186
1187 cf::sync_job {
1188 my $map = cf::map::find_map $path, $origin
1189 or return;
1190 $map->load;
1191 $map
1192 }
1193}
1194
1195sub save {
1196 my ($self) = @_;
1197
1198 my $save = $self->{path}->save_path; utf8::encode $save;
1199 my $uniq = $self->{path}->uniq_path; utf8::encode $uniq;
1200
1201 $self->{last_save} = $cf::RUNTIME;
1202
1203 return unless $self->dirty;
1204
1205 $self->{load_path} = $save;
1206
1207 return if $self->{deny_save};
1208
1209 warn "saving map ", $self->path;
1210
1211 if ($uniq) {
1212 $self->save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS);
1213 $self->save_objects ($uniq, cf::IO_UNIQUES);
1214 } else {
1215 $self->save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS | cf::IO_UNIQUES);
1216 }
1217}
1218
1219sub swap_out {
1220 my ($self) = @_;
1221
1222 return if $self->players;
1223 return if $self->in_memory != cf::MAP_IN_MEMORY;
1224 return if $self->{deny_save};
1225
1226 $self->save;
1227 $self->clear;
1228 $self->in_memory (cf::MAP_SWAPPED);
1229}
1230
1231sub should_reset {
1232 my ($map) = @_;
1233
1234 # TODO: safety, remove and allow resettable per-player maps
1235 return if $map->{path}{user_rel};#d#
1236 return if $map->{deny_reset};
1237 #return unless $map->reset_timeout;
1238
1239 my $time = $map->fixed_resettime ? $map->{instantiate_time} : $map->last_access;
1240
1241 $time + ($map->reset_timeout || $DEFAULT_RESET) < $cf::RUNTIME
1242}
1243
1244sub reset {
1245 my ($self) = @_;
1246
1247 return if $self->players;
1248 return if $self->{path}{user_rel};#d#
1249
1250 warn "resetting map ", $self->path;#d#
1251
1252 utf8::encode (my $save = $self->{path}->save_path);
1253 aioreq_pri 3; IO::AIO::aio_unlink $save;
1254 aioreq_pri 3; IO::AIO::aio_unlink "$save.pst";
1255
1256 $_->clear_links_to ($self) for values %cf::MAP;
1257
1258 $self->clear;
1259 $self->in_memory (cf::MAP_SWAPPED);
1260 utf8::encode ($self->{load_path} = $self->{path}->load_path);
1261}
1262
1263sub customise_for {
1264 my ($map, $ob) = @_;
1265
1266 if ($map->per_player) {
1267 return cf::map::find_map "~" . $ob->name . "/" . $map->{path}{path};
1268 }
1269
1270 $map
1271}
1272
1273sub emergency_save {
1274 local $cf::FREEZE = 1;
1275
1276 warn "enter emergency map save\n";
1277
1278 cf::sync_job {
1279 warn "begin emergency map save\n";
1280 $_->save for values %cf::MAP;
1281 };
1282
1283 warn "end emergency map save\n";
1284}
1285
1286package cf;
1287
1288=back
1289
1290
1034=head3 cf::object::player 1291=head3 cf::object::player
1035 1292
1036=over 4 1293=over 4
1037 1294
1038=item $player_object->reply ($npc, $msg[, $flags]) 1295=item $player_object->reply ($npc, $msg[, $flags])
… …
1071 1328
1072 $self->flag (cf::FLAG_WIZ) || 1329 $self->flag (cf::FLAG_WIZ) ||
1073 (ref $cf::CFG{"may_$access"} 1330 (ref $cf::CFG{"may_$access"}
1074 ? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}} 1331 ? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}
1075 : $cf::CFG{"may_$access"}) 1332 : $cf::CFG{"may_$access"})
1333}
1334
1335sub cf::object::player::enter_link {
1336 my ($self) = @_;
1337
1338 return if $self->map == $LINK_MAP;
1339
1340 $self->{_link_pos} = [$self->map->{path}, $self->x, $self->y]
1341 if $self->map;
1342
1343 $self->enter_map ($LINK_MAP, 20, 20);
1344 $self->deactivate_recursive;
1345}
1346
1347sub cf::object::player::leave_link {
1348 my ($self, $map, $x, $y) = @_;
1349
1350 my $link_pos = delete $self->{_link_pos};
1351
1352 unless ($map) {
1353 $self->message ("The exit is closed", cf::NDI_UNIQUE | cf::NDI_RED);
1354
1355 # restore original map position
1356 ($map, $x, $y) = @{ $link_pos || [] };
1357 $map = cf::map::find_map $map;
1358
1359 unless ($map) {
1360 ($map, $x, $y) = @$EMERGENCY_POSITION;
1361 $map = cf::map::find_map $map
1362 or die "FATAL: cannot load emergency map\n";
1363 }
1364 }
1365
1366 ($x, $y) = (-1, -1)
1367 unless (defined $x) && (defined $y);
1368
1369 # use -1 or undef as default coordinates, not 0, 0
1370 ($x, $y) = ($map->enter_x, $map->enter_y)
1371 if $x <=0 && $y <= 0;
1372
1373 $map->load;
1374
1375 $self->activate_recursive;
1376 $self->enter_map ($map, $x, $y);
1377}
1378
1379=item $player_object->goto_map ($map, $x, $y)
1380
1381=cut
1382
1383sub cf::object::player::goto_map {
1384 my ($self, $path, $x, $y) = @_;
1385
1386 $self->enter_link;
1387
1388 (Coro::async {
1389 $path = new cf::path $path;
1390
1391 my $map = cf::map::find_map $path->as_string;
1392 $map = $map->customise_for ($self) if $map;
1393
1394 warn "entering ", $map->path, " at ($x, $y)\n"
1395 if $map;
1396
1397 $self->leave_link ($map, $x, $y);
1398 })->prio (1);
1399}
1400
1401=item $player_object->enter_exit ($exit_object)
1402
1403=cut
1404
1405sub parse_random_map_params {
1406 my ($spec) = @_;
1407
1408 my $rmp = { # defaults
1409 xsize => 10,
1410 ysize => 10,
1411 };
1412
1413 for (split /\n/, $spec) {
1414 my ($k, $v) = split /\s+/, $_, 2;
1415
1416 $rmp->{lc $k} = $v if (length $k) && (length $v);
1417 }
1418
1419 $rmp
1420}
1421
1422sub prepare_random_map {
1423 my ($exit) = @_;
1424
1425 # all this does is basically replace the /! path by
1426 # a new random map path (?random/...) with a seed
1427 # that depends on the exit object
1428
1429 my $rmp = parse_random_map_params $exit->msg;
1430
1431 if ($exit->map) {
1432 $rmp->{region} = $exit->map->region_name;
1433 $rmp->{origin_map} = $exit->map->path;
1434 $rmp->{origin_x} = $exit->x;
1435 $rmp->{origin_y} = $exit->y;
1436 }
1437
1438 $rmp->{random_seed} ||= $exit->random_seed;
1439
1440 my $data = cf::to_json $rmp;
1441 my $md5 = Digest::MD5::md5_hex $data;
1442
1443 if (my $fh = aio_open "$cf::RANDOM_MAPS/$md5.meta", O_WRONLY | O_CREAT, 0666) {
1444 aio_write $fh, 0, (length $data), $data, 0;
1445
1446 $exit->slaying ("?random/$md5");
1447 $exit->msg (undef);
1448 }
1449}
1450
1451sub cf::object::player::enter_exit {
1452 my ($self, $exit) = @_;
1453
1454 return unless $self->type == cf::PLAYER;
1455
1456 $self->enter_link;
1457
1458 (Coro::async {
1459 unless (eval {
1460
1461 prepare_random_map $exit
1462 if $exit->slaying eq "/!";
1463
1464 my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;
1465 $self->goto_map ($path, $exit->stats->hp, $exit->stats->sp);
1466
1467 1;
1468 }) {
1469 $self->message ("Something went wrong deep within the crossfire server. "
1470 . "I'll try to bring you back to the map you were before. "
1471 . "Please report this to the dungeon master",
1472 cf::NDI_UNIQUE | cf::NDI_RED);
1473
1474 warn "ERROR in enter_exit: $@";
1475 $self->leave_link;
1476 }
1477 })->prio (1);
1076} 1478}
1077 1479
1078=head3 cf::client 1480=head3 cf::client
1079 1481
1080=over 4 1482=over 4
… …
1527 $LINK_MAP->height (41); 1929 $LINK_MAP->height (41);
1528 $LINK_MAP->alloc; 1930 $LINK_MAP->alloc;
1529 $LINK_MAP->path ("{link}"); 1931 $LINK_MAP->path ("{link}");
1530 $LINK_MAP->{path} = bless { path => "{link}" }, "cf::path"; 1932 $LINK_MAP->{path} = bless { path => "{link}" }, "cf::path";
1531 $LINK_MAP->in_memory (MAP_IN_MEMORY); 1933 $LINK_MAP->in_memory (MAP_IN_MEMORY);
1934
1935 # dirty hack because... archetypes are not yet loaded
1936 Event->timer (
1937 after => 2,
1938 cb => sub {
1939 $_[0]->w->cancel;
1940
1941 # provide some exits "home"
1942 my $exit = cf::object::new "exit";
1943
1944 $exit->slaying ($EMERGENCY_POSITION->[0]);
1945 $exit->stats->hp ($EMERGENCY_POSITION->[1]);
1946 $exit->stats->sp ($EMERGENCY_POSITION->[2]);
1947
1948 $LINK_MAP->insert ($exit->clone, 19, 19);
1949 $LINK_MAP->insert ($exit->clone, 19, 20);
1950 $LINK_MAP->insert ($exit->clone, 19, 21);
1951 $LINK_MAP->insert ($exit->clone, 20, 19);
1952 $LINK_MAP->insert ($exit->clone, 20, 21);
1953 $LINK_MAP->insert ($exit->clone, 21, 19);
1954 $LINK_MAP->insert ($exit->clone, 21, 20);
1955 $LINK_MAP->insert ($exit->clone, 21, 21);
1956
1957 $exit->destroy;
1958 });
1959
1960 $LINK_MAP->{deny_save} = 1;
1961 $LINK_MAP->{deny_reset} = 1;
1962
1963 $cf::MAP{$LINK_MAP->path} = $LINK_MAP;
1532} 1964}
1533 1965
1534register "<global>", __PACKAGE__; 1966register "<global>", __PACKAGE__;
1535 1967
1536register_command "perl-reload" => sub { 1968register_command "perl-reload" => sub {

Diff Legend

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