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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.1 by root, Tue Aug 15 17:10:46 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	dSP;
506	int i, count;
507
508	clean_obj_cache ();
509
510	ENTER;
511	SAVETMPS;
512
513	// service up to 8 events per tick better would be
514	// to check for elapsed time and stop processing after
515	// 0.25 * server_tick or so
516	for (i = 9; --i; )
517	{
518	PUSHMARK (SP);
519	XPUSHs (sv_2mortal (newSViv (0)));
520	PUTBACK;
521	count = call_pv ("Event::one_event", G_SCALAR \| G_EVAL);
522	SPAGAIN;
523
524	if (!count \|\| !POPi)
525	break;
526	}
527
528	FREETMPS;
529	LEAVE;
530	}
531	else
532	{
533	dSP;
534
535	ENTER;
536	SAVETMPS;
537
538	PUSHMARK (SP);
539
540	EXTEND (SP, 10);
541	PUSHs (sv_2mortal (newSViv (event_code)));
542
543	switch (event_code)
544	{
545	case EVENT_CRASH:
546	break;
547
548	case EVENT_PLAYER_LOAD:
549	case EVENT_PLAYER_SAVE:
550	PUSH_OB;
551	PUSH_PV;
552	break;
553
554	case EVENT_MAPLOAD:
555	case EVENT_MAPOUT:
556	case EVENT_MAPIN:
557	case EVENT_MAPCLEAN:
558	case EVENT_MAPRESET:
559	PUSH_MAP;
560	break;
561
562	case EVENT_MAPENTER:
563	case EVENT_MAPLEAVE:
564	case EVENT_BORN:
565	case EVENT_REMOVE:
566	case EVENT_PLAYER_DEATH:
567	PUSH_OB;
568	break;
569
570	case EVENT_GKILL:
571	PUSH_OB;
572	PUSH_OB;
573	break;
574
575	case EVENT_LOGIN:
576	case EVENT_LOGOUT:
577	PUSH_PL;
578	PUSH_PV;
579	break;
580
581	case EVENT_SHOUT:
582	case EVENT_MUZZLE:
583	case EVENT_KICK:
584	PUSH_OB;
585	PUSH_PV;
586	break;
587
588	case EVENT_FIND_UNARMED_SKILL:
589	PUSH_OB;
590	break;
591
592	case EVENT_PLAYER_USE_SKILL:
593	case EVENT_MONSTER_USE_SKILL:
594	case EVENT_CAST_SPELL:
595	PUSH_OB;
596	PUSH_OB;
597	PUSH_OB;
598	PUSH_IV;
599	PUSH_PV;
600	break;
601
602	case EVENT_EXTCMD:
603	PUSH_PL;
604	{
605	char buf = va_arg (args, char );
606	int len = va_arg (args, int);
607	PUSHs (sv_2mortal (newSVpvn (buf, len)));
608	}
609	break;
610
611	case EVENT_TELL:
612	break;
613	}
614
615	va_end (args);
616
617	PUTBACK;
618	int count = call_pv ("cf::inject_global_event", G_SCALAR \| G_EVAL);
619	SPAGAIN;
620
621	if (SvTRUE (ERRSV))
622	LOG (llevError, "global event '%d' callback evaluation error: %s", event_code, SvPV_nolen (ERRSV));
623
624	rv = count > 0 ? POPi : 0;
625
626	PUTBACK;
627	FREETMPS;
628	LEAVE;
629	}
630
631	return &rv;
632	}	973	}
633		974
634	extern "C" void cfperl_eventListener (int type, ...)	975	void
		976	_connect_to_perl ()
