ViewVC Help

View File | Revision Log | Show Annotations | Download File

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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.131 by root, Mon Jan 8 18:18:35 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	{
…		…
101		157
102	unordered_vector<attachable *> attachable::mortals;	158	unordered_vector<attachable *> attachable::mortals;
103		159
104	attachable::~attachable ()	160	attachable::~attachable ()
105	{	161	{
106	assert (!(flags & F_BORROWED));	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	flags &= ~F_BORROWED;
123	refcnt_inc ();
124	SvREFCNT_dec ((SV *)self);	216	SvREFCNT_dec (cb);
		217	cb = 0;
125	}	218	}
126	}
127
128	// check wether the object really is dead
129	void
130	attachable::do_check ()
131	{
132	if (refcnt > 0)
133	return;
134
135	optimise ();
136
137	if (self)
138	{
139	if (refcnt + SvREFCNT (self) > 0)
140	return;
141
142	assert (flags & F_BORROWED);
143
144	flags &= ~F_BORROWED;
145	refcnt_inc ();
146	SvREFCNT_dec (self);
147	self = 0;
148	}
149
150	if (refcnt > 0)
151	return;
152
153	destroy ();
154	}
155
156	void
157	attachable::do_destroy ()
158	{
159	invoke (EVENT_ATTACHABLE_DESTROY, DT_END);
160
161	if (self)
162	hv_clear (self);
163		219
164	mortals.push_back (this);	220	mortals.push_back (this);
165	}	221	}
166		222
167	void	223	void
168	attachable::destroy ()	224	attachable::destroy ()
169	{	225	{
170	if (destroyed ())	226	if (destroyed ())
171	return;	227	return;
172		228
173	flags |= F_DESTROYED;	229	attachable_flags |= F_DESTROYED;
174	do_destroy ();	230	do_destroy ();
		231	sever_self ();
175	}	232	}
176		233
177	void	234	void
178	attachable::check_mortals ()	235	attachable::check_mortals ()
179	{	236	{
180	for (int i = 0; i < mortals.size (); )	237	static int i = 0;
		238
		239	for (;;)
181	{	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
182	attachable *obj = mortals [i];	265	attachable *obj = mortals [i];
183		266
184	obj->refcnt_chk (); // unborrow from perl, if necessary	267	#if 0
185		268	if (obj->self)//D make this an assert later
186	if (obj->refcnt || obj->self)
187	{	269	{
188	#if 0	270	LOG (llevError, "check_mortals: object '%s' still has self\n", typeid (obj).name ());
189	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 ();
190	obj->refcnt, obj->self, obj->self ? SvREFCNT(obj->self): - 1);//D	272	}
191	#endif	273	#endif
192		274
		275	if (obj->refcnt)
		276	{
193	++i; // further delay freeing	277	++i; // further delay freeing
		278
		279	if (!(i & 0x3ff))
		280	break;
194	}//D	281	}
195	else	282	else
196	{	283	{
197	//Dfprintf (stderr, "deleteing %d:%p:%s\n", i, obj,typeid (*obj).name ());//D
198	mortals.erase (i);	284	mortals.erase (i);
		285	obj->sever_self ();
199	delete obj;	286	delete obj;
200	}	287	}
201	}	288	}
202	}	289	}
203		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
204	attachable &	303	attachable &
205	attachable::operator =(const attachable &src)	304	attachable::operator =(const attachable &src)
206	{	305	{
207	//if (self || cb)	306	//if (self || cb)
208	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));	307	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));
209		308
210	attach = src.attach;	309	attach = src.attach;
211	return *this;	310	return *this;
212	}	311	}
213		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
214	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	348	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
215		349
216	static SV *	350	static SV *
217	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())	351	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())
218	{	352	{
219	SV *sv;	353	SV *sv;
220		354
221	if (!ptr)	355	if (!ptr)
222	return &PL_sv_undef;	356	return newSV (0);
223		357
224	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);
225	return sv_bless (newRV_noinc ((SV *)hv), stash);	359	return sv_bless (newRV_noinc ((SV *)hv), stash);
226	}	360	}
227		361
228	static int	362	static int
229	attachable_free (pTHX_ SV *sv, MAGIC *mg)	363	attachable_free (pTHX_ SV *sv, MAGIC *mg)
230	{	364	{
231	attachable *at = (attachable *)mg->mg_ptr;	365	attachable *at = (attachable *)mg->mg_ptr;
232	assert (!(at->flags & attachable::F_BORROWED));	366
		367	//TODO: check if transaction behaviour is really required here
		368	if (SV *self = (SV *)at->self)
		369	{
233	at->self = 0;	370	at->self = 0;
		371	SvREFCNT_dec (self);
		372	}
		373
234	// 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
235	//at->refcnt_chk ();	375	//at->refcnt_chk ();
236	return 0;	376	return 0;
237	}	377	}
238		378
…		…
240		380
241	static SV *	381	static SV *
242	newSVattachable (attachable *obj, HV *stash)	382	newSVattachable (attachable *obj, HV *stash)
243	{	383	{
244	if (!obj)	384	if (!obj)
245	return &PL_sv_undef;	385	return newSV (0);
246		386
247	if (!obj->self)	387	if (!obj->self)
		388	obj->self = newHV ();
		389
		390	if (!SvOBJECT (obj->self))
248	{	391	{
249	obj->self = newHV ();
250	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);
251		393
252	// borrow the refcnt from the object
253	obj->flags |= attachable::F_BORROWED;
254	obj->refcnt_dec ();
255
256	// 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
257	return sv_bless (newRV_inc ((SV *)obj->self), stash);	396	return sv_bless (newRV_inc ((SV *)obj->self), stash);
258	}	397	}
259	else	398	else
		399	{
260	return newRV_inc ((SV *)obj->self);	400	SV *sv = newRV_inc ((SV *)obj->self);
261	}
262		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
263	static void	410	static void
264	clearSVptr (SV *sv)	411	clearSVptr (SV *sv)
265	{	412	{
266	if (SvROK (sv))	413	if (SvROK (sv))
267	sv = SvRV (sv);	414	sv = SvRV (sv);
268		415
269	hv_clear ((HV *)sv);	416	hv_clear ((HV *)sv);
270	sv_unmagic (sv, PERL_MAGIC_ext);	417	sv_unmagic (sv, PERL_MAGIC_ext);
271	}	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	}
272		435
273	static long	436	static long
274	SvPTR (SV *sv, const char *klass)	437	SvPTR (SV *sv, const char *klass)
275	{	438	{
276	if (!sv_derived_from (sv, klass))	439	if (!sv_derived_from (sv, klass))
277	croak ("object of type %s expected", klass);	440	croak ("object of type %s expected", klass);
278		441
279	MAGIC *mg = mg_find (SvRV (sv), PERL_MAGIC_ext);	442	return SvPTR_nc (sv);
280
281	if (!mg)
282	croak ("perl code used %s object, but C object is already destroyed, caught", klass);
283
284	return (long)mg->mg_ptr;
285	}	443	}
286		444
287	static long	445	static long noinline
288	SvPTR_ornull (SV *sv, const char *klass)	446	SvPTR_ornull (SV *sv, const char *klass)
289	{	447	{
290	if (SvOK (sv))	448	if (expect_false (!SvOK (sv))) return 0;
		449
291	return SvPTR (sv, klass);	450	return SvPTR (sv, klass);
292	else
293	return 0;
294	}	451	}
295		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
296	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); }
297	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); }
298	inline SV *to_sv (bool v) { return newSViv (v); }	496	static inline SV *to_sv (bool v) { return newSViv (v); }
299	inline SV *to_sv ( signed char v) { return newSViv (v); }	497	static inline SV *to_sv ( signed char v) { return newSViv (v); }
300	inline SV *to_sv (unsigned char v) { return newSViv (v); }	498	static inline SV *to_sv (unsigned char v) { return newSViv (v); }
301	inline SV *to_sv ( signed short v) { return newSViv (v); }	499	static inline SV *to_sv ( signed short v) { return newSViv (v); }
302	inline SV *to_sv (unsigned short v) { return newSVuv (v); }	500	static inline SV *to_sv (unsigned short v) { return newSVuv (v); }
303	inline SV *to_sv ( signed int v) { return newSViv (v); }	501	static inline SV *to_sv ( signed int v) { return newSViv (v); }
304	inline SV *to_sv (unsigned int v) { return newSVuv (v); }	502	static inline SV *to_sv (unsigned int v) { return newSVuv (v); }
305	inline SV *to_sv ( signed long v) { return newSViv (v); }	503	static inline SV *to_sv ( signed long v) { return newSViv (v); }
306	inline SV *to_sv (unsigned long v) { return newSVuv (v); }	504	static inline SV *to_sv (unsigned long v) { return newSVuv (v); }
307	inline SV *to_sv ( signed long long v) { return newSVval64 (v); }	505	static inline SV *to_sv ( signed long long v) { return newSVval64 (v); }
308	inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }	506	static inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }
309	inline SV *to_sv (float v) { return newSVnv (v); }	507	static inline SV *to_sv (float v) { return newSVnv (v); }
310	inline SV *to_sv (double v) { return newSVnv (v); }	508	static inline SV *to_sv (double v) { return newSVnv (v); }
311	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); }
312	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); }
313	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); }
314	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); }
315	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); }
316	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); }
317	inline SV *to_sv (region * v) { return newSVptr (v, stash_cf_region_wrap); }
318	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); }
319		518
320	inline SV *to_sv (object & v) { return to_sv (&v); }	519	static inline SV *to_sv (object & v) { return to_sv (&v); }
321	inline SV *to_sv (living & v) { return to_sv (&v); }	520	static inline SV *to_sv (living & v) { return to_sv (&v); }
322		521
323	//TODO:	522	static inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); }
324	inline SV *to_sv (New_Face * v) { return to_sv (v->name); }
325	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); }
326		524
327	inline SV *to_sv (UUID v)	525	static inline SV *to_sv (UUID v) { return newSVpv (v.c_str (), 0); }
328	{
329	char buf[128];
330	snprintf (buf, 128, "<1,%" PRIx64 ">", v.seq);
331	return newSVpv (buf, 0);
332	}
333		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
334	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; }
335	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; }
336	inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }	550	static inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }
337	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); }
338	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); }
339	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); }
340	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); }
341	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); }
342	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); }
343	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); }
344	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); }
345	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); }
346	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); }
347	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }	561	static inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
348	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }	562	static inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }
349	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); }
350	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); }
351	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); }
352	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"); }
353	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"); }
354	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"); }
355	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"); }
356	inline void sv_to (SV *sv, region * &v) { v = (region *)SvPTR_ornull (sv, "cf::region"); }
357	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" ); }
358		575
359	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)]; }
360	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)); }
361		578
362	template<class T>	579	template<class T>
363	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; }
364		581
365	template<int N>	582	template<int N>
366	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)); }
367		584
368	inline void sv_to (SV *sv, rangetype &v) { v = (rangetype) SvIV (sv); }
369	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); }
370	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); }
371	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); }
372	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); }
373		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
374	inline void sv_to (SV *sv, UUID &v)	597	static inline void sv_to (SV *sv, UUID &v)
375	{	598	{
376	unsigned int version;	599	if (!v.parse (SvPV_nolen (sv)))
377
378	if (2 != sscanf (SvPV_nolen (sv), "<%d.%" SCNx64 ">", &version, &v.seq) || 1 != version)
379	croak ("unparsable uuid: %s", SvPV_nolen (sv));	600	croak ("unparsable uuid: %s", SvPV_nolen (sv));
380	}	601	}
381		602
382	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); }
383		604
384	static SV *	605	static SV *
385	newSVdt_va (va_list &ap, data_type type)	606	newSVdt_va (va_list &ap, data_type type)
386	{	607	{
387	SV *sv;	608	SV *sv;
…		…
401	break;	622	break;
402		623
403	case DT_STRING:	624	case DT_STRING:
404	{	625	{
405	char *str = (char *)va_arg (ap, const char *);	626	char *str = (char *)va_arg (ap, const char *);
406	sv = str ? newSVpv (str, 0) : &PL_sv_undef;	627	sv = str ? newSVpv (str, 0) : newSV (0);
407	}	628	}
408	break;	629	break;
409		630
410	case DT_DATA:	631	case DT_DATA:
411	{	632	{
412	char *str = (char *)va_arg (ap, const void *);	633	char *str = (char *)va_arg (ap, const void *);
413	int len = va_arg (ap, int);	634	int len = va_arg (ap, int);
414	sv = str ? newSVpv (str, len) : &PL_sv_undef;	635	sv = str ? newSVpv (str, len) : newSV (0);
415	}	636	}
416	break;	637	break;
417		638
418	case DT_OBJECT:	639	case DT_OBJECT:
419	sv = to_sv (va_arg (ap, object *));	640	sv = to_sv (va_arg (ap, object *));
…		…
461	va_end (ap);	682	va_end (ap);
462		683
463	return sv;	684	return sv;
464	}	685	}
465		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
466	static SV *	713	static SV *
467	newSVcfapi (int type, ...)
468	{
469	SV *sv;
470
471	va_list ap;
472	va_start (ap, type);
473
474	switch (type)
475	{
476	case CFAPI_INT: sv = newSViv (*va_arg (ap, int * )); break;
477	case CFAPI_LONG: sv = newSVval64 (*va_arg (ap, sint64 *)); break;
478	case CFAPI_DOUBLE: sv = newSVnv (*va_arg (ap, double *)); break;
479	case CFAPI_STRING: sv = newSVdt_va (ap, DT_STRING); break;
480	case CFAPI_POBJECT: sv = newSVdt_va (ap, DT_OBJECT); break;
481	case CFAPI_PMAP: sv = newSVdt_va (ap, DT_MAP ); break;
482	case CFAPI_PPLAYER: sv = newSVdt_va (ap, DT_PLAYER); break;
483	case CFAPI_PARCH: sv = newSVdt_va (ap, DT_ARCH ); break;
484	case CFAPI_PPARTY: sv = newSVdt_va (ap, DT_PARTY ); break;
485	case CFAPI_PREGION: sv = newSVdt_va (ap, DT_REGION); break;
486
487	default:
488	assert (("unhandled type in newSVcfapi", 0));
489	}
490
491	va_end (ap);
492
493	return sv;
494	}
495
496	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
497
498	SV *
499	registry (attachable *ext)	714	registry (attachable *ext)
500	{	715	{
501	if (!ext->cb)	716	if (!ext->cb)
502	ext->cb = newAV ();	717	ext->cb = newAV ();
503		718
504	return newRV_inc ((SV *)ext->cb);	719	return newRV_inc ((SV *)ext->cb);
505	}	720	}
506		721
507	#if 0
508	void attachable::clear ()
509	{
510	if (self)
511	{
512	// disconnect Perl from C, to avoid crashes
513	sv_unmagic (SvRV ((SV *)self), PERL_MAGIC_ext);
514
515	// clear the perl hash, might or might not be a good idea
516	hv_clear ((HV *)SvRV ((SV *)self));
517
518	SvREFCNT_dec (self);
519	self = 0;
520	}
521
522	if (cb)
523	{
524	SvREFCNT_dec (cb);
525	cb = 0;
526	}
527
528	attach = 0;
529	}
530	#endif
531
532	/////////////////////////////////////////////////////////////////////////////	722	/////////////////////////////////////////////////////////////////////////////
533		723
534	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
535	{
536	return 0;
537	}
538
539	static CommArray_s rtn_cmd;
540
541	static int
542	runPluginCommand (object *obj, char *params)
543	{
544	return -1;
545	}
546
547	extern "C" void *cfperl_getPluginProperty (int *type, ...)
548	{
549	va_list args;
550	char *propname;
551	int i;
552	va_start (args, type);
553	propname = va_arg (args, char *);
554	//printf ("Property name: %s\n", propname);
555
556	if (!strcmp (propname, "command?"))
557	return NULL;
558	else if (!strcmp (propname, "Identification"))
559	{
560	va_end (args);
561	return (void *)PLUGIN_NAME;
562	}
563	else if (!strcmp (propname, "FullName"))
564	{
565	va_end (args);
566	return (void *)PLUGIN_VERSION;
567	}
568	else
569	va_end (args);
570
571	return NULL;
572	}
573
574	extern "C" int cfperl_postInitPlugin ()
575	{
576	int hooktype = 1;
577	int rtype = 0;
578
579	cf_init_plugin (gethook);
580
581	return 0;
582	}
583
584	extern "C" int cfperl_closePlugin ()
585	{
586	return 0;
587	}
588
589	void	724	void
590	cfperl_init ()	725	cfperl_init ()
591	{	726	{
		727	extern char **environ;
		728
592	PERL_SYS_INIT3 (&settings.argc, &settings.argv, 0);	729	PERL_SYS_INIT3 (&settings.argc, &settings.argv, &environ);
593	perl = perl_alloc ();	730	perl = perl_alloc ();
594	perl_construct (perl);	731	perl_construct (perl);
595		732
596	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;	733	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
597		734
598	char *argv[] = {	735	const char *argv[] = {
599	"",	736	settings.argv [0],
600	"-e"	737	"-e0"
601	"use Event; use Coro;" // required for bootstrap
602	"cf->bootstrap;" // required for datadir :*>
603	"unshift @INC, cf::datadir ();"
604	"require cf;"
605	};	738	};
606		739
607	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))
608	{	742	{
609	printf ("unable to initialize perl-interpreter, aborting.\n");	743	printf ("unable to initialize perl-interpreter, aborting.\n");
610	exit (EXIT_FAILURE);	744	exit (EXIT_FAILURE);
611	}	745	}
612	}
613		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
614	void cfperl_main ()	765	cfperl_main ()
615	{	766	{
616	dSP;	767	dSP;
617		768
618	PUSHMARK (SP);	769	PUSHMARK (SP);
619	PUTBACK;	770	PUTBACK;
…		…
623	void	774	void
624	attachable::instantiate ()	775	attachable::instantiate ()
625	{	776	{
626	if (attach)	777	if (attach)
627	{	778	{
628	invoke (EVENT_ATTACHABLE_INSTANTIATE, ARG_STRING (attach), DT_END);	779	INVOKE_ATTACHABLE (INSTANTIATE, this, ARG_STRING (attach));
629	attach = 0;	780	attach = 0;
630	}	781	}
631	}	782	}
632		783
633	void	784	void
634	attachable::reattach ()	785	attachable::reattach ()
635	{	786	{
636	optimise ();	787	optimise ();
637	//TODO: check for _attachment's, very important for restarts	788	//TODO: check for _attachment's, very important for restarts
638	invoke (EVENT_ATTACHABLE_REATTACH, DT_END);	789	INVOKE_ATTACHABLE (REATTACH, this);
639	}	790	}
640		791
641	static event_klass klass_of[NUM_EVENT_TYPES] = {	792	static event_klass klass_of[NUM_EVENT_TYPES] = {
642	# define def(type,name) KLASS_ ## type,	793	# define def(type,name) KLASS_ ## type,
643	# include "eventinc.h"	794	# include "eventinc.h"
644	# undef def	795	# undef def
645	};	796	};
646		797
647	#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)
648		799
649	static void	800	static void noinline
650	gather_callbacks (AV *&callbacks, AV *registry, event_type event)	801	gather_callbacks (AV *&callbacks, AV *registry, event_type event)
651	{	802	{
652	// event must be in array	803	// event must be in array
653	if (event >= 0 && event <= AvFILLp (registry))	804	if (event >= 0 && event <= AvFILLp (registry))
654	{	805	{
…		…
686	}	837	}
687		838
688	void	839	void
689	global::gather_callbacks (AV *&callbacks, event_type event) const	840	global::gather_callbacks (AV *&callbacks, event_type event) const
690	{	841	{
691	::gather_callbacks (callbacks, cb_object, event);	842	::gather_callbacks (callbacks, cb_global, event);
692	}	843	}
693		844
694	void	845	void
695	object::gather_callbacks (AV *&callbacks, event_type event) const	846	object::gather_callbacks (AV *&callbacks, event_type event) const
696	{	847	{
697	if (subtype && type + subtype * NUM_SUBTYPES <= AvFILLp (cb_type))	848	if (subtype && type + subtype * NUM_TYPES <= AvFILLp (cb_type))
698	{	849	{
699	SV *registry = AvARRAY (cb_type)[type + subtype * NUM_SUBTYPES];	850	SV *registry = AvARRAY (cb_type)[type + subtype * NUM_TYPES];
700		851
701	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)	852	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
702	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);	853	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);
703	}	854	}
704		855
…		…
740	{	891	{
741	attachable::gather_callbacks (callbacks, event);	892	attachable::gather_callbacks (callbacks, event);
742	::gather_callbacks (callbacks, cb_map, event);	893	::gather_callbacks (callbacks, cb_map, event);
743	}	894	}
744		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
745	bool	946	bool
746	attachable::invoke (event_type event, ...)	947	attachable::invoke (event_type event, ...)
747	{	948	{
748	data_type dt;	949	data_type dt;
749	va_list ap;
750
751	va_start (ap, event);
752		950
753	// callback call ordering should be:	951	// callback call ordering should be:
754	// 1. per-object callback	952	// 1. per-object callback
755	// 2. per-class object	953	// 2. per-class object
756	// 3. per-type callback	954	// 3. per-type callback
…		…
760	gather_callbacks (callbacks, event);	958	gather_callbacks (callbacks, event);
761		959
762	// short-circuit processing if no callbacks found/defined	960	// short-circuit processing if no callbacks found/defined
763	if (!callbacks)	961	if (!callbacks)
764	return 0;	962	return 0;
		963
		964	va_list ap;
		965	va_start (ap, event);
765		966
766	CALL_BEGIN (3);	967	CALL_BEGIN (3);
767	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays	968	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays
768	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));	969	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));
769		970
…		…
793	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));	994	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
794	}	995	}
795		996
796	va_end (ap);	997	va_end (ap);
797		998
798	CALL_CALL ("cf::do_invoke", G_SCALAR);	999	CALL_CALL (cv_cf_do_invoke, G_SCALAR);
799	count = count > 0 ? POPi : 0;	1000	count = count > 0 ? POPi : 0;
800		1001
801	CALL_END;	1002	CALL_END;
802		1003
803	return count;	1004	return count;
804	}	1005	}
805		1006
806	SV *	1007	static SV *
807	cfperl_result (int idx)	1008	cfperl_result (int idx)
808	{	1009	{
809	AV *av = get_av ("cfperl::invoke_results", 0);	1010	AV *av = get_av ("cf::INVOKE_RESULTS", 0);
810	if (!av)	1011	if (!av)
811	return &PL_sv_undef;	1012	return &PL_sv_undef;
812		1013
813	SV **sv = av_fetch (av, idx, 0);	1014	SV **sv = av_fetch (av, idx, 0);
814	if (!sv)	1015	if (!sv)
…		…
828	{	1029	{
829	return SvNV (cfperl_result (idx));	1030	return SvNV (cfperl_result (idx));
830	}	1031	}
831		1032
832	/////////////////////////////////////////////////////////////////////////////	1033	/////////////////////////////////////////////////////////////////////////////
		1034	// various c++ => perl glue functions
833		1035
834	void	1036	void
		1037	cfperl_tick ()
		1038	{
		1039	tick_pending = 1;
		1040
		1041	if (tick_inhibit)
		1042	return;
		1043
		1044	tick_pending = 0;
		1045
		1046	dSP;
		1047
		1048	PUSHMARK (SP);
		1049	PUTBACK;
		1050	call_pvsv (cv_cf_tick, G_DISCARD | G_VOID);
		1051
		1052	SvNV_set (sv_next_tick, get_next_tick ()); SvNOK_only (sv_next_tick);
		1053	}
		1054
		1055	void
835	maptile::emergency_save ()	1056	cfperl_emergency_save ()
836	{	1057	{
837	CALL_BEGIN (0);	1058	CALL_BEGIN (0);
838	CALL_CALL ("cf::map::emergency_save", G_VOID);	1059	CALL_CALL ("cf::emergency_save", G_VOID);
839	CALL_END;	1060	CALL_END;
840	}	1061	}
841		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
842	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 *
843	maptile::find_sync (const char *path, maptile *origin)	1154	maptile::find_sync (const_utf8_string path, maptile *origin)
844	{	1155	{
845	CALL_BEGIN (2);	1156	CALL_BEGIN (2);
846	CALL_ARG (path);	1157	CALL_ARG (path);
847	CALL_ARG (origin);	1158	CALL_ARG (origin);
848	CALL_CALL ("cf::map::find_sync", G_SCALAR);	1159	CALL_CALL ("cf::map::find_sync", G_SCALAR);
849		1160
850	maptile *retval;	1161	maptile *retval = 0;
851
852	if (count)
853	sv_to (POPs, retval);	1162	if (count) sv_to (POPs, retval);
854	else	1163
855	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);
856		1180
857	CALL_END;	1181	CALL_END;
858		1182
859	return retval;	1183	return retval;
860	}	1184	}
…		…
863	maptile::do_load_sync ()	1187	maptile::do_load_sync ()
864	{	1188	{
865	CALL_BEGIN (1);	1189	CALL_BEGIN (1);
866	CALL_ARG (this);	1190	CALL_ARG (this);
867	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);	1191	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);
868	CALL_END;
869	}
870
871	void
872	maptile::change_all_map_light (int change)
873	{
874	CALL_BEGIN (1);
875	CALL_ARG (change);
876	CALL_CALL ("cf::map::change_all_map_light", G_VOID);
877	CALL_END;	1192	CALL_END;
878	}	1193	}
879		1194
880	void	1195	void
881	object::enter_exit (object *exit)	1196	object::enter_exit (object *exit)
…		…
888	CALL_ARG (exit);	1203	CALL_ARG (exit);
889	CALL_CALL ("cf::object::player::enter_exit", G_VOID);	1204	CALL_CALL ("cf::object::player::enter_exit", G_VOID);
890	CALL_END;	1205	CALL_END;
891	}	1206	}
892		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
893	/////////////////////////////////////////////////////////////////////////////	1319	/////////////////////////////////////////////////////////////////////////////
894		1320
895	struct EventAPI *watcher_base::GEventAPI;	1321	struct EVAPI *evapi::GEVAPI;
896	struct CoroAPI *coroapi::GCoroAPI;	1322	struct CoroAPI *coroapi::GCoroAPI;
897		1323
898	int coroapi::cede_counter;
899
900	static void iw_dispatch (pe_event *ev)
901	{
902	iw *w = (iw *)ev->ext_data;
903	w->call (*w);
904	}
905
906	void	1324	void
907	iw::alloc ()	1325	coroapi::do_cede_to_tick ()
908	{	1326	{
909	pe = GEventAPI->new_idle (0, 0);	1327	cede_pending = 0;
910		1328	cede ();
911	pe->base.callback = (void *)iw_dispatch;
912	pe->base.ext_data = (void *)this;
913	}	1329	}
914		1330
915	static void iow_dispatch (pe_event *ev)
916	{
917	iow *w = (iow *)ev->ext_data;
918	w->call (*w, ((pe_ioevent *)ev)->got);
919	}
920
921	void	1331	void
922	iow::alloc ()	1332	coroapi::wait_for_tick ()
923	{	1333	{
924	pe = GEventAPI->new_io (0, 0);	1334	CALL_BEGIN (0);
925		1335	CALL_CALL ("cf::wait_for_tick", G_DISCARD);
926	pe->base.callback = (void *)iow_dispatch;	1336	CALL_END;
927	pe->base.ext_data = (void *)this;
928
929	pe->fd = -1;
930	pe->poll = 0;
931	}	1337	}
932		1338
933	void	1339	void
934	iow::fd (int fd)	1340	coroapi::wait_for_tick_begin ()
935	{	1341	{
936	pe->fd = fd;	1342	CALL_BEGIN (0);
937	}	1343	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);
938		1344	CALL_END;
939	int
940	iow::poll ()
941	{
942	return pe->poll;
943	}	1345	}
944		1346
945	void	1347	void
946	iow::poll (int events)	1348	iow::poll (int events)
947	{	1349	{
948	if (pe->poll != events)	1350	if (events != this->events)
949	{	1351	{
		1352	int active = ev_is_active ((ev_io *)this);
950	if (pe->poll) stop ();	1353	if (active) stop ();
951	pe->poll = events;	1354	ev_io_set ((ev_io *)this, fd, events);
952	if (pe->poll) start ();	1355	if (active) start ();
953	}	1356	}
954	}	1357	}
955		1358
956	void	1359	static void
957	_connect_to_perl ()	1360	_connect_to_perl_1 ()
958	{	1361	{
959	stash_cf = gv_stashpv ("cf" , 1);	1362	stash_cf = gv_stashpv ("cf", 1);
960		1363
961	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);	1364	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);
962	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);
963	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);	1366	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);
964	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);
965	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);	1369	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);
966	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);	1370	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
967	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);	1371	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
968	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);	1372	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
969	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);	1373	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
970		1374
971	sv_runtime = get_sv ("cf::RUNTIME", 1);	1375	sv_now = get_sv ("cf::NOW" , 1); SvUPGRADE (sv_now , SVt_NV);
972	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);
973		1379
974	cb_global = get_av ("cf::CB_GLOBAL", 1);	1380	cb_global = get_av ("cf::CB_GLOBAL", 1);
975	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);	1381	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
976	cb_object = get_av ("cf::CB_OBJECT", 1);	1382	cb_object = get_av ("cf::CB_OBJECT", 1);
977	cb_player = get_av ("cf::CB_PLAYER", 1);	1383	cb_player = get_av ("cf::CB_PLAYER", 1);
978	cb_client = get_av ("cf::CB_CLIENT", 1);	1384	cb_client = get_av ("cf::CB_CLIENT", 1);
979	cb_type = get_av ("cf::CB_TYPE" , 1);	1385	cb_type = get_av ("cf::CB_TYPE" , 1);
980	cb_map = get_av ("cf::CB_MAP" , 1);	1386	cb_map = get_av ("cf::CB_MAP" , 1);
981	}	1387	}
982		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
983	MODULE = cf PACKAGE = cf PREFIX = cf_	1399	MODULE = cf PACKAGE = cf PREFIX = cf_
984		1400
985	BOOT:	1401	BOOT:
986	{	1402	{
		1403	I_EV_API (PACKAGE); evapi::GEVAPI = GEVAPI;
		1404	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
		1405
987	_connect_to_perl ();	1406	_connect_to_perl_1 ();
988
989	I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;
990	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
991		1407
992	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	//}
993		1418
994	static const struct {	1419	static const struct {
995	const char *name;	1420	const char *name;
996	IV iv;	1421	IV iv;
997	} *civ, const_iv[] = {	1422	} *civ, const_iv[] = {
998	# define const_iv(name) { # name, (IV)name },	1423	# define const_iv(name) { # name, (IV)name },
999	const_iv (llevError)	1424	const_iv (llevError) const_iv (llevInfo) const_iv (llevDebug) const_iv (llevMonster)
1000	const_iv (llevInfo)	1425	const_iv (logBacktrace)
1001	const_iv (llevDebug)	1426
1002	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)
1003		1430
1004	const_iv (MAX_TIME)	1431	const_iv (MAX_TIME)
1005	const_iv (PLAYER)
1006	const_iv (TRANSPORT)
1007	const_iv (ROD)
1008	const_iv (TREASURE)
1009	const_iv (POTION)
1010	const_iv (FOOD)
1011	const_iv (POISON)
1012	const_iv (BOOK)
1013	const_iv (CLOCK)	1432	const_iv (MAXSOCKBUF)
1014	const_iv (ARROW)	1433
1015	const_iv (BOW)
1016	const_iv (WEAPON)
1017	const_iv (ARMOUR)
1018	const_iv (PEDESTAL)
1019	const_iv (ALTAR)
1020	const_iv (LOCKED_DOOR)
1021	const_iv (SPECIAL_KEY)
1022	const_iv (MAP)
1023	const_iv (DOOR)
1024	const_iv (KEY)
1025	const_iv (TIMED_GATE)
1026	const_iv (TRIGGER)
1027	const_iv (GRIMREAPER)
1028	const_iv (MAGIC_EAR)
1029	const_iv (TRIGGER_BUTTON)
1030	const_iv (TRIGGER_ALTAR)
1031	const_iv (TRIGGER_PEDESTAL)
1032	const_iv (SHIELD)
1033	const_iv (HELMET)
1034	const_iv (HORN)
1035	const_iv (MONEY)
1036	const_iv (CLASS)
1037	const_iv (GRAVESTONE)
1038	const_iv (AMULET)
1039	const_iv (PLAYERMOVER)
1040	const_iv (TELEPORTER)
1041	const_iv (CREATOR)
1042	const_iv (SKILL)
1043	const_iv (EARTHWALL)
1044	const_iv (GOLEM)
1045	const_iv (THROWN_OBJ)
1046	const_iv (BLINDNESS)
1047	const_iv (GOD)
1048	const_iv (DETECTOR)
1049	const_iv (TRIGGER_MARKER)
1050	const_iv (DEAD_OBJECT)
1051	const_iv (DRINK)
1052	const_iv (MARKER)
1053	const_iv (HOLY_ALTAR)
1054	const_iv (PLAYER_CHANGER)
1055	const_iv (BATTLEGROUND)
1056	const_iv (PEACEMAKER)
1057	const_iv (GEM)
1058	const_iv (FIREWALL)
1059	const_iv (ANVIL)
1060	const_iv (CHECK_INV)
1061	const_iv (MOOD_FLOOR)	1434	const_iv (NUM_BODY_LOCATIONS)
1062	const_iv (EXIT)	1435	const_iv (body_range) const_iv (body_shield) const_iv (body_combat)
1063	const_iv (ENCOUNTER)	1436	const_iv (body_arm) const_iv (body_torso) const_iv (body_head)
1064	const_iv (SHOP_FLOOR)	1437	const_iv (body_neck) const_iv (body_skill) const_iv (body_finger)
1065	const_iv (SHOP_MAT)	1438	const_iv (body_shoulder) const_iv (body_foot) const_iv (body_hand)
1066	const_iv (RING)	1439	const_iv (body_wrist) const_iv (body_waist)
1067	const_iv (FLOOR)
1068	const_iv (FLESH)
1069	const_iv (INORGANIC)
1070	const_iv (SKILL_TOOL)
1071	const_iv (LIGHTER)
1072	const_iv (BUILDABLE_WALL)
1073	const_iv (MISC_OBJECT)
1074	const_iv (LAMP)
1075	const_iv (DUPLICATOR)
1076	const_iv (SPELLBOOK)
1077	const_iv (CLOAK)
1078	const_iv (SPINNER)
1079	const_iv (GATE)
1080	const_iv (BUTTON)
1081	const_iv (CF_HANDLE)
1082	const_iv (HOLE)
1083	const_iv (TRAPDOOR)
1084	const_iv (SIGN)
1085	const_iv (BOOTS)
1086	const_iv (GLOVES)
1087	const_iv (SPELL)
1088	const_iv (SPELL_EFFECT)
1089	const_iv (CONVERTER)
1090	const_iv (BRACERS)
1091	const_iv (POISONING)
1092	const_iv (SAVEBED)
1093	const_iv (WAND)
1094	const_iv (SCROLL)
1095	const_iv (DIRECTOR)
1096	const_iv (GIRDLE)
1097	const_iv (FORCE)
1098	const_iv (POTION_EFFECT)
1099	const_iv (EVENT_CONNECTOR)
1100	const_iv (CLOSE_CON)
1101	const_iv (CONTAINER)
1102	const_iv (ARMOUR_IMPROVER)
1103	const_iv (WEAPON_IMPROVER)
1104	const_iv (SKILLSCROLL)
1105	const_iv (DEEP_SWAMP)
1106	const_iv (IDENTIFY_ALTAR)
1107	const_iv (MENU)
1108	const_iv (RUNE)
1109	const_iv (TRAP)
1110	const_iv (POWER_CRYSTAL)
1111	const_iv (CORPSE)
1112	const_iv (DISEASE)
1113	const_iv (SYMPTOM)
1114	const_iv (BUILDER)
1115	const_iv (MATERIAL)
1116	const_iv (ITEM_TRANSFORMER)
1117		1440
1118	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)
1119		1470
1120	const_iv (ST_BD_BUILD)	1471	const_iv (NUM_TYPES) const_iv (NUM_SUBTYPES)
1121	const_iv (ST_BD_REMOVE)
1122		1472
1123	const_iv (ST_MAT_FLOOR)	1473	const_iv (ST_BD_BUILD) const_iv (ST_BD_REMOVE)
1124	const_iv (ST_MAT_WALL)	1474	const_iv (ST_MAT_FLOOR) const_iv (ST_MAT_WALL) const_iv (ST_MAT_ITEM)
1125	const_iv (ST_MAT_ITEM)
1126		1475
1127	const_iv (AT_PHYSICAL)	1476	const_iv (AT_PHYSICAL) const_iv (AT_MAGIC) const_iv (AT_FIRE) const_iv (AT_ELECTRICITY)
1128	const_iv (AT_MAGIC)	1477	const_iv (AT_COLD) const_iv (AT_CONFUSION) const_iv (AT_ACID) const_iv (AT_DRAIN)
1129	const_iv (AT_FIRE)	1478	const_iv (AT_WEAPONMAGIC) const_iv (AT_GHOSTHIT) const_iv (AT_POISON) const_iv (AT_SLOW)
1130	const_iv (AT_ELECTRICITY)	1479	const_iv (AT_PARALYZE) const_iv (AT_TURN_UNDEAD) const_iv (AT_FEAR) const_iv (AT_CANCELLATION)
1131	const_iv (AT_COLD)	1480	const_iv (AT_DEPLETE) const_iv (AT_DEATH) const_iv (AT_CHAOS) const_iv (AT_COUNTERSPELL)
1132	const_iv (AT_CONFUSION)	1481	const_iv (AT_GODPOWER) const_iv (AT_HOLYWORD) const_iv (AT_BLIND) const_iv (AT_INTERNAL)
1133	const_iv (AT_ACID)	1482	const_iv (AT_LIFE_STEALING) const_iv (AT_DISEASE)
1134	const_iv (AT_DRAIN)
1135	const_iv (AT_WEAPONMAGIC)
1136	const_iv (AT_GHOSTHIT)
1137	const_iv (AT_POISON)
1138	const_iv (AT_SLOW)
1139	const_iv (AT_PARALYZE)
1140	const_iv (AT_TURN_UNDEAD)
1141	const_iv (AT_FEAR)
1142	const_iv (AT_CANCELLATION)
1143	const_iv (AT_DEPLETE)
1144	const_iv (AT_DEATH)
1145	const_iv (AT_CHAOS)
1146	const_iv (AT_COUNTERSPELL)
1147	const_iv (AT_GODPOWER)
1148	const_iv (AT_HOLYWORD)
1149	const_iv (AT_BLIND)
1150	const_iv (AT_INTERNAL)
1151	const_iv (AT_LIFE_STEALING)
1152	const_iv (AT_DISEASE)
1153		1483
1154	const_iv (WEAP_HIT)	1484	const_iv (WEAP_HIT) const_iv (WEAP_SLASH) const_iv (WEAP_PIERCE) const_iv (WEAP_CLEAVE)
1155	const_iv (WEAP_SLASH)	1485	const_iv (WEAP_SLICE) const_iv (WEAP_STAB) const_iv (WEAP_WHIP) const_iv (WEAP_CRUSH)
1156	const_iv (WEAP_PIERCE)
1157	const_iv (WEAP_CLEAVE)
1158	const_iv (WEAP_SLICE)
1159	const_iv (WEAP_STAB)
1160	const_iv (WEAP_WHIP)
1161	const_iv (WEAP_CRUSH)
1162	const_iv (WEAP_BLUD)	1486	const_iv (WEAP_BLUD)
1163		1487
1164	const_iv (FLAG_ALIVE)	1488	const_iv (FLAG_ALIVE) const_iv (FLAG_WIZ) const_iv (FLAG_REMOVED) const_iv (FLAG_FREED)
1165	const_iv (FLAG_WIZ)	1489	const_iv (FLAG_APPLIED) const_iv (FLAG_UNPAID) const_iv (FLAG_USE_SHIELD)
1166	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)
1167	const_iv (FLAG_FREED)	1528	const_iv (SP_RUNE)
1168	const_iv (FLAG_WAS_WIZ)	1529	const_iv (SP_MAKE_MARK)
1169	const_iv (FLAG_APPLIED)	1530	const_iv (SP_BOLT)
1170	const_iv (FLAG_UNPAID)	1531	const_iv (SP_BULLET)
1171	const_iv (FLAG_USE_SHIELD)	1532	const_iv (SP_EXPLOSION)
1172	const_iv (FLAG_NO_PICK)	1533	const_iv (SP_CONE)
1173	const_iv (FLAG_ANIMATE)	1534	const_iv (SP_BOMB)
1174	const_iv (FLAG_MONSTER)	1535	const_iv (SP_WONDER)
1175	const_iv (FLAG_FRIENDLY)	1536	const_iv (SP_SMITE)
1176	const_iv (FLAG_GENERATOR)	1537	const_iv (SP_MAGIC_MISSILE)
1177	const_iv (FLAG_IS_THROWN)	1538	const_iv (SP_SUMMON_GOLEM)
1178	const_iv (FLAG_AUTO_APPLY)	1539	const_iv (SP_DIMENSION_DOOR)
1179	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)
1180	const_iv (FLAG_SEE_INVISIBLE)	1545	const_iv (SP_INVISIBLE)
1181	const_iv (FLAG_CAN_ROLL)
1182	const_iv (FLAG_OVERLAY_FLOOR)
1183	const_iv (FLAG_IS_TURNABLE)
1184	const_iv (FLAG_IS_USED_UP)
1185	const_iv (FLAG_IDENTIFIED)
1186	const_iv (FLAG_REFLECTING)
1187	const_iv (FLAG_CHANGING)
1188	const_iv (FLAG_SPLITTING)
1189	const_iv (FLAG_HITBACK)
1190	const_iv (FLAG_STARTEQUIP)
1191	const_iv (FLAG_BLOCKSVIEW)
1192	const_iv (FLAG_UNDEAD)
1193	const_iv (FLAG_SCARED)
1194	const_iv (FLAG_UNAGGRESSIVE)
1195	const_iv (FLAG_REFL_MISSILE)
1196	const_iv (FLAG_REFL_SPELL)
1197	const_iv (FLAG_NO_MAGIC)
1198	const_iv (FLAG_NO_FIX_PLAYER)
1199	const_iv (FLAG_IS_LIGHTABLE)
1200	const_iv (FLAG_TEAR_DOWN)
1201	const_iv (FLAG_RUN_AWAY)
1202	const_iv (FLAG_PICK_UP)
1203	const_iv (FLAG_UNIQUE)
1204	const_iv (FLAG_NO_DROP)
1205	const_iv (FLAG_WIZCAST)
1206	const_iv (FLAG_CAST_SPELL)
1207	const_iv (FLAG_USE_SCROLL)
1208	const_iv (FLAG_USE_RANGE)
1209	const_iv (FLAG_USE_BOW)
1210	const_iv (FLAG_USE_ARMOUR)
1211	const_iv (FLAG_USE_WEAPON)
1212	const_iv (FLAG_USE_RING)
1213	const_iv (FLAG_READY_RANGE)
1214	const_iv (FLAG_READY_BOW)
1215	const_iv (FLAG_XRAYS)
1216	const_iv (FLAG_NO_APPLY)
1217	const_iv (FLAG_IS_FLOOR)
1218	const_iv (FLAG_LIFESAVE)
1219	const_iv (FLAG_NO_STRENGTH)
1220	const_iv (FLAG_SLEEP)
1221	const_iv (FLAG_STAND_STILL)
1222	const_iv (FLAG_RANDOM_MOVE)
1223	const_iv (FLAG_ONLY_ATTACK)
1224	const_iv (FLAG_CONFUSED)
1225	const_iv (FLAG_STEALTH)
1226	const_iv (FLAG_WIZPASS)
1227	const_iv (FLAG_IS_LINKED)
1228	const_iv (FLAG_CURSED)
1229	const_iv (FLAG_DAMNED)
1230	const_iv (FLAG_SEE_ANYWHERE)
1231	const_iv (FLAG_KNOWN_MAGICAL)
1232	const_iv (FLAG_KNOWN_CURSED)
1233	const_iv (FLAG_CAN_USE_SKILL)
1234	const_iv (FLAG_BEEN_APPLIED)
1235	const_iv (FLAG_READY_SCROLL)
1236	const_iv (FLAG_USE_ROD)
1237	const_iv (FLAG_USE_HORN)
1238	const_iv (FLAG_MAKE_INVIS)
1239	const_iv (FLAG_INV_LOCKED)
1240	const_iv (FLAG_IS_WOODED)
1241	const_iv (FLAG_IS_HILLY)
1242	const_iv (FLAG_READY_SKILL)
1243	const_iv (FLAG_READY_WEAPON)
1244	const_iv (FLAG_NO_SKILL_IDENT)
1245	const_iv (FLAG_BLIND)
1246	const_iv (FLAG_SEE_IN_DARK)
1247	const_iv (FLAG_IS_CAULDRON)
1248	const_iv (FLAG_NO_STEAL)
1249	const_iv (FLAG_ONE_HIT)
1250	const_iv (FLAG_CLIENT_SENT)
1251	const_iv (FLAG_BERSERK)
1252	const_iv (FLAG_NEUTRAL)
1253	const_iv (FLAG_NO_ATTACK)
1254	const_iv (FLAG_NO_DAMAGE)
1255	const_iv (FLAG_OBJ_ORIGINAL)
1256	const_iv (FLAG_OBJ_SAVE_ON_OVL)
1257	const_iv (FLAG_ACTIVATE_ON_PUSH)
1258	const_iv (FLAG_ACTIVATE_ON_RELEASE)
1259	const_iv (FLAG_IS_WATER)
1260	const_iv (FLAG_CONTENT_ON_GEN)
1261	const_iv (FLAG_IS_A_TEMPLATE)
1262	const_iv (FLAG_IS_BUILDABLE)
1263
1264	const_iv (NDI_BLACK)
1265	const_iv (NDI_WHITE)
1266	const_iv (NDI_NAVY)
1267	const_iv (NDI_RED)
1268	const_iv (NDI_ORANGE)
1269	const_iv (NDI_BLUE)
1270	const_iv (NDI_DK_ORANGE)
1271	const_iv (NDI_GREEN)
1272	const_iv (NDI_LT_GREEN)
1273	const_iv (NDI_GREY)
1274	const_iv (NDI_BROWN)
1275	const_iv (NDI_GOLD)
1276	const_iv (NDI_TAN)
1277	const_iv (NDI_MAX_COLOR)
1278	const_iv (NDI_COLOR_MASK)
1279	const_iv (NDI_UNIQUE)
1280	const_iv (NDI_ALL)
1281
1282	const_iv (UPD_LOCATION)
1283	const_iv (UPD_FLAGS)
1284	const_iv (UPD_WEIGHT)
1285	const_iv (UPD_FACE)
1286	const_iv (UPD_NAME)
1287	const_iv (UPD_ANIM)
1288	const_iv (UPD_ANIMSPEED)
1289	const_iv (UPD_NROF)	1546	const_iv (SP_PROBE)
1290
1291	const_iv (UPD_SP_MANA)	1547	const_iv (SP_HEALING)
1292	const_iv (UPD_SP_GRACE)	1548	const_iv (SP_CREATE_FOOD)
1293	const_iv (UPD_SP_DAMAGE)	1549	const_iv (SP_EARTH_TO_DUST)
1294		1550	const_iv (SP_CHANGE_ABILITY)
1295	const_iv (F_APPLIED)	1551	const_iv (SP_BLESS)
1296	const_iv (F_LOCATION)
1297	const_iv (F_UNPAID)
1298	const_iv (F_MAGIC)
1299	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)
1300	const_iv (F_DAMNED)	1562	const_iv (SP_SWARM)
		1563	const_iv (SP_CHANGE_MANA)
