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

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.151 by root, Tue Jan 23 01:29:51 2007 UTC vs. Revision 1.425 by root, Wed Nov 14 06:21:39 2012 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.151 by root, Tue Jan 23 01:29:51 2007 UTC vs.
Revision 1.425 by root, Wed Nov 14 06:21:39 2012 UTC