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.194 by root, Mon Apr 23 18:09:57 2007 UTC vs.
Revision 1.391 by root, Sat Jul 3 01:49:18 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,2007 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	#define CEDES_PER_TICK 5	25	#if HAVE_EXECINFO_H
		26	# include <execinfo.h>
		27	#endif
30		28
31	#include <plugin_common.h>
32	#include <sounds.h>
33	#include <cstdarg>	29	#include <cstdarg>
		30	#include <typeinfo>
		31
		32	#include "global.h"
		33	#include "../random_maps/random_map.h"
		34	#include "evthread.h"
34	#include <sproto.h>	35	#include "sproto.h"
35
36	#include "loader.h"
37	#include "cfperl.h"
38	#include "shstr.h"
39		36
40	#include <unistd.h>	37	#include <unistd.h>
41	#if _POSIX_MEMLOCK	38	#if _POSIX_MEMLOCK
42	# include <sys/mman.h>	39	# include <sys/mman.h>
43	#endif	40	#endif
44		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
45	#include <EXTERN.h>	50	#include <EXTERN.h>
46	#include <perl.h>	51	#include <perl.h>
47	#include <XSUB.h>	52	#include <XSUB.h>
48		53
49	#include "CoroAPI.h"	54	#include "CoroAPI.h"
50	#include "perlxsi.c"	55	#include "perlxsi.c"
51		56
52	extern sint64 *levels; // the experience table	57	typedef object_thawer &object_thawer_ref;
53		58	typedef object_freezer &object_freezer_ref;
54	typedef object object_ornull;
55	typedef maptile maptile_ornull;
56
57	typedef char *octet_string;
58	typedef char *utf8_string;
59	typedef const char *const_octet_string;
60	typedef const char *const_utf8_string;
61		59
62	typedef std::string std__string;	60	typedef std::string std__string;
63		61
64	#if IVSIZE >= 8
65	typedef IV val64;
66	# define newSVval64 newSViv
67	# define SvVAL64 SvIV
68	#else
69	typedef double val64;
70	# define newSVval64 newSVnv
71	# define SvVAL64 SvNV
72	#endif
73
74	static f_plug_api gethook = cfapi_get_hooks;
75	static f_plug_api object_set_property = cfapi_object_set_property;
76	static f_plug_api object_insert = cfapi_object_insert;
77
78	static PerlInterpreter *perl;	62	static PerlInterpreter *perl;
79		63
80	double runtime;	64	tstamp NOW, runtime;
		65
		66	static int tick_inhibit;
		67	static int tick_pending;
81		68
82	global gbl_ev;	69	global gbl_ev;
83	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;
84	static SV *sv_runtime, *sv_next_tick;	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;
85		76
86	static HV	77	static HV
87	*stash_cf,	78	*stash_cf,
88	*stash_cf_object_wrap,	79	*stash_cf_object_wrap,
89	*stash_cf_object_player_wrap,	80	*stash_cf_object_player_wrap,
90	*stash_cf_player_wrap,	81	*stash_cf_player_wrap,
91	*stash_cf_map_wrap,	82	*stash_cf_map_wrap,
		83	*stash_cf_mapspace_wrap,
92	*stash_cf_client_wrap,	84	*stash_cf_client_wrap,
93	*stash_cf_arch_wrap,	85	*stash_cf_arch_wrap,
94	*stash_cf_party_wrap,	86	*stash_cf_party_wrap,
95	*stash_cf_region_wrap,	87	*stash_cf_region_wrap,
96	*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	}
97		143
98	// helper cast function, returns super class * or 0	144	// helper cast function, returns super class * or 0
99	template<class super>	145	template<class super>
100	static super *	146	static super *
101	is_a (attachable *at)	147	is_a (attachable *at)
…		…
111		157
112	unordered_vector<attachable *> attachable::mortals;	158	unordered_vector<attachable *> attachable::mortals;
113		159
114	attachable::~attachable ()	160	attachable::~attachable ()
115	{	161	{
116	flags |=0x3300;//D
117	assert (!self);	162	assert (!self);
118	assert (!cb);	163	assert (!cb);
119	}	164	}
120		165
121	int	166	int
…		…
135	SvREFCNT_inc (self);	180	SvREFCNT_inc (self);
136	hv_clear (self);	181	hv_clear (self);
137	sv_unmagic ((SV *)self, PERL_MAGIC_ext);	182	sv_unmagic ((SV *)self, PERL_MAGIC_ext);
138	SvREFCNT_dec (self);	183	SvREFCNT_dec (self);
139		184
140	// self *must* be null now because thats sv_unmagic's job.	185	// self *must* be null now because that's sv_unmagic's job.
141	assert (!this->self);	186	assert (!this->self);
142	flags |= 0x80; // severed //D
143	}	187	}
144	}	188	}
145		189
146	void	190	void
147	attachable::optimise ()	191	attachable::optimise ()
148	{	192	{
149	if (self	193	if (self
150	&& SvREFCNT (self) == 1	194	&& SvREFCNT (self) == 1
151	&& !HvTOTALKEYS (self))	195	&& !HvTOTALKEYS (self))
152	flags |= 0x40,//D
153	sever_self ();	196	sever_self ();
154	}	197	}
155		198
156	// check wether the object really is dead	199	// check wether the object really is dead
157	void	200	void
…		…
164	}	207	}
165		208
166	void	209	void
167	attachable::do_destroy ()	210	attachable::do_destroy ()
168	{	211	{
169	invoke (EVENT_ATTACHABLE_DESTROY, DT_END);	212	INVOKE_ATTACHABLE (DESTROY, this);
170		213
171	if (cb)	214	if (cb)
172	{	215	{
173	SvREFCNT_dec (cb);	216	SvREFCNT_dec (cb);
174	cb = 0;	217	cb = 0;
175	}	218	}
176		219
177	if (self)
178	sever_self ();
179
180	flags |= 0x20; //D
181	mortals.push_back (this);	220	mortals.push_back (this);
182	}	221	}
183		222
184	void	223	void
185	attachable::destroy ()	224	attachable::destroy ()
186	{	225	{
187	if (destroyed ())	226	if (destroyed ())
188	return;	227	return;
189		228
190	flags |= F_DESTROYED;	229	attachable_flags |= F_DESTROYED;
191	do_destroy ();	230	do_destroy ();
		231	sever_self ();
		232	}
		233
		234	void
		235	attachable::do_delete ()
		236	{
		237	delete this;
192	}	238	}
193		239
194	void	240	void
195	attachable::check_mortals ()	241	attachable::check_mortals ()
196	{	242	{
…		…
200	{	246	{
201	if (i >= mortals.size ())	247	if (i >= mortals.size ())
202	{	248	{
203	i = 0;	249	i = 0;
204		250
205	if (mortals.size () > 1000)	251	if (mortals.size () >= 512)
206	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	}
207		268
208	break;	269	break;
209	}	270	}
210		271
211	attachable *obj = mortals [i];	272	attachable *obj = mortals [i];
212		273
213	obj->refcnt_chk (); // unborrow from perl, if necessary	274	#if 0
214		275	if (obj->self)//D make this an assert later
215	//if (obj->refcnt > 0 || obj->self)
216	if (obj->refcnt || obj->self)
217	{	276	{
218	//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	{
219	++i; // further delay freeing	284	++i; // further delay freeing
220		285
221	if (!(i & 0x3ff))	286	if (!(i & 0x3ff))
222	break;	287	break;
223	}	288	}
224	else	289	else
225	{	290	{
226	mortals.erase (i);	291	mortals.erase (i);
227	delete obj;	292	obj->sever_self ();
		293	obj->do_delete ();
228	}	294	}
229	}	295	}
230	}	296	}
231		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
232	attachable &	310	attachable &
233	attachable::operator =(const attachable &src)	311	attachable::operator =(const attachable &src)
234	{	312	{
235	//if (self || cb)	313	//if (self || cb)
236	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));	314	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));
237		315
238	attach = src.attach;	316	attach = src.attach;
239	return *this;	317	return *this;
240	}	318	}
241		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
242	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	355	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
243		356
244	static SV *	357	static SV *
245	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())	358	newSVptr (void *ptr, HV *stash, HV *hv)
246	{	359	{
247	SV *sv;
248
249	if (!ptr)	360	if (!ptr)
250	return &PL_sv_undef;	361	return newSV (0);
251		362
252	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);
253	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 ());
254	}	371	}
255		372
256	static int	373	static int
257	attachable_free (pTHX_ SV *sv, MAGIC *mg)	374	attachable_free (pTHX_ SV *sv, MAGIC *mg)
258	{	375	{
…		…
270	return 0;	387	return 0;
271	}	388	}
272		389
273	MGVTBL attachable::vtbl = {0, 0, 0, 0, attachable_free};	390	MGVTBL attachable::vtbl = {0, 0, 0, 0, attachable_free};
274		391
275	static SV *	392	static SV * noinline
276	newSVattachable (attachable *obj, HV *stash)	393	newSVattachable (attachable *obj, HV *stash)
277	{	394	{
278	if (!obj)	395	if (!obj)
279	return &PL_sv_undef;	396	return newSV (0);
280		397
281	if (!obj->self)	398	if (!obj->self)
		399	obj->self = newHV ();
		400
		401	if (!SvOBJECT (obj->self))
282	{	402	{
283	obj->self = newHV ();
284	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);
285	obj->flags |= (obj->flags & 0xc0) << 8;
286	obj->flags &= ~0xc0;//D
287	obj->flags |= 0x10;//D
288		404
289	// 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
290	return sv_bless (newRV_inc ((SV *)obj->self), stash);	407	return sv_bless (newRV_inc ((SV *)obj->self), stash);
291	}	408	}
292	else	409	else
293	{	410	{
294	SV *sv = newRV_inc ((SV *)obj->self);	411	SV *sv = newRV_inc ((SV *)obj->self);
…		…
298		415
299	return sv;	416	return sv;
300	}	417	}
301	}	418	}
302		419
		420	#if 0 // unused
