[ViewVC] Diff of: cvs/deliantra/server/server/cfperl.xs

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.152 by root, Tue Jan 23 03:17:56 2007 UTC vs.
Revision 1.388 by root, Wed Jun 30 01:57:54 2010 UTC

…		…
1	/*****************************************************************************/
2	/* CrossFire, A Multiplayer game for the X Window System */
3	/*****************************************************************************/
4
5	/*	1	/*
6	* This code is placed under the GNU General Public Licence (GPL)	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
7	*	3	*
8	* Copyright (C) 2001-2005 by Chachkoff Yann	4	* Copyright (©) 2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
9	* Copyright (C) 2006 by Marc Lehmann <cf@schmorp.de>	5	*
10	*
11	* This program is free software; you can redistribute it and/or modify	6	* Deliantra is free software: you can redistribute it and/or modify it under
12	* it under the terms of the GNU General Public License as published by	7	* the terms of the Affero GNU General Public License as published by the
13	* the Free Software Foundation; either version 2 of the License, or	8	* Free Software Foundation, either version 3 of the License, or (at your
14	* (at your option) any later version.	9	* option) any later version.
15	*	10	*
16	* This program is distributed in the hope that it will be useful,	11	* This program is distributed in the hope that it will be useful,
17	* but WITHOUT ANY WARRANTY; without even the implied warranty of	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19	* GNU General Public License for more details.	14	* GNU General Public License for more details.
20	*	15	*
21	* You should have received a copy of the GNU General Public License	16	* You should have received a copy of the Affero GNU General Public License
22	* along with this program; if not, write to the Free Software	17	* and the GNU General Public License along with this program. If not, see
23	* Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA	18	* <http://www.gnu.org/licenses/>.
		19	*
		20	* The authors can be reached via e-mail to <support@deliantra.net>
24	*/	21	*/
25		22
26	#define PLUGIN_NAME "perl"	23	#include "autoconf.h"
27	#define PLUGIN_VERSION "cfperl 0.5"
28		24
29	#include <plugin_common.h>	25	#if HAVE_EXECINFO_H
30	#include <sounds.h>	26	# include <execinfo.h>
		27	#endif
		28
31	#include <cstdarg>	29	#include <cstdarg>
		30	#include <typeinfo>
		31
		32	#include "global.h"
		33	#include "../random_maps/random_map.h"
		34	#include "evthread.h"
32	#include <sproto.h>	35	#include "sproto.h"
33
34	#include "cfperl.h"
35	#include "shstr.h"
36		36
37	#include <unistd.h>	37	#include <unistd.h>
38	#if _POSIX_MEMLOCK	38	#if _POSIX_MEMLOCK
39	# include <sys/mman.h>	39	# include <sys/mman.h>
40	#endif	40	#endif
41		41
		42	#if HAVE_MALLOC_H
		43	# include <malloc.h>
		44	#endif
		45
		46	#if !__GLIBC__
		47	# define malloc_trim(pad) -1
		48	#endif
		49
42	#include <EXTERN.h>	50	#include <EXTERN.h>
43	#include <perl.h>	51	#include <perl.h>
44	#include <XSUB.h>	52	#include <XSUB.h>
45		53
46	#include "CoroAPI.h"	54	#include "CoroAPI.h"
47	#include "perlxsi.c"	55	#include "perlxsi.c"
48		56
49	extern sint64 *levels; // the experience table	57	typedef object_thawer &object_thawer_ref;
		58	typedef object_freezer &object_freezer_ref;
50		59
51	typedef object object_ornull;	60	typedef std::string std__string;
52	typedef maptile maptile_ornull;
53
54	#if IVSIZE >= 8
55	typedef IV val64;
56	# define newSVval64 newSViv
57	# define SvVAL64 SvIV
58	#else
59	typedef double val64;
60	# define newSVval64 newSVnv
61	# define SvVAL64 SvNV
62	#endif
63
64	static f_plug_api gethook = cfapi_get_hooks;
65	static f_plug_api object_set_property = cfapi_object_set_property;
66	static f_plug_api object_insert = cfapi_object_insert;
67		61
68	static PerlInterpreter *perl;	62	static PerlInterpreter *perl;
69		63
70	double runtime;	64	tstamp NOW, runtime;
		65
		66	static int tick_inhibit;
		67	static int tick_pending;
71		68
72	global gbl_ev;	69	global gbl_ev;
73	static AV cb_global, cb_attachable, cb_object, cb_player, cb_client, cb_type, *cb_map;	70	static AV cb_global, cb_attachable, cb_object, cb_player, cb_client, cb_type, *cb_map;
74	static SV *sv_runtime;	71	static SV sv_runtime, sv_tick_start, sv_next_tick, sv_now;
		72	static AV *av_reflect;
		73
		74	bitset<NUM_EVENT_TYPES> ev_want_event;
		75	bitset<NUM_TYPES> ev_want_type;
75		76
76	static HV	77	static HV
77	*stash_cf,	78	*stash_cf,
78	*stash_cf_object_wrap,	79	*stash_cf_object_wrap,
79	*stash_cf_object_player_wrap,	80	*stash_cf_object_player_wrap,
80	*stash_cf_player_wrap,	81	*stash_cf_player_wrap,
81	*stash_cf_map_wrap,	82	*stash_cf_map_wrap,
		83	*stash_cf_mapspace_wrap,
82	*stash_cf_client_wrap,	84	*stash_cf_client_wrap,
83	*stash_cf_arch_wrap,	85	*stash_cf_arch_wrap,
84	*stash_cf_party_wrap,	86	*stash_cf_party_wrap,
85	*stash_cf_region_wrap,	87	*stash_cf_region_wrap,
86	*stash_cf_living_wrap;	88	*stash_cf_living_wrap,
		89	*stash_ext_map_world;
		90
		91	static SV
		92	*cv_cf_do_invoke,
		93	*cv_cf__can_merge,
		94	*cv_cf_client_send_msg,
		95	*cv_cf_tick,
		96	*cv_cf_match_match;
		97
		98	#ifndef newSVpv_utf8
		99	static SV *
		100	newSVpv_utf8 (const char *s)
		101	{
		102	if (!s)
		103	return newSV (0);
		104
		105	SV *sv = newSVpv (s, 0);
		106	SvUTF8_on (sv);
		107	return sv;
		108	}
		109	#endif
		110
		111	#ifndef newSVpvn_utf8
		112	static SV *
		113	newSVpvn_utf8 (const char *s, STRLEN l, int utf8)
		114	{
		115	if (!s)
		116	return newSV (0);
		117
		118	SV *sv = newSVpvn (s, l);
		119
		120	if (utf8)
		121	SvUTF8_on (sv);
		122
		123	return sv;
		124	}
		125	#endif
		126
		127	noinline utf8_string
		128	cfSvPVutf8_nolen (SV *sv)
		129	{
		130	SvGETMAGIC (sv);
		131
		132	if (SvPOK (sv))
		133	{
		134	if (!SvUTF8 (sv))
		135	sv_utf8_upgrade_nomg (sv);
		136
		137	return SvPVX (sv);
		138	}
		139
		140	return SvPV_nolen (sv);
		141	}
87		142
88	// helper cast function, returns super class * or 0	143	// helper cast function, returns super class * or 0
89	template<class super>	144	template<class super>
90	static super *	145	static super *
91	is_a (attachable *at)	146	is_a (attachable *at)
102	unordered_vector<attachable *> attachable::mortals;	157	unordered_vector<attachable *> attachable::mortals;
103		158
104	attachable::~attachable ()	159	attachable::~attachable ()
105	{	160	{
106	assert (!self);	161	assert (!self);
		162	assert (!cb);
107	}	163	}
108		164
109	int	165	int
110	attachable::refcnt_cnt () const	166	attachable::refcnt_cnt () const
111	{	167	{
112	return refcnt + (self ? SvREFCNT (self) - 1 : 0);	168	return refcnt + (self ? SvREFCNT (self) - 1 : 0);
		169	}
		170
		171	void
		172	attachable::sever_self ()
		173	{
		174	if (HV *self = this->self)
		175	{
		176	// keep a refcount because sv_unmagic might call attachable_free,
		177	// which might clear self, causing sv_unmagic to crash on a now
		178	// invalid object.
		179	SvREFCNT_inc (self);
		180	hv_clear (self);
		181	sv_unmagic ((SV *)self, PERL_MAGIC_ext);
		182	SvREFCNT_dec (self);
		183
		184	// self must be null now because that's sv_unmagic's job.
		185	assert (!this->self);
		186	}
113	}	187	}
114		188
115	void	189	void
116	attachable::optimise ()	190	attachable::optimise ()
117	{	191	{
118	if (self	192	if (self
119	&& SvREFCNT (self) == 1	193	&& SvREFCNT (self) == 1
120	&& !HvTOTALKEYS (self))	194	&& !HvTOTALKEYS (self))
121	{	195	sever_self ();
122	SvREFCNT_dec ((SV *)self);
123	assert (!self);
124	}
125	}	196	}
126		197
127	// check wether the object really is dead	198	// check wether the object really is dead
128	void	199	void
129	attachable::do_check ()	200	attachable::do_check ()
130	{	201	{
131	if (refcnt_cnt () > 0)	202	if (refcnt_cnt () > 0)
132	return;	203	return;
133		204
134	destroy ();	205	destroy ();
		206	}
135		207
136	if (self)	208	void
		209	attachable::do_destroy ()
		210	{
		211	INVOKE_ATTACHABLE (DESTROY, this);
		212
		213	if (cb)
137	{	214	{
138	hv_clear (self);
139	sv_unmagic ((SV *)self, PERL_MAGIC_ext);
140	SvREFCNT_dec (self);	215	SvREFCNT_dec (cb);
141	self = 0;	216	cb = 0;
142	}	217	}
143	}
144
145	void
146	attachable::do_destroy ()
147	{
148	invoke (EVENT_ATTACHABLE_DESTROY, DT_END);
149
150	if (self)
151	hv_clear (self);
152		218
153	mortals.push_back (this);	219	mortals.push_back (this);
154	}	220	}
155		221
156	void	222	void
157	attachable::destroy ()	223	attachable::destroy ()
158	{	224	{
159	if (destroyed ())	225	if (destroyed ())
160	return;	226	return;
161		227
162	flags \|= F_DESTROYED;	228	attachable_flags \|= F_DESTROYED;
163	do_destroy ();	229	do_destroy ();
		230	sever_self ();
		231	}
		232
		233	void
		234	attachable::do_delete ()
		235	{
		236	delete this;
164	}	237	}
165		238
166	void	239	void
167	attachable::check_mortals ()	240	attachable::check_mortals ()
168	{	241	{
…		…
172	{	245	{
173	if (i >= mortals.size ())	246	if (i >= mortals.size ())
174	{	247	{
175	i = 0;	248	i = 0;
176		249
177	if (mortals.size () > 1000)	250	if (mortals.size () >= 512)
178	fprintf (stderr, "mortal queue size (%d) exceeds 1000.\n", (int)mortals.size ());	251	{
		252	static int last_mortalcount;
		253	if (mortals.size () != last_mortalcount)
		254	{
		255	last_mortalcount = mortals.size ();
		256	LOG (llevInfo, "%d mortals.\n", (int)mortals.size ());
		257
		258	if (0)
		259	{
		260	for (int j = 0; j < mortals.size (); ++j)//D
		261	fprintf (stderr, "%d:%s %p ", j, &((object *)mortals[j])->name, mortals[j]);//D
		262
		263	fprintf (stderr, "\n");//D
		264	}
		265	}
		266	}
179		267
180	break;	268	break;
181	}	269	}
182		270
183	attachable *obj = mortals [i];	271	attachable *obj = mortals [i];
184		272
185	obj->refcnt_chk (); // unborrow from perl, if necessary	273	#if 0
186		274	if (obj->self)//D make this an assert later
187	//if (obj->refcnt > 0 \|\| obj->self)
188	if (obj->refcnt \|\| obj->self)
189	{	275	{
190	//printf ("%p rc %d\n", obj, obj->refcnt_cnt ());//D	276	LOG (llevError, "check_mortals: object '%s' still has self\n", typeid (obj).name ());
		277	obj->sever_self ();
		278	}
		279	#endif
		280
		281	if (obj->refcnt)
		282	{
191	++i; // further delay freeing	283	++i; // further delay freeing
192		284
193	if (!(i & 0x3ff))	285	if (!(i & 0x3ff))
194	break;	286	break;
195	}	287	}
196	else	288	else
197	{	289	{
198	mortals.erase (i);	290	mortals.erase (i);
199	delete obj;	291	obj->sever_self ();
		292	obj->do_delete ();
200	}	293	}
201	}	294	}
202	}	295	}
203		296
		297	void
		298	attachable::set_key (const char key, const char value, bool is_utf8)
		299	{
		300	if (!self)
		301	self = newHV ();
		302
		303	if (value)
		304	hv_store (self, key, strlen (key), is_utf8 ? newSVpv_utf8 (value) : newSVpv (value, 0), 0);
		305	else
		306	hv_delete (self, key, strlen (key), G_DISCARD);
		307	}
		308
204	attachable &	309	attachable &
205	attachable::operator =(const attachable &src)	310	attachable::operator =(const attachable &src)
206	{	311	{
207	//if (self \|\| cb)	312	//if (self \|\| cb)
208	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));	313	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));
209		314
210	attach = src.attach;	315	attach = src.attach;
211	return *this;	316	return *this;
212	}	317	}
213		318
		319	#if 0
		320	template<typename T>
		321	static bool
		322	find_backref (void ptr, T obj)
		323	{
		324	char s = (char )obj;
		325	while (s < (char *)obj + sizeof (T))
		326	{
		327	if (ptr == (void *)s)
		328	return true;
		329
		330	s += sizeof (void *); // assume natural alignment
		331	}
		332
		333	return false;
		334	}
		335
		336	// for debugging, find "live" objects containing this ptr
		337	static void
		338	find_backref (void *ptr)
		339	{
		340	for_all_objects (op)
		341	if (find_backref (ptr, op))
		342	fprintf (stderr, "O %p %d:'%s'\n", op, op->count, &op->name);
		343
		344	for_all_players (pl)
		345	if (find_backref (ptr, pl))
		346	fprintf (stderr, "P %p\n", pl);
		347
		348	for_all_clients (ns)
		349	if (find_backref (ptr, ns))
		350	fprintf (stderr, "C %p\n", ns);
		351	}
		352	#endif
		353
214	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	354	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
215		355
216	static SV *	356	static SV *
217	newSVptr (void ptr, HV stash, HV *hv = newHV ())	357	newSVptr (void ptr, HV stash, HV *hv)
218	{	358	{
219	SV *sv;
220
221	if (!ptr)	359	if (!ptr)
222	return &PL_sv_undef;	360	return newSV (0);
223		361
224	sv_magicext ((SV )hv, 0, PERL_MAGIC_ext, 0, (char )ptr, 0);	362	sv_magicext ((SV )hv, 0, PERL_MAGIC_ext, 0, (char )ptr, 0);
225	return sv_bless (newRV_noinc ((SV *)hv), stash);	363	return sv_bless (newRV_noinc ((SV *)hv), stash);
226	}	364	}
227		365
		366	static SV * noinline
		367	newSVptr (void ptr, HV stash)
		368	{
		369	return newSVptr (ptr, stash, newHV ());
		370	}
		371
228	static int	372	static int
229	attachable_free (pTHX_ SV sv, MAGIC mg)	373	attachable_free (pTHX_ SV sv, MAGIC mg)
230	{	374	{
231	attachable at = (attachable )mg->mg_ptr;	375	attachable at = (attachable )mg->mg_ptr;
		376
		377	//TODO: check if transaction behaviour is really required here
		378	if (SV self = (SV )at->self)
		379	{
232	at->self = 0;	380	at->self = 0;
		381	SvREFCNT_dec (self);
		382	}
		383
233	// next line makes sense, but most objects still have refcnt 0 by default	384	// next line makes sense, but most objects still have refcnt 0 by default
234	//at->refcnt_chk ();	385	//at->refcnt_chk ();
235	return 0;	386	return 0;
236	}	387	}
237		388
238	MGVTBL attachable::vtbl = {0, 0, 0, 0, attachable_free};	389	MGVTBL attachable::vtbl = {0, 0, 0, 0, attachable_free};
239		390
240	static SV *	391	static SV * noinline
241	newSVattachable (attachable obj, HV stash)	392	newSVattachable (attachable obj, HV stash)
242	{	393	{
243	if (!obj)	394	if (!obj)
244	return &PL_sv_undef;	395	return newSV (0);
245		396
246	if (!obj->self)	397	if (!obj->self)
		398	obj->self = newHV ();
		399
		400	if (!SvOBJECT (obj->self))
247	{	401	{
248	obj->self = newHV ();
249	sv_magicext ((SV )obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char )obj, 0);	402	sv_magicext ((SV )obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char )obj, 0);
250		403
251	// now bless the object _once_	404	// now bless the object _once_
		405	//TODO: create a class registry with c++ type<=>perl name<=>stash and use it here and elsewhere
252	return sv_bless (newRV_inc ((SV *)obj->self), stash);	406	return sv_bless (newRV_inc ((SV *)obj->self), stash);
253	}	407	}
254	else	408	else
255	{	409	{
256	SV sv = newRV_inc ((SV )obj->self);	410	SV sv = newRV_inc ((SV )obj->self);
…		…
260		414
261	return sv;	415	return sv;
262	}	416	}
263	}	417	}
264		418
		419	#if 0 // unused
265	static void	420	static void
266	clearSVptr (SV *sv)	421	clearSVptr (SV *sv)
267	{	422	{
268	if (SvROK (sv))	423	if (SvROK (sv))
269	sv = SvRV (sv);	424	sv = SvRV (sv);
270		425
271	hv_clear ((HV *)sv);	426	hv_clear ((HV *)sv);
272	sv_unmagic (sv, PERL_MAGIC_ext);	427	sv_unmagic (sv, PERL_MAGIC_ext);
273	}	428	}
		429	#endif
		430
		431	static long
		432	SvPTR_nc (SV *sv)
		433	{
		434	sv = SvRV (sv);
		435
		436	// very important shortcut
		437	if (expect_true (SvMAGIC (sv) && SvMAGIC (sv)->mg_type == PERL_MAGIC_ext))
		438	return (long)SvMAGIC (sv)->mg_ptr;
		439
		440	if (MAGIC *mg = mg_find (sv, PERL_MAGIC_ext))
		441	return (long)mg->mg_ptr;
		442
		443	croak ("perl code used object, but C object is already destroyed, caught");
		444	}
274		445
275	static long	446	static long
276	SvPTR (SV sv, const char klass)	447	SvPTR (SV sv, const char klass)
277	{	448	{
278	if (!sv_derived_from (sv, klass))	449	if (!sv_derived_from (sv, klass))
279	croak ("object of type %s expected", klass);	450	croak ("object of type %s expected", klass);
280		451
281	MAGIC *mg = mg_find (SvRV (sv), PERL_MAGIC_ext);	452	return SvPTR_nc (sv);
282
283	if (!mg)
284	croak ("perl code used %s object, but C object is already destroyed, caught", klass);
285
286	return (long)mg->mg_ptr;
287	}	453	}
288		454
289	static long	455	static long noinline
290	SvPTR_ornull (SV sv, const char klass)	456	SvPTR_ornull (SV sv, const char klass)
291	{	457	{
292	if (SvOK (sv))	458	if (expect_false (!SvOK (sv))) return 0;
		459
293	return SvPTR (sv, klass);	460	return SvPTR (sv, klass);
294	else
295	return 0;
296	}	461	}
297		462
		463	static long noinline
		464	SvPTR_ornull_client (SV *sv)
		465	{
		466	if (expect_false (!SvOK (sv))) return 0;
		467
		468	if (!SvROK (sv)
		469	\|\| (SvSTASH (SvRV (sv)) != stash_cf_client_wrap
		470	&& !sv_derived_from (sv, "cf::client")))
		471	croak ("object of type cf::client expected");
		472
		473	return SvPTR_nc (sv);
		474	}
		475
		476	static long noinline
		477	SvPTR_ornull_object (SV *sv)
		478	{
		479	if (expect_false (!SvOK (sv))) return 0;
		480
		481	if (!SvROK (sv)
		482	\|\| (SvSTASH (SvRV (sv)) != stash_cf_object_wrap
		483	&& SvSTASH (SvRV (sv)) != stash_cf_object_player_wrap
		484	&& SvSTASH (SvRV (sv)) != stash_cf_arch_wrap
		485	&& !sv_derived_from (sv, "cf::object")))
		486	croak ("object of type cf::object expected");
		487
		488	return SvPTR_nc (sv);
		489	}
		490
		491	static long noinline
		492	SvPTR_ornull_maptile (SV *sv)
		493	{
		494	if (expect_false (!SvOK (sv))) return 0;
		495
		496	if (!SvROK (sv)
		497	\|\| (SvSTASH (SvRV (sv)) != stash_cf_map_wrap
		498	&& SvSTASH (SvRV (sv)) != stash_ext_map_world
		499	&& !sv_derived_from (sv, "cf::map")))
		500	croak ("object of type cf::map expected");
		501
		502	return SvPTR_nc (sv);
		503	}
		504
		505	static long noinline
		506	SvPTR_ornull_player (SV *sv)
		507	{
		508	if (expect_false (!SvOK (sv))) return 0;
		509
		510	if (!SvROK (sv)
		511	\|\| (SvSTASH (SvRV (sv)) != stash_cf_player_wrap
		512	&& !sv_derived_from (sv, "cf::player")))
		513	croak ("object of type cf::player expected");
		514
		515	return SvPTR_nc (sv);
		516	}
		517
