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

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.108 by root, Sun Dec 31 21:02:05 2006 UTC vs.
Revision 1.134 by root, Thu Jan 4 17:28:49 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	use Coro::AIO;
…		…
49	our $UPTIME; $UPTIME \|\|= time;	49	our $UPTIME; $UPTIME \|\|= time;
50	our $RUNTIME;	50	our $RUNTIME;
51		51
52	our %MAP; # all maps	52	our %MAP; # all maps
53	our $LINK_MAP; # the special {link} map	53	our $LINK_MAP; # the special {link} map
54	our $FREEZE;
55	our $RANDOM_MAPS = cf::localdir . "/random";	54	our $RANDOM_MAPS = cf::localdir . "/random";
56	our %EXT_CORO;	55	our %EXT_CORO;
57		56
58	binmode STDOUT;	57	binmode STDOUT;
59	binmode STDERR;	58	binmode STDERR;
…		…
71	mkdir cf::localdir . "/" . cf::uniquedir;	70	mkdir cf::localdir . "/" . cf::uniquedir;
72	mkdir $RANDOM_MAPS;	71	mkdir $RANDOM_MAPS;
73		72
74	# a special map that is always available	73	# a special map that is always available
75	our $LINK_MAP;	74	our $LINK_MAP;
		75	our $EMERGENCY_POSITION;
76		76
77	#############################################################################	77	#############################################################################
78		78
79	=head2 GLOBAL VARIABLES	79	=head2 GLOBAL VARIABLES
80		80
…		…
179	sub to_json($) {	179	sub to_json($) {
180	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs	180	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs
181	JSON::Syck::Dump $_[0]	181	JSON::Syck::Dump $_[0]
182	}	182	}
183		183
		184	=item my $guard = cf::guard { BLOCK }
		185
		186	Run the given callback when the guard object gets destroyed (useful for
		187	coroutine cancellations).
		188
		189	You can call C<< ->cancel >> on the guard object to stop the block from
		190	being executed.
		191
		192	=cut
		193
		194	sub guard(&) {
		195	bless \(my $cb = $_[0]), cf::guard::;
		196	}
		197
		198	sub cf::guard::cancel {
		199	${$_[0]} = sub { };
		200	}
		201
		202	sub cf::guard::DESTROY {
		203	${$_[0]}->();
		204	}
		205
		206	=item cf::lock_wait $string
		207
		208	Wait until the given lock is available. See cf::lock_acquire.
		209
		210	=item my $lock = cf::lock_acquire $string
		211
		212	Wait until the given lock is available and then acquires it and returns
		213	a guard object. If the guard object gets destroyed (goes out of scope,
		214	for example when the coroutine gets canceled), the lock is automatically
		215	returned.
		216
		217	Lock names should begin with a unique identifier (for example, cf::map::find
		218	uses map_find and cf::map::load uses map_load).
		219
		220	=cut
		221
		222	our %LOCK;
		223
		224	sub lock_wait($) {
		225	my ($key) = @_;
		226
		227	# wait for lock, if any
		228	while ($LOCK{$key}) {
		229	push @{ $LOCK{$key} }, $Coro::current;
		230	Coro::schedule;
		231	}
		232	}
		233
		234	sub lock_acquire($) {
		235	my ($key) = @_;
		236
		237	# wait, to be sure we are not locked
		238	lock_wait $key;
		239
		240	$LOCK{$key} = [];
		241
		242	cf::guard {
		243	# wake up all waiters, to be on the safe side
		244	$_->ready for @{ delete $LOCK{$key} };
		245	}
		246	}
		247
		248	=item cf::async { BLOCK }
		249
		250	Like C<Coro::async>, but runs the given BLOCK in an eval and only logs the
		251	error instead of exiting the server in case of a problem.
		252
		253	=cut
		254
		255	sub async(&) {
		256	my ($cb) = @_;
		257
		258	Coro::async {
		259	eval { $cb->() };
		260	warn $@ if $@;
		261	}
		262	}
		263
		264	sub freeze_mainloop {
		265	return unless $TICK_WATCHER->is_active;
		266
		267	my $guard = guard { $TICK_WATCHER->start };
		268	$TICK_WATCHER->stop;
		269	$guard
		270	}
		271
