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.45 by root, Sat Aug 26 23:36:32 2006 UTC vs.
Revision 1.219 by root, Sat Feb 17 03:19:44 2007 UTC

1	package cf;	1	package cf;
		2
		3	use utf8;
		4	use strict;
2		5
3	use Symbol;	6	use Symbol;
4	use List::Util;	7	use List::Util;
5	use Storable;	8	use Storable;
6	use Opcode;	9	use Opcode;
7	use Safe;	10	use Safe;
8	use Safe::Hole;	11	use Safe::Hole;
9		12
		13	use Coro 3.5 ();
		14	use Coro::Event;
		15	use Coro::Timer;
		16	use Coro::Signal;
		17	use Coro::Semaphore;
		18	use Coro::AIO;
		19
		20	use BDB ();
		21	use Data::Dumper;
		22	use Digest::MD5;
		23	use Fcntl;
		24	use IO::AIO 2.32 ();
		25	use YAML::Syck ();
10	use Time::HiRes;	26	use Time::HiRes;
11	use Event;	27	use Compress::LZF;
		28
		29	Compress::LZF::sfreeze_cr { }; # prime Compress::LZF so it does not use require later
		30
12	$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
13		32
14	use strict;	33	sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload
15		34
		35	# work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode?
		36	$YAML::Syck::ImplicitUnicode = 1;
		37
		38	$Coro::main->prio (Coro::PRIO_MAX); # run main coroutine ("the server") with very high priority
		39
16	our %COMMAND = ();	40	our %COMMAND = ();
		41	our %COMMAND_TIME = ();
		42
		43	our @EXTS = (); # list of extension package names
		44	our %EXTCMD = ();
		45	our %EXT_CORO = (); # coroutines bound to extensions
		46	our %EXT_MAP = (); # pluggable maps
		47
17	our @EVENT;	48	our @EVENT;
18	our %PROP_TYPE;	49	our $LIBDIR = datadir . "/ext";
19	our %PROP_IDX;
20	our $LIBDIR = maps_directory "perl";
21		50
22	our $TICK = MAX_TIME * 1e-6;	51	our $TICK = MAX_TIME * 1e-6;
23	our $TICK_WATCHER;	52	our $TICK_WATCHER;
		53	our $AIO_POLL_WATCHER;
		54	our $NEXT_RUNTIME_WRITE; # when should the runtime file be written
24	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;
		61
		62	our %CFG;
		63
		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;
		99
		100	#############################################################################
		101
		102	=head2 GLOBAL VARIABLES
		103
		104	=over 4
		105
		106	=item $cf::UPTIME
		107
		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.
		114
		115	=item $cf::LIBDIR
		116
		117	The perl library directory, where extensions and cf-specific modules can
		118	be found. It will be added to C<@INC> automatically.
		119
		120	=item $cf::NOW
		121
		122	The time of the last (current) server tick.
		123
		124	=item $cf::TICK
		125
		126	The interval between server ticks, in seconds.
		127
		128	=item %cf::CFG
		129
		130	Configuration for the server, loaded from C</etc/crossfire/config>, or
		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.
		139
		140	=back
		141
		142	=cut
25		143
26	BEGIN {	144	BEGIN {
27	*CORE::GLOBAL::warn = sub {	145	*CORE::GLOBAL::warn = sub {
28	my $msg = join "", @_;	146	my $msg = join "", @_;
		147	utf8::encode $msg;
		148
29	$msg .= "\n"	149	$msg .= "\n"
30	unless $msg =~ /\n$/;	150	unless $msg =~ /\n$/;
31		151
32	print STDERR "cfperl: $msg";
33	LOG llevError, "cfperl: $msg";	152	LOG llevError, $msg;
34	};	153	};
35	}	154	}
36		155
37	my %ignore_set = (MAP_PROP_PATH => 1); # I hate the plug-in api. Deeply!	156	@safe::cf::global::ISA = @cf::global::ISA = 'cf::attachable';
38		157	@safe::cf::object::ISA = @cf::object::ISA = 'cf::attachable';
39	# generate property mutators	158	@safe::cf::player::ISA = @cf::player::ISA = 'cf::attachable';
40	sub prop_gen {	159	@safe::cf::client::ISA = @cf::client::ISA = 'cf::attachable';
41	my ($prefix, $class) = @_;	160	@safe::cf::map::ISA = @cf::map::ISA = 'cf::attachable';
42
43	no strict 'refs';
44
45	for my $prop (keys %PROP_TYPE) {
46	$prop =~ /^\Q$prefix\E_(.*$)/ or next;
47	my $sub = lc $1;
48
49	my $type = $PROP_TYPE{$prop};
50	my $idx = $PROP_IDX {$prop};
51
52	*{"$class\::get_$sub"} = *{"$class\::$sub"} = sub {
53	$_[0]->get_property ($type, $idx)
54	};
55
56	*{"$class\::set_$sub"} = sub {
57	$_[0]->set_property ($type, $idx, $_[1]);
58	} unless $ignore_set{$prop};
59	}
60	}
61
62	# auto-generate most of the API
63
64	prop_gen OBJECT_PROP => "cf::object";
65	# CFAPI_OBJECT_ANIMATION?
66	prop_gen PLAYER_PROP => "cf::object::player";
67
68	prop_gen MAP_PROP => "cf::map";
69	prop_gen ARCH_PROP => "cf::arch";
70
71	@safe::cf::object::player::ISA = @cf::object::player::ISA = 'cf::object';	161	@safe::cf::object::player::ISA = @cf::object::player::ISA = 'cf::object';
72		162
73	# we bless all objects into (empty) derived classes to force a method lookup	163	# we bless all objects into (empty) derived classes to force a method lookup
74	# within the Safe compartment.	164	# within the Safe compartment.
75	for my $pkg (qw(cf::object cf::object::player cf::player cf::map cf::party cf::region cf::arch)) {	165	for my $pkg (qw(
		166	cf::global cf::attachable
		167	cf::object cf::object::player
		168	cf::client cf::player
		169	cf::arch cf::living
		170	cf::map cf::party cf::region
		171	)) {
76	no strict 'refs';	172	no strict 'refs';
77	@{"safe::$pkg\::wrap::ISA"} = @{"$pkg\::wrap::ISA"} = $pkg;	173	@{"safe::$pkg\::wrap::ISA"} = @{"$pkg\::wrap::ISA"} = $pkg;
78	}	174	}
79		175
80	$Event::DIED = sub {	176	$Event::DIED = sub {
81	warn "error in event callback: @_";	177	warn "error in event callback: @_";
82	};	178	};
83		179
84	my %ext_pkg;	180	=head2 UTILITY FUNCTIONS
85	my @exts;
86	my @hook;
87	my %command;
88	my %extcmd;
89		181
90	#############################################################################	182	=over 4
91	# utility functions	183
		184	=item dumpval $ref
		185
		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	}
92		206
93	use JSON::Syck (); # TODO# replace by JSON::PC once working	207	use JSON::Syck (); # TODO# replace by JSON::PC once working
		208
		209	=item $ref = cf::from_json $json
		210
		211	Converts a JSON string into the corresponding perl data structure.
		212
		213	=cut
