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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.132 by root, Mon Jan 8 20:59:15 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)
101		156
102	unordered_vector<attachable *> attachable::mortals;	157	unordered_vector<attachable *> attachable::mortals;
103		158
104	attachable::~attachable ()	159	attachable::~attachable ()
105	{	160	{
106	assert (!(flags & F_BORROWED));	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	flags &= ~F_BORROWED;
123	refcnt_inc ();
124	SvREFCNT_dec ((SV *)self);	215	SvREFCNT_dec (cb);
		216	cb = 0;
125	}	217	}
126	}
127
128	// check wether the object really is dead
129	void
130	attachable::do_check ()
131	{
132	if (refcnt > 0)
133	return;
134
135	optimise ();
136
137	if (self)
138	{
139	if (refcnt + SvREFCNT (self) > 0)
140	return;
141
142	if (flags & F_BORROWED)
143	{
144	flags &= ~F_BORROWED;
145	refcnt_inc ();
146	SvREFCNT_dec (self);
147	}
148
149	if (self)
150	if (refcnt + SvREFCNT (self) > 0)
151	return;
152	}
153
154	if (refcnt > 0)
155	return;
156
157	destroy ();
158	}
159
160	void
161	attachable::do_destroy ()
162	{
163	invoke (EVENT_ATTACHABLE_DESTROY, DT_END);
164
165	if (self)
166	hv_clear (self);
167		218
168	mortals.push_back (this);	219	mortals.push_back (this);
169	}	220	}
170		221
171	void	222	void
172	attachable::destroy ()	223	attachable::destroy ()
173	{	224	{
174	if (destroyed ())	225	if (destroyed ())
175	return;	226	return;
176		227
177	flags \|= F_DESTROYED;	228	attachable_flags \|= F_DESTROYED;
178	do_destroy ();	229	do_destroy ();
		230	sever_self ();
		231	}
		232
		233	void
		234	attachable::do_delete ()
		235	{
		236	delete this;
179	}	237	}
180		238
181	void	239	void
182	attachable::check_mortals ()	240	attachable::check_mortals ()
183	{	241	{
184	for (int i = 0; i < mortals.size (); )	242	static int i = 0;
		243
		244	for (;;)
185	{	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
186	attachable *obj = mortals [i];	271	attachable *obj = mortals [i];
187		272
188	obj->refcnt_chk (); // unborrow from perl, if necessary	273	#if 0
189		274	if (obj->self)//D make this an assert later
190	if (obj->refcnt \|\| obj->self)
191	{	275	{
192	#if 0	276	LOG (llevError, "check_mortals: object '%s' still has self\n", typeid (obj).name ());
193	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 ();
194	obj->refcnt, obj->self, obj->self ? SvREFCNT(obj->self): - 1);//D	278	}
195	#endif	279	#endif
196		280
		281	if (obj->refcnt)
		282	{
197	++i; // further delay freeing	283	++i; // further delay freeing
		284
		285	if (!(i & 0x3ff))
		286	break;
198	}//D	287	}
199	else	288	else
200	{	289	{
201	//Dfprintf (stderr, "deleteing %d:%p:%s\n", i, obj,typeid (*obj).name ());//D
202	mortals.erase (i);	290	mortals.erase (i);
203	delete obj;	291	obj->sever_self ();
		292	obj->do_delete ();
204	}	293	}
205	}	294	}
206	}	295	}
207		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
208	attachable &	309	attachable &
209	attachable::operator =(const attachable &src)	310	attachable::operator =(const attachable &src)
210	{	311	{
211	//if (self \|\| cb)	312	//if (self \|\| cb)
212	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));	313	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));
213		314
214	attach = src.attach;	315	attach = src.attach;
215	return *this;	316	return *this;
216	}	317	}
217		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
218	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	354	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
219		355
220	static SV *	356	static SV *
221	newSVptr (void ptr, HV stash, HV *hv = newHV ())	357	newSVptr (void ptr, HV stash, HV *hv)
222	{	358	{
223	SV *sv;	359	SV *sv;
224		360
225	if (!ptr)	361	if (!ptr)
226	return &PL_sv_undef;	362	return newSV (0);
227		363
228	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);
229	return sv_bless (newRV_noinc ((SV *)hv), stash);	365	return sv_bless (newRV_noinc ((SV *)hv), stash);
230	}	366	}
231		367
		368	static SV *
		369	newSVptr (void ptr, HV stash)
		370	{
		371	return newSVptr (ptr, stash, newHV ());
		372	}
		373
232	static int	374	static int
233	attachable_free (pTHX_ SV sv, MAGIC mg)	375	attachable_free (pTHX_ SV sv, MAGIC mg)
234	{	376	{
235	attachable at = (attachable )mg->mg_ptr;	377	attachable at = (attachable )mg->mg_ptr;
236	assert (!(at->flags & attachable::F_BORROWED));	378
		379	//TODO: check if transaction behaviour is really required here
		380	if (SV self = (SV )at->self)
		381	{
237	at->self = 0;	382	at->self = 0;
		383	SvREFCNT_dec (self);
		384	}
		385
238	// 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
239	//at->refcnt_chk ();	387	//at->refcnt_chk ();
240	return 0;	388	return 0;
241	}	389	}
242		390
…		…
244		392
245	static SV *	393	static SV *
246	newSVattachable (attachable obj, HV stash)	394	newSVattachable (attachable obj, HV stash)
247	{	395	{
248	if (!obj)	396	if (!obj)
249	return &PL_sv_undef;	397	return newSV (0);
250		398
251	if (!obj->self)	399	if (!obj->self)
		400	obj->self = newHV ();
		401
		402	if (!SvOBJECT (obj->self))
252	{	403	{
253	obj->self = newHV ();
254	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);
255		405
256	// borrow the refcnt from the object
257	obj->flags \|= attachable::F_BORROWED;
258	obj->refcnt_dec ();
259
260	// 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
261	return sv_bless (newRV_inc ((SV *)obj->self), stash);	408	return sv_bless (newRV_inc ((SV *)obj->self), stash);
262	}	409	}
263	else	410	else
		411	{
264	return newRV_inc ((SV *)obj->self);	412	SV sv = newRV_inc ((SV )obj->self);
265	}
266		413
		414	if (Gv_AMG (stash)) // handle overload correctly, as the perl core does not
		415	SvAMAGIC_on (sv);
		416
		417	return sv;
		418	}
		419	}
		420
		421	#if 0 // unused