1301	const_iv (F_OPEN)	1564	const_iv (SP_DISPEL_RUNE)
1302	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)
1303	const_iv (F_LOCKED)	1578	const_iv (F_LOCKED)
1304		1579
1305	const_iv (F_BUY)	1580	const_iv (F_BUY) const_iv (F_SHOP) const_iv (F_SELL)
1306	const_iv (F_SHOP)
1307	const_iv (F_SELL)
1308		1581
1309	const_iv (P_BLOCKSVIEW)	1582	const_iv (P_BLOCKSVIEW) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE)
1310	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)
1311	const_iv (P_NO_MAGIC)
1312	const_iv (P_IS_ALIVE)
1313	const_iv (P_NO_CLERIC)
1314	const_iv (P_OUT_OF_MAP)
1315	const_iv (P_NEW_MAP)
1316	const_iv (P_UPTODATE)
1317		1584
1318	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)
1319	const_iv (UP_OBJ_REMOVE)
1320	const_iv (UP_OBJ_CHANGE)
1321	const_iv (UP_OBJ_FACE)
1322		1586
1323	const_iv (INS_NO_MERGE)	1587	const_iv (INS_NO_MERGE) const_iv (INS_ABOVE_FLOOR_ONLY) const_iv (INS_NO_WALK_ON)
1324	const_iv (INS_ABOVE_FLOOR_ONLY)
1325	const_iv (INS_NO_WALK_ON)
1326	const_iv (INS_ON_TOP)
1327	const_iv (INS_BELOW_ORIGINATOR)	1588	const_iv (INS_ON_TOP) const_iv (INS_BELOW_ORIGINATOR)
1328	const_iv (INS_MAP_LOAD)
1329		1589
1330	const_iv (WILL_APPLY_HANDLE)	1590	const_iv (WILL_APPLY_HANDLE) const_iv (WILL_APPLY_TREASURE) const_iv (WILL_APPLY_EARTHWALL)
1331	const_iv (WILL_APPLY_TREASURE)	1591	const_iv (WILL_APPLY_DOOR) const_iv (WILL_APPLY_FOOD)
1332	const_iv (WILL_APPLY_EARTHWALL)
1333	const_iv (WILL_APPLY_DOOR)
1334	const_iv (WILL_APPLY_FOOD)
1335		1592
1336	const_iv (SAVE_MODE)	1593	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)
1337	const_iv (SAVE_DIR_MODE)
1338		1594
1339	const_iv (M_PAPER)	1595	const_iv (M_PAPER) const_iv (M_IRON) const_iv (M_GLASS) const_iv (M_LEATHER)
1340	const_iv (M_IRON)	1596	const_iv (M_WOOD) const_iv (M_ORGANIC) const_iv (M_STONE) const_iv (M_CLOTH)
1341	const_iv (M_GLASS)	1597	const_iv (M_ADAMANT) const_iv (M_LIQUID) const_iv (M_SOFT_METAL) const_iv (M_BONE)
1342	const_iv (M_LEATHER)	1598	const_iv (M_ICE) const_iv (M_SPECIAL)
1343	const_iv (M_WOOD)	1599
1344	const_iv (M_ORGANIC)	1600	const_iv (SK_EXP_ADD_SKILL) const_iv (SK_EXP_TOTAL) const_iv (SK_EXP_NONE)
1345	const_iv (M_STONE)	1601	const_iv (SK_SUBTRACT_SKILL_EXP) const_iv (SK_EXP_SKILL_ONLY)
1346	const_iv (M_CLOTH)	1602
1347	const_iv (M_ADAMANT)	1603	const_iv (SK_LOCKPICKING) const_iv (SK_HIDING) const_iv (SK_SMITHERY) const_iv (SK_BOWYER)
1348	const_iv (M_LIQUID)	1604	const_iv (SK_JEWELER) const_iv (SK_ALCHEMY) const_iv (SK_STEALING) const_iv (SK_LITERACY)
1349	const_iv (M_SOFT_METAL)	1605	const_iv (SK_BARGAINING) const_iv (SK_JUMPING) const_iv (SK_DET_MAGIC) const_iv (SK_ORATORY)
1350	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)
1351	const_iv (M_ICE)	1633	const_iv (MAP_INACTIVE)
1352	const_iv (M_SPECIAL)
1353		1634
1354	const_iv (SK_EXP_ADD_SKILL)	1635	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)
1355	const_iv (SK_EXP_TOTAL)	1636	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)
1356	const_iv (SK_EXP_NONE)
1357	const_iv (SK_SUBTRACT_SKILL_EXP)
1358	const_iv (SK_EXP_SKILL_ONLY)
1359		1637
1360	const_iv (SK_LOCKPICKING)	1638	const_iv (VERSION_CS) const_iv (VERSION_SC)
1361	const_iv (SK_HIDING)
1362	const_iv (SK_SMITHERY)
1363	const_iv (SK_BOWYER)
1364	const_iv (SK_JEWELER)
1365	const_iv (SK_ALCHEMY)
1366	const_iv (SK_STEALING)
1367	const_iv (SK_LITERACY)
1368	const_iv (SK_BARGAINING)
1369	const_iv (SK_JUMPING)
1370	const_iv (SK_DET_MAGIC)
1371	const_iv (SK_ORATORY)
1372	const_iv (SK_SINGING)
1373	const_iv (SK_DET_CURSE)
1374	const_iv (SK_FIND_TRAPS)
1375	const_iv (SK_MEDITATION)
1376	const_iv (SK_PUNCHING)
1377	const_iv (SK_FLAME_TOUCH)
1378	const_iv (SK_KARATE)
1379	const_iv (SK_CLIMBING)
1380	const_iv (SK_WOODSMAN)
1381	const_iv (SK_INSCRIPTION)
1382	const_iv (SK_ONE_HANDED_WEAPON)
1383	const_iv (SK_MISSILE_WEAPON)
1384	const_iv (SK_THROWING)
1385	const_iv (SK_USE_MAGIC_ITEM)
1386	const_iv (SK_DISARM_TRAPS)
1387	const_iv (SK_SET_TRAP)
1388	const_iv (SK_THAUMATURGY)
1389	const_iv (SK_PRAYING)
1390	const_iv (SK_CLAWING)
1391	const_iv (SK_LEVITATION)
1392	const_iv (SK_SUMMONING)
1393	const_iv (SK_PYROMANCY)
1394	const_iv (SK_EVOCATION)
1395	const_iv (SK_SORCERY)
1396	const_iv (SK_TWO_HANDED_WEAPON)
1397	const_iv (SK_SPARK_TOUCH)
1398	const_iv (SK_SHIVER)
1399	const_iv (SK_ACID_SPLASH)
1400	const_iv (SK_POISON_NAIL)
1401		1639
1402	const_iv (SOUND_NEW_PLAYER)	1640	const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)
1403	const_iv (SOUND_FIRE_ARROW)
1404	const_iv (SOUND_LEARN_SPELL)
1405	const_iv (SOUND_FUMBLE_SPELL)
1406	const_iv (SOUND_WAND_POOF)
1407	const_iv (SOUND_OPEN_DOOR)
1408	const_iv (SOUND_PUSH_PLAYER)
1409	const_iv (SOUND_PLAYER_HITS1)
1410	const_iv (SOUND_PLAYER_HITS2)
1411	const_iv (SOUND_PLAYER_HITS3)
1412	const_iv (SOUND_PLAYER_HITS4)
1413	const_iv (SOUND_PLAYER_IS_HIT1)
1414	const_iv (SOUND_PLAYER_IS_HIT2)
1415	const_iv (SOUND_PLAYER_IS_HIT3)
1416	const_iv (SOUND_PLAYER_KILLS)
1417	const_iv (SOUND_PET_IS_KILLED)
1418	const_iv (SOUND_PLAYER_DIES)
1419	const_iv (SOUND_OB_EVAPORATE)
1420	const_iv (SOUND_OB_EXPLODE)
1421	const_iv (SOUND_CLOCK)
1422	const_iv (SOUND_TURN_HANDLE)
1423	const_iv (SOUND_FALL_HOLE)
1424	const_iv (SOUND_DRINK_POISON)
1425	const_iv (SOUND_CAST_SPELL_0)
1426		1641
1427	const_iv (PREFER_LOW)	1642	const_iv (ST_DEAD) const_iv (ST_SETUP) const_iv (ST_PLAYING) const_iv (ST_CUSTOM)
1428	const_iv (PREFER_HIGH)
1429		1643
1430	const_iv (ATNR_PHYSICAL)	1644	const_iv (IO_HEADER) const_iv (IO_OBJECTS) const_iv (IO_UNIQUES)
1431	const_iv (ATNR_MAGIC)
1432	const_iv (ATNR_FIRE)
1433	const_iv (ATNR_ELECTRICITY)
1434	const_iv (ATNR_COLD)
1435	const_iv (ATNR_CONFUSION)
1436	const_iv (ATNR_ACID)
1437	const_iv (ATNR_DRAIN)
1438	const_iv (ATNR_WEAPONMAGIC)
1439	const_iv (ATNR_GHOSTHIT)
1440	const_iv (ATNR_POISON)
1441	const_iv (ATNR_SLOW)
1442	const_iv (ATNR_PARALYZE)
1443	const_iv (ATNR_TURN_UNDEAD)
1444	const_iv (ATNR_FEAR)
1445	const_iv (ATNR_CANCELLATION)
1446	const_iv (ATNR_DEPLETE)
1447	const_iv (ATNR_DEATH)
1448	const_iv (ATNR_CHAOS)
1449	const_iv (ATNR_COUNTERSPELL)
1450	const_iv (ATNR_GODPOWER)
1451	const_iv (ATNR_HOLYWORD)
1452	const_iv (ATNR_BLIND)
1453	const_iv (ATNR_INTERNAL)
1454	const_iv (ATNR_LIFE_STEALING)
1455	const_iv (ATNR_DISEASE)
1456
1457	const_iv (MAP_FLUSH)
1458	const_iv (MAP_PLAYER_UNIQUE)
1459	const_iv (MAP_BLOCK)
1460	const_iv (MAP_STYLE)
1461	const_iv (MAP_OVERLAY)
1462
1463	const_iv (MAP_IN_MEMORY)
1464	const_iv (MAP_SWAPPED)
1465	const_iv (MAP_LOADING)
1466	const_iv (MAP_SAVING)
1467
1468	const_iv (KLASS_ATTACHABLE)
1469	const_iv (KLASS_GLOBAL)
1470	const_iv (KLASS_OBJECT)
1471	const_iv (KLASS_CLIENT)
1472	const_iv (KLASS_PLAYER)
1473	const_iv (KLASS_MAP)
1474
1475	const_iv (CS_QUERY_YESNO)
1476	const_iv (CS_QUERY_SINGLECHAR)
1477	const_iv (CS_QUERY_HIDEINPUT)
1478
1479	const_iv (ST_DEAD)
1480	const_iv (ST_SETUP)
1481	const_iv (ST_PLAYING)
1482	const_iv (ST_CUSTOM)
1483
1484	const_iv (ST_CHANGE_CLASS)
1485
1486	const_iv (IO_HEADER)
1487	const_iv (IO_OBJECTS)
1488	const_iv (IO_UNIQUES)
1489		1645
1490	// random map generator	1646	// random map generator
1491	const_iv (LAYOUT_NONE)	1647	const_iv (LAYOUT_NONE) const_iv (LAYOUT_ONION) const_iv (LAYOUT_MAZE) const_iv (LAYOUT_SPIRAL)
1492	const_iv (LAYOUT_ONION)	1648	const_iv (LAYOUT_ROGUELIKE) const_iv (LAYOUT_SNAKE) const_iv (LAYOUT_SQUARE_SPIRAL)
1493	const_iv (LAYOUT_MAZE)
1494	const_iv (LAYOUT_SPIRAL)
1495	const_iv (LAYOUT_ROGUELIKE)
1496	const_iv (LAYOUT_SNAKE)
1497	const_iv (LAYOUT_SQUARE_SPIRAL)
1498		1649
1499	const_iv (RMOPT_RANDOM)	1650	const_iv (RMOPT_RANDOM) const_iv (RMOPT_CENTERED) const_iv (RMOPT_LINEAR)
1500	const_iv (RMOPT_CENTERED)	1651	const_iv (RMOPT_BOTTOM_C) const_iv (RMOPT_BOTTOM_R) const_iv (RMOPT_IRR_SPACE)
1501	const_iv (RMOPT_LINEAR)	1652	const_iv (RMOPT_WALL_OFF) const_iv (RMOPT_WALLS_ONLY) const_iv (RMOPT_NO_DOORS)
1502	const_iv (RMOPT_BOTTOM_C)
1503	const_iv (RMOPT_BOTTOM_R)
1504	const_iv (RMOPT_IRR_SPACE)
1505	const_iv (RMOPT_WALL_OFF)
1506	const_iv (RMOPT_WALLS_ONLY)
1507	const_iv (RMOPT_NO_DOORS)
1508		1653
1509	const_iv (SYMMETRY_RANDOM)	1654	const_iv (SYMMETRY_RANDOM) const_iv (SYMMETRY_NONE) const_iv (SYMMETRY_X)
1510	const_iv (SYMMETRY_NONE)	1655	const_iv (SYMMETRY_Y) const_iv (SYMMETRY_XY)
1511	const_iv (SYMMETRY_X)	1656
1512	const_iv (SYMMETRY_Y)	1657	const_iv (GT_ENVIRONMENT) const_iv (GT_INVISIBLE) const_iv (GT_STARTEQUIP)
1513	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)
1514	};	1662	};
1515		1663
1516	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; )
1517	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));	1665	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1518		1666
…		…
1535	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));	1683	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));
1536	av_push (event, newSViv (eiv->klass));	1684	av_push (event, newSViv (eiv->klass));
1537	av_store (av, eiv->iv, newRV_noinc ((SV *)event));	1685	av_store (av, eiv->iv, newRV_noinc ((SV *)event));
1538	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));	1686	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));
1539	}	1687	}
1540	}
1541		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
1542	void _connect_to_perl ()	1707	void _connect_to_perl_1 ()
1543		1708
		1709	void _connect_to_perl_2 ()
		1710
		1711	void _recalc_want ()
		1712
		1713	# not used by default anymore