298	inline SV to_sv (const shstr & v) { return v ? newSVpvn ((const char )v, v.length ()) : &PL_sv_undef; }	518	static inline SV to_sv (const shstr & v) { return newSVpvn_utf8 ((const char )v, v.length (), 1); }
299	inline SV to_sv (const char v) { return newSVpv (v, 0); }	519	static inline SV to_sv (const char v) { return v ? newSVpv (v, 0) : newSV (0); }
300	inline SV *to_sv (bool v) { return newSViv (v); }	520	static inline SV *to_sv (bool v) { return newSViv (v); }
301	inline SV *to_sv ( signed char v) { return newSViv (v); }	521	static inline SV *to_sv ( signed char v) { return newSViv (v); }
302	inline SV *to_sv (unsigned char v) { return newSViv (v); }	522	static inline SV *to_sv (unsigned char v) { return newSViv (v); }
303	inline SV *to_sv ( signed short v) { return newSViv (v); }	523	static inline SV *to_sv ( signed short v) { return newSViv (v); }
304	inline SV *to_sv (unsigned short v) { return newSVuv (v); }	524	static inline SV *to_sv (unsigned short v) { return newSVuv (v); }
305	inline SV *to_sv ( signed int v) { return newSViv (v); }	525	static inline SV *to_sv ( signed int v) { return newSViv (v); }
306	inline SV *to_sv (unsigned int v) { return newSVuv (v); }	526	static inline SV *to_sv (unsigned int v) { return newSVuv (v); }
307	inline SV *to_sv ( signed long v) { return newSViv (v); }	527	static inline SV *to_sv ( signed long v) { return newSViv (v); }
308	inline SV *to_sv (unsigned long v) { return newSVuv (v); }	528	static inline SV *to_sv (unsigned long v) { return newSVuv (v); }
309	inline SV *to_sv ( signed long long v) { return newSVval64 (v); }	529	static inline SV *to_sv ( signed long long v) { return newSVval64 (v); }
310	inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }	530	static inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }
311	inline SV *to_sv (float v) { return newSVnv (v); }	531	static inline SV *to_sv (float v) { return newSVnv (v); }
312	inline SV *to_sv (double v) { return newSVnv (v); }	532	static inline SV *to_sv (double v) { return newSVnv (v); }
313	inline SV to_sv (client v) { return newSVattachable (v, stash_cf_client_wrap); }	533	static inline SV to_sv (client v) { return newSVattachable (v, stash_cf_client_wrap); }
314	inline SV to_sv (player v) { return newSVattachable (v, stash_cf_player_wrap); }	534	static inline SV to_sv (player v) { return newSVattachable (v, stash_cf_player_wrap); }
		535	// gcc dislikes noilnine on to_sv
315	inline SV to_sv (object v) { return newSVattachable (v, v && v->type == PLAYER ? stash_cf_object_player_wrap : stash_cf_object_wrap); }	536	static noinline SV to_sv_ni (object v) { return newSVattachable (v, v && v->type == PLAYER ? stash_cf_object_player_wrap : stash_cf_object_wrap); }
		537	static inline SV to_sv (object v) { return to_sv_ni (v); }
316	inline SV to_sv (maptile v) { return newSVattachable (v, stash_cf_map_wrap); }	538	static inline SV to_sv (maptile v) { return newSVattachable (v, stash_cf_map_wrap); }
317	inline SV to_sv (archetype v) { return newSVattachable (v, stash_cf_arch_wrap); }	539	static inline SV to_sv (archetype v) { return newSVattachable (v, stash_cf_arch_wrap); }
		540	static inline SV to_sv (region v) { return newSVattachable (v, stash_cf_region_wrap); }
318	inline SV to_sv (partylist v) { return newSVptr (v, stash_cf_party_wrap); }	541	static inline SV to_sv (partylist v) { return newSVptr (v, stash_cf_party_wrap); }
319	inline SV to_sv (region v) { return newSVptr (v, stash_cf_region_wrap); }
320	inline SV to_sv (living v) { return newSVptr (v, stash_cf_living_wrap); }	542	static inline SV to_sv (living v) { return newSVptr (v, stash_cf_living_wrap); }
		543	static inline SV to_sv (mapspace v) { return newSVptr (v, stash_cf_mapspace_wrap); }
321		544
322	inline SV *to_sv (object & v) { return to_sv (&v); }	545	static inline SV *to_sv (object & v) { return to_sv (&v); }
323	inline SV *to_sv (living & v) { return to_sv (&v); }	546	static inline SV *to_sv (living & v) { return to_sv (&v); }
324		547
325	inline SV to_sv (facetile v) { return to_sv (v->name); }	548	static inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); }
326	inline SV to_sv (treasurelist v) { return to_sv (v->name); }	549	static inline SV to_sv (const treasurelist v) { return to_sv (v->name); }
327		550
328	inline SV *to_sv (UUID v)	551	static inline SV *to_sv (UUID v) { return newSVpv (v.c_str (), 0); }
329	{
330	char buf[128];
331	snprintf (buf, 128, "<1,%" PRIx64 ">", v.seq);
332	return newSVpv (buf, 0);
333	}
334		552
		553	static inline SV to_sv (dynbuf v)
		554	{
		555	SV *sv = newSV (0);
		556
		557	sv_upgrade (sv, SVt_PV);
		558	SvGROW (sv, v->size () + 1);
		559	SvPOK_only (sv);
		560	v->linearise (SvPVX (sv));
		561	SvCUR_set (sv, v->size ());
		562	*SvEND (sv) = 0;
		563
		564	return sv;
		565	}
		566
		567	static inline SV to_sv (dynbuf_text v)
		568	{
		569	SV sv = to_sv (static_cast<dynbuf > (v));
		570	SvUTF8_on (sv);
		571	return sv;
		572	}
		573
335	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPV_nolen (sv) : 0; }	574	static inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? cfSvPVutf8_nolen (sv) : 0; }
336	inline void sv_to (SV sv, char &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }	575	static inline void sv_to (SV sv, char &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }
337	inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }	576	static inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }
338	inline void sv_to (SV *sv, signed char &v) { v = SvIV (sv); }	577	static inline void sv_to (SV *sv, signed char &v) { v = SvIV (sv); }
339	inline void sv_to (SV *sv, unsigned char &v) { v = SvIV (sv); }	578	static inline void sv_to (SV *sv, unsigned char &v) { v = SvIV (sv); }
340	inline void sv_to (SV *sv, signed short &v) { v = SvIV (sv); }	579	static inline void sv_to (SV *sv, signed short &v) { v = SvIV (sv); }
341	inline void sv_to (SV *sv, unsigned short &v) { v = SvIV (sv); }	580	static inline void sv_to (SV *sv, unsigned short &v) { v = SvIV (sv); }
342	inline void sv_to (SV *sv, signed int &v) { v = SvIV (sv); }	581	static inline void sv_to (SV *sv, signed int &v) { v = SvIV (sv); }
343	inline void sv_to (SV *sv, unsigned int &v) { v = SvUV (sv); }	582	static inline void sv_to (SV *sv, unsigned int &v) { v = SvUV (sv); }
344	inline void sv_to (SV *sv, signed long &v) { v = SvIV (sv); }	583	static inline void sv_to (SV *sv, signed long &v) { v = SvIV (sv); }
345	inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }	584	static inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }
346	inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }	585	static inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }
347	inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }	586	static inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }
348	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }	587	static inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
349	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }	588	static inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }
350	inline void sv_to (SV sv, client &v) { v = (client )(attachable )SvPTR_ornull (sv, "cf::client"); }	589	static inline void sv_to (SV sv, client &v) { v = (client ) (attachable )SvPTR_ornull_client (sv); }
351	inline void sv_to (SV sv, player &v) { v = (player )(attachable )SvPTR_ornull (sv, "cf::player"); }	590	static inline void sv_to (SV sv, player &v) { v = (player ) (attachable )SvPTR_ornull_player (sv); }
352	inline void sv_to (SV sv, object &v) { v = (object )(attachable )SvPTR_ornull (sv, "cf::object"); }	591	static inline void sv_to (SV sv, object &v) { v = (object ) (attachable )SvPTR_ornull_object (sv); }
		592	static inline void sv_to (SV sv, maptile &v) { v = (maptile ) (attachable )SvPTR_ornull_maptile (sv); }
353	inline void sv_to (SV sv, archetype &v) { v = (archetype )(attachable )SvPTR_ornull (sv, "cf::arch"); }	593	static inline void sv_to (SV sv, archetype &v) { v = (archetype )(attachable )SvPTR_ornull (sv, "cf::arch"); }
354	inline void sv_to (SV sv, maptile &v) { v = (maptile )(attachable )SvPTR_ornull (sv, "cf::map"); }	594	static inline void sv_to (SV sv, region &v) { v = (region ) (attachable )SvPTR_ornull (sv, "cf::region"); }
355	inline void sv_to (SV sv, attachable &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); }	595	static inline void sv_to (SV sv, attachable &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); }
356	inline void sv_to (SV sv, partylist &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }	596	static inline void sv_to (SV sv, partylist &v) { v = (partylist *) SvPTR_ornull (sv, "cf::party"); }
357	inline void sv_to (SV sv, region &v) { v = (region *)SvPTR_ornull (sv, "cf::region"); }
358	inline void sv_to (SV sv, living &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }	597	static inline void sv_to (SV sv, living &v) { v = (living *) SvPTR_ornull (sv, "cf::living"); }
		598	static inline void sv_to (SV sv, mapspace &v) { v = (mapspace *) SvPTR_ornull (sv, "cf::mapspace"); }
		599	static inline void sv_to (SV sv, object_freezer &v) { v = (object_freezer *) SvPTR_ornull (sv, "cf::object::freezer"); }
		600	static inline void sv_to (SV sv, object_thawer &v) { v = (object_thawer *) SvPTR_ornull (sv, "cf::object::thawer" ); }
359		601
360	inline void sv_to (SV sv, facetile &v) { v = &new_faces[FindFace (SvPV_nolen (sv), 0)]; }	602	//static inline void sv_to (SV sv, faceinfo &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }
361	inline void sv_to (SV sv, treasurelist &v) { v = find_treasurelist (SvPV_nolen (sv)); }	603	static inline void sv_to (SV sv, treasurelist &v) { v = treasurelist::find (SvPV_nolen (sv)); }
362		604
363	template<class T>	605	template<class T>
364	inline void sv_to (SV sv, refptr<T> &v) { T tmp; sv_to (sv, tmp); v = tmp; }	606	static inline void sv_to (SV sv, refptr<T> &v) { T tmp; sv_to (sv, tmp); v = tmp; }
365		607
366	template<int N>	608	template<int N>
367	inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); }	609	static inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); }
368		610
369	inline void sv_to (SV *sv, rangetype &v) { v = (rangetype) SvIV (sv); }
370	inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); }	611	static inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); }
371	inline void sv_to (SV *sv, petmode_t &v) { v = (petmode_t) SvIV (sv); }	612	static inline void sv_to (SV *sv, petmode_t &v) { v = (petmode_t) SvIV (sv); }
372	inline void sv_to (SV *sv, usekeytype &v) { v = (usekeytype) SvIV (sv); }	613	static inline void sv_to (SV *sv, usekeytype &v) { v = (usekeytype) SvIV (sv); }
373	inline void sv_to (SV *sv, unapplymode &v) { v = (unapplymode) SvIV (sv); }	614	static inline void sv_to (SV *sv, unapplymode &v) { v = (unapplymode) SvIV (sv); }
374		615
		616	static inline void sv_to (SV *sv, std::string &v)
		617	{
		618	STRLEN len;
		619	char *data = SvPVbyte (sv, len);
		620	v.assign (data, len);
		621	}
		622
375	inline void sv_to (SV *sv, UUID &v)	623	static inline void sv_to (SV *sv, UUID &v)
376	{	624	{
377	unsigned int version;	625	if (!v.parse (SvPV_nolen (sv)))
378
379	if (2 != sscanf (SvPV_nolen (sv), "<%d.%" SCNx64 ">", &version, &v.seq) \|\| 1 != version)
380	croak ("unparsable uuid: %s", SvPV_nolen (sv));	626	croak ("unparsable uuid: %s", SvPV_nolen (sv));
381	}	627	}
382		628
383	inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }	629	static inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }
384		630
385	static SV *	631	static SV *
386	newSVdt_va (va_list &ap, data_type type)	632	newSVdt_va (va_list &ap, data_type type)
387	{	633	{
388	SV *sv;	634	SV *sv;
…		…
402	break;	648	break;
403		649
404	case DT_STRING:	650	case DT_STRING:
405	{	651	{
406	char str = (char )va_arg (ap, const char *);	652	char str = (char )va_arg (ap, const char *);
407	sv = str ? newSVpv (str, 0) : &PL_sv_undef;	653	sv = str ? newSVpv (str, 0) : newSV (0);
408	}	654	}
409	break;	655	break;
410		656
411	case DT_DATA:	657	case DT_DATA:
412	{	658	{
413	char str = (char )va_arg (ap, const void *);	659	char str = (char )va_arg (ap, const void *);
414	int len = va_arg (ap, int);	660	int len = va_arg (ap, int);
415	sv = str ? newSVpv (str, len) : &PL_sv_undef;	661	sv = str ? newSVpv (str, len) : newSV (0);
416	}	662	}
417	break;	663	break;
418		664
419	case DT_OBJECT:	665	case DT_OBJECT:
420	sv = to_sv (va_arg (ap, object *));	666	sv = to_sv (va_arg (ap, object *));
…		…
462	va_end (ap);	708	va_end (ap);
463		709
464	return sv;	710	return sv;
465	}	711	}
466		712
		713	// typemap support, mostly to avoid excessive inlining
		714	template<class type>
		715	static void noinline
		716	cf_obj_to (SV *arg, type &var)
		717	{
		718	sv_to (arg, var);
		719	if (expect_false (!var))
		720	croak ("must not pass invalid/null cf_obj here");
		721	}
		722
		723	template<class object>
		724	static void noinline
		725	cf_obj_ornull_to (SV arg, object &var)
		726	{
		727	if (SvOK (arg))
		728	{
		729	sv_to (arg, var);
		730	if (expect_false (!var))
		731	croak ("unable to convert perl object to C++ object");
		732	}
		733	else
		734	var = 0;
		735	}
		736
		737	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		738
467	static SV *	739	static SV *
468	newSVcfapi (int type, ...)
469	{
470	SV *sv;
471
472	va_list ap;
473	va_start (ap, type);
474
475	switch (type)
476	{
477	case CFAPI_INT: sv = newSViv (va_arg (ap, int )); break;
478	case CFAPI_LONG: sv = newSVval64 (va_arg (ap, sint64 )); break;
479	case CFAPI_DOUBLE: sv = newSVnv (va_arg (ap, double )); break;
480	case CFAPI_STRING: sv = newSVdt_va (ap, DT_STRING); break;
481	case CFAPI_POBJECT: sv = newSVdt_va (ap, DT_OBJECT); break;
482	case CFAPI_PMAP: sv = newSVdt_va (ap, DT_MAP ); break;
483	case CFAPI_PPLAYER: sv = newSVdt_va (ap, DT_PLAYER); break;
484	case CFAPI_PARCH: sv = newSVdt_va (ap, DT_ARCH ); break;
485	case CFAPI_PPARTY: sv = newSVdt_va (ap, DT_PARTY ); break;
486	case CFAPI_PREGION: sv = newSVdt_va (ap, DT_REGION); break;
487
488	default:
489	assert (("unhandled type in newSVcfapi", 0));
490	}
491
492	va_end (ap);
493
494	return sv;
495	}
496
497	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
498
499	SV *
500	registry (attachable *ext)	740	registry (attachable *ext)
501	{	741	{
502	if (!ext->cb)	742	if (!ext->cb)
503	ext->cb = newAV ();	743	ext->cb = newAV ();
504		744
505	return newRV_inc ((SV *)ext->cb);	745	return newRV_inc ((SV *)ext->cb);
506	}	746	}
507		747
508	/////////////////////////////////////////////////////////////////////////////	748	/////////////////////////////////////////////////////////////////////////////
509		749
510	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
511	{
512	return 0;
513	}
514
515	static CommArray_s rtn_cmd;
516
517	static int
518	runPluginCommand (object obj, char params)
519	{
520	return -1;
521	}
522
523	extern "C" void cfperl_getPluginProperty (int type, ...)
524	{
525	va_list args;
526	char *propname;
527	int i;
528	va_start (args, type);
529	propname = va_arg (args, char *);
530	//printf ("Property name: %s\n", propname);
531
532	if (!strcmp (propname, "command?"))
533	return NULL;
534	else if (!strcmp (propname, "Identification"))
535	{
536	va_end (args);
537	return (void *)PLUGIN_NAME;
538	}
539	else if (!strcmp (propname, "FullName"))
540	{
541	va_end (args);
542	return (void *)PLUGIN_VERSION;
543	}
544	else
545	va_end (args);
546
547	return NULL;
548	}
549
550	extern "C" int cfperl_postInitPlugin ()
551	{
552	int hooktype = 1;
553	int rtype = 0;
554
555	cf_init_plugin (gethook);
556
557	return 0;
558	}
559
560	extern "C" int cfperl_closePlugin ()
561	{
562	return 0;
563	}
564
565	void	750	void
566	cfperl_init ()	751	cfperl_init ()
567	{	752	{
		753	extern char **environ;
		754
568	PERL_SYS_INIT3 (&settings.argc, &settings.argv, 0);	755	PERL_SYS_INIT3 (&settings.argc, &settings.argv, &environ);
569	perl = perl_alloc ();	756	perl = perl_alloc ();
570	perl_construct (perl);	757	perl_construct (perl);
571		758
572	PL_exit_flags \|= PERL_EXIT_DESTRUCT_END;	759	PL_exit_flags \|= PERL_EXIT_DESTRUCT_END;
573		760
574	char *argv[] = {	761	const char *argv[] = {
575	"",	762	settings.argv [0],
576	"-e"	763	"-e0"
577	"use Event; use Coro;" // required for bootstrap
578	"cf->bootstrap;" // required for datadir :*>
579	"unshift @INC, cf::datadir ();"
580	"require cf;"
581	};	764	};
582		765
583	if (perl_parse (perl, xs_init, 2, argv, (char **)NULL) \|\| perl_run (perl))	766	if (perl_parse (perl, xs_init, 2, (char **)argv, environ)
		767	\|\| perl_run (perl))
584	{	768	{
585	printf ("unable to initialize perl-interpreter, aborting.\n");	769	printf ("unable to initialize perl-interpreter, aborting.\n");
586	exit (EXIT_FAILURE);	770	exit (EXIT_FAILURE);
587	}	771	}
588	}
589		772
		773	eval_pv (
		774	"#line 1 'cfperl init'\n"
		775	"use EV ();\n" // required by bootstrap
		776	"use Coro ();\n" // required by bootstrap
		777	"cf->bootstrap;\n" // required for cf::datadir
		778	"unshift @INC, cf::datadir ();\n" // required for 'require' :)
		779	"require cf;\n",
		780	0
		781	);
		782
		783	if (SvTRUE (ERRSV))
		784	{
		785	printf ("unable to bootstrap perl, aborting:\n%s", SvPV_nolen (ERRSV));
		786	exit (EXIT_FAILURE);
		787	}
		788	}
		789
		790	void
