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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.6 by root, Thu Aug 24 17:29:30 2006 UTC vs.
Revision 1.210 by root, Sat May 19 00:08:12 2007 UTC

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.6 by root, Thu Aug 24 17:29:30 2006 UTC vs. Revision 1.210 by root, Sat May 19 00:08:12 2007 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.6 by root, Thu Aug 24 17:29:30 2006 UTC vs.
Revision 1.210 by root, Sat May 19 00:08:12 2007 UTC