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.1 by root, Tue Aug 15 17:10:46 2006 UTC vs.
Revision 1.425 by root, Wed Nov 14 06:21:39 2012 UTC

1	/*****************************************************************************/
2	/* CrossFire, A Multiplayer game for the X Window System */
3	/*****************************************************************************/
4
5	/*	1	/*
6	* This code is placed under the GNU General Public Licence (GPL)	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
7	*	3	*
8	* Copyright (C) 2001-2005 by Chachkoff Yann	4	* Copyright (©) 2006,2007,2008,2009,2010,2012 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
9	* Copyright (C) 2006 by Marc Lehmann <cf@schmorpd.e>	5	*
10	*
11	* This program is free software; you can redistribute it and/or modify	6	* Deliantra is free software: you can redistribute it and/or modify it under
12	* it under the terms of the GNU General Public License as published by	7	* the terms of the Affero GNU General Public License as published by the
13	* the Free Software Foundation; either version 2 of the License, or	8	* Free Software Foundation, either version 3 of the License, or (at your
14	* (at your option) any later version.	9	* option) any later version.
15	*	10	*
16	* This program is distributed in the hope that it will be useful,	11	* This program is distributed in the hope that it will be useful,
17	* but WITHOUT ANY WARRANTY; without even the implied warranty of	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19	* GNU General Public License for more details.	14	* GNU General Public License for more details.
20	*	15	*
21	* You should have received a copy of the GNU General Public License	16	* You should have received a copy of the Affero GNU General Public License
22	* along with this program; if not, write to the Free Software	17	* and the GNU General Public License along with this program. If not, see
23	* Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA	18	* <http://www.gnu.org/licenses/>.
		19	*
		20	* The authors can be reached via e-mail to <support@deliantra.net>
24	*/	21	*/
		22
		23	#include "autoconf.h"
		24
		25	#if HAVE_EXECINFO_H
		26	# include <execinfo.h>
		27	#endif
		28
		29	#include <cstdarg>
		30	#include <typeinfo>
		31
		32	#include "global.h"
		33	#include "rmg.h"
		34	#include "noise.h"
		35	#include "evthread.h"
		36	#include "sproto.h"
		37
		38	#include <unistd.h>
		39	#if _POSIX_MEMLOCK
		40	# include <sys/mman.h>
		41	#endif
		42
		43	#if HAVE_MALLOC_H
		44	# include <malloc.h>
		45	#endif
		46
		47	#if !__GLIBC__
		48	# define malloc_trim(pad) -1
		49	#endif
25		50
26	#include <EXTERN.h>	51	#include <EXTERN.h>
27	#include <perl.h>	52	#include <perl.h>
28	#include <XSUB.h>	53	#include <XSUB.h>
29		54
30	#undef save_long // clashes with libproto.h	55	#include "CoroAPI.h"
		56	#include "perlxsi.c"
31		57
32	#define PLUGIN_NAME "perl"	58	typedef object_thawer &object_thawer_ref;
33	#define PLUGIN_VERSION "cfperl 0.3"	59	typedef object_freezer &object_freezer_ref;
34		60
35	#ifndef __CEXTRACT__	61	typedef std::string std__string;
36	#include <plugin.h>	62
		63	static PerlInterpreter *perl;
		64
		65	tstamp NOW, runtime;
		66
		67	static int tick_inhibit;
		68	static int tick_pending;
		69
		70	global gbl_ev;
		71	static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map;
		72	static SV *sv_runtime, *sv_tick_start, *sv_next_tick, *sv_now, *sv_server_tick;
		73	static AV *av_reflect;
		74
		75	bitset<NUM_EVENT_TYPES> ev_want_event;
		76	bitset<NUM_TYPES> ev_want_type;
		77
		78	static HV
		79	*stash_cf,
		80	*stash_cf_object_wrap,
		81	*stash_cf_object_player_wrap,
		82	*stash_cf_player_wrap,
		83	*stash_cf_map_wrap,
		84	*stash_cf_mapspace_wrap,
		85	*stash_cf_client_wrap,
		86	*stash_cf_arch_wrap,
		87	*stash_cf_party_wrap,
		88	*stash_cf_region_wrap,
		89	*stash_cf_living_wrap,
		90	*stash_cf_layout_wrap,
		91	*stash_ext_map_world;
		92
		93	static SV
		94	*cv_cf_do_invoke,
		95	*cv_cf__can_merge,
		96	*cv_cf_client_send_msg,
		97	*cv_cf_ix,
		98	*cv_cf_tick,
		99	*cv_cf_match_match;
		100
		101	#ifndef newSVpv_utf8
		102	static SV *
		103	newSVpv_utf8 (const char *s)
		104	{
		105	if (!s)
		106	return newSV (0);
		107
		108	SV *sv = newSVpv (s, 0);
		109	SvUTF8_on (sv);
		110	return sv;
		111	}
37	#endif	112	#endif
38		113
39	#undef MODULEAPI	114	#ifndef newSVpvn_utf8
40	#ifdef WIN32	115	static SV *
41	#else	116	newSVpvn_utf8 (const char *s, STRLEN l, int utf8)
42	#define MODULEAPI	117	{
		118	if (!s)
		119	return newSV (0);
		120
		121	SV *sv = newSVpvn (s, l);
		122
		123	if (utf8)
		124	SvUTF8_on (sv);
		125
		126	return sv;
		127	}
43	#endif	128	#endif
44		129
45	#include <plugin_common.h>	130	noinline utf8_string
46	#include <sounds.h>	131	cfSvPVutf8_nolen (SV *sv)
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	{	132	{
77	object* who;	133	SvGETMAGIC (sv);
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		134
90	static HV *obj_cache;	135	if (SvPOK (sv))
91	static PerlInterpreter *perl;	136	{
		137	if (!SvUTF8 (sv))
		138	sv_utf8_upgrade_nomg (sv);
92		139
93	#define PUSHcfapi(type,value) PUSHs (sv_2mortal (newSVcfapi (CFAPI_ ## type, (value))))	140	return SvPVX (sv);
94	#define PUSHcfapi_va(type,ctype) PUSHcfapi (type, va_arg (args, ctype))	141	}
95	#define PUSH_OB PUSHcfapi_va(POBJECT, object *)	142
96	#define PUSH_PL PUSHcfapi_va(PPLAYER, player *)	143	return SvPV_nolen (sv);
97	#define PUSH_MAP PUSHcfapi_va(PMAP, mapstruct *)	144	}
98	#define PUSH_PV PUSHcfapi_va(STRING, const char *)	145
99	#define PUSH_IV PUSHs (sv_2mortal (newSViv (va_arg (args, int))))	146	// helper cast function, returns super class * or 0
		147	template<class super>
		148	static super *
		149	is_a (attachable *at)
		150	{
		151	//return dynamic_cast<super *>(at); // slower, safer
		152	if (typeid (*at) == typeid (super))
		153	return static_cast<super *>(at);
		154	else
		155	return 0;
		156	}
100		157
101	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	158	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
102		159
103	// garbage collect some perl objects, if possible	160	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		161
111	if (++count & 7)	162	attachable::~attachable ()
		163	{
		164	assert (!self);
		165	assert (!cb);
		166	}
		167
		168	int
		169	attachable::refcnt_cnt () const
		170	{
		171	return refcnt + (self ? SvREFCNT (self) - 1 : 0);
		172	}
		173
		174	void
		175	attachable::sever_self ()
		176	{
		177	if (HV *self = this->self)
		178	{
		179	// keep a refcount because sv_unmagic might call attachable_free,
		180	// which might clear self, causing sv_unmagic to crash on a now
		181	// invalid object.
		182	SvREFCNT_inc (self);
		183	hv_clear (self);
		184	sv_unmagic ((SV *)self, PERL_MAGIC_ext);
		185	SvREFCNT_dec (self);
		186
		187	// self *must* be null now because that's sv_unmagic's job.
		188	assert (!this->self);
		189	}
		190	}
		191
		192	void
		193	attachable::optimise ()
		194	{
		195	if (self
		196	&& SvREFCNT (self) == 1
		197	&& !HvTOTALKEYS (self))
		198	sever_self ();
		199	}
		200
		201	// check wether the object really is dead
		202	void
		203	attachable::do_check ()
		204	{
		205	if (refcnt_cnt () > 0)
112	return;	206	return;
113		207
114	int todo = 1000;	208	destroy ();
115	do	209	}
		210
		211	void
		212	attachable::do_destroy ()
		213	{
		214	INVOKE_ATTACHABLE (DESTROY, this);
		215
		216	if (cb)
116	{	217	{
117	I32 klen;	218	SvREFCNT_dec (cb);
118	char *key;	219	cb = 0;
119	HE *he = hv_iternext (obj_cache);	220	}
120		221
121	if (he)	222	mortals.push_back (this);
		223	}
		224
		225	void
		226	attachable::destroy ()
		227	{
		228	if (destroyed ())
		229	return;
		230
		231	attachable_flags |= F_DESTROYED;
		232	do_destroy ();
		233	sever_self ();
		234	}
		235
		236	void
		237	attachable::do_delete ()
		238	{
		239	delete this;
		240	}
		241
		242	void
		243	attachable::check_mortals ()
		244	{
		245	static int i = 0;
		246
		247	for (;;)
		248	{
		249	if (i >= mortals.size ())
122	{	250	{
123	SV *sv = hv_iterval (obj_cache, he);	251	i = 0;
124		252
125	// empty and unreferenced? nuke it	253	if (mortals.size () >= 512)
126	if (SvREFCNT (sv) == 1 && SvREFCNT (SvRV (sv)) == 1 && !HvFILL ((HV *)(SvRV (sv))))
127	{	254	{
128	hv_delete (obj_cache, HeKEY (he), HeKLEN (he), G_DISCARD);	255	static int last_mortalcount;
129	todo++;	256	if (mortals.size () != last_mortalcount)
		257	{
		258	last_mortalcount = mortals.size ();
		259	object *specimen = is_a<object> (mortals [rndm (mortals.size ())]);
		260
		261	LOG (llevInfo, "%d mortals (random specimen: %s).\n",
		262	(int)mortals.size (), specimen ? specimen->debug_desc () : "(not an object)");
		263
		264	if (0)
		265	{
		266	for (int j = 0; j < mortals.size (); ++j)//D
		267	fprintf (stderr, "%d:%s %p ", j, &((object *)mortals[j])->name, mortals[j]);//D
		268
		269	fprintf (stderr, "\n");//D
		270	}
		271	}
130	}	272	}
		273
		274	break;
		275	}
		276
		277	attachable *obj = mortals [i];
		278
		279	#if 0
		280	if (obj->self)//D make this an assert later
		281	{
		282	LOG (llevError, "check_mortals: object '%s' still has self\n", typeid (obj).name ());
		283	obj->sever_self ();
		284	}
		285	#endif
		286
		287	if (obj->refcnt)
		288	{
		289	++i; // further delay freeing
		290
		291	if (!(i & 0x3ff))
		292	break;
131	}	293	}
132	else	294	else
133	break;
134	}
135	while (--todo);
136	}
137
138	static SV *
139	newSVptr (void *ptr, const char *klass)
140	{
141	SV *sv;
142
143	if (!ptr)
144	return &PL_sv_undef;
145
146	sv = newSV (0);
147	sv_magic (sv, 0, PERL_MAGIC_ext, (char *)ptr, 0);
148	return sv_bless (newRV_noinc (sv), gv_stashpv (klass, 1));
149	}
150
151	static void
152	SVptr_cache_set (void *ptr, SV *sv)
153	{
154	hv_store (obj_cache, (char *)&ptr, sizeof (ptr), sv, 0);
155	}
156
157	static SV *
158	SVptr_cache_get (void *ptr)
159	{
160	SV **he = hv_fetch (obj_cache, (char *)&ptr, sizeof (ptr), 0);
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;
172
173	sv = SVptr_cache_get (ptr);
174
175	if (!sv)
176	{
177	HV *hv = newHV ();
178	sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0);
179	sv = sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));
180
181	SVptr_cache_set (ptr, sv);
182	}
183
184	return newSVsv (sv);
185	}
186
187	static void
188	clearSVptr (SV *sv)
189	{
190	if (SvROK (sv))
191	sv = SvRV (sv);
192
193	hv_clear ((HV *)sv);
194	sv_unmagic (sv, PERL_MAGIC_ext);
195	}
196
197	static long
198	SvPTR (SV *sv, const char *klass)
199	{
200	if (!sv_derived_from (sv, klass))
201	croak ("object of type %s expected", klass);
202
203	MAGIC *mg = mg_find (SvRV (sv), PERL_MAGIC_ext);
204
205	if (!mg)
206	croak ("perl code used %s object, but C object is already destroyed, caught", klass);
207
208	return (long)mg->mg_ptr;
209	}
210
211	static long
212	SvPTR_ornull (SV *sv, const char *klass)
213	{
214	if (SvOK (sv))
215	return SvPTR (sv, klass);
216	else
217	return 0;
218	}
219
220	static SV *
221	newSVcfapi (int type, ...)
222	{
223	SV *sv;
224
225	va_list args;
226	va_start (args, type);
227
228	switch (type)
229	{
230	#if 0
231	case CFAPI_INT16:
232	sv = newSViv (*va_arg (args, sint16_t *));
233	break;
234	#endif
235
236	case CFAPI_INT:
237	sv = newSViv (*va_arg (args, int *));
238	break;
239
240	case CFAPI_LONG:
241	sv = newSVval64 ((val64)*va_arg (args, sint64 *));
242	break;
243
244	case CFAPI_DOUBLE:
245	sv = newSVnv (*va_arg (args, double *));
246	break;
247
248	case CFAPI_STRING:
249	{	295	{
250	char *str = va_arg (args, char *);	296	mortals.erase (i);
251	sv = str ? newSVpv (str, 0) : &PL_sv_undef;	297	obj->sever_self ();
252	}	298	obj->do_delete ();
253	break;
254
255	case CFAPI_POBJECT:
256	{
257	object *obj = va_arg (args, object *);
258
259	if (!obj)
260	sv = &PL_sv_undef;
261	else
262	switch (obj->type)
263	{
264	case MAP:
265	sv = newSVptr_cached (obj, "cf::object::map::wrap");
266	break;
267
268	case PLAYER:
269	sv = newSVptr_cached (obj, "cf::object::player::wrap");
270	break;
271
272	default:
273	sv = newSVptr_cached (obj, "cf::object::wrap");
274	break;
275	}
276	}
277	break;
278
279	case CFAPI_PMAP:
280	sv = newSVptr (va_arg (args, mapstruct *), "cf::map::wrap");
281	break;
282
283	case CFAPI_PPLAYER:
284	sv = newSVptr (va_arg (args, player *), "cf::player::wrap");
285	break;
286
287	case CFAPI_PARCH:
288	sv = newSVptr (va_arg (args, archetype *), "cf::arch::wrap");
289	break;
290
291	case CFAPI_PPARTY:
292	sv = newSVptr (va_arg (args, partylist *), "cf::party::wrap");
293	break;
294
295	case CFAPI_PREGION:
296	sv = newSVptr (va_arg (args, region *), "cf::region::wrap");
297	break;
298
299	default:
300	assert (("unhandled type in newSVcfapi", 0));
301	}
302
303	va_end (args);
304
305	return sv;
306	}
307
308	/////////////////////////////////////////////////////////////////////////////
309
310	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
311	{
312	gethook = gethooksptr;
313	printf (PLUGIN_VERSION " init\n");
314
315	return 0;
316	}
317
318	static CommArray_s rtn_cmd;
319
320	static int
321	runPluginCommand (object *obj, char *params)
322	{
323	dSP;
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	}
352
353	extern "C" void *cfperl_getPluginProperty (int *type, ...)
354	{
355	va_list args;
356	char *propname;
357	int i;
358	va_start (args, type);
359	propname = va_arg (args, char *);
360	//printf ("Property name: %s\n", propname);
361
362	if (!strcmp (propname, "command?"))
363	{
364	if (!perl)
365	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	}	299	}
382	}	300	}
383	else if (!strcmp (propname, "Identification"))	301	}
		302
		303	void
		304	attachable::set_key (const char *key, const char *value, bool is_utf8)
		305	{
		306	if (!self)
		307	self = newHV ();
		308
		309	if (value)
		310	hv_store (self, key, strlen (key), is_utf8 ? newSVpv_utf8 (value) : newSVpv (value, 0), 0);
		311	else
		312	hv_delete (self, key, strlen (key), G_DISCARD);
		313	}
		314
		315	attachable &
		316	attachable::operator =(const attachable &src)
		317	{
		318	//if (self || cb)
		319	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));
		320
		321	attach = src.attach;
		322	return *this;
		323	}
		324
		325	#if 0
		326	template<typename T>
		327	static bool
		328	find_backref (void *ptr, T *obj)
		329	{
		330	char *s = (char *)obj;
		331	while (s < (char *)obj + sizeof (T))
384	{	332	{
385	va_end (args);	333	if (ptr == *(void **)s)
386	return (void*) PLUGIN_NAME;	334	return true;
		335
		336	s += sizeof (void *); // assume natural alignment
387	}	337	}
388	else if (!strcmp (propname, "FullName"))	338
		339	return false;
		340	}
		341
		342	// for debugging, find "live" objects containing this ptr
		343	static void
		344	find_backref (void *ptr)
		345	{
		346	for_all_objects (op)
		347	if (find_backref (ptr, op))
		348	fprintf (stderr, "O %p %d:'%s'\n", op, op->count, &op->name);
		349
		350	for_all_players (pl)
		351	if (find_backref (ptr, pl))
		352	fprintf (stderr, "P %p\n", pl);
		353
		354	for_all_clients (ns)
		355	if (find_backref (ptr, ns))
		356	fprintf (stderr, "C %p\n", ns);
		357	}
		358	#endif
		359
		360	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		361
		362	static SV *
		363	newSVptr (void *ptr, HV *stash, HV *hv)
		364	{
		365	if (!ptr)
		366	return newSV (0);
		367
		368	sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);
		369	return sv_bless (newRV_noinc ((SV *)hv), stash);
		370	}
		371
		372	static SV * noinline
		373	newSVptr (void *ptr, HV *stash)
		374	{
		375	return newSVptr (ptr, stash, newHV ());
		376	}
		377
		378	static int
		379	attachable_free (pTHX_ SV *sv, MAGIC *mg)
		380	{
		381	attachable *at = (attachable *)mg->mg_ptr;
		382
		383	//TODO: check if transaction behaviour is really required here
		384	if (SV *self = (SV *)at->self)
389	{	385	{
390	va_end (args);	386	at->self = 0;
391	return (void*) PLUGIN_VERSION;	387	SvREFCNT_dec (self);
392	}	388	}
393	else
394	va_end (args);
395		389
		390	// next line makes sense, but most objects still have refcnt 0 by default
		391	//at->refcnt_chk ();
396	return NULL;	392	return 0;
397	}	393	}
398		394
399	extern "C" int cfperl_postInitPlugin ()	395	MGVTBL attachable::vtbl = {0, 0, 0, 0, attachable_free};
400	{
401	int hooktype = 1;
402	int rtype = 0;
403		396
404	printf (PLUGIN_VERSION " post init\n");	397	static SV * noinline
		398	newSVattachable (attachable *obj, HV *stash)
		399	{
		400	if (!obj)
		401	return newSV (0);
405		402
406	registerGlobalEvent = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_system_register_global_event");	403	if (!obj->self)
407	unregisterGlobalEvent = (void* (*)(int*, ...)) gethook (&rtype, hooktype, "cfapi_system_unregister_global_event");	404	obj->self = newHV ();
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		405
413	cf_init_plugin (gethook);	406	if (!SvOBJECT (obj->self))
414
415	/* Pick the global events you want to monitor from this plugin */
416	registerGlobalEvent (NULL, EVENT_BORN, PLUGIN_NAME, globalEventListener);
417	registerGlobalEvent (NULL, EVENT_CLOCK, PLUGIN_NAME, globalEventListener);
418	//registerGlobalEvent (NULL, EVENT_CRASH, PLUGIN_NAME, globalEventListener);
419	registerGlobalEvent (NULL, EVENT_FIND_UNARMED_SKILL, PLUGIN_NAME, globalEventListener);
420	registerGlobalEvent (NULL, EVENT_PLAYER_USE_SKILL, PLUGIN_NAME, globalEventListener);
421	registerGlobalEvent (NULL, EVENT_CAST_SPELL, PLUGIN_NAME, globalEventListener);
422	registerGlobalEvent (NULL, EVENT_MONSTER_USE_SKILL, PLUGIN_NAME, globalEventListener);
423	registerGlobalEvent (NULL, EVENT_PLAYER_DEATH, PLUGIN_NAME, globalEventListener);
424	registerGlobalEvent (NULL, EVENT_GKILL, PLUGIN_NAME, globalEventListener);
425	registerGlobalEvent (NULL, EVENT_LOGIN, PLUGIN_NAME, globalEventListener);
426	registerGlobalEvent (NULL, EVENT_LOGOUT, PLUGIN_NAME, globalEventListener);
427	registerGlobalEvent (NULL, EVENT_MAPENTER, PLUGIN_NAME, globalEventListener);
428	registerGlobalEvent (NULL, EVENT_MAPLEAVE, PLUGIN_NAME, globalEventListener);
429	registerGlobalEvent (NULL, EVENT_MAPRESET, PLUGIN_NAME, globalEventListener);
430	registerGlobalEvent (NULL, EVENT_MAPLOAD, PLUGIN_NAME, globalEventListener);
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
444	char *argv[] = {
445	"",
446	"-e"
447	"BEGIN {"
448	" cf->bootstrap;"
449	" unshift @INC, cf::datadir ();"
450	"}"
451	""
452	"use cf;"
453	};
454
455	perl = perl_alloc ();
456	perl_construct (perl);
457
458	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
459
460	if (perl_parse (perl, xs_init, 2, argv, (char **)NULL) || perl_run (perl))
461	{	407	{
462	printf ("unable to initialize perl-interpreter, continuing without.\n");	408	sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char *)obj, 0);
463		409
464	perl_destruct (perl);	410	// now bless the object _once_
465	perl_free (perl);	411	//TODO: create a class registry with c++ type<=>perl name<=>stash and use it here and elsewhere
466	perl = 0;	412	return sv_bless (newRV_inc ((SV *)obj->self), stash);
467	}	413	}
468	else	414	else
469	{	415	{
470	obj_cache = newHV ();	416	SV *sv = newRV_inc ((SV *)obj->self);
		417
		418	if (Gv_AMG (stash)) // handle overload correctly, as the perl core does not
		419	SvAMAGIC_on (sv);
		420
		421	return sv;
471	}	422	}
472
473	return 0;
474	}	423	}
475		424
		425	#if 0 // unused