303	static void	421	static void
304	clearSVptr (SV *sv)	422	clearSVptr (SV *sv)
305	{	423	{
306	if (SvROK (sv))	424	if (SvROK (sv))
307	sv = SvRV (sv);	425	sv = SvRV (sv);
308		426
309	hv_clear ((HV *)sv);	427	hv_clear ((HV *)sv);
310	sv_unmagic (sv, PERL_MAGIC_ext);	428	sv_unmagic (sv, PERL_MAGIC_ext);
311	}	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	}
312		446
313	static long	447	static long
314	SvPTR (SV *sv, const char *klass)	448	SvPTR (SV *sv, const char *klass)
315	{	449	{
316	if (!sv_derived_from (sv, klass))	450	if (!sv_derived_from (sv, klass))
317	croak ("object of type %s expected", klass);	451	croak ("object of type %s expected", klass);
318		452
319	MAGIC *mg = mg_find (SvRV (sv), PERL_MAGIC_ext);	453	return SvPTR_nc (sv);
320
321	if (!mg)
322	croak ("perl code used %s object, but C object is already destroyed, caught", klass);
323
324	return (long)mg->mg_ptr;
325	}	454	}
326		455
327	static long	456	static long noinline
328	SvPTR_ornull (SV *sv, const char *klass)	457	SvPTR_ornull (SV *sv, const char *klass)
329	{	458	{
330	if (SvOK (sv))	459	if (expect_false (!SvOK (sv))) return 0;
		460
331	return SvPTR (sv, klass);	461	return SvPTR (sv, klass);
332	else
333	return 0;
334	}	462	}
335		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
336	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); }
337	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); }
338	inline SV *to_sv (bool v) { return newSViv (v); }	521	static inline SV *to_sv (bool v) { return newSViv (v); }
339	inline SV *to_sv ( signed char v) { return newSViv (v); }	522	static inline SV *to_sv ( signed char v) { return newSViv (v); }
340	inline SV *to_sv (unsigned char v) { return newSViv (v); }	523	static inline SV *to_sv (unsigned char v) { return newSViv (v); }
341	inline SV *to_sv ( signed short v) { return newSViv (v); }	524	static inline SV *to_sv ( signed short v) { return newSViv (v); }
342	inline SV *to_sv (unsigned short v) { return newSVuv (v); }	525	static inline SV *to_sv (unsigned short v) { return newSVuv (v); }
343	inline SV *to_sv ( signed int v) { return newSViv (v); }	526	static inline SV *to_sv ( signed int v) { return newSViv (v); }
344	inline SV *to_sv (unsigned int v) { return newSVuv (v); }	527	static inline SV *to_sv (unsigned int v) { return newSVuv (v); }
345	inline SV *to_sv ( signed long v) { return newSViv (v); }	528	static inline SV *to_sv ( signed long v) { return newSViv (v); }
346	inline SV *to_sv (unsigned long v) { return newSVuv (v); }	529	static inline SV *to_sv (unsigned long v) { return newSVuv (v); }
347	inline SV *to_sv ( signed long long v) { return newSVval64 (v); }	530	static inline SV *to_sv ( signed long long v) { return newSVval64 (v); }
348	inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }	531	static inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }
349	inline SV *to_sv (float v) { return newSVnv (v); }	532	static inline SV *to_sv (float v) { return newSVnv (v); }
350	inline SV *to_sv (double v) { return newSVnv (v); }	533	static inline SV *to_sv (double v) { return newSVnv (v); }
351	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); }
352	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
353	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); }
354	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); }
355	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); }
356	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); }
357	inline SV *to_sv (region * v) { return newSVptr (v, stash_cf_region_wrap); }
358	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); }
359		546
360	inline SV *to_sv (object & v) { return to_sv (&v); }	547	static inline SV *to_sv (object & v) { return to_sv (&v); }
361	inline SV *to_sv (living & v) { return to_sv (&v); }	548	static inline SV *to_sv (living & v) { return to_sv (&v); }
362		549
363	inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); }	550	static inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); }
364	inline SV *to_sv (const treasurelist *v) { return to_sv (v->name); }	551	static inline SV *to_sv (const treasurelist *v) { return to_sv (v->name); }
365		552
366	inline SV *to_sv (UUID v)	553	static inline SV *to_sv (UUID v) { return newSVpv (v.c_str (), 0); }
367	{
368	char buf[128];
369	snprintf (buf, 128, "<1.%" PRIx64 ">", v.seq);
370	return newSVpv (buf, 0);
371	}
372		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
373	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; }
374	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; }
375	inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }	578	static inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }
376	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); }
377	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); }
378	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); }
379	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); }
380	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); }
381	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); }
382	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); }
383	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); }
384	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); }
385	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); }
386	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }	589	static inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
387	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }	590	static inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }
388	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); }
389	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); }
390	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); }
391	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"); }
392	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"); }
393	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"); }
394	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"); }
395	inline void sv_to (SV *sv, region * &v) { v = (region *)SvPTR_ornull (sv, "cf::region"); }
396	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" ); }
397		604
398	//inline void sv_to (SV *sv, faceinfo * &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }	605	//static inline void sv_to (SV *sv, faceinfo * &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }
399	inline void sv_to (SV *sv, treasurelist * &v) { v = treasurelist::find (SvPV_nolen (sv)); }	606	static inline void sv_to (SV *sv, treasurelist * &v) { v = treasurelist::find (SvPV_nolen (sv)); }
400		607
401	template<class T>	608	template<class T>
402	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; }
403		610
404	template<int N>	611	template<int N>
405	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)); }
406		613
407	inline void sv_to (SV *sv, rangetype &v) { v = (rangetype) SvIV (sv); }
408	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); }
409	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); }
410	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); }
411	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); }
412		618
413	inline void sv_to (SV *sv, std::string &v)	619	static inline void sv_to (SV *sv, std::string &v)
414	{	620	{
415	STRLEN len;	621	STRLEN len;
416	char *data = SvPVbyte (sv, len);	622	char *data = SvPVbyte (sv, len);
417	v.assign (data, len);	623	v.assign (data, len);
418	}	624	}
419		625
420	inline void sv_to (SV *sv, UUID &v)	626	static inline void sv_to (SV *sv, UUID &v)
421	{	627	{
422	unsigned int version;	628	if (!v.parse (SvPV_nolen (sv)))
423
424	if (2 != sscanf (SvPV_nolen (sv), "<%d.%" SCNx64 ">", &version, &v.seq) || 1 != version)
425	croak ("unparsable uuid: %s", SvPV_nolen (sv));	629	croak ("unparsable uuid: %s", SvPV_nolen (sv));
426	}	630	}
427		631
428	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); }
429		633
430	static SV *	634	static SV *
431	newSVdt_va (va_list &ap, data_type type)	635	newSVdt_va (va_list &ap, data_type type)
432	{	636	{
433	SV *sv;	637	SV *sv;
…		…
447	break;	651	break;
448		652
449	case DT_STRING:	653	case DT_STRING:
450	{	654	{
451	char *str = (char *)va_arg (ap, const char *);	655	char *str = (char *)va_arg (ap, const char *);
452	sv = str ? newSVpv (str, 0) : &PL_sv_undef;	656	sv = str ? newSVpv (str, 0) : newSV (0);
453	}	657	}
454	break;	658	break;
455		659
456	case DT_DATA:	660	case DT_DATA:
457	{	661	{
458	char *str = (char *)va_arg (ap, const void *);	662	char *str = (char *)va_arg (ap, const void *);
459	int len = va_arg (ap, int);	663	int len = va_arg (ap, int);
460	sv = str ? newSVpv (str, len) : &PL_sv_undef;	664	sv = str ? newSVpv (str, len) : newSV (0);
461	}	665	}
462	break;	666	break;
463		667
464	case DT_OBJECT:	668	case DT_OBJECT:
465	sv = to_sv (va_arg (ap, object *));	669	sv = to_sv (va_arg (ap, object *));
…		…
507	va_end (ap);	711	va_end (ap);
508		712
509	return sv;	713	return sv;
510	}	714	}
511		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
512	static SV *	742	static SV *
513	newSVcfapi (int type, ...)
514	{
515	SV *sv;
516
517	va_list ap;
518	va_start (ap, type);
519
520	switch (type)
521	{
522	case CFAPI_INT: sv = newSViv (*va_arg (ap, int * )); break;
523	case CFAPI_LONG: sv = newSVval64 (*va_arg (ap, sint64 *)); break;
524	case CFAPI_DOUBLE: sv = newSVnv (*va_arg (ap, double *)); break;
525	case CFAPI_STRING: sv = newSVdt_va (ap, DT_STRING); break;
526	case CFAPI_POBJECT: sv = newSVdt_va (ap, DT_OBJECT); break;
527	case CFAPI_PMAP: sv = newSVdt_va (ap, DT_MAP ); break;
528	case CFAPI_PPLAYER: sv = newSVdt_va (ap, DT_PLAYER); break;
529	case CFAPI_PARCH: sv = newSVdt_va (ap, DT_ARCH ); break;
530	case CFAPI_PPARTY: sv = newSVdt_va (ap, DT_PARTY ); break;
531	case CFAPI_PREGION: sv = newSVdt_va (ap, DT_REGION); break;
532
533	default:
534	assert (("unhandled type in newSVcfapi", 0));
535	}
536
537	va_end (ap);
538
539	return sv;
540	}
541
542	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
543
544	SV *
545	registry (attachable *ext)	743	registry (attachable *ext)
546	{	744	{
547	if (!ext->cb)	745	if (!ext->cb)
548	ext->cb = newAV ();	746	ext->cb = newAV ();
549		747
550	return newRV_inc ((SV *)ext->cb);	748	return newRV_inc ((SV *)ext->cb);
551	}	749	}
552		750
553	/////////////////////////////////////////////////////////////////////////////	751	/////////////////////////////////////////////////////////////////////////////
554		752
555	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
556	{
557	return 0;
558	}
559
560	static CommArray_s rtn_cmd;
561
562	static int
563	runPluginCommand (object *obj, char *params)
564	{
565	return -1;
566	}
567
568	extern "C" void *cfperl_getPluginProperty (int *type, ...)
569	{
570	va_list args;
571	char *propname;
572	int i;
573	va_start (args, type);
574	propname = va_arg (args, char *);
575	//printf ("Property name: %s\n", propname);
576
577	if (!strcmp (propname, "command?"))
578	return NULL;
579	else if (!strcmp (propname, "Identification"))
580	{
581	va_end (args);
582	return (void *)PLUGIN_NAME;
583	}
584	else if (!strcmp (propname, "FullName"))
585	{
586	va_end (args);
587	return (void *)PLUGIN_VERSION;
588	}
589	else
590	va_end (args);
591
592	return NULL;
593	}
594
595	extern "C" int cfperl_postInitPlugin ()
596	{
597	int hooktype = 1;
598	int rtype = 0;
599
600	cf_init_plugin (gethook);
601
602	return 0;
603	}
604
605	extern "C" int cfperl_closePlugin ()
606	{
607	return 0;
608	}
609
610	void	753	void
611	cfperl_init ()	754	cfperl_init ()
612	{	755	{
		756	extern char **environ;
		757
613	PERL_SYS_INIT3 (&settings.argc, &settings.argv, 0);	758	PERL_SYS_INIT3 (&settings.argc, &settings.argv, &environ);
614	perl = perl_alloc ();	759	perl = perl_alloc ();
615	perl_construct (perl);	760	perl_construct (perl);
616		761
617	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;	762	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
618		763
619	const char *argv[] = {	764	const char *argv[] = {
620	"",	765	settings.argv [0],
621	"-e"	766	"-e0"
622	"use Event; use Coro;" // required for bootstrap
623	"cf->bootstrap;" // required for datadir :*>
624	"unshift @INC, cf::datadir ();"
625	"require cf;"
626	};	767	};
627		768
628	if (perl_parse (perl, xs_init, 2, (char **)argv, (char **)NULL)	769	if (perl_parse (perl, xs_init, 2, (char **)argv, environ)
629	|| perl_run (perl))	770	|| perl_run (perl))
630	{	771	{
631	printf ("unable to initialize perl-interpreter, aborting.\n");	772	printf ("unable to initialize perl-interpreter, aborting.\n");
632	exit (EXIT_FAILURE);	773	exit (EXIT_FAILURE);
633	}	774	}
634		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))
635	{	787	{
636	dSP;	788	printf ("unable to bootstrap perl, aborting:\n%s", SvPV_nolen (ERRSV));
637		789	exit (EXIT_FAILURE);
638	PUSHMARK (SP);
639	PUTBACK;
640	call_pv ("cf::init", G_DISCARD | G_VOID);
641	}	790	}
642	}	791	}
643		792
		793	void
