ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/lib/cf.pm

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.102 by root, Wed Dec 27 15:20:54 2006 UTC vs.
Revision 1.219 by root, Sat Feb 17 03:19:44 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.5 ();
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 BDB ();
		21	use Data::Dumper;
		22	use Digest::MD5;
		23	use Fcntl;
19	use IO::AIO 2.3;	24	use IO::AIO 2.32 ();
20	use YAML::Syck ();	25	use YAML::Syck ();
21	use Time::HiRes;	26	use Time::HiRes;
		27	use Compress::LZF;
		28
		29	Compress::LZF::sfreeze_cr { }; # prime Compress::LZF so it does not use require later
22		30
23	use Event; $Event::Eval = 1; # no idea why this is required, but it is	31	use Event; $Event::Eval = 1; # no idea why this is required, but it is
		32
		33	sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload
24		34
25	# work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode?	35	# work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode?
26	$YAML::Syck::ImplicitUnicode = 1;	36	$YAML::Syck::ImplicitUnicode = 1;
27		37
28	$Coro::main->prio (Coro::PRIO_MIN);	38	$Coro::main->prio (Coro::PRIO_MAX); # run main coroutine ("the server") with very high priority
29
30	sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload
31		39
32	our %COMMAND = ();	40	our %COMMAND = ();
33	our %COMMAND_TIME = ();	41	our %COMMAND_TIME = ();
		42
		43	our @EXTS = (); # list of extension package names
34	our %EXTCMD = ();	44	our %EXTCMD = ();
		45	our %EXT_CORO = (); # coroutines bound to extensions
		46	our %EXT_MAP = (); # pluggable maps
35		47
36	our @EVENT;	48	our @EVENT;
37	our $LIBDIR = datadir . "/ext";	49	our $LIBDIR = datadir . "/ext";
38		50
39	our $TICK = MAX_TIME * 1e-6;	51	our $TICK = MAX_TIME * 1e-6;
40	our $TICK_WATCHER;	52	our $TICK_WATCHER;
		53	our $AIO_POLL_WATCHER;
		54	our $NEXT_RUNTIME_WRITE; # when should the runtime file be written
41	our $NEXT_TICK;	55	our $NEXT_TICK;
		56	our $NOW;
		57	our $USE_FSYNC = 1; # use fsync to write maps - default off
		58
		59	our $BDB_POLL_WATCHER;
		60	our $DB_ENV;
42		61
43	our %CFG;	62	our %CFG;
44		63
45	our $UPTIME; $UPTIME ||= time;	64	our $UPTIME; $UPTIME ||= time;
		65	our $RUNTIME;
		66
		67	our %PLAYER; # all users
		68	our %MAP; # all maps
		69	our $LINK_MAP; # the special {link} map, which is always available
		70	our $RANDOM_MAPS = cf::localdir . "/random";
		71	our $BDB_ENV_DIR = cf::localdir . "/db";
		72
		73	our $WAIT_FOR_TICK; $WAIT_FOR_TICK ||= new Coro::Signal;
		74	our $WAIT_FOR_TICK_ONE; $WAIT_FOR_TICK_ONE ||= new Coro::Signal;
		75
		76	# used to convert map paths into valid unix filenames by replacing / by ∕
		77	our $PATH_SEP = "∕"; # U+2215, chosen purely for visual reasons
		78
		79	binmode STDOUT;
		80	binmode STDERR;
		81
		82	# read virtual server time, if available
		83	unless ($RUNTIME || !-e cf::localdir . "/runtime") {
		84	open my $fh, "<", cf::localdir . "/runtime"
		85	or die "unable to read runtime file: $!";
		86	$RUNTIME = <$fh> + 0.;
		87	}
		88
		89	mkdir cf::localdir;
		90	mkdir cf::localdir . "/" . cf::playerdir;
		91	mkdir cf::localdir . "/" . cf::tmpdir;
		92	mkdir cf::localdir . "/" . cf::uniquedir;
		93	mkdir $RANDOM_MAPS;
		94	mkdir $BDB_ENV_DIR;
		95
		96	our $EMERGENCY_POSITION;
		97
		98	sub cf::map::normalise;
46		99
47	#############################################################################	100	#############################################################################
48		101
49	=head2 GLOBAL VARIABLES	102	=head2 GLOBAL VARIABLES
50		103
51	=over 4	104	=over 4
52		105
53	=item $cf::UPTIME	106	=item $cf::UPTIME
54		107
55	The timestamp of the server start (so not actually an uptime).	108	The timestamp of the server start (so not actually an uptime).
		109
		110	=item $cf::RUNTIME
		111
		112	The time this server has run, starts at 0 and is increased by $cf::TICK on
		113	every server tick.
56		114
57	=item $cf::LIBDIR	115	=item $cf::LIBDIR
58		116
59	The perl library directory, where extensions and cf-specific modules can	117	The perl library directory, where extensions and cf-specific modules can
60	be found. It will be added to C<@INC> automatically.	118	be found. It will be added to C<@INC> automatically.
61		119
		120	=item $cf::NOW
		121
		122	The time of the last (current) server tick.
		123
62	=item $cf::TICK	124	=item $cf::TICK
63		125
64	The interval between server ticks, in seconds.	126	The interval between server ticks, in seconds.
65		127
66	=item %cf::CFG	128	=item %cf::CFG
67		129
68	Configuration for the server, loaded from C</etc/crossfire/config>, or	130	Configuration for the server, loaded from C</etc/crossfire/config>, or
69	from wherever your confdir points to.	131	from wherever your confdir points to.
		132
		133	=item $cf::WAIT_FOR_TICK, $cf::WAIT_FOR_TICK_ONE
		134
		135	These are Coro::Signal objects that are C<< ->broadcast >> (WAIT_FOR_TICK)
		136	or C<< ->send >> (WAIT_FOR_TICK_ONE) on after normal server tick
		137	processing has been done. Call C<< ->wait >> on them to maximise the
		138	window of cpu time available, or simply to synchronise to the server tick.
70		139
71	=back	140	=back
72		141
73	=cut	142	=cut
74		143
75	BEGIN {	144	BEGIN {
76	*CORE::GLOBAL::warn = sub {	145	*CORE::GLOBAL::warn = sub {
77	my $msg = join "", @_;	146	my $msg = join "", @_;
		147	utf8::encode $msg;
		148
78	$msg .= "\n"	149	$msg .= "\n"
79	unless $msg =~ /\n$/;	150	unless $msg =~ /\n$/;
80		151
81	print STDERR "cfperl: $msg";
82	LOG llevError, "cfperl: $msg";	152	LOG llevError, $msg;
83	};	153	};
84	}	154	}
85		155
86	@safe::cf::global::ISA = @cf::global::ISA = 'cf::attachable';	156	@safe::cf::global::ISA = @cf::global::ISA = 'cf::attachable';
87	@safe::cf::object::ISA = @cf::object::ISA = 'cf::attachable';	157	@safe::cf::object::ISA = @cf::object::ISA = 'cf::attachable';
…		…
105		175
106	$Event::DIED = sub {	176	$Event::DIED = sub {
107	warn "error in event callback: @_";	177	warn "error in event callback: @_";
108	};	178	};
109		179
110	my %ext_pkg;
111	my @exts;
112	my @hook;
113
114	=head2 UTILITY FUNCTIONS	180	=head2 UTILITY FUNCTIONS
115		181
116	=over 4	182	=over 4
117		183
		184	=item dumpval $ref
		185
118	=cut	186	=cut
		187
		188	sub dumpval {
		189	eval {
		190	local $SIG{__DIE__};
		191	my $d;
		192	if (1) {
		193	$d = new Data::Dumper([$_[0]], ["*var"]);
		194	$d->Terse(1);
		195	$d->Indent(2);
		196	$d->Quotekeys(0);
		197	$d->Useqq(1);
		198	#$d->Bless(...);
		199	$d->Seen($_[1]) if @_ > 1;
		200	$d = $d->Dump();
		201	}
		202	$d =~ s/([\x00-\x07\x09\x0b\x0c\x0e-\x1f])/sprintf "\\x%02x", ord($1)/ge;
		203	$d
		204	} || "[unable to dump $_[0]: '$@']";
		205	}
