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.208 by root, Sat May 12 13:27:38 2007 UTC vs.
Revision 1.368 by root, Tue Apr 13 02:39:53 2010 UTC

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

Diff Legend

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