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

Diff Legend

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