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.84 by root, Mon Dec 11 02:54:57 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;
10	use IO::AIO ();	24	use IO::AIO 2.32 ();
11	use YAML::Syck ();	25	use YAML::Syck ();
12	use Time::HiRes;	26	use Time::HiRes;
13	use Event;	27	use Compress::LZF;
		28
		29	Compress::LZF::sfreeze_cr { }; # prime Compress::LZF so it does not use require later
		30
14	$Event::Eval = 1; # no idea why this is required, but it is	31	use Event; $Event::Eval = 1; # no idea why this is required, but it is
		32
		33	sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload
15		34
16	# work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode?	35	# work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode?
17	$YAML::Syck::ImplicitUnicode = 1;	36	$YAML::Syck::ImplicitUnicode = 1;
18		37
19	use strict;	38	$Coro::main->prio (Coro::PRIO_MAX); # run main coroutine ("the server") with very high priority
20		39
21	_init_vars;
22
23	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
24	our @EVENT;	48	our @EVENT;
25	our $LIBDIR = maps_directory "perl";	49	our $LIBDIR = datadir . "/ext";
26		50
27	our $TICK = MAX_TIME * 1e-6;	51	our $TICK = MAX_TIME * 1e-6;
28	our $TICK_WATCHER;	52	our $TICK_WATCHER;
		53	our $AIO_POLL_WATCHER;
		54	our $NEXT_RUNTIME_WRITE; # when should the runtime file be written
29	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;
30		61
31	our %CFG;	62	our %CFG;
32		63
33	our $UPTIME; $UPTIME ||= time;	64	our $UPTIME; $UPTIME ||= time;
		65	our $RUNTIME;
		66
		67	our %PLAYER; # all users
		68	our %MAP; # all maps
		69	our $LINK_MAP; # the special {link} map, which is always available
		70	our $RANDOM_MAPS = cf::localdir . "/random";
		71	our $BDB_ENV_DIR = cf::localdir . "/db";
		72
		73	our $WAIT_FOR_TICK; $WAIT_FOR_TICK ||= new Coro::Signal;
		74	our $WAIT_FOR_TICK_ONE; $WAIT_FOR_TICK_ONE ||= new Coro::Signal;
		75
		76	# used to convert map paths into valid unix filenames by replacing / by ∕
		77	our $PATH_SEP = "∕"; # U+2215, chosen purely for visual reasons
		78
		79	binmode STDOUT;
		80	binmode STDERR;
		81
		82	# read virtual server time, if available
		83	unless ($RUNTIME || !-e cf::localdir . "/runtime") {
		84	open my $fh, "<", cf::localdir . "/runtime"
		85	or die "unable to read runtime file: $!";
		86	$RUNTIME = <$fh> + 0.;
		87	}
		88
		89	mkdir cf::localdir;
		90	mkdir cf::localdir . "/" . cf::playerdir;
		91	mkdir cf::localdir . "/" . cf::tmpdir;
		92	mkdir cf::localdir . "/" . cf::uniquedir;
		93	mkdir $RANDOM_MAPS;
		94	mkdir $BDB_ENV_DIR;
		95
		96	our $EMERGENCY_POSITION;
		97
		98	sub cf::map::normalise;
34		99
35	#############################################################################	100	#############################################################################
36		101
37	=head2 GLOBAL VARIABLES	102	=head2 GLOBAL VARIABLES
38		103
39	=over 4	104	=over 4
40		105
41	=item $cf::UPTIME	106	=item $cf::UPTIME
42		107
43	The timestamp of the server start (so not actually an uptime).	108	The timestamp of the server start (so not actually an uptime).
		109
		110	=item $cf::RUNTIME
		111
		112	The time this server has run, starts at 0 and is increased by $cf::TICK on
		113	every server tick.
44		114
45	=item $cf::LIBDIR	115	=item $cf::LIBDIR
46		116
47	The perl library directory, where extensions and cf-specific modules can	117	The perl library directory, where extensions and cf-specific modules can
48	be found. It will be added to C<@INC> automatically.	118	be found. It will be added to C<@INC> automatically.
49		119
		120	=item $cf::NOW
		121
		122	The time of the last (current) server tick.
		123
50	=item $cf::TICK	124	=item $cf::TICK
51		125
52	The interval between server ticks, in seconds.	126	The interval between server ticks, in seconds.
53		127
54	=item %cf::CFG	128	=item %cf::CFG
55		129
56	Configuration for the server, loaded from C</etc/crossfire/config>, or	130	Configuration for the server, loaded from C</etc/crossfire/config>, or
57	from wherever your confdir points to.	131	from wherever your confdir points to.
		132
		133	=item $cf::WAIT_FOR_TICK, $cf::WAIT_FOR_TICK_ONE
		134
		135	These are Coro::Signal objects that are C<< ->broadcast >> (WAIT_FOR_TICK)
		136	or C<< ->send >> (WAIT_FOR_TICK_ONE) on after normal server tick
		137	processing has been done. Call C<< ->wait >> on them to maximise the
		138	window of cpu time available, or simply to synchronise to the server tick.
58		139
59	=back	140	=back
60		141
61	=cut	142	=cut
62		143
63	BEGIN {	144	BEGIN {
64	*CORE::GLOBAL::warn = sub {	145	*CORE::GLOBAL::warn = sub {
65	my $msg = join "", @_;	146	my $msg = join "", @_;
		147	utf8::encode $msg;
		148
66	$msg .= "\n"	149	$msg .= "\n"
67	unless $msg =~ /\n$/;	150	unless $msg =~ /\n$/;
68		151
69	print STDERR "cfperl: $msg";
70	LOG llevError, "cfperl: $msg";	152	LOG llevError, $msg;
71	};	153	};
72	}	154	}
73		155
		156	@safe::cf::global::ISA = @cf::global::ISA = 'cf::attachable';
		157	@safe::cf::object::ISA = @cf::object::ISA = 'cf::attachable';
		158	@safe::cf::player::ISA = @cf::player::ISA = 'cf::attachable';
		159	@safe::cf::client::ISA = @cf::client::ISA = 'cf::attachable';
		160	@safe::cf::map::ISA = @cf::map::ISA = 'cf::attachable';
74	@safe::cf::object::player::ISA = @cf::object::player::ISA = 'cf::object';	161	@safe::cf::object::player::ISA = @cf::object::player::ISA = 'cf::object';
75		162
76	# 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
77	# within the Safe compartment.	164	# within the Safe compartment.
78	for my $pkg (qw(cf::object cf::object::player cf::player cf::map cf::party cf::region cf::arch cf::living)) {	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	)) {
79	no strict 'refs';	172	no strict 'refs';
80	@{"safe::$pkg\::wrap::ISA"} = @{"$pkg\::wrap::ISA"} = $pkg;	173	@{"safe::$pkg\::wrap::ISA"} = @{"$pkg\::wrap::ISA"} = $pkg;
81	}	174	}
82		175
83	$Event::DIED = sub {	176	$Event::DIED = sub {
84	warn "error in event callback: @_";	177	warn "error in event callback: @_";
85	};	178	};
86		179
87	my %ext_pkg;
88	my @exts;
89	my @hook;
90	my %command;
91	my %extcmd;
92
93	=head2 UTILITY FUNCTIONS	180	=head2 UTILITY FUNCTIONS
94		181
95	=over 4	182	=over 4
96		183
		184	=item dumpval $ref
		185
97	=cut	186	=cut
		187
		188	sub dumpval {
		189	eval {
		190	local $SIG{__DIE__};
		191	my $d;
		192	if (1) {
		193	$d = new Data::Dumper([$_[0]], ["*var"]);
		194	$d->Terse(1);
		195	$d->Indent(2);
		196	$d->Quotekeys(0);
		197	$d->Useqq(1);
		198	#$d->Bless(...);
		199	$d->Seen($_[1]) if @_ > 1;
		200	$d = $d->Dump();
		201	}
		202	$d =~ s/([\x00-\x07\x09\x0b\x0c\x0e-\x1f])/sprintf "\\x%02x", ord($1)/ge;
		203	$d
		204	} || "[unable to dump $_[0]: '$@']";
		205	}
98		206
99	use JSON::Syck (); # TODO# replace by JSON::PC once working	207	use JSON::Syck (); # TODO# replace by JSON::PC once working
100		208
101	=item $ref = cf::from_json $json	209	=item $ref = cf::from_json $json
102		210
…		…
118	sub to_json($) {	226	sub to_json($) {
119	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs	227	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs
120	JSON::Syck::Dump $_[0]	228	JSON::Syck::Dump $_[0]
121	}	229	}
122		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
123	=back	386	=back
124		387
125	=cut	388	=cut
126		389
127	#############################################################################	390	#############################################################################
128		391
129	=head2 EVENTS AND OBJECT ATTACHMENTS	392	=head2 ATTACHABLE OBJECTS
		393
		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.
		397
		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+).
