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.93 by root, Thu Dec 21 22:41:35 2006 UTC vs.
Revision 1.126 by root, Tue Jan 2 23:12:47 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.3;
		14	use Coro::Event;
		15	use Coro::Timer;
		16	use Coro::Signal;
		17	use Coro::Semaphore;
		18	use Coro::AIO;
		19
		20	use Digest::MD5;
		21	use Fcntl;
10	use IO::AIO ();	22	use IO::AIO 2.31 ();
11	use YAML::Syck ();	23	use YAML::Syck ();
12	use Time::HiRes;	24	use Time::HiRes;
13	use Event;	25
14	$Event::Eval = 1; # no idea why this is required, but it is	26	use Event; $Event::Eval = 1; # no idea why this is required, but it is
15		27
16	# work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode?	28	# work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode?
17	$YAML::Syck::ImplicitUnicode = 1;	29	$YAML::Syck::ImplicitUnicode = 1;
18		30
19	use strict;	31	$Coro::main->prio (2); # run main coroutine ("the server") with very high priority
20		32
21	sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload	33	sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload
22		34
23	our %COMMAND = ();	35	our %COMMAND = ();
24	our %COMMAND_TIME = ();	36	our %COMMAND_TIME = ();
25	our %EXTCMD = ();	37	our %EXTCMD = ();
26		38
27	_init_vars;
28
29	our @EVENT;	39	our @EVENT;
30	our $LIBDIR = datadir . "/ext";	40	our $LIBDIR = datadir . "/ext";
31		41
32	our $TICK = MAX_TIME * 1e-6;	42	our $TICK = MAX_TIME * 1e-6;
33	our $TICK_WATCHER;	43	our $TICK_WATCHER;
34	our $NEXT_TICK;	44	our $NEXT_TICK;
		45	our $NOW;
35		46
36	our %CFG;	47	our %CFG;
37		48
38	our $UPTIME; $UPTIME ||= time;	49	our $UPTIME; $UPTIME ||= time;
		50	our $RUNTIME;
		51
		52	our %MAP; # all maps
		53	our $LINK_MAP; # the special {link} map
		54	our $FREEZE;
		55	our $RANDOM_MAPS = cf::localdir . "/random";
		56	our %EXT_CORO;
		57
		58	binmode STDOUT;
		59	binmode STDERR;
		60
		61	# read virtual server time, if available
		62	unless ($RUNTIME || !-e cf::localdir . "/runtime") {
		63	open my $fh, "<", cf::localdir . "/runtime"
		64	or die "unable to read runtime file: $!";
		65	$RUNTIME = <$fh> + 0.;
		66	}
		67
		68	mkdir cf::localdir;
		69	mkdir cf::localdir . "/" . cf::playerdir;
		70	mkdir cf::localdir . "/" . cf::tmpdir;
		71	mkdir cf::localdir . "/" . cf::uniquedir;
		72	mkdir $RANDOM_MAPS;
		73
		74	# a special map that is always available
		75	our $LINK_MAP;
		76
		77	our $EMERGENCY_POSITION = $cf::CFG{emergency_position} || ["/world/world_105_115", 5, 37];
39		78
40	#############################################################################	79	#############################################################################
41		80
42	=head2 GLOBAL VARIABLES	81	=head2 GLOBAL VARIABLES
43		82
44	=over 4	83	=over 4
45		84
46	=item $cf::UPTIME	85	=item $cf::UPTIME
47		86
48	The timestamp of the server start (so not actually an uptime).	87	The timestamp of the server start (so not actually an uptime).
		88
		89	=item $cf::RUNTIME
		90
		91	The time this server has run, starts at 0 and is increased by $cf::TICK on
		92	every server tick.
49		93
50	=item $cf::LIBDIR	94	=item $cf::LIBDIR
51		95
52	The perl library directory, where extensions and cf-specific modules can	96	The perl library directory, where extensions and cf-specific modules can
53	be found. It will be added to C<@INC> automatically.	97	be found. It will be added to C<@INC> automatically.
		98
		99	=item $cf::NOW
		100
		101	The time of the last (current) server tick.
