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.204 by root, Mon Apr 30 04:25:30 2007 UTC vs.
Revision 1.427 by root, Tue Nov 20 14:50:17 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 (PLAYER) const_iv (TRANSPORT) const_iv (ROD) const_iv (TREASURE)
1141	const_iv (POTION) const_iv (FOOD) const_iv (POISON) const_iv (BOOK)
1142	const_iv (CLOCK) const_iv (ARROW) const_iv (BOW) const_iv (WEAPON)
1143	const_iv (ARMOUR) const_iv (PEDESTAL) const_iv (ALTAR) const_iv (LOCKED_DOOR)
1144	const_iv (SPECIAL_KEY) const_iv (MAP) const_iv (DOOR) const_iv (KEY)
1145	const_iv (TIMED_GATE) const_iv (TRIGGER) const_iv (GRIMREAPER) const_iv (MAGIC_EAR)
1146	const_iv (TRIGGER_BUTTON) const_iv (TRIGGER_ALTAR) const_iv (TRIGGER_PEDESTAL) const_iv (SHIELD)
1147	const_iv (HELMET) const_iv (HORN) const_iv (MONEY) const_iv (CLASS)
1148	const_iv (GRAVESTONE) const_iv (AMULET) const_iv (PLAYERMOVER) const_iv (TELEPORTER)
1149	const_iv (CREATOR) const_iv (SKILL) const_iv (EARTHWALL) const_iv (GOLEM)
1150	const_iv (THROWN_OBJ) const_iv (BLINDNESS) const_iv (GOD) const_iv (DETECTOR)
1151	const_iv (TRIGGER_MARKER) const_iv (DEAD_OBJECT) const_iv (DRINK) const_iv (MARKER)
1152	const_iv (HOLY_ALTAR) const_iv (PLAYER_CHANGER) const_iv (BATTLEGROUND) const_iv (PEACEMAKER)
1153	const_iv (GEM) const_iv (FIREWALL) const_iv (ANVIL) const_iv (CHECK_INV)
1154	const_iv (MOOD_FLOOR) const_iv (EXIT) const_iv (ENCOUNTER) const_iv (SHOP_FLOOR)
1155	const_iv (SHOP_MAT) const_iv (RING) const_iv (FLOOR) const_iv (FLESH)
1156	const_iv (INORGANIC) const_iv (SKILL_TOOL) const_iv (LIGHTER) const_iv (BUILDABLE_WALL)
1157	const_iv (MISC_OBJECT) const_iv (LAMP) const_iv (DUPLICATOR) const_iv (SPELLBOOK)
1158	const_iv (CLOAK) const_iv (SPINNER) const_iv (GATE) const_iv (BUTTON)
1159	const_iv (CF_HANDLE) const_iv (HOLE) const_iv (TRAPDOOR) const_iv (SIGN)
1160	const_iv (BOOTS) const_iv (GLOVES) const_iv (SPELL) const_iv (SPELL_EFFECT)
1161	const_iv (CONVERTER) const_iv (BRACERS) const_iv (POISONING) const_iv (SAVEBED)
1162	const_iv (WAND) const_iv (SCROLL) const_iv (DIRECTOR) const_iv (GIRDLE)
1163	const_iv (FORCE) const_iv (POTION_EFFECT) const_iv (EVENT_CONNECTOR) const_iv (CLOSE_CON)
1164	const_iv (CONTAINER) const_iv (ARMOUR_IMPROVER) const_iv (WEAPON_IMPROVER) const_iv (SKILLSCROLL)
1165	const_iv (DEEP_SWAMP) const_iv (IDENTIFY_ALTAR) const_iv (MENU) const_iv (RUNE)
1166	const_iv (TRAP) const_iv (POWER_CRYSTAL) const_iv (CORPSE) const_iv (DISEASE)
1167	const_iv (SYMPTOM) const_iv (BUILDER) const_iv (MATERIAL) const_iv (ITEM_TRANSFORMER)
1168
1169	const_iv (NUM_SUBTYPES)
1170
1171	const_iv (ST_BD_BUILD) const_iv (ST_BD_REMOVE)
1172	const_iv (ST_MAT_FLOOR) const_iv (ST_MAT_WALL) const_iv (ST_MAT_ITEM)
1173
1174	const_iv (AT_PHYSICAL) const_iv (AT_MAGIC) const_iv (AT_FIRE) const_iv (AT_ELECTRICITY)
1175	const_iv (AT_COLD) const_iv (AT_CONFUSION) const_iv (AT_ACID) const_iv (AT_DRAIN)
1176	const_iv (AT_WEAPONMAGIC) const_iv (AT_GHOSTHIT) const_iv (AT_POISON) const_iv (AT_SLOW)
1177	const_iv (AT_PARALYZE) const_iv (AT_TURN_UNDEAD) const_iv (AT_FEAR) const_iv (AT_CANCELLATION)
1178	const_iv (AT_DEPLETE) const_iv (AT_DEATH) const_iv (AT_CHAOS) const_iv (AT_COUNTERSPELL)
1179	const_iv (AT_GODPOWER) const_iv (AT_HOLYWORD) const_iv (AT_BLIND) const_iv (AT_INTERNAL)
1180	const_iv (AT_LIFE_STEALING) const_iv (AT_DISEASE)
1181
1182	const_iv (WEAP_HIT) const_iv (WEAP_SLASH) const_iv (WEAP_PIERCE) const_iv (WEAP_CLEAVE)
1183	const_iv (WEAP_SLICE) const_iv (WEAP_STAB) const_iv (WEAP_WHIP) const_iv (WEAP_CRUSH)
1184	const_iv (WEAP_BLUD)
1185
1186	const_iv (FLAG_ALIVE) const_iv (FLAG_WIZ) const_iv (FLAG_REMOVED) const_iv (FLAG_FREED)
1187	const_iv (FLAG_WAS_WIZ) const_iv (FLAG_APPLIED) const_iv (FLAG_UNPAID) const_iv (FLAG_USE_SHIELD)
1188	const_iv (FLAG_NO_PICK) const_iv (FLAG_ANIMATE) const_iv (FLAG_MONSTER) const_iv (FLAG_FRIENDLY)
1189	const_iv (FLAG_GENERATOR) const_iv (FLAG_IS_THROWN) const_iv (FLAG_AUTO_APPLY) const_iv (FLAG_PLAYER_SOLD)
1190	const_iv (FLAG_SEE_INVISIBLE) const_iv (FLAG_CAN_ROLL) const_iv (FLAG_OVERLAY_FLOOR) const_iv (FLAG_IS_TURNABLE)
1191	const_iv (FLAG_IS_USED_UP) const_iv (FLAG_IDENTIFIED) const_iv (FLAG_REFLECTING) const_iv (FLAG_CHANGING)
1192	const_iv (FLAG_SPLITTING) const_iv (FLAG_HITBACK) const_iv (FLAG_STARTEQUIP) const_iv (FLAG_BLOCKSVIEW)
1193	const_iv (FLAG_UNDEAD) const_iv (FLAG_SCARED) const_iv (FLAG_UNAGGRESSIVE) const_iv (FLAG_REFL_MISSILE)
1194	const_iv (FLAG_REFL_SPELL) const_iv (FLAG_NO_MAGIC) const_iv (FLAG_NO_FIX_PLAYER) const_iv (FLAG_IS_LIGHTABLE)
1195	const_iv (FLAG_TEAR_DOWN) const_iv (FLAG_RUN_AWAY) const_iv (FLAG_PICK_UP) const_iv (FLAG_UNIQUE)
1196	const_iv (FLAG_NO_DROP) const_iv (FLAG_WIZCAST) const_iv (FLAG_CAST_SPELL) const_iv (FLAG_USE_SCROLL)
1197	const_iv (FLAG_USE_RANGE) const_iv (FLAG_USE_BOW) const_iv (FLAG_USE_ARMOUR) const_iv (FLAG_USE_WEAPON)
1198	const_iv (FLAG_USE_RING) const_iv (FLAG_READY_RANGE) const_iv (FLAG_READY_BOW) const_iv (FLAG_XRAYS)
1199	const_iv (FLAG_NO_APPLY) const_iv (FLAG_IS_FLOOR) const_iv (FLAG_LIFESAVE) const_iv (FLAG_NO_STRENGTH)
1200	const_iv (FLAG_SLEEP) const_iv (FLAG_STAND_STILL) const_iv (FLAG_RANDOM_MOVE) const_iv (FLAG_ONLY_ATTACK)
1201	const_iv (FLAG_CONFUSED) const_iv (FLAG_STEALTH) const_iv (FLAG_WIZPASS) const_iv (FLAG_IS_LINKED)
1202	const_iv (FLAG_CURSED) const_iv (FLAG_DAMNED) const_iv (FLAG_SEE_ANYWHERE) const_iv (FLAG_KNOWN_MAGICAL)
1203	const_iv (FLAG_KNOWN_CURSED) const_iv (FLAG_CAN_USE_SKILL) const_iv (FLAG_BEEN_APPLIED) const_iv (FLAG_READY_SCROLL)
1204	const_iv (FLAG_USE_ROD) const_iv (FLAG_USE_HORN) const_iv (FLAG_MAKE_INVIS) const_iv (FLAG_INV_LOCKED)
1205	const_iv (FLAG_IS_WOODED) const_iv (FLAG_IS_HILLY) const_iv (FLAG_READY_SKILL) const_iv (FLAG_READY_WEAPON)
1206	const_iv (FLAG_NO_SKILL_IDENT) const_iv (FLAG_BLIND) const_iv (FLAG_SEE_IN_DARK) const_iv (FLAG_IS_CAULDRON)
1207	const_iv (FLAG_NO_STEAL) const_iv (FLAG_ONE_HIT) const_iv (FLAG_CLIENT_SENT) const_iv (FLAG_BERSERK)
1208	const_iv (FLAG_NEUTRAL) const_iv (FLAG_NO_ATTACK) const_iv (FLAG_NO_DAMAGE) const_iv (FLAG_OBJ_ORIGINAL)
1209	const_iv (FLAG_OBJ_SAVE_ON_OVL) const_iv (FLAG_ACTIVATE_ON_PUSH) const_iv (FLAG_ACTIVATE_ON_RELEASE) const_iv (FLAG_IS_WATER)
1210	const_iv (FLAG_CONTENT_ON_GEN) const_iv (FLAG_IS_A_TEMPLATE) const_iv (FLAG_IS_BUILDABLE)
1211	const_iv (FLAG_DESTROY_ON_DEATH) const_iv (FLAG_NO_MAP_SAVE)
1212
1213	const_iv (NDI_BLACK) const_iv (NDI_WHITE) const_iv (NDI_NAVY) const_iv (NDI_RED)
1214	const_iv (NDI_ORANGE) const_iv (NDI_BLUE) const_iv (NDI_DK_ORANGE) const_iv (NDI_GREEN)
1215	const_iv (NDI_LT_GREEN) const_iv (NDI_GREY) const_iv (NDI_BROWN) const_iv (NDI_GOLD)
1216	const_iv (NDI_TAN) const_iv (NDI_MAX_COLOR) const_iv (NDI_COLOR_MASK) const_iv (NDI_UNIQUE)
1217	const_iv (NDI_ALL)
1218		1489
1219	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)
1220	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)
1221		1492
1222	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)
1223		1494
1224	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)
1225	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)
1226	const_iv (F_LOCKED)	1497	const_iv (F_LOCKED)
1227		1498
1228	const_iv (F_BUY) const_iv (F_SHOP) const_iv (F_SELL)
1229
1230	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)
1231	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)
1232		1501
1233	const_iv (UP_OBJ_INSERT) const_iv (UP_OBJ_REMOVE) const_iv (UP_OBJ_CHANGE) const_iv (UP_OBJ_FACE)
1234
1235	const_iv (INS_NO_MERGE) const_iv (INS_ABOVE_FLOOR_ONLY) const_iv (INS_NO_WALK_ON)
1236	const_iv (INS_ON_TOP) const_iv (INS_BELOW_ORIGINATOR) const_iv (INS_MAP_LOAD)
1237
1238	const_iv (WILL_APPLY_HANDLE) const_iv (WILL_APPLY_TREASURE) const_iv (WILL_APPLY_EARTHWALL)
1239	const_iv (WILL_APPLY_DOOR) const_iv (WILL_APPLY_FOOD)
1240
1241	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)	1502	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)
1242
1243	const_iv (M_PAPER) const_iv (M_IRON) const_iv (M_GLASS) const_iv (M_LEATHER)
1244	const_iv (M_WOOD) const_iv (M_ORGANIC) const_iv (M_STONE) const_iv (M_CLOTH)
1245	const_iv (M_ADAMANT) const_iv (M_LIQUID) const_iv (M_SOFT_METAL) const_iv (M_BONE)
1246	const_iv (M_ICE) const_iv (M_SPECIAL)
1247		1503
1248	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)
1249	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)
1250		1506
1251	const_iv (SK_LOCKPICKING) const_iv (SK_HIDING) const_iv (SK_SMITHERY) const_iv (SK_BOWYER)
1252	const_iv (SK_JEWELER) const_iv (SK_ALCHEMY) const_iv (SK_STEALING) const_iv (SK_LITERACY)
1253	const_iv (SK_BARGAINING) const_iv (SK_JUMPING) const_iv (SK_DET_MAGIC) const_iv (SK_ORATORY)
1254	const_iv (SK_SINGING) const_iv (SK_DET_CURSE) const_iv (SK_FIND_TRAPS) const_iv (SK_MEDITATION)
1255	const_iv (SK_PUNCHING) const_iv (SK_FLAME_TOUCH) const_iv (SK_KARATE) const_iv (SK_CLIMBING)
1256	const_iv (SK_WOODSMAN) const_iv (SK_INSCRIPTION) const_iv (SK_ONE_HANDED_WEAPON) const_iv (SK_MISSILE_WEAPON)
1257	const_iv (SK_THROWING) const_iv (SK_USE_MAGIC_ITEM) const_iv (SK_DISARM_TRAPS) const_iv (SK_SET_TRAP)
1258	const_iv (SK_THAUMATURGY) const_iv (SK_PRAYING) const_iv (SK_CLAWING) const_iv (SK_LEVITATION)
1259	const_iv (SK_SUMMONING) const_iv (SK_PYROMANCY) const_iv (SK_EVOCATION) const_iv (SK_SORCERY)
1260	const_iv (SK_TWO_HANDED_WEAPON) const_iv (SK_SPARK_TOUCH) const_iv (SK_SHIVER) const_iv (SK_ACID_SPLASH)
1261	const_iv (SK_POISON_NAIL)
1262
1263	const_iv (SOUND_NEW_PLAYER) const_iv (SOUND_FIRE_ARROW) const_iv (SOUND_LEARN_SPELL) const_iv (SOUND_FUMBLE_SPELL)
1264	const_iv (SOUND_WAND_POOF) const_iv (SOUND_OPEN_DOOR) const_iv (SOUND_PUSH_PLAYER) const_iv (SOUND_PLAYER_HITS1)
1265	const_iv (SOUND_PLAYER_HITS2) const_iv (SOUND_PLAYER_HITS3) const_iv (SOUND_PLAYER_HITS4) const_iv (SOUND_PLAYER_IS_HIT1)
1266	const_iv (SOUND_PLAYER_IS_HIT2) const_iv (SOUND_PLAYER_IS_HIT3) const_iv (SOUND_PLAYER_KILLS) const_iv (SOUND_PET_IS_KILLED)
1267	const_iv (SOUND_PLAYER_DIES) const_iv (SOUND_OB_EVAPORATE) const_iv (SOUND_OB_EXPLODE) const_iv (SOUND_CLOCK)
1268	const_iv (SOUND_TURN_HANDLE) const_iv (SOUND_FALL_HOLE) const_iv (SOUND_DRINK_POISON) const_iv (SOUND_CAST_SPELL_0)
1269
1270	const_iv (PREFER_LOW) const_iv (PREFER_HIGH)
1271
1272	const_iv (ATNR_PHYSICAL) const_iv (ATNR_MAGIC) const_iv (ATNR_FIRE) const_iv (ATNR_ELECTRICITY)
1273	const_iv (ATNR_COLD) const_iv (ATNR_CONFUSION) const_iv (ATNR_ACID) const_iv (ATNR_DRAIN)
1274	const_iv (ATNR_WEAPONMAGIC) const_iv (ATNR_GHOSTHIT) const_iv (ATNR_POISON) const_iv (ATNR_SLOW)
1275	const_iv (ATNR_PARALYZE) const_iv (ATNR_TURN_UNDEAD) const_iv (ATNR_FEAR) const_iv (ATNR_CANCELLATION)
1276	const_iv (ATNR_DEPLETE) const_iv (ATNR_DEATH) const_iv (ATNR_CHAOS) const_iv (ATNR_COUNTERSPELL)
1277	const_iv (ATNR_GODPOWER) const_iv (ATNR_HOLYWORD) const_iv (ATNR_BLIND) const_iv (ATNR_INTERNAL)
1278	const_iv (ATNR_LIFE_STEALING) const_iv (ATNR_DISEASE)
1279
1280	const_iv (MAP_IN_MEMORY) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)
1281
1282	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)
1283	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)
1284		1509
1285	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)
1286		1511
1287	const_iv (ST_DEAD) const_iv (ST_SETUP) const_iv (ST_PLAYING) const_iv (ST_CUSTOM)
1288
1289	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)
1290
1291	// random map generator
1292	const_iv (LAYOUT_NONE) const_iv (LAYOUT_ONION) const_iv (LAYOUT_MAZE) const_iv (LAYOUT_SPIRAL)
1293	const_iv (LAYOUT_ROGUELIKE) const_iv (LAYOUT_SNAKE) const_iv (LAYOUT_SQUARE_SPIRAL)
1294
1295	const_iv (RMOPT_RANDOM) const_iv (RMOPT_CENTERED) const_iv (RMOPT_LINEAR)
1296	const_iv (RMOPT_BOTTOM_C) const_iv (RMOPT_BOTTOM_R) const_iv (RMOPT_IRR_SPACE)
1297	const_iv (RMOPT_WALL_OFF) const_iv (RMOPT_WALLS_ONLY) const_iv (RMOPT_NO_DOORS)
1298
1299	const_iv (SYMMETRY_RANDOM) const_iv (SYMMETRY_NONE) const_iv (SYMMETRY_X)
1300	const_iv (SYMMETRY_Y) const_iv (SYMMETRY_XY)
1301
1302	const_iv (GT_ENVIRONMENT) const_iv (GT_INVISIBLE) const_iv (GT_STARTEQUIP)
1303	const_iv (GT_APPLY) const_iv (GT_ONLY_GOOD) const_iv (GT_UPDATE_INV)
1304	const_iv (GT_MINIMAL)
1305	};	1513	};
1306		1514
1307	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; )
1308	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));	1516	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1309		1517
1310	static const struct {	1518	static const struct {
1311	const char *name;	1519	const char *name;
1312	int skip;	1520	int skip;
…		…
1318	# undef def	1526	# undef def
1319	};	1527	};
1320		1528
1321	AV *av = get_av ("cf::EVENT", 1);	1529	AV *av = get_av ("cf::EVENT", 1);
1322		1530
1323	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; )
1324	{	1532	{
1325	AV *event = newAV ();	1533	AV *event = newAV ();
1326	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));	1534	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));
1327	av_push (event, newSViv (eiv->klass));	1535	av_push (event, newSViv (eiv->klass));
1328	av_store (av, eiv->iv, newRV_noinc ((SV *)event));	1536	av_store (av, eiv->iv, newRV_noinc ((SV *)event));
1329	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));	1537	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));
1330	}	1538	}
1331	}
1332		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
1333	void _connect_to_perl ()	1560	void _connect_to_perl_1 ()
1334		1561
		1562	void _connect_to_perl_2 ()
		1563
		1564	void _recalc_want ()
		1565
		1566	# not used by default anymore
