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.131 by root, Thu Jan 4 00:53:54 2007 UTC vs.
Revision 1.142 by root, Fri Jan 5 21:51:42 2007 UTC

… …
26use Event; $Event::Eval = 1; # no idea why this is required, but it is 26use Event; $Event::Eval = 1; # no idea why this is required, but it is
27 27
28# work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode? 28# work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode?
29$YAML::Syck::ImplicitUnicode = 1; 29$YAML::Syck::ImplicitUnicode = 1;
30 30
31$Coro::main->prio (2); # run main coroutine ("the server") with very high priority 31$Coro::main->prio (Coro::PRIO_MAX); # run main coroutine ("the server") with very high priority
32 32
33sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload 33sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload
34 34
35our %COMMAND = (); 35our %COMMAND = ();
36our %COMMAND_TIME = (); 36our %COMMAND_TIME = ();
… …
49our $UPTIME; $UPTIME ||= time; 49our $UPTIME; $UPTIME ||= time;
50our $RUNTIME; 50our $RUNTIME;
51 51
52our %MAP; # all maps 52our %MAP; # all maps
53our $LINK_MAP; # the special {link} map 53our $LINK_MAP; # the special {link} map
54our $FREEZE;
55our $RANDOM_MAPS = cf::localdir . "/random"; 54our $RANDOM_MAPS = cf::localdir . "/random";
56our %EXT_CORO; 55our %EXT_CORO;
57 56
58binmode STDOUT; 57binmode STDOUT;
59binmode STDERR; 58binmode STDERR;
… …
180sub to_json($) { 179sub to_json($) {
181 $JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs 180 $JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs
182 JSON::Syck::Dump $_[0] 181 JSON::Syck::Dump $_[0]
183} 182}
184 183
185=item my $guard = cf::guard { BLOCK }
186
187Run the given callback when the guard object gets destroyed (useful for
188coroutine cancellations).
189
190You can call C<< ->cancel >> on the guard object to stop the block from
191being executed.
192
193=cut
194
195sub guard(&) {
196 bless \(my $cb = $_[0]), cf::guard::;
197}
198
199sub cf::guard::cancel {
200 ${$_[0]} = sub { };
201}
202
203sub cf::guard::DESTROY {
204 ${$_[0]}->();
205}
206
207=item cf::lock_wait $string 184=item cf::lock_wait $string
208 185
209Wait until the given lock is available. See cf::lock_acquire. 186Wait until the given lock is available. See cf::lock_acquire.
210 187
211=item my $lock = cf::lock_acquire $string 188=item my $lock = cf::lock_acquire $string
212 189
213Wait until the given lock is available and then acquires it and returns 190Wait until the given lock is available and then acquires it and returns
214a guard object. If the guard object gets destroyed (goes out of scope, 191a Coro::guard object. If the guard object gets destroyed (goes out of scope,
215for example when the coroutine gets canceled), the lock is automatically 192for example when the coroutine gets canceled), the lock is automatically
216returned. 193returned.
217 194
218Lock names should begin with a unique identifier (for example, find_map 195Lock names should begin with a unique identifier (for example, cf::map::find
219uses map_find and load_map uses map_load). 196uses map_find and cf::map::load uses map_load).
220 197
221=cut 198=cut
222 199
223our %LOCK; 200our %LOCK;
224 201
… …
238 # wait, to be sure we are not locked 215 # wait, to be sure we are not locked
239 lock_wait $key; 216 lock_wait $key;
240 217
241 $LOCK{$key} = []; 218 $LOCK{$key} = [];
242 219
243 cf::guard { 220 Coro::guard {
244 # wake up all waiters, to be on the safe side 221 # wake up all waiters, to be on the safe side
245 $_->ready for @{ delete $LOCK{$key} }; 222 $_->ready for @{ delete $LOCK{$key} };
246 } 223 }
247} 224}
248 225
226sub freeze_mainloop {
227 return unless $TICK_WATCHER->is_active;
228
229 my $guard = Coro::guard { $TICK_WATCHER->start };
230 $TICK_WATCHER->stop;
231 $guard
232}
233
249=item cf::async { BLOCK } 234=item cf::async { BLOCK }
250 235
251Like C<Coro::async>, but runs the given BLOCK in an eval and only logs the 236Currently the same as Coro::async_pool, meaning you cannot use
252error instead of exiting the server in case of a problem. 237C<on_destroy>, C<join> or other gimmicks on these coroutines. The only
238thing you are allowed to do is call C<prio> on it.
253 239
254=cut 240=cut
255 241
256sub async(&) { 242BEGIN { *async = \&Coro::async_pool }
257 my ($cb) = @_;
258
259 Coro::async {
260 eval { $cb->() };
261 warn $@ if $@;
262 }
263}
264 243
265=item cf::sync_job { BLOCK } 244=item cf::sync_job { BLOCK }
266 245
267The design of crossfire+ requires that the main coro ($Coro::main) is 246The design of crossfire+ requires that the main coro ($Coro::main) is
268always able to handle events or runnable, as crossfire+ is only partly 247always able to handle events or runnable, as crossfire+ is only partly
… …
282 # this is the main coro, too bad, we have to block 261 # this is the main coro, too bad, we have to block
283 # till the operation succeeds, freezing the server :/ 262 # till the operation succeeds, freezing the server :/
284 263
285 # TODO: use suspend/resume instead 264 # TODO: use suspend/resume instead
286 # (but this is cancel-safe) 265 # (but this is cancel-safe)
287 local $FREEZE = 1; 266 my $freeze_guard = freeze_mainloop;
288 267
289 my $busy = 1; 268 my $busy = 1;
290 my @res; 269 my @res;
291 270
292 (Coro::async { 271 (async {
293 @res = eval { $job->() }; 272 @res = eval { $job->() };
294 warn $@ if $@; 273 warn $@ if $@;
295 undef $busy; 274 undef $busy;
296 })->prio (Coro::PRIO_MAX); 275 })->prio (Coro::PRIO_MAX);
297 276
298 while ($busy) { 277 while ($busy) {
299 Coro::cede_notself; 278 Coro::cede or Event::one_event;
300 Event::one_event unless Coro::nready;
301 } 279 }
302 280
303 wantarray ? @res : $res[0] 281 wantarray ? @res : $res[0]
304 } else { 282 } else {
305 # we are in another coroutine, how wonderful, everything just works 283 # we are in another coroutine, how wonderful, everything just works
306 284
307 $job->() 285 $job->()
308 } 286 }
309} 287}
310 288
311=item $coro = cf::coro { BLOCK } 289=item $coro = cf::async_ext { BLOCK }
312 290
313Creates and returns a new coro. This coro is automcatially being canceled 291Like async, but this coro is automcatially being canceled when the
314when the extension calling this is being unloaded. 292extension calling this is being unloaded.
315 293
316=cut 294=cut
317 295
318sub coro(&) { 296sub async_ext(&) {
319 my $cb = shift; 297 my $cb = shift;
320 298
321 my $coro = &cf::async ($cb); 299 my $coro = &Coro::async ($cb);
322 300
323 $coro->on_destroy (sub { 301 $coro->on_destroy (sub {
324 delete $EXT_CORO{$coro+0}; 302 delete $EXT_CORO{$coro+0};
325 }); 303 });
326 $EXT_CORO{$coro+0} = $coro; 304 $EXT_CORO{$coro+0} = $coro;
… …
1136package cf::map; 1114package cf::map;
1137 1115
1138use Fcntl; 1116use Fcntl;
1139use Coro::AIO; 1117use Coro::AIO;
1140 1118
1141our $MAX_RESET = 7200; 1119our $MAX_RESET = 3600;
1142our $DEFAULT_RESET = 3600; 1120our $DEFAULT_RESET = 3000;
1143 1121
1144sub generate_random_map { 1122sub generate_random_map {
1145 my ($path, $rmp) = @_; 1123 my ($path, $rmp) = @_;
1146 1124
1147 # mit "rum" bekleckern, nicht 1125 # mit "rum" bekleckern, nicht
… …
1177 or return; 1155 or return;
1178 1156
1179 my $map = cf::map::new 1157 my $map = cf::map::new
1180 or return; 1158 or return;
1181 1159
1160 # for better error messages only, will be overwritten
1161 $map->path ($path);
1162
1182 $map->load_header ($path) 1163 $map->load_header ($path)
1183 or return; 1164 or return;
1184 1165
1185 $map->{load_path} = $path; 1166 $map->{load_path} = $path;
1186 1167
1187 $map 1168 $map
1188} 1169}
1189 1170
1190sub find_map; 1171sub find;
1191sub find_map { 1172sub find {
1192 my ($path, $origin) = @_; 1173 my ($path, $origin) = @_;
1193 1174
1194 #warn "find_map<$path,$origin>\n";#d# 1175 #warn "find<$path,$origin>\n";#d#
1195 1176
1196 $path = new cf::path $path, $origin && $origin->path; 1177 $path = new cf::path $path, $origin && $origin->path;
1197 my $key = $path->as_string; 1178 my $key = $path->as_string;
1198 1179
1199 cf::lock_wait "map_find:$key"; 1180 cf::lock_wait "map_find:$key";
… …
1202 my $guard = cf::lock_acquire "map_find:$key"; 1183 my $guard = cf::lock_acquire "map_find:$key";
1203 1184
1204 # do it the slow way 1185 # do it the slow way
1205 my $map = try_load_header $path->save_path; 1186 my $map = try_load_header $path->save_path;
1206 1187
1188 Coro::cede;
1189
1207 if ($map) { 1190 if ($map) {
1191 $map->last_access ((delete $map->{last_access})
1192 || $cf::RUNTIME); #d#
1208 # safety 1193 # safety
1209 $map->{instantiate_time} = $cf::RUNTIME 1194 $map->{instantiate_time} = $cf::RUNTIME
1210 if $map->{instantiate_time} > $cf::RUNTIME; 1195 if $map->{instantiate_time} > $cf::RUNTIME;
1211 } else { 1196 } else {
1212 if (my $rmp = $path->random_map_params) { 1197 if (my $rmp = $path->random_map_params) {
… …
1217 1202
1218 $map or return; 1203 $map or return;
1219 1204
1220 $map->{load_original} = 1; 1205 $map->{load_original} = 1;
1221 $map->{instantiate_time} = $cf::RUNTIME; 1206 $map->{instantiate_time} = $cf::RUNTIME;
1207 $map->last_access ($cf::RUNTIME);
1222 $map->instantiate; 1208 $map->instantiate;
1223 1209
1224 # per-player maps become, after loading, normal maps 1210 # per-player maps become, after loading, normal maps
1225 $map->per_player (0) if $path->{user_rel}; 1211 $map->per_player (0) if $path->{user_rel};
1226 } 1212 }
1227 1213
1228 $map->path ($key); 1214 $map->path ($key);
1229 $map->{path} = $path; 1215 $map->{path} = $path;
1230 $map->{last_save} = $cf::RUNTIME; 1216 $map->{last_save} = $cf::RUNTIME;
1231 $map->last_access ($cf::RUNTIME); 1217
1218 Coro::cede;
1232 1219
1233 if ($map->should_reset) { 1220 if ($map->should_reset) {
1234 $map->reset; 1221 $map->reset;
1235 undef $guard; 1222 undef $guard;
1236 $map = find_map $path 1223 $map = find $path
1237 or return; 1224 or return;
1238 } 1225 }
1239 1226
1240 $cf::MAP{$key} = $map 1227 $cf::MAP{$key} = $map
1241 } 1228 }
… …
1263 if (aio_open $uniq, O_RDONLY, 0) { 1250 if (aio_open $uniq, O_RDONLY, 0) {
1264 $self->clear_unique_items; 1251 $self->clear_unique_items;
1265 $self->load_objects ($uniq, 0); 1252 $self->load_objects ($uniq, 0);
1266 } 1253 }
1267 } 1254 }
1255
1256 Coro::cede;
1268 1257
1269 # now do the right thing for maps 1258 # now do the right thing for maps
1270 $self->link_multipart_objects; 1259 $self->link_multipart_objects;
1271 1260
1272 if ($self->{path}->is_style_map) { 1261 if ($self->{path}->is_style_map) {
… …
1280 $self->difficulty ($self->estimate_difficulty) 1269 $self->difficulty ($self->estimate_difficulty)
1281 unless $self->difficulty; 1270 unless $self->difficulty;
1282 $self->activate; 1271 $self->activate;
1283 } 1272 }
1284 1273
1274 Coro::cede;
1275
1285 $self->in_memory (cf::MAP_IN_MEMORY); 1276 $self->in_memory (cf::MAP_IN_MEMORY);
1286} 1277}
1287 1278
1288sub load_map_sync { 1279sub find_sync {
1289 my ($path, $origin) = @_; 1280 my ($path, $origin) = @_;
1290 1281
1291 #warn "load_map_sync<$path, $origin>\n";#d# 1282 cf::sync_job { cf::map::find $path, $origin }
1283}
1292 1284
1293 cf::sync_job { 1285sub do_load_sync {
1294 my $map = cf::map::find_map $path, $origin 1286 my ($map) = @_;
1295 or return; 1287
1296 $map->load; 1288 cf::sync_job { $map->load };
1297 $map
1298 }
1299} 1289}
1300 1290
1301sub save { 1291sub save {
1302 my ($self) = @_; 1292 my ($self) = @_;
1303 1293
1294 my $lock = cf::lock_acquire "map_data:" . $self->path;
1295
1304 $self->{last_save} = $cf::RUNTIME; 1296 $self->{last_save} = $cf::RUNTIME;
1305 1297
1306 return unless $self->dirty; 1298 return unless $self->dirty;
1307 1299
1308 my $save = $self->{path}->save_path; utf8::encode $save; 1300 my $save = $self->{path}->save_path; utf8::encode $save;
1309 my $uniq = $self->{path}->uniq_path; utf8::encode $uniq; 1301 my $uniq = $self->{path}->uniq_path; utf8::encode $uniq;
1310 1302
1311 $self->{load_path} = $save; 1303 $self->{load_path} = $save;
1312 1304
1313 return if $self->{deny_save}; 1305 return if $self->{deny_save};
1306
1307 local $self->{last_access} = $self->last_access;#d#
1314 1308
1315 if ($uniq) { 1309 if ($uniq) {
1316 $self->save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS); 1310 $self->save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS);
1317 $self->save_objects ($uniq, cf::IO_UNIQUES); 1311 $self->save_objects ($uniq, cf::IO_UNIQUES);
1318 } else { 1312 } else {
… …
1324 my ($self) = @_; 1318 my ($self) = @_;
1325 1319
1326 # save first because save cedes 1320 # save first because save cedes
1327 $self->save; 1321 $self->save;
1328 1322
1323 my $lock = cf::lock_acquire "map_data:" . $self->path;
1324
1329 return if $self->players; 1325 return if $self->players;
1330 return if $self->in_memory != cf::MAP_IN_MEMORY; 1326 return if $self->in_memory != cf::MAP_IN_MEMORY;
1331 return if $self->{deny_save}; 1327 return if $self->{deny_save};
1332 1328
1333 $self->clear; 1329 $self->clear;
… …
1375} 1371}
1376 1372
1377sub reset { 1373sub reset {
1378 my ($self) = @_; 1374 my ($self) = @_;
1379 1375
1376 my $lock = cf::lock_acquire "map_data:" . $self->path;
1377
1380 return if $self->players; 1378 return if $self->players;
1381 return if $self->{path}{user_rel};#d# 1379 return if $self->{path}{user_rel};#d#
1382 1380
1383 warn "resetting map ", $self->path;#d# 1381 warn "resetting map ", $self->path;#d#
1384 1382
… …
1403 1401
1404sub customise_for { 1402sub customise_for {
1405 my ($map, $ob) = @_; 1403 my ($map, $ob) = @_;
1406 1404
1407 if ($map->per_player) { 1405 if ($map->per_player) {
1408 return cf::map::find_map "~" . $ob->name . "/" . $map->{path}{path}; 1406 return cf::map::find "~" . $ob->name . "/" . $map->{path}{path};
1409 } 1407 }
1410 1408
1411 $map 1409 $map
1412} 1410}
1413 1411
1414sub emergency_save { 1412sub emergency_save {
1415 local $cf::FREEZE = 1; 1413 my $freeze_guard = cf::freeze_mainloop;
1416 1414
1417 warn "enter emergency map save\n"; 1415 warn "enter emergency map save\n";
1418 1416
1419 cf::sync_job { 1417 cf::sync_job {
1420 warn "begin emergency map save\n"; 1418 warn "begin emergency map save\n";
… …
1510 my $link_pos = delete $self->{_link_pos}; 1508 my $link_pos = delete $self->{_link_pos};
1511 1509
1512 unless ($map) { 1510 unless ($map) {
1513 # restore original map position 1511 # restore original map position
1514 ($map, $x, $y) = @{ $link_pos || [] }; 1512 ($map, $x, $y) = @{ $link_pos || [] };
1515 $map = cf::map::find_map $map; 1513 $map = cf::map::find $map;
1516 1514
1517 unless ($map) { 1515 unless ($map) {
1518 ($map, $x, $y) = @$EMERGENCY_POSITION; 1516 ($map, $x, $y) = @$EMERGENCY_POSITION;
1519 $map = cf::map::find_map $map 1517 $map = cf::map::find $map
1520 or die "FATAL: cannot load emergency map\n"; 1518 or die "FATAL: cannot load emergency map\n";
1521 } 1519 }
1522 } 1520 }
1523 1521
1524 ($x, $y) = (-1, -1) 1522 ($x, $y) = (-1, -1)
… …
1549 my ($pl) = @_; 1547 my ($pl) = @_;
1550 1548
1551 # try to abort aborted map switching on player login :) 1549 # try to abort aborted map switching on player login :)
1552 # should happen only on crashes 1550 # should happen only on crashes
1553 if ($pl->ob->{_link_pos}) { 1551 if ($pl->ob->{_link_pos}) {
1552
1554 $pl->ob->enter_link; 1553 $pl->ob->enter_link;
1555 cf::async { 1554 (async {
1556 # we need this sleep as the login has a concurrent enter_exit running 1555 # we need this sleep as the login has a concurrent enter_exit running
1557 # and this sleep increases chances of the player not ending up in scorn 1556 # and this sleep increases chances of the player not ending up in scorn
1557 $pl->ob->reply (undef,
1558 "There was an internal problem at your last logout, "
1559 . "the server will try to bring you to your intended destination in a second.",
1560 cf::NDI_RED);
1558 Coro::Timer::sleep 1; 1561 Coro::Timer::sleep 1;
1559 $pl->ob->leave_link; 1562 $pl->ob->leave_link;
1560 }; 1563 })->prio (2);
1561 } 1564 }
1562 }, 1565 },
1563); 1566);
1564 1567
1565=item $player_object->goto_map ($path, $x, $y) 1568=item $player_object->goto ($path, $x, $y)
1566 1569
1567=cut 1570=cut
1568 1571
1569sub cf::object::player::goto_map { 1572sub cf::object::player::goto {
1570 my ($self, $path, $x, $y) = @_; 1573 my ($self, $path, $x, $y) = @_;
1571 1574
1572 $self->enter_link; 1575 $self->enter_link;
1573 1576
1574 (cf::async { 1577 (async {
1575 $path = new cf::path $path; 1578 $path = new cf::path $path;
1576 1579
1577 my $map = cf::map::find_map $path->as_string; 1580 my $map = cf::map::find $path->as_string;
1578 $map = $map->customise_for ($self) if $map; 1581 $map = $map->customise_for ($self) if $map;
1579 1582
1580# warn "entering ", $map->path, " at ($x, $y)\n" 1583# warn "entering ", $map->path, " at ($x, $y)\n"
1581# if $map; 1584# if $map;
1582 1585
… …
1641 1644
1642 return unless $self->type == cf::PLAYER; 1645 return unless $self->type == cf::PLAYER;
1643 1646
1644 $self->enter_link; 1647 $self->enter_link;
1645 1648
1646 (cf::async { 1649 (async {
1650 $self->deactivate_recursive; # just to be sure
1647 unless (eval { 1651 unless (eval {
1648 prepare_random_map $exit 1652 prepare_random_map $exit
1649 if $exit->slaying eq "/!"; 1653 if $exit->slaying eq "/!";
1650 1654
1651 my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path; 1655 my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;
1652 $self->goto_map ($path, $exit->stats->hp, $exit->stats->sp); 1656 $self->goto ($path, $exit->stats->hp, $exit->stats->sp);
1653 1657
1654 1; 1658 1;
1655 }) { 1659 }) {
1656 $self->message ("Something went wrong deep within the crossfire server. " 1660 $self->message ("Something went wrong deep within the crossfire server. "
1657 . "I'll try to bring you back to the map you were before. " 1661 . "I'll try to bring you back to the map you were before. "
… …
1731 } 1735 }
1732 } 1736 }
1733 }, 1737 },
1734); 1738);
1735 1739
1736=item $client->coro (\&cb) 1740=item $client->async (\&cb)
1737 1741
1738Create a new coroutine, running the specified callback. The coroutine will 1742Create a new coroutine, running the specified callback. The coroutine will
1739be automatically cancelled when the client gets destroyed (e.g. on logout, 1743be automatically cancelled when the client gets destroyed (e.g. on logout,
1740or loss of connection). 1744or loss of connection).
1741 1745
1742=cut 1746=cut
1743 1747
1744sub cf::client::coro { 1748sub cf::client::async {
1745 my ($self, $cb) = @_; 1749 my ($self, $cb) = @_;
1746 1750
1747 my $coro = &cf::async ($cb); 1751 my $coro = &Coro::async ($cb);
1748 1752
1749 $coro->on_destroy (sub { 1753 $coro->on_destroy (sub {
1750 delete $self->{_coro}{$coro+0}; 1754 delete $self->{_coro}{$coro+0};
1751 }); 1755 });
1752 1756
… …
1990 local $/; 1994 local $/;
1991 *CFG = YAML::Syck::Load <$fh>; 1995 *CFG = YAML::Syck::Load <$fh>;
1992 1996
1993 $EMERGENCY_POSITION = $CFG{emergency_position} || ["/world/world_105_115", 5, 37]; 1997 $EMERGENCY_POSITION = $CFG{emergency_position} || ["/world/world_105_115", 5, 37];
1994 1998
1999 $cf::map::MAX_RESET = $CFG{map_max_reset} if exists $CFG{map_max_reset};
2000 $cf::map::DEFAULT_RESET = $CFG{map_default_reset} if exists $CFG{map_default_reset};
2001
1995 if (exists $CFG{mlockall}) { 2002 if (exists $CFG{mlockall}) {
1996 eval { 2003 eval {
1997 $CFG{mlockall} ? &mlockall : &munlockall 2004 $CFG{mlockall} ? &mlockall : &munlockall
1998 and die "WARNING: m(un)lockall failed: $!\n"; 2005 and die "WARNING: m(un)lockall failed: $!\n";
1999 }; 2006 };
… …
2003 2010
2004sub main { 2011sub main {
2005 # we must not ever block the main coroutine 2012 # we must not ever block the main coroutine
2006 local $Coro::idle = sub { 2013 local $Coro::idle = sub {
2007 Carp::cluck "FATAL: Coro::idle was called, major BUG, use cf::sync_job!\n";#d# 2014 Carp::cluck "FATAL: Coro::idle was called, major BUG, use cf::sync_job!\n";#d#
2008 (Coro::unblock_sub {
2009 Event::one_event; 2015 async { Event::one_event };
2010 })->();
2011 }; 2016 };
2012 2017
2013 cfg_load; 2018 cfg_load;
2014 db_load; 2019 db_load;
2015 load_extensions; 2020 load_extensions;
… …
2026 return; 2031 return;
2027 } 2032 }
2028 2033
2029 warn "reloading..."; 2034 warn "reloading...";
2030 2035
2031 local $FREEZE = 1; 2036 my $guard = freeze_mainloop;
2032 cf::emergency_save; 2037 cf::emergency_save;
2033 2038
2034 eval { 2039 eval {
2035 # if anything goes wrong in here, we should simply crash as we already saved 2040 # if anything goes wrong in here, we should simply crash as we already saved
2036 2041
… …
2123 $LINK_MAP->{path} = bless { path => "{link}" }, "cf::path"; 2128 $LINK_MAP->{path} = bless { path => "{link}" }, "cf::path";
2124 $LINK_MAP->in_memory (MAP_IN_MEMORY); 2129 $LINK_MAP->in_memory (MAP_IN_MEMORY);
2125 2130
2126 # dirty hack because... archetypes are not yet loaded 2131 # dirty hack because... archetypes are not yet loaded
2127 Event->timer ( 2132 Event->timer (
2128 after => 2, 2133 after => 10,
2129 cb => sub { 2134 cb => sub {
2130 $_[0]->w->cancel; 2135 $_[0]->w->cancel;
2131 2136
2132 # provide some exits "home" 2137 # provide some exits "home"
2133 my $exit = cf::object::new "exit"; 2138 my $exit = cf::object::new "exit";
… …
2172 reentrant => 0, 2177 reentrant => 0,
2173 prio => 0, 2178 prio => 0,
2174 at => $NEXT_TICK || $TICK, 2179 at => $NEXT_TICK || $TICK,
2175 data => WF_AUTOCANCEL, 2180 data => WF_AUTOCANCEL,
2176 cb => sub { 2181 cb => sub {
2177 unless ($FREEZE) {
2178 cf::server_tick; # one server iteration 2182 cf::server_tick; # one server iteration
2179 $RUNTIME += $TICK; 2183 $RUNTIME += $TICK;
2180 }
2181
2182 $NEXT_TICK += $TICK; 2184 $NEXT_TICK += $TICK;
2183 2185
2184 # if we are delayed by four ticks or more, skip them all 2186 # if we are delayed by four ticks or more, skip them all
2185 $NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4; 2187 $NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;
2186 2188

Diff Legend

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