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.209 by root, Thu May 17 14:14:55 2007 UTC vs.
Revision 1.346 by root, Sat Jan 16 17:41:01 2010 UTC

1	/*	1	/*
2	* CrossFire, A Multiplayer game	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* This code is placed under the GNU General Public Licence (GPL)	4	* Copyright (©) 2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	*	5	*
6	* Copyright (C) 2001-2005 by Chachkoff Yann
7	* Copyright (C) 2006,2007 by Marc Lehmann <cf@schmorp.de>
8	*
9	* 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
10	* 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
11	* the Free Software Foundation; either version 2 of the License, or	8	* Free Software Foundation, either version 3 of the License, or (at your
12	* (at your option) any later version.	9	* option) any later version.
13	*	10	*
14	* 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,
15	* but WITHOUT ANY WARRANTY; without even the implied warranty of	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	* GNU General Public License for more details.	14	* GNU General Public License for more details.
18	*	15	*
19	* 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
20	* 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
21	* 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>
22	*/	21	*/
23		22
24	#include "autoconf.h"	23	#include "autoconf.h"
25
26	#define PLUGIN_NAME "perl"
27	#define PLUGIN_VERSION "cfperl 0.5"
28
29	#define CEDES_PER_TICK 5
30		24
31	#if HAVE_EXECINFO_H	25	#if HAVE_EXECINFO_H
32	# include <execinfo.h>	26	# include <execinfo.h>
33	#endif	27	#endif
34		28
35	#include <plugin_common.h>
36	#include <sounds.h>
37	#include <cstdarg>	29	#include <cstdarg>
		30	#include <typeinfo>
		31
		32	#include "global.h"
		33	#include "../random_maps/random_map.h"
		34	#include "evthread.h"
38	#include <sproto.h>	35	#include "sproto.h"
39
40	#include "loader.h"
41	#include "cfperl.h"
42	#include "shstr.h"
43		36
44	#include <unistd.h>	37	#include <unistd.h>
45	#if _POSIX_MEMLOCK	38	#if _POSIX_MEMLOCK
46	# include <sys/mman.h>	39	# include <sys/mman.h>
47	#endif	40	#endif
48		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
49	#include <EXTERN.h>	50	#include <EXTERN.h>
50	#include <perl.h>	51	#include <perl.h>
51	#include <XSUB.h>	52	#include <XSUB.h>
52		53
53	#include "CoroAPI.h"	54	#include "CoroAPI.h"
54	#include "perlxsi.c"	55	#include "perlxsi.c"
55		56
56	extern sint64 *levels; // the experience table	57	extern sint64 *levels; // the experience table
57		58
58	typedef object object_ornull;	59	typedef object_thawer &object_thawer_ref;
59	typedef maptile maptile_ornull;	60	typedef object_freezer &object_freezer_ref;
60
61	typedef char *octet_string;
62	typedef char *utf8_string;
63	typedef const char *const_octet_string;
64	typedef const char *const_utf8_string;
65		61
66	typedef std::string std__string;	62	typedef std::string std__string;
67		63
68	#if IVSIZE >= 8
69	typedef IV val64;
70	# define newSVval64 newSViv
71	# define SvVAL64 SvIV
72	#else
73	typedef double val64;
74	# define newSVval64 newSVnv
75	# define SvVAL64 SvNV
76	#endif
77
78	static f_plug_api gethook = cfapi_get_hooks;
79	static f_plug_api object_set_property = cfapi_object_set_property;
80	static f_plug_api object_insert = cfapi_object_insert;
81
82	static PerlInterpreter *perl;	64	static PerlInterpreter *perl;
83		65
84	double runtime;	66	tstamp NOW, runtime;
		67
		68	static int tick_inhibit;
		69	static int tick_pending;
85		70
86	global gbl_ev;	71	global gbl_ev;
87	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;
88	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;
89		78
90	static HV	79	static HV
91	*stash_cf,	80	*stash_cf,
92	*stash_cf_object_wrap,	81	*stash_cf_object_wrap,
93	*stash_cf_object_player_wrap,	82	*stash_cf_object_player_wrap,
94	*stash_cf_player_wrap,	83	*stash_cf_player_wrap,
95	*stash_cf_map_wrap,	84	*stash_cf_map_wrap,
		85	*stash_cf_mapspace_wrap,
96	*stash_cf_client_wrap,	86	*stash_cf_client_wrap,
97	*stash_cf_arch_wrap,	87	*stash_cf_arch_wrap,
98	*stash_cf_party_wrap,	88	*stash_cf_party_wrap,
99	*stash_cf_region_wrap,	89	*stash_cf_region_wrap,
100	*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	}
101		143
102	// helper cast function, returns super class * or 0	144	// helper cast function, returns super class * or 0
103	template<class super>	145	template<class super>
104	static super *	146	static super *
105	is_a (attachable *at)	147	is_a (attachable *at)
…		…
138	SvREFCNT_inc (self);	180	SvREFCNT_inc (self);
139	hv_clear (self);	181	hv_clear (self);
140	sv_unmagic ((SV *)self, PERL_MAGIC_ext);	182	sv_unmagic ((SV *)self, PERL_MAGIC_ext);
141	SvREFCNT_dec (self);	183	SvREFCNT_dec (self);
142		184
143	// self *must* be null now because thats sv_unmagic's job.	185	// self *must* be null now because that's sv_unmagic's job.
144	assert (!this->self);	186	assert (!this->self);
145	}	187	}
146	}	188	}
147		189
148	void	190	void
…		…
165	}	207	}
166		208
167	void	209	void
168	attachable::do_destroy ()	210	attachable::do_destroy ()
169	{	211	{
170	invoke (EVENT_ATTACHABLE_DESTROY, DT_END);	212	INVOKE_ATTACHABLE (DESTROY, this);
171		213
172	if (cb)	214	if (cb)
173	{	215	{
174	SvREFCNT_dec (cb);	216	SvREFCNT_dec (cb);
175	cb = 0;	217	cb = 0;
…		…
182	attachable::destroy ()	224	attachable::destroy ()
183	{	225	{
184	if (destroyed ())	226	if (destroyed ())
185	return;	227	return;
186		228
187	flags |= F_DESTROYED;	229	attachable_flags |= F_DESTROYED;
188	do_destroy ();	230	do_destroy ();
189	sever_self ();	231	sever_self ();
190	}	232	}
191		233
192	void	234	void
…		…
198	{	240	{
199	if (i >= mortals.size ())	241	if (i >= mortals.size ())
200	{	242	{
201	i = 0;	243	i = 0;
202		244
203	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 ();
204	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	}
205		261
206	break;	262	break;
207	}	263	}
208		264
209	attachable *obj = mortals [i];	265	attachable *obj = mortals [i];
…		…
230	delete obj;	286	delete obj;
231	}	287	}
232	}	288	}
233	}	289	}
234		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
235	attachable &	303	attachable &
236	attachable::operator =(const attachable &src)	304	attachable::operator =(const attachable &src)
237	{	305	{
238	//if (self || cb)	306	//if (self || cb)
239	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));	307	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));
240		308
241	attach = src.attach;	309	attach = src.attach;
242	return *this;	310	return *this;
243	}	311	}
244		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
245	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	348	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
246		349
247	static SV *	350	static SV *
248	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())	351	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())
249	{	352	{
250	SV *sv;	353	SV *sv;
251		354
252	if (!ptr)	355	if (!ptr)
253	return &PL_sv_undef;	356	return newSV (0);
254		357
255	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);
256	return sv_bless (newRV_noinc ((SV *)hv), stash);	359	return sv_bless (newRV_noinc ((SV *)hv), stash);
257	}	360	}
258		361
…		…
277		380
278	static SV *	381	static SV *
279	newSVattachable (attachable *obj, HV *stash)	382	newSVattachable (attachable *obj, HV *stash)
280	{	383	{
281	if (!obj)	384	if (!obj)
282	return &PL_sv_undef;	385	return newSV (0);
283		386
284	if (!obj->self)	387	if (!obj->self)
		388	obj->self = newHV ();
		389
		390	if (!SvOBJECT (obj->self))
285	{	391	{
286	obj->self = newHV ();
287	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);
288		393
289	// now bless the object _once_	394	// now bless the object _once_
		395	//TODO: create a class registry with c++ type<=>perl name<=>stash and use it here and elsewhere
290	return sv_bless (newRV_inc ((SV *)obj->self), stash);	396	return sv_bless (newRV_inc ((SV *)obj->self), stash);
291	}	397	}
292	else	398	else
293	{	399	{
294	SV *sv = newRV_inc ((SV *)obj->self);	400	SV *sv = newRV_inc ((SV *)obj->self);
…		…
298		404
299	return sv;	405	return sv;
300	}	406	}
301	}	407	}
302		408
		409	#if 0 // unused
303	static void	410	static void
304	clearSVptr (SV *sv)	411	clearSVptr (SV *sv)
305	{	412	{
306	if (SvROK (sv))	413	if (SvROK (sv))
307	sv = SvRV (sv);	414	sv = SvRV (sv);
308		415
309	hv_clear ((HV *)sv);	416	hv_clear ((HV *)sv);
310	sv_unmagic (sv, PERL_MAGIC_ext);	417	sv_unmagic (sv, PERL_MAGIC_ext);
311	}	418	}
		419	#endif
		420
		421	static long
		422	SvPTR_nc (SV *sv)
		423	{
		424	sv = SvRV (sv);
		425
		426	// very important shortcut
		427	if (expect_true (SvMAGIC (sv) && SvMAGIC (sv)->mg_type == PERL_MAGIC_ext))
		428	return (long)SvMAGIC (sv)->mg_ptr;
		429
		430	if (MAGIC *mg = mg_find (sv, PERL_MAGIC_ext))
		431	return (long)mg->mg_ptr;
		432
		433	croak ("perl code used object, but C object is already destroyed, caught");
		434	}
312		435
313	static long	436	static long
314	SvPTR (SV *sv, const char *klass)	437	SvPTR (SV *sv, const char *klass)
315	{	438	{
316	if (!sv_derived_from (sv, klass))	439	if (!sv_derived_from (sv, klass))
317	croak ("object of type %s expected", klass);	440	croak ("object of type %s expected", klass);
318		441
319	MAGIC *mg = mg_find (SvRV (sv), PERL_MAGIC_ext);	442	return SvPTR_nc (sv);
320
321	if (!mg)
322	croak ("perl code used %s object, but C object is already destroyed, caught", klass);
323
324	return (long)mg->mg_ptr;
325	}	443	}
326		444
327	static long	445	static long noinline
328	SvPTR_ornull (SV *sv, const char *klass)	446	SvPTR_ornull (SV *sv, const char *klass)
329	{	447	{
330	if (SvOK (sv))	448	if (expect_false (!SvOK (sv))) return 0;
		449
331	return SvPTR (sv, klass);	450	return SvPTR (sv, klass);
332	else
333	return 0;
334	}	451	}
335		452
		453	static long noinline
		454	SvPTR_ornull_client (SV *sv)
		455	{
		456	if (expect_false (!SvOK (sv))) return 0;
		457
		458	if (!SvROK (sv)
		459	|| (SvSTASH (SvRV (sv)) != stash_cf_client_wrap
		460	&& !sv_derived_from (sv, "cf::client")))
		461	croak ("object of type cf::client expected");
		462
		463	return SvPTR_nc (sv);
		464	}
		465
		466	static long noinline
		467	SvPTR_ornull_object (SV *sv)
		468	{
		469	if (expect_false (!SvOK (sv))) return 0;
		470
		471	if (!SvROK (sv)
		472	|| (SvSTASH (SvRV (sv)) != stash_cf_object_wrap
		473	&& SvSTASH (SvRV (sv)) != stash_cf_object_player_wrap
		474	&& SvSTASH (SvRV (sv)) != stash_cf_arch_wrap
		475	&& !sv_derived_from (sv, "cf::object")))
		476	croak ("object of type cf::object expected");
		477
		478	return SvPTR_nc (sv);
		479	}
		480
		481	static long noinline
		482	SvPTR_ornull_player (SV *sv)
		483	{
		484	if (expect_false (!SvOK (sv))) return 0;
		485
		486	if (!SvROK (sv)
		487	|| (SvSTASH (SvRV (sv)) != stash_cf_player_wrap
		488	&& !sv_derived_from (sv, "cf::player")))
		489	croak ("object of type cf::player expected");
		490
		491	return SvPTR_nc (sv);
		492	}
		493
336	inline SV *to_sv (const shstr & v) { return v ? newSVpvn ((const char *)v, v.length ()) : &PL_sv_undef; }	494	static inline SV *to_sv (const shstr & v) { return newSVpvn_utf8 ((const char *)v, v.length (), 1); }
337	inline SV *to_sv (const char * v) { return newSVpv (v, 0); }	495	static inline SV *to_sv (const char * v) { return v ? newSVpv (v, 0) : newSV (0); }
338	inline SV *to_sv (bool v) { return newSViv (v); }	496	static inline SV *to_sv (bool v) { return newSViv (v); }
339	inline SV *to_sv ( signed char v) { return newSViv (v); }	497	static inline SV *to_sv ( signed char v) { return newSViv (v); }
340	inline SV *to_sv (unsigned char v) { return newSViv (v); }	498	static inline SV *to_sv (unsigned char v) { return newSViv (v); }
341	inline SV *to_sv ( signed short v) { return newSViv (v); }	499	static inline SV *to_sv ( signed short v) { return newSViv (v); }
342	inline SV *to_sv (unsigned short v) { return newSVuv (v); }	500	static inline SV *to_sv (unsigned short v) { return newSVuv (v); }
343	inline SV *to_sv ( signed int v) { return newSViv (v); }	501	static inline SV *to_sv ( signed int v) { return newSViv (v); }
344	inline SV *to_sv (unsigned int v) { return newSVuv (v); }	502	static inline SV *to_sv (unsigned int v) { return newSVuv (v); }
345	inline SV *to_sv ( signed long v) { return newSViv (v); }	503	static inline SV *to_sv ( signed long v) { return newSViv (v); }
346	inline SV *to_sv (unsigned long v) { return newSVuv (v); }	504	static inline SV *to_sv (unsigned long v) { return newSVuv (v); }
347	inline SV *to_sv ( signed long long v) { return newSVval64 (v); }	505	static inline SV *to_sv ( signed long long v) { return newSVval64 (v); }
348	inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }	506	static inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }
349	inline SV *to_sv (float v) { return newSVnv (v); }	507	static inline SV *to_sv (float v) { return newSVnv (v); }
350	inline SV *to_sv (double v) { return newSVnv (v); }	508	static inline SV *to_sv (double v) { return newSVnv (v); }
351	inline SV *to_sv (client * v) { return newSVattachable (v, stash_cf_client_wrap); }	509	static inline SV *to_sv (client * v) { return newSVattachable (v, stash_cf_client_wrap); }
352	inline SV *to_sv (player * v) { return newSVattachable (v, stash_cf_player_wrap); }	510	static inline SV *to_sv (player * v) { return newSVattachable (v, stash_cf_player_wrap); }
353	inline SV *to_sv (object * v) { return newSVattachable (v, v && v->type == PLAYER ? stash_cf_object_player_wrap : stash_cf_object_wrap); }	511	static inline SV *to_sv (object * v) { return newSVattachable (v, v && v->type == PLAYER ? stash_cf_object_player_wrap : stash_cf_object_wrap); }
354	inline SV *to_sv (maptile * v) { return newSVattachable (v, stash_cf_map_wrap); }	512	static inline SV *to_sv (maptile * v) { return newSVattachable (v, stash_cf_map_wrap); }
355	inline SV *to_sv (archetype * v) { return newSVattachable (v, stash_cf_arch_wrap); }	513	static inline SV *to_sv (archetype * v) { return newSVattachable (v, stash_cf_arch_wrap); }
		514	static inline SV *to_sv (region * v) { return newSVattachable (v, stash_cf_region_wrap); }
356	inline SV *to_sv (partylist * v) { return newSVptr (v, stash_cf_party_wrap); }	515	static inline SV *to_sv (partylist * v) { return newSVptr (v, stash_cf_party_wrap); }
357	inline SV *to_sv (region * v) { return newSVptr (v, stash_cf_region_wrap); }
358	inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }	516	static inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }
		517	static inline SV *to_sv (mapspace * v) { return newSVptr (v, stash_cf_mapspace_wrap); }
