ViewVC Help

View File | Revision Log | Show Annotations | Download File

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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.110 by root, Mon Dec 25 14:43:23 2006 UTC vs.
Revision 1.194 by root, Mon Apr 23 18:09:57 2007 UTC

…		…
4		4
5	/*	5	/*
6	* This code is placed under the GNU General Public Licence (GPL)	6	* This code is placed under the GNU General Public Licence (GPL)
7	*	7	*
8	* Copyright (C) 2001-2005 by Chachkoff Yann	8	* Copyright (C) 2001-2005 by Chachkoff Yann
9	* Copyright (C) 2006 by Marc Lehmann <cf@schmorp.de>	9	* Copyright (C) 2006,2007 by Marc Lehmann <cf@schmorp.de>
10	*	10	*
11	* This program is free software; you can redistribute it and/or modify	11	* This program is free software; you can redistribute it and/or modify
12	* it under the terms of the GNU General Public License as published by	12	* it under the terms of the GNU General Public License as published by
13	* the Free Software Foundation; either version 2 of the License, or	13	* the Free Software Foundation; either version 2 of the License, or
14	* (at your option) any later version.	14	* (at your option) any later version.
…		…
24	*/	24	*/
25		25
26	#define PLUGIN_NAME "perl"	26	#define PLUGIN_NAME "perl"
27	#define PLUGIN_VERSION "cfperl 0.5"	27	#define PLUGIN_VERSION "cfperl 0.5"
28		28
		29	#define CEDES_PER_TICK 5
		30
29	#include <plugin_common.h>	31	#include <plugin_common.h>
30	#include <sounds.h>	32	#include <sounds.h>
31	#include <cstdarg>	33	#include <cstdarg>
32	#include <sproto.h>	34	#include <sproto.h>
33		35
		36	#include "loader.h"
34	#include "cfperl.h"	37	#include "cfperl.h"
35	#include "shstr.h"	38	#include "shstr.h"
		39
		40	#include <unistd.h>
		41	#if _POSIX_MEMLOCK
		42	# include <sys/mman.h>
		43	#endif
36		44
37	#include <EXTERN.h>	45	#include <EXTERN.h>
38	#include <perl.h>	46	#include <perl.h>
39	#include <XSUB.h>	47	#include <XSUB.h>
40		48
…		…
43		51
44	extern sint64 *levels; // the experience table	52	extern sint64 *levels; // the experience table
45		53
46	typedef object object_ornull;	54	typedef object object_ornull;
47	typedef maptile maptile_ornull;	55	typedef maptile maptile_ornull;
		56
		57	typedef char *octet_string;
		58	typedef char *utf8_string;
		59	typedef const char *const_octet_string;
		60	typedef const char *const_utf8_string;
		61
		62	typedef std::string std__string;
48		63
49	#if IVSIZE >= 8	64	#if IVSIZE >= 8
50	typedef IV val64;	65	typedef IV val64;
51	# define newSVval64 newSViv	66	# define newSVval64 newSViv
52	# define SvVAL64 SvIV	67	# define SvVAL64 SvIV
…		…
60	static f_plug_api object_set_property = cfapi_object_set_property;	75	static f_plug_api object_set_property = cfapi_object_set_property;
61	static f_plug_api object_insert = cfapi_object_insert;	76	static f_plug_api object_insert = cfapi_object_insert;
62		77
63	static PerlInterpreter *perl;	78	static PerlInterpreter *perl;
64		79
		80	double runtime;
		81
65	global gbl_ev;	82	global gbl_ev;
66	static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map;	83	static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map;
		84	static SV *sv_runtime, *sv_next_tick;
67		85
68	static HV	86	static HV
69	*stash_cf,	87	*stash_cf,
70	*stash_cf_object_wrap,	88	*stash_cf_object_wrap,
71	*stash_cf_object_player_wrap,	89	*stash_cf_object_player_wrap,
…		…
91		109
92	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	110	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
93		111
94	unordered_vector<attachable *> attachable::mortals;	112	unordered_vector<attachable *> attachable::mortals;
95		113
96	#if 0
97	attachable *attachable::rc_first;
98
99	attachable::attachable ()
100	{
101	refcnt = 0;
102	rc_next = rc_first;
103	rc_first = this;
104	}
105	#endif
106
107	attachable::~attachable ()	114	attachable::~attachable ()
108	{	115	{
109	assert (!(flags & F_BORROWED));//D//TODO//remove when stable	116	flags |=0x3300;//D
110	#if 0
111	assert (!rc_next);
112	assert (!refcnt);	117	assert (!self);
113	#endif	118	assert (!cb);
		119	}
		120
		121	int
		122	attachable::refcnt_cnt () const
		123	{
		124	return refcnt + (self ? SvREFCNT (self) - 1 : 0);
		125	}
		126
		127	void
		128	attachable::sever_self ()
		129	{
		130	if (HV *self = this->self)
		131	{
		132	// keep a refcount because sv_unmagic might call attachable_free,
		133	// which might clear self, causing sv_unmagic to crash on a now
		134	// invalid object.
		135	SvREFCNT_inc (self);
		136	hv_clear (self);
		137	sv_unmagic ((SV *)self, PERL_MAGIC_ext);
		138	SvREFCNT_dec (self);
		139
		140	// self *must* be null now because thats sv_unmagic's job.
		141	assert (!this->self);
		142	flags |= 0x80; // severed //D
		143	}
		144	}
		145
		146	void
		147	attachable::optimise ()
		148	{
		149	if (self
		150	&& SvREFCNT (self) == 1
		151	&& !HvTOTALKEYS (self))
		152	flags |= 0x40,//D
		153	sever_self ();
114	}	154	}
115		155
116	// check wether the object really is dead	156	// check wether the object really is dead
117	void	157	void
118	attachable::do_check ()	158	attachable::do_check ()
119	{	159	{
120	if (refcnt > 0)	160	if (refcnt_cnt () > 0)
121	return;	161	return;
122		162
123	// try to unborrow the refcnt from perl	163	destroy ();
124	if (flags & F_BORROWED)	164	}
		165
		166	void
		167	attachable::do_destroy ()
		168	{
		169	invoke (EVENT_ATTACHABLE_DESTROY, DT_END);
		170
		171	if (cb)
125	{	172	{
126	assert (self);//D//TODO//remove when stable	173	SvREFCNT_dec (cb);
127	flags &= ~F_BORROWED;	174	cb = 0;
128	refcnt_inc ();	175	}
		176
		177	if (self)
		178	sever_self ();
		179
		180	flags |= 0x20; //D
		181	mortals.push_back (this);
		182	}
		183
		184	void
		185	attachable::destroy ()
		186	{
		187	if (destroyed ())
		188	return;
		189
		190	flags |= F_DESTROYED;
		191	do_destroy ();
		192	}
		193
		194	void
		195	attachable::check_mortals ()
		196	{
		197	static int i = 0;
		198
		199	for (;;)
		200	{
		201	if (i >= mortals.size ())
		202	{
		203	i = 0;
		204
		205	if (mortals.size () > 1000)
		206	fprintf (stderr, "mortal queue size (%d) exceeds 1000.\n", (int)mortals.size ());
		207
		208	break;
		209	}
		210
		211	attachable *obj = mortals [i];
		212
		213	obj->refcnt_chk (); // unborrow from perl, if necessary
		214
		215	//if (obj->refcnt > 0 || obj->self)
		216	if (obj->refcnt || obj->self)
		217	{
		218	//printf ("%p rc %d\n", obj, obj->refcnt_cnt ());//D
		219	++i; // further delay freeing
		220
		221	if (!(i & 0x3ff))
		222	break;
		223	}
		224	else
		225	{
		226	mortals.erase (i);
		227	delete obj;
		228	}
		229	}
		230	}
		231
		232	attachable &
		233	attachable::operator =(const attachable &src)
		234	{
		235	//if (self || cb)
		236	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));
		237
		238	attach = src.attach;
		239	return *this;
		240	}
		241
		242	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		243
		244	static SV *
		245	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())
		246	{
		247	SV *sv;
		248
		249	if (!ptr)
		250	return &PL_sv_undef;
		251
		252	sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);
		253	return sv_bless (newRV_noinc ((SV *)hv), stash);
		254	}
		255
		256	static int
		257	attachable_free (pTHX_ SV *sv, MAGIC *mg)
		258	{
		259	attachable *at = (attachable *)mg->mg_ptr;
		260
		261	//TODO: check if transaction behaviour is really required here
		262	if (SV *self = (SV *)at->self)
		263	{
		264	at->self = 0;
129	SvREFCNT_dec (self);	265	SvREFCNT_dec (self);
130	}	266	}
131		267
132	if (refcnt > 0 || self)	268	// next line makes sense, but most objects still have refcnt 0 by default
		269	//at->refcnt_chk ();
133	return;	270	return 0;
134
135	destroy ();
136	}	271	}
137		272
138	void	273	MGVTBL attachable::vtbl = {0, 0, 0, 0, attachable_free};
139	attachable::do_destroy ()
140	{
141	invoke (EVENT_ATTACHABLE_DESTROY, DT_END);
142
143	//TODO: call generic destroy callback
144	mortals.push_back (this);
145	}
146
147	void
148	attachable::destroy ()
149	{
150	if (destroyed ())
151	return;
152
153	flags |= F_DESTROYED;
154	do_destroy ();
155	}
156
157	void attachable::check_mortals ()
158	{
159	for (int i = 0; i < mortals.size (); )
160	{
161	attachable *obj = mortals [i];
162
163	obj->refcnt_chk (); // unborrow from perl, if necessary
164
165	if (obj->refcnt || obj->self)
166	{
167	#if 0
168	if (mortals.size() > 5)fprintf (stderr, "%d delaying %d:%p:%s %d (self %p:%d)\n", time(0),i, obj, typeid (*obj).name (),
169	obj->refcnt, obj->self, obj->self ? SvREFCNT(obj->self): - 1);//D
170	#endif
171
172	++i; // further delay freeing
173	}//D
174	else
175	{
176	//Dfprintf (stderr, "deleteing %d:%p:%s\n", i, obj,typeid (*obj).name ());//D
177	delete obj;
178	mortals.erase (i);
179	}
180	}
181	}
182
183	attachable &
184	attachable::operator =(const attachable &src)
185	{
186	//if (self || cb)
187	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));
188
189	attach = src.attach;
190	return *this;
191	}
192
193	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
194		274
195	static SV *	275	static SV *
196	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())
197	{
198	SV *sv;
199
200	if (!ptr)
201	return &PL_sv_undef;
202
203	sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);
204	return sv_bless (newRV_noinc ((SV *)hv), stash);
205	}
206
207	static int
208	attachable_free (pTHX_ SV *sv, MAGIC *mg)
209	{
210	attachable *at = (attachable *)mg->mg_ptr;
211	assert (!(at->flags & attachable::F_BORROWED));//D//TODO//remove when stable
212	at->self = 0;
213	at->refcnt_chk ();
214	return 0;
215	}
216
217	static MGVTBL vtbl_attachable = {0, 0, 0, 0, attachable_free};
218
219	SV *
220	newSVattachable (attachable *obj, HV *stash)	276	newSVattachable (attachable *obj, HV *stash)
221	{	277	{
222	if (!obj)	278	if (!obj)
223	return &PL_sv_undef;	279	return &PL_sv_undef;
224		280
225	if (!obj->self)	281	if (!obj->self)
226	{	282	{
227	obj->self = newHV ();	283	obj->self = newHV ();
228	sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &vtbl_attachable, (char *)obj, 0);	284	sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char *)obj, 0);
		285	obj->flags |= (obj->flags & 0xc0) << 8;
		286	obj->flags &= ~0xc0;//D
		287	obj->flags |= 0x10;//D
229		288
230	// borrow the refcnt from the object	289	// now bless the object _once_
231	obj->flags |= attachable::F_BORROWED;	290	return sv_bless (newRV_inc ((SV *)obj->self), stash);
232	obj->refcnt_dec ();
233	}	291	}
		292	else
		293	{
		294	SV *sv = newRV_inc ((SV *)obj->self);
234		295
235	return sv_bless (newRV_inc ((SV *)obj->self), stash);	296	if (Gv_AMG (stash)) // handle overload correctly, as the perl core does not
		297	SvAMAGIC_on (sv);
		298
		299	return sv;
		300	}
236	}	301	}
237		302
238	static void	303	static void
239	clearSVptr (SV *sv)	304	clearSVptr (SV *sv)
240	{	305	{
…		…
293	inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }	358	inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }
294		359
295	inline SV *to_sv (object & v) { return to_sv (&v); }	360	inline SV *to_sv (object & v) { return to_sv (&v); }
296	inline SV *to_sv (living & v) { return to_sv (&v); }	361	inline SV *to_sv (living & v) { return to_sv (&v); }
297		362
298	//TODO:	363	inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); }
299	inline SV *to_sv (New_Face * v) { return to_sv (v->name); }
300	inline SV *to_sv (treasurelist * v) { return to_sv (v->name); }	364	inline SV *to_sv (const treasurelist *v) { return to_sv (v->name); }
301		365
302	inline SV *to_sv (UUID v)	366	inline SV *to_sv (UUID v)
303	{	367	{
304	char buf[128];	368	char buf[128];
305	snprintf (buf, 128, "<1,%" PRIx64 ">", v.seq);	369	snprintf (buf, 128, "<1.%" PRIx64 ">", v.seq);
306	return newSVpv (buf, 0);	370	return newSVpv (buf, 0);
307	}	371	}
308		372
309	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPV_nolen (sv) : 0; }	373	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPV_nolen (sv) : 0; }
310	inline void sv_to (SV *sv, char * &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }	374	inline void sv_to (SV *sv, char * &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }
…		…
319	inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }	383	inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }
320	inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }	384	inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }
321	inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }	385	inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }
322	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }	386	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
323	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }	387	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }
324	inline void sv_to (SV *sv, client * &v) { v = (client *)SvPTR_ornull (sv, "cf::client"); }	388	inline void sv_to (SV *sv, client * &v) { v = (client *)(attachable *)SvPTR_ornull (sv, "cf::client"); }
325	inline void sv_to (SV *sv, player * &v) { v = (player *)SvPTR_ornull (sv, "cf::player"); }	389	inline void sv_to (SV *sv, player * &v) { v = (player *)(attachable *)SvPTR_ornull (sv, "cf::player"); }
326	inline void sv_to (SV *sv, object * &v) { v = (object *)SvPTR_ornull (sv, "cf::object"); }	390	inline void sv_to (SV *sv, object * &v) { v = (object *)(attachable *)SvPTR_ornull (sv, "cf::object"); }
327	inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)SvPTR_ornull (sv, "cf::arch"); }	391	inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)(attachable *)SvPTR_ornull (sv, "cf::arch"); }
328	inline void sv_to (SV *sv, maptile * &v) { v = (maptile *)SvPTR_ornull (sv, "cf::map"); }	392	inline void sv_to (SV *sv, maptile * &v) { v = (maptile *)(attachable *)SvPTR_ornull (sv, "cf::map"); }
		393	inline void sv_to (SV *sv, attachable * &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); }
329	inline void sv_to (SV *sv, partylist * &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }	394	inline void sv_to (SV *sv, partylist * &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }
330	inline void sv_to (SV *sv, region * &v) { v = (region *)SvPTR_ornull (sv, "cf::region"); }	395	inline void sv_to (SV *sv, region * &v) { v = (region *)SvPTR_ornull (sv, "cf::region"); }
331	inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }	396	inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }
332		397
333	inline void sv_to (SV *sv, New_Face * &v) { v = &new_faces[FindFace (SvPV_nolen (sv), 0)]; } //TODO	398	//inline void sv_to (SV *sv, faceinfo * &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }
334	inline void sv_to (SV *sv, treasurelist * &v) { v = find_treasurelist (SvPV_nolen (sv)); } // TODO	399	inline void sv_to (SV *sv, treasurelist * &v) { v = treasurelist::find (SvPV_nolen (sv)); }
335		400
336	template<class T>	401	template<class T>
337	inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }	402	inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }
338		403
339	template<int N>	404	template<int N>
…		…
342	inline void sv_to (SV *sv, rangetype &v) { v = (rangetype) SvIV (sv); }	407	inline void sv_to (SV *sv, rangetype &v) { v = (rangetype) SvIV (sv); }
343	inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); }	408	inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); }
344	inline void sv_to (SV *sv, petmode_t &v) { v = (petmode_t) SvIV (sv); }	409	inline void sv_to (SV *sv, petmode_t &v) { v = (petmode_t) SvIV (sv); }
345	inline void sv_to (SV *sv, usekeytype &v) { v = (usekeytype) SvIV (sv); }	410	inline void sv_to (SV *sv, usekeytype &v) { v = (usekeytype) SvIV (sv); }
346	inline void sv_to (SV *sv, unapplymode &v) { v = (unapplymode) SvIV (sv); }	411	inline void sv_to (SV *sv, unapplymode &v) { v = (unapplymode) SvIV (sv); }
		412
		413	inline void sv_to (SV *sv, std::string &v)
		414	{
		415	STRLEN len;
		416	char *data = SvPVbyte (sv, len);
		417	v.assign (data, len);
		418	}
