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.3 by root, Thu Aug 17 20:23:31 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	#define PLUGIN_NAME "perl"
		27	#define PLUGIN_VERSION "cfperl 0.5"
		28
		29	#include <plugin_common.h>
		30	#include <sounds.h>
		31	#include <cstdarg>
		32	#include <sproto.h>
		33
		34	#include "cfperl.h"
		35	#include "shstr.h"
		36
		37	#include <unistd.h>
		38	#if _POSIX_MEMLOCK
		39	# include <sys/mman.h>
		40	#endif
25		41
26	#include <EXTERN.h>	42	#include <EXTERN.h>
27	#include <perl.h>	43	#include <perl.h>
28	#include <XSUB.h>	44	#include <XSUB.h>
29		45
30	#undef save_long // clashes with libproto.h	46	#include "CoroAPI.h"
		47	#include "perlxsi.c"
31		48
32	#define PLUGIN_NAME "perl"	49	extern sint64 *levels; // the experience table
33	#define PLUGIN_VERSION "cfperl 0.3"
34		50
35	#ifndef __CEXTRACT__	51	typedef object object_ornull;
36	#include <plugin.h>	52	typedef maptile maptile_ornull;
		53
		54	#if IVSIZE >= 8
		55	typedef IV val64;
		56	# define newSVval64 newSViv
		57	# define SvVAL64 SvIV
		58	#else
		59	typedef double val64;
		60	# define newSVval64 newSVnv
		61	# define SvVAL64 SvNV
37	#endif	62	#endif
38		63
39	#undef MODULEAPI	64	static f_plug_api gethook = cfapi_get_hooks;
40	#ifdef WIN32	65	static f_plug_api object_set_property = cfapi_object_set_property;
41	#else	66	static f_plug_api object_insert = cfapi_object_insert;
42	#define MODULEAPI
43	#endif
44		67
45	#include <plugin_common.h>
46	#include <sounds.h>
47
48	#include <stdarg.h>
49
50	#include <sproto.h>
51
52	//#include "EventAPI.h"
53	#include "perlxsi.c"
54
55	static void *globalEventListener (int *type, ...);
56
57	extern sint64 *levels; // the experience table
58
59	typedef object object_ornull;
60	typedef mapstruct mapstruct_ornull;
61
62	typedef double val64;
63	#define newSVval64 newSVnv
64	#define SvVAL64 SvNV
65
66	static f_plug_api gethook;
67	static f_plug_api registerGlobalEvent;
68	static f_plug_api unregisterGlobalEvent;
69	static f_plug_api systemDirectory;
70	static f_plug_api object_set_property;
71	static f_plug_api map_get_map;
72	static f_plug_api object_insert;
73
74	/* this is a stupid way to do things, and awkward to use for plug-in authors */
75	typedef struct
76	{
77	object* who;
78	object* activator;
79	object* third;
80	object* event;
81	mapstruct* map;
82	char message[1024];
83	int fix; // seems to be python-only, and should not be part of the API
84	int event_code;
85	char extension[1024]; // name field, should invoke specific perl extension
86	char options[1024]; // slaying field of event_connectors
87	int returnvalue;
88	} CFPContext;
89
90	static HV *obj_cache;
91	static PerlInterpreter *perl;	68	static PerlInterpreter *perl;
92		69
93	#define PUSHcfapi(type,value) PUSHs (sv_2mortal (newSVcfapi (CFAPI_ ## type, (value))))	70	double runtime;
94	#define PUSHcfapi_va(type,ctype) PUSHcfapi (type, va_arg (args, ctype))	71
95	#define PUSH_OB PUSHcfapi_va(POBJECT, object *)	72	global gbl_ev;
96	#define PUSH_PL PUSHcfapi_va(PPLAYER, player *)	73	static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map;
97	#define PUSH_MAP PUSHcfapi_va(PMAP, mapstruct *)	74	static SV *sv_runtime;
98	#define PUSH_PV PUSHcfapi_va(STRING, const char *)	75
99	#define PUSH_IV PUSHs (sv_2mortal (newSViv (va_arg (args, int))))	76	static HV
		77	*stash_cf,
		78	*stash_cf_object_wrap,
		79	*stash_cf_object_player_wrap,
		80	*stash_cf_player_wrap,
		81	*stash_cf_map_wrap,
		82	*stash_cf_client_wrap,
		83	*stash_cf_arch_wrap,
		84	*stash_cf_party_wrap,
		85	*stash_cf_region_wrap,
		86	*stash_cf_living_wrap;
		87
		88	// helper cast function, returns super class * or 0
		89	template<class super>
		90	static super *
		91	is_a (attachable *at)
		92	{
		93	//return dynamic_cast<super *>(at); // slower, safer
		94	if (typeid (*at) == typeid (super))
		95	return static_cast<super *>(at);
		96	else
		97	return 0;
		98	}
100		99
101	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	100	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
102		101
103	// garbage collect some perl objects, if possible	102	unordered_vector<attachable *> attachable::mortals;
104	// all objects no longer referenced and empty are
105	// eligible for destruction.
106	static void
107	clean_obj_cache ()
108	{
109	static int count;
110		103
111	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)
112	return;	148	return;
113		149
114	int todo = 1000;	150	destroy ();
115	do	151	}
		152
		153	void
		154	attachable::do_destroy ()
		155	{
		156	invoke (EVENT_ATTACHABLE_DESTROY, DT_END);
		157
		158	if (cb)
116	{	159	{
117	I32 klen;	160	SvREFCNT_dec (cb);
118	char *key;	161	cb = 0;
119	HE *he = hv_iternext (obj_cache);	162	}
120		163
121	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 ())
122	{	188	{
123	SV *sv = hv_iterval (obj_cache, he);	189	i = 0;
124		190
125	// empty and unreferenced? nuke it	191	if (mortals.size () > 1000)
126	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 ());
127	{	193
128	hv_delete (obj_cache, HeKEY (he), HeKLEN (he), G_DISCARD);	194	break;
129	todo++;
130	}	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;
131	}	209	}
132	else	210	else
133	break;	211	{
		212	mortals.erase (i);
		213	delete obj;
		214	}
134	}	215	}
135	while (--todo);
136	}	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	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
137		229
138	static SV *	230	static SV *
139	newSVptr (void *ptr, const char *klass)	231	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())
140	{	232	{
141	SV *sv;	233	SV *sv;
142		234
143	if (!ptr)	235	if (!ptr)
144	return &PL_sv_undef;	236	return &PL_sv_undef;
145		237
146	sv = newSV (0);
147	sv_magic (sv, 0, PERL_MAGIC_ext, (char *)ptr, 0);	238	sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);
148	return sv_bless (newRV_noinc (sv), gv_stashpv (klass, 1));	239	return sv_bless (newRV_noinc ((SV *)hv), stash);
149	}	240	}
150		241
151	static void	242	static int
152	SVptr_cache_set (void *ptr, SV *sv)	243	attachable_free (pTHX_ SV *sv, MAGIC *mg)
153	{	244	{
154	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;
155	}	257	}
		258
		259	MGVTBL attachable::vtbl = {0, 0, 0, 0, attachable_free};
