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

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.187 by root, Mon Apr 16 06:23:42 2007 UTC vs. Revision 1.369 by root, Wed Apr 14 02:31:24 2010 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.187 by root, Mon Apr 16 06:23:42 2007 UTC vs.
Revision 1.369 by root, Wed Apr 14 02:31:24 2010 UTC