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

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.134 by root, Tue Jan 9 21:32:42 2007 UTC vs. Revision 1.356 by root, Sat Apr 3 02:27:24 2010 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.134 by root, Tue Jan 9 21:32:42 2007 UTC vs.
Revision 1.356 by root, Sat Apr 3 02:27:24 2010 UTC