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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.55 by root, Tue Sep 12 18:15:34 2006 UTC vs.
Revision 1.150 by root, Tue Jan 23 01:05:18 2007 UTC

…		…
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		25
26	#define PLUGIN_NAME "perl"	26	#define PLUGIN_NAME "perl"
27	#define PLUGIN_VERSION "cfperl 0.5"	27	#define PLUGIN_VERSION "cfperl 0.5"
28		28
29	#include <plugin_common.h>	29	#include <plugin_common.h>
…		…
32	#include <sproto.h>	32	#include <sproto.h>
33		33
34	#include "cfperl.h"	34	#include "cfperl.h"
35	#include "shstr.h"	35	#include "shstr.h"
36		36
		37	#include <unistd.h>
		38	#if _POSIX_MEMLOCK
		39	# include <sys/mman.h>
		40	#endif
		41
37	#include <EXTERN.h>	42	#include <EXTERN.h>
38	#include <perl.h>	43	#include <perl.h>
39	#include <XSUB.h>	44	#include <XSUB.h>
40		45
		46	#include "CoroAPI.h"
41	#include "perlxsi.c"	47	#include "perlxsi.c"
42		48
43	extern sint64 *levels; // the experience table	49	extern sint64 *levels; // the experience table
44		50
45	typedef object object_ornull;	51	typedef object object_ornull;
46	typedef mapstruct mapstruct_ornull;	52	typedef maptile maptile_ornull;
47		53
		54	#if IVSIZE >= 8
		55	typedef IV val64;
		56	# define newSVval64 newSViv
		57	# define SvVAL64 SvIV
		58	#else
48	typedef double val64;	59	typedef double val64;
49	#define newSVval64 newSVnv	60	# define newSVval64 newSVnv
50	#define SvVAL64 SvNV	61	# define SvVAL64 SvNV
		62	#endif
51		63
52	static f_plug_api gethook = cfapi_get_hooks;	64	static f_plug_api gethook = cfapi_get_hooks;
53	static f_plug_api object_set_property = cfapi_object_set_property;	65	static f_plug_api object_set_property = cfapi_object_set_property;
54	static f_plug_api object_insert = cfapi_object_insert;	66	static f_plug_api object_insert = cfapi_object_insert;
55		67
56	static HV *obj_cache;
57	static PerlInterpreter *perl;	68	static PerlInterpreter *perl;
58		69
		70	double runtime;
		71
		72	global gbl_ev;
59	static AV cb_global, cb_object, cb_player, cb_type, *cb_map;	73	static AV cb_global, cb_attachable, cb_object, cb_player, cb_client, cb_type, *cb_map;
		74	static SV *sv_runtime;
60		75
61	#define PUSHcfapi(type,value) PUSHs (sv_2mortal (newSVcfapi (CFAPI_ ## type, (value))))	76	static HV
62	#define PUSHcfapi_va(type,ctype) PUSHcfapi (type, va_arg (args, ctype))	77	*stash_cf,
63	#define PUSH_OB PUSHcfapi_va(POBJECT, object *)	78	*stash_cf_object_wrap,
64	#define PUSH_PL PUSHcfapi_va(PPLAYER, player *)	79	*stash_cf_object_player_wrap,
65	#define PUSH_MAP PUSHcfapi_va(PMAP, mapstruct *)	80	*stash_cf_player_wrap,
66	#define PUSH_PV PUSHcfapi_va(STRING, const char *)	81	*stash_cf_map_wrap,
67	#define PUSH_IV PUSHs (sv_2mortal (newSViv (va_arg (args, int))))	82	*stash_cf_client_wrap,
		83	*stash_cf_arch_wrap,
		84	*stash_cf_party_wrap,
		85	*stash_cf_region_wrap,
		86	*stash_cf_living_wrap;
		87
		88	// helper cast function, returns super class * or 0
		89	template<class super>
		90	static super *
		91	is_a (attachable *at)
		92	{
		93	//return dynamic_cast<super *>(at); // slower, safer
		94	if (typeid (*at) == typeid (super))
		95	return static_cast<super *>(at);
		96	else
		97	return 0;
		98	}
68		99
69	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	100	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
70		101
		102	unordered_vector<attachable *> attachable::mortals;
		103
		104	attachable::~attachable ()
		105	{
		106	assert (!self);
		107	}
		108
		109	int
		110	attachable::refcnt_cnt () const
		111	{
		112	return refcnt + (self ? SvREFCNT (self) : 0);
		113	}
		114
		115	void
		116	attachable::optimise ()
		117	{
		118	if (self
		119	&& SvREFCNT (self) == 1
		120	&& !HvTOTALKEYS (self))
		121	{
		122	refcnt_inc ();
		123	SvREFCNT_dec ((SV *)self);
		124	}
		125	}
		126
		127	// check wether the object really is dead
		128	void
		129	attachable::do_check ()
		130	{
		131	if (refcnt > 0 \|\| refcnt_cnt () > 0)
		132	return;
		133
		134	destroy ();
		135
		136	if (self)
		137	{
		138	hv_clear (self);
		139	sv_unmagic ((SV *)self, PERL_MAGIC_ext);
		140	SvREFCNT_dec (self);
		141	self = 0;
		142	}
		143	}
		144
		145	void
		146	attachable::do_destroy ()
		147	{
		148	invoke (EVENT_ATTACHABLE_DESTROY, DT_END);
		149
		150	if (self)
		151	hv_clear (self);
		152
		153	mortals.push_back (this);
		154	}
		155
		156	void
		157	attachable::destroy ()
		158	{
		159	if (destroyed ())
		160	return;
		161
		162	flags \|= F_DESTROYED;
		163	do_destroy ();
		164	}
		165
		166	void
		167	attachable::check_mortals ()
		168	{
		169	static int i = 0;
		170
		171	for (;;)
		172	{
		173	if (i >= mortals.size ())
		174	{
		175	i = 0;
		176
		177	if (mortals.size () > 1000)
		178	fprintf (stderr, "mortal queue size (%d) exceeds 1000.\n", mortals.size ());
		179
		180	break;
		181	}
		182
		183	attachable *obj = mortals [i];
		184
		185	obj->refcnt_chk (); // unborrow from perl, if necessary
		186
		187	if (obj->refcnt > 0 \|\| obj->self)
		188	{
		189	//printf ("%p rc %d\n", obj, obj->refcnt_cnt ());//D
		190	++i; // further delay freeing
		191
		192	if (!(i & 0x3ff))
		193	break;
		194	}
		195	else
		196	{
		197	mortals.erase (i);
		198	delete obj;
		199	}
		200	}
		201	}
		202
		203	attachable &
		204	attachable::operator =(const attachable &src)
		205	{
		206	//if (self \|\| cb)
		207	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));
		208
		209	attach = src.attach;
		210	return *this;
		211	}
		212
		213	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		214
71	static SV *	215	static SV *
72	newSVptr (void ptr, const char klass, HV *hv = newHV ())	216	newSVptr (void ptr, HV stash, HV *hv = newHV ())
73	{	217	{
74	SV *sv;	218	SV *sv;
75		219
76	if (!ptr)	220	if (!ptr)
77	return &PL_sv_undef;	221	return &PL_sv_undef;
78		222
79	sv_magic ((SV )hv, 0, PERL_MAGIC_ext, (char )ptr, 0);	223	sv_magicext ((SV )hv, 0, PERL_MAGIC_ext, 0, (char )ptr, 0);
80	return sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));	224	return sv_bless (newRV_noinc ((SV *)hv), stash);
81	}	225	}
82		226
83	template<class attachable>	227	static int
84	SV *	228	attachable_free (pTHX_ SV sv, MAGIC mg)
		229	{
		230	attachable at = (attachable )mg->mg_ptr;
		231	at->self = 0;
		232	// next line makes sense, but most objects still have refcnt 0 by default
		233	//at->refcnt_chk ();
		234	return 0;
		235	}
		236
		237	MGVTBL attachable::vtbl = {0, 0, 0, 0, attachable_free};
		238
		239	static SV *
85	newSVattachable (attachable obj, const char klass)	240	newSVattachable (attachable obj, HV stash)
86	{	241	{
87	if (!obj)	242	if (!obj)
88	return &PL_sv_undef;	243	return &PL_sv_undef;
89		244
90	if (!obj->self)	245	if (!obj->self)
91	obj->self = newSVptr (obj, klass);
92
93	return newSVsv (obj->self);
94	}
95
96	static void
97	SVptr_cache_set (void ptr, SV sv)
98	{
99	hv_store (obj_cache, (char *)&ptr, sizeof (ptr), sv, 0);
100	}
101
102	static SV *
103	SVptr_cache_get (void *ptr)
104	{
105	SV *he = hv_fetch (obj_cache, (char )&ptr, sizeof (ptr), 0);
106
107	return he ? *he : 0;
108	}
109
110	static SV *
111	newSVptr_cached (void ptr, const char klass)
112	{
113	SV *sv;
114
115	if (!ptr)
116	return &PL_sv_undef;
117
118	sv = SVptr_cache_get (ptr);
119
120	if (!sv)
121	{	246	{
122	HV *hv = newHV ();	247	obj->self = newHV ();
123	sv_magic ((SV )hv, 0, PERL_MAGIC_ext, (char )ptr, 0);	248	sv_magicext ((SV )obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char )obj, 0);
124	sv = sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));
125		249
126	SVptr_cache_set (ptr, sv);	250	// borrow the refcnt from the object
		251	// it is important thta no refcnt_chk is being executed here
		252	obj->refcnt_dec ();
		253
		254	// now bless the object _once_
		255	return sv_bless (newRV_inc ((SV *)obj->self), stash);
127	}	256	}
		257	else
		258	{
		259	SV sv = newRV_inc ((SV )obj->self);
128		260
129	return newSVsv (sv);	261	if (Gv_AMG (stash)) // handle overload correctly, as the perl core does not
		262	SvAMAGIC_on (sv);
		263
		264	return sv;
		265	}
130	}	266	}
131		267
132	static void	268	static void
133	clearSVptr (SV *sv)	269	clearSVptr (SV *sv)
134	{	270	{
…		…
175	inline SV *to_sv (unsigned long v) { return newSVuv (v); }	311	inline SV *to_sv (unsigned long v) { return newSVuv (v); }
176	inline SV *to_sv ( signed long long v) { return newSVval64 (v); }	312	inline SV *to_sv ( signed long long v) { return newSVval64 (v); }
177	inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }	313	inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }
178	inline SV *to_sv (float v) { return newSVnv (v); }	314	inline SV *to_sv (float v) { return newSVnv (v); }
179	inline SV *to_sv (double v) { return newSVnv (v); }	315	inline SV *to_sv (double v) { return newSVnv (v); }
		316	inline SV to_sv (client v) { return newSVattachable (v, stash_cf_client_wrap); }
180	inline SV to_sv (player v) { return newSVattachable (v, "cf::player::wrap"); }	317	inline SV to_sv (player v) { return newSVattachable (v, stash_cf_player_wrap); }
181	inline SV to_sv (object v) { return newSVattachable (v, v && v->type == PLAYER ? "cf::object::player::wrap" : "cf::object::wrap"); }	318	inline SV to_sv (object v) { return newSVattachable (v, v && v->type == PLAYER ? stash_cf_object_player_wrap : stash_cf_object_wrap); }
182	inline SV to_sv (mapstruct v) { return newSVattachable (v, "cf::map::wrap"); }	319	inline SV to_sv (maptile v) { return newSVattachable (v, stash_cf_map_wrap); }
183	inline SV to_sv (archetype v) { return newSVptr (v, "cf::arch::wrap"); }	320	inline SV to_sv (archetype v) { return newSVattachable (v, stash_cf_arch_wrap); }
184	inline SV to_sv (partylist v) { return newSVptr (v, "cf::party::wrap"); }	321	inline SV to_sv (partylist v) { return newSVptr (v, stash_cf_party_wrap); }
185	inline SV to_sv (region v) { return newSVptr (v, "cf::region::wrap"); }	322	inline SV to_sv (region v) { return newSVptr (v, stash_cf_region_wrap); }
186	inline SV to_sv (living v) { return newSVptr (v, "cf::living::wrap"); }	323	inline SV to_sv (living v) { return newSVptr (v, stash_cf_living_wrap); }
187		324
188	inline SV *to_sv (object & v) { return to_sv (&v); }	325	inline SV *to_sv (object & v) { return to_sv (&v); }
189	inline SV *to_sv (living & v) { return to_sv (&v); }	326	inline SV *to_sv (living & v) { return to_sv (&v); }
190		327
191	//TODO:
192	inline SV to_sv (New_Face v) { return to_sv (v->name); }	328	inline SV to_sv (facetile v) { return to_sv (v->name); }
193	inline SV to_sv (treasurelist v) { return to_sv (v->name); }	329	inline SV to_sv (treasurelist v) { return to_sv (v->name); }
194		330
		331	inline SV *to_sv (UUID v)
		332	{
		333	char buf[128];
		334	snprintf (buf, 128, "<1,%" PRIx64 ">", v.seq);
		335	return newSVpv (buf, 0);
		336	}
		337
