ViewVC Help

View File | Revision Log | Show Annotations | Download File

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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.1 by root, Tue Aug 15 17:10:46 2006 UTC vs.
Revision 1.272 by root, Wed Apr 2 11:13:56 2008 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	*
		4	* Copyright (©) 2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
8	* Copyright (C) 2001-2005 by Chachkoff Yann	5	* Copyright (©) 2001-2005,2007 by Chachkoff Yann
9	* Copyright (C) 2006 by Marc Lehmann <cf@schmorpd.e>	6	* Copyright (©) 2006,2007 by Marc Lehmann <cf@schmorp.de>
10	*	7	*
11	* This program is free software; you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify
12	* it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
13	* the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation, either version 3 of the License, or
14	* (at your option) any later version.	11	* (at your option) any later version.
15	*	12	*
16	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
17	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19	* GNU General Public License for more details.	16	* GNU General Public License for more details.
20	*	17	*
21	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
22	* along with this program; if not, write to the Free Software	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
23	* Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA	20	*
		21	* The authors can be reached via e-mail to <support@deliantra.net>
24	*/	22	*/
		23
		24	#include "autoconf.h"
		25
		26	#define PLUGIN_NAME "perl"
		27	#define PLUGIN_VERSION "cfperl 0.5"
		28
		29	#if HAVE_EXECINFO_H
		30	# include <execinfo.h>
		31	#endif
		32
		33	#include <cstdarg>
		34
		35	#include "global.h"
		36	#include "loader.h"
		37	#include "../random_maps/random_map.h"
		38	#include "evthread.h"
		39	#include "sproto.h"
		40
		41	#include <unistd.h>
		42	#if _POSIX_MEMLOCK
		43	# include <sys/mman.h>
		44	#endif
		45
		46	#if HAVE_MALLOC_H
		47	# include <malloc.h>
		48	#endif
25		49
26	#include <EXTERN.h>	50	#include <EXTERN.h>
27	#include <perl.h>	51	#include <perl.h>
28	#include <XSUB.h>	52	#include <XSUB.h>
29		53
30	#undef save_long // clashes with libproto.h	54	#include "CoroAPI.h"
		55	#include "perlxsi.c"
31		56
32	#define PLUGIN_NAME "perl"	57	extern sint64 *levels; // the experience table
33	#define PLUGIN_VERSION "cfperl 0.3"
34		58
35	#ifndef __CEXTRACT__	59	typedef object_thawer &object_thawer_ref;
36	#include <plugin.h>	60	typedef object_freezer &object_freezer_ref;
		61
		62	typedef std::string std__string;
		63
		64	#if IVSIZE >= 8
		65	typedef IV val64;
		66	# define newSVval64 newSViv
		67	# define SvVAL64 SvIV
		68	#else
		69	typedef double val64;
		70	# define newSVval64 newSVnv
		71	# define SvVAL64 SvNV
37	#endif	72	#endif
38		73
39	#undef MODULEAPI	74	static PerlInterpreter *perl;
40	#ifdef WIN32	75
41	#else	76	tstamp NOW, runtime;
42	#define MODULEAPI	77
		78	static int tick_inhibit;
		79	static int tick_pending;
		80
		81	global gbl_ev;
		82	static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map;
		83	static SV *sv_runtime, *sv_tick_start, *sv_next_tick, *sv_now;
		84
		85	bitset<NUM_EVENT_TYPES> ev_want_event;
		86	bitset<NUM_TYPES> ev_want_type;
		87
		88	static HV
		89	*stash_cf,
		90	*stash_cf_object_wrap,
		91	*stash_cf_object_player_wrap,
		92	*stash_cf_player_wrap,
		93	*stash_cf_map_wrap,
		94	*stash_cf_client_wrap,
		95	*stash_cf_arch_wrap,
		96	*stash_cf_party_wrap,
		97	*stash_cf_region_wrap,
		98	*stash_cf_living_wrap;
		99
		100	static inline SV *
		101	newSVpv_utf8 (const char *s)
		102	{
		103	if (!s)
		104	return newSV (0);
		105
		106	SV *sv = newSVpv (s, 0);
		107	SvUTF8_on (sv);
		108	return sv;
		109	}
		110
		111	static inline SV *
		112	newSVpvn_utf8 (const char *s, STRLEN l)
		113	{
		114	if (!s)
		115	return newSV (0);
		116
		117	SV *sv = newSVpvn (s, l);
		118	SvUTF8_on (sv);
		119	return sv;
		120	}
		121
		122	// helper cast function, returns super class * or 0
		123	template<class super>
		124	static super *
		125	is_a (attachable *at)
		126	{
		127	//return dynamic_cast<super *>(at); // slower, safer
		128	if (typeid (*at) == typeid (super))
		129	return static_cast<super *>(at);
		130	else
		131	return 0;
		132	}
		133
		134	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		135
		136	unordered_vector<attachable *> attachable::mortals;
		137
		138	attachable::~attachable ()
		139	{
		140	assert (!self);
		141	assert (!cb);
		142	}
		143
		144	int
		145	attachable::refcnt_cnt () const
		146	{
		147	return refcnt + (self ? SvREFCNT (self) - 1 : 0);
		148	}
		149
		150	void
		151	attachable::sever_self ()
		152	{
		153	if (HV *self = this->self)
		154	{
		155	// keep a refcount because sv_unmagic might call attachable_free,
		156	// which might clear self, causing sv_unmagic to crash on a now
		157	// invalid object.
		158	SvREFCNT_inc (self);
		159	hv_clear (self);
		160	sv_unmagic ((SV *)self, PERL_MAGIC_ext);
		161	SvREFCNT_dec (self);
		162
		163	// self *must* be null now because thats sv_unmagic's job.
		164	assert (!this->self);
		165	}
		166	}
		167
		168	void
		169	attachable::optimise ()
		170	{
		171	if (self
		172	&& SvREFCNT (self) == 1
		173	&& !HvTOTALKEYS (self))
		174	sever_self ();
		175	}
		176
		177	// check wether the object really is dead
		178	void
		179	attachable::do_check ()
		180	{
		181	if (refcnt_cnt () > 0)
		182	return;
		183
		184	destroy ();
		185	}
		186
		187	void
		188	attachable::do_destroy ()
		189	{
		190	INVOKE_ATTACHABLE (DESTROY, this);
		191
		192	if (cb)
		193	{
		194	SvREFCNT_dec (cb);
		195	cb = 0;
		196	}
		197
		198	mortals.push_back (this);
		199	}
		200
		201	void
		202	attachable::destroy ()
		203	{
		204	if (destroyed ())
		205	return;
		206
		207	flags |= F_DESTROYED;
		208	do_destroy ();
		209	sever_self ();
		210	}
		211
		212	void
		213	attachable::check_mortals ()
		214	{
		215	static int i = 0;
		216
		217	for (;;)
		218	{
		219	if (i >= mortals.size ())
		220	{
		221	i = 0;
		222
		223	if (mortals.size () >= 512)
		224	{
		225	static int last_mortalcount;
		226	if (mortals.size () != last_mortalcount)
		227	{
		228	last_mortalcount = mortals.size ();
		229	LOG (llevInfo, "%d mortals.\n", (int)mortals.size ());
		230
		231	if (0)
		232	{
		233	for (int j = 0; j < mortals.size (); ++j)//D
		234	fprintf (stderr, "%d:%s %p ", j, &((object *)mortals[j])->name, mortals[j]);//D
		235	fprintf (stderr, "\n");//D
		236	}
		237	}
		238	}
		239
		240	break;
		241	}
		242
		243	attachable *obj = mortals [i];
		244
		245	#if 0
		246	if (obj->self)//D make this an assert later
		247	{
		248	LOG (llevError, "check_mortals: object '%s' still has self\n", typeid (obj).name ());
		249	obj->sever_self ();
		250	}
43	#endif	251	#endif
44		252
45	#include <plugin_common.h>	253	if (obj->refcnt)
46	#include <sounds.h>
47
48	#include <stdarg.h>
49
50	#include <sproto.h>
51
52	//#include "EventAPI.h"
53	#include "perlxsi.c"
54
55	static void *globalEventListener (int *type, ...);
56
57	extern sint64 *levels; // the experience table
58
59	typedef object object_ornull;
60	typedef mapstruct mapstruct_ornull;
61
62	typedef double val64;
63	#define newSVval64 newSVnv
64	#define SvVAL64 SvNV
65
66	static f_plug_api gethook;
67	static f_plug_api registerGlobalEvent;
68	static f_plug_api unregisterGlobalEvent;
69	static f_plug_api systemDirectory;
70	static f_plug_api object_set_property;
71	static f_plug_api map_get_map;
72	static f_plug_api object_insert;
73
74	/* this is a stupid way to do things, and awkward to use for plug-in authors */
75	typedef struct
76	{
77	object* who;
78	object* activator;
79	object* third;
80	object* event;
81	mapstruct* map;
82	char message[1024];
83	int fix; // seems to be python-only, and should not be part of the API
84	int event_code;
85	char extension[1024]; // name field, should invoke specific perl extension
86	char options[1024]; // slaying field of event_connectors
87	int returnvalue;
88	} CFPContext;
89
90	static HV *obj_cache;
91	static PerlInterpreter *perl;
92
93	#define PUSHcfapi(type,value) PUSHs (sv_2mortal (newSVcfapi (CFAPI_ ## type, (value))))
94	#define PUSHcfapi_va(type,ctype) PUSHcfapi (type, va_arg (args, ctype))
95	#define PUSH_OB PUSHcfapi_va(POBJECT, object *)
96	#define PUSH_PL PUSHcfapi_va(PPLAYER, player *)
97	#define PUSH_MAP PUSHcfapi_va(PMAP, mapstruct *)
98	#define PUSH_PV PUSHcfapi_va(STRING, const char *)
99	#define PUSH_IV PUSHs (sv_2mortal (newSViv (va_arg (args, int))))
100
101	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
102
103	// garbage collect some perl objects, if possible
104	// all objects no longer referenced and empty are
105	// eligible for destruction.
106	static void
107	clean_obj_cache ()
108	{
109	static int count;
110
111	if (++count & 7)
112	return;
113
114	int todo = 1000;
115	do
116	{
117	I32 klen;
118	char *key;
119	HE *he = hv_iternext (obj_cache);
120
121	if (he)
122	{	254	{
123	SV *sv = hv_iterval (obj_cache, he);	255	++i; // further delay freeing
124		256
125	// empty and unreferenced? nuke it	257	if (!(i & 0x3ff))
126	if (SvREFCNT (sv) == 1 && SvREFCNT (SvRV (sv)) == 1 && !HvFILL ((HV *)(SvRV (sv))))
127	{	258	break;
128	hv_delete (obj_cache, HeKEY (he), HeKLEN (he), G_DISCARD);
129	todo++;
130	}
131	}	259	}
132	else	260	else
133	break;	261	{
		262	mortals.erase (i);
		263	obj->sever_self ();
		264	delete obj;
		265	}
134	}	266	}
135	while (--todo);
136	}	267	}
		268
		269	void
		270	attachable::set_key (const char *key, const char *value, bool is_utf8)
		271	{
		272	if (!self)
		273	self = newHV ();
		274
		275	if (value)
		276	hv_store (self, key, strlen (key), is_utf8 ? newSVpv_utf8 (value) : newSVpv (value, 0), 0);
		277	else
		278	hv_delete (self, key, strlen (key), G_DISCARD);
		279	}
		280
		281	attachable &
		282	attachable::operator =(const attachable &src)
		283	{
		284	//if (self || cb)
		285	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));
		286
		287	attach = src.attach;
		288	return *this;
		289	}
		290
		291	template<typename T>
		292	static bool
		293	find_backref (void *ptr, T *obj)
		294	{
		295	char *s = (char *)obj;
		296	while (s < (char *)obj + sizeof (T))
		297	{
		298	if (ptr == *(void **)s)
		299	return true;
		300
		301	s += sizeof (void *); // assume natural alignment
		302	}
		303
		304	return false;
		305	}
		306
		307	// for debugging, find "live" objects containing this ptr
		308	void
		309	find_backref (void *ptr)
		310	{
		311	for_all_objects (op)
		312	if (find_backref (ptr, op))
		313	fprintf (stderr, "O %p %d:'%s'\n", op, op->count, &op->name);
		314
		315	for_all_players (pl)
		316	if (find_backref (ptr, pl))
		317	fprintf (stderr, "P %p\n", pl);
		318
		319	for_all_clients (ns)
		320	if (find_backref (ptr, ns))
		321	fprintf (stderr, "C %p\n", ns);
		322
		323	}
		324
		325	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
137		326
138	static SV *	327	static SV *
139	newSVptr (void *ptr, const char *klass)	328	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())
140	{	329	{
141	SV *sv;	330	SV *sv;
142		331
143	if (!ptr)	332	if (!ptr)
144	return &PL_sv_undef;	333	return newSV (0);
145		334
146	sv = newSV (0);
147	sv_magic (sv, 0, PERL_MAGIC_ext, (char *)ptr, 0);	335	sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);
148	return sv_bless (newRV_noinc (sv), gv_stashpv (klass, 1));	336	return sv_bless (newRV_noinc ((SV *)hv), stash);
149	}	337	}
150		338
151	static void	339	static int
152	SVptr_cache_set (void *ptr, SV *sv)	340	attachable_free (pTHX_ SV *sv, MAGIC *mg)
153	{	341	{
154	hv_store (obj_cache, (char *)&ptr, sizeof (ptr), sv, 0);	342	attachable *at = (attachable *)mg->mg_ptr;
		343
		344	//TODO: check if transaction behaviour is really required here
		345	if (SV *self = (SV *)at->self)
		346	{
		347	at->self = 0;
		348	SvREFCNT_dec (self);
		349	}
		350
		351	// next line makes sense, but most objects still have refcnt 0 by default
		352	//at->refcnt_chk ();
		353	return 0;
155	}	354	}
		355
		356	MGVTBL attachable::vtbl = {0, 0, 0, 0, attachable_free};
156		357
157	static SV *	358	static SV *
158	SVptr_cache_get (void *ptr)	359	newSVattachable (attachable *obj, HV *stash)
159	{	360	{
160	SV **he = hv_fetch (obj_cache, (char *)&ptr, sizeof (ptr), 0);
161
162	return he ? *he : 0;
163	}
164
165	static SV *
166	newSVptr_cached (void *ptr, const char *klass)
167	{
168	SV *sv;
169
170	if (!ptr)
171	return &PL_sv_undef;
172
173	sv = SVptr_cache_get (ptr);
174
175	if (!sv)	361	if (!obj)
		362	return newSV (0);
		363
		364	if (!obj->self)
		365	obj->self = newHV ();
		366
		367	if (!SvOBJECT (obj->self))
176	{	368	{
177	HV *hv = newHV ();	369	sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char *)obj, 0);
178	sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0);
179	sv = sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));
180		370
181	SVptr_cache_set (ptr, sv);	371	// now bless the object _once_
		372	//TODO: create a class registry with c++ type<=>perl name<=>stash and use it here and elsewhere
		373	return sv_bless (newRV_inc ((SV *)obj->self), stash);
182	}	374	}
		375	else
		376	{
		377	SV *sv = newRV_inc ((SV *)obj->self);
183		378
184	return newSVsv (sv);	379	if (Gv_AMG (stash)) // handle overload correctly, as the perl core does not
		380	SvAMAGIC_on (sv);
		381
		382	return sv;
		383	}
185	}	384	}
186		385
187	static void	386	static void
188	clearSVptr (SV *sv)	387	clearSVptr (SV *sv)
189	{	388	{
…		…
215	return SvPTR (sv, klass);	414	return SvPTR (sv, klass);
216	else	415	else
217	return 0;	416	return 0;
218	}	417	}
219		418
		419	inline SV *to_sv (const shstr & v) { return newSVpvn_utf8 ((const char *)v, v.length ()); }
		420	inline SV *to_sv (const char * v) { return v ? newSVpv (v, 0) : newSV (0); }
		421	inline SV *to_sv (bool v) { return newSViv (v); }
		422	inline SV *to_sv ( signed char v) { return newSViv (v); }
		423	inline SV *to_sv (unsigned char v) { return newSViv (v); }
		424	inline SV *to_sv ( signed short v) { return newSViv (v); }
		425	inline SV *to_sv (unsigned short v) { return newSVuv (v); }
		426	inline SV *to_sv ( signed int v) { return newSViv (v); }
		427	inline SV *to_sv (unsigned int v) { return newSVuv (v); }
		428	inline SV *to_sv ( signed long v) { return newSViv (v); }
		429	inline SV *to_sv (unsigned long v) { return newSVuv (v); }
		430	inline SV *to_sv ( signed long long v) { return newSVval64 (v); }
		431	inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }
		432	inline SV *to_sv (float v) { return newSVnv (v); }
		433	inline SV *to_sv (double v) { return newSVnv (v); }
		434	inline SV *to_sv (client * v) { return newSVattachable (v, stash_cf_client_wrap); }
		435	inline SV *to_sv (player * v) { return newSVattachable (v, stash_cf_player_wrap); }
		436	inline SV *to_sv (object * v) { return newSVattachable (v, v && v->type == PLAYER ? stash_cf_object_player_wrap : stash_cf_object_wrap); }
		437	inline SV *to_sv (maptile * v) { return newSVattachable (v, stash_cf_map_wrap); }
		438	inline SV *to_sv (archetype * v) { return newSVattachable (v, stash_cf_arch_wrap); }
		439	inline SV *to_sv (region * v) { return newSVattachable (v, stash_cf_region_wrap); }
		440	inline SV *to_sv (partylist * v) { return newSVptr (v, stash_cf_party_wrap); }
		441	inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }
		442
		443	inline SV *to_sv (object & v) { return to_sv (&v); }
		444	inline SV *to_sv (living & v) { return to_sv (&v); }
		445
		446	inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); }
		447	inline SV *to_sv (const treasurelist *v) { return to_sv (v->name); }
		448
		449	inline SV *to_sv (UUID v)
		450	{
		451	char buf[128];
		452	snprintf (buf, 128, "<1.%" PRIx64 ">", v.seq);
		453	return newSVpv (buf, 0);
		454	}
		455
		456	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPVutf8_nolen (sv) : 0; }
		457	inline void sv_to (SV *sv, char * &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }
		458	inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }
		459	inline void sv_to (SV *sv, signed char &v) { v = SvIV (sv); }
		460	inline void sv_to (SV *sv, unsigned char &v) { v = SvIV (sv); }
		461	inline void sv_to (SV *sv, signed short &v) { v = SvIV (sv); }
		462	inline void sv_to (SV *sv, unsigned short &v) { v = SvIV (sv); }
		463	inline void sv_to (SV *sv, signed int &v) { v = SvIV (sv); }
		464	inline void sv_to (SV *sv, unsigned int &v) { v = SvUV (sv); }
		465	inline void sv_to (SV *sv, signed long &v) { v = SvIV (sv); }
		466	inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }
		467	inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }
		468	inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }
		469	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
		470	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }
		471	inline void sv_to (SV *sv, client * &v) { v = (client *)(attachable *)SvPTR_ornull (sv, "cf::client"); }
		472	inline void sv_to (SV *sv, player * &v) { v = (player *)(attachable *)SvPTR_ornull (sv, "cf::player"); }
		473	inline void sv_to (SV *sv, object * &v) { v = (object *)(attachable *)SvPTR_ornull (sv, "cf::object"); }
		474	inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)(attachable *)SvPTR_ornull (sv, "cf::arch"); }
		475	inline void sv_to (SV *sv, maptile * &v) { v = (maptile *)(attachable *)SvPTR_ornull (sv, "cf::map"); }
		476	inline void sv_to (SV *sv, region * &v) { v = (region *)(attachable *)SvPTR_ornull (sv, "cf::region"); }
		477	inline void sv_to (SV *sv, attachable * &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); }
		478	inline void sv_to (SV *sv, partylist * &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }
		479	inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }
		480	inline void sv_to (SV *sv, object_freezer * &v) { v = (object_freezer *)SvPTR_ornull (sv, "cf::object::freezer"); }
		481	inline void sv_to (SV *sv, object_thawer * &v) { v = (object_thawer *)SvPTR_ornull (sv, "cf::object::thawer" ); }
		482
		483	//inline void sv_to (SV *sv, faceinfo * &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }
		484	inline void sv_to (SV *sv, treasurelist * &v) { v = treasurelist::find (SvPV_nolen (sv)); }
		485
		486	template<class T>
		487	inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }
		488
		489	template<int N>
		490	inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); }
		491
		492	inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); }
		493	inline void sv_to (SV *sv, petmode_t &v) { v = (petmode_t) SvIV (sv); }
		494	inline void sv_to (SV *sv, usekeytype &v) { v = (usekeytype) SvIV (sv); }
		495	inline void sv_to (SV *sv, unapplymode &v) { v = (unapplymode) SvIV (sv); }
		496
		497	inline void sv_to (SV *sv, std::string &v)
		498	{
		499	STRLEN len;
		500	char *data = SvPVbyte (sv, len);
		501	v.assign (data, len);
		502	}
		503
		504	inline void sv_to (SV *sv, UUID &v)
		505	{
		506	unsigned int version;
		507
		508	if (2 != sscanf (SvPV_nolen (sv), "<%d.%" SCNx64 ">", &version, &v.seq) || 1 != version)
		509	croak ("unparsable uuid: %s", SvPV_nolen (sv));
		510	}
		511
		512	inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }
		513
