ViewVC Help

View File | Revision Log | Show Annotations | Download File

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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.194 by root, Mon Apr 23 18:09:57 2007 UTC vs.
Revision 1.331 by root, Thu Nov 5 14:38:47 2009 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 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
9	* Copyright (C) 2006,2007 by Marc Lehmann <cf@schmorp.de>	5	* Copyright (©) 2006,2007 by Marc Lehmann <cf@schmorp.de>
10	*	6	*
11	* This program is free software; you can redistribute it and/or modify	7	* 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	8	* 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	9	* Free Software Foundation, either version 3 of the License, or (at your
14	* (at your option) any later version.	10	* option) any later version.
15	*	11	*
16	* This program is distributed in the hope that it will be useful,	12	* This program is distributed in the hope that it will be useful,
17	* but WITHOUT ANY WARRANTY; without even the implied warranty of	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19	* GNU General Public License for more details.	15	* GNU General Public License for more details.
20	*	16	*
21	* You should have received a copy of the GNU General Public License	17	* 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	18	* 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	19	* <http://www.gnu.org/licenses/>.
		20	*
		21	* The authors can be reached via e-mail to <support@deliantra.net>
24	*/	22	*/
25		23
26	#define PLUGIN_NAME "perl"	24	#include "autoconf.h"
27	#define PLUGIN_VERSION "cfperl 0.5"
28		25
29	#define CEDES_PER_TICK 5	26	#if HAVE_EXECINFO_H
		27	# include <execinfo.h>
		28	#endif
30		29
31	#include <plugin_common.h>
32	#include <sounds.h>
33	#include <cstdarg>	30	#include <cstdarg>
34	#include <sproto.h>	31	#include <typeinfo>
35		32
		33	#include "global.h"
36	#include "loader.h"	34	#include "loader.h"
		35	#include "../random_maps/random_map.h"
37	#include "cfperl.h"	36	#include "evthread.h"
38	#include "shstr.h"	37	#include "sproto.h"
39		38
40	#include <unistd.h>	39	#include <unistd.h>
41	#if _POSIX_MEMLOCK	40	#if _POSIX_MEMLOCK
42	# include <sys/mman.h>	41	# include <sys/mman.h>
43	#endif	42	#endif
44		43
		44	#if HAVE_MALLOC_H
		45	# include <malloc.h>
		46	#endif
		47
		48	#if !__GLIBC__
		49	# define malloc_trim(pad) -1
		50	#endif
		51
45	#include <EXTERN.h>	52	#include <EXTERN.h>
46	#include <perl.h>	53	#include <perl.h>
47	#include <XSUB.h>	54	#include <XSUB.h>
48		55
49	#include "CoroAPI.h"	56	#include "CoroAPI.h"
50	#include "perlxsi.c"	57	#include "perlxsi.c"
51		58
52	extern sint64 *levels; // the experience table	59	extern sint64 *levels; // the experience table
53		60
54	typedef object object_ornull;	61	typedef object_thawer &object_thawer_ref;
55	typedef maptile maptile_ornull;	62	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		63
62	typedef std::string std__string;	64	typedef std::string std__string;
63		65
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;	66	static PerlInterpreter *perl;
79		67
80	double runtime;	68	tstamp NOW, runtime;
		69
		70	static int tick_inhibit;
		71	static int tick_pending;
81		72
82	global gbl_ev;	73	global gbl_ev;
83	static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map;	74	static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map;
84	static SV *sv_runtime, *sv_next_tick;	75	static SV *sv_runtime, *sv_tick_start, *sv_next_tick, *sv_now;
		76	static AV *av_reflect;
		77
		78	bitset<NUM_EVENT_TYPES> ev_want_event;
		79	bitset<NUM_TYPES> ev_want_type;
85		80
86	static HV	81	static HV
87	*stash_cf,	82	*stash_cf,
88	*stash_cf_object_wrap,	83	*stash_cf_object_wrap,
89	*stash_cf_object_player_wrap,	84	*stash_cf_object_player_wrap,
90	*stash_cf_player_wrap,	85	*stash_cf_player_wrap,
91	*stash_cf_map_wrap,	86	*stash_cf_map_wrap,
		87	*stash_cf_mapspace_wrap,
92	*stash_cf_client_wrap,	88	*stash_cf_client_wrap,
93	*stash_cf_arch_wrap,	89	*stash_cf_arch_wrap,
94	*stash_cf_party_wrap,	90	*stash_cf_party_wrap,
95	*stash_cf_region_wrap,	91	*stash_cf_region_wrap,
96	*stash_cf_living_wrap;	92	*stash_cf_living_wrap;
97		93
		94	static SV
		95	*cv_cf_do_invoke,
		96	*cv_cf__can_merge,
		97	*cv_cf_client_send_msg,
		98	*cv_cf_tick,
		99	*cv_cf_match_match;
		100
		101	#ifndef newSVpv_utf8
		102	static inline SV *
		103	newSVpv_utf8 (const char *s)
		104	{
		105	if (!s)
		106	return newSV (0);
		107
		108	SV *sv = newSVpv (s, 0);
		109	SvUTF8_on (sv);
		110	return sv;
		111	}
		112	#endif
		113
		114	#ifndef newSVpvn_utf8
		115	static inline SV *
		116	newSVpvn_utf8 (const char *s, STRLEN l, int utf8)
		117	{
		118	if (!s)
		119	return newSV (0);
		120
		121	SV *sv = newSVpvn (s, l);
		122
		123	if (utf8)
		124	SvUTF8_on (sv);
		125
		126	return sv;
		127	}
		128	#endif
		129
98	// helper cast function, returns super class * or 0	130	// helper cast function, returns super class * or 0
99	template<class super>	131	template<class super>
100	static super *	132	static super *
101	is_a (attachable *at)	133	is_a (attachable *at)
102	{	134	{
…		…
111		143
112	unordered_vector<attachable *> attachable::mortals;	144	unordered_vector<attachable *> attachable::mortals;
113		145
114	attachable::~attachable ()	146	attachable::~attachable ()
115	{	147	{
116	flags |=0x3300;//D
117	assert (!self);	148	assert (!self);
118	assert (!cb);	149	assert (!cb);
119	}	150	}
120		151
121	int	152	int
…		…
135	SvREFCNT_inc (self);	166	SvREFCNT_inc (self);
136	hv_clear (self);	167	hv_clear (self);
137	sv_unmagic ((SV *)self, PERL_MAGIC_ext);	168	sv_unmagic ((SV *)self, PERL_MAGIC_ext);
138	SvREFCNT_dec (self);	169	SvREFCNT_dec (self);
139		170
140	// self *must* be null now because thats sv_unmagic's job.	171	// self *must* be null now because that's sv_unmagic's job.
141	assert (!this->self);	172	assert (!this->self);
142	flags |= 0x80; // severed //D
143	}	173	}
144	}	174	}
145		175
146	void	176	void
147	attachable::optimise ()	177	attachable::optimise ()
148	{	178	{
149	if (self	179	if (self
150	&& SvREFCNT (self) == 1	180	&& SvREFCNT (self) == 1
151	&& !HvTOTALKEYS (self))	181	&& !HvTOTALKEYS (self))
152	flags |= 0x40,//D
153	sever_self ();	182	sever_self ();
154	}	183	}
155		184
156	// check wether the object really is dead	185	// check wether the object really is dead
157	void	186	void
…		…
164	}	193	}
165		194
166	void	195	void
167	attachable::do_destroy ()	196	attachable::do_destroy ()
168	{	197	{
169	invoke (EVENT_ATTACHABLE_DESTROY, DT_END);	198	INVOKE_ATTACHABLE (DESTROY, this);
170		199
171	if (cb)	200	if (cb)
172	{	201	{
173	SvREFCNT_dec (cb);	202	SvREFCNT_dec (cb);
174	cb = 0;	203	cb = 0;
175	}	204	}
176		205
177	if (self)
178	sever_self ();
179
180	flags |= 0x20; //D
181	mortals.push_back (this);	206	mortals.push_back (this);
182	}	207	}
183		208
184	void	209	void
185	attachable::destroy ()	210	attachable::destroy ()
…		…
187	if (destroyed ())	212	if (destroyed ())
188	return;	213	return;
189		214
190	flags |= F_DESTROYED;	215	flags |= F_DESTROYED;
191	do_destroy ();	216	do_destroy ();
		217	sever_self ();
192	}	218	}
193		219
194	void	220	void
195	attachable::check_mortals ()	221	attachable::check_mortals ()
196	{	222	{
…		…
200	{	226	{
201	if (i >= mortals.size ())	227	if (i >= mortals.size ())
202	{	228	{
203	i = 0;	229	i = 0;
204		230
205	if (mortals.size () > 1000)	231	if (mortals.size () >= 512)
206	fprintf (stderr, "mortal queue size (%d) exceeds 1000.\n", (int)mortals.size ());	232	{
		233	static int last_mortalcount;
		234	if (mortals.size () != last_mortalcount)
		235	{
		236	last_mortalcount = mortals.size ();
		237	LOG (llevInfo, "%d mortals.\n", (int)mortals.size ());
		238
		239	if (0)
		240	{
		241	for (int j = 0; j < mortals.size (); ++j)//D
		242	fprintf (stderr, "%d:%s %p ", j, &((object *)mortals[j])->name, mortals[j]);//D
		243	fprintf (stderr, "\n");//D
		244	}
		245	}
		246	}
207		247
208	break;	248	break;
209	}	249	}
210		250
211	attachable *obj = mortals [i];	251	attachable *obj = mortals [i];
212		252
213	obj->refcnt_chk (); // unborrow from perl, if necessary	253	#if 0
214		254	if (obj->self)//D make this an assert later
215	//if (obj->refcnt > 0 || obj->self)
216	if (obj->refcnt || obj->self)
217	{	255	{
218	//printf ("%p rc %d\n", obj, obj->refcnt_cnt ());//D	256	LOG (llevError, "check_mortals: object '%s' still has self\n", typeid (obj).name ());
		257	obj->sever_self ();
		258	}
		259	#endif
		260
		261	if (obj->refcnt)
		262	{
219	++i; // further delay freeing	263	++i; // further delay freeing
220		264
221	if (!(i & 0x3ff))	265	if (!(i & 0x3ff))
222	break;	266	break;
223	}	267	}
224	else	268	else
225	{	269	{
226	mortals.erase (i);	270	mortals.erase (i);
		271	obj->sever_self ();
227	delete obj;	272	delete obj;
228	}	273	}
229	}	274	}
230	}	275	}
231		276
		277	void
		278	attachable::set_key (const char *key, const char *value, bool is_utf8)
		279	{
		280	if (!self)
		281	self = newHV ();
		282
		283	if (value)
		284	hv_store (self, key, strlen (key), is_utf8 ? newSVpv_utf8 (value) : newSVpv (value, 0), 0);
		285	else
		286	hv_delete (self, key, strlen (key), G_DISCARD);
		287	}
		288
232	attachable &	289	attachable &
233	attachable::operator =(const attachable &src)	290	attachable::operator =(const attachable &src)
234	{	291	{
235	//if (self || cb)	292	//if (self || cb)
236	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));	293	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));
237		294
238	attach = src.attach;	295	attach = src.attach;
239	return *this;	296	return *this;
240	}	297	}
241		298
		299	template<typename T>
		300	static bool
		301	find_backref (void *ptr, T *obj)
		302	{
		303	char *s = (char *)obj;
		304	while (s < (char *)obj + sizeof (T))
		305	{
		306	if (ptr == *(void **)s)
		307	return true;
		308
		309	s += sizeof (void *); // assume natural alignment
		310	}
		311
		312	return false;
		313	}
		314
		315	// for debugging, find "live" objects containing this ptr
		316	void
		317	find_backref (void *ptr)
		318	{
		319	for_all_objects (op)
		320	if (find_backref (ptr, op))
		321	fprintf (stderr, "O %p %d:'%s'\n", op, op->count, &op->name);
		322
		323	for_all_players (pl)
		324	if (find_backref (ptr, pl))
		325	fprintf (stderr, "P %p\n", pl);
		326
		327	for_all_clients (ns)
		328	if (find_backref (ptr, ns))
		329	fprintf (stderr, "C %p\n", ns);
		330	}
		331
242	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	332	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
243		333
244	static SV *	334	static SV *
245	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())	335	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())
246	{	336	{
247	SV *sv;	337	SV *sv;
248		338
249	if (!ptr)	339	if (!ptr)
250	return &PL_sv_undef;	340	return newSV (0);
251		341
252	sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);	342	sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);
253	return sv_bless (newRV_noinc ((SV *)hv), stash);	343	return sv_bless (newRV_noinc ((SV *)hv), stash);
254	}	344	}
255		345
…		…
274		364
275	static SV *	365	static SV *
276	newSVattachable (attachable *obj, HV *stash)	366	newSVattachable (attachable *obj, HV *stash)
277	{	367	{
278	if (!obj)	368	if (!obj)
279	return &PL_sv_undef;	369	return newSV (0);
280		370
281	if (!obj->self)	371	if (!obj->self)
		372	obj->self = newHV ();
		373
		374	if (!SvOBJECT (obj->self))
282	{	375	{
283	obj->self = newHV ();
284	sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char *)obj, 0);	376	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		377
289	// now bless the object _once_	378	// now bless the object _once_
		379	//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);	380	return sv_bless (newRV_inc ((SV *)obj->self), stash);
291	}	381	}
292	else	382	else
293	{	383	{
294	SV *sv = newRV_inc ((SV *)obj->self);	384	SV *sv = newRV_inc ((SV *)obj->self);
…		…
322	croak ("perl code used %s object, but C object is already destroyed, caught", klass);	412	croak ("perl code used %s object, but C object is already destroyed, caught", klass);
323		413
324	return (long)mg->mg_ptr;	414	return (long)mg->mg_ptr;
325	}	415	}
326		416
327	static long	417	static long noinline
328	SvPTR_ornull (SV *sv, const char *klass)	418	SvPTR_ornull (SV *sv, const char *klass)
329	{	419	{
330	if (SvOK (sv))	420	if (SvOK (sv))
331	return SvPTR (sv, klass);	421	return SvPTR (sv, klass);
332	else	422	else
333	return 0;	423	return 0;
334	}	424	}
335		425
336	inline SV *to_sv (const shstr & v) { return v ? newSVpvn ((const char *)v, v.length ()) : &PL_sv_undef; }	426	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); }	427	inline SV *to_sv (const char * v) { return v ? newSVpv (v, 0) : newSV (0); }
338	inline SV *to_sv (bool v) { return newSViv (v); }	428	inline SV *to_sv (bool v) { return newSViv (v); }
339	inline SV *to_sv ( signed char v) { return newSViv (v); }	429	inline SV *to_sv ( signed char v) { return newSViv (v); }
340	inline SV *to_sv (unsigned char v) { return newSViv (v); }	430	inline SV *to_sv (unsigned char v) { return newSViv (v); }
341	inline SV *to_sv ( signed short v) { return newSViv (v); }	431	inline SV *to_sv ( signed short v) { return newSViv (v); }
342	inline SV *to_sv (unsigned short v) { return newSVuv (v); }	432	inline SV *to_sv (unsigned short v) { return newSVuv (v); }
…		…
351	inline SV *to_sv (client * v) { return newSVattachable (v, stash_cf_client_wrap); }	441	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); }	442	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); }	443	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); }	444	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); }	445	inline SV *to_sv (archetype * v) { return newSVattachable (v, stash_cf_arch_wrap); }
		446	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); }	447	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); }	448	inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }
		449	inline SV *to_sv (mapspace * v) { return newSVptr (v, stash_cf_mapspace_wrap); }
