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.26 by elmex, Tue Aug 29 17:29:28 2006 UTC vs.
Revision 1.181 by root, Tue Apr 3 00:21:38 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@schmorpd.e>	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.
…		…
19	* GNU General Public License for more details.	19	* GNU General Public License for more details.
20	*	20	*
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
26	#include <EXTERN.h>
27	#include <perl.h>
28	#include <XSUB.h>
29
30	#undef save_long // clashes with libproto.h
31		25
32	#define PLUGIN_NAME "perl"	26	#define PLUGIN_NAME "perl"
33	#define PLUGIN_VERSION "cfperl 0.5"	27	#define PLUGIN_VERSION "cfperl 0.5"
34
35	#ifndef __CEXTRACT__
36	#include <plugin.h>
37	#endif
38
39	#undef MODULEAPI
40	#ifdef WIN32
41	#else
42	#define MODULEAPI
43	#endif
44		28
45	#include <plugin_common.h>	29	#include <plugin_common.h>
46	#include <sounds.h>	30	#include <sounds.h>
47	#include <cstdarg>	31	#include <cstdarg>
48	#include <sproto.h>	32	#include <sproto.h>
49		33
		34	#include "loader.h"
50	#include "cfperl.h"	35	#include "cfperl.h"
51	#include "shstr.h"	36	#include "shstr.h"
52		37
		38	#include <unistd.h>
		39	#if _POSIX_MEMLOCK
		40	# include <sys/mman.h>
		41	#endif
		42
		43	#include <EXTERN.h>
		44	#include <perl.h>
		45	#include <XSUB.h>
		46
		47	#include "CoroAPI.h"
53	#include "perlxsi.c"	48	#include "perlxsi.c"
54		49
55	extern sint64 *levels; // the experience table	50	extern sint64 *levels; // the experience table
56		51
57	typedef object object_ornull;	52	typedef object object_ornull;
58	typedef mapstruct mapstruct_ornull;	53	typedef maptile maptile_ornull;
59		54
		55	#if IVSIZE >= 8
		56	typedef IV val64;
		57	# define newSVval64 newSViv
		58	# define SvVAL64 SvIV
		59	#else
60	typedef double val64;	60	typedef double val64;
61	#define newSVval64 newSVnv	61	# define newSVval64 newSVnv
62	#define SvVAL64 SvNV	62	# define SvVAL64 SvNV
		63	#endif
63		64
64	static f_plug_api gethook = cfapi_get_hooks;	65	static f_plug_api gethook = cfapi_get_hooks;
65	static f_plug_api object_set_property = cfapi_object_set_property;	66	static f_plug_api object_set_property = cfapi_object_set_property;
66	static f_plug_api map_get_map = cfapi_map_get_map;
67	static f_plug_api object_insert = cfapi_object_insert;	67	static f_plug_api object_insert = cfapi_object_insert;
68		68
69	/* this is a stupid way to do things, and awkward to use for plug-in authors */
70	typedef struct
71	{
72	object* who;
73	object* activator;
74	object* third;
75	object* event;
76	mapstruct* map;
77	char message[1024];
78	int fix; // seems to be python-only, and should not be part of the API
79	int event_code;
80	char extension[1024]; // name field, should invoke specific perl extension
81	char options[1024]; // slaying field of event_connectors
82	int returnvalue;
83	} CFPContext;
84
85	static HV *obj_cache;
86	static PerlInterpreter *perl;	69	static PerlInterpreter *perl;
87		70
		71	double runtime;
		72
		73	global gbl_ev;
88	static AV *cb_global, *cb_object, *cb_player, *cb_type, *cb_map;	74	static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map;
		75	static SV *sv_runtime;
89		76
90	#define PUSHcfapi(type,value) PUSHs (sv_2mortal (newSVcfapi (CFAPI_ ## type, (value))))	77	static HV
91	#define PUSHcfapi_va(type,ctype) PUSHcfapi (type, va_arg (args, ctype))	78	*stash_cf,
92	#define PUSH_OB PUSHcfapi_va(POBJECT, object *)	79	*stash_cf_object_wrap,
93	#define PUSH_PL PUSHcfapi_va(PPLAYER, player *)	80	*stash_cf_object_player_wrap,
94	#define PUSH_MAP PUSHcfapi_va(PMAP, mapstruct *)	81	*stash_cf_player_wrap,
95	#define PUSH_PV PUSHcfapi_va(STRING, const char *)	82	*stash_cf_map_wrap,
96	#define PUSH_IV PUSHs (sv_2mortal (newSViv (va_arg (args, int))))	83	*stash_cf_client_wrap,
		84	*stash_cf_arch_wrap,
		85	*stash_cf_party_wrap,
		86	*stash_cf_region_wrap,
		87	*stash_cf_living_wrap;
		88
		89	// helper cast function, returns super class * or 0
		90	template<class super>
		91	static super *
		92	is_a (attachable *at)
		93	{
		94	//return dynamic_cast<super *>(at); // slower, safer
		95	if (typeid (*at) == typeid (super))
		96	return static_cast<super *>(at);
		97	else
		98	return 0;
		99	}
97		100
98	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	101	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
99		102
		103	unordered_vector<attachable *> attachable::mortals;
		104
		105	attachable::~attachable ()
		106	{
		107	flags |=0x3300;//D
		108	assert (!self);
		109	assert (!cb);
		110	}
		111
		112	int
		113	attachable::refcnt_cnt () const
		114	{
		115	return refcnt + (self ? SvREFCNT (self) - 1 : 0);
		116	}
		117
		118	void
		119	attachable::sever_self ()
		120	{
		121	if (HV *self = this->self)
		122	{
		123	// keep a refcount because sv_unmagic might call attachable_free,
		124	// which might clear self, causing sv_unmagic to crash on a now
		125	// invalid object.
		126	SvREFCNT_inc (self);
		127	hv_clear (self);
		128	sv_unmagic ((SV *)self, PERL_MAGIC_ext);
		129	SvREFCNT_dec (self);
		130
		131	// self *must* be null now because thats sv_unmagic's job.
		132	assert (!this->self);
		133	flags |= 0x80; // severed //D
		134	}
		135	}
		136
		137	void
		138	attachable::optimise ()
		139	{
		140	if (self
		141	&& SvREFCNT (self) == 1
		142	&& !HvTOTALKEYS (self))
		143	flags |= 0x40,//D
		144	sever_self ();
		145	}
		146
		147	// check wether the object really is dead
		148	void
		149	attachable::do_check ()
		150	{
		151	if (refcnt_cnt () > 0)
		152	return;
		153
		154	destroy ();
		155	}
		156
		157	void
		158	attachable::do_destroy ()
		159	{
		160	invoke (EVENT_ATTACHABLE_DESTROY, DT_END);
		161
		162	if (cb)
		163	{
		164	SvREFCNT_dec (cb);
		165	cb = 0;
		166	}
		167
		168	if (self)
		169	sever_self ();
		170
		171	flags |= 0x20; //D
		172	mortals.push_back (this);
		173	}
		174
		175	void
		176	attachable::destroy ()
		177	{
		178	if (destroyed ())
		179	return;
		180
		181	flags |= F_DESTROYED;
		182	do_destroy ();
		183	}
		184
		185	void
		186	attachable::check_mortals ()
		187	{
		188	static int i = 0;
		189
		190	for (;;)
		191	{
		192	if (i >= mortals.size ())
		193	{
		194	i = 0;
		195
		196	if (mortals.size () > 1000)
		197	fprintf (stderr, "mortal queue size (%d) exceeds 1000.\n", (int)mortals.size ());
		198
		199	break;
		200	}
		201
		202	attachable *obj = mortals [i];
		203
		204	obj->refcnt_chk (); // unborrow from perl, if necessary
		205
		206	//if (obj->refcnt > 0 || obj->self)
		207	if (obj->refcnt || obj->self)
		208	{
		209	//printf ("%p rc %d\n", obj, obj->refcnt_cnt ());//D
		210	++i; // further delay freeing
		211
		212	if (!(i & 0x3ff))
		213	break;
		214	}
		215	else
		216	{
		217	mortals.erase (i);
		218	delete obj;
		219	}
		220	}
		221	}
		222
		223	attachable &
		224	attachable::operator =(const attachable &src)
		225	{
		226	//if (self || cb)
		227	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));
		228
		229	attach = src.attach;
		230	return *this;
		231	}
		232
		233	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		234
100	static SV *	235	static SV *
101	newSVptr (void *ptr, const char *klass, HV *hv = newHV ())	236	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())
102	{	237	{
103	SV *sv;	238	SV *sv;
104		239
105	if (!ptr)	240	if (!ptr)
106	return &PL_sv_undef;	241	return &PL_sv_undef;
107		242
108	sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0);	243	sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);
109	return sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));	244	return sv_bless (newRV_noinc ((SV *)hv), stash);
110	}	245	}
111		246
112	template<class attachable>	247	static int
113	SV *	248	attachable_free (pTHX_ SV *sv, MAGIC *mg)
		249	{
		250	attachable *at = (attachable *)mg->mg_ptr;
		251
		252	//TODO: check if transaction behaviour is really required here
		253	if (SV *self = (SV *)at->self)
		254	{
		255	at->self = 0;
		256	SvREFCNT_dec (self);
		257	}
		258
		259	// next line makes sense, but most objects still have refcnt 0 by default
		260	//at->refcnt_chk ();
		261	return 0;
		262	}
		263
		264	MGVTBL attachable::vtbl = {0, 0, 0, 0, attachable_free};
		265
		266	static SV *
114	newSVattachable (attachable *obj, const char *klass)	267	newSVattachable (attachable *obj, HV *stash)
115	{	268	{
116	if (!obj)	269	if (!obj)
117	return &PL_sv_undef;	270	return &PL_sv_undef;
118		271
119	if (!obj->self)	272	if (!obj->self)
120	obj->self = newSVptr (obj, klass);
121
122	return newSVsv (static_cast<SV *>(obj->self));
123	}
124
125	static void
126	SVptr_cache_set (void *ptr, SV *sv)
127	{
128	hv_store (obj_cache, (char *)&ptr, sizeof (ptr), sv, 0);
129	}
130
131	static SV *
132	SVptr_cache_get (void *ptr)
133	{
134	SV **he = hv_fetch (obj_cache, (char *)&ptr, sizeof (ptr), 0);
135
136	return he ? *he : 0;
137	}
138
139	static SV *
140	newSVptr_cached (void *ptr, const char *klass)
141	{
142	SV *sv;
143
144	if (!ptr)
145	return &PL_sv_undef;
146
147	sv = SVptr_cache_get (ptr);
148
149	if (!sv)
150	{	273	{
151	HV *hv = newHV ();	274	obj->self = newHV ();
152	sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0);	275	sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char *)obj, 0);
153	sv = sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));	276	obj->flags |= (obj->flags & 0xc0) << 8;
		277	obj->flags &= ~0xc0;//D
		278	obj->flags |= 0x10;//D
154		279
155	SVptr_cache_set (ptr, sv);	280	// now bless the object _once_
		281	return sv_bless (newRV_inc ((SV *)obj->self), stash);
156	}	282	}
		283	else
		284	{
		285	SV *sv = newRV_inc ((SV *)obj->self);
157		286
158	return newSVsv (sv);	287	if (Gv_AMG (stash)) // handle overload correctly, as the perl core does not
		288	SvAMAGIC_on (sv);
		289
		290	return sv;
		291	}
159	}	292	}
160		293
161	static void	294	static void
162	clearSVptr (SV *sv)	295	clearSVptr (SV *sv)
163	{	296	{
…		…
188	if (SvOK (sv))	321	if (SvOK (sv))
189	return SvPTR (sv, klass);	322	return SvPTR (sv, klass);
190	else	323	else
191	return 0;	324	return 0;
192	}	325	}
		326
		327	inline SV *to_sv (const shstr & v) { return v ? newSVpvn ((const char *)v, v.length ()) : &PL_sv_undef; }
		328	inline SV *to_sv (const char * v) { return newSVpv (v, 0); }
		329	inline SV *to_sv (bool v) { return newSViv (v); }
		330	inline SV *to_sv ( signed char v) { return newSViv (v); }
		331	inline SV *to_sv (unsigned char v) { return newSViv (v); }
		332	inline SV *to_sv ( signed short v) { return newSViv (v); }
		333	inline SV *to_sv (unsigned short v) { return newSVuv (v); }
		334	inline SV *to_sv ( signed int v) { return newSViv (v); }
		335	inline SV *to_sv (unsigned int v) { return newSVuv (v); }
		336	inline SV *to_sv ( signed long v) { return newSViv (v); }
		337	inline SV *to_sv (unsigned long v) { return newSVuv (v); }
		338	inline SV *to_sv ( signed long long v) { return newSVval64 (v); }
		339	inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }
		340	inline SV *to_sv (float v) { return newSVnv (v); }
		341	inline SV *to_sv (double v) { return newSVnv (v); }
		342	inline SV *to_sv (client * v) { return newSVattachable (v, stash_cf_client_wrap); }
		343	inline SV *to_sv (player * v) { return newSVattachable (v, stash_cf_player_wrap); }
		344	inline SV *to_sv (object * v) { return newSVattachable (v, v && v->type == PLAYER ? stash_cf_object_player_wrap : stash_cf_object_wrap); }
		345	inline SV *to_sv (maptile * v) { return newSVattachable (v, stash_cf_map_wrap); }
		346	inline SV *to_sv (archetype * v) { return newSVattachable (v, stash_cf_arch_wrap); }
		347	inline SV *to_sv (partylist * v) { return newSVptr (v, stash_cf_party_wrap); }
		348	inline SV *to_sv (region * v) { return newSVptr (v, stash_cf_region_wrap); }
		349	inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }
		350
		351	inline SV *to_sv (object & v) { return to_sv (&v); }
		352	inline SV *to_sv (living & v) { return to_sv (&v); }
		353
		354	//inline SV *to_sv (faceinfo * v) { return to_sv (v->name); }
		355	inline SV *to_sv (treasurelist * v) { return to_sv (v->name); }
		356	inline SV *to_sv (std::string & v) { return newSVpvn (v.data (), v.size ()); }
		357
		358	inline SV *to_sv (UUID v)
		359	{
		360	char buf[128];
		361	snprintf (buf, 128, "<1.%" PRIx64 ">", v.seq);
		362	return newSVpv (buf, 0);
		363	}
		364
		365	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPV_nolen (sv) : 0; }
		366	inline void sv_to (SV *sv, char * &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }
		367	inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }
		368	inline void sv_to (SV *sv, signed char &v) { v = SvIV (sv); }
		369	inline void sv_to (SV *sv, unsigned char &v) { v = SvIV (sv); }
		370	inline void sv_to (SV *sv, signed short &v) { v = SvIV (sv); }
		371	inline void sv_to (SV *sv, unsigned short &v) { v = SvIV (sv); }
		372	inline void sv_to (SV *sv, signed int &v) { v = SvIV (sv); }
		373	inline void sv_to (SV *sv, unsigned int &v) { v = SvUV (sv); }
		374	inline void sv_to (SV *sv, signed long &v) { v = SvIV (sv); }
		375	inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }
		376	inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }
		377	inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }
		378	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
		379	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }
		380	inline void sv_to (SV *sv, client * &v) { v = (client *)(attachable *)SvPTR_ornull (sv, "cf::client"); }
		381	inline void sv_to (SV *sv, player * &v) { v = (player *)(attachable *)SvPTR_ornull (sv, "cf::player"); }
		382	inline void sv_to (SV *sv, object * &v) { v = (object *)(attachable *)SvPTR_ornull (sv, "cf::object"); }
		383	inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)(attachable *)SvPTR_ornull (sv, "cf::arch"); }
		384	inline void sv_to (SV *sv, maptile * &v) { v = (maptile *)(attachable *)SvPTR_ornull (sv, "cf::map"); }
		385	inline void sv_to (SV *sv, attachable * &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); }
		386	inline void sv_to (SV *sv, partylist * &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }
		387	inline void sv_to (SV *sv, region * &v) { v = (region *)SvPTR_ornull (sv, "cf::region"); }
		388	inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }
		389
		390	//inline void sv_to (SV *sv, faceinfo * &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }
		391	inline void sv_to (SV *sv, treasurelist * &v) { v = find_treasurelist (SvPV_nolen (sv)); }
		392
		393	template<class T>
		394	inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }
		395
		396	template<int N>
		397	inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); }
		398
		399	inline void sv_to (SV *sv, rangetype &v) { v = (rangetype) SvIV (sv); }
		400	inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); }
		401	inline void sv_to (SV *sv, petmode_t &v) { v = (petmode_t) SvIV (sv); }
		402	inline void sv_to (SV *sv, usekeytype &v) { v = (usekeytype) SvIV (sv); }
		403	inline void sv_to (SV *sv, unapplymode &v) { v = (unapplymode) SvIV (sv); }
		404
		405	inline void sv_to (SV *sv, std::string &v)
		406	{
		407	STRLEN len;
		408	char *data = SvPVbyte (sv, len);
		409	v.assign (data, len);
		410	}
		411
		412	inline void sv_to (SV *sv, UUID &v)
		413	{
		414	unsigned int version;
		415
		416	if (2 != sscanf (SvPV_nolen (sv), "<%d.%" SCNx64 ">", &version, &v.seq) || 1 != version)
		417	croak ("unparsable uuid: %s", SvPV_nolen (sv));
		418	}
		419
		420	inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }
