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

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.160 by elmex, Wed Jan 31 14:11:02 2007 UTC vs. Revision 1.364 by root, Sun Apr 11 03:53:33 2010 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.160 by elmex, Wed Jan 31 14:11:02 2007 UTC vs.
Revision 1.364 by root, Sun Apr 11 03:53:33 2010 UTC