590	void cfperl_main ()	791	cfperl_main ()
591	{	792	{
592	dSP;	793	dSP;
593		794
594	PUSHMARK (SP);	795	PUSHMARK (SP);
595	PUTBACK;	796	PUTBACK;
…		…
599	void	800	void
600	attachable::instantiate ()	801	attachable::instantiate ()
601	{	802	{
602	if (attach)	803	if (attach)
603	{	804	{
604	invoke (EVENT_ATTACHABLE_INSTANTIATE, ARG_STRING (attach), DT_END);	805	INVOKE_ATTACHABLE (INSTANTIATE, this, ARG_STRING (attach));
605	attach = 0;	806	attach = 0;
606	}	807	}
607	}	808	}
608		809
609	void	810	void
610	attachable::reattach ()	811	attachable::reattach ()
611	{	812	{
612	optimise ();	813	optimise ();
613	//TODO: check for _attachment's, very important for restarts	814	//TODO: check for _attachment's, very important for restarts
614	invoke (EVENT_ATTACHABLE_REATTACH, DT_END);	815	INVOKE_ATTACHABLE (REATTACH, this);
615	}	816	}
616		817
617	static event_klass klass_of[NUM_EVENT_TYPES] = {	818	static event_klass klass_of[NUM_EVENT_TYPES] = {
618	# define def(type,name) KLASS_ ## type,	819	# define def(type,name) KLASS_ ## type,
619	# include "eventinc.h"	820	# include "eventinc.h"
620	# undef def	821	# undef def
621	};	822	};
622		823
623	#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)	824	#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)
624		825
625	static void	826	static void noinline
626	gather_callbacks (AV &callbacks, AV registry, event_type event)	827	gather_callbacks (AV &callbacks, AV registry, event_type event)
627	{	828	{
628	// event must be in array	829	// event must be in array
629	if (event >= 0 && event <= AvFILLp (registry))	830	if (event >= 0 && event <= AvFILLp (registry))
630	{	831	{
…		…
662	}	863	}
663		864
664	void	865	void
665	global::gather_callbacks (AV *&callbacks, event_type event) const	866	global::gather_callbacks (AV *&callbacks, event_type event) const
666	{	867	{
667	::gather_callbacks (callbacks, cb_object, event);	868	::gather_callbacks (callbacks, cb_global, event);
668	}	869	}
669		870
670	void	871	void
671	object::gather_callbacks (AV *&callbacks, event_type event) const	872	object::gather_callbacks (AV *&callbacks, event_type event) const
672	{	873	{
673	if (subtype && type + subtype * NUM_SUBTYPES <= AvFILLp (cb_type))	874	if (subtype && type + subtype * NUM_TYPES <= AvFILLp (cb_type))
674	{	875	{
675	SV registry = AvARRAY (cb_type)[type + subtype NUM_SUBTYPES];	876	SV registry = AvARRAY (cb_type)[type + subtype NUM_TYPES];
676		877
677	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)	878	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
678	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);	879	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);
679	}	880	}
680		881
…		…
716	{	917	{
717	attachable::gather_callbacks (callbacks, event);	918	attachable::gather_callbacks (callbacks, event);
718	::gather_callbacks (callbacks, cb_map, event);	919	::gather_callbacks (callbacks, cb_map, event);
719	}	920	}
720		921
		922	static void noinline
		923	_recalc_want (bitset<NUM_EVENT_TYPES> &set, AV *registry)
		924	{
		925	for (int event = 0; event <= AvFILLp (registry); ++event)
		926	{
		927	SV *cbs_ = AvARRAY (registry)[event];
		928
		929	// element must be list of callback entries
		930	if (cbs_ && SvROK (cbs_) && SvTYPE (SvRV (cbs_)) == SVt_PVAV)
		931	{
		932	AV cbs = (AV )SvRV (cbs_);
		933
		934	// no callback entries, no callbacks to call
		935	if (AvFILLp (cbs) >= 0)
		936	set.set (event);
		937	}
		938	}
		939	}
		940
		941	// very slow and inefficient way to recalculate the global want bitsets
		942	static void
		943	_recalc_want ()
		944	{
		945	ev_want_event.reset ();
		946
		947	_recalc_want (ev_want_event, cb_global);
		948	_recalc_want (ev_want_event, cb_attachable);
		949	_recalc_want (ev_want_event, cb_object);
		950	_recalc_want (ev_want_event, cb_client);
		951	_recalc_want (ev_want_event, cb_player);
		952	_recalc_want (ev_want_event, cb_map);
		953
		954	ev_want_type.reset ();
		955
		956	for (int type = 0; type <= AvFILLp (cb_type); ++type)
		957	{
		958	SV *cbs_ = AvARRAY (cb_type)[type];
		959
		960	// element must be list of callback entries
		961	if (cbs_ && SvROK (cbs_) && SvTYPE (SvRV (cbs_)) == SVt_PVAV)
		962	{
		963	AV cbs = (AV )SvRV (cbs_);
		964
		965	// no callback entries, no callbacks to call
		966	if (AvFILLp (cbs) >= 0)
		967	ev_want_type.set (type % NUM_TYPES);
		968	}
		969	}
		970	}
		971
721	bool	972	bool
722	attachable::invoke (event_type event, ...)	973	attachable::invoke (event_type event, ...)
723	{	974	{
724	data_type dt;	975	data_type dt;
725	va_list ap;
726
727	va_start (ap, event);
728		976
729	// callback call ordering should be:	977	// callback call ordering should be:
730	// 1. per-object callback	978	// 1. per-object callback
731	// 2. per-class object	979	// 2. per-class object
732	// 3. per-type callback	980	// 3. per-type callback
…		…
736	gather_callbacks (callbacks, event);	984	gather_callbacks (callbacks, event);
737		985
738	// short-circuit processing if no callbacks found/defined	986	// short-circuit processing if no callbacks found/defined
739	if (!callbacks)	987	if (!callbacks)
740	return 0;	988	return 0;
		989
		990	va_list ap;
		991	va_start (ap, event);
741		992
742	CALL_BEGIN (3);	993	CALL_BEGIN (3);
743	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays	994	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays
744	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));	995	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));
745		996
…		…
769	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));	1020	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
770	}	1021	}
771		1022
772	va_end (ap);	1023	va_end (ap);
773		1024
774	CALL_CALL ("cf::do_invoke", G_SCALAR);	1025	CALL_CALL (cv_cf_do_invoke, G_SCALAR);
775	count = count > 0 ? POPi : 0;	1026	count = count > 0 ? POPi : 0;
776		1027
777	CALL_END;	1028	CALL_END;
778		1029
779	return count;	1030	return count;
780	}	1031	}
781		1032
782	SV *	1033	static SV *
783	cfperl_result (int idx)	1034	cfperl_result (int idx)
784	{	1035	{
785	AV *av = get_av ("cfperl::invoke_results", 0);	1036	AV *av = get_av ("cf::INVOKE_RESULTS", 0);
786	if (!av)	1037	if (!av)
787	return &PL_sv_undef;	1038	return &PL_sv_undef;
788		1039
789	SV **sv = av_fetch (av, idx, 0);	1040	SV **sv = av_fetch (av, idx, 0);
790	if (!sv)	1041	if (!sv)
…		…
804	{	1055	{
805	return SvNV (cfperl_result (idx));	1056	return SvNV (cfperl_result (idx));
806	}	1057	}
807		1058
808	/////////////////////////////////////////////////////////////////////////////	1059	/////////////////////////////////////////////////////////////////////////////
		1060	// various c++ => perl glue functions
		1061
		1062	void
		1063	cfperl_tick ()
		1064	{
		1065	tick_pending = 1;
		1066
		1067	if (tick_inhibit)
		1068	return;
		1069
		1070	tick_pending = 0;
		1071
		1072	dSP;
		1073
		1074	PUSHMARK (SP);
		1075	PUTBACK;
		1076	call_pvsv (cv_cf_tick, G_DISCARD \| G_VOID);
		1077
		1078	SvNV_set (sv_next_tick, get_next_tick ()); SvNOK_only (sv_next_tick);
		1079	}
809		1080
810	void	1081	void
811	cfperl_emergency_save ()	1082	cfperl_emergency_save ()
812	{	1083	{
813	CALL_BEGIN (0);	1084	CALL_BEGIN (0);
814	CALL_CALL ("cf::emergency_save", G_VOID);	1085	CALL_CALL ("cf::emergency_save", G_VOID);
815	CALL_END;	1086	CALL_END;
816	}	1087	}
817		1088
		1089	void
		1090	cfperl_cleanup (int make_core)
		1091	{
		1092	CALL_BEGIN (1);
		1093	CALL_ARG (make_core);
		1094	CALL_CALL ("cf::post_cleanup", G_VOID);
		1095	CALL_END;
		1096	}
		1097
		1098	void
		1099	cfperl_make_book (object *book, int level)
		1100	{
		1101	CALL_BEGIN (2);
		1102	CALL_ARG (book);
		1103	CALL_ARG (level);
		1104	CALL_CALL ("ext::books::make_book", G_VOID);
		1105	CALL_END;
		1106	}
		1107
		1108	void
		1109	cfperl_send_msg (client *ns, int color, const_utf8_string type, const_utf8_string msg)
		1110	{
		1111	CALL_BEGIN (4);
		1112	CALL_ARG (ns);
		1113	CALL_ARG (type);
		1114	CALL_ARG_SV (newSVpv_utf8 (msg));
		1115	CALL_ARG (color);
		1116	CALL_CALL (cv_cf_client_send_msg, G_VOID);
		1117	CALL_END;
		1118	}
		1119
		1120	int
		1121	cfperl_can_merge (object ob1, object ob2)
		1122	{
		1123	int can;
		1124
		1125	CALL_BEGIN (2);
		1126	CALL_ARG (ob1);
		1127	CALL_ARG (ob2);
		1128	CALL_CALL (cv_cf__can_merge, G_SCALAR);
		1129	can = count && SvTRUE (TOPs);
		1130	CALL_END;
		1131
		1132	return can;
		1133	}
		1134
		1135	void
		1136	cfperl_mapscript_activate (object ob, int state, object activator, object *originator)
		1137	{
		1138	CALL_BEGIN (4);
		1139	CALL_ARG (ob);
		1140	CALL_ARG (state);
		1141	CALL_ARG (activator);
		1142	CALL_ARG (originator);
		1143	CALL_CALL ("cf::mapscript::activate", G_VOID);
		1144	CALL_END;
		1145	}
		1146
		1147	player *
		1148	player::find (const_utf8_string name)
		1149	{
		1150	CALL_BEGIN (1);
		1151	CALL_ARG (name);
		1152	CALL_CALL ("cf::player::find", G_SCALAR);
		1153
		1154	player *retval = 0;
		1155	if (count) sv_to (POPs, retval);
		1156
		1157	CALL_END;
		1158
		1159	return retval;
		1160	}
		1161
818	maptile *	1162	maptile *
		1163	find_style (const_utf8_string dirname, const_utf8_string stylename, int difficulty, bool recurse)
		1164	{
		1165	CALL_BEGIN (4);
		1166	CALL_ARG (dirname);
		1167	CALL_ARG (stylename);
		1168	CALL_ARG (difficulty);
		1169	CALL_ARG (recurse);
		1170	CALL_CALL ("ext::map_random::find_style", G_SCALAR);
		1171
		1172	maptile *retval = 0;
		1173	if (count) sv_to (POPs, retval);
		1174
		1175	CALL_END;
		1176
		1177	return retval;
		1178	}
		1179
		1180	maptile *
819	maptile::find_sync (const char path, maptile origin)	1181	maptile::find_sync (const_utf8_string path, maptile *origin)
820	{	1182	{
821	CALL_BEGIN (2);	1183	CALL_BEGIN (2);
822	CALL_ARG (path);	1184	CALL_ARG (path);
823	CALL_ARG (origin);	1185	CALL_ARG (origin);
824	CALL_CALL ("cf::map::find_sync", G_SCALAR);	1186	CALL_CALL ("cf::map::find_sync", G_SCALAR);
825		1187
826	maptile *retval;	1188	maptile *retval = 0;
827
828	if (count)
829	sv_to (POPs, retval);	1189	if (count) sv_to (POPs, retval);
830	else
831	retval = 0;
832		1190
833	CALL_END;	1191	CALL_END;
834		1192
835	return retval;	1193	return retval;
836	}	1194	}
837		1195
838	maptile *	1196	maptile *
839	maptile::find_async (const char path, maptile origin)	1197	maptile::find_async (const_utf8_string path, maptile *origin, bool load)
840	{	1198	{
841	CALL_BEGIN (2);	1199	CALL_BEGIN (3);
842	CALL_ARG (path);	1200	CALL_ARG (path);
843	CALL_ARG (origin);	1201	CALL_ARG (origin);
		1202	CALL_ARG (load);
844	CALL_CALL ("cf::map::find_async", G_SCALAR);	1203	CALL_CALL ("cf::map::find_async", G_SCALAR);
845		1204
846	maptile *retval;	1205	maptile *retval = 0;
847
848	if (count)
849	sv_to (POPs, retval);	1206	if (count) sv_to (POPs, retval);
850	else
851	retval = 0;
852		1207
853	CALL_END;	1208	CALL_END;
854		1209
855	return retval;	1210	return retval;
856	}	1211	}
…		…
859	maptile::do_load_sync ()	1214	maptile::do_load_sync ()
860	{	1215	{
861	CALL_BEGIN (1);	1216	CALL_BEGIN (1);
862	CALL_ARG (this);	1217	CALL_ARG (this);
863	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);	1218	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);
864	CALL_END;
865	}
866
867	void
868	maptile::change_all_map_light (int change)
869	{
870	CALL_BEGIN (1);
871	CALL_ARG (change);
872	CALL_CALL ("cf::map::change_all_map_light", G_VOID);
873	CALL_END;	1219	CALL_END;
874	}	1220	}
875		1221
876	void	1222	void
877	object::enter_exit (object *exit)	1223	object::enter_exit (object *exit)
…		…
884	CALL_ARG (exit);	1230	CALL_ARG (exit);
885	CALL_CALL ("cf::object::player::enter_exit", G_VOID);	1231	CALL_CALL ("cf::object::player::enter_exit", G_VOID);
886	CALL_END;	1232	CALL_END;
887	}	1233	}
888		1234
		1235	void
		1236	object::player_goto (const_utf8_string path, int x, int y)
		1237	{
		1238	if (type != PLAYER)
		1239	return;
		1240
		1241	CALL_BEGIN (4);
		1242	CALL_ARG (this);
		1243	CALL_ARG (path);
		1244	CALL_ARG (x);
		1245	CALL_ARG (y);
		1246	CALL_CALL ("cf::object::player::goto", G_VOID);
		1247	CALL_END;
		1248	}
		1249
		1250	const_utf8_string
		1251	object::ref () const
		1252	{
		1253	if (type == PLAYER)
		1254	return format ("player/<1.%llx>/%s", (unsigned long long)uuid.seq, &name);
		1255	else
		1256	// TODO: should be able to save references within the same map, at least
		1257	return 0;
		1258	}
		1259
		1260	object *
		1261	object::deref (const_utf8_string ref)
		1262	{
		1263	object *retval = 0;
		1264
		1265	if (ref)
		1266	{
		1267	CALL_BEGIN (1);
		1268	CALL_ARG (ref);
		1269	CALL_CALL ("cf::object::deref", G_SCALAR);
		1270
		1271	if (count)
		1272	sv_to (POPs, retval);
		1273
		1274	CALL_END;
		1275	}
		1276
		1277	return retval;
		1278	}
		1279
		1280	void
		1281	log_backtrace (const_utf8_string msg)
		1282	{
		1283	#if HAVE_BACKTRACE
		1284	void *addr [20];
		1285	int size = backtrace (addr, 20);
		1286
		1287	CALL_BEGIN (size);
		1288	CALL_ARG (msg);
		1289	for (int i = 0; i < size; ++i)
		1290	CALL_ARG ((IV)addr [i]);
		1291	CALL_CALL ("cf::_log_backtrace", G_VOID);
		1292	CALL_END;
		1293	#endif
		1294	}
		1295
		1296	bool
		1297	is_match_expr (const_utf8_string expr)
		1298	{
		1299	return !strncmp (expr, "match ", sizeof ("match ") - 1);
		1300	}
		1301
		1302	bool
		1303	match (const_utf8_string expr, object ob, object self, object source, object originator)
		1304	{
		1305	if (!strncmp (expr, "match ", sizeof ("match ") - 1))
		1306	expr += sizeof ("match ") - 1;
		1307
		1308	CALL_BEGIN (5);
		1309	CALL_ARG (expr);
		1310	CALL_ARG (ob);
		1311	CALL_ARG (self);
		1312	CALL_ARG (source);
		1313	CALL_ARG (originator);
		1314	CALL_CALL (cv_cf_match_match, G_SCALAR);
		1315
		1316	bool matched = count && SvTRUE (TOPs);
		1317
		1318	CALL_END;
		1319
		1320	return matched;
		1321	}
		1322
		1323	object *
		1324	match_one (const_utf8_string expr, object ob, object self, object source, object originator)
		1325	{
		1326	if (!strncmp (expr, "match ", sizeof ("match ") - 1))
		1327	expr += sizeof ("match ") - 1;
		1328
		1329	CALL_BEGIN (5);
		1330	CALL_ARG (expr);
		1331	CALL_ARG (ob);
		1332	CALL_ARG (self);
		1333	CALL_ARG (source);
		1334	CALL_ARG (originator);
		1335	CALL_CALL (cv_cf_match_match, G_ARRAY);
		1336
		1337	object *one = 0;
		1338
		1339	if (count)
		1340	sv_to (TOPs, one);
		1341
		1342	CALL_END;
		1343
		1344	return one;
		1345	}
		1346
889	/////////////////////////////////////////////////////////////////////////////	1347	/////////////////////////////////////////////////////////////////////////////
890		1348
891	struct EventAPI *watcher_base::GEventAPI;	1349	struct EVAPI *evapi::GEVAPI;
892	struct CoroAPI *coroapi::GCoroAPI;	1350	struct CoroAPI *coroapi::GCoroAPI;
893		1351
894	int coroapi::cede_counter;
895
896	static void iw_dispatch (pe_event *ev)
897	{
898	iw w = (iw )ev->ext_data;
899	w->call (*w);
900	}
901
902	void	1352	void
903	iw::alloc ()	1353	coroapi::do_cede_to_tick ()
904	{	1354	{
905	pe = GEventAPI->new_idle (0, 0);	1355	cede_pending = 0;
906		1356	cede ();
907	WaREENTRANT_off (pe);
908	pe->base.callback = (void *)iw_dispatch;
909	pe->base.ext_data = (void *)this;
910	}	1357	}
911		1358
912	static void iow_dispatch (pe_event *ev)
913	{
914	iow w = (iow )ev->ext_data;
915	w->call (w, ((pe_ioevent )ev)->got);
916	}
917
918	void	1359	void
919	iow::alloc ()	1360	coroapi::wait_for_tick ()
920	{	1361	{
921	pe = GEventAPI->new_io (0, 0);	1362	CALL_BEGIN (0);
922		1363	CALL_CALL ("cf::wait_for_tick", G_DISCARD);
923	WaREENTRANT_off (pe);	1364	CALL_END;
924	pe->base.callback = (void *)iow_dispatch;
925	pe->base.ext_data = (void *)this;
926
927	pe->fd = -1;
928	pe->poll = 0;
929	}	1365	}
930		1366
931	void	1367	void
932	iow::fd (int fd)	1368	coroapi::wait_for_tick_begin ()
933	{	1369	{
934	pe->fd = fd;	1370	CALL_BEGIN (0);
935	}	1371	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);
936		1372	CALL_END;
937	int
938	iow::poll ()
939	{
940	return pe->poll;
941	}	1373	}
942		1374
943	void	1375	void
944	iow::poll (int events)	1376	iow::poll (int events)
945	{	1377	{
946	if (pe->poll != events)	1378	if (events != this->events)
947	{	1379	{
		1380	int active = ev_is_active ((ev_io *)this);
948	if (pe->poll) stop ();	1381	if (active) stop ();
949	pe->poll = events;	1382	ev_io_set ((ev_io *)this, fd, events);
950	if (pe->poll) start ();	1383	if (active) start ();
951	}	1384	}
952	}	1385	}
953		1386
954	void	1387	static void
955	_connect_to_perl ()	1388	_connect_to_perl_1 ()
956	{	1389	{
957	stash_cf = gv_stashpv ("cf" , 1);	1390	stash_cf = gv_stashpv ("cf", 1);
958		1391
959	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);	1392	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);
960	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);	1393	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);
961	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);	1394	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);
962	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);	1395	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);
		1396	stash_cf_mapspace_wrap = gv_stashpv ("cf::mapspace::wrap" , 1);