635	{	977	{
636	static int rv;	978	stash_cf = gv_stashpv ("cf" , 1);
637	va_list args;
638	int event_code;
639	object who, activator, third, event;
640	char message, extension, *options;
641		979
642	if (!perl)	980	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);
643	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);
644		989
645	va_start (args, type);	990	sv_runtime = get_sv ("cf::RUNTIME", 1);
646	who = va_arg (args, object *);	991	sv_upgrade (sv_runtime, SVt_NV);
647	event_code = va_arg (args, int);
648	activator = va_arg (args, object *);
649	third = va_arg (args, object *);
650	message = va_arg (args, char *);
651	va_arg (args, int); // fix yourself
652	extension = va_arg (args, char *);
653	options = va_arg (args, char *);
654	event = va_arg (args, object *);
655	va_end (args);
656		992
657	{	993	cb_global = get_av ("cf::CB_GLOBAL", 1);
658	dSP;	994	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
659		995	cb_object = get_av ("cf::CB_OBJECT", 1);
660	ENTER;	996	cb_player = get_av ("cf::CB_PLAYER", 1);
661	SAVETMPS;	997	cb_client = get_av ("cf::CB_CLIENT", 1);
662		998	cb_type = get_av ("cf::CB_TYPE" , 1);
663	PUSHMARK (SP);	999	cb_map = get_av ("cf::CB_MAP" , 1);
664	EXTEND (SP, 10);
665
666	PUSHcfapi (STRING, extension);
667	PUSHs (sv_2mortal (newSViv (event_code)));
668
669	PUSHcfapi (POBJECT, event);
670	PUSHcfapi (POBJECT, who);
671
672	switch (event_code)
673	{
674	case EVENT_STOP: // $ob (e.g. arrow)
675	case EVENT_TIME: // $ob
676	case EVENT_TIMER: // $ob
677	break;
678
679	case EVENT_APPLY: // $ob, $who
680	case EVENT_DROP: // $ob, $who
681	case EVENT_CLOSE: // $ob, $who
682	case EVENT_DEATH: // $ob[, $killer]
683	case EVENT_MOVE: // $ob, $enemy
684	case EVENT_THROW: // $ob, $thrower
685	PUSHcfapi (POBJECT, activator);
686	break;
687
688	case EVENT_DROP_ON: // $ob, $who, $what
689	case EVENT_ATTACK: // $ob, $who, $victim (?? please god enlighten me)
690	PUSHcfapi (POBJECT, activator);
691	PUSHcfapi (POBJECT, third);
692	break;
693
694	case EVENT_TRIGGER: // $ob, $originator, [$victim], [$msg]
695	PUSHcfapi (POBJECT, activator);
696	PUSHcfapi (POBJECT, third);
697	PUSHcfapi (POBJECT, message);
698	break;
699
700	case EVENT_SAY: // $ob, $who, $msg
701	PUSHcfapi (POBJECT, activator);
702	PUSHcfapi (STRING, message);
703	break;
704
705	default:
706	LOG (llevError, "perl plugin called for unsupported event type %d", event_code);
707	break;
708	}
709
710	PUTBACK;
711	int count = call_pv ("cf::inject_event", G_SCALAR \| G_EVAL);
712	SPAGAIN;
713
714	if (SvTRUE (ERRSV))
715	LOG (llevError, "event '%d' callback evaluation error: %s", event_code, SvPV_nolen (ERRSV));
716
717	rv = count > 0 ? POPi : 0;
718
719	PUTBACK;
720	FREETMPS;
721	LEAVE;
722	}
723
724	return &rv;
725	}
726
727	extern "C" int cfperl_closePlugin ()
728	{
729	printf (PLUGIN_VERSION " closing\n");
730
731	if (perl)
732	{
733	perl_destruct (perl);
734	perl_free (perl);
735	perl = 0;
736	}
737
738	return 0;
739	}	1000	}
740		1001
741	MODULE = cf PACKAGE = cf PREFIX = cf_	1002	MODULE = cf PACKAGE = cf PREFIX = cf_
742		1003
743	BOOT:	1004	BOOT:
744	{	1005	{
745	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));
746		1012
747	static const struct {	1013	static const struct {
748	const char *name;	1014	const char *name;
749	IV iv;	1015	IV iv;
750	} *civ, const_iv[] = {	1016	} *civ, const_iv[] = {
…		…
752	const_iv (llevError)	1018	const_iv (llevError)
753	const_iv (llevInfo)	1019	const_iv (llevInfo)
754	const_iv (llevDebug)	1020	const_iv (llevDebug)
755	const_iv (llevMonster)	1021	const_iv (llevMonster)
756		1022
		1023	const_iv (MAX_TIME)
757	const_iv (PLAYER)	1024	const_iv (PLAYER)
758	const_iv (TRANSPORT)	1025	const_iv (TRANSPORT)
759	const_iv (ROD)	1026	const_iv (ROD)
760	const_iv (TREASURE)	1027	const_iv (TREASURE)
761	const_iv (POTION)	1028	const_iv (POTION)
762	const_iv (FOOD)	1029	const_iv (FOOD)
763	const_iv (POISON)	1030	const_iv (POISON)
764	const_iv (BOOK)	1031	const_iv (BOOK)
765	const_iv (CLOCK)	1032	const_iv (CLOCK)
766	const_iv (LIGHTNING)
767	const_iv (ARROW)	1033	const_iv (ARROW)
768	const_iv (BOW)	1034	const_iv (BOW)
769	const_iv (WEAPON)	1035	const_iv (WEAPON)
770	const_iv (ARMOUR)	1036	const_iv (ARMOUR)
771	const_iv (PEDESTAL)	1037	const_iv (PEDESTAL)
…		…
791	const_iv (AMULET)	1057	const_iv (AMULET)
792	const_iv (PLAYERMOVER)	1058	const_iv (PLAYERMOVER)
793	const_iv (TELEPORTER)	1059	const_iv (TELEPORTER)
794	const_iv (CREATOR)	1060	const_iv (CREATOR)
795	const_iv (SKILL)	1061	const_iv (SKILL)
796	const_iv (EXPERIENCE)
797	const_iv (EARTHWALL)	1062	const_iv (EARTHWALL)
798	const_iv (GOLEM)	1063	const_iv (GOLEM)
799	const_iv (THROWN_OBJ)	1064	const_iv (THROWN_OBJ)
800	const_iv (BLINDNESS)	1065	const_iv (BLINDNESS)
801	const_iv (GOD)	1066	const_iv (GOD)
…		…
821	const_iv (FLOOR)	1086	const_iv (FLOOR)
822	const_iv (FLESH)	1087	const_iv (FLESH)
823	const_iv (INORGANIC)	1088	const_iv (INORGANIC)
824	const_iv (SKILL_TOOL)	1089	const_iv (SKILL_TOOL)
825	const_iv (LIGHTER)	1090	const_iv (LIGHTER)
826	const_iv (TRAP_PART)
827	const_iv (WALL)	1091	const_iv (BUILDABLE_WALL)
828	const_iv (LIGHT_SOURCE)
829	const_iv (MISC_OBJECT)	1092	const_iv (MISC_OBJECT)
830	const_iv (MONSTER)
831	const_iv (SPAWN_GENERATOR)
832	const_iv (LAMP)	1093	const_iv (LAMP)
833	const_iv (DUPLICATOR)	1094	const_iv (DUPLICATOR)
834	const_iv (TOOL)
835	const_iv (SPELLBOOK)	1095	const_iv (SPELLBOOK)
836	const_iv (BUILDFAC)
837	const_iv (CLOAK)	1096	const_iv (CLOAK)
838	const_iv (SPINNER)	1097	const_iv (SPINNER)
839	const_iv (GATE)	1098	const_iv (GATE)
840	const_iv (BUTTON)	1099	const_iv (BUTTON)
841	const_iv (CF_HANDLE)	1100	const_iv (CF_HANDLE)
…		…
848	const_iv (SPELL_EFFECT)	1107	const_iv (SPELL_EFFECT)
849	const_iv (CONVERTER)	1108	const_iv (CONVERTER)
850	const_iv (BRACERS)	1109	const_iv (BRACERS)
851	const_iv (POISONING)	1110	const_iv (POISONING)
852	const_iv (SAVEBED)	1111	const_iv (SAVEBED)
853	const_iv (POISONCLOUD)
854	const_iv (FIREHOLES)
855	const_iv (WAND)	1112	const_iv (WAND)
856	const_iv (SCROLL)	1113	const_iv (SCROLL)
857	const_iv (DIRECTOR)	1114	const_iv (DIRECTOR)
858	const_iv (GIRDLE)	1115	const_iv (GIRDLE)
859	const_iv (FORCE)	1116	const_iv (FORCE)
…		…
874	const_iv (DISEASE)	1131	const_iv (DISEASE)
875	const_iv (SYMPTOM)	1132	const_iv (SYMPTOM)
876	const_iv (BUILDER)	1133	const_iv (BUILDER)
877	const_iv (MATERIAL)	1134	const_iv (MATERIAL)
878	const_iv (ITEM_TRANSFORMER)	1135	const_iv (ITEM_TRANSFORMER)
		1136
879	const_iv (QUEST)	1137	const_iv (NUM_SUBTYPES)
880		1138
881	const_iv (ST_BD_BUILD)	1139	const_iv (ST_BD_BUILD)
882	const_iv (ST_BD_REMOVE)	1140	const_iv (ST_BD_REMOVE)
883		1141
884	const_iv (ST_MAT_FLOOR)	1142	const_iv (ST_MAT_FLOOR)
…		…
910	const_iv (AT_BLIND)	1168	const_iv (AT_BLIND)
911	const_iv (AT_INTERNAL)	1169	const_iv (AT_INTERNAL)
912	const_iv (AT_LIFE_STEALING)	1170	const_iv (AT_LIFE_STEALING)
913	const_iv (AT_DISEASE)	1171	const_iv (AT_DISEASE)
914		1172
915	const_iv (QUEST_IN_PROGRESS)
916	const_iv (QUEST_DONE_QUEST)
917	const_iv (QUEST_DONE_TASK)
918	const_iv (QUEST_START_QUEST)
919	const_iv (QUEST_END_QUEST)
920	const_iv (QUEST_START_TASK)
921	const_iv (QUEST_END_TASK)
922	const_iv (QUEST_OVERRIDE)
923	const_iv (QUEST_ON_ACTIVATE)
924
925	const_iv (WEAP_HIT)	1173	const_iv (WEAP_HIT)
926	const_iv (WEAP_SLASH)	1174	const_iv (WEAP_SLASH)
927	const_iv (WEAP_PIERCE)	1175	const_iv (WEAP_PIERCE)
928	const_iv (WEAP_CLEAVE)	1176	const_iv (WEAP_CLEAVE)
929	const_iv (WEAP_SLICE)	1177	const_iv (WEAP_SLICE)
…		…
945	const_iv (FLAG_MONSTER)	1193	const_iv (FLAG_MONSTER)
946	const_iv (FLAG_FRIENDLY)	1194	const_iv (FLAG_FRIENDLY)
947	const_iv (FLAG_GENERATOR)	1195	const_iv (FLAG_GENERATOR)
948	const_iv (FLAG_IS_THROWN)	1196	const_iv (FLAG_IS_THROWN)
949	const_iv (FLAG_AUTO_APPLY)	1197	const_iv (FLAG_AUTO_APPLY)
950	const_iv (FLAG_TREASURE)
951	const_iv (FLAG_PLAYER_SOLD)	1198	const_iv (FLAG_PLAYER_SOLD)
952	const_iv (FLAG_SEE_INVISIBLE)	1199	const_iv (FLAG_SEE_INVISIBLE)
953	const_iv (FLAG_CAN_ROLL)	1200	const_iv (FLAG_CAN_ROLL)
954	const_iv (FLAG_OVERLAY_FLOOR)	1201	const_iv (FLAG_OVERLAY_FLOOR)
955	const_iv (FLAG_IS_TURNABLE)	1202	const_iv (FLAG_IS_TURNABLE)
…		…
1030	const_iv (FLAG_ACTIVATE_ON_RELEASE)	1277	const_iv (FLAG_ACTIVATE_ON_RELEASE)
1031	const_iv (FLAG_IS_WATER)	1278	const_iv (FLAG_IS_WATER)
1032	const_iv (FLAG_CONTENT_ON_GEN)	1279	const_iv (FLAG_CONTENT_ON_GEN)
1033	const_iv (FLAG_IS_A_TEMPLATE)	1280	const_iv (FLAG_IS_A_TEMPLATE)
1034	const_iv (FLAG_IS_BUILDABLE)	1281	const_iv (FLAG_IS_BUILDABLE)
		1282	const_iv (FLAG_DESTROY_ON_DEATH)
1035	const_iv (FLAG_AFK)	1283	const_iv (FLAG_NO_MAP_SAVE)
1036		1284
1037	const_iv (NDI_BLACK)	1285	const_iv (NDI_BLACK)
1038	const_iv (NDI_WHITE)	1286	const_iv (NDI_WHITE)
1039	const_iv (NDI_NAVY)	1287	const_iv (NDI_NAVY)
1040	const_iv (NDI_RED)	1288	const_iv (NDI_RED)
…		…
1050	const_iv (NDI_MAX_COLOR)	1298	const_iv (NDI_MAX_COLOR)
1051	const_iv (NDI_COLOR_MASK)	1299	const_iv (NDI_COLOR_MASK)
1052	const_iv (NDI_UNIQUE)	1300	const_iv (NDI_UNIQUE)
1053	const_iv (NDI_ALL)	1301	const_iv (NDI_ALL)
1054		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
1055	const_iv (F_APPLIED)	1316	const_iv (F_APPLIED)
1056	const_iv (F_LOCATION)	1317	const_iv (F_LOCATION)
1057	const_iv (F_UNPAID)	1318	const_iv (F_UNPAID)
1058	const_iv (F_MAGIC)	1319	const_iv (F_MAGIC)
1059	const_iv (F_CURSED)	1320	const_iv (F_CURSED)
…		…
1065	const_iv (F_BUY)	1326	const_iv (F_BUY)
1066	const_iv (F_SHOP)	1327	const_iv (F_SHOP)
1067	const_iv (F_SELL)	1328	const_iv (F_SELL)
1068		1329
1069	const_iv (P_BLOCKSVIEW)	1330	const_iv (P_BLOCKSVIEW)
		1331	const_iv (P_PLAYER)
1070	const_iv (P_NO_MAGIC)	1332	const_iv (P_NO_MAGIC)
1071	const_iv (P_IS_ALIVE)	1333	const_iv (P_IS_ALIVE)
1072	const_iv (P_NO_CLERIC)	1334	const_iv (P_NO_CLERIC)
1073	const_iv (P_NEED_UPDATE)
1074	const_iv (P_NO_ERROR)
1075	const_iv (P_OUT_OF_MAP)	1335	const_iv (P_OUT_OF_MAP)
1076	const_iv (P_NEW_MAP)	1336	const_iv (P_NEW_MAP)
		1337	const_iv (P_UPTODATE)
1077		1338
1078	const_iv (UP_OBJ_INSERT)	1339	const_iv (UP_OBJ_INSERT)
1079	const_iv (UP_OBJ_REMOVE)	1340	const_iv (UP_OBJ_REMOVE)
1080	const_iv (UP_OBJ_CHANGE)	1341	const_iv (UP_OBJ_CHANGE)
1081	const_iv (UP_OBJ_FACE)	1342	const_iv (UP_OBJ_FACE)
…		…
1113		1374
1114	const_iv (SK_EXP_ADD_SKILL)	1375	const_iv (SK_EXP_ADD_SKILL)
1115	const_iv (SK_EXP_TOTAL)	1376	const_iv (SK_EXP_TOTAL)
1116	const_iv (SK_EXP_NONE)	1377	const_iv (SK_EXP_NONE)
1117	const_iv (SK_SUBTRACT_SKILL_EXP)	1378	const_iv (SK_SUBTRACT_SKILL_EXP)
		1379	const_iv (SK_EXP_SKILL_ONLY)
1118		1380
1119	const_iv (SK_LOCKPICKING)	1381	const_iv (SK_LOCKPICKING)
1120	const_iv (SK_HIDING)	1382	const_iv (SK_HIDING)
1121	const_iv (SK_SMITHERY)	1383	const_iv (SK_SMITHERY)
1122	const_iv (SK_BOWYER)	1384	const_iv (SK_BOWYER)
…		…
1211	const_iv (ATNR_BLIND)	1473	const_iv (ATNR_BLIND)
1212	const_iv (ATNR_INTERNAL)	1474	const_iv (ATNR_INTERNAL)
1213	const_iv (ATNR_LIFE_STEALING)	1475	const_iv (ATNR_LIFE_STEALING)
1214	const_iv (ATNR_DISEASE)	1476	const_iv (ATNR_DISEASE)
1215		1477
1216	const_iv (MAP_FLUSH)
1217	const_iv (MAP_PLAYER_UNIQUE)
1218	const_iv (MAP_BLOCK)
1219	const_iv (MAP_STYLE)
1220	const_iv (MAP_OVERLAY)
1221
1222	const_iv (MAP_IN_MEMORY)	1478	const_iv (MAP_IN_MEMORY)
1223	const_iv (MAP_SWAPPED)	1479	const_iv (MAP_SWAPPED)
1224	const_iv (MAP_LOADING)	1480	const_iv (MAP_LOADING)
1225	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)
1226	};	1529	};
1227		1530
1228	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; )
1229	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));	1532	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1230		1533
1231	static const struct {	1534	static const struct {
1232	const char *name;	1535	const char *name;
		1536	int skip;
		1537	IV klass;
1233	IV iv;	1538	IV iv;
1234	} *event, event_list[] = {	1539	} *eiv, event_iv[] = {
1235	# 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 },
1236	const_event (NONE)	1541	# include "eventinc.h"
1237	const_event (APPLY)	1542	# undef def
1238	const_event (ATTACK)
1239	const_event (DEATH)
1240	const_event (DROP)
1241	const_event (DROP_ON)
1242	const_event (PICKUP)
1243	const_event (SAY)
1244	const_event (STOP)
1245	const_event (TIME)
1246	const_event (THROW)
1247	const_event (TRIGGER)
1248	const_event (CLOSE)
1249	const_event (TIMER)
1250	const_event (MOVE)
1251
1252	const_event (BORN)
1253	//const_event (CLOCK)
1254	const_event (CRASH)
1255	const_event (PLAYER_DEATH)
1256	const_event (PLAYER_LOAD)
1257	const_event (PLAYER_SAVE)
1258	const_event (GKILL)
1259	const_event (LOGIN)
1260	const_event (LOGOUT)
1261	const_event (MAPENTER)
1262	const_event (MAPLEAVE)
1263	const_event (MAPRESET)
1264	const_event (MAPLOAD)
1265	const_event (MAPOUT)
1266	const_event (MAPIN)
1267	const_event (MAPCLEAN)
1268	const_event (REMOVE)
1269	const_event (SHOUT)
1270	const_event (TELL)
1271	const_event (MUZZLE)
1272	const_event (KICK)
1273	const_event (PLAYER_USE_SKILL)
1274	const_event (MONSTER_USE_SKILL)
1275	const_event (CAST_SPELL)
1276	const_event (FIND_UNARMED_SKILL)
1277	const_event (EXTCMD)
1278	//const_event (FREE_OB)
1279	};	1543	};
1280		1544
1281	AV *av = get_av ("cf::EVENT", 1);	1545	AV *av = get_av ("cf::EVENT", 1);
1282		1546
1283	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; )
1284	av_store (av, event->iv, newSVpv ((char *)event->name, 0));
1285
1286	static const struct {
1287	int dtype;
1288	const char *name;
1289	IV idx;
1290	} *cprop, prop_table[] = {
1291	# define prop(type, name) { type, # name, (IV) CFAPI_ ## name },
1292	prop (CFAPI_INT, MAP_PROP_FLAGS)
1293	prop (CFAPI_INT, MAP_PROP_DIFFICULTY)
1294	prop (CFAPI_STRING, MAP_PROP_PATH)
1295	prop (CFAPI_STRING, MAP_PROP_TMPNAME)
1296	prop (CFAPI_STRING, MAP_PROP_NAME)
1297	prop (CFAPI_INT, MAP_PROP_RESET_TIME)
1298	prop (CFAPI_INT, MAP_PROP_RESET_TIMEOUT)
1299	prop (CFAPI_INT, MAP_PROP_PLAYERS)
1300	prop (CFAPI_INT, MAP_PROP_DARKNESS)
1301	prop (CFAPI_INT, MAP_PROP_WIDTH)
1302	prop (CFAPI_INT, MAP_PROP_HEIGHT)
1303	prop (CFAPI_INT, MAP_PROP_ENTER_X)
1304	prop (CFAPI_INT, MAP_PROP_ENTER_Y)
1305	prop (CFAPI_INT, MAP_PROP_TEMPERATURE)
1306	prop (CFAPI_INT, MAP_PROP_PRESSURE)
1307	prop (CFAPI_INT, MAP_PROP_HUMIDITY)
1308	prop (CFAPI_INT, MAP_PROP_WINDSPEED)
1309	prop (CFAPI_INT, MAP_PROP_WINDDIR)
1310	prop (CFAPI_INT, MAP_PROP_SKY)
1311	prop (CFAPI_INT, MAP_PROP_WPARTX)
1312	prop (CFAPI_INT, MAP_PROP_WPARTY)
1313	prop (CFAPI_STRING, MAP_PROP_MESSAGE)
1314	prop (CFAPI_PMAP, MAP_PROP_NEXT)
1315	prop (CFAPI_PREGION, MAP_PROP_REGION)
1316	prop (CFAPI_POBJECT, OBJECT_PROP_OB_ABOVE)
1317	prop (CFAPI_POBJECT, OBJECT_PROP_OB_BELOW)
1318	prop (CFAPI_POBJECT, OBJECT_PROP_NEXT_ACTIVE_OB)
1319	prop (CFAPI_POBJECT, OBJECT_PROP_PREV_ACTIVE_OB)
1320	prop (CFAPI_POBJECT, OBJECT_PROP_INVENTORY)
1321	prop (CFAPI_POBJECT, OBJECT_PROP_ENVIRONMENT)
1322	prop (CFAPI_POBJECT, OBJECT_PROP_HEAD)
1323	prop (CFAPI_POBJECT, OBJECT_PROP_CONTAINER)
1324	prop (CFAPI_PMAP, OBJECT_PROP_MAP)
1325	prop (CFAPI_INT, OBJECT_PROP_COUNT)
1326	prop (CFAPI_INT, OBJECT_PROP_REFCOUNT)
1327	prop (CFAPI_STRING, OBJECT_PROP_NAME)
1328	prop (CFAPI_STRING, OBJECT_PROP_NAME_PLURAL)
1329	prop (CFAPI_STRING, OBJECT_PROP_TITLE)
1330	prop (CFAPI_STRING, OBJECT_PROP_RACE)
1331	prop (CFAPI_STRING, OBJECT_PROP_SLAYING)
1332	prop (CFAPI_STRING, OBJECT_PROP_SKILL)
1333	prop (CFAPI_STRING, OBJECT_PROP_MESSAGE)
1334	prop (CFAPI_STRING, OBJECT_PROP_LORE)
1335	prop (CFAPI_INT, OBJECT_PROP_X)
1336	prop (CFAPI_INT, OBJECT_PROP_Y)
1337	prop (CFAPI_DOUBLE, OBJECT_PROP_SPEED)
1338	prop (CFAPI_DOUBLE, OBJECT_PROP_SPEED_LEFT)
1339	prop (CFAPI_INT, OBJECT_PROP_NROF)
1340	prop (CFAPI_INT, OBJECT_PROP_DIRECTION)
1341	prop (CFAPI_INT, OBJECT_PROP_FACING)
1342	prop (CFAPI_INT, OBJECT_PROP_TYPE)
1343	prop (CFAPI_INT, OBJECT_PROP_SUBTYPE)
1344	prop (CFAPI_INT, OBJECT_PROP_CLIENT_TYPE)
1345	prop (CFAPI_INT, OBJECT_PROP_ATTACK_TYPE)
1346	prop (CFAPI_INT, OBJECT_PROP_PATH_ATTUNED)
1347	prop (CFAPI_INT, OBJECT_PROP_PATH_REPELLED)
1348	prop (CFAPI_INT, OBJECT_PROP_PATH_DENIED)
1349	prop (CFAPI_INT, OBJECT_PROP_MATERIAL)
1350	prop (CFAPI_STRING, OBJECT_PROP_MATERIAL_NAME)
1351	prop (CFAPI_INT, OBJECT_PROP_MAGIC)
1352	prop (CFAPI_INT, OBJECT_PROP_VALUE)
1353	prop (CFAPI_INT, OBJECT_PROP_LEVEL)
1354	prop (CFAPI_INT, OBJECT_PROP_LAST_HEAL)
1355	prop (CFAPI_INT, OBJECT_PROP_LAST_SP)
1356	prop (CFAPI_INT, OBJECT_PROP_LAST_GRACE)
1357	prop (CFAPI_INT, OBJECT_PROP_LAST_EAT)
1358	prop (CFAPI_INT, OBJECT_PROP_INVISIBLE_TIME)
1359	prop (CFAPI_INT, OBJECT_PROP_PICK_UP)
1360	prop (CFAPI_INT, OBJECT_PROP_ITEM_POWER)
1361	prop (CFAPI_INT, OBJECT_PROP_GEN_SP_ARMOUR)
1362	prop (CFAPI_INT, OBJECT_PROP_WEIGHT)
1363	prop (CFAPI_INT, OBJECT_PROP_WEIGHT_LIMIT)
1364	prop (CFAPI_INT, OBJECT_PROP_CARRYING)
1365	prop (CFAPI_INT, OBJECT_PROP_GLOW_RADIUS)
1366	prop (CFAPI_LONG, OBJECT_PROP_PERM_EXP)
1367	prop (CFAPI_POBJECT, OBJECT_PROP_CURRENT_WEAPON)
1368	prop (CFAPI_POBJECT, OBJECT_PROP_ENEMY)
1369	prop (CFAPI_POBJECT, OBJECT_PROP_ATTACKED_BY)
1370	prop (CFAPI_INT, OBJECT_PROP_RUN_AWAY)
1371	prop (CFAPI_POBJECT, OBJECT_PROP_CHOSEN_SKILL)
1372	prop (CFAPI_INT, OBJECT_PROP_HIDDEN)
1373	prop (CFAPI_INT, OBJECT_PROP_MOVE_STATUS)
1374	prop (CFAPI_INT, OBJECT_PROP_MOVE_TYPE)
1375	prop (CFAPI_POBJECT, OBJECT_PROP_SPELL_ITEM)
1376	prop (CFAPI_DOUBLE, OBJECT_PROP_EXP_MULTIPLIER)
1377	prop (CFAPI_PARCH, OBJECT_PROP_ARCHETYPE)
1378	prop (CFAPI_PARCH, OBJECT_PROP_OTHER_ARCH)
1379	prop (CFAPI_STRING, OBJECT_PROP_CUSTOM_NAME)
1380	prop (CFAPI_INT, OBJECT_PROP_ANIM_SPEED)
1381	prop (CFAPI_INT, OBJECT_PROP_FRIENDLY)
1382	prop (CFAPI_STRING, OBJECT_PROP_SHORT_NAME)
1383	prop (CFAPI_INT, OBJECT_PROP_MAGICAL)
1384	prop (CFAPI_INT, OBJECT_PROP_LUCK)
1385	prop (CFAPI_POBJECT, OBJECT_PROP_OWNER)
1386	prop (CFAPI_POBJECT, OBJECT_PROP_PRESENT)
1387	prop (CFAPI_INT, OBJECT_PROP_CHEATER)
1388	prop (CFAPI_INT, OBJECT_PROP_MERGEABLE)
1389	prop (CFAPI_INT, OBJECT_PROP_PICKABLE)
1390	prop (CFAPI_INT, OBJECT_PROP_STR)
1391	prop (CFAPI_INT, OBJECT_PROP_DEX)
1392	prop (CFAPI_INT, OBJECT_PROP_CON)
1393	prop (CFAPI_INT, OBJECT_PROP_WIS)
1394	prop (CFAPI_INT, OBJECT_PROP_INT)
1395	prop (CFAPI_INT, OBJECT_PROP_POW)
1396	prop (CFAPI_INT, OBJECT_PROP_CHA)
1397	prop (CFAPI_INT, OBJECT_PROP_WC)
1398	prop (CFAPI_INT, OBJECT_PROP_AC)
1399	prop (CFAPI_INT, OBJECT_PROP_HP)
1400	prop (CFAPI_INT, OBJECT_PROP_SP)
1401	prop (CFAPI_INT, OBJECT_PROP_GP)
1402	prop (CFAPI_INT, OBJECT_PROP_FP)
1403	prop (CFAPI_INT, OBJECT_PROP_MAXHP)
1404	prop (CFAPI_INT, OBJECT_PROP_MAXSP)
1405	prop (CFAPI_INT, OBJECT_PROP_MAXGP)
1406	prop (CFAPI_INT, OBJECT_PROP_DAM)
1407	prop (CFAPI_STRING, OBJECT_PROP_GOD)
1408	prop (CFAPI_STRING, OBJECT_PROP_ARCH_NAME)
1409	prop (CFAPI_INT, OBJECT_PROP_INVISIBLE)
1410	prop (CFAPI_INT, OBJECT_PROP_FACE)
1411	};
1412
1413	HV *prop_type = get_hv ("cf::PROP_TYPE", 1);
1414	HV *prop_idx = get_hv ("cf::PROP_IDX", 1);
1415
1416	for (cprop = prop_table + sizeof (prop_table) / sizeof (prop_table [0]); cprop-- > prop_table; )
1417	{	1548	{
1418	hv_store (prop_type, cprop->name, strlen (cprop->name), newSViv (cprop->dtype), 0);	1549	AV *event = newAV ();
1419	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));
1420	}	1554	}
		1555	}