195	inline void sv_to (SV *sv, shstr &v) { v = SvPV_nolen (sv); }	338	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPV_nolen (sv) : 0; }
196	inline void sv_to (SV sv, char &v) { free (v); v = strdup (SvPV_nolen (sv)); } //TODO: verify that all simple pointers are strdup-managed	339	inline void sv_to (SV sv, char &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }
197	inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }	340	inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }
198	inline void sv_to (SV *sv, signed char &v) { v = SvIV (sv); }	341	inline void sv_to (SV *sv, signed char &v) { v = SvIV (sv); }
199	inline void sv_to (SV *sv, unsigned char &v) { v = SvIV (sv); }	342	inline void sv_to (SV *sv, unsigned char &v) { v = SvIV (sv); }
200	inline void sv_to (SV *sv, signed short &v) { v = SvIV (sv); }	343	inline void sv_to (SV *sv, signed short &v) { v = SvIV (sv); }
201	inline void sv_to (SV *sv, unsigned short &v) { v = SvIV (sv); }	344	inline void sv_to (SV *sv, unsigned short &v) { v = SvIV (sv); }
…		…
205	inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }	348	inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }
206	inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }	349	inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }
207	inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }	350	inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }
208	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }	351	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
209	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }	352	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }
		353	inline void sv_to (SV sv, client &v) { v = (client )(attachable )SvPTR_ornull (sv, "cf::client"); }
210	inline void sv_to (SV sv, player &v) { v = (player *)SvPTR_ornull (sv, "cf::player"); }	354	inline void sv_to (SV sv, player &v) { v = (player )(attachable )SvPTR_ornull (sv, "cf::player"); }
211	inline void sv_to (SV sv, object &v) { v = (object *)SvPTR_ornull (sv, "cf::object"); }	355	inline void sv_to (SV sv, object &v) { v = (object )(attachable )SvPTR_ornull (sv, "cf::object"); }
212	inline void sv_to (SV sv, archetype &v) { v = (archetype *)SvPTR_ornull (sv, "cf::arch"); }	356	inline void sv_to (SV sv, archetype &v) { v = (archetype )(attachable )SvPTR_ornull (sv, "cf::arch"); }
213	inline void sv_to (SV sv, mapstruct &v) { v = (mapstruct *)SvPTR_ornull (sv, "cf::map"); }	357	inline void sv_to (SV sv, maptile &v) { v = (maptile )(attachable )SvPTR_ornull (sv, "cf::map"); }
		358	inline void sv_to (SV sv, attachable &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); }
214	inline void sv_to (SV sv, partylist &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }	359	inline void sv_to (SV sv, partylist &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }
215	inline void sv_to (SV sv, region &v) { v = (region *)SvPTR_ornull (sv, "cf::region"); }	360	inline void sv_to (SV sv, region &v) { v = (region *)SvPTR_ornull (sv, "cf::region"); }
216	inline void sv_to (SV sv, living &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }	361	inline void sv_to (SV sv, living &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }
217		362
218	inline void sv_to (SV sv, New_Face &v) { v = &new_faces[FindFace (SvPV_nolen (sv), 0)]; } //TODO	363	inline void sv_to (SV sv, facetile &v) { v = &new_faces[FindFace (SvPV_nolen (sv), 0)]; }
219	inline void sv_to (SV sv, treasurelist &v) { v = find_treasurelist (SvPV_nolen (sv)); } // TODO	364	inline void sv_to (SV sv, treasurelist &v) { v = find_treasurelist (SvPV_nolen (sv)); }
220		365
221	template<class T>	366	template<class T>
222	inline void sv_to (SV sv, refptr<T> &v) { T tmp; sv_to (sv, tmp); v = tmp; }	367	inline void sv_to (SV sv, refptr<T> &v) { T tmp; sv_to (sv, tmp); v = tmp; }
223		368
224	template<int N>	369	template<int N>
225	inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); }	370	inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); }
		371
		372	inline void sv_to (SV *sv, rangetype &v) { v = (rangetype) SvIV (sv); }
		373	inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); }
		374	inline void sv_to (SV *sv, petmode_t &v) { v = (petmode_t) SvIV (sv); }
		375	inline void sv_to (SV *sv, usekeytype &v) { v = (usekeytype) SvIV (sv); }
		376	inline void sv_to (SV *sv, unapplymode &v) { v = (unapplymode) SvIV (sv); }
		377
		378	inline void sv_to (SV *sv, UUID &v)
		379	{
		380	unsigned int version;
		381
		382	if (2 != sscanf (SvPV_nolen (sv), "<%d.%" SCNx64 ">", &version, &v.seq) \|\| 1 != version)
		383	croak ("unparsable uuid: %s", SvPV_nolen (sv));
		384	}
		385
		386	inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }
