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

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.104 by root, Sat Dec 30 16:56:16 2006 UTC vs.
Revision 1.169 by root, Sun Jan 14 01:09:46 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 3.3;	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 Data::Dumper;
		21	use Digest::MD5;
		22	use Fcntl;
19	use IO::AIO 2.3;	23	use IO::AIO 2.32 ();
20	use YAML::Syck ();	24	use YAML::Syck ();
21	use Time::HiRes;	25	use Time::HiRes;
22		26
23	use Event; $Event::Eval = 1; # no idea why this is required, but it is	27	use Event; $Event::Eval = 1; # no idea why this is required, but it is
24		28
		29	sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload
		30
25	# work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode?	31	# work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode?
26	$YAML::Syck::ImplicitUnicode = 1;	32	$YAML::Syck::ImplicitUnicode = 1;
27		33
28	$Coro::main->prio (2); # run main coroutine ("the server") with very high priority	34	$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		35
32	our %COMMAND = ();	36	our %COMMAND = ();
33	our %COMMAND_TIME = ();	37	our %COMMAND_TIME = ();
		38
		39	our @EXTS = (); # list of extension package names
34	our %EXTCMD = ();	40	our %EXTCMD = ();
		41	our %EXT_CORO = (); # coroutines bound to extensions
		42	our %EXT_MAP = (); # pluggable maps
35		43
36	our @EVENT;	44	our @EVENT;
37	our $LIBDIR = datadir . "/ext";	45	our $LIBDIR = datadir . "/ext";
38		46
39	our $TICK = MAX_TIME * 1e-6;	47	our $TICK = MAX_TIME * 1e-6;
40	our $TICK_WATCHER;	48	our $TICK_WATCHER;
		49	our $AIO_POLL_WATCHER;
		50	our $WRITE_RUNTIME_WATCHER;
41	our $NEXT_TICK;	51	our $NEXT_TICK;
42	our $NOW;	52	our $NOW;
43		53
44	our %CFG;	54	our %CFG;
45		55
46	our $UPTIME; $UPTIME \|\|= time;	56	our $UPTIME; $UPTIME \|\|= time;
47	our $RUNTIME;	57	our $RUNTIME;
48		58
		59	our %PLAYER; # all users
49	our %MAP; # all maps	60	our %MAP; # all maps
50	our $LINK_MAP; # the special {link} map	61	our $LINK_MAP; # the special {link} map, which is always available
51	our $FREEZE;	62	our $RANDOM_MAPS = cf::localdir . "/random";
		63
		64	our $WAIT_FOR_TICK; $WAIT_FOR_TICK \|\|= new Coro::Signal;
		65	our $WAIT_FOR_TICK_ONE; $WAIT_FOR_TICK_ONE \|\|= new Coro::Signal;
		66
		67	# used to convert map paths into valid unix filenames by replacing / by ∕
		68	our $PATH_SEP = "∕"; # U+2215, chosen purely for visual reasons
52		69
53	binmode STDOUT;	70	binmode STDOUT;
54	binmode STDERR;	71	binmode STDERR;
55		72
56	# read virtual server time, if available	73	# read virtual server time, if available
…		…
62		79
63	mkdir cf::localdir;	80	mkdir cf::localdir;
64	mkdir cf::localdir . "/" . cf::playerdir;	81	mkdir cf::localdir . "/" . cf::playerdir;
65	mkdir cf::localdir . "/" . cf::tmpdir;	82	mkdir cf::localdir . "/" . cf::tmpdir;
66	mkdir cf::localdir . "/" . cf::uniquedir;	83	mkdir cf::localdir . "/" . cf::uniquedir;
		84	mkdir $RANDOM_MAPS;
67		85
68	our %EXT_CORO;	86	our $EMERGENCY_POSITION;
69		87
70	#############################################################################	88	#############################################################################
71		89
72	=head2 GLOBAL VARIABLES	90	=head2 GLOBAL VARIABLES
73		91
…		…
97		115
98	=item %cf::CFG	116	=item %cf::CFG
99		117
100	Configuration for the server, loaded from C</etc/crossfire/config>, or	118	Configuration for the server, loaded from C</etc/crossfire/config>, or
101	from wherever your confdir points to.	119	from wherever your confdir points to.
		120
		121	=item $cf::WAIT_FOR_TICK, $cf::WAIT_FOR_TICK_ONE
		122
		123	These are Coro::Signal objects that are C<< ->broadcast >> (WAIT_FOR_TICK)
		124	or C<< ->send >> (WAIT_FOR_TICK_ONE) on after normal server tick
		125	processing has been done. Call C<< ->wait >> on them to maximise the
		126	window of cpu time available, or simply to synchronise to the server tick.
102		127
103	=back	128	=back
104		129
105	=cut	130	=cut
106		131
…		…
110	utf8::encode $msg;	135	utf8::encode $msg;
111		136
112	$msg .= "\n"	137	$msg .= "\n"
113	unless $msg =~ /\n$/;	138	unless $msg =~ /\n$/;
114		139
115	LOG llevError, "cfperl: $msg";	140	LOG llevError, $msg;
116	};	141	};
117	}	142	}
118		143
119	@safe::cf::global::ISA = @cf::global::ISA = 'cf::attachable';	144	@safe::cf::global::ISA = @cf::global::ISA = 'cf::attachable';
120	@safe::cf::object::ISA = @cf::object::ISA = 'cf::attachable';	145	@safe::cf::object::ISA = @cf::object::ISA = 'cf::attachable';
…		…
138		163
139	$Event::DIED = sub {	164	$Event::DIED = sub {
140	warn "error in event callback: @_";	165	warn "error in event callback: @_";
141	};	166	};
142		167
143	my %ext_pkg;
144	my @exts;
145	my @hook;
146
147	=head2 UTILITY FUNCTIONS	168	=head2 UTILITY FUNCTIONS
148		169
149	=over 4	170	=over 4
150		171
		172	=item dumpval $ref
		173
151	=cut	174	=cut
		175
		176	sub dumpval {
		177	eval {
		178	local $SIG{__DIE__};
		179	my $d;
		180	if (1) {
		181	$d = new Data::Dumper([$_[0]], ["*var"]);
		182	$d->Terse(1);
		183	$d->Indent(2);
		184	$d->Quotekeys(0);
		185	$d->Useqq(1);
		186	#$d->Bless(...);
		187	$d->Seen($_[1]) if @_ > 1;
		188	$d = $d->Dump();
		189	}
		190	$d =~ s/([\x00-\x07\x09\x0b\x0c\x0e-\x1f])/sprintf "\\x%02x", ord($1)/ge;
		191	$d
		192	} \|\| "[unable to dump $_[0]: '$@']";
		193	}
152		194
153	use JSON::Syck (); # TODO# replace by JSON::PC once working	195	use JSON::Syck (); # TODO# replace by JSON::PC once working
154		196
155	=item $ref = cf::from_json $json	197	=item $ref = cf::from_json $json
156		198
…		…
172	sub to_json($) {	214	sub to_json($) {
173	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs	215	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs
174	JSON::Syck::Dump $_[0]	216	JSON::Syck::Dump $_[0]
175	}	217	}
176		218
		219	=item cf::lock_wait $string
		220
		221	Wait until the given lock is available. See cf::lock_acquire.
		222
		223	=item my $lock = cf::lock_acquire $string
		224
		225	Wait until the given lock is available and then acquires it and returns
		226	a Coro::guard object. If the guard object gets destroyed (goes out of scope,
		227	for example when the coroutine gets canceled), the lock is automatically
		228	returned.
		229
		230	Lock names should begin with a unique identifier (for example, cf::map::find
		231	uses map_find and cf::map::load uses map_load).
		232
		233	=cut
		234
		235	our %LOCK;
		236
		237	sub lock_wait($) {
		238	my ($key) = @_;
		239
		240	# wait for lock, if any
		241	while ($LOCK{$key}) {
		242	push @{ $LOCK{$key} }, $Coro::current;
		243	Coro::schedule;
		244	}
		245	}
		246
		247	sub lock_acquire($) {
		248	my ($key) = @_;
		249
		250	# wait, to be sure we are not locked
		251	lock_wait $key;
		252
		253	$LOCK{$key} = [];
		254
		255	Coro::guard {
		256	# wake up all waiters, to be on the safe side
		257	$_->ready for @{ delete $LOCK{$key} };
		258	}
		259	}
		260
		261	sub freeze_mainloop {
		262	return unless $TICK_WATCHER->is_active;
		263
		264	my $guard = Coro::guard {
		265	$TICK_WATCHER->start;
		266	$WRITE_RUNTIME_WATCHER->start;
		267	};
		268	$WRITE_RUNTIME_WATCHER->stop;
		269	$TICK_WATCHER->stop;
		270	$guard
		271	}
		272
		273	=item cf::async { BLOCK }
		274
		275	Currently the same as Coro::async_pool, meaning you cannot use
		276	C<on_destroy>, C<join> or other gimmicks on these coroutines. The only
		277	thing you are allowed to do is call C<prio> on it.
		278
		279	=cut
		280
		281	BEGIN { *async = \&Coro::async_pool }
		282
		283	=item cf::sync_job { BLOCK }
		284
		285	The design of crossfire+ requires that the main coro ($Coro::main) is
		286	always able to handle events or runnable, as crossfire+ is only partly
		287	reentrant. Thus "blocking" it by e.g. waiting for I/O is not acceptable.
		288
		289	If it must be done, put the blocking parts into C<sync_job>. This will run
		290	the given BLOCK in another coroutine while waiting for the result. The
		291	server will be frozen during this time, so the block should either finish
		292	fast or be very important.
		293
		294	=cut
		295
		296	sub sync_job(&) {
		297	my ($job) = @_;
		298
		299	if ($Coro::current == $Coro::main) {
		300	# this is the main coro, too bad, we have to block
		301	# till the operation succeeds, freezing the server :/
		302
		303	# TODO: use suspend/resume instead
		304	# (but this is cancel-safe)
		305	my $freeze_guard = freeze_mainloop;
		306
		307	my $busy = 1;
		308	my @res;
		309
		310	(async {
		311	@res = eval { $job->() };
		312	warn $@ if $@;
		313	undef $busy;
		314	})->prio (Coro::PRIO_MAX);
		315
		316	while ($busy) {
		317	Coro::cede or Event::one_event;
		318	}
		319
		320	wantarray ? @res : $res[0]
		321	} else {
		322	# we are in another coroutine, how wonderful, everything just works
		323
		324	$job->()
		325	}
		326	}
		327