220	static SV *	514	static SV *
221	newSVcfapi (int type, ...)	515	newSVdt_va (va_list &ap, data_type type)
222	{	516	{
223	SV *sv;	517	SV *sv;
224
225	va_list args;
226	va_start (args, type);
227		518
228	switch (type)	519	switch (type)
229	{	520	{
230	#if 0
231	case CFAPI_INT16:	521	case DT_INT:
232	sv = newSViv (*va_arg (args, sint16_t *));	522	sv = newSViv (va_arg (ap, int));
233	break;	523	break;
234	#endif
235		524
236	case CFAPI_INT:	525	case DT_INT64:
237	sv = newSViv (*va_arg (args, int *));	526	sv = newSVval64 ((val64)va_arg (ap, sint64));
238	break;	527	break;
239		528
240	case CFAPI_LONG:	529	case DT_DOUBLE:
241	sv = newSVval64 ((val64)*va_arg (args, sint64 *));	530	sv = newSVnv (va_arg (ap, double));
242	break;	531	break;
243		532
244	case CFAPI_DOUBLE:
245	sv = newSVnv (*va_arg (args, double *));
246	break;
247
248	case CFAPI_STRING:	533	case DT_STRING:
249	{	534	{
250	char *str = va_arg (args, char *);	535	char *str = (char *)va_arg (ap, const char *);
251	sv = str ? newSVpv (str, 0) : &PL_sv_undef;	536	sv = str ? newSVpv (str, 0) : newSV (0);
252	}	537	}
253	break;	538	break;
254		539
255	case CFAPI_POBJECT:	540	case DT_DATA:
256	{	541	{
257	object *obj = va_arg (args, object *);	542	char *str = (char *)va_arg (ap, const void *);
258		543	int len = va_arg (ap, int);
259	if (!obj)	544	sv = str ? newSVpv (str, len) : newSV (0);
260	sv = &PL_sv_undef;
261	else
262	switch (obj->type)
263	{
264	case MAP:
265	sv = newSVptr_cached (obj, "cf::object::map::wrap");
266	break;
267
268	case PLAYER:
269	sv = newSVptr_cached (obj, "cf::object::player::wrap");
270	break;
271
272	default:
273	sv = newSVptr_cached (obj, "cf::object::wrap");
274	break;
275	}
276	}	545	}
277	break;	546	break;
278		547
279	case CFAPI_PMAP:	548	case DT_OBJECT:
280	sv = newSVptr (va_arg (args, mapstruct *), "cf::map::wrap");	549	sv = to_sv (va_arg (ap, object *));
281	break;	550	break;
282		551
283	case CFAPI_PPLAYER:	552	case DT_MAP:
284	sv = newSVptr (va_arg (args, player *), "cf::player::wrap");	553	// va_arg (object *) when void * is passed is an XSI extension
		554	sv = to_sv (va_arg (ap, maptile *));
285	break;	555	break;
286		556
287	case CFAPI_PARCH:	557	case DT_CLIENT:
288	sv = newSVptr (va_arg (args, archetype *), "cf::arch::wrap");	558	sv = to_sv (va_arg (ap, client *));
289	break;	559	break;
290		560
291	case CFAPI_PPARTY:	561	case DT_PLAYER:
292	sv = newSVptr (va_arg (args, partylist *), "cf::party::wrap");	562	sv = to_sv (va_arg (ap, player *));
293	break;	563	break;
294		564
295	case CFAPI_PREGION:	565	case DT_ARCH:
296	sv = newSVptr (va_arg (args, region *), "cf::region::wrap");	566	sv = to_sv (va_arg (ap, archetype *));
297	break;	567	break;
298		568
		569	case DT_PARTY:
		570	sv = to_sv (va_arg (ap, partylist *));
		571	break;
		572
		573	case DT_REGION:
		574	sv = to_sv (va_arg (ap, region *));
		575	break;
		576
299	default:	577	default:
300	assert (("unhandled type in newSVcfapi", 0));	578	assert (("unhandled type in newSVdt_va", 0));
301	}	579	}
302		580
303	va_end (args);
304
305	return sv;	581	return sv;
306	}	582	}
307		583
		584	static SV *
		585	newSVdt (data_type type, ...)
		586	{
		587	va_list ap;
		588
		589	va_start (ap, type);
		590	SV *sv = newSVdt_va (ap, type);
		591	va_end (ap);
		592
		593	return sv;
		594	}
		595
		596	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		597
		598	SV *
		599	registry (attachable *ext)
		600	{
		601	if (!ext->cb)
		602	ext->cb = newAV ();
		603
		604	return newRV_inc ((SV *)ext->cb);
		605	}
		606
308	/////////////////////////////////////////////////////////////////////////////	607	/////////////////////////////////////////////////////////////////////////////
309		608
310	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)	609	void
		610	cfperl_init ()
311	{	611	{
312	gethook = gethooksptr;	612	extern char **environ;
313	printf (PLUGIN_VERSION " init\n");
314		613
315	return 0;	614	PERL_SYS_INIT3 (&settings.argc, &settings.argv, &environ);
316	}	615	perl = perl_alloc ();
		616	perl_construct (perl);
317		617
318	static CommArray_s rtn_cmd;	618	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
319		619
320	static int	620	const char *argv[] = {
321	runPluginCommand (object *obj, char *params)	621	settings.argv [0],
		622	"-e"
		623	"use EV; use Coro;" // required for bootstrap
		624	"cf->bootstrap;" // required for datadir :*>
		625	"unshift @INC, cf::datadir ();"
		626	"require cf;"
		627	};
		628
		629	if (perl_parse (perl, xs_init, 2, (char **)argv, environ)
		630	|| perl_run (perl))
		631	{
		632	printf ("unable to initialize perl-interpreter, aborting.\n");
		633	exit (EXIT_FAILURE);
		634	}
		635
		636	{
		637	dSP;
		638
		639	PUSHMARK (SP);
		640	PUTBACK;
		641	call_pv ("cf::init", G_DISCARD | G_VOID);
		642	}
		643	}
		644
		645	void cfperl_main ()
322	{	646	{
323	dSP;	647	dSP;
324		648
325	ENTER;
326	SAVETMPS;
327
328	PUSHMARK (SP);	649	PUSHMARK (SP);
329
330	EXTEND (SP, 3);
331	PUSHs (sv_2mortal (newSVpv (rtn_cmd.name, 0)));
332	PUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, obj)));
333
334	if (params)
335	PUSHs (sv_2mortal (newSVpv (params, 0)));
336
337	PUTBACK;	650	PUTBACK;
338	int count = call_pv ("cf::inject_command", G_SCALAR | G_EVAL);	651	call_pv ("cf::main", G_DISCARD | G_VOID);
339	SPAGAIN;
340
341	if (SvTRUE (ERRSV))
342	LOG (llevError, "command '%s' callback evaluation error: %s", rtn_cmd.name, SvPV_nolen (ERRSV));
343
344	int returnvalue = count > 0 ? POPi : -1;
345
346	PUTBACK;
347	FREETMPS;
348	LEAVE;
349
350	return returnvalue;
351	}	652	}
352		653
353	extern "C" void *cfperl_getPluginProperty (int *type, ...)	654	void
		655	attachable::instantiate ()
354	{	656	{
355	va_list args;	657	if (attach)
356	char *propname;
357	int i;
358	va_start (args, type);
359	propname = va_arg (args, char *);
360	//printf ("Property name: %s\n", propname);
361
362	if (!strcmp (propname, "command?"))
363	{	658	{
364	if (!perl)	659	INVOKE_ATTACHABLE (INSTANTIATE, this, ARG_STRING (attach));
365	return NULL;	660	attach = 0;
		661	}
		662	}
366		663
367	const char *cmdname = va_arg (args, const char *);	664	void
368	HV *hv = get_hv ("cf::COMMAND", 1);	665	attachable::reattach ()
369	SV **svp = hv_fetch (hv, cmdname, strlen (cmdname) + 1, 0);	666	{
		667	optimise ();
		668	//TODO: check for _attachment's, very important for restarts
		669	INVOKE_ATTACHABLE (REATTACH, this);
		670	}
370		671
371	va_end (args);	672	static event_klass klass_of[NUM_EVENT_TYPES] = {
		673	# define def(type,name) KLASS_ ## type,
		674	# include "eventinc.h"
		675	# undef def
		676	};
372		677
373	if (svp)	678	#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)
		679
		680	static void
		681	gather_callbacks (AV *&callbacks, AV *registry, event_type event)
		682	{
		683	// event must be in array
		684	if (event >= 0 && event <= AvFILLp (registry))
		685	{
		686	SV *cbs_ = AvARRAY (registry)[event];
		687
		688	// element must be list of callback entries
		689	if (cbs_ && SvROK (cbs_) && SvTYPE (SvRV (cbs_)) == SVt_PVAV)
374	{	690	{
375	// this is totaly broken, should stash it into %COMMAND	691	AV *cbs = (AV *)SvRV (cbs_);
376	rtn_cmd.name = cmdname;
377	rtn_cmd.time = SvNV (*svp);
378	rtn_cmd.func = runPluginCommand;
379		692
380	return &rtn_cmd;	693	// no callback entries, no callbacks to call
		694	if (AvFILLp (cbs) >= 0)
		695	{
		696	if (!callbacks)
		697	{
		698	callbacks = newAV ();
		699	av_extend (callbacks, 16);
		700	}
		701
		702	// never use SvREFCNT_inc to copy values, but its ok here :)
		703	for (int i = 0; i <= AvFILLp (cbs); ++i)
		704	av_push (callbacks, SvREFCNT_inc (AvARRAY (cbs)[i]));
		705	}
381	}	706	}
382	}	707	}
383	else if (!strcmp (propname, "Identification"))	708	}
		709
		710	void
		711	attachable::gather_callbacks (AV *&callbacks, event_type event) const
		712	{
		713	::gather_callbacks (callbacks, cb_attachable, event);
		714
		715	if (cb)
		716	::gather_callbacks (callbacks, cb, event);
		717	}
		718
		719	void
		720	global::gather_callbacks (AV *&callbacks, event_type event) const
		721	{
		722	::gather_callbacks (callbacks, cb_global, event);
		723	}
		724
		725	void
		726	object::gather_callbacks (AV *&callbacks, event_type event) const
		727	{
		728	if (subtype && type + subtype * NUM_TYPES <= AvFILLp (cb_type))
384	{	729	{
385	va_end (args);	730	SV *registry = AvARRAY (cb_type)[type + subtype * NUM_TYPES];
386	return (void*) PLUGIN_NAME;	731
		732	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
		733	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);
387	}	734	}
388	else if (!strcmp (propname, "FullName"))	735
		736	if (type <= AvFILLp (cb_type))
389	{	737	{
390	va_end (args);	738	SV *registry = AvARRAY (cb_type)[type];
391	return (void*) PLUGIN_VERSION;	739
		740	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
		741	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);
392	}	742	}
		743
		744	attachable::gather_callbacks (callbacks, event);
		745	::gather_callbacks (callbacks, cb_object, event);
		746	}
		747
		748	void
		749	archetype::gather_callbacks (AV *&callbacks, event_type event) const
		750	{
		751	attachable::gather_callbacks (callbacks, event);
		752	//TODO//::gather_callbacks (callbacks, cb_archetype, event);
		753	}
		754
		755	void
		756	client::gather_callbacks (AV *&callbacks, event_type event) const
		757	{
		758	attachable::gather_callbacks (callbacks, event);
		759	::gather_callbacks (callbacks, cb_client, event);
		760	}
		761
		762	void
		763	player::gather_callbacks (AV *&callbacks, event_type event) const
		764	{
		765	attachable::gather_callbacks (callbacks, event);
		766	::gather_callbacks (callbacks, cb_player, event);
		767	}
		768
		769	void
		770	maptile::gather_callbacks (AV *&callbacks, event_type event) const
		771	{
		772	attachable::gather_callbacks (callbacks, event);
		773	::gather_callbacks (callbacks, cb_map, event);
		774	}
		775
		776	void
		777	_recalc_want (bitset<NUM_EVENT_TYPES> &set, AV *registry)
		778	{
		779	for (int event = 0; event <= AvFILLp (registry); ++event)
		780	{
		781	SV *cbs_ = AvARRAY (registry)[event];
		782
		783	// element must be list of callback entries
		784	if (cbs_ && SvROK (cbs_) && SvTYPE (SvRV (cbs_)) == SVt_PVAV)
		785	{
		786	AV *cbs = (AV *)SvRV (cbs_);
		787
		788	// no callback entries, no callbacks to call
		789	if (AvFILLp (cbs) >= 0)
		790	set.set (event);
		791	}
		792	}
		793	}
		794
		795	// very slow and inefficient way to recalculate the global want bitsets
		796	void
		797	_recalc_want ()
		798	{
		799	ev_want_event.reset ();
		800
		801	_recalc_want (ev_want_event, cb_global);
		802	_recalc_want (ev_want_event, cb_attachable);
		803	_recalc_want (ev_want_event, cb_object);
		804	_recalc_want (ev_want_event, cb_client);
		805	_recalc_want (ev_want_event, cb_player);
		806	_recalc_want (ev_want_event, cb_map);
		807
		808	ev_want_type.reset ();
		809
		810	for (int type = 0; type <= AvFILLp (cb_type); ++type)
		811	{
		812	SV *cbs_ = AvARRAY (cb_type)[type];
		813
		814	// element must be list of callback entries
		815	if (cbs_ && SvROK (cbs_) && SvTYPE (SvRV (cbs_)) == SVt_PVAV)
		816	{
		817	AV *cbs = (AV *)SvRV (cbs_);
		818
		819	// no callback entries, no callbacks to call
		820	if (AvFILLp (cbs) >= 0)
		821	ev_want_type.set (type % NUM_TYPES);
		822	}
		823	}
		824	}
		825
		826	bool
		827	attachable::invoke (event_type event, ...)
		828	{
		829	data_type dt;
		830
		831	// callback call ordering should be:
		832	// 1. per-object callback
		833	// 2. per-class object
		834	// 3. per-type callback
		835	// 4. global callbacks
		836
		837	AV *callbacks = 0;
		838	gather_callbacks (callbacks, event);
		839
		840	// short-circuit processing if no callbacks found/defined
		841	if (!callbacks)
		842	return 0;
		843
		844	va_list ap;
		845	va_start (ap, event);
		846
		847	CALL_BEGIN (3);
		848	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays
		849	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));
		850
		851	//TODO: unhack
		852	if (object *op = is_a<object>(this)) CALL_ARG_SV (newSVdt (DT_OBJECT, op));
		853	else if (player *pl = is_a<player>(this)) CALL_ARG_SV (newSVdt (DT_PLAYER, pl));
		854	else if (client *ns = is_a<client>(this)) CALL_ARG_SV (newSVdt (DT_CLIENT, ns));
		855	else if (maptile *m = is_a<maptile>(this)) CALL_ARG_SV (newSVdt (DT_MAP, m));
		856	else if (global *gl = is_a<global>(this)) /*nop*/;
393	else	857	else
394	va_end (args);	858	abort (); //TODO
395		859
396	return NULL;	860	for (;;)
397	}
398
399	extern "C" int cfperl_postInitPlugin ()
400	{
401	int hooktype = 1;
402	int rtype = 0;
403
404	printf (PLUGIN_VERSION " post init\n");
405
406	registerGlobalEvent = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_system_register_global_event");
407	unregisterGlobalEvent = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_system_unregister_global_event");
408	systemDirectory = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_system_directory");
409	object_set_property = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_object_set_property");
410	map_get_map = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_map_get_map");
411	object_insert = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_object_insert");
412
413	cf_init_plugin (gethook);
414
415	/* Pick the global events you want to monitor from this plugin */
416	registerGlobalEvent (NULL, EVENT_BORN, PLUGIN_NAME, globalEventListener);
417	registerGlobalEvent (NULL, EVENT_CLOCK, PLUGIN_NAME, globalEventListener);
418	//registerGlobalEvent (NULL, EVENT_CRASH, PLUGIN_NAME, globalEventListener);
419	registerGlobalEvent (NULL, EVENT_FIND_UNARMED_SKILL, PLUGIN_NAME, globalEventListener);
420	registerGlobalEvent (NULL, EVENT_PLAYER_USE_SKILL, PLUGIN_NAME, globalEventListener);
421	registerGlobalEvent (NULL, EVENT_CAST_SPELL, PLUGIN_NAME, globalEventListener);
422	registerGlobalEvent (NULL, EVENT_MONSTER_USE_SKILL, PLUGIN_NAME, globalEventListener);
423	registerGlobalEvent (NULL, EVENT_PLAYER_DEATH, PLUGIN_NAME, globalEventListener);
424	registerGlobalEvent (NULL, EVENT_GKILL, PLUGIN_NAME, globalEventListener);
425	registerGlobalEvent (NULL, EVENT_LOGIN, PLUGIN_NAME, globalEventListener);
426	registerGlobalEvent (NULL, EVENT_LOGOUT, PLUGIN_NAME, globalEventListener);
427	registerGlobalEvent (NULL, EVENT_MAPENTER, PLUGIN_NAME, globalEventListener);
428	registerGlobalEvent (NULL, EVENT_MAPLEAVE, PLUGIN_NAME, globalEventListener);
429	registerGlobalEvent (NULL, EVENT_MAPRESET, PLUGIN_NAME, globalEventListener);
430	registerGlobalEvent (NULL, EVENT_MAPLOAD, PLUGIN_NAME, globalEventListener);
431	registerGlobalEvent (NULL, EVENT_MAPOUT, PLUGIN_NAME, globalEventListener);
432	registerGlobalEvent (NULL, EVENT_MAPIN, PLUGIN_NAME, globalEventListener);
433	registerGlobalEvent (NULL, EVENT_MAPCLEAN, PLUGIN_NAME, globalEventListener);
434	registerGlobalEvent (NULL, EVENT_REMOVE, PLUGIN_NAME, globalEventListener);
435	registerGlobalEvent (NULL, EVENT_SHOUT, PLUGIN_NAME, globalEventListener);
436	registerGlobalEvent (NULL, EVENT_TELL, PLUGIN_NAME, globalEventListener);
437	registerGlobalEvent (NULL, EVENT_MUZZLE, PLUGIN_NAME, globalEventListener);
438	registerGlobalEvent (NULL, EVENT_KICK, PLUGIN_NAME, globalEventListener);
439	registerGlobalEvent (NULL, EVENT_FREE_OB, PLUGIN_NAME, globalEventListener);
440	registerGlobalEvent (NULL, EVENT_PLAYER_LOAD, PLUGIN_NAME, globalEventListener);
441	registerGlobalEvent (NULL, EVENT_PLAYER_SAVE, PLUGIN_NAME, globalEventListener);
442	registerGlobalEvent (NULL, EVENT_EXTCMD, PLUGIN_NAME, globalEventListener);
443
444	char *argv[] = {
445	"",
446	"-e"
447	"BEGIN {"
448	" cf->bootstrap;"
449	" unshift @INC, cf::datadir ();"
450	"}"
451	""
452	"use cf;"
453	};
454
455	perl = perl_alloc ();
456	perl_construct (perl);
457
458	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
459
460	if (perl_parse (perl, xs_init, 2, argv, (char **)NULL) || perl_run (perl))
461	{	861	{
462	printf ("unable to initialize perl-interpreter, continuing without.\n");	862	dt = (data_type) va_arg (ap, int);
463		863
464	perl_destruct (perl);	864	if (dt == DT_END)
465	perl_free (perl);	865	break;
466	perl = 0;	866	else if (dt == DT_AV)
		867	{
		868	AV *av = va_arg (ap, AV *);
		869
		870	for (int i = 0; i <= av_len (av); ++i)
		871	XPUSHs (*av_fetch (av, i, 1));
		872	}
		873	else
		874	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
467	}	875	}
		876
		877	va_end (ap);
		878
		879	CALL_CALL ("cf::do_invoke", G_SCALAR);
		880	count = count > 0 ? POPi : 0;
		881
		882	CALL_END;
		883
		884	return count;
		885	}
		886
		887	SV *
		888	cfperl_result (int idx)
		889	{
		890	AV *av = get_av ("cf::INVOKE_RESULTS", 0);
		891	if (!av)
		892	return &PL_sv_undef;
		893
		894	SV **sv = av_fetch (av, idx, 0);
		895	if (!sv)
		896	return &PL_sv_undef;
		897
		898	return *sv;
		899	}
		900
		901	int
		902	cfperl_result_INT (int idx)
		903	{
		904	return SvIV (cfperl_result (idx));
		905	}
		906
		907	double
		908	cfperl_result_DOUBLE (int idx)
		909	{
		910	return SvNV (cfperl_result (idx));
		911	}
		912
		913	/////////////////////////////////////////////////////////////////////////////
		914	// various c++ => perl glue functions
		915
		916	void cfperl_tick ()
		917	{
		918	tick_pending = 1;
		919
		920	if (tick_inhibit)
		921	return;
		922
		923	tick_pending = 0;
		924
		925	dSP;
		926
		927	PUSHMARK (SP);
		928	PUTBACK;
		929	call_pv ("cf::tick", G_DISCARD | G_VOID);
		930
		931	SvNV_set (sv_next_tick, get_next_tick ()); SvNOK_only (sv_next_tick);
		932	}
		933
		934	void
		935	cfperl_emergency_save ()
		936	{
		937	CALL_BEGIN (0);
		938	CALL_CALL ("cf::emergency_save", G_VOID);
		939	CALL_END;
		940	}
		941
		942	void
		943	cfperl_cleanup (int make_core)
		944	{
		945	CALL_BEGIN (1);
		946	CALL_ARG (make_core);
		947	CALL_CALL ("cf::post_cleanup", G_VOID);
		948	CALL_END;
		949	}
		950
		951	void
		952	cfperl_make_book (object *book, int level)
		953	{
		954	CALL_BEGIN (2);
		955	CALL_ARG (book);
		956	CALL_ARG (level);
		957	CALL_CALL ("ext::books::make_book", G_VOID);
		958	CALL_END;
		959	}
		960
		961	void
		962	cfperl_send_msg (client *ns, int color, const char *type, const char *msg)
		963	{
		964	CALL_BEGIN (4);
		965	CALL_ARG (ns);
		966	CALL_ARG (type);
		967	CALL_ARG_SV (newSVpv_utf8 (msg));
		968	CALL_ARG (color);
		969	CALL_CALL ("cf::client::send_msg", G_VOID);
		970	CALL_END;
		971	}
		972
		973	int
		974	cfperl_can_merge (object *ob1, object *ob2)
		975	{
		976	int can;
		977
		978	CALL_BEGIN (2);
		979	CALL_ARG (ob1);
		980	CALL_ARG (ob2);
		981	CALL_CALL ("cf::_can_merge", G_SCALAR);
		982	can = count && SvTRUE (TOPs);
		983	CALL_END;
		984
		985	return can;
		986	}
		987
		988	player *
		989	player::find (const char *name)
		990	{
		991	CALL_BEGIN (1);
		992	CALL_ARG (name);
		993	CALL_CALL ("cf::player::find", G_SCALAR);
		994
		995	player *retval;
		996
		997	if (count)
		998	sv_to (POPs, retval);
468	else	999	else
		1000	retval = 0;
		1001
		1002	CALL_END;
		1003
		1004	return retval;
		1005	}
		1006
		1007	maptile *
		1008	maptile::find_sync (const char *path, maptile *origin)
		1009	{
		1010	CALL_BEGIN (2);
		1011	CALL_ARG (path);
		1012	CALL_ARG (origin);
		1013	CALL_CALL ("cf::map::find_sync", G_SCALAR);
		1014
		1015	maptile *retval;
		1016
		1017	if (count)
		1018	sv_to (POPs, retval);
		1019	else
		1020	retval = 0;
		1021
		1022	CALL_END;
		1023
		1024	return retval;
		1025	}
		1026
		1027	maptile *
		1028	maptile::find_async (const char *path, maptile *origin, bool load)
		1029	{
		1030	CALL_BEGIN (3);
		1031	CALL_ARG (path);
		1032	CALL_ARG (origin);
		1033	CALL_ARG (load);
		1034	CALL_CALL ("cf::map::find_async", G_SCALAR);
		1035
		1036	maptile *retval;
		1037
		1038	if (count)
		1039	sv_to (POPs, retval);
		1040	else
		1041	retval = 0;
		1042
		1043	CALL_END;
		1044
		1045	return retval;
		1046	}
		1047
		1048	void
		1049	maptile::do_load_sync ()
		1050	{
		1051	CALL_BEGIN (1);
		1052	CALL_ARG (this);
		1053	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);
		1054	CALL_END;
		1055	}
		1056
		1057	void
		1058	maptile::change_all_map_light (int change)
		1059	{
		1060	CALL_BEGIN (1);
		1061	CALL_ARG (change);
		1062	CALL_CALL ("cf::map::change_all_map_light", G_VOID);
		1063	CALL_END;
		1064	}
		1065
		1066	void
		1067	object::enter_exit (object *exit)
		1068	{
		1069	if (type != PLAYER)
		1070	return;
		1071
		1072	CALL_BEGIN (2);
		1073	CALL_ARG (this);
		1074	CALL_ARG (exit);
		1075	CALL_CALL ("cf::object::player::enter_exit", G_VOID);
		1076	CALL_END;
		1077	}
		1078
		1079	const char *
		1080	object::ref () const
		1081	{
		1082	if (type == PLAYER)
		1083	return format ("player/<1.%llx>/%s", (unsigned long long)uuid.seq, &name);
		1084	else
		1085	return 0;
		1086	}
		1087
		1088	object *
		1089	object::deref (const char *ref)
		1090	{
		1091	object *retval = 0;
		1092
		1093	if (ref)
469	{	1094	{
470	obj_cache = newHV ();	1095	CALL_BEGIN (1);
		1096	CALL_ARG (ref);
		1097	CALL_CALL ("cf::object::deref", G_SCALAR);
		1098
		1099	if (count)
		1100	sv_to (POPs, retval);
		1101
		1102	CALL_END;
471	}	1103	}
472		1104
473	return 0;	1105	return retval;
474	}	1106	}
475		1107
476	static void *	1108	void
477	globalEventListener (int *type, ...)	1109	log_backtrace (const char *msg)
478	{	1110	{
479	va_list args;	1111	#if HAVE_BACKTRACE
480	static int rv;	1112	void *addr [20];
481	int event_code;	1113	int size = backtrace (addr, 20);
482		1114
483	if (!perl)	1115	CALL_BEGIN (size);
484	return NULL;	1116	CALL_ARG (msg);
		1117	for (int i = 0; i < size; ++i)
		1118	CALL_ARG ((IV)addr [i]);
		1119	CALL_CALL ("cf::_log_backtrace", G_VOID);
		1120	CALL_END;
		1121	#endif
		1122	}
485		1123
486	va_start (args, type);	1124	/////////////////////////////////////////////////////////////////////////////
487	event_code = va_arg (args, int);
488		1125
489	if (event_code == EVENT_FREE_OB)	1126	struct EVAPI *evapi::GEVAPI;
		1127	struct CoroAPI *coroapi::GCoroAPI;
		1128
		1129	void coroapi::do_cede_to_tick ()
		1130	{
		1131	cede_pending = 0;
		1132	cede ();
		1133	}
		1134
		1135	void
		1136	coroapi::wait_for_tick ()
		1137	{
		1138	CALL_BEGIN (0);
		1139	CALL_CALL ("cf::wait_for_tick", G_DISCARD);
		1140	CALL_END;
		1141	}
		1142
		1143	void
		1144	coroapi::wait_for_tick_begin ()
		1145	{
		1146	CALL_BEGIN (0);
		1147	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);
		1148	CALL_END;
		1149	}
		1150
		1151	void
		1152	iow::poll (int events)
		1153	{
		1154	if (events != this->events)
490	{	1155	{
491	player *pl;	1156	int active = ev_is_active ((ev_io *)this);
492	object *op;	1157	if (active) stop ();
493	SV *sv;	1158	ev_io_set ((ev_io *)this, fd, events);
494		1159	if (active) start ();
495	op = va_arg (args, object *);
496	sv = hv_delete (obj_cache, (char *)&op, sizeof (void *), 0);
497
498	if (sv)
499	clearSVptr (sv);
500
501	rv = 0;
502	}	1160	}
503	else if (event_code == EVENT_CLOCK)
504	{
505	dSP;
506	int i, count;
507
508	clean_obj_cache ();
509
510	ENTER;
511	SAVETMPS;
512
513	// service up to 8 events per tick better would be
514	// to check for elapsed time and stop processing after
515	// 0.25 * server_tick or so
516	for (i = 9; --i; )
517	{
518	PUSHMARK (SP);
519	XPUSHs (sv_2mortal (newSViv (0)));
520	PUTBACK;
521	count = call_pv ("Event::one_event", G_SCALAR | G_EVAL);
522	SPAGAIN;
523
524	if (!count || !POPi)
525	break;
526	}
527
528	FREETMPS;
529	LEAVE;
530	}
531	else
532	{
533	dSP;
534
535	ENTER;
536	SAVETMPS;
537
538	PUSHMARK (SP);
539
540	EXTEND (SP, 10);
541	PUSHs (sv_2mortal (newSViv (event_code)));
542
543	switch (event_code)
544	{
545	case EVENT_CRASH:
546	break;
547
548	case EVENT_PLAYER_LOAD:
549	case EVENT_PLAYER_SAVE:
550	PUSH_OB;
551	PUSH_PV;
552	break;
553
554	case EVENT_MAPLOAD:
555	case EVENT_MAPOUT:
556	case EVENT_MAPIN:
557	case EVENT_MAPCLEAN:
558	case EVENT_MAPRESET:
559	PUSH_MAP;
560	break;
561
562	case EVENT_MAPENTER:
563	case EVENT_MAPLEAVE:
564	case EVENT_BORN:
565	case EVENT_REMOVE:
566	case EVENT_PLAYER_DEATH:
567	PUSH_OB;
568	break;
569
570	case EVENT_GKILL:
571	PUSH_OB;
572	PUSH_OB;
573	break;
574
575	case EVENT_LOGIN:
576	case EVENT_LOGOUT:
577	PUSH_PL;
578	PUSH_PV;
579	break;
580
581	case EVENT_SHOUT:
582	case EVENT_MUZZLE:
583	case EVENT_KICK:
584	PUSH_OB;
585	PUSH_PV;
586	break;
587
588	case EVENT_FIND_UNARMED_SKILL:
589	PUSH_OB;
590	break;
591
592	case EVENT_PLAYER_USE_SKILL:
593	case EVENT_MONSTER_USE_SKILL:
594	case EVENT_CAST_SPELL:
595	PUSH_OB;
596	PUSH_OB;
597	PUSH_OB;
598	PUSH_IV;
599	PUSH_PV;
600	break;
601
602	case EVENT_EXTCMD:
603	PUSH_PL;
604	{
605	char *buf = va_arg (args, char *);
606	int len = va_arg (args, int);
607	PUSHs (sv_2mortal (newSVpvn (buf, len)));
608	}
609	break;
610
611	case EVENT_TELL:
612	break;
613	}
614
615	va_end (args);
616
617	PUTBACK;
618	int count = call_pv ("cf::inject_global_event", G_SCALAR | G_EVAL);
619	SPAGAIN;
620
621	if (SvTRUE (ERRSV))
622	LOG (llevError, "global event '%d' callback evaluation error: %s", event_code, SvPV_nolen (ERRSV));
623
624	rv = count > 0 ? POPi : 0;
625
626	PUTBACK;
627	FREETMPS;
628	LEAVE;
629	}
630
631	return &rv;
632	}	1161	}
633		1162
634	extern "C" void *cfperl_eventListener (int *type, ...)	1163	void
		1164	_connect_to_perl ()
