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

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.103 by root, Sat Dec 30 10:16:11 2006 UTC vs.
Revision 1.135 by root, Thu Jan 4 20:29:46 2007 UTC

…		…
8	use Storable;	8	use Storable;
9	use Opcode;	9	use Opcode;
10	use Safe;	10	use Safe;
11	use Safe::Hole;	11	use Safe::Hole;
12		12
13	use Coro 3.3;	13	use Coro 3.3 ();
14	use Coro::Event;	14	use Coro::Event;
15	use Coro::Timer;	15	use Coro::Timer;
16	use Coro::Signal;	16	use Coro::Signal;
17	use Coro::Semaphore;	17	use Coro::Semaphore;
		18	use Coro::AIO;
18		19
		20	use Digest::MD5;
		21	use Fcntl;
19	use IO::AIO 2.3;	22	use IO::AIO 2.31 ();
20	use YAML::Syck ();	23	use YAML::Syck ();
21	use Time::HiRes;	24	use Time::HiRes;
22		25
23	use Event; $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
24		27
…		…
46	our $UPTIME; $UPTIME \|\|= time;	49	our $UPTIME; $UPTIME \|\|= time;
47	our $RUNTIME;	50	our $RUNTIME;
48		51
49	our %MAP; # all maps	52	our %MAP; # all maps
50	our $LINK_MAP; # the special {link} map	53	our $LINK_MAP; # the special {link} map
51	our $FREEZE;	54	our $RANDOM_MAPS = cf::localdir . "/random";
		55	our %EXT_CORO;
52		56
53	binmode STDOUT;	57	binmode STDOUT;
54	binmode STDERR;	58	binmode STDERR;
55		59
56	# read virtual server time, if available	60	# read virtual server time, if available
…		…
62		66
63	mkdir cf::localdir;	67	mkdir cf::localdir;
64	mkdir cf::localdir . "/" . cf::playerdir;	68	mkdir cf::localdir . "/" . cf::playerdir;
65	mkdir cf::localdir . "/" . cf::tmpdir;	69	mkdir cf::localdir . "/" . cf::tmpdir;
66	mkdir cf::localdir . "/" . cf::uniquedir;	70	mkdir cf::localdir . "/" . cf::uniquedir;
		71	mkdir $RANDOM_MAPS;
67		72
68	our %EXT_CORO;	73	# a special map that is always available
		74	our $LINK_MAP;
		75	our $EMERGENCY_POSITION;