226		387
227	static SV *	388	static SV *
228	newSVdt_va (va_list &ap, data_type type)	389	newSVdt_va (va_list &ap, data_type type)
229	{	390	{
230	SV *sv;	391	SV *sv;
…		…
262	sv = to_sv (va_arg (ap, object *));	423	sv = to_sv (va_arg (ap, object *));
263	break;	424	break;
264		425
265	case DT_MAP:	426	case DT_MAP:
266	// va_arg (object ) when void is passed is an XSI extension	427	// va_arg (object ) when void is passed is an XSI extension
267	sv = to_sv (va_arg (ap, mapstruct *));	428	sv = to_sv (va_arg (ap, maptile *));
		429	break;
		430
		431	case DT_CLIENT:
		432	sv = to_sv (va_arg (ap, client *));
268	break;	433	break;
269		434
270	case DT_PLAYER:	435	case DT_PLAYER:
271	sv = to_sv (va_arg (ap, player *));	436	sv = to_sv (va_arg (ap, player *));
272	break;	437	break;
…		…
333	}	498	}
334		499
335	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	500	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
336		501
337	SV *	502	SV *
338	registry_of (attachable_base *ext)	503	registry (attachable *ext)
339	{	504	{
340	if (!ext->cb)	505	if (!ext->cb)
341	ext->cb = newAV ();	506	ext->cb = newAV ();
342		507
343	return newRV_inc ((SV *)ext->cb);	508	return newRV_inc ((SV *)ext->cb);
344	}	509	}
345		510
346	void attachable_base::clear ()
347	{
348	if (self)
349	{
350	if (cb)
351	if (SvROK (*av_fetch (cb, EVENT_OBJECT_DESTROY, 1)))
352	INVOKE_OBJECT (DESTROY, static_cast<object *>(this));
353	else if (SvROK (*av_fetch (cb, EVENT_MAP_DESTROY, 1)))
354	INVOKE_MAP (DESTROY, static_cast<mapstruct *>(this));
355
356	// disconnect Perl from C, to avoid crashes
357	sv_unmagic (SvRV ((SV *)self), PERL_MAGIC_ext);
358
359	// clear the perl hash, might or might not be a good idea
360	hv_clear ((HV )SvRV ((SV )self));
361
362	SvREFCNT_dec (self);
363	self = 0;
364	}
365
366	if (cb)
367	{
368	SvREFCNT_dec (cb);
369	cb = 0;
370	}
371
372	attach = 0;
373	}
374
375	void attachable_base::optimise ()
376	{
377	if (!self)
378	return;
379
380	HV hv = (HV )SvRV ((SV *)self);
381
382	if (SvREFCNT ((SV *)self) == 1
383	&& SvREFCNT ((SV *)hv) == 1
384	&& !HvKEYS (hv))
385	{
386	SvREFCNT_dec ((SV *)self);
387	self = 0;
388	}
389	}
390
391	void attachable_base::instantiate (data_type type, void *obj)
392	{
393	dSP;
394	ENTER;
395	SAVETMPS;
396	PUSHMARK (SP);
397	EXTEND (SP, 2);
398	PUSHs (sv_2mortal (newSVdt (type, obj)));
399	PUSHs (sv_2mortal (newSVpv (attach, 0)));
400
401	attach = 0;
402
403	PUTBACK;
404	call_pv ("cf::instantiate", G_DISCARD \| G_VOID \| G_EVAL);
405	FREETMPS;
406	LEAVE;
407
408	switch (type)
409	{
410	case DT_OBJECT: INVOKE_OBJECT (INSTANTIATE, obj); break;
411	case DT_MAP: INVOKE_MAP (INSTANTIATE, obj); break;
412	}
413	}
414
415	/////////////////////////////////////////////////////////////////////////////
416
417	void reattach (data_type type, void *obj)
418	{
419	//TODO only do this when the object has _attachment's
420
421	dSP;
422	ENTER;
423	SAVETMPS;
424	PUSHMARK (SP);
425	XPUSHs (sv_2mortal (newSVdt (type, obj)));
426	PUTBACK;
427	call_pv ("cf::reattach", G_DISCARD \| G_VOID \| G_EVAL);
428	FREETMPS;
429	LEAVE;
430
431	switch (type)
432	{
433	case DT_OBJECT: INVOKE_OBJECT (REATTACH, obj); break;
434	case DT_PLAYER: INVOKE_PLAYER (REATTACH, obj); break;
435	case DT_MAP: INVOKE_MAP (REATTACH, obj); break;
436	}
437	}
438
439	template<class subclass>
440	void reattach (attachable<subclass> *obj)
441	{
442	obj->optimise ();
443
444	if (obj->self)
445	reattach ((data_type) cftype<subclass>::dt, (subclass *)obj);
446	}
447
448	#include "kw_hash.h"
449
450	object_freezer::object_freezer ()
451	: dynbuf (128 * 1024, 64 * 1024)
452	{
453	av = newAV ();
454	}
455
456	object_freezer::~object_freezer ()
457	{
458	SvREFCNT_dec (av);
459	}
460
461	void object_freezer::put (attachable_base *ext)
462	{
463	ext->optimise ();
464
465	if (ext->self)
466	{
467	int idx = AvFILLp ((AV *)av) + 1;
468	av_store (av, idx, SvREFCNT_inc (ext->self));
469
470	add ((void *)"oid ", 4);
471	add ((sint32)idx);
472	add ('\n');
473	}
474	}
475
476	bool object_freezer::save (const char *filename)
477	{
478	dSP;
479	ENTER;
480	SAVETMPS;
481	PUSHMARK (SP);
482	EXTEND (SP, 3);
483	PUSHs (sv_2mortal (newSVpv (filename, 0)));
484	PUSHs (sv_2mortal (newRV_noinc (newSVpvn ((char *)linearise (), size ()))));
485	PUSHs (sv_2mortal (newRV_inc ((SV *)av)));
486	PUTBACK;
487	call_pv ("cf::object_freezer_save", G_VOID \| G_DISCARD \| G_EVAL);
488	FREETMPS;
489	LEAVE;
490	}
491
492	int fprintf (object_freezer &freezer, const char *format, ...)
493	{
494	va_list ap;
495
496	va_start (ap, format);
497
498	int len = vsnprintf ((char *)freezer.force (1024), 1024, format, ap);
499
500	if (len >= 0)
501	freezer.alloc (len);
502
503	va_end (ap);
504	}
505
506	int fputs (const char *s, object_freezer &freezer)
507	{
508	freezer.add (s);
509	}
510
511	object_thawer::object_thawer (const char *filename)
512	{
513	static const char eof[] = "\n\n\n\0\0\0";
514
515	av = 0;
516	text = 0;
517	line = 0;
518
519	if (filename)
520	{
521	dSP;
522	ENTER;
523	SAVETMPS;
524	PUSHMARK (SP);
525	XPUSHs (sv_2mortal (newSVpv (filename, 0)));
526	PUTBACK;
527
528	if (2 == call_pv ("cf::object_thawer_load", G_ARRAY \| G_EVAL))
529	{
530	SPAGAIN;
531
532	// second value - perl objects
533	{
534	SV *sv = POPs;
535	if (SvROK (sv))
536	av = (AV *)SvREFCNT_inc (SvRV (sv));
537	}
538
539	// first value - text part, pad with 3 zeroes
540	{
541	SV *sv = POPs;
542	STRLEN len;
543	char *sv_ = SvPVbyte (sv, len);
544	text = newSV (len + sizeof (eof));
545	SvCUR_set (text, len);
546	memcpy (SvPVX (text), sv_, len);
547	memcpy (SvEND (text), eof, sizeof (eof)); // just to be sure
548
549	line = SvPVX (text);
550	}
551	}
552
553	PUTBACK;
554	FREETMPS;
555	LEAVE;
556	}
557	}
558
559	void object_thawer::get (data_type type, void obj, attachable_base ext, int oid)
560	{
561	if (!av \|\| oid < 0) // this is actually an error of sorts
562	return;
563
564	// we have to "re-instantiate"/reattach to an object, so nuke ext->attach
565	ext->clear ();
566
567	SV *svp = av_fetch ((AV )av, oid, 0);
568
569	if (!svp \|\| !SvROK (*svp))
570	{
571	printf ("trying to thaw duplicate or never-issued oid %d, ignoring.\n", oid);
572	return;
573	}
574
575	ext->self = svp; svp = &PL_sv_undef;
576	sv_magic (SvRV (ext->self), 0, PERL_MAGIC_ext, (char *)obj, 0);
577
578	reattach (type, obj);
579	}
580
581	object_thawer::~object_thawer ()
582	{
583	if (text) SvREFCNT_dec (text);
584	if (av) SvREFCNT_dec (av);
585	}
586
587	char fgets (char s, int n, object_thawer &thawer)
588	{
589	char *p = thawer.line;
590	char *q = s;
591
592	if (!p)
593	return 0;
594
595	while (--n)
596	{
597	if (!*p)
598	break;
599
600	q++ = p;
601
602	if (*p++ == '\n')
603	break;
604	}
605
606	*q = 0;
607	thawer.line = p;
608
609	return s == q ? 0 : s;
610	}
611
612	keyword object_thawer::get_kv ()
613	{
614	if (!line)
615	return KW_EOF;
616
617	for (;;)
618	{
619	char *p = line;
620
621	if (!*p)
622	return KW_EOF;
623
624	// parse keyword
625	while (*p > ' ')
626	p++;
627
628	int klen = p - line;
629
630	if (*p++ != '\n')
631	{
632	// parse value
633	while ((unsigned char )p <= ' ' && *p != '\n') // skip 0x01 .. 0x20
634	++p;
635
636	last_value = p;
637
638	while (*p != '\n')
639	p++;
640
641	*p++ = 0;
642	}
643	else
644	last_value = 0;
645
646	line [klen] = 0;
647	keyword_idx *kw = kw_lex::match (line, klen);
648
649	//printf ("KV %d<%s,%s>\n", kw ? kw->index : 0, line, last_value);//D
650
651	if (kw)
652	{
653	line = p;
654	return kw->index;
655	}
656	else if (!line \|\| line == '#')
657	{
658	// empty/comment line
659	line = p;
660	}
661	else
662	return KW_ERROR;
663	}
664	}
665
666	void object_thawer::get (shstr &sh) const
667	{
668	if (last_value)
669	sh = last_value;
670	else
671	{
672	sh = "<value missing>";
673	LOG (llevError, "keyword requires value: <%s>\n", line);//TODO: add filename
674	}
675	}
676
677	void object_thawer::get_ml (keyword kend, shstr &sh)
678	{
679	char kw[128];
680
681	int klen = keyword_len [kend];
682
683	kw [0] = '\n';
684	memcpy (kw + 1, keyword_str [kend], klen);
685	kw [klen + 1] = '\n';
686	kw [klen + 2] = 0;
687
688	// first test for completely empty msg... "endXXX\n"
689	if (!strncmp (line, kw + 1, klen + 1))
690	{
691	sh = 0;
692
693	line += klen + 1;
694
695	return;
696	}
697	else
698	{
699	// multi-line strings are delimited by "\nendXXX\n" or "endXXX\n" (NULL)
700
701	char *end = strstr (line, kw);
702
703	if (!end)
704	{
705	sh = 0;
706	return;
707	}
708
709	*end = 0;
710	sh = line;
711
712	line = end + keyword_len [kend] + 1;
713
714	while (*line++ != '\n')
715	;
716	}
717	}
718
719	sint32 object_thawer::get_sint32 () const
720	{
721	char *p = last_value;
722
723	if (!p)
724	return 0;
725
726	sint32 val = 0;
727	bool negate;
728
729	if (*p == '-')
730	{
731	negate = true;
732	++p;
733	}
734	else
735	negate = false;
736
737	do
738	{
739	val *= 10;
740	val += *p++ - '0';
741	}
742	while (*p);
743
744	return negate ? -val : val;
745	}
746
747	sint64 object_thawer::get_sint64 () const
748	{
749	return last_value ? atoll (last_value) : 0;
750	}
751
752	double object_thawer::get_double () const
753	{
754	return last_value ? atof (last_value) : 0;
755	}
756
757	/////////////////////////////////////////////////////////////////////////////	511	/////////////////////////////////////////////////////////////////////////////
758		512
759	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)	513	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
760	{	514	{
761	return 0;	515	return 0;
…		…
764	static CommArray_s rtn_cmd;	518	static CommArray_s rtn_cmd;
765		519
766	static int	520	static int
767	runPluginCommand (object obj, char params)	521	runPluginCommand (object obj, char params)
768	{	522	{
769	dSP;	523	return -1;
770
771	ENTER;
772	SAVETMPS;
773
774	PUSHMARK (SP);
775
776	EXTEND (SP, 3);
777	PUSHs (sv_2mortal (newSVpv (rtn_cmd.name, 0)));
778	PUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, obj)));
779
780	if (params)
781	PUSHs (sv_2mortal (newSVpv (params, 0)));
782
783	PUTBACK;
784	int count = call_pv ("cf::inject_command", G_SCALAR \| G_EVAL);
785	SPAGAIN;
786
787	if (SvTRUE (ERRSV))
788	LOG (llevError, "command '%s' callback evaluation error: %s", rtn_cmd.name, SvPV_nolen (ERRSV));
789
790	int returnvalue = count > 0 ? POPi : -1;
791
792	PUTBACK;
793	FREETMPS;
794	LEAVE;
795
796	return returnvalue;
797	}	524	}
798		525
799	extern "C" void cfperl_getPluginProperty (int type, ...)	526	extern "C" void cfperl_getPluginProperty (int type, ...)
800	{	527	{
801	va_list args;	528	va_list args;
…		…
804	va_start (args, type);	531	va_start (args, type);
805	propname = va_arg (args, char *);	532	propname = va_arg (args, char *);
806	//printf ("Property name: %s\n", propname);	533	//printf ("Property name: %s\n", propname);
807		534
808	if (!strcmp (propname, "command?"))	535	if (!strcmp (propname, "command?"))
809	{
810	if (!perl)
811	return NULL;	536	return NULL;
812
813	const char cmdname = va_arg (args, const char );
814	HV *hv = get_hv ("cf::COMMAND", 1);
815	SV **svp = hv_fetch (hv, cmdname, strlen (cmdname) + 1, 0);
816
817	va_end (args);
818
819	if (svp)
820	{
821	// this is totaly broken, should stash it into %COMMAND
822	rtn_cmd.name = cmdname;
823	rtn_cmd.time = SvNV (*svp);
824	rtn_cmd.func = runPluginCommand;
825
826	return &rtn_cmd;
827	}
828	}
829	else if (!strcmp (propname, "Identification"))	537	else if (!strcmp (propname, "Identification"))
830	{	538	{
831	va_end (args);	539	va_end (args);
832	return (void*) PLUGIN_NAME;	540	return (void *)PLUGIN_NAME;
833	}	541	}
834	else if (!strcmp (propname, "FullName"))	542	else if (!strcmp (propname, "FullName"))
835	{	543	{
836	va_end (args);	544	va_end (args);
837	return (void*) PLUGIN_VERSION;	545	return (void *)PLUGIN_VERSION;
838	}	546	}
839	else	547	else
840	va_end (args);	548	va_end (args);
841		549
842	return NULL;	550	return NULL;
…		…
867	PL_exit_flags \|= PERL_EXIT_DESTRUCT_END;	575	PL_exit_flags \|= PERL_EXIT_DESTRUCT_END;
868		576
869	char *argv[] = {	577	char *argv[] = {
870	"",	578	"",
871	"-e"	579	"-e"
872	"cf->bootstrap;"	580	"use Event; use Coro;" // required for bootstrap
		581	"cf->bootstrap;" // required for datadir :*>
873	"unshift @INC, cf::datadir ();"	582	"unshift @INC, cf::datadir ();"
874	"require cf;"	583	"require cf;"
875	};	584	};
876		585
877	if (perl_parse (perl, xs_init, 2, argv, (char **)NULL) \|\| perl_run (perl))	586	if (perl_parse (perl, xs_init, 2, argv, (char **)NULL) \|\| perl_run (perl))
878	{	587	{
879	printf ("unable to initialize perl-interpreter, aborting.\n");	588	printf ("unable to initialize perl-interpreter, aborting.\n");
880	exit (EXIT_FAILURE);	589	exit (EXIT_FAILURE);
881	}	590	}
882
883	obj_cache = newHV ();
884	}	591	}
885		592
886	void cfperl_main ()	593	void cfperl_main ()
887	{	594	{
888	dSP;	595	dSP;
889		596
890	PUSHMARK (SP);	597	PUSHMARK (SP);
891	PUTBACK;	598	PUTBACK;
892	call_pv ("cf::main", G_DISCARD \| G_VOID);	599	call_pv ("cf::main", G_DISCARD \| G_VOID);
		600	}
		601
		602	void
		603	attachable::instantiate ()
		604	{
		605	if (attach)
		606	{
		607	invoke (EVENT_ATTACHABLE_INSTANTIATE, ARG_STRING (attach), DT_END);
		608	attach = 0;
		609	}
		610	}
		611
		612	void
		613	attachable::reattach ()
		614	{
		615	optimise ();
		616	//TODO: check for _attachment's, very important for restarts
		617	invoke (EVENT_ATTACHABLE_REATTACH, DT_END);
893	}	618	}
894		619
895	static event_klass klass_of[NUM_EVENT_TYPES] = {	620	static event_klass klass_of[NUM_EVENT_TYPES] = {
896	# define def(type,name) KLASS_ ## type,	621	# define def(type,name) KLASS_ ## type,
897	# include "eventinc.h"	622	# include "eventinc.h"
…		…
928	}	653	}
929	}	654	}
930	}	655	}
931	}	656	}
932		657
		658	void
		659	attachable::gather_callbacks (AV *&callbacks, event_type event) const
		660	{
		661	::gather_callbacks (callbacks, cb_attachable, event);
		662
		663	if (cb)
		664	::gather_callbacks (callbacks, cb, event);
		665	}
		666
		667	void
		668	global::gather_callbacks (AV *&callbacks, event_type event) const
		669	{
		670	::gather_callbacks (callbacks, cb_object, event);
		671	}
		672
		673	void
		674	object::gather_callbacks (AV *&callbacks, event_type event) const
		675	{
		676	if (subtype && type + subtype * NUM_SUBTYPES <= AvFILLp (cb_type))
		677	{
		678	SV registry = AvARRAY (cb_type)[type + subtype NUM_SUBTYPES];
		679
		680	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
		681	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);
		682	}
		683
		684	if (type <= AvFILLp (cb_type))
		685	{
		686	SV *registry = AvARRAY (cb_type)[type];
		687
		688	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
		689	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);
		690	}
		691
		692	attachable::gather_callbacks (callbacks, event);
		693	::gather_callbacks (callbacks, cb_object, event);
		694	}
		695
		696	void
		697	archetype::gather_callbacks (AV *&callbacks, event_type event) const
		698	{
		699	attachable::gather_callbacks (callbacks, event);
		700	//TODO//::gather_callbacks (callbacks, cb_archetype, event);
		701	}
		702
		703	void
		704	client::gather_callbacks (AV *&callbacks, event_type event) const
		705	{
		706	attachable::gather_callbacks (callbacks, event);
		707	::gather_callbacks (callbacks, cb_client, event);
		708	}
		709
		710	void
		711	player::gather_callbacks (AV *&callbacks, event_type event) const
		712	{
		713	attachable::gather_callbacks (callbacks, event);
		714	::gather_callbacks (callbacks, cb_player, event);
		715	}
		716
		717	void
		718	maptile::gather_callbacks (AV *&callbacks, event_type event) const
		719	{
		720	attachable::gather_callbacks (callbacks, event);
		721	::gather_callbacks (callbacks, cb_map, event);
		722	}
		723
		724	bool