130		401
131	=over 4	402	=over 4
132		403
133	=item $object->attach ($attachment, key => $value...)
134
135	=item $object->detach ($attachment)
136
137	Attach/detach a pre-registered attachment to an object.
138
139	=item $player->attach ($attachment, key => $value...)
140
141	=item $player->detach ($attachment)
142
143	Attach/detach a pre-registered attachment to a player.
144
145	=item $map->attach ($attachment, key => $value...)	404	=item $attachable->attach ($attachment, key => $value...)
146		405
147	=item $map->detach ($attachment)	406	=item $attachable->detach ($attachment)
148		407
149	Attach/detach a pre-registered attachment to a map.	408	Attach/detach a pre-registered attachment to a specific object and give it
		409	the specified key/value pairs as arguments.
150		410
151	=item $bool = $object->attached ($name)	411	Example, attach a minesweeper attachment to the given object, making it a
		412	10x10 minesweeper game:
152		413
153	=item $bool = $player->attached ($name)	414	$obj->attach (minesweeper => width => 10, height => 10);
154		415
155	=item $bool = $map->attached ($name)	416	=item $bool = $attachable->attached ($name)
156		417
157	Checks wether the named attachment is currently attached to the object.	418	Checks wether the named attachment is currently attached to the object.
158		419
159	=item cf::attach_global ...	420	=item cf::CLASS->attach ...
160		421
161	Attach handlers for global events.	422	=item cf::CLASS->detach ...
162		423
163	This and all following C<attach_*>-functions expect any number of the	424	Define an anonymous attachment and attach it to all objects of the given
164	following handler/hook descriptions:	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
		449	=item cf::CLASS::attachment $name, ...
		450
		451	Register an attachment by C<$name> through which attachable objects of the
		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:
