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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.168 by root, Thu Feb 15 03:19:02 2007 UTC vs.
Revision 1.425 by root, Wed Nov 14 06:21:39 2012 UTC

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.168 by root, Thu Feb 15 03:19:02 2007 UTC vs. Revision 1.425 by root, Wed Nov 14 06:21:39 2012 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.168 by root, Thu Feb 15 03:19:02 2007 UTC vs.
Revision 1.425 by root, Wed Nov 14 06:21:39 2012 UTC