193		421
194	static SV *	422	static SV *
195	newSVdt_va (va_list &ap, data_type type)	423	newSVdt_va (va_list &ap, data_type type)
196	{	424	{
197	SV *sv;	425	SV *sv;
…		…
224	sv = str ? newSVpv (str, len) : &PL_sv_undef;	452	sv = str ? newSVpv (str, len) : &PL_sv_undef;
225	}	453	}
226	break;	454	break;
227		455
228	case DT_OBJECT:	456	case DT_OBJECT:
229	{	457	sv = to_sv (va_arg (ap, object *));
230	object *obj = va_arg (ap, object *);
231	sv = newSVattachable (obj, obj && obj->type == PLAYER ? "cf::object::player::wrap" : "cf::object::wrap");
232	}
233	break;	458	break;
234		459
235	case DT_MAP:	460	case DT_MAP:
236	// va_arg (object *) when void * is passed is an XSI extension	461	// va_arg (object *) when void * is passed is an XSI extension
237	sv = newSVattachable (va_arg (ap, mapstruct *), "cf::map::wrap");	462	sv = to_sv (va_arg (ap, maptile *));
238	break;	463	break;
239		464
		465	case DT_CLIENT:
		466	sv = to_sv (va_arg (ap, client *));
		467	break;
		468
240	case DT_PLAYER:	469	case DT_PLAYER:
241	sv = newSVattachable (va_arg (ap, player *), "cf::player::wrap");	470	sv = to_sv (va_arg (ap, player *));
242	break;	471	break;
243		472
244	case DT_ARCH:	473	case DT_ARCH:
245	sv = newSVptr (va_arg (ap, archetype *), "cf::arch::wrap");	474	sv = to_sv (va_arg (ap, archetype *));
246	break;	475	break;
247		476
248	case DT_PARTY:	477	case DT_PARTY:
249	sv = newSVptr (va_arg (ap, partylist *), "cf::party::wrap");	478	sv = to_sv (va_arg (ap, partylist *));
250	break;	479	break;
251		480
252	case DT_REGION:	481	case DT_REGION:
253	sv = newSVptr (va_arg (ap, region *), "cf::region::wrap");	482	sv = to_sv (va_arg (ap, region *));
254	break;	483	break;
255		484
256	default:	485	default:
257	assert (("unhandled type in newSVdt_va", 0));	486	assert (("unhandled type in newSVdt_va", 0));
258	}	487	}
…		…
303	}	532	}
304		533
305	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	534	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
306		535
307	SV *	536	SV *
308	registry_of (attachable_base *ext)	537	registry (attachable *ext)
309	{	538	{
310	if (!ext->cb)	539	if (!ext->cb)
311	ext->cb = newAV ();	540	ext->cb = newAV ();
312		541
313	return newRV_inc ((SV *)ext->cb);	542	return newRV_inc ((SV *)ext->cb);
314	}	543	}
315		544
316	void attachable_base::clear ()
317	{
318	if (self)
319	{
320	if (cb)
321	if (SvROK (*av_fetch ((AV *)cb, EVENT_OBJECT_DESTROY, 1)))
322	INVOKE_OBJECT (DESTROY, static_cast<object *>(this));
323	else if (SvROK (*av_fetch ((AV *)cb, EVENT_MAP_DESTROY, 1)))
324	INVOKE_MAP (DESTROY, static_cast<mapstruct *>(this));
325
326	// disconnect Perl from C, to avoid crashes
327	sv_unmagic (SvRV ((SV *)self), PERL_MAGIC_ext);
328
329	// clear the perl hash, might or might not be a good idea
330	hv_clear ((HV *)SvRV ((SV *)self));
331
332	SvREFCNT_dec (self);
333	self = 0;
334	}
335
336	if (cb)
337	{
338	SvREFCNT_dec (cb);
339	cb = 0;
340	}
341
342	if (attach)
343	{
344	free_string (attach);
345	attach = 0;
346	}
347	}
348
349	void attachable_base::optimise ()
350	{
351	if (!self)
352	return;
353
354	HV *hv = (HV *)SvRV ((SV *)self);
355
356	if (SvREFCNT ((SV *)self) == 1
357	&& SvREFCNT ((SV *)hv) == 1
358	&& !HvKEYS (hv))
359	{
360	SvREFCNT_dec ((SV *)self);
361	self = 0;
362	}
363	}
364
365	void attachable_base::instantiate (data_type type, void *obj)
366	{
367	dSP;
368	ENTER;
369	SAVETMPS;
370	PUSHMARK (SP);
371	EXTEND (SP, 2);
372	PUSHs (sv_2mortal (newSVdt (type, obj)));
373	PUSHs (sv_2mortal (newSVpv (attach, 0)));
374
375	free_string (attach);
376	attach = 0;
377
378	PUTBACK;
379	call_pv ("cf::instantiate", G_DISCARD | G_VOID | G_EVAL);
380	FREETMPS;
381	LEAVE;
382
383	switch (type)
384	{
385	case DT_OBJECT: INVOKE_OBJECT (INSTANTIATE, obj); break;
386	case DT_MAP: INVOKE_MAP (INSTANTIATE, obj); break;
387	}
388	}
389
390	/////////////////////////////////////////////////////////////////////////////
391
392	void reattach (data_type type, void *obj)
393	{
394	//TODO only do this when the object has _attachment's
395
396	dSP;
397	ENTER;
398	SAVETMPS;
399	PUSHMARK (SP);
400	XPUSHs (sv_2mortal (newSVdt (type, obj)));
401	PUTBACK;
402	call_pv ("cf::reattach", G_DISCARD | G_VOID | G_EVAL);
403	FREETMPS;
404	LEAVE;
405
406	switch (type)
407	{
408	case DT_OBJECT: INVOKE_OBJECT (REATTACH, obj); break;
409	case DT_PLAYER: INVOKE_PLAYER (REATTACH, obj); break;
410	case DT_MAP: INVOKE_MAP (REATTACH, obj); break;
411	}
412	}
413
414	template<class subclass>
415	void reattach (attachable<subclass> *obj)
416	{
417	obj->optimise ();
418
419	if (obj->self)
420	reattach (subclass::get_dt (), (subclass *)obj);
421	}
422
423	object_freezer::object_freezer (const char *filename)
424	{
425	this->filename = (SV *)newSVpv (filename, 0);
426
427	char filename2 [4096];
428	snprintf (filename2, 4096, "%s~", filename);
429
430	fp = fopen (filename2, "w");
431
432	if (!fp)
433	LOG (llevError, "cannot open file '%s' for writing: %s\n", filename2, strerror (errno));
434
435	av = (AV *)newAV ();
436	}
437
438	object_freezer::~object_freezer ()
439	{
440	if (fp)
441	{
442	fclose (fp);
443
444	dSP;
445	ENTER;
446	SAVETMPS;
447	PUSHMARK (SP);
448	XPUSHs (sv_2mortal ((SV *)filename));
449	XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
450	PUTBACK;
451	call_pv ("cf::object_freezer_save", G_VOID | G_DISCARD | G_EVAL);
452	FREETMPS;
453	LEAVE;
454	}
455	else
456	SvREFCNT_dec ((SV *)filename);
457	}
458
459	void object_freezer::put (attachable_base *ext)
460	{
461	ext->optimise ();
462
463	if (ext->self)
464	{
465	int idx = AvFILLp ((AV *)av) + 1;
466	av_store ((AV *)av, idx, SvREFCNT_inc ((SV *)ext->self));
467	fprintf (fp, "oid %d\n", idx);
468	}
469	}
470
471	object_thawer::object_thawer (FILE *fp, const char *filename)
472	{
473	this->fp = fp;
474	av = 0;
475
476	if (!filename)
477	return;
478
479	dSP;
480	ENTER;
481	SAVETMPS;
482	PUSHMARK (SP);
483	XPUSHs (sv_2mortal (newSVpv (filename, 0)));
484	PUTBACK;
485
486	if (0 < call_pv ("cf::object_thawer_load", G_SCALAR | G_EVAL))
487	{
488	SPAGAIN;
489	SV *sv = POPs;
490	if (SvROK (sv))
491	av = SvREFCNT_inc (SvRV (sv));
492	}
493
494	FREETMPS;
495	LEAVE;
496	}
497
498	void object_thawer::get (data_type type, void *obj, attachable_base *ext, int oid)
499	{
500	if (!av || oid < 0) // this is actually an error of sorts
501	return;
502
503	// we have to "re-instantiate"/reattach to an object, so nuke ext->attach
504	ext->clear ();
505
506	SV **svp = av_fetch ((AV *)av, oid, 0);
507
508	if (!svp || !SvROK (*svp))
509	{
510	printf ("trying to thaw duplicate or never-issued oid %d, ignoring.\n", oid);
511	return;
512	}
513
514	ext->self = *svp; *svp = &PL_sv_undef;
515	sv_magic (SvRV ((SV *)ext->self), 0, PERL_MAGIC_ext, (char *)obj, 0);
516
517	reattach (type, obj);
518	}
519
520	object_thawer::~object_thawer ()
521	{
522	if (av) SvREFCNT_dec ((AV *)av);
523	}
524
525	/////////////////////////////////////////////////////////////////////////////	545	/////////////////////////////////////////////////////////////////////////////
526		546
527	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)	547	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
528	{	548	{
529	return 0;	549	return 0;
…		…
532	static CommArray_s rtn_cmd;	552	static CommArray_s rtn_cmd;
533		553
534	static int	554	static int
535	runPluginCommand (object *obj, char *params)	555	runPluginCommand (object *obj, char *params)
536	{	556	{
537	dSP;	557	return -1;
538
539	ENTER;
540	SAVETMPS;
541
542	PUSHMARK (SP);
543
544	EXTEND (SP, 3);
545	PUSHs (sv_2mortal (newSVpv (rtn_cmd.name, 0)));
546	PUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, obj)));
547
548	if (params)
549	PUSHs (sv_2mortal (newSVpv (params, 0)));
550
551	PUTBACK;
552	int count = call_pv ("cf::inject_command", G_SCALAR | G_EVAL);
553	SPAGAIN;
554
555	if (SvTRUE (ERRSV))
556	LOG (llevError, "command '%s' callback evaluation error: %s", rtn_cmd.name, SvPV_nolen (ERRSV));
557
558	int returnvalue = count > 0 ? POPi : -1;
559
560	PUTBACK;
561	FREETMPS;
562	LEAVE;
563
564	return returnvalue;
565	}	558	}
566		559
567	extern "C" void *cfperl_getPluginProperty (int *type, ...)	560	extern "C" void *cfperl_getPluginProperty (int *type, ...)
568	{	561	{
569	va_list args;	562	va_list args;
…		…
572	va_start (args, type);	565	va_start (args, type);
573	propname = va_arg (args, char *);	566	propname = va_arg (args, char *);
574	//printf ("Property name: %s\n", propname);	567	//printf ("Property name: %s\n", propname);
575		568
576	if (!strcmp (propname, "command?"))	569	if (!strcmp (propname, "command?"))
577	{
578	if (!perl)
579	return NULL;	570	return NULL;
580
581	const char *cmdname = va_arg (args, const char *);
582	HV *hv = get_hv ("cf::COMMAND", 1);
583	SV **svp = hv_fetch (hv, cmdname, strlen (cmdname) + 1, 0);
584
585	va_end (args);
586
587	if (svp)
588	{
589	// this is totaly broken, should stash it into %COMMAND
590	rtn_cmd.name = cmdname;
591	rtn_cmd.time = SvNV (*svp);
592	rtn_cmd.func = runPluginCommand;
593
594	return &rtn_cmd;
595	}
596	}
597	else if (!strcmp (propname, "Identification"))	571	else if (!strcmp (propname, "Identification"))
598	{	572	{
599	va_end (args);	573	va_end (args);
600	return (void*) PLUGIN_NAME;	574	return (void *)PLUGIN_NAME;
601	}	575	}
602	else if (!strcmp (propname, "FullName"))	576	else if (!strcmp (propname, "FullName"))
603	{	577	{
604	va_end (args);	578	va_end (args);
605	return (void*) PLUGIN_VERSION;	579	return (void *)PLUGIN_VERSION;
606	}	580	}
607	else	581	else
608	va_end (args);	582	va_end (args);
609		583
610	return NULL;	584	return NULL;
…		…
626	}	600	}
627		601
628	void	602	void
629	cfperl_init ()	603	cfperl_init ()
630	{	604	{
		605	PERL_SYS_INIT3 (&settings.argc, &settings.argv, 0);
		606	perl = perl_alloc ();
		607	perl_construct (perl);
		608
		609	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
		610
631	char *argv[] = {	611	const char *argv[] = {
632	"",	612	"",
633	"-e"	613	"-e"
634	"BEGIN {"	614	"use Event; use Coro;" // required for bootstrap
635	" cf->bootstrap;"	615	"cf->bootstrap;" // required for datadir :*>
636	" unshift @INC, cf::datadir ();"	616	"unshift @INC, cf::datadir ();"
637	"}"
638	""
639	"use cf;"	617	"require cf;"
640	};	618	};
641		619
642	perl = perl_alloc ();
643	perl_construct (perl);
644
645	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
646
647	if (perl_parse (perl, xs_init, 2, argv, (char **)NULL) || perl_run (perl))	620	if (perl_parse (perl, xs_init, 2, (char **)argv, (char **)NULL)
		621	|| perl_run (perl))
648	{	622	{
649	printf ("unable to initialize perl-interpreter, aborting.\n");	623	printf ("unable to initialize perl-interpreter, aborting.\n");
650
651	exit (EXIT_FAILURE);	624	exit (EXIT_FAILURE);
652	//perl_destruct (perl);
653	//perl_free (perl);
654	//perl = 0;
655	//return;
656	}	625	}
657		626
658	obj_cache = newHV ();	627	{
		628	dSP;
		629
		630	PUSHMARK (SP);
		631	PUTBACK;
		632	call_pv ("cf::init", G_DISCARD | G_VOID);
		633	}
659	}	634	}
660		635
661	void cfperl_main ()	636	void cfperl_main ()
662	{	637	{
663	dSP;	638	dSP;
664		639
665	PUSHMARK (SP);	640	PUSHMARK (SP);
666	PUTBACK;	641	PUTBACK;
667	call_pv ("cf::main", G_DISCARD | G_VOID);	642	call_pv ("cf::main", G_DISCARD | G_VOID);
		643	}
		644
		645	void
		646	attachable::instantiate ()
		647	{
		648	if (attach)
		649	{
		650	invoke (EVENT_ATTACHABLE_INSTANTIATE, ARG_STRING (attach), DT_END);
		651	attach = 0;
		652	}
		653	}
		654
		655	void
		656	attachable::reattach ()
		657	{
		658	optimise ();
		659	//TODO: check for _attachment's, very important for restarts
		660	invoke (EVENT_ATTACHABLE_REATTACH, DT_END);
668	}	661	}
669		662
670	static event_klass klass_of[NUM_EVENT_TYPES] = {	663	static event_klass klass_of[NUM_EVENT_TYPES] = {
671	# define def(type,name) KLASS_ ## type,	664	# define def(type,name) KLASS_ ## type,
672	# include "eventinc.h"	665	# include "eventinc.h"
…		…
703	}	696	}
704	}	697	}
705	}	698	}
706	}	699	}
707		700
		701	void
		702	attachable::gather_callbacks (AV *&callbacks, event_type event) const
		703	{
		704	::gather_callbacks (callbacks, cb_attachable, event);
		705
		706	if (cb)
		707	::gather_callbacks (callbacks, cb, event);
		708	}
		709
		710	void
		711	global::gather_callbacks (AV *&callbacks, event_type event) const
		712	{
		713	::gather_callbacks (callbacks, cb_object, event);
		714	}
		715
		716	void
		717	object::gather_callbacks (AV *&callbacks, event_type event) const
		718	{
		719	if (subtype && type + subtype * NUM_SUBTYPES <= AvFILLp (cb_type))
		720	{
		721	SV *registry = AvARRAY (cb_type)[type + subtype * NUM_SUBTYPES];
		722
		723	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
		724	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);
		725	}
		726
		727	if (type <= AvFILLp (cb_type))
		728	{
		729	SV *registry = AvARRAY (cb_type)[type];
		730
		731	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
		732	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);
		733	}
		734
		735	attachable::gather_callbacks (callbacks, event);
		736	::gather_callbacks (callbacks, cb_object, event);
		737	}
		738
		739	void
		740	archetype::gather_callbacks (AV *&callbacks, event_type event) const
		741	{
		742	attachable::gather_callbacks (callbacks, event);
		743	//TODO//::gather_callbacks (callbacks, cb_archetype, event);
		744	}
		745
		746	void
		747	client::gather_callbacks (AV *&callbacks, event_type event) const
		748	{
		749	attachable::gather_callbacks (callbacks, event);
		750	::gather_callbacks (callbacks, cb_client, event);
		751	}
		752
		753	void
		754	player::gather_callbacks (AV *&callbacks, event_type event) const
		755	{
		756	attachable::gather_callbacks (callbacks, event);
		757	::gather_callbacks (callbacks, cb_player, event);
		758	}
		759
		760	void
		761	maptile::gather_callbacks (AV *&callbacks, event_type event) const
		762	{
		763	attachable::gather_callbacks (callbacks, event);
		764	::gather_callbacks (callbacks, cb_map, event);
		765	}
		766
		767	bool