156		260
157	static SV *	261	static SV *
158	SVptr_cache_get (void *ptr)	262	newSVattachable (attachable *obj, HV *stash)
159	{	263	{
160	SV **he = hv_fetch (obj_cache, (char *)&ptr, sizeof (ptr), 0);	264	if (!obj)
161
162	return he ? *he : 0;
163	}
164
165	static SV *
166	newSVptr_cached (void *ptr, const char *klass)
167	{
168	SV *sv;
169
170	if (!ptr)
171	return &PL_sv_undef;	265	return &PL_sv_undef;
172		266
173	sv = SVptr_cache_get (ptr);	267	if (!obj->self)
174
175	if (!sv)
176	{	268	{
177	HV *hv = newHV ();	269	obj->self = newHV ();
178	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);
179	sv = sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));
180		271
181	SVptr_cache_set (ptr, sv);	272	// now bless the object _once_
		273	return sv_bless (newRV_inc ((SV *)obj->self), stash);
182	}	274	}
		275	else
		276	{
		277	SV *sv = newRV_inc ((SV *)obj->self);
183		278
184	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	}
185	}	284	}
186		285
187	static void	286	static void
188	clearSVptr (SV *sv)	287	clearSVptr (SV *sv)
189	{	288	{
…		…
215	return SvPTR (sv, klass);	314	return SvPTR (sv, klass);
216	else	315	else
217	return 0;	316	return 0;
218	}	317	}
219		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
220	static SV *	406	static SV *
221	newSVcfapi (int type, ...)	407	newSVdt_va (va_list &ap, data_type type)
222	{	408	{
223	SV *sv;	409	SV *sv;
224
225	va_list args;
226	va_start (args, type);
227		410
228	switch (type)	411	switch (type)
229	{	412	{
230	#if 0
231	case CFAPI_INT16:	413	case DT_INT:
232	sv = newSViv (*va_arg (args, sint16_t *));	414	sv = newSViv (va_arg (ap, int));
233	break;	415	break;
234	#endif
235		416
236	case CFAPI_INT:	417	case DT_INT64:
237	sv = newSViv (*va_arg (args, int *));	418	sv = newSVval64 ((val64)va_arg (ap, sint64));
238	break;	419	break;
239		420
240	case CFAPI_LONG:	421	case DT_DOUBLE:
241	sv = newSVval64 ((val64)*va_arg (args, sint64 *));	422	sv = newSVnv (va_arg (ap, double));
242	break;	423	break;
243		424
244	case CFAPI_DOUBLE:
245	sv = newSVnv (*va_arg (args, double *));
246	break;
247
248	case CFAPI_STRING:	425	case DT_STRING:
249	{	426	{
250	char *str = va_arg (args, char *);	427	char *str = (char *)va_arg (ap, const char *);
251	sv = str ? newSVpv (str, 0) : &PL_sv_undef;	428	sv = str ? newSVpv (str, 0) : &PL_sv_undef;
252	}	429	}
253	break;	430	break;
254		431
255	case CFAPI_POBJECT:	432	case DT_DATA:
256	{	433	{
257	object *obj = va_arg (args, object *);	434	char *str = (char *)va_arg (ap, const void *);
258		435	int len = va_arg (ap, int);
259	if (!obj)	436	sv = str ? newSVpv (str, len) : &PL_sv_undef;
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	}	437	}
277	break;	438	break;
278		439
279	case CFAPI_PMAP:	440	case DT_OBJECT:
280	sv = newSVptr (va_arg (args, mapstruct *), "cf::map::wrap");	441	sv = to_sv (va_arg (ap, object *));
281	break;	442	break;
282		443
283	case CFAPI_PPLAYER:	444	case DT_MAP:
284	sv = newSVptr (va_arg (args, player *), "cf::player::wrap");	445	// va_arg (object *) when void * is passed is an XSI extension
		446	sv = to_sv (va_arg (ap, maptile *));
285	break;	447	break;
286		448
287	case CFAPI_PARCH:	449	case DT_CLIENT:
288	sv = newSVptr (va_arg (args, archetype *), "cf::arch::wrap");	450	sv = to_sv (va_arg (ap, client *));
289	break;	451	break;
290		452
291	case CFAPI_PPARTY:	453	case DT_PLAYER:
292	sv = newSVptr (va_arg (args, partylist *), "cf::party::wrap");	454	sv = to_sv (va_arg (ap, player *));
293	break;	455	break;
294		456
295	case CFAPI_PREGION:	457	case DT_ARCH:
296	sv = newSVptr (va_arg (args, region *), "cf::region::wrap");	458	sv = to_sv (va_arg (ap, archetype *));
297	break;	459	break;
		460
		461	case DT_PARTY:
		462	sv = to_sv (va_arg (ap, partylist *));
		463	break;
		464
		465	case DT_REGION:
		466	sv = to_sv (va_arg (ap, region *));
		467	break;
		468
		469	default:
		470	assert (("unhandled type in newSVdt_va", 0));
		471	}
		472
		473	return sv;
		474	}
		475
		476	static SV *
		477	newSVdt (data_type type, ...)
		478	{
		479	va_list ap;
		480
		481	va_start (ap, type);
		482	SV *sv = newSVdt_va (ap, type);
		483	va_end (ap);
		484
		485	return sv;
		486	}
		487
		488	static SV *
		489	newSVcfapi (int type, ...)
		490	{
		491	SV *sv;
		492
		493	va_list ap;
		494	va_start (ap, type);
		495
		496	switch (type)
		497	{
		498	case CFAPI_INT: sv = newSViv (*va_arg (ap, int * )); break;
		499	case CFAPI_LONG: sv = newSVval64 (*va_arg (ap, sint64 *)); break;
		500	case CFAPI_DOUBLE: sv = newSVnv (*va_arg (ap, double *)); break;
		501	case CFAPI_STRING: sv = newSVdt_va (ap, DT_STRING); break;
		502	case CFAPI_POBJECT: sv = newSVdt_va (ap, DT_OBJECT); break;
		503	case CFAPI_PMAP: sv = newSVdt_va (ap, DT_MAP ); break;
		504	case CFAPI_PPLAYER: sv = newSVdt_va (ap, DT_PLAYER); break;
		505	case CFAPI_PARCH: sv = newSVdt_va (ap, DT_ARCH ); break;
		506	case CFAPI_PPARTY: sv = newSVdt_va (ap, DT_PARTY ); break;
		507	case CFAPI_PREGION: sv = newSVdt_va (ap, DT_REGION); break;
298		508
299	default:	509	default:
300	assert (("unhandled type in newSVcfapi", 0));	510	assert (("unhandled type in newSVcfapi", 0));
301	}	511	}
302		512
303	va_end (args);	513	va_end (ap);
304		514
305	return sv;	515	return sv;
306	}	516	}
307		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
308	/////////////////////////////////////////////////////////////////////////////	529	/////////////////////////////////////////////////////////////////////////////
309		530
310	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)
311	{	532	{
312	gethook = gethooksptr;
313	printf (PLUGIN_VERSION " init\n");
314
315	return 0;	533	return 0;
316	}	534	}
317		535
318	static CommArray_s rtn_cmd;	536	static CommArray_s rtn_cmd;
319		537
320	static int	538	static int
321	runPluginCommand (object *obj, char *params)	539	runPluginCommand (object *obj, char *params)
322	{	540	{
323	dSP;	541	return -1;
324
325	ENTER;
326	SAVETMPS;
327
328	PUSHMARK (SP);
329
330	EXTEND (SP, 3);
331	PUSHs (sv_2mortal (newSVpv (rtn_cmd.name, 0)));
332	PUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, obj)));
333
334	if (params)
335	PUSHs (sv_2mortal (newSVpv (params, 0)));
336
337	PUTBACK;
338	int count = call_pv ("cf::inject_command", G_SCALAR | G_EVAL);
339	SPAGAIN;
340
341	if (SvTRUE (ERRSV))
342	LOG (llevError, "command '%s' callback evaluation error: %s", rtn_cmd.name, SvPV_nolen (ERRSV));
343
344	int returnvalue = count > 0 ? POPi : -1;
345
346	PUTBACK;
347	FREETMPS;
348	LEAVE;
349
350	return returnvalue;
351	}	542	}
352		543
353	extern "C" void *cfperl_getPluginProperty (int *type, ...)	544	extern "C" void *cfperl_getPluginProperty (int *type, ...)
354	{	545	{
355	va_list args;	546	va_list args;
…		…
358	va_start (args, type);	549	va_start (args, type);
359	propname = va_arg (args, char *);	550	propname = va_arg (args, char *);
360	//printf ("Property name: %s\n", propname);	551	//printf ("Property name: %s\n", propname);
361		552
362	if (!strcmp (propname, "command?"))	553	if (!strcmp (propname, "command?"))
363	{
364	if (!perl)
365	return NULL;	554	return NULL;
366
367	const char *cmdname = va_arg (args, const char *);
368	HV *hv = get_hv ("cf::COMMAND", 1);
369	SV **svp = hv_fetch (hv, cmdname, strlen (cmdname) + 1, 0);
370
371	va_end (args);
372
373	if (svp)
374	{
375	// this is totaly broken, should stash it into %COMMAND
376	rtn_cmd.name = cmdname;
377	rtn_cmd.time = SvNV (*svp);
378	rtn_cmd.func = runPluginCommand;
379
380	return &rtn_cmd;
381	}
382	}
383	else if (!strcmp (propname, "Identification"))	555	else if (!strcmp (propname, "Identification"))
384	{	556	{
385	va_end (args);	557	va_end (args);
386	return (void*) PLUGIN_NAME;	558	return (void *)PLUGIN_NAME;
387	}	559	}
388	else if (!strcmp (propname, "FullName"))	560	else if (!strcmp (propname, "FullName"))
389	{	561	{
390	va_end (args);	562	va_end (args);
391	return (void*) PLUGIN_VERSION;	563	return (void *)PLUGIN_VERSION;
392	}	564	}
393	else	565	else
394	va_end (args);	566	va_end (args);
395		567
396	return NULL;	568	return NULL;
…		…
399	extern "C" int cfperl_postInitPlugin ()	571	extern "C" int cfperl_postInitPlugin ()
400	{	572	{
401	int hooktype = 1;	573	int hooktype = 1;
402	int rtype = 0;	574	int rtype = 0;
403		575
404	printf (PLUGIN_VERSION " post init\n");
405
406	registerGlobalEvent = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_system_register_global_event");
407	unregisterGlobalEvent = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_system_unregister_global_event");
408	systemDirectory = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_system_directory");
409	object_set_property = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_object_set_property");
410	map_get_map = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_map_get_map");
411	object_insert = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_object_insert");
412
413	cf_init_plugin (gethook);	576	cf_init_plugin (gethook);
414		577
415	/* Pick the global events you want to monitor from this plugin */	578	return 0;
416	registerGlobalEvent (NULL, EVENT_BORN, PLUGIN_NAME, globalEventListener);	579	}
417	registerGlobalEvent (NULL, EVENT_CLOCK, PLUGIN_NAME, globalEventListener);	580
418	//registerGlobalEvent (NULL, EVENT_CRASH, PLUGIN_NAME, globalEventListener);	581	extern "C" int cfperl_closePlugin ()
419	registerGlobalEvent (NULL, EVENT_FIND_UNARMED_SKILL, PLUGIN_NAME, globalEventListener);	582	{
420	registerGlobalEvent (NULL, EVENT_PLAYER_USE_SKILL, PLUGIN_NAME, globalEventListener);	583	return 0;
421	registerGlobalEvent (NULL, EVENT_CAST_SPELL, PLUGIN_NAME, globalEventListener);	584	}
422	registerGlobalEvent (NULL, EVENT_MONSTER_USE_SKILL, PLUGIN_NAME, globalEventListener);	585
423	registerGlobalEvent (NULL, EVENT_PLAYER_DEATH, PLUGIN_NAME, globalEventListener);	586	void
424	registerGlobalEvent (NULL, EVENT_GKILL, PLUGIN_NAME, globalEventListener);	587	cfperl_init ()
425	registerGlobalEvent (NULL, EVENT_LOGIN, PLUGIN_NAME, globalEventListener);	588	{
426	registerGlobalEvent (NULL, EVENT_LOGOUT, PLUGIN_NAME, globalEventListener);	589	PERL_SYS_INIT3 (&settings.argc, &settings.argv, 0);
427	registerGlobalEvent (NULL, EVENT_MAPENTER, PLUGIN_NAME, globalEventListener);	590	perl = perl_alloc ();
428	registerGlobalEvent (NULL, EVENT_MAPLEAVE, PLUGIN_NAME, globalEventListener);	591	perl_construct (perl);
429	registerGlobalEvent (NULL, EVENT_MAPRESET, PLUGIN_NAME, globalEventListener);	592
430	registerGlobalEvent (NULL, EVENT_MAPLOAD, PLUGIN_NAME, globalEventListener);	593	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
431	registerGlobalEvent (NULL, EVENT_MAPOUT, PLUGIN_NAME, globalEventListener);
432	registerGlobalEvent (NULL, EVENT_MAPIN, PLUGIN_NAME, globalEventListener);
433	registerGlobalEvent (NULL, EVENT_MAPCLEAN, PLUGIN_NAME, globalEventListener);
434	registerGlobalEvent (NULL, EVENT_REMOVE, PLUGIN_NAME, globalEventListener);
435	registerGlobalEvent (NULL, EVENT_SHOUT, PLUGIN_NAME, globalEventListener);
436	registerGlobalEvent (NULL, EVENT_TELL, PLUGIN_NAME, globalEventListener);
437	registerGlobalEvent (NULL, EVENT_MUZZLE, PLUGIN_NAME, globalEventListener);
438	registerGlobalEvent (NULL, EVENT_KICK, PLUGIN_NAME, globalEventListener);
439	registerGlobalEvent (NULL, EVENT_FREE_OB, PLUGIN_NAME, globalEventListener);
440	registerGlobalEvent (NULL, EVENT_PLAYER_LOAD, PLUGIN_NAME, globalEventListener);
441	registerGlobalEvent (NULL, EVENT_PLAYER_SAVE, PLUGIN_NAME, globalEventListener);
442	registerGlobalEvent (NULL, EVENT_EXTCMD, PLUGIN_NAME, globalEventListener);
443		594
444	char *argv[] = {	595	char *argv[] = {
445	"",	596	"",
446	"-e"	597	"-e"
447	"BEGIN {"	598	"use Event; use Coro;" // required for bootstrap
448	" cf->bootstrap;"	599	"cf->bootstrap;" // required for datadir :*>
449	" unshift @INC, cf::datadir ();"	600	"unshift @INC, cf::datadir ();"
450	"}"
451	""
452	"use cf;"	601	"require cf;"
453	};	602	};
454
455	perl = perl_alloc ();
456	perl_construct (perl);
457
458	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
459		603
460	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))
461	{	605	{
462	printf ("unable to initialize perl-interpreter, continuing without.\n");	606	printf ("unable to initialize perl-interpreter, aborting.\n");
463		607	exit (EXIT_FAILURE);
464	perl_destruct (perl);
465	perl_free (perl);
466	perl = 0;
467	}	608	}
		609	}
		610
		611	void cfperl_main ()
		612	{
		613	dSP;
		614
		615	PUSHMARK (SP);
		616	PUTBACK;
		617	call_pv ("cf::main", G_DISCARD | G_VOID);
		618	}
		619
		620	void
		621	attachable::instantiate ()
		622	{
		623	if (attach)
		624	{
		625	invoke (EVENT_ATTACHABLE_INSTANTIATE, ARG_STRING (attach), DT_END);
		626	attach = 0;
		627	}
		628	}
		629
		630	void
		631	attachable::reattach ()
		632	{
		633	optimise ();
		634	//TODO: check for _attachment's, very important for restarts
		635	invoke (EVENT_ATTACHABLE_REATTACH, DT_END);
		636	}
		637
		638	static event_klass klass_of[NUM_EVENT_TYPES] = {
		639	# define def(type,name) KLASS_ ## type,
		640	# include "eventinc.h"
		641	# undef def
		642	};
		643
		644	#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)
		645
		646	static void
		647	gather_callbacks (AV *&callbacks, AV *registry, event_type event)
		648	{
		649	// event must be in array
		650	if (event >= 0 && event <= AvFILLp (registry))
		651	{
		652	SV *cbs_ = AvARRAY (registry)[event];
		653
		654	// element must be list of callback entries
		655	if (cbs_ && SvROK (cbs_) && SvTYPE (SvRV (cbs_)) == SVt_PVAV)
		656	{
		657	AV *cbs = (AV *)SvRV (cbs_);
		658
		659	// no callback entries, no callbacks to call
		660	if (AvFILLp (cbs) >= 0)
		661	{
		662	if (!callbacks)
		663	{
		664	callbacks = newAV ();
		665	av_extend (callbacks, 16);
		666	}
		667
		668	// never use SvREFCNT_inc to copy values, but its ok here :)
		669	for (int i = 0; i <= AvFILLp (cbs); ++i)
		670	av_push (callbacks, SvREFCNT_inc (AvARRAY (cbs)[i]));
		671	}
		672	}
		673	}
		674	}
		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
		743	attachable::invoke (event_type event, ...)
		744	{
		745	data_type dt;
		746	va_list ap;
		747
		748	va_start (ap, event);
		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
		756	AV *callbacks = 0;
		757	gather_callbacks (callbacks, event);
		758
		759	// short-circuit processing if no callbacks found/defined
		760	if (!callbacks)
		761	return 0;
		762
		763	CALL_BEGIN (3);
		764	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays
		765	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));
		766
		767	//TODO: unhack
		768	if (object *op = is_a<object>(this)) CALL_ARG_SV (newSVdt (DT_OBJECT, op));
		769	else if (player *pl = is_a<player>(this)) CALL_ARG_SV (newSVdt (DT_PLAYER, pl));
		770	else if (client *ns = is_a<client>(this)) CALL_ARG_SV (newSVdt (DT_CLIENT, ns));
		771	else if (maptile *m = is_a<maptile>(this)) CALL_ARG_SV (newSVdt (DT_MAP, m));
		772	else if (global *gl = is_a<global>(this)) /*nop*/;
