[ViewVC] Diff of: cvs/deliantra/server/lib/cf.pm

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.100 by root, Mon Dec 25 11:25:49 2006 UTC vs.
Revision 1.126 by root, Tue Jan 2 23:12:47 2007 UTC

…		…
8	use Storable;	8	use Storable;
9	use Opcode;	9	use Opcode;
10	use Safe;	10	use Safe;
11	use Safe::Hole;	11	use Safe::Hole;
12		12
13	use Coro;	13	use Coro 3.3;
14	use Coro::Event;	14	use Coro::Event;
15	use Coro::Timer;	15	use Coro::Timer;
16	use Coro::Signal;	16	use Coro::Signal;
17	use Coro::Semaphore;	17	use Coro::Semaphore;
		18	use Coro::AIO;
18		19
		20	use Digest::MD5;
		21	use Fcntl;
19	use IO::AIO 2.3;	22	use IO::AIO 2.31 ();
20	use YAML::Syck ();	23	use YAML::Syck ();
21	use Time::HiRes;	24	use Time::HiRes;
22		25
23	use Event; $Event::Eval = 1; # no idea why this is required, but it is	26	use Event; $Event::Eval = 1; # no idea why this is required, but it is
24		27
25	# 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?
26	$YAML::Syck::ImplicitUnicode = 1;	29	$YAML::Syck::ImplicitUnicode = 1;
27		30
28	$Coro::main->prio (Coro::PRIO_MIN);	31	$Coro::main->prio (2); # run main coroutine ("the server") with very high priority
29		32
30	sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload	33	sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload
31		34
32	our %COMMAND = ();	35	our %COMMAND = ();
33	our %COMMAND_TIME = ();	36	our %COMMAND_TIME = ();
…		…
37	our $LIBDIR = datadir . "/ext";	40	our $LIBDIR = datadir . "/ext";
38		41
39	our $TICK = MAX_TIME * 1e-6;	42	our $TICK = MAX_TIME * 1e-6;
40	our $TICK_WATCHER;	43	our $TICK_WATCHER;
41	our $NEXT_TICK;	44	our $NEXT_TICK;
		45	our $NOW;
42		46
43	our %CFG;	47	our %CFG;
44		48
45	our $UPTIME; $UPTIME \|\|= time;	49	our $UPTIME; $UPTIME \|\|= time;
		50	our $RUNTIME;
		51
		52	our %MAP; # all maps
		53	our $LINK_MAP; # the special {link} map
		54	our $FREEZE;
		55	our $RANDOM_MAPS = cf::localdir . "/random";
		56	our %EXT_CORO;
		57
		58	binmode STDOUT;
		59	binmode STDERR;
		60
		61	# read virtual server time, if available
		62	unless ($RUNTIME \|\| !-e cf::localdir . "/runtime") {
		63	open my $fh, "<", cf::localdir . "/runtime"
		64	or die "unable to read runtime file: $!";
		65	$RUNTIME = <$fh> + 0.;
		66	}
		67
		68	mkdir cf::localdir;
		69	mkdir cf::localdir . "/" . cf::playerdir;
		70	mkdir cf::localdir . "/" . cf::tmpdir;
		71	mkdir cf::localdir . "/" . cf::uniquedir;
		72	mkdir $RANDOM_MAPS;
		73
		74	# a special map that is always available
		75	our $LINK_MAP;
		76
		77	our $EMERGENCY_POSITION = $cf::CFG{emergency_position} \|\| ["/world/world_105_115", 5, 37];
46		78
47	#############################################################################	79	#############################################################################
48		80
49	=head2 GLOBAL VARIABLES	81	=head2 GLOBAL VARIABLES
50		82
51	=over 4	83	=over 4
52		84
53	=item $cf::UPTIME	85	=item $cf::UPTIME
54		86
55	The timestamp of the server start (so not actually an uptime).	87	The timestamp of the server start (so not actually an uptime).
		88
		89	=item $cf::RUNTIME
		90
		91	The time this server has run, starts at 0 and is increased by $cf::TICK on
		92	every server tick.
56		93
57	=item $cf::LIBDIR	94	=item $cf::LIBDIR
58		95
59	The perl library directory, where extensions and cf-specific modules can	96	The perl library directory, where extensions and cf-specific modules can
60	be found. It will be added to C<@INC> automatically.	97	be found. It will be added to C<@INC> automatically.
		98
		99	=item $cf::NOW
		100
		101	The time of the last (current) server tick.
