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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.68 by elmex, Sat Nov 18 23:16:19 2006 UTC vs.
Revision 1.270 by root, Sat Mar 15 13:52:38 2008 UTC

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.68 by elmex, Sat Nov 18 23:16:19 2006 UTC vs. Revision 1.270 by root, Sat Mar 15 13:52:38 2008 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.68 by elmex, Sat Nov 18 23:16:19 2006 UTC vs.
Revision 1.270 by root, Sat Mar 15 13:52:38 2008 UTC