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.52 by root, Mon Aug 28 16:52:51 2006 UTC vs.
Revision 1.139 by root, Fri Jan 5 19:12:03 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;
		22	use IO::AIO 2.31 ();
		23	use YAML::Syck ();
10	use Time::HiRes;	24	use Time::HiRes;
11	use Event;	25
12	$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
13		27
14	use strict;	28	# work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode?
		29	$YAML::Syck::ImplicitUnicode = 1;
15		30
16	_reload_1;	31	$Coro::main->prio (Coro::PRIO_MAX); # run main coroutine ("the server") with very high priority
17		32
		33	sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload
		34
18	our %COMMAND = ();	35	our %COMMAND = ();
		36	our %COMMAND_TIME = ();
		37	our %EXTCMD = ();
		38
19	our @EVENT;	39	our @EVENT;
20	our %PROP_TYPE;	40	our $LIBDIR = datadir . "/ext";
21	our %PROP_IDX;
22	our $LIBDIR = maps_directory "perl";
23		41
24	our $TICK = MAX_TIME * 1e-6;	42	our $TICK = MAX_TIME * 1e-6;
25	our $TICK_WATCHER;	43	our $TICK_WATCHER;
26	our $NEXT_TICK;	44	our $NEXT_TICK;
		45	our $NOW;
		46
		47	our %CFG;
		48
		49	our $UPTIME; $UPTIME ||= time;
		50	our $RUNTIME;
		51
		52	our %MAP; # all maps
		53	our $LINK_MAP; # the special {link} map
		54	our $RANDOM_MAPS = cf::localdir . "/random";
		55	our %EXT_CORO;
		56
		57	binmode STDOUT;
		58	binmode STDERR;
		59
		60	# read virtual server time, if available
		61	unless ($RUNTIME || !-e cf::localdir . "/runtime") {
		62	open my $fh, "<", cf::localdir . "/runtime"
		63	or die "unable to read runtime file: $!";
		64	$RUNTIME = <$fh> + 0.;
		65	}
		66
		67	mkdir cf::localdir;
		68	mkdir cf::localdir . "/" . cf::playerdir;
		69	mkdir cf::localdir . "/" . cf::tmpdir;
		70	mkdir cf::localdir . "/" . cf::uniquedir;
		71	mkdir $RANDOM_MAPS;
		72
		73	# a special map that is always available
		74	our $LINK_MAP;
		75	our $EMERGENCY_POSITION;
		76
		77	#############################################################################
		78
		79	=head2 GLOBAL VARIABLES
		80
		81	=over 4
		82
		83	=item $cf::UPTIME
		84
		85	The timestamp of the server start (so not actually an uptime).
		86
		87	=item $cf::RUNTIME
		88
		89	The time this server has run, starts at 0 and is increased by $cf::TICK on
		90	every server tick.
		91
		92	=item $cf::LIBDIR
		93
		94	The perl library directory, where extensions and cf-specific modules can
		95	be found. It will be added to C<@INC> automatically.
		96
		97	=item $cf::NOW
		98
		99	The time of the last (current) server tick.
		100
		101	=item $cf::TICK
		102
		103	The interval between server ticks, in seconds.
		104
		105	=item %cf::CFG
		106
		107	Configuration for the server, loaded from C</etc/crossfire/config>, or
		108	from wherever your confdir points to.
		109
		110	=back
		111
		112	=cut
27		113
28	BEGIN {	114	BEGIN {
29	*CORE::GLOBAL::warn = sub {	115	*CORE::GLOBAL::warn = sub {
30	my $msg = join "", @_;	116	my $msg = join "", @_;
		117	utf8::encode $msg;
		118
31	$msg .= "\n"	119	$msg .= "\n"
32	unless $msg =~ /\n$/;	120	unless $msg =~ /\n$/;
33		121
34	print STDERR "cfperl: $msg";
35	LOG llevError, "cfperl: $msg";	122	LOG llevError, "cfperl: $msg";
36	};	123	};
37	}	124	}
38		125
39	my %ignore_set = (MAP_PROP_PATH => 1); # I hate the plug-in api. Deeply!	126	@safe::cf::global::ISA = @cf::global::ISA = 'cf::attachable';
40		127	@safe::cf::object::ISA = @cf::object::ISA = 'cf::attachable';
41	# generate property mutators	128	@safe::cf::player::ISA = @cf::player::ISA = 'cf::attachable';
42	sub prop_gen {	129	@safe::cf::client::ISA = @cf::client::ISA = 'cf::attachable';
43	my ($prefix, $class) = @_;	130	@safe::cf::map::ISA = @cf::map::ISA = 'cf::attachable';
44
45	no strict 'refs';
46
47	for my $prop (keys %PROP_TYPE) {
48	$prop =~ /^\Q$prefix\E_(.*$)/ or next;
49	my $sub = lc $1;
50
51	my $type = $PROP_TYPE{$prop};
52	my $idx = $PROP_IDX {$prop};
53
54	*{"$class\::get_$sub"} = *{"$class\::$sub"} = sub {
55	$_[0]->get_property ($type, $idx)
56	};
57
58	*{"$class\::set_$sub"} = sub {
59	$_[0]->set_property ($type, $idx, $_[1]);
60	} unless $ignore_set{$prop};
61	}
62	}
63
64	# auto-generate most of the API
65
66	prop_gen OBJECT_PROP => "cf::object";
67	# CFAPI_OBJECT_ANIMATION?
68	prop_gen PLAYER_PROP => "cf::object::player";
69
70	prop_gen MAP_PROP => "cf::map";
71	prop_gen ARCH_PROP => "cf::arch";
72
73	@safe::cf::object::player::ISA = @cf::object::player::ISA = 'cf::object';	131	@safe::cf::object::player::ISA = @cf::object::player::ISA = 'cf::object';
74		132
75	# we bless all objects into (empty) derived classes to force a method lookup	133	# we bless all objects into (empty) derived classes to force a method lookup
76	# within the Safe compartment.	134	# within the Safe compartment.
77	for my $pkg (qw(cf::object cf::object::player cf::player cf::map cf::party cf::region cf::arch cf::living)) {	135	for my $pkg (qw(
		136	cf::global cf::attachable
		137	cf::object cf::object::player
		138	cf::client cf::player
		139	cf::arch cf::living
		140	cf::map cf::party cf::region
		141	)) {
78	no strict 'refs';	142	no strict 'refs';
79	@{"safe::$pkg\::wrap::ISA"} = @{"$pkg\::wrap::ISA"} = $pkg;	143	@{"safe::$pkg\::wrap::ISA"} = @{"$pkg\::wrap::ISA"} = $pkg;
80	}	144	}
81		145
82	$Event::DIED = sub {	146	$Event::DIED = sub {
…		…
84	};	148	};
85		149
86	my %ext_pkg;	150	my %ext_pkg;
87	my @exts;	151	my @exts;
88	my @hook;	152	my @hook;
89	my %command;
90	my %extcmd;
91		153
92	#############################################################################	154	=head2 UTILITY FUNCTIONS
93	# utility functions	155
		156	=over 4
		157
		158	=cut
94		159
95	use JSON::Syck (); # TODO# replace by JSON::PC once working	160	use JSON::Syck (); # TODO# replace by JSON::PC once working
		161
		162	=item $ref = cf::from_json $json
		163
		164	Converts a JSON string into the corresponding perl data structure.
		165
		166	=cut
96		167
97	sub from_json($) {	168	sub from_json($) {
98	$JSON::Syck::ImplicitUnicode = 1; # work around JSON::Syck bugs	169	$JSON::Syck::ImplicitUnicode = 1; # work around JSON::Syck bugs
99	JSON::Syck::Load $_[0]	170	JSON::Syck::Load $_[0]
100	}	171	}
101		172
		173	=item $json = cf::to_json $ref
		174
		175	Converts a perl data structure into its JSON representation.
		176
		177	=cut
		178
102	sub to_json($) {	179	sub to_json($) {
103	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs	180	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs
104	JSON::Syck::Dump $_[0]	181	JSON::Syck::Dump $_[0]
105	}	182	}
106		183
		184	=item cf::lock_wait $string
		185
		186	Wait until the given lock is available. See cf::lock_acquire.
		187
		188	=item my $lock = cf::lock_acquire $string
		189
		190	Wait until the given lock is available and then acquires it and returns
		191	a Coro::guard object. If the guard object gets destroyed (goes out of scope,
		192	for example when the coroutine gets canceled), the lock is automatically
		193	returned.
		194
		195	Lock names should begin with a unique identifier (for example, cf::map::find
		196	uses map_find and cf::map::load uses map_load).
		197
		198	=cut
		199
		200	our %LOCK;
		201
		202	sub lock_wait($) {
		203	my ($key) = @_;
		204
		205	# wait for lock, if any
		206	while ($LOCK{$key}) {
		207	push @{ $LOCK{$key} }, $Coro::current;
		208	Coro::schedule;
		209	}
		210	}
		211
		212	sub lock_acquire($) {
		213	my ($key) = @_;
		214
		215	# wait, to be sure we are not locked
		216	lock_wait $key;
		217
		218	$LOCK{$key} = [];
		219
		220	Coro::guard {
		221	# wake up all waiters, to be on the safe side
		222	$_->ready for @{ delete $LOCK{$key} };
		223	}
		224	}
		225
		226	sub freeze_mainloop {
		227	return unless $TICK_WATCHER->is_active;
		228
		229	my $guard = Coro::guard { $TICK_WATCHER->start };
		230	$TICK_WATCHER->stop;
		231	$guard
		232	}
		233
		234	=item cf::sync_job { BLOCK }
		235
		236	The design of crossfire+ requires that the main coro ($Coro::main) is
		237	always able to handle events or runnable, as crossfire+ is only partly
		238	reentrant. Thus "blocking" it by e.g. waiting for I/O is not acceptable.
		239
		240	If it must be done, put the blocking parts into C<sync_job>. This will run
		241	the given BLOCK in another coroutine while waiting for the result. The
		242	server will be frozen during this time, so the block should either finish
		243	fast or be very important.
		244
		245	=cut
		246
		247	sub sync_job(&) {
		248	my ($job) = @_;
		249
		250	if ($Coro::current == $Coro::main) {
		251	# this is the main coro, too bad, we have to block
		252	# till the operation succeeds, freezing the server :/
		253
		254	# TODO: use suspend/resume instead
		255	# (but this is cancel-safe)
		256	my $freeze_guard = freeze_mainloop;
		257
		258	my $busy = 1;
		259	my @res;
		260
		261	(Coro::async_pool {
		262	@res = eval { $job->() };
		263	warn $@ if $@;
		264	undef $busy;
		265	})->prio (Coro::PRIO_MAX);
		266
		267	while ($busy) {
		268	unless (Coro::cede) {
		269	Coro::nready ? Event::one_event 0 : Event::one_event;
		270	Coro::cede_notself unless Coro::cede;
		271	}
		272	}
		273
		274	wantarray ? @res : $res[0]
		275	} else {
		276	# we are in another coroutine, how wonderful, everything just works
		277
		278	$job->()
		279	}
		280	}
		281
		282	=item $coro = cf::coro { BLOCK }
		283
		284	Creates (and readies) and returns a new coro. This coro is automcatially
		285	being canceled when the extension calling this is being unloaded.
		286
		287	=cut
		288
		289	sub coro(&) {
		290	my $cb = shift;
		291
		292	my $coro = &Coro::async_pool ($cb);
		293
		294	$coro->on_destroy (sub {
		295	delete $EXT_CORO{$coro+0};
		296	});
		297	$EXT_CORO{$coro+0} = $coro;
		298
		299	$coro
		300	}
		301
		302	sub write_runtime {
		303	my $runtime = cf::localdir . "/runtime";
		304
		305	my $fh = aio_open "$runtime~", O_WRONLY | O_CREAT, 0644
		306	or return;
		307
		308	my $value = $cf::RUNTIME + 1 + 10; # 10 is the runtime save interval, for a monotonic clock
		309	(aio_write $fh, 0, (length $value), $value, 0) <= 0
		310	and return;
		311
		312	aio_fsync $fh
		313	and return;
		314
		315	close $fh
		316	or return;
		317
		318	aio_rename "$runtime~", $runtime
		319	and return;
		320
		321	1
		322	}
		323
		324	=back
		325
		326	=cut
		327
