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

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.11 by root, Sat Aug 26 08:44:06 2006 UTC vs. Revision 1.267 by root, Mon Dec 17 08:03:22 2007 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.11 by root, Sat Aug 26 08:44:06 2006 UTC vs.
Revision 1.267 by root, Mon Dec 17 08:03:22 2007 UTC