61		102
62	=item $cf::TICK	103	=item $cf::TICK
63		104
64	The interval between server ticks, in seconds.	105	The interval between server ticks, in seconds.
65		106
…		…
73	=cut	114	=cut
74		115
75	BEGIN {	116	BEGIN {
76	*CORE::GLOBAL::warn = sub {	117	*CORE::GLOBAL::warn = sub {
77	my $msg = join "", @_;	118	my $msg = join "", @_;
		119	utf8::encode $msg;
		120
78	$msg .= "\n"	121	$msg .= "\n"
79	unless $msg =~ /\n$/;	122	unless $msg =~ /\n$/;
80		123
81	print STDERR "cfperl: $msg";
82	LOG llevError, "cfperl: $msg";	124	LOG llevError, "cfperl: $msg";
83	};	125	};
84	}	126	}
85		127
86	@safe::cf::global::ISA = @cf::global::ISA = 'cf::attachable';	128	@safe::cf::global::ISA = @cf::global::ISA = 'cf::attachable';
…		…
139	sub to_json($) {	181	sub to_json($) {
140	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs	182	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs
141	JSON::Syck::Dump $_[0]	183	JSON::Syck::Dump $_[0]
142	}	184	}
143		185
		186	=item my $guard = cf::guard { BLOCK }
		187
		188	Run the given callback when the guard object gets destroyed (useful for
		189	coroutine cancellations).
		190
		191	You can call C<< ->cancel >> on the guard object to stop the block from
		192	being executed.
		193
		194	=cut
		195
		196	sub guard(&) {
		197	bless \(my $cb = $_[0]), cf::guard::;
		198	}
		199
		200	sub cf::guard::cancel {
		201	${$_[0]} = sub { };
		202	}
		203
		204	sub cf::guard::DESTROY {
		205	${$_[0]}->();
		206	}
		207
		208	=item cf::lock_wait $string
		209
		210	Wait until the given lock is available. See cf::lock_acquire.
		211
		212	=item my $lock = cf::lock_acquire $string
		213
		214	Wait until the given lock is available and then acquires it and returns
		215	a guard object. If the guard object gets destroyed (goes out of scope,
		216	for example when the coroutine gets canceled), the lock is automatically
		217	returned.
		218
		219	Lock names should begin with a unique identifier (for example, find_map
		220	uses map_find and load_map uses map_load).
		221
		222	=cut
		223
		224	our %LOCK;
		225
		226	sub lock_wait($) {
		227	my ($key) = @_;
		228
		229	# wait for lock, if any
		230	while ($LOCK{$key}) {
		231	push @{ $LOCK{$key} }, $Coro::current;
		232	Coro::schedule;
		233	}
		234	}
		235
		236	sub lock_acquire($) {
		237	my ($key) = @_;
		238
		239	# wait, to be sure we are not locked
		240	lock_wait $key;
		241
		242	$LOCK{$key} = [];
		243
		244	cf::guard {
		245	# wake up all waiters, to be on the safe side
		246	$_->ready for @{ delete $LOCK{$key} };
		247	}
		248	}
		249
		250	=item cf::sync_job { BLOCK }
		251
		252	The design of crossfire+ requires that the main coro ($Coro::main) is
		253	always able to handle events or runnable, as crossfire+ is only partly
		254	reentrant. Thus "blocking" it by e.g. waiting for I/O is not acceptable.
		255
		256	If it must be done, put the blocking parts into C<sync_job>. This will run
		257	the given BLOCK in another coroutine while waiting for the result. The
		258	server will be frozen during this time, so the block should either finish
		259	fast or be very important.
		260
		261	=cut
		262
		263	sub sync_job(&) {
		264	my ($job) = @_;
		265
		266	if ($Coro::current == $Coro::main) {
		267	# this is the main coro, too bad, we have to block
		268	# till the operation succeeds, freezing the server :/
		269
		270	# TODO: use suspend/resume instead
		271	# (but this is cancel-safe)
		272	local $FREEZE = 1;
		273
		274	my $busy = 1;
		275	my @res;
		276
		277	(Coro::async {
		278	@res = eval { $job->() };
		279	warn $@ if $@;
		280	undef $busy;
		281	})->prio (Coro::PRIO_MAX);
		282
		283	while ($busy) {
		284	Coro::cede_notself;
		285	Event::one_event unless Coro::nready;
		286	}
		287
		288	wantarray ? @res : $res[0]
		289	} else {
		290	# we are in another coroutine, how wonderful, everything just works
		291
		292	$job->()
		293	}
		294	}
		295
		296	=item $coro = cf::coro { BLOCK }
		297
		298	Creates and returns a new coro. This coro is automcatially being canceled
		299	when the extension calling this is being unloaded.
		300
		301	=cut
		302
		303	sub coro(&) {
		304	my $cb = shift;
		305
		306	my $coro; $coro = async {
		307	eval {
		308	$cb->();
		309	};
		310	warn $@ if $@;
		311	};
		312
		313	$coro->on_destroy (sub {
		314	delete $EXT_CORO{$coro+0};
		315	});
		316	$EXT_CORO{$coro+0} = $coro;
		317
		318	$coro
		319	}
		320
		321	sub write_runtime {
		322	my $runtime = cf::localdir . "/runtime";
		323
		324	my $fh = aio_open "$runtime~", O_WRONLY \| O_CREAT, 0644
		325	or return;
		326
		327	my $value = $cf::RUNTIME + 1 + 10; # 10 is the runtime save interval, for a monotonic clock
		328	(aio_write $fh, 0, (length $value), $value, 0) <= 0
		329	and return;
		330
		331	aio_fsync $fh
		332	and return;
		333
		334	close $fh
		335	or return;
		336
		337	aio_rename "$runtime~", $runtime
		338	and return;
		339
		340	1
		341	}
		342