359		518
360	inline SV *to_sv (object & v) { return to_sv (&v); }	519	static inline SV *to_sv (object & v) { return to_sv (&v); }
361	inline SV *to_sv (living & v) { return to_sv (&v); }	520	static inline SV *to_sv (living & v) { return to_sv (&v); }
362		521
363	inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); }	522	static inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); }
364	inline SV *to_sv (const treasurelist *v) { return to_sv (v->name); }	523	static inline SV *to_sv (const treasurelist *v) { return to_sv (v->name); }
365		524
366	inline SV *to_sv (UUID v)	525	static inline SV *to_sv (UUID v) { return newSVpv (v.c_str (), 0); }
367	{
368	char buf[128];
369	snprintf (buf, 128, "<1.%" PRIx64 ">", v.seq);
370	return newSVpv (buf, 0);
371	}
372		526
		527	static inline SV *to_sv (dynbuf * v)
		528	{
		529	SV *sv = newSV (0);
		530
		531	sv_upgrade (sv, SVt_PV);
		532	SvGROW (sv, v->size () + 1);
		533	SvPOK_only (sv);
		534	v->linearise (SvPVX (sv));
		535	SvCUR_set (sv, v->size ());
		536	*SvEND (sv) = 0;
		537
		538	return sv;
		539	}
		540
		541	static inline SV *to_sv (dynbuf_text * v)
		542	{
		543	SV *sv = to_sv (static_cast<dynbuf *> (v));
		544	SvUTF8_on (sv);
		545	return sv;
		546	}
		547
373	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPV_nolen (sv) : 0; }	548	static inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? cfSvPVutf8_nolen (sv) : 0; }
374	inline void sv_to (SV *sv, char * &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }	549	static inline void sv_to (SV *sv, char * &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }
375	inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }	550	static inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }
376	inline void sv_to (SV *sv, signed char &v) { v = SvIV (sv); }	551	static inline void sv_to (SV *sv, signed char &v) { v = SvIV (sv); }
377	inline void sv_to (SV *sv, unsigned char &v) { v = SvIV (sv); }	552	static inline void sv_to (SV *sv, unsigned char &v) { v = SvIV (sv); }
378	inline void sv_to (SV *sv, signed short &v) { v = SvIV (sv); }	553	static inline void sv_to (SV *sv, signed short &v) { v = SvIV (sv); }
379	inline void sv_to (SV *sv, unsigned short &v) { v = SvIV (sv); }	554	static inline void sv_to (SV *sv, unsigned short &v) { v = SvIV (sv); }
380	inline void sv_to (SV *sv, signed int &v) { v = SvIV (sv); }	555	static inline void sv_to (SV *sv, signed int &v) { v = SvIV (sv); }
381	inline void sv_to (SV *sv, unsigned int &v) { v = SvUV (sv); }	556	static inline void sv_to (SV *sv, unsigned int &v) { v = SvUV (sv); }
382	inline void sv_to (SV *sv, signed long &v) { v = SvIV (sv); }	557	static inline void sv_to (SV *sv, signed long &v) { v = SvIV (sv); }
383	inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }	558	static inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }
384	inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }	559	static inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }
385	inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }	560	static inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }
386	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }	561	static inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
387	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }	562	static inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }
388	inline void sv_to (SV *sv, client * &v) { v = (client *)(attachable *)SvPTR_ornull (sv, "cf::client"); }	563	static inline void sv_to (SV *sv, client * &v) { v = (client *) (attachable *)SvPTR_ornull_client (sv); }
389	inline void sv_to (SV *sv, player * &v) { v = (player *)(attachable *)SvPTR_ornull (sv, "cf::player"); }	564	static inline void sv_to (SV *sv, player * &v) { v = (player *) (attachable *)SvPTR_ornull_player (sv); }
390	inline void sv_to (SV *sv, object * &v) { v = (object *)(attachable *)SvPTR_ornull (sv, "cf::object"); }	565	static inline void sv_to (SV *sv, object * &v) { v = (object *) (attachable *)SvPTR_ornull_object (sv); }
391	inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)(attachable *)SvPTR_ornull (sv, "cf::arch"); }	566	static inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)(attachable *)SvPTR_ornull (sv, "cf::arch"); }
392	inline void sv_to (SV *sv, maptile * &v) { v = (maptile *)(attachable *)SvPTR_ornull (sv, "cf::map"); }	567	static inline void sv_to (SV *sv, maptile * &v) { v = (maptile *) (attachable *)SvPTR_ornull (sv, "cf::map"); }
		568	static inline void sv_to (SV *sv, region * &v) { v = (region *) (attachable *)SvPTR_ornull (sv, "cf::region"); }
393	inline void sv_to (SV *sv, attachable * &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); }	569	static inline void sv_to (SV *sv, attachable * &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); }
394	inline void sv_to (SV *sv, partylist * &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }	570	static inline void sv_to (SV *sv, partylist * &v) { v = (partylist *) SvPTR_ornull (sv, "cf::party"); }
395	inline void sv_to (SV *sv, region * &v) { v = (region *)SvPTR_ornull (sv, "cf::region"); }
396	inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }	571	static inline void sv_to (SV *sv, living * &v) { v = (living *) SvPTR_ornull (sv, "cf::living"); }
		572	static inline void sv_to (SV *sv, mapspace * &v) { v = (mapspace *) SvPTR_ornull (sv, "cf::mapspace"); }
		573	static inline void sv_to (SV *sv, object_freezer * &v) { v = (object_freezer *) SvPTR_ornull (sv, "cf::object::freezer"); }
		574	static inline void sv_to (SV *sv, object_thawer * &v) { v = (object_thawer *) SvPTR_ornull (sv, "cf::object::thawer" ); }
397		575
398	//inline void sv_to (SV *sv, faceinfo * &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }	576	//static inline void sv_to (SV *sv, faceinfo * &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }
399	inline void sv_to (SV *sv, treasurelist * &v) { v = treasurelist::find (SvPV_nolen (sv)); }	577	static inline void sv_to (SV *sv, treasurelist * &v) { v = treasurelist::find (SvPV_nolen (sv)); }
400		578
401	template<class T>	579	template<class T>
402	inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }	580	static inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }
403		581
404	template<int N>	582	template<int N>
405	inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); }	583	static inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); }
406		584
407	inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); }	585	static inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); }
408	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); }
409	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); }
410	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); }
411		589
412	inline void sv_to (SV *sv, std::string &v)	590	static inline void sv_to (SV *sv, std::string &v)
413	{	591	{
414	STRLEN len;	592	STRLEN len;
415	char *data = SvPVbyte (sv, len);	593	char *data = SvPVbyte (sv, len);
416	v.assign (data, len);	594	v.assign (data, len);
417	}	595	}
418		596
419	inline void sv_to (SV *sv, UUID &v)	597	static inline void sv_to (SV *sv, UUID &v)
420	{	598	{
421	unsigned int version;	599	if (!v.parse (SvPV_nolen (sv)))
422
423	if (2 != sscanf (SvPV_nolen (sv), "<%d.%" SCNx64 ">", &version, &v.seq) || 1 != version)
424	croak ("unparsable uuid: %s", SvPV_nolen (sv));	600	croak ("unparsable uuid: %s", SvPV_nolen (sv));
425	}	601	}
426		602
427	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); }
428		604
429	static SV *	605	static SV *
430	newSVdt_va (va_list &ap, data_type type)	606	newSVdt_va (va_list &ap, data_type type)
431	{	607	{
432	SV *sv;	608	SV *sv;
…		…
446	break;	622	break;
447		623
448	case DT_STRING:	624	case DT_STRING:
449	{	625	{
450	char *str = (char *)va_arg (ap, const char *);	626	char *str = (char *)va_arg (ap, const char *);
451	sv = str ? newSVpv (str, 0) : &PL_sv_undef;	627	sv = str ? newSVpv (str, 0) : newSV (0);
452	}	628	}
453	break;	629	break;
454		630
455	case DT_DATA:	631	case DT_DATA:
456	{	632	{
457	char *str = (char *)va_arg (ap, const void *);	633	char *str = (char *)va_arg (ap, const void *);
458	int len = va_arg (ap, int);	634	int len = va_arg (ap, int);
459	sv = str ? newSVpv (str, len) : &PL_sv_undef;	635	sv = str ? newSVpv (str, len) : newSV (0);
460	}	636	}
461	break;	637	break;
462		638
463	case DT_OBJECT:	639	case DT_OBJECT:
464	sv = to_sv (va_arg (ap, object *));	640	sv = to_sv (va_arg (ap, object *));
…		…
506	va_end (ap);	682	va_end (ap);
507		683
508	return sv;	684	return sv;
509	}	685	}
510		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
511	static SV *	713	static SV *
512	newSVcfapi (int type, ...)
513	{
514	SV *sv;
515
516	va_list ap;
517	va_start (ap, type);
518
519	switch (type)
520	{
521	case CFAPI_INT: sv = newSViv (*va_arg (ap, int * )); break;
522	case CFAPI_LONG: sv = newSVval64 (*va_arg (ap, sint64 *)); break;
523	case CFAPI_DOUBLE: sv = newSVnv (*va_arg (ap, double *)); break;
524	case CFAPI_STRING: sv = newSVdt_va (ap, DT_STRING); break;
525	case CFAPI_POBJECT: sv = newSVdt_va (ap, DT_OBJECT); break;
526	case CFAPI_PMAP: sv = newSVdt_va (ap, DT_MAP ); break;
527	case CFAPI_PPLAYER: sv = newSVdt_va (ap, DT_PLAYER); break;
528	case CFAPI_PARCH: sv = newSVdt_va (ap, DT_ARCH ); break;
529	case CFAPI_PPARTY: sv = newSVdt_va (ap, DT_PARTY ); break;
530	case CFAPI_PREGION: sv = newSVdt_va (ap, DT_REGION); break;
531
532	default:
533	assert (("unhandled type in newSVcfapi", 0));
534	}
535
536	va_end (ap);
537
538	return sv;
539	}
540
541	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
542
543	SV *
544	registry (attachable *ext)	714	registry (attachable *ext)
545	{	715	{
546	if (!ext->cb)	716	if (!ext->cb)
547	ext->cb = newAV ();	717	ext->cb = newAV ();
548		718
549	return newRV_inc ((SV *)ext->cb);	719	return newRV_inc ((SV *)ext->cb);
550	}	720	}
551		721
552	/////////////////////////////////////////////////////////////////////////////	722	/////////////////////////////////////////////////////////////////////////////
553		723
554	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
555	{
556	return 0;
557	}
558
559	static CommArray_s rtn_cmd;
560
561	static int
562	runPluginCommand (object *obj, char *params)
563	{
564	return -1;
565	}
566
567	extern "C" void *cfperl_getPluginProperty (int *type, ...)
568	{
569	va_list args;
570	char *propname;
571	int i;
572	va_start (args, type);
573	propname = va_arg (args, char *);
574	//printf ("Property name: %s\n", propname);
575
576	if (!strcmp (propname, "command?"))
577	return NULL;
578	else if (!strcmp (propname, "Identification"))
579	{
580	va_end (args);
581	return (void *)PLUGIN_NAME;
582	}
583	else if (!strcmp (propname, "FullName"))
584	{
585	va_end (args);
586	return (void *)PLUGIN_VERSION;
587	}
588	else
589	va_end (args);
590
591	return NULL;
592	}
593
594	extern "C" int cfperl_postInitPlugin ()
595	{
596	int hooktype = 1;
597	int rtype = 0;
598
599	cf_init_plugin (gethook);
600
601	return 0;
602	}
603
604	extern "C" int cfperl_closePlugin ()
605	{
606	return 0;
607	}
608
609	void	724	void
610	cfperl_init ()	725	cfperl_init ()
611	{	726	{
		727	extern char **environ;
		728
612	PERL_SYS_INIT3 (&settings.argc, &settings.argv, 0);	729	PERL_SYS_INIT3 (&settings.argc, &settings.argv, &environ);
613	perl = perl_alloc ();	730	perl = perl_alloc ();
614	perl_construct (perl);	731	perl_construct (perl);
615		732
616	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;	733	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
617		734
618	const char *argv[] = {	735	const char *argv[] = {
619	settings.argv [0],	736	settings.argv [0],
620	"-e"	737	"-e0"
621	"use Event; use Coro;" // required for bootstrap
622	"cf->bootstrap;" // required for datadir :*>
623	"unshift @INC, cf::datadir ();"
624	"require cf;"
625	};	738	};
626		739
627	if (perl_parse (perl, xs_init, 2, (char **)argv, (char **)NULL)	740	if (perl_parse (perl, xs_init, 2, (char **)argv, environ)
628	|| perl_run (perl))	741	|| perl_run (perl))
629	{	742	{
630	printf ("unable to initialize perl-interpreter, aborting.\n");	743	printf ("unable to initialize perl-interpreter, aborting.\n");
631	exit (EXIT_FAILURE);	744	exit (EXIT_FAILURE);
632	}	745	}
633		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))
634	{	758	{
635	dSP;	759	printf ("unable to bootstrap perl, aborting:\n%s", SvPV_nolen (ERRSV));
636		760	exit (EXIT_FAILURE);
637	PUSHMARK (SP);
638	PUTBACK;
639	call_pv ("cf::init", G_DISCARD | G_VOID);
640	}	761	}
641	}	762	}
642		763
		764	void