347		419
348	inline void sv_to (SV *sv, UUID &v)	420	inline void sv_to (SV *sv, UUID &v)
349	{	421	{
350	unsigned int version;	422	unsigned int version;
351		423
…		…
474	{	546	{
475	if (!ext->cb)	547	if (!ext->cb)
476	ext->cb = newAV ();	548	ext->cb = newAV ();
477		549
478	return newRV_inc ((SV *)ext->cb);	550	return newRV_inc ((SV *)ext->cb);
479	}
480
481	#if 0
482	void attachable::clear ()
483	{
484	if (self)
485	{
486	// disconnect Perl from C, to avoid crashes
487	sv_unmagic (SvRV ((SV *)self), PERL_MAGIC_ext);
488
489	// clear the perl hash, might or might not be a good idea
490	hv_clear ((HV *)SvRV ((SV *)self));
491
492	SvREFCNT_dec (self);
493	self = 0;
494	}
495
496	if (cb)
497	{
498	SvREFCNT_dec (cb);
499	cb = 0;
500	}
501
502	attach = 0;
503	}
504	#endif
505
506	void attachable::optimise ()
507	{
508	if (self
509	&& SvREFCNT (self) == 1
510	&& !HvTOTALKEYS (self))
511	{
512	flags &= ~F_BORROWED;
513	refcnt_inc ();
514	SvREFCNT_dec ((SV *)self);
515	}
516	}
517
518	/////////////////////////////////////////////////////////////////////////////
519
520	#include "kw_hash.h"
521
522	object_freezer::object_freezer ()
523	: dynbuf (128 * 1024, 64 * 1024)
524	{
525	av = newAV ();
526	}
527
528	object_freezer::~object_freezer ()
529	{
530	SvREFCNT_dec (av);
531	}
532
533	void object_freezer::put (attachable *ext)
534	{
535	ext->optimise ();
536
537	if (ext->self)
538	{
539	int idx = AvFILLp ((AV *)av) + 1;
540	av_store (av, idx, newRV_inc ((SV *)ext->self));
541
542	add ((void *)"oid ", 4);
543	add ((sint32)idx);
544	add ('\n');
545	}
546	}
547
548	bool object_freezer::save (const char *filename)
549	{
550	dSP;
551	ENTER;
552	SAVETMPS;
553	PUSHMARK (SP);
554	EXTEND (SP, 3);
555	PUSHs (sv_2mortal (newSVpv (filename, 0)));
556	PUSHs (sv_2mortal (newRV_noinc (newSVpvn ((char *)linearise (), size ()))));
557	PUSHs (sv_2mortal (newRV_inc ((SV *)av)));
558	PUTBACK;
559	call_pv ("cf::object_freezer_save", G_VOID | G_DISCARD | G_EVAL);
560	FREETMPS;
561	LEAVE;
562	}
563
564	char *object_freezer::as_string ()
565	{
566	dSP;
567	ENTER;
568	SAVETMPS;
569	PUSHMARK (SP);
570	EXTEND (SP, 3);
571	PUSHs (sv_2mortal (newRV_noinc (newSVpvn ((char *)linearise (), size ()))));
572	PUSHs (sv_2mortal (newRV_inc ((SV *)av)));
573	PUTBACK;
574
575	char *res = call_pv ("cf::object_freezer_as_string", G_SCALAR | G_EVAL) > 0
576	? strdup (SvPVbyte_nolen (POPs))
577	: strdup ("[fatal error]");
578
579	FREETMPS;
580	LEAVE;
581
582	return res;
583	}
584
585	int fprintf (object_freezer &freezer, const char *format, ...)
586	{
587	va_list ap;
588
589	va_start (ap, format);
590
591	int len = vsnprintf ((char *)freezer.force (1024), 1024, format, ap);
592
593	if (len >= 0)
594	freezer.alloc (len);
595
596	va_end (ap);
597	}
598
599	int fputs (const char *s, object_freezer &freezer)
600	{
601	freezer.add (s);
602	}
603
604	static const char thawer_eof[] = "\n\n\n\0\0\0";
605
606	object_thawer::object_thawer (const char *filename)
607	{
608	static const char eof[] = "\n\n\n\0\0\0";
609
610	av = 0;
611	text = 0;
612	line = 0;
613
614	if (filename)
615	{
616	dSP;
617	ENTER;
618	SAVETMPS;
619	PUSHMARK (SP);
620	XPUSHs (sv_2mortal (newSVpv (filename, 0)));
621	PUTBACK;
622
623	if (2 == call_pv ("cf::object_thawer_load", G_ARRAY | G_EVAL))
624	{
625	SPAGAIN;
626
627	// second value - perl objects
628	{
629	SV *sv = POPs;
630	if (SvROK (sv))
631	av = (AV *)SvREFCNT_inc (SvRV (sv));
632	}
633
634	// first value - text part, pad with 3 zeroes
635	{
636	SV *sv = POPs;
637	STRLEN len;
638	char *sv_ = SvPVbyte (sv, len);
639	text = newSV (len + sizeof (eof));
640	SvCUR_set (text, len);
641	memcpy (SvPVX (text), sv_, len);
642	memcpy (SvEND (text), eof, sizeof (eof)); // just to be sure
643
644	line = SvPVX (text);
645	}
646	}
647
648	PUTBACK;
649	FREETMPS;
650	LEAVE;
651	}
652	}
653
654	object_thawer::object_thawer (const char *data, AV *perlav)
655	{
656	av = perlav;
657	text = newSVpv (data, 0);
658	sv_catpv (text, thawer_eof);
659	line = SvPVbyte_nolen (text);
660	}
661
662	void object_thawer::get (attachable *obj, int oid)
663	{
664	if (!av || oid < 0) // this is actually an error of sorts
665	return;
666
667	// object must be virgin
668	assert (!obj->self);
669
670	SV **svp = av_fetch ((AV *)av, oid, 0);
671
672	if (!svp || !SvROK (*svp))
673	{
674	printf ("trying to thaw duplicate or never-issued oid %d, ignoring.\n", oid);
675	return;
676	}
677
678	obj->self = (HV *)SvRV (*svp);
679	SvRV_set (*svp, &PL_sv_undef);
680
681	sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &vtbl_attachable, (char *)obj, 0);
682	obj->reattach ();
683
684	// borrow a refcount for the perl object
685	obj->flags |= attachable::F_BORROWED;
686	obj->refcnt_dec ();
687	}
688
689	object_thawer::~object_thawer ()
690	{
691	if (text) SvREFCNT_dec (text);
692	if (av) SvREFCNT_dec (av);
693	}
694
695	char *fgets (char *s, int n, object_thawer &thawer)
696	{
697	char *p = thawer.line;
698	char *q = s;
699
700	if (!p)
701	return 0;
702
703	while (--n)
704	{
705	if (!*p)
706	break;
707
708	*q++ = *p;
709
710	if (*p++ == '\n')
711	break;
712	}
713
714	*q = 0;
715	thawer.line = p;
716
717	return s == q ? 0 : s;
718	}
719
720	keyword object_thawer::get_kv ()
721	{
722	if (!line)
723	return KW_EOF;
724
725	for (;;)
726	{
727	char *p = line;
728
729	if (!*p)
730	return KW_EOF;
731
732	// parse keyword
733	while (*p > ' ')
734	p++;
735
736	int klen = p - line;
737
738	if (*p++ != '\n')
739	{
740	// parse value
741	while (*(unsigned char *)p <= ' ' && *p != '\n') // skip 0x01 .. 0x20
742	++p;
743
744	last_value = p;
745
746	while (*p != '\n')
747	p++;
748
749	*p++ = 0;
750	}
751	else
752	last_value = 0;
753
754	line [klen] = 0;
755	keyword_idx *kw = kw_lex::match (line, klen);
756
757	//printf ("KV %d<%s,%s>\n", kw ? kw->index : 0, line, last_value);//D
758
759	if (kw)
760	{
761	line = p;
762	return kw->index;
763	}
764	else if (!*line || *line == '#')
765	{
766	// empty/comment line
767	line = p;
768	}
769	else
770	return KW_ERROR;
771	}
772	}
773
774	void object_thawer::get (shstr &sh) const
775	{
776	if (last_value)
777	sh = last_value;
778	else
779	{
780	sh = "<value missing>";
781	LOG (llevError, "keyword requires value: <%s>\n", line);//TODO: add filename
782	}
783	}
784
785	void object_thawer::get_ml (keyword kend, shstr &sh)
786	{
787	char kw[128];
788
789	int klen = keyword_len [kend];
790
791	kw [0] = '\n';
792	memcpy (kw + 1, keyword_str [kend], klen);
793	kw [klen + 1] = '\n';
794	kw [klen + 2] = 0;
795
796	// first test for completely empty msg... "endXXX\n"
797	if (!strncmp (line, kw + 1, klen + 1))
798	{
799	sh = 0;
800
801	line += klen + 1;
802
803	return;
804	}
805	else
806	{
807	// multi-line strings are delimited by "\nendXXX\n" or "endXXX\n" (NULL)
808
809	char *end = strstr (line, kw);
810
811	if (!end)
812	{
813	sh = 0;
814	return;
815	}
816
817	*end = 0;
818	sh = line;
819
820	line = end + keyword_len [kend] + 1;
821
822	while (*line++ != '\n')
823	;
824	}
825	}
826
827	sint32 object_thawer::get_sint32 () const
828	{
829	char *p = last_value;
830
831	if (!p)
832	return 0;
833
834	sint32 val = 0;
835	bool negate;
836
837	if (*p == '-')
838	{
839	negate = true;
840	++p;
841	}
842	else
843	negate = false;
844
845	do
846	{
847	val *= 10;
848	val += *p++ - '0';
849	}
850	while (*p);
851
852	return negate ? -val : val;
853	}
854
855	sint64 object_thawer::get_sint64 () const
856	{
857	return last_value ? atoll (last_value) : 0;
858	}
859
860	double object_thawer::get_double () const
861	{
862	return last_value ? atof (last_value) : 0;
863	}	551	}
864		552
865	/////////////////////////////////////////////////////////////////////////////	553	/////////////////////////////////////////////////////////////////////////////
866		554
867	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)	555	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
…		…
926	perl = perl_alloc ();	614	perl = perl_alloc ();
927	perl_construct (perl);	615	perl_construct (perl);
928		616
929	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;	617	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
930		618
931	char *argv[] = {	619	const char *argv[] = {
932	"",	620	"",
933	"-e"	621	"-e"
934	"use Event; use Coro;" // required for bootstrap	622	"use Event; use Coro;" // required for bootstrap
935	"cf->bootstrap;" // required for datadir :*>	623	"cf->bootstrap;" // required for datadir :*>
936	"unshift @INC, cf::datadir ();"	624	"unshift @INC, cf::datadir ();"
937	"require cf;"	625	"require cf;"
938	};	626	};
939		627
940	if (perl_parse (perl, xs_init, 2, argv, (char **)NULL) || perl_run (perl))	628	if (perl_parse (perl, xs_init, 2, (char **)argv, (char **)NULL)
		629	|| perl_run (perl))
941	{	630	{
942	printf ("unable to initialize perl-interpreter, aborting.\n");	631	printf ("unable to initialize perl-interpreter, aborting.\n");
943	exit (EXIT_FAILURE);	632	exit (EXIT_FAILURE);
944	}	633	}
		634
		635	{
		636	dSP;
		637
		638	PUSHMARK (SP);
		639	PUTBACK;
		640	call_pv ("cf::init", G_DISCARD | G_VOID);
		641	}
945	}	642	}
946		643
947	void cfperl_main ()	644	void cfperl_main ()
948	{	645	{
949	dSP;	646	dSP;
…		…
1094		791
1095	// short-circuit processing if no callbacks found/defined	792	// short-circuit processing if no callbacks found/defined
1096	if (!callbacks)	793	if (!callbacks)
1097	return 0;	794	return 0;
1098		795
1099	dSP;	796	CALL_BEGIN (3);
1100	ENTER;
1101	SAVETMPS;
1102
1103	PUSHMARK (SP);
1104	EXTEND (SP, 3);
1105
1106	PUSHs (sv_2mortal (newSViv (event))); // only used for debugging nowadays	797	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays
1107	PUSHs (sv_2mortal (newRV_noinc ((SV *)callbacks)));	798	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));
1108		799
1109	//TODO: unhack	800	//TODO: unhack
1110	if (object *op = is_a<object>(this)) PUSHs (sv_2mortal (newSVdt (DT_OBJECT, op)));	801	if (object *op = is_a<object>(this)) CALL_ARG_SV (newSVdt (DT_OBJECT, op));
1111	else if (player *pl = is_a<player>(this)) PUSHs (sv_2mortal (newSVdt (DT_PLAYER, pl)));	802	else if (player *pl = is_a<player>(this)) CALL_ARG_SV (newSVdt (DT_PLAYER, pl));
1112	else if (client *ns = is_a<client>(this)) PUSHs (sv_2mortal (newSVdt (DT_CLIENT, ns)));	803	else if (client *ns = is_a<client>(this)) CALL_ARG_SV (newSVdt (DT_CLIENT, ns));
1113	else if (maptile *m = is_a<maptile>(this)) PUSHs (sv_2mortal (newSVdt (DT_MAP, m)));	804	else if (maptile *m = is_a<maptile>(this)) CALL_ARG_SV (newSVdt (DT_MAP, m));
1114	else if (global *gl = is_a<global>(this)) /*nop*/;	805	else if (global *gl = is_a<global>(this)) /*nop*/;
1115	else	806	else
1116	abort (); //TODO	807	abort (); //TODO
1117		808
1118	for (;;)	809	for (;;)
…		…
1132	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));	823	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
1133	}	824	}
1134		825
1135	va_end (ap);	826	va_end (ap);
1136		827
1137	PUTBACK;	828	CALL_CALL ("cf::do_invoke", G_SCALAR);
1138	int count = call_pv ("cf::do_invoke", G_SCALAR | G_EVAL);
1139	SPAGAIN;
1140
1141	count = count > 0 ? POPi : 0;	829	count = count > 0 ? POPi : 0;
1142		830
1143	FREETMPS;	831	CALL_END;
1144	LEAVE;
1145		832
1146	return count;	833	return count;
1147	}	834	}
1148		835
1149	SV *	836	SV *
…		…
1172	return SvNV (cfperl_result (idx));	859	return SvNV (cfperl_result (idx));
1173	}	860	}
1174		861
1175	/////////////////////////////////////////////////////////////////////////////	862	/////////////////////////////////////////////////////////////////////////////
1176		863
		864	void
		865	cfperl_emergency_save ()
		866	{
		867	CALL_BEGIN (0);
		868	CALL_CALL ("cf::emergency_save", G_VOID);
		869	CALL_END;
		870	}
		871
		872	void
		873	cfperl_cleanup (int make_core)
		874	{
		875	CALL_BEGIN (1);
		876	CALL_ARG (make_core);
		877	CALL_CALL ("cf::post_cleanup", G_VOID);
		878	CALL_END;
		879	}
		880
		881	maptile *
		882	maptile::find_sync (const char *path, maptile *origin)
		883	{
		884	CALL_BEGIN (2);
		885	CALL_ARG (path);
		886	CALL_ARG (origin);
		887	CALL_CALL ("cf::map::find_sync", G_SCALAR);
		888
		889	maptile *retval;
		890
		891	if (count)
		892	sv_to (POPs, retval);
		893	else
		894	retval = 0;
		895
		896	CALL_END;
		897
		898	return retval;
		899	}
		900
		901	maptile *
		902	maptile::find_async (const char *path, maptile *origin)
		903	{
		904	CALL_BEGIN (2);
		905	CALL_ARG (path);
		906	CALL_ARG (origin);
		907	CALL_CALL ("cf::map::find_async", G_SCALAR);
		908
		909	maptile *retval;
		910
		911	if (count)
		912	sv_to (POPs, retval);
		913	else
		914	retval = 0;
		915
		916	CALL_END;
		917
		918	return retval;
		919	}
		920
		921	void
		922	maptile::do_load_sync ()
		923	{
		924	CALL_BEGIN (1);
		925	CALL_ARG (this);
		926	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);
		927	CALL_END;
		928	}
		929
		930	void
		931	maptile::change_all_map_light (int change)
		932	{
		933	CALL_BEGIN (1);
		934	CALL_ARG (change);
		935	CALL_CALL ("cf::map::change_all_map_light", G_VOID);
		936	CALL_END;
		937	}
		938
		939	void
		940	object::enter_exit (object *exit)
		941	{
		942	if (type != PLAYER)
		943	return;
		944
		945	CALL_BEGIN (2);
		946	CALL_ARG (this);
		947	CALL_ARG (exit);
		948	CALL_CALL ("cf::object::player::enter_exit", G_VOID);
		949	CALL_END;
		950	}
		951
		952	/////////////////////////////////////////////////////////////////////////////
		953