69		76
70	#############################################################################	77	#############################################################################
71		78
72	=head2 GLOBAL VARIABLES	79	=head2 GLOBAL VARIABLES
73		80
…		…
172	sub to_json($) {	179	sub to_json($) {
173	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs	180	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs
174	JSON::Syck::Dump $_[0]	181	JSON::Syck::Dump $_[0]
175	}	182	}
176		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	=item cf::async { BLOCK }
		227
		228	Like C<Coro::async>, but runs the given BLOCK in an eval and only logs the
		229	error instead of exiting the server in case of a problem.
		230
		231	=cut
		232
		233	sub async(&) {
		234	my ($cb) = @_;
		235
		236	Coro::async {
		237	eval { $cb->() };
		238	warn $@ if $@;
		239	}
		240	}
		241
		242	sub freeze_mainloop {
		243	return unless $TICK_WATCHER->is_active;
		244
		245	my $guard = Coro::guard { $TICK_WATCHER->start };
		246	$TICK_WATCHER->stop;
		247	$guard
		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	my $freeze_guard = freeze_mainloop;
		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
177	=item $coro = cf::coro { BLOCK }	296	=item $coro = cf::coro { BLOCK }
178		297
179	Creates and returns a new coro. This coro is automcatially being canceled	298	Creates and returns a new coro. This coro is automcatially being canceled
180	when the extension calling this is being unloaded.	299	when the extension calling this is being unloaded.
181		300
182	=cut	301	=cut
183		302
184	sub coro(&) {	303	sub coro(&) {
185	my $cb = shift;	304	my $cb = shift;
186		305
187	my $coro; $coro = async {	306	my $coro = &cf::async ($cb);
188	eval {
189	$cb->();
190	};
191	warn $@ if $@;
192	};
193		307
194	$coro->on_destroy (sub {	308	$coro->on_destroy (sub {
195	delete $EXT_CORO{$coro+0};	309	delete $EXT_CORO{$coro+0};
196	});	310	});
197	$EXT_CORO{$coro+0} = $coro;	311	$EXT_CORO{$coro+0} = $coro;
198		312
199	$coro	313	$coro
200	}	314	}
201		315
		316	sub write_runtime {
		317	my $runtime = cf::localdir . "/runtime";
		318
		319	my $fh = aio_open "$runtime~", O_WRONLY \| O_CREAT, 0644
		320	or return;
		321
		322	my $value = $cf::RUNTIME + 1 + 10; # 10 is the runtime save interval, for a monotonic clock
		323	(aio_write $fh, 0, (length $value), $value, 0) <= 0
		324	and return;
		325
		326	aio_fsync $fh
		327	and return;
		328
		329	close $fh
		330	or return;
		331
		332	aio_rename "$runtime~", $runtime
		333	and return;
		334
		335	1
		336	}
		337
202	=back	338	=back
203		339
204	=cut	340	=cut
		341
		342	#############################################################################
		343
		344	package cf::path;
		345
		346	sub new {
		347	my ($class, $path, $base) = @_;
		348
		349	$path = $path->as_string if ref $path;
		350
		351	my $self = bless { }, $class;
		352
		353	# {... are special paths that are not touched
		354	# ?xxx/... are special absolute paths
		355	# ?random/... random maps
		356	# /! non-realised random map exit
		357	# /... normal maps
		358	# ~/... per-player maps without a specific player (DO NOT USE)
		359	# ~user/... per-player map of a specific user
		360
		361	if ($path =~ /^{/) {
		362	# fine as it is
		363	} elsif ($path =~ s{^\?random/}{}) {
		364	Coro::AIO::aio_load "$cf::RANDOM_MAPS/$path.meta", my $data;
		365	$self->{random} = cf::from_json $data;
		366	} else {
		367	if ($path =~ s{^~([^/]+)?}{}) {
		368	$self->{user_rel} = 1;
		369
		370	if (defined $1) {
		371	$self->{user} = $1;
		372	} elsif ($base =~ m{^~([^/]+)/}) {
		373	$self->{user} = $1;
		374	} else {
		375	warn "cannot resolve user-relative path without user <$path,$base>\n";
		376	}
		377	} elsif ($path =~ /^\//) {
		378	# already absolute
		379	} else {
		380	$base =~ s{[^/]+/?$}{};
		381	return $class->new ("$base/$path");
		382	}
		383
		384	for ($path) {
		385	redo if s{/\.?/}{/};
		386	redo if s{/[^/]+/\.\./}{/};
		387	}
		388	}
		389
		390	$self->{path} = $path;
		391
		392	$self
		393	}
		394
		395	# the name / primary key / in-game path
		396	sub as_string {
		397	my ($self) = @_;
		398
		399	$self->{user_rel} ? "~$self->{user}$self->{path}"
		400	: $self->{random} ? "?random/$self->{path}"
		401	: $self->{path}
		402	}
		403
		404	# the displayed name, this is a one way mapping
		405	sub visible_name {
		406	my ($self) = @_;
		407
		408	# if (my $rmp = $self->{random}) {
		409	# # todo: be more intelligent about this
		410	# "?random/$rmp->{origin_map}+$rmp->{origin_x}+$rmp->{origin_y}/$rmp->{dungeon_level}"
		411	# } else {
		412	$self->as_string
		413	# }
		414	}
		415
		416	# escape the /'s in the path
		417	sub _escaped_path {
		418	# ∕ is U+2215
		419	(my $path = $_[0]{path}) =~ s/\//∕/g;
		420	$path
		421	}
		422
		423	# the original (read-only) location
		424	sub load_path {
		425	my ($self) = @_;
		426
		427	sprintf "%s/%s/%s", cf::datadir, cf::mapdir, $self->{path}
		428	}
		429
		430	# the temporary/swap location
		431	sub save_path {
		432	my ($self) = @_;
		433
		434	$self->{user_rel} ? sprintf "%s/%s/%s/%s", cf::localdir, cf::playerdir, $self->{user}, $self->_escaped_path
		435	: $self->{random} ? sprintf "%s/%s", $RANDOM_MAPS, $self->{path}
		436	: sprintf "%s/%s/%s", cf::localdir, cf::tmpdir, $self->_escaped_path
		437	}
		438
		439	# the unique path, might be eq to save_path
		440	sub uniq_path {
		441	my ($self) = @_;
		442
		443	$self->{user_rel} \|\| $self->{random}
		444	? undef
		445	: sprintf "%s/%s/%s", cf::localdir, cf::uniquedir, $self->_escaped_path
		446	}
		447
		448	# return random map parameters, or undef
		449	sub random_map_params {
		450	my ($self) = @_;
		451
		452	$self->{random}
		453	}
		454
		455	# this is somewhat ugly, but style maps do need special treatment
		456	sub is_style_map {
		457	$_[0]{path} =~ m{^/styles/}
		458	}
		459
		460	package cf;
205		461
206	#############################################################################	462	#############################################################################
207		463
208	=head2 ATTACHABLE OBJECTS	464	=head2 ATTACHABLE OBJECTS
209		465
…		…
563	);	819	);
564		820
565	sub object_freezer_save {	821	sub object_freezer_save {
566	my ($filename, $rdata, $objs) = @_;	822	my ($filename, $rdata, $objs) = @_;
567		823
		824	sync_job {
568	if (length $$rdata) {	825	if (length $$rdata) {
569	warn sprintf "saving %s (%d,%d)\n",	826	warn sprintf "saving %s (%d,%d)\n",
570	$filename, length $$rdata, scalar @$objs;	827	$filename, length $$rdata, scalar @$objs;
571		828
572	if (open my $fh, ">:raw", "$filename~") {	829	if (my $fh = aio_open "$filename~", O_WRONLY \| O_CREAT, 0600) {
573	chmod SAVE_MODE, $fh;
574	syswrite $fh, $$rdata;
575	close $fh;
576
577	if (@$objs && open my $fh, ">:raw", "$filename.pst~") {
578	chmod SAVE_MODE, $fh;	830	chmod SAVE_MODE, $fh;
579	syswrite $fh, Storable::nfreeze { version => 1, objs => $objs };	831	aio_write $fh, 0, (length $$rdata), $$rdata, 0;
		832	aio_fsync $fh;
580	close $fh;	833	close $fh;
		834
		835	if (@$objs) {
		836	if (my $fh = aio_open "$filename.pst~", O_WRONLY \| O_CREAT, 0600) {
		837	chmod SAVE_MODE, $fh;
		838	my $data = Storable::nfreeze { version => 1, objs => $objs };
		839	aio_write $fh, 0, (length $data), $data, 0;
		840	aio_fsync $fh;
		841	close $fh;
581	rename "$filename.pst~", "$filename.pst";	842	aio_rename "$filename.pst~", "$filename.pst";
		843	}
		844	} else {
		845	aio_unlink "$filename.pst";
		846	}
		847
		848	aio_rename "$filename~", $filename;
582	} else {	849	} else {
583	unlink "$filename.pst";	850	warn "FATAL: $filename~: $!\n";
584	}	851	}
585
586	rename "$filename~", $filename;
587	} else {	852	} else {
588	warn "FATAL: $filename~: $!\n";
589	}
590	} else {
591	unlink $filename;	853	aio_unlink $filename;
592	unlink "$filename.pst";	854	aio_unlink "$filename.pst";
		855	}
593	}	856	}
594	}	857	}
595		858
596	sub object_freezer_as_string {	859	sub object_freezer_as_string {
597	my ($rdata, $objs) = @_;	860	my ($rdata, $objs) = @_;
…		…
602	}	865	}
603		866
604	sub object_thawer_load {	867	sub object_thawer_load {
605	my ($filename) = @_;	868	my ($filename) = @_;
606		869
607	local $/;	870	my ($data, $av);
608		871
609	my $av;	872	(aio_load $filename, $data) >= 0
		873	or return;
610		874
611	#TODO: use sysread etc.	875	unless (aio_stat "$filename.pst") {
612	if (open my $data, "<:raw:perlio", $filename) {	876	(aio_load "$filename.pst", $av) >= 0
613	$data = <$data>;	877	or return;
614	if (open my $pst, "<:raw:perlio", "$filename.pst") {
615	$av = eval { (Storable::thaw <$pst>)->{objs} };	878	$av = eval { (Storable::thaw $av)->{objs} };
616	}	879	}
		880
		881	warn sprintf "loading %s (%d)\n",
		882	$filename, length $data, scalar @{$av \|\| []};#d#
617	return ($data, $av);	883	return ($data, $av);
618	}
619
620	()
621	}	884	}
622		885
623	#############################################################################	886	#############################################################################
624	# command handling &c	887	# command handling &c
625		888
…		…
846	$self->send ("ext " . to_json \%msg);	1109	$self->send ("ext " . to_json \%msg);
847	}	1110	}
848		1111
849	=back	1112	=back
850		1113
		1114
		1115	=head3 cf::map
		1116
		1117	=over 4
		1118
		1119	=cut
		1120
		1121	package cf::map;
		1122
		1123	use Fcntl;
		1124	use Coro::AIO;
		1125
		1126	our $MAX_RESET = 3600;
		1127	our $DEFAULT_RESET = 3000;
		1128
		1129	sub generate_random_map {
		1130	my ($path, $rmp) = @_;
		1131
		1132	# mit "rum" bekleckern, nicht
		1133	cf::map::_create_random_map
		1134	$path,
		1135	$rmp->{wallstyle}, $rmp->{wall_name}, $rmp->{floorstyle}, $rmp->{monsterstyle},
		1136	$rmp->{treasurestyle}, $rmp->{layoutstyle}, $rmp->{doorstyle}, $rmp->{decorstyle},
		1137	$rmp->{origin_map}, $rmp->{final_map}, $rmp->{exitstyle}, $rmp->{this_map},
		1138	$rmp->{exit_on_final_map},
		1139	$rmp->{xsize}, $rmp->{ysize},
		1140	$rmp->{expand2x}, $rmp->{layoutoptions1}, $rmp->{layoutoptions2}, $rmp->{layoutoptions3},
		1141	$rmp->{symmetry}, $rmp->{difficulty}, $rmp->{difficulty_given}, $rmp->{difficulty_increase},
		1142	$rmp->{dungeon_level}, $rmp->{dungeon_depth}, $rmp->{decoroptions}, $rmp->{orientation},
		1143	$rmp->{origin_y}, $rmp->{origin_x}, $rmp->{random_seed}, $rmp->{total_map_hp},
		1144	$rmp->{map_layout_style}, $rmp->{treasureoptions}, $rmp->{symmetry_used},
		1145	(cf::region::find $rmp->{region})
		1146	}
		1147
		1148	# and all this just because we cannot iterate over
		1149	# all maps in C++...
		1150	sub change_all_map_light {
		1151	my ($change) = @_;
		1152
		1153	$_->change_map_light ($change)
		1154	for grep $_->outdoor, values %cf::MAP;
		1155	}
		1156
		1157	sub try_load_header($) {
		1158	my ($path) = @_;
		1159
		1160	utf8::encode $path;
		1161	aio_open $path, O_RDONLY, 0
		1162	or return;
		1163
		1164	my $map = cf::map::new
		1165	or return;
		1166
		1167	# for better error messages only, will be overwritten
		1168	$map->path ($path);
		1169
		1170	$map->load_header ($path)
		1171	or return;
		1172
		1173	$map->{load_path} = $path;
		1174
		1175	$map
		1176	}
		1177
		1178	sub find;
		1179	sub find {
		1180	my ($path, $origin) = @_;
		1181
		1182	#warn "find<$path,$origin>\n";#d#
		1183
		1184	$path = new cf::path $path, $origin && $origin->path;
		1185	my $key = $path->as_string;
		1186
		1187	cf::lock_wait "map_find:$key";
		1188
		1189	$cf::MAP{$key} \|\| do {
		1190	my $guard = cf::lock_acquire "map_find:$key";
		1191
		1192	# do it the slow way
		1193	my $map = try_load_header $path->save_path;
		1194
		1195	Coro::cede;
		1196
		1197	if ($map) {
		1198	$map->last_access ((delete $map->{last_access})
		1199	\|\| $cf::RUNTIME); #d#
		1200	# safety
		1201	$map->{instantiate_time} = $cf::RUNTIME
		1202	if $map->{instantiate_time} > $cf::RUNTIME;
		1203	} else {
		1204	if (my $rmp = $path->random_map_params) {
		1205	$map = generate_random_map $key, $rmp;
		1206	} else {
		1207	$map = try_load_header $path->load_path;
		1208	}
		1209
		1210	$map or return;
		1211
		1212	$map->{load_original} = 1;
		1213	$map->{instantiate_time} = $cf::RUNTIME;
		1214	$map->last_access ($cf::RUNTIME);
		1215	$map->instantiate;
		1216
		1217	# per-player maps become, after loading, normal maps
		1218	$map->per_player (0) if $path->{user_rel};
		1219	}
		1220
		1221	$map->path ($key);
		1222	$map->{path} = $path;
		1223	$map->{last_save} = $cf::RUNTIME;
		1224
		1225	Coro::cede;
		1226
		1227	if ($map->should_reset) {
		1228	$map->reset;
		1229	undef $guard;
		1230	$map = find $path
		1231	or return;
		1232	}
		1233
		1234	$cf::MAP{$key} = $map
		1235	}
		1236	}
		1237
		1238	sub load {
		1239	my ($self) = @_;
		1240
		1241	my $path = $self->{path};
		1242	my $guard = cf::lock_acquire "map_load:" . $path->as_string;
		1243
		1244	return if $self->in_memory != cf::MAP_SWAPPED;
		1245
		1246	$self->in_memory (cf::MAP_LOADING);
		1247
		1248	$self->alloc;
		1249	$self->load_objects ($self->{load_path}, 1)
		1250	or return;
		1251
		1252	$self->set_object_flag (cf::FLAG_OBJ_ORIGINAL, 1)
		1253	if delete $self->{load_original};
		1254
		1255	if (my $uniq = $path->uniq_path) {
		1256	utf8::encode $uniq;
		1257	if (aio_open $uniq, O_RDONLY, 0) {
		1258	$self->clear_unique_items;
		1259	$self->load_objects ($uniq, 0);
		1260	}
		1261	}
		1262
		1263	Coro::cede;
		1264
		1265	# now do the right thing for maps
		1266	$self->link_multipart_objects;
		1267
		1268	if ($self->{path}->is_style_map) {
		1269	$self->{deny_save} = 1;
		1270	$self->{deny_reset} = 1;
		1271	} else {
		1272	$self->fix_auto_apply;
		1273	$self->decay_objects;
		1274	$self->update_buttons;
		1275	$self->set_darkness_map;
		1276	$self->difficulty ($self->estimate_difficulty)
		1277	unless $self->difficulty;
		1278	$self->activate;
		1279	}
		1280
		1281	Coro::cede;
		1282
		1283	$self->in_memory (cf::MAP_IN_MEMORY);
		1284	}
		1285
		1286	sub find_sync {
		1287	my ($path, $origin) = @_;
		1288
		1289	cf::sync_job { cf::map::find $path, $origin }
		1290	}
		1291
		1292	sub do_load_sync {
		1293	my ($map) = @_;
		1294
		1295	cf::sync_job { $map->load };
		1296	}
		1297
		1298	sub save {
		1299	my ($self) = @_;
		1300
		1301	$self->{last_save} = $cf::RUNTIME;
		1302
		1303	return unless $self->dirty;
		1304
		1305	my $save = $self->{path}->save_path; utf8::encode $save;
		1306	my $uniq = $self->{path}->uniq_path; utf8::encode $uniq;
		1307
		1308	$self->{load_path} = $save;
		1309
		1310	return if $self->{deny_save};
		1311
		1312	local $self->{last_access} = $self->last_access;#d#
		1313
		1314	if ($uniq) {
		1315	$self->save_objects ($save, cf::IO_HEADER \| cf::IO_OBJECTS);
		1316	$self->save_objects ($uniq, cf::IO_UNIQUES);
		1317	} else {
		1318	$self->save_objects ($save, cf::IO_HEADER \| cf::IO_OBJECTS \| cf::IO_UNIQUES);
		1319	}
		1320	}
		1321
		1322	sub swap_out {
		1323	my ($self) = @_;
		1324
		1325	# save first because save cedes
		1326	$self->save;
		1327
		1328	return if $self->players;
		1329	return if $self->in_memory != cf::MAP_IN_MEMORY;
		1330	return if $self->{deny_save};
		1331
		1332	$self->clear;
		1333	$self->in_memory (cf::MAP_SWAPPED);
		1334	}
		1335
		1336	sub reset_at {
		1337	my ($self) = @_;
		1338
		1339	# TODO: safety, remove and allow resettable per-player maps
		1340	return 1e99 if $self->{path}{user_rel};
		1341	return 1e99 if $self->{deny_reset};
		1342
		1343	my $time = $self->fixed_resettime ? $self->{instantiate_time} : $self->last_access;
		1344	my $to = List::Util::min $MAX_RESET, $self->reset_timeout \|\| $DEFAULT_RESET;
		1345
		1346	$time + $to
		1347	}
		1348
		1349	sub should_reset {
		1350	my ($self) = @_;
		1351
		1352	$self->reset_at <= $cf::RUNTIME
		1353	}
		1354
		1355	sub unlink_save {
		1356	my ($self) = @_;
		1357
		1358	utf8::encode (my $save = $self->{path}->save_path);
		1359	aioreq_pri 3; IO::AIO::aio_unlink $save;
		1360	aioreq_pri 3; IO::AIO::aio_unlink "$save.pst";
		1361	}
		1362
		1363	sub rename {
		1364	my ($self, $new_path) = @_;
		1365
		1366	$self->unlink_save;
		1367
		1368	delete $cf::MAP{$self->path};
		1369	$self->{path} = new cf::path $new_path;
		1370	$self->path ($self->{path}->as_string);
		1371	$cf::MAP{$self->path} = $self;
		1372
		1373	$self->save;
		1374	}
		1375
		1376	sub reset {
		1377	my ($self) = @_;
		1378
		1379	return if $self->players;
		1380	return if $self->{path}{user_rel};#d#
		1381
		1382	warn "resetting map ", $self->path;#d#
		1383
		1384	delete $cf::MAP{$self->path};
		1385
		1386	$_->clear_links_to ($self) for values %cf::MAP;
		1387
		1388	$self->unlink_save;
		1389	$self->destroy;
		1390	}
		1391
		1392	my $nuke_counter = "aaaa";
		1393
		1394	sub nuke {
		1395	my ($self) = @_;
		1396
		1397	$self->{deny_save} = 1;
		1398	$self->reset_timeout (1);
		1399	$self->rename ("{nuke}/" . ($nuke_counter++));
		1400	$self->reset; # polite request, might not happen
		1401	}
		1402
		1403	sub customise_for {
		1404	my ($map, $ob) = @_;
		1405
		1406	if ($map->per_player) {
		1407	return cf::map::find "~" . $ob->name . "/" . $map->{path}{path};
		1408	}
		1409
		1410	$map
		1411	}
		1412
		1413	sub emergency_save {
		1414	my $freeze_guard = cf::freeze_mainloop;
		1415
		1416	warn "enter emergency map save\n";
		1417
		1418	cf::sync_job {
		1419	warn "begin emergency map save\n";
		1420	$_->save for values %cf::MAP;
		1421	};
		1422
		1423	warn "end emergency map save\n";
		1424	}
		1425
		1426	package cf;
		1427
		1428	=back
		1429
		1430