643	void cfperl_main ()	765	cfperl_main ()
644	{	766	{
645	dSP;	767	dSP;
646		768
647	PUSHMARK (SP);	769	PUSHMARK (SP);
648	PUTBACK;	770	PUTBACK;
…		…
652	void	774	void
653	attachable::instantiate ()	775	attachable::instantiate ()
654	{	776	{
655	if (attach)	777	if (attach)
656	{	778	{
657	invoke (EVENT_ATTACHABLE_INSTANTIATE, ARG_STRING (attach), DT_END);	779	INVOKE_ATTACHABLE (INSTANTIATE, this, ARG_STRING (attach));
658	attach = 0;	780	attach = 0;
659	}	781	}
660	}	782	}
661		783
662	void	784	void
663	attachable::reattach ()	785	attachable::reattach ()
664	{	786	{
665	optimise ();	787	optimise ();
666	//TODO: check for _attachment's, very important for restarts	788	//TODO: check for _attachment's, very important for restarts
667	invoke (EVENT_ATTACHABLE_REATTACH, DT_END);	789	INVOKE_ATTACHABLE (REATTACH, this);
668	}	790	}
669		791
670	static event_klass klass_of[NUM_EVENT_TYPES] = {	792	static event_klass klass_of[NUM_EVENT_TYPES] = {
671	# define def(type,name) KLASS_ ## type,	793	# define def(type,name) KLASS_ ## type,
672	# include "eventinc.h"	794	# include "eventinc.h"
673	# undef def	795	# undef def
674	};	796	};
675		797
676	#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)
677		799
678	static void	800	static void noinline
679	gather_callbacks (AV *&callbacks, AV *registry, event_type event)	801	gather_callbacks (AV *&callbacks, AV *registry, event_type event)
680	{	802	{
681	// event must be in array	803	// event must be in array
682	if (event >= 0 && event <= AvFILLp (registry))	804	if (event >= 0 && event <= AvFILLp (registry))
683	{	805	{
…		…
715	}	837	}
716		838
717	void	839	void
718	global::gather_callbacks (AV *&callbacks, event_type event) const	840	global::gather_callbacks (AV *&callbacks, event_type event) const
719	{	841	{
720	::gather_callbacks (callbacks, cb_object, event);	842	::gather_callbacks (callbacks, cb_global, event);
721	}	843	}
722		844
723	void	845	void
724	object::gather_callbacks (AV *&callbacks, event_type event) const	846	object::gather_callbacks (AV *&callbacks, event_type event) const
725	{	847	{
726	if (subtype && type + subtype * NUM_SUBTYPES <= AvFILLp (cb_type))	848	if (subtype && type + subtype * NUM_TYPES <= AvFILLp (cb_type))
727	{	849	{
728	SV *registry = AvARRAY (cb_type)[type + subtype * NUM_SUBTYPES];	850	SV *registry = AvARRAY (cb_type)[type + subtype * NUM_TYPES];
729		851
730	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)	852	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
731	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);	853	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);
732	}	854	}
733		855
…		…
769	{	891	{
770	attachable::gather_callbacks (callbacks, event);	892	attachable::gather_callbacks (callbacks, event);
771	::gather_callbacks (callbacks, cb_map, event);	893	::gather_callbacks (callbacks, cb_map, event);
772	}	894	}
773		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
774	bool	946	bool
775	attachable::invoke (event_type event, ...)	947	attachable::invoke (event_type event, ...)
776	{	948	{
777	data_type dt;	949	data_type dt;
778	va_list ap;
779
780	va_start (ap, event);
781		950
782	// callback call ordering should be:	951	// callback call ordering should be:
783	// 1. per-object callback	952	// 1. per-object callback
784	// 2. per-class object	953	// 2. per-class object
785	// 3. per-type callback	954	// 3. per-type callback
…		…
789	gather_callbacks (callbacks, event);	958	gather_callbacks (callbacks, event);
790		959
791	// short-circuit processing if no callbacks found/defined	960	// short-circuit processing if no callbacks found/defined
792	if (!callbacks)	961	if (!callbacks)
793	return 0;	962	return 0;
		963
		964	va_list ap;
		965	va_start (ap, event);
794		966
795	CALL_BEGIN (3);	967	CALL_BEGIN (3);
796	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays	968	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays
797	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));	969	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));
798		970
…		…
822	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));	994	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
823	}	995	}
824		996
825	va_end (ap);	997	va_end (ap);
826		998
827	CALL_CALL ("cf::do_invoke", G_SCALAR);	999	CALL_CALL (cv_cf_do_invoke, G_SCALAR);
828	count = count > 0 ? POPi : 0;	1000	count = count > 0 ? POPi : 0;
829		1001
830	CALL_END;	1002	CALL_END;
831		1003
832	return count;	1004	return count;
833	}	1005	}
834		1006
835	SV *	1007	static SV *
836	cfperl_result (int idx)	1008	cfperl_result (int idx)
837	{	1009	{
838	AV *av = get_av ("cfperl::invoke_results", 0);	1010	AV *av = get_av ("cf::INVOKE_RESULTS", 0);
839	if (!av)	1011	if (!av)
840	return &PL_sv_undef;	1012	return &PL_sv_undef;
841		1013
842	SV **sv = av_fetch (av, idx, 0);	1014	SV **sv = av_fetch (av, idx, 0);
843	if (!sv)	1015	if (!sv)
…		…
857	{	1029	{
858	return SvNV (cfperl_result (idx));	1030	return SvNV (cfperl_result (idx));
859	}	1031	}
860		1032
861	/////////////////////////////////////////////////////////////////////////////	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	}
862		1054
863	void	1055	void
864	cfperl_emergency_save ()	1056	cfperl_emergency_save ()
865	{	1057	{
866	CALL_BEGIN (0);	1058	CALL_BEGIN (0);
…		…
875	CALL_ARG (make_core);	1067	CALL_ARG (make_core);
876	CALL_CALL ("cf::post_cleanup", G_VOID);	1068	CALL_CALL ("cf::post_cleanup", G_VOID);
877	CALL_END;	1069	CALL_END;
878	}	1070	}
879		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
880	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 *
881	maptile::find_sync (const char *path, maptile *origin)	1154	maptile::find_sync (const_utf8_string path, maptile *origin)
882	{	1155	{
883	CALL_BEGIN (2);	1156	CALL_BEGIN (2);
884	CALL_ARG (path);	1157	CALL_ARG (path);
885	CALL_ARG (origin);	1158	CALL_ARG (origin);
886	CALL_CALL ("cf::map::find_sync", G_SCALAR);	1159	CALL_CALL ("cf::map::find_sync", G_SCALAR);
887		1160
888	maptile *retval;	1161	maptile *retval = 0;
889
890	if (count)
891	sv_to (POPs, retval);	1162	if (count) sv_to (POPs, retval);
892	else
893	retval = 0;
894		1163
895	CALL_END;	1164	CALL_END;
896		1165
897	return retval;	1166	return retval;
898	}	1167	}
899		1168
900	maptile *	1169	maptile *
901	maptile::find_async (const char *path, maptile *origin)	1170	maptile::find_async (const_utf8_string path, maptile *origin, bool load)
902	{	1171	{
903	CALL_BEGIN (2);	1172	CALL_BEGIN (3);
904	CALL_ARG (path);	1173	CALL_ARG (path);
905	CALL_ARG (origin);	1174	CALL_ARG (origin);
		1175	CALL_ARG (load);
906	CALL_CALL ("cf::map::find_async", G_SCALAR);	1176	CALL_CALL ("cf::map::find_async", G_SCALAR);
907		1177
908	maptile *retval;	1178	maptile *retval = 0;
909
910	if (count)
911	sv_to (POPs, retval);	1179	if (count) sv_to (POPs, retval);
912	else
913	retval = 0;
914		1180
915	CALL_END;	1181	CALL_END;
916		1182
917	return retval;	1183	return retval;
918	}	1184	}
…		…
921	maptile::do_load_sync ()	1187	maptile::do_load_sync ()
922	{	1188	{
923	CALL_BEGIN (1);	1189	CALL_BEGIN (1);
924	CALL_ARG (this);	1190	CALL_ARG (this);
925	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);	1191	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);
926	CALL_END;
927	}
928
929	void
930	maptile::change_all_map_light (int change)
931	{
932	CALL_BEGIN (1);
933	CALL_ARG (change);
934	CALL_CALL ("cf::map::change_all_map_light", G_VOID);
935	CALL_END;	1192	CALL_END;
936	}	1193	}
937		1194
938	void	1195	void
939	object::enter_exit (object *exit)	1196	object::enter_exit (object *exit)
…		…
947	CALL_CALL ("cf::object::player::enter_exit", G_VOID);	1204	CALL_CALL ("cf::object::player::enter_exit", G_VOID);
948	CALL_END;	1205	CALL_END;
949	}	1206	}
950		1207
951	void	1208	void
952	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	return 0;
		1230	}
		1231
		1232	object *
		1233	object::deref (const_utf8_string ref)
		1234	{
		1235	object *retval = 0;
		1236
		1237	if (ref)
		1238	{
		1239	CALL_BEGIN (1);
		1240	CALL_ARG (ref);
		1241	CALL_CALL ("cf::object::deref", G_SCALAR);
		1242
		1243	if (count)
		1244	sv_to (POPs, retval);
		1245
		1246	CALL_END;
		1247	}
		1248
		1249	return retval;
		1250	}
		1251
		1252	void
		1253	log_backtrace (const_utf8_string msg)
953	{	1254	{
954	#if HAVE_BACKTRACE	1255	#if HAVE_BACKTRACE
955	void *addr [20];	1256	void *addr [20];
956	int size = backtrace (addr, 20);	1257	int size = backtrace (addr, 20);
957		1258
…		…
962	CALL_CALL ("cf::_log_backtrace", G_VOID);	1263	CALL_CALL ("cf::_log_backtrace", G_VOID);
963	CALL_END;	1264	CALL_END;
964	#endif	1265	#endif
965	}	1266	}
966		1267
		1268	bool
		1269	is_match_expr (const_utf8_string expr)
		1270	{
		1271	return !strncmp (expr, "match ", sizeof ("match ") - 1);
		1272	}
		1273
		1274	bool
		1275	match (const_utf8_string expr, object *ob, object *self, object *source, object *originator)
		1276	{
		1277	if (!strncmp (expr, "match ", sizeof ("match ") - 1))
		1278	expr += sizeof ("match ") - 1;
		1279
		1280	CALL_BEGIN (5);
		1281	CALL_ARG (expr);
		1282	CALL_ARG (ob);
		1283	CALL_ARG (self);
		1284	CALL_ARG (source);
		1285	CALL_ARG (originator);
		1286	CALL_CALL (cv_cf_match_match, G_SCALAR);
		1287
		1288	bool matched = count && SvTRUE (TOPs);
		1289
		1290	CALL_END;
		1291
		1292	return matched;
		1293	}
		1294
		1295	object *
		1296	match_one (const_utf8_string expr, object *ob, object *self, object *source, object *originator)
		1297	{
		1298	if (!strncmp (expr, "match ", sizeof ("match ") - 1))
		1299	expr += sizeof ("match ") - 1;
		1300
		1301	CALL_BEGIN (5);
		1302	CALL_ARG (expr);
		1303	CALL_ARG (ob);
		1304	CALL_ARG (self);
		1305	CALL_ARG (source);
		1306	CALL_ARG (originator);
		1307	CALL_CALL (cv_cf_match_match, G_ARRAY);
		1308
		1309	object *one = 0;
		1310
		1311	if (count)
		1312	sv_to (TOPs, one);
		1313
		1314	CALL_END;
		1315
		1316	return one;
		1317	}
		1318
967	/////////////////////////////////////////////////////////////////////////////	1319	/////////////////////////////////////////////////////////////////////////////
968		1320
969	struct EventAPI *watcher_base::GEventAPI;	1321	struct EVAPI *evapi::GEVAPI;
970	struct CoroAPI *coroapi::GCoroAPI;	1322	struct CoroAPI *coroapi::GCoroAPI;
971		1323
972	int coroapi::cede_counter;	1324	void
973	double (*coroapi::time)();
974	double coroapi::next_cede;
975
976	void coroapi::do_cede_to_tick ()	1325	coroapi::do_cede_to_tick ()
977	{	1326	{
978	cede_counter = 0;	1327	cede_pending = 0;
979
980	cede ();	1328	cede ();
981
982	next_cede += (TICK / CEDES_PER_TICK) * 0.99;
983	if (next_cede > SvNV (sv_next_tick) - 0.02)
984	next_cede = SvNV (sv_next_tick);
985	}
986
987	void coroapi::do_cede_every ()
988	{
989	cede_counter = 0;
990
991	if (coroapi::nready ())
992	coroapi::cede ();
993	}
994
995	void coroapi::do_cede_to_tick_every ()
996	{
997	cede_counter = 0;
998
999	cede_to_tick ();
1000	}	1329	}
1001		1330
1002	void	1331	void
1003	coroapi::wait_for_tick ()	1332	coroapi::wait_for_tick ()
1004	{	1333	{
…		…
1013	CALL_BEGIN (0);	1342	CALL_BEGIN (0);
1014	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);	1343	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);
1015	CALL_END;	1344	CALL_END;
1016	}	1345	}
1017		1346
		1347	void
		1348	iow::poll (int events)
		1349	{
		1350	if (events != this->events)
		1351	{
		1352	int active = ev_is_active ((ev_io *)this);
		1353	if (active) stop ();
		1354	ev_io_set ((ev_io *)this, fd, events);
		1355	if (active) start ();
		1356	}
		1357	}
		1358
1018	static void	1359	static void
1019	iw_dispatch (pe_event *ev)
1020	{
1021	iw *w = (iw *)ev->ext_data;
1022	w->call (*w);
1023	}
1024
1025	void
1026	iw::alloc ()
1027	{
1028	pe = GEventAPI->new_idle (0, 0);
1029
1030	WaREENTRANT_off (pe);
1031	pe->base.callback = (void *)iw_dispatch;
1032	pe->base.ext_data = (void *)this;
1033	}
1034
1035	static void iow_dispatch (pe_event *ev)
1036	{
1037	iow *w = (iow *)ev->ext_data;
1038	w->call (*w, ((pe_ioevent *)ev)->got);
1039	}
1040
1041	void
1042	iow::alloc ()
1043	{
1044	pe = GEventAPI->new_io (0, 0);
1045
1046	WaREENTRANT_off (pe);
1047	pe->base.callback = (void *)iow_dispatch;
1048	pe->base.ext_data = (void *)this;
1049
1050	pe->fd = -1;
1051	pe->poll = 0;
1052	}
1053
1054	void
1055	iow::fd (int fd)
1056	{
1057	pe->fd = fd;
1058	}
1059
1060	int
1061	iow::poll ()
1062	{
1063	return pe->poll;
1064	}
1065
1066	void
1067	iow::poll (int events)
1068	{
1069	if (pe->poll != events)
1070	{
1071	if (pe->poll) stop ();
1072	pe->poll = events;
1073	if (pe->poll) start ();
1074	}
1075	}
1076
1077	void
1078	_connect_to_perl ()	1360	_connect_to_perl_1 ()
1079	{	1361	{
1080	stash_cf = gv_stashpv ("cf" , 1);	1362	stash_cf = gv_stashpv ("cf", 1);
1081		1363
1082	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);	1364	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);
1083	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);	1365	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);
1084	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);	1366	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);
1085	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);	1367	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);
		1368	stash_cf_mapspace_wrap = gv_stashpv ("cf::mapspace::wrap" , 1);
1086	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);	1369	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);
1087	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);	1370	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
1088	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);	1371	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
1089	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);	1372	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
1090	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);	1373	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
1091		1374
		1375	sv_now = get_sv ("cf::NOW" , 1); SvUPGRADE (sv_now , SVt_NV);
1092	sv_runtime = get_sv ("cf::RUNTIME" , 1); sv_upgrade (sv_runtime , SVt_NV);	1376	sv_runtime = get_sv ("cf::RUNTIME" , 1); SvUPGRADE (sv_runtime , SVt_NV);
		1377	sv_tick_start = get_sv ("cf::TICK_START", 1); SvUPGRADE (sv_tick_start, SVt_NV);
1093	sv_next_tick = get_sv ("cf::NEXT_TICK", 1); sv_upgrade (sv_next_tick, SVt_NV);	1378	sv_next_tick = get_sv ("cf::NEXT_TICK" , 1); SvUPGRADE (sv_next_tick , SVt_NV);
1094		1379
1095	cb_global = get_av ("cf::CB_GLOBAL", 1);	1380	cb_global = get_av ("cf::CB_GLOBAL", 1);
1096	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);	1381	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
1097	cb_object = get_av ("cf::CB_OBJECT", 1);	1382	cb_object = get_av ("cf::CB_OBJECT", 1);
1098	cb_player = get_av ("cf::CB_PLAYER", 1);	1383	cb_player = get_av ("cf::CB_PLAYER", 1);
1099	cb_client = get_av ("cf::CB_CLIENT", 1);	1384	cb_client = get_av ("cf::CB_CLIENT", 1);
1100	cb_type = get_av ("cf::CB_TYPE" , 1);	1385	cb_type = get_av ("cf::CB_TYPE" , 1);
1101	cb_map = get_av ("cf::CB_MAP" , 1);	1386	cb_map = get_av ("cf::CB_MAP" , 1);
1102	}	1387	}
1103		1388
		1389	static void
		1390	_connect_to_perl_2 ()
		1391	{
		1392	cv_cf_do_invoke = (SV *)get_cv ("cf::do_invoke" , 0); assert (cv_cf_do_invoke);
		1393	cv_cf__can_merge = (SV *)get_cv ("cf::_can_merge" , 0); assert (cv_cf__can_merge);
		1394	cv_cf_client_send_msg = (SV *)get_cv ("cf::client::send_msg", 0); assert (cv_cf_client_send_msg);
		1395	cv_cf_tick = (SV *)get_cv ("cf::tick" , 0); assert (cv_cf_tick);
		1396	cv_cf_match_match = (SV *)get_cv ("cf::match::match" , 0); assert (cv_cf_match_match);
		1397	}
		1398
1104	MODULE = cf PACKAGE = cf PREFIX = cf_	1399	MODULE = cf PACKAGE = cf PREFIX = cf_
1105		1400
1106	BOOT:	1401	BOOT:
1107	{	1402	{
1108	I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;	1403	I_EV_API (PACKAGE); evapi::GEVAPI = GEVAPI;
1109	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;	1404	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
1110		1405
1111	_connect_to_perl ();	1406	_connect_to_perl_1 ();
1112		1407
1113	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));	1408	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
1114		1409
1115	{	1410	//{
1116	require_pv ("Time::HiRes");	1411	// require_pv ("Time::HiRes");
1117		1412	//
1118	SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);	1413	// SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
1119	if (!svp) croak ("Time::HiRes is required");	1414	// if (!svp) croak ("Time::HiRes is required");
1120	if (!SvIOK(*svp)) croak ("Time::NVtime isn’t a function pointer");	1415	// if (!SvIOK(*svp)) croak ("Time::NVtime isn’t a function pointer");
1121	coroapi::time = INT2PTR (double(*)(), SvIV(*svp));	1416	// coroapi::time = INT2PTR (double(*)(), SvIV(*svp));
1122	}	1417	//}
1123		1418
1124	static const struct {	1419	static const struct {
1125	const char *name;	1420	const char *name;
1126	IV iv;	1421	IV iv;
1127	} *civ, const_iv[] = {	1422	} *civ, const_iv[] = {
…		…
1132	const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)	1427	const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)
1133		1428
1134	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)	1429	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)
1135		1430
1136	const_iv (MAX_TIME)	1431	const_iv (MAX_TIME)
		1432	const_iv (MAXSOCKBUF)