119		206
120	use JSON::Syck (); # TODO# replace by JSON::PC once working	207	use JSON::Syck (); # TODO# replace by JSON::PC once working
121		208
122	=item $ref = cf::from_json $json	209	=item $ref = cf::from_json $json
123		210
…		…
137	=cut	224	=cut
138		225
139	sub to_json($) {	226	sub to_json($) {
140	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs	227	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs
141	JSON::Syck::Dump $_[0]	228	JSON::Syck::Dump $_[0]
		229	}
		230
		231	=item cf::lock_wait $string
		232
		233	Wait until the given lock is available. See cf::lock_acquire.
		234
		235	=item my $lock = cf::lock_acquire $string
		236
		237	Wait until the given lock is available and then acquires it and returns
		238	a Coro::guard object. If the guard object gets destroyed (goes out of scope,
		239	for example when the coroutine gets canceled), the lock is automatically
		240	returned.
		241
		242	Lock names should begin with a unique identifier (for example, cf::map::find
		243	uses map_find and cf::map::load uses map_load).
		244
		245	=cut
		246
		247	our %LOCK;
		248
		249	sub lock_wait($) {
		250	my ($key) = @_;
		251
		252	# wait for lock, if any
		253	while ($LOCK{$key}) {
		254	push @{ $LOCK{$key} }, $Coro::current;
		255	Coro::schedule;
		256	}
		257	}
		258
		259	sub lock_acquire($) {
		260	my ($key) = @_;
		261
		262	# wait, to be sure we are not locked
		263	lock_wait $key;
		264
		265	$LOCK{$key} = [];
		266
		267	Coro::guard {
		268	# wake up all waiters, to be on the safe side
		269	$_->ready for @{ delete $LOCK{$key} };
		270	}
		271	}
		272
		273	sub freeze_mainloop {
		274	return unless $TICK_WATCHER->is_active;
		275
		276	my $guard = Coro::guard {
		277	$TICK_WATCHER->start;
		278	};
		279	$TICK_WATCHER->stop;
		280	$guard
		281	}
		282
		283	=item cf::async { BLOCK }
		284
		285	Currently the same as Coro::async_pool, meaning you cannot use
		286	C<on_destroy>, C<join> or other gimmicks on these coroutines. The only
		287	thing you are allowed to do is call C<prio> on it.
		288
		289	=cut
		290
		291	BEGIN { *async = \&Coro::async_pool }
		292
		293	=item cf::sync_job { BLOCK }
		294
		295	The design of crossfire+ requires that the main coro ($Coro::main) is
		296	always able to handle events or runnable, as crossfire+ is only partly
		297	reentrant. Thus "blocking" it by e.g. waiting for I/O is not acceptable.
		298
		299	If it must be done, put the blocking parts into C<sync_job>. This will run
		300	the given BLOCK in another coroutine while waiting for the result. The
		301	server will be frozen during this time, so the block should either finish
		302	fast or be very important.
		303
		304	=cut
		305
		306	sub sync_job(&) {
		307	my ($job) = @_;
		308
		309	if ($Coro::current == $Coro::main) {
		310	# this is the main coro, too bad, we have to block
		311	# till the operation succeeds, freezing the server :/
		312
		313	# TODO: use suspend/resume instead
		314	# (but this is cancel-safe)
		315	my $freeze_guard = freeze_mainloop;
		316
		317	my $busy = 1;
		318	my @res;
		319
		320	(async {
		321	@res = eval { $job->() };
		322	warn $@ if $@;
		323	undef $busy;
		324	})->prio (Coro::PRIO_MAX);
		325
		326	while ($busy) {
		327	Coro::cede or Event::one_event;
		328	}
		329
		330	wantarray ? @res : $res[0]
		331	} else {
		332	# we are in another coroutine, how wonderful, everything just works
		333
		334	$job->()
		335	}
		336	}
		337
		338	=item $coro = cf::async_ext { BLOCK }
		339
		340	Like async, but this coro is automatically being canceled when the
		341	extension calling this is being unloaded.
		342
		343	=cut
		344
		345	sub async_ext(&) {
		346	my $cb = shift;
		347
		348	my $coro = &Coro::async ($cb);
		349
		350	$coro->on_destroy (sub {
		351	delete $EXT_CORO{$coro+0};
		352	});
		353	$EXT_CORO{$coro+0} = $coro;
		354
		355	$coro
		356	}
		357
		358	sub write_runtime {
		359	my $guard = cf::lock_acquire "write_runtime";
		360
		361	my $runtime = cf::localdir . "/runtime";
		362
		363	my $fh = aio_open "$runtime~", O_WRONLY | O_CREAT, 0644
		364	or return;
		365
		366	my $value = $cf::RUNTIME + 90 + 10;
		367	# 10 is the runtime save interval, for a monotonic clock
		368	# 60 allows for the watchdog to kill the server.
		369
		370	(aio_write $fh, 0, (length $value), $value, 0) <= 0
		371	and return;
		372
		373	# always fsync - this file is important
		374	aio_fsync $fh
		375	and return;
		376
		377	close $fh
		378	or return;
		379
		380	aio_rename "$runtime~", $runtime
		381	and return;
		382
		383	1
142	}	384	}
143		385
144	=back	386	=back
145		387
146	=cut	388	=cut
…		…
277	our @CB_TYPE = (); # registry for type (cf-object class) based events	519	our @CB_TYPE = (); # registry for type (cf-object class) based events
278	our @CB_MAP = ();	520	our @CB_MAP = ();
279		521
280	my %attachment;	522	my %attachment;
281		523
		524	sub cf::attachable::thawer_merge {
		525	# simply override everything except _meta
		526	local $_[0]{_meta};
		527	%{$_[0]} = %{$_[1]};
		528	}
		529