359		450
360	inline SV *to_sv (object & v) { return to_sv (&v); }	451	inline SV *to_sv (object & v) { return to_sv (&v); }
361	inline SV *to_sv (living & v) { return to_sv (&v); }	452	inline SV *to_sv (living & v) { return to_sv (&v); }
362		453
363	inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); }	454	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); }	455	inline SV *to_sv (const treasurelist *v) { return to_sv (v->name); }
365		456
		457	inline SV *to_sv (UUID v) { return newSVpv (v.c_str (), 0); }
		458
366	inline SV *to_sv (UUID v)	459	inline SV *to_sv (dynbuf * v)
367	{	460	{
368	char buf[128];	461	SV *sv = newSV (0);
369	snprintf (buf, 128, "<1.%" PRIx64 ">", v.seq);
370	return newSVpv (buf, 0);
371	}
372		462
		463	sv_upgrade (sv, SVt_PV);
		464	SvGROW (sv, v->size () + 1);
		465	SvPOK_only (sv);
		466	v->linearise (SvPVX (sv));
		467	SvCUR_set (sv, v->size ());
		468	*SvEND (sv) = 0;
		469
		470	return sv;
		471	}
		472
		473	inline SV *to_sv (dynbuf_text * v)
		474	{
		475	SV *sv = to_sv (static_cast<dynbuf *> (v));
		476	SvUTF8_on (sv);
		477	return sv;
		478	}
		479
373	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPV_nolen (sv) : 0; }	480	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPVutf8_nolen (sv) : 0; }
374	inline void sv_to (SV *sv, char * &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }	481	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); }	482	inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }
376	inline void sv_to (SV *sv, signed char &v) { v = SvIV (sv); }	483	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); }	484	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); }	485	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); }	486	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); }	487	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); }	488	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); }	489	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); }	490	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); }	491	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); }	492	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); }	493	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
387	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }	494	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"); }	495	inline void sv_to (SV *sv, client * &v) { v = (client *)(attachable *)SvPTR_ornull (sv, "cf::client"); }
389	inline void sv_to (SV *sv, player * &v) { v = (player *)(attachable *)SvPTR_ornull (sv, "cf::player"); }	496	inline void sv_to (SV *sv, player * &v) { v = (player *)(attachable *)SvPTR_ornull (sv, "cf::player"); }
390	inline void sv_to (SV *sv, object * &v) { v = (object *)(attachable *)SvPTR_ornull (sv, "cf::object"); }	497	inline void sv_to (SV *sv, object * &v) { v = (object *)(attachable *)SvPTR_ornull (sv, "cf::object"); }
391	inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)(attachable *)SvPTR_ornull (sv, "cf::arch"); }	498	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"); }	499	inline void sv_to (SV *sv, maptile * &v) { v = (maptile *)(attachable *)SvPTR_ornull (sv, "cf::map"); }
		500	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"); }	501	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"); }	502	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"); }	503	inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }
		504	inline void sv_to (SV *sv, mapspace * &v) { v = (mapspace *)SvPTR_ornull (sv, "cf::mapspace"); }
		505	inline void sv_to (SV *sv, object_freezer * &v) { v = (object_freezer *)SvPTR_ornull (sv, "cf::object::freezer"); }
		506	inline void sv_to (SV *sv, object_thawer * &v) { v = (object_thawer *)SvPTR_ornull (sv, "cf::object::thawer" ); }
397		507
398	//inline void sv_to (SV *sv, faceinfo * &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }	508	//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)); }	509	inline void sv_to (SV *sv, treasurelist * &v) { v = treasurelist::find (SvPV_nolen (sv)); }
400		510
401	template<class T>	511	template<class T>
402	inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }	512	inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }
403		513
404	template<int N>	514	template<int N>
405	inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); }	515	inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); }
406		516
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); }	517	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); }	518	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); }	519	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); }	520	inline void sv_to (SV *sv, unapplymode &v) { v = (unapplymode) SvIV (sv); }
412		521
413	inline void sv_to (SV *sv, std::string &v)	522	inline void sv_to (SV *sv, std::string &v)
414	{	523	{
415	STRLEN len;	524	STRLEN len;
416	char *data = SvPVbyte (sv, len);	525	char *data = SvPVbyte (sv, len);
417	v.assign (data, len);	526	v.assign (data, len);
418	}	527	}
419		528
420	inline void sv_to (SV *sv, UUID &v)	529	inline void sv_to (SV *sv, UUID &v)
421	{	530	{
422	unsigned int version;	531	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));	532	croak ("unparsable uuid: %s", SvPV_nolen (sv));
426	}	533	}
427		534
428	inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }	535	inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }
429		536
…		…
447	break;	554	break;
448		555
449	case DT_STRING:	556	case DT_STRING:
450	{	557	{
451	char *str = (char *)va_arg (ap, const char *);	558	char *str = (char *)va_arg (ap, const char *);
452	sv = str ? newSVpv (str, 0) : &PL_sv_undef;	559	sv = str ? newSVpv (str, 0) : newSV (0);
453	}	560	}
454	break;	561	break;
455		562
456	case DT_DATA:	563	case DT_DATA:
457	{	564	{
458	char *str = (char *)va_arg (ap, const void *);	565	char *str = (char *)va_arg (ap, const void *);
459	int len = va_arg (ap, int);	566	int len = va_arg (ap, int);
460	sv = str ? newSVpv (str, len) : &PL_sv_undef;	567	sv = str ? newSVpv (str, len) : newSV (0);
461	}	568	}
462	break;	569	break;
463		570
464	case DT_OBJECT:	571	case DT_OBJECT:
465	sv = to_sv (va_arg (ap, object *));	572	sv = to_sv (va_arg (ap, object *));
…		…
507	va_end (ap);	614	va_end (ap);
508		615
509	return sv;	616	return sv;
510	}	617	}
511		618
512	static SV *	619	// typemap support, mostly to avoid excessive inlining
513	newSVcfapi (int type, ...)	620	template<class type>
		621	static void noinline
		622	cf_obj_to (SV *arg, type &var)
514	{	623	{
515	SV *sv;	624	sv_to (arg, var);
		625	if (!var)
		626	croak ("must not pass invalid/null cf_obj here");
		627	}
516		628
517	va_list ap;	629	template<class object>
518	va_start (ap, type);	630	static void noinline
519		631	cf_obj_ornull_to (SV *arg, object *&var)
520	switch (type)	632	{
		633	if (SvOK (arg))
521	{	634	{
522	case CFAPI_INT: sv = newSViv (*va_arg (ap, int * )); break;	635	sv_to (arg, var);
523	case CFAPI_LONG: sv = newSVval64 (*va_arg (ap, sint64 *)); break;	636	if (!var)
524	case CFAPI_DOUBLE: sv = newSVnv (*va_arg (ap, double *)); break;	637	croak ("unable to convert perl object to C++ object");
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	}	638	}
536		639	else
537	va_end (ap);	640	var = 0;
538
539	return sv;
540	}	641	}
541		642
542	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	643	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
543		644
544	SV *	645	SV *
…		…
550	return newRV_inc ((SV *)ext->cb);	651	return newRV_inc ((SV *)ext->cb);
551	}	652	}
552		653
553	/////////////////////////////////////////////////////////////////////////////	654	/////////////////////////////////////////////////////////////////////////////
554		655
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	656	void
611	cfperl_init ()	657	cfperl_init ()
612	{	658	{
		659	extern char **environ;
		660
613	PERL_SYS_INIT3 (&settings.argc, &settings.argv, 0);	661	PERL_SYS_INIT3 (&settings.argc, &settings.argv, &environ);
614	perl = perl_alloc ();	662	perl = perl_alloc ();
615	perl_construct (perl);	663	perl_construct (perl);
616		664
617	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;	665	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
618		666
619	const char *argv[] = {	667	const char *argv[] = {
620	"",	668	settings.argv [0],
621	"-e"	669	"-e0"
622	"use Event; use Coro;" // required for bootstrap
623	"cf->bootstrap;" // required for datadir :*>
624	"unshift @INC, cf::datadir ();"
625	"require cf;"
626	};	670	};
627		671
628	if (perl_parse (perl, xs_init, 2, (char **)argv, (char **)NULL)	672	if (perl_parse (perl, xs_init, 2, (char **)argv, environ)
629	|| perl_run (perl))	673	|| perl_run (perl))
630	{	674	{
631	printf ("unable to initialize perl-interpreter, aborting.\n");	675	printf ("unable to initialize perl-interpreter, aborting.\n");
632	exit (EXIT_FAILURE);	676	exit (EXIT_FAILURE);
633	}	677	}
634		678
		679	eval_pv (
		680	"#line 1 'cfperl init'\n"
		681	"use EV ();\n"
		682	"use Coro ();\n"
		683	"cf->bootstrap;\n"
		684	"unshift @INC, cf::datadir ();\n"
		685	"require cf;\n",
		686	0
		687	);
		688
		689	if (SvTRUE (ERRSV))
635	{	690	{
636	dSP;	691	printf ("unable to bootstrap perl, aborting:\n%s", SvPV_nolen (ERRSV));
637		692	exit (EXIT_FAILURE);
638	PUSHMARK (SP);
639	PUTBACK;
640	call_pv ("cf::init", G_DISCARD | G_VOID);
641	}	693	}
642	}	694	}
643		695
		696	void