708	bool cfperl_invoke (event_type event, ...)	768	attachable::invoke (event_type event, ...)
709	{	769	{
710	data_type dt;	770	data_type dt;
711	va_list ap;	771	va_list ap;
712		772
713	va_start (ap, event);	773	va_start (ap, event);
714		774
		775	// callback call ordering should be:
		776	// 1. per-object callback
		777	// 2. per-class object
		778	// 3. per-type callback
		779	// 4. global callbacks
		780
715	AV *callbacks = 0;	781	AV *callbacks = 0;
716
717	object *op;
718	player *pl;
719	mapstruct *map;
720
721	// callback call ordering is:
722	// 1. per-object callback (NYI)
723	// 2. per-class object
724	// 2a. per-type callback
725	// 4. global callbacks
726
727	gather_callbacks (callbacks, cb_global, event);	782	gather_callbacks (callbacks, event);
728
729	switch (KLASS_OF (event))
730	{
731	case KLASS_GLOBAL:
732	break;
733
734	case KLASS_OBJECT:
735	dt = (data_type) va_arg (ap, int);
736	assert (("first argument must be of type object", dt == DT_OBJECT));
737	op = va_arg (ap, object *);
738
739	if (op->cb)
740	gather_callbacks (callbacks, (AV *)op->cb, event);
741
742	if (op->type)
743	{
744	if (op->subtype && op->type + op->subtype * NUM_SUBTYPES <= AvFILLp (cb_type))
745	{
746	SV *registry = AvARRAY (cb_type)[op->type + op->subtype * NUM_SUBTYPES];
747
748	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
749	gather_callbacks (callbacks, (AV *)SvRV (registry), event);
750	}
751
752	if (op->type <= AvFILLp (cb_type))
753	{
754	SV *registry = AvARRAY (cb_type)[op->type];
755
756	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
757	gather_callbacks (callbacks, (AV *)SvRV (registry), event);
758	}
759	}
760
761	gather_callbacks (callbacks, cb_object, event);
762
763	break;
764
765	case KLASS_PLAYER:
766	dt = (data_type) va_arg (ap, int);
767	assert (("first argument must be of type player", dt == DT_PLAYER));
768	pl = va_arg (ap, player *);
769
770	if (pl->cb)
771	gather_callbacks (callbacks, (AV *)pl->cb, event);
772
773	gather_callbacks (callbacks, cb_player, event);
774	break;
775
776	case KLASS_MAP:
777	dt = (data_type) va_arg (ap, int);
778	assert (("first argument must be of type object", dt == DT_MAP));
779	map = va_arg (ap, mapstruct *);
780
781	if (map->cb)
782	gather_callbacks (callbacks, (AV *)map->cb, event);
783
784	gather_callbacks (callbacks, cb_map, event);
785	break;
786
787	default:
788	assert (("unsupported event klass in cfperl_invoke", 0));
789	}
790		783
791	// short-circuit processing if no callbacks found/defined	784	// short-circuit processing if no callbacks found/defined
792	if (!callbacks)	785	if (!callbacks)
793	return 0;	786	return 0;
794		787
795	dSP;	788	CALL_BEGIN (3);
796	ENTER;
797	SAVETMPS;
798
799	PUSHMARK (SP);
800	EXTEND (SP, 3);
801
802	PUSHs (sv_2mortal (newSViv (event))); // only used for debugging nowadays	789	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays
803	PUSHs (sv_2mortal (newRV_noinc ((SV *)callbacks)));	790	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));
804		791
805	switch (KLASS_OF (event))	792	//TODO: unhack
806	{	793	if (object *op = is_a<object>(this)) CALL_ARG_SV (newSVdt (DT_OBJECT, op));
807	case KLASS_OBJECT: PUSHs (sv_2mortal (newSVdt (DT_OBJECT, op))); break;	794	else if (player *pl = is_a<player>(this)) CALL_ARG_SV (newSVdt (DT_PLAYER, pl));
808	case KLASS_PLAYER: PUSHs (sv_2mortal (newSVdt (DT_PLAYER, pl))); break;	795	else if (client *ns = is_a<client>(this)) CALL_ARG_SV (newSVdt (DT_CLIENT, ns));
809	case KLASS_MAP: PUSHs (sv_2mortal (newSVdt (DT_MAP, map))); break;	796	else if (maptile *m = is_a<maptile>(this)) CALL_ARG_SV (newSVdt (DT_MAP, m));
810	}	797	else if (global *gl = is_a<global>(this)) /*nop*/;
		798	else
		799	abort (); //TODO
811		800
812	for (;;)	801	for (;;)
813	{	802	{
814	dt = (data_type) va_arg (ap, int);	803	dt = (data_type) va_arg (ap, int);
815		804
816	if (dt == DT_END)	805	if (dt == DT_END)
817	break;	806	break;
818
819	if (dt == DT_AV)	807	else if (dt == DT_AV)
820	{	808	{
821	AV *av = va_arg (ap, AV *);	809	AV *av = va_arg (ap, AV *);
822		810
823	for (int i = 0; i <= av_len (av); ++i)	811	for (int i = 0; i <= av_len (av); ++i)
824	XPUSHs (*av_fetch (av, i, 1));	812	XPUSHs (*av_fetch (av, i, 1));
…		…
827	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));	815	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
828	}	816	}
829		817
830	va_end (ap);	818	va_end (ap);
831		819
832	PUTBACK;	820	CALL_CALL ("cf::do_invoke", G_SCALAR);
833	int count = call_pv ("cf::do_invoke", G_SCALAR | G_EVAL);
834	SPAGAIN;
835
836	count = count > 0 ? POPi : 0;	821	count = count > 0 ? POPi : 0;
837		822
838	FREETMPS;	823	CALL_END;
839	LEAVE;
840		824
841	return count;	825	return count;
842	}	826	}
843		827
844	SV *	828	SV *
…		…
859	cfperl_result_INT (int idx)	843	cfperl_result_INT (int idx)
860	{	844	{
861	return SvIV (cfperl_result (idx));	845	return SvIV (cfperl_result (idx));
862	}	846	}
863		847
		848	double
		849	cfperl_result_DOUBLE (int idx)
		850	{
		851	return SvNV (cfperl_result (idx));
		852	}
		853
		854	/////////////////////////////////////////////////////////////////////////////
		855
		856	void
		857	cfperl_emergency_save ()
		858	{
		859	CALL_BEGIN (0);
		860	CALL_CALL ("cf::emergency_save", G_VOID);
		861	CALL_END;
		862	}
		863
		864	void
		865	cfperl_cleanup (int make_core)
		866	{
		867	CALL_BEGIN (1);
		868	CALL_ARG (make_core);
		869	CALL_CALL ("cf::post_cleanup", G_VOID);
		870	CALL_END;
		871	}
		872
		873	maptile *
		874	maptile::find_sync (const char *path, maptile *origin)
		875	{
		876	CALL_BEGIN (2);
		877	CALL_ARG (path);
		878	CALL_ARG (origin);
		879	CALL_CALL ("cf::map::find_sync", G_SCALAR);
		880
		881	maptile *retval;
		882
		883	if (count)
		884	sv_to (POPs, retval);
		885	else
		886	retval = 0;
		887
		888	CALL_END;
		889
		890	return retval;
		891	}
		892
		893	maptile *
		894	maptile::find_async (const char *path, maptile *origin)
		895	{
		896	CALL_BEGIN (2);
		897	CALL_ARG (path);
		898	CALL_ARG (origin);
		899	CALL_CALL ("cf::map::find_async", G_SCALAR);
		900
		901	maptile *retval;
		902
		903	if (count)
		904	sv_to (POPs, retval);
		905	else
		906	retval = 0;
		907
		908	CALL_END;
		909
		910	return retval;
		911	}
		912
		913	void
		914	maptile::do_load_sync ()
		915	{
		916	CALL_BEGIN (1);
		917	CALL_ARG (this);
		918	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);
		919	CALL_END;
		920	}
		921
		922	void
		923	maptile::change_all_map_light (int change)
		924	{
		925	CALL_BEGIN (1);
		926	CALL_ARG (change);
		927	CALL_CALL ("cf::map::change_all_map_light", G_VOID);
		928	CALL_END;
		929	}
		930
		931	void
		932	object::enter_exit (object *exit)
		933	{
		934	if (type != PLAYER)
		935	return;
		936
		937	CALL_BEGIN (2);
		938	CALL_ARG (this);
		939	CALL_ARG (exit);
		940	CALL_CALL ("cf::object::player::enter_exit", G_VOID);
		941	CALL_END;
		942	}
		943
		944	/////////////////////////////////////////////////////////////////////////////
		945
		946	struct EventAPI *watcher_base::GEventAPI;
		947	struct CoroAPI *coroapi::GCoroAPI;
		948
		949	int coroapi::cede_counter;
		950
		951	static void iw_dispatch (pe_event *ev)
		952	{
		953	iw *w = (iw *)ev->ext_data;
		954	w->call (*w);
		955	}
		956
		957	void
		958	iw::alloc ()
		959	{
		960	pe = GEventAPI->new_idle (0, 0);
		961
		962	WaREENTRANT_off (pe);
		963	pe->base.callback = (void *)iw_dispatch;
		964	pe->base.ext_data = (void *)this;
		965	}
		966
		967	static void iow_dispatch (pe_event *ev)
		968	{
		969	iow *w = (iow *)ev->ext_data;
		970	w->call (*w, ((pe_ioevent *)ev)->got);
		971	}
		972
		973	void
		974	iow::alloc ()
		975	{
		976	pe = GEventAPI->new_io (0, 0);
		977
		978	WaREENTRANT_off (pe);
		979	pe->base.callback = (void *)iow_dispatch;
		980	pe->base.ext_data = (void *)this;
		981
		982	pe->fd = -1;
		983	pe->poll = 0;
		984	}
		985
		986	void
		987	iow::fd (int fd)
		988	{
		989	pe->fd = fd;
		990	}
		991
		992	int
		993	iow::poll ()
		994	{
		995	return pe->poll;
		996	}
		997
		998	void
		999	iow::poll (int events)
		1000	{
		1001	if (pe->poll != events)
		1002	{
		1003	if (pe->poll) stop ();
		1004	pe->poll = events;
		1005	if (pe->poll) start ();
		1006	}
		1007	}
		1008
		1009	void
		1010	_connect_to_perl ()
		1011	{
		1012	stash_cf = gv_stashpv ("cf" , 1);
		1013
		1014	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);
		1015	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);
		1016	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);
		1017	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);
		1018	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);
		1019	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
		1020	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
		1021	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
		1022	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
		1023
		1024	sv_runtime = get_sv ("cf::RUNTIME", 1);
		1025	sv_upgrade (sv_runtime, SVt_NV);
		1026
		1027	cb_global = get_av ("cf::CB_GLOBAL", 1);
		1028	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
		1029	cb_object = get_av ("cf::CB_OBJECT", 1);
		1030	cb_player = get_av ("cf::CB_PLAYER", 1);
		1031	cb_client = get_av ("cf::CB_CLIENT", 1);
		1032	cb_type = get_av ("cf::CB_TYPE" , 1);
		1033	cb_map = get_av ("cf::CB_MAP" , 1);
		1034	}
		1035