1421		1556
1422	//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 ();
1423	}	1575	}
1424		1576
1425	NV floor (NV x)	1577	NV floor (NV x)
1426		1578
1427	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 ();
1428		1597
1429	void	1598	void
1430	LOG (int level, char *msg)	1599	LOG (int level, char *msg)
1431	PROTOTYPE: $$	1600	PROTOTYPE: $$
1432	C_ARGS: (LogLevel)level, "%s", msg	1601	C_ARGS: (LogLevel)level, "%s", msg
…		…
1435	PROTOTYPE: $$	1604	PROTOTYPE: $$
1436		1605
1437	char path_combine_and_normalize (char base, char *path)	1606	char path_combine_and_normalize (char base, char *path)
1438	PROTOTYPE: $$	1607	PROTOTYPE: $$
1439		1608
1440	char *	1609	const char *
1441	cf_get_maps_directory (char *path)	1610	get_maps_directory (char *path)
1442	PROTOTYPE: $	1611	PROTOTYPE: $
1443	ALIAS: maps_directory = 0	1612	ALIAS: maps_directory = 0
		1613	CODE:
		1614	RETVAL = create_pathname (path);
		1615	OUTPUT: RETVAL
1444		1616
1445	void	1617	void
1446	sub_generation_inc ()	1618	sub_generation_inc ()
1447	CODE:	1619	CODE:
1448	PL_sub_generation++;	1620	PL_sub_generation++;
…		…
1457	confdir = 3	1629	confdir = 3
1458	localdir = 4	1630	localdir = 4
1459	playerdir = 5	1631	playerdir = 5
1460	datadir = 6	1632	datadir = 6
1461	CODE:	1633	CODE:
1462	{	1634	switch (ix)
1463	int unused_type;	1635	{
1464	RETVAL = (char *)systemDirectory (&unused_type, ix);	1636	case 0: RETVAL = settings.mapdir ; break;
1465	}	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	}
1466	OUTPUT: RETVAL	1644	OUTPUT: RETVAL
1467		1645
1468	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
1469	cf_find_animation (char *text)	1670	int find_animation (char *text)
1470	PROTOTYPE: $	1671	PROTOTYPE: $
1471		1672
1472	int random_roll(int min, int max, object *op, int goodbad);	1673	int random_roll (int min, int max, object *op, int goodbad);
1473		1674
1474	const char *cost_string_from_value(uint64 cost, int approx = 0)	1675	const char *cost_string_from_value(uint64 cost, int approx = 0)
1475		1676
1476	int	1677	int
1477	exp_to_level (val64 exp)	1678	exp_to_level (val64 exp)
…		…
1510	RETVAL = newSVpv (resist_plus[atnr], 0);	1711	RETVAL = newSVpv (resist_plus[atnr], 0);
1511	else	1712	else
1512	XSRETURN_UNDEF;	1713	XSRETURN_UNDEF;
1513	OUTPUT: RETVAL	1714	OUTPUT: RETVAL
1514		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
1515	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_	1747	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
1516		1748
1517	SV *	1749	INCLUDE: $PERL genacc object ../include/object.h \|
1518	get_property (object *obj, int type, int idx)	1750
		1751	int invoke (object *op, int event, ...)