94		214
95	sub from_json($) {	215	sub from_json($) {
96	$JSON::Syck::ImplicitUnicode = 1; # work around JSON::Syck bugs	216	$JSON::Syck::ImplicitUnicode = 1; # work around JSON::Syck bugs
97	JSON::Syck::Load $_[0]	217	JSON::Syck::Load $_[0]
98	}	218	}
99		219
		220	=item $json = cf::to_json $ref
		221
		222	Converts a perl data structure into its JSON representation.
		223
		224	=cut
		225
100	sub to_json($) {	226	sub to_json($) {
101	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs	227	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs
102	JSON::Syck::Dump $_[0]	228	JSON::Syck::Dump $_[0]
103	}	229	}
104		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
		384	}
		385
		386	=back
		387
		388	=cut
		389
105	#############################################################################	390	#############################################################################
106	# "new" plug-in system
107		391
108	=item cf::object::attach ... # NYI	392	=head2 ATTACHABLE OBJECTS
109		393
110	=item cf::attach_global ...	394	Many objects in crossfire are so-called attachable objects. That means you can
		395	attach callbacks/event handlers (a collection of which is called an "attachment")
		396	to it. All such attachable objects support the following methods.
111		397
112	=item cf::attach_to_type $object_type, ...	398	In the following description, CLASS can be any of C<global>, C<object>
		399	C<player>, C<client> or C<map> (i.e. the attachable objects in
		400	crossfire+).
113		401
114	=item cf::attach_to_objects ...	402	=over 4
115		403
116	=item cf::attach_to_players ...	404	=item $attachable->attach ($attachment, key => $value...)
117		405
118	=item cf::attach_to_maps ...	406	=item $attachable->detach ($attachment)
119		407
		408	Attach/detach a pre-registered attachment to a specific object and give it
		409	the specified key/value pairs as arguments.
		410
		411	Example, attach a minesweeper attachment to the given object, making it a
		412	10x10 minesweeper game:
		413
		414	$obj->attach (minesweeper => width => 10, height => 10);
		415
		416	=item $bool = $attachable->attached ($name)
		417
		418	Checks wether the named attachment is currently attached to the object.
		419
		420	=item cf::CLASS->attach ...
		421
		422	=item cf::CLASS->detach ...
		423
		424	Define an anonymous attachment and attach it to all objects of the given
		425	CLASS. See the next function for an explanation of its arguments.
		426
		427	You can attach to global events by using the C<cf::global> class.
		428
		429	Example, log all player logins:
		430
		431	cf::player->attach (
		432	on_login => sub {
		433	my ($pl) = @_;
		434	...
		435	},
		436	);
		437
		438	Example, attach to the jeweler skill:
		439
		440	cf::object->attach (
		441	type => cf::SKILL,
		442	subtype => cf::SK_JEWELER,
		443	on_use_skill => sub {
		444	my ($sk, $ob, $part, $dir, $msg) = @_;
		445	...
		446	},
		447	);
		448
120	=item cf:register_attachment $name, ...	449	=item cf::CLASS::attachment $name, ...
121		450
122	prio => $number, # lower is earlier	451	Register an attachment by C<$name> through which attachable objects of the
123	on_xxx => \&cb,	452	given CLASS can refer to this attachment.
		453
		454	Some classes such as crossfire maps and objects can specify attachments
		455	that are attached at load/instantiate time, thus the need for a name.
		456
		457	These calls expect any number of the following handler/hook descriptions:
		458
		459	=over 4
		460
		461	=item prio => $number
		462
		463	Set the priority for all following handlers/hooks (unless overwritten
		464	by another C<prio> setting). Lower priority handlers get executed
		465	earlier. The default priority is C<0>, and many built-in handlers are
		466	registered at priority C<-1000>, so lower priorities should not be used
		467	unless you know what you are doing.
		468
		469	=item type => $type
		470
		471	(Only for C<< cf::object->attach >> calls), limits the attachment to the
		472	given type of objects only (the additional parameter C<subtype> can be
		473	used to further limit to the given subtype).
		474
		475	=item on_I<event> => \&cb
		476
		477	Call the given code reference whenever the named event happens (event is
		478	something like C<instantiate>, C<apply>, C<use_skill> and so on, and which
		479	handlers are recognised generally depends on the type of object these
		480	handlers attach to).
		481
		482	See F<include/eventinc.h> for the full list of events supported, and their
		483	class.
		484
124	package => package::,	485	=item package => package::
		486
		487	Look for sub functions of the name C<< on_I<event> >> in the given
		488	package and register them. Only handlers for eevents supported by the
		489	object/class are recognised.
		490
		491	=back
		492
		493	Example, define an attachment called "sockpuppet" that calls the given
		494	event handler when a monster attacks:
		495
		496	cf::object::attachment sockpuppet =>
		497	on_skill_attack => sub {
		498	my ($self, $victim) = @_;
		499	...
		500	}
		501	}
		502
		503	=item $attachable->valid
		504
		505	Just because you have a perl object does not mean that the corresponding
		506	C-level object still exists. If you try to access an object that has no
		507	valid C counterpart anymore you get an exception at runtime. This method
		508	can be used to test for existence of the C object part without causing an
		509	exception.
125		510
126	=cut	511	=cut
127		512
128	# the following variables are defined in .xs and must not be re-created	513	# the following variables are defined in .xs and must not be re-created
129	our @CB_GLOBAL = (); # registry for all global events	514	our @CB_GLOBAL = (); # registry for all global events
		515	our @CB_ATTACHABLE = (); # registry for all attachables
130	our @CB_OBJECT = (); # all objects (should not be used except in emergency)	516	our @CB_OBJECT = (); # all objects (should not be used except in emergency)
131	our @CB_PLAYER = ();	517	our @CB_PLAYER = ();
		518	our @CB_CLIENT = ();
132	our @CB_TYPE = (); # registry for type (cf-object class) based events	519	our @CB_TYPE = (); # registry for type (cf-object class) based events
133	our @CB_MAP = ();	520	our @CB_MAP = ();
134		521
135	my %attachment;	522	my %attachment;
136		523
		524	sub cf::attachable::thawer_merge {
		525	# simply override everything except _meta
		526	local $_[0]{_meta};
		527	%{$_[0]} = %{$_[1]};
		528	}
		529
137	sub _attach_cb($\%$$$) {	530	sub _attach_cb($$$$) {
138	my ($registry, $undo, $event, $prio, $cb) = @_;	531	my ($registry, $event, $prio, $cb) = @_;
139		532
140	use sort 'stable';	533	use sort 'stable';
141		534
142	$cb = [$prio, $cb];	535	$cb = [$prio, $cb];
143		536
144	@{$registry->[$event]} = sort	537	@{$registry->[$event]} = sort
145	{ $a->[0] cmp $b->[0] }	538	{ $a->[0] cmp $b->[0] }
146	@{$registry->[$event] || []}, $cb;	539	@{$registry->[$event] || []}, $cb;
147
148	push @{$undo->{cb}}, [$event, $cb];
149	}	540	}
		541
		542	# hack
		543	my %attachable_klass = map +($_ => 1), KLASS_OBJECT, KLASS_CLIENT, KLASS_PLAYER, KLASS_MAP;