864	MODULE = cf PACKAGE = cf PREFIX = cf_	1036	MODULE = cf PACKAGE = cf PREFIX = cf_
865		1037
866	BOOT:	1038	BOOT:
867	{	1039	{
868	HV *stash = gv_stashpv ("cf", 1);	1040	_connect_to_perl ();
		1041
		1042	I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;
		1043	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
		1044
		1045	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
869		1046
870	static const struct {	1047	static const struct {
871	const char *name;	1048	const char *name;
872	IV iv;	1049	IV iv;
873	} *civ, const_iv[] = {	1050	} *civ, const_iv[] = {
874	# define const_iv(name) { # name, (IV)name },	1051	# define const_iv(name) { # name, (IV)name },
875	const_iv (llevError)	1052	const_iv (llevError)
876	const_iv (llevInfo)	1053	const_iv (llevInfo)
877	const_iv (llevDebug)	1054	const_iv (llevDebug)
878	const_iv (llevMonster)	1055	const_iv (llevMonster)
		1056
		1057	const_iv (Map0Cmd)
		1058	const_iv (Map1Cmd)
		1059	const_iv (Map1aCmd)
		1060
		1061	const_iv (MAP_CLIENT_X)
		1062	const_iv (MAP_CLIENT_Y)
879		1063
880	const_iv (MAX_TIME)	1064	const_iv (MAX_TIME)
881	const_iv (PLAYER)	1065	const_iv (PLAYER)
882	const_iv (TRANSPORT)	1066	const_iv (TRANSPORT)
883	const_iv (ROD)	1067	const_iv (ROD)
…		…
885	const_iv (POTION)	1069	const_iv (POTION)
886	const_iv (FOOD)	1070	const_iv (FOOD)
887	const_iv (POISON)	1071	const_iv (POISON)
888	const_iv (BOOK)	1072	const_iv (BOOK)
889	const_iv (CLOCK)	1073	const_iv (CLOCK)
890	const_iv (LIGHTNING)
891	const_iv (ARROW)	1074	const_iv (ARROW)
892	const_iv (BOW)	1075	const_iv (BOW)
893	const_iv (WEAPON)	1076	const_iv (WEAPON)
894	const_iv (ARMOUR)	1077	const_iv (ARMOUR)
895	const_iv (PEDESTAL)	1078	const_iv (PEDESTAL)
…		…
915	const_iv (AMULET)	1098	const_iv (AMULET)
916	const_iv (PLAYERMOVER)	1099	const_iv (PLAYERMOVER)
917	const_iv (TELEPORTER)	1100	const_iv (TELEPORTER)
918	const_iv (CREATOR)	1101	const_iv (CREATOR)
919	const_iv (SKILL)	1102	const_iv (SKILL)
920	const_iv (EXPERIENCE)
921	const_iv (EARTHWALL)	1103	const_iv (EARTHWALL)
922	const_iv (GOLEM)	1104	const_iv (GOLEM)
923	const_iv (THROWN_OBJ)	1105	const_iv (THROWN_OBJ)
924	const_iv (BLINDNESS)	1106	const_iv (BLINDNESS)
925	const_iv (GOD)	1107	const_iv (GOD)
…		…
945	const_iv (FLOOR)	1127	const_iv (FLOOR)
946	const_iv (FLESH)	1128	const_iv (FLESH)
947	const_iv (INORGANIC)	1129	const_iv (INORGANIC)
948	const_iv (SKILL_TOOL)	1130	const_iv (SKILL_TOOL)
949	const_iv (LIGHTER)	1131	const_iv (LIGHTER)
950	const_iv (TRAP_PART)
951	const_iv (WALL)	1132	const_iv (BUILDABLE_WALL)
952	const_iv (LIGHT_SOURCE)
953	const_iv (MISC_OBJECT)	1133	const_iv (MISC_OBJECT)
954	const_iv (MONSTER)
955	const_iv (SPAWN_GENERATOR)
956	const_iv (LAMP)	1134	const_iv (LAMP)
957	const_iv (DUPLICATOR)	1135	const_iv (DUPLICATOR)
958	const_iv (TOOL)
959	const_iv (SPELLBOOK)	1136	const_iv (SPELLBOOK)
960	const_iv (BUILDFAC)
961	const_iv (CLOAK)	1137	const_iv (CLOAK)
962	const_iv (SPINNER)	1138	const_iv (SPINNER)
963	const_iv (GATE)	1139	const_iv (GATE)
964	const_iv (BUTTON)	1140	const_iv (BUTTON)
965	const_iv (CF_HANDLE)	1141	const_iv (CF_HANDLE)
…		…
972	const_iv (SPELL_EFFECT)	1148	const_iv (SPELL_EFFECT)
973	const_iv (CONVERTER)	1149	const_iv (CONVERTER)
974	const_iv (BRACERS)	1150	const_iv (BRACERS)
975	const_iv (POISONING)	1151	const_iv (POISONING)
976	const_iv (SAVEBED)	1152	const_iv (SAVEBED)
977	const_iv (POISONCLOUD)
978	const_iv (FIREHOLES)
979	const_iv (WAND)	1153	const_iv (WAND)
980	const_iv (SCROLL)	1154	const_iv (SCROLL)
981	const_iv (DIRECTOR)	1155	const_iv (DIRECTOR)
982	const_iv (GIRDLE)	1156	const_iv (GIRDLE)
983	const_iv (FORCE)	1157	const_iv (FORCE)
…		…
998	const_iv (DISEASE)	1172	const_iv (DISEASE)
999	const_iv (SYMPTOM)	1173	const_iv (SYMPTOM)
1000	const_iv (BUILDER)	1174	const_iv (BUILDER)
1001	const_iv (MATERIAL)	1175	const_iv (MATERIAL)
1002	const_iv (ITEM_TRANSFORMER)	1176	const_iv (ITEM_TRANSFORMER)
1003	const_iv (QUEST)
1004		1177
1005	const_iv (NUM_SUBTYPES)	1178	const_iv (NUM_SUBTYPES)
1006		1179
1007	const_iv (ST_BD_BUILD)	1180	const_iv (ST_BD_BUILD)
1008	const_iv (ST_BD_REMOVE)	1181	const_iv (ST_BD_REMOVE)
…		…
1036	const_iv (AT_BLIND)	1209	const_iv (AT_BLIND)
1037	const_iv (AT_INTERNAL)	1210	const_iv (AT_INTERNAL)
1038	const_iv (AT_LIFE_STEALING)	1211	const_iv (AT_LIFE_STEALING)
1039	const_iv (AT_DISEASE)	1212	const_iv (AT_DISEASE)
1040		1213
1041	const_iv (QUEST_IN_PROGRESS)
1042	const_iv (QUEST_DONE_QUEST)
1043	const_iv (QUEST_DONE_TASK)
1044	const_iv (QUEST_START_QUEST)
1045	const_iv (QUEST_END_QUEST)
1046	const_iv (QUEST_START_TASK)
1047	const_iv (QUEST_END_TASK)
1048	const_iv (QUEST_OVERRIDE)
1049	const_iv (QUEST_ON_ACTIVATE)
1050
1051	const_iv (WEAP_HIT)	1214	const_iv (WEAP_HIT)
1052	const_iv (WEAP_SLASH)	1215	const_iv (WEAP_SLASH)
1053	const_iv (WEAP_PIERCE)	1216	const_iv (WEAP_PIERCE)
1054	const_iv (WEAP_CLEAVE)	1217	const_iv (WEAP_CLEAVE)
1055	const_iv (WEAP_SLICE)	1218	const_iv (WEAP_SLICE)
…		…
1071	const_iv (FLAG_MONSTER)	1234	const_iv (FLAG_MONSTER)
1072	const_iv (FLAG_FRIENDLY)	1235	const_iv (FLAG_FRIENDLY)
1073	const_iv (FLAG_GENERATOR)	1236	const_iv (FLAG_GENERATOR)
1074	const_iv (FLAG_IS_THROWN)	1237	const_iv (FLAG_IS_THROWN)
1075	const_iv (FLAG_AUTO_APPLY)	1238	const_iv (FLAG_AUTO_APPLY)
1076	const_iv (FLAG_TREASURE)
1077	const_iv (FLAG_PLAYER_SOLD)	1239	const_iv (FLAG_PLAYER_SOLD)
1078	const_iv (FLAG_SEE_INVISIBLE)	1240	const_iv (FLAG_SEE_INVISIBLE)
1079	const_iv (FLAG_CAN_ROLL)	1241	const_iv (FLAG_CAN_ROLL)
1080	const_iv (FLAG_OVERLAY_FLOOR)	1242	const_iv (FLAG_OVERLAY_FLOOR)
1081	const_iv (FLAG_IS_TURNABLE)	1243	const_iv (FLAG_IS_TURNABLE)
…		…
1156	const_iv (FLAG_ACTIVATE_ON_RELEASE)	1318	const_iv (FLAG_ACTIVATE_ON_RELEASE)
1157	const_iv (FLAG_IS_WATER)	1319	const_iv (FLAG_IS_WATER)
1158	const_iv (FLAG_CONTENT_ON_GEN)	1320	const_iv (FLAG_CONTENT_ON_GEN)
1159	const_iv (FLAG_IS_A_TEMPLATE)	1321	const_iv (FLAG_IS_A_TEMPLATE)
1160	const_iv (FLAG_IS_BUILDABLE)	1322	const_iv (FLAG_IS_BUILDABLE)
		1323	const_iv (FLAG_DESTROY_ON_DEATH)
1161	const_iv (FLAG_AFK)	1324	const_iv (FLAG_NO_MAP_SAVE)
1162		1325
1163	const_iv (NDI_BLACK)	1326	const_iv (NDI_BLACK)
1164	const_iv (NDI_WHITE)	1327	const_iv (NDI_WHITE)
1165	const_iv (NDI_NAVY)	1328	const_iv (NDI_NAVY)
1166	const_iv (NDI_RED)	1329	const_iv (NDI_RED)
…		…
1176	const_iv (NDI_MAX_COLOR)	1339	const_iv (NDI_MAX_COLOR)
1177	const_iv (NDI_COLOR_MASK)	1340	const_iv (NDI_COLOR_MASK)
1178	const_iv (NDI_UNIQUE)	1341	const_iv (NDI_UNIQUE)
1179	const_iv (NDI_ALL)	1342	const_iv (NDI_ALL)
1180		1343
		1344	const_iv (UPD_LOCATION)
		1345	const_iv (UPD_FLAGS)
		1346	const_iv (UPD_WEIGHT)
		1347	const_iv (UPD_FACE)
		1348	const_iv (UPD_NAME)
		1349	const_iv (UPD_ANIM)
		1350	const_iv (UPD_ANIMSPEED)
		1351	const_iv (UPD_NROF)
		1352
		1353	const_iv (UPD_SP_MANA)
		1354	const_iv (UPD_SP_GRACE)
		1355	const_iv (UPD_SP_DAMAGE)
		1356
1181	const_iv (F_APPLIED)	1357	const_iv (F_APPLIED)
1182	const_iv (F_LOCATION)	1358	const_iv (F_LOCATION)
1183	const_iv (F_UNPAID)	1359	const_iv (F_UNPAID)
1184	const_iv (F_MAGIC)	1360	const_iv (F_MAGIC)
1185	const_iv (F_CURSED)	1361	const_iv (F_CURSED)
…		…
1191	const_iv (F_BUY)	1367	const_iv (F_BUY)
1192	const_iv (F_SHOP)	1368	const_iv (F_SHOP)
1193	const_iv (F_SELL)	1369	const_iv (F_SELL)
1194		1370
1195	const_iv (P_BLOCKSVIEW)	1371	const_iv (P_BLOCKSVIEW)
		1372	const_iv (P_PLAYER)
1196	const_iv (P_NO_MAGIC)	1373	const_iv (P_NO_MAGIC)
1197	const_iv (P_IS_ALIVE)	1374	const_iv (P_IS_ALIVE)
1198	const_iv (P_NO_CLERIC)	1375	const_iv (P_NO_CLERIC)
1199	const_iv (P_NEED_UPDATE)
1200	const_iv (P_NO_ERROR)
1201	const_iv (P_OUT_OF_MAP)	1376	const_iv (P_OUT_OF_MAP)
1202	const_iv (P_NEW_MAP)	1377	const_iv (P_NEW_MAP)
		1378	const_iv (P_UPTODATE)
1203		1379
1204	const_iv (UP_OBJ_INSERT)	1380	const_iv (UP_OBJ_INSERT)
1205	const_iv (UP_OBJ_REMOVE)	1381	const_iv (UP_OBJ_REMOVE)
1206	const_iv (UP_OBJ_CHANGE)	1382	const_iv (UP_OBJ_CHANGE)
1207	const_iv (UP_OBJ_FACE)	1383	const_iv (UP_OBJ_FACE)
…		…
1239		1415
1240	const_iv (SK_EXP_ADD_SKILL)	1416	const_iv (SK_EXP_ADD_SKILL)
1241	const_iv (SK_EXP_TOTAL)	1417	const_iv (SK_EXP_TOTAL)
1242	const_iv (SK_EXP_NONE)	1418	const_iv (SK_EXP_NONE)
1243	const_iv (SK_SUBTRACT_SKILL_EXP)	1419	const_iv (SK_SUBTRACT_SKILL_EXP)
		1420	const_iv (SK_EXP_SKILL_ONLY)
1244		1421
1245	const_iv (SK_LOCKPICKING)	1422	const_iv (SK_LOCKPICKING)
1246	const_iv (SK_HIDING)	1423	const_iv (SK_HIDING)
1247	const_iv (SK_SMITHERY)	1424	const_iv (SK_SMITHERY)
1248	const_iv (SK_BOWYER)	1425	const_iv (SK_BOWYER)
…		…
1337	const_iv (ATNR_BLIND)	1514	const_iv (ATNR_BLIND)
1338	const_iv (ATNR_INTERNAL)	1515	const_iv (ATNR_INTERNAL)
1339	const_iv (ATNR_LIFE_STEALING)	1516	const_iv (ATNR_LIFE_STEALING)
1340	const_iv (ATNR_DISEASE)	1517	const_iv (ATNR_DISEASE)
1341		1518
1342	const_iv (MAP_FLUSH)
1343	const_iv (MAP_PLAYER_UNIQUE)
1344	const_iv (MAP_BLOCK)
1345	const_iv (MAP_STYLE)
1346	const_iv (MAP_OVERLAY)
1347
1348	const_iv (MAP_IN_MEMORY)	1519	const_iv (MAP_IN_MEMORY)
1349	const_iv (MAP_SWAPPED)	1520	const_iv (MAP_SWAPPED)
1350	const_iv (MAP_LOADING)	1521	const_iv (MAP_LOADING)
1351	const_iv (MAP_SAVING)	1522	const_iv (MAP_SAVING)
1352		1523
		1524	const_iv (KLASS_ATTACHABLE)
1353	const_iv (KLASS_GLOBAL)	1525	const_iv (KLASS_GLOBAL)
1354	const_iv (KLASS_OBJECT)	1526	const_iv (KLASS_OBJECT)
		1527	const_iv (KLASS_CLIENT)
1355	const_iv (KLASS_PLAYER)	1528	const_iv (KLASS_PLAYER)
1356	const_iv (KLASS_MAP)	1529	const_iv (KLASS_MAP)
		1530
		1531	const_iv (CS_QUERY_YESNO)
		1532	const_iv (CS_QUERY_SINGLECHAR)
		1533	const_iv (CS_QUERY_HIDEINPUT)
		1534
		1535	const_iv (ST_DEAD)
		1536	const_iv (ST_SETUP)
		1537	const_iv (ST_PLAYING)
		1538	const_iv (ST_CUSTOM)
		1539
		1540	const_iv (ST_CHANGE_CLASS)
		1541
		1542	const_iv (IO_HEADER)
		1543	const_iv (IO_OBJECTS)
		1544	const_iv (IO_UNIQUES)
		1545
		1546	// random map generator
		1547	const_iv (LAYOUT_NONE)
		1548	const_iv (LAYOUT_ONION)
		1549	const_iv (LAYOUT_MAZE)
		1550	const_iv (LAYOUT_SPIRAL)
		1551	const_iv (LAYOUT_ROGUELIKE)
		1552	const_iv (LAYOUT_SNAKE)
		1553	const_iv (LAYOUT_SQUARE_SPIRAL)
		1554
		1555	const_iv (RMOPT_RANDOM)
		1556	const_iv (RMOPT_CENTERED)
		1557	const_iv (RMOPT_LINEAR)
		1558	const_iv (RMOPT_BOTTOM_C)
		1559	const_iv (RMOPT_BOTTOM_R)
		1560	const_iv (RMOPT_IRR_SPACE)
		1561	const_iv (RMOPT_WALL_OFF)
		1562	const_iv (RMOPT_WALLS_ONLY)
		1563	const_iv (RMOPT_NO_DOORS)
		1564
		1565	const_iv (SYMMETRY_RANDOM)
		1566	const_iv (SYMMETRY_NONE)
		1567	const_iv (SYMMETRY_X)
		1568	const_iv (SYMMETRY_Y)
		1569	const_iv (SYMMETRY_XY)
1357	};	1570	};
1358		1571
1359	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	1572	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1360	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));	1573	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1361		1574
1362	static const struct {	1575	static const struct {
1363	const char *name;	1576	const char *name;
1364	int skip;	1577	int skip;
1365	IV klass;	1578	IV klass;
…		…
1376	{	1589	{
1377	AV *event = newAV ();	1590	AV *event = newAV ();
1378	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));	1591	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));
1379	av_push (event, newSViv (eiv->klass));	1592	av_push (event, newSViv (eiv->klass));
1380	av_store (av, eiv->iv, newRV_noinc ((SV *)event));	1593	av_store (av, eiv->iv, newRV_noinc ((SV *)event));
1381	newCONSTSUB (stash, (char *)eiv->name, newSViv (eiv->iv));	1594	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));
1382	}	1595	}
1383
1384	static const struct {
1385	int dtype;
1386	const char *name;
1387	IV idx;
1388	} *cprop, prop_table[] = {
1389	# define prop(type, name) { type, # name, (IV) CFAPI_ ## name },
1390	prop (CFAPI_INT, MAP_PROP_FLAGS)
1391	prop (CFAPI_INT, MAP_PROP_DIFFICULTY)
1392	prop (CFAPI_STRING, MAP_PROP_PATH)
1393	prop (CFAPI_STRING, MAP_PROP_TMPNAME)
1394	prop (CFAPI_STRING, MAP_PROP_NAME)
1395	prop (CFAPI_INT, MAP_PROP_RESET_TIME)
1396	prop (CFAPI_INT, MAP_PROP_RESET_TIMEOUT)
1397	prop (CFAPI_INT, MAP_PROP_PLAYERS)
1398	prop (CFAPI_INT, MAP_PROP_DARKNESS)
1399	prop (CFAPI_INT, MAP_PROP_WIDTH)
1400	prop (CFAPI_INT, MAP_PROP_HEIGHT)
1401	prop (CFAPI_INT, MAP_PROP_ENTER_X)
1402	prop (CFAPI_INT, MAP_PROP_ENTER_Y)
1403	prop (CFAPI_INT, MAP_PROP_TEMPERATURE)
1404	prop (CFAPI_INT, MAP_PROP_PRESSURE)
1405	prop (CFAPI_INT, MAP_PROP_HUMIDITY)
1406	prop (CFAPI_INT, MAP_PROP_WINDSPEED)
1407	prop (CFAPI_INT, MAP_PROP_WINDDIR)
1408	prop (CFAPI_INT, MAP_PROP_SKY)
1409	prop (CFAPI_INT, MAP_PROP_WPARTX)
1410	prop (CFAPI_INT, MAP_PROP_WPARTY)
1411	prop (CFAPI_STRING, MAP_PROP_MESSAGE)
1412	prop (CFAPI_PMAP, MAP_PROP_NEXT)
1413	prop (CFAPI_PREGION, MAP_PROP_REGION)
1414	prop (CFAPI_POBJECT, OBJECT_PROP_OB_ABOVE)
1415	prop (CFAPI_POBJECT, OBJECT_PROP_OB_BELOW)
1416	prop (CFAPI_POBJECT, OBJECT_PROP_NEXT_ACTIVE_OB)
1417	prop (CFAPI_POBJECT, OBJECT_PROP_PREV_ACTIVE_OB)
1418	prop (CFAPI_POBJECT, OBJECT_PROP_INVENTORY)
1419	prop (CFAPI_POBJECT, OBJECT_PROP_ENVIRONMENT)
1420	prop (CFAPI_POBJECT, OBJECT_PROP_HEAD)
1421	prop (CFAPI_POBJECT, OBJECT_PROP_CONTAINER)
1422	prop (CFAPI_PMAP, OBJECT_PROP_MAP)
1423	prop (CFAPI_INT, OBJECT_PROP_COUNT)
1424	prop (CFAPI_INT, OBJECT_PROP_REFCOUNT)
1425	prop (CFAPI_STRING, OBJECT_PROP_NAME)
1426	prop (CFAPI_STRING, OBJECT_PROP_NAME_PLURAL)
1427	prop (CFAPI_STRING, OBJECT_PROP_TITLE)
1428	prop (CFAPI_STRING, OBJECT_PROP_RACE)
1429	prop (CFAPI_STRING, OBJECT_PROP_SLAYING)
1430	prop (CFAPI_STRING, OBJECT_PROP_SKILL)
1431	prop (CFAPI_STRING, OBJECT_PROP_MESSAGE)
1432	prop (CFAPI_STRING, OBJECT_PROP_LORE)
1433	prop (CFAPI_INT, OBJECT_PROP_X)
1434	prop (CFAPI_INT, OBJECT_PROP_Y)
1435	prop (CFAPI_DOUBLE, OBJECT_PROP_SPEED)
1436	prop (CFAPI_DOUBLE, OBJECT_PROP_SPEED_LEFT)
1437	prop (CFAPI_INT, OBJECT_PROP_NROF)
1438	prop (CFAPI_INT, OBJECT_PROP_DIRECTION)
1439	prop (CFAPI_INT, OBJECT_PROP_FACING)
1440	prop (CFAPI_INT, OBJECT_PROP_TYPE)
1441	prop (CFAPI_INT, OBJECT_PROP_SUBTYPE)
1442	prop (CFAPI_INT, OBJECT_PROP_CLIENT_TYPE)
1443	prop (CFAPI_INT, OBJECT_PROP_ATTACK_TYPE)
1444	prop (CFAPI_INT, OBJECT_PROP_PATH_ATTUNED)
1445	prop (CFAPI_INT, OBJECT_PROP_PATH_REPELLED)
1446	prop (CFAPI_INT, OBJECT_PROP_PATH_DENIED)
1447	prop (CFAPI_INT, OBJECT_PROP_MATERIAL)
1448	prop (CFAPI_STRING, OBJECT_PROP_MATERIAL_NAME)
1449	prop (CFAPI_INT, OBJECT_PROP_MAGIC)
1450	prop (CFAPI_INT, OBJECT_PROP_VALUE)
1451	prop (CFAPI_INT, OBJECT_PROP_LEVEL)
1452	prop (CFAPI_INT, OBJECT_PROP_LAST_HEAL)
1453	prop (CFAPI_INT, OBJECT_PROP_LAST_SP)
1454	prop (CFAPI_INT, OBJECT_PROP_LAST_GRACE)
1455	prop (CFAPI_INT, OBJECT_PROP_LAST_EAT)
1456	prop (CFAPI_INT, OBJECT_PROP_INVISIBLE_TIME)
1457	prop (CFAPI_INT, OBJECT_PROP_PICK_UP)
1458	prop (CFAPI_INT, OBJECT_PROP_ITEM_POWER)
1459	prop (CFAPI_INT, OBJECT_PROP_GEN_SP_ARMOUR)
1460	prop (CFAPI_INT, OBJECT_PROP_WEIGHT)
1461	prop (CFAPI_INT, OBJECT_PROP_WEIGHT_LIMIT)
1462	prop (CFAPI_INT, OBJECT_PROP_CARRYING)
1463	prop (CFAPI_INT, OBJECT_PROP_GLOW_RADIUS)
1464	prop (CFAPI_LONG, OBJECT_PROP_PERM_EXP)
1465	prop (CFAPI_POBJECT, OBJECT_PROP_CURRENT_WEAPON)
1466	prop (CFAPI_POBJECT, OBJECT_PROP_ENEMY)
1467	prop (CFAPI_POBJECT, OBJECT_PROP_ATTACKED_BY)
1468	prop (CFAPI_INT, OBJECT_PROP_RUN_AWAY)
1469	prop (CFAPI_POBJECT, OBJECT_PROP_CHOSEN_SKILL)
1470	prop (CFAPI_INT, OBJECT_PROP_HIDDEN)
1471	prop (CFAPI_INT, OBJECT_PROP_MOVE_STATUS)
1472	prop (CFAPI_INT, OBJECT_PROP_MOVE_TYPE)
1473	prop (CFAPI_POBJECT, OBJECT_PROP_SPELL_ITEM)
1474	prop (CFAPI_DOUBLE, OBJECT_PROP_EXP_MULTIPLIER)
1475	prop (CFAPI_PARCH, OBJECT_PROP_ARCHETYPE)
1476	prop (CFAPI_PARCH, OBJECT_PROP_OTHER_ARCH)
1477	prop (CFAPI_STRING, OBJECT_PROP_CUSTOM_NAME)
1478	prop (CFAPI_INT, OBJECT_PROP_ANIM_SPEED)
1479	prop (CFAPI_INT, OBJECT_PROP_FRIENDLY)
1480	prop (CFAPI_STRING, OBJECT_PROP_SHORT_NAME)
1481	prop (CFAPI_INT, OBJECT_PROP_MAGICAL)
1482	prop (CFAPI_INT, OBJECT_PROP_LUCK)
1483	prop (CFAPI_POBJECT, OBJECT_PROP_OWNER)
1484	prop (CFAPI_POBJECT, OBJECT_PROP_PRESENT)
1485	prop (CFAPI_INT, OBJECT_PROP_CHEATER)
1486	prop (CFAPI_INT, OBJECT_PROP_MERGEABLE)
1487	prop (CFAPI_INT, OBJECT_PROP_PICKABLE)
1488	prop (CFAPI_INT, OBJECT_PROP_STR)
1489	prop (CFAPI_INT, OBJECT_PROP_DEX)
1490	prop (CFAPI_INT, OBJECT_PROP_CON)
1491	prop (CFAPI_INT, OBJECT_PROP_WIS)
1492	prop (CFAPI_INT, OBJECT_PROP_INT)
1493	prop (CFAPI_INT, OBJECT_PROP_POW)
1494	prop (CFAPI_INT, OBJECT_PROP_CHA)
1495	prop (CFAPI_INT, OBJECT_PROP_WC)
1496	prop (CFAPI_INT, OBJECT_PROP_AC)
1497	prop (CFAPI_INT, OBJECT_PROP_HP)
1498	prop (CFAPI_INT, OBJECT_PROP_SP)
1499	prop (CFAPI_INT, OBJECT_PROP_GP)
1500	prop (CFAPI_INT, OBJECT_PROP_FP)
1501	prop (CFAPI_INT, OBJECT_PROP_MAXHP)
1502	prop (CFAPI_INT, OBJECT_PROP_MAXSP)
1503	prop (CFAPI_INT, OBJECT_PROP_MAXGP)
1504	prop (CFAPI_INT, OBJECT_PROP_DAM)
1505	prop (CFAPI_STRING, OBJECT_PROP_GOD)
1506	prop (CFAPI_STRING, OBJECT_PROP_ARCH_NAME)
1507	prop (CFAPI_INT, OBJECT_PROP_INVISIBLE)
1508	prop (CFAPI_INT, OBJECT_PROP_FACE)
1509	};
1510
1511	HV *prop_type = get_hv ("cf::PROP_TYPE", 1);
1512	HV *prop_idx = get_hv ("cf::PROP_IDX", 1);
1513
1514	for (cprop = prop_table + sizeof (prop_table) / sizeof (prop_table [0]); cprop-- > prop_table; )
1515	{
1516	hv_store (prop_type, cprop->name, strlen (cprop->name), newSViv (cprop->dtype), 0);
1517	hv_store (prop_idx, cprop->name, strlen (cprop->name), newSViv (cprop->idx ), 0);
1518	}
1519
1520	//I_EVENT_API (PACKAGE);
1521	}	1596	}
1522		1597
1523	void _reload_1 ()	1598	void _connect_to_perl ()
1524	CODE:
1525	cb_global = get_av ("cf::CB_GLOBAL", 1);
1526	cb_object = get_av ("cf::CB_OBJECT", 1);
1527	cb_player = get_av ("cf::CB_PLAYER", 1);
1528	cb_type = get_av ("cf::CB_TYPE" , 1);
1529	cb_map = get_av ("cf::CB_MAP" , 1);
1530		1599
1531	void _reload_2 ()	1600	void _global_reattach ()
1532	CODE:	1601	CODE:
1533	{	1602	{
1534	// reattach to all attachable objects in the game.	1603	// reattach to all attachable objects in the game.
1535	for (player *pl = first_player; pl; pl = pl->next)	1604	for_all_clients (ns)
1536	reattach (pl);	1605	ns->reattach ();
1537		1606
1538	for (mapstruct *map = first_map; map; map = map->next)	1607	for_all_objects (op)
1539	reattach (map);
1540
1541	for (object *op = objects; op; op = op->next)
1542	reattach (op);	1608	op->reattach ();
1543	}	1609	}
1544		1610
1545	NV floor (NV x)	1611	NV floor (NV x)
1546		1612
1547	NV ceil (NV x)	1613	NV ceil (NV x)
1548		1614
		1615	NV rndm (...)
		1616	CODE:
		1617	switch (items)
		1618	{
		1619	case 0: RETVAL = rndm (); break;
		1620	case 1: RETVAL = rndm (SvUV (ST (0))); break;
		1621	case 2: RETVAL = rndm (SvIV (ST (0)), SvIV (ST (1))); break;
		1622	default: croak ("cf::rndm requires none, one or two parameters."); break;
		1623	}
		1624	OUTPUT:
		1625	RETVAL
		1626
