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

Diff Legend

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