ViewVC Help

View File | Revision Log | Show Annotations | Download File

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

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