1335	void _global_reattach ()	1567	void _global_reattach ()
1336	CODE:	1568	CODE:
1337	{	1569	{
1338	// reattach to all attachable objects in the game.	1570	// reattach to all attachable objects in the game.
1339	for_all_clients (ns)	1571	for_all_clients (ns)
…		…
1341		1573
1342	for_all_objects (op)	1574	for_all_objects (op)
1343	op->reattach ();	1575	op->reattach ();
1344	}	1576	}
1345		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
1346	void _post_tick ()	1604	void cede_to_tick ()
1347	CODE:	1605	CODE:
1348	coroapi::next_cede = SvNV (sv_next_tick) - TICK * (1. - 1. / CEDES_PER_TICK);	1606	coroapi::cede_to_tick ();
1349		1607
1350	# support function for map-world.ext	1608	NV till_tick ()
1351	void _quantise (SV *data_sv, SV *plt_sv)
1352	CODE:	1609	CODE:
1353	{	1610	RETVAL = SvNVX (sv_next_tick) - now ();
1354	if (!SvROK (plt_sv) || SvTYPE (SvRV (plt_sv)) != SVt_PVAV)	1611	OUTPUT: RETVAL
1355	croak ("_quantise called with invalid agruments");
1356		1612
1357	plt_sv = SvRV (plt_sv);	1613	int tick_inhibit ()
1358	SV **plt = AvARRAY (plt_sv);	1614	CODE:
1359	int plt_count = AvFILL (plt_sv) + 1;	1615	RETVAL = tick_inhibit;
		1616	OUTPUT: RETVAL
1360		1617
1361	STRLEN len;	1618	void tick_inhibit_inc ()
1362	char *data = SvPVbyte (data_sv, len);	1619	CODE:
1363	char *dst = data;	1620	++tick_inhibit;
1364		1621
1365	while (len >= 3)	1622	void tick_inhibit_dec ()
1366	{	1623	CODE:
1367	for (SV **val_sv = plt + plt_count; val_sv-- > plt; )	1624	if (!--tick_inhibit)
		1625	if (tick_pending)
1368	{	1626	{
1369	char *val = SvPVX (*val_sv);	1627	ev_async_send (EV_DEFAULT, &tick_watcher);
1370		1628	coroapi::cede ();
1371	if (val [0] == data [0]
1372	&& val [1] == data [1]
1373	&& val [2] == data [2])
1374	{
1375	*dst++ = val [3];
1376	goto next;
1377	}
1378	}	1629	}
1379		1630
1380	croak ("_quantise: color not found in palette: #%02x%02x%02x, at offset %d %d",	1631	void one_tick ()
1381	(uint8_t)data [0], (uint8_t)data [1], (uint8_t)data [2],	1632	CODE:
1382	dst - SvPVX (data_sv), len);	1633	{
		1634	ev_now_update (EV_DEFAULT);
		1635	NOW = ev_now (EV_DEFAULT);
		1636	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1637	SvNV_set (sv_tick_start, NOW); SvNOK_only (sv_tick_start);
		1638	runtime = SvNVX (sv_runtime);
1383		1639
1384	next:	1640	one_tick ();
1385	data += 3;
1386	len -= 3;
1387	}
1388		1641
1389	SvCUR_set (data_sv, dst - SvPVX (data_sv));	1642	++server_tick;
		1643	SvUV_set (sv_server_tick, server_tick); SvIOK_only_UV (sv_server_tick);
		1644
		1645	ev_now_update (EV_DEFAULT);
		1646	NOW = ev_now (EV_DEFAULT);
		1647	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1648
		1649	runtime += TICK;
		1650	SvNV_set (sv_runtime, runtime); SvNOK_only (sv_runtime);
1390	}	1651	}
1391		1652
1392	NV floor (NV x)	1653	NV floor (NV x)
1393		1654
1394	NV ceil (NV x)	1655	NV ceil (NV x)
1395		1656
1396	NV rndm (...)	1657	NV rndm (...)
		1658	ALIAS:
		1659	rmg_rndm = 1
