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

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.218 by root, Mon Jun 4 12:19:09 2007 UTC vs. Revision 1.369 by root, Wed Apr 14 02:31:24 2010 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.218 by root, Mon Jun 4 12:19:09 2007 UTC vs.
Revision 1.369 by root, Wed Apr 14 02:31:24 2010 UTC