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

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.144 by root, Fri Jan 19 15:55:27 2007 UTC vs. Revision 1.423 by root, Wed Nov 14 05:25:50 2012 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.144 by root, Fri Jan 19 15:55:27 2007 UTC vs.
Revision 1.423 by root, Wed Nov 14 05:25:50 2012 UTC