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.8 by root, Fri Aug 25 15:21:57 2006 UTC vs.
Revision 1.210 by root, Sat May 19 00:08:12 2007 UTC

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