933	bool cfperl_invoke (event_type event, ...)	725	attachable::invoke (event_type event, ...)
934	{	726	{
935	data_type dt;	727	data_type dt;
936	va_list ap;	728	va_list ap;
937		729
938	va_start (ap, event);	730	va_start (ap, event);
939		731
		732	// callback call ordering should be:
		733	// 1. per-object callback
		734	// 2. per-class object
		735	// 3. per-type callback
		736	// 4. global callbacks
		737
940	AV *callbacks = 0;	738	AV *callbacks = 0;
941
942	object *op;
943	player *pl;
944	mapstruct *map;
945
946	// callback call ordering is:
947	// 1. per-object callback (NYI)
948	// 2. per-class object
949	// 2a. per-type callback
950	// 4. global callbacks
951
952	gather_callbacks (callbacks, cb_global, event);	739	gather_callbacks (callbacks, event);
953
954	switch (KLASS_OF (event))
955	{
956	case KLASS_GLOBAL:
957	break;
958
959	case KLASS_OBJECT:
960	dt = (data_type) va_arg (ap, int);
961	assert (("first argument must be of type object", dt == DT_OBJECT));
962	op = va_arg (ap, object *);
963
964	if (op->cb)
965	gather_callbacks (callbacks, op->cb, event);
966
967	if (op->type)
968	{
969	if (op->subtype && op->type + op->subtype * NUM_SUBTYPES <= AvFILLp (cb_type))
970	{
971	SV registry = AvARRAY (cb_type)[op->type + op->subtype NUM_SUBTYPES];
972
973	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
974	gather_callbacks (callbacks, (AV *)SvRV (registry), event);
975	}
976
977	if (op->type <= AvFILLp (cb_type))
978	{
979	SV *registry = AvARRAY (cb_type)[op->type];
980
981	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
982	gather_callbacks (callbacks, (AV *)SvRV (registry), event);
983	}
984	}
985
986	gather_callbacks (callbacks, cb_object, event);
987
988	break;
989
990	case KLASS_PLAYER:
991	dt = (data_type) va_arg (ap, int);
992	assert (("first argument must be of type player", dt == DT_PLAYER));
993	pl = va_arg (ap, player *);
994
995	if (pl->cb)
996	gather_callbacks (callbacks, pl->cb, event);
997
998	gather_callbacks (callbacks, cb_player, event);
999	break;
1000
1001	case KLASS_MAP:
1002	dt = (data_type) va_arg (ap, int);
1003	assert (("first argument must be of type object", dt == DT_MAP));
1004	map = va_arg (ap, mapstruct *);
1005
1006	if (map->cb)
1007	gather_callbacks (callbacks, map->cb, event);
1008
1009	gather_callbacks (callbacks, cb_map, event);
1010	break;
1011
1012	default:
1013	assert (("unsupported event klass in cfperl_invoke", 0));
1014	}
1015		740
1016	// short-circuit processing if no callbacks found/defined	741	// short-circuit processing if no callbacks found/defined
1017	if (!callbacks)	742	if (!callbacks)
1018	return 0;	743	return 0;
1019		744
1020	dSP;	745	CALL_BEGIN (3);
1021	ENTER;
1022	SAVETMPS;
1023
1024	PUSHMARK (SP);
1025	EXTEND (SP, 3);
1026
1027	PUSHs (sv_2mortal (newSViv (event))); // only used for debugging nowadays	746	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays
1028	PUSHs (sv_2mortal (newRV_noinc ((SV *)callbacks)));	747	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));
1029		748
1030	switch (KLASS_OF (event))	749	//TODO: unhack
1031	{	750	if (object *op = is_a<object>(this)) CALL_ARG_SV (newSVdt (DT_OBJECT, op));
1032	case KLASS_OBJECT: PUSHs (sv_2mortal (newSVdt (DT_OBJECT, op))); break;	751	else if (player *pl = is_a<player>(this)) CALL_ARG_SV (newSVdt (DT_PLAYER, pl));
1033	case KLASS_PLAYER: PUSHs (sv_2mortal (newSVdt (DT_PLAYER, pl))); break;	752	else if (client *ns = is_a<client>(this)) CALL_ARG_SV (newSVdt (DT_CLIENT, ns));
1034	case KLASS_MAP: PUSHs (sv_2mortal (newSVdt (DT_MAP, map))); break;	753	else if (maptile *m = is_a<maptile>(this)) CALL_ARG_SV (newSVdt (DT_MAP, m));
1035	}	754	else if (global gl = is_a<global>(this)) /nop*/;
		755	else
		756	abort (); //TODO
1036		757
1037	for (;;)	758	for (;;)
1038	{	759	{
1039	dt = (data_type) va_arg (ap, int);	760	dt = (data_type) va_arg (ap, int);
1040		761
1041	if (dt == DT_END)	762	if (dt == DT_END)
1042	break;	763	break;
1043
1044	if (dt == DT_AV)	764	else if (dt == DT_AV)
1045	{	765	{
1046	AV av = va_arg (ap, AV );	766	AV av = va_arg (ap, AV );
1047		767
1048	for (int i = 0; i <= av_len (av); ++i)	768	for (int i = 0; i <= av_len (av); ++i)
1049	XPUSHs (*av_fetch (av, i, 1));	769	XPUSHs (*av_fetch (av, i, 1));
…		…
1052	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));	772	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
1053	}	773	}
1054		774
1055	va_end (ap);	775	va_end (ap);
1056		776
1057	PUTBACK;	777	CALL_CALL ("cf::do_invoke", G_SCALAR);
1058	int count = call_pv ("cf::do_invoke", G_SCALAR \| G_EVAL);
1059	SPAGAIN;
1060
1061	count = count > 0 ? POPi : 0;	778	count = count > 0 ? POPi : 0;
1062		779
1063	FREETMPS;	780	CALL_END;
1064	LEAVE;
1065		781
1066	return count;	782	return count;
1067	}	783	}
1068		784
1069	SV *	785	SV *
…		…
1084	cfperl_result_INT (int idx)	800	cfperl_result_INT (int idx)
1085	{	801	{
1086	return SvIV (cfperl_result (idx));	802	return SvIV (cfperl_result (idx));
1087	}	803	}
1088		804
		805	double
		806	cfperl_result_DOUBLE (int idx)
		807	{
		808	return SvNV (cfperl_result (idx));
		809	}
		810
		811	/////////////////////////////////////////////////////////////////////////////
		812
		813	void
		814	cfperl_emergency_save ()
		815	{
		816	CALL_BEGIN (0);
		817	CALL_CALL ("cf::emergency_save", G_VOID);
		818	CALL_END;
		819	}
		820
		821	maptile *
		822	maptile::find_sync (const char path, maptile origin)
		823	{
		824	CALL_BEGIN (2);
		825	CALL_ARG (path);
		826	CALL_ARG (origin);
		827	CALL_CALL ("cf::map::find_sync", G_SCALAR);
		828
		829	maptile *retval;
		830
		831	if (count)
		832	sv_to (POPs, retval);
		833	else
		834	retval = 0;
		835
		836	CALL_END;
		837
		838	return retval;
		839	}
		840
		841	maptile *
		842	maptile::find_async (const char path, maptile origin)
		843	{
		844	CALL_BEGIN (2);
		845	CALL_ARG (path);
		846	CALL_ARG (origin);
		847	CALL_CALL ("cf::map::find_async", G_SCALAR);
		848
		849	maptile *retval;
		850
		851	if (count)
		852	sv_to (POPs, retval);
		853	else
		854	retval = 0;
		855
		856	CALL_END;
		857
		858	return retval;
		859	}
		860
		861	void
		862	maptile::do_load_sync ()
		863	{
		864	CALL_BEGIN (1);
		865	CALL_ARG (this);
		866	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);
		867	CALL_END;
		868	}
		869
		870	void
		871	maptile::change_all_map_light (int change)
		872	{
		873	CALL_BEGIN (1);
		874	CALL_ARG (change);
		875	CALL_CALL ("cf::map::change_all_map_light", G_VOID);
		876	CALL_END;
		877	}
		878
		879	void
		880	object::enter_exit (object *exit)
		881	{
		882	if (type != PLAYER)
		883	return;
		884
		885	CALL_BEGIN (2);
		886	CALL_ARG (this);
		887	CALL_ARG (exit);
		888	CALL_CALL ("cf::object::player::enter_exit", G_VOID);
		889	CALL_END;
		890	}
		891
		892	/////////////////////////////////////////////////////////////////////////////
		893
		894	struct EventAPI *watcher_base::GEventAPI;
		895	struct CoroAPI *coroapi::GCoroAPI;
		896
		897	int coroapi::cede_counter;
		898
		899	static void iw_dispatch (pe_event *ev)
		900	{
		901	iw w = (iw )ev->ext_data;
		902	w->call (*w);
		903	}
		904
		905	void
		906	iw::alloc ()
		907	{
		908	pe = GEventAPI->new_idle (0, 0);
		909
		910	WaREENTRANT_off (pe);
		911	pe->base.callback = (void *)iw_dispatch;
		912	pe->base.ext_data = (void *)this;
		913	}
		914
		915	static void iow_dispatch (pe_event *ev)
		916	{
		917	iow w = (iow )ev->ext_data;
		918	w->call (w, ((pe_ioevent )ev)->got);
		919	}
		920
		921	void
		922	iow::alloc ()
		923	{
		924	pe = GEventAPI->new_io (0, 0);
		925
		926	WaREENTRANT_off (pe);
		927	pe->base.callback = (void *)iow_dispatch;
		928	pe->base.ext_data = (void *)this;
		929
		930	pe->fd = -1;
		931	pe->poll = 0;
		932	}
		933
		934	void
		935	iow::fd (int fd)
		936	{
		937	pe->fd = fd;
		938	}
		939
		940	int
		941	iow::poll ()
		942	{
		943	return pe->poll;
		944	}
		945
		946	void
		947	iow::poll (int events)
		948	{
		949	if (pe->poll != events)
		950	{
		951	if (pe->poll) stop ();
		952	pe->poll = events;
		953	if (pe->poll) start ();
		954	}
		955	}
		956
		957	void
		958	_connect_to_perl ()
		959	{
		960	stash_cf = gv_stashpv ("cf" , 1);
		961
		962	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);
		963	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);
		964	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);
		965	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);
		966	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);
		967	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
		968	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
		969	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
		970	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
		971
		972	sv_runtime = get_sv ("cf::RUNTIME", 1);
		973	sv_upgrade (sv_runtime, SVt_NV);
		974
		975	cb_global = get_av ("cf::CB_GLOBAL", 1);
		976	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
		977	cb_object = get_av ("cf::CB_OBJECT", 1);
		978	cb_player = get_av ("cf::CB_PLAYER", 1);
		979	cb_client = get_av ("cf::CB_CLIENT", 1);
		980	cb_type = get_av ("cf::CB_TYPE" , 1);
		981	cb_map = get_av ("cf::CB_MAP" , 1);
		982	}
		983
