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

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

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.153 by root, Fri Jan 26 20:59:57 2007 UTC vs.
Revision 1.370 by root, Wed Apr 14 21:36:32 2010 UTC