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

Diff Legend

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