1137		1433
1138	const_iv (NUM_BODY_LOCATIONS)	1434	const_iv (NUM_BODY_LOCATIONS)
1139	const_iv (body_range) const_iv (body_shield) const_iv (body_combat)	1435	const_iv (body_range) const_iv (body_shield) const_iv (body_combat)
1140	const_iv (body_arm) const_iv (body_torso) const_iv (body_head)	1436	const_iv (body_arm) const_iv (body_torso) const_iv (body_head)
1141	const_iv (body_neck) const_iv (body_skill) const_iv (body_finger)	1437	const_iv (body_neck) const_iv (body_skill) const_iv (body_finger)
…		…
1159	const_iv (MOOD_FLOOR) const_iv (EXIT) const_iv (ENCOUNTER) const_iv (SHOP_FLOOR)	1455	const_iv (MOOD_FLOOR) const_iv (EXIT) const_iv (ENCOUNTER) const_iv (SHOP_FLOOR)
1160	const_iv (SHOP_MAT) const_iv (RING) const_iv (FLOOR) const_iv (FLESH)	1456	const_iv (SHOP_MAT) const_iv (RING) const_iv (FLOOR) const_iv (FLESH)
1161	const_iv (INORGANIC) const_iv (SKILL_TOOL) const_iv (LIGHTER) const_iv (BUILDABLE_WALL)	1457	const_iv (INORGANIC) const_iv (SKILL_TOOL) const_iv (LIGHTER) const_iv (BUILDABLE_WALL)
1162	const_iv (MISC_OBJECT) const_iv (LAMP) const_iv (DUPLICATOR) const_iv (SPELLBOOK)	1458	const_iv (MISC_OBJECT) const_iv (LAMP) const_iv (DUPLICATOR) const_iv (SPELLBOOK)
1163	const_iv (CLOAK) const_iv (SPINNER) const_iv (GATE) const_iv (BUTTON)	1459	const_iv (CLOAK) const_iv (SPINNER) const_iv (GATE) const_iv (BUTTON)
1164	const_iv (CF_HANDLE) const_iv (HOLE) const_iv (TRAPDOOR) const_iv (SIGN)	1460	const_iv (T_HANDLE) const_iv (HOLE) const_iv (TRAPDOOR) const_iv (SIGN)
1165	const_iv (BOOTS) const_iv (GLOVES) const_iv (SPELL) const_iv (SPELL_EFFECT)	1461	const_iv (BOOTS) const_iv (GLOVES) const_iv (SPELL) const_iv (SPELL_EFFECT)
1166	const_iv (CONVERTER) const_iv (BRACERS) const_iv (POISONING) const_iv (SAVEBED)	1462	const_iv (CONVERTER) const_iv (BRACERS) const_iv (POISONING) const_iv (SAVEBED)
1167	const_iv (WAND) const_iv (SCROLL) const_iv (DIRECTOR) const_iv (GIRDLE)	1463	const_iv (WAND) const_iv (SCROLL) const_iv (DIRECTOR) const_iv (GIRDLE)
1168	const_iv (FORCE) const_iv (POTION_EFFECT) const_iv (EVENT_CONNECTOR) const_iv (CLOSE_CON)	1464	const_iv (FORCE) const_iv (POTION_EFFECT) const_iv (EVENT_CONNECTOR) const_iv (CLOSE_CON)
1169	const_iv (CONTAINER) const_iv (ARMOUR_IMPROVER) const_iv (WEAPON_IMPROVER) const_iv (SKILLSCROLL)	1465	const_iv (CONTAINER) const_iv (ARMOUR_IMPROVER) const_iv (WEAPON_IMPROVER) const_iv (SKILLSCROLL)
1170	const_iv (DEEP_SWAMP) const_iv (IDENTIFY_ALTAR) const_iv (MENU) const_iv (RUNE)	1466	const_iv (DEEP_SWAMP) const_iv (IDENTIFY_ALTAR) const_iv (MENU) const_iv (RUNE)
1171	const_iv (TRAP) const_iv (POWER_CRYSTAL) const_iv (CORPSE) const_iv (DISEASE)	1467	const_iv (TRAP) const_iv (POWER_CRYSTAL) const_iv (CORPSE) const_iv (DISEASE)
1172	const_iv (SYMPTOM) const_iv (BUILDER) const_iv (MATERIAL) const_iv (ITEM_TRANSFORMER)	1468	const_iv (SYMPTOM) const_iv (BUILDER) const_iv (MATERIAL) const_iv (ITEM_TRANSFORMER)
		1469	const_iv (MAPSCRIPT) const_iv (SAFE_GROUND)
1173		1470
1174	const_iv (NUM_SUBTYPES)	1471	const_iv (NUM_TYPES) const_iv (NUM_SUBTYPES)
1175		1472
1176	const_iv (ST_BD_BUILD) const_iv (ST_BD_REMOVE)	1473	const_iv (ST_BD_BUILD) const_iv (ST_BD_REMOVE)
1177	const_iv (ST_MAT_FLOOR) const_iv (ST_MAT_WALL) const_iv (ST_MAT_ITEM)	1474	const_iv (ST_MAT_FLOOR) const_iv (ST_MAT_WALL) const_iv (ST_MAT_ITEM)
1178		1475
1179	const_iv (AT_PHYSICAL) const_iv (AT_MAGIC) const_iv (AT_FIRE) const_iv (AT_ELECTRICITY)	1476	const_iv (AT_PHYSICAL) const_iv (AT_MAGIC) const_iv (AT_FIRE) const_iv (AT_ELECTRICITY)
…		…
1194	const_iv (FLAG_GENERATOR) const_iv (FLAG_IS_THROWN) const_iv (FLAG_AUTO_APPLY) const_iv (FLAG_PLAYER_SOLD)	1491	const_iv (FLAG_GENERATOR) const_iv (FLAG_IS_THROWN) const_iv (FLAG_AUTO_APPLY) const_iv (FLAG_PLAYER_SOLD)
1195	const_iv (FLAG_SEE_INVISIBLE) const_iv (FLAG_CAN_ROLL) const_iv (FLAG_OVERLAY_FLOOR) const_iv (FLAG_IS_TURNABLE)	1492	const_iv (FLAG_SEE_INVISIBLE) const_iv (FLAG_CAN_ROLL) const_iv (FLAG_OVERLAY_FLOOR) const_iv (FLAG_IS_TURNABLE)
1196	const_iv (FLAG_IS_USED_UP) const_iv (FLAG_IDENTIFIED) const_iv (FLAG_REFLECTING) const_iv (FLAG_CHANGING)	1493	const_iv (FLAG_IS_USED_UP) const_iv (FLAG_IDENTIFIED) const_iv (FLAG_REFLECTING) const_iv (FLAG_CHANGING)
1197	const_iv (FLAG_SPLITTING) const_iv (FLAG_HITBACK) const_iv (FLAG_STARTEQUIP) const_iv (FLAG_BLOCKSVIEW)	1494	const_iv (FLAG_SPLITTING) const_iv (FLAG_HITBACK) const_iv (FLAG_STARTEQUIP) const_iv (FLAG_BLOCKSVIEW)
1198	const_iv (FLAG_UNDEAD) const_iv (FLAG_SCARED) const_iv (FLAG_UNAGGRESSIVE) const_iv (FLAG_REFL_MISSILE)	1495	const_iv (FLAG_UNDEAD) const_iv (FLAG_SCARED) const_iv (FLAG_UNAGGRESSIVE) const_iv (FLAG_REFL_MISSILE)
1199	const_iv (FLAG_REFL_SPELL) const_iv (FLAG_NO_MAGIC) const_iv (FLAG_NO_FIX_PLAYER) const_iv (FLAG_IS_LIGHTABLE)	1496	const_iv (FLAG_REFL_SPELL) const_iv (FLAG_NO_MAGIC) const_iv (FLAG_IS_LIGHTABLE)
1200	const_iv (FLAG_TEAR_DOWN) const_iv (FLAG_RUN_AWAY) const_iv (FLAG_PICK_UP) const_iv (FLAG_UNIQUE)	1497	const_iv (FLAG_TEAR_DOWN) const_iv (FLAG_RUN_AWAY) const_iv (FLAG_PICK_UP) const_iv (FLAG_UNIQUE)
1201	const_iv (FLAG_NO_DROP) const_iv (FLAG_WIZCAST) const_iv (FLAG_CAST_SPELL) const_iv (FLAG_USE_SCROLL)	1498	const_iv (FLAG_NO_DROP) const_iv (FLAG_WIZCAST) const_iv (FLAG_CAST_SPELL) const_iv (FLAG_USE_SCROLL)
1202	const_iv (FLAG_USE_RANGE) const_iv (FLAG_USE_BOW) const_iv (FLAG_USE_ARMOUR) const_iv (FLAG_USE_WEAPON)	1499	const_iv (FLAG_USE_RANGE) const_iv (FLAG_USE_BOW) const_iv (FLAG_USE_ARMOUR) const_iv (FLAG_USE_WEAPON)
1203	const_iv (FLAG_USE_RING) const_iv (FLAG_READY_RANGE) const_iv (FLAG_READY_BOW) const_iv (FLAG_XRAYS)	1500	const_iv (FLAG_USE_RING) const_iv (FLAG_READY_RANGE) const_iv (FLAG_READY_BOW) const_iv (FLAG_XRAYS)
1204	const_iv (FLAG_NO_APPLY) const_iv (FLAG_IS_FLOOR) const_iv (FLAG_LIFESAVE) const_iv (FLAG_NO_STRENGTH)	1501	const_iv (FLAG_NO_APPLY) const_iv (FLAG_IS_FLOOR) const_iv (FLAG_LIFESAVE) const_iv (FLAG_NO_STRENGTH)
…		…
1207	const_iv (FLAG_CURSED) const_iv (FLAG_DAMNED) const_iv (FLAG_SEE_ANYWHERE) const_iv (FLAG_KNOWN_MAGICAL)	1504	const_iv (FLAG_CURSED) const_iv (FLAG_DAMNED) const_iv (FLAG_SEE_ANYWHERE) const_iv (FLAG_KNOWN_MAGICAL)
1208	const_iv (FLAG_KNOWN_CURSED) const_iv (FLAG_CAN_USE_SKILL) const_iv (FLAG_BEEN_APPLIED) const_iv (FLAG_READY_SCROLL)	1505	const_iv (FLAG_KNOWN_CURSED) const_iv (FLAG_CAN_USE_SKILL) const_iv (FLAG_BEEN_APPLIED) const_iv (FLAG_READY_SCROLL)
1209	const_iv (FLAG_USE_ROD) const_iv (FLAG_USE_HORN) const_iv (FLAG_MAKE_INVIS) const_iv (FLAG_INV_LOCKED)	1506	const_iv (FLAG_USE_ROD) const_iv (FLAG_USE_HORN) const_iv (FLAG_MAKE_INVIS) const_iv (FLAG_INV_LOCKED)
1210	const_iv (FLAG_IS_WOODED) const_iv (FLAG_IS_HILLY) const_iv (FLAG_READY_SKILL) const_iv (FLAG_READY_WEAPON)	1507	const_iv (FLAG_IS_WOODED) const_iv (FLAG_IS_HILLY) const_iv (FLAG_READY_SKILL) const_iv (FLAG_READY_WEAPON)
1211	const_iv (FLAG_NO_SKILL_IDENT) const_iv (FLAG_BLIND) const_iv (FLAG_SEE_IN_DARK) const_iv (FLAG_IS_CAULDRON)	1508	const_iv (FLAG_NO_SKILL_IDENT) const_iv (FLAG_BLIND) const_iv (FLAG_SEE_IN_DARK) const_iv (FLAG_IS_CAULDRON)
1212	const_iv (FLAG_NO_STEAL) const_iv (FLAG_ONE_HIT) const_iv (FLAG_CLIENT_SENT) const_iv (FLAG_BERSERK)	1509	const_iv (FLAG_NO_STEAL) const_iv (FLAG_ONE_HIT) const_iv (FLAG_DEBUG) const_iv (FLAG_BERSERK)
1213	const_iv (FLAG_NEUTRAL) const_iv (FLAG_NO_ATTACK) const_iv (FLAG_NO_DAMAGE) const_iv (FLAG_OBJ_ORIGINAL)	1510	const_iv (FLAG_NEUTRAL) const_iv (FLAG_NO_ATTACK) const_iv (FLAG_NO_DAMAGE) const_iv (FLAG_OBJ_ORIGINAL)
1214	const_iv (FLAG_OBJ_SAVE_ON_OVL) const_iv (FLAG_ACTIVATE_ON_PUSH) const_iv (FLAG_ACTIVATE_ON_RELEASE) const_iv (FLAG_IS_WATER)	1511	const_iv (FLAG_ACTIVATE_ON_PUSH) const_iv (FLAG_ACTIVATE_ON_RELEASE) const_iv (FLAG_IS_WATER) const_iv (FLAG_WIZLOOK)
1215	const_iv (FLAG_CONTENT_ON_GEN) const_iv (FLAG_IS_A_TEMPLATE) const_iv (FLAG_IS_BUILDABLE)	1512	const_iv (FLAG_CONTENT_ON_GEN) const_iv (FLAG_IS_A_TEMPLATE) const_iv (FLAG_IS_BUILDABLE)
1216	const_iv (FLAG_DESTROY_ON_DEATH) const_iv (FLAG_NO_MAP_SAVE)	1513	const_iv (FLAG_DESTROY_ON_DEATH) const_iv (FLAG_NO_MAP_SAVE)
1217		1514
1218	const_iv (NDI_BLACK) const_iv (NDI_WHITE) const_iv (NDI_NAVY) const_iv (NDI_RED)	1515	const_iv (NDI_BLACK) const_iv (NDI_WHITE) const_iv (NDI_NAVY) const_iv (NDI_RED)
1219	const_iv (NDI_ORANGE) const_iv (NDI_BLUE) const_iv (NDI_DK_ORANGE) const_iv (NDI_GREEN)	1516	const_iv (NDI_ORANGE) const_iv (NDI_BLUE) const_iv (NDI_DK_ORANGE) const_iv (NDI_GREEN)
1220	const_iv (NDI_LT_GREEN) const_iv (NDI_GREY) const_iv (NDI_BROWN) const_iv (NDI_GOLD)	1517	const_iv (NDI_LT_GREEN) const_iv (NDI_GREY) const_iv (NDI_BROWN) const_iv (NDI_GOLD)
1221	const_iv (NDI_TAN) const_iv (NDI_MAX_COLOR) const_iv (NDI_COLOR_MASK) const_iv (NDI_UNIQUE)	1518	const_iv (NDI_TAN) const_iv (NDI_MAX_COLOR) const_iv (NDI_COLOR_MASK) const_iv (NDI_UNIQUE)
1222	const_iv (NDI_ALL)	1519	const_iv (NDI_ALL) const_iv (NDI_DEF) const_iv (NDI_REPLY) const_iv (NDI_CLIENT_MASK)
		1520	const_iv (NDI_NOCREATE) const_iv (NDI_CLEAR) const_iv (NDI_VERBATIM)
1223		1521
1224	const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE)	1522	const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE)
1225	const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF)	1523	const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF)
1226		1524
1227	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_DAMAGE)	1525	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_DAMAGE)
		1526
		1527	const_iv (SP_RAISE_DEAD)
		1528	const_iv (SP_RUNE)
		1529	const_iv (SP_MAKE_MARK)
		1530	const_iv (SP_BOLT)
		1531	const_iv (SP_BULLET)
		1532	const_iv (SP_EXPLOSION)
		1533	const_iv (SP_CONE)
		1534	const_iv (SP_BOMB)
		1535	const_iv (SP_WONDER)
		1536	const_iv (SP_SMITE)
		1537	const_iv (SP_MAGIC_MISSILE)
		1538	const_iv (SP_SUMMON_GOLEM)
		1539	const_iv (SP_DIMENSION_DOOR)
		1540	const_iv (SP_MAGIC_MAPPING)
		1541	const_iv (SP_MAGIC_WALL)
		1542	const_iv (SP_DESTRUCTION)
		1543	const_iv (SP_PERCEIVE_SELF)
		1544	const_iv (SP_WORD_OF_RECALL)
		1545	const_iv (SP_INVISIBLE)
		1546	const_iv (SP_PROBE)
		1547	const_iv (SP_HEALING)
		1548	const_iv (SP_CREATE_FOOD)
		1549	const_iv (SP_EARTH_TO_DUST)
		1550	const_iv (SP_CHANGE_ABILITY)
		1551	const_iv (SP_BLESS)
		1552	const_iv (SP_CURSE)
		1553	const_iv (SP_SUMMON_MONSTER)
		1554	const_iv (SP_CHARGING)
		1555	const_iv (SP_POLYMORPH)
		1556	const_iv (SP_ALCHEMY)
		1557	const_iv (SP_REMOVE_CURSE)
		1558	const_iv (SP_IDENTIFY)
		1559	const_iv (SP_DETECTION)
		1560	const_iv (SP_MOOD_CHANGE)
		1561	const_iv (SP_MOVING_BALL)
		1562	const_iv (SP_SWARM)
		1563	const_iv (SP_CHANGE_MANA)
		1564	const_iv (SP_DISPEL_RUNE)
		1565	const_iv (SP_CREATE_MISSILE)
		1566	const_iv (SP_CONSECRATE)
		1567	const_iv (SP_ANIMATE_WEAPON)
		1568	const_iv (SP_LIGHT)
		1569	const_iv (SP_CHANGE_MAP_LIGHT)
		1570	const_iv (SP_FAERY_FIRE)
		1571	const_iv (SP_CAUSE_DISEASE)
		1572	const_iv (SP_AURA)
		1573	const_iv (SP_TOWN_PORTAL)
		1574	const_iv (SP_PARTY_SPELL)
