ViewVC Help

View File | Revision Log | Show Annotations | Download File

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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.19 by root, Mon Aug 28 07:54:11 2006 UTC vs.
Revision 1.267 by root, Mon Dec 17 08:03:22 2007 UTC

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

Diff Legend

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