1177	struct EventAPI *watcher_base::GEventAPI;	954	struct EventAPI *watcher_base::GEventAPI;
		955	struct CoroAPI *coroapi::GCoroAPI;
1178		956
		957	int coroapi::cede_counter;
		958	double (*coroapi::time)();
		959	double coroapi::next_cede;
		960
		961	void coroapi::do_cede_to_tick ()
		962	{
		963	cede_counter = 0;
		964
		965	cede ();
		966
		967	next_cede += (TICK / CEDES_PER_TICK) * 0.99;
		968	if (next_cede > SvNV (sv_next_tick) - 0.02)
		969	next_cede = SvNV (sv_next_tick);
		970	}
		971
		972	void coroapi::do_cede_every ()
		973	{
		974	cede_counter = 0;
		975
		976	if (coroapi::nready ())
		977	coroapi::cede ();
		978	}
		979
		980	void coroapi::do_cede_to_tick_every ()
		981	{
		982	cede_counter = 0;
		983
		984	cede_to_tick ();
		985	}
		986
		987	void
		988	coroapi::wait_for_tick ()
		989	{
		990	CALL_BEGIN (0);
		991	CALL_CALL ("cf::wait_for_tick", G_DISCARD);
		992	CALL_END;
		993	}
		994
		995	void
		996	coroapi::wait_for_tick_begin ()
		997	{
		998	CALL_BEGIN (0);
		999	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);
		1000	CALL_END;
		1001	}
		1002
		1003	static void
1179	static void iw_dispatch (pe_event *ev)	1004	iw_dispatch (pe_event *ev)
1180	{	1005	{
1181	iw *w = (iw *)ev->ext_data;	1006	iw *w = (iw *)ev->ext_data;
1182	w->call (*w);	1007	w->call (*w);
1183	}	1008	}
1184		1009
1185	void	1010	void
1186	iw::alloc ()	1011	iw::alloc ()
1187	{	1012	{
1188	pe = GEventAPI->new_idle (0, 0);	1013	pe = GEventAPI->new_idle (0, 0);
1189		1014
		1015	WaREENTRANT_off (pe);
1190	pe->base.callback = (void *)iw_dispatch;	1016	pe->base.callback = (void *)iw_dispatch;
1191	pe->base.ext_data = (void *)this;	1017	pe->base.ext_data = (void *)this;
1192	}	1018	}
1193		1019
1194	static void iow_dispatch (pe_event *ev)	1020	static void iow_dispatch (pe_event *ev)
…		…
1200	void	1026	void
1201	iow::alloc ()	1027	iow::alloc ()
1202	{	1028	{
1203	pe = GEventAPI->new_io (0, 0);	1029	pe = GEventAPI->new_io (0, 0);
1204		1030
		1031	WaREENTRANT_off (pe);
1205	pe->base.callback = (void *)iow_dispatch;	1032	pe->base.callback = (void *)iow_dispatch;
1206	pe->base.ext_data = (void *)this;	1033	pe->base.ext_data = (void *)this;
1207		1034
1208	pe->fd = -1;	1035	pe->fd = -1;
1209	pe->poll = 0;	1036	pe->poll = 0;
…		…
1245	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);	1072	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
1246	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);	1073	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
1247	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);	1074	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
1248	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);	1075	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
1249		1076
		1077	sv_runtime = get_sv ("cf::RUNTIME" , 1); sv_upgrade (sv_runtime , SVt_NV);
		1078	sv_next_tick = get_sv ("cf::NEXT_TICK", 1); sv_upgrade (sv_next_tick, SVt_NV);
		1079
1250	cb_global = get_av ("cf::CB_GLOBAL", 1);	1080	cb_global = get_av ("cf::CB_GLOBAL", 1);
1251	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);	1081	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
1252	cb_object = get_av ("cf::CB_OBJECT", 1);	1082	cb_object = get_av ("cf::CB_OBJECT", 1);
1253	cb_player = get_av ("cf::CB_PLAYER", 1);	1083	cb_player = get_av ("cf::CB_PLAYER", 1);
1254	cb_client = get_av ("cf::CB_CLIENT", 1);	1084	cb_client = get_av ("cf::CB_CLIENT", 1);
…		…
1258		1088
1259	MODULE = cf PACKAGE = cf PREFIX = cf_	1089	MODULE = cf PACKAGE = cf PREFIX = cf_
1260		1090
1261	BOOT:	1091	BOOT:
1262	{	1092	{
		1093	I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;
		1094	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
		1095
1263	_connect_to_perl ();	1096	_connect_to_perl ();
1264		1097
1265	I_EVENT_API (PACKAGE);
1266	watcher_base::GEventAPI = GEventAPI;
1267	I_CORO_API (PACKAGE);
1268
1269	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));	1098	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
		1099
		1100	{
		1101	require_pv ("Time::HiRes");
		1102
		1103	SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
		1104	if (!svp) croak ("Time::HiRes is required");
		1105	if (!SvIOK(*svp)) croak ("Time::NVtime isn’t a function pointer");
		1106	coroapi::time = INT2PTR (double(*)(), SvIV(*svp));
		1107	}
1270		1108
1271	static const struct {	1109	static const struct {
1272	const char *name;	1110	const char *name;
1273	IV iv;	1111	IV iv;
1274	} *civ, const_iv[] = {	1112	} *civ, const_iv[] = {
1275	# define const_iv(name) { # name, (IV)name },	1113	# define const_iv(name) { # name, (IV)name },
1276	const_iv (llevError)	1114	const_iv (llevError) const_iv (llevInfo) const_iv (llevDebug) const_iv (llevMonster)
1277	const_iv (llevInfo)	1115
1278	const_iv (llevDebug)	1116	const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)
1279	const_iv (llevMonster)	1117
		1118	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)
1280		1119
1281	const_iv (MAX_TIME)	1120	const_iv (MAX_TIME)
1282	const_iv (PLAYER)	1121
1283	const_iv (TRANSPORT)	1122	const_iv (PLAYER) const_iv (TRANSPORT) const_iv (ROD) const_iv (TREASURE)
1284	const_iv (ROD)	1123	const_iv (POTION) const_iv (FOOD) const_iv (POISON) const_iv (BOOK)
1285	const_iv (TREASURE)	1124	const_iv (CLOCK) const_iv (ARROW) const_iv (BOW) const_iv (WEAPON)
1286	const_iv (POTION)	1125	const_iv (ARMOUR) const_iv (PEDESTAL) const_iv (ALTAR) const_iv (LOCKED_DOOR)
1287	const_iv (FOOD)	1126	const_iv (SPECIAL_KEY) const_iv (MAP) const_iv (DOOR) const_iv (KEY)
1288	const_iv (POISON)	1127	const_iv (TIMED_GATE) const_iv (TRIGGER) const_iv (GRIMREAPER) const_iv (MAGIC_EAR)
1289	const_iv (BOOK)	1128	const_iv (TRIGGER_BUTTON) const_iv (TRIGGER_ALTAR) const_iv (TRIGGER_PEDESTAL) const_iv (SHIELD)
1290	const_iv (CLOCK)	1129	const_iv (HELMET) const_iv (HORN) const_iv (MONEY) const_iv (CLASS)
1291	const_iv (ARROW)	1130	const_iv (GRAVESTONE) const_iv (AMULET) const_iv (PLAYERMOVER) const_iv (TELEPORTER)
1292	const_iv (BOW)	1131	const_iv (CREATOR) const_iv (SKILL) const_iv (EARTHWALL) const_iv (GOLEM)
1293	const_iv (WEAPON)	1132	const_iv (THROWN_OBJ) const_iv (BLINDNESS) const_iv (GOD) const_iv (DETECTOR)
1294	const_iv (ARMOUR)	1133	const_iv (TRIGGER_MARKER) const_iv (DEAD_OBJECT) const_iv (DRINK) const_iv (MARKER)
1295	const_iv (PEDESTAL)	1134	const_iv (HOLY_ALTAR) const_iv (PLAYER_CHANGER) const_iv (BATTLEGROUND) const_iv (PEACEMAKER)
1296	const_iv (ALTAR)	1135	const_iv (GEM) const_iv (FIREWALL) const_iv (ANVIL) const_iv (CHECK_INV)
1297	const_iv (LOCKED_DOOR)	1136	const_iv (MOOD_FLOOR) const_iv (EXIT) const_iv (ENCOUNTER) const_iv (SHOP_FLOOR)
1298	const_iv (SPECIAL_KEY)	1137	const_iv (SHOP_MAT) const_iv (RING) const_iv (FLOOR) const_iv (FLESH)
1299	const_iv (MAP)	1138	const_iv (INORGANIC) const_iv (SKILL_TOOL) const_iv (LIGHTER) const_iv (BUILDABLE_WALL)
1300	const_iv (DOOR)	1139	const_iv (MISC_OBJECT) const_iv (LAMP) const_iv (DUPLICATOR) const_iv (SPELLBOOK)
1301	const_iv (KEY)	1140	const_iv (CLOAK) const_iv (SPINNER) const_iv (GATE) const_iv (BUTTON)
1302	const_iv (TIMED_GATE)	1141	const_iv (CF_HANDLE) const_iv (HOLE) const_iv (TRAPDOOR) const_iv (SIGN)
1303	const_iv (TRIGGER)	1142	const_iv (BOOTS) const_iv (GLOVES) const_iv (SPELL) const_iv (SPELL_EFFECT)
1304	const_iv (GRIMREAPER)	1143	const_iv (CONVERTER) const_iv (BRACERS) const_iv (POISONING) const_iv (SAVEBED)
1305	const_iv (MAGIC_EAR)	1144	const_iv (WAND) const_iv (SCROLL) const_iv (DIRECTOR) const_iv (GIRDLE)
1306	const_iv (TRIGGER_BUTTON)	1145	const_iv (FORCE) const_iv (POTION_EFFECT) const_iv (EVENT_CONNECTOR) const_iv (CLOSE_CON)
1307	const_iv (TRIGGER_ALTAR)	1146	const_iv (CONTAINER) const_iv (ARMOUR_IMPROVER) const_iv (WEAPON_IMPROVER) const_iv (SKILLSCROLL)
1308	const_iv (TRIGGER_PEDESTAL)	1147	const_iv (DEEP_SWAMP) const_iv (IDENTIFY_ALTAR) const_iv (MENU) const_iv (RUNE)
1309	const_iv (SHIELD)	1148	const_iv (TRAP) const_iv (POWER_CRYSTAL) const_iv (CORPSE) const_iv (DISEASE)
1310	const_iv (HELMET)	1149	const_iv (SYMPTOM) const_iv (BUILDER) const_iv (MATERIAL) const_iv (ITEM_TRANSFORMER)
1311	const_iv (HORN)
1312	const_iv (MONEY)
1313	const_iv (CLASS)
1314	const_iv (GRAVESTONE)
1315	const_iv (AMULET)
1316	const_iv (PLAYERMOVER)
1317	const_iv (TELEPORTER)
1318	const_iv (CREATOR)
1319	const_iv (SKILL)
1320	const_iv (EARTHWALL)
1321	const_iv (GOLEM)
1322	const_iv (THROWN_OBJ)
1323	const_iv (BLINDNESS)
1324	const_iv (GOD)
1325	const_iv (DETECTOR)
1326	const_iv (TRIGGER_MARKER)
1327	const_iv (DEAD_OBJECT)
1328	const_iv (DRINK)
1329	const_iv (MARKER)
1330	const_iv (HOLY_ALTAR)
1331	const_iv (PLAYER_CHANGER)
1332	const_iv (BATTLEGROUND)
1333	const_iv (PEACEMAKER)
1334	const_iv (GEM)
1335	const_iv (FIREWALL)
1336	const_iv (ANVIL)
1337	const_iv (CHECK_INV)
1338	const_iv (MOOD_FLOOR)
1339	const_iv (EXIT)
1340	const_iv (ENCOUNTER)
1341	const_iv (SHOP_FLOOR)
1342	const_iv (SHOP_MAT)
1343	const_iv (RING)
1344	const_iv (FLOOR)
1345	const_iv (FLESH)
1346	const_iv (INORGANIC)
1347	const_iv (SKILL_TOOL)
1348	const_iv (LIGHTER)
1349	const_iv (BUILDABLE_WALL)
1350	const_iv (MISC_OBJECT)
1351	const_iv (LAMP)
1352	const_iv (DUPLICATOR)
1353	const_iv (SPELLBOOK)
1354	const_iv (CLOAK)
1355	const_iv (SPINNER)
1356	const_iv (GATE)
1357	const_iv (BUTTON)
1358	const_iv (CF_HANDLE)
1359	const_iv (HOLE)
1360	const_iv (TRAPDOOR)
1361	const_iv (SIGN)
1362	const_iv (BOOTS)
1363	const_iv (GLOVES)
1364	const_iv (SPELL)
1365	const_iv (SPELL_EFFECT)
1366	const_iv (CONVERTER)
1367	const_iv (BRACERS)
1368	const_iv (POISONING)
1369	const_iv (SAVEBED)
1370	const_iv (WAND)
1371	const_iv (SCROLL)
1372	const_iv (DIRECTOR)
1373	const_iv (GIRDLE)
1374	const_iv (FORCE)
1375	const_iv (POTION_EFFECT)
1376	const_iv (EVENT_CONNECTOR)
1377	const_iv (CLOSE_CON)
1378	const_iv (CONTAINER)
1379	const_iv (ARMOUR_IMPROVER)
1380	const_iv (WEAPON_IMPROVER)
1381	const_iv (SKILLSCROLL)
1382	const_iv (DEEP_SWAMP)
1383	const_iv (IDENTIFY_ALTAR)
1384	const_iv (MENU)
1385	const_iv (RUNE)
1386	const_iv (TRAP)
1387	const_iv (POWER_CRYSTAL)
1388	const_iv (CORPSE)
1389	const_iv (DISEASE)
1390	const_iv (SYMPTOM)
1391	const_iv (BUILDER)
1392	const_iv (MATERIAL)
1393	const_iv (ITEM_TRANSFORMER)
1394		1150
1395	const_iv (NUM_SUBTYPES)	1151	const_iv (NUM_SUBTYPES)
1396		1152
1397	const_iv (ST_BD_BUILD)	1153	const_iv (ST_BD_BUILD) const_iv (ST_BD_REMOVE)
1398	const_iv (ST_BD_REMOVE)	1154	const_iv (ST_MAT_FLOOR) const_iv (ST_MAT_WALL) const_iv (ST_MAT_ITEM)
1399		1155
1400	const_iv (ST_MAT_FLOOR)	1156	const_iv (AT_PHYSICAL) const_iv (AT_MAGIC) const_iv (AT_FIRE) const_iv (AT_ELECTRICITY)
1401	const_iv (ST_MAT_WALL)	1157	const_iv (AT_COLD) const_iv (AT_CONFUSION) const_iv (AT_ACID) const_iv (AT_DRAIN)
1402	const_iv (ST_MAT_ITEM)	1158	const_iv (AT_WEAPONMAGIC) const_iv (AT_GHOSTHIT) const_iv (AT_POISON) const_iv (AT_SLOW)
		1159	const_iv (AT_PARALYZE) const_iv (AT_TURN_UNDEAD) const_iv (AT_FEAR) const_iv (AT_CANCELLATION)
		1160	const_iv (AT_DEPLETE) const_iv (AT_DEATH) const_iv (AT_CHAOS) const_iv (AT_COUNTERSPELL)
		1161	const_iv (AT_GODPOWER) const_iv (AT_HOLYWORD) const_iv (AT_BLIND) const_iv (AT_INTERNAL)
		1162	const_iv (AT_LIFE_STEALING) const_iv (AT_DISEASE)