644	void cfperl_main ()	697	cfperl_main ()
645	{	698	{
646	dSP;	699	dSP;
647		700
648	PUSHMARK (SP);	701	PUSHMARK (SP);
649	PUTBACK;	702	PUTBACK;
…		…
653	void	706	void
654	attachable::instantiate ()	707	attachable::instantiate ()
655	{	708	{
656	if (attach)	709	if (attach)
657	{	710	{
658	invoke (EVENT_ATTACHABLE_INSTANTIATE, ARG_STRING (attach), DT_END);	711	INVOKE_ATTACHABLE (INSTANTIATE, this, ARG_STRING (attach));
659	attach = 0;	712	attach = 0;
660	}	713	}
661	}	714	}
662		715
663	void	716	void
664	attachable::reattach ()	717	attachable::reattach ()
665	{	718	{
666	optimise ();	719	optimise ();
667	//TODO: check for _attachment's, very important for restarts	720	//TODO: check for _attachment's, very important for restarts
668	invoke (EVENT_ATTACHABLE_REATTACH, DT_END);	721	INVOKE_ATTACHABLE (REATTACH, this);
669	}	722	}
670		723
671	static event_klass klass_of[NUM_EVENT_TYPES] = {	724	static event_klass klass_of[NUM_EVENT_TYPES] = {
672	# define def(type,name) KLASS_ ## type,	725	# define def(type,name) KLASS_ ## type,
673	# include "eventinc.h"	726	# include "eventinc.h"
674	# undef def	727	# undef def
675	};	728	};
676		729
677	#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)	730	#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)
678		731
679	static void	732	static void noinline
680	gather_callbacks (AV *&callbacks, AV *registry, event_type event)	733	gather_callbacks (AV *&callbacks, AV *registry, event_type event)
681	{	734	{
682	// event must be in array	735	// event must be in array
683	if (event >= 0 && event <= AvFILLp (registry))	736	if (event >= 0 && event <= AvFILLp (registry))
684	{	737	{
…		…
716	}	769	}
717		770
718	void	771	void
719	global::gather_callbacks (AV *&callbacks, event_type event) const	772	global::gather_callbacks (AV *&callbacks, event_type event) const
720	{	773	{
721	::gather_callbacks (callbacks, cb_object, event);	774	::gather_callbacks (callbacks, cb_global, event);
722	}	775	}
723		776
724	void	777	void
725	object::gather_callbacks (AV *&callbacks, event_type event) const	778	object::gather_callbacks (AV *&callbacks, event_type event) const
726	{	779	{
727	if (subtype && type + subtype * NUM_SUBTYPES <= AvFILLp (cb_type))	780	if (subtype && type + subtype * NUM_TYPES <= AvFILLp (cb_type))
728	{	781	{
729	SV *registry = AvARRAY (cb_type)[type + subtype * NUM_SUBTYPES];	782	SV *registry = AvARRAY (cb_type)[type + subtype * NUM_TYPES];
730		783
731	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)	784	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
732	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);	785	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);
733	}	786	}
734		787
…		…
770	{	823	{
771	attachable::gather_callbacks (callbacks, event);	824	attachable::gather_callbacks (callbacks, event);
772	::gather_callbacks (callbacks, cb_map, event);	825	::gather_callbacks (callbacks, cb_map, event);
773	}	826	}
774		827
		828	static void noinline
		829	_recalc_want (bitset<NUM_EVENT_TYPES> &set, AV *registry)
		830	{
		831	for (int event = 0; event <= AvFILLp (registry); ++event)
		832	{
		833	SV *cbs_ = AvARRAY (registry)[event];
		834
		835	// element must be list of callback entries
		836	if (cbs_ && SvROK (cbs_) && SvTYPE (SvRV (cbs_)) == SVt_PVAV)
		837	{
		838	AV *cbs = (AV *)SvRV (cbs_);
		839
		840	// no callback entries, no callbacks to call
		841	if (AvFILLp (cbs) >= 0)
		842	set.set (event);
		843	}
		844	}
		845	}
		846
		847	// very slow and inefficient way to recalculate the global want bitsets
		848	static void
		849	_recalc_want ()
		850	{
		851	ev_want_event.reset ();
		852
		853	_recalc_want (ev_want_event, cb_global);
		854	_recalc_want (ev_want_event, cb_attachable);
		855	_recalc_want (ev_want_event, cb_object);
		856	_recalc_want (ev_want_event, cb_client);
		857	_recalc_want (ev_want_event, cb_player);
		858	_recalc_want (ev_want_event, cb_map);
		859
		860	ev_want_type.reset ();
		861
		862	for (int type = 0; type <= AvFILLp (cb_type); ++type)
		863	{
		864	SV *cbs_ = AvARRAY (cb_type)[type];
		865
		866	// element must be list of callback entries
		867	if (cbs_ && SvROK (cbs_) && SvTYPE (SvRV (cbs_)) == SVt_PVAV)
		868	{
		869	AV *cbs = (AV *)SvRV (cbs_);
		870
		871	// no callback entries, no callbacks to call
		872	if (AvFILLp (cbs) >= 0)
		873	ev_want_type.set (type % NUM_TYPES);
		874	}
		875	}
		876	}
		877
775	bool	878	bool
776	attachable::invoke (event_type event, ...)	879	attachable::invoke (event_type event, ...)
777	{	880	{
778	data_type dt;	881	data_type dt;
779	va_list ap;
780
781	va_start (ap, event);
782		882
783	// callback call ordering should be:	883	// callback call ordering should be:
784	// 1. per-object callback	884	// 1. per-object callback
785	// 2. per-class object	885	// 2. per-class object
786	// 3. per-type callback	886	// 3. per-type callback
…		…
790	gather_callbacks (callbacks, event);	890	gather_callbacks (callbacks, event);
791		891
792	// short-circuit processing if no callbacks found/defined	892	// short-circuit processing if no callbacks found/defined
793	if (!callbacks)	893	if (!callbacks)
794	return 0;	894	return 0;
		895
		896	va_list ap;
		897	va_start (ap, event);
795		898
796	CALL_BEGIN (3);	899	CALL_BEGIN (3);
797	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays	900	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays
798	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));	901	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));
799		902
…		…
823	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));	926	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
824	}	927	}
825		928
826	va_end (ap);	929	va_end (ap);
827		930
828	CALL_CALL ("cf::do_invoke", G_SCALAR);	931	CALL_CALL (cv_cf_do_invoke, G_SCALAR);
829	count = count > 0 ? POPi : 0;	932	count = count > 0 ? POPi : 0;
830		933
831	CALL_END;	934	CALL_END;
832		935
833	return count;	936	return count;
834	}	937	}
835		938
836	SV *	939	SV *
837	cfperl_result (int idx)	940	cfperl_result (int idx)
838	{	941	{
839	AV *av = get_av ("cfperl::invoke_results", 0);	942	AV *av = get_av ("cf::INVOKE_RESULTS", 0);
840	if (!av)	943	if (!av)
841	return &PL_sv_undef;	944	return &PL_sv_undef;
842		945
843	SV **sv = av_fetch (av, idx, 0);	946	SV **sv = av_fetch (av, idx, 0);
844	if (!sv)	947	if (!sv)
…		…
858	{	961	{
859	return SvNV (cfperl_result (idx));	962	return SvNV (cfperl_result (idx));
860	}	963	}
861		964
862	/////////////////////////////////////////////////////////////////////////////	965	/////////////////////////////////////////////////////////////////////////////
		966	// various c++ => perl glue functions
		967
		968	void
		969	cfperl_tick ()
		970	{
		971	tick_pending = 1;
		972
		973	if (tick_inhibit)
		974	return;
		975
		976	tick_pending = 0;
		977
		978	dSP;
		979
		980	PUSHMARK (SP);
		981	PUTBACK;
		982	call_pvsv (cv_cf_tick, G_DISCARD | G_VOID);
		983
		984	SvNV_set (sv_next_tick, get_next_tick ()); SvNOK_only (sv_next_tick);
		985	}
863		986
864	void	987	void
865	cfperl_emergency_save ()	988	cfperl_emergency_save ()
866	{	989	{
867	CALL_BEGIN (0);	990	CALL_BEGIN (0);
…		…
876	CALL_ARG (make_core);	999	CALL_ARG (make_core);
877	CALL_CALL ("cf::post_cleanup", G_VOID);	1000	CALL_CALL ("cf::post_cleanup", G_VOID);
878	CALL_END;	1001	CALL_END;
879	}	1002	}
880		1003
		1004	void
		1005	cfperl_make_book (object *book, int level)
		1006	{
		1007	CALL_BEGIN (2);
		1008	CALL_ARG (book);
		1009	CALL_ARG (level);
		1010	CALL_CALL ("ext::books::make_book", G_VOID);
		1011	CALL_END;
		1012	}
		1013
		1014	void
		1015	cfperl_send_msg (client *ns, int color, const char *type, const char *msg)
		1016	{
		1017	CALL_BEGIN (4);
		1018	CALL_ARG (ns);
		1019	CALL_ARG (type);
		1020	CALL_ARG_SV (newSVpv_utf8 (msg));
		1021	CALL_ARG (color);
		1022	CALL_CALL (cv_cf_client_send_msg, G_VOID);
		1023	CALL_END;
		1024	}
		1025
		1026	int
		1027	cfperl_can_merge (object *ob1, object *ob2)
		1028	{
		1029	int can;
		1030
		1031	CALL_BEGIN (2);
		1032	CALL_ARG (ob1);
		1033	CALL_ARG (ob2);
		1034	CALL_CALL (cv_cf__can_merge, G_SCALAR);
		1035	can = count && SvTRUE (TOPs);
		1036	CALL_END;
		1037
		1038	return can;
		1039	}
		1040
		1041	void
		1042	cfperl_mapscript_activate (object *ob, int state, object *activator, object *originator)
		1043	{
		1044	CALL_BEGIN (4);
		1045	CALL_ARG (ob);
		1046	CALL_ARG (state);
		1047	CALL_ARG (activator);
		1048	CALL_ARG (originator);
		1049	CALL_CALL ("cf::mapscript::activate", G_VOID);
		1050	CALL_END;
		1051	}
		1052
		1053	player *
		1054	player::find (const char *name)
		1055	{
		1056	CALL_BEGIN (1);
		1057	CALL_ARG (name);
		1058	CALL_CALL ("cf::player::find", G_SCALAR);
		1059
		1060	player *retval = 0;
		1061	if (count) sv_to (POPs, retval);
		1062
		1063	CALL_END;
		1064
		1065	return retval;
		1066	}
		1067
		1068	maptile *
		1069	find_style (const char *dirname, const char *stylename, int difficulty)
		1070	{
		1071	CALL_BEGIN (3);
		1072	CALL_ARG (dirname);
		1073	CALL_ARG (stylename);
		1074	CALL_ARG (difficulty);
		1075	CALL_CALL ("ext::map_random::find_style", G_SCALAR);
		1076
		1077	maptile *retval = 0;
		1078	if (count) sv_to (POPs, retval);
		1079
		1080	CALL_END;
		1081
		1082	return retval;
		1083	}
		1084
881	maptile *	1085	maptile *
882	maptile::find_sync (const char *path, maptile *origin)	1086	maptile::find_sync (const char *path, maptile *origin)
883	{	1087	{
884	CALL_BEGIN (2);	1088	CALL_BEGIN (2);
885	CALL_ARG (path);	1089	CALL_ARG (path);
886	CALL_ARG (origin);	1090	CALL_ARG (origin);
887	CALL_CALL ("cf::map::find_sync", G_SCALAR);	1091	CALL_CALL ("cf::map::find_sync", G_SCALAR);
888		1092
889	maptile *retval;	1093	maptile *retval = 0;
890
891	if (count)
892	sv_to (POPs, retval);	1094	if (count) sv_to (POPs, retval);
893	else
894	retval = 0;
895		1095
896	CALL_END;	1096	CALL_END;
897		1097
898	return retval;	1098	return retval;
899	}	1099	}
900		1100
901	maptile *	1101	maptile *
902	maptile::find_async (const char *path, maptile *origin)	1102	maptile::find_async (const char *path, maptile *origin, bool load)
903	{	1103	{
904	CALL_BEGIN (2);	1104	CALL_BEGIN (3);
905	CALL_ARG (path);	1105	CALL_ARG (path);
906	CALL_ARG (origin);	1106	CALL_ARG (origin);
		1107	CALL_ARG (load);
907	CALL_CALL ("cf::map::find_async", G_SCALAR);	1108	CALL_CALL ("cf::map::find_async", G_SCALAR);
908		1109
909	maptile *retval;	1110	maptile *retval = 0;
910
911	if (count)
912	sv_to (POPs, retval);	1111	if (count) sv_to (POPs, retval);
913	else
914	retval = 0;
915		1112
916	CALL_END;	1113	CALL_END;
917		1114
918	return retval;	1115	return retval;
919	}	1116	}
…		…
922	maptile::do_load_sync ()	1119	maptile::do_load_sync ()
923	{	1120	{
924	CALL_BEGIN (1);	1121	CALL_BEGIN (1);
925	CALL_ARG (this);	1122	CALL_ARG (this);
926	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);	1123	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;	1124	CALL_END;
937	}	1125	}
938		1126
939	void	1127	void
940	object::enter_exit (object *exit)	1128	object::enter_exit (object *exit)
…		…
947	CALL_ARG (exit);	1135	CALL_ARG (exit);
948	CALL_CALL ("cf::object::player::enter_exit", G_VOID);	1136	CALL_CALL ("cf::object::player::enter_exit", G_VOID);
949	CALL_END;	1137	CALL_END;
950	}	1138	}
951		1139
		1140	void
		1141	object::player_goto (const char *path, int x, int y)
		1142	{
		1143	if (type != PLAYER)
		1144	return;
		1145
		1146	CALL_BEGIN (4);
		1147	CALL_ARG (this);
		1148	CALL_ARG (path);
		1149	CALL_ARG (x);
		1150	CALL_ARG (y);
		1151	CALL_CALL ("cf::object::player::goto", G_VOID);
		1152	CALL_END;
		1153	}
		1154
		1155	const char *
		1156	object::ref () const
		1157	{
		1158	if (type == PLAYER)
		1159	return format ("player/<1.%llx>/%s", (unsigned long long)uuid.seq, &name);
		1160	else
		1161	return 0;
		1162	}
		1163
		1164	object *
		1165	object::deref (const char *ref)
		1166	{
		1167	object *retval = 0;
		1168
		1169	if (ref)
		1170	{
		1171	CALL_BEGIN (1);
		1172	CALL_ARG (ref);
		1173	CALL_CALL ("cf::object::deref", G_SCALAR);
		1174
		1175	if (count)
		1176	sv_to (POPs, retval);
		1177
		1178	CALL_END;
		1179	}
		1180
		1181	return retval;
		1182	}
		1183
		1184	void
		1185	log_backtrace (const char *msg)
		1186	{
		1187	#if HAVE_BACKTRACE
		1188	void *addr [20];
		1189	int size = backtrace (addr, 20);
		1190
		1191	CALL_BEGIN (size);
		1192	CALL_ARG (msg);
		1193	for (int i = 0; i < size; ++i)
		1194	CALL_ARG ((IV)addr [i]);
		1195	CALL_CALL ("cf::_log_backtrace", G_VOID);
		1196	CALL_END;
		1197	#endif
		1198	}
		1199
		1200	bool
		1201	is_match_expr (const char *expr)
		1202	{
		1203	return !strncmp (expr, "match ", sizeof ("match ") - 1);
		1204	}
		1205
		1206	bool
		1207	match (const char *expr, object *ob, object *self, object *source, object *originator)
		1208	{
		1209	if (!strncmp (expr, "match ", sizeof ("match ") - 1))
		1210	expr += sizeof ("match ") - 1;
		1211
		1212	CALL_BEGIN (5);
		1213	CALL_ARG (expr);
		1214	CALL_ARG (ob);
		1215	CALL_ARG (self);
		1216	CALL_ARG (source);
		1217	CALL_ARG (originator);
		1218	CALL_CALL (cv_cf_match_match, G_SCALAR);
		1219
		1220	bool matched = count && SvTRUE (TOPs);
		1221
		1222	CALL_END;
		1223
		1224	return matched;
		1225	}
		1226
		1227	object *
		1228	match_one (const char *expr, object *ob, object *self, object *source, object *originator)
		1229	{
		1230	if (!strncmp (expr, "match ", sizeof ("match ") - 1))
		1231	expr += sizeof ("match ") - 1;
		1232
		1233	CALL_BEGIN (5);
		1234	CALL_ARG (expr);
		1235	CALL_ARG (ob);
		1236	CALL_ARG (self);
		1237	CALL_ARG (source);
		1238	CALL_ARG (originator);
		1239	CALL_CALL (cv_cf_match_match, G_ARRAY);
		1240
		1241	object *one = 0;
		1242
		1243	if (count)
		1244	sv_to (TOPs, one);
		1245
		1246	CALL_END;
		1247
		1248	return one;
		1249	}
		1250
