ViewVC Help

View File | Revision Log | Show Annotations | Download File

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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.4 by root, Mon Aug 21 07:13:32 2006 UTC vs.
Revision 1.304 by root, Wed Oct 1 05:50:19 2008 UTC

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

Diff Legend

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