1403		1163
1404	const_iv (AT_PHYSICAL)	1164	const_iv (WEAP_HIT) const_iv (WEAP_SLASH) const_iv (WEAP_PIERCE) const_iv (WEAP_CLEAVE)
1405	const_iv (AT_MAGIC)	1165	const_iv (WEAP_SLICE) const_iv (WEAP_STAB) const_iv (WEAP_WHIP) const_iv (WEAP_CRUSH)
1406	const_iv (AT_FIRE)
1407	const_iv (AT_ELECTRICITY)
1408	const_iv (AT_COLD)
1409	const_iv (AT_CONFUSION)
1410	const_iv (AT_ACID)
1411	const_iv (AT_DRAIN)
1412	const_iv (AT_WEAPONMAGIC)
1413	const_iv (AT_GHOSTHIT)
1414	const_iv (AT_POISON)
1415	const_iv (AT_SLOW)
1416	const_iv (AT_PARALYZE)
1417	const_iv (AT_TURN_UNDEAD)
1418	const_iv (AT_FEAR)
1419	const_iv (AT_CANCELLATION)
1420	const_iv (AT_DEPLETE)
1421	const_iv (AT_DEATH)
1422	const_iv (AT_CHAOS)
1423	const_iv (AT_COUNTERSPELL)
1424	const_iv (AT_GODPOWER)
1425	const_iv (AT_HOLYWORD)
1426	const_iv (AT_BLIND)
1427	const_iv (AT_INTERNAL)
1428	const_iv (AT_LIFE_STEALING)
1429	const_iv (AT_DISEASE)
1430
1431	const_iv (WEAP_HIT)
1432	const_iv (WEAP_SLASH)
1433	const_iv (WEAP_PIERCE)
1434	const_iv (WEAP_CLEAVE)
1435	const_iv (WEAP_SLICE)
1436	const_iv (WEAP_STAB)
1437	const_iv (WEAP_WHIP)
1438	const_iv (WEAP_CRUSH)
1439	const_iv (WEAP_BLUD)	1166	const_iv (WEAP_BLUD)
1440		1167
1441	const_iv (FLAG_ALIVE)	1168	const_iv (FLAG_ALIVE) const_iv (FLAG_WIZ) const_iv (FLAG_REMOVED) const_iv (FLAG_FREED)
1442	const_iv (FLAG_WIZ)	1169	const_iv (FLAG_WAS_WIZ) const_iv (FLAG_APPLIED) const_iv (FLAG_UNPAID) const_iv (FLAG_USE_SHIELD)
1443	const_iv (FLAG_REMOVED)	1170	const_iv (FLAG_NO_PICK) const_iv (FLAG_ANIMATE) const_iv (FLAG_MONSTER) const_iv (FLAG_FRIENDLY)
1444	const_iv (FLAG_FREED)	1171	const_iv (FLAG_GENERATOR) const_iv (FLAG_IS_THROWN) const_iv (FLAG_AUTO_APPLY) const_iv (FLAG_PLAYER_SOLD)
1445	const_iv (FLAG_WAS_WIZ)	1172	const_iv (FLAG_SEE_INVISIBLE) const_iv (FLAG_CAN_ROLL) const_iv (FLAG_OVERLAY_FLOOR) const_iv (FLAG_IS_TURNABLE)
1446	const_iv (FLAG_APPLIED)	1173	const_iv (FLAG_IS_USED_UP) const_iv (FLAG_IDENTIFIED) const_iv (FLAG_REFLECTING) const_iv (FLAG_CHANGING)
1447	const_iv (FLAG_UNPAID)	1174	const_iv (FLAG_SPLITTING) const_iv (FLAG_HITBACK) const_iv (FLAG_STARTEQUIP) const_iv (FLAG_BLOCKSVIEW)
1448	const_iv (FLAG_USE_SHIELD)	1175	const_iv (FLAG_UNDEAD) const_iv (FLAG_SCARED) const_iv (FLAG_UNAGGRESSIVE) const_iv (FLAG_REFL_MISSILE)
1449	const_iv (FLAG_NO_PICK)	1176	const_iv (FLAG_REFL_SPELL) const_iv (FLAG_NO_MAGIC) const_iv (FLAG_NO_FIX_PLAYER) const_iv (FLAG_IS_LIGHTABLE)
1450	const_iv (FLAG_ANIMATE)	1177	const_iv (FLAG_TEAR_DOWN) const_iv (FLAG_RUN_AWAY) const_iv (FLAG_PICK_UP) const_iv (FLAG_UNIQUE)
1451	const_iv (FLAG_MONSTER)	1178	const_iv (FLAG_NO_DROP) const_iv (FLAG_WIZCAST) const_iv (FLAG_CAST_SPELL) const_iv (FLAG_USE_SCROLL)
1452	const_iv (FLAG_FRIENDLY)	1179	const_iv (FLAG_USE_RANGE) const_iv (FLAG_USE_BOW) const_iv (FLAG_USE_ARMOUR) const_iv (FLAG_USE_WEAPON)
1453	const_iv (FLAG_GENERATOR)	1180	const_iv (FLAG_USE_RING) const_iv (FLAG_READY_RANGE) const_iv (FLAG_READY_BOW) const_iv (FLAG_XRAYS)
1454	const_iv (FLAG_IS_THROWN)	1181	const_iv (FLAG_NO_APPLY) const_iv (FLAG_IS_FLOOR) const_iv (FLAG_LIFESAVE) const_iv (FLAG_NO_STRENGTH)
1455	const_iv (FLAG_AUTO_APPLY)	1182	const_iv (FLAG_SLEEP) const_iv (FLAG_STAND_STILL) const_iv (FLAG_RANDOM_MOVE) const_iv (FLAG_ONLY_ATTACK)
1456	const_iv (FLAG_PLAYER_SOLD)	1183	const_iv (FLAG_CONFUSED) const_iv (FLAG_STEALTH) const_iv (FLAG_WIZPASS) const_iv (FLAG_IS_LINKED)
1457	const_iv (FLAG_SEE_INVISIBLE)	1184	const_iv (FLAG_CURSED) const_iv (FLAG_DAMNED) const_iv (FLAG_SEE_ANYWHERE) const_iv (FLAG_KNOWN_MAGICAL)
1458	const_iv (FLAG_CAN_ROLL)	1185	const_iv (FLAG_KNOWN_CURSED) const_iv (FLAG_CAN_USE_SKILL) const_iv (FLAG_BEEN_APPLIED) const_iv (FLAG_READY_SCROLL)
1459	const_iv (FLAG_OVERLAY_FLOOR)	1186	const_iv (FLAG_USE_ROD) const_iv (FLAG_USE_HORN) const_iv (FLAG_MAKE_INVIS) const_iv (FLAG_INV_LOCKED)
1460	const_iv (FLAG_IS_TURNABLE)	1187	const_iv (FLAG_IS_WOODED) const_iv (FLAG_IS_HILLY) const_iv (FLAG_READY_SKILL) const_iv (FLAG_READY_WEAPON)
1461	const_iv (FLAG_IS_USED_UP)	1188	const_iv (FLAG_NO_SKILL_IDENT) const_iv (FLAG_BLIND) const_iv (FLAG_SEE_IN_DARK) const_iv (FLAG_IS_CAULDRON)
1462	const_iv (FLAG_IDENTIFIED)	1189	const_iv (FLAG_NO_STEAL) const_iv (FLAG_ONE_HIT) const_iv (FLAG_CLIENT_SENT) const_iv (FLAG_BERSERK)
1463	const_iv (FLAG_REFLECTING)	1190	const_iv (FLAG_NEUTRAL) const_iv (FLAG_NO_ATTACK) const_iv (FLAG_NO_DAMAGE) const_iv (FLAG_OBJ_ORIGINAL)
1464	const_iv (FLAG_CHANGING)	1191	const_iv (FLAG_OBJ_SAVE_ON_OVL) const_iv (FLAG_ACTIVATE_ON_PUSH) const_iv (FLAG_ACTIVATE_ON_RELEASE) const_iv (FLAG_IS_WATER)
1465	const_iv (FLAG_SPLITTING)	1192	const_iv (FLAG_CONTENT_ON_GEN) const_iv (FLAG_IS_A_TEMPLATE) const_iv (FLAG_IS_BUILDABLE)
1466	const_iv (FLAG_HITBACK)	1193	const_iv (FLAG_DESTROY_ON_DEATH) const_iv (FLAG_NO_MAP_SAVE)
1467	const_iv (FLAG_STARTEQUIP)
1468	const_iv (FLAG_BLOCKSVIEW)
1469	const_iv (FLAG_UNDEAD)
1470	const_iv (FLAG_SCARED)
1471	const_iv (FLAG_UNAGGRESSIVE)
1472	const_iv (FLAG_REFL_MISSILE)
1473	const_iv (FLAG_REFL_SPELL)
1474	const_iv (FLAG_NO_MAGIC)
1475	const_iv (FLAG_NO_FIX_PLAYER)
1476	const_iv (FLAG_IS_LIGHTABLE)
1477	const_iv (FLAG_TEAR_DOWN)
1478	const_iv (FLAG_RUN_AWAY)
1479	const_iv (FLAG_PICK_UP)
1480	const_iv (FLAG_UNIQUE)
1481	const_iv (FLAG_NO_DROP)
1482	const_iv (FLAG_WIZCAST)
1483	const_iv (FLAG_CAST_SPELL)
1484	const_iv (FLAG_USE_SCROLL)
1485	const_iv (FLAG_USE_RANGE)
1486	const_iv (FLAG_USE_BOW)
1487	const_iv (FLAG_USE_ARMOUR)
1488	const_iv (FLAG_USE_WEAPON)
1489	const_iv (FLAG_USE_RING)
1490	const_iv (FLAG_READY_RANGE)
1491	const_iv (FLAG_READY_BOW)
1492	const_iv (FLAG_XRAYS)
1493	const_iv (FLAG_NO_APPLY)
1494	const_iv (FLAG_IS_FLOOR)
1495	const_iv (FLAG_LIFESAVE)
1496	const_iv (FLAG_NO_STRENGTH)
1497	const_iv (FLAG_SLEEP)
1498	const_iv (FLAG_STAND_STILL)
1499	const_iv (FLAG_RANDOM_MOVE)
1500	const_iv (FLAG_ONLY_ATTACK)
1501	const_iv (FLAG_CONFUSED)
1502	const_iv (FLAG_STEALTH)
1503	const_iv (FLAG_WIZPASS)
1504	const_iv (FLAG_IS_LINKED)
1505	const_iv (FLAG_CURSED)
1506	const_iv (FLAG_DAMNED)
1507	const_iv (FLAG_SEE_ANYWHERE)
1508	const_iv (FLAG_KNOWN_MAGICAL)
1509	const_iv (FLAG_KNOWN_CURSED)
1510	const_iv (FLAG_CAN_USE_SKILL)
1511	const_iv (FLAG_BEEN_APPLIED)
1512	const_iv (FLAG_READY_SCROLL)
1513	const_iv (FLAG_USE_ROD)
1514	const_iv (FLAG_USE_HORN)
1515	const_iv (FLAG_MAKE_INVIS)
1516	const_iv (FLAG_INV_LOCKED)
1517	const_iv (FLAG_IS_WOODED)
1518	const_iv (FLAG_IS_HILLY)
1519	const_iv (FLAG_READY_SKILL)
1520	const_iv (FLAG_READY_WEAPON)
1521	const_iv (FLAG_NO_SKILL_IDENT)
1522	const_iv (FLAG_BLIND)
1523	const_iv (FLAG_SEE_IN_DARK)
1524	const_iv (FLAG_IS_CAULDRON)
1525	const_iv (FLAG_NO_STEAL)
1526	const_iv (FLAG_ONE_HIT)
1527	const_iv (FLAG_CLIENT_SENT)
1528	const_iv (FLAG_BERSERK)
1529	const_iv (FLAG_NEUTRAL)
1530	const_iv (FLAG_NO_ATTACK)
1531	const_iv (FLAG_NO_DAMAGE)
1532	const_iv (FLAG_OBJ_ORIGINAL)
1533	const_iv (FLAG_OBJ_SAVE_ON_OVL)
1534	const_iv (FLAG_ACTIVATE_ON_PUSH)
1535	const_iv (FLAG_ACTIVATE_ON_RELEASE)
1536	const_iv (FLAG_IS_WATER)
1537	const_iv (FLAG_CONTENT_ON_GEN)
1538	const_iv (FLAG_IS_A_TEMPLATE)
1539	const_iv (FLAG_IS_BUILDABLE)
1540		1194
1541	const_iv (NDI_BLACK)	1195	const_iv (NDI_BLACK) const_iv (NDI_WHITE) const_iv (NDI_NAVY) const_iv (NDI_RED)
1542	const_iv (NDI_WHITE)	1196	const_iv (NDI_ORANGE) const_iv (NDI_BLUE) const_iv (NDI_DK_ORANGE) const_iv (NDI_GREEN)
1543	const_iv (NDI_NAVY)	1197	const_iv (NDI_LT_GREEN) const_iv (NDI_GREY) const_iv (NDI_BROWN) const_iv (NDI_GOLD)
1544	const_iv (NDI_RED)	1198	const_iv (NDI_TAN) const_iv (NDI_MAX_COLOR) const_iv (NDI_COLOR_MASK) const_iv (NDI_UNIQUE)
1545	const_iv (NDI_ORANGE)
1546	const_iv (NDI_BLUE)
1547	const_iv (NDI_DK_ORANGE)
1548	const_iv (NDI_GREEN)
1549	const_iv (NDI_LT_GREEN)
1550	const_iv (NDI_GREY)
1551	const_iv (NDI_BROWN)
1552	const_iv (NDI_GOLD)
1553	const_iv (NDI_TAN)
1554	const_iv (NDI_MAX_COLOR)
1555	const_iv (NDI_COLOR_MASK)
1556	const_iv (NDI_UNIQUE)
1557	const_iv (NDI_ALL)	1199	const_iv (NDI_ALL)
1558		1200
1559	const_iv (UPD_LOCATION)	1201	const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE)
1560	const_iv (UPD_FLAGS)	1202	const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF)
1561	const_iv (UPD_WEIGHT)
1562	const_iv (UPD_FACE)
1563	const_iv (UPD_NAME)
1564	const_iv (UPD_ANIM)
1565	const_iv (UPD_ANIMSPEED)
1566	const_iv (UPD_NROF)
1567		1203
1568	const_iv (UPD_SP_MANA)	1204	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_DAMAGE)
1569	const_iv (UPD_SP_GRACE)
1570	const_iv (UPD_SP_DAMAGE)
1571		1205
1572	const_iv (F_APPLIED)	1206	const_iv (F_APPLIED) const_iv (F_LOCATION) const_iv (F_UNPAID) const_iv (F_MAGIC)
1573	const_iv (F_LOCATION)	1207	const_iv (F_CURSED) const_iv (F_DAMNED) const_iv (F_OPEN) const_iv (F_NOPICK)
1574	const_iv (F_UNPAID)
1575	const_iv (F_MAGIC)
1576	const_iv (F_CURSED)
1577	const_iv (F_DAMNED)
1578	const_iv (F_OPEN)
1579	const_iv (F_NOPICK)
1580	const_iv (F_LOCKED)	1208	const_iv (F_LOCKED)
1581		1209
1582	const_iv (F_BUY)	1210	const_iv (F_BUY) const_iv (F_SHOP) const_iv (F_SELL)
1583	const_iv (F_SHOP)
1584	const_iv (F_SELL)
1585		1211
1586	const_iv (P_BLOCKSVIEW)	1212	const_iv (P_BLOCKSVIEW) const_iv (P_PLAYER) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE)
1587	const_iv (P_PLAYER)	1213	const_iv (P_NO_CLERIC) const_iv (P_OUT_OF_MAP) const_iv (P_NEW_MAP) const_iv (P_UPTODATE)
1588	const_iv (P_NO_MAGIC)
1589	const_iv (P_IS_ALIVE)
1590	const_iv (P_NO_CLERIC)
1591	const_iv (P_NEED_UPDATE)
1592	const_iv (P_OUT_OF_MAP)
1593	const_iv (P_NEW_MAP)
1594		1214
1595	const_iv (UP_OBJ_INSERT)	1215	const_iv (UP_OBJ_INSERT) const_iv (UP_OBJ_REMOVE) const_iv (UP_OBJ_CHANGE) const_iv (UP_OBJ_FACE)
1596	const_iv (UP_OBJ_REMOVE)
1597	const_iv (UP_OBJ_CHANGE)
1598	const_iv (UP_OBJ_FACE)
1599		1216
1600	const_iv (INS_NO_MERGE)	1217	const_iv (INS_NO_MERGE) const_iv (INS_ABOVE_FLOOR_ONLY) const_iv (INS_NO_WALK_ON)
1601	const_iv (INS_ABOVE_FLOOR_ONLY)	1218	const_iv (INS_ON_TOP) const_iv (INS_BELOW_ORIGINATOR) const_iv (INS_MAP_LOAD)
1602	const_iv (INS_NO_WALK_ON)
1603	const_iv (INS_ON_TOP)
1604	const_iv (INS_BELOW_ORIGINATOR)
1605	const_iv (INS_MAP_LOAD)
1606		1219
1607	const_iv (WILL_APPLY_HANDLE)	1220	const_iv (WILL_APPLY_HANDLE) const_iv (WILL_APPLY_TREASURE) const_iv (WILL_APPLY_EARTHWALL)
1608	const_iv (WILL_APPLY_TREASURE)	1221	const_iv (WILL_APPLY_DOOR) const_iv (WILL_APPLY_FOOD)
1609	const_iv (WILL_APPLY_EARTHWALL)
1610	const_iv (WILL_APPLY_DOOR)
1611	const_iv (WILL_APPLY_FOOD)
1612		1222
1613	const_iv (SAVE_MODE)	1223	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)
1614	const_iv (SAVE_DIR_MODE)
1615		1224
1616	const_iv (M_PAPER)	1225	const_iv (M_PAPER) const_iv (M_IRON) const_iv (M_GLASS) const_iv (M_LEATHER)
1617	const_iv (M_IRON)	1226	const_iv (M_WOOD) const_iv (M_ORGANIC) const_iv (M_STONE) const_iv (M_CLOTH)
1618	const_iv (M_GLASS)	1227	const_iv (M_ADAMANT) const_iv (M_LIQUID) const_iv (M_SOFT_METAL) const_iv (M_BONE)
1619	const_iv (M_LEATHER)	1228	const_iv (M_ICE) const_iv (M_SPECIAL)
1620	const_iv (M_WOOD)
1621	const_iv (M_ORGANIC)
1622	const_iv (M_STONE)
1623	const_iv (M_CLOTH)
1624	const_iv (M_ADAMANT)
1625	const_iv (M_LIQUID)
1626	const_iv (M_SOFT_METAL)
1627	const_iv (M_BONE)
1628	const_iv (M_ICE)
1629	const_iv (M_SPECIAL)
1630		1229
1631	const_iv (SK_EXP_ADD_SKILL)	1230	const_iv (SK_EXP_ADD_SKILL) const_iv (SK_EXP_TOTAL) const_iv (SK_EXP_NONE)
1632	const_iv (SK_EXP_TOTAL)	1231	const_iv (SK_SUBTRACT_SKILL_EXP) const_iv (SK_EXP_SKILL_ONLY)
1633	const_iv (SK_EXP_NONE)
1634	const_iv (SK_SUBTRACT_SKILL_EXP)
1635	const_iv (SK_EXP_SKILL_ONLY)
1636		1232
1637	const_iv (SK_LOCKPICKING)	1233	const_iv (SK_LOCKPICKING) const_iv (SK_HIDING) const_iv (SK_SMITHERY) const_iv (SK_BOWYER)
1638	const_iv (SK_HIDING)	1234	const_iv (SK_JEWELER) const_iv (SK_ALCHEMY) const_iv (SK_STEALING) const_iv (SK_LITERACY)
1639	const_iv (SK_SMITHERY)	1235	const_iv (SK_BARGAINING) const_iv (SK_JUMPING) const_iv (SK_DET_MAGIC) const_iv (SK_ORATORY)
1640	const_iv (SK_BOWYER)	1236	const_iv (SK_SINGING) const_iv (SK_DET_CURSE) const_iv (SK_FIND_TRAPS) const_iv (SK_MEDITATION)
1641	const_iv (SK_JEWELER)	1237	const_iv (SK_PUNCHING) const_iv (SK_FLAME_TOUCH) const_iv (SK_KARATE) const_iv (SK_CLIMBING)
1642	const_iv (SK_ALCHEMY)	1238	const_iv (SK_WOODSMAN) const_iv (SK_INSCRIPTION) const_iv (SK_ONE_HANDED_WEAPON) const_iv (SK_MISSILE_WEAPON)
1643	const_iv (SK_STEALING)	1239	const_iv (SK_THROWING) const_iv (SK_USE_MAGIC_ITEM) const_iv (SK_DISARM_TRAPS) const_iv (SK_SET_TRAP)
1644	const_iv (SK_LITERACY)	1240	const_iv (SK_THAUMATURGY) const_iv (SK_PRAYING) const_iv (SK_CLAWING) const_iv (SK_LEVITATION)
1645	const_iv (SK_BARGAINING)	1241	const_iv (SK_SUMMONING) const_iv (SK_PYROMANCY) const_iv (SK_EVOCATION) const_iv (SK_SORCERY)
1646	const_iv (SK_JUMPING)	1242	const_iv (SK_TWO_HANDED_WEAPON) const_iv (SK_SPARK_TOUCH) const_iv (SK_SHIVER) const_iv (SK_ACID_SPLASH)
1647	const_iv (SK_DET_MAGIC)
1648	const_iv (SK_ORATORY)
1649	const_iv (SK_SINGING)
1650	const_iv (SK_DET_CURSE)
1651	const_iv (SK_FIND_TRAPS)
1652	const_iv (SK_MEDITATION)
1653	const_iv (SK_PUNCHING)
1654	const_iv (SK_FLAME_TOUCH)
1655	const_iv (SK_KARATE)
1656	const_iv (SK_CLIMBING)
1657	const_iv (SK_WOODSMAN)
1658	const_iv (SK_INSCRIPTION)
1659	const_iv (SK_ONE_HANDED_WEAPON)
1660	const_iv (SK_MISSILE_WEAPON)
1661	const_iv (SK_THROWING)
1662	const_iv (SK_USE_MAGIC_ITEM)
1663	const_iv (SK_DISARM_TRAPS)
1664	const_iv (SK_SET_TRAP)
1665	const_iv (SK_THAUMATURGY)
1666	const_iv (SK_PRAYING)
1667	const_iv (SK_CLAWING)
1668	const_iv (SK_LEVITATION)
1669	const_iv (SK_SUMMONING)
1670	const_iv (SK_PYROMANCY)
1671	const_iv (SK_EVOCATION)
1672	const_iv (SK_SORCERY)
1673	const_iv (SK_TWO_HANDED_WEAPON)
1674	const_iv (SK_SPARK_TOUCH)
1675	const_iv (SK_SHIVER)
1676	const_iv (SK_ACID_SPLASH)
1677	const_iv (SK_POISON_NAIL)	1243	const_iv (SK_POISON_NAIL)
1678		1244
1679	const_iv (SOUND_NEW_PLAYER)	1245	const_iv (SOUND_NEW_PLAYER) const_iv (SOUND_FIRE_ARROW) const_iv (SOUND_LEARN_SPELL) const_iv (SOUND_FUMBLE_SPELL)
1680	const_iv (SOUND_FIRE_ARROW)	1246	const_iv (SOUND_WAND_POOF) const_iv (SOUND_OPEN_DOOR) const_iv (SOUND_PUSH_PLAYER) const_iv (SOUND_PLAYER_HITS1)
1681	const_iv (SOUND_LEARN_SPELL)	1247	const_iv (SOUND_PLAYER_HITS2) const_iv (SOUND_PLAYER_HITS3) const_iv (SOUND_PLAYER_HITS4) const_iv (SOUND_PLAYER_IS_HIT1)
1682	const_iv (SOUND_FUMBLE_SPELL)	1248	const_iv (SOUND_PLAYER_IS_HIT2) const_iv (SOUND_PLAYER_IS_HIT3) const_iv (SOUND_PLAYER_KILLS) const_iv (SOUND_PET_IS_KILLED)
1683	const_iv (SOUND_WAND_POOF)	1249	const_iv (SOUND_PLAYER_DIES) const_iv (SOUND_OB_EVAPORATE) const_iv (SOUND_OB_EXPLODE) const_iv (SOUND_CLOCK)
1684	const_iv (SOUND_OPEN_DOOR)	1250	const_iv (SOUND_TURN_HANDLE) const_iv (SOUND_FALL_HOLE) const_iv (SOUND_DRINK_POISON) const_iv (SOUND_CAST_SPELL_0)
1685	const_iv (SOUND_PUSH_PLAYER)
1686	const_iv (SOUND_PLAYER_HITS1)
1687	const_iv (SOUND_PLAYER_HITS2)
1688	const_iv (SOUND_PLAYER_HITS3)
1689	const_iv (SOUND_PLAYER_HITS4)
1690	const_iv (SOUND_PLAYER_IS_HIT1)
1691	const_iv (SOUND_PLAYER_IS_HIT2)
1692	const_iv (SOUND_PLAYER_IS_HIT3)
1693	const_iv (SOUND_PLAYER_KILLS)
1694	const_iv (SOUND_PET_IS_KILLED)
1695	const_iv (SOUND_PLAYER_DIES)
1696	const_iv (SOUND_OB_EVAPORATE)
1697	const_iv (SOUND_OB_EXPLODE)
1698	const_iv (SOUND_CLOCK)
1699	const_iv (SOUND_TURN_HANDLE)
1700	const_iv (SOUND_FALL_HOLE)
1701	const_iv (SOUND_DRINK_POISON)
1702	const_iv (SOUND_CAST_SPELL_0)
1703		1251
1704	const_iv (PREFER_LOW)	1252	const_iv (PREFER_LOW) const_iv (PREFER_HIGH)
1705	const_iv (PREFER_HIGH)
1706		1253
1707	const_iv (ATNR_PHYSICAL)	1254	const_iv (ATNR_PHYSICAL) const_iv (ATNR_MAGIC) const_iv (ATNR_FIRE) const_iv (ATNR_ELECTRICITY)
1708	const_iv (ATNR_MAGIC)	1255	const_iv (ATNR_COLD) const_iv (ATNR_CONFUSION) const_iv (ATNR_ACID) const_iv (ATNR_DRAIN)
1709	const_iv (ATNR_FIRE)	1256	const_iv (ATNR_WEAPONMAGIC) const_iv (ATNR_GHOSTHIT) const_iv (ATNR_POISON) const_iv (ATNR_SLOW)
1710	const_iv (ATNR_ELECTRICITY)	1257	const_iv (ATNR_PARALYZE) const_iv (ATNR_TURN_UNDEAD) const_iv (ATNR_FEAR) const_iv (ATNR_CANCELLATION)
1711	const_iv (ATNR_COLD)	1258	const_iv (ATNR_DEPLETE) const_iv (ATNR_DEATH) const_iv (ATNR_CHAOS) const_iv (ATNR_COUNTERSPELL)
1712	const_iv (ATNR_CONFUSION)	1259	const_iv (ATNR_GODPOWER) const_iv (ATNR_HOLYWORD) const_iv (ATNR_BLIND) const_iv (ATNR_INTERNAL)
1713	const_iv (ATNR_ACID)	1260	const_iv (ATNR_LIFE_STEALING) const_iv (ATNR_DISEASE)
1714	const_iv (ATNR_DRAIN)
1715	const_iv (ATNR_WEAPONMAGIC)
1716	const_iv (ATNR_GHOSTHIT)
1717	const_iv (ATNR_POISON)
1718	const_iv (ATNR_SLOW)
1719	const_iv (ATNR_PARALYZE)
1720	const_iv (ATNR_TURN_UNDEAD)
1721	const_iv (ATNR_FEAR)
1722	const_iv (ATNR_CANCELLATION)
1723	const_iv (ATNR_DEPLETE)
1724	const_iv (ATNR_DEATH)
1725	const_iv (ATNR_CHAOS)
1726	const_iv (ATNR_COUNTERSPELL)
1727	const_iv (ATNR_GODPOWER)
1728	const_iv (ATNR_HOLYWORD)
1729	const_iv (ATNR_BLIND)
1730	const_iv (ATNR_INTERNAL)
1731	const_iv (ATNR_LIFE_STEALING)
1732	const_iv (ATNR_DISEASE)
1733		1261
1734	const_iv (MAP_FLUSH)	1262	const_iv (MAP_IN_MEMORY) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)
1735	const_iv (MAP_PLAYER_UNIQUE)
1736	const_iv (MAP_BLOCK)
1737	const_iv (MAP_STYLE)
1738	const_iv (MAP_OVERLAY)
1739		1263
1740	const_iv (MAP_IN_MEMORY)	1264	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)
1741	const_iv (MAP_SWAPPED)	1265	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)
1742	const_iv (MAP_LOADING)
1743	const_iv (MAP_SAVING)
1744		1266
1745	const_iv (KLASS_ATTACHABLE)	1267	const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)
1746	const_iv (KLASS_GLOBAL)
1747	const_iv (KLASS_OBJECT)
1748	const_iv (KLASS_CLIENT)
1749	const_iv (KLASS_PLAYER)
1750	const_iv (KLASS_MAP)
1751		1268
1752	const_iv (CS_QUERY_YESNO)	1269	const_iv (ST_DEAD) const_iv (ST_SETUP) const_iv (ST_PLAYING) const_iv (ST_CUSTOM)
1753	const_iv (CS_QUERY_SINGLECHAR)
1754	const_iv (CS_QUERY_HIDEINPUT)
1755
1756	const_iv (ST_DEAD)
1757	const_iv (ST_SETUP)
1758	const_iv (ST_PLAYING)
1759	const_iv (ST_CUSTOM)
1760		1270
1761	const_iv (ST_CHANGE_CLASS)	1271	const_iv (ST_CHANGE_CLASS)
1762	const_iv (ST_CONFIRM_QUIT)	1272
1763	const_iv (ST_GET_PARTY_PASSWORD)	1273	const_iv (IO_HEADER) const_iv (IO_OBJECTS) const_iv (IO_UNIQUES)
		1274
		1275	// random map generator
		1276	const_iv (LAYOUT_NONE) const_iv (LAYOUT_ONION) const_iv (LAYOUT_MAZE) const_iv (LAYOUT_SPIRAL)
		1277	const_iv (LAYOUT_ROGUELIKE) const_iv (LAYOUT_SNAKE) const_iv (LAYOUT_SQUARE_SPIRAL)
		1278
		1279	const_iv (RMOPT_RANDOM) const_iv (RMOPT_CENTERED) const_iv (RMOPT_LINEAR)
		1280	const_iv (RMOPT_BOTTOM_C) const_iv (RMOPT_BOTTOM_R) const_iv (RMOPT_IRR_SPACE)
		1281	const_iv (RMOPT_WALL_OFF) const_iv (RMOPT_WALLS_ONLY) const_iv (RMOPT_NO_DOORS)
		1282
		1283	const_iv (SYMMETRY_RANDOM) const_iv (SYMMETRY_NONE) const_iv (SYMMETRY_X)
		1284	const_iv (SYMMETRY_Y) const_iv (SYMMETRY_XY)