150		544
151	# attach handles attaching event callbacks	545	# attach handles attaching event callbacks
152	# the only thing the caller has to do is pass the correct	546	# the only thing the caller has to do is pass the correct
153	# registry (== where the callback attaches to).	547	# registry (== where the callback attaches to).
154	sub _attach(\@$@) {	548	sub _attach {
155	my ($registry, $klass, @arg) = @_;	549	my ($registry, $klass, @arg) = @_;
156		550
		551	my $object_type;
157	my $prio = 0;	552	my $prio = 0;
158
159	my %undo = (
160	registry => $registry,
161	cb => [],
162	);
163
164	my %cb_id = map +("on_" . lc $EVENT[$_][0], $_) , grep $EVENT[$_][1] == $klass, 0 .. $#EVENT;	553	my %cb_id = map +("on_" . lc $EVENT[$_][0], $_) , grep $EVENT[$_][1] == $klass, 0 .. $#EVENT;
		554
		555	#TODO: get rid of this hack
		556	if ($attachable_klass{$klass}) {
		557	%cb_id = (%cb_id, map +("on_" . lc $EVENT[$_][0], $_) , grep $EVENT[$_][1] == KLASS_ATTACHABLE, 0 .. $#EVENT);
		558	}
165		559
166	while (@arg) {	560	while (@arg) {
167	my $type = shift @arg;	561	my $type = shift @arg;
168		562
169	if ($type eq "prio") {	563	if ($type eq "prio") {
170	$prio = shift @arg;	564	$prio = shift @arg;
171		565
		566	} elsif ($type eq "type") {
		567	$object_type = shift @arg;
		568	$registry = $CB_TYPE[$object_type] ||= [];
		569
		570	} elsif ($type eq "subtype") {
		571	defined $object_type or Carp::croak "subtype specified without type";
		572	my $object_subtype = shift @arg;
		573	$registry = $CB_TYPE[$object_type + $object_subtype * NUM_SUBTYPES] ||= [];
		574
172	} elsif ($type eq "package") {	575	} elsif ($type eq "package") {
173	my $pkg = shift @arg;	576	my $pkg = shift @arg;
174		577
175	while (my ($name, $id) = each %cb_id) {	578	while (my ($name, $id) = each %cb_id) {
176	if (my $cb = $pkg->can ($name)) {	579	if (my $cb = $pkg->can ($name)) {
177	_attach_cb $registry, %undo, $id, $prio, $cb;	580	_attach_cb $registry, $id, $prio, $cb;
178	}	581	}
179	}	582	}
180		583
181	} elsif (exists $cb_id{$type}) {	584	} elsif (exists $cb_id{$type}) {
182	_attach_cb $registry, %undo, $cb_id{$type}, $prio, shift @arg;	585	_attach_cb $registry, $cb_id{$type}, $prio, shift @arg;
183		586
184	} elsif (ref $type) {	587	} elsif (ref $type) {
185	warn "attaching objects not supported, ignoring.\n";	588	warn "attaching objects not supported, ignoring.\n";
186		589
187	} else {	590	} else {
188	shift @arg;	591	shift @arg;
189	warn "attach argument '$type' not supported, ignoring.\n";	592	warn "attach argument '$type' not supported, ignoring.\n";
190	}	593	}
191	}	594	}
192
193	\%undo
194	}	595	}
195		596
196	sub cf::object::attach {	597	sub _object_attach {
197	die;	598	my ($obj, $name, %arg) = @_;
198	}
199		599
200	sub attach_global {	600	return if exists $obj->{_attachment}{$name};
201	_attach @CB_GLOBAL, KLASS_GLOBAL, @_
202	}
203		601
204	sub attach_to_type {	602	if (my $attach = $attachment{$name}) {
205	my $type = shift;	603	my $registry = $obj->registry;
206		604
207	_attach @{$CB_TYPE[$type]}, KLASS_OBJECT, @_	605	for (@$attach) {
208	}	606	my ($klass, @attach) = @$_;
		607	_attach $registry, $klass, @attach;
		608	}
209		609
210	sub attach_to_objects {	610	$obj->{$name} = \%arg;
211	_attach @CB_OBJECT, KLASS_OBJECT, @_	611	} else {
212	}	612	warn "object uses attachment '$name' that is not available, postponing.\n";
		613	}
213		614
214	sub attach_to_players {	615	$obj->{_attachment}{$name} = undef;
215	_attach @CB_PLAYER, KLASS_PLAYER, @_
216	}	616	}
217		617
218	sub attach_to_maps {	618	sub cf::attachable::attach {
219	_attach @CB_MAP, KLASS_MAP, @_	619	if (ref $_[0]) {
220	}	620	_object_attach @_;
		621	} else {
		622	_attach shift->_attach_registry, @_;
		623	}
		624	};
221		625
222	sub register_attachment {	626	# all those should be optimised
		627	sub cf::attachable::detach {
		628	my ($obj, $name) = @_;
		629
		630	if (ref $obj) {
		631	delete $obj->{_attachment}{$name};
		632	reattach ($obj);
		633	} else {
		634	Carp::croak "cannot, currently, detach class attachments";
		635	}
		636	};
		637
		638	sub cf::attachable::attached {
		639	my ($obj, $name) = @_;
		640
		641	exists $obj->{_attachment}{$name}
		642	}
		643
		644	for my $klass (qw(ATTACHABLE GLOBAL OBJECT PLAYER CLIENT MAP)) {
		645	eval "#line " . __LINE__ . " 'cf.pm'
		646	sub cf::\L$klass\E::_attach_registry {
		647	(\\\@CB_$klass, KLASS_$klass)
		648	}
		649
		650	sub cf::\L$klass\E::attachment {
223	my $name = shift;	651	my \$name = shift;
224		652
225	$attachment{$name} = [@_];	653	\$attachment{\$name} = [[KLASS_$klass, \@_]];
		654	}
		655	";
		656	die if $@;
226	}	657	}
227		658
228	our $override;	659	our $override;
229	our @invoke_results = (); # referenced from .xs code. TODO: play tricks with reify and mortals?	660	our @invoke_results = (); # referenced from .xs code. TODO: play tricks with reify and mortals?
230		661
…		…
244	for (@$callbacks) {	675	for (@$callbacks) {
245	eval { &{$_->[1]} };	676	eval { &{$_->[1]} };
246		677
247	if ($@) {	678	if ($@) {
248	warn "$@";	679	warn "$@";
249	warn "... while processing $EVENT[$event][0] event, skipping processing altogether.\n";	680	warn "... while processing $EVENT[$event][0](@_) event, skipping processing altogether.\n";
250	override;	681	override;
251	}	682	}
252		683
253	return 1 if $override;	684	return 1 if $override;
254	}	685	}
255		686
256	0	687	0
257	}	688	}
		689
		690	=item $bool = cf::global::invoke (EVENT_CLASS_XXX, ...)
		691
		692	=item $bool = $attachable->invoke (EVENT_CLASS_XXX, ...)
		693
		694	Generate an object-specific event with the given arguments.
		695
		696	This API is preliminary (most likely, the EVENT_CLASS_xxx prefix will be
		697	removed in future versions), and there is no public API to access override
		698	results (if you must, access C<@cf::invoke_results> directly).
		699
		700	=back
		701
		702	=cut