1089	MODULE = cf PACKAGE = cf PREFIX = cf_	984	MODULE = cf PACKAGE = cf PREFIX = cf_
1090		985
1091	BOOT:	986	BOOT:
1092	{	987	{
1093	HV *stash = gv_stashpv ("cf", 1);	988	_connect_to_perl ();
		989
		990	I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;
		991	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
		992
		993	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
1094		994
1095	static const struct {	995	static const struct {
1096	const char *name;	996	const char *name;
1097	IV iv;	997	IV iv;
1098	} *civ, const_iv[] = {	998	} *civ, const_iv[] = {
…		…
1110	const_iv (POTION)	1010	const_iv (POTION)
1111	const_iv (FOOD)	1011	const_iv (FOOD)
1112	const_iv (POISON)	1012	const_iv (POISON)
1113	const_iv (BOOK)	1013	const_iv (BOOK)
1114	const_iv (CLOCK)	1014	const_iv (CLOCK)
1115	const_iv (LIGHTNING)
1116	const_iv (ARROW)	1015	const_iv (ARROW)
1117	const_iv (BOW)	1016	const_iv (BOW)
1118	const_iv (WEAPON)	1017	const_iv (WEAPON)
1119	const_iv (ARMOUR)	1018	const_iv (ARMOUR)
1120	const_iv (PEDESTAL)	1019	const_iv (PEDESTAL)
…		…
1140	const_iv (AMULET)	1039	const_iv (AMULET)
1141	const_iv (PLAYERMOVER)	1040	const_iv (PLAYERMOVER)
1142	const_iv (TELEPORTER)	1041	const_iv (TELEPORTER)
1143	const_iv (CREATOR)	1042	const_iv (CREATOR)
1144	const_iv (SKILL)	1043	const_iv (SKILL)
1145	const_iv (EXPERIENCE)
1146	const_iv (EARTHWALL)	1044	const_iv (EARTHWALL)
1147	const_iv (GOLEM)	1045	const_iv (GOLEM)
1148	const_iv (THROWN_OBJ)	1046	const_iv (THROWN_OBJ)
1149	const_iv (BLINDNESS)	1047	const_iv (BLINDNESS)
1150	const_iv (GOD)	1048	const_iv (GOD)
…		…
1170	const_iv (FLOOR)	1068	const_iv (FLOOR)
1171	const_iv (FLESH)	1069	const_iv (FLESH)
1172	const_iv (INORGANIC)	1070	const_iv (INORGANIC)
1173	const_iv (SKILL_TOOL)	1071	const_iv (SKILL_TOOL)
1174	const_iv (LIGHTER)	1072	const_iv (LIGHTER)
1175	const_iv (TRAP_PART)
1176	const_iv (WALL)	1073	const_iv (BUILDABLE_WALL)
1177	const_iv (LIGHT_SOURCE)
1178	const_iv (MISC_OBJECT)	1074	const_iv (MISC_OBJECT)
1179	const_iv (MONSTER)
1180	const_iv (SPAWN_GENERATOR)
1181	const_iv (LAMP)	1075	const_iv (LAMP)
1182	const_iv (DUPLICATOR)	1076	const_iv (DUPLICATOR)
1183	const_iv (TOOL)
1184	const_iv (SPELLBOOK)	1077	const_iv (SPELLBOOK)
1185	const_iv (BUILDFAC)
1186	const_iv (CLOAK)	1078	const_iv (CLOAK)
1187	const_iv (SPINNER)	1079	const_iv (SPINNER)
1188	const_iv (GATE)	1080	const_iv (GATE)
1189	const_iv (BUTTON)	1081	const_iv (BUTTON)
1190	const_iv (CF_HANDLE)	1082	const_iv (CF_HANDLE)
…		…
1197	const_iv (SPELL_EFFECT)	1089	const_iv (SPELL_EFFECT)
1198	const_iv (CONVERTER)	1090	const_iv (CONVERTER)
1199	const_iv (BRACERS)	1091	const_iv (BRACERS)
1200	const_iv (POISONING)	1092	const_iv (POISONING)
1201	const_iv (SAVEBED)	1093	const_iv (SAVEBED)
1202	const_iv (POISONCLOUD)
1203	const_iv (FIREHOLES)
1204	const_iv (WAND)	1094	const_iv (WAND)
1205	const_iv (SCROLL)	1095	const_iv (SCROLL)
1206	const_iv (DIRECTOR)	1096	const_iv (DIRECTOR)
1207	const_iv (GIRDLE)	1097	const_iv (GIRDLE)
1208	const_iv (FORCE)	1098	const_iv (FORCE)
…		…
1223	const_iv (DISEASE)	1113	const_iv (DISEASE)
1224	const_iv (SYMPTOM)	1114	const_iv (SYMPTOM)
1225	const_iv (BUILDER)	1115	const_iv (BUILDER)
1226	const_iv (MATERIAL)	1116	const_iv (MATERIAL)
1227	const_iv (ITEM_TRANSFORMER)	1117	const_iv (ITEM_TRANSFORMER)
1228	const_iv (QUEST)
1229		1118
1230	const_iv (NUM_SUBTYPES)	1119	const_iv (NUM_SUBTYPES)
1231		1120
1232	const_iv (ST_BD_BUILD)	1121	const_iv (ST_BD_BUILD)
1233	const_iv (ST_BD_REMOVE)	1122	const_iv (ST_BD_REMOVE)
…		…
1286	const_iv (FLAG_MONSTER)	1175	const_iv (FLAG_MONSTER)
1287	const_iv (FLAG_FRIENDLY)	1176	const_iv (FLAG_FRIENDLY)
1288	const_iv (FLAG_GENERATOR)	1177	const_iv (FLAG_GENERATOR)
1289	const_iv (FLAG_IS_THROWN)	1178	const_iv (FLAG_IS_THROWN)
1290	const_iv (FLAG_AUTO_APPLY)	1179	const_iv (FLAG_AUTO_APPLY)
1291	const_iv (FLAG_TREASURE)
1292	const_iv (FLAG_PLAYER_SOLD)	1180	const_iv (FLAG_PLAYER_SOLD)
1293	const_iv (FLAG_SEE_INVISIBLE)	1181	const_iv (FLAG_SEE_INVISIBLE)
1294	const_iv (FLAG_CAN_ROLL)	1182	const_iv (FLAG_CAN_ROLL)
1295	const_iv (FLAG_OVERLAY_FLOOR)	1183	const_iv (FLAG_OVERLAY_FLOOR)
1296	const_iv (FLAG_IS_TURNABLE)	1184	const_iv (FLAG_IS_TURNABLE)
…		…
1371	const_iv (FLAG_ACTIVATE_ON_RELEASE)	1259	const_iv (FLAG_ACTIVATE_ON_RELEASE)
1372	const_iv (FLAG_IS_WATER)	1260	const_iv (FLAG_IS_WATER)
1373	const_iv (FLAG_CONTENT_ON_GEN)	1261	const_iv (FLAG_CONTENT_ON_GEN)
1374	const_iv (FLAG_IS_A_TEMPLATE)	1262	const_iv (FLAG_IS_A_TEMPLATE)
1375	const_iv (FLAG_IS_BUILDABLE)	1263	const_iv (FLAG_IS_BUILDABLE)
		1264	const_iv (FLAG_DESTROY_ON_DEATH)
1376	const_iv (FLAG_AFK)	1265	const_iv (FLAG_NO_MAP_SAVE)
1377		1266
1378	const_iv (NDI_BLACK)	1267	const_iv (NDI_BLACK)
1379	const_iv (NDI_WHITE)	1268	const_iv (NDI_WHITE)
1380	const_iv (NDI_NAVY)	1269	const_iv (NDI_NAVY)
1381	const_iv (NDI_RED)	1270	const_iv (NDI_RED)
…		…
1391	const_iv (NDI_MAX_COLOR)	1280	const_iv (NDI_MAX_COLOR)
1392	const_iv (NDI_COLOR_MASK)	1281	const_iv (NDI_COLOR_MASK)
1393	const_iv (NDI_UNIQUE)	1282	const_iv (NDI_UNIQUE)
1394	const_iv (NDI_ALL)	1283	const_iv (NDI_ALL)
1395		1284
		1285	const_iv (UPD_LOCATION)
		1286	const_iv (UPD_FLAGS)
		1287	const_iv (UPD_WEIGHT)
		1288	const_iv (UPD_FACE)
		1289	const_iv (UPD_NAME)
		1290	const_iv (UPD_ANIM)
		1291	const_iv (UPD_ANIMSPEED)
		1292	const_iv (UPD_NROF)
		1293
		1294	const_iv (UPD_SP_MANA)
		1295	const_iv (UPD_SP_GRACE)
		1296	const_iv (UPD_SP_DAMAGE)
		1297
1396	const_iv (F_APPLIED)	1298	const_iv (F_APPLIED)
1397	const_iv (F_LOCATION)	1299	const_iv (F_LOCATION)
1398	const_iv (F_UNPAID)	1300	const_iv (F_UNPAID)
1399	const_iv (F_MAGIC)	1301	const_iv (F_MAGIC)
1400	const_iv (F_CURSED)	1302	const_iv (F_CURSED)
…		…
1406	const_iv (F_BUY)	1308	const_iv (F_BUY)
1407	const_iv (F_SHOP)	1309	const_iv (F_SHOP)
1408	const_iv (F_SELL)	1310	const_iv (F_SELL)
1409		1311
1410	const_iv (P_BLOCKSVIEW)	1312	const_iv (P_BLOCKSVIEW)
		1313	const_iv (P_PLAYER)
1411	const_iv (P_NO_MAGIC)	1314	const_iv (P_NO_MAGIC)
1412	const_iv (P_IS_ALIVE)	1315	const_iv (P_IS_ALIVE)
1413	const_iv (P_NO_CLERIC)	1316	const_iv (P_NO_CLERIC)
1414	const_iv (P_NEED_UPDATE)
1415	const_iv (P_NO_ERROR)
1416	const_iv (P_OUT_OF_MAP)	1317	const_iv (P_OUT_OF_MAP)
1417	const_iv (P_NEW_MAP)	1318	const_iv (P_NEW_MAP)
		1319	const_iv (P_UPTODATE)
1418		1320
1419	const_iv (UP_OBJ_INSERT)	1321	const_iv (UP_OBJ_INSERT)
1420	const_iv (UP_OBJ_REMOVE)	1322	const_iv (UP_OBJ_REMOVE)
1421	const_iv (UP_OBJ_CHANGE)	1323	const_iv (UP_OBJ_CHANGE)
1422	const_iv (UP_OBJ_FACE)	1324	const_iv (UP_OBJ_FACE)
…		…
1553	const_iv (ATNR_BLIND)	1455	const_iv (ATNR_BLIND)
1554	const_iv (ATNR_INTERNAL)	1456	const_iv (ATNR_INTERNAL)
1555	const_iv (ATNR_LIFE_STEALING)	1457	const_iv (ATNR_LIFE_STEALING)
1556	const_iv (ATNR_DISEASE)	1458	const_iv (ATNR_DISEASE)
1557		1459
1558	const_iv (MAP_FLUSH)
1559	const_iv (MAP_PLAYER_UNIQUE)
1560	const_iv (MAP_BLOCK)
1561	const_iv (MAP_STYLE)
1562	const_iv (MAP_OVERLAY)
1563
1564	const_iv (MAP_IN_MEMORY)	1460	const_iv (MAP_IN_MEMORY)
1565	const_iv (MAP_SWAPPED)	1461	const_iv (MAP_SWAPPED)
1566	const_iv (MAP_LOADING)	1462	const_iv (MAP_LOADING)
1567	const_iv (MAP_SAVING)	1463	const_iv (MAP_SAVING)
1568		1464
		1465	const_iv (KLASS_ATTACHABLE)
1569	const_iv (KLASS_GLOBAL)	1466	const_iv (KLASS_GLOBAL)
1570	const_iv (KLASS_OBJECT)	1467	const_iv (KLASS_OBJECT)
		1468	const_iv (KLASS_CLIENT)
1571	const_iv (KLASS_PLAYER)	1469	const_iv (KLASS_PLAYER)
1572	const_iv (KLASS_MAP)	1470	const_iv (KLASS_MAP)
		1471
		1472	const_iv (CS_QUERY_YESNO)
		1473	const_iv (CS_QUERY_SINGLECHAR)
		1474	const_iv (CS_QUERY_HIDEINPUT)
		1475
		1476	const_iv (ST_DEAD)
		1477	const_iv (ST_SETUP)
		1478	const_iv (ST_PLAYING)
		1479	const_iv (ST_CUSTOM)
		1480
		1481	const_iv (ST_CHANGE_CLASS)
		1482
		1483	const_iv (IO_HEADER)
		1484	const_iv (IO_OBJECTS)
		1485	const_iv (IO_UNIQUES)
		1486
		1487	// random map generator
		1488	const_iv (LAYOUT_NONE)
		1489	const_iv (LAYOUT_ONION)
		1490	const_iv (LAYOUT_MAZE)
		1491	const_iv (LAYOUT_SPIRAL)
		1492	const_iv (LAYOUT_ROGUELIKE)
		1493	const_iv (LAYOUT_SNAKE)
		1494	const_iv (LAYOUT_SQUARE_SPIRAL)
		1495
		1496	const_iv (RMOPT_RANDOM)
		1497	const_iv (RMOPT_CENTERED)
		1498	const_iv (RMOPT_LINEAR)
		1499	const_iv (RMOPT_BOTTOM_C)
		1500	const_iv (RMOPT_BOTTOM_R)
		1501	const_iv (RMOPT_IRR_SPACE)
		1502	const_iv (RMOPT_WALL_OFF)
		1503	const_iv (RMOPT_WALLS_ONLY)
		1504	const_iv (RMOPT_NO_DOORS)
		1505
		1506	const_iv (SYMMETRY_RANDOM)
		1507	const_iv (SYMMETRY_NONE)
		1508	const_iv (SYMMETRY_X)
		1509	const_iv (SYMMETRY_Y)
		1510	const_iv (SYMMETRY_XY)
1573	};	1511	};
1574		1512
1575	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	1513	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1576	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));	1514	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1577		1515
1578	static const struct {	1516	static const struct {
1579	const char *name;	1517	const char *name;
1580	int skip;	1518	int skip;
1581	IV klass;	1519	IV klass;
…		…
1592	{	1530	{
1593	AV *event = newAV ();	1531	AV *event = newAV ();
1594	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));	1532	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));
1595	av_push (event, newSViv (eiv->klass));	1533	av_push (event, newSViv (eiv->klass));
1596	av_store (av, eiv->iv, newRV_noinc ((SV *)event));	1534	av_store (av, eiv->iv, newRV_noinc ((SV *)event));
1597	newCONSTSUB (stash, (char *)eiv->name, newSViv (eiv->iv));	1535	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));
1598	}	1536	}
1599
1600	//I_EVENT_API (PACKAGE);
1601	}	1537	}
1602		1538
1603	void _init_vars ()	1539	void _connect_to_perl ()
1604	CODE:
1605	cb_global = get_av ("cf::CB_GLOBAL", 1);
1606	cb_object = get_av ("cf::CB_OBJECT", 1);
1607	cb_player = get_av ("cf::CB_PLAYER", 1);
1608	cb_type = get_av ("cf::CB_TYPE" , 1);
1609	cb_map = get_av ("cf::CB_MAP" , 1);
1610		1540
1611	void _global_reattach ()	1541	void _global_reattach ()
1612	CODE:	1542	CODE:
1613	{	1543	{
1614	// reattach to all attachable objects in the game.	1544	// reattach to all attachable objects in the game.
1615	for (player *pl = first_player; pl; pl = pl->next)	1545	for_all_clients (ns)
1616	reattach (pl);	1546	ns->reattach ();
1617		1547
1618	for (mapstruct *map = first_map; map; map = map->next)	1548	for_all_players (pl)
1619	reattach (map);
1620
1621	for (object *op = objects; op; op = op->next)
1622	reattach (op);	1549	pl->reattach ();
		1550
		1551	//TODO
		1552	//for (map_container::iterator i = maps.begin (); i != maps.end (); ++i)
		1553	// i->second->reattach ();
		1554
		1555	for_all_objects (op)
		1556	op->reattach ();
1623	}	1557	}
1624		1558
1625	NV floor (NV x)	1559	NV floor (NV x)
1626		1560
1627	NV ceil (NV x)	1561	NV ceil (NV x)
1628		1562
		1563	NV rndm (...)
		1564	CODE:
		1565	switch (items)
		1566	{
		1567	case 0: RETVAL = rndm (); break;
		1568	case 1: RETVAL = rndm (SvUV (ST (0))); break;
		1569	case 2: RETVAL = rndm (SvIV (ST (0)), SvIV (ST (1))); break;
		1570	default: croak ("cf::rndm requires none, one or two parameters."); break;
		1571	}
		1572	OUTPUT:
		1573	RETVAL
		1574
