ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/cfperl.xs

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

Diff Legend

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