468	else	773	else
		774	abort (); //TODO
		775
		776	for (;;)
469	{	777	{
470	obj_cache = newHV ();	778	dt = (data_type) va_arg (ap, int);
		779
		780	if (dt == DT_END)
		781	break;
		782	else if (dt == DT_AV)
		783	{
		784	AV *av = va_arg (ap, AV *);
		785
		786	for (int i = 0; i <= av_len (av); ++i)
		787	XPUSHs (*av_fetch (av, i, 1));
		788	}
		789	else
		790	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
471	}	791	}
472		792
		793	va_end (ap);
		794
		795	CALL_CALL ("cf::do_invoke", G_SCALAR);
		796	count = count > 0 ? POPi : 0;
		797
		798	CALL_END;
		799
		800	return count;
		801	}
		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
473	return 0;	814	return *sv;
474	}	815	}
475		816
476	static void *	817	int
477	globalEventListener (int *type, ...)	818	cfperl_result_INT (int idx)
478	{	819	{
479	va_list args;	820	return SvIV (cfperl_result (idx));
480	static int rv;	821	}
481	int event_code;
482		822
483	if (!perl)	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)
484	return NULL;	901	return;
485		902
486	va_start (args, type);	903	CALL_BEGIN (2);
487	event_code = va_arg (args, int);	904	CALL_ARG (this);
		905	CALL_ARG (exit);
		906	CALL_CALL ("cf::object::player::enter_exit", G_VOID);
		907	CALL_END;
		908	}
488		909
489	if (event_code == EVENT_FREE_OB)	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)
490	{	968	{
491	player *pl;	969	if (pe->poll) stop ();
492	object *op;	970	pe->poll = events;
493	SV *sv;	971	if (pe->poll) start ();
494
495	op = va_arg (args, object *);
496	sv = hv_delete (obj_cache, (char *)&op, sizeof (void *), 0);
497
498	if (sv)
499	clearSVptr (sv);
500
501	rv = 0;
502	}	972	}
503	else if (event_code == EVENT_CLOCK)
504	{
505	clean_obj_cache ();
506	}
507	else
508	{
509	dSP;
510
511	ENTER;
512	SAVETMPS;
513
514	PUSHMARK (SP);
515
516	EXTEND (SP, 10);
517	PUSHs (sv_2mortal (newSViv (event_code)));
518
519	switch (event_code)
520	{
521	case EVENT_CRASH:
522	break;
523
524	case EVENT_PLAYER_LOAD:
525	case EVENT_PLAYER_SAVE:
526	PUSH_OB;
527	PUSH_PV;
528	break;
529
530	case EVENT_MAPLOAD:
531	case EVENT_MAPOUT:
532	case EVENT_MAPIN:
533	case EVENT_MAPCLEAN:
534	case EVENT_MAPRESET:
535	PUSH_MAP;
536	break;
537
538	case EVENT_MAPENTER:
539	case EVENT_MAPLEAVE:
540	case EVENT_BORN:
541	case EVENT_REMOVE:
542	case EVENT_PLAYER_DEATH:
543	PUSH_OB;
544	break;
545
546	case EVENT_GKILL:
547	PUSH_OB;
548	PUSH_OB;
549	break;
550
551	case EVENT_LOGIN:
552	case EVENT_LOGOUT:
553	PUSH_PL;
554	PUSH_PV;
555	break;
556
557	case EVENT_SHOUT:
558	case EVENT_MUZZLE:
559	case EVENT_KICK:
560	PUSH_OB;
561	PUSH_PV;
562	break;
563
564	case EVENT_FIND_UNARMED_SKILL:
565	PUSH_OB;
566	break;
567
568	case EVENT_PLAYER_USE_SKILL:
569	case EVENT_MONSTER_USE_SKILL:
570	case EVENT_CAST_SPELL:
571	PUSH_OB;
572	PUSH_OB;
573	PUSH_OB;
574	PUSH_IV;
575	PUSH_PV;
576	break;
577
578	case EVENT_EXTCMD:
579	PUSH_PL;
580	{
581	char *buf = va_arg (args, char *);
582	int len = va_arg (args, int);
583	PUSHs (sv_2mortal (newSVpvn (buf, len)));
584	}
585	break;
586
587	case EVENT_TELL:
588	break;
589	}
590
591	va_end (args);
592
593	PUTBACK;
594	int count = call_pv ("cf::inject_global_event", G_SCALAR | G_EVAL);
595	SPAGAIN;
596
597	if (SvTRUE (ERRSV))
598	LOG (llevError, "global event '%d' callback evaluation error: %s", event_code, SvPV_nolen (ERRSV));
599
600	rv = count > 0 ? POPi : 0;
601
602	PUTBACK;
603	FREETMPS;
604	LEAVE;
605	}
606
607	return &rv;
608	}	973	}
609		974
610	extern "C" void *cfperl_eventListener (int *type, ...)	975	void
		976	_connect_to_perl ()