177	=item $coro = cf::coro { BLOCK }	328	=item $coro = cf::async_ext { BLOCK }
178		329
179	Creates and returns a new coro. This coro is automcatially being canceled	330	Like async, but this coro is automatically being canceled when the
180	when the extension calling this is being unloaded.	331	extension calling this is being unloaded.
181		332
182	=cut	333	=cut
183		334
184	sub coro(&) {	335	sub async_ext(&) {
185	my $cb = shift;	336	my $cb = shift;
186		337
187	my $coro; $coro = async {	338	my $coro = &Coro::async ($cb);
188	eval {
189	$cb->();
190	};
191	warn $@ if $@;
192	};
193		339
194	$coro->on_destroy (sub {	340	$coro->on_destroy (sub {
195	delete $EXT_CORO{$coro+0};	341	delete $EXT_CORO{$coro+0};
196	});	342	});
197	$EXT_CORO{$coro+0} = $coro;	343	$EXT_CORO{$coro+0} = $coro;
198		344
199	$coro	345	$coro
		346	}
		347
		348	sub write_runtime {
		349	my $runtime = cf::localdir . "/runtime";
		350
		351	my $fh = aio_open "$runtime~", O_WRONLY \| O_CREAT, 0644
		352	or return;
		353
		354	my $value = $cf::RUNTIME + 1 + 10; # 10 is the runtime save interval, for a monotonic clock
		355	(aio_write $fh, 0, (length $value), $value, 0) <= 0
		356	and return;
		357
		358	aio_fsync $fh
		359	and return;
		360
		361	close $fh
		362	or return;
		363
		364	aio_rename "$runtime~", $runtime
		365	and return;
		366
		367	1
200	}	368	}
201		369
202	=back	370	=back
203		371
204	=cut	372	=cut
…		…
516		684
517	sub reattach {	685	sub reattach {
518	# basically do the same as instantiate, without calling instantiate	686	# basically do the same as instantiate, without calling instantiate
519	my ($obj) = @_;	687	my ($obj) = @_;
520		688
		689	bless $obj, ref $obj; # re-bless in case extensions have been reloaded
		690
521	my $registry = $obj->registry;	691	my $registry = $obj->registry;
522		692
523	@$registry = ();	693	@$registry = ();
524		694
525	delete $obj->{_attachment} unless scalar keys %{ $obj->{_attachment} \|\| {} };	695	delete $obj->{_attachment} unless scalar keys %{ $obj->{_attachment} \|\| {} };
…		…
563	);	733	);
564		734
565	sub object_freezer_save {	735	sub object_freezer_save {
566	my ($filename, $rdata, $objs) = @_;	736	my ($filename, $rdata, $objs) = @_;
567		737
		738	sync_job {
568	if (length $$rdata) {	739	if (length $$rdata) {
569	warn sprintf "saving %s (%d,%d)\n",	740	warn sprintf "saving %s (%d,%d)\n",
570	$filename, length $$rdata, scalar @$objs;	741	$filename, length $$rdata, scalar @$objs;
571		742
572	if (open my $fh, ">:raw", "$filename~") {	743	if (my $fh = aio_open "$filename~", O_WRONLY \| O_CREAT, 0600) {
573	chmod SAVE_MODE, $fh;
574	syswrite $fh, $$rdata;
575	close $fh;
576
577	if (@$objs && open my $fh, ">:raw", "$filename.pst~") {
578	chmod SAVE_MODE, $fh;	744	chmod SAVE_MODE, $fh;
579	syswrite $fh, Storable::nfreeze { version => 1, objs => $objs };	745	aio_write $fh, 0, (length $$rdata), $$rdata, 0;
		746	aio_fsync $fh;
580	close $fh;	747	close $fh;
		748
		749	if (@$objs) {
		750	if (my $fh = aio_open "$filename.pst~", O_WRONLY \| O_CREAT, 0600) {
		751	chmod SAVE_MODE, $fh;
		752	my $data = Storable::nfreeze { version => 1, objs => $objs };
		753	aio_write $fh, 0, (length $data), $data, 0;
		754	aio_fsync $fh;
		755	close $fh;
581	rename "$filename.pst~", "$filename.pst";	756	aio_rename "$filename.pst~", "$filename.pst";
		757	}
		758	} else {
		759	aio_unlink "$filename.pst";
		760	}
		761
		762	aio_rename "$filename~", $filename;
582	} else {	763	} else {
583	unlink "$filename.pst";	764	warn "FATAL: $filename~: $!\n";
584	}	765	}
585
586	rename "$filename~", $filename;
587	} else {	766	} else {
588	warn "FATAL: $filename~: $!\n";
589	}
590	} else {
591	unlink $filename;	767	aio_unlink $filename;
592	unlink "$filename.pst";	768	aio_unlink "$filename.pst";
		769	}
593	}	770	}
594	}	771	}
595		772
596	sub object_freezer_as_string {	773	sub object_freezer_as_string {
597	my ($rdata, $objs) = @_;	774	my ($rdata, $objs) = @_;
…		…
602	}	779	}
603		780
604	sub object_thawer_load {	781	sub object_thawer_load {
605	my ($filename) = @_;	782	my ($filename) = @_;
606		783
607	local $/;	784	my ($data, $av);
608		785
609	my $av;	786	(aio_load $filename, $data) >= 0
		787	or return;
610		788
611	#TODO: use sysread etc.	789	unless (aio_stat "$filename.pst") {
612	if (open my $data, "<:raw:perlio", $filename) {	790	(aio_load "$filename.pst", $av) >= 0
613	$data = <$data>;	791	or return;
614	if (open my $pst, "<:raw:perlio", "$filename.pst") {
615	$av = eval { (Storable::thaw <$pst>)->{objs} };	792	$av = eval { (Storable::thaw $av)->{objs} };
616	}	793	}
		794
		795	warn sprintf "loading %s (%d)\n",
		796	$filename, length $data, scalar @{$av \|\| []};#d#
617	return ($data, $av);	797	return ($data, $av);
618	}
619
620	()
621	}	798	}
622		799
623	#############################################################################	800	#############################################################################
624	# command handling &c	801	# command handling &c
625		802
…		…
649	=cut	826	=cut
650		827
651	sub register_extcmd {	828	sub register_extcmd {
652	my ($name, $cb) = @_;	829	my ($name, $cb) = @_;
653		830
654	my $caller = caller;
655	#warn "registering extcmd '$name' to '$caller'";
656
657	$EXTCMD{$name} = [$cb, $caller];	831	$EXTCMD{$name} = $cb;
658	}	832	}
659		833
660	cf::player->attach (	834	cf::player->attach (
661	on_command => sub {	835	on_command => sub {
662	my ($pl, $name, $params) = @_;	836	my ($pl, $name, $params) = @_;
…		…
675		849
676	my $msg = eval { from_json $buf };	850	my $msg = eval { from_json $buf };
677		851
678	if (ref $msg) {	852	if (ref $msg) {
679	if (my $cb = $EXTCMD{$msg->{msgtype}}) {	853	if (my $cb = $EXTCMD{$msg->{msgtype}}) {
680	if (my %reply = $cb->[0]->($pl, $msg)) {	854	if (my %reply = $cb->($pl, $msg)) {
681	$pl->ext_reply ($msg->{msgid}, %reply);	855	$pl->ext_reply ($msg->{msgid}, %reply);
682	}	856	}
683	}	857	}
684	} else {	858	} else {
685	warn "player " . ($pl->ob->name) . " sent unparseable ext message: <$buf>\n";	859	warn "player " . ($pl->ob->name) . " sent unparseable ext message: <$buf>\n";
…		…
687		861
688	cf::override;	862	cf::override;
689	},	863	},
690	);	864	);
691		865
692	sub register {
693	my ($base, $pkg) = @_;
694
695	#TODO
696	}
697
698	sub load_extension {	866	sub load_extension {
699	my ($path) = @_;	867	my ($path) = @_;
700		868
701	$path =~ /([^\/\\]+)\.ext$/ or die "$path";	869	$path =~ /([^\/\\]+)\.ext$/ or die "$path";
702	my $base = $1;	870	my $base = $1;
703	my $pkg = $1;	871	my $pkg = $1;
704	$pkg =~ s/[^[:word:]]/_/g;	872	$pkg =~ s/[^[:word:]]/_/g;
705	$pkg = "ext::$pkg";	873	$pkg = "ext::$pkg";
706		874
707	warn "loading '$path' into '$pkg'\n";	875	warn "... loading '$path' into '$pkg'\n";
708		876
709	open my $fh, "<:utf8", $path	877	open my $fh, "<:utf8", $path
710	or die "$path: $!";	878	or die "$path: $!";
711		879
712	my $source =	880	my $source =
713	"package $pkg; use strict; use utf8;\n"	881	"package $pkg; use strict; use utf8;\n"
714	. "#line 1 \"$path\"\n{\n"	882	. "#line 1 \"$path\"\n{\n"
715	. (do { local $/; <$fh> })	883	. (do { local $/; <$fh> })
716	. "\n};\n1";	884	. "\n};\n1";
717		885
718	eval $source	886	unless (eval $source) {
719	or die $@ ? "$path: $@\n"	887	my $msg = $@ ? "$path: $@\n"
720	: "extension disabled.\n";	888	: "extension disabled.\n";
721		889	if ($source =~ /^#!.perl.#.*MANDATORY/m) { # ugly match
722	push @exts, $pkg;	890	warn $@;
723	$ext_pkg{$base} = $pkg;	891	warn "mandatory extension failed to load, exiting.\n";
724		892	exit 1;
725	# no strict 'refs';	893	}
726	# @{"$pkg\::ISA"} = ext::;	894	die $@;
727
728	register $base, $pkg;
729	}
730
731	sub unload_extension {
732	my ($pkg) = @_;
733
734	warn "removing extension $pkg\n";
735
736	# remove hooks
737	#TODO
738	# for my $idx (0 .. $#PLUGIN_EVENT) {
739	# delete $hook[$idx]{$pkg};
740	# }	895	}
741		896
742	# remove commands	897	push @EXTS, $pkg;
743	for my $name (keys %COMMAND) {
744	my @cb = grep $_->[0] ne $pkg, @{ $COMMAND{$name} };
745
746	if (@cb) {
747	$COMMAND{$name} = \@cb;
748	} else {
749	delete $COMMAND{$name};
750	}
751	}
752
753	# remove extcmds
754	for my $name (grep $EXTCMD{$_}[1] eq $pkg, keys %EXTCMD) {
755	delete $EXTCMD{$name};
756	}
757
758	if (my $cb = $pkg->can ("unload")) {
759	eval {
760	$cb->($pkg);
761	1
762	} or warn "$pkg unloaded, but with errors: $@";
763	}
764
765	Symbol::delete_package $pkg;
766	}	898	}
767		899
768	sub load_extensions {	900	sub load_extensions {
769	for my $ext (<$LIBDIR/*.ext>) {	901	for my $ext (<$LIBDIR/*.ext>) {
770	next unless -r $ext;	902	next unless -r $ext;
…		…
774	} or warn "$ext not loaded: $@";	906	} or warn "$ext not loaded: $@";
775	}	907	}
776	}	908	}
777		909
778	#############################################################################	910	#############################################################################
779	# load/save/clean perl data associated with a map
780		911
781	*cf::mapsupport::on_clean = sub {	912	=head2 CORE EXTENSIONS
		913
		914	Functions and methods that extend core crossfire objects.
		915
		916	=cut
		917
		918	package cf::player;
		919
		920	use Coro::AIO;
		921
		922	=head3 cf::player
		923
		924	=over 4
		925
		926	=item cf::player::find $login
		927
		928	Returns the given player object, loading it if necessary (might block).
		929
		930	=cut
		931
		932	sub playerdir($) {
		933	cf::localdir
		934	. "/"
		935	. cf::playerdir
		936	. "/"
		937	. (ref $_[0] ? $_[0]->ob->name : $_[0])
		938	}
		939
		940	sub path($) {
		941	my $login = ref $_[0] ? $_[0]->ob->name : $_[0];
		942
		943	(playerdir $login) . "/$login.pl"
		944	}
		945
		946	sub find_active($) {
		947	$cf::PLAYER{$_[0]}
		948	and $cf::PLAYER{$_[0]}->active
		949	and $cf::PLAYER{$_[0]}
		950	}
		951
		952	sub exists($) {
		953	my ($login) = @_;
		954
		955	$cf::PLAYER{$login}
		956	or cf::sync_job { !aio_stat $login }
		957	}
		958
		959	sub find($) {
		960	return $cf::PLAYER{$_[0]} \|\| do {
		961	my $login = $_[0];
		962
		963	my $guard = cf::lock_acquire "user_find:$login";
		964
		965	$cf::PLAYER{$_[0]} \|\| do {
		966	my $pl = load_pl path $login
		967	or return;
		968	$cf::PLAYER{$login} = $pl
		969	}
		970	}
		971	}
		972
		973	sub save($) {
		974	my ($pl) = @_;
		975
		976	return if $pl->{deny_save};
		977
		978	my $path = path $pl;
		979	my $guard = cf::lock_acquire "user_save:$path";
		980
		981	return if $pl->{deny_save};
		982
		983	aio_mkdir playerdir $pl, 0770;
		984	$pl->{last_save} = $cf::RUNTIME;
		985
		986	$pl->save_pl ($path);
		987	Coro::cede;
		988	}
		989
		990	sub new($) {
		991	my ($login) = @_;
		992
		993	my $self = create;
		994
		995	$self->ob->name ($login);
		996	$self->{deny_save} = 1;
		997
		998	$cf::PLAYER{$login} = $self;
		999
		1000	$self
		1001	}
		1002
		1003	=item $pl->quit_character
		1004
		1005	Nukes the player without looking back. If logged in, the connection will
		1006	be destroyed. May block for a long time.
		1007
		1008	=cut
		1009
		1010	sub quit_character {
		1011	my ($pl) = @_;
		1012
		1013	$pl->{deny_save} = 1;
		1014	$pl->password ("*"); # this should lock out the player until we nuked the dir
		1015
		1016	$pl->invoke (cf::EVENT_PLAYER_LOGOUT, 1) if $pl->active;
		1017	$pl->deactivate;
		1018	$pl->invoke (cf::EVENT_PLAYER_QUIT);
		1019	$pl->ns->destroy if $pl->ns;
		1020
		1021	my $path = playerdir $pl;
		1022	my $temp = "$path~$cf::RUNTIME~deleting~";
		1023	aio_rename $path, $temp;
		1024	delete $cf::PLAYER{$pl->ob->name};
		1025	$pl->destroy;
		1026	IO::AIO::aio_rmtree $temp;
		1027	}
		1028
		1029	=item cf::player::list_logins
		1030
		1031	Returns am arrayref of all valid playernames in the system, can take a
		1032	while and may block, so not sync_job-capable, ever.
		1033
		1034	=cut
		1035
		1036	sub list_logins {
		1037	my $dirs = aio_readdir cf::localdir . "/" . cf::playerdir
		1038	or return [];
		1039
		1040	my @logins;
		1041
		1042	for my $login (@$dirs) {
		1043	my $fh = aio_open path $login, Fcntl::O_RDONLY, 0 or next;
		1044	aio_read $fh, 0, 512, my $buf, 0 or next;
		1045	$buf !~ /^password -------------$/m or next; # official not-valid tag
		1046
		1047	utf8::decode $login;
		1048	push @logins, $login;
		1049	}
		1050
		1051	\@logins
		1052	}
		1053
		1054	=item $player->maps
		1055
		1056	Returns an arrayref of map paths that are private for this
		1057	player. May block.
		1058
		1059	=cut
		1060
		1061	sub maps($) {
		1062	my ($pl) = @_;
		1063
		1064	my $files = aio_readdir playerdir $pl
		1065	or return;
		1066
		1067	my @paths;
		1068
		1069	for (@$files) {
		1070	utf8::decode $_;
		1071	next if /\.(?:pl\|pst)$/;
		1072	next unless /^$PATH_SEP/o;
		1073
		1074	s/\.map$//;
		1075	push @paths, "~" . $pl->ob->name . "/" . $_;
		1076	}
		1077
		1078	\@paths
		1079	}
		1080
		1081	=item $player->ext_reply ($msgid, $msgtype, %msg)
		1082
		1083	Sends an ext reply to the player.
		1084
		1085	=cut
		1086
		1087	sub ext_reply($$$%) {
		1088	my ($self, $id, %msg) = @_;
		1089
		1090	$msg{msgid} = $id;
		1091
		1092	$self->send ("ext " . cf::to_json \%msg);
		1093	}
		1094
		1095	package cf;
		1096
		1097	=back
		1098
		1099
		1100	=head3 cf::map
		1101
		1102	=over 4
		1103
		1104	=cut
		1105
		1106	package cf::map;
		1107
		1108	use Fcntl;
		1109	use Coro::AIO;
		1110
		1111	use overload
		1112	'""' => \&as_string;
		1113
		1114	our $MAX_RESET = 3600;
		1115	our $DEFAULT_RESET = 3000;
		1116
		1117	sub generate_random_map {
		1118	my ($self, $rmp) = @_;
		1119
		1120	# mit "rum" bekleckern, nicht
		1121	$self->_create_random_map (
		1122	$rmp->{wallstyle}, $rmp->{wall_name}, $rmp->{floorstyle}, $rmp->{monsterstyle},
		1123	$rmp->{treasurestyle}, $rmp->{layoutstyle}, $rmp->{doorstyle}, $rmp->{decorstyle},
		1124	$rmp->{origin_map}, $rmp->{final_map}, $rmp->{exitstyle}, $rmp->{this_map},
		1125	$rmp->{exit_on_final_map},
		1126	$rmp->{xsize}, $rmp->{ysize},
		1127	$rmp->{expand2x}, $rmp->{layoutoptions1}, $rmp->{layoutoptions2}, $rmp->{layoutoptions3},
		1128	$rmp->{symmetry}, $rmp->{difficulty}, $rmp->{difficulty_given}, $rmp->{difficulty_increase},
		1129	$rmp->{dungeon_level}, $rmp->{dungeon_depth}, $rmp->{decoroptions}, $rmp->{orientation},
		1130	$rmp->{origin_y}, $rmp->{origin_x}, $rmp->{random_seed}, $rmp->{total_map_hp},
		1131	$rmp->{map_layout_style}, $rmp->{treasureoptions}, $rmp->{symmetry_used},
		1132	(cf::region::find $rmp->{region}), $rmp->{custom}
		1133	)
		1134	}
		1135
		1136	sub register {
		1137	my (undef, $regex) = @_;
		1138	my $pkg = caller;
		1139
		1140	no strict;
		1141	push @{"$pkg\::ISA"}, __PACKAGE__;
		1142
		1143	$EXT_MAP{$pkg} = qr<$regex>;
		1144	}
		1145
		1146	# also paths starting with '/'
		1147	$EXT_MAP{"cf::map"} = qr{^(?=/)};
		1148
		1149	sub normalise {
		1150	my ($path, $base) = @_;
		1151
		1152	# map plan:
		1153	#
		1154	# /! non-realised random map exit (special hack!)
		1155	# {... are special paths that are not being touched
		1156	# ?xxx/... are special absolute paths
		1157	# ?random/... random maps
		1158	# /... normal maps
		1159	# ~user/... per-player map of a specific user
		1160
		1161	$path =~ s/$PATH_SEP/\//go;
		1162
		1163	# treat it as relative path if it starts with
		1164	# something that looks reasonable
		1165	if ($path =~ m{^(?:\./\|\.\./\|\w)}) {
		1166	$base or Carp::carp "normalise called with relative path and no base: '$path'";
		1167
		1168	$base =~ s{[^/]+/?$}{};
		1169	$path = "$base/$path";
		1170	}
		1171
		1172	for ($path) {
		1173	redo if s{//}{/};
		1174	redo if s{/\.?/}{/};
		1175	redo if s{/[^/]+/\.\./}{/};
		1176	}
		1177
		1178	$path
		1179	}
		1180
		1181	sub new_from_path {
		1182	my (undef, $path, $base) = @_;
		1183
		1184	return $path if UNIVERSAL::isa $path, "cf::map"; # already a map object
		1185
		1186	$path = normalise $path, $base;
		1187
		1188	for my $pkg (keys %EXT_MAP) {
		1189	if ($path =~ $EXT_MAP{$pkg}) {
		1190	my $self = bless cf::map::new, $pkg;
		1191	$self->{path} = $path; $self->path ($path);
		1192	$self->init; # pass $1 etc.
		1193	return $self;
		1194	}
		1195	}
		1196
		1197	Carp::carp "unable to resolve path '$path'.";
		1198	()
		1199	}
		1200
		1201	sub init {
		1202	my ($self) = @_;
		1203
		1204	$self
		1205	}
		1206
		1207	sub as_string {
		1208	my ($self) = @_;
		1209
		1210	"$self->{path}"
		1211	}
		1212
		1213	# the displayed name, this is a one way mapping
		1214	sub visible_name {
		1215	&as_string
		1216	}
		1217
		1218	# the original (read-only) location
		1219	sub load_path {
		1220	my ($self) = @_;
		1221
		1222	sprintf "%s/%s/%s", cf::datadir, cf::mapdir, $self->{path}
		1223	}
		1224
		1225	# the temporary/swap location
		1226	sub save_path {
		1227	my ($self) = @_;
		1228
		1229	(my $path = $_[0]{path}) =~ s/\//$PATH_SEP/g;
		1230	sprintf "%s/%s/%s", cf::localdir, cf::tmpdir, $path
		1231	}
		1232
		1233	# the unique path, undef == no special unique path
		1234	sub uniq_path {
		1235	my ($self) = @_;
		1236
		1237	(my $path = $_[0]{path}) =~ s/\//$PATH_SEP/g;
		1238	sprintf "%s/%s/%s", cf::localdir, cf::uniquedir, $path
		1239	}
		1240
		1241	# and all this just because we cannot iterate over
		1242	# all maps in C++...
		1243	sub change_all_map_light {
		1244	my ($change) = @_;
		1245
		1246	$_->change_map_light ($change)
		1247	for grep $_->outdoor, values %cf::MAP;
		1248	}
		1249
		1250	sub unlink_save {
		1251	my ($self) = @_;
		1252
		1253	utf8::encode (my $save = $self->save_path);
		1254	IO::AIO::aioreq_pri 4; IO::AIO::aio_unlink $save;
		1255	IO::AIO::aioreq_pri 4; IO::AIO::aio_unlink "$save.pst";
		1256	}
		1257
		1258	sub load_header_from($) {
		1259	my ($self, $path) = @_;
		1260
		1261	utf8::encode $path;
		1262	aio_open $path, O_RDONLY, 0
		1263	or return;
		1264
		1265	$self->_load_header ($path)
		1266	or return;
		1267
		1268	$self->{load_path} = $path;
		1269
		1270	1
		1271	}
		1272
		1273	sub load_orig {
		1274	my ($self) = @_;
		1275
		1276	$self->load_header_from ($self->load_path)
		1277	}
		1278
		1279	sub load_temp {
		1280	my ($self) = @_;
		1281
		1282	$self->load_header_from ($self->save_path)
		1283	}
		1284
		1285	sub load_header {
		1286	my ($self) = @_;
		1287
		1288	if ($self->load_temp) {
		1289	$self->last_access ((delete $self->{last_access})
		1290	\|\| $cf::RUNTIME); #d#
		1291	# safety
		1292	$self->{instantiate_time} = $cf::RUNTIME
		1293	if $self->{instantiate_time} > $cf::RUNTIME;
		1294	} else {
		1295	$self->load_orig
		1296	or return;
		1297
		1298	$self->{load_original} = 1;
		1299	$self->{instantiate_time} = $cf::RUNTIME;
		1300	$self->last_access ($cf::RUNTIME);
		1301	$self->instantiate;
		1302	}
		1303
		1304	1
		1305	}
		1306
		1307	sub find;
		1308	sub find {
		1309	my ($path, $origin) = @_;
		1310
		1311	$path = normalise $path, $origin && $origin->path;
		1312
		1313	cf::lock_wait "map_find:$path";
		1314
		1315	$cf::MAP{$path} \|\| do {
		1316	my $guard = cf::lock_acquire "map_find:$path";
		1317	my $map = new_from_path cf::map $path
		1318	or return;
		1319
		1320	$map->{last_save} = $cf::RUNTIME;
		1321
		1322	$map->load_header
		1323	or return;
		1324
		1325	if ($map->should_reset) {
		1326	$map->reset;
		1327	undef $guard;
		1328	$map = find $path
		1329	or return;
		1330	}
		1331
		1332	$cf::MAP{$path} = $map
		1333	}
		1334	}
		1335
		1336	sub load {
		1337	my ($self) = @_;
		1338
		1339	my $path = $self->{path};
		1340	my $guard = cf::lock_acquire "map_load:$path";
		1341
		1342	return if $self->in_memory != cf::MAP_SWAPPED;
		1343
		1344	$self->in_memory (cf::MAP_LOADING);
		1345
		1346	$self->alloc;
		1347	$self->_load_objects ($self->{load_path}, 1)
		1348	or return;
		1349
		1350	$self->set_object_flag (cf::FLAG_OBJ_ORIGINAL, 1)
		1351	if delete $self->{load_original};
		1352
		1353	if (my $uniq = $self->uniq_path) {
		1354	utf8::encode $uniq;
		1355	if (aio_open $uniq, O_RDONLY, 0) {
		1356	$self->clear_unique_items;
		1357	$self->_load_objects ($uniq, 0);
		1358	}
		1359	}
		1360
		1361	Coro::cede;
		1362
		1363	# now do the right thing for maps
		1364	$self->link_multipart_objects;
		1365
		1366	unless ($self->{deny_activate}) {
		1367	$self->decay_objects;
		1368	$self->fix_auto_apply;
		1369	$self->update_buttons;
		1370	Coro::cede;
		1371	$self->set_darkness_map;
		1372	$self->difficulty ($self->estimate_difficulty)
		1373	unless $self->difficulty;
		1374	Coro::cede;
		1375	$self->activate;
		1376	}
		1377
		1378	$self->in_memory (cf::MAP_IN_MEMORY);
		1379	}
		1380
		1381	sub customise_for {
		1382	my ($self, $ob) = @_;
		1383
		1384	return find "~" . $ob->name . "/" . $self->{path}
		1385	if $self->per_player;
		1386
		1387	$self
		1388	}
		1389
		1390	# find and load all maps in the 3x3 area around a map
		1391	sub load_diag {
782	my ($map) = @_;	1392	my ($map) = @_;
783		1393
784	my $path = $map->tmpname;	1394	my @diag; # diagonal neighbours
785	defined $path or return;
786		1395
787	unlink "$path.pst";	1396	for (0 .. 3) {
		1397	my $neigh = $map->tile_path ($_)
		1398	or next;
		1399	$neigh = find $neigh, $map
		1400	or next;
		1401	$neigh->load;
		1402
		1403	push @diag, [$neigh->tile_path (($_ + 3) % 4), $neigh],
		1404	[$neigh->tile_path (($_ + 1) % 4), $neigh];
		1405	}
		1406
		1407	for (@diag) {
		1408	my $neigh = find @$_
		1409	or next;
		1410	$neigh->load;
		1411	}
		1412	}
		1413
		1414	sub find_sync {
		1415	my ($path, $origin) = @_;
		1416
		1417	cf::sync_job { find $path, $origin }
		1418	}
		1419
		1420	sub do_load_sync {
		1421	my ($map) = @_;
		1422
		1423	cf::sync_job { $map->load };
		1424	}
		1425
		1426	our %MAP_PREFETCH;
		1427	our $MAP_PREFETCHER = Coro::async {
		1428	while () {
		1429	for my $path (keys %MAP_PREFETCH) {
		1430	my $map = find $path
		1431	or next;
		1432	$map->load;
		1433
		1434	delete $MAP_PREFETCH{$path};
		1435	}
		1436	Coro::schedule;
		1437	}
788	};	1438	};
789		1439
790	cf::map->attach (prio => -10000, package => cf::mapsupport::);	1440	sub find_async {
		1441	my ($path, $origin) = @_;
791		1442
792	#############################################################################	1443	$path = normalise $path, $origin && $origin->{path};
793	# load/save perl data associated with player->ob objects
794		1444
795	sub all_objects(@) {	1445	if (my $map = $cf::MAP{$path}) {
796	@_, map all_objects ($_->inv), @_	1446	return $map if $map->in_memory == cf::MAP_IN_MEMORY;
797	}
798
799	# TODO: compatibility cruft, remove when no longer needed
800	cf::player->attach (
801	on_load => sub {
802	my ($pl, $path) = @_;
803
804	for my $o (all_objects $pl->ob) {
805	if (my $value = $o->get_ob_key_value ("_perl_data")) {
806	$o->set_ob_key_value ("_perl_data");
807
808	%$o = %{ Storable::thaw pack "H*", $value };
809	}
810	}
811	},	1447	}
812	);
813		1448
814	#############################################################################	1449	$MAP_PREFETCH{$path} = 0;
		1450	$MAP_PREFETCHER->ready;
815		1451
816	=head2 CORE EXTENSIONS	1452	()
		1453	}
817		1454
818	Functions and methods that extend core crossfire objects.	1455	sub save {
		1456	my ($self) = @_;
819		1457
820	=head3 cf::player	1458	my $lock = cf::lock_acquire "map_data:" . $self->path;
		1459
		1460	$self->{last_save} = $cf::RUNTIME;
		1461
		1462	return unless $self->dirty;
		1463
		1464	my $save = $self->save_path; utf8::encode $save;
		1465	my $uniq = $self->uniq_path; utf8::encode $uniq;
		1466
		1467	$self->{load_path} = $save;
		1468
		1469	return if $self->{deny_save};
		1470
		1471	local $self->{last_access} = $self->last_access;#d#
		1472
		1473	cf::async {
		1474	$_->contr->save for $self->players;
		1475	};
		1476
		1477	if ($uniq) {
		1478	$self->_save_objects ($save, cf::IO_HEADER \| cf::IO_OBJECTS);
		1479	$self->_save_objects ($uniq, cf::IO_UNIQUES);
		1480	} else {
		1481	$self->_save_objects ($save, cf::IO_HEADER \| cf::IO_OBJECTS \| cf::IO_UNIQUES);
		1482	}
		1483	}
		1484
		1485	sub swap_out {
		1486	my ($self) = @_;
		1487
		1488	# save first because save cedes
		1489	$self->save;
		1490
		1491	my $lock = cf::lock_acquire "map_data:" . $self->path;
		1492
		1493	return if $self->players;
		1494	return if $self->in_memory != cf::MAP_IN_MEMORY;
		1495	return if $self->{deny_save};
		1496
		1497	$self->clear;
		1498	$self->in_memory (cf::MAP_SWAPPED);
		1499	}
		1500
		1501	sub reset_at {
		1502	my ($self) = @_;
		1503
		1504	# TODO: safety, remove and allow resettable per-player maps
		1505	return 1e99 if $self->isa ("ext::map_per_player");#d#
		1506	return 1e99 if $self->{deny_reset};
		1507
		1508	my $time = $self->fixed_resettime ? $self->{instantiate_time} : $self->last_access;
		1509	my $to = List::Util::min $MAX_RESET, $self->reset_timeout \|\| $DEFAULT_RESET;
		1510
		1511	$time + $to
		1512	}
		1513
		1514	sub should_reset {
		1515	my ($self) = @_;
		1516
		1517	$self->reset_at <= $cf::RUNTIME
		1518	}
		1519
		1520	sub rename {
		1521	my ($self, $new_path) = @_;
		1522
		1523	normalise $new_path;
		1524
		1525	$self->unlink_save;
		1526
		1527	delete $cf::MAP{$self->path};
		1528	$self->{path} = $new_path; $self->path ($self->{path});
		1529	$cf::MAP{$self->path} = $self;
		1530
		1531	$self->save;
		1532	}
		1533
		1534	sub reset {
		1535	my ($self) = @_;
		1536
		1537	my $lock = cf::lock_acquire "map_data:$self->{path}";
		1538
		1539	return if $self->players;
		1540	return if $self->isa ("ext::map_per_player");#d#
		1541
		1542	warn "resetting map ", $self->path;#d#
		1543
		1544	delete $cf::MAP{$self->path};
		1545
		1546	$self->in_memory (cf::MAP_SWAPPED);
		1547	$self->clear;
		1548
		1549	$_->clear_links_to ($self) for values %cf::MAP;
		1550
		1551	$self->unlink_save;
		1552	$self->destroy;
		1553	}
		1554
		1555	my $nuke_counter = "aaaa";
		1556
		1557	sub nuke {
		1558	my ($self) = @_;
		1559
		1560	$self->{deny_save} = 1;
		1561	$self->reset_timeout (1);
		1562	$self->rename ("{nuke}/" . ($nuke_counter++));
		1563	$self->reset; # polite request, might not happen
		1564	}
		1565
		1566	=item cf::map::unique_maps
		1567
		1568	Returns an arrayref of paths of all shared maps that have
		1569	instantiated unique items. May block.
		1570
		1571	=cut
		1572
		1573	sub unique_maps() {
		1574	my $files = aio_readdir cf::localdir . "/" . cf::uniquedir
		1575	or return;
		1576
		1577	my @paths;
		1578
		1579	for (@$files) {
		1580	utf8::decode $_;
		1581	next if /\.pst$/;
		1582	next unless /^$PATH_SEP/o;
		1583
		1584	s/\.map$//;
		1585	push @paths, $_;
		1586	}
		1587
		1588	\@paths
		1589	}
		1590
		1591	package cf;
		1592
		1593	=back
		1594
		1595	=head3 cf::object
		1596
		1597	=cut
		1598
		1599	package cf::object;
821		1600
822	=over 4	1601	=over 4
823		1602
824	=item cf::player::exists $login	1603	=item $ob->inv_recursive
825		1604
826	Returns true when the given account exists.	1605	Returns the inventory of the object _and_ their inventories, recursively.
827		1606
828	=cut	1607	=cut
829		1608
830	sub cf::player::exists($) {	1609	sub inv_recursive_;
831	cf::player::find $_[0]	1610	sub inv_recursive_ {
832	or -f sprintf "%s/%s/%s/%s.pl", cf::localdir, cf::playerdir, ($_[0]) x 2;	1611	map { $_, inv_recursive_ $_->inv } @_
833	}	1612	}
834		1613
835	=item $player->ext_reply ($msgid, $msgtype, %msg)	1614	sub inv_recursive {
836		1615	inv_recursive_ inv $_[0]
837	Sends an ext reply to the player.
838
839	=cut
840
841	sub cf::player::ext_reply($$$%) {
842	my ($self, $id, %msg) = @_;
843
844	$msg{msgid} = $id;
845
846	$self->send ("ext " . to_json \%msg);
847	}	1616	}
		1617
		1618	package cf;
848		1619
849	=back	1620	=back
850		1621
851	=head3 cf::object::player	1622	=head3 cf::object::player
852		1623
…		…
890	(ref $cf::CFG{"may_$access"}	1661	(ref $cf::CFG{"may_$access"}
891	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}	1662	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}
892	: $cf::CFG{"may_$access"})	1663	: $cf::CFG{"may_$access"})
893	}	1664	}
894		1665
		1666	=item $player_object->enter_link
		1667
		1668	Freezes the player and moves him/her to a special map (C<{link}>).
		1669
		1670	The player should be reasonably safe there for short amounts of time. You
		1671	I<MUST> call C<leave_link> as soon as possible, though.
		1672
		1673	Will never block.
		1674
		1675	=item $player_object->leave_link ($map, $x, $y)
		1676
		1677	Moves the player out of the special C<{link}> map onto the specified
		1678	map. If the map is not valid (or omitted), the player will be moved back
		1679	to the location he/she was before the call to C<enter_link>, or, if that
		1680	fails, to the emergency map position.
		1681
		1682	Might block.
		1683
		1684	=cut
		1685
		1686	sub link_map {
		1687	unless ($LINK_MAP) {
		1688	$LINK_MAP = cf::map::find "{link}"
		1689	or do { warn "FATAL: unable to provide {link} map, exiting."; exit 1 };
		1690	$LINK_MAP->load;
		1691	}
		1692
		1693	$LINK_MAP
		1694	}
		1695
		1696	sub cf::object::player::enter_link {
		1697	my ($self) = @_;
		1698
		1699	$self->deactivate_recursive;
		1700
		1701	return if UNIVERSAL::isa $self->map, "ext::map_link";
		1702
		1703	$self->{_link_pos} \|\|= [$self->map->{path}, $self->x, $self->y]
		1704	if $self->map;
		1705
		1706	$self->enter_map ($LINK_MAP \|\| link_map, 20, 20);
		1707	}
		1708
		1709	sub cf::object::player::leave_link {
		1710	my ($self, $map, $x, $y) = @_;
		1711
		1712	my $link_pos = delete $self->{_link_pos};
		1713
		1714	unless ($map) {
		1715	# restore original map position
		1716	($map, $x, $y) = @{ $link_pos \|\| [] };
		1717	$map = cf::map::find $map;
		1718
		1719	unless ($map) {
		1720	($map, $x, $y) = @$EMERGENCY_POSITION;
		1721	$map = cf::map::find $map
		1722	or die "FATAL: cannot load emergency map\n";
		1723	}
		1724	}
		1725
		1726	($x, $y) = (-1, -1)
		1727	unless (defined $x) && (defined $y);
		1728
		1729	# use -1 or undef as default coordinates, not 0, 0
		1730	($x, $y) = ($map->enter_x, $map->enter_y)
		1731	if $x <=0 && $y <= 0;
		1732
		1733	$map->load;
		1734	$map->load_diag;
		1735
		1736	return unless $self->contr->active;
		1737	$self->activate_recursive;
		1738	$self->enter_map ($map, $x, $y);
		1739	}
		1740
		1741	cf::player->attach (
		1742	on_logout => sub {
		1743	my ($pl) = @_;
		1744
		1745	# abort map switching before logout
		1746	if ($pl->ob->{_link_pos}) {
		1747	cf::sync_job {
		1748	$pl->ob->leave_link
		1749	};
		1750	}
		1751	},
		1752	on_login => sub {
		1753	my ($pl) = @_;
		1754
		1755	# try to abort aborted map switching on player login :)
		1756	# should happen only on crashes
		1757	if ($pl->ob->{_link_pos}) {
		1758	$pl->ob->enter_link;
		1759	(async {
		1760	# we need this sleep as the login has a concurrent enter_exit running
		1761	# and this sleep increases chances of the player not ending up in scorn
		1762	$pl->ob->reply (undef,
		1763	"There was an internal problem at your last logout, "
		1764	. "the server will try to bring you to your intended destination in a second.",
		1765	cf::NDI_RED);
		1766	Coro::Timer::sleep 1;
		1767	$pl->ob->leave_link;
		1768	})->prio (2);
		1769	}
		1770	},
		1771	);
		1772
		1773	=item $player_object->goto ($path, $x, $y)
		1774
		1775	=cut
		1776
		1777	sub cf::object::player::goto {
		1778	my ($self, $path, $x, $y) = @_;
		1779
		1780	$self->enter_link;
		1781
		1782	(async {
		1783	my $map = cf::map::find $path;
		1784	$map = $map->customise_for ($self) if $map;
		1785
		1786	# warn "entering ", $map->path, " at ($x, $y)\n"
		1787	# if $map;
		1788
		1789	$map or $self->message ("The exit to '" . ($path->visible_name) . "' is closed", cf::NDI_UNIQUE \| cf::NDI_RED);
		1790
		1791	$self->leave_link ($map, $x, $y);
		1792	})->prio (1);
		1793	}
		1794
		1795	=item $player_object->enter_exit ($exit_object)
		1796
		1797	=cut
		1798
		1799	sub parse_random_map_params {
		1800	my ($spec) = @_;
		1801
		1802	my $rmp = { # defaults
		1803	xsize => 10,
		1804	ysize => 10,
		1805	};
		1806
		1807	for (split /\n/, $spec) {
		1808	my ($k, $v) = split /\s+/, $_, 2;
		1809
		1810	$rmp->{lc $k} = $v if (length $k) && (length $v);
		1811	}
		1812
		1813	$rmp
		1814	}
		1815
		1816	sub prepare_random_map {
		1817	my ($exit) = @_;
		1818
		1819	# all this does is basically replace the /! path by
		1820	# a new random map path (?random/...) with a seed
		1821	# that depends on the exit object
		1822
		1823	my $rmp = parse_random_map_params $exit->msg;
		1824
		1825	if ($exit->map) {
		1826	$rmp->{region} = $exit->map->region_name;
		1827	$rmp->{origin_map} = $exit->map->path;
		1828	$rmp->{origin_x} = $exit->x;
		1829	$rmp->{origin_y} = $exit->y;
		1830	}
		1831
		1832	$rmp->{random_seed} \|\|= $exit->random_seed;
		1833
		1834	my $data = cf::to_json $rmp;
		1835	my $md5 = Digest::MD5::md5_hex $data;
		1836
		1837	if (my $fh = aio_open "$cf::RANDOM_MAPS/$md5.meta", O_WRONLY \| O_CREAT, 0666) {
		1838	aio_write $fh, 0, (length $data), $data, 0;
		1839
		1840	$exit->slaying ("?random/$md5");
		1841	$exit->msg (undef);
		1842	}
		1843	}
		1844
		1845	sub cf::object::player::enter_exit {
		1846	my ($self, $exit) = @_;
		1847
		1848	return unless $self->type == cf::PLAYER;
		1849
		1850	$self->enter_link;
		1851
		1852	(async {
		1853	$self->deactivate_recursive; # just to be sure
		1854	unless (eval {
		1855	prepare_random_map $exit
		1856	if $exit->slaying eq "/!";
		1857
		1858	my $path = new_from_path cf::map $exit->slaying, $exit->map && $exit->map->path;
		1859	$self->goto ($path, $exit->stats->hp, $exit->stats->sp);
		1860
		1861	1;
		1862	}) {
		1863	$self->message ("Something went wrong deep within the crossfire server. "
		1864	. "I'll try to bring you back to the map you were before. "
		1865	. "Please report this to the dungeon master!",
		1866	cf::NDI_UNIQUE \| cf::NDI_RED);
		1867
		1868	warn "ERROR in enter_exit: $@";
		1869	$self->leave_link;
		1870	}
		1871	})->prio (1);
		1872	}
		1873
895	=head3 cf::client	1874	=head3 cf::client
896		1875
897	=over 4	1876	=over 4
898		1877
899	=item $client->send_drawinfo ($text, $flags)	1878	=item $client->send_drawinfo ($text, $flags)
…		…
942	on_reply => sub {	1921	on_reply => sub {
943	my ($ns, $msg) = @_;	1922	my ($ns, $msg) = @_;
944		1923
945	# this weird shuffling is so that direct followup queries	1924	# this weird shuffling is so that direct followup queries
946	# get handled first	1925	# get handled first
947	my $queue = delete $ns->{query_queue};	1926	my $queue = delete $ns->{query_queue}
		1927	or return; # be conservative, not sure how that can happen, but we saw a crash here
948		1928
949	(shift @$queue)->[1]->($msg);	1929	(shift @$queue)->[1]->($msg);
950		1930
951	push @{ $ns->{query_queue} }, @$queue;	1931	push @{ $ns->{query_queue} }, @$queue;
952		1932
…		…
958	}	1938	}
959	}	1939	}
960	},	1940	},
961	);	1941	);
962		1942
963	=item $client->coro (\&cb)	1943	=item $client->async (\&cb)
964		1944
965	Create a new coroutine, running the specified callback. The coroutine will	1945	Create a new coroutine, running the specified callback. The coroutine will
966	be automatically cancelled when the client gets destroyed (e.g. on logout,	1946	be automatically cancelled when the client gets destroyed (e.g. on logout,
967	or loss of connection).	1947	or loss of connection).
968		1948
969	=cut	1949	=cut
970		1950
971	sub cf::client::coro {	1951	sub cf::client::async {
972	my ($self, $cb) = @_;	1952	my ($self, $cb) = @_;
973		1953
974	my $coro; $coro = async {	1954	my $coro = &Coro::async ($cb);
975	eval {
976	$cb->();
977	};
978	warn $@ if $@;
979	};
980		1955
981	$coro->on_destroy (sub {	1956	$coro->on_destroy (sub {
982	delete $self->{_coro}{$coro+0};	1957	delete $self->{_coro}{$coro+0};
983	});	1958	});
984		1959
…		…
1156		2131
1157	{	2132	{
1158	my $path = cf::localdir . "/database.pst";	2133	my $path = cf::localdir . "/database.pst";
1159		2134
1160	sub db_load() {	2135	sub db_load() {
1161	warn "loading database $path\n";#d# remove later
1162	$DB = stat $path ? Storable::retrieve $path : { };	2136	$DB = stat $path ? Storable::retrieve $path : { };
1163	}	2137	}
1164		2138
1165	my $pid;	2139	my $pid;
1166		2140
1167	sub db_save() {	2141	sub db_save() {
1168	warn "saving database $path\n";#d# remove later
1169	waitpid $pid, 0 if $pid;	2142	waitpid $pid, 0 if $pid;
1170	if (0 == ($pid = fork)) {	2143	if (0 == ($pid = fork)) {
1171	$DB->{_meta}{version} = 1;	2144	$DB->{_meta}{version} = 1;
1172	Storable::nstore $DB, "$path~";	2145	Storable::nstore $DB, "$path~";
1173	rename "$path~", $path;	2146	rename "$path~", $path;
…		…
1221	open my $fh, "<:utf8", cf::confdir . "/config"	2194	open my $fh, "<:utf8", cf::confdir . "/config"
1222	or return;	2195	or return;
1223		2196
1224	local $/;	2197	local $/;
1225	*CFG = YAML::Syck::Load <$fh>;	2198	*CFG = YAML::Syck::Load <$fh>;
		2199
		2200	$EMERGENCY_POSITION = $CFG{emergency_position} \|\| ["/world/world_105_115", 5, 37];
		2201
		2202	$cf::map::MAX_RESET = $CFG{map_max_reset} if exists $CFG{map_max_reset};
		2203	$cf::map::DEFAULT_RESET = $CFG{map_default_reset} if exists $CFG{map_default_reset};
		2204
		2205	if (exists $CFG{mlockall}) {
		2206	eval {
		2207	$CFG{mlockall} ? eval "mlockall()" : eval "munlockall()"
		2208	and die "WARNING: m(un)lockall failed: $!\n";
		2209	};
		2210	warn $@ if $@;
		2211	}
1226	}	2212	}
1227		2213
1228	sub main {	2214	sub main {
		2215	# we must not ever block the main coroutine
		2216	local $Coro::idle = sub {
		2217	Carp::cluck "FATAL: Coro::idle was called, major BUG, use cf::sync_job!\n";#d#
		2218	async { Event::one_event };
		2219	};
		2220
1229	cfg_load;	2221	cfg_load;
1230	db_load;	2222	db_load;
1231	load_extensions;	2223	load_extensions;
1232	Event::loop;	2224	Event::loop;
1233	}	2225	}
1234		2226
1235	#############################################################################	2227	#############################################################################
1236	# initialisation	2228	# initialisation and cleanup
1237		2229
		2230	# install some emergency cleanup handlers
		2231	BEGIN {
		2232	for my $signal (qw(INT HUP TERM)) {
		2233	Event->signal (
		2234	data => WF_AUTOCANCEL,
		2235	signal => $signal,
		2236	cb => sub {
		2237	cf::cleanup "SIG$signal";
		2238	},
		2239	);
		2240	}
		2241	}
		2242
		2243	sub emergency_save() {
		2244	my $freeze_guard = cf::freeze_mainloop;
		2245
		2246	warn "enter emergency perl save\n";
		2247
		2248	cf::sync_job {
		2249	# use a peculiar iteration method to avoid tripping on perl
		2250	# refcount bugs in for. also avoids problems with players
		2251	# and maps saved/destroyed asynchronously.
		2252	warn "begin emergency player save\n";
		2253	for my $login (keys %cf::PLAYER) {
		2254	my $pl = $cf::PLAYER{$login} or next;
		2255	$pl->valid or next;
		2256	$pl->save;
		2257	}
		2258	warn "end emergency player save\n";
		2259
		2260	warn "begin emergency map save\n";
		2261	for my $path (keys %cf::MAP) {
		2262	my $map = $cf::MAP{$path} or next;
		2263	$map->valid or next;
		2264	$map->save;
		2265	}
		2266	warn "end emergency map save\n";
		2267	};
		2268
		2269	warn "leave emergency perl save\n";
		2270	}
		2271
1238	sub _perl_reload() {	2272	sub reload() {
		2273	# can/must only be called in main
		2274	if ($Coro::current != $Coro::main) {
		2275	warn "can only reload from main coroutine\n";
		2276	return;
		2277	}
		2278
1239	warn "reloading...";	2279	warn "reloading...";
1240		2280
		2281	warn "freezing server";
		2282	my $guard = freeze_mainloop;
		2283	cf::emergency_save;
		2284
		2285	warn "sync database to disk";
		2286	cf::db_sync;
		2287	IO::AIO::flush;
		2288
1241	eval {	2289	eval {
1242	local $FREEZE = 1;	2290	# if anything goes wrong in here, we should simply crash as we already saved
1243		2291
1244	cf::emergency_save;
1245
1246	# cancel all watchers	2292	warn "cancel all watchers";
1247	for (Event::all_watchers) {	2293	for (Event::all_watchers) {
1248	$_->cancel if $_->data & WF_AUTOCANCEL;	2294	$_->cancel if $_->data & WF_AUTOCANCEL;
1249	}	2295	}
1250		2296
1251	# cancel all extension coros	2297	warn "cancel all extension coros";
1252	$_->cancel for values %EXT_CORO;	2298	$_->cancel for values %EXT_CORO;
1253	%EXT_CORO = ();	2299	%EXT_CORO = ();
1254		2300
		2301	warn "remove commands";
		2302	%COMMAND = ();
		2303
		2304	warn "remove ext commands";
		2305	%EXTCMD = ();
		2306
1255	# unload all extensions	2307	warn "unload/nuke all extensions";
1256	for (@exts) {	2308	for my $pkg (@EXTS) {
1257	warn "unloading <$_>";	2309	warn "... unloading $pkg";
1258	unload_extension $_;	2310
		2311	if (my $cb = $pkg->can ("unload")) {
		2312	eval {
		2313	$cb->($pkg);
		2314	1
		2315	} or warn "$pkg unloaded, but with errors: $@";
1259	}	2316	}
1260		2317
		2318	warn "... nuking $pkg";
		2319	Symbol::delete_package $pkg;
		2320	}
		2321
1261	# unload all modules loaded from $LIBDIR	2322	warn "unload all perl modules loaded from $LIBDIR";
1262	while (my ($k, $v) = each %INC) {	2323	while (my ($k, $v) = each %INC) {
1263	next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;	2324	next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;
1264		2325
1265	warn "removing <$k>";	2326	warn "removing <$k>";
1266	delete $INC{$k};	2327	delete $INC{$k};
…		…
1273	}	2334	}
1274		2335
1275	Symbol::delete_package $k;	2336	Symbol::delete_package $k;
1276	}	2337	}
1277		2338
1278	# sync database to disk
1279	cf::db_sync;
1280	IO::AIO::flush;
1281
1282	# get rid of safe::, as good as possible	2339	warn "get rid of safe::, as good as possible";
1283	Symbol::delete_package "safe::$_"	2340	Symbol::delete_package "safe::$_"
1284	for qw(cf::attachable cf::object cf::object::player cf::client cf::player cf::map cf::party cf::region);	2341	for qw(cf::attachable cf::object cf::object::player cf::client cf::player cf::map cf::party cf::region);
1285		2342
1286	# remove register_script_function callbacks
1287	# TODO
1288
1289	# unload cf.pm "a bit"	2343	warn "unload cf.pm \"a bit\"";
1290	delete $INC{"cf.pm"};	2344	delete $INC{"cf.pm"};
1291		2345
1292	# don't, removes xs symbols, too,	2346	# don't, removes xs symbols, too,
1293	# and global variables created in xs	2347	# and global variables created in xs
1294	#Symbol::delete_package __PACKAGE__;	2348	#Symbol::delete_package __PACKAGE__;
1295		2349
1296	# reload cf.pm
1297	warn "reloading cf.pm";	2350	warn "reloading cf.pm";
1298	require cf;	2351	require cf;
1299	cf::_connect_to_perl; # nominally unnecessary, but cannot hurt	2352	cf::_connect_to_perl; # nominally unnecessary, but cannot hurt
1300		2353
1301	# load config and database again	2354	warn "load config and database again";
1302	cf::cfg_load;	2355	cf::cfg_load;
1303	cf::db_load;	2356	cf::db_load;
1304		2357
1305	# load extensions
1306	warn "load extensions";	2358	warn "load extensions";
1307	cf::load_extensions;	2359	cf::load_extensions;
1308		2360
1309	# reattach attachments to objects	2361	warn "reattach attachments to objects/players";
1310	warn "reattach";
1311	_global_reattach;	2362	_global_reattach;
		2363	warn "reattach attachments to maps";
		2364	reattach $_ for values %MAP;
1312	};	2365	};
1313	warn $@ if $@;	2366
		2367	if ($@) {
		2368	warn $@;
		2369	warn "error while reloading, exiting.";
		2370	exit 1;
		2371	}
1314		2372
1315	warn "reloaded";	2373	warn "reloaded";
1316	};	2374	};
1317		2375
1318	sub perl_reload() {
1319	_perl_reload;
1320	}
1321
1322	register "<global>", __PACKAGE__;
1323
1324	register_command "perl-reload" => sub {	2376	register_command "reload" => sub {
1325	my ($who, $arg) = @_;	2377	my ($who, $arg) = @_;
1326		2378
1327	if ($who->flag (FLAG_WIZ)) {	2379	if ($who->flag (FLAG_WIZ)) {
		2380	$who->message ("start of reload.");
		2381	reload;
1328	$who->message ("reloading...");	2382	$who->message ("end of reload.");
1329	_perl_reload;
1330	}	2383	}
1331	};	2384	};
1332		2385
1333	unshift @INC, $LIBDIR;	2386	unshift @INC, $LIBDIR;
1334		2387
…		…
1336	reentrant => 0,	2389	reentrant => 0,
1337	prio => 0,	2390	prio => 0,
1338	at => $NEXT_TICK \|\| $TICK,	2391	at => $NEXT_TICK \|\| $TICK,
1339	data => WF_AUTOCANCEL,	2392	data => WF_AUTOCANCEL,
1340	cb => sub {	2393	cb => sub {
1341	unless ($FREEZE) {	2394	$NOW = Event::time;
		2395
1342	cf::server_tick; # one server iteration	2396	cf::server_tick; # one server iteration
1343	$RUNTIME += $TICK;	2397	$RUNTIME += $TICK;
1344	}
1345
1346	$NEXT_TICK += $TICK;	2398	$NEXT_TICK += $TICK;
		2399
		2400	$WAIT_FOR_TICK->broadcast;
		2401	$WAIT_FOR_TICK_ONE->send if $WAIT_FOR_TICK_ONE->awaited;
1347		2402
1348	# if we are delayed by four ticks or more, skip them all	2403	# if we are delayed by four ticks or more, skip them all
1349	$NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;	2404	$NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;
1350		2405
1351	$TICK_WATCHER->at ($NEXT_TICK);	2406	$TICK_WATCHER->at ($NEXT_TICK);
…		…
1353	},	2408	},
1354	);	2409	);
1355		2410
1356	IO::AIO::max_poll_time $TICK * 0.2;	2411	IO::AIO::max_poll_time $TICK * 0.2;
1357		2412
		2413	$AIO_POLL_WATCHER = Event->io (
1358	Event->io (fd => IO::AIO::poll_fileno,	2414	fd => IO::AIO::poll_fileno,
1359	poll => 'r',	2415	poll => 'r',
1360	prio => 5,	2416	prio => 5,
1361	data => WF_AUTOCANCEL,	2417	data => WF_AUTOCANCEL,
1362	cb => \&IO::AIO::poll_cb);	2418	cb => \&IO::AIO::poll_cb,
		2419	);
1363		2420
1364	# we must not ever block the main coroutine	2421	$WRITE_RUNTIME_WATCHER = Event->timer (
1365	$Coro::idle = sub {	2422	data => WF_AUTOCANCEL,
1366	#Carp::cluck "FATAL: Coro::idle was called, major BUG\n";#d#	2423	after => 0,
1367	warn "FATAL: Coro::idle was called, major BUG\n";	2424	interval => 10,
		2425	cb => sub {
1368	(Coro::unblock_sub {	2426	(Coro::unblock_sub {
1369	Event::one_event;	2427	write_runtime
		2428	or warn "ERROR: unable to write runtime file: $!";
1370	})->();	2429	})->();
1371	};	2430	},
		2431	);
		2432
		2433	END { cf::emergency_save }
1372		2434
1373	1	2435	1
1374		2436

Diff Legend

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

Comparing deliantra/server/lib/cf.pm (file contents): Revision 1.104 by root, Sat Dec 30 16:56:16 2006 UTC vs. Revision 1.169 by root, Sun Jan 14 01:09:46 2007 UTC

Diff Legend

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.104 by root, Sat Dec 30 16:56:16 2006 UTC vs.
Revision 1.169 by root, Sun Jan 14 01:09:46 2007 UTC