644	void cfperl_main ()	794	cfperl_main ()
645	{	795	{
646	dSP;	796	dSP;
647		797
648	PUSHMARK (SP);	798	PUSHMARK (SP);
649	PUTBACK;	799	PUTBACK;
…		…
653	void	803	void
654	attachable::instantiate ()	804	attachable::instantiate ()
655	{	805	{
656	if (attach)	806	if (attach)
657	{	807	{
658	invoke (EVENT_ATTACHABLE_INSTANTIATE, ARG_STRING (attach), DT_END);	808	INVOKE_ATTACHABLE (INSTANTIATE, this, ARG_STRING (attach));
659	attach = 0;	809	attach = 0;
660	}	810	}
661	}	811	}
662		812
663	void	813	void
664	attachable::reattach ()	814	attachable::reattach ()
665	{	815	{
666	optimise ();	816	optimise ();
667	//TODO: check for _attachment's, very important for restarts	817	//TODO: check for _attachment's, very important for restarts
668	invoke (EVENT_ATTACHABLE_REATTACH, DT_END);	818	INVOKE_ATTACHABLE (REATTACH, this);
669	}	819	}
670		820
671	static event_klass klass_of[NUM_EVENT_TYPES] = {	821	static event_klass klass_of[NUM_EVENT_TYPES] = {
672	# define def(type,name) KLASS_ ## type,	822	# define def(type,name) KLASS_ ## type,
673	# include "eventinc.h"	823	# include "eventinc.h"
674	# undef def	824	# undef def
675	};	825	};
676		826
677	#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)
678		828
679	static void	829	static void noinline
680	gather_callbacks (AV *&callbacks, AV *registry, event_type event)	830	gather_callbacks (AV *&callbacks, AV *registry, event_type event)
681	{	831	{
682	// event must be in array	832	// event must be in array
683	if (event >= 0 && event <= AvFILLp (registry))	833	if (event >= 0 && event <= AvFILLp (registry))
684	{	834	{
…		…
716	}	866	}
717		867
718	void	868	void
719	global::gather_callbacks (AV *&callbacks, event_type event) const	869	global::gather_callbacks (AV *&callbacks, event_type event) const
720	{	870	{
721	::gather_callbacks (callbacks, cb_object, event);	871	::gather_callbacks (callbacks, cb_global, event);
722	}	872	}
723		873
724	void	874	void
725	object::gather_callbacks (AV *&callbacks, event_type event) const	875	object::gather_callbacks (AV *&callbacks, event_type event) const
726	{	876	{
727	if (subtype && type + subtype * NUM_SUBTYPES <= AvFILLp (cb_type))	877	if (subtype && type + subtype * NUM_TYPES <= AvFILLp (cb_type))
728	{	878	{
729	SV *registry = AvARRAY (cb_type)[type + subtype * NUM_SUBTYPES];	879	SV *registry = AvARRAY (cb_type)[type + subtype * NUM_TYPES];
730		880
731	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)	881	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
732	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);	882	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);
733	}	883	}
734		884
…		…
770	{	920	{
771	attachable::gather_callbacks (callbacks, event);	921	attachable::gather_callbacks (callbacks, event);
772	::gather_callbacks (callbacks, cb_map, event);	922	::gather_callbacks (callbacks, cb_map, event);
773	}	923	}
774		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
775	bool	975	bool
776	attachable::invoke (event_type event, ...)	976	attachable::invoke (event_type event, ...)
777	{	977	{
778	data_type dt;	978	data_type dt;
779	va_list ap;
780
781	va_start (ap, event);
782		979
783	// callback call ordering should be:	980	// callback call ordering should be:
784	// 1. per-object callback	981	// 1. per-object callback
785	// 2. per-class object	982	// 2. per-class object
786	// 3. per-type callback	983	// 3. per-type callback
…		…
790	gather_callbacks (callbacks, event);	987	gather_callbacks (callbacks, event);
791		988
792	// short-circuit processing if no callbacks found/defined	989	// short-circuit processing if no callbacks found/defined
793	if (!callbacks)	990	if (!callbacks)
794	return 0;	991	return 0;
		992
		993	va_list ap;
		994	va_start (ap, event);
795		995
796	CALL_BEGIN (3);	996	CALL_BEGIN (3);
797	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays	997	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays
798	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));	998	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));
799		999
…		…
823	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));	1023	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
824	}	1024	}
825		1025
826	va_end (ap);	1026	va_end (ap);
827		1027
828	CALL_CALL ("cf::do_invoke", G_SCALAR);	1028	CALL_CALL (cv_cf_do_invoke, G_SCALAR);
829	count = count > 0 ? POPi : 0;	1029	count = count > 0 ? POPi : 0;
830		1030
831	CALL_END;	1031	CALL_END;
832		1032
833	return count;	1033	return count;
834	}	1034	}
835		1035
836	SV *	1036	static SV *
837	cfperl_result (int idx)	1037	cfperl_result (int idx)
838	{	1038	{
839	AV *av = get_av ("cfperl::invoke_results", 0);	1039	AV *av = get_av ("cf::INVOKE_RESULTS", 0);
840	if (!av)	1040	if (!av)
841	return &PL_sv_undef;	1041	return &PL_sv_undef;
842		1042
843	SV **sv = av_fetch (av, idx, 0);	1043	SV **sv = av_fetch (av, idx, 0);
844	if (!sv)	1044	if (!sv)
…		…
858	{	1058	{
859	return SvNV (cfperl_result (idx));	1059	return SvNV (cfperl_result (idx));
860	}	1060	}
861		1061
862	/////////////////////////////////////////////////////////////////////////////	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	}
863		1083
864	void	1084	void
865	cfperl_emergency_save ()	1085	cfperl_emergency_save ()
866	{	1086	{
867	CALL_BEGIN (0);	1087	CALL_BEGIN (0);
…		…
876	CALL_ARG (make_core);	1096	CALL_ARG (make_core);
877	CALL_CALL ("cf::post_cleanup", G_VOID);	1097	CALL_CALL ("cf::post_cleanup", G_VOID);
878	CALL_END;	1098	CALL_END;
879	}	1099	}
880		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
881	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 *
882	maptile::find_sync (const char *path, maptile *origin)	1184	maptile::find_sync (const_utf8_string path, maptile *origin)
883	{	1185	{
884	CALL_BEGIN (2);	1186	CALL_BEGIN (2);
885	CALL_ARG (path);	1187	CALL_ARG (path);
886	CALL_ARG (origin);	1188	CALL_ARG (origin);
887	CALL_CALL ("cf::map::find_sync", G_SCALAR);	1189	CALL_CALL ("cf::map::find_sync", G_SCALAR);
888		1190
889	maptile *retval;	1191	maptile *retval = 0;
890
891	if (count)
892	sv_to (POPs, retval);	1192	if (count) sv_to (POPs, retval);
893	else
894	retval = 0;
895		1193
896	CALL_END;	1194	CALL_END;
897		1195
898	return retval;	1196	return retval;
899	}	1197	}
900		1198
901	maptile *	1199	maptile *
902	maptile::find_async (const char *path, maptile *origin)	1200	maptile::find_async (const_utf8_string path, maptile *origin, bool load)
903	{	1201	{
904	CALL_BEGIN (2);	1202	CALL_BEGIN (3);
905	CALL_ARG (path);	1203	CALL_ARG (path);
906	CALL_ARG (origin);	1204	CALL_ARG (origin);
		1205	CALL_ARG (load);
907	CALL_CALL ("cf::map::find_async", G_SCALAR);	1206	CALL_CALL ("cf::map::find_async", G_SCALAR);
908		1207
909	maptile *retval;	1208	maptile *retval = 0;
910
911	if (count)
912	sv_to (POPs, retval);	1209	if (count) sv_to (POPs, retval);
913	else
914	retval = 0;
915		1210
916	CALL_END;	1211	CALL_END;
917		1212
918	return retval;	1213	return retval;
919	}	1214	}
…		…
922	maptile::do_load_sync ()	1217	maptile::do_load_sync ()
923	{	1218	{
924	CALL_BEGIN (1);	1219	CALL_BEGIN (1);
925	CALL_ARG (this);	1220	CALL_ARG (this);
926	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);	1221	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);
927	CALL_END;
928	}
929
930	void
931	maptile::change_all_map_light (int change)
932	{
933	CALL_BEGIN (1);
934	CALL_ARG (change);
935	CALL_CALL ("cf::map::change_all_map_light", G_VOID);
936	CALL_END;	1222	CALL_END;
937	}	1223	}
938		1224
939	void	1225	void
940	object::enter_exit (object *exit)	1226	object::enter_exit (object *exit)
…		…
947	CALL_ARG (exit);	1233	CALL_ARG (exit);
948	CALL_CALL ("cf::object::player::enter_exit", G_VOID);	1234	CALL_CALL ("cf::object::player::enter_exit", G_VOID);
949	CALL_END;	1235	CALL_END;
950	}	1236	}
951		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
952	/////////////////////////////////////////////////////////////////////////////	1350	/////////////////////////////////////////////////////////////////////////////
953		1351
954	struct EventAPI *watcher_base::GEventAPI;	1352	struct EVAPI *evapi::GEVAPI;
955	struct CoroAPI *coroapi::GCoroAPI;	1353	struct CoroAPI *coroapi::GCoroAPI;
956		1354
957	int coroapi::cede_counter;	1355	void
958	double (*coroapi::time)();
959	double coroapi::next_cede;
960
961	void coroapi::do_cede_to_tick ()	1356	coroapi::do_cede_to_tick ()
962	{	1357	{
963	cede_counter = 0;	1358	cede_pending = 0;
964
965	cede ();	1359	cede ();
966
967	next_cede += (TICK / CEDES_PER_TICK) * 0.99;
968	if (next_cede > SvNV (sv_next_tick) - 0.02)
969	next_cede = SvNV (sv_next_tick);
970	}
971
972	void coroapi::do_cede_every ()
973	{
974	cede_counter = 0;
975
976	if (coroapi::nready ())
977	coroapi::cede ();
978	}
979
980	void coroapi::do_cede_to_tick_every ()
981	{
982	cede_counter = 0;
983
984	cede_to_tick ();
985	}	1360	}
986		1361
987	void	1362	void
988	coroapi::wait_for_tick ()	1363	coroapi::wait_for_tick ()
989	{	1364	{
…		…
998	CALL_BEGIN (0);	1373	CALL_BEGIN (0);
999	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);	1374	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);
1000	CALL_END;	1375	CALL_END;
1001	}	1376	}
1002		1377
		1378	void
		1379	iow::poll (int events)
		1380	{
		1381	if (events != this->events)
		1382	{
		1383	int active = ev_is_active ((ev_io *)this);
		1384	if (active) stop ();
		1385	ev_io_set ((ev_io *)this, fd, events);
		1386	if (active) start ();
		1387	}
		1388	}
		1389
1003	static void	1390	static void
1004	iw_dispatch (pe_event *ev)
1005	{
1006	iw *w = (iw *)ev->ext_data;
1007	w->call (*w);
1008	}
1009
1010	void
1011	iw::alloc ()
1012	{
1013	pe = GEventAPI->new_idle (0, 0);
1014
1015	WaREENTRANT_off (pe);
1016	pe->base.callback = (void *)iw_dispatch;
1017	pe->base.ext_data = (void *)this;
1018	}
1019
1020	static void iow_dispatch (pe_event *ev)
1021	{
1022	iow *w = (iow *)ev->ext_data;
1023	w->call (*w, ((pe_ioevent *)ev)->got);
1024	}
1025
1026	void
1027	iow::alloc ()
1028	{
1029	pe = GEventAPI->new_io (0, 0);
1030
1031	WaREENTRANT_off (pe);
1032	pe->base.callback = (void *)iow_dispatch;
1033	pe->base.ext_data = (void *)this;
1034
1035	pe->fd = -1;
1036	pe->poll = 0;
1037	}
1038
1039	void
1040	iow::fd (int fd)
1041	{
1042	pe->fd = fd;
1043	}
1044
1045	int
1046	iow::poll ()
1047	{
1048	return pe->poll;
1049	}
1050
1051	void
1052	iow::poll (int events)
1053	{
1054	if (pe->poll != events)
1055	{
1056	if (pe->poll) stop ();
1057	pe->poll = events;
1058	if (pe->poll) start ();
1059	}
1060	}
1061
1062	void
1063	_connect_to_perl ()	1391	_connect_to_perl_1 ()
1064	{	1392	{
1065	stash_cf = gv_stashpv ("cf" , 1);	1393	stash_cf = gv_stashpv ("cf", 1);
1066		1394
1067	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);	1395	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);
1068	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);
1069	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);	1397	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);
1070	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);
1071	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);	1400	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);
1072	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);	1401	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
1073	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);	1402	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
1074	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);	1403	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
1075	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);
1076		1407
		1408	sv_now = get_sv ("cf::NOW" , 1); SvUPGRADE (sv_now , SVt_NV);