1764	};	1285	};
1765		1286
1766	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	1287	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1767	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));	1288	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1768		1289
…		…
1793		1314
1794	void _global_reattach ()	1315	void _global_reattach ()
1795	CODE:	1316	CODE:
1796	{	1317	{
1797	// reattach to all attachable objects in the game.	1318	// reattach to all attachable objects in the game.
1798	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)	1319	for_all_clients (ns)
1799	(*i)->reattach ();	1320	ns->reattach ();
1800		1321
1801	for (player *pl = first_player; pl; pl = pl->next)	1322	for_all_objects (op)
1802	pl->reattach ();
1803
1804	for (maptile *m = first_map; m; m = m->next)
1805	m->reattach ();
1806
1807	for (object *op = object::first; op; op = op->next)
1808	op->reattach ();	1323	op->reattach ();
1809	}	1324	}
1810		1325
		1326	void _post_tick ()
		1327	CODE:
		1328	coroapi::next_cede = SvNV (sv_next_tick) - TICK * (1. - 1. / CEDES_PER_TICK);
		1329
		1330	# support function for map-world.ext
		1331	void _quantise (SV *data_sv, SV *plt_sv)
		1332	CODE:
		1333	{
		1334	if (!SvROK (plt_sv) || SvTYPE (SvRV (plt_sv)) != SVt_PVAV)
		1335	croak ("_quantise called with invalid agruments");
		1336
		1337	plt_sv = SvRV (plt_sv);
		1338	SV **plt = AvARRAY (plt_sv);
		1339	int plt_count = AvFILL (plt_sv) + 1;
		1340
		1341	STRLEN len;
		1342	char *data = SvPVbyte (data_sv, len);
		1343	char *dst = data;
		1344
		1345	while (len >= 3)
		1346	{
		1347	for (SV **val_sv = plt + plt_count; val_sv-- > plt; )
		1348	{
		1349	char *val = SvPVX (*val_sv);
		1350
		1351	if (val [0] == data [0]
		1352	&& val [1] == data [1]
		1353	&& val [2] == data [2])
		1354	{
		1355	*dst++ = val [3];
		1356	goto next;
		1357	}
		1358	}
		1359
		1360	croak ("_quantise: color not found in palette: #%02x%02x%02x, at offset %d %d",
		1361	(uint8_t)data [0], (uint8_t)data [1], (uint8_t)data [2],
		1362	dst - SvPVX (data_sv), len);
		1363
		1364	next:
		1365	data += 3;
		1366	len -= 3;
		1367	}
		1368
		1369	SvCUR_set (data_sv, dst - SvPVX (data_sv));
		1370	}
		1371