963	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);	1397	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);
964	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);	1398	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
965	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);	1399	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
966	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);	1400	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
967	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);	1401	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
		1402	stash_ext_map_world = gv_stashpv ("ext::map_world" , 1);
968		1403
969	sv_runtime = get_sv ("cf::RUNTIME", 1);	1404	sv_now = get_sv ("cf::NOW" , 1); SvUPGRADE (sv_now , SVt_NV);
970	sv_upgrade (sv_runtime, SVt_NV);	1405	sv_runtime = get_sv ("cf::RUNTIME" , 1); SvUPGRADE (sv_runtime , SVt_NV);
		1406	sv_tick_start = get_sv ("cf::TICK_START", 1); SvUPGRADE (sv_tick_start, SVt_NV);
		1407	sv_next_tick = get_sv ("cf::NEXT_TICK" , 1); SvUPGRADE (sv_next_tick , SVt_NV);
971		1408
972	cb_global = get_av ("cf::CB_GLOBAL", 1);	1409	cb_global = get_av ("cf::CB_GLOBAL", 1);
973	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);	1410	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
974	cb_object = get_av ("cf::CB_OBJECT", 1);	1411	cb_object = get_av ("cf::CB_OBJECT", 1);
975	cb_player = get_av ("cf::CB_PLAYER", 1);	1412	cb_player = get_av ("cf::CB_PLAYER", 1);
976	cb_client = get_av ("cf::CB_CLIENT", 1);	1413	cb_client = get_av ("cf::CB_CLIENT", 1);
977	cb_type = get_av ("cf::CB_TYPE" , 1);	1414	cb_type = get_av ("cf::CB_TYPE" , 1);
978	cb_map = get_av ("cf::CB_MAP" , 1);	1415	cb_map = get_av ("cf::CB_MAP" , 1);
979	}	1416	}
980		1417
		1418	static void
		1419	_connect_to_perl_2 ()
		1420	{
		1421	cv_cf_do_invoke = (SV *)get_cv ("cf::do_invoke" , 0); assert (cv_cf_do_invoke);
		1422	cv_cf__can_merge = (SV *)get_cv ("cf::_can_merge" , 0); assert (cv_cf__can_merge);
		1423	cv_cf_client_send_msg = (SV *)get_cv ("cf::client::send_msg", 0); assert (cv_cf_client_send_msg);
		1424	cv_cf_tick = (SV *)get_cv ("cf::tick" , 0); assert (cv_cf_tick);
		1425	cv_cf_match_match = (SV *)get_cv ("cf::match::match" , 0); assert (cv_cf_match_match);
		1426	}
		1427
981	MODULE = cf PACKAGE = cf PREFIX = cf_	1428	MODULE = cf PACKAGE = cf PREFIX = cf_
982		1429
983	BOOT:	1430	BOOT:
984	{	1431	{
		1432	I_EV_API (PACKAGE); evapi::GEVAPI = GEVAPI;
		1433	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
		1434
985	_connect_to_perl ();	1435	_connect_to_perl_1 ();
986
987	I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;
988	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
989		1436
990	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));	1437	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
		1438
		1439	//{
		1440	// require_pv ("Time::HiRes");
		1441	//
		1442	// SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
		1443	// if (!svp) croak ("Time::HiRes is required");
		1444	// if (!SvIOK(*svp)) croak ("Time::NVtime isn’t a function pointer");
		1445	// coroapi::time = INT2PTR (double()(), SvIV(svp));
		1446	//}
991		1447
992	static const struct {	1448	static const struct {
993	const char *name;	1449	const char *name;
994	IV iv;	1450	IV iv;
995	} *civ, const_iv[] = {	1451	} *civ, const_iv[] = {
996	# define const_iv(name) { # name, (IV)name },	1452	# define const_iv(name) { # name, (IV)name },
997	const_iv (llevError)	1453	# include "const_iv.h"
998	const_iv (llevInfo)	1454	# define def(uc, lc, name, plus, change) const_iv (AT_ ## uc) const_iv (ATNR_ ## uc)
999	const_iv (llevDebug)	1455	# include "attackinc.h"
1000	const_iv (llevMonster)	1456	# undef def
		1457	# define def(uc, flags) const_iv (SK_ ## uc)
		1458	# include "skillinc.h"
		1459	# undef def
		1460
		1461	const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)
		1462
		1463	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)
1001		1464
1002	const_iv (MAX_TIME)	1465	const_iv (MAX_TIME)
1003	const_iv (PLAYER)
1004	const_iv (TRANSPORT)
1005	const_iv (ROD)
1006	const_iv (TREASURE)
1007	const_iv (POTION)
1008	const_iv (FOOD)
1009	const_iv (POISON)
1010	const_iv (BOOK)
1011	const_iv (CLOCK)	1466	const_iv (MAXSOCKBUF)
1012	const_iv (ARROW)
1013	const_iv (BOW)
1014	const_iv (WEAPON)
1015	const_iv (ARMOUR)
1016	const_iv (PEDESTAL)
1017	const_iv (ALTAR)
1018	const_iv (LOCKED_DOOR)
1019	const_iv (SPECIAL_KEY)
1020	const_iv (MAP)
1021	const_iv (DOOR)
1022	const_iv (KEY)
1023	const_iv (TIMED_GATE)
1024	const_iv (TRIGGER)
1025	const_iv (GRIMREAPER)
1026	const_iv (MAGIC_EAR)
1027	const_iv (TRIGGER_BUTTON)
1028	const_iv (TRIGGER_ALTAR)
1029	const_iv (TRIGGER_PEDESTAL)
1030	const_iv (SHIELD)
1031	const_iv (HELMET)
1032	const_iv (HORN)
1033	const_iv (MONEY)
1034	const_iv (CLASS)
1035	const_iv (GRAVESTONE)
1036	const_iv (AMULET)
1037	const_iv (PLAYERMOVER)
1038	const_iv (TELEPORTER)
1039	const_iv (CREATOR)
1040	const_iv (SKILL)
1041	const_iv (EARTHWALL)
1042	const_iv (GOLEM)
1043	const_iv (THROWN_OBJ)
1044	const_iv (BLINDNESS)
1045	const_iv (GOD)
1046	const_iv (DETECTOR)
1047	const_iv (TRIGGER_MARKER)
1048	const_iv (DEAD_OBJECT)
1049	const_iv (DRINK)
1050	const_iv (MARKER)
1051	const_iv (HOLY_ALTAR)
1052	const_iv (PLAYER_CHANGER)
1053	const_iv (BATTLEGROUND)
1054	const_iv (PEACEMAKER)
1055	const_iv (GEM)
1056	const_iv (FIREWALL)
1057	const_iv (ANVIL)
1058	const_iv (CHECK_INV)
1059	const_iv (MOOD_FLOOR)
1060	const_iv (EXIT)
1061	const_iv (ENCOUNTER)
1062	const_iv (SHOP_FLOOR)
1063	const_iv (SHOP_MAT)
1064	const_iv (RING)
1065	const_iv (FLOOR)
1066	const_iv (FLESH)
1067	const_iv (INORGANIC)
1068	const_iv (SKILL_TOOL)
1069	const_iv (LIGHTER)
1070	const_iv (BUILDABLE_WALL)
1071	const_iv (MISC_OBJECT)
1072	const_iv (LAMP)
1073	const_iv (DUPLICATOR)
1074	const_iv (SPELLBOOK)
1075	const_iv (CLOAK)
1076	const_iv (SPINNER)
1077	const_iv (GATE)
1078	const_iv (BUTTON)
1079	const_iv (CF_HANDLE)
1080	const_iv (HOLE)
1081	const_iv (TRAPDOOR)
1082	const_iv (SIGN)
1083	const_iv (BOOTS)
1084	const_iv (GLOVES)
1085	const_iv (SPELL)
1086	const_iv (SPELL_EFFECT)
1087	const_iv (CONVERTER)
1088	const_iv (BRACERS)
1089	const_iv (POISONING)
1090	const_iv (SAVEBED)
1091	const_iv (WAND)
1092	const_iv (SCROLL)
1093	const_iv (DIRECTOR)
1094	const_iv (GIRDLE)
1095	const_iv (FORCE)
1096	const_iv (POTION_EFFECT)
1097	const_iv (EVENT_CONNECTOR)
1098	const_iv (CLOSE_CON)
1099	const_iv (CONTAINER)
1100	const_iv (ARMOUR_IMPROVER)
1101	const_iv (WEAPON_IMPROVER)
1102	const_iv (SKILLSCROLL)
1103	const_iv (DEEP_SWAMP)
1104	const_iv (IDENTIFY_ALTAR)
1105	const_iv (MENU)
1106	const_iv (RUNE)
1107	const_iv (TRAP)
1108	const_iv (POWER_CRYSTAL)
1109	const_iv (CORPSE)
1110	const_iv (DISEASE)
1111	const_iv (SYMPTOM)
1112	const_iv (BUILDER)
1113	const_iv (MATERIAL)
1114	const_iv (ITEM_TRANSFORMER)
1115		1467
1116	const_iv (NUM_SUBTYPES)	1468	const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE)
		1469	const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF)
