[ViewVC] Diff of: cvs/deliantra/server/server/cfperl.xs

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.216 by root, Mon May 28 21:28:36 2007 UTC vs.
Revision 1.367 by root, Mon Apr 12 05:22:38 2010 UTC

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.216 by root, Mon May 28 21:28:36 2007 UTC vs. Revision 1.367 by root, Mon Apr 12 05:22:38 2010 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.216 by root, Mon May 28 21:28:36 2007 UTC vs.
Revision 1.367 by root, Mon Apr 12 05:22:38 2010 UTC