1397	CODE:	1660	CODE:
		1661	{
		1662	rand_gen &gen = ix ? rmg_rndm : rndm;
1398	switch (items)	1663	switch (items)
1399	{	1664	{
1400	case 0: RETVAL = rndm (); break;	1665	case 0: RETVAL = gen (); break;
1401	case 1: RETVAL = rndm (SvUV (ST (0))); break;	1666	case 1: RETVAL = gen (SvUV (ST (0))); break;
1402	case 2: RETVAL = rndm (SvIV (ST (0)), SvIV (ST (1))); break;	1667	case 2: RETVAL = gen (SvIV (ST (0)), SvIV (ST (1))); break;
1403	default: croak ("cf::rndm requires none, one or two parameters."); break;	1668	default: croak ("cf::rndm requires zero, one or two parameters."); break;
1404	}	1669	}
		1670	}
1405	OUTPUT:	1671	OUTPUT: RETVAL
		1672
		1673	NV clamp (NV value, NV min_value, NV max_value)
		1674	CODE:
		1675	RETVAL = clamp (value, min_value, max_value);
1406	RETVAL	1676	OUTPUT: RETVAL
1407		1677
1408	void server_tick ()	1678	NV lerp (NV value, NV min_in, NV max_in, NV min_out, NV max_out)
1409	CODE:	1679	CODE:
1410	runtime = SvNVx (sv_runtime);	1680	RETVAL = lerp (value, min_in, max_in, min_out, max_out);
1411	server_tick ();	1681	OUTPUT: RETVAL
1412		1682
1413	void	1683	const char *ordinal (int i)
		1684
		1685	void weaken (...)
		1686	PROTOTYPE: @
		1687	CODE:
		1688	while (items > 0)
		1689	sv_rvweaken (ST (--items));
		1690
		1691	void log_suspend ()
		1692
		1693	void log_resume ()
		1694
1414	log_backtrace (utf8_string msg)	1695	void log_backtrace (utf8_string msg)
1415		1696
1416	void
1417	LOG (int flags, utf8_string msg)	1697	void LOG (int flags, utf8_string msg)
1418	PROTOTYPE: $$	1698	PROTOTYPE: $$
1419	C_ARGS: flags, "%s", msg	1699	C_ARGS: flags, "%s", msg
1420		1700
1421	octet_string path_combine (octet_string base, octet_string path)	1701	octet_string path_combine (octet_string base, octet_string path)
1422	PROTOTYPE: $$	1702	PROTOTYPE: $$
1423		1703
1424	octet_string path_combine_and_normalize (octet_string base, octet_string path)	1704	octet_string path_combine_and_normalize (octet_string base, octet_string path)
1425	PROTOTYPE: $$	1705	PROTOTYPE: $$
1426
1427	const_octet_string
1428	get_maps_directory (octet_string path)
1429	PROTOTYPE: $
1430	ALIAS: maps_directory = 0
1431	CODE:
1432	RETVAL = create_pathname (path);
1433	OUTPUT: RETVAL
1434		1706
1435	void	1707	void
1436	sub_generation_inc ()	1708	sub_generation_inc ()
1437	CODE:	1709	CODE:
1438	PL_sub_generation++;	1710	PL_sub_generation++;
…		…
1463		1735
1464	void abort ()	1736	void abort ()
1465		1737
1466	void reset_signals ()	1738	void reset_signals ()
1467		1739
1468	void fork_abort (octet_string cause = "cf::fork_abort")	1740	void fork_abort (const_octet_string cause = "cf::fork_abort")
1469		1741
1470	void cleanup (octet_string cause, bool make_core = false)	1742	void cleanup (const_octet_string cause, bool make_core = false)
1471		1743
1472	void emergency_save ()	1744	void emergency_save ()
1473		1745
1474	void _exit (int status = EXIT_SUCCESS)	1746	void _exit (int status = EXIT_SUCCESS)
1475		1747
1476	UV sv_2watcher (SV *w)
1477	CODE:
1478	RETVAL = (UV)GEventAPI->sv_2watcher (w);
1479	OUTPUT:
1480	RETVAL
1481
1482	#if _POSIX_MEMLOCK	1748	#if _POSIX_MEMLOCK
1483		1749
1484	int mlockall (int flags = MCL_CURRENT | MCL_FUTURE)	1750	int mlockall (int flags = MCL_CURRENT | MCL_FUTURE)
		1751	INIT:
		1752	#if __GLIBC__
		1753	mallopt (M_TOP_PAD, 1024 * 1024);
		1754	mallopt (M_MMAP_THRESHOLD, 1024 * 1024);
		1755	mallopt (M_MMAP_MAX, 0); // likely bug-workaround, also frees memory
		1756	if (__GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ < 10))
		1757	mallopt (M_PERTURB, 0xee); // bug-workaround for linux glibc+mlockall+calloc
		1758	#endif
