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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.164 by root, Sun Feb 11 01:38:49 2007 UTC vs.
Revision 1.384 by root, Fri Apr 30 21:00:40 2010 UTC

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.164 by root, Sun Feb 11 01:38:49 2007 UTC vs. Revision 1.384 by root, Fri Apr 30 21:00:40 2010 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.164 by root, Sun Feb 11 01:38:49 2007 UTC vs.
Revision 1.384 by root, Fri Apr 30 21:00:40 2010 UTC