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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.210 by root, Sat May 19 00:08:12 2007 UTC vs.
Revision 1.337 by root, Thu Nov 12 01:11:52 2009 UTC

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.210 by root, Sat May 19 00:08:12 2007 UTC vs. Revision 1.337 by root, Thu Nov 12 01:11:52 2009 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.210 by root, Sat May 19 00:08:12 2007 UTC vs.
Revision 1.337 by root, Thu Nov 12 01:11:52 2009 UTC