1077	sv_runtime = get_sv ("cf::RUNTIME" , 1); 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);
1078	sv_next_tick = get_sv ("cf::NEXT_TICK", 1); sv_upgrade (sv_next_tick, SVt_NV);	1411	sv_next_tick = get_sv ("cf::NEXT_TICK" , 1); SvUPGRADE (sv_next_tick , SVt_NV);
1079		1412
1080	cb_global = get_av ("cf::CB_GLOBAL", 1);	1413	cb_global = get_av ("cf::CB_GLOBAL", 1);
1081	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);	1414	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
1082	cb_object = get_av ("cf::CB_OBJECT", 1);	1415	cb_object = get_av ("cf::CB_OBJECT", 1);
1083	cb_player = get_av ("cf::CB_PLAYER", 1);	1416	cb_player = get_av ("cf::CB_PLAYER", 1);
1084	cb_client = get_av ("cf::CB_CLIENT", 1);	1417	cb_client = get_av ("cf::CB_CLIENT", 1);
1085	cb_type = get_av ("cf::CB_TYPE" , 1);	1418	cb_type = get_av ("cf::CB_TYPE" , 1);
1086	cb_map = get_av ("cf::CB_MAP" , 1);	1419	cb_map = get_av ("cf::CB_MAP" , 1);
1087	}	1420	}
1088		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
1089	MODULE = cf PACKAGE = cf PREFIX = cf_	1432	MODULE = cf PACKAGE = cf PREFIX = cf_
1090		1433
1091	BOOT:	1434	BOOT:
1092	{	1435	{
1093	I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;	1436	I_EV_API (PACKAGE); evapi::GEVAPI = GEVAPI;
1094	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;	1437	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
1095		1438
1096	_connect_to_perl ();	1439	_connect_to_perl_1 ();
1097		1440
1098	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));	1441	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
1099		1442
1100	{	1443	//{
1101	require_pv ("Time::HiRes");	1444	// require_pv ("Time::HiRes");
1102		1445	//
1103	SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);	1446	// SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
1104	if (!svp) croak ("Time::HiRes is required");	1447	// if (!svp) croak ("Time::HiRes is required");
1105	if (!SvIOK(*svp)) croak ("Time::NVtime isn’t a function pointer");	1448	// if (!SvIOK(*svp)) croak ("Time::NVtime isn’t a function pointer");
1106	coroapi::time = INT2PTR (double(*)(), SvIV(*svp));	1449	// coroapi::time = INT2PTR (double(*)(), SvIV(*svp));
1107	}	1450	//}
1108		1451
1109	static const struct {	1452	static const struct {
1110	const char *name;	1453	const char *name;
1111	IV iv;	1454	IV iv;
1112	} *civ, const_iv[] = {	1455	} *civ, const_iv[] = {
1113	# define const_iv(name) { # name, (IV)name },	1456	# define const_iv(name) { # name, (IV)name },
1114	const_iv (llevError) const_iv (llevInfo) const_iv (llevDebug) const_iv (llevMonster)	1457	# include "const_iv.h"
		1458	# define def(uc, lc, name, plus, change) const_iv (AT_ ## uc) const_iv (ATNR_ ## uc)
		1459	# include "attackinc.h"
		1460	# undef def
		1461	# define def(uc, flags) const_iv (SK_ ## uc)
		1462	# include "skillinc.h"
		1463	# undef def
1115		1464
1116	const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)	1465	const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)
1117		1466
1118	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)	1467	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)
1119		1468
1120	const_iv (MAX_TIME)	1469	const_iv (MAX_TIME)
1121		1470	const_iv (MAXSOCKBUF)
1122	const_iv (PLAYER) const_iv (TRANSPORT) const_iv (ROD) const_iv (TREASURE)
1123	const_iv (POTION) const_iv (FOOD) const_iv (POISON) const_iv (BOOK)
1124	const_iv (CLOCK) const_iv (ARROW) const_iv (BOW) const_iv (WEAPON)
1125	const_iv (ARMOUR) const_iv (PEDESTAL) const_iv (ALTAR) const_iv (LOCKED_DOOR)
1126	const_iv (SPECIAL_KEY) const_iv (MAP) const_iv (DOOR) const_iv (KEY)
1127	const_iv (TIMED_GATE) const_iv (TRIGGER) const_iv (GRIMREAPER) const_iv (MAGIC_EAR)
1128	const_iv (TRIGGER_BUTTON) const_iv (TRIGGER_ALTAR) const_iv (TRIGGER_PEDESTAL) const_iv (SHIELD)
1129	const_iv (HELMET) const_iv (HORN) const_iv (MONEY) const_iv (CLASS)
1130	const_iv (GRAVESTONE) const_iv (AMULET) const_iv (PLAYERMOVER) const_iv (TELEPORTER)
1131	const_iv (CREATOR) const_iv (SKILL) const_iv (EARTHWALL) const_iv (GOLEM)
1132	const_iv (THROWN_OBJ) const_iv (BLINDNESS) const_iv (GOD) const_iv (DETECTOR)
1133	const_iv (TRIGGER_MARKER) const_iv (DEAD_OBJECT) const_iv (DRINK) const_iv (MARKER)
1134	const_iv (HOLY_ALTAR) const_iv (PLAYER_CHANGER) const_iv (BATTLEGROUND) const_iv (PEACEMAKER)
1135	const_iv (GEM) const_iv (FIREWALL) const_iv (ANVIL) const_iv (CHECK_INV)
1136	const_iv (MOOD_FLOOR) const_iv (EXIT) const_iv (ENCOUNTER) const_iv (SHOP_FLOOR)
1137	const_iv (SHOP_MAT) const_iv (RING) const_iv (FLOOR) const_iv (FLESH)
1138	const_iv (INORGANIC) const_iv (SKILL_TOOL) const_iv (LIGHTER) const_iv (BUILDABLE_WALL)
1139	const_iv (MISC_OBJECT) const_iv (LAMP) const_iv (DUPLICATOR) const_iv (SPELLBOOK)
1140	const_iv (CLOAK) const_iv (SPINNER) const_iv (GATE) const_iv (BUTTON)
1141	const_iv (CF_HANDLE) const_iv (HOLE) const_iv (TRAPDOOR) const_iv (SIGN)
1142	const_iv (BOOTS) const_iv (GLOVES) const_iv (SPELL) const_iv (SPELL_EFFECT)
1143	const_iv (CONVERTER) const_iv (BRACERS) const_iv (POISONING) const_iv (SAVEBED)
1144	const_iv (WAND) const_iv (SCROLL) const_iv (DIRECTOR) const_iv (GIRDLE)
1145	const_iv (FORCE) const_iv (POTION_EFFECT) const_iv (EVENT_CONNECTOR) const_iv (CLOSE_CON)
1146	const_iv (CONTAINER) const_iv (ARMOUR_IMPROVER) const_iv (WEAPON_IMPROVER) const_iv (SKILLSCROLL)
1147	const_iv (DEEP_SWAMP) const_iv (IDENTIFY_ALTAR) const_iv (MENU) const_iv (RUNE)
1148	const_iv (TRAP) const_iv (POWER_CRYSTAL) const_iv (CORPSE) const_iv (DISEASE)
1149	const_iv (SYMPTOM) const_iv (BUILDER) const_iv (MATERIAL) const_iv (ITEM_TRANSFORMER)
1150
1151	const_iv (NUM_SUBTYPES)
1152
1153	const_iv (ST_BD_BUILD) const_iv (ST_BD_REMOVE)
1154	const_iv (ST_MAT_FLOOR) const_iv (ST_MAT_WALL) const_iv (ST_MAT_ITEM)
1155
1156	const_iv (AT_PHYSICAL) const_iv (AT_MAGIC) const_iv (AT_FIRE) const_iv (AT_ELECTRICITY)
1157	const_iv (AT_COLD) const_iv (AT_CONFUSION) const_iv (AT_ACID) const_iv (AT_DRAIN)
1158	const_iv (AT_WEAPONMAGIC) const_iv (AT_GHOSTHIT) const_iv (AT_POISON) const_iv (AT_SLOW)
1159	const_iv (AT_PARALYZE) const_iv (AT_TURN_UNDEAD) const_iv (AT_FEAR) const_iv (AT_CANCELLATION)
1160	const_iv (AT_DEPLETE) const_iv (AT_DEATH) const_iv (AT_CHAOS) const_iv (AT_COUNTERSPELL)
1161	const_iv (AT_GODPOWER) const_iv (AT_HOLYWORD) const_iv (AT_BLIND) const_iv (AT_INTERNAL)
1162	const_iv (AT_LIFE_STEALING) const_iv (AT_DISEASE)
1163
1164	const_iv (WEAP_HIT) const_iv (WEAP_SLASH) const_iv (WEAP_PIERCE) const_iv (WEAP_CLEAVE)
1165	const_iv (WEAP_SLICE) const_iv (WEAP_STAB) const_iv (WEAP_WHIP) const_iv (WEAP_CRUSH)
1166	const_iv (WEAP_BLUD)
1167
1168	const_iv (FLAG_ALIVE) const_iv (FLAG_WIZ) const_iv (FLAG_REMOVED) const_iv (FLAG_FREED)
1169	const_iv (FLAG_WAS_WIZ) const_iv (FLAG_APPLIED) const_iv (FLAG_UNPAID) const_iv (FLAG_USE_SHIELD)
1170	const_iv (FLAG_NO_PICK) const_iv (FLAG_ANIMATE) const_iv (FLAG_MONSTER) const_iv (FLAG_FRIENDLY)
1171	const_iv (FLAG_GENERATOR) const_iv (FLAG_IS_THROWN) const_iv (FLAG_AUTO_APPLY) const_iv (FLAG_PLAYER_SOLD)
1172	const_iv (FLAG_SEE_INVISIBLE) const_iv (FLAG_CAN_ROLL) const_iv (FLAG_OVERLAY_FLOOR) const_iv (FLAG_IS_TURNABLE)
1173	const_iv (FLAG_IS_USED_UP) const_iv (FLAG_IDENTIFIED) const_iv (FLAG_REFLECTING) const_iv (FLAG_CHANGING)
1174	const_iv (FLAG_SPLITTING) const_iv (FLAG_HITBACK) const_iv (FLAG_STARTEQUIP) const_iv (FLAG_BLOCKSVIEW)
1175	const_iv (FLAG_UNDEAD) const_iv (FLAG_SCARED) const_iv (FLAG_UNAGGRESSIVE) const_iv (FLAG_REFL_MISSILE)
1176	const_iv (FLAG_REFL_SPELL) const_iv (FLAG_NO_MAGIC) const_iv (FLAG_NO_FIX_PLAYER) const_iv (FLAG_IS_LIGHTABLE)
1177	const_iv (FLAG_TEAR_DOWN) const_iv (FLAG_RUN_AWAY) const_iv (FLAG_PICK_UP) const_iv (FLAG_UNIQUE)
1178	const_iv (FLAG_NO_DROP) const_iv (FLAG_WIZCAST) const_iv (FLAG_CAST_SPELL) const_iv (FLAG_USE_SCROLL)
1179	const_iv (FLAG_USE_RANGE) const_iv (FLAG_USE_BOW) const_iv (FLAG_USE_ARMOUR) const_iv (FLAG_USE_WEAPON)
1180	const_iv (FLAG_USE_RING) const_iv (FLAG_READY_RANGE) const_iv (FLAG_READY_BOW) const_iv (FLAG_XRAYS)
1181	const_iv (FLAG_NO_APPLY) const_iv (FLAG_IS_FLOOR) const_iv (FLAG_LIFESAVE) const_iv (FLAG_NO_STRENGTH)
1182	const_iv (FLAG_SLEEP) const_iv (FLAG_STAND_STILL) const_iv (FLAG_RANDOM_MOVE) const_iv (FLAG_ONLY_ATTACK)
1183	const_iv (FLAG_CONFUSED) const_iv (FLAG_STEALTH) const_iv (FLAG_WIZPASS) const_iv (FLAG_IS_LINKED)
1184	const_iv (FLAG_CURSED) const_iv (FLAG_DAMNED) const_iv (FLAG_SEE_ANYWHERE) const_iv (FLAG_KNOWN_MAGICAL)
1185	const_iv (FLAG_KNOWN_CURSED) const_iv (FLAG_CAN_USE_SKILL) const_iv (FLAG_BEEN_APPLIED) const_iv (FLAG_READY_SCROLL)
1186	const_iv (FLAG_USE_ROD) const_iv (FLAG_USE_HORN) const_iv (FLAG_MAKE_INVIS) const_iv (FLAG_INV_LOCKED)
1187	const_iv (FLAG_IS_WOODED) const_iv (FLAG_IS_HILLY) const_iv (FLAG_READY_SKILL) const_iv (FLAG_READY_WEAPON)
1188	const_iv (FLAG_NO_SKILL_IDENT) const_iv (FLAG_BLIND) const_iv (FLAG_SEE_IN_DARK) const_iv (FLAG_IS_CAULDRON)
1189	const_iv (FLAG_NO_STEAL) const_iv (FLAG_ONE_HIT) const_iv (FLAG_CLIENT_SENT) const_iv (FLAG_BERSERK)
1190	const_iv (FLAG_NEUTRAL) const_iv (FLAG_NO_ATTACK) const_iv (FLAG_NO_DAMAGE) const_iv (FLAG_OBJ_ORIGINAL)
1191	const_iv (FLAG_OBJ_SAVE_ON_OVL) const_iv (FLAG_ACTIVATE_ON_PUSH) const_iv (FLAG_ACTIVATE_ON_RELEASE) const_iv (FLAG_IS_WATER)
1192	const_iv (FLAG_CONTENT_ON_GEN) const_iv (FLAG_IS_A_TEMPLATE) const_iv (FLAG_IS_BUILDABLE)
1193	const_iv (FLAG_DESTROY_ON_DEATH) const_iv (FLAG_NO_MAP_SAVE)
1194
1195	const_iv (NDI_BLACK) const_iv (NDI_WHITE) const_iv (NDI_NAVY) const_iv (NDI_RED)
1196	const_iv (NDI_ORANGE) const_iv (NDI_BLUE) const_iv (NDI_DK_ORANGE) const_iv (NDI_GREEN)
1197	const_iv (NDI_LT_GREEN) const_iv (NDI_GREY) const_iv (NDI_BROWN) const_iv (NDI_GOLD)
1198	const_iv (NDI_TAN) const_iv (NDI_MAX_COLOR) const_iv (NDI_COLOR_MASK) const_iv (NDI_UNIQUE)
1199	const_iv (NDI_ALL)
1200		1471
1201	const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE)	1472	const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE)
1202	const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF)	1473	const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF)
1203		1474
1204	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_DAMAGE)	1475	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_LEVEL)
1205		1476
1206	const_iv (F_APPLIED) const_iv (F_LOCATION) const_iv (F_UNPAID) const_iv (F_MAGIC)	1477	const_iv (F_APPLIED) const_iv (F_LOCATION) const_iv (F_UNPAID) const_iv (F_MAGIC)
1207	const_iv (F_CURSED) const_iv (F_DAMNED) const_iv (F_OPEN) const_iv (F_NOPICK)	1478	const_iv (F_CURSED) const_iv (F_DAMNED) const_iv (F_OPEN) const_iv (F_NOPICK)
1208	const_iv (F_LOCKED)	1479	const_iv (F_LOCKED)
1209		1480
1210	const_iv (F_BUY) const_iv (F_SHOP) const_iv (F_SELL)
1211
1212	const_iv (P_BLOCKSVIEW) const_iv (P_PLAYER) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE)	1481	const_iv (P_BLOCKSVIEW) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE)
1213	const_iv (P_NO_CLERIC) const_iv (P_OUT_OF_MAP) const_iv (P_NEW_MAP) const_iv (P_UPTODATE)	1482	const_iv (P_NO_CLERIC) const_iv (P_OUT_OF_MAP) const_iv (P_NEW_MAP) const_iv (P_UPTODATE)
1214		1483
1215	const_iv (UP_OBJ_INSERT) const_iv (UP_OBJ_REMOVE) const_iv (UP_OBJ_CHANGE) const_iv (UP_OBJ_FACE)
1216
1217	const_iv (INS_NO_MERGE) const_iv (INS_ABOVE_FLOOR_ONLY) const_iv (INS_NO_WALK_ON)
1218	const_iv (INS_ON_TOP) const_iv (INS_BELOW_ORIGINATOR) const_iv (INS_MAP_LOAD)
1219
1220	const_iv (WILL_APPLY_HANDLE) const_iv (WILL_APPLY_TREASURE) const_iv (WILL_APPLY_EARTHWALL)
1221	const_iv (WILL_APPLY_DOOR) const_iv (WILL_APPLY_FOOD)
1222
1223	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)	1484	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)
1224
1225	const_iv (M_PAPER) const_iv (M_IRON) const_iv (M_GLASS) const_iv (M_LEATHER)
1226	const_iv (M_WOOD) const_iv (M_ORGANIC) const_iv (M_STONE) const_iv (M_CLOTH)
1227	const_iv (M_ADAMANT) const_iv (M_LIQUID) const_iv (M_SOFT_METAL) const_iv (M_BONE)
1228	const_iv (M_ICE) const_iv (M_SPECIAL)
1229		1485
1230	const_iv (SK_EXP_ADD_SKILL) const_iv (SK_EXP_TOTAL) const_iv (SK_EXP_NONE)	1486	const_iv (SK_EXP_ADD_SKILL) const_iv (SK_EXP_TOTAL) const_iv (SK_EXP_NONE)
1231	const_iv (SK_SUBTRACT_SKILL_EXP) const_iv (SK_EXP_SKILL_ONLY)	1487	const_iv (SK_SUBTRACT_SKILL_EXP) const_iv (SK_EXP_SKILL_ONLY)
1232		1488
1233	const_iv (SK_LOCKPICKING) const_iv (SK_HIDING) const_iv (SK_SMITHERY) const_iv (SK_BOWYER)
1234	const_iv (SK_JEWELER) const_iv (SK_ALCHEMY) const_iv (SK_STEALING) const_iv (SK_LITERACY)
1235	const_iv (SK_BARGAINING) const_iv (SK_JUMPING) const_iv (SK_DET_MAGIC) const_iv (SK_ORATORY)
1236	const_iv (SK_SINGING) const_iv (SK_DET_CURSE) const_iv (SK_FIND_TRAPS) const_iv (SK_MEDITATION)
1237	const_iv (SK_PUNCHING) const_iv (SK_FLAME_TOUCH) const_iv (SK_KARATE) const_iv (SK_CLIMBING)
1238	const_iv (SK_WOODSMAN) const_iv (SK_INSCRIPTION) const_iv (SK_ONE_HANDED_WEAPON) const_iv (SK_MISSILE_WEAPON)
1239	const_iv (SK_THROWING) const_iv (SK_USE_MAGIC_ITEM) const_iv (SK_DISARM_TRAPS) const_iv (SK_SET_TRAP)
1240	const_iv (SK_THAUMATURGY) const_iv (SK_PRAYING) const_iv (SK_CLAWING) const_iv (SK_LEVITATION)
1241	const_iv (SK_SUMMONING) const_iv (SK_PYROMANCY) const_iv (SK_EVOCATION) const_iv (SK_SORCERY)
1242	const_iv (SK_TWO_HANDED_WEAPON) const_iv (SK_SPARK_TOUCH) const_iv (SK_SHIVER) const_iv (SK_ACID_SPLASH)
1243	const_iv (SK_POISON_NAIL)
1244
1245	const_iv (SOUND_NEW_PLAYER) const_iv (SOUND_FIRE_ARROW) const_iv (SOUND_LEARN_SPELL) const_iv (SOUND_FUMBLE_SPELL)
1246	const_iv (SOUND_WAND_POOF) const_iv (SOUND_OPEN_DOOR) const_iv (SOUND_PUSH_PLAYER) const_iv (SOUND_PLAYER_HITS1)
1247	const_iv (SOUND_PLAYER_HITS2) const_iv (SOUND_PLAYER_HITS3) const_iv (SOUND_PLAYER_HITS4) const_iv (SOUND_PLAYER_IS_HIT1)
1248	const_iv (SOUND_PLAYER_IS_HIT2) const_iv (SOUND_PLAYER_IS_HIT3) const_iv (SOUND_PLAYER_KILLS) const_iv (SOUND_PET_IS_KILLED)
1249	const_iv (SOUND_PLAYER_DIES) const_iv (SOUND_OB_EVAPORATE) const_iv (SOUND_OB_EXPLODE) const_iv (SOUND_CLOCK)
1250	const_iv (SOUND_TURN_HANDLE) const_iv (SOUND_FALL_HOLE) const_iv (SOUND_DRINK_POISON) const_iv (SOUND_CAST_SPELL_0)
1251
1252	const_iv (PREFER_LOW) const_iv (PREFER_HIGH)
1253
1254	const_iv (ATNR_PHYSICAL) const_iv (ATNR_MAGIC) const_iv (ATNR_FIRE) const_iv (ATNR_ELECTRICITY)
1255	const_iv (ATNR_COLD) const_iv (ATNR_CONFUSION) const_iv (ATNR_ACID) const_iv (ATNR_DRAIN)
1256	const_iv (ATNR_WEAPONMAGIC) const_iv (ATNR_GHOSTHIT) const_iv (ATNR_POISON) const_iv (ATNR_SLOW)
1257	const_iv (ATNR_PARALYZE) const_iv (ATNR_TURN_UNDEAD) const_iv (ATNR_FEAR) const_iv (ATNR_CANCELLATION)
1258	const_iv (ATNR_DEPLETE) const_iv (ATNR_DEATH) const_iv (ATNR_CHAOS) const_iv (ATNR_COUNTERSPELL)
1259	const_iv (ATNR_GODPOWER) const_iv (ATNR_HOLYWORD) const_iv (ATNR_BLIND) const_iv (ATNR_INTERNAL)
1260	const_iv (ATNR_LIFE_STEALING) const_iv (ATNR_DISEASE)
1261
1262	const_iv (MAP_IN_MEMORY) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)	1489	const_iv (MAP_ACTIVE) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)
		1490	const_iv (MAP_INACTIVE)