1228		1575
1229	const_iv (F_APPLIED) const_iv (F_LOCATION) const_iv (F_UNPAID) const_iv (F_MAGIC)	1576	const_iv (F_APPLIED) const_iv (F_LOCATION) const_iv (F_UNPAID) const_iv (F_MAGIC)
1230	const_iv (F_CURSED) const_iv (F_DAMNED) const_iv (F_OPEN) const_iv (F_NOPICK)	1577	const_iv (F_CURSED) const_iv (F_DAMNED) const_iv (F_OPEN) const_iv (F_NOPICK)
1231	const_iv (F_LOCKED)	1578	const_iv (F_LOCKED)
1232		1579
1233	const_iv (F_BUY) const_iv (F_SHOP) const_iv (F_SELL)	1580	const_iv (F_BUY) const_iv (F_SHOP) const_iv (F_SELL)
1234		1581
1235	const_iv (P_BLOCKSVIEW) const_iv (P_PLAYER) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE)	1582	const_iv (P_BLOCKSVIEW) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE)
1236	const_iv (P_NO_CLERIC) const_iv (P_OUT_OF_MAP) const_iv (P_NEW_MAP) const_iv (P_UPTODATE)	1583	const_iv (P_NO_CLERIC) const_iv (P_OUT_OF_MAP) const_iv (P_NEW_MAP) const_iv (P_UPTODATE)
1237		1584
1238	const_iv (UP_OBJ_INSERT) const_iv (UP_OBJ_REMOVE) const_iv (UP_OBJ_CHANGE) const_iv (UP_OBJ_FACE)	1585	const_iv (UP_OBJ_INSERT) const_iv (UP_OBJ_REMOVE) const_iv (UP_OBJ_CHANGE) const_iv (UP_OBJ_FACE)
1239		1586
1240	const_iv (INS_NO_MERGE) const_iv (INS_ABOVE_FLOOR_ONLY) const_iv (INS_NO_WALK_ON)	1587	const_iv (INS_NO_MERGE) const_iv (INS_ABOVE_FLOOR_ONLY) const_iv (INS_NO_WALK_ON)
1241	const_iv (INS_ON_TOP) const_iv (INS_BELOW_ORIGINATOR) const_iv (INS_MAP_LOAD)	1588	const_iv (INS_ON_TOP) const_iv (INS_BELOW_ORIGINATOR)
1242		1589
1243	const_iv (WILL_APPLY_HANDLE) const_iv (WILL_APPLY_TREASURE) const_iv (WILL_APPLY_EARTHWALL)	1590	const_iv (WILL_APPLY_HANDLE) const_iv (WILL_APPLY_TREASURE) const_iv (WILL_APPLY_EARTHWALL)
1244	const_iv (WILL_APPLY_DOOR) const_iv (WILL_APPLY_FOOD)	1591	const_iv (WILL_APPLY_DOOR) const_iv (WILL_APPLY_FOOD)
1245		1592
1246	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)	1593	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)
…		…
1280	const_iv (ATNR_PARALYZE) const_iv (ATNR_TURN_UNDEAD) const_iv (ATNR_FEAR) const_iv (ATNR_CANCELLATION)	1627	const_iv (ATNR_PARALYZE) const_iv (ATNR_TURN_UNDEAD) const_iv (ATNR_FEAR) const_iv (ATNR_CANCELLATION)
1281	const_iv (ATNR_DEPLETE) const_iv (ATNR_DEATH) const_iv (ATNR_CHAOS) const_iv (ATNR_COUNTERSPELL)	1628	const_iv (ATNR_DEPLETE) const_iv (ATNR_DEATH) const_iv (ATNR_CHAOS) const_iv (ATNR_COUNTERSPELL)
1282	const_iv (ATNR_GODPOWER) const_iv (ATNR_HOLYWORD) const_iv (ATNR_BLIND) const_iv (ATNR_INTERNAL)	1629	const_iv (ATNR_GODPOWER) const_iv (ATNR_HOLYWORD) const_iv (ATNR_BLIND) const_iv (ATNR_INTERNAL)
1283	const_iv (ATNR_LIFE_STEALING) const_iv (ATNR_DISEASE)	1630	const_iv (ATNR_LIFE_STEALING) const_iv (ATNR_DISEASE)
1284		1631
1285	const_iv (MAP_IN_MEMORY) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)	1632	const_iv (MAP_ACTIVE) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)
		1633	const_iv (MAP_INACTIVE)
1286		1634
1287	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)	1635	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)
1288	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)	1636	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)
		1637
		1638	const_iv (VERSION_CS) const_iv (VERSION_SC)
1289		1639
1290	const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)	1640	const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)
1291		1641
1292	const_iv (ST_DEAD) const_iv (ST_SETUP) const_iv (ST_PLAYING) const_iv (ST_CUSTOM)	1642	const_iv (ST_DEAD) const_iv (ST_SETUP) const_iv (ST_PLAYING) const_iv (ST_CUSTOM)
1293		1643
…		…
1303		1653
1304	const_iv (SYMMETRY_RANDOM) const_iv (SYMMETRY_NONE) const_iv (SYMMETRY_X)	1654	const_iv (SYMMETRY_RANDOM) const_iv (SYMMETRY_NONE) const_iv (SYMMETRY_X)
1305	const_iv (SYMMETRY_Y) const_iv (SYMMETRY_XY)	1655	const_iv (SYMMETRY_Y) const_iv (SYMMETRY_XY)
1306		1656
1307	const_iv (GT_ENVIRONMENT) const_iv (GT_INVISIBLE) const_iv (GT_STARTEQUIP)	1657	const_iv (GT_ENVIRONMENT) const_iv (GT_INVISIBLE) const_iv (GT_STARTEQUIP)
1308	const_iv (GT_APPLY) const_iv (GT_ONLY_GOOD) const_iv (GT_UPDATE_INV)	1658	const_iv (GT_APPLY) const_iv (GT_ONLY_GOOD) const_iv (GT_MINIMAL)
1309	const_iv (GT_MINIMAL)	1659
		1660	const_iv (FT_FACE) const_iv (FT_MUSIC) const_iv (FT_SOUND)
		1661	const_iv (FT_RSRC) const_iv (FT_NUM)
1310	};	1662	};
1311		1663
1312	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	1664	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1313	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));	1665	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1314		1666
…		…
1331	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));	1683	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));
1332	av_push (event, newSViv (eiv->klass));	1684	av_push (event, newSViv (eiv->klass));
1333	av_store (av, eiv->iv, newRV_noinc ((SV *)event));	1685	av_store (av, eiv->iv, newRV_noinc ((SV *)event));
1334	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));	1686	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));
1335	}	1687	}
1336	}
1337		1688
		1689	// used by autogenerated BOOT sections from genacc
		1690	av_reflect = get_av ("cf::REFLECT", 1);
		1691	}
		1692
		1693	void _gv_clear (SV *gv)
		1694	CODE:
		1695	assert (SvTYPE (gv) == SVt_PVGV);
		1696	# define f(sv) { SV *sv_ = (SV *)(sv); sv = 0; SvREFCNT_dec (sv_); }
		1697	f (GvGP (gv)->gp_form);
		1698	f (GvGP (gv)->gp_io);
		1699	f (GvGP (gv)->gp_sv);
		1700	f (GvGP (gv)->gp_av);
		1701	f (GvGP (gv)->gp_hv);
		1702	f (GvGP (gv)->gp_cv);
		1703	GvCVGEN (gv) = 0;
		1704	GvMULTI_off (gv);
		1705	# undef f
		1706
1338	void _connect_to_perl ()	1707	void _connect_to_perl_1 ()
1339		1708
		1709	void _connect_to_perl_2 ()
		1710
		1711	void _recalc_want ()
		1712
		1713	# not used by default anymore
1340	void _global_reattach ()	1714	void _global_reattach ()
1341	CODE:	1715	CODE:
1342	{	1716	{
1343	// reattach to all attachable objects in the game.	1717	// reattach to all attachable objects in the game.
1344	for_all_clients (ns)	1718	for_all_clients (ns)
1345	ns->reattach ();	1719	ns->reattach ();
1346		1720
1347	for_all_objects (op)	1721	for_all_objects (op)
1348	op->reattach ();	1722	op->reattach ();
1349	}	1723	}
1350
1351	void _post_tick ()
1352	CODE:
1353	coroapi::next_cede = SvNV (sv_next_tick) - TICK * (1. - 1. / CEDES_PER_TICK);
1354		1724
1355	# support function for map-world.ext	1725	# support function for map-world.ext
1356	void _quantise (SV *data_sv, SV *plt_sv)	1726	void _quantise (SV *data_sv, SV *plt_sv)
1357	CODE:	1727	CODE:
1358	{	1728	{
…		…
1392	}	1762	}
1393		1763
1394	SvCUR_set (data_sv, dst - SvPVX (data_sv));	1764	SvCUR_set (data_sv, dst - SvPVX (data_sv));
1395	}	1765	}
1396		1766
		1767	void init_anim ()
		1768
		1769	void init_globals ()
		1770
		1771	void init_experience ()
		1772
		1773	void init_attackmess ()
		1774
		1775	void init_dynamic ()
		1776
		1777	void load_settings ()
		1778
		1779	void load_materials ()
		1780
		1781	void init_uuid ()
		1782	CODE:
		1783	UUID::init ();
		1784
		1785	void init_signals ()
		1786
		1787	void init_commands ()
		1788
		1789	void init_skills ()
		1790
		1791	void init_beforeplay ()
		1792
		1793	void evthread_start (int aiofd)
		1794
		1795	void cede_to_tick ()
		1796	CODE:
		1797	coroapi::cede_to_tick ();
		1798
		1799	NV till_tick ()
		1800	CODE:
		1801	RETVAL = SvNVX (sv_next_tick) - now ();
		1802	OUTPUT:
		1803	RETVAL
		1804
		1805	int tick_inhibit ()
		1806	CODE:
		1807	RETVAL = tick_inhibit;
		1808	OUTPUT:
		1809	RETVAL
		1810
		1811	void tick_inhibit_inc ()
		1812	CODE:
		1813	++tick_inhibit;
		1814
		1815	void tick_inhibit_dec ()
		1816	CODE:
		1817	if (!--tick_inhibit)
		1818	if (tick_pending)
		1819	{
		1820	ev_async_send (EV_DEFAULT, &tick_watcher);
		1821	coroapi::cede ();
		1822	}
		1823
		1824	void server_tick ()
		1825	CODE:
		1826	{
		1827	NOW = ev_now (EV_DEFAULT);
		1828	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1829	SvNV_set (sv_tick_start, NOW); SvNOK_only (sv_tick_start);
		1830	runtime = SvNVX (sv_runtime);
		1831
		1832	server_tick ();
		1833
		1834	NOW = ev_time ();
		1835	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1836	runtime += TICK;
		1837	SvNV_set (sv_runtime, runtime); SvNOK_only (sv_runtime);
		1838	}
		1839
1397	NV floor (NV x)	1840	NV floor (NV x)
1398		1841
1399	NV ceil (NV x)	1842	NV ceil (NV x)
1400		1843
1401	NV rndm (...)	1844	NV rndm (...)
		1845	ALIAS:
		1846	rmg_rndm = 1
1402	CODE:	1847	CODE:
		1848	{
		1849	rand_gen &gen = ix ? rmg_rndm : rndm;
1403	switch (items)	1850	switch (items)
1404	{	1851	{
1405	case 0: RETVAL = rndm (); break;	1852	case 0: RETVAL = gen (); break;
1406	case 1: RETVAL = rndm (SvUV (ST (0))); break;	1853	case 1: RETVAL = gen (SvUV (ST (0))); break;
1407	case 2: RETVAL = rndm (SvIV (ST (0)), SvIV (ST (1))); break;	1854	case 2: RETVAL = gen (SvIV (ST (0)), SvIV (ST (1))); break;
1408	default: croak ("cf::rndm requires none, one or two parameters."); break;	1855	default: croak ("cf::rndm requires none, one or two parameters."); break;
1409	}	1856	}
		1857	}
1410	OUTPUT:	1858	OUTPUT:
1411	RETVAL	1859	RETVAL
1412		1860
1413	NV clamp (NV value, NV min_value, NV max_value)	1861	NV clamp (NV value, NV min_value, NV max_value)
1414	CODE:	1862	CODE:
…		…
1420	CODE:	1868	CODE:
1421	RETVAL = lerp (value, min_in, max_in, min_out, max_out);	1869	RETVAL = lerp (value, min_in, max_in, min_out, max_out);
1422	OUTPUT:	1870	OUTPUT:
1423	RETVAL	1871	RETVAL
1424		1872
1425	void cede_to_tick ()	1873	void weaken (...)
1426	CODE:	1874	PROTOTYPE: @
1427	coroapi::cede_to_tick ();	1875	CODE:
1428		1876	while (items > 0)
1429	void server_tick ()	1877	sv_rvweaken (ST (--items));
1430	CODE:
1431	runtime = SvNVx (sv_runtime);
1432	server_tick ();
1433		1878
1434	void	1879	void
1435	log_backtrace (utf8_string msg)	1880	log_backtrace (utf8_string msg)
1436		1881
1437	void	1882	void
…		…
1442	octet_string path_combine (octet_string base, octet_string path)	1887	octet_string path_combine (octet_string base, octet_string path)
1443	PROTOTYPE: $$	1888	PROTOTYPE: $$
1444		1889
1445	octet_string path_combine_and_normalize (octet_string base, octet_string path)	1890	octet_string path_combine_and_normalize (octet_string base, octet_string path)
1446	PROTOTYPE: $$	1891	PROTOTYPE: $$
1447
1448	const_octet_string
1449	get_maps_directory (octet_string path)
1450	PROTOTYPE: $
1451	ALIAS: maps_directory = 0
1452	CODE:
1453	RETVAL = create_pathname (path);
1454	OUTPUT: RETVAL
1455		1892
1456	void	1893	void
1457	sub_generation_inc ()	1894	sub_generation_inc ()
1458	CODE:	1895	CODE:
1459	PL_sub_generation++;	1896	PL_sub_generation++;
…		…
1484		1921
1485	void abort ()	1922	void abort ()
1486		1923
1487	void reset_signals ()	1924	void reset_signals ()
1488		1925
1489	void fork_abort (octet_string cause = "cf::fork_abort")	1926	void fork_abort (const_octet_string cause = "cf::fork_abort")
1490		1927
1491	void cleanup (octet_string cause, bool make_core = false)	1928	void cleanup (const_octet_string cause, bool make_core = false)
1492		1929
1493	void emergency_save ()	1930	void emergency_save ()
1494		1931
1495	void _exit (int status = EXIT_SUCCESS)	1932	void _exit (int status = EXIT_SUCCESS)
1496		1933
1497	UV sv_2watcher (SV *w)
1498	CODE:
1499	RETVAL = (UV)GEventAPI->sv_2watcher (w);
1500	OUTPUT:
1501	RETVAL
1502
1503	#if _POSIX_MEMLOCK	1934	#if _POSIX_MEMLOCK
1504		1935
1505	int mlockall (int flags = MCL_CURRENT | MCL_FUTURE)	1936	int mlockall (int flags = MCL_CURRENT | MCL_FUTURE)
		1937	INIT:
		1938	#if __GLIBC__
		1939	mallopt (M_TOP_PAD, 1024 * 1024);
		1940	mallopt (M_MMAP_THRESHOLD, 1024 * 1024 * 128);
		1941	mallopt (M_MMAP_MAX, 0); // likely bug-workaround, also frees memory
		1942	mallopt (M_PERTURB, 0xee); // bug-workaround for linux glibc+mlockall+calloc
		1943	#endif
