ViewVC Help

View File | Revision Log | Show Annotations | Download File

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

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

Diff Legend

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