165		458
166	=over 4	459	=over 4
167		460
168	=item prio => $number	461	=item prio => $number
169		462
…		…
171	by another C<prio> setting). Lower priority handlers get executed	464	by another C<prio> setting). Lower priority handlers get executed
172	earlier. The default priority is C<0>, and many built-in handlers are	465	earlier. The default priority is C<0>, and many built-in handlers are
173	registered at priority C<-1000>, so lower priorities should not be used	466	registered at priority C<-1000>, so lower priorities should not be used
174	unless you know what you are doing.	467	unless you know what you are doing.
175		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
176	=item on_I<event> => \&cb	475	=item on_I<event> => \&cb
177		476
178	Call the given code reference whenever the named event happens (event is	477	Call the given code reference whenever the named event happens (event is
179	something like C<instantiate>, C<apply>, C<use_skill> and so on, and which	478	something like C<instantiate>, C<apply>, C<use_skill> and so on, and which
180	handlers are recognised generally depends on the type of object these	479	handlers are recognised generally depends on the type of object these
…		…
189	package and register them. Only handlers for eevents supported by the	488	package and register them. Only handlers for eevents supported by the
190	object/class are recognised.	489	object/class are recognised.
191		490
192	=back	491	=back
193		492
194	=item cf::attach_to_type $object_type, $subtype, ...	493	Example, define an attachment called "sockpuppet" that calls the given
		494	event handler when a monster attacks:
195		495
196	Attach handlers for a specific object type (e.g. TRANSPORT) and	496	cf::object::attachment sockpuppet =>
197	subtype. If C<$subtype> is zero or undef, matches all objects of the given	497	on_skill_attack => sub {
198	type.	498	my ($self, $victim) = @_;
199		499	...
200	=item cf::attach_to_objects ...
201
202	Attach handlers to all objects. Do not use this except for debugging or
203	very rare events, as handlers are (obviously) called for I<all> objects in
204	the game.
205
206	=item cf::attach_to_players ...
207
208	Attach handlers to all players.
209
210	=item cf::attach_to_maps ...
211
212	Attach handlers to all maps.
213
214	=item cf:register_attachment $name, ...
215
216	Register an attachment by name through which objects can refer to this
217	attachment.
218
219	=item cf:register_player_attachment $name, ...
220
221	Register an attachment by name through which players can refer to this
222	attachment.
223
224	=item cf:register_map_attachment $name, ...
225
226	Register an attachment by name through which maps can refer to this
227	attachment.
228
229	=cut
230
231	# the following variables are defined in .xs and must not be re-created
232	our @CB_GLOBAL = (); # registry for all global events
233	our @CB_OBJECT = (); # all objects (should not be used except in emergency)
234	our @CB_PLAYER = ();
235	our @CB_TYPE = (); # registry for type (cf-object class) based events
236	our @CB_MAP = ();
237
238	my %attachment;
239
240	sub _attach_cb($\%$$$) {
241	my ($registry, $undo, $event, $prio, $cb) = @_;
242
243	use sort 'stable';
244
245	$cb = [$prio, $cb];
246
247	@{$registry->[$event]} = sort
248	{ $a->[0] cmp $b->[0] }
249	@{$registry->[$event] || []}, $cb;
250
251	push @{$undo->{cb}}, [$event, $cb];
252	}
253
254	# attach handles attaching event callbacks
255	# the only thing the caller has to do is pass the correct
256	# registry (== where the callback attaches to).
257	sub _attach(\@$@) {
258	my ($registry, $klass, @arg) = @_;
259
260	my $prio = 0;
261
262	my %undo = (
263	registry => $registry,
264	cb => [],
265	);
266
267	my %cb_id = map +("on_" . lc $EVENT[$_][0], $_) , grep $EVENT[$_][1] == $klass, 0 .. $#EVENT;
268
269	while (@arg) {
270	my $type = shift @arg;
271
272	if ($type eq "prio") {
273	$prio = shift @arg;
274
275	} elsif ($type eq "package") {
276	my $pkg = shift @arg;
277
278	while (my ($name, $id) = each %cb_id) {
279	if (my $cb = $pkg->can ($name)) {
280	_attach_cb $registry, %undo, $id, $prio, $cb;
281	}
282	}	500	}
283
284	} elsif (exists $cb_id{$type}) {
285	_attach_cb $registry, %undo, $cb_id{$type}, $prio, shift @arg;
286
287	} elsif (ref $type) {
288	warn "attaching objects not supported, ignoring.\n";
289
290	} else {
291	shift @arg;
292	warn "attach argument '$type' not supported, ignoring.\n";
293	}
294	}
295
296	\%undo
297	}
298
299	sub _attach_attachment {
300	my ($obj, $name, %arg) = @_;
301
302	return if exists $obj->{_attachment}{$name};
303
304	my $res;
305
306	if (my $attach = $attachment{$name}) {
307	my $registry = $obj->registry;
308
309	for (@$attach) {
310	my ($klass, @attach) = @$_;
311	$res = _attach @$registry, $klass, @attach;
312	}
313
314	$obj->{$name} = \%arg;
315	} else {
316	warn "object uses attachment '$name' that is not available, postponing.\n";
317	}
318
319	$obj->{_attachment}{$name} = undef;
320
321	$res->{attachment} = $name;
322	$res
323	}
324
325	*cf::object::attach =
326	*cf::player::attach =
327	*cf::map::attach = sub {
328	my ($obj, $name, %arg) = @_;
329
330	_attach_attachment $obj, $name, %arg;
331	};
332
333	# all those should be optimised
334	*cf::object::detach =
335	*cf::player::detach =
336	*cf::map::detach = sub {
337	my ($obj, $name) = @_;
338
339	delete $obj->{_attachment}{$name};
340	reattach ($obj);
341	};
342
343	*cf::object::attached =
344	*cf::player::attached =
345	*cf::map::attached = sub {
346	my ($obj, $name) = @_;
347
348	exists $obj->{_attachment}{$name}
349	};
350
351	sub attach_global {
352	_attach @CB_GLOBAL, KLASS_GLOBAL, @_
353	}
354
355	sub attach_to_type {
356	my $type = shift;
357	my $subtype = shift;
358
359	_attach @{$CB_TYPE[$type + $subtype * NUM_SUBTYPES]}, KLASS_OBJECT, @_
360	}
361
362	sub attach_to_objects {
363	_attach @CB_OBJECT, KLASS_OBJECT, @_
364	}
365
366	sub attach_to_players {
367	_attach @CB_PLAYER, KLASS_PLAYER, @_
368	}
369
370	sub attach_to_maps {
371	_attach @CB_MAP, KLASS_MAP, @_
372	}
373
374	sub register_attachment {
375	my $name = shift;
376
377	$attachment{$name} = [[KLASS_OBJECT, @_]];
378	}
379
380	sub register_player_attachment {
381	my $name = shift;
382
383	$attachment{$name} = [[KLASS_PLAYER, @_]];
384	}
385
386	sub register_map_attachment {
387	my $name = shift;
388
389	$attachment{$name} = [[KLASS_MAP, @_]];
390	}
391
392	our $override;
393	our @invoke_results = (); # referenced from .xs code. TODO: play tricks with reify and mortals?
394
395	sub override {
396	$override = 1;
397	@invoke_results = ();
398	}
399
400	sub do_invoke {
401	my $event = shift;
402	my $callbacks = shift;
403
404	@invoke_results = ();
405
406	local $override;
407
408	for (@$callbacks) {
409	eval { &{$_->[1]} };
410
411	if ($@) {
412	warn "$@";
413	warn "... while processing $EVENT[$event][0](@_) event, skipping processing altogether.\n";
414	override;
415	}
416
417	return 1 if $override;
418	}
419
420	0	501	}
421	}
422		502
423	=item $bool = cf::invoke EVENT_GLOBAL_XXX, ...	503	=item $attachable->valid
424
425	=item $bool = $object->invoke (EVENT_OBJECT_XXX, ...)
426
427	=item $bool = $player->invoke (EVENT_PLAYER_XXX, ...)
428
429	=item $bool = $map->invoke (EVENT_MAP_XXX, ...)
430
431	Generate a global/object/player/map-specific event with the given arguments.
432
433	This API is preliminary (most likely, the EVENT_KLASS_xxx prefix will be
434	removed in future versions), and there is no public API to access override
435	results (if you must, access C<@cf::invoke_results> directly).
436
437	=back
438
439	=cut
440
441	#############################################################################
442
443	=head2 METHODS VALID FOR ALL CORE OBJECTS
444
445	=over 4
446
447	=item $object->valid, $player->valid, $map->valid
448		504
449	Just because you have a perl object does not mean that the corresponding	505	Just because you have a perl object does not mean that the corresponding
450	C-level object still exists. If you try to access an object that has no	506	C-level object still exists. If you try to access an object that has no
451	valid C counterpart anymore you get an exception at runtime. This method	507	valid C counterpart anymore you get an exception at runtime. This method
452	can be used to test for existence of the C object part without causing an	508	can be used to test for existence of the C object part without causing an
453	exception.	509	exception.
454		510
		511	=cut
		512
		513	# the following variables are defined in .xs and must not be re-created
		514	our @CB_GLOBAL = (); # registry for all global events
		515	our @CB_ATTACHABLE = (); # registry for all attachables
		516	our @CB_OBJECT = (); # all objects (should not be used except in emergency)
		517	our @CB_PLAYER = ();
		518	our @CB_CLIENT = ();
		519	our @CB_TYPE = (); # registry for type (cf-object class) based events
		520	our @CB_MAP = ();
		521
		522	my %attachment;
		523
		524	sub cf::attachable::thawer_merge {
		525	# simply override everything except _meta
		526	local $_[0]{_meta};
		527	%{$_[0]} = %{$_[1]};
		528	}
		529
		530	sub _attach_cb($$$$) {
		531	my ($registry, $event, $prio, $cb) = @_;
		532
		533	use sort 'stable';
		534
		535	$cb = [$prio, $cb];
		536
		537	@{$registry->[$event]} = sort
		538	{ $a->[0] cmp $b->[0] }
		539	@{$registry->[$event] || []}, $cb;
		540	}
		541
		542	# hack
		543	my %attachable_klass = map +($_ => 1), KLASS_OBJECT, KLASS_CLIENT, KLASS_PLAYER, KLASS_MAP;
		544
		545	# attach handles attaching event callbacks
		546	# the only thing the caller has to do is pass the correct
		547	# registry (== where the callback attaches to).
		548	sub _attach {
		549	my ($registry, $klass, @arg) = @_;
		550
		551	my $object_type;
		552	my $prio = 0;
		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	}
		559
		560	while (@arg) {
		561	my $type = shift @arg;
		562
		563	if ($type eq "prio") {
		564	$prio = shift @arg;
		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
		575	} elsif ($type eq "package") {
		576	my $pkg = shift @arg;
		577
		578	while (my ($name, $id) = each %cb_id) {
		579	if (my $cb = $pkg->can ($name)) {
		580	_attach_cb $registry, $id, $prio, $cb;
		581	}
		582	}
		583
		584	} elsif (exists $cb_id{$type}) {
		585	_attach_cb $registry, $cb_id{$type}, $prio, shift @arg;
		586
		587	} elsif (ref $type) {
		588	warn "attaching objects not supported, ignoring.\n";
		589
		590	} else {
		591	shift @arg;
		592	warn "attach argument '$type' not supported, ignoring.\n";
		593	}
		594	}
		595	}
		596
		597	sub _object_attach {
		598	my ($obj, $name, %arg) = @_;
		599
		600	return if exists $obj->{_attachment}{$name};
		601
		602	if (my $attach = $attachment{$name}) {
		603	my $registry = $obj->registry;
		604
		605	for (@$attach) {
		606	my ($klass, @attach) = @$_;
		607	_attach $registry, $klass, @attach;
		608	}
		609
		610	$obj->{$name} = \%arg;
		611	} else {
		612	warn "object uses attachment '$name' that is not available, postponing.\n";
		613	}
		614
		615	$obj->{_attachment}{$name} = undef;
		616	}
		617
		618	sub cf::attachable::attach {
		619	if (ref $_[0]) {
		620	_object_attach @_;
		621	} else {
		622	_attach shift->_attach_registry, @_;
		623	}
		624	};
		625
		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 {
		651	my \$name = shift;
		652
		653	\$attachment{\$name} = [[KLASS_$klass, \@_]];
		654	}
		655	";
		656	die if $@;
		657	}
		658
		659	our $override;
		660	our @invoke_results = (); # referenced from .xs code. TODO: play tricks with reify and mortals?
		661
		662	sub override {
		663	$override = 1;
		664	@invoke_results = ();
		665	}
		666
		667	sub do_invoke {
		668	my $event = shift;
		669	my $callbacks = shift;
		670
		671	@invoke_results = ();
		672
		673	local $override;
		674
		675	for (@$callbacks) {
		676	eval { &{$_->[1]} };
		677
		678	if ($@) {
		679	warn "$@";
		680	warn "... while processing $EVENT[$event][0](@_) event, skipping processing altogether.\n";
		681	override;
		682	}
		683
		684	return 1 if $override;
		685	}
		686
		687	0
		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
455	=back	700	=back
456		701
457	=cut	702	=cut
458
459	*cf::object::valid =
460	*cf::player::valid =
461	*cf::map::valid = \&cf::_valid;
462		703
463	#############################################################################	704	#############################################################################
464	# object support	705	# object support
465		706
466	sub instantiate {
467	my ($obj, $data) = @_;
468
469	$data = from_json $data;
470
471	for (@$data) {
472	my ($name, $args) = @$_;
473
474	$obj->attach ($name, %{$args || {} });
475	}
476	}
477
478	# basically do the same as instantiate, without calling instantiate
479	sub reattach {	707	sub reattach {
		708	# basically do the same as instantiate, without calling instantiate
480	my ($obj) = @_;	709	my ($obj) = @_;
		710
		711	bless $obj, ref $obj; # re-bless in case extensions have been reloaded
		712
481	my $registry = $obj->registry;	713	my $registry = $obj->registry;
482		714
483	@$registry = ();	715	@$registry = ();
484		716
485	delete $obj->{_attachment} unless scalar keys %{ $obj->{_attachment} || {} };	717	delete $obj->{_attachment} unless scalar keys %{ $obj->{_attachment} || {} };
486		718
487	for my $name (keys %{ $obj->{_attachment} || {} }) {	719	for my $name (keys %{ $obj->{_attachment} || {} }) {
488	if (my $attach = $attachment{$name}) {	720	if (my $attach = $attachment{$name}) {
489	for (@$attach) {	721	for (@$attach) {
490	my ($klass, @attach) = @$_;	722	my ($klass, @attach) = @$_;
491	_attach @$registry, $klass, @attach;	723	_attach $registry, $klass, @attach;
492	}	724	}
493	} else {	725	} else {
494	warn "object uses attachment '$name' that is not available, postponing.\n";	726	warn "object uses attachment '$name' that is not available, postponing.\n";
495	}	727	}
496	}	728	}
497	}	729	}
498		730
499	sub object_freezer_save {	731	cf::attachable->attach (
500	my ($filename, $rdata, $objs) = @_;
501
502	if (length $$rdata) {
503	warn sprintf "saving %s (%d,%d)\n",
504	$filename, length $$rdata, scalar @$objs;
505
506	if (open my $fh, ">:raw", "$filename~") {
507	chmod SAVE_MODE, $fh;
508	syswrite $fh, $$rdata;
509	close $fh;
510
511	if (@$objs && open my $fh, ">:raw", "$filename.pst~") {
512	chmod SAVE_MODE, $fh;
513	syswrite $fh, Storable::nfreeze { version => 1, objs => $objs };
514	close $fh;
515	rename "$filename.pst~", "$filename.pst";
516	} else {
517	unlink "$filename.pst";
518	}
519
520	rename "$filename~", $filename;
521	} else {
522	warn "FATAL: $filename~: $!\n";
523	}
524	} else {
525	unlink $filename;
526	unlink "$filename.pst";
527	}
528	}
529
530	sub object_freezer_as_string {
531	my ($rdata, $objs) = @_;
532
533	use Data::Dumper;
534
535	$$rdata . Dumper $objs
536	}
537
538	sub object_thawer_load {
539	my ($filename) = @_;
540
541	local $/;
542
543	my $av;
544
545	#TODO: use sysread etc.
546	if (open my $data, "<:raw:perlio", $filename) {
547	$data = <$data>;
548	if (open my $pst, "<:raw:perlio", "$filename.pst") {
549	$av = eval { (Storable::thaw <$pst>)->{objs} };
550	}
551	return ($data, $av);
552	}
553
554	()
555	}
556
557	attach_to_objects
558	prio => -1000000,	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,
559	on_clone => sub {	745	on_clone => sub {
560	my ($src, $dst) = @_;	746	my ($src, $dst) = @_;
561		747
562	@{$dst->registry} = @{$src->registry};	748	@{$dst->registry} = @{$src->registry};
563		749
564	%$dst = %$src;	750	%$dst = %$src;
565		751
566	%{$dst->{_attachment}} = %{$src->{_attachment}}	752	%{$dst->{_attachment}} = %{$src->{_attachment}}
567	if exists $src->{_attachment};	753	if exists $src->{_attachment};
568	},	754	},
569	;	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
		771	if (@$objs) {
		772	if (my $fh = aio_open "$filename.pst~", O_WRONLY | O_CREAT, 0600) {
		773	chmod SAVE_MODE, $fh;
		774	my $data = Storable::nfreeze { version => 1, objs => $objs };
		775	aio_write $fh, 0, (length $data), $data, 0;
		776	aio_fsync $fh if $cf::USE_FSYNC;
		777	close $fh;
		778	aio_rename "$filename.pst~", "$filename.pst";
		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	}
570		821
571	#############################################################################	822	#############################################################################
572	# old plug-in events	823	# command handling &c
573		824
574	sub inject_event {	825	=item cf::register_command $name => \&callback($ob,$args);
575	my $extension = shift;
576	my $event_code = shift;
577		826
578	my $cb = $hook[$event_code]{$extension}	827	Register a callback for execution when the client sends the user command
579	or return;	828	$name.
580		829
581	&$cb	830	=cut
582	}
583
584	sub inject_global_event {
585	my $event = shift;
586
587	my $cb = $hook[$event]
588	or return;
589
590	List::Util::max map &$_, values %$cb
591	}
592
593	sub inject_command {
594	my ($name, $obj, $params) = @_;
595
596	for my $cmd (@{ $command{$name} }) {
597	$cmd->[1]->($obj, $params);
598	}
599
600	-1
601	}
602		831
603	sub register_command {	832	sub register_command {
604	my ($name, $time, $cb) = @_;	833	my ($name, $cb) = @_;
605		834
606	my $caller = caller;	835	my $caller = caller;
607	#warn "registering command '$name/$time' to '$caller'";	836	#warn "registering command '$name/$time' to '$caller'";
608		837
609	push @{ $command{$name} }, [$time, $cb, $caller];	838	push @{ $COMMAND{$name} }, [$caller, $cb];
610	$COMMAND{"$name\000"} = List::Util::max map $_->[0], @{ $command{$name} };
611	}	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
612		849
613	sub register_extcmd {	850	sub register_extcmd {
614	my ($name, $cb) = @_;	851	my ($name, $cb) = @_;
615		852
616	my $caller = caller;	853	$EXTCMD{$name} = $cb;
617	#warn "registering extcmd '$name' to '$caller'";
618
619	$extcmd{$name} = [$cb, $caller];
620	}	854	}
621		855
622	sub register {	856	cf::player->attach (
623	my ($base, $pkg) = @_;	857	on_command => sub {
		858	my ($pl, $name, $params) = @_;
624		859
625	#TODO	860	my $cb = $COMMAND{$name}
626	}	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);
		878	}
		879	}
		880	} else {
		881	warn "player " . ($pl->ob->name) . " sent unparseable ext message: <$buf>\n";
		882	}
		883
		884	cf::override;
		885	},
		886	);