1519	CODE:	1752	CODE:
1520	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);
1521	OUTPUT: RETVAL	1757	OUTPUT: RETVAL
1522		1758
1523	SV *	1759	SV registry (object op)
1524	set_property (object obj, int type, int idx, SV newval)	1760
		1761	int objects_size ()
1525	CODE:	1762	CODE:
1526	switch (type)	1763	RETVAL = objects.size ();
1527	{	1764	OUTPUT: RETVAL
1528	case CFAPI_INT:	1765
1529	cf_object_set_int_property (obj, idx, SvIV (newval));	1766	object *objects (U32 index)
1530	break;	1767	CODE:
1531	case CFAPI_LONG:	1768	RETVAL = index < objects.size () ? objects [index] : 0;
1532	cf_object_set_long_property (obj, idx, (long) SvVAL64 (newval));	1769	OUTPUT: RETVAL
1533	break;	1770
1534	case CFAPI_DOUBLE:	1771	int actives_size ()
1535	{	1772	CODE:
1536	int unused_type;	1773	RETVAL = actives.size ();
1537	object_set_property (&unused_type, obj, idx, (double)SvNV (newval));	1774	OUTPUT: RETVAL
1538	}	1775
1539	break;	1776	object *actives (U32 index)
1540	case CFAPI_STRING:	1777	CODE:
1541	cf_object_set_string_property (obj, idx, SvOK (newval) ? SvPV_nolen (newval) : 0);	1778	RETVAL = index < actives.size () ? actives [index] : 0;
1542	break;	1779	OUTPUT: RETVAL
1543	case CFAPI_POBJECT:
1544	{
1545	int unused_type;
1546	object_set_property (&unused_type, obj, idx, (object *)SvPTR_ornull (newval, "cf::object"));
1547	}
1548	break;
1549	default:
1550	croak ("unhandled type '%d' in set_property '%d'", type, idx);
1551	}
1552		1780
1553	# missing properties	1781	# missing properties
1554		1782
1555	void	1783	object head (object op)
1556	set_attacktype (object *obj, U32 attacktype)	1784	PROTOTYPE: $
1557	CODE:	1785	CODE:
1558	obj->attacktype = attacktype;	1786	RETVAL = op->head_ ();
1559
1560	U32
1561	get_attacktype (object *obj)
1562	ALIAS:
1563	attacktype = 0
1564	CODE:
1565	RETVAL = obj->attacktype;
1566	OUTPUT: RETVAL	1787	OUTPUT: RETVAL
1567		1788
1568	# missing in plug-in api, of course	1789	int is_head (object *op)
1569	void	1790	PROTOTYPE: $
1570	set_food (object *obj, int food)	1791	CODE:
1571	CODE:	1792	RETVAL = op->head_ () == op;
1572	obj->stats.food = food;
1573
1574	int
1575	get_food (object *obj)
1576	ALIAS:
1577	food = 0
1578	CODE:
1579	RETVAL = obj->stats.food;
1580	OUTPUT: RETVAL	1793	OUTPUT: RETVAL
1581		1794
1582	void	1795	void
1583	inv (object *obj)	1796	inv (object *obj)
1584	PROTOTYPE: $	1797	PROTOTYPE: $
1585	PPCODE:	1798	PPCODE:
1586	{	1799	{
1587	object *o;	1800	object *o;
1588	for (o = obj->inv; o; o = o->below)	1801	for (o = obj->inv; o; o = o->below)
1589	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));	1802	XPUSHs (sv_2mortal (to_sv (o)));
1590	}	1803	}
1591		1804
1592	int cf_object_get_resistance (object *op, int rtype)	1805	void
1593	ALIAS: resistance = 0	1806	set_animation (object *op, int idx)
		1807	CODE:
		1808	SET_ANIMATION (op, idx);
