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

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.153 by root, Fri Jan 26 20:59:57 2007 UTC vs. Revision 1.429 by root, Sat Nov 17 23:33:18 2018 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.153 by root, Fri Jan 26 20:59:57 2007 UTC vs.
Revision 1.429 by root, Sat Nov 17 23:33:18 2018 UTC