[ViewVC] Diff of: cvs/deliantra/server/server/cfperl.xs

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.197 by root, Fri Apr 27 03:38:33 2007 UTC vs. Revision 1.423 by root, Wed Nov 14 05:25:50 2012 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.197 by root, Fri Apr 27 03:38:33 2007 UTC vs.
Revision 1.423 by root, Wed Nov 14 05:25:50 2012 UTC