1506		1944
1507	int munlockall ()	1945	int munlockall ()
1508		1946
1509	#endif	1947	#endif
		1948
		1949	int
		1950	malloc_trim (IV pad = 0)
		1951
		1952	void
		1953	mallinfo ()
		1954	PPCODE:
		1955	{
		1956	#if __GLIBC__
		1957	struct mallinfo mai = mallinfo ();
		1958	EXTEND (SP, 10*2);
		1959	PUSHs (sv_2mortal (newSVpv ("arena" , 0))); PUSHs (sv_2mortal (newSViv (mai.arena)));
		1960	PUSHs (sv_2mortal (newSVpv ("ordblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.ordblks)));
		1961	PUSHs (sv_2mortal (newSVpv ("smblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.smblks)));
		1962	PUSHs (sv_2mortal (newSVpv ("hblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblks)));
		1963	PUSHs (sv_2mortal (newSVpv ("hblkhd" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblkhd)));
		1964	PUSHs (sv_2mortal (newSVpv ("usmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.usmblks)));
		1965	PUSHs (sv_2mortal (newSVpv ("fsmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.fsmblks)));
		1966	PUSHs (sv_2mortal (newSVpv ("uordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.uordblks)));
		1967	PUSHs (sv_2mortal (newSVpv ("fordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.fordblks)));
		1968	PUSHs (sv_2mortal (newSVpv ("keepcost", 0))); PUSHs (sv_2mortal (newSViv (mai.keepcost)));
		1969	#endif
		1970	EXTEND (SP, 5*2);
		1971	PUSHs (sv_2mortal (newSVpv ("slice_alloc", 0))); PUSHs (sv_2mortal (newSVuv (slice_alloc)));
		1972	PUSHs (sv_2mortal (newSVpv ("shstr_alloc", 0))); PUSHs (sv_2mortal (newSVuv (shstr_alloc)));
		1973	PUSHs (sv_2mortal (newSVpv ("objects" , 0))); PUSHs (sv_2mortal (newSVuv (objects.size () * sizeof (object))));
		1974	PUSHs (sv_2mortal (newSVpv ("sv_count" , 0))); PUSHs (sv_2mortal (newSVuv (PL_sv_count)));
		1975	PUSHs (sv_2mortal (newSVpv ("sv_objcount", 0))); PUSHs (sv_2mortal (newSVuv (PL_sv_objcount)));
		1976	}
1510		1977
1511	int find_animation (utf8_string text)	1978	int find_animation (utf8_string text)
1512	PROTOTYPE: $	1979	PROTOTYPE: $
1513		1980
1514	int random_roll (int min, int max, object *op, int goodbad);	1981	int random_roll (int min, int max, object *op, int goodbad);
…		…
1552	RETVAL = newSVpv (resist_plus[atnr], 0);	2019	RETVAL = newSVpv (resist_plus[atnr], 0);
1553	else	2020	else
1554	XSRETURN_UNDEF;	2021	XSRETURN_UNDEF;
1555	OUTPUT: RETVAL	2022	OUTPUT: RETVAL
1556		2023
		2024	UUID
		2025	uuid_cur ()
		2026	CODE:
		2027	RETVAL = UUID::cur;
		2028	OUTPUT:
		2029	RETVAL
		2030
		2031	UUID
		2032	uuid_gen ()
		2033	CODE:
		2034	RETVAL = UUID::gen ();
		2035	OUTPUT:
		2036	RETVAL
		2037
		2038	val64
		2039	uuid_seq (UUID uuid)
		2040	CODE:
		2041	RETVAL = uuid.seq;
		2042	OUTPUT:
		2043	RETVAL
		2044
		2045	UUID
		2046	uuid_str (val64 seq)
		2047	CODE:
		2048	RETVAL.seq = seq;
		2049	OUTPUT:
		2050	RETVAL
		2051
		2052	void
		2053	coin_names ()
		2054	PPCODE:
		2055	EXTEND (SP, NUM_COINS);
		2056	for (int i = 0; i < NUM_COINS; ++i)
		2057	PUSHs (sv_2mortal (newSVpv (coins [i], 0)));
		2058
		2059	void
		2060	coin_archetypes ()
		2061	PPCODE:
		2062	EXTEND (SP, NUM_COINS);
		2063	for (int i = 0; i < NUM_COINS; ++i)
		2064	PUSHs (sv_2mortal (to_sv (archetype::find (coins [i]))));
		2065
1557	bool	2066	bool
1558	load_resource_file (octet_string filename)	2067	load_resource_file_ (octet_string filename)
		2068
		2069	void
		2070	fix_weight ()
1559		2071
1560	MODULE = cf PACKAGE = cf::attachable	2072	MODULE = cf PACKAGE = cf::attachable
1561		2073
1562	int	2074	int
1563	valid (SV *obj)	2075	valid (SV *obj)
…		…
1567	RETVAL	2079	RETVAL
1568		2080
1569	void	2081	void
1570	debug_trace (attachable *obj, bool on = true)	2082	debug_trace (attachable *obj, bool on = true)
1571	CODE:	2083	CODE:
1572	obj->flags &= ~attachable::F_DEBUG_TRACE;	2084	obj->attachable_flags &= ~attachable::F_DEBUG_TRACE;
1573	if (on)	2085	if (on)
1574	obj->flags |= attachable::F_DEBUG_TRACE;	2086	obj->attachable_flags |= attachable::F_DEBUG_TRACE;
1575		2087
1576	int mortals_size ()	2088	int mortals_size ()
1577	CODE:	2089	CODE:
1578	RETVAL = attachable::mortals.size ();	2090	RETVAL = attachable::mortals.size ();
1579	OUTPUT: RETVAL	2091	OUTPUT: RETVAL
…		…
1581	#object *mortals (U32 index)	2093	#object *mortals (U32 index)
1582	# CODE:	2094	# CODE:
1583	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;	2095	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;
1584	# OUTPUT: RETVAL	2096	# OUTPUT: RETVAL
1585		2097
1586	INCLUDE: $PERL $srcdir/genacc attachable ../include/cfperl.h |	2098	INCLUDE: $PERL $srcdir/genacc attachable ../include/util.h ../include/cfperl.h |
1587		2099
1588	MODULE = cf PACKAGE = cf::global	2100	MODULE = cf PACKAGE = cf::global
1589		2101
1590	int invoke (SV *klass, int event, ...)	2102	int invoke (SV *klass, int event, ...)
1591	CODE:	2103	CODE:
…		…
1627	object *actives (U32 index)	2139	object *actives (U32 index)
1628	CODE:	2140	CODE:
1629	RETVAL = index < actives.size () ? actives [index] : 0;	2141	RETVAL = index < actives.size () ? actives [index] : 0;
1630	OUTPUT: RETVAL	2142	OUTPUT: RETVAL
1631		2143
1632	const char *slot_save_name (U32 slot)	2144	int mortals_size ()
		2145	CODE:
		2146	RETVAL = attachable::mortals.size ();
		2147	OUTPUT: RETVAL
		2148
		2149	const_utf8_string slot_use_name (U32 slot)
1633	ALIAS:	2150	ALIAS:
1634	slot_use_name = 1
1635	slot_nonuse_name = 2	2151	slot_nonuse_name = 1
1636	CODE:	2152	CODE:
1637	{	2153	{
1638	if (slot >= NUM_BODY_LOCATIONS)	2154	if (slot >= NUM_BODY_LOCATIONS)
1639	croak ("body slot index out of range");	2155	croak ("body slot index out of range");
1640		2156
1641	switch (ix)	2157	switch (ix)
1642	{	2158	{
1643	case 0: RETVAL = body_locations[slot].save_name; break;
1644	case 1: RETVAL = body_locations[slot].use_name; break;	2159	case 0: RETVAL = body_locations[slot].use_name; break;
1645	case 2: RETVAL = body_locations[slot].nonuse_name; break;	2160	case 1: RETVAL = body_locations[slot].nonuse_name; break;
1646	}	2161	}
1647	}	2162	}
1648	OUTPUT:	2163	OUTPUT:
1649	RETVAL	2164	RETVAL
1650		2165
…		…
1652		2167
1653	object *head (object *op)	2168	object *head (object *op)
1654	PROTOTYPE: $	2169	PROTOTYPE: $
1655	CODE:	2170	CODE:
1656	RETVAL = op->head_ ();	2171	RETVAL = op->head_ ();
1657	OUTPUT: RETVAL
1658
1659	int is_head (object *op)
1660	PROTOTYPE: $
1661	CODE:
1662	RETVAL = op->head_ () == op;
1663	OUTPUT: RETVAL	2172	OUTPUT: RETVAL
1664		2173
1665	void	2174	void
1666	inv (object *obj)	2175	inv (object *obj)
1667	PROTOTYPE: $	2176	PROTOTYPE: $
1668	PPCODE:	2177	PPCODE:
1669	{	2178	{
1670	object *o;
1671	for (o = obj->inv; o; o = o->below)	2179	for (object *o = obj->inv; o; o = o->below)
1672	XPUSHs (sv_2mortal (to_sv (o)));	2180	XPUSHs (sv_2mortal (to_sv (o)));
1673	}	2181	}
1674		2182
1675	void	2183	void
1676	set_animation (object *op, int idx)	2184	set_animation (object *op, int idx)
…		…
1708		2216
1709	int need_identify (object *obj);	2217	int need_identify (object *obj);
1710		2218
1711	int apply_shop_mat (object *shop_mat, object *op);	2219	int apply_shop_mat (object *shop_mat, object *op);
1712		2220
1713	int move_player (object *op, int dir)
1714	CODE:
1715	RETVAL = move_player (op, dir);
1716	OUTPUT:
1717	RETVAL
1718
1719	int move (object *op, int dir, object *originator = op)	2221	int move (object *op, int dir, object *originator = op)
1720	CODE:	2222	CODE:
1721	RETVAL = move_ob (op, dir, originator);	2223	RETVAL = move_ob (op, dir, originator);
1722	OUTPUT:	2224	OUTPUT:
1723	RETVAL	2225	RETVAL
…		…
1730	CODE:	2232	CODE:
1731	player_apply_below (op);	2233	player_apply_below (op);
1732		2234
1733	int cast_heal (object *op, object *caster, object *spell, int dir = 0)	2235	int cast_heal (object *op, object *caster, object *spell, int dir = 0)
1734		2236
1735	object *cf_object_present_archname_inside (object *op, utf8_string whatstr)	2237	int casting_level (object *caster, object *spell)
1736
1737	int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)
1738
1739	int cf_object_change_map (object *op, int x, int y, maptile *map)
1740
1741	#//TODO
1742	object *clone_ (object *op, int recursive = 0)
1743	CODE:
1744	if (recursive)
1745	RETVAL = object_create_clone (op);
1746	else
1747	{
1748	RETVAL = object::create ();
1749	op->copy_to (RETVAL);
1750	}
1751	OUTPUT: RETVAL
1752		2238
1753	int pay_item (object *op, object *buyer)	2239	int pay_item (object *op, object *buyer)
1754	CODE:	2240	CODE:
1755	RETVAL = pay_for_item (op, buyer);	2241	RETVAL = pay_for_item (op, buyer);
1756	OUTPUT: RETVAL	2242	OUTPUT: RETVAL
…		…
1791		2277
1792	void drop (object *who, object *op)	2278	void drop (object *who, object *op)
1793		2279
1794	void pick_up (object *who, object *op)	2280	void pick_up (object *who, object *op)
1795		2281
1796	int cf_object_teleport (object *op, maptile *map, int x, int y)
1797
1798	void update_object (object *op, int action)	2282	void update_object (object *op, int action)
1799		2283
1800	object *cf_create_object_by_name (utf8_string name)
1801
1802	void change_exp (object *op, uint64 exp, utf8_string skill_name = 0, int flag = 0)	2284	void change_exp (object *op, uint64 exp, utf8_string skill_name = 0, int flag = 0)
1803		2285
1804	void player_lvl_adj (object *who, object *skill = 0)	2286	void player_lvl_adj (object *who, object *skill = 0)
1805		2287
1806	int kill_object (object *op, int dam = 0, object *hitter = 0, int type = AT_PHYSICAL)	2288	int kill_object (object *op, int dam = 0, object *hitter = 0, int type = AT_PHYSICAL)
1807		2289
1808	int calc_skill_exp (object *who, object *op, object *skill);	2290	int calc_skill_exp (object *who, object *op, object *skill)
1809		2291
1810	void push_button (object *op);	2292	void push_button (object *op, object *originator)
1811		2293
1812	void use_trigger (object *op);	2294	void use_trigger (object *op, object *originator)
1813		2295
1814	void add_button_link (object *button, maptile *map, int connected);	2296	void handle_apply_yield (object *op)
1815		2297
1816	void remove_button_link (object *op);	2298	int convert_item (object *item, object *converter)
1817		2299
1818		2300
1819	MODULE = cf PACKAGE = cf::object PREFIX = cf_	2301	MODULE = cf PACKAGE = cf::object PREFIX = cf_
1820
1821	object *cf_insert_ob_in_ob (object *ob, object *where)
1822		2302
1823	# no clean way to get an object from an archetype - stupid idiotic	2303	# no clean way to get an object from an archetype - stupid idiotic
1824	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.	2304	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.
1825		2305
1826	object *new (utf8_string archetype = 0)	2306	object *new (utf8_string archetype = 0)
1827	PROTOTYPE: ;$	2307	PROTOTYPE: ;$
1828	CODE:	2308	CODE:
1829	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();	2309	RETVAL = archetype ? get_archetype (archetype) : object::create ();
1830	OUTPUT:	2310	OUTPUT:
1831	RETVAL	2311	RETVAL
1832		2312
		2313	object *find_object (U32 tag)
		2314
		2315	# TODO: nuke
1833	object *insert_ob_in_map_at (object *ob, maptile *where, object_ornull *orig, int flag, int x, int y)	2316	object *insert_ob_in_map_at (object *ob, maptile *where, object_ornull *orig, int flag, int x, int y)
1834	PROTOTYPE: $$$$$$	2317	PROTOTYPE: $$$$$$
1835	CODE:	2318	CODE:
1836	{	2319	{
1837	int unused_type;	2320	RETVAL = insert_ob_in_map_at (ob, where, orig, flag, x, y);
1838	RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);
1839	}
1840		2321
1841	player *contr (object *op)	2322	if (RETVAL->destroyed ())
1842	CODE:
1843	RETVAL = op->contr;	2323	RETVAL = 0;
1844	OUTPUT: RETVAL	2324	}
1845		2325
1846	const_utf8_string get_ob_key_value (object *op, utf8_string key)	2326	shstr
		2327	object::kv_get (shstr key)
1847		2328
1848	bool set_ob_key_value (object *op, utf8_string key, utf8_string value = 0, int add_key = 1)	2329	void
		2330	object::kv_del (shstr key)
		2331
		2332	void
		2333	object::kv_set (shstr key, shstr value)
1849		2334
1850	object *get_nearest_player (object *ob)	2335	object *get_nearest_player (object *ob)
1851	ALIAS: nearest_player = 0	2336	ALIAS: nearest_player = 0
1852	PREINIT:	2337	PREINIT:
1853	extern object *get_nearest_player (object *);	2338	extern object *get_nearest_player (object *);
…		…
1855	void rangevector (object *ob, object *other, int flags = 0)	2340	void rangevector (object *ob, object *other, int flags = 0)
1856	PROTOTYPE: $$;$	2341	PROTOTYPE: $$;$
1857	PPCODE:	2342	PPCODE:
1858	{	2343	{
1859	rv_vector rv;	2344	rv_vector rv;
		2345
		2346	PUTBACK;
1860	get_rangevector (ob, other, &rv, flags);	2347	get_rangevector (ob, other, &rv, flags);
		2348	SPAGAIN;
		2349
1861	EXTEND (SP, 5);	2350	EXTEND (SP, 5);
1862	PUSHs (newSVuv (rv.distance));	2351	PUSHs (newSVuv (rv.distance));
1863	PUSHs (newSViv (rv.distance_x));	2352	PUSHs (newSViv (rv.distance_x));
1864	PUSHs (newSViv (rv.distance_y));	2353	PUSHs (newSViv (rv.distance_y));
1865	PUSHs (newSViv (rv.direction));	2354	PUSHs (newSViv (rv.direction));
1866	PUSHs (newSVcfapi (CFAPI_POBJECT, rv.part));	2355	PUSHs (to_sv (rv.part));
1867	}	2356	}
1868		2357
1869	bool on_same_map_as (object *ob, object *other)	2358	bool on_same_map_as (object *ob, object *other)
1870	CODE:	2359	CODE:
1871	RETVAL = on_same_map (ob, other);	2360	RETVAL = on_same_map (ob, other);
…		…
1875	base_name (object *op, int plural = op->nrof > 1)	2364	base_name (object *op, int plural = op->nrof > 1)
1876	CODE:	2365	CODE:
1877	RETVAL = query_base_name (op, plural);	2366	RETVAL = query_base_name (op, plural);
1878	OUTPUT: RETVAL	2367	OUTPUT: RETVAL
1879		2368
1880	object *decrease_ob_nr (object *op, unsigned long i)	2369	# return the tail of an object, excluding itself
		2370	void
		2371	tail (object *op)
		2372	PPCODE:
		2373	while ((op = op->more))
		2374	XPUSHs (sv_2mortal (to_sv (op)));
1881		2375
1882	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_	2376	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_
1883		2377
1884	player *player (object *op)	2378	player *player (object *op)
1885	CODE:	2379	CODE:
1886	RETVAL = op->contr;	2380	RETVAL = op->contr;
1887	OUTPUT: RETVAL	2381	OUTPUT: RETVAL
1888		2382
		2383	bool move_player (object *op, int dir)
		2384
1889	void check_score (object *op)	2385	void check_score (object *op)
1890		2386
1891	void message (object *op, utf8_string txt, int flags = NDI_ORANGE | NDI_UNIQUE)	2387	void message (object *op, utf8_string txt, int flags = NDI_ORANGE | NDI_UNIQUE)
1892	CODE:	2388	CODE:
1893	new_draw_info (flags, 0, op, txt);	2389	new_draw_info (flags, 0, op, txt);
1894		2390
1895	object *cf_player_send_inventory (object *op)
1896
1897	octet_string cf_player_get_ip (object *op)
1898	ALIAS: ip = 0
1899
1900	object *cf_player_get_marked_item (object *op)
1901	ALIAS: marked_item = 0
1902
1903	void cf_player_set_marked_item (object *op, object *ob)
1904
1905	partylist *cf_player_get_party (object *op)
1906	ALIAS: party = 0
1907
1908	void cf_player_set_party (object *op, partylist *party)
1909
1910	void kill_player (object *op)	2391	void kill_player (object *op)
1911		2392
		2393	void esrv_send_item (object *pl, object *item)
		2394
1912	void esrv_update_item (object *op, int what, object *item)	2395	void esrv_update_item (object *pl, int what, object *item)
1913	C_ARGS: what, op, item	2396	C_ARGS: what, pl, item
1914		2397
1915	void clear_los (object *op)	2398	void esrv_del_item (object *pl, int tag)
		2399	C_ARGS: pl->contr, tag
1916		2400
1917	int command_summon (object *op, utf8_string params)	2401	int command_summon (object *op, utf8_string params)
1918		2402
1919	int command_arrest (object *op, utf8_string params)	2403	int command_arrest (object *op, utf8_string params)
1920		2404
…		…
1939	pl->ob->stats.hp = pl->ob->stats.maxhp;	2423	pl->ob->stats.hp = pl->ob->stats.maxhp;
1940	pl->ob->stats.sp = pl->ob->stats.maxsp;	2424	pl->ob->stats.sp = pl->ob->stats.maxsp;
1941	pl->ob->stats.grace = pl->ob->stats.maxgrace;	2425	pl->ob->stats.grace = pl->ob->stats.maxgrace;
1942	pl->orig_stats = pl->ob->stats;	2426	pl->orig_stats = pl->ob->stats;
1943		2427
1944	void cf_player_move (player *pl, int dir)	2428	# should only be temporary
		2429	void esrv_new_player (player *pl)
1945		2430
1946	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);	2431	#d# TODO: replace by blocked_los accessor, fix code using this
1947
1948	bool	2432	bool
1949	cell_visible (player *pl, int dx, int dy)	2433	cell_visible (player *pl, int dx, int dy)
1950	CODE:	2434	CODE:
1951	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2	2435	RETVAL = pl->blocked_los (dx, dy) != LOS_BLOCKED;
1952	&& !pl->blocked_los [dx + pl->ns->mapx / 2][dy + pl->ns->mapy / 2];
1953	OUTPUT:	2436	OUTPUT:
1954	RETVAL	2437	RETVAL
1955		2438
1956	void	2439	void
1957	send (player *pl, SV *packet)	2440	send (player *pl, SV *packet)
1958	CODE:	2441	CODE:
1959	{	2442	{
1960	STRLEN len;	2443	STRLEN len;
1961	char *buf = SvPVbyte (packet, len);	2444	char *buf = SvPVbyte (packet, len);
1962		2445
		2446	if (len > MAXSOCKBUF)
		2447	pl->failmsg ("[packet too long for client]");
1963	if (pl->ns)	2448	else if (pl->ns)
1964	pl->ns->send_packet (buf, len);	2449	pl->ns->send_packet (buf, len);
1965	}	2450	}
1966
1967	int
1968	listening (player *pl, int new_value = -1)
1969	CODE:
1970	RETVAL = pl->listening;
1971	if (new_value >= 0)
1972	pl->listening = new_value;
1973	OUTPUT:
1974	RETVAL
1975		2451
1976	void savebed (player *pl, SV *map_path = 0, SV *x = 0, SV *y = 0)	2452	void savebed (player *pl, SV *map_path = 0, SV *x = 0, SV *y = 0)
1977	PROTOTYPE: $;$$$	2453	PROTOTYPE: $;$$$
1978	PPCODE:	2454	PPCODE:
1979	if (GIMME_V != G_VOID)	2455	if (GIMME_V != G_VOID)
…		…
2004	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);	2480	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);
2005	OUTPUT: RETVAL	2481	OUTPUT: RETVAL
2006		2482
2007	SV *registry (maptile *map)	2483	SV *registry (maptile *map)
2008		2484
		2485	void
		2486	find_tagged_objects (maptile *map, utf8_string tag = 0)
		2487	PPCODE:
		2488	{
		2489	if (!map->spaces)
		2490	XSRETURN_EMPTY;
		2491
		2492	if (tag)
		2493	{
		2494	shstr_cmp tag_ (tag);
		2495
		2496	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2497	for (object *op = ms->bot; op; op = op->above)
		2498	if (op->tag == tag_)
		2499	XPUSHs (sv_2mortal (to_sv (op)));
		2500	}
		2501	else
		2502	{
		2503	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2504	for (object *op = ms->bot; op; op = op->above)
		2505	if (op->tag)
		2506	XPUSHs (sv_2mortal (to_sv (op)));
		2507	}
		2508	}
		2509
2009	INCLUDE: $PERL $srcdir/genacc maptile ../include/map.h |	2510	INCLUDE: $PERL $srcdir/genacc maptile ../include/map.h |
		2511
		2512	void
		2513	adjust_daylight ()
		2514	CODE:
		2515	maptile::adjust_daylight ();
		2516
		2517	int
		2518	outdoor_darkness (int darkness = 0)
		2519	CODE:
		2520	RETVAL = maptile::outdoor_darkness;
		2521	if (items)
		2522	maptile::outdoor_darkness = darkness;
		2523	OUTPUT:
		2524	RETVAL
2010		2525
2011	void	2526	void
2012	maptile::instantiate ()	2527	maptile::instantiate ()
2013		2528
2014	maptile *new ()	2529	maptile *new ()
…		…
2046	for (int x = 0; x < THIS->width; ++x)	2561	for (int x = 0; x < THIS->width; ++x)
2047	for (int y = 0; y < THIS->height; ++y)	2562	for (int y = 0; y < THIS->height; ++y)
2048	{	2563	{
2049	for (object *op = THIS->at (x, y).bot; op; op = op->above)	2564	for (object *op = THIS->at (x, y).bot; op; op = op->above)
2050	if (op->flag [FLAG_IS_FLOOR])	2565	if (op->flag [FLAG_IS_FLOOR])
2051	goto skip_space;	2566	goto skip;
2052		2567
2053	{	2568	{
2054	int offs = offset + y * stride + x;	2569	int offs = offset + y * stride + x;
		2570
2055	if (IN_RANGE_EXC (offs, 0, idxlen))	2571	if (IN_RANGE_EXC (offs, 0, idxlen))
2056	{	2572	{
2057	if (SV **elem = av_fetch ((AV *)palette, idx [offs], 0))	2573	if (SV **elem = av_fetch ((AV *)palette, idx [offs], 0))
2058	{	2574	{
2059	object *ob = get_archetype (SvPVutf8_nolen (*elem));	2575	object *ob = get_archetype (cfSvPVutf8_nolen (*elem));
2060	ob->flag [FLAG_NO_MAP_SAVE] = true;	2576	ob->flag [FLAG_NO_MAP_SAVE] = true;
2061	THIS->insert (ob, x, y, 0, INS_ABOVE_FLOOR_ONLY);	2577	THIS->insert (ob, x, y, 0, INS_ABOVE_FLOOR_ONLY);
2062		2578
2063	if (ob->randomitems)	2579	if (ob->randomitems && !ob->above)
2064	{	2580	{
2065	if (!ob->above)
2066	{
2067	ob->create_treasure (ob->randomitems);	2581	ob->create_treasure (ob->randomitems);
2068		2582
2069	for (object *op = ob->above; op; op = op->above)	2583	for (object *op = ob->above; op; op = op->above)
2070	op->flag [FLAG_NO_MAP_SAVE] = true;	2584	op->flag [FLAG_NO_MAP_SAVE] = true;
2071	}	2585	// TODO: if this is a pickable object, then the item
2072		2586	// will at a bit weird - saving inside the player
2073	ob->randomitems = 0;	2587	// will clear the flag, but when the player drops
		2588	// it without logging out, it keeps the flag.
		2589	// nobody ahs reported this, but this can be rather
		2590	// annoying on persistent maps.
2074	}	2591	}
2075	}	2592	}
2076	}	2593	}
2077	}	2594	}
2078		2595
2079	skip_space: ;	2596	skip: ;
2080	}	2597	}
2081	}	2598	}
2082		2599
2083	void	2600	void
2084	maptile::set_regiondata (SV *data, int offset, int stride, SV *palette)	2601	maptile::set_regiondata (SV *data, int offset, int stride, SV *palette)
…		…
2090	palette = SvRV (palette);	2607	palette = SvRV (palette);
2091		2608
2092	STRLEN idxlen;	2609	STRLEN idxlen;
2093	const uint8_t *idx = (const uint8_t *)SvPVbyte (data, idxlen);	2610	const uint8_t *idx = (const uint8_t *)SvPVbyte (data, idxlen);
2094		2611
2095	region **regionmap = (region **)malloc (	2612	region_ptr *regionmap = new region_ptr [av_len ((AV *)palette) + 1];
2096	(av_len ((AV *)palette) + 1) * sizeof (region *));
2097	uint8_t *regions = salloc<uint8_t> (THIS->size ());	2613	uint8_t *regions = salloc<uint8_t> (THIS->size ());
2098		2614
2099	for (int i = av_len ((AV *)palette) + 1; i--; )	2615	for (int i = av_len ((AV *)palette) + 1; i--; )
2100	regionmap [i] = region::find (	2616	regionmap [i] = region::find (cfSvPVutf8_nolen (*av_fetch ((AV *)palette, i, 1)));
2101	SvPVutf8_nolen (*av_fetch ((AV *)palette, i, 1)));
2102		2617
2103	for (int y = 0; y < THIS->height; ++y)	2618	for (int y = 0; y < THIS->height; ++y)
2104	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);	2619	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);
2105		2620
2106	sfree (THIS->regions, THIS->size ());	2621	sfree (THIS->regions, THIS->size ());
2107	free (THIS->regionmap);	2622	delete [] THIS->regionmap;
2108		2623
2109	THIS->regions = regions;	2624	THIS->regions = regions;
2110	THIS->regionmap = regionmap;	2625	THIS->regionmap = regionmap;
2111	}	2626	}
2112		2627
2113	void	2628	void
2114	maptile::create_region_treasure ()	2629	maptile::create_region_treasure ()
2115	CODE:	2630	CODE:
2116	{
2117	object *op = object::create ();
2118	op->type = FLOOR;
2119	op->map = THIS;
2120
2121	for (int x = 0; x < THIS->width; ++x)	2631	for (int x = 0; x < THIS->width; ++x)
2122	for (int y = 0; y < THIS->height; ++y)	2632	for (int y = 0; y < THIS->height; ++y)
2123	{	2633	{
2124	region *rgn = THIS->region (x, y);	2634	region *rgn = THIS->region (x, y);
2125		2635
2126	//fprintf (stderr, "%d,%d %f %p\n", x, y, rgn->treasure_density,rgn->treasure);//D	2636	//fprintf (stderr, "%d,%d %f %p\n", x, y, rgn->treasure_density,rgn->treasure);//D
		2637	if (object *op = THIS->at (x, y).top)
2127	if (rgn->treasure && rndm () < rgn->treasure_density)	2638	if (rgn->treasure && rndm () < rgn->treasure_density)
2128	{
2129	op->x = x;
2130	op->y = y;
2131	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);	2639	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);
2132	}
2133	}	2640	}
2134		2641
2135	op->destroy ();
2136	}
2137
2138	void play_sound_map (maptile *map, int x, int y, int sound_num)
2139
2140	int out_of_map (maptile *map, int x, int y)	2642	int out_of_map (maptile *map, int x, int y)
2141		2643
2142	void	2644	void
2143	trigger (maptile *map, long connection, bool state = true)	2645	find_link (maptile *map, shstr_tmp connection)
2144	CODE:
2145	activate_connection (map, connection, state);
2146
2147	void
2148	get_connection (maptile *map, long connection)
2149	PPCODE:	2646	PPCODE:
2150	oblinkpt *obp = get_connection_links (map, connection);	2647	if (oblinkpt *obp = map->find_link (connection))
2151	if (obp)
2152	for (objectlink *ol = obp->link; ol; ol = ol->next)	2648	for (objectlink *ol = obp->link; ol; ol = ol->next)
2153	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, (object *)ol->ob)));	2649	XPUSHs (sv_2mortal (to_sv ((object *)ol->ob)));
2154
2155	object *cf_map_insert_object_there (maptile *where, object *op, object *originator, int flags)
2156
2157	object *cf_map_insert_object (maptile *where, object* op, int x, int y)
2158
2159	object* cf_map_present_arch_by_name (maptile *map, const char* str, int nx, int ny)
2160	C_ARGS: str, map, nx, ny
2161		2650
2162	void	2651	void
2163	get_map_flags (maptile *map, int x, int y)	2652	get_map_flags (maptile *map, int x, int y)
2164	PPCODE:	2653	PPCODE:
2165	{	2654	{
2166	maptile *nmap = 0;	2655	maptile *nmap = 0;
2167	I16 nx = 0, ny = 0;	2656	I16 nx = 0, ny = 0;
		2657
		2658	PUTBACK;
2168	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);	2659	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
		2660	SPAGAIN;
2169		2661
2170	EXTEND (SP, 4);	2662	EXTEND (SP, 4);
2171	PUSHs (sv_2mortal (newSViv (flags)));	2663	PUSHs (sv_2mortal (newSViv (flags)));
2172		2664
2173	if (GIMME_V == G_ARRAY)	2665	if (GIMME_V == G_ARRAY)
2174	{	2666	{
2175	PUSHs (sv_2mortal (newSVcfapi (CFAPI_PMAP, nmap)));	2667	PUSHs (sv_2mortal (to_sv (nmap)));
2176	PUSHs (sv_2mortal (newSViv (nx)));	2668	PUSHs (sv_2mortal (newSViv (nx)));
2177	PUSHs (sv_2mortal (newSViv (ny)));	2669	PUSHs (sv_2mortal (newSViv (ny)));
2178	}	2670	}
2179	}	2671	}
2180		2672
		2673	mapspace *
		2674	ms (maptile *map, unsigned int x, unsigned int y)
		2675	PROTOTYPE: $$$
		2676	CODE:
		2677	{
		2678	maptile *nmap = 0;
		2679	I16 nx, ny;
		2680
		2681	PUTBACK;
		2682	get_map_flags (map, &nmap, x, y, &nx, &ny);
		2683	SPAGAIN;
		2684
		2685	if (!nmap)
		2686	XSRETURN_UNDEF;
		2687
		2688	RETVAL = &nmap->at (nx, ny);
		2689	}
		2690	OUTPUT:
		2691	RETVAL
		2692
2181	void	2693	void
2182	at (maptile *map, unsigned int x, unsigned int y)	2694	at (maptile *map, unsigned int x, unsigned int y)
2183	PROTOTYPE: $$$	2695	PROTOTYPE: $$$
2184	PPCODE:	2696	PPCODE:
2185	{	2697	{
2186	object *o;
2187	maptile *nmap = 0;	2698	maptile *nmap = 0;
2188	I16 nx, ny;	2699	I16 nx, ny;
2189		2700
		2701	PUTBACK;
2190	get_map_flags (map, &nmap, x, y, &nx, &ny);	2702	get_map_flags (map, &nmap, x, y, &nx, &ny);
		2703	SPAGAIN;
2191		2704
2192	if (nmap)	2705	if (nmap)
2193	for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)	2706	for (object *o = nmap->at (nx, ny).bot; o; o = o->above)
2194	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));	2707	XPUSHs (sv_2mortal (to_sv (o)));
2195	}	2708	}
2196		2709
2197	SV *	2710	SV *
2198	bot_at (maptile *obj, unsigned int x, unsigned int y)	2711	bot_at (maptile *map, unsigned int x, unsigned int y)
2199	PROTOTYPE: $$$	2712	PROTOTYPE: $$$
2200	ALIAS:	2713	ALIAS:
2201	top_at = 1	2714	top_at = 1
2202	flags_at = 2	2715	flags_at = 2
2203	light_at = 3	2716	light_at = 3
2204	move_block_at = 4	2717	move_block_at = 4
2205	move_slow_at = 5	2718	move_slow_at = 5
2206	move_on_at = 6	2719	move_on_at = 6
2207	move_off_at = 7	2720	move_off_at = 7
2208	INIT:
2209	if (x >= obj->width || y >= obj->height) XSRETURN_UNDEF;
2210	CODE:	2721	CODE:
		2722	{
		2723	sint16 nx = x;
		2724	sint16 ny = y;
		2725
		2726	if (!xy_normalise (map, nx, ny))
		2727	XSRETURN_UNDEF;
		2728
		2729	mapspace &ms = map->at (nx, ny);
		2730
		2731	ms.update ();
		2732
2211	switch (ix)	2733	switch (ix)
2212	{	2734	{
2213	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;	2735	case 0: RETVAL = to_sv (ms.bot ); break;
2214	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;	2736	case 1: RETVAL = to_sv (ms.top ); break;
2215	case 2: RETVAL = newSVuv ( GET_MAP_FLAGS (obj, x, y)); break;	2737	case 2: RETVAL = newSVuv (ms.flags_ ); break;
2216	case 3: RETVAL = newSViv ( GET_MAP_LIGHT (obj, x, y)); break;	2738	case 3: RETVAL = newSViv (ms.light ); break;
2217	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;	2739	case 4: RETVAL = newSVuv (ms.move_block); break;
2218	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;	2740	case 5: RETVAL = newSVuv (ms.move_slow ); break;
2219	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;	2741	case 6: RETVAL = newSVuv (ms.move_on ); break;
2220	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;	2742	case 7: RETVAL = newSVuv (ms.move_off ); break;
2221	}	2743	}
		2744	}
2222	OUTPUT: RETVAL	2745	OUTPUT: RETVAL
2223
2224	void fix_walls (maptile *map, int x, int y)
2225
2226	void fix_walls_around (maptile *map, int x, int y)
2227		2746
2228	# worst xs function of my life	2747	# worst xs function of my life
2229	bool	2748	bool
2230	_create_random_map (\	2749	_create_random_map (\
2231	maptile *self,\	2750	maptile *self,\
…		…
2299	rmp.decoroptions = decoroptions;	2818	rmp.decoroptions = decoroptions;
2300	rmp.orientation = orientation;	2819	rmp.orientation = orientation;
2301	rmp.origin_y = origin_y;	2820	rmp.origin_y = origin_y;
2302	rmp.origin_x = origin_x;	2821	rmp.origin_x = origin_x;
2303	rmp.random_seed = random_seed;	2822	rmp.random_seed = random_seed;
2304	rmp.total_map_hp = total_map_hp;	2823	rmp.total_map_hp = (uint64_t) total_map_hp;
2305	rmp.map_layout_style = map_layout_style;	2824	rmp.map_layout_style = map_layout_style;
2306	rmp.treasureoptions = treasureoptions;	2825	rmp.treasureoptions = treasureoptions;
2307	rmp.symmetry_used = symmetry_used;	2826	rmp.symmetry_used = symmetry_used;
2308	rmp.region = region;	2827	rmp.region = region;
2309	rmp.custom = custom;	2828	rmp.custom = custom;
…		…
2311	RETVAL = self->generate_random_map (&rmp);	2830	RETVAL = self->generate_random_map (&rmp);
2312	}	2831	}
2313	OUTPUT:	2832	OUTPUT:
2314	RETVAL	2833	RETVAL
2315		2834
		2835	MODULE = cf PACKAGE = cf::mapspace
		2836
		2837	INCLUDE: $PERL $srcdir/genacc mapspace ../include/map.h |
		2838
2316	MODULE = cf PACKAGE = cf::arch	2839	MODULE = cf PACKAGE = cf::arch
2317		2840
2318	archetype *find (utf8_string name)	2841	int archetypes_size ()
2319	CODE:	2842	CODE:
2320	RETVAL = archetype::find (name);	2843	RETVAL = archetypes.size ();
2321	OUTPUT:
2322	RETVAL
2323
2324	archetype *first()
2325	PROTOTYPE:
2326	CODE:
2327	RETVAL = first_archetype;
2328	OUTPUT: RETVAL	2844	OUTPUT: RETVAL
		2845
		2846	archetype *archetypes (U32 index)
		2847	CODE:
		2848	RETVAL = index < archetypes.size () ? archetypes [index] : 0;
		2849	OUTPUT: RETVAL
2329		2850
2330	INCLUDE: $PERL $srcdir/genacc archetype ../include/object.h |	2851	INCLUDE: $PERL $srcdir/genacc archetype ../include/object.h |
2331		2852
2332	MODULE = cf PACKAGE = cf::party	2853	MODULE = cf PACKAGE = cf::party
2333		2854
…		…
2351	PROTOTYPE: $	2872	PROTOTYPE: $
2352	CODE:	2873	CODE:
2353	RETVAL = region::find (name);	2874	RETVAL = region::find (name);
2354	OUTPUT: RETVAL	2875	OUTPUT: RETVAL
2355		2876
2356	region *find_fuzzy (utf8_string name)
2357	PROTOTYPE: $
2358	CODE:
2359	RETVAL = region::find_fuzzy (name);
2360	OUTPUT: RETVAL
2361
2362	int specificity (region *rgn)	2877	int specificity (region *rgn)
2363	CODE:	2878	CODE:
2364	RETVAL = 0;	2879	RETVAL = 0;
2365	while (rgn = rgn->parent)	2880	while (rgn = rgn->parent)
2366	RETVAL++;	2881	RETVAL++;
…		…
2402	CODE:	2917	CODE:
2403	{	2918	{
2404	STRLEN len;	2919	STRLEN len;
2405	char *buf = SvPVbyte (packet, len);	2920	char *buf = SvPVbyte (packet, len);
2406		2921
		2922	if (len > MAXSOCKBUF)
		2923	{
		2924	// ugly
		2925	if (THIS->pl)
		2926	THIS->pl->failmsg ("[packet too long for client]");
		2927	}
		2928	else
2407	THIS->send_packet (buf, len);	2929	THIS->send_packet (buf, len);
2408	}	2930	}
		2931
		2932	faceidx
		2933	client::need_face (utf8_string name, int pri = 0)
		2934	CODE:
		2935	RETVAL = face_find (name, 0);
		2936	if (RETVAL)
		2937	{
		2938	THIS->send_face (RETVAL, pri);
		2939	THIS->flush_fx ();
		2940	}
		2941	OUTPUT:
		2942	RETVAL
		2943
		2944	int
		2945	client::fx_want (int idx, int value = -1)
		2946	CODE:
		2947	if (0 < idx && idx < FT_NUM)
		2948	{
		2949	RETVAL = THIS->fx_want [idx];
		2950	if (items > 2)
		2951	THIS->fx_want [idx] = value;
		2952	}
		2953	else
		2954	RETVAL = 0;
		2955	OUTPUT:
		2956	RETVAL
		2957
		2958	MODULE = cf PACKAGE = cf::sound PREFIX = sound_
		2959
		2960	faceidx sound_find (utf8_string name)
		2961
		2962	void sound_set (utf8_string str, faceidx face)
		2963
		2964	# dire hack
		2965	void old_sound_index (int idx, faceidx face)
		2966	CODE:
		2967	extern faceidx old_sound_index [SOUND_CAST_SPELL_0];
		2968	old_sound_index [idx] = face;
2409		2969
2410	MODULE = cf PACKAGE = cf::face PREFIX = face_	2970	MODULE = cf PACKAGE = cf::face PREFIX = face_
2411		2971
2412	#INCLUDE: $PERL $srcdir/genacc faceset ../include/face.h |	2972	#INCLUDE: $PERL $srcdir/genacc faceset ../include/face.h |
2413		2973
…		…
2429	if (!strcmp (name, BLANK_FACE_NAME)) blank_face = RETVAL;	2989	if (!strcmp (name, BLANK_FACE_NAME)) blank_face = RETVAL;
2430	if (!strcmp (name, EMPTY_FACE_NAME)) empty_face = RETVAL;	2990	if (!strcmp (name, EMPTY_FACE_NAME)) empty_face = RETVAL;
2431	}	2991	}
2432	OUTPUT: RETVAL	2992	OUTPUT: RETVAL
2433		2993
2434	void set (faceidx idx, int visibility, int magicmap)	2994	void set_type (faceidx idx, int value)
2435	CODE:	2995	ALIAS:
2436	faceinfo *f = face_info (idx);	2996	set_type = 0
2437	assert (f);	2997	set_visibility = 1
2438	f->visibility = visibility;	2998	set_magicmap = 2
2439	f->magicmap = magicmap;	2999	set_smooth = 3
2440		3000	set_smoothlevel = 4
2441	void set_smooth (faceidx idx, faceidx smooth, int smoothlevel)
2442	CODE:	3001	CODE:
2443	faceinfo *f = face_info (idx); assert (f);	3002	faceinfo *f = face_info (idx); assert (f);
2444	f->smooth = smooth;	3003	switch (ix)
2445	f->smoothlevel = smoothlevel;	3004	{
		3005	case 0: f->type = value; break;
		3006	case 1: f->visibility = value; break;
		3007	case 2: f->magicmap = value; break;
		3008	case 3: f->smooth = value; break;
		3009	case 4: f->smoothlevel = value; break;
		3010	}