258		703
259	#############################################################################	704	#############################################################################
260	# object support	705	# object support
261		706
262	sub instantiate {	707	sub reattach {
		708	# basically do the same as instantiate, without calling instantiate
263	my ($obj, $data) = @_;	709	my ($obj) = @_;
		710
		711	bless $obj, ref $obj; # re-bless in case extensions have been reloaded
		712
264	my $registry = $obj->registry;	713	my $registry = $obj->registry;
265		714
266	$data = from_json $data;	715	@$registry = ();
267		716
268	for (@$data) {	717	delete $obj->{_attachment} unless scalar keys %{ $obj->{_attachment} || {} };
269	my ($pri, $name, @args) = @$_;
270		718
		719	for my $name (keys %{ $obj->{_attachment} || {} }) {
271	if (my $attach = $attachment{$name}) {	720	if (my $attach = $attachment{$name}) {
		721	for (@$attach) {
		722	my ($klass, @attach) = @$_;
272	_attach @$registry, KLASS_OBJECT, @$attach;	723	_attach $registry, $klass, @attach;
		724	}
		725	} else {
		726	warn "object uses attachment '$name' that is not available, postponing.\n";
		727	}
		728	}
		729	}
273		730
274	if (my $cb = delete $registry->[EVENT_OBJECT_INSTANTIATE]) {	731	cf::attachable->attach (
		732	prio => -1000000,
		733	on_instantiate => sub {
		734	my ($obj, $data) = @_;
		735
		736	$data = from_json $data;
		737
		738	for (@$data) {
		739	my ($name, $args) = @$_;
		740
		741	$obj->attach ($name, %{$args || {} });
		742	}
		743	},
		744	on_reattach => \&reattach,
		745	on_clone => sub {
		746	my ($src, $dst) = @_;
		747
		748	@{$dst->registry} = @{$src->registry};
		749
		750	%$dst = %$src;
		751
		752	%{$dst->{_attachment}} = %{$src->{_attachment}}
		753	if exists $src->{_attachment};
		754	},
		755	);
		756
		757	sub object_freezer_save {
		758	my ($filename, $rdata, $objs) = @_;
		759
		760	sync_job {
		761	if (length $$rdata) {
		762	warn sprintf "saving %s (%d,%d)\n",
		763	$filename, length $$rdata, scalar @$objs;
		764
		765	if (my $fh = aio_open "$filename~", O_WRONLY | O_CREAT, 0600) {
		766	chmod SAVE_MODE, $fh;
		767	aio_write $fh, 0, (length $$rdata), $$rdata, 0;
		768	aio_fsync $fh if $cf::USE_FSYNC;
		769	close $fh;
		770
275	for (@$cb) {	771	if (@$objs) {
276	eval { $_->[1]->($obj, @args); };	772	if (my $fh = aio_open "$filename.pst~", O_WRONLY | O_CREAT, 0600) {
277	if ($@) {	773	chmod SAVE_MODE, $fh;
278	warn "$@";	774	my $data = Storable::nfreeze { version => 1, objs => $objs };
279	warn "... while processing '$name' instantiate with args <@args>\n";	775	aio_write $fh, 0, (length $data), $data, 0;
		776	aio_fsync $fh if $cf::USE_FSYNC;
		777	close $fh;
		778	aio_rename "$filename.pst~", "$filename.pst";
280	}	779	}
		780	} else {
		781	aio_unlink "$filename.pst";
		782	}
		783
		784	aio_rename "$filename~", $filename;
		785	} else {
		786	warn "FATAL: $filename~: $!\n";
		787	}
		788	} else {
		789	aio_unlink $filename;
		790	aio_unlink "$filename.pst";
		791	}
		792	}
		793	}
		794
		795	sub object_freezer_as_string {
		796	my ($rdata, $objs) = @_;
		797
		798	use Data::Dumper;
		799
		800	$$rdata . Dumper $objs
		801	}
		802
		803	sub object_thawer_load {
		804	my ($filename) = @_;
		805
		806	my ($data, $av);
		807
		808	(aio_load $filename, $data) >= 0
		809	or return;
		810
		811	unless (aio_stat "$filename.pst") {
		812	(aio_load "$filename.pst", $av) >= 0
		813	or return;
		814	$av = eval { (Storable::thaw $av)->{objs} };
		815	}
		816
		817	warn sprintf "loading %s (%d)\n",
		818	$filename, length $data, scalar @{$av || []};#d#
		819	return ($data, $av);
		820	}
		821
		822	#############################################################################
		823	# command handling &c
		824
		825	=item cf::register_command $name => \&callback($ob,$args);
		826
		827	Register a callback for execution when the client sends the user command
		828	$name.
		829
		830	=cut
		831
		832	sub register_command {
		833	my ($name, $cb) = @_;
		834
		835	my $caller = caller;
		836	#warn "registering command '$name/$time' to '$caller'";
		837
		838	push @{ $COMMAND{$name} }, [$caller, $cb];
		839	}
		840
		841	=item cf::register_extcmd $name => \&callback($pl,$packet);
		842
		843	Register a callbackf ro execution when the client sends an extcmd packet.
		844
		845	If the callback returns something, it is sent back as if reply was being
		846	called.
		847
		848	=cut
		849
		850	sub register_extcmd {
		851	my ($name, $cb) = @_;
		852
		853	$EXTCMD{$name} = $cb;
		854	}
		855
		856	cf::player->attach (
		857	on_command => sub {
		858	my ($pl, $name, $params) = @_;
		859
		860	my $cb = $COMMAND{$name}
		861	or return;
		862
		863	for my $cmd (@$cb) {
		864	$cmd->[1]->($pl->ob, $params);
		865	}
		866
		867	cf::override;
		868	},
		869	on_extcmd => sub {
		870	my ($pl, $buf) = @_;
		871
		872	my $msg = eval { from_json $buf };
		873
		874	if (ref $msg) {
		875	if (my $cb = $EXTCMD{$msg->{msgtype}}) {
		876	if (my %reply = $cb->($pl, $msg)) {
		877	$pl->ext_reply ($msg->{msgid}, %reply);
281	}	878	}
282	}	879	}
283	} else {	880	} else {
284	warn "object uses attachment $name that is not available, postponing.\n";	881	warn "player " . ($pl->ob->name) . " sent unparseable ext message: <$buf>\n";
285	}	882	}
286		883
287	push @{$obj->{_attachment}}, $name;	884	cf::override;
288	}
289	}
290
291	# basically do the same as instantiate, without calling instantiate
292	sub reattach {
293	my ($obj) = @_;
294	my $registry = $obj->registry;
295
296	warn "reattach<@_, $_>\n";
297	}
298
299	attach_to_objects
300	prio => -1000000,
301	on_clone => sub {
302	my ($src, $dst) = @_;
303
304	@{$dst->registry} = @{$src->registry};
305	warn "registry clone ", join ":", @{$src->registry};#d#
306
307	%$dst = %$src;
308
309	$dst->{_attachment} = [@{ $src->{_attachment} }]
310	if exists $src->{_attachment};
311
312	warn "clone<@_>\n";#d#
313	},	885	},
314	;	886	);
315
316	#############################################################################
317	# old plug-in events
318
319	sub inject_event {
320	my $extension = shift;
321	my $event_code = shift;
322
323	my $cb = $hook[$event_code]{$extension}
324	or return;
325
326	&$cb
327	}
328
329	sub inject_global_event {
330	my $event = shift;
331
332	my $cb = $hook[$event]
333	or return;
334
335	List::Util::max map &$_, values %$cb
336	}
337
338	sub inject_command {
339	my ($name, $obj, $params) = @_;
340
341	for my $cmd (@{ $command{$name} }) {
342	$cmd->[1]->($obj, $params);
343	}
344
345	-1
346	}
347
348	sub register_command {
349	my ($name, $time, $cb) = @_;
350
351	my $caller = caller;
352	#warn "registering command '$name/$time' to '$caller'";
353
354	push @{ $command{$name} }, [$time, $cb, $caller];
355	$COMMAND{"$name\000"} = List::Util::max map $_->[0], @{ $command{$name} };
356	}
357
358	sub register_extcmd {
359	my ($name, $cb) = @_;
360
361	my $caller = caller;
362	#warn "registering extcmd '$name' to '$caller'";
363
364	$extcmd{$name} = [$cb, $caller];
365	}
366
367	sub register {
368	my ($base, $pkg) = @_;
369
370	#TODO
371	}
372		887
373	sub load_extension {	888	sub load_extension {
374	my ($path) = @_;	889	my ($path) = @_;
375		890
376	$path =~ /([^\/\\]+)\.ext$/ or die "$path";	891	$path =~ /([^\/\\]+)\.ext$/ or die "$path";
377	my $base = $1;	892	my $base = $1;
378	my $pkg = $1;	893	my $pkg = $1;
379	$pkg =~ s/[^[:word:]]/_/g;	894	$pkg =~ s/[^[:word:]]/_/g;
380	$pkg = "ext::$pkg";	895	$pkg = "ext::$pkg";
381		896
382	warn "loading '$path' into '$pkg'\n";	897	warn "... loading '$path' into '$pkg'\n";
383		898
384	open my $fh, "<:utf8", $path	899	open my $fh, "<:utf8", $path
385	or die "$path: $!";	900	or die "$path: $!";
386		901
387	my $source =	902	my $source =
388	"package $pkg; use strict; use utf8;\n"	903	"package $pkg; use strict; use utf8;\n"
389	. "#line 1 \"$path\"\n{\n"	904	. "#line 1 \"$path\"\n{\n"
390	. (do { local $/; <$fh> })	905	. (do { local $/; <$fh> })
391	. "\n};\n1";	906	. "\n};\n1";
392		907
393	eval $source	908	unless (eval $source) {
394	or die "$path: $@";	909	my $msg = $@ ? "$path: $@\n"
395		910	: "extension disabled.\n";
396	push @exts, $pkg;	911	if ($source =~ /^#!.*perl.*#.*MANDATORY/m) { # ugly match
397	$ext_pkg{$base} = $pkg;	912	warn $@;
398		913	warn "mandatory extension failed to load, exiting.\n";
399	# no strict 'refs';	914	exit 1;
400	# @{"$pkg\::ISA"} = ext::;	915	}
401		916	die $@;
402	register $base, $pkg;
403	}
404
405	sub unload_extension {
406	my ($pkg) = @_;
407
408	warn "removing extension $pkg\n";
409
410	# remove hooks
411	#TODO
412	# for my $idx (0 .. $#PLUGIN_EVENT) {
413	# delete $hook[$idx]{$pkg};
414	# }	917	}
415		918
416	# remove commands	919	push @EXTS, $pkg;
417	for my $name (keys %command) {
418	my @cb = grep $_->[2] ne $pkg, @{ $command{$name} };
419
420	if (@cb) {
421	$command{$name} = \@cb;
422	$COMMAND{"$name\000"} = List::Util::max map $_->[0], @cb;
423	} else {
424	delete $command{$name};
425	delete $COMMAND{"$name\000"};
426	}
427	}
428
429	# remove extcmds
430	for my $name (grep $extcmd{$_}[1] eq $pkg, keys %extcmd) {
431	delete $extcmd{$name};
432	}
433
434	if (my $cb = $pkg->can ("unload")) {
435	eval {
436	$cb->($pkg);
437	1
438	} or warn "$pkg unloaded, but with errors: $@";
439	}
440
441	Symbol::delete_package $pkg;
442	}	920	}
443		921
444	sub load_extensions {	922	sub load_extensions {
445	my $LIBDIR = maps_directory "perl";
446
447	for my $ext (<$LIBDIR/*.ext>) {	923	for my $ext (<$LIBDIR/*.ext>) {
448	next unless -r $ext;	924	next unless -r $ext;
449	eval {	925	eval {
450	load_extension $ext;	926	load_extension $ext;
451	1	927	1
452	} or warn "$ext not loaded: $@";	928	} or warn "$ext not loaded: $@";
453	}	929	}
454	}	930	}
455		931
456	sub _perl_reload(&) {	932	#############################################################################
		933
		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 {
457	my ($msg) = @_;	1461	my ($map) = @_;
458		1462
459	$msg->("reloading...");	1463	my @diag; # diagonal neighbours
460		1464
461	eval {	1465	for (0 .. 3) {
462	# 1. cancel all watchers	1466	my $neigh = $map->tile_path ($_)
463	$_->cancel for Event::all_watchers;	1467	or next;
		1468	$neigh = find $neigh, $map
		1469	or next;
		1470	$neigh->load;
464		1471
465	# 2. unload all extensions	1472	push @diag, [$neigh->tile_path (($_ + 3) % 4), $neigh],
466	for (@exts) {	1473	[$neigh->tile_path (($_ + 1) % 4), $neigh];
467	$msg->("unloading <$_>");	1474	}
468	unload_extension $_;
469	}
470		1475
471	# 3. unload all modules loaded from $LIBDIR	1476	for (@diag) {
472	while (my ($k, $v) = each %INC) {	1477	my $neigh = find @$_
473	next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;	1478	or next;
		1479	$neigh->load;
		1480	}
		1481	}
474		1482
475	$msg->("removing <$k>");	1483	sub find_sync {
476	delete $INC{$k};	1484	my ($path, $origin) = @_;
477		1485
478	$k =~ s/\.pm$//;	1486	cf::sync_job { find $path, $origin }
479	$k =~ s/\//::/g;	1487	}
480		1488
481	if (my $cb = $k->can ("unload_module")) {	1489	sub do_load_sync {
482	$cb->();	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};
483	}	1516	}
484
485	Symbol::delete_package $k;
486	}
487
488	# 4. get rid of safe::, as good as possible
489	Symbol::delete_package "safe::$_"
490	for qw(cf::object cf::object::player cf::player cf::map cf::party cf::region);
491
492	# 5. remove register_script_function callbacks
493	# TODO
494		1517	}
495	# 6. unload cf.pm "a bit"	1518	undef $MAP_PREFETCHER;
496	delete $INC{"cf.pm"};
497
498	# don't, removes xs symbols, too,
499	# and global variables created in xs
500	#Symbol::delete_package __PACKAGE__;
501
502	# 7. reload cf.pm
503	$msg->("reloading cf.pm");
504	require cf;
505	};	1519	};
506	$msg->($@) if $@;	1520	$MAP_PREFETCHER->prio (6);
507		1521
508	$msg->("reloaded");	1522	()
509	};	1523	}
510		1524
511	sub perl_reload() {	1525	sub save {
512	_perl_reload {	1526	my ($self) = @_;
513	warn $_[0];	1527
514	print "$_[0]\n";	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;
515	};	1545	};
516	}
517		1546
518	register_command "perl-reload", 0, sub {	1547	if ($uniq) {
519	my ($who, $arg) = @_;	1548	$self->_save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS);
520		1549	$self->_save_objects ($uniq, cf::IO_UNIQUES);
521	if ($who->flag (FLAG_WIZ)) {
522	_perl_reload {
523	warn $_[0];
524	$who->message ($_[0]);
525	};
526	}
527	};
528
529	#############################################################################
530	# extcmd framework, basically convert ext <msg>
531	# into pkg::->on_extcmd_arg1 (...) while shortcutting a few
532
533	attach_to_players
534	on_extcmd => sub {
535	my ($pl, $buf) = @_;
536
537	my $msg = eval { from_json $buf };
538
539	if (ref $msg) {
540	if (my $cb = $extcmd{$msg->{msgtype}}) {
541	if (my %reply = $cb->[0]->($pl, $msg)) {
542	$pl->ext_reply ($msg->{msgid}, %reply);
543	}
544	}
545	} else {
546	warn "player " . ($pl->ob->name) . " sent unparseable ext message: <$buf>\n";
547	}
548
549	cf::override;
550	},
551	;
552
553	#############################################################################
554	# load/save/clean perl data associated with a map
555
556	*cf::mapsupport::on_clean = sub {
557	my ($map) = @_;
558
559	my $path = $map->tmpname;
560	defined $path or return;
561
562	unlink "$path.cfperl";
563	};
564
565	*cf::mapsupport::on_swapin =
566	*cf::mapsupport::on_load = sub {
567	my ($map) = @_;
568
569	my $path = $map->tmpname;
570	$path = $map->path unless defined $path;
571
572	open my $fh, "<:raw", "$path.cfperl"
573	or return; # no perl data
574
575	my $data = Storable::thaw do { local $/; <$fh> };
576
577	$data->{version} <= 1
578	or return; # too new
579
580	$map->_set_obs ($data->{obs});
581	};
582
583	*cf::mapsupport::on_swapout = sub {
584	my ($map) = @_;
585
586	my $path = $map->tmpname;
587	$path = $map->path unless defined $path;
588
589	my $obs = $map->_get_obs;
590
591	if (defined $obs) {
592	open my $fh, ">:raw", "$path.cfperl"
593	or die "$path.cfperl: $!";
594
595	stat $path;
596
597	print $fh Storable::nfreeze {
598	size => (stat _)[7],
599	time => (stat _)[9],
600	version => 1,
601	obs => $obs,
602	};
603
604	chmod SAVE_MODE, "$path.cfperl"; # very racy, but cf-compatible *g*
605	} else {	1550	} else {
606	unlink "$path.cfperl";	1551	$self->_save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS | cf::IO_UNIQUES);
607	}
608	};
609
610	attach_to_maps prio => -10000, package => cf::mapsupport::;
611
612	#############################################################################
613	# load/save perl data associated with player->ob objects
614
615	sub all_objects(@) {
616	@_, map all_objects ($_->inv), @_
617	}
618
619	attach_to_players
620	on_load => sub {
621	my ($pl, $path) = @_;
622
623	for my $o (all_objects $pl->ob) {
624	if (my $value = $o->get_ob_key_value ("_perl_data")) {
625	$o->set_ob_key_value ("_perl_data");
626
627	%$o = %{ Storable::thaw pack "H*", $value };
628	}
629	}
630	},	1552	}
631	on_save => sub {	1553	}
632	my ($pl, $path) = @_;
633		1554
634	$_->set_ob_key_value (_perl_data => unpack "H*", Storable::nfreeze $_)	1555	sub swap_out {
635	for grep %$_, all_objects $pl->ob;	1556	my ($self) = @_;
		1557
		1558	# save first because save cedes
		1559	$self->save;
		1560
		1561	my $lock = cf::lock_acquire "map_data:" . $self->path;
		1562
		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;
636	},	1608	}
637	;
638		1609
639	#############################################################################	1610	delete $cf::MAP{$self->path};
640	# core extensions - in perl
641		1611
642	=item cf::player::exists $login	1612	$self->clear;
643		1613
644	Returns true when the given account exists.	1614	$_->clear_links_to ($self) for values %cf::MAP;
645		1615
646	=cut	1616	$self->unlink_save;
647		1617	$self->destroy;
648	sub cf::player::exists($) {
649	cf::player::find $_[0]
650	or -f sprintf "%s/%s/%s/%s.pl", cf::localdir, cf::playerdir, ($_[0]) x 2;
651	}	1618	}
652		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;
		1673
		1674	=over 4
		1675
		1676	=item $ob->inv_recursive
		1677
		1678	Returns the inventory of the object _and_ their inventories, recursively.
		1679
		1680	=cut
		1681
		1682	sub inv_recursive_;
		1683	sub inv_recursive_ {
		1684	map { $_, inv_recursive_ $_->inv } @_
		1685	}
		1686
		1687	sub inv_recursive {
		1688	inv_recursive_ inv $_[0]
		1689	}
		1690
		1691	package cf;
		1692
		1693	=back
		1694
		1695	=head3 cf::object::player
		1696
		1697	=over 4
		1698
653	=item $player->reply ($npc, $msg[, $flags])	1699	=item $player_object->reply ($npc, $msg[, $flags])
654		1700
655	Sends a message to the player, as if the npc C<$npc> replied. C<$npc>	1701	Sends a message to the player, as if the npc C<$npc> replied. C<$npc>
656	can be C<undef>. Does the right thing when the player is currently in a	1702	can be C<undef>. Does the right thing when the player is currently in a
657	dialogue with the given NPC character.	1703	dialogue with the given NPC character.
658		1704
659	=cut	1705	=cut
660		1706
661	# rough implementation of a future "reply" method that works	1707	# rough implementation of a future "reply" method that works
662	# with dialog boxes.	1708	# with dialog boxes.
		1709	#TODO: the first argument must go, split into a $npc->reply_to ( method
663	sub cf::object::player::reply($$$;$) {	1710	sub cf::object::player::reply($$$;$) {
664	my ($self, $npc, $msg, $flags) = @_;	1711	my ($self, $npc, $msg, $flags) = @_;
665		1712
666	$flags = cf::NDI_BROWN | cf::NDI_UNIQUE unless @_ >= 4;	1713	$flags = cf::NDI_BROWN | cf::NDI_UNIQUE unless @_ >= 4;
667		1714
…		…
671	$msg = $npc->name . " says: $msg" if $npc;	1718	$msg = $npc->name . " says: $msg" if $npc;
672	$self->message ($msg, $flags);	1719	$self->message ($msg, $flags);
673	}	1720	}
674	}	1721	}
675		1722
676	=item $player->ext_reply ($msgid, $msgtype, %msg)	1723	=item $player_object->may ("access")
677		1724
678	Sends an ext reply to the player.	1725	Returns wether the given player is authorized to access resource "access"
		1726	(e.g. "command_wizcast").
679		1727
680	=cut	1728	=cut
681		1729
682	sub cf::player::ext_reply($$$%) {	1730	sub cf::object::player::may {
		1731	my ($self, $access) = @_;
		1732
		1733	$self->flag (cf::FLAG_WIZ) ||
		1734	(ref $cf::CFG{"may_$access"}
		1735	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}
		1736	: $cf::CFG{"may_$access"})
		1737	}
		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 {
683	my ($self, $id, %msg) = @_;	1927	my ($self, $exit) = @_;
684		1928
685	$msg{msgid} = $id;	1929	return unless $self->type == cf::PLAYER;
686		1930
687	$self->send ("ext " . to_json \%msg);	1931	if ($exit->slaying eq "/!") {
688	}	1932	#TODO: this should de-fi-ni-te-ly not be a sync-job
		1933	cf::sync_job { prepare_random_map $exit };
		1934	}
689		1935
690	#############################################################################	1936	my $slaying = cf::map::normalise $exit->slaying, $exit->map && $exit->map->path;
691	# map scripting support	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
		1960	=head3 cf::client
		1961
		1962	=over 4
		1963
		1964	=item $client->send_drawinfo ($text, $flags)
		1965
		1966	Sends a drawinfo packet to the client. Circumvents output buffering so
		1967	should not be used under normal circumstances.
		1968
		1969	=cut
		1970
		1971	sub cf::client::send_drawinfo {
		1972	my ($self, $text, $flags) = @_;
		1973
		1974	utf8::encode $text;
		1975	$self->send_packet (sprintf "drawinfo %d %s", $flags, $text);
		1976	}
		1977
		1978
		1979	=item $success = $client->query ($flags, "text", \&cb)
		1980
		1981	Queues a query to the client, calling the given callback with
		1982	the reply text on a reply. flags can be C<cf::CS_QUERY_YESNO>,
		1983	C<cf::CS_QUERY_SINGLECHAR> or C<cf::CS_QUERY_HIDEINPUT> or C<0>.
		1984
		1985	Queries can fail, so check the return code. Or don't, as queries will become
		1986	reliable at some point in the future.
		1987
		1988	=cut
		1989
		1990	sub cf::client::query {
		1991	my ($self, $flags, $text, $cb) = @_;
		1992
		1993	return unless $self->state == ST_PLAYING
		1994	|| $self->state == ST_SETUP
		1995	|| $self->state == ST_CUSTOM;
		1996
		1997	$self->state (ST_CUSTOM);
		1998
		1999	utf8::encode $text;
		2000	push @{ $self->{query_queue} }, [(sprintf "query %d %s", $flags, $text), $cb];
		2001
		2002	$self->send_packet ($self->{query_queue}[0][0])
		2003	if @{ $self->{query_queue} } == 1;
		2004	}
		2005
		2006	cf::client->attach (
		2007	on_reply => sub {
		2008	my ($ns, $msg) = @_;
		2009
		2010	# this weird shuffling is so that direct followup queries
		2011	# get handled first
		2012	my $queue = delete $ns->{query_queue}
		2013	or return; # be conservative, not sure how that can happen, but we saw a crash here
		2014
		2015	(shift @$queue)->[1]->($msg);
		2016	return unless $ns->valid; # temporary(?) workaround for callback destroying socket
		2017
		2018	push @{ $ns->{query_queue} }, @$queue;
		2019
		2020	if (@{ $ns->{query_queue} } == @$queue) {
		2021	if (@$queue) {
		2022	$ns->send_packet ($ns->{query_queue}[0][0]);
		2023	} else {
		2024	$ns->state (ST_PLAYING) if $ns->state == ST_CUSTOM;
		2025	}
		2026	}
		2027	},
		2028	);
		2029
		2030	=item $client->async (\&cb)
		2031
		2032	Create a new coroutine, running the specified callback. The coroutine will
		2033	be automatically cancelled when the client gets destroyed (e.g. on logout,
		2034	or loss of connection).
		2035
		2036	=cut
		2037
		2038	sub cf::client::async {
		2039	my ($self, $cb) = @_;
		2040
		2041	my $coro = &Coro::async ($cb);
		2042
		2043	$coro->on_destroy (sub {
		2044	delete $self->{_coro}{$coro+0};
		2045	});
		2046
		2047	$self->{_coro}{$coro+0} = $coro;
		2048
		2049	$coro
		2050	}
		2051
		2052	cf::client->attach (
		2053	on_destroy => sub {
		2054	my ($ns) = @_;
		2055
		2056	$_->cancel for values %{ (delete $ns->{_coro}) || {} };
		2057	},
		2058	);
		2059
		2060	=back
		2061
		2062
		2063	=head2 SAFE SCRIPTING
		2064
		2065	Functions that provide a safe environment to compile and execute
		2066	snippets of perl code without them endangering the safety of the server
		2067	itself. Looping constructs, I/O operators and other built-in functionality
		2068	is not available in the safe scripting environment, and the number of
		2069	functions and methods that can be called is greatly reduced.
		2070
		2071	=cut
692		2072
693	our $safe = new Safe "safe";	2073	our $safe = new Safe "safe";
694	our $safe_hole = new Safe::Hole;	2074	our $safe_hole = new Safe::Hole;
695		2075
696	$SIG{FPE} = 'IGNORE';	2076	$SIG{FPE} = 'IGNORE';
697		2077
698	$safe->permit_only (Opcode::opset qw(:base_core :base_mem :base_orig :base_math sort time));	2078	$safe->permit_only (Opcode::opset qw(:base_core :base_mem :base_orig :base_math sort time));
699		2079
700	# here we export the classes and methods available to script code	2080	# here we export the classes and methods available to script code
701		2081
		2082	=pod
		2083
		2084	The following fucntions and emthods are available within a safe environment:
		2085
		2086	cf::object contr pay_amount pay_player map
		2087	cf::object::player player
		2088	cf::player peaceful
		2089	cf::map trigger
		2090
		2091	=cut
		2092
702	for (	2093	for (
703	["cf::object" => qw(contr pay_amount pay_player)],	2094	["cf::object" => qw(contr pay_amount pay_player map)],
704	["cf::object::player" => qw(player)],	2095	["cf::object::player" => qw(player)],
705	["cf::player" => qw(peaceful)],	2096	["cf::player" => qw(peaceful)],
		2097	["cf::map" => qw(trigger)],
706	) {	2098	) {
707	no strict 'refs';	2099	no strict 'refs';
708	my ($pkg, @funs) = @$_;	2100	my ($pkg, @funs) = @$_;
709	*{"safe::$pkg\::$_"} = $safe_hole->wrap (\&{"$pkg\::$_"})	2101	*{"safe::$pkg\::$_"} = $safe_hole->wrap (\&{"$pkg\::$_"})
710	for @funs;	2102	for @funs;
711	}	2103	}
		2104
		2105	=over 4
		2106
		2107	=item @retval = safe_eval $code, [var => value, ...]
		2108
		2109	Compiled and executes the given perl code snippet. additional var/value
		2110	pairs result in temporary local (my) scalar variables of the given name
		2111	that are available in the code snippet. Example:
		2112
		2113	my $five = safe_eval '$first + $second', first => 1, second => 4;
		2114
		2115	=cut
712		2116
713	sub safe_eval($;@) {	2117	sub safe_eval($;@) {
714	my ($code, %vars) = @_;	2118	my ($code, %vars) = @_;
715		2119
716	my $qcode = $code;	2120	my $qcode = $code;
…		…
739	}	2143	}
740		2144
741	wantarray ? @res : $res[0]	2145	wantarray ? @res : $res[0]
742	}	2146	}
743		2147
		2148	=item cf::register_script_function $function => $cb
		2149
		2150	Register a function that can be called from within map/npc scripts. The
		2151	function should be reasonably secure and should be put into a package name
		2152	like the extension.
		2153
		2154	Example: register a function that gets called whenever a map script calls
		2155	C<rent::overview>, as used by the C<rent> extension.
		2156
		2157	cf::register_script_function "rent::overview" => sub {
		2158	...
		2159	};
		2160
		2161	=cut
		2162
744	sub register_script_function {	2163	sub register_script_function {
745	my ($fun, $cb) = @_;	2164	my ($fun, $cb) = @_;
746		2165
747	no strict 'refs';	2166	no strict 'refs';
748	*{"safe::$fun"} = $safe_hole->wrap ($cb);	2167	*{"safe::$fun"} = $safe_hole->wrap ($cb);
749	}	2168	}
750		2169
		2170	=back
		2171
		2172	=cut
		2173
751	#############################################################################	2174	#############################################################################
752	# the server's main()	2175
		2176	=head2 EXTENSION DATABASE SUPPORT
		2177
		2178	Crossfire maintains a very simple database for extension use. It can
		2179	currently store anything that can be serialised using Storable, which
		2180	excludes objects.
		2181
		2182	The parameter C<$family> should best start with the name of the extension
		2183	using it, it should be unique.
		2184
		2185	=over 4
		2186
		2187	=item $value = cf::db_get $family => $key
		2188
		2189	Returns a single value from the database.
		2190
		2191	=item cf::db_put $family => $key => $value
		2192
		2193	Stores the given C<$value> in the family.
		2194
		2195	=cut
		2196
		2197	our $DB;
		2198
		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
		2214	my $path = cf::localdir . "/database.pst";
		2215	if (stat $path) {
		2216	cf::sync_job {
		2217	my $pst = Storable::retrieve $path;
		2218
		2219	cf::db_put (board => data => $pst->{board});
		2220	cf::db_put (guildrules => data => $pst->{guildrules});
		2221	cf::db_put (rent => balance => $pst->{rent}{balance});
		2222	BDB::db_env_txn_checkpoint $DB_ENV;
		2223
		2224	unlink $path;
		2225	};
		2226	}
		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 { };
		2244	}
		2245
		2246	#############################################################################
		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	}
		2253
		2254	sub cfg_load {
		2255	open my $fh, "<:utf8", cf::confdir . "/config"
		2256	or return;
		2257
		2258	local $/;
		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;
		2277	}
753		2278
754	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
		2288	cfg_load;
		2289	db_init;
		2290	load_extensions;
		2291
		2292	$TICK_WATCHER->start;
755	Event::loop;	2293	Event::loop;
756	}	2294	}
757		2295
758	#############################################################################	2296	#############################################################################
759	# initialisation	2297	# initialisation and cleanup
760		2298
761	register "<global>", __PACKAGE__;	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
		2354	sub reload() {
		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	}
		2360
		2361	warn "reloading...";
		2362
		2363	warn "entering sync_job";
		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";
		2376	for (Event::all_watchers) {
		2377	$_->cancel if $_->data & WF_AUTOCANCEL;
		2378	}
		2379
		2380	warn "flushing outstanding aio requests";
		2381	for (;;) {
		2382	BDB::flush;
		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: $@";
		2408	}
		2409
		2410	warn "... nuking $pkg";
		2411	Symbol::delete_package $pkg;
		2412	}
		2413
		2414	warn "unloading all perl modules loaded from $LIBDIR";
		2415	while (my ($k, $v) = each %INC) {
		2416	next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;
		2417
		2418	warn "... unloading $k";
		2419	delete $INC{$k};
		2420
		2421	$k =~ s/\.pm$//;
		2422	$k =~ s/\//::/g;
		2423
		2424	if (my $cb = $k->can ("unload_module")) {
		2425	$cb->();
		2426	}
		2427
		2428	Symbol::delete_package $k;
		2429	}
		2430
		2431	warn "getting rid of safe::, as good as possible";
		2432	Symbol::delete_package "safe::$_"
		2433	for qw(cf::attachable cf::object cf::object::player cf::client cf::player cf::map cf::party cf::region);
		2434
		2435	warn "unloading cf.pm \"a bit\"";
		2436	delete $INC{"cf.pm"};
		2437
		2438	# don't, removes xs symbols, too,
		2439	# and global variables created in xs
		2440	#Symbol::delete_package __PACKAGE__;
		2441
		2442	warn "unload completed, starting to reload now";
		2443
		2444	warn "reloading cf.pm";
		2445	require cf;
		2446	cf::_connect_to_perl; # nominally unnecessary, but cannot hurt
		2447
		2448	warn "loading config and database again";
		2449	cf::cfg_load;
		2450
		2451	warn "loading extensions";
		2452	cf::load_extensions;
		2453
		2454	warn "reattaching attachments to objects/players";
		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;
		2469	};
		2470
		2471	warn "reloaded";
		2472	};
		2473
		2474	our $RELOAD_WATCHER; # used only during reload
		2475
		2476	register_command "reload" => sub {
		2477	my ($who, $arg) = @_;
		2478
		2479	if ($who->flag (FLAG_WIZ)) {
		2480	$who->message ("reloading server.");
		2481
		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	},
		2493	);
		2494	}
		2495	};
762		2496
763	unshift @INC, $LIBDIR;	2497	unshift @INC, $LIBDIR;
764		2498
765	load_extensions;	2499	my $bug_warning = 0;
766		2500
767	$TICK_WATCHER = Event->timer (	2501	$TICK_WATCHER = Event->timer (
		2502	reentrant => 0,
		2503	parked => 1,
768	prio => 1,	2504	prio => 0,
769	at => $NEXT_TICK || 1,	2505	at => $NEXT_TICK || $TICK,
		2506	data => WF_AUTOCANCEL,
770	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
771	cf::server_tick; # one server iteration	2516	cf::server_tick; # one server iteration
772		2517	$RUNTIME += $TICK;
773	my $NOW = Event::time;
774	$NEXT_TICK += $TICK;	2518	$NEXT_TICK += $TICK;
775		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
776	# if we are delayed by four ticks, skip them all	2534	# if we are delayed by four ticks or more, skip them all
777	$NEXT_TICK = $NOW if $NOW >= $NEXT_TICK + $TICK * 4;	2535	$NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;
778		2536
779	$TICK_WATCHER->at ($NEXT_TICK);	2537	$TICK_WATCHER->at ($NEXT_TICK);
780	$TICK_WATCHER->start;	2538	$TICK_WATCHER->start;
781	},	2539	},
782	);	2540	);
783		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;
		2596	IO::AIO::max_poll_time $TICK * 0.1;
		2597	$AIO_POLL_WATCHER = Event->io (
		2598	reentrant => 0,
		2599	data => WF_AUTOCANCEL,
		2600	fd => IO::AIO::poll_fileno,
		2601	poll => 'r',
		2602	prio => 6,
		2603	cb => \&IO::AIO::poll_cb,
		2604	);
		2605	}
		2606
		2607	END { cf::emergency_save }
		2608
784	1	2609	1
785		2610

Diff Legend

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