1549	void server_tick ()	1627	void server_tick ()
		1628	CODE:
		1629	runtime = SvNVx (sv_runtime);
		1630	server_tick ();
1550		1631
1551	void	1632	void
1552	LOG (int level, char *msg)	1633	LOG (int level, char *msg)
1553	PROTOTYPE: $$	1634	PROTOTYPE: $$
1554	C_ARGS: (LogLevel)level, "%s", msg	1635	C_ARGS: (LogLevel)level, "%s", msg
…		…
1570	void	1651	void
1571	sub_generation_inc ()	1652	sub_generation_inc ()
1572	CODE:	1653	CODE:
1573	PL_sub_generation++;	1654	PL_sub_generation++;
1574		1655
1575	char *	1656	const char *
1576	mapdir ()	1657	mapdir ()
1577	PROTOTYPE:	1658	PROTOTYPE:
1578	ALIAS:	1659	ALIAS:
1579	mapdir = 0	1660	mapdir = 0
1580	uniquedir = 1	1661	uniquedir = 1
…		…
1594	case 5: RETVAL = settings.playerdir; break;	1675	case 5: RETVAL = settings.playerdir; break;
1595	case 6: RETVAL = settings.datadir ; break;	1676	case 6: RETVAL = settings.datadir ; break;
1596	}	1677	}
1597	OUTPUT: RETVAL	1678	OUTPUT: RETVAL
1598		1679
1599	int	1680	void abort ()
		1681
		1682	void fork_abort (char *cause = "cf::fork_abort")
		1683
		1684	void cleanup (const char *cause, bool make_core = false)
		1685
		1686	void emergency_save ()
		1687
		1688	void _exit (int status = EXIT_SUCCESS)
		1689
		1690	UV sv_2watcher (SV *w)
		1691	CODE:
		1692	RETVAL = (UV)GEventAPI->sv_2watcher (w);
		1693	OUTPUT:
		1694	RETVAL
		1695
		1696	#if _POSIX_MEMLOCK
		1697
		1698	int mlockall (int flags = MCL_CURRENT | MCL_FUTURE)
		1699
		1700	int munlockall ()
		1701
		1702	#endif
		1703
