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

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.120 by root, Sun Dec 31 17:17:23 2006 UTC vs. Revision 1.351 by elmex, Mon Mar 22 18:16:39 2010 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.120 by root, Sun Dec 31 17:17:23 2006 UTC vs.
Revision 1.351 by elmex, Mon Mar 22 18:16:39 2010 UTC