1263		1491
1264	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)	1492	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)
1265	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)	1493	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)
1266		1494
1267	const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)	1495	const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)
1268		1496
1269	const_iv (ST_DEAD) const_iv (ST_SETUP) const_iv (ST_PLAYING) const_iv (ST_CUSTOM)
1270
1271	const_iv (ST_CHANGE_CLASS)
1272
1273	const_iv (IO_HEADER) const_iv (IO_OBJECTS) const_iv (IO_UNIQUES)	1497	const_iv (IO_HEADER) const_iv (IO_OBJECTS) const_iv (IO_UNIQUES)
1274
1275	// random map generator
1276	const_iv (LAYOUT_NONE) const_iv (LAYOUT_ONION) const_iv (LAYOUT_MAZE) const_iv (LAYOUT_SPIRAL)
1277	const_iv (LAYOUT_ROGUELIKE) const_iv (LAYOUT_SNAKE) const_iv (LAYOUT_SQUARE_SPIRAL)
1278
1279	const_iv (RMOPT_RANDOM) const_iv (RMOPT_CENTERED) const_iv (RMOPT_LINEAR)
1280	const_iv (RMOPT_BOTTOM_C) const_iv (RMOPT_BOTTOM_R) const_iv (RMOPT_IRR_SPACE)
1281	const_iv (RMOPT_WALL_OFF) const_iv (RMOPT_WALLS_ONLY) const_iv (RMOPT_NO_DOORS)
1282
1283	const_iv (SYMMETRY_RANDOM) const_iv (SYMMETRY_NONE) const_iv (SYMMETRY_X)
1284	const_iv (SYMMETRY_Y) const_iv (SYMMETRY_XY)
1285	};	1498	};
1286		1499
1287	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; )
1288	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));	1501	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1289		1502
1290	static const struct {	1503	static const struct {
1291	const char *name;	1504	const char *name;
1292	int skip;	1505	int skip;
…		…
1298	# undef def	1511	# undef def
1299	};	1512	};
1300		1513
1301	AV *av = get_av ("cf::EVENT", 1);	1514	AV *av = get_av ("cf::EVENT", 1);
1302		1515
1303	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; )
1304	{	1517	{
1305	AV *event = newAV ();	1518	AV *event = newAV ();
1306	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));	1519	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));
1307	av_push (event, newSViv (eiv->klass));	1520	av_push (event, newSViv (eiv->klass));
1308	av_store (av, eiv->iv, newRV_noinc ((SV *)event));	1521	av_store (av, eiv->iv, newRV_noinc ((SV *)event));
1309	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));	1522	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));
1310	}	1523	}
1311	}
1312		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
1313	void _connect_to_perl ()	1543	void _connect_to_perl_1 ()
1314		1544
		1545	void _connect_to_perl_2 ()
		1546
		1547	void _recalc_want ()
		1548
		1549	# not used by default anymore
1315	void _global_reattach ()	1550	void _global_reattach ()
1316	CODE:	1551	CODE:
1317	{	1552	{
1318	// reattach to all attachable objects in the game.	1553	// reattach to all attachable objects in the game.
1319	for_all_clients (ns)	1554	for_all_clients (ns)
1320	ns->reattach ();	1555	ns->reattach ();
1321		1556
1322	for_all_objects (op)	1557	for_all_objects (op)
1323	op->reattach ();	1558	op->reattach ();
1324	}	1559	}
1325
1326	void _post_tick ()
1327	CODE:
1328	coroapi::next_cede = SvNV (sv_next_tick) - TICK * (1. - 1. / CEDES_PER_TICK);
1329		1560
1330	# support function for map-world.ext	1561	# support function for map-world.ext
1331	void _quantise (SV *data_sv, SV *plt_sv)	1562	void _quantise (SV *data_sv, SV *plt_sv)
1332	CODE:	1563	CODE:
1333	{	1564	{
…		…
1367	}	1598	}
1368		1599
1369	SvCUR_set (data_sv, dst - SvPVX (data_sv));	1600	SvCUR_set (data_sv, dst - SvPVX (data_sv));
1370	}	1601	}
1371		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
1372	NV floor (NV x)	1676	NV floor (NV x)
1373		1677
1374	NV ceil (NV x)	1678	NV ceil (NV x)
1375		1679
1376	NV rndm (...)	1680	NV rndm (...)
		1681	ALIAS:
		1682	rmg_rndm = 1
1377	CODE:	1683	CODE:
		1684	{
		1685	rand_gen &gen = ix ? rmg_rndm : rndm;
1378	switch (items)	1686	switch (items)
1379	{	1687	{
1380	case 0: RETVAL = rndm (); break;	1688	case 0: RETVAL = gen (); break;
1381	case 1: RETVAL = rndm (SvUV (ST (0))); break;	1689	case 1: RETVAL = gen (SvUV (ST (0))); break;
1382	case 2: RETVAL = rndm (SvIV (ST (0)), SvIV (ST (1))); break;	1690	case 2: RETVAL = gen (SvIV (ST (0)), SvIV (ST (1))); break;
1383	default: croak ("cf::rndm requires none, one or two parameters."); break;	1691	default: croak ("cf::rndm requires zero, one or two parameters."); break;
1384	}	1692	}
		1693	}
1385	OUTPUT:	1694	OUTPUT:
1386	RETVAL	1695	RETVAL
1387		1696
1388	void server_tick ()	1697	NV clamp (NV value, NV min_value, NV max_value)
1389	CODE:	1698	CODE:
1390	runtime = SvNVx (sv_runtime);	1699	RETVAL = clamp (value, min_value, max_value);
1391	server_tick ();	1700	OUTPUT:
		1701	RETVAL
1392		1702
1393	void	1703	NV lerp (NV value, NV min_in, NV max_in, NV min_out, NV max_out)
		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
1394	LOG (int level, utf8_string msg)	1723	void LOG (int flags, utf8_string msg)
1395	PROTOTYPE: $$	1724	PROTOTYPE: $$
1396	C_ARGS: (LogLevel)level, "%s", msg	1725	C_ARGS: flags, "%s", msg
1397		1726
1398	octet_string path_combine (octet_string base, octet_string path)	1727	octet_string path_combine (octet_string base, octet_string path)
1399	PROTOTYPE: $$	1728	PROTOTYPE: $$
1400		1729
1401	octet_string path_combine_and_normalize (octet_string base, octet_string path)	1730	octet_string path_combine_and_normalize (octet_string base, octet_string path)
1402	PROTOTYPE: $$	1731	PROTOTYPE: $$
1403
1404	const_octet_string
1405	get_maps_directory (octet_string path)
1406	PROTOTYPE: $
1407	ALIAS: maps_directory = 0
1408	CODE:
1409	RETVAL = create_pathname (path);
1410	OUTPUT: RETVAL
1411		1732
1412	void	1733	void
1413	sub_generation_inc ()	1734	sub_generation_inc ()
1414	CODE:	1735	CODE:
1415	PL_sub_generation++;	1736	PL_sub_generation++;
…		…
1438	}	1759	}
1439	OUTPUT: RETVAL	1760	OUTPUT: RETVAL
1440		1761
1441	void abort ()	1762	void abort ()
1442		1763
		1764	void reset_signals ()
		1765
1443	void fork_abort (octet_string cause = "cf::fork_abort")	1766	void fork_abort (const_octet_string cause = "cf::fork_abort")
1444		1767
1445	void cleanup (octet_string cause, bool make_core = false)	1768	void cleanup (const_octet_string cause, bool make_core = false)
1446		1769
1447	void emergency_save ()	1770	void emergency_save ()
1448		1771
1449	void _exit (int status = EXIT_SUCCESS)	1772	void _exit (int status = EXIT_SUCCESS)
1450		1773
1451	UV sv_2watcher (SV *w)
1452	CODE:
1453	RETVAL = (UV)GEventAPI->sv_2watcher (w);
1454	OUTPUT:
1455	RETVAL
1456
1457	#if _POSIX_MEMLOCK	1774	#if _POSIX_MEMLOCK
1458		1775
1459	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
1460		1784
1461	int munlockall ()	1785	int munlockall ()
1462		1786
1463	#endif	1787	#endif
		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	}
1464		1817
1465	int find_animation (utf8_string text)	1818	int find_animation (utf8_string text)
1466	PROTOTYPE: $	1819	PROTOTYPE: $
1467		1820
1468	int random_roll (int min, int max, object *op, int goodbad);	1821	int random_roll (int min, int max, object *op, int goodbad);
1469		1822
1470	const_utf8_string cost_string_from_value(uint64 cost, int approx = 0)	1823	const_utf8_string cost_string_from_value(uint64 cost, int approx = 0)
1471		1824
1472	int
1473	exp_to_level (val64 exp)	1825	int exp_to_level (val64 exp)
1474	CODE:
1475	{
1476	int i = 0;
1477		1826
1478	RETVAL = settings.max_level;
1479
1480	for (i = 1; i <= settings.max_level; i++)
1481	{
1482	if (levels[i] > exp)
1483	{
1484	RETVAL = i - 1;
1485	break;
1486	}
1487	}
1488	}
1489	OUTPUT: RETVAL
1490
1491	val64
1492	level_to_min_exp (int level)	1827	val64 level_to_min_exp (int level)
1493	CODE:
1494	if (level > settings.max_level)
1495	RETVAL = levels[settings.max_level];
1496	else if (level < 1)
1497	RETVAL = 0;
1498	else
1499	RETVAL = levels[level];
1500	OUTPUT: RETVAL
1501		1828
1502	SV *	1829	SV *
1503	resistance_to_string (int atnr)	1830	resistance_to_string (int atnr)
1504	CODE:	1831	CODE:
1505	if (atnr >= 0 && atnr < NROFATTACKS)	1832	if (atnr >= 0 && atnr < NROFATTACKS)
1506	RETVAL = newSVpv (resist_plus[atnr], 0);	1833	RETVAL = newSVpv (resist_plus[atnr], 0);
1507	else	1834	else
1508	XSRETURN_UNDEF;	1835	XSRETURN_UNDEF;
1509	OUTPUT: RETVAL	1836	OUTPUT: RETVAL
1510		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
1511	bool	1880	bool
1512	load_resource_file (octet_string filename)	1881	load_resource_file_ (octet_string filename)
		1882
		1883	void
		1884	fix_weight ()
1513		1885
1514	MODULE = cf PACKAGE = cf::attachable	1886	MODULE = cf PACKAGE = cf::attachable
1515		1887
1516	int	1888	int
1517	valid (SV *obj)	1889	valid (SV *obj)
1518	CODE:	1890	CODE:
1519	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);	1891	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
1520	OUTPUT:	1892	OUTPUT:
1521	RETVAL	1893	RETVAL
1522		1894
		1895	bool should_invoke (attachable *obj, int event)
		1896	CODE:
		1897	RETVAL = obj->should_invoke ((event_type)event);
		1898	OUTPUT: RETVAL
		1899