952	/////////////////////////////////////////////////////////////////////////////	1251	/////////////////////////////////////////////////////////////////////////////
953		1252
954	struct EventAPI *watcher_base::GEventAPI;	1253	struct EVAPI *evapi::GEVAPI;
955	struct CoroAPI *coroapi::GCoroAPI;	1254	struct CoroAPI *coroapi::GCoroAPI;
956		1255
957	int coroapi::cede_counter;	1256	void
958	double (*coroapi::time)();
959	double coroapi::next_cede;
960
961	void coroapi::do_cede_to_tick ()	1257	coroapi::do_cede_to_tick ()
962	{	1258	{
963	cede_counter = 0;	1259	cede_pending = 0;
964
965	cede ();	1260	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	}	1261	}
986		1262
987	void	1263	void
988	coroapi::wait_for_tick ()	1264	coroapi::wait_for_tick ()
989	{	1265	{
…		…
998	CALL_BEGIN (0);	1274	CALL_BEGIN (0);
999	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);	1275	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);
1000	CALL_END;	1276	CALL_END;
1001	}	1277	}
1002		1278
		1279	void
		1280	iow::poll (int events)
		1281	{
		1282	if (events != this->events)
		1283	{
		1284	int active = ev_is_active ((ev_io *)this);
		1285	if (active) stop ();
		1286	ev_io_set ((ev_io *)this, fd, events);
		1287	if (active) start ();
		1288	}
		1289	}
		1290
1003	static void	1291	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 ()	1292	_connect_to_perl_1 ()
1064	{	1293	{
1065	stash_cf = gv_stashpv ("cf" , 1);	1294	stash_cf = gv_stashpv ("cf", 1);
1066		1295
1067	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);	1296	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);
1068	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);	1297	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);
1069	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);	1298	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);
1070	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);	1299	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);
		1300	stash_cf_mapspace_wrap = gv_stashpv ("cf::mapspace::wrap" , 1);
1071	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);	1301	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);
1072	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);	1302	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
1073	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);	1303	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
1074	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);	1304	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
1075	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);	1305	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
1076		1306
		1307	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);	1308	sv_runtime = get_sv ("cf::RUNTIME" , 1); SvUPGRADE (sv_runtime , SVt_NV);
		1309	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);	1310	sv_next_tick = get_sv ("cf::NEXT_TICK" , 1); SvUPGRADE (sv_next_tick , SVt_NV);
1079		1311
1080	cb_global = get_av ("cf::CB_GLOBAL", 1);	1312	cb_global = get_av ("cf::CB_GLOBAL", 1);
1081	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);	1313	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
1082	cb_object = get_av ("cf::CB_OBJECT", 1);	1314	cb_object = get_av ("cf::CB_OBJECT", 1);
1083	cb_player = get_av ("cf::CB_PLAYER", 1);	1315	cb_player = get_av ("cf::CB_PLAYER", 1);
1084	cb_client = get_av ("cf::CB_CLIENT", 1);	1316	cb_client = get_av ("cf::CB_CLIENT", 1);
1085	cb_type = get_av ("cf::CB_TYPE" , 1);	1317	cb_type = get_av ("cf::CB_TYPE" , 1);
1086	cb_map = get_av ("cf::CB_MAP" , 1);	1318	cb_map = get_av ("cf::CB_MAP" , 1);
1087	}	1319	}
1088		1320
		1321	static void
		1322	_connect_to_perl_2 ()
		1323	{
		1324	cv_cf_do_invoke = (SV *)get_cv ("cf::do_invoke" , 0); assert (cv_cf_do_invoke);
		1325	cv_cf__can_merge = (SV *)get_cv ("cf::_can_merge" , 0); assert (cv_cf__can_merge);
		1326	cv_cf_client_send_msg = (SV *)get_cv ("cf::client::send_msg", 0); assert (cv_cf_client_send_msg);
		1327	cv_cf_tick = (SV *)get_cv ("cf::tick" , 0); assert (cv_cf_tick);
		1328	cv_cf_match_match = (SV *)get_cv ("cf::match::match" , 0); assert (cv_cf_match_match);
		1329	}
		1330
1089	MODULE = cf PACKAGE = cf PREFIX = cf_	1331	MODULE = cf PACKAGE = cf PREFIX = cf_
1090		1332
1091	BOOT:	1333	BOOT:
1092	{	1334	{
1093	I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;	1335	I_EV_API (PACKAGE); evapi::GEVAPI = GEVAPI;
1094	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;	1336	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
1095		1337
1096	_connect_to_perl ();	1338	_connect_to_perl_1 ();
1097		1339
1098	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));	1340	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
1099		1341
1100	{	1342	//{
1101	require_pv ("Time::HiRes");	1343	// require_pv ("Time::HiRes");
1102		1344	//
1103	SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);	1345	// SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
1104	if (!svp) croak ("Time::HiRes is required");	1346	// if (!svp) croak ("Time::HiRes is required");
1105	if (!SvIOK(*svp)) croak ("Time::NVtime isn’t a function pointer");	1347	// if (!SvIOK(*svp)) croak ("Time::NVtime isn’t a function pointer");
1106	coroapi::time = INT2PTR (double(*)(), SvIV(*svp));	1348	// coroapi::time = INT2PTR (double(*)(), SvIV(*svp));
1107	}	1349	//}
1108		1350
1109	static const struct {	1351	static const struct {
1110	const char *name;	1352	const char *name;
1111	IV iv;	1353	IV iv;
1112	} *civ, const_iv[] = {	1354	} *civ, const_iv[] = {
1113	# define const_iv(name) { # name, (IV)name },	1355	# define const_iv(name) { # name, (IV)name },
1114	const_iv (llevError) const_iv (llevInfo) const_iv (llevDebug) const_iv (llevMonster)	1356	const_iv (llevError) const_iv (llevInfo) const_iv (llevDebug) const_iv (llevMonster)
		1357	const_iv (logBacktrace)
1115		1358
1116	const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)	1359	const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)
1117		1360
1118	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)	1361	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)
1119		1362
1120	const_iv (MAX_TIME)	1363	const_iv (MAX_TIME)
		1364	const_iv (MAXSOCKBUF)
		1365
		1366	const_iv (NUM_BODY_LOCATIONS)
		1367	const_iv (body_range) const_iv (body_shield) const_iv (body_combat)
		1368	const_iv (body_arm) const_iv (body_torso) const_iv (body_head)
		1369	const_iv (body_neck) const_iv (body_skill) const_iv (body_finger)
		1370	const_iv (body_shoulder) const_iv (body_foot) const_iv (body_hand)
		1371	const_iv (body_wrist) const_iv (body_waist)
1121		1372
1122	const_iv (PLAYER) const_iv (TRANSPORT) const_iv (ROD) const_iv (TREASURE)	1373	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)	1374	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)	1375	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)	1376	const_iv (ARMOUR) const_iv (PEDESTAL) const_iv (ALTAR) const_iv (LOCKED_DOOR)
…		…
1136	const_iv (MOOD_FLOOR) const_iv (EXIT) const_iv (ENCOUNTER) const_iv (SHOP_FLOOR)	1387	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)	1388	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)	1389	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)	1390	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)	1391	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)	1392	const_iv (T_HANDLE) const_iv (HOLE) const_iv (TRAPDOOR) const_iv (SIGN)
1142	const_iv (BOOTS) const_iv (GLOVES) const_iv (SPELL) const_iv (SPELL_EFFECT)	1393	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)	1394	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)	1395	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)	1396	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)	1397	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)	1398	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)	1399	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)	1400	const_iv (SYMPTOM) const_iv (BUILDER) const_iv (MATERIAL) const_iv (ITEM_TRANSFORMER)
		1401	const_iv (MAPSCRIPT) const_iv (SAFE_GROUND)
1150		1402
1151	const_iv (NUM_SUBTYPES)	1403	const_iv (NUM_TYPES) const_iv (NUM_SUBTYPES)
1152		1404
1153	const_iv (ST_BD_BUILD) const_iv (ST_BD_REMOVE)	1405	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)	1406	const_iv (ST_MAT_FLOOR) const_iv (ST_MAT_WALL) const_iv (ST_MAT_ITEM)
1155		1407
1156	const_iv (AT_PHYSICAL) const_iv (AT_MAGIC) const_iv (AT_FIRE) const_iv (AT_ELECTRICITY)	1408	const_iv (AT_PHYSICAL) const_iv (AT_MAGIC) const_iv (AT_FIRE) const_iv (AT_ELECTRICITY)
…		…
1164	const_iv (WEAP_HIT) const_iv (WEAP_SLASH) const_iv (WEAP_PIERCE) const_iv (WEAP_CLEAVE)	1416	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)	1417	const_iv (WEAP_SLICE) const_iv (WEAP_STAB) const_iv (WEAP_WHIP) const_iv (WEAP_CRUSH)
1166	const_iv (WEAP_BLUD)	1418	const_iv (WEAP_BLUD)
1167		1419
1168	const_iv (FLAG_ALIVE) const_iv (FLAG_WIZ) const_iv (FLAG_REMOVED) const_iv (FLAG_FREED)	1420	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)	1421	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)	1422	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)	1423	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)	1424	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)	1425	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)	1426	const_iv (FLAG_SPLITTING) const_iv (FLAG_HITBACK) const_iv (FLAG_STARTEQUIP) const_iv (FLAG_BLOCKSVIEW)
…		…
1184	const_iv (FLAG_CURSED) const_iv (FLAG_DAMNED) const_iv (FLAG_SEE_ANYWHERE) const_iv (FLAG_KNOWN_MAGICAL)	1436	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)	1437	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)	1438	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)	1439	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)	1440	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)	1441	const_iv (FLAG_NO_STEAL) const_iv (FLAG_ONE_HIT) const_iv (FLAG_DEBUG) const_iv (FLAG_BERSERK)
1190	const_iv (FLAG_NEUTRAL) const_iv (FLAG_NO_ATTACK) const_iv (FLAG_NO_DAMAGE) const_iv (FLAG_OBJ_ORIGINAL)	1442	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)	1443	const_iv (FLAG_ACTIVATE_ON_PUSH) const_iv (FLAG_ACTIVATE_ON_RELEASE) const_iv (FLAG_IS_WATER) const_iv (FLAG_WIZLOOK)
1192	const_iv (FLAG_CONTENT_ON_GEN) const_iv (FLAG_IS_A_TEMPLATE) const_iv (FLAG_IS_BUILDABLE)	1444	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)	1445	const_iv (FLAG_DESTROY_ON_DEATH) const_iv (FLAG_NO_MAP_SAVE)
1194		1446
1195	const_iv (NDI_BLACK) const_iv (NDI_WHITE) const_iv (NDI_NAVY) const_iv (NDI_RED)	1447	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)	1448	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)	1449	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)	1450	const_iv (NDI_TAN) const_iv (NDI_MAX_COLOR) const_iv (NDI_COLOR_MASK) const_iv (NDI_UNIQUE)
1199	const_iv (NDI_ALL)	1451	const_iv (NDI_ALL) const_iv (NDI_DEF) const_iv (NDI_REPLY) const_iv (NDI_CLIENT_MASK)
		1452	const_iv (NDI_NOCREATE) const_iv (NDI_CLEAR) const_iv (NDI_VERBATIM)
1200		1453
1201	const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE)	1454	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)	1455	const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF)
1203		1456
1204	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_DAMAGE)	1457	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_DAMAGE)
		1458
		1459	const_iv (SP_RAISE_DEAD)
		1460	const_iv (SP_RUNE)
		1461	const_iv (SP_MAKE_MARK)
		1462	const_iv (SP_BOLT)
		1463	const_iv (SP_BULLET)
		1464	const_iv (SP_EXPLOSION)
		1465	const_iv (SP_CONE)
		1466	const_iv (SP_BOMB)
		1467	const_iv (SP_WONDER)
		1468	const_iv (SP_SMITE)
		1469	const_iv (SP_MAGIC_MISSILE)
		1470	const_iv (SP_SUMMON_GOLEM)
		1471	const_iv (SP_DIMENSION_DOOR)
		1472	const_iv (SP_MAGIC_MAPPING)
		1473	const_iv (SP_MAGIC_WALL)
		1474	const_iv (SP_DESTRUCTION)
		1475	const_iv (SP_PERCEIVE_SELF)
		1476	const_iv (SP_WORD_OF_RECALL)
		1477	const_iv (SP_INVISIBLE)
		1478	const_iv (SP_PROBE)
		1479	const_iv (SP_HEALING)
		1480	const_iv (SP_CREATE_FOOD)
		1481	const_iv (SP_EARTH_TO_DUST)
		1482	const_iv (SP_CHANGE_ABILITY)
		1483	const_iv (SP_BLESS)
		1484	const_iv (SP_CURSE)
		1485	const_iv (SP_SUMMON_MONSTER)
		1486	const_iv (SP_CHARGING)
		1487	const_iv (SP_POLYMORPH)
		1488	const_iv (SP_ALCHEMY)
		1489	const_iv (SP_REMOVE_CURSE)
		1490	const_iv (SP_IDENTIFY)
		1491	const_iv (SP_DETECTION)
		1492	const_iv (SP_MOOD_CHANGE)
		1493	const_iv (SP_MOVING_BALL)
		1494	const_iv (SP_SWARM)
		1495	const_iv (SP_CHANGE_MANA)
		1496	const_iv (SP_DISPEL_RUNE)
		1497	const_iv (SP_CREATE_MISSILE)
		1498	const_iv (SP_CONSECRATE)
		1499	const_iv (SP_ANIMATE_WEAPON)
		1500	const_iv (SP_LIGHT)
		1501	const_iv (SP_CHANGE_MAP_LIGHT)
		1502	const_iv (SP_FAERY_FIRE)
		1503	const_iv (SP_CAUSE_DISEASE)
		1504	const_iv (SP_AURA)
		1505	const_iv (SP_TOWN_PORTAL)
		1506	const_iv (SP_PARTY_SPELL)