1629	void server_tick ()	1575	void server_tick ()
		1576	CODE:
		1577	runtime = SvNVx (sv_runtime);
		1578	server_tick ();
1630		1579
1631	void	1580	void
1632	LOG (int level, char *msg)	1581	LOG (int level, char *msg)
1633	PROTOTYPE: $$	1582	PROTOTYPE: $$
1634	C_ARGS: (LogLevel)level, "%s", msg	1583	C_ARGS: (LogLevel)level, "%s", msg
…		…
1674	case 5: RETVAL = settings.playerdir; break;	1623	case 5: RETVAL = settings.playerdir; break;
1675	case 6: RETVAL = settings.datadir ; break;	1624	case 6: RETVAL = settings.datadir ; break;
1676	}	1625	}
1677	OUTPUT: RETVAL	1626	OUTPUT: RETVAL
1678		1627
1679	int	1628	void abort ()
		1629
		1630	void fork_abort (char *cause = "cf::fork_abort")
		1631
		1632	void cleanup (const char *cause, bool make_core = false)
		1633
		1634	void emergency_save ()
		1635
		1636	UV sv_2watcher (SV *w)
		1637	CODE:
		1638	RETVAL = (UV)GEventAPI->sv_2watcher (w);
		1639	OUTPUT:
		1640	RETVAL
		1641
		1642	void _exit (int status = 0)
		1643
		1644	#if _POSIX_MEMLOCK
		1645
		1646	int mlockall (int flags = MCL_CURRENT \| MCL_FUTURE)
		1647
		1648	int munlockall ()
		1649
		1650	#endif
		1651
1680	cf_find_animation (char *text)	1652	int find_animation (char *text)
1681	PROTOTYPE: $	1653	PROTOTYPE: $
1682		1654
1683	int random_roll(int min, int max, object *op, int goodbad);	1655	int random_roll (int min, int max, object *op, int goodbad);
1684		1656
1685	const char *cost_string_from_value(uint64 cost, int approx = 0)	1657	const char *cost_string_from_value(uint64 cost, int approx = 0)
1686
1687	int invoke (int event, ...)
1688	CODE:
1689	if (KLASS_OF (event) != KLASS_GLOBAL) croak ("event class must be GLOBAL");
1690	AV av = (AV )sv_2mortal ((SV *)newAV ());
1691	for (int i = 1; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
1692	RETVAL = INVOKE_((event_type)event, ARG_AV (av));
1693	OUTPUT: RETVAL
1694		1658
1695	int	1659	int
1696	exp_to_level (val64 exp)	1660	exp_to_level (val64 exp)
1697	CODE:	1661	CODE:
1698	{	1662	{
…		…
1729	RETVAL = newSVpv (resist_plus[atnr], 0);	1693	RETVAL = newSVpv (resist_plus[atnr], 0);
1730	else	1694	else
1731	XSRETURN_UNDEF;	1695	XSRETURN_UNDEF;
1732	OUTPUT: RETVAL	1696	OUTPUT: RETVAL
1733		1697
		1698	MODULE = cf PACKAGE = cf::attachable
		1699
1734	int	1700	int
1735	_valid (SV *obj)	1701	valid (SV *obj)
1736	CODE:	1702	CODE:
1737	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);	1703	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
1738	OUTPUT:	1704	OUTPUT:
1739	RETVAL	1705	RETVAL
1740		1706
		1707	INCLUDE: $PERL genacc attachable ../include/cfperl.h \|
		1708
		1709	MODULE = cf PACKAGE = cf::global
		1710
		1711	int invoke (SV *klass, int event, ...)
		1712	CODE:
		1713	if (KLASS_OF (event) != KLASS_GLOBAL) croak ("event class must be GLOBAL");
		1714	AV av = (AV )sv_2mortal ((SV *)newAV ());
		1715	for (int i = 1; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
		1716	RETVAL = gbl_ev.invoke ((event_type)event, ARG_AV (av), DT_END);
		1717	OUTPUT: RETVAL
		1718
1741	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_	1719	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
		1720
		1721	INCLUDE: $PERL genacc object ../include/object.h \|
1742		1722
1743	int invoke (object *op, int event, ...)	1723	int invoke (object *op, int event, ...)
1744	CODE:	1724	CODE:
1745	if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");	1725	if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");
1746	AV av = (AV )sv_2mortal ((SV *)newAV ());	1726	AV av = (AV )sv_2mortal ((SV *)newAV ());
1747	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));	1727	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
1748	RETVAL = INVOKE_((event_type)event, ARG_OBJECT (op), ARG_AV (av));	1728	RETVAL = op->invoke ((event_type)event, ARG_AV (av), DT_END);
1749	OUTPUT: RETVAL	1729	OUTPUT: RETVAL
1750		1730
1751	SV registry (object op)	1731	SV registry (object op)
		1732
		1733	void mortals ()
1752	CODE:	1734	PPCODE:
1753	RETVAL = registry_of (op);	1735	EXTEND (SP, object::mortals.size ());
1754	OUTPUT:	1736	for (AUTODECL (i, object::mortals.begin ()); i != object::mortals.end (); ++i)
1755	RETVAL	1737	PUSHs (to_sv (*i));
1756		1738
1757	INCLUDE: $PERL genacc object ../include/object.h \|	1739	int objects_size ()
		1740	CODE:
		1741	RETVAL = objects.size ();
		1742	OUTPUT: RETVAL
		1743
		1744	object *objects (U32 index)
		1745	CODE:
		1746	RETVAL = index < objects.size () ? objects [index] : 0;
		1747	OUTPUT: RETVAL
		1748
		1749	int actives_size ()
		1750	CODE:
		1751	RETVAL = actives.size ();
		1752	OUTPUT: RETVAL
		1753
		1754	object *actives (U32 index)
		1755	CODE:
		1756	RETVAL = index < actives.size () ? actives [index] : 0;
		1757	OUTPUT: RETVAL
1758		1758
1759	# missing properties	1759	# missing properties
1760
1761	int flag (object *op, int flag, int value = 1)
1762	PROTOTYPE: $$;$
1763	CODE:
1764	RETVAL = QUERY_FLAG (op, flag);
1765	if (items >= 3)
1766	if (value)
1767	SET_FLAG (op, flag);
1768	else
1769	CLEAR_FLAG (op, flag);
1770	OUTPUT: RETVAL
1771		1760
1772	object head (object op)	1761	object head (object op)
1773	PROTOTYPE: $	1762	PROTOTYPE: $
1774	CODE:	1763	CODE:
1775	RETVAL = op->head ? op->head : op;	1764	RETVAL = op->head_ ();
1776	OUTPUT: RETVAL	1765	OUTPUT: RETVAL
1777		1766
1778	int is_head (object *op)	1767	int is_head (object *op)
1779	PROTOTYPE: $	1768	PROTOTYPE: $
1780	CODE:	1769	CODE:
1781	RETVAL = !op->head;	1770	RETVAL = op->head_ () == op;
1782	OUTPUT: RETVAL	1771	OUTPUT: RETVAL
1783		1772
1784	void	1773	void
1785	inv (object *obj)	1774	inv (object *obj)
1786	PROTOTYPE: $	1775	PROTOTYPE: $
1787	PPCODE:	1776	PPCODE:
1788	{	1777	{
1789	object *o;	1778	object *o;
1790	for (o = obj->inv; o; o = o->below)	1779	for (o = obj->inv; o; o = o->below)
1791	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));	1780	XPUSHs (sv_2mortal (to_sv (o)));
1792	}	1781	}
1793		1782
1794	int cf_object_get_resistance (object *op, int rtype)	1783	void
1795	ALIAS: resistance = 0	1784	set_animation (object *op, int idx)
		1785	CODE:
		1786	SET_ANIMATION (op, idx);
1796		1787
		1788	object find_best_object_match (object op, const char *match)
		1789
		1790	object find_marked_object (object op)
		1791
1797	int need_identify (const object *obj);	1792	int need_identify (object *obj);
1798		1793
1799	int apply_shop_mat (object shop_mat, object op);	1794	int apply_shop_mat (object shop_mat, object op);
1800		1795
1801	int move (object op, int dir, object originator = op)	1796	int move (object op, int dir, object originator = op)
1802	CODE:	1797	CODE:
1803	RETVAL = move_ob (op, dir, originator);	1798	RETVAL = move_ob (op, dir, originator);
1804	OUTPUT:	1799	OUTPUT:
1805	RETVAL	1800	RETVAL
1806		1801
1807	void cf_object_apply (object op, object author, int flags = 0)	1802	void apply (object applier, object applied, int flags = 0)
		1803	CODE:
		1804	manual_apply (applied, applier, flags);
1808		1805
1809	void cf_object_apply_below (object *op)	1806	void apply_below (object *op)
1810		1807	CODE:
1811	void cf_object_remove (object *op)	1808	player_apply_below (op);
1812
1813	void cf_object_free (object *op)
1814		1809
1815	object cf_object_present_archname_inside (object op, char *whatstr)	1810	object cf_object_present_archname_inside (object op, char *whatstr)
1816		1811
1817	int cf_object_transfer (object op, int x, int y, int r = 0, object_ornull orig = 0)	1812	int cf_object_transfer (object op, int x, int y, int r = 0, object_ornull orig = 0)
1818		1813
1819	int cf_object_change_map (object op, int x, int y, mapstruct map)	1814	int cf_object_change_map (object op, int x, int y, maptile map)
1820		1815
		1816	#//TODO
1821	object cf_object_clone (object op, int clonetype = 0)	1817	object clone_ (object op, int recursive = 0)
		1818	CODE:
		1819	if (recursive)
		1820	RETVAL = object_create_clone (op);
		1821	else
		1822	{
		1823	RETVAL = object::create ();
		1824	op->copy_to (RETVAL);
		1825	}
		1826	OUTPUT: RETVAL
1822		1827
1823	int cf_object_pay_item (object op, object buyer)	1828	int pay_item (object op, object buyer)
		1829	CODE:
		1830	RETVAL = pay_for_item (op, buyer);
		1831	OUTPUT: RETVAL
1824		1832
1825	int cf_object_pay_amount (object *op, uint64 amount)	1833	int pay_amount (object *op, uint64 amount)
		1834	CODE:
		1835	RETVAL = pay_for_amount (amount, op);
		1836	OUTPUT: RETVAL
1826		1837
1827	void pay_player (object *op, uint64 amount)	1838	void pay_player (object *op, uint64 amount)
1828		1839
1829	val64 pay_player_arch (object op, const char arch, uint64 amount)	1840	val64 pay_player_arch (object op, const char arch, uint64 amount)
1830		1841
1831	int cf_object_cast_spell (object caster, object ctoo, int dir, object spell_ob, char stringarg = 0)	1842	int cast_spell (object op, object caster, int dir, object spell_ob, char stringarg = 0)
1832		1843
1833	int cf_object_cast_ability (object caster, object ctoo, int dir, object sp_, char stringarg = 0)	1844	void learn_spell (object op, object sp, int special_prayer = 0)
		1845	CODE:
		1846	do_learn_spell (op, sp, special_prayer);
1834		1847
1835	void cf_object_learn_spell (object op, object sp)
1836
1837	void cf_object_forget_spell (object op, object sp)	1848	void forget_spell (object op, object sp)
		1849	CODE:
		1850	do_forget_spell (op, query_name (sp));
1838		1851
1839	object cf_object_check_for_spell (object op, char *spellname)	1852	object check_for_spell (object op, char *spellname)
		1853	CODE:
		1854	RETVAL = check_spell_known (op, spellname);
		1855	OUTPUT: RETVAL