1811	NV floor (NV x)	1372	NV floor (NV x)
1812		1373
1813	NV ceil (NV x)	1374	NV ceil (NV x)
1814		1375
		1376	NV rndm (...)
		1377	CODE:
		1378	switch (items)
		1379	{
		1380	case 0: RETVAL = rndm (); break;
		1381	case 1: RETVAL = rndm (SvUV (ST (0))); break;
		1382	case 2: RETVAL = rndm (SvIV (ST (0)), SvIV (ST (1))); break;
		1383	default: croak ("cf::rndm requires none, one or two parameters."); break;
		1384	}
		1385	OUTPUT:
		1386	RETVAL
		1387
1815	void server_tick ()	1388	void server_tick ()
		1389	CODE:
		1390	runtime = SvNVx (sv_runtime);
		1391	server_tick ();
1816		1392
1817	void	1393	void
1818	LOG (int level, char *msg)	1394	LOG (int level, utf8_string msg)
1819	PROTOTYPE: $$	1395	PROTOTYPE: $$
1820	C_ARGS: (LogLevel)level, "%s", msg	1396	C_ARGS: (LogLevel)level, "%s", msg
1821		1397
1822	char *path_combine (char *base, char *path)	1398	octet_string path_combine (octet_string base, octet_string path)
1823	PROTOTYPE: $$	1399	PROTOTYPE: $$
1824		1400
1825	char *path_combine_and_normalize (char *base, char *path)	1401	octet_string path_combine_and_normalize (octet_string base, octet_string path)
1826	PROTOTYPE: $$	1402	PROTOTYPE: $$
1827		1403
1828	const char *	1404	const_octet_string
1829	get_maps_directory (char *path)	1405	get_maps_directory (octet_string path)
1830	PROTOTYPE: $	1406	PROTOTYPE: $
1831	ALIAS: maps_directory = 0	1407	ALIAS: maps_directory = 0
1832	CODE:	1408	CODE:
1833	RETVAL = create_pathname (path);	1409	RETVAL = create_pathname (path);
1834	OUTPUT: RETVAL	1410	OUTPUT: RETVAL
…		…
1836	void	1412	void
1837	sub_generation_inc ()	1413	sub_generation_inc ()
1838	CODE:	1414	CODE:
1839	PL_sub_generation++;	1415	PL_sub_generation++;
1840		1416
1841	char *	1417	const_octet_string
1842	mapdir ()	1418	mapdir ()
1843	PROTOTYPE:	1419	PROTOTYPE:
1844	ALIAS:	1420	ALIAS:
1845	mapdir = 0	1421	mapdir = 0
1846	uniquedir = 1	1422	uniquedir = 1
…		…
1860	case 5: RETVAL = settings.playerdir; break;	1436	case 5: RETVAL = settings.playerdir; break;
1861	case 6: RETVAL = settings.datadir ; break;	1437	case 6: RETVAL = settings.datadir ; break;
1862	}	1438	}
1863	OUTPUT: RETVAL	1439	OUTPUT: RETVAL
1864		1440
		1441	void abort ()
		1442
		1443	void fork_abort (octet_string cause = "cf::fork_abort")
		1444
		1445	void cleanup (octet_string cause, bool make_core = false)
		1446
		1447	void emergency_save ()
		1448
1865	void _exit (int status = 0)	1449	void _exit (int status = EXIT_SUCCESS)
1866		1450
		1451	UV sv_2watcher (SV *w)
		1452	CODE:
		1453	RETVAL = (UV)GEventAPI->sv_2watcher (w);
		1454	OUTPUT:
		1455	RETVAL
		1456
		1457	#if _POSIX_MEMLOCK
		1458
		1459	int mlockall (int flags = MCL_CURRENT | MCL_FUTURE)
		1460
		1461	int munlockall ()
		1462
		1463	#endif
		1464
1867	int find_animation (char *text)	1465	int find_animation (utf8_string text)
1868	PROTOTYPE: $	1466	PROTOTYPE: $
1869		1467
1870	int random_roll (int min, int max, object *op, int goodbad);	1468	int random_roll (int min, int max, object *op, int goodbad);
1871		1469
1872	const char *cost_string_from_value(uint64 cost, int approx = 0)	1470	const_utf8_string cost_string_from_value(uint64 cost, int approx = 0)
1873		1471
1874	int	1472	int
1875	exp_to_level (val64 exp)	1473	exp_to_level (val64 exp)
1876	CODE:	1474	CODE:
1877	{	1475	{
…		…
1908	RETVAL = newSVpv (resist_plus[atnr], 0);	1506	RETVAL = newSVpv (resist_plus[atnr], 0);
1909	else	1507	else
1910	XSRETURN_UNDEF;	1508	XSRETURN_UNDEF;
1911	OUTPUT: RETVAL	1509	OUTPUT: RETVAL
1912		1510
		1511	bool
		1512	load_resource_file (octet_string filename)
		1513
1913	MODULE = cf PACKAGE = cf::attachable	1514	MODULE = cf PACKAGE = cf::attachable
1914		1515
1915	int	1516	int
1916	valid (SV *obj)	1517	valid (SV *obj)
1917	CODE:	1518	CODE:
1918	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);	1519	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
1919	OUTPUT:	1520	OUTPUT:
1920	RETVAL	1521	RETVAL
		1522
		1523	void
		1524	debug_trace (attachable *obj, bool on = true)
		1525	CODE:
		1526	obj->flags &= ~attachable::F_DEBUG_TRACE;
		1527	if (on)
		1528	obj->flags |= attachable::F_DEBUG_TRACE;
		1529
		1530	int mortals_size ()
		1531	CODE:
		1532	RETVAL = attachable::mortals.size ();
		1533	OUTPUT: RETVAL
		1534
		1535	#object *mortals (U32 index)
		1536	# CODE:
		1537	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;
		1538	# OUTPUT: RETVAL
		1539
		1540	INCLUDE: $PERL $srcdir/genacc attachable ../include/cfperl.h |
1921		1541
1922	MODULE = cf PACKAGE = cf::global	1542	MODULE = cf PACKAGE = cf::global
1923		1543
1924	int invoke (SV *klass, int event, ...)	1544	int invoke (SV *klass, int event, ...)
1925	CODE:	1545	CODE:
…		…
1929	RETVAL = gbl_ev.invoke ((event_type)event, ARG_AV (av), DT_END);	1549	RETVAL = gbl_ev.invoke ((event_type)event, ARG_AV (av), DT_END);
1930	OUTPUT: RETVAL	1550	OUTPUT: RETVAL
1931		1551
1932	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_	1552	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
1933		1553
1934	INCLUDE: $PERL genacc object ../include/object.h |	1554	INCLUDE: $PERL $srcdir/genacc object ../include/object.h |
1935		1555
1936	int invoke (object *op, int event, ...)	1556	int invoke (object *op, int event, ...)
1937	CODE:	1557	CODE:
1938	if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");	1558	if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");
1939	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	1559	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
1941	RETVAL = op->invoke ((event_type)event, ARG_AV (av), DT_END);	1561	RETVAL = op->invoke ((event_type)event, ARG_AV (av), DT_END);
1942	OUTPUT: RETVAL	1562	OUTPUT: RETVAL
1943		1563
1944	SV *registry (object *op)	1564	SV *registry (object *op)
1945		1565
1946	void mortals ()	1566	int objects_size ()
1947	PPCODE:	1567	CODE:
1948	EXTEND (SP, object::mortals.size ());
1949	for (AUTODECL (i, object::mortals.begin ()); i != object::mortals.end (); ++i)
1950	PUSHs (to_sv (*i));
1951
1952	object *first ()
1953	CODE:
1954	RETVAL = object::first;	1568	RETVAL = objects.size ();
		1569	OUTPUT: RETVAL
		1570
		1571	object *objects (U32 index)
		1572	CODE:
		1573	RETVAL = index < objects.size () ? objects [index] : 0;
		1574	OUTPUT: RETVAL
		1575
		1576	int actives_size ()
		1577	CODE:
		1578	RETVAL = actives.size ();
		1579	OUTPUT: RETVAL
		1580
		1581	object *actives (U32 index)
		1582	CODE:
		1583	RETVAL = index < actives.size () ? actives [index] : 0;
1955	OUTPUT: RETVAL	1584	OUTPUT: RETVAL
1956		1585
1957	# missing properties	1586	# missing properties
1958		1587
1959	object *head (object *op)	1588	object *head (object *op)
1960	PROTOTYPE: $	1589	PROTOTYPE: $
1961	CODE:	1590	CODE:
1962	RETVAL = op->head ? op->head : op;	1591	RETVAL = op->head_ ();
1963	OUTPUT: RETVAL	1592	OUTPUT: RETVAL
1964		1593
1965	int is_head (object *op)	1594	int is_head (object *op)
1966	PROTOTYPE: $	1595	PROTOTYPE: $
1967	CODE:	1596	CODE:
1968	RETVAL = !op->head;	1597	RETVAL = op->head_ () == op;
1969	OUTPUT: RETVAL	1598	OUTPUT: RETVAL
1970		1599
1971	void	1600	void
1972	inv (object *obj)	1601	inv (object *obj)
1973	PROTOTYPE: $	1602	PROTOTYPE: $
…		…
1981	void	1610	void
1982	set_animation (object *op, int idx)	1611	set_animation (object *op, int idx)
1983	CODE:	1612	CODE:
1984	SET_ANIMATION (op, idx);	1613	SET_ANIMATION (op, idx);
1985		1614
1986	void	1615	int
1987	object::drain_stat ()	1616	num_animations (object *op)
		1617	CODE:
		1618	RETVAL = NUM_ANIMATIONS (op);
		1619	OUTPUT: RETVAL
1988		1620
1989	void
1990	object::drain_specific_stat (int stat)
1991
1992	void
1993	object::change_luck (int change)
1994
1995	void
1996	object::add_statbonus ()
1997
1998	void
1999	object::remove_statbonus ()
2000
2001	object *find_best_object_match (object *op, const char *match)	1621	object *find_best_object_match (object *op, utf8_string match)
2002		1622
2003	object *find_marked_object (object *op)	1623	object *find_marked_object (object *op)
2004		1624
2005	int need_identify (object *obj);	1625	int need_identify (object *obj);
2006		1626
2007	int apply_shop_mat (object *shop_mat, object *op);	1627	int apply_shop_mat (object *shop_mat, object *op);
		1628
		1629	int move_player (object *op, int dir)
		1630	CODE:
		1631	RETVAL = move_player (op, dir);
		1632	OUTPUT:
		1633	RETVAL
2008		1634
2009	int move (object *op, int dir, object *originator = op)	1635	int move (object *op, int dir, object *originator = op)
2010	CODE:	1636	CODE:
2011	RETVAL = move_ob (op, dir, originator);	1637	RETVAL = move_ob (op, dir, originator);
2012	OUTPUT:	1638	OUTPUT:
…		…
2018		1644
2019	void apply_below (object *op)	1645	void apply_below (object *op)
2020	CODE:	1646	CODE:
2021	player_apply_below (op);	1647	player_apply_below (op);
2022		1648
2023	void remove (object *op)	1649	int cast_heal (object *op, object *caster, object *spell, int dir = 0)
2024	CODE:
2025	op->remove ();
2026		1650
2027	void
2028	object::destroy (bool destroy_inventory = false)
2029
2030	void
2031	object::destroy_inv (bool drop_to_ground = false)
2032
2033	object *cf_object_present_archname_inside (object *op, char *whatstr)	1651	object *cf_object_present_archname_inside (object *op, utf8_string whatstr)
2034		1652
2035	int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)	1653	int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)
2036		1654
2037	int cf_object_change_map (object *op, int x, int y, maptile *map)	1655	int cf_object_change_map (object *op, int x, int y, maptile *map)
2038		1656
		1657	#//TODO
