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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.10 by root, Fri Aug 25 17:11:53 2006 UTC vs.
Revision 1.189 by root, Tue Apr 17 10:06:34 2007 UTC

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.10 by root, Fri Aug 25 17:11:53 2006 UTC vs. Revision 1.189 by root, Tue Apr 17 10:06:34 2007 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.10 by root, Fri Aug 25 17:11:53 2006 UTC vs.
Revision 1.189 by root, Tue Apr 17 10:06:34 2007 UTC