635	{	1165	{
636	static int rv;	1166	stash_cf = gv_stashpv ("cf", 1);
637	va_list args;
638	int event_code;
639	object *who, *activator, *third, *event;
640	char *message, *extension, *options;
641		1167
642	if (!perl)	1168	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);
643	return NULL;	1169	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);
		1170	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);
		1171	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);
		1172	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);
		1173	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
		1174	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
		1175	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
		1176	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
644		1177
645	va_start (args, type);	1178	sv_now = get_sv ("cf::NOW" , 1); SvUPGRADE (sv_now , SVt_NV);
646	who = va_arg (args, object *);	1179	sv_runtime = get_sv ("cf::RUNTIME" , 1); SvUPGRADE (sv_runtime , SVt_NV);
647	event_code = va_arg (args, int);	1180	sv_tick_start = get_sv ("cf::TICK_START", 1); SvUPGRADE (sv_tick_start, SVt_NV);
648	activator = va_arg (args, object *);	1181	sv_next_tick = get_sv ("cf::NEXT_TICK" , 1); SvUPGRADE (sv_next_tick , SVt_NV);
649	third = va_arg (args, object *);
650	message = va_arg (args, char *);
651	va_arg (args, int); // fix yourself
652	extension = va_arg (args, char *);
653	options = va_arg (args, char *);
654	event = va_arg (args, object *);
655	va_end (args);
656		1182
657	{	1183	cb_global = get_av ("cf::CB_GLOBAL", 1);
658	dSP;	1184	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
659		1185	cb_object = get_av ("cf::CB_OBJECT", 1);
660	ENTER;	1186	cb_player = get_av ("cf::CB_PLAYER", 1);
661	SAVETMPS;	1187	cb_client = get_av ("cf::CB_CLIENT", 1);
662		1188	cb_type = get_av ("cf::CB_TYPE" , 1);
663	PUSHMARK (SP);	1189	cb_map = get_av ("cf::CB_MAP" , 1);
664	EXTEND (SP, 10);
665
666	PUSHcfapi (STRING, extension);
667	PUSHs (sv_2mortal (newSViv (event_code)));
668
669	PUSHcfapi (POBJECT, event);
670	PUSHcfapi (POBJECT, who);
671
672	switch (event_code)
673	{
674	case EVENT_STOP: // $ob (e.g. arrow)
675	case EVENT_TIME: // $ob
676	case EVENT_TIMER: // $ob
677	break;
678
679	case EVENT_APPLY: // $ob, $who
680	case EVENT_DROP: // $ob, $who
681	case EVENT_CLOSE: // $ob, $who
682	case EVENT_DEATH: // $ob[, $killer]
683	case EVENT_MOVE: // $ob, $enemy
684	case EVENT_THROW: // $ob, $thrower
685	PUSHcfapi (POBJECT, activator);
686	break;
687
688	case EVENT_DROP_ON: // $ob, $who, $what
689	case EVENT_ATTACK: // $ob, $who, $victim (?? please god enlighten me)
690	PUSHcfapi (POBJECT, activator);
691	PUSHcfapi (POBJECT, third);
692	break;
693
694	case EVENT_TRIGGER: // $ob, $originator, [$victim], [$msg]
695	PUSHcfapi (POBJECT, activator);
696	PUSHcfapi (POBJECT, third);
697	PUSHcfapi (POBJECT, message);
698	break;
699
700	case EVENT_SAY: // $ob, $who, $msg
701	PUSHcfapi (POBJECT, activator);
702	PUSHcfapi (STRING, message);
703	break;
704
705	default:
706	LOG (llevError, "perl plugin called for unsupported event type %d", event_code);
707	break;
708	}
709
710	PUTBACK;
711	int count = call_pv ("cf::inject_event", G_SCALAR | G_EVAL);
712	SPAGAIN;
713
714	if (SvTRUE (ERRSV))
715	LOG (llevError, "event '%d' callback evaluation error: %s", event_code, SvPV_nolen (ERRSV));
716
717	rv = count > 0 ? POPi : 0;
718
719	PUTBACK;
720	FREETMPS;
721	LEAVE;
722	}
723
724	return &rv;
725	}
726
727	extern "C" int cfperl_closePlugin ()
728	{
729	printf (PLUGIN_VERSION " closing\n");
730
731	if (perl)
732	{
733	perl_destruct (perl);
734	perl_free (perl);
735	perl = 0;
736	}
737
738	return 0;
739	}	1190	}
740		1191
741	MODULE = cf PACKAGE = cf PREFIX = cf_	1192	MODULE = cf PACKAGE = cf PREFIX = cf_
742		1193
743	BOOT:	1194	BOOT:
744	{	1195	{
745	HV *stash = gv_stashpv ("cf", 1);	1196	I_EV_API (PACKAGE); evapi::GEVAPI = GEVAPI;
		1197	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
		1198
		1199	_connect_to_perl ();
		1200
		1201	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
		1202
		1203	//{
		1204	// require_pv ("Time::HiRes");
		1205	//
		1206	// SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
		1207	// if (!svp) croak ("Time::HiRes is required");
		1208	// if (!SvIOK(*svp)) croak ("Time::NVtime isn’t a function pointer");
		1209	// coroapi::time = INT2PTR (double(*)(), SvIV(*svp));
		1210	//}
746		1211
747	static const struct {	1212	static const struct {
748	const char *name;	1213	const char *name;
749	IV iv;	1214	IV iv;
750	} *civ, const_iv[] = {	1215	} *civ, const_iv[] = {
751	# define const_iv(name) { # name, (IV)name },	1216	# define const_iv(name) { # name, (IV)name },
752	const_iv (llevError)	1217	const_iv (llevError) const_iv (llevInfo) const_iv (llevDebug) const_iv (llevMonster)
753	const_iv (llevInfo)	1218	const_iv (logBacktrace)
754	const_iv (llevDebug)
755	const_iv (llevMonster)
756		1219
757	const_iv (PLAYER)	1220	const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)
758	const_iv (TRANSPORT)	1221
759	const_iv (ROD)	1222	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)
760	const_iv (TREASURE)	1223
761	const_iv (POTION)
762	const_iv (FOOD)
763	const_iv (POISON)
764	const_iv (BOOK)
765	const_iv (CLOCK)
766	const_iv (LIGHTNING)
767	const_iv (ARROW)
768	const_iv (BOW)
769	const_iv (WEAPON)
770	const_iv (ARMOUR)
771	const_iv (PEDESTAL)
772	const_iv (ALTAR)
773	const_iv (LOCKED_DOOR)
774	const_iv (SPECIAL_KEY)
775	const_iv (MAP)
776	const_iv (DOOR)
777	const_iv (KEY)
778	const_iv (TIMED_GATE)
779	const_iv (TRIGGER)
780	const_iv (GRIMREAPER)
781	const_iv (MAGIC_EAR)
782	const_iv (TRIGGER_BUTTON)
783	const_iv (TRIGGER_ALTAR)
784	const_iv (TRIGGER_PEDESTAL)
785	const_iv (SHIELD)
786	const_iv (HELMET)
787	const_iv (HORN)
788	const_iv (MONEY)
789	const_iv (CLASS)
790	const_iv (GRAVESTONE)
791	const_iv (AMULET)
792	const_iv (PLAYERMOVER)
793	const_iv (TELEPORTER)
794	const_iv (CREATOR)
795	const_iv (SKILL)
796	const_iv (EXPERIENCE)
797	const_iv (EARTHWALL)
798	const_iv (GOLEM)
799	const_iv (THROWN_OBJ)
800	const_iv (BLINDNESS)
801	const_iv (GOD)
802	const_iv (DETECTOR)
803	const_iv (TRIGGER_MARKER)
804	const_iv (DEAD_OBJECT)
805	const_iv (DRINK)
806	const_iv (MARKER)
807	const_iv (HOLY_ALTAR)
808	const_iv (PLAYER_CHANGER)
809	const_iv (BATTLEGROUND)
810	const_iv (PEACEMAKER)
811	const_iv (GEM)
812	const_iv (FIREWALL)
813	const_iv (ANVIL)
814	const_iv (CHECK_INV)
815	const_iv (MOOD_FLOOR)
816	const_iv (EXIT)
817	const_iv (ENCOUNTER)
818	const_iv (SHOP_FLOOR)
819	const_iv (SHOP_MAT)
820	const_iv (RING)
821	const_iv (FLOOR)
822	const_iv (FLESH)
823	const_iv (INORGANIC)
824	const_iv (SKILL_TOOL)
825	const_iv (LIGHTER)
826	const_iv (TRAP_PART)
827	const_iv (WALL)
828	const_iv (LIGHT_SOURCE)
829	const_iv (MISC_OBJECT)
830	const_iv (MONSTER)
831	const_iv (SPAWN_GENERATOR)
832	const_iv (LAMP)
833	const_iv (DUPLICATOR)
834	const_iv (TOOL)
835	const_iv (SPELLBOOK)
836	const_iv (BUILDFAC)
837	const_iv (CLOAK)
838	const_iv (SPINNER)
839	const_iv (GATE)	1224	const_iv (MAX_TIME)
840	const_iv (BUTTON)
841	const_iv (CF_HANDLE)
842	const_iv (HOLE)
843	const_iv (TRAPDOOR)
844	const_iv (SIGN)
845	const_iv (BOOTS)
846	const_iv (GLOVES)
847	const_iv (SPELL)
848	const_iv (SPELL_EFFECT)
849	const_iv (CONVERTER)
850	const_iv (BRACERS)
851	const_iv (POISONING)
852	const_iv (SAVEBED)
853	const_iv (POISONCLOUD)
854	const_iv (FIREHOLES)
855	const_iv (WAND)
856	const_iv (SCROLL)
857	const_iv (DIRECTOR)
858	const_iv (GIRDLE)
859	const_iv (FORCE)
860	const_iv (POTION_EFFECT)
861	const_iv (EVENT_CONNECTOR)
862	const_iv (CLOSE_CON)
863	const_iv (CONTAINER)
864	const_iv (ARMOUR_IMPROVER)
865	const_iv (WEAPON_IMPROVER)
866	const_iv (SKILLSCROLL)
867	const_iv (DEEP_SWAMP)
868	const_iv (IDENTIFY_ALTAR)
869	const_iv (MENU)	1225	const_iv (MAXSOCKBUF)
870	const_iv (RUNE)
871	const_iv (TRAP)
872	const_iv (POWER_CRYSTAL)
873	const_iv (CORPSE)
874	const_iv (DISEASE)
875	const_iv (SYMPTOM)
876	const_iv (BUILDER)
877	const_iv (MATERIAL)
878	const_iv (ITEM_TRANSFORMER)
879	const_iv (QUEST)
880		1226
881	const_iv (ST_BD_BUILD)	1227	const_iv (NUM_BODY_LOCATIONS)
882	const_iv (ST_BD_REMOVE)	1228	const_iv (body_range) const_iv (body_shield) const_iv (body_combat)
		1229	const_iv (body_arm) const_iv (body_torso) const_iv (body_head)
		1230	const_iv (body_neck) const_iv (body_skill) const_iv (body_finger)
		1231	const_iv (body_shoulder) const_iv (body_foot) const_iv (body_hand)
		1232	const_iv (body_wrist) const_iv (body_waist)
883		1233
884	const_iv (ST_MAT_FLOOR)	1234	const_iv (PLAYER) const_iv (TRANSPORT) const_iv (ROD) const_iv (TREASURE)
885	const_iv (ST_MAT_WALL)	1235	const_iv (POTION) const_iv (FOOD) const_iv (POISON) const_iv (BOOK)
886	const_iv (ST_MAT_ITEM)	1236	const_iv (CLOCK) const_iv (ARROW) const_iv (BOW) const_iv (WEAPON)
		1237	const_iv (ARMOUR) const_iv (PEDESTAL) const_iv (ALTAR) const_iv (LOCKED_DOOR)
		1238	const_iv (SPECIAL_KEY) const_iv (MAP) const_iv (DOOR) const_iv (KEY)
		1239	const_iv (TIMED_GATE) const_iv (TRIGGER) const_iv (GRIMREAPER) const_iv (MAGIC_EAR)
		1240	const_iv (TRIGGER_BUTTON) const_iv (TRIGGER_ALTAR) const_iv (TRIGGER_PEDESTAL) const_iv (SHIELD)
		1241	const_iv (HELMET) const_iv (HORN) const_iv (MONEY) const_iv (CLASS)
		1242	const_iv (GRAVESTONE) const_iv (AMULET) const_iv (PLAYERMOVER) const_iv (TELEPORTER)
		1243	const_iv (CREATOR) const_iv (SKILL) const_iv (EARTHWALL) const_iv (GOLEM)
		1244	const_iv (THROWN_OBJ) const_iv (BLINDNESS) const_iv (GOD) const_iv (DETECTOR)
		1245	const_iv (TRIGGER_MARKER) const_iv (DEAD_OBJECT) const_iv (DRINK) const_iv (MARKER)
		1246	const_iv (HOLY_ALTAR) const_iv (PLAYER_CHANGER) const_iv (BATTLEGROUND) const_iv (PEACEMAKER)
		1247	const_iv (GEM) const_iv (FIREWALL) const_iv (ANVIL) const_iv (CHECK_INV)
		1248	const_iv (MOOD_FLOOR) const_iv (EXIT) const_iv (ENCOUNTER) const_iv (SHOP_FLOOR)
		1249	const_iv (SHOP_MAT) const_iv (RING) const_iv (FLOOR) const_iv (FLESH)
		1250	const_iv (INORGANIC) const_iv (SKILL_TOOL) const_iv (LIGHTER) const_iv (BUILDABLE_WALL)
		1251	const_iv (MISC_OBJECT) const_iv (LAMP) const_iv (DUPLICATOR) const_iv (SPELLBOOK)
		1252	const_iv (CLOAK) const_iv (SPINNER) const_iv (GATE) const_iv (BUTTON)
		1253	const_iv (CF_HANDLE) const_iv (HOLE) const_iv (TRAPDOOR) const_iv (SIGN)
		1254	const_iv (BOOTS) const_iv (GLOVES) const_iv (SPELL) const_iv (SPELL_EFFECT)
		1255	const_iv (CONVERTER) const_iv (BRACERS) const_iv (POISONING) const_iv (SAVEBED)
		1256	const_iv (WAND) const_iv (SCROLL) const_iv (DIRECTOR) const_iv (GIRDLE)
		1257	const_iv (FORCE) const_iv (POTION_EFFECT) const_iv (EVENT_CONNECTOR) const_iv (CLOSE_CON)
		1258	const_iv (CONTAINER) const_iv (ARMOUR_IMPROVER) const_iv (WEAPON_IMPROVER) const_iv (SKILLSCROLL)
		1259	const_iv (DEEP_SWAMP) const_iv (IDENTIFY_ALTAR) const_iv (MENU) const_iv (RUNE)
		1260	const_iv (TRAP) const_iv (POWER_CRYSTAL) const_iv (CORPSE) const_iv (DISEASE)
		1261	const_iv (SYMPTOM) const_iv (BUILDER) const_iv (MATERIAL) const_iv (ITEM_TRANSFORMER)
887		1262
888	const_iv (AT_PHYSICAL)	1263	const_iv (NUM_TYPES) const_iv (NUM_SUBTYPES)
889	const_iv (AT_MAGIC)
890	const_iv (AT_FIRE)
891	const_iv (AT_ELECTRICITY)
892	const_iv (AT_COLD)
893	const_iv (AT_CONFUSION)
894	const_iv (AT_ACID)
895	const_iv (AT_DRAIN)
896	const_iv (AT_WEAPONMAGIC)
897	const_iv (AT_GHOSTHIT)
898	const_iv (AT_POISON)
899	const_iv (AT_SLOW)
900	const_iv (AT_PARALYZE)
901	const_iv (AT_TURN_UNDEAD)
902	const_iv (AT_FEAR)
903	const_iv (AT_CANCELLATION)
904	const_iv (AT_DEPLETE)
905	const_iv (AT_DEATH)
906	const_iv (AT_CHAOS)
907	const_iv (AT_COUNTERSPELL)
908	const_iv (AT_GODPOWER)
909	const_iv (AT_HOLYWORD)
910	const_iv (AT_BLIND)
911	const_iv (AT_INTERNAL)
912	const_iv (AT_LIFE_STEALING)
913	const_iv (AT_DISEASE)
914		1264
915	const_iv (QUEST_IN_PROGRESS)	1265	const_iv (ST_BD_BUILD) const_iv (ST_BD_REMOVE)
916	const_iv (QUEST_DONE_QUEST)	1266	const_iv (ST_MAT_FLOOR) const_iv (ST_MAT_WALL) const_iv (ST_MAT_ITEM)
917	const_iv (QUEST_DONE_TASK)
918	const_iv (QUEST_START_QUEST)
919	const_iv (QUEST_END_QUEST)
920	const_iv (QUEST_START_TASK)
921	const_iv (QUEST_END_TASK)
922	const_iv (QUEST_OVERRIDE)
923	const_iv (QUEST_ON_ACTIVATE)
924		1267
925	const_iv (WEAP_HIT)	1268	const_iv (AT_PHYSICAL) const_iv (AT_MAGIC) const_iv (AT_FIRE) const_iv (AT_ELECTRICITY)
926	const_iv (WEAP_SLASH)	1269	const_iv (AT_COLD) const_iv (AT_CONFUSION) const_iv (AT_ACID) const_iv (AT_DRAIN)
927	const_iv (WEAP_PIERCE)	1270	const_iv (AT_WEAPONMAGIC) const_iv (AT_GHOSTHIT) const_iv (AT_POISON) const_iv (AT_SLOW)
928	const_iv (WEAP_CLEAVE)	1271	const_iv (AT_PARALYZE) const_iv (AT_TURN_UNDEAD) const_iv (AT_FEAR) const_iv (AT_CANCELLATION)
929	const_iv (WEAP_SLICE)	1272	const_iv (AT_DEPLETE) const_iv (AT_DEATH) const_iv (AT_CHAOS) const_iv (AT_COUNTERSPELL)
930	const_iv (WEAP_STAB)	1273	const_iv (AT_GODPOWER) const_iv (AT_HOLYWORD) const_iv (AT_BLIND) const_iv (AT_INTERNAL)
931	const_iv (WEAP_WHIP)	1274	const_iv (AT_LIFE_STEALING) const_iv (AT_DISEASE)
932	const_iv (WEAP_CRUSH)	1275
		1276	const_iv (WEAP_HIT) const_iv (WEAP_SLASH) const_iv (WEAP_PIERCE) const_iv (WEAP_CLEAVE)
		1277	const_iv (WEAP_SLICE) const_iv (WEAP_STAB) const_iv (WEAP_WHIP) const_iv (WEAP_CRUSH)
933	const_iv (WEAP_BLUD)	1278	const_iv (WEAP_BLUD)
934		1279
935	const_iv (FLAG_ALIVE)	1280	const_iv (FLAG_ALIVE) const_iv (FLAG_WIZ) const_iv (FLAG_REMOVED) const_iv (FLAG_FREED)
936	const_iv (FLAG_WIZ)	1281	const_iv (FLAG_APPLIED) const_iv (FLAG_UNPAID) const_iv (FLAG_USE_SHIELD)
937	const_iv (FLAG_REMOVED)	1282	const_iv (FLAG_NO_PICK) const_iv (FLAG_ANIMATE) const_iv (FLAG_MONSTER) const_iv (FLAG_FRIENDLY)
		1283	const_iv (FLAG_GENERATOR) const_iv (FLAG_IS_THROWN) const_iv (FLAG_AUTO_APPLY) const_iv (FLAG_PLAYER_SOLD)
		1284	const_iv (FLAG_SEE_INVISIBLE) const_iv (FLAG_CAN_ROLL) const_iv (FLAG_OVERLAY_FLOOR) const_iv (FLAG_IS_TURNABLE)
		1285	const_iv (FLAG_IS_USED_UP) const_iv (FLAG_IDENTIFIED) const_iv (FLAG_REFLECTING) const_iv (FLAG_CHANGING)
		1286	const_iv (FLAG_SPLITTING) const_iv (FLAG_HITBACK) const_iv (FLAG_STARTEQUIP) const_iv (FLAG_BLOCKSVIEW)
		1287	const_iv (FLAG_UNDEAD) const_iv (FLAG_SCARED) const_iv (FLAG_UNAGGRESSIVE) const_iv (FLAG_REFL_MISSILE)
		1288	const_iv (FLAG_REFL_SPELL) const_iv (FLAG_NO_MAGIC) const_iv (FLAG_NO_FIX_PLAYER) const_iv (FLAG_IS_LIGHTABLE)
		1289	const_iv (FLAG_TEAR_DOWN) const_iv (FLAG_RUN_AWAY) const_iv (FLAG_PICK_UP) const_iv (FLAG_UNIQUE)
		1290	const_iv (FLAG_NO_DROP) const_iv (FLAG_WIZCAST) const_iv (FLAG_CAST_SPELL) const_iv (FLAG_USE_SCROLL)
		1291	const_iv (FLAG_USE_RANGE) const_iv (FLAG_USE_BOW) const_iv (FLAG_USE_ARMOUR) const_iv (FLAG_USE_WEAPON)
		1292	const_iv (FLAG_USE_RING) const_iv (FLAG_READY_RANGE) const_iv (FLAG_READY_BOW) const_iv (FLAG_XRAYS)
		1293	const_iv (FLAG_NO_APPLY) const_iv (FLAG_IS_FLOOR) const_iv (FLAG_LIFESAVE) const_iv (FLAG_NO_STRENGTH)
		1294	const_iv (FLAG_SLEEP) const_iv (FLAG_STAND_STILL) const_iv (FLAG_RANDOM_MOVE) const_iv (FLAG_ONLY_ATTACK)
		1295	const_iv (FLAG_CONFUSED) const_iv (FLAG_STEALTH) const_iv (FLAG_WIZPASS) const_iv (FLAG_IS_LINKED)
		1296	const_iv (FLAG_CURSED) const_iv (FLAG_DAMNED) const_iv (FLAG_SEE_ANYWHERE) const_iv (FLAG_KNOWN_MAGICAL)
		1297	const_iv (FLAG_KNOWN_CURSED) const_iv (FLAG_CAN_USE_SKILL) const_iv (FLAG_BEEN_APPLIED) const_iv (FLAG_READY_SCROLL)
		1298	const_iv (FLAG_USE_ROD) const_iv (FLAG_USE_HORN) const_iv (FLAG_MAKE_INVIS) const_iv (FLAG_INV_LOCKED)
		1299	const_iv (FLAG_IS_WOODED) const_iv (FLAG_IS_HILLY) const_iv (FLAG_READY_SKILL) const_iv (FLAG_READY_WEAPON)
		1300	const_iv (FLAG_NO_SKILL_IDENT) const_iv (FLAG_BLIND) const_iv (FLAG_SEE_IN_DARK) const_iv (FLAG_IS_CAULDRON)
		1301	const_iv (FLAG_NO_STEAL) const_iv (FLAG_ONE_HIT) const_iv (FLAG_CLIENT_SENT) const_iv (FLAG_BERSERK)
		1302	const_iv (FLAG_NEUTRAL) const_iv (FLAG_NO_ATTACK) const_iv (FLAG_NO_DAMAGE) const_iv (FLAG_OBJ_ORIGINAL)
		1303	const_iv (FLAG_ACTIVATE_ON_PUSH) const_iv (FLAG_ACTIVATE_ON_RELEASE) const_iv (FLAG_IS_WATER)
		1304	const_iv (FLAG_CONTENT_ON_GEN) const_iv (FLAG_IS_A_TEMPLATE) const_iv (FLAG_IS_BUILDABLE)
		1305	const_iv (FLAG_DESTROY_ON_DEATH) const_iv (FLAG_NO_MAP_SAVE)
		1306
		1307	const_iv (NDI_BLACK) const_iv (NDI_WHITE) const_iv (NDI_NAVY) const_iv (NDI_RED)
		1308	const_iv (NDI_ORANGE) const_iv (NDI_BLUE) const_iv (NDI_DK_ORANGE) const_iv (NDI_GREEN)
		1309	const_iv (NDI_LT_GREEN) const_iv (NDI_GREY) const_iv (NDI_BROWN) const_iv (NDI_GOLD)
		1310	const_iv (NDI_TAN) const_iv (NDI_MAX_COLOR) const_iv (NDI_COLOR_MASK) const_iv (NDI_UNIQUE)
		1311	const_iv (NDI_ALL) const_iv (NDI_DEF) const_iv (NDI_REPLY) const_iv (NDI_CLIENT_MASK)
		1312	const_iv (NDI_NOCREATE) const_iv (NDI_CLEAR)
		1313
		1314	const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE)
		1315	const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF)
		1316
		1317	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_DAMAGE)
		1318
		1319	const_iv (SP_RAISE_DEAD)