1523	void	1900	void
1524	debug_trace (attachable *obj, bool on = true)	1901	debug_trace (attachable *obj, bool on = true)
1525	CODE:	1902	CODE:
1526	obj->flags &= ~attachable::F_DEBUG_TRACE;	1903	obj->attachable_flags &= ~attachable::F_DEBUG_TRACE;
1527	if (on)	1904	if (on)
1528	obj->flags |= attachable::F_DEBUG_TRACE;	1905	obj->attachable_flags |= attachable::F_DEBUG_TRACE;
1529		1906
1530	int mortals_size ()	1907	int mortals_size ()
1531	CODE:	1908	CODE:
1532	RETVAL = attachable::mortals.size ();	1909	RETVAL = attachable::mortals.size ();
1533	OUTPUT: RETVAL	1910	OUTPUT: RETVAL
…		…
1535	#object *mortals (U32 index)	1912	#object *mortals (U32 index)
1536	# CODE:	1913	# CODE:
1537	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;	1914	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;
1538	# OUTPUT: RETVAL	1915	# OUTPUT: RETVAL
1539		1916
1540	INCLUDE: $PERL $srcdir/genacc attachable ../include/cfperl.h |	1917	INCLUDE: $PERL $srcdir/genacc attachable $srcdir/../include/util.h $srcdir/../include/cfperl.h |
1541		1918
1542	MODULE = cf PACKAGE = cf::global	1919	MODULE = cf PACKAGE = cf::global
1543		1920
1544	int invoke (SV *klass, int event, ...)	1921	int invoke (SV *klass, int event, ...)
1545	CODE:	1922	CODE:
…		…
1549	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);
1550	OUTPUT: RETVAL	1927	OUTPUT: RETVAL
1551		1928
1552	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_	1929	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
1553		1930
1554	INCLUDE: $PERL $srcdir/genacc object ../include/object.h |	1931	INCLUDE: $PERL $srcdir/genacc object $srcdir/../include/object.h |
1555		1932
1556	int invoke (object *op, int event, ...)	1933	int invoke (object *op, int event, ...)
1557	CODE:	1934	CODE:
1558	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");
1559	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	1936	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
1581	object *actives (U32 index)	1958	object *actives (U32 index)
1582	CODE:	1959	CODE:
1583	RETVAL = index < actives.size () ? actives [index] : 0;	1960	RETVAL = index < actives.size () ? actives [index] : 0;
1584	OUTPUT: RETVAL	1961	OUTPUT: RETVAL
1585		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
1586	# missing properties	1985	# missing properties
1587		1986
1588	object *head (object *op)	1987	object *head (object *op)
1589	PROTOTYPE: $	1988	PROTOTYPE: $
1590	CODE:	1989	CODE:
1591	RETVAL = op->head_ ();	1990	RETVAL = op->head_ ();
1592	OUTPUT: RETVAL
1593
1594	int is_head (object *op)
1595	PROTOTYPE: $
1596	CODE:
1597	RETVAL = op->head_ () == op;
1598	OUTPUT: RETVAL	1991	OUTPUT: RETVAL
1599		1992
1600	void	1993	void
1601	inv (object *obj)	1994	inv (object *obj)
1602	PROTOTYPE: $	1995	PROTOTYPE: $
1603	PPCODE:	1996	PPCODE:
1604	{	1997	{
1605	object *o;
1606	for (o = obj->inv; o; o = o->below)	1998	for (object *o = obj->inv; o; o = o->below)
1607	XPUSHs (sv_2mortal (to_sv (o)));	1999	XPUSHs (sv_2mortal (to_sv (o)));
1608	}	2000	}
1609		2001
1610	void	2002	void
1611	set_animation (object *op, int idx)	2003	set_animation (object *op, int idx)
…		…
1616	num_animations (object *op)	2008	num_animations (object *op)
1617	CODE:	2009	CODE:
1618	RETVAL = NUM_ANIMATIONS (op);	2010	RETVAL = NUM_ANIMATIONS (op);
1619	OUTPUT: RETVAL	2011	OUTPUT: RETVAL
1620		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
1621	object *find_best_object_match (object *op, utf8_string match)	2032	object *find_best_object_match (object *op, utf8_string match)
1622		2033
1623	object *find_marked_object (object *op)
1624
1625	int need_identify (object *obj);
1626
1627	int apply_shop_mat (object *shop_mat, object *op);	2034	int apply_shop_mat (object *shop_mat, object *op);
1628		2035
1629	int move_player (object *op, int dir)	2036	int move (object *op, int dir, object *originator = op)
1630	CODE:	2037	CODE:
1631	RETVAL = move_player (op, dir);	2038	RETVAL = op->move (dir, originator);
1632	OUTPUT:	2039	OUTPUT:
1633	RETVAL	2040	RETVAL
1634		2041
1635	int move (object *op, int dir, object *originator = op)
1636	CODE:
1637	RETVAL = move_ob (op, dir, originator);
1638	OUTPUT:
1639	RETVAL
1640
1641	void apply (object *applier, object *applied, int flags = 0)
1642	CODE:
1643	manual_apply (applied, applier, flags);
1644
1645	void apply_below (object *op)	2042	void apply_below (object *op)
1646	CODE:	2043	CODE:
1647	player_apply_below (op);	2044	player_apply_below (op);
1648		2045
1649	int cast_heal (object *op, object *caster, object *spell, int dir = 0)	2046	int cast_heal (object *op, object *caster, object *spell, int dir = 0)
1650		2047
1651	object *cf_object_present_archname_inside (object *op, utf8_string whatstr)	2048	int casting_level (object *caster, object *spell)
1652
1653	int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)
1654
1655	int cf_object_change_map (object *op, int x, int y, maptile *map)
1656
1657	#//TODO
1658	object *clone_ (object *op, int recursive = 0)
1659	CODE:
1660	if (recursive)
1661	RETVAL = object_create_clone (op);
1662	else
1663	{
1664	RETVAL = object::create ();
1665	op->copy_to (RETVAL);
1666	}
1667	OUTPUT: RETVAL
1668		2049
1669	int pay_item (object *op, object *buyer)	2050	int pay_item (object *op, object *buyer)
1670	CODE:	2051	CODE:
1671	RETVAL = pay_for_item (op, buyer);	2052	RETVAL = pay_for_item (op, buyer);
1672	OUTPUT: RETVAL	2053	OUTPUT: RETVAL
…		…
1707		2088
1708	void drop (object *who, object *op)	2089	void drop (object *who, object *op)
1709		2090
1710	void pick_up (object *who, object *op)	2091	void pick_up (object *who, object *op)
1711		2092
1712	int cf_object_teleport (object *op, maptile *map, int x, int y)
1713
1714	void update_object (object *op, int action)	2093	void update_object (object *op, int action)
1715		2094
1716	object *cf_create_object_by_name (utf8_string name)
1717
1718	void change_exp (object *op, uint64 exp, utf8_string skill_name = 0, int flag = 0)	2095	void change_exp (object *op, uint64 exp, shstr_tmp skill_name = shstr_tmp (), int flag = 0)
1719		2096
1720	void player_lvl_adj (object *who, object *skill = 0)	2097	void player_lvl_adj (object *who, object *skill = 0)
1721		2098
1722	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)
1723		2100
1724	int calc_skill_exp (object *who, object *op, object *skill);	2101	int calc_skill_exp (object *who, object *op, object *skill)
1725		2102
1726	void push_button (object *op);	2103	void push_button (object *op, object *originator)
1727		2104
1728	void use_trigger (object *op);	2105	void use_trigger (object *op, object *originator)
1729		2106
1730	void add_button_link (object *button, maptile *map, int connected);	2107	void handle_apply_yield (object *op)
1731		2108
1732	void remove_button_link (object *op);	2109	int convert_item (object *item, object *converter)
1733		2110
		2111	void fix_generated_item (object *op, object *creator, int difficulty, int max_magic, int flags);
1734		2112
1735	MODULE = cf PACKAGE = cf::object PREFIX = cf_	2113	MODULE = cf PACKAGE = cf::object PREFIX = cf_
1736
1737	object *cf_insert_ob_in_ob (object *ob, object *where)
1738		2114
1739	# 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
1740	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.	2116	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.
1741		2117
1742	object *new (utf8_string archetype = 0)	2118	object *new (utf8_string archetype = 0)
1743	PROTOTYPE: ;$	2119	PROTOTYPE: ;$
1744	CODE:	2120	CODE:
1745	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();	2121	RETVAL = archetype ? get_archetype (archetype) : object::create ();
1746	OUTPUT:	2122	OUTPUT:
1747	RETVAL	2123	RETVAL
1748		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
1749	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)
1750	PROTOTYPE: $$$$$$	2139	PROTOTYPE: $$$$$$
1751	CODE:	2140	CODE:
1752	{	2141	{
1753	int unused_type;	2142	RETVAL = insert_ob_in_map_at (ob, where, orig, flag, x, y);
1754	RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);
1755	}
1756		2143
1757	player *contr (object *op)	2144	if (RETVAL->destroyed ())
1758	CODE:
1759	RETVAL = op->contr;	2145	RETVAL = 0;
1760	OUTPUT: RETVAL	2146	}
1761		2147
1762	const_utf8_string get_ob_key_value (object *op, utf8_string key)	2148	shstr
		2149	object::kv_get (shstr key)
1763		2150
1764	bool set_ob_key_value (object *op, utf8_string key, utf8_string value = 0, int add_key = 1)	2151	void
		2152	object::kv_del (shstr key)
		2153
		2154	void
		2155	object::kv_set (shstr key, shstr value)
1765		2156
1766	object *get_nearest_player (object *ob)	2157	object *get_nearest_player (object *ob)
1767	ALIAS: nearest_player = 0	2158	ALIAS: nearest_player = 0
1768	PREINIT:	2159	PREINIT:
1769	extern object *get_nearest_player (object *);	2160	extern object *get_nearest_player (object *);
…		…
1771	void rangevector (object *ob, object *other, int flags = 0)	2162	void rangevector (object *ob, object *other, int flags = 0)
1772	PROTOTYPE: $$;$	2163	PROTOTYPE: $$;$
1773	PPCODE:	2164	PPCODE:
1774	{	2165	{
1775	rv_vector rv;	2166	rv_vector rv;
		2167
1776	get_rangevector (ob, other, &rv, flags);	2168	get_rangevector (ob, other, &rv, flags);
		2169
1777	EXTEND (SP, 5);	2170	EXTEND (SP, 5);
1778	PUSHs (newSVuv (rv.distance));	2171	PUSHs (sv_2mortal (newSVuv (rv.distance)));
1779	PUSHs (newSViv (rv.distance_x));	2172	PUSHs (sv_2mortal (newSViv (rv.distance_x)));
1780	PUSHs (newSViv (rv.distance_y));	2173	PUSHs (sv_2mortal (newSViv (rv.distance_y)));
1781	PUSHs (newSViv (rv.direction));	2174	PUSHs (sv_2mortal (newSViv (rv.direction)));
1782	PUSHs (newSVcfapi (CFAPI_POBJECT, rv.part));	2175	PUSHs (sv_2mortal (to_sv (rv.part)));
1783	}	2176	}
1784		2177
1785	bool on_same_map_as (object *ob, object *other)	2178	bool on_same_map_as (object *ob, object *other)
1786	CODE:	2179	CODE:
1787	RETVAL = on_same_map (ob, other);	2180	RETVAL = on_same_map (ob, other);
…		…
1791	base_name (object *op, int plural = op->nrof > 1)	2184	base_name (object *op, int plural = op->nrof > 1)
1792	CODE:	2185	CODE:
1793	RETVAL = query_base_name (op, plural);	2186	RETVAL = query_base_name (op, plural);
1794	OUTPUT: RETVAL	2187	OUTPUT: RETVAL
1795		2188
1796	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)));
1797		2195
1798	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_	2196	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_
1799		2197
1800	player *player (object *op)	2198	player *player (object *op)
1801	CODE:	2199	CODE:
1802	RETVAL = op->contr;	2200	RETVAL = op->contr;
1803	OUTPUT: RETVAL	2201	OUTPUT: RETVAL
1804		2202
1805	void check_score (object *op)	2203	bool move_player (object *op, int dir)
1806		2204
1807	void message (object *op, utf8_string txt, int flags = NDI_ORANGE | NDI_UNIQUE)	2205	void message (object *op, utf8_string txt, int flags = NDI_ORANGE | NDI_UNIQUE)
1808	CODE:	2206	CODE:
1809	new_draw_info (flags, 0, op, txt);	2207	new_draw_info (flags, 0, op, txt);
1810		2208
1811	object *cf_player_send_inventory (object *op)
1812
1813	octet_string cf_player_get_ip (object *op)
1814	ALIAS: ip = 0
1815
1816	object *cf_player_get_marked_item (object *op)
1817	ALIAS: marked_item = 0
1818
1819	void cf_player_set_marked_item (object *op, object *ob)
1820
1821	partylist *cf_player_get_party (object *op)
1822	ALIAS: party = 0
1823
1824	void cf_player_set_party (object *op, partylist *party)
1825
1826	void kill_player (object *op)	2209	void kill_player (object *op)
1827		2210
		2211	void esrv_send_item (object *pl, object *item)
		2212
1828	void esrv_update_item (object *op, int what, object *item)	2213	void esrv_update_item (object *pl, int what, object *item)
1829	C_ARGS: what, op, item	2214	C_ARGS: what, pl, item
1830		2215
1831	void clear_los (object *op)	2216	void esrv_del_item (object *pl, int tag)
		2217	C_ARGS: pl->contr, tag