476	static void *	426	static void
477	globalEventListener (int *type, ...)	427	clearSVptr (SV *sv)
478	{	428	{
479	va_list args;	429	if (SvROK (sv))
480	static int rv;	430	sv = SvRV (sv);
481	int event_code;
482		431
483	if (!perl)	432	hv_clear ((HV *)sv);
484	return NULL;	433	sv_unmagic (sv, PERL_MAGIC_ext);
		434	}
		435	#endif
485		436
486	va_start (args, type);	437	static long
487	event_code = va_arg (args, int);	438	SvPTR_nc (SV *sv)
		439	{
		440	sv = SvRV (sv);
488		441
489	if (event_code == EVENT_FREE_OB)	442	// very important shortcut
		443	if (expect_true (SvMAGIC (sv) && SvMAGIC (sv)->mg_type == PERL_MAGIC_ext))
		444	return (long)SvMAGIC (sv)->mg_ptr;
		445
		446	if (MAGIC *mg = mg_find (sv, PERL_MAGIC_ext))
		447	return (long)mg->mg_ptr;
		448
		449	croak ("perl code used object, but C object is already destroyed, caught");
		450	}
		451
		452	static long
		453	SvPTR (SV *sv, const char *klass)
		454	{
		455	if (!sv_derived_from (sv, klass))
		456	croak ("object of type %s expected", klass);
		457
		458	return SvPTR_nc (sv);
		459	}
		460
		461	static long noinline
		462	SvPTR_ornull (SV *sv, const char *klass)
		463	{
		464	if (expect_false (!SvOK (sv))) return 0;
		465
		466	return SvPTR (sv, klass);
		467	}
		468
		469	static long noinline
		470	SvPTR_ornull_client (SV *sv)
		471	{
		472	if (expect_false (!SvOK (sv))) return 0;
		473
		474	if (!SvROK (sv)
		475	|| (SvSTASH (SvRV (sv)) != stash_cf_client_wrap
		476	&& !sv_derived_from (sv, "cf::client")))
		477	croak ("object of type cf::client expected");
		478
		479	return SvPTR_nc (sv);
		480	}
		481
		482	static long noinline
		483	SvPTR_ornull_object (SV *sv)
		484	{
		485	if (expect_false (!SvOK (sv))) return 0;
		486
		487	if (!SvROK (sv)
		488	|| (SvSTASH (SvRV (sv)) != stash_cf_object_wrap
		489	&& SvSTASH (SvRV (sv)) != stash_cf_object_player_wrap
		490	&& SvSTASH (SvRV (sv)) != stash_cf_arch_wrap
		491	&& !sv_derived_from (sv, "cf::object")))
		492	croak ("object of type cf::object expected");
		493
		494	return SvPTR_nc (sv);
		495	}
		496
		497	static long noinline
		498	SvPTR_ornull_maptile (SV *sv)
		499	{
		500	if (expect_false (!SvOK (sv))) return 0;
		501
		502	if (!SvROK (sv)
		503	|| (SvSTASH (SvRV (sv)) != stash_cf_map_wrap
		504	&& SvSTASH (SvRV (sv)) != stash_ext_map_world
		505	&& !sv_derived_from (sv, "cf::map")))
		506	croak ("object of type cf::map expected");
		507
		508	return SvPTR_nc (sv);
		509	}
		510
		511	static long noinline
		512	SvPTR_ornull_player (SV *sv)
		513	{
		514	if (expect_false (!SvOK (sv))) return 0;
		515
		516	if (!SvROK (sv)
		517	|| (SvSTASH (SvRV (sv)) != stash_cf_player_wrap
		518	&& !sv_derived_from (sv, "cf::player")))
		519	croak ("object of type cf::player expected");
		520
		521	return SvPTR_nc (sv);
		522	}
		523
		524	static inline SV *to_sv (const shstr & v) { return newSVpvn_utf8 ((const char *)v, v.length (), 1); }
		525	static inline SV *to_sv (const char * v) { return v ? newSVpv (v, 0) : newSV (0); }
		526	static inline SV *to_sv (bool v) { return newSViv (v); }
		527	static inline SV *to_sv ( signed char v) { return newSViv (v); }
		528	static inline SV *to_sv (unsigned char v) { return newSViv (v); }
		529	static inline SV *to_sv ( signed short v) { return newSViv (v); }
		530	static inline SV *to_sv (unsigned short v) { return newSVuv (v); }
		531	static inline SV *to_sv ( signed int v) { return newSViv (v); }
		532	static inline SV *to_sv (unsigned int v) { return newSVuv (v); }
		533	static inline SV *to_sv ( signed long v) { return newSViv (v); }
		534	static inline SV *to_sv (unsigned long v) { return newSVuv (v); }
		535	static inline SV *to_sv ( signed long long v) { return newSVval64 (v); }
		536	static inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }
		537	static inline SV *to_sv (float v) { return newSVnv (v); }
		538	static inline SV *to_sv (double v) { return newSVnv (v); }
		539	static inline SV *to_sv (client * v) { return newSVattachable (v, stash_cf_client_wrap); }
		540	static inline SV *to_sv (player * v) { return newSVattachable (v, stash_cf_player_wrap); }
		541	// gcc dislikes noilnine on to_sv
		542	static noinline SV *to_sv_ni (object * v) { return newSVattachable (v, v && v->type == PLAYER ? stash_cf_object_player_wrap : stash_cf_object_wrap); }
		543	static inline SV *to_sv (object * v) { return to_sv_ni (v); }
		544	static inline SV *to_sv (maptile * v) { return newSVattachable (v, stash_cf_map_wrap); }
		545	static inline SV *to_sv (archetype * v) { return newSVattachable (v, stash_cf_arch_wrap); }
		546	static inline SV *to_sv (region * v) { return newSVattachable (v, stash_cf_region_wrap); }
		547	static inline SV *to_sv (partylist * v) { return newSVptr (v, stash_cf_party_wrap); }
		548	static inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }
		549	static inline SV *to_sv (mapspace * v) { return newSVptr (v, stash_cf_mapspace_wrap); }
		550	static inline SV *to_sv (layout * v) { return newSVptr (v, stash_cf_layout_wrap); }
		551
		552	static inline SV *to_sv (object & v) { return to_sv (&v); }
		553	static inline SV *to_sv (living & v) { return to_sv (&v); }
		554
		555	static inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); }
		556	static inline SV *to_sv (const treasurelist *v) { return to_sv (v->name); }
		557
		558	static inline SV *to_sv (UUID v) { return newSVpv (v.c_str (), 0); }
		559
		560	static inline SV *to_sv (dynbuf * v)
		561	{
		562	SV *sv = newSV (0);
		563
		564	sv_upgrade (sv, SVt_PV);
		565	SvGROW (sv, v->size () + 1);
		566	SvPOK_only (sv);
		567	v->linearise (SvPVX (sv));
		568	SvCUR_set (sv, v->size ());
		569	*SvEND (sv) = 0;
		570
		571	return sv;
		572	}
		573
		574	static inline SV *to_sv (dynbuf_text * v)
		575	{
		576	SV *sv = to_sv (static_cast<dynbuf *> (v));
		577	SvUTF8_on (sv);
		578	return sv;
		579	}
		580
		581	static inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? cfSvPVutf8_nolen (sv) : 0; }
		582	static inline void sv_to (SV *sv, char * &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }
		583	static inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }
		584	static inline void sv_to (SV *sv, signed char &v) { v = SvIV (sv); }
		585	static inline void sv_to (SV *sv, unsigned char &v) { v = SvIV (sv); }
		586	static inline void sv_to (SV *sv, signed short &v) { v = SvIV (sv); }
		587	static inline void sv_to (SV *sv, unsigned short &v) { v = SvIV (sv); }
		588	static inline void sv_to (SV *sv, signed int &v) { v = SvIV (sv); }
		589	static inline void sv_to (SV *sv, unsigned int &v) { v = SvUV (sv); }
		590	static inline void sv_to (SV *sv, signed long &v) { v = SvIV (sv); }
		591	static inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }
		592	static inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }
		593	static inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }
		594	static inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
		595	static inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }
		596	static inline void sv_to (SV *sv, client * &v) { v = (client *) (attachable *)SvPTR_ornull_client (sv); }
		597	static inline void sv_to (SV *sv, player * &v) { v = (player *) (attachable *)SvPTR_ornull_player (sv); }
		598	static inline void sv_to (SV *sv, object * &v) { v = (object *) (attachable *)SvPTR_ornull_object (sv); }
		599	static inline void sv_to (SV *sv, maptile * &v) { v = (maptile *) (attachable *)SvPTR_ornull_maptile (sv); }
		600	static inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)(attachable *)SvPTR_ornull (sv, "cf::arch"); }
		601	static inline void sv_to (SV *sv, region * &v) { v = (region *) (attachable *)SvPTR_ornull (sv, "cf::region"); }
		602	static inline void sv_to (SV *sv, attachable * &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); }
		603	static inline void sv_to (SV *sv, partylist * &v) { v = (partylist *) SvPTR_ornull (sv, "cf::party"); }
		604	static inline void sv_to (SV *sv, living * &v) { v = (living *) SvPTR_ornull (sv, "cf::living"); }
		605	static inline void sv_to (SV *sv, mapspace * &v) { v = (mapspace *) SvPTR_ornull (sv, "cf::mapspace"); }
		606	static inline void sv_to (SV *sv, layout * &v) { v = (layout *) SvPTR_ornull (sv, "cf::layout"); }
		607	static inline void sv_to (SV *sv, object_freezer * &v) { v = (object_freezer *) SvPTR_ornull (sv, "cf::object::freezer"); }
		608	static inline void sv_to (SV *sv, object_thawer * &v) { v = (object_thawer *) SvPTR_ornull (sv, "cf::object::thawer" ); }
		609
		610	//static inline void sv_to (SV *sv, faceinfo * &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }
		611	static inline void sv_to (SV *sv, treasurelist * &v) { v = treasurelist::find (SvPV_nolen (sv)); }
		612
		613	template<class T>
		614	static inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }
		615
		616	template<int N>
		617	static inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); }
		618
		619	static inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); }
		620	static inline void sv_to (SV *sv, petmode_t &v) { v = (petmode_t) SvIV (sv); }
		621	static inline void sv_to (SV *sv, usekeytype &v) { v = (usekeytype) SvIV (sv); }
		622	static inline void sv_to (SV *sv, unapplymode &v) { v = (unapplymode) SvIV (sv); }
		623
		624	static inline void sv_to (SV *sv, std::string &v)
		625	{
		626	STRLEN len;
		627	char *data = SvPVbyte (sv, len);
		628	v.assign (data, len);
		629	}
		630
		631	static inline void sv_to (SV *sv, refcnt_buf &v)
		632	{
		633	STRLEN len;
		634	char *data = SvPVbyte (sv, len);
		635	refcnt_buf buf (data, len);
		636	v = buf;
		637	}
		638
		639	static inline void sv_to (SV *sv, UUID &v)
		640	{
		641	if (!v.parse (SvPV_nolen (sv)))
		642	croak ("unparsable uuid: %s", SvPV_nolen (sv));
		643	}
		644
		645	static inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }
		646
		647	static SV *
		648	newSVdt_va (va_list &ap, data_type type)
		649	{
		650	SV *sv;
		651
		652	switch (type)
490	{	653	{
491	player *pl;	654	case DT_INT:
492	object *op;	655	sv = newSViv (va_arg (ap, int));
493	SV *sv;	656	break;
494		657
495	op = va_arg (args, object *);	658	case DT_INT64:
496	sv = hv_delete (obj_cache, (char *)&op, sizeof (void *), 0);	659	sv = newSVval64 ((val64)va_arg (ap, sint64));
		660	break;
497		661
498	if (sv)	662	case DT_DOUBLE:
499	clearSVptr (sv);	663	sv = newSVnv (va_arg (ap, double));
		664	break;
500		665
501	rv = 0;	666	case DT_STRING:
		667	{
		668	char *str = (char *)va_arg (ap, const char *);
		669	sv = str ? newSVpv (str, 0) : newSV (0);
		670	}
		671	break;
		672
		673	case DT_DATA:
		674	{
		675	char *str = (char *)va_arg (ap, const void *);
		676	int len = va_arg (ap, int);
		677	sv = str ? newSVpv (str, len) : newSV (0);
		678	}
		679	break;
		680
		681	case DT_OBJECT:
		682	sv = to_sv (va_arg (ap, object *));
		683	break;
		684
		685	case DT_MAP:
		686	// va_arg (object *) when void * is passed is an XSI extension
		687	sv = to_sv (va_arg (ap, maptile *));
		688	break;
		689
		690	case DT_CLIENT:
		691	sv = to_sv (va_arg (ap, client *));
		692	break;
		693
		694	case DT_PLAYER:
		695	sv = to_sv (va_arg (ap, player *));
		696	break;
		697
		698	case DT_ARCH:
		699	sv = to_sv (va_arg (ap, archetype *));
		700	break;
		701
		702	case DT_PARTY:
		703	sv = to_sv (va_arg (ap, partylist *));
		704	break;
		705
		706	case DT_REGION:
		707	sv = to_sv (va_arg (ap, region *));
		708	break;
		709
		710	default:
		711	assert (("unhandled type in newSVdt_va", 0));
502	}	712	}
503	else if (event_code == EVENT_CLOCK)	713
		714	return sv;
		715	}
		716
		717	static SV *
		718	newSVdt (data_type type, ...)
		719	{
		720	va_list ap;
		721
		722	va_start (ap, type);
		723	SV *sv = newSVdt_va (ap, type);
		724	va_end (ap);
		725
		726	return sv;
		727	}
		728
		729	// typemap support, mostly to avoid excessive inlining
		730	template<class type>
		731	static void noinline
		732	cf_obj_to (SV *arg, type &var)
		733	{
		734	sv_to (arg, var);
		735	if (expect_false (!var))
		736	croak ("must not pass invalid/null cf_obj here");
		737	}
		738
		739	template<class object>
		740	static void noinline
		741	cf_obj_ornull_to (SV *arg, object *&var)
		742	{
		743	if (SvOK (arg))
504	{	744	{
505	dSP;	745	sv_to (arg, var);
506	int i, count;	746	if (expect_false (!var))
507		747	croak ("unable to convert perl object to C++ object");
508	clean_obj_cache ();
509
510	ENTER;
511	SAVETMPS;
512
513	// service up to 8 events per tick better would be
514	// to check for elapsed time and stop processing after
515	// 0.25 * server_tick or so
516	for (i = 9; --i; )
517	{
518	PUSHMARK (SP);
519	XPUSHs (sv_2mortal (newSViv (0)));
520	PUTBACK;
521	count = call_pv ("Event::one_event", G_SCALAR | G_EVAL);
522	SPAGAIN;
523
524	if (!count || !POPi)
525	break;
526	}
527
528	FREETMPS;
529	LEAVE;
530	}	748	}
531	else	749	else
		750	var = 0;
		751	}
		752
		753	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		754
		755	static SV *
		756	registry (attachable *ext)
		757	{
		758	if (!ext->cb)
		759	ext->cb = newAV ();
		760
		761	return newRV_inc ((SV *)ext->cb);
		762	}
		763
		764	/////////////////////////////////////////////////////////////////////////////
		765
		766	void
		767	cfperl_init ()
		768	{
		769	extern char **environ;
		770
		771	PERL_SYS_INIT3 (&settings.argc, &settings.argv, &environ);
		772	perl = perl_alloc ();
		773	perl_construct (perl);
		774
		775	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
		776
		777	const char *argv[] = {
		778	settings.argv [0],
		779	"-e0"
		780	};
		781
		782	if (perl_parse (perl, xs_init, 2, (char **)argv, environ)
		783	|| perl_run (perl))
532	{	784	{
		785	printf ("unable to initialize perl-interpreter, aborting.\n");
		786	exit (EXIT_FAILURE);
		787	}
		788
		789	eval_pv (
		790	"#line 1 'cfperl init'\n"
		791	"use EV ();\n" // required by bootstrap
		792	"use Coro ();\n" // required by bootstrap
		793	"cf->bootstrap;\n" // required for cf::datadir
		794	"unshift @INC, cf::datadir ();\n" // required for 'require' :)
		795	"require cf;\n",
		796	0
		797	);
		798
		799	if (SvTRUE (ERRSV))
		800	{
		801	printf ("unable to bootstrap perl, aborting:\n%s", SvPV_nolen (ERRSV));
		802	exit (EXIT_FAILURE);
		803	}
		804	}
		805
		806	void
		807	cfperl_main ()
		808	{
533	dSP;	809	dSP;
534		810
535	ENTER;
536	SAVETMPS;
537
538	PUSHMARK (SP);	811	PUSHMARK (SP);
		812	PUTBACK;
		813	call_pv ("cf::main", G_DISCARD | G_VOID);
		814	}
539		815
540	EXTEND (SP, 10);	816	void
541	PUSHs (sv_2mortal (newSViv (event_code)));	817	attachable::instantiate ()
		818	{
		819	if (attach)
		820	{
		821	INVOKE_ATTACHABLE (INSTANTIATE, this, ARG_STRING (attach));
		822	attach = 0;
		823	}
		824	}
542		825
543	switch (event_code)	826	void
		827	attachable::reattach ()
		828	{
		829	optimise ();
		830	//TODO: check for _attachment's, very important for restarts
		831	INVOKE_ATTACHABLE (REATTACH, this);
		832	}
		833
		834	static event_klass klass_of[NUM_EVENT_TYPES] = {
		835	# define def(type,name) KLASS_ ## type,
		836	# include "eventinc.h"
		837	# undef def
		838	};
		839
		840	#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)
		841
		842	static void noinline
		843	gather_callbacks (AV *&callbacks, AV *registry, event_type event)
		844	{
		845	// event must be in array
		846	if (event >= 0 && event <= AvFILLp (registry))
		847	{
		848	SV *cbs_ = AvARRAY (registry)[event];
		849
		850	// element must be list of callback entries
		851	if (cbs_ && SvROK (cbs_) && SvTYPE (SvRV (cbs_)) == SVt_PVAV)
544	{	852	{
545	case EVENT_CRASH:	853	AV *cbs = (AV *)SvRV (cbs_);
546	break;
547		854
548	case EVENT_PLAYER_LOAD:	855	// no callback entries, no callbacks to call
549	case EVENT_PLAYER_SAVE:	856	if (AvFILLp (cbs) >= 0)
550	PUSH_OB;
551	PUSH_PV;
552	break;
553
554	case EVENT_MAPLOAD:
555	case EVENT_MAPOUT:
556	case EVENT_MAPIN:
557	case EVENT_MAPCLEAN:
558	case EVENT_MAPRESET:
559	PUSH_MAP;
560	break;
561
562	case EVENT_MAPENTER:
563	case EVENT_MAPLEAVE:
564	case EVENT_BORN:
565	case EVENT_REMOVE:
566	case EVENT_PLAYER_DEATH:
567	PUSH_OB;
568	break;
569
570	case EVENT_GKILL:
571	PUSH_OB;
572	PUSH_OB;
573	break;
574
575	case EVENT_LOGIN:
576	case EVENT_LOGOUT:
577	PUSH_PL;
578	PUSH_PV;
579	break;
580
581	case EVENT_SHOUT:
582	case EVENT_MUZZLE:
583	case EVENT_KICK:
584	PUSH_OB;
585	PUSH_PV;
586	break;
587
588	case EVENT_FIND_UNARMED_SKILL:
589	PUSH_OB;
590	break;
591
592	case EVENT_PLAYER_USE_SKILL:
593	case EVENT_MONSTER_USE_SKILL:
594	case EVENT_CAST_SPELL:
595	PUSH_OB;
596	PUSH_OB;
597	PUSH_OB;
598	PUSH_IV;
599	PUSH_PV;
600	break;
601
602	case EVENT_EXTCMD:
603	PUSH_PL;
604	{	857	{
605	char *buf = va_arg (args, char *);	858	if (!callbacks)
606	int len = va_arg (args, int);	859	{
607	PUSHs (sv_2mortal (newSVpvn (buf, len)));	860	callbacks = newAV ();
		861	av_extend (callbacks, 16);
		862	}
		863
		864	// never use SvREFCNT_inc to copy values, but its ok here :)
		865	for (int i = 0; i <= AvFILLp (cbs); ++i)
		866	av_push (callbacks, SvREFCNT_inc (AvARRAY (cbs)[i]));
608	}	867	}
609	break;
610
611	case EVENT_TELL:
612	break;
613	}	868	}
614
615	va_end (args);
616
617	PUTBACK;
618	int count = call_pv ("cf::inject_global_event", G_SCALAR | G_EVAL);
619	SPAGAIN;
620
621	if (SvTRUE (ERRSV))
622	LOG (llevError, "global event '%d' callback evaluation error: %s", event_code, SvPV_nolen (ERRSV));
623
624	rv = count > 0 ? POPi : 0;
625
626	PUTBACK;
627	FREETMPS;
628	LEAVE;
629	}	869	}
		870	}
