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

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.1 by root, Tue Aug 15 17:10:46 2006 UTC vs. Revision 1.402 by root, Sun May 1 13:18:24 2011 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.1 by root, Tue Aug 15 17:10:46 2006 UTC vs.
Revision 1.402 by root, Sun May 1 13:18:24 2011 UTC