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.181 by root, Tue Apr 3 00:21:38 2007 UTC vs.
Revision 1.289 by root, Thu May 8 20:03:50 2008 UTC

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

Diff Legend

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