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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.7 by root, Fri Aug 25 13:24:50 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 */
454	registerGlobalEvent (NULL, EVENT_CLOCK, PLUGIN_NAME, globalEventListener);
455	//registerGlobalEvent (NULL, EVENT_CRASH, PLUGIN_NAME, globalEventListener);
456	registerGlobalEvent (NULL, EVENT_FIND_UNARMED_SKILL, PLUGIN_NAME, globalEventListener);
457	registerGlobalEvent (NULL, EVENT_PLAYER_USE_SKILL, PLUGIN_NAME, globalEventListener);
458	registerGlobalEvent (NULL, EVENT_CAST_SPELL, PLUGIN_NAME, globalEventListener);
459	registerGlobalEvent (NULL, EVENT_MONSTER_USE_SKILL, PLUGIN_NAME, globalEventListener);
460	registerGlobalEvent (NULL, EVENT_GKILL, PLUGIN_NAME, globalEventListener);
461	registerGlobalEvent (NULL, EVENT_SHOUT, PLUGIN_NAME, globalEventListener);
462	registerGlobalEvent (NULL, EVENT_TELL, PLUGIN_NAME, globalEventListener);
463	registerGlobalEvent (NULL, EVENT_MUZZLE, PLUGIN_NAME, globalEventListener);
464	registerGlobalEvent (NULL, EVENT_KICK, PLUGIN_NAME, globalEventListener);
465	registerGlobalEvent (NULL, EVENT_EXTCMD, PLUGIN_NAME, globalEventListener);
466
467	return 0;	604	return 0;
468	}	605	}
469		606
470	static void *	607	extern "C" int cfperl_closePlugin ()
471	globalEventListener (int *type, ...)
472	{	608	{
473	va_list args;	609	return 0;
474	static int rv;	610	}
475	int event_code;
476		611
477	if (!perl)	612	void
478	return NULL;	613	cfperl_init ()
		614	{
		615	PERL_SYS_INIT3 (&settings.argc, &settings.argv, 0);
		616	perl = perl_alloc ();
		617	perl_construct (perl);
479		618
480	va_start (args, type);	619	PL_exit_flags \|= PERL_EXIT_DESTRUCT_END;
481	event_code = va_arg (args, int);
482		620
483	if (event_code == EVENT_CLOCK)	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
		630	if (perl_parse (perl, xs_init, 2, (char )argv, (char )NULL)
		631	\|\| perl_run (perl))
484	{	632	{
485	clean_obj_cache ();	633	printf ("unable to initialize perl-interpreter, aborting.\n");
		634	exit (EXIT_FAILURE);
486	}	635	}
487	else
488	{
489	dSP;
490
491	ENTER;
492	SAVETMPS;
493
494	PUSHMARK (SP);
495
496	EXTEND (SP, 10);
497	PUSHs (sv_2mortal (newSViv (event_code)));
498
499	switch (event_code)
500	{
501	case EVENT_CRASH:
502	break;
503
504	case EVENT_GKILL:
505	PUSH_OB;
506	PUSH_OB;
507	break;
508
509	case EVENT_SHOUT:
510	case EVENT_MUZZLE:
511	case EVENT_KICK:
512	PUSH_OB;
513	PUSH_PV;
514	break;
515
516	case EVENT_FIND_UNARMED_SKILL:
517	PUSH_OB;
518	break;
519
520	case EVENT_PLAYER_USE_SKILL:
521	case EVENT_MONSTER_USE_SKILL:
522	case EVENT_CAST_SPELL:
523	PUSH_OB;
524	PUSH_OB;
525	PUSH_OB;
526	PUSH_IV;
527	PUSH_PV;
528	break;
529
530	case EVENT_EXTCMD:
531	PUSH_PL;
532	{
533	char buf = va_arg (args, char );
534	int len = va_arg (args, int);
535	PUSHs (sv_2mortal (newSVpvn (buf, len)));
536	}
537	break;
538
539	case EVENT_TELL:
540	break;
541	}
542
543	va_end (args);
544
545	PUTBACK;
546	int count = call_pv ("cf::inject_global_event", G_SCALAR \| G_EVAL);
547	SPAGAIN;
548
549	if (SvTRUE (ERRSV))
550	LOG (llevError, "global event '%d' callback evaluation error: %s", event_code, SvPV_nolen (ERRSV));
551
552	rv = count > 0 ? POPi : 0;
553
554	PUTBACK;
555	FREETMPS;
556	LEAVE;
557	}
558
559	return &rv;
560	}
561
562	extern "C" void cfperl_eventListener (int type, ...)
563	{
564	static int rv;
565	va_list args;
566	int event_code;
567	object who, activator, third, event;
568	char message, extension, *options;
569
570	if (!perl)
571	return NULL;
572
573	va_start (args, type);
574	who = va_arg (args, object *);
575	event_code = va_arg (args, int);
576	activator = va_arg (args, object *);
577	third = va_arg (args, object *);
578	message = va_arg (args, char *);
579	va_arg (args, int); // fix yourself
580	extension = va_arg (args, char *);
581	options = va_arg (args, char *);
582	event = va_arg (args, object *);
583	va_end (args);
584		636
585	{	637	{
586	dSP;	638	dSP;
587		639
588	ENTER;
589	SAVETMPS;
590
591	PUSHMARK (SP);	640	PUSHMARK (SP);
592	EXTEND (SP, 10);
593
594	PUSHcfapi (STRING, extension);
595	PUSHs (sv_2mortal (newSViv (event_code)));
596
597	PUSHcfapi (POBJECT, event);
598	PUSHcfapi (POBJECT, who);
599
600	switch (event_code)
601	{
602	case EVENT_STOP: // $ob (e.g. arrow)
603	case EVENT_TIME: // $ob
604	case EVENT_TIMER: // $ob
605	break;
606
607	case EVENT_APPLY: // $ob, $who
608	case EVENT_DROP: // $ob, $who
609	case EVENT_CLOSE: // $ob, $who
610	case EVENT_DEATH: // $ob[, $killer]
611	case EVENT_MOVE: // $ob, $enemy
612	case EVENT_THROW: // $ob, $thrower
613	PUSHcfapi (POBJECT, activator);
614	break;
615
616	case EVENT_DROP_ON: // $ob, $who, $what
617	case EVENT_ATTACK: // $ob, $who, $victim (?? please god enlighten me)
618	PUSHcfapi (POBJECT, activator);
619	PUSHcfapi (POBJECT, third);
620	break;
621
622	case EVENT_TRIGGER: // $ob, $originator, [$victim], [$msg]
623	PUSHcfapi (POBJECT, activator);
624	PUSHcfapi (POBJECT, third);
625	PUSHcfapi (POBJECT, message);
626	break;
627
628	case EVENT_SAY: // $ob, $who, $msg
629	PUSHcfapi (POBJECT, activator);
630	PUSHcfapi (STRING, message);
631	break;
632
633	default:
634	LOG (llevError, "perl plugin called for unsupported event type %d", event_code);
635	break;
636	}
637
638	PUTBACK;	641	PUTBACK;
639	int count = call_pv ("cf::inject_event", G_SCALAR \| G_EVAL);	642	call_pv ("cf::init", G_DISCARD \| G_VOID);
640	SPAGAIN;
641
642	if (SvTRUE (ERRSV))
643	LOG (llevError, "event '%d' callback evaluation error: %s", event_code, SvPV_nolen (ERRSV));
644
645	rv = count > 0 ? POPi : 0;
646
647	PUTBACK;
648	FREETMPS;
649	LEAVE;
650	}	643	}
651
652	return &rv;
653	}
654
655	extern "C" int cfperl_closePlugin ()
656	{
657	return 0;
658	}
659
660	void
661	cfperl_init ()
662	{
663	char *argv[] = {
664	"",
665	"-e"
666	"BEGIN {"
667	" cf->bootstrap;"
668	" unshift @INC, cf::datadir ();"
669	"}"
670	""
671	"use cf;"
672	};
673
674	perl = perl_alloc ();
675	perl_construct (perl);
676
677	PL_exit_flags \|= PERL_EXIT_DESTRUCT_END;
678
679	if (perl_parse (perl, xs_init, 2, argv, (char **)NULL) \|\| perl_run (perl))
680	{
681	printf ("unable to initialize perl-interpreter, aborting.\n");
682
683	exit (EXIT_FAILURE);
684	//perl_destruct (perl);
685	//perl_free (perl);
686	//perl = 0;
687	}
688	else
689	obj_cache = newHV ();
690	}	644	}
691		645
692	void cfperl_main ()	646	void cfperl_main ()
693	{	647	{
694	dSP;	648	dSP;
…		…
696	PUSHMARK (SP);	650	PUSHMARK (SP);
697	PUTBACK;	651	PUTBACK;
698	call_pv ("cf::main", G_DISCARD \| G_VOID);	652	call_pv ("cf::main", G_DISCARD \| G_VOID);
699	}	653	}
700		654
701	void cfperl_free_ob (object *op)	655	void
		656	attachable::instantiate ()
702	{	657	{
703	SV sv = hv_delete (obj_cache, (char )&op, sizeof (void *), 0);	658	if (attach)
		659	{
		660	invoke (EVENT_ATTACHABLE_INSTANTIATE, ARG_STRING (attach), DT_END);
		661	attach = 0;
		662	}
		663	}
704		664
		665	void
		666	attachable::reattach ()
		667	{
		668	optimise ();
		669	//TODO: check for _attachment's, very important for restarts
		670	invoke (EVENT_ATTACHABLE_REATTACH, DT_END);
		671	}
		672
		673	static event_klass klass_of[NUM_EVENT_TYPES] = {
		674	# define def(type,name) KLASS_ ## type,
		675	# include "eventinc.h"
		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
705	if (sv)	716	if (cb)
706	clearSVptr (sv);	717	::gather_callbacks (callbacks, cb, event);
707	}	718	}
708		719
709	int cfperl_invoke (event_type event, ...)	720	void
		721	global::gather_callbacks (AV *&callbacks, event_type event) const