1205		1507
1206	const_iv (F_APPLIED) const_iv (F_LOCATION) const_iv (F_UNPAID) const_iv (F_MAGIC)	1508	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)	1509	const_iv (F_CURSED) const_iv (F_DAMNED) const_iv (F_OPEN) const_iv (F_NOPICK)
1208	const_iv (F_LOCKED)	1510	const_iv (F_LOCKED)
1209		1511
1210	const_iv (F_BUY) const_iv (F_SHOP) const_iv (F_SELL)	1512	const_iv (F_BUY) const_iv (F_SHOP) const_iv (F_SELL)
1211		1513
1212	const_iv (P_BLOCKSVIEW) const_iv (P_PLAYER) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE)	1514	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)	1515	const_iv (P_NO_CLERIC) const_iv (P_OUT_OF_MAP) const_iv (P_NEW_MAP) const_iv (P_UPTODATE)
1214		1516
1215	const_iv (UP_OBJ_INSERT) const_iv (UP_OBJ_REMOVE) const_iv (UP_OBJ_CHANGE) const_iv (UP_OBJ_FACE)	1517	const_iv (UP_OBJ_INSERT) const_iv (UP_OBJ_REMOVE) const_iv (UP_OBJ_CHANGE) const_iv (UP_OBJ_FACE)
1216		1518
1217	const_iv (INS_NO_MERGE) const_iv (INS_ABOVE_FLOOR_ONLY) const_iv (INS_NO_WALK_ON)	1519	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)	1520	const_iv (INS_ON_TOP) const_iv (INS_BELOW_ORIGINATOR)
1219		1521
1220	const_iv (WILL_APPLY_HANDLE) const_iv (WILL_APPLY_TREASURE) const_iv (WILL_APPLY_EARTHWALL)	1522	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)	1523	const_iv (WILL_APPLY_DOOR) const_iv (WILL_APPLY_FOOD)
1222		1524
1223	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)	1525	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)
…		…
1257	const_iv (ATNR_PARALYZE) const_iv (ATNR_TURN_UNDEAD) const_iv (ATNR_FEAR) const_iv (ATNR_CANCELLATION)	1559	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)	1560	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)	1561	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)	1562	const_iv (ATNR_LIFE_STEALING) const_iv (ATNR_DISEASE)
1261		1563
1262	const_iv (MAP_IN_MEMORY) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)	1564	const_iv (MAP_ACTIVE) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)
		1565	const_iv (MAP_INACTIVE)
1263		1566
1264	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)	1567	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)	1568	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)
1266		1569
		1570	const_iv (VERSION_CS) const_iv (VERSION_SC)
		1571
1267	const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)	1572	const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)
1268		1573
1269	const_iv (ST_DEAD) const_iv (ST_SETUP) const_iv (ST_PLAYING) const_iv (ST_CUSTOM)	1574	const_iv (ST_DEAD) const_iv (ST_SETUP) const_iv (ST_PLAYING) const_iv (ST_CUSTOM)
1270
1271	const_iv (ST_CHANGE_CLASS)
1272		1575
1273	const_iv (IO_HEADER) const_iv (IO_OBJECTS) const_iv (IO_UNIQUES)	1576	const_iv (IO_HEADER) const_iv (IO_OBJECTS) const_iv (IO_UNIQUES)
1274		1577
1275	// random map generator	1578	// random map generator
1276	const_iv (LAYOUT_NONE) const_iv (LAYOUT_ONION) const_iv (LAYOUT_MAZE) const_iv (LAYOUT_SPIRAL)	1579	const_iv (LAYOUT_NONE) const_iv (LAYOUT_ONION) const_iv (LAYOUT_MAZE) const_iv (LAYOUT_SPIRAL)
…		…
1280	const_iv (RMOPT_BOTTOM_C) const_iv (RMOPT_BOTTOM_R) const_iv (RMOPT_IRR_SPACE)	1583	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)	1584	const_iv (RMOPT_WALL_OFF) const_iv (RMOPT_WALLS_ONLY) const_iv (RMOPT_NO_DOORS)
1282		1585
1283	const_iv (SYMMETRY_RANDOM) const_iv (SYMMETRY_NONE) const_iv (SYMMETRY_X)	1586	const_iv (SYMMETRY_RANDOM) const_iv (SYMMETRY_NONE) const_iv (SYMMETRY_X)
1284	const_iv (SYMMETRY_Y) const_iv (SYMMETRY_XY)	1587	const_iv (SYMMETRY_Y) const_iv (SYMMETRY_XY)
		1588
		1589	const_iv (GT_ENVIRONMENT) const_iv (GT_INVISIBLE) const_iv (GT_STARTEQUIP)
		1590	const_iv (GT_APPLY) const_iv (GT_ONLY_GOOD) const_iv (GT_MINIMAL)
		1591
		1592	const_iv (FT_FACE) const_iv (FT_MUSIC) const_iv (FT_SOUND)
		1593	const_iv (FT_RSRC) const_iv (FT_NUM)
1285	};	1594	};
1286		1595
1287	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	1596	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1288	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));	1597	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1289		1598
…		…
1306	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));	1615	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));
1307	av_push (event, newSViv (eiv->klass));	1616	av_push (event, newSViv (eiv->klass));
1308	av_store (av, eiv->iv, newRV_noinc ((SV *)event));	1617	av_store (av, eiv->iv, newRV_noinc ((SV *)event));
1309	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));	1618	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));
1310	}	1619	}
1311	}
1312		1620
		1621	// used by autogenerated BOOT sections from genacc
		1622	av_reflect = get_av ("cf::REFLECT", 1);
		1623	}
		1624
		1625	void _gv_clear (SV *gv)
		1626	CODE:
		1627	assert (SvTYPE (gv) == SVt_PVGV);
		1628	# define f(sv) { SV *sv_ = (SV *)(sv); sv = 0; SvREFCNT_dec (sv_); }
		1629	f (GvGP (gv)->gp_form);
		1630	f (GvGP (gv)->gp_io);
		1631	f (GvGP (gv)->gp_sv);
		1632	f (GvGP (gv)->gp_av);
		1633	f (GvGP (gv)->gp_hv);
		1634	f (GvGP (gv)->gp_cv);
		1635	GvCVGEN (gv) = 0;
		1636	GvMULTI_off (gv);
		1637	# undef f
		1638
1313	void _connect_to_perl ()	1639	void _connect_to_perl_1 ()
1314		1640
		1641	void _connect_to_perl_2 ()
		1642
		1643	void _recalc_want ()
		1644
		1645	# not used by default anymore
1315	void _global_reattach ()	1646	void _global_reattach ()
1316	CODE:	1647	CODE:
1317	{	1648	{
1318	// reattach to all attachable objects in the game.	1649	// reattach to all attachable objects in the game.
1319	for_all_clients (ns)	1650	for_all_clients (ns)
1320	ns->reattach ();	1651	ns->reattach ();
1321		1652
1322	for_all_objects (op)	1653	for_all_objects (op)
1323	op->reattach ();	1654	op->reattach ();
1324	}	1655	}
1325
1326	void _post_tick ()
1327	CODE:
1328	coroapi::next_cede = SvNV (sv_next_tick) - TICK * (1. - 1. / CEDES_PER_TICK);
1329		1656
1330	# support function for map-world.ext	1657	# support function for map-world.ext
1331	void _quantise (SV *data_sv, SV *plt_sv)	1658	void _quantise (SV *data_sv, SV *plt_sv)
1332	CODE:	1659	CODE:
1333	{	1660	{
…		…
1367	}	1694	}
1368		1695
1369	SvCUR_set (data_sv, dst - SvPVX (data_sv));	1696	SvCUR_set (data_sv, dst - SvPVX (data_sv));
1370	}	1697	}
1371		1698
		1699	void init_anim ()
		1700
		1701	void init_globals ()
		1702
		1703	void init_experience ()
		1704
		1705	void init_attackmess ()
		1706
		1707	void init_dynamic ()
		1708
		1709	void load_settings ()
		1710
		1711	void load_materials ()
		1712
		1713	void init_uuid ()
		1714	CODE:
		1715	UUID::init ();
		1716
		1717	void init_signals ()
		1718
		1719	void init_commands ()
		1720
		1721	void init_skills ()
		1722
		1723	void init_beforeplay ()
		1724
		1725	void evthread_start (int aiofd)
		1726
		1727	void cede_to_tick ()
		1728	CODE:
		1729	coroapi::cede_to_tick ();
		1730
		1731	NV till_tick ()
		1732	CODE:
		1733	RETVAL = SvNVX (sv_next_tick) - now ();
		1734	OUTPUT:
		1735	RETVAL
		1736
		1737	int tick_inhibit ()
		1738	CODE:
		1739	RETVAL = tick_inhibit;
		1740	OUTPUT:
		1741	RETVAL
		1742
		1743	void tick_inhibit_inc ()
		1744	CODE:
		1745	++tick_inhibit;
		1746
		1747	void tick_inhibit_dec ()
		1748	CODE:
		1749	if (!--tick_inhibit)
		1750	if (tick_pending)
		1751	{
		1752	ev_async_send (EV_DEFAULT, &tick_watcher);
		1753	coroapi::cede ();
		1754	}
		1755
		1756	void server_tick ()
		1757	CODE:
		1758	{
		1759	NOW = ev_now (EV_DEFAULT);
		1760	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1761	SvNV_set (sv_tick_start, NOW); SvNOK_only (sv_tick_start);
		1762	runtime = SvNVX (sv_runtime);
		1763
		1764	server_tick ();
		1765
		1766	NOW = ev_time ();
		1767	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1768	runtime += TICK;
		1769	SvNV_set (sv_runtime, runtime); SvNOK_only (sv_runtime);
		1770	}
		1771
1372	NV floor (NV x)	1772	NV floor (NV x)
1373		1773
1374	NV ceil (NV x)	1774	NV ceil (NV x)
1375		1775
1376	NV rndm (...)	1776	NV rndm (...)
		1777	ALIAS:
		1778	rmg_rndm = 1
1377	CODE:	1779	CODE:
		1780	{
		1781	rand_gen &gen = ix ? rmg_rndm : rndm;
1378	switch (items)	1782	switch (items)
1379	{	1783	{
1380	case 0: RETVAL = rndm (); break;	1784	case 0: RETVAL = gen (); break;
1381	case 1: RETVAL = rndm (SvUV (ST (0))); break;	1785	case 1: RETVAL = gen (SvUV (ST (0))); break;
1382	case 2: RETVAL = rndm (SvIV (ST (0)), SvIV (ST (1))); break;	1786	case 2: RETVAL = gen (SvIV (ST (0)), SvIV (ST (1))); break;
1383	default: croak ("cf::rndm requires none, one or two parameters."); break;	1787	default: croak ("cf::rndm requires none, one or two parameters."); break;
1384	}	1788	}
		1789	}
1385	OUTPUT:	1790	OUTPUT:
1386	RETVAL	1791	RETVAL
1387		1792
1388	void server_tick ()	1793	NV clamp (NV value, NV min_value, NV max_value)
1389	CODE:	1794	CODE:
1390	runtime = SvNVx (sv_runtime);	1795	RETVAL = clamp (value, min_value, max_value);
1391	server_tick ();	1796	OUTPUT:
		1797	RETVAL
1392		1798
		1799	NV lerp (NV value, NV min_in, NV max_in, NV min_out, NV max_out)
		1800	CODE:
		1801	RETVAL = lerp (value, min_in, max_in, min_out, max_out);
		1802	OUTPUT:
		1803	RETVAL
		1804
		1805	void weaken (...)
		1806	PROTOTYPE: @
		1807	CODE:
		1808	while (items > 0)
		1809	sv_rvweaken (ST (--items));
		1810
1393	void	1811	void
		1812	log_backtrace (utf8_string msg)
		1813
		1814	void
1394	LOG (int level, utf8_string msg)	1815	LOG (int flags, utf8_string msg)
1395	PROTOTYPE: $$	1816	PROTOTYPE: $$
1396	C_ARGS: (LogLevel)level, "%s", msg	1817	C_ARGS: flags, "%s", msg
1397		1818
1398	octet_string path_combine (octet_string base, octet_string path)	1819	octet_string path_combine (octet_string base, octet_string path)
1399	PROTOTYPE: $$	1820	PROTOTYPE: $$
1400		1821
1401	octet_string path_combine_and_normalize (octet_string base, octet_string path)	1822	octet_string path_combine_and_normalize (octet_string base, octet_string path)
1402	PROTOTYPE: $$	1823	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		1824
1412	void	1825	void
1413	sub_generation_inc ()	1826	sub_generation_inc ()
1414	CODE:	1827	CODE:
1415	PL_sub_generation++;	1828	PL_sub_generation++;
…		…
1438	}	1851	}
1439	OUTPUT: RETVAL	1852	OUTPUT: RETVAL
1440		1853
1441	void abort ()	1854	void abort ()
1442		1855
		1856	void reset_signals ()
		1857
1443	void fork_abort (octet_string cause = "cf::fork_abort")	1858	void fork_abort (const_octet_string cause = "cf::fork_abort")
1444		1859
1445	void cleanup (octet_string cause, bool make_core = false)	1860	void cleanup (const_octet_string cause, bool make_core = false)
1446		1861
1447	void emergency_save ()	1862	void emergency_save ()
1448		1863
1449	void _exit (int status = EXIT_SUCCESS)	1864	void _exit (int status = EXIT_SUCCESS)
1450		1865
1451	UV sv_2watcher (SV *w)
1452	CODE:
1453	RETVAL = (UV)GEventAPI->sv_2watcher (w);
1454	OUTPUT:
1455	RETVAL
1456
1457	#if _POSIX_MEMLOCK	1866	#if _POSIX_MEMLOCK
1458		1867
1459	int mlockall (int flags = MCL_CURRENT | MCL_FUTURE)	1868	int mlockall (int flags = MCL_CURRENT | MCL_FUTURE)
		1869	INIT:
		1870	#if __GLIBC__
		1871	mallopt (M_TOP_PAD, 1024 * 1024);
		1872	mallopt (M_MMAP_THRESHOLD, 1024 * 1024 * 128);
		1873	mallopt (M_MMAP_MAX, 0); // likely bug-workaround, also frees memory
		1874	mallopt (M_PERTURB, 0xee); // bug-workaround for linux glibc+mlockall+calloc
		1875	#endif