2039	object *clone (object *op, int recursive = 0)	1658	object *clone_ (object *op, int recursive = 0)
2040	CODE:	1659	CODE:
2041	if (recursive)	1660	if (recursive)
2042	RETVAL = object_create_clone (op);	1661	RETVAL = object_create_clone (op);
2043	else	1662	else
2044	{	1663	{
…		…
2057	RETVAL = pay_for_amount (amount, op);	1676	RETVAL = pay_for_amount (amount, op);
2058	OUTPUT: RETVAL	1677	OUTPUT: RETVAL
2059		1678
2060	void pay_player (object *op, uint64 amount)	1679	void pay_player (object *op, uint64 amount)
2061		1680
2062	val64 pay_player_arch (object *op, const char *arch, uint64 amount)	1681	val64 pay_player_arch (object *op, utf8_string arch, uint64 amount)
2063		1682
2064	int cast_spell (object *op, object *caster, int dir, object *spell_ob, char *stringarg = 0)	1683	int cast_spell (object *op, object *caster, int dir, object *spell_ob, utf8_string stringarg = 0)
2065		1684
2066	void learn_spell (object *op, object *sp, int special_prayer = 0)	1685	void learn_spell (object *op, object *sp, int special_prayer = 0)
2067	CODE:	1686	CODE:
2068	do_learn_spell (op, sp, special_prayer);	1687	do_learn_spell (op, sp, special_prayer);
2069		1688
2070	void forget_spell (object *op, object *sp)	1689	void forget_spell (object *op, object *sp)
2071	CODE:	1690	CODE:
2072	do_forget_spell (op, query_name (sp));	1691	do_forget_spell (op, query_name (sp));
2073		1692
2074	object *check_for_spell (object *op, char *spellname)	1693	object *check_for_spell (object *op, utf8_string spellname)
2075	CODE:	1694	CODE:
2076	RETVAL = check_spell_known (op, spellname);	1695	RETVAL = check_spell_known (op, spellname);
2077	OUTPUT: RETVAL	1696	OUTPUT: RETVAL
2078		1697
2079	int query_money (object *op)	1698	int query_money (object *op)
…		…
2088		1707
2089	void drop (object *who, object *op)	1708	void drop (object *who, object *op)
2090		1709
2091	void pick_up (object *who, object *op)	1710	void pick_up (object *who, object *op)
2092		1711
2093	object *cf_object_insert_object (object *op, object *container)
2094
2095	object *cf_object_insert_in_ob (object *ob, object *where)
2096
2097	int cf_object_teleport (object *op, maptile *map, int x, int y)	1712	int cf_object_teleport (object *op, maptile *map, int x, int y)
2098		1713
2099	void update_object (object *op, int action)	1714	void update_object (object *op, int action)
2100		1715
2101	object *cf_create_object_by_name (const char *name)	1716	object *cf_create_object_by_name (utf8_string name)
2102		1717
2103	void change_exp (object *op, uint64 exp, const char *skill_name = 0, int flag = 0)	1718	void change_exp (object *op, uint64 exp, utf8_string skill_name = 0, int flag = 0)
2104		1719
2105	void player_lvl_adj (object *who, object *skill = 0)	1720	void player_lvl_adj (object *who, object *skill = 0)
2106		1721
2107	int kill_object (object *op, int dam = 0, object *hitter = 0, int type = AT_PHYSICAL)	1722	int kill_object (object *op, int dam = 0, object *hitter = 0, int type = AT_PHYSICAL)
2108		1723
…		…
2122	object *cf_insert_ob_in_ob (object *ob, object *where)	1737	object *cf_insert_ob_in_ob (object *ob, object *where)
2123		1738
2124	# no clean way to get an object from an archetype - stupid idiotic	1739	# no clean way to get an object from an archetype - stupid idiotic
2125	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.	1740	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.
2126		1741
2127	object *new (const char *archetype = 0)	1742	object *new (utf8_string archetype = 0)
2128	PROTOTYPE: ;$	1743	PROTOTYPE: ;$
2129	CODE:	1744	CODE:
2130	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();	1745	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();
2131	OUTPUT:	1746	OUTPUT:
2132	RETVAL	1747	RETVAL
…		…
2137	{	1752	{
2138	int unused_type;	1753	int unused_type;
2139	RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);	1754	RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);
2140	}	1755	}
2141		1756
2142	# syntatic sugar for easier use in event callbacks.
2143	const char *options (object *op)
2144	CODE:
2145	RETVAL = op->name;
2146	OUTPUT:
2147	RETVAL
2148
2149	player *contr (object *op)	1757	player *contr (object *op)
2150	CODE:	1758	CODE:
2151	RETVAL = op->contr;	1759	RETVAL = op->contr;
2152	OUTPUT: RETVAL	1760	OUTPUT: RETVAL
2153		1761
2154	void	1762	const_utf8_string get_ob_key_value (object *op, utf8_string key)
2155	object::roll_stats ()
2156		1763
2157	void
2158	object::update_stats ()
2159
2160	void
2161	object::swap_stats (int a, int b)
2162
2163	const char *get_ob_key_value (object *op, const char *key)
2164
2165	bool set_ob_key_value (object *op, const char *key, const char *value = 0, int add_key = 1)	1764	bool set_ob_key_value (object *op, utf8_string key, utf8_string value = 0, int add_key = 1)
2166		1765
2167	object *get_nearest_player (object *ob)	1766	object *get_nearest_player (object *ob)
2168	ALIAS: nearest_player = 0	1767	ALIAS: nearest_player = 0
2169	PREINIT:	1768	PREINIT:
2170	extern object *get_nearest_player (object *);	1769	extern object *get_nearest_player (object *);
…		…
2186	bool on_same_map_as (object *ob, object *other)	1785	bool on_same_map_as (object *ob, object *other)
2187	CODE:	1786	CODE:
2188	RETVAL = on_same_map (ob, other);	1787	RETVAL = on_same_map (ob, other);
2189	OUTPUT: RETVAL	1788	OUTPUT: RETVAL
2190		1789
2191	const char *	1790	const_utf8_string
2192	base_name (object *op, int plural = op->nrof > 1)	1791	base_name (object *op, int plural = op->nrof > 1)
2193	CODE:	1792	CODE:
2194	RETVAL = query_base_name (op, plural);	1793	RETVAL = query_base_name (op, plural);
2195	OUTPUT: RETVAL	1794	OUTPUT: RETVAL
2196		1795
…		…
2203	RETVAL = op->contr;	1802	RETVAL = op->contr;
2204	OUTPUT: RETVAL	1803	OUTPUT: RETVAL
2205		1804
2206	void check_score (object *op)	1805	void check_score (object *op)
2207		1806
2208	void cf_player_message (object *obj, char *txt, int flags = NDI_ORANGE | NDI_UNIQUE)	1807	void message (object *op, utf8_string txt, int flags = NDI_ORANGE | NDI_UNIQUE)
		1808	CODE:
		1809	new_draw_info (flags, 0, op, txt);
2209		1810
2210	object *cf_player_send_inventory (object *op)	1811	object *cf_player_send_inventory (object *op)
2211		1812
2212	char *cf_player_get_ip (object *op)	1813	octet_string cf_player_get_ip (object *op)
2213	ALIAS: ip = 0	1814	ALIAS: ip = 0
2214		1815
2215	object *cf_player_get_marked_item (object *op)	1816	object *cf_player_get_marked_item (object *op)
2216	ALIAS: marked_item = 0	1817	ALIAS: marked_item = 0
2217		1818
…		…
2227	void esrv_update_item (object *op, int what, object *item)	1828	void esrv_update_item (object *op, int what, object *item)
2228	C_ARGS: what, op, item	1829	C_ARGS: what, op, item
2229		1830
2230	void clear_los (object *op)	1831	void clear_los (object *op)
2231		1832
2232	int command_reset (object *op, char *params)
2233
2234	int command_teleport (object *op, char *params)
2235
2236	int command_summon (object *op, char *params)	1833	int command_summon (object *op, utf8_string params)
2237		1834
2238	int command_arrest (object *op, char *params)	1835	int command_arrest (object *op, utf8_string params)
2239
2240	int command_kick (object *op, char *params)
2241
2242	int command_banish (object *op, char *params)
2243		1836
2244		1837
2245	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_	1838	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
2246		1839
2247	INCLUDE: $PERL genacc player ../include/player.h |	1840	INCLUDE: $PERL $srcdir/genacc player ../include/player.h |
2248		1841
2249	int invoke (player *pl, int event, ...)	1842	int invoke (player *pl, int event, ...)
2250	CODE:	1843	CODE:
2251	if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");	1844	if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");
2252	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	1845	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
2254	RETVAL = pl->invoke ((event_type)event, ARG_AV (av), DT_END);	1847	RETVAL = pl->invoke ((event_type)event, ARG_AV (av), DT_END);
2255	OUTPUT: RETVAL	1848	OUTPUT: RETVAL
2256		1849
2257	SV *registry (player *pl)	1850	SV *registry (player *pl)
2258		1851
2259	player *
2260	create ()
2261	CODE:
2262	RETVAL = player::create ();
2263	OUTPUT:
2264	RETVAL
2265
2266	player *
2267	load (const char *path)
2268	CODE:
2269	RETVAL = player::load (path);
2270	OUTPUT:
2271	RETVAL
2272
2273	void
2274	player::save (bool final = false)
2275
2276	void
2277	player::connect (client *ns)
2278
2279	void	1852	void
2280	save_stats (player *pl)	1853	save_stats (player *pl)
2281	CODE:	1854	CODE:
2282	pl->ob->stats.hp = pl->ob->stats.maxhp;	1855	pl->ob->stats.hp = pl->ob->stats.maxhp;
2283	pl->ob->stats.sp = pl->ob->stats.maxsp;	1856	pl->ob->stats.sp = pl->ob->stats.maxsp;
2284	pl->ob->stats.grace = pl->ob->stats.maxgrace;	1857	pl->ob->stats.grace = pl->ob->stats.maxgrace;
2285	pl->orig_stats = pl->ob->stats;	1858	pl->orig_stats = pl->ob->stats;
2286		1859
2287	player *cf_player_find (char *name)
2288	PROTOTYPE: $
2289
2290	void cf_player_move (player *pl, int dir)	1860	void cf_player_move (player *pl, int dir)
2291		1861
2292	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);	1862	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);
2293
2294	player *first ()
2295	CODE:
2296	RETVAL = first_player;
2297	OUTPUT: RETVAL
2298		1863
2299	bool	1864	bool
2300	cell_visible (player *pl, int dx, int dy)	1865	cell_visible (player *pl, int dx, int dy)
2301	CODE:	1866	CODE:
2302	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2	1867	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2
…		…
2339	if (y) sv_to (y, pl->bed_y);	1904	if (y) sv_to (y, pl->bed_y);
2340		1905
2341	void	1906	void
2342	list ()	1907	list ()
2343	PPCODE:	1908	PPCODE:
2344	for (player *pl = first_player; pl; pl = pl->next)	1909	for_all_players (pl)
2345	XPUSHs (sv_2mortal (to_sv (pl)));	1910	XPUSHs (sv_2mortal (to_sv (pl)));
2346		1911
2347	bool
2348	peaceful (player *pl, bool new_setting = 0)
2349	PROTOTYPE: $;$
2350	CODE:
2351	RETVAL = pl->peaceful;
2352	if (items > 1)
2353	pl->peaceful = new_setting;
2354	OUTPUT:
2355	RETVAL
2356
2357	living *
2358	orig_stats (player *pl)
2359	CODE:
2360	RETVAL = &pl->orig_stats;
2361	OUTPUT: RETVAL
2362
2363	living *
2364	last_stats (player *pl)
2365	CODE:
2366	RETVAL = &pl->last_stats;
2367	OUTPUT: RETVAL
2368
2369		1912
2370	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_	1913	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_
2371
2372	maptile *first ()
2373	PROTOTYPE:
2374	CODE:
2375	RETVAL = first_map;
2376	OUTPUT: RETVAL
2377		1914
2378	int invoke (maptile *map, int event, ...)	1915	int invoke (maptile *map, int event, ...)
2379	CODE:	1916	CODE:
2380	if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");	1917	if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");
2381	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	1918	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
2383	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);	1920	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);
2384	OUTPUT: RETVAL	1921	OUTPUT: RETVAL
2385		1922
2386	SV *registry (maptile *map)	1923	SV *registry (maptile *map)
2387		1924
2388	INCLUDE: $PERL genacc maptile ../include/map.h |	1925	INCLUDE: $PERL $srcdir/genacc maptile ../include/map.h |
2389		1926
2390	maptile *new (int width, int height)	1927	void
		1928	maptile::instantiate ()
		1929
		1930	maptile *new ()
2391	PROTOTYPE:	1931	PROTOTYPE:
2392	CODE:	1932	CODE:
2393	{	1933	RETVAL = new maptile;
2394	RETVAL = get_empty_map (width, height);
2395	}
2396	OUTPUT:	1934	OUTPUT:
2397	RETVAL	1935	RETVAL
2398		1936
2399	void delete_map (maptile *map)	1937	void
		1938	maptile::players ()
		1939	PPCODE:
		1940	if (GIMME_V == G_SCALAR)
		1941	XPUSHs (sv_2mortal (to_sv (THIS->players)));
		1942	else if (GIMME_V == G_ARRAY)
		1943	{
		1944	EXTEND (SP, THIS->players);
		1945	for_all_players (pl)
		1946	if (pl->ob && pl->ob->map == THIS)
		1947	PUSHs (sv_2mortal (to_sv (pl->ob)));
		1948	}
2400		1949
2401	void clean_tmp_map (maptile *map)	1950	void
		1951	maptile::add_underlay (SV *data, int offset, int stride, SV *palette)
		1952	CODE:
		1953	{
		1954	if (!SvROK (palette) || SvTYPE (SvRV (palette)) != SVt_PVAV)
		1955	croak ("maptile::add_underlay: palette must be arrayref");
		1956
		1957	palette = SvRV (palette);
		1958
		1959	STRLEN idxlen;
		1960	const uint8_t *idx = (const uint8_t *)SvPVbyte (data, idxlen);
		1961
		1962	for (int x = 0; x < THIS->width; ++x)
		1963	for (int y = 0; y < THIS->height; ++y)
		1964	{
		1965	for (object *op = THIS->at (x, y).bot; op; op = op->above)
		1966	if (op->flag [FLAG_IS_FLOOR])
		1967	goto skip_space;
		1968
		1969	{
		1970	int offs = offset + y * stride + x;
		1971	if (IN_RANGE_EXC (offs, 0, idxlen))
		1972	{
		1973	if (SV **elem = av_fetch ((AV *)palette, idx [offs], 0))
		1974	{
		1975	object *ob = get_archetype (SvPVutf8_nolen (*elem));
		1976	ob->flag [FLAG_NO_MAP_SAVE] = true;
		1977	THIS->insert (ob, x, y, 0, INS_ABOVE_FLOOR_ONLY);
		1978	}
		1979	}
		1980	}
		1981
		1982	skip_space: ;
		1983	}
		1984	}
		1985
		1986	void
		1987	maptile::set_regiondata (SV *data, int offset, int stride, SV *palette)
		1988	CODE:
		1989	{
		1990	if (!SvROK (palette) || SvTYPE (SvRV (palette)) != SVt_PVAV)
		1991	croak ("maptile::set_regiondata: palette must be arrayref");
		1992
		1993	palette = SvRV (palette);
		1994
		1995	STRLEN idxlen;
		1996	const uint8_t *idx = (const uint8_t *)SvPVbyte (data, idxlen);
		1997
		1998	region **regionmap = (region **)malloc (
		1999	(av_len ((AV *)palette) + 1) * sizeof (region *));
		2000	uint8_t *regions = salloc<uint8_t> (THIS->size ());
		2001
		2002	for (int i = av_len ((AV *)palette) + 1; i--; )
		2003	regionmap [i] = region::find (
		2004	SvPVutf8_nolen (*av_fetch ((AV *)palette, i, 1)));
		2005
		2006	for (int y = 0; y < THIS->height; ++y)
		2007	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);
		2008
		2009	sfree (THIS->regions, THIS->size ());
		2010	free (THIS->regionmap);
		2011
		2012	THIS->regions = regions;
		2013	THIS->regionmap = regionmap;
		2014	}
		2015
		2016	void
		2017	maptile::create_region_treasure ()
		2018	CODE:
		2019	{
		2020	object *op = object::create ();
		2021	op->type = FLOOR;
		2022	op->map = THIS;
		2023
		2024	for (int x = 0; x < THIS->width; ++x)
		2025	for (int y = 0; y < THIS->height; ++y)
		2026	{
		2027	region *rgn = THIS->region (x, y);
		2028
		2029	//fprintf (stderr, "%d,%d %f %p\n", x, y, rgn->treasure_density,rgn->treasure);//D
		2030	if (rgn->treasure && rndm () < rgn->treasure_density)
		2031	{
		2032	op->x = x;
		2033	op->y = y;
		2034	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);
		2035	}
		2036	}
		2037
		2038	op->destroy ();
		2039	}