107	#############################################################################	328	#############################################################################
108	# "new" plug-in system
109		329
		330	package cf::path;
		331
		332	sub new {
		333	my ($class, $path, $base) = @_;
		334
		335	$path = $path->as_string if ref $path;
		336
		337	my $self = bless { }, $class;
		338
		339	# {... are special paths that are not touched
		340	# ?xxx/... are special absolute paths
		341	# ?random/... random maps
		342	# /! non-realised random map exit
		343	# /... normal maps
		344	# ~/... per-player maps without a specific player (DO NOT USE)
		345	# ~user/... per-player map of a specific user
		346
		347	if ($path =~ /^{/) {
		348	# fine as it is
		349	} elsif ($path =~ s{^\?random/}{}) {
		350	Coro::AIO::aio_load "$cf::RANDOM_MAPS/$path.meta", my $data;
		351	$self->{random} = cf::from_json $data;
		352	} else {
		353	if ($path =~ s{^~([^/]+)?}{}) {
		354	$self->{user_rel} = 1;
		355
		356	if (defined $1) {
		357	$self->{user} = $1;
		358	} elsif ($base =~ m{^~([^/]+)/}) {
		359	$self->{user} = $1;
		360	} else {
		361	warn "cannot resolve user-relative path without user <$path,$base>\n";
		362	}
		363	} elsif ($path =~ /^\//) {
		364	# already absolute
		365	} else {
		366	$base =~ s{[^/]+/?$}{};
		367	return $class->new ("$base/$path");
		368	}
		369
		370	for ($path) {
		371	redo if s{/\.?/}{/};
		372	redo if s{/[^/]+/\.\./}{/};
		373	}
		374	}
		375
		376	$self->{path} = $path;
		377
		378	$self
		379	}
		380
		381	# the name / primary key / in-game path
		382	sub as_string {
		383	my ($self) = @_;
		384
		385	$self->{user_rel} ? "~$self->{user}$self->{path}"
		386	: $self->{random} ? "?random/$self->{path}"
		387	: $self->{path}
		388	}
		389
		390	# the displayed name, this is a one way mapping
		391	sub visible_name {
		392	my ($self) = @_;
		393
		394	# if (my $rmp = $self->{random}) {
		395	# # todo: be more intelligent about this
		396	# "?random/$rmp->{origin_map}+$rmp->{origin_x}+$rmp->{origin_y}/$rmp->{dungeon_level}"
		397	# } else {
		398	$self->as_string
		399	# }
		400	}
		401
		402	# escape the /'s in the path
		403	sub _escaped_path {
		404	# ∕ is U+2215
		405	(my $path = $_[0]{path}) =~ s/\//∕/g;
		406	$path
		407	}
		408
		409	# the original (read-only) location
		410	sub load_path {
		411	my ($self) = @_;
		412
		413	sprintf "%s/%s/%s", cf::datadir, cf::mapdir, $self->{path}
		414	}
		415
		416	# the temporary/swap location
		417	sub save_path {
		418	my ($self) = @_;
		419
		420	$self->{user_rel} ? sprintf "%s/%s/%s/%s", cf::localdir, cf::playerdir, $self->{user}, $self->_escaped_path
		421	: $self->{random} ? sprintf "%s/%s", $RANDOM_MAPS, $self->{path}
		422	: sprintf "%s/%s/%s", cf::localdir, cf::tmpdir, $self->_escaped_path
		423	}
		424
		425	# the unique path, might be eq to save_path
		426	sub uniq_path {
		427	my ($self) = @_;
		428
		429	$self->{user_rel} || $self->{random}
		430	? undef
		431	: sprintf "%s/%s/%s", cf::localdir, cf::uniquedir, $self->_escaped_path
		432	}
		433
		434	# return random map parameters, or undef
		435	sub random_map_params {
		436	my ($self) = @_;
		437
		438	$self->{random}
		439	}
		440
		441	# this is somewhat ugly, but style maps do need special treatment
		442	sub is_style_map {
		443	$_[0]{path} =~ m{^/styles/}
		444	}
		445
		446	package cf;
		447
		448	#############################################################################
		449
		450	=head2 ATTACHABLE OBJECTS
		451
		452	Many objects in crossfire are so-called attachable objects. That means you can
		453	attach callbacks/event handlers (a collection of which is called an "attachment")
		454	to it. All such attachable objects support the following methods.
		455
		456	In the following description, CLASS can be any of C<global>, C<object>
		457	C<player>, C<client> or C<map> (i.e. the attachable objects in
		458	crossfire+).
		459
		460	=over 4
		461
110	=item $object->attach ($attachment, key => $value...)	462	=item $attachable->attach ($attachment, key => $value...)
111		463
112	Attach a pre-registered attachment to an object.	464	=item $attachable->detach ($attachment)
113		465
114	=item $player->attach ($attachment, key => $value...)	466	Attach/detach a pre-registered attachment to a specific object and give it
		467	the specified key/value pairs as arguments.
115		468
116	Attach a pre-registered attachment to a player.	469	Example, attach a minesweeper attachment to the given object, making it a
		470	10x10 minesweeper game:
117		471
118	=item $map->attach ($attachment, key => $value...) # not yet persistent	472	$obj->attach (minesweeper => width => 10, height => 10);
119		473
120	Attach a pre-registered attachment to a map.	474	=item $bool = $attachable->attached ($name)
121		475
122	=item cf::attach_global ...	476	Checks wether the named attachment is currently attached to the object.
123		477
124	Attach handlers for global events.	478	=item cf::CLASS->attach ...
125		479
126	This and all following C<attach_*>-functions expect any number of the	480	=item cf::CLASS->detach ...
127	following handler/hook descriptions:	481
		482	Define an anonymous attachment and attach it to all objects of the given
		483	CLASS. See the next function for an explanation of its arguments.
		484
		485	You can attach to global events by using the C<cf::global> class.
		486
		487	Example, log all player logins:
		488
		489	cf::player->attach (
		490	on_login => sub {
		491	my ($pl) = @_;
		492	...
		493	},
		494	);
		495
		496	Example, attach to the jeweler skill:
		497
		498	cf::object->attach (
		499	type => cf::SKILL,
		500	subtype => cf::SK_JEWELER,
		501	on_use_skill => sub {
		502	my ($sk, $ob, $part, $dir, $msg) = @_;
		503	...
		504	},
		505	);
		506
		507	=item cf::CLASS::attachment $name, ...
		508
		509	Register an attachment by C<$name> through which attachable objects of the
		510	given CLASS can refer to this attachment.
		511
		512	Some classes such as crossfire maps and objects can specify attachments
		513	that are attached at load/instantiate time, thus the need for a name.
		514
		515	These calls expect any number of the following handler/hook descriptions:
128		516
129	=over 4	517	=over 4
130		518
131	=item prio => $number	519	=item prio => $number
132		520
…		…
134	by another C<prio> setting). Lower priority handlers get executed	522	by another C<prio> setting). Lower priority handlers get executed
135	earlier. The default priority is C<0>, and many built-in handlers are	523	earlier. The default priority is C<0>, and many built-in handlers are
136	registered at priority C<-1000>, so lower priorities should not be used	524	registered at priority C<-1000>, so lower priorities should not be used
137	unless you know what you are doing.	525	unless you know what you are doing.
138		526
		527	=item type => $type
		528
		529	(Only for C<< cf::object->attach >> calls), limits the attachment to the
		530	given type of objects only (the additional parameter C<subtype> can be
		531	used to further limit to the given subtype).
		532