1840		1856
1841	int cf_object_query_money (object *op)	1857	int query_money (object *op)
1842	ALIAS: money = 0	1858	ALIAS: money = 0
1843		1859
1844	int cf_object_query_cost (object op, object who, int flags)	1860	val64 query_cost (object op, object who, int flags)
1845	ALIAS: cost = 0	1861	ALIAS: cost = 0
1846		1862
1847	void cf_object_activate_rune (object op , object victim)	1863	void spring_trap (object op, object victim)
1848		1864
1849	int cf_object_check_trigger (object op, object cause)	1865	int check_trigger (object op, object cause)
1850		1866
1851	int cf_object_out_of_map (object *op, int x, int y)
1852
1853	void cf_object_drop (object op, object author)	1867	void drop (object who, object op)
1854		1868
1855	void cf_object_take (object op, object author)	1869	void pick_up (object who, object op)
1856		1870
1857	object cf_object_insert_object (object op, object *container)
1858
1859	object cf_object_insert_in_ob (object ob, object *where)
1860
1861	int cf_object_teleport (object op, mapstruct map, int x, int y)	1871	int cf_object_teleport (object op, maptile map, int x, int y)
1862		1872
1863	void cf_object_update (object *op, int flags)	1873	void update_object (object *op, int action)
1864
1865	void cf_object_pickup (object op, object what)
1866		1874
1867	object cf_create_object_by_name (const char name)	1875	object cf_create_object_by_name (const char name)
1868		1876
1869	void change_exp (object op, uint64 exp, const char skill_name = 0, int flag = 0)	1877	void change_exp (object op, uint64 exp, const char skill_name = 0, int flag = 0)
1870		1878
…		…
1876		1884
1877	void push_button (object *op);	1885	void push_button (object *op);
1878		1886
1879	void use_trigger (object *op);	1887	void use_trigger (object *op);
1880		1888
1881	void add_button_link (object button, mapstruct map, int connected);	1889	void add_button_link (object button, maptile map, int connected);
1882		1890
1883	void remove_button_link (object *op);	1891	void remove_button_link (object *op);
1884		1892
1885	void
1886	cf_object_set_resistance (object *op, int rtype, int val)
1887	CODE:
1888	if (rtype >= 0 && rtype < NROFATTACKS)
1889	op->resist[rtype] = val;
1890
1891		1893
1892	MODULE = cf PACKAGE = cf::object PREFIX = cf_	1894	MODULE = cf PACKAGE = cf::object PREFIX = cf_
1893
1894	void cf_fix_object (object *pl)
1895	ALIAS: fix = 0
1896		1895
1897	object cf_insert_ob_in_ob (object ob, object *where)	1896	object cf_insert_ob_in_ob (object ob, object *where)
1898		1897
1899	# no clean way to get an object from an archetype - stupid idiotic	1898	# no clean way to get an object from an archetype - stupid idiotic
1900	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.	1899	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.
…		…
1904	CODE:	1903	CODE:
1905	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();	1904	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();
1906	OUTPUT:	1905	OUTPUT:
1907	RETVAL	1906	RETVAL
1908		1907
1909	object insert_ob_in_map_at (object ob, mapstruct where, object_ornull orig, int flag, int x, int y)	1908	object insert_ob_in_map_at (object ob, maptile where, object_ornull orig, int flag, int x, int y)
1910	PROTOTYPE: $$$$$$	1909	PROTOTYPE: $$$$$$
1911	CODE:	1910	CODE:
1912	{	1911	{
1913	int unused_type;	1912	int unused_type;
1914	RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);	1913	RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);
…		…
1952	bool on_same_map_as (object ob, object other)	1951	bool on_same_map_as (object ob, object other)
1953	CODE:	1952	CODE:
1954	RETVAL = on_same_map (ob, other);	1953	RETVAL = on_same_map (ob, other);
1955	OUTPUT: RETVAL	1954	OUTPUT: RETVAL
1956		1955
1957	char *	1956	const char *
1958	base_name (object *ob, int plural)	1957	base_name (object *op, int plural = op->nrof > 1)
1959	CODE:	1958	CODE:
1960	RETVAL = cf_query_base_name (ob, plural);	1959	RETVAL = query_base_name (op, plural);
1961	OUTPUT: RETVAL	1960	OUTPUT: RETVAL
		1961
		1962	object decrease_ob_nr (object op, unsigned long i)
1962		1963
1963	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_	1964	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_
1964		1965
1965	player player (object op)	1966	player player (object op)
1966	CODE:	1967	CODE:
1967	RETVAL = op->contr;	1968	RETVAL = op->contr;
1968	OUTPUT: RETVAL	1969	OUTPUT: RETVAL
1969		1970
		1971	void check_score (object *op)
		1972
1970	void cf_player_message (object obj, char txt, int flags = NDI_ORANGE \| NDI_UNIQUE)	1973	void message (object op, char txt, int flags = NDI_ORANGE \| NDI_UNIQUE)
		1974	CODE:
		1975	new_draw_info (flags, 0, op, txt);
1971		1976
1972	object cf_player_send_inventory (object op)	1977	object cf_player_send_inventory (object op)
1973		1978
1974	char cf_player_get_ip (object op)	1979	char cf_player_get_ip (object op)
1975	ALIAS: ip = 0	1980	ALIAS: ip = 0
…		…
1984		1989
1985	void cf_player_set_party (object op, partylist party)	1990	void cf_player_set_party (object op, partylist party)
1986		1991
1987	void kill_player (object *op)	1992	void kill_player (object *op)
1988		1993
		1994	void esrv_update_item (object op, int what, object item)
		1995	C_ARGS: what, op, item
		1996
		1997	void clear_los (object *op)
		1998
		1999	int command_summon (object op, char params)
		2000
		2001	int command_arrest (object op, char params)
		2002
		2003	int command_kick (object op, char params)
		2004
		2005	int command_banish (object op, char params)
		2006
		2007
1989	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_	2008	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
		2009
		2010	INCLUDE: $PERL genacc player ../include/player.h \|
1990		2011
1991	int invoke (player *pl, int event, ...)	2012	int invoke (player *pl, int event, ...)
1992	CODE:	2013	CODE:
1993	if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");	2014	if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");
1994	AV av = (AV )sv_2mortal ((SV *)newAV ());	2015	AV av = (AV )sv_2mortal ((SV *)newAV ());
1995	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));	2016	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
1996	RETVAL = INVOKE_((event_type)event, ARG_PLAYER (pl), ARG_AV (av));	2017	RETVAL = pl->invoke ((event_type)event, ARG_AV (av), DT_END);
1997	OUTPUT: RETVAL	2018	OUTPUT: RETVAL
1998		2019
1999	SV registry (player pl)	2020	SV registry (player pl)
		2021
		2022	void
		2023	save_stats (player *pl)
2000	CODE:	2024	CODE:
		2025	pl->ob->stats.hp = pl->ob->stats.maxhp;
		2026	pl->ob->stats.sp = pl->ob->stats.maxsp;
		2027	pl->ob->stats.grace = pl->ob->stats.maxgrace;
		2028	pl->orig_stats = pl->ob->stats;
		2029
		2030	void cf_player_move (player *pl, int dir)
		2031
		2032	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);
		2033
		2034	player *first ()
		2035	CODE:
2001	RETVAL = registry_of (pl);	2036	RETVAL = first_player;
		2037	OUTPUT: RETVAL
		2038
		2039	bool
		2040	cell_visible (player *pl, int dx, int dy)
		2041	CODE:
		2042	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2
		2043	&& !pl->blocked_los [dx + pl->ns->mapx / 2][dy + pl->ns->mapy / 2];
2002	OUTPUT:	2044	OUTPUT:
2003	RETVAL	2045	RETVAL
2004		2046
2005	player cf_player_find (char name)
2006	PROTOTYPE: $
2007
2008	void cf_player_move (player *pl, int dir)
2009
2010	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);
2011
2012	# nonstandard
2013	object ob (player pl)
2014	CODE:
2015	RETVAL = pl->ob;
2016	OUTPUT: RETVAL
2017
2018	player *first ()
2019	CODE:
2020	RETVAL = first_player;
2021	OUTPUT: RETVAL
2022
2023	player next (player pl)
2024	CODE:
2025	RETVAL = pl->next;
2026	OUTPUT: RETVAL
2027
2028	bool
2029	cell_visible (player *pl, int dx, int dy)
2030	CODE:
2031	RETVAL = FABS (dx) <= pl->socket.mapx / 2 && FABS (dy) <= pl->socket.mapy / 2
2032	&& !pl->blocked_los [dx + pl->socket.mapx / 2][dy + pl->socket.mapy / 2];
2033	OUTPUT:
2034	RETVAL
2035
2036	char *
2037	client (player *pl)
2038	CODE:
2039	RETVAL = pl->socket.client;
2040	OUTPUT:
2041	RETVAL
2042
2043	char *
2044	host (player *pl)
2045	CODE:
2046	RETVAL = pl->socket.host;
2047	OUTPUT:
2048	RETVAL
2049
2050	char *
2051	killer (player pl, char killer = 0)
2052	CODE:
2053	if (killer)
2054	snprintf (pl->killer, sizeof (pl->killer), "%s", killer);
2055	RETVAL = pl->killer;
2056	OUTPUT:
2057	RETVAL
2058
2059	void
2060	buggy_mapscroll (player *pl, int value = 1)
2061	CODE:
2062	pl->socket.buggy_mapscroll = value;
2063
2064	void	2047	void
2065	send (player pl, SV packet)	2048	send (player pl, SV packet)
2066	CODE:	2049	CODE:
2067	{	2050	{
2068	STRLEN len;	2051	STRLEN len;
2069	char *buf = SvPVbyte (packet, len);	2052	char *buf = SvPVbyte (packet, len);
2070		2053
2071	Write_String_To_Socket (&pl->socket, buf, len);	2054	if (pl->ns)
		2055	pl->ns->send_packet (buf, len);
2072	}	2056	}
2073		2057
2074	int	2058	int
2075	listening (player *pl, int new_value = -1)	2059	listening (player *pl, int new_value = -1)
2076	CODE:	2060	CODE:
…		…
2095	if (y) sv_to (y, pl->bed_y);	2079	if (y) sv_to (y, pl->bed_y);
2096		2080
2097	void	2081	void
2098	list ()	2082	list ()
2099	PPCODE:	2083	PPCODE:
2100	{	2084	for_all_players (pl)
2101	player *pl;	2085	XPUSHs (sv_2mortal (to_sv (pl)));
2102	for (pl = first_player; pl; pl = pl->next)
2103	XPUSHs (newSVcfapi (CFAPI_PPLAYER, pl));
2104	}
2105
2106	bool
2107	peaceful (player *pl, bool new_setting = 0)
2108	PROTOTYPE: $;$
2109	CODE:
2110	RETVAL = pl->peaceful;
2111	if (items > 1)
2112	pl->peaceful = new_setting;
2113	OUTPUT:
2114	RETVAL
2115
2116	living *
2117	orig_stats (player *pl)
2118	CODE:
2119	RETVAL = &pl->orig_stats;
2120	OUTPUT: RETVAL
2121
2122	living *
2123	last_stats (player *pl)
2124	CODE:
2125	RETVAL = &pl->last_stats;
2126	OUTPUT: RETVAL
2127		2086
2128		2087
2129	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_	2088	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_
2130		2089
2131	mapstruct *first ()
2132	PROTOTYPE:
2133	CODE:
2134	RETVAL = first_map;
2135	OUTPUT: RETVAL
2136
2137	int invoke (mapstruct *map, int event, ...)	2090	int invoke (maptile *map, int event, ...)
2138	CODE:	2091	CODE:
2139	if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");	2092	if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");
2140	AV av = (AV )sv_2mortal ((SV *)newAV ());	2093	AV av = (AV )sv_2mortal ((SV *)newAV ());
2141	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));	2094	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
2142	RETVAL = INVOKE_((event_type)event, ARG_MAP (map), ARG_AV (av));	2095	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);
2143	OUTPUT: RETVAL	2096	OUTPUT: RETVAL
2144		2097
2145	SV registry (mapstruct map)	2098	SV registry (maptile map)
2146	CODE:
2147	RETVAL = registry_of (map);
2148	OUTPUT:
2149	RETVAL
2150		2099
2151	INCLUDE: $PERL genacc mapstruct ../include/map.h \|	2100	INCLUDE: $PERL genacc maptile ../include/map.h \|
2152		2101
2153	mapstruct *new (int width, int height)	2102	void
		2103	maptile::instantiate ()
		2104
		2105	maptile *new ()
2154	PROTOTYPE:	2106	PROTOTYPE:
2155	CODE:	2107	CODE:
2156	{	2108	RETVAL = new maptile;
2157	RETVAL = get_empty_map (width, height);
2158	}
2159	OUTPUT:	2109	OUTPUT:
2160	RETVAL	2110	RETVAL
2161		2111
2162	void delete_map (mapstruct *map)	2112	void
		2113	maptile::players ()
		2114	PPCODE:
		2115	if (GIMME_V == G_SCALAR)
		2116	XPUSHs (sv_2mortal (to_sv (THIS->players)));
		2117	else if (GIMME_V == G_ARRAY)
		2118	{
		2119	EXTEND (SP, THIS->players);
		2120	for_all_players (pl)
		2121	if (pl->ob && pl->ob->map == THIS)
		2122	PUSHs (sv_2mortal (to_sv (pl->ob)));
		2123	}