54		102
55	=item $cf::TICK	103	=item $cf::TICK
56		104
57	The interval between server ticks, in seconds.	105	The interval between server ticks, in seconds.
58		106
…		…
66	=cut	114	=cut
67		115
68	BEGIN {	116	BEGIN {
69	*CORE::GLOBAL::warn = sub {	117	*CORE::GLOBAL::warn = sub {
70	my $msg = join "", @_;	118	my $msg = join "", @_;
		119	utf8::encode $msg;
		120
71	$msg .= "\n"	121	$msg .= "\n"
72	unless $msg =~ /\n$/;	122	unless $msg =~ /\n$/;
73		123
74	print STDERR "cfperl: $msg";
75	LOG llevError, "cfperl: $msg";	124	LOG llevError, "cfperl: $msg";
76	};	125	};
77	}	126	}
78		127
79	@safe::cf::global::ISA = @cf::global::ISA = 'cf::attachable';	128	@safe::cf::global::ISA = @cf::global::ISA = 'cf::attachable';
…		…
84	@safe::cf::object::player::ISA = @cf::object::player::ISA = 'cf::object';	133	@safe::cf::object::player::ISA = @cf::object::player::ISA = 'cf::object';
85		134
86	# we bless all objects into (empty) derived classes to force a method lookup	135	# we bless all objects into (empty) derived classes to force a method lookup
87	# within the Safe compartment.	136	# within the Safe compartment.
88	for my $pkg (qw(	137	for my $pkg (qw(
89	cf::global	138	cf::global cf::attachable
90	cf::object cf::object::player	139	cf::object cf::object::player
91	cf::client cf::player	140	cf::client cf::player
92	cf::arch cf::living	141	cf::arch cf::living
93	cf::map cf::party cf::region	142	cf::map cf::party cf::region
94	)) {	143	)) {
…		…
132	sub to_json($) {	181	sub to_json($) {
133	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs	182	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs
134	JSON::Syck::Dump $_[0]	183	JSON::Syck::Dump $_[0]
135	}	184	}
136		185
		186	=item my $guard = cf::guard { BLOCK }
		187
		188	Run the given callback when the guard object gets destroyed (useful for
		189	coroutine cancellations).
		190
		191	You can call C<< ->cancel >> on the guard object to stop the block from
		192	being executed.
		193
		194	=cut
		195
		196	sub guard(&) {
		197	bless \(my $cb = $_[0]), cf::guard::;
		198	}
		199
		200	sub cf::guard::cancel {
		201	${$_[0]} = sub { };
		202	}
		203
		204	sub cf::guard::DESTROY {
		205	${$_[0]}->();
		206	}
		207
		208	=item cf::lock_wait $string
		209
		210	Wait until the given lock is available. See cf::lock_acquire.
		211
		212	=item my $lock = cf::lock_acquire $string
		213
		214	Wait until the given lock is available and then acquires it and returns
		215	a guard object. If the guard object gets destroyed (goes out of scope,
		216	for example when the coroutine gets canceled), the lock is automatically
		217	returned.
		218
		219	Lock names should begin with a unique identifier (for example, find_map
		220	uses map_find and load_map uses map_load).
		221
		222	=cut
		223
		224	our %LOCK;
		225
		226	sub lock_wait($) {
		227	my ($key) = @_;
		228
		229	# wait for lock, if any
		230	while ($LOCK{$key}) {
		231	push @{ $LOCK{$key} }, $Coro::current;
		232	Coro::schedule;
		233	}
		234	}
		235
		236	sub lock_acquire($) {
		237	my ($key) = @_;
		238
		239	# wait, to be sure we are not locked
		240	lock_wait $key;
		241
		242	$LOCK{$key} = [];
		243
		244	cf::guard {
		245	# wake up all waiters, to be on the safe side
		246	$_->ready for @{ delete $LOCK{$key} };
		247	}
		248	}
		249
		250	=item cf::sync_job { BLOCK }
		251
		252	The design of crossfire+ requires that the main coro ($Coro::main) is
		253	always able to handle events or runnable, as crossfire+ is only partly
		254	reentrant. Thus "blocking" it by e.g. waiting for I/O is not acceptable.
		255
		256	If it must be done, put the blocking parts into C<sync_job>. This will run
		257	the given BLOCK in another coroutine while waiting for the result. The
		258	server will be frozen during this time, so the block should either finish
		259	fast or be very important.
		260
		261	=cut
		262
		263	sub sync_job(&) {
		264	my ($job) = @_;
		265
		266	if ($Coro::current == $Coro::main) {
		267	# this is the main coro, too bad, we have to block
		268	# till the operation succeeds, freezing the server :/
		269
		270	# TODO: use suspend/resume instead
		271	# (but this is cancel-safe)
		272	local $FREEZE = 1;
		273
		274	my $busy = 1;
		275	my @res;
		276
		277	(Coro::async {
		278	@res = eval { $job->() };
		279	warn $@ if $@;
		280	undef $busy;
		281	})->prio (Coro::PRIO_MAX);
		282
		283	while ($busy) {
		284	Coro::cede_notself;
		285	Event::one_event unless Coro::nready;
		286	}
		287
		288	wantarray ? @res : $res[0]
		289	} else {
		290	# we are in another coroutine, how wonderful, everything just works
		291
		292	$job->()
		293	}
		294	}
		295
		296	=item $coro = cf::coro { BLOCK }
		297
		298	Creates and returns a new coro. This coro is automcatially being canceled
		299	when the extension calling this is being unloaded.
		300
		301	=cut
		302
		303	sub coro(&) {
		304	my $cb = shift;
		305
		306	my $coro; $coro = async {
		307	eval {
		308	$cb->();
		309	};
		310	warn $@ if $@;
		311	};
		312
		313	$coro->on_destroy (sub {
		314	delete $EXT_CORO{$coro+0};
		315	});
		316	$EXT_CORO{$coro+0} = $coro;
		317
		318	$coro
		319	}
		320
		321	sub write_runtime {
		322	my $runtime = cf::localdir . "/runtime";
		323
		324	my $fh = aio_open "$runtime~", O_WRONLY | O_CREAT, 0644
		325	or return;
		326
		327	my $value = $cf::RUNTIME + 1 + 10; # 10 is the runtime save interval, for a monotonic clock
		328	(aio_write $fh, 0, (length $value), $value, 0) <= 0
		329	and return;
		330
		331	aio_fsync $fh
		332	and return;
		333
		334	close $fh
		335	or return;
		336
		337	aio_rename "$runtime~", $runtime
		338	and return;
		339
		340	1
		341	}
		342
137	=back	343	=back
138		344
139	=cut	345	=cut
140		346
141	#############################################################################	347	#############################################################################
142		348
		349	package cf::path;
		350
		351	sub new {
		352	my ($class, $path, $base) = @_;
		353
		354	$path = $path->as_string if ref $path;
		355
		356	my $self = bless { }, $class;
		357
		358	# {... are special paths that are not touched
		359	# ?xxx/... are special absolute paths
		360	# ?random/... random maps
		361	# /! non-realised random map exit
		362	# /... normal maps
		363	# ~/... per-player maps without a specific player (DO NOT USE)
		364	# ~user/... per-player map of a specific user
		365
		366	if ($path =~ /^{/) {
		367	# fine as it is
		368	} elsif ($path =~ s{^\?random/}{}) {
		369	Coro::AIO::aio_load "$cf::RANDOM_MAPS/$path.meta", my $data;
		370	$self->{random} = cf::from_json $data;
		371	} else {
		372	if ($path =~ s{^~([^/]+)?}{}) {
		373	$self->{user_rel} = 1;
		374
		375	if (defined $1) {
		376	$self->{user} = $1;
		377	} elsif ($base =~ m{^~([^/]+)/}) {
		378	$self->{user} = $1;
		379	} else {
		380	warn "cannot resolve user-relative path without user <$path,$base>\n";
		381	}
		382	} elsif ($path =~ /^\//) {
		383	# already absolute
		384	} else {
		385	$base =~ s{[^/]+/?$}{};
		386	return $class->new ("$base/$path");
		387	}
		388
		389	for ($path) {
		390	redo if s{/\.?/}{/};
		391	redo if s{/[^/]+/\.\./}{/};
		392	}
		393	}
		394
		395	$self->{path} = $path;
		396
		397	$self
		398	}
		399
		400	# the name / primary key / in-game path
		401	sub as_string {
		402	my ($self) = @_;
		403
		404	$self->{user_rel} ? "~$self->{user}$self->{path}"
		405	: $self->{random} ? "?random/$self->{path}"
		406	: $self->{path}
		407	}
		408
		409	# the displayed name, this is a one way mapping
		410	sub visible_name {
		411	my ($self) = @_;
		412
		413	# if (my $rmp = $self->{random}) {
		414	# # todo: be more intelligent about this
		415	# "?random/$rmp->{origin_map}+$rmp->{origin_x}+$rmp->{origin_y}/$rmp->{dungeon_level}"
		416	# } else {
		417	$self->as_string
		418	# }
		419	}
		420
		421	# escape the /'s in the path
		422	sub _escaped_path {
		423	# ∕ is U+2215
		424	(my $path = $_[0]{path}) =~ s/\//∕/g;
		425	$path
		426	}
		427
		428	# the original (read-only) location
		429	sub load_path {
		430	my ($self) = @_;
		431
		432	sprintf "%s/%s/%s", cf::datadir, cf::mapdir, $self->{path}
		433	}
		434
		435	# the temporary/swap location
		436	sub save_path {
		437	my ($self) = @_;
		438
		439	$self->{user_rel} ? sprintf "%s/%s/%s/%s", cf::localdir, cf::playerdir, $self->{user}, $self->_escaped_path
		440	: $self->{random} ? sprintf "%s/%s", $RANDOM_MAPS, $self->{path}
		441	: sprintf "%s/%s/%s", cf::localdir, cf::tmpdir, $self->_escaped_path
		442	}
		443
		444	# the unique path, might be eq to save_path
		445	sub uniq_path {
		446	my ($self) = @_;
		447
		448	$self->{user_rel} || $self->{random}
		449	? undef
		450	: sprintf "%s/%s/%s", cf::localdir, cf::uniquedir, $self->_escaped_path
		451	}
		452
		453	# return random map parameters, or undef
		454	sub random_map_params {
		455	my ($self) = @_;
		456
		457	$self->{random}
		458	}
		459
		460	# this is somewhat ugly, but style maps do need special treatment
		461	sub is_style_map {
		462	$_[0]{path} =~ m{^/styles/}
		463	}
		464
		465	package cf;
		466
		467	#############################################################################
		468
143	=head2 ATTACHABLE OBJECTS	469	=head2 ATTACHABLE OBJECTS
144		470
145	You can define and attach attachments to each "attachable" object in	471	Many objects in crossfire are so-called attachable objects. That means you can
146	crossfire+ (objects, players, clients, maps and the special "global"	472	attach callbacks/event handlers (a collection of which is called an "attachment")
		473	to it. All such attachable objects support the following methods.
		474
147	class). In the following description, CLASS can be any of C<global>,	475	In the following description, CLASS can be any of C<global>, C<object>
148	C<object> C<player>, C<client> or C<map>.	476	C<player>, C<client> or C<map> (i.e. the attachable objects in
		477	crossfire+).
149		478
150	=over 4	479	=over 4
151		480
		481	=item $attachable->attach ($attachment, key => $value...)
		482
		483	=item $attachable->detach ($attachment)
		484
		485	Attach/detach a pre-registered attachment to a specific object and give it
		486	the specified key/value pairs as arguments.
		487
		488	Example, attach a minesweeper attachment to the given object, making it a
		489	10x10 minesweeper game:
		490
		491	$obj->attach (minesweeper => width => 10, height => 10);
		492
		493	=item $bool = $attachable->attached ($name)
		494
		495	Checks wether the named attachment is currently attached to the object.
		496
		497	=item cf::CLASS->attach ...
		498
		499	=item cf::CLASS->detach ...
		500
		501	Define an anonymous attachment and attach it to all objects of the given
		502	CLASS. See the next function for an explanation of its arguments.
		503
		504	You can attach to global events by using the C<cf::global> class.
		505
		506	Example, log all player logins:
		507
		508	cf::player->attach (
		509	on_login => sub {
		510	my ($pl) = @_;
		511	...
		512	},
		513	);
		514
		515	Example, attach to the jeweler skill:
		516
		517	cf::object->attach (
		518	type => cf::SKILL,
		519	subtype => cf::SK_JEWELER,
		520	on_use_skill => sub {
		521	my ($sk, $ob, $part, $dir, $msg) = @_;
		522	...
		523	},
		524	);
		525
152	=item cf::CLASS::attachment $name, ...	526	=item cf::CLASS::attachment $name, ...
153		527
154	Register an attachment by name through which attachable objects can refer	528	Register an attachment by C<$name> through which attachable objects of the
155	to this attachment.	529	given CLASS can refer to this attachment.
156		530
157	=item $bool = $attachable->attached ($name)	531	Some classes such as crossfire maps and objects can specify attachments
		532	that are attached at load/instantiate time, thus the need for a name.
158		533
159	Checks wether the named attachment is currently attached to the object.
160
161	=item $attachable->attach ($attachment, key => $value...)
162
163	=item $attachable->detach ($attachment)
164
165	Attach/detach a pre-registered attachment either to a specific object
166	(C<$attachable>) or all objects of the given class (if C<$attachable> is a
167	class in a static method call).
168
169	You can attach to global events by using the C<cf::global> class.
170
171	These method calls expect any number of the following handler/hook	534	These calls expect any number of the following handler/hook descriptions:
172	descriptions:
173		535
174	=over 4	536	=over 4
175		537
176	=item prio => $number	538	=item prio => $number
177		539
…		…
203	package and register them. Only handlers for eevents supported by the	565	package and register them. Only handlers for eevents supported by the
204	object/class are recognised.	566	object/class are recognised.
205		567
206	=back	568	=back
207		569
		570	Example, define an attachment called "sockpuppet" that calls the given
		571	event handler when a monster attacks:
		572
		573	cf::object::attachment sockpuppet =>
		574	on_skill_attack => sub {
		575	my ($self, $victim) = @_;
		576	...
		577	}
		578	}
		579
		580	=item $attachable->valid
		581
		582	Just because you have a perl object does not mean that the corresponding
		583	C-level object still exists. If you try to access an object that has no
		584	valid C counterpart anymore you get an exception at runtime. This method
		585	can be used to test for existence of the C object part without causing an
		586	exception.
		587
208	=cut	588	=cut
209		589
210	# the following variables are defined in .xs and must not be re-created	590	# the following variables are defined in .xs and must not be re-created
211	our @CB_GLOBAL = (); # registry for all global events	591	our @CB_GLOBAL = (); # registry for all global events
		592	our @CB_ATTACHABLE = (); # registry for all attachables
212	our @CB_OBJECT = (); # all objects (should not be used except in emergency)	593	our @CB_OBJECT = (); # all objects (should not be used except in emergency)
213	our @CB_PLAYER = ();	594	our @CB_PLAYER = ();
214	our @CB_CLIENT = ();	595	our @CB_CLIENT = ();
215	our @CB_TYPE = (); # registry for type (cf-object class) based events	596	our @CB_TYPE = (); # registry for type (cf-object class) based events
216	our @CB_MAP = ();	597	our @CB_MAP = ();
217		598
218	my %attachment;	599	my %attachment;
219		600
220	sub _attach_cb($$$$) {	601	sub _attach_cb($$$$) {
221	my ($registry, $event, $prio, $cb) = @_;	602	my ($registry, $event, $prio, $cb) = @_;
…		…
226		607
227	@{$registry->[$event]} = sort	608	@{$registry->[$event]} = sort
228	{ $a->[0] cmp $b->[0] }	609	{ $a->[0] cmp $b->[0] }
229	@{$registry->[$event] || []}, $cb;	610	@{$registry->[$event] || []}, $cb;
230	}	611	}
		612
		613	# hack
		614	my %attachable_klass = map +($_ => 1), KLASS_OBJECT, KLASS_CLIENT, KLASS_PLAYER, KLASS_MAP;
231		615
232	# attach handles attaching event callbacks	616	# attach handles attaching event callbacks
233	# the only thing the caller has to do is pass the correct	617	# the only thing the caller has to do is pass the correct
234	# registry (== where the callback attaches to).	618	# registry (== where the callback attaches to).
235	sub _attach {	619	sub _attach {
…		…
237		621
238	my $object_type;	622	my $object_type;
239	my $prio = 0;	623	my $prio = 0;
240	my %cb_id = map +("on_" . lc $EVENT[$_][0], $_) , grep $EVENT[$_][1] == $klass, 0 .. $#EVENT;	624	my %cb_id = map +("on_" . lc $EVENT[$_][0], $_) , grep $EVENT[$_][1] == $klass, 0 .. $#EVENT;
241		625
		626	#TODO: get rid of this hack
		627	if ($attachable_klass{$klass}) {
		628	%cb_id = (%cb_id, map +("on_" . lc $EVENT[$_][0], $_) , grep $EVENT[$_][1] == KLASS_ATTACHABLE, 0 .. $#EVENT);
		629	}
		630
242	while (@arg) {	631	while (@arg) {
243	my $type = shift @arg;	632	my $type = shift @arg;
244		633
245	if ($type eq "prio") {	634	if ($type eq "prio") {
246	$prio = shift @arg;	635	$prio = shift @arg;
…		…
321	my ($obj, $name) = @_;	710	my ($obj, $name) = @_;
322		711
323	exists $obj->{_attachment}{$name}	712	exists $obj->{_attachment}{$name}
324	}	713	}
325		714
326	for my $klass (qw(GLOBAL OBJECT PLAYER CLIENT MAP)) {	715	for my $klass (qw(ATTACHABLE GLOBAL OBJECT PLAYER CLIENT MAP)) {
327	eval "#line " . __LINE__ . " 'cf.pm'	716	eval "#line " . __LINE__ . " 'cf.pm'
328	sub cf::\L$klass\E::_attach_registry {	717	sub cf::\L$klass\E::_attach_registry {
329	(\\\@CB_$klass, KLASS_$klass)	718	(\\\@CB_$klass, KLASS_$klass)
330	}	719	}
331		720
…		…
367	}	756	}
368		757
369	0	758	0
370	}	759	}
371		760
372	=item $bool = cf::invoke EVENT_GLOBAL_XXX, ...	761	=item $bool = cf::global::invoke (EVENT_CLASS_XXX, ...)
373		762
374	=item $bool = $object->invoke (EVENT_OBJECT_XXX, ...)
375
376	=item $bool = $player->invoke (EVENT_PLAYER_XXX, ...)
377
378	=item $bool = $client->invoke (EVENT_CLIENT_XXX, ...)	763	=item $bool = $attachable->invoke (EVENT_CLASS_XXX, ...)
379		764
380	=item $bool = $map->invoke (EVENT_MAP_XXX, ...)
381
382	Generate a global/object/player/map-specific event with the given arguments.	765	Generate an object-specific event with the given arguments.
383		766
384	This API is preliminary (most likely, the EVENT_KLASS_xxx prefix will be	767	This API is preliminary (most likely, the EVENT_CLASS_xxx prefix will be
385	removed in future versions), and there is no public API to access override	768	removed in future versions), and there is no public API to access override
386	results (if you must, access C<@cf::invoke_results> directly).	769	results (if you must, access C<@cf::invoke_results> directly).
387		770
388	=back	771	=back
389		772
390	=cut	773	=cut
391		774
392	#############################################################################	775	#############################################################################
393
394	=head2 METHODS VALID FOR ALL ATTACHABLE OBJECTS
395
396	Attachable objects includes objects, players, clients and maps.
397
398	=over 4
399
400	=item $object->valid
401
402	Just because you have a perl object does not mean that the corresponding
403	C-level object still exists. If you try to access an object that has no
404	valid C counterpart anymore you get an exception at runtime. This method
405	can be used to test for existence of the C object part without causing an
406	exception.
407
408	=back
409
410	=cut
411
412	#############################################################################
413	# object support	776	# object support
414		777
415	sub instantiate {
416	my ($obj, $data) = @_;
417
418	$data = from_json $data;
419
420	for (@$data) {
421	my ($name, $args) = @$_;
422
423	$obj->attach ($name, %{$args || {} });
424	}
425	}
426
427	# basically do the same as instantiate, without calling instantiate
428	sub reattach {	778	sub reattach {
		779	# basically do the same as instantiate, without calling instantiate
429	my ($obj) = @_;	780	my ($obj) = @_;
		781
430	my $registry = $obj->registry;	782	my $registry = $obj->registry;
431		783
432	@$registry = ();	784	@$registry = ();
433		785
434	delete $obj->{_attachment} unless scalar keys %{ $obj->{_attachment} || {} };	786	delete $obj->{_attachment} unless scalar keys %{ $obj->{_attachment} || {} };
…		…
443	warn "object uses attachment '$name' that is not available, postponing.\n";	795	warn "object uses attachment '$name' that is not available, postponing.\n";
444	}	796	}
445	}	797	}
446	}	798	}
447		799
448	sub object_freezer_save {	800	cf::attachable->attach (
449	my ($filename, $rdata, $objs) = @_;
450
451	if (length $$rdata) {
452	warn sprintf "saving %s (%d,%d)\n",
453	$filename, length $$rdata, scalar @$objs;
454
455	if (open my $fh, ">:raw", "$filename~") {
456	chmod SAVE_MODE, $fh;
457	syswrite $fh, $$rdata;
458	close $fh;
459
460	if (@$objs && open my $fh, ">:raw", "$filename.pst~") {
461	chmod SAVE_MODE, $fh;
462	syswrite $fh, Storable::nfreeze { version => 1, objs => $objs };
463	close $fh;
464	rename "$filename.pst~", "$filename.pst";
465	} else {
466	unlink "$filename.pst";
467	}
468
469	rename "$filename~", $filename;
470	} else {
471	warn "FATAL: $filename~: $!\n";
472	}
473	} else {
474	unlink $filename;
475	unlink "$filename.pst";
476	}
477	}
478
479	sub object_freezer_as_string {
480	my ($rdata, $objs) = @_;
481
482	use Data::Dumper;
483
484	$$rdata . Dumper $objs
485	}
486
487	sub object_thawer_load {
488	my ($filename) = @_;
489
490	local $/;
491
492	my $av;
493
494	#TODO: use sysread etc.
495	if (open my $data, "<:raw:perlio", $filename) {
496	$data = <$data>;
497	if (open my $pst, "<:raw:perlio", "$filename.pst") {
498	$av = eval { (Storable::thaw <$pst>)->{objs} };
499	}
500	return ($data, $av);
501	}
502
503	()
504	}
505
506	cf::object->attach (
507	prio => -1000000,	801	prio => -1000000,
		802	on_instantiate => sub {
		803	my ($obj, $data) = @_;
		804
		805	$data = from_json $data;
		806
		807	for (@$data) {
		808	my ($name, $args) = @$_;
		809
		810	$obj->attach ($name, %{$args || {} });
		811	}
		812	},
		813	on_reattach => \&reattach,
508	on_clone => sub {	814	on_clone => sub {
509	my ($src, $dst) = @_;	815	my ($src, $dst) = @_;
510		816
511	@{$dst->registry} = @{$src->registry};	817	@{$dst->registry} = @{$src->registry};
512		818
…		…
514		820
515	%{$dst->{_attachment}} = %{$src->{_attachment}}	821	%{$dst->{_attachment}} = %{$src->{_attachment}}
516	if exists $src->{_attachment};	822	if exists $src->{_attachment};
517	},	823	},
518	);	824	);
		825
		826	sub object_freezer_save {
		827	my ($filename, $rdata, $objs) = @_;
		828
		829	sync_job {
		830	if (length $$rdata) {
		831	warn sprintf "saving %s (%d,%d)\n",
		832	$filename, length $$rdata, scalar @$objs;
		833
		834	if (my $fh = aio_open "$filename~", O_WRONLY | O_CREAT, 0600) {
		835	chmod SAVE_MODE, $fh;
		836	aio_write $fh, 0, (length $$rdata), $$rdata, 0;
		837	aio_fsync $fh;
		838	close $fh;
		839
		840	if (@$objs) {
		841	if (my $fh = aio_open "$filename.pst~", O_WRONLY | O_CREAT, 0600) {
		842	chmod SAVE_MODE, $fh;
		843	my $data = Storable::nfreeze { version => 1, objs => $objs };
		844	aio_write $fh, 0, (length $data), $data, 0;
		845	aio_fsync $fh;
		846	close $fh;
		847	aio_rename "$filename.pst~", "$filename.pst";
		848	}
		849	} else {
		850	aio_unlink "$filename.pst";
		851	}
		852
		853	aio_rename "$filename~", $filename;
		854	} else {
		855	warn "FATAL: $filename~: $!\n";
		856	}
		857	} else {
		858	aio_unlink $filename;
		859	aio_unlink "$filename.pst";
		860	}
		861	}
		862	}
		863
		864	sub object_freezer_as_string {
		865	my ($rdata, $objs) = @_;
		866
		867	use Data::Dumper;
		868
		869	$$rdata . Dumper $objs
		870	}
		871
		872	sub object_thawer_load {
		873	my ($filename) = @_;
		874
		875	my ($data, $av);
		876
		877	(aio_load $filename, $data) >= 0
		878	or return;
		879
		880	unless (aio_stat "$filename.pst") {
		881	(aio_load "$filename.pst", $av) >= 0
		882	or return;
		883	$av = eval { (Storable::thaw $av)->{objs} };
		884	}
		885
		886	warn sprintf "loading %s (%d)\n",
		887	$filename, length $data, scalar @{$av || []};#d#
		888	return ($data, $av);
		889	}
519		890
520	#############################################################################	891	#############################################################################
521	# command handling &c	892	# command handling &c
522		893
523	=item cf::register_command $name => \&callback($ob,$args);	894	=item cf::register_command $name => \&callback($ob,$args);
…		…
712		1083
713	=head2 CORE EXTENSIONS	1084	=head2 CORE EXTENSIONS
714		1085
715	Functions and methods that extend core crossfire objects.	1086	Functions and methods that extend core crossfire objects.
716		1087
		1088	=head3 cf::player
		1089
717	=over 4	1090	=over 4
718		1091
719	=item cf::player::exists $login	1092	=item cf::player::exists $login
720		1093
721	Returns true when the given account exists.	1094	Returns true when the given account exists.
…		…
725	sub cf::player::exists($) {	1098	sub cf::player::exists($) {
726	cf::player::find $_[0]	1099	cf::player::find $_[0]
727	or -f sprintf "%s/%s/%s/%s.pl", cf::localdir, cf::playerdir, ($_[0]) x 2;	1100	or -f sprintf "%s/%s/%s/%s.pl", cf::localdir, cf::playerdir, ($_[0]) x 2;
728	}	1101	}
729		1102
		1103	=item $player->ext_reply ($msgid, $msgtype, %msg)
		1104
		1105	Sends an ext reply to the player.
		1106
		1107	=cut
		1108
		1109	sub cf::player::ext_reply($$$%) {
		1110	my ($self, $id, %msg) = @_;
		1111
		1112	$msg{msgid} = $id;
		1113
		1114	$self->send ("ext " . to_json \%msg);
		1115	}
		1116
		1117	=back
		1118
		1119
		1120	=head3 cf::map
		1121
		1122	=over 4
		1123
		1124	=cut
		1125
		1126	package cf::map;
		1127
		1128	use Fcntl;
		1129	use Coro::AIO;
		1130
		1131	our $MAX_RESET = 7200;
		1132	our $DEFAULT_RESET = 3600;
		1133
		1134	sub generate_random_map {
		1135	my ($path, $rmp) = @_;
		1136
		1137	# mit "rum" bekleckern, nicht
		1138	cf::map::_create_random_map
		1139	$path,
		1140	$rmp->{wallstyle}, $rmp->{wall_name}, $rmp->{floorstyle}, $rmp->{monsterstyle},
		1141	$rmp->{treasurestyle}, $rmp->{layoutstyle}, $rmp->{doorstyle}, $rmp->{decorstyle},
		1142	$rmp->{origin_map}, $rmp->{final_map}, $rmp->{exitstyle}, $rmp->{this_map},
		1143	$rmp->{exit_on_final_map},
		1144	$rmp->{xsize}, $rmp->{ysize},
		1145	$rmp->{expand2x}, $rmp->{layoutoptions1}, $rmp->{layoutoptions2}, $rmp->{layoutoptions3},
		1146	$rmp->{symmetry}, $rmp->{difficulty}, $rmp->{difficulty_given}, $rmp->{difficulty_increase},
		1147	$rmp->{dungeon_level}, $rmp->{dungeon_depth}, $rmp->{decoroptions}, $rmp->{orientation},
		1148	$rmp->{origin_y}, $rmp->{origin_x}, $rmp->{random_seed}, $rmp->{total_map_hp},
		1149	$rmp->{map_layout_style}, $rmp->{treasureoptions}, $rmp->{symmetry_used},
		1150	(cf::region::find $rmp->{region})
		1151	}
		1152
		1153	# and all this just because we cannot iterate over
		1154	# all maps in C++...
		1155	sub change_all_map_light {
		1156	my ($change) = @_;
		1157
		1158	$_->change_map_light ($change)
		1159	for grep $_->outdoor, values %cf::MAP;
		1160	}
		1161
		1162	sub try_load_header($) {
		1163	my ($path) = @_;
		1164
		1165	utf8::encode $path;
		1166	aio_open $path, O_RDONLY, 0
		1167	or return;
		1168
		1169	my $map = cf::map::new
		1170	or return;
		1171
		1172	$map->load_header ($path)
		1173	or return;
		1174
		1175	$map->{load_path} = $path;
		1176
		1177	$map
		1178	}
		1179
		1180	sub find_map;
		1181	sub find_map {
		1182	my ($path, $origin) = @_;
		1183
		1184	#warn "find_map<$path,$origin>\n";#d#
		1185
		1186	$path = new cf::path $path, $origin && $origin->path;
		1187	my $key = $path->as_string;
		1188
		1189	cf::lock_wait "map_find:$key";
		1190
		1191	$cf::MAP{$key} || do {
		1192	my $guard = cf::lock_acquire "map_find:$key";
		1193
		1194	# do it the slow way
		1195	my $map = try_load_header $path->save_path;
		1196
		1197	if ($map) {
		1198	# safety
		1199	$map->{instantiate_time} = $cf::RUNTIME
		1200	if $map->{instantiate_time} > $cf::RUNTIME;
		1201	} else {
		1202	if (my $rmp = $path->random_map_params) {
		1203	$map = generate_random_map $key, $rmp;
		1204	} else {
		1205	$map = try_load_header $path->load_path;
		1206	}
		1207
		1208	$map or return;
		1209
		1210	$map->{load_original} = 1;
		1211	$map->{instantiate_time} = $cf::RUNTIME;
		1212	$map->instantiate;
		1213
		1214	# per-player maps become, after loading, normal maps
		1215	$map->per_player (0) if $path->{user_rel};
		1216	}
		1217
		1218	$map->path ($key);
		1219	$map->{path} = $path;
		1220	$map->{last_save} = $cf::RUNTIME;
		1221	$map->last_access ($cf::RUNTIME);
		1222
		1223	if ($map->should_reset) {
		1224	$map->reset;
		1225	undef $guard;
		1226	$map = find_map $path
		1227	or return;
		1228	}
		1229
		1230	$cf::MAP{$key} = $map
		1231	}
		1232	}
		1233
		1234	sub load {
		1235	my ($self) = @_;
		1236
		1237	my $path = $self->{path};
		1238	my $guard = cf::lock_acquire "map_load:" . $path->as_string;
		1239
		1240	return if $self->in_memory != cf::MAP_SWAPPED;
		1241
		1242	$self->in_memory (cf::MAP_LOADING);
		1243
		1244	$self->alloc;
		1245	$self->load_objects ($self->{load_path}, 1)
		1246	or return;
		1247
		1248	$self->set_object_flag (cf::FLAG_OBJ_ORIGINAL, 1)
		1249	if delete $self->{load_original};
		1250
		1251	if (my $uniq = $path->uniq_path) {
		1252	utf8::encode $uniq;
		1253	if (aio_open $uniq, O_RDONLY, 0) {
		1254	$self->clear_unique_items;
		1255	$self->load_objects ($uniq, 0);
		1256	}
		1257	}
		1258
		1259	# now do the right thing for maps
		1260	$self->link_multipart_objects;
		1261
		1262	if ($self->{path}->is_style_map) {
		1263	$self->{deny_save} = 1;
		1264	$self->{deny_reset} = 1;
		1265	} else {
		1266	$self->fix_auto_apply;
		1267	$self->decay_objects;
		1268	$self->update_buttons;
		1269	$self->set_darkness_map;
		1270	$self->difficulty ($self->estimate_difficulty)
		1271	unless $self->difficulty;
		1272	$self->activate;
		1273	}
		1274
		1275	$self->in_memory (cf::MAP_IN_MEMORY);
		1276	}
		1277
		1278	sub load_map_sync {
		1279	my ($path, $origin) = @_;
		1280
		1281	#warn "load_map_sync<$path, $origin>\n";#d#
		1282
		1283	cf::sync_job {
		1284	my $map = cf::map::find_map $path, $origin
		1285	or return;
		1286	$map->load;
		1287	$map
		1288	}
		1289	}
		1290
		1291	sub save {
		1292	my ($self) = @_;
		1293
		1294	$self->{last_save} = $cf::RUNTIME;
		1295
		1296	return unless $self->dirty;
		1297
		1298	my $save = $self->{path}->save_path; utf8::encode $save;
		1299	my $uniq = $self->{path}->uniq_path; utf8::encode $uniq;
		1300
		1301	$self->{load_path} = $save;
		1302
		1303	return if $self->{deny_save};
		1304
		1305	if ($uniq) {
		1306	$self->save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS);
		1307	$self->save_objects ($uniq, cf::IO_UNIQUES);
		1308	} else {
		1309	$self->save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS | cf::IO_UNIQUES);
		1310	}
		1311	}
		1312
		1313	sub swap_out {
		1314	my ($self) = @_;
		1315
		1316	return if $self->players;
		1317	return if $self->in_memory != cf::MAP_IN_MEMORY;
		1318	return if $self->{deny_save};
		1319
		1320	$self->save;
		1321	$self->clear;
		1322	$self->in_memory (cf::MAP_SWAPPED);
		1323	}
		1324
		1325	sub reset_at {
		1326	my ($self) = @_;
		1327
		1328	# TODO: safety, remove and allow resettable per-player maps
		1329	return 1e99 if $self->{path}{user_rel};
		1330	return 1e99 if $self->{deny_reset};
		1331
		1332	my $time = $self->fixed_resettime ? $self->{instantiate_time} : $self->last_access;
		1333	my $to = List::Util::min $MAX_RESET, $self->reset_timeout || $DEFAULT_RESET;
		1334
		1335	$time + $to
		1336	}
		1337
		1338	sub should_reset {
		1339	my ($self) = @_;
		1340
		1341	$self->reset_at <= $cf::RUNTIME
		1342	}
		1343
		1344	sub unlink_save {
		1345	my ($self) = @_;
		1346
		1347	utf8::encode (my $save = $self->{path}->save_path);
		1348	aioreq_pri 3; IO::AIO::aio_unlink $save;
		1349	aioreq_pri 3; IO::AIO::aio_unlink "$save.pst";
		1350	}
		1351
		1352	sub rename {
		1353	my ($self, $new_path) = @_;
		1354
		1355	$self->unlink_save;
		1356
		1357	delete $cf::MAP{$self->path};
		1358	$self->{path} = new cf::path $new_path;
		1359	$self->path ($self->{path}->as_string);
		1360	$cf::MAP{$self->path} = $self;
		1361
		1362	$self->save;
		1363	}
		1364
		1365	sub reset {
		1366	my ($self) = @_;
		1367
		1368	return if $self->players;
		1369	return if $self->{path}{user_rel};#d#
		1370
		1371	warn "resetting map ", $self->path;#d#
		1372
		1373	delete $cf::MAP{$self->path};
		1374
		1375	$_->clear_links_to ($self) for values %cf::MAP;
		1376
		1377	$self->unlink_save;
		1378	$self->destroy;
		1379	}
		1380
		1381	my $nuke_counter = "aaaa";
		1382
		1383	sub nuke {
		1384	my ($self) = @_;
		1385
		1386	$self->{deny_save} = 1;
		1387	$self->reset_timeout (1);
		1388	$self->rename ("{nuke}/" . ($nuke_counter++));
		1389	$self->reset; # polite request, might not happen
		1390	}
		1391
		1392	sub customise_for {
		1393	my ($map, $ob) = @_;
		1394
		1395	if ($map->per_player) {
		1396	return cf::map::find_map "~" . $ob->name . "/" . $map->{path}{path};
		1397	}
		1398
		1399	$map
		1400	}
		1401
		1402	sub emergency_save {
		1403	local $cf::FREEZE = 1;
		1404
		1405	warn "enter emergency map save\n";
		1406
		1407	cf::sync_job {
		1408	warn "begin emergency map save\n";
		1409	$_->save for values %cf::MAP;
		1410	};
		1411
		1412	warn "end emergency map save\n";
		1413	}
		1414
		1415	package cf;
		1416
		1417	=back
		1418
		1419
		1420	=head3 cf::object::player
		1421
		1422	=over 4
		1423
