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.9 by root, Fri Aug 25 15:31:45 2006 UTC vs.
Revision 1.160 by elmex, Wed Jan 31 14:11:02 2007 UTC

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

Diff Legend

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