938	const_iv (FLAG_FREED)	1320	const_iv (SP_RUNE)
939	const_iv (FLAG_WAS_WIZ)	1321	const_iv (SP_MAKE_MARK)
940	const_iv (FLAG_APPLIED)	1322	const_iv (SP_BOLT)
941	const_iv (FLAG_UNPAID)	1323	const_iv (SP_BULLET)
942	const_iv (FLAG_USE_SHIELD)	1324	const_iv (SP_EXPLOSION)
943	const_iv (FLAG_NO_PICK)	1325	const_iv (SP_CONE)
944	const_iv (FLAG_ANIMATE)	1326	const_iv (SP_BOMB)
945	const_iv (FLAG_MONSTER)	1327	const_iv (SP_WONDER)
946	const_iv (FLAG_FRIENDLY)	1328	const_iv (SP_SMITE)
947	const_iv (FLAG_GENERATOR)	1329	const_iv (SP_MAGIC_MISSILE)
948	const_iv (FLAG_IS_THROWN)	1330	const_iv (SP_SUMMON_GOLEM)
949	const_iv (FLAG_AUTO_APPLY)	1331	const_iv (SP_DIMENSION_DOOR)
950	const_iv (FLAG_TREASURE)	1332	const_iv (SP_MAGIC_MAPPING)
951	const_iv (FLAG_PLAYER_SOLD)	1333	const_iv (SP_MAGIC_WALL)
		1334	const_iv (SP_DESTRUCTION)
		1335	const_iv (SP_PERCEIVE_SELF)
		1336	const_iv (SP_WORD_OF_RECALL)
952	const_iv (FLAG_SEE_INVISIBLE)	1337	const_iv (SP_INVISIBLE)
953	const_iv (FLAG_CAN_ROLL)
954	const_iv (FLAG_OVERLAY_FLOOR)
955	const_iv (FLAG_IS_TURNABLE)
956	const_iv (FLAG_IS_USED_UP)
957	const_iv (FLAG_IDENTIFIED)
958	const_iv (FLAG_REFLECTING)
959	const_iv (FLAG_CHANGING)
960	const_iv (FLAG_SPLITTING)
961	const_iv (FLAG_HITBACK)
962	const_iv (FLAG_STARTEQUIP)
963	const_iv (FLAG_BLOCKSVIEW)
964	const_iv (FLAG_UNDEAD)
965	const_iv (FLAG_SCARED)
966	const_iv (FLAG_UNAGGRESSIVE)
967	const_iv (FLAG_REFL_MISSILE)
968	const_iv (FLAG_REFL_SPELL)
969	const_iv (FLAG_NO_MAGIC)
970	const_iv (FLAG_NO_FIX_PLAYER)
971	const_iv (FLAG_IS_LIGHTABLE)
972	const_iv (FLAG_TEAR_DOWN)
973	const_iv (FLAG_RUN_AWAY)
974	const_iv (FLAG_PICK_UP)
975	const_iv (FLAG_UNIQUE)
976	const_iv (FLAG_NO_DROP)
977	const_iv (FLAG_WIZCAST)
978	const_iv (FLAG_CAST_SPELL)
979	const_iv (FLAG_USE_SCROLL)
980	const_iv (FLAG_USE_RANGE)
981	const_iv (FLAG_USE_BOW)
982	const_iv (FLAG_USE_ARMOUR)
983	const_iv (FLAG_USE_WEAPON)
984	const_iv (FLAG_USE_RING)
985	const_iv (FLAG_READY_RANGE)
986	const_iv (FLAG_READY_BOW)
987	const_iv (FLAG_XRAYS)
988	const_iv (FLAG_NO_APPLY)
989	const_iv (FLAG_IS_FLOOR)
990	const_iv (FLAG_LIFESAVE)
991	const_iv (FLAG_NO_STRENGTH)
992	const_iv (FLAG_SLEEP)
993	const_iv (FLAG_STAND_STILL)
994	const_iv (FLAG_RANDOM_MOVE)
995	const_iv (FLAG_ONLY_ATTACK)
996	const_iv (FLAG_CONFUSED)
997	const_iv (FLAG_STEALTH)
998	const_iv (FLAG_WIZPASS)
999	const_iv (FLAG_IS_LINKED)
1000	const_iv (FLAG_CURSED)
1001	const_iv (FLAG_DAMNED)
1002	const_iv (FLAG_SEE_ANYWHERE)
1003	const_iv (FLAG_KNOWN_MAGICAL)
1004	const_iv (FLAG_KNOWN_CURSED)
1005	const_iv (FLAG_CAN_USE_SKILL)
1006	const_iv (FLAG_BEEN_APPLIED)
1007	const_iv (FLAG_READY_SCROLL)
1008	const_iv (FLAG_USE_ROD)
1009	const_iv (FLAG_USE_HORN)
1010	const_iv (FLAG_MAKE_INVIS)
1011	const_iv (FLAG_INV_LOCKED)
1012	const_iv (FLAG_IS_WOODED)
1013	const_iv (FLAG_IS_HILLY)
1014	const_iv (FLAG_READY_SKILL)
1015	const_iv (FLAG_READY_WEAPON)
1016	const_iv (FLAG_NO_SKILL_IDENT)
1017	const_iv (FLAG_BLIND)
1018	const_iv (FLAG_SEE_IN_DARK)
1019	const_iv (FLAG_IS_CAULDRON)
1020	const_iv (FLAG_NO_STEAL)
1021	const_iv (FLAG_ONE_HIT)
1022	const_iv (FLAG_CLIENT_SENT)
1023	const_iv (FLAG_BERSERK)
1024	const_iv (FLAG_NEUTRAL)
1025	const_iv (FLAG_NO_ATTACK)
1026	const_iv (FLAG_NO_DAMAGE)
1027	const_iv (FLAG_OBJ_ORIGINAL)
1028	const_iv (FLAG_OBJ_SAVE_ON_OVL)
1029	const_iv (FLAG_ACTIVATE_ON_PUSH)
1030	const_iv (FLAG_ACTIVATE_ON_RELEASE)
1031	const_iv (FLAG_IS_WATER)
1032	const_iv (FLAG_CONTENT_ON_GEN)
1033	const_iv (FLAG_IS_A_TEMPLATE)
1034	const_iv (FLAG_IS_BUILDABLE)
1035	const_iv (FLAG_AFK)
1036
1037	const_iv (NDI_BLACK)
1038	const_iv (NDI_WHITE)
1039	const_iv (NDI_NAVY)
1040	const_iv (NDI_RED)	1338	const_iv (SP_PROBE)
1041	const_iv (NDI_ORANGE)	1339	const_iv (SP_HEALING)
		1340	const_iv (SP_CREATE_FOOD)
		1341	const_iv (SP_EARTH_TO_DUST)
		1342	const_iv (SP_CHANGE_ABILITY)
1042	const_iv (NDI_BLUE)	1343	const_iv (SP_BLESS)
1043	const_iv (NDI_DK_ORANGE)
1044	const_iv (NDI_GREEN)
1045	const_iv (NDI_LT_GREEN)
1046	const_iv (NDI_GREY)
1047	const_iv (NDI_BROWN)
1048	const_iv (NDI_GOLD)
1049	const_iv (NDI_TAN)
1050	const_iv (NDI_MAX_COLOR)
1051	const_iv (NDI_COLOR_MASK)
1052	const_iv (NDI_UNIQUE)
1053	const_iv (NDI_ALL)
1054
1055	const_iv (F_APPLIED)
1056	const_iv (F_LOCATION)
1057	const_iv (F_UNPAID)
1058	const_iv (F_MAGIC)
1059	const_iv (F_CURSED)	1344	const_iv (SP_CURSE)
		1345	const_iv (SP_SUMMON_MONSTER)
		1346	const_iv (SP_CHARGING)
		1347	const_iv (SP_POLYMORPH)
		1348	const_iv (SP_ALCHEMY)
		1349	const_iv (SP_REMOVE_CURSE)
		1350	const_iv (SP_IDENTIFY)
		1351	const_iv (SP_DETECTION)
		1352	const_iv (SP_MOOD_CHANGE)
		1353	const_iv (SP_MOVING_BALL)
1060	const_iv (F_DAMNED)	1354	const_iv (SP_SWARM)
		1355	const_iv (SP_CHANGE_MANA)
1061	const_iv (F_OPEN)	1356	const_iv (SP_DISPEL_RUNE)
1062	const_iv (F_NOPICK)	1357	const_iv (SP_CREATE_MISSILE)
		1358	const_iv (SP_CONSECRATE)
		1359	const_iv (SP_ANIMATE_WEAPON)
		1360	const_iv (SP_LIGHT)
		1361	const_iv (SP_CHANGE_MAP_LIGHT)
		1362	const_iv (SP_FAERY_FIRE)
		1363	const_iv (SP_CAUSE_DISEASE)
		1364	const_iv (SP_AURA)
		1365	const_iv (SP_TOWN_PORTAL)
		1366	const_iv (SP_PARTY_SPELL)
		1367
		1368	const_iv (F_APPLIED) const_iv (F_LOCATION) const_iv (F_UNPAID) const_iv (F_MAGIC)
		1369	const_iv (F_CURSED) const_iv (F_DAMNED) const_iv (F_OPEN) const_iv (F_NOPICK)