2446		3011
2447	void set_data (faceidx idx, int faceset, SV *data, SV *chksum)	3012	void set_data (faceidx idx, int faceset, SV *data, SV *chksum)
2448	CODE:	3013	CODE:
2449	{	3014	{
2450	facedata *d = face_data (idx, faceset);	3015	faceinfo *f = face_info (idx); assert (f);
2451	assert (d);	3016	facedata *d = &(faceset ? f->data64 : f->data32);
2452	sv_to (data, d->data);	3017	sv_to (data, d->data);
2453	STRLEN clen;	3018	STRLEN clen;
2454	char *cdata = SvPVbyte (chksum, clen);	3019	char *cdata = SvPVbyte (chksum, clen);
2455	clen = min (CHKSUM_SIZE, clen);	3020	clen = min (CHKSUM_MAXLEN, clen);
2456		3021
		3022	assert (("cf::face::set_data must be called with a non-empty checksum", clen));
		3023
2457	if (memcmp (d->chksum, cdata, clen))	3024	if (clen != d->chksum_len || memcmp (d->chksum, cdata, clen))
2458	{	3025	{
		3026	d->chksum_len = clen;
2459	memcpy (d->chksum, cdata, clen);	3027	memcpy (d->chksum, cdata, clen);
2460		3028
2461	// invalidate existing client face info	3029	// invalidate existing client face info
2462	for_all_clients (ns)	3030	for_all_clients (ns)
2463	if (ns->faceset == faceset)	3031	if (ns->faceset == faceset)
…		…
2466	ns->force_newmap = true;	3034	ns->force_newmap = true;
2467	}	3035	}
2468	}	3036	}
2469	}	3037	}
2470		3038
		3039	int get_data_size (faceidx idx, int faceset = 0)
		3040	CODE:
		3041	facedata *d = face_data (idx, faceset);
		3042	if (!d) XSRETURN_UNDEF;
		3043	RETVAL = d->data.size ();
		3044	OUTPUT:
		3045	RETVAL
		3046
		3047	SV *get_chksum (faceidx idx, int faceset = 0)
		3048	CODE:
		3049	facedata *d = face_data (idx, faceset);
		3050	if (!d) XSRETURN_UNDEF;
		3051	RETVAL = newSVpvn ((char *)d->chksum, d->chksum_len);
		3052	OUTPUT:
		3053	RETVAL
		3054
		3055	SV *get_data (faceidx idx, int faceset = 0)
		3056	CODE:
		3057	facedata *d = face_data (idx, faceset);
		3058	if (!d) XSRETURN_UNDEF;
		3059	RETVAL = newSVpvn (d->data.data (), d->data.length ());
		3060	OUTPUT:
		3061	RETVAL
		3062