710	{	722	{
711	dSP;	723	::gather_callbacks (callbacks, cb_global, event);
712	va_list ap;	724	}
713		725
714	ENTER;	726	void
715	SAVETMPS;	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];
716		732
717	va_start (ap, event);	733	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
718	PUSHMARK (SP);	734	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);
719	EXTEND (SP, 2);	735	}
720	PUSHs (sv_2mortal (newSViv (event)));
721		736
722	// todo, optimise here wether we actually want to invoke an event	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
723		857
724	for (;;)	858	for (;;)
725	{	859	{
726	data_type dt = (data_type) va_arg (ap, int);	860	dt = (data_type) va_arg (ap, int);
727		861
728	if (dt == DT_END)	862	if (dt == DT_END)
729	break;	863	break;
		864	else if (dt == DT_AV)
		865	{
		866	AV av = va_arg (ap, AV );
730		867
		868	for (int i = 0; i <= av_len (av); ++i)
		869	XPUSHs (*av_fetch (av, i, 1));
		870	}
		871	else
731	PUSHs (sv_2mortal (newSVdt_va (ap, dt)));	872	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
732	}	873	}
733		874
734	va_end (ap);	875	va_end (ap);
735		876
736	PUTBACK;	877	CALL_CALL ("cf::do_invoke", G_SCALAR);
737	int count = call_pv ("cf::invoke", G_SCALAR \| G_EVAL);
738	SPAGAIN;
739
740	count = count > 0 ? POPi : 0;	878	count = count > 0 ? POPi : 0;
741		879
742	FREETMPS;	880	CALL_END;
743	LEAVE;
744		881
745	return count;	882	return count;
746	}	883	}
747		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
748	MODULE = cf PACKAGE = cf PREFIX = cf_	1154	MODULE = cf PACKAGE = cf PREFIX = cf_
749		1155
750	BOOT:	1156	BOOT:
751	{	1157	{
752	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	}
753		1173
754	static const struct {	1174	static const struct {
755	const char *name;	1175	const char *name;
756	IV iv;	1176	IV iv;
757	} *civ, const_iv[] = {	1177	} *civ, const_iv[] = {
758	# define const_iv(name) { # name, (IV)name },	1178	# define const_iv(name) { # name, (IV)name },
759	const_iv (llevError)	1179	const_iv (llevError) const_iv (llevInfo) const_iv (llevDebug) const_iv (llevMonster)
760	const_iv (llevInfo)	1180	const_iv (logBacktrace)
761	const_iv (llevDebug)	1181
762	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)
763		1185
764	const_iv (MAX_TIME)	1186	const_iv (MAX_TIME)
765	const_iv (PLAYER)	1187
766	const_iv (TRANSPORT)
767	const_iv (ROD)
768	const_iv (TREASURE)
769	const_iv (POTION)
770	const_iv (FOOD)
771	const_iv (POISON)
772	const_iv (BOOK)
773	const_iv (CLOCK)
774	const_iv (LIGHTNING)
775	const_iv (ARROW)
776	const_iv (BOW)
777	const_iv (WEAPON)
778	const_iv (ARMOUR)
779	const_iv (PEDESTAL)
780	const_iv (ALTAR)
781	const_iv (LOCKED_DOOR)
782	const_iv (SPECIAL_KEY)
783	const_iv (MAP)
784	const_iv (DOOR)
785	const_iv (KEY)
786	const_iv (TIMED_GATE)
787	const_iv (TRIGGER)
788	const_iv (GRIMREAPER)
789	const_iv (MAGIC_EAR)
790	const_iv (TRIGGER_BUTTON)
791	const_iv (TRIGGER_ALTAR)
792	const_iv (TRIGGER_PEDESTAL)
793	const_iv (SHIELD)
794	const_iv (HELMET)
795	const_iv (HORN)
796	const_iv (MONEY)
797	const_iv (CLASS)
798	const_iv (GRAVESTONE)
799	const_iv (AMULET)
800	const_iv (PLAYERMOVER)
801	const_iv (TELEPORTER)
802	const_iv (CREATOR)
803	const_iv (SKILL)
804	const_iv (EXPERIENCE)
805	const_iv (EARTHWALL)
806	const_iv (GOLEM)
807	const_iv (THROWN_OBJ)
808	const_iv (BLINDNESS)
809	const_iv (GOD)
810	const_iv (DETECTOR)
811	const_iv (TRIGGER_MARKER)
812	const_iv (DEAD_OBJECT)
813	const_iv (DRINK)
814	const_iv (MARKER)
815	const_iv (HOLY_ALTAR)
816	const_iv (PLAYER_CHANGER)
817	const_iv (BATTLEGROUND)
818	const_iv (PEACEMAKER)
819	const_iv (GEM)
820	const_iv (FIREWALL)
821	const_iv (ANVIL)
822	const_iv (CHECK_INV)
823	const_iv (MOOD_FLOOR)	1188	const_iv (NUM_BODY_LOCATIONS)
824	const_iv (EXIT)	1189	const_iv (body_range) const_iv (body_shield) const_iv (body_combat)
825	const_iv (ENCOUNTER)	1190	const_iv (body_arm) const_iv (body_torso) const_iv (body_head)
826	const_iv (SHOP_FLOOR)	1191	const_iv (body_neck) const_iv (body_skill) const_iv (body_finger)
827	const_iv (SHOP_MAT)	1192	const_iv (body_shoulder) const_iv (body_foot) const_iv (body_hand)
828	const_iv (RING)	1193	const_iv (body_wrist) const_iv (body_waist)
829	const_iv (FLOOR)
830	const_iv (FLESH)
831	const_iv (INORGANIC)
832	const_iv (SKILL_TOOL)
833	const_iv (LIGHTER)
834	const_iv (TRAP_PART)
835	const_iv (WALL)
836	const_iv (LIGHT_SOURCE)
837	const_iv (MISC_OBJECT)
838	const_iv (MONSTER)
839	const_iv (SPAWN_GENERATOR)
840	const_iv (LAMP)
841	const_iv (DUPLICATOR)
842	const_iv (TOOL)
843	const_iv (SPELLBOOK)
844	const_iv (BUILDFAC)
845	const_iv (CLOAK)
846	const_iv (SPINNER)
847	const_iv (GATE)
848	const_iv (BUTTON)
849	const_iv (CF_HANDLE)
850	const_iv (HOLE)
851	const_iv (TRAPDOOR)
852	const_iv (SIGN)
853	const_iv (BOOTS)
854	const_iv (GLOVES)
855	const_iv (SPELL)
856	const_iv (SPELL_EFFECT)
857	const_iv (CONVERTER)
858	const_iv (BRACERS)
859	const_iv (POISONING)
860	const_iv (SAVEBED)
861	const_iv (POISONCLOUD)
862	const_iv (FIREHOLES)
863	const_iv (WAND)
864	const_iv (SCROLL)
865	const_iv (DIRECTOR)
866	const_iv (GIRDLE)
867	const_iv (FORCE)
868	const_iv (POTION_EFFECT)
869	const_iv (EVENT_CONNECTOR)
870	const_iv (CLOSE_CON)
871	const_iv (CONTAINER)
872	const_iv (ARMOUR_IMPROVER)
873	const_iv (WEAPON_IMPROVER)
874	const_iv (SKILLSCROLL)
875	const_iv (DEEP_SWAMP)
876	const_iv (IDENTIFY_ALTAR)
877	const_iv (MENU)
878	const_iv (RUNE)
879	const_iv (TRAP)
880	const_iv (POWER_CRYSTAL)
881	const_iv (CORPSE)
882	const_iv (DISEASE)
883	const_iv (SYMPTOM)
884	const_iv (BUILDER)
885	const_iv (MATERIAL)
886	const_iv (ITEM_TRANSFORMER)
887	const_iv (QUEST)
888		1194
889	const_iv (ST_BD_BUILD)	1195	const_iv (PLAYER) const_iv (TRANSPORT) const_iv (ROD) const_iv (TREASURE)
890	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)
891		1223
892	const_iv (ST_MAT_FLOOR)	1224	const_iv (NUM_TYPES) const_iv (NUM_SUBTYPES)
893	const_iv (ST_MAT_WALL)
894	const_iv (ST_MAT_ITEM)
895		1225
896	const_iv (AT_PHYSICAL)	1226	const_iv (ST_BD_BUILD) const_iv (ST_BD_REMOVE)
897	const_iv (AT_MAGIC)	1227	const_iv (ST_MAT_FLOOR) const_iv (ST_MAT_WALL) const_iv (ST_MAT_ITEM)
898	const_iv (AT_FIRE)
899	const_iv (AT_ELECTRICITY)
900	const_iv (AT_COLD)
901	const_iv (AT_CONFUSION)
902	const_iv (AT_ACID)
903	const_iv (AT_DRAIN)
904	const_iv (AT_WEAPONMAGIC)
905	const_iv (AT_GHOSTHIT)
906	const_iv (AT_POISON)
907	const_iv (AT_SLOW)
908	const_iv (AT_PARALYZE)
909	const_iv (AT_TURN_UNDEAD)
910	const_iv (AT_FEAR)
911	const_iv (AT_CANCELLATION)
912	const_iv (AT_DEPLETE)
913	const_iv (AT_DEATH)
914	const_iv (AT_CHAOS)
915	const_iv (AT_COUNTERSPELL)
916	const_iv (AT_GODPOWER)
917	const_iv (AT_HOLYWORD)
918	const_iv (AT_BLIND)
919	const_iv (AT_INTERNAL)
920	const_iv (AT_LIFE_STEALING)
921	const_iv (AT_DISEASE)
922		1228
923	const_iv (QUEST_IN_PROGRESS)	1229	const_iv (AT_PHYSICAL) const_iv (AT_MAGIC) const_iv (AT_FIRE) const_iv (AT_ELECTRICITY)
924	const_iv (QUEST_DONE_QUEST)	1230	const_iv (AT_COLD) const_iv (AT_CONFUSION) const_iv (AT_ACID) const_iv (AT_DRAIN)
925	const_iv (QUEST_DONE_TASK)	1231	const_iv (AT_WEAPONMAGIC) const_iv (AT_GHOSTHIT) const_iv (AT_POISON) const_iv (AT_SLOW)
926	const_iv (QUEST_START_QUEST)	1232	const_iv (AT_PARALYZE) const_iv (AT_TURN_UNDEAD) const_iv (AT_FEAR) const_iv (AT_CANCELLATION)
927	const_iv (QUEST_END_QUEST)	1233	const_iv (AT_DEPLETE) const_iv (AT_DEATH) const_iv (AT_CHAOS) const_iv (AT_COUNTERSPELL)
928	const_iv (QUEST_START_TASK)	1234	const_iv (AT_GODPOWER) const_iv (AT_HOLYWORD) const_iv (AT_BLIND) const_iv (AT_INTERNAL)
929	const_iv (QUEST_END_TASK)	1235	const_iv (AT_LIFE_STEALING) const_iv (AT_DISEASE)
930	const_iv (QUEST_OVERRIDE)
931	const_iv (QUEST_ON_ACTIVATE)
932		1236
933	const_iv (WEAP_HIT)	1237	const_iv (WEAP_HIT) const_iv (WEAP_SLASH) const_iv (WEAP_PIERCE) const_iv (WEAP_CLEAVE)
934	const_iv (WEAP_SLASH)	1238	const_iv (WEAP_SLICE) const_iv (WEAP_STAB) const_iv (WEAP_WHIP) const_iv (WEAP_CRUSH)
935	const_iv (WEAP_PIERCE)
936	const_iv (WEAP_CLEAVE)
937	const_iv (WEAP_SLICE)
938	const_iv (WEAP_STAB)
939	const_iv (WEAP_WHIP)
940	const_iv (WEAP_CRUSH)
941	const_iv (WEAP_BLUD)	1239	const_iv (WEAP_BLUD)
942		1240
943	const_iv (FLAG_ALIVE)	1241	const_iv (FLAG_ALIVE) const_iv (FLAG_WIZ) const_iv (FLAG_REMOVED) const_iv (FLAG_FREED)
944	const_iv (FLAG_WIZ)	1242	const_iv (FLAG_APPLIED) const_iv (FLAG_UNPAID) const_iv (FLAG_USE_SHIELD)
945	const_iv (FLAG_REMOVED)	1243	const_iv (FLAG_NO_PICK) const_iv (FLAG_ANIMATE) const_iv (FLAG_MONSTER) const_iv (FLAG_FRIENDLY)
946	const_iv (FLAG_FREED)	1244	const_iv (FLAG_GENERATOR) const_iv (FLAG_IS_THROWN) const_iv (FLAG_AUTO_APPLY) const_iv (FLAG_PLAYER_SOLD)
947	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)
948	const_iv (FLAG_APPLIED)	1246	const_iv (FLAG_IS_USED_UP) const_iv (FLAG_IDENTIFIED) const_iv (FLAG_REFLECTING) const_iv (FLAG_CHANGING)
949	const_iv (FLAG_UNPAID)	1247	const_iv (FLAG_SPLITTING) const_iv (FLAG_HITBACK) const_iv (FLAG_STARTEQUIP) const_iv (FLAG_BLOCKSVIEW)
950	const_iv (FLAG_USE_SHIELD)	1248	const_iv (FLAG_UNDEAD) const_iv (FLAG_SCARED) const_iv (FLAG_UNAGGRESSIVE) const_iv (FLAG_REFL_MISSILE)
951	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)
952	const_iv (FLAG_ANIMATE)	1250	const_iv (FLAG_TEAR_DOWN) const_iv (FLAG_RUN_AWAY) const_iv (FLAG_PICK_UP) const_iv (FLAG_UNIQUE)
953	const_iv (FLAG_MONSTER)	1251	const_iv (FLAG_NO_DROP) const_iv (FLAG_WIZCAST) const_iv (FLAG_CAST_SPELL) const_iv (FLAG_USE_SCROLL)
954	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)
955	const_iv (FLAG_GENERATOR)	1253	const_iv (FLAG_USE_RING) const_iv (FLAG_READY_RANGE) const_iv (FLAG_READY_BOW) const_iv (FLAG_XRAYS)
956	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)
957	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)
958	const_iv (FLAG_TREASURE)	1256	const_iv (FLAG_CONFUSED) const_iv (FLAG_STEALTH) const_iv (FLAG_WIZPASS) const_iv (FLAG_IS_LINKED)
959	const_iv (FLAG_PLAYER_SOLD)	1257	const_iv (FLAG_CURSED) const_iv (FLAG_DAMNED) const_iv (FLAG_SEE_ANYWHERE) const_iv (FLAG_KNOWN_MAGICAL)
960	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)
961	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)
962	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)
963	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)
964	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)
965	const_iv (FLAG_IDENTIFIED)	1263	const_iv (FLAG_NEUTRAL) const_iv (FLAG_NO_ATTACK) const_iv (FLAG_NO_DAMAGE) const_iv (FLAG_OBJ_ORIGINAL)
966	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)
967	const_iv (FLAG_CHANGING)	1265	const_iv (FLAG_CONTENT_ON_GEN) const_iv (FLAG_IS_A_TEMPLATE) const_iv (FLAG_IS_BUILDABLE)
968	const_iv (FLAG_SPLITTING)	1266	const_iv (FLAG_DESTROY_ON_DEATH) const_iv (FLAG_NO_MAP_SAVE)
969	const_iv (FLAG_HITBACK)
970	const_iv (FLAG_STARTEQUIP)
971	const_iv (FLAG_BLOCKSVIEW)
972	const_iv (FLAG_UNDEAD)
973	const_iv (FLAG_SCARED)
974	const_iv (FLAG_UNAGGRESSIVE)
975	const_iv (FLAG_REFL_MISSILE)
976	const_iv (FLAG_REFL_SPELL)
977	const_iv (FLAG_NO_MAGIC)
978	const_iv (FLAG_NO_FIX_PLAYER)
979	const_iv (FLAG_IS_LIGHTABLE)
980	const_iv (FLAG_TEAR_DOWN)
981	const_iv (FLAG_RUN_AWAY)
982	const_iv (FLAG_PICK_UP)
983	const_iv (FLAG_UNIQUE)
984	const_iv (FLAG_NO_DROP)
985	const_iv (FLAG_WIZCAST)
986	const_iv (FLAG_CAST_SPELL)
987	const_iv (FLAG_USE_SCROLL)
988	const_iv (FLAG_USE_RANGE)
989	const_iv (FLAG_USE_BOW)
990	const_iv (FLAG_USE_ARMOUR)
991	const_iv (FLAG_USE_WEAPON)
992	const_iv (FLAG_USE_RING)
993	const_iv (FLAG_READY_RANGE)
994	const_iv (FLAG_READY_BOW)
995	const_iv (FLAG_XRAYS)
996	const_iv (FLAG_NO_APPLY)
997	const_iv (FLAG_IS_FLOOR)
998	const_iv (FLAG_LIFESAVE)
999	const_iv (FLAG_NO_STRENGTH)
1000	const_iv (FLAG_SLEEP)
1001	const_iv (FLAG_STAND_STILL)
1002	const_iv (FLAG_RANDOM_MOVE)
1003	const_iv (FLAG_ONLY_ATTACK)
1004	const_iv (FLAG_CONFUSED)
1005	const_iv (FLAG_STEALTH)
1006	const_iv (FLAG_WIZPASS)
1007	const_iv (FLAG_IS_LINKED)
1008	const_iv (FLAG_CURSED)
1009	const_iv (FLAG_DAMNED)
1010	const_iv (FLAG_SEE_ANYWHERE)
1011	const_iv (FLAG_KNOWN_MAGICAL)
1012	const_iv (FLAG_KNOWN_CURSED)
1013	const_iv (FLAG_CAN_USE_SKILL)
1014	const_iv (FLAG_BEEN_APPLIED)
1015	const_iv (FLAG_READY_SCROLL)
1016	const_iv (FLAG_USE_ROD)
1017	const_iv (FLAG_USE_HORN)
1018	const_iv (FLAG_MAKE_INVIS)
1019	const_iv (FLAG_INV_LOCKED)
1020	const_iv (FLAG_IS_WOODED)
1021	const_iv (FLAG_IS_HILLY)
1022	const_iv (FLAG_READY_SKILL)
1023	const_iv (FLAG_READY_WEAPON)
1024	const_iv (FLAG_NO_SKILL_IDENT)
1025	const_iv (FLAG_BLIND)
1026	const_iv (FLAG_SEE_IN_DARK)
1027	const_iv (FLAG_IS_CAULDRON)
1028	const_iv (FLAG_NO_STEAL)
1029	const_iv (FLAG_ONE_HIT)
1030	const_iv (FLAG_CLIENT_SENT)
1031	const_iv (FLAG_BERSERK)
1032	const_iv (FLAG_NEUTRAL)
1033	const_iv (FLAG_NO_ATTACK)
1034	const_iv (FLAG_NO_DAMAGE)
1035	const_iv (FLAG_OBJ_ORIGINAL)
1036	const_iv (FLAG_OBJ_SAVE_ON_OVL)
1037	const_iv (FLAG_ACTIVATE_ON_PUSH)
1038	const_iv (FLAG_ACTIVATE_ON_RELEASE)
1039	const_iv (FLAG_IS_WATER)
1040	const_iv (FLAG_CONTENT_ON_GEN)
1041	const_iv (FLAG_IS_A_TEMPLATE)
1042	const_iv (FLAG_IS_BUILDABLE)
1043	const_iv (FLAG_AFK)
1044		1267
1045	const_iv (NDI_BLACK)	1268	const_iv (NDI_BLACK) const_iv (NDI_WHITE) const_iv (NDI_NAVY) const_iv (NDI_RED)
1046	const_iv (NDI_WHITE)	1269	const_iv (NDI_ORANGE) const_iv (NDI_BLUE) const_iv (NDI_DK_ORANGE) const_iv (NDI_GREEN)
1047	const_iv (NDI_NAVY)	1270	const_iv (NDI_LT_GREEN) const_iv (NDI_GREY) const_iv (NDI_BROWN) const_iv (NDI_GOLD)
1048	const_iv (NDI_RED)	1271	const_iv (NDI_TAN) const_iv (NDI_MAX_COLOR) const_iv (NDI_COLOR_MASK) const_iv (NDI_UNIQUE)
1049	const_iv (NDI_ORANGE)
1050	const_iv (NDI_BLUE)
1051	const_iv (NDI_DK_ORANGE)
1052	const_iv (NDI_GREEN)
1053	const_iv (NDI_LT_GREEN)
1054	const_iv (NDI_GREY)
1055	const_iv (NDI_BROWN)
1056	const_iv (NDI_GOLD)
1057	const_iv (NDI_TAN)
1058	const_iv (NDI_MAX_COLOR)
1059	const_iv (NDI_COLOR_MASK)
1060	const_iv (NDI_UNIQUE)
1061	const_iv (NDI_ALL)	1272	const_iv (NDI_ALL)
1062		1273
1063	const_iv (F_APPLIED)	1274	const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE)
1064	const_iv (F_LOCATION)	1275	const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF)
1065	const_iv (F_UNPAID)	1276
1066	const_iv (F_MAGIC)	1277	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_DAMAGE)
1067	const_iv (F_CURSED)	1278
1068	const_iv (F_DAMNED)	1279	const_iv (F_APPLIED) const_iv (F_LOCATION) const_iv (F_UNPAID) const_iv (F_MAGIC)
1069	const_iv (F_OPEN)	1280	const_iv (F_CURSED) const_iv (F_DAMNED) const_iv (F_OPEN) const_iv (F_NOPICK)
1070	const_iv (F_NOPICK)
1071	const_iv (F_LOCKED)	1281	const_iv (F_LOCKED)
1072		1282
1073	const_iv (F_BUY)	1283	const_iv (F_BUY) const_iv (F_SHOP) const_iv (F_SELL)
1074	const_iv (F_SHOP)
1075	const_iv (F_SELL)
1076		1284
1077	const_iv (P_BLOCKSVIEW)	1285	const_iv (P_BLOCKSVIEW) const_iv (P_PLAYER) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE)
1078	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)
1079	const_iv (P_IS_ALIVE)
1080	const_iv (P_NO_CLERIC)
1081	const_iv (P_NEED_UPDATE)
1082	const_iv (P_NO_ERROR)
1083	const_iv (P_OUT_OF_MAP)
1084	const_iv (P_NEW_MAP)
1085		1287
1086	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)
1087	const_iv (UP_OBJ_REMOVE)
1088	const_iv (UP_OBJ_CHANGE)
1089	const_iv (UP_OBJ_FACE)
1090		1289
1091	const_iv (INS_NO_MERGE)	1290	const_iv (INS_NO_MERGE) const_iv (INS_ABOVE_FLOOR_ONLY) const_iv (INS_NO_WALK_ON)
1092	const_iv (INS_ABOVE_FLOOR_ONLY)	1291	const_iv (INS_ON_TOP) const_iv (INS_BELOW_ORIGINATOR) const_iv (INS_MAP_LOAD)
1093	const_iv (INS_NO_WALK_ON)
1094	const_iv (INS_ON_TOP)
1095	const_iv (INS_BELOW_ORIGINATOR)
1096	const_iv (INS_MAP_LOAD)
1097		1292
1098	const_iv (WILL_APPLY_HANDLE)	1293	const_iv (WILL_APPLY_HANDLE) const_iv (WILL_APPLY_TREASURE) const_iv (WILL_APPLY_EARTHWALL)
1099	const_iv (WILL_APPLY_TREASURE)	1294	const_iv (WILL_APPLY_DOOR) const_iv (WILL_APPLY_FOOD)
1100	const_iv (WILL_APPLY_EARTHWALL)
1101	const_iv (WILL_APPLY_DOOR)
1102	const_iv (WILL_APPLY_FOOD)
1103		1295
1104	const_iv (SAVE_MODE)	1296	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)
1105	const_iv (SAVE_DIR_MODE)
1106		1297
1107	const_iv (M_PAPER)	1298	const_iv (M_PAPER) const_iv (M_IRON) const_iv (M_GLASS) const_iv (M_LEATHER)
1108	const_iv (M_IRON)	1299	const_iv (M_WOOD) const_iv (M_ORGANIC) const_iv (M_STONE) const_iv (M_CLOTH)
1109	const_iv (M_GLASS)	1300	const_iv (M_ADAMANT) const_iv (M_LIQUID) const_iv (M_SOFT_METAL) const_iv (M_BONE)
1110	const_iv (M_LEATHER)	1301	const_iv (M_ICE) const_iv (M_SPECIAL)
1111	const_iv (M_WOOD)
1112	const_iv (M_ORGANIC)
1113	const_iv (M_STONE)
1114	const_iv (M_CLOTH)
1115	const_iv (M_ADAMANT)
1116	const_iv (M_LIQUID)
1117	const_iv (M_SOFT_METAL)
1118	const_iv (M_BONE)
1119	const_iv (M_ICE)
1120	const_iv (M_SPECIAL)
1121		1302
1122	const_iv (SK_EXP_ADD_SKILL)	1303	const_iv (SK_EXP_ADD_SKILL) const_iv (SK_EXP_TOTAL) const_iv (SK_EXP_NONE)
1123	const_iv (SK_EXP_TOTAL)	1304	const_iv (SK_SUBTRACT_SKILL_EXP) const_iv (SK_EXP_SKILL_ONLY)
1124	const_iv (SK_EXP_NONE)
1125	const_iv (SK_SUBTRACT_SKILL_EXP)
1126		1305
1127	const_iv (SK_LOCKPICKING)	1306	const_iv (SK_LOCKPICKING) const_iv (SK_HIDING) const_iv (SK_SMITHERY) const_iv (SK_BOWYER)
1128	const_iv (SK_HIDING)	1307	const_iv (SK_JEWELER) const_iv (SK_ALCHEMY) const_iv (SK_STEALING) const_iv (SK_LITERACY)
1129	const_iv (SK_SMITHERY)	1308	const_iv (SK_BARGAINING) const_iv (SK_JUMPING) const_iv (SK_DET_MAGIC) const_iv (SK_ORATORY)
1130	const_iv (SK_BOWYER)	1309	const_iv (SK_SINGING) const_iv (SK_DET_CURSE) const_iv (SK_FIND_TRAPS) const_iv (SK_MEDITATION)
1131	const_iv (SK_JEWELER)	1310	const_iv (SK_PUNCHING) const_iv (SK_FLAME_TOUCH) const_iv (SK_KARATE) const_iv (SK_CLIMBING)
1132	const_iv (SK_ALCHEMY)	1311	const_iv (SK_WOODSMAN) const_iv (SK_INSCRIPTION) const_iv (SK_ONE_HANDED_WEAPON) const_iv (SK_MISSILE_WEAPON)
1133	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)
1134	const_iv (SK_LITERACY)	1313	const_iv (SK_THAUMATURGY) const_iv (SK_PRAYING) const_iv (SK_CLAWING) const_iv (SK_LEVITATION)
1135	const_iv (SK_BARGAINING)	1314	const_iv (SK_SUMMONING) const_iv (SK_PYROMANCY) const_iv (SK_EVOCATION) const_iv (SK_SORCERY)
1136	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)
1137	const_iv (SK_DET_MAGIC)
1138	const_iv (SK_ORATORY)
1139	const_iv (SK_SINGING)
1140	const_iv (SK_DET_CURSE)
1141	const_iv (SK_FIND_TRAPS)
1142	const_iv (SK_MEDITATION)
1143	const_iv (SK_PUNCHING)
1144	const_iv (SK_FLAME_TOUCH)
1145	const_iv (SK_KARATE)
1146	const_iv (SK_CLIMBING)
1147	const_iv (SK_WOODSMAN)
1148	const_iv (SK_INSCRIPTION)
1149	const_iv (SK_ONE_HANDED_WEAPON)
1150	const_iv (SK_MISSILE_WEAPON)
1151	const_iv (SK_THROWING)
1152	const_iv (SK_USE_MAGIC_ITEM)
1153	const_iv (SK_DISARM_TRAPS)
1154	const_iv (SK_SET_TRAP)
1155	const_iv (SK_THAUMATURGY)
1156	const_iv (SK_PRAYING)
1157	const_iv (SK_CLAWING)
1158	const_iv (SK_LEVITATION)
1159	const_iv (SK_SUMMONING)
1160	const_iv (SK_PYROMANCY)
1161	const_iv (SK_EVOCATION)
1162	const_iv (SK_SORCERY)
1163	const_iv (SK_TWO_HANDED_WEAPON)
1164	const_iv (SK_SPARK_TOUCH)
1165	const_iv (SK_SHIVER)
1166	const_iv (SK_ACID_SPLASH)
1167	const_iv (SK_POISON_NAIL)	1316	const_iv (SK_POISON_NAIL)
1168		1317
1169	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)
1170	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)
1171	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)
1172	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)
1173	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)
1174	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)
1175	const_iv (SOUND_PUSH_PLAYER)
1176	const_iv (SOUND_PLAYER_HITS1)
1177	const_iv (SOUND_PLAYER_HITS2)
1178	const_iv (SOUND_PLAYER_HITS3)
1179	const_iv (SOUND_PLAYER_HITS4)
1180	const_iv (SOUND_PLAYER_IS_HIT1)
1181	const_iv (SOUND_PLAYER_IS_HIT2)
1182	const_iv (SOUND_PLAYER_IS_HIT3)
1183	const_iv (SOUND_PLAYER_KILLS)
1184	const_iv (SOUND_PET_IS_KILLED)
1185	const_iv (SOUND_PLAYER_DIES)
1186	const_iv (SOUND_OB_EVAPORATE)
1187	const_iv (SOUND_OB_EXPLODE)
1188	const_iv (SOUND_CLOCK)
1189	const_iv (SOUND_TURN_HANDLE)
1190	const_iv (SOUND_FALL_HOLE)
1191	const_iv (SOUND_DRINK_POISON)
1192	const_iv (SOUND_CAST_SPELL_0)
1193		1324
1194	const_iv (PREFER_LOW)	1325	const_iv (PREFER_LOW) const_iv (PREFER_HIGH)
1195	const_iv (PREFER_HIGH)
1196		1326
1197	const_iv (ATNR_PHYSICAL)	1327	const_iv (ATNR_PHYSICAL) const_iv (ATNR_MAGIC) const_iv (ATNR_FIRE) const_iv (ATNR_ELECTRICITY)
1198	const_iv (ATNR_MAGIC)	1328	const_iv (ATNR_COLD) const_iv (ATNR_CONFUSION) const_iv (ATNR_ACID) const_iv (ATNR_DRAIN)
1199	const_iv (ATNR_FIRE)	1329	const_iv (ATNR_WEAPONMAGIC) const_iv (ATNR_GHOSTHIT) const_iv (ATNR_POISON) const_iv (ATNR_SLOW)
1200	const_iv (ATNR_ELECTRICITY)	1330	const_iv (ATNR_PARALYZE) const_iv (ATNR_TURN_UNDEAD) const_iv (ATNR_FEAR) const_iv (ATNR_CANCELLATION)
1201	const_iv (ATNR_COLD)	1331	const_iv (ATNR_DEPLETE) const_iv (ATNR_DEATH) const_iv (ATNR_CHAOS) const_iv (ATNR_COUNTERSPELL)
1202	const_iv (ATNR_CONFUSION)	1332	const_iv (ATNR_GODPOWER) const_iv (ATNR_HOLYWORD) const_iv (ATNR_BLIND) const_iv (ATNR_INTERNAL)
1203	const_iv (ATNR_ACID)	1333	const_iv (ATNR_LIFE_STEALING) const_iv (ATNR_DISEASE)
1204	const_iv (ATNR_DRAIN)	1334
1205	const_iv (ATNR_WEAPONMAGIC)	1335	const_iv (MAP_IN_MEMORY) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)
1206	const_iv (ATNR_GHOSTHIT)	1336
1207	const_iv (ATNR_POISON)	1337	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)
1208	const_iv (ATNR_SLOW)	1338	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)
1209	const_iv (ATNR_PARALYZE)	1339
1210	const_iv (ATNR_TURN_UNDEAD)	1340	const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)
1211	const_iv (ATNR_FEAR)	1341
1212	const_iv (ATNR_CANCELLATION)	1342	const_iv (ST_DEAD) const_iv (ST_SETUP) const_iv (ST_PLAYING) const_iv (ST_CUSTOM)
1213	const_iv (ATNR_DEPLETE)	1343
1214	const_iv (ATNR_DEATH)	1344	const_iv (IO_HEADER) const_iv (IO_OBJECTS) const_iv (IO_UNIQUES)
1215	const_iv (ATNR_CHAOS)	1345
1216	const_iv (ATNR_COUNTERSPELL)	1346	// random map generator
1217	const_iv (ATNR_GODPOWER)	1347	const_iv (LAYOUT_NONE) const_iv (LAYOUT_ONION) const_iv (LAYOUT_MAZE) const_iv (LAYOUT_SPIRAL)
1218	const_iv (ATNR_HOLYWORD)	1348	const_iv (LAYOUT_ROGUELIKE) const_iv (LAYOUT_SNAKE) const_iv (LAYOUT_SQUARE_SPIRAL)
1219	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)
1220	const_iv (ATNR_INTERNAL)	1359	const_iv (GT_MINIMAL)
1221	const_iv (ATNR_LIFE_STEALING)
1222	const_iv (ATNR_DISEASE)
1223
1224	const_iv (MAP_FLUSH)
1225	const_iv (MAP_PLAYER_UNIQUE)
1226	const_iv (MAP_BLOCK)
1227	const_iv (MAP_STYLE)
1228	const_iv (MAP_OVERLAY)
1229
1230	const_iv (MAP_IN_MEMORY)
1231	const_iv (MAP_SWAPPED)
1232	const_iv (MAP_LOADING)
1233	const_iv (MAP_SAVING)
1234
1235	const_iv (KLASS_GLOBAL)
1236	const_iv (KLASS_OBJECT)
1237	const_iv (KLASS_PLAYER)
1238	const_iv (KLASS_MAP)
1239	};	1360	};
1240		1361
1241	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; )
1242	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));	1363	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1243		1364
1244	static const struct {	1365	static const struct {
1245	const char *name;	1366	const char *name;
		1367	int skip;
1246	IV klass;	1368	IV klass;
1247	IV iv;	1369	IV iv;
1248	} *eiv, event_iv[] = {	1370	} *eiv, event_iv[] = {
1249	# define def(klass,name) { # name, (IV)KLASS_ ## klass, (IV)EV_ ## klass ## name },	1371	# define def(klass,name) { "EVENT_" # klass "_" # name, sizeof ("EVENT_" # klass), (IV)KLASS_ ## klass, (IV)EVENT_ ## klass ## _ ## name },
1250	# include "eventinc.h"	1372	# include "eventinc.h"
1251	# undef def	1373	# undef def
1252	};	1374	};
1253		1375
1254	AV *av = get_av ("cf::EVENT", 1);	1376	AV *av = get_av ("cf::EVENT", 1);
1255		1377
1256	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; )
1257	{	1379	{
1258	AV *event = newAV ();	1380	AV *event = newAV ();
1259	av_push (event, newSVpv ((char *)eiv->name, 0));	1381	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));
1260	av_push (event, newSViv (eiv->klass));	1382	av_push (event, newSViv (eiv->klass));
1261	av_store (av, eiv->iv, newRV_noinc ((SV *)event));	1383	av_store (av, eiv->iv, newRV_noinc ((SV *)event));
		1384	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));