630		871
		872	void
		873	attachable::gather_callbacks (AV *&callbacks, event_type event) const
		874	{
		875	::gather_callbacks (callbacks, cb_attachable, event);
		876
		877	if (cb)
		878	::gather_callbacks (callbacks, cb, event);
		879	}
		880
		881	void
		882	global::gather_callbacks (AV *&callbacks, event_type event) const
		883	{
		884	::gather_callbacks (callbacks, cb_global, event);
		885	}
		886
		887	void
		888	object::gather_callbacks (AV *&callbacks, event_type event) const
		889	{
		890	if (subtype && type + subtype * NUM_TYPES <= AvFILLp (cb_type))
		891	{
		892	SV *registry = AvARRAY (cb_type)[type + subtype * NUM_TYPES];
		893
		894	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
		895	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);
		896	}
		897
		898	if (type <= AvFILLp (cb_type))
		899	{
		900	SV *registry = AvARRAY (cb_type)[type];
		901
		902	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
		903	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);
		904	}
		905
		906	attachable::gather_callbacks (callbacks, event);
		907	::gather_callbacks (callbacks, cb_object, event);
		908	}
		909
		910	void
		911	archetype::gather_callbacks (AV *&callbacks, event_type event) const
		912	{
		913	attachable::gather_callbacks (callbacks, event);
		914	//TODO//::gather_callbacks (callbacks, cb_archetype, event);
		915	}
		916
		917	void
		918	client::gather_callbacks (AV *&callbacks, event_type event) const
		919	{
		920	attachable::gather_callbacks (callbacks, event);
		921	::gather_callbacks (callbacks, cb_client, event);
		922	}
		923
		924	void
		925	player::gather_callbacks (AV *&callbacks, event_type event) const
		926	{
		927	attachable::gather_callbacks (callbacks, event);
		928	::gather_callbacks (callbacks, cb_player, event);
		929	}
		930
		931	void
		932	maptile::gather_callbacks (AV *&callbacks, event_type event) const
		933	{
		934	attachable::gather_callbacks (callbacks, event);
		935	::gather_callbacks (callbacks, cb_map, event);
		936	}
		937
		938	static void noinline
		939	_recalc_want (bitset<NUM_EVENT_TYPES> &set, AV *registry)
		940	{
		941	for (int event = 0; event <= AvFILLp (registry); ++event)
		942	{
		943	SV *cbs_ = AvARRAY (registry)[event];
		944
		945	// element must be list of callback entries
		946	if (cbs_ && SvROK (cbs_) && SvTYPE (SvRV (cbs_)) == SVt_PVAV)
		947	{
		948	AV *cbs = (AV *)SvRV (cbs_);
		949
		950	// no callback entries, no callbacks to call
		951	if (AvFILLp (cbs) >= 0)
		952	set.set (event);
		953	}
		954	}
		955	}
		956
		957	// very slow and inefficient way to recalculate the global want bitsets
		958	static void
		959	_recalc_want ()
		960	{
		961	ev_want_event.reset ();
		962
		963	_recalc_want (ev_want_event, cb_global);
		964	_recalc_want (ev_want_event, cb_attachable);
		965	_recalc_want (ev_want_event, cb_object);
		966	_recalc_want (ev_want_event, cb_client);
		967	_recalc_want (ev_want_event, cb_player);
		968	_recalc_want (ev_want_event, cb_map);
		969
		970	ev_want_type.reset ();
		971
		972	for (int type = 0; type <= AvFILLp (cb_type); ++type)
		973	{
		974	SV *cbs_ = AvARRAY (cb_type)[type];
		975
		976	// element must be list of callback entries
		977	if (cbs_ && SvROK (cbs_) && SvTYPE (SvRV (cbs_)) == SVt_PVAV)
		978	{
		979	AV *cbs = (AV *)SvRV (cbs_);
		980
		981	// no callback entries, no callbacks to call
		982	if (AvFILLp (cbs) >= 0)
		983	ev_want_type.set (type % NUM_TYPES);
		984	}
		985	}
		986	}
		987
		988	bool
		989	attachable::invoke (event_type event, ...)
		990	{
		991	data_type dt;
		992
		993	// callback call ordering should be:
		994	// 1. per-object callback
		995	// 2. per-class object
		996	// 3. per-type callback
		997	// 4. global callbacks
		998
		999	AV *callbacks = 0;
		1000	gather_callbacks (callbacks, event);
		1001
		1002	// short-circuit processing if no callbacks found/defined
		1003	if (!callbacks)
631	return &rv;	1004	return 0;
632	}
633		1005
634	extern "C" void *cfperl_eventListener (int *type, ...)
635	{
636	static int rv;
637	va_list args;	1006	va_list ap;
638	int event_code;
639	object *who, *activator, *third, *event;
640	char *message, *extension, *options;
641
642	if (!perl)
643	return NULL;
644
645	va_start (args, type);	1007	va_start (ap, event);
646	who = va_arg (args, object *);	1008
647	event_code = va_arg (args, int);	1009	CALL_BEGIN (3);
648	activator = va_arg (args, object *);	1010	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays
649	third = va_arg (args, object *);	1011	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));
650	message = va_arg (args, char *);	1012
651	va_arg (args, int); // fix yourself	1013	//TODO: unhack
652	extension = va_arg (args, char *);	1014	if (object *op = is_a<object>(this)) CALL_ARG_SV (newSVdt (DT_OBJECT, op));
653	options = va_arg (args, char *);	1015	else if (player *pl = is_a<player>(this)) CALL_ARG_SV (newSVdt (DT_PLAYER, pl));
654	event = va_arg (args, object *);	1016	else if (client *ns = is_a<client>(this)) CALL_ARG_SV (newSVdt (DT_CLIENT, ns));
		1017	else if (maptile *m = is_a<maptile>(this)) CALL_ARG_SV (newSVdt (DT_MAP, m));
		1018	else if (global *gl = is_a<global>(this)) /*nop*/;
		1019	else
		1020	abort (); //TODO
		1021
		1022	for (;;)
		1023	{
		1024	dt = (data_type) va_arg (ap, int);
		1025
		1026	if (dt == DT_END)
		1027	break;
		1028	else if (dt == DT_AV)
		1029	{
		1030	AV *av = va_arg (ap, AV *);
		1031
		1032	for (int i = 0; i <= av_len (av); ++i)
		1033	XPUSHs (*av_fetch (av, i, 1));
		1034	}
		1035	else
		1036	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
		1037	}
		1038
655	va_end (args);	1039	va_end (ap);
656		1040
657	{	1041	CALL_CALL (cv_cf_do_invoke, G_SCALAR);
		1042	count = count > 0 ? POPi : 0;
		1043
		1044	CALL_END;
		1045
		1046	return count;
		1047	}
		1048
		1049	static SV *
		1050	cfperl_result (int idx)
		1051	{
		1052	AV *av = get_av ("cf::INVOKE_RESULTS", 0);
		1053	if (!av)
		1054	return &PL_sv_undef;
		1055
		1056	SV **sv = av_fetch (av, idx, 0);
		1057	if (!sv)
		1058	return &PL_sv_undef;
		1059
		1060	return *sv;
		1061	}
		1062
		1063	int
		1064	cfperl_result_INT (int idx)
		1065	{
		1066	return SvIV (cfperl_result (idx));
		1067	}
		1068
		1069	double
		1070	cfperl_result_DOUBLE (int idx)
		1071	{
		1072	return SvNV (cfperl_result (idx));
		1073	}
		1074
		1075	/////////////////////////////////////////////////////////////////////////////
		1076	// various c++ => perl glue functions
		1077
		1078	void
		1079	cfperl_tick ()
		1080	{
		1081	tick_pending = 1;
		1082
		1083	if (tick_inhibit)
		1084	return;
		1085
		1086	tick_pending = 0;
		1087
658	dSP;	1088	dSP;
659		1089
660	ENTER;
661	SAVETMPS;
662
663	PUSHMARK (SP);	1090	PUSHMARK (SP);
664	EXTEND (SP, 10);
665
666	PUSHcfapi (STRING, extension);
667	PUSHs (sv_2mortal (newSViv (event_code)));
668
669	PUSHcfapi (POBJECT, event);
670	PUSHcfapi (POBJECT, who);
671
672	switch (event_code)
673	{
674	case EVENT_STOP: // $ob (e.g. arrow)
675	case EVENT_TIME: // $ob
676	case EVENT_TIMER: // $ob
677	break;
678
679	case EVENT_APPLY: // $ob, $who
680	case EVENT_DROP: // $ob, $who
681	case EVENT_CLOSE: // $ob, $who
682	case EVENT_DEATH: // $ob[, $killer]
683	case EVENT_MOVE: // $ob, $enemy
684	case EVENT_THROW: // $ob, $thrower
685	PUSHcfapi (POBJECT, activator);
686	break;
687
688	case EVENT_DROP_ON: // $ob, $who, $what
689	case EVENT_ATTACK: // $ob, $who, $victim (?? please god enlighten me)
690	PUSHcfapi (POBJECT, activator);
691	PUSHcfapi (POBJECT, third);
692	break;
693
694	case EVENT_TRIGGER: // $ob, $originator, [$victim], [$msg]
695	PUSHcfapi (POBJECT, activator);
696	PUSHcfapi (POBJECT, third);
697	PUSHcfapi (POBJECT, message);
698	break;
699
700	case EVENT_SAY: // $ob, $who, $msg
701	PUSHcfapi (POBJECT, activator);
702	PUSHcfapi (STRING, message);
703	break;
704
705	default:
706	LOG (llevError, "perl plugin called for unsupported event type %d", event_code);
707	break;
708	}
709
710	PUTBACK;	1091	PUTBACK;
711	int count = call_pv ("cf::inject_event", G_SCALAR | G_EVAL);	1092	call_pvsv (cv_cf_tick, G_DISCARD | G_VOID);
712	SPAGAIN;
713		1093
714	if (SvTRUE (ERRSV))	1094	SvNV_set (sv_next_tick, get_next_tick ()); SvNOK_only (sv_next_tick);
715	LOG (llevError, "event '%d' callback evaluation error: %s", event_code, SvPV_nolen (ERRSV));	1095	}
716		1096
717	rv = count > 0 ? POPi : 0;	1097	void
		1098	cfperl_emergency_save ()
		1099	{
		1100	CALL_BEGIN (0);
		1101	CALL_CALL ("cf::emergency_save", G_VOID);
		1102	CALL_END;
		1103	}
718		1104
719	PUTBACK;	1105	void
720	FREETMPS;	1106	cfperl_cleanup (int make_core)
721	LEAVE;	1107	{
		1108	CALL_BEGIN (1);
		1109	CALL_ARG (make_core);
		1110	CALL_CALL ("cf::post_cleanup", G_VOID);
		1111	CALL_END;
		1112	}
		1113
		1114	void
		1115	cfperl_make_book (object *book, int level)
		1116	{
		1117	CALL_BEGIN (2);
		1118	CALL_ARG (book);
		1119	CALL_ARG (level);
		1120	CALL_CALL ("ext::books::make_book", G_VOID);
		1121	CALL_END;
		1122	}
		1123
		1124	void
		1125	cfperl_send_msg (client *ns, int color, const_utf8_string type, const_utf8_string msg)
		1126	{
		1127	CALL_BEGIN (4);
		1128	CALL_ARG (ns);
		1129	CALL_ARG (type);
		1130	CALL_ARG_SV (newSVpv_utf8 (msg));
		1131	CALL_ARG (color);
		1132	CALL_CALL (cv_cf_client_send_msg, G_VOID);
		1133	CALL_END;
		1134	}
		1135
		1136	int
		1137	cfperl_can_merge (object *ob1, object *ob2)
		1138	{
		1139	int can;
		1140
		1141	CALL_BEGIN (2);
		1142	CALL_ARG (ob1);
		1143	CALL_ARG (ob2);
		1144	CALL_CALL (cv_cf__can_merge, G_SCALAR);
		1145	can = count && SvTRUE (TOPs);
		1146	CALL_END;
		1147
		1148	return can;
		1149	}
		1150
		1151	void
		1152	cfperl_mapscript_activate (object *ob, int state, object *activator, object *originator)
		1153	{
		1154	CALL_BEGIN (4);
		1155	CALL_ARG (ob);
		1156	CALL_ARG (state);
		1157	CALL_ARG (activator);
		1158	CALL_ARG (originator);
		1159	CALL_CALL ("cf::mapscript::activate", G_VOID);
		1160	CALL_END;
		1161	}
		1162
		1163	void cfperl_ix (client *ns, int set, faceidx idx, int pri)
		1164	{
		1165	CALL_BEGIN (3);
		1166	CALL_ARG (ns);
		1167	CALL_ARG (set);
		1168	CALL_ARG (idx);
		1169	CALL_ARG (pri);
		1170	CALL_CALL (cv_cf_ix, G_VOID);
		1171	CALL_END;
		1172	}
		1173
		1174	player *
		1175	player::find (const_utf8_string name)
		1176	{
		1177	CALL_BEGIN (1);
		1178	CALL_ARG (name);
		1179	CALL_CALL ("cf::player::find", G_SCALAR);
		1180
		1181	player *retval = 0;
		1182	if (count) sv_to (POPs, retval);
		1183
		1184	CALL_END;
		1185
		1186	return retval;
		1187	}
		1188
		1189	maptile *
		1190	find_style (const_utf8_string dirname, const_utf8_string stylename, int difficulty, bool recurse)
		1191	{
		1192	CALL_BEGIN (4);
		1193	CALL_ARG (dirname);
		1194	CALL_ARG (stylename);
		1195	CALL_ARG (difficulty);
		1196	CALL_ARG (recurse);
		1197	CALL_CALL ("ext::map_random::find_style", G_SCALAR);
		1198
		1199	maptile *retval = 0;
		1200	if (count) sv_to (POPs, retval);
		1201
		1202	CALL_END;
		1203
		1204	return retval;
		1205	}
		1206
		1207	maptile *
		1208	maptile::find_sync (const_utf8_string path, maptile *origin)
		1209	{
		1210	CALL_BEGIN (2);
		1211	CALL_ARG (path);
		1212	CALL_ARG (origin);
		1213	CALL_CALL ("cf::map::find_sync", G_SCALAR);
		1214
		1215	maptile *retval = 0;
		1216	if (count) sv_to (POPs, retval);
		1217
		1218	CALL_END;
		1219
		1220	return retval;
		1221	}
		1222
		1223	maptile *
		1224	maptile::find_async (const_utf8_string path, maptile *origin, bool load)
		1225	{
		1226	CALL_BEGIN (3);
		1227	CALL_ARG (path);
		1228	CALL_ARG (origin);
		1229	CALL_ARG (load);
		1230	CALL_CALL ("cf::map::find_async", G_SCALAR);
		1231
		1232	maptile *retval = 0;
		1233	if (count) sv_to (POPs, retval);
		1234
		1235	CALL_END;
		1236
		1237	return retval;
		1238	}
		1239
		1240	void
		1241	maptile::do_load_sync ()
		1242	{
		1243	CALL_BEGIN (1);
		1244	CALL_ARG (this);
		1245	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);
		1246	CALL_END;
		1247	}
		1248
		1249	void
		1250	object::enter_exit (object *exit)
		1251	{
		1252	if (type != PLAYER)
		1253	return;
		1254
		1255	CALL_BEGIN (2);
		1256	CALL_ARG (this);
		1257	CALL_ARG (exit);
		1258	CALL_CALL ("cf::object::player::enter_exit", G_VOID);
		1259	CALL_END;
		1260	}
		1261
		1262	void
		1263	object::player_goto (const_utf8_string path, int x, int y)
		1264	{
		1265	if (type != PLAYER)
		1266	return;
		1267
		1268	CALL_BEGIN (4);
		1269	CALL_ARG (this);
		1270	CALL_ARG (path);
		1271	CALL_ARG (x);
		1272	CALL_ARG (y);
		1273	CALL_CALL ("cf::object::player::goto", G_VOID);
		1274	CALL_END;
		1275	}
		1276
		1277	const_utf8_string
		1278	object::ref () const
		1279	{
		1280	if (type == PLAYER)
		1281	return format ("player/<1.%llx>/%s", (unsigned long long)uuid.seq, &name);
		1282	else
		1283	// TODO: should be able to save references within the same map, at least
		1284	return 0;
		1285	}
		1286
		1287	object *
		1288	object::deref (const_utf8_string ref)
		1289	{
		1290	object *retval = 0;
		1291
		1292	if (ref)
		1293	{
		1294	CALL_BEGIN (1);
		1295	CALL_ARG (ref);
		1296	CALL_CALL ("cf::object::deref", G_SCALAR);
		1297
		1298	if (count)
		1299	sv_to (POPs, retval);
		1300
		1301	CALL_END;
722	}	1302	}
		1303
		1304	return retval;
		1305	}
		1306
		1307	void
		1308	log_backtrace (const_utf8_string msg)
		1309	{
		1310	#if HAVE_BACKTRACE
		1311	void *addr [20];
		1312	int size = backtrace (addr, 20);
		1313
		1314	CALL_BEGIN (size);
		1315	CALL_ARG (msg);
		1316	for (int i = 0; i < size; ++i)
		1317	CALL_ARG ((IV)addr [i]);
		1318	CALL_CALL ("cf::_log_backtrace", G_VOID);
		1319	CALL_END;
		1320	#endif
		1321	}
		1322
		1323	bool
		1324	is_match_expr (const_utf8_string expr)
		1325	{
		1326	return !strncmp (expr, "match ", sizeof ("match ") - 1);
		1327	}
		1328
		1329	bool
		1330	match (const_utf8_string expr, object *ob, object *self, object *source, object *originator)
		1331	{
		1332	if (!strncmp (expr, "match ", sizeof ("match ") - 1))
		1333	expr += sizeof ("match ") - 1;
		1334
		1335	CALL_BEGIN (5);
		1336	CALL_ARG (expr);
		1337	CALL_ARG (ob);
		1338	CALL_ARG (self);
		1339	CALL_ARG (source);
		1340	CALL_ARG (originator);
		1341	CALL_CALL (cv_cf_match_match, G_SCALAR);
		1342
		1343	bool matched = count && SvTRUE (TOPs);
		1344
		1345	CALL_END;
		1346
		1347	return matched;
		1348	}
		1349
		1350	object *
		1351	match_one (const_utf8_string expr, object *ob, object *self, object *source, object *originator)
		1352	{
		1353	if (!strncmp (expr, "match ", sizeof ("match ") - 1))
		1354	expr += sizeof ("match ") - 1;
		1355
		1356	CALL_BEGIN (5);
		1357	CALL_ARG (expr);
		1358	CALL_ARG (ob);
		1359	CALL_ARG (self);
		1360	CALL_ARG (source);
		1361	CALL_ARG (originator);
		1362	CALL_CALL (cv_cf_match_match, G_ARRAY);
723		1363
		1364	object *one = 0;
		1365
		1366	if (count)
		1367	sv_to (TOPs, one);
		1368
		1369	CALL_END;
		1370
724	return &rv;	1371	return one;
725	}	1372	}
726		1373
727	extern "C" int cfperl_closePlugin ()	1374	/////////////////////////////////////////////////////////////////////////////
728	{
729	printf (PLUGIN_VERSION " closing\n");
730		1375
731	if (perl)	1376	struct EVAPI *evapi::GEVAPI;
		1377	struct CoroAPI *coroapi::GCoroAPI;
		1378
		1379	void
		1380	coroapi::do_cede_to_tick ()
		1381	{
		1382	cede_pending = 0;
		1383	cede ();
		1384	}
		1385
		1386	void
		1387	coroapi::wait_for_tick ()
		1388	{
		1389	CALL_BEGIN (0);
		1390	CALL_CALL ("cf::wait_for_tick", G_DISCARD);
		1391	CALL_END;
		1392	}
		1393
		1394	void
		1395	coroapi::wait_for_tick_begin ()
		1396	{
		1397	CALL_BEGIN (0);
		1398	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);
		1399	CALL_END;
		1400	}
		1401
		1402	void
		1403	iow::poll (int events)
		1404	{
		1405	if (events != this->events)
732	{	1406	{
733	perl_destruct (perl);	1407	int active = ev_is_active ((ev_io *)this);
734	perl_free (perl);	1408	if (active) stop ();
735	perl = 0;	1409	ev_io_set ((ev_io *)this, fd, events);
		1410	if (active) start ();
736	}	1411	}
		1412	}
