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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.160 by elmex, Wed Jan 31 14:11:02 2007 UTC vs.
Revision 1.359 by root, Sun Apr 4 20:00:06 2010 UTC

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.160 by elmex, Wed Jan 31 14:11:02 2007 UTC vs. Revision 1.359 by root, Sun Apr 4 20:00:06 2010 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.160 by elmex, Wed Jan 31 14:11:02 2007 UTC vs.
Revision 1.359 by root, Sun Apr 4 20:00:06 2010 UTC