1544	void _global_reattach ()	1714	void _global_reattach ()
1545	CODE:	1715	CODE:
1546	{	1716	{
1547	// reattach to all attachable objects in the game.	1717	// reattach to all attachable objects in the game.
1548	for_all_clients (ns)	1718	for_all_clients (ns)
1549	ns->reattach ();	1719	ns->reattach ();
1550		1720
1551	for_all_players (pl)
1552	pl->reattach ();
1553
1554	//TODO
1555	//for (map_container::iterator i = maps.begin (); i != maps.end (); ++i)
1556	// i->second->reattach ();
1557
1558	for_all_objects (op)	1721	for_all_objects (op)
1559	op->reattach ();	1722	op->reattach ();
1560	}	1723	}
1561		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
1562	NV floor (NV x)	1842	NV floor (NV x)
1563		1843
1564	NV ceil (NV x)	1844	NV ceil (NV x)
1565		1845
1566	void server_tick ()	1846	NV rndm (...)
		1847	ALIAS:
		1848	rmg_rndm = 1
1567	CODE:	1849	CODE:
1568	runtime = SvNVx (sv_runtime);	1850	{
1569	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
1570		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
1571	void	1881	void
1572	LOG (int level, char *msg)	1882	log_backtrace (utf8_string msg)
		1883
		1884	void
		1885	LOG (int flags, utf8_string msg)
1573	PROTOTYPE: $$	1886	PROTOTYPE: $$
1574	C_ARGS: (LogLevel)level, "%s", msg	1887	C_ARGS: flags, "%s", msg
1575		1888
1576	char *path_combine (char *base, char *path)	1889	octet_string path_combine (octet_string base, octet_string path)
1577	PROTOTYPE: $$	1890	PROTOTYPE: $$
1578		1891
1579	char *path_combine_and_normalize (char *base, char *path)	1892	octet_string path_combine_and_normalize (octet_string base, octet_string path)
1580	PROTOTYPE: $$	1893	PROTOTYPE: $$
1581		1894
1582	const char *
1583	get_maps_directory (char *path)
1584	PROTOTYPE: $
1585	ALIAS: maps_directory = 0
1586	CODE:
1587	RETVAL = create_pathname (path);
1588	OUTPUT: RETVAL
1589
1590	void	1895	void
1591	sub_generation_inc ()	1896	sub_generation_inc ()
1592	CODE:	1897	CODE:
1593	PL_sub_generation++;	1898	PL_sub_generation++;
1594		1899
1595	char *	1900	const_octet_string
1596	mapdir ()	1901	mapdir ()
1597	PROTOTYPE:	1902	PROTOTYPE:
1598	ALIAS:	1903	ALIAS:
1599	mapdir = 0	1904	mapdir = 0
1600	uniquedir = 1	1905	uniquedir = 1
…		…
1616	}	1921	}
1617	OUTPUT: RETVAL	1922	OUTPUT: RETVAL
1618		1923
1619	void abort ()	1924	void abort ()
1620		1925
		1926	void reset_signals ()
		1927
		1928	void fork_abort (const_octet_string cause = "cf::fork_abort")
		1929
		1930	void cleanup (const_octet_string cause, bool make_core = false)
		1931
