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

Diff Legend

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