1063	const_iv (F_LOCKED)	1370	const_iv (F_LOCKED)
1064		1371
1065	const_iv (F_BUY)	1372	const_iv (F_BUY) const_iv (F_SHOP) const_iv (F_SELL)
1066	const_iv (F_SHOP)
1067	const_iv (F_SELL)
1068		1373
1069	const_iv (P_BLOCKSVIEW)	1374	const_iv (P_BLOCKSVIEW) const_iv (P_PLAYER) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE)
1070	const_iv (P_NO_MAGIC)	1375	const_iv (P_NO_CLERIC) const_iv (P_OUT_OF_MAP) const_iv (P_NEW_MAP) const_iv (P_UPTODATE)
1071	const_iv (P_IS_ALIVE)
1072	const_iv (P_NO_CLERIC)
1073	const_iv (P_NEED_UPDATE)
1074	const_iv (P_NO_ERROR)
1075	const_iv (P_OUT_OF_MAP)
1076	const_iv (P_NEW_MAP)
1077		1376
1078	const_iv (UP_OBJ_INSERT)	1377	const_iv (UP_OBJ_INSERT) const_iv (UP_OBJ_REMOVE) const_iv (UP_OBJ_CHANGE) const_iv (UP_OBJ_FACE)
1079	const_iv (UP_OBJ_REMOVE)
1080	const_iv (UP_OBJ_CHANGE)
1081	const_iv (UP_OBJ_FACE)
1082		1378
1083	const_iv (INS_NO_MERGE)	1379	const_iv (INS_NO_MERGE) const_iv (INS_ABOVE_FLOOR_ONLY) const_iv (INS_NO_WALK_ON)
1084	const_iv (INS_ABOVE_FLOOR_ONLY)
1085	const_iv (INS_NO_WALK_ON)
1086	const_iv (INS_ON_TOP)
1087	const_iv (INS_BELOW_ORIGINATOR)	1380	const_iv (INS_ON_TOP) const_iv (INS_BELOW_ORIGINATOR)
1088	const_iv (INS_MAP_LOAD)
1089		1381
1090	const_iv (WILL_APPLY_HANDLE)	1382	const_iv (WILL_APPLY_HANDLE) const_iv (WILL_APPLY_TREASURE) const_iv (WILL_APPLY_EARTHWALL)
1091	const_iv (WILL_APPLY_TREASURE)	1383	const_iv (WILL_APPLY_DOOR) const_iv (WILL_APPLY_FOOD)
1092	const_iv (WILL_APPLY_EARTHWALL)
1093	const_iv (WILL_APPLY_DOOR)
1094	const_iv (WILL_APPLY_FOOD)
1095		1384
1096	const_iv (SAVE_MODE)	1385	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)
1097	const_iv (SAVE_DIR_MODE)
1098		1386
1099	const_iv (M_PAPER)	1387	const_iv (M_PAPER) const_iv (M_IRON) const_iv (M_GLASS) const_iv (M_LEATHER)
1100	const_iv (M_IRON)	1388	const_iv (M_WOOD) const_iv (M_ORGANIC) const_iv (M_STONE) const_iv (M_CLOTH)
1101	const_iv (M_GLASS)	1389	const_iv (M_ADAMANT) const_iv (M_LIQUID) const_iv (M_SOFT_METAL) const_iv (M_BONE)
1102	const_iv (M_LEATHER)	1390	const_iv (M_ICE) const_iv (M_SPECIAL)
1103	const_iv (M_WOOD)
1104	const_iv (M_ORGANIC)
1105	const_iv (M_STONE)
1106	const_iv (M_CLOTH)
1107	const_iv (M_ADAMANT)
1108	const_iv (M_LIQUID)
1109	const_iv (M_SOFT_METAL)
1110	const_iv (M_BONE)
1111	const_iv (M_ICE)
1112	const_iv (M_SPECIAL)
1113		1391
1114	const_iv (SK_EXP_ADD_SKILL)	1392	const_iv (SK_EXP_ADD_SKILL) const_iv (SK_EXP_TOTAL) const_iv (SK_EXP_NONE)
1115	const_iv (SK_EXP_TOTAL)	1393	const_iv (SK_SUBTRACT_SKILL_EXP) const_iv (SK_EXP_SKILL_ONLY)
1116	const_iv (SK_EXP_NONE)
1117	const_iv (SK_SUBTRACT_SKILL_EXP)
1118		1394
1119	const_iv (SK_LOCKPICKING)	1395	const_iv (SK_LOCKPICKING) const_iv (SK_HIDING) const_iv (SK_SMITHERY) const_iv (SK_BOWYER)
1120	const_iv (SK_HIDING)	1396	const_iv (SK_JEWELER) const_iv (SK_ALCHEMY) const_iv (SK_STEALING) const_iv (SK_LITERACY)
1121	const_iv (SK_SMITHERY)	1397	const_iv (SK_BARGAINING) const_iv (SK_JUMPING) const_iv (SK_DET_MAGIC) const_iv (SK_ORATORY)
1122	const_iv (SK_BOWYER)	1398	const_iv (SK_SINGING) const_iv (SK_DET_CURSE) const_iv (SK_FIND_TRAPS) const_iv (SK_MEDITATION)
1123	const_iv (SK_JEWELER)	1399	const_iv (SK_PUNCHING) const_iv (SK_FLAME_TOUCH) const_iv (SK_KARATE) const_iv (SK_CLIMBING)
1124	const_iv (SK_ALCHEMY)	1400	const_iv (SK_WOODSMAN) const_iv (SK_INSCRIPTION) const_iv (SK_ONE_HANDED_WEAPON) const_iv (SK_MISSILE_WEAPON)
1125	const_iv (SK_STEALING)	1401	const_iv (SK_THROWING) const_iv (SK_USE_MAGIC_ITEM) const_iv (SK_DISARM_TRAPS) const_iv (SK_SET_TRAP)
1126	const_iv (SK_LITERACY)	1402	const_iv (SK_THAUMATURGY) const_iv (SK_PRAYING) const_iv (SK_CLAWING) const_iv (SK_LEVITATION)
1127	const_iv (SK_BARGAINING)	1403	const_iv (SK_SUMMONING) const_iv (SK_PYROMANCY) const_iv (SK_EVOCATION) const_iv (SK_SORCERY)
1128	const_iv (SK_JUMPING)	1404	const_iv (SK_TWO_HANDED_WEAPON) const_iv (SK_SPARK_TOUCH) const_iv (SK_SHIVER) const_iv (SK_ACID_SPLASH)
1129	const_iv (SK_DET_MAGIC)
1130	const_iv (SK_ORATORY)
1131	const_iv (SK_SINGING)
1132	const_iv (SK_DET_CURSE)
1133	const_iv (SK_FIND_TRAPS)
1134	const_iv (SK_MEDITATION)
1135	const_iv (SK_PUNCHING)
1136	const_iv (SK_FLAME_TOUCH)
1137	const_iv (SK_KARATE)
1138	const_iv (SK_CLIMBING)
1139	const_iv (SK_WOODSMAN)
1140	const_iv (SK_INSCRIPTION)
1141	const_iv (SK_ONE_HANDED_WEAPON)
1142	const_iv (SK_MISSILE_WEAPON)
1143	const_iv (SK_THROWING)
1144	const_iv (SK_USE_MAGIC_ITEM)
1145	const_iv (SK_DISARM_TRAPS)
1146	const_iv (SK_SET_TRAP)
1147	const_iv (SK_THAUMATURGY)
1148	const_iv (SK_PRAYING)
1149	const_iv (SK_CLAWING)
1150	const_iv (SK_LEVITATION)
1151	const_iv (SK_SUMMONING)
1152	const_iv (SK_PYROMANCY)
1153	const_iv (SK_EVOCATION)
1154	const_iv (SK_SORCERY)
1155	const_iv (SK_TWO_HANDED_WEAPON)
1156	const_iv (SK_SPARK_TOUCH)
1157	const_iv (SK_SHIVER)
1158	const_iv (SK_ACID_SPLASH)
1159	const_iv (SK_POISON_NAIL)	1405	const_iv (SK_POISON_NAIL)
1160		1406
1161	const_iv (SOUND_NEW_PLAYER)	1407	const_iv (SOUND_NEW_PLAYER) const_iv (SOUND_FIRE_ARROW) const_iv (SOUND_LEARN_SPELL) const_iv (SOUND_FUMBLE_SPELL)
1162	const_iv (SOUND_FIRE_ARROW)	1408	const_iv (SOUND_WAND_POOF) const_iv (SOUND_OPEN_DOOR) const_iv (SOUND_PUSH_PLAYER) const_iv (SOUND_PLAYER_HITS1)
1163	const_iv (SOUND_LEARN_SPELL)	1409	const_iv (SOUND_PLAYER_HITS2) const_iv (SOUND_PLAYER_HITS3) const_iv (SOUND_PLAYER_HITS4) const_iv (SOUND_PLAYER_IS_HIT1)
1164	const_iv (SOUND_FUMBLE_SPELL)	1410	const_iv (SOUND_PLAYER_IS_HIT2) const_iv (SOUND_PLAYER_IS_HIT3) const_iv (SOUND_PLAYER_KILLS) const_iv (SOUND_PET_IS_KILLED)
1165	const_iv (SOUND_WAND_POOF)	1411	const_iv (SOUND_PLAYER_DIES) const_iv (SOUND_OB_EVAPORATE) const_iv (SOUND_OB_EXPLODE) const_iv (SOUND_CLOCK)
1166	const_iv (SOUND_OPEN_DOOR)	1412	const_iv (SOUND_TURN_HANDLE) const_iv (SOUND_FALL_HOLE) const_iv (SOUND_DRINK_POISON) const_iv (SOUND_CAST_SPELL_0)
1167	const_iv (SOUND_PUSH_PLAYER)
1168	const_iv (SOUND_PLAYER_HITS1)
1169	const_iv (SOUND_PLAYER_HITS2)
1170	const_iv (SOUND_PLAYER_HITS3)
1171	const_iv (SOUND_PLAYER_HITS4)
1172	const_iv (SOUND_PLAYER_IS_HIT1)
1173	const_iv (SOUND_PLAYER_IS_HIT2)
1174	const_iv (SOUND_PLAYER_IS_HIT3)
1175	const_iv (SOUND_PLAYER_KILLS)
1176	const_iv (SOUND_PET_IS_KILLED)
1177	const_iv (SOUND_PLAYER_DIES)
1178	const_iv (SOUND_OB_EVAPORATE)
1179	const_iv (SOUND_OB_EXPLODE)
1180	const_iv (SOUND_CLOCK)
1181	const_iv (SOUND_TURN_HANDLE)
1182	const_iv (SOUND_FALL_HOLE)
1183	const_iv (SOUND_DRINK_POISON)
1184	const_iv (SOUND_CAST_SPELL_0)
1185		1413
1186	const_iv (PREFER_LOW)	1414	const_iv (PREFER_LOW) const_iv (PREFER_HIGH)
1187	const_iv (PREFER_HIGH)
1188		1415
1189	const_iv (ATNR_PHYSICAL)	1416	const_iv (ATNR_PHYSICAL) const_iv (ATNR_MAGIC) const_iv (ATNR_FIRE) const_iv (ATNR_ELECTRICITY)
1190	const_iv (ATNR_MAGIC)	1417	const_iv (ATNR_COLD) const_iv (ATNR_CONFUSION) const_iv (ATNR_ACID) const_iv (ATNR_DRAIN)
1191	const_iv (ATNR_FIRE)	1418	const_iv (ATNR_WEAPONMAGIC) const_iv (ATNR_GHOSTHIT) const_iv (ATNR_POISON) const_iv (ATNR_SLOW)
1192	const_iv (ATNR_ELECTRICITY)	1419	const_iv (ATNR_PARALYZE) const_iv (ATNR_TURN_UNDEAD) const_iv (ATNR_FEAR) const_iv (ATNR_CANCELLATION)
1193	const_iv (ATNR_COLD)	1420	const_iv (ATNR_DEPLETE) const_iv (ATNR_DEATH) const_iv (ATNR_CHAOS) const_iv (ATNR_COUNTERSPELL)
1194	const_iv (ATNR_CONFUSION)	1421	const_iv (ATNR_GODPOWER) const_iv (ATNR_HOLYWORD) const_iv (ATNR_BLIND) const_iv (ATNR_INTERNAL)
1195	const_iv (ATNR_ACID)	1422	const_iv (ATNR_LIFE_STEALING) const_iv (ATNR_DISEASE)
1196	const_iv (ATNR_DRAIN)	1423
1197	const_iv (ATNR_WEAPONMAGIC)	1424	const_iv (MAP_IN_MEMORY) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)
1198	const_iv (ATNR_GHOSTHIT)	1425
1199	const_iv (ATNR_POISON)	1426	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)
1200	const_iv (ATNR_SLOW)	1427	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)
1201	const_iv (ATNR_PARALYZE)	1428
1202	const_iv (ATNR_TURN_UNDEAD)	1429	const_iv (VERSION_CS) const_iv (VERSION_SC)
1203	const_iv (ATNR_FEAR)	1430
1204	const_iv (ATNR_CANCELLATION)	1431	const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)
1205	const_iv (ATNR_DEPLETE)	1432
1206	const_iv (ATNR_DEATH)	1433	const_iv (ST_DEAD) const_iv (ST_SETUP) const_iv (ST_PLAYING) const_iv (ST_CUSTOM)
1207	const_iv (ATNR_CHAOS)	1434
1208	const_iv (ATNR_COUNTERSPELL)	1435	const_iv (IO_HEADER) const_iv (IO_OBJECTS) const_iv (IO_UNIQUES)
1209	const_iv (ATNR_GODPOWER)	1436
1210	const_iv (ATNR_HOLYWORD)	1437	// random map generator
1211	const_iv (ATNR_BLIND)	1438	const_iv (LAYOUT_NONE) const_iv (LAYOUT_ONION) const_iv (LAYOUT_MAZE) const_iv (LAYOUT_SPIRAL)
		1439	const_iv (LAYOUT_ROGUELIKE) const_iv (LAYOUT_SNAKE) const_iv (LAYOUT_SQUARE_SPIRAL)
		1440
		1441	const_iv (RMOPT_RANDOM) const_iv (RMOPT_CENTERED) const_iv (RMOPT_LINEAR)
		1442	const_iv (RMOPT_BOTTOM_C) const_iv (RMOPT_BOTTOM_R) const_iv (RMOPT_IRR_SPACE)
		1443	const_iv (RMOPT_WALL_OFF) const_iv (RMOPT_WALLS_ONLY) const_iv (RMOPT_NO_DOORS)
		1444
		1445	const_iv (SYMMETRY_RANDOM) const_iv (SYMMETRY_NONE) const_iv (SYMMETRY_X)
		1446	const_iv (SYMMETRY_Y) const_iv (SYMMETRY_XY)
		1447
		1448	const_iv (GT_ENVIRONMENT) const_iv (GT_INVISIBLE) const_iv (GT_STARTEQUIP)
		1449	const_iv (GT_APPLY) const_iv (GT_ONLY_GOOD) const_iv (GT_UPDATE_INV)
1212	const_iv (ATNR_INTERNAL)	1450	const_iv (GT_MINIMAL)
1213	const_iv (ATNR_LIFE_STEALING)
1214	const_iv (ATNR_DISEASE)
1215		1451
1216	const_iv (MAP_FLUSH)	1452	const_iv (FT_FACE) const_iv (FT_MUSIC) const_iv (FT_SOUND)
1217	const_iv (MAP_PLAYER_UNIQUE)	1453	const_iv (FT_RSRC) const_iv (FT_NUM)
1218	const_iv (MAP_BLOCK)
1219	const_iv (MAP_STYLE)
1220	const_iv (MAP_OVERLAY)
1221
1222	const_iv (MAP_IN_MEMORY)
1223	const_iv (MAP_SWAPPED)
1224	const_iv (MAP_LOADING)
1225	const_iv (MAP_SAVING)
1226	};	1454	};
1227		1455
1228	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	1456	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1229	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));	1457	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1230		1458
1231	static const struct {	1459	static const struct {
1232	const char *name;	1460	const char *name;
		1461	int skip;
		1462	IV klass;
1233	IV iv;	1463	IV iv;
1234	} *event, event_list[] = {	1464	} *eiv, event_iv[] = {
1235	# define const_event(name) { # name, (IV)EVENT_ ## name },	1465	# define def(klass,name) { "EVENT_" # klass "_" # name, sizeof ("EVENT_" # klass), (IV)KLASS_ ## klass, (IV)EVENT_ ## klass ## _ ## name },
1236	const_event (NONE)	1466	# include "eventinc.h"
1237	const_event (APPLY)	1467	# undef def
1238	const_event (ATTACK)
1239	const_event (DEATH)
1240	const_event (DROP)
1241	const_event (DROP_ON)
1242	const_event (PICKUP)
1243	const_event (SAY)
1244	const_event (STOP)
1245	const_event (TIME)
1246	const_event (THROW)
1247	const_event (TRIGGER)
1248	const_event (CLOSE)
1249	const_event (TIMER)
1250	const_event (MOVE)
1251
1252	const_event (BORN)
1253	//const_event (CLOCK)
1254	const_event (CRASH)
1255	const_event (PLAYER_DEATH)
1256	const_event (PLAYER_LOAD)
1257	const_event (PLAYER_SAVE)
1258	const_event (GKILL)
1259	const_event (LOGIN)
1260	const_event (LOGOUT)
1261	const_event (MAPENTER)
1262	const_event (MAPLEAVE)
1263	const_event (MAPRESET)
1264	const_event (MAPLOAD)
1265	const_event (MAPOUT)
1266	const_event (MAPIN)
1267	const_event (MAPCLEAN)
1268	const_event (REMOVE)
1269	const_event (SHOUT)
1270	const_event (TELL)
1271	const_event (MUZZLE)
1272	const_event (KICK)
1273	const_event (PLAYER_USE_SKILL)
1274	const_event (MONSTER_USE_SKILL)
1275	const_event (CAST_SPELL)
1276	const_event (FIND_UNARMED_SKILL)
1277	const_event (EXTCMD)
1278	//const_event (FREE_OB)
1279	};	1468	};
1280		1469
1281	AV *av = get_av ("cf::EVENT", 1);	1470	AV *av = get_av ("cf::EVENT", 1);
1282		1471
1283	for (event = event_list + sizeof (event_list) / sizeof (event_list [0]); event-- > event_list; )	1472	for (eiv = event_iv + sizeof (event_iv) / sizeof (event_iv [0]); eiv-- > event_iv; )
1284	av_store (av, event->iv, newSVpv ((char *)event->name, 0));
1285
1286	static const struct {
1287	int dtype;
1288	const char *name;
1289	IV idx;
1290	} *cprop, prop_table[] = {
1291	# define prop(type, name) { type, # name, (IV) CFAPI_ ## name },
1292	prop (CFAPI_INT, MAP_PROP_FLAGS)
1293	prop (CFAPI_INT, MAP_PROP_DIFFICULTY)
1294	prop (CFAPI_STRING, MAP_PROP_PATH)
1295	prop (CFAPI_STRING, MAP_PROP_TMPNAME)
1296	prop (CFAPI_STRING, MAP_PROP_NAME)
1297	prop (CFAPI_INT, MAP_PROP_RESET_TIME)
1298	prop (CFAPI_INT, MAP_PROP_RESET_TIMEOUT)
1299	prop (CFAPI_INT, MAP_PROP_PLAYERS)
1300	prop (CFAPI_INT, MAP_PROP_DARKNESS)
1301	prop (CFAPI_INT, MAP_PROP_WIDTH)
1302	prop (CFAPI_INT, MAP_PROP_HEIGHT)
1303	prop (CFAPI_INT, MAP_PROP_ENTER_X)
1304	prop (CFAPI_INT, MAP_PROP_ENTER_Y)
1305	prop (CFAPI_INT, MAP_PROP_TEMPERATURE)
1306	prop (CFAPI_INT, MAP_PROP_PRESSURE)
1307	prop (CFAPI_INT, MAP_PROP_HUMIDITY)
1308	prop (CFAPI_INT, MAP_PROP_WINDSPEED)
1309	prop (CFAPI_INT, MAP_PROP_WINDDIR)
1310	prop (CFAPI_INT, MAP_PROP_SKY)
1311	prop (CFAPI_INT, MAP_PROP_WPARTX)
1312	prop (CFAPI_INT, MAP_PROP_WPARTY)
1313	prop (CFAPI_STRING, MAP_PROP_MESSAGE)
1314	prop (CFAPI_PMAP, MAP_PROP_NEXT)
1315	prop (CFAPI_PREGION, MAP_PROP_REGION)
1316	prop (CFAPI_POBJECT, OBJECT_PROP_OB_ABOVE)
1317	prop (CFAPI_POBJECT, OBJECT_PROP_OB_BELOW)
1318	prop (CFAPI_POBJECT, OBJECT_PROP_NEXT_ACTIVE_OB)
1319	prop (CFAPI_POBJECT, OBJECT_PROP_PREV_ACTIVE_OB)
1320	prop (CFAPI_POBJECT, OBJECT_PROP_INVENTORY)
1321	prop (CFAPI_POBJECT, OBJECT_PROP_ENVIRONMENT)
1322	prop (CFAPI_POBJECT, OBJECT_PROP_HEAD)
1323	prop (CFAPI_POBJECT, OBJECT_PROP_CONTAINER)
1324	prop (CFAPI_PMAP, OBJECT_PROP_MAP)
1325	prop (CFAPI_INT, OBJECT_PROP_COUNT)
1326	prop (CFAPI_INT, OBJECT_PROP_REFCOUNT)
1327	prop (CFAPI_STRING, OBJECT_PROP_NAME)
1328	prop (CFAPI_STRING, OBJECT_PROP_NAME_PLURAL)
1329	prop (CFAPI_STRING, OBJECT_PROP_TITLE)
1330	prop (CFAPI_STRING, OBJECT_PROP_RACE)
1331	prop (CFAPI_STRING, OBJECT_PROP_SLAYING)
1332	prop (CFAPI_STRING, OBJECT_PROP_SKILL)
1333	prop (CFAPI_STRING, OBJECT_PROP_MESSAGE)
1334	prop (CFAPI_STRING, OBJECT_PROP_LORE)
1335	prop (CFAPI_INT, OBJECT_PROP_X)
1336	prop (CFAPI_INT, OBJECT_PROP_Y)
1337	prop (CFAPI_DOUBLE, OBJECT_PROP_SPEED)
1338	prop (CFAPI_DOUBLE, OBJECT_PROP_SPEED_LEFT)
1339	prop (CFAPI_INT, OBJECT_PROP_NROF)
1340	prop (CFAPI_INT, OBJECT_PROP_DIRECTION)
1341	prop (CFAPI_INT, OBJECT_PROP_FACING)
1342	prop (CFAPI_INT, OBJECT_PROP_TYPE)
1343	prop (CFAPI_INT, OBJECT_PROP_SUBTYPE)
1344	prop (CFAPI_INT, OBJECT_PROP_CLIENT_TYPE)
1345	prop (CFAPI_INT, OBJECT_PROP_ATTACK_TYPE)
1346	prop (CFAPI_INT, OBJECT_PROP_PATH_ATTUNED)
1347	prop (CFAPI_INT, OBJECT_PROP_PATH_REPELLED)
1348	prop (CFAPI_INT, OBJECT_PROP_PATH_DENIED)
1349	prop (CFAPI_INT, OBJECT_PROP_MATERIAL)
1350	prop (CFAPI_STRING, OBJECT_PROP_MATERIAL_NAME)
1351	prop (CFAPI_INT, OBJECT_PROP_MAGIC)
1352	prop (CFAPI_INT, OBJECT_PROP_VALUE)
1353	prop (CFAPI_INT, OBJECT_PROP_LEVEL)
1354	prop (CFAPI_INT, OBJECT_PROP_LAST_HEAL)
1355	prop (CFAPI_INT, OBJECT_PROP_LAST_SP)
1356	prop (CFAPI_INT, OBJECT_PROP_LAST_GRACE)
1357	prop (CFAPI_INT, OBJECT_PROP_LAST_EAT)
1358	prop (CFAPI_INT, OBJECT_PROP_INVISIBLE_TIME)
1359	prop (CFAPI_INT, OBJECT_PROP_PICK_UP)
1360	prop (CFAPI_INT, OBJECT_PROP_ITEM_POWER)
1361	prop (CFAPI_INT, OBJECT_PROP_GEN_SP_ARMOUR)
1362	prop (CFAPI_INT, OBJECT_PROP_WEIGHT)
1363	prop (CFAPI_INT, OBJECT_PROP_WEIGHT_LIMIT)
1364	prop (CFAPI_INT, OBJECT_PROP_CARRYING)
1365	prop (CFAPI_INT, OBJECT_PROP_GLOW_RADIUS)
1366	prop (CFAPI_LONG, OBJECT_PROP_PERM_EXP)
1367	prop (CFAPI_POBJECT, OBJECT_PROP_CURRENT_WEAPON)
1368	prop (CFAPI_POBJECT, OBJECT_PROP_ENEMY)
1369	prop (CFAPI_POBJECT, OBJECT_PROP_ATTACKED_BY)
1370	prop (CFAPI_INT, OBJECT_PROP_RUN_AWAY)
1371	prop (CFAPI_POBJECT, OBJECT_PROP_CHOSEN_SKILL)
1372	prop (CFAPI_INT, OBJECT_PROP_HIDDEN)
1373	prop (CFAPI_INT, OBJECT_PROP_MOVE_STATUS)
1374	prop (CFAPI_INT, OBJECT_PROP_MOVE_TYPE)
1375	prop (CFAPI_POBJECT, OBJECT_PROP_SPELL_ITEM)
1376	prop (CFAPI_DOUBLE, OBJECT_PROP_EXP_MULTIPLIER)
1377	prop (CFAPI_PARCH, OBJECT_PROP_ARCHETYPE)
1378	prop (CFAPI_PARCH, OBJECT_PROP_OTHER_ARCH)
1379	prop (CFAPI_STRING, OBJECT_PROP_CUSTOM_NAME)
1380	prop (CFAPI_INT, OBJECT_PROP_ANIM_SPEED)
1381	prop (CFAPI_INT, OBJECT_PROP_FRIENDLY)
1382	prop (CFAPI_STRING, OBJECT_PROP_SHORT_NAME)
1383	prop (CFAPI_INT, OBJECT_PROP_MAGICAL)
1384	prop (CFAPI_INT, OBJECT_PROP_LUCK)
1385	prop (CFAPI_POBJECT, OBJECT_PROP_OWNER)
1386	prop (CFAPI_POBJECT, OBJECT_PROP_PRESENT)
1387	prop (CFAPI_INT, OBJECT_PROP_CHEATER)
1388	prop (CFAPI_INT, OBJECT_PROP_MERGEABLE)
1389	prop (CFAPI_INT, OBJECT_PROP_PICKABLE)
1390	prop (CFAPI_INT, OBJECT_PROP_STR)
1391	prop (CFAPI_INT, OBJECT_PROP_DEX)
1392	prop (CFAPI_INT, OBJECT_PROP_CON)
1393	prop (CFAPI_INT, OBJECT_PROP_WIS)
1394	prop (CFAPI_INT, OBJECT_PROP_INT)
1395	prop (CFAPI_INT, OBJECT_PROP_POW)
1396	prop (CFAPI_INT, OBJECT_PROP_CHA)
1397	prop (CFAPI_INT, OBJECT_PROP_WC)
1398	prop (CFAPI_INT, OBJECT_PROP_AC)
1399	prop (CFAPI_INT, OBJECT_PROP_HP)
1400	prop (CFAPI_INT, OBJECT_PROP_SP)
1401	prop (CFAPI_INT, OBJECT_PROP_GP)
1402	prop (CFAPI_INT, OBJECT_PROP_FP)
1403	prop (CFAPI_INT, OBJECT_PROP_MAXHP)
1404	prop (CFAPI_INT, OBJECT_PROP_MAXSP)
1405	prop (CFAPI_INT, OBJECT_PROP_MAXGP)
1406	prop (CFAPI_INT, OBJECT_PROP_DAM)
1407	prop (CFAPI_STRING, OBJECT_PROP_GOD)
1408	prop (CFAPI_STRING, OBJECT_PROP_ARCH_NAME)
1409	prop (CFAPI_INT, OBJECT_PROP_INVISIBLE)
1410	prop (CFAPI_INT, OBJECT_PROP_FACE)
1411	};
1412
1413	HV *prop_type = get_hv ("cf::PROP_TYPE", 1);
1414	HV *prop_idx = get_hv ("cf::PROP_IDX", 1);
1415
1416	for (cprop = prop_table + sizeof (prop_table) / sizeof (prop_table [0]); cprop-- > prop_table; )
1417	{	1473	{
1418	hv_store (prop_type, cprop->name, strlen (cprop->name), newSViv (cprop->dtype), 0);	1474	AV *event = newAV ();
1419	hv_store (prop_idx, cprop->name, strlen (cprop->name), newSViv (cprop->idx ), 0);	1475	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));
		1476	av_push (event, newSViv (eiv->klass));
		1477	av_store (av, eiv->iv, newRV_noinc ((SV *)event));
		1478	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));
1420	}	1479	}
		1480	}