1832		2218
1833	int command_summon (object *op, utf8_string params)	2219	int command_summon (object *op, utf8_string params)
1834		2220
1835	int command_arrest (object *op, utf8_string params)	2221	int command_arrest (object *op, utf8_string params)
1836		2222
1837		2223
1838	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_	2224	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
1839		2225
1840	INCLUDE: $PERL $srcdir/genacc player ../include/player.h |	2226	INCLUDE: $PERL $srcdir/genacc player $srcdir/../include/player.h |
1841		2227
1842	int invoke (player *pl, int event, ...)	2228	int invoke (player *pl, int event, ...)
1843	CODE:	2229	CODE:
1844	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");
1845	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	2231	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
1855	pl->ob->stats.hp = pl->ob->stats.maxhp;	2241	pl->ob->stats.hp = pl->ob->stats.maxhp;
1856	pl->ob->stats.sp = pl->ob->stats.maxsp;	2242	pl->ob->stats.sp = pl->ob->stats.maxsp;
1857	pl->ob->stats.grace = pl->ob->stats.maxgrace;	2243	pl->ob->stats.grace = pl->ob->stats.maxgrace;
1858	pl->orig_stats = pl->ob->stats;	2244	pl->orig_stats = pl->ob->stats;
1859		2245
1860	void cf_player_move (player *pl, int dir)	2246	# should only be temporary
		2247	void esrv_new_player (player *pl)
1861		2248
1862	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
1863
1864	bool	2250	bool
1865	cell_visible (player *pl, int dx, int dy)	2251	cell_visible (player *pl, int dx, int dy)
1866	CODE:	2252	CODE:
1867	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2	2253	RETVAL = pl->blocked_los (dx, dy) != LOS_BLOCKED;
1868	&& !pl->blocked_los [dx + pl->ns->mapx / 2][dy + pl->ns->mapy / 2];
1869	OUTPUT:	2254	OUTPUT:
1870	RETVAL	2255	RETVAL
1871		2256
1872	void	2257	void
1873	send (player *pl, SV *packet)	2258	send (player *pl, SV *packet)
1874	CODE:	2259	CODE:
1875	{	2260	{
1876	STRLEN len;	2261	STRLEN len;
1877	char *buf = SvPVbyte (packet, len);	2262	char *buf = SvPVbyte (packet, len);
1878		2263
		2264	if (len > MAXSOCKBUF)
		2265	pl->failmsg ("[packet too long for client]");
1879	if (pl->ns)	2266	else if (pl->ns)
1880	pl->ns->send_packet (buf, len);	2267	pl->ns->send_packet (buf, len);
1881	}	2268	}
1882
1883	int
1884	listening (player *pl, int new_value = -1)
1885	CODE:
1886	RETVAL = pl->listening;
1887	if (new_value >= 0)
1888	pl->listening = new_value;
1889	OUTPUT:
1890	RETVAL
1891		2269
1892	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)
1893	PROTOTYPE: $;$$$	2271	PROTOTYPE: $;$$$
1894	PPCODE:	2272	PPCODE:
1895	if (GIMME_V != G_VOID)	2273	if (GIMME_V != G_VOID)
…		…
1920	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);	2298	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);
1921	OUTPUT: RETVAL	2299	OUTPUT: RETVAL
1922		2300
1923	SV *registry (maptile *map)	2301	SV *registry (maptile *map)
1924		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
1925	INCLUDE: $PERL $srcdir/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
1926		2343
1927	void	2344	void
1928	maptile::instantiate ()	2345	maptile::instantiate ()
1929		2346
1930	maptile *new ()	2347	maptile *new ()
…		…
1962	for (int x = 0; x < THIS->width; ++x)	2379	for (int x = 0; x < THIS->width; ++x)
1963	for (int y = 0; y < THIS->height; ++y)	2380	for (int y = 0; y < THIS->height; ++y)
1964	{	2381	{
1965	for (object *op = THIS->at (x, y).bot; op; op = op->above)	2382	for (object *op = THIS->at (x, y).bot; op; op = op->above)
1966	if (op->flag [FLAG_IS_FLOOR])	2383	if (op->flag [FLAG_IS_FLOOR])
1967	goto skip_space;	2384	goto skip;
1968		2385
1969	{	2386	{
1970	int offs = offset + y * stride + x;	2387	int offs = offset + y * stride + x;
		2388
1971	if (IN_RANGE_EXC (offs, 0, idxlen))	2389	if (IN_RANGE_EXC (offs, 0, idxlen))
1972	{	2390	{
1973	if (SV **elem = av_fetch ((AV *)palette, idx [offs], 0))	2391	if (SV **elem = av_fetch ((AV *)palette, idx [offs], 0))
1974	{	2392	{
1975	object *ob = get_archetype (SvPVutf8_nolen (*elem));	2393	object *ob = get_archetype (cfSvPVutf8_nolen (*elem));
1976	ob->flag [FLAG_NO_MAP_SAVE] = true;	2394	ob->flag [FLAG_NO_MAP_SAVE] = true;
1977	THIS->insert (ob, x, y, 0, INS_ABOVE_FLOOR_ONLY);	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	}
1978	}	2410	}
1979	}	2411	}
1980	}	2412	}
1981		2413
1982	skip_space: ;	2414	skip: ;
1983	}	2415	}
1984	}	2416	}
1985		2417
1986	void	2418	void
1987	maptile::set_regiondata (SV *data, int offset, int stride, SV *palette)	2419	maptile::set_regiondata (SV *data, int offset, int stride, SV *palette)
…		…
1993	palette = SvRV (palette);	2425	palette = SvRV (palette);
1994		2426
1995	STRLEN idxlen;	2427	STRLEN idxlen;
1996	const uint8_t *idx = (const uint8_t *)SvPVbyte (data, idxlen);	2428	const uint8_t *idx = (const uint8_t *)SvPVbyte (data, idxlen);
1997		2429
1998	region **regionmap = (region **)malloc (	2430	region_ptr *regionmap = new region_ptr [av_len ((AV *)palette) + 1];
1999	(av_len ((AV *)palette) + 1) * sizeof (region *));
2000	uint8_t *regions = salloc<uint8_t> (THIS->size ());	2431	uint8_t *regions = salloc<uint8_t> (THIS->size ());
2001		2432
2002	for (int i = av_len ((AV *)palette) + 1; i--; )	2433	for (int i = av_len ((AV *)palette) + 1; i--; )
2003	regionmap [i] = region::find (	2434	regionmap [i] = region::find (cfSvPVutf8_nolen (*av_fetch ((AV *)palette, i, 1)));
2004	SvPVutf8_nolen (*av_fetch ((AV *)palette, i, 1)));
2005		2435
2006	for (int y = 0; y < THIS->height; ++y)	2436	for (int y = 0; y < THIS->height; ++y)
2007	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);	2437	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);
2008		2438
2009	sfree (THIS->regions, THIS->size ());	2439	sfree (THIS->regions, THIS->size ());
2010	free (THIS->regionmap);	2440	delete [] THIS->regionmap;
2011		2441
2012	THIS->regions = regions;	2442	THIS->regions = regions;
2013	THIS->regionmap = regionmap;	2443	THIS->regionmap = regionmap;
2014	}	2444	}
2015		2445
2016	void	2446	void
2017	maptile::create_region_treasure ()	2447	maptile::create_region_treasure ()
2018	CODE:	2448	CODE:
2019	{
2020	object *op = object::create ();
2021	op->type = FLOOR;
2022	op->map = THIS;
2023
2024	for (int x = 0; x < THIS->width; ++x)	2449	for (int x = 0; x < THIS->width; ++x)
2025	for (int y = 0; y < THIS->height; ++y)	2450	for (int y = 0; y < THIS->height; ++y)
2026	{	2451	{
2027	region *rgn = THIS->region (x, y);	2452	region *rgn = THIS->region (x, y);
2028		2453
2029	//fprintf (stderr, "%d,%d %f %p\n", x, y, rgn->treasure_density,rgn->treasure);//D	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)
2030	if (rgn->treasure && rndm () < rgn->treasure_density)	2456	if (rgn->treasure && rndm () < rgn->treasure_density)
2031	{
2032	op->x = x;
2033	op->y = y;
2034	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);	2457	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);
2035	}
2036	}	2458	}
2037		2459
2038	op->destroy ();
2039	}
2040
2041	void play_sound_map (maptile *map, int x, int y, int sound_num)
2042
2043	int out_of_map (maptile *map, int x, int y)	2460	int out_of_map (maptile *map, int x, int y)
2044		2461
2045	void	2462	void
2046	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: $$$;$
2047	CODE:	2486	CODE:
2048	activate_connection (map, connection, state);
2049
2050	void
2051	get_connection (maptile *map, long connection)
2052	PPCODE:
2053	oblinkpt *obp = get_connection_links (map, connection);
2054	if (obp)
2055	for (objectlink *ol = obp->link; ol; ol = ol->next)
2056	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, (object *)ol->ob)));
2057
2058	object *cf_map_insert_object_there (maptile *where, object *op, object *originator, int flags)
2059
2060	object *cf_map_insert_object (maptile *where, object* op, int x, int y)
2061
2062	object* cf_map_present_arch_by_name (maptile *map, const char* str, int nx, int ny)
2063	C_ARGS: str, map, nx, ny
2064
2065	void
2066	get_map_flags (maptile *map, int x, int y)
2067	PPCODE:
2068	{	2487	{
2069	maptile *nmap = 0;	2488	mapxy pos (map, x, y);
2070	I16 nx = 0, ny = 0;	2489	if (!pos.move (dir).normalise ())
2071	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);	2490	XSRETURN_UNDEF;
2072		2491
2073	EXTEND (SP, 4);	2492	RETVAL = &*pos;
2074	PUSHs (sv_2mortal (newSViv (flags)));
2075
2076	if (GIMME_V == G_ARRAY)
2077	{
2078	PUSHs (sv_2mortal (newSVcfapi (CFAPI_PMAP, nmap)));
2079	PUSHs (sv_2mortal (newSViv (nx)));
2080	PUSHs (sv_2mortal (newSViv (ny)));
2081	}
2082	}	2493	}
		2494	OUTPUT:
		2495	RETVAL
2083		2496
2084	void	2497	void
2085	at (maptile *map, unsigned int x, unsigned int y)	2498	at (maptile *map, unsigned int x, unsigned int y, int dir = 0)
2086	PROTOTYPE: $$$	2499	PROTOTYPE: $$$;$
2087	PPCODE:	2500	PPCODE:
2088	{	2501	mapxy pos (map, x, y);
2089	object *o;	2502	if (pos.move (dir).normalise ())
2090	maptile *nmap = 0;	2503	for (object *o = pos->bot; o; o = o->above)
2091	I16 nx, ny;	2504	XPUSHs (sv_2mortal (to_sv (o)));
2092
2093	get_map_flags (map, &nmap, x, y, &nx, &ny);
2094
2095	if (nmap)
2096	for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)
2097	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));
2098	}
2099		2505
2100	SV *	2506	SV *
2101	bot_at (maptile *obj, unsigned int x, unsigned int y)	2507	bot_at (maptile *map, unsigned int x, unsigned int y, int dir = 0)
2102	PROTOTYPE: $$$	2508	PROTOTYPE: $$$;$
2103	ALIAS:	2509	ALIAS:
2104	top_at = 1	2510	top_at = 1
2105	flags_at = 2	2511	flags_at = 2
2106	light_at = 3	2512	light_at = 3
2107	move_block_at = 4	2513	move_block_at = 4
2108	move_slow_at = 5	2514	move_slow_at = 5
2109	move_on_at = 6	2515	move_on_at = 6
2110	move_off_at = 7	2516	move_off_at = 7
2111	INIT:
2112	if (x >= obj->width || y >= obj->height) XSRETURN_UNDEF;
2113	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
2114	switch (ix)	2527	switch (ix)
2115	{	2528	{
2116	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;	2529	case 0: RETVAL = to_sv (ms.bot ); break;
2117	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;	2530	case 1: RETVAL = to_sv (ms.top ); break;
2118	case 2: RETVAL = newSVuv ( GET_MAP_FLAGS (obj, x, y)); break;	2531	case 2: RETVAL = newSVuv (ms.flags_ ); break;
2119	case 3: RETVAL = newSViv ( GET_MAP_LIGHT (obj, x, y)); break;	2532	case 3: RETVAL = newSViv (ms.light ); break;
2120	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;	2533	case 4: RETVAL = newSVuv (ms.move_block); break;
2121	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;	2534	case 5: RETVAL = newSVuv (ms.move_slow ); break;
2122	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;	2535	case 6: RETVAL = newSVuv (ms.move_on ); break;
2123	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;	2536	case 7: RETVAL = newSVuv (ms.move_off ); break;
2124	}	2537	}
		2538	}
