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

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.4 by root, Mon Aug 21 07:13:32 2006 UTC vs. Revision 1.221 by root, Sat Jun 16 00:12:20 2007 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.4 by root, Mon Aug 21 07:13:32 2006 UTC vs.
Revision 1.221 by root, Sat Jun 16 00:12:20 2007 UTC