282	sub _attach_cb($$$$) {	530	sub _attach_cb($$$$) {
283	my ($registry, $event, $prio, $cb) = @_;	531	my ($registry, $event, $prio, $cb) = @_;
284		532
285	use sort 'stable';	533	use sort 'stable';
286		534
…		…
457	# object support	705	# object support
458		706
459	sub reattach {	707	sub reattach {
460	# basically do the same as instantiate, without calling instantiate	708	# basically do the same as instantiate, without calling instantiate
461	my ($obj) = @_;	709	my ($obj) = @_;
		710
		711	bless $obj, ref $obj; # re-bless in case extensions have been reloaded
462		712
463	my $registry = $obj->registry;	713	my $registry = $obj->registry;
464		714
465	@$registry = ();	715	@$registry = ();
466		716
…		…
505	);	755	);
506		756
507	sub object_freezer_save {	757	sub object_freezer_save {
508	my ($filename, $rdata, $objs) = @_;	758	my ($filename, $rdata, $objs) = @_;
509		759
		760	sync_job {
510	if (length $$rdata) {	761	if (length $$rdata) {
511	warn sprintf "saving %s (%d,%d)\n",	762	warn sprintf "saving %s (%d,%d)\n",
512	$filename, length $$rdata, scalar @$objs;	763	$filename, length $$rdata, scalar @$objs;
513		764
514	if (open my $fh, ">:raw", "$filename~") {	765	if (my $fh = aio_open "$filename~", O_WRONLY | O_CREAT, 0600) {
515	chmod SAVE_MODE, $fh;
516	syswrite $fh, $$rdata;
517	close $fh;
518
519	if (@$objs && open my $fh, ">:raw", "$filename.pst~") {
520	chmod SAVE_MODE, $fh;	766	chmod SAVE_MODE, $fh;
521	syswrite $fh, Storable::nfreeze { version => 1, objs => $objs };	767	aio_write $fh, 0, (length $$rdata), $$rdata, 0;
		768	aio_fsync $fh if $cf::USE_FSYNC;
522	close $fh;	769	close $fh;
		770
		771	if (@$objs) {
		772	if (my $fh = aio_open "$filename.pst~", O_WRONLY | O_CREAT, 0600) {
		773	chmod SAVE_MODE, $fh;
		774	my $data = Storable::nfreeze { version => 1, objs => $objs };
		775	aio_write $fh, 0, (length $data), $data, 0;
		776	aio_fsync $fh if $cf::USE_FSYNC;
		777	close $fh;
523	rename "$filename.pst~", "$filename.pst";	778	aio_rename "$filename.pst~", "$filename.pst";
		779	}
		780	} else {
		781	aio_unlink "$filename.pst";
		782	}
		783
		784	aio_rename "$filename~", $filename;
524	} else {	785	} else {
525	unlink "$filename.pst";	786	warn "FATAL: $filename~: $!\n";
526	}	787	}
527
528	rename "$filename~", $filename;
529	} else {	788	} else {
530	warn "FATAL: $filename~: $!\n";
531	}
532	} else {
533	unlink $filename;	789	aio_unlink $filename;
534	unlink "$filename.pst";	790	aio_unlink "$filename.pst";
		791	}
535	}	792	}
536	}	793	}
537		794
538	sub object_freezer_as_string {	795	sub object_freezer_as_string {
539	my ($rdata, $objs) = @_;	796	my ($rdata, $objs) = @_;
…		…
544	}	801	}
545		802
546	sub object_thawer_load {	803	sub object_thawer_load {
547	my ($filename) = @_;	804	my ($filename) = @_;
548		805
549	local $/;	806	my ($data, $av);
550		807
551	my $av;	808	(aio_load $filename, $data) >= 0
		809	or return;
552		810
553	#TODO: use sysread etc.	811	unless (aio_stat "$filename.pst") {
554	if (open my $data, "<:raw:perlio", $filename) {	812	(aio_load "$filename.pst", $av) >= 0
555	$data = <$data>;	813	or return;
556	if (open my $pst, "<:raw:perlio", "$filename.pst") {
557	$av = eval { (Storable::thaw <$pst>)->{objs} };	814	$av = eval { (Storable::thaw $av)->{objs} };
558	}	815	}
		816
		817	warn sprintf "loading %s (%d)\n",
		818	$filename, length $data, scalar @{$av || []};#d#
559	return ($data, $av);	819	return ($data, $av);
560	}
561
562	()
563	}	820	}
564		821
565	#############################################################################	822	#############################################################################
566	# command handling &c	823	# command handling &c
567		824
…		…
591	=cut	848	=cut
592		849
593	sub register_extcmd {	850	sub register_extcmd {
594	my ($name, $cb) = @_;	851	my ($name, $cb) = @_;
595		852
596	my $caller = caller;
597	#warn "registering extcmd '$name' to '$caller'";
598
599	$EXTCMD{$name} = [$cb, $caller];	853	$EXTCMD{$name} = $cb;
600	}	854	}
601		855
602	cf::player->attach (	856	cf::player->attach (
603	on_command => sub {	857	on_command => sub {
604	my ($pl, $name, $params) = @_;	858	my ($pl, $name, $params) = @_;
…		…
617		871
618	my $msg = eval { from_json $buf };	872	my $msg = eval { from_json $buf };
619		873
620	if (ref $msg) {	874	if (ref $msg) {
621	if (my $cb = $EXTCMD{$msg->{msgtype}}) {	875	if (my $cb = $EXTCMD{$msg->{msgtype}}) {
622	if (my %reply = $cb->[0]->($pl, $msg)) {	876	if (my %reply = $cb->($pl, $msg)) {
623	$pl->ext_reply ($msg->{msgid}, %reply);	877	$pl->ext_reply ($msg->{msgid}, %reply);
624	}	878	}
625	}	879	}
626	} else {	880	} else {
627	warn "player " . ($pl->ob->name) . " sent unparseable ext message: <$buf>\n";	881	warn "player " . ($pl->ob->name) . " sent unparseable ext message: <$buf>\n";
…		…
629		883
630	cf::override;	884	cf::override;
631	},	885	},
632	);	886	);
633		887
634	sub register {
635	my ($base, $pkg) = @_;
636
637	#TODO
638	}
639
640	sub load_extension {	888	sub load_extension {
641	my ($path) = @_;	889	my ($path) = @_;
642		890
643	$path =~ /([^\/\\]+)\.ext$/ or die "$path";	891	$path =~ /([^\/\\]+)\.ext$/ or die "$path";
644	my $base = $1;	892	my $base = $1;
645	my $pkg = $1;	893	my $pkg = $1;
646	$pkg =~ s/[^[:word:]]/_/g;	894	$pkg =~ s/[^[:word:]]/_/g;
647	$pkg = "ext::$pkg";	895	$pkg = "ext::$pkg";
648		896
649	warn "loading '$path' into '$pkg'\n";	897	warn "... loading '$path' into '$pkg'\n";
650		898
651	open my $fh, "<:utf8", $path	899	open my $fh, "<:utf8", $path
652	or die "$path: $!";	900	or die "$path: $!";
653		901
654	my $source =	902	my $source =
655	"package $pkg; use strict; use utf8;\n"	903	"package $pkg; use strict; use utf8;\n"
656	. "#line 1 \"$path\"\n{\n"	904	. "#line 1 \"$path\"\n{\n"
657	. (do { local $/; <$fh> })	905	. (do { local $/; <$fh> })
658	. "\n};\n1";	906	. "\n};\n1";
659		907
660	eval $source	908	unless (eval $source) {
661	or die $@ ? "$path: $@\n"	909	my $msg = $@ ? "$path: $@\n"
662	: "extension disabled.\n";	910	: "extension disabled.\n";
663		911	if ($source =~ /^#!.*perl.*#.*MANDATORY/m) { # ugly match
664	push @exts, $pkg;	912	warn $@;
665	$ext_pkg{$base} = $pkg;	913	warn "mandatory extension failed to load, exiting.\n";
666		914	exit 1;
667	# no strict 'refs';	915	}
668	# @{"$pkg\::ISA"} = ext::;	916	die $@;
669
670	register $base, $pkg;
671	}
672
673	sub unload_extension {
674	my ($pkg) = @_;
675
676	warn "removing extension $pkg\n";
677
678	# remove hooks
679	#TODO
680	# for my $idx (0 .. $#PLUGIN_EVENT) {
681	# delete $hook[$idx]{$pkg};
682	# }	917	}
683		918
684	# remove commands	919	push @EXTS, $pkg;
685	for my $name (keys %COMMAND) {
686	my @cb = grep $_->[0] ne $pkg, @{ $COMMAND{$name} };
687
688	if (@cb) {
689	$COMMAND{$name} = \@cb;
690	} else {
691	delete $COMMAND{$name};
692	}
693	}
694
695	# remove extcmds
696	for my $name (grep $EXTCMD{$_}[1] eq $pkg, keys %EXTCMD) {
697	delete $EXTCMD{$name};
698	}
699
700	if (my $cb = $pkg->can ("unload")) {
701	eval {
702	$cb->($pkg);
703	1
704	} or warn "$pkg unloaded, but with errors: $@";
705	}
706
707	Symbol::delete_package $pkg;
708	}	920	}
709		921
710	sub load_extensions {	922	sub load_extensions {
711	for my $ext (<$LIBDIR/*.ext>) {	923	for my $ext (<$LIBDIR/*.ext>) {
712	next unless -r $ext;	924	next unless -r $ext;
…		…
716	} or warn "$ext not loaded: $@";	928	} or warn "$ext not loaded: $@";
717	}	929	}
718	}	930	}
719		931
720	#############################################################################	932	#############################################################################
721	# load/save/clean perl data associated with a map
722		933
723	*cf::mapsupport::on_clean = sub {	934	=head2 CORE EXTENSIONS
		935
		936	Functions and methods that extend core crossfire objects.
		937
		938	=cut
		939
		940	package cf::player;
		941
		942	use Coro::AIO;
		943
		944	=head3 cf::player
		945
		946	=over 4
		947
		948	=item cf::player::find $login
		949
		950	Returns the given player object, loading it if necessary (might block).
		951
		952	=cut
		953
		954	sub playerdir($) {
		955	cf::localdir
		956	. "/"
		957	. cf::playerdir
		958	. "/"
		959	. (ref $_[0] ? $_[0]->ob->name : $_[0])
		960	}
		961
		962	sub path($) {
		963	my $login = ref $_[0] ? $_[0]->ob->name : $_[0];
		964
		965	(playerdir $login) . "/$login.pl"
		966	}
		967
		968	sub find_active($) {
		969	$cf::PLAYER{$_[0]}
		970	and $cf::PLAYER{$_[0]}->active
		971	and $cf::PLAYER{$_[0]}
		972	}
		973
		974	sub exists($) {
		975	my ($login) = @_;
		976
		977	$cf::PLAYER{$login}
		978	or cf::sync_job { !aio_stat path $login }
		979	}
		980
		981	sub find($) {
		982	return $cf::PLAYER{$_[0]} || do {
		983	my $login = $_[0];
		984
		985	my $guard = cf::lock_acquire "user_find:$login";
		986
		987	$cf::PLAYER{$_[0]} || do {
		988	my $pl = load_pl path $login
		989	or return;
		990	$cf::PLAYER{$login} = $pl
		991	}
		992	}
		993	}
		994
		995	sub save($) {
		996	my ($pl) = @_;
		997
		998	return if $pl->{deny_save};
		999
		1000	my $path = path $pl;
		1001	my $guard = cf::lock_acquire "user_save:$path";
		1002
		1003	return if $pl->{deny_save};
		1004
		1005	aio_mkdir playerdir $pl, 0770;
		1006	$pl->{last_save} = $cf::RUNTIME;
		1007
		1008	$pl->save_pl ($path);
		1009	Coro::cede;
		1010	}
		1011
		1012	sub new($) {
		1013	my ($login) = @_;
		1014
		1015	my $self = create;
		1016
		1017	$self->ob->name ($login);
		1018	$self->{deny_save} = 1;
		1019
		1020	$cf::PLAYER{$login} = $self;
		1021
		1022	$self
		1023	}
		1024
		1025	=item $pl->quit_character
		1026
		1027	Nukes the player without looking back. If logged in, the connection will
		1028	be destroyed. May block for a long time.
		1029
		1030	=cut
		1031
		1032	sub quit_character {
		1033	my ($pl) = @_;
		1034
		1035	$pl->{deny_save} = 1;
		1036	$pl->password ("*"); # this should lock out the player until we nuked the dir
		1037
		1038	$pl->invoke (cf::EVENT_PLAYER_LOGOUT, 1) if $pl->active;
		1039	$pl->deactivate;
		1040	$pl->invoke (cf::EVENT_PLAYER_QUIT);
		1041	$pl->ns->destroy if $pl->ns;
		1042
		1043	my $path = playerdir $pl;
		1044	my $temp = "$path~$cf::RUNTIME~deleting~";
		1045	aio_rename $path, $temp;
		1046	delete $cf::PLAYER{$pl->ob->name};
		1047	$pl->destroy;
		1048	IO::AIO::aio_rmtree $temp;
		1049	}
		1050
		1051	=item cf::player::list_logins
		1052
		1053	Returns am arrayref of all valid playernames in the system, can take a
		1054	while and may block, so not sync_job-capable, ever.
		1055
		1056	=cut
		1057
		1058	sub list_logins {
		1059	my $dirs = aio_readdir cf::localdir . "/" . cf::playerdir
		1060	or return [];
		1061
		1062	my @logins;
		1063
		1064	for my $login (@$dirs) {
		1065	my $fh = aio_open path $login, Fcntl::O_RDONLY, 0 or next;
		1066	aio_read $fh, 0, 512, my $buf, 0 or next;
		1067	$buf !~ /^password -------------$/m or next; # official not-valid tag
		1068
		1069	utf8::decode $login;
		1070	push @logins, $login;
		1071	}
		1072
		1073	\@logins
		1074	}
		1075
		1076	=item $player->maps
		1077
		1078	Returns an arrayref of map paths that are private for this
		1079	player. May block.
		1080
		1081	=cut
		1082
		1083	sub maps($) {
		1084	my ($pl) = @_;
		1085
		1086	$pl = ref $pl ? $pl->ob->name : $pl;
		1087
		1088	my $files = aio_readdir playerdir $pl
		1089	or return;
		1090
		1091	my @paths;
		1092
		1093	for (@$files) {
		1094	utf8::decode $_;
		1095	next if /\.(?:pl|pst)$/;
		1096	next unless /^$PATH_SEP/o;
		1097
		1098	push @paths, cf::map::normalise "~$pl/$_";
		1099	}
		1100
		1101	\@paths
		1102	}
		1103
		1104	=item $player->ext_reply ($msgid, $msgtype, %msg)
		1105
		1106	Sends an ext reply to the player.
		1107
		1108	=cut
		1109
		1110	sub ext_reply($$$%) {
		1111	my ($self, $id, %msg) = @_;
		1112
		1113	$msg{msgid} = $id;
		1114
		1115	$self->send ("ext " . cf::to_json \%msg);
		1116	}
		1117
		1118	package cf;
		1119
		1120	=back
		1121
		1122
		1123	=head3 cf::map
		1124
		1125	=over 4
		1126
		1127	=cut
		1128
		1129	package cf::map;
		1130
		1131	use Fcntl;
		1132	use Coro::AIO;
		1133
		1134	use overload
		1135	'""' => \&as_string,
		1136	fallback => 1;
		1137
		1138	our $MAX_RESET = 3600;
		1139	our $DEFAULT_RESET = 3000;
		1140
		1141	sub generate_random_map {
		1142	my ($self, $rmp) = @_;
		1143	# mit "rum" bekleckern, nicht
		1144	$self->_create_random_map (
		1145	$rmp->{wallstyle}, $rmp->{wall_name}, $rmp->{floorstyle}, $rmp->{monsterstyle},
		1146	$rmp->{treasurestyle}, $rmp->{layoutstyle}, $rmp->{doorstyle}, $rmp->{decorstyle},
		1147	$rmp->{origin_map}, $rmp->{final_map}, $rmp->{exitstyle}, $rmp->{this_map},
		1148	$rmp->{exit_on_final_map},
		1149	$rmp->{xsize}, $rmp->{ysize},
		1150	$rmp->{expand2x}, $rmp->{layoutoptions1}, $rmp->{layoutoptions2}, $rmp->{layoutoptions3},
		1151	$rmp->{symmetry}, $rmp->{difficulty}, $rmp->{difficulty_given}, $rmp->{difficulty_increase},
		1152	$rmp->{dungeon_level}, $rmp->{dungeon_depth}, $rmp->{decoroptions}, $rmp->{orientation},
		1153	$rmp->{origin_y}, $rmp->{origin_x}, $rmp->{random_seed}, $rmp->{total_map_hp},
		1154	$rmp->{map_layout_style}, $rmp->{treasureoptions}, $rmp->{symmetry_used},
		1155	(cf::region::find $rmp->{region}), $rmp->{custom}
		1156	)
		1157	}
		1158
		1159	=item cf::map->register ($regex, $prio)
		1160
		1161	Register a handler for the map path matching the given regex at the
		1162	givne priority (higher is better, built-in handlers have priority 0, the
		1163	default).
		1164
		1165	=cut
		1166
		1167	sub register {
		1168	my (undef, $regex, $prio) = @_;
		1169	my $pkg = caller;
		1170
		1171	no strict;
		1172	push @{"$pkg\::ISA"}, __PACKAGE__;
		1173
		1174	$EXT_MAP{$pkg} = [$prio, qr<$regex>];
		1175	}
		1176
		1177	# also paths starting with '/'
		1178	$EXT_MAP{"cf::map"} = [0, qr{^(?=/)}];
		1179
		1180	sub thawer_merge {
		1181	my ($self, $merge) = @_;
		1182
		1183	# we have to keep some variables in memory intact
		1184	local $self->{path};
		1185	local $self->{load_path};
		1186	local $self->{deny_save};
		1187	local $self->{deny_reset};
		1188
		1189	$self->SUPER::thawer_merge ($merge);
		1190	}
		1191
		1192	sub normalise {
		1193	my ($path, $base) = @_;
		1194
		1195	$path = "$path"; # make sure its a string
		1196
		1197	$path =~ s/\.map$//;
		1198
		1199	# map plan:
		1200	#
		1201	# /! non-realised random map exit (special hack!)
		1202	# {... are special paths that are not being touched
		1203	# ?xxx/... are special absolute paths
		1204	# ?random/... random maps
		1205	# /... normal maps
		1206	# ~user/... per-player map of a specific user
		1207
		1208	$path =~ s/$PATH_SEP/\//go;
		1209
		1210	# treat it as relative path if it starts with
		1211	# something that looks reasonable
		1212	if ($path =~ m{^(?:\./|\.\./|\w)}) {
		1213	$base or Carp::carp "normalise called with relative path and no base: '$path'";
		1214
		1215	$base =~ s{[^/]+/?$}{};
		1216	$path = "$base/$path";
		1217	}
		1218
		1219	for ($path) {
		1220	redo if s{//}{/};
		1221	redo if s{/\.?/}{/};
		1222	redo if s{/[^/]+/\.\./}{/};
		1223	}
		1224
		1225	$path
		1226	}
		1227
		1228	sub new_from_path {
		1229	my (undef, $path, $base) = @_;
		1230
		1231	return $path if UNIVERSAL::isa $path, "cf::map"; # already a map object
		1232
		1233	$path = normalise $path, $base;
		1234
		1235	for my $pkg (sort { $EXT_MAP{$b}[0] <=> $EXT_MAP{$a}[0] } keys %EXT_MAP) {
		1236	if ($path =~ $EXT_MAP{$pkg}[1]) {
		1237	my $self = bless cf::map::new, $pkg;
		1238	$self->{path} = $path; $self->path ($path);
		1239	$self->init; # pass $1 etc.
		1240	return $self;
		1241	}
		1242	}
		1243
		1244	Carp::carp "unable to resolve path '$path' (base '$base').";
		1245	()
		1246	}
		1247
		1248	sub init {
		1249	my ($self) = @_;
		1250
		1251	$self
		1252	}
		1253
		1254	sub as_string {
		1255	my ($self) = @_;
		1256
		1257	"$self->{path}"
		1258	}
		1259
		1260	# the displayed name, this is a one way mapping
		1261	sub visible_name {
		1262	&as_string
		1263	}
		1264
		1265	# the original (read-only) location
		1266	sub load_path {
		1267	my ($self) = @_;
		1268
		1269	sprintf "%s/%s/%s.map", cf::datadir, cf::mapdir, $self->{path}
		1270	}
		1271
		1272	# the temporary/swap location
		1273	sub save_path {
		1274	my ($self) = @_;
		1275
		1276	(my $path = $_[0]{path}) =~ s/\//$PATH_SEP/g;
		1277	sprintf "%s/%s/%s.map", cf::localdir, cf::tmpdir, $path
		1278	}
		1279
		1280	# the unique path, undef == no special unique path
		1281	sub uniq_path {
		1282	my ($self) = @_;
		1283
		1284	(my $path = $_[0]{path}) =~ s/\//$PATH_SEP/g;
		1285	sprintf "%s/%s/%s", cf::localdir, cf::uniquedir, $path
		1286	}
		1287
		1288	# and all this just because we cannot iterate over
		1289	# all maps in C++...
		1290	sub change_all_map_light {
		1291	my ($change) = @_;
		1292
		1293	$_->change_map_light ($change)
		1294	for grep $_->outdoor, values %cf::MAP;
		1295	}
		1296
		1297	sub unlink_save {
		1298	my ($self) = @_;
		1299
		1300	utf8::encode (my $save = $self->save_path);
		1301	IO::AIO::aioreq_pri 4; Coro::AIO::aio_unlink $save;
		1302	IO::AIO::aioreq_pri 4; Coro::AIO::aio_unlink "$save.pst";
		1303	}
		1304
		1305	sub load_header_from($) {
		1306	my ($self, $path) = @_;
		1307
		1308	utf8::encode $path;
		1309	#aio_open $path, O_RDONLY, 0
		1310	# or return;
		1311
		1312	$self->_load_header ($path)
		1313	or return;
		1314
		1315	$self->{load_path} = $path;
		1316
		1317	1
		1318	}
		1319
		1320	sub load_header_orig {
		1321	my ($self) = @_;
		1322
		1323	$self->load_header_from ($self->load_path)
		1324	}
		1325
		1326	sub load_header_temp {
		1327	my ($self) = @_;
		1328
		1329	$self->load_header_from ($self->save_path)
		1330	}
		1331
		1332	sub prepare_temp {
		1333	my ($self) = @_;
		1334
		1335	$self->last_access ((delete $self->{last_access})
		1336	|| $cf::RUNTIME); #d#
		1337	# safety
		1338	$self->{instantiate_time} = $cf::RUNTIME
		1339	if $self->{instantiate_time} > $cf::RUNTIME;
		1340	}
		1341
		1342	sub prepare_orig {
		1343	my ($self) = @_;
		1344
		1345	$self->{load_original} = 1;
		1346	$self->{instantiate_time} = $cf::RUNTIME;
		1347	$self->last_access ($cf::RUNTIME);
		1348	$self->instantiate;
		1349	}
		1350
		1351	sub load_header {
		1352	my ($self) = @_;
		1353
		1354	if ($self->load_header_temp) {
		1355	$self->prepare_temp;
		1356	} else {
		1357	$self->load_header_orig
		1358	or return;
		1359	$self->prepare_orig;
		1360	}
		1361
		1362	1
		1363	}
		1364
		1365	sub find;
		1366	sub find {
		1367	my ($path, $origin) = @_;
		1368
		1369	$path = normalise $path, $origin && $origin->path;
		1370
		1371	cf::lock_wait "map_find:$path";
		1372
		1373	$cf::MAP{$path} || do {
		1374	my $guard = cf::lock_acquire "map_find:$path";
		1375	my $map = new_from_path cf::map $path
		1376	or return;
		1377
		1378	$map->{last_save} = $cf::RUNTIME;
		1379
		1380	$map->load_header
		1381	or return;
		1382
		1383	if ($map->should_reset && 0) {#d#TODO# disabled, crashy (locking issue?)
		1384	# doing this can freeze the server in a sync job, obviously
		1385	#$cf::WAIT_FOR_TICK->wait;
		1386	$map->reset;
		1387	undef $guard;
		1388	return find $path;
		1389	}
		1390
		1391	$cf::MAP{$path} = $map
		1392	}
		1393	}
		1394
		1395	sub pre_load { }
		1396	sub post_load { }
		1397
		1398	sub load {
		1399	my ($self) = @_;
		1400
		1401	local $self->{deny_reset} = 1; # loading can take a long time
		1402
		1403	my $path = $self->{path};
		1404	my $guard = cf::lock_acquire "map_load:$path";
		1405
		1406	return if $self->in_memory != cf::MAP_SWAPPED;
		1407
		1408	$self->in_memory (cf::MAP_LOADING);
		1409
		1410	$self->alloc;
		1411
		1412	$self->pre_load;
		1413
		1414	$self->_load_objects ($self->{load_path}, 1)
		1415	or return;
		1416
		1417	$self->set_object_flag (cf::FLAG_OBJ_ORIGINAL, 1)
		1418	if delete $self->{load_original};
		1419
		1420	if (my $uniq = $self->uniq_path) {
		1421	utf8::encode $uniq;
		1422	if (aio_open $uniq, O_RDONLY, 0) {
		1423	$self->clear_unique_items;
		1424	$self->_load_objects ($uniq, 0);
		1425	}
		1426	}
		1427
		1428	Coro::cede;
		1429
		1430	# now do the right thing for maps
		1431	$self->link_multipart_objects;
		1432
		1433	unless ($self->{deny_activate}) {
		1434	$self->decay_objects;
		1435	$self->fix_auto_apply;
		1436	$self->update_buttons;
		1437	Coro::cede;
		1438	$self->set_darkness_map;
		1439	$self->difficulty ($self->estimate_difficulty)
		1440	unless $self->difficulty;
		1441	Coro::cede;
		1442	$self->activate;
		1443	}
		1444
		1445	$self->post_load;
		1446
		1447	$self->in_memory (cf::MAP_IN_MEMORY);
		1448	}
		1449
		1450	sub customise_for {
		1451	my ($self, $ob) = @_;
		1452
		1453	return find "~" . $ob->name . "/" . $self->{path}
		1454	if $self->per_player;
		1455
		1456	$self
		1457	}
		1458
		1459	# find and load all maps in the 3x3 area around a map
		1460	sub load_diag {
724	my ($map) = @_;	1461	my ($map) = @_;
725		1462
726	my $path = $map->tmpname;	1463	my @diag; # diagonal neighbours
727	defined $path or return;
728		1464
729	unlink "$path.pst";	1465	for (0 .. 3) {
730	};	1466	my $neigh = $map->tile_path ($_)
		1467	or next;
		1468	$neigh = find $neigh, $map
		1469	or next;
		1470	$neigh->load;
731		1471
732	cf::map->attach (prio => -10000, package => cf::mapsupport::);	1472	push @diag, [$neigh->tile_path (($_ + 3) % 4), $neigh],
		1473	[$neigh->tile_path (($_ + 1) % 4), $neigh];
		1474	}
733		1475
734	#############################################################################	1476	for (@diag) {
735	# load/save perl data associated with player->ob objects	1477	my $neigh = find @$_
736		1478	or next;
737	sub all_objects(@) {	1479	$neigh->load;
738	@_, map all_objects ($_->inv), @_	1480	}
739	}	1481	}
740		1482
741	# TODO: compatibility cruft, remove when no longer needed	1483	sub find_sync {
742	cf::player->attach (	1484	my ($path, $origin) = @_;
743	on_load => sub {
744	my ($pl, $path) = @_;
745		1485
746	for my $o (all_objects $pl->ob) {	1486	cf::sync_job { find $path, $origin }
747	if (my $value = $o->get_ob_key_value ("_perl_data")) {	1487	}
748	$o->set_ob_key_value ("_perl_data");
749		1488
750	%$o = %{ Storable::thaw pack "H*", $value };	1489	sub do_load_sync {
		1490	my ($map) = @_;
		1491
		1492	cf::sync_job { $map->load };
		1493	}
		1494
		1495	our %MAP_PREFETCH;
		1496	our $MAP_PREFETCHER = undef;
		1497
		1498	sub find_async {
		1499	my ($path, $origin) = @_;
		1500
		1501	$path = normalise $path, $origin && $origin->{path};
		1502
		1503	if (my $map = $cf::MAP{$path}) {
		1504	return $map if $map->in_memory == cf::MAP_IN_MEMORY;
		1505	}
		1506
		1507	undef $MAP_PREFETCH{$path};
		1508	$MAP_PREFETCHER ||= cf::async {
		1509	while (%MAP_PREFETCH) {
		1510	for my $path (keys %MAP_PREFETCH) {
		1511	my $map = find $path
		1512	or next;
		1513	$map->load;
		1514
		1515	delete $MAP_PREFETCH{$path};
751	}	1516	}
752	}	1517	}
		1518	undef $MAP_PREFETCHER;
		1519	};
		1520	$MAP_PREFETCHER->prio (6);
		1521
		1522	()
		1523	}
		1524
		1525	sub save {
		1526	my ($self) = @_;
		1527
		1528	my $lock = cf::lock_acquire "map_data:" . $self->path;
		1529
		1530	$self->{last_save} = $cf::RUNTIME;
		1531
		1532	return unless $self->dirty;
		1533
		1534	my $save = $self->save_path; utf8::encode $save;
		1535	my $uniq = $self->uniq_path; utf8::encode $uniq;
		1536
		1537	$self->{load_path} = $save;
		1538
		1539	return if $self->{deny_save};
		1540
		1541	local $self->{last_access} = $self->last_access;#d#
		1542
		1543	cf::async {
		1544	$_->contr->save for $self->players;
		1545	};
		1546
		1547	if ($uniq) {
		1548	$self->_save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS);
		1549	$self->_save_objects ($uniq, cf::IO_UNIQUES);
		1550	} else {
		1551	$self->_save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS | cf::IO_UNIQUES);
753	},	1552	}
754	);	1553	}
755		1554
756	#############################################################################	1555	sub swap_out {
		1556	my ($self) = @_;
757		1557
758	=head2 CORE EXTENSIONS	1558	# save first because save cedes
		1559	$self->save;
759		1560
760	Functions and methods that extend core crossfire objects.	1561	my $lock = cf::lock_acquire "map_data:" . $self->path;
761		1562
762	=head3 cf::player	1563	return if $self->players;
		1564	return if $self->in_memory != cf::MAP_IN_MEMORY;
		1565	return if $self->{deny_save};
		1566
		1567	$self->clear;
		1568	$self->in_memory (cf::MAP_SWAPPED);
		1569	}
		1570
		1571	sub reset_at {
		1572	my ($self) = @_;
		1573
		1574	# TODO: safety, remove and allow resettable per-player maps
		1575	return 1e99 if $self->isa ("ext::map_per_player");#d#
		1576	return 1e99 if $self->{deny_reset};
		1577
		1578	my $time = $self->fixed_resettime ? $self->{instantiate_time} : $self->last_access;
		1579	my $to = List::Util::min $MAX_RESET, $self->reset_timeout || $DEFAULT_RESET;
		1580
		1581	$time + $to
		1582	}
		1583
		1584	sub should_reset {
		1585	my ($self) = @_;
		1586
		1587	$self->reset_at <= $cf::RUNTIME
		1588	}
		1589
		1590	sub reset {
		1591	my ($self) = @_;
		1592
		1593	my $lock = cf::lock_acquire "map_data:$self->{path}";
		1594
		1595	return if $self->players;
		1596	return if $self->isa ("ext::map_per_player");#d#
		1597
		1598	warn "resetting map ", $self->path;#d#
		1599
		1600	$self->in_memory (cf::MAP_SWAPPED);
		1601
		1602	# need to save uniques path
		1603	unless ($self->{deny_save}) {
		1604	my $uniq = $self->uniq_path; utf8::encode $uniq;
		1605
		1606	$self->_save_objects ($uniq, cf::IO_UNIQUES)
		1607	if $uniq;
		1608	}
		1609
		1610	delete $cf::MAP{$self->path};
		1611
		1612	$self->clear;
		1613
		1614	$_->clear_links_to ($self) for values %cf::MAP;
		1615
		1616	$self->unlink_save;
		1617	$self->destroy;
		1618	}
		1619
		1620	my $nuke_counter = "aaaa";
		1621
		1622	sub nuke {
		1623	my ($self) = @_;
		1624
		1625	delete $cf::MAP{$self->path};
		1626
		1627	$self->unlink_save;
		1628
		1629	bless $self, "cf::map";
		1630	delete $self->{deny_reset};
		1631	$self->{deny_save} = 1;
		1632	$self->reset_timeout (1);
		1633	$self->path ($self->{path} = "{nuke}/" . ($nuke_counter++));
		1634
		1635	$cf::MAP{$self->path} = $self;
		1636
		1637	$self->reset; # polite request, might not happen
		1638	}
		1639
		1640	=item cf::map::unique_maps
		1641
		1642	Returns an arrayref of paths of all shared maps that have
		1643	instantiated unique items. May block.
		1644
		1645	=cut
		1646
		1647	sub unique_maps() {
		1648	my $files = aio_readdir cf::localdir . "/" . cf::uniquedir
		1649	or return;
		1650
		1651	my @paths;
		1652
		1653	for (@$files) {
		1654	utf8::decode $_;
		1655	next if /\.pst$/;
		1656	next unless /^$PATH_SEP/o;
		1657
		1658	push @paths, cf::map::normalise $_;
		1659	}
		1660
		1661	\@paths
		1662	}
		1663
		1664	package cf;
		1665
		1666	=back
		1667
		1668	=head3 cf::object
		1669
		1670	=cut
		1671
		1672	package cf::object;
763		1673
764	=over 4	1674	=over 4
765		1675
766	=item cf::player::exists $login	1676	=item $ob->inv_recursive
767		1677
768	Returns true when the given account exists.	1678	Returns the inventory of the object _and_ their inventories, recursively.
769		1679
770	=cut	1680	=cut
771		1681
772	sub cf::player::exists($) {	1682	sub inv_recursive_;
773	cf::player::find $_[0]	1683	sub inv_recursive_ {
774	or -f sprintf "%s/%s/%s/%s.pl", cf::localdir, cf::playerdir, ($_[0]) x 2;	1684	map { $_, inv_recursive_ $_->inv } @_
775	}	1685	}
776		1686
777	=item $player->ext_reply ($msgid, $msgtype, %msg)	1687	sub inv_recursive {
778		1688	inv_recursive_ inv $_[0]
779	Sends an ext reply to the player.
780
781	=cut
782
783	sub cf::player::ext_reply($$$%) {
784	my ($self, $id, %msg) = @_;
785
786	$msg{msgid} = $id;
787
788	$self->send ("ext " . to_json \%msg);
789	}	1689	}
		1690
		1691	package cf;
790		1692
791	=back	1693	=back
792		1694
793	=head3 cf::object::player	1695	=head3 cf::object::player
794		1696
…		…
832	(ref $cf::CFG{"may_$access"}	1734	(ref $cf::CFG{"may_$access"}
833	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}	1735	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}
834	: $cf::CFG{"may_$access"})	1736	: $cf::CFG{"may_$access"})
835	}	1737	}
836		1738
		1739	=item $player_object->enter_link
		1740
		1741	Freezes the player and moves him/her to a special map (C<{link}>).
		1742
		1743	The player should be reasonably safe there for short amounts of time. You
		1744	I<MUST> call C<leave_link> as soon as possible, though.
		1745
		1746	Will never block.
		1747
		1748	=item $player_object->leave_link ($map, $x, $y)
		1749
		1750	Moves the player out of the special C<{link}> map onto the specified
		1751	map. If the map is not valid (or omitted), the player will be moved back
		1752	to the location he/she was before the call to C<enter_link>, or, if that
		1753	fails, to the emergency map position.
		1754
		1755	Might block.
		1756
		1757	=cut
		1758
		1759	sub link_map {
		1760	unless ($LINK_MAP) {
		1761	$LINK_MAP = cf::map::find "{link}"
		1762	or cf::cleanup "FATAL: unable to provide {link} map, exiting.";
		1763	$LINK_MAP->load;
		1764	}
		1765
		1766	$LINK_MAP
		1767	}
		1768
		1769	sub cf::object::player::enter_link {
		1770	my ($self) = @_;
		1771
		1772	$self->deactivate_recursive;
		1773
		1774	return if UNIVERSAL::isa $self->map, "ext::map_link";
		1775
		1776	$self->{_link_pos} ||= [$self->map->{path}, $self->x, $self->y]
		1777	if $self->map;
		1778
		1779	$self->enter_map ($LINK_MAP || link_map, 10, 10);
		1780	}
		1781
		1782	sub cf::object::player::leave_link {
		1783	my ($self, $map, $x, $y) = @_;
		1784
		1785	my $link_pos = delete $self->{_link_pos};
		1786
		1787	unless ($map) {
		1788	# restore original map position
		1789	($map, $x, $y) = @{ $link_pos || [] };
		1790	$map = cf::map::find $map;
		1791
		1792	unless ($map) {
		1793	($map, $x, $y) = @$EMERGENCY_POSITION;
		1794	$map = cf::map::find $map
		1795	or die "FATAL: cannot load emergency map\n";
		1796	}
		1797	}
		1798
		1799	($x, $y) = (-1, -1)
		1800	unless (defined $x) && (defined $y);
		1801
		1802	# use -1 or undef as default coordinates, not 0, 0
		1803	($x, $y) = ($map->enter_x, $map->enter_y)
		1804	if $x <=0 && $y <= 0;
		1805
		1806	$map->load;
		1807	$map->load_diag;
		1808
		1809	return unless $self->contr->active;
		1810	$self->activate_recursive;
		1811
		1812	local $self->{_prev_pos} = $link_pos; # ugly hack for rent.ext
		1813	$self->enter_map ($map, $x, $y);
		1814	}
		1815
		1816	cf::player->attach (
		1817	on_logout => sub {
		1818	my ($pl) = @_;
		1819
		1820	# abort map switching before logout
		1821	if ($pl->ob->{_link_pos}) {
		1822	cf::sync_job {
		1823	$pl->ob->leave_link
		1824	};
		1825	}
		1826	},
		1827	on_login => sub {
		1828	my ($pl) = @_;
		1829
		1830	# try to abort aborted map switching on player login :)
		1831	# should happen only on crashes
		1832	if ($pl->ob->{_link_pos}) {
		1833	$pl->ob->enter_link;
		1834	(async {
		1835	$pl->ob->reply (undef,
		1836	"There was an internal problem at your last logout, "
		1837	. "the server will try to bring you to your intended destination in a second.",
		1838	cf::NDI_RED);
		1839	# we need this sleep as the login has a concurrent enter_exit running
		1840	# and this sleep increases chances of the player not ending up in scorn
		1841	Coro::Timer::sleep 1;
		1842	$pl->ob->leave_link;
		1843	})->prio (2);
		1844	}
		1845	},
		1846	);
		1847
		1848	=item $player_object->goto ($path, $x, $y)
		1849
		1850	=cut
		1851
		1852	sub cf::object::player::goto {
		1853	my ($self, $path, $x, $y) = @_;
		1854
		1855	$self->enter_link;
		1856
		1857	(async {
		1858	my $map = eval {
		1859	my $map = cf::map::find $path;
		1860	$map = $map->customise_for ($self) if $map;
		1861	$map
		1862	} or
		1863	$self->message ("The exit to '$path' is closed", cf::NDI_UNIQUE | cf::NDI_RED);
		1864
		1865	$self->leave_link ($map, $x, $y);
		1866	})->prio (1);
		1867	}
		1868
		1869	=item $player_object->enter_exit ($exit_object)
		1870
		1871	=cut
		1872
		1873	sub parse_random_map_params {
		1874	my ($spec) = @_;
		1875
		1876	my $rmp = { # defaults
		1877	xsize => (cf::rndm 15, 40),
		1878	ysize => (cf::rndm 15, 40),
		1879	symmetry => (cf::rndm 1, cf::SYMMETRY_XY),
		1880	#layout => string,
		1881	};
		1882
		1883	for (split /\n/, $spec) {
		1884	my ($k, $v) = split /\s+/, $_, 2;
		1885
		1886	$rmp->{lc $k} = $v if (length $k) && (length $v);
		1887	}
		1888
		1889	$rmp
		1890	}
		1891
		1892	sub prepare_random_map {
		1893	my ($exit) = @_;
		1894
		1895	my $guard = cf::lock_acquire "exit_prepare:$exit";
		1896
		1897	# all this does is basically replace the /! path by
		1898	# a new random map path (?random/...) with a seed
		1899	# that depends on the exit object
		1900
		1901	my $rmp = parse_random_map_params $exit->msg;
		1902
		1903	if ($exit->map) {
		1904	$rmp->{region} = $exit->region->name;
		1905	$rmp->{origin_map} = $exit->map->path;
		1906	$rmp->{origin_x} = $exit->x;
		1907	$rmp->{origin_y} = $exit->y;
		1908	}
		1909
		1910	$rmp->{random_seed} ||= $exit->random_seed;
		1911
		1912	my $data = cf::to_json $rmp;
		1913	my $md5 = Digest::MD5::md5_hex $data;
		1914	my $meta = "$cf::RANDOM_MAPS/$md5.meta";
		1915
		1916	if (my $fh = aio_open "$meta~", O_WRONLY | O_CREAT, 0666) {
		1917	aio_write $fh, 0, (length $data), $data, 0;
		1918	undef $fh;
		1919	aio_rename "$meta~", $meta;
		1920
		1921	$exit->slaying ("?random/$md5");
		1922	$exit->msg (undef);
		1923	}
		1924	}
		1925
		1926	sub cf::object::player::enter_exit {
		1927	my ($self, $exit) = @_;
		1928
		1929	return unless $self->type == cf::PLAYER;
		1930
		1931	if ($exit->slaying eq "/!") {
		1932	#TODO: this should de-fi-ni-te-ly not be a sync-job
		1933	cf::sync_job { prepare_random_map $exit };
		1934	}
		1935
		1936	my $slaying = cf::map::normalise $exit->slaying, $exit->map && $exit->map->path;
		1937	my $hp = $exit->stats->hp;
		1938	my $sp = $exit->stats->sp;
		1939
		1940	$self->enter_link;
		1941
		1942	(async {
		1943	$self->deactivate_recursive; # just to be sure
		1944	unless (eval {
		1945	$self->goto ($slaying, $hp, $sp);
		1946
		1947	1;
		1948	}) {
		1949	$self->message ("Something went wrong deep within the crossfire server. "
		1950	. "I'll try to bring you back to the map you were before. "
		1951	. "Please report this to the dungeon master!",
		1952	cf::NDI_UNIQUE | cf::NDI_RED);
		1953
		1954	warn "ERROR in enter_exit: $@";
		1955	$self->leave_link;
		1956	}
		1957	})->prio (1);
		1958	}
		1959
837	=head3 cf::client	1960	=head3 cf::client
838		1961
839	=over 4	1962	=over 4
840		1963
841	=item $client->send_drawinfo ($text, $flags)	1964	=item $client->send_drawinfo ($text, $flags)
…		…
884	on_reply => sub {	2007	on_reply => sub {
885	my ($ns, $msg) = @_;	2008	my ($ns, $msg) = @_;
886		2009
887	# this weird shuffling is so that direct followup queries	2010	# this weird shuffling is so that direct followup queries
888	# get handled first	2011	# get handled first
889	my $queue = delete $ns->{query_queue};	2012	my $queue = delete $ns->{query_queue}
		2013	or return; # be conservative, not sure how that can happen, but we saw a crash here
890		2014
891	(shift @$queue)->[1]->($msg);	2015	(shift @$queue)->[1]->($msg);
		2016	return unless $ns->valid; # temporary(?) workaround for callback destroying socket
892		2017
893	push @{ $ns->{query_queue} }, @$queue;	2018	push @{ $ns->{query_queue} }, @$queue;
894		2019
895	if (@{ $ns->{query_queue} } == @$queue) {	2020	if (@{ $ns->{query_queue} } == @$queue) {
896	if (@$queue) {	2021	if (@$queue) {
…		…
900	}	2025	}
901	}	2026	}
902	},	2027	},
903	);	2028	);
904		2029
905	=item $client->coro (\&cb)	2030	=item $client->async (\&cb)
906		2031
907	Create a new coroutine, running the specified callback. The coroutine will	2032	Create a new coroutine, running the specified callback. The coroutine will
908	be automatically cancelled when the client gets destroyed (e.g. on logout,	2033	be automatically cancelled when the client gets destroyed (e.g. on logout,
909	or loss of connection).	2034	or loss of connection).
910		2035
911	=cut	2036	=cut
912		2037
913	sub cf::client::coro {	2038	sub cf::client::async {
914	my ($self, $cb) = @_;	2039	my ($self, $cb) = @_;
915		2040
916	my $coro; $coro = async {	2041	my $coro = &Coro::async ($cb);
917	eval {	2042
918	$cb->();	2043	$coro->on_destroy (sub {
919	};
920	warn $@ if $@;
921	delete $self->{_coro}{$coro+0};	2044	delete $self->{_coro}{$coro+0};
922	};	2045	});
923		2046
924	$self->{_coro}{$coro+0} = $coro;	2047	$self->{_coro}{$coro+0} = $coro;
		2048
		2049	$coro
925	}	2050	}
926		2051
927	cf::client->attach (	2052	cf::client->attach (
928	on_destroy => sub {	2053	on_destroy => sub {
929	my ($ns) = @_;	2054	my ($ns) = @_;
…		…
1057	The parameter C<$family> should best start with the name of the extension	2182	The parameter C<$family> should best start with the name of the extension
1058	using it, it should be unique.	2183	using it, it should be unique.
1059		2184
1060	=over 4	2185	=over 4
1061		2186
1062	=item $hashref = cf::db_get $family
1063
1064	Return a hashref for use by the extension C<$family>, which can be
1065	modified. After modifications, you have to call C<cf::db_dirty> or
1066	C<cf::db_sync>.
1067
1068	=item $value = cf::db_get $family => $key	2187	=item $value = cf::db_get $family => $key
1069		2188
1070	Returns a single value from the database	2189	Returns a single value from the database.
1071
1072	=item cf::db_put $family => $hashref
1073
1074	Stores the given family hashref into the database. Updates are delayed, if
1075	you want the data to be synced to disk immediately, use C<cf::db_sync>.
1076		2190
1077	=item cf::db_put $family => $key => $value	2191	=item cf::db_put $family => $key => $value
1078		2192
1079	Stores the given C<$value> in the family hash. Updates are delayed, if you	2193	Stores the given C<$value> in the family.
1080	want the data to be synced to disk immediately, use C<cf::db_sync>.
1081
1082	=item cf::db_dirty
1083
1084	Marks the database as dirty, to be updated at a later time.
1085
1086	=item cf::db_sync
1087
1088	Immediately write the database to disk I<if it is dirty>.
1089		2194
1090	=cut	2195	=cut
1091		2196
1092	our $DB;	2197	our $DB;
1093		2198
1094	{	2199	sub db_init {
		2200	unless ($DB) {
		2201	$DB = BDB::db_create $DB_ENV;
		2202
		2203	cf::sync_job {
		2204	eval {
		2205	$DB->set_flags (BDB::CHKSUM);
		2206
		2207	BDB::db_open $DB, undef, "db", undef, BDB::BTREE,
		2208	BDB::CREATE | BDB::AUTO_COMMIT, 0666;
		2209	cf::cleanup "db_open(db): $!" if $!;
		2210	};
		2211	cf::cleanup "db_open(db): $@" if $@;
		2212	};
		2213
1095	my $path = cf::localdir . "/database.pst";	2214	my $path = cf::localdir . "/database.pst";
		2215	if (stat $path) {
		2216	cf::sync_job {
		2217	my $pst = Storable::retrieve $path;
1096		2218
1097	sub db_load() {	2219	cf::db_put (board => data => $pst->{board});
1098	warn "loading database $path\n";#d# remove later	2220	cf::db_put (guildrules => data => $pst->{guildrules});
1099	$DB = stat $path ? Storable::retrieve $path : { };	2221	cf::db_put (rent => balance => $pst->{rent}{balance});
1100	}	2222	BDB::db_env_txn_checkpoint $DB_ENV;
1101		2223
1102	my $pid;	2224	unlink $path;
1103
1104	sub db_save() {
1105	warn "saving database $path\n";#d# remove later
1106	waitpid $pid, 0 if $pid;
1107	if (0 == ($pid = fork)) {
1108	$DB->{_meta}{version} = 1;
1109	Storable::nstore $DB, "$path~";
1110	rename "$path~", $path;
1111	cf::_exit 0 if defined $pid;
1112	}	2225	};
1113	}
1114
1115	my $dirty;
1116
1117	sub db_sync() {
1118	db_save if $dirty;
1119	undef $dirty;
1120	}
1121
1122	my $idle = Event->idle (min => $TICK * 2.8, max => 10, repeat => 0, data => WF_AUTOCANCEL, cb => sub {
1123	db_sync;
1124	});
1125
1126	sub db_dirty() {
1127	$dirty = 1;
1128	$idle->start;
1129	}
1130
1131	sub db_get($;$) {
1132	@_ >= 2
1133	? $DB->{$_[0]}{$_[1]}
1134	: ($DB->{$_[0]} ||= { })
1135	}
1136
1137	sub db_put($$;$) {
1138	if (@_ >= 3) {
1139	$DB->{$_[0]}{$_[1]} = $_[2];
1140	} else {
1141	$DB->{$_[0]} = $_[1];
1142	}
1143	db_dirty;
1144	}
1145
1146	cf::global->attach (
1147	prio => 10000,
1148	on_cleanup => sub {
1149	db_sync;
1150	},	2226	}
1151	);	2227	}
		2228	}
		2229
		2230	sub db_get($$) {
		2231	my $key = "$_[0]/$_[1]";
		2232
		2233	cf::sync_job {
		2234	BDB::db_get $DB, undef, $key, my $data;
		2235
		2236	$! ? ()
		2237	: Compress::LZF::sthaw $data
		2238	}
		2239	}
		2240
		2241	sub db_put($$$) {
		2242	BDB::dbreq_pri 4;
		2243	BDB::db_put $DB, undef, "$_[0]/$_[1]", Compress::LZF::sfreeze_cr $_[2], 0, sub { };
1152	}	2244	}
1153		2245
1154	#############################################################################	2246	#############################################################################
1155	# the server's main()	2247	# the server's init and main functions
		2248
		2249	sub init_resources {
		2250	load_resource_file sprintf "%s/%s/regions", cf::datadir, cf::mapdir
		2251	or die "unable to load regions file\n";#d#
		2252	}
1156		2253
1157	sub cfg_load {	2254	sub cfg_load {
1158	open my $fh, "<:utf8", cf::confdir . "/config"	2255	open my $fh, "<:utf8", cf::confdir . "/config"
1159	or return;	2256	or return;
1160		2257
1161	local $/;	2258	local $/;
1162	*CFG = YAML::Syck::Load <$fh>;	2259	*CFG = YAML::Syck::Load <$fh>;
		2260
		2261	$EMERGENCY_POSITION = $CFG{emergency_position} || ["/world/world_105_115", 5, 37];
		2262
		2263	$cf::map::MAX_RESET = $CFG{map_max_reset} if exists $CFG{map_max_reset};
		2264	$cf::map::DEFAULT_RESET = $CFG{map_default_reset} if exists $CFG{map_default_reset};
		2265
		2266	if (exists $CFG{mlockall}) {
		2267	eval {
		2268	$CFG{mlockall} ? eval "mlockall()" : eval "munlockall()"
		2269	and die "WARNING: m(un)lockall failed: $!\n";
		2270	};
		2271	warn $@ if $@;
		2272	}
		2273	}
		2274
		2275	sub init {
		2276	init_resources;
1163	}	2277	}
1164		2278
1165	sub main {	2279	sub main {
		2280	# we must not ever block the main coroutine
		2281	local $Coro::idle = sub {
		2282	Carp::cluck "FATAL: Coro::idle was called, major BUG, use cf::sync_job!\n";#d#
		2283	(async {
		2284	Event::one_event;
		2285	})->prio (Coro::PRIO_MAX);
		2286	};
		2287
1166	cfg_load;	2288	cfg_load;
1167	db_load;	2289	db_init;
1168	load_extensions;	2290	load_extensions;
		2291
		2292	$TICK_WATCHER->start;
1169	Event::loop;	2293	Event::loop;
1170	}	2294	}
1171		2295
1172	#############################################################################	2296	#############################################################################
1173	# initialisation	2297	# initialisation and cleanup
1174		2298
		2299	# install some emergency cleanup handlers
		2300	BEGIN {
		2301	for my $signal (qw(INT HUP TERM)) {
		2302	Event->signal (
		2303	reentrant => 0,
		2304	data => WF_AUTOCANCEL,
		2305	signal => $signal,
		2306	prio => 0,
		2307	cb => sub {
		2308	cf::cleanup "SIG$signal";
		2309	},
		2310	);
		2311	}
		2312	}
		2313
		2314	sub emergency_save() {
		2315	my $freeze_guard = cf::freeze_mainloop;
		2316
		2317	warn "enter emergency perl save\n";
		2318
		2319	cf::sync_job {
		2320	# use a peculiar iteration method to avoid tripping on perl
		2321	# refcount bugs in for. also avoids problems with players
		2322	# and maps saved/destroyed asynchronously.
		2323	warn "begin emergency player save\n";
		2324	for my $login (keys %cf::PLAYER) {
		2325	my $pl = $cf::PLAYER{$login} or next;
		2326	$pl->valid or next;
		2327	$pl->save;
		2328	}
		2329	warn "end emergency player save\n";
		2330
		2331	warn "begin emergency map save\n";
		2332	for my $path (keys %cf::MAP) {
		2333	my $map = $cf::MAP{$path} or next;
		2334	$map->valid or next;
		2335	$map->save;
		2336	}
		2337	warn "end emergency map save\n";
		2338
		2339	warn "begin emergency database checkpoint\n";
		2340	BDB::db_env_txn_checkpoint $DB_ENV;
		2341	warn "end emergency database checkpoint\n";
		2342	};
		2343
		2344	warn "leave emergency perl save\n";
		2345	}
		2346
		2347	sub post_cleanup {
		2348	my ($make_core) = @_;
		2349
		2350	warn Carp::longmess "post_cleanup backtrace"
		2351	if $make_core;
		2352	}
		2353
1175	sub _perl_reload(&) {	2354	sub reload() {
1176	my ($msg) = @_;	2355	# can/must only be called in main
		2356	if ($Coro::current != $Coro::main) {
		2357	warn "can only reload from main coroutine";
		2358	return;
		2359	}
1177		2360
1178	$msg->("reloading...");	2361	warn "reloading...";
1179		2362
1180	eval {	2363	warn "entering sync_job";
1181	# cancel all watchers	2364
		2365	cf::sync_job {
		2366	cf::write_runtime; # external watchdog should not bark
		2367	cf::emergency_save;
		2368	cf::write_runtime; # external watchdog should not bark
		2369
		2370	warn "syncing database to disk";
		2371	BDB::db_env_txn_checkpoint $DB_ENV;
		2372
		2373	# if anything goes wrong in here, we should simply crash as we already saved
		2374
		2375	warn "cancelling all WF_AUTOCANCEL watchers";
1182	for (Event::all_watchers) {	2376	for (Event::all_watchers) {
1183	$_->cancel if $_->data & WF_AUTOCANCEL;	2377	$_->cancel if $_->data & WF_AUTOCANCEL;
1184	}	2378	}
1185		2379
1186	# unload all extensions	2380	warn "flushing outstanding aio requests";
1187	for (@exts) {	2381	for (;;) {
1188	$msg->("unloading <$_>");	2382	BDB::flush;
1189	unload_extension $_;	2383	IO::AIO::flush;
		2384	Coro::cede;
		2385	last unless IO::AIO::nreqs || BDB::nreqs;
		2386	warn "iterate...";
		2387	}
		2388
		2389	warn "cancelling all extension coros";
		2390	$_->cancel for values %EXT_CORO;
		2391	%EXT_CORO = ();
		2392
		2393	warn "removing commands";
		2394	%COMMAND = ();
		2395
		2396	warn "removing ext commands";
		2397	%EXTCMD = ();
		2398
		2399	warn "unloading/nuking all extensions";
		2400	for my $pkg (@EXTS) {
		2401	warn "... unloading $pkg";
		2402
		2403	if (my $cb = $pkg->can ("unload")) {
		2404	eval {
		2405	$cb->($pkg);
		2406	1
		2407	} or warn "$pkg unloaded, but with errors: $@";
1190	}	2408	}
1191		2409
		2410	warn "... nuking $pkg";
		2411	Symbol::delete_package $pkg;
		2412	}
		2413
1192	# unload all modules loaded from $LIBDIR	2414	warn "unloading all perl modules loaded from $LIBDIR";
1193	while (my ($k, $v) = each %INC) {	2415	while (my ($k, $v) = each %INC) {
1194	next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;	2416	next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;
1195		2417
1196	$msg->("removing <$k>");	2418	warn "... unloading $k";
1197	delete $INC{$k};	2419	delete $INC{$k};
1198		2420
1199	$k =~ s/\.pm$//;	2421	$k =~ s/\.pm$//;
1200	$k =~ s/\//::/g;	2422	$k =~ s/\//::/g;
1201		2423
…		…
1204	}	2426	}
1205		2427
1206	Symbol::delete_package $k;	2428	Symbol::delete_package $k;
1207	}	2429	}
1208		2430
1209	# sync database to disk
1210	cf::db_sync;
1211
1212	# get rid of safe::, as good as possible	2431	warn "getting rid of safe::, as good as possible";
1213	Symbol::delete_package "safe::$_"	2432	Symbol::delete_package "safe::$_"
1214	for qw(cf::object cf::object::player cf::player cf::map cf::party cf::region);	2433	for qw(cf::attachable cf::object cf::object::player cf::client cf::player cf::map cf::party cf::region);
1215		2434
1216	# remove register_script_function callbacks
1217	# TODO
1218
1219	# unload cf.pm "a bit"	2435	warn "unloading cf.pm \"a bit\"";
1220	delete $INC{"cf.pm"};	2436	delete $INC{"cf.pm"};
1221		2437
1222	# don't, removes xs symbols, too,	2438	# don't, removes xs symbols, too,
1223	# and global variables created in xs	2439	# and global variables created in xs
1224	#Symbol::delete_package __PACKAGE__;	2440	#Symbol::delete_package __PACKAGE__;
1225		2441
1226	# reload cf.pm	2442	warn "unload completed, starting to reload now";
		2443
1227	$msg->("reloading cf.pm");	2444	warn "reloading cf.pm";
1228	require cf;	2445	require cf;
1229	cf::_connect_to_perl; # nominally unnecessary, but cannot hurt	2446	cf::_connect_to_perl; # nominally unnecessary, but cannot hurt
1230		2447
1231	# load config and database again	2448	warn "loading config and database again";
1232	cf::cfg_load;	2449	cf::cfg_load;
1233	cf::db_load;
1234		2450
1235	# load extensions	2451	warn "loading extensions";
1236	$msg->("load extensions");
1237	cf::load_extensions;	2452	cf::load_extensions;
1238		2453
1239	# reattach attachments to objects	2454	warn "reattaching attachments to objects/players";
1240	$msg->("reattach");
1241	_global_reattach;	2455	_global_reattach;
		2456	warn "reattaching attachments to maps";
		2457	reattach $_ for values %MAP;
		2458
		2459	warn "loading reloadable resources";
		2460	init_resources;
		2461
		2462	warn "leaving sync_job";
		2463
		2464	1
		2465	} or do {
		2466	warn $@;
		2467	warn "error while reloading, exiting.";
		2468	exit 1;
1242	};	2469	};
1243	$msg->($@) if $@;
1244		2470
1245	$msg->("reloaded");	2471	warn "reloaded";
1246	};	2472	};
1247		2473
1248	sub perl_reload() {	2474	our $RELOAD_WATCHER; # used only during reload
1249	_perl_reload {
1250	warn $_[0];
1251	print "$_[0]\n";
1252	};
1253	}
1254		2475
1255	register "<global>", __PACKAGE__;
1256
1257	register_command "perl-reload" => sub {	2476	register_command "reload" => sub {
1258	my ($who, $arg) = @_;	2477	my ($who, $arg) = @_;
1259		2478
1260	if ($who->flag (FLAG_WIZ)) {	2479	if ($who->flag (FLAG_WIZ)) {
1261	_perl_reload {	2480	$who->message ("reloading server.");
1262	warn $_[0];	2481
1263	$who->message ($_[0]);	2482	# doing reload synchronously and two reloads happen back-to-back,
		2483	# coro crashes during coro_state_free->destroy here.
		2484
		2485	$RELOAD_WATCHER ||= Event->timer (
		2486	reentrant => 0,
		2487	after => 0,
		2488	data => WF_AUTOCANCEL,
		2489	cb => sub {
		2490	reload;
		2491	undef $RELOAD_WATCHER;
		2492	},
1264	};	2493	);
1265	}	2494	}
1266	};	2495	};
1267		2496
1268	unshift @INC, $LIBDIR;	2497	unshift @INC, $LIBDIR;
1269		2498
		2499	my $bug_warning = 0;
		2500
1270	$TICK_WATCHER = Event->timer (	2501	$TICK_WATCHER = Event->timer (
		2502	reentrant => 0,
		2503	parked => 1,
1271	prio => 0,	2504	prio => 0,
1272	at => $NEXT_TICK || 1,	2505	at => $NEXT_TICK || $TICK,
1273	data => WF_AUTOCANCEL,	2506	data => WF_AUTOCANCEL,
1274	cb => sub {	2507	cb => sub {
		2508	if ($Coro::current != $Coro::main) {
		2509	Carp::cluck "major BUG: server tick called outside of main coro, skipping it"
		2510	unless ++$bug_warning > 10;
		2511	return;
		2512	}
		2513
		2514	$NOW = Event::time;
		2515
1275	cf::server_tick; # one server iteration	2516	cf::server_tick; # one server iteration
1276		2517	$RUNTIME += $TICK;
1277	my $NOW = Event::time;
1278	$NEXT_TICK += $TICK;	2518	$NEXT_TICK += $TICK;
1279		2519
		2520	if ($NOW >= $NEXT_RUNTIME_WRITE) {
		2521	$NEXT_RUNTIME_WRITE = $NOW + 10;
		2522	Coro::async_pool {
		2523	write_runtime
		2524	or warn "ERROR: unable to write runtime file: $!";
		2525	};
		2526	}
		2527
		2528	$WAIT_FOR_TICK->broadcast;
		2529	$WAIT_FOR_TICK_ONE->send if $WAIT_FOR_TICK_ONE->awaited;
		2530
		2531	# my $AFTER = Event::time;
		2532	# warn $AFTER - $NOW;#d#
		2533
1280	# if we are delayed by four ticks or more, skip them all	2534	# if we are delayed by four ticks or more, skip them all
1281	$NEXT_TICK = $NOW if $NOW >= $NEXT_TICK + $TICK * 4;	2535	$NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;
1282		2536
1283	$TICK_WATCHER->at ($NEXT_TICK);	2537	$TICK_WATCHER->at ($NEXT_TICK);
1284	$TICK_WATCHER->start;	2538	$TICK_WATCHER->start;
1285	},	2539	},
1286	);	2540	);
1287		2541
		2542	{
		2543	BDB::max_poll_time $TICK * 0.1;
		2544	$BDB_POLL_WATCHER = Event->io (
		2545	reentrant => 0,
		2546	fd => BDB::poll_fileno,
		2547	poll => 'r',
		2548	prio => 0,
		2549	data => WF_AUTOCANCEL,
		2550	cb => \&BDB::poll_cb,
		2551	);
		2552	BDB::min_parallel 8;
		2553
		2554	BDB::set_sync_prepare {
		2555	my $status;
		2556	my $current = $Coro::current;
		2557	(
		2558	sub {
		2559	$status = $!;
		2560	$current->ready; undef $current;
		2561	},
		2562	sub {
		2563	Coro::schedule while defined $current;
		2564	$! = $status;
		2565	},
		2566	)
		2567	};
		2568
		2569	unless ($DB_ENV) {
		2570	$DB_ENV = BDB::db_env_create;
		2571
		2572	cf::sync_job {
		2573	eval {
		2574	BDB::db_env_open
		2575	$DB_ENV,
		2576	$BDB_ENV_DIR,
		2577	BDB::INIT_LOCK | BDB::INIT_LOG | BDB::INIT_MPOOL | BDB::INIT_TXN
		2578	| BDB::RECOVER | BDB::REGISTER | BDB::USE_ENVIRON | BDB::CREATE,
		2579	0666;
		2580
		2581	cf::cleanup "db_env_open($BDB_ENV_DIR): $!" if $!;
		2582
		2583	$DB_ENV->set_flags (BDB::AUTO_COMMIT | BDB::REGION_INIT | BDB::TXN_NOSYNC, 1);
		2584	$DB_ENV->set_lk_detect;
		2585	};
		2586
		2587	cf::cleanup "db_env_open(db): $@" if $@;
		2588	};
		2589	}
		2590	}
		2591
		2592	{
		2593	IO::AIO::min_parallel 8;
		2594
		2595	undef $Coro::AIO::WATCHER;
1288	IO::AIO::max_poll_time $TICK * 0.2;	2596	IO::AIO::max_poll_time $TICK * 0.1;
1289		2597	$AIO_POLL_WATCHER = Event->io (
1290	Event->io (fd => IO::AIO::poll_fileno,	2598	reentrant => 0,
1291	poll => 'r',
1292	prio => 5,
1293	data => WF_AUTOCANCEL,	2599	data => WF_AUTOCANCEL,
		2600	fd => IO::AIO::poll_fileno,
		2601	poll => 'r',
		2602	prio => 6,
1294	cb => \&IO::AIO::poll_cb);	2603	cb => \&IO::AIO::poll_cb,
		2604	);
		2605	}
		2606
		2607	END { cf::emergency_save }
1295		2608
1296	1	2609	1
1297		2610

Diff Legend

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