737		1413
738	return 0;	1414	static void
		1415	_connect_to_perl_1 ()
		1416	{
		1417	stash_cf = gv_stashpv ("cf", 1);
		1418
		1419	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);
		1420	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);
		1421	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);
		1422	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);
		1423	stash_cf_mapspace_wrap = gv_stashpv ("cf::mapspace::wrap" , 1);
		1424	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);
		1425	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
		1426	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
		1427	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
		1428	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
		1429	stash_cf_layout_wrap = gv_stashpv ("cf::layout::wrap", 1);
		1430	stash_ext_map_world = gv_stashpv ("ext::map_world" , 1);
		1431
		1432	sv_now = get_sv ("cf::NOW" , 1); SvUPGRADE (sv_now , SVt_NV);
		1433	sv_runtime = get_sv ("cf::RUNTIME" , 1); SvUPGRADE (sv_runtime , SVt_NV);
		1434	sv_server_tick = get_sv ("cf::SERVER_TICK", 1); SvUPGRADE (sv_server_tick, SVt_IV);
		1435	sv_tick_start = get_sv ("cf::TICK_START" , 1); SvUPGRADE (sv_tick_start , SVt_NV);
		1436	sv_next_tick = get_sv ("cf::NEXT_TICK" , 1); SvUPGRADE (sv_next_tick , SVt_NV);
		1437
		1438	cb_global = get_av ("cf::CB_GLOBAL", 1);
		1439	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
		1440	cb_object = get_av ("cf::CB_OBJECT", 1);
		1441	cb_player = get_av ("cf::CB_PLAYER", 1);
		1442	cb_client = get_av ("cf::CB_CLIENT", 1);
		1443	cb_type = get_av ("cf::CB_TYPE" , 1);
		1444	cb_map = get_av ("cf::CB_MAP" , 1);
		1445	}
		1446
		1447	static void
		1448	_connect_to_perl_2 ()
		1449	{
		1450	cv_cf_do_invoke = (SV *)get_cv ("cf::do_invoke" , 0); assert (cv_cf_do_invoke);
		1451	cv_cf__can_merge = (SV *)get_cv ("cf::_can_merge" , 0); assert (cv_cf__can_merge);
		1452	cv_cf_client_send_msg = (SV *)get_cv ("cf::client::send_msg", 0); assert (cv_cf_client_send_msg);
		1453	cv_cf_ix = (SV *)get_cv ("cf::face::ix" , 0); assert (cv_cf_ix);
		1454	cv_cf_tick = (SV *)get_cv ("cf::tick" , 0); assert (cv_cf_tick);
		1455	cv_cf_match_match = (SV *)get_cv ("cf::match::match" , 0); assert (cv_cf_match_match);
739	}	1456	}
740		1457
741	MODULE = cf PACKAGE = cf PREFIX = cf_	1458	MODULE = cf PACKAGE = cf PREFIX = cf_
742		1459
743	BOOT:	1460	BOOT:
744	{	1461	{
745	HV *stash = gv_stashpv ("cf", 1);	1462	I_EV_API (PACKAGE); evapi::GEVAPI = GEVAPI;
		1463	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
		1464
		1465	_connect_to_perl_1 ();
		1466
		1467	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
746		1468
747	static const struct {	1469	static const struct {
748	const char *name;	1470	const char *name;
749	IV iv;	1471	IV iv;
750	} *civ, const_iv[] = {	1472	} *civ, const_iv[] = {
751	# define const_iv(name) { # name, (IV)name },	1473	# define const_iv(name) { # name, (IV)name },
752	const_iv (llevError)	1474	# include "const_iv.h"
753	const_iv (llevInfo)	1475	# define def(uc, lc, name, plus, change) const_iv (AT_ ## uc) const_iv (ATNR_ ## uc)
754	const_iv (llevDebug)	1476	# include "attackinc.h"
755	const_iv (llevMonster)	1477	# undef def
		1478	# define def(uc, flags) const_iv (SK_ ## uc)
		1479	# include "skillinc.h"
		1480	# undef def
		1481	# define def(name, use, nonuse) const_iv (body_ ## name)
		1482	# include "slotinc.h"
		1483	# undef def
756		1484
757	const_iv (PLAYER)	1485	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)
758	const_iv (TRANSPORT)	1486
759	const_iv (ROD)
760	const_iv (TREASURE)
761	const_iv (POTION)
762	const_iv (FOOD)
763	const_iv (POISON)
764	const_iv (BOOK)
765	const_iv (CLOCK)
766	const_iv (LIGHTNING)
767	const_iv (ARROW)
768	const_iv (BOW)
769	const_iv (WEAPON)
770	const_iv (ARMOUR)
771	const_iv (PEDESTAL)
772	const_iv (ALTAR)
773	const_iv (LOCKED_DOOR)
774	const_iv (SPECIAL_KEY)
775	const_iv (MAP)
776	const_iv (DOOR)
777	const_iv (KEY)
778	const_iv (TIMED_GATE)
779	const_iv (TRIGGER)
780	const_iv (GRIMREAPER)
781	const_iv (MAGIC_EAR)
782	const_iv (TRIGGER_BUTTON)
783	const_iv (TRIGGER_ALTAR)
784	const_iv (TRIGGER_PEDESTAL)
785	const_iv (SHIELD)
786	const_iv (HELMET)
787	const_iv (HORN)
788	const_iv (MONEY)
789	const_iv (CLASS)
790	const_iv (GRAVESTONE)
791	const_iv (AMULET)
792	const_iv (PLAYERMOVER)
793	const_iv (TELEPORTER)
794	const_iv (CREATOR)
795	const_iv (SKILL)
796	const_iv (EXPERIENCE)
797	const_iv (EARTHWALL)
798	const_iv (GOLEM)
799	const_iv (THROWN_OBJ)
800	const_iv (BLINDNESS)
801	const_iv (GOD)
802	const_iv (DETECTOR)
803	const_iv (TRIGGER_MARKER)
804	const_iv (DEAD_OBJECT)
805	const_iv (DRINK)
806	const_iv (MARKER)
807	const_iv (HOLY_ALTAR)
808	const_iv (PLAYER_CHANGER)
809	const_iv (BATTLEGROUND)
810	const_iv (PEACEMAKER)
811	const_iv (GEM)
812	const_iv (FIREWALL)
813	const_iv (ANVIL)
814	const_iv (CHECK_INV)
815	const_iv (MOOD_FLOOR)
816	const_iv (EXIT)
817	const_iv (ENCOUNTER)
818	const_iv (SHOP_FLOOR)
819	const_iv (SHOP_MAT)
820	const_iv (RING)
821	const_iv (FLOOR)
822	const_iv (FLESH)
823	const_iv (INORGANIC)
824	const_iv (SKILL_TOOL)
825	const_iv (LIGHTER)
826	const_iv (TRAP_PART)
827	const_iv (WALL)
828	const_iv (LIGHT_SOURCE)
829	const_iv (MISC_OBJECT)
830	const_iv (MONSTER)
831	const_iv (SPAWN_GENERATOR)
832	const_iv (LAMP)
833	const_iv (DUPLICATOR)
834	const_iv (TOOL)
835	const_iv (SPELLBOOK)
836	const_iv (BUILDFAC)
837	const_iv (CLOAK)
838	const_iv (SPINNER)
839	const_iv (GATE)	1487	const_iv (MAX_TIME)
840	const_iv (BUTTON)
841	const_iv (CF_HANDLE)
842	const_iv (HOLE)
843	const_iv (TRAPDOOR)
844	const_iv (SIGN)
845	const_iv (BOOTS)
846	const_iv (GLOVES)
847	const_iv (SPELL)
848	const_iv (SPELL_EFFECT)
849	const_iv (CONVERTER)
850	const_iv (BRACERS)
851	const_iv (POISONING)
852	const_iv (SAVEBED)
853	const_iv (POISONCLOUD)
854	const_iv (FIREHOLES)
855	const_iv (WAND)
856	const_iv (SCROLL)
857	const_iv (DIRECTOR)
858	const_iv (GIRDLE)
859	const_iv (FORCE)
860	const_iv (POTION_EFFECT)
861	const_iv (EVENT_CONNECTOR)
862	const_iv (CLOSE_CON)
863	const_iv (CONTAINER)
864	const_iv (ARMOUR_IMPROVER)
865	const_iv (WEAPON_IMPROVER)
866	const_iv (SKILLSCROLL)
867	const_iv (DEEP_SWAMP)
868	const_iv (IDENTIFY_ALTAR)
869	const_iv (MENU)	1488	const_iv (MAXSOCKBUF)
870	const_iv (RUNE)
871	const_iv (TRAP)
872	const_iv (POWER_CRYSTAL)
873	const_iv (CORPSE)
874	const_iv (DISEASE)
875	const_iv (SYMPTOM)
876	const_iv (BUILDER)
877	const_iv (MATERIAL)
878	const_iv (ITEM_TRANSFORMER)
879	const_iv (QUEST)
880		1489
881	const_iv (ST_BD_BUILD)	1490	const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE)
882	const_iv (ST_BD_REMOVE)	1491	const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF)
883		1492
884	const_iv (ST_MAT_FLOOR)	1493	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_LEVEL)
885	const_iv (ST_MAT_WALL)
886	const_iv (ST_MAT_ITEM)
887		1494
888	const_iv (AT_PHYSICAL)	1495	const_iv (F_APPLIED) const_iv (F_LOCATION) const_iv (F_UNPAID) const_iv (F_MAGIC)
889	const_iv (AT_MAGIC)	1496	const_iv (F_CURSED) const_iv (F_DAMNED) const_iv (F_OPEN) const_iv (F_NOPICK)
890	const_iv (AT_FIRE)
891	const_iv (AT_ELECTRICITY)
892	const_iv (AT_COLD)
893	const_iv (AT_CONFUSION)
894	const_iv (AT_ACID)
895	const_iv (AT_DRAIN)
896	const_iv (AT_WEAPONMAGIC)
897	const_iv (AT_GHOSTHIT)
898	const_iv (AT_POISON)
899	const_iv (AT_SLOW)
900	const_iv (AT_PARALYZE)
901	const_iv (AT_TURN_UNDEAD)
902	const_iv (AT_FEAR)
903	const_iv (AT_CANCELLATION)
904	const_iv (AT_DEPLETE)
905	const_iv (AT_DEATH)
906	const_iv (AT_CHAOS)
907	const_iv (AT_COUNTERSPELL)
908	const_iv (AT_GODPOWER)
909	const_iv (AT_HOLYWORD)
910	const_iv (AT_BLIND)
911	const_iv (AT_INTERNAL)
912	const_iv (AT_LIFE_STEALING)
913	const_iv (AT_DISEASE)
914
915	const_iv (QUEST_IN_PROGRESS)
916	const_iv (QUEST_DONE_QUEST)
917	const_iv (QUEST_DONE_TASK)
918	const_iv (QUEST_START_QUEST)
919	const_iv (QUEST_END_QUEST)
920	const_iv (QUEST_START_TASK)
921	const_iv (QUEST_END_TASK)
922	const_iv (QUEST_OVERRIDE)
923	const_iv (QUEST_ON_ACTIVATE)
924
925	const_iv (WEAP_HIT)
926	const_iv (WEAP_SLASH)
927	const_iv (WEAP_PIERCE)
928	const_iv (WEAP_CLEAVE)
929	const_iv (WEAP_SLICE)
930	const_iv (WEAP_STAB)
931	const_iv (WEAP_WHIP)
932	const_iv (WEAP_CRUSH)
933	const_iv (WEAP_BLUD)
934
935	const_iv (FLAG_ALIVE)
936	const_iv (FLAG_WIZ)
937	const_iv (FLAG_REMOVED)
938	const_iv (FLAG_FREED)
939	const_iv (FLAG_WAS_WIZ)
940	const_iv (FLAG_APPLIED)
941	const_iv (FLAG_UNPAID)
942	const_iv (FLAG_USE_SHIELD)
943	const_iv (FLAG_NO_PICK)
944	const_iv (FLAG_ANIMATE)
945	const_iv (FLAG_MONSTER)
946	const_iv (FLAG_FRIENDLY)
947	const_iv (FLAG_GENERATOR)
948	const_iv (FLAG_IS_THROWN)
949	const_iv (FLAG_AUTO_APPLY)
950	const_iv (FLAG_TREASURE)
951	const_iv (FLAG_PLAYER_SOLD)
952	const_iv (FLAG_SEE_INVISIBLE)
953	const_iv (FLAG_CAN_ROLL)
954	const_iv (FLAG_OVERLAY_FLOOR)
955	const_iv (FLAG_IS_TURNABLE)
956	const_iv (FLAG_IS_USED_UP)
957	const_iv (FLAG_IDENTIFIED)
958	const_iv (FLAG_REFLECTING)
959	const_iv (FLAG_CHANGING)
960	const_iv (FLAG_SPLITTING)
961	const_iv (FLAG_HITBACK)
962	const_iv (FLAG_STARTEQUIP)
963	const_iv (FLAG_BLOCKSVIEW)
964	const_iv (FLAG_UNDEAD)
965	const_iv (FLAG_SCARED)
966	const_iv (FLAG_UNAGGRESSIVE)
967	const_iv (FLAG_REFL_MISSILE)
968	const_iv (FLAG_REFL_SPELL)
969	const_iv (FLAG_NO_MAGIC)
970	const_iv (FLAG_NO_FIX_PLAYER)
971	const_iv (FLAG_IS_LIGHTABLE)
972	const_iv (FLAG_TEAR_DOWN)
973	const_iv (FLAG_RUN_AWAY)
974	const_iv (FLAG_PICK_UP)
975	const_iv (FLAG_UNIQUE)
976	const_iv (FLAG_NO_DROP)
977	const_iv (FLAG_WIZCAST)
978	const_iv (FLAG_CAST_SPELL)
979	const_iv (FLAG_USE_SCROLL)
980	const_iv (FLAG_USE_RANGE)
981	const_iv (FLAG_USE_BOW)
982	const_iv (FLAG_USE_ARMOUR)
983	const_iv (FLAG_USE_WEAPON)
984	const_iv (FLAG_USE_RING)
985	const_iv (FLAG_READY_RANGE)
986	const_iv (FLAG_READY_BOW)
987	const_iv (FLAG_XRAYS)
988	const_iv (FLAG_NO_APPLY)
989	const_iv (FLAG_IS_FLOOR)
990	const_iv (FLAG_LIFESAVE)
991	const_iv (FLAG_NO_STRENGTH)
992	const_iv (FLAG_SLEEP)
993	const_iv (FLAG_STAND_STILL)
994	const_iv (FLAG_RANDOM_MOVE)
995	const_iv (FLAG_ONLY_ATTACK)
996	const_iv (FLAG_CONFUSED)
997	const_iv (FLAG_STEALTH)
998	const_iv (FLAG_WIZPASS)
999	const_iv (FLAG_IS_LINKED)
1000	const_iv (FLAG_CURSED)
1001	const_iv (FLAG_DAMNED)
1002	const_iv (FLAG_SEE_ANYWHERE)
1003	const_iv (FLAG_KNOWN_MAGICAL)
1004	const_iv (FLAG_KNOWN_CURSED)
1005	const_iv (FLAG_CAN_USE_SKILL)
1006	const_iv (FLAG_BEEN_APPLIED)
1007	const_iv (FLAG_READY_SCROLL)
1008	const_iv (FLAG_USE_ROD)
1009	const_iv (FLAG_USE_HORN)
1010	const_iv (FLAG_MAKE_INVIS)
1011	const_iv (FLAG_INV_LOCKED)
1012	const_iv (FLAG_IS_WOODED)
1013	const_iv (FLAG_IS_HILLY)
1014	const_iv (FLAG_READY_SKILL)
1015	const_iv (FLAG_READY_WEAPON)
1016	const_iv (FLAG_NO_SKILL_IDENT)
1017	const_iv (FLAG_BLIND)
1018	const_iv (FLAG_SEE_IN_DARK)
1019	const_iv (FLAG_IS_CAULDRON)
1020	const_iv (FLAG_NO_STEAL)
1021	const_iv (FLAG_ONE_HIT)
1022	const_iv (FLAG_CLIENT_SENT)
1023	const_iv (FLAG_BERSERK)
1024	const_iv (FLAG_NEUTRAL)
1025	const_iv (FLAG_NO_ATTACK)
1026	const_iv (FLAG_NO_DAMAGE)
1027	const_iv (FLAG_OBJ_ORIGINAL)
1028	const_iv (FLAG_OBJ_SAVE_ON_OVL)
1029	const_iv (FLAG_ACTIVATE_ON_PUSH)
1030	const_iv (FLAG_ACTIVATE_ON_RELEASE)
1031	const_iv (FLAG_IS_WATER)
1032	const_iv (FLAG_CONTENT_ON_GEN)
1033	const_iv (FLAG_IS_A_TEMPLATE)
1034	const_iv (FLAG_IS_BUILDABLE)
1035	const_iv (FLAG_AFK)
1036
1037	const_iv (NDI_BLACK)
1038	const_iv (NDI_WHITE)
1039	const_iv (NDI_NAVY)
1040	const_iv (NDI_RED)
1041	const_iv (NDI_ORANGE)
1042	const_iv (NDI_BLUE)
1043	const_iv (NDI_DK_ORANGE)
1044	const_iv (NDI_GREEN)
1045	const_iv (NDI_LT_GREEN)
1046	const_iv (NDI_GREY)
1047	const_iv (NDI_BROWN)
1048	const_iv (NDI_GOLD)
1049	const_iv (NDI_TAN)
1050	const_iv (NDI_MAX_COLOR)
1051	const_iv (NDI_COLOR_MASK)
1052	const_iv (NDI_UNIQUE)
1053	const_iv (NDI_ALL)
1054
1055	const_iv (F_APPLIED)
1056	const_iv (F_LOCATION)
1057	const_iv (F_UNPAID)
1058	const_iv (F_MAGIC)
1059	const_iv (F_CURSED)
1060	const_iv (F_DAMNED)
1061	const_iv (F_OPEN)
1062	const_iv (F_NOPICK)
1063	const_iv (F_LOCKED)	1497	const_iv (F_LOCKED)
1064		1498
1065	const_iv (F_BUY)	1499	const_iv (P_BLOCKSVIEW) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE)
1066	const_iv (F_SHOP)	1500	const_iv (P_NO_CLERIC) const_iv (P_OUT_OF_MAP) const_iv (P_NEW_MAP) const_iv (P_UPTODATE)
1067	const_iv (F_SELL)
1068		1501
1069	const_iv (P_BLOCKSVIEW)	1502	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)
1070	const_iv (P_NO_MAGIC)
1071	const_iv (P_IS_ALIVE)
1072	const_iv (P_NO_CLERIC)
1073	const_iv (P_NEED_UPDATE)
1074	const_iv (P_NO_ERROR)
1075	const_iv (P_OUT_OF_MAP)
1076	const_iv (P_NEW_MAP)
1077		1503
1078	const_iv (UP_OBJ_INSERT)	1504	const_iv (SK_EXP_ADD_SKILL) const_iv (SK_EXP_TOTAL) const_iv (SK_EXP_NONE)
1079	const_iv (UP_OBJ_REMOVE)	1505	const_iv (SK_SUBTRACT_SKILL_EXP) const_iv (SK_EXP_SKILL_ONLY)
1080	const_iv (UP_OBJ_CHANGE)
1081	const_iv (UP_OBJ_FACE)
1082		1506
1083	const_iv (INS_NO_MERGE)	1507	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)
1084	const_iv (INS_ABOVE_FLOOR_ONLY)	1508	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)
1085	const_iv (INS_NO_WALK_ON)
1086	const_iv (INS_ON_TOP)
1087	const_iv (INS_BELOW_ORIGINATOR)
1088	const_iv (INS_MAP_LOAD)
1089		1509
1090	const_iv (WILL_APPLY_HANDLE)	1510	const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)
1091	const_iv (WILL_APPLY_TREASURE)
1092	const_iv (WILL_APPLY_EARTHWALL)
1093	const_iv (WILL_APPLY_DOOR)
1094	const_iv (WILL_APPLY_FOOD)
1095		1511
1096	const_iv (SAVE_MODE)	1512	const_iv (IO_HEADER) const_iv (IO_OBJECTS) const_iv (IO_UNIQUES)
1097	const_iv (SAVE_DIR_MODE)
1098
1099	const_iv (M_PAPER)
1100	const_iv (M_IRON)
1101	const_iv (M_GLASS)
1102	const_iv (M_LEATHER)
1103	const_iv (M_WOOD)
1104	const_iv (M_ORGANIC)
1105	const_iv (M_STONE)
1106	const_iv (M_CLOTH)
1107	const_iv (M_ADAMANT)
1108	const_iv (M_LIQUID)
1109	const_iv (M_SOFT_METAL)
1110	const_iv (M_BONE)
1111	const_iv (M_ICE)
1112	const_iv (M_SPECIAL)
1113
1114	const_iv (SK_EXP_ADD_SKILL)
1115	const_iv (SK_EXP_TOTAL)
1116	const_iv (SK_EXP_NONE)
1117	const_iv (SK_SUBTRACT_SKILL_EXP)
1118
1119	const_iv (SK_LOCKPICKING)
1120	const_iv (SK_HIDING)
1121	const_iv (SK_SMITHERY)
1122	const_iv (SK_BOWYER)
1123	const_iv (SK_JEWELER)
1124	const_iv (SK_ALCHEMY)
1125	const_iv (SK_STEALING)
1126	const_iv (SK_LITERACY)
1127	const_iv (SK_BARGAINING)
1128	const_iv (SK_JUMPING)
1129	const_iv (SK_DET_MAGIC)
1130	const_iv (SK_ORATORY)
1131	const_iv (SK_SINGING)
1132	const_iv (SK_DET_CURSE)
1133	const_iv (SK_FIND_TRAPS)
1134	const_iv (SK_MEDITATION)
1135	const_iv (SK_PUNCHING)
1136	const_iv (SK_FLAME_TOUCH)
1137	const_iv (SK_KARATE)
1138	const_iv (SK_CLIMBING)
1139	const_iv (SK_WOODSMAN)
1140	const_iv (SK_INSCRIPTION)
1141	const_iv (SK_ONE_HANDED_WEAPON)
1142	const_iv (SK_MISSILE_WEAPON)
1143	const_iv (SK_THROWING)
1144	const_iv (SK_USE_MAGIC_ITEM)
1145	const_iv (SK_DISARM_TRAPS)
1146	const_iv (SK_SET_TRAP)
1147	const_iv (SK_THAUMATURGY)
1148	const_iv (SK_PRAYING)
1149	const_iv (SK_CLAWING)
1150	const_iv (SK_LEVITATION)
1151	const_iv (SK_SUMMONING)
1152	const_iv (SK_PYROMANCY)
1153	const_iv (SK_EVOCATION)
1154	const_iv (SK_SORCERY)
1155	const_iv (SK_TWO_HANDED_WEAPON)
1156	const_iv (SK_SPARK_TOUCH)
1157	const_iv (SK_SHIVER)
1158	const_iv (SK_ACID_SPLASH)
1159	const_iv (SK_POISON_NAIL)
1160
1161	const_iv (SOUND_NEW_PLAYER)
1162	const_iv (SOUND_FIRE_ARROW)
1163	const_iv (SOUND_LEARN_SPELL)
1164	const_iv (SOUND_FUMBLE_SPELL)
1165	const_iv (SOUND_WAND_POOF)
1166	const_iv (SOUND_OPEN_DOOR)
1167	const_iv (SOUND_PUSH_PLAYER)
1168	const_iv (SOUND_PLAYER_HITS1)
1169	const_iv (SOUND_PLAYER_HITS2)
1170	const_iv (SOUND_PLAYER_HITS3)
1171	const_iv (SOUND_PLAYER_HITS4)
1172	const_iv (SOUND_PLAYER_IS_HIT1)
1173	const_iv (SOUND_PLAYER_IS_HIT2)
1174	const_iv (SOUND_PLAYER_IS_HIT3)
1175	const_iv (SOUND_PLAYER_KILLS)
1176	const_iv (SOUND_PET_IS_KILLED)
1177	const_iv (SOUND_PLAYER_DIES)
1178	const_iv (SOUND_OB_EVAPORATE)
1179	const_iv (SOUND_OB_EXPLODE)
1180	const_iv (SOUND_CLOCK)
1181	const_iv (SOUND_TURN_HANDLE)
1182	const_iv (SOUND_FALL_HOLE)
1183	const_iv (SOUND_DRINK_POISON)
1184	const_iv (SOUND_CAST_SPELL_0)
1185
1186	const_iv (PREFER_LOW)
1187	const_iv (PREFER_HIGH)
1188
1189	const_iv (ATNR_PHYSICAL)
1190	const_iv (ATNR_MAGIC)
1191	const_iv (ATNR_FIRE)
1192	const_iv (ATNR_ELECTRICITY)
1193	const_iv (ATNR_COLD)
1194	const_iv (ATNR_CONFUSION)
1195	const_iv (ATNR_ACID)
1196	const_iv (ATNR_DRAIN)
1197	const_iv (ATNR_WEAPONMAGIC)
1198	const_iv (ATNR_GHOSTHIT)
1199	const_iv (ATNR_POISON)
1200	const_iv (ATNR_SLOW)
1201	const_iv (ATNR_PARALYZE)
1202	const_iv (ATNR_TURN_UNDEAD)
1203	const_iv (ATNR_FEAR)
1204	const_iv (ATNR_CANCELLATION)
1205	const_iv (ATNR_DEPLETE)
1206	const_iv (ATNR_DEATH)
1207	const_iv (ATNR_CHAOS)
1208	const_iv (ATNR_COUNTERSPELL)
1209	const_iv (ATNR_GODPOWER)
1210	const_iv (ATNR_HOLYWORD)
1211	const_iv (ATNR_BLIND)
1212	const_iv (ATNR_INTERNAL)
1213	const_iv (ATNR_LIFE_STEALING)
1214	const_iv (ATNR_DISEASE)
1215
1216	const_iv (MAP_FLUSH)
1217	const_iv (MAP_PLAYER_UNIQUE)
1218	const_iv (MAP_BLOCK)
1219	const_iv (MAP_STYLE)
1220	const_iv (MAP_OVERLAY)
1221
1222	const_iv (MAP_IN_MEMORY)
1223	const_iv (MAP_SWAPPED)
1224	const_iv (MAP_LOADING)
1225	const_iv (MAP_SAVING)
1226	};	1513	};
1227		1514
1228	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	1515	for (civ = const_iv + array_length (const_iv); civ-- > const_iv; )
1229	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));	1516	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1230		1517
1231	static const struct {	1518	static const struct {
1232	const char *name;	1519	const char *name;
		1520	int skip;
		1521	IV klass;
1233	IV iv;	1522	IV iv;
1234	} *event, event_list[] = {	1523	} *eiv, event_iv[] = {
1235	# define const_event(name) { # name, (IV)EVENT_ ## name },	1524	# define def(klass,name) { "EVENT_" # klass "_" # name, sizeof ("EVENT_" # klass), (IV)KLASS_ ## klass, (IV)EVENT_ ## klass ## _ ## name },
1236	const_event (NONE)	1525	# include "eventinc.h"
1237	const_event (APPLY)	1526	# undef def
1238	const_event (ATTACK)
1239	const_event (DEATH)
1240	const_event (DROP)
1241	const_event (DROP_ON)
1242	const_event (PICKUP)
1243	const_event (SAY)
1244	const_event (STOP)
1245	const_event (TIME)
1246	const_event (THROW)
1247	const_event (TRIGGER)
1248	const_event (CLOSE)
1249	const_event (TIMER)
1250	const_event (MOVE)
1251
1252	const_event (BORN)
1253	//const_event (CLOCK)
1254	const_event (CRASH)
1255	const_event (PLAYER_DEATH)
1256	const_event (PLAYER_LOAD)
1257	const_event (PLAYER_SAVE)
1258	const_event (GKILL)
1259	const_event (LOGIN)
1260	const_event (LOGOUT)
1261	const_event (MAPENTER)
1262	const_event (MAPLEAVE)
1263	const_event (MAPRESET)
1264	const_event (MAPLOAD)
1265	const_event (MAPOUT)
1266	const_event (MAPIN)
1267	const_event (MAPCLEAN)
1268	const_event (REMOVE)
1269	const_event (SHOUT)
1270	const_event (TELL)
1271	const_event (MUZZLE)
1272	const_event (KICK)
1273	const_event (PLAYER_USE_SKILL)
1274	const_event (MONSTER_USE_SKILL)
1275	const_event (CAST_SPELL)
1276	const_event (FIND_UNARMED_SKILL)
1277	const_event (EXTCMD)
1278	//const_event (FREE_OB)
1279	};	1527	};
1280		1528
1281	AV *av = get_av ("cf::EVENT", 1);	1529	AV *av = get_av ("cf::EVENT", 1);
1282		1530
1283	for (event = event_list + sizeof (event_list) / sizeof (event_list [0]); event-- > event_list; )	1531	for (eiv = event_iv + array_length (event_iv); eiv-- > event_iv; )
1284	av_store (av, event->iv, newSVpv ((char *)event->name, 0));
1285
1286	static const struct {
1287	int dtype;
1288	const char *name;
1289	IV idx;
1290	} *cprop, prop_table[] = {
1291	# define prop(type, name) { type, # name, (IV) CFAPI_ ## name },
1292	prop (CFAPI_INT, MAP_PROP_FLAGS)
1293	prop (CFAPI_INT, MAP_PROP_DIFFICULTY)
1294	prop (CFAPI_STRING, MAP_PROP_PATH)
1295	prop (CFAPI_STRING, MAP_PROP_TMPNAME)
1296	prop (CFAPI_STRING, MAP_PROP_NAME)
1297	prop (CFAPI_INT, MAP_PROP_RESET_TIME)
1298	prop (CFAPI_INT, MAP_PROP_RESET_TIMEOUT)
1299	prop (CFAPI_INT, MAP_PROP_PLAYERS)
1300	prop (CFAPI_INT, MAP_PROP_DARKNESS)
1301	prop (CFAPI_INT, MAP_PROP_WIDTH)
1302	prop (CFAPI_INT, MAP_PROP_HEIGHT)
1303	prop (CFAPI_INT, MAP_PROP_ENTER_X)
1304	prop (CFAPI_INT, MAP_PROP_ENTER_Y)
1305	prop (CFAPI_INT, MAP_PROP_TEMPERATURE)
1306	prop (CFAPI_INT, MAP_PROP_PRESSURE)
1307	prop (CFAPI_INT, MAP_PROP_HUMIDITY)
1308	prop (CFAPI_INT, MAP_PROP_WINDSPEED)
1309	prop (CFAPI_INT, MAP_PROP_WINDDIR)
1310	prop (CFAPI_INT, MAP_PROP_SKY)
1311	prop (CFAPI_INT, MAP_PROP_WPARTX)
1312	prop (CFAPI_INT, MAP_PROP_WPARTY)
1313	prop (CFAPI_STRING, MAP_PROP_MESSAGE)
1314	prop (CFAPI_PMAP, MAP_PROP_NEXT)
1315	prop (CFAPI_PREGION, MAP_PROP_REGION)
1316	prop (CFAPI_POBJECT, OBJECT_PROP_OB_ABOVE)
1317	prop (CFAPI_POBJECT, OBJECT_PROP_OB_BELOW)
1318	prop (CFAPI_POBJECT, OBJECT_PROP_NEXT_ACTIVE_OB)
1319	prop (CFAPI_POBJECT, OBJECT_PROP_PREV_ACTIVE_OB)
1320	prop (CFAPI_POBJECT, OBJECT_PROP_INVENTORY)
1321	prop (CFAPI_POBJECT, OBJECT_PROP_ENVIRONMENT)
1322	prop (CFAPI_POBJECT, OBJECT_PROP_HEAD)
1323	prop (CFAPI_POBJECT, OBJECT_PROP_CONTAINER)
1324	prop (CFAPI_PMAP, OBJECT_PROP_MAP)
1325	prop (CFAPI_INT, OBJECT_PROP_COUNT)
1326	prop (CFAPI_INT, OBJECT_PROP_REFCOUNT)
1327	prop (CFAPI_STRING, OBJECT_PROP_NAME)
1328	prop (CFAPI_STRING, OBJECT_PROP_NAME_PLURAL)
1329	prop (CFAPI_STRING, OBJECT_PROP_TITLE)
1330	prop (CFAPI_STRING, OBJECT_PROP_RACE)
1331	prop (CFAPI_STRING, OBJECT_PROP_SLAYING)
1332	prop (CFAPI_STRING, OBJECT_PROP_SKILL)
1333	prop (CFAPI_STRING, OBJECT_PROP_MESSAGE)
1334	prop (CFAPI_STRING, OBJECT_PROP_LORE)
1335	prop (CFAPI_INT, OBJECT_PROP_X)
1336	prop (CFAPI_INT, OBJECT_PROP_Y)
1337	prop (CFAPI_DOUBLE, OBJECT_PROP_SPEED)
1338	prop (CFAPI_DOUBLE, OBJECT_PROP_SPEED_LEFT)
1339	prop (CFAPI_INT, OBJECT_PROP_NROF)
1340	prop (CFAPI_INT, OBJECT_PROP_DIRECTION)
1341	prop (CFAPI_INT, OBJECT_PROP_FACING)
1342	prop (CFAPI_INT, OBJECT_PROP_TYPE)
1343	prop (CFAPI_INT, OBJECT_PROP_SUBTYPE)
1344	prop (CFAPI_INT, OBJECT_PROP_CLIENT_TYPE)
1345	prop (CFAPI_INT, OBJECT_PROP_ATTACK_TYPE)
1346	prop (CFAPI_INT, OBJECT_PROP_PATH_ATTUNED)
1347	prop (CFAPI_INT, OBJECT_PROP_PATH_REPELLED)
1348	prop (CFAPI_INT, OBJECT_PROP_PATH_DENIED)
1349	prop (CFAPI_INT, OBJECT_PROP_MATERIAL)
1350	prop (CFAPI_STRING, OBJECT_PROP_MATERIAL_NAME)
1351	prop (CFAPI_INT, OBJECT_PROP_MAGIC)
1352	prop (CFAPI_INT, OBJECT_PROP_VALUE)
1353	prop (CFAPI_INT, OBJECT_PROP_LEVEL)
1354	prop (CFAPI_INT, OBJECT_PROP_LAST_HEAL)
1355	prop (CFAPI_INT, OBJECT_PROP_LAST_SP)
1356	prop (CFAPI_INT, OBJECT_PROP_LAST_GRACE)
1357	prop (CFAPI_INT, OBJECT_PROP_LAST_EAT)
1358	prop (CFAPI_INT, OBJECT_PROP_INVISIBLE_TIME)
1359	prop (CFAPI_INT, OBJECT_PROP_PICK_UP)
1360	prop (CFAPI_INT, OBJECT_PROP_ITEM_POWER)
1361	prop (CFAPI_INT, OBJECT_PROP_GEN_SP_ARMOUR)
1362	prop (CFAPI_INT, OBJECT_PROP_WEIGHT)
1363	prop (CFAPI_INT, OBJECT_PROP_WEIGHT_LIMIT)
1364	prop (CFAPI_INT, OBJECT_PROP_CARRYING)
1365	prop (CFAPI_INT, OBJECT_PROP_GLOW_RADIUS)
1366	prop (CFAPI_LONG, OBJECT_PROP_PERM_EXP)
1367	prop (CFAPI_POBJECT, OBJECT_PROP_CURRENT_WEAPON)
1368	prop (CFAPI_POBJECT, OBJECT_PROP_ENEMY)
1369	prop (CFAPI_POBJECT, OBJECT_PROP_ATTACKED_BY)
1370	prop (CFAPI_INT, OBJECT_PROP_RUN_AWAY)
1371	prop (CFAPI_POBJECT, OBJECT_PROP_CHOSEN_SKILL)
1372	prop (CFAPI_INT, OBJECT_PROP_HIDDEN)
1373	prop (CFAPI_INT, OBJECT_PROP_MOVE_STATUS)
1374	prop (CFAPI_INT, OBJECT_PROP_MOVE_TYPE)
1375	prop (CFAPI_POBJECT, OBJECT_PROP_SPELL_ITEM)
1376	prop (CFAPI_DOUBLE, OBJECT_PROP_EXP_MULTIPLIER)
1377	prop (CFAPI_PARCH, OBJECT_PROP_ARCHETYPE)
1378	prop (CFAPI_PARCH, OBJECT_PROP_OTHER_ARCH)
1379	prop (CFAPI_STRING, OBJECT_PROP_CUSTOM_NAME)
1380	prop (CFAPI_INT, OBJECT_PROP_ANIM_SPEED)
1381	prop (CFAPI_INT, OBJECT_PROP_FRIENDLY)
1382	prop (CFAPI_STRING, OBJECT_PROP_SHORT_NAME)
1383	prop (CFAPI_INT, OBJECT_PROP_MAGICAL)
1384	prop (CFAPI_INT, OBJECT_PROP_LUCK)
1385	prop (CFAPI_POBJECT, OBJECT_PROP_OWNER)
1386	prop (CFAPI_POBJECT, OBJECT_PROP_PRESENT)
1387	prop (CFAPI_INT, OBJECT_PROP_CHEATER)
1388	prop (CFAPI_INT, OBJECT_PROP_MERGEABLE)
1389	prop (CFAPI_INT, OBJECT_PROP_PICKABLE)
1390	prop (CFAPI_INT, OBJECT_PROP_STR)
1391	prop (CFAPI_INT, OBJECT_PROP_DEX)
1392	prop (CFAPI_INT, OBJECT_PROP_CON)
1393	prop (CFAPI_INT, OBJECT_PROP_WIS)
1394	prop (CFAPI_INT, OBJECT_PROP_INT)
1395	prop (CFAPI_INT, OBJECT_PROP_POW)
1396	prop (CFAPI_INT, OBJECT_PROP_CHA)
1397	prop (CFAPI_INT, OBJECT_PROP_WC)
1398	prop (CFAPI_INT, OBJECT_PROP_AC)
1399	prop (CFAPI_INT, OBJECT_PROP_HP)
1400	prop (CFAPI_INT, OBJECT_PROP_SP)
1401	prop (CFAPI_INT, OBJECT_PROP_GP)
1402	prop (CFAPI_INT, OBJECT_PROP_FP)
1403	prop (CFAPI_INT, OBJECT_PROP_MAXHP)
1404	prop (CFAPI_INT, OBJECT_PROP_MAXSP)
1405	prop (CFAPI_INT, OBJECT_PROP_MAXGP)
1406	prop (CFAPI_INT, OBJECT_PROP_DAM)
1407	prop (CFAPI_STRING, OBJECT_PROP_GOD)
1408	prop (CFAPI_STRING, OBJECT_PROP_ARCH_NAME)
1409	prop (CFAPI_INT, OBJECT_PROP_INVISIBLE)
1410	prop (CFAPI_INT, OBJECT_PROP_FACE)
1411	};
1412
1413	HV *prop_type = get_hv ("cf::PROP_TYPE", 1);
1414	HV *prop_idx = get_hv ("cf::PROP_IDX", 1);
1415
1416	for (cprop = prop_table + sizeof (prop_table) / sizeof (prop_table [0]); cprop-- > prop_table; )
1417	{	1532	{
1418	hv_store (prop_type, cprop->name, strlen (cprop->name), newSViv (cprop->dtype), 0);	1533	AV *event = newAV ();
1419	hv_store (prop_idx, cprop->name, strlen (cprop->name), newSViv (cprop->idx ), 0);	1534	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));
		1535	av_push (event, newSViv (eiv->klass));
		1536	av_store (av, eiv->iv, newRV_noinc ((SV *)event));
		1537	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));
