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

Diff Legend

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