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

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.109 by root, Sun Dec 31 22:23:12 2006 UTC vs.
Revision 1.133 by root, Thu Jan 4 16:19:32 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/}{}) {
286	Coro::AIO::aio_load "$cf::RANDOM_MAPS/$path.meta", my $data;	386	Coro::AIO::aio_load "$cf::RANDOM_MAPS/$path.meta", my $data;
287	$self->{random} = cf::from_json $data;	387	$self->{random} = cf::from_json $data;
288	} else {	388	} else {
289	if ($path =~ s{^~([^/]+)?}{}) {	389	if ($path =~ s{^~([^/]+)?}{}) {
290	$self->{user_rel} = 1;	390	$self->{user_rel} = 1;
…		…
795	or return;	895	or return;
796		896
797	unless (aio_stat "$filename.pst") {	897	unless (aio_stat "$filename.pst") {
798	(aio_load "$filename.pst", $av) >= 0	898	(aio_load "$filename.pst", $av) >= 0
799	or return;	899	or return;
800	$av = eval { (Storable::thaw <$av>)->{objs} };	900	$av = eval { (Storable::thaw $av)->{objs} };
801	}	901	}
802		902
		903	warn sprintf "loading %s (%d)\n",
		904	$filename, length $data, scalar @{$av \|\| []};#d#
803	return ($data, $av);	905	return ($data, $av);
804	}	906	}
805		907
806	#############################################################################	908	#############################################################################
807	# command handling &c	909	# command handling &c
…		…
1029	$self->send ("ext " . to_json \%msg);	1131	$self->send ("ext " . to_json \%msg);
1030	}	1132	}
1031		1133
1032	=back	1134	=back
1033		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	if ($map) {
		1215	$map->last_access ((delete $map->{last_access})
		1216	\|\| $cf::RUNTIME); #d#
		1217	# safety
		1218	$map->{instantiate_time} = $cf::RUNTIME
		1219	if $map->{instantiate_time} > $cf::RUNTIME;
		1220	} else {
		1221	if (my $rmp = $path->random_map_params) {
		1222	$map = generate_random_map $key, $rmp;
		1223	} else {
		1224	$map = try_load_header $path->load_path;
		1225	}
		1226
		1227	$map or return;
		1228
		1229	$map->{load_original} = 1;
		1230	$map->{instantiate_time} = $cf::RUNTIME;
		1231	$map->last_access ($cf::RUNTIME);
		1232	$map->instantiate;
		1233
		1234	# per-player maps become, after loading, normal maps
		1235	$map->per_player (0) if $path->{user_rel};
		1236	}
		1237
		1238	$map->path ($key);
		1239	$map->{path} = $path;
		1240	$map->{last_save} = $cf::RUNTIME;
		1241
		1242	if ($map->should_reset) {
		1243	$map->reset;
		1244	undef $guard;
		1245	$map = find $path
		1246	or return;
		1247	}
		1248
		1249	$cf::MAP{$key} = $map
		1250	}
		1251	}
		1252
		1253	sub load {
		1254	my ($self) = @_;
		1255
		1256	my $path = $self->{path};
		1257	my $guard = cf::lock_acquire "map_load:" . $path->as_string;
		1258
		1259	return if $self->in_memory != cf::MAP_SWAPPED;
		1260
		1261	$self->in_memory (cf::MAP_LOADING);
		1262
		1263	$self->alloc;
		1264	$self->load_objects ($self->{load_path}, 1)
		1265	or return;
		1266
		1267	$self->set_object_flag (cf::FLAG_OBJ_ORIGINAL, 1)
		1268	if delete $self->{load_original};
		1269
		1270	if (my $uniq = $path->uniq_path) {
		1271	utf8::encode $uniq;
		1272	if (aio_open $uniq, O_RDONLY, 0) {
		1273	$self->clear_unique_items;
		1274	$self->load_objects ($uniq, 0);
		1275	}
		1276	}
		1277
		1278	# now do the right thing for maps
		1279	$self->link_multipart_objects;
		1280
		1281	if ($self->{path}->is_style_map) {
		1282	$self->{deny_save} = 1;
		1283	$self->{deny_reset} = 1;
		1284	} else {
		1285	$self->fix_auto_apply;
		1286	$self->decay_objects;
		1287	$self->update_buttons;
		1288	$self->set_darkness_map;
		1289	$self->difficulty ($self->estimate_difficulty)
		1290	unless $self->difficulty;
		1291	$self->activate;
		1292	}
		1293
		1294	$self->in_memory (cf::MAP_IN_MEMORY);
		1295	}
		1296
		1297	sub find_sync {
		1298	my ($path, $origin) = @_;
		1299
		1300	cf::sync_job { cf::map::find $path, $origin }
		1301	}
		1302
		1303	sub do_load_sync {
		1304	my ($map) = @_;
		1305
		1306	cf::sync_job { $map->load };
		1307	}
		1308
		1309	sub save {
		1310	my ($self) = @_;
		1311
		1312	$self->{last_save} = $cf::RUNTIME;
		1313
		1314	return unless $self->dirty;
		1315
		1316	my $save = $self->{path}->save_path; utf8::encode $save;
		1317	my $uniq = $self->{path}->uniq_path; utf8::encode $uniq;
		1318
		1319	$self->{load_path} = $save;
		1320
		1321	return if $self->{deny_save};
		1322
		1323	local $self->{last_access} = $self->last_access;#d#
		1324
		1325	if ($uniq) {
		1326	$self->save_objects ($save, cf::IO_HEADER \| cf::IO_OBJECTS);
		1327	$self->save_objects ($uniq, cf::IO_UNIQUES);
		1328	} else {
		1329	$self->save_objects ($save, cf::IO_HEADER \| cf::IO_OBJECTS \| cf::IO_UNIQUES);
		1330	}
		1331	}
		1332
		1333	sub swap_out {
		1334	my ($self) = @_;
		1335
		1336	# save first because save cedes
		1337	$self->save;
		1338
		1339	return if $self->players;
		1340	return if $self->in_memory != cf::MAP_IN_MEMORY;
		1341	return if $self->{deny_save};
		1342
		1343	$self->clear;
		1344	$self->in_memory (cf::MAP_SWAPPED);
		1345	}
		1346
		1347	sub reset_at {
		1348	my ($self) = @_;
		1349
		1350	# TODO: safety, remove and allow resettable per-player maps
		1351	return 1e99 if $self->{path}{user_rel};
		1352	return 1e99 if $self->{deny_reset};
		1353
		1354	my $time = $self->fixed_resettime ? $self->{instantiate_time} : $self->last_access;
		1355	my $to = List::Util::min $MAX_RESET, $self->reset_timeout \|\| $DEFAULT_RESET;
		1356
		1357	$time + $to
		1358	}
		1359
		1360	sub should_reset {
		1361	my ($self) = @_;
		1362
		1363	$self->reset_at <= $cf::RUNTIME
		1364	}
		1365
		1366	sub unlink_save {
		1367	my ($self) = @_;
		1368
		1369	utf8::encode (my $save = $self->{path}->save_path);
		1370	aioreq_pri 3; IO::AIO::aio_unlink $save;
		1371	aioreq_pri 3; IO::AIO::aio_unlink "$save.pst";
		1372	}
		1373
		1374	sub rename {
		1375	my ($self, $new_path) = @_;
		1376
		1377	$self->unlink_save;
		1378
		1379	delete $cf::MAP{$self->path};
		1380	$self->{path} = new cf::path $new_path;
		1381	$self->path ($self->{path}->as_string);
		1382	$cf::MAP{$self->path} = $self;
		1383
		1384	$self->save;
		1385	}
		1386
		1387	sub reset {
		1388	my ($self) = @_;
		1389
		1390	return if $self->players;
		1391	return if $self->{path}{user_rel};#d#
		1392
		1393	warn "resetting map ", $self->path;#d#
		1394
		1395	delete $cf::MAP{$self->path};
		1396
		1397	$_->clear_links_to ($self) for values %cf::MAP;
		1398
		1399	$self->unlink_save;
		1400	$self->destroy;
		1401	}
		1402
		1403	my $nuke_counter = "aaaa";
		1404
		1405	sub nuke {
		1406	my ($self) = @_;
		1407
		1408	$self->{deny_save} = 1;
		1409	$self->reset_timeout (1);
		1410	$self->rename ("{nuke}/" . ($nuke_counter++));
		1411	$self->reset; # polite request, might not happen
		1412	}
		1413
		1414	sub customise_for {
		1415	my ($map, $ob) = @_;
		1416
		1417	if ($map->per_player) {
		1418	return cf::map::find "~" . $ob->name . "/" . $map->{path}{path};
		1419	}
		1420
		1421	$map
		1422	}
		1423
		1424	sub emergency_save {
		1425	my $freeze_guard = cf::freeze_mainloop;
		1426
		1427	warn "enter emergency map save\n";
		1428
		1429	cf::sync_job {
		1430	warn "begin emergency map save\n";
		1431	$_->save for values %cf::MAP;
		1432	};
		1433
		1434	warn "end emergency map save\n";
		1435	}
		1436
		1437	package cf;
		1438
		1439	=back
		1440
		1441