730	=item $player_object->reply ($npc, $msg[, $flags])	1424	=item $player_object->reply ($npc, $msg[, $flags])
731		1425
732	Sends a message to the player, as if the npc C<$npc> replied. C<$npc>	1426	Sends a message to the player, as if the npc C<$npc> replied. C<$npc>
733	can be C<undef>. Does the right thing when the player is currently in a	1427	can be C<undef>. Does the right thing when the player is currently in a
734	dialogue with the given NPC character.	1428	dialogue with the given NPC character.
735		1429
736	=cut	1430	=cut
737		1431
738	# rough implementation of a future "reply" method that works	1432	# rough implementation of a future "reply" method that works
739	# with dialog boxes.	1433	# with dialog boxes.
		1434	#TODO: the first argument must go, split into a $npc->reply_to ( method
740	sub cf::object::player::reply($$$;$) {	1435	sub cf::object::player::reply($$$;$) {
741	my ($self, $npc, $msg, $flags) = @_;	1436	my ($self, $npc, $msg, $flags) = @_;
742		1437
743	$flags = cf::NDI_BROWN | cf::NDI_UNIQUE unless @_ >= 4;	1438	$flags = cf::NDI_BROWN | cf::NDI_UNIQUE unless @_ >= 4;
744		1439
…		…
748	$msg = $npc->name . " says: $msg" if $npc;	1443	$msg = $npc->name . " says: $msg" if $npc;
749	$self->message ($msg, $flags);	1444	$self->message ($msg, $flags);
750	}	1445	}
751	}	1446	}
752		1447
753	=item $player->ext_reply ($msgid, $msgtype, %msg)
754
755	Sends an ext reply to the player.
756
757	=cut
758
759	sub cf::player::ext_reply($$$%) {
760	my ($self, $id, %msg) = @_;
761
762	$msg{msgid} = $id;
763
764	$self->send ("ext " . to_json \%msg);
765	}
766
767	=item $player_object->may ("access")	1448	=item $player_object->may ("access")
768		1449
769	Returns wether the given player is authorized to access resource "access"	1450	Returns wether the given player is authorized to access resource "access"
770	(e.g. "command_wizcast").	1451	(e.g. "command_wizcast").
771		1452
…		…
778	(ref $cf::CFG{"may_$access"}	1459	(ref $cf::CFG{"may_$access"}
779	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}	1460	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}
780	: $cf::CFG{"may_$access"})	1461	: $cf::CFG{"may_$access"})
781	}	1462	}
782		1463
783	=cut	1464	=item $player_object->enter_link
784		1465
785	#############################################################################	1466	Freezes the player and moves him/her to a special map (C<{link}>).
		1467
		1468	The player should be reaosnably safe there for short amounts of time. You
		1469	I<MUST> call C<leave_link> as soon as possible, though.
		1470
		1471	=item $player_object->leave_link ($map, $x, $y)
		1472
		1473	Moves the player out of the specila link map onto the given map. If the
		1474	map is not valid (or omitted), the player will be moved back to the
		1475	location he/she was before the call to C<enter_link>, or, if that fails,
		1476	to the emergency map position.
		1477
		1478	Might block.
		1479
		1480	=cut
		1481
		1482	sub cf::object::player::enter_link {
		1483	my ($self) = @_;
		1484
		1485	$self->deactivate_recursive;
		1486
		1487	return if $self->map == $LINK_MAP;
		1488
		1489	$self->{_link_pos} ||= [$self->map->{path}, $self->x, $self->y]
		1490	if $self->map;
		1491
		1492	$self->enter_map ($LINK_MAP, 20, 20);
		1493	}
		1494
		1495	sub cf::object::player::leave_link {
		1496	my ($self, $map, $x, $y) = @_;
		1497
		1498	my $link_pos = delete $self->{_link_pos};
		1499
		1500	unless ($map) {
		1501	# restore original map position
		1502	($map, $x, $y) = @{ $link_pos || [] };
		1503	$map = cf::map::find_map $map;
		1504
		1505	unless ($map) {
		1506	($map, $x, $y) = @$EMERGENCY_POSITION;
		1507	$map = cf::map::find_map $map
		1508	or die "FATAL: cannot load emergency map\n";
		1509	}
		1510	}
		1511
		1512	($x, $y) = (-1, -1)
		1513	unless (defined $x) && (defined $y);
		1514
		1515	# use -1 or undef as default coordinates, not 0, 0
		1516	($x, $y) = ($map->enter_x, $map->enter_y)
		1517	if $x <=0 && $y <= 0;
		1518
		1519	$map->load;
		1520
		1521	$self->activate_recursive;
		1522	$self->enter_map ($map, $x, $y);
		1523	}
		1524
		1525	cf::player->attach (
		1526	on_logout => sub {
		1527	my ($pl) = @_;
		1528
		1529	# abort map switching before logout
		1530	if ($pl->ob->{_link_pos}) {
		1531	cf::sync_job {
		1532	$pl->ob->leave_link
		1533	};
		1534	}
		1535	},
		1536	on_login => sub {
		1537	my ($pl) = @_;
		1538
		1539	# try to abort aborted map switching on player login :)
		1540	# should happen only on crashes
		1541	if ($pl->ob->{_link_pos}) {
		1542	$pl->ob->enter_link;
		1543	Coro::async {
		1544	# we need this sleep as the login has a concurrent enter_exit running
		1545	# and this sleep increases chances of the player not ending up in scorn
		1546	Coro::Timer::sleep 1;
		1547	$pl->ob->leave_link;
		1548	};
		1549	}
		1550	},
		1551	);
		1552
		1553	=item $player_object->goto_map ($path, $x, $y)
		1554
		1555	=cut
		1556
		1557	sub cf::object::player::goto_map {
		1558	my ($self, $path, $x, $y) = @_;
		1559
		1560	$self->enter_link;
		1561
		1562	(Coro::async {
		1563	$path = new cf::path $path;
		1564
		1565	my $map = cf::map::find_map $path->as_string;
		1566	$map = $map->customise_for ($self) if $map;
		1567
		1568	# warn "entering ", $map->path, " at ($x, $y)\n"
		1569	# if $map;
		1570
		1571	$map or $self->message ("The exit is closed", cf::NDI_UNIQUE | cf::NDI_RED);
		1572
		1573	$self->leave_link ($map, $x, $y);
		1574	})->prio (1);
		1575	}
		1576
		1577	=item $player_object->enter_exit ($exit_object)
		1578
		1579	=cut
		1580
		1581	sub parse_random_map_params {
		1582	my ($spec) = @_;
		1583
		1584	my $rmp = { # defaults
		1585	xsize => 10,
		1586	ysize => 10,
		1587	};
		1588
		1589	for (split /\n/, $spec) {
		1590	my ($k, $v) = split /\s+/, $_, 2;
		1591
		1592	$rmp->{lc $k} = $v if (length $k) && (length $v);
		1593	}
		1594
		1595	$rmp
		1596	}
		1597
		1598	sub prepare_random_map {
		1599	my ($exit) = @_;
		1600
		1601	# all this does is basically replace the /! path by
		1602	# a new random map path (?random/...) with a seed
		1603	# that depends on the exit object
		1604
		1605	my $rmp = parse_random_map_params $exit->msg;
		1606
		1607	if ($exit->map) {
		1608	$rmp->{region} = $exit->map->region_name;
		1609	$rmp->{origin_map} = $exit->map->path;
		1610	$rmp->{origin_x} = $exit->x;
		1611	$rmp->{origin_y} = $exit->y;
		1612	}
		1613
		1614	$rmp->{random_seed} ||= $exit->random_seed;
		1615
		1616	my $data = cf::to_json $rmp;
		1617	my $md5 = Digest::MD5::md5_hex $data;
		1618
		1619	if (my $fh = aio_open "$cf::RANDOM_MAPS/$md5.meta", O_WRONLY | O_CREAT, 0666) {
		1620	aio_write $fh, 0, (length $data), $data, 0;
		1621
		1622	$exit->slaying ("?random/$md5");
		1623	$exit->msg (undef);
		1624	}
		1625	}
		1626
		1627	sub cf::object::player::enter_exit {
		1628	my ($self, $exit) = @_;
		1629
		1630	return unless $self->type == cf::PLAYER;
		1631
		1632	$self->enter_link;
		1633
		1634	(Coro::async {
		1635	unless (eval {
		1636
		1637	prepare_random_map $exit
		1638	if $exit->slaying eq "/!";
		1639
		1640	my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;
		1641	$self->goto_map ($path, $exit->stats->hp, $exit->stats->sp);
		1642
		1643	1;
		1644	}) {
		1645	$self->message ("Something went wrong deep within the crossfire server. "
		1646	. "I'll try to bring you back to the map you were before. "
		1647	. "Please report this to the dungeon master",
		1648	cf::NDI_UNIQUE | cf::NDI_RED);
		1649
		1650	warn "ERROR in enter_exit: $@";
		1651	$self->leave_link;
		1652	}
		1653	})->prio (1);
		1654	}
		1655
		1656	=head3 cf::client
		1657
		1658	=over 4
		1659
		1660	=item $client->send_drawinfo ($text, $flags)
		1661
		1662	Sends a drawinfo packet to the client. Circumvents output buffering so
		1663	should not be used under normal circumstances.
		1664
		1665	=cut
		1666
		1667	sub cf::client::send_drawinfo {
		1668	my ($self, $text, $flags) = @_;
		1669
		1670	utf8::encode $text;
		1671	$self->send_packet (sprintf "drawinfo %d %s", $flags, $text);
		1672	}
		1673
		1674
		1675	=item $success = $client->query ($flags, "text", \&cb)
		1676
		1677	Queues a query to the client, calling the given callback with
		1678	the reply text on a reply. flags can be C<cf::CS_QUERY_YESNO>,
		1679	C<cf::CS_QUERY_SINGLECHAR> or C<cf::CS_QUERY_HIDEINPUT> or C<0>.
		1680
		1681	Queries can fail, so check the return code. Or don't, as queries will become
		1682	reliable at some point in the future.
		1683
		1684	=cut
		1685
		1686	sub cf::client::query {
		1687	my ($self, $flags, $text, $cb) = @_;
		1688
		1689	return unless $self->state == ST_PLAYING
		1690	|| $self->state == ST_SETUP
		1691	|| $self->state == ST_CUSTOM;
		1692
		1693	$self->state (ST_CUSTOM);
		1694
		1695	utf8::encode $text;
		1696	push @{ $self->{query_queue} }, [(sprintf "query %d %s", $flags, $text), $cb];
		1697
		1698	$self->send_packet ($self->{query_queue}[0][0])
		1699	if @{ $self->{query_queue} } == 1;
		1700	}
		1701
		1702	cf::client->attach (
		1703	on_reply => sub {
		1704	my ($ns, $msg) = @_;
		1705
		1706	# this weird shuffling is so that direct followup queries
		1707	# get handled first
		1708	my $queue = delete $ns->{query_queue};
		1709
		1710	(shift @$queue)->[1]->($msg);
		1711
		1712	push @{ $ns->{query_queue} }, @$queue;
		1713
		1714	if (@{ $ns->{query_queue} } == @$queue) {
		1715	if (@$queue) {
		1716	$ns->send_packet ($ns->{query_queue}[0][0]);
		1717	} else {
		1718	$ns->state (ST_PLAYING) if $ns->state == ST_CUSTOM;
		1719	}
		1720	}
		1721	},
		1722	);
		1723
		1724	=item $client->coro (\&cb)
		1725
		1726	Create a new coroutine, running the specified callback. The coroutine will
		1727	be automatically cancelled when the client gets destroyed (e.g. on logout,
		1728	or loss of connection).
		1729
		1730	=cut
		1731
		1732	sub cf::client::coro {
		1733	my ($self, $cb) = @_;
		1734
		1735	my $coro; $coro = async {
		1736	eval {
		1737	$cb->();
		1738	};
		1739	warn $@ if $@;
		1740	};
		1741
		1742	$coro->on_destroy (sub {
		1743	delete $self->{_coro}{$coro+0};
		1744	});
		1745
		1746	$self->{_coro}{$coro+0} = $coro;
		1747
		1748	$coro
		1749	}
		1750
		1751	cf::client->attach (
		1752	on_destroy => sub {
		1753	my ($ns) = @_;
		1754
		1755	$_->cancel for values %{ (delete $ns->{_coro}) || {} };
		1756	},
		1757	);
		1758
		1759	=back
		1760