1621	void emergency_save ()	1932	void emergency_save ()
1622		1933
1623	void _exit (int status = 0)	1934	void _exit (int status = EXIT_SUCCESS)
1624		1935
1625	#if _POSIX_MEMLOCK	1936	#if _POSIX_MEMLOCK
1626		1937
1627	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
1628		1946
1629	int munlockall ()	1947	int munlockall ()
1630		1948
1631	#endif	1949	#endif
1632		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
1633	int find_animation (char *text)	1980	int find_animation (utf8_string text)
1634	PROTOTYPE: $	1981	PROTOTYPE: $
1635		1982
1636	int random_roll (int min, int max, object *op, int goodbad);	1983	int random_roll (int min, int max, object *op, int goodbad);
1637		1984
1638	const char *cost_string_from_value(uint64 cost, int approx = 0)	1985	const_utf8_string cost_string_from_value(uint64 cost, int approx = 0)
1639		1986
1640	int	1987	int
1641	exp_to_level (val64 exp)	1988	exp_to_level (val64 exp)
1642	CODE:	1989	CODE:
1643	{	1990	{
…		…
1674	RETVAL = newSVpv (resist_plus[atnr], 0);	2021	RETVAL = newSVpv (resist_plus[atnr], 0);
1675	else	2022	else
1676	XSRETURN_UNDEF;	2023	XSRETURN_UNDEF;
1677	OUTPUT: RETVAL	2024	OUTPUT: RETVAL
1678		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
1679	MODULE = cf PACKAGE = cf::attachable	2074	MODULE = cf PACKAGE = cf::attachable
1680		2075
1681	int	2076	int
1682	valid (SV *obj)	2077	valid (SV *obj)
1683	CODE:	2078	CODE:
1684	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);	2079	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
1685	OUTPUT:	2080	OUTPUT:
1686	RETVAL	2081	RETVAL
1687		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
1688	INCLUDE: $PERL genacc attachable ../include/cfperl.h |	2100	INCLUDE: $PERL $srcdir/genacc attachable ../include/util.h ../include/cfperl.h |
1689		2101
1690	MODULE = cf PACKAGE = cf::global	2102	MODULE = cf PACKAGE = cf::global
1691		2103
1692	int invoke (SV *klass, int event, ...)	2104	int invoke (SV *klass, int event, ...)
1693	CODE:	2105	CODE:
…		…
1697	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);
1698	OUTPUT: RETVAL	2110	OUTPUT: RETVAL
1699		2111
1700	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_	2112	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
1701		2113
1702	INCLUDE: $PERL genacc object ../include/object.h |	2114	INCLUDE: $PERL $srcdir/genacc object ../include/object.h |
1703		2115
1704	int invoke (object *op, int event, ...)	2116	int invoke (object *op, int event, ...)
1705	CODE:	2117	CODE:
1706	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");
1707	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	2119	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
1709	RETVAL = op->invoke ((event_type)event, ARG_AV (av), DT_END);	2121	RETVAL = op->invoke ((event_type)event, ARG_AV (av), DT_END);
1710	OUTPUT: RETVAL	2122	OUTPUT: RETVAL
1711		2123
1712	SV *registry (object *op)	2124	SV *registry (object *op)
1713		2125
1714	void mortals ()	2126	int objects_size ()
1715	PPCODE:	2127	CODE:
1716	EXTEND (SP, object::mortals.size ());
1717	for (AUTODECL (i, object::mortals.begin ()); i != object::mortals.end (); ++i)
1718	PUSHs (to_sv (*i));
1719
1720	object *first ()
1721	CODE:
1722	RETVAL = object::first;	2128	RETVAL = objects.size ();
1723	OUTPUT: RETVAL	2129	OUTPUT: RETVAL
		2130
		2131	object *objects (U32 index)
		2132	CODE:
		2133	RETVAL = index < objects.size () ? objects [index] : 0;
		2134	OUTPUT: RETVAL
		2135
		2136	int actives_size ()
		2137	CODE:
		2138	RETVAL = actives.size ();
		2139	OUTPUT: RETVAL
		2140
		2141	object *actives (U32 index)
		2142	CODE:
		2143	RETVAL = index < actives.size () ? actives [index] : 0;
		2144	OUTPUT: RETVAL
		2145
		2146	int mortals_size ()
		2147	CODE:
		2148	RETVAL = attachable::mortals.size ();
		2149	OUTPUT: RETVAL
		2150
		2151	const_utf8_string slot_use_name (U32 slot)
		2152	ALIAS:
		2153	slot_nonuse_name = 1
		2154	CODE:
		2155	{
		2156	if (slot >= NUM_BODY_LOCATIONS)
		2157	croak ("body slot index out of range");
		2158
		2159	switch (ix)
		2160	{
		2161	case 0: RETVAL = body_locations[slot].use_name; break;
		2162	case 1: RETVAL = body_locations[slot].nonuse_name; break;
		2163	}
		2164	}
		2165	OUTPUT:
		2166	RETVAL
