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

Diff Legend

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