1600	cf_find_animation (char *text)	1704	int find_animation (char *text)
1601	PROTOTYPE: $	1705	PROTOTYPE: $
1602		1706
1603	int random_roll(int min, int max, object *op, int goodbad);	1707	int random_roll (int min, int max, object *op, int goodbad);
1604		1708
1605	const char *cost_string_from_value(uint64 cost, int approx = 0)	1709	const char *cost_string_from_value(uint64 cost, int approx = 0)
1606
1607	int invoke (int event, ...)
1608	CODE:
1609	if (KLASS_OF (event) != KLASS_GLOBAL) croak ("event class must be GLOBAL");
1610	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
1611	for (int i = 1; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
1612	RETVAL = INVOKE_((event_type)event, ARG_AV (av));
1613	OUTPUT: RETVAL
1614		1710
1615	int	1711	int
1616	exp_to_level (val64 exp)	1712	exp_to_level (val64 exp)
1617	CODE:	1713	CODE:
1618	{	1714	{
…		…
1649	RETVAL = newSVpv (resist_plus[atnr], 0);	1745	RETVAL = newSVpv (resist_plus[atnr], 0);
1650	else	1746	else
1651	XSRETURN_UNDEF;	1747	XSRETURN_UNDEF;
1652	OUTPUT: RETVAL	1748	OUTPUT: RETVAL
1653		1749
		1750	bool
		1751	load_resource_file (const char *filename)
		1752
		1753	MODULE = cf PACKAGE = cf::attachable
		1754
		1755	int
		1756	valid (SV *obj)
		1757	CODE:
		1758	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
		1759	OUTPUT:
		1760	RETVAL
		1761
		1762	void
		1763	debug_trace (attachable *obj, bool on = true)
		1764	CODE:
		1765	obj->flags &= ~attachable::F_DEBUG_TRACE;
		1766	if (on)
		1767	obj->flags |= attachable::F_DEBUG_TRACE;
		1768
		1769	int mortals_size ()
		1770	CODE:
		1771	RETVAL = attachable::mortals.size ();
		1772	OUTPUT: RETVAL
		1773
		1774	#object *mortals (U32 index)
		1775	# CODE:
		1776	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;
		1777	# OUTPUT: RETVAL
		1778
		1779	INCLUDE: $PERL $srcdir/genacc attachable ../include/cfperl.h |
		1780
		1781	MODULE = cf PACKAGE = cf::global
		1782
		1783	int invoke (SV *klass, int event, ...)
		1784	CODE:
		1785	if (KLASS_OF (event) != KLASS_GLOBAL) croak ("event class must be GLOBAL");
		1786	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
		1787	for (int i = 1; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
		1788	RETVAL = gbl_ev.invoke ((event_type)event, ARG_AV (av), DT_END);
		1789	OUTPUT: RETVAL
		1790
1654	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_	1791	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
		1792
		1793	INCLUDE: $PERL $srcdir/genacc object ../include/object.h |
1655		1794
1656	int invoke (object *op, int event, ...)	1795	int invoke (object *op, int event, ...)
1657	CODE:	1796	CODE:
1658	if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");	1797	if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");
1659	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	1798	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
1660	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));	1799	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
1661	RETVAL = INVOKE_((event_type)event, ARG_OBJECT (op), ARG_AV (av));	1800	RETVAL = op->invoke ((event_type)event, ARG_AV (av), DT_END);
1662	OUTPUT: RETVAL	1801	OUTPUT: RETVAL
1663		1802
1664	SV *registry (object *op)	1803	SV *registry (object *op)
1665	CODE:
1666	RETVAL = registry_of (op);
1667	OUTPUT:
1668	RETVAL
1669		1804
1670	SV *	1805	int objects_size ()
1671	get_property (object *obj, int type, int idx)
1672	CODE:	1806	CODE:
1673	RETVAL = newSVcfapi (type, cf_object_get_property (obj, idx));	1807	RETVAL = objects.size ();
1674	OUTPUT: RETVAL	1808	OUTPUT: RETVAL
1675		1809
1676	SV *	1810	object *objects (U32 index)
1677	set_property (object *obj, int type, int idx, SV *newval)
1678	CODE:	1811	CODE:
1679	switch (type)	1812	RETVAL = index < objects.size () ? objects [index] : 0;
1680	{	1813	OUTPUT: RETVAL
1681	case CFAPI_INT:	1814
1682	cf_object_set_int_property (obj, idx, SvIV (newval));	1815	int actives_size ()
1683	break;	1816	CODE:
1684	case CFAPI_LONG:	1817	RETVAL = actives.size ();
1685	cf_object_set_long_property (obj, idx, (long) SvVAL64 (newval));	1818	OUTPUT: RETVAL
1686	break;	1819
1687	case CFAPI_DOUBLE:	1820	object *actives (U32 index)
1688	{	1821	CODE:
1689	int unused_type;	1822	RETVAL = index < actives.size () ? actives [index] : 0;
1690	object_set_property (&unused_type, obj, idx, (double)SvNV (newval));	1823	OUTPUT: RETVAL
1691	}
1692	break;
1693	case CFAPI_STRING:
1694	cf_object_set_string_property (obj, idx, SvOK (newval) ? SvPV_nolen (newval) : 0);
1695	break;
1696	case CFAPI_POBJECT:
1697	{
1698	int unused_type;
1699	object_set_property (&unused_type, obj, idx, (object *)SvPTR_ornull (newval, "cf::object"));
1700	}
1701	break;
1702	default:
1703	croak ("unhandled type '%d' in set_property '%d'", type, idx);
1704	}
1705		1824
1706	# missing properties	1825	# missing properties
1707		1826
1708	void	1827	object *head (object *op)
1709	set_attacktype (object *obj, U32 attacktype)	1828	PROTOTYPE: $
1710	CODE:	1829	CODE:
1711	obj->attacktype = attacktype;	1830	RETVAL = op->head_ ();
1712
1713	U32
1714	get_attacktype (object *obj)
1715	ALIAS:
1716	attacktype = 0
1717	CODE:
1718	RETVAL = obj->attacktype;
1719	OUTPUT: RETVAL	1831	OUTPUT: RETVAL
1720		1832
1721	# missing in plug-in api, of course	1833	int is_head (object *op)
1722	void	1834	PROTOTYPE: $
1723	set_food (object *obj, int food)	1835	CODE:
1724	CODE:	1836	RETVAL = op->head_ () == op;
1725	obj->stats.food = food;
1726
1727	int
1728	get_food (object *obj)
1729	ALIAS:
1730	food = 0
1731	CODE:
1732	RETVAL = obj->stats.food;
1733	OUTPUT: RETVAL	1837	OUTPUT: RETVAL
1734		1838
1735	void	1839	void
1736	inv (object *obj)	1840	inv (object *obj)
1737	PROTOTYPE: $	1841	PROTOTYPE: $
1738	PPCODE:	1842	PPCODE:
1739	{	1843	{
1740	object *o;	1844	object *o;
1741	for (o = obj->inv; o; o = o->below)	1845	for (o = obj->inv; o; o = o->below)
1742	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));	1846	XPUSHs (sv_2mortal (to_sv (o)));
1743	}	1847	}
1744		1848
1745	int cf_object_get_resistance (object *op, int rtype)	1849	void
1746	ALIAS: resistance = 0	1850	set_animation (object *op, int idx)
		1851	CODE:
		1852	SET_ANIMATION (op, idx);
1747		1853
1748	int cf_object_get_flag (object *op, int flag)	1854	int
1749	ALIAS: flag = 0	1855	num_animations (object *op)
		1856	CODE:
		1857	RETVAL = NUM_ANIMATIONS (op);
		1858	OUTPUT: RETVAL
1750		1859
1751	void cf_object_set_flag (object *op, int flag, int value)	1860	object *find_best_object_match (object *op, const char *match)
1752		1861
		1862	object *find_marked_object (object *op)
		1863
1753	int need_identify (const object *obj);	1864	int need_identify (object *obj);
1754		1865
1755	int apply_shop_mat (object *shop_mat, object *op);	1866	int apply_shop_mat (object *shop_mat, object *op);
1756		1867
		1868	int move_player (object *op, int dir)
		1869	CODE:
		1870	RETVAL = move_player (op, dir);
		1871	OUTPUT:
		1872	RETVAL
		1873
1757	void cf_object_move (object *op, int dir, object *originator = op)	1874	int move (object *op, int dir, object *originator = op)
		1875	CODE:
		1876	RETVAL = move_ob (op, dir, originator);
		1877	OUTPUT:
		1878	RETVAL
1758		1879
1759	void cf_object_apply (object *op, object *author, int flags = 0)	1880	void apply (object *applier, object *applied, int flags = 0)
		1881	CODE:
		1882	manual_apply (applied, applier, flags);
1760		1883
1761	void cf_object_apply_below (object *op)	1884	void apply_below (object *op)
		1885	CODE:
		1886	player_apply_below (op);
1762		1887
1763	void cf_object_remove (object *op)	1888	int cast_heal (object *op, object *caster, object *spell, int dir = 0)
1764
1765	void cf_object_free (object *op)
1766		1889
1767	object *cf_object_present_archname_inside (object *op, char *whatstr)	1890	object *cf_object_present_archname_inside (object *op, char *whatstr)
1768		1891
1769	int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)	1892	int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)
1770		1893
1771	int cf_object_change_map (object *op, int x, int y, mapstruct *map)	1894	int cf_object_change_map (object *op, int x, int y, maptile *map)
1772		1895
		1896	#//TODO
1773	object *cf_object_clone (object *op, int clonetype = 0)	1897	object *clone_ (object *op, int recursive = 0)
		1898	CODE:
		1899	if (recursive)
		1900	RETVAL = object_create_clone (op);
		1901	else
		1902	{
		1903	RETVAL = object::create ();
		1904	op->copy_to (RETVAL);
		1905	}
		1906	OUTPUT: RETVAL
1774		1907
1775	int cf_object_pay_item (object *op, object *buyer)	1908	int pay_item (object *op, object *buyer)
		1909	CODE:
		1910	RETVAL = pay_for_item (op, buyer);
		1911	OUTPUT: RETVAL
1776		1912
1777	int cf_object_pay_amount (object *op, uint64 amount)	1913	int pay_amount (object *op, uint64 amount)
		1914	CODE:
		1915	RETVAL = pay_for_amount (amount, op);
		1916	OUTPUT: RETVAL
1778		1917
1779	void pay_player (object *op, uint64 amount)	1918	void pay_player (object *op, uint64 amount)
1780		1919
1781	val64 pay_player_arch (object *op, const char *arch, uint64 amount)	1920	val64 pay_player_arch (object *op, const char *arch, uint64 amount)
1782		1921
1783	int cf_object_cast_spell (object *caster, object *ctoo, int dir, object *spell_ob, char *stringarg = 0)	1922	int cast_spell (object *op, object *caster, int dir, object *spell_ob, char *stringarg = 0)
1784		1923
1785	int cf_object_cast_ability (object *caster, object *ctoo, int dir, object *sp_, char *stringarg = 0)	1924	void learn_spell (object *op, object *sp, int special_prayer = 0)
		1925	CODE:
		1926	do_learn_spell (op, sp, special_prayer);
1786		1927
1787	void cf_object_learn_spell (object *op, object *sp)
1788
1789	void cf_object_forget_spell (object *op, object *sp)	1928	void forget_spell (object *op, object *sp)
		1929	CODE:
		1930	do_forget_spell (op, query_name (sp));
1790		1931
1791	object *cf_object_check_for_spell (object *op, char *spellname)	1932	object *check_for_spell (object *op, char *spellname)
		1933	CODE:
		1934	RETVAL = check_spell_known (op, spellname);
		1935	OUTPUT: RETVAL
1792		1936
1793	int cf_object_query_money (object *op)	1937	int query_money (object *op)
1794	ALIAS: money = 0	1938	ALIAS: money = 0
1795		1939
1796	int cf_object_query_cost (object *op, object *who, int flags)	1940	val64 query_cost (object *op, object *who, int flags)
1797	ALIAS: cost = 0	1941	ALIAS: cost = 0
1798		1942
1799	void cf_object_activate_rune (object *op , object *victim)	1943	void spring_trap (object *op, object *victim)
1800		1944
1801	int cf_object_check_trigger (object *op, object *cause)	1945	int check_trigger (object *op, object *cause)
1802		1946
1803	int cf_object_out_of_map (object *op, int x, int y)
1804
1805	void cf_object_drop (object *op, object *author)	1947	void drop (object *who, object *op)
1806		1948
1807	void cf_object_take (object *op, object *author)	1949	void pick_up (object *who, object *op)
1808		1950
1809	void cf_object_say (object *op, char *msg)
1810
1811	void cf_object_speak (object *op, char *msg)
1812
1813	object *cf_object_insert_object (object *op, object *container)
1814
1815	const char *cf_object_get_msg (object *ob)
1816	ALIAS: msg = 0
1817
1818	object *cf_object_insert_in_ob (object *ob, object *where)
1819
1820	int cf_object_teleport (object *op, mapstruct *map, int x, int y)	1951	int cf_object_teleport (object *op, maptile *map, int x, int y)
1821		1952
1822	void cf_object_update (object *op, int flags)	1953	void update_object (object *op, int action)
1823
1824	void cf_object_pickup (object *op, object *what)
1825		1954
1826	object *cf_create_object_by_name (const char *name)	1955	object *cf_create_object_by_name (const char *name)
1827		1956
1828	void change_exp (object *op, uint64 exp, const char *skill_name = 0, int flag = 0)	1957	void change_exp (object *op, uint64 exp, const char *skill_name = 0, int flag = 0)
1829		1958
…		…
1835		1964
1836	void push_button (object *op);	1965	void push_button (object *op);
1837		1966
1838	void use_trigger (object *op);	1967	void use_trigger (object *op);
1839		1968
1840	void add_button_link (object *button, mapstruct *map, int connected);	1969	void add_button_link (object *button, maptile *map, int connected);
1841		1970
1842	void remove_button_link (object *op);	1971	void remove_button_link (object *op);
1843		1972
1844	void
1845	cf_object_set_resistance (object *op, int rtype, int val)
1846	CODE:
1847	if (rtype >= 0 && rtype < NROFATTACKS)
1848	op->resist[rtype] = val;
1849
1850		1973
1851	MODULE = cf PACKAGE = cf::object PREFIX = cf_	1974	MODULE = cf PACKAGE = cf::object PREFIX = cf_
1852
1853	void cf_fix_object (object *pl)
1854	ALIAS: fix = 0
1855		1975
1856	object *cf_insert_ob_in_ob (object *ob, object *where)	1976	object *cf_insert_ob_in_ob (object *ob, object *where)
1857		1977
1858	# no clean way to get an object from an archetype - stupid idiotic	1978	# no clean way to get an object from an archetype - stupid idiotic
1859	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.	1979	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.
…		…
1863	CODE:	1983	CODE:
1864	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();	1984	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();
1865	OUTPUT:	1985	OUTPUT:
1866	RETVAL	1986	RETVAL
1867		1987
1868	object *insert_ob_in_map_at (object *ob, mapstruct *where, object_ornull *orig, int flag, int x, int y)	1988	object *insert_ob_in_map_at (object *ob, maptile *where, object_ornull *orig, int flag, int x, int y)
1869	PROTOTYPE: $$$$$$	1989	PROTOTYPE: $$$$$$
1870	CODE:	1990	CODE:
1871	{	1991	{
1872	int unused_type;	1992	int unused_type;
1873	RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);	1993	RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);
…		…
1911	bool on_same_map_as (object *ob, object *other)	2031	bool on_same_map_as (object *ob, object *other)
1912	CODE:	2032	CODE:
1913	RETVAL = on_same_map (ob, other);	2033	RETVAL = on_same_map (ob, other);
1914	OUTPUT: RETVAL	2034	OUTPUT: RETVAL
1915		2035
1916	char *	2036	const char *
1917	base_name (object *ob, int plural)	2037	base_name (object *op, int plural = op->nrof > 1)
1918	CODE:	2038	CODE:
1919	RETVAL = cf_query_base_name (ob, plural);	2039	RETVAL = query_base_name (op, plural);
1920	OUTPUT: RETVAL	2040	OUTPUT: RETVAL
1921		2041
1922	living *	2042	object *decrease_ob_nr (object *op, unsigned long i)
1923	stats (object *ob)
1924	CODE:
1925	RETVAL = &ob->stats;
1926	OUTPUT: RETVAL
1927
1928		2043
1929	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_	2044	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_
1930		2045
1931	player *player (object *op)	2046	player *player (object *op)
1932	CODE:	2047	CODE:
1933	RETVAL = op->contr;	2048	RETVAL = op->contr;
1934	OUTPUT: RETVAL	2049	OUTPUT: RETVAL
1935		2050
		2051	void check_score (object *op)
		2052
1936	void cf_player_message (object *obj, char *txt, int flags = NDI_ORANGE | NDI_UNIQUE)	2053	void message (object *op, char *txt, int flags = NDI_ORANGE | NDI_UNIQUE)
		2054	CODE:
		2055	new_draw_info (flags, 0, op, txt);
1937		2056
1938	object *cf_player_send_inventory (object *op)	2057	object *cf_player_send_inventory (object *op)
1939		2058
1940	char *cf_player_get_ip (object *op)	2059	char *cf_player_get_ip (object *op)
1941	ALIAS: ip = 0	2060	ALIAS: ip = 0
…		…
1950		2069
1951	void cf_player_set_party (object *op, partylist *party)	2070	void cf_player_set_party (object *op, partylist *party)
1952		2071
1953	void kill_player (object *op)	2072	void kill_player (object *op)
1954		2073
		2074	void esrv_update_item (object *op, int what, object *item)
		2075	C_ARGS: what, op, item
		2076
		2077	void clear_los (object *op)
		2078
		2079	int command_summon (object *op, char *params)
		2080
		2081	int command_arrest (object *op, char *params)
		2082
		2083
1955	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_	2084	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
		2085
		2086	INCLUDE: $PERL $srcdir/genacc player ../include/player.h |
