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.31 by root, Wed Aug 30 12:08:15 2006 UTC vs.
Revision 1.224 by root, Tue Jun 26 05:07:21 2007 UTC

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

Diff Legend

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