[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.126 by root, Tue Jan 2 23:12:47 2007 UTC

…		…
71	mkdir cf::localdir . "/" . cf::uniquedir;	71	mkdir cf::localdir . "/" . cf::uniquedir;
72	mkdir $RANDOM_MAPS;	72	mkdir $RANDOM_MAPS;
73		73
74	# a special map that is always available	74	# a special map that is always available
75	our $LINK_MAP;	75	our $LINK_MAP;
		76
		77	our $EMERGENCY_POSITION = $cf::CFG{emergency_position} \|\| ["/world/world_105_115", 5, 37];
76		78
77	#############################################################################	79	#############################################################################
78		80
79	=head2 GLOBAL VARIABLES	81	=head2 GLOBAL VARIABLES
80		82
…		…
179	sub to_json($) {	181	sub to_json($) {
180	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs	182	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs
181	JSON::Syck::Dump $_[0]	183	JSON::Syck::Dump $_[0]
182	}	184	}
183		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
184	=item cf::sync_job { BLOCK }	250	=item cf::sync_job { BLOCK }
185		251
186	The design of crossfire+ requires that the main coro ($Coro::main) is	252	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	253	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.	254	reentrant. Thus "blocking" it by e.g. waiting for I/O is not acceptable.
…		…
195	=cut	261	=cut
196		262
197	sub sync_job(&) {	263	sub sync_job(&) {
198	my ($job) = @_;	264	my ($job) = @_;
199		265
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) {	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;
213	$coro->prio (Coro::PRIO_MAX);	281	})->prio (Coro::PRIO_MAX);
		282
214	while ($busy) {	283	while ($busy) {
215	Coro::cede_notself;	284	Coro::cede_notself;
216	Event::one_event unless Coro::nready;	285	Event::one_event unless Coro::nready;
217	}	286	}
		287
		288	wantarray ? @res : $res[0]
218	} else {	289	} else {
219	$coro->join;	290	# we are in another coroutine, how wonderful, everything just works
		291
		292	$job->()
220	}	293	}
221
222	wantarray ? @res : $res[0]
223	}	294	}
224		295
225	=item $coro = cf::coro { BLOCK }	296	=item $coro = cf::coro { BLOCK }
226		297
227	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
…		…
251	my $runtime = cf::localdir . "/runtime";	322	my $runtime = cf::localdir . "/runtime";
252		323
253	my $fh = aio_open "$runtime~", O_WRONLY \| O_CREAT, 0644	324	my $fh = aio_open "$runtime~", O_WRONLY \| O_CREAT, 0644
254	or return;	325	or return;
255		326
256	my $value = $cf::RUNTIME;	327	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	328	(aio_write $fh, 0, (length $value), $value, 0) <= 0
258	and return;	329	and return;
259		330
260	aio_fsync $fh	331	aio_fsync $fh
261	and return;	332	and return;
…		…
278	package cf::path;	349	package cf::path;
279		350
280	sub new {	351	sub new {
281	my ($class, $path, $base) = @_;	352	my ($class, $path, $base) = @_;
282		353
		354	$path = $path->as_string if ref $path;
		355
283	my $self = bless { }, $class;	356	my $self = bless { }, $class;
284		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
285	if ($path =~ s{^\?random/}{}) {	368	} elsif ($path =~ s{^\?random/}{}) {
		369	Coro::AIO::aio_load "$cf::RANDOM_MAPS/$path.meta", my $data;
286	$self->{random} = cf::from_json $path;	370	$self->{random} = cf::from_json $data;
287	} else {	371	} else {
288	if ($path =~ s{^~([^/]+)?}{}) {	372	if ($path =~ s{^~([^/]+)?}{}) {
289	$self->{user_rel} = 1;	373	$self->{user_rel} = 1;
290		374
291	if (defined $1) {	375	if (defined $1) {
…		…
324		408
325	# the displayed name, this is a one way mapping	409	# the displayed name, this is a one way mapping
326	sub visible_name {	410	sub visible_name {
327	my ($self) = @_;	411	my ($self) = @_;
328		412
329	$self->{random} ? "?random/$self->{random}{origin_map}+$self->{random}{origin_x}+$self->{random}{origin_y}/$self->{random}{dungeon_level}"	413	# if (my $rmp = $self->{random}) {
330	: $self->as_string	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	# }
331	}	419	}
332		420
333	# escape the /'s in the path	421	# escape the /'s in the path
334	sub _escaped_path {	422	sub _escaped_path {
335	# ∕ is U+2215	423	# ∕ is U+2215
…		…
347	# the temporary/swap location	435	# the temporary/swap location
348	sub save_path {	436	sub save_path {
349	my ($self) = @_;	437	my ($self) = @_;
350		438
351	$self->{user_rel} ? sprintf "%s/%s/%s/%s", cf::localdir, cf::playerdir, $self->{user}, $self->_escaped_path	439	$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}	440	: $self->{random} ? sprintf "%s/%s", $RANDOM_MAPS, $self->{path}
353	: sprintf "%s/%s/%s", cf::localdir, cf::tmpdir, $self->_escaped_path	441	: sprintf "%s/%s/%s", cf::localdir, cf::tmpdir, $self->_escaped_path
354	}	442	}
355		443
356	# the unique path, might be eq to save_path	444	# the unique path, might be eq to save_path
357	sub uniq_path {	445	sub uniq_path {
…		…
790	or return;	878	or return;
791		879
792	unless (aio_stat "$filename.pst") {	880	unless (aio_stat "$filename.pst") {
793	(aio_load "$filename.pst", $av) >= 0	881	(aio_load "$filename.pst", $av) >= 0
794	or return;	882	or return;
795	$av = eval { (Storable::thaw <$av>)->{objs} };	883	$av = eval { (Storable::thaw $av)->{objs} };
796	}	884	}
797		885
		886	warn sprintf "loading %s (%d)\n",
		887	$filename, length $data, scalar @{$av \|\| []};#d#
798	return ($data, $av);	888	return ($data, $av);
799	}	889	}
800		890
801	#############################################################################	891	#############################################################################
802	# command handling &c	892	# command handling &c
…		…
1024	$self->send ("ext " . to_json \%msg);	1114	$self->send ("ext " . to_json \%msg);
1025	}	1115	}
1026		1116
1027	=back	1117	=back
1028		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	sub find_map {
		1182	my ($path, $origin) = @_;
		1183
		1184	#warn "find_map<$path,$origin>\n";#d#
		1185
		1186	$path = new cf::path $path, $origin && $origin->path;
		1187	my $key = $path->as_string;
		1188
		1189	cf::lock_wait "map_find:$key";
		1190
		1191	$cf::MAP{$key} \|\| do {
		1192	my $guard = cf::lock_acquire "map_find:$key";
		1193
		1194	# do it the slow way
		1195	my $map = try_load_header $path->save_path;
		1196
		1197	if ($map) {
		1198	# safety
		1199	$map->{instantiate_time} = $cf::RUNTIME
		1200	if $map->{instantiate_time} > $cf::RUNTIME;
		1201	} else {
		1202	if (my $rmp = $path->random_map_params) {
		1203	$map = generate_random_map $key, $rmp;
		1204	} else {
		1205	$map = try_load_header $path->load_path;
		1206	}
		1207
		1208	$map or return;
		1209
		1210	$map->{load_original} = 1;
		1211	$map->{instantiate_time} = $cf::RUNTIME;
		1212	$map->instantiate;
		1213
		1214	# per-player maps become, after loading, normal maps
		1215	$map->per_player (0) if $path->{user_rel};
		1216	}
		1217
		1218	$map->path ($key);
		1219	$map->{path} = $path;
		1220	$map->{last_save} = $cf::RUNTIME;
		1221	$map->last_access ($cf::RUNTIME);
		1222
		1223	if ($map->should_reset) {
		1224	$map->reset;
		1225	undef $guard;
		1226	$map = find_map $path
		1227	or return;
		1228	}
		1229
		1230	$cf::MAP{$key} = $map
		1231	}
		1232	}
		1233
		1234	sub load {
		1235	my ($self) = @_;
		1236
		1237	my $path = $self->{path};
		1238	my $guard = cf::lock_acquire "map_load:" . $path->as_string;
		1239
		1240	return if $self->in_memory != cf::MAP_SWAPPED;
		1241
		1242	$self->in_memory (cf::MAP_LOADING);
		1243
		1244	$self->alloc;
		1245	$self->load_objects ($self->{load_path}, 1)
		1246	or return;
		1247
		1248	$self->set_object_flag (cf::FLAG_OBJ_ORIGINAL, 1)
		1249	if delete $self->{load_original};
		1250
		1251	if (my $uniq = $path->uniq_path) {
		1252	utf8::encode $uniq;
		1253	if (aio_open $uniq, O_RDONLY, 0) {
		1254	$self->clear_unique_items;
		1255	$self->load_objects ($uniq, 0);
		1256	}
		1257	}
		1258
		1259	# now do the right thing for maps
		1260	$self->link_multipart_objects;
		1261
		1262	if ($self->{path}->is_style_map) {
		1263	$self->{deny_save} = 1;
		1264	$self->{deny_reset} = 1;
		1265	} else {
		1266	$self->fix_auto_apply;
		1267	$self->decay_objects;
		1268	$self->update_buttons;
		1269	$self->set_darkness_map;
		1270	$self->difficulty ($self->estimate_difficulty)
		1271	unless $self->difficulty;
		1272	$self->activate;
		1273	}
		1274
		1275	$self->in_memory (cf::MAP_IN_MEMORY);
		1276	}
		1277
		1278	sub load_map_sync {
		1279	my ($path, $origin) = @_;
		1280
		1281	#warn "load_map_sync<$path, $origin>\n";#d#
		1282
		1283	cf::sync_job {
		1284	my $map = cf::map::find_map $path, $origin
		1285	or return;
		1286	$map->load;
		1287	$map
		1288	}
		1289	}
		1290
		1291	sub save {
		1292	my ($self) = @_;
		1293
		1294	$self->{last_save} = $cf::RUNTIME;
		1295
		1296	return unless $self->dirty;
		1297
		1298	my $save = $self->{path}->save_path; utf8::encode $save;
		1299	my $uniq = $self->{path}->uniq_path; utf8::encode $uniq;
		1300
		1301	$self->{load_path} = $save;
		1302
		1303	return if $self->{deny_save};
		1304
		1305	if ($uniq) {
		1306	$self->save_objects ($save, cf::IO_HEADER \| cf::IO_OBJECTS);
		1307	$self->save_objects ($uniq, cf::IO_UNIQUES);
		1308	} else {
		1309	$self->save_objects ($save, cf::IO_HEADER \| cf::IO_OBJECTS \| cf::IO_UNIQUES);
		1310	}
		1311	}
		1312
		1313	sub swap_out {
		1314	my ($self) = @_;
		1315
		1316	return if $self->players;
		1317	return if $self->in_memory != cf::MAP_IN_MEMORY;
		1318	return if $self->{deny_save};
		1319
		1320	$self->save;
		1321	$self->clear;
		1322	$self->in_memory (cf::MAP_SWAPPED);
		1323	}
		1324
		1325	sub reset_at {
		1326	my ($self) = @_;
		1327
		1328	# TODO: safety, remove and allow resettable per-player maps
		1329	return 1e99 if $self->{path}{user_rel};
		1330	return 1e99 if $self->{deny_reset};
		1331
		1332	my $time = $self->fixed_resettime ? $self->{instantiate_time} : $self->last_access;
		1333	my $to = List::Util::min $MAX_RESET, $self->reset_timeout \|\| $DEFAULT_RESET;
		1334
		1335	$time + $to
		1336	}
		1337
		1338	sub should_reset {
		1339	my ($self) = @_;
		1340
		1341	$self->reset_at <= $cf::RUNTIME
		1342	}
		1343
		1344	sub unlink_save {
		1345	my ($self) = @_;
		1346
		1347	utf8::encode (my $save = $self->{path}->save_path);
		1348	aioreq_pri 3; IO::AIO::aio_unlink $save;
		1349	aioreq_pri 3; IO::AIO::aio_unlink "$save.pst";
		1350	}
		1351
		1352	sub rename {
		1353	my ($self, $new_path) = @_;
		1354
		1355	$self->unlink_save;
		1356
		1357	delete $cf::MAP{$self->path};
		1358	$self->{path} = new cf::path $new_path;
		1359	$self->path ($self->{path}->as_string);
		1360	$cf::MAP{$self->path} = $self;
		1361
		1362	$self->save;
		1363	}
		1364
		1365	sub reset {
		1366	my ($self) = @_;
		1367
		1368	return if $self->players;
		1369	return if $self->{path}{user_rel};#d#
		1370
		1371	warn "resetting map ", $self->path;#d#
		1372
		1373	delete $cf::MAP{$self->path};
		1374
		1375	$_->clear_links_to ($self) for values %cf::MAP;
		1376
		1377	$self->unlink_save;
		1378	$self->destroy;
		1379	}
		1380
		1381	my $nuke_counter = "aaaa";
		1382
		1383	sub nuke {
		1384	my ($self) = @_;
		1385
		1386	$self->{deny_save} = 1;
		1387	$self->reset_timeout (1);
		1388	$self->rename ("{nuke}/" . ($nuke_counter++));
		1389	$self->reset; # polite request, might not happen
		1390	}
		1391
		1392	sub customise_for {
		1393	my ($map, $ob) = @_;
		1394
		1395	if ($map->per_player) {
		1396	return cf::map::find_map "~" . $ob->name . "/" . $map->{path}{path};
		1397	}
		1398
		1399	$map
		1400	}
		1401
		1402	sub emergency_save {
		1403	local $cf::FREEZE = 1;
		1404
		1405	warn "enter emergency map save\n";
		1406
		1407	cf::sync_job {
		1408	warn "begin emergency map save\n";
		1409	$_->save for values %cf::MAP;
		1410	};
		1411
		1412	warn "end emergency map save\n";
		1413	}
		1414
		1415	package cf;
		1416
		1417	=back
		1418
		1419
1029	=head3 cf::object::player	1420	=head3 cf::object::player
1030		1421
1031	=over 4	1422	=over 4
1032		1423
1033	=item $player_object->reply ($npc, $msg[, $flags])	1424	=item $player_object->reply ($npc, $msg[, $flags])
…		…
1066		1457
1067	$self->flag (cf::FLAG_WIZ) \|\|	1458	$self->flag (cf::FLAG_WIZ) \|\|
1068	(ref $cf::CFG{"may_$access"}	1459	(ref $cf::CFG{"may_$access"}
1069	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}	1460	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}
1070	: $cf::CFG{"may_$access"})	1461	: $cf::CFG{"may_$access"})
		1462	}
		1463
		1464	=item $player_object->enter_link
		1465
		1466	Freezes the player and moves him/her to a special map (C<{link}>).
		1467
		1468	The player should be reaosnably safe there for short amounts of time. You
		1469	I<MUST> call C<leave_link> as soon as possible, though.
		1470
		1471	=item $player_object->leave_link ($map, $x, $y)
		1472
		1473	Moves the player out of the specila link map onto the given map. If the
		1474	map is not valid (or omitted), the player will be moved back to the
		1475	location he/she was before the call to C<enter_link>, or, if that fails,
		1476	to the emergency map position.
		1477
		1478	Might block.
		1479
		1480	=cut
		1481
		1482	sub cf::object::player::enter_link {
		1483	my ($self) = @_;
		1484
		1485	$self->deactivate_recursive;
		1486
		1487	return if $self->map == $LINK_MAP;
		1488
		1489	$self->{_link_pos} \|\|= [$self->map->{path}, $self->x, $self->y]
		1490	if $self->map;
		1491
		1492	$self->enter_map ($LINK_MAP, 20, 20);
		1493	}
		1494
		1495	sub cf::object::player::leave_link {
		1496	my ($self, $map, $x, $y) = @_;
		1497
		1498	my $link_pos = delete $self->{_link_pos};
		1499
		1500	unless ($map) {
		1501	# restore original map position
		1502	($map, $x, $y) = @{ $link_pos \|\| [] };
		1503	$map = cf::map::find_map $map;
		1504
		1505	unless ($map) {
		1506	($map, $x, $y) = @$EMERGENCY_POSITION;
		1507	$map = cf::map::find_map $map
		1508	or die "FATAL: cannot load emergency map\n";
		1509	}
		1510	}
		1511
		1512	($x, $y) = (-1, -1)
		1513	unless (defined $x) && (defined $y);
		1514
		1515	# use -1 or undef as default coordinates, not 0, 0
		1516	($x, $y) = ($map->enter_x, $map->enter_y)
		1517	if $x <=0 && $y <= 0;
		1518
		1519	$map->load;
		1520
		1521	$self->activate_recursive;
		1522	$self->enter_map ($map, $x, $y);
		1523	}
		1524
		1525	cf::player->attach (
		1526	on_logout => sub {
		1527	my ($pl) = @_;
		1528
		1529	# abort map switching before logout
		1530	if ($pl->ob->{_link_pos}) {
		1531	cf::sync_job {
		1532	$pl->ob->leave_link
		1533	};
		1534	}
		1535	},
		1536	on_login => sub {
		1537	my ($pl) = @_;
		1538
		1539	# try to abort aborted map switching on player login :)
		1540	# should happen only on crashes
		1541	if ($pl->ob->{_link_pos}) {
		1542	$pl->ob->enter_link;
		1543	Coro::async {
		1544	# we need this sleep as the login has a concurrent enter_exit running
		1545	# and this sleep increases chances of the player not ending up in scorn
		1546	Coro::Timer::sleep 1;
		1547	$pl->ob->leave_link;
		1548	};
		1549	}
		1550	},
		1551	);
		1552
		1553	=item $player_object->goto_map ($path, $x, $y)
		1554
		1555	=cut
		1556
		1557	sub cf::object::player::goto_map {
		1558	my ($self, $path, $x, $y) = @_;
		1559
		1560	$self->enter_link;
		1561
		1562	(Coro::async {
		1563	$path = new cf::path $path;
		1564
		1565	my $map = cf::map::find_map $path->as_string;
		1566	$map = $map->customise_for ($self) if $map;
		1567
		1568	# warn "entering ", $map->path, " at ($x, $y)\n"
		1569	# if $map;
		1570
		1571	$map or $self->message ("The exit is closed", cf::NDI_UNIQUE \| cf::NDI_RED);
		1572
		1573	$self->leave_link ($map, $x, $y);
		1574	})->prio (1);
		1575	}
		1576
		1577	=item $player_object->enter_exit ($exit_object)
		1578
		1579	=cut
		1580
		1581	sub parse_random_map_params {
		1582	my ($spec) = @_;
		1583
		1584	my $rmp = { # defaults
		1585	xsize => 10,
		1586	ysize => 10,
		1587	};
		1588
		1589	for (split /\n/, $spec) {
		1590	my ($k, $v) = split /\s+/, $_, 2;
		1591
		1592	$rmp->{lc $k} = $v if (length $k) && (length $v);
		1593	}
		1594
		1595	$rmp
		1596	}
		1597
		1598	sub prepare_random_map {
		1599	my ($exit) = @_;
		1600
		1601	# all this does is basically replace the /! path by
		1602	# a new random map path (?random/...) with a seed
		1603	# that depends on the exit object
		1604
		1605	my $rmp = parse_random_map_params $exit->msg;
		1606
		1607	if ($exit->map) {
		1608	$rmp->{region} = $exit->map->region_name;
		1609	$rmp->{origin_map} = $exit->map->path;
		1610	$rmp->{origin_x} = $exit->x;
		1611	$rmp->{origin_y} = $exit->y;
		1612	}
		1613
		1614	$rmp->{random_seed} \|\|= $exit->random_seed;
		1615
		1616	my $data = cf::to_json $rmp;
		1617	my $md5 = Digest::MD5::md5_hex $data;
		1618
		1619	if (my $fh = aio_open "$cf::RANDOM_MAPS/$md5.meta", O_WRONLY \| O_CREAT, 0666) {
		1620	aio_write $fh, 0, (length $data), $data, 0;
		1621
		1622	$exit->slaying ("?random/$md5");
		1623	$exit->msg (undef);
		1624	}
		1625	}
		1626
		1627	sub cf::object::player::enter_exit {
		1628	my ($self, $exit) = @_;
		1629
		1630	return unless $self->type == cf::PLAYER;
		1631
		1632	$self->enter_link;
		1633
		1634	(Coro::async {
		1635	unless (eval {
		1636
		1637	prepare_random_map $exit
		1638	if $exit->slaying eq "/!";
		1639
		1640	my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;
		1641	$self->goto_map ($path, $exit->stats->hp, $exit->stats->sp);
		1642
		1643	1;
		1644	}) {
		1645	$self->message ("Something went wrong deep within the crossfire server. "
		1646	. "I'll try to bring you back to the map you were before. "
		1647	. "Please report this to the dungeon master",
		1648	cf::NDI_UNIQUE \| cf::NDI_RED);
		1649
		1650	warn "ERROR in enter_exit: $@";
		1651	$self->leave_link;
		1652	}
		1653	})->prio (1);
1071	}	1654	}
1072		1655
1073	=head3 cf::client	1656	=head3 cf::client
1074		1657
1075	=over 4	1658	=over 4
…		…
1334		1917
1335	{	1918	{
1336	my $path = cf::localdir . "/database.pst";	1919	my $path = cf::localdir . "/database.pst";
1337		1920
1338	sub db_load() {	1921	sub db_load() {
1339	warn "loading database $path\n";#d# remove later
1340	$DB = stat $path ? Storable::retrieve $path : { };	1922	$DB = stat $path ? Storable::retrieve $path : { };
1341	}	1923	}
1342		1924
1343	my $pid;	1925	my $pid;
1344		1926
1345	sub db_save() {	1927	sub db_save() {
1346	warn "saving database $path\n";#d# remove later
1347	waitpid $pid, 0 if $pid;	1928	waitpid $pid, 0 if $pid;
1348	if (0 == ($pid = fork)) {	1929	if (0 == ($pid = fork)) {
1349	$DB->{_meta}{version} = 1;	1930	$DB->{_meta}{version} = 1;
1350	Storable::nstore $DB, "$path~";	1931	Storable::nstore $DB, "$path~";
1351	rename "$path~", $path;	1932	rename "$path~", $path;
…		…
1404	}	1985	}
1405		1986
1406	sub main {	1987	sub main {
1407	# we must not ever block the main coroutine	1988	# we must not ever block the main coroutine
1408	local $Coro::idle = sub {	1989	local $Coro::idle = sub {
1409	Carp::cluck "FATAL: Coro::idle was called, major BUG\n";#d#	1990	Carp::cluck "FATAL: Coro::idle was called, major BUG, use cf::sync_job!\n";#d#
1410	(Coro::unblock_sub {	1991	(Coro::unblock_sub {
1411	Event::one_event;	1992	Event::one_event;
1412	})->();	1993	})->();
1413	};	1994	};
1414		1995
…		…
1419	}	2000	}
1420		2001
1421	#############################################################################	2002	#############################################################################
1422	# initialisation	2003	# initialisation
1423		2004
1424	sub perl_reload() {	2005	sub reload() {
1425	# can/must only be called in main	2006	# can/must only be called in main
1426	if ($Coro::current != $Coro::main) {	2007	if ($Coro::current != $Coro::main) {
1427	warn "can only reload from main coroutine\n";	2008	warn "can only reload from main coroutine\n";
1428	return;	2009	return;
1429	}	2010	}
…		…
1522	$LINK_MAP->height (41);	2103	$LINK_MAP->height (41);
1523	$LINK_MAP->alloc;	2104	$LINK_MAP->alloc;
1524	$LINK_MAP->path ("{link}");	2105	$LINK_MAP->path ("{link}");
1525	$LINK_MAP->{path} = bless { path => "{link}" }, "cf::path";	2106	$LINK_MAP->{path} = bless { path => "{link}" }, "cf::path";
1526	$LINK_MAP->in_memory (MAP_IN_MEMORY);	2107	$LINK_MAP->in_memory (MAP_IN_MEMORY);
		2108
		2109	# dirty hack because... archetypes are not yet loaded
		2110	Event->timer (
		2111	after => 2,
		2112	cb => sub {
		2113	$_[0]->w->cancel;
		2114
		2115	# provide some exits "home"
		2116	my $exit = cf::object::new "exit";
		2117
		2118	$exit->slaying ($EMERGENCY_POSITION->[0]);
		2119	$exit->stats->hp ($EMERGENCY_POSITION->[1]);
		2120	$exit->stats->sp ($EMERGENCY_POSITION->[2]);
		2121
		2122	$LINK_MAP->insert ($exit->clone, 19, 19);
		2123	$LINK_MAP->insert ($exit->clone, 19, 20);
		2124	$LINK_MAP->insert ($exit->clone, 19, 21);
		2125	$LINK_MAP->insert ($exit->clone, 20, 19);
		2126	$LINK_MAP->insert ($exit->clone, 20, 21);
		2127	$LINK_MAP->insert ($exit->clone, 21, 19);
		2128	$LINK_MAP->insert ($exit->clone, 21, 20);
		2129	$LINK_MAP->insert ($exit->clone, 21, 21);
		2130
		2131	$exit->destroy;
		2132	});
		2133
		2134	$LINK_MAP->{deny_save} = 1;
		2135	$LINK_MAP->{deny_reset} = 1;
		2136
		2137	$cf::MAP{$LINK_MAP->path} = $LINK_MAP;
1527	}	2138	}
1528		2139
1529	register "<global>", __PACKAGE__;	2140	register "<global>", __PACKAGE__;
1530		2141
1531	register_command "perl-reload" => sub {	2142	register_command "reload" => sub {
1532	my ($who, $arg) = @_;	2143	my ($who, $arg) = @_;
1533		2144
1534	if ($who->flag (FLAG_WIZ)) {	2145	if ($who->flag (FLAG_WIZ)) {
1535	$who->message ("start of reload.");	2146	$who->message ("start of reload.");
1536	perl_reload;	2147	reload;
1537	$who->message ("end of reload.");	2148	$who->message ("end of reload.");
1538	}	2149	}
1539	};	2150	};
1540		2151
1541	unshift @INC, $LIBDIR;	2152	unshift @INC, $LIBDIR;
…		…
1581	or warn "ERROR: unable to write runtime file: $!";	2192	or warn "ERROR: unable to write runtime file: $!";
1582	})->();	2193	})->();
1583	},	2194	},
1584	);	2195	);
1585		2196
		2197	END { cf::emergency_save }
		2198
1586	1	2199	1
1587		2200

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.126 by root, Tue Jan 2 23:12:47 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.126 by root, Tue Jan 2 23:12:47 2007 UTC