1421		1481
1422	//I_EVENT_API (PACKAGE);	1482	void _connect_to_perl ()
		1483
		1484	void _recalc_want ()
		1485
		1486	void _global_reattach ()
		1487	CODE:
		1488	{
		1489	// reattach to all attachable objects in the game.
		1490	for_all_clients (ns)
		1491	ns->reattach ();
		1492
		1493	for_all_objects (op)
		1494	op->reattach ();
		1495	}
		1496
		1497	# support function for map-world.ext
		1498	void _quantise (SV *data_sv, SV *plt_sv)
		1499	CODE:
		1500	{
		1501	if (!SvROK (plt_sv) || SvTYPE (SvRV (plt_sv)) != SVt_PVAV)
		1502	croak ("_quantise called with invalid agruments");
		1503
		1504	plt_sv = SvRV (plt_sv);
		1505	SV **plt = AvARRAY (plt_sv);
		1506	int plt_count = AvFILL (plt_sv) + 1;
		1507
		1508	STRLEN len;
		1509	char *data = SvPVbyte (data_sv, len);
		1510	char *dst = data;
		1511
		1512	while (len >= 3)
		1513	{
		1514	for (SV **val_sv = plt + plt_count; val_sv-- > plt; )
		1515	{
		1516	char *val = SvPVX (*val_sv);
		1517
		1518	if (val [0] == data [0]
		1519	&& val [1] == data [1]
		1520	&& val [2] == data [2])
		1521	{
		1522	*dst++ = val [3];
		1523	goto next;
		1524	}
		1525	}
		1526
		1527	croak ("_quantise: color not found in palette: #%02x%02x%02x, at offset %d %d",
		1528	(uint8_t)data [0], (uint8_t)data [1], (uint8_t)data [2],
		1529	dst - SvPVX (data_sv), len);
		1530
		1531	next:
		1532	data += 3;
		1533	len -= 3;
		1534	}
		1535
		1536	SvCUR_set (data_sv, dst - SvPVX (data_sv));
		1537	}
		1538
		1539	void evthread_start ()
		1540
		1541	void cede_to_tick ()
		1542	CODE:
		1543	coroapi::cede_to_tick ();
		1544
		1545	NV till_tick ()
		1546	CODE:
		1547	RETVAL = SvNVX (sv_next_tick) - now ();
		1548	OUTPUT:
		1549	RETVAL
		1550
		1551	int tick_inhibit ()
		1552	CODE:
		1553	RETVAL = tick_inhibit;
		1554	OUTPUT:
		1555	RETVAL
		1556
		1557	void tick_inhibit_inc ()
		1558	CODE:
		1559	++tick_inhibit;
		1560
		1561	void tick_inhibit_dec ()
		1562	CODE:
		1563	if (!--tick_inhibit)
		1564	if (tick_pending)
		1565	{
		1566	ev_async_send (EV_DEFAULT, &tick_watcher);
		1567	coroapi::cede ();
		1568	}
		1569
		1570	void server_tick ()
		1571	CODE:
		1572	{
		1573	NOW = ev_now (EV_DEFAULT);
		1574	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1575	SvNV_set (sv_tick_start, NOW); SvNOK_only (sv_tick_start);
		1576	runtime = SvNVX (sv_runtime);
		1577
		1578	server_tick ();
		1579
		1580	NOW = ev_time ();
		1581	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1582	runtime += TICK;
		1583	SvNV_set (sv_runtime, runtime); SvNOK_only (sv_runtime);
1423	}	1584	}
1424		1585
1425	NV floor (NV x)	1586	NV floor (NV x)
1426		1587
1427	NV ceil (NV x)	1588	NV ceil (NV x)
1428		1589
		1590	NV rndm (...)
		1591	CODE:
		1592	switch (items)
		1593	{
		1594	case 0: RETVAL = rndm (); break;
		1595	case 1: RETVAL = rndm (SvUV (ST (0))); break;
		1596	case 2: RETVAL = rndm (SvIV (ST (0)), SvIV (ST (1))); break;
		1597	default: croak ("cf::rndm requires none, one or two parameters."); break;
		1598	}
		1599	OUTPUT:
		1600	RETVAL
		1601
		1602	NV clamp (NV value, NV min_value, NV max_value)
		1603	CODE:
		1604	RETVAL = clamp (value, min_value, max_value);
		1605	OUTPUT:
		1606	RETVAL
		1607
		1608	NV lerp (NV value, NV min_in, NV max_in, NV min_out, NV max_out)
		1609	CODE:
		1610	RETVAL = lerp (value, min_in, max_in, min_out, max_out);
		1611	OUTPUT:
		1612	RETVAL
		1613
		1614	void weaken (...)
		1615	PROTOTYPE: @
		1616	CODE:
		1617	while (items > 0)
		1618	sv_rvweaken (ST (--items));
		1619
1429	void	1620	void
1430	LOG (int level, char *msg)	1621	log_backtrace (utf8_string msg)
		1622
		1623	void
		1624	LOG (int flags, utf8_string msg)