851	=head3 cf::object::player	1431	=head3 cf::object::player
852		1432
853	=over 4	1433	=over 4
854		1434
855	=item $player_object->reply ($npc, $msg[, $flags])	1435	=item $player_object->reply ($npc, $msg[, $flags])
…		…
890	(ref $cf::CFG{"may_$access"}	1470	(ref $cf::CFG{"may_$access"}
891	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}	1471	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}
892	: $cf::CFG{"may_$access"})	1472	: $cf::CFG{"may_$access"})
893	}	1473	}
894		1474
		1475	=item $player_object->enter_link
		1476
		1477	Freezes the player and moves him/her to a special map (C<{link}>).
		1478
		1479	The player should be reaosnably safe there for short amounts of time. You
		1480	I<MUST> call C<leave_link> as soon as possible, though.
		1481
		1482	=item $player_object->leave_link ($map, $x, $y)
		1483
		1484	Moves the player out of the specila link map onto the given map. If the
		1485	map is not valid (or omitted), the player will be moved back to the
		1486	location he/she was before the call to C<enter_link>, or, if that fails,
		1487	to the emergency map position.
		1488
		1489	Might block.
		1490
		1491	=cut
		1492
		1493	sub cf::object::player::enter_link {
		1494	my ($self) = @_;
		1495
		1496	$self->deactivate_recursive;
		1497
		1498	return if $self->map == $LINK_MAP;
		1499
		1500	$self->{_link_pos} \|\|= [$self->map->{path}, $self->x, $self->y]
		1501	if $self->map;
		1502
		1503	$self->enter_map ($LINK_MAP, 20, 20);
		1504	}
		1505
		1506	sub cf::object::player::leave_link {
		1507	my ($self, $map, $x, $y) = @_;
		1508
		1509	my $link_pos = delete $self->{_link_pos};
		1510
		1511	unless ($map) {
		1512	# restore original map position
		1513	($map, $x, $y) = @{ $link_pos \|\| [] };
		1514	$map = cf::map::find $map;
		1515
		1516	unless ($map) {
		1517	($map, $x, $y) = @$EMERGENCY_POSITION;
		1518	$map = cf::map::find $map
		1519	or die "FATAL: cannot load emergency map\n";
		1520	}
		1521	}
		1522
		1523	($x, $y) = (-1, -1)
		1524	unless (defined $x) && (defined $y);
		1525
		1526	# use -1 or undef as default coordinates, not 0, 0
		1527	($x, $y) = ($map->enter_x, $map->enter_y)
		1528	if $x <=0 && $y <= 0;
		1529
		1530	$map->load;
		1531
		1532	$self->activate_recursive;
		1533	$self->enter_map ($map, $x, $y);
		1534	}
		1535
		1536	cf::player->attach (
		1537	on_logout => sub {
		1538	my ($pl) = @_;
		1539
		1540	# abort map switching before logout
		1541	if ($pl->ob->{_link_pos}) {
		1542	cf::sync_job {
		1543	$pl->ob->leave_link
		1544	};
		1545	}
		1546	},
		1547	on_login => sub {
		1548	my ($pl) = @_;
		1549
		1550	# try to abort aborted map switching on player login :)
		1551	# should happen only on crashes
		1552	if ($pl->ob->{_link_pos}) {
		1553	$pl->ob->enter_link;
		1554	cf::async {
		1555	# we need this sleep as the login has a concurrent enter_exit running
		1556	# and this sleep increases chances of the player not ending up in scorn
		1557	Coro::Timer::sleep 1;
		1558	$pl->ob->leave_link;
		1559	};
		1560	}
		1561	},
		1562	);
		1563
		1564	=item $player_object->goto_map ($path, $x, $y)
		1565
		1566	=cut
		1567
		1568	sub cf::object::player::goto_map {
		1569	my ($self, $path, $x, $y) = @_;
		1570
		1571	$self->enter_link;
		1572
		1573	(cf::async {
		1574	$path = new cf::path $path;
		1575
		1576	my $map = cf::map::find $path->as_string;
		1577	$map = $map->customise_for ($self) if $map;
		1578
		1579	# warn "entering ", $map->path, " at ($x, $y)\n"
		1580	# if $map;
		1581
		1582	$map or $self->message ("The exit is closed", cf::NDI_UNIQUE \| cf::NDI_RED);
		1583
		1584	$self->leave_link ($map, $x, $y);
		1585	})->prio (1);
		1586	}
		1587
		1588	=item $player_object->enter_exit ($exit_object)
		1589
		1590	=cut
		1591
		1592	sub parse_random_map_params {
		1593	my ($spec) = @_;
		1594
		1595	my $rmp = { # defaults
		1596	xsize => 10,
		1597	ysize => 10,
		1598	};
		1599
		1600	for (split /\n/, $spec) {
		1601	my ($k, $v) = split /\s+/, $_, 2;
		1602
		1603	$rmp->{lc $k} = $v if (length $k) && (length $v);
		1604	}
		1605
		1606	$rmp
		1607	}
		1608
		1609	sub prepare_random_map {
		1610	my ($exit) = @_;
		1611
		1612	# all this does is basically replace the /! path by
		1613	# a new random map path (?random/...) with a seed
		1614	# that depends on the exit object
		1615
		1616	my $rmp = parse_random_map_params $exit->msg;
		1617
		1618	if ($exit->map) {
		1619	$rmp->{region} = $exit->map->region_name;
		1620	$rmp->{origin_map} = $exit->map->path;
		1621	$rmp->{origin_x} = $exit->x;
		1622	$rmp->{origin_y} = $exit->y;
		1623	}
		1624
		1625	$rmp->{random_seed} \|\|= $exit->random_seed;
		1626
		1627	my $data = cf::to_json $rmp;
		1628	my $md5 = Digest::MD5::md5_hex $data;
		1629
		1630	if (my $fh = aio_open "$cf::RANDOM_MAPS/$md5.meta", O_WRONLY \| O_CREAT, 0666) {
		1631	aio_write $fh, 0, (length $data), $data, 0;
		1632
		1633	$exit->slaying ("?random/$md5");
		1634	$exit->msg (undef);
		1635	}
		1636	}
		1637
		1638	sub cf::object::player::enter_exit {
		1639	my ($self, $exit) = @_;
		1640
		1641	return unless $self->type == cf::PLAYER;
		1642
		1643	$self->enter_link;
		1644
		1645	(cf::async {
		1646	$self->deactivate_recursive; # just to be sure
		1647	unless (eval {
		1648	prepare_random_map $exit
		1649	if $exit->slaying eq "/!";
		1650
		1651	my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;
		1652	$self->goto_map ($path, $exit->stats->hp, $exit->stats->sp);
		1653
		1654	1;
		1655	}) {
		1656	$self->message ("Something went wrong deep within the crossfire server. "
		1657	. "I'll try to bring you back to the map you were before. "
		1658	. "Please report this to the dungeon master",
		1659	cf::NDI_UNIQUE \| cf::NDI_RED);
		1660
		1661	warn "ERROR in enter_exit: $@";
		1662	$self->leave_link;
		1663	}
		1664	})->prio (1);
		1665	}
		1666