139	=item on_I<event> => \&cb	533	=item on_I<event> => \&cb
140		534
141	Call the given code reference whenever the named event happens (event is	535	Call the given code reference whenever the named event happens (event is
142	something like C<instantiate>, C<apply>, C<use_skill> and so on, and which	536	something like C<instantiate>, C<apply>, C<use_skill> and so on, and which
143	handlers are recognised generally depends on the type of object these	537	handlers are recognised generally depends on the type of object these
…		…
152	package and register them. Only handlers for eevents supported by the	546	package and register them. Only handlers for eevents supported by the
153	object/class are recognised.	547	object/class are recognised.
154		548
155	=back	549	=back
156		550
157	=item cf::attach_to_type $object_type, $subtype, ...	551	Example, define an attachment called "sockpuppet" that calls the given
		552	event handler when a monster attacks:
158		553
159	Attach handlers for a specific object type (e.g. TRANSPORT) and	554	cf::object::attachment sockpuppet =>
160	subtype. If C<$subtype> is zero or undef, matches all objects of the given	555	on_skill_attack => sub {
161	type.	556	my ($self, $victim) = @_;
		557	...
		558	}
		559	}
162		560
163	=item cf::attach_to_objects ...	561	=item $attachable->valid
164		562
165	Attach handlers to all objects. Do not use this except for debugging or	563	Just because you have a perl object does not mean that the corresponding
166	very rare events, as handlers are (obviously) called for I<all> objects in	564	C-level object still exists. If you try to access an object that has no
167	the game.	565	valid C counterpart anymore you get an exception at runtime. This method
168		566	can be used to test for existence of the C object part without causing an
169	=item cf::attach_to_players ...	567	exception.
170
171	Attach handlers to all players.
172
173	=item cf::attach_to_maps ...
174
175	Attach handlers to all maps.
176
177	=item cf:register_attachment $name, ...
178
179	Register an attachment by name through which objects can refer to this
180	attachment.
181
182	=item cf:register_map_attachment $name, ...
183
184	Register an attachment by name through which maps can refer to this
185	attachment.
186		568
187	=cut	569	=cut
188		570
189	# the following variables are defined in .xs and must not be re-created	571	# the following variables are defined in .xs and must not be re-created
190	our @CB_GLOBAL = (); # registry for all global events	572	our @CB_GLOBAL = (); # registry for all global events
		573	our @CB_ATTACHABLE = (); # registry for all attachables
191	our @CB_OBJECT = (); # all objects (should not be used except in emergency)	574	our @CB_OBJECT = (); # all objects (should not be used except in emergency)
192	our @CB_PLAYER = ();	575	our @CB_PLAYER = ();
		576	our @CB_CLIENT = ();
193	our @CB_TYPE = (); # registry for type (cf-object class) based events	577	our @CB_TYPE = (); # registry for type (cf-object class) based events
194	our @CB_MAP = ();	578	our @CB_MAP = ();
195		579
196	my %attachment;	580	my %attachment;
197		581
198	sub _attach_cb($\%$$$) {	582	sub _attach_cb($$$$) {
199	my ($registry, $undo, $event, $prio, $cb) = @_;	583	my ($registry, $event, $prio, $cb) = @_;
200		584
201	use sort 'stable';	585	use sort 'stable';
202		586
203	$cb = [$prio, $cb];	587	$cb = [$prio, $cb];
204		588
205	@{$registry->[$event]} = sort	589	@{$registry->[$event]} = sort
206	{ $a->[0] cmp $b->[0] }	590	{ $a->[0] cmp $b->[0] }
207	@{$registry->[$event] || []}, $cb;	591	@{$registry->[$event] || []}, $cb;
208
209	push @{$undo->{cb}}, [$event, $cb];
210	}	592	}
		593
		594	# hack
		595	my %attachable_klass = map +($_ => 1), KLASS_OBJECT, KLASS_CLIENT, KLASS_PLAYER, KLASS_MAP;
211		596
212	# attach handles attaching event callbacks	597	# attach handles attaching event callbacks
213	# the only thing the caller has to do is pass the correct	598	# the only thing the caller has to do is pass the correct
214	# registry (== where the callback attaches to).	599	# registry (== where the callback attaches to).
215	sub _attach(\@$@) {	600	sub _attach {
216	my ($registry, $klass, @arg) = @_;	601	my ($registry, $klass, @arg) = @_;
217		602
		603	my $object_type;
218	my $prio = 0;	604	my $prio = 0;
219
220	my %undo = (
221	registry => $registry,
222	cb => [],
223	);
224
225	my %cb_id = map +("on_" . lc $EVENT[$_][0], $_) , grep $EVENT[$_][1] == $klass, 0 .. $#EVENT;	605	my %cb_id = map +("on_" . lc $EVENT[$_][0], $_) , grep $EVENT[$_][1] == $klass, 0 .. $#EVENT;
		606
		607	#TODO: get rid of this hack
		608	if ($attachable_klass{$klass}) {
		609	%cb_id = (%cb_id, map +("on_" . lc $EVENT[$_][0], $_) , grep $EVENT[$_][1] == KLASS_ATTACHABLE, 0 .. $#EVENT);
		610	}
226		611
227	while (@arg) {	612	while (@arg) {
228	my $type = shift @arg;	613	my $type = shift @arg;
229		614
230	if ($type eq "prio") {	615	if ($type eq "prio") {
231	$prio = shift @arg;	616	$prio = shift @arg;
232		617
		618	} elsif ($type eq "type") {
		619	$object_type = shift @arg;
		620	$registry = $CB_TYPE[$object_type] ||= [];
		621
		622	} elsif ($type eq "subtype") {
		623	defined $object_type or Carp::croak "subtype specified without type";
		624	my $object_subtype = shift @arg;
		625	$registry = $CB_TYPE[$object_type + $object_subtype * NUM_SUBTYPES] ||= [];
		626
233	} elsif ($type eq "package") {	627	} elsif ($type eq "package") {
234	my $pkg = shift @arg;	628	my $pkg = shift @arg;
235		629
236	while (my ($name, $id) = each %cb_id) {	630	while (my ($name, $id) = each %cb_id) {
237	if (my $cb = $pkg->can ($name)) {	631	if (my $cb = $pkg->can ($name)) {
238	_attach_cb $registry, %undo, $id, $prio, $cb;	632	_attach_cb $registry, $id, $prio, $cb;
239	}	633	}
240	}	634	}
241		635
242	} elsif (exists $cb_id{$type}) {	636	} elsif (exists $cb_id{$type}) {
243	_attach_cb $registry, %undo, $cb_id{$type}, $prio, shift @arg;	637	_attach_cb $registry, $cb_id{$type}, $prio, shift @arg;
244		638
245	} elsif (ref $type) {	639	} elsif (ref $type) {
246	warn "attaching objects not supported, ignoring.\n";	640	warn "attaching objects not supported, ignoring.\n";
247		641
248	} else {	642	} else {
249	shift @arg;	643	shift @arg;
250	warn "attach argument '$type' not supported, ignoring.\n";	644	warn "attach argument '$type' not supported, ignoring.\n";
251	}	645	}
252	}	646	}
253
254	\%undo
255	}	647	}
256		648
257	sub _attach_attachment {	649	sub _object_attach {
258	my ($obj, $name, %arg) = @_;	650	my ($obj, $name, %arg) = @_;
259		651
260	my $res;	652	return if exists $obj->{_attachment}{$name};
261		653
262	if (my $attach = $attachment{$name}) {	654	if (my $attach = $attachment{$name}) {
263	my $registry = $obj->registry;	655	my $registry = $obj->registry;
264		656
265	for (@$attach) {	657	for (@$attach) {
266	my ($klass, @attach) = @$_;	658	my ($klass, @attach) = @$_;
267	$res = _attach @$registry, $klass, @attach;	659	_attach $registry, $klass, @attach;
268	}	660	}
269		661
270	$obj->{$name} = \%arg;	662	$obj->{$name} = \%arg;
271	} else {	663	} else {
272	warn "object uses attachment '$name' that is not available, postponing.\n";	664	warn "object uses attachment '$name' that is not available, postponing.\n";
273	}	665	}
274		666
275	$obj->{_attachment}{$name} = undef;	667	$obj->{_attachment}{$name} = undef;
276
277	$res->{attachment} = $name;
278	$res
279	}	668	}
280		669
281	sub cf::object::attach {	670	sub cf::attachable::attach {
		671	if (ref $_[0]) {
		672	_object_attach @_;
		673	} else {
		674	_attach shift->_attach_registry, @_;
		675	}
		676	};
		677
		678	# all those should be optimised
		679	sub cf::attachable::detach {
282	my ($obj, $name, %arg) = @_;	680	my ($obj, $name) = @_;
283		681
284	_attach_attachment $obj, $name, %arg;	682	if (ref $obj) {
285	}	683	delete $obj->{_attachment}{$name};
		684	reattach ($obj);
		685	} else {
		686	Carp::croak "cannot, currently, detach class attachments";
		687	}
		688	};
286		689
287	sub cf::player::attach {	690	sub cf::attachable::attached {
288	my ($obj, $name, %arg) = @_;	691	my ($obj, $name) = @_;
289		692
290	_attach_attachment $obj, $name, %arg;	693	exists $obj->{_attachment}{$name}
291	}	694	}
292		695
293	sub cf::map::attach {	696	for my $klass (qw(ATTACHABLE GLOBAL OBJECT PLAYER CLIENT MAP)) {
294	my ($obj, $name, %arg) = @_;	697	eval "#line " . __LINE__ . " 'cf.pm'
		698	sub cf::\L$klass\E::_attach_registry {
		699	(\\\@CB_$klass, KLASS_$klass)
		700	}
295		701
296	_attach_attachment $obj, $name, %arg;	702	sub cf::\L$klass\E::attachment {
297	}
298
299	sub attach_global {
300	_attach @CB_GLOBAL, KLASS_GLOBAL, @_
301	}
302
303	sub attach_to_type {
304	my $type = shift;
305	my $subtype = shift;
306
307	_attach @{$CB_TYPE[$type + $subtype * NUM_SUBTYPES]}, KLASS_OBJECT, @_
308	}
309
310	sub attach_to_objects {
311	_attach @CB_OBJECT, KLASS_OBJECT, @_
312	}
313
314	sub attach_to_players {
315	_attach @CB_PLAYER, KLASS_PLAYER, @_
316	}
317
318	sub attach_to_maps {
319	_attach @CB_MAP, KLASS_MAP, @_
320	}
321
322	sub register_attachment {
323	my $name = shift;	703	my \$name = shift;
324		704
325	$attachment{$name} = [[KLASS_OBJECT, @_]];
326	}
327
328	sub register_map_attachment {
329	my $name = shift;
330
331	$attachment{$name} = [[KLASS_MAP, @_]];	705	\$attachment{\$name} = [[KLASS_$klass, \@_]];
		706	}
		707	";
		708	die if $@;
332	}	709	}
333		710
334	our $override;	711	our $override;
335	our @invoke_results = (); # referenced from .xs code. TODO: play tricks with reify and mortals?	712	our @invoke_results = (); # referenced from .xs code. TODO: play tricks with reify and mortals?
336		713
…		…
350	for (@$callbacks) {	727	for (@$callbacks) {
351	eval { &{$_->[1]} };	728	eval { &{$_->[1]} };
352		729
353	if ($@) {	730	if ($@) {
354	warn "$@";	731	warn "$@";
355	warn "... while processing $EVENT[$event][0] event, skipping processing altogether.\n";	732	warn "... while processing $EVENT[$event][0](@_) event, skipping processing altogether.\n";
356	override;	733	override;
357	}	734	}
358		735
359	return 1 if $override;	736	return 1 if $override;
360	}	737	}
361		738
362	0	739	0
363	}	740	}
		741
		742	=item $bool = cf::global::invoke (EVENT_CLASS_XXX, ...)
		743
		744	=item $bool = $attachable->invoke (EVENT_CLASS_XXX, ...)
		745
		746	Generate an object-specific event with the given arguments.
		747
		748	This API is preliminary (most likely, the EVENT_CLASS_xxx prefix will be
		749	removed in future versions), and there is no public API to access override
		750	results (if you must, access C<@cf::invoke_results> directly).
		751
		752	=back
		753
		754	=cut