1431	PROTOTYPE: $$	1625	PROTOTYPE: $$
1432	C_ARGS: (LogLevel)level, "%s", msg	1626	C_ARGS: flags, "%s", msg
1433		1627
1434	char *path_combine (char *base, char *path)	1628	octet_string path_combine (octet_string base, octet_string path)
1435	PROTOTYPE: $$	1629	PROTOTYPE: $$
1436		1630
1437	char *path_combine_and_normalize (char *base, char *path)	1631	octet_string path_combine_and_normalize (octet_string base, octet_string path)
1438	PROTOTYPE: $$	1632	PROTOTYPE: $$
1439		1633
1440	char *	1634	void
1441	cf_get_maps_directory (char *path)	1635	mallinfo ()
1442	PROTOTYPE: $	1636	PPCODE:
1443	ALIAS: maps_directory = 0	1637	{
		1638	#if __GLIBC__
		1639	struct mallinfo mai = mallinfo ();
		1640	EXTEND (SP, 10*2);
		1641	PUSHs (sv_2mortal (newSVpv ("arena" , 0))); PUSHs (sv_2mortal (newSViv (mai.arena)));
		1642	PUSHs (sv_2mortal (newSVpv ("ordblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.ordblks)));
		1643	PUSHs (sv_2mortal (newSVpv ("smblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.smblks)));
		1644	PUSHs (sv_2mortal (newSVpv ("hblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblks)));
		1645	PUSHs (sv_2mortal (newSVpv ("hblkhd" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblkhd)));
		1646	PUSHs (sv_2mortal (newSVpv ("usmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.usmblks)));
		1647	PUSHs (sv_2mortal (newSVpv ("fsmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.fsmblks)));
		1648	PUSHs (sv_2mortal (newSVpv ("uordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.uordblks)));
		1649	PUSHs (sv_2mortal (newSVpv ("fordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.fordblks)));
		1650	PUSHs (sv_2mortal (newSVpv ("keepcost", 0))); PUSHs (sv_2mortal (newSViv (mai.keepcost)));
		1651	#endif
		1652	EXTEND (SP, 2*2);
		1653	PUSHs (sv_2mortal (newSVpv ("slice_alloc", 0))); PUSHs (sv_2mortal (newSVuv (slice_alloc)));
		1654	PUSHs (sv_2mortal (newSVpv ("shstr_alloc", 0))); PUSHs (sv_2mortal (newSVuv (shstr_alloc)));
		1655	}
1444		1656
1445	void	1657	void
1446	sub_generation_inc ()	1658	sub_generation_inc ()
1447	CODE:	1659	CODE:
1448	PL_sub_generation++;	1660	PL_sub_generation++;
1449		1661
1450	char *	1662	const_octet_string
1451	mapdir ()	1663	mapdir ()
1452	PROTOTYPE:	1664	PROTOTYPE:
1453	ALIAS:	1665	ALIAS:
1454	mapdir = 0	1666	mapdir = 0
1455	uniquedir = 1	1667	uniquedir = 1
…		…
1457	confdir = 3	1669	confdir = 3
1458	localdir = 4	1670	localdir = 4
1459	playerdir = 5	1671	playerdir = 5
1460	datadir = 6	1672	datadir = 6
1461	CODE:	1673	CODE:
1462	{	1674	switch (ix)
1463	int unused_type;	1675	{
1464	RETVAL = (char *)systemDirectory (&unused_type, ix);	1676	case 0: RETVAL = settings.mapdir ; break;
1465	}	1677	case 1: RETVAL = settings.uniquedir; break;
		1678	case 2: RETVAL = settings.tmpdir ; break;
		1679	case 3: RETVAL = settings.confdir ; break;
		1680	case 4: RETVAL = settings.localdir ; break;
		1681	case 5: RETVAL = settings.playerdir; break;
		1682	case 6: RETVAL = settings.datadir ; break;
		1683	}
1466	OUTPUT: RETVAL	1684	OUTPUT: RETVAL
1467		1685
1468	int	1686	void abort ()
1469	cf_find_animation (char *text)	1687
		1688	void reset_signals ()
		1689
		1690	void fork_abort (const_octet_string cause = "cf::fork_abort")
		1691
		1692	void cleanup (const_octet_string cause, bool make_core = false)
		1693
		1694	void emergency_save ()
		1695
		1696	void _exit (int status = EXIT_SUCCESS)
		1697
		1698	#if _POSIX_MEMLOCK
		1699
		1700	int mlockall (int flags = MCL_CURRENT | MCL_FUTURE)
		1701	INIT:
		1702	mallopt (M_PERTURB, 0xaa); // bug-workaround for linux glibc+mlockall+calloc
		1703
		1704	int munlockall ()
		1705
		1706	#endif
		1707
		1708	int find_animation (utf8_string text)
1470	PROTOTYPE: $	1709	PROTOTYPE: $
1471		1710
1472	int random_roll(int min, int max, object *op, int goodbad);	1711	int random_roll (int min, int max, object *op, int goodbad);
1473		1712
1474	const char *cost_string_from_value(uint64 cost, int approx = 0)	1713	const_utf8_string cost_string_from_value(uint64 cost, int approx = 0)
1475		1714
1476	int	1715	int
1477	exp_to_level (val64 exp)	1716	exp_to_level (val64 exp)
1478	CODE:	1717	CODE:
1479	{	1718	{
…		…
1510	RETVAL = newSVpv (resist_plus[atnr], 0);	1749	RETVAL = newSVpv (resist_plus[atnr], 0);
1511	else	1750	else
1512	XSRETURN_UNDEF;	1751	XSRETURN_UNDEF;
1513	OUTPUT: RETVAL	1752	OUTPUT: RETVAL
1514		1753
		1754	bool
		1755	load_resource_file (octet_string filename)
		1756
		1757	MODULE = cf PACKAGE = cf::attachable
		1758
		1759	int
		1760	valid (SV *obj)
		1761	CODE:
		1762	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
		1763	OUTPUT:
		1764	RETVAL
		1765
		1766	void
		1767	debug_trace (attachable *obj, bool on = true)
		1768	CODE:
		1769	obj->flags &= ~attachable::F_DEBUG_TRACE;
		1770	if (on)
		1771	obj->flags |= attachable::F_DEBUG_TRACE;
		1772
		1773	int mortals_size ()
		1774	CODE:
		1775	RETVAL = attachable::mortals.size ();
		1776	OUTPUT: RETVAL
		1777
		1778	#object *mortals (U32 index)
		1779	# CODE:
		1780	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;
		1781	# OUTPUT: RETVAL
		1782
		1783	INCLUDE: $PERL $srcdir/genacc attachable ../include/util.h ../include/cfperl.h |
		1784
		1785	MODULE = cf PACKAGE = cf::global
		1786
		1787	int invoke (SV *klass, int event, ...)
		1788	CODE:
		1789	if (KLASS_OF (event) != KLASS_GLOBAL) croak ("event class must be GLOBAL");
		1790	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
		1791	for (int i = 1; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
		1792	RETVAL = gbl_ev.invoke ((event_type)event, ARG_AV (av), DT_END);
		1793	OUTPUT: RETVAL
		1794
1515	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_	1795	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
1516		1796
1517	SV *	1797	INCLUDE: $PERL $srcdir/genacc object ../include/object.h |
1518	get_property (object *obj, int type, int idx)	1798
		1799	int invoke (object *op, int event, ...)
1519	CODE:	1800	CODE:
1520	RETVAL = newSVcfapi (type, cf_object_get_property (obj, idx));	1801	if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");
		1802	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
		1803	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
		1804	RETVAL = op->invoke ((event_type)event, ARG_AV (av), DT_END);
1521	OUTPUT: RETVAL	1805	OUTPUT: RETVAL
1522		1806
1523	SV *	1807	SV *registry (object *op)
1524	set_property (object *obj, int type, int idx, SV *newval)	1808
		1809	int objects_size ()
1525	CODE:	1810	CODE:
		1811	RETVAL = objects.size ();
		1812	OUTPUT: RETVAL
		1813
		1814	object *objects (U32 index)
		1815	CODE:
		1816	RETVAL = index < objects.size () ? objects [index] : 0;
		1817	OUTPUT: RETVAL
		1818
		1819	int actives_size ()
		1820	CODE:
		1821	RETVAL = actives.size ();
		1822	OUTPUT: RETVAL
		1823
		1824	object *actives (U32 index)
		1825	CODE:
		1826	RETVAL = index < actives.size () ? actives [index] : 0;
		1827	OUTPUT: RETVAL
		1828
		1829	const char *slot_use_name (U32 slot)
		1830	ALIAS:
		1831	slot_nonuse_name = 1
		1832	CODE:
		1833	{
		1834	if (slot >= NUM_BODY_LOCATIONS)
		1835	croak ("body slot index out of range");
		1836
1526	switch (type)	1837	switch (ix)
1527	{	1838	{
1528	case CFAPI_INT:	1839	case 0: RETVAL = body_locations[slot].use_name; break;
1529	cf_object_set_int_property (obj, idx, SvIV (newval));	1840	case 1: RETVAL = body_locations[slot].nonuse_name; break;
1530	break;
1531	case CFAPI_LONG:
1532	cf_object_set_long_property (obj, idx, (long) SvVAL64 (newval));
1533	break;
1534	case CFAPI_DOUBLE:
1535	{
1536	int unused_type;
1537	object_set_property (&unused_type, obj, idx, (double)SvNV (newval));
1538	}
1539	break;
1540	case CFAPI_STRING:
1541	cf_object_set_string_property (obj, idx, SvOK (newval) ? SvPV_nolen (newval) : 0);
1542	break;
1543	case CFAPI_POBJECT:
1544	{
1545	int unused_type;
1546	object_set_property (&unused_type, obj, idx, (object *)SvPTR_ornull (newval, "cf::object"));
1547	}
1548	break;
1549	default:
1550	croak ("unhandled type '%d' in set_property '%d'", type, idx);
1551	}	1841	}
		1842	}
		1843	OUTPUT:
		1844	RETVAL
1552		1845
1553	# missing properties	1846	# missing properties
1554		1847
1555	void	1848	object *head (object *op)
1556	set_attacktype (object *obj, U32 attacktype)	1849	PROTOTYPE: $
1557	CODE:	1850	CODE:
1558	obj->attacktype = attacktype;	1851	RETVAL = op->head_ ();
1559
1560	U32
1561	get_attacktype (object *obj)
1562	ALIAS:
1563	attacktype = 0
1564	CODE:
1565	RETVAL = obj->attacktype;
1566	OUTPUT: RETVAL	1852	OUTPUT: RETVAL
1567
1568	# missing in plug-in api, of course
1569	void
1570	set_food (object *obj, int food)
1571	CODE:
1572	obj->stats.food = food;
1573
1574	int
1575	get_food (object *obj)
1576	ALIAS:
1577	food = 0
1578	CODE:
1579	RETVAL = obj->stats.food;
1580	OUTPUT: RETVAL
1581		1853
1582	void	1854	void
1583	inv (object *obj)	1855	inv (object *obj)
1584	PROTOTYPE: $	1856	PROTOTYPE: $
1585	PPCODE:	1857	PPCODE:
1586	{	1858	{
1587	object *o;
1588	for (o = obj->inv; o; o = o->below)	1859	for (object *o = obj->inv; o; o = o->below)
1589	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));	1860	XPUSHs (sv_2mortal (to_sv (o)));
1590	}	1861	}
1591		1862
1592	int cf_object_get_resistance (object *op, int rtype)	1863	void
1593	ALIAS: resistance = 0	1864	set_animation (object *op, int idx)
		1865	CODE:
		1866	SET_ANIMATION (op, idx);
1594		1867
1595	int cf_object_get_flag (object *op, int flag)	1868	int
1596	ALIAS: flag = 0	1869	num_animations (object *op)
		1870	CODE:
		1871	RETVAL = NUM_ANIMATIONS (op);
		1872	OUTPUT: RETVAL
1597		1873
1598	void cf_object_set_flag (object *op, int flag, int value)	1874	int slot_info (object *op, UV slot, int value = 0)
		1875	ALIAS:
		1876	slot_used = 1
		1877	CODE:
		1878	{
		1879	if (slot >= NUM_BODY_LOCATIONS)
		1880	croak ("body slot index out of range");
1599		1881
		1882	RETVAL = ix ? op->slot[slot].used : op->slot[slot].info;
		1883
		1884	if (items > 2)
		1885	if (ix)
		1886	op->slot[slot].used = value;
		1887	else
		1888	op->slot[slot].info = value;
		1889	}
		1890	OUTPUT:
		1891	RETVAL
		1892
		1893	object *find_best_object_match (object *op, utf8_string match)
		1894
		1895	object *find_marked_object (object *op)
		1896
1600	int need_identify (const object *obj);	1897	int need_identify (object *obj);
1601		1898
1602	int apply_shop_mat (object *shop_mat, object *op);	1899	int apply_shop_mat (object *shop_mat, object *op);
1603		1900
1604	void cf_object_move (object *op, int dir, object *originator = op)	1901	int move (object *op, int dir, object *originator = op)
		1902	CODE:
		1903	RETVAL = move_ob (op, dir, originator);
		1904	OUTPUT:
		1905	RETVAL
1605		1906
1606	void cf_object_apply (object *op, object *author, int flags = 0)	1907	void apply (object *applier, object *applied, int flags = 0)
		1908	CODE:
		1909	manual_apply (applied, applier, flags);
1607		1910
1608	void cf_object_apply_below (object *op)	1911	void apply_below (object *op)
		1912	CODE:
		1913	player_apply_below (op);
1609		1914
1610	void cf_object_remove (object *op)	1915	int cast_heal (object *op, object *caster, object *spell, int dir = 0)
1611		1916
1612	void cf_object_free (object *op)	1917	#//TODO
1613
1614	object *cf_object_present_archname_inside (object *op, char *whatstr)
1615
1616	int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)
1617
1618	int cf_object_change_map (object *op, int x, int y, mapstruct *map)
1619
1620	object *cf_object_clone (object *op, int clonetype = 0)	1918	object *clone_ (object *op, int recursive = 0)
		1919	CODE:
		1920	if (recursive)
		1921	RETVAL = object_create_clone (op);
		1922	else
		1923	{
		1924	RETVAL = object::create ();
		1925	op->copy_to (RETVAL);
		1926	}
		1927	OUTPUT: RETVAL
1621		1928
1622	int cf_object_pay_item (object *op, object *buyer)	1929	int pay_item (object *op, object *buyer)
		1930	CODE:
		1931	RETVAL = pay_for_item (op, buyer);
		1932	OUTPUT: RETVAL
1623		1933
1624	int cf_object_pay_amount (object *op, uint64 amount)	1934	int pay_amount (object *op, uint64 amount)
		1935	CODE:
		1936	RETVAL = pay_for_amount (amount, op);
		1937	OUTPUT: RETVAL
1625		1938
1626	void pay_player (object *op, uint64 amount)	1939	void pay_player (object *op, uint64 amount)
1627		1940
1628	val64 pay_player_arch (object *op, const char *arch, uint64 amount)	1941	val64 pay_player_arch (object *op, utf8_string arch, uint64 amount)
1629		1942
1630	int cf_object_cast_spell (object *caster, object *ctoo, int dir, object *spell_ob, char *stringarg = 0)	1943	int cast_spell (object *op, object *caster, int dir, object *spell_ob, utf8_string stringarg = 0)
1631		1944
1632	int cf_object_cast_ability (object *caster, object *ctoo, int dir, object *sp_, char *stringarg = 0)	1945	void learn_spell (object *op, object *sp, int special_prayer = 0)
		1946	CODE:
		1947	do_learn_spell (op, sp, special_prayer);
1633		1948
1634	void cf_object_learn_spell (object *op, object *sp)
1635
1636	void cf_object_forget_spell (object *op, object *sp)	1949	void forget_spell (object *op, object *sp)
		1950	CODE:
		1951	do_forget_spell (op, query_name (sp));
1637		1952
1638	object *cf_object_check_for_spell (object *op, char *spellname)	1953	object *check_for_spell (object *op, utf8_string spellname)
		1954	CODE:
		1955	RETVAL = check_spell_known (op, spellname);
		1956	OUTPUT: RETVAL
1639		1957
1640	int cf_object_query_money (object *op)	1958	int query_money (object *op)
1641	ALIAS: money = 0	1959	ALIAS: money = 0
1642		1960
1643	int cf_object_query_cost (object *op, object *who, int flags)	1961	val64 query_cost (object *op, object *who, int flags)
1644	ALIAS: cost = 0	1962	ALIAS: cost = 0
1645		1963
1646	void cf_object_activate_rune (object *op , object *victim)	1964	void spring_trap (object *op, object *victim)
1647		1965
1648	int cf_object_check_trigger (object *op, object *cause)	1966	int check_trigger (object *op, object *cause)
1649		1967
1650	int cf_object_out_of_map (object *op, int x, int y)
1651
1652	void cf_object_drop (object *op, object *author)	1968	void drop (object *who, object *op)
1653		1969
1654	void cf_object_take (object *op, object *author)
1655
1656	void cf_object_say (object *op, char *msg)
1657
1658	void cf_object_speak (object *op, char *msg)
1659
1660	object *cf_object_insert_object (object *op, object *container)
1661
1662	const char *cf_object_get_msg (object *ob)
1663	ALIAS: msg = 0
1664
1665	object *cf_object_insert_in_ob (object *ob, object *where)
1666
1667	int cf_object_teleport (object *op, mapstruct *map, int x, int y)
1668
1669	void cf_object_update (object *op, int flags)
1670
1671	void cf_object_pickup (object *op, object *what)	1970	void pick_up (object *who, object *op)
1672		1971
1673	object *cf_create_object_by_name (const char *name)	1972	void update_object (object *op, int action)
1674		1973
1675	void change_exp (object *op, uint64 exp, const char *skill_name = 0, int flag = 0)	1974	void change_exp (object *op, uint64 exp, utf8_string skill_name = 0, int flag = 0)
1676		1975
1677	void player_lvl_adj (object *who, object *skill = 0)	1976	void player_lvl_adj (object *who, object *skill = 0)
1678		1977
1679	int kill_object (object *op, int dam = 0, object *hitter = 0, int type = AT_PHYSICAL)	1978	int kill_object (object *op, int dam = 0, object *hitter = 0, int type = AT_PHYSICAL)
1680		1979
…		…
1682		1981
1683	void push_button (object *op);	1982	void push_button (object *op);
1684		1983
1685	void use_trigger (object *op);	1984	void use_trigger (object *op);
1686		1985
1687	void add_button_link (object *button, mapstruct *map, int connected);	1986	void add_button_link (object *button, maptile *map, int connected);
1688		1987
1689	void remove_button_link (object *op);	1988	void remove_button_link (object *op);
1690		1989
1691	void	1990	void handle_apply_yield (object *op);
1692	cf_object_set_resistance (object *op, int rtype, int val)
1693	CODE:
1694	if (rtype >= 0 && rtype < NROFATTACKS)
1695	op->resist[rtype] = val;
1696		1991
1697		1992
1698	MODULE = cf PACKAGE = cf::object PREFIX = cf_	1993	MODULE = cf PACKAGE = cf::object PREFIX = cf_
1699
1700	void cf_fix_object (object *pl)
1701	ALIAS: fix = 0
1702
1703	object *cf_insert_ob_in_ob (object *ob, object *where)
1704		1994
1705	# no clean way to get an object from an archetype - stupid idiotic	1995	# no clean way to get an object from an archetype - stupid idiotic
1706	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.	1996	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.
1707		1997
1708	object *new (const char *archetype = 0)	1998	object *new (utf8_string archetype = 0)
1709	PROTOTYPE: ;$	1999	PROTOTYPE: ;$
1710	CODE:	2000	CODE:
1711	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();	2001	RETVAL = archetype ? get_archetype (archetype) : object::create ();
1712	OUTPUT:	2002	OUTPUT:
1713	RETVAL	2003	RETVAL
1714		2004
		2005	object *find_object (U32 tag)
		2006
		2007	# TODO: nuke
1715	object *insert_ob_in_map_at (object *ob, mapstruct *where, object_ornull *orig, int flag, int x, int y)	2008	object *insert_ob_in_map_at (object *ob, maptile *where, object_ornull *orig, int flag, int x, int y)
1716	PROTOTYPE: $$$$$$	2009	PROTOTYPE: $$$$$$
1717	CODE:	2010	CODE:
1718	{	2011	{
1719	int unused_type;	2012	RETVAL = insert_ob_in_map_at (ob, where, orig, flag, x, y);
1720	RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);
1721	}	2013	}
1722		2014
1723	# syntatic sugar for easier use in event callbacks.	2015	const_utf8_string get_ob_key_value (object *op, utf8_string key)
1724	const char *options (object *op)
1725	CODE:
1726	RETVAL = op->name;
1727	OUTPUT:
1728	RETVAL
1729		2016
1730	player *contr (object *op)
1731	CODE:
1732	RETVAL = op->contr;
1733	OUTPUT: RETVAL
1734
1735	const char *get_ob_key_value (object *op, const char *key)
1736
1737	bool set_ob_key_value (object *op, const char *key, const char *value = 0, int add_key = 1)	2017	bool set_ob_key_value (object *op, utf8_string key, utf8_string value = 0, int add_key = 1)
1738		2018
1739	object *get_nearest_player (object *ob)	2019	object *get_nearest_player (object *ob)
1740	ALIAS: nearest_player = 0	2020	ALIAS: nearest_player = 0
1741	PREINIT:	2021	PREINIT:
1742	extern object *get_nearest_player (object *);	2022	extern object *get_nearest_player (object *);
…		…
1750	EXTEND (SP, 5);	2030	EXTEND (SP, 5);
1751	PUSHs (newSVuv (rv.distance));	2031	PUSHs (newSVuv (rv.distance));
1752	PUSHs (newSViv (rv.distance_x));	2032	PUSHs (newSViv (rv.distance_x));
1753	PUSHs (newSViv (rv.distance_y));	2033	PUSHs (newSViv (rv.distance_y));
1754	PUSHs (newSViv (rv.direction));	2034	PUSHs (newSViv (rv.direction));
1755	PUSHs (newSVcfapi (CFAPI_POBJECT, rv.part));	2035	PUSHs (to_sv (rv.part));
1756	}	2036	}
1757		2037
1758	bool on_same_map_as (object *ob, object *other)	2038	bool on_same_map_as (object *ob, object *other)
1759	CODE:	2039	CODE:
1760	RETVAL = on_same_map (ob, other);	2040	RETVAL = on_same_map (ob, other);
1761	OUTPUT: RETVAL	2041	OUTPUT: RETVAL
1762		2042
1763	char *	2043	const_utf8_string
1764	base_name (object *ob, int plural)	2044	base_name (object *op, int plural = op->nrof > 1)
1765	CODE:	2045	CODE:
1766	RETVAL = cf_query_base_name (ob, plural);	2046	RETVAL = query_base_name (op, plural);
1767	OUTPUT: RETVAL	2047	OUTPUT: RETVAL
1768		2048
1769	living *	2049	object *decrease_ob_nr (object *op, unsigned long i)
		2050
		2051	# return the tail of an object, excluding itself
		2052	void
1770	stats (object *ob)	2053	tail (object *op)
1771	CODE:	2054	PPCODE:
1772	RETVAL = &ob->stats;	2055	while ((op = op->more))
1773	OUTPUT: RETVAL	2056	XPUSHs (sv_2mortal (to_sv (op)));
1774
1775		2057
1776	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_	2058	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_
1777		2059
1778	player *player (object *op)	2060	player *player (object *op)
1779	CODE:	2061	CODE:
1780	RETVAL = op->contr;	2062	RETVAL = op->contr;
1781	OUTPUT: RETVAL	2063	OUTPUT: RETVAL
1782		2064
		2065	bool move_player (object *op, int dir)
		2066
		2067	void check_score (object *op)
		2068
1783	void cf_player_message (object *obj, char *txt, int flags = NDI_ORANGE | NDI_UNIQUE)	2069	void message (object *op, utf8_string txt, int flags = NDI_ORANGE | NDI_UNIQUE)
1784		2070	CODE:
1785	object *cf_player_send_inventory (object *op)	2071	new_draw_info (flags, 0, op, txt);
1786
1787	char *cf_player_get_ip (object *op)
1788	ALIAS: ip = 0
1789
1790	object *cf_player_get_marked_item (object *op)
1791	ALIAS: marked_item = 0
1792
1793	void cf_player_set_marked_item (object *op, object *ob)
1794
1795	partylist *cf_player_get_party (object *op)
1796	ALIAS: party = 0
1797
1798	void cf_player_set_party (object *op, partylist *party)
1799		2072
1800	void kill_player (object *op)	2073	void kill_player (object *op)
1801		2074
1802	MODULE = cf PACKAGE = cf::object::map PREFIX = cf_	2075	void esrv_send_item (object *pl, object *item)
		2076
		2077	void esrv_update_item (object *pl, int what, object *item)
		2078	C_ARGS: what, pl, item
		2079
		2080	void esrv_del_item (object *pl, int tag)
		2081	C_ARGS: pl->contr, tag
		2082
		2083	int command_summon (object *op, utf8_string params)
		2084
		2085	int command_arrest (object *op, utf8_string params)
		2086
1803		2087
1804	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_	2088	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
1805		2089
1806	player *cf_player_find (char *name)	2090	INCLUDE: $PERL $srcdir/genacc player ../include/player.h |
1807	PROTOTYPE: $
1808		2091
1809	void cf_player_move (player *pl, int dir)	2092	int invoke (player *pl, int event, ...)
1810
1811	void MapNewmapCmd (player *pl)
1812
1813	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);
1814
1815	# nonstandard
1816	object *ob (player *pl)
1817	CODE:	2093	CODE:
1818	RETVAL = pl->ob;	2094	if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");
		2095	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
		2096	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
		2097	RETVAL = pl->invoke ((event_type)event, ARG_AV (av), DT_END);
1819	OUTPUT: RETVAL	2098	OUTPUT: RETVAL
1820		2099
1821	player *first ()	2100	SV *registry (player *pl)
1822	CODE:
1823	RETVAL = first_player;
1824	OUTPUT: RETVAL
1825		2101
1826	player *next (player *pl)	2102	void
		2103	save_stats (player *pl)
1827	CODE:	2104	CODE:
1828	RETVAL = pl->next;	2105	pl->ob->stats.hp = pl->ob->stats.maxhp;
1829	OUTPUT: RETVAL	2106	pl->ob->stats.sp = pl->ob->stats.maxsp;
		2107	pl->ob->stats.grace = pl->ob->stats.maxgrace;
		2108	pl->orig_stats = pl->ob->stats;
		2109
		2110	void clear_los (player *pl)
1830		2111
1831	bool	2112	bool
1832	cell_visible (player *pl, int dx, int dy)	2113	cell_visible (player *pl, int dx, int dy)
1833	CODE:	2114	CODE:
1834	RETVAL = FABS (dx) <= pl->socket.mapx / 2 && FABS (dy) <= pl->socket.mapy / 2	2115	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2
1835	&& !pl->blocked_los [dx + pl->socket.mapx / 2][dy + pl->socket.mapy / 2];	2116	&& !pl->blocked_los [dx + pl->ns->mapx / 2][dy + pl->ns->mapy / 2];
1836	OUTPUT:	2117	OUTPUT:
1837	RETVAL	2118	RETVAL
1838		2119
1839	void	2120	void
1840	send (player *pl, SV *packet)	2121	send (player *pl, SV *packet)
1841	CODE:	2122	CODE:
1842	{	2123	{
1843	STRLEN len;	2124	STRLEN len;
1844	char *buf = SvPVbyte (packet, len);	2125	char *buf = SvPVbyte (packet, len);
1845		2126
1846	Write_String_To_Socket (&pl->socket, buf, len);	2127	if (len > MAXSOCKBUF)
		2128	pl->failmsg ("[packet too long for client]");
		2129	else if (pl->ns)
		2130	pl->ns->send_packet (buf, len);
1847	}	2131	}
1848		2132
1849	int	2133	int
1850	listening (player *pl, int new_value = -1)	2134	listening (player *pl, int new_value = -1)
1851	CODE:	2135	CODE:
…		…
1853	if (new_value >= 0)	2137	if (new_value >= 0)
1854	pl->listening = new_value;	2138	pl->listening = new_value;
1855	OUTPUT:	2139	OUTPUT:
1856	RETVAL	2140	RETVAL
1857		2141
1858	void get_savebed (player *pl)	2142	void savebed (player *pl, SV *map_path = 0, SV *x = 0, SV *y = 0)
1859	ALIAS:	2143	PROTOTYPE: $;$$$
1860	savebed = 0
1861	PPCODE:	2144	PPCODE:
		2145	if (GIMME_V != G_VOID)
		2146	{
1862	EXTEND (SP, 3);	2147	EXTEND (SP, 3);
1863	PUSHs (sv_2mortal (newSVpv (pl->savebed_map, 0)));	2148	PUSHs (sv_2mortal (newSVpv (pl->savebed_map, 0)));
1864	PUSHs (sv_2mortal (newSViv (pl->bed_x)));	2149	PUSHs (sv_2mortal (newSViv (pl->bed_x)));
1865	PUSHs (sv_2mortal (newSViv (pl->bed_y)));	2150	PUSHs (sv_2mortal (newSViv (pl->bed_y)));
1866		2151	}
1867	void set_savebed (player *pl, char *map_path, int x, int y)	2152	if (map_path) sv_to (map_path, pl->savebed_map);
1868	CODE:	2153	if (x) sv_to (x, pl->bed_x);
1869	strcpy (pl->savebed_map, map_path);	2154	if (y) sv_to (y, pl->bed_y);
1870	pl->bed_x = x;
1871	pl->bed_y = y;
1872		2155
1873	void	2156	void
1874	list ()	2157	list ()
1875	PPCODE:	2158	PPCODE:
1876	{	2159	for_all_players (pl)
1877	player *pl;	2160	XPUSHs (sv_2mortal (to_sv (pl)));
1878	for (pl = first_player; pl; pl = pl->next)
1879	XPUSHs (newSVcfapi (CFAPI_PPLAYER, pl));
1880	}
1881
1882	bool
1883	peaceful (player *pl, bool new_setting = 0)
1884	PROTOTYPE: $;$
1885	CODE:
1886	RETVAL = pl->peaceful;
1887	if (items > 1)
1888	pl->peaceful = new_setting;
1889	OUTPUT:
1890	RETVAL
1891
1892	living *
1893	orig_stats (player *pl)
1894	CODE:
1895	RETVAL = &pl->orig_stats;
1896	OUTPUT: RETVAL
1897
1898	living *
1899	last_stats (player *pl)
1900	CODE:
1901	RETVAL = &pl->last_stats;
1902	OUTPUT: RETVAL
1903		2161
1904		2162
1905	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_	2163	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_
1906		2164
1907	SV *	2165	int invoke (maptile *map, int event, ...)
1908	get_property (mapstruct *obj, int type, int idx)
1909	CODE:	2166	CODE:
1910	RETVAL = newSVcfapi (type, cf_map_get_property (obj, idx));	2167	if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");
		2168	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
		2169	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
		2170	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);
1911	OUTPUT: RETVAL	2171	OUTPUT: RETVAL
1912		2172
1913	SV *	2173	SV *registry (maptile *map)
1914	set_property (mapstruct *obj, int type, int idx, SV *newval)	2174
		2175	void
		2176	find_tagged_objects (maptile *map, utf8_string tag = 0)
1915	CODE:	2177	PPCODE:
1916	switch (type)	2178	{
		2179	if (!map->spaces)
		2180	XSRETURN_EMPTY;
		2181
		2182	if (tag)
1917	{	2183	{
1918	case CFAPI_INT:	2184	shstr_cmp tag_ (tag);
1919	cf_map_set_int_property (obj, idx, SvIV (newval));	2185
1920	break;	2186	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
1921	default:	2187	for (object *op = ms->bot; op; op = op->above)
1922	croak ("unhandled type '%d' in set_property '%d'", type, idx);	2188	if (op->tag == tag_)
		2189	XPUSHs (sv_2mortal (to_sv (op)));
1923	}	2190	}
		2191	else
		2192	{
		2193	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2194	for (object *op = ms->bot; op; op = op->above)
		2195	if (op->tag)
		2196	XPUSHs (sv_2mortal (to_sv (op)));
		2197	}
		2198	}
1924		2199
1925	mapstruct *new (int width, int height)	2200	INCLUDE: $PERL $srcdir/genacc maptile ../include/map.h |
		2201
		2202	void
		2203	maptile::instantiate ()
		2204
		2205	maptile *new ()
1926	PROTOTYPE:	2206	PROTOTYPE:
1927	CODE:	2207	CODE:
1928	{	2208	RETVAL = new maptile;
1929	int unused_type;
1930	RETVAL = (mapstruct*) map_get_map (&unused_type, 0, width, height);
1931	}
1932	OUTPUT:	2209	OUTPUT:
1933	RETVAL	2210	RETVAL
1934		2211
1935	void delete_map (mapstruct *map)
1936
1937	void clean_tmp_map (mapstruct *map)
1938
1939	void play_sound_map (mapstruct *map, int x, int y, int sound_num)
1940
1941	mapstruct *tile_map (mapstruct *map, unsigned int dir)
1942	CODE:
1943	RETVAL = dir < 4 ? map->tile_map [dir] : 0;
1944	OUTPUT:
1945	RETVAL
1946
1947	char *tile_path (mapstruct *map, unsigned int dir)
1948	CODE:
1949	if (dir >= 4)
1950	XSRETURN_UNDEF;
1951	RETVAL = map->tile_path [dir];
1952	OUTPUT:
1953	RETVAL
1954
1955	mapstruct *cf_map_get_map (char *name)
1956	PROTOTYPE: $
1957	ALIAS: map = 0
1958
1959	mapstruct *has_been_loaded (char *name)
1960	PROTOTYPE: $
1961
1962	mapstruct *cf_map_get_first ()
1963	PROTOTYPE:
1964	ALIAS: first = 0
1965
1966	# whoever "designed" the plug-in api should have wasted
1967	# his/her time with staying away from the project - would have
1968	# saved others a lot of time, without doubt.
1969	void set_path (mapstruct *where, char *path)
1970	CODE:
1971	strcpy (where->path, path);
1972
1973	int in_memory (mapstruct *map)
1974	CODE:
1975	RETVAL = map->in_memory;
1976	OUTPUT:
1977	RETVAL
1978
1979	bool unique (mapstruct *map)
1980	CODE:
1981	RETVAL = map->unique;
1982	OUTPUT:
1983	RETVAL
1984
1985	void set_unique (mapstruct *map, bool unique)
1986	CODE:
1987	map->unique = unique;
1988
1989	object *cf_map_insert_object_there (mapstruct *where, object *op, object *originator, int flags)
1990
1991	object *cf_map_insert_object (mapstruct *where, object* op, int x, int y)
1992
1993	object* cf_map_present_arch_by_name (mapstruct *map, const char* str, int nx, int ny)
1994	C_ARGS: str, map, nx, ny
1995
1996	void	2212	void
1997	cf_map_normalise (mapstruct *map, int x, int y)	2213	maptile::players ()
1998	PPCODE:	2214	PPCODE:
		2215	if (GIMME_V == G_SCALAR)
		2216	XPUSHs (sv_2mortal (to_sv (THIS->players)));
		2217	else if (GIMME_V == G_ARRAY)
		2218	{
		2219	EXTEND (SP, THIS->players);
		2220	for_all_players (pl)
		2221	if (pl->ob && pl->ob->map == THIS)
		2222	PUSHs (sv_2mortal (to_sv (pl->ob)));
		2223	}
		2224
		2225	void
		2226	maptile::add_underlay (SV *data, int offset, int stride, SV *palette)
		2227	CODE:
1999	{	2228	{
		2229	if (!SvROK (palette) || SvTYPE (SvRV (palette)) != SVt_PVAV)
		2230	croak ("maptile::add_underlay: palette must be arrayref");
		2231
		2232	palette = SvRV (palette);
		2233
		2234	STRLEN idxlen;
		2235	const uint8_t *idx = (const uint8_t *)SvPVbyte (data, idxlen);
		2236
		2237	for (int x = 0; x < THIS->width; ++x)
		2238	for (int y = 0; y < THIS->height; ++y)
		2239	{
		2240	for (object *op = THIS->at (x, y).bot; op; op = op->above)
		2241	if (op->flag [FLAG_IS_FLOOR])
		2242	goto skip_space;
		2243
		2244	{
		2245	int offs = offset + y * stride + x;
		2246	if (IN_RANGE_EXC (offs, 0, idxlen))
		2247	{
		2248	if (SV **elem = av_fetch ((AV *)palette, idx [offs], 0))
		2249	{
		2250	object *ob = get_archetype (SvPVutf8_nolen (*elem));
		2251	ob->flag [FLAG_NO_MAP_SAVE] = true;
		2252	THIS->insert (ob, x, y, 0, INS_ABOVE_FLOOR_ONLY);
		2253
		2254	if (ob->randomitems)
		2255	{
		2256	if (!ob->above)
		2257	{
		2258	ob->create_treasure (ob->randomitems);
		2259
		2260	for (object *op = ob->above; op; op = op->above)
		2261	op->flag [FLAG_NO_MAP_SAVE] = true;
		2262	}
		2263
		2264	ob->randomitems = 0;
		2265	}
		2266	}
		2267	}
		2268	}
		2269
		2270	skip_space: ;
		2271	}
		2272	}
		2273
		2274	void
		2275	maptile::set_regiondata (SV *data, int offset, int stride, SV *palette)
		2276	CODE:
		2277	{
		2278	if (!SvROK (palette) || SvTYPE (SvRV (palette)) != SVt_PVAV)
		2279	croak ("maptile::set_regiondata: palette must be arrayref");
		2280
		2281	palette = SvRV (palette);
		2282
		2283	STRLEN idxlen;
		2284	const uint8_t *idx = (const uint8_t *)SvPVbyte (data, idxlen);
		2285
		2286	region_ptr *regionmap = new region_ptr [av_len ((AV *)palette) + 1];
		2287	uint8_t *regions = salloc<uint8_t> (THIS->size ());
		2288
		2289	for (int i = av_len ((AV *)palette) + 1; i--; )
		2290	regionmap [i] = region::find (SvPVutf8_nolen (*av_fetch ((AV *)palette, i, 1)));
		2291
		2292	for (int y = 0; y < THIS->height; ++y)
		2293	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);
		2294
		2295	sfree (THIS->regions, THIS->size ());
		2296	delete [] THIS->regionmap;
		2297
		2298	THIS->regions = regions;
		2299	THIS->regionmap = regionmap;
		2300	}
		2301
		2302	void
		2303	maptile::create_region_treasure ()
		2304	CODE:
		2305	{
		2306	object *op = object::create ();
		2307	op->type = FLOOR;
		2308	op->map = THIS;
		2309
		2310	for (int x = 0; x < THIS->width; ++x)
		2311	for (int y = 0; y < THIS->height; ++y)
		2312	{
		2313	region *rgn = THIS->region (x, y);
		2314
		2315	//fprintf (stderr, "%d,%d %f %p\n", x, y, rgn->treasure_density,rgn->treasure);//D
		2316	if (rgn->treasure && rndm () < rgn->treasure_density)
		2317	{
		2318	op->x = x;
		2319	op->y = y;
		2320	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);
		2321	}
		2322	}
		2323
		2324	op->destroy ();
		2325	}
		2326
		2327	int out_of_map (maptile *map, int x, int y)
		2328
		2329	void
		2330	trigger (maptile *map, long connection, bool state = true)
		2331	CODE:
		2332	activate_connection (map, connection, state);
		2333
		2334	void
		2335	get_connection (maptile *map, long connection)
		2336	PPCODE:
		2337	oblinkpt *obp = get_connection_links (map, connection);
		2338	if (obp)
		2339	for (objectlink *ol = obp->link; ol; ol = ol->next)
		2340	XPUSHs (sv_2mortal (to_sv ((object *)ol->ob)));
		2341
		2342	void
		2343	get_map_flags (maptile *map, int x, int y)
		2344	PPCODE:
		2345	{
2000	mapstruct *nmap = 0;	2346	maptile *nmap = 0;
2001	I16 nx = 0, ny = 0;	2347	I16 nx = 0, ny = 0;
2002	int flags = cf_map_get_flags (map, &nmap, x, y, &nx, &ny);	2348	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
2003		2349
2004	EXTEND (SP, 4);	2350	EXTEND (SP, 4);
2005	PUSHs (sv_2mortal (newSViv (flags)));	2351	PUSHs (sv_2mortal (newSViv (flags)));
2006		2352
2007	if (GIMME_V == G_ARRAY)	2353	if (GIMME_V == G_ARRAY)
2008	{	2354	{
2009	PUSHs (sv_2mortal (newSVcfapi (CFAPI_PMAP, nmap)));	2355	PUSHs (sv_2mortal (to_sv (nmap)));
2010	PUSHs (sv_2mortal (newSViv (nx)));	2356	PUSHs (sv_2mortal (newSViv (nx)));
2011	PUSHs (sv_2mortal (newSViv (ny)));	2357	PUSHs (sv_2mortal (newSViv (ny)));
2012	}	2358	}
2013	}	2359	}
2014		2360
2015	void	2361	void
2016	at (mapstruct *map, unsigned int x, unsigned int y)	2362	at (maptile *map, unsigned int x, unsigned int y)
2017	PROTOTYPE: $$$	2363	PROTOTYPE: $$$
2018	PPCODE:	2364	PPCODE:
2019	{	2365	{
2020	object *o;	2366	object *o;
2021	mapstruct *nmap = 0;	2367	maptile *nmap = 0;
2022	I16 nx, ny;	2368	I16 nx, ny;
2023		2369
2024	cf_map_get_flags (map, &nmap, x, y, &nx, &ny);	2370	get_map_flags (map, &nmap, x, y, &nx, &ny);
2025		2371
2026	if (nmap)	2372	if (nmap)
2027	for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)	2373	for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)
2028	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));	2374	XPUSHs (sv_2mortal (to_sv (o)));
2029	}	2375	}
2030		2376
2031	SV *	2377	SV *
2032	bot_at (mapstruct *obj, unsigned int x, unsigned int y)	2378	bot_at (maptile *obj, unsigned int x, unsigned int y)
2033	PROTOTYPE: $$$	2379	PROTOTYPE: $$$
2034	ALIAS:	2380	ALIAS:
2035	top_at = 1	2381	top_at = 1
2036	flags_at = 2	2382	flags_at = 2
2037	light_at = 3	2383	light_at = 3
2038	move_block_at = 4	2384	move_block_at = 4
2039	move_slow_at = 5	2385	move_slow_at = 5
2040	move_on_at = 6	2386	move_on_at = 6
2041	move_off_at = 7	2387	move_off_at = 7
2042	INIT:	2388	INIT:
2043	if (x >= MAP_WIDTH (obj) || y >= MAP_HEIGHT (obj)) XSRETURN_UNDEF;	2389	if (x >= obj->width || y >= obj->height) XSRETURN_UNDEF;
2044	CODE:	2390	CODE:
2045	switch (ix)	2391	switch (ix)
2046	{	2392	{
2047	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;	2393	case 0: RETVAL = to_sv (GET_MAP_OB (obj, x, y)); break;
2048	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;	2394	case 1: RETVAL = to_sv (GET_MAP_TOP (obj, x, y)); break;
2049	case 2: RETVAL = newSVuv ( GET_MAP_FLAGS (obj, x, y)); break;	2395	case 2: RETVAL = newSVuv (GET_MAP_FLAGS (obj, x, y)); break;
2050	case 3: RETVAL = newSViv ( GET_MAP_LIGHT (obj, x, y)); break;	2396	case 3: RETVAL = newSViv (GET_MAP_LIGHT (obj, x, y)); break;
2051	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;	2397	case 4: RETVAL = newSVuv (GET_MAP_MOVE_BLOCK (obj, x, y)); break;
2052	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;	2398	case 5: RETVAL = newSVuv (GET_MAP_MOVE_SLOW (obj, x, y)); break;
2053	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;	2399	case 6: RETVAL = newSVuv (GET_MAP_MOVE_ON (obj, x, y)); break;
2054	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;	2400	case 7: RETVAL = newSVuv (GET_MAP_MOVE_OFF (obj, x, y)); break;
2055	}	2401	}
2056	OUTPUT:	2402	OUTPUT: RETVAL
		2403
		2404	void fix_walls (maptile *map, int x, int y)
		2405
		2406	void fix_walls_around (maptile *map, int x, int y)
		2407
		2408	# worst xs function of my life
		2409	bool
		2410	_create_random_map (\
		2411	maptile *self,\
		2412	utf8_string wallstyle,\
		2413	utf8_string wall_name,\
		2414	utf8_string floorstyle,\
		2415	utf8_string monsterstyle,\
		2416	utf8_string treasurestyle,\
		2417	utf8_string layoutstyle,\
		2418	utf8_string doorstyle,\
		2419	utf8_string decorstyle,\
		2420	utf8_string origin_map,\
		2421	utf8_string final_map,\
		2422	utf8_string exitstyle,\
		2423	utf8_string this_map,\
		2424	utf8_string exit_on_final_map,\
		2425	int xsize,\
		2426	int ysize,\
		2427	int expand2x,\
		2428	int layoutoptions1,\
		2429	int layoutoptions2,\
		2430	int layoutoptions3,\
		2431	int symmetry,\
		2432	int difficulty,\
		2433	int difficulty_given,\
		2434	float difficulty_increase,\
		2435	int dungeon_level,\
		2436	int dungeon_depth,\
		2437	int decoroptions,\
		2438	int orientation,\
		2439	int origin_y,\
		2440	int origin_x,\
		2441	U32 random_seed,\
		2442	val64 total_map_hp,\
		2443	int map_layout_style,\
		2444	int treasureoptions,\
		2445	int symmetry_used,\
		2446	region *region,\
		2447	utf8_string custom\
		2448	)
		2449	CODE:
		2450	{
		2451	random_map_params rmp;
		2452
		2453	assign (rmp.wallstyle , wallstyle);
		2454	assign (rmp.wall_name , wall_name);
		2455	assign (rmp.floorstyle , floorstyle);
		2456	assign (rmp.monsterstyle , monsterstyle);
		2457	assign (rmp.treasurestyle , treasurestyle);
		2458	assign (rmp.layoutstyle , layoutstyle);
		2459	assign (rmp.doorstyle , doorstyle);
		2460	assign (rmp.decorstyle , decorstyle);
		2461	assign (rmp.exitstyle , exitstyle);
		2462	assign (rmp.exit_on_final_map, exit_on_final_map);
		2463
		2464	rmp.origin_map = origin_map;
		2465	rmp.final_map = final_map;
		2466	rmp.this_map = this_map;
		2467	rmp.xsize = xsize;
		2468	rmp.ysize = ysize;
		2469	rmp.expand2x = expand2x;
		2470	rmp.layoutoptions1 = layoutoptions1;
		2471	rmp.layoutoptions2 = layoutoptions2;
		2472	rmp.layoutoptions3 = layoutoptions3;
		2473	rmp.symmetry = symmetry;
		2474	rmp.difficulty = difficulty;
		2475	rmp.difficulty_given = difficulty_given;
		2476	rmp.difficulty_increase = difficulty_increase;
		2477	rmp.dungeon_level = dungeon_level;
		2478	rmp.dungeon_depth = dungeon_depth;
		2479	rmp.decoroptions = decoroptions;
		2480	rmp.orientation = orientation;
		2481	rmp.origin_y = origin_y;
		2482	rmp.origin_x = origin_x;
		2483	rmp.random_seed = random_seed;
		2484	rmp.total_map_hp = (uint64_t) total_map_hp;
		2485	rmp.map_layout_style = map_layout_style;
		2486	rmp.treasureoptions = treasureoptions;
		2487	rmp.symmetry_used = symmetry_used;
		2488	rmp.region = region;
		2489	rmp.custom = custom;
		2490
		2491	RETVAL = self->generate_random_map (&rmp);
		2492	}
		2493	OUTPUT:
2057	RETVAL	2494	RETVAL
2058		2495
2059	# "serialise" map perl data into a ref	2496	MODULE = cf PACKAGE = cf::arch
		2497
		2498	int archetypes_size ()
		2499	CODE:
		2500	RETVAL = archetypes.size ();
		2501	OUTPUT: RETVAL
		2502
		2503	archetype *archetypes (U32 index)
		2504	CODE:
		2505	RETVAL = index < archetypes.size () ? archetypes [index] : 0;
		2506	OUTPUT: RETVAL
		2507
		2508	object *instantiate (archetype *arch)
		2509	CODE:
		2510	RETVAL = arch_to_object (arch);
		2511	OUTPUT:
		2512	RETVAL
		2513
		2514	INCLUDE: $PERL $srcdir/genacc archetype ../include/object.h |
		2515
		2516	MODULE = cf PACKAGE = cf::party
		2517
		2518	partylist *first ()
		2519	PROTOTYPE:
		2520	CODE:
		2521	RETVAL = get_firstparty ();
		2522	OUTPUT: RETVAL
		2523
		2524	INCLUDE: $PERL $srcdir/genacc partylist ../include/player.h |
		2525
		2526	MODULE = cf PACKAGE = cf::region
		2527
2060	void	2528	void
2061	_get_obs (mapstruct *map)	2529	list ()
2062	PPCODE:	2530	PPCODE:
2063	{	2531	for_all_regions (rgn)
2064	object *o;	2532	XPUSHs (sv_2mortal (to_sv (rgn)));
2065	int x, y;
2066	AV *obs = newAV ();
2067	int nonnull = 0;
2068		2533
2069	for (y = 0; y < MAP_HEIGHT (map); y++)	2534	region *find (utf8_string name)
2070	for (x = 0; x < MAP_WIDTH (map); x++)	2535	PROTOTYPE: $
		2536	CODE:
		2537	RETVAL = region::find (name);
		2538	OUTPUT: RETVAL
		2539
		2540	region *find_fuzzy (utf8_string name)
		2541	PROTOTYPE: $
		2542	CODE:
		2543	RETVAL = region::find_fuzzy (name);
		2544	OUTPUT: RETVAL
		2545
		2546	int specificity (region *rgn)
		2547	CODE:
		2548	RETVAL = 0;
		2549	while (rgn = rgn->parent)
		2550	RETVAL++;
		2551	OUTPUT: RETVAL
		2552
		2553	INCLUDE: $PERL $srcdir/genacc region ../include/region.h |
		2554
		2555	MODULE = cf PACKAGE = cf::living
		2556
		2557	INCLUDE: $PERL $srcdir/genacc living ../include/living.h |
		2558
		2559	MODULE = cf PACKAGE = cf::settings
		2560
		2561	INCLUDE: $PERL $srcdir/genacc Settings ../include/global.h |
		2562
		2563	MODULE = cf PACKAGE = cf::client
		2564
		2565	INCLUDE: $PERL $srcdir/genacc client ../include/client.h |
		2566
		2567	int invoke (client *ns, int event, ...)
		2568	CODE:
		2569	if (KLASS_OF (event) != KLASS_CLIENT) croak ("event class must be CLIENT");
		2570	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
		2571	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
		2572	RETVAL = ns->invoke ((event_type)event, ARG_AV (av), DT_END);
		2573	OUTPUT: RETVAL
		2574
		2575	SV *registry (client *ns)
		2576
		2577	void
		2578	list ()
		2579	PPCODE:
		2580	EXTEND (SP, clients.size ());
		2581	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
		2582	PUSHs (sv_2mortal (to_sv (*i)));
		2583
		2584	void
		2585	client::send_packet (SV *packet)
		2586	CODE:
		2587	{
		2588	STRLEN len;
		2589	char *buf = SvPVbyte (packet, len);
		2590
		2591	if (len > MAXSOCKBUF)
2071	{	2592	{
2072	AV *av = newAV ();	2593	// ugly
2073		2594	if (THIS->pl)
2074	for (o = GET_MAP_OB (map, x, y); o; o = o->above)	2595	THIS->pl->failmsg ("[packet too long for client]");
2075	{
2076	SV *sv = SVptr_cache_get (o);
2077
2078	if (sv && HvFILL (SvRV (sv)))
2079	{
2080	nonnull = 1;
2081	sv = newSVsv (sv);
2082	}
2083	else
2084	sv = &PL_sv_undef;
2085
2086	av_push (av, sv);
2087	}
2088
2089	av_store (obs, x + y * MAP_HEIGHT (map), newRV_noinc ((SV *)av));
2090	}	2596	}
2091
2092	if (nonnull)
2093	XPUSHs (sv_2mortal (newRV_noinc ((SV *)obs)));
2094	else	2597	else
2095	SvREFCNT_dec (obs);	2598	THIS->send_packet (buf, len);
2096	}	2599	}
2097		2600
2098	# "deserialise" perl map data into the map	2601	faceidx
2099	void	2602	client::need_face (utf8_string name, int pri = 0)
2100	_set_obs (mapstruct *map, SV *sv)
2101	CODE:	2603	CODE:
2102	{	2604	RETVAL = face_find (name, 0);
2103	object *o;	2605	if (RETVAL)
2104	AV *av;
2105	int x, y;
2106	AV *obs = (AV *)SvRV (sv);
2107
2108	for (y = 0; y < MAP_HEIGHT (map); y++)
2109	for (x = 0; x < MAP_WIDTH (map); x++)
2110	{	2606	{
2111	sv = *av_fetch (obs, x + y * MAP_HEIGHT (map), 1);	2607	THIS->send_face (RETVAL, pri);
2112		2608	THIS->flush_fx ();
2113	if (!SvROK (sv))
2114	continue;
2115
2116	av = (AV *)SvRV (sv);
2117
2118	for (o = GET_MAP_OB (map, x, y); o; o = o->above)
2119	{
2120	sv = av_shift (av);
2121
2122	if (SvROK (sv))
2123	{
2124	sv_magic ((SV *)SvRV (sv), 0, PERL_MAGIC_ext, (char *)o, 0);
2125	SVptr_cache_set (o, sv);
2126	}
2127	}
2128	}	2609	}
2129	}	2610	OUTPUT:
		2611	RETVAL
2130		2612
		2613	int
		2614	client::fx_want (int idx, int value = -1)
		2615	CODE:
		2616	if (0 < idx && idx < FT_NUM)
		2617	{
		2618	RETVAL = THIS->fx_want [idx];
		2619	if (items > 2)
		2620	THIS->fx_want [idx] = value;
		2621	}
		2622	else
		2623	RETVAL = 0;
		2624	OUTPUT:
		2625	RETVAL
2131		2626
		2627	MODULE = cf PACKAGE = cf::sound PREFIX = sound_
		2628
		2629	faceidx sound_find (utf8_string name)
		2630
		2631	void sound_set (utf8_string str, faceidx face)
		2632
		2633	# dire hack
		2634	void old_sound_index (int idx, faceidx face)
		2635	CODE:
		2636	extern faceidx old_sound_index [SOUND_CAST_SPELL_0];
		2637	old_sound_index [idx] = face;
		2638
2132	MODULE = cf PACKAGE = cf::arch PREFIX = cf_archetype_	2639	MODULE = cf PACKAGE = cf::face PREFIX = face_
2133		2640
2134	archetype *cf_archetype_get_first()	2641	#INCLUDE: $PERL $srcdir/genacc faceset ../include/face.h |
2135	PROTOTYPE:
2136	ALIAS: first = 0
2137		2642
2138	archetype *cf_archetype_get_next (archetype *arch)	2643	faceidx face_find (utf8_string name, faceidx defidx = 0)
2139	ALIAS: next = 0
2140		2644
2141	archetype *cf_archetype_get_head (archetype *arch)	2645	faceidx alloc (utf8_string name)
2142	ALIAS: head = 0	2646	CODE:
		2647	{
		2648	do
		2649	{
		2650	RETVAL = faces.size ();
		2651	faces.resize (RETVAL + 1);
		2652	}
		2653	while (!RETVAL); // crude way to leave index 0
2143		2654
2144	archetype *cf_archetype_get_more (archetype *arch)	2655	faces [RETVAL].name = name;
2145	ALIAS: more = 0	2656	facehash.insert (std::make_pair (faces [RETVAL].name, RETVAL));
2146		2657
2147	const char *cf_archetype_get_name (archetype *arch)	2658	if (!strcmp (name, BLANK_FACE_NAME)) blank_face = RETVAL;
2148	ALIAS: name = 0	2659	if (!strcmp (name, EMPTY_FACE_NAME)) empty_face = RETVAL;
		2660	}
		2661	OUTPUT: RETVAL
2149		2662
2150	object *cf_archetype_get_clone (archetype *arch)	2663	void set_type (faceidx idx, int value)
2151	ALIAS: clone = 0	2664	ALIAS:
2152
2153	MODULE = cf PACKAGE = cf::party PREFIX = cf_party_
2154
2155	partylist *cf_party_get_first ()
2156	PROTOTYPE:
2157	ALIAS: first = 0
2158
2159	partylist *cf_party_get_next (partylist *party)
2160	ALIAS: next = 0
2161
2162	const char *cf_party_get_name (partylist *party)
2163
2164	const char *cf_party_get_password (partylist *party)
2165	ALIAS: password = 0
2166
2167	player *cf_party_get_first_player (partylist *party)
2168	ALIAS: first_player = 0
2169
2170	player *cf_party_get_next_player (partylist *party, player *op)
2171	ALIAS: next_player = 0
2172
2173
2174	MODULE = cf PACKAGE = cf::region PREFIX = cf_region_
2175
2176	region *cf_region_get_first ()
2177	PROTOTYPE:
2178	ALIAS: first = 0
2179
2180	const char *cf_region_get_name (region *reg)
2181	ALIAS: name = 0
2182
2183	region *cf_region_get_next (region *reg)
2184	ALIAS: next = 0
2185
2186	region *cf_region_get_parent (region *reg)
2187	ALIAS: parent = 0
2188
2189	const char *cf_region_get_longname (region *reg)
2190	ALIAS: longname = 0
2191
2192	const char *cf_region_get_message (region *reg)
2193	ALIAS: message = 0
2194
2195
2196	MODULE = cf PACKAGE = cf::living PREFIX = cf_living_
2197
2198	val64
2199	exp (living *liv, val64 new_val = 0)
2200	PROTOTYPE: $;$
2201	ALIAS:
2202	Str = 1
2203	Dex = 2
2204	Con = 3
2205	Wis = 4
2206	Cha = 5
2207	Int = 6
2208	Pow = 7
2209	wc = 8
2210	ac = 9
2211	hp = 10	2665	set_type = 0
2212	maxhp = 11	2666	set_visibility = 1
2213	sp = 12	2667	set_magicmap = 2
2214	maxsp = 13	2668	set_smooth = 3
2215	grace = 14	2669	set_smoothlevel = 4
2216	maxgrace = 15	2670	CODE:
2217	food = 16	2671	faceinfo *f = face_info (idx); assert (f);
2218	dam = 17
2219	luck = 18
2220	CODE:
2221	# define LIVING_ACC(acc,idx) case idx: RETVAL = liv->acc; if (items > 1) liv->acc = (sint64)new_val; break
2222	switch (ix)	2672	switch (ix)
2223	{	2673	{
2224	LIVING_ACC (exp , 0);	2674	case 0: f->type = value; break;
2225	LIVING_ACC (Str , 1);	2675	case 1: f->visibility = value; break;
2226	LIVING_ACC (Dex , 2);	2676	case 2: f->magicmap = value; break;
2227	LIVING_ACC (Con , 3);	2677	case 3: f->smooth = value; break;
2228	LIVING_ACC (Wis , 4);	2678	case 4: f->smoothlevel = value; break;
2229	LIVING_ACC (Cha , 5);
2230	LIVING_ACC (Int , 6);
2231	LIVING_ACC (Pow , 7);
2232	LIVING_ACC (wc , 8);
2233	LIVING_ACC (ac , 9);
2234	LIVING_ACC (hp , 10);
2235	LIVING_ACC (maxhp , 11);
2236	LIVING_ACC (sp , 12);
2237	LIVING_ACC (maxsp , 13);
2238	LIVING_ACC (grace , 14);
2239	LIVING_ACC (maxgrace, 15);
2240	LIVING_ACC (food , 16);
2241	LIVING_ACC (dam , 17);
2242	LIVING_ACC (luck , 18);
2243	}	2679	}
2244	# undef LIVING_ACC	2680
		2681	void set_data (faceidx idx, int faceset, SV *data, SV *chksum)
		2682	CODE:
		2683	{
		2684	faceinfo *f = face_info (idx); assert (f);
		2685	facedata *d = &(faceset ? f->data64 : f->data32);
		2686	sv_to (data, d->data);
		2687	STRLEN clen;
		2688	char *cdata = SvPVbyte (chksum, clen);
		2689	clen = min (CHKSUM_SIZE, clen);
		2690
		2691	if (memcmp (d->chksum, cdata, clen))
		2692	{
		2693	memcpy (d->chksum, cdata, clen);
		2694
		2695	// invalidate existing client face info
		2696	for_all_clients (ns)
		2697	if (ns->faceset == faceset)
		2698	{
		2699	ns->faces_sent [idx] = false;
		2700	ns->force_newmap = true;
		2701	}
		2702	}
		2703	}
		2704
		2705	int get_data_size (faceidx idx, int faceset = 0)
		2706	CODE:
		2707	facedata *d = face_data (idx, faceset);
		2708	if (!d) XSRETURN_UNDEF;
		2709	RETVAL = d->data.size ();
2245	OUTPUT:	2710	OUTPUT:
2246	RETVAL	2711	RETVAL
2247		2712
		2713	SV *get_chksum (faceidx idx, int faceset = 0)
		2714	CODE:
		2715	facedata *d = face_data (idx, faceset);
		2716	if (!d) XSRETURN_UNDEF;
		2717	RETVAL = newSVpvn ((char *)d->chksum, CHKSUM_SIZE);
		2718	OUTPUT:
		2719	RETVAL
		2720
		2721	SV *get_data (faceidx idx, int faceset = 0)
		2722	CODE:
		2723	facedata *d = face_data (idx, faceset);
		2724	if (!d) XSRETURN_UNDEF;
		2725	RETVAL = newSVpvn (d->data.data (), d->data.length ());
		2726	OUTPUT:
		2727	RETVAL
		2728
		2729	void invalidate (faceidx idx)
		2730	CODE:
		2731	for_all_clients (ns)
		2732	{
		2733	ns->faces_sent [idx] = false;
		2734	ns->force_newmap = true;
		2735	}
		2736
		2737	void invalidate_all ()
		2738	CODE:
		2739	for_all_clients (ns)
		2740	{
		2741	ns->faces_sent.reset ();
		2742	ns->force_newmap = true;
		2743	}
		2744
		2745	MODULE = cf PACKAGE = cf::anim PREFIX = anim_
		2746
		2747	#INCLUDE: $PERL $srcdir/genacc faceset ../include/anim.h |
		2748
		2749	animidx anim_find (utf8_string name)
		2750	CODE:
		2751	RETVAL = animation::find (name).number;
		2752	OUTPUT: RETVAL
		2753
		2754	animidx set (utf8_string name, SV *frames, int facings = 1)
		2755	CODE:
		2756	{
		2757	if (!SvROK (frames) && SvTYPE (SvRV (frames)) != SVt_PVAV)
		2758	croak ("frames must be an arrayref");
		2759
		2760	AV *av = (AV *)SvRV (frames);
		2761
		2762	animation *anim = &animation::find (name);
		2763	if (anim->number)
		2764	{
		2765	anim->resize (av_len (av) + 1);
		2766	anim->facings = facings;
		2767	}
		2768	else
		2769	anim = &animation::create (name, av_len (av) + 1, facings);
		2770
		2771	for (int i = 0; i < anim->num_animations; ++i)
		2772	anim->faces [i] = face_find (SvPVutf8_nolen (*av_fetch (av, i, 1)));
		2773	}
		2774	OUTPUT: RETVAL
		2775
		2776	void invalidate_all ()
		2777	CODE:
		2778	for_all_clients (ns)
		2779	ns->anims_sent.reset ();
		2780
		2781	MODULE = cf PACKAGE = cf::object::freezer
		2782
		2783	INCLUDE: $PERL $srcdir/genacc object_freezer ../include/cfperl.h |
		2784
		2785	SV *
		2786	new (char *klass)
		2787	CODE:
		2788	RETVAL = newSVptr (new object_freezer, gv_stashpv ("cf::object::freezer", 1));
		2789	OUTPUT: RETVAL
		2790
		2791	void
		2792	DESTROY (SV *sv)
		2793	CODE:
		2794	object_freezer *self;
		2795	sv_to (sv, self);
		2796	delete self;
		2797
		2798	MODULE = cf PACKAGE = cf::object::thawer
		2799
		2800	INCLUDE: $PERL $srcdir/genacc object_thawer ../include/cfperl.h |
		2801
		2802	SV *
		2803	new_from_file (char *klass, octet_string path)
		2804	CODE:
		2805	object_thawer *f = new object_thawer (path);
		2806	if (!*f)
		2807	{
		2808	delete f;
		2809	XSRETURN_UNDEF;
		2810	}
		2811	RETVAL = newSVptr (f, gv_stashpv ("cf::object::thawer", 1));
		2812	OUTPUT: RETVAL
		2813
		2814	void
		2815	DESTROY (SV *sv)
		2816	CODE:
		2817	object_thawer *self;
		2818	sv_to (sv, self);
		2819	delete self;
		2820
		2821	void
		2822	extract_tags (object_thawer *self)
		2823	PPCODE:
		2824	while (self->kw != KW_EOF)
		2825	{
		2826	PUTBACK;
		2827	coroapi::cede_to_tick ();
		2828	SPAGAIN;
		2829
		2830	if (self->kw == KW_tag)
		2831	XPUSHs (sv_2mortal (newSVpv_utf8 (self->get_str ())));
		2832
		2833	self->skip ();
		2834	}
		2835

Diff Legend

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