1485		1759
1486	int munlockall ()	1760	int munlockall ()
1487		1761
1488	#endif	1762	#endif
1489		1763
1490	int find_animation (utf8_string text)	1764	int
1491	PROTOTYPE: $	1765	malloc_trim (IV pad = 0)
		1766
		1767	void
		1768	mallinfo ()
		1769	PPCODE:
		1770	{
		1771	#if __GLIBC__
		1772	struct mallinfo mai = mallinfo ();
		1773	EXTEND (SP, 10*2);
		1774	PUSHs (sv_2mortal (newSVpv ("arena" , 0))); PUSHs (sv_2mortal (newSViv (mai.arena)));
		1775	PUSHs (sv_2mortal (newSVpv ("ordblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.ordblks)));
		1776	PUSHs (sv_2mortal (newSVpv ("smblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.smblks)));
		1777	PUSHs (sv_2mortal (newSVpv ("hblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblks)));
		1778	PUSHs (sv_2mortal (newSVpv ("hblkhd" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblkhd)));
		1779	PUSHs (sv_2mortal (newSVpv ("usmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.usmblks)));
		1780	PUSHs (sv_2mortal (newSVpv ("fsmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.fsmblks)));
		1781	PUSHs (sv_2mortal (newSVpv ("uordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.uordblks)));
		1782	PUSHs (sv_2mortal (newSVpv ("fordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.fordblks)));
		1783	PUSHs (sv_2mortal (newSVpv ("keepcost", 0))); PUSHs (sv_2mortal (newSViv (mai.keepcost)));
		1784	#endif
		1785	EXTEND (SP, 5*2);
		1786	PUSHs (sv_2mortal (newSVpv ("slice_alloc", 0))); PUSHs (sv_2mortal (newSVuv (slice_alloc)));
		1787	PUSHs (sv_2mortal (newSVpv ("shstr_alloc", 0))); PUSHs (sv_2mortal (newSVuv (shstr_alloc)));
		1788	PUSHs (sv_2mortal (newSVpv ("objects" , 0))); PUSHs (sv_2mortal (newSVuv (objects.size () * sizeof (object))));
		1789	PUSHs (sv_2mortal (newSVpv ("sv_count" , 0))); PUSHs (sv_2mortal (newSVuv (PL_sv_count)));
		1790	PUSHs (sv_2mortal (newSVpv ("sv_objcount", 0))); PUSHs (sv_2mortal (newSVuv (PL_sv_objcount)));
		1791	}
1492		1792
1493	int random_roll (int min, int max, object *op, int goodbad);	1793	int random_roll (int min, int max, object *op, int goodbad);
1494		1794
1495	const_utf8_string cost_string_from_value(uint64 cost, int approx = 0)	1795	const_utf8_string cost_string_from_value(uint64 cost, int approx = 0)
1496		1796
		1797	int exp_to_level (val64 exp)
		1798
		1799	val64 level_to_min_exp (int level)
		1800
		1801	const_utf8_string
		1802	spellpathnames (int idx)
		1803	CODE:
		1804	RETVAL = spellpathnames [idx];
		1805	OUTPUT: RETVAL
		1806
		1807	SV *
		1808	attacktype_name (int atnr)
		1809	CODE:
		1810	RETVAL = IN_RANGE_EXC (atnr, 0, NROFATTACKS)
		1811	? newSVpv (attacktype_name [atnr], 0)
		1812	: &PL_sv_undef;
		1813	OUTPUT: RETVAL
		1814
		1815	SV *
		1816	attacktype_desc (int atnr)
		1817	CODE:
		1818	RETVAL = IN_RANGE_EXC (atnr, 0, NROFATTACKS)
		1819	? newSVpv (attacktype_desc [atnr], 0)
		1820	: &PL_sv_undef;
		1821	OUTPUT: RETVAL
		1822
		1823	SV *
		1824	resist_plus (int atnr)
		1825	CODE:
		1826	RETVAL = IN_RANGE_EXC (atnr, 0, NROFATTACKS)
		1827	? newSVpv (resist_plus [atnr], 0)
		1828	: &PL_sv_undef;
		1829	OUTPUT: RETVAL
		1830
		1831	SV *
		1832	change_resist_msg (int atnr)
		1833	CODE:
		1834	RETVAL = IN_RANGE_EXC (atnr, 0, NROFATTACKS)
		1835	? newSVpv (change_resist_msg [atnr], 0)
		1836	: &PL_sv_undef;
		1837	OUTPUT: RETVAL
		1838
1497	int	1839	int
1498	exp_to_level (val64 exp)	1840	skill_flags (int idx)
1499	CODE:	1841	CODE:
1500	{	1842	if (idx < 0 || idx >= array_length (skill_flags))
1501	int i = 0;	1843	croak ("skill_flags: index out of bounds");
1502		1844	RETVAL = skill_flags [idx];
1503	RETVAL = settings.max_level;
1504
1505	for (i = 1; i <= settings.max_level; i++)
1506	{
1507	if (levels[i] > exp)
1508	{
1509	RETVAL = i - 1;
1510	break;
1511	}
1512	}
1513	}
1514	OUTPUT: RETVAL	1845	OUTPUT: RETVAL
		1846
		1847	UUID
		1848	uuid_cur ()
		1849	CODE:
		1850	RETVAL = UUID::cur;
		1851	OUTPUT: RETVAL
		1852
		1853	UUID
		1854	uuid_gen ()
		1855	CODE:
		1856	RETVAL = UUID::gen ();
		1857	OUTPUT: RETVAL
1515		1858
1516	val64	1859	val64
1517	level_to_min_exp (int level)	1860	uuid_seq (UUID uuid)
1518	CODE:	1861	CODE:
1519	if (level > settings.max_level)	1862	RETVAL = uuid.seq;
1520	RETVAL = levels[settings.max_level];	1863	OUTPUT: RETVAL
1521	else if (level < 1)	1864
		1865	UUID
		1866	uuid_str (val64 seq)
		1867	CODE:
1522	RETVAL = 0;	1868	RETVAL.seq = seq;
1523	else
1524	RETVAL = levels[level];
1525	OUTPUT: RETVAL	1869	OUTPUT: RETVAL
1526		1870
1527	SV *	1871	void
1528	resistance_to_string (int atnr)	1872	coin_names ()
1529	CODE:	1873	PPCODE:
1530	if (atnr >= 0 && atnr < NROFATTACKS)	1874	EXTEND (SP, NUM_COINS);
1531	RETVAL = newSVpv (resist_plus[atnr], 0);	1875	for (int i = 0; i < NUM_COINS; ++i)
1532	else	1876	PUSHs (sv_2mortal (newSVpv (coins [i], 0)));
1533	XSRETURN_UNDEF;	1877
1534	OUTPUT: RETVAL	1878	void
		1879	coin_archetypes ()
		1880	PPCODE:
		1881	EXTEND (SP, NUM_COINS);
		1882	for (int i = 0; i < NUM_COINS; ++i)
		1883	PUSHs (sv_2mortal (to_sv (archetype::find (coins [i]))));
1535		1884
1536	bool	1885	bool
1537	load_resource_file (octet_string filename)	1886	load_resource_file_ (octet_string filename)
		1887
		1888	void
		1889	fix_weight ()
		1890
		1891	utf8_string
		1892	expand_cfpod (int hintmode, int gender, const_utf8_string cfpod)
		1893	PPCODE:
		1894	XPUSHs (to_sv (player::expand_cfpod (hintmode, gender, cfpod)));
1538		1895
1539	MODULE = cf PACKAGE = cf::attachable	1896	MODULE = cf PACKAGE = cf::attachable
1540		1897
1541	int	1898	int
1542	valid (SV *obj)	1899	valid (SV *obj)
1543	CODE:	1900	CODE:
1544	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);	1901	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
1545	OUTPUT:	1902	OUTPUT: RETVAL
1546	RETVAL	1903
		1904	bool should_invoke (attachable *obj, int event)
		1905	CODE:
		1906	RETVAL = obj->should_invoke ((event_type)event);
		1907	OUTPUT: RETVAL
1547		1908
1548	void	1909	void
1549	debug_trace (attachable *obj, bool on = true)	1910	debug_trace (attachable *obj, bool on = true)
1550	CODE:	1911	CODE:
1551	obj->flags &= ~attachable::F_DEBUG_TRACE;	1912	obj->attachable_flags &= ~attachable::F_DEBUG_TRACE;
1552	if (on)	1913	if (on)
1553	obj->flags |= attachable::F_DEBUG_TRACE;	1914	obj->attachable_flags |= attachable::F_DEBUG_TRACE;
1554		1915
1555	int mortals_size ()	1916	int mortals_size ()
1556	CODE:	1917	CODE:
1557	RETVAL = attachable::mortals.size ();	1918	RETVAL = attachable::mortals.size ();
1558	OUTPUT: RETVAL	1919	OUTPUT: RETVAL
…		…
1560	#object *mortals (U32 index)	1921	#object *mortals (U32 index)
1561	# CODE:	1922	# CODE:
1562	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;	1923	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;
1563	# OUTPUT: RETVAL	1924	# OUTPUT: RETVAL
1564		1925
1565	INCLUDE: $PERL $srcdir/genacc attachable ../include/cfperl.h |	1926	INCLUDE: $PERL $srcdir/genacc attachable $srcdir/../include/util.h $srcdir/../include/cfperl.h |
1566		1927
1567	MODULE = cf PACKAGE = cf::global	1928	MODULE = cf PACKAGE = cf::global
1568		1929
1569	int invoke (SV *klass, int event, ...)	1930	int invoke (SV *klass, int event, ...)
1570	CODE:	1931	CODE:
…		…
1574	RETVAL = gbl_ev.invoke ((event_type)event, ARG_AV (av), DT_END);	1935	RETVAL = gbl_ev.invoke ((event_type)event, ARG_AV (av), DT_END);
1575	OUTPUT: RETVAL	1936	OUTPUT: RETVAL
1576		1937
1577	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_	1938	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
1578		1939
1579	INCLUDE: $PERL $srcdir/genacc object ../include/object.h |	1940	INCLUDE: $PERL $srcdir/genacc object $srcdir/../include/object.h |
1580		1941
1581	int invoke (object *op, int event, ...)	1942	int invoke (object *op, int event, ...)
1582	CODE:	1943	CODE:
1583	if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");	1944	if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");
1584	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	1945	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
1606	object *actives (U32 index)	1967	object *actives (U32 index)
1607	CODE:	1968	CODE:
1608	RETVAL = index < actives.size () ? actives [index] : 0;	1969	RETVAL = index < actives.size () ? actives [index] : 0;
1609	OUTPUT: RETVAL	1970	OUTPUT: RETVAL
1610		1971
		1972	int mortals_size ()
		1973	CODE:
		1974	RETVAL = attachable::mortals.size ();
		1975	OUTPUT: RETVAL
		1976
		1977	const_utf8_string slot_name (U32 slot)
		1978	ALIAS:
		1979	slot_name = 0
		1980	slot_use_name = 1
		1981	slot_nonuse_name = 2
		1982	CODE:
		1983	{
		1984	if (slot >= NUM_BODY_LOCATIONS)
		1985	croak ("body slot index out of range");
		1986
		1987	switch (ix)
		1988	{
		1989	case 0: RETVAL = body_locations[slot].name ; break;
		1990	case 1: RETVAL = body_locations[slot].use_name ; break;
		1991	case 2: RETVAL = body_locations[slot].nonuse_name; break;
		1992	}
		1993	}
		1994	OUTPUT: RETVAL
		1995
1611	# missing properties	1996	# missing properties
1612		1997
1613	object *head (object *op)	1998	object *head (object *op)
1614	PROTOTYPE: $	1999	PROTOTYPE: $
1615	CODE:	2000	CODE:
1616	RETVAL = op->head_ ();	2001	RETVAL = op->head_ ();
1617	OUTPUT: RETVAL
1618
1619	int is_head (object *op)
1620	PROTOTYPE: $
1621	CODE:
1622	RETVAL = op->head_ () == op;
1623	OUTPUT: RETVAL	2002	OUTPUT: RETVAL
1624		2003
1625	void	2004	void
1626	inv (object *obj)	2005	inv (object *obj)
1627	PROTOTYPE: $	2006	PROTOTYPE: $
1628	PPCODE:	2007	PPCODE:
1629	{	2008	{
1630	object *o;
1631	for (o = obj->inv; o; o = o->below)	2009	for (object *o = obj->inv; o; o = o->below)
1632	XPUSHs (sv_2mortal (to_sv (o)));	2010	XPUSHs (sv_2mortal (to_sv (o)));
1633	}	2011	}
1634		2012
1635	void	2013	void
1636	set_animation (object *op, int idx)	2014	set_animation (object *op, int idx)
…		…
1641	num_animations (object *op)	2019	num_animations (object *op)
1642	CODE:	2020	CODE:
1643	RETVAL = NUM_ANIMATIONS (op);	2021	RETVAL = NUM_ANIMATIONS (op);
1644	OUTPUT: RETVAL	2022	OUTPUT: RETVAL
1645		2023
		2024	int slot_info (object *op, UV slot, int value = 0)
		2025	ALIAS:
		2026	slot_used = 1
		2027	CODE:
		2028	{
		2029	if (slot >= NUM_BODY_LOCATIONS)
		2030	croak ("body slot index out of range");
		2031
		2032	RETVAL = ix ? op->slot[slot].used : op->slot[slot].info;
		2033
		2034	if (items > 2)
		2035	if (ix)
		2036	op->slot[slot].used = value;
		2037	else
		2038	op->slot[slot].info = value;
		2039	}
		2040	OUTPUT: RETVAL
		2041
1646	object *find_best_object_match (object *op, utf8_string match)	2042	object *find_best_object_match (object *op, utf8_string match)
1647		2043
1648	object *find_marked_object (object *op)
1649
1650	int need_identify (object *obj);
1651
1652	int apply_shop_mat (object *shop_mat, object *op);	2044	int apply_shop_mat (object *shop_mat, object *op);
1653		2045
1654	int move_player (object *op, int dir)
1655	CODE:
1656	RETVAL = move_player (op, dir);
1657	OUTPUT:
1658	RETVAL
1659
1660	int move (object *op, int dir, object *originator = op)	2046	int move (object *op, int dir, object *originator = op)
1661	CODE:	2047	CODE:
1662	RETVAL = move_ob (op, dir, originator);	2048	RETVAL = op->move (dir, originator);
1663	OUTPUT:	2049	OUTPUT: RETVAL
1664	RETVAL
1665
1666	void apply (object *applier, object *applied, int flags = 0)
1667	CODE:
1668	manual_apply (applied, applier, flags);
1669		2050
1670	void apply_below (object *op)	2051	void apply_below (object *op)
1671	CODE:	2052	CODE:
1672	player_apply_below (op);	2053	player_apply_below (op);
1673		2054
1674	int cast_heal (object *op, object *caster, object *spell, int dir = 0)	2055	int cast_heal (object *op, object *caster, object *spell, int dir = 0)
1675		2056
1676	object *cf_object_present_archname_inside (object *op, utf8_string whatstr)	2057	int casting_level (object *caster, object *spell)
1677
1678	int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)
1679
1680	int cf_object_change_map (object *op, int x, int y, maptile *map)
1681
1682	#//TODO
1683	object *clone_ (object *op, int recursive = 0)
1684	CODE:
1685	if (recursive)
1686	RETVAL = object_create_clone (op);
1687	else
1688	{
1689	RETVAL = object::create ();
1690	op->copy_to (RETVAL);
1691	}
1692	OUTPUT: RETVAL
1693		2058
1694	int pay_item (object *op, object *buyer)	2059	int pay_item (object *op, object *buyer)
1695	CODE:	2060	CODE:
1696	RETVAL = pay_for_item (op, buyer);	2061	RETVAL = pay_for_item (op, buyer);
1697	OUTPUT: RETVAL	2062	OUTPUT: RETVAL
…		…
1732		2097
1733	void drop (object *who, object *op)	2098	void drop (object *who, object *op)
1734		2099
1735	void pick_up (object *who, object *op)	2100	void pick_up (object *who, object *op)
1736		2101
1737	int cf_object_teleport (object *op, maptile *map, int x, int y)
1738
1739	void update_object (object *op, int action)	2102	void update_object (object *op, int action)
1740		2103
1741	object *cf_create_object_by_name (utf8_string name)
1742
1743	void change_exp (object *op, uint64 exp, utf8_string skill_name = 0, int flag = 0)	2104	void change_exp (object *op, uint64 exp, shstr_tmp skill_name = shstr_tmp (), int flag = 0)
1744		2105
1745	void player_lvl_adj (object *who, object *skill = 0)	2106	void player_lvl_adj (object *who, object *skill = 0)
1746		2107
1747	int kill_object (object *op, int dam = 0, object *hitter = 0, int type = AT_PHYSICAL)	2108	int kill_object (object *op, int dam = 0, object *hitter = 0, int type = AT_PHYSICAL)
1748		2109
1749	int calc_skill_exp (object *who, object *op, object *skill);	2110	int calc_skill_exp (object *who, object *op, object *skill)
1750		2111
1751	void push_button (object *op);	2112	void push_button (object *op, object *originator)
1752		2113
1753	void use_trigger (object *op);	2114	void use_trigger (object *op, object *originator)
1754		2115
1755	void add_button_link (object *button, maptile *map, int connected);	2116	void handle_apply_yield (object *op)
1756		2117
1757	void remove_button_link (object *op);	2118	int convert_item (object *item, object *converter)
1758		2119
		2120	void fix_generated_item (object *op, object *creator, int difficulty, int max_magic, int flags);
1759		2121
1760	MODULE = cf PACKAGE = cf::object PREFIX = cf_	2122	MODULE = cf PACKAGE = cf::object PREFIX = cf_
1761
1762	object *cf_insert_ob_in_ob (object *ob, object *where)
1763
1764	# no clean way to get an object from an archetype - stupid idiotic
1765	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.
1766		2123
1767	object *new (utf8_string archetype = 0)	2124	object *new (utf8_string archetype = 0)
1768	PROTOTYPE: ;$	2125	PROTOTYPE: ;$
1769	CODE:	2126	CODE:
1770	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();	2127	RETVAL = archetype
		2128	? archetype::get (archetype)
		2129	: object::create ();
1771	OUTPUT:	2130	OUTPUT: RETVAL
1772	RETVAL
1773		2131
		2132	object *generate (utf8_string arch, object *creator)
		2133	CODE:
		2134	object *obj = archetype::get (arch);
		2135	fix_generated_item (obj, creator, 0, 0, GT_MINIMAL);
		2136	RETVAL = obj;
		2137	OUTPUT: RETVAL
		2138
		2139	object *find_object (U32 tag)
		2140
		2141	object *find_object_uuid (UUID i)
		2142
		2143	# TODO: nuke
1774	object *insert_ob_in_map_at (object *ob, maptile *where, object_ornull *orig, int flag, int x, int y)	2144	object *insert_ob_in_map_at (object *ob, maptile *where, object_ornull *orig, int flag, int x, int y)
1775	PROTOTYPE: $$$$$$	2145	PROTOTYPE: $$$$$$
1776	CODE:	2146	CODE:
1777	{	2147	{
1778	int unused_type;	2148	RETVAL = insert_ob_in_map_at (ob, where, orig, flag, x, y);
1779	RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);
1780	}
1781		2149
1782	player *contr (object *op)	2150	if (RETVAL->destroyed ())
1783	CODE:
1784	RETVAL = op->contr;	2151	RETVAL = 0;
		2152	}
1785	OUTPUT: RETVAL	2153	OUTPUT: RETVAL
1786		2154
1787	const_utf8_string get_ob_key_value (object *op, utf8_string key)	2155	shstr
		2156	object::kv_get (shstr key)
		2157	CODE:
		2158	RETVAL = THIS->kv.get (key);
		2159	OUTPUT: RETVAL
1788		2160
1789	bool set_ob_key_value (object *op, utf8_string key, utf8_string value = 0, int add_key = 1)	2161	void
		2162	object::kv_del (shstr key)
		2163	CODE:
		2164	THIS->kv.del (key);
		2165
		2166	void
		2167	object::kv_set (shstr key, shstr value)
		2168	CODE:
		2169	THIS->kv.set (key, value);
1790		2170
1791	object *get_nearest_player (object *ob)	2171	object *get_nearest_player (object *ob)
1792	ALIAS: nearest_player = 0	2172	ALIAS: nearest_player = 0
1793	PREINIT:	2173	PREINIT:
1794	extern object *get_nearest_player (object *);	2174	extern object *get_nearest_player (object *);
…		…
1796	void rangevector (object *ob, object *other, int flags = 0)	2176	void rangevector (object *ob, object *other, int flags = 0)
1797	PROTOTYPE: $$;$	2177	PROTOTYPE: $$;$
1798	PPCODE:	2178	PPCODE:
1799	{	2179	{
1800	rv_vector rv;	2180	rv_vector rv;
		2181
1801	get_rangevector (ob, other, &rv, flags);	2182	get_rangevector (ob, other, &rv, flags);
		2183
1802	EXTEND (SP, 5);	2184	EXTEND (SP, 5);
1803	PUSHs (newSVuv (rv.distance));	2185	PUSHs (sv_2mortal (newSVuv (rv.distance)));
1804	PUSHs (newSViv (rv.distance_x));	2186	PUSHs (sv_2mortal (newSViv (rv.distance_x)));
1805	PUSHs (newSViv (rv.distance_y));	2187	PUSHs (sv_2mortal (newSViv (rv.distance_y)));
1806	PUSHs (newSViv (rv.direction));	2188	PUSHs (sv_2mortal (newSViv (rv.direction)));
1807	PUSHs (newSVcfapi (CFAPI_POBJECT, rv.part));	2189	PUSHs (sv_2mortal (to_sv (rv.part)));
1808	}	2190	}
1809		2191
1810	bool on_same_map_as (object *ob, object *other)	2192	bool on_same_map_as (object *ob, object *other)
1811	CODE:	2193	CODE:
1812	RETVAL = on_same_map (ob, other);	2194	RETVAL = on_same_map (ob, other);
…		…
1816	base_name (object *op, int plural = op->nrof > 1)	2198	base_name (object *op, int plural = op->nrof > 1)
1817	CODE:	2199	CODE:
1818	RETVAL = query_base_name (op, plural);	2200	RETVAL = query_base_name (op, plural);
1819	OUTPUT: RETVAL	2201	OUTPUT: RETVAL
1820		2202
1821	object *decrease_ob_nr (object *op, unsigned long i)	2203	# return the tail of an object, excluding itself
		2204	void
		2205	tail (object *op)
		2206	PPCODE:
		2207	while ((op = op->more))
		2208	XPUSHs (sv_2mortal (to_sv (op)));
1822		2209
1823	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_	2210	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_
1824		2211
1825	player *player (object *op)	2212	player *player (object *op)
1826	CODE:	2213	CODE:
1827	RETVAL = op->contr;	2214	RETVAL = op->contr;
1828	OUTPUT: RETVAL	2215	OUTPUT: RETVAL
1829		2216
1830	void check_score (object *op)	2217	bool move_player (object *op, int dir)
1831		2218
1832	void message (object *op, utf8_string txt, int flags = NDI_ORANGE | NDI_UNIQUE)	2219	void message (object *op, utf8_string txt, int flags = NDI_ORANGE | NDI_UNIQUE)
1833	CODE:	2220	CODE:
1834	new_draw_info (flags, 0, op, txt);	2221	new_draw_info (flags, 0, op, txt);
1835		2222
1836	object *cf_player_send_inventory (object *op)
1837
1838	octet_string cf_player_get_ip (object *op)
1839	ALIAS: ip = 0
1840
1841	object *cf_player_get_marked_item (object *op)
1842	ALIAS: marked_item = 0
1843
1844	void cf_player_set_marked_item (object *op, object *ob)
1845
1846	partylist *cf_player_get_party (object *op)
1847	ALIAS: party = 0
1848
1849	void cf_player_set_party (object *op, partylist *party)
1850
1851	void kill_player (object *op)	2223	void kill_player (object *op)
1852		2224
		2225	void esrv_send_item (object *pl, object *item)
		2226
1853	void esrv_update_item (object *op, int what, object *item)	2227	void esrv_update_item (object *pl, int what, object *item)
1854	C_ARGS: what, op, item	2228	C_ARGS: what, pl, item
1855		2229
1856	void clear_los (object *op)	2230	void esrv_del_item (object *pl, int tag)
		2231	C_ARGS: pl->contr, tag
1857		2232
1858	int command_summon (object *op, utf8_string params)	2233	int command_summon (object *op, utf8_string params)
1859		2234
1860	int command_arrest (object *op, utf8_string params)	2235	int command_arrest (object *op, utf8_string params)
1861		2236
1862		2237
1863	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_	2238	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
1864		2239
1865	INCLUDE: $PERL $srcdir/genacc player ../include/player.h |	2240	INCLUDE: $PERL $srcdir/genacc player $srcdir/../include/player.h |
1866		2241
1867	int invoke (player *pl, int event, ...)	2242	int invoke (player *pl, int event, ...)
1868	CODE:	2243	CODE:
1869	if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");	2244	if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");
1870	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	2245	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
1880	pl->ob->stats.hp = pl->ob->stats.maxhp;	2255	pl->ob->stats.hp = pl->ob->stats.maxhp;
1881	pl->ob->stats.sp = pl->ob->stats.maxsp;	2256	pl->ob->stats.sp = pl->ob->stats.maxsp;
1882	pl->ob->stats.grace = pl->ob->stats.maxgrace;	2257	pl->ob->stats.grace = pl->ob->stats.maxgrace;
1883	pl->orig_stats = pl->ob->stats;	2258	pl->orig_stats = pl->ob->stats;
1884		2259
1885	void cf_player_move (player *pl, int dir)	2260	# should only be temporary
		2261	void esrv_new_player (player *pl)
1886		2262
1887	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);	2263	#d# TODO: replace by blocked_los accessor, fix code using this
1888
1889	bool	2264	bool
1890	cell_visible (player *pl, int dx, int dy)	2265	cell_visible (player *pl, int dx, int dy)
1891	CODE:	2266	CODE:
1892	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2	2267	RETVAL = pl->blocked_los (dx, dy) != LOS_BLOCKED;
1893	&& !pl->blocked_los [dx + pl->ns->mapx / 2][dy + pl->ns->mapy / 2];
1894	OUTPUT:	2268	OUTPUT: RETVAL
1895	RETVAL
1896		2269
1897	void	2270	void
1898	send (player *pl, SV *packet)	2271	send (player *pl, SV *packet)
1899	CODE:	2272	CODE:
1900	{	2273	{
1901	STRLEN len;	2274	STRLEN len;
1902	char *buf = SvPVbyte (packet, len);	2275	char *buf = SvPVbyte (packet, len);
1903		2276
		2277	if (len > MAXSOCKBUF)
		2278	pl->failmsg ("[packet too long for client]");
1904	if (pl->ns)	2279	else if (pl->ns)
1905	pl->ns->send_packet (buf, len);	2280	pl->ns->send_packet (buf, len);
1906	}	2281	}
1907
1908	int
1909	listening (player *pl, int new_value = -1)
1910	CODE:
1911	RETVAL = pl->listening;
1912	if (new_value >= 0)
1913	pl->listening = new_value;
1914	OUTPUT:
1915	RETVAL
1916		2282
1917	void savebed (player *pl, SV *map_path = 0, SV *x = 0, SV *y = 0)	2283	void savebed (player *pl, SV *map_path = 0, SV *x = 0, SV *y = 0)
1918	PROTOTYPE: $;$$$	2284	PROTOTYPE: $;$$$
1919	PPCODE:	2285	PPCODE:
1920	if (GIMME_V != G_VOID)	2286	if (GIMME_V != G_VOID)
…		…
1945	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);	2311	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);
1946	OUTPUT: RETVAL	2312	OUTPUT: RETVAL
1947		2313
1948	SV *registry (maptile *map)	2314	SV *registry (maptile *map)
1949		2315
		2316	void
		2317	find_tagged_objects (maptile *map, utf8_string tag = 0)
		2318	PPCODE:
		2319	{
		2320	if (!map->spaces)
		2321	XSRETURN_EMPTY;
		2322
		2323	if (tag)
		2324	{
		2325	shstr_cmp tag_ (tag);
		2326
		2327	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2328	for (object *op = ms->bot; op; op = op->above)
		2329	if (op->tag == tag_)
		2330	XPUSHs (sv_2mortal (to_sv (op)));
		2331	}
		2332	else
		2333	{
		2334	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2335	for (object *op = ms->bot; op; op = op->above)
		2336	if (op->tag)
		2337	XPUSHs (sv_2mortal (to_sv (op)));
		2338	}
		2339	}
		2340
1950	INCLUDE: $PERL $srcdir/genacc maptile ../include/map.h |	2341	INCLUDE: $PERL $srcdir/genacc maptile $srcdir/../include/map.h |
		2342
		2343	void
		2344	adjust_daylight ()
		2345	CODE:
		2346	maptile::adjust_daylight ();
		2347
		2348	int
		2349	outdoor_darkness (int darkness = 0)
		2350	CODE:
		2351	RETVAL = maptile::outdoor_darkness;
		2352	if (items)
		2353	maptile::outdoor_darkness = darkness;
		2354	OUTPUT: RETVAL
1951		2355
1952	void	2356	void
1953	maptile::instantiate ()	2357	maptile::instantiate ()
1954		2358
1955	maptile *new ()	2359	maptile *new ()
1956	PROTOTYPE:	2360	PROTOTYPE:
1957	CODE:	2361	CODE:
1958	RETVAL = new maptile;	2362	RETVAL = new maptile;
1959	OUTPUT:	2363	OUTPUT: RETVAL
1960	RETVAL
1961		2364
1962	void	2365	void
1963	maptile::players ()	2366	maptile::players ()
1964	PPCODE:	2367	PPCODE:
1965	if (GIMME_V == G_SCALAR)	2368	if (GIMME_V == G_SCALAR)
…		…
1971	if (pl->ob && pl->ob->map == THIS)	2374	if (pl->ob && pl->ob->map == THIS)
1972	PUSHs (sv_2mortal (to_sv (pl->ob)));	2375	PUSHs (sv_2mortal (to_sv (pl->ob)));
1973	}	2376	}
1974		2377
1975	void	2378	void
		2379	maptile::gen_quadmap (int x, int y, int z)
		2380	CODE:
		2381	gen_quadmap (THIS, x * 50, y * 50, z);
		2382
		2383	void
1976	maptile::add_underlay (SV *data, int offset, int stride, SV *palette)	2384	maptile::add_underlay (SV *data, int offset, int stride, SV *palette)
1977	CODE:	2385	CODE:
1978	{	2386	{
1979	if (!SvROK (palette) || SvTYPE (SvRV (palette)) != SVt_PVAV)	2387	if (!SvROK (palette) || SvTYPE (SvRV (palette)) != SVt_PVAV)
1980	croak ("maptile::add_underlay: palette must be arrayref");	2388	croak ("maptile::add_underlay: palette must be arrayref");
1981		2389
1982	palette = SvRV (palette);	2390	palette = SvRV (palette);
1983		2391
1984	STRLEN idxlen;	2392	STRLEN idxlen;
1985	const uint8_t *idx = (const uint8_t *)SvPVbyte (data, idxlen);	2393	const uint8 *idx = (const uint8 *)SvPVbyte (data, idxlen);
1986		2394
1987	for (int x = 0; x < THIS->width; ++x)	2395	for (int x = 0; x < THIS->width; ++x)
1988	for (int y = 0; y < THIS->height; ++y)	2396	for (int y = 0; y < THIS->height; ++y)
1989	{	2397	{
1990	for (object *op = THIS->at (x, y).bot; op; op = op->above)	2398	for (object *op = THIS->at (x, y).bot; op; op = op->above)
1991	if (op->flag [FLAG_IS_FLOOR])	2399	if (op->flag [FLAG_IS_FLOOR])
1992	goto skip_space;	2400	goto skip;
1993		2401
1994	{	2402	{
1995	int offs = offset + y * stride + x;	2403	int offs = offset + y * stride + x;
		2404
1996	if (IN_RANGE_EXC (offs, 0, idxlen))	2405	if (IN_RANGE_EXC (offs, 0, idxlen))
1997	{	2406	{
1998	if (SV **elem = av_fetch ((AV *)palette, idx [offs], 0))	2407	if (SV **elem = av_fetch ((AV *)palette, idx [offs], 0))
1999	{	2408	{
2000	object *ob = get_archetype (SvPVutf8_nolen (*elem));	2409	object *ob = archetype::get (cfSvPVutf8_nolen (*elem));
2001	ob->flag [FLAG_NO_MAP_SAVE] = true;	2410	ob->flag [FLAG_NO_MAP_SAVE] = true;
2002	THIS->insert (ob, x, y, 0, INS_ABOVE_FLOOR_ONLY);	2411	THIS->insert (ob, x, y, 0, INS_ABOVE_FLOOR_ONLY);
2003		2412
2004	if (ob->randomitems)	2413	if (ob->randomitems && !ob->above)
2005	{	2414	{
2006	if (!ob->above)
2007	{
2008	ob->create_treasure (ob->randomitems);	2415	ob->create_treasure (ob->randomitems);
2009		2416
2010	for (object *op = ob->above; op; op = op->above)	2417	for (object *op = ob->above; op; op = op->above)
2011	op->flag [FLAG_NO_MAP_SAVE] = true;	2418	op->flag [FLAG_NO_MAP_SAVE] = true;
2012	}	2419	// TODO: if this is a pickable object, then the item
2013		2420	// will at a bit weird - saving inside the player
2014	ob->randomitems = 0;	2421	// will clear the flag, but when the player drops
		2422	// it without logging out, it keeps the flag.
		2423	// nobody has reported this, but this can be rather
		2424	// annoying on persistent maps.
2015	}	2425	}
2016	}	2426	}
2017	}	2427	}
2018	}	2428	}
2019
2020	skip_space: ;	2429	skip: ;
2021	}	2430	}
2022	}	2431	}
2023		2432
2024	void	2433	void
2025	maptile::set_regiondata (SV *data, int offset, int stride, SV *palette)	2434	maptile::set_regiondata (SV *data, int offset, int stride, SV *palette)
…		…
2029	croak ("maptile::set_regiondata: palette must be arrayref");	2438	croak ("maptile::set_regiondata: palette must be arrayref");
2030		2439
2031	palette = SvRV (palette);	2440	palette = SvRV (palette);
2032		2441
2033	STRLEN idxlen;	2442	STRLEN idxlen;
2034	const uint8_t *idx = (const uint8_t *)SvPVbyte (data, idxlen);	2443	const uint8 *idx = (const uint8 *)SvPVbyte (data, idxlen);
2035		2444
2036	region **regionmap = (region **)malloc (	2445	region_ptr *regionmap = new region_ptr [av_len ((AV *)palette) + 1];
2037	(av_len ((AV *)palette) + 1) * sizeof (region *));
2038	uint8_t *regions = salloc<uint8_t> (THIS->size ());	2446	uint8 *regions = salloc<uint8_t> (THIS->size ());
2039		2447
2040	for (int i = av_len ((AV *)palette) + 1; i--; )	2448	for (int i = av_len ((AV *)palette) + 1; i--; )
2041	regionmap [i] = region::find (	2449	regionmap [i] = region::find (cfSvPVutf8_nolen (*av_fetch ((AV *)palette, i, 1)));
2042	SvPVutf8_nolen (*av_fetch ((AV *)palette, i, 1)));
2043		2450
2044	for (int y = 0; y < THIS->height; ++y)	2451	for (int y = 0; y < THIS->height; ++y)
2045	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);	2452	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);
2046		2453
2047	sfree (THIS->regions, THIS->size ());	2454	sfree (THIS->regions, THIS->size ());
2048	free (THIS->regionmap);	2455	delete [] THIS->regionmap;
2049		2456
2050	THIS->regions = regions;	2457	THIS->regions = regions;
2051	THIS->regionmap = regionmap;	2458	THIS->regionmap = regionmap;
2052	}	2459	}
2053		2460
2054	void	2461	void
2055	maptile::create_region_treasure ()	2462	maptile::create_region_treasure ()
2056	CODE:	2463	CODE:
2057	{
2058	object *op = object::create ();
2059	op->type = FLOOR;
2060	op->map = THIS;
2061
2062	for (int x = 0; x < THIS->width; ++x)	2464	for (int x = 0; x < THIS->width; ++x)
2063	for (int y = 0; y < THIS->height; ++y)	2465	for (int y = 0; y < THIS->height; ++y)
2064	{	2466	{
2065	region *rgn = THIS->region (x, y);	2467	region *rgn = THIS->region (x, y);
2066		2468
2067	//fprintf (stderr, "%d,%d %f %p\n", x, y, rgn->treasure_density,rgn->treasure);//D	2469	if (object *op = THIS->at (x, y).top)
2068	if (rgn->treasure && rndm () < rgn->treasure_density)	2470	if (rgn->treasure && rndm () < rgn->treasure_density)
2069	{
2070	op->x = x;
2071	op->y = y;
2072	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);	2471	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);
2073	}
2074	}	2472	}
2075		2473
2076	op->destroy ();
2077	}
2078
2079	void play_sound_map (maptile *map, int x, int y, int sound_num)
2080
2081	int out_of_map (maptile *map, int x, int y)	2474	int out_of_map (maptile *map, int x, int y)
2082		2475
2083	void	2476	void
2084	trigger (maptile *map, long connection, bool state = true)	2477	find_link (maptile *map, shstr_tmp connection)
		2478	PPCODE:
		2479	if (oblinkpt *obp = map->find_link (connection))
		2480	for (objectlink *ol = obp->link; ol; ol = ol->next)
		2481	XPUSHs (sv_2mortal (to_sv ((object *)ol->ob)));
		2482
		2483	void
		2484	xy_normalise (maptile *map, int x, int y, int dir = 0)
		2485	PPCODE:
		2486	{
		2487	mapxy pos (map, x, y);
		2488	if (!pos.move (dir).normalise ())
		2489	XSRETURN_EMPTY;
		2490
		2491	EXTEND (SP, 3);
		2492	PUSHs (sv_2mortal (to_sv (pos.m)));
		2493	PUSHs (sv_2mortal (to_sv (pos.x)));
		2494	PUSHs (sv_2mortal (to_sv (pos.y)));
		2495	}
		2496
		2497	mapspace *
		2498	ms (maptile *map, unsigned int x, unsigned int y, int dir = 0)
		2499	PROTOTYPE: $$$;$
2085	CODE:	2500	CODE:
2086	activate_connection (map, connection, state);
2087
2088	void
2089	get_connection (maptile *map, long connection)
2090	PPCODE:
2091	oblinkpt *obp = get_connection_links (map, connection);
2092	if (obp)
2093	for (objectlink *ol = obp->link; ol; ol = ol->next)
2094	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, (object *)ol->ob)));
2095
2096	object *cf_map_insert_object_there (maptile *where, object *op, object *originator, int flags)
2097
2098	object *cf_map_insert_object (maptile *where, object* op, int x, int y)
2099
2100	object* cf_map_present_arch_by_name (maptile *map, const char* str, int nx, int ny)
2101	C_ARGS: str, map, nx, ny
2102
2103	void
2104	get_map_flags (maptile *map, int x, int y)
2105	PPCODE:
2106	{	2501	{
2107	maptile *nmap = 0;	2502	mapxy pos (map, x, y);
2108	I16 nx = 0, ny = 0;	2503	if (!pos.move (dir).normalise ())
2109	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);	2504	XSRETURN_UNDEF;
2110		2505
2111	EXTEND (SP, 4);	2506	RETVAL = &*pos;
2112	PUSHs (sv_2mortal (newSViv (flags)));
2113
2114	if (GIMME_V == G_ARRAY)
2115	{
2116	PUSHs (sv_2mortal (newSVcfapi (CFAPI_PMAP, nmap)));
2117	PUSHs (sv_2mortal (newSViv (nx)));
2118	PUSHs (sv_2mortal (newSViv (ny)));
2119	}
2120	}	2507	}
		2508	OUTPUT: RETVAL
2121		2509
2122	void	2510	void
2123	at (maptile *map, unsigned int x, unsigned int y)	2511	at (maptile *map, unsigned int x, unsigned int y, int dir = 0)
2124	PROTOTYPE: $$$	2512	PROTOTYPE: $$$;$
2125	PPCODE:	2513	PPCODE:
2126	{	2514	mapxy pos (map, x, y);
2127	object *o;	2515	if (pos.move (dir).normalise ())
2128	maptile *nmap = 0;	2516	for (object *o = pos->bot; o; o = o->above)
2129	I16 nx, ny;	2517	XPUSHs (sv_2mortal (to_sv (o)));
2130
2131	get_map_flags (map, &nmap, x, y, &nx, &ny);
2132
2133	if (nmap)
2134	for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)
2135	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));
2136	}
2137		2518
2138	SV *	2519	SV *
2139	bot_at (maptile *obj, unsigned int x, unsigned int y)	2520	bot_at (maptile *map, unsigned int x, unsigned int y, int dir = 0)
2140	PROTOTYPE: $$$	2521	PROTOTYPE: $$$;$
2141	ALIAS:	2522	ALIAS:
2142	top_at = 1	2523	top_at = 1
2143	flags_at = 2	2524	flags_at = 2
2144	light_at = 3	2525	light_at = 3
2145	move_block_at = 4	2526	move_block_at = 4
2146	move_slow_at = 5	2527	move_slow_at = 5
2147	move_on_at = 6	2528	move_on_at = 6
2148	move_off_at = 7	2529	move_off_at = 7
2149	INIT:
2150	if (x >= obj->width || y >= obj->height) XSRETURN_UNDEF;
2151	CODE:	2530	CODE:
		2531	{
		2532	mapxy pos (map, x, y);
		2533	if (!pos.move (dir).normalise ())
		2534	XSRETURN_UNDEF;
		2535
		2536	mapspace &ms = *pos;
		2537
		2538	ms.update ();
		2539
2152	switch (ix)	2540	switch (ix)
2153	{	2541	{
2154	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;	2542	case 0: RETVAL = to_sv (ms.bot ); break;
2155	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;	2543	case 1: RETVAL = to_sv (ms.top ); break;
2156	case 2: RETVAL = newSVuv ( GET_MAP_FLAGS (obj, x, y)); break;	2544	case 2: RETVAL = newSVuv (ms.flags_ ); break;
2157	case 3: RETVAL = newSViv ( GET_MAP_LIGHT (obj, x, y)); break;	2545	case 3: RETVAL = newSViv (ms.light ); break;
2158	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;	2546	case 4: RETVAL = newSVuv (ms.move_block); break;
2159	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;	2547	case 5: RETVAL = newSVuv (ms.move_slow ); break;
2160	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;	2548	case 6: RETVAL = newSVuv (ms.move_on ); break;
2161	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;	2549	case 7: RETVAL = newSVuv (ms.move_off ); break;
2162	}	2550	}
		2551	}