364		755
365	#############################################################################	756	#############################################################################
366	# object support	757	# object support
367		758
368	sub instantiate {
369	my ($obj, $data) = @_;
370
371	$data = from_json $data;
372
373	for (@$data) {
374	my ($name, $args) = @$_;
375
376	$obj->attach ($name, %{$args || {} });
377	}
378	}
379
380	# basically do the same as instantiate, without calling instantiate
381	sub reattach {	759	sub reattach {
		760	# basically do the same as instantiate, without calling instantiate
382	my ($obj) = @_;	761	my ($obj) = @_;
		762
383	my $registry = $obj->registry;	763	my $registry = $obj->registry;
384		764
385	@$registry = ();	765	@$registry = ();
386		766
387	delete $obj->{_attachment} unless scalar keys %{ $obj->{_attachment} || {} };	767	delete $obj->{_attachment} unless scalar keys %{ $obj->{_attachment} || {} };
388		768
389	for my $name (keys %{ $obj->{_attachment} || {} }) {	769	for my $name (keys %{ $obj->{_attachment} || {} }) {
390	if (my $attach = $attachment{$name}) {	770	if (my $attach = $attachment{$name}) {
391	for (@$attach) {	771	for (@$attach) {
392	my ($klass, @attach) = @$_;	772	my ($klass, @attach) = @$_;
393	_attach @$registry, $klass, @attach;	773	_attach $registry, $klass, @attach;
394	}	774	}
395	} else {	775	} else {
396	warn "object uses attachment '$name' that is not available, postponing.\n";	776	warn "object uses attachment '$name' that is not available, postponing.\n";
397	}	777	}
398	}	778	}
399	}	779	}
400		780
401	sub object_freezer_save {	781	cf::attachable->attach (
402	my ($filename, $objs) = @_;
403
404	if (@$objs) {
405	open my $fh, ">:raw", "$filename.pst~";
406	syswrite $fh, Storable::nfreeze { version => 1, objs => $objs };
407	close $fh;
408	chmod SAVE_MODE, "$filename.pst~";
409	rename "$filename.pst~", "$filename.pst";
410	} else {
411	unlink "$filename.pst";
412	}
413
414	chmod SAVE_MODE, "$filename~";
415	rename "$filename~", $filename;
416	}
417
418	sub object_thawer_load {
419	my ($filename) = @_;
420
421	open my $fh, "<:raw:perlio", "$filename.pst"
422	or return;
423
424	eval { local $/; (Storable::thaw <$fh>)->{objs} }
425	}
426
427	attach_to_objects
428	prio => -1000000,	782	prio => -1000000,
		783	on_instantiate => sub {
		784	my ($obj, $data) = @_;
		785
		786	$data = from_json $data;
		787
		788	for (@$data) {
		789	my ($name, $args) = @$_;
		790
		791	$obj->attach ($name, %{$args || {} });
		792	}
		793	},
		794	on_reattach => \&reattach,
429	on_clone => sub {	795	on_clone => sub {
430	my ($src, $dst) = @_;	796	my ($src, $dst) = @_;
431		797
432	@{$dst->registry} = @{$src->registry};	798	@{$dst->registry} = @{$src->registry};
433		799
434	%$dst = %$src;	800	%$dst = %$src;
435		801
436	%{$dst->{_attachment}} = %{$src->{_attachment}}	802	%{$dst->{_attachment}} = %{$src->{_attachment}}
437	if exists $src->{_attachment};	803	if exists $src->{_attachment};
438	},	804	},
439	;	805	);
		806
		807	sub object_freezer_save {
		808	my ($filename, $rdata, $objs) = @_;
		809
		810	sync_job {
		811	if (length $$rdata) {
		812	warn sprintf "saving %s (%d,%d)\n",
		813	$filename, length $$rdata, scalar @$objs;
		814
		815	if (my $fh = aio_open "$filename~", O_WRONLY | O_CREAT, 0600) {
		816	chmod SAVE_MODE, $fh;
		817	aio_write $fh, 0, (length $$rdata), $$rdata, 0;
		818	aio_fsync $fh;
		819	close $fh;
		820
		821	if (@$objs) {
		822	if (my $fh = aio_open "$filename.pst~", O_WRONLY | O_CREAT, 0600) {
		823	chmod SAVE_MODE, $fh;
		824	my $data = Storable::nfreeze { version => 1, objs => $objs };
		825	aio_write $fh, 0, (length $data), $data, 0;
		826	aio_fsync $fh;
		827	close $fh;
		828	aio_rename "$filename.pst~", "$filename.pst";
		829	}
		830	} else {
		831	aio_unlink "$filename.pst";
		832	}
		833
		834	aio_rename "$filename~", $filename;
		835	} else {
		836	warn "FATAL: $filename~: $!\n";
		837	}
		838	} else {
		839	aio_unlink $filename;
		840	aio_unlink "$filename.pst";
		841	}
		842	}
		843	}
		844
		845	sub object_freezer_as_string {
		846	my ($rdata, $objs) = @_;
		847
		848	use Data::Dumper;
		849
		850	$$rdata . Dumper $objs
		851	}
		852
		853	sub object_thawer_load {
		854	my ($filename) = @_;
		855
		856	my ($data, $av);
		857
		858	(aio_load $filename, $data) >= 0
		859	or return;
		860
		861	unless (aio_stat "$filename.pst") {
		862	(aio_load "$filename.pst", $av) >= 0
		863	or return;
		864	$av = eval { (Storable::thaw $av)->{objs} };
		865	}
		866
		867	warn sprintf "loading %s (%d)\n",
		868	$filename, length $data, scalar @{$av || []};#d#
		869	return ($data, $av);
		870	}
440		871
441	#############################################################################	872	#############################################################################
442	# old plug-in events	873	# command handling &c
443		874
444	sub inject_event {	875	=item cf::register_command $name => \&callback($ob,$args);
445	my $extension = shift;
446	my $event_code = shift;
447		876
448	my $cb = $hook[$event_code]{$extension}	877	Register a callback for execution when the client sends the user command
449	or return;	878	$name.
450		879
451	&$cb	880	=cut
452	}
453
454	sub inject_global_event {
455	my $event = shift;
456
457	my $cb = $hook[$event]
458	or return;
459
460	List::Util::max map &$_, values %$cb
461	}
462
463	sub inject_command {
464	my ($name, $obj, $params) = @_;
465
466	for my $cmd (@{ $command{$name} }) {
467	$cmd->[1]->($obj, $params);
468	}
469
470	-1
471	}
472		881
473	sub register_command {	882	sub register_command {
474	my ($name, $time, $cb) = @_;	883	my ($name, $cb) = @_;
475		884
476	my $caller = caller;	885	my $caller = caller;
477	#warn "registering command '$name/$time' to '$caller'";	886	#warn "registering command '$name/$time' to '$caller'";
478		887
479	push @{ $command{$name} }, [$time, $cb, $caller];	888	push @{ $COMMAND{$name} }, [$caller, $cb];
480	$COMMAND{"$name\000"} = List::Util::max map $_->[0], @{ $command{$name} };
481	}	889	}
		890
		891	=item cf::register_extcmd $name => \&callback($pl,$packet);
		892
		893	Register a callbackf ro execution when the client sends an extcmd packet.
		894
		895	If the callback returns something, it is sent back as if reply was being
		896	called.
		897
		898	=cut
482		899
483	sub register_extcmd {	900	sub register_extcmd {
484	my ($name, $cb) = @_;	901	my ($name, $cb) = @_;
485		902
486	my $caller = caller;	903	my $caller = caller;
487	#warn "registering extcmd '$name' to '$caller'";	904	#warn "registering extcmd '$name' to '$caller'";
488		905
489	$extcmd{$name} = [$cb, $caller];	906	$EXTCMD{$name} = [$cb, $caller];
490	}	907	}
		908
		909	cf::player->attach (
		910	on_command => sub {
		911	my ($pl, $name, $params) = @_;
		912
		913	my $cb = $COMMAND{$name}
		914	or return;
		915
		916	for my $cmd (@$cb) {
		917	$cmd->[1]->($pl->ob, $params);
		918	}
		919
		920	cf::override;
		921	},
		922	on_extcmd => sub {
		923	my ($pl, $buf) = @_;
		924
		925	my $msg = eval { from_json $buf };
		926
		927	if (ref $msg) {
		928	if (my $cb = $EXTCMD{$msg->{msgtype}}) {
		929	if (my %reply = $cb->[0]->($pl, $msg)) {
		930	$pl->ext_reply ($msg->{msgid}, %reply);
		931	}
		932	}
		933	} else {
		934	warn "player " . ($pl->ob->name) . " sent unparseable ext message: <$buf>\n";
		935	}
		936
		937	cf::override;
		938	},
		939	);