1034	=head3 cf::object::player	1442	=head3 cf::object::player
1035		1443
1036	=over 4	1444	=over 4
1037		1445
1038	=item $player_object->reply ($npc, $msg[, $flags])	1446	=item $player_object->reply ($npc, $msg[, $flags])
…		…
1073	(ref $cf::CFG{"may_$access"}	1481	(ref $cf::CFG{"may_$access"}
1074	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}	1482	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}
1075	: $cf::CFG{"may_$access"})	1483	: $cf::CFG{"may_$access"})
1076	}	1484	}
1077		1485
		1486	=item $player_object->enter_link
		1487
		1488	Freezes the player and moves him/her to a special map (C<{link}>).
		1489
		1490	The player should be reaosnably safe there for short amounts of time. You
		1491	I<MUST> call C<leave_link> as soon as possible, though.
		1492
		1493	=item $player_object->leave_link ($map, $x, $y)
		1494
		1495	Moves the player out of the specila link map onto the given map. If the
		1496	map is not valid (or omitted), the player will be moved back to the
		1497	location he/she was before the call to C<enter_link>, or, if that fails,
		1498	to the emergency map position.
		1499
		1500	Might block.
		1501
		1502	=cut
		1503
		1504	sub cf::object::player::enter_link {
		1505	my ($self) = @_;
		1506
		1507	$self->deactivate_recursive;
		1508
		1509	return if $self->map == $LINK_MAP;
		1510
		1511	$self->{_link_pos} \|\|= [$self->map->{path}, $self->x, $self->y]
		1512	if $self->map;
		1513
		1514	$self->enter_map ($LINK_MAP, 20, 20);
		1515	}
		1516
		1517	sub cf::object::player::leave_link {
		1518	my ($self, $map, $x, $y) = @_;
		1519
		1520	my $link_pos = delete $self->{_link_pos};
		1521
		1522	unless ($map) {
		1523	# restore original map position
		1524	($map, $x, $y) = @{ $link_pos \|\| [] };
		1525	$map = cf::map::find $map;
		1526
		1527	unless ($map) {
		1528	($map, $x, $y) = @$EMERGENCY_POSITION;
		1529	$map = cf::map::find $map
		1530	or die "FATAL: cannot load emergency map\n";
		1531	}
		1532	}
		1533
		1534	($x, $y) = (-1, -1)
		1535	unless (defined $x) && (defined $y);
		1536
		1537	# use -1 or undef as default coordinates, not 0, 0
		1538	($x, $y) = ($map->enter_x, $map->enter_y)
		1539	if $x <=0 && $y <= 0;
		1540
		1541	$map->load;
		1542
		1543	$self->activate_recursive;
		1544	$self->enter_map ($map, $x, $y);
		1545	}
		1546
		1547	cf::player->attach (
		1548	on_logout => sub {
		1549	my ($pl) = @_;
		1550
		1551	# abort map switching before logout
		1552	if ($pl->ob->{_link_pos}) {
		1553	cf::sync_job {
		1554	$pl->ob->leave_link
		1555	};
		1556	}
		1557	},
		1558	on_login => sub {
		1559	my ($pl) = @_;
		1560
		1561	# try to abort aborted map switching on player login :)
		1562	# should happen only on crashes
		1563	if ($pl->ob->{_link_pos}) {
		1564	$pl->ob->enter_link;
		1565	cf::async {
		1566	# we need this sleep as the login has a concurrent enter_exit running
		1567	# and this sleep increases chances of the player not ending up in scorn
		1568	Coro::Timer::sleep 1;
		1569	$pl->ob->leave_link;
		1570	};
		1571	}
		1572	},
		1573	);
		1574
		1575	=item $player_object->goto_map ($path, $x, $y)
		1576
		1577	=cut
		1578
		1579	sub cf::object::player::goto_map {
		1580	my ($self, $path, $x, $y) = @_;
		1581
		1582	$self->enter_link;
		1583
		1584	(cf::async {
		1585	$path = new cf::path $path;
		1586
		1587	my $map = cf::map::find $path->as_string;
		1588	$map = $map->customise_for ($self) if $map;
		1589
		1590	# warn "entering ", $map->path, " at ($x, $y)\n"
		1591	# if $map;
		1592
		1593	$map or $self->message ("The exit is closed", cf::NDI_UNIQUE \| cf::NDI_RED);
		1594
		1595	$self->leave_link ($map, $x, $y);
		1596	})->prio (1);
		1597	}
		1598
		1599	=item $player_object->enter_exit ($exit_object)
		1600
		1601	=cut
		1602
		1603	sub parse_random_map_params {
		1604	my ($spec) = @_;
		1605
		1606	my $rmp = { # defaults
		1607	xsize => 10,
		1608	ysize => 10,
		1609	};
		1610
		1611	for (split /\n/, $spec) {
		1612	my ($k, $v) = split /\s+/, $_, 2;
		1613
		1614	$rmp->{lc $k} = $v if (length $k) && (length $v);
		1615	}
		1616
		1617	$rmp
		1618	}
		1619
		1620	sub prepare_random_map {
		1621	my ($exit) = @_;
		1622
		1623	# all this does is basically replace the /! path by
		1624	# a new random map path (?random/...) with a seed
		1625	# that depends on the exit object
		1626
		1627	my $rmp = parse_random_map_params $exit->msg;
		1628
		1629	if ($exit->map) {
		1630	$rmp->{region} = $exit->map->region_name;
		1631	$rmp->{origin_map} = $exit->map->path;
		1632	$rmp->{origin_x} = $exit->x;
		1633	$rmp->{origin_y} = $exit->y;
		1634	}
		1635
		1636	$rmp->{random_seed} \|\|= $exit->random_seed;
		1637
		1638	my $data = cf::to_json $rmp;
		1639	my $md5 = Digest::MD5::md5_hex $data;
		1640
		1641	if (my $fh = aio_open "$cf::RANDOM_MAPS/$md5.meta", O_WRONLY \| O_CREAT, 0666) {
		1642	aio_write $fh, 0, (length $data), $data, 0;
		1643
		1644	$exit->slaying ("?random/$md5");
		1645	$exit->msg (undef);
		1646	}
		1647	}
		1648
		1649	sub cf::object::player::enter_exit {
		1650	my ($self, $exit) = @_;
		1651
		1652	return unless $self->type == cf::PLAYER;
		1653
		1654	$self->enter_link;
		1655
		1656	(cf::async {
		1657	$self->deactivate_recursive; # just to be sure
		1658	unless (eval {
		1659	prepare_random_map $exit
		1660	if $exit->slaying eq "/!";
		1661
		1662	my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;
		1663	$self->goto_map ($path, $exit->stats->hp, $exit->stats->sp);
		1664
		1665	1;
		1666	}) {
		1667	$self->message ("Something went wrong deep within the crossfire server. "
		1668	. "I'll try to bring you back to the map you were before. "
		1669	. "Please report this to the dungeon master",
		1670	cf::NDI_UNIQUE \| cf::NDI_RED);
		1671
		1672	warn "ERROR in enter_exit: $@";
		1673	$self->leave_link;
		1674	}
		1675	})->prio (1);
		1676	}
		1677