1460		1876
1461	int munlockall ()	1877	int munlockall ()
1462		1878
1463	#endif	1879	#endif
		1880
		1881	int
		1882	malloc_trim (IV pad = 0)
		1883
		1884	void
		1885	mallinfo ()
		1886	PPCODE:
		1887	{
		1888	#if __GLIBC__
		1889	struct mallinfo mai = mallinfo ();
		1890	EXTEND (SP, 10*2);
		1891	PUSHs (sv_2mortal (newSVpv ("arena" , 0))); PUSHs (sv_2mortal (newSViv (mai.arena)));
		1892	PUSHs (sv_2mortal (newSVpv ("ordblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.ordblks)));
		1893	PUSHs (sv_2mortal (newSVpv ("smblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.smblks)));
		1894	PUSHs (sv_2mortal (newSVpv ("hblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblks)));
		1895	PUSHs (sv_2mortal (newSVpv ("hblkhd" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblkhd)));
		1896	PUSHs (sv_2mortal (newSVpv ("usmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.usmblks)));
		1897	PUSHs (sv_2mortal (newSVpv ("fsmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.fsmblks)));
		1898	PUSHs (sv_2mortal (newSVpv ("uordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.uordblks)));
		1899	PUSHs (sv_2mortal (newSVpv ("fordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.fordblks)));
		1900	PUSHs (sv_2mortal (newSVpv ("keepcost", 0))); PUSHs (sv_2mortal (newSViv (mai.keepcost)));
		1901	#endif
		1902	EXTEND (SP, 5*2);
		1903	PUSHs (sv_2mortal (newSVpv ("slice_alloc", 0))); PUSHs (sv_2mortal (newSVuv (slice_alloc)));
		1904	PUSHs (sv_2mortal (newSVpv ("shstr_alloc", 0))); PUSHs (sv_2mortal (newSVuv (shstr_alloc)));
		1905	PUSHs (sv_2mortal (newSVpv ("objects" , 0))); PUSHs (sv_2mortal (newSVuv (objects.size () * sizeof (object))));
		1906	PUSHs (sv_2mortal (newSVpv ("sv_count" , 0))); PUSHs (sv_2mortal (newSVuv (PL_sv_count)));
		1907	PUSHs (sv_2mortal (newSVpv ("sv_objcount", 0))); PUSHs (sv_2mortal (newSVuv (PL_sv_objcount)));
		1908	}
1464		1909
1465	int find_animation (utf8_string text)	1910	int find_animation (utf8_string text)
1466	PROTOTYPE: $	1911	PROTOTYPE: $
1467		1912
1468	int random_roll (int min, int max, object *op, int goodbad);	1913	int random_roll (int min, int max, object *op, int goodbad);
…		…
1506	RETVAL = newSVpv (resist_plus[atnr], 0);	1951	RETVAL = newSVpv (resist_plus[atnr], 0);
1507	else	1952	else
1508	XSRETURN_UNDEF;	1953	XSRETURN_UNDEF;
1509	OUTPUT: RETVAL	1954	OUTPUT: RETVAL
1510		1955
		1956	UUID
		1957	uuid_cur ()
		1958	CODE:
		1959	RETVAL = UUID::cur;
		1960	OUTPUT:
		1961	RETVAL
		1962
		1963	UUID
		1964	uuid_gen ()
		1965	CODE:
		1966	RETVAL = UUID::gen ();
		1967	OUTPUT:
		1968	RETVAL
		1969
		1970	val64
		1971	uuid_seq (UUID uuid)
		1972	CODE:
		1973	RETVAL = uuid.seq;
		1974	OUTPUT:
		1975	RETVAL
		1976
		1977	UUID
		1978	uuid_str (val64 seq)
		1979	CODE:
		1980	RETVAL.seq = seq;
		1981	OUTPUT:
		1982	RETVAL
		1983
		1984	void
		1985	coin_names ()
		1986	PPCODE:
		1987	EXTEND (SP, NUM_COINS);
		1988	for (int i = 0; i < NUM_COINS; ++i)
		1989	PUSHs (sv_2mortal (newSVpv (coins [i], 0)));
		1990
		1991	void
		1992	coin_archetypes ()
		1993	PPCODE:
		1994	EXTEND (SP, NUM_COINS);
		1995	for (int i = 0; i < NUM_COINS; ++i)
		1996	PUSHs (sv_2mortal (to_sv (archetype::find (coins [i]))));
		1997
1511	bool	1998	bool
1512	load_resource_file (octet_string filename)	1999	load_resource_file_ (octet_string filename)
		2000
		2001	void
		2002	fix_weight ()
1513		2003
1514	MODULE = cf PACKAGE = cf::attachable	2004	MODULE = cf PACKAGE = cf::attachable
1515		2005
1516	int	2006	int
1517	valid (SV *obj)	2007	valid (SV *obj)
…		…
1535	#object *mortals (U32 index)	2025	#object *mortals (U32 index)
1536	# CODE:	2026	# CODE:
1537	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;	2027	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;
1538	# OUTPUT: RETVAL	2028	# OUTPUT: RETVAL
1539		2029
1540	INCLUDE: $PERL $srcdir/genacc attachable ../include/cfperl.h |	2030	INCLUDE: $PERL $srcdir/genacc attachable ../include/util.h ../include/cfperl.h |
1541		2031
1542	MODULE = cf PACKAGE = cf::global	2032	MODULE = cf PACKAGE = cf::global
1543		2033
1544	int invoke (SV *klass, int event, ...)	2034	int invoke (SV *klass, int event, ...)
1545	CODE:	2035	CODE:
…		…
1581	object *actives (U32 index)	2071	object *actives (U32 index)
1582	CODE:	2072	CODE:
1583	RETVAL = index < actives.size () ? actives [index] : 0;	2073	RETVAL = index < actives.size () ? actives [index] : 0;
1584	OUTPUT: RETVAL	2074	OUTPUT: RETVAL
1585		2075
		2076	int mortals_size ()
		2077	CODE:
		2078	RETVAL = attachable::mortals.size ();
		2079	OUTPUT: RETVAL
		2080
		2081	const char *slot_use_name (U32 slot)
		2082	ALIAS:
		2083	slot_nonuse_name = 1
		2084	CODE:
		2085	{
		2086	if (slot >= NUM_BODY_LOCATIONS)
		2087	croak ("body slot index out of range");
		2088
		2089	switch (ix)
		2090	{
		2091	case 0: RETVAL = body_locations[slot].use_name; break;
		2092	case 1: RETVAL = body_locations[slot].nonuse_name; break;
		2093	}
		2094	}
		2095	OUTPUT:
		2096	RETVAL
		2097
1586	# missing properties	2098	# missing properties
1587		2099
1588	object *head (object *op)	2100	object *head (object *op)
1589	PROTOTYPE: $	2101	PROTOTYPE: $
1590	CODE:	2102	CODE:
1591	RETVAL = op->head_ ();	2103	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	2104	OUTPUT: RETVAL
1599		2105
1600	void	2106	void
1601	inv (object *obj)	2107	inv (object *obj)
1602	PROTOTYPE: $	2108	PROTOTYPE: $
1603	PPCODE:	2109	PPCODE:
1604	{	2110	{
1605	object *o;
1606	for (o = obj->inv; o; o = o->below)	2111	for (object *o = obj->inv; o; o = o->below)
1607	XPUSHs (sv_2mortal (to_sv (o)));	2112	XPUSHs (sv_2mortal (to_sv (o)));
1608	}	2113	}
1609		2114
1610	void	2115	void
1611	set_animation (object *op, int idx)	2116	set_animation (object *op, int idx)
…		…
1616	num_animations (object *op)	2121	num_animations (object *op)
1617	CODE:	2122	CODE:
1618	RETVAL = NUM_ANIMATIONS (op);	2123	RETVAL = NUM_ANIMATIONS (op);
1619	OUTPUT: RETVAL	2124	OUTPUT: RETVAL
1620		2125
		2126	int slot_info (object *op, UV slot, int value = 0)
		2127	ALIAS:
		2128	slot_used = 1
		2129	CODE:
		2130	{
		2131	if (slot >= NUM_BODY_LOCATIONS)
		2132	croak ("body slot index out of range");
		2133
		2134	RETVAL = ix ? op->slot[slot].used : op->slot[slot].info;
		2135
		2136	if (items > 2)
		2137	if (ix)
		2138	op->slot[slot].used = value;
		2139	else
		2140	op->slot[slot].info = value;
		2141	}
		2142	OUTPUT:
		2143	RETVAL
		2144
1621	object *find_best_object_match (object *op, utf8_string match)	2145	object *find_best_object_match (object *op, utf8_string match)
1622		2146
1623	object *find_marked_object (object *op)	2147	object *find_marked_object (object *op)
1624		2148
1625	int need_identify (object *obj);	2149	int need_identify (object *obj);
1626		2150
1627	int apply_shop_mat (object *shop_mat, object *op);	2151	int apply_shop_mat (object *shop_mat, object *op);
1628
1629	int move_player (object *op, int dir)
1630	CODE:
1631	RETVAL = move_player (op, dir);
1632	OUTPUT:
1633	RETVAL
1634		2152
1635	int move (object *op, int dir, object *originator = op)	2153	int move (object *op, int dir, object *originator = op)
1636	CODE:	2154	CODE:
1637	RETVAL = move_ob (op, dir, originator);	2155	RETVAL = move_ob (op, dir, originator);
1638	OUTPUT:	2156	OUTPUT:
…		…
1646	CODE:	2164	CODE:
1647	player_apply_below (op);	2165	player_apply_below (op);
1648		2166
1649	int cast_heal (object *op, object *caster, object *spell, int dir = 0)	2167	int cast_heal (object *op, object *caster, object *spell, int dir = 0)
1650		2168
1651	object *cf_object_present_archname_inside (object *op, utf8_string whatstr)	2169	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		2170
1669	int pay_item (object *op, object *buyer)	2171	int pay_item (object *op, object *buyer)
1670	CODE:	2172	CODE:
1671	RETVAL = pay_for_item (op, buyer);	2173	RETVAL = pay_for_item (op, buyer);
1672	OUTPUT: RETVAL	2174	OUTPUT: RETVAL
…		…
1707		2209
1708	void drop (object *who, object *op)	2210	void drop (object *who, object *op)
1709		2211
1710	void pick_up (object *who, object *op)	2212	void pick_up (object *who, object *op)
1711		2213
1712	int cf_object_teleport (object *op, maptile *map, int x, int y)
1713
1714	void update_object (object *op, int action)	2214	void update_object (object *op, int action)
1715		2215
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)	2216	void change_exp (object *op, uint64 exp, utf8_string skill_name = 0, int flag = 0)
1719		2217
1720	void player_lvl_adj (object *who, object *skill = 0)	2218	void player_lvl_adj (object *who, object *skill = 0)
1721		2219
1722	int kill_object (object *op, int dam = 0, object *hitter = 0, int type = AT_PHYSICAL)	2220	int kill_object (object *op, int dam = 0, object *hitter = 0, int type = AT_PHYSICAL)
1723		2221
1724	int calc_skill_exp (object *who, object *op, object *skill);	2222	int calc_skill_exp (object *who, object *op, object *skill);
1725		2223
1726	void push_button (object *op);	2224	void push_button (object *op, object *originator);
1727		2225
1728	void use_trigger (object *op);	2226	void use_trigger (object *op, object *originator);
1729		2227
1730	void add_button_link (object *button, maptile *map, int connected);	2228	void handle_apply_yield (object *op);
1731		2229
1732	void remove_button_link (object *op);	2230	int convert_item (object *item, object *converter);
1733		2231
1734		2232
1735	MODULE = cf PACKAGE = cf::object PREFIX = cf_	2233	MODULE = cf PACKAGE = cf::object PREFIX = cf_
1736
1737	object *cf_insert_ob_in_ob (object *ob, object *where)
1738		2234
1739	# no clean way to get an object from an archetype - stupid idiotic	2235	# no clean way to get an object from an archetype - stupid idiotic
1740	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.	2236	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.
1741		2237
1742	object *new (utf8_string archetype = 0)	2238	object *new (utf8_string archetype = 0)
1743	PROTOTYPE: ;$	2239	PROTOTYPE: ;$
1744	CODE:	2240	CODE:
1745	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();	2241	RETVAL = archetype ? get_archetype (archetype) : object::create ();
1746	OUTPUT:	2242	OUTPUT:
1747	RETVAL	2243	RETVAL
1748		2244
		2245	object *find_object (U32 tag)
		2246
		2247	# TODO: nuke
1749	object *insert_ob_in_map_at (object *ob, maptile *where, object_ornull *orig, int flag, int x, int y)	2248	object *insert_ob_in_map_at (object *ob, maptile *where, object_ornull *orig, int flag, int x, int y)
1750	PROTOTYPE: $$$$$$	2249	PROTOTYPE: $$$$$$
1751	CODE:	2250	CODE:
1752	{	2251	{
1753	int unused_type;	2252	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		2253
1757	player *contr (object *op)	2254	if (RETVAL->destroyed ())
1758	CODE:
1759	RETVAL = op->contr;	2255	RETVAL = 0;
1760	OUTPUT: RETVAL	2256	}
1761		2257
1762	const_utf8_string get_ob_key_value (object *op, utf8_string key)	2258	shstr
		2259	object::kv_get (shstr key)
1763		2260
1764	bool set_ob_key_value (object *op, utf8_string key, utf8_string value = 0, int add_key = 1)	2261	void
		2262	object::kv_del (shstr key)
		2263
		2264	void
		2265	object::kv_set (shstr key, shstr value)
1765		2266
1766	object *get_nearest_player (object *ob)	2267	object *get_nearest_player (object *ob)
1767	ALIAS: nearest_player = 0	2268	ALIAS: nearest_player = 0
1768	PREINIT:	2269	PREINIT:
1769	extern object *get_nearest_player (object *);	2270	extern object *get_nearest_player (object *);
…		…
1771	void rangevector (object *ob, object *other, int flags = 0)	2272	void rangevector (object *ob, object *other, int flags = 0)
1772	PROTOTYPE: $$;$	2273	PROTOTYPE: $$;$
1773	PPCODE:	2274	PPCODE:
1774	{	2275	{
1775	rv_vector rv;	2276	rv_vector rv;
		2277
		2278	PUTBACK;
1776	get_rangevector (ob, other, &rv, flags);	2279	get_rangevector (ob, other, &rv, flags);
		2280	SPAGAIN;
		2281
1777	EXTEND (SP, 5);	2282	EXTEND (SP, 5);
1778	PUSHs (newSVuv (rv.distance));	2283	PUSHs (newSVuv (rv.distance));
1779	PUSHs (newSViv (rv.distance_x));	2284	PUSHs (newSViv (rv.distance_x));
1780	PUSHs (newSViv (rv.distance_y));	2285	PUSHs (newSViv (rv.distance_y));
1781	PUSHs (newSViv (rv.direction));	2286	PUSHs (newSViv (rv.direction));
1782	PUSHs (newSVcfapi (CFAPI_POBJECT, rv.part));	2287	PUSHs (to_sv (rv.part));
1783	}	2288	}
1784		2289
1785	bool on_same_map_as (object *ob, object *other)	2290	bool on_same_map_as (object *ob, object *other)
1786	CODE:	2291	CODE:
1787	RETVAL = on_same_map (ob, other);	2292	RETVAL = on_same_map (ob, other);
…		…
1791	base_name (object *op, int plural = op->nrof > 1)	2296	base_name (object *op, int plural = op->nrof > 1)
1792	CODE:	2297	CODE:
1793	RETVAL = query_base_name (op, plural);	2298	RETVAL = query_base_name (op, plural);
1794	OUTPUT: RETVAL	2299	OUTPUT: RETVAL
1795		2300
1796	object *decrease_ob_nr (object *op, unsigned long i)	2301	# return the tail of an object, excluding itself
		2302	void
		2303	tail (object *op)
		2304	PPCODE:
		2305	while ((op = op->more))
		2306	XPUSHs (sv_2mortal (to_sv (op)));
1797		2307
1798	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_	2308	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_
1799		2309
1800	player *player (object *op)	2310	player *player (object *op)
1801	CODE:	2311	CODE:
1802	RETVAL = op->contr;	2312	RETVAL = op->contr;
1803	OUTPUT: RETVAL	2313	OUTPUT: RETVAL
1804		2314
		2315	bool move_player (object *op, int dir)
		2316
1805	void check_score (object *op)	2317	void check_score (object *op)
1806		2318
1807	void message (object *op, utf8_string txt, int flags = NDI_ORANGE | NDI_UNIQUE)	2319	void message (object *op, utf8_string txt, int flags = NDI_ORANGE | NDI_UNIQUE)
1808	CODE:	2320	CODE:
1809	new_draw_info (flags, 0, op, txt);	2321	new_draw_info (flags, 0, op, txt);
1810		2322
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)	2323	void kill_player (object *op)
1827		2324
		2325	void esrv_send_item (object *pl, object *item)
		2326
1828	void esrv_update_item (object *op, int what, object *item)	2327	void esrv_update_item (object *pl, int what, object *item)
1829	C_ARGS: what, op, item	2328	C_ARGS: what, pl, item
1830		2329
1831	void clear_los (object *op)	2330	void esrv_del_item (object *pl, int tag)
		2331	C_ARGS: pl->contr, tag
1832		2332
1833	int command_summon (object *op, utf8_string params)	2333	int command_summon (object *op, utf8_string params)
1834		2334
1835	int command_arrest (object *op, utf8_string params)	2335	int command_arrest (object *op, utf8_string params)
1836		2336
…		…
1855	pl->ob->stats.hp = pl->ob->stats.maxhp;	2355	pl->ob->stats.hp = pl->ob->stats.maxhp;
1856	pl->ob->stats.sp = pl->ob->stats.maxsp;	2356	pl->ob->stats.sp = pl->ob->stats.maxsp;
1857	pl->ob->stats.grace = pl->ob->stats.maxgrace;	2357	pl->ob->stats.grace = pl->ob->stats.maxgrace;
1858	pl->orig_stats = pl->ob->stats;	2358	pl->orig_stats = pl->ob->stats;
1859		2359
1860	void cf_player_move (player *pl, int dir)	2360	# should only be temporary
		2361	void esrv_new_player (player *pl)
1861		2362
1862	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);	2363	#d# TODO: replace by blocked_los accessor, fix code using this
1863
1864	bool	2364	bool
1865	cell_visible (player *pl, int dx, int dy)	2365	cell_visible (player *pl, int dx, int dy)
1866	CODE:	2366	CODE:
1867	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2	2367	RETVAL = pl->blocked_los (dx, dy) != LOS_BLOCKED;
1868	&& !pl->blocked_los [dx + pl->ns->mapx / 2][dy + pl->ns->mapy / 2];
1869	OUTPUT:	2368	OUTPUT:
1870	RETVAL	2369	RETVAL
1871		2370
1872	void	2371	void
1873	send (player *pl, SV *packet)	2372	send (player *pl, SV *packet)
1874	CODE:	2373	CODE:
1875	{	2374	{
1876	STRLEN len;	2375	STRLEN len;
1877	char *buf = SvPVbyte (packet, len);	2376	char *buf = SvPVbyte (packet, len);
1878		2377
		2378	if (len > MAXSOCKBUF)
		2379	pl->failmsg ("[packet too long for client]");
1879	if (pl->ns)	2380	else if (pl->ns)
1880	pl->ns->send_packet (buf, len);	2381	pl->ns->send_packet (buf, len);
1881	}	2382	}
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		2383
1892	void savebed (player *pl, SV *map_path = 0, SV *x = 0, SV *y = 0)	2384	void savebed (player *pl, SV *map_path = 0, SV *x = 0, SV *y = 0)
1893	PROTOTYPE: $;$$$	2385	PROTOTYPE: $;$$$
1894	PPCODE:	2386	PPCODE:
1895	if (GIMME_V != G_VOID)	2387	if (GIMME_V != G_VOID)
…		…
1920	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);	2412	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);
1921	OUTPUT: RETVAL	2413	OUTPUT: RETVAL
1922		2414
1923	SV *registry (maptile *map)	2415	SV *registry (maptile *map)
1924		2416
		2417	void
		2418	find_tagged_objects (maptile *map, utf8_string tag = 0)
		2419	PPCODE:
		2420	{
		2421	if (!map->spaces)
		2422	XSRETURN_EMPTY;
		2423
		2424	if (tag)
		2425	{
		2426	shstr_cmp tag_ (tag);
		2427
		2428	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2429	for (object *op = ms->bot; op; op = op->above)
		2430	if (op->tag == tag_)
		2431	XPUSHs (sv_2mortal (to_sv (op)));
		2432	}
		2433	else
		2434	{
		2435	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2436	for (object *op = ms->bot; op; op = op->above)
		2437	if (op->tag)
		2438	XPUSHs (sv_2mortal (to_sv (op)));
		2439	}
		2440	}
		2441
1925	INCLUDE: $PERL $srcdir/genacc maptile ../include/map.h |	2442	INCLUDE: $PERL $srcdir/genacc maptile ../include/map.h |
		2443
		2444	void
		2445	adjust_daylight ()
		2446	CODE:
		2447	maptile::adjust_daylight ();
		2448
		2449	int
		2450	outdoor_darkness (int darkness = 0)
		2451	CODE:
		2452	RETVAL = maptile::outdoor_darkness;
		2453	if (items)
		2454	maptile::outdoor_darkness = darkness;
		2455	OUTPUT:
		2456	RETVAL
1926		2457
1927	void	2458	void
1928	maptile::instantiate ()	2459	maptile::instantiate ()
1929		2460
1930	maptile *new ()	2461	maptile *new ()
…		…
1973	if (SV **elem = av_fetch ((AV *)palette, idx [offs], 0))	2504	if (SV **elem = av_fetch ((AV *)palette, idx [offs], 0))
1974	{	2505	{
1975	object *ob = get_archetype (SvPVutf8_nolen (*elem));	2506	object *ob = get_archetype (SvPVutf8_nolen (*elem));
1976	ob->flag [FLAG_NO_MAP_SAVE] = true;	2507	ob->flag [FLAG_NO_MAP_SAVE] = true;
1977	THIS->insert (ob, x, y, 0, INS_ABOVE_FLOOR_ONLY);	2508	THIS->insert (ob, x, y, 0, INS_ABOVE_FLOOR_ONLY);
		2509
		2510	if (ob->randomitems)
		2511	{
		2512	if (!ob->above)
		2513	{
		2514	ob->create_treasure (ob->randomitems);
		2515
		2516	for (object *op = ob->above; op; op = op->above)
		2517	op->flag [FLAG_NO_MAP_SAVE] = true;
		2518	}
		2519
		2520	ob->randomitems = 0;
		2521	}
1978	}	2522	}
1979	}	2523	}
1980	}	2524	}
1981		2525
1982	skip_space: ;	2526	skip_space: ;
…		…
1993	palette = SvRV (palette);	2537	palette = SvRV (palette);
1994		2538
1995	STRLEN idxlen;	2539	STRLEN idxlen;
1996	const uint8_t *idx = (const uint8_t *)SvPVbyte (data, idxlen);	2540	const uint8_t *idx = (const uint8_t *)SvPVbyte (data, idxlen);
1997		2541
1998	region **regionmap = (region **)malloc (	2542	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 ());	2543	uint8_t *regions = salloc<uint8_t> (THIS->size ());
2001		2544
2002	for (int i = av_len ((AV *)palette) + 1; i--; )	2545	for (int i = av_len ((AV *)palette) + 1; i--; )
2003	regionmap [i] = region::find (	2546	regionmap [i] = region::find (SvPVutf8_nolen (*av_fetch ((AV *)palette, i, 1)));
2004	SvPVutf8_nolen (*av_fetch ((AV *)palette, i, 1)));
2005		2547
2006	for (int y = 0; y < THIS->height; ++y)	2548	for (int y = 0; y < THIS->height; ++y)
2007	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);	2549	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);
2008		2550
2009	sfree (THIS->regions, THIS->size ());	2551	sfree (THIS->regions, THIS->size ());
2010	free (THIS->regionmap);	2552	delete [] THIS->regionmap;
2011		2553
2012	THIS->regions = regions;	2554	THIS->regions = regions;
2013	THIS->regionmap = regionmap;	2555	THIS->regionmap = regionmap;
2014	}	2556	}
2015		2557
2016	void	2558	void
2017	maptile::create_region_treasure ()	2559	maptile::create_region_treasure ()
2018	CODE:	2560	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)	2561	for (int x = 0; x < THIS->width; ++x)
2025	for (int y = 0; y < THIS->height; ++y)	2562	for (int y = 0; y < THIS->height; ++y)
2026	{	2563	{
2027	region *rgn = THIS->region (x, y);	2564	region *rgn = THIS->region (x, y);
2028		2565
2029	//fprintf (stderr, "%d,%d %f %p\n", x, y, rgn->treasure_density,rgn->treasure);//D	2566	//fprintf (stderr, "%d,%d %f %p\n", x, y, rgn->treasure_density,rgn->treasure);//D
		2567	if (object *op = THIS->at (x, y).top)
2030	if (rgn->treasure && rndm () < rgn->treasure_density)	2568	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);	2569	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);
2035	}
2036	}	2570	}
2037		2571
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)	2572	int out_of_map (maptile *map, int x, int y)
2044		2573
2045	void	2574	void
2046	trigger (maptile *map, long connection, bool state = true)	2575	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:	2576	PPCODE:
2053	oblinkpt *obp = get_connection_links (map, connection);	2577	if (oblinkpt *obp = map->find_link (connection))
2054	if (obp)
2055	for (objectlink *ol = obp->link; ol; ol = ol->next)	2578	for (objectlink *ol = obp->link; ol; ol = ol->next)
2056	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, (object *)ol->ob)));	2579	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		2580
2065	void	2581	void
2066	get_map_flags (maptile *map, int x, int y)	2582	get_map_flags (maptile *map, int x, int y)
2067	PPCODE:	2583	PPCODE:
2068	{	2584	{
2069	maptile *nmap = 0;	2585	maptile *nmap = 0;
2070	I16 nx = 0, ny = 0;	2586	I16 nx = 0, ny = 0;
		2587
		2588	PUTBACK;
2071	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);	2589	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
		2590	SPAGAIN;
2072		2591
2073	EXTEND (SP, 4);	2592	EXTEND (SP, 4);
2074	PUSHs (sv_2mortal (newSViv (flags)));	2593	PUSHs (sv_2mortal (newSViv (flags)));
2075		2594
2076	if (GIMME_V == G_ARRAY)	2595	if (GIMME_V == G_ARRAY)
2077	{	2596	{
2078	PUSHs (sv_2mortal (newSVcfapi (CFAPI_PMAP, nmap)));	2597	PUSHs (sv_2mortal (to_sv (nmap)));
2079	PUSHs (sv_2mortal (newSViv (nx)));	2598	PUSHs (sv_2mortal (newSViv (nx)));
2080	PUSHs (sv_2mortal (newSViv (ny)));	2599	PUSHs (sv_2mortal (newSViv (ny)));
2081	}	2600	}
2082	}	2601	}
2083		2602
		2603	mapspace *
		2604	ms (maptile *map, unsigned int x, unsigned int y)
		2605	PROTOTYPE: $$$
		2606	CODE:
		2607	{
		2608	maptile *nmap = 0;
		2609	I16 nx, ny;
		2610
		2611	PUTBACK;
		2612	get_map_flags (map, &nmap, x, y, &nx, &ny);
		2613	SPAGAIN;
		2614
		2615	if (!nmap)
		2616	XSRETURN_UNDEF;
		2617
		2618	RETVAL = &nmap->at (nx, ny);
		2619	}
		2620	OUTPUT:
		2621	RETVAL
		2622