144	=back	343	=back
145		344
146	=cut	345	=cut
		346
		347	#############################################################################
		348
		349	package cf::path;
		350
		351	sub new {
		352	my ($class, $path, $base) = @_;
		353
		354	$path = $path->as_string if ref $path;
		355
		356	my $self = bless { }, $class;
		357
		358	# {... are special paths that are not touched
		359	# ?xxx/... are special absolute paths
		360	# ?random/... random maps
		361	# /! non-realised random map exit
		362	# /... normal maps
		363	# ~/... per-player maps without a specific player (DO NOT USE)
		364	# ~user/... per-player map of a specific user
		365
		366	if ($path =~ /^{/) {
		367	# fine as it is
		368	} elsif ($path =~ s{^\?random/}{}) {
		369	Coro::AIO::aio_load "$cf::RANDOM_MAPS/$path.meta", my $data;
		370	$self->{random} = cf::from_json $data;
		371	} else {
		372	if ($path =~ s{^~([^/]+)?}{}) {
		373	$self->{user_rel} = 1;
		374
		375	if (defined $1) {
		376	$self->{user} = $1;
		377	} elsif ($base =~ m{^~([^/]+)/}) {
		378	$self->{user} = $1;
		379	} else {
		380	warn "cannot resolve user-relative path without user <$path,$base>\n";
		381	}
		382	} elsif ($path =~ /^\//) {
		383	# already absolute
		384	} else {
		385	$base =~ s{[^/]+/?$}{};
		386	return $class->new ("$base/$path");
		387	}
		388
		389	for ($path) {
		390	redo if s{/\.?/}{/};
		391	redo if s{/[^/]+/\.\./}{/};
		392	}
		393	}
		394
		395	$self->{path} = $path;
		396
		397	$self
		398	}
		399
		400	# the name / primary key / in-game path
		401	sub as_string {
		402	my ($self) = @_;
		403
		404	$self->{user_rel} ? "~$self->{user}$self->{path}"
		405	: $self->{random} ? "?random/$self->{path}"
		406	: $self->{path}
		407	}
		408
		409	# the displayed name, this is a one way mapping
		410	sub visible_name {
		411	my ($self) = @_;
		412
		413	# if (my $rmp = $self->{random}) {
		414	# # todo: be more intelligent about this
		415	# "?random/$rmp->{origin_map}+$rmp->{origin_x}+$rmp->{origin_y}/$rmp->{dungeon_level}"
		416	# } else {
		417	$self->as_string
		418	# }
		419	}
		420
		421	# escape the /'s in the path
		422	sub _escaped_path {
		423	# ∕ is U+2215
		424	(my $path = $_[0]{path}) =~ s/\//∕/g;
		425	$path
		426	}
		427
		428	# the original (read-only) location
		429	sub load_path {
		430	my ($self) = @_;
		431
		432	sprintf "%s/%s/%s", cf::datadir, cf::mapdir, $self->{path}
		433	}
		434
		435	# the temporary/swap location
		436	sub save_path {
		437	my ($self) = @_;
		438
		439	$self->{user_rel} ? sprintf "%s/%s/%s/%s", cf::localdir, cf::playerdir, $self->{user}, $self->_escaped_path
		440	: $self->{random} ? sprintf "%s/%s", $RANDOM_MAPS, $self->{path}
		441	: sprintf "%s/%s/%s", cf::localdir, cf::tmpdir, $self->_escaped_path
		442	}
		443
		444	# the unique path, might be eq to save_path
		445	sub uniq_path {
		446	my ($self) = @_;
		447
		448	$self->{user_rel} \|\| $self->{random}
		449	? undef
		450	: sprintf "%s/%s/%s", cf::localdir, cf::uniquedir, $self->_escaped_path
		451	}
		452
		453	# return random map parameters, or undef
		454	sub random_map_params {
		455	my ($self) = @_;
		456
		457	$self->{random}
		458	}
		459
		460	# this is somewhat ugly, but style maps do need special treatment
		461	sub is_style_map {
		462	$_[0]{path} =~ m{^/styles/}
		463	}
		464
		465	package cf;
147		466
148	#############################################################################	467	#############################################################################
149		468
150	=head2 ATTACHABLE OBJECTS	469	=head2 ATTACHABLE OBJECTS
151		470
…		…
454	=cut	773	=cut
455		774
456	#############################################################################	775	#############################################################################
457	# object support	776	# object support
458		777
		778	sub reattach {
		779	# basically do the same as instantiate, without calling instantiate
		780	my ($obj) = @_;
		781
		782	my $registry = $obj->registry;
		783
		784	@$registry = ();
		785
		786	delete $obj->{_attachment} unless scalar keys %{ $obj->{_attachment} \|\| {} };
		787
		788	for my $name (keys %{ $obj->{_attachment} \|\| {} }) {
		789	if (my $attach = $attachment{$name}) {
		790	for (@$attach) {
		791	my ($klass, @attach) = @$_;
		792	_attach $registry, $klass, @attach;
		793	}
		794	} else {
		795	warn "object uses attachment '$name' that is not available, postponing.\n";
		796	}
		797	}
		798	}
		799
459	cf::attachable->attach (	800	cf::attachable->attach (
460	prio => -1000000,	801	prio => -1000000,
461	on_instantiate => sub {	802	on_instantiate => sub {
462	my ($obj, $data) = @_;	803	my ($obj, $data) = @_;
463		804
…		…
467	my ($name, $args) = @$_;	808	my ($name, $args) = @$_;
468		809
469	$obj->attach ($name, %{$args \|\| {} });	810	$obj->attach ($name, %{$args \|\| {} });
470	}	811	}
471	},	812	},
472	on_reattach => sub {	813	on_reattach => \&reattach,
473	# basically do the same as instantiate, without calling instantiate
474	my ($obj) = @_;
475	my $registry = $obj->registry;
476
477	@$registry = ();
478
479	delete $obj->{_attachment} unless scalar keys %{ $obj->{_attachment} \|\| {} };
480
481	for my $name (keys %{ $obj->{_attachment} \|\| {} }) {
482	if (my $attach = $attachment{$name}) {
483	for (@$attach) {
484	my ($klass, @attach) = @$_;
485	_attach $registry, $klass, @attach;
486	}
487	} else {
488	warn "object uses attachment '$name' that is not available, postponing.\n";
489	}
490	}
491	},
492	on_clone => sub {	814	on_clone => sub {
493	my ($src, $dst) = @_;	815	my ($src, $dst) = @_;
494		816
495	@{$dst->registry} = @{$src->registry};	817	@{$dst->registry} = @{$src->registry};
496		818
…		…
502	);	824	);
503		825
504	sub object_freezer_save {	826	sub object_freezer_save {
505	my ($filename, $rdata, $objs) = @_;	827	my ($filename, $rdata, $objs) = @_;
506		828
		829	sync_job {
507	if (length $$rdata) {	830	if (length $$rdata) {
508	warn sprintf "saving %s (%d,%d)\n",	831	warn sprintf "saving %s (%d,%d)\n",
509	$filename, length $$rdata, scalar @$objs;	832	$filename, length $$rdata, scalar @$objs;
510		833
511	if (open my $fh, ">:raw", "$filename~") {	834	if (my $fh = aio_open "$filename~", O_WRONLY \| O_CREAT, 0600) {
512	chmod SAVE_MODE, $fh;
513	syswrite $fh, $$rdata;
514	close $fh;
515
516	if (@$objs && open my $fh, ">:raw", "$filename.pst~") {
517	chmod SAVE_MODE, $fh;	835	chmod SAVE_MODE, $fh;
518	syswrite $fh, Storable::nfreeze { version => 1, objs => $objs };	836	aio_write $fh, 0, (length $$rdata), $$rdata, 0;
		837	aio_fsync $fh;
519	close $fh;	838	close $fh;
		839
		840	if (@$objs) {
		841	if (my $fh = aio_open "$filename.pst~", O_WRONLY \| O_CREAT, 0600) {
		842	chmod SAVE_MODE, $fh;
		843	my $data = Storable::nfreeze { version => 1, objs => $objs };
		844	aio_write $fh, 0, (length $data), $data, 0;
		845	aio_fsync $fh;
		846	close $fh;
520	rename "$filename.pst~", "$filename.pst";	847	aio_rename "$filename.pst~", "$filename.pst";
		848	}
		849	} else {
		850	aio_unlink "$filename.pst";
		851	}
		852
		853	aio_rename "$filename~", $filename;
521	} else {	854	} else {
522	unlink "$filename.pst";	855	warn "FATAL: $filename~: $!\n";
523	}	856	}
524
525	rename "$filename~", $filename;
526	} else {	857	} else {
527	warn "FATAL: $filename~: $!\n";
528	}
529	} else {
530	unlink $filename;	858	aio_unlink $filename;
531	unlink "$filename.pst";	859	aio_unlink "$filename.pst";
		860	}
532	}	861	}
533	}	862	}
534		863
535	sub object_freezer_as_string {	864	sub object_freezer_as_string {
536	my ($rdata, $objs) = @_;	865	my ($rdata, $objs) = @_;
…		…
541	}	870	}
542		871
543	sub object_thawer_load {	872	sub object_thawer_load {
544	my ($filename) = @_;	873	my ($filename) = @_;
545		874
546	local $/;	875	my ($data, $av);
547		876
548	my $av;	877	(aio_load $filename, $data) >= 0
		878	or return;
549		879
550	#TODO: use sysread etc.	880	unless (aio_stat "$filename.pst") {
551	if (open my $data, "<:raw:perlio", $filename) {	881	(aio_load "$filename.pst", $av) >= 0
552	$data = <$data>;	882	or return;
553	if (open my $pst, "<:raw:perlio", "$filename.pst") {
554	$av = eval { (Storable::thaw <$pst>)->{objs} };	883	$av = eval { (Storable::thaw $av)->{objs} };
555	}	884	}
		885
		886	warn sprintf "loading %s (%d)\n",
		887	$filename, length $data, scalar @{$av \|\| []};#d#
556	return ($data, $av);	888	return ($data, $av);
557	}
558
559	()
560	}	889	}
561		890
562	#############################################################################	891	#############################################################################
563	# command handling &c	892	# command handling &c
564		893
…		…
785	$self->send ("ext " . to_json \%msg);	1114	$self->send ("ext " . to_json \%msg);
786	}	1115	}
787		1116
788	=back	1117	=back
789		1118
		1119
		1120	=head3 cf::map
		1121
		1122	=over 4
		1123
		1124	=cut
		1125
		1126	package cf::map;
		1127
		1128	use Fcntl;
		1129	use Coro::AIO;
		1130
		1131	our $MAX_RESET = 7200;
		1132	our $DEFAULT_RESET = 3600;
		1133
		1134	sub generate_random_map {
		1135	my ($path, $rmp) = @_;
		1136
		1137	# mit "rum" bekleckern, nicht
		1138	cf::map::_create_random_map
		1139	$path,
		1140	$rmp->{wallstyle}, $rmp->{wall_name}, $rmp->{floorstyle}, $rmp->{monsterstyle},
		1141	$rmp->{treasurestyle}, $rmp->{layoutstyle}, $rmp->{doorstyle}, $rmp->{decorstyle},
		1142	$rmp->{origin_map}, $rmp->{final_map}, $rmp->{exitstyle}, $rmp->{this_map},
		1143	$rmp->{exit_on_final_map},
		1144	$rmp->{xsize}, $rmp->{ysize},
		1145	$rmp->{expand2x}, $rmp->{layoutoptions1}, $rmp->{layoutoptions2}, $rmp->{layoutoptions3},
		1146	$rmp->{symmetry}, $rmp->{difficulty}, $rmp->{difficulty_given}, $rmp->{difficulty_increase},
		1147	$rmp->{dungeon_level}, $rmp->{dungeon_depth}, $rmp->{decoroptions}, $rmp->{orientation},
		1148	$rmp->{origin_y}, $rmp->{origin_x}, $rmp->{random_seed}, $rmp->{total_map_hp},
		1149	$rmp->{map_layout_style}, $rmp->{treasureoptions}, $rmp->{symmetry_used},
		1150	(cf::region::find $rmp->{region})
		1151	}
		1152
		1153	# and all this just because we cannot iterate over
		1154	# all maps in C++...
		1155	sub change_all_map_light {
		1156	my ($change) = @_;
		1157
		1158	$_->change_map_light ($change)
		1159	for grep $_->outdoor, values %cf::MAP;
		1160	}
		1161
		1162	sub try_load_header($) {
		1163	my ($path) = @_;
		1164
		1165	utf8::encode $path;
		1166	aio_open $path, O_RDONLY, 0
		1167	or return;
		1168
		1169	my $map = cf::map::new
		1170	or return;
		1171
		1172	$map->load_header ($path)
		1173	or return;
		1174
		1175	$map->{load_path} = $path;
		1176
		1177	$map
		1178	}
		1179
		1180	sub find_map;
		1181	sub find_map {
		1182	my ($path, $origin) = @_;
		1183
		1184	#warn "find_map<$path,$origin>\n";#d#
		1185
		1186	$path = new cf::path $path, $origin && $origin->path;
		1187	my $key = $path->as_string;
		1188
		1189	cf::lock_wait "map_find:$key";
		1190
		1191	$cf::MAP{$key} \|\| do {
		1192	my $guard = cf::lock_acquire "map_find:$key";
		1193
		1194	# do it the slow way
		1195	my $map = try_load_header $path->save_path;
		1196
		1197	if ($map) {
		1198	# safety
		1199	$map->{instantiate_time} = $cf::RUNTIME
		1200	if $map->{instantiate_time} > $cf::RUNTIME;
		1201	} else {
		1202	if (my $rmp = $path->random_map_params) {
		1203	$map = generate_random_map $key, $rmp;
		1204	} else {
		1205	$map = try_load_header $path->load_path;
		1206	}
		1207
		1208	$map or return;
		1209
		1210	$map->{load_original} = 1;
		1211	$map->{instantiate_time} = $cf::RUNTIME;
		1212	$map->instantiate;
		1213
		1214	# per-player maps become, after loading, normal maps
		1215	$map->per_player (0) if $path->{user_rel};
		1216	}
		1217
		1218	$map->path ($key);
		1219	$map->{path} = $path;
		1220	$map->{last_save} = $cf::RUNTIME;
		1221	$map->last_access ($cf::RUNTIME);
		1222
		1223	if ($map->should_reset) {
		1224	$map->reset;
		1225	undef $guard;
		1226	$map = find_map $path
		1227	or return;
		1228	}
		1229
		1230	$cf::MAP{$key} = $map
		1231	}
		1232	}
		1233
		1234	sub load {
		1235	my ($self) = @_;
		1236
		1237	my $path = $self->{path};
		1238	my $guard = cf::lock_acquire "map_load:" . $path->as_string;
		1239
		1240	return if $self->in_memory != cf::MAP_SWAPPED;
		1241
		1242	$self->in_memory (cf::MAP_LOADING);
		1243
		1244	$self->alloc;
		1245	$self->load_objects ($self->{load_path}, 1)
		1246	or return;
		1247
		1248	$self->set_object_flag (cf::FLAG_OBJ_ORIGINAL, 1)
		1249	if delete $self->{load_original};
		1250
		1251	if (my $uniq = $path->uniq_path) {
		1252	utf8::encode $uniq;
		1253	if (aio_open $uniq, O_RDONLY, 0) {
		1254	$self->clear_unique_items;
		1255	$self->load_objects ($uniq, 0);
		1256	}
		1257	}
		1258
		1259	# now do the right thing for maps
		1260	$self->link_multipart_objects;
		1261
		1262	if ($self->{path}->is_style_map) {
		1263	$self->{deny_save} = 1;
		1264	$self->{deny_reset} = 1;
		1265	} else {
		1266	$self->fix_auto_apply;
		1267	$self->decay_objects;
		1268	$self->update_buttons;
		1269	$self->set_darkness_map;
		1270	$self->difficulty ($self->estimate_difficulty)
		1271	unless $self->difficulty;
		1272	$self->activate;
		1273	}
		1274
		1275	$self->in_memory (cf::MAP_IN_MEMORY);
		1276	}
		1277
		1278	sub load_map_sync {
		1279	my ($path, $origin) = @_;
		1280
		1281	#warn "load_map_sync<$path, $origin>\n";#d#
		1282
		1283	cf::sync_job {
		1284	my $map = cf::map::find_map $path, $origin
		1285	or return;
		1286	$map->load;
		1287	$map
		1288	}
		1289	}
		1290
		1291	sub save {
		1292	my ($self) = @_;
		1293
		1294	$self->{last_save} = $cf::RUNTIME;
		1295
		1296	return unless $self->dirty;
		1297
		1298	my $save = $self->{path}->save_path; utf8::encode $save;
		1299	my $uniq = $self->{path}->uniq_path; utf8::encode $uniq;
		1300
		1301	$self->{load_path} = $save;
		1302
		1303	return if $self->{deny_save};
		1304
		1305	if ($uniq) {
		1306	$self->save_objects ($save, cf::IO_HEADER \| cf::IO_OBJECTS);
		1307	$self->save_objects ($uniq, cf::IO_UNIQUES);
		1308	} else {
		1309	$self->save_objects ($save, cf::IO_HEADER \| cf::IO_OBJECTS \| cf::IO_UNIQUES);
		1310	}
		1311	}
		1312
		1313	sub swap_out {
		1314	my ($self) = @_;
		1315
		1316	return if $self->players;
		1317	return if $self->in_memory != cf::MAP_IN_MEMORY;
		1318	return if $self->{deny_save};
		1319
		1320	$self->save;
		1321	$self->clear;
		1322	$self->in_memory (cf::MAP_SWAPPED);
		1323	}
		1324
		1325	sub reset_at {
		1326	my ($self) = @_;
		1327
		1328	# TODO: safety, remove and allow resettable per-player maps
		1329	return 1e99 if $self->{path}{user_rel};
		1330	return 1e99 if $self->{deny_reset};
		1331
		1332	my $time = $self->fixed_resettime ? $self->{instantiate_time} : $self->last_access;
		1333	my $to = List::Util::min $MAX_RESET, $self->reset_timeout \|\| $DEFAULT_RESET;
		1334
		1335	$time + $to
		1336	}
		1337
		1338	sub should_reset {
		1339	my ($self) = @_;
		1340
		1341	$self->reset_at <= $cf::RUNTIME
		1342	}
		1343
		1344	sub unlink_save {
		1345	my ($self) = @_;
		1346
		1347	utf8::encode (my $save = $self->{path}->save_path);
		1348	aioreq_pri 3; IO::AIO::aio_unlink $save;
		1349	aioreq_pri 3; IO::AIO::aio_unlink "$save.pst";
		1350	}
		1351
		1352	sub rename {
		1353	my ($self, $new_path) = @_;
		1354
		1355	$self->unlink_save;
		1356
		1357	delete $cf::MAP{$self->path};
		1358	$self->{path} = new cf::path $new_path;
		1359	$self->path ($self->{path}->as_string);
		1360	$cf::MAP{$self->path} = $self;
		1361
		1362	$self->save;
		1363	}
		1364
		1365	sub reset {
		1366	my ($self) = @_;
		1367
		1368	return if $self->players;
		1369	return if $self->{path}{user_rel};#d#
		1370
		1371	warn "resetting map ", $self->path;#d#
		1372
		1373	delete $cf::MAP{$self->path};
		1374
		1375	$_->clear_links_to ($self) for values %cf::MAP;
		1376
		1377	$self->unlink_save;
		1378	$self->destroy;
		1379	}
		1380
		1381	my $nuke_counter = "aaaa";
		1382
		1383	sub nuke {
		1384	my ($self) = @_;
		1385
		1386	$self->{deny_save} = 1;
		1387	$self->reset_timeout (1);
		1388	$self->rename ("{nuke}/" . ($nuke_counter++));
		1389	$self->reset; # polite request, might not happen
		1390	}
		1391
		1392	sub customise_for {
		1393	my ($map, $ob) = @_;
		1394
		1395	if ($map->per_player) {
		1396	return cf::map::find_map "~" . $ob->name . "/" . $map->{path}{path};
		1397	}
		1398
		1399	$map
		1400	}
		1401
		1402	sub emergency_save {
		1403	local $cf::FREEZE = 1;
		1404
		1405	warn "enter emergency map save\n";
		1406
		1407	cf::sync_job {
		1408	warn "begin emergency map save\n";
		1409	$_->save for values %cf::MAP;
		1410	};
		1411
		1412	warn "end emergency map save\n";
		1413	}
		1414
		1415	package cf;
		1416
		1417	=back
		1418
		1419
