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.118 by root, Sat Dec 30 20:32:30 2006 UTC vs.
Revision 1.341 by root, Sun Nov 29 17:41:08 2009 UTC

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

Diff Legend

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