267	static void	422	static void
268	clearSVptr (SV *sv)	423	clearSVptr (SV *sv)
269	{	424	{
270	if (SvROK (sv))	425	if (SvROK (sv))
271	sv = SvRV (sv);	426	sv = SvRV (sv);
272		427
273	hv_clear ((HV *)sv);	428	hv_clear ((HV *)sv);
274	sv_unmagic (sv, PERL_MAGIC_ext);	429	sv_unmagic (sv, PERL_MAGIC_ext);
275	}	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	}
276		447
277	static long	448	static long
278	SvPTR (SV sv, const char klass)	449	SvPTR (SV sv, const char klass)
279	{	450	{
280	if (!sv_derived_from (sv, klass))	451	if (!sv_derived_from (sv, klass))
281	croak ("object of type %s expected", klass);	452	croak ("object of type %s expected", klass);
282		453
283	MAGIC *mg = mg_find (SvRV (sv), PERL_MAGIC_ext);	454	return SvPTR_nc (sv);
284
285	if (!mg)
286	croak ("perl code used %s object, but C object is already destroyed, caught", klass);
287
288	return (long)mg->mg_ptr;
289	}	455	}
290		456
291	static long	457	static long noinline
292	SvPTR_ornull (SV sv, const char klass)	458	SvPTR_ornull (SV sv, const char klass)
293	{	459	{
294	if (SvOK (sv))	460	if (expect_false (!SvOK (sv))) return 0;
		461
295	return SvPTR (sv, klass);	462	return SvPTR (sv, klass);
296	else
297	return 0;
298	}	463	}
299		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
300	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); }
301	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); }
302	inline SV *to_sv (bool v) { return newSViv (v); }	522	static inline SV *to_sv (bool v) { return newSViv (v); }
303	inline SV *to_sv ( signed char v) { return newSViv (v); }	523	static inline SV *to_sv ( signed char v) { return newSViv (v); }
304	inline SV *to_sv (unsigned char v) { return newSViv (v); }	524	static inline SV *to_sv (unsigned char v) { return newSViv (v); }
305	inline SV *to_sv ( signed short v) { return newSViv (v); }	525	static inline SV *to_sv ( signed short v) { return newSViv (v); }
306	inline SV *to_sv (unsigned short v) { return newSVuv (v); }	526	static inline SV *to_sv (unsigned short v) { return newSVuv (v); }
307	inline SV *to_sv ( signed int v) { return newSViv (v); }	527	static inline SV *to_sv ( signed int v) { return newSViv (v); }
308	inline SV *to_sv (unsigned int v) { return newSVuv (v); }	528	static inline SV *to_sv (unsigned int v) { return newSVuv (v); }
309	inline SV *to_sv ( signed long v) { return newSViv (v); }	529	static inline SV *to_sv ( signed long v) { return newSViv (v); }
310	inline SV *to_sv (unsigned long v) { return newSVuv (v); }	530	static inline SV *to_sv (unsigned long v) { return newSVuv (v); }
311	inline SV *to_sv ( signed long long v) { return newSVval64 (v); }	531	static inline SV *to_sv ( signed long long v) { return newSVval64 (v); }
312	inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }	532	static inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }
313	inline SV *to_sv (float v) { return newSVnv (v); }	533	static inline SV *to_sv (float v) { return newSVnv (v); }
314	inline SV *to_sv (double v) { return newSVnv (v); }	534	static inline SV *to_sv (double v) { return newSVnv (v); }
315	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); }
316	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); }
317	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); }
318	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); }
319	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); }
320	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); }
321	inline SV to_sv (region v) { return newSVptr (v, stash_cf_region_wrap); }
322	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); }
323		544
324	inline SV *to_sv (object & v) { return to_sv (&v); }	545	static inline SV *to_sv (object & v) { return to_sv (&v); }
325	inline SV *to_sv (living & v) { return to_sv (&v); }	546	static inline SV *to_sv (living & v) { return to_sv (&v); }
326		547
327	//TODO:	548	static inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); }
328	inline SV to_sv (New_Face v) { return to_sv (v->name); }
329	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); }
330		550
331	inline SV *to_sv (UUID v)	551	static inline SV *to_sv (UUID v) { return newSVpv (v.c_str (), 0); }
332	{
333	char buf[128];
334	snprintf (buf, 128, "<1,%" PRIx64 ">", v.seq);
335	return newSVpv (buf, 0);
336	}
337		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
338	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; }
339	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; }
340	inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }	576	static inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }
341	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); }
342	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); }
343	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); }
344	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); }
345	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); }
346	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); }
347	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); }
348	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); }
349	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); }
350	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); }
351	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }	587	static inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
352	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }	588	static inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }
353	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); }
354	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); }
355	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); }
356	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"); }
357	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"); }
358	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"); }
359	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"); }
360	inline void sv_to (SV sv, region &v) { v = (region *)SvPTR_ornull (sv, "cf::region"); }
361	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" ); }
362		601
363	inline void sv_to (SV sv, New_Face &v) { v = &new_faces[FindFace (SvPV_nolen (sv), 0)]; } //TODO	602	//static inline void sv_to (SV sv, faceinfo &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }
364	inline void sv_to (SV sv, treasurelist &v) { v = find_treasurelist (SvPV_nolen (sv)); } // TODO	603	static inline void sv_to (SV sv, treasurelist &v) { v = treasurelist::find (SvPV_nolen (sv)); }
365		604
366	template<class T>	605	template<class T>
367	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; }
368		607
369	template<int N>	608	template<int N>
370	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)); }
371		610
372	inline void sv_to (SV *sv, rangetype &v) { v = (rangetype) SvIV (sv); }
373	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); }
374	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); }
375	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); }
376	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); }
377		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
378	inline void sv_to (SV *sv, UUID &v)	623	static inline void sv_to (SV *sv, UUID &v)
379	{	624	{
380	unsigned int version;	625	if (!v.parse (SvPV_nolen (sv)))
381
382	if (2 != sscanf (SvPV_nolen (sv), "<%d.%" SCNx64 ">", &version, &v.seq) \|\| 1 != version)
383	croak ("unparsable uuid: %s", SvPV_nolen (sv));	626	croak ("unparsable uuid: %s", SvPV_nolen (sv));
384	}	627	}
385		628
386	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); }
387		630
388	static SV *	631	static SV *
389	newSVdt_va (va_list &ap, data_type type)	632	newSVdt_va (va_list &ap, data_type type)
390	{	633	{
391	SV *sv;	634	SV *sv;
…		…
405	break;	648	break;
406		649
407	case DT_STRING:	650	case DT_STRING:
408	{	651	{
409	char str = (char )va_arg (ap, const char *);	652	char str = (char )va_arg (ap, const char *);
410	sv = str ? newSVpv (str, 0) : &PL_sv_undef;	653	sv = str ? newSVpv (str, 0) : newSV (0);
411	}	654	}
412	break;	655	break;
413		656
414	case DT_DATA:	657	case DT_DATA:
415	{	658	{
416	char str = (char )va_arg (ap, const void *);	659	char str = (char )va_arg (ap, const void *);
417	int len = va_arg (ap, int);	660	int len = va_arg (ap, int);
418	sv = str ? newSVpv (str, len) : &PL_sv_undef;	661	sv = str ? newSVpv (str, len) : newSV (0);
419	}	662	}
420	break;	663	break;
421		664
422	case DT_OBJECT:	665	case DT_OBJECT:
423	sv = to_sv (va_arg (ap, object *));	666	sv = to_sv (va_arg (ap, object *));
…		…
465	va_end (ap);	708	va_end (ap);
466		709
467	return sv;	710	return sv;
468	}	711	}
469		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
470	static SV *	739	static SV *
471	newSVcfapi (int type, ...)
472	{
473	SV *sv;
474
475	va_list ap;
476	va_start (ap, type);
477
478	switch (type)
479	{
480	case CFAPI_INT: sv = newSViv (va_arg (ap, int )); break;
481	case CFAPI_LONG: sv = newSVval64 (va_arg (ap, sint64 )); break;
482	case CFAPI_DOUBLE: sv = newSVnv (va_arg (ap, double )); break;
483	case CFAPI_STRING: sv = newSVdt_va (ap, DT_STRING); break;
484	case CFAPI_POBJECT: sv = newSVdt_va (ap, DT_OBJECT); break;
485	case CFAPI_PMAP: sv = newSVdt_va (ap, DT_MAP ); break;
486	case CFAPI_PPLAYER: sv = newSVdt_va (ap, DT_PLAYER); break;
487	case CFAPI_PARCH: sv = newSVdt_va (ap, DT_ARCH ); break;
488	case CFAPI_PPARTY: sv = newSVdt_va (ap, DT_PARTY ); break;
489	case CFAPI_PREGION: sv = newSVdt_va (ap, DT_REGION); break;
490
491	default:
492	assert (("unhandled type in newSVcfapi", 0));
493	}
494
495	va_end (ap);
496
497	return sv;
498	}
499
500	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
501
502	SV *
503	registry (attachable *ext)	740	registry (attachable *ext)
504	{	741	{
505	if (!ext->cb)	742	if (!ext->cb)
506	ext->cb = newAV ();	743	ext->cb = newAV ();
507		744
508	return newRV_inc ((SV *)ext->cb);	745	return newRV_inc ((SV *)ext->cb);
509	}	746	}
510		747
511	#if 0
512	void attachable::clear ()
513	{
514	if (self)
515	{
516	// disconnect Perl from C, to avoid crashes
517	sv_unmagic (SvRV ((SV *)self), PERL_MAGIC_ext);
518
519	// clear the perl hash, might or might not be a good idea
520	hv_clear ((HV )SvRV ((SV )self));
521
522	SvREFCNT_dec (self);
523	self = 0;
524	}
525
526	if (cb)
527	{
528	SvREFCNT_dec (cb);
529	cb = 0;
530	}
531
532	attach = 0;
533	}
534	#endif
535
536	/////////////////////////////////////////////////////////////////////////////	748	/////////////////////////////////////////////////////////////////////////////
537		749
538	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
539	{
540	return 0;
541	}
542
543	static CommArray_s rtn_cmd;
544
545	static int
546	runPluginCommand (object obj, char params)
547	{
548	return -1;
549	}
550
551	extern "C" void cfperl_getPluginProperty (int type, ...)
552	{
553	va_list args;
554	char *propname;
555	int i;
556	va_start (args, type);
557	propname = va_arg (args, char *);
558	//printf ("Property name: %s\n", propname);
559
560	if (!strcmp (propname, "command?"))
561	return NULL;
562	else if (!strcmp (propname, "Identification"))
563	{
564	va_end (args);
565	return (void *)PLUGIN_NAME;
566	}
567	else if (!strcmp (propname, "FullName"))
568	{
569	va_end (args);
570	return (void *)PLUGIN_VERSION;
571	}
572	else
573	va_end (args);
574
575	return NULL;
576	}
577
578	extern "C" int cfperl_postInitPlugin ()
579	{
580	int hooktype = 1;
581	int rtype = 0;
582
583	cf_init_plugin (gethook);
584
585	return 0;
586	}
587
588	extern "C" int cfperl_closePlugin ()
589	{
590	return 0;
591	}
592
593	void	750	void
594	cfperl_init ()	751	cfperl_init ()
595	{	752	{
		753	extern char **environ;
		754
596	PERL_SYS_INIT3 (&settings.argc, &settings.argv, 0);	755	PERL_SYS_INIT3 (&settings.argc, &settings.argv, &environ);
597	perl = perl_alloc ();	756	perl = perl_alloc ();
598	perl_construct (perl);	757	perl_construct (perl);
599		758
600	PL_exit_flags \|= PERL_EXIT_DESTRUCT_END;	759	PL_exit_flags \|= PERL_EXIT_DESTRUCT_END;
601		760
602	char *argv[] = {	761	const char *argv[] = {
603	"",	762	settings.argv [0],
604	"-e"	763	"-e0"
605	"use Event; use Coro;" // required for bootstrap
606	"cf->bootstrap;" // required for datadir :*>
607	"unshift @INC, cf::datadir ();"
608	"require cf;"
609	};	764	};
610		765
611	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))
612	{	768	{
613	printf ("unable to initialize perl-interpreter, aborting.\n");	769	printf ("unable to initialize perl-interpreter, aborting.\n");
614	exit (EXIT_FAILURE);	770	exit (EXIT_FAILURE);
615	}	771	}
616	}
617		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
618	void cfperl_main ()	791	cfperl_main ()
619	{	792	{
620	dSP;	793	dSP;
621		794
622	PUSHMARK (SP);	795	PUSHMARK (SP);
623	PUTBACK;	796	PUTBACK;
…		…
627	void	800	void
628	attachable::instantiate ()	801	attachable::instantiate ()
629	{	802	{
630	if (attach)	803	if (attach)
631	{	804	{
632	invoke (EVENT_ATTACHABLE_INSTANTIATE, ARG_STRING (attach), DT_END);	805	INVOKE_ATTACHABLE (INSTANTIATE, this, ARG_STRING (attach));
633	attach = 0;	806	attach = 0;
634	}	807	}
635	}	808	}
636		809
637	void	810	void
638	attachable::reattach ()	811	attachable::reattach ()
639	{	812	{
640	optimise ();	813	optimise ();
641	//TODO: check for _attachment's, very important for restarts	814	//TODO: check for _attachment's, very important for restarts
642	invoke (EVENT_ATTACHABLE_REATTACH, DT_END);	815	INVOKE_ATTACHABLE (REATTACH, this);
643	}	816	}
644		817
645	static event_klass klass_of[NUM_EVENT_TYPES] = {	818	static event_klass klass_of[NUM_EVENT_TYPES] = {
646	# define def(type,name) KLASS_ ## type,	819	# define def(type,name) KLASS_ ## type,
647	# include "eventinc.h"	820	# include "eventinc.h"
648	# undef def	821	# undef def
649	};	822	};
650		823
651	#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)
652		825
653	static void	826	static void noinline
654	gather_callbacks (AV &callbacks, AV registry, event_type event)	827	gather_callbacks (AV &callbacks, AV registry, event_type event)
655	{	828	{
656	// event must be in array	829	// event must be in array
657	if (event >= 0 && event <= AvFILLp (registry))	830	if (event >= 0 && event <= AvFILLp (registry))
658	{	831	{
…		…
690	}	863	}
691		864
692	void	865	void
693	global::gather_callbacks (AV *&callbacks, event_type event) const	866	global::gather_callbacks (AV *&callbacks, event_type event) const
694	{	867	{
695	::gather_callbacks (callbacks, cb_object, event);	868	::gather_callbacks (callbacks, cb_global, event);
696	}	869	}
697		870
698	void	871	void
699	object::gather_callbacks (AV *&callbacks, event_type event) const	872	object::gather_callbacks (AV *&callbacks, event_type event) const
700	{	873	{
701	if (subtype && type + subtype * NUM_SUBTYPES <= AvFILLp (cb_type))	874	if (subtype && type + subtype * NUM_TYPES <= AvFILLp (cb_type))
702	{	875	{
703	SV registry = AvARRAY (cb_type)[type + subtype NUM_SUBTYPES];	876	SV registry = AvARRAY (cb_type)[type + subtype NUM_TYPES];
704		877
705	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)	878	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
706	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);	879	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);
707	}	880	}
708		881
…		…
744	{	917	{
745	attachable::gather_callbacks (callbacks, event);	918	attachable::gather_callbacks (callbacks, event);
746	::gather_callbacks (callbacks, cb_map, event);	919	::gather_callbacks (callbacks, cb_map, event);
747	}	920	}
748		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
749	bool	972	bool
750	attachable::invoke (event_type event, ...)	973	attachable::invoke (event_type event, ...)
751	{	974	{
752	data_type dt;	975	data_type dt;
753	va_list ap;
754
755	va_start (ap, event);
756		976
757	// callback call ordering should be:	977	// callback call ordering should be:
758	// 1. per-object callback	978	// 1. per-object callback
759	// 2. per-class object	979	// 2. per-class object
760	// 3. per-type callback	980	// 3. per-type callback
…		…
764	gather_callbacks (callbacks, event);	984	gather_callbacks (callbacks, event);
765		985
766	// short-circuit processing if no callbacks found/defined	986	// short-circuit processing if no callbacks found/defined
767	if (!callbacks)	987	if (!callbacks)
768	return 0;	988	return 0;
		989
		990	va_list ap;
		991	va_start (ap, event);
769		992
770	CALL_BEGIN (3);	993	CALL_BEGIN (3);
771	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays	994	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays
772	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));	995	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));
773		996
…		…
797	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));	1020	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
798	}	1021	}
799		1022
800	va_end (ap);	1023	va_end (ap);
801		1024
802	CALL_CALL ("cf::do_invoke", G_SCALAR);	1025	CALL_CALL (cv_cf_do_invoke, G_SCALAR);
803	count = count > 0 ? POPi : 0;	1026	count = count > 0 ? POPi : 0;
804		1027
805	CALL_END;	1028	CALL_END;
806		1029
807	return count;	1030	return count;
808	}	1031	}
809		1032
810	SV *	1033	static SV *
811	cfperl_result (int idx)	1034	cfperl_result (int idx)
812	{	1035	{
813	AV *av = get_av ("cfperl::invoke_results", 0);	1036	AV *av = get_av ("cf::INVOKE_RESULTS", 0);
814	if (!av)	1037	if (!av)
815	return &PL_sv_undef;	1038	return &PL_sv_undef;
816		1039
817	SV **sv = av_fetch (av, idx, 0);	1040	SV **sv = av_fetch (av, idx, 0);
818	if (!sv)	1041	if (!sv)
…		…
832	{	1055	{
833	return SvNV (cfperl_result (idx));	1056	return SvNV (cfperl_result (idx));
834	}	1057	}
835		1058
836	/////////////////////////////////////////////////////////////////////////////	1059	/////////////////////////////////////////////////////////////////////////////
		1060	// various c++ => perl glue functions
837		1061
838	void	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	}
		1080
		1081	void
839	maptile::emergency_save ()	1082	cfperl_emergency_save ()
840	{	1083	{
841	CALL_BEGIN (0);	1084	CALL_BEGIN (0);
842	CALL_CALL ("cf::map::emergency_save", G_VOID);	1085	CALL_CALL ("cf::emergency_save", G_VOID);
843	CALL_END;	1086	CALL_END;
844	}	1087	}
845		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
846	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 *
847	maptile::find_sync (const char path, maptile origin)	1181	maptile::find_sync (const_utf8_string path, maptile *origin)
848	{	1182	{
849	CALL_BEGIN (2);	1183	CALL_BEGIN (2);
850	CALL_ARG (path);	1184	CALL_ARG (path);
851	CALL_ARG (origin);	1185	CALL_ARG (origin);
852	CALL_CALL ("cf::map::find_sync", G_SCALAR);	1186	CALL_CALL ("cf::map::find_sync", G_SCALAR);
853		1187
854	maptile *retval;	1188	maptile *retval = 0;
855
856	if (count)
857	sv_to (POPs, retval);	1189	if (count) sv_to (POPs, retval);
858	else	1190
859	retval = 0;	1191	CALL_END;
		1192
		1193	return retval;
		1194	}
		1195
		1196	maptile *
		1197	maptile::find_async (const_utf8_string path, maptile *origin, bool load)
		1198	{
		1199	CALL_BEGIN (3);
		1200	CALL_ARG (path);
		1201	CALL_ARG (origin);
		1202	CALL_ARG (load);
		1203	CALL_CALL ("cf::map::find_async", G_SCALAR);
		1204
		1205	maptile *retval = 0;
		1206	if (count) sv_to (POPs, retval);
860		1207
861	CALL_END;	1208	CALL_END;
862		1209
863	return retval;	1210	return retval;
864	}	1211	}
…		…
867	maptile::do_load_sync ()	1214	maptile::do_load_sync ()
868	{	1215	{
869	CALL_BEGIN (1);	1216	CALL_BEGIN (1);
870	CALL_ARG (this);	1217	CALL_ARG (this);
871	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);	1218	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);
872	CALL_END;
873	}
874
875	void
876	maptile::change_all_map_light (int change)
877	{
878	CALL_BEGIN (1);
879	CALL_ARG (change);
880	CALL_CALL ("cf::map::change_all_map_light", G_VOID);
881	CALL_END;	1219	CALL_END;
882	}	1220	}
883		1221
884	void	1222	void
885	object::enter_exit (object *exit)	1223	object::enter_exit (object *exit)
…		…
892	CALL_ARG (exit);	1230	CALL_ARG (exit);
893	CALL_CALL ("cf::object::player::enter_exit", G_VOID);	1231	CALL_CALL ("cf::object::player::enter_exit", G_VOID);
894	CALL_END;	1232	CALL_END;
895	}	1233	}
896		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
897	/////////////////////////////////////////////////////////////////////////////	1347	/////////////////////////////////////////////////////////////////////////////
898		1348
899	struct EventAPI *watcher_base::GEventAPI;	1349	struct EVAPI *evapi::GEVAPI;
900	struct CoroAPI *coroapi::GCoroAPI;	1350	struct CoroAPI *coroapi::GCoroAPI;
901		1351
902	int coroapi::cede_counter;
903
904	static void iw_dispatch (pe_event *ev)
905	{
906	iw w = (iw )ev->ext_data;
907	w->call (*w);
908	}
909
910	void	1352	void
911	iw::alloc ()	1353	coroapi::do_cede_to_tick ()
912	{	1354	{
913	pe = GEventAPI->new_idle (0, 0);	1355	cede_pending = 0;
914		1356	cede ();
915	pe->base.callback = (void *)iw_dispatch;
916	pe->base.ext_data = (void *)this;
917	}	1357	}
918		1358
919	static void iow_dispatch (pe_event *ev)
920	{
921	iow w = (iow )ev->ext_data;
922	w->call (w, ((pe_ioevent )ev)->got);
923	}
924
925	void	1359	void
926	iow::alloc ()	1360	coroapi::wait_for_tick ()
927	{	1361	{
928	pe = GEventAPI->new_io (0, 0);	1362	CALL_BEGIN (0);
929		1363	CALL_CALL ("cf::wait_for_tick", G_DISCARD);
930	pe->base.callback = (void *)iow_dispatch;	1364	CALL_END;
931	pe->base.ext_data = (void *)this;
932
933	pe->fd = -1;
934	pe->poll = 0;
935	}	1365	}
936		1366
937	void	1367	void
938	iow::fd (int fd)	1368	coroapi::wait_for_tick_begin ()
939	{	1369	{
940	pe->fd = fd;	1370	CALL_BEGIN (0);
941	}	1371	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);
942		1372	CALL_END;
943	int
944	iow::poll ()
945	{
946	return pe->poll;
947	}	1373	}
948		1374
949	void	1375	void
950	iow::poll (int events)	1376	iow::poll (int events)
951	{	1377	{
952	if (pe->poll != events)	1378	if (events != this->events)
953	{	1379	{
		1380	int active = ev_is_active ((ev_io *)this);
954	if (pe->poll) stop ();	1381	if (active) stop ();
955	pe->poll = events;	1382	ev_io_set ((ev_io *)this, fd, events);
956	if (pe->poll) start ();	1383	if (active) start ();
957	}	1384	}
958	}	1385	}
959		1386
960	void	1387	static void
961	_connect_to_perl ()	1388	_connect_to_perl_1 ()
962	{	1389	{
963	stash_cf = gv_stashpv ("cf" , 1);	1390	stash_cf = gv_stashpv ("cf", 1);
964		1391
965	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);	1392	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);
966	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);
967	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);	1394	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);
968	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);
969	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);	1397	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);
970	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);	1398	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
971	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);	1399	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
972	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);	1400	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
973	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);
974		1403
975	sv_runtime = get_sv ("cf::RUNTIME", 1);	1404	sv_now = get_sv ("cf::NOW" , 1); SvUPGRADE (sv_now , SVt_NV);
976	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);
977		1408
978	cb_global = get_av ("cf::CB_GLOBAL", 1);	1409	cb_global = get_av ("cf::CB_GLOBAL", 1);
979	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);	1410	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
980	cb_object = get_av ("cf::CB_OBJECT", 1);	1411	cb_object = get_av ("cf::CB_OBJECT", 1);
981	cb_player = get_av ("cf::CB_PLAYER", 1);	1412	cb_player = get_av ("cf::CB_PLAYER", 1);
982	cb_client = get_av ("cf::CB_CLIENT", 1);	1413	cb_client = get_av ("cf::CB_CLIENT", 1);
983	cb_type = get_av ("cf::CB_TYPE" , 1);	1414	cb_type = get_av ("cf::CB_TYPE" , 1);
984	cb_map = get_av ("cf::CB_MAP" , 1);	1415	cb_map = get_av ("cf::CB_MAP" , 1);
985	}	1416	}
986		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
987	MODULE = cf PACKAGE = cf PREFIX = cf_	1428	MODULE = cf PACKAGE = cf PREFIX = cf_
988		1429
989	BOOT:	1430	BOOT:
990	{	1431	{
		1432	I_EV_API (PACKAGE); evapi::GEVAPI = GEVAPI;
		1433	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
		1434
991	_connect_to_perl ();	1435	_connect_to_perl_1 ();
992
993	I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;
994	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
995		1436
996	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	//}
997		1447
998	static const struct {	1448	static const struct {
999	const char *name;	1449	const char *name;
1000	IV iv;	1450	IV iv;
1001	} *civ, const_iv[] = {	1451	} *civ, const_iv[] = {
1002	# define const_iv(name) { # name, (IV)name },	1452	# define const_iv(name) { # name, (IV)name },
1003	const_iv (llevError)	1453	# include "const_iv.h"
1004	const_iv (llevInfo)	1454	# define def(uc, lc, name, plus, change) const_iv (AT_ ## uc) const_iv (ATNR_ ## uc)
1005	const_iv (llevDebug)	1455	# include "attackinc.h"
1006	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)
1007		1464
1008	const_iv (MAX_TIME)	1465	const_iv (MAX_TIME)
1009	const_iv (PLAYER)
1010	const_iv (TRANSPORT)
1011	const_iv (ROD)
1012	const_iv (TREASURE)
1013	const_iv (POTION)
1014	const_iv (FOOD)
1015	const_iv (POISON)
1016	const_iv (BOOK)
1017	const_iv (CLOCK)	1466	const_iv (MAXSOCKBUF)
1018	const_iv (ARROW)
1019	const_iv (BOW)
1020	const_iv (WEAPON)
1021	const_iv (ARMOUR)
1022	const_iv (PEDESTAL)
1023	const_iv (ALTAR)
1024	const_iv (LOCKED_DOOR)
1025	const_iv (SPECIAL_KEY)
1026	const_iv (MAP)
1027	const_iv (DOOR)
1028	const_iv (KEY)
1029	const_iv (TIMED_GATE)
1030	const_iv (TRIGGER)
1031	const_iv (GRIMREAPER)
1032	const_iv (MAGIC_EAR)
1033	const_iv (TRIGGER_BUTTON)
1034	const_iv (TRIGGER_ALTAR)
1035	const_iv (TRIGGER_PEDESTAL)
1036	const_iv (SHIELD)
1037	const_iv (HELMET)
1038	const_iv (HORN)
1039	const_iv (MONEY)
1040	const_iv (CLASS)
1041	const_iv (GRAVESTONE)
1042	const_iv (AMULET)
1043	const_iv (PLAYERMOVER)
1044	const_iv (TELEPORTER)
1045	const_iv (CREATOR)
1046	const_iv (SKILL)
1047	const_iv (EARTHWALL)
1048	const_iv (GOLEM)
1049	const_iv (THROWN_OBJ)
1050	const_iv (BLINDNESS)
1051	const_iv (GOD)
1052	const_iv (DETECTOR)
1053	const_iv (TRIGGER_MARKER)
1054	const_iv (DEAD_OBJECT)
1055	const_iv (DRINK)
1056	const_iv (MARKER)
1057	const_iv (HOLY_ALTAR)
1058	const_iv (PLAYER_CHANGER)
1059	const_iv (BATTLEGROUND)
1060	const_iv (PEACEMAKER)
1061	const_iv (GEM)
1062	const_iv (FIREWALL)
1063	const_iv (ANVIL)
1064	const_iv (CHECK_INV)
1065	const_iv (MOOD_FLOOR)
1066	const_iv (EXIT)
1067	const_iv (ENCOUNTER)
1068	const_iv (SHOP_FLOOR)
1069	const_iv (SHOP_MAT)
1070	const_iv (RING)
1071	const_iv (FLOOR)
1072	const_iv (FLESH)
1073	const_iv (INORGANIC)
1074	const_iv (SKILL_TOOL)
1075	const_iv (LIGHTER)
1076	const_iv (BUILDABLE_WALL)
1077	const_iv (MISC_OBJECT)
1078	const_iv (LAMP)
1079	const_iv (DUPLICATOR)
1080	const_iv (SPELLBOOK)
1081	const_iv (CLOAK)
1082	const_iv (SPINNER)
1083	const_iv (GATE)
1084	const_iv (BUTTON)
1085	const_iv (CF_HANDLE)
1086	const_iv (HOLE)
1087	const_iv (TRAPDOOR)
1088	const_iv (SIGN)
1089	const_iv (BOOTS)
1090	const_iv (GLOVES)
1091	const_iv (SPELL)
1092	const_iv (SPELL_EFFECT)
1093	const_iv (CONVERTER)
1094	const_iv (BRACERS)
1095	const_iv (POISONING)
1096	const_iv (SAVEBED)
1097	const_iv (WAND)
1098	const_iv (SCROLL)
1099	const_iv (DIRECTOR)
1100	const_iv (GIRDLE)
1101	const_iv (FORCE)
1102	const_iv (POTION_EFFECT)
1103	const_iv (EVENT_CONNECTOR)
1104	const_iv (CLOSE_CON)
1105	const_iv (CONTAINER)
1106	const_iv (ARMOUR_IMPROVER)
1107	const_iv (WEAPON_IMPROVER)
1108	const_iv (SKILLSCROLL)
1109	const_iv (DEEP_SWAMP)
1110	const_iv (IDENTIFY_ALTAR)
1111	const_iv (MENU)
1112	const_iv (RUNE)
1113	const_iv (TRAP)
1114	const_iv (POWER_CRYSTAL)
1115	const_iv (CORPSE)
1116	const_iv (DISEASE)
1117	const_iv (SYMPTOM)
1118	const_iv (BUILDER)
1119	const_iv (MATERIAL)
1120	const_iv (ITEM_TRANSFORMER)
1121		1467
1122	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)
1123		1470
1124	const_iv (ST_BD_BUILD)	1471	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_LEVEL)
1125	const_iv (ST_BD_REMOVE)
1126		1472
1127	const_iv (ST_MAT_FLOOR)	1473	const_iv (F_APPLIED) const_iv (F_LOCATION) const_iv (F_UNPAID) const_iv (F_MAGIC)
1128	const_iv (ST_MAT_WALL)	1474	const_iv (F_CURSED) const_iv (F_DAMNED) const_iv (F_OPEN) const_iv (F_NOPICK)
1129	const_iv (ST_MAT_ITEM)
1130
1131	const_iv (AT_PHYSICAL)
1132	const_iv (AT_MAGIC)
1133	const_iv (AT_FIRE)
1134	const_iv (AT_ELECTRICITY)
1135	const_iv (AT_COLD)
1136	const_iv (AT_CONFUSION)
1137	const_iv (AT_ACID)
1138	const_iv (AT_DRAIN)
1139	const_iv (AT_WEAPONMAGIC)
1140	const_iv (AT_GHOSTHIT)
1141	const_iv (AT_POISON)
1142	const_iv (AT_SLOW)
1143	const_iv (AT_PARALYZE)
1144	const_iv (AT_TURN_UNDEAD)
1145	const_iv (AT_FEAR)
1146	const_iv (AT_CANCELLATION)
1147	const_iv (AT_DEPLETE)
1148	const_iv (AT_DEATH)
1149	const_iv (AT_CHAOS)
1150	const_iv (AT_COUNTERSPELL)
1151	const_iv (AT_GODPOWER)
1152	const_iv (AT_HOLYWORD)
1153	const_iv (AT_BLIND)
1154	const_iv (AT_INTERNAL)
1155	const_iv (AT_LIFE_STEALING)
1156	const_iv (AT_DISEASE)
1157
1158	const_iv (WEAP_HIT)
1159	const_iv (WEAP_SLASH)
1160	const_iv (WEAP_PIERCE)
1161	const_iv (WEAP_CLEAVE)
1162	const_iv (WEAP_SLICE)
1163	const_iv (WEAP_STAB)
1164	const_iv (WEAP_WHIP)
1165	const_iv (WEAP_CRUSH)
1166	const_iv (WEAP_BLUD)
1167
1168	const_iv (FLAG_ALIVE)
1169	const_iv (FLAG_WIZ)
1170	const_iv (FLAG_REMOVED)
1171	const_iv (FLAG_FREED)
1172	const_iv (FLAG_WAS_WIZ)
1173	const_iv (FLAG_APPLIED)
1174	const_iv (FLAG_UNPAID)
1175	const_iv (FLAG_USE_SHIELD)
1176	const_iv (FLAG_NO_PICK)
1177	const_iv (FLAG_ANIMATE)
1178	const_iv (FLAG_MONSTER)
1179	const_iv (FLAG_FRIENDLY)
1180	const_iv (FLAG_GENERATOR)
1181	const_iv (FLAG_IS_THROWN)
1182	const_iv (FLAG_AUTO_APPLY)
1183	const_iv (FLAG_PLAYER_SOLD)
1184	const_iv (FLAG_SEE_INVISIBLE)
1185	const_iv (FLAG_CAN_ROLL)
1186	const_iv (FLAG_OVERLAY_FLOOR)
1187	const_iv (FLAG_IS_TURNABLE)
1188	const_iv (FLAG_IS_USED_UP)
1189	const_iv (FLAG_IDENTIFIED)
1190	const_iv (FLAG_REFLECTING)
1191	const_iv (FLAG_CHANGING)
1192	const_iv (FLAG_SPLITTING)
1193	const_iv (FLAG_HITBACK)
1194	const_iv (FLAG_STARTEQUIP)
1195	const_iv (FLAG_BLOCKSVIEW)
1196	const_iv (FLAG_UNDEAD)
1197	const_iv (FLAG_SCARED)
1198	const_iv (FLAG_UNAGGRESSIVE)
1199	const_iv (FLAG_REFL_MISSILE)
1200	const_iv (FLAG_REFL_SPELL)
1201	const_iv (FLAG_NO_MAGIC)
1202	const_iv (FLAG_NO_FIX_PLAYER)
1203	const_iv (FLAG_IS_LIGHTABLE)
1204	const_iv (FLAG_TEAR_DOWN)
1205	const_iv (FLAG_RUN_AWAY)
1206	const_iv (FLAG_PICK_UP)
1207	const_iv (FLAG_UNIQUE)
1208	const_iv (FLAG_NO_DROP)
1209	const_iv (FLAG_WIZCAST)
1210	const_iv (FLAG_CAST_SPELL)
1211	const_iv (FLAG_USE_SCROLL)
1212	const_iv (FLAG_USE_RANGE)
1213	const_iv (FLAG_USE_BOW)
1214	const_iv (FLAG_USE_ARMOUR)
1215	const_iv (FLAG_USE_WEAPON)
1216	const_iv (FLAG_USE_RING)
1217	const_iv (FLAG_READY_RANGE)
1218	const_iv (FLAG_READY_BOW)
1219	const_iv (FLAG_XRAYS)
1220	const_iv (FLAG_NO_APPLY)
1221	const_iv (FLAG_IS_FLOOR)
1222	const_iv (FLAG_LIFESAVE)
1223	const_iv (FLAG_NO_STRENGTH)
1224	const_iv (FLAG_SLEEP)
1225	const_iv (FLAG_STAND_STILL)
1226	const_iv (FLAG_RANDOM_MOVE)
1227	const_iv (FLAG_ONLY_ATTACK)
1228	const_iv (FLAG_CONFUSED)
1229	const_iv (FLAG_STEALTH)
1230	const_iv (FLAG_WIZPASS)
1231	const_iv (FLAG_IS_LINKED)
1232	const_iv (FLAG_CURSED)
1233	const_iv (FLAG_DAMNED)
1234	const_iv (FLAG_SEE_ANYWHERE)
1235	const_iv (FLAG_KNOWN_MAGICAL)
1236	const_iv (FLAG_KNOWN_CURSED)
1237	const_iv (FLAG_CAN_USE_SKILL)
1238	const_iv (FLAG_BEEN_APPLIED)
1239	const_iv (FLAG_READY_SCROLL)
1240	const_iv (FLAG_USE_ROD)
1241	const_iv (FLAG_USE_HORN)
1242	const_iv (FLAG_MAKE_INVIS)
1243	const_iv (FLAG_INV_LOCKED)
1244	const_iv (FLAG_IS_WOODED)
1245	const_iv (FLAG_IS_HILLY)
1246	const_iv (FLAG_READY_SKILL)
1247	const_iv (FLAG_READY_WEAPON)
1248	const_iv (FLAG_NO_SKILL_IDENT)
1249	const_iv (FLAG_BLIND)
1250	const_iv (FLAG_SEE_IN_DARK)
1251	const_iv (FLAG_IS_CAULDRON)
1252	const_iv (FLAG_NO_STEAL)
1253	const_iv (FLAG_ONE_HIT)
1254	const_iv (FLAG_CLIENT_SENT)
1255	const_iv (FLAG_BERSERK)
1256	const_iv (FLAG_NEUTRAL)
1257	const_iv (FLAG_NO_ATTACK)
1258	const_iv (FLAG_NO_DAMAGE)
1259	const_iv (FLAG_OBJ_ORIGINAL)
1260	const_iv (FLAG_OBJ_SAVE_ON_OVL)
1261	const_iv (FLAG_ACTIVATE_ON_PUSH)
1262	const_iv (FLAG_ACTIVATE_ON_RELEASE)
1263	const_iv (FLAG_IS_WATER)
1264	const_iv (FLAG_CONTENT_ON_GEN)
1265	const_iv (FLAG_IS_A_TEMPLATE)
1266	const_iv (FLAG_IS_BUILDABLE)
1267
1268	const_iv (NDI_BLACK)
1269	const_iv (NDI_WHITE)
1270	const_iv (NDI_NAVY)
1271	const_iv (NDI_RED)
1272	const_iv (NDI_ORANGE)
1273	const_iv (NDI_BLUE)
1274	const_iv (NDI_DK_ORANGE)
1275	const_iv (NDI_GREEN)
1276	const_iv (NDI_LT_GREEN)
1277	const_iv (NDI_GREY)
1278	const_iv (NDI_BROWN)
1279	const_iv (NDI_GOLD)
1280	const_iv (NDI_TAN)
1281	const_iv (NDI_MAX_COLOR)
1282	const_iv (NDI_COLOR_MASK)
1283	const_iv (NDI_UNIQUE)
1284	const_iv (NDI_ALL)
1285
1286	const_iv (UPD_LOCATION)
1287	const_iv (UPD_FLAGS)
1288	const_iv (UPD_WEIGHT)
1289	const_iv (UPD_FACE)
1290	const_iv (UPD_NAME)
1291	const_iv (UPD_ANIM)
1292	const_iv (UPD_ANIMSPEED)
1293	const_iv (UPD_NROF)
1294
1295	const_iv (UPD_SP_MANA)
1296	const_iv (UPD_SP_GRACE)
1297	const_iv (UPD_SP_DAMAGE)
1298
1299	const_iv (F_APPLIED)
1300	const_iv (F_LOCATION)
1301	const_iv (F_UNPAID)
1302	const_iv (F_MAGIC)
1303	const_iv (F_CURSED)
1304	const_iv (F_DAMNED)
1305	const_iv (F_OPEN)
1306	const_iv (F_NOPICK)
1307	const_iv (F_LOCKED)	1475	const_iv (F_LOCKED)
1308		1476
1309	const_iv (F_BUY)	1477	const_iv (P_BLOCKSVIEW) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE)
1310	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)
1311	const_iv (F_SELL)
1312		1479
1313	const_iv (P_BLOCKSVIEW)	1480	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)
1314	const_iv (P_PLAYER)
1315	const_iv (P_NO_MAGIC)
1316	const_iv (P_IS_ALIVE)
1317	const_iv (P_NO_CLERIC)
1318	const_iv (P_OUT_OF_MAP)
1319	const_iv (P_NEW_MAP)
1320	const_iv (P_UPTODATE)
1321		1481
1322	const_iv (UP_OBJ_INSERT)	1482	const_iv (SK_EXP_ADD_SKILL) const_iv (SK_EXP_TOTAL) const_iv (SK_EXP_NONE)
1323	const_iv (UP_OBJ_REMOVE)	1483	const_iv (SK_SUBTRACT_SKILL_EXP) const_iv (SK_EXP_SKILL_ONLY)
1324	const_iv (UP_OBJ_CHANGE)
1325	const_iv (UP_OBJ_FACE)
1326		1484
1327	const_iv (INS_NO_MERGE)	1485	const_iv (MAP_ACTIVE) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)
1328	const_iv (INS_ABOVE_FLOOR_ONLY)
1329	const_iv (INS_NO_WALK_ON)
1330	const_iv (INS_ON_TOP)
1331	const_iv (INS_BELOW_ORIGINATOR)
1332	const_iv (INS_MAP_LOAD)
1333
1334	const_iv (WILL_APPLY_HANDLE)
1335	const_iv (WILL_APPLY_TREASURE)
1336	const_iv (WILL_APPLY_EARTHWALL)
1337	const_iv (WILL_APPLY_DOOR)
1338	const_iv (WILL_APPLY_FOOD)
1339
1340	const_iv (SAVE_MODE)
1341	const_iv (SAVE_DIR_MODE)
1342
1343	const_iv (M_PAPER)
1344	const_iv (M_IRON)
1345	const_iv (M_GLASS)
1346	const_iv (M_LEATHER)
1347	const_iv (M_WOOD)
1348	const_iv (M_ORGANIC)
1349	const_iv (M_STONE)
1350	const_iv (M_CLOTH)
1351	const_iv (M_ADAMANT)
1352	const_iv (M_LIQUID)
1353	const_iv (M_SOFT_METAL)
1354	const_iv (M_BONE)
1355	const_iv (M_ICE)	1486	const_iv (MAP_INACTIVE)
1356	const_iv (M_SPECIAL)
1357		1487
1358	const_iv (SK_EXP_ADD_SKILL)	1488	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)
1359	const_iv (SK_EXP_TOTAL)	1489	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)
1360	const_iv (SK_EXP_NONE)
1361	const_iv (SK_SUBTRACT_SKILL_EXP)
1362	const_iv (SK_EXP_SKILL_ONLY)
1363		1490
1364	const_iv (SK_LOCKPICKING)	1491	const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)
1365	const_iv (SK_HIDING)
1366	const_iv (SK_SMITHERY)
1367	const_iv (SK_BOWYER)
1368	const_iv (SK_JEWELER)
1369	const_iv (SK_ALCHEMY)
1370	const_iv (SK_STEALING)
1371	const_iv (SK_LITERACY)
1372	const_iv (SK_BARGAINING)
1373	const_iv (SK_JUMPING)
1374	const_iv (SK_DET_MAGIC)
1375	const_iv (SK_ORATORY)
1376	const_iv (SK_SINGING)
1377	const_iv (SK_DET_CURSE)
1378	const_iv (SK_FIND_TRAPS)
1379	const_iv (SK_MEDITATION)
1380	const_iv (SK_PUNCHING)
1381	const_iv (SK_FLAME_TOUCH)
1382	const_iv (SK_KARATE)
1383	const_iv (SK_CLIMBING)
1384	const_iv (SK_WOODSMAN)
1385	const_iv (SK_INSCRIPTION)
1386	const_iv (SK_ONE_HANDED_WEAPON)
1387	const_iv (SK_MISSILE_WEAPON)
1388	const_iv (SK_THROWING)
1389	const_iv (SK_USE_MAGIC_ITEM)
1390	const_iv (SK_DISARM_TRAPS)
1391	const_iv (SK_SET_TRAP)
1392	const_iv (SK_THAUMATURGY)
1393	const_iv (SK_PRAYING)
1394	const_iv (SK_CLAWING)
1395	const_iv (SK_LEVITATION)
1396	const_iv (SK_SUMMONING)
1397	const_iv (SK_PYROMANCY)
1398	const_iv (SK_EVOCATION)
1399	const_iv (SK_SORCERY)
1400	const_iv (SK_TWO_HANDED_WEAPON)
1401	const_iv (SK_SPARK_TOUCH)
1402	const_iv (SK_SHIVER)
1403	const_iv (SK_ACID_SPLASH)
1404	const_iv (SK_POISON_NAIL)
1405		1492
1406	const_iv (SOUND_NEW_PLAYER)	1493	const_iv (IO_HEADER) const_iv (IO_OBJECTS) const_iv (IO_UNIQUES)
1407	const_iv (SOUND_FIRE_ARROW)
1408	const_iv (SOUND_LEARN_SPELL)
1409	const_iv (SOUND_FUMBLE_SPELL)
1410	const_iv (SOUND_WAND_POOF)
1411	const_iv (SOUND_OPEN_DOOR)
1412	const_iv (SOUND_PUSH_PLAYER)
1413	const_iv (SOUND_PLAYER_HITS1)
1414	const_iv (SOUND_PLAYER_HITS2)
1415	const_iv (SOUND_PLAYER_HITS3)
1416	const_iv (SOUND_PLAYER_HITS4)
1417	const_iv (SOUND_PLAYER_IS_HIT1)
1418	const_iv (SOUND_PLAYER_IS_HIT2)
1419	const_iv (SOUND_PLAYER_IS_HIT3)
1420	const_iv (SOUND_PLAYER_KILLS)
1421	const_iv (SOUND_PET_IS_KILLED)
1422	const_iv (SOUND_PLAYER_DIES)
1423	const_iv (SOUND_OB_EVAPORATE)
1424	const_iv (SOUND_OB_EXPLODE)
1425	const_iv (SOUND_CLOCK)
1426	const_iv (SOUND_TURN_HANDLE)
1427	const_iv (SOUND_FALL_HOLE)
1428	const_iv (SOUND_DRINK_POISON)
1429	const_iv (SOUND_CAST_SPELL_0)
1430
1431	const_iv (PREFER_LOW)
1432	const_iv (PREFER_HIGH)
1433
1434	const_iv (ATNR_PHYSICAL)
1435	const_iv (ATNR_MAGIC)
1436	const_iv (ATNR_FIRE)
1437	const_iv (ATNR_ELECTRICITY)
1438	const_iv (ATNR_COLD)
1439	const_iv (ATNR_CONFUSION)
1440	const_iv (ATNR_ACID)
1441	const_iv (ATNR_DRAIN)
1442	const_iv (ATNR_WEAPONMAGIC)
1443	const_iv (ATNR_GHOSTHIT)
1444	const_iv (ATNR_POISON)
1445	const_iv (ATNR_SLOW)
1446	const_iv (ATNR_PARALYZE)
1447	const_iv (ATNR_TURN_UNDEAD)
1448	const_iv (ATNR_FEAR)
1449	const_iv (ATNR_CANCELLATION)
1450	const_iv (ATNR_DEPLETE)
1451	const_iv (ATNR_DEATH)
1452	const_iv (ATNR_CHAOS)
1453	const_iv (ATNR_COUNTERSPELL)
1454	const_iv (ATNR_GODPOWER)
1455	const_iv (ATNR_HOLYWORD)
1456	const_iv (ATNR_BLIND)
1457	const_iv (ATNR_INTERNAL)
1458	const_iv (ATNR_LIFE_STEALING)
1459	const_iv (ATNR_DISEASE)
1460
1461	const_iv (MAP_FLUSH)
1462	const_iv (MAP_PLAYER_UNIQUE)
1463	const_iv (MAP_BLOCK)
1464	const_iv (MAP_STYLE)
1465	const_iv (MAP_OVERLAY)
1466
1467	const_iv (MAP_IN_MEMORY)
1468	const_iv (MAP_SWAPPED)
1469	const_iv (MAP_LOADING)
1470	const_iv (MAP_SAVING)
1471
1472	const_iv (KLASS_ATTACHABLE)
1473	const_iv (KLASS_GLOBAL)
1474	const_iv (KLASS_OBJECT)
1475	const_iv (KLASS_CLIENT)
1476	const_iv (KLASS_PLAYER)
1477	const_iv (KLASS_MAP)
1478
1479	const_iv (CS_QUERY_YESNO)
1480	const_iv (CS_QUERY_SINGLECHAR)
1481	const_iv (CS_QUERY_HIDEINPUT)
1482
1483	const_iv (ST_DEAD)
1484	const_iv (ST_SETUP)
1485	const_iv (ST_PLAYING)
1486	const_iv (ST_CUSTOM)
1487
1488	const_iv (ST_CHANGE_CLASS)
1489
1490	const_iv (IO_HEADER)
1491	const_iv (IO_OBJECTS)
1492	const_iv (IO_UNIQUES)
1493
1494	// random map generator
1495	const_iv (LAYOUT_NONE)
1496	const_iv (LAYOUT_ONION)
1497	const_iv (LAYOUT_MAZE)
1498	const_iv (LAYOUT_SPIRAL)
1499	const_iv (LAYOUT_ROGUELIKE)
1500	const_iv (LAYOUT_SNAKE)
1501	const_iv (LAYOUT_SQUARE_SPIRAL)
1502
1503	const_iv (RMOPT_RANDOM)
1504	const_iv (RMOPT_CENTERED)
1505	const_iv (RMOPT_LINEAR)
1506	const_iv (RMOPT_BOTTOM_C)
1507	const_iv (RMOPT_BOTTOM_R)
1508	const_iv (RMOPT_IRR_SPACE)
1509	const_iv (RMOPT_WALL_OFF)
1510	const_iv (RMOPT_WALLS_ONLY)
1511	const_iv (RMOPT_NO_DOORS)
1512
1513	const_iv (SYMMETRY_RANDOM)
1514	const_iv (SYMMETRY_NONE)
1515	const_iv (SYMMETRY_X)
1516	const_iv (SYMMETRY_Y)
1517	const_iv (SYMMETRY_XY)
1518	};	1494	};
1519		1495
1520	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; )
1521	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));	1497	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1522		1498
1523	static const struct {	1499	static const struct {
1524	const char *name;	1500	const char *name;
1525	int skip;	1501	int skip;
…		…
1531	# undef def	1507	# undef def
1532	};	1508	};
1533		1509
1534	AV *av = get_av ("cf::EVENT", 1);	1510	AV *av = get_av ("cf::EVENT", 1);
1535		1511
1536	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; )
1537	{	1513	{
1538	AV *event = newAV ();	1514	AV *event = newAV ();
1539	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));	1515	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));
1540	av_push (event, newSViv (eiv->klass));	1516	av_push (event, newSViv (eiv->klass));
1541	av_store (av, eiv->iv, newRV_noinc ((SV *)event));	1517	av_store (av, eiv->iv, newRV_noinc ((SV *)event));
1542	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));	1518	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));
1543	}	1519	}
1544	}
1545		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
1546	void _connect_to_perl ()	1539	void _connect_to_perl_1 ()
1547		1540
		1541	void _connect_to_perl_2 ()
		1542
		1543	void _recalc_want ()
		1544
		1545	# not used by default anymore
