[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.145 by root, Sun Jan 7 21:54:59 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;
19		19
20	use Digest::MD5;	20	use Digest::MD5;
21	use Fcntl;	21	use Fcntl;
22	use IO::AIO 2.31 ();	22	use IO::AIO 2.32 ();
23	use YAML::Syck ();	23	use YAML::Syck ();
24	use Time::HiRes;	24	use Time::HiRes;
25		25
26	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
27		27
28	# work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode?	28	# work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode?
29	$YAML::Syck::ImplicitUnicode = 1;	29	$YAML::Syck::ImplicitUnicode = 1;
30		30
31	$Coro::main->prio (2); # run main coroutine ("the server") with very high priority	31	$Coro::main->prio (Coro::PRIO_MAX); # run main coroutine ("the server") with very high priority
32		32
33	sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload	33	sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload
34		34
35	our %COMMAND = ();	35	our %COMMAND = ();
36	our %COMMAND_TIME = ();	36	our %COMMAND_TIME = ();
…		…
47	our %CFG;	47	our %CFG;
48		48
49	our $UPTIME; $UPTIME \|\|= time;	49	our $UPTIME; $UPTIME \|\|= time;
50	our $RUNTIME;	50	our $RUNTIME;
51		51
		52	our %PLAYER; # all users
52	our %MAP; # all maps	53	our %MAP; # all maps
53	our $LINK_MAP; # the special {link} map	54	our $LINK_MAP; # the special {link} map
54	our $FREEZE;
55	our $RANDOM_MAPS = cf::localdir . "/random";	55	our $RANDOM_MAPS = cf::localdir . "/random";
56	our %EXT_CORO;	56	our %EXT_CORO; # coroutines bound to extensions
57		57
58	binmode STDOUT;	58	binmode STDOUT;
59	binmode STDERR;	59	binmode STDERR;
60		60
61	# read virtual server time, if available	61	# read virtual server time, if available
…		…
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	our $EMERGENCY_POSITION;
76		77
77	#############################################################################	78	#############################################################################
78		79
79	=head2 GLOBAL VARIABLES	80	=head2 GLOBAL VARIABLES
80		81
…		…
179	sub to_json($) {	180	sub to_json($) {
180	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs	181	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs
181	JSON::Syck::Dump $_[0]	182	JSON::Syck::Dump $_[0]
182	}	183	}
183		184
		185	=item cf::lock_wait $string
		186
		187	Wait until the given lock is available. See cf::lock_acquire.
		188
		189	=item my $lock = cf::lock_acquire $string
		190
		191	Wait until the given lock is available and then acquires it and returns
		192	a Coro::guard object. If the guard object gets destroyed (goes out of scope,
		193	for example when the coroutine gets canceled), the lock is automatically
		194	returned.
		195
		196	Lock names should begin with a unique identifier (for example, cf::map::find
		197	uses map_find and cf::map::load uses map_load).
		198
		199	=cut
		200
		201	our %LOCK;
		202
		203	sub lock_wait($) {
		204	my ($key) = @_;
		205
		206	# wait for lock, if any
		207	while ($LOCK{$key}) {
		208	push @{ $LOCK{$key} }, $Coro::current;
		209	Coro::schedule;
		210	}
		211	}
		212
		213	sub lock_acquire($) {
		214	my ($key) = @_;
		215
		216	# wait, to be sure we are not locked
		217	lock_wait $key;
		218
		219	$LOCK{$key} = [];
		220
		221	Coro::guard {
		222	# wake up all waiters, to be on the safe side
		223	$_->ready for @{ delete $LOCK{$key} };
		224	}
		225	}
		226
		227	sub freeze_mainloop {
		228	return unless $TICK_WATCHER->is_active;
		229
		230	my $guard = Coro::guard { $TICK_WATCHER->start };
		231	$TICK_WATCHER->stop;
		232	$guard
		233	}
		234
		235	=item cf::async { BLOCK }
		236
		237	Currently the same as Coro::async_pool, meaning you cannot use
		238	C<on_destroy>, C<join> or other gimmicks on these coroutines. The only
		239	thing you are allowed to do is call C<prio> on it.
		240
		241	=cut
		242
		243	BEGIN { *async = \&Coro::async_pool }
		244
184	=item cf::sync_job { BLOCK }	245	=item cf::sync_job { BLOCK }
185		246
186	The design of crossfire+ requires that the main coro ($Coro::main) is	247	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	248	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.	249	reentrant. Thus "blocking" it by e.g. waiting for I/O is not acceptable.
…		…
195	=cut	256	=cut
196		257
197	sub sync_job(&) {	258	sub sync_job(&) {
198	my ($job) = @_;	259	my ($job) = @_;
199		260
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) {	261	if ($Coro::current == $Coro::main) {
		262	# this is the main coro, too bad, we have to block
		263	# till the operation succeeds, freezing the server :/
		264
		265	# TODO: use suspend/resume instead
		266	# (but this is cancel-safe)
		267	my $freeze_guard = freeze_mainloop;
		268
		269	my $busy = 1;
		270	my @res;
		271
		272	(async {
		273	@res = eval { $job->() };
		274	warn $@ if $@;
		275	undef $busy;
213	$coro->prio (Coro::PRIO_MAX);	276	})->prio (Coro::PRIO_MAX);
		277
214	while ($busy) {	278	while ($busy) {
215	Coro::cede_notself;	279	Coro::cede or Event::one_event;
216	Event::one_event unless Coro::nready;
217	}	280	}
		281
		282	wantarray ? @res : $res[0]
218	} else {	283	} else {
219	$coro->join;	284	# we are in another coroutine, how wonderful, everything just works
		285
		286	$job->()
220	}	287	}
221
222	wantarray ? @res : $res[0]
223	}	288	}
224		289
225	=item $coro = cf::coro { BLOCK }	290	=item $coro = cf::async_ext { BLOCK }
226		291
227	Creates and returns a new coro. This coro is automcatially being canceled	292	Like async, but this coro is automcatially being canceled when the
228	when the extension calling this is being unloaded.	293	extension calling this is being unloaded.
229		294
230	=cut	295	=cut
231		296
232	sub coro(&) {	297	sub async_ext(&) {
233	my $cb = shift;	298	my $cb = shift;
234		299
235	my $coro; $coro = async {	300	my $coro = &Coro::async ($cb);
236	eval {
237	$cb->();
238	};
239	warn $@ if $@;
240	};
241		301
242	$coro->on_destroy (sub {	302	$coro->on_destroy (sub {
243	delete $EXT_CORO{$coro+0};	303	delete $EXT_CORO{$coro+0};
244	});	304	});
245	$EXT_CORO{$coro+0} = $coro;	305	$EXT_CORO{$coro+0} = $coro;
…		…
251	my $runtime = cf::localdir . "/runtime";	311	my $runtime = cf::localdir . "/runtime";
252		312
253	my $fh = aio_open "$runtime~", O_WRONLY \| O_CREAT, 0644	313	my $fh = aio_open "$runtime~", O_WRONLY \| O_CREAT, 0644
254	or return;	314	or return;
255		315
256	my $value = $cf::RUNTIME;	316	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	317	(aio_write $fh, 0, (length $value), $value, 0) <= 0
258	and return;	318	and return;
259		319
260	aio_fsync $fh	320	aio_fsync $fh
261	and return;	321	and return;
…		…
278	package cf::path;	338	package cf::path;
279		339
280	sub new {	340	sub new {
281	my ($class, $path, $base) = @_;	341	my ($class, $path, $base) = @_;
282		342
		343	$path = $path->as_string if ref $path;
		344
283	my $self = bless { }, $class;	345	my $self = bless { }, $class;
284		346
		347	# {... are special paths that are not touched
		348	# ?xxx/... are special absolute paths
		349	# ?random/... random maps
		350	# /! non-realised random map exit
		351	# /... normal maps
		352	# ~/... per-player maps without a specific player (DO NOT USE)
		353	# ~user/... per-player map of a specific user
		354
		355	if ($path =~ /^{/) {
		356	# fine as it is
285	if ($path =~ s{^\?random/}{}) {	357	} elsif ($path =~ s{^\?random/}{}) {
		358	Coro::AIO::aio_load "$cf::RANDOM_MAPS/$path.meta", my $data;
286	$self->{random} = cf::from_json $path;	359	$self->{random} = cf::from_json $data;
287	} else {	360	} else {
288	if ($path =~ s{^~([^/]+)?}{}) {	361	if ($path =~ s{^~([^/]+)?}{}) {
289	$self->{user_rel} = 1;	362	$self->{user_rel} = 1;
290		363
291	if (defined $1) {	364	if (defined $1) {
…		…
324		397
325	# the displayed name, this is a one way mapping	398	# the displayed name, this is a one way mapping
326	sub visible_name {	399	sub visible_name {
327	my ($self) = @_;	400	my ($self) = @_;
328		401
329	$self->{random} ? "?random/$self->{random}{origin_map}+$self->{random}{origin_x}+$self->{random}{origin_y}/$self->{random}{dungeon_level}"	402	# if (my $rmp = $self->{random}) {
330	: $self->as_string	403	# # todo: be more intelligent about this
		404	# "?random/$rmp->{origin_map}+$rmp->{origin_x}+$rmp->{origin_y}/$rmp->{dungeon_level}"
		405	# } else {
		406	$self->as_string
		407	# }
331	}	408	}
332		409
333	# escape the /'s in the path	410	# escape the /'s in the path
334	sub _escaped_path {	411	sub _escaped_path {
335	# ∕ is U+2215	412	# ∕ is U+2215
…		…
347	# the temporary/swap location	424	# the temporary/swap location
348	sub save_path {	425	sub save_path {
349	my ($self) = @_;	426	my ($self) = @_;
350		427
351	$self->{user_rel} ? sprintf "%s/%s/%s/%s", cf::localdir, cf::playerdir, $self->{user}, $self->_escaped_path	428	$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}	429	: $self->{random} ? sprintf "%s/%s", $RANDOM_MAPS, $self->{path}
353	: sprintf "%s/%s/%s", cf::localdir, cf::tmpdir, $self->_escaped_path	430	: sprintf "%s/%s/%s", cf::localdir, cf::tmpdir, $self->_escaped_path
354	}	431	}
355		432
356	# the unique path, might be eq to save_path	433	# the unique path, might be eq to save_path
357	sub uniq_path {	434	sub uniq_path {
…		…
790	or return;	867	or return;
791		868
792	unless (aio_stat "$filename.pst") {	869	unless (aio_stat "$filename.pst") {
793	(aio_load "$filename.pst", $av) >= 0	870	(aio_load "$filename.pst", $av) >= 0
794	or return;	871	or return;
795	$av = eval { (Storable::thaw <$av>)->{objs} };	872	$av = eval { (Storable::thaw $av)->{objs} };
796	}	873	}
797		874
		875	warn sprintf "loading %s (%d)\n",
		876	$filename, length $data, scalar @{$av \|\| []};#d#
798	return ($data, $av);	877	return ($data, $av);
799	}	878	}
800		879
801	#############################################################################	880	#############################################################################
802	# command handling &c	881	# command handling &c
…		…
993		1072
994	=head2 CORE EXTENSIONS	1073	=head2 CORE EXTENSIONS
995		1074
996	Functions and methods that extend core crossfire objects.	1075	Functions and methods that extend core crossfire objects.
997		1076
		1077	=cut
		1078
		1079	package cf::player;
		1080
998	=head3 cf::player	1081	=head3 cf::player
999		1082
1000	=over 4	1083	=over 4
1001		1084
1002	=item cf::player::exists $login	1085	=item cf::player::find $login
1003		1086
1004	Returns true when the given account exists.	1087	Returns the given player object, loading it if necessary (might block).
1005		1088
1006	=cut	1089	=cut
1007		1090
1008	sub cf::player::exists($) {	1091	sub playerdir($) {
1009	cf::player::find $_[0]	1092	cf::localdir
1010	or -f sprintf "%s/%s/%s/%s.pl", cf::localdir, cf::playerdir, ($_[0]) x 2;	1093	. "/"
		1094	. cf::playerdir
		1095	. "/"
		1096	. (ref $_[0] ? $_[0]->ob->name : $_[0])
		1097	}
		1098
		1099	sub path($) {
		1100	my $login = ref $_[0] ? $_[0]->ob->name : $_[0];
		1101
		1102	(playerdir $login) . "/$login.pl"
		1103	}
		1104
		1105	sub find_active($) {
		1106	$cf::PLAYER{$_[0]}
		1107	and $cf::PLAYER{$_[0]}->active
		1108	and $cf::PLAYER{$_[0]}
		1109	}
		1110
		1111	sub exists($) {
		1112	my ($login) = @_;
		1113
		1114	$cf::PLAYER{$login}
		1115	or cf::sync_job { !aio_stat $login }
		1116	}
		1117
		1118	sub find($) {
		1119	return $cf::PLAYER{$_[0]} \|\| do {
		1120	my $login = $_[0];
		1121
		1122	my $guard = cf::lock_acquire "user_find:$login";
		1123
		1124	$cf::PLAYER{$login} \|\|= (load_pl path $login or return);
		1125	};
		1126	}
		1127
		1128	sub save($) {
		1129	my ($pl) = @_;
		1130
		1131	return if $pl->{deny_save};
		1132
		1133	my $path = path $pl;
		1134	my $guard = cf::lock_acquire "user_save:$path";
		1135
		1136	return if $pl->{deny_save};
		1137	$pl->{last_save} = $cf::RUNTIME;
		1138
		1139	Coro::cede;
		1140	$pl->save_pl ($path);
		1141	Coro::cede;
		1142	}
		1143
		1144	sub new($) {
		1145	my ($login) = @_;
		1146
		1147	my $self = create;
		1148
		1149	$self->ob->name ($login);
		1150	$self->{deny_save} = 1;
		1151
		1152	$cf::PLAYER{$login} = $self;
		1153
		1154	$self
		1155	}
		1156
		1157	sub quit_character {
		1158	my ($pl) = @_;
		1159
		1160	$pl->{deny_save} = 1;
		1161	$pl->password ("*"); # this should lock out the player until we nuked the dir
		1162
		1163	$pl->invoke (cf::EVENT_PLAYER_LOGOUT, 1) if $pl->active;
		1164	$pl->deactivate;
		1165	$pl->invoke (cf::EVENT_PLAYER_QUIT);
		1166	$pl->ns->destroy if $pl->ns;
		1167
		1168	my $path = playerdir $pl;
		1169	my $temp = "$path~$cf::RUNTIME~deleting~";
		1170	IO::AIO::aio_rename $path, $temp, sub {
		1171	delete $cf::PLAYER{$pl->ob->name};
		1172	$pl->destroy;
		1173
		1174	IO::AIO::aio_rmtree $temp;
		1175	};
1011	}	1176	}
1012		1177
1013	=item $player->ext_reply ($msgid, $msgtype, %msg)	1178	=item $player->ext_reply ($msgid, $msgtype, %msg)
1014		1179
1015	Sends an ext reply to the player.	1180	Sends an ext reply to the player.
1016		1181
1017	=cut	1182	=cut
1018		1183
1019	sub cf::player::ext_reply($$$%) {	1184	sub ext_reply($$$%) {
1020	my ($self, $id, %msg) = @_;	1185	my ($self, $id, %msg) = @_;
1021		1186
1022	$msg{msgid} = $id;	1187	$msg{msgid} = $id;
1023		1188
1024	$self->send ("ext " . to_json \%msg);	1189	$self->send ("ext " . cf::to_json \%msg);
1025	}	1190	}
		1191
		1192	package cf;
1026		1193
1027	=back	1194	=back
		1195
		1196
		1197	=head3 cf::map
		1198
		1199	=over 4
		1200
		1201	=cut
		1202
		1203	package cf::map;
		1204
		1205	use Fcntl;
		1206	use Coro::AIO;
		1207
		1208	our $MAX_RESET = 3600;
		1209	our $DEFAULT_RESET = 3000;
		1210
		1211	sub generate_random_map {
		1212	my ($path, $rmp) = @_;
		1213
		1214	# mit "rum" bekleckern, nicht
		1215	cf::map::_create_random_map
		1216	$path,
		1217	$rmp->{wallstyle}, $rmp->{wall_name}, $rmp->{floorstyle}, $rmp->{monsterstyle},
		1218	$rmp->{treasurestyle}, $rmp->{layoutstyle}, $rmp->{doorstyle}, $rmp->{decorstyle},
		1219	$rmp->{origin_map}, $rmp->{final_map}, $rmp->{exitstyle}, $rmp->{this_map},
		1220	$rmp->{exit_on_final_map},
		1221	$rmp->{xsize}, $rmp->{ysize},
		1222	$rmp->{expand2x}, $rmp->{layoutoptions1}, $rmp->{layoutoptions2}, $rmp->{layoutoptions3},
		1223	$rmp->{symmetry}, $rmp->{difficulty}, $rmp->{difficulty_given}, $rmp->{difficulty_increase},
		1224	$rmp->{dungeon_level}, $rmp->{dungeon_depth}, $rmp->{decoroptions}, $rmp->{orientation},
		1225	$rmp->{origin_y}, $rmp->{origin_x}, $rmp->{random_seed}, $rmp->{total_map_hp},
		1226	$rmp->{map_layout_style}, $rmp->{treasureoptions}, $rmp->{symmetry_used},
		1227	(cf::region::find $rmp->{region})
		1228	}
		1229
		1230	# and all this just because we cannot iterate over
		1231	# all maps in C++...
		1232	sub change_all_map_light {
		1233	my ($change) = @_;
		1234
		1235	$_->change_map_light ($change)
		1236	for grep $_->outdoor, values %cf::MAP;
		1237	}
		1238
		1239	sub try_load_header($) {
		1240	my ($path) = @_;
		1241
		1242	utf8::encode $path;
		1243	aio_open $path, O_RDONLY, 0
		1244	or return;
		1245
		1246	my $map = cf::map::new
		1247	or return;
		1248
		1249	# for better error messages only, will be overwritten
		1250	$map->path ($path);
		1251
		1252	$map->load_header ($path)
		1253	or return;
		1254
		1255	$map->{load_path} = $path;
		1256
		1257	$map
		1258	}
		1259
		1260	sub find;
		1261	sub find {
		1262	my ($path, $origin) = @_;
		1263
		1264	#warn "find<$path,$origin>\n";#d#
		1265
		1266	$path = new cf::path $path, $origin && $origin->path;
		1267	my $key = $path->as_string;
		1268
		1269	cf::lock_wait "map_find:$key";
		1270
		1271	$cf::MAP{$key} \|\| do {
		1272	my $guard = cf::lock_acquire "map_find:$key";
		1273
		1274	# do it the slow way
		1275	my $map = try_load_header $path->save_path;
		1276
		1277	Coro::cede;
		1278
		1279	if ($map) {
		1280	$map->last_access ((delete $map->{last_access})
		1281	\|\| $cf::RUNTIME); #d#
		1282	# safety
		1283	$map->{instantiate_time} = $cf::RUNTIME
		1284	if $map->{instantiate_time} > $cf::RUNTIME;
		1285	} else {
		1286	if (my $rmp = $path->random_map_params) {
		1287	$map = generate_random_map $key, $rmp;
		1288	} else {
		1289	$map = try_load_header $path->load_path;
		1290	}
		1291
		1292	$map or return;
		1293
		1294	$map->{load_original} = 1;
		1295	$map->{instantiate_time} = $cf::RUNTIME;
		1296	$map->last_access ($cf::RUNTIME);
		1297	$map->instantiate;
		1298
		1299	# per-player maps become, after loading, normal maps
		1300	$map->per_player (0) if $path->{user_rel};
		1301	}
		1302
		1303	$map->path ($key);
		1304	$map->{path} = $path;
		1305	$map->{last_save} = $cf::RUNTIME;
		1306
		1307	Coro::cede;
		1308
		1309	if ($map->should_reset) {
		1310	$map->reset;
		1311	undef $guard;
		1312	$map = find $path
		1313	or return;
		1314	}
		1315
		1316	$cf::MAP{$key} = $map
		1317	}
		1318	}
		1319
		1320	sub load {
		1321	my ($self) = @_;
		1322
		1323	my $path = $self->{path};
		1324	my $guard = cf::lock_acquire "map_load:" . $path->as_string;
		1325
		1326	return if $self->in_memory != cf::MAP_SWAPPED;
		1327
		1328	$self->in_memory (cf::MAP_LOADING);
		1329
		1330	$self->alloc;
		1331	$self->load_objects ($self->{load_path}, 1)
		1332	or return;
		1333
		1334	$self->set_object_flag (cf::FLAG_OBJ_ORIGINAL, 1)
		1335	if delete $self->{load_original};
		1336
		1337	if (my $uniq = $path->uniq_path) {
		1338	utf8::encode $uniq;
		1339	if (aio_open $uniq, O_RDONLY, 0) {
		1340	$self->clear_unique_items;
		1341	$self->load_objects ($uniq, 0);
		1342	}
		1343	}
		1344
		1345	Coro::cede;
		1346
		1347	# now do the right thing for maps
		1348	$self->link_multipart_objects;
		1349
		1350	if ($self->{path}->is_style_map) {
		1351	$self->{deny_save} = 1;
		1352	$self->{deny_reset} = 1;
		1353	} else {
		1354	$self->fix_auto_apply;
		1355	$self->decay_objects;
		1356	$self->update_buttons;
		1357	$self->set_darkness_map;
		1358	$self->difficulty ($self->estimate_difficulty)
		1359	unless $self->difficulty;
		1360	$self->activate;
		1361	}
		1362
		1363	Coro::cede;
		1364
		1365	$self->in_memory (cf::MAP_IN_MEMORY);
		1366	}
		1367
		1368	sub find_sync {
		1369	my ($path, $origin) = @_;
		1370
		1371	cf::sync_job { cf::map::find $path, $origin }
		1372	}
		1373
		1374	sub do_load_sync {
		1375	my ($map) = @_;
		1376
		1377	cf::sync_job { $map->load };
		1378	}
		1379
		1380	sub save {
		1381	my ($self) = @_;
		1382
		1383	my $lock = cf::lock_acquire "map_data:" . $self->path;
		1384
		1385	$self->{last_save} = $cf::RUNTIME;
		1386
		1387	return unless $self->dirty;
		1388
		1389	my $save = $self->{path}->save_path; utf8::encode $save;
		1390	my $uniq = $self->{path}->uniq_path; utf8::encode $uniq;
		1391
		1392	$self->{load_path} = $save;
		1393
		1394	return if $self->{deny_save};
		1395
		1396	local $self->{last_access} = $self->last_access;#d#
		1397
		1398	cf::async {
		1399	$_->contr->save for $self->players;
		1400	};
		1401
		1402	if ($uniq) {
		1403	$self->save_objects ($save, cf::IO_HEADER \| cf::IO_OBJECTS);
		1404	$self->save_objects ($uniq, cf::IO_UNIQUES);
		1405	} else {
		1406	$self->save_objects ($save, cf::IO_HEADER \| cf::IO_OBJECTS \| cf::IO_UNIQUES);
		1407	}
		1408	}
		1409
		1410	sub swap_out {
		1411	my ($self) = @_;
		1412
		1413	# save first because save cedes
		1414	$self->save;
		1415
		1416	my $lock = cf::lock_acquire "map_data:" . $self->path;
		1417
		1418	return if $self->players;
		1419	return if $self->in_memory != cf::MAP_IN_MEMORY;
		1420	return if $self->{deny_save};
		1421
		1422	$self->clear;
		1423	$self->in_memory (cf::MAP_SWAPPED);
		1424	}
		1425
		1426	sub reset_at {
		1427	my ($self) = @_;
		1428
		1429	# TODO: safety, remove and allow resettable per-player maps
		1430	return 1e99 if $self->{path}{user_rel};
		1431	return 1e99 if $self->{deny_reset};
		1432
		1433	my $time = $self->fixed_resettime ? $self->{instantiate_time} : $self->last_access;
		1434	my $to = List::Util::min $MAX_RESET, $self->reset_timeout \|\| $DEFAULT_RESET;
		1435
		1436	$time + $to
		1437	}
		1438
		1439	sub should_reset {
		1440	my ($self) = @_;
		1441
		1442	$self->reset_at <= $cf::RUNTIME
		1443	}
		1444
		1445	sub unlink_save {
		1446	my ($self) = @_;
		1447
		1448	utf8::encode (my $save = $self->{path}->save_path);
		1449	aioreq_pri 3; IO::AIO::aio_unlink $save;
		1450	aioreq_pri 3; IO::AIO::aio_unlink "$save.pst";
		1451	}
		1452
		1453	sub rename {
		1454	my ($self, $new_path) = @_;
		1455
		1456	$self->unlink_save;
		1457
		1458	delete $cf::MAP{$self->path};
		1459	$self->{path} = new cf::path $new_path;
		1460	$self->path ($self->{path}->as_string);
		1461	$cf::MAP{$self->path} = $self;
		1462
		1463	$self->save;
		1464	}
		1465
		1466	sub reset {
		1467	my ($self) = @_;
		1468
		1469	my $lock = cf::lock_acquire "map_data:" . $self->path;
		1470
		1471	return if $self->players;
		1472	return if $self->{path}{user_rel};#d#
		1473
		1474	warn "resetting map ", $self->path;#d#
		1475
		1476	delete $cf::MAP{$self->path};
		1477
		1478	$_->clear_links_to ($self) for values %cf::MAP;
		1479
		1480	$self->unlink_save;
		1481	$self->destroy;
		1482	}
		1483
		1484	my $nuke_counter = "aaaa";
		1485
		1486	sub nuke {
		1487	my ($self) = @_;
		1488
		1489	$self->{deny_save} = 1;
		1490	$self->reset_timeout (1);
		1491	$self->rename ("{nuke}/" . ($nuke_counter++));
		1492	$self->reset; # polite request, might not happen
		1493	}
		1494
		1495	sub customise_for {
		1496	my ($map, $ob) = @_;
		1497
		1498	if ($map->per_player) {
		1499	return cf::map::find "~" . $ob->name . "/" . $map->{path}{path};
		1500	}
		1501
		1502	$map
		1503	}
		1504
		1505	sub emergency_save {
		1506	my $freeze_guard = cf::freeze_mainloop;
		1507
		1508	warn "enter emergency perl save\n";
		1509
		1510	cf::sync_job {
		1511	warn "begin emergency player save\n";
		1512	$_->save for values %cf::PLAYER;
		1513	warn "end emergency player save\n";
		1514
		1515	warn "begin emergency map save\n";
		1516	$_->save for values %cf::MAP;
		1517	warn "end emergency map save\n";
		1518	};
		1519
		1520	warn "leave emergency perl save\n";
		1521	}
		1522
		1523	package cf;
		1524
		1525	=back
		1526
1028		1527
1029	=head3 cf::object::player	1528	=head3 cf::object::player
1030		1529
1031	=over 4	1530	=over 4
1032		1531
…		…
1068	(ref $cf::CFG{"may_$access"}	1567	(ref $cf::CFG{"may_$access"}
1069	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}	1568	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}
1070	: $cf::CFG{"may_$access"})	1569	: $cf::CFG{"may_$access"})
1071	}	1570	}
1072		1571
		1572	=item $player_object->enter_link
		1573
		1574	Freezes the player and moves him/her to a special map (C<{link}>).
		1575
		1576	The player should be reaosnably safe there for short amounts of time. You
		1577	I<MUST> call C<leave_link> as soon as possible, though.
		1578
		1579	=item $player_object->leave_link ($map, $x, $y)
		1580
		1581	Moves the player out of the specila link map onto the given map. If the
		1582	map is not valid (or omitted), the player will be moved back to the
		1583	location he/she was before the call to C<enter_link>, or, if that fails,
		1584	to the emergency map position.
		1585
		1586	Might block.
		1587
		1588	=cut
		1589
		1590	sub cf::object::player::enter_link {
		1591	my ($self) = @_;
		1592
		1593	$self->deactivate_recursive;
		1594
		1595	return if $self->map == $LINK_MAP;
		1596
		1597	$self->{_link_pos} \|\|= [$self->map->{path}, $self->x, $self->y]
		1598	if $self->map;
		1599
		1600	$self->enter_map ($LINK_MAP, 20, 20);
		1601	}
		1602
		1603	sub cf::object::player::leave_link {
		1604	my ($self, $map, $x, $y) = @_;
		1605
		1606	my $link_pos = delete $self->{_link_pos};
		1607
		1608	unless ($map) {
		1609	# restore original map position
		1610	($map, $x, $y) = @{ $link_pos \|\| [] };
		1611	$map = cf::map::find $map;
		1612
		1613	unless ($map) {
		1614	($map, $x, $y) = @$EMERGENCY_POSITION;
		1615	$map = cf::map::find $map
		1616	or die "FATAL: cannot load emergency map\n";
		1617	}
		1618	}
		1619
		1620	($x, $y) = (-1, -1)
		1621	unless (defined $x) && (defined $y);
		1622
		1623	# use -1 or undef as default coordinates, not 0, 0
		1624	($x, $y) = ($map->enter_x, $map->enter_y)
		1625	if $x <=0 && $y <= 0;
		1626
		1627	$map->load;
		1628
		1629	return unless $self->contr->active;
		1630	$self->activate_recursive;
		1631	$self->enter_map ($map, $x, $y);
		1632	}
		1633
		1634	cf::player->attach (
		1635	on_logout => sub {
		1636	my ($pl) = @_;
		1637
		1638	# abort map switching before logout
		1639	if ($pl->ob->{_link_pos}) {
		1640	cf::sync_job {
		1641	$pl->ob->leave_link
		1642	};
		1643	}
		1644	},
		1645	on_login => sub {
		1646	my ($pl) = @_;
		1647
		1648	# try to abort aborted map switching on player login :)
		1649	# should happen only on crashes
		1650	if ($pl->ob->{_link_pos}) {
		1651	$pl->ob->enter_link;
		1652	(async {
		1653	# we need this sleep as the login has a concurrent enter_exit running
		1654	# and this sleep increases chances of the player not ending up in scorn
		1655	$pl->ob->reply (undef,
		1656	"There was an internal problem at your last logout, "
		1657	. "the server will try to bring you to your intended destination in a second.",
		1658	cf::NDI_RED);
		1659	Coro::Timer::sleep 1;
		1660	$pl->ob->leave_link;
		1661	})->prio (2);
		1662	}
		1663	},
		1664	);
		1665
		1666	=item $player_object->goto ($path, $x, $y)
		1667
		1668	=cut
		1669
		1670	sub cf::object::player::goto {
		1671	my ($self, $path, $x, $y) = @_;
		1672
		1673	$self->enter_link;
		1674
		1675	(async {
		1676	$path = new cf::path $path;
		1677
		1678	my $map = cf::map::find $path->as_string;
		1679	$map = $map->customise_for ($self) if $map;
		1680
		1681	# warn "entering ", $map->path, " at ($x, $y)\n"
		1682	# if $map;
		1683
		1684	$map or $self->message ("The exit is closed", cf::NDI_UNIQUE \| cf::NDI_RED);
		1685
		1686	$self->leave_link ($map, $x, $y);
		1687	})->prio (1);
		1688	}
		1689
		1690	=item $player_object->enter_exit ($exit_object)
		1691
		1692	=cut
		1693
		1694	sub parse_random_map_params {
		1695	my ($spec) = @_;
		1696
		1697	my $rmp = { # defaults
		1698	xsize => 10,
		1699	ysize => 10,
		1700	};
		1701
		1702	for (split /\n/, $spec) {
		1703	my ($k, $v) = split /\s+/, $_, 2;
		1704
		1705	$rmp->{lc $k} = $v if (length $k) && (length $v);
		1706	}
		1707
		1708	$rmp
		1709	}
		1710
		1711	sub prepare_random_map {
		1712	my ($exit) = @_;
		1713
		1714	# all this does is basically replace the /! path by
		1715	# a new random map path (?random/...) with a seed
		1716	# that depends on the exit object
		1717
		1718	my $rmp = parse_random_map_params $exit->msg;
		1719
		1720	if ($exit->map) {
		1721	$rmp->{region} = $exit->map->region_name;
		1722	$rmp->{origin_map} = $exit->map->path;
		1723	$rmp->{origin_x} = $exit->x;
		1724	$rmp->{origin_y} = $exit->y;
		1725	}
		1726
		1727	$rmp->{random_seed} \|\|= $exit->random_seed;
		1728
		1729	my $data = cf::to_json $rmp;
		1730	my $md5 = Digest::MD5::md5_hex $data;
		1731
		1732	if (my $fh = aio_open "$cf::RANDOM_MAPS/$md5.meta", O_WRONLY \| O_CREAT, 0666) {
		1733	aio_write $fh, 0, (length $data), $data, 0;
		1734
		1735	$exit->slaying ("?random/$md5");
		1736	$exit->msg (undef);
		1737	}
		1738	}
		1739
		1740	sub cf::object::player::enter_exit {
		1741	my ($self, $exit) = @_;
		1742
		1743	return unless $self->type == cf::PLAYER;
		1744
		1745	$self->enter_link;
		1746
		1747	(async {
		1748	$self->deactivate_recursive; # just to be sure
		1749	unless (eval {
		1750	prepare_random_map $exit
		1751	if $exit->slaying eq "/!";
		1752
		1753	my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;
		1754	$self->goto ($path, $exit->stats->hp, $exit->stats->sp);
		1755
		1756	1;
		1757	}) {
		1758	$self->message ("Something went wrong deep within the crossfire server. "
		1759	. "I'll try to bring you back to the map you were before. "
		1760	. "Please report this to the dungeon master",
		1761	cf::NDI_UNIQUE \| cf::NDI_RED);
		1762
		1763	warn "ERROR in enter_exit: $@";
		1764	$self->leave_link;
		1765	}
		1766	})->prio (1);
		1767	}
		1768
1073	=head3 cf::client	1769	=head3 cf::client
1074		1770
1075	=over 4	1771	=over 4
1076		1772
1077	=item $client->send_drawinfo ($text, $flags)	1773	=item $client->send_drawinfo ($text, $flags)
…		…
1120	on_reply => sub {	1816	on_reply => sub {
1121	my ($ns, $msg) = @_;	1817	my ($ns, $msg) = @_;
1122		1818
1123	# this weird shuffling is so that direct followup queries	1819	# this weird shuffling is so that direct followup queries
1124	# get handled first	1820	# get handled first
1125	my $queue = delete $ns->{query_queue};	1821	my $queue = delete $ns->{query_queue}
		1822	or return; # be conservative, not sure how that can happen, but we saw a crash here
1126		1823
1127	(shift @$queue)->[1]->($msg);	1824	(shift @$queue)->[1]->($msg);
1128		1825
1129	push @{ $ns->{query_queue} }, @$queue;	1826	push @{ $ns->{query_queue} }, @$queue;
1130		1827
…		…
1136	}	1833	}
1137	}	1834	}
1138	},	1835	},
1139	);	1836	);
1140		1837
1141	=item $client->coro (\&cb)	1838	=item $client->async (\&cb)
1142		1839
1143	Create a new coroutine, running the specified callback. The coroutine will	1840	Create a new coroutine, running the specified callback. The coroutine will
1144	be automatically cancelled when the client gets destroyed (e.g. on logout,	1841	be automatically cancelled when the client gets destroyed (e.g. on logout,
1145	or loss of connection).	1842	or loss of connection).
1146		1843
1147	=cut	1844	=cut
1148		1845
1149	sub cf::client::coro {	1846	sub cf::client::async {
1150	my ($self, $cb) = @_;	1847	my ($self, $cb) = @_;
1151		1848
1152	my $coro; $coro = async {	1849	my $coro = &Coro::async ($cb);
1153	eval {
1154	$cb->();
1155	};
1156	warn $@ if $@;
1157	};
1158		1850
1159	$coro->on_destroy (sub {	1851	$coro->on_destroy (sub {
1160	delete $self->{_coro}{$coro+0};	1852	delete $self->{_coro}{$coro+0};
1161	});	1853	});
1162		1854
…		…
1334		2026
1335	{	2027	{
1336	my $path = cf::localdir . "/database.pst";	2028	my $path = cf::localdir . "/database.pst";
1337		2029
1338	sub db_load() {	2030	sub db_load() {
1339	warn "loading database $path\n";#d# remove later
1340	$DB = stat $path ? Storable::retrieve $path : { };	2031	$DB = stat $path ? Storable::retrieve $path : { };
1341	}	2032	}
1342		2033
1343	my $pid;	2034	my $pid;
1344		2035
1345	sub db_save() {	2036	sub db_save() {
1346	warn "saving database $path\n";#d# remove later
1347	waitpid $pid, 0 if $pid;	2037	waitpid $pid, 0 if $pid;
1348	if (0 == ($pid = fork)) {	2038	if (0 == ($pid = fork)) {
1349	$DB->{_meta}{version} = 1;	2039	$DB->{_meta}{version} = 1;
1350	Storable::nstore $DB, "$path~";	2040	Storable::nstore $DB, "$path~";
1351	rename "$path~", $path;	2041	rename "$path~", $path;
…		…
1399	open my $fh, "<:utf8", cf::confdir . "/config"	2089	open my $fh, "<:utf8", cf::confdir . "/config"
1400	or return;	2090	or return;
1401		2091
1402	local $/;	2092	local $/;
1403	*CFG = YAML::Syck::Load <$fh>;	2093	*CFG = YAML::Syck::Load <$fh>;
		2094
		2095	$EMERGENCY_POSITION = $CFG{emergency_position} \|\| ["/world/world_105_115", 5, 37];
		2096
		2097	$cf::map::MAX_RESET = $CFG{map_max_reset} if exists $CFG{map_max_reset};
		2098	$cf::map::DEFAULT_RESET = $CFG{map_default_reset} if exists $CFG{map_default_reset};
		2099
		2100	if (exists $CFG{mlockall}) {
		2101	eval {
		2102	$CFG{mlockall} ? &mlockall : &munlockall
		2103	and die "WARNING: m(un)lockall failed: $!\n";
		2104	};
		2105	warn $@ if $@;
		2106	}
1404	}	2107	}
1405		2108
1406	sub main {	2109	sub main {
1407	# we must not ever block the main coroutine	2110	# we must not ever block the main coroutine
1408	local $Coro::idle = sub {	2111	local $Coro::idle = sub {
1409	Carp::cluck "FATAL: Coro::idle was called, major BUG\n";#d#	2112	Carp::cluck "FATAL: Coro::idle was called, major BUG, use cf::sync_job!\n";#d#
1410	(Coro::unblock_sub {
1411	Event::one_event;	2113	async { Event::one_event };
1412	})->();
1413	};	2114	};
1414		2115
1415	cfg_load;	2116	cfg_load;
1416	db_load;	2117	db_load;
1417	load_extensions;	2118	load_extensions;
…		…
1419	}	2120	}
1420		2121
1421	#############################################################################	2122	#############################################################################
1422	# initialisation	2123	# initialisation
1423		2124
1424	sub perl_reload() {	2125	sub reload() {
1425	# can/must only be called in main	2126	# can/must only be called in main
1426	if ($Coro::current != $Coro::main) {	2127	if ($Coro::current != $Coro::main) {
1427	warn "can only reload from main coroutine\n";	2128	warn "can only reload from main coroutine\n";
1428	return;	2129	return;
1429	}	2130	}
1430		2131
1431	warn "reloading...";	2132	warn "reloading...";
1432		2133
1433	local $FREEZE = 1;	2134	my $guard = freeze_mainloop;
1434	cf::emergency_save;	2135	cf::emergency_save;
1435		2136
1436	eval {	2137	eval {
1437	# if anything goes wrong in here, we should simply crash as we already saved	2138	# if anything goes wrong in here, we should simply crash as we already saved
1438		2139
…		…
1500	cf::load_extensions;	2201	cf::load_extensions;
1501		2202
1502	# reattach attachments to objects	2203	# reattach attachments to objects
1503	warn "reattach";	2204	warn "reattach";
1504	_global_reattach;	2205	_global_reattach;
		2206	reattach $_ for values %MAP;
1505	};	2207	};
1506		2208
1507	if ($@) {	2209	if ($@) {
1508	warn $@;	2210	warn $@;
1509	warn "error while reloading, exiting.";	2211	warn "error while reloading, exiting.";
…		…
1522	$LINK_MAP->height (41);	2224	$LINK_MAP->height (41);
1523	$LINK_MAP->alloc;	2225	$LINK_MAP->alloc;
1524	$LINK_MAP->path ("{link}");	2226	$LINK_MAP->path ("{link}");
1525	$LINK_MAP->{path} = bless { path => "{link}" }, "cf::path";	2227	$LINK_MAP->{path} = bless { path => "{link}" }, "cf::path";
1526	$LINK_MAP->in_memory (MAP_IN_MEMORY);	2228	$LINK_MAP->in_memory (MAP_IN_MEMORY);
		2229
		2230	# dirty hack because... archetypes are not yet loaded
		2231	Event->timer (
		2232	after => 10,
		2233	cb => sub {
		2234	$_[0]->w->cancel;
		2235
		2236	# provide some exits "home"
		2237	my $exit = cf::object::new "exit";
		2238
		2239	$exit->slaying ($EMERGENCY_POSITION->[0]);
		2240	$exit->stats->hp ($EMERGENCY_POSITION->[1]);
		2241	$exit->stats->sp ($EMERGENCY_POSITION->[2]);
		2242
		2243	$LINK_MAP->insert ($exit->clone, 19, 19);
		2244	$LINK_MAP->insert ($exit->clone, 19, 20);
		2245	$LINK_MAP->insert ($exit->clone, 19, 21);
		2246	$LINK_MAP->insert ($exit->clone, 20, 19);
		2247	$LINK_MAP->insert ($exit->clone, 20, 21);
		2248	$LINK_MAP->insert ($exit->clone, 21, 19);
		2249	$LINK_MAP->insert ($exit->clone, 21, 20);
		2250	$LINK_MAP->insert ($exit->clone, 21, 21);
		2251
		2252	$exit->destroy;
		2253	});
		2254
		2255	$LINK_MAP->{deny_save} = 1;
		2256	$LINK_MAP->{deny_reset} = 1;
		2257
		2258	$cf::MAP{$LINK_MAP->path} = $LINK_MAP;
1527	}	2259	}
1528		2260
1529	register "<global>", __PACKAGE__;	2261	register "<global>", __PACKAGE__;
1530		2262
1531	register_command "perl-reload" => sub {	2263	register_command "reload" => sub {
1532	my ($who, $arg) = @_;	2264	my ($who, $arg) = @_;
1533		2265
1534	if ($who->flag (FLAG_WIZ)) {	2266	if ($who->flag (FLAG_WIZ)) {
1535	$who->message ("start of reload.");	2267	$who->message ("start of reload.");
1536	perl_reload;	2268	reload;
1537	$who->message ("end of reload.");	2269	$who->message ("end of reload.");
1538	}	2270	}
1539	};	2271	};
1540		2272
1541	unshift @INC, $LIBDIR;	2273	unshift @INC, $LIBDIR;
…		…
1544	reentrant => 0,	2276	reentrant => 0,
1545	prio => 0,	2277	prio => 0,
1546	at => $NEXT_TICK \|\| $TICK,	2278	at => $NEXT_TICK \|\| $TICK,
1547	data => WF_AUTOCANCEL,	2279	data => WF_AUTOCANCEL,
1548	cb => sub {	2280	cb => sub {
1549	unless ($FREEZE) {
1550	cf::server_tick; # one server iteration	2281	cf::server_tick; # one server iteration
1551	$RUNTIME += $TICK;	2282	$RUNTIME += $TICK;
1552	}
1553
1554	$NEXT_TICK += $TICK;	2283	$NEXT_TICK += $TICK;
1555		2284
1556	# if we are delayed by four ticks or more, skip them all	2285	# if we are delayed by four ticks or more, skip them all
1557	$NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;	2286	$NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;
1558		2287
…		…
1581	or warn "ERROR: unable to write runtime file: $!";	2310	or warn "ERROR: unable to write runtime file: $!";
1582	})->();	2311	})->();
1583	},	2312	},
1584	);	2313	);
1585		2314
		2315	END { cf::emergency_save }
		2316
1586	1	2317	1
1587		2318

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.145 by root, Sun Jan 7 21:54:59 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.145 by root, Sun Jan 7 21:54:59 2007 UTC