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

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.104 by root, Sat Dec 30 16:56:16 2006 UTC vs.
Revision 1.123 by root, Tue Jan 2 19:18:33 2007 UTC

…		…
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
…		…
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 $FREEZE;
		55	our $RANDOM_MAPS = cf::localdir . "/random";
		56	our %EXT_CORO;
52		57
53	binmode STDOUT;	58	binmode STDOUT;
54	binmode STDERR;	59	binmode STDERR;
55		60
56	# read virtual server time, if available	61	# read virtual server time, if available
…		…
62		67
63	mkdir cf::localdir;	68	mkdir cf::localdir;
64	mkdir cf::localdir . "/" . cf::playerdir;	69	mkdir cf::localdir . "/" . cf::playerdir;
65	mkdir cf::localdir . "/" . cf::tmpdir;	70	mkdir cf::localdir . "/" . cf::tmpdir;
66	mkdir cf::localdir . "/" . cf::uniquedir;	71	mkdir cf::localdir . "/" . cf::uniquedir;
		72	mkdir $RANDOM_MAPS;
67		73
68	our %EXT_CORO;	74	# a special map that is always available
		75	our $LINK_MAP;
		76
		77	our $EMERGENCY_POSITION = $cf::CFG{emergency_position} \|\| ["/world/world_105_115", 5, 37];
69		78
70	#############################################################################	79	#############################################################################
71		80
72	=head2 GLOBAL VARIABLES	81	=head2 GLOBAL VARIABLES
73		82
…		…
172	sub to_json($) {	181	sub to_json($) {
173	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs	182	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs
174	JSON::Syck::Dump $_[0]	183	JSON::Syck::Dump $_[0]
175	}	184	}
176		185
		186	=item my $guard = cf::guard { BLOCK }
		187
		188	Run the given callback when the guard object gets destroyed (useful for
		189	coroutine cancellations).
		190
		191	You can call C<< ->cancel >> on the guard object to stop the block from
		192	being executed.
		193
		194	=cut
		195
		196	sub guard(&) {
		197	bless \(my $cb = $_[0]), cf::guard::;
		198	}
		199
		200	sub cf::guard::cancel {
		201	${$_[0]} = sub { };
		202	}
		203
		204	sub cf::guard::DESTROY {
		205	${$_[0]}->();
		206	}
		207
		208	=item cf::lock_wait $string
		209
		210	Wait until the given lock is available. See cf::lock_acquire.
		211
		212	=item my $lock = cf::lock_acquire $string
		213
		214	Wait until the given lock is available and then acquires it and returns
		215	a guard object. If the guard object gets destroyed (goes out of scope,
		216	for example when the coroutine gets canceled), the lock is automatically
		217	returned.
		218
		219	Lock names should begin with a unique identifier (for example, find_map
		220	uses map_find and load_map uses map_load).
		221
		222	=cut
		223
		224	our %LOCK;
		225
		226	sub lock_wait($) {
		227	my ($key) = @_;
		228
		229	# wait for lock, if any
		230	while ($LOCK{$key}) {
		231	push @{ $LOCK{$key} }, $Coro::current;
		232	Coro::schedule;
		233	}
		234	}
		235
		236	sub lock_acquire($) {
		237	my ($key) = @_;
		238
		239	# wait, to be sure we are not locked
		240	lock_wait $key;
		241
		242	$LOCK{$key} = [];
		243
		244	cf::guard {
		245	# wake up all waiters, to be on the safe side
		246	$_->ready for @{ delete $LOCK{$key} };
		247	}
		248	}
		249
		250	=item cf::sync_job { BLOCK }
		251
		252	The design of crossfire+ requires that the main coro ($Coro::main) is
		253	always able to handle events or runnable, as crossfire+ is only partly
		254	reentrant. Thus "blocking" it by e.g. waiting for I/O is not acceptable.
		255
		256	If it must be done, put the blocking parts into C<sync_job>. This will run
		257	the given BLOCK in another coroutine while waiting for the result. The
		258	server will be frozen during this time, so the block should either finish
		259	fast or be very important.
		260
		261	=cut
		262
		263	sub sync_job(&) {
		264	my ($job) = @_;
		265
		266	if ($Coro::current == $Coro::main) {
		267	# this is the main coro, too bad, we have to block
		268	# till the operation succeeds, freezing the server :/
		269
		270	# TODO: use suspend/resume instead
		271	# (but this is cancel-safe)
		272	local $FREEZE = 1;
		273
		274	my $busy = 1;
		275	my @res;
		276
		277	(Coro::async {
		278	@res = eval { $job->() };
		279	warn $@ if $@;
		280	undef $busy;
		281	})->prio (Coro::PRIO_MAX);
		282
		283	while ($busy) {
		284	Coro::cede_notself;
		285	Event::one_event unless Coro::nready;
		286	}
		287
		288	wantarray ? @res : $res[0]
		289	} else {
		290	# we are in another coroutine, how wonderful, everything just works
		291
		292	$job->()
		293	}
		294	}
		295
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
…		…
197	$EXT_CORO{$coro+0} = $coro;	316	$EXT_CORO{$coro+0} = $coro;
198		317
199	$coro	318	$coro
200	}	319	}
201		320
		321	sub write_runtime {
		322	my $runtime = cf::localdir . "/runtime";
		323
		324	my $fh = aio_open "$runtime~", O_WRONLY \| O_CREAT, 0644
		325	or return;
		326
		327	my $value = $cf::RUNTIME + 1 + 10; # 10 is the runtime save interval, for a monotonic clock
		328	(aio_write $fh, 0, (length $value), $value, 0) <= 0
		329	and return;
		330
		331	aio_fsync $fh
		332	and return;
		333
		334	close $fh
		335	or return;
		336
		337	aio_rename "$runtime~", $runtime
		338	and return;
		339
		340	1
		341	}
		342