2084	void	2623	void
2085	at (maptile *map, unsigned int x, unsigned int y)	2624	at (maptile *map, unsigned int x, unsigned int y)
2086	PROTOTYPE: $$$	2625	PROTOTYPE: $$$
2087	PPCODE:	2626	PPCODE:
2088	{	2627	{
2089	object *o;
2090	maptile *nmap = 0;	2628	maptile *nmap = 0;
2091	I16 nx, ny;	2629	I16 nx, ny;
2092		2630
		2631	PUTBACK;
2093	get_map_flags (map, &nmap, x, y, &nx, &ny);	2632	get_map_flags (map, &nmap, x, y, &nx, &ny);
		2633	SPAGAIN;
2094		2634
2095	if (nmap)	2635	if (nmap)
2096	for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)	2636	for (object *o = nmap->at (nx, ny).bot; o; o = o->above)
2097	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));	2637	XPUSHs (sv_2mortal (to_sv (o)));
2098	}	2638	}
2099		2639
2100	SV *	2640	SV *
2101	bot_at (maptile *obj, unsigned int x, unsigned int y)	2641	bot_at (maptile *map, unsigned int x, unsigned int y)
2102	PROTOTYPE: $$$	2642	PROTOTYPE: $$$
2103	ALIAS:	2643	ALIAS:
2104	top_at = 1	2644	top_at = 1
2105	flags_at = 2	2645	flags_at = 2
2106	light_at = 3	2646	light_at = 3
2107	move_block_at = 4	2647	move_block_at = 4
2108	move_slow_at = 5	2648	move_slow_at = 5
2109	move_on_at = 6	2649	move_on_at = 6
2110	move_off_at = 7	2650	move_off_at = 7
2111	INIT:
2112	if (x >= obj->width || y >= obj->height) XSRETURN_UNDEF;
2113	CODE:	2651	CODE:
		2652	{
		2653	sint16 nx = x;
		2654	sint16 ny = y;
		2655
		2656	if (!xy_normalise (map, nx, ny))
		2657	XSRETURN_UNDEF;
		2658
		2659	mapspace &ms = map->at (nx, ny);
		2660
		2661	ms.update ();
		2662
2114	switch (ix)	2663	switch (ix)
2115	{	2664	{
2116	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;	2665	case 0: RETVAL = to_sv (ms.bot ); break;
2117	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;	2666	case 1: RETVAL = to_sv (ms.top ); break;
2118	case 2: RETVAL = newSVuv ( GET_MAP_FLAGS (obj, x, y)); break;	2667	case 2: RETVAL = newSVuv (ms.flags_ ); break;
2119	case 3: RETVAL = newSViv ( GET_MAP_LIGHT (obj, x, y)); break;	2668	case 3: RETVAL = newSViv (ms.light ); break;
2120	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;	2669	case 4: RETVAL = newSVuv (ms.move_block); break;
2121	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;	2670	case 5: RETVAL = newSVuv (ms.move_slow ); break;
2122	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;	2671	case 6: RETVAL = newSVuv (ms.move_on ); break;
2123	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;	2672	case 7: RETVAL = newSVuv (ms.move_off ); break;
2124	}	2673	}
		2674	}