627		887
628	sub load_extension {	888	sub load_extension {
629	my ($path) = @_;	889	my ($path) = @_;
630		890
631	$path =~ /([^\/\\]+)\.ext$/ or die "$path";	891	$path =~ /([^\/\\]+)\.ext$/ or die "$path";
632	my $base = $1;	892	my $base = $1;
633	my $pkg = $1;	893	my $pkg = $1;
634	$pkg =~ s/[^[:word:]]/_/g;	894	$pkg =~ s/[^[:word:]]/_/g;
635	$pkg = "ext::$pkg";	895	$pkg = "ext::$pkg";
636		896
637	warn "loading '$path' into '$pkg'\n";	897	warn "... loading '$path' into '$pkg'\n";
638		898
639	open my $fh, "<:utf8", $path	899	open my $fh, "<:utf8", $path
640	or die "$path: $!";	900	or die "$path: $!";
641		901
642	my $source =	902	my $source =
643	"package $pkg; use strict; use utf8;\n"	903	"package $pkg; use strict; use utf8;\n"
644	. "#line 1 \"$path\"\n{\n"	904	. "#line 1 \"$path\"\n{\n"
645	. (do { local $/; <$fh> })	905	. (do { local $/; <$fh> })
646	. "\n};\n1";	906	. "\n};\n1";
647		907
648	eval $source	908	unless (eval $source) {
649	or die $@ ? "$path: $@\n"	909	my $msg = $@ ? "$path: $@\n"
650	: "extension disabled.\n";	910	: "extension disabled.\n";
651		911	if ($source =~ /^#!.*perl.*#.*MANDATORY/m) { # ugly match
652	push @exts, $pkg;	912	warn $@;
653	$ext_pkg{$base} = $pkg;	913	warn "mandatory extension failed to load, exiting.\n";
654		914	exit 1;
655	# no strict 'refs';	915	}
656	# @{"$pkg\::ISA"} = ext::;	916	die $@;
657
658	register $base, $pkg;
659	}
660
661	sub unload_extension {
662	my ($pkg) = @_;
663
664	warn "removing extension $pkg\n";
665
666	# remove hooks
667	#TODO
668	# for my $idx (0 .. $#PLUGIN_EVENT) {
669	# delete $hook[$idx]{$pkg};
670	# }	917	}
671		918
672	# remove commands	919	push @EXTS, $pkg;
673	for my $name (keys %command) {
674	my @cb = grep $_->[2] ne $pkg, @{ $command{$name} };
675
676	if (@cb) {
677	$command{$name} = \@cb;
678	$COMMAND{"$name\000"} = List::Util::max map $_->[0], @cb;
679	} else {
680	delete $command{$name};
681	delete $COMMAND{"$name\000"};
682	}
683	}
684
685	# remove extcmds
686	for my $name (grep $extcmd{$_}[1] eq $pkg, keys %extcmd) {
687	delete $extcmd{$name};
688	}
689
690	if (my $cb = $pkg->can ("unload")) {
691	eval {
692	$cb->($pkg);
693	1
694	} or warn "$pkg unloaded, but with errors: $@";
695	}
696
697	Symbol::delete_package $pkg;
698	}	920	}
699		921
700	sub load_extensions {	922	sub load_extensions {
701	my $LIBDIR = maps_directory "perl";
702
703	for my $ext (<$LIBDIR/*.ext>) {	923	for my $ext (<$LIBDIR/*.ext>) {
704	next unless -r $ext;	924	next unless -r $ext;
705	eval {	925	eval {
706	load_extension $ext;	926	load_extension $ext;
707	1	927	1
708	} or warn "$ext not loaded: $@";	928	} or warn "$ext not loaded: $@";
709	}	929	}
710	}	930	}
711		931
712	#############################################################################	932	#############################################################################
713	# extcmd framework, basically convert ext <msg>
714	# into pkg::->on_extcmd_arg1 (...) while shortcutting a few
715		933
716	attach_to_players	934	=head2 CORE EXTENSIONS
717	on_extcmd => sub {	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 {
718	my ($pl, $buf) = @_;	1451	my ($self, $ob) = @_;
719		1452
720	my $msg = eval { from_json $buf };	1453	return find "~" . $ob->name . "/" . $self->{path}
		1454	if $self->per_player;
721		1455
722	if (ref $msg) {	1456	$self
723	if (my $cb = $extcmd{$msg->{msgtype}}) {	1457	}
724	if (my %reply = $cb->[0]->($pl, $msg)) {	1458
725	$pl->ext_reply ($msg->{msgid}, %reply);	1459	# find and load all maps in the 3x3 area around a map
726	}	1460	sub load_diag {
		1461	my ($map) = @_;
		1462
		1463	my @diag; # diagonal neighbours
		1464
		1465	for (0 .. 3) {
		1466	my $neigh = $map->tile_path ($_)
		1467	or next;
		1468	$neigh = find $neigh, $map
		1469	or next;
		1470	$neigh->load;
		1471
		1472	push @diag, [$neigh->tile_path (($_ + 3) % 4), $neigh],
		1473	[$neigh->tile_path (($_ + 1) % 4), $neigh];
		1474	}
		1475
		1476	for (@diag) {
		1477	my $neigh = find @$_
		1478	or next;
		1479	$neigh->load;
		1480	}
		1481	}
		1482
		1483	sub find_sync {
		1484	my ($path, $origin) = @_;
		1485
		1486	cf::sync_job { find $path, $origin }
		1487	}
		1488
		1489	sub do_load_sync {
		1490	my ($map) = @_;
		1491
		1492	cf::sync_job { $map->load };
		1493	}
		1494
		1495	our %MAP_PREFETCH;
		1496	our $MAP_PREFETCHER = undef;
		1497
		1498	sub find_async {
		1499	my ($path, $origin) = @_;
		1500
		1501	$path = normalise $path, $origin && $origin->{path};
		1502
		1503	if (my $map = $cf::MAP{$path}) {
		1504	return $map if $map->in_memory == cf::MAP_IN_MEMORY;
		1505	}
		1506
		1507	undef $MAP_PREFETCH{$path};
		1508	$MAP_PREFETCHER ||= cf::async {
		1509	while (%MAP_PREFETCH) {
		1510	for my $path (keys %MAP_PREFETCH) {
		1511	my $map = find $path
		1512	or next;
		1513	$map->load;
		1514
		1515	delete $MAP_PREFETCH{$path};
727	}	1516	}
		1517	}
		1518	undef $MAP_PREFETCHER;
		1519	};
		1520	$MAP_PREFETCHER->prio (6);
		1521
		1522	()
		1523	}
		1524
		1525	sub save {
		1526	my ($self) = @_;
		1527
		1528	my $lock = cf::lock_acquire "map_data:" . $self->path;
		1529
		1530	$self->{last_save} = $cf::RUNTIME;
		1531
		1532	return unless $self->dirty;
		1533
		1534	my $save = $self->save_path; utf8::encode $save;
		1535	my $uniq = $self->uniq_path; utf8::encode $uniq;
		1536
		1537	$self->{load_path} = $save;
		1538
		1539	return if $self->{deny_save};
		1540
		1541	local $self->{last_access} = $self->last_access;#d#
		1542
		1543	cf::async {
		1544	$_->contr->save for $self->players;
		1545	};
		1546
		1547	if ($uniq) {
		1548	$self->_save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS);
		1549	$self->_save_objects ($uniq, cf::IO_UNIQUES);
728	} else {	1550	} else {
729	warn "player " . ($pl->ob->name) . " sent unparseable ext message: <$buf>\n";	1551	$self->_save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS | cf::IO_UNIQUES);
730	}
731
732	cf::override;
733	},	1552	}
734	;	1553	}
735		1554
736	#############################################################################	1555	sub swap_out {
737	# load/save/clean perl data associated with a map
738
739	*cf::mapsupport::on_clean = sub {
740	my ($map) = @_;	1556	my ($self) = @_;
741		1557
742	my $path = $map->tmpname;	1558	# save first because save cedes
743	defined $path or return;	1559	$self->save;
744		1560
745	unlink "$path.pst";	1561	my $lock = cf::lock_acquire "map_data:" . $self->path;
746	};
747		1562
748	attach_to_maps prio => -10000, package => cf::mapsupport::;	1563	return if $self->players;
		1564	return if $self->in_memory != cf::MAP_IN_MEMORY;
		1565	return if $self->{deny_save};
749		1566
750	#############################################################################	1567	$self->clear;
751	# load/save perl data associated with player->ob objects	1568	$self->in_memory (cf::MAP_SWAPPED);
752
753	sub all_objects(@) {
754	@_, map all_objects ($_->inv), @_
755	}	1569	}
756		1570
757	# TODO: compatibility cruft, remove when no longer needed	1571	sub reset_at {
758	attach_to_players	1572	my ($self) = @_;
759	on_load => sub {
760	my ($pl, $path) = @_;
761		1573
762	for my $o (all_objects $pl->ob) {	1574	# TODO: safety, remove and allow resettable per-player maps
763	if (my $value = $o->get_ob_key_value ("_perl_data")) {	1575	return 1e99 if $self->isa ("ext::map_per_player");#d#
764	$o->set_ob_key_value ("_perl_data");	1576	return 1e99 if $self->{deny_reset};
765		1577
766	%$o = %{ Storable::thaw pack "H*", $value };	1578	my $time = $self->fixed_resettime ? $self->{instantiate_time} : $self->last_access;
767	}	1579	my $to = List::Util::min $MAX_RESET, $self->reset_timeout || $DEFAULT_RESET;
768	}	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;
769	},	1608	}
770	;
771		1609
772	#############################################################################	1610	delete $cf::MAP{$self->path};
773		1611
774	=head2 CORE EXTENSIONS	1612	$self->clear;
775		1613
776	Functions and methods that extend core crossfire objects.	1614	$_->clear_links_to ($self) for values %cf::MAP;
		1615
		1616	$self->unlink_save;
		1617	$self->destroy;
		1618	}
		1619
		1620	my $nuke_counter = "aaaa";
		1621
		1622	sub nuke {
		1623	my ($self) = @_;
		1624
		1625	delete $cf::MAP{$self->path};
		1626
		1627	$self->unlink_save;
		1628
		1629	bless $self, "cf::map";
		1630	delete $self->{deny_reset};
		1631	$self->{deny_save} = 1;
		1632	$self->reset_timeout (1);
		1633	$self->path ($self->{path} = "{nuke}/" . ($nuke_counter++));
		1634
		1635	$cf::MAP{$self->path} = $self;
		1636
		1637	$self->reset; # polite request, might not happen
		1638	}
		1639
		1640	=item cf::map::unique_maps
		1641
		1642	Returns an arrayref of paths of all shared maps that have
		1643	instantiated unique items. May block.
		1644
		1645	=cut
		1646
		1647	sub unique_maps() {
		1648	my $files = aio_readdir cf::localdir . "/" . cf::uniquedir
		1649	or return;
		1650
		1651	my @paths;
		1652
		1653	for (@$files) {
		1654	utf8::decode $_;
		1655	next if /\.pst$/;
		1656	next unless /^$PATH_SEP/o;
		1657
		1658	push @paths, cf::map::normalise $_;
		1659	}
		1660
		1661	\@paths
		1662	}
		1663
		1664	package cf;
		1665
		1666	=back
		1667
		1668	=head3 cf::object
		1669
		1670	=cut
		1671
		1672	package cf::object;
777		1673
778	=over 4	1674	=over 4
779		1675
780	=item cf::player::exists $login	1676	=item $ob->inv_recursive
781		1677
782	Returns true when the given account exists.	1678	Returns the inventory of the object _and_ their inventories, recursively.
783		1679
784	=cut	1680	=cut
785		1681
786	sub cf::player::exists($) {	1682	sub inv_recursive_;
787	cf::player::find $_[0]	1683	sub inv_recursive_ {
788	or -f sprintf "%s/%s/%s/%s.pl", cf::localdir, cf::playerdir, ($_[0]) x 2;	1684	map { $_, inv_recursive_ $_->inv } @_
789	}	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
790		1698
791	=item $player_object->reply ($npc, $msg[, $flags])	1699	=item $player_object->reply ($npc, $msg[, $flags])
792		1700
793	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>
794	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
…		…
796		1704
797	=cut	1705	=cut
798		1706
799	# rough implementation of a future "reply" method that works	1707	# rough implementation of a future "reply" method that works
800	# with dialog boxes.	1708	# with dialog boxes.
		1709	#TODO: the first argument must go, split into a $npc->reply_to ( method
801	sub cf::object::player::reply($$$;$) {	1710	sub cf::object::player::reply($$$;$) {
802	my ($self, $npc, $msg, $flags) = @_;	1711	my ($self, $npc, $msg, $flags) = @_;
803		1712
804	$flags = cf::NDI_BROWN | cf::NDI_UNIQUE unless @_ >= 4;	1713	$flags = cf::NDI_BROWN | cf::NDI_UNIQUE unless @_ >= 4;
805		1714
…		…
809	$msg = $npc->name . " says: $msg" if $npc;	1718	$msg = $npc->name . " says: $msg" if $npc;
810	$self->message ($msg, $flags);	1719	$self->message ($msg, $flags);
811	}	1720	}
812	}	1721	}
813		1722
814	=item $player->ext_reply ($msgid, $msgtype, %msg)
815
816	Sends an ext reply to the player.
817
818	=cut
819
820	sub cf::player::ext_reply($$$%) {
821	my ($self, $id, %msg) = @_;
822
823	$msg{msgid} = $id;
824
825	$self->send ("ext " . to_json \%msg);
826	}
827
828	=item $player_object->may ("access")	1723	=item $player_object->may ("access")
829		1724
830	Returns wether the given player is authorized to access resource "access"	1725	Returns wether the given player is authorized to access resource "access"
831	(e.g. "command_wizcast").	1726	(e.g. "command_wizcast").
832		1727
…		…
839	(ref $cf::CFG{"may_$access"}	1734	(ref $cf::CFG{"may_$access"}
840	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}	1735	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}
841	: $cf::CFG{"may_$access"})	1736	: $cf::CFG{"may_$access"})
842	}	1737	}
843		1738
844	=cut	1739	=item $player_object->enter_link
845		1740
846	#############################################################################	1741	Freezes the player and moves him/her to a special map (C<{link}>).
		1742
		1743	The player should be reasonably safe there for short amounts of time. You
		1744	I<MUST> call C<leave_link> as soon as possible, though.
		1745
		1746	Will never block.
		1747
		1748	=item $player_object->leave_link ($map, $x, $y)
		1749
		1750	Moves the player out of the special C<{link}> map onto the specified
		1751	map. If the map is not valid (or omitted), the player will be moved back
		1752	to the location he/she was before the call to C<enter_link>, or, if that
		1753	fails, to the emergency map position.
		1754
		1755	Might block.
		1756
		1757	=cut
		1758
		1759	sub link_map {
		1760	unless ($LINK_MAP) {
		1761	$LINK_MAP = cf::map::find "{link}"
		1762	or cf::cleanup "FATAL: unable to provide {link} map, exiting.";
		1763	$LINK_MAP->load;
		1764	}
		1765
		1766	$LINK_MAP
		1767	}
		1768
		1769	sub cf::object::player::enter_link {
		1770	my ($self) = @_;
		1771
		1772	$self->deactivate_recursive;
		1773
		1774	return if UNIVERSAL::isa $self->map, "ext::map_link";
		1775
		1776	$self->{_link_pos} ||= [$self->map->{path}, $self->x, $self->y]
		1777	if $self->map;
		1778
		1779	$self->enter_map ($LINK_MAP || link_map, 10, 10);
		1780	}
		1781
		1782	sub cf::object::player::leave_link {
		1783	my ($self, $map, $x, $y) = @_;
		1784
		1785	my $link_pos = delete $self->{_link_pos};
		1786
		1787	unless ($map) {
		1788	# restore original map position
		1789	($map, $x, $y) = @{ $link_pos || [] };
		1790	$map = cf::map::find $map;
		1791
		1792	unless ($map) {
		1793	($map, $x, $y) = @$EMERGENCY_POSITION;
		1794	$map = cf::map::find $map
		1795	or die "FATAL: cannot load emergency map\n";
		1796	}
		1797	}
		1798
		1799	($x, $y) = (-1, -1)
		1800	unless (defined $x) && (defined $y);
		1801
		1802	# use -1 or undef as default coordinates, not 0, 0
		1803	($x, $y) = ($map->enter_x, $map->enter_y)
		1804	if $x <=0 && $y <= 0;
		1805
		1806	$map->load;
		1807	$map->load_diag;
		1808
		1809	return unless $self->contr->active;
		1810	$self->activate_recursive;
		1811
		1812	local $self->{_prev_pos} = $link_pos; # ugly hack for rent.ext
		1813	$self->enter_map ($map, $x, $y);
		1814	}
		1815
		1816	cf::player->attach (
		1817	on_logout => sub {
		1818	my ($pl) = @_;
		1819
		1820	# abort map switching before logout
		1821	if ($pl->ob->{_link_pos}) {
		1822	cf::sync_job {
		1823	$pl->ob->leave_link
		1824	};
		1825	}
		1826	},
		1827	on_login => sub {
		1828	my ($pl) = @_;
		1829
		1830	# try to abort aborted map switching on player login :)
		1831	# should happen only on crashes
		1832	if ($pl->ob->{_link_pos}) {
		1833	$pl->ob->enter_link;
		1834	(async {
		1835	$pl->ob->reply (undef,
		1836	"There was an internal problem at your last logout, "
		1837	. "the server will try to bring you to your intended destination in a second.",
		1838	cf::NDI_RED);
		1839	# we need this sleep as the login has a concurrent enter_exit running
		1840	# and this sleep increases chances of the player not ending up in scorn
		1841	Coro::Timer::sleep 1;
		1842	$pl->ob->leave_link;
		1843	})->prio (2);
		1844	}
		1845	},
		1846	);
		1847
		1848	=item $player_object->goto ($path, $x, $y)
		1849
		1850	=cut
		1851
		1852	sub cf::object::player::goto {
		1853	my ($self, $path, $x, $y) = @_;
		1854
		1855	$self->enter_link;
		1856
		1857	(async {
		1858	my $map = eval {
		1859	my $map = cf::map::find $path;
		1860	$map = $map->customise_for ($self) if $map;
		1861	$map
		1862	} or
		1863	$self->message ("The exit to '$path' is closed", cf::NDI_UNIQUE | cf::NDI_RED);
		1864
		1865	$self->leave_link ($map, $x, $y);
		1866	})->prio (1);
		1867	}
		1868
		1869	=item $player_object->enter_exit ($exit_object)
		1870
		1871	=cut
		1872
		1873	sub parse_random_map_params {
		1874	my ($spec) = @_;
		1875
		1876	my $rmp = { # defaults
		1877	xsize => (cf::rndm 15, 40),
		1878	ysize => (cf::rndm 15, 40),
		1879	symmetry => (cf::rndm 1, cf::SYMMETRY_XY),
		1880	#layout => string,
		1881	};
		1882
		1883	for (split /\n/, $spec) {
		1884	my ($k, $v) = split /\s+/, $_, 2;
		1885
		1886	$rmp->{lc $k} = $v if (length $k) && (length $v);
		1887	}
		1888
		1889	$rmp
		1890	}
		1891
		1892	sub prepare_random_map {
		1893	my ($exit) = @_;
		1894
		1895	my $guard = cf::lock_acquire "exit_prepare:$exit";
		1896
		1897	# all this does is basically replace the /! path by
		1898	# a new random map path (?random/...) with a seed
		1899	# that depends on the exit object
		1900
		1901	my $rmp = parse_random_map_params $exit->msg;
		1902
		1903	if ($exit->map) {
		1904	$rmp->{region} = $exit->region->name;
		1905	$rmp->{origin_map} = $exit->map->path;
		1906	$rmp->{origin_x} = $exit->x;
		1907	$rmp->{origin_y} = $exit->y;
		1908	}
		1909
		1910	$rmp->{random_seed} ||= $exit->random_seed;
		1911
		1912	my $data = cf::to_json $rmp;
		1913	my $md5 = Digest::MD5::md5_hex $data;
		1914	my $meta = "$cf::RANDOM_MAPS/$md5.meta";
		1915
		1916	if (my $fh = aio_open "$meta~", O_WRONLY | O_CREAT, 0666) {
		1917	aio_write $fh, 0, (length $data), $data, 0;
		1918	undef $fh;
		1919	aio_rename "$meta~", $meta;
		1920
		1921	$exit->slaying ("?random/$md5");
		1922	$exit->msg (undef);
		1923	}
		1924	}
		1925
		1926	sub cf::object::player::enter_exit {
		1927	my ($self, $exit) = @_;
		1928
		1929	return unless $self->type == cf::PLAYER;
		1930
		1931	if ($exit->slaying eq "/!") {
		1932	#TODO: this should de-fi-ni-te-ly not be a sync-job
		1933	cf::sync_job { prepare_random_map $exit };
		1934	}
		1935
		1936	my $slaying = cf::map::normalise $exit->slaying, $exit->map && $exit->map->path;
		1937	my $hp = $exit->stats->hp;
		1938	my $sp = $exit->stats->sp;
		1939
		1940	$self->enter_link;
		1941
		1942	(async {
		1943	$self->deactivate_recursive; # just to be sure
		1944	unless (eval {
		1945	$self->goto ($slaying, $hp, $sp);
		1946
		1947	1;
		1948	}) {
		1949	$self->message ("Something went wrong deep within the crossfire server. "
		1950	. "I'll try to bring you back to the map you were before. "
		1951	. "Please report this to the dungeon master!",
		1952	cf::NDI_UNIQUE | cf::NDI_RED);
		1953
		1954	warn "ERROR in enter_exit: $@";
		1955	$self->leave_link;
		1956	}
		1957	})->prio (1);
		1958	}
		1959
		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
847		2062
848	=head2 SAFE SCRIPTING	2063	=head2 SAFE SCRIPTING
849		2064
850	Functions that provide a safe environment to compile and execute	2065	Functions that provide a safe environment to compile and execute
851	snippets of perl code without them endangering the safety of the server	2066	snippets of perl code without them endangering the safety of the server
…		…
866		2081
867	=pod	2082	=pod
868		2083
869	The following fucntions and emthods are available within a safe environment:	2084	The following fucntions and emthods are available within a safe environment:
870		2085
871	cf::object contr pay_amount pay_player	2086	cf::object contr pay_amount pay_player map
872	cf::object::player player	2087	cf::object::player player
873	cf::player peaceful	2088	cf::player peaceful
		2089	cf::map trigger
874		2090
875	=cut	2091	=cut
876		2092
877	for (	2093	for (
878	["cf::object" => qw(contr pay_amount pay_player)],	2094	["cf::object" => qw(contr pay_amount pay_player map)],
879	["cf::object::player" => qw(player)],	2095	["cf::object::player" => qw(player)],
880	["cf::player" => qw(peaceful)],	2096	["cf::player" => qw(peaceful)],
		2097	["cf::map" => qw(trigger)],
881	) {	2098	) {
882	no strict 'refs';	2099	no strict 'refs';
883	my ($pkg, @funs) = @$_;	2100	my ($pkg, @funs) = @$_;
884	*{"safe::$pkg\::$_"} = $safe_hole->wrap (\&{"$pkg\::$_"})	2101	*{"safe::$pkg\::$_"} = $safe_hole->wrap (\&{"$pkg\::$_"})
885	for @funs;	2102	for @funs;
…		…
965	The parameter C<$family> should best start with the name of the extension	2182	The parameter C<$family> should best start with the name of the extension
966	using it, it should be unique.	2183	using it, it should be unique.
967		2184
968	=over 4	2185	=over 4
969		2186
970	=item $hashref = cf::db_get $family
971
972	Return a hashref for use by the extension C<$family>, which can be
973	modified. After modifications, you have to call C<cf::db_dirty> or
974	C<cf::db_sync>.
975
976	=item $value = cf::db_get $family => $key	2187	=item $value = cf::db_get $family => $key
977		2188
978	Returns a single value from the database	2189	Returns a single value from the database.
979
980	=item cf::db_put $family => $hashref
981
982	Stores the given family hashref into the database. Updates are delayed, if
983	you want the data to be synced to disk immediately, use C<cf::db_sync>.
984		2190
985	=item cf::db_put $family => $key => $value	2191	=item cf::db_put $family => $key => $value
986		2192
987	Stores the given C<$value> in the family hash. Updates are delayed, if you	2193	Stores the given C<$value> in the family.
988	want the data to be synced to disk immediately, use C<cf::db_sync>.
989
990	=item cf::db_dirty
991
992	Marks the database as dirty, to be updated at a later time.
993
994	=item cf::db_sync
995
996	Immediately write the database to disk I<if it is dirty>.
997		2194
998	=cut	2195	=cut
999		2196
1000	our $DB;	2197	our $DB;
1001		2198
1002	{	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
1003	my $path = cf::localdir . "/database.pst";	2214	my $path = cf::localdir . "/database.pst";
		2215	if (stat $path) {
		2216	cf::sync_job {
		2217	my $pst = Storable::retrieve $path;
1004		2218
1005	sub db_load() {	2219	cf::db_put (board => data => $pst->{board});
1006	warn "loading database $path\n";#d# remove later	2220	cf::db_put (guildrules => data => $pst->{guildrules});
1007	$DB = stat $path ? Storable::retrieve $path : { };	2221	cf::db_put (rent => balance => $pst->{rent}{balance});
1008	}	2222	BDB::db_env_txn_checkpoint $DB_ENV;
1009		2223
1010	my $pid;	2224	unlink $path;
1011
1012	sub db_save() {
1013	warn "saving database $path\n";#d# remove later
1014	waitpid $pid, 0 if $pid;
1015	if (0 == ($pid = fork)) {
1016	$DB->{_meta}{version} = 1;
1017	Storable::nstore $DB, "$path~";
1018	rename "$path~", $path;
1019	cf::_exit 0 if defined $pid;
1020	}	2225	};
1021	}
1022
1023	my $dirty;
1024
1025	sub db_sync() {
1026	db_save if $dirty;
1027	undef $dirty;
1028	}
1029
1030	my $idle = Event->idle (min => $TICK * 2.8, max => 10, repeat => 0, cb => sub {
1031	db_sync;
1032	});
1033
1034	sub db_dirty() {
1035	$dirty = 1;
1036	$idle->start;
1037	}
1038
1039	sub db_get($;$) {
1040	@_ >= 2
1041	? $DB->{$_[0]}{$_[1]}
1042	: ($DB->{$_[0]} ||= { })
1043	}
1044
1045	sub db_put($$;$) {
1046	if (@_ >= 3) {
1047	$DB->{$_[0]}{$_[1]} = $_[2];
1048	} else {
1049	$DB->{$_[0]} = $_[1];
1050	}
1051	db_dirty;
1052	}
1053
1054	attach_global
1055	prio => 10000,
1056	on_cleanup => sub {
1057	db_sync;
1058	},	2226	}
1059	;	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 { };
1060	}	2244	}
1061		2245
1062	#############################################################################	2246	#############################################################################
1063	# the server's main()	2247	# the server's init and main functions
		2248
		2249	sub init_resources {
		2250	load_resource_file sprintf "%s/%s/regions", cf::datadir, cf::mapdir
		2251	or die "unable to load regions file\n";#d#
		2252	}
1064		2253
1065	sub cfg_load {	2254	sub cfg_load {
1066	open my $fh, "<:utf8", cf::confdir . "/config"	2255	open my $fh, "<:utf8", cf::confdir . "/config"
1067	or return;	2256	or return;
1068		2257
1069	local $/;	2258	local $/;
1070	*CFG = YAML::Syck::Load <$fh>;	2259	*CFG = YAML::Syck::Load <$fh>;
		2260
		2261	$EMERGENCY_POSITION = $CFG{emergency_position} || ["/world/world_105_115", 5, 37];
		2262
		2263	$cf::map::MAX_RESET = $CFG{map_max_reset} if exists $CFG{map_max_reset};
		2264	$cf::map::DEFAULT_RESET = $CFG{map_default_reset} if exists $CFG{map_default_reset};
		2265
		2266	if (exists $CFG{mlockall}) {
		2267	eval {
		2268	$CFG{mlockall} ? eval "mlockall()" : eval "munlockall()"
		2269	and die "WARNING: m(un)lockall failed: $!\n";
		2270	};
		2271	warn $@ if $@;
		2272	}
		2273	}
		2274
		2275	sub init {
		2276	init_resources;
1071	}	2277	}
1072		2278
1073	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
1074	cfg_load;	2288	cfg_load;
1075	db_load;	2289	db_init;
1076	load_extensions;	2290	load_extensions;
		2291
		2292	$TICK_WATCHER->start;
1077	Event::loop;	2293	Event::loop;
1078	}	2294	}
1079		2295
1080	#############################################################################	2296	#############################################################################
1081	# initialisation	2297	# initialisation and cleanup
1082		2298
		2299	# install some emergency cleanup handlers
		2300	BEGIN {
		2301	for my $signal (qw(INT HUP TERM)) {
		2302	Event->signal (
		2303	reentrant => 0,
		2304	data => WF_AUTOCANCEL,
		2305	signal => $signal,
		2306	prio => 0,
		2307	cb => sub {
		2308	cf::cleanup "SIG$signal";
		2309	},
		2310	);
		2311	}
		2312	}
		2313
		2314	sub emergency_save() {
		2315	my $freeze_guard = cf::freeze_mainloop;
		2316
		2317	warn "enter emergency perl save\n";
		2318
		2319	cf::sync_job {
		2320	# use a peculiar iteration method to avoid tripping on perl
		2321	# refcount bugs in for. also avoids problems with players
		2322	# and maps saved/destroyed asynchronously.
		2323	warn "begin emergency player save\n";
		2324	for my $login (keys %cf::PLAYER) {
		2325	my $pl = $cf::PLAYER{$login} or next;
		2326	$pl->valid or next;
		2327	$pl->save;
		2328	}
		2329	warn "end emergency player save\n";
		2330
		2331	warn "begin emergency map save\n";
		2332	for my $path (keys %cf::MAP) {
		2333	my $map = $cf::MAP{$path} or next;
		2334	$map->valid or next;
		2335	$map->save;
		2336	}
		2337	warn "end emergency map save\n";
		2338
		2339	warn "begin emergency database checkpoint\n";
		2340	BDB::db_env_txn_checkpoint $DB_ENV;
		2341	warn "end emergency database checkpoint\n";
		2342	};
		2343
		2344	warn "leave emergency perl save\n";
		2345	}
		2346
		2347	sub post_cleanup {
		2348	my ($make_core) = @_;
		2349
		2350	warn Carp::longmess "post_cleanup backtrace"
		2351	if $make_core;
		2352	}
		2353
1083	sub _perl_reload(&) {	2354	sub reload() {
1084	my ($msg) = @_;	2355	# can/must only be called in main
		2356	if ($Coro::current != $Coro::main) {
		2357	warn "can only reload from main coroutine";
		2358	return;
		2359	}
1085		2360
1086	$msg->("reloading...");	2361	warn "reloading...";
1087		2362
1088	eval {	2363	warn "entering sync_job";
1089	# cancel all watchers	2364
		2365	cf::sync_job {
		2366	cf::write_runtime; # external watchdog should not bark
		2367	cf::emergency_save;
		2368	cf::write_runtime; # external watchdog should not bark
		2369
		2370	warn "syncing database to disk";
		2371	BDB::db_env_txn_checkpoint $DB_ENV;
		2372
		2373	# if anything goes wrong in here, we should simply crash as we already saved
		2374
		2375	warn "cancelling all WF_AUTOCANCEL watchers";
1090	$_->cancel for Event::all_watchers;	2376	for (Event::all_watchers) {
		2377	$_->cancel if $_->data & WF_AUTOCANCEL;
		2378	}
1091		2379
1092	# unload all extensions	2380	warn "flushing outstanding aio requests";
1093	for (@exts) {	2381	for (;;) {
1094	$msg->("unloading <$_>");	2382	BDB::flush;
1095	unload_extension $_;	2383	IO::AIO::flush;
		2384	Coro::cede;
		2385	last unless IO::AIO::nreqs || BDB::nreqs;
		2386	warn "iterate...";
		2387	}
		2388
		2389	warn "cancelling all extension coros";
		2390	$_->cancel for values %EXT_CORO;
		2391	%EXT_CORO = ();
		2392
		2393	warn "removing commands";
		2394	%COMMAND = ();
		2395
		2396	warn "removing ext commands";
		2397	%EXTCMD = ();
		2398
		2399	warn "unloading/nuking all extensions";
		2400	for my $pkg (@EXTS) {
		2401	warn "... unloading $pkg";
		2402
		2403	if (my $cb = $pkg->can ("unload")) {
		2404	eval {
		2405	$cb->($pkg);
		2406	1
		2407	} or warn "$pkg unloaded, but with errors: $@";
1096	}	2408	}
1097		2409
		2410	warn "... nuking $pkg";
		2411	Symbol::delete_package $pkg;
		2412	}
		2413
1098	# unload all modules loaded from $LIBDIR	2414	warn "unloading all perl modules loaded from $LIBDIR";
1099	while (my ($k, $v) = each %INC) {	2415	while (my ($k, $v) = each %INC) {
1100	next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;	2416	next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;
1101		2417
1102	$msg->("removing <$k>");	2418	warn "... unloading $k";
1103	delete $INC{$k};	2419	delete $INC{$k};
1104		2420
1105	$k =~ s/\.pm$//;	2421	$k =~ s/\.pm$//;
1106	$k =~ s/\//::/g;	2422	$k =~ s/\//::/g;
1107		2423
…		…
1110	}	2426	}
1111		2427
1112	Symbol::delete_package $k;	2428	Symbol::delete_package $k;
1113	}	2429	}
1114		2430
1115	# sync database to disk
1116	cf::db_sync;
1117
1118	# get rid of safe::, as good as possible	2431	warn "getting rid of safe::, as good as possible";
1119	Symbol::delete_package "safe::$_"	2432	Symbol::delete_package "safe::$_"
1120	for qw(cf::object cf::object::player cf::player cf::map cf::party cf::region);	2433	for qw(cf::attachable cf::object cf::object::player cf::client cf::player cf::map cf::party cf::region);
1121		2434
1122	# remove register_script_function callbacks
1123	# TODO
1124
1125	# unload cf.pm "a bit"	2435	warn "unloading cf.pm \"a bit\"";
1126	delete $INC{"cf.pm"};	2436	delete $INC{"cf.pm"};
1127		2437
1128	# don't, removes xs symbols, too,	2438	# don't, removes xs symbols, too,
1129	# and global variables created in xs	2439	# and global variables created in xs
1130	#Symbol::delete_package __PACKAGE__;	2440	#Symbol::delete_package __PACKAGE__;
1131		2441
1132	# reload cf.pm	2442	warn "unload completed, starting to reload now";
		2443
1133	$msg->("reloading cf.pm");	2444	warn "reloading cf.pm";
1134	require cf;	2445	require cf;
		2446	cf::_connect_to_perl; # nominally unnecessary, but cannot hurt
1135		2447
1136	# load config and database again	2448	warn "loading config and database again";
1137	cf::cfg_load;	2449	cf::cfg_load;
1138	cf::db_load;
1139		2450
1140	# load extensions	2451	warn "loading extensions";
1141	$msg->("load extensions");
1142	cf::load_extensions;	2452	cf::load_extensions;
1143		2453
1144	# reattach attachments to objects	2454	warn "reattaching attachments to objects/players";
1145	$msg->("reattach");
1146	_global_reattach;	2455	_global_reattach;
		2456	warn "reattaching attachments to maps";
		2457	reattach $_ for values %MAP;
		2458
		2459	warn "loading reloadable resources";
		2460	init_resources;
		2461
		2462	warn "leaving sync_job";
		2463
		2464	1
		2465	} or do {
		2466	warn $@;
		2467	warn "error while reloading, exiting.";
		2468	exit 1;
1147	};	2469	};
1148	$msg->($@) if $@;
1149		2470
1150	$msg->("reloaded");	2471	warn "reloaded";
1151	};	2472	};
1152		2473
1153	sub perl_reload() {	2474	our $RELOAD_WATCHER; # used only during reload
1154	_perl_reload {
1155	warn $_[0];
1156	print "$_[0]\n";
1157	};
1158	}
1159		2475
1160	register_command "perl-reload", 0, sub {	2476	register_command "reload" => sub {
1161	my ($who, $arg) = @_;	2477	my ($who, $arg) = @_;
1162		2478
1163	if ($who->flag (FLAG_WIZ)) {	2479	if ($who->flag (FLAG_WIZ)) {
1164	_perl_reload {	2480	$who->message ("reloading server.");
1165	warn $_[0];	2481
1166	$who->message ($_[0]);	2482	# doing reload synchronously and two reloads happen back-to-back,
		2483	# coro crashes during coro_state_free->destroy here.
		2484
		2485	$RELOAD_WATCHER ||= Event->timer (
		2486	reentrant => 0,
		2487	after => 0,
		2488	data => WF_AUTOCANCEL,
		2489	cb => sub {
		2490	reload;
		2491	undef $RELOAD_WATCHER;
		2492	},
1167	};	2493	);
1168	}	2494	}
1169	};	2495	};
1170		2496
1171	register "<global>", __PACKAGE__;
1172
1173	unshift @INC, $LIBDIR;	2497	unshift @INC, $LIBDIR;
1174		2498
		2499	my $bug_warning = 0;
		2500
1175	$TICK_WATCHER = Event->timer (	2501	$TICK_WATCHER = Event->timer (
		2502	reentrant => 0,
		2503	parked => 1,
1176	prio => 1,	2504	prio => 0,
1177	async => 1,
1178	at => $NEXT_TICK || 1,	2505	at => $NEXT_TICK || $TICK,
		2506	data => WF_AUTOCANCEL,
1179	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
1180	cf::server_tick; # one server iteration	2516	cf::server_tick; # one server iteration
1181		2517	$RUNTIME += $TICK;
1182	my $NOW = Event::time;
1183	$NEXT_TICK += $TICK;	2518	$NEXT_TICK += $TICK;
1184		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
1185	# if we are delayed by four ticks or more, skip them all	2534	# if we are delayed by four ticks or more, skip them all
1186	$NEXT_TICK = $NOW if $NOW >= $NEXT_TICK + $TICK * 4;	2535	$NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;
1187		2536
1188	$TICK_WATCHER->at ($NEXT_TICK);	2537	$TICK_WATCHER->at ($NEXT_TICK);
1189	$TICK_WATCHER->start;	2538	$TICK_WATCHER->start;
1190	},	2539	},
1191	);	2540	);
1192		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;
1193	IO::AIO::max_poll_time $TICK * 0.2;	2596	IO::AIO::max_poll_time $TICK * 0.1;
1194		2597	$AIO_POLL_WATCHER = Event->io (
1195	Event->io (fd => IO::AIO::poll_fileno,	2598	reentrant => 0,
		2599	data => WF_AUTOCANCEL,
		2600	fd => IO::AIO::poll_fileno,
1196	poll => 'r',	2601	poll => 'r',
1197	prio => 5,	2602	prio => 6,
1198	cb => \&IO::AIO::poll_cb);	2603	cb => \&IO::AIO::poll_cb,
		2604	);
		2605	}
		2606
		2607	END { cf::emergency_save }
1199		2608
1200	1	2609	1
1201		2610

Diff Legend

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