2163	OUTPUT: RETVAL	2552	OUTPUT: RETVAL
2164
2165	void fix_walls (maptile *map, int x, int y)
2166
2167	void fix_walls_around (maptile *map, int x, int y)
2168		2553
2169	# worst xs function of my life	2554	# worst xs function of my life
2170	bool	2555	bool
2171	_create_random_map (\	2556	_create_random_map (maptile *self, SV *options)
2172	maptile *self,\
2173	utf8_string wallstyle,\
2174	utf8_string wall_name,\
2175	utf8_string floorstyle,\
2176	utf8_string monsterstyle,\
2177	utf8_string treasurestyle,\
2178	utf8_string layoutstyle,\
2179	utf8_string doorstyle,\
2180	utf8_string decorstyle,\
2181	utf8_string origin_map,\
2182	utf8_string final_map,\
2183	utf8_string exitstyle,\
2184	utf8_string this_map,\
2185	utf8_string exit_on_final_map,\
2186	int xsize,\
2187	int ysize,\
2188	int expand2x,\
2189	int layoutoptions1,\
2190	int layoutoptions2,\
2191	int layoutoptions3,\
2192	int symmetry,\
2193	int difficulty,\
2194	int difficulty_given,\
2195	float difficulty_increase,\
2196	int dungeon_level,\
2197	int dungeon_depth,\
2198	int decoroptions,\
2199	int orientation,\
2200	int origin_y,\
2201	int origin_x,\
2202	U32 random_seed,\
2203	val64 total_map_hp,\
2204	int map_layout_style,\
2205	int treasureoptions,\
2206	int symmetry_used,\
2207	region *region,\
2208	utf8_string custom\
2209	)
2210	CODE:	2557	CODE:
2211	{	2558	{
2212	random_map_params rmp;	2559	random_map_params rmp ((HV *)SvRV (options));
2213
2214	assign (rmp.wallstyle , wallstyle);
2215	assign (rmp.wall_name , wall_name);
2216	assign (rmp.floorstyle , floorstyle);
2217	assign (rmp.monsterstyle , monsterstyle);
2218	assign (rmp.treasurestyle , treasurestyle);
2219	assign (rmp.layoutstyle , layoutstyle);
2220	assign (rmp.doorstyle , doorstyle);
2221	assign (rmp.decorstyle , decorstyle);
2222	assign (rmp.exitstyle , exitstyle);
2223	assign (rmp.exit_on_final_map, exit_on_final_map);
2224
2225	rmp.origin_map = origin_map;
2226	rmp.final_map = final_map;
2227	rmp.this_map = this_map;
2228	rmp.xsize = xsize;
2229	rmp.ysize = ysize;
2230	rmp.expand2x = expand2x;
2231	rmp.layoutoptions1 = layoutoptions1;
2232	rmp.layoutoptions2 = layoutoptions2;
2233	rmp.layoutoptions3 = layoutoptions3;
2234	rmp.symmetry = symmetry;
2235	rmp.difficulty = difficulty;
2236	rmp.difficulty_given = difficulty_given;
2237	rmp.difficulty_increase = difficulty_increase;
2238	rmp.dungeon_level = dungeon_level;
2239	rmp.dungeon_depth = dungeon_depth;
2240	rmp.decoroptions = decoroptions;
2241	rmp.orientation = orientation;
2242	rmp.origin_y = origin_y;
2243	rmp.origin_x = origin_x;
2244	rmp.random_seed = random_seed;
2245	rmp.total_map_hp = total_map_hp;
2246	rmp.map_layout_style = map_layout_style;
2247	rmp.treasureoptions = treasureoptions;
2248	rmp.symmetry_used = symmetry_used;
2249	rmp.region = region;
2250	rmp.custom = custom;
2251
2252	RETVAL = self->generate_random_map (&rmp);	2560	RETVAL = self->generate_random_map (&rmp);
2253	}	2561	}
2254	OUTPUT:	2562	OUTPUT: RETVAL
2255	RETVAL	2563
		2564	MODULE = cf PACKAGE = cf::mapspace
		2565
		2566	INCLUDE: $PERL $srcdir/genacc mapspace $srcdir/../include/map.h |