1078	=head3 cf::client	1678	=head3 cf::client
1079		1679
1080	=over 4	1680	=over 4
1081		1681
1082	=item $client->send_drawinfo ($text, $flags)	1682	=item $client->send_drawinfo ($text, $flags)
…		…
1125	on_reply => sub {	1725	on_reply => sub {
1126	my ($ns, $msg) = @_;	1726	my ($ns, $msg) = @_;
1127		1727
1128	# this weird shuffling is so that direct followup queries	1728	# this weird shuffling is so that direct followup queries
1129	# get handled first	1729	# get handled first
1130	my $queue = delete $ns->{query_queue};	1730	my $queue = delete $ns->{query_queue}
		1731	or return; # be conservative, not sure how that can happen, but we saw a crash here
1131		1732
1132	(shift @$queue)->[1]->($msg);	1733	(shift @$queue)->[1]->($msg);
1133		1734
1134	push @{ $ns->{query_queue} }, @$queue;	1735	push @{ $ns->{query_queue} }, @$queue;
1135		1736
…		…
1152	=cut	1753	=cut
1153		1754
1154	sub cf::client::coro {	1755	sub cf::client::coro {
1155	my ($self, $cb) = @_;	1756	my ($self, $cb) = @_;
1156		1757
1157	my $coro; $coro = async {	1758	my $coro = &cf::async ($cb);
1158	eval {
1159	$cb->();
1160	};
1161	warn $@ if $@;
1162	};
1163		1759
1164	$coro->on_destroy (sub {	1760	$coro->on_destroy (sub {
1165	delete $self->{_coro}{$coro+0};	1761	delete $self->{_coro}{$coro+0};
1166	});	1762	});
1167		1763
…		…
1339		1935
1340	{	1936	{
1341	my $path = cf::localdir . "/database.pst";	1937	my $path = cf::localdir . "/database.pst";
1342		1938
1343	sub db_load() {	1939	sub db_load() {
1344	warn "loading database $path\n";#d# remove later
1345	$DB = stat $path ? Storable::retrieve $path : { };	1940	$DB = stat $path ? Storable::retrieve $path : { };
1346	}	1941	}
1347		1942
1348	my $pid;	1943	my $pid;
1349		1944
1350	sub db_save() {	1945	sub db_save() {
1351	warn "saving database $path\n";#d# remove later
1352	waitpid $pid, 0 if $pid;	1946	waitpid $pid, 0 if $pid;
1353	if (0 == ($pid = fork)) {	1947	if (0 == ($pid = fork)) {
1354	$DB->{_meta}{version} = 1;	1948	$DB->{_meta}{version} = 1;
1355	Storable::nstore $DB, "$path~";	1949	Storable::nstore $DB, "$path~";
1356	rename "$path~", $path;	1950	rename "$path~", $path;
…		…
1404	open my $fh, "<:utf8", cf::confdir . "/config"	1998	open my $fh, "<:utf8", cf::confdir . "/config"
1405	or return;	1999	or return;
1406		2000
1407	local $/;	2001	local $/;
1408	*CFG = YAML::Syck::Load <$fh>;	2002	*CFG = YAML::Syck::Load <$fh>;
		2003
		2004	$EMERGENCY_POSITION = $CFG{emergency_position} \|\| ["/world/world_105_115", 5, 37];
		2005
		2006	if (exists $CFG{mlockall}) {
		2007	eval {
		2008	$CFG{mlockall} ? &mlockall : &munlockall
		2009	and die "WARNING: m(un)lockall failed: $!\n";
		2010	};
		2011	warn $@ if $@;
		2012	}
1409	}	2013	}
1410		2014
1411	sub main {	2015	sub main {
1412	# we must not ever block the main coroutine	2016	# we must not ever block the main coroutine
1413	local $Coro::idle = sub {	2017	local $Coro::idle = sub {
1414	Carp::cluck "FATAL: Coro::idle was called, major BUG\n";#d#	2018	Carp::cluck "FATAL: Coro::idle was called, major BUG, use cf::sync_job!\n";#d#
1415	(Coro::unblock_sub {	2019	(Coro::unblock_sub {
1416	Event::one_event;	2020	Event::one_event;
1417	})->();	2021	})->();
1418	};	2022	};
1419		2023
…		…
1424	}	2028	}
1425		2029
1426	#############################################################################	2030	#############################################################################
1427	# initialisation	2031	# initialisation
1428		2032
1429	sub perl_reload() {	2033	sub reload() {
1430	# can/must only be called in main	2034	# can/must only be called in main
1431	if ($Coro::current != $Coro::main) {	2035	if ($Coro::current != $Coro::main) {
1432	warn "can only reload from main coroutine\n";	2036	warn "can only reload from main coroutine\n";
1433	return;	2037	return;
1434	}	2038	}
1435		2039
1436	warn "reloading...";	2040	warn "reloading...";
1437		2041
1438	local $FREEZE = 1;	2042	my $guard = freeze_mainloop;
1439	cf::emergency_save;	2043	cf::emergency_save;
1440		2044
1441	eval {	2045	eval {
1442	# if anything goes wrong in here, we should simply crash as we already saved	2046	# if anything goes wrong in here, we should simply crash as we already saved
1443		2047
…		…
1527	$LINK_MAP->height (41);	2131	$LINK_MAP->height (41);
1528	$LINK_MAP->alloc;	2132	$LINK_MAP->alloc;
1529	$LINK_MAP->path ("{link}");	2133	$LINK_MAP->path ("{link}");
1530	$LINK_MAP->{path} = bless { path => "{link}" }, "cf::path";	2134	$LINK_MAP->{path} = bless { path => "{link}" }, "cf::path";
1531	$LINK_MAP->in_memory (MAP_IN_MEMORY);	2135	$LINK_MAP->in_memory (MAP_IN_MEMORY);
		2136
		2137	# dirty hack because... archetypes are not yet loaded
		2138	Event->timer (
		2139	after => 2,
		2140	cb => sub {
		2141	$_[0]->w->cancel;
		2142
		2143	# provide some exits "home"
		2144	my $exit = cf::object::new "exit";
		2145
		2146	$exit->slaying ($EMERGENCY_POSITION->[0]);
		2147	$exit->stats->hp ($EMERGENCY_POSITION->[1]);
		2148	$exit->stats->sp ($EMERGENCY_POSITION->[2]);
		2149
		2150	$LINK_MAP->insert ($exit->clone, 19, 19);
		2151	$LINK_MAP->insert ($exit->clone, 19, 20);
		2152	$LINK_MAP->insert ($exit->clone, 19, 21);
		2153	$LINK_MAP->insert ($exit->clone, 20, 19);
		2154	$LINK_MAP->insert ($exit->clone, 20, 21);
		2155	$LINK_MAP->insert ($exit->clone, 21, 19);
		2156	$LINK_MAP->insert ($exit->clone, 21, 20);
		2157	$LINK_MAP->insert ($exit->clone, 21, 21);
		2158
		2159	$exit->destroy;
		2160	});
		2161
		2162	$LINK_MAP->{deny_save} = 1;
		2163	$LINK_MAP->{deny_reset} = 1;
		2164
		2165	$cf::MAP{$LINK_MAP->path} = $LINK_MAP;
1532	}	2166	}
1533		2167
1534	register "<global>", __PACKAGE__;	2168	register "<global>", __PACKAGE__;
1535		2169
1536	register_command "perl-reload" => sub {	2170	register_command "reload" => sub {
1537	my ($who, $arg) = @_;	2171	my ($who, $arg) = @_;
1538		2172
1539	if ($who->flag (FLAG_WIZ)) {	2173	if ($who->flag (FLAG_WIZ)) {
1540	$who->message ("start of reload.");	2174	$who->message ("start of reload.");
1541	perl_reload;	2175	reload;
1542	$who->message ("end of reload.");	2176	$who->message ("end of reload.");
1543	}	2177	}
1544	};	2178	};
1545		2179
1546	unshift @INC, $LIBDIR;	2180	unshift @INC, $LIBDIR;
…		…
1549	reentrant => 0,	2183	reentrant => 0,
1550	prio => 0,	2184	prio => 0,
1551	at => $NEXT_TICK \|\| $TICK,	2185	at => $NEXT_TICK \|\| $TICK,
1552	data => WF_AUTOCANCEL,	2186	data => WF_AUTOCANCEL,
1553	cb => sub {	2187	cb => sub {
1554	unless ($FREEZE) {
1555	cf::server_tick; # one server iteration	2188	cf::server_tick; # one server iteration
1556	$RUNTIME += $TICK;	2189	$RUNTIME += $TICK;
1557	}
1558
1559	$NEXT_TICK += $TICK;	2190	$NEXT_TICK += $TICK;
1560		2191
1561	# if we are delayed by four ticks or more, skip them all	2192	# if we are delayed by four ticks or more, skip them all
1562	$NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;	2193	$NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;
1563		2194
…		…
1586	or warn "ERROR: unable to write runtime file: $!";	2217	or warn "ERROR: unable to write runtime file: $!";
1587	})->();	2218	})->();
1588	},	2219	},
1589	);	2220	);
1590		2221
		2222	END { cf::emergency_save }
		2223
1591	1	2224	1
1592		2225

Diff Legend

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

Comparing deliantra/server/lib/cf.pm (file contents): Revision 1.109 by root, Sun Dec 31 22:23:12 2006 UTC vs. Revision 1.133 by root, Thu Jan 4 16:19:32 2007 UTC

Diff Legend

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.109 by root, Sun Dec 31 22:23:12 2006 UTC vs.
Revision 1.133 by root, Thu Jan 4 16:19:32 2007 UTC