1262	}	1385	}
		1386	}
1263		1387
1264	static const struct {	1388	void _connect_to_perl ()
1265	const char *name;
1266	IV iv;
1267	} *event, event_list[] = {
1268	# define const_event(name) { # name, (IV)EVENT_ ## name },
1269	const_event (NONE)
1270	const_event (APPLY)
1271	const_event (ATTACK)
1272	const_event (DEATH)
1273	const_event (DROP)
1274	const_event (DROP_ON)
1275	const_event (PICKUP)
1276	const_event (SAY)
1277	const_event (STOP)
1278	const_event (TIME)
1279	const_event (THROW)
1280	const_event (TRIGGER)
1281	const_event (CLOSE)
1282	const_event (TIMER)
1283	const_event (MOVE)
1284		1389
1285	//const_event (CLOCK)	1390	void _recalc_want ()
1286	const_event (CRASH)
1287	const_event (GKILL)
1288	const_event (SHOUT)
1289	const_event (TELL)
1290	const_event (MUZZLE)
1291	const_event (KICK)
1292	const_event (PLAYER_USE_SKILL)
1293	const_event (MONSTER_USE_SKILL)
1294	const_event (CAST_SPELL)
1295	const_event (FIND_UNARMED_SKILL)
1296	const_event (EXTCMD)
1297	//const_event (FREE_OB)
1298	};
1299		1391
1300	av = get_av ("cf::PLUGIN_EVENT", 1);	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	}
1301		1402
1302	for (event = event_list + sizeof (event_list) / sizeof (event_list [0]); event-- > event_list; )	1403	void _post_tick ()
1303	av_store (av, event->iv, newSVpv ((char *)event->name, 0));	1404	CODE:
		1405	coroapi::next_cede = SvNV (sv_next_tick) - TICK * (1. - 1. / CEDES_PER_TICK);