491		940
492	sub register {	941	sub register {
493	my ($base, $pkg) = @_;	942	my ($base, $pkg) = @_;
494		943
495	#TODO	944	#TODO
…		…
514	. "#line 1 \"$path\"\n{\n"	963	. "#line 1 \"$path\"\n{\n"
515	. (do { local $/; <$fh> })	964	. (do { local $/; <$fh> })
516	. "\n};\n1";	965	. "\n};\n1";
517		966
518	eval $source	967	eval $source
519	or die "$path: $@";	968	or die $@ ? "$path: $@\n"
		969	: "extension disabled.\n";
520		970
521	push @exts, $pkg;	971	push @exts, $pkg;
522	$ext_pkg{$base} = $pkg;	972	$ext_pkg{$base} = $pkg;
523		973
524	# no strict 'refs';	974	# no strict 'refs';
…		…
537	# for my $idx (0 .. $#PLUGIN_EVENT) {	987	# for my $idx (0 .. $#PLUGIN_EVENT) {
538	# delete $hook[$idx]{$pkg};	988	# delete $hook[$idx]{$pkg};
539	# }	989	# }
540		990
541	# remove commands	991	# remove commands
542	for my $name (keys %command) {	992	for my $name (keys %COMMAND) {
543	my @cb = grep $_->[2] ne $pkg, @{ $command{$name} };	993	my @cb = grep $_->[0] ne $pkg, @{ $COMMAND{$name} };
544		994
545	if (@cb) {	995	if (@cb) {
546	$command{$name} = \@cb;	996	$COMMAND{$name} = \@cb;
547	$COMMAND{"$name\000"} = List::Util::max map $_->[0], @cb;
548	} else {	997	} else {
549	delete $command{$name};
550	delete $COMMAND{"$name\000"};	998	delete $COMMAND{$name};
551	}	999	}
552	}	1000	}
553		1001
554	# remove extcmds	1002	# remove extcmds
555	for my $name (grep $extcmd{$_}[1] eq $pkg, keys %extcmd) {	1003	for my $name (grep $EXTCMD{$_}[1] eq $pkg, keys %EXTCMD) {
556	delete $extcmd{$name};	1004	delete $EXTCMD{$name};
557	}	1005	}
558		1006
559	if (my $cb = $pkg->can ("unload")) {	1007	if (my $cb = $pkg->can ("unload")) {
560	eval {	1008	eval {
561	$cb->($pkg);	1009	$cb->($pkg);
…		…
565		1013
566	Symbol::delete_package $pkg;	1014	Symbol::delete_package $pkg;
567	}	1015	}
568		1016
569	sub load_extensions {	1017	sub load_extensions {
570	my $LIBDIR = maps_directory "perl";
571
572	for my $ext (<$LIBDIR/*.ext>) {	1018	for my $ext (<$LIBDIR/*.ext>) {
573	next unless -r $ext;	1019	next unless -r $ext;
574	eval {	1020	eval {
575	load_extension $ext;	1021	load_extension $ext;
576	1	1022	1
577	} or warn "$ext not loaded: $@";	1023	} or warn "$ext not loaded: $@";
578	}	1024	}
579	}	1025	}
580		1026
581	sub _perl_reload(&) {
582	my ($msg) = @_;
583
584	$msg->("reloading...");
585
586	eval {
587	# 1. cancel all watchers
588	$_->cancel for Event::all_watchers;
589
590	# 2. unload all extensions
591	for (@exts) {
592	$msg->("unloading <$_>");
593	unload_extension $_;
594	}
595
596	# 3. unload all modules loaded from $LIBDIR
597	while (my ($k, $v) = each %INC) {
598	next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;
599
600	$msg->("removing <$k>");
601	delete $INC{$k};
602
603	$k =~ s/\.pm$//;
604	$k =~ s/\//::/g;
605
606	if (my $cb = $k->can ("unload_module")) {
607	$cb->();
608	}
609
610	Symbol::delete_package $k;
611	}
612
613	# 4. get rid of safe::, as good as possible
614	Symbol::delete_package "safe::$_"
615	for qw(cf::object cf::object::player cf::player cf::map cf::party cf::region);
616
617	# 5. remove register_script_function callbacks
618	# TODO
619
620	# 6. unload cf.pm "a bit"
621	delete $INC{"cf.pm"};
622
623	# don't, removes xs symbols, too,
624	# and global variables created in xs
625	#Symbol::delete_package __PACKAGE__;
626
627	# 7. reload cf.pm
628	$msg->("reloading cf.pm");
629	require cf;
630	};
631	$msg->($@) if $@;
632
633	$msg->("reloaded");
634	};
635
636	sub perl_reload() {
637	_perl_reload {
638	warn $_[0];
639	print "$_[0]\n";
640	};
641	}
642
643	register_command "perl-reload", 0, sub {
644	my ($who, $arg) = @_;
645
646	if ($who->flag (FLAG_WIZ)) {
647	_perl_reload {
648	warn $_[0];
649	$who->message ($_[0]);
650	};
651	}
652	};
653
654	#############################################################################
655	# extcmd framework, basically convert ext <msg>
656	# into pkg::->on_extcmd_arg1 (...) while shortcutting a few
657
658	attach_to_players
659	on_extcmd => sub {
660	my ($pl, $buf) = @_;
661
662	my $msg = eval { from_json $buf };
663
664	if (ref $msg) {
665	if (my $cb = $extcmd{$msg->{msgtype}}) {
666	if (my %reply = $cb->[0]->($pl, $msg)) {
667	$pl->ext_reply ($msg->{msgid}, %reply);
668	}
669	}
670	} else {
671	warn "player " . ($pl->ob->name) . " sent unparseable ext message: <$buf>\n";
672	}
673
674	cf::override;
675	},
676	;
677
678	#############################################################################	1027	#############################################################################
679	# load/save/clean perl data associated with a map	1028	# load/save/clean perl data associated with a map
680		1029
681	*cf::mapsupport::on_clean = sub {	1030	*cf::mapsupport::on_clean = sub {
682	my ($map) = @_;	1031	my ($map) = @_;
…		…
685	defined $path or return;	1034	defined $path or return;
686		1035
687	unlink "$path.pst";	1036	unlink "$path.pst";
688	};	1037	};
689		1038
690	# old style persistent data, TODO: remove #d#
691	*cf::mapsupport::on_swapin =
692	*cf::mapsupport::on_load = sub {
693	my ($map) = @_;
694
695	my $path = $map->tmpname;
696	$path = $map->path unless defined $path;
697
698	open my $fh, "<:raw", "$path.cfperl"
699	or return; # no perl data
700
701	my $data = Storable::thaw do { local $/; <$fh> };
702
703	$data->{version} <= 1
704	or return; # too new
705
706	$map->_set_obs ($data->{obs});
707	$map->invoke (EVENT_MAP_UPGRADE);
708	};
709
710	attach_to_maps prio => -10000, package => cf::mapsupport::;	1039	cf::map->attach (prio => -10000, package => cf::mapsupport::);
711		1040
712	#############################################################################	1041	#############################################################################
713	# load/save perl data associated with player->ob objects	1042	# load/save perl data associated with player->ob objects
714		1043
715	sub all_objects(@) {	1044	sub all_objects(@) {
716	@_, map all_objects ($_->inv), @_	1045	@_, map all_objects ($_->inv), @_
717	}	1046	}
718		1047
719	attach_to_players	1048	# TODO: compatibility cruft, remove when no longer needed
		1049	cf::player->attach (
720	on_load => sub {	1050	on_load => sub {
721	my ($pl, $path) = @_;	1051	my ($pl, $path) = @_;
722		1052
723	for my $o (all_objects $pl->ob) {	1053	for my $o (all_objects $pl->ob) {
724	if (my $value = $o->get_ob_key_value ("_perl_data")) {	1054	if (my $value = $o->get_ob_key_value ("_perl_data")) {
…		…
726		1056
727	%$o = %{ Storable::thaw pack "H*", $value };	1057	%$o = %{ Storable::thaw pack "H*", $value };
728	}	1058	}
729	}	1059	}
730	},	1060	},
731	;	1061	);
732		1062
733	#############################################################################	1063	#############################################################################
734	# core extensions - in perl	1064
		1065	=head2 CORE EXTENSIONS
		1066
		1067	Functions and methods that extend core crossfire objects.
		1068
		1069	=head3 cf::player
		1070
		1071	=over 4
735		1072
736	=item cf::player::exists $login	1073	=item cf::player::exists $login
737		1074
738	Returns true when the given account exists.	1075	Returns true when the given account exists.
739		1076
…		…
742	sub cf::player::exists($) {	1079	sub cf::player::exists($) {
743	cf::player::find $_[0]	1080	cf::player::find $_[0]
744	or -f sprintf "%s/%s/%s/%s.pl", cf::localdir, cf::playerdir, ($_[0]) x 2;	1081	or -f sprintf "%s/%s/%s/%s.pl", cf::localdir, cf::playerdir, ($_[0]) x 2;
745	}	1082	}
746		1083
		1084	=item $player->ext_reply ($msgid, $msgtype, %msg)
		1085
		1086	Sends an ext reply to the player.
		1087
		1088	=cut
		1089
		1090	sub cf::player::ext_reply($$$%) {
		1091	my ($self, $id, %msg) = @_;
		1092
		1093	$msg{msgid} = $id;
		1094
		1095	$self->send ("ext " . to_json \%msg);
		1096	}
		1097
		1098	=back
		1099
		1100
		1101	=head3 cf::map
		1102
		1103	=over 4
		1104
		1105	=cut
		1106
		1107	package cf::map;
		1108
		1109	use Fcntl;
		1110	use Coro::AIO;
		1111
		1112	our $MAX_RESET = 3600;
		1113	our $DEFAULT_RESET = 3000;
		1114
		1115	sub generate_random_map {
		1116	my ($path, $rmp) = @_;
		1117
		1118	# mit "rum" bekleckern, nicht
		1119	cf::map::_create_random_map
		1120	$path,
		1121	$rmp->{wallstyle}, $rmp->{wall_name}, $rmp->{floorstyle}, $rmp->{monsterstyle},
		1122	$rmp->{treasurestyle}, $rmp->{layoutstyle}, $rmp->{doorstyle}, $rmp->{decorstyle},
		1123	$rmp->{origin_map}, $rmp->{final_map}, $rmp->{exitstyle}, $rmp->{this_map},
		1124	$rmp->{exit_on_final_map},
		1125	$rmp->{xsize}, $rmp->{ysize},
		1126	$rmp->{expand2x}, $rmp->{layoutoptions1}, $rmp->{layoutoptions2}, $rmp->{layoutoptions3},
		1127	$rmp->{symmetry}, $rmp->{difficulty}, $rmp->{difficulty_given}, $rmp->{difficulty_increase},
		1128	$rmp->{dungeon_level}, $rmp->{dungeon_depth}, $rmp->{decoroptions}, $rmp->{orientation},
		1129	$rmp->{origin_y}, $rmp->{origin_x}, $rmp->{random_seed}, $rmp->{total_map_hp},
		1130	$rmp->{map_layout_style}, $rmp->{treasureoptions}, $rmp->{symmetry_used},
		1131	(cf::region::find $rmp->{region})
		1132	}
		1133
		1134	# and all this just because we cannot iterate over
		1135	# all maps in C++...
		1136	sub change_all_map_light {
		1137	my ($change) = @_;
		1138
		1139	$_->change_map_light ($change)
		1140	for grep $_->outdoor, values %cf::MAP;
		1141	}
		1142
		1143	sub try_load_header($) {
		1144	my ($path) = @_;
		1145
		1146	utf8::encode $path;
		1147	aio_open $path, O_RDONLY, 0
		1148	or return;
		1149
		1150	my $map = cf::map::new
		1151	or return;
		1152
		1153	# for better error messages only, will be overwritten
		1154	$map->path ($path);
		1155
		1156	$map->load_header ($path)
		1157	or return;
		1158
		1159	$map->{load_path} = $path;
		1160
		1161	$map
		1162	}
		1163
		1164	sub find;
		1165	sub find {
		1166	my ($path, $origin) = @_;
		1167
		1168	#warn "find<$path,$origin>\n";#d#
		1169
		1170	$path = new cf::path $path, $origin && $origin->path;
		1171	my $key = $path->as_string;
		1172
		1173	cf::lock_wait "map_find:$key";
		1174
		1175	$cf::MAP{$key} || do {
		1176	my $guard = cf::lock_acquire "map_find:$key";
		1177
		1178	# do it the slow way
		1179	my $map = try_load_header $path->save_path;
		1180
		1181	Coro::cede;
		1182
		1183	if ($map) {
		1184	$map->last_access ((delete $map->{last_access})
		1185	|| $cf::RUNTIME); #d#
		1186	# safety
		1187	$map->{instantiate_time} = $cf::RUNTIME
		1188	if $map->{instantiate_time} > $cf::RUNTIME;
		1189	} else {
		1190	if (my $rmp = $path->random_map_params) {
		1191	$map = generate_random_map $key, $rmp;
		1192	} else {
		1193	$map = try_load_header $path->load_path;
		1194	}
		1195
		1196	$map or return;
		1197
		1198	$map->{load_original} = 1;
		1199	$map->{instantiate_time} = $cf::RUNTIME;
		1200	$map->last_access ($cf::RUNTIME);
		1201	$map->instantiate;
		1202
		1203	# per-player maps become, after loading, normal maps
		1204	$map->per_player (0) if $path->{user_rel};
		1205	}
		1206
		1207	$map->path ($key);
		1208	$map->{path} = $path;
		1209	$map->{last_save} = $cf::RUNTIME;
		1210
		1211	Coro::cede;
		1212
		1213	if ($map->should_reset) {
		1214	$map->reset;
		1215	undef $guard;
		1216	$map = find $path
		1217	or return;
		1218	}
		1219
		1220	$cf::MAP{$key} = $map
		1221	}
		1222	}
		1223
		1224	sub load {
		1225	my ($self) = @_;
		1226
		1227	my $path = $self->{path};
		1228	my $guard = cf::lock_acquire "map_load:" . $path->as_string;
		1229
		1230	return if $self->in_memory != cf::MAP_SWAPPED;
		1231
		1232	$self->in_memory (cf::MAP_LOADING);
		1233
		1234	$self->alloc;
		1235	$self->load_objects ($self->{load_path}, 1)
		1236	or return;
		1237
		1238	$self->set_object_flag (cf::FLAG_OBJ_ORIGINAL, 1)
		1239	if delete $self->{load_original};
		1240
		1241	if (my $uniq = $path->uniq_path) {
		1242	utf8::encode $uniq;
		1243	if (aio_open $uniq, O_RDONLY, 0) {
		1244	$self->clear_unique_items;
		1245	$self->load_objects ($uniq, 0);
		1246	}
		1247	}
		1248
		1249	Coro::cede;
		1250
		1251	# now do the right thing for maps
		1252	$self->link_multipart_objects;
		1253
		1254	if ($self->{path}->is_style_map) {
		1255	$self->{deny_save} = 1;
		1256	$self->{deny_reset} = 1;
		1257	} else {
		1258	$self->fix_auto_apply;
		1259	$self->decay_objects;
		1260	$self->update_buttons;
		1261	$self->set_darkness_map;
		1262	$self->difficulty ($self->estimate_difficulty)
		1263	unless $self->difficulty;
		1264	$self->activate;
		1265	}
		1266
		1267	Coro::cede;
		1268
		1269	$self->in_memory (cf::MAP_IN_MEMORY);
		1270	}
		1271
		1272	sub find_sync {
		1273	my ($path, $origin) = @_;
		1274
		1275	cf::sync_job {
		1276	my $map = cf::map::find $path, $origin;
		1277	$map
		1278	}
		1279	}
		1280
		1281	sub do_load_sync {
		1282	my ($map) = @_;
		1283
		1284	cf::sync_job { $map->load };
		1285	}
		1286
		1287	sub save {
		1288	my ($self) = @_;
		1289
		1290	my $lock = cf::lock_acquire "map_data:" . $self->path;
		1291
		1292	$self->{last_save} = $cf::RUNTIME;
		1293
		1294	return unless $self->dirty;
		1295
		1296	my $save = $self->{path}->save_path; utf8::encode $save;
		1297	my $uniq = $self->{path}->uniq_path; utf8::encode $uniq;
		1298
		1299	$self->{load_path} = $save;
		1300
		1301	return if $self->{deny_save};
		1302
		1303	local $self->{last_access} = $self->last_access;#d#
		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	# save first because save cedes
		1317	$self->save;
		1318
		1319	my $lock = cf::lock_acquire "map_data:" . $self->path;
		1320
		1321	return if $self->players;
		1322	return if $self->in_memory != cf::MAP_IN_MEMORY;
		1323	return if $self->{deny_save};
		1324
		1325	$self->clear;
		1326	$self->in_memory (cf::MAP_SWAPPED);
		1327	}
		1328
		1329	sub reset_at {
		1330	my ($self) = @_;
		1331
		1332	# TODO: safety, remove and allow resettable per-player maps
		1333	return 1e99 if $self->{path}{user_rel};
		1334	return 1e99 if $self->{deny_reset};
		1335
		1336	my $time = $self->fixed_resettime ? $self->{instantiate_time} : $self->last_access;
		1337	my $to = List::Util::min $MAX_RESET, $self->reset_timeout || $DEFAULT_RESET;
		1338
		1339	$time + $to
		1340	}
		1341
		1342	sub should_reset {
		1343	my ($self) = @_;
		1344
		1345	$self->reset_at <= $cf::RUNTIME
		1346	}
		1347
		1348	sub unlink_save {
		1349	my ($self) = @_;
		1350
		1351	utf8::encode (my $save = $self->{path}->save_path);
		1352	aioreq_pri 3; IO::AIO::aio_unlink $save;
		1353	aioreq_pri 3; IO::AIO::aio_unlink "$save.pst";
		1354	}
		1355
		1356	sub rename {
		1357	my ($self, $new_path) = @_;
		1358
		1359	$self->unlink_save;
		1360
		1361	delete $cf::MAP{$self->path};
		1362	$self->{path} = new cf::path $new_path;
		1363	$self->path ($self->{path}->as_string);
		1364	$cf::MAP{$self->path} = $self;
		1365
		1366	$self->save;
		1367	}
		1368
		1369	sub reset {
		1370	my ($self) = @_;
		1371
		1372	my $lock = cf::lock_acquire "map_data:" . $self->path;
		1373
		1374	return if $self->players;
		1375	return if $self->{path}{user_rel};#d#
		1376
		1377	warn "resetting map ", $self->path;#d#
		1378
		1379	delete $cf::MAP{$self->path};
		1380
		1381	$_->clear_links_to ($self) for values %cf::MAP;
		1382
		1383	$self->unlink_save;
		1384	$self->destroy;
		1385	}
		1386
		1387	my $nuke_counter = "aaaa";
		1388
		1389	sub nuke {
		1390	my ($self) = @_;
		1391
		1392	$self->{deny_save} = 1;
		1393	$self->reset_timeout (1);
		1394	$self->rename ("{nuke}/" . ($nuke_counter++));
		1395	$self->reset; # polite request, might not happen
		1396	}
		1397
		1398	sub customise_for {
		1399	my ($map, $ob) = @_;
		1400
		1401	if ($map->per_player) {
		1402	return cf::map::find "~" . $ob->name . "/" . $map->{path}{path};
		1403	}
		1404
		1405	$map
		1406	}
		1407
		1408	sub emergency_save {
		1409	my $freeze_guard = cf::freeze_mainloop;
		1410
		1411	warn "enter emergency map save\n";
		1412
		1413	cf::sync_job {
		1414	warn "begin emergency map save\n";
		1415	$_->save for values %cf::MAP;
		1416	};
		1417
		1418	warn "end emergency map save\n";
		1419	}
		1420
		1421	package cf;
		1422
		1423	=back
		1424
		1425
		1426	=head3 cf::object::player
		1427
		1428	=over 4
		1429
747	=item $player->reply ($npc, $msg[, $flags])	1430	=item $player_object->reply ($npc, $msg[, $flags])
748		1431
749	Sends a message to the player, as if the npc C<$npc> replied. C<$npc>	1432	Sends a message to the player, as if the npc C<$npc> replied. C<$npc>
750	can be C<undef>. Does the right thing when the player is currently in a	1433	can be C<undef>. Does the right thing when the player is currently in a
751	dialogue with the given NPC character.	1434	dialogue with the given NPC character.
752		1435
753	=cut	1436	=cut
754		1437
755	# rough implementation of a future "reply" method that works	1438	# rough implementation of a future "reply" method that works
756	# with dialog boxes.	1439	# with dialog boxes.
		1440	#TODO: the first argument must go, split into a $npc->reply_to ( method
757	sub cf::object::player::reply($$$;$) {	1441	sub cf::object::player::reply($$$;$) {
758	my ($self, $npc, $msg, $flags) = @_;	1442	my ($self, $npc, $msg, $flags) = @_;
759		1443
760	$flags = cf::NDI_BROWN | cf::NDI_UNIQUE unless @_ >= 4;	1444	$flags = cf::NDI_BROWN | cf::NDI_UNIQUE unless @_ >= 4;
761		1445
…		…
765	$msg = $npc->name . " says: $msg" if $npc;	1449	$msg = $npc->name . " says: $msg" if $npc;
766	$self->message ($msg, $flags);	1450	$self->message ($msg, $flags);
767	}	1451	}
768	}	1452	}
769		1453
770	=item $player->ext_reply ($msgid, $msgtype, %msg)	1454	=item $player_object->may ("access")
771		1455
772	Sends an ext reply to the player.	1456	Returns wether the given player is authorized to access resource "access"
		1457	(e.g. "command_wizcast").
773		1458
774	=cut	1459	=cut
775		1460
776	sub cf::player::ext_reply($$$%) {	1461	sub cf::object::player::may {
		1462	my ($self, $access) = @_;
		1463
		1464	$self->flag (cf::FLAG_WIZ) ||
		1465	(ref $cf::CFG{"may_$access"}
		1466	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}
		1467	: $cf::CFG{"may_$access"})
		1468	}
		1469
		1470	=item $player_object->enter_link
		1471
		1472	Freezes the player and moves him/her to a special map (C<{link}>).
		1473
		1474	The player should be reaosnably safe there for short amounts of time. You
		1475	I<MUST> call C<leave_link> as soon as possible, though.
		1476
		1477	=item $player_object->leave_link ($map, $x, $y)
		1478
		1479	Moves the player out of the specila link map onto the given map. If the
		1480	map is not valid (or omitted), the player will be moved back to the
		1481	location he/she was before the call to C<enter_link>, or, if that fails,
		1482	to the emergency map position.
		1483
		1484	Might block.
		1485
		1486	=cut
		1487
		1488	sub cf::object::player::enter_link {
		1489	my ($self) = @_;
		1490
		1491	$self->deactivate_recursive;
		1492
		1493	return if $self->map == $LINK_MAP;
		1494
		1495	$self->{_link_pos} ||= [$self->map->{path}, $self->x, $self->y]
		1496	if $self->map;
		1497
		1498	$self->enter_map ($LINK_MAP, 20, 20);
		1499	}
		1500
		1501	sub cf::object::player::leave_link {
		1502	my ($self, $map, $x, $y) = @_;
		1503
		1504	my $link_pos = delete $self->{_link_pos};
		1505
		1506	unless ($map) {
		1507	# restore original map position
		1508	($map, $x, $y) = @{ $link_pos || [] };
		1509	$map = cf::map::find $map;
		1510
		1511	unless ($map) {
		1512	($map, $x, $y) = @$EMERGENCY_POSITION;
		1513	$map = cf::map::find $map
		1514	or die "FATAL: cannot load emergency map\n";
		1515	}
		1516	}
		1517
		1518	($x, $y) = (-1, -1)
		1519	unless (defined $x) && (defined $y);
		1520
		1521	# use -1 or undef as default coordinates, not 0, 0
		1522	($x, $y) = ($map->enter_x, $map->enter_y)
		1523	if $x <=0 && $y <= 0;
		1524
		1525	$map->load;
		1526
		1527	$self->activate_recursive;
		1528	$self->enter_map ($map, $x, $y);
		1529	}
		1530
		1531	cf::player->attach (
		1532	on_logout => sub {
		1533	my ($pl) = @_;
		1534
		1535	# abort map switching before logout
		1536	if ($pl->ob->{_link_pos}) {
		1537	cf::sync_job {
		1538	$pl->ob->leave_link
		1539	};
		1540	}
		1541	},
		1542	on_login => sub {
		1543	my ($pl) = @_;
		1544
		1545	# try to abort aborted map switching on player login :)
		1546	# should happen only on crashes
		1547	if ($pl->ob->{_link_pos}) {
		1548
		1549	$pl->ob->enter_link;
		1550	(Coro::async_pool {
		1551	# we need this sleep as the login has a concurrent enter_exit running
		1552	# and this sleep increases chances of the player not ending up in scorn
		1553	Coro::Timer::sleep 1;
		1554	$pl->ob->leave_link;
		1555	})->prio (2);
		1556	}
		1557	},
		1558	);
		1559
		1560	=item $player_object->goto ($path, $x, $y)
		1561
		1562	=cut
		1563
		1564	sub cf::object::player::goto {
		1565	my ($self, $path, $x, $y) = @_;
		1566
		1567	$self->enter_link;
		1568
		1569	(Coro::async_pool {
		1570	$path = new cf::path $path;
		1571
		1572	my $map = cf::map::find $path->as_string;
		1573	$map = $map->customise_for ($self) if $map;
		1574
		1575	# warn "entering ", $map->path, " at ($x, $y)\n"
		1576	# if $map;
		1577
		1578	$map or $self->message ("The exit is closed", cf::NDI_UNIQUE | cf::NDI_RED);
		1579
		1580	$self->leave_link ($map, $x, $y);
		1581	})->prio (1);
		1582	}
		1583
		1584	=item $player_object->enter_exit ($exit_object)
		1585
		1586	=cut
		1587
		1588	sub parse_random_map_params {
		1589	my ($spec) = @_;
		1590
		1591	my $rmp = { # defaults
		1592	xsize => 10,
		1593	ysize => 10,
		1594	};
		1595
		1596	for (split /\n/, $spec) {
		1597	my ($k, $v) = split /\s+/, $_, 2;
		1598
		1599	$rmp->{lc $k} = $v if (length $k) && (length $v);
		1600	}
		1601
		1602	$rmp
		1603	}
		1604
		1605	sub prepare_random_map {
		1606	my ($exit) = @_;
		1607
		1608	# all this does is basically replace the /! path by
		1609	# a new random map path (?random/...) with a seed
		1610	# that depends on the exit object
		1611
		1612	my $rmp = parse_random_map_params $exit->msg;
		1613
		1614	if ($exit->map) {
		1615	$rmp->{region} = $exit->map->region_name;
		1616	$rmp->{origin_map} = $exit->map->path;
		1617	$rmp->{origin_x} = $exit->x;
		1618	$rmp->{origin_y} = $exit->y;
		1619	}
		1620
		1621	$rmp->{random_seed} ||= $exit->random_seed;
		1622
		1623	my $data = cf::to_json $rmp;
		1624	my $md5 = Digest::MD5::md5_hex $data;
		1625
		1626	if (my $fh = aio_open "$cf::RANDOM_MAPS/$md5.meta", O_WRONLY | O_CREAT, 0666) {
		1627	aio_write $fh, 0, (length $data), $data, 0;
		1628
		1629	$exit->slaying ("?random/$md5");
		1630	$exit->msg (undef);
		1631	}
		1632	}
		1633
		1634	sub cf::object::player::enter_exit {
777	my ($self, $id, %msg) = @_;	1635	my ($self, $exit) = @_;
778		1636
779	$msg{msgid} = $id;	1637	return unless $self->type == cf::PLAYER;
780		1638
781	$self->send ("ext " . to_json \%msg);	1639	$self->enter_link;
782	}
783		1640
784	#############################################################################	1641	(Coro::async_pool {
785	# map scripting support	1642	$self->deactivate_recursive; # just to be sure
		1643	unless (eval {
		1644	prepare_random_map $exit
		1645	if $exit->slaying eq "/!";
		1646
		1647	my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;
		1648	$self->goto ($path, $exit->stats->hp, $exit->stats->sp);
		1649
		1650	1;
		1651	}) {
		1652	$self->message ("Something went wrong deep within the crossfire server. "
		1653	. "I'll try to bring you back to the map you were before. "
		1654	. "Please report this to the dungeon master",
		1655	cf::NDI_UNIQUE | cf::NDI_RED);
		1656
		1657	warn "ERROR in enter_exit: $@";
		1658	$self->leave_link;
		1659	}
		1660	})->prio (1);
		1661	}
		1662
		1663	=head3 cf::client
		1664
		1665	=over 4
		1666
		1667	=item $client->send_drawinfo ($text, $flags)
		1668
		1669	Sends a drawinfo packet to the client. Circumvents output buffering so
		1670	should not be used under normal circumstances.
		1671
		1672	=cut
		1673
		1674	sub cf::client::send_drawinfo {
		1675	my ($self, $text, $flags) = @_;
		1676
		1677	utf8::encode $text;
		1678	$self->send_packet (sprintf "drawinfo %d %s", $flags, $text);
		1679	}
		1680
		1681
		1682	=item $success = $client->query ($flags, "text", \&cb)
		1683
		1684	Queues a query to the client, calling the given callback with
		1685	the reply text on a reply. flags can be C<cf::CS_QUERY_YESNO>,
		1686	C<cf::CS_QUERY_SINGLECHAR> or C<cf::CS_QUERY_HIDEINPUT> or C<0>.
		1687
		1688	Queries can fail, so check the return code. Or don't, as queries will become
		1689	reliable at some point in the future.
		1690
		1691	=cut
		1692
		1693	sub cf::client::query {
		1694	my ($self, $flags, $text, $cb) = @_;
		1695
		1696	return unless $self->state == ST_PLAYING
		1697	|| $self->state == ST_SETUP
		1698	|| $self->state == ST_CUSTOM;
		1699
		1700	$self->state (ST_CUSTOM);
		1701
		1702	utf8::encode $text;
		1703	push @{ $self->{query_queue} }, [(sprintf "query %d %s", $flags, $text), $cb];
		1704
		1705	$self->send_packet ($self->{query_queue}[0][0])
		1706	if @{ $self->{query_queue} } == 1;
		1707	}
		1708
		1709	cf::client->attach (
		1710	on_reply => sub {
		1711	my ($ns, $msg) = @_;
		1712
		1713	# this weird shuffling is so that direct followup queries
		1714	# get handled first
		1715	my $queue = delete $ns->{query_queue}
		1716	or return; # be conservative, not sure how that can happen, but we saw a crash here
		1717
		1718	(shift @$queue)->[1]->($msg);
		1719
		1720	push @{ $ns->{query_queue} }, @$queue;
		1721
		1722	if (@{ $ns->{query_queue} } == @$queue) {
		1723	if (@$queue) {
		1724	$ns->send_packet ($ns->{query_queue}[0][0]);
		1725	} else {
		1726	$ns->state (ST_PLAYING) if $ns->state == ST_CUSTOM;
		1727	}
		1728	}
		1729	},
		1730	);
		1731
		1732	=item $client->coro (\&cb)
		1733
		1734	Create a new coroutine, running the specified callback. The coroutine will
		1735	be automatically cancelled when the client gets destroyed (e.g. on logout,
		1736	or loss of connection).
		1737
		1738	=cut
		1739
		1740	sub cf::client::coro {
		1741	my ($self, $cb) = @_;
		1742
		1743	my $coro = &Coro::async_pool ($cb);
		1744
		1745	$coro->on_destroy (sub {
		1746	delete $self->{_coro}{$coro+0};
		1747	});
		1748
		1749	$self->{_coro}{$coro+0} = $coro;
		1750
		1751	$coro
		1752	}
		1753
		1754	cf::client->attach (
		1755	on_destroy => sub {
		1756	my ($ns) = @_;
		1757
		1758	$_->cancel for values %{ (delete $ns->{_coro}) || {} };
		1759	},
		1760	);
		1761
		1762	=back
		1763
		1764
		1765	=head2 SAFE SCRIPTING
		1766
		1767	Functions that provide a safe environment to compile and execute
		1768	snippets of perl code without them endangering the safety of the server
		1769	itself. Looping constructs, I/O operators and other built-in functionality
		1770	is not available in the safe scripting environment, and the number of
		1771	functions and methods that can be called is greatly reduced.
		1772
		1773	=cut
786		1774
787	our $safe = new Safe "safe";	1775	our $safe = new Safe "safe";
788	our $safe_hole = new Safe::Hole;	1776	our $safe_hole = new Safe::Hole;
789		1777
790	$SIG{FPE} = 'IGNORE';	1778	$SIG{FPE} = 'IGNORE';
791		1779
792	$safe->permit_only (Opcode::opset qw(:base_core :base_mem :base_orig :base_math sort time));	1780	$safe->permit_only (Opcode::opset qw(:base_core :base_mem :base_orig :base_math sort time));
793		1781
794	# here we export the classes and methods available to script code	1782	# here we export the classes and methods available to script code
795		1783
		1784	=pod
		1785
		1786	The following fucntions and emthods are available within a safe environment:
		1787
		1788	cf::object contr pay_amount pay_player map
		1789	cf::object::player player
		1790	cf::player peaceful
		1791	cf::map trigger
		1792
		1793	=cut
		1794
796	for (	1795	for (
797	["cf::object" => qw(contr pay_amount pay_player)],	1796	["cf::object" => qw(contr pay_amount pay_player map)],
798	["cf::object::player" => qw(player)],	1797	["cf::object::player" => qw(player)],
799	["cf::player" => qw(peaceful)],	1798	["cf::player" => qw(peaceful)],
		1799	["cf::map" => qw(trigger)],
800	) {	1800	) {
801	no strict 'refs';	1801	no strict 'refs';
802	my ($pkg, @funs) = @$_;	1802	my ($pkg, @funs) = @$_;
803	*{"safe::$pkg\::$_"} = $safe_hole->wrap (\&{"$pkg\::$_"})	1803	*{"safe::$pkg\::$_"} = $safe_hole->wrap (\&{"$pkg\::$_"})
804	for @funs;	1804	for @funs;
805	}	1805	}
		1806
		1807	=over 4
		1808
		1809	=item @retval = safe_eval $code, [var => value, ...]
		1810
		1811	Compiled and executes the given perl code snippet. additional var/value
		1812	pairs result in temporary local (my) scalar variables of the given name
		1813	that are available in the code snippet. Example:
		1814
		1815	my $five = safe_eval '$first + $second', first => 1, second => 4;
		1816
		1817	=cut
806		1818
807	sub safe_eval($;@) {	1819	sub safe_eval($;@) {
808	my ($code, %vars) = @_;	1820	my ($code, %vars) = @_;
809		1821
810	my $qcode = $code;	1822	my $qcode = $code;
…		…
833	}	1845	}
834		1846
835	wantarray ? @res : $res[0]	1847	wantarray ? @res : $res[0]
836	}	1848	}
837		1849
		1850	=item cf::register_script_function $function => $cb
		1851
		1852	Register a function that can be called from within map/npc scripts. The
		1853	function should be reasonably secure and should be put into a package name
		1854	like the extension.
		1855
		1856	Example: register a function that gets called whenever a map script calls
		1857	C<rent::overview>, as used by the C<rent> extension.
		1858
		1859	cf::register_script_function "rent::overview" => sub {
		1860	...
		1861	};
		1862
		1863	=cut
		1864
838	sub register_script_function {	1865	sub register_script_function {
839	my ($fun, $cb) = @_;	1866	my ($fun, $cb) = @_;
840		1867
841	no strict 'refs';	1868	no strict 'refs';
842	*{"safe::$fun"} = $safe_hole->wrap ($cb);	1869	*{"safe::$fun"} = $safe_hole->wrap ($cb);
843	}	1870	}
844		1871
		1872	=back
		1873
		1874	=cut
		1875
		1876	#############################################################################
		1877
		1878	=head2 EXTENSION DATABASE SUPPORT
		1879
		1880	Crossfire maintains a very simple database for extension use. It can
		1881	currently store anything that can be serialised using Storable, which
		1882	excludes objects.
		1883
		1884	The parameter C<$family> should best start with the name of the extension
		1885	using it, it should be unique.
		1886
		1887	=over 4
		1888
		1889	=item $hashref = cf::db_get $family
		1890
		1891	Return a hashref for use by the extension C<$family>, which can be
		1892	modified. After modifications, you have to call C<cf::db_dirty> or
		1893	C<cf::db_sync>.
		1894
		1895	=item $value = cf::db_get $family => $key
		1896
		1897	Returns a single value from the database
		1898
		1899	=item cf::db_put $family => $hashref
		1900
		1901	Stores the given family hashref into the database. Updates are delayed, if
		1902	you want the data to be synced to disk immediately, use C<cf::db_sync>.
		1903
		1904	=item cf::db_put $family => $key => $value
		1905
		1906	Stores the given C<$value> in the family hash. Updates are delayed, if you
		1907	want the data to be synced to disk immediately, use C<cf::db_sync>.
		1908
		1909	=item cf::db_dirty
		1910
		1911	Marks the database as dirty, to be updated at a later time.
		1912
		1913	=item cf::db_sync
		1914
		1915	Immediately write the database to disk I<if it is dirty>.
		1916
		1917	=cut
		1918
		1919	our $DB;
		1920
		1921	{
		1922	my $path = cf::localdir . "/database.pst";
		1923
		1924	sub db_load() {
		1925	$DB = stat $path ? Storable::retrieve $path : { };
		1926	}
		1927
		1928	my $pid;
		1929
		1930	sub db_save() {
		1931	waitpid $pid, 0 if $pid;
		1932	if (0 == ($pid = fork)) {
		1933	$DB->{_meta}{version} = 1;
		1934	Storable::nstore $DB, "$path~";
		1935	rename "$path~", $path;
		1936	cf::_exit 0 if defined $pid;
		1937	}
		1938	}
		1939
		1940	my $dirty;
		1941
		1942	sub db_sync() {
		1943	db_save if $dirty;
		1944	undef $dirty;
		1945	}
		1946
		1947	my $idle = Event->idle (min => $TICK * 2.8, max => 10, repeat => 0, data => WF_AUTOCANCEL, cb => sub {
		1948	db_sync;
		1949	});
		1950
		1951	sub db_dirty() {
		1952	$dirty = 1;
		1953	$idle->start;
		1954	}
		1955
		1956	sub db_get($;$) {
		1957	@_ >= 2
		1958	? $DB->{$_[0]}{$_[1]}
		1959	: ($DB->{$_[0]} ||= { })
		1960	}
		1961
		1962	sub db_put($$;$) {
		1963	if (@_ >= 3) {
		1964	$DB->{$_[0]}{$_[1]} = $_[2];
		1965	} else {
		1966	$DB->{$_[0]} = $_[1];
		1967	}
		1968	db_dirty;
		1969	}
		1970
		1971	cf::global->attach (
		1972	prio => 10000,
		1973	on_cleanup => sub {
		1974	db_sync;
		1975	},
		1976	);
		1977	}
		1978
845	#############################################################################	1979	#############################################################################
846	# the server's main()	1980	# the server's main()
847		1981
		1982	sub cfg_load {
		1983	open my $fh, "<:utf8", cf::confdir . "/config"
		1984	or return;
		1985
		1986	local $/;
		1987	*CFG = YAML::Syck::Load <$fh>;
		1988
		1989	$EMERGENCY_POSITION = $CFG{emergency_position} || ["/world/world_105_115", 5, 37];
		1990
		1991	$cf::map::MAX_RESET = $CFG{map_max_reset} if exists $CFG{map_max_reset};
		1992	$cf::map::DEFAULT_RESET = $CFG{map_default_reset} if exists $CFG{map_default_reset};
		1993
		1994	if (exists $CFG{mlockall}) {
		1995	eval {
		1996	$CFG{mlockall} ? &mlockall : &munlockall
		1997	and die "WARNING: m(un)lockall failed: $!\n";
		1998	};
		1999	warn $@ if $@;
		2000	}
		2001	}
		2002
848	sub main {	2003	sub main {
		2004	# we must not ever block the main coroutine
		2005	local $Coro::idle = sub {
		2006	Carp::cluck "FATAL: Coro::idle was called, major BUG, use cf::sync_job!\n";#d#
		2007	Coro::async_pool { Event::one_event };
		2008	};
		2009
		2010	cfg_load;
		2011	db_load;
		2012	load_extensions;
849	Event::loop;	2013	Event::loop;
850	}	2014	}
851		2015
852	#############################################################################	2016	#############################################################################
853	# initialisation	2017	# initialisation
854		2018
		2019	sub reload() {
		2020	# can/must only be called in main
		2021	if ($Coro::current != $Coro::main) {
		2022	warn "can only reload from main coroutine\n";
		2023	return;
		2024	}
		2025
		2026	warn "reloading...";
		2027
		2028	my $guard = freeze_mainloop;
		2029	cf::emergency_save;
		2030
		2031	eval {
		2032	# if anything goes wrong in here, we should simply crash as we already saved
		2033
		2034	# cancel all watchers
		2035	for (Event::all_watchers) {
		2036	$_->cancel if $_->data & WF_AUTOCANCEL;
		2037	}
		2038
		2039	# cancel all extension coros
		2040	$_->cancel for values %EXT_CORO;
		2041	%EXT_CORO = ();
		2042
		2043	# unload all extensions
		2044	for (@exts) {
		2045	warn "unloading <$_>";
		2046	unload_extension $_;
		2047	}
		2048
		2049	# unload all modules loaded from $LIBDIR
		2050	while (my ($k, $v) = each %INC) {
		2051	next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;
		2052
		2053	warn "removing <$k>";
		2054	delete $INC{$k};
		2055
		2056	$k =~ s/\.pm$//;
		2057	$k =~ s/\//::/g;
		2058
		2059	if (my $cb = $k->can ("unload_module")) {
		2060	$cb->();
		2061	}
		2062
		2063	Symbol::delete_package $k;
		2064	}
		2065
		2066	# sync database to disk
		2067	cf::db_sync;
		2068	IO::AIO::flush;
		2069
		2070	# get rid of safe::, as good as possible
		2071	Symbol::delete_package "safe::$_"
		2072	for qw(cf::attachable cf::object cf::object::player cf::client cf::player cf::map cf::party cf::region);
		2073
		2074	# remove register_script_function callbacks
		2075	# TODO
		2076
		2077	# unload cf.pm "a bit"
		2078	delete $INC{"cf.pm"};
		2079
		2080	# don't, removes xs symbols, too,
		2081	# and global variables created in xs
		2082	#Symbol::delete_package __PACKAGE__;
		2083
		2084	# reload cf.pm
		2085	warn "reloading cf.pm";
		2086	require cf;
		2087	cf::_connect_to_perl; # nominally unnecessary, but cannot hurt
		2088
		2089	# load config and database again
		2090	cf::cfg_load;
		2091	cf::db_load;
		2092
		2093	# load extensions
		2094	warn "load extensions";
		2095	cf::load_extensions;
		2096
		2097	# reattach attachments to objects
		2098	warn "reattach";
		2099	_global_reattach;
		2100	};
		2101
		2102	if ($@) {
		2103	warn $@;
		2104	warn "error while reloading, exiting.";
		2105	exit 1;
		2106	}
		2107
		2108	warn "reloaded successfully";
		2109	};
		2110
		2111	#############################################################################
		2112
		2113	unless ($LINK_MAP) {
		2114	$LINK_MAP = cf::map::new;
		2115
		2116	$LINK_MAP->width (41);
		2117	$LINK_MAP->height (41);
		2118	$LINK_MAP->alloc;
		2119	$LINK_MAP->path ("{link}");
		2120	$LINK_MAP->{path} = bless { path => "{link}" }, "cf::path";
		2121	$LINK_MAP->in_memory (MAP_IN_MEMORY);
		2122
		2123	# dirty hack because... archetypes are not yet loaded
		2124	Event->timer (
		2125	after => 2,
		2126	cb => sub {
		2127	$_[0]->w->cancel;
		2128
		2129	# provide some exits "home"
		2130	my $exit = cf::object::new "exit";
		2131
		2132	$exit->slaying ($EMERGENCY_POSITION->[0]);
		2133	$exit->stats->hp ($EMERGENCY_POSITION->[1]);
		2134	$exit->stats->sp ($EMERGENCY_POSITION->[2]);
		2135
		2136	$LINK_MAP->insert ($exit->clone, 19, 19);
		2137	$LINK_MAP->insert ($exit->clone, 19, 20);
		2138	$LINK_MAP->insert ($exit->clone, 19, 21);
		2139	$LINK_MAP->insert ($exit->clone, 20, 19);
		2140	$LINK_MAP->insert ($exit->clone, 20, 21);
		2141	$LINK_MAP->insert ($exit->clone, 21, 19);
		2142	$LINK_MAP->insert ($exit->clone, 21, 20);
		2143	$LINK_MAP->insert ($exit->clone, 21, 21);
		2144
		2145	$exit->destroy;
		2146	});
		2147
		2148	$LINK_MAP->{deny_save} = 1;
		2149	$LINK_MAP->{deny_reset} = 1;
		2150
		2151	$cf::MAP{$LINK_MAP->path} = $LINK_MAP;
		2152	}
		2153
855	register "<global>", __PACKAGE__;	2154	register "<global>", __PACKAGE__;
856		2155
		2156	register_command "reload" => sub {
		2157	my ($who, $arg) = @_;
		2158
		2159	if ($who->flag (FLAG_WIZ)) {
		2160	$who->message ("start of reload.");
		2161	reload;
		2162	$who->message ("end of reload.");
		2163	}
		2164	};
		2165
857	unshift @INC, $LIBDIR;	2166	unshift @INC, $LIBDIR;
858		2167
859	load_extensions;
860
861	$TICK_WATCHER = Event->timer (	2168	$TICK_WATCHER = Event->timer (
		2169	reentrant => 0,
862	prio => 1,	2170	prio => 0,
863	at => $NEXT_TICK || 1,	2171	at => $NEXT_TICK || $TICK,
		2172	data => WF_AUTOCANCEL,
864	cb => sub {	2173	cb => sub {
865	cf::server_tick; # one server iteration	2174	cf::server_tick; # one server iteration
866		2175	$RUNTIME += $TICK;
867	my $NOW = Event::time;
868	$NEXT_TICK += $TICK;	2176	$NEXT_TICK += $TICK;
869		2177
870	# if we are delayed by four ticks, skip them all	2178	# if we are delayed by four ticks or more, skip them all
871	$NEXT_TICK = $NOW if $NOW >= $NEXT_TICK + $TICK * 4;	2179	$NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;
872		2180
873	$TICK_WATCHER->at ($NEXT_TICK);	2181	$TICK_WATCHER->at ($NEXT_TICK);
874	$TICK_WATCHER->start;	2182	$TICK_WATCHER->start;
875	},	2183	},
876	);	2184	);
877		2185
878	_reload_2;	2186	IO::AIO::max_poll_time $TICK * 0.2;
		2187
		2188	Event->io (
		2189	fd => IO::AIO::poll_fileno,
		2190	poll => 'r',
		2191	prio => 5,
		2192	data => WF_AUTOCANCEL,
		2193	cb => \&IO::AIO::poll_cb,
		2194	);
		2195
		2196	Event->timer (
		2197	data => WF_AUTOCANCEL,
		2198	after => 0,
		2199	interval => 10,
		2200	cb => sub {
		2201	(Coro::unblock_sub {
		2202	write_runtime
		2203	or warn "ERROR: unable to write runtime file: $!";
		2204	})->();
		2205	},
		2206	);
		2207
		2208	END { cf::emergency_save }
879		2209
880	1	2210	1
881		2211

Diff Legend

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