ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/cfperl.xs

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

Diff Legend

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