1304		1406
1305	static const struct {	1407	# support function for map-world.ext
1306	int dtype;	1408	void _quantise (SV data_sv, SV plt_sv)
1307	const char *name;	1409	CODE:
1308	IV idx;	1410	{
1309	} *cprop, prop_table[] = {	1411	if (!SvROK (plt_sv) \|\| SvTYPE (SvRV (plt_sv)) != SVt_PVAV)
1310	# define prop(type, name) { type, # name, (IV) CFAPI_ ## name },	1412	croak ("_quantise called with invalid agruments");
1311	prop (CFAPI_INT, MAP_PROP_FLAGS)
1312	prop (CFAPI_INT, MAP_PROP_DIFFICULTY)
1313	prop (CFAPI_STRING, MAP_PROP_PATH)
1314	prop (CFAPI_STRING, MAP_PROP_TMPNAME)
1315	prop (CFAPI_STRING, MAP_PROP_NAME)
1316	prop (CFAPI_INT, MAP_PROP_RESET_TIME)
1317	prop (CFAPI_INT, MAP_PROP_RESET_TIMEOUT)
1318	prop (CFAPI_INT, MAP_PROP_PLAYERS)
1319	prop (CFAPI_INT, MAP_PROP_DARKNESS)
1320	prop (CFAPI_INT, MAP_PROP_WIDTH)
1321	prop (CFAPI_INT, MAP_PROP_HEIGHT)
1322	prop (CFAPI_INT, MAP_PROP_ENTER_X)
1323	prop (CFAPI_INT, MAP_PROP_ENTER_Y)
1324	prop (CFAPI_INT, MAP_PROP_TEMPERATURE)
1325	prop (CFAPI_INT, MAP_PROP_PRESSURE)
1326	prop (CFAPI_INT, MAP_PROP_HUMIDITY)
1327	prop (CFAPI_INT, MAP_PROP_WINDSPEED)
1328	prop (CFAPI_INT, MAP_PROP_WINDDIR)
1329	prop (CFAPI_INT, MAP_PROP_SKY)
1330	prop (CFAPI_INT, MAP_PROP_WPARTX)
1331	prop (CFAPI_INT, MAP_PROP_WPARTY)
1332	prop (CFAPI_STRING, MAP_PROP_MESSAGE)
1333	prop (CFAPI_PMAP, MAP_PROP_NEXT)
1334	prop (CFAPI_PREGION, MAP_PROP_REGION)
1335	prop (CFAPI_POBJECT, OBJECT_PROP_OB_ABOVE)
1336	prop (CFAPI_POBJECT, OBJECT_PROP_OB_BELOW)
1337	prop (CFAPI_POBJECT, OBJECT_PROP_NEXT_ACTIVE_OB)
1338	prop (CFAPI_POBJECT, OBJECT_PROP_PREV_ACTIVE_OB)
1339	prop (CFAPI_POBJECT, OBJECT_PROP_INVENTORY)
1340	prop (CFAPI_POBJECT, OBJECT_PROP_ENVIRONMENT)
1341	prop (CFAPI_POBJECT, OBJECT_PROP_HEAD)
1342	prop (CFAPI_POBJECT, OBJECT_PROP_CONTAINER)
1343	prop (CFAPI_PMAP, OBJECT_PROP_MAP)
1344	prop (CFAPI_INT, OBJECT_PROP_COUNT)
1345	prop (CFAPI_INT, OBJECT_PROP_REFCOUNT)
1346	prop (CFAPI_STRING, OBJECT_PROP_NAME)
1347	prop (CFAPI_STRING, OBJECT_PROP_NAME_PLURAL)
1348	prop (CFAPI_STRING, OBJECT_PROP_TITLE)
1349	prop (CFAPI_STRING, OBJECT_PROP_RACE)
1350	prop (CFAPI_STRING, OBJECT_PROP_SLAYING)
1351	prop (CFAPI_STRING, OBJECT_PROP_SKILL)
1352	prop (CFAPI_STRING, OBJECT_PROP_MESSAGE)
1353	prop (CFAPI_STRING, OBJECT_PROP_LORE)
1354	prop (CFAPI_INT, OBJECT_PROP_X)
1355	prop (CFAPI_INT, OBJECT_PROP_Y)
1356	prop (CFAPI_DOUBLE, OBJECT_PROP_SPEED)
1357	prop (CFAPI_DOUBLE, OBJECT_PROP_SPEED_LEFT)
1358	prop (CFAPI_INT, OBJECT_PROP_NROF)
1359	prop (CFAPI_INT, OBJECT_PROP_DIRECTION)
1360	prop (CFAPI_INT, OBJECT_PROP_FACING)
1361	prop (CFAPI_INT, OBJECT_PROP_TYPE)
1362	prop (CFAPI_INT, OBJECT_PROP_SUBTYPE)
1363	prop (CFAPI_INT, OBJECT_PROP_CLIENT_TYPE)
1364	prop (CFAPI_INT, OBJECT_PROP_ATTACK_TYPE)
1365	prop (CFAPI_INT, OBJECT_PROP_PATH_ATTUNED)
1366	prop (CFAPI_INT, OBJECT_PROP_PATH_REPELLED)
1367	prop (CFAPI_INT, OBJECT_PROP_PATH_DENIED)
1368	prop (CFAPI_INT, OBJECT_PROP_MATERIAL)
1369	prop (CFAPI_STRING, OBJECT_PROP_MATERIAL_NAME)
1370	prop (CFAPI_INT, OBJECT_PROP_MAGIC)
1371	prop (CFAPI_INT, OBJECT_PROP_VALUE)
1372	prop (CFAPI_INT, OBJECT_PROP_LEVEL)
1373	prop (CFAPI_INT, OBJECT_PROP_LAST_HEAL)
1374	prop (CFAPI_INT, OBJECT_PROP_LAST_SP)
1375	prop (CFAPI_INT, OBJECT_PROP_LAST_GRACE)
1376	prop (CFAPI_INT, OBJECT_PROP_LAST_EAT)
1377	prop (CFAPI_INT, OBJECT_PROP_INVISIBLE_TIME)
1378	prop (CFAPI_INT, OBJECT_PROP_PICK_UP)
1379	prop (CFAPI_INT, OBJECT_PROP_ITEM_POWER)
1380	prop (CFAPI_INT, OBJECT_PROP_GEN_SP_ARMOUR)
1381	prop (CFAPI_INT, OBJECT_PROP_WEIGHT)
1382	prop (CFAPI_INT, OBJECT_PROP_WEIGHT_LIMIT)
1383	prop (CFAPI_INT, OBJECT_PROP_CARRYING)
1384	prop (CFAPI_INT, OBJECT_PROP_GLOW_RADIUS)
1385	prop (CFAPI_LONG, OBJECT_PROP_PERM_EXP)
1386	prop (CFAPI_POBJECT, OBJECT_PROP_CURRENT_WEAPON)
1387	prop (CFAPI_POBJECT, OBJECT_PROP_ENEMY)
1388	prop (CFAPI_POBJECT, OBJECT_PROP_ATTACKED_BY)
1389	prop (CFAPI_INT, OBJECT_PROP_RUN_AWAY)
1390	prop (CFAPI_POBJECT, OBJECT_PROP_CHOSEN_SKILL)
1391	prop (CFAPI_INT, OBJECT_PROP_HIDDEN)
1392	prop (CFAPI_INT, OBJECT_PROP_MOVE_STATUS)
1393	prop (CFAPI_INT, OBJECT_PROP_MOVE_TYPE)
1394	prop (CFAPI_POBJECT, OBJECT_PROP_SPELL_ITEM)
1395	prop (CFAPI_DOUBLE, OBJECT_PROP_EXP_MULTIPLIER)
1396	prop (CFAPI_PARCH, OBJECT_PROP_ARCHETYPE)
1397	prop (CFAPI_PARCH, OBJECT_PROP_OTHER_ARCH)
1398	prop (CFAPI_STRING, OBJECT_PROP_CUSTOM_NAME)
1399	prop (CFAPI_INT, OBJECT_PROP_ANIM_SPEED)
1400	prop (CFAPI_INT, OBJECT_PROP_FRIENDLY)
1401	prop (CFAPI_STRING, OBJECT_PROP_SHORT_NAME)
1402	prop (CFAPI_INT, OBJECT_PROP_MAGICAL)
1403	prop (CFAPI_INT, OBJECT_PROP_LUCK)
1404	prop (CFAPI_POBJECT, OBJECT_PROP_OWNER)
1405	prop (CFAPI_POBJECT, OBJECT_PROP_PRESENT)
1406	prop (CFAPI_INT, OBJECT_PROP_CHEATER)
1407	prop (CFAPI_INT, OBJECT_PROP_MERGEABLE)
1408	prop (CFAPI_INT, OBJECT_PROP_PICKABLE)
1409	prop (CFAPI_INT, OBJECT_PROP_STR)
1410	prop (CFAPI_INT, OBJECT_PROP_DEX)
1411	prop (CFAPI_INT, OBJECT_PROP_CON)
1412	prop (CFAPI_INT, OBJECT_PROP_WIS)
1413	prop (CFAPI_INT, OBJECT_PROP_INT)
1414	prop (CFAPI_INT, OBJECT_PROP_POW)
1415	prop (CFAPI_INT, OBJECT_PROP_CHA)
1416	prop (CFAPI_INT, OBJECT_PROP_WC)
1417	prop (CFAPI_INT, OBJECT_PROP_AC)
1418	prop (CFAPI_INT, OBJECT_PROP_HP)
1419	prop (CFAPI_INT, OBJECT_PROP_SP)
1420	prop (CFAPI_INT, OBJECT_PROP_GP)
1421	prop (CFAPI_INT, OBJECT_PROP_FP)
1422	prop (CFAPI_INT, OBJECT_PROP_MAXHP)
1423	prop (CFAPI_INT, OBJECT_PROP_MAXSP)
1424	prop (CFAPI_INT, OBJECT_PROP_MAXGP)
1425	prop (CFAPI_INT, OBJECT_PROP_DAM)
1426	prop (CFAPI_STRING, OBJECT_PROP_GOD)
1427	prop (CFAPI_STRING, OBJECT_PROP_ARCH_NAME)
1428	prop (CFAPI_INT, OBJECT_PROP_INVISIBLE)
1429	prop (CFAPI_INT, OBJECT_PROP_FACE)
1430	};
1431		1413
1432	HV *prop_type = get_hv ("cf::PROP_TYPE", 1);	1414	plt_sv = SvRV (plt_sv);
1433	HV *prop_idx = get_hv ("cf::PROP_IDX", 1);	1415	SV **plt = AvARRAY (plt_sv);
		1416	int plt_count = AvFILL (plt_sv) + 1;
1434		1417
1435	for (cprop = prop_table + sizeof (prop_table) / sizeof (prop_table [0]); cprop-- > prop_table; )	1418	STRLEN len;
1436	{	1419	char *data = SvPVbyte (data_sv, len);
1437	hv_store (prop_type, cprop->name, strlen (cprop->name), newSViv (cprop->dtype), 0);	1420	char *dst = data;
1438	hv_store (prop_idx, cprop->name, strlen (cprop->name), newSViv (cprop->idx ), 0);
1439	}
1440		1421
1441	//I_EVENT_API (PACKAGE);	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));
1442	}	1447	}
1443		1448
1444	NV floor (NV x)	1449	NV floor (NV x)
1445		1450
1446	NV ceil (NV x)	1451	NV ceil (NV x)
1447		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
1448	void server_tick ()	1481	void server_tick ()
		1482	CODE:
		1483	runtime = SvNVx (sv_runtime);
		1484	server_tick ();
