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.197 by root, Fri Apr 27 03:38:33 2007 UTC vs.
Revision 1.375 by root, Sun Apr 18 05:08:14 2010 UTC

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

Diff Legend

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