2125	OUTPUT: RETVAL	2675	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		2676
2131	# worst xs function of my life	2677	# worst xs function of my life
2132	bool	2678	bool
2133	_create_random_map (\	2679	_create_random_map (\
2134	maptile *self,\	2680	maptile *self,\
…		…
2202	rmp.decoroptions = decoroptions;	2748	rmp.decoroptions = decoroptions;
2203	rmp.orientation = orientation;	2749	rmp.orientation = orientation;
2204	rmp.origin_y = origin_y;	2750	rmp.origin_y = origin_y;
2205	rmp.origin_x = origin_x;	2751	rmp.origin_x = origin_x;
2206	rmp.random_seed = random_seed;	2752	rmp.random_seed = random_seed;
2207	rmp.total_map_hp = total_map_hp;	2753	rmp.total_map_hp = (uint64_t) total_map_hp;
2208	rmp.map_layout_style = map_layout_style;	2754	rmp.map_layout_style = map_layout_style;
2209	rmp.treasureoptions = treasureoptions;	2755	rmp.treasureoptions = treasureoptions;
2210	rmp.symmetry_used = symmetry_used;	2756	rmp.symmetry_used = symmetry_used;
2211	rmp.region = region;	2757	rmp.region = region;
2212	rmp.custom = custom;	2758	rmp.custom = custom;
…		…
2214	RETVAL = self->generate_random_map (&rmp);	2760	RETVAL = self->generate_random_map (&rmp);
2215	}	2761	}
2216	OUTPUT:	2762	OUTPUT:
2217	RETVAL	2763	RETVAL
2218		2764
		2765	MODULE = cf PACKAGE = cf::mapspace
		2766
		2767	INCLUDE: $PERL $srcdir/genacc mapspace ../include/map.h |
		2768
2219	MODULE = cf PACKAGE = cf::arch	2769	MODULE = cf PACKAGE = cf::arch
2220		2770
2221	archetype *find (utf8_string name)	2771	int archetypes_size ()
2222	CODE:	2772	CODE:
2223	RETVAL = archetype::find (name);	2773	RETVAL = archetypes.size ();
2224	OUTPUT:	2774	OUTPUT: RETVAL
2225	RETVAL
2226		2775
2227	archetype *first()	2776	archetype *archetypes (U32 index)
2228	PROTOTYPE:	2777	CODE:
2229	CODE:	2778	RETVAL = index < archetypes.size () ? archetypes [index] : 0;
2230	RETVAL = first_archetype;	2779	OUTPUT: RETVAL
		2780
		2781	object *instantiate (archetype *arch)
		2782	CODE:
		2783	RETVAL = arch_to_object (arch);
		2784	OUTPUT:
2231	OUTPUT: RETVAL	2785	RETVAL
2232		2786
2233	INCLUDE: $PERL $srcdir/genacc archetype ../include/object.h |	2787	INCLUDE: $PERL $srcdir/genacc archetype ../include/object.h |
2234		2788
2235	MODULE = cf PACKAGE = cf::party	2789	MODULE = cf PACKAGE = cf::party
2236		2790
…		…
2254	PROTOTYPE: $	2808	PROTOTYPE: $
2255	CODE:	2809	CODE:
2256	RETVAL = region::find (name);	2810	RETVAL = region::find (name);
2257	OUTPUT: RETVAL	2811	OUTPUT: RETVAL
2258		2812
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)	2813	int specificity (region *rgn)
2266	CODE:	2814	CODE:
2267	RETVAL = 0;	2815	RETVAL = 0;
2268	while (rgn = rgn->parent)	2816	while (rgn = rgn->parent)
2269	RETVAL++;	2817	RETVAL++;
…		…
2305	CODE:	2853	CODE:
2306	{	2854	{
2307	STRLEN len;	2855	STRLEN len;
2308	char *buf = SvPVbyte (packet, len);	2856	char *buf = SvPVbyte (packet, len);
2309		2857
		2858	if (len > MAXSOCKBUF)
		2859	{
		2860	// ugly
		2861	if (THIS->pl)
		2862	THIS->pl->failmsg ("[packet too long for client]");
		2863	}
		2864	else
2310	THIS->send_packet (buf, len);	2865	THIS->send_packet (buf, len);
2311	}	2866	}
		2867
		2868	faceidx
		2869	client::need_face (utf8_string name, int pri = 0)
		2870	CODE:
		2871	RETVAL = face_find (name, 0);
		2872	if (RETVAL)
		2873	{
		2874	THIS->send_face (RETVAL, pri);
		2875	THIS->flush_fx ();
		2876	}
		2877	OUTPUT:
		2878	RETVAL
		2879
		2880	int
		2881	client::fx_want (int idx, int value = -1)
		2882	CODE:
		2883	if (0 < idx && idx < FT_NUM)
		2884	{
		2885	RETVAL = THIS->fx_want [idx];
		2886	if (items > 2)
		2887	THIS->fx_want [idx] = value;
		2888	}
		2889	else
		2890	RETVAL = 0;
		2891	OUTPUT:
		2892	RETVAL
		2893
		2894	MODULE = cf PACKAGE = cf::sound PREFIX = sound_
		2895
		2896	faceidx sound_find (utf8_string name)
		2897
		2898	void sound_set (utf8_string str, faceidx face)
		2899
		2900	# dire hack
		2901	void old_sound_index (int idx, faceidx face)
		2902	CODE:
		2903	extern faceidx old_sound_index [SOUND_CAST_SPELL_0];
		2904	old_sound_index [idx] = face;
2312		2905
2313	MODULE = cf PACKAGE = cf::face PREFIX = face_	2906	MODULE = cf PACKAGE = cf::face PREFIX = face_
2314		2907
2315	#INCLUDE: $PERL $srcdir/genacc faceset ../include/face.h |	2908	#INCLUDE: $PERL $srcdir/genacc faceset ../include/face.h |
2316		2909
…		…
2332	if (!strcmp (name, BLANK_FACE_NAME)) blank_face = RETVAL;	2925	if (!strcmp (name, BLANK_FACE_NAME)) blank_face = RETVAL;
2333	if (!strcmp (name, EMPTY_FACE_NAME)) empty_face = RETVAL;	2926	if (!strcmp (name, EMPTY_FACE_NAME)) empty_face = RETVAL;
2334	}	2927	}
2335	OUTPUT: RETVAL	2928	OUTPUT: RETVAL
2336		2929
2337	void set (faceidx idx, int visibility, int magicmap)	2930	void set_type (faceidx idx, int value)
2338	CODE:	2931	ALIAS:
2339	faceinfo *f = face_info (idx);	2932	set_type = 0
2340	assert (f);	2933	set_visibility = 1
2341	f->visibility = visibility;	2934	set_magicmap = 2
2342	f->magicmap = magicmap;	2935	set_smooth = 3
2343		2936	set_smoothlevel = 4
2344	void set_smooth (faceidx idx, faceidx smooth, int smoothlevel)
2345	CODE:	2937	CODE:
2346	faceinfo *f = face_info (idx); assert (f);	2938	faceinfo *f = face_info (idx); assert (f);
2347	f->smooth = smooth;	2939	switch (ix)
2348	f->smoothlevel = smoothlevel;	2940	{
		2941	case 0: f->type = value; break;
		2942	case 1: f->visibility = value; break;
		2943	case 2: f->magicmap = value; break;
		2944	case 3: f->smooth = value; break;
		2945	case 4: f->smoothlevel = value; break;
		2946	}
2349		2947
2350	void set_data (faceidx idx, int faceset, SV *data, SV *chksum)	2948	void set_data (faceidx idx, int faceset, SV *data, SV *chksum)
2351	CODE:	2949	CODE:
2352	{	2950	{
2353	facedata *d = face_data (idx, faceset);	2951	faceinfo *f = face_info (idx); assert (f);
2354	assert (d);	2952	facedata *d = &(faceset ? f->data64 : f->data32);
2355	sv_to (data, d->data);	2953	sv_to (data, d->data);
2356	STRLEN clen;	2954	STRLEN clen;
2357	char *cdata = SvPVbyte (chksum, clen);	2955	char *cdata = SvPVbyte (chksum, clen);
2358	clen = min (CHKSUM_SIZE, clen);	2956	clen = min (CHKSUM_SIZE, clen);
2359		2957
…		…
2369	ns->force_newmap = true;	2967	ns->force_newmap = true;
2370	}	2968	}
2371	}	2969	}
2372	}	2970	}
2373		2971
		2972	int get_data_size (faceidx idx, int faceset = 0)
		2973	CODE:
		2974	facedata *d = face_data (idx, faceset);
		2975	if (!d) XSRETURN_UNDEF;
		2976	RETVAL = d->data.size ();
		2977	OUTPUT:
		2978	RETVAL
		2979
		2980	SV *get_chksum (faceidx idx, int faceset = 0)
		2981	CODE:
		2982	facedata *d = face_data (idx, faceset);
		2983	if (!d) XSRETURN_UNDEF;
		2984	RETVAL = newSVpvn ((char *)d->chksum, CHKSUM_SIZE);
		2985	OUTPUT:
		2986	RETVAL
		2987
		2988	SV *get_data (faceidx idx, int faceset = 0)
		2989	CODE:
		2990	facedata *d = face_data (idx, faceset);
		2991	if (!d) XSRETURN_UNDEF;
		2992	RETVAL = newSVpvn (d->data.data (), d->data.length ());
		2993	OUTPUT:
		2994	RETVAL
		2995
2374	void invalidate (faceidx idx)	2996	void invalidate (faceidx idx)
2375	CODE:	2997	CODE:
2376	for_all_clients (ns)	2998	for_all_clients (ns)
2377	{	2999	{
2378	ns->faces_sent [idx] = false;	3000	ns->faces_sent [idx] = false;
…		…
2421	void invalidate_all ()	3043	void invalidate_all ()
2422	CODE:	3044	CODE:
2423	for_all_clients (ns)	3045	for_all_clients (ns)
2424	ns->anims_sent.reset ();	3046	ns->anims_sent.reset ();
2425		3047
		3048	MODULE = cf PACKAGE = cf::object::freezer
		3049
		3050	INCLUDE: $PERL $srcdir/genacc object_freezer ../include/cfperl.h |
		3051
		3052	SV *
		3053	new (char *klass)
		3054	CODE:
		3055	RETVAL = newSVptr (new object_freezer, gv_stashpv ("cf::object::freezer", 1));
		3056	OUTPUT: RETVAL
		3057
		3058	void
		3059	DESTROY (SV *sv)
		3060	CODE:
		3061	object_freezer *self;
		3062	sv_to (sv, self);
		3063	delete self;
		3064
		3065	MODULE = cf PACKAGE = cf::object::thawer
		3066
		3067	INCLUDE: $PERL $srcdir/genacc object_thawer ../include/cfperl.h |
		3068
		3069	SV *
		3070	new_from_file (char *klass, octet_string path)
		3071	CODE:
		3072	object_thawer *f = new object_thawer (path);
		3073	if (!*f)
		3074	{
		3075	delete f;
		3076	XSRETURN_UNDEF;
		3077	}
		3078	RETVAL = newSVptr (f, gv_stashpv ("cf::object::thawer", 1));
		3079	OUTPUT: RETVAL
		3080
		3081	void
		3082	DESTROY (SV *sv)
		3083	CODE:
		3084	object_thawer *self;
		3085	sv_to (sv, self);
		3086	delete self;
		3087
		3088	void
		3089	extract_tags (object_thawer *self)
		3090	PPCODE:
		3091	while (self->kw != KW_EOF)
		3092	{
		3093	PUTBACK;
		3094	coroapi::cede_to_tick ();
		3095	SPAGAIN;
		3096
		3097	if (self->kw == KW_tag)
		3098	XPUSHs (sv_2mortal (newSVpv_utf8 (self->get_str ())));
		3099
		3100	self->skip ();
		3101	}
		3102

Diff Legend

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