1449		1485
1450	void	1486	void
1451	LOG (int level, char *msg)	1487	log_backtrace (utf8_string msg)
		1488
		1489	void
		1490	LOG (int flags, utf8_string msg)
1452	PROTOTYPE: $$	1491	PROTOTYPE: $$
1453	C_ARGS: (LogLevel)level, "%s", msg	1492	C_ARGS: flags, "%s", msg
1454		1493
1455	char path_combine (char base, char *path)	1494	octet_string path_combine (octet_string base, octet_string path)
1456	PROTOTYPE: $$	1495	PROTOTYPE: $$
1457		1496
1458	char path_combine_and_normalize (char base, char *path)	1497	octet_string path_combine_and_normalize (octet_string base, octet_string path)
1459	PROTOTYPE: $$	1498	PROTOTYPE: $$
1460		1499
1461	char *	1500	const_octet_string
1462	cf_get_maps_directory (char *path)	1501	get_maps_directory (octet_string path)
1463	PROTOTYPE: $	1502	PROTOTYPE: $
1464	ALIAS: maps_directory = 0	1503	ALIAS: maps_directory = 0
		1504	CODE:
		1505	RETVAL = create_pathname (path);
		1506	OUTPUT: RETVAL
1465		1507
1466	void	1508	void
1467	sub_generation_inc ()	1509	sub_generation_inc ()
1468	CODE:	1510	CODE:
1469	PL_sub_generation++;	1511	PL_sub_generation++;
1470		1512
1471	char *	1513	const_octet_string
1472	mapdir ()	1514	mapdir ()
1473	PROTOTYPE:	1515	PROTOTYPE:
1474	ALIAS:	1516	ALIAS:
1475	mapdir = 0	1517	mapdir = 0
1476	uniquedir = 1	1518	uniquedir = 1
…		…
1478	confdir = 3	1520	confdir = 3
1479	localdir = 4	1521	localdir = 4
1480	playerdir = 5	1522	playerdir = 5
1481	datadir = 6	1523	datadir = 6
1482	CODE:	1524	CODE:
1483	{	1525	switch (ix)
1484	int unused_type;	1526	{
1485	RETVAL = (char *)systemDirectory (&unused_type, ix);	1527	case 0: RETVAL = settings.mapdir ; break;
1486	}	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	}
1487	OUTPUT: RETVAL	1535	OUTPUT: RETVAL
1488		1536
1489	int	1537	void abort ()
1490	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)
1491	PROTOTYPE: $	1564	PROTOTYPE: $
1492		1565
1493	int random_roll(int min, int max, object *op, int goodbad);	1566	int random_roll (int min, int max, object *op, int goodbad);
1494		1567
1495	const char *cost_string_from_value(uint64 cost, int approx = 0)	1568	const_utf8_string cost_string_from_value(uint64 cost, int approx = 0)
1496		1569
1497	int	1570	int
1498	exp_to_level (val64 exp)	1571	exp_to_level (val64 exp)
1499	CODE:	1572	CODE:
1500	{	1573	{
…		…
1531	RETVAL = newSVpv (resist_plus[atnr], 0);	1604	RETVAL = newSVpv (resist_plus[atnr], 0);
1532	else	1605	else
1533	XSRETURN_UNDEF;	1606	XSRETURN_UNDEF;
1534	OUTPUT: RETVAL	1607	OUTPUT: RETVAL
1535		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
1536	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_	1650	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
1537		1651
1538	SV *	1652	INCLUDE: $PERL $srcdir/genacc object ../include/object.h \|
1539	get_property (object *obj, int type, int idx)	1653
		1654	int invoke (object *op, int event, ...)
1540	CODE:	1655	CODE:
1541	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);
1542	OUTPUT: RETVAL	1660	OUTPUT: RETVAL
1543		1661
1544	SV *	1662	SV registry (object op)
1545	set_property (object obj, int type, int idx, SV newval)	1663
		1664	int objects_size ()
1546	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
1547	switch (type)	1693	switch (ix)
1548	{	1694	{
1549	case CFAPI_INT:	1695	case 0: RETVAL = body_locations[slot].save_name; break;
1550	cf_object_set_int_property (obj, idx, SvIV (newval));	1696	case 1: RETVAL = body_locations[slot].use_name; break;
1551	break;	1697	case 2: RETVAL = body_locations[slot].nonuse_name; break;
1552	case CFAPI_LONG:
1553	cf_object_set_long_property (obj, idx, (long) SvVAL64 (newval));
1554	break;
1555	case CFAPI_DOUBLE:
1556	{
1557	int unused_type;
1558	object_set_property (&unused_type, obj, idx, (double)SvNV (newval));
1559	}
1560	break;
1561	case CFAPI_STRING:
1562	cf_object_set_string_property (obj, idx, SvOK (newval) ? SvPV_nolen (newval) : 0);
1563	break;
1564	case CFAPI_POBJECT:
1565	{
1566	int unused_type;
1567	object_set_property (&unused_type, obj, idx, (object *)SvPTR_ornull (newval, "cf::object"));
1568	}
1569	break;
1570	default:
1571	croak ("unhandled type '%d' in set_property '%d'", type, idx);
1572	}	1698	}
		1699	}
		1700	OUTPUT:
		1701	RETVAL