1420	}	1538	}
1421		1539
1422	//I_EVENT_API (PACKAGE);	1540	// used by autogenerated BOOT sections from genacc
		1541	av_reflect = get_av ("cf::REFLECT", 1);
		1542	}
		1543
		1544	void _gv_clear (SV *gv)
		1545	CODE:
		1546	assert (SvTYPE (gv) == SVt_PVGV);
		1547	# define f(sv) { SV *sv_ = (SV *)(sv); sv = 0; SvREFCNT_dec (sv_); }
		1548	SvREFCNT_inc (gv);
		1549	f (GvGP (gv)->gp_form);
		1550	f (GvGP (gv)->gp_io);
		1551	f (GvGP (gv)->gp_sv);
		1552	f (GvGP (gv)->gp_av);
		1553	f (GvGP (gv)->gp_hv);
		1554	f (GvGP (gv)->gp_cv);
		1555	GvCVGEN (gv) = 0;
		1556	GvMULTI_off (gv);
		1557	SvREFCNT_dec (gv);
		1558	# undef f
		1559
		1560	void _connect_to_perl_1 ()
		1561
		1562	void _connect_to_perl_2 ()
		1563
		1564	void _recalc_want ()
		1565
		1566	# not used by default anymore
		1567	void _global_reattach ()
		1568	CODE:
		1569	{
		1570	// reattach to all attachable objects in the game.
		1571	for_all_clients (ns)
		1572	ns->reattach ();
		1573
		1574	for_all_objects (op)
		1575	op->reattach ();
		1576	}
		1577
		1578	void init_anim ()
		1579
		1580	void init_globals ()
		1581
		1582	void init_attackmess ()
		1583
		1584	void init_dynamic ()
		1585
		1586	void load_settings ()
		1587
		1588	void _reload_exp_table ()
		1589
		1590	void _reload_materials ()
		1591
		1592	void init_uuid ()
		1593	CODE:
		1594	UUID::init ();
		1595
		1596	void init_signals ()
		1597
		1598	void init_skills ()
		1599
		1600	void init_beforeplay ()
		1601
		1602	void evthread_start (int aiofd)
		1603
		1604	void cede_to_tick ()
		1605	CODE:
		1606	coroapi::cede_to_tick ();
		1607
		1608	NV till_tick ()
		1609	CODE:
		1610	RETVAL = SvNVX (sv_next_tick) - now ();
		1611	OUTPUT:
		1612	RETVAL
		1613
		1614	int tick_inhibit ()
		1615	CODE:
		1616	RETVAL = tick_inhibit;
		1617	OUTPUT:
		1618	RETVAL
		1619
		1620	void tick_inhibit_inc ()
		1621	CODE:
		1622	++tick_inhibit;
		1623
		1624	void tick_inhibit_dec ()
		1625	CODE:
		1626	if (!--tick_inhibit)
		1627	if (tick_pending)
		1628	{
		1629	ev_async_send (EV_DEFAULT, &tick_watcher);
		1630	coroapi::cede ();
		1631	}
		1632
		1633	void one_tick ()
		1634	CODE:
		1635	{
		1636	ev_now_update (EV_DEFAULT);
		1637	NOW = ev_now (EV_DEFAULT);
		1638	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1639	SvNV_set (sv_tick_start, NOW); SvNOK_only (sv_tick_start);
		1640	runtime = SvNVX (sv_runtime);
		1641
		1642	one_tick ();
		1643
		1644	++server_tick;
		1645	SvUV_set (sv_server_tick, server_tick); SvIOK_only_UV (sv_server_tick);
		1646
		1647	ev_now_update (EV_DEFAULT);
		1648	NOW = ev_now (EV_DEFAULT);
		1649	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1650
		1651	runtime += TICK;
		1652	SvNV_set (sv_runtime, runtime); SvNOK_only (sv_runtime);
1423	}	1653	}
1424		1654
1425	NV floor (NV x)	1655	NV floor (NV x)
1426		1656
1427	NV ceil (NV x)	1657	NV ceil (NV x)
1428		1658
1429	void	1659	NV rndm (...)
1430	LOG (int level, char *msg)	1660	ALIAS:
		1661	rmg_rndm = 1
		1662	CODE:
		1663	{
		1664	rand_gen &gen = ix ? rmg_rndm : rndm;
		1665	switch (items)
		1666	{
		1667	case 0: RETVAL = gen (); break;
		1668	case 1: RETVAL = gen (SvUV (ST (0))); break;
		1669	case 2: RETVAL = gen (SvIV (ST (0)), SvIV (ST (1))); break;
		1670	default: croak ("cf::rndm requires zero, one or two parameters."); break;
		1671	}
		1672	}
		1673	OUTPUT:
		1674	RETVAL
		1675
		1676	NV clamp (NV value, NV min_value, NV max_value)
		1677	CODE:
		1678	RETVAL = clamp (value, min_value, max_value);
		1679	OUTPUT:
		1680	RETVAL
		1681
		1682	NV lerp (NV value, NV min_in, NV max_in, NV min_out, NV max_out)
		1683	CODE:
		1684	RETVAL = lerp (value, min_in, max_in, min_out, max_out);
		1685	OUTPUT:
		1686	RETVAL
		1687
		1688	const char *ordinal (int i)
		1689
		1690	void weaken (...)
		1691	PROTOTYPE: @
		1692	CODE:
		1693	while (items > 0)
		1694	sv_rvweaken (ST (--items));
		1695
		1696	void log_suspend ()
		1697
		1698	void log_resume ()
		1699
		1700	void log_backtrace (utf8_string msg)
		1701
		1702	void LOG (int flags, utf8_string msg)
1431	PROTOTYPE: $$	1703	PROTOTYPE: $$
1432	C_ARGS: (LogLevel)level, "%s", msg	1704	C_ARGS: flags, "%s", msg
1433		1705
1434	char *path_combine (char *base, char *path)	1706	octet_string path_combine (octet_string base, octet_string path)
1435	PROTOTYPE: $$	1707	PROTOTYPE: $$
1436		1708
1437	char *path_combine_and_normalize (char *base, char *path)	1709	octet_string path_combine_and_normalize (octet_string base, octet_string path)
1438	PROTOTYPE: $$	1710	PROTOTYPE: $$
1439		1711
1440	char *
1441	cf_get_maps_directory (char *path)
1442	PROTOTYPE: $
1443	ALIAS: maps_directory = 0
1444
1445	void	1712	void
1446	sub_generation_inc ()	1713	sub_generation_inc ()
1447	CODE:	1714	CODE:
1448	PL_sub_generation++;	1715	PL_sub_generation++;
1449		1716
1450	char *	1717	const_octet_string
1451	mapdir ()	1718	mapdir ()
1452	PROTOTYPE:	1719	PROTOTYPE:
1453	ALIAS:	1720	ALIAS:
1454	mapdir = 0	1721	mapdir = 0
1455	uniquedir = 1	1722	uniquedir = 1
…		…
1457	confdir = 3	1724	confdir = 3
1458	localdir = 4	1725	localdir = 4
1459	playerdir = 5	1726	playerdir = 5
1460	datadir = 6	1727	datadir = 6
1461	CODE:	1728	CODE:
1462	{	1729	switch (ix)
1463	int unused_type;	1730	{
1464	RETVAL = (char *)systemDirectory (&unused_type, ix);	1731	case 0: RETVAL = settings.mapdir ; break;
1465	}	1732	case 1: RETVAL = settings.uniquedir; break;
		1733	case 2: RETVAL = settings.tmpdir ; break;
		1734	case 3: RETVAL = settings.confdir ; break;
		1735	case 4: RETVAL = settings.localdir ; break;
		1736	case 5: RETVAL = settings.playerdir; break;
		1737	case 6: RETVAL = settings.datadir ; break;
		1738	}
1466	OUTPUT: RETVAL	1739	OUTPUT: RETVAL
1467		1740
		1741	void abort ()
		1742
		1743	void reset_signals ()
		1744
		1745	void fork_abort (const_octet_string cause = "cf::fork_abort")
		1746
		1747	void cleanup (const_octet_string cause, bool make_core = false)
		1748
		1749	void emergency_save ()
		1750
		1751	void _exit (int status = EXIT_SUCCESS)
		1752
		1753	#if _POSIX_MEMLOCK
		1754
		1755	int mlockall (int flags = MCL_CURRENT | MCL_FUTURE)
		1756	INIT:
		1757	#if __GLIBC__
		1758	mallopt (M_TOP_PAD, 1024 * 1024);
		1759	mallopt (M_MMAP_THRESHOLD, 1024 * 1024);
		1760	mallopt (M_MMAP_MAX, 0); // likely bug-workaround, also frees memory
		1761	if (__GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ < 10))
		1762	mallopt (M_PERTURB, 0xee); // bug-workaround for linux glibc+mlockall+calloc
		1763	#endif
		1764
		1765	int munlockall ()
		1766
		1767	#endif
		1768