2125	OUTPUT: RETVAL	2539	OUTPUT: RETVAL
2126
2127	void fix_walls (maptile *map, int x, int y)
2128
2129	void fix_walls_around (maptile *map, int x, int y)
2130		2540
2131	# worst xs function of my life	2541	# worst xs function of my life
2132	bool	2542	bool
2133	_create_random_map (\	2543	_create_random_map (maptile *self, SV *options)
2134	maptile *self,\
2135	utf8_string wallstyle,\
2136	utf8_string wall_name,\
2137	utf8_string floorstyle,\
2138	utf8_string monsterstyle,\
2139	utf8_string treasurestyle,\
2140	utf8_string layoutstyle,\
2141	utf8_string doorstyle,\
2142	utf8_string decorstyle,\
2143	utf8_string origin_map,\
2144	utf8_string final_map,\
2145	utf8_string exitstyle,\
2146	utf8_string this_map,\
2147	utf8_string exit_on_final_map,\
2148	int xsize,\
2149	int ysize,\
2150	int expand2x,\
2151	int layoutoptions1,\
2152	int layoutoptions2,\
2153	int layoutoptions3,\
2154	int symmetry,\
2155	int difficulty,\
2156	int difficulty_given,\
2157	float difficulty_increase,\
2158	int dungeon_level,\
2159	int dungeon_depth,\
2160	int decoroptions,\
2161	int orientation,\
2162	int origin_y,\
2163	int origin_x,\
2164	U32 random_seed,\
2165	val64 total_map_hp,\
2166	int map_layout_style,\
2167	int treasureoptions,\
2168	int symmetry_used,\
2169	region *region,\
2170	utf8_string custom\
2171	)
2172	CODE:	2544	CODE:
2173	{	2545	{
2174	random_map_params rmp;	2546	random_map_params rmp ((HV *)SvRV (options));
2175
2176	assign (rmp.wallstyle , wallstyle);
2177	assign (rmp.wall_name , wall_name);
2178	assign (rmp.floorstyle , floorstyle);
2179	assign (rmp.monsterstyle , monsterstyle);
2180	assign (rmp.treasurestyle , treasurestyle);
2181	assign (rmp.layoutstyle , layoutstyle);
2182	assign (rmp.doorstyle , doorstyle);
2183	assign (rmp.decorstyle , decorstyle);
2184	assign (rmp.exitstyle , exitstyle);
2185	assign (rmp.exit_on_final_map, exit_on_final_map);
2186
2187	rmp.origin_map = origin_map;
2188	rmp.final_map = final_map;
2189	rmp.this_map = this_map;
2190	rmp.xsize = xsize;
2191	rmp.ysize = ysize;
2192	rmp.expand2x = expand2x;
2193	rmp.layoutoptions1 = layoutoptions1;
2194	rmp.layoutoptions2 = layoutoptions2;
2195	rmp.layoutoptions3 = layoutoptions3;
2196	rmp.symmetry = symmetry;
2197	rmp.difficulty = difficulty;
2198	rmp.difficulty_given = difficulty_given;
2199	rmp.difficulty_increase = difficulty_increase;
2200	rmp.dungeon_level = dungeon_level;
2201	rmp.dungeon_depth = dungeon_depth;
2202	rmp.decoroptions = decoroptions;
2203	rmp.orientation = orientation;
2204	rmp.origin_y = origin_y;
2205	rmp.origin_x = origin_x;
2206	rmp.random_seed = random_seed;
2207	rmp.total_map_hp = total_map_hp;
2208	rmp.map_layout_style = map_layout_style;
2209	rmp.treasureoptions = treasureoptions;
2210	rmp.symmetry_used = symmetry_used;
2211	rmp.region = region;
2212	rmp.custom = custom;
2213
2214	RETVAL = self->generate_random_map (&rmp);	2547	RETVAL = self->generate_random_map (&rmp);
2215	}	2548	}
2216	OUTPUT:	2549	OUTPUT:
2217	RETVAL	2550	RETVAL
2218		2551
		2552	MODULE = cf PACKAGE = cf::mapspace
		2553
		2554	INCLUDE: $PERL $srcdir/genacc mapspace $srcdir/../include/map.h |
		2555
2219	MODULE = cf PACKAGE = cf::arch	2556	MODULE = cf PACKAGE = cf::arch
2220		2557
2221	archetype *find (utf8_string name)	2558	int archetypes_size ()
2222	CODE:	2559	CODE:
2223	RETVAL = archetype::find (name);	2560	RETVAL = archetypes.size ();
2224	OUTPUT:
2225	RETVAL
2226
2227	archetype *first()
2228	PROTOTYPE:
2229	CODE:
2230	RETVAL = first_archetype;
2231	OUTPUT: RETVAL	2561	OUTPUT: RETVAL
2232		2562
		2563	archetype *archetypes (U32 index)
		2564	CODE:
		2565	RETVAL = index < archetypes.size () ? archetypes [index] : 0;
		2566	OUTPUT: RETVAL
		2567
2233	INCLUDE: $PERL $srcdir/genacc archetype ../include/object.h |	2568	INCLUDE: $PERL $srcdir/genacc archetype $srcdir/../include/object.h |
2234		2569
2235	MODULE = cf PACKAGE = cf::party	2570	MODULE = cf PACKAGE = cf::party
2236		2571
2237	partylist *first ()	2572	partylist *first ()
2238	PROTOTYPE:	2573	PROTOTYPE:
2239	CODE:	2574	CODE:
2240	RETVAL = get_firstparty ();	2575	RETVAL = get_firstparty ();
2241	OUTPUT: RETVAL	2576	OUTPUT: RETVAL
2242		2577
2243	INCLUDE: $PERL $srcdir/genacc partylist ../include/player.h |	2578	INCLUDE: $PERL $srcdir/genacc partylist $srcdir/../include/player.h |
2244		2579
2245	MODULE = cf PACKAGE = cf::region	2580	MODULE = cf PACKAGE = cf::region
2246		2581
2247	void	2582	void
2248	list ()	2583	list ()
2249	PPCODE:	2584	PPCODE:
2250	for_all_regions (rgn)	2585	for_all_regions (rgn)
2251	XPUSHs (sv_2mortal (to_sv (rgn)));	2586	XPUSHs (sv_2mortal (to_sv (rgn)));
2252		2587
2253	region *find (utf8_string name)
2254	PROTOTYPE: $
2255	CODE:
2256	RETVAL = region::find (name);
2257	OUTPUT: RETVAL
2258
2259	region *find_fuzzy (utf8_string name)
2260	PROTOTYPE: $
2261	CODE:
2262	RETVAL = region::find_fuzzy (name);
2263	OUTPUT: RETVAL
2264
2265	int specificity (region *rgn)	2588	int specificity (region *rgn)
2266	CODE:	2589	CODE:
2267	RETVAL = 0;	2590	RETVAL = 0;
2268	while (rgn = rgn->parent)	2591	while (rgn = rgn->parent)
2269	RETVAL++;	2592	RETVAL++;
2270	OUTPUT: RETVAL	2593	OUTPUT: RETVAL
2271		2594
2272	INCLUDE: $PERL $srcdir/genacc region ../include/region.h |	2595	INCLUDE: $PERL $srcdir/genacc region $srcdir/../include/region.h |
2273		2596
2274	MODULE = cf PACKAGE = cf::living	2597	MODULE = cf PACKAGE = cf::living
2275		2598
2276	INCLUDE: $PERL $srcdir/genacc living ../include/living.h |	2599	INCLUDE: $PERL $srcdir/genacc living $srcdir/../include/living.h |
2277		2600
2278	MODULE = cf PACKAGE = cf::settings	2601	MODULE = cf PACKAGE = cf::settings
2279		2602
2280	INCLUDE: $PERL $srcdir/genacc Settings ../include/global.h |	2603	INCLUDE: $PERL $srcdir/genacc Settings $srcdir/../include/global.h |
2281		2604
2282	MODULE = cf PACKAGE = cf::client	2605	MODULE = cf PACKAGE = cf::client
2283		2606
2284	INCLUDE: $PERL $srcdir/genacc client ../include/client.h |	2607	INCLUDE: $PERL $srcdir/genacc client $srcdir/../include/client.h |
2285		2608
2286	int invoke (client *ns, int event, ...)	2609	int invoke (client *ns, int event, ...)
2287	CODE:	2610	CODE:
2288	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");
2289	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	2612	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
2305	CODE:	2628	CODE:
2306	{	2629	{
2307	STRLEN len;	2630	STRLEN len;
2308	char *buf = SvPVbyte (packet, len);	2631	char *buf = SvPVbyte (packet, len);
2309		2632
		2633	if (len > MAXSOCKBUF)
		2634	{
		2635	// ugly
		2636	if (THIS->pl)
		2637	THIS->pl->failmsg ("[packet too long for client]");
		2638	}
		2639	else
2310	THIS->send_packet (buf, len);	2640	THIS->send_packet (buf, len);
2311	}	2641	}
		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;
2312		2680
2313	MODULE = cf PACKAGE = cf::face PREFIX = face_	2681	MODULE = cf PACKAGE = cf::face PREFIX = face_
2314		2682
2315	#INCLUDE: $PERL $srcdir/genacc faceset ../include/face.h |	2683	#INCLUDE: $PERL $srcdir/genacc faceset $srcdir/../include/face.h |
2316		2684
2317	faceidx face_find (utf8_string name, faceidx defidx = 0)	2685	faceidx face_find (utf8_string name, faceidx defidx = 0)
2318		2686
2319	faceidx alloc (utf8_string name)	2687	faceidx alloc (utf8_string name)
2320	CODE:	2688	CODE:
…		…
2327	while (!RETVAL); // crude way to leave index 0	2695	while (!RETVAL); // crude way to leave index 0
2328		2696
2329	faces [RETVAL].name = name;	2697	faces [RETVAL].name = name;
2330	facehash.insert (std::make_pair (faces [RETVAL].name, RETVAL));	2698	facehash.insert (std::make_pair (faces [RETVAL].name, RETVAL));
2331		2699
2332	if (!strcmp (name, BLANK_FACE_NAME)) blank_face = RETVAL;	2700	if (!strcmp (name, BLANK_FACE_NAME )) blank_face = RETVAL;
2333	if (!strcmp (name, EMPTY_FACE_NAME)) empty_face = RETVAL;	2701	if (!strcmp (name, EMPTY_FACE_NAME )) empty_face = RETVAL;
		2702	if (!strcmp (name, MAGICMOUTH_FACE_NAME)) magicmouth_face = RETVAL;
2334	}	2703	}
2335	OUTPUT: RETVAL	2704	OUTPUT: RETVAL
2336		2705
2337	void set (faceidx idx, int visibility, int magicmap)	2706	void set_type (faceidx idx, int value)
2338	CODE:	2707	ALIAS:
2339	faceinfo *f = face_info (idx);	2708	set_type = 0
2340	assert (f);	2709	set_visibility = 1
2341	f->visibility = visibility;	2710	set_magicmap = 2
2342	f->magicmap = magicmap;	2711	set_smooth = 3
2343		2712	set_smoothlevel = 4
2344	void set_smooth (faceidx idx, faceidx smooth, int smoothlevel)
2345	CODE:	2713	CODE:
2346	faceinfo *f = face_info (idx); assert (f);	2714	faceinfo *f = face_info (idx); assert (f);
2347	f->smooth = smooth;	2715	switch (ix)
2348	f->smoothlevel = smoothlevel;	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	}
2349		2723
2350	void set_data (faceidx idx, int faceset, SV *data, SV *chksum)	2724	void set_data (faceidx idx, int faceset, SV *data, SV *chksum)
2351	CODE:	2725	CODE:
2352	{	2726	{
2353	facedata *d = face_data (idx, faceset);	2727	faceinfo *f = face_info (idx); assert (f);
2354	assert (d);	2728	facedata *d = &(faceset ? f->data64 : f->data32);
2355	sv_to (data, d->data);	2729	sv_to (data, d->data);
2356	STRLEN clen;	2730	STRLEN clen;
2357	char *cdata = SvPVbyte (chksum, clen);	2731	char *cdata = SvPVbyte (chksum, clen);
2358	clen = min (CHKSUM_SIZE, clen);	2732	clen = min (CHKSUM_MAXLEN, clen);
2359		2733
		2734	assert (("cf::face::set_data must be called with a non-empty checksum", clen));
		2735
2360	if (memcmp (d->chksum, cdata, clen))	2736	if (clen != d->chksum_len || memcmp (d->chksum, cdata, clen))
2361	{	2737	{
		2738	d->chksum_len = clen;
2362	memcpy (d->chksum, cdata, clen);	2739	memcpy (d->chksum, cdata, clen);
2363		2740
2364	// invalidate existing client face info	2741	// invalidate existing client face info
2365	for_all_clients (ns)	2742	for_all_clients (ns)
2366	if (ns->faceset == faceset)	2743	if (ns->faceset == faceset)
…		…
2369	ns->force_newmap = true;	2746	ns->force_newmap = true;
2370	}	2747	}
2371	}	2748	}
2372	}	2749	}
2373		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
2374	void invalidate (faceidx idx)	2775	void invalidate (faceidx idx)
2375	CODE:	2776	CODE:
2376	for_all_clients (ns)	2777	for_all_clients (ns)
2377	{	2778	{
2378	ns->faces_sent [idx] = false;	2779	ns->faces_sent [idx] = false;
…		…
2387	ns->force_newmap = true;	2788	ns->force_newmap = true;
2388	}	2789	}
2389		2790
2390	MODULE = cf PACKAGE = cf::anim PREFIX = anim_	2791	MODULE = cf PACKAGE = cf::anim PREFIX = anim_
2391		2792
2392	#INCLUDE: $PERL $srcdir/genacc faceset ../include/anim.h |	2793	#INCLUDE: $PERL $srcdir/genacc faceset $srcdir/../include/anim.h |
2393		2794
2394	animidx anim_find (utf8_string name)	2795	animidx anim_find (utf8_string name)
2395	CODE:	2796	CODE:
2396	RETVAL = animation::find (name).number;	2797	RETVAL = animation::find (name).number;
2397	OUTPUT: RETVAL	2798	OUTPUT: RETVAL
…		…
2412	}	2813	}
2413	else	2814	else
2414	anim = &animation::create (name, av_len (av) + 1, facings);	2815	anim = &animation::create (name, av_len (av) + 1, facings);
2415		2816
2416	for (int i = 0; i < anim->num_animations; ++i)	2817	for (int i = 0; i < anim->num_animations; ++i)
2417	anim->faces [i] = face_find (SvPVutf8_nolen (*av_fetch (av, i, 1)));	2818	anim->faces [i] = face_find (cfSvPVutf8_nolen (*av_fetch (av, i, 1)));
2418	}	2819	}
2419	OUTPUT: RETVAL	2820	OUTPUT: RETVAL
2420		2821
2421	void invalidate_all ()	2822	void invalidate_all ()
2422	CODE:	2823	CODE:
2423	for_all_clients (ns)	2824	for_all_clients (ns)
2424	ns->anims_sent.reset ();	2825	ns->anims_sent.reset ();
2425		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/../random_maps/random_map.h |
		2893

Diff Legend

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