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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.197 by root, Fri Apr 27 03:38:33 2007 UTC vs.
Revision 1.420 by root, Sun Nov 11 04:29:11 2012 UTC

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.197 by root, Fri Apr 27 03:38:33 2007 UTC vs. Revision 1.420 by root, Sun Nov 11 04:29:11 2012 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.197 by root, Fri Apr 27 03:38:33 2007 UTC vs.
Revision 1.420 by root, Sun Nov 11 04:29:11 2012 UTC