1724		2167
1725	# missing properties	2168	# missing properties
1726		2169
1727	object *head (object *op)	2170	object *head (object *op)
1728	PROTOTYPE: $	2171	PROTOTYPE: $
1729	CODE:	2172	CODE:
1730	RETVAL = op->head ? op->head : op;
1731	OUTPUT: RETVAL
1732
1733	int is_head (object *op)
1734	PROTOTYPE: $
1735	CODE:
1736	RETVAL = !op->head;	2173	RETVAL = op->head_ ();
1737	OUTPUT: RETVAL	2174	OUTPUT: RETVAL
1738		2175
1739	void	2176	void
1740	inv (object *obj)	2177	inv (object *obj)
1741	PROTOTYPE: $	2178	PROTOTYPE: $
1742	PPCODE:	2179	PPCODE:
1743	{	2180	{
1744	object *o;
1745	for (o = obj->inv; o; o = o->below)	2181	for (object *o = obj->inv; o; o = o->below)
1746	XPUSHs (sv_2mortal (to_sv (o)));	2182	XPUSHs (sv_2mortal (to_sv (o)));
1747	}	2183	}
1748		2184
1749	void	2185	void
1750	set_animation (object *op, int idx)	2186	set_animation (object *op, int idx)
1751	CODE:	2187	CODE:
1752	SET_ANIMATION (op, idx);	2188	SET_ANIMATION (op, idx);
1753		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
1754	object *find_best_object_match (object *op, const char *match)	2215	object *find_best_object_match (object *op, utf8_string match)
1755		2216
1756	object *find_marked_object (object *op)	2217	object *find_marked_object (object *op)
1757		2218
1758	int need_identify (object *obj);	2219	int need_identify (object *obj);
1759		2220
1760	int apply_shop_mat (object *shop_mat, object *op);	2221	int apply_shop_mat (object *shop_mat, object *op);
1761		2222
1762	int move (object *op, int dir, object *originator = op)	2223	int move (object *op, int dir, object *originator = op)
1763	CODE:	2224	CODE:
1764	RETVAL = move_ob (op, dir, originator);	2225	RETVAL = op->move (dir, originator);
1765	OUTPUT:	2226	OUTPUT:
1766	RETVAL	2227	RETVAL
1767		2228
1768	void apply (object *applier, object *applied, int flags = 0)
1769	CODE:
1770	manual_apply (applied, applier, flags);
1771
1772	void apply_below (object *op)	2229	void apply_below (object *op)
1773	CODE:	2230	CODE:
1774	player_apply_below (op);	2231	player_apply_below (op);
1775		2232
1776	object *cf_object_present_archname_inside (object *op, char *whatstr)	2233	int cast_heal (object *op, object *caster, object *spell, int dir = 0)
1777		2234
1778	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)
1779
1780	int cf_object_change_map (object *op, int x, int y, maptile *map)
1781
1782	#//TODO
1783	object *clone_ (object *op, int recursive = 0)
1784	CODE:
1785	if (recursive)
1786	RETVAL = object_create_clone (op);
1787	else
1788	{
1789	RETVAL = object::create ();
1790	op->copy_to (RETVAL);
1791	}
1792	OUTPUT: RETVAL
1793		2236
1794	int pay_item (object *op, object *buyer)	2237	int pay_item (object *op, object *buyer)
1795	CODE:	2238	CODE:
1796	RETVAL = pay_for_item (op, buyer);	2239	RETVAL = pay_for_item (op, buyer);
1797	OUTPUT: RETVAL	2240	OUTPUT: RETVAL
…		…
1801	RETVAL = pay_for_amount (amount, op);	2244	RETVAL = pay_for_amount (amount, op);
1802	OUTPUT: RETVAL	2245	OUTPUT: RETVAL
1803		2246
1804	void pay_player (object *op, uint64 amount)	2247	void pay_player (object *op, uint64 amount)
1805		2248
1806	val64 pay_player_arch (object *op, const char *arch, uint64 amount)	2249	val64 pay_player_arch (object *op, utf8_string arch, uint64 amount)
1807		2250
1808	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)
1809		2252
1810	void learn_spell (object *op, object *sp, int special_prayer = 0)	2253	void learn_spell (object *op, object *sp, int special_prayer = 0)
1811	CODE:	2254	CODE:
1812	do_learn_spell (op, sp, special_prayer);	2255	do_learn_spell (op, sp, special_prayer);
1813		2256
1814	void forget_spell (object *op, object *sp)	2257	void forget_spell (object *op, object *sp)
1815	CODE:	2258	CODE:
1816	do_forget_spell (op, query_name (sp));	2259	do_forget_spell (op, query_name (sp));
1817		2260
1818	object *check_for_spell (object *op, char *spellname)	2261	object *check_for_spell (object *op, utf8_string spellname)
1819	CODE:	2262	CODE:
1820	RETVAL = check_spell_known (op, spellname);	2263	RETVAL = check_spell_known (op, spellname);
1821	OUTPUT: RETVAL	2264	OUTPUT: RETVAL
1822		2265
1823	int query_money (object *op)	2266	int query_money (object *op)
…		…
1832		2275
1833	void drop (object *who, object *op)	2276	void drop (object *who, object *op)
1834		2277
1835	void pick_up (object *who, object *op)	2278	void pick_up (object *who, object *op)
1836		2279
1837	object *cf_object_insert_object (object *op, object *container)
1838
1839	object *cf_object_insert_in_ob (object *ob, object *where)
1840
1841	int cf_object_teleport (object *op, maptile *map, int x, int y)
1842
1843	void update_object (object *op, int action)	2280	void update_object (object *op, int action)
1844		2281
1845	object *cf_create_object_by_name (const char *name)
1846
1847	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)
1848		2283
1849	void player_lvl_adj (object *who, object *skill = 0)	2284	void player_lvl_adj (object *who, object *skill = 0)
1850		2285
1851	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)
1852		2287
1853	int calc_skill_exp (object *who, object *op, object *skill);	2288	int calc_skill_exp (object *who, object *op, object *skill)
1854		2289
1855	void push_button (object *op);	2290	void push_button (object *op, object *originator)
1856		2291
1857	void use_trigger (object *op);	2292	void use_trigger (object *op, object *originator)
1858		2293
1859	void add_button_link (object *button, maptile *map, int connected);	2294	void handle_apply_yield (object *op)
1860		2295
1861	void remove_button_link (object *op);	2296	int convert_item (object *item, object *converter)
1862		2297
		2298	void fix_generated_item (object *op, object *creator, int difficulty, int max_magic, int flags);