1956		2087
1957	int invoke (player *pl, int event, ...)	2088	int invoke (player *pl, int event, ...)
1958	CODE:	2089	CODE:
1959	if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");	2090	if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");
1960	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	2091	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
1961	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));	2092	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
1962	RETVAL = INVOKE_((event_type)event, ARG_PLAYER (pl), ARG_AV (av));	2093	RETVAL = pl->invoke ((event_type)event, ARG_AV (av), DT_END);
1963	OUTPUT: RETVAL	2094	OUTPUT: RETVAL
1964		2095
1965	SV *registry (player *pl)	2096	SV *registry (player *pl)
		2097
		2098	void
		2099	save_stats (player *pl)
1966	CODE:	2100	CODE:
1967	RETVAL = registry_of (pl);	2101	pl->ob->stats.hp = pl->ob->stats.maxhp;
		2102	pl->ob->stats.sp = pl->ob->stats.maxsp;
		2103	pl->ob->stats.grace = pl->ob->stats.maxgrace;
		2104	pl->orig_stats = pl->ob->stats;
		2105
		2106	void cf_player_move (player *pl, int dir)
		2107
		2108	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);
		2109
		2110	bool
		2111	cell_visible (player *pl, int dx, int dy)
		2112	CODE:
		2113	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2
		2114	&& !pl->blocked_los [dx + pl->ns->mapx / 2][dy + pl->ns->mapy / 2];
1968	OUTPUT:	2115	OUTPUT:
1969	RETVAL	2116	RETVAL
1970		2117
1971	player *cf_player_find (char *name)
1972	PROTOTYPE: $
1973
1974	void cf_player_move (player *pl, int dir)
1975
1976	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);
1977
1978	# nonstandard
1979	object *ob (player *pl)
1980	CODE:
1981	RETVAL = pl->ob;
1982	OUTPUT: RETVAL
1983
1984	player *first ()
1985	CODE:
1986	RETVAL = first_player;
1987	OUTPUT: RETVAL
1988
1989	player *next (player *pl)
1990	CODE:
1991	RETVAL = pl->next;
1992	OUTPUT: RETVAL
1993
1994	bool
1995	cell_visible (player *pl, int dx, int dy)
1996	CODE:
1997	RETVAL = FABS (dx) <= pl->socket.mapx / 2 && FABS (dy) <= pl->socket.mapy / 2
1998	&& !pl->blocked_los [dx + pl->socket.mapx / 2][dy + pl->socket.mapy / 2];
1999	OUTPUT:
2000	RETVAL
2001
2002	char *
2003	client (player *pl)
2004	CODE:
2005	RETVAL = pl->socket.client;
2006	OUTPUT:
2007	RETVAL
2008
2009	char *
2010	host (player *pl)
2011	CODE:
2012	RETVAL = pl->socket.host;
2013	OUTPUT:
2014	RETVAL
2015
2016	char *
2017	killer (player *pl, char *killer = 0)
2018	CODE:
2019	if (killer)
2020	snprintf (pl->killer, sizeof (pl->killer), "%s", killer);
2021	RETVAL = pl->killer;
2022	OUTPUT:
2023	RETVAL
2024
2025	void
2026	buggy_mapscroll (player *pl, int value = 1)
2027	CODE:
2028	pl->socket.buggy_mapscroll = value;
2029
2030	void	2118	void
2031	send (player *pl, SV *packet)	2119	send (player *pl, SV *packet)
2032	CODE:	2120	CODE:
2033	{	2121	{
2034	STRLEN len;	2122	STRLEN len;
2035	char *buf = SvPVbyte (packet, len);	2123	char *buf = SvPVbyte (packet, len);
2036		2124
2037	Write_String_To_Socket (&pl->socket, buf, len);	2125	if (pl->ns)
		2126	pl->ns->send_packet (buf, len);
2038	}	2127	}
2039		2128
2040	int	2129	int
2041	listening (player *pl, int new_value = -1)	2130	listening (player *pl, int new_value = -1)
2042	CODE:	2131	CODE:
…		…
2044	if (new_value >= 0)	2133	if (new_value >= 0)
2045	pl->listening = new_value;	2134	pl->listening = new_value;
2046	OUTPUT:	2135	OUTPUT:
2047	RETVAL	2136	RETVAL
2048		2137
2049	void get_savebed (player *pl)	2138	void savebed (player *pl, SV *map_path = 0, SV *x = 0, SV *y = 0)
2050	ALIAS:	2139	PROTOTYPE: $;$$$
2051	savebed = 0
2052	PPCODE:	2140	PPCODE:
		2141	if (GIMME_V != G_VOID)
		2142	{
2053	EXTEND (SP, 3);	2143	EXTEND (SP, 3);
2054	PUSHs (sv_2mortal (newSVpv (pl->savebed_map, 0)));	2144	PUSHs (sv_2mortal (newSVpv (pl->savebed_map, 0)));
2055	PUSHs (sv_2mortal (newSViv (pl->bed_x)));	2145	PUSHs (sv_2mortal (newSViv (pl->bed_x)));
2056	PUSHs (sv_2mortal (newSViv (pl->bed_y)));	2146	PUSHs (sv_2mortal (newSViv (pl->bed_y)));
2057		2147	}
2058	void set_savebed (player *pl, char *map_path, int x, int y)	2148	if (map_path) sv_to (map_path, pl->savebed_map);
2059	CODE:	2149	if (x) sv_to (x, pl->bed_x);
2060	strcpy (pl->savebed_map, map_path);	2150	if (y) sv_to (y, pl->bed_y);
2061	pl->bed_x = x;
2062	pl->bed_y = y;
2063		2151
2064	void	2152	void
2065	list ()	2153	list ()
2066	PPCODE:	2154	PPCODE:
2067	{	2155	for_all_players (pl)
2068	player *pl;	2156	XPUSHs (sv_2mortal (to_sv (pl)));
2069	for (pl = first_player; pl; pl = pl->next)
2070	XPUSHs (newSVcfapi (CFAPI_PPLAYER, pl));
2071	}
2072
2073	bool
2074	peaceful (player *pl, bool new_setting = 0)
2075	PROTOTYPE: $;$
2076	CODE:
2077	RETVAL = pl->peaceful;
2078	if (items > 1)
2079	pl->peaceful = new_setting;
2080	OUTPUT:
2081	RETVAL
2082
2083	living *
2084	orig_stats (player *pl)
2085	CODE:
2086	RETVAL = &pl->orig_stats;
2087	OUTPUT: RETVAL
2088
2089	living *
2090	last_stats (player *pl)
2091	CODE:
2092	RETVAL = &pl->last_stats;
2093	OUTPUT: RETVAL
2094		2157
2095		2158
2096	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_	2159	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_
2097		2160
2098	void
2099	trigger (mapstruct *map, long connection, bool state = true)
2100	CODE:
2101	activate_connection (map, connection, state);
2102
2103	void
2104	get_connection (mapstruct *map, long connection)
2105	PPCODE:
2106	{
2107	oblinkpt *obp = get_connection_links (map, connection);
2108	if (obp)
2109	for (objectlink *ol = obp->link; ol; ol = ol->next)
2110	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, ol->ob)));
2111	}
2112
2113	int invoke (mapstruct *map, int event, ...)	2161	int invoke (maptile *map, int event, ...)
2114	CODE:	2162	CODE:
2115	if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");	2163	if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");
2116	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	2164	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
2117	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));	2165	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
2118	RETVAL = INVOKE_((event_type)event, ARG_MAP (map), ARG_AV (av));	2166	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);
2119	OUTPUT: RETVAL	2167	OUTPUT: RETVAL
2120		2168
2121	SV *registry (mapstruct *map)	2169	SV *registry (maptile *map)
2122	CODE:
2123	RETVAL = registry_of (map);
2124	OUTPUT:
2125	RETVAL
2126		2170
2127	SV *	2171	INCLUDE: $PERL $srcdir/genacc maptile ../include/map.h |
2128	get_property (mapstruct *obj, int type, int idx)
2129	CODE:
2130	RETVAL = newSVcfapi (type, cf_map_get_property (obj, idx));
2131	OUTPUT: RETVAL
2132		2172
2133	SV *	2173	void
2134	set_property (mapstruct *obj, int type, int idx, SV *newval)	2174	maptile::instantiate ()
2135	CODE:
2136	switch (type)
2137	{
2138	case CFAPI_INT:
2139	cf_map_set_int_property (obj, idx, SvIV (newval));
2140	break;
2141	default:
2142	croak ("unhandled type '%d' in set_property '%d'", type, idx);
2143	}
2144		2175
2145	mapstruct *new (int width, int height)	2176	maptile *new ()
2146	PROTOTYPE:	2177	PROTOTYPE:
2147	CODE:	2178	CODE:
2148	{	2179	RETVAL = new maptile;
2149	int unused_type;
2150	RETVAL = (mapstruct*) map_get_map (&unused_type, 0, width, height);
2151	}
2152	OUTPUT:	2180	OUTPUT:
2153	RETVAL	2181	RETVAL
2154		2182
2155	void delete_map (mapstruct *map)	2183	void
		2184	maptile::players ()
		2185	PPCODE:
		2186	if (GIMME_V == G_SCALAR)
		2187	XPUSHs (sv_2mortal (to_sv (THIS->players)));
		2188	else if (GIMME_V == G_ARRAY)
		2189	{
		2190	EXTEND (SP, THIS->players);
		2191	for_all_players (pl)
		2192	if (pl->ob && pl->ob->map == THIS)
		2193	PUSHs (sv_2mortal (to_sv (pl->ob)));
		2194	}
2156		2195
2157	void clean_tmp_map (mapstruct *map)	2196	void
		2197	maptile::add_underlay (SV *data, int offset, int stride, SV *palette)
		2198	CODE:
		2199	{
		2200	if (!SvROK (palette) || SvTYPE (SvRV (palette)) != SVt_PVAV)
		2201	croak ("maptile::add_underlay: palette must be arrayref");
2158		2202
		2203	palette = SvRV (palette);
		2204
		2205	STRLEN idxlen;
		2206	const uint8_t *idx = (const uint8_t *)SvPVbyte (data, idxlen);
		2207
		2208	for (int x = 0; x < THIS->width; ++x)
		2209	for (int y = 0; y < THIS->height; ++y)
		2210	{
		2211	for (object *op = THIS->at (x, y).bot; op; op = op->above)
		2212	if (op->flag [FLAG_IS_FLOOR])
		2213	goto skip_space;
		2214
		2215	{
		2216	int offs = offset + y * stride + x;
		2217	if (IN_RANGE_EXC (offs, 0, idxlen))
		2218	{
		2219	if (SV **elem = av_fetch ((AV *)palette, idx [offs], 0))
		2220	{
		2221	object *ob = get_archetype (SvPVutf8_nolen (*elem));
		2222	ob->flag [FLAG_NO_MAP_SAVE] = true;
		2223	THIS->insert (ob, x, y, 0, INS_ABOVE_FLOOR_ONLY);
		2224	}
		2225	}
		2226	}
		2227
		2228	skip_space: ;
		2229	}
		2230	}
		2231
		2232	void
		2233	maptile::set_regiondata (SV *data, int offset, int stride, SV *palette)
		2234	CODE:
		2235	{
		2236	if (!SvROK (palette) || SvTYPE (SvRV (palette)) != SVt_PVAV)
		2237	croak ("maptile::set_regiondata: palette must be arrayref");
		2238
		2239	palette = SvRV (palette);
		2240
		2241	STRLEN idxlen;
		2242	const uint8_t *idx = (const uint8_t *)SvPVbyte (data, idxlen);
		2243
		2244	region **regionmap = (region **)malloc (
		2245	(av_len ((AV *)palette) + 1) * sizeof (region *));
		2246	uint8_t *regions = salloc<uint8_t> (THIS->size ());
		2247
		2248	for (int i = av_len ((AV *)palette) + 1; i--; )
		2249	regionmap [i] = region::find (
		2250	SvPVutf8_nolen (*av_fetch ((AV *)palette, i, 1)));
		2251
		2252	for (int y = 0; y < THIS->height; ++y)
		2253	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);
		2254
		2255	sfree (THIS->regions, THIS->size ());
		2256	free (THIS->regionmap);
		2257
		2258	THIS->regions = regions;
		2259	THIS->regionmap = regionmap;
		2260	}
		2261
2159	void play_sound_map (mapstruct *map, int x, int y, int sound_num)	2262	void play_sound_map (maptile *map, int x, int y, int sound_num)
2160		2263
2161	mapstruct *tile_map (mapstruct *map, unsigned int dir)	2264	int out_of_map (maptile *map, int x, int y)
2162	CODE:
2163	RETVAL = dir < 4 ? map->tile_map [dir] : 0;
2164	OUTPUT:
2165	RETVAL
2166		2265
2167	char *tile_path (mapstruct *map, unsigned int dir)	2266	void
2168	CODE:	2267	trigger (maptile *map, long connection, bool state = true)
2169	if (dir >= 4)	2268	CODE:
2170	XSRETURN_UNDEF;	2269	activate_connection (map, connection, state);
2171	RETVAL = map->tile_path [dir];
2172	OUTPUT:
2173	RETVAL
2174		2270
2175	mapstruct *cf_map_get_map (char *name)	2271	void
2176	PROTOTYPE: $	2272	get_connection (maptile *map, long connection)
2177	ALIAS: map = 0	2273	PPCODE:
		2274	oblinkpt *obp = get_connection_links (map, connection);
		2275	if (obp)
		2276	for (objectlink *ol = obp->link; ol; ol = ol->next)
		2277	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, (object *)ol->ob)));