895	=head3 cf::client	1667	=head3 cf::client
896		1668
897	=over 4	1669	=over 4
898		1670
899	=item $client->send_drawinfo ($text, $flags)	1671	=item $client->send_drawinfo ($text, $flags)
…		…
942	on_reply => sub {	1714	on_reply => sub {
943	my ($ns, $msg) = @_;	1715	my ($ns, $msg) = @_;
944		1716
945	# this weird shuffling is so that direct followup queries	1717	# this weird shuffling is so that direct followup queries
946	# get handled first	1718	# get handled first
947	my $queue = delete $ns->{query_queue};	1719	my $queue = delete $ns->{query_queue}
		1720	or return; # be conservative, not sure how that can happen, but we saw a crash here
948		1721
949	(shift @$queue)->[1]->($msg);	1722	(shift @$queue)->[1]->($msg);
950		1723
951	push @{ $ns->{query_queue} }, @$queue;	1724	push @{ $ns->{query_queue} }, @$queue;
952		1725
…		…
969	=cut	1742	=cut
970		1743
971	sub cf::client::coro {	1744	sub cf::client::coro {
972	my ($self, $cb) = @_;	1745	my ($self, $cb) = @_;
973		1746
974	my $coro; $coro = async {	1747	my $coro = &cf::async ($cb);
975	eval {
976	$cb->();
977	};
978	warn $@ if $@;
979	};
980		1748
981	$coro->on_destroy (sub {	1749	$coro->on_destroy (sub {
982	delete $self->{_coro}{$coro+0};	1750	delete $self->{_coro}{$coro+0};
983	});	1751	});
984		1752
…		…
1156		1924
1157	{	1925	{
1158	my $path = cf::localdir . "/database.pst";	1926	my $path = cf::localdir . "/database.pst";
1159		1927
1160	sub db_load() {	1928	sub db_load() {
1161	warn "loading database $path\n";#d# remove later
1162	$DB = stat $path ? Storable::retrieve $path : { };	1929	$DB = stat $path ? Storable::retrieve $path : { };
1163	}	1930	}
1164		1931
1165	my $pid;	1932	my $pid;
1166		1933
1167	sub db_save() {	1934	sub db_save() {
1168	warn "saving database $path\n";#d# remove later
1169	waitpid $pid, 0 if $pid;	1935	waitpid $pid, 0 if $pid;
1170	if (0 == ($pid = fork)) {	1936	if (0 == ($pid = fork)) {
1171	$DB->{_meta}{version} = 1;	1937	$DB->{_meta}{version} = 1;
1172	Storable::nstore $DB, "$path~";	1938	Storable::nstore $DB, "$path~";
1173	rename "$path~", $path;	1939	rename "$path~", $path;
…		…
1221	open my $fh, "<:utf8", cf::confdir . "/config"	1987	open my $fh, "<:utf8", cf::confdir . "/config"
1222	or return;	1988	or return;
1223		1989
1224	local $/;	1990	local $/;
1225	*CFG = YAML::Syck::Load <$fh>;	1991	*CFG = YAML::Syck::Load <$fh>;
		1992
		1993	$EMERGENCY_POSITION = $CFG{emergency_position} \|\| ["/world/world_105_115", 5, 37];
		1994
		1995	if (exists $CFG{mlockall}) {
		1996	eval {
		1997	$CFG{mlockall} ? &mlockall : &munlockall
		1998	and die "WARNING: m(un)lockall failed: $!\n";
		1999	};
		2000	warn $@ if $@;
		2001	}
1226	}	2002	}
1227		2003
1228	sub main {	2004	sub main {
		2005	# we must not ever block the main coroutine
		2006	local $Coro::idle = sub {
		2007	Carp::cluck "FATAL: Coro::idle was called, major BUG, use cf::sync_job!\n";#d#
		2008	(Coro::unblock_sub {
		2009	Event::one_event;
		2010	})->();
		2011	};
		2012
1229	cfg_load;	2013	cfg_load;
1230	db_load;	2014	db_load;
1231	load_extensions;	2015	load_extensions;
1232	Event::loop;	2016	Event::loop;
1233	}	2017	}
1234		2018
1235	#############################################################################	2019	#############################################################################
1236	# initialisation	2020	# initialisation
1237		2021
1238	sub _perl_reload() {	2022	sub reload() {
		2023	# can/must only be called in main
		2024	if ($Coro::current != $Coro::main) {
		2025	warn "can only reload from main coroutine\n";
		2026	return;
		2027	}
		2028
1239	warn "reloading...";	2029	warn "reloading...";
1240		2030
		2031	my $guard = freeze_mainloop;
		2032	cf::emergency_save;
		2033
1241	eval {	2034	eval {
1242	local $FREEZE = 1;	2035	# if anything goes wrong in here, we should simply crash as we already saved
1243
1244	cf::emergency_save;
1245		2036
1246	# cancel all watchers	2037	# cancel all watchers
1247	for (Event::all_watchers) {	2038	for (Event::all_watchers) {
1248	$_->cancel if $_->data & WF_AUTOCANCEL;	2039	$_->cancel if $_->data & WF_AUTOCANCEL;
1249	}	2040	}
…		…
1308		2099
1309	# reattach attachments to objects	2100	# reattach attachments to objects
1310	warn "reattach";	2101	warn "reattach";
1311	_global_reattach;	2102	_global_reattach;
1312	};	2103	};
1313	warn $@ if $@;
1314		2104
1315	warn "reloaded";	2105	if ($@) {
		2106	warn $@;
		2107	warn "error while reloading, exiting.";
		2108	exit 1;
		2109	}
		2110
		2111	warn "reloaded successfully";
1316	};	2112	};
1317		2113
1318	sub perl_reload() {	2114	#############################################################################
1319	_perl_reload;	2115
		2116	unless ($LINK_MAP) {
		2117	$LINK_MAP = cf::map::new;
		2118
		2119	$LINK_MAP->width (41);
		2120	$LINK_MAP->height (41);
		2121	$LINK_MAP->alloc;
		2122	$LINK_MAP->path ("{link}");
		2123	$LINK_MAP->{path} = bless { path => "{link}" }, "cf::path";
		2124	$LINK_MAP->in_memory (MAP_IN_MEMORY);
		2125
		2126	# dirty hack because... archetypes are not yet loaded
		2127	Event->timer (
		2128	after => 2,
		2129	cb => sub {
		2130	$_[0]->w->cancel;
		2131
		2132	# provide some exits "home"
		2133	my $exit = cf::object::new "exit";
		2134
		2135	$exit->slaying ($EMERGENCY_POSITION->[0]);
		2136	$exit->stats->hp ($EMERGENCY_POSITION->[1]);
		2137	$exit->stats->sp ($EMERGENCY_POSITION->[2]);
		2138
		2139	$LINK_MAP->insert ($exit->clone, 19, 19);
		2140	$LINK_MAP->insert ($exit->clone, 19, 20);
		2141	$LINK_MAP->insert ($exit->clone, 19, 21);
		2142	$LINK_MAP->insert ($exit->clone, 20, 19);
		2143	$LINK_MAP->insert ($exit->clone, 20, 21);
		2144	$LINK_MAP->insert ($exit->clone, 21, 19);
		2145	$LINK_MAP->insert ($exit->clone, 21, 20);
		2146	$LINK_MAP->insert ($exit->clone, 21, 21);
		2147
		2148	$exit->destroy;
		2149	});
		2150
		2151	$LINK_MAP->{deny_save} = 1;
		2152	$LINK_MAP->{deny_reset} = 1;
		2153
		2154	$cf::MAP{$LINK_MAP->path} = $LINK_MAP;
1320	}	2155	}
1321		2156
1322	register "<global>", __PACKAGE__;	2157	register "<global>", __PACKAGE__;
1323		2158
1324	register_command "perl-reload" => sub {	2159	register_command "reload" => sub {
1325	my ($who, $arg) = @_;	2160	my ($who, $arg) = @_;
1326		2161
1327	if ($who->flag (FLAG_WIZ)) {	2162	if ($who->flag (FLAG_WIZ)) {
		2163	$who->message ("start of reload.");
		2164	reload;
1328	$who->message ("reloading...");	2165	$who->message ("end of reload.");
1329	_perl_reload;
1330	}	2166	}
1331	};	2167	};
1332		2168
1333	unshift @INC, $LIBDIR;	2169	unshift @INC, $LIBDIR;
1334		2170
1335	$TICK_WATCHER = Event->timer (	2171	$TICK_WATCHER = Event->timer (
		2172	reentrant => 0,
1336	prio => 0,	2173	prio => 0,
1337	at => $NEXT_TICK \|\| $TICK,	2174	at => $NEXT_TICK \|\| $TICK,
1338	data => WF_AUTOCANCEL,	2175	data => WF_AUTOCANCEL,
1339	cb => sub {	2176	cb => sub {
1340	unless ($FREEZE) {
1341	cf::server_tick; # one server iteration	2177	cf::server_tick; # one server iteration
1342	$RUNTIME += $TICK;	2178	$RUNTIME += $TICK;
1343	}
1344
1345	$NEXT_TICK += $TICK;	2179	$NEXT_TICK += $TICK;
1346		2180
1347	# if we are delayed by four ticks or more, skip them all	2181	# if we are delayed by four ticks or more, skip them all
1348	$NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;	2182	$NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;
1349		2183
…		…
1352	},	2186	},
1353	);	2187	);
1354		2188
1355	IO::AIO::max_poll_time $TICK * 0.2;	2189	IO::AIO::max_poll_time $TICK * 0.2;
1356		2190
		2191	Event->io (
1357	Event->io (fd => IO::AIO::poll_fileno,	2192	fd => IO::AIO::poll_fileno,
1358	poll => 'r',	2193	poll => 'r',
1359	prio => 5,	2194	prio => 5,
1360	data => WF_AUTOCANCEL,	2195	data => WF_AUTOCANCEL,
1361	cb => \&IO::AIO::poll_cb);	2196	cb => \&IO::AIO::poll_cb,
		2197	);
1362		2198
1363	# we must not ever block the main coroutine	2199	Event->timer (
1364	$Coro::idle = sub {	2200	data => WF_AUTOCANCEL,
1365	#Carp::cluck "FATAL: Coro::idle was called, major BUG\n";#d#	2201	after => 0,
1366	warn "FATAL: Coro::idle was called, major BUG\n";	2202	interval => 10,
		2203	cb => sub {
1367	(Coro::unblock_sub {	2204	(Coro::unblock_sub {
1368	Event::one_event;	2205	write_runtime
		2206	or warn "ERROR: unable to write runtime file: $!";
1369	})->();	2207	})->();
1370	};	2208	},
		2209	);
		2210
		2211	END { cf::emergency_save }
1371		2212
1372	1	2213	1
1373		2214

Diff Legend

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

Comparing deliantra/server/lib/cf.pm (file contents): Revision 1.103 by root, Sat Dec 30 10:16:11 2006 UTC vs. Revision 1.135 by root, Thu Jan 4 20:29:46 2007 UTC

Diff Legend

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.103 by root, Sat Dec 30 10:16:11 2006 UTC vs.
Revision 1.135 by root, Thu Jan 4 20:29:46 2007 UTC