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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.194 by root, Mon Apr 23 18:09:57 2007 UTC vs.
Revision 1.365 by root, Sun Apr 11 04:09:56 2010 UTC

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.194 by root, Mon Apr 23 18:09:57 2007 UTC vs. Revision 1.365 by root, Sun Apr 11 04:09:56 2010 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.194 by root, Mon Apr 23 18:09:57 2007 UTC vs.
Revision 1.365 by root, Sun Apr 11 04:09:56 2010 UTC