202	=back	343	=back
203		344
204	=cut	345	=cut
		346
		347	#############################################################################
		348
		349	package cf::path;
		350
		351	sub new {
		352	my ($class, $path, $base) = @_;
		353
		354	$path = $path->as_string if ref $path;
		355
		356	my $self = bless { }, $class;
		357
		358	# {... are special paths that are not touched
		359	# ?xxx/... are special absolute paths
		360	# ?random/... random maps
		361	# /! non-realised random map exit
		362	# /... normal maps
		363	# ~/... per-player maps without a specific player (DO NOT USE)
		364	# ~user/... per-player map of a specific user
		365
		366	if ($path =~ /^{/) {
		367	# fine as it is
		368	} elsif ($path =~ s{^\?random/}{}) {
		369	Coro::AIO::aio_load "$cf::RANDOM_MAPS/$path.meta", my $data;
		370	$self->{random} = cf::from_json $data;
		371	} else {
		372	if ($path =~ s{^~([^/]+)?}{}) {
		373	$self->{user_rel} = 1;
		374
		375	if (defined $1) {
		376	$self->{user} = $1;
		377	} elsif ($base =~ m{^~([^/]+)/}) {
		378	$self->{user} = $1;
		379	} else {
		380	warn "cannot resolve user-relative path without user <$path,$base>\n";
		381	}
		382	} elsif ($path =~ /^\//) {
		383	# already absolute
		384	} else {
		385	$base =~ s{[^/]+/?$}{};
		386	return $class->new ("$base/$path");
		387	}
		388
		389	for ($path) {
		390	redo if s{/\.?/}{/};
		391	redo if s{/[^/]+/\.\./}{/};
		392	}
		393	}
		394
		395	$self->{path} = $path;
		396
		397	$self
		398	}
		399
		400	# the name / primary key / in-game path
		401	sub as_string {
		402	my ($self) = @_;
		403
		404	$self->{user_rel} ? "~$self->{user}$self->{path}"
		405	: $self->{random} ? "?random/$self->{path}"
		406	: $self->{path}
		407	}
		408
		409	# the displayed name, this is a one way mapping
		410	sub visible_name {
		411	my ($self) = @_;
		412
		413	# if (my $rmp = $self->{random}) {
		414	# # todo: be more intelligent about this
		415	# "?random/$rmp->{origin_map}+$rmp->{origin_x}+$rmp->{origin_y}/$rmp->{dungeon_level}"
		416	# } else {
		417	$self->as_string
		418	# }
		419	}
		420
		421	# escape the /'s in the path
		422	sub _escaped_path {
		423	# ∕ is U+2215
		424	(my $path = $_[0]{path}) =~ s/\//∕/g;
		425	$path
		426	}
		427
		428	# the original (read-only) location
		429	sub load_path {
		430	my ($self) = @_;
		431
		432	sprintf "%s/%s/%s", cf::datadir, cf::mapdir, $self->{path}
		433	}
		434
		435	# the temporary/swap location
		436	sub save_path {
		437	my ($self) = @_;
		438
		439	$self->{user_rel} ? sprintf "%s/%s/%s/%s", cf::localdir, cf::playerdir, $self->{user}, $self->_escaped_path
		440	: $self->{random} ? sprintf "%s/%s", $RANDOM_MAPS, $self->{path}
		441	: sprintf "%s/%s/%s", cf::localdir, cf::tmpdir, $self->_escaped_path
		442	}
		443
		444	# the unique path, might be eq to save_path
		445	sub uniq_path {
		446	my ($self) = @_;
		447
		448	$self->{user_rel} \|\| $self->{random}
		449	? undef
		450	: sprintf "%s/%s/%s", cf::localdir, cf::uniquedir, $self->_escaped_path
		451	}
		452
		453	# return random map parameters, or undef
		454	sub random_map_params {
		455	my ($self) = @_;
		456
		457	$self->{random}
		458	}
		459
		460	# this is somewhat ugly, but style maps do need special treatment
		461	sub is_style_map {
		462	$_[0]{path} =~ m{^/styles/}
		463	}
		464
		465	package cf;
205		466
206	#############################################################################	467	#############################################################################
207		468
208	=head2 ATTACHABLE OBJECTS	469	=head2 ATTACHABLE OBJECTS
209		470
…		…
563	);	824	);
564		825
565	sub object_freezer_save {	826	sub object_freezer_save {
566	my ($filename, $rdata, $objs) = @_;	827	my ($filename, $rdata, $objs) = @_;
567		828
		829	sync_job {
568	if (length $$rdata) {	830	if (length $$rdata) {
569	warn sprintf "saving %s (%d,%d)\n",	831	warn sprintf "saving %s (%d,%d)\n",
570	$filename, length $$rdata, scalar @$objs;	832	$filename, length $$rdata, scalar @$objs;
571		833
572	if (open my $fh, ">:raw", "$filename~") {	834	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;	835	chmod SAVE_MODE, $fh;
579	syswrite $fh, Storable::nfreeze { version => 1, objs => $objs };	836	aio_write $fh, 0, (length $$rdata), $$rdata, 0;
		837	aio_fsync $fh;
580	close $fh;	838	close $fh;
		839
		840	if (@$objs) {
		841	if (my $fh = aio_open "$filename.pst~", O_WRONLY \| O_CREAT, 0600) {
		842	chmod SAVE_MODE, $fh;
		843	my $data = Storable::nfreeze { version => 1, objs => $objs };
		844	aio_write $fh, 0, (length $data), $data, 0;
		845	aio_fsync $fh;
		846	close $fh;
581	rename "$filename.pst~", "$filename.pst";	847	aio_rename "$filename.pst~", "$filename.pst";
		848	}
		849	} else {
		850	aio_unlink "$filename.pst";
		851	}
		852
		853	aio_rename "$filename~", $filename;
582	} else {	854	} else {
583	unlink "$filename.pst";	855	warn "FATAL: $filename~: $!\n";
584	}	856	}
585
586	rename "$filename~", $filename;
587	} else {	857	} else {
588	warn "FATAL: $filename~: $!\n";
589	}
590	} else {
591	unlink $filename;	858	aio_unlink $filename;
592	unlink "$filename.pst";	859	aio_unlink "$filename.pst";
		860	}
593	}	861	}
594	}	862	}
595		863
596	sub object_freezer_as_string {	864	sub object_freezer_as_string {
597	my ($rdata, $objs) = @_;	865	my ($rdata, $objs) = @_;
…		…
602	}	870	}
603		871
604	sub object_thawer_load {	872	sub object_thawer_load {
605	my ($filename) = @_;	873	my ($filename) = @_;
606		874
607	local $/;	875	my ($data, $av);
608		876
609	my $av;	877	(aio_load $filename, $data) >= 0
		878	or return;
610		879
611	#TODO: use sysread etc.	880	unless (aio_stat "$filename.pst") {
612	if (open my $data, "<:raw:perlio", $filename) {	881	(aio_load "$filename.pst", $av) >= 0
613	$data = <$data>;	882	or return;
614	if (open my $pst, "<:raw:perlio", "$filename.pst") {
615	$av = eval { (Storable::thaw <$pst>)->{objs} };	883	$av = eval { (Storable::thaw $av)->{objs} };
616	}	884	}
		885
		886	warn sprintf "loading %s (%d)\n",
		887	$filename, length $data, scalar @{$av \|\| []};#d#
617	return ($data, $av);	888	return ($data, $av);
618	}
619
620	()
621	}	889	}
622		890
623	#############################################################################	891	#############################################################################
624	# command handling &c	892	# command handling &c
625		893
…		…
846	$self->send ("ext " . to_json \%msg);	1114	$self->send ("ext " . to_json \%msg);
847	}	1115	}
848		1116
849	=back	1117	=back
850		1118
		1119
		1120	=head3 cf::map
		1121
		1122	=over 4
		1123
		1124	=cut
		1125
		1126	package cf::map;
		1127
		1128	use Fcntl;
		1129	use Coro::AIO;
		1130
		1131	our $MAX_RESET = 7200;
		1132	our $DEFAULT_RESET = 3600;
		1133
		1134	sub generate_random_map {
		1135	my ($path, $rmp) = @_;
		1136
		1137	# mit "rum" bekleckern, nicht
		1138	cf::map::_create_random_map
		1139	$path,
		1140	$rmp->{wallstyle}, $rmp->{wall_name}, $rmp->{floorstyle}, $rmp->{monsterstyle},
		1141	$rmp->{treasurestyle}, $rmp->{layoutstyle}, $rmp->{doorstyle}, $rmp->{decorstyle},
		1142	$rmp->{origin_map}, $rmp->{final_map}, $rmp->{exitstyle}, $rmp->{this_map},
		1143	$rmp->{exit_on_final_map},
		1144	$rmp->{xsize}, $rmp->{ysize},
		1145	$rmp->{expand2x}, $rmp->{layoutoptions1}, $rmp->{layoutoptions2}, $rmp->{layoutoptions3},
		1146	$rmp->{symmetry}, $rmp->{difficulty}, $rmp->{difficulty_given}, $rmp->{difficulty_increase},
		1147	$rmp->{dungeon_level}, $rmp->{dungeon_depth}, $rmp->{decoroptions}, $rmp->{orientation},
		1148	$rmp->{origin_y}, $rmp->{origin_x}, $rmp->{random_seed}, $rmp->{total_map_hp},
		1149	$rmp->{map_layout_style}, $rmp->{treasureoptions}, $rmp->{symmetry_used},
		1150	(cf::region::find $rmp->{region})
		1151	}
		1152
		1153	# and all this just because we cannot iterate over
		1154	# all maps in C++...
		1155	sub change_all_map_light {
		1156	my ($change) = @_;
		1157
		1158	$_->change_map_light ($change)
		1159	for grep $_->outdoor, values %cf::MAP;
		1160	}
		1161
		1162	sub try_load_header($) {
		1163	my ($path) = @_;
		1164
		1165	utf8::encode $path;
		1166	aio_open $path, O_RDONLY, 0
		1167	or return;
		1168
		1169	my $map = cf::map::new
		1170	or return;
		1171
		1172	$map->load_header ($path)
		1173	or return;
		1174
		1175	$map->{load_path} = $path;
		1176
		1177	$map
		1178	}
		1179
		1180	sub find_map {
		1181	my ($path, $origin) = @_;
		1182
		1183	#warn "find_map<$path,$origin>\n";#d#
		1184
		1185	$path = new cf::path $path, $origin && $origin->path;
		1186	my $key = $path->as_string;
		1187
		1188	cf::lock_wait "map_find:$key";
		1189
		1190	$cf::MAP{$key} \|\| do {
		1191	my $guard = cf::lock_acquire "map_find:$key";
		1192
		1193	# do it the slow way
		1194	my $map = try_load_header $path->save_path;
		1195
		1196	if ($map) {
		1197	# safety
		1198	$map->{instantiate_time} = $cf::RUNTIME
		1199	if $map->{instantiate_time} > $cf::RUNTIME;
		1200	} else {
		1201	if (my $rmp = $path->random_map_params) {
		1202	$map = generate_random_map $key, $rmp;
		1203	} else {
		1204	$map = try_load_header $path->load_path;
		1205	}
		1206
		1207	$map or return;
		1208
		1209	$map->{load_original} = 1;
		1210	$map->{instantiate_time} = $cf::RUNTIME;
		1211	$map->instantiate;
		1212
		1213	# per-player maps become, after loading, normal maps
		1214	$map->per_player (0) if $path->{user_rel};
		1215	}
		1216
		1217	$map->path ($key);
		1218	$map->{path} = $path;
		1219	$map->{last_save} = $cf::RUNTIME;
		1220	$map->last_access ($cf::RUNTIME);
		1221
		1222	if ($map->should_reset) {
		1223	$map->reset;
		1224	undef $guard;
		1225	$map = find_map $path;
		1226	}
		1227
		1228	$cf::MAP{$key} = $map
		1229	}
		1230	}
		1231
		1232	sub load {
		1233	my ($self) = @_;
		1234
		1235	my $path = $self->{path};
		1236	my $guard = cf::lock_acquire "map_load:" . $path->as_string;
		1237
		1238	return if $self->in_memory != cf::MAP_SWAPPED;
		1239
		1240	$self->in_memory (cf::MAP_LOADING);
		1241
		1242	$self->alloc;
		1243	$self->load_objects ($self->{load_path}, 1)
		1244	or return;
		1245
		1246	$self->set_object_flag (cf::FLAG_OBJ_ORIGINAL, 1)
		1247	if delete $self->{load_original};
		1248
		1249	if (my $uniq = $path->uniq_path) {
		1250	utf8::encode $uniq;
		1251	if (aio_open $uniq, O_RDONLY, 0) {
		1252	$self->clear_unique_items;
		1253	$self->load_objects ($uniq, 0);
		1254	}
		1255	}
		1256
		1257	# now do the right thing for maps
		1258	$self->link_multipart_objects;
		1259
		1260	if ($self->{path}->is_style_map) {
		1261	$self->{deny_save} = 1;
		1262	$self->{deny_reset} = 1;
		1263	} else {
		1264	$self->fix_auto_apply;
		1265	$self->decay_objects;
		1266	$self->update_buttons;
		1267	$self->set_darkness_map;
		1268	$self->difficulty ($self->estimate_difficulty)
		1269	unless $self->difficulty;
		1270	$self->activate;
		1271	}
		1272
		1273	$self->in_memory (cf::MAP_IN_MEMORY);
		1274	}
		1275
		1276	sub load_map_sync {
		1277	my ($path, $origin) = @_;
		1278
		1279	#warn "load_map_sync<$path, $origin>\n";#d#
		1280
		1281	cf::sync_job {
		1282	my $map = cf::map::find_map $path, $origin
		1283	or return;
		1284	$map->load;
		1285	$map
		1286	}
		1287	}
		1288
		1289	sub save {
		1290	my ($self) = @_;
		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	if ($uniq) {
		1304	$self->save_objects ($save, cf::IO_HEADER \| cf::IO_OBJECTS);
		1305	$self->save_objects ($uniq, cf::IO_UNIQUES);
		1306	} else {
		1307	$self->save_objects ($save, cf::IO_HEADER \| cf::IO_OBJECTS \| cf::IO_UNIQUES);
		1308	}
		1309	}
		1310
		1311	sub swap_out {
		1312	my ($self) = @_;
		1313
		1314	return if $self->players;
		1315	return if $self->in_memory != cf::MAP_IN_MEMORY;
		1316	return if $self->{deny_save};
		1317
		1318	$self->save;
		1319	$self->clear;
		1320	$self->in_memory (cf::MAP_SWAPPED);
		1321	}
		1322
		1323	sub reset_at {
		1324	my ($self) = @_;
		1325
		1326	# TODO: safety, remove and allow resettable per-player maps
		1327	return 1e99 if $self->{path}{user_rel};
		1328	return 1e99 if $self->{deny_reset};
		1329
		1330	my $time = $self->fixed_resettime ? $self->{instantiate_time} : $self->last_access;
		1331	my $to = List::Util::min $MAX_RESET, $self->reset_timeout \|\| $DEFAULT_RESET;
		1332
		1333	$time + $to
		1334	}
		1335
		1336	sub should_reset {
		1337	my ($self) = @_;
		1338
		1339	$self->reset_at <= $cf::RUNTIME
		1340	}
		1341
		1342	sub unlink_save {
		1343	my ($self) = @_;
		1344
		1345	utf8::encode (my $save = $self->{path}->save_path);
		1346	aioreq_pri 3; IO::AIO::aio_unlink $save;
		1347	aioreq_pri 3; IO::AIO::aio_unlink "$save.pst";
		1348	}
		1349
		1350	sub rename {
		1351	my ($self, $new_path) = @_;
		1352
		1353	$self->unlink_save;
		1354
		1355	delete $cf::MAP{$self->path};
		1356	$self->{path} = new cf::path $new_path;
		1357	$self->path ($self->{path}->as_string);
		1358	$cf::MAP{$self->path} = $self;
		1359
		1360	$self->save;
		1361	}
		1362
		1363	sub reset {
		1364	my ($self) = @_;
		1365
		1366	return if $self->players;
		1367	return if $self->{path}{user_rel};#d#
		1368
		1369	warn "resetting map ", $self->path;#d#
		1370
		1371	delete $cf::MAP{$self->path};
		1372
		1373	$_->clear_links_to ($self) for values %cf::MAP;
		1374
		1375	$self->unlink_save;
		1376	$self->destroy;
		1377	}
		1378
		1379	my $nuke_counter = "aaaa";
		1380
		1381	sub nuke {
		1382	my ($self) = @_;
		1383
		1384	$self->{deny_save} = 1;
		1385	$self->reset_timeout (1);
		1386	$self->rename ("{nuke}/" . ($nuke_counter++));
		1387	$self->reset; # polite request, might not happen
		1388	}
		1389
		1390	sub customise_for {
		1391	my ($map, $ob) = @_;
		1392
		1393	if ($map->per_player) {
		1394	return cf::map::find_map "~" . $ob->name . "/" . $map->{path}{path};
		1395	}
		1396
		1397	$map
		1398	}
		1399
		1400	sub emergency_save {
		1401	local $cf::FREEZE = 1;
		1402
		1403	warn "enter emergency map save\n";
		1404
		1405	cf::sync_job {
		1406	warn "begin emergency map save\n";
		1407	$_->save for values %cf::MAP;
		1408	};
		1409
		1410	warn "end emergency map save\n";
		1411	}
		1412
		1413	package cf;
		1414
		1415	=back
		1416
		1417
