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

Diff Legend

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