1573		1702
1574	# missing properties	1703	# missing properties
1575		1704
1576	void	1705	object head (object op)
1577	set_attacktype (object *obj, U32 attacktype)	1706	PROTOTYPE: $
1578	CODE:	1707	CODE:
1579	obj->attacktype = attacktype;	1708	RETVAL = op->head_ ();
1580
1581	U32
1582	get_attacktype (object *obj)
1583	ALIAS:
1584	attacktype = 0
1585	CODE:
1586	RETVAL = obj->attacktype;
1587	OUTPUT: RETVAL	1709	OUTPUT: RETVAL
1588		1710
1589	# missing in plug-in api, of course	1711	int is_head (object *op)
1590	void	1712	PROTOTYPE: $
1591	set_food (object *obj, int food)	1713	CODE:
1592	CODE:	1714	RETVAL = op->head_ () == op;
1593	obj->stats.food = food;
1594
1595	int
1596	get_food (object *obj)
1597	ALIAS:
1598	food = 0
1599	CODE:
1600	RETVAL = obj->stats.food;
1601	OUTPUT: RETVAL	1715	OUTPUT: RETVAL
1602		1716
1603	void	1717	void
1604	inv (object *obj)	1718	inv (object *obj)
1605	PROTOTYPE: $	1719	PROTOTYPE: $
1606	PPCODE:	1720	PPCODE:
1607	{	1721	{
1608	object *o;	1722	object *o;
1609	for (o = obj->inv; o; o = o->below)	1723	for (o = obj->inv; o; o = o->below)
1610	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));	1724	XPUSHs (sv_2mortal (to_sv (o)));
1611	}	1725	}
1612		1726
1613	int cf_object_get_resistance (object *op, int rtype)	1727	void
1614	ALIAS: resistance = 0	1728	set_animation (object *op, int idx)
		1729	CODE:
		1730	SET_ANIMATION (op, idx);
1615		1731
1616	int cf_object_get_flag (object *op, int flag)	1732	int
1617	ALIAS: flag = 0	1733	num_animations (object *op)
		1734	CODE:
		1735	RETVAL = NUM_ANIMATIONS (op);
		1736	OUTPUT: RETVAL
1618		1737
1619	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");
1620		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
1621	int need_identify (const object *obj);	1761	int need_identify (object *obj);
1622		1762
1623	int apply_shop_mat (object shop_mat, object op);	1763	int apply_shop_mat (object shop_mat, object op);
1624		1764
		1765	int move_player (object *op, int dir)
		1766	CODE:
		1767	RETVAL = move_player (op, dir);
		1768	OUTPUT:
		1769	RETVAL
		1770
1625	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
1626		1776
1627	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);
1628		1780
1629	void cf_object_apply_below (object *op)	1781	void apply_below (object *op)
		1782	CODE:
		1783	player_apply_below (op);
1630		1784
1631	void cf_object_remove (object *op)	1785	int cast_heal (object op, object caster, object *spell, int dir = 0)
1632		1786
1633	void cf_object_free (object *op)
1634
1635	object cf_object_present_archname_inside (object op, char *whatstr)	1787	object cf_object_present_archname_inside (object op, utf8_string whatstr)
1636		1788
1637	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)
1638		1790
1639	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)
1640		1792
		1793	#//TODO
