ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/cfperl.xs

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.204 by root, Mon Apr 30 04:25:30 2007 UTC vs.
Revision 1.401 by root, Sat Apr 30 05:41:17 2011 UTC

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

Diff Legend

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