2471	void invalidate (faceidx idx)	3063	void invalidate (faceidx idx)
2472	CODE:	3064	CODE:
2473	for_all_clients (ns)	3065	for_all_clients (ns)
2474	{	3066	{
2475	ns->faces_sent [idx] = false;	3067	ns->faces_sent [idx] = false;
…		…
2509	}	3101	}
2510	else	3102	else
2511	anim = &animation::create (name, av_len (av) + 1, facings);	3103	anim = &animation::create (name, av_len (av) + 1, facings);
2512		3104
2513	for (int i = 0; i < anim->num_animations; ++i)	3105	for (int i = 0; i < anim->num_animations; ++i)
2514	anim->faces [i] = face_find (SvPVutf8_nolen (*av_fetch (av, i, 1)));	3106	anim->faces [i] = face_find (cfSvPVutf8_nolen (*av_fetch (av, i, 1)));
2515	}	3107	}
2516	OUTPUT: RETVAL	3108	OUTPUT: RETVAL
2517		3109
2518	void invalidate_all ()	3110	void invalidate_all ()
2519	CODE:	3111	CODE:
2520	for_all_clients (ns)	3112	for_all_clients (ns)
2521	ns->anims_sent.reset ();	3113	ns->anims_sent.reset ();
2522		3114
		3115	MODULE = cf PACKAGE = cf::object::freezer
		3116
		3117	INCLUDE: $PERL $srcdir/genacc object_freezer ../include/cfperl.h |
		3118
		3119	SV *
		3120	new (char *klass)
		3121	CODE:
		3122	RETVAL = newSVptr (new object_freezer, gv_stashpv ("cf::object::freezer", 1));
		3123	OUTPUT: RETVAL
		3124
		3125	void
		3126	DESTROY (SV *sv)
		3127	CODE:
		3128	object_freezer *self;
		3129	sv_to (sv, self);
		3130	delete self;
		3131
		3132	MODULE = cf PACKAGE = cf::object::thawer
		3133
		3134	INCLUDE: $PERL $srcdir/genacc object_thawer ../include/cfperl.h |
		3135
		3136	SV *
		3137	new_from_file (char *klass, octet_string path)
		3138	CODE:
		3139	object_thawer *f = new object_thawer (path);
		3140	if (!*f)
		3141	{
		3142	delete f;
		3143	XSRETURN_UNDEF;
		3144	}
		3145	RETVAL = newSVptr (f, gv_stashpv ("cf::object::thawer", 1));
		3146	OUTPUT: RETVAL
		3147
		3148	void
		3149	DESTROY (SV *sv)
		3150	CODE:
		3151	object_thawer *self;
		3152	sv_to (sv, self);
		3153	delete self;
		3154
		3155	void
		3156	extract_tags (object_thawer *self)
		3157	PPCODE:
		3158	while (self->kw != KW_EOF)
		3159	{
		3160	PUTBACK;
		3161	coroapi::cede_to_tick ();
		3162	SPAGAIN;
		3163
		3164	if (self->kw == KW_tag)
		3165	XPUSHs (sv_2mortal (newSVpv_utf8 (self->get_str ())));
		3166
		3167	self->skip ();
		3168	}
		3169

Diff Legend

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