ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/cfperl.xs

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.2 by root, Tue Aug 15 18:07:25 2006 UTC vs.
Revision 1.154 by root, Fri Jan 26 21:44:11 2007 UTC

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

Diff Legend

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