611	{	977	{
612	static int rv;	978	stash_cf = gv_stashpv ("cf" , 1);
613	va_list args;
614	int event_code;
615	object *who, *activator, *third, *event;
616	char *message, *extension, *options;
617		979
618	if (!perl)	980	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);
619	return NULL;	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);
620		989
621	va_start (args, type);	990	sv_runtime = get_sv ("cf::RUNTIME", 1);
622	who = va_arg (args, object *);	991	sv_upgrade (sv_runtime, SVt_NV);
623	event_code = va_arg (args, int);
624	activator = va_arg (args, object *);
625	third = va_arg (args, object *);
626	message = va_arg (args, char *);
627	va_arg (args, int); // fix yourself
628	extension = va_arg (args, char *);
629	options = va_arg (args, char *);
630	event = va_arg (args, object *);
631	va_end (args);
632		992
633	{	993	cb_global = get_av ("cf::CB_GLOBAL", 1);
634	dSP;	994	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
635		995	cb_object = get_av ("cf::CB_OBJECT", 1);
636	ENTER;	996	cb_player = get_av ("cf::CB_PLAYER", 1);
637	SAVETMPS;	997	cb_client = get_av ("cf::CB_CLIENT", 1);
638		998	cb_type = get_av ("cf::CB_TYPE" , 1);
639	PUSHMARK (SP);	999	cb_map = get_av ("cf::CB_MAP" , 1);
640	EXTEND (SP, 10);
641
642	PUSHcfapi (STRING, extension);
643	PUSHs (sv_2mortal (newSViv (event_code)));
644
645	PUSHcfapi (POBJECT, event);
646	PUSHcfapi (POBJECT, who);
647
648	switch (event_code)
649	{
650	case EVENT_STOP: // $ob (e.g. arrow)
651	case EVENT_TIME: // $ob
652	case EVENT_TIMER: // $ob
653	break;
654
655	case EVENT_APPLY: // $ob, $who
656	case EVENT_DROP: // $ob, $who
657	case EVENT_CLOSE: // $ob, $who
658	case EVENT_DEATH: // $ob[, $killer]
659	case EVENT_MOVE: // $ob, $enemy
660	case EVENT_THROW: // $ob, $thrower
661	PUSHcfapi (POBJECT, activator);
662	break;
663
664	case EVENT_DROP_ON: // $ob, $who, $what
665	case EVENT_ATTACK: // $ob, $who, $victim (?? please god enlighten me)
666	PUSHcfapi (POBJECT, activator);
667	PUSHcfapi (POBJECT, third);
668	break;
669
670	case EVENT_TRIGGER: // $ob, $originator, [$victim], [$msg]
671	PUSHcfapi (POBJECT, activator);
672	PUSHcfapi (POBJECT, third);
673	PUSHcfapi (POBJECT, message);
674	break;
675
676	case EVENT_SAY: // $ob, $who, $msg
677	PUSHcfapi (POBJECT, activator);
678	PUSHcfapi (STRING, message);
679	break;
680
681	default:
682	LOG (llevError, "perl plugin called for unsupported event type %d", event_code);
683	break;
684	}
685
686	PUTBACK;
687	int count = call_pv ("cf::inject_event", G_SCALAR | G_EVAL);
688	SPAGAIN;
689
690	if (SvTRUE (ERRSV))
691	LOG (llevError, "event '%d' callback evaluation error: %s", event_code, SvPV_nolen (ERRSV));
692
693	rv = count > 0 ? POPi : 0;
694
695	PUTBACK;
696	FREETMPS;
697	LEAVE;
698	}
699
700	return &rv;
701	}
702
703	extern "C" int cfperl_closePlugin ()
704	{
705	printf (PLUGIN_VERSION " closing\n");
706
707	if (perl)
708	{
709	perl_destruct (perl);
710	perl_free (perl);
711	perl = 0;
712	}
713
714	return 0;
715	}
716
717	void cfperl_sleep (double delta)
718	{
719	dSP;
720	ENTER;
721	SAVETMPS;
722
723	PUSHMARK (SP);
724	XPUSHs (sv_2mortal (newSVnv (delta)));
725	PUTBACK;
726	call_pv ("cf::sleep_delta", G_DISCARD | G_VOID | G_EVAL);
727	SPAGAIN;
728
729	FREETMPS;
730	LEAVE;
731	}	1000	}
732		1001
733	MODULE = cf PACKAGE = cf PREFIX = cf_	1002	MODULE = cf PACKAGE = cf PREFIX = cf_
734		1003
735	BOOT:	1004	BOOT:
736	{	1005	{
737	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));
738		1012
739	static const struct {	1013	static const struct {
740	const char *name;	1014	const char *name;
741	IV iv;	1015	IV iv;
742	} *civ, const_iv[] = {	1016	} *civ, const_iv[] = {
…		…
744	const_iv (llevError)	1018	const_iv (llevError)
745	const_iv (llevInfo)	1019	const_iv (llevInfo)
746	const_iv (llevDebug)	1020	const_iv (llevDebug)
747	const_iv (llevMonster)	1021	const_iv (llevMonster)
748		1022
		1023	const_iv (MAX_TIME)
749	const_iv (PLAYER)	1024	const_iv (PLAYER)
750	const_iv (TRANSPORT)	1025	const_iv (TRANSPORT)
751	const_iv (ROD)	1026	const_iv (ROD)
752	const_iv (TREASURE)	1027	const_iv (TREASURE)
753	const_iv (POTION)	1028	const_iv (POTION)
754	const_iv (FOOD)	1029	const_iv (FOOD)
755	const_iv (POISON)	1030	const_iv (POISON)
756	const_iv (BOOK)	1031	const_iv (BOOK)
757	const_iv (CLOCK)	1032	const_iv (CLOCK)
758	const_iv (LIGHTNING)
759	const_iv (ARROW)	1033	const_iv (ARROW)
760	const_iv (BOW)	1034	const_iv (BOW)
761	const_iv (WEAPON)	1035	const_iv (WEAPON)
762	const_iv (ARMOUR)	1036	const_iv (ARMOUR)
763	const_iv (PEDESTAL)	1037	const_iv (PEDESTAL)
…		…
783	const_iv (AMULET)	1057	const_iv (AMULET)
784	const_iv (PLAYERMOVER)	1058	const_iv (PLAYERMOVER)
785	const_iv (TELEPORTER)	1059	const_iv (TELEPORTER)
786	const_iv (CREATOR)	1060	const_iv (CREATOR)
787	const_iv (SKILL)	1061	const_iv (SKILL)
788	const_iv (EXPERIENCE)
789	const_iv (EARTHWALL)	1062	const_iv (EARTHWALL)
790	const_iv (GOLEM)	1063	const_iv (GOLEM)
791	const_iv (THROWN_OBJ)	1064	const_iv (THROWN_OBJ)
792	const_iv (BLINDNESS)	1065	const_iv (BLINDNESS)
793	const_iv (GOD)	1066	const_iv (GOD)
…		…
813	const_iv (FLOOR)	1086	const_iv (FLOOR)
814	const_iv (FLESH)	1087	const_iv (FLESH)
815	const_iv (INORGANIC)	1088	const_iv (INORGANIC)
816	const_iv (SKILL_TOOL)	1089	const_iv (SKILL_TOOL)
817	const_iv (LIGHTER)	1090	const_iv (LIGHTER)
818	const_iv (TRAP_PART)
819	const_iv (WALL)	1091	const_iv (BUILDABLE_WALL)
820	const_iv (LIGHT_SOURCE)
821	const_iv (MISC_OBJECT)	1092	const_iv (MISC_OBJECT)
822	const_iv (MONSTER)
823	const_iv (SPAWN_GENERATOR)
824	const_iv (LAMP)	1093	const_iv (LAMP)
825	const_iv (DUPLICATOR)	1094	const_iv (DUPLICATOR)
826	const_iv (TOOL)
827	const_iv (SPELLBOOK)	1095	const_iv (SPELLBOOK)
828	const_iv (BUILDFAC)
829	const_iv (CLOAK)	1096	const_iv (CLOAK)
830	const_iv (SPINNER)	1097	const_iv (SPINNER)
831	const_iv (GATE)	1098	const_iv (GATE)
832	const_iv (BUTTON)	1099	const_iv (BUTTON)
833	const_iv (CF_HANDLE)	1100	const_iv (CF_HANDLE)
…		…
840	const_iv (SPELL_EFFECT)	1107	const_iv (SPELL_EFFECT)
841	const_iv (CONVERTER)	1108	const_iv (CONVERTER)
842	const_iv (BRACERS)	1109	const_iv (BRACERS)
843	const_iv (POISONING)	1110	const_iv (POISONING)
844	const_iv (SAVEBED)	1111	const_iv (SAVEBED)
845	const_iv (POISONCLOUD)
846	const_iv (FIREHOLES)
847	const_iv (WAND)	1112	const_iv (WAND)
848	const_iv (SCROLL)	1113	const_iv (SCROLL)
849	const_iv (DIRECTOR)	1114	const_iv (DIRECTOR)
850	const_iv (GIRDLE)	1115	const_iv (GIRDLE)
851	const_iv (FORCE)	1116	const_iv (FORCE)
…		…
866	const_iv (DISEASE)	1131	const_iv (DISEASE)
867	const_iv (SYMPTOM)	1132	const_iv (SYMPTOM)
868	const_iv (BUILDER)	1133	const_iv (BUILDER)
869	const_iv (MATERIAL)	1134	const_iv (MATERIAL)
870	const_iv (ITEM_TRANSFORMER)	1135	const_iv (ITEM_TRANSFORMER)
		1136
871	const_iv (QUEST)	1137	const_iv (NUM_SUBTYPES)
872		1138
873	const_iv (ST_BD_BUILD)	1139	const_iv (ST_BD_BUILD)
874	const_iv (ST_BD_REMOVE)	1140	const_iv (ST_BD_REMOVE)
875		1141
876	const_iv (ST_MAT_FLOOR)	1142	const_iv (ST_MAT_FLOOR)
…		…
902	const_iv (AT_BLIND)	1168	const_iv (AT_BLIND)
903	const_iv (AT_INTERNAL)	1169	const_iv (AT_INTERNAL)
904	const_iv (AT_LIFE_STEALING)	1170	const_iv (AT_LIFE_STEALING)
905	const_iv (AT_DISEASE)	1171	const_iv (AT_DISEASE)
906		1172
907	const_iv (QUEST_IN_PROGRESS)
908	const_iv (QUEST_DONE_QUEST)
909	const_iv (QUEST_DONE_TASK)
910	const_iv (QUEST_START_QUEST)
911	const_iv (QUEST_END_QUEST)
912	const_iv (QUEST_START_TASK)
913	const_iv (QUEST_END_TASK)
914	const_iv (QUEST_OVERRIDE)
915	const_iv (QUEST_ON_ACTIVATE)
916
917	const_iv (WEAP_HIT)	1173	const_iv (WEAP_HIT)
918	const_iv (WEAP_SLASH)	1174	const_iv (WEAP_SLASH)
919	const_iv (WEAP_PIERCE)	1175	const_iv (WEAP_PIERCE)
920	const_iv (WEAP_CLEAVE)	1176	const_iv (WEAP_CLEAVE)
921	const_iv (WEAP_SLICE)	1177	const_iv (WEAP_SLICE)
…		…
937	const_iv (FLAG_MONSTER)	1193	const_iv (FLAG_MONSTER)
938	const_iv (FLAG_FRIENDLY)	1194	const_iv (FLAG_FRIENDLY)
939	const_iv (FLAG_GENERATOR)	1195	const_iv (FLAG_GENERATOR)
940	const_iv (FLAG_IS_THROWN)	1196	const_iv (FLAG_IS_THROWN)
941	const_iv (FLAG_AUTO_APPLY)	1197	const_iv (FLAG_AUTO_APPLY)
942	const_iv (FLAG_TREASURE)
943	const_iv (FLAG_PLAYER_SOLD)	1198	const_iv (FLAG_PLAYER_SOLD)
944	const_iv (FLAG_SEE_INVISIBLE)	1199	const_iv (FLAG_SEE_INVISIBLE)
945	const_iv (FLAG_CAN_ROLL)	1200	const_iv (FLAG_CAN_ROLL)
946	const_iv (FLAG_OVERLAY_FLOOR)	1201	const_iv (FLAG_OVERLAY_FLOOR)
947	const_iv (FLAG_IS_TURNABLE)	1202	const_iv (FLAG_IS_TURNABLE)
…		…
1022	const_iv (FLAG_ACTIVATE_ON_RELEASE)	1277	const_iv (FLAG_ACTIVATE_ON_RELEASE)
1023	const_iv (FLAG_IS_WATER)	1278	const_iv (FLAG_IS_WATER)
1024	const_iv (FLAG_CONTENT_ON_GEN)	1279	const_iv (FLAG_CONTENT_ON_GEN)
1025	const_iv (FLAG_IS_A_TEMPLATE)	1280	const_iv (FLAG_IS_A_TEMPLATE)
1026	const_iv (FLAG_IS_BUILDABLE)	1281	const_iv (FLAG_IS_BUILDABLE)
		1282	const_iv (FLAG_DESTROY_ON_DEATH)
1027	const_iv (FLAG_AFK)	1283	const_iv (FLAG_NO_MAP_SAVE)
1028		1284
1029	const_iv (NDI_BLACK)	1285	const_iv (NDI_BLACK)
1030	const_iv (NDI_WHITE)	1286	const_iv (NDI_WHITE)
1031	const_iv (NDI_NAVY)	1287	const_iv (NDI_NAVY)
1032	const_iv (NDI_RED)	1288	const_iv (NDI_RED)
…		…
1042	const_iv (NDI_MAX_COLOR)	1298	const_iv (NDI_MAX_COLOR)
1043	const_iv (NDI_COLOR_MASK)	1299	const_iv (NDI_COLOR_MASK)
1044	const_iv (NDI_UNIQUE)	1300	const_iv (NDI_UNIQUE)
1045	const_iv (NDI_ALL)	1301	const_iv (NDI_ALL)
1046		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
1047	const_iv (F_APPLIED)	1316	const_iv (F_APPLIED)
1048	const_iv (F_LOCATION)	1317	const_iv (F_LOCATION)
1049	const_iv (F_UNPAID)	1318	const_iv (F_UNPAID)
1050	const_iv (F_MAGIC)	1319	const_iv (F_MAGIC)
1051	const_iv (F_CURSED)	1320	const_iv (F_CURSED)
…		…
1057	const_iv (F_BUY)	1326	const_iv (F_BUY)
1058	const_iv (F_SHOP)	1327	const_iv (F_SHOP)
1059	const_iv (F_SELL)	1328	const_iv (F_SELL)
1060		1329
1061	const_iv (P_BLOCKSVIEW)	1330	const_iv (P_BLOCKSVIEW)
		1331	const_iv (P_PLAYER)
1062	const_iv (P_NO_MAGIC)	1332	const_iv (P_NO_MAGIC)
1063	const_iv (P_IS_ALIVE)	1333	const_iv (P_IS_ALIVE)
1064	const_iv (P_NO_CLERIC)	1334	const_iv (P_NO_CLERIC)
1065	const_iv (P_NEED_UPDATE)
1066	const_iv (P_NO_ERROR)
1067	const_iv (P_OUT_OF_MAP)	1335	const_iv (P_OUT_OF_MAP)
1068	const_iv (P_NEW_MAP)	1336	const_iv (P_NEW_MAP)
		1337	const_iv (P_UPTODATE)
1069		1338
1070	const_iv (UP_OBJ_INSERT)	1339	const_iv (UP_OBJ_INSERT)
1071	const_iv (UP_OBJ_REMOVE)	1340	const_iv (UP_OBJ_REMOVE)
1072	const_iv (UP_OBJ_CHANGE)	1341	const_iv (UP_OBJ_CHANGE)
1073	const_iv (UP_OBJ_FACE)	1342	const_iv (UP_OBJ_FACE)
…		…
1105		1374
1106	const_iv (SK_EXP_ADD_SKILL)	1375	const_iv (SK_EXP_ADD_SKILL)
1107	const_iv (SK_EXP_TOTAL)	1376	const_iv (SK_EXP_TOTAL)
1108	const_iv (SK_EXP_NONE)	1377	const_iv (SK_EXP_NONE)
1109	const_iv (SK_SUBTRACT_SKILL_EXP)	1378	const_iv (SK_SUBTRACT_SKILL_EXP)
		1379	const_iv (SK_EXP_SKILL_ONLY)
1110		1380
1111	const_iv (SK_LOCKPICKING)	1381	const_iv (SK_LOCKPICKING)
1112	const_iv (SK_HIDING)	1382	const_iv (SK_HIDING)
1113	const_iv (SK_SMITHERY)	1383	const_iv (SK_SMITHERY)
1114	const_iv (SK_BOWYER)	1384	const_iv (SK_BOWYER)
…		…
1203	const_iv (ATNR_BLIND)	1473	const_iv (ATNR_BLIND)
1204	const_iv (ATNR_INTERNAL)	1474	const_iv (ATNR_INTERNAL)
1205	const_iv (ATNR_LIFE_STEALING)	1475	const_iv (ATNR_LIFE_STEALING)
1206	const_iv (ATNR_DISEASE)	1476	const_iv (ATNR_DISEASE)
1207		1477
1208	const_iv (MAP_FLUSH)
1209	const_iv (MAP_PLAYER_UNIQUE)
1210	const_iv (MAP_BLOCK)
1211	const_iv (MAP_STYLE)
1212	const_iv (MAP_OVERLAY)
1213
1214	const_iv (MAP_IN_MEMORY)	1478	const_iv (MAP_IN_MEMORY)
1215	const_iv (MAP_SWAPPED)	1479	const_iv (MAP_SWAPPED)
1216	const_iv (MAP_LOADING)	1480	const_iv (MAP_LOADING)
1217	const_iv (MAP_SAVING)	1481	const_iv (MAP_SAVING)
		1482
		1483	const_iv (KLASS_ATTACHABLE)
		1484	const_iv (KLASS_GLOBAL)
		1485	const_iv (KLASS_OBJECT)
		1486	const_iv (KLASS_CLIENT)
		1487	const_iv (KLASS_PLAYER)
		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)
1218	};	1529	};
1219		1530
1220	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; )
1221	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));	1532	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1222		1533
1223	static const struct {	1534	static const struct {
1224	const char *name;	1535	const char *name;
		1536	int skip;
		1537	IV klass;
1225	IV iv;	1538	IV iv;
1226	} *event, event_list[] = {	1539	} *eiv, event_iv[] = {
1227	# define const_event(name) { # name, (IV)EVENT_ ## name },	1540	# define def(klass,name) { "EVENT_" # klass "_" # name, sizeof ("EVENT_" # klass), (IV)KLASS_ ## klass, (IV)EVENT_ ## klass ## _ ## name },
1228	const_event (NONE)	1541	# include "eventinc.h"
1229	const_event (APPLY)	1542	# undef def
1230	const_event (ATTACK)
1231	const_event (DEATH)
1232	const_event (DROP)
1233	const_event (DROP_ON)
1234	const_event (PICKUP)
1235	const_event (SAY)
1236	const_event (STOP)
1237	const_event (TIME)
1238	const_event (THROW)
1239	const_event (TRIGGER)
1240	const_event (CLOSE)
1241	const_event (TIMER)
1242	const_event (MOVE)
1243
1244	const_event (BORN)
1245	//const_event (CLOCK)
1246	const_event (CRASH)
1247	const_event (PLAYER_DEATH)
1248	const_event (PLAYER_LOAD)
1249	const_event (PLAYER_SAVE)
1250	const_event (GKILL)
1251	const_event (LOGIN)
1252	const_event (LOGOUT)
1253	const_event (MAPENTER)
1254	const_event (MAPLEAVE)
1255	const_event (MAPRESET)
1256	const_event (MAPLOAD)
1257	const_event (MAPOUT)
1258	const_event (MAPIN)
1259	const_event (MAPCLEAN)
1260	const_event (REMOVE)
1261	const_event (SHOUT)
1262	const_event (TELL)
1263	const_event (MUZZLE)
1264	const_event (KICK)
1265	const_event (PLAYER_USE_SKILL)
1266	const_event (MONSTER_USE_SKILL)
1267	const_event (CAST_SPELL)
1268	const_event (FIND_UNARMED_SKILL)
1269	const_event (EXTCMD)
1270	//const_event (FREE_OB)
1271	};	1543	};
1272		1544
1273	AV *av = get_av ("cf::EVENT", 1);	1545	AV *av = get_av ("cf::EVENT", 1);
1274		1546
1275	for (event = event_list + sizeof (event_list) / sizeof (event_list [0]); event-- > event_list; )	1547	for (eiv = event_iv + sizeof (event_iv) / sizeof (event_iv [0]); eiv-- > event_iv; )
1276	av_store (av, event->iv, newSVpv ((char *)event->name, 0));
1277
1278	static const struct {
1279	int dtype;
1280	const char *name;
1281	IV idx;
1282	} *cprop, prop_table[] = {
1283	# define prop(type, name) { type, # name, (IV) CFAPI_ ## name },
1284	prop (CFAPI_INT, MAP_PROP_FLAGS)
1285	prop (CFAPI_INT, MAP_PROP_DIFFICULTY)
1286	prop (CFAPI_STRING, MAP_PROP_PATH)
1287	prop (CFAPI_STRING, MAP_PROP_TMPNAME)
1288	prop (CFAPI_STRING, MAP_PROP_NAME)
1289	prop (CFAPI_INT, MAP_PROP_RESET_TIME)
1290	prop (CFAPI_INT, MAP_PROP_RESET_TIMEOUT)
1291	prop (CFAPI_INT, MAP_PROP_PLAYERS)
1292	prop (CFAPI_INT, MAP_PROP_DARKNESS)
1293	prop (CFAPI_INT, MAP_PROP_WIDTH)
1294	prop (CFAPI_INT, MAP_PROP_HEIGHT)
1295	prop (CFAPI_INT, MAP_PROP_ENTER_X)
1296	prop (CFAPI_INT, MAP_PROP_ENTER_Y)
1297	prop (CFAPI_INT, MAP_PROP_TEMPERATURE)
1298	prop (CFAPI_INT, MAP_PROP_PRESSURE)
1299	prop (CFAPI_INT, MAP_PROP_HUMIDITY)
1300	prop (CFAPI_INT, MAP_PROP_WINDSPEED)
1301	prop (CFAPI_INT, MAP_PROP_WINDDIR)
1302	prop (CFAPI_INT, MAP_PROP_SKY)
1303	prop (CFAPI_INT, MAP_PROP_WPARTX)
1304	prop (CFAPI_INT, MAP_PROP_WPARTY)
1305	prop (CFAPI_STRING, MAP_PROP_MESSAGE)
1306	prop (CFAPI_PMAP, MAP_PROP_NEXT)
1307	prop (CFAPI_PREGION, MAP_PROP_REGION)
1308	prop (CFAPI_POBJECT, OBJECT_PROP_OB_ABOVE)
1309	prop (CFAPI_POBJECT, OBJECT_PROP_OB_BELOW)
1310	prop (CFAPI_POBJECT, OBJECT_PROP_NEXT_ACTIVE_OB)
1311	prop (CFAPI_POBJECT, OBJECT_PROP_PREV_ACTIVE_OB)
1312	prop (CFAPI_POBJECT, OBJECT_PROP_INVENTORY)
1313	prop (CFAPI_POBJECT, OBJECT_PROP_ENVIRONMENT)
1314	prop (CFAPI_POBJECT, OBJECT_PROP_HEAD)
1315	prop (CFAPI_POBJECT, OBJECT_PROP_CONTAINER)
1316	prop (CFAPI_PMAP, OBJECT_PROP_MAP)
1317	prop (CFAPI_INT, OBJECT_PROP_COUNT)
1318	prop (CFAPI_INT, OBJECT_PROP_REFCOUNT)
1319	prop (CFAPI_STRING, OBJECT_PROP_NAME)
1320	prop (CFAPI_STRING, OBJECT_PROP_NAME_PLURAL)
1321	prop (CFAPI_STRING, OBJECT_PROP_TITLE)
1322	prop (CFAPI_STRING, OBJECT_PROP_RACE)
1323	prop (CFAPI_STRING, OBJECT_PROP_SLAYING)
1324	prop (CFAPI_STRING, OBJECT_PROP_SKILL)
1325	prop (CFAPI_STRING, OBJECT_PROP_MESSAGE)
1326	prop (CFAPI_STRING, OBJECT_PROP_LORE)
1327	prop (CFAPI_INT, OBJECT_PROP_X)
1328	prop (CFAPI_INT, OBJECT_PROP_Y)
1329	prop (CFAPI_DOUBLE, OBJECT_PROP_SPEED)
1330	prop (CFAPI_DOUBLE, OBJECT_PROP_SPEED_LEFT)
1331	prop (CFAPI_INT, OBJECT_PROP_NROF)
1332	prop (CFAPI_INT, OBJECT_PROP_DIRECTION)
1333	prop (CFAPI_INT, OBJECT_PROP_FACING)
1334	prop (CFAPI_INT, OBJECT_PROP_TYPE)
1335	prop (CFAPI_INT, OBJECT_PROP_SUBTYPE)
1336	prop (CFAPI_INT, OBJECT_PROP_CLIENT_TYPE)
1337	prop (CFAPI_INT, OBJECT_PROP_ATTACK_TYPE)
1338	prop (CFAPI_INT, OBJECT_PROP_PATH_ATTUNED)
1339	prop (CFAPI_INT, OBJECT_PROP_PATH_REPELLED)
1340	prop (CFAPI_INT, OBJECT_PROP_PATH_DENIED)
1341	prop (CFAPI_INT, OBJECT_PROP_MATERIAL)
1342	prop (CFAPI_STRING, OBJECT_PROP_MATERIAL_NAME)
1343	prop (CFAPI_INT, OBJECT_PROP_MAGIC)
1344	prop (CFAPI_INT, OBJECT_PROP_VALUE)
1345	prop (CFAPI_INT, OBJECT_PROP_LEVEL)
1346	prop (CFAPI_INT, OBJECT_PROP_LAST_HEAL)
1347	prop (CFAPI_INT, OBJECT_PROP_LAST_SP)
1348	prop (CFAPI_INT, OBJECT_PROP_LAST_GRACE)
1349	prop (CFAPI_INT, OBJECT_PROP_LAST_EAT)
1350	prop (CFAPI_INT, OBJECT_PROP_INVISIBLE_TIME)
1351	prop (CFAPI_INT, OBJECT_PROP_PICK_UP)
1352	prop (CFAPI_INT, OBJECT_PROP_ITEM_POWER)
1353	prop (CFAPI_INT, OBJECT_PROP_GEN_SP_ARMOUR)
1354	prop (CFAPI_INT, OBJECT_PROP_WEIGHT)
1355	prop (CFAPI_INT, OBJECT_PROP_WEIGHT_LIMIT)
1356	prop (CFAPI_INT, OBJECT_PROP_CARRYING)
1357	prop (CFAPI_INT, OBJECT_PROP_GLOW_RADIUS)
1358	prop (CFAPI_LONG, OBJECT_PROP_PERM_EXP)
1359	prop (CFAPI_POBJECT, OBJECT_PROP_CURRENT_WEAPON)
1360	prop (CFAPI_POBJECT, OBJECT_PROP_ENEMY)
1361	prop (CFAPI_POBJECT, OBJECT_PROP_ATTACKED_BY)
1362	prop (CFAPI_INT, OBJECT_PROP_RUN_AWAY)
1363	prop (CFAPI_POBJECT, OBJECT_PROP_CHOSEN_SKILL)
1364	prop (CFAPI_INT, OBJECT_PROP_HIDDEN)
1365	prop (CFAPI_INT, OBJECT_PROP_MOVE_STATUS)
1366	prop (CFAPI_INT, OBJECT_PROP_MOVE_TYPE)
1367	prop (CFAPI_POBJECT, OBJECT_PROP_SPELL_ITEM)
1368	prop (CFAPI_DOUBLE, OBJECT_PROP_EXP_MULTIPLIER)
1369	prop (CFAPI_PARCH, OBJECT_PROP_ARCHETYPE)
1370	prop (CFAPI_PARCH, OBJECT_PROP_OTHER_ARCH)
1371	prop (CFAPI_STRING, OBJECT_PROP_CUSTOM_NAME)
1372	prop (CFAPI_INT, OBJECT_PROP_ANIM_SPEED)
1373	prop (CFAPI_INT, OBJECT_PROP_FRIENDLY)
1374	prop (CFAPI_STRING, OBJECT_PROP_SHORT_NAME)
1375	prop (CFAPI_INT, OBJECT_PROP_MAGICAL)
1376	prop (CFAPI_INT, OBJECT_PROP_LUCK)
1377	prop (CFAPI_POBJECT, OBJECT_PROP_OWNER)
1378	prop (CFAPI_POBJECT, OBJECT_PROP_PRESENT)
1379	prop (CFAPI_INT, OBJECT_PROP_CHEATER)
1380	prop (CFAPI_INT, OBJECT_PROP_MERGEABLE)
1381	prop (CFAPI_INT, OBJECT_PROP_PICKABLE)
1382	prop (CFAPI_INT, OBJECT_PROP_STR)
1383	prop (CFAPI_INT, OBJECT_PROP_DEX)
1384	prop (CFAPI_INT, OBJECT_PROP_CON)
1385	prop (CFAPI_INT, OBJECT_PROP_WIS)
1386	prop (CFAPI_INT, OBJECT_PROP_INT)
1387	prop (CFAPI_INT, OBJECT_PROP_POW)
1388	prop (CFAPI_INT, OBJECT_PROP_CHA)
1389	prop (CFAPI_INT, OBJECT_PROP_WC)
1390	prop (CFAPI_INT, OBJECT_PROP_AC)
1391	prop (CFAPI_INT, OBJECT_PROP_HP)
1392	prop (CFAPI_INT, OBJECT_PROP_SP)
1393	prop (CFAPI_INT, OBJECT_PROP_GP)
1394	prop (CFAPI_INT, OBJECT_PROP_FP)
1395	prop (CFAPI_INT, OBJECT_PROP_MAXHP)
1396	prop (CFAPI_INT, OBJECT_PROP_MAXSP)
1397	prop (CFAPI_INT, OBJECT_PROP_MAXGP)
1398	prop (CFAPI_INT, OBJECT_PROP_DAM)
1399	prop (CFAPI_STRING, OBJECT_PROP_GOD)
1400	prop (CFAPI_STRING, OBJECT_PROP_ARCH_NAME)
1401	prop (CFAPI_INT, OBJECT_PROP_INVISIBLE)
1402	prop (CFAPI_INT, OBJECT_PROP_FACE)
1403	};
1404
1405	HV *prop_type = get_hv ("cf::PROP_TYPE", 1);
1406	HV *prop_idx = get_hv ("cf::PROP_IDX", 1);
1407
1408	for (cprop = prop_table + sizeof (prop_table) / sizeof (prop_table [0]); cprop-- > prop_table; )
1409	{	1548	{
1410	hv_store (prop_type, cprop->name, strlen (cprop->name), newSViv (cprop->dtype), 0);	1549	AV *event = newAV ();
1411	hv_store (prop_idx, cprop->name, strlen (cprop->name), newSViv (cprop->idx ), 0);	1550	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));
		1551	av_push (event, newSViv (eiv->klass));
		1552	av_store (av, eiv->iv, newRV_noinc ((SV *)event));
		1553	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));
