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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.147 by root, Sat Jan 20 22:09:54 2007 UTC vs.
Revision 1.384 by root, Fri Apr 30 21:00:40 2010 UTC

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.147 by root, Sat Jan 20 22:09:54 2007 UTC vs. Revision 1.384 by root, Fri Apr 30 21:00:40 2010 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.147 by root, Sat Jan 20 22:09:54 2007 UTC vs.
Revision 1.384 by root, Fri Apr 30 21:00:40 2010 UTC