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

Diff Legend

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