1117		1470
1118	const_iv (ST_BD_BUILD)	1471	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_LEVEL)
1119	const_iv (ST_BD_REMOVE)
1120		1472
1121	const_iv (ST_MAT_FLOOR)	1473	const_iv (F_APPLIED) const_iv (F_LOCATION) const_iv (F_UNPAID) const_iv (F_MAGIC)
1122	const_iv (ST_MAT_WALL)	1474	const_iv (F_CURSED) const_iv (F_DAMNED) const_iv (F_OPEN) const_iv (F_NOPICK)
1123	const_iv (ST_MAT_ITEM)
1124
1125	const_iv (AT_PHYSICAL)
1126	const_iv (AT_MAGIC)
1127	const_iv (AT_FIRE)
1128	const_iv (AT_ELECTRICITY)
1129	const_iv (AT_COLD)
1130	const_iv (AT_CONFUSION)
1131	const_iv (AT_ACID)
1132	const_iv (AT_DRAIN)
1133	const_iv (AT_WEAPONMAGIC)
1134	const_iv (AT_GHOSTHIT)
1135	const_iv (AT_POISON)
1136	const_iv (AT_SLOW)
1137	const_iv (AT_PARALYZE)
1138	const_iv (AT_TURN_UNDEAD)
1139	const_iv (AT_FEAR)
1140	const_iv (AT_CANCELLATION)
1141	const_iv (AT_DEPLETE)
1142	const_iv (AT_DEATH)
1143	const_iv (AT_CHAOS)
1144	const_iv (AT_COUNTERSPELL)
1145	const_iv (AT_GODPOWER)
1146	const_iv (AT_HOLYWORD)
1147	const_iv (AT_BLIND)
1148	const_iv (AT_INTERNAL)
1149	const_iv (AT_LIFE_STEALING)
1150	const_iv (AT_DISEASE)
1151
1152	const_iv (WEAP_HIT)
1153	const_iv (WEAP_SLASH)
1154	const_iv (WEAP_PIERCE)
1155	const_iv (WEAP_CLEAVE)
1156	const_iv (WEAP_SLICE)
1157	const_iv (WEAP_STAB)
1158	const_iv (WEAP_WHIP)
1159	const_iv (WEAP_CRUSH)
1160	const_iv (WEAP_BLUD)
1161
1162	const_iv (FLAG_ALIVE)
1163	const_iv (FLAG_WIZ)
1164	const_iv (FLAG_REMOVED)
1165	const_iv (FLAG_FREED)
1166	const_iv (FLAG_WAS_WIZ)
1167	const_iv (FLAG_APPLIED)
1168	const_iv (FLAG_UNPAID)
1169	const_iv (FLAG_USE_SHIELD)
1170	const_iv (FLAG_NO_PICK)
1171	const_iv (FLAG_ANIMATE)
1172	const_iv (FLAG_MONSTER)
1173	const_iv (FLAG_FRIENDLY)
1174	const_iv (FLAG_GENERATOR)
1175	const_iv (FLAG_IS_THROWN)
1176	const_iv (FLAG_AUTO_APPLY)
1177	const_iv (FLAG_PLAYER_SOLD)
1178	const_iv (FLAG_SEE_INVISIBLE)
1179	const_iv (FLAG_CAN_ROLL)
1180	const_iv (FLAG_OVERLAY_FLOOR)
1181	const_iv (FLAG_IS_TURNABLE)
1182	const_iv (FLAG_IS_USED_UP)
1183	const_iv (FLAG_IDENTIFIED)
1184	const_iv (FLAG_REFLECTING)
1185	const_iv (FLAG_CHANGING)
1186	const_iv (FLAG_SPLITTING)
1187	const_iv (FLAG_HITBACK)
1188	const_iv (FLAG_STARTEQUIP)
1189	const_iv (FLAG_BLOCKSVIEW)
1190	const_iv (FLAG_UNDEAD)
1191	const_iv (FLAG_SCARED)
1192	const_iv (FLAG_UNAGGRESSIVE)
1193	const_iv (FLAG_REFL_MISSILE)
1194	const_iv (FLAG_REFL_SPELL)
1195	const_iv (FLAG_NO_MAGIC)
1196	const_iv (FLAG_NO_FIX_PLAYER)
1197	const_iv (FLAG_IS_LIGHTABLE)
1198	const_iv (FLAG_TEAR_DOWN)
1199	const_iv (FLAG_RUN_AWAY)
1200	const_iv (FLAG_PICK_UP)
1201	const_iv (FLAG_UNIQUE)
1202	const_iv (FLAG_NO_DROP)
1203	const_iv (FLAG_WIZCAST)
1204	const_iv (FLAG_CAST_SPELL)
1205	const_iv (FLAG_USE_SCROLL)
1206	const_iv (FLAG_USE_RANGE)
1207	const_iv (FLAG_USE_BOW)
1208	const_iv (FLAG_USE_ARMOUR)
1209	const_iv (FLAG_USE_WEAPON)
1210	const_iv (FLAG_USE_RING)
1211	const_iv (FLAG_READY_RANGE)
1212	const_iv (FLAG_READY_BOW)
1213	const_iv (FLAG_XRAYS)
1214	const_iv (FLAG_NO_APPLY)
1215	const_iv (FLAG_IS_FLOOR)
1216	const_iv (FLAG_LIFESAVE)
1217	const_iv (FLAG_NO_STRENGTH)
1218	const_iv (FLAG_SLEEP)
1219	const_iv (FLAG_STAND_STILL)
1220	const_iv (FLAG_RANDOM_MOVE)
1221	const_iv (FLAG_ONLY_ATTACK)
1222	const_iv (FLAG_CONFUSED)
1223	const_iv (FLAG_STEALTH)
1224	const_iv (FLAG_WIZPASS)
1225	const_iv (FLAG_IS_LINKED)
1226	const_iv (FLAG_CURSED)
1227	const_iv (FLAG_DAMNED)
1228	const_iv (FLAG_SEE_ANYWHERE)
1229	const_iv (FLAG_KNOWN_MAGICAL)
1230	const_iv (FLAG_KNOWN_CURSED)
1231	const_iv (FLAG_CAN_USE_SKILL)
1232	const_iv (FLAG_BEEN_APPLIED)
1233	const_iv (FLAG_READY_SCROLL)
1234	const_iv (FLAG_USE_ROD)
1235	const_iv (FLAG_USE_HORN)
1236	const_iv (FLAG_MAKE_INVIS)
1237	const_iv (FLAG_INV_LOCKED)
1238	const_iv (FLAG_IS_WOODED)
1239	const_iv (FLAG_IS_HILLY)
1240	const_iv (FLAG_READY_SKILL)
1241	const_iv (FLAG_READY_WEAPON)
1242	const_iv (FLAG_NO_SKILL_IDENT)
1243	const_iv (FLAG_BLIND)
1244	const_iv (FLAG_SEE_IN_DARK)
1245	const_iv (FLAG_IS_CAULDRON)
1246	const_iv (FLAG_NO_STEAL)
1247	const_iv (FLAG_ONE_HIT)
1248	const_iv (FLAG_CLIENT_SENT)
1249	const_iv (FLAG_BERSERK)
1250	const_iv (FLAG_NEUTRAL)
1251	const_iv (FLAG_NO_ATTACK)
1252	const_iv (FLAG_NO_DAMAGE)
1253	const_iv (FLAG_OBJ_ORIGINAL)
1254	const_iv (FLAG_OBJ_SAVE_ON_OVL)
1255	const_iv (FLAG_ACTIVATE_ON_PUSH)
1256	const_iv (FLAG_ACTIVATE_ON_RELEASE)
1257	const_iv (FLAG_IS_WATER)
1258	const_iv (FLAG_CONTENT_ON_GEN)
1259	const_iv (FLAG_IS_A_TEMPLATE)
1260	const_iv (FLAG_IS_BUILDABLE)
1261	const_iv (FLAG_DESTROY_ON_DEATH)
1262	const_iv (FLAG_NO_MAP_SAVE)
1263
1264	const_iv (NDI_BLACK)
1265	const_iv (NDI_WHITE)
1266	const_iv (NDI_NAVY)
1267	const_iv (NDI_RED)
1268	const_iv (NDI_ORANGE)
1269	const_iv (NDI_BLUE)
1270	const_iv (NDI_DK_ORANGE)
1271	const_iv (NDI_GREEN)
1272	const_iv (NDI_LT_GREEN)
1273	const_iv (NDI_GREY)
1274	const_iv (NDI_BROWN)
1275	const_iv (NDI_GOLD)
1276	const_iv (NDI_TAN)
1277	const_iv (NDI_MAX_COLOR)
1278	const_iv (NDI_COLOR_MASK)
1279	const_iv (NDI_UNIQUE)
1280	const_iv (NDI_ALL)
1281
1282	const_iv (UPD_LOCATION)
1283	const_iv (UPD_FLAGS)
1284	const_iv (UPD_WEIGHT)
1285	const_iv (UPD_FACE)
1286	const_iv (UPD_NAME)
1287	const_iv (UPD_ANIM)
1288	const_iv (UPD_ANIMSPEED)
1289	const_iv (UPD_NROF)
1290
1291	const_iv (UPD_SP_MANA)
1292	const_iv (UPD_SP_GRACE)
1293	const_iv (UPD_SP_DAMAGE)
1294
1295	const_iv (F_APPLIED)
1296	const_iv (F_LOCATION)
1297	const_iv (F_UNPAID)
1298	const_iv (F_MAGIC)
1299	const_iv (F_CURSED)
1300	const_iv (F_DAMNED)
1301	const_iv (F_OPEN)
1302	const_iv (F_NOPICK)
1303	const_iv (F_LOCKED)	1475	const_iv (F_LOCKED)
1304		1476
1305	const_iv (F_BUY)	1477	const_iv (P_BLOCKSVIEW) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE)
1306	const_iv (F_SHOP)	1478	const_iv (P_NO_CLERIC) const_iv (P_OUT_OF_MAP) const_iv (P_NEW_MAP) const_iv (P_UPTODATE)
1307	const_iv (F_SELL)
1308		1479
1309	const_iv (P_BLOCKSVIEW)	1480	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)
1310	const_iv (P_PLAYER)
1311	const_iv (P_NO_MAGIC)
1312	const_iv (P_IS_ALIVE)
1313	const_iv (P_NO_CLERIC)
1314	const_iv (P_OUT_OF_MAP)
1315	const_iv (P_NEW_MAP)
1316	const_iv (P_UPTODATE)
1317		1481
1318	const_iv (UP_OBJ_INSERT)	1482	const_iv (SK_EXP_ADD_SKILL) const_iv (SK_EXP_TOTAL) const_iv (SK_EXP_NONE)
1319	const_iv (UP_OBJ_REMOVE)	1483	const_iv (SK_SUBTRACT_SKILL_EXP) const_iv (SK_EXP_SKILL_ONLY)
1320	const_iv (UP_OBJ_CHANGE)
1321	const_iv (UP_OBJ_FACE)
1322		1484
1323	const_iv (INS_NO_MERGE)	1485	const_iv (MAP_ACTIVE) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)
1324	const_iv (INS_ABOVE_FLOOR_ONLY)
1325	const_iv (INS_NO_WALK_ON)
1326	const_iv (INS_ON_TOP)
1327	const_iv (INS_BELOW_ORIGINATOR)
1328	const_iv (INS_MAP_LOAD)
1329
1330	const_iv (WILL_APPLY_HANDLE)
1331	const_iv (WILL_APPLY_TREASURE)
1332	const_iv (WILL_APPLY_EARTHWALL)
1333	const_iv (WILL_APPLY_DOOR)
1334	const_iv (WILL_APPLY_FOOD)
1335
1336	const_iv (SAVE_MODE)
1337	const_iv (SAVE_DIR_MODE)
1338
1339	const_iv (M_PAPER)
1340	const_iv (M_IRON)
1341	const_iv (M_GLASS)
1342	const_iv (M_LEATHER)
1343	const_iv (M_WOOD)
1344	const_iv (M_ORGANIC)
1345	const_iv (M_STONE)
1346	const_iv (M_CLOTH)
1347	const_iv (M_ADAMANT)
1348	const_iv (M_LIQUID)
1349	const_iv (M_SOFT_METAL)
1350	const_iv (M_BONE)
1351	const_iv (M_ICE)	1486	const_iv (MAP_INACTIVE)
1352	const_iv (M_SPECIAL)
1353		1487
1354	const_iv (SK_EXP_ADD_SKILL)	1488	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)
1355	const_iv (SK_EXP_TOTAL)	1489	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)
1356	const_iv (SK_EXP_NONE)
1357	const_iv (SK_SUBTRACT_SKILL_EXP)
1358	const_iv (SK_EXP_SKILL_ONLY)
1359		1490
1360	const_iv (SK_LOCKPICKING)	1491	const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)
1361	const_iv (SK_HIDING)
1362	const_iv (SK_SMITHERY)
1363	const_iv (SK_BOWYER)
1364	const_iv (SK_JEWELER)
1365	const_iv (SK_ALCHEMY)
1366	const_iv (SK_STEALING)
1367	const_iv (SK_LITERACY)
1368	const_iv (SK_BARGAINING)
1369	const_iv (SK_JUMPING)
1370	const_iv (SK_DET_MAGIC)
1371	const_iv (SK_ORATORY)
1372	const_iv (SK_SINGING)
1373	const_iv (SK_DET_CURSE)
1374	const_iv (SK_FIND_TRAPS)
1375	const_iv (SK_MEDITATION)
1376	const_iv (SK_PUNCHING)
1377	const_iv (SK_FLAME_TOUCH)
1378	const_iv (SK_KARATE)
1379	const_iv (SK_CLIMBING)
1380	const_iv (SK_WOODSMAN)
1381	const_iv (SK_INSCRIPTION)
1382	const_iv (SK_ONE_HANDED_WEAPON)
1383	const_iv (SK_MISSILE_WEAPON)
1384	const_iv (SK_THROWING)
1385	const_iv (SK_USE_MAGIC_ITEM)
1386	const_iv (SK_DISARM_TRAPS)
1387	const_iv (SK_SET_TRAP)
1388	const_iv (SK_THAUMATURGY)
1389	const_iv (SK_PRAYING)
1390	const_iv (SK_CLAWING)
1391	const_iv (SK_LEVITATION)
1392	const_iv (SK_SUMMONING)
1393	const_iv (SK_PYROMANCY)
1394	const_iv (SK_EVOCATION)
1395	const_iv (SK_SORCERY)
1396	const_iv (SK_TWO_HANDED_WEAPON)
1397	const_iv (SK_SPARK_TOUCH)
1398	const_iv (SK_SHIVER)
1399	const_iv (SK_ACID_SPLASH)
1400	const_iv (SK_POISON_NAIL)
1401		1492
1402	const_iv (SOUND_NEW_PLAYER)	1493	const_iv (IO_HEADER) const_iv (IO_OBJECTS) const_iv (IO_UNIQUES)
1403	const_iv (SOUND_FIRE_ARROW)
1404	const_iv (SOUND_LEARN_SPELL)
1405	const_iv (SOUND_FUMBLE_SPELL)
1406	const_iv (SOUND_WAND_POOF)
1407	const_iv (SOUND_OPEN_DOOR)
1408	const_iv (SOUND_PUSH_PLAYER)
1409	const_iv (SOUND_PLAYER_HITS1)
1410	const_iv (SOUND_PLAYER_HITS2)
1411	const_iv (SOUND_PLAYER_HITS3)
1412	const_iv (SOUND_PLAYER_HITS4)
1413	const_iv (SOUND_PLAYER_IS_HIT1)
1414	const_iv (SOUND_PLAYER_IS_HIT2)
1415	const_iv (SOUND_PLAYER_IS_HIT3)
1416	const_iv (SOUND_PLAYER_KILLS)
1417	const_iv (SOUND_PET_IS_KILLED)
1418	const_iv (SOUND_PLAYER_DIES)
1419	const_iv (SOUND_OB_EVAPORATE)
1420	const_iv (SOUND_OB_EXPLODE)
1421	const_iv (SOUND_CLOCK)
1422	const_iv (SOUND_TURN_HANDLE)
1423	const_iv (SOUND_FALL_HOLE)
1424	const_iv (SOUND_DRINK_POISON)
1425	const_iv (SOUND_CAST_SPELL_0)
1426
1427	const_iv (PREFER_LOW)
1428	const_iv (PREFER_HIGH)
1429
1430	const_iv (ATNR_PHYSICAL)
1431	const_iv (ATNR_MAGIC)
1432	const_iv (ATNR_FIRE)
1433	const_iv (ATNR_ELECTRICITY)
1434	const_iv (ATNR_COLD)
1435	const_iv (ATNR_CONFUSION)
1436	const_iv (ATNR_ACID)
1437	const_iv (ATNR_DRAIN)
1438	const_iv (ATNR_WEAPONMAGIC)
1439	const_iv (ATNR_GHOSTHIT)
1440	const_iv (ATNR_POISON)
1441	const_iv (ATNR_SLOW)
1442	const_iv (ATNR_PARALYZE)
1443	const_iv (ATNR_TURN_UNDEAD)
1444	const_iv (ATNR_FEAR)
1445	const_iv (ATNR_CANCELLATION)
1446	const_iv (ATNR_DEPLETE)
1447	const_iv (ATNR_DEATH)
1448	const_iv (ATNR_CHAOS)
1449	const_iv (ATNR_COUNTERSPELL)
1450	const_iv (ATNR_GODPOWER)
1451	const_iv (ATNR_HOLYWORD)
1452	const_iv (ATNR_BLIND)
1453	const_iv (ATNR_INTERNAL)
1454	const_iv (ATNR_LIFE_STEALING)
1455	const_iv (ATNR_DISEASE)
1456
1457	const_iv (MAP_IN_MEMORY)
1458	const_iv (MAP_SWAPPED)
1459	const_iv (MAP_LOADING)
1460	const_iv (MAP_SAVING)
1461
1462	const_iv (KLASS_ATTACHABLE)
1463	const_iv (KLASS_GLOBAL)
1464	const_iv (KLASS_OBJECT)
1465	const_iv (KLASS_CLIENT)
1466	const_iv (KLASS_PLAYER)
1467	const_iv (KLASS_MAP)
1468
1469	const_iv (CS_QUERY_YESNO)
1470	const_iv (CS_QUERY_SINGLECHAR)
1471	const_iv (CS_QUERY_HIDEINPUT)
1472
1473	const_iv (ST_DEAD)
1474	const_iv (ST_SETUP)
1475	const_iv (ST_PLAYING)
1476	const_iv (ST_CUSTOM)
1477
1478	const_iv (ST_CHANGE_CLASS)
1479
1480	const_iv (IO_HEADER)
1481	const_iv (IO_OBJECTS)
1482	const_iv (IO_UNIQUES)
1483
1484	// random map generator
1485	const_iv (LAYOUT_NONE)
1486	const_iv (LAYOUT_ONION)
1487	const_iv (LAYOUT_MAZE)
1488	const_iv (LAYOUT_SPIRAL)
1489	const_iv (LAYOUT_ROGUELIKE)
1490	const_iv (LAYOUT_SNAKE)
1491	const_iv (LAYOUT_SQUARE_SPIRAL)
1492
1493	const_iv (RMOPT_RANDOM)
1494	const_iv (RMOPT_CENTERED)
1495	const_iv (RMOPT_LINEAR)
1496	const_iv (RMOPT_BOTTOM_C)
1497	const_iv (RMOPT_BOTTOM_R)
1498	const_iv (RMOPT_IRR_SPACE)
1499	const_iv (RMOPT_WALL_OFF)
1500	const_iv (RMOPT_WALLS_ONLY)
1501	const_iv (RMOPT_NO_DOORS)
1502
1503	const_iv (SYMMETRY_RANDOM)
1504	const_iv (SYMMETRY_NONE)
1505	const_iv (SYMMETRY_X)
1506	const_iv (SYMMETRY_Y)
1507	const_iv (SYMMETRY_XY)
1508	};	1494	};
1509		1495
1510	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	1496	for (civ = const_iv + array_length (const_iv); civ-- > const_iv; )
1511	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));	1497	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1512		1498
1513	static const struct {	1499	static const struct {
1514	const char *name;	1500	const char *name;
1515	int skip;	1501	int skip;
…		…
1521	# undef def	1507	# undef def
1522	};	1508	};
1523		1509
1524	AV *av = get_av ("cf::EVENT", 1);	1510	AV *av = get_av ("cf::EVENT", 1);
1525		1511
1526	for (eiv = event_iv + sizeof (event_iv) / sizeof (event_iv [0]); eiv-- > event_iv; )	1512	for (eiv = event_iv + array_length (event_iv); eiv-- > event_iv; )
1527	{	1513	{
1528	AV *event = newAV ();	1514	AV *event = newAV ();
1529	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));	1515	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));
1530	av_push (event, newSViv (eiv->klass));	1516	av_push (event, newSViv (eiv->klass));
1531	av_store (av, eiv->iv, newRV_noinc ((SV *)event));	1517	av_store (av, eiv->iv, newRV_noinc ((SV *)event));
1532	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));	1518	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));
1533	}	1519	}
1534	}
1535		1520
		1521	// used by autogenerated BOOT sections from genacc
		1522	av_reflect = get_av ("cf::REFLECT", 1);
		1523	}
		1524
		1525	void _gv_clear (SV *gv)
		1526	CODE:
		1527	assert (SvTYPE (gv) == SVt_PVGV);
		1528	# define f(sv) { SV sv_ = (SV )(sv); sv = 0; SvREFCNT_dec (sv_); }
		1529	f (GvGP (gv)->gp_form);
		1530	f (GvGP (gv)->gp_io);
		1531	f (GvGP (gv)->gp_sv);
		1532	f (GvGP (gv)->gp_av);
		1533	f (GvGP (gv)->gp_hv);
		1534	f (GvGP (gv)->gp_cv);
		1535	GvCVGEN (gv) = 0;
		1536	GvMULTI_off (gv);
		1537	# undef f
		1538
1536	void _connect_to_perl ()	1539	void _connect_to_perl_1 ()
1537		1540
		1541	void _connect_to_perl_2 ()
		1542
		1543	void _recalc_want ()
		1544
		1545	# not used by default anymore
1538	void _global_reattach ()	1546	void _global_reattach ()
1539	CODE:	1547	CODE:
1540	{	1548	{
1541	// reattach to all attachable objects in the game.	1549	// reattach to all attachable objects in the game.
1542	for_all_clients (ns)	1550	for_all_clients (ns)
1543	ns->reattach ();	1551	ns->reattach ();
1544		1552
1545	for_all_players (pl)
1546	pl->reattach ();
1547
1548	//TODO
1549	//for (map_container::iterator i = maps.begin (); i != maps.end (); ++i)
1550	// i->second->reattach ();
1551
1552	for_all_objects (op)	1553	for_all_objects (op)
1553	op->reattach ();	1554	op->reattach ();
1554	}	1555	}
1555		1556
		1557	# support function for map-world.ext
		1558	void _quantise (SV data_sv, SV plt_sv)
		1559	CODE:
		1560	{
		1561	if (!SvROK (plt_sv) \|\| SvTYPE (SvRV (plt_sv)) != SVt_PVAV)
		1562	croak ("_quantise called with invalid agruments");
		1563
		1564	plt_sv = SvRV (plt_sv);
		1565	SV **plt = AvARRAY (plt_sv);
		1566	int plt_count = AvFILL (plt_sv) + 1;
		1567
		1568	STRLEN len;
		1569	char *data = SvPVbyte (data_sv, len);
		1570	char *dst = data;
		1571
		1572	while (len >= 3)
		1573	{
		1574	for (SV **val_sv = plt + plt_count; val_sv-- > plt; )
		1575	{
		1576	char val = SvPVX (val_sv);
		1577
		1578	if (val [0] == data [0]
		1579	&& val [1] == data [1]
		1580	&& val [2] == data [2])
		1581	{
		1582	*dst++ = val [3];
		1583	goto next;
		1584	}
		1585	}
		1586
		1587	croak ("_quantise: color not found in palette: #%02x%02x%02x, at offset %d %d",
		1588	(uint8_t)data [0], (uint8_t)data [1], (uint8_t)data [2],
		1589	dst - SvPVX (data_sv), len);
		1590
		1591	next:
		1592	data += 3;
		1593	len -= 3;
		1594	}
		1595
		1596	SvCUR_set (data_sv, dst - SvPVX (data_sv));
		1597	}
		1598
		1599	void init_anim ()
		1600
		1601	void init_globals ()
		1602
		1603	void init_attackmess ()
		1604
		1605	void init_dynamic ()
		1606
		1607	void load_settings ()
		1608
		1609	void reload_exp_table ()
		1610
		1611	void reload_materials ()
		1612
		1613	void init_uuid ()
		1614	CODE:
		1615	UUID::init ();
		1616
		1617	void init_signals ()
		1618
		1619	void init_skills ()
		1620
		1621	void init_beforeplay ()
		1622
		1623	void evthread_start (int aiofd)
		1624
		1625	void cede_to_tick ()
		1626	CODE:
		1627	coroapi::cede_to_tick ();
		1628
		1629	NV till_tick ()
		1630	CODE:
		1631	RETVAL = SvNVX (sv_next_tick) - now ();
		1632	OUTPUT:
		1633	RETVAL
		1634
		1635	int tick_inhibit ()
		1636	CODE:
		1637	RETVAL = tick_inhibit;
		1638	OUTPUT:
		1639	RETVAL
		1640
		1641	void tick_inhibit_inc ()
		1642	CODE:
		1643	++tick_inhibit;
		1644
		1645	void tick_inhibit_dec ()
		1646	CODE:
		1647	if (!--tick_inhibit)
		1648	if (tick_pending)
		1649	{
		1650	ev_async_send (EV_DEFAULT, &tick_watcher);
		1651	coroapi::cede ();
		1652	}
		1653
		1654	void server_tick ()
		1655	CODE:
		1656	{
		1657	ev_now_update (EV_DEFAULT);
		1658	NOW = ev_now (EV_DEFAULT);
		1659	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1660	SvNV_set (sv_tick_start, NOW); SvNOK_only (sv_tick_start);
		1661	runtime = SvNVX (sv_runtime);
		1662
		1663	server_tick ();
		1664
		1665	ev_now_update (EV_DEFAULT);
		1666	NOW = ev_now (EV_DEFAULT);
		1667	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1668	runtime += TICK;
		1669	SvNV_set (sv_runtime, runtime); SvNOK_only (sv_runtime);
		1670	}
		1671
1556	NV floor (NV x)	1672	NV floor (NV x)
1557		1673
1558	NV ceil (NV x)	1674	NV ceil (NV x)
1559		1675
1560	NV rndm (...)	1676	NV rndm (...)
		1677	ALIAS:
		1678	rmg_rndm = 1
1561	CODE:	1679	CODE:
		1680	{
		1681	rand_gen &gen = ix ? rmg_rndm : rndm;
1562	switch (items)	1682	switch (items)
1563	{	1683	{
1564	case 0: RETVAL = rndm (); break;	1684	case 0: RETVAL = gen (); break;
1565	case 1: RETVAL = rndm (SvUV (ST (0))); break;	1685	case 1: RETVAL = gen (SvUV (ST (0))); break;
1566	case 2: RETVAL = rndm (SvIV (ST (0)), SvIV (ST (1))); break;	1686	case 2: RETVAL = gen (SvIV (ST (0)), SvIV (ST (1))); break;
1567	default: croak ("cf::rndm requires none, one or two parameters."); break;	1687	default: croak ("cf::rndm requires zero, one or two parameters."); break;
1568	}	1688	}
		1689	}
1569	OUTPUT:	1690	OUTPUT:
1570	RETVAL	1691	RETVAL
1571		1692
1572	void server_tick ()	1693	NV clamp (NV value, NV min_value, NV max_value)
1573	CODE:	1694	CODE:
1574	runtime = SvNVx (sv_runtime);	1695	RETVAL = clamp (value, min_value, max_value);
1575	server_tick ();	1696	OUTPUT:
		1697	RETVAL
1576		1698
1577	void	1699	NV lerp (NV value, NV min_in, NV max_in, NV min_out, NV max_out)
1578	LOG (int level, char *msg)	1700	CODE:
		1701	RETVAL = lerp (value, min_in, max_in, min_out, max_out);
		1702	OUTPUT:
		1703	RETVAL
		1704
		1705	const char *ordinal (int i)
		1706
		1707	void weaken (...)
		1708	PROTOTYPE: @
		1709	CODE:
		1710	while (items > 0)
		1711	sv_rvweaken (ST (--items));
		1712
		1713	void log_suspend ()
		1714
		1715	void log_resume ()
		1716
		1717	void log_backtrace (utf8_string msg)
		1718
		1719	void LOG (int flags, utf8_string msg)
1579	PROTOTYPE: $$	1720	PROTOTYPE: $$
1580	C_ARGS: (LogLevel)level, "%s", msg	1721	C_ARGS: flags, "%s", msg
1581		1722
1582	char path_combine (char base, char *path)	1723	octet_string path_combine (octet_string base, octet_string path)
1583	PROTOTYPE: $$	1724	PROTOTYPE: $$
1584		1725
1585	char path_combine_and_normalize (char base, char *path)	1726	octet_string path_combine_and_normalize (octet_string base, octet_string path)
1586	PROTOTYPE: $$	1727	PROTOTYPE: $$
1587		1728
1588	const char *
1589	get_maps_directory (char *path)
1590	PROTOTYPE: $
1591	ALIAS: maps_directory = 0
1592	CODE:
1593	RETVAL = create_pathname (path);
1594	OUTPUT: RETVAL
1595
1596	void	1729	void
1597	sub_generation_inc ()	1730	sub_generation_inc ()
1598	CODE:	1731	CODE:
1599	PL_sub_generation++;	1732	PL_sub_generation++;
1600		1733
1601	char *	1734	const_octet_string
1602	mapdir ()	1735	mapdir ()
1603	PROTOTYPE:	1736	PROTOTYPE:
1604	ALIAS:	1737	ALIAS:
1605	mapdir = 0	1738	mapdir = 0
1606	uniquedir = 1	1739	uniquedir = 1
…		…
1622	}	1755	}
1623	OUTPUT: RETVAL	1756	OUTPUT: RETVAL
1624		1757
1625	void abort ()	1758	void abort ()
1626		1759
		1760	void reset_signals ()
		1761