2256		2567
2257	MODULE = cf PACKAGE = cf::arch	2568	MODULE = cf PACKAGE = cf::arch
2258		2569
2259	archetype *find (utf8_string name)	2570	int archetypes_size ()
		2571	CODE:
		2572	RETVAL = archetypes.size ();
		2573	OUTPUT: RETVAL
		2574
		2575	archetype *archetypes (U32 index)
		2576	CODE:
		2577	RETVAL = index < archetypes.size () ? archetypes [index] : 0;
		2578	OUTPUT: RETVAL
		2579
		2580	int skillvec_size ()
		2581	CODE:
		2582	RETVAL = skillvec.size ();
		2583	OUTPUT: RETVAL
		2584
		2585	archetype *skillvec (U32 index)
		2586	CODE:
		2587	RETVAL = index < skillvec.size () ? (archetype *)(object *)skillvec [index] : 0;
		2588	OUTPUT: RETVAL
		2589
		2590	void
		2591	find_by_type (int type)
2260	CODE:	2592	PPCODE:
2261	RETVAL = archetype::find (name);	2593	for_all_archetypes (arch)
2262	OUTPUT:	2594	if (arch->type == type)
2263	RETVAL	2595	XPUSHs (sv_2mortal (to_sv (arch)));
2264		2596
2265	archetype *first()
2266	PROTOTYPE:
2267	CODE:
2268	RETVAL = first_archetype;
2269	OUTPUT: RETVAL
2270
2271	INCLUDE: $PERL $srcdir/genacc archetype ../include/object.h |	2597	INCLUDE: $PERL $srcdir/genacc archetype $srcdir/../include/object.h |
2272		2598
2273	MODULE = cf PACKAGE = cf::party	2599	MODULE = cf PACKAGE = cf::party
2274		2600
2275	partylist *first ()	2601	partylist *first ()
2276	PROTOTYPE:	2602	PROTOTYPE:
2277	CODE:	2603	CODE:
2278	RETVAL = get_firstparty ();	2604	RETVAL = get_firstparty ();
2279	OUTPUT: RETVAL	2605	OUTPUT: RETVAL
2280		2606
2281	INCLUDE: $PERL $srcdir/genacc partylist ../include/player.h |	2607	INCLUDE: $PERL $srcdir/genacc partylist $srcdir/../include/player.h |
2282		2608
2283	MODULE = cf PACKAGE = cf::region	2609	MODULE = cf PACKAGE = cf::region
2284		2610
2285	void	2611	void
2286	list ()	2612	list ()
2287	PPCODE:	2613	PPCODE:
2288	for_all_regions (rgn)	2614	for_all_regions (rgn)
2289	XPUSHs (sv_2mortal (to_sv (rgn)));	2615	XPUSHs (sv_2mortal (to_sv (rgn)));
2290		2616
2291	region *find (utf8_string name)
2292	PROTOTYPE: $
2293	CODE:
2294	RETVAL = region::find (name);
2295	OUTPUT: RETVAL
2296
2297	region *find_fuzzy (utf8_string name)
2298	PROTOTYPE: $
2299	CODE:
2300	RETVAL = region::find_fuzzy (name);
2301	OUTPUT: RETVAL
2302
2303	int specificity (region *rgn)	2617	int specificity (region *rgn)
2304	CODE:	2618	CODE:
2305	RETVAL = 0;	2619	RETVAL = 0;
2306	while (rgn = rgn->parent)	2620	while (rgn = rgn->parent)
2307	RETVAL++;	2621	RETVAL++;
2308	OUTPUT: RETVAL	2622	OUTPUT: RETVAL
2309		2623
2310	INCLUDE: $PERL $srcdir/genacc region ../include/region.h |	2624	INCLUDE: $PERL $srcdir/genacc region $srcdir/../include/region.h |
2311		2625
2312	MODULE = cf PACKAGE = cf::living	2626	MODULE = cf PACKAGE = cf::living
2313		2627
2314	INCLUDE: $PERL $srcdir/genacc living ../include/living.h |	2628	INCLUDE: $PERL $srcdir/genacc living $srcdir/../include/living.h |
2315		2629
2316	MODULE = cf PACKAGE = cf::settings	2630	MODULE = cf PACKAGE = cf::settings
2317		2631
2318	INCLUDE: $PERL $srcdir/genacc Settings ../include/global.h |	2632	INCLUDE: $PERL $srcdir/genacc Settings $srcdir/../include/global.h |
2319		2633
2320	MODULE = cf PACKAGE = cf::client	2634	MODULE = cf PACKAGE = cf::client
2321		2635
2322	INCLUDE: $PERL $srcdir/genacc client ../include/client.h |	2636	INCLUDE: $PERL $srcdir/genacc client $srcdir/../include/client.h |
2323		2637
2324	int invoke (client *ns, int event, ...)	2638	int invoke (client *ns, int event, ...)
2325	CODE:	2639	CODE:
2326	if (KLASS_OF (event) != KLASS_CLIENT) croak ("event class must be CLIENT");	2640	if (KLASS_OF (event) != KLASS_CLIENT) croak ("event class must be CLIENT");
2327	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	2641	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
2336	PPCODE:	2650	PPCODE:
2337	EXTEND (SP, clients.size ());	2651	EXTEND (SP, clients.size ());
2338	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)	2652	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
2339	PUSHs (sv_2mortal (to_sv (*i)));	2653	PUSHs (sv_2mortal (to_sv (*i)));
2340		2654
		2655	STRLEN
		2656	client::inbuf_append (SV *data)
		2657	CODE:
		2658	{
		2659	STRLEN len;
		2660	char *ptr = SvPVbyte (data, len);
		2661
		2662	min_it (len, sizeof (THIS->inbuf) - THIS->inbuf_len);
		2663	memcpy (THIS->inbuf + THIS->inbuf_len, ptr, len);
		2664	THIS->inbuf_len += len;
		2665
		2666	THIS->inbuf_handle ();
		2667
		2668	RETVAL = len;
		2669	}
		2670	OUTPUT: RETVAL
		2671
