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

Diff Legend

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