1641	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
1642		1804
1643	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
1644		1809
1645	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
1646		1814
1647	void pay_player (object *op, uint64 amount)	1815	void pay_player (object *op, uint64 amount)
1648		1816
1649	val64 pay_player_arch (object op, const char arch, uint64 amount)	1817	val64 pay_player_arch (object *op, utf8_string arch, uint64 amount)
1650		1818
1651	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)
1652		1820
1653	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);
1654		1824
1655	void cf_object_learn_spell (object op, object sp)
1656
1657	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));
1658		1828
1659	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
1660		1833
1661	int cf_object_query_money (object *op)	1834	int query_money (object *op)
1662	ALIAS: money = 0	1835	ALIAS: money = 0
1663		1836
1664	int cf_object_query_cost (object op, object who, int flags)	1837	val64 query_cost (object op, object who, int flags)
1665	ALIAS: cost = 0	1838	ALIAS: cost = 0
1666		1839
1667	void cf_object_activate_rune (object op , object victim)	1840	void spring_trap (object op, object victim)
1668		1841
1669	int cf_object_check_trigger (object op, object cause)	1842	int check_trigger (object op, object cause)
1670		1843
1671	int cf_object_out_of_map (object *op, int x, int y)
1672
1673	void cf_object_drop (object op, object author)	1844	void drop (object who, object op)
1674		1845
1675	void cf_object_take (object op, object author)	1846	void pick_up (object who, object op)
1676		1847
1677	void cf_object_say (object op, char msg)
1678
1679	void cf_object_speak (object op, char msg)
1680
1681	object cf_object_insert_object (object op, object *container)
1682
1683	const char cf_object_get_msg (object ob)
1684	ALIAS: msg = 0
1685
1686	object cf_object_insert_in_ob (object ob, object *where)
1687
1688	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)
1689		1849
1690	void cf_object_update (object *op, int flags)	1850	void update_object (object *op, int action)
1691		1851
1692	void cf_object_pickup (object op, object what)
1693
1694	object cf_create_object_by_name (const char name)	1852	object *cf_create_object_by_name (utf8_string name)
1695		1853
1696	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)
1697		1855
1698	void player_lvl_adj (object who, object skill = 0)	1856	void player_lvl_adj (object who, object skill = 0)
1699		1857
1700	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)
1701		1859
…		…
1703		1861
1704	void push_button (object *op);	1862	void push_button (object *op);
1705		1863
1706	void use_trigger (object *op);	1864	void use_trigger (object *op);
1707		1865
1708	void add_button_link (object button, mapstruct map, int connected);	1866	void add_button_link (object button, maptile map, int connected);
1709		1867
1710	void remove_button_link (object *op);	1868	void remove_button_link (object *op);
1711		1869
1712	void
1713	cf_object_set_resistance (object *op, int rtype, int val)
1714	CODE:
1715	if (rtype >= 0 && rtype < NROFATTACKS)
1716	op->resist[rtype] = val;
1717
1718		1870
1719	MODULE = cf PACKAGE = cf::object PREFIX = cf_	1871	MODULE = cf PACKAGE = cf::object PREFIX = cf_
1720
1721	void cf_fix_object (object *pl)
1722	ALIAS: fix = 0
1723		1872
1724	object cf_insert_ob_in_ob (object ob, object *where)	1873	object cf_insert_ob_in_ob (object ob, object *where)
1725		1874
1726	# 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
1727	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.	1876	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.
1728		1877
1729	object new (const char archetype = 0)	1878	object *new (utf8_string archetype = 0)
1730	PROTOTYPE: ;$	1879	PROTOTYPE: ;$
1731	CODE:	1880	CODE:
1732	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();	1881	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();
1733	OUTPUT:	1882	OUTPUT:
1734	RETVAL	1883	RETVAL
1735		1884
1736	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)
1737	PROTOTYPE: $$$$$$	1886	PROTOTYPE: $$$$$$
1738	CODE:	1887	CODE:
1739	{	1888	{
1740	int unused_type;	1889	int unused_type;
1741	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);
1742	}	1891	}
1743		1892
1744	# syntatic sugar for easier use in event callbacks.
1745	const char options (object op)
1746	CODE:
1747	RETVAL = op->name;
1748	OUTPUT:
1749	RETVAL
1750
1751	player contr (object op)	1893	player contr (object op)
1752	CODE:	1894	CODE:
1753	RETVAL = op->contr;	1895	RETVAL = op->contr;
1754	OUTPUT: RETVAL	1896	OUTPUT: RETVAL
1755		1897
1756	const char get_ob_key_value (object op, const char *key)	1898	const_utf8_string get_ob_key_value (object *op, utf8_string key)
1757		1899
1758	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)
1759		1901
1760	object get_nearest_player (object ob)	1902	object get_nearest_player (object ob)
1761	ALIAS: nearest_player = 0	1903	ALIAS: nearest_player = 0
1762	PREINIT:	1904	PREINIT:
1763	extern object get_nearest_player (object );	1905	extern object get_nearest_player (object );
…		…
1779	bool on_same_map_as (object ob, object other)	1921	bool on_same_map_as (object ob, object other)
1780	CODE:	1922	CODE:
1781	RETVAL = on_same_map (ob, other);	1923	RETVAL = on_same_map (ob, other);
1782	OUTPUT: RETVAL	1924	OUTPUT: RETVAL
1783		1925
1784	char *	1926	const_utf8_string
1785	base_name (object *ob, int plural)	1927	base_name (object *op, int plural = op->nrof > 1)
1786	CODE:	1928	CODE:
1787	RETVAL = cf_query_base_name (ob, plural);	1929	RETVAL = query_base_name (op, plural);
1788	OUTPUT: RETVAL	1930	OUTPUT: RETVAL
1789		1931
1790	living *	1932	object decrease_ob_nr (object op, unsigned long i)
1791	stats (object *ob)
1792	CODE:
1793	RETVAL = &ob->stats;
1794	OUTPUT: RETVAL
1795
1796		1933
1797	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_	1934	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_
1798		1935
1799	player player (object op)	1936	player player (object op)
1800	CODE:	1937	CODE:
1801	RETVAL = op->contr;	1938	RETVAL = op->contr;
1802	OUTPUT: RETVAL	1939	OUTPUT: RETVAL
1803		1940
		1941	void check_score (object *op)
		1942