2341	void	2672	void
2342	client::send_packet (SV *packet)	2673	client::send_packet (SV *packet)
2343	CODE:	2674	CODE:
2344	{	2675	{
2345	STRLEN len;	2676	STRLEN len;
2346	char *buf = SvPVbyte (packet, len);	2677	char *buf = SvPVbyte (packet, len);
2347		2678
		2679	if (len > MAXSOCKBUF)
		2680	{
		2681	// ugly
		2682	if (THIS->pl)
		2683	THIS->pl->failmsg ("[packet too long for client]");
		2684	}
		2685	else
2348	THIS->send_packet (buf, len);	2686	THIS->send_packet (buf, len);
2349	}	2687	}
		2688
		2689	faceidx
		2690	client::need_face (utf8_string name, int pri = 0)
		2691	CODE:
		2692	RETVAL = face_find (name, 0);
		2693	if (RETVAL)
		2694	{
		2695	THIS->send_face (RETVAL, pri);
		2696	THIS->flush_fx ();
		2697	}
		2698	OUTPUT: RETVAL
		2699
		2700	int
		2701	client::fx_want (int idx, int value = -1)
		2702	CODE:
		2703	if (0 < idx && idx < FT_NUM)
		2704	{
		2705	RETVAL = THIS->fx_want [idx];
		2706	if (items > 2)
		2707	THIS->fx_want [idx] = value;
		2708	}
		2709	else
		2710	RETVAL = 0;
		2711	OUTPUT: RETVAL
		2712
		2713	MODULE = cf PACKAGE = cf::sound PREFIX = sound_
		2714
		2715	faceidx sound_find (utf8_string name)
		2716
		2717	void sound_set (utf8_string str, faceidx face)
		2718
		2719	# dire hack
		2720	void old_sound_index (int idx, faceidx face)
		2721	CODE:
		2722	extern faceidx old_sound_index [SOUND_CAST_SPELL_0];
		2723	old_sound_index [idx] = face;
