ViewVC Help

View File | Revision Log | Show Annotations | Download File

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

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

Diff Legend

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