1548	void _global_reattach ()	1546	void _global_reattach ()
1549	CODE:	1547	CODE:
1550	{	1548	{
1551	// reattach to all attachable objects in the game.	1549	// reattach to all attachable objects in the game.
1552	for_all_clients (ns)	1550	for_all_clients (ns)
1553	ns->reattach ();	1551	ns->reattach ();
1554		1552
1555	for_all_players (pl)
1556	pl->reattach ();
1557
1558	//TODO
1559	//for (map_container::iterator i = maps.begin (); i != maps.end (); ++i)
1560	// i->second->reattach ();
1561
1562	for_all_objects (op)	1553	for_all_objects (op)
1563	op->reattach ();	1554	op->reattach ();
1564	}	1555	}
1565		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
1566	NV floor (NV x)	1672	NV floor (NV x)
1567		1673
1568	NV ceil (NV x)	1674	NV ceil (NV x)
1569		1675
1570	void server_tick ()	1676	NV rndm (...)
		1677	ALIAS:
		1678	rmg_rndm = 1
1571	CODE:	1679	CODE:
1572	runtime = SvNVx (sv_runtime);	1680	{
1573	server_tick ();	1681	rand_gen &gen = ix ? rmg_rndm : rndm;
		1682	switch (items)
		1683	{
		1684	case 0: RETVAL = gen (); break;
		1685	case 1: RETVAL = gen (SvUV (ST (0))); break;
		1686	case 2: RETVAL = gen (SvIV (ST (0)), SvIV (ST (1))); break;
		1687	default: croak ("cf::rndm requires zero, one or two parameters."); break;
		1688	}
		1689	}
		1690	OUTPUT:
		1691	RETVAL