1863		2299
1864	MODULE = cf PACKAGE = cf::object PREFIX = cf_	2300	MODULE = cf PACKAGE = cf::object PREFIX = cf_
1865
1866	object *cf_insert_ob_in_ob (object *ob, object *where)
1867		2301
1868	# 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
1869	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.	2303	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.
1870		2304
1871	object *new (const char *archetype = 0)	2305	object *new (utf8_string archetype = 0)
1872	PROTOTYPE: ;$	2306	PROTOTYPE: ;$
1873	CODE:	2307	CODE:
1874	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();	2308	RETVAL = archetype ? get_archetype (archetype) : object::create ();
1875	OUTPUT:	2309	OUTPUT:
1876	RETVAL	2310	RETVAL
1877		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
1878	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)
1879	PROTOTYPE: $$$$$$	2326	PROTOTYPE: $$$$$$
1880	CODE:	2327	CODE:
1881	{	2328	{
1882	int unused_type;	2329	RETVAL = insert_ob_in_map_at (ob, where, orig, flag, x, y);
1883	RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);
1884	}
1885		2330
1886	# syntatic sugar for easier use in event callbacks.	2331	if (RETVAL->destroyed ())
1887	const char *options (object *op)
1888	CODE:
1889	RETVAL = op->name;
1890	OUTPUT:
1891	RETVAL	2332	RETVAL = 0;
		2333	}