1627	void fork_abort (char *cause = "cf::fork_abort")	1762	void fork_abort (const_octet_string cause = "cf::fork_abort")
1628		1763
1629	void cleanup (const char *cause, bool make_core = false)	1764	void cleanup (const_octet_string cause, bool make_core = false)
1630		1765
1631	void emergency_save ()	1766	void emergency_save ()
1632		1767
1633	UV sv_2watcher (SV *w)
1634	CODE:
1635	RETVAL = (UV)GEventAPI->sv_2watcher (w);
1636	OUTPUT:
1637	RETVAL
1638
1639	void _exit (int status = 0)	1768	void _exit (int status = EXIT_SUCCESS)
1640		1769
1641	#if _POSIX_MEMLOCK	1770	#if _POSIX_MEMLOCK
1642		1771
1643	int mlockall (int flags = MCL_CURRENT \| MCL_FUTURE)	1772	int mlockall (int flags = MCL_CURRENT \| MCL_FUTURE)
		1773	INIT:
		1774	#if __GLIBC__
		1775	mallopt (M_TOP_PAD, 1024 * 1024);
		1776	mallopt (M_MMAP_THRESHOLD, 1024 * 1024 * 128);
		1777	mallopt (M_MMAP_MAX, 0); // likely bug-workaround, also frees memory
		1778	mallopt (M_PERTURB, 0xee); // bug-workaround for linux glibc+mlockall+calloc
		1779	#endif