1574		1692
1575	void	1693	NV clamp (NV value, NV min_value, NV max_value)
1576	LOG (int level, char *msg)	1694	CODE:
		1695	RETVAL = clamp (value, min_value, max_value);
		1696	OUTPUT:
		1697	RETVAL
		1698
		1699	NV lerp (NV value, NV min_in, NV max_in, NV min_out, NV max_out)
		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)
1577	PROTOTYPE: $$	1720	PROTOTYPE: $$
1578	C_ARGS: (LogLevel)level, "%s", msg	1721	C_ARGS: flags, "%s", msg
1579		1722
1580	char path_combine (char base, char *path)	1723	octet_string path_combine (octet_string base, octet_string path)
1581	PROTOTYPE: $$	1724	PROTOTYPE: $$
1582		1725
1583	char path_combine_and_normalize (char base, char *path)	1726	octet_string path_combine_and_normalize (octet_string base, octet_string path)
1584	PROTOTYPE: $$	1727	PROTOTYPE: $$
1585		1728
1586	const char *
1587	get_maps_directory (char *path)
1588	PROTOTYPE: $
1589	ALIAS: maps_directory = 0
1590	CODE:
1591	RETVAL = create_pathname (path);
1592	OUTPUT: RETVAL
1593
1594	void	1729	void
1595	sub_generation_inc ()	1730	sub_generation_inc ()
1596	CODE:	1731	CODE:
1597	PL_sub_generation++;	1732	PL_sub_generation++;
1598		1733
1599	char *	1734	const_octet_string
1600	mapdir ()	1735	mapdir ()
1601	PROTOTYPE:	1736	PROTOTYPE:
1602	ALIAS:	1737	ALIAS:
1603	mapdir = 0	1738	mapdir = 0
1604	uniquedir = 1	1739	uniquedir = 1
…		…
1620	}	1755	}
1621	OUTPUT: RETVAL	1756	OUTPUT: RETVAL
1622		1757
1623	void abort ()	1758	void abort ()
1624		1759
		1760	void reset_signals ()
		1761
		1762	void fork_abort (const_octet_string cause = "cf::fork_abort")
		1763
		1764	void cleanup (const_octet_string cause, bool make_core = false)
		1765