1892		2334
1893	player *contr (object *op)	2335	shstr
1894	CODE:	2336	object::kv_get (shstr key)
1895	RETVAL = op->contr;
1896	OUTPUT: RETVAL
1897		2337
1898	const char *get_ob_key_value (object *op, const char *key)	2338	void
		2339	object::kv_del (shstr key)
1899		2340
1900	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)
1901		2343
1902	object *get_nearest_player (object *ob)	2344	object *get_nearest_player (object *ob)
1903	ALIAS: nearest_player = 0	2345	ALIAS: nearest_player = 0
1904	PREINIT:	2346	PREINIT:
1905	extern object *get_nearest_player (object *);	2347	extern object *get_nearest_player (object *);
…		…
1907	void rangevector (object *ob, object *other, int flags = 0)	2349	void rangevector (object *ob, object *other, int flags = 0)
1908	PROTOTYPE: $$;$	2350	PROTOTYPE: $$;$
1909	PPCODE:	2351	PPCODE:
1910	{	2352	{
1911	rv_vector rv;	2353	rv_vector rv;
		2354
		2355	PUTBACK;
1912	get_rangevector (ob, other, &rv, flags);	2356	get_rangevector (ob, other, &rv, flags);
		2357	SPAGAIN;
		2358
1913	EXTEND (SP, 5);	2359	EXTEND (SP, 5);
1914	PUSHs (newSVuv (rv.distance));	2360	PUSHs (newSVuv (rv.distance));
1915	PUSHs (newSViv (rv.distance_x));	2361	PUSHs (newSViv (rv.distance_x));
1916	PUSHs (newSViv (rv.distance_y));	2362	PUSHs (newSViv (rv.distance_y));
1917	PUSHs (newSViv (rv.direction));	2363	PUSHs (newSViv (rv.direction));
1918	PUSHs (newSVcfapi (CFAPI_POBJECT, rv.part));	2364	PUSHs (to_sv (rv.part));
1919	}	2365	}
1920		2366
1921	bool on_same_map_as (object *ob, object *other)	2367	bool on_same_map_as (object *ob, object *other)
1922	CODE:	2368	CODE:
1923	RETVAL = on_same_map (ob, other);	2369	RETVAL = on_same_map (ob, other);
1924	OUTPUT: RETVAL	2370	OUTPUT: RETVAL
1925		2371
1926	const char *	2372	const_utf8_string
1927	base_name (object *op, int plural = op->nrof > 1)	2373	base_name (object *op, int plural = op->nrof > 1)
1928	CODE:	2374	CODE:
1929	RETVAL = query_base_name (op, plural);	2375	RETVAL = query_base_name (op, plural);
1930	OUTPUT: RETVAL	2376	OUTPUT: RETVAL
1931		2377
1932	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)));
1933		2384
1934	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_	2385	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_
1935		2386
1936	player *player (object *op)	2387	player *player (object *op)
1937	CODE:	2388	CODE:
1938	RETVAL = op->contr;	2389	RETVAL = op->contr;
1939	OUTPUT: RETVAL	2390	OUTPUT: RETVAL
1940		2391
1941	void check_score (object *op)	2392	bool move_player (object *op, int dir)
1942		2393
1943	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)
1944	CODE:	2395	CODE:
1945	new_draw_info (flags, 0, op, txt);	2396	new_draw_info (flags, 0, op, txt);
1946		2397
1947	object *cf_player_send_inventory (object *op)
1948
1949	char *cf_player_get_ip (object *op)
1950	ALIAS: ip = 0
1951
1952	object *cf_player_get_marked_item (object *op)
1953	ALIAS: marked_item = 0
1954
1955	void cf_player_set_marked_item (object *op, object *ob)
1956
1957	partylist *cf_player_get_party (object *op)
1958	ALIAS: party = 0
1959
1960	void cf_player_set_party (object *op, partylist *party)
1961
1962	void kill_player (object *op)	2398	void kill_player (object *op)
1963		2399
		2400	void esrv_send_item (object *pl, object *item)
		2401
1964	void esrv_update_item (object *op, int what, object *item)	2402	void esrv_update_item (object *pl, int what, object *item)
1965	C_ARGS: what, op, item	2403	C_ARGS: what, pl, item
1966		2404
1967	void clear_los (object *op)	2405	void esrv_del_item (object *pl, int tag)
		2406	C_ARGS: pl->contr, tag
1968		2407
1969	int command_teleport (object *op, char *params)
1970
1971	int command_summon (object *op, char *params)	2408	int command_summon (object *op, utf8_string params)
1972		2409
1973	int command_arrest (object *op, char *params)	2410	int command_arrest (object *op, utf8_string params)
1974
1975	int command_kick (object *op, char *params)
1976
1977	int command_banish (object *op, char *params)
1978		2411
1979		2412
1980	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_	2413	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
1981		2414
1982	INCLUDE: $PERL genacc player ../include/player.h |	2415	INCLUDE: $PERL $srcdir/genacc player ../include/player.h |
1983		2416
1984	int invoke (player *pl, int event, ...)	2417	int invoke (player *pl, int event, ...)
1985	CODE:	2418	CODE:
1986	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");
1987	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	2420	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
1997	pl->ob->stats.hp = pl->ob->stats.maxhp;	2430	pl->ob->stats.hp = pl->ob->stats.maxhp;
1998	pl->ob->stats.sp = pl->ob->stats.maxsp;	2431	pl->ob->stats.sp = pl->ob->stats.maxsp;
1999	pl->ob->stats.grace = pl->ob->stats.maxgrace;	2432	pl->ob->stats.grace = pl->ob->stats.maxgrace;
2000	pl->orig_stats = pl->ob->stats;	2433	pl->orig_stats = pl->ob->stats;
2001		2434
2002	void cf_player_move (player *pl, int dir)	2435	# should only be temporary
		2436	void esrv_new_player (player *pl)
2003		2437
2004	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
2005
2006	player *first ()
2007	CODE:
2008	RETVAL = first_player;
2009	OUTPUT: RETVAL
2010
2011	bool	2439	bool
2012	cell_visible (player *pl, int dx, int dy)	2440	cell_visible (player *pl, int dx, int dy)
2013	CODE:	2441	CODE:
2014	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2	2442	RETVAL = pl->blocked_los (dx, dy) != LOS_BLOCKED;
2015	&& !pl->blocked_los [dx + pl->ns->mapx / 2][dy + pl->ns->mapy / 2];
2016	OUTPUT:	2443	OUTPUT:
2017	RETVAL	2444	RETVAL
2018		2445
2019	void	2446	void
2020	send (player *pl, SV *packet)	2447	send (player *pl, SV *packet)
2021	CODE:	2448	CODE:
2022	{	2449	{
2023	STRLEN len;	2450	STRLEN len;
2024	char *buf = SvPVbyte (packet, len);	2451	char *buf = SvPVbyte (packet, len);
2025		2452
		2453	if (len > MAXSOCKBUF)
		2454	pl->failmsg ("[packet too long for client]");
2026	if (pl->ns)	2455	else if (pl->ns)
2027	pl->ns->send_packet (buf, len);	2456	pl->ns->send_packet (buf, len);
2028	}	2457	}
2029
2030	int
2031	listening (player *pl, int new_value = -1)
2032	CODE:
2033	RETVAL = pl->listening;
2034	if (new_value >= 0)
2035	pl->listening = new_value;
2036	OUTPUT:
2037	RETVAL
2038		2458
2039	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)
2040	PROTOTYPE: $;$$$	2460	PROTOTYPE: $;$$$
2041	PPCODE:	2461	PPCODE:
2042	if (GIMME_V != G_VOID)	2462	if (GIMME_V != G_VOID)
…		…
2067	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);	2487	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);
2068	OUTPUT: RETVAL	2488	OUTPUT: RETVAL
2069		2489
2070	SV *registry (maptile *map)	2490	SV *registry (maptile *map)
2071		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
2072	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
2073		2532
2074	void	2533	void
2075	maptile::instantiate ()	2534	maptile::instantiate ()
2076		2535
2077	maptile *new ()	2536	maptile *new ()
…		…
2092	for_all_players (pl)	2551	for_all_players (pl)
2093	if (pl->ob && pl->ob->map == THIS)	2552	if (pl->ob && pl->ob->map == THIS)
2094	PUSHs (sv_2mortal (to_sv (pl->ob)));	2553	PUSHs (sv_2mortal (to_sv (pl->ob)));
2095	}	2554	}
2096		2555
2097	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	}
2098		2648
2099	int out_of_map (maptile *map, int x, int y)	2649	int out_of_map (maptile *map, int x, int y)
2100		2650
2101	void	2651	void
2102	trigger (maptile *map, long connection, bool state = true)	2652	find_link (maptile *map, shstr_tmp connection)
2103	CODE:
2104	activate_connection (map, connection, state);
2105
2106	void
2107	get_connection (maptile *map, long connection)
2108	PPCODE:	2653	PPCODE:
2109	oblinkpt *obp = get_connection_links (map, connection);	2654	if (oblinkpt *obp = map->find_link (connection))
2110	if (obp)
2111	for (objectlink *ol = obp->link; ol; ol = ol->next)	2655	for (objectlink *ol = obp->link; ol; ol = ol->next)
2112	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, (object *)ol->ob)));	2656	XPUSHs (sv_2mortal (to_sv ((object *)ol->ob)));
2113		2657
2114	object *cf_map_insert_object_there (maptile *where, object *op, object *originator, int flags)
2115
2116	object *cf_map_insert_object (maptile *where, object* op, int x, int y)
2117
2118	object* cf_map_present_arch_by_name (maptile *map, const char* str, int nx, int ny)
2119	C_ARGS: str, map, nx, ny
2120
2121	void	2658	void
2122	cf_map_normalise (maptile *map, int x, int y)	2659	get_map_flags (maptile *map, int x, int y)
2123	PPCODE:	2660	PPCODE:
2124	{	2661	{
2125	maptile *nmap = 0;	2662	maptile *nmap = 0;
2126	I16 nx = 0, ny = 0;	2663	I16 nx = 0, ny = 0;
		2664
		2665	PUTBACK;
2127	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;
2128		2668
2129	EXTEND (SP, 4);	2669	EXTEND (SP, 4);
2130	PUSHs (sv_2mortal (newSViv (flags)));	2670	PUSHs (sv_2mortal (newSViv (flags)));
2131		2671
2132	if (GIMME_V == G_ARRAY)	2672	if (GIMME_V == G_ARRAY)
2133	{	2673	{
2134	PUSHs (sv_2mortal (newSVcfapi (CFAPI_PMAP, nmap)));	2674	PUSHs (sv_2mortal (to_sv (nmap)));
2135	PUSHs (sv_2mortal (newSViv (nx)));	2675	PUSHs (sv_2mortal (newSViv (nx)));
2136	PUSHs (sv_2mortal (newSViv (ny)));	2676	PUSHs (sv_2mortal (newSViv (ny)));
2137	}	2677	}
2138	}	2678	}
2139		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
2140	void	2700	void
2141	at (maptile *map, unsigned int x, unsigned int y)	2701	at (maptile *map, unsigned int x, unsigned int y)
2142	PROTOTYPE: $$$	2702	PROTOTYPE: $$$
2143	PPCODE:	2703	PPCODE:
2144	{	2704	{
2145	object *o;
2146	maptile *nmap = 0;	2705	maptile *nmap = 0;
2147	I16 nx, ny;	2706	I16 nx, ny;
2148		2707
		2708	PUTBACK;
2149	get_map_flags (map, &nmap, x, y, &nx, &ny);	2709	get_map_flags (map, &nmap, x, y, &nx, &ny);
		2710	SPAGAIN;
2150		2711
2151	if (nmap)	2712	if (nmap)
2152	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)
2153	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));	2714	XPUSHs (sv_2mortal (to_sv (o)));
2154	}	2715	}
2155		2716
2156	SV *	2717	SV *
2157	bot_at (maptile *obj, unsigned int x, unsigned int y)	2718	bot_at (maptile *map, unsigned int x, unsigned int y)
2158	PROTOTYPE: $$$	2719	PROTOTYPE: $$$
2159	ALIAS:	2720	ALIAS:
2160	top_at = 1	2721	top_at = 1
2161	flags_at = 2	2722	flags_at = 2
2162	light_at = 3	2723	light_at = 3
2163	move_block_at = 4	2724	move_block_at = 4
2164	move_slow_at = 5	2725	move_slow_at = 5
2165	move_on_at = 6	2726	move_on_at = 6
2166	move_off_at = 7	2727	move_off_at = 7
2167	INIT:
2168	if (x >= obj->width || y >= obj->height) XSRETURN_UNDEF;
2169	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
2170	switch (ix)	2740	switch (ix)
2171	{	2741	{
2172	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;	2742	case 0: RETVAL = to_sv (ms.bot ); break;
2173	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;	2743	case 1: RETVAL = to_sv (ms.top ); break;
2174	case 2: RETVAL = newSVuv ( GET_MAP_FLAGS (obj, x, y)); break;	2744	case 2: RETVAL = newSVuv (ms.flags_ ); break;
2175	case 3: RETVAL = newSViv ( GET_MAP_LIGHT (obj, x, y)); break;	2745	case 3: RETVAL = newSViv (ms.light ); break;
2176	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;	2746	case 4: RETVAL = newSVuv (ms.move_block); break;
2177	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;	2747	case 5: RETVAL = newSVuv (ms.move_slow ); break;
2178	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;	2748	case 6: RETVAL = newSVuv (ms.move_on ); break;
2179	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;	2749	case 7: RETVAL = newSVuv (ms.move_off ); break;
2180	}	2750	}
		2751	}