1804	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);
1805		1946
1806	object cf_player_send_inventory (object op)	1947	object cf_player_send_inventory (object op)
1807		1948
1808	char cf_player_get_ip (object op)	1949	octet_string cf_player_get_ip (object *op)
1809	ALIAS: ip = 0	1950	ALIAS: ip = 0
1810		1951
1811	object cf_player_get_marked_item (object op)	1952	object cf_player_get_marked_item (object op)
1812	ALIAS: marked_item = 0	1953	ALIAS: marked_item = 0
1813		1954
…		…
1818		1959
1819	void cf_player_set_party (object op, partylist party)	1960	void cf_player_set_party (object op, partylist party)
1820		1961
1821	void kill_player (object *op)	1962	void kill_player (object *op)
1822		1963
1823	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
1824		1973
1825	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_	1974	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
1826		1975
1827	player cf_player_find (char name)	1976	INCLUDE: $PERL $srcdir/genacc player ../include/player.h \|
1828	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;
1829		1995
1830	void cf_player_move (player *pl, int dir)	1996	void cf_player_move (player *pl, int dir)
1831		1997
1832	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);
1833
1834	# nonstandard
1835	object ob (player pl)
1836	CODE:
1837	RETVAL = pl->ob;
1838	OUTPUT: RETVAL
1839
1840	player *first ()
1841	CODE:
1842	RETVAL = first_player;
1843	OUTPUT: RETVAL
1844
1845	player next (player pl)
1846	CODE:
1847	RETVAL = pl->next;
1848	OUTPUT: RETVAL
1849		1999
1850	bool	2000	bool
1851	cell_visible (player *pl, int dx, int dy)	2001	cell_visible (player *pl, int dx, int dy)
1852	CODE:	2002	CODE:
1853	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
1854	&& !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];
1855	OUTPUT:	2005	OUTPUT:
1856	RETVAL	2006	RETVAL
1857		2007
1858	char *
1859	client (player *pl)
1860	CODE:
1861	RETVAL = pl->socket.client;
1862	OUTPUT:
1863	RETVAL
1864
1865	char *
1866	host (player *pl)
1867	CODE:
1868	RETVAL = pl->socket.host;
1869	OUTPUT:
1870	RETVAL
1871
1872	char *
1873	killer (player pl, char killer = 0)
1874	CODE:
1875	if (killer)
1876	snprintf (pl->killer, sizeof (pl->killer), "%s", killer);
1877	RETVAL = pl->killer;
1878	OUTPUT:
1879	RETVAL
1880
1881	void
1882	buggy_mapscroll (player *pl, int value = 1)
1883	CODE:
1884	pl->socket.buggy_mapscroll = value;
1885
1886	void	2008	void
1887	send (player pl, SV packet)	2009	send (player pl, SV packet)
1888	CODE:	2010	CODE:
1889	{	2011	{
1890	STRLEN len;	2012	STRLEN len;
1891	char *buf = SvPVbyte (packet, len);	2013	char *buf = SvPVbyte (packet, len);
1892		2014
1893	Write_String_To_Socket (&pl->socket, buf, len);	2015	if (pl->ns)
		2016	pl->ns->send_packet (buf, len);
1894	}	2017	}
1895		2018
1896	int	2019	int
1897	listening (player *pl, int new_value = -1)	2020	listening (player *pl, int new_value = -1)
1898	CODE:	2021	CODE:
…		…
1900	if (new_value >= 0)	2023	if (new_value >= 0)
1901	pl->listening = new_value;	2024	pl->listening = new_value;
1902	OUTPUT:	2025	OUTPUT:
1903	RETVAL	2026	RETVAL
1904		2027
1905	void get_savebed (player *pl)	2028	void savebed (player pl, SV map_path = 0, SV x = 0, SV y = 0)
1906	ALIAS:	2029	PROTOTYPE: $;$$$
1907	savebed = 0
1908	PPCODE:	2030	PPCODE:
		2031	if (GIMME_V != G_VOID)
		2032	{
1909	EXTEND (SP, 3);	2033	EXTEND (SP, 3);
1910	PUSHs (sv_2mortal (newSVpv (pl->savebed_map, 0)));	2034	PUSHs (sv_2mortal (newSVpv (pl->savebed_map, 0)));
1911	PUSHs (sv_2mortal (newSViv (pl->bed_x)));	2035	PUSHs (sv_2mortal (newSViv (pl->bed_x)));
1912	PUSHs (sv_2mortal (newSViv (pl->bed_y)));	2036	PUSHs (sv_2mortal (newSViv (pl->bed_y)));
1913		2037	}
1914	void set_savebed (player pl, char map_path, int x, int y)	2038	if (map_path) sv_to (map_path, pl->savebed_map);
1915	CODE:	2039	if (x) sv_to (x, pl->bed_x);
1916	strcpy (pl->savebed_map, map_path);	2040	if (y) sv_to (y, pl->bed_y);
1917	pl->bed_x = x;
1918	pl->bed_y = y;
1919		2041
1920	void	2042	void
1921	list ()	2043	list ()
1922	PPCODE:	2044	PPCODE:
1923	{	2045	for_all_players (pl)
1924	player *pl;	2046	XPUSHs (sv_2mortal (to_sv (pl)));
1925	for (pl = first_player; pl; pl = pl->next)
1926	XPUSHs (newSVcfapi (CFAPI_PPLAYER, pl));
1927	}
1928
1929	bool
1930	peaceful (player *pl, bool new_setting = 0)
1931	PROTOTYPE: $;$
1932	CODE:
1933	RETVAL = pl->peaceful;
1934	if (items > 1)
1935	pl->peaceful = new_setting;
1936	OUTPUT:
1937	RETVAL
1938
1939	living *
1940	orig_stats (player *pl)
1941	CODE:
1942	RETVAL = &pl->orig_stats;
1943	OUTPUT: RETVAL
1944
1945	living *
1946	last_stats (player *pl)
1947	CODE:
1948	RETVAL = &pl->last_stats;
1949	OUTPUT: RETVAL
1950		2047
1951		2048
1952	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_	2049	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_
1953		2050
1954	SV *	2051	int invoke (maptile *map, int event, ...)
1955	get_property (mapstruct *obj, int type, int idx)
1956	CODE:	2052	CODE:
1957	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);
1958	OUTPUT: RETVAL	2057	OUTPUT: RETVAL
1959		2058
1960	SV *	2059	SV registry (maptile map)
1961	set_property (mapstruct obj, int type, int idx, SV newval)
1962	CODE:
1963	switch (type)
1964	{
1965	case CFAPI_INT:
1966	cf_map_set_int_property (obj, idx, SvIV (newval));
1967	break;
1968	default:
1969	croak ("unhandled type '%d' in set_property '%d'", type, idx);
1970	}
1971		2060
1972	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 ()
1973	PROTOTYPE:	2067	PROTOTYPE:
1974	CODE:	2068	CODE:
1975	{	2069	RETVAL = new maptile;
1976	int unused_type;
1977	RETVAL = (mapstruct*) map_get_map (&unused_type, 0, width, height);
1978	}
1979	OUTPUT:	2070	OUTPUT:
1980	RETVAL	2071	RETVAL
1981		2072
1982	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	}
1983		2085
1984	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");
1985		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
1986	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)
1987		2191
1988	mapstruct tile_map (mapstruct map, unsigned int dir)	2192	int out_of_map (maptile *map, int x, int y)
1989	CODE:
1990	RETVAL = dir < 4 ? map->tile_map [dir] : 0;
1991	OUTPUT:
1992	RETVAL
1993		2193
1994	char tile_path (mapstruct map, unsigned int dir)	2194	void
1995	CODE:	2195	trigger (maptile *map, long connection, bool state = true)
1996	if (dir >= 4)	2196	CODE:
1997	XSRETURN_UNDEF;	2197	activate_connection (map, connection, state);
1998	RETVAL = map->tile_path [dir];
1999	OUTPUT:
2000	RETVAL
2001		2198
2002	mapstruct cf_map_get_map (char name)	2199	void
2003	PROTOTYPE: $	2200	get_connection (maptile *map, long connection)
2004	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)));
2005		2206
2006	mapstruct has_been_loaded (char name)
2007	PROTOTYPE: $
2008
2009	mapstruct *cf_map_get_first ()
2010	PROTOTYPE:
2011	ALIAS: first = 0
2012
2013	# whoever "designed" the plug-in api should have wasted
2014	# his/her time with staying away from the project - would have
2015	# saved others a lot of time, without doubt.
2016	void set_path (mapstruct where, char path)
2017	CODE:
2018	strcpy (where->path, path);
2019
2020	int in_memory (mapstruct *map)
2021	CODE:
2022	RETVAL = map->in_memory;
2023	OUTPUT:
2024	RETVAL
2025
2026	bool unique (mapstruct *map)
2027	CODE:
2028	RETVAL = map->unique;
2029	OUTPUT:
2030	RETVAL
2031
2032	void set_unique (mapstruct *map, bool unique)
2033	CODE:
2034	map->unique = unique;
2035
2036	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)
2037		2208
2038	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)
2039		2210
2040	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)
2041	C_ARGS: str, map, nx, ny	2212	C_ARGS: str, map, nx, ny
2042		2213
2043	void	2214	void
2044	cf_map_normalise (mapstruct *map, int x, int y)	2215	get_map_flags (maptile *map, int x, int y)
2045	PPCODE:	2216	PPCODE:
2046	{	2217	{
2047	mapstruct *nmap = 0;	2218	maptile *nmap = 0;
2048	I16 nx = 0, ny = 0;	2219	I16 nx = 0, ny = 0;
2049	int flags = cf_map_get_flags (map, &nmap, x, y, &nx, &ny);	2220	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
2050		2221
2051	EXTEND (SP, 4);	2222	EXTEND (SP, 4);
2052	PUSHs (sv_2mortal (newSViv (flags)));	2223	PUSHs (sv_2mortal (newSViv (flags)));
2053		2224
2054	if (GIMME_V == G_ARRAY)	2225	if (GIMME_V == G_ARRAY)
…		…
2058	PUSHs (sv_2mortal (newSViv (ny)));	2229	PUSHs (sv_2mortal (newSViv (ny)));
2059	}	2230	}
2060	}	2231	}
2061		2232
2062	void	2233	void
2063	at (mapstruct *map, unsigned int x, unsigned int y)	2234	at (maptile *map, unsigned int x, unsigned int y)
2064	PROTOTYPE: $$$	2235	PROTOTYPE: $$$
2065	PPCODE:	2236	PPCODE:
2066	{	2237	{
2067	object *o;	2238	object *o;
2068	mapstruct *nmap = 0;	2239	maptile *nmap = 0;
2069	I16 nx, ny;	2240	I16 nx, ny;
2070		2241
2071	cf_map_get_flags (map, &nmap, x, y, &nx, &ny);	2242	get_map_flags (map, &nmap, x, y, &nx, &ny);
2072		2243
2073	if (nmap)	2244	if (nmap)
2074	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)
2075	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));	2246	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));
2076	}	2247	}
2077		2248
2078	SV *	2249	SV *
2079	bot_at (mapstruct *obj, unsigned int x, unsigned int y)	2250	bot_at (maptile *obj, unsigned int x, unsigned int y)
2080	PROTOTYPE: $$$	2251	PROTOTYPE: $$$
2081	ALIAS:	2252	ALIAS:
2082	top_at = 1	2253	top_at = 1
2083	flags_at = 2	2254	flags_at = 2
2084	light_at = 3	2255	light_at = 3
2085	move_block_at = 4	2256	move_block_at = 4
2086	move_slow_at = 5	2257	move_slow_at = 5
2087	move_on_at = 6	2258	move_on_at = 6
2088	move_off_at = 7	2259	move_off_at = 7
2089	INIT:	2260	INIT:
2090	if (x >= MAP_WIDTH (obj) \|\| y >= MAP_HEIGHT (obj)) XSRETURN_UNDEF;	2261	if (x >= obj->width \|\| y >= obj->height) XSRETURN_UNDEF;
2091	CODE:	2262	CODE:
2092	switch (ix)	2263	switch (ix)
2093	{	2264	{
2094	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;
2095	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;
…		…
2098	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;
2099	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;
2100	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;
2101	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;
2102	}	2273	}
2103	OUTPUT:	2274	OUTPUT: RETVAL
2104	RETVAL
2105		2275
2106	# "serialise" map perl data into a ref	2276	void fix_walls (maptile *map, int x, int y)
2107	void	2277
2108	_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	)
2109	PPCODE:	2321	CODE:
2110	{	2322	{
2111	object *o;	2323	random_map_params rmp;
2112	int x, y;
2113	AV *obs = newAV ();
2114	int nonnull = 0;
2115		2324
2116	for (y = 0; y < MAP_HEIGHT (map); y++)	2325	assign (rmp.wallstyle , wallstyle);
2117	for (x = 0; x < MAP_WIDTH (map); x++)	2326	assign (rmp.wall_name , wall_name);
2118	{	2327	assign (rmp.floorstyle , floorstyle);
2119	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);
2120		2335
2121	for (o = GET_MAP_OB (map, x, y); o; o = o->above)	2336	rmp.origin_map = origin_map;
2122	{	2337	rmp.final_map = final_map;
2123	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;
2124		2362
2125	if (sv && HvFILL (SvRV (sv)))	2363	RETVAL = self->generate_random_map (&rmp);
2126	{
2127	nonnull = 1;
2128	sv = newSVsv (sv);
2129	}
2130	else
2131	sv = &PL_sv_undef;
2132
2133	av_push (av, sv);
2134	}
2135
2136	av_store (obs, x + y * MAP_HEIGHT (map), newRV_noinc ((SV *)av));
2137	}
2138
2139	if (nonnull)
2140	XPUSHs (sv_2mortal (newRV_noinc ((SV *)obs)));
2141	else
2142	SvREFCNT_dec (obs);
2143	}	2364	}
2144
2145	# "deserialise" perl map data into the map
2146	void
2147	_set_obs (mapstruct map, SV sv)
2148	CODE:
2149	{
2150	object *o;
2151	AV *av;
2152	int x, y;
2153	AV obs = (AV )SvRV (sv);
2154
2155	for (y = 0; y < MAP_HEIGHT (map); y++)
2156	for (x = 0; x < MAP_WIDTH (map); x++)
2157	{
2158	sv = av_fetch (obs, x + y MAP_HEIGHT (map), 1);
2159
2160	if (!SvROK (sv))
2161	continue;
2162
2163	av = (AV *)SvRV (sv);
2164
2165	for (o = GET_MAP_OB (map, x, y); o; o = o->above)
2166	{
2167	sv = av_shift (av);
2168
2169	if (SvROK (sv))
2170	{
2171	sv_magic ((SV )SvRV (sv), 0, PERL_MAGIC_ext, (char )o, 0);
2172	SVptr_cache_set (o, sv);
2173	}
2174	}
2175	}
2176	}
2177
2178
2179	MODULE = cf PACKAGE = cf::arch PREFIX = cf_archetype_
2180
2181	archetype *cf_archetype_get_first()
2182	PROTOTYPE:
2183	ALIAS: first = 0
2184
2185	archetype cf_archetype_get_next (archetype arch)
2186	ALIAS: next = 0
2187
2188	archetype cf_archetype_get_head (archetype arch)
2189	ALIAS: head = 0
2190
2191	archetype cf_archetype_get_more (archetype arch)
2192	ALIAS: more = 0
2193
2194	const char cf_archetype_get_name (archetype arch)
2195	ALIAS: name = 0
2196
2197	object cf_archetype_get_clone (archetype arch)
2198	ALIAS: clone = 0
2199
2200	MODULE = cf PACKAGE = cf::party PREFIX = cf_party_
2201
2202	partylist *cf_party_get_first ()
2203	PROTOTYPE:
2204	ALIAS: first = 0
2205
2206	partylist cf_party_get_next (partylist party)
2207	ALIAS: next = 0
2208
2209	const char cf_party_get_name (partylist party)
2210
2211	const char cf_party_get_password (partylist party)
2212	ALIAS: password = 0
2213
2214	player cf_party_get_first_player (partylist party)
2215	ALIAS: first_player = 0
2216
2217	player cf_party_get_next_player (partylist party, player *op)
2218	ALIAS: next_player = 0
2219
2220
2221	MODULE = cf PACKAGE = cf::region PREFIX = cf_region_
2222
2223	region *cf_region_get_first ()
2224	PROTOTYPE:
2225	ALIAS: first = 0
2226
2227	const char cf_region_get_name (region reg)
2228	ALIAS: name = 0
2229
2230	region cf_region_get_next (region reg)
2231	ALIAS: next = 0
2232
2233	region cf_region_get_parent (region reg)
2234	ALIAS: parent = 0
2235
2236	const char cf_region_get_longname (region reg)
2237	ALIAS: longname = 0
2238
2239	const char cf_region_get_message (region reg)
2240	ALIAS: message = 0
2241
2242
2243	MODULE = cf PACKAGE = cf::living PREFIX = cf_living_
2244
2245	val64
2246	exp (living *liv, val64 new_val = 0)
2247	PROTOTYPE: $;$
2248	ALIAS:
2249	Str = 1
2250	Dex = 2
2251	Con = 3
2252	Wis = 4
2253	Cha = 5
2254	Int = 6
2255	Pow = 7
2256	wc = 8
2257	ac = 9
2258	hp = 10
2259	maxhp = 11
2260	sp = 12
2261	maxsp = 13
2262	grace = 14
2263	maxgrace = 15
2264	food = 16
2265	dam = 17
2266	luck = 18
2267	CODE:
2268	# define LIVING_ACC(acc,idx) case idx: RETVAL = liv->acc; if (items > 1) liv->acc = (sint64)new_val; break
2269	switch (ix)
2270	{
2271	LIVING_ACC (exp , 0);
2272	LIVING_ACC (Str , 1);
2273	LIVING_ACC (Dex , 2);
2274	LIVING_ACC (Con , 3);
2275	LIVING_ACC (Wis , 4);
2276	LIVING_ACC (Cha , 5);
2277	LIVING_ACC (Int , 6);
2278	LIVING_ACC (Pow , 7);
2279	LIVING_ACC (wc , 8);
2280	LIVING_ACC (ac , 9);
2281	LIVING_ACC (hp , 10);
2282	LIVING_ACC (maxhp , 11);
2283	LIVING_ACC (sp , 12);
2284	LIVING_ACC (maxsp , 13);
2285	LIVING_ACC (grace , 14);
2286	LIVING_ACC (maxgrace, 15);
2287	LIVING_ACC (food , 16);
2288	LIVING_ACC (dam , 17);
2289	LIVING_ACC (luck , 18);
2290	}
2291	# undef LIVING_ACC
2292	OUTPUT:	2365	OUTPUT:
2293	RETVAL	2366	RETVAL
2294		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.7 by root, Fri Aug 25 13:24:50 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.7 by root, Fri Aug 25 13:24:50 2006 UTC vs.
Revision 1.210 by root, Sat May 19 00:08:12 2007 UTC