1625	void emergency_save ()	1766	void emergency_save ()
1626		1767
1627	void _exit (int status = 0)	1768	void _exit (int status = EXIT_SUCCESS)
1628		1769
1629	#if _POSIX_MEMLOCK	1770	#if _POSIX_MEMLOCK
1630		1771
1631	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
1632		1780
1633	int munlockall ()	1781	int munlockall ()
1634		1782
1635	#endif	1783	#endif
1636		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
1637	int find_animation (char *text)	1814	int find_animation (utf8_string text)
1638	PROTOTYPE: $	1815	PROTOTYPE: $
1639		1816
1640	int random_roll (int min, int max, object *op, int goodbad);	1817	int random_roll (int min, int max, object *op, int goodbad);
1641		1818
1642	const char *cost_string_from_value(uint64 cost, int approx = 0)	1819	const_utf8_string cost_string_from_value(uint64 cost, int approx = 0)
1643		1820
1644	int
1645	exp_to_level (val64 exp)	1821	int exp_to_level (val64 exp)
1646	CODE:
1647	{
1648	int i = 0;
1649		1822
1650	RETVAL = settings.max_level;
1651
1652	for (i = 1; i <= settings.max_level; i++)
1653	{
1654	if (levels[i] > exp)
1655	{
1656	RETVAL = i - 1;
1657	break;
1658	}
1659	}
1660	}
1661	OUTPUT: RETVAL
1662
1663	val64
1664	level_to_min_exp (int level)	1823	val64 level_to_min_exp (int level)
1665	CODE:
1666	if (level > settings.max_level)
1667	RETVAL = levels[settings.max_level];
1668	else if (level < 1)
1669	RETVAL = 0;
1670	else
1671	RETVAL = levels[level];
1672	OUTPUT: RETVAL
1673		1824
1674	SV *	1825	SV *
1675	resistance_to_string (int atnr)	1826	resistance_to_string (int atnr)
1676	CODE:	1827	CODE:
1677	if (atnr >= 0 && atnr < NROFATTACKS)	1828	if (atnr >= 0 && atnr < NROFATTACKS)
1678	RETVAL = newSVpv (resist_plus[atnr], 0);	1829	RETVAL = newSVpv (resist_plus[atnr], 0);
1679	else	1830	else
1680	XSRETURN_UNDEF;	1831	XSRETURN_UNDEF;
1681	OUTPUT: RETVAL	1832	OUTPUT: RETVAL
1682		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
1683	MODULE = cf PACKAGE = cf::attachable	1882	MODULE = cf PACKAGE = cf::attachable
1684		1883
1685	int	1884	int
1686	valid (SV *obj)	1885	valid (SV *obj)
1687	CODE:	1886	CODE:
1688	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);	1887	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
1689	OUTPUT:	1888	OUTPUT:
1690	RETVAL	1889	RETVAL
1691		1890
1692	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 \|
1693		1914
1694	MODULE = cf PACKAGE = cf::global	1915	MODULE = cf PACKAGE = cf::global
1695		1916
1696	int invoke (SV *klass, int event, ...)	1917	int invoke (SV *klass, int event, ...)
1697	CODE:	1918	CODE:
…		…
1701	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);
1702	OUTPUT: RETVAL	1923	OUTPUT: RETVAL
1703		1924
1704	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_	1925	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
1705		1926
1706	INCLUDE: $PERL genacc object ../include/object.h \|	1927	INCLUDE: $PERL $srcdir/genacc object $srcdir/../include/object.h \|
1707		1928
1708	int invoke (object *op, int event, ...)	1929	int invoke (object *op, int event, ...)
1709	CODE:	1930	CODE:
1710	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");
1711	AV av = (AV )sv_2mortal ((SV *)newAV ());	1932	AV av = (AV )sv_2mortal ((SV *)newAV ());
…		…
1713	RETVAL = op->invoke ((event_type)event, ARG_AV (av), DT_END);	1934	RETVAL = op->invoke ((event_type)event, ARG_AV (av), DT_END);
1714	OUTPUT: RETVAL	1935	OUTPUT: RETVAL
1715		1936
1716	SV registry (object op)	1937	SV registry (object op)
1717		1938
1718	void mortals ()	1939	int objects_size ()
1719	PPCODE:	1940	CODE:
1720	EXTEND (SP, object::mortals.size ());
1721	for (AUTODECL (i, object::mortals.begin ()); i != object::mortals.end (); ++i)
1722	PUSHs (to_sv (*i));
1723
1724	object *first ()
1725	CODE:
1726	RETVAL = object::first;	1941	RETVAL = objects.size ();
1727	OUTPUT: RETVAL	1942	OUTPUT: RETVAL
		1943
		1944	object *objects (U32 index)
		1945	CODE:
		1946	RETVAL = index < objects.size () ? objects [index] : 0;
		1947	OUTPUT: RETVAL
		1948
		1949	int actives_size ()
		1950	CODE:
		1951	RETVAL = actives.size ();
		1952	OUTPUT: RETVAL
		1953
		1954	object *actives (U32 index)
		1955	CODE:
		1956	RETVAL = index < actives.size () ? actives [index] : 0;
		1957	OUTPUT: RETVAL
		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
