ViewVC Help

View File | Revision Log | Show Annotations | Download File

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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.208 by root, Sat May 12 13:27:38 2007 UTC vs.
Revision 1.364 by root, Sun Apr 11 03:53:33 2010 UTC

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

Diff Legend

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