2402		2040
2403	void play_sound_map (maptile *map, int x, int y, int sound_num)	2041	void play_sound_map (maptile *map, int x, int y, int sound_num)
2404		2042
2405	int out_of_map (maptile *map, int x, int y)	2043	int out_of_map (maptile *map, int x, int y)
2406
2407	maptile *tile_map (maptile *map, unsigned int dir)
2408	CODE:
2409	RETVAL = dir < 4 ? map->tile_map [dir] : 0;
2410	OUTPUT:
2411	RETVAL
2412
2413	char *tile_path (maptile *map, unsigned int dir)
2414	CODE:
2415	if (dir >= 4)
2416	XSRETURN_UNDEF;
2417	RETVAL = map->tile_path [dir];
2418	OUTPUT:
2419	RETVAL
2420
2421	maptile *ready_map_name (char *name, int flags = 0)
2422	PROTOTYPE: $;$
2423	ALIAS:
2424	find = 0
2425	get_map = 1
2426
2427	maptile *has_been_loaded (char *name)
2428	PROTOTYPE: $
2429
2430	int in_memory (maptile *map)
2431	CODE:
2432	RETVAL = map->in_memory;
2433	OUTPUT:
2434	RETVAL
2435		2044
2436	void	2045	void
2437	trigger (maptile *map, long connection, bool state = true)	2046	trigger (maptile *map, long connection, bool state = true)
2438	CODE:	2047	CODE:
2439	activate_connection (map, connection, state);	2048	activate_connection (map, connection, state);
…		…
2452		2061
2453	object* cf_map_present_arch_by_name (maptile *map, const char* str, int nx, int ny)	2062	object* cf_map_present_arch_by_name (maptile *map, const char* str, int nx, int ny)
2454	C_ARGS: str, map, nx, ny	2063	C_ARGS: str, map, nx, ny
2455		2064
2456	void	2065	void
2457	cf_map_normalise (maptile *map, int x, int y)	2066	get_map_flags (maptile *map, int x, int y)
2458	PPCODE:	2067	PPCODE:
2459	{	2068	{
2460	maptile *nmap = 0;	2069	maptile *nmap = 0;
2461	I16 nx = 0, ny = 0;	2070	I16 nx = 0, ny = 0;
2462	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);	2071	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
…		…
2511	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;	2120	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;
2512	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;	2121	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;
2513	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;	2122	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;
2514	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;	2123	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;
2515	}	2124	}
2516	OUTPUT:	2125	OUTPUT: RETVAL
		2126
		2127	void fix_walls (maptile *map, int x, int y)
		2128
		2129	void fix_walls_around (maptile *map, int x, int y)
		2130
		2131	# worst xs function of my life
		2132	bool
		2133	_create_random_map (\
		2134	maptile *self,\
		2135	utf8_string wallstyle,\
		2136	utf8_string wall_name,\
		2137	utf8_string floorstyle,\
		2138	utf8_string monsterstyle,\
		2139	utf8_string treasurestyle,\
		2140	utf8_string layoutstyle,\
		2141	utf8_string doorstyle,\
		2142	utf8_string decorstyle,\
		2143	utf8_string origin_map,\
		2144	utf8_string final_map,\
		2145	utf8_string exitstyle,\
		2146	utf8_string this_map,\
		2147	utf8_string exit_on_final_map,\
		2148	int xsize,\
		2149	int ysize,\
		2150	int expand2x,\
		2151	int layoutoptions1,\
		2152	int layoutoptions2,\
		2153	int layoutoptions3,\
		2154	int symmetry,\
		2155	int difficulty,\
		2156	int difficulty_given,\
		2157	float difficulty_increase,\
		2158	int dungeon_level,\
		2159	int dungeon_depth,\
		2160	int decoroptions,\
		2161	int orientation,\
		2162	int origin_y,\
		2163	int origin_x,\
		2164	U32 random_seed,\
		2165	val64 total_map_hp,\
		2166	int map_layout_style,\
		2167	int treasureoptions,\
		2168	int symmetry_used,\
		2169	region *region,\
		2170	utf8_string custom\
		2171	)
		2172	CODE:
		2173	{
		2174	random_map_params rmp;
		2175
		2176	assign (rmp.wallstyle , wallstyle);
		2177	assign (rmp.wall_name , wall_name);
		2178	assign (rmp.floorstyle , floorstyle);
		2179	assign (rmp.monsterstyle , monsterstyle);
		2180	assign (rmp.treasurestyle , treasurestyle);
		2181	assign (rmp.layoutstyle , layoutstyle);
		2182	assign (rmp.doorstyle , doorstyle);
		2183	assign (rmp.decorstyle , decorstyle);
		2184	assign (rmp.exitstyle , exitstyle);
		2185	assign (rmp.exit_on_final_map, exit_on_final_map);
		2186
		2187	rmp.origin_map = origin_map;
		2188	rmp.final_map = final_map;
		2189	rmp.this_map = this_map;
		2190	rmp.xsize = xsize;
		2191	rmp.ysize = ysize;
		2192	rmp.expand2x = expand2x;
		2193	rmp.layoutoptions1 = layoutoptions1;
		2194	rmp.layoutoptions2 = layoutoptions2;
		2195	rmp.layoutoptions3 = layoutoptions3;
		2196	rmp.symmetry = symmetry;
		2197	rmp.difficulty = difficulty;
		2198	rmp.difficulty_given = difficulty_given;
		2199	rmp.difficulty_increase = difficulty_increase;
		2200	rmp.dungeon_level = dungeon_level;
		2201	rmp.dungeon_depth = dungeon_depth;
		2202	rmp.decoroptions = decoroptions;
		2203	rmp.orientation = orientation;
		2204	rmp.origin_y = origin_y;
		2205	rmp.origin_x = origin_x;
		2206	rmp.random_seed = random_seed;
		2207	rmp.total_map_hp = total_map_hp;
		2208	rmp.map_layout_style = map_layout_style;
		2209	rmp.treasureoptions = treasureoptions;
		2210	rmp.symmetry_used = symmetry_used;
		2211	rmp.region = region;
		2212	rmp.custom = custom;
		2213
		2214	RETVAL = self->generate_random_map (&rmp);
		2215	}
		2216	OUTPUT:
2517	RETVAL	2217	RETVAL
2518		2218
2519	void fix_walls (maptile *map, int x, int y)
2520
2521	void fix_walls_around (maptile *map, int x, int y)
2522
2523	MODULE = cf PACKAGE = cf::arch	2219	MODULE = cf PACKAGE = cf::arch
2524		2220
2525	archetype *find (const char *name)	2221	archetype *find (utf8_string name)
2526	CODE:	2222	CODE:
2527	RETVAL = archetype::find (name);	2223	RETVAL = archetype::find (name);
2528	OUTPUT:	2224	OUTPUT:
2529	RETVAL	2225	RETVAL
2530		2226
…		…
2532	PROTOTYPE:	2228	PROTOTYPE:
2533	CODE:	2229	CODE:
2534	RETVAL = first_archetype;	2230	RETVAL = first_archetype;
2535	OUTPUT: RETVAL	2231	OUTPUT: RETVAL
2536		2232
2537	INCLUDE: $PERL genacc archetype ../include/object.h |	2233	INCLUDE: $PERL $srcdir/genacc archetype ../include/object.h |
2538		2234
2539	MODULE = cf PACKAGE = cf::party	2235	MODULE = cf PACKAGE = cf::party
2540		2236
2541	partylist *first ()	2237	partylist *first ()
2542	PROTOTYPE:	2238	PROTOTYPE:
2543	CODE:	2239	CODE:
2544	RETVAL = get_firstparty ();	2240	RETVAL = get_firstparty ();
2545	OUTPUT: RETVAL	2241	OUTPUT: RETVAL
2546		2242
2547	partylist *next (partylist *party)	2243	INCLUDE: $PERL $srcdir/genacc partylist ../include/player.h |
		2244
		2245	MODULE = cf PACKAGE = cf::region
		2246
		2247	void
		2248	list ()
		2249	PPCODE:
		2250	for_all_regions (rgn)
		2251	XPUSHs (sv_2mortal (to_sv (rgn)));
		2252
		2253	region *find (utf8_string name)
		2254	PROTOTYPE: $
2548	CODE:	2255	CODE:
2549	RETVAL = party->next;	2256	RETVAL = region::find (name);
2550	OUTPUT: RETVAL	2257	OUTPUT: RETVAL
2551		2258
2552	const char *name (partylist *party)	2259	region *find_fuzzy (utf8_string name)
		2260	PROTOTYPE: $
2553	CODE:	2261	CODE:
2554	RETVAL = party->partyname;	2262	RETVAL = region::find_fuzzy (name);
2555	OUTPUT: RETVAL	2263	OUTPUT: RETVAL
2556		2264
2557	const char *password (partylist *party)	2265	int specificity (region *rgn)
2558	CODE:	2266	CODE:
2559	RETVAL = party->passwd;	2267	RETVAL = 0;
		2268	while (rgn = rgn->parent)
		2269	RETVAL++;
2560	OUTPUT: RETVAL	2270	OUTPUT: RETVAL
2561		2271
2562	MODULE = cf PACKAGE = cf::region	2272	INCLUDE: $PERL $srcdir/genacc region ../include/region.h |
2563
2564	region *first ()
2565	PROTOTYPE:
2566	CODE:
2567	RETVAL = first_region;
2568	OUTPUT: RETVAL
2569
2570	region *next (region *reg)
2571	CODE:
2572	RETVAL = reg->next;
2573	OUTPUT: RETVAL
2574
2575	const char *name (region *reg)
2576	CODE:
2577	RETVAL = reg->name;
2578	OUTPUT: RETVAL
2579
2580	region *parent (region *reg)
2581	CODE:
2582	RETVAL = reg->parent;
2583	OUTPUT: RETVAL
2584
2585	const char *longname (region *reg)
2586	CODE:
2587	RETVAL = reg->longname;
2588	OUTPUT: RETVAL
2589
2590	const char *msg (region *reg)
2591	CODE:
2592	RETVAL = reg->msg;
2593	OUTPUT: RETVAL
2594		2273
2595	MODULE = cf PACKAGE = cf::living	2274	MODULE = cf PACKAGE = cf::living
2596		2275
2597	INCLUDE: $PERL genacc living ../include/living.h |	2276	INCLUDE: $PERL $srcdir/genacc living ../include/living.h |
2598		2277
2599	MODULE = cf PACKAGE = cf::settings	2278	MODULE = cf PACKAGE = cf::settings
2600		2279
2601	INCLUDE: $PERL genacc Settings ../include/global.h |	2280	INCLUDE: $PERL $srcdir/genacc Settings ../include/global.h |
2602		2281
2603	MODULE = cf PACKAGE = cf::client	2282	MODULE = cf PACKAGE = cf::client
2604		2283
2605	INCLUDE: $PERL genacc client ../include/client.h |	2284	INCLUDE: $PERL $srcdir/genacc client ../include/client.h |
2606		2285
2607	int invoke (client *ns, int event, ...)	2286	int invoke (client *ns, int event, ...)
2608	CODE:	2287	CODE:
2609	if (KLASS_OF (event) != KLASS_CLIENT) croak ("event class must be CLIENT");	2288	if (KLASS_OF (event) != KLASS_CLIENT) croak ("event class must be CLIENT");
2610	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	2289	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
2619	PPCODE:	2298	PPCODE:
2620	EXTEND (SP, clients.size ());	2299	EXTEND (SP, clients.size ());
2621	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)	2300	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
2622	PUSHs (sv_2mortal (to_sv (*i)));	2301	PUSHs (sv_2mortal (to_sv (*i)));
2623		2302
2624	client *
2625	create (int fd, const char *peername)
2626	CODE:
2627	RETVAL = client::create (fd, peername);
2628	OUTPUT:
2629	RETVAL
2630
2631	void	2303	void
2632	client::send_packet (SV *packet)	2304	client::send_packet (SV *packet)
2633	CODE:	2305	CODE:
2634	{	2306	{
2635	STRLEN len;	2307	STRLEN len;
2636	char *buf = SvPVbyte (packet, len);	2308	char *buf = SvPVbyte (packet, len);
2637		2309
2638	THIS->send_packet (buf, len);	2310	THIS->send_packet (buf, len);
2639	}	2311	}
2640		2312
2641	void	2313	MODULE = cf PACKAGE = cf::face PREFIX = face_
2642	client::destroy ()
2643		2314
		2315	#INCLUDE: $PERL $srcdir/genacc faceset ../include/face.h |
		2316
		2317	faceidx face_find (utf8_string name, faceidx defidx = 0)
		2318
		2319	faceidx alloc (utf8_string name)
		2320	CODE:
		2321	{
		2322	do
		2323	{
		2324	RETVAL = faces.size ();
		2325	faces.resize (RETVAL + 1);
		2326	}
		2327	while (!RETVAL); // crude way to leave index 0
		2328
		2329	faces [RETVAL].name = name;
		2330	facehash.insert (std::make_pair (faces [RETVAL].name, RETVAL));
		2331
		2332	if (!strcmp (name, BLANK_FACE_NAME)) blank_face = RETVAL;
		2333	if (!strcmp (name, EMPTY_FACE_NAME)) empty_face = RETVAL;
		2334	}
		2335	OUTPUT: RETVAL
		2336
		2337	void set (faceidx idx, int visibility, int magicmap)
		2338	CODE:
		2339	faceinfo *f = face_info (idx);
		2340	assert (f);
		2341	f->visibility = visibility;
		2342	f->magicmap = magicmap;
		2343
		2344	void set_smooth (faceidx idx, faceidx smooth, int smoothlevel)
		2345	CODE:
		2346	faceinfo *f = face_info (idx); assert (f);
		2347	f->smooth = smooth;
		2348	f->smoothlevel = smoothlevel;
		2349
		2350	void set_data (faceidx idx, int faceset, SV *data, SV *chksum)
		2351	CODE:
		2352	{
		2353	facedata *d = face_data (idx, faceset);
		2354	assert (d);
		2355	sv_to (data, d->data);
		2356	STRLEN clen;
		2357	char *cdata = SvPVbyte (chksum, clen);
		2358	clen = min (CHKSUM_SIZE, clen);
		2359
		2360	if (memcmp (d->chksum, cdata, clen))
		2361	{
		2362	memcpy (d->chksum, cdata, clen);
		2363
		2364	// invalidate existing client face info
		2365	for_all_clients (ns)
		2366	if (ns->faceset == faceset)
		2367	{
		2368	ns->faces_sent [idx] = false;
		2369	ns->force_newmap = true;
		2370	}
		2371	}
		2372	}
		2373
		2374	void invalidate (faceidx idx)
		2375	CODE:
		2376	for_all_clients (ns)
		2377	{
		2378	ns->faces_sent [idx] = false;
		2379	ns->force_newmap = true;
		2380	}
		2381
		2382	void invalidate_all ()
		2383	CODE:
		2384	for_all_clients (ns)
		2385	{
		2386	ns->faces_sent.reset ();
		2387	ns->force_newmap = true;
		2388	}
		2389
		2390	MODULE = cf PACKAGE = cf::anim PREFIX = anim_
		2391
		2392	#INCLUDE: $PERL $srcdir/genacc faceset ../include/anim.h |
		2393
		2394	animidx anim_find (utf8_string name)
		2395	CODE:
		2396	RETVAL = animation::find (name).number;
		2397	OUTPUT: RETVAL
		2398
		2399	animidx set (utf8_string name, SV *frames, int facings = 1)
		2400	CODE:
		2401	{
		2402	if (!SvROK (frames) && SvTYPE (SvRV (frames)) != SVt_PVAV)
		2403	croak ("frames must be an arrayref");
		2404
		2405	AV *av = (AV *)SvRV (frames);
		2406
		2407	animation *anim = &animation::find (name);
		2408	if (anim->number)
		2409	{
		2410	anim->resize (av_len (av) + 1);
		2411	anim->facings = facings;
		2412	}
		2413	else
		2414	anim = &animation::create (name, av_len (av) + 1, facings);
		2415
		2416	for (int i = 0; i < anim->num_animations; ++i)
		2417	anim->faces [i] = face_find (SvPVutf8_nolen (*av_fetch (av, i, 1)));
		2418	}
		2419	OUTPUT: RETVAL
		2420
		2421	void invalidate_all ()
		2422	CODE:
		2423	for_all_clients (ns)
		2424	ns->anims_sent.reset ();
		2425

Diff Legend

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