2178		2278
2179	mapstruct *has_been_loaded (char *name)
2180	PROTOTYPE: $
2181
2182	mapstruct *cf_map_get_first ()
2183	PROTOTYPE:
2184	ALIAS: first = 0
2185
2186	# whoever "designed" the plug-in api should have wasted
2187	# his/her time with staying away from the project - would have
2188	# saved others a lot of time, without doubt.
2189	void set_path (mapstruct *where, char *path)
2190	CODE:
2191	strcpy (where->path, path);
2192
2193	int in_memory (mapstruct *map)
2194	CODE:
2195	RETVAL = map->in_memory;
2196	OUTPUT:
2197	RETVAL
2198
2199	bool unique (mapstruct *map)
2200	CODE:
2201	RETVAL = map->unique;
2202	OUTPUT:
2203	RETVAL
2204
2205	void set_unique (mapstruct *map, bool unique)
2206	CODE:
2207	map->unique = unique;
2208
2209	object *cf_map_insert_object_there (mapstruct *where, object *op, object *originator, int flags)	2279	object *cf_map_insert_object_there (maptile *where, object *op, object *originator, int flags)
2210		2280
2211	object *cf_map_insert_object (mapstruct *where, object* op, int x, int y)	2281	object *cf_map_insert_object (maptile *where, object* op, int x, int y)
2212		2282
2213	object* cf_map_present_arch_by_name (mapstruct *map, const char* str, int nx, int ny)	2283	object* cf_map_present_arch_by_name (maptile *map, const char* str, int nx, int ny)
2214	C_ARGS: str, map, nx, ny	2284	C_ARGS: str, map, nx, ny
2215		2285
2216	void	2286	void
2217	cf_map_normalise (mapstruct *map, int x, int y)	2287	get_map_flags (maptile *map, int x, int y)
2218	PPCODE:	2288	PPCODE:
2219	{	2289	{
2220	mapstruct *nmap = 0;	2290	maptile *nmap = 0;
2221	I16 nx = 0, ny = 0;	2291	I16 nx = 0, ny = 0;
2222	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);	2292	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
2223		2293
2224	EXTEND (SP, 4);	2294	EXTEND (SP, 4);
2225	PUSHs (sv_2mortal (newSViv (flags)));	2295	PUSHs (sv_2mortal (newSViv (flags)));
…		…
2231	PUSHs (sv_2mortal (newSViv (ny)));	2301	PUSHs (sv_2mortal (newSViv (ny)));
2232	}	2302	}
2233	}	2303	}
2234		2304
2235	void	2305	void
2236	at (mapstruct *map, unsigned int x, unsigned int y)	2306	at (maptile *map, unsigned int x, unsigned int y)
2237	PROTOTYPE: $$$	2307	PROTOTYPE: $$$
2238	PPCODE:	2308	PPCODE:
2239	{	2309	{
2240	object *o;	2310	object *o;
2241	mapstruct *nmap = 0;	2311	maptile *nmap = 0;
2242	I16 nx, ny;	2312	I16 nx, ny;
2243		2313
2244	get_map_flags (map, &nmap, x, y, &nx, &ny);	2314	get_map_flags (map, &nmap, x, y, &nx, &ny);
2245		2315
2246	if (nmap)	2316	if (nmap)
2247	for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)	2317	for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)
2248	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));	2318	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));
2249	}	2319	}
2250		2320
2251	SV *	2321	SV *
2252	bot_at (mapstruct *obj, unsigned int x, unsigned int y)	2322	bot_at (maptile *obj, unsigned int x, unsigned int y)
2253	PROTOTYPE: $$$	2323	PROTOTYPE: $$$
2254	ALIAS:	2324	ALIAS:
2255	top_at = 1	2325	top_at = 1
2256	flags_at = 2	2326	flags_at = 2
2257	light_at = 3	2327	light_at = 3
2258	move_block_at = 4	2328	move_block_at = 4
2259	move_slow_at = 5	2329	move_slow_at = 5
2260	move_on_at = 6	2330	move_on_at = 6
2261	move_off_at = 7	2331	move_off_at = 7
2262	INIT:	2332	INIT:
2263	if (x >= MAP_WIDTH (obj) || y >= MAP_HEIGHT (obj)) XSRETURN_UNDEF;	2333	if (x >= obj->width || y >= obj->height) XSRETURN_UNDEF;
2264	CODE:	2334	CODE:
2265	switch (ix)	2335	switch (ix)
2266	{	2336	{
2267	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;	2337	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;
2268	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;	2338	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;
…		…
2271	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;	2341	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;
2272	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;	2342	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;
2273	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;	2343	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;
2274	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;	2344	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;
2275	}	2345	}
		2346	OUTPUT: RETVAL
		2347
		2348	void fix_walls (maptile *map, int x, int y)
		2349
		2350	void fix_walls_around (maptile *map, int x, int y)
		2351
		2352	# worst xs function of my life
		2353	bool
		2354	_create_random_map (\
		2355	maptile *self,\
		2356	char *wallstyle,\
		2357	char *wall_name,\
		2358	char *floorstyle,\
		2359	char *monsterstyle,\
		2360	char *treasurestyle,\
		2361	char *layoutstyle,\
		2362	char *doorstyle,\
		2363	char *decorstyle,\
		2364	char *origin_map,\
		2365	char *final_map,\
		2366	char *exitstyle,\
		2367	char *this_map,\
		2368	char *exit_on_final_map,\
		2369	int xsize,\
		2370	int ysize,\
		2371	int expand2x,\
		2372	int layoutoptions1,\
		2373	int layoutoptions2,\
		2374	int layoutoptions3,\
		2375	int symmetry,\
		2376	int difficulty,\
		2377	int difficulty_given,\
		2378	float difficulty_increase,\
		2379	int dungeon_level,\
		2380	int dungeon_depth,\
		2381	int decoroptions,\
		2382	int orientation,\
		2383	int origin_y,\
		2384	int origin_x,\
		2385	U32 random_seed,\
		2386	val64 total_map_hp,\
		2387	int map_layout_style,\
		2388	int treasureoptions,\
		2389	int symmetry_used,\
		2390	region *region,\
		2391	char *custom\
		2392	)
		2393	CODE:
		2394	{
		2395	random_map_params rmp;
		2396
		2397	assign (rmp.wallstyle , wallstyle);
		2398	assign (rmp.wall_name , wall_name);
		2399	assign (rmp.floorstyle , floorstyle);
		2400	assign (rmp.monsterstyle , monsterstyle);
		2401	assign (rmp.treasurestyle , treasurestyle);
		2402	assign (rmp.layoutstyle , layoutstyle);
		2403	assign (rmp.doorstyle , doorstyle);
		2404	assign (rmp.decorstyle , decorstyle);
		2405	assign (rmp.exitstyle , exitstyle);
		2406	assign (rmp.exit_on_final_map, exit_on_final_map);
		2407
		2408	rmp.origin_map = origin_map;
		2409	rmp.final_map = final_map;
		2410	rmp.this_map = this_map;
		2411	rmp.xsize = xsize;
		2412	rmp.ysize = ysize;
		2413	rmp.expand2x = expand2x;
		2414	rmp.layoutoptions1 = layoutoptions1;
		2415	rmp.layoutoptions2 = layoutoptions2;
		2416	rmp.layoutoptions3 = layoutoptions3;
		2417	rmp.symmetry = symmetry;
		2418	rmp.difficulty = difficulty;
		2419	rmp.difficulty_given = difficulty_given;
		2420	rmp.difficulty_increase = difficulty_increase;
		2421	rmp.dungeon_level = dungeon_level;
		2422	rmp.dungeon_depth = dungeon_depth;
		2423	rmp.decoroptions = decoroptions;
		2424	rmp.orientation = orientation;
		2425	rmp.origin_y = origin_y;
		2426	rmp.origin_x = origin_x;
		2427	rmp.random_seed = random_seed;
		2428	rmp.total_map_hp = total_map_hp;
		2429	rmp.map_layout_style = map_layout_style;
		2430	rmp.treasureoptions = treasureoptions;
		2431	rmp.symmetry_used = symmetry_used;
		2432	rmp.region = region;
		2433	rmp.custom = custom;
		2434
		2435	RETVAL = self->generate_random_map (&rmp);
		2436	}
		2437	OUTPUT:
		2438	RETVAL
		2439
		2440	MODULE = cf PACKAGE = cf::arch
		2441
		2442	archetype *find (const char *name)
		2443	CODE:
		2444	RETVAL = archetype::find (name);
2276	OUTPUT:	2445	OUTPUT:
2277	RETVAL	2446	RETVAL
2278
2279	# "deserialise" perl map data into the map # TODO# compatibility cruft, remove
2280	void
2281	_set_obs (mapstruct *map, SV *sv)
2282	CODE:
2283	{
2284	object *o;
2285	AV *av;
2286	int x, y;
2287	AV *obs = (AV *)SvRV (sv);
2288
2289	for (y = 0; y < MAP_HEIGHT (map); y++)
2290	for (x = 0; x < MAP_WIDTH (map); x++)
2291	{
2292	sv = *av_fetch (obs, x + y * MAP_HEIGHT (map), 1);
2293
2294	if (!SvROK (sv))
2295	continue;
2296
2297	av = (AV *)SvRV (sv);
2298
2299	for (o = GET_MAP_OB (map, x, y); o; o = o->above)
2300	{
2301	sv = av_shift (av);
2302
2303	if (SvROK (sv))
2304	{
2305	sv_magic ((SV *)SvRV (sv), 0, PERL_MAGIC_ext, (char *)o, 0);
2306	SVptr_cache_set (o, sv);
2307	}
2308	}
2309	}
2310	}
2311
2312
2313	MODULE = cf PACKAGE = cf::arch
2314		2447
2315	archetype *first()	2448	archetype *first()
2316	PROTOTYPE:	2449	PROTOTYPE:
2317	CODE:	2450	CODE:
2318	RETVAL = first_archetype;	2451	RETVAL = first_archetype;
2319	OUTPUT: RETVAL	2452	OUTPUT: RETVAL
2320		2453
2321	archetype *next (archetype *arch)	2454	INCLUDE: $PERL $srcdir/genacc archetype ../include/object.h |
2322	CODE:
2323	RETVAL = arch->next;
2324	OUTPUT: RETVAL
2325
2326	archetype *head (archetype *arch)
2327	CODE:
2328	RETVAL = arch->head;
2329	OUTPUT: RETVAL
2330
2331	archetype *more (archetype *arch)
2332	CODE:
2333	RETVAL = arch->more;
2334	OUTPUT: RETVAL
2335
2336	const char *name (archetype *arch)
2337	CODE:
2338	RETVAL = arch->name;
2339	OUTPUT: RETVAL
2340
2341	object *clone (archetype *arch)
2342	CODE:
2343	RETVAL = &arch->clone;
2344	OUTPUT: RETVAL
2345		2455
2346	MODULE = cf PACKAGE = cf::party	2456	MODULE = cf PACKAGE = cf::party
2347		2457
2348	partylist *first ()	2458	partylist *first ()
2349	PROTOTYPE:	2459	PROTOTYPE:
2350	CODE:	2460	CODE:
2351	RETVAL = get_firstparty ();	2461	RETVAL = get_firstparty ();
2352	OUTPUT: RETVAL	2462	OUTPUT: RETVAL
2353		2463
2354	partylist *next (partylist *party)	2464	INCLUDE: $PERL $srcdir/genacc partylist ../include/player.h |
		2465
		2466	MODULE = cf PACKAGE = cf::region
		2467
		2468	void
		2469	list ()
		2470	PPCODE:
		2471	for_all_regions (rgn)
		2472	XPUSHs (sv_2mortal (to_sv (rgn)));
		2473
		2474	region *find (char *name)
		2475	PROTOTYPE: $
2355	CODE:	2476	CODE:
2356	RETVAL = party->next;	2477	RETVAL = region::find (name);
2357	OUTPUT: RETVAL	2478	OUTPUT: RETVAL
2358		2479
2359	const char *name (partylist *party)	2480	region *find_fuzzy (char *name)
		2481	PROTOTYPE: $
2360	CODE:	2482	CODE:
2361	RETVAL = party->partyname;	2483	RETVAL = region::find_fuzzy (name);
2362	OUTPUT: RETVAL	2484	OUTPUT: RETVAL
2363		2485
2364	const char *password (partylist *party)	2486	INCLUDE: $PERL $srcdir/genacc region ../include/map.h |
2365	CODE:
2366	RETVAL = party->passwd;
2367	OUTPUT: RETVAL
2368
2369	MODULE = cf PACKAGE = cf::region
2370
2371	region *first ()
2372	PROTOTYPE:
2373	CODE:
2374	RETVAL = first_region;
2375	OUTPUT: RETVAL
2376
2377	region *next (region *reg)
2378	CODE:
2379	RETVAL = reg->next;
2380	OUTPUT: RETVAL
2381
2382	const char *name (region *reg)
2383	CODE:
2384	RETVAL = reg->name;
2385	OUTPUT: RETVAL
2386
2387	region *parent (region *reg)
2388	CODE:
2389	RETVAL = reg->parent;
2390	OUTPUT: RETVAL
2391
2392	const char *longname (region *reg)
2393	CODE:
2394	RETVAL = reg->longname;
2395	OUTPUT: RETVAL
2396
2397	const char *msg (region *reg)
2398	CODE:
2399	RETVAL = reg->msg;
2400	OUTPUT: RETVAL
2401		2487
2402	MODULE = cf PACKAGE = cf::living	2488	MODULE = cf PACKAGE = cf::living
2403		2489
2404	val64	2490	INCLUDE: $PERL $srcdir/genacc living ../include/living.h |
2405	exp (living *liv, val64 new_val = 0)	2491
2406	PROTOTYPE: $;$	2492	MODULE = cf PACKAGE = cf::settings
2407	ALIAS:	2493
2408	Str = 1	2494	INCLUDE: $PERL $srcdir/genacc Settings ../include/global.h |
2409	Dex = 2	2495
2410	Con = 3	2496	MODULE = cf PACKAGE = cf::client
2411	Wis = 4	2497
2412	Cha = 5	2498	INCLUDE: $PERL $srcdir/genacc client ../include/client.h |
2413	Int = 6	2499
2414	Pow = 7	2500	int invoke (client *ns, int event, ...)
2415	wc = 8	2501	CODE:
2416	ac = 9	2502	if (KLASS_OF (event) != KLASS_CLIENT) croak ("event class must be CLIENT");
2417	hp = 10	2503	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
2418	maxhp = 11	2504	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
2419	sp = 12	2505	RETVAL = ns->invoke ((event_type)event, ARG_AV (av), DT_END);
2420	maxsp = 13	2506	OUTPUT: RETVAL
2421	grace = 14	2507
2422	maxgrace = 15	2508	SV *registry (client *ns)
2423	food = 16	2509
2424	dam = 17	2510	void
2425	luck = 18	2511	list ()
2426	CODE:	2512	PPCODE:
2427	# define LIVING_ACC(acc,idx) case idx: RETVAL = liv->acc; if (items > 1) liv->acc = (sint64)new_val; break	2513	EXTEND (SP, clients.size ());
2428	switch (ix)	2514	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
		2515	PUSHs (sv_2mortal (to_sv (*i)));
		2516
		2517	void
		2518	client::send_packet (SV *packet)
		2519	CODE:
		2520	{
		2521	STRLEN len;
		2522	char *buf = SvPVbyte (packet, len);
		2523
		2524	THIS->send_packet (buf, len);
		2525	}
		2526
		2527	MODULE = cf PACKAGE = cf::face PREFIX = face_
		2528
		2529	INCLUDE: $PERL $srcdir/genacc faceset ../include/face.h |
		2530
		2531	faceidx face_find (const char *name, faceidx defidx = 0)
		2532
		2533	faceidx alloc (const char *name)
		2534	CODE:
		2535	{
		2536	do
2429	{	2537	{
2430	LIVING_ACC (exp , 0);	2538	RETVAL = faces.size ();
2431	LIVING_ACC (Str , 1);	2539	faces.resize (RETVAL + 1);
2432	LIVING_ACC (Dex , 2);
2433	LIVING_ACC (Con , 3);
2434	LIVING_ACC (Wis , 4);
2435	LIVING_ACC (Cha , 5);
2436	LIVING_ACC (Int , 6);
2437	LIVING_ACC (Pow , 7);
2438	LIVING_ACC (wc , 8);
2439	LIVING_ACC (ac , 9);
2440	LIVING_ACC (hp , 10);
2441	LIVING_ACC (maxhp , 11);
2442	LIVING_ACC (sp , 12);
2443	LIVING_ACC (maxsp , 13);
2444	LIVING_ACC (grace , 14);
2445	LIVING_ACC (maxgrace, 15);
2446	LIVING_ACC (food , 16);
2447	LIVING_ACC (dam , 17);
2448	LIVING_ACC (luck , 18);
2449	}	2540	}
2450	# undef LIVING_ACC	2541	while (!RETVAL); // crude way to leave index 0
2451	OUTPUT:
2452	RETVAL
2453		2542
		2543	faces [RETVAL].name = name;
		2544	facehash.insert (std::make_pair (faces [RETVAL].name, RETVAL));
		2545
		2546	if (!strcmp (name, BLANK_FACE_NAME)) blank_face = RETVAL;
		2547	if (!strcmp (name, EMPTY_FACE_NAME)) empty_face = RETVAL;
		2548	}
		2549	OUTPUT: RETVAL
		2550
		2551	void set (faceidx idx, int visibility, int magicmap)
		2552	CODE:
		2553	faceinfo *f = face_info (idx);
		2554	assert (f);
		2555	f->visibility = visibility;
		2556	f->magicmap = magicmap;
		2557
		2558	void set_smooth (faceidx idx, faceidx smooth)
		2559	CODE:
		2560	faceinfo *f = face_info (idx);
		2561	assert (f);
		2562	f->smooth = smooth;
		2563
		2564	void set_data (faceidx idx, int faceset, SV *data, SV *chksum)
		2565	CODE:
		2566	facedata *d = face_data (idx, faceset);
		2567	assert (d);
		2568	sv_to (data, d->data);
		2569	STRLEN clen;
		2570	char *cdata = SvPVbyte (chksum, clen);
		2571	memcpy (d->chksum, cdata, min (CHKSUM_SIZE, clen));
		2572
		2573	void invalidate (faceidx idx)
		2574	CODE:
		2575	for_all_clients (ns)
		2576	ns->faces_sent [idx] = false;
		2577
		2578	void invalidate_all ()
		2579	CODE:
		2580	for_all_clients (ns)
		2581	ns->faces_sent.reset ();
		2582

Diff Legend

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