2181	OUTPUT: RETVAL	2752	OUTPUT: RETVAL
2182		2753
2183	void fix_walls (maptile *map, int x, int y)
2184
2185	void fix_walls_around (maptile *map, int x, int y)
2186
2187	const char *
2188	region_name (maptile *m)
2189	CODE:
2190	RETVAL = get_name_of_region_for_map (m);
2191	OUTPUT: RETVAL
2192
2193	# worst xs function of my life	2754	# worst xs function of my life
2194	maptile *	2755	bool
2195	_create_random_map (\	2756	_create_random_map (\
2196	char *path,\	2757	maptile *self,\
2197	char *wallstyle,\	2758	utf8_string wallstyle,\
2198	char *wall_name,\	2759	utf8_string wall_name,\
2199	char *floorstyle,\	2760	utf8_string floorstyle,\
2200	char *monsterstyle,\	2761	utf8_string monsterstyle,\
2201	char *treasurestyle,\	2762	utf8_string treasurestyle,\
2202	char *layoutstyle,\	2763	utf8_string layoutstyle,\
2203	char *doorstyle,\	2764	utf8_string doorstyle,\
2204	char *decorstyle,\	2765	utf8_string decorstyle,\
2205	char *origin_map,\	2766	utf8_string miningstyle,\
2206	char *final_map,\	2767	utf8_string origin_map,\
2207	char *exitstyle,\	2768	utf8_string final_map,\
2208	char *this_map,\	2769	utf8_string exitstyle,\
2209	char *exit_on_final_map,\	2770	utf8_string this_map,\
		2771	utf8_string exit_on_final_map,\
2210	int Xsize,\	2772	int xsize,\
2211	int Ysize,\	2773	int ysize,\
2212	int expand2x,\	2774	int expand2x,\
2213	int layoutoptions1,\	2775	int layoutoptions1,\
2214	int layoutoptions2,\	2776	int layoutoptions2,\
2215	int layoutoptions3,\	2777	int layoutoptions3,\
2216	int symmetry,\	2778	int symmetry,\
…		…
2221	int dungeon_depth,\	2783	int dungeon_depth,\
2222	int decoroptions,\	2784	int decoroptions,\
2223	int orientation,\	2785	int orientation,\
2224	int origin_y,\	2786	int origin_y,\
2225	int origin_x,\	2787	int origin_x,\
2226	int random_seed,\	2788	U32 random_seed,\
2227	val64 total_map_hp,\	2789	val64 total_map_hp,\
2228	int map_layout_style,\	2790	int map_layout_style,\
2229	int treasureoptions,\	2791	int treasureoptions,\
2230	int symmetry_used,\	2792	int symmetry_used,\
2231	region *region\	2793	region *region,\
		2794	utf8_string custom\
2232	)	2795	)
2233	CODE:	2796	CODE:
2234	{	2797	{
2235	random_map_params rmp;	2798	random_map_params rmp;
2236		2799
…		…
2240	assign (rmp.monsterstyle , monsterstyle);	2803	assign (rmp.monsterstyle , monsterstyle);
2241	assign (rmp.treasurestyle , treasurestyle);	2804	assign (rmp.treasurestyle , treasurestyle);
2242	assign (rmp.layoutstyle , layoutstyle);	2805	assign (rmp.layoutstyle , layoutstyle);
2243	assign (rmp.doorstyle , doorstyle);	2806	assign (rmp.doorstyle , doorstyle);
2244	assign (rmp.decorstyle , decorstyle);	2807	assign (rmp.decorstyle , decorstyle);
		2808	assign (rmp.miningstyle , miningstyle);
2245	assign (rmp.exitstyle , exitstyle);	2809	assign (rmp.exitstyle , exitstyle);
2246	assign (rmp.exit_on_final_map, exit_on_final_map);	2810	assign (rmp.exit_on_final_map, exit_on_final_map);
2247		2811
2248	rmp.origin_map = origin_map;	2812	rmp.origin_map = origin_map;
2249	rmp.final_map = final_map;	2813	rmp.final_map = final_map;
2250	rmp.this_map = this_map;	2814	rmp.this_map = this_map;
2251	rmp.Xsize = Xsize;	2815	rmp.xsize = xsize;
2252	rmp.Ysize = Ysize;	2816	rmp.ysize = ysize;
2253	rmp.expand2x = expand2x;	2817	rmp.expand2x = expand2x;
2254	rmp.layoutoptions1 = layoutoptions1;	2818	rmp.layoutoptions1 = layoutoptions1;
2255	rmp.layoutoptions2 = layoutoptions2;	2819	rmp.layoutoptions2 = layoutoptions2;
2256	rmp.layoutoptions3 = layoutoptions3;	2820	rmp.layoutoptions3 = layoutoptions3;
2257	rmp.symmetry = symmetry;	2821	rmp.symmetry = symmetry;
…		…
2263	rmp.decoroptions = decoroptions;	2827	rmp.decoroptions = decoroptions;
2264	rmp.orientation = orientation;	2828	rmp.orientation = orientation;
2265	rmp.origin_y = origin_y;	2829	rmp.origin_y = origin_y;
2266	rmp.origin_x = origin_x;	2830	rmp.origin_x = origin_x;
2267	rmp.random_seed = random_seed;	2831	rmp.random_seed = random_seed;
2268	rmp.total_map_hp = total_map_hp;	2832	rmp.total_map_hp = (uint64_t) total_map_hp;
2269	rmp.map_layout_style = map_layout_style;	2833	rmp.map_layout_style = map_layout_style;
2270	rmp.treasureoptions = treasureoptions;	2834	rmp.treasureoptions = treasureoptions;
2271	rmp.symmetry_used = symmetry_used;	2835	rmp.symmetry_used = symmetry_used;
2272	rmp.region = region;	2836	rmp.region = region;
		2837	rmp.custom = custom;
2273		2838
2274	RETVAL = generate_random_map (path, &rmp);	2839	RETVAL = self->generate_random_map (&rmp);
2275	}	2840	}
2276	OUTPUT:	2841	OUTPUT:
2277	RETVAL	2842	RETVAL
2278		2843
		2844	MODULE = cf PACKAGE = cf::mapspace
		2845
		2846	INCLUDE: $PERL $srcdir/genacc mapspace ../include/map.h |
		2847
2279	MODULE = cf PACKAGE = cf::arch	2848	MODULE = cf PACKAGE = cf::arch
2280		2849
2281	archetype *find (const char *name)	2850	int archetypes_size ()
2282	CODE:	2851	CODE:
2283	RETVAL = archetype::find (name);	2852	RETVAL = archetypes.size ();
2284	OUTPUT:
2285	RETVAL
2286
2287	archetype *first()
2288	PROTOTYPE:
2289	CODE:
2290	RETVAL = first_archetype;
2291	OUTPUT: RETVAL	2853	OUTPUT: RETVAL
2292		2854
		2855	archetype *archetypes (U32 index)
		2856	CODE:
		2857	RETVAL = index < archetypes.size () ? archetypes [index] : 0;
		2858	OUTPUT: RETVAL
		2859
2293	INCLUDE: $PERL genacc archetype ../include/object.h |	2860	INCLUDE: $PERL $srcdir/genacc archetype ../include/object.h |
2294		2861
2295	MODULE = cf PACKAGE = cf::party	2862	MODULE = cf PACKAGE = cf::party
2296		2863
2297	partylist *first ()	2864	partylist *first ()
2298	PROTOTYPE:	2865	PROTOTYPE:
2299	CODE:	2866	CODE:
2300	RETVAL = get_firstparty ();	2867	RETVAL = get_firstparty ();
2301	OUTPUT: RETVAL	2868	OUTPUT: RETVAL
2302		2869
2303	INCLUDE: $PERL genacc partylist ../include/player.h |	2870	INCLUDE: $PERL $srcdir/genacc partylist ../include/player.h |
2304		2871
2305	MODULE = cf PACKAGE = cf::region	2872	MODULE = cf PACKAGE = cf::region
2306		2873
2307	region *first ()	2874	void
2308	PROTOTYPE:	2875	list ()
2309	CODE:	2876	PPCODE:
2310	RETVAL = first_region;	2877	for_all_regions (rgn)
2311	OUTPUT: RETVAL	2878	XPUSHs (sv_2mortal (to_sv (rgn)));
2312		2879
2313	region *find (char *name)	2880	region *find (utf8_string name)
2314	PROTOTYPE: $	2881	PROTOTYPE: $
2315	CODE:	2882	CODE:
2316	RETVAL = get_region_by_name (name);	2883	RETVAL = region::find (name);
2317	OUTPUT: RETVAL	2884	OUTPUT: RETVAL
2318		2885
		2886	int specificity (region *rgn)
		2887	CODE:
		2888	RETVAL = 0;
		2889	while (rgn = rgn->parent)
		2890	RETVAL++;
		2891	OUTPUT: RETVAL
		2892
2319	INCLUDE: $PERL genacc region ../include/map.h |	2893	INCLUDE: $PERL $srcdir/genacc region ../include/region.h |
2320		2894
2321	MODULE = cf PACKAGE = cf::living	2895	MODULE = cf PACKAGE = cf::living
2322		2896
2323	INCLUDE: $PERL genacc living ../include/living.h |	2897	INCLUDE: $PERL $srcdir/genacc living ../include/living.h |
2324		2898
2325	MODULE = cf PACKAGE = cf::settings	2899	MODULE = cf PACKAGE = cf::settings
2326		2900
2327	INCLUDE: $PERL genacc Settings ../include/global.h |	2901	INCLUDE: $PERL $srcdir/genacc Settings ../include/global.h |
2328		2902
2329	MODULE = cf PACKAGE = cf::client	2903	MODULE = cf PACKAGE = cf::client
2330		2904
2331	INCLUDE: $PERL genacc client ../include/client.h |	2905	INCLUDE: $PERL $srcdir/genacc client ../include/client.h |
2332		2906
2333	int invoke (client *ns, int event, ...)	2907	int invoke (client *ns, int event, ...)
2334	CODE:	2908	CODE:
2335	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");
2336	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	2910	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
2352	CODE:	2926	CODE:
2353	{	2927	{
2354	STRLEN len;	2928	STRLEN len;
2355	char *buf = SvPVbyte (packet, len);	2929	char *buf = SvPVbyte (packet, len);
2356		2930
		2931	if (len > MAXSOCKBUF)
		2932	{
		2933	// ugly
		2934	if (THIS->pl)
		2935	THIS->pl->failmsg ("[packet too long for client]");
		2936	}
		2937	else
2357	THIS->send_packet (buf, len);	2938	THIS->send_packet (buf, len);
2358	}	2939	}
2359		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