790	=head3 cf::object::player	1420	=head3 cf::object::player
791		1421
792	=over 4	1422	=over 4
793		1423
794	=item $player_object->reply ($npc, $msg[, $flags])	1424	=item $player_object->reply ($npc, $msg[, $flags])
…		…
827		1457
828	$self->flag (cf::FLAG_WIZ) \|\|	1458	$self->flag (cf::FLAG_WIZ) \|\|
829	(ref $cf::CFG{"may_$access"}	1459	(ref $cf::CFG{"may_$access"}
830	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}	1460	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}
831	: $cf::CFG{"may_$access"})	1461	: $cf::CFG{"may_$access"})
		1462	}
		1463
		1464	=item $player_object->enter_link
		1465
		1466	Freezes the player and moves him/her to a special map (C<{link}>).
		1467
		1468	The player should be reaosnably safe there for short amounts of time. You
		1469	I<MUST> call C<leave_link> as soon as possible, though.
		1470
		1471	=item $player_object->leave_link ($map, $x, $y)
		1472
		1473	Moves the player out of the specila link map onto the given map. If the
		1474	map is not valid (or omitted), the player will be moved back to the
		1475	location he/she was before the call to C<enter_link>, or, if that fails,
		1476	to the emergency map position.
		1477
		1478	Might block.
		1479
		1480	=cut
		1481
		1482	sub cf::object::player::enter_link {
		1483	my ($self) = @_;
		1484
		1485	$self->deactivate_recursive;
		1486
		1487	return if $self->map == $LINK_MAP;
		1488
		1489	$self->{_link_pos} \|\|= [$self->map->{path}, $self->x, $self->y]
		1490	if $self->map;
		1491
		1492	$self->enter_map ($LINK_MAP, 20, 20);
		1493	}
		1494
		1495	sub cf::object::player::leave_link {
		1496	my ($self, $map, $x, $y) = @_;
		1497
		1498	my $link_pos = delete $self->{_link_pos};
		1499
		1500	unless ($map) {
		1501	# restore original map position
		1502	($map, $x, $y) = @{ $link_pos \|\| [] };
		1503	$map = cf::map::find_map $map;
		1504
		1505	unless ($map) {
		1506	($map, $x, $y) = @$EMERGENCY_POSITION;
		1507	$map = cf::map::find_map $map
		1508	or die "FATAL: cannot load emergency map\n";
		1509	}
		1510	}
		1511
		1512	($x, $y) = (-1, -1)
		1513	unless (defined $x) && (defined $y);
		1514
		1515	# use -1 or undef as default coordinates, not 0, 0
		1516	($x, $y) = ($map->enter_x, $map->enter_y)
		1517	if $x <=0 && $y <= 0;
		1518
		1519	$map->load;
		1520
		1521	$self->activate_recursive;
		1522	$self->enter_map ($map, $x, $y);
		1523	}
		1524
		1525	cf::player->attach (
		1526	on_logout => sub {
		1527	my ($pl) = @_;
		1528
		1529	# abort map switching before logout
		1530	if ($pl->ob->{_link_pos}) {
		1531	cf::sync_job {
		1532	$pl->ob->leave_link
		1533	};
		1534	}
		1535	},
		1536	on_login => sub {
		1537	my ($pl) = @_;
		1538
		1539	# try to abort aborted map switching on player login :)
		1540	# should happen only on crashes
		1541	if ($pl->ob->{_link_pos}) {
		1542	$pl->ob->enter_link;
		1543	Coro::async {
		1544	# we need this sleep as the login has a concurrent enter_exit running
		1545	# and this sleep increases chances of the player not ending up in scorn
		1546	Coro::Timer::sleep 1;
		1547	$pl->ob->leave_link;
		1548	};
		1549	}
		1550	},
		1551	);
		1552
		1553	=item $player_object->goto_map ($path, $x, $y)
		1554
		1555	=cut
		1556
		1557	sub cf::object::player::goto_map {
		1558	my ($self, $path, $x, $y) = @_;
		1559
		1560	$self->enter_link;
		1561
		1562	(Coro::async {
		1563	$path = new cf::path $path;
		1564
		1565	my $map = cf::map::find_map $path->as_string;
		1566	$map = $map->customise_for ($self) if $map;
		1567
		1568	# warn "entering ", $map->path, " at ($x, $y)\n"
		1569	# if $map;
		1570
		1571	$map or $self->message ("The exit is closed", cf::NDI_UNIQUE \| cf::NDI_RED);
		1572
		1573	$self->leave_link ($map, $x, $y);
		1574	})->prio (1);
		1575	}
		1576
		1577	=item $player_object->enter_exit ($exit_object)
		1578
		1579	=cut
		1580
		1581	sub parse_random_map_params {
		1582	my ($spec) = @_;
		1583
		1584	my $rmp = { # defaults
		1585	xsize => 10,
		1586	ysize => 10,
		1587	};
		1588
		1589	for (split /\n/, $spec) {
		1590	my ($k, $v) = split /\s+/, $_, 2;
		1591
		1592	$rmp->{lc $k} = $v if (length $k) && (length $v);
		1593	}
		1594
		1595	$rmp
		1596	}
		1597
		1598	sub prepare_random_map {
		1599	my ($exit) = @_;
		1600
		1601	# all this does is basically replace the /! path by
		1602	# a new random map path (?random/...) with a seed
		1603	# that depends on the exit object
		1604
		1605	my $rmp = parse_random_map_params $exit->msg;
		1606
		1607	if ($exit->map) {
		1608	$rmp->{region} = $exit->map->region_name;
		1609	$rmp->{origin_map} = $exit->map->path;
		1610	$rmp->{origin_x} = $exit->x;
		1611	$rmp->{origin_y} = $exit->y;
		1612	}
		1613
		1614	$rmp->{random_seed} \|\|= $exit->random_seed;
		1615
		1616	my $data = cf::to_json $rmp;
		1617	my $md5 = Digest::MD5::md5_hex $data;
		1618
		1619	if (my $fh = aio_open "$cf::RANDOM_MAPS/$md5.meta", O_WRONLY \| O_CREAT, 0666) {
		1620	aio_write $fh, 0, (length $data), $data, 0;
		1621
		1622	$exit->slaying ("?random/$md5");
		1623	$exit->msg (undef);
		1624	}
		1625	}
		1626
		1627	sub cf::object::player::enter_exit {
		1628	my ($self, $exit) = @_;
		1629
		1630	return unless $self->type == cf::PLAYER;
		1631
		1632	$self->enter_link;
		1633
		1634	(Coro::async {
		1635	unless (eval {
		1636
		1637	prepare_random_map $exit
		1638	if $exit->slaying eq "/!";
		1639
		1640	my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;
		1641	$self->goto_map ($path, $exit->stats->hp, $exit->stats->sp);
		1642
		1643	1;
		1644	}) {
		1645	$self->message ("Something went wrong deep within the crossfire server. "
		1646	. "I'll try to bring you back to the map you were before. "
		1647	. "Please report this to the dungeon master",
		1648	cf::NDI_UNIQUE \| cf::NDI_RED);
		1649
		1650	warn "ERROR in enter_exit: $@";
		1651	$self->leave_link;
		1652	}
		1653	})->prio (1);
832	}	1654	}
833		1655
834	=head3 cf::client	1656	=head3 cf::client
835		1657
836	=over 4	1658	=over 4
…		…
913	my $coro; $coro = async {	1735	my $coro; $coro = async {
914	eval {	1736	eval {
915	$cb->();	1737	$cb->();
916	};	1738	};
917	warn $@ if $@;	1739	warn $@ if $@;
		1740	};
		1741
		1742	$coro->on_destroy (sub {
918	delete $self->{_coro}{$coro+0};	1743	delete $self->{_coro}{$coro+0};
919	};	1744	});
920		1745
921	$self->{_coro}{$coro+0} = $coro;	1746	$self->{_coro}{$coro+0} = $coro;
		1747
		1748	$coro