1412	}	1554	}
		1555	}
1413		1556
1414	//I_EVENT_API (PACKAGE);	1557	void _connect_to_perl ()
		1558
		1559	void _global_reattach ()
		1560	CODE:
		1561	{
		1562	// reattach to all attachable objects in the game.
		1563	for_all_clients (ns)
		1564	ns->reattach ();
		1565
		1566	for_all_players (pl)
		1567	pl->reattach ();
		1568
		1569	//TODO
		1570	//for (map_container::iterator i = maps.begin (); i != maps.end (); ++i)
		1571	// i->second->reattach ();
		1572
		1573	for_all_objects (op)
		1574	op->reattach ();
1415	}	1575	}
1416		1576
1417	NV floor (NV x)	1577	NV floor (NV x)
1418		1578
1419	NV ceil (NV x)	1579	NV ceil (NV x)
		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
		1593	void server_tick ()
		1594	CODE:
		1595	runtime = SvNVx (sv_runtime);
		1596	server_tick ();
1420		1597
1421	void	1598	void
1422	LOG (int level, char *msg)	1599	LOG (int level, char *msg)
1423	PROTOTYPE: $$	1600	PROTOTYPE: $$
1424	C_ARGS: (LogLevel)level, "%s", msg	1601	C_ARGS: (LogLevel)level, "%s", msg
…		…
1427	PROTOTYPE: $$	1604	PROTOTYPE: $$
1428		1605
1429	char *path_combine_and_normalize (char *base, char *path)	1606	char *path_combine_and_normalize (char *base, char *path)
1430	PROTOTYPE: $$	1607	PROTOTYPE: $$
1431		1608
1432	char *	1609	const char *
1433	cf_get_maps_directory (char *path)	1610	get_maps_directory (char *path)
1434	PROTOTYPE: $	1611	PROTOTYPE: $
1435	ALIAS: maps_directory = 0	1612	ALIAS: maps_directory = 0
		1613	CODE:
		1614	RETVAL = create_pathname (path);
		1615	OUTPUT: RETVAL
