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

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.168 by root, Thu Feb 15 03:19:02 2007 UTC vs. Revision 1.367 by root, Mon Apr 12 05:22:38 2010 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.168 by root, Thu Feb 15 03:19:02 2007 UTC vs.
Revision 1.367 by root, Mon Apr 12 05:22:38 2010 UTC