922	}	1749	}
923		1750
924	cf::client->attach (	1751	cf::client->attach (
925	on_destroy => sub {	1752	on_destroy => sub {
926	my ($ns) = @_;	1753	my ($ns) = @_;
…		…
1090		1917
1091	{	1918	{
1092	my $path = cf::localdir . "/database.pst";	1919	my $path = cf::localdir . "/database.pst";
1093		1920
1094	sub db_load() {	1921	sub db_load() {
1095	warn "loading database $path\n";#d# remove later
1096	$DB = stat $path ? Storable::retrieve $path : { };	1922	$DB = stat $path ? Storable::retrieve $path : { };
1097	}	1923	}
1098		1924
1099	my $pid;	1925	my $pid;
1100		1926
1101	sub db_save() {	1927	sub db_save() {
1102	warn "saving database $path\n";#d# remove later
1103	waitpid $pid, 0 if $pid;	1928	waitpid $pid, 0 if $pid;
1104	if (0 == ($pid = fork)) {	1929	if (0 == ($pid = fork)) {
1105	$DB->{_meta}{version} = 1;	1930	$DB->{_meta}{version} = 1;
1106	Storable::nstore $DB, "$path~";	1931	Storable::nstore $DB, "$path~";
1107	rename "$path~", $path;	1932	rename "$path~", $path;
…		…
1158	local $/;	1983	local $/;
1159	*CFG = YAML::Syck::Load <$fh>;	1984	*CFG = YAML::Syck::Load <$fh>;
1160	}	1985	}
1161		1986
1162	sub main {	1987	sub main {
		1988	# we must not ever block the main coroutine
		1989	local $Coro::idle = sub {
		1990	Carp::cluck "FATAL: Coro::idle was called, major BUG, use cf::sync_job!\n";#d#
		1991	(Coro::unblock_sub {
		1992	Event::one_event;
		1993	})->();
		1994	};
		1995
1163	cfg_load;	1996	cfg_load;
1164	db_load;	1997	db_load;
1165	load_extensions;	1998	load_extensions;
1166	Event::loop;	1999	Event::loop;
1167	}	2000	}
1168		2001
1169	#############################################################################	2002	#############################################################################
1170	# initialisation	2003	# initialisation
1171		2004
1172	sub _perl_reload(&) {	2005	sub reload() {
1173	my ($msg) = @_;	2006	# can/must only be called in main
		2007	if ($Coro::current != $Coro::main) {
		2008	warn "can only reload from main coroutine\n";
		2009	return;
		2010	}
1174		2011
1175	$msg->("reloading...");	2012	warn "reloading...";
		2013
		2014	local $FREEZE = 1;
		2015	cf::emergency_save;
1176		2016
1177	eval {	2017	eval {
		2018	# if anything goes wrong in here, we should simply crash as we already saved
		2019
1178	# cancel all watchers	2020	# cancel all watchers
1179	for (Event::all_watchers) {	2021	for (Event::all_watchers) {
1180	$_->cancel if $_->data & WF_AUTOCANCEL;	2022	$_->cancel if $_->data & WF_AUTOCANCEL;
1181	}	2023	}
1182		2024
		2025	# cancel all extension coros
		2026	$_->cancel for values %EXT_CORO;
		2027	%EXT_CORO = ();
		2028
1183	# unload all extensions	2029	# unload all extensions
1184	for (@exts) {	2030	for (@exts) {
1185	$msg->("unloading <$_>");	2031	warn "unloading <$_>";
1186	unload_extension $_;	2032	unload_extension $_;
1187	}	2033	}
1188		2034
1189	# unload all modules loaded from $LIBDIR	2035	# unload all modules loaded from $LIBDIR
1190	while (my ($k, $v) = each %INC) {	2036	while (my ($k, $v) = each %INC) {
1191	next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;	2037	next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;
1192		2038
1193	$msg->("removing <$k>");	2039	warn "removing <$k>";
1194	delete $INC{$k};	2040	delete $INC{$k};
1195		2041
1196	$k =~ s/\.pm$//;	2042	$k =~ s/\.pm$//;
1197	$k =~ s/\//::/g;	2043	$k =~ s/\//::/g;
1198		2044
…		…
1203	Symbol::delete_package $k;	2049	Symbol::delete_package $k;
1204	}	2050	}
1205		2051
1206	# sync database to disk	2052	# sync database to disk
1207	cf::db_sync;	2053	cf::db_sync;
		2054	IO::AIO::flush;
1208		2055
1209	# get rid of safe::, as good as possible	2056	# get rid of safe::, as good as possible
1210	Symbol::delete_package "safe::$_"	2057	Symbol::delete_package "safe::$_"
1211	for qw(cf::object cf::object::player cf::player cf::map cf::party cf::region);	2058	for qw(cf::attachable cf::object cf::object::player cf::client cf::player cf::map cf::party cf::region);
1212		2059
1213	# remove register_script_function callbacks	2060	# remove register_script_function callbacks
1214	# TODO	2061	# TODO
1215		2062
1216	# unload cf.pm "a bit"	2063	# unload cf.pm "a bit"
…		…
1219	# don't, removes xs symbols, too,	2066	# don't, removes xs symbols, too,
1220	# and global variables created in xs	2067	# and global variables created in xs
1221	#Symbol::delete_package __PACKAGE__;	2068	#Symbol::delete_package __PACKAGE__;
1222		2069
1223	# reload cf.pm	2070	# reload cf.pm
1224	$msg->("reloading cf.pm");	2071	warn "reloading cf.pm";
1225	require cf;	2072	require cf;
1226	cf::_connect_to_perl; # nominally unnecessary, but cannot hurt	2073	cf::_connect_to_perl; # nominally unnecessary, but cannot hurt
1227
1228		2074
1229	# load config and database again	2075	# load config and database again
1230	cf::cfg_load;	2076	cf::cfg_load;
1231	cf::db_load;	2077	cf::db_load;
1232		2078
1233	# load extensions	2079	# load extensions
1234	$msg->("load extensions");	2080	warn "load extensions";
1235	cf::load_extensions;	2081	cf::load_extensions;
1236		2082
1237	# reattach attachments to objects	2083	# reattach attachments to objects
1238	$msg->("reattach");	2084	warn "reattach";
1239	_global_reattach;	2085	_global_reattach;
1240	};	2086	};
1241	$msg->($@) if $@;
1242		2087
1243	$msg->("reloaded");	2088	if ($@) {
		2089	warn $@;
		2090	warn "error while reloading, exiting.";
		2091	exit 1;
		2092	}
		2093
		2094	warn "reloaded successfully";
1244	};	2095	};
1245		2096
1246	sub perl_reload() {	2097	#############################################################################
1247	_perl_reload {	2098
1248	warn $_[0];	2099	unless ($LINK_MAP) {
1249	print "$_[0]\n";	2100	$LINK_MAP = cf::map::new;
1250	};	2101
		2102	$LINK_MAP->width (41);
		2103	$LINK_MAP->height (41);
		2104	$LINK_MAP->alloc;
		2105	$LINK_MAP->path ("{link}");
		2106	$LINK_MAP->{path} = bless { path => "{link}" }, "cf::path";
		2107	$LINK_MAP->in_memory (MAP_IN_MEMORY);
		2108
		2109	# dirty hack because... archetypes are not yet loaded
		2110	Event->timer (
		2111	after => 2,
		2112	cb => sub {
		2113	$_[0]->w->cancel;
		2114
		2115	# provide some exits "home"
		2116	my $exit = cf::object::new "exit";
		2117
		2118	$exit->slaying ($EMERGENCY_POSITION->[0]);
		2119	$exit->stats->hp ($EMERGENCY_POSITION->[1]);
		2120	$exit->stats->sp ($EMERGENCY_POSITION->[2]);
		2121
		2122	$LINK_MAP->insert ($exit->clone, 19, 19);
		2123	$LINK_MAP->insert ($exit->clone, 19, 20);
		2124	$LINK_MAP->insert ($exit->clone, 19, 21);
		2125	$LINK_MAP->insert ($exit->clone, 20, 19);
		2126	$LINK_MAP->insert ($exit->clone, 20, 21);
		2127	$LINK_MAP->insert ($exit->clone, 21, 19);
		2128	$LINK_MAP->insert ($exit->clone, 21, 20);
		2129	$LINK_MAP->insert ($exit->clone, 21, 21);
		2130
		2131	$exit->destroy;
		2132	});
		2133
		2134	$LINK_MAP->{deny_save} = 1;
		2135	$LINK_MAP->{deny_reset} = 1;
		2136
		2137	$cf::MAP{$LINK_MAP->path} = $LINK_MAP;
1251	}	2138	}
1252		2139
1253	register "<global>", __PACKAGE__;	2140	register "<global>", __PACKAGE__;
1254		2141
1255	register_command "perl-reload" => sub {	2142	register_command "reload" => sub {
1256	my ($who, $arg) = @_;	2143	my ($who, $arg) = @_;
1257		2144
1258	if ($who->flag (FLAG_WIZ)) {	2145	if ($who->flag (FLAG_WIZ)) {
1259	_perl_reload {	2146	$who->message ("start of reload.");
1260	warn $_[0];	2147	reload;
1261	$who->message ($_[0]);	2148	$who->message ("end of reload.");
1262	};
1263	}	2149	}
1264	};	2150	};
1265		2151
1266	unshift @INC, $LIBDIR;	2152	unshift @INC, $LIBDIR;
1267		2153
1268	$TICK_WATCHER = Event->timer (	2154	$TICK_WATCHER = Event->timer (
		2155	reentrant => 0,
1269	prio => 0,	2156	prio => 0,
1270	at => $NEXT_TICK \|\| 1,	2157	at => $NEXT_TICK \|\| $TICK,
1271	data => WF_AUTOCANCEL,	2158	data => WF_AUTOCANCEL,
1272	cb => sub {	2159	cb => sub {
		2160	unless ($FREEZE) {
1273	cf::server_tick; # one server iteration	2161	cf::server_tick; # one server iteration
		2162	$RUNTIME += $TICK;
		2163	}
1274		2164
1275	my $NOW = Event::time;
1276	$NEXT_TICK += $TICK;	2165	$NEXT_TICK += $TICK;
1277		2166
1278	# if we are delayed by four ticks or more, skip them all	2167	# if we are delayed by four ticks or more, skip them all
1279	$NEXT_TICK = $NOW if $NOW >= $NEXT_TICK + $TICK * 4;	2168	$NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;
1280		2169
1281	$TICK_WATCHER->at ($NEXT_TICK);	2170	$TICK_WATCHER->at ($NEXT_TICK);
1282	$TICK_WATCHER->start;	2171	$TICK_WATCHER->start;
1283	},	2172	},
1284	);	2173	);
1285		2174
1286	IO::AIO::max_poll_time $TICK * 0.2;	2175	IO::AIO::max_poll_time $TICK * 0.2;
1287		2176
		2177	Event->io (
1288	Event->io (fd => IO::AIO::poll_fileno,	2178	fd => IO::AIO::poll_fileno,
1289	poll => 'r',	2179	poll => 'r',
1290	prio => 5,	2180	prio => 5,
1291	data => WF_AUTOCANCEL,	2181	data => WF_AUTOCANCEL,
1292	cb => \&IO::AIO::poll_cb);	2182	cb => \&IO::AIO::poll_cb,
		2183	);
		2184
		2185	Event->timer (
		2186	data => WF_AUTOCANCEL,
		2187	after => 0,
		2188	interval => 10,
		2189	cb => sub {
		2190	(Coro::unblock_sub {
		2191	write_runtime
		2192	or warn "ERROR: unable to write runtime file: $!";
		2193	})->();
		2194	},
		2195	);
		2196
		2197	END { cf::emergency_save }
1293		2198
1294	1	2199	1
1295		2200

Diff Legend

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

Comparing deliantra/server/lib/cf.pm (file contents): Revision 1.100 by root, Mon Dec 25 11:25:49 2006 UTC vs. Revision 1.126 by root, Tue Jan 2 23:12:47 2007 UTC

Diff Legend

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.100 by root, Mon Dec 25 11:25:49 2006 UTC vs.
Revision 1.126 by root, Tue Jan 2 23:12:47 2007 UTC