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.140 by root, Fri Jan 5 20:04:02 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 unless (Coro::cede) {
300 Event::one_event unless Coro::nready; 279 Coro::nready ? Event::one_event 0 : Event::one_event;
280 Coro::cede_notself unless Coro::cede;
281 }
301 } 282 }
302 283
303 wantarray ? @res : $res[0] 284 wantarray ? @res : $res[0]
304 } else { 285 } else {
305 # we are in another coroutine, how wonderful, everything just works 286 # we are in another coroutine, how wonderful, everything just works
306 287
307 $job->() 288 $job->()
308 } 289 }
309} 290}
310 291
311=item $coro = cf::coro { BLOCK } 292=item $coro = cf::async_ext { BLOCK }
312 293
313Creates and returns a new coro. This coro is automcatially being canceled 294Like async, but this coro is automcatially being canceled when the
314when the extension calling this is being unloaded. 295extension calling this is being unloaded.
315 296
316=cut 297=cut
317 298
318sub coro(&) { 299sub async_ext(&) {
319 my $cb = shift; 300 my $cb = shift;
320 301
321 my $coro = &cf::async ($cb); 302 my $coro = &Coro::async ($cb);
322 303
323 $coro->on_destroy (sub { 304 $coro->on_destroy (sub {
324 delete $EXT_CORO{$coro+0}; 305 delete $EXT_CORO{$coro+0};
325 }); 306 });
326 $EXT_CORO{$coro+0} = $coro; 307 $EXT_CORO{$coro+0} = $coro;
… …
1136package cf::map; 1117package cf::map;
1137 1118
1138use Fcntl; 1119use Fcntl;
1139use Coro::AIO; 1120use Coro::AIO;
1140 1121
1141our $MAX_RESET = 7200; 1122our $MAX_RESET = 3600;
1142our $DEFAULT_RESET = 3600; 1123our $DEFAULT_RESET = 3000;
1143 1124
1144sub generate_random_map { 1125sub generate_random_map {
1145 my ($path, $rmp) = @_; 1126 my ($path, $rmp) = @_;
1146 1127
1147 # mit "rum" bekleckern, nicht 1128 # mit "rum" bekleckern, nicht
… …
1177 or return; 1158 or return;
1178 1159
1179 my $map = cf::map::new 1160 my $map = cf::map::new
1180 or return; 1161 or return;
1181 1162
1163 # for better error messages only, will be overwritten
1164 $map->path ($path);
1165
1182 $map->load_header ($path) 1166 $map->load_header ($path)
1183 or return; 1167 or return;
1184 1168
1185 $map->{load_path} = $path; 1169 $map->{load_path} = $path;
1186 1170
1187 $map 1171 $map
1188} 1172}
1189 1173
1190sub find_map; 1174sub find;
1191sub find_map { 1175sub find {
1192 my ($path, $origin) = @_; 1176 my ($path, $origin) = @_;
1193 1177
1194 #warn "find_map<$path,$origin>\n";#d# 1178 #warn "find<$path,$origin>\n";#d#
1195 1179
1196 $path = new cf::path $path, $origin && $origin->path; 1180 $path = new cf::path $path, $origin && $origin->path;
1197 my $key = $path->as_string; 1181 my $key = $path->as_string;
1198 1182
1199 cf::lock_wait "map_find:$key"; 1183 cf::lock_wait "map_find:$key";
… …
1202 my $guard = cf::lock_acquire "map_find:$key"; 1186 my $guard = cf::lock_acquire "map_find:$key";
1203 1187
1204 # do it the slow way 1188 # do it the slow way
1205 my $map = try_load_header $path->save_path; 1189 my $map = try_load_header $path->save_path;
1206 1190
1191 Coro::cede;
1192
1207 if ($map) { 1193 if ($map) {
1194 $map->last_access ((delete $map->{last_access})
1195 || $cf::RUNTIME); #d#
1208 # safety 1196 # safety
1209 $map->{instantiate_time} = $cf::RUNTIME 1197 $map->{instantiate_time} = $cf::RUNTIME
1210 if $map->{instantiate_time} > $cf::RUNTIME; 1198 if $map->{instantiate_time} > $cf::RUNTIME;
1211 } else { 1199 } else {
1212 if (my $rmp = $path->random_map_params) { 1200 if (my $rmp = $path->random_map_params) {
… …
1217 1205
1218 $map or return; 1206 $map or return;
1219 1207
1220 $map->{load_original} = 1; 1208 $map->{load_original} = 1;
1221 $map->{instantiate_time} = $cf::RUNTIME; 1209 $map->{instantiate_time} = $cf::RUNTIME;
1210 $map->last_access ($cf::RUNTIME);
1222 $map->instantiate; 1211 $map->instantiate;
1223 1212
1224 # per-player maps become, after loading, normal maps 1213 # per-player maps become, after loading, normal maps
1225 $map->per_player (0) if $path->{user_rel}; 1214 $map->per_player (0) if $path->{user_rel};
1226 } 1215 }
1227 1216
1228 $map->path ($key); 1217 $map->path ($key);
1229 $map->{path} = $path; 1218 $map->{path} = $path;
1230 $map->{last_save} = $cf::RUNTIME; 1219 $map->{last_save} = $cf::RUNTIME;
1231 $map->last_access ($cf::RUNTIME); 1220
1221 Coro::cede;
1232 1222
1233 if ($map->should_reset) { 1223 if ($map->should_reset) {
1234 $map->reset; 1224 $map->reset;
1235 undef $guard; 1225 undef $guard;
1236 $map = find_map $path 1226 $map = find $path
1237 or return; 1227 or return;
1238 } 1228 }
1239 1229
1240 $cf::MAP{$key} = $map 1230 $cf::MAP{$key} = $map
1241 } 1231 }
… …
1263 if (aio_open $uniq, O_RDONLY, 0) { 1253 if (aio_open $uniq, O_RDONLY, 0) {
1264 $self->clear_unique_items; 1254 $self->clear_unique_items;
1265 $self->load_objects ($uniq, 0); 1255 $self->load_objects ($uniq, 0);
1266 } 1256 }
1267 } 1257 }
1258
1259 Coro::cede;
1268 1260
1269 # now do the right thing for maps 1261 # now do the right thing for maps
1270 $self->link_multipart_objects; 1262 $self->link_multipart_objects;
1271 1263
1272 if ($self->{path}->is_style_map) { 1264 if ($self->{path}->is_style_map) {
… …
1280 $self->difficulty ($self->estimate_difficulty) 1272 $self->difficulty ($self->estimate_difficulty)
1281 unless $self->difficulty; 1273 unless $self->difficulty;
1282 $self->activate; 1274 $self->activate;
1283 } 1275 }
1284 1276
1277 Coro::cede;
1278
1285 $self->in_memory (cf::MAP_IN_MEMORY); 1279 $self->in_memory (cf::MAP_IN_MEMORY);
1286} 1280}
1287 1281
1288sub load_map_sync { 1282sub find_sync {
1289 my ($path, $origin) = @_; 1283 my ($path, $origin) = @_;
1290 1284
1291 #warn "load_map_sync<$path, $origin>\n";#d# 1285 cf::sync_job { cf::map::find $path, $origin }
1286}
1292 1287
1293 cf::sync_job { 1288sub do_load_sync {
1294 my $map = cf::map::find_map $path, $origin 1289 my ($map) = @_;
1295 or return; 1290
1296 $map->load; 1291 cf::sync_job { $map->load };
1297 $map
1298 }
1299} 1292}
1300 1293
1301sub save { 1294sub save {
1302 my ($self) = @_; 1295 my ($self) = @_;
1303 1296
1297 my $lock = cf::lock_acquire "map_data:" . $self->path;
1298
1304 $self->{last_save} = $cf::RUNTIME; 1299 $self->{last_save} = $cf::RUNTIME;
1305 1300
1306 return unless $self->dirty; 1301 return unless $self->dirty;
1307 1302
1308 my $save = $self->{path}->save_path; utf8::encode $save; 1303 my $save = $self->{path}->save_path; utf8::encode $save;
1309 my $uniq = $self->{path}->uniq_path; utf8::encode $uniq; 1304 my $uniq = $self->{path}->uniq_path; utf8::encode $uniq;
1310 1305
1311 $self->{load_path} = $save; 1306 $self->{load_path} = $save;
1312 1307
1313 return if $self->{deny_save}; 1308 return if $self->{deny_save};
1309
1310 local $self->{last_access} = $self->last_access;#d#
1314 1311
1315 if ($uniq) { 1312 if ($uniq) {
1316 $self->save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS); 1313 $self->save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS);
1317 $self->save_objects ($uniq, cf::IO_UNIQUES); 1314 $self->save_objects ($uniq, cf::IO_UNIQUES);
1318 } else { 1315 } else {
… …
1324 my ($self) = @_; 1321 my ($self) = @_;
1325 1322
1326 # save first because save cedes 1323 # save first because save cedes
1327 $self->save; 1324 $self->save;
1328 1325
1326 my $lock = cf::lock_acquire "map_data:" . $self->path;
1327
1329 return if $self->players; 1328 return if $self->players;
1330 return if $self->in_memory != cf::MAP_IN_MEMORY; 1329 return if $self->in_memory != cf::MAP_IN_MEMORY;
1331 return if $self->{deny_save}; 1330 return if $self->{deny_save};
1332 1331
1333 $self->clear; 1332 $self->clear;
… …
1375} 1374}
1376 1375
1377sub reset { 1376sub reset {
1378 my ($self) = @_; 1377 my ($self) = @_;
1379 1378
1379 my $lock = cf::lock_acquire "map_data:" . $self->path;
1380
1380 return if $self->players; 1381 return if $self->players;
1381 return if $self->{path}{user_rel};#d# 1382 return if $self->{path}{user_rel};#d#
1382 1383
1383 warn "resetting map ", $self->path;#d# 1384 warn "resetting map ", $self->path;#d#
1384 1385
… …
1403 1404
1404sub customise_for { 1405sub customise_for {
1405 my ($map, $ob) = @_; 1406 my ($map, $ob) = @_;
1406 1407
1407 if ($map->per_player) { 1408 if ($map->per_player) {
1408 return cf::map::find_map "~" . $ob->name . "/" . $map->{path}{path}; 1409 return cf::map::find "~" . $ob->name . "/" . $map->{path}{path};
1409 } 1410 }
1410 1411
1411 $map 1412 $map
1412} 1413}
1413 1414
1414sub emergency_save { 1415sub emergency_save {
1415 local $cf::FREEZE = 1; 1416 my $freeze_guard = cf::freeze_mainloop;
1416 1417
1417 warn "enter emergency map save\n"; 1418 warn "enter emergency map save\n";
1418 1419
1419 cf::sync_job { 1420 cf::sync_job {
1420 warn "begin emergency map save\n"; 1421 warn "begin emergency map save\n";
… …
1510 my $link_pos = delete $self->{_link_pos}; 1511 my $link_pos = delete $self->{_link_pos};
1511 1512
1512 unless ($map) { 1513 unless ($map) {
1513 # restore original map position 1514 # restore original map position
1514 ($map, $x, $y) = @{ $link_pos || [] }; 1515 ($map, $x, $y) = @{ $link_pos || [] };
1515 $map = cf::map::find_map $map; 1516 $map = cf::map::find $map;
1516 1517
1517 unless ($map) { 1518 unless ($map) {
1518 ($map, $x, $y) = @$EMERGENCY_POSITION; 1519 ($map, $x, $y) = @$EMERGENCY_POSITION;
1519 $map = cf::map::find_map $map 1520 $map = cf::map::find $map
1520 or die "FATAL: cannot load emergency map\n"; 1521 or die "FATAL: cannot load emergency map\n";
1521 } 1522 }
1522 } 1523 }
1523 1524
1524 ($x, $y) = (-1, -1) 1525 ($x, $y) = (-1, -1)
… …
1549 my ($pl) = @_; 1550 my ($pl) = @_;
1550 1551
1551 # try to abort aborted map switching on player login :) 1552 # try to abort aborted map switching on player login :)
1552 # should happen only on crashes 1553 # should happen only on crashes
1553 if ($pl->ob->{_link_pos}) { 1554 if ($pl->ob->{_link_pos}) {
1555
1554 $pl->ob->enter_link; 1556 $pl->ob->enter_link;
1555 cf::async { 1557 (async {
1556 # we need this sleep as the login has a concurrent enter_exit running 1558 # 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 1559 # and this sleep increases chances of the player not ending up in scorn
1560 $pl->ob->reply (undef,
1561 "There was an internal problem at your last logout, "
1562 . "the server will try to bring you to your intended destination in a second.",
1563 cf::NDI_RED);
1558 Coro::Timer::sleep 1; 1564 Coro::Timer::sleep 1;
1559 $pl->ob->leave_link; 1565 $pl->ob->leave_link;
1560 }; 1566 })->prio (2);
1561 } 1567 }
1562 }, 1568 },
1563); 1569);
1564 1570
1565=item $player_object->goto_map ($path, $x, $y) 1571=item $player_object->goto ($path, $x, $y)
1566 1572
1567=cut 1573=cut
1568 1574
1569sub cf::object::player::goto_map { 1575sub cf::object::player::goto {
1570 my ($self, $path, $x, $y) = @_; 1576 my ($self, $path, $x, $y) = @_;
1571 1577
1572 $self->enter_link; 1578 $self->enter_link;
1573 1579
1574 (cf::async { 1580 (async {
1575 $path = new cf::path $path; 1581 $path = new cf::path $path;
1576 1582
1577 my $map = cf::map::find_map $path->as_string; 1583 my $map = cf::map::find $path->as_string;
1578 $map = $map->customise_for ($self) if $map; 1584 $map = $map->customise_for ($self) if $map;
1579 1585
1580# warn "entering ", $map->path, " at ($x, $y)\n" 1586# warn "entering ", $map->path, " at ($x, $y)\n"
1581# if $map; 1587# if $map;
1582 1588
… …
1641 1647
1642 return unless $self->type == cf::PLAYER; 1648 return unless $self->type == cf::PLAYER;
1643 1649
1644 $self->enter_link; 1650 $self->enter_link;
1645 1651
1646 (cf::async { 1652 (async {
1653 $self->deactivate_recursive; # just to be sure
1647 unless (eval { 1654 unless (eval {
1648 prepare_random_map $exit 1655 prepare_random_map $exit
1649 if $exit->slaying eq "/!"; 1656 if $exit->slaying eq "/!";
1650 1657
1651 my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path; 1658 my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;
1652 $self->goto_map ($path, $exit->stats->hp, $exit->stats->sp); 1659 $self->goto ($path, $exit->stats->hp, $exit->stats->sp);
1653 1660
1654 1; 1661 1;
1655 }) { 1662 }) {
1656 $self->message ("Something went wrong deep within the crossfire server. " 1663 $self->message ("Something went wrong deep within the crossfire server. "
1657 . "I'll try to bring you back to the map you were before. " 1664 . "I'll try to bring you back to the map you were before. "
… …
1731 } 1738 }
1732 } 1739 }
1733 }, 1740 },
1734); 1741);
1735 1742
1736=item $client->coro (\&cb) 1743=item $client->async (\&cb)
1737 1744
1738Create a new coroutine, running the specified callback. The coroutine will 1745Create a new coroutine, running the specified callback. The coroutine will
1739be automatically cancelled when the client gets destroyed (e.g. on logout, 1746be automatically cancelled when the client gets destroyed (e.g. on logout,
1740or loss of connection). 1747or loss of connection).
1741 1748
1742=cut 1749=cut
1743 1750
1744sub cf::client::coro { 1751sub cf::client::async {
1745 my ($self, $cb) = @_; 1752 my ($self, $cb) = @_;
1746 1753
1747 my $coro = &cf::async ($cb); 1754 my $coro = &Coro::async ($cb);
1748 1755
1749 $coro->on_destroy (sub { 1756 $coro->on_destroy (sub {
1750 delete $self->{_coro}{$coro+0}; 1757 delete $self->{_coro}{$coro+0};
1751 }); 1758 });
1752 1759
… …
1990 local $/; 1997 local $/;
1991 *CFG = YAML::Syck::Load <$fh>; 1998 *CFG = YAML::Syck::Load <$fh>;
1992 1999
1993 $EMERGENCY_POSITION = $CFG{emergency_position} || ["/world/world_105_115", 5, 37]; 2000 $EMERGENCY_POSITION = $CFG{emergency_position} || ["/world/world_105_115", 5, 37];
1994 2001
2002 $cf::map::MAX_RESET = $CFG{map_max_reset} if exists $CFG{map_max_reset};
2003 $cf::map::DEFAULT_RESET = $CFG{map_default_reset} if exists $CFG{map_default_reset};
2004
1995 if (exists $CFG{mlockall}) { 2005 if (exists $CFG{mlockall}) {
1996 eval { 2006 eval {
1997 $CFG{mlockall} ? &mlockall : &munlockall 2007 $CFG{mlockall} ? &mlockall : &munlockall
1998 and die "WARNING: m(un)lockall failed: $!\n"; 2008 and die "WARNING: m(un)lockall failed: $!\n";
1999 }; 2009 };
… …
2003 2013
2004sub main { 2014sub main {
2005 # we must not ever block the main coroutine 2015 # we must not ever block the main coroutine
2006 local $Coro::idle = sub { 2016 local $Coro::idle = sub {
2007 Carp::cluck "FATAL: Coro::idle was called, major BUG, use cf::sync_job!\n";#d# 2017 Carp::cluck "FATAL: Coro::idle was called, major BUG, use cf::sync_job!\n";#d#
2008 (Coro::unblock_sub {
2009 Event::one_event; 2018 async { Event::one_event };
2010 })->();
2011 }; 2019 };
2012 2020
2013 cfg_load; 2021 cfg_load;
2014 db_load; 2022 db_load;
2015 load_extensions; 2023 load_extensions;
… …
2026 return; 2034 return;
2027 } 2035 }
2028 2036
2029 warn "reloading..."; 2037 warn "reloading...";
2030 2038
2031 local $FREEZE = 1; 2039 my $guard = freeze_mainloop;
2032 cf::emergency_save; 2040 cf::emergency_save;
2033 2041
2034 eval { 2042 eval {
2035 # if anything goes wrong in here, we should simply crash as we already saved 2043 # if anything goes wrong in here, we should simply crash as we already saved
2036 2044
… …
2172 reentrant => 0, 2180 reentrant => 0,
2173 prio => 0, 2181 prio => 0,
2174 at => $NEXT_TICK || $TICK, 2182 at => $NEXT_TICK || $TICK,
2175 data => WF_AUTOCANCEL, 2183 data => WF_AUTOCANCEL,
2176 cb => sub { 2184 cb => sub {
2177 unless ($FREEZE) {
2178 cf::server_tick; # one server iteration 2185 cf::server_tick; # one server iteration
2179 $RUNTIME += $TICK; 2186 $RUNTIME += $TICK;
2180 }
2181
2182 $NEXT_TICK += $TICK; 2187 $NEXT_TICK += $TICK;
2183 2188
2184 # if we are delayed by four ticks or more, skip them all 2189 # if we are delayed by four ticks or more, skip them all
2185 $NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4; 2190 $NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;
2186 2191

Diff Legend

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