1468	int	1769	int
1469	cf_find_animation (char *text)	1770	malloc_trim (IV pad = 0)
		1771
		1772	void
		1773	mallinfo ()
		1774	PPCODE:
		1775	{
		1776	#if __GLIBC__
		1777	struct mallinfo mai = mallinfo ();
		1778	EXTEND (SP, 10*2);
		1779	PUSHs (sv_2mortal (newSVpv ("arena" , 0))); PUSHs (sv_2mortal (newSViv (mai.arena)));
		1780	PUSHs (sv_2mortal (newSVpv ("ordblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.ordblks)));
		1781	PUSHs (sv_2mortal (newSVpv ("smblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.smblks)));
		1782	PUSHs (sv_2mortal (newSVpv ("hblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblks)));
		1783	PUSHs (sv_2mortal (newSVpv ("hblkhd" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblkhd)));
		1784	PUSHs (sv_2mortal (newSVpv ("usmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.usmblks)));
		1785	PUSHs (sv_2mortal (newSVpv ("fsmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.fsmblks)));
		1786	PUSHs (sv_2mortal (newSVpv ("uordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.uordblks)));
		1787	PUSHs (sv_2mortal (newSVpv ("fordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.fordblks)));
		1788	PUSHs (sv_2mortal (newSVpv ("keepcost", 0))); PUSHs (sv_2mortal (newSViv (mai.keepcost)));
		1789	#endif
		1790	EXTEND (SP, 5*2);
		1791	PUSHs (sv_2mortal (newSVpv ("slice_alloc", 0))); PUSHs (sv_2mortal (newSVuv (slice_alloc)));
		1792	PUSHs (sv_2mortal (newSVpv ("shstr_alloc", 0))); PUSHs (sv_2mortal (newSVuv (shstr_alloc)));
		1793	PUSHs (sv_2mortal (newSVpv ("objects" , 0))); PUSHs (sv_2mortal (newSVuv (objects.size () * sizeof (object))));
		1794	PUSHs (sv_2mortal (newSVpv ("sv_count" , 0))); PUSHs (sv_2mortal (newSVuv (PL_sv_count)));
		1795	PUSHs (sv_2mortal (newSVpv ("sv_objcount", 0))); PUSHs (sv_2mortal (newSVuv (PL_sv_objcount)));
		1796	}
		1797
		1798	int random_roll (int min, int max, object *op, int goodbad);
		1799
		1800	const_utf8_string cost_string_from_value(uint64 cost, int approx = 0)
		1801
		1802	int exp_to_level (val64 exp)
		1803
		1804	val64 level_to_min_exp (int level)
		1805
		1806	const_utf8_string
		1807	spellpathnames (int idx)
		1808	CODE:
		1809	RETVAL = spellpathnames [idx];
		1810	OUTPUT: RETVAL
		1811
		1812	SV *
		1813	attacktype_name (int atnr)
		1814	CODE:
		1815	RETVAL = IN_RANGE_EXC (atnr, 0, NROFATTACKS)
		1816	? newSVpv (attacktype_name [atnr], 0)
		1817	: &PL_sv_undef;
		1818	OUTPUT: RETVAL
		1819
		1820	SV *
		1821	attacktype_desc (int atnr)
		1822	CODE:
		1823	RETVAL = IN_RANGE_EXC (atnr, 0, NROFATTACKS)
		1824	? newSVpv (attacktype_desc [atnr], 0)
		1825	: &PL_sv_undef;
		1826	OUTPUT: RETVAL
		1827
		1828	SV *
		1829	resist_plus (int atnr)
		1830	CODE:
		1831	RETVAL = IN_RANGE_EXC (atnr, 0, NROFATTACKS)
		1832	? newSVpv (resist_plus [atnr], 0)
		1833	: &PL_sv_undef;
		1834	OUTPUT: RETVAL
		1835
		1836	SV *
		1837	change_resist_msg (int atnr)
		1838	CODE:
		1839	RETVAL = IN_RANGE_EXC (atnr, 0, NROFATTACKS)
		1840	? newSVpv (change_resist_msg [atnr], 0)
		1841	: &PL_sv_undef;
		1842	OUTPUT: RETVAL
		1843
		1844	UUID
		1845	uuid_cur ()
		1846	CODE:
		1847	RETVAL = UUID::cur;
		1848	OUTPUT:
		1849	RETVAL
		1850
		1851	UUID
		1852	uuid_gen ()
		1853	CODE:
		1854	RETVAL = UUID::gen ();
		1855	OUTPUT:
		1856	RETVAL
		1857
		1858	val64
		1859	uuid_seq (UUID uuid)
		1860	CODE:
		1861	RETVAL = uuid.seq;
		1862	OUTPUT:
		1863	RETVAL
		1864
		1865	UUID
		1866	uuid_str (val64 seq)
		1867	CODE:
		1868	RETVAL.seq = seq;
		1869	OUTPUT:
		1870	RETVAL
		1871
		1872	void
		1873	coin_names ()
		1874	PPCODE:
		1875	EXTEND (SP, NUM_COINS);
		1876	for (int i = 0; i < NUM_COINS; ++i)
		1877	PUSHs (sv_2mortal (newSVpv (coins [i], 0)));
		1878
		1879	void
		1880	coin_archetypes ()
		1881	PPCODE:
		1882	EXTEND (SP, NUM_COINS);
		1883	for (int i = 0; i < NUM_COINS; ++i)
		1884	PUSHs (sv_2mortal (to_sv (archetype::find (coins [i]))));
		1885
		1886	bool
		1887	load_resource_file_ (octet_string filename)
		1888
		1889	void
		1890	fix_weight ()
		1891
		1892	utf8_string
		1893	expand_cfpod (int hintmode, int gender, const_utf8_string cfpod)
		1894	PPCODE:
		1895	XPUSHs (to_sv (player::expand_cfpod (hintmode, gender, cfpod)));
		1896
		1897	MODULE = cf PACKAGE = cf::attachable
		1898
		1899	int
		1900	valid (SV *obj)
		1901	CODE:
		1902	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
		1903	OUTPUT:
		1904	RETVAL
		1905
		1906	bool should_invoke (attachable *obj, int event)
		1907	CODE:
		1908	RETVAL = obj->should_invoke ((event_type)event);
		1909	OUTPUT: RETVAL
		1910
		1911	void
		1912	debug_trace (attachable *obj, bool on = true)
		1913	CODE:
		1914	obj->attachable_flags &= ~attachable::F_DEBUG_TRACE;
		1915	if (on)
		1916	obj->attachable_flags |= attachable::F_DEBUG_TRACE;
		1917
		1918	int mortals_size ()
		1919	CODE:
		1920	RETVAL = attachable::mortals.size ();
		1921	OUTPUT: RETVAL
		1922
		1923	#object *mortals (U32 index)
		1924	# CODE:
		1925	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;
		1926	# OUTPUT: RETVAL
		1927
		1928	INCLUDE: $PERL $srcdir/genacc attachable $srcdir/../include/util.h $srcdir/../include/cfperl.h |
		1929
		1930	MODULE = cf PACKAGE = cf::global
		1931
		1932	int invoke (SV *klass, int event, ...)
		1933	CODE:
		1934	if (KLASS_OF (event) != KLASS_GLOBAL) croak ("event class must be GLOBAL");
		1935	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
		1936	for (int i = 1; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
		1937	RETVAL = gbl_ev.invoke ((event_type)event, ARG_AV (av), DT_END);
		1938	OUTPUT: RETVAL
		1939
		1940	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
		1941
		1942	INCLUDE: $PERL $srcdir/genacc object $srcdir/../include/object.h |
		1943
		1944	int invoke (object *op, int event, ...)
		1945	CODE:
		1946	if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");
		1947	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
		1948	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
		1949	RETVAL = op->invoke ((event_type)event, ARG_AV (av), DT_END);
		1950	OUTPUT: RETVAL
		1951
		1952	SV *registry (object *op)
		1953
		1954	int objects_size ()
		1955	CODE:
		1956	RETVAL = objects.size ();
		1957	OUTPUT: RETVAL
		1958
		1959	object *objects (U32 index)
		1960	CODE:
		1961	RETVAL = index < objects.size () ? objects [index] : 0;
		1962	OUTPUT: RETVAL
		1963
		1964	int actives_size ()
		1965	CODE:
		1966	RETVAL = actives.size ();
		1967	OUTPUT: RETVAL
		1968
		1969	object *actives (U32 index)
		1970	CODE:
		1971	RETVAL = index < actives.size () ? actives [index] : 0;
		1972	OUTPUT: RETVAL
		1973
		1974	int mortals_size ()
		1975	CODE:
		1976	RETVAL = attachable::mortals.size ();
		1977	OUTPUT: RETVAL
		1978
		1979	const_utf8_string slot_name (U32 slot)
		1980	ALIAS:
		1981	slot_name = 0
		1982	slot_use_name = 1
		1983	slot_nonuse_name = 2
		1984	CODE:
		1985	{
		1986	if (slot >= NUM_BODY_LOCATIONS)
		1987	croak ("body slot index out of range");
		1988
		1989	switch (ix)
		1990	{
		1991	case 0: RETVAL = body_locations[slot].name ; break;
		1992	case 1: RETVAL = body_locations[slot].use_name ; break;
		1993	case 2: RETVAL = body_locations[slot].nonuse_name; break;
		1994	}
		1995	}
		1996	OUTPUT:
		1997	RETVAL
		1998
		1999	# missing properties
		2000
		2001	object *head (object *op)
1470	PROTOTYPE: $	2002	PROTOTYPE: $
1471		2003	CODE:
1472	int random_roll(int min, int max, object *op, int goodbad);	2004	RETVAL = op->head_ ();
1473
1474	const char *cost_string_from_value(uint64 cost, int approx = 0)
1475
1476	int
1477	exp_to_level (val64 exp)
1478	CODE:
1479	{
1480	int i = 0;
1481
1482	RETVAL = settings.max_level;
1483
1484	for (i = 1; i <= settings.max_level; i++)
1485	{
1486	if (levels[i] > exp)
1487	{
1488	RETVAL = i - 1;
1489	break;
1490	}
1491	}
1492	}
1493	OUTPUT: RETVAL	2005	OUTPUT: RETVAL
1494
1495	val64
1496	level_to_min_exp (int level)
1497	CODE:
1498	if (level > settings.max_level)
1499	RETVAL = levels[settings.max_level];
1500	else if (level < 1)
1501	RETVAL = 0;
1502	else
1503	RETVAL = levels[level];
1504	OUTPUT: RETVAL
1505
1506	SV *
1507	resistance_to_string (int atnr)
1508	CODE:
1509	if (atnr >= 0 && atnr < NROFATTACKS)
1510	RETVAL = newSVpv (resist_plus[atnr], 0);
1511	else
1512	XSRETURN_UNDEF;
1513	OUTPUT: RETVAL
1514
1515	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
1516
1517	SV *
1518	get_property (object *obj, int type, int idx)
1519	CODE:
1520	RETVAL = newSVcfapi (type, cf_object_get_property (obj, idx));
1521	OUTPUT: RETVAL
1522
1523	SV *
1524	set_property (object *obj, int type, int idx, SV *newval)
1525	CODE:
1526	switch (type)
1527	{
1528	case CFAPI_INT:
1529	cf_object_set_int_property (obj, idx, SvIV (newval));
1530	break;
1531	case CFAPI_LONG:
1532	cf_object_set_long_property (obj, idx, (long) SvVAL64 (newval));
1533	break;
1534	case CFAPI_DOUBLE:
1535	{
1536	int unused_type;
1537	object_set_property (&unused_type, obj, idx, (double)SvNV (newval));
1538	}
1539	break;
1540	case CFAPI_STRING:
1541	cf_object_set_string_property (obj, idx, SvOK (newval) ? SvPV_nolen (newval) : 0);
1542	break;
1543	case CFAPI_POBJECT:
1544	{
1545	int unused_type;
1546	object_set_property (&unused_type, obj, idx, (object *)SvPTR_ornull (newval, "cf::object"));
1547	}
1548	break;
1549	default:
1550	croak ("unhandled type '%d' in set_property '%d'", type, idx);
1551	}
1552
1553	# missing properties
1554
1555	void
1556	set_attacktype (object *obj, U32 attacktype)
1557	CODE:
1558	obj->attacktype = attacktype;
1559
1560	U32
1561	get_attacktype (object *obj)
1562	ALIAS:
1563	attacktype = 0
1564	CODE:
1565	RETVAL = obj->attacktype;
1566	OUTPUT: RETVAL
1567
1568	# missing in plug-in api, of course
1569	void
1570	set_food (object *obj, int food)
1571	CODE:
1572	obj->stats.food = food;
1573
1574	int
1575	get_food (object *obj)
1576	ALIAS:
1577	food = 0
1578	CODE:
1579	RETVAL = obj->stats.food;
1580	OUTPUT: RETVAL
1581		2006
1582	void	2007	void
1583	inv (object *obj)	2008	inv (object *obj)
1584	PROTOTYPE: $	2009	PROTOTYPE: $
1585	PPCODE:	2010	PPCODE:
1586	{	2011	{
1587	object *o;
1588	for (o = obj->inv; o; o = o->below)	2012	for (object *o = obj->inv; o; o = o->below)
1589	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));	2013	XPUSHs (sv_2mortal (to_sv (o)));
1590	}	2014	}
1591		2015
1592	int cf_object_get_resistance (object *op, int rtype)	2016	void
1593	ALIAS: resistance = 0	2017	set_animation (object *op, int idx)
		2018	CODE:
		2019	SET_ANIMATION (op, idx);
1594		2020
1595	int cf_object_get_flag (object *op, int flag)	2021	int
1596	ALIAS: flag = 0	2022	num_animations (object *op)
		2023	CODE:
		2024	RETVAL = NUM_ANIMATIONS (op);
		2025	OUTPUT: RETVAL
1597		2026
1598	void cf_object_set_flag (object *op, int flag, int value)	2027	int slot_info (object *op, UV slot, int value = 0)
		2028	ALIAS:
		2029	slot_used = 1
		2030	CODE:
		2031	{
		2032	if (slot >= NUM_BODY_LOCATIONS)
		2033	croak ("body slot index out of range");
1599		2034
1600	int need_identify (const object *obj);	2035	RETVAL = ix ? op->slot[slot].used : op->slot[slot].info;
		2036
		2037	if (items > 2)
		2038	if (ix)
		2039	op->slot[slot].used = value;
		2040	else
		2041	op->slot[slot].info = value;
		2042	}
		2043	OUTPUT:
		2044	RETVAL
		2045
		2046	object *find_best_object_match (object *op, utf8_string match)
1601		2047
1602	int apply_shop_mat (object *shop_mat, object *op);	2048	int apply_shop_mat (object *shop_mat, object *op);
1603		2049
1604	void cf_object_move (object *op, int dir, object *originator = op)	2050	int move (object *op, int dir, object *originator = op)
		2051	CODE:
		2052	RETVAL = op->move (dir, originator);
		2053	OUTPUT:
		2054	RETVAL
1605		2055
1606	void cf_object_apply (object *op, object *author, int flags = 0)
1607
1608	void cf_object_apply_below (object *op)	2056	void apply_below (object *op)
		2057	CODE:
		2058	player_apply_below (op);
1609		2059
1610	void cf_object_remove (object *op)	2060	int cast_heal (object *op, object *caster, object *spell, int dir = 0)
1611		2061
1612	void cf_object_free (object *op)	2062	int casting_level (object *caster, object *spell)
1613		2063
1614	object *cf_object_present_archname_inside (object *op, char *whatstr)
1615
1616	int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)
1617
1618	int cf_object_change_map (object *op, int x, int y, mapstruct *map)
1619
1620	object *cf_object_clone (object *op, int clonetype = 0)
1621
1622	int cf_object_pay_item (object *op, object *buyer)	2064	int pay_item (object *op, object *buyer)
		2065	CODE:
		2066	RETVAL = pay_for_item (op, buyer);
		2067	OUTPUT: RETVAL
1623		2068
1624	int cf_object_pay_amount (object *op, uint64 amount)	2069	int pay_amount (object *op, uint64 amount)
		2070	CODE:
		2071	RETVAL = pay_for_amount (amount, op);
		2072	OUTPUT: RETVAL
1625		2073
1626	void pay_player (object *op, uint64 amount)	2074	void pay_player (object *op, uint64 amount)
1627		2075
1628	val64 pay_player_arch (object *op, const char *arch, uint64 amount)	2076	val64 pay_player_arch (object *op, utf8_string arch, uint64 amount)
1629		2077
1630	int cf_object_cast_spell (object *caster, object *ctoo, int dir, object *spell_ob, char *stringarg = 0)	2078	int cast_spell (object *op, object *caster, int dir, object *spell_ob, utf8_string stringarg = 0)
1631		2079
1632	int cf_object_cast_ability (object *caster, object *ctoo, int dir, object *sp_, char *stringarg = 0)	2080	void learn_spell (object *op, object *sp, int special_prayer = 0)
		2081	CODE:
		2082	do_learn_spell (op, sp, special_prayer);
1633		2083
1634	void cf_object_learn_spell (object *op, object *sp)
1635
1636	void cf_object_forget_spell (object *op, object *sp)	2084	void forget_spell (object *op, object *sp)
		2085	CODE:
		2086	do_forget_spell (op, query_name (sp));
1637		2087
1638	object *cf_object_check_for_spell (object *op, char *spellname)	2088	object *check_for_spell (object *op, utf8_string spellname)
		2089	CODE:
		2090	RETVAL = check_spell_known (op, spellname);
		2091	OUTPUT: RETVAL
1639		2092
1640	int cf_object_query_money (object *op)	2093	int query_money (object *op)
1641	ALIAS: money = 0	2094	ALIAS: money = 0
1642		2095
1643	int cf_object_query_cost (object *op, object *who, int flags)	2096	val64 query_cost (object *op, object *who, int flags)
1644	ALIAS: cost = 0	2097	ALIAS: cost = 0
1645		2098
1646	void cf_object_activate_rune (object *op , object *victim)	2099	void spring_trap (object *op, object *victim)
1647		2100
1648	int cf_object_check_trigger (object *op, object *cause)	2101	int check_trigger (object *op, object *cause)
1649		2102
1650	int cf_object_out_of_map (object *op, int x, int y)
1651
1652	void cf_object_drop (object *op, object *author)	2103	void drop (object *who, object *op)
1653		2104
1654	void cf_object_take (object *op, object *author)
1655
1656	void cf_object_say (object *op, char *msg)
1657
1658	void cf_object_speak (object *op, char *msg)
1659
1660	object *cf_object_insert_object (object *op, object *container)
1661
1662	const char *cf_object_get_msg (object *ob)
1663	ALIAS: msg = 0
1664
1665	object *cf_object_insert_in_ob (object *ob, object *where)
1666
1667	int cf_object_teleport (object *op, mapstruct *map, int x, int y)
1668
1669	void cf_object_update (object *op, int flags)
1670
1671	void cf_object_pickup (object *op, object *what)	2105	void pick_up (object *who, object *op)
1672		2106
1673	object *cf_create_object_by_name (const char *name)	2107	void update_object (object *op, int action)
1674		2108
1675	void change_exp (object *op, uint64 exp, const char *skill_name = 0, int flag = 0)	2109	void change_exp (object *op, uint64 exp, shstr_tmp skill_name = shstr_tmp (), int flag = 0)
1676		2110
1677	void player_lvl_adj (object *who, object *skill = 0)	2111	void player_lvl_adj (object *who, object *skill = 0)
1678		2112
1679	int kill_object (object *op, int dam = 0, object *hitter = 0, int type = AT_PHYSICAL)	2113	int kill_object (object *op, int dam = 0, object *hitter = 0, int type = AT_PHYSICAL)
1680		2114
1681	int calc_skill_exp (object *who, object *op, object *skill);	2115	int calc_skill_exp (object *who, object *op, object *skill)
1682		2116
1683	void push_button (object *op);	2117	void push_button (object *op, object *originator)
1684		2118
1685	void use_trigger (object *op);	2119	void use_trigger (object *op, object *originator)
1686		2120
1687	void add_button_link (object *button, mapstruct *map, int connected);	2121	void handle_apply_yield (object *op)
1688		2122
1689	void remove_button_link (object *op);	2123	int convert_item (object *item, object *converter)
1690		2124
1691	void	2125	void fix_generated_item (object *op, object *creator, int difficulty, int max_magic, int flags);
1692	cf_object_set_resistance (object *op, int rtype, int val)
1693	CODE:
1694	if (rtype >= 0 && rtype < NROFATTACKS)
1695	op->resist[rtype] = val;
1696
1697		2126
1698	MODULE = cf PACKAGE = cf::object PREFIX = cf_	2127	MODULE = cf PACKAGE = cf::object PREFIX = cf_
1699		2128
1700	void cf_fix_object (object *pl)
1701	ALIAS: fix = 0
1702
1703	object *cf_insert_ob_in_ob (object *ob, object *where)
1704
1705	# no clean way to get an object from an archetype - stupid idiotic
1706	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.
1707
1708	object *new (const char *archetype = 0)	2129	object *new (utf8_string archetype = 0)
1709	PROTOTYPE: ;$	2130	PROTOTYPE: ;$
1710	CODE:	2131	CODE:
1711	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();	2132	RETVAL = archetype
		2133	? archetype::get (archetype)
		2134	: object::create ();
1712	OUTPUT:	2135	OUTPUT:
1713	RETVAL	2136	RETVAL
1714		2137
		2138	object *generate (utf8_string arch, object *creator)
		2139	CODE:
		2140	object *obj = archetype::get (arch);
		2141	fix_generated_item (obj, creator, 0, 0, GT_MINIMAL);
		2142	RETVAL = obj;
		2143	OUTPUT:
		2144	RETVAL
		2145
		2146	object *find_object (U32 tag)
		2147
		2148	object *find_object_uuid (UUID i)
		2149
		2150	# TODO: nuke
1715	object *insert_ob_in_map_at (object *ob, mapstruct *where, object_ornull *orig, int flag, int x, int y)	2151	object *insert_ob_in_map_at (object *ob, maptile *where, object_ornull *orig, int flag, int x, int y)
1716	PROTOTYPE: $$$$$$	2152	PROTOTYPE: $$$$$$
1717	CODE:	2153	CODE:
1718	{	2154	{
1719	int unused_type;	2155	RETVAL = insert_ob_in_map_at (ob, where, orig, flag, x, y);
1720	RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);
1721	}
1722		2156
1723	# syntatic sugar for easier use in event callbacks.	2157	if (RETVAL->destroyed ())
1724	const char *options (object *op)
1725	CODE:
1726	RETVAL = op->name;	2158	RETVAL = 0;
		2159	}
1727	OUTPUT:	2160	OUTPUT:
1728	RETVAL	2161	RETVAL
1729		2162
1730	player *contr (object *op)	2163	shstr
		2164	object::kv_get (shstr key)
1731	CODE:	2165	CODE:
1732	RETVAL = op->contr;	2166	RETVAL = THIS->kv.get (key);
		2167	OUTPUT:
1733	OUTPUT: RETVAL	2168	RETVAL
1734		2169
1735	const char *get_ob_key_value (object *op, const char *key)	2170	void
		2171	object::kv_del (shstr key)
		2172	CODE:
		2173	THIS->kv.del (key);
1736		2174
1737	bool set_ob_key_value (object *op, const char *key, const char *value = 0, int add_key = 1)	2175	void
		2176	object::kv_set (shstr key, shstr value)
		2177	CODE:
		2178	THIS->kv.set (key, value);
1738		2179
1739	object *get_nearest_player (object *ob)	2180	object *get_nearest_player (object *ob)
1740	ALIAS: nearest_player = 0	2181	ALIAS: nearest_player = 0
1741	PREINIT:	2182	PREINIT:
1742	extern object *get_nearest_player (object *);	2183	extern object *get_nearest_player (object *);
…		…
1744	void rangevector (object *ob, object *other, int flags = 0)	2185	void rangevector (object *ob, object *other, int flags = 0)
1745	PROTOTYPE: $$;$	2186	PROTOTYPE: $$;$
1746	PPCODE:	2187	PPCODE:
1747	{	2188	{
1748	rv_vector rv;	2189	rv_vector rv;
		2190
1749	get_rangevector (ob, other, &rv, flags);	2191	get_rangevector (ob, other, &rv, flags);
		2192
1750	EXTEND (SP, 5);	2193	EXTEND (SP, 5);
1751	PUSHs (newSVuv (rv.distance));	2194	PUSHs (sv_2mortal (newSVuv (rv.distance)));
1752	PUSHs (newSViv (rv.distance_x));	2195	PUSHs (sv_2mortal (newSViv (rv.distance_x)));
1753	PUSHs (newSViv (rv.distance_y));	2196	PUSHs (sv_2mortal (newSViv (rv.distance_y)));
1754	PUSHs (newSViv (rv.direction));	2197	PUSHs (sv_2mortal (newSViv (rv.direction)));
1755	PUSHs (newSVcfapi (CFAPI_POBJECT, rv.part));	2198	PUSHs (sv_2mortal (to_sv (rv.part)));
1756	}	2199	}
1757		2200
1758	bool on_same_map_as (object *ob, object *other)	2201	bool on_same_map_as (object *ob, object *other)
1759	CODE:	2202	CODE:
1760	RETVAL = on_same_map (ob, other);	2203	RETVAL = on_same_map (ob, other);
1761	OUTPUT: RETVAL	2204	OUTPUT: RETVAL
1762		2205
1763	char *	2206	const_utf8_string
1764	base_name (object *ob, int plural)	2207	base_name (object *op, int plural = op->nrof > 1)
1765	CODE:	2208	CODE:
1766	RETVAL = cf_query_base_name (ob, plural);	2209	RETVAL = query_base_name (op, plural);
1767	OUTPUT: RETVAL	2210	OUTPUT: RETVAL
1768		2211
1769	living *	2212	# return the tail of an object, excluding itself
		2213	void
1770	stats (object *ob)	2214	tail (object *op)
1771	CODE:	2215	PPCODE:
1772	RETVAL = &ob->stats;	2216	while ((op = op->more))
1773	OUTPUT: RETVAL	2217	XPUSHs (sv_2mortal (to_sv (op)));
1774
1775		2218
1776	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_	2219	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_
1777		2220
1778	player *player (object *op)	2221	player *player (object *op)
1779	CODE:	2222	CODE:
1780	RETVAL = op->contr;	2223	RETVAL = op->contr;
1781	OUTPUT: RETVAL	2224	OUTPUT: RETVAL
1782		2225
		2226	bool move_player (object *op, int dir)
		2227
1783	void cf_player_message (object *obj, char *txt, int flags = NDI_ORANGE | NDI_UNIQUE)	2228	void message (object *op, utf8_string txt, int flags = NDI_ORANGE | NDI_UNIQUE)
1784		2229	CODE:
1785	object *cf_player_send_inventory (object *op)	2230	new_draw_info (flags, 0, op, txt);
1786
1787	char *cf_player_get_ip (object *op)
1788	ALIAS: ip = 0
1789
1790	object *cf_player_get_marked_item (object *op)
1791	ALIAS: marked_item = 0
1792
1793	void cf_player_set_marked_item (object *op, object *ob)
1794
1795	partylist *cf_player_get_party (object *op)
1796	ALIAS: party = 0
1797
1798	void cf_player_set_party (object *op, partylist *party)
1799		2231
1800	void kill_player (object *op)	2232	void kill_player (object *op)
1801		2233
1802	MODULE = cf PACKAGE = cf::object::map PREFIX = cf_	2234	void esrv_send_item (object *pl, object *item)
		2235
		2236	void esrv_update_item (object *pl, int what, object *item)
		2237	C_ARGS: what, pl, item
		2238
		2239	void esrv_del_item (object *pl, int tag)
		2240	C_ARGS: pl->contr, tag
		2241
		2242	int command_summon (object *op, utf8_string params)
		2243
		2244	int command_arrest (object *op, utf8_string params)
		2245
1803		2246
1804	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_	2247	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
1805		2248
1806	player *cf_player_find (char *name)	2249	INCLUDE: $PERL $srcdir/genacc player $srcdir/../include/player.h |
1807	PROTOTYPE: $
1808		2250
1809	void cf_player_move (player *pl, int dir)	2251	int invoke (player *pl, int event, ...)
1810
1811	void MapNewmapCmd (player *pl)
1812
1813	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);
1814
1815	# nonstandard
1816	object *ob (player *pl)
1817	CODE:	2252	CODE:
1818	RETVAL = pl->ob;	2253	if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");
		2254	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
		2255	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
		2256	RETVAL = pl->invoke ((event_type)event, ARG_AV (av), DT_END);
1819	OUTPUT: RETVAL	2257	OUTPUT: RETVAL
1820		2258
1821	player *first ()	2259	SV *registry (player *pl)
1822	CODE:
1823	RETVAL = first_player;
1824	OUTPUT: RETVAL
1825		2260
1826	player *next (player *pl)	2261	void
		2262	save_stats (player *pl)
1827	CODE:	2263	CODE:
1828	RETVAL = pl->next;	2264	pl->ob->stats.hp = pl->ob->stats.maxhp;
1829	OUTPUT: RETVAL	2265	pl->ob->stats.sp = pl->ob->stats.maxsp;
		2266	pl->ob->stats.grace = pl->ob->stats.maxgrace;
		2267	pl->orig_stats = pl->ob->stats;
1830		2268
		2269	# should only be temporary
		2270	void esrv_new_player (player *pl)
		2271
		2272	#d# TODO: replace by blocked_los accessor, fix code using this
1831	bool	2273	bool
1832	cell_visible (player *pl, int dx, int dy)	2274	cell_visible (player *pl, int dx, int dy)
1833	CODE:	2275	CODE:
1834	RETVAL = FABS (dx) <= pl->socket.mapx / 2 && FABS (dy) <= pl->socket.mapy / 2	2276	RETVAL = pl->blocked_los (dx, dy) != LOS_BLOCKED;
1835	&& !pl->blocked_los [dx + pl->socket.mapx / 2][dy + pl->socket.mapy / 2];
1836	OUTPUT:	2277	OUTPUT:
1837	RETVAL	2278	RETVAL
1838		2279
1839	void	2280	void
1840	send (player *pl, SV *packet)	2281	send (player *pl, SV *packet)
1841	CODE:	2282	CODE:
1842	{	2283	{
1843	STRLEN len;	2284	STRLEN len;
1844	char *buf = SvPVbyte (packet, len);	2285	char *buf = SvPVbyte (packet, len);
1845		2286
1846	Write_String_To_Socket (&pl->socket, buf, len);	2287	if (len > MAXSOCKBUF)
		2288	pl->failmsg ("[packet too long for client]");
		2289	else if (pl->ns)
		2290	pl->ns->send_packet (buf, len);
1847	}	2291	}
		2292
		2293	void savebed (player *pl, SV *map_path = 0, SV *x = 0, SV *y = 0)
		2294	PROTOTYPE: $;$$$
		2295	PPCODE:
		2296	if (GIMME_V != G_VOID)
		2297	{
		2298	EXTEND (SP, 3);
		2299	PUSHs (sv_2mortal (newSVpv (pl->savebed_map, 0)));
		2300	PUSHs (sv_2mortal (newSViv (pl->bed_x)));
		2301	PUSHs (sv_2mortal (newSViv (pl->bed_y)));
		2302	}
		2303	if (map_path) sv_to (map_path, pl->savebed_map);
		2304	if (x) sv_to (x, pl->bed_x);
		2305	if (y) sv_to (y, pl->bed_y);
		2306
		2307	void
		2308	list ()
		2309	PPCODE:
		2310	for_all_players (pl)
		2311	XPUSHs (sv_2mortal (to_sv (pl)));
		2312
		2313
		2314	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_
		2315
		2316	int invoke (maptile *map, int event, ...)
		2317	CODE:
		2318	if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");
		2319	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
		2320	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
		2321	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);
		2322	OUTPUT: RETVAL
		2323
		2324	SV *registry (maptile *map)
		2325
		2326	void
		2327	find_tagged_objects (maptile *map, utf8_string tag = 0)
		2328	PPCODE:
		2329	{
		2330	if (!map->spaces)
		2331	XSRETURN_EMPTY;
		2332
		2333	if (tag)
		2334	{
		2335	shstr_cmp tag_ (tag);
		2336
		2337	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2338	for (object *op = ms->bot; op; op = op->above)
		2339	if (op->tag == tag_)
		2340	XPUSHs (sv_2mortal (to_sv (op)));
		2341	}
		2342	else
		2343	{
		2344	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2345	for (object *op = ms->bot; op; op = op->above)
		2346	if (op->tag)
		2347	XPUSHs (sv_2mortal (to_sv (op)));
		2348	}
		2349	}
		2350
		2351	INCLUDE: $PERL $srcdir/genacc maptile $srcdir/../include/map.h |
		2352
		2353	void
		2354	adjust_daylight ()
		2355	CODE:
		2356	maptile::adjust_daylight ();
1848		2357
1849	int	2358	int
1850	listening (player *pl, int new_value = -1)	2359	outdoor_darkness (int darkness = 0)
1851	CODE:	2360	CODE:
1852	RETVAL = pl->listening;	2361	RETVAL = maptile::outdoor_darkness;
1853	if (new_value >= 0)	2362	if (items)
1854	pl->listening = new_value;	2363	maptile::outdoor_darkness = darkness;
1855	OUTPUT:	2364	OUTPUT:
1856	RETVAL	2365	RETVAL
1857		2366
1858	void get_savebed (player *pl)
1859	ALIAS:
1860	savebed = 0
1861	PPCODE:
1862	EXTEND (SP, 3);
1863	PUSHs (sv_2mortal (newSVpv (pl->savebed_map, 0)));
1864	PUSHs (sv_2mortal (newSViv (pl->bed_x)));
1865	PUSHs (sv_2mortal (newSViv (pl->bed_y)));
1866
1867	void set_savebed (player *pl, char *map_path, int x, int y)
1868	CODE:
1869	strcpy (pl->savebed_map, map_path);
1870	pl->bed_x = x;
1871	pl->bed_y = y;
1872
1873	void	2367	void
1874	list ()	2368	maptile::instantiate ()
1875	PPCODE:
1876	{
1877	player *pl;
1878	for (pl = first_player; pl; pl = pl->next)
1879	XPUSHs (newSVcfapi (CFAPI_PPLAYER, pl));
1880	}
1881		2369
1882	bool	2370	maptile *new ()
1883	peaceful (player *pl, bool new_setting = 0)
1884	PROTOTYPE: $;$
1885	CODE:
1886	RETVAL = pl->peaceful;
1887	if (items > 1)
1888	pl->peaceful = new_setting;
1889	OUTPUT:
1890	RETVAL
1891
1892	living *
1893	orig_stats (player *pl)
1894	CODE:
1895	RETVAL = &pl->orig_stats;
1896	OUTPUT: RETVAL
1897
1898	living *
1899	last_stats (player *pl)
1900	CODE:
1901	RETVAL = &pl->last_stats;
1902	OUTPUT: RETVAL
1903
1904
1905	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_
1906
1907	SV *
1908	get_property (mapstruct *obj, int type, int idx)
1909	CODE:
1910	RETVAL = newSVcfapi (type, cf_map_get_property (obj, idx));
1911	OUTPUT: RETVAL
1912
1913	SV *
1914	set_property (mapstruct *obj, int type, int idx, SV *newval)
1915	CODE:
1916	switch (type)
1917	{
1918	case CFAPI_INT:
1919	cf_map_set_int_property (obj, idx, SvIV (newval));
1920	break;
1921	default:
1922	croak ("unhandled type '%d' in set_property '%d'", type, idx);
1923	}
1924
1925	mapstruct *new (int width, int height)
1926	PROTOTYPE:	2371	PROTOTYPE:
1927	CODE:	2372	CODE:
1928	{	2373	RETVAL = new maptile;
1929	int unused_type;
1930	RETVAL = (mapstruct*) map_get_map (&unused_type, 0, width, height);
1931	}
1932	OUTPUT:	2374	OUTPUT:
1933	RETVAL	2375	RETVAL
1934		2376
1935	void delete_map (mapstruct *map)	2377	void
1936		2378	maptile::players ()
1937	void clean_tmp_map (mapstruct *map)
1938
1939	void play_sound_map (mapstruct *map, int x, int y, int sound_num)
1940
1941	mapstruct *tile_map (mapstruct *map, unsigned int dir)
1942	CODE:	2379	PPCODE:
1943	RETVAL = dir < 4 ? map->tile_map [dir] : 0;	2380	if (GIMME_V == G_SCALAR)
		2381	XPUSHs (sv_2mortal (to_sv (THIS->players)));
		2382	else if (GIMME_V == G_ARRAY)
		2383	{
		2384	EXTEND (SP, THIS->players);
		2385	for_all_players (pl)
		2386	if (pl->ob && pl->ob->map == THIS)
		2387	PUSHs (sv_2mortal (to_sv (pl->ob)));
		2388	}
		2389
		2390	void
		2391	maptile::gen_quadmap (int x, int y, int z)
		2392	CODE:
		2393	gen_quadmap (THIS, x * 50, y * 50, z);
		2394
		2395	void
		2396	maptile::add_underlay (SV *data, int offset, int stride, SV *palette)
		2397	CODE:
		2398	{
		2399	if (!SvROK (palette) || SvTYPE (SvRV (palette)) != SVt_PVAV)
		2400	croak ("maptile::add_underlay: palette must be arrayref");
		2401
		2402	palette = SvRV (palette);
		2403
		2404	STRLEN idxlen;
		2405	const uint8 *idx = (const uint8 *)SvPVbyte (data, idxlen);
		2406
		2407	for (int x = 0; x < THIS->width; ++x)
		2408	for (int y = 0; y < THIS->height; ++y)
		2409	{
		2410	for (object *op = THIS->at (x, y).bot; op; op = op->above)
		2411	if (op->flag [FLAG_IS_FLOOR])
		2412	goto skip;
		2413
		2414	{
		2415	int offs = offset + y * stride + x;
		2416
		2417	if (IN_RANGE_EXC (offs, 0, idxlen))
		2418	{
		2419	if (SV **elem = av_fetch ((AV *)palette, idx [offs], 0))
		2420	{
		2421	object *ob = archetype::get (cfSvPVutf8_nolen (*elem));
		2422	ob->flag [FLAG_NO_MAP_SAVE] = true;
		2423	THIS->insert (ob, x, y, 0, INS_ABOVE_FLOOR_ONLY);
		2424
		2425	if (ob->randomitems && !ob->above)
		2426	{
		2427	ob->create_treasure (ob->randomitems);
		2428
		2429	for (object *op = ob->above; op; op = op->above)
		2430	op->flag [FLAG_NO_MAP_SAVE] = true;
		2431	// TODO: if this is a pickable object, then the item
		2432	// will at a bit weird - saving inside the player
		2433	// will clear the flag, but when the player drops
		2434	// it without logging out, it keeps the flag.
		2435	// nobody has reported this, but this can be rather
		2436	// annoying on persistent maps.
		2437	}
		2438	}
		2439	}
		2440	}
		2441	skip: ;
		2442	}
		2443	}
		2444
		2445	void
		2446	maptile::set_regiondata (SV *data, int offset, int stride, SV *palette)
		2447	CODE:
		2448	{
		2449	if (!SvROK (palette) || SvTYPE (SvRV (palette)) != SVt_PVAV)
		2450	croak ("maptile::set_regiondata: palette must be arrayref");
		2451
		2452	palette = SvRV (palette);
		2453
		2454	STRLEN idxlen;
		2455	const uint8 *idx = (const uint8 *)SvPVbyte (data, idxlen);
		2456
		2457	region_ptr *regionmap = new region_ptr [av_len ((AV *)palette) + 1];
		2458	uint8 *regions = salloc<uint8_t> (THIS->size ());
		2459
		2460	for (int i = av_len ((AV *)palette) + 1; i--; )
		2461	regionmap [i] = region::find (cfSvPVutf8_nolen (*av_fetch ((AV *)palette, i, 1)));
		2462
		2463	for (int y = 0; y < THIS->height; ++y)
		2464	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);
		2465
		2466	sfree (THIS->regions, THIS->size ());
		2467	delete [] THIS->regionmap;
		2468
		2469	THIS->regions = regions;
		2470	THIS->regionmap = regionmap;
		2471	}
		2472
		2473	void
		2474	maptile::create_region_treasure ()
		2475	CODE:
		2476	for (int x = 0; x < THIS->width; ++x)
		2477	for (int y = 0; y < THIS->height; ++y)
		2478	{
		2479	region *rgn = THIS->region (x, y);
		2480
		2481	if (object *op = THIS->at (x, y).top)
		2482	if (rgn->treasure && rndm () < rgn->treasure_density)
		2483	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);
		2484	}
		2485
		2486	int out_of_map (maptile *map, int x, int y)
		2487
		2488	void
		2489	find_link (maptile *map, shstr_tmp connection)
		2490	PPCODE:
		2491	if (oblinkpt *obp = map->find_link (connection))
		2492	for (objectlink *ol = obp->link; ol; ol = ol->next)
		2493	XPUSHs (sv_2mortal (to_sv ((object *)ol->ob)));
		2494
		2495	void
		2496	xy_normalise (maptile *map, int x, int y, int dir = 0)
		2497	PPCODE:
		2498	{
		2499	mapxy pos (map, x, y);
		2500	if (!pos.move (dir).normalise ())
		2501	XSRETURN_EMPTY;
		2502
		2503	EXTEND (SP, 3);
		2504	PUSHs (sv_2mortal (to_sv (pos.m)));
		2505	PUSHs (sv_2mortal (to_sv (pos.x)));
		2506	PUSHs (sv_2mortal (to_sv (pos.y)));
		2507	}
		2508
		2509	mapspace *
		2510	ms (maptile *map, unsigned int x, unsigned int y, int dir = 0)
		2511	PROTOTYPE: $$$;$
		2512	CODE:
		2513	{
		2514	mapxy pos (map, x, y);
		2515	if (!pos.move (dir).normalise ())
		2516	XSRETURN_UNDEF;
		2517
		2518	RETVAL = &*pos;
		2519	}
1944	OUTPUT:	2520	OUTPUT:
1945	RETVAL	2521	RETVAL
1946		2522
1947	char *tile_path (mapstruct *map, unsigned int dir)
1948	CODE:
1949	if (dir >= 4)
1950	XSRETURN_UNDEF;
1951	RETVAL = map->tile_path [dir];
1952	OUTPUT:
1953	RETVAL
1954
1955	mapstruct *cf_map_get_map (char *name)
1956	PROTOTYPE: $
1957	ALIAS: map = 0
1958
1959	mapstruct *has_been_loaded (char *name)
1960	PROTOTYPE: $
1961
1962	mapstruct *cf_map_get_first ()
1963	PROTOTYPE:
1964	ALIAS: first = 0
1965
1966	# whoever "designed" the plug-in api should have wasted
1967	# his/her time with staying away from the project - would have
1968	# saved others a lot of time, without doubt.
1969	void set_path (mapstruct *where, char *path)
1970	CODE:
1971	strcpy (where->path, path);
1972
1973	int in_memory (mapstruct *map)
1974	CODE:
1975	RETVAL = map->in_memory;
1976	OUTPUT:
1977	RETVAL
1978
1979	bool unique (mapstruct *map)
1980	CODE:
1981	RETVAL = map->unique;
1982	OUTPUT:
1983	RETVAL
1984
1985	void set_unique (mapstruct *map, bool unique)
1986	CODE:
1987	map->unique = unique;
1988
1989	object *cf_map_insert_object_there (mapstruct *where, object *op, object *originator, int flags)
1990
1991	object *cf_map_insert_object (mapstruct *where, object* op, int x, int y)
1992
1993	object* cf_map_present_arch_by_name (mapstruct *map, const char* str, int nx, int ny)
1994	C_ARGS: str, map, nx, ny
1995
1996	void	2523	void
1997	cf_map_normalise (mapstruct *map, int x, int y)
1998	PPCODE:
1999	{
2000	mapstruct *nmap = 0;
2001	I16 nx = 0, ny = 0;
2002	int flags = cf_map_get_flags (map, &nmap, x, y, &nx, &ny);
2003
2004	EXTEND (SP, 4);
2005	PUSHs (sv_2mortal (newSViv (flags)));
2006
2007	if (GIMME_V == G_ARRAY)
2008	{
2009	PUSHs (sv_2mortal (newSVcfapi (CFAPI_PMAP, nmap)));
2010	PUSHs (sv_2mortal (newSViv (nx)));
2011	PUSHs (sv_2mortal (newSViv (ny)));
2012	}
2013	}
2014
2015	void
2016	at (mapstruct *map, unsigned int x, unsigned int y)	2524	at (maptile *map, unsigned int x, unsigned int y, int dir = 0)
2017	PROTOTYPE: $$$	2525	PROTOTYPE: $$$;$
2018	PPCODE:	2526	PPCODE:
2019	{	2527	mapxy pos (map, x, y);
2020	object *o;	2528	if (pos.move (dir).normalise ())
2021	mapstruct *nmap = 0;	2529	for (object *o = pos->bot; o; o = o->above)
2022	I16 nx, ny;	2530	XPUSHs (sv_2mortal (to_sv (o)));
2023
2024	cf_map_get_flags (map, &nmap, x, y, &nx, &ny);
2025
2026	if (nmap)
2027	for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)
2028	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));
2029	}
2030		2531
2031	SV *	2532	SV *
2032	bot_at (mapstruct *obj, unsigned int x, unsigned int y)	2533	bot_at (maptile *map, unsigned int x, unsigned int y, int dir = 0)
2033	PROTOTYPE: $$$	2534	PROTOTYPE: $$$;$
2034	ALIAS:	2535	ALIAS:
2035	top_at = 1	2536	top_at = 1
2036	flags_at = 2	2537	flags_at = 2
2037	light_at = 3	2538	light_at = 3
2038	move_block_at = 4	2539	move_block_at = 4
2039	move_slow_at = 5	2540	move_slow_at = 5
2040	move_on_at = 6	2541	move_on_at = 6
2041	move_off_at = 7	2542	move_off_at = 7
2042	INIT:
2043	if (x >= MAP_WIDTH (obj) || y >= MAP_HEIGHT (obj)) XSRETURN_UNDEF;
2044	CODE:	2543	CODE:
		2544	{
		2545	mapxy pos (map, x, y);
		2546	if (!pos.move (dir).normalise ())
		2547	XSRETURN_UNDEF;
		2548
		2549	mapspace &ms = *pos;
		2550
		2551	ms.update ();
		2552
2045	switch (ix)	2553	switch (ix)
2046	{	2554	{
2047	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;	2555	case 0: RETVAL = to_sv (ms.bot ); break;
2048	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;	2556	case 1: RETVAL = to_sv (ms.top ); break;
2049	case 2: RETVAL = newSVuv ( GET_MAP_FLAGS (obj, x, y)); break;	2557	case 2: RETVAL = newSVuv (ms.flags_ ); break;
2050	case 3: RETVAL = newSViv ( GET_MAP_LIGHT (obj, x, y)); break;	2558	case 3: RETVAL = newSViv (ms.light ); break;
2051	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;	2559	case 4: RETVAL = newSVuv (ms.move_block); break;
2052	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;	2560	case 5: RETVAL = newSVuv (ms.move_slow ); break;
2053	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;	2561	case 6: RETVAL = newSVuv (ms.move_on ); break;
2054	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;	2562	case 7: RETVAL = newSVuv (ms.move_off ); break;
2055	}	2563	}
		2564	}
2056	OUTPUT:	2565	OUTPUT: RETVAL
		2566
		2567	# worst xs function of my life
		2568	bool
		2569	_create_random_map (maptile *self, SV *options)
		2570	CODE:
		2571	{
		2572	random_map_params rmp ((HV *)SvRV (options));
		2573	RETVAL = self->generate_random_map (&rmp);
		2574	}
		2575	OUTPUT:
2057	RETVAL	2576	RETVAL
2058		2577
2059	# "serialise" map perl data into a ref	2578	MODULE = cf PACKAGE = cf::mapspace
		2579
		2580	INCLUDE: $PERL $srcdir/genacc mapspace $srcdir/../include/map.h |
		2581
		2582	MODULE = cf PACKAGE = cf::arch
		2583
		2584	int archetypes_size ()
		2585	CODE:
		2586	RETVAL = archetypes.size ();
		2587	OUTPUT: RETVAL
		2588
		2589	archetype *archetypes (U32 index)
		2590	CODE:
		2591	RETVAL = index < archetypes.size () ? archetypes [index] : 0;
		2592	OUTPUT: RETVAL
		2593
		2594	int skillvec_size ()
		2595	CODE:
		2596	RETVAL = skillvec.size ();
		2597	OUTPUT: RETVAL
		2598
		2599	archetype *skillvec (U32 index)
		2600	CODE:
		2601	RETVAL = index < skillvec.size () ? (archetype *)(object *)skillvec [index] : 0;
		2602	OUTPUT: RETVAL
		2603
2060	void	2604	void
2061	_get_obs (mapstruct *map)	2605	find_by_type (int type)
		2606	PPCODE:
		2607	for_all_archetypes (arch)
		2608	if (arch->type == type)
		2609	XPUSHs (sv_2mortal (to_sv (arch)));
		2610
		2611	INCLUDE: $PERL $srcdir/genacc archetype $srcdir/../include/object.h |
		2612
		2613	MODULE = cf PACKAGE = cf::party
		2614
		2615	partylist *first ()
		2616	PROTOTYPE:
		2617	CODE:
		2618	RETVAL = get_firstparty ();
		2619	OUTPUT: RETVAL
		2620
		2621	INCLUDE: $PERL $srcdir/genacc partylist $srcdir/../include/player.h |
		2622
		2623	MODULE = cf PACKAGE = cf::region
		2624
		2625	void
		2626	list ()
2062	PPCODE:	2627	PPCODE:
2063	{	2628	for_all_regions (rgn)
2064	object *o;	2629	XPUSHs (sv_2mortal (to_sv (rgn)));
2065	int x, y;
2066	AV *obs = newAV ();
2067	int nonnull = 0;
2068		2630
2069	for (y = 0; y < MAP_HEIGHT (map); y++)	2631	int specificity (region *rgn)
2070	for (x = 0; x < MAP_WIDTH (map); x++)	2632	CODE:
		2633	RETVAL = 0;
		2634	while (rgn = rgn->parent)
		2635	RETVAL++;
		2636	OUTPUT: RETVAL
		2637
		2638	INCLUDE: $PERL $srcdir/genacc region $srcdir/../include/region.h |
		2639
		2640	MODULE = cf PACKAGE = cf::living
		2641
		2642	INCLUDE: $PERL $srcdir/genacc living $srcdir/../include/living.h |
		2643
		2644	MODULE = cf PACKAGE = cf::settings
		2645
		2646	INCLUDE: $PERL $srcdir/genacc Settings $srcdir/../include/global.h |
		2647
		2648	MODULE = cf PACKAGE = cf::client
		2649
		2650	INCLUDE: $PERL $srcdir/genacc client $srcdir/../include/client.h |
		2651
		2652	int invoke (client *ns, int event, ...)
		2653	CODE:
		2654	if (KLASS_OF (event) != KLASS_CLIENT) croak ("event class must be CLIENT");
		2655	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
		2656	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
		2657	RETVAL = ns->invoke ((event_type)event, ARG_AV (av), DT_END);
		2658	OUTPUT: RETVAL
		2659
		2660	SV *registry (client *ns)
		2661
		2662	void
		2663	list ()
		2664	PPCODE:
		2665	EXTEND (SP, clients.size ());
		2666	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
		2667	PUSHs (sv_2mortal (to_sv (*i)));
		2668
		2669	STRLEN
		2670	client::inbuf_append (SV *data)
		2671	CODE:
		2672	{
		2673	STRLEN len;
		2674	char *ptr = SvPVbyte (data, len);
		2675
		2676	min_it (len, sizeof (THIS->inbuf) - THIS->inbuf_len);
		2677	memcpy (THIS->inbuf + THIS->inbuf_len, ptr, len);
		2678	THIS->inbuf_len += len;
		2679
		2680	THIS->inbuf_handle ();
		2681
		2682	RETVAL = len;
		2683	}
		2684	OUTPUT: RETVAL
		2685
		2686	void
		2687	client::send_packet (SV *packet)
		2688	CODE:
		2689	{
		2690	STRLEN len;
		2691	char *buf = SvPVbyte (packet, len);
		2692
		2693	if (len > MAXSOCKBUF)
2071	{	2694	{
2072	AV *av = newAV ();	2695	// ugly
2073		2696	if (THIS->pl)
2074	for (o = GET_MAP_OB (map, x, y); o; o = o->above)	2697	THIS->pl->failmsg ("[packet too long for client]");
2075	{
2076	SV *sv = SVptr_cache_get (o);
2077
2078	if (sv && HvFILL (SvRV (sv)))
2079	{
2080	nonnull = 1;
2081	sv = newSVsv (sv);
2082	}
2083	else
2084	sv = &PL_sv_undef;
2085
2086	av_push (av, sv);
2087	}
2088
2089	av_store (obs, x + y * MAP_HEIGHT (map), newRV_noinc ((SV *)av));
2090	}	2698	}
2091
2092	if (nonnull)
2093	XPUSHs (sv_2mortal (newRV_noinc ((SV *)obs)));
2094	else	2699	else
2095	SvREFCNT_dec (obs);	2700	THIS->send_packet (buf, len);
2096	}	2701	}
2097		2702
2098	# "deserialise" perl map data into the map	2703	faceidx
2099	void	2704	client::need_face (utf8_string name, int pri = 0)
2100	_set_obs (mapstruct *map, SV *sv)
2101	CODE:	2705	CODE:
2102	{	2706	RETVAL = face_find (name, 0);
2103	object *o;	2707	if (RETVAL)
2104	AV *av;
2105	int x, y;
2106	AV *obs = (AV *)SvRV (sv);
2107
2108	for (y = 0; y < MAP_HEIGHT (map); y++)
2109	for (x = 0; x < MAP_WIDTH (map); x++)
2110	{	2708	{
2111	sv = *av_fetch (obs, x + y * MAP_HEIGHT (map), 1);	2709	THIS->send_face (RETVAL, pri);
2112		2710	THIS->flush_fx ();
2113	if (!SvROK (sv))
2114	continue;
2115
2116	av = (AV *)SvRV (sv);
2117
2118	for (o = GET_MAP_OB (map, x, y); o; o = o->above)
2119	{
2120	sv = av_shift (av);
2121
2122	if (SvROK (sv))
2123	{
2124	sv_magic ((SV *)SvRV (sv), 0, PERL_MAGIC_ext, (char *)o, 0);
2125	SVptr_cache_set (o, sv);
2126	}
2127	}
2128	}	2711	}
2129	}	2712	OUTPUT:
		2713	RETVAL
2130		2714
		2715	int
		2716	client::fx_want (int idx, int value = -1)
		2717	CODE:
		2718	if (0 < idx && idx < FT_NUM)
		2719	{
		2720	RETVAL = THIS->fx_want [idx];
		2721	if (items > 2)
		2722	THIS->fx_want [idx] = value;
		2723	}
		2724	else
		2725	RETVAL = 0;
		2726	OUTPUT:
		2727	RETVAL
2131		2728
		2729	MODULE = cf PACKAGE = cf::sound PREFIX = sound_
		2730
		2731	faceidx sound_find (utf8_string name)
		2732
		2733	void sound_set (utf8_string str, faceidx face)
		2734
		2735	# dire hack
		2736	void old_sound_index (int idx, faceidx face)
		2737	CODE:
		2738	extern faceidx old_sound_index [SOUND_CAST_SPELL_0];
		2739	old_sound_index [idx] = face;
		2740
2132	MODULE = cf PACKAGE = cf::arch PREFIX = cf_archetype_	2741	MODULE = cf PACKAGE = cf::face PREFIX = face_
2133		2742
2134	archetype *cf_archetype_get_first()	2743	#INCLUDE: $PERL $srcdir/genacc faceset $srcdir/../include/face.h |
2135	PROTOTYPE:
2136	ALIAS: first = 0
2137		2744
2138	archetype *cf_archetype_get_next (archetype *arch)	2745	faceidx face_find (utf8_string name, faceidx defidx = 0)
2139	ALIAS: next = 0
2140		2746
2141	archetype *cf_archetype_get_head (archetype *arch)	2747	faceidx alloc (utf8_string name)
2142	ALIAS: head = 0	2748	CODE:
		2749	{
		2750	RETVAL = face_alloc ();
2143		2751
2144	archetype *cf_archetype_get_more (archetype *arch)	2752	faces [RETVAL].name = name;
2145	ALIAS: more = 0	2753	facehash.insert (std::make_pair (faces [RETVAL].name, RETVAL));
2146		2754
2147	const char *cf_archetype_get_name (archetype *arch)	2755	if (!strcmp (name, BLANK_FACE_NAME )) blank_face = RETVAL;
2148	ALIAS: name = 0	2756	if (!strcmp (name, EMPTY_FACE_NAME )) empty_face = RETVAL;
		2757	if (!strcmp (name, MAGICMOUTH_FACE_NAME)) magicmouth_face = RETVAL;
		2758	}
		2759	OUTPUT: RETVAL
2149		2760
2150	object *cf_archetype_get_clone (archetype *arch)	2761	faceidx faces_size ()
2151	ALIAS: clone = 0	2762	CODE:
		2763	RETVAL = faces.size ();
		2764	OUTPUT: RETVAL
2152		2765
2153	MODULE = cf PACKAGE = cf::party PREFIX = cf_party_	2766	void set_type (faceidx idx, int value)
2154		2767	ALIAS:
2155	partylist *cf_party_get_first ()
2156	PROTOTYPE:
2157	ALIAS: first = 0
2158
2159	partylist *cf_party_get_next (partylist *party)
2160	ALIAS: next = 0
2161
2162	const char *cf_party_get_name (partylist *party)
2163
2164	const char *cf_party_get_password (partylist *party)
2165	ALIAS: password = 0
2166
2167	player *cf_party_get_first_player (partylist *party)
2168	ALIAS: first_player = 0
2169
2170	player *cf_party_get_next_player (partylist *party, player *op)
2171	ALIAS: next_player = 0
2172
2173
2174	MODULE = cf PACKAGE = cf::region PREFIX = cf_region_
2175
2176	region *cf_region_get_first ()
2177	PROTOTYPE:
2178	ALIAS: first = 0
2179
2180	const char *cf_region_get_name (region *reg)
2181	ALIAS: name = 0
2182
2183	region *cf_region_get_next (region *reg)
2184	ALIAS: next = 0
2185
2186	region *cf_region_get_parent (region *reg)
2187	ALIAS: parent = 0
2188
2189	const char *cf_region_get_longname (region *reg)
2190	ALIAS: longname = 0
2191
2192	const char *cf_region_get_message (region *reg)
2193	ALIAS: message = 0
2194
2195
2196	MODULE = cf PACKAGE = cf::living PREFIX = cf_living_
2197
2198	val64
2199	exp (living *liv, val64 new_val = 0)
2200	PROTOTYPE: $;$
2201	ALIAS:
2202	Str = 1
2203	Dex = 2
2204	Con = 3
2205	Wis = 4
2206	Cha = 5
2207	Int = 6
2208	Pow = 7
2209	wc = 8
2210	ac = 9
2211	hp = 10	2768	set_type = 0
2212	maxhp = 11	2769	set_visibility = 1
2213	sp = 12	2770	set_magicmap = 2
2214	maxsp = 13	2771	set_smooth = 3
2215	grace = 14	2772	set_smoothlevel = 4
2216	maxgrace = 15	2773	CODE:
2217	food = 16	2774	faceinfo *f = face_info (idx); assert (f);
2218	dam = 17
2219	luck = 18
2220	CODE:
2221	# define LIVING_ACC(acc,idx) case idx: RETVAL = liv->acc; if (items > 1) liv->acc = (sint64)new_val; break
2222	switch (ix)	2775	switch (ix)
2223	{	2776	{
2224	LIVING_ACC (exp , 0);	2777	case 0: f->type = value; break;
2225	LIVING_ACC (Str , 1);	2778	case 1: f->visibility = value; break;
2226	LIVING_ACC (Dex , 2);	2779	case 2: f->magicmap = value; break;
2227	LIVING_ACC (Con , 3);	2780	case 3: f->smooth = value; break;
2228	LIVING_ACC (Wis , 4);	2781	case 4: f->smoothlevel = value; break;
2229	LIVING_ACC (Cha , 5);
2230	LIVING_ACC (Int , 6);
2231	LIVING_ACC (Pow , 7);
2232	LIVING_ACC (wc , 8);
2233	LIVING_ACC (ac , 9);
2234	LIVING_ACC (hp , 10);
2235	LIVING_ACC (maxhp , 11);
2236	LIVING_ACC (sp , 12);
2237	LIVING_ACC (maxsp , 13);
2238	LIVING_ACC (grace , 14);
2239	LIVING_ACC (maxgrace, 15);
2240	LIVING_ACC (food , 16);
2241	LIVING_ACC (dam , 17);
2242	LIVING_ACC (luck , 18);
2243	}	2782	}
2244	# undef LIVING_ACC	2783
		2784	void set_csum (faceidx idx, int faceset, SV *chksum)
		2785	CODE:
		2786	{
		2787	faceinfo *f = face_info (idx); assert (f);
		2788	facedata *d = f->face + faceset;
		2789	STRLEN clen;
		2790	char *cdata = SvPVbyte (chksum, clen);
		2791
		2792	assert (("cf::face::set_data called with too long checksum", clen <= CHKSUM_MAXLEN));
		2793	assert (("cf::face::set_data must be called with a non-empty checksum", clen));
		2794
		2795	if (clen != d->chksum_len || memcmp (d->chksum, cdata, clen))
		2796	{
		2797	d->chksum_len = clen;
		2798	memcpy (d->chksum, cdata, clen);
		2799
		2800	// invalidate existing client face info
		2801	for_all_clients (ns)
		2802	ns->invalidate_face (idx);
		2803	}
		2804	}
		2805
		2806	SV *mangle_csum (SV *chksum)
		2807	CODE:
		2808	STRLEN len;
		2809	char *data = SvPVbyte (chksum, len);
		2810	RETVAL = newSVpvn (data, min (len, CHKSUM_MAXLEN));
		2811	OUTPUT:
		2812	RETVAL
		2813
		2814	SV *get_csum (faceidx idx, int faceset = 0)
		2815	CODE:
		2816	facedata *d = face_data (idx, faceset);
		2817	if (!d) XSRETURN_UNDEF;
		2818	RETVAL = newSVpvn ((char *)d->chksum, d->chksum_len);
2245	OUTPUT:	2819	OUTPUT:
2246	RETVAL	2820	RETVAL
2247		2821
		2822	int get_type (faceidx idx)
		2823	CODE:
		2824	faceinfo *f = face_info (idx);
		2825	if (!f) XSRETURN_UNDEF;
		2826	RETVAL = f->type;
		2827	OUTPUT:
		2828	RETVAL
		2829
		2830	SV *get_name (faceidx idx)
		2831	CODE:
		2832	faceinfo *f = face_info (idx);
		2833	if (!f) XSRETURN_UNDEF;
		2834	RETVAL = to_sv (f->name);
		2835	OUTPUT:
		2836	RETVAL
		2837
		2838	void invalidate (faceidx idx)
		2839	CODE:
		2840	for_all_clients (ns)
		2841	ns->invalidate_face (idx);
		2842
		2843	void invalidate_all ()
		2844	CODE:
		2845	for_all_clients (ns)
		2846	ns->invalidate_all_faces ();
		2847
		2848	MODULE = cf PACKAGE = cf::anim PREFIX = anim_
		2849
		2850	#INCLUDE: $PERL $srcdir/genacc faceset $srcdir/../include/anim.h |
		2851
		2852	animidx anim_find (utf8_string name)
		2853	CODE:
		2854	RETVAL = animation::find (name).number;
		2855	OUTPUT: RETVAL
		2856
		2857	animidx set (utf8_string name, SV *frames, int facings = 1)
		2858	CODE:
		2859	{
		2860	if (!SvROK (frames) && SvTYPE (SvRV (frames)) != SVt_PVAV)
		2861	croak ("frames must be an arrayref");
		2862
		2863	AV *av = (AV *)SvRV (frames);
		2864
		2865	animation *anim = &animation::find (name);
		2866	if (anim->number)
		2867	{
		2868	anim->resize (av_len (av) + 1);
		2869	anim->facings = facings;
		2870	}
		2871	else
		2872	anim = &animation::create (name, av_len (av) + 1, facings);
		2873
		2874	for (int i = 0; i < anim->num_animations; ++i)
		2875	anim->faces [i] = face_find (cfSvPVutf8_nolen (*av_fetch (av, i, 1)));
		2876	}
		2877	OUTPUT: RETVAL
		2878
		2879	void invalidate_all ()
		2880	CODE:
		2881	for_all_clients (ns)
		2882	ns->anims_sent.reset ();
		2883
		2884	MODULE = cf PACKAGE = cf::object::freezer
		2885
		2886	INCLUDE: $PERL $srcdir/genacc object_freezer $srcdir/../include/cfperl.h |
		2887
		2888	SV *
		2889	new (char *klass)
		2890	CODE:
		2891	RETVAL = newSVptr (new object_freezer, gv_stashpv ("cf::object::freezer", 1));
		2892	OUTPUT: RETVAL
		2893
		2894	void
		2895	DESTROY (SV *sv)
		2896	CODE:
		2897	object_freezer *self;
		2898	sv_to (sv, self);
		2899	delete self;
		2900
		2901	MODULE = cf PACKAGE = cf::object::thawer
		2902
		2903	INCLUDE: $PERL $srcdir/genacc object_thawer $srcdir/../include/freezethaw.h |
		2904
		2905	bool
		2906	errors_are_fatal (bool fatal)
		2907	CODE:
		2908	RETVAL = object_thawer::errors_are_fatal;
		2909	object_thawer::errors_are_fatal = fatal;
		2910	OUTPUT:
		2911	RETVAL
		2912
		2913	SV *
		2914	new_from_file (char *klass, octet_string path)
		2915	CODE:
		2916	object_thawer *f = new object_thawer (path);
		2917	if (!*f)
		2918	{
		2919	delete f;
		2920	XSRETURN_UNDEF;
		2921	}
		2922	RETVAL = newSVptr (f, gv_stashpv ("cf::object::thawer", 1));
		2923	OUTPUT: RETVAL
		2924
		2925	void
		2926	DESTROY (SV *sv)
		2927	CODE:
		2928	object_thawer *self;
		2929	sv_to (sv, self);
		2930	delete self;
		2931
		2932	void
		2933	extract_tags (object_thawer *self)
		2934	PPCODE:
		2935	while (self->kw != KW_EOF)
		2936	{
		2937	PUTBACK;
		2938	coroapi::cede_to_tick ();
		2939	SPAGAIN;
		2940
		2941	if (self->kw == KW_tag)
		2942	XPUSHs (sv_2mortal (newSVpv_utf8 (self->get_str ())));
		2943
		2944	self->skip ();
		2945	}
		2946
		2947	MODULE = cf PACKAGE = cf::treasurelist
		2948
		2949	# quick hack, because I didn't want to implement accessors for treasurelist.
		2950	# this asks for even more autogen, actually.
		2951
		2952	void
		2953	expand (treasurelist *list)
		2954	PPCODE:
		2955	EXTEND (SP, 3);
		2956	PUSHs (sv_2mortal (to_sv (list->name)));
		2957	PUSHs (sv_2mortal (to_sv (list->total_chance)));
		2958	AV *av = newAV ();
		2959	PUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
		2960	for (treasure *item = list->items; item; item = item->next)
		2961	{
		2962	AV *iav = newAV ();
		2963	av_push (av, newRV_noinc ((SV *)iav));
		2964
		2965	av_extend (iav, 7);
		2966	av_push (iav, to_sv (item->item));
		2967	av_push (iav, to_sv (item->name));
		2968	av_push (iav, to_sv (item->change_arch.name));
		2969	av_push (iav, to_sv (item->change_arch.title));
		2970	av_push (iav, to_sv (item->change_arch.slaying));
		2971	av_push (iav, to_sv (item->chance));
		2972	av_push (iav, to_sv (item->nrof));
		2973	av_push (iav, to_sv (item->magic));
		2974	}
		2975
		2976	MODULE = cf PACKAGE = cf::layout
		2977
		2978	INCLUDE: $PERL $srcdir/genacc layout $srcdir/../include/rmg.h |
		2979

Diff Legend

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