786		1761
787	=head2 SAFE SCRIPTING	1762	=head2 SAFE SCRIPTING
788		1763
789	Functions that provide a safe environment to compile and execute	1764	Functions that provide a safe environment to compile and execute
790	snippets of perl code without them endangering the safety of the server	1765	snippets of perl code without them endangering the safety of the server
…		…
942		1917
943	{	1918	{
944	my $path = cf::localdir . "/database.pst";	1919	my $path = cf::localdir . "/database.pst";
945		1920
946	sub db_load() {	1921	sub db_load() {
947	warn "loading database $path\n";#d# remove later
948	$DB = stat $path ? Storable::retrieve $path : { };	1922	$DB = stat $path ? Storable::retrieve $path : { };
949	}	1923	}
950		1924
951	my $pid;	1925	my $pid;
952		1926
953	sub db_save() {	1927	sub db_save() {
954	warn "saving database $path\n";#d# remove later
955	waitpid $pid, 0 if $pid;	1928	waitpid $pid, 0 if $pid;
956	if (0 == ($pid = fork)) {	1929	if (0 == ($pid = fork)) {
957	$DB->{_meta}{version} = 1;	1930	$DB->{_meta}{version} = 1;
958	Storable::nstore $DB, "$path~";	1931	Storable::nstore $DB, "$path~";
959	rename "$path~", $path;	1932	rename "$path~", $path;
…		…
1010	local $/;	1983	local $/;
1011	*CFG = YAML::Syck::Load <$fh>;	1984	*CFG = YAML::Syck::Load <$fh>;
1012	}	1985	}
1013		1986
1014	sub main {	1987	sub main {
		1988	# we must not ever block the main coroutine
		1989	local $Coro::idle = sub {
		1990	Carp::cluck "FATAL: Coro::idle was called, major BUG, use cf::sync_job!\n";#d#
		1991	(Coro::unblock_sub {
		1992	Event::one_event;
		1993	})->();
		1994	};
		1995
1015	cfg_load;	1996	cfg_load;
1016	db_load;	1997	db_load;
1017	load_extensions;	1998	load_extensions;
1018	Event::loop;	1999	Event::loop;
1019	}	2000	}
1020		2001
1021	#############################################################################	2002	#############################################################################
1022	# initialisation	2003	# initialisation
1023		2004
1024	sub _perl_reload(&) {	2005	sub reload() {
1025	my ($msg) = @_;	2006	# can/must only be called in main
		2007	if ($Coro::current != $Coro::main) {
		2008	warn "can only reload from main coroutine\n";
		2009	return;
		2010	}
1026		2011
1027	$msg->("reloading...");	2012	warn "reloading...";
		2013
		2014	local $FREEZE = 1;
		2015	cf::emergency_save;
1028		2016
1029	eval {	2017	eval {
		2018	# if anything goes wrong in here, we should simply crash as we already saved
		2019
1030	# cancel all watchers	2020	# cancel all watchers
1031	for (Event::all_watchers) {	2021	for (Event::all_watchers) {
1032	$_->cancel if $_->data & WF_AUTOCANCEL;	2022	$_->cancel if $_->data & WF_AUTOCANCEL;
1033	}	2023	}
1034		2024
		2025	# cancel all extension coros
		2026	$_->cancel for values %EXT_CORO;
		2027	%EXT_CORO = ();
		2028
1035	# unload all extensions	2029	# unload all extensions
1036	for (@exts) {	2030	for (@exts) {
1037	$msg->("unloading <$_>");	2031	warn "unloading <$_>";
1038	unload_extension $_;	2032	unload_extension $_;
1039	}	2033	}
1040		2034
1041	# unload all modules loaded from $LIBDIR	2035	# unload all modules loaded from $LIBDIR
1042	while (my ($k, $v) = each %INC) {	2036	while (my ($k, $v) = each %INC) {
1043	next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;	2037	next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;
1044		2038
1045	$msg->("removing <$k>");	2039	warn "removing <$k>";
1046	delete $INC{$k};	2040	delete $INC{$k};
1047		2041
1048	$k =~ s/\.pm$//;	2042	$k =~ s/\.pm$//;
1049	$k =~ s/\//::/g;	2043	$k =~ s/\//::/g;
1050		2044
…		…
1055	Symbol::delete_package $k;	2049	Symbol::delete_package $k;
1056	}	2050	}
1057		2051
1058	# sync database to disk	2052	# sync database to disk
1059	cf::db_sync;	2053	cf::db_sync;
		2054	IO::AIO::flush;
1060		2055
1061	# get rid of safe::, as good as possible	2056	# get rid of safe::, as good as possible
1062	Symbol::delete_package "safe::$_"	2057	Symbol::delete_package "safe::$_"
1063	for qw(cf::object cf::object::player cf::player cf::map cf::party cf::region);	2058	for qw(cf::attachable cf::object cf::object::player cf::client cf::player cf::map cf::party cf::region);
1064		2059
1065	# remove register_script_function callbacks	2060	# remove register_script_function callbacks
1066	# TODO	2061	# TODO
1067		2062
1068	# unload cf.pm "a bit"	2063	# unload cf.pm "a bit"
…		…
1071	# don't, removes xs symbols, too,	2066	# don't, removes xs symbols, too,
1072	# and global variables created in xs	2067	# and global variables created in xs
1073	#Symbol::delete_package __PACKAGE__;	2068	#Symbol::delete_package __PACKAGE__;
1074		2069
1075	# reload cf.pm	2070	# reload cf.pm
1076	$msg->("reloading cf.pm");	2071	warn "reloading cf.pm";
1077	require cf;	2072	require cf;
		2073	cf::_connect_to_perl; # nominally unnecessary, but cannot hurt
1078		2074
1079	# load config and database again	2075	# load config and database again
1080	cf::cfg_load;	2076	cf::cfg_load;
1081	cf::db_load;	2077	cf::db_load;
1082		2078
1083	# load extensions	2079	# load extensions
1084	$msg->("load extensions");	2080	warn "load extensions";
1085	cf::load_extensions;	2081	cf::load_extensions;
1086		2082
1087	# reattach attachments to objects	2083	# reattach attachments to objects
1088	$msg->("reattach");	2084	warn "reattach";
1089	_global_reattach;	2085	_global_reattach;
1090	};	2086	};
1091	$msg->($@) if $@;
1092		2087
1093	$msg->("reloaded");	2088	if ($@) {
		2089	warn $@;
		2090	warn "error while reloading, exiting.";
		2091	exit 1;
		2092	}
		2093
		2094	warn "reloaded successfully";
1094	};	2095	};
1095		2096
1096	sub perl_reload() {	2097	#############################################################################
1097	_perl_reload {	2098
1098	warn $_[0];	2099	unless ($LINK_MAP) {
1099	print "$_[0]\n";	2100	$LINK_MAP = cf::map::new;
1100	};	2101
		2102	$LINK_MAP->width (41);
		2103	$LINK_MAP->height (41);
		2104	$LINK_MAP->alloc;
		2105	$LINK_MAP->path ("{link}");
		2106	$LINK_MAP->{path} = bless { path => "{link}" }, "cf::path";
		2107	$LINK_MAP->in_memory (MAP_IN_MEMORY);
		2108
		2109	# dirty hack because... archetypes are not yet loaded
		2110	Event->timer (
		2111	after => 2,
		2112	cb => sub {
		2113	$_[0]->w->cancel;
		2114
		2115	# provide some exits "home"
		2116	my $exit = cf::object::new "exit";
		2117
		2118	$exit->slaying ($EMERGENCY_POSITION->[0]);
		2119	$exit->stats->hp ($EMERGENCY_POSITION->[1]);
		2120	$exit->stats->sp ($EMERGENCY_POSITION->[2]);
		2121
		2122	$LINK_MAP->insert ($exit->clone, 19, 19);
		2123	$LINK_MAP->insert ($exit->clone, 19, 20);
		2124	$LINK_MAP->insert ($exit->clone, 19, 21);
		2125	$LINK_MAP->insert ($exit->clone, 20, 19);
		2126	$LINK_MAP->insert ($exit->clone, 20, 21);
		2127	$LINK_MAP->insert ($exit->clone, 21, 19);
		2128	$LINK_MAP->insert ($exit->clone, 21, 20);
		2129	$LINK_MAP->insert ($exit->clone, 21, 21);
		2130
		2131	$exit->destroy;
		2132	});
		2133
		2134	$LINK_MAP->{deny_save} = 1;
		2135	$LINK_MAP->{deny_reset} = 1;
		2136
		2137	$cf::MAP{$LINK_MAP->path} = $LINK_MAP;
1101	}	2138	}
1102		2139
1103	register "<global>", __PACKAGE__;	2140	register "<global>", __PACKAGE__;
1104		2141
1105	register_command "perl-reload" => sub {	2142	register_command "reload" => sub {
1106	my ($who, $arg) = @_;	2143	my ($who, $arg) = @_;
1107		2144
1108	if ($who->flag (FLAG_WIZ)) {	2145	if ($who->flag (FLAG_WIZ)) {
1109	_perl_reload {	2146	$who->message ("start of reload.");
1110	warn $_[0];	2147	reload;
1111	$who->message ($_[0]);	2148	$who->message ("end of reload.");
1112	};
1113	}	2149	}
1114	};	2150	};
1115		2151
1116	unshift @INC, $LIBDIR;	2152	unshift @INC, $LIBDIR;
1117		2153
1118	$TICK_WATCHER = Event->timer (	2154	$TICK_WATCHER = Event->timer (
		2155	reentrant => 0,
1119	prio => 0,	2156	prio => 0,
1120	at => $NEXT_TICK || 1,	2157	at => $NEXT_TICK || $TICK,
1121	data => WF_AUTOCANCEL,	2158	data => WF_AUTOCANCEL,
1122	cb => sub {	2159	cb => sub {
		2160	unless ($FREEZE) {
1123	cf::server_tick; # one server iteration	2161	cf::server_tick; # one server iteration
		2162	$RUNTIME += $TICK;
		2163	}
1124		2164
1125	my $NOW = Event::time;
1126	$NEXT_TICK += $TICK;	2165	$NEXT_TICK += $TICK;
1127		2166
1128	# if we are delayed by four ticks or more, skip them all	2167	# if we are delayed by four ticks or more, skip them all
1129	$NEXT_TICK = $NOW if $NOW >= $NEXT_TICK + $TICK * 4;	2168	$NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;
1130		2169
1131	$TICK_WATCHER->at ($NEXT_TICK);	2170	$TICK_WATCHER->at ($NEXT_TICK);
1132	$TICK_WATCHER->start;	2171	$TICK_WATCHER->start;
1133	},	2172	},
1134	);	2173	);
1135		2174
1136	IO::AIO::max_poll_time $TICK * 0.2;	2175	IO::AIO::max_poll_time $TICK * 0.2;
1137		2176
		2177	Event->io (
1138	Event->io (fd => IO::AIO::poll_fileno,	2178	fd => IO::AIO::poll_fileno,
1139	poll => 'r',	2179	poll => 'r',
1140	prio => 5,	2180	prio => 5,
1141	data => WF_AUTOCANCEL,	2181	data => WF_AUTOCANCEL,
1142	cb => \&IO::AIO::poll_cb);	2182	cb => \&IO::AIO::poll_cb,
		2183	);
		2184
		2185	Event->timer (
		2186	data => WF_AUTOCANCEL,
		2187	after => 0,
		2188	interval => 10,
		2189	cb => sub {
		2190	(Coro::unblock_sub {
		2191	write_runtime
		2192	or warn "ERROR: unable to write runtime file: $!";
		2193	})->();
		2194	},
		2195	);
		2196
		2197	END { cf::emergency_save }
1143		2198
1144	1	2199	1
1145		2200

Diff Legend

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