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