1436		1616
1437	void	1617	void
1438	sub_generation_inc ()	1618	sub_generation_inc ()
1439	CODE:	1619	CODE:
1440	PL_sub_generation++;	1620	PL_sub_generation++;
…		…
1449	confdir = 3	1629	confdir = 3
1450	localdir = 4	1630	localdir = 4
1451	playerdir = 5	1631	playerdir = 5
1452	datadir = 6	1632	datadir = 6
1453	CODE:	1633	CODE:
1454	{	1634	switch (ix)
1455	int unused_type;	1635	{
1456	RETVAL = (char *)systemDirectory (&unused_type, ix);	1636	case 0: RETVAL = settings.mapdir ; break;
1457	}	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	}
1458	OUTPUT: RETVAL	1644	OUTPUT: RETVAL
1459		1645
1460	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
1461	cf_find_animation (char *text)	1670	int find_animation (char *text)
1462	PROTOTYPE: $	1671	PROTOTYPE: $
1463		1672
1464	int random_roll(int min, int max, object *op, int goodbad);	1673	int random_roll (int min, int max, object *op, int goodbad);
1465		1674
1466	const char *cost_string_from_value(uint64 cost, int approx = 0)	1675	const char *cost_string_from_value(uint64 cost, int approx = 0)
1467		1676
1468	int	1677	int
1469	exp_to_level (val64 exp)	1678	exp_to_level (val64 exp)
…		…
1502	RETVAL = newSVpv (resist_plus[atnr], 0);	1711	RETVAL = newSVpv (resist_plus[atnr], 0);
1503	else	1712	else
1504	XSRETURN_UNDEF;	1713	XSRETURN_UNDEF;
1505	OUTPUT: RETVAL	1714	OUTPUT: RETVAL
1506		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
1507	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_	1747	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
1508		1748
1509	SV *	1749	INCLUDE: $PERL genacc object ../include/object.h |
1510	get_property (object *obj, int type, int idx)	1750
		1751	int invoke (object *op, int event, ...)
1511	CODE:	1752	CODE:
1512	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);
1513	OUTPUT: RETVAL	1757	OUTPUT: RETVAL
1514		1758
1515	SV *	1759	SV *registry (object *op)
1516	set_property (object *obj, int type, int idx, SV *newval)	1760
		1761	int objects_size ()
1517	CODE:	1762	CODE:
1518	switch (type)	1763	RETVAL = objects.size ();
1519	{	1764	OUTPUT: RETVAL
1520	case CFAPI_INT:	1765
1521	cf_object_set_int_property (obj, idx, SvIV (newval));	1766	object *objects (U32 index)
1522	break;	1767	CODE:
1523	case CFAPI_LONG:	1768	RETVAL = index < objects.size () ? objects [index] : 0;
1524	cf_object_set_long_property (obj, idx, (long) SvVAL64 (newval));	1769	OUTPUT: RETVAL
1525	break;	1770
1526	case CFAPI_DOUBLE:	1771	int actives_size ()
1527	{	1772	CODE:
1528	int unused_type;	1773	RETVAL = actives.size ();
1529	object_set_property (&unused_type, obj, idx, (double)SvNV (newval));	1774	OUTPUT: RETVAL
1530	}	1775
1531	break;	1776	object *actives (U32 index)
1532	case CFAPI_STRING:	1777	CODE:
1533	cf_object_set_string_property (obj, idx, SvOK (newval) ? SvPV_nolen (newval) : 0);	1778	RETVAL = index < actives.size () ? actives [index] : 0;
1534	break;	1779	OUTPUT: RETVAL
1535	case CFAPI_POBJECT:
1536	{
1537	int unused_type;
1538	object_set_property (&unused_type, obj, idx, (object *)SvPTR_ornull (newval, "cf::object"));
1539	}
1540	break;
1541	default:
1542	croak ("unhandled type '%d' in set_property '%d'", type, idx);
1543	}
1544		1780
1545	# missing properties	1781	# missing properties
1546		1782
1547	void	1783	object *head (object *op)
1548	set_attacktype (object *obj, U32 attacktype)	1784	PROTOTYPE: $
1549	CODE:	1785	CODE:
1550	obj->attacktype = attacktype;	1786	RETVAL = op->head_ ();
1551
1552	U32
1553	get_attacktype (object *obj)
1554	ALIAS:
1555	attacktype = 0
1556	CODE:
1557	RETVAL = obj->attacktype;
1558	OUTPUT: RETVAL	1787	OUTPUT: RETVAL
1559		1788
1560	# missing in plug-in api, of course	1789	int is_head (object *op)
1561	void	1790	PROTOTYPE: $
1562	set_food (object *obj, int food)	1791	CODE:
1563	CODE:	1792	RETVAL = op->head_ () == op;
1564	obj->stats.food = food;
1565
1566	int
1567	get_food (object *obj)
1568	ALIAS:
1569	food = 0
1570	CODE:
1571	RETVAL = obj->stats.food;
1572	OUTPUT: RETVAL	1793	OUTPUT: RETVAL
1573		1794
1574	void	1795	void
1575	inv (object *obj)	1796	inv (object *obj)
1576	PROTOTYPE: $	1797	PROTOTYPE: $
1577	PPCODE:	1798	PPCODE:
1578	{	1799	{
1579	object *o;	1800	object *o;
1580	for (o = obj->inv; o; o = o->below)	1801	for (o = obj->inv; o; o = o->below)
1581	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));	1802	XPUSHs (sv_2mortal (to_sv (o)));
1582	}	1803	}
1583		1804
1584	int cf_object_get_resistance (object *op, int rtype)	1805	void
1585	ALIAS: resistance = 0	1806	set_animation (object *op, int idx)
		1807	CODE:
		1808	SET_ANIMATION (op, idx);
1586		1809
1587	int cf_object_get_flag (object *op, int flag)	1810	int
1588	ALIAS: flag = 0	1811	num_animations (object *op)
		1812	CODE:
		1813	RETVAL = NUM_ANIMATIONS (op);
		1814	OUTPUT: RETVAL
1589		1815
1590	void cf_object_set_flag (object *op, int flag, int value)	1816	object *find_best_object_match (object *op, const char *match)
1591		1817
		1818	object *find_marked_object (object *op)
		1819
1592	int need_identify (const object *obj);	1820	int need_identify (object *obj);
1593		1821
1594	int apply_shop_mat (object *shop_mat, object *op);	1822	int apply_shop_mat (object *shop_mat, object *op);
1595		1823
1596	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
1597		1829
1598	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);
1599		1833
1600	void cf_object_apply_below (object *op)	1834	void apply_below (object *op)
1601		1835	CODE:
1602	void cf_object_remove (object *op)	1836	player_apply_below (op);
1603
1604	void cf_object_free (object *op)
1605		1837
1606	object *cf_object_present_archname_inside (object *op, char *whatstr)	1838	object *cf_object_present_archname_inside (object *op, char *whatstr)
1607		1839
1608	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)
1609		1841
1610	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)
1611		1843
		1844	#//TODO
