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

Diff Legend

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