1728		1980
1729	# missing properties	1981	# missing properties
1730		1982
1731	object head (object op)	1983	object head (object op)
1732	PROTOTYPE: $	1984	PROTOTYPE: $
1733	CODE:	1985	CODE:
1734	RETVAL = op->head ? op->head : op;
1735	OUTPUT: RETVAL
1736
1737	int is_head (object *op)
1738	PROTOTYPE: $
1739	CODE:
1740	RETVAL = !op->head;	1986	RETVAL = op->head_ ();
1741	OUTPUT: RETVAL	1987	OUTPUT: RETVAL
1742		1988
1743	void	1989	void
1744	inv (object *obj)	1990	inv (object *obj)
1745	PROTOTYPE: $	1991	PROTOTYPE: $
1746	PPCODE:	1992	PPCODE:
1747	{	1993	{
1748	object *o;
1749	for (o = obj->inv; o; o = o->below)	1994	for (object *o = obj->inv; o; o = o->below)
1750	XPUSHs (sv_2mortal (to_sv (o)));	1995	XPUSHs (sv_2mortal (to_sv (o)));
1751	}	1996	}
1752		1997
1753	void	1998	void
1754	set_animation (object *op, int idx)	1999	set_animation (object *op, int idx)
1755	CODE:	2000	CODE:
1756	SET_ANIMATION (op, idx);	2001	SET_ANIMATION (op, idx);
1757		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
1758	object find_best_object_match (object op, const char *match)	2028	object find_best_object_match (object op, utf8_string match)
1759
1760	object find_marked_object (object op)
1761
1762	int need_identify (object *obj);
1763		2029
1764	int apply_shop_mat (object shop_mat, object op);	2030	int apply_shop_mat (object shop_mat, object op);
1765		2031
1766	int move (object op, int dir, object originator = op)	2032	int move (object op, int dir, object originator = op)
1767	CODE:	2033	CODE:
1768	RETVAL = move_ob (op, dir, originator);	2034	RETVAL = op->move (dir, originator);
1769	OUTPUT:	2035	OUTPUT:
1770	RETVAL	2036	RETVAL
1771		2037
1772	void apply (object applier, object applied, int flags = 0)
1773	CODE:
1774	manual_apply (applied, applier, flags);
1775
1776	void apply_below (object *op)	2038	void apply_below (object *op)
1777	CODE:	2039	CODE:
1778	player_apply_below (op);	2040	player_apply_below (op);
1779		2041
1780	object cf_object_present_archname_inside (object op, char *whatstr)	2042	int cast_heal (object op, object caster, object *spell, int dir = 0)
1781		2043
1782	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)
1783
1784	int cf_object_change_map (object op, int x, int y, maptile map)
1785
1786	#//TODO
1787	object clone_ (object op, int recursive = 0)
1788	CODE:
1789	if (recursive)
1790	RETVAL = object_create_clone (op);
1791	else
1792	{
1793	RETVAL = object::create ();
1794	op->copy_to (RETVAL);
1795	}
1796	OUTPUT: RETVAL
1797		2045
1798	int pay_item (object op, object buyer)	2046	int pay_item (object op, object buyer)
1799	CODE:	2047	CODE:
1800	RETVAL = pay_for_item (op, buyer);	2048	RETVAL = pay_for_item (op, buyer);
1801	OUTPUT: RETVAL	2049	OUTPUT: RETVAL
…		…
1805	RETVAL = pay_for_amount (amount, op);	2053	RETVAL = pay_for_amount (amount, op);
1806	OUTPUT: RETVAL	2054	OUTPUT: RETVAL
1807		2055
1808	void pay_player (object *op, uint64 amount)	2056	void pay_player (object *op, uint64 amount)
1809		2057
1810	val64 pay_player_arch (object op, const char arch, uint64 amount)	2058	val64 pay_player_arch (object *op, utf8_string arch, uint64 amount)
1811		2059
1812	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)
1813		2061
1814	void learn_spell (object op, object sp, int special_prayer = 0)	2062	void learn_spell (object op, object sp, int special_prayer = 0)
1815	CODE:	2063	CODE:
1816	do_learn_spell (op, sp, special_prayer);	2064	do_learn_spell (op, sp, special_prayer);
1817		2065
1818	void forget_spell (object op, object sp)	2066	void forget_spell (object op, object sp)
1819	CODE:	2067	CODE:
1820	do_forget_spell (op, query_name (sp));	2068	do_forget_spell (op, query_name (sp));
1821		2069
1822	object check_for_spell (object op, char *spellname)	2070	object check_for_spell (object op, utf8_string spellname)
1823	CODE:	2071	CODE:
1824	RETVAL = check_spell_known (op, spellname);	2072	RETVAL = check_spell_known (op, spellname);
1825	OUTPUT: RETVAL	2073	OUTPUT: RETVAL
1826		2074
1827	int query_money (object *op)	2075	int query_money (object *op)
…		…
1836		2084
1837	void drop (object who, object op)	2085	void drop (object who, object op)
1838		2086
1839	void pick_up (object who, object op)	2087	void pick_up (object who, object op)
1840		2088
1841	object cf_object_insert_object (object op, object *container)
1842
1843	object cf_object_insert_in_ob (object ob, object *where)
1844
1845	int cf_object_teleport (object op, maptile map, int x, int y)
1846
1847	void update_object (object *op, int action)	2089	void update_object (object *op, int action)
1848		2090
1849	object cf_create_object_by_name (const char name)
1850
1851	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)
1852		2092
1853	void player_lvl_adj (object who, object skill = 0)	2093	void player_lvl_adj (object who, object skill = 0)
1854		2094
1855	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)
1856		2096
1857	int calc_skill_exp (object who, object op, object *skill);	2097	int calc_skill_exp (object who, object op, object *skill)
1858		2098
1859	void push_button (object *op);	2099	void push_button (object op, object originator)
1860		2100
1861	void use_trigger (object *op);	2101	void use_trigger (object op, object originator)
1862		2102
1863	void add_button_link (object button, maptile map, int connected);	2103	void handle_apply_yield (object *op)
1864		2104
1865	void remove_button_link (object *op);	2105	int convert_item (object item, object converter)
1866		2106
		2107	void fix_generated_item (object op, object creator, int difficulty, int max_magic, int flags);