184	=item cf::sync_job { BLOCK }	272	=item cf::sync_job { BLOCK }
185		273
186	The design of crossfire+ requires that the main coro ($Coro::main) is	274	The design of crossfire+ requires that the main coro ($Coro::main) is
187	always able to handle events or runnable, as crossfire+ is only partly	275	always able to handle events or runnable, as crossfire+ is only partly
188	reentrant. Thus "blocking" it by e.g. waiting for I/O is not acceptable.	276	reentrant. Thus "blocking" it by e.g. waiting for I/O is not acceptable.
…		…
195	=cut	283	=cut
196		284
197	sub sync_job(&) {	285	sub sync_job(&) {
198	my ($job) = @_;	286	my ($job) = @_;
199		287
200	my $busy = 1;
201	my @res;
202
203	# TODO: use suspend/resume instead
204	local $FREEZE = 1;
205
206	my $coro = Coro::async {
207	@res = eval { $job->() };
208	warn $@ if $@;
209	undef $busy;
210	};
211
212	if ($Coro::current == $Coro::main) {	288	if ($Coro::current == $Coro::main) {
		289	# this is the main coro, too bad, we have to block
		290	# till the operation succeeds, freezing the server :/
		291
		292	# TODO: use suspend/resume instead
		293	# (but this is cancel-safe)
		294	my $freeze_guard = freeze_mainloop;
		295
		296	my $busy = 1;
		297	my @res;
		298
		299	(Coro::async {
		300	@res = eval { $job->() };
		301	warn $@ if $@;
		302	undef $busy;
213	$coro->prio (Coro::PRIO_MAX);	303	})->prio (Coro::PRIO_MAX);
		304
214	while ($busy) {	305	while ($busy) {
215	Coro::cede_notself;	306	Coro::cede_notself;
216	Event::one_event unless Coro::nready;	307	Event::one_event unless Coro::nready;
217	}	308	}
		309
		310	wantarray ? @res : $res[0]
218	} else {	311	} else {
219	$coro->join;	312	# we are in another coroutine, how wonderful, everything just works
		313
		314	$job->()
220	}	315	}
221
222	wantarray ? @res : $res[0]
223	}	316	}
224		317
225	=item $coro = cf::coro { BLOCK }	318	=item $coro = cf::coro { BLOCK }
226		319
227	Creates and returns a new coro. This coro is automcatially being canceled	320	Creates and returns a new coro. This coro is automcatially being canceled
…		…
230	=cut	323	=cut
231		324
232	sub coro(&) {	325	sub coro(&) {
233	my $cb = shift;	326	my $cb = shift;
234		327
235	my $coro; $coro = async {	328	my $coro = &cf::async ($cb);
236	eval {
237	$cb->();
238	};
239	warn $@ if $@;
240	};
241		329
242	$coro->on_destroy (sub {	330	$coro->on_destroy (sub {
243	delete $EXT_CORO{$coro+0};	331	delete $EXT_CORO{$coro+0};
244	});	332	});
245	$EXT_CORO{$coro+0} = $coro;	333	$EXT_CORO{$coro+0} = $coro;
…		…
251	my $runtime = cf::localdir . "/runtime";	339	my $runtime = cf::localdir . "/runtime";
252		340
253	my $fh = aio_open "$runtime~", O_WRONLY \| O_CREAT, 0644	341	my $fh = aio_open "$runtime~", O_WRONLY \| O_CREAT, 0644
254	or return;	342	or return;
255		343
256	my $value = $cf::RUNTIME;	344	my $value = $cf::RUNTIME + 1 + 10; # 10 is the runtime save interval, for a monotonic clock
257	(aio_write $fh, 0, (length $value), $value, 0) <= 0	345	(aio_write $fh, 0, (length $value), $value, 0) <= 0
258	and return;	346	and return;
259		347
260	aio_fsync $fh	348	aio_fsync $fh
261	and return;	349	and return;
…		…
278	package cf::path;	366	package cf::path;
279		367
280	sub new {	368	sub new {
281	my ($class, $path, $base) = @_;	369	my ($class, $path, $base) = @_;
282		370
		371	$path = $path->as_string if ref $path;
		372
283	my $self = bless { }, $class;	373	my $self = bless { }, $class;
284		374
		375	# {... are special paths that are not touched
		376	# ?xxx/... are special absolute paths
		377	# ?random/... random maps
		378	# /! non-realised random map exit
		379	# /... normal maps
		380	# ~/... per-player maps without a specific player (DO NOT USE)
		381	# ~user/... per-player map of a specific user
		382
		383	if ($path =~ /^{/) {
		384	# fine as it is
285	if ($path =~ s{^\?random/}{}) {	385	} elsif ($path =~ s{^\?random/}{}) {
		386	Coro::AIO::aio_load "$cf::RANDOM_MAPS/$path.meta", my $data;
286	$self->{random} = cf::from_json $path;	387	$self->{random} = cf::from_json $data;
287	} else {	388	} else {
288	if ($path =~ s{^~([^/]+)?}{}) {	389	if ($path =~ s{^~([^/]+)?}{}) {
289	$self->{user_rel} = 1;	390	$self->{user_rel} = 1;
290		391
291	if (defined $1) {	392	if (defined $1) {
…		…
324		425
325	# the displayed name, this is a one way mapping	426	# the displayed name, this is a one way mapping
326	sub visible_name {	427	sub visible_name {
327	my ($self) = @_;	428	my ($self) = @_;
328		429
329	$self->{random} ? "?random/$self->{random}{origin_map}+$self->{random}{origin_x}+$self->{random}{origin_y}/$self->{random}{dungeon_level}"	430	# if (my $rmp = $self->{random}) {
330	: $self->as_string	431	# # todo: be more intelligent about this
		432	# "?random/$rmp->{origin_map}+$rmp->{origin_x}+$rmp->{origin_y}/$rmp->{dungeon_level}"
		433	# } else {
		434	$self->as_string
		435	# }
331	}	436	}
332		437
333	# escape the /'s in the path	438	# escape the /'s in the path
334	sub _escaped_path {	439	sub _escaped_path {
335	# ∕ is U+2215	440	# ∕ is U+2215
…		…
347	# the temporary/swap location	452	# the temporary/swap location
348	sub save_path {	453	sub save_path {
349	my ($self) = @_;	454	my ($self) = @_;
350		455
351	$self->{user_rel} ? sprintf "%s/%s/%s/%s", cf::localdir, cf::playerdir, $self->{user}, $self->_escaped_path	456	$self->{user_rel} ? sprintf "%s/%s/%s/%s", cf::localdir, cf::playerdir, $self->{user}, $self->_escaped_path
352	: $self->{random} ? sprintf "%s/%s", $RANDOM_MAPS, Digest::MD5::md5_hex $self->{path}	457	: $self->{random} ? sprintf "%s/%s", $RANDOM_MAPS, $self->{path}
353	: sprintf "%s/%s/%s", cf::localdir, cf::tmpdir, $self->_escaped_path	458	: sprintf "%s/%s/%s", cf::localdir, cf::tmpdir, $self->_escaped_path
354	}	459	}
355		460
356	# the unique path, might be eq to save_path	461	# the unique path, might be eq to save_path
357	sub uniq_path {	462	sub uniq_path {
…		…
790	or return;	895	or return;
791		896
792	unless (aio_stat "$filename.pst") {	897	unless (aio_stat "$filename.pst") {
793	(aio_load "$filename.pst", $av) >= 0	898	(aio_load "$filename.pst", $av) >= 0
794	or return;	899	or return;
795	$av = eval { (Storable::thaw <$av>)->{objs} };	900	$av = eval { (Storable::thaw $av)->{objs} };
796	}	901	}
797		902
		903	warn sprintf "loading %s (%d)\n",
		904	$filename, length $data, scalar @{$av \|\| []};#d#
798	return ($data, $av);	905	return ($data, $av);
799	}	906	}
800		907
801	#############################################################################	908	#############################################################################
802	# command handling &c	909	# command handling &c
…		…
1024	$self->send ("ext " . to_json \%msg);	1131	$self->send ("ext " . to_json \%msg);
1025	}	1132	}
1026		1133
1027	=back	1134	=back
1028		1135
		1136
		1137	=head3 cf::map
		1138
		1139	=over 4
		1140
		1141	=cut
		1142
		1143	package cf::map;
		1144
		1145	use Fcntl;
		1146	use Coro::AIO;
		1147
		1148	our $MAX_RESET = 3600;
		1149	our $DEFAULT_RESET = 3000;
		1150
		1151	sub generate_random_map {
		1152	my ($path, $rmp) = @_;
		1153
		1154	# mit "rum" bekleckern, nicht
		1155	cf::map::_create_random_map
		1156	$path,
		1157	$rmp->{wallstyle}, $rmp->{wall_name}, $rmp->{floorstyle}, $rmp->{monsterstyle},
		1158	$rmp->{treasurestyle}, $rmp->{layoutstyle}, $rmp->{doorstyle}, $rmp->{decorstyle},
		1159	$rmp->{origin_map}, $rmp->{final_map}, $rmp->{exitstyle}, $rmp->{this_map},
		1160	$rmp->{exit_on_final_map},
		1161	$rmp->{xsize}, $rmp->{ysize},
		1162	$rmp->{expand2x}, $rmp->{layoutoptions1}, $rmp->{layoutoptions2}, $rmp->{layoutoptions3},
		1163	$rmp->{symmetry}, $rmp->{difficulty}, $rmp->{difficulty_given}, $rmp->{difficulty_increase},
		1164	$rmp->{dungeon_level}, $rmp->{dungeon_depth}, $rmp->{decoroptions}, $rmp->{orientation},
		1165	$rmp->{origin_y}, $rmp->{origin_x}, $rmp->{random_seed}, $rmp->{total_map_hp},
		1166	$rmp->{map_layout_style}, $rmp->{treasureoptions}, $rmp->{symmetry_used},
		1167	(cf::region::find $rmp->{region})
		1168	}
		1169
		1170	# and all this just because we cannot iterate over
		1171	# all maps in C++...
		1172	sub change_all_map_light {
		1173	my ($change) = @_;
		1174
		1175	$_->change_map_light ($change)
		1176	for grep $_->outdoor, values %cf::MAP;
		1177	}
		1178
		1179	sub try_load_header($) {
		1180	my ($path) = @_;
		1181
		1182	utf8::encode $path;
		1183	aio_open $path, O_RDONLY, 0
		1184	or return;
		1185
		1186	my $map = cf::map::new
		1187	or return;
		1188
		1189	$map->load_header ($path)
		1190	or return;
		1191
		1192	$map->{load_path} = $path;
		1193
		1194	$map
		1195	}
		1196
		1197	sub find;
		1198	sub find {
		1199	my ($path, $origin) = @_;
		1200
		1201	#warn "find<$path,$origin>\n";#d#
		1202
		1203	$path = new cf::path $path, $origin && $origin->path;
		1204	my $key = $path->as_string;
		1205
		1206	cf::lock_wait "map_find:$key";
		1207
		1208	$cf::MAP{$key} \|\| do {
		1209	my $guard = cf::lock_acquire "map_find:$key";
		1210
		1211	# do it the slow way
		1212	my $map = try_load_header $path->save_path;
		1213
		1214	Coro::cede;
		1215
		1216	if ($map) {
		1217	$map->last_access ((delete $map->{last_access})
		1218	\|\| $cf::RUNTIME); #d#
		1219	# safety
		1220	$map->{instantiate_time} = $cf::RUNTIME
		1221	if $map->{instantiate_time} > $cf::RUNTIME;
		1222	} else {
		1223	if (my $rmp = $path->random_map_params) {
		1224	$map = generate_random_map $key, $rmp;
		1225	} else {
		1226	$map = try_load_header $path->load_path;
		1227	}
		1228
		1229	$map or return;
		1230
		1231	$map->{load_original} = 1;
		1232	$map->{instantiate_time} = $cf::RUNTIME;
		1233	$map->last_access ($cf::RUNTIME);
		1234	$map->instantiate;
		1235
		1236	# per-player maps become, after loading, normal maps
		1237	$map->per_player (0) if $path->{user_rel};
		1238	}
		1239
		1240	$map->path ($key);
		1241	$map->{path} = $path;
		1242	$map->{last_save} = $cf::RUNTIME;
		1243
		1244	Coro::cede;
		1245
		1246	if ($map->should_reset) {
		1247	$map->reset;
		1248	undef $guard;
		1249	$map = find $path
		1250	or return;
		1251	}
		1252
		1253	$cf::MAP{$key} = $map
		1254	}
		1255	}
		1256
		1257	sub load {
		1258	my ($self) = @_;
		1259
		1260	my $path = $self->{path};
		1261	my $guard = cf::lock_acquire "map_load:" . $path->as_string;
		1262
		1263	return if $self->in_memory != cf::MAP_SWAPPED;
		1264
		1265	$self->in_memory (cf::MAP_LOADING);
		1266
		1267	$self->alloc;
		1268	$self->load_objects ($self->{load_path}, 1)
		1269	or return;
		1270
		1271	$self->set_object_flag (cf::FLAG_OBJ_ORIGINAL, 1)
		1272	if delete $self->{load_original};
		1273
		1274	if (my $uniq = $path->uniq_path) {
		1275	utf8::encode $uniq;
		1276	if (aio_open $uniq, O_RDONLY, 0) {
		1277	$self->clear_unique_items;
		1278	$self->load_objects ($uniq, 0);
		1279	}
		1280	}
		1281
		1282	Coro::cede;
		1283
		1284	# now do the right thing for maps
		1285	$self->link_multipart_objects;
		1286
		1287	if ($self->{path}->is_style_map) {
		1288	$self->{deny_save} = 1;
		1289	$self->{deny_reset} = 1;
		1290	} else {
		1291	$self->fix_auto_apply;
		1292	$self->decay_objects;
		1293	$self->update_buttons;
		1294	$self->set_darkness_map;
		1295	$self->difficulty ($self->estimate_difficulty)
		1296	unless $self->difficulty;
		1297	$self->activate;
		1298	}
		1299
		1300	Coro::cede;
		1301
		1302	$self->in_memory (cf::MAP_IN_MEMORY);
		1303	}
		1304
		1305	sub find_sync {
		1306	my ($path, $origin) = @_;
		1307
		1308	cf::sync_job { cf::map::find $path, $origin }
		1309	}
		1310
		1311	sub do_load_sync {
		1312	my ($map) = @_;
		1313
		1314	cf::sync_job { $map->load };
		1315	}
		1316
		1317	sub save {
		1318	my ($self) = @_;
		1319
		1320	$self->{last_save} = $cf::RUNTIME;
		1321
		1322	return unless $self->dirty;
		1323
		1324	my $save = $self->{path}->save_path; utf8::encode $save;
		1325	my $uniq = $self->{path}->uniq_path; utf8::encode $uniq;
		1326
		1327	$self->{load_path} = $save;
		1328
		1329	return if $self->{deny_save};
		1330
		1331	local $self->{last_access} = $self->last_access;#d#
		1332
		1333	if ($uniq) {
		1334	$self->save_objects ($save, cf::IO_HEADER \| cf::IO_OBJECTS);
		1335	$self->save_objects ($uniq, cf::IO_UNIQUES);
		1336	} else {
		1337	$self->save_objects ($save, cf::IO_HEADER \| cf::IO_OBJECTS \| cf::IO_UNIQUES);
		1338	}
		1339	}
		1340
		1341	sub swap_out {
		1342	my ($self) = @_;
		1343
		1344	# save first because save cedes
		1345	$self->save;
		1346
		1347	return if $self->players;
		1348	return if $self->in_memory != cf::MAP_IN_MEMORY;
		1349	return if $self->{deny_save};
		1350
		1351	$self->clear;
		1352	$self->in_memory (cf::MAP_SWAPPED);
		1353	}
		1354
		1355	sub reset_at {
		1356	my ($self) = @_;
		1357
		1358	# TODO: safety, remove and allow resettable per-player maps
		1359	return 1e99 if $self->{path}{user_rel};
		1360	return 1e99 if $self->{deny_reset};
		1361
		1362	my $time = $self->fixed_resettime ? $self->{instantiate_time} : $self->last_access;
		1363	my $to = List::Util::min $MAX_RESET, $self->reset_timeout \|\| $DEFAULT_RESET;
		1364
		1365	$time + $to
		1366	}
		1367
		1368	sub should_reset {
		1369	my ($self) = @_;
		1370
		1371	$self->reset_at <= $cf::RUNTIME
		1372	}
		1373
		1374	sub unlink_save {
		1375	my ($self) = @_;
		1376
		1377	utf8::encode (my $save = $self->{path}->save_path);
		1378	aioreq_pri 3; IO::AIO::aio_unlink $save;
		1379	aioreq_pri 3; IO::AIO::aio_unlink "$save.pst";
		1380	}
		1381
		1382	sub rename {
		1383	my ($self, $new_path) = @_;
		1384
		1385	$self->unlink_save;
		1386
		1387	delete $cf::MAP{$self->path};
		1388	$self->{path} = new cf::path $new_path;
		1389	$self->path ($self->{path}->as_string);
		1390	$cf::MAP{$self->path} = $self;
		1391
		1392	$self->save;
		1393	}
		1394
		1395	sub reset {
		1396	my ($self) = @_;
		1397
		1398	return if $self->players;
		1399	return if $self->{path}{user_rel};#d#
		1400
		1401	warn "resetting map ", $self->path;#d#
		1402
		1403	delete $cf::MAP{$self->path};
		1404
		1405	$_->clear_links_to ($self) for values %cf::MAP;
		1406
		1407	$self->unlink_save;
		1408	$self->destroy;
		1409	}
		1410
		1411	my $nuke_counter = "aaaa";
		1412
		1413	sub nuke {
		1414	my ($self) = @_;
		1415
		1416	$self->{deny_save} = 1;
		1417	$self->reset_timeout (1);
		1418	$self->rename ("{nuke}/" . ($nuke_counter++));
		1419	$self->reset; # polite request, might not happen
		1420	}
		1421
		1422	sub customise_for {
		1423	my ($map, $ob) = @_;
		1424
		1425	if ($map->per_player) {
		1426	return cf::map::find "~" . $ob->name . "/" . $map->{path}{path};
		1427	}
		1428
		1429	$map
		1430	}
		1431
		1432	sub emergency_save {
		1433	my $freeze_guard = cf::freeze_mainloop;
		1434
		1435	warn "enter emergency map save\n";
		1436
		1437	cf::sync_job {
		1438	warn "begin emergency map save\n";
		1439	$_->save for values %cf::MAP;
		1440	};
		1441
		1442	warn "end emergency map save\n";
		1443	}
		1444
		1445	package cf;
		1446
		1447	=back
		1448
		1449
1029	=head3 cf::object::player	1450	=head3 cf::object::player
1030		1451
1031	=over 4	1452	=over 4
1032		1453
1033	=item $player_object->reply ($npc, $msg[, $flags])	1454	=item $player_object->reply ($npc, $msg[, $flags])
…		…
1068	(ref $cf::CFG{"may_$access"}	1489	(ref $cf::CFG{"may_$access"}
1069	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}	1490	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}
1070	: $cf::CFG{"may_$access"})	1491	: $cf::CFG{"may_$access"})
1071	}	1492	}
1072		1493
		1494	=item $player_object->enter_link
		1495
		1496	Freezes the player and moves him/her to a special map (C<{link}>).
		1497
		1498	The player should be reaosnably safe there for short amounts of time. You
		1499	I<MUST> call C<leave_link> as soon as possible, though.
		1500
		1501	=item $player_object->leave_link ($map, $x, $y)
		1502
		1503	Moves the player out of the specila link map onto the given map. If the
		1504	map is not valid (or omitted), the player will be moved back to the
		1505	location he/she was before the call to C<enter_link>, or, if that fails,
		1506	to the emergency map position.
		1507
		1508	Might block.
		1509
		1510	=cut
		1511
		1512	sub cf::object::player::enter_link {
		1513	my ($self) = @_;
		1514
		1515	$self->deactivate_recursive;
		1516
		1517	return if $self->map == $LINK_MAP;
		1518
		1519	$self->{_link_pos} \|\|= [$self->map->{path}, $self->x, $self->y]
		1520	if $self->map;
		1521
		1522	$self->enter_map ($LINK_MAP, 20, 20);
		1523	}
		1524
		1525	sub cf::object::player::leave_link {
		1526	my ($self, $map, $x, $y) = @_;
		1527
		1528	my $link_pos = delete $self->{_link_pos};
		1529
		1530	unless ($map) {
		1531	# restore original map position
		1532	($map, $x, $y) = @{ $link_pos \|\| [] };
		1533	$map = cf::map::find $map;
		1534
		1535	unless ($map) {
		1536	($map, $x, $y) = @$EMERGENCY_POSITION;
		1537	$map = cf::map::find $map
		1538	or die "FATAL: cannot load emergency map\n";
		1539	}
		1540	}
		1541
		1542	($x, $y) = (-1, -1)
		1543	unless (defined $x) && (defined $y);
		1544
		1545	# use -1 or undef as default coordinates, not 0, 0
		1546	($x, $y) = ($map->enter_x, $map->enter_y)
		1547	if $x <=0 && $y <= 0;
		1548
		1549	$map->load;
		1550
		1551	$self->activate_recursive;
		1552	$self->enter_map ($map, $x, $y);
		1553	}
		1554
		1555	cf::player->attach (
		1556	on_logout => sub {
		1557	my ($pl) = @_;
		1558
		1559	# abort map switching before logout
		1560	if ($pl->ob->{_link_pos}) {
		1561	cf::sync_job {
		1562	$pl->ob->leave_link
		1563	};
		1564	}
		1565	},
		1566	on_login => sub {
		1567	my ($pl) = @_;
		1568
		1569	# try to abort aborted map switching on player login :)
		1570	# should happen only on crashes
		1571	if ($pl->ob->{_link_pos}) {
		1572	$pl->ob->enter_link;
		1573	cf::async {
		1574	# we need this sleep as the login has a concurrent enter_exit running
		1575	# and this sleep increases chances of the player not ending up in scorn
		1576	Coro::Timer::sleep 1;
		1577	$pl->ob->leave_link;
		1578	};
		1579	}
		1580	},
		1581	);
		1582
		1583	=item $player_object->goto_map ($path, $x, $y)
		1584
		1585	=cut
		1586
		1587	sub cf::object::player::goto_map {
		1588	my ($self, $path, $x, $y) = @_;
		1589
		1590	$self->enter_link;
		1591
		1592	(cf::async {
		1593	$path = new cf::path $path;
		1594
		1595	my $map = cf::map::find $path->as_string;
		1596	$map = $map->customise_for ($self) if $map;
		1597
		1598	# warn "entering ", $map->path, " at ($x, $y)\n"
		1599	# if $map;
		1600
		1601	$map or $self->message ("The exit is closed", cf::NDI_UNIQUE \| cf::NDI_RED);
		1602
		1603	$self->leave_link ($map, $x, $y);
		1604	})->prio (1);
		1605	}
		1606
		1607	=item $player_object->enter_exit ($exit_object)
		1608
		1609	=cut
		1610
		1611	sub parse_random_map_params {
		1612	my ($spec) = @_;
		1613
		1614	my $rmp = { # defaults
		1615	xsize => 10,
		1616	ysize => 10,
		1617	};
		1618
		1619	for (split /\n/, $spec) {
		1620	my ($k, $v) = split /\s+/, $_, 2;
		1621
		1622	$rmp->{lc $k} = $v if (length $k) && (length $v);
		1623	}
		1624
		1625	$rmp
		1626	}
		1627
		1628	sub prepare_random_map {
		1629	my ($exit) = @_;
		1630
		1631	# all this does is basically replace the /! path by
		1632	# a new random map path (?random/...) with a seed
		1633	# that depends on the exit object
		1634
		1635	my $rmp = parse_random_map_params $exit->msg;
		1636
		1637	if ($exit->map) {
		1638	$rmp->{region} = $exit->map->region_name;
		1639	$rmp->{origin_map} = $exit->map->path;
		1640	$rmp->{origin_x} = $exit->x;
		1641	$rmp->{origin_y} = $exit->y;
		1642	}
		1643
		1644	$rmp->{random_seed} \|\|= $exit->random_seed;
		1645
		1646	my $data = cf::to_json $rmp;
		1647	my $md5 = Digest::MD5::md5_hex $data;
		1648
		1649	if (my $fh = aio_open "$cf::RANDOM_MAPS/$md5.meta", O_WRONLY \| O_CREAT, 0666) {
		1650	aio_write $fh, 0, (length $data), $data, 0;
		1651
		1652	$exit->slaying ("?random/$md5");
		1653	$exit->msg (undef);
		1654	}
		1655	}
		1656
		1657	sub cf::object::player::enter_exit {
		1658	my ($self, $exit) = @_;
		1659
		1660	return unless $self->type == cf::PLAYER;
		1661
		1662	$self->enter_link;
		1663
		1664	(cf::async {
		1665	$self->deactivate_recursive; # just to be sure
		1666	unless (eval {
		1667	prepare_random_map $exit
		1668	if $exit->slaying eq "/!";
		1669
		1670	my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;
		1671	$self->goto_map ($path, $exit->stats->hp, $exit->stats->sp);
		1672
		1673	1;
		1674	}) {
		1675	$self->message ("Something went wrong deep within the crossfire server. "
		1676	. "I'll try to bring you back to the map you were before. "
		1677	. "Please report this to the dungeon master",
		1678	cf::NDI_UNIQUE \| cf::NDI_RED);
		1679
		1680	warn "ERROR in enter_exit: $@";
		1681	$self->leave_link;
		1682	}
		1683	})->prio (1);
		1684	}
		1685
1073	=head3 cf::client	1686	=head3 cf::client
1074		1687
1075	=over 4	1688	=over 4
1076		1689
1077	=item $client->send_drawinfo ($text, $flags)	1690	=item $client->send_drawinfo ($text, $flags)
…		…
1120	on_reply => sub {	1733	on_reply => sub {
1121	my ($ns, $msg) = @_;	1734	my ($ns, $msg) = @_;
1122		1735
1123	# this weird shuffling is so that direct followup queries	1736	# this weird shuffling is so that direct followup queries
1124	# get handled first	1737	# get handled first
1125	my $queue = delete $ns->{query_queue};	1738	my $queue = delete $ns->{query_queue}
		1739	or return; # be conservative, not sure how that can happen, but we saw a crash here
1126		1740
1127	(shift @$queue)->[1]->($msg);	1741	(shift @$queue)->[1]->($msg);
1128		1742
1129	push @{ $ns->{query_queue} }, @$queue;	1743	push @{ $ns->{query_queue} }, @$queue;
1130		1744
…		…
1147	=cut	1761	=cut
1148		1762
1149	sub cf::client::coro {	1763	sub cf::client::coro {
1150	my ($self, $cb) = @_;	1764	my ($self, $cb) = @_;
1151		1765
1152	my $coro; $coro = async {	1766	my $coro = &cf::async ($cb);
1153	eval {
1154	$cb->();
1155	};
1156	warn $@ if $@;
1157	};
1158		1767
1159	$coro->on_destroy (sub {	1768	$coro->on_destroy (sub {
1160	delete $self->{_coro}{$coro+0};	1769	delete $self->{_coro}{$coro+0};
1161	});	1770	});
1162		1771
…		…
1334		1943
1335	{	1944	{
1336	my $path = cf::localdir . "/database.pst";	1945	my $path = cf::localdir . "/database.pst";
1337		1946
1338	sub db_load() {	1947	sub db_load() {
1339	warn "loading database $path\n";#d# remove later
1340	$DB = stat $path ? Storable::retrieve $path : { };	1948	$DB = stat $path ? Storable::retrieve $path : { };
1341	}	1949	}
1342		1950
1343	my $pid;	1951	my $pid;
1344		1952
1345	sub db_save() {	1953	sub db_save() {
1346	warn "saving database $path\n";#d# remove later
1347	waitpid $pid, 0 if $pid;	1954	waitpid $pid, 0 if $pid;
1348	if (0 == ($pid = fork)) {	1955	if (0 == ($pid = fork)) {
1349	$DB->{_meta}{version} = 1;	1956	$DB->{_meta}{version} = 1;
1350	Storable::nstore $DB, "$path~";	1957	Storable::nstore $DB, "$path~";
1351	rename "$path~", $path;	1958	rename "$path~", $path;
…		…
1399	open my $fh, "<:utf8", cf::confdir . "/config"	2006	open my $fh, "<:utf8", cf::confdir . "/config"
1400	or return;	2007	or return;
1401		2008
1402	local $/;	2009	local $/;
1403	*CFG = YAML::Syck::Load <$fh>;	2010	*CFG = YAML::Syck::Load <$fh>;
		2011
		2012	$EMERGENCY_POSITION = $CFG{emergency_position} \|\| ["/world/world_105_115", 5, 37];
		2013
		2014	if (exists $CFG{mlockall}) {
		2015	eval {
		2016	$CFG{mlockall} ? &mlockall : &munlockall
		2017	and die "WARNING: m(un)lockall failed: $!\n";
		2018	};
		2019	warn $@ if $@;
		2020	}
1404	}	2021	}
1405		2022
1406	sub main {	2023	sub main {
1407	# we must not ever block the main coroutine	2024	# we must not ever block the main coroutine
1408	local $Coro::idle = sub {	2025	local $Coro::idle = sub {
1409	Carp::cluck "FATAL: Coro::idle was called, major BUG\n";#d#	2026	Carp::cluck "FATAL: Coro::idle was called, major BUG, use cf::sync_job!\n";#d#
1410	(Coro::unblock_sub {	2027	(Coro::unblock_sub {
1411	Event::one_event;	2028	Event::one_event;
1412	})->();	2029	})->();
1413	};	2030	};
1414		2031
…		…
1419	}	2036	}
1420		2037
1421	#############################################################################	2038	#############################################################################
1422	# initialisation	2039	# initialisation
1423		2040
1424	sub perl_reload() {	2041	sub reload() {
1425	# can/must only be called in main	2042	# can/must only be called in main
1426	if ($Coro::current != $Coro::main) {	2043	if ($Coro::current != $Coro::main) {
1427	warn "can only reload from main coroutine\n";	2044	warn "can only reload from main coroutine\n";
1428	return;	2045	return;
1429	}	2046	}
1430		2047
1431	warn "reloading...";	2048	warn "reloading...";
1432		2049
1433	local $FREEZE = 1;	2050	my $guard = freeze_mainloop;
1434	cf::emergency_save;	2051	cf::emergency_save;
1435		2052
1436	eval {	2053	eval {
1437	# if anything goes wrong in here, we should simply crash as we already saved	2054	# if anything goes wrong in here, we should simply crash as we already saved
1438		2055
…		…
1522	$LINK_MAP->height (41);	2139	$LINK_MAP->height (41);
1523	$LINK_MAP->alloc;	2140	$LINK_MAP->alloc;
1524	$LINK_MAP->path ("{link}");	2141	$LINK_MAP->path ("{link}");
1525	$LINK_MAP->{path} = bless { path => "{link}" }, "cf::path";	2142	$LINK_MAP->{path} = bless { path => "{link}" }, "cf::path";
1526	$LINK_MAP->in_memory (MAP_IN_MEMORY);	2143	$LINK_MAP->in_memory (MAP_IN_MEMORY);
		2144
		2145	# dirty hack because... archetypes are not yet loaded
		2146	Event->timer (
		2147	after => 2,
		2148	cb => sub {
		2149	$_[0]->w->cancel;
		2150
		2151	# provide some exits "home"
		2152	my $exit = cf::object::new "exit";
		2153
		2154	$exit->slaying ($EMERGENCY_POSITION->[0]);
		2155	$exit->stats->hp ($EMERGENCY_POSITION->[1]);
		2156	$exit->stats->sp ($EMERGENCY_POSITION->[2]);
		2157
		2158	$LINK_MAP->insert ($exit->clone, 19, 19);
		2159	$LINK_MAP->insert ($exit->clone, 19, 20);
		2160	$LINK_MAP->insert ($exit->clone, 19, 21);
		2161	$LINK_MAP->insert ($exit->clone, 20, 19);
		2162	$LINK_MAP->insert ($exit->clone, 20, 21);
		2163	$LINK_MAP->insert ($exit->clone, 21, 19);
		2164	$LINK_MAP->insert ($exit->clone, 21, 20);
		2165	$LINK_MAP->insert ($exit->clone, 21, 21);
		2166
		2167	$exit->destroy;
		2168	});
		2169
		2170	$LINK_MAP->{deny_save} = 1;
		2171	$LINK_MAP->{deny_reset} = 1;
		2172
		2173	$cf::MAP{$LINK_MAP->path} = $LINK_MAP;
1527	}	2174	}
1528		2175
1529	register "<global>", __PACKAGE__;	2176	register "<global>", __PACKAGE__;
1530		2177
1531	register_command "perl-reload" => sub {	2178	register_command "reload" => sub {
1532	my ($who, $arg) = @_;	2179	my ($who, $arg) = @_;
1533		2180
1534	if ($who->flag (FLAG_WIZ)) {	2181	if ($who->flag (FLAG_WIZ)) {
1535	$who->message ("start of reload.");	2182	$who->message ("start of reload.");
1536	perl_reload;	2183	reload;
1537	$who->message ("end of reload.");	2184	$who->message ("end of reload.");
1538	}	2185	}
1539	};	2186	};
1540		2187
1541	unshift @INC, $LIBDIR;	2188	unshift @INC, $LIBDIR;
…		…
1544	reentrant => 0,	2191	reentrant => 0,
1545	prio => 0,	2192	prio => 0,
1546	at => $NEXT_TICK \|\| $TICK,	2193	at => $NEXT_TICK \|\| $TICK,
1547	data => WF_AUTOCANCEL,	2194	data => WF_AUTOCANCEL,
1548	cb => sub {	2195	cb => sub {
1549	unless ($FREEZE) {
1550	cf::server_tick; # one server iteration	2196	cf::server_tick; # one server iteration
1551	$RUNTIME += $TICK;	2197	$RUNTIME += $TICK;
1552	}
1553
1554	$NEXT_TICK += $TICK;	2198	$NEXT_TICK += $TICK;
1555		2199
1556	# if we are delayed by four ticks or more, skip them all	2200	# if we are delayed by four ticks or more, skip them all
1557	$NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;	2201	$NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;
1558		2202
…		…
1581	or warn "ERROR: unable to write runtime file: $!";	2225	or warn "ERROR: unable to write runtime file: $!";
1582	})->();	2226	})->();
1583	},	2227	},
1584	);	2228	);
1585		2229
		2230	END { cf::emergency_save }
		2231
1586	1	2232	1
1587		2233

Diff Legend

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

Comparing deliantra/server/lib/cf.pm (file contents): Revision 1.108 by root, Sun Dec 31 21:02:05 2006 UTC vs. Revision 1.134 by root, Thu Jan 4 17:28:49 2007 UTC

Diff Legend

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.108 by root, Sun Dec 31 21:02:05 2006 UTC vs.
Revision 1.134 by root, Thu Jan 4 17:28:49 2007 UTC