1594		1809
1595	int cf_object_get_flag (object *op, int flag)	1810	int
1596	ALIAS: flag = 0	1811	num_animations (object *op)
		1812	CODE:
		1813	RETVAL = NUM_ANIMATIONS (op);
		1814	OUTPUT: RETVAL
1597		1815
1598	void cf_object_set_flag (object *op, int flag, int value)	1816	object find_best_object_match (object op, const char *match)
1599		1817
		1818	object find_marked_object (object op)
		1819
1600	int need_identify (const object *obj);	1820	int need_identify (object *obj);
1601		1821
1602	int apply_shop_mat (object shop_mat, object op);	1822	int apply_shop_mat (object shop_mat, object op);
1603		1823
1604	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
1605		1829
1606	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);
1607		1833
1608	void cf_object_apply_below (object *op)	1834	void apply_below (object *op)
1609		1835	CODE:
1610	void cf_object_remove (object *op)	1836	player_apply_below (op);
1611
1612	void cf_object_free (object *op)
1613		1837
1614	object cf_object_present_archname_inside (object op, char *whatstr)	1838	object cf_object_present_archname_inside (object op, char *whatstr)
1615		1839
1616	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)
1617		1841
1618	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)
1619		1843
		1844	#//TODO
1620	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
1621		1855
1622	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
1623		1860
1624	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
1625		1865
1626	void pay_player (object *op, uint64 amount)	1866	void pay_player (object *op, uint64 amount)
1627		1867
1628	val64 pay_player_arch (object op, const char arch, uint64 amount)	1868	val64 pay_player_arch (object op, const char arch, uint64 amount)
1629		1869
1630	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)
1631		1871
1632	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);
1633		1875
1634	void cf_object_learn_spell (object op, object sp)
1635
1636	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));
1637		1879
1638	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
1639		1884
1640	int cf_object_query_money (object *op)	1885	int query_money (object *op)
1641	ALIAS: money = 0	1886	ALIAS: money = 0
1642		1887
1643	int cf_object_query_cost (object op, object who, int flags)	1888	val64 query_cost (object op, object who, int flags)
1644	ALIAS: cost = 0	1889	ALIAS: cost = 0
1645		1890
1646	void cf_object_activate_rune (object op , object victim)	1891	void spring_trap (object op, object victim)
1647		1892
1648	int cf_object_check_trigger (object op, object cause)	1893	int check_trigger (object op, object cause)
1649		1894
1650	int cf_object_out_of_map (object *op, int x, int y)
1651
1652	void cf_object_drop (object op, object author)	1895	void drop (object who, object op)
1653		1896
1654	void cf_object_take (object op, object author)	1897	void pick_up (object who, object op)
1655		1898
1656	void cf_object_say (object op, char msg)
1657
1658	void cf_object_speak (object op, char msg)
1659
1660	object cf_object_insert_object (object op, object *container)
1661
1662	const char cf_object_get_msg (object ob)
1663	ALIAS: msg = 0
1664
1665	object cf_object_insert_in_ob (object ob, object *where)
1666
1667	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)
1668		1900
1669	void cf_object_update (object *op, int flags)	1901	void update_object (object *op, int action)
1670
1671	void cf_object_pickup (object op, object what)
1672		1902
1673	object cf_create_object_by_name (const char name)	1903	object cf_create_object_by_name (const char name)
1674		1904
1675	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)
1676		1906
…		…
1682		1912
1683	void push_button (object *op);	1913	void push_button (object *op);
1684		1914
1685	void use_trigger (object *op);	1915	void use_trigger (object *op);
1686		1916
1687	void add_button_link (object button, mapstruct map, int connected);	1917	void add_button_link (object button, maptile map, int connected);
1688		1918
1689	void remove_button_link (object *op);	1919	void remove_button_link (object *op);
1690		1920
1691	void
1692	cf_object_set_resistance (object *op, int rtype, int val)
1693	CODE:
1694	if (rtype >= 0 && rtype < NROFATTACKS)
1695	op->resist[rtype] = val;
1696
1697		1921
1698	MODULE = cf PACKAGE = cf::object PREFIX = cf_	1922	MODULE = cf PACKAGE = cf::object PREFIX = cf_
1699
1700	void cf_fix_object (object *pl)
1701	ALIAS: fix = 0
1702		1923
1703	object cf_insert_ob_in_ob (object ob, object *where)	1924	object cf_insert_ob_in_ob (object ob, object *where)
1704		1925
1705	# 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
1706	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.	1927	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.
…		…
1710	CODE:	1931	CODE:
1711	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();	1932	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();
1712	OUTPUT:	1933	OUTPUT:
1713	RETVAL	1934	RETVAL
1714		1935
1715	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)
1716	PROTOTYPE: $$$$$$	1937	PROTOTYPE: $$$$$$
1717	CODE:	1938	CODE:
1718	{	1939	{
1719	int unused_type;	1940	int unused_type;
1720	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);
…		…
1758	bool on_same_map_as (object ob, object other)	1979	bool on_same_map_as (object ob, object other)
1759	CODE:	1980	CODE:
1760	RETVAL = on_same_map (ob, other);	1981	RETVAL = on_same_map (ob, other);
1761	OUTPUT: RETVAL	1982	OUTPUT: RETVAL
1762		1983
1763	char *	1984	const char *
1764	base_name (object *ob, int plural)	1985	base_name (object *op, int plural = op->nrof > 1)
1765	CODE:	1986	CODE:
1766	RETVAL = cf_query_base_name (ob, plural);	1987	RETVAL = query_base_name (op, plural);
1767	OUTPUT: RETVAL	1988	OUTPUT: RETVAL
1768		1989
1769	living *	1990	object decrease_ob_nr (object op, unsigned long i)
1770	stats (object *ob)
1771	CODE:
1772	RETVAL = &ob->stats;
1773	OUTPUT: RETVAL
1774
1775		1991
1776	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_	1992	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_
1777		1993
1778	player player (object op)	1994	player player (object op)
1779	CODE:	1995	CODE:
1780	RETVAL = op->contr;	1996	RETVAL = op->contr;
1781	OUTPUT: RETVAL	1997	OUTPUT: RETVAL
1782		1998
		1999	void check_score (object *op)
		2000
1783	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);
1784		2004
1785	object cf_player_send_inventory (object op)	2005	object cf_player_send_inventory (object op)
1786		2006
1787	char cf_player_get_ip (object op)	2007	char cf_player_get_ip (object op)
1788	ALIAS: ip = 0	2008	ALIAS: ip = 0
…		…
1797		2017
1798	void cf_player_set_party (object op, partylist party)	2018	void cf_player_set_party (object op, partylist party)
1799		2019
1800	void kill_player (object *op)	2020	void kill_player (object *op)
1801		2021
1802	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
1803		2035
1804	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_	2036	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
1805		2037
1806	player cf_player_find (char name)	2038	INCLUDE: $PERL genacc player ../include/player.h \|
1807	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;
1808		2057
1809	void cf_player_move (player *pl, int dir)	2058	void cf_player_move (player *pl, int dir)
1810		2059
1811	void MapNewmapCmd (player *pl)
1812
1813	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);
1814
1815	# nonstandard
1816	object ob (player pl)
1817	CODE:
1818	RETVAL = pl->ob;
1819	OUTPUT: RETVAL
1820		2061
1821	player *first ()	2062	player *first ()
1822	CODE:	2063	CODE:
1823	RETVAL = first_player;	2064	RETVAL = first_player;
1824	OUTPUT: RETVAL	2065	OUTPUT: RETVAL
1825		2066
1826	player next (player pl)
1827	CODE:
1828	RETVAL = pl->next;
1829	OUTPUT: RETVAL
1830
1831	bool	2067	bool
1832	cell_visible (player *pl, int dx, int dy)	2068	cell_visible (player *pl, int dx, int dy)
1833	CODE:	2069	CODE:
1834	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
1835	&& !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];
1836	OUTPUT:	2072	OUTPUT:
1837	RETVAL	2073	RETVAL
1838		2074
1839	void	2075	void
1840	send (player pl, SV packet)	2076	send (player pl, SV packet)
1841	CODE:	2077	CODE:
1842	{	2078	{
1843	STRLEN len;	2079	STRLEN len;
1844	char *buf = SvPVbyte (packet, len);	2080	char *buf = SvPVbyte (packet, len);
1845		2081
1846	Write_String_To_Socket (&pl->socket, buf, len);	2082	if (pl->ns)
		2083	pl->ns->send_packet (buf, len);
1847	}	2084	}
1848		2085
1849	int	2086	int
1850	listening (player *pl, int new_value = -1)	2087	listening (player *pl, int new_value = -1)
1851	CODE:	2088	CODE:
…		…
1853	if (new_value >= 0)	2090	if (new_value >= 0)
1854	pl->listening = new_value;	2091	pl->listening = new_value;
1855	OUTPUT:	2092	OUTPUT:
1856	RETVAL	2093	RETVAL
1857		2094
1858	void get_savebed (player *pl)	2095	void savebed (player pl, SV map_path = 0, SV x = 0, SV y = 0)
1859	ALIAS:	2096	PROTOTYPE: $;$$$
1860	savebed = 0
1861	PPCODE:	2097	PPCODE:
		2098	if (GIMME_V != G_VOID)
		2099	{
1862	EXTEND (SP, 3);	2100	EXTEND (SP, 3);
1863	PUSHs (sv_2mortal (newSVpv (pl->savebed_map, 0)));	2101	PUSHs (sv_2mortal (newSVpv (pl->savebed_map, 0)));
1864	PUSHs (sv_2mortal (newSViv (pl->bed_x)));	2102	PUSHs (sv_2mortal (newSViv (pl->bed_x)));
1865	PUSHs (sv_2mortal (newSViv (pl->bed_y)));	2103	PUSHs (sv_2mortal (newSViv (pl->bed_y)));
1866		2104	}
1867	void set_savebed (player pl, char map_path, int x, int y)	2105	if (map_path) sv_to (map_path, pl->savebed_map);
1868	CODE:	2106	if (x) sv_to (x, pl->bed_x);
1869	strcpy (pl->savebed_map, map_path);	2107	if (y) sv_to (y, pl->bed_y);
1870	pl->bed_x = x;
1871	pl->bed_y = y;
1872		2108
1873	void	2109	void
1874	list ()	2110	list ()
1875	PPCODE:	2111	PPCODE:
1876	{	2112	for_all_players (pl)
1877	player *pl;	2113	XPUSHs (sv_2mortal (to_sv (pl)));
1878	for (pl = first_player; pl; pl = pl->next)
1879	XPUSHs (newSVcfapi (CFAPI_PPLAYER, pl));
1880	}
1881
1882	bool
1883	peaceful (player *pl, bool new_setting = 0)
1884	PROTOTYPE: $;$
1885	CODE:
1886	RETVAL = pl->peaceful;
1887	if (items > 1)
1888	pl->peaceful = new_setting;
1889	OUTPUT:
1890	RETVAL
1891
1892	living *
1893	orig_stats (player *pl)
1894	CODE:
1895	RETVAL = &pl->orig_stats;
1896	OUTPUT: RETVAL
1897
1898	living *
1899	last_stats (player *pl)
1900	CODE:
1901	RETVAL = &pl->last_stats;
1902	OUTPUT: RETVAL
1903		2114
1904		2115
1905	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_	2116	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_
1906		2117
1907	SV *	2118	int invoke (maptile *map, int event, ...)
1908	get_property (mapstruct *obj, int type, int idx)
1909	CODE:	2119	CODE:
1910	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);
1911	OUTPUT: RETVAL	2124	OUTPUT: RETVAL
1912		2125
1913	SV *	2126	SV registry (maptile map)
1914	set_property (mapstruct obj, int type, int idx, SV newval)
1915	CODE:
1916	switch (type)
1917	{
1918	case CFAPI_INT:
1919	cf_map_set_int_property (obj, idx, SvIV (newval));
1920	break;
1921	default:
1922	croak ("unhandled type '%d' in set_property '%d'", type, idx);
1923	}
1924		2127
1925	mapstruct *new (int width, int height)	2128	INCLUDE: $PERL genacc maptile ../include/map.h \|
		2129
		2130	void
		2131	maptile::instantiate ()
		2132
		2133	maptile *new ()