1612	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
1613		1855
1614	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
1615		1860
1616	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
1617		1865
1618	void pay_player (object *op, uint64 amount)	1866	void pay_player (object *op, uint64 amount)
1619		1867
1620	val64 pay_player_arch (object *op, const char *arch, uint64 amount)	1868	val64 pay_player_arch (object *op, const char *arch, uint64 amount)
1621		1869
1622	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)
1623		1871
1624	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);
1625		1875
1626	void cf_object_learn_spell (object *op, object *sp)
1627
1628	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));
1629		1879
1630	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
1631		1884
1632	int cf_object_query_money (object *op)	1885	int query_money (object *op)
1633	ALIAS: money = 0	1886	ALIAS: money = 0
1634		1887
1635	int cf_object_query_cost (object *op, object *who, int flags)	1888	val64 query_cost (object *op, object *who, int flags)
1636	ALIAS: cost = 0	1889	ALIAS: cost = 0
1637		1890
1638	void cf_object_activate_rune (object *op , object *victim)	1891	void spring_trap (object *op, object *victim)
1639		1892
1640	int cf_object_check_trigger (object *op, object *cause)	1893	int check_trigger (object *op, object *cause)
1641		1894
1642	int cf_object_out_of_map (object *op, int x, int y)
1643
1644	void cf_object_drop (object *op, object *author)	1895	void drop (object *who, object *op)
1645		1896
1646	void cf_object_take (object *op, object *author)	1897	void pick_up (object *who, object *op)
1647		1898
1648	void cf_object_say (object *op, char *msg)
1649
1650	void cf_object_speak (object *op, char *msg)
1651
1652	object *cf_object_insert_object (object *op, object *container)
1653
1654	const char *cf_object_get_msg (object *ob)
1655	ALIAS: msg = 0
1656
1657	object *cf_object_insert_in_ob (object *ob, object *where)
1658
1659	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)
1660		1900
1661	void cf_object_update (object *op, int flags)	1901	void update_object (object *op, int action)
1662
1663	void cf_object_pickup (object *op, object *what)
1664		1902
1665	object *cf_create_object_by_name (const char *name)	1903	object *cf_create_object_by_name (const char *name)
1666		1904
1667	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)
1668		1906
…		…
1674		1912
1675	void push_button (object *op);	1913	void push_button (object *op);
1676		1914
1677	void use_trigger (object *op);	1915	void use_trigger (object *op);
1678		1916
1679	void add_button_link (object *button, mapstruct *map, int connected);	1917	void add_button_link (object *button, maptile *map, int connected);
1680		1918
1681	void remove_button_link (object *op);	1919	void remove_button_link (object *op);
1682		1920
1683	void
1684	cf_object_set_resistance (object *op, int rtype, int val)
1685	CODE:
1686	if (rtype >= 0 && rtype < NROFATTACKS)
1687	op->resist[rtype] = val;
1688
1689		1921
1690	MODULE = cf PACKAGE = cf::object PREFIX = cf_	1922	MODULE = cf PACKAGE = cf::object PREFIX = cf_
1691
1692	void cf_fix_object (object *pl)
1693	ALIAS: fix = 0
1694		1923
1695	object *cf_insert_ob_in_ob (object *ob, object *where)	1924	object *cf_insert_ob_in_ob (object *ob, object *where)
1696		1925
1697	# 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
1698	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.	1927	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.
…		…
1702	CODE:	1931	CODE:
1703	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();	1932	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();
1704	OUTPUT:	1933	OUTPUT:
1705	RETVAL	1934	RETVAL
1706		1935
1707	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)
1708	PROTOTYPE: $$$$$$	1937	PROTOTYPE: $$$$$$
1709	CODE:	1938	CODE:
1710	{	1939	{
1711	int unused_type;	1940	int unused_type;
1712	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);
…		…
1750	bool on_same_map_as (object *ob, object *other)	1979	bool on_same_map_as (object *ob, object *other)
1751	CODE:	1980	CODE:
1752	RETVAL = on_same_map (ob, other);	1981	RETVAL = on_same_map (ob, other);
1753	OUTPUT: RETVAL	1982	OUTPUT: RETVAL
1754		1983
1755	char *	1984	const char *
1756	base_name (object *ob, int plural)	1985	base_name (object *op, int plural = op->nrof > 1)
1757	CODE:	1986	CODE:
1758	RETVAL = cf_query_base_name (ob, plural);	1987	RETVAL = query_base_name (op, plural);
1759	OUTPUT: RETVAL	1988	OUTPUT: RETVAL
1760		1989
1761	living *	1990	object *decrease_ob_nr (object *op, unsigned long i)
1762	stats (object *ob)
1763	CODE:
1764	RETVAL = &ob->stats;
1765	OUTPUT: RETVAL
1766
1767		1991
1768	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_	1992	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_
1769		1993
1770	player *player (object *op)	1994	player *player (object *op)
1771	CODE:	1995	CODE:
1772	RETVAL = op->contr;	1996	RETVAL = op->contr;
1773	OUTPUT: RETVAL	1997	OUTPUT: RETVAL
1774		1998
		1999	void check_score (object *op)
		2000
1775	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);
1776		2004
1777	object *cf_player_send_inventory (object *op)	2005	object *cf_player_send_inventory (object *op)
1778		2006
1779	char *cf_player_get_ip (object *op)	2007	char *cf_player_get_ip (object *op)
1780	ALIAS: ip = 0	2008	ALIAS: ip = 0
…		…
1789		2017
1790	void cf_player_set_party (object *op, partylist *party)	2018	void cf_player_set_party (object *op, partylist *party)
1791		2019
1792	void kill_player (object *op)	2020	void kill_player (object *op)
1793		2021
1794	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
1795		2035
1796	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_	2036	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
1797		2037
1798	player *cf_player_find (char *name)	2038	INCLUDE: $PERL genacc player ../include/player.h |
1799	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;
1800		2057
1801	void cf_player_move (player *pl, int dir)	2058	void cf_player_move (player *pl, int dir)
1802		2059
1803	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);
1804
1805	# nonstandard
1806	object *ob (player *pl)
1807	CODE:
1808	RETVAL = pl->ob;
1809	OUTPUT: RETVAL
1810		2061
1811	player *first ()	2062	player *first ()
1812	CODE:	2063	CODE:
1813	RETVAL = first_player;	2064	RETVAL = first_player;
1814	OUTPUT: RETVAL	2065	OUTPUT: RETVAL
1815		2066
1816	player *next (player *pl)
1817	CODE:
1818	RETVAL = pl->next;
1819	OUTPUT: RETVAL
1820
1821	bool	2067	bool
1822	cell_visible (player *pl, int dx, int dy)	2068	cell_visible (player *pl, int dx, int dy)
1823	CODE:	2069	CODE:
1824	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
1825	&& !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];
1826	OUTPUT:	2072	OUTPUT:
1827	RETVAL	2073	RETVAL
1828		2074
1829	void	2075	void
1830	send (player *pl, SV *packet)	2076	send (player *pl, SV *packet)
1831	CODE:	2077	CODE:
1832	{	2078	{
1833	STRLEN len;	2079	STRLEN len;
1834	char *buf = SvPVbyte (packet, len);	2080	char *buf = SvPVbyte (packet, len);
1835		2081
1836	Write_String_To_Socket (&pl->socket, buf, len);	2082	if (pl->ns)
		2083	pl->ns->send_packet (buf, len);
1837	}	2084	}
1838		2085
1839	int	2086	int
1840	listening (player *pl, int new_value = -1)	2087	listening (player *pl, int new_value = -1)
1841	CODE:	2088	CODE:
…		…
1843	if (new_value >= 0)	2090	if (new_value >= 0)
1844	pl->listening = new_value;	2091	pl->listening = new_value;
1845	OUTPUT:	2092	OUTPUT:
1846	RETVAL	2093	RETVAL
1847		2094
1848	void get_savebed (player *pl)	2095	void savebed (player *pl, SV *map_path = 0, SV *x = 0, SV *y = 0)
1849	ALIAS:	2096	PROTOTYPE: $;$$$
1850	savebed = 0
1851	PPCODE:	2097	PPCODE:
		2098	if (GIMME_V != G_VOID)
		2099	{
1852	EXTEND (SP, 3);	2100	EXTEND (SP, 3);
1853	PUSHs (sv_2mortal (newSVpv (pl->savebed_map, 0)));	2101	PUSHs (sv_2mortal (newSVpv (pl->savebed_map, 0)));
1854	PUSHs (sv_2mortal (newSViv (pl->bed_x)));	2102	PUSHs (sv_2mortal (newSViv (pl->bed_x)));
1855	PUSHs (sv_2mortal (newSViv (pl->bed_y)));	2103	PUSHs (sv_2mortal (newSViv (pl->bed_y)));
1856		2104	}
1857	void set_savebed (player *pl, char *map_path, int x, int y)	2105	if (map_path) sv_to (map_path, pl->savebed_map);
1858	CODE:	2106	if (x) sv_to (x, pl->bed_x);
1859	strcpy (pl->savebed_map, map_path);	2107	if (y) sv_to (y, pl->bed_y);
1860	pl->bed_x = x;
1861	pl->bed_y = y;
1862		2108
1863	void	2109	void
1864	list ()	2110	list ()
1865	PPCODE:	2111	PPCODE:
1866	{	2112	for_all_players (pl)
1867	player *pl;	2113	XPUSHs (sv_2mortal (to_sv (pl)));
1868	for (pl = first_player; pl; pl = pl->next)
1869	XPUSHs (newSVcfapi (CFAPI_PPLAYER, pl));
1870	}
1871
1872	bool
1873	peaceful (player *pl, bool new_setting = 0)
1874	PROTOTYPE: $;$
1875	CODE:
1876	RETVAL = pl->peaceful;
1877	if (items > 1)
1878	pl->peaceful = new_setting;
1879	OUTPUT:
1880	RETVAL
1881
1882	living *
1883	orig_stats (player *pl)
1884	CODE:
1885	RETVAL = &pl->orig_stats;
1886	OUTPUT: RETVAL
1887
1888	living *
1889	last_stats (player *pl)
1890	CODE:
1891	RETVAL = &pl->last_stats;
1892	OUTPUT: RETVAL
1893		2114
1894		2115
1895	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_	2116	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_
1896		2117
1897	SV *	2118	int invoke (maptile *map, int event, ...)
1898	get_property (mapstruct *obj, int type, int idx)
1899	CODE:	2119	CODE:
1900	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);
1901	OUTPUT: RETVAL	2124	OUTPUT: RETVAL
1902		2125
1903	SV *	2126	SV *registry (maptile *map)
1904	set_property (mapstruct *obj, int type, int idx, SV *newval)
1905	CODE:
1906	switch (type)
1907	{
1908	case CFAPI_INT:
1909	cf_map_set_int_property (obj, idx, SvIV (newval));
1910	break;
1911	default:
1912	croak ("unhandled type '%d' in set_property '%d'", type, idx);
1913	}
1914		2127
1915	mapstruct *new (int width, int height)	2128	INCLUDE: $PERL genacc maptile ../include/map.h |
		2129
		2130	void
		2131	maptile::instantiate ()
		2132
		2133	maptile *new ()