1867		2108
1868	MODULE = cf PACKAGE = cf::object PREFIX = cf_	2109	MODULE = cf PACKAGE = cf::object PREFIX = cf_
1869
1870	object cf_insert_ob_in_ob (object ob, object *where)
1871		2110
1872	# 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
1873	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.	2112	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.
1874		2113
1875	object new (const char archetype = 0)	2114	object *new (utf8_string archetype = 0)
1876	PROTOTYPE: ;$	2115	PROTOTYPE: ;$
1877	CODE:	2116	CODE:
1878	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();	2117	RETVAL = archetype ? get_archetype (archetype) : object::create ();
1879	OUTPUT:	2118	OUTPUT:
1880	RETVAL	2119	RETVAL
1881		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
1882	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)
1883	PROTOTYPE: $$$$$$	2135	PROTOTYPE: $$$$$$
1884	CODE:	2136	CODE:
1885	{	2137	{
1886	int unused_type;	2138	RETVAL = insert_ob_in_map_at (ob, where, orig, flag, x, y);
1887	RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);
1888	}
1889		2139
1890	# syntatic sugar for easier use in event callbacks.	2140	if (RETVAL->destroyed ())
1891	const char options (object op)
1892	CODE:
1893	RETVAL = op->name;
1894	OUTPUT:
1895	RETVAL	2141	RETVAL = 0;
		2142	}
1896		2143
1897	player contr (object op)	2144	shstr
1898	CODE:	2145	object::kv_get (shstr key)
1899	RETVAL = op->contr;
1900	OUTPUT: RETVAL
1901		2146
1902	const char get_ob_key_value (object op, const char *key)	2147	void
		2148	object::kv_del (shstr key)
1903		2149
1904	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)
1905		2152
1906	object get_nearest_player (object ob)	2153	object get_nearest_player (object ob)
1907	ALIAS: nearest_player = 0	2154	ALIAS: nearest_player = 0
1908	PREINIT:	2155	PREINIT:
1909	extern object get_nearest_player (object );	2156	extern object get_nearest_player (object );
…		…
1911	void rangevector (object ob, object other, int flags = 0)	2158	void rangevector (object ob, object other, int flags = 0)
1912	PROTOTYPE: $$;$	2159	PROTOTYPE: $$;$
1913	PPCODE:	2160	PPCODE:
1914	{	2161	{
1915	rv_vector rv;	2162	rv_vector rv;
		2163
1916	get_rangevector (ob, other, &rv, flags);	2164	get_rangevector (ob, other, &rv, flags);
		2165
1917	EXTEND (SP, 5);	2166	EXTEND (SP, 5);
1918	PUSHs (newSVuv (rv.distance));	2167	PUSHs (sv_2mortal (newSVuv (rv.distance)));
1919	PUSHs (newSViv (rv.distance_x));	2168	PUSHs (sv_2mortal (newSViv (rv.distance_x)));
1920	PUSHs (newSViv (rv.distance_y));	2169	PUSHs (sv_2mortal (newSViv (rv.distance_y)));
1921	PUSHs (newSViv (rv.direction));	2170	PUSHs (sv_2mortal (newSViv (rv.direction)));
1922	PUSHs (newSVcfapi (CFAPI_POBJECT, rv.part));	2171	PUSHs (sv_2mortal (to_sv (rv.part)));
1923	}	2172	}
1924		2173
1925	bool on_same_map_as (object ob, object other)	2174	bool on_same_map_as (object ob, object other)
1926	CODE:	2175	CODE:
1927	RETVAL = on_same_map (ob, other);	2176	RETVAL = on_same_map (ob, other);
1928	OUTPUT: RETVAL	2177	OUTPUT: RETVAL
1929		2178
1930	const char *	2179	const_utf8_string
1931	base_name (object *op, int plural = op->nrof > 1)	2180	base_name (object *op, int plural = op->nrof > 1)
1932	CODE:	2181	CODE:
1933	RETVAL = query_base_name (op, plural);	2182	RETVAL = query_base_name (op, plural);
1934	OUTPUT: RETVAL	2183	OUTPUT: RETVAL
1935		2184
1936	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)));
1937		2191
1938	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_	2192	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_
1939		2193
1940	player player (object op)	2194	player player (object op)
1941	CODE:	2195	CODE:
1942	RETVAL = op->contr;	2196	RETVAL = op->contr;
1943	OUTPUT: RETVAL	2197	OUTPUT: RETVAL
1944		2198
1945	void check_score (object *op)	2199	bool move_player (object *op, int dir)
1946		2200
1947	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)
1948	CODE:	2202	CODE:
1949	new_draw_info (flags, 0, op, txt);	2203	new_draw_info (flags, 0, op, txt);
1950		2204
1951	object cf_player_send_inventory (object op)
1952
1953	char cf_player_get_ip (object op)
1954	ALIAS: ip = 0
1955
1956	object cf_player_get_marked_item (object op)
1957	ALIAS: marked_item = 0
1958
1959	void cf_player_set_marked_item (object op, object ob)
1960
1961	partylist cf_player_get_party (object op)
1962	ALIAS: party = 0
1963
1964	void cf_player_set_party (object op, partylist party)
1965
1966	void kill_player (object *op)	2205	void kill_player (object *op)
1967		2206
		2207	void esrv_send_item (object pl, object item)
		2208
1968	void esrv_update_item (object op, int what, object item)	2209	void esrv_update_item (object pl, int what, object item)
1969	C_ARGS: what, op, item	2210	C_ARGS: what, pl, item
1970		2211
1971	void clear_los (object *op)	2212	void esrv_del_item (object *pl, int tag)
		2213	C_ARGS: pl->contr, tag
1972		2214
1973	int command_teleport (object op, char params)
1974
1975	int command_summon (object op, char params)	2215	int command_summon (object *op, utf8_string params)
1976		2216
1977	int command_arrest (object op, char params)	2217	int command_arrest (object *op, utf8_string params)
1978
1979	int command_kick (object op, char params)
1980
1981	int command_banish (object op, char params)
1982		2218
1983		2219
1984	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_	2220	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
1985		2221
1986	INCLUDE: $PERL genacc player ../include/player.h \|	2222	INCLUDE: $PERL $srcdir/genacc player $srcdir/../include/player.h \|
1987		2223
1988	int invoke (player *pl, int event, ...)	2224	int invoke (player *pl, int event, ...)
1989	CODE:	2225	CODE:
1990	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");
1991	AV av = (AV )sv_2mortal ((SV *)newAV ());	2227	AV av = (AV )sv_2mortal ((SV *)newAV ());
…		…
2001	pl->ob->stats.hp = pl->ob->stats.maxhp;	2237	pl->ob->stats.hp = pl->ob->stats.maxhp;
2002	pl->ob->stats.sp = pl->ob->stats.maxsp;	2238	pl->ob->stats.sp = pl->ob->stats.maxsp;
2003	pl->ob->stats.grace = pl->ob->stats.maxgrace;	2239	pl->ob->stats.grace = pl->ob->stats.maxgrace;
2004	pl->orig_stats = pl->ob->stats;	2240	pl->orig_stats = pl->ob->stats;
2005		2241
2006	void cf_player_move (player *pl, int dir)	2242	# should only be temporary
		2243	void esrv_new_player (player *pl)
2007		2244
2008	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
2009
2010	player *first ()
2011	CODE:
2012	RETVAL = first_player;
2013	OUTPUT: RETVAL
2014
2015	bool	2246	bool
2016	cell_visible (player *pl, int dx, int dy)	2247	cell_visible (player *pl, int dx, int dy)
2017	CODE:	2248	CODE:
2018	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2	2249	RETVAL = pl->blocked_los (dx, dy) != LOS_BLOCKED;
2019	&& !pl->blocked_los [dx + pl->ns->mapx / 2][dy + pl->ns->mapy / 2];
2020	OUTPUT:	2250	OUTPUT:
2021	RETVAL	2251	RETVAL
2022		2252
2023	void	2253	void
2024	send (player pl, SV packet)	2254	send (player pl, SV packet)
2025	CODE:	2255	CODE:
2026	{	2256	{
2027	STRLEN len;	2257	STRLEN len;
2028	char *buf = SvPVbyte (packet, len);	2258	char *buf = SvPVbyte (packet, len);
2029		2259
		2260	if (len > MAXSOCKBUF)
		2261	pl->failmsg ("[packet too long for client]");
2030	if (pl->ns)	2262	else if (pl->ns)
2031	pl->ns->send_packet (buf, len);	2263	pl->ns->send_packet (buf, len);
2032	}	2264	}
2033
2034	int
2035	listening (player *pl, int new_value = -1)
2036	CODE:
2037	RETVAL = pl->listening;
2038	if (new_value >= 0)
2039	pl->listening = new_value;
2040	OUTPUT:
2041	RETVAL
2042		2265
2043	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)
2044	PROTOTYPE: $;$$$	2267	PROTOTYPE: $;$$$
2045	PPCODE:	2268	PPCODE:
2046	if (GIMME_V != G_VOID)	2269	if (GIMME_V != G_VOID)
…		…
2071	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);	2294	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);
2072	OUTPUT: RETVAL	2295	OUTPUT: RETVAL
2073		2296
2074	SV registry (maptile map)	2297	SV registry (maptile map)
2075		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
2076	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
2077		2339
2078	void	2340	void
2079	maptile::instantiate ()	2341	maptile::instantiate ()
2080		2342
2081	maptile *new ()	2343	maptile *new ()
…		…
2096	for_all_players (pl)	2358	for_all_players (pl)
2097	if (pl->ob && pl->ob->map == THIS)	2359	if (pl->ob && pl->ob->map == THIS)
2098	PUSHs (sv_2mortal (to_sv (pl->ob)));	2360	PUSHs (sv_2mortal (to_sv (pl->ob)));
2099	}	2361	}
2100		2362
2101	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	}
2102		2455
2103	int out_of_map (maptile *map, int x, int y)	2456	int out_of_map (maptile *map, int x, int y)
2104		2457
2105	void	2458	void
2106	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: $$$;$
2107	CODE:	2482	CODE:
2108	activate_connection (map, connection, state);
2109
2110	void
2111	get_connection (maptile *map, long connection)
2112	PPCODE:
2113	oblinkpt *obp = get_connection_links (map, connection);
2114	if (obp)
2115	for (objectlink *ol = obp->link; ol; ol = ol->next)
2116	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, (object *)ol->ob)));
2117
2118	object cf_map_insert_object_there (maptile where, object op, object originator, int flags)
2119
2120	object cf_map_insert_object (maptile where, object* op, int x, int y)
2121
2122	object* cf_map_present_arch_by_name (maptile map, const char str, int nx, int ny)
2123	C_ARGS: str, map, nx, ny
2124
2125	void
2126	cf_map_normalise (maptile *map, int x, int y)
2127	PPCODE:
2128	{	2483	{
2129	maptile *nmap = 0;	2484	mapxy pos (map, x, y);
2130	I16 nx = 0, ny = 0;	2485	if (!pos.move (dir).normalise ())
2131	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);	2486	XSRETURN_UNDEF;
2132		2487
2133	EXTEND (SP, 4);	2488	RETVAL = &*pos;
2134	PUSHs (sv_2mortal (newSViv (flags)));
2135
2136	if (GIMME_V == G_ARRAY)
2137	{
2138	PUSHs (sv_2mortal (newSVcfapi (CFAPI_PMAP, nmap)));
2139	PUSHs (sv_2mortal (newSViv (nx)));
2140	PUSHs (sv_2mortal (newSViv (ny)));
2141	}
2142	}	2489	}
		2490	OUTPUT:
		2491	RETVAL