1926	PROTOTYPE:	2134	PROTOTYPE:
1927	CODE:	2135	CODE:
1928	{	2136	RETVAL = new maptile;
1929	int unused_type;
1930	RETVAL = (mapstruct*) map_get_map (&unused_type, 0, width, height);
1931	}
1932	OUTPUT:	2137	OUTPUT:
1933	RETVAL	2138	RETVAL
1934		2139
1935	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	}
1936		2152
1937	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");
1938		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
1939	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)
1940		2172
1941	mapstruct tile_map (mapstruct map, unsigned int dir)	2173	int out_of_map (maptile *map, int x, int y)
1942	CODE:
1943	RETVAL = dir < 4 ? map->tile_map [dir] : 0;
1944	OUTPUT:
1945	RETVAL
1946		2174
1947	char tile_path (mapstruct map, unsigned int dir)	2175	void
1948	CODE:	2176	trigger (maptile *map, long connection, bool state = true)
1949	if (dir >= 4)	2177	CODE:
1950	XSRETURN_UNDEF;	2178	activate_connection (map, connection, state);
1951	RETVAL = map->tile_path [dir];
1952	OUTPUT:
1953	RETVAL
1954		2179
1955	mapstruct cf_map_get_map (char name)	2180	void
1956	PROTOTYPE: $	2181	get_connection (maptile *map, long connection)
1957	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)));
1958		2187
1959	mapstruct has_been_loaded (char name)
1960	PROTOTYPE: $
1961
1962	mapstruct *cf_map_get_first ()
1963	PROTOTYPE:
1964	ALIAS: first = 0
1965
1966	# whoever "designed" the plug-in api should have wasted
1967	# his/her time with staying away from the project - would have
1968	# saved others a lot of time, without doubt.
1969	void set_path (mapstruct where, char path)
1970	CODE:
1971	strcpy (where->path, path);
1972
1973	int in_memory (mapstruct *map)
1974	CODE:
1975	RETVAL = map->in_memory;
1976	OUTPUT:
1977	RETVAL
1978
1979	bool unique (mapstruct *map)
1980	CODE:
1981	RETVAL = map->unique;
1982	OUTPUT:
1983	RETVAL
1984
1985	void set_unique (mapstruct *map, bool unique)
1986	CODE:
1987	map->unique = unique;
1988
1989	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)
1990		2189
1991	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)
1992		2191
1993	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)
1994	C_ARGS: str, map, nx, ny	2193	C_ARGS: str, map, nx, ny
1995		2194
1996	void	2195	void
1997	cf_map_normalise (mapstruct *map, int x, int y)	2196	get_map_flags (maptile *map, int x, int y)
1998	PPCODE:	2197	PPCODE:
1999	{	2198	{
2000	mapstruct *nmap = 0;	2199	maptile *nmap = 0;
2001	I16 nx = 0, ny = 0;	2200	I16 nx = 0, ny = 0;
2002	int flags = cf_map_get_flags (map, &nmap, x, y, &nx, &ny);	2201	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
2003		2202
2004	EXTEND (SP, 4);	2203	EXTEND (SP, 4);
2005	PUSHs (sv_2mortal (newSViv (flags)));	2204	PUSHs (sv_2mortal (newSViv (flags)));
2006		2205
2007	if (GIMME_V == G_ARRAY)	2206	if (GIMME_V == G_ARRAY)
…		…
2011	PUSHs (sv_2mortal (newSViv (ny)));	2210	PUSHs (sv_2mortal (newSViv (ny)));
2012	}	2211	}
2013	}	2212	}
2014		2213
2015	void	2214	void
2016	at (mapstruct *map, unsigned int x, unsigned int y)	2215	at (maptile *map, unsigned int x, unsigned int y)
2017	PROTOTYPE: $$$	2216	PROTOTYPE: $$$
2018	PPCODE:	2217	PPCODE:
2019	{	2218	{
2020	object *o;	2219	object *o;
2021	mapstruct *nmap = 0;	2220	maptile *nmap = 0;
2022	I16 nx, ny;	2221	I16 nx, ny;
2023		2222
2024	cf_map_get_flags (map, &nmap, x, y, &nx, &ny);	2223	get_map_flags (map, &nmap, x, y, &nx, &ny);
2025		2224
2026	if (nmap)	2225	if (nmap)
2027	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)
2028	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));	2227	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));
2029	}	2228	}
2030		2229
2031	SV *	2230	SV *
2032	bot_at (mapstruct *obj, unsigned int x, unsigned int y)	2231	bot_at (maptile *obj, unsigned int x, unsigned int y)
2033	PROTOTYPE: $$$	2232	PROTOTYPE: $$$
2034	ALIAS:	2233	ALIAS:
2035	top_at = 1	2234	top_at = 1
2036	flags_at = 2	2235	flags_at = 2
2037	light_at = 3	2236	light_at = 3
2038	move_block_at = 4	2237	move_block_at = 4
2039	move_slow_at = 5	2238	move_slow_at = 5
2040	move_on_at = 6	2239	move_on_at = 6
2041	move_off_at = 7	2240	move_off_at = 7
2042	INIT:	2241	INIT:
2043	if (x >= MAP_WIDTH (obj) \|\| y >= MAP_HEIGHT (obj)) XSRETURN_UNDEF;	2242	if (x >= obj->width \|\| y >= obj->height) XSRETURN_UNDEF;
2044	CODE:	2243	CODE:
2045	switch (ix)	2244	switch (ix)
2046	{	2245	{
2047	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;
2048	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;
…		…
2051	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;
2052	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;
2053	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;
2054	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;
2055	}	2254	}
2056	OUTPUT:	2255	OUTPUT: RETVAL
2057	RETVAL
2058		2256
2059	# "serialise" map perl data into a ref	2257	void fix_walls (maptile *map, int x, int y)
2060	void	2258
2061	_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	)
2062	PPCODE:	2302	CODE:
2063	{	2303	{
2064	object *o;	2304	random_map_params rmp;
2065	int x, y;
2066	AV *obs = newAV ();
2067	int nonnull = 0;
2068		2305
2069	for (y = 0; y < MAP_HEIGHT (map); y++)	2306	assign (rmp.wallstyle , wallstyle);
2070	for (x = 0; x < MAP_WIDTH (map); x++)	2307	assign (rmp.wall_name , wall_name);
2071	{	2308	assign (rmp.floorstyle , floorstyle);
2072	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);
2073		2316
2074	for (o = GET_MAP_OB (map, x, y); o; o = o->above)	2317	rmp.origin_map = origin_map;
2075	{	2318	rmp.final_map = final_map;
2076	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;
2077		2343
2078	if (sv && HvFILL (SvRV (sv)))	2344	RETVAL = self->generate_random_map (&rmp);
2079	{
2080	nonnull = 1;
2081	sv = newSVsv (sv);
2082	}
2083	else
2084	sv = &PL_sv_undef;
2085
2086	av_push (av, sv);
2087	}
2088
2089	av_store (obs, x + y * MAP_HEIGHT (map), newRV_noinc ((SV *)av));
2090	}
2091
2092	if (nonnull)
2093	XPUSHs (sv_2mortal (newRV_noinc ((SV *)obs)));
2094	else
2095	SvREFCNT_dec (obs);
2096	}	2345	}
2097
2098	# "deserialise" perl map data into the map
2099	void
2100	_set_obs (mapstruct map, SV sv)
2101	CODE:
2102	{
2103	object *o;
2104	AV *av;
2105	int x, y;
2106	AV obs = (AV )SvRV (sv);
2107
2108	for (y = 0; y < MAP_HEIGHT (map); y++)
2109	for (x = 0; x < MAP_WIDTH (map); x++)
2110	{
2111	sv = av_fetch (obs, x + y MAP_HEIGHT (map), 1);
2112
2113	if (!SvROK (sv))
2114	continue;
2115
2116	av = (AV *)SvRV (sv);
2117
2118	for (o = GET_MAP_OB (map, x, y); o; o = o->above)
2119	{
2120	sv = av_shift (av);
2121
2122	if (SvROK (sv))
2123	{
2124	sv_magic ((SV )SvRV (sv), 0, PERL_MAGIC_ext, (char )o, 0);
2125	SVptr_cache_set (o, sv);
2126	}
2127	}
2128	}
2129	}
2130
2131
2132	MODULE = cf PACKAGE = cf::arch PREFIX = cf_archetype_
2133
2134	archetype *cf_archetype_get_first()
2135	PROTOTYPE:
2136	ALIAS: first = 0
2137
2138	archetype cf_archetype_get_next (archetype arch)
2139	ALIAS: next = 0
2140
2141	archetype cf_archetype_get_head (archetype arch)
2142	ALIAS: head = 0
2143
2144	archetype cf_archetype_get_more (archetype arch)
2145	ALIAS: more = 0
2146
2147	const char cf_archetype_get_name (archetype arch)
2148	ALIAS: name = 0
2149
2150	object cf_archetype_get_clone (archetype arch)
2151	ALIAS: clone = 0
2152
2153	MODULE = cf PACKAGE = cf::party PREFIX = cf_party_
2154
2155	partylist *cf_party_get_first ()
2156	PROTOTYPE:
2157	ALIAS: first = 0
2158
2159	partylist cf_party_get_next (partylist party)
2160	ALIAS: next = 0
2161
2162	const char cf_party_get_name (partylist party)
2163
2164	const char cf_party_get_password (partylist party)
2165	ALIAS: password = 0
2166
2167	player cf_party_get_first_player (partylist party)
2168	ALIAS: first_player = 0
2169
2170	player cf_party_get_next_player (partylist party, player *op)
2171	ALIAS: next_player = 0
2172
2173
2174	MODULE = cf PACKAGE = cf::region PREFIX = cf_region_
2175
2176	region *cf_region_get_first ()
2177	PROTOTYPE:
2178	ALIAS: first = 0
2179
2180	const char cf_region_get_name (region reg)
2181	ALIAS: name = 0
2182
2183	region cf_region_get_next (region reg)
2184	ALIAS: next = 0
2185
2186	region cf_region_get_parent (region reg)
2187	ALIAS: parent = 0
2188
2189	const char cf_region_get_longname (region reg)
2190	ALIAS: longname = 0
2191
2192	const char cf_region_get_message (region reg)
2193	ALIAS: message = 0
2194
2195
2196	MODULE = cf PACKAGE = cf::living PREFIX = cf_living_
2197
2198	val64
2199	exp (living *liv, val64 new_val = 0)
2200	PROTOTYPE: $;$
2201	ALIAS:
2202	Str = 1
2203	Dex = 2
2204	Con = 3
2205	Wis = 4
2206	Cha = 5
2207	Int = 6
2208	Pow = 7
2209	wc = 8
2210	ac = 9
2211	hp = 10
2212	maxhp = 11
2213	sp = 12
2214	maxsp = 13
2215	grace = 14
2216	maxgrace = 15
2217	food = 16
2218	dam = 17
2219	luck = 18
2220	CODE:
2221	# define LIVING_ACC(acc,idx) case idx: RETVAL = liv->acc; if (items > 1) liv->acc = (sint64)new_val; break
2222	switch (ix)
2223	{
2224	LIVING_ACC (exp , 0);
2225	LIVING_ACC (Str , 1);
2226	LIVING_ACC (Dex , 2);
2227	LIVING_ACC (Con , 3);
2228	LIVING_ACC (Wis , 4);
2229	LIVING_ACC (Cha , 5);
2230	LIVING_ACC (Int , 6);
2231	LIVING_ACC (Pow , 7);
2232	LIVING_ACC (wc , 8);
2233	LIVING_ACC (ac , 9);
2234	LIVING_ACC (hp , 10);
2235	LIVING_ACC (maxhp , 11);
2236	LIVING_ACC (sp , 12);
2237	LIVING_ACC (maxsp , 13);
2238	LIVING_ACC (grace , 14);
2239	LIVING_ACC (maxgrace, 15);
2240	LIVING_ACC (food , 16);
2241	LIVING_ACC (dam , 17);
2242	LIVING_ACC (luck , 18);
2243	}
2244	# undef LIVING_ACC
2245	OUTPUT:	2346	OUTPUT:
2246	RETVAL	2347	RETVAL
2247		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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.1 by root, Tue Aug 15 17:10:46 2006 UTC vs. Revision 1.160 by elmex, Wed Jan 31 14:11:02 2007 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.1 by root, Tue Aug 15 17:10:46 2006 UTC vs.
Revision 1.160 by elmex, Wed Jan 31 14:11:02 2007 UTC