1916	PROTOTYPE:	2134	PROTOTYPE:
1917	CODE:	2135	CODE:
1918	{	2136	RETVAL = new maptile;
1919	int unused_type;
1920	RETVAL = (mapstruct*) map_get_map (&unused_type, 0, width, height);
1921	}
1922	OUTPUT:	2137	OUTPUT:
1923	RETVAL	2138	RETVAL
1924		2139
1925	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	}
1926		2152
1927	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");
1928		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
1929	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)
1930		2172
1931	mapstruct *tile_map (mapstruct *map, unsigned int dir)	2173	int out_of_map (maptile *map, int x, int y)
1932	CODE:
1933	RETVAL = dir < 4 ? map->tile_map [dir] : 0;
1934	OUTPUT:
1935	RETVAL
1936		2174
1937	char *tile_path (mapstruct *map, unsigned int dir)	2175	void
1938	CODE:	2176	trigger (maptile *map, long connection, bool state = true)
1939	if (dir >= 4)	2177	CODE:
1940	XSRETURN_UNDEF;	2178	activate_connection (map, connection, state);
1941	RETVAL = map->tile_path [dir];
1942	OUTPUT:
1943	RETVAL
1944		2179
1945	mapstruct *cf_map_get_map (char *name)	2180	void
1946	PROTOTYPE: $	2181	get_connection (maptile *map, long connection)
1947	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)));
1948		2187
1949	mapstruct *has_been_loaded (char *name)
1950	PROTOTYPE: $
1951
1952	mapstruct *cf_map_get_first ()
1953	PROTOTYPE:
1954	ALIAS: first = 0
1955
1956	# whoever "designed" the plug-in api should have wasted
1957	# his/her time with staying away from the project - would have
1958	# saved others a lot of time, without doubt.
1959	void set_path (mapstruct *where, char *path)
1960	CODE:
1961	strcpy (where->path, path);
1962
1963	int in_memory (mapstruct *map)
1964	CODE:
1965	RETVAL = map->in_memory;
1966	OUTPUT:
1967	RETVAL
1968
1969	bool unique (mapstruct *map)
1970	CODE:
1971	RETVAL = map->unique;
1972	OUTPUT:
1973	RETVAL
1974
1975	void set_unique (mapstruct *map, bool unique)
1976	CODE:
1977	map->unique = unique;
1978
1979	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)
1980		2189
1981	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)
1982		2191
1983	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)
1984	C_ARGS: str, map, nx, ny	2193	C_ARGS: str, map, nx, ny
1985		2194
1986	void	2195	void
1987	cf_map_normalise (mapstruct *map, int x, int y)	2196	get_map_flags (maptile *map, int x, int y)
1988	PPCODE:	2197	PPCODE:
1989	{	2198	{
1990	mapstruct *nmap = 0;	2199	maptile *nmap = 0;
1991	I16 nx = 0, ny = 0;	2200	I16 nx = 0, ny = 0;
1992	int flags = cf_map_get_flags (map, &nmap, x, y, &nx, &ny);	2201	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
1993		2202
1994	EXTEND (SP, 4);	2203	EXTEND (SP, 4);
1995	PUSHs (sv_2mortal (newSViv (flags)));	2204	PUSHs (sv_2mortal (newSViv (flags)));
1996		2205
1997	if (GIMME_V == G_ARRAY)	2206	if (GIMME_V == G_ARRAY)
…		…
2001	PUSHs (sv_2mortal (newSViv (ny)));	2210	PUSHs (sv_2mortal (newSViv (ny)));
2002	}	2211	}
2003	}	2212	}
2004		2213
2005	void	2214	void
2006	at (mapstruct *map, unsigned int x, unsigned int y)	2215	at (maptile *map, unsigned int x, unsigned int y)
2007	PROTOTYPE: $$$	2216	PROTOTYPE: $$$
2008	PPCODE:	2217	PPCODE:
2009	{	2218	{
2010	object *o;	2219	object *o;
2011	mapstruct *nmap = 0;	2220	maptile *nmap = 0;
2012	I16 nx, ny;	2221	I16 nx, ny;
2013		2222
2014	cf_map_get_flags (map, &nmap, x, y, &nx, &ny);	2223	get_map_flags (map, &nmap, x, y, &nx, &ny);
2015		2224
2016	if (nmap)	2225	if (nmap)
2017	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)
2018	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));	2227	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));
2019	}	2228	}
2020		2229
2021	SV *	2230	SV *
2022	bot_at (mapstruct *obj, unsigned int x, unsigned int y)	2231	bot_at (maptile *obj, unsigned int x, unsigned int y)
2023	PROTOTYPE: $$$	2232	PROTOTYPE: $$$
2024	ALIAS:	2233	ALIAS:
2025	top_at = 1	2234	top_at = 1
2026	flags_at = 2	2235	flags_at = 2
2027	light_at = 3	2236	light_at = 3
2028	move_block_at = 4	2237	move_block_at = 4
2029	move_slow_at = 5	2238	move_slow_at = 5
2030	move_on_at = 6	2239	move_on_at = 6
2031	move_off_at = 7	2240	move_off_at = 7
2032	INIT:	2241	INIT:
2033	if (x >= MAP_WIDTH (obj) || y >= MAP_HEIGHT (obj)) XSRETURN_UNDEF;	2242	if (x >= obj->width || y >= obj->height) XSRETURN_UNDEF;
2034	CODE:	2243	CODE:
2035	switch (ix)	2244	switch (ix)
2036	{	2245	{
2037	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;
2038	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;
…		…
2041	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;
2042	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;
2043	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;
2044	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;
2045	}	2254	}
2046	OUTPUT:	2255	OUTPUT: RETVAL
2047	RETVAL
2048		2256
2049	# "serialise" map perl data into a ref	2257	void fix_walls (maptile *map, int x, int y)
2050	void	2258
2051	_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	)
2052	PPCODE:	2302	CODE:
2053	{	2303	{
2054	object *o;	2304	random_map_params rmp;
2055	int x, y;
2056	AV *obs = newAV ();
2057	int nonnull = 0;
2058		2305
2059	for (y = 0; y < MAP_HEIGHT (map); y++)	2306	assign (rmp.wallstyle , wallstyle);
2060	for (x = 0; x < MAP_WIDTH (map); x++)	2307	assign (rmp.wall_name , wall_name);
2061	{	2308	assign (rmp.floorstyle , floorstyle);
2062	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);
2063		2316
2064	for (o = GET_MAP_OB (map, x, y); o; o = o->above)	2317	rmp.origin_map = origin_map;
2065	{	2318	rmp.final_map = final_map;
2066	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;
2067		2343
2068	if (sv && HvFILL (SvRV (sv)))	2344	RETVAL = self->generate_random_map (&rmp);
2069	{
2070	nonnull = 1;
2071	sv = newSVsv (sv);
2072	}
2073	else
2074	sv = &PL_sv_undef;
2075
2076	av_push (av, sv);
2077	}
2078
2079	av_store (obs, x + y * MAP_HEIGHT (map), newRV_noinc ((SV *)av));
2080	}
2081
2082	if (nonnull)
2083	XPUSHs (sv_2mortal (newRV_noinc ((SV *)obs)));
2084	else
2085	SvREFCNT_dec (obs);
2086	}	2345	}
2087
2088	# "deserialise" perl map data into the map
2089	void
2090	_set_obs (mapstruct *map, SV *sv)
2091	CODE:
2092	{
2093	object *o;
2094	AV *av;
2095	int x, y;
2096	AV *obs = (AV *)SvRV (sv);
2097
2098	for (y = 0; y < MAP_HEIGHT (map); y++)
2099	for (x = 0; x < MAP_WIDTH (map); x++)
2100	{
2101	sv = *av_fetch (obs, x + y * MAP_HEIGHT (map), 1);
2102
2103	if (!SvROK (sv))
2104	continue;
2105
2106	av = (AV *)SvRV (sv);
2107
2108	for (o = GET_MAP_OB (map, x, y); o; o = o->above)
2109	{
2110	sv = av_shift (av);
2111
2112	if (SvROK (sv))
2113	{
2114	sv_magic ((SV *)SvRV (sv), 0, PERL_MAGIC_ext, (char *)o, 0);
2115	SVptr_cache_set (o, sv);
2116	}
2117	}
2118	}
2119	}
2120
2121
2122	MODULE = cf PACKAGE = cf::arch PREFIX = cf_archetype_
2123
2124	archetype *cf_archetype_get_first()
2125	PROTOTYPE:
2126	ALIAS: first = 0
2127
2128	archetype *cf_archetype_get_next (archetype *arch)
2129	ALIAS: next = 0
2130
2131	archetype *cf_archetype_get_head (archetype *arch)
2132	ALIAS: head = 0
2133
2134	archetype *cf_archetype_get_more (archetype *arch)
2135	ALIAS: more = 0
2136
2137	const char *cf_archetype_get_name (archetype *arch)
2138	ALIAS: name = 0
2139
2140	object *cf_archetype_get_clone (archetype *arch)
2141	ALIAS: clone = 0
2142
2143	MODULE = cf PACKAGE = cf::party PREFIX = cf_party_
2144
2145	partylist *cf_party_get_first ()
2146	PROTOTYPE:
2147	ALIAS: first = 0
2148
2149	partylist *cf_party_get_next (partylist *party)
2150	ALIAS: next = 0
2151
2152	const char *cf_party_get_name (partylist *party)
2153
2154	const char *cf_party_get_password (partylist *party)
2155	ALIAS: password = 0
2156
2157	player *cf_party_get_first_player (partylist *party)
2158	ALIAS: first_player = 0
2159
2160	player *cf_party_get_next_player (partylist *party, player *op)
2161	ALIAS: next_player = 0
2162
2163
2164	MODULE = cf PACKAGE = cf::region PREFIX = cf_region_
2165
2166	region *cf_region_get_first ()
2167	PROTOTYPE:
2168	ALIAS: first = 0
2169
2170	const char *cf_region_get_name (region *reg)
2171	ALIAS: name = 0
2172
2173	region *cf_region_get_next (region *reg)
2174	ALIAS: next = 0
2175
2176	region *cf_region_get_parent (region *reg)
2177	ALIAS: parent = 0
2178
2179	const char *cf_region_get_longname (region *reg)
2180	ALIAS: longname = 0
2181
2182	const char *cf_region_get_message (region *reg)
2183	ALIAS: message = 0
2184
2185
2186	MODULE = cf PACKAGE = cf::living PREFIX = cf_living_
2187
2188	val64
2189	exp (living *liv, val64 new_val = 0)
2190	PROTOTYPE: $;$
2191	ALIAS:
2192	Str = 1
2193	Dex = 2
2194	Con = 3
2195	Wis = 4
2196	Cha = 5
2197	Int = 6
2198	Pow = 7
2199	wc = 8
2200	ac = 9
2201	hp = 10
2202	maxhp = 11
2203	sp = 12
2204	maxsp = 13
2205	grace = 14
2206	maxgrace = 15
2207	food = 16
2208	dam = 17
2209	luck = 18
2210	CODE:
2211	# define LIVING_ACC(acc,idx) case idx: RETVAL = liv->acc; if (items > 1) liv->acc = (sint64)new_val; break
2212	switch (ix)
2213	{
2214	LIVING_ACC (exp , 0);
2215	LIVING_ACC (Str , 1);
2216	LIVING_ACC (Dex , 2);
2217	LIVING_ACC (Con , 3);
2218	LIVING_ACC (Wis , 4);
2219	LIVING_ACC (Cha , 5);
2220	LIVING_ACC (Int , 6);
2221	LIVING_ACC (Pow , 7);
2222	LIVING_ACC (wc , 8);
2223	LIVING_ACC (ac , 9);
2224	LIVING_ACC (hp , 10);
2225	LIVING_ACC (maxhp , 11);
2226	LIVING_ACC (sp , 12);
2227	LIVING_ACC (maxsp , 13);
2228	LIVING_ACC (grace , 14);
2229	LIVING_ACC (maxgrace, 15);
2230	LIVING_ACC (food , 16);
2231	LIVING_ACC (dam , 17);
2232	LIVING_ACC (luck , 18);
2233	}
2234	# undef LIVING_ACC
2235	OUTPUT:	2346	OUTPUT:
2236	RETVAL	2347	RETVAL
2237		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