1644		1780
1645	int munlockall ()	1781	int munlockall ()
1646		1782
1647	#endif	1783	#endif
1648		1784
		1785	int
		1786	malloc_trim (IV pad = 0)
		1787
		1788	void
		1789	mallinfo ()
		1790	PPCODE:
		1791	{
		1792	#if __GLIBC__
		1793	struct mallinfo mai = mallinfo ();
		1794	EXTEND (SP, 10*2);
		1795	PUSHs (sv_2mortal (newSVpv ("arena" , 0))); PUSHs (sv_2mortal (newSViv (mai.arena)));
		1796	PUSHs (sv_2mortal (newSVpv ("ordblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.ordblks)));
		1797	PUSHs (sv_2mortal (newSVpv ("smblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.smblks)));
		1798	PUSHs (sv_2mortal (newSVpv ("hblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblks)));
		1799	PUSHs (sv_2mortal (newSVpv ("hblkhd" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblkhd)));
		1800	PUSHs (sv_2mortal (newSVpv ("usmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.usmblks)));
		1801	PUSHs (sv_2mortal (newSVpv ("fsmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.fsmblks)));
		1802	PUSHs (sv_2mortal (newSVpv ("uordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.uordblks)));
		1803	PUSHs (sv_2mortal (newSVpv ("fordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.fordblks)));
		1804	PUSHs (sv_2mortal (newSVpv ("keepcost", 0))); PUSHs (sv_2mortal (newSViv (mai.keepcost)));
		1805	#endif
		1806	EXTEND (SP, 5*2);
		1807	PUSHs (sv_2mortal (newSVpv ("slice_alloc", 0))); PUSHs (sv_2mortal (newSVuv (slice_alloc)));
		1808	PUSHs (sv_2mortal (newSVpv ("shstr_alloc", 0))); PUSHs (sv_2mortal (newSVuv (shstr_alloc)));
		1809	PUSHs (sv_2mortal (newSVpv ("objects" , 0))); PUSHs (sv_2mortal (newSVuv (objects.size () * sizeof (object))));
		1810	PUSHs (sv_2mortal (newSVpv ("sv_count" , 0))); PUSHs (sv_2mortal (newSVuv (PL_sv_count)));
		1811	PUSHs (sv_2mortal (newSVpv ("sv_objcount", 0))); PUSHs (sv_2mortal (newSVuv (PL_sv_objcount)));
		1812	}
		1813
1649	int find_animation (char *text)	1814	int find_animation (utf8_string text)
1650	PROTOTYPE: $	1815	PROTOTYPE: $
1651		1816
1652	int random_roll (int min, int max, object *op, int goodbad);	1817	int random_roll (int min, int max, object *op, int goodbad);
1653		1818
1654	const char *cost_string_from_value(uint64 cost, int approx = 0)	1819	const_utf8_string cost_string_from_value(uint64 cost, int approx = 0)
1655		1820
1656	int
1657	exp_to_level (val64 exp)	1821	int exp_to_level (val64 exp)
1658	CODE:
1659	{
1660	int i = 0;
1661		1822
1662	RETVAL = settings.max_level;
1663
1664	for (i = 1; i <= settings.max_level; i++)
1665	{
1666	if (levels[i] > exp)
1667	{
1668	RETVAL = i - 1;
1669	break;
1670	}
1671	}
1672	}
1673	OUTPUT: RETVAL
1674
1675	val64
1676	level_to_min_exp (int level)	1823	val64 level_to_min_exp (int level)
1677	CODE:
1678	if (level > settings.max_level)
1679	RETVAL = levels[settings.max_level];
1680	else if (level < 1)
1681	RETVAL = 0;
1682	else
1683	RETVAL = levels[level];
1684	OUTPUT: RETVAL
1685		1824
1686	SV *	1825	SV *
1687	resistance_to_string (int atnr)	1826	resistance_to_string (int atnr)
1688	CODE:	1827	CODE:
1689	if (atnr >= 0 && atnr < NROFATTACKS)	1828	if (atnr >= 0 && atnr < NROFATTACKS)
1690	RETVAL = newSVpv (resist_plus[atnr], 0);	1829	RETVAL = newSVpv (resist_plus[atnr], 0);
1691	else	1830	else
1692	XSRETURN_UNDEF;	1831	XSRETURN_UNDEF;
1693	OUTPUT: RETVAL	1832	OUTPUT: RETVAL
1694		1833
		1834	UUID
		1835	uuid_cur ()
		1836	CODE:
		1837	RETVAL = UUID::cur;
		1838	OUTPUT:
		1839	RETVAL
		1840
		1841	UUID
		1842	uuid_gen ()
		1843	CODE:
		1844	RETVAL = UUID::gen ();
		1845	OUTPUT:
		1846	RETVAL
		1847
		1848	val64
		1849	uuid_seq (UUID uuid)
		1850	CODE:
		1851	RETVAL = uuid.seq;
		1852	OUTPUT:
		1853	RETVAL
		1854
		1855	UUID
		1856	uuid_str (val64 seq)
		1857	CODE:
		1858	RETVAL.seq = seq;
		1859	OUTPUT:
		1860	RETVAL
		1861
		1862	void
		1863	coin_names ()
		1864	PPCODE:
		1865	EXTEND (SP, NUM_COINS);
		1866	for (int i = 0; i < NUM_COINS; ++i)
		1867	PUSHs (sv_2mortal (newSVpv (coins [i], 0)));
		1868
		1869	void
		1870	coin_archetypes ()
		1871	PPCODE:
		1872	EXTEND (SP, NUM_COINS);
		1873	for (int i = 0; i < NUM_COINS; ++i)
		1874	PUSHs (sv_2mortal (to_sv (archetype::find (coins [i]))));
		1875
		1876	bool
		1877	load_resource_file_ (octet_string filename)
		1878
		1879	void
		1880	fix_weight ()
		1881
1695	MODULE = cf PACKAGE = cf::attachable	1882	MODULE = cf PACKAGE = cf::attachable
1696		1883
1697	int	1884	int
1698	valid (SV *obj)	1885	valid (SV *obj)
1699	CODE:	1886	CODE:
1700	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);	1887	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
1701	OUTPUT:	1888	OUTPUT:
1702	RETVAL	1889	RETVAL
1703		1890
1704	INCLUDE: $PERL genacc attachable ../include/cfperl.h \|	1891	bool should_invoke (attachable *obj, int event)
		1892	CODE:
		1893	RETVAL = obj->should_invoke ((event_type)event);
		1894	OUTPUT: RETVAL
		1895
		1896	void
		1897	debug_trace (attachable *obj, bool on = true)
		1898	CODE:
		1899	obj->attachable_flags &= ~attachable::F_DEBUG_TRACE;
		1900	if (on)
		1901	obj->attachable_flags \|= attachable::F_DEBUG_TRACE;
		1902
		1903	int mortals_size ()
		1904	CODE:
		1905	RETVAL = attachable::mortals.size ();
		1906	OUTPUT: RETVAL
		1907
		1908	#object *mortals (U32 index)
		1909	# CODE:
		1910	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;
		1911	# OUTPUT: RETVAL
		1912
		1913	INCLUDE: $PERL $srcdir/genacc attachable $srcdir/../include/util.h $srcdir/../include/cfperl.h \|
1705		1914
1706	MODULE = cf PACKAGE = cf::global	1915	MODULE = cf PACKAGE = cf::global
1707		1916
1708	int invoke (SV *klass, int event, ...)	1917	int invoke (SV *klass, int event, ...)
1709	CODE:	1918	CODE:
…		…
1713	RETVAL = gbl_ev.invoke ((event_type)event, ARG_AV (av), DT_END);	1922	RETVAL = gbl_ev.invoke ((event_type)event, ARG_AV (av), DT_END);
1714	OUTPUT: RETVAL	1923	OUTPUT: RETVAL
1715		1924
1716	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_	1925	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
1717		1926
1718	INCLUDE: $PERL genacc object ../include/object.h \|	1927	INCLUDE: $PERL $srcdir/genacc object $srcdir/../include/object.h \|
1719		1928
1720	int invoke (object *op, int event, ...)	1929	int invoke (object *op, int event, ...)
1721	CODE:	1930	CODE:
1722	if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");	1931	if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");
1723	AV av = (AV )sv_2mortal ((SV *)newAV ());	1932	AV av = (AV )sv_2mortal ((SV *)newAV ());
…		…
1725	RETVAL = op->invoke ((event_type)event, ARG_AV (av), DT_END);	1934	RETVAL = op->invoke ((event_type)event, ARG_AV (av), DT_END);
1726	OUTPUT: RETVAL	1935	OUTPUT: RETVAL
1727		1936
1728	SV registry (object op)	1937	SV registry (object op)
1729		1938
1730	void mortals ()
1731	PPCODE:
1732	EXTEND (SP, object::mortals.size ());
1733	for (AUTODECL (i, object::mortals.begin ()); i != object::mortals.end (); ++i)
1734	PUSHs (to_sv (*i));
1735
1736	int objects_size ()	1939	int objects_size ()
1737	CODE:	1940	CODE:
1738	RETVAL = objects.size ();	1941	RETVAL = objects.size ();
1739	OUTPUT: RETVAL	1942	OUTPUT: RETVAL
1740		1943
…		…
1751	object *actives (U32 index)	1954	object *actives (U32 index)
1752	CODE:	1955	CODE:
1753	RETVAL = index < actives.size () ? actives [index] : 0;	1956	RETVAL = index < actives.size () ? actives [index] : 0;
1754	OUTPUT: RETVAL	1957	OUTPUT: RETVAL
1755		1958
		1959	int mortals_size ()
		1960	CODE:
		1961	RETVAL = attachable::mortals.size ();
		1962	OUTPUT: RETVAL
		1963
		1964	const_utf8_string slot_use_name (U32 slot)
		1965	ALIAS:
		1966	slot_nonuse_name = 1
		1967	CODE:
		1968	{
		1969	if (slot >= NUM_BODY_LOCATIONS)
		1970	croak ("body slot index out of range");
		1971
		1972	switch (ix)
		1973	{
		1974	case 0: RETVAL = body_locations[slot].use_name; break;
		1975	case 1: RETVAL = body_locations[slot].nonuse_name; break;
		1976	}
		1977	}
		1978	OUTPUT:
		1979	RETVAL
		1980
1756	# missing properties	1981	# missing properties
1757		1982
1758	object head (object op)	1983	object head (object op)
1759	PROTOTYPE: $	1984	PROTOTYPE: $
1760	CODE:	1985	CODE:
1761	RETVAL = op->head_ ();	1986	RETVAL = op->head_ ();
1762	OUTPUT: RETVAL
1763
1764	int is_head (object *op)
1765	PROTOTYPE: $
1766	CODE:
1767	RETVAL = op->head_ () == op;
1768	OUTPUT: RETVAL	1987	OUTPUT: RETVAL
1769		1988
1770	void	1989	void
1771	inv (object *obj)	1990	inv (object *obj)
1772	PROTOTYPE: $	1991	PROTOTYPE: $
1773	PPCODE:	1992	PPCODE:
1774	{	1993	{
1775	object *o;
1776	for (o = obj->inv; o; o = o->below)	1994	for (object *o = obj->inv; o; o = o->below)
1777	XPUSHs (sv_2mortal (to_sv (o)));	1995	XPUSHs (sv_2mortal (to_sv (o)));
1778	}	1996	}
1779		1997
1780	void	1998	void
1781	set_animation (object *op, int idx)	1999	set_animation (object *op, int idx)
1782	CODE:	2000	CODE:
1783	SET_ANIMATION (op, idx);	2001	SET_ANIMATION (op, idx);
1784		2002
		2003	int
		2004	num_animations (object *op)
		2005	CODE:
		2006	RETVAL = NUM_ANIMATIONS (op);
		2007	OUTPUT: RETVAL
		2008
		2009	int slot_info (object *op, UV slot, int value = 0)
		2010	ALIAS:
		2011	slot_used = 1
		2012	CODE:
		2013	{
		2014	if (slot >= NUM_BODY_LOCATIONS)
		2015	croak ("body slot index out of range");
		2016
		2017	RETVAL = ix ? op->slot[slot].used : op->slot[slot].info;
		2018
		2019	if (items > 2)
		2020	if (ix)
		2021	op->slot[slot].used = value;
		2022	else
		2023	op->slot[slot].info = value;
		2024	}
		2025	OUTPUT:
		2026	RETVAL
		2027
1785	object find_best_object_match (object op, const char *match)	2028	object find_best_object_match (object op, utf8_string match)
1786
1787	object find_marked_object (object op)
1788
1789	int need_identify (object *obj);
1790		2029
1791	int apply_shop_mat (object shop_mat, object op);	2030	int apply_shop_mat (object shop_mat, object op);
1792		2031
1793	int move (object op, int dir, object originator = op)	2032	int move (object op, int dir, object originator = op)
1794	CODE:	2033	CODE:
1795	RETVAL = move_ob (op, dir, originator);	2034	RETVAL = op->move (dir, originator);
1796	OUTPUT:	2035	OUTPUT:
1797	RETVAL	2036	RETVAL
1798		2037
1799	void apply (object applier, object applied, int flags = 0)
1800	CODE:
1801	manual_apply (applied, applier, flags);
1802
1803	void apply_below (object *op)	2038	void apply_below (object *op)
1804	CODE:	2039	CODE:
1805	player_apply_below (op);	2040	player_apply_below (op);
1806		2041
1807	object cf_object_present_archname_inside (object op, char *whatstr)	2042	int cast_heal (object op, object caster, object *spell, int dir = 0)
1808		2043
1809	int cf_object_transfer (object op, int x, int y, int r = 0, object_ornull orig = 0)	2044	int casting_level (object caster, object spell)
1810
1811	int cf_object_change_map (object op, int x, int y, maptile map)
1812
1813	#//TODO
1814	object clone_ (object op, int recursive = 0)
1815	CODE:
1816	if (recursive)
1817	RETVAL = object_create_clone (op);
1818	else
1819	{
1820	RETVAL = object::create ();
1821	op->copy_to (RETVAL);
1822	}
1823	OUTPUT: RETVAL
1824		2045
1825	int pay_item (object op, object buyer)	2046	int pay_item (object op, object buyer)
1826	CODE:	2047	CODE:
1827	RETVAL = pay_for_item (op, buyer);	2048	RETVAL = pay_for_item (op, buyer);
1828	OUTPUT: RETVAL	2049	OUTPUT: RETVAL
…		…
1832	RETVAL = pay_for_amount (amount, op);	2053	RETVAL = pay_for_amount (amount, op);
1833	OUTPUT: RETVAL	2054	OUTPUT: RETVAL
1834		2055
1835	void pay_player (object *op, uint64 amount)	2056	void pay_player (object *op, uint64 amount)
1836		2057
1837	val64 pay_player_arch (object op, const char arch, uint64 amount)	2058	val64 pay_player_arch (object *op, utf8_string arch, uint64 amount)
1838		2059
1839	int cast_spell (object op, object caster, int dir, object spell_ob, char stringarg = 0)	2060	int cast_spell (object op, object caster, int dir, object *spell_ob, utf8_string stringarg = 0)
1840		2061
1841	void learn_spell (object op, object sp, int special_prayer = 0)	2062	void learn_spell (object op, object sp, int special_prayer = 0)
1842	CODE:	2063	CODE:
1843	do_learn_spell (op, sp, special_prayer);	2064	do_learn_spell (op, sp, special_prayer);
1844		2065
1845	void forget_spell (object op, object sp)	2066	void forget_spell (object op, object sp)
1846	CODE:	2067	CODE:
1847	do_forget_spell (op, query_name (sp));	2068	do_forget_spell (op, query_name (sp));
1848		2069
1849	object check_for_spell (object op, char *spellname)	2070	object check_for_spell (object op, utf8_string spellname)
1850	CODE:	2071	CODE:
1851	RETVAL = check_spell_known (op, spellname);	2072	RETVAL = check_spell_known (op, spellname);
1852	OUTPUT: RETVAL	2073	OUTPUT: RETVAL
1853		2074
1854	int query_money (object *op)	2075	int query_money (object *op)
…		…
1863		2084
1864	void drop (object who, object op)	2085	void drop (object who, object op)
1865		2086
1866	void pick_up (object who, object op)	2087	void pick_up (object who, object op)
1867		2088
1868	int cf_object_teleport (object op, maptile map, int x, int y)
1869
1870	void update_object (object *op, int action)	2089	void update_object (object *op, int action)
1871		2090
1872	object cf_create_object_by_name (const char name)
1873
1874	void change_exp (object op, uint64 exp, const char skill_name = 0, int flag = 0)	2091	void change_exp (object *op, uint64 exp, shstr_tmp skill_name = shstr_tmp (), int flag = 0)
1875		2092
1876	void player_lvl_adj (object who, object skill = 0)	2093	void player_lvl_adj (object who, object skill = 0)
1877		2094
1878	int kill_object (object op, int dam = 0, object hitter = 0, int type = AT_PHYSICAL)	2095	int kill_object (object op, int dam = 0, object hitter = 0, int type = AT_PHYSICAL)
1879		2096
1880	int calc_skill_exp (object who, object op, object *skill);	2097	int calc_skill_exp (object who, object op, object *skill)
1881		2098
1882	void push_button (object *op);	2099	void push_button (object op, object originator)
1883		2100
1884	void use_trigger (object *op);	2101	void use_trigger (object op, object originator)
1885		2102
1886	void add_button_link (object button, maptile map, int connected);	2103	void handle_apply_yield (object *op)
1887		2104
1888	void remove_button_link (object *op);	2105	int convert_item (object item, object converter)
1889		2106
		2107	void fix_generated_item (object op, object creator, int difficulty, int max_magic, int flags);
1890		2108
1891	MODULE = cf PACKAGE = cf::object PREFIX = cf_	2109	MODULE = cf PACKAGE = cf::object PREFIX = cf_
1892
1893	object cf_insert_ob_in_ob (object ob, object *where)
1894		2110
1895	# no clean way to get an object from an archetype - stupid idiotic	2111	# no clean way to get an object from an archetype - stupid idiotic
1896	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.	2112	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.
1897		2113
1898	object new (const char archetype = 0)	2114	object *new (utf8_string archetype = 0)
1899	PROTOTYPE: ;$	2115	PROTOTYPE: ;$
1900	CODE:	2116	CODE:
1901	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();	2117	RETVAL = archetype ? get_archetype (archetype) : object::create ();
1902	OUTPUT:	2118	OUTPUT:
1903	RETVAL	2119	RETVAL
1904		2120
		2121	object generate (utf8_string arch, object creator)
		2122	CODE:
		2123	object *obj = get_archetype (arch);
		2124	fix_generated_item (obj, creator, 0, 0, GT_MINIMAL);
		2125	RETVAL = obj;
		2126	OUTPUT:
		2127	RETVAL
		2128
		2129	object *find_object (U32 tag)
		2130
		2131	object *find_object_uuid (UUID i)
		2132
		2133	# TODO: nuke
1905	object insert_ob_in_map_at (object ob, maptile where, object_ornull orig, int flag, int x, int y)	2134	object insert_ob_in_map_at (object ob, maptile where, object_ornull orig, int flag, int x, int y)
1906	PROTOTYPE: $$$$$$	2135	PROTOTYPE: $$$$$$
1907	CODE:	2136	CODE:
1908	{	2137	{
1909	int unused_type;	2138	RETVAL = insert_ob_in_map_at (ob, where, orig, flag, x, y);
1910	RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);
1911	}
1912		2139
1913	# syntatic sugar for easier use in event callbacks.	2140	if (RETVAL->destroyed ())
1914	const char options (object op)
1915	CODE:
1916	RETVAL = op->name;
1917	OUTPUT:
1918	RETVAL	2141	RETVAL = 0;
		2142	}
1919		2143
1920	player contr (object op)	2144	shstr
1921	CODE:	2145	object::kv_get (shstr key)
1922	RETVAL = op->contr;
1923	OUTPUT: RETVAL
1924		2146
1925	const char get_ob_key_value (object op, const char *key)	2147	void
		2148	object::kv_del (shstr key)
1926		2149
1927	bool set_ob_key_value (object op, const char key, const char *value = 0, int add_key = 1)	2150	void
		2151	object::kv_set (shstr key, shstr value)
1928		2152
1929	object get_nearest_player (object ob)	2153	object get_nearest_player (object ob)
1930	ALIAS: nearest_player = 0	2154	ALIAS: nearest_player = 0
1931	PREINIT:	2155	PREINIT:
1932	extern object get_nearest_player (object );	2156	extern object get_nearest_player (object );
…		…
1934	void rangevector (object ob, object other, int flags = 0)	2158	void rangevector (object ob, object other, int flags = 0)
1935	PROTOTYPE: $$;$	2159	PROTOTYPE: $$;$
1936	PPCODE:	2160	PPCODE:
1937	{	2161	{
1938	rv_vector rv;	2162	rv_vector rv;
		2163
1939	get_rangevector (ob, other, &rv, flags);	2164	get_rangevector (ob, other, &rv, flags);
		2165
1940	EXTEND (SP, 5);	2166	EXTEND (SP, 5);
1941	PUSHs (newSVuv (rv.distance));	2167	PUSHs (sv_2mortal (newSVuv (rv.distance)));
1942	PUSHs (newSViv (rv.distance_x));	2168	PUSHs (sv_2mortal (newSViv (rv.distance_x)));
1943	PUSHs (newSViv (rv.distance_y));	2169	PUSHs (sv_2mortal (newSViv (rv.distance_y)));
1944	PUSHs (newSViv (rv.direction));	2170	PUSHs (sv_2mortal (newSViv (rv.direction)));
1945	PUSHs (newSVcfapi (CFAPI_POBJECT, rv.part));	2171	PUSHs (sv_2mortal (to_sv (rv.part)));
1946	}	2172	}
1947		2173
1948	bool on_same_map_as (object ob, object other)	2174	bool on_same_map_as (object ob, object other)
1949	CODE:	2175	CODE:
1950	RETVAL = on_same_map (ob, other);	2176	RETVAL = on_same_map (ob, other);
1951	OUTPUT: RETVAL	2177	OUTPUT: RETVAL
1952		2178
1953	const char *	2179	const_utf8_string
1954	base_name (object *op, int plural = op->nrof > 1)	2180	base_name (object *op, int plural = op->nrof > 1)
1955	CODE:	2181	CODE:
1956	RETVAL = query_base_name (op, plural);	2182	RETVAL = query_base_name (op, plural);
1957	OUTPUT: RETVAL	2183	OUTPUT: RETVAL
1958		2184
1959	object decrease_ob_nr (object op, unsigned long i)	2185	# return the tail of an object, excluding itself
		2186	void
		2187	tail (object *op)
		2188	PPCODE:
		2189	while ((op = op->more))
		2190	XPUSHs (sv_2mortal (to_sv (op)));
1960		2191
1961	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_	2192	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_
1962		2193
1963	player player (object op)	2194	player player (object op)
1964	CODE:	2195	CODE:
1965	RETVAL = op->contr;	2196	RETVAL = op->contr;
1966	OUTPUT: RETVAL	2197	OUTPUT: RETVAL
1967		2198
1968	void check_score (object *op)	2199	bool move_player (object *op, int dir)
1969		2200
1970	void message (object op, char txt, int flags = NDI_ORANGE \| NDI_UNIQUE)	2201	void message (object *op, utf8_string txt, int flags = NDI_ORANGE \| NDI_UNIQUE)
1971	CODE:	2202	CODE:
1972	new_draw_info (flags, 0, op, txt);	2203	new_draw_info (flags, 0, op, txt);
1973		2204
1974	object cf_player_send_inventory (object op)
1975
1976	char cf_player_get_ip (object op)
1977	ALIAS: ip = 0
1978
1979	object cf_player_get_marked_item (object op)
1980	ALIAS: marked_item = 0
1981
1982	void cf_player_set_marked_item (object op, object ob)
1983
1984	partylist cf_player_get_party (object op)
1985	ALIAS: party = 0
1986
1987	void cf_player_set_party (object op, partylist party)
1988
1989	void kill_player (object *op)	2205	void kill_player (object *op)
1990		2206
		2207	void esrv_send_item (object pl, object item)
		2208
1991	void esrv_update_item (object op, int what, object item)	2209	void esrv_update_item (object pl, int what, object item)
1992	C_ARGS: what, op, item	2210	C_ARGS: what, pl, item
1993		2211
1994	void clear_los (object *op)	2212	void esrv_del_item (object *pl, int tag)
		2213	C_ARGS: pl->contr, tag
1995		2214
1996	int command_summon (object op, char params)	2215	int command_summon (object *op, utf8_string params)
1997		2216
1998	int command_arrest (object op, char params)	2217	int command_arrest (object *op, utf8_string params)
1999
2000	int command_kick (object op, char params)
2001
2002	int command_banish (object op, char params)
2003		2218
2004		2219
2005	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_	2220	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
2006		2221
2007	INCLUDE: $PERL genacc player ../include/player.h \|	2222	INCLUDE: $PERL $srcdir/genacc player $srcdir/../include/player.h \|
2008		2223
2009	int invoke (player *pl, int event, ...)	2224	int invoke (player *pl, int event, ...)
2010	CODE:	2225	CODE:
2011	if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");	2226	if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");
2012	AV av = (AV )sv_2mortal ((SV *)newAV ());	2227	AV av = (AV )sv_2mortal ((SV *)newAV ());
…		…
2022	pl->ob->stats.hp = pl->ob->stats.maxhp;	2237	pl->ob->stats.hp = pl->ob->stats.maxhp;
2023	pl->ob->stats.sp = pl->ob->stats.maxsp;	2238	pl->ob->stats.sp = pl->ob->stats.maxsp;
2024	pl->ob->stats.grace = pl->ob->stats.maxgrace;	2239	pl->ob->stats.grace = pl->ob->stats.maxgrace;
2025	pl->orig_stats = pl->ob->stats;	2240	pl->orig_stats = pl->ob->stats;
2026		2241
2027	void cf_player_move (player *pl, int dir)	2242	# should only be temporary
		2243	void esrv_new_player (player *pl)
2028		2244
2029	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);	2245	#d# TODO: replace by blocked_los accessor, fix code using this
2030
2031	player *first ()
2032	CODE:
2033	RETVAL = first_player;
2034	OUTPUT: RETVAL
2035
2036	bool	2246	bool
2037	cell_visible (player *pl, int dx, int dy)	2247	cell_visible (player *pl, int dx, int dy)
2038	CODE:	2248	CODE:
2039	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2	2249	RETVAL = pl->blocked_los (dx, dy) != LOS_BLOCKED;
2040	&& !pl->blocked_los [dx + pl->ns->mapx / 2][dy + pl->ns->mapy / 2];
2041	OUTPUT:	2250	OUTPUT:
2042	RETVAL	2251	RETVAL
2043		2252
2044	void	2253	void
2045	send (player pl, SV packet)	2254	send (player pl, SV packet)
2046	CODE:	2255	CODE:
2047	{	2256	{
2048	STRLEN len;	2257	STRLEN len;
2049	char *buf = SvPVbyte (packet, len);	2258	char *buf = SvPVbyte (packet, len);
2050		2259
		2260	if (len > MAXSOCKBUF)
		2261	pl->failmsg ("[packet too long for client]");
2051	if (pl->ns)	2262	else if (pl->ns)
2052	pl->ns->send_packet (buf, len);	2263	pl->ns->send_packet (buf, len);
2053	}	2264	}
2054
2055	int
2056	listening (player *pl, int new_value = -1)
2057	CODE:
2058	RETVAL = pl->listening;
2059	if (new_value >= 0)
2060	pl->listening = new_value;
2061	OUTPUT:
2062	RETVAL
2063		2265
2064	void savebed (player pl, SV map_path = 0, SV x = 0, SV y = 0)	2266	void savebed (player pl, SV map_path = 0, SV x = 0, SV y = 0)
2065	PROTOTYPE: $;$$$	2267	PROTOTYPE: $;$$$
2066	PPCODE:	2268	PPCODE:
2067	if (GIMME_V != G_VOID)	2269	if (GIMME_V != G_VOID)
…		…
2092	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);	2294	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);
2093	OUTPUT: RETVAL	2295	OUTPUT: RETVAL
2094		2296
2095	SV registry (maptile map)	2297	SV registry (maptile map)
2096		2298
		2299	void
		2300	find_tagged_objects (maptile *map, utf8_string tag = 0)
		2301	PPCODE:
		2302	{
		2303	if (!map->spaces)
		2304	XSRETURN_EMPTY;
		2305
		2306	if (tag)
		2307	{
		2308	shstr_cmp tag_ (tag);
		2309
		2310	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2311	for (object *op = ms->bot; op; op = op->above)
		2312	if (op->tag == tag_)
		2313	XPUSHs (sv_2mortal (to_sv (op)));
		2314	}
		2315	else
		2316	{
		2317	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2318	for (object *op = ms->bot; op; op = op->above)
		2319	if (op->tag)
		2320	XPUSHs (sv_2mortal (to_sv (op)));
		2321	}
		2322	}
		2323
2097	INCLUDE: $PERL genacc maptile ../include/map.h \|	2324	INCLUDE: $PERL $srcdir/genacc maptile $srcdir/../include/map.h \|
		2325
		2326	void
		2327	adjust_daylight ()
		2328	CODE:
		2329	maptile::adjust_daylight ();
		2330
		2331	int
		2332	outdoor_darkness (int darkness = 0)
		2333	CODE:
		2334	RETVAL = maptile::outdoor_darkness;
		2335	if (items)
		2336	maptile::outdoor_darkness = darkness;
		2337	OUTPUT:
		2338	RETVAL
2098		2339
2099	void	2340	void
2100	maptile::instantiate ()	2341	maptile::instantiate ()
2101		2342
2102	maptile *new ()	2343	maptile *new ()
…		…
2117	for_all_players (pl)	2358	for_all_players (pl)
2118	if (pl->ob && pl->ob->map == THIS)	2359	if (pl->ob && pl->ob->map == THIS)
2119	PUSHs (sv_2mortal (to_sv (pl->ob)));	2360	PUSHs (sv_2mortal (to_sv (pl->ob)));
2120	}	2361	}
2121		2362
2122	void play_sound_map (maptile *map, int x, int y, int sound_num)	2363	void
		2364	maptile::add_underlay (SV data, int offset, int stride, SV palette)
		2365	CODE:
		2366	{
		2367	if (!SvROK (palette) \|\| SvTYPE (SvRV (palette)) != SVt_PVAV)
		2368	croak ("maptile::add_underlay: palette must be arrayref");
		2369
		2370	palette = SvRV (palette);
		2371
		2372	STRLEN idxlen;
		2373	const uint8_t idx = (const uint8_t )SvPVbyte (data, idxlen);
		2374
		2375	for (int x = 0; x < THIS->width; ++x)
		2376	for (int y = 0; y < THIS->height; ++y)
		2377	{
		2378	for (object *op = THIS->at (x, y).bot; op; op = op->above)
		2379	if (op->flag [FLAG_IS_FLOOR])
		2380	goto skip;
		2381
		2382	{
		2383	int offs = offset + y * stride + x;
		2384
		2385	if (IN_RANGE_EXC (offs, 0, idxlen))
		2386	{
		2387	if (SV *elem = av_fetch ((AV )palette, idx [offs], 0))
		2388	{
		2389	object ob = get_archetype (cfSvPVutf8_nolen (elem));
		2390	ob->flag [FLAG_NO_MAP_SAVE] = true;
		2391	THIS->insert (ob, x, y, 0, INS_ABOVE_FLOOR_ONLY);
		2392
		2393	if (ob->randomitems && !ob->above)
		2394	{
		2395	ob->create_treasure (ob->randomitems);
		2396
		2397	for (object *op = ob->above; op; op = op->above)
		2398	op->flag [FLAG_NO_MAP_SAVE] = true;
		2399	// TODO: if this is a pickable object, then the item
		2400	// will at a bit weird - saving inside the player
		2401	// will clear the flag, but when the player drops
		2402	// it without logging out, it keeps the flag.
		2403	// nobody ahs reported this, but this can be rather
		2404	// annoying on persistent maps.
		2405	}
		2406	}
		2407	}
		2408	}
		2409
		2410	skip: ;
		2411	}
		2412	}
		2413
		2414	void
		2415	maptile::set_regiondata (SV data, int offset, int stride, SV palette)
		2416	CODE:
		2417	{
		2418	if (!SvROK (palette) \|\| SvTYPE (SvRV (palette)) != SVt_PVAV)
		2419	croak ("maptile::set_regiondata: palette must be arrayref");
		2420
		2421	palette = SvRV (palette);
		2422
		2423	STRLEN idxlen;
		2424	const uint8_t idx = (const uint8_t )SvPVbyte (data, idxlen);
		2425
		2426	region_ptr regionmap = new region_ptr [av_len ((AV )palette) + 1];
		2427	uint8_t *regions = salloc<uint8_t> (THIS->size ());
		2428
		2429	for (int i = av_len ((AV *)palette) + 1; i--; )
		2430	regionmap [i] = region::find (cfSvPVutf8_nolen (av_fetch ((AV )palette, i, 1)));
		2431
		2432	for (int y = 0; y < THIS->height; ++y)
		2433	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);
		2434
		2435	sfree (THIS->regions, THIS->size ());
		2436	delete [] THIS->regionmap;
		2437
		2438	THIS->regions = regions;
		2439	THIS->regionmap = regionmap;
		2440	}
		2441
		2442	void
		2443	maptile::create_region_treasure ()
		2444	CODE:
		2445	for (int x = 0; x < THIS->width; ++x)
		2446	for (int y = 0; y < THIS->height; ++y)
		2447	{
		2448	region *rgn = THIS->region (x, y);
		2449
		2450	//fprintf (stderr, "%d,%d %f %p\n", x, y, rgn->treasure_density,rgn->treasure);//D
		2451	if (object *op = THIS->at (x, y).top)
		2452	if (rgn->treasure && rndm () < rgn->treasure_density)
		2453	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);
		2454	}
2123		2455
2124	int out_of_map (maptile *map, int x, int y)	2456	int out_of_map (maptile *map, int x, int y)
2125		2457
2126	void	2458	void
2127	trigger (maptile *map, long connection, bool state = true)	2459	find_link (maptile *map, shstr_tmp connection)
		2460	PPCODE:
		2461	if (oblinkpt *obp = map->find_link (connection))
		2462	for (objectlink *ol = obp->link; ol; ol = ol->next)
		2463	XPUSHs (sv_2mortal (to_sv ((object *)ol->ob)));
		2464
		2465	void
		2466	xy_normalise (maptile *map, int x, int y, int dir = 0)
		2467	PPCODE:
		2468	{
		2469	mapxy pos (map, x, y);
		2470	if (!pos.move (dir).normalise ())
		2471	XSRETURN_EMPTY;
		2472
		2473	EXTEND (SP, 3);
		2474	PUSHs (sv_2mortal (to_sv (pos.m)));
		2475	PUSHs (sv_2mortal (to_sv (pos.x)));
		2476	PUSHs (sv_2mortal (to_sv (pos.y)));
		2477	}
		2478
		2479	mapspace *
		2480	ms (maptile *map, unsigned int x, unsigned int y, int dir = 0)
		2481	PROTOTYPE: $$$;$
2128	CODE:	2482	CODE:
2129	activate_connection (map, connection, state);
2130
2131	void
2132	get_connection (maptile *map, long connection)
2133	PPCODE:
2134	oblinkpt *obp = get_connection_links (map, connection);
2135	if (obp)
2136	for (objectlink *ol = obp->link; ol; ol = ol->next)
2137	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, (object *)ol->ob)));
2138
2139	object cf_map_insert_object_there (maptile where, object op, object originator, int flags)
2140
2141	object cf_map_insert_object (maptile where, object* op, int x, int y)
2142
2143	object* cf_map_present_arch_by_name (maptile map, const char str, int nx, int ny)
2144	C_ARGS: str, map, nx, ny
2145
2146	void
2147	get_map_flags (maptile *map, int x, int y)
2148	PPCODE:
2149	{	2483	{
2150	maptile *nmap = 0;	2484	mapxy pos (map, x, y);
2151	I16 nx = 0, ny = 0;	2485	if (!pos.move (dir).normalise ())
2152	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);	2486	XSRETURN_UNDEF;
2153		2487
2154	EXTEND (SP, 4);	2488	RETVAL = &*pos;
2155	PUSHs (sv_2mortal (newSViv (flags)));
2156
2157	if (GIMME_V == G_ARRAY)
2158	{
2159	PUSHs (sv_2mortal (newSVcfapi (CFAPI_PMAP, nmap)));
2160	PUSHs (sv_2mortal (newSViv (nx)));
2161	PUSHs (sv_2mortal (newSViv (ny)));
2162	}
2163	}	2489	}
		2490	OUTPUT:
		2491	RETVAL
2164		2492
2165	void	2493	void
2166	at (maptile *map, unsigned int x, unsigned int y)	2494	at (maptile *map, unsigned int x, unsigned int y, int dir = 0)
2167	PROTOTYPE: $$$	2495	PROTOTYPE: $$$;$
2168	PPCODE:	2496	PPCODE:
2169	{	2497	mapxy pos (map, x, y);
2170	object *o;	2498	if (pos.move (dir).normalise ())
2171	maptile *nmap = 0;	2499	for (object *o = pos->bot; o; o = o->above)
2172	I16 nx, ny;	2500	XPUSHs (sv_2mortal (to_sv (o)));
2173
2174	get_map_flags (map, &nmap, x, y, &nx, &ny);
2175
2176	if (nmap)
2177	for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)
2178	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));
2179	}
2180		2501
2181	SV *	2502	SV *
2182	bot_at (maptile *obj, unsigned int x, unsigned int y)	2503	bot_at (maptile *map, unsigned int x, unsigned int y, int dir = 0)
2183	PROTOTYPE: $$$	2504	PROTOTYPE: $$$;$
2184	ALIAS:	2505	ALIAS:
2185	top_at = 1	2506	top_at = 1
2186	flags_at = 2	2507	flags_at = 2
2187	light_at = 3	2508	light_at = 3
2188	move_block_at = 4	2509	move_block_at = 4
2189	move_slow_at = 5	2510	move_slow_at = 5
2190	move_on_at = 6	2511	move_on_at = 6
2191	move_off_at = 7	2512	move_off_at = 7
2192	INIT:
2193	if (x >= obj->width \|\| y >= obj->height) XSRETURN_UNDEF;
2194	CODE:	2513	CODE:
		2514	{
		2515	mapxy pos (map, x, y);
		2516	if (!pos.move (dir).normalise ())
		2517	XSRETURN_UNDEF;
		2518
		2519	mapspace &ms = *pos;
		2520
		2521	ms.update ();
		2522
2195	switch (ix)	2523	switch (ix)
2196	{	2524	{
2197	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;	2525	case 0: RETVAL = to_sv (ms.bot ); break;
2198	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;	2526	case 1: RETVAL = to_sv (ms.top ); break;
2199	case 2: RETVAL = newSVuv ( GET_MAP_FLAGS (obj, x, y)); break;	2527	case 2: RETVAL = newSVuv (ms.flags_ ); break;
2200	case 3: RETVAL = newSViv ( GET_MAP_LIGHT (obj, x, y)); break;	2528	case 3: RETVAL = newSViv (ms.light ); break;
2201	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;	2529	case 4: RETVAL = newSVuv (ms.move_block); break;
2202	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;	2530	case 5: RETVAL = newSVuv (ms.move_slow ); break;
2203	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;	2531	case 6: RETVAL = newSVuv (ms.move_on ); break;
2204	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;	2532	case 7: RETVAL = newSVuv (ms.move_off ); break;
2205	}	2533	}
		2534	}
2206	OUTPUT: RETVAL	2535	OUTPUT: RETVAL
2207
2208	void fix_walls (maptile *map, int x, int y)
2209
2210	void fix_walls_around (maptile *map, int x, int y)
2211
2212	const char *
2213	region_name (maptile *m)
2214	CODE:
2215	RETVAL = get_name_of_region_for_map (m);
2216	OUTPUT: RETVAL
2217		2536
2218	# worst xs function of my life	2537	# worst xs function of my life
2219	bool	2538	bool
2220	_create_random_map (\	2539	_create_random_map (\
2221	maptile *self,\	2540	maptile *self,\
2222	char *wallstyle,\	2541	SV *options,\
2223	char *wall_name,\
2224	char *floorstyle,\
2225	char *monsterstyle,\
2226	char *treasurestyle,\
2227	char *layoutstyle,\
2228	char *doorstyle,\
2229	char *decorstyle,\
2230	char *origin_map,\
2231	char *final_map,\
2232	char *exitstyle,\
2233	char *this_map,\
2234	char *exit_on_final_map,\
2235	int xsize,\
2236	int ysize,\
2237	int expand2x,\
2238	int layoutoptions1,\
2239	int layoutoptions2,\
2240	int layoutoptions3,\
2241	int symmetry,\
2242	int difficulty,\
2243	int difficulty_given,\
2244	float difficulty_increase,\
2245	int dungeon_level,\
2246	int dungeon_depth,\
2247	int decoroptions,\
2248	int orientation,\
2249	int origin_y,\
2250	int origin_x,\
2251	U32 random_seed,\
2252	val64 total_map_hp,\	2542	val64 total_map_hp,\
2253	int map_layout_style,\
2254	int treasureoptions,\
2255	int symmetry_used,\
2256	region *region,\	2543	region *region\
2257	char *custom\
2258	)	2544	)
2259	CODE:	2545	CODE:
2260	{	2546	{
2261	random_map_params rmp;	2547	random_map_params rmp;
2262		2548
2263	assign (rmp.wallstyle , wallstyle);	2549	rmp.hv = (HV *)SvREFCNT_inc_NN (SvRV (options));
		2550
2264	assign (rmp.wall_name , wall_name);	2551	assign (rmp.wall_name , rmp.get_str ("wall_name"));
2265	assign (rmp.floorstyle , floorstyle);
2266	assign (rmp.monsterstyle , monsterstyle);	2552	assign (rmp.monsterstyle , rmp.get_str ("monsterstyle"));
2267	assign (rmp.treasurestyle , treasurestyle);
2268	assign (rmp.layoutstyle , layoutstyle);	2553	assign (rmp.layoutstyle , rmp.get_str ("layoutstyle"));
2269	assign (rmp.doorstyle , doorstyle);	2554	assign (rmp.doorstyle , rmp.get_str ("doorstyle"));
2270	assign (rmp.decorstyle , decorstyle);
2271	assign (rmp.exitstyle , exitstyle);
2272	assign (rmp.exit_on_final_map, exit_on_final_map);	2555	assign (rmp.exit_on_final_map, rmp.get_str ("exit_on_final_map"));
2273		2556
2274	rmp.origin_map = origin_map;	2557	rmp.origin_map = rmp.get_str ("origin_map");
		2558	rmp.origin_x = rmp.get_iv ("origin_x");
		2559	rmp.origin_y = rmp.get_iv ("origin_y");
2275	rmp.final_map = final_map;	2560	rmp.final_map = rmp.get_str ("final_map");
2276	rmp.this_map = this_map;	2561	rmp.this_map = rmp.get_str ("this_map");
2277	rmp.xsize = xsize;	2562	rmp.xsize = rmp.get_iv ("xsize");
2278	rmp.ysize = ysize;	2563	rmp.ysize = rmp.get_iv ("ysize");
2279	rmp.expand2x = expand2x;	2564	rmp.expand2x = rmp.get_iv ("expand2x");
2280	rmp.layoutoptions1 = layoutoptions1;	2565	rmp.layoutoptions1 = rmp.get_iv ("layoutoptions1");
2281	rmp.layoutoptions2 = layoutoptions2;	2566	rmp.layoutoptions2 = rmp.get_iv ("layoutoptions2");
2282	rmp.layoutoptions3 = layoutoptions3;	2567	rmp.layoutoptions3 = rmp.get_iv ("layoutoptions3");
2283	rmp.symmetry = symmetry;	2568	rmp.symmetry = rmp.get_iv ("symmetry");
2284	rmp.difficulty = difficulty;	2569	rmp.difficulty = rmp.get_iv ("difficulty");
2285	rmp.difficulty_given = difficulty_given;	2570	rmp.difficulty_given = rmp.get_iv ("difficulty_given");
2286	rmp.difficulty_increase = difficulty_increase;	2571	rmp.difficulty_increase = rmp.get_nv ("difficulty_increase");
2287	rmp.dungeon_level = dungeon_level;	2572	rmp.dungeon_level = rmp.get_iv ("dungeon_level");
2288	rmp.dungeon_depth = dungeon_depth;	2573	rmp.dungeon_depth = rmp.get_iv ("dungeon_depth");
2289	rmp.decoroptions = decoroptions;
2290	rmp.orientation = orientation;	2574	rmp.orientation = rmp.get_iv ("orientation");
2291	rmp.origin_y = origin_y;
2292	rmp.origin_x = origin_x;
2293	rmp.random_seed = random_seed;	2575	rmp.random_seed = rmp.get_uv ("random_seed");
2294	rmp.total_map_hp = total_map_hp;	2576	rmp.total_map_hp = (uint64_t)total_map_hp;
2295	rmp.map_layout_style = map_layout_style;	2577	rmp.map_layout_style = rmp.get_iv ("map_layout_style");
2296	rmp.treasureoptions = treasureoptions;
2297	rmp.symmetry_used = symmetry_used;	2578	rmp.symmetry_used = rmp.get_iv ("symmetry_used");
2298	rmp.region = region;	2579	rmp.region = region;
2299	rmp.custom = custom;
2300		2580
2301	RETVAL = self->generate_random_map (&rmp);	2581	RETVAL = self->generate_random_map (&rmp);
2302	}	2582	}
2303	OUTPUT:	2583	OUTPUT:
2304	RETVAL	2584	RETVAL
2305		2585
		2586	MODULE = cf PACKAGE = cf::mapspace
		2587
		2588	INCLUDE: $PERL $srcdir/genacc mapspace $srcdir/../include/map.h \|
		2589
2306	MODULE = cf PACKAGE = cf::arch	2590	MODULE = cf PACKAGE = cf::arch
2307		2591
2308	archetype find (const char name)	2592	int archetypes_size ()
2309	CODE:	2593	CODE:
2310	RETVAL = archetype::find (name);	2594	RETVAL = archetypes.size ();
2311	OUTPUT:
2312	RETVAL
2313
2314	archetype *first()
2315	PROTOTYPE:
2316	CODE:
2317	RETVAL = first_archetype;
2318	OUTPUT: RETVAL	2595	OUTPUT: RETVAL
2319		2596
		2597	archetype *archetypes (U32 index)
		2598	CODE:
		2599	RETVAL = index < archetypes.size () ? archetypes [index] : 0;
		2600	OUTPUT: RETVAL
		2601
2320	INCLUDE: $PERL genacc archetype ../include/object.h \|	2602	INCLUDE: $PERL $srcdir/genacc archetype $srcdir/../include/object.h \|
2321		2603
2322	MODULE = cf PACKAGE = cf::party	2604	MODULE = cf PACKAGE = cf::party
2323		2605
2324	partylist *first ()	2606	partylist *first ()
2325	PROTOTYPE:	2607	PROTOTYPE:
2326	CODE:	2608	CODE:
2327	RETVAL = get_firstparty ();	2609	RETVAL = get_firstparty ();
2328	OUTPUT: RETVAL	2610	OUTPUT: RETVAL
2329		2611
2330	INCLUDE: $PERL genacc partylist ../include/player.h \|	2612	INCLUDE: $PERL $srcdir/genacc partylist $srcdir/../include/player.h \|
2331		2613
2332	MODULE = cf PACKAGE = cf::region	2614	MODULE = cf PACKAGE = cf::region
2333		2615
2334	region *first ()	2616	void
2335	PROTOTYPE:	2617	list ()
2336	CODE:	2618	PPCODE:
2337	RETVAL = first_region;	2619	for_all_regions (rgn)
		2620	XPUSHs (sv_2mortal (to_sv (rgn)));
		2621
		2622	int specificity (region *rgn)
		2623	CODE:
		2624	RETVAL = 0;
		2625	while (rgn = rgn->parent)
		2626	RETVAL++;
2338	OUTPUT: RETVAL	2627	OUTPUT: RETVAL
2339		2628
2340	region find (char name)
2341	PROTOTYPE: $
2342	CODE:
2343	RETVAL = get_region_by_name (name);
2344	OUTPUT: RETVAL
2345
2346	INCLUDE: $PERL genacc region ../include/map.h \|	2629	INCLUDE: $PERL $srcdir/genacc region $srcdir/../include/region.h \|
2347		2630
2348	MODULE = cf PACKAGE = cf::living	2631	MODULE = cf PACKAGE = cf::living
2349		2632
2350	INCLUDE: $PERL genacc living ../include/living.h \|	2633	INCLUDE: $PERL $srcdir/genacc living $srcdir/../include/living.h \|
2351		2634
2352	MODULE = cf PACKAGE = cf::settings	2635	MODULE = cf PACKAGE = cf::settings
2353		2636
2354	INCLUDE: $PERL genacc Settings ../include/global.h \|	2637	INCLUDE: $PERL $srcdir/genacc Settings $srcdir/../include/global.h \|
2355		2638
2356	MODULE = cf PACKAGE = cf::client	2639	MODULE = cf PACKAGE = cf::client
2357		2640
2358	INCLUDE: $PERL genacc client ../include/client.h \|	2641	INCLUDE: $PERL $srcdir/genacc client $srcdir/../include/client.h \|
2359		2642
2360	int invoke (client *ns, int event, ...)	2643	int invoke (client *ns, int event, ...)
2361	CODE:	2644	CODE:
2362	if (KLASS_OF (event) != KLASS_CLIENT) croak ("event class must be CLIENT");	2645	if (KLASS_OF (event) != KLASS_CLIENT) croak ("event class must be CLIENT");
2363	AV av = (AV )sv_2mortal ((SV *)newAV ());	2646	AV av = (AV )sv_2mortal ((SV *)newAV ());
…		…
2379	CODE:	2662	CODE:
2380	{	2663	{
2381	STRLEN len;	2664	STRLEN len;
2382	char *buf = SvPVbyte (packet, len);	2665	char *buf = SvPVbyte (packet, len);
2383		2666
		2667	if (len > MAXSOCKBUF)
		2668	{
		2669	// ugly
		2670	if (THIS->pl)
		2671	THIS->pl->failmsg ("[packet too long for client]");
		2672	}
		2673	else
2384	THIS->send_packet (buf, len);	2674	THIS->send_packet (buf, len);
2385	}	2675	}
2386		2676
		2677	faceidx
		2678	client::need_face (utf8_string name, int pri = 0)
		2679	CODE:
		2680	RETVAL = face_find (name, 0);
		2681	if (RETVAL)
		2682	{
		2683	THIS->send_face (RETVAL, pri);
		2684	THIS->flush_fx ();
		2685	}
		2686	OUTPUT:
		2687	RETVAL
		2688
		2689	int
		2690	client::fx_want (int idx, int value = -1)
		2691	CODE:
		2692	if (0 < idx && idx < FT_NUM)
		2693	{
		2694	RETVAL = THIS->fx_want [idx];
		2695	if (items > 2)
		2696	THIS->fx_want [idx] = value;
		2697	}
		2698	else
		2699	RETVAL = 0;
		2700	OUTPUT:
		2701	RETVAL
		2702
		2703	MODULE = cf PACKAGE = cf::sound PREFIX = sound_
		2704
		2705	faceidx sound_find (utf8_string name)
		2706
		2707	void sound_set (utf8_string str, faceidx face)
		2708
		2709	# dire hack
		2710	void old_sound_index (int idx, faceidx face)
		2711	CODE:
		2712	extern faceidx old_sound_index [SOUND_CAST_SPELL_0];
		2713	old_sound_index [idx] = face;
		2714
		2715	MODULE = cf PACKAGE = cf::face PREFIX = face_
		2716
		2717	#INCLUDE: $PERL $srcdir/genacc faceset $srcdir/../include/face.h \|
		2718
		2719	faceidx face_find (utf8_string name, faceidx defidx = 0)
		2720
		2721	faceidx alloc (utf8_string name)
		2722	CODE:
		2723	{
		2724	do
		2725	{
		2726	RETVAL = faces.size ();
		2727	faces.resize (RETVAL + 1);
		2728	}
		2729	while (!RETVAL); // crude way to leave index 0
		2730
		2731	faces [RETVAL].name = name;
		2732	facehash.insert (std::make_pair (faces [RETVAL].name, RETVAL));
		2733
		2734	if (!strcmp (name, BLANK_FACE_NAME )) blank_face = RETVAL;
		2735	if (!strcmp (name, EMPTY_FACE_NAME )) empty_face = RETVAL;
		2736	if (!strcmp (name, MAGICMOUTH_FACE_NAME)) magicmouth_face = RETVAL;
		2737	}
		2738	OUTPUT: RETVAL
		2739
		2740	void set_type (faceidx idx, int value)
		2741	ALIAS:
		2742	set_type = 0
		2743	set_visibility = 1
		2744	set_magicmap = 2
		2745	set_smooth = 3
		2746	set_smoothlevel = 4
		2747	CODE:
		2748	faceinfo *f = face_info (idx); assert (f);
		2749	switch (ix)
		2750	{
		2751	case 0: f->type = value; break;
		2752	case 1: f->visibility = value; break;
		2753	case 2: f->magicmap = value; break;
		2754	case 3: f->smooth = value; break;
		2755	case 4: f->smoothlevel = value; break;
		2756	}
		2757
		2758	void set_data (faceidx idx, int faceset, SV data, SV chksum)
		2759	CODE:
		2760	{
		2761	faceinfo *f = face_info (idx); assert (f);
		2762	facedata *d = &(faceset ? f->data64 : f->data32);
		2763	sv_to (data, d->data);
		2764	STRLEN clen;
		2765	char *cdata = SvPVbyte (chksum, clen);
		2766	clen = min (CHKSUM_MAXLEN, clen);
		2767
		2768	assert (("cf::face::set_data must be called with a non-empty checksum", clen));
		2769
		2770	if (clen != d->chksum_len \|\| memcmp (d->chksum, cdata, clen))
		2771	{
		2772	d->chksum_len = clen;
		2773	memcpy (d->chksum, cdata, clen);
		2774
		2775	// invalidate existing client face info
		2776	for_all_clients (ns)
		2777	if (ns->faceset == faceset)
		2778	{
		2779	ns->faces_sent [idx] = false;
		2780	ns->force_newmap = true;
		2781	}
		2782	}
		2783	}
		2784
		2785	int get_data_size (faceidx idx, int faceset = 0)
		2786	CODE:
		2787	facedata *d = face_data (idx, faceset);
		2788	if (!d) XSRETURN_UNDEF;
		2789	RETVAL = d->data.size ();
		2790	OUTPUT:
		2791	RETVAL
		2792
		2793	SV *get_chksum (faceidx idx, int faceset = 0)
		2794	CODE:
		2795	facedata *d = face_data (idx, faceset);
		2796	if (!d) XSRETURN_UNDEF;
		2797	RETVAL = newSVpvn ((char *)d->chksum, d->chksum_len);
		2798	OUTPUT:
		2799	RETVAL
		2800
		2801	SV *get_data (faceidx idx, int faceset = 0)
		2802	CODE:
		2803	facedata *d = face_data (idx, faceset);
		2804	if (!d) XSRETURN_UNDEF;
		2805	RETVAL = newSVpvn (d->data.data (), d->data.length ());
		2806	OUTPUT:
		2807	RETVAL
		2808
		2809	void invalidate (faceidx idx)
		2810	CODE:
		2811	for_all_clients (ns)
		2812	{
		2813	ns->faces_sent [idx] = false;
		2814	ns->force_newmap = true;
		2815	}
		2816
		2817	void invalidate_all ()
		2818	CODE:
		2819	for_all_clients (ns)
		2820	{
		2821	ns->faces_sent.reset ();
		2822	ns->force_newmap = true;
		2823	}
		2824
		2825	MODULE = cf PACKAGE = cf::anim PREFIX = anim_
		2826
		2827	#INCLUDE: $PERL $srcdir/genacc faceset $srcdir/../include/anim.h \|
		2828
		2829	animidx anim_find (utf8_string name)
		2830	CODE:
		2831	RETVAL = animation::find (name).number;
		2832	OUTPUT: RETVAL
		2833
		2834	animidx set (utf8_string name, SV *frames, int facings = 1)
		2835	CODE:
		2836	{
		2837	if (!SvROK (frames) && SvTYPE (SvRV (frames)) != SVt_PVAV)
		2838	croak ("frames must be an arrayref");
		2839
		2840	AV av = (AV )SvRV (frames);
		2841
		2842	animation *anim = &animation::find (name);
		2843	if (anim->number)
		2844	{
		2845	anim->resize (av_len (av) + 1);
		2846	anim->facings = facings;
		2847	}
		2848	else
		2849	anim = &animation::create (name, av_len (av) + 1, facings);
		2850
		2851	for (int i = 0; i < anim->num_animations; ++i)
		2852	anim->faces [i] = face_find (cfSvPVutf8_nolen (*av_fetch (av, i, 1)));
		2853	}
		2854	OUTPUT: RETVAL
		2855
		2856	void invalidate_all ()
		2857	CODE:
		2858	for_all_clients (ns)
		2859	ns->anims_sent.reset ();
		2860
		2861	MODULE = cf PACKAGE = cf::object::freezer
		2862
		2863	INCLUDE: $PERL $srcdir/genacc object_freezer $srcdir/../include/cfperl.h \|
		2864
		2865	SV *
		2866	new (char *klass)
		2867	CODE:
		2868	RETVAL = newSVptr (new object_freezer, gv_stashpv ("cf::object::freezer", 1));
		2869	OUTPUT: RETVAL
		2870
		2871	void
		2872	DESTROY (SV *sv)
		2873	CODE:
		2874	object_freezer *self;
		2875	sv_to (sv, self);
		2876	delete self;
		2877
		2878	MODULE = cf PACKAGE = cf::object::thawer
		2879
		2880	INCLUDE: $PERL $srcdir/genacc object_thawer $srcdir/../include/freezethaw.h \|
		2881
		2882	bool
		2883	errors_are_fatal (bool fatal)
		2884	CODE:
		2885	RETVAL = object_thawer::errors_are_fatal;
		2886	object_thawer::errors_are_fatal = fatal;
		2887	OUTPUT:
		2888	RETVAL
		2889
		2890	SV *
		2891	new_from_file (char *klass, octet_string path)
		2892	CODE:
		2893	object_thawer *f = new object_thawer (path);
		2894	if (!*f)
		2895	{
		2896	delete f;
		2897	XSRETURN_UNDEF;
		2898	}
		2899	RETVAL = newSVptr (f, gv_stashpv ("cf::object::thawer", 1));
		2900	OUTPUT: RETVAL
		2901
		2902	void
		2903	DESTROY (SV *sv)
		2904	CODE:
		2905	object_thawer *self;
		2906	sv_to (sv, self);
		2907	delete self;
		2908
		2909	void
		2910	extract_tags (object_thawer *self)
		2911	PPCODE:
		2912	while (self->kw != KW_EOF)
		2913	{
		2914	PUTBACK;
		2915	coroapi::cede_to_tick ();
		2916	SPAGAIN;
		2917
		2918	if (self->kw == KW_tag)
		2919	XPUSHs (sv_2mortal (newSVpv_utf8 (self->get_str ())));
		2920
		2921	self->skip ();
		2922	}
		2923

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.152 by root, Tue Jan 23 03:17:56 2007 UTC vs. Revision 1.388 by root, Wed Jun 30 01:57:54 2010 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.152 by root, Tue Jan 23 03:17:56 2007 UTC vs.
Revision 1.388 by root, Wed Jun 30 01:57:54 2010 UTC