2143		2492
2144	void	2493	void
2145	at (maptile *map, unsigned int x, unsigned int y)	2494	at (maptile *map, unsigned int x, unsigned int y, int dir = 0)
2146	PROTOTYPE: $$$	2495	PROTOTYPE: $$$;$
2147	PPCODE:	2496	PPCODE:
2148	{	2497	mapxy pos (map, x, y);
2149	object *o;	2498	if (pos.move (dir).normalise ())
2150	maptile *nmap = 0;	2499	for (object *o = pos->bot; o; o = o->above)
2151	I16 nx, ny;	2500	XPUSHs (sv_2mortal (to_sv (o)));
2152
2153	get_map_flags (map, &nmap, x, y, &nx, &ny);
2154
2155	if (nmap)
2156	for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)
2157	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));
2158	}
2159		2501
2160	SV *	2502	SV *
2161	bot_at (maptile *obj, unsigned int x, unsigned int y)	2503	bot_at (maptile *map, unsigned int x, unsigned int y, int dir = 0)
2162	PROTOTYPE: $$$	2504	PROTOTYPE: $$$;$
2163	ALIAS:	2505	ALIAS:
2164	top_at = 1	2506	top_at = 1
2165	flags_at = 2	2507	flags_at = 2
2166	light_at = 3	2508	light_at = 3
2167	move_block_at = 4	2509	move_block_at = 4
2168	move_slow_at = 5	2510	move_slow_at = 5
2169	move_on_at = 6	2511	move_on_at = 6
2170	move_off_at = 7	2512	move_off_at = 7
2171	INIT:
2172	if (x >= obj->width \|\| y >= obj->height) XSRETURN_UNDEF;
2173	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
2174	switch (ix)	2523	switch (ix)
2175	{	2524	{
2176	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;	2525	case 0: RETVAL = to_sv (ms.bot ); break;
2177	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;	2526	case 1: RETVAL = to_sv (ms.top ); break;
2178	case 2: RETVAL = newSVuv ( GET_MAP_FLAGS (obj, x, y)); break;	2527	case 2: RETVAL = newSVuv (ms.flags_ ); break;
2179	case 3: RETVAL = newSViv ( GET_MAP_LIGHT (obj, x, y)); break;	2528	case 3: RETVAL = newSViv (ms.light ); break;
2180	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;	2529	case 4: RETVAL = newSVuv (ms.move_block); break;
2181	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;	2530	case 5: RETVAL = newSVuv (ms.move_slow ); break;
2182	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;	2531	case 6: RETVAL = newSVuv (ms.move_on ); break;
2183	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;	2532	case 7: RETVAL = newSVuv (ms.move_off ); break;
2184	}	2533	}
		2534	}
2185	OUTPUT: RETVAL	2535	OUTPUT: RETVAL
2186		2536
2187	void fix_walls (maptile *map, int x, int y)
2188
2189	void fix_walls_around (maptile *map, int x, int y)
2190
2191	const char *
2192	region_name (maptile *m)
2193	CODE:
2194	RETVAL = get_name_of_region_for_map (m);
2195	OUTPUT: RETVAL
2196
2197	# worst xs function of my life	2537	# worst xs function of my life
2198	maptile *	2538	bool
2199	_create_random_map (\	2539	_create_random_map (\
2200	char *path,\	2540	maptile *self,\
2201	char *wallstyle,\	2541	utf8_string wallstyle,\
2202	char *wall_name,\	2542	utf8_string wall_name,\
2203	char *floorstyle,\	2543	utf8_string floorstyle,\
2204	char *monsterstyle,\	2544	utf8_string monsterstyle,\
2205	char *treasurestyle,\	2545	utf8_string treasurestyle,\
2206	char *layoutstyle,\	2546	utf8_string layoutstyle,\
2207	char *doorstyle,\	2547	utf8_string doorstyle,\
2208	char *decorstyle,\	2548	utf8_string decorstyle,\
2209	char *origin_map,\	2549	utf8_string miningstyle,\
2210	char *final_map,\	2550	utf8_string origin_map,\
2211	char *exitstyle,\	2551	utf8_string final_map,\
2212	char *this_map,\	2552	utf8_string exitstyle,\
2213	char *exit_on_final_map,\	2553	utf8_string this_map,\
		2554	utf8_string exit_on_final_map,\
2214	int Xsize,\	2555	int xsize,\
2215	int Ysize,\	2556	int ysize,\
2216	int expand2x,\	2557	int expand2x,\
2217	int layoutoptions1,\	2558	int layoutoptions1,\
2218	int layoutoptions2,\	2559	int layoutoptions2,\
2219	int layoutoptions3,\	2560	int layoutoptions3,\
2220	int symmetry,\	2561	int symmetry,\
…		…
2225	int dungeon_depth,\	2566	int dungeon_depth,\
2226	int decoroptions,\	2567	int decoroptions,\
2227	int orientation,\	2568	int orientation,\
2228	int origin_y,\	2569	int origin_y,\
2229	int origin_x,\	2570	int origin_x,\
2230	int random_seed,\	2571	U32 random_seed,\
2231	val64 total_map_hp,\	2572	val64 total_map_hp,\
2232	int map_layout_style,\	2573	int map_layout_style,\
2233	int treasureoptions,\	2574	int treasureoptions,\
2234	int symmetry_used,\	2575	int symmetry_used,\
2235	region *region\	2576	region *region,\
		2577	utf8_string custom\
2236	)	2578	)
2237	CODE:	2579	CODE:
2238	{	2580	{
2239	random_map_params rmp;	2581	random_map_params rmp;
2240		2582
…		…
2244	assign (rmp.monsterstyle , monsterstyle);	2586	assign (rmp.monsterstyle , monsterstyle);
2245	assign (rmp.treasurestyle , treasurestyle);	2587	assign (rmp.treasurestyle , treasurestyle);
2246	assign (rmp.layoutstyle , layoutstyle);	2588	assign (rmp.layoutstyle , layoutstyle);
2247	assign (rmp.doorstyle , doorstyle);	2589	assign (rmp.doorstyle , doorstyle);
2248	assign (rmp.decorstyle , decorstyle);	2590	assign (rmp.decorstyle , decorstyle);
		2591	assign (rmp.miningstyle , miningstyle);
2249	assign (rmp.exitstyle , exitstyle);	2592	assign (rmp.exitstyle , exitstyle);
2250	assign (rmp.exit_on_final_map, exit_on_final_map);	2593	assign (rmp.exit_on_final_map, exit_on_final_map);
2251		2594
2252	rmp.origin_map = origin_map;	2595	rmp.origin_map = origin_map;
2253	rmp.final_map = final_map;	2596	rmp.final_map = final_map;
2254	rmp.this_map = this_map;	2597	rmp.this_map = this_map;
2255	rmp.Xsize = Xsize;	2598	rmp.xsize = xsize;
2256	rmp.Ysize = Ysize;	2599	rmp.ysize = ysize;
2257	rmp.expand2x = expand2x;	2600	rmp.expand2x = expand2x;
2258	rmp.layoutoptions1 = layoutoptions1;	2601	rmp.layoutoptions1 = layoutoptions1;
2259	rmp.layoutoptions2 = layoutoptions2;	2602	rmp.layoutoptions2 = layoutoptions2;
2260	rmp.layoutoptions3 = layoutoptions3;	2603	rmp.layoutoptions3 = layoutoptions3;
2261	rmp.symmetry = symmetry;	2604	rmp.symmetry = symmetry;
…		…
2267	rmp.decoroptions = decoroptions;	2610	rmp.decoroptions = decoroptions;
2268	rmp.orientation = orientation;	2611	rmp.orientation = orientation;
2269	rmp.origin_y = origin_y;	2612	rmp.origin_y = origin_y;
2270	rmp.origin_x = origin_x;	2613	rmp.origin_x = origin_x;
2271	rmp.random_seed = random_seed;	2614	rmp.random_seed = random_seed;
2272	rmp.total_map_hp = total_map_hp;	2615	rmp.total_map_hp = (uint64_t) total_map_hp;
2273	rmp.map_layout_style = map_layout_style;	2616	rmp.map_layout_style = map_layout_style;
2274	rmp.treasureoptions = treasureoptions;	2617	rmp.treasureoptions = treasureoptions;
2275	rmp.symmetry_used = symmetry_used;	2618	rmp.symmetry_used = symmetry_used;
2276	rmp.region = region;	2619	rmp.region = region;
		2620	rmp.custom = custom;
2277		2621
2278	RETVAL = generate_random_map (path, &rmp);	2622	RETVAL = self->generate_random_map (&rmp);
2279	}	2623	}
2280	OUTPUT:	2624	OUTPUT:
2281	RETVAL	2625	RETVAL
2282		2626
		2627	MODULE = cf PACKAGE = cf::mapspace
		2628
		2629	INCLUDE: $PERL $srcdir/genacc mapspace $srcdir/../include/map.h \|
		2630
2283	MODULE = cf PACKAGE = cf::arch	2631	MODULE = cf PACKAGE = cf::arch
2284		2632
2285	archetype find (const char name)	2633	int archetypes_size ()
2286	CODE:	2634	CODE:
2287	RETVAL = archetype::find (name);	2635	RETVAL = archetypes.size ();
2288	OUTPUT:
2289	RETVAL
2290
2291	archetype *first()
2292	PROTOTYPE:
2293	CODE:
2294	RETVAL = first_archetype;
2295	OUTPUT: RETVAL	2636	OUTPUT: RETVAL
2296		2637
		2638	archetype *archetypes (U32 index)
		2639	CODE:
		2640	RETVAL = index < archetypes.size () ? archetypes [index] : 0;
		2641	OUTPUT: RETVAL
		2642
2297	INCLUDE: $PERL genacc archetype ../include/object.h \|	2643	INCLUDE: $PERL $srcdir/genacc archetype $srcdir/../include/object.h \|
2298		2644
2299	MODULE = cf PACKAGE = cf::party	2645	MODULE = cf PACKAGE = cf::party
2300		2646
2301	partylist *first ()	2647	partylist *first ()
2302	PROTOTYPE:	2648	PROTOTYPE:
2303	CODE:	2649	CODE:
2304	RETVAL = get_firstparty ();	2650	RETVAL = get_firstparty ();
2305	OUTPUT: RETVAL	2651	OUTPUT: RETVAL
2306		2652
2307	INCLUDE: $PERL genacc partylist ../include/player.h \|	2653	INCLUDE: $PERL $srcdir/genacc partylist $srcdir/../include/player.h \|
2308		2654
2309	MODULE = cf PACKAGE = cf::region	2655	MODULE = cf PACKAGE = cf::region
2310		2656
2311	region *first ()	2657	void
2312	PROTOTYPE:	2658	list ()
2313	CODE:	2659	PPCODE:
2314	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++;
2315	OUTPUT: RETVAL	2668	OUTPUT: RETVAL
2316		2669
2317	region find (char name)
2318	PROTOTYPE: $
2319	CODE:
2320	RETVAL = get_region_by_name (name);
2321	OUTPUT: RETVAL
2322
2323	INCLUDE: $PERL genacc region ../include/map.h \|	2670	INCLUDE: $PERL $srcdir/genacc region $srcdir/../include/region.h \|
2324		2671
2325	MODULE = cf PACKAGE = cf::living	2672	MODULE = cf PACKAGE = cf::living
2326		2673
2327	INCLUDE: $PERL genacc living ../include/living.h \|	2674	INCLUDE: $PERL $srcdir/genacc living $srcdir/../include/living.h \|
2328		2675
2329	MODULE = cf PACKAGE = cf::settings	2676	MODULE = cf PACKAGE = cf::settings
2330		2677
2331	INCLUDE: $PERL genacc Settings ../include/global.h \|	2678	INCLUDE: $PERL $srcdir/genacc Settings $srcdir/../include/global.h \|
2332		2679
2333	MODULE = cf PACKAGE = cf::client	2680	MODULE = cf PACKAGE = cf::client
2334		2681
2335	INCLUDE: $PERL genacc client ../include/client.h \|	2682	INCLUDE: $PERL $srcdir/genacc client $srcdir/../include/client.h \|
2336		2683
2337	int invoke (client *ns, int event, ...)	2684	int invoke (client *ns, int event, ...)
2338	CODE:	2685	CODE:
2339	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");
2340	AV av = (AV )sv_2mortal ((SV *)newAV ());	2687	AV av = (AV )sv_2mortal ((SV *)newAV ());
…		…
2356	CODE:	2703	CODE:
2357	{	2704	{
2358	STRLEN len;	2705	STRLEN len;
2359	char *buf = SvPVbyte (packet, len);	2706	char *buf = SvPVbyte (packet, len);
2360		2707
		2708	if (len > MAXSOCKBUF)
		2709	{
		2710	// ugly
		2711	if (THIS->pl)
		2712	THIS->pl->failmsg ("[packet too long for client]");
		2713	}
		2714	else
2361	THIS->send_packet (buf, len);	2715	THIS->send_packet (buf, len);
2362	}	2716	}
2363		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.132 by root, Mon Jan 8 20:59:15 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.132 by root, Mon Jan 8 20:59:15 2007 UTC vs.
Revision 1.384 by root, Fri Apr 30 21:00:40 2010 UTC