2350		2724
2351	MODULE = cf PACKAGE = cf::face PREFIX = face_	2725	MODULE = cf PACKAGE = cf::face PREFIX = face_
2352		2726
2353	#INCLUDE: $PERL $srcdir/genacc faceset ../include/face.h |	2727	#INCLUDE: $PERL $srcdir/genacc faceset $srcdir/../include/face.h |
2354		2728
2355	faceidx face_find (utf8_string name, faceidx defidx = 0)	2729	faceidx face_find (utf8_string name, faceidx defidx = 0)
2356		2730
2357	faceidx alloc (utf8_string name)	2731	faceidx alloc (utf8_string name)
2358	CODE:	2732	CODE:
2359	{	2733	{
2360	do	2734	RETVAL = face_alloc ();
2361	{
2362	RETVAL = faces.size ();
2363	faces.resize (RETVAL + 1);
2364	}
2365	while (!RETVAL); // crude way to leave index 0
2366		2735
2367	faces [RETVAL].name = name;	2736	faces [RETVAL].name = name;
2368	facehash.insert (std::make_pair (faces [RETVAL].name, RETVAL));	2737	facehash.insert (std::make_pair (faces [RETVAL].name, RETVAL));
2369		2738
2370	if (!strcmp (name, BLANK_FACE_NAME)) blank_face = RETVAL;	2739	if (!strcmp (name, BLANK_FACE_NAME )) blank_face = RETVAL;
2371	if (!strcmp (name, EMPTY_FACE_NAME)) empty_face = RETVAL;	2740	if (!strcmp (name, EMPTY_FACE_NAME )) empty_face = RETVAL;
		2741	if (!strcmp (name, MAGICMOUTH_FACE_NAME)) magicmouth_face = RETVAL;
2372	}	2742	}
2373	OUTPUT: RETVAL	2743	OUTPUT: RETVAL
2374		2744
2375	void set (faceidx idx, int visibility, int magicmap)	2745	faceidx faces_size ()
2376	CODE:	2746	CODE:
2377	faceinfo *f = face_info (idx);	2747	RETVAL = faces.size ();
2378	assert (f);	2748	OUTPUT: RETVAL
2379	f->visibility = visibility;
2380	f->magicmap = magicmap;
2381		2749
2382	void set_smooth (faceidx idx, faceidx smooth, int smoothlevel)	2750	void set_type (faceidx idx, int value)
		2751	ALIAS:
		2752	set_type = 0
		2753	set_visibility = 1
		2754	set_magicmap = 2
		2755	set_smooth = 3
		2756	set_smoothlevel = 4
2383	CODE:	2757	CODE:
2384	faceinfo *f = face_info (idx); assert (f);	2758	faceinfo *f = face_info (idx); assert (f);
2385	f->smooth = smooth;	2759	switch (ix)
2386	f->smoothlevel = smoothlevel;	2760	{
		2761	case 0: f->type = value; break;
		2762	case 1: f->visibility = value; break;
		2763	case 2: f->magicmap = value; break;
		2764	case 3: f->smooth = value; break;
		2765	case 4: f->smoothlevel = value; break;
		2766	}
2387		2767
2388	void set_data (faceidx idx, int faceset, SV *data, SV *chksum)	2768	void set_csum (faceidx idx, int faceset, SV *chksum)
2389	CODE:	2769	CODE:
2390	{	2770	{
		2771	faceinfo *f = face_info (idx); assert (f);
2391	facedata *d = face_data (idx, faceset);	2772	facedata *d = f->face + faceset;
2392	assert (d);
2393	sv_to (data, d->data);
2394	STRLEN clen;	2773	STRLEN clen;
2395	char *cdata = SvPVbyte (chksum, clen);	2774	char *cdata = SvPVbyte (chksum, clen);
2396	clen = min (CHKSUM_SIZE, clen);
2397		2775
		2776	assert (("cf::face::set_data called with too long checksum", clen <= CHKSUM_MAXLEN));
		2777	assert (("cf::face::set_data must be called with a non-empty checksum", clen));
		2778
2398	if (memcmp (d->chksum, cdata, clen))	2779	if (clen != d->chksum_len || memcmp (d->chksum, cdata, clen))
2399	{	2780	{
		2781	d->chksum_len = clen;
2400	memcpy (d->chksum, cdata, clen);	2782	memcpy (d->chksum, cdata, clen);
2401		2783
2402	// invalidate existing client face info	2784	// invalidate existing client face info
2403	for_all_clients (ns)	2785	for_all_clients (ns)
2404	if (ns->faceset == faceset)	2786	ns->invalidate_face (idx);
2405	{
2406	ns->faces_sent [idx] = false;
2407	ns->force_newmap = true;
2408	}
2409	}	2787	}
2410	}	2788	}
2411		2789
		2790	SV *mangle_csum (SV *chksum)
		2791	CODE:
		2792	STRLEN len;
		2793	char *data = SvPVbyte (chksum, len);
		2794	RETVAL = newSVpvn (data, min (len, CHKSUM_MAXLEN));
		2795	OUTPUT: RETVAL
		2796
		2797	SV *get_csum (faceidx idx, int faceset = 0)
		2798	CODE:
		2799	facedata *d = face_data (idx, faceset);
		2800	if (!d) XSRETURN_UNDEF;
		2801	RETVAL = newSVpvn ((char *)d->chksum, d->chksum_len);
		2802	OUTPUT: RETVAL
		2803
		2804	int get_type (faceidx idx)
		2805	CODE:
		2806	faceinfo *f = face_info (idx);
		2807	if (!f) XSRETURN_UNDEF;
		2808	RETVAL = f->type;
		2809	OUTPUT: RETVAL
		2810
		2811	SV *get_name (faceidx idx)
		2812	CODE:
		2813	faceinfo *f = face_info (idx);
		2814	if (!f) XSRETURN_UNDEF;
		2815	RETVAL = to_sv (f->name);
		2816	OUTPUT: RETVAL
		2817
2412	void invalidate (faceidx idx)	2818	void invalidate (faceidx idx)
2413	CODE:	2819	CODE:
2414	for_all_clients (ns)	2820	for_all_clients (ns)
2415	{	2821	ns->invalidate_face (idx);
2416	ns->faces_sent [idx] = false;
2417	ns->force_newmap = true;
2418	}
2419		2822
2420	void invalidate_all ()	2823	void invalidate_all ()
2421	CODE:	2824	CODE:
2422	for_all_clients (ns)	2825	for_all_clients (ns)
2423	{	2826	ns->invalidate_all_faces ();
2424	ns->faces_sent.reset ();
2425	ns->force_newmap = true;
2426	}
2427		2827
2428	MODULE = cf PACKAGE = cf::anim PREFIX = anim_	2828	MODULE = cf PACKAGE = cf::anim PREFIX = anim_
2429		2829
2430	#INCLUDE: $PERL $srcdir/genacc faceset ../include/anim.h |	2830	#INCLUDE: $PERL $srcdir/genacc faceset $srcdir/../include/anim.h |
2431		2831
2432	animidx anim_find (utf8_string name)	2832	animidx anim_find (utf8_string name)
2433	CODE:	2833	CODE:
2434	RETVAL = animation::find (name).number;	2834	RETVAL = animation::find (name).number;
2435	OUTPUT: RETVAL	2835	OUTPUT: RETVAL
2436		2836
2437	animidx set (utf8_string name, SV *frames, int facings = 1)	2837	animidx set (utf8_string name, SV *frames, int facings = 1)
2438	CODE:	2838	CODE:
2439	{	2839	{
2440	if (!SvROK (frames) && SvTYPE (SvRV (frames)) != SVt_PVAV)	2840	if (!SvROK (frames) && SvTYPE (SvRV (frames)) != SVt_PVAV)
2441	croak ("frames must be an arrayref");	2841	croak ("frames must be an arrayref");
2442		2842
2443	AV *av = (AV *)SvRV (frames);	2843	AV *av = (AV *)SvRV (frames);
2444		2844
2445	animation *anim = &animation::find (name);	2845	animation *anim = &animation::find (name);
2446	if (anim->number)	2846	if (anim->number)
2447	{	2847	{
2448	anim->resize (av_len (av) + 1);	2848	anim->resize (av_len (av) + 1);
2449	anim->facings = facings;	2849	anim->facings = facings;
2450	}	2850	}
2451	else	2851	else
2452	anim = &animation::create (name, av_len (av) + 1, facings);	2852	anim = &animation::create (name, av_len (av) + 1, facings);
2453		2853
2454	for (int i = 0; i < anim->num_animations; ++i)	2854	for (int i = 0; i < anim->num_animations; ++i)
2455	anim->faces [i] = face_find (SvPVutf8_nolen (*av_fetch (av, i, 1)));	2855	anim->faces [i] = face_find (cfSvPVutf8_nolen (*av_fetch (av, i, 1)));
2456	}	2856	}
2457	OUTPUT: RETVAL	2857	OUTPUT: RETVAL
2458		2858
2459	void invalidate_all ()	2859	void invalidate_all ()
2460	CODE:	2860	CODE:
2461	for_all_clients (ns)	2861	for_all_clients (ns)
2462	ns->anims_sent.reset ();	2862	ns->anims_sent.reset ();
2463		2863
		2864	MODULE = cf PACKAGE = cf::object::freezer
		2865
		2866	INCLUDE: $PERL $srcdir/genacc object_freezer $srcdir/../include/cfperl.h |
		2867
		2868	SV *
		2869	new (char *klass)
		2870	CODE:
		2871	RETVAL = newSVptr (new object_freezer, gv_stashpv ("cf::object::freezer", 1));
		2872	OUTPUT: RETVAL
		2873
		2874	void
		2875	DESTROY (SV *sv)
		2876	CODE:
		2877	object_freezer *self;
		2878	sv_to (sv, self);
		2879	delete self;
		2880
		2881	MODULE = cf PACKAGE = cf::object::thawer
		2882
		2883	INCLUDE: $PERL $srcdir/genacc object_thawer $srcdir/../include/freezethaw.h |
		2884
		2885	bool
		2886	errors_are_fatal (bool fatal)
		2887	CODE:
		2888	RETVAL = object_thawer::errors_are_fatal;
		2889	object_thawer::errors_are_fatal = fatal;
		2890	OUTPUT: RETVAL
		2891
		2892	SV *
		2893	new_from_file (char *klass, octet_string path)
		2894	CODE:
		2895	object_thawer *f = new object_thawer (path);
		2896	if (!*f)
		2897	{
		2898	delete f;
		2899	XSRETURN_UNDEF;
		2900	}
		2901	RETVAL = newSVptr (f, gv_stashpv ("cf::object::thawer", 1));
		2902	OUTPUT: RETVAL
		2903
		2904	void
		2905	DESTROY (SV *sv)
		2906	CODE:
		2907	object_thawer *self;
		2908	sv_to (sv, self);
		2909	delete self;
		2910
		2911	void
		2912	extract_tags (object_thawer *self)
		2913	PPCODE:
		2914	while (self->kw != KW_EOF)
		2915	{
		2916	PUTBACK;
		2917	coroapi::cede_to_tick ();
		2918	SPAGAIN;
		2919
		2920	if (self->kw == KW_tag)
		2921	XPUSHs (sv_2mortal (newSVpv_utf8 (self->get_str ())));
		2922
		2923	self->skip ();
		2924	}
		2925
		2926	MODULE = cf PACKAGE = cf::treasurelist
		2927
		2928	# quick hack, because I didn't want to implement accessors for treasurelist.
		2929	# this asks for even more autogen, actually.
		2930
		2931	void
		2932	expand (treasurelist *list)
		2933	PPCODE:
		2934	EXTEND (SP, 3);
		2935	PUSHs (sv_2mortal (to_sv (list->name)));
		2936	PUSHs (sv_2mortal (to_sv (list->total_chance)));
		2937	AV *av = newAV ();
		2938	PUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
		2939	for (treasure *item = list->items; item; item = item->next)
		2940	{
		2941	AV *iav = newAV ();
		2942	av_push (av, newRV_noinc ((SV *)iav));
		2943
		2944	av_extend (iav, 7);
		2945	av_push (iav, to_sv (item->item));
		2946	av_push (iav, to_sv (item->name));
		2947	av_push (iav, to_sv (item->change_arch.name));
		2948	av_push (iav, to_sv (item->change_arch.title));
		2949	av_push (iav, to_sv (item->change_arch.slaying));
		2950	av_push (iav, to_sv (item->chance));
		2951	av_push (iav, to_sv (item->nrof));
		2952	av_push (iav, to_sv (item->magic));
		2953	}
		2954
		2955	MODULE = cf PACKAGE = cf::layout
		2956
		2957	INCLUDE: $PERL $srcdir/genacc layout $srcdir/../include/rmg.h |
		2958

Diff Legend

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