851	=head3 cf::object::player	1418	=head3 cf::object::player
852		1419
853	=over 4	1420	=over 4
854		1421
855	=item $player_object->reply ($npc, $msg[, $flags])	1422	=item $player_object->reply ($npc, $msg[, $flags])
…		…
888		1455
889	$self->flag (cf::FLAG_WIZ) \|\|	1456	$self->flag (cf::FLAG_WIZ) \|\|
890	(ref $cf::CFG{"may_$access"}	1457	(ref $cf::CFG{"may_$access"}
891	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}	1458	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}
892	: $cf::CFG{"may_$access"})	1459	: $cf::CFG{"may_$access"})
		1460	}
		1461
		1462	=item $player_object->enter_link
		1463
		1464	Freezes the player and moves him/her to a special map (C<{link}>).
		1465
		1466	The player should be reaosnably safe there for short amounts of time. You
		1467	I<MUST> call C<leave_link> as soon as possible, though.
		1468
		1469	=item $player_object->leave_link ($map, $x, $y)
		1470
		1471	Moves the player out of the specila link map onto the given map. If the
		1472	map is not valid (or omitted), the player will be moved back to the
		1473	location he/she was before the call to C<enter_link>, or, if that fails,
		1474	to the emergency map position.
		1475
		1476	Might block.
		1477
		1478	=cut
		1479
		1480	sub cf::object::player::enter_link {
		1481	my ($self) = @_;
		1482
		1483	$self->deactivate_recursive;
		1484
		1485	return if $self->map == $LINK_MAP;
		1486
		1487	$self->{_link_pos} \|\|= [$self->map->{path}, $self->x, $self->y]
		1488	if $self->map;
		1489
		1490	$self->enter_map ($LINK_MAP, 20, 20);
		1491	}
		1492
		1493	sub cf::object::player::leave_link {
		1494	my ($self, $map, $x, $y) = @_;
		1495
		1496	my $link_pos = delete $self->{_link_pos};
		1497
		1498	unless ($map) {
		1499	# restore original map position
		1500	($map, $x, $y) = @{ $link_pos \|\| [] };
		1501	$map = cf::map::find_map $map;
		1502
		1503	unless ($map) {
		1504	($map, $x, $y) = @$EMERGENCY_POSITION;
		1505	$map = cf::map::find_map $map
		1506	or die "FATAL: cannot load emergency map\n";
		1507	}
		1508	}
		1509
		1510	($x, $y) = (-1, -1)
		1511	unless (defined $x) && (defined $y);
		1512
		1513	# use -1 or undef as default coordinates, not 0, 0
		1514	($x, $y) = ($map->enter_x, $map->enter_y)
		1515	if $x <=0 && $y <= 0;
		1516
		1517	$map->load;
		1518
		1519	$self->activate_recursive;
		1520	$self->enter_map ($map, $x, $y);
		1521	}
		1522
		1523	cf::player->attach (
		1524	on_logout => sub {
		1525	my ($pl) = @_;
		1526
		1527	# abort map switching before logout
		1528	if ($pl->ob->{_link_pos}) {
		1529	cf::sync_job {
		1530	$pl->ob->leave_link
		1531	};
		1532	}
		1533	},
		1534	on_login => sub {
		1535	my ($pl) = @_;
		1536
		1537	# try to abort aborted map switching on player login :)
		1538	# should happen only on crashes
		1539	if ($pl->ob->{_link_pos}) {
		1540	$pl->ob->enter_link;
		1541	Coro::async {
		1542	# we need this sleep as the login has a concurrent enter_exit running
		1543	# and this sleep increases chances of the player not ending up in scorn
		1544	Coro::Timer::sleep 1;
		1545	$pl->ob->leave_link;
		1546	};
		1547	}
		1548	},
		1549	);
		1550
		1551	=item $player_object->goto_map ($path, $x, $y)
		1552
		1553	=cut
		1554
		1555	sub cf::object::player::goto_map {
		1556	my ($self, $path, $x, $y) = @_;
		1557
		1558	$self->enter_link;
		1559
		1560	(Coro::async {
		1561	$path = new cf::path $path;
		1562
		1563	my $map = cf::map::find_map $path->as_string;
		1564	$map = $map->customise_for ($self) if $map;
		1565
		1566	# warn "entering ", $map->path, " at ($x, $y)\n"
		1567	# if $map;
		1568
		1569	$map or $self->message ("The exit is closed", cf::NDI_UNIQUE \| cf::NDI_RED);
		1570
		1571	$self->leave_link ($map, $x, $y);
		1572	})->prio (1);
		1573	}
		1574
		1575	=item $player_object->enter_exit ($exit_object)
		1576
		1577	=cut
		1578
		1579	sub parse_random_map_params {
		1580	my ($spec) = @_;
		1581
		1582	my $rmp = { # defaults
		1583	xsize => 10,
		1584	ysize => 10,
		1585	};
		1586
		1587	for (split /\n/, $spec) {
		1588	my ($k, $v) = split /\s+/, $_, 2;
		1589
		1590	$rmp->{lc $k} = $v if (length $k) && (length $v);
		1591	}
		1592
		1593	$rmp
		1594	}
		1595
		1596	sub prepare_random_map {
		1597	my ($exit) = @_;
		1598
		1599	# all this does is basically replace the /! path by
		1600	# a new random map path (?random/...) with a seed
		1601	# that depends on the exit object
		1602
		1603	my $rmp = parse_random_map_params $exit->msg;
		1604
		1605	if ($exit->map) {
		1606	$rmp->{region} = $exit->map->region_name;
		1607	$rmp->{origin_map} = $exit->map->path;
		1608	$rmp->{origin_x} = $exit->x;
		1609	$rmp->{origin_y} = $exit->y;
		1610	}
		1611
		1612	$rmp->{random_seed} \|\|= $exit->random_seed;
		1613
		1614	my $data = cf::to_json $rmp;
		1615	my $md5 = Digest::MD5::md5_hex $data;
		1616
		1617	if (my $fh = aio_open "$cf::RANDOM_MAPS/$md5.meta", O_WRONLY \| O_CREAT, 0666) {
		1618	aio_write $fh, 0, (length $data), $data, 0;
		1619
		1620	$exit->slaying ("?random/$md5");
		1621	$exit->msg (undef);
		1622	}
		1623	}
		1624
		1625	sub cf::object::player::enter_exit {
		1626	my ($self, $exit) = @_;
		1627
		1628	return unless $self->type == cf::PLAYER;
		1629
		1630	$self->enter_link;
		1631
		1632	(Coro::async {
		1633	unless (eval {
		1634
		1635	prepare_random_map $exit
		1636	if $exit->slaying eq "/!";
		1637
		1638	my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;
		1639	$self->goto_map ($path, $exit->stats->hp, $exit->stats->sp);
		1640
		1641	1;
		1642	}) {
		1643	$self->message ("Something went wrong deep within the crossfire server. "
		1644	. "I'll try to bring you back to the map you were before. "
		1645	. "Please report this to the dungeon master",
		1646	cf::NDI_UNIQUE \| cf::NDI_RED);
		1647
		1648	warn "ERROR in enter_exit: $@";
		1649	$self->leave_link;
		1650	}
		1651	})->prio (1);
893	}	1652	}
894		1653
895	=head3 cf::client	1654	=head3 cf::client
896		1655
897	=over 4	1656	=over 4
…		…
1156		1915
1157	{	1916	{
1158	my $path = cf::localdir . "/database.pst";	1917	my $path = cf::localdir . "/database.pst";
1159		1918
1160	sub db_load() {	1919	sub db_load() {
1161	warn "loading database $path\n";#d# remove later
1162	$DB = stat $path ? Storable::retrieve $path : { };	1920	$DB = stat $path ? Storable::retrieve $path : { };
1163	}	1921	}
1164		1922
1165	my $pid;	1923	my $pid;
1166		1924
1167	sub db_save() {	1925	sub db_save() {
1168	warn "saving database $path\n";#d# remove later
1169	waitpid $pid, 0 if $pid;	1926	waitpid $pid, 0 if $pid;
1170	if (0 == ($pid = fork)) {	1927	if (0 == ($pid = fork)) {
1171	$DB->{_meta}{version} = 1;	1928	$DB->{_meta}{version} = 1;
1172	Storable::nstore $DB, "$path~";	1929	Storable::nstore $DB, "$path~";
1173	rename "$path~", $path;	1930	rename "$path~", $path;
…		…
1224	local $/;	1981	local $/;
1225	*CFG = YAML::Syck::Load <$fh>;	1982	*CFG = YAML::Syck::Load <$fh>;
1226	}	1983	}
1227		1984
1228	sub main {	1985	sub main {
		1986	# we must not ever block the main coroutine
		1987	local $Coro::idle = sub {
		1988	Carp::cluck "FATAL: Coro::idle was called, major BUG, use cf::sync_job!\n";#d#
		1989	(Coro::unblock_sub {
		1990	Event::one_event;
		1991	})->();
		1992	};
		1993
1229	cfg_load;	1994	cfg_load;
1230	db_load;	1995	db_load;
1231	load_extensions;	1996	load_extensions;
1232	Event::loop;	1997	Event::loop;
1233	}	1998	}
1234		1999
1235	#############################################################################	2000	#############################################################################
1236	# initialisation	2001	# initialisation
1237		2002
1238	sub _perl_reload() {	2003	sub reload() {
		2004	# can/must only be called in main
		2005	if ($Coro::current != $Coro::main) {
		2006	warn "can only reload from main coroutine\n";
		2007	return;
		2008	}
		2009
1239	warn "reloading...";	2010	warn "reloading...";
1240		2011
		2012	local $FREEZE = 1;
		2013	cf::emergency_save;
		2014
1241	eval {	2015	eval {
1242	local $FREEZE = 1;	2016	# if anything goes wrong in here, we should simply crash as we already saved
1243
1244	cf::emergency_save;
1245		2017
1246	# cancel all watchers	2018	# cancel all watchers
1247	for (Event::all_watchers) {	2019	for (Event::all_watchers) {
1248	$_->cancel if $_->data & WF_AUTOCANCEL;	2020	$_->cancel if $_->data & WF_AUTOCANCEL;
1249	}	2021	}
…		…
1308		2080
1309	# reattach attachments to objects	2081	# reattach attachments to objects
1310	warn "reattach";	2082	warn "reattach";
1311	_global_reattach;	2083	_global_reattach;
1312	};	2084	};
1313	warn $@ if $@;
1314		2085
1315	warn "reloaded";	2086	if ($@) {
		2087	warn $@;
		2088	warn "error while reloading, exiting.";
		2089	exit 1;
		2090	}
		2091
		2092	warn "reloaded successfully";
1316	};	2093	};
1317		2094
1318	sub perl_reload() {	2095	#############################################################################
1319	_perl_reload;	2096
		2097	unless ($LINK_MAP) {
		2098	$LINK_MAP = cf::map::new;
		2099
		2100	$LINK_MAP->width (41);
		2101	$LINK_MAP->height (41);
		2102	$LINK_MAP->alloc;
		2103	$LINK_MAP->path ("{link}");
		2104	$LINK_MAP->{path} = bless { path => "{link}" }, "cf::path";
		2105	$LINK_MAP->in_memory (MAP_IN_MEMORY);
		2106
		2107	# dirty hack because... archetypes are not yet loaded
		2108	Event->timer (
		2109	after => 2,
		2110	cb => sub {
		2111	$_[0]->w->cancel;
		2112
		2113	# provide some exits "home"
		2114	my $exit = cf::object::new "exit";
		2115
		2116	$exit->slaying ($EMERGENCY_POSITION->[0]);
		2117	$exit->stats->hp ($EMERGENCY_POSITION->[1]);
		2118	$exit->stats->sp ($EMERGENCY_POSITION->[2]);
		2119
		2120	$LINK_MAP->insert ($exit->clone, 19, 19);
		2121	$LINK_MAP->insert ($exit->clone, 19, 20);
		2122	$LINK_MAP->insert ($exit->clone, 19, 21);
		2123	$LINK_MAP->insert ($exit->clone, 20, 19);
		2124	$LINK_MAP->insert ($exit->clone, 20, 21);
		2125	$LINK_MAP->insert ($exit->clone, 21, 19);
		2126	$LINK_MAP->insert ($exit->clone, 21, 20);
		2127	$LINK_MAP->insert ($exit->clone, 21, 21);
		2128
		2129	$exit->destroy;
		2130	});
		2131
		2132	$LINK_MAP->{deny_save} = 1;
		2133	$LINK_MAP->{deny_reset} = 1;
		2134
		2135	$cf::MAP{$LINK_MAP->path} = $LINK_MAP;
1320	}	2136	}
1321		2137
1322	register "<global>", __PACKAGE__;	2138	register "<global>", __PACKAGE__;
1323		2139
1324	register_command "perl-reload" => sub {	2140	register_command "reload" => sub {
1325	my ($who, $arg) = @_;	2141	my ($who, $arg) = @_;
1326		2142
1327	if ($who->flag (FLAG_WIZ)) {	2143	if ($who->flag (FLAG_WIZ)) {
		2144	$who->message ("start of reload.");
		2145	reload;
1328	$who->message ("reloading...");	2146	$who->message ("end of reload.");
1329	_perl_reload;
1330	}	2147	}
1331	};	2148	};
1332		2149
1333	unshift @INC, $LIBDIR;	2150	unshift @INC, $LIBDIR;
1334		2151
…		…
1353	},	2170	},
1354	);	2171	);
1355		2172
1356	IO::AIO::max_poll_time $TICK * 0.2;	2173	IO::AIO::max_poll_time $TICK * 0.2;
1357		2174
		2175	Event->io (
1358	Event->io (fd => IO::AIO::poll_fileno,	2176	fd => IO::AIO::poll_fileno,
1359	poll => 'r',	2177	poll => 'r',
1360	prio => 5,	2178	prio => 5,
1361	data => WF_AUTOCANCEL,	2179	data => WF_AUTOCANCEL,
1362	cb => \&IO::AIO::poll_cb);	2180	cb => \&IO::AIO::poll_cb,
		2181	);
1363		2182
1364	# we must not ever block the main coroutine	2183	Event->timer (
1365	$Coro::idle = sub {	2184	data => WF_AUTOCANCEL,
1366	#Carp::cluck "FATAL: Coro::idle was called, major BUG\n";#d#	2185	after => 0,
1367	warn "FATAL: Coro::idle was called, major BUG\n";	2186	interval => 10,
		2187	cb => sub {
1368	(Coro::unblock_sub {	2188	(Coro::unblock_sub {
1369	Event::one_event;	2189	write_runtime
		2190	or warn "ERROR: unable to write runtime file: $!";
1370	})->();	2191	})->();
1371	};	2192	},
		2193	);
1372		2194
1373	1	2195	1
1374		2196

Diff Legend

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

Comparing deliantra/server/lib/cf.pm (file contents): Revision 1.104 by root, Sat Dec 30 16:56:16 2006 UTC vs. Revision 1.123 by root, Tue Jan 2 19:18:33 2007 UTC

Diff Legend

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.104 by root, Sat Dec 30 16:56:16 2006 UTC vs.
Revision 1.123 by root, Tue Jan 2 19:18:33 2007 UTC