2163		2124
2164	void clean_tmp_map (mapstruct *map)
2165
2166	void play_sound_map (mapstruct *map, int x, int y, int sound_num)	2125	void play_sound_map (maptile *map, int x, int y, int sound_num)
2167		2126
2168	mapstruct tile_map (mapstruct map, unsigned int dir)	2127	int out_of_map (maptile *map, int x, int y)
2169	CODE:
2170	RETVAL = dir < 4 ? map->tile_map [dir] : 0;
2171	OUTPUT:
2172	RETVAL
2173		2128
2174	char tile_path (mapstruct map, unsigned int dir)
2175	CODE:
2176	if (dir >= 4)
2177	XSRETURN_UNDEF;
2178	RETVAL = map->tile_path [dir];
2179	OUTPUT:
2180	RETVAL
2181
2182	mapstruct ready_map_name (char name, int flags = 0)
2183	PROTOTYPE: $;$
2184	ALIAS:
2185	find = 0
2186	get_map = 1
2187
2188	mapstruct has_been_loaded (char name)
2189	PROTOTYPE: $
2190
2191	int in_memory (mapstruct *map)
2192	CODE:
2193	RETVAL = map->in_memory;
2194	OUTPUT:
2195	RETVAL
2196
2197	void	2129	void
2198	trigger (mapstruct *map, long connection, bool state = true)	2130	trigger (maptile *map, long connection, bool state = true)
2199	CODE:	2131	CODE:
2200	activate_connection (map, connection, state);	2132	activate_connection (map, connection, state);
2201		2133
2202	void	2134	void
2203	get_connection (mapstruct *map, long connection)	2135	get_connection (maptile *map, long connection)
2204	PPCODE:	2136	PPCODE:
2205	oblinkpt *obp = get_connection_links (map, connection);	2137	oblinkpt *obp = get_connection_links (map, connection);
2206	if (obp)	2138	if (obp)
2207	for (objectlink *ol = obp->link; ol; ol = ol->next)	2139	for (objectlink *ol = obp->link; ol; ol = ol->next)
2208	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, ol->ob)));	2140	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, (object *)ol->ob)));
2209		2141
2210	object cf_map_insert_object_there (mapstruct where, object op, object originator, int flags)	2142	object cf_map_insert_object_there (maptile where, object op, object originator, int flags)
2211		2143
2212	object cf_map_insert_object (mapstruct where, object* op, int x, int y)	2144	object cf_map_insert_object (maptile where, object* op, int x, int y)
2213		2145
2214	object* cf_map_present_arch_by_name (mapstruct map, const char str, int nx, int ny)	2146	object* cf_map_present_arch_by_name (maptile map, const char str, int nx, int ny)
2215	C_ARGS: str, map, nx, ny	2147	C_ARGS: str, map, nx, ny
2216		2148
2217	void	2149	void
2218	cf_map_normalise (mapstruct *map, int x, int y)	2150	get_map_flags (maptile *map, int x, int y)
2219	PPCODE:	2151	PPCODE:
2220	{	2152	{
2221	mapstruct *nmap = 0;	2153	maptile *nmap = 0;
2222	I16 nx = 0, ny = 0;	2154	I16 nx = 0, ny = 0;
2223	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);	2155	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
2224		2156
2225	EXTEND (SP, 4);	2157	EXTEND (SP, 4);
2226	PUSHs (sv_2mortal (newSViv (flags)));	2158	PUSHs (sv_2mortal (newSViv (flags)));
…		…
2232	PUSHs (sv_2mortal (newSViv (ny)));	2164	PUSHs (sv_2mortal (newSViv (ny)));
2233	}	2165	}
2234	}	2166	}
2235		2167
2236	void	2168	void
2237	at (mapstruct *map, unsigned int x, unsigned int y)	2169	at (maptile *map, unsigned int x, unsigned int y)
2238	PROTOTYPE: $$$	2170	PROTOTYPE: $$$
2239	PPCODE:	2171	PPCODE:
2240	{	2172	{
2241	object *o;	2173	object *o;
2242	mapstruct *nmap = 0;	2174	maptile *nmap = 0;
2243	I16 nx, ny;	2175	I16 nx, ny;
2244		2176
2245	get_map_flags (map, &nmap, x, y, &nx, &ny);	2177	get_map_flags (map, &nmap, x, y, &nx, &ny);
2246		2178
2247	if (nmap)	2179	if (nmap)
2248	for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)	2180	for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)
2249	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));	2181	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));
2250	}	2182	}
2251		2183
2252	SV *	2184	SV *
2253	bot_at (mapstruct *obj, unsigned int x, unsigned int y)	2185	bot_at (maptile *obj, unsigned int x, unsigned int y)
2254	PROTOTYPE: $$$	2186	PROTOTYPE: $$$
2255	ALIAS:	2187	ALIAS:
2256	top_at = 1	2188	top_at = 1
2257	flags_at = 2	2189	flags_at = 2
2258	light_at = 3	2190	light_at = 3
2259	move_block_at = 4	2191	move_block_at = 4
2260	move_slow_at = 5	2192	move_slow_at = 5
2261	move_on_at = 6	2193	move_on_at = 6
2262	move_off_at = 7	2194	move_off_at = 7
2263	INIT:	2195	INIT:
2264	if (x >= MAP_WIDTH (obj) \|\| y >= MAP_HEIGHT (obj)) XSRETURN_UNDEF;	2196	if (x >= obj->width \|\| y >= obj->height) XSRETURN_UNDEF;
2265	CODE:	2197	CODE:
2266	switch (ix)	2198	switch (ix)
2267	{	2199	{
2268	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;	2200	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;
2269	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;	2201	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;
…		…
2272	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;	2204	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;
2273	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;	2205	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;
2274	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;	2206	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;
2275	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;	2207	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;
2276	}	2208	}
2277	OUTPUT:	2209	OUTPUT: RETVAL
		2210
		2211	void fix_walls (maptile *map, int x, int y)
		2212
		2213	void fix_walls_around (maptile *map, int x, int y)
		2214
		2215	const char *
		2216	region_name (maptile *m)
		2217	CODE:
		2218	RETVAL = get_name_of_region_for_map (m);
		2219	OUTPUT: RETVAL
		2220
		2221	# worst xs function of my life
		2222	bool
		2223	_create_random_map (\
		2224	maptile *self,\
		2225	char *wallstyle,\
		2226	char *wall_name,\
		2227	char *floorstyle,\
		2228	char *monsterstyle,\
		2229	char *treasurestyle,\
		2230	char *layoutstyle,\
		2231	char *doorstyle,\
		2232	char *decorstyle,\
		2233	char *origin_map,\
		2234	char *final_map,\
		2235	char *exitstyle,\
		2236	char *this_map,\
		2237	char *exit_on_final_map,\
		2238	int xsize,\
		2239	int ysize,\
		2240	int expand2x,\
		2241	int layoutoptions1,\
		2242	int layoutoptions2,\
		2243	int layoutoptions3,\
		2244	int symmetry,\
		2245	int difficulty,\
		2246	int difficulty_given,\
		2247	float difficulty_increase,\
		2248	int dungeon_level,\
		2249	int dungeon_depth,\
		2250	int decoroptions,\
		2251	int orientation,\
		2252	int origin_y,\
		2253	int origin_x,\
		2254	U32 random_seed,\
		2255	val64 total_map_hp,\
		2256	int map_layout_style,\
		2257	int treasureoptions,\
		2258	int symmetry_used,\
		2259	region *region,\
		2260	char *custom\
		2261	)
		2262	CODE:
		2263	{
		2264	random_map_params rmp;
		2265
		2266	assign (rmp.wallstyle , wallstyle);
		2267	assign (rmp.wall_name , wall_name);
		2268	assign (rmp.floorstyle , floorstyle);
		2269	assign (rmp.monsterstyle , monsterstyle);
		2270	assign (rmp.treasurestyle , treasurestyle);
		2271	assign (rmp.layoutstyle , layoutstyle);
		2272	assign (rmp.doorstyle , doorstyle);
		2273	assign (rmp.decorstyle , decorstyle);
		2274	assign (rmp.exitstyle , exitstyle);
		2275	assign (rmp.exit_on_final_map, exit_on_final_map);
		2276
		2277	rmp.origin_map = origin_map;
		2278	rmp.final_map = final_map;
		2279	rmp.this_map = this_map;
		2280	rmp.xsize = xsize;
		2281	rmp.ysize = ysize;
		2282	rmp.expand2x = expand2x;
		2283	rmp.layoutoptions1 = layoutoptions1;
		2284	rmp.layoutoptions2 = layoutoptions2;
		2285	rmp.layoutoptions3 = layoutoptions3;
		2286	rmp.symmetry = symmetry;
		2287	rmp.difficulty = difficulty;
		2288	rmp.difficulty_given = difficulty_given;
		2289	rmp.difficulty_increase = difficulty_increase;
		2290	rmp.dungeon_level = dungeon_level;
		2291	rmp.dungeon_depth = dungeon_depth;
		2292	rmp.decoroptions = decoroptions;
		2293	rmp.orientation = orientation;
		2294	rmp.origin_y = origin_y;
		2295	rmp.origin_x = origin_x;
		2296	rmp.random_seed = random_seed;
		2297	rmp.total_map_hp = total_map_hp;
		2298	rmp.map_layout_style = map_layout_style;
		2299	rmp.treasureoptions = treasureoptions;
		2300	rmp.symmetry_used = symmetry_used;
		2301	rmp.region = region;
		2302	rmp.custom = custom;
		2303
		2304	RETVAL = self->generate_random_map (&rmp);
		2305	}
		2306	OUTPUT:
2278	RETVAL	2307	RETVAL
2279
2280		2308
2281	MODULE = cf PACKAGE = cf::arch	2309	MODULE = cf PACKAGE = cf::arch
2282		2310
2283	archetype find (const char name)	2311	archetype find (const char name)
2284	CODE:	2312	CODE:
2285	RETVAL = find_archetype (name);	2313	RETVAL = archetype::find (name);
2286	OUTPUT:	2314	OUTPUT:
2287	RETVAL	2315	RETVAL
2288		2316
2289	archetype *first()	2317	archetype *first()
2290	PROTOTYPE:	2318	PROTOTYPE:
…		…
2300	PROTOTYPE:	2328	PROTOTYPE:
2301	CODE:	2329	CODE:
2302	RETVAL = get_firstparty ();	2330	RETVAL = get_firstparty ();
2303	OUTPUT: RETVAL	2331	OUTPUT: RETVAL
2304		2332
2305	partylist next (partylist party)	2333	INCLUDE: $PERL genacc partylist ../include/player.h \|
2306	CODE:
2307	RETVAL = party->next;
2308	OUTPUT: RETVAL
2309
2310	const char name (partylist party)
2311	CODE:
2312	RETVAL = party->partyname;
2313	OUTPUT: RETVAL
2314
2315	const char password (partylist party)
2316	CODE:
2317	RETVAL = party->passwd;
2318	OUTPUT: RETVAL
2319		2334
2320	MODULE = cf PACKAGE = cf::region	2335	MODULE = cf PACKAGE = cf::region
2321		2336
2322	region *first ()	2337	region *first ()
2323	PROTOTYPE:	2338	PROTOTYPE:
2324	CODE:	2339	CODE:
2325	RETVAL = first_region;	2340	RETVAL = first_region;
2326	OUTPUT: RETVAL	2341	OUTPUT: RETVAL
2327		2342
2328	region next (region reg)	2343	region find (char name)
		2344	PROTOTYPE: $
2329	CODE:	2345	CODE:
2330	RETVAL = reg->next;	2346	RETVAL = get_region_by_name (name);
2331	OUTPUT: RETVAL	2347	OUTPUT: RETVAL
2332		2348
2333	const char name (region reg)	2349	INCLUDE: $PERL genacc region ../include/map.h \|
2334	CODE:
2335	RETVAL = reg->name;
2336	OUTPUT: RETVAL
2337
2338	region parent (region reg)
2339	CODE:
2340	RETVAL = reg->parent;
2341	OUTPUT: RETVAL
2342
2343	const char longname (region reg)
2344	CODE:
2345	RETVAL = reg->longname;
2346	OUTPUT: RETVAL
2347
2348	const char msg (region reg)
2349	CODE:
2350	RETVAL = reg->msg;
2351	OUTPUT: RETVAL
2352		2350
2353	MODULE = cf PACKAGE = cf::living	2351	MODULE = cf PACKAGE = cf::living
2354		2352
2355	INCLUDE: $PERL genacc living ../include/living.h \|	2353	INCLUDE: $PERL genacc living ../include/living.h \|
2356		2354
		2355	MODULE = cf PACKAGE = cf::settings
		2356
		2357	INCLUDE: $PERL genacc Settings ../include/global.h \|
		2358
		2359	MODULE = cf PACKAGE = cf::client
		2360
		2361	INCLUDE: $PERL genacc client ../include/client.h \|
		2362
		2363	int invoke (client *ns, int event, ...)
		2364	CODE:
		2365	if (KLASS_OF (event) != KLASS_CLIENT) croak ("event class must be CLIENT");
		2366	AV av = (AV )sv_2mortal ((SV *)newAV ());
		2367	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
		2368	RETVAL = ns->invoke ((event_type)event, ARG_AV (av), DT_END);
		2369	OUTPUT: RETVAL
		2370
		2371	SV registry (client ns)
		2372
		2373	void
		2374	list ()
		2375	PPCODE:
		2376	EXTEND (SP, clients.size ());
		2377	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
		2378	PUSHs (sv_2mortal (to_sv (*i)));
		2379
		2380	void
		2381	client::send_packet (SV *packet)
		2382	CODE:
		2383	{
		2384	STRLEN len;
		2385	char *buf = SvPVbyte (packet, len);
		2386
		2387	THIS->send_packet (buf, len);
		2388	}
		2389

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.55 by root, Tue Sep 12 18:15:34 2006 UTC vs. Revision 1.150 by root, Tue Jan 23 01:05:18 2007 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.55 by root, Tue Sep 12 18:15:34 2006 UTC vs.
Revision 1.150 by root, Tue Jan 23 01:05:18 2007 UTC