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

Diff Legend

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