ViewVC Help

View File | Revision Log | Show Annotations | Download File

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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.207 by root, Fri May 11 08:00:00 2007 UTC vs.
Revision 1.328 by root, Tue Nov 3 22:57:06 2009 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 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
9	* Copyright (C) 2006,2007 by Marc Lehmann <cf@schmorp.de>	5	* Copyright (©) 2006,2007 by Marc Lehmann <cf@schmorp.de>
10	*	6	*
11	* This program is free software; you can redistribute it and/or modify	7	* 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	8	* 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	9	* Free Software Foundation, either version 3 of the License, or (at your
14	* (at your option) any later version.	10	* option) any later version.
15	*	11	*
16	* This program is distributed in the hope that it will be useful,	12	* This program is distributed in the hope that it will be useful,
17	* but WITHOUT ANY WARRANTY; without even the implied warranty of	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19	* GNU General Public License for more details.	15	* GNU General Public License for more details.
20	*	16	*
21	* You should have received a copy of the GNU General Public License	17	* 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	18	* 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	19	* <http://www.gnu.org/licenses/>.
		20	*
		21	* The authors can be reached via e-mail to <support@deliantra.net>
24	*/	22	*/
25		23
26	#include "autoconf.h"	24	#include "autoconf.h"
27
28	#define PLUGIN_NAME "perl"
29	#define PLUGIN_VERSION "cfperl 0.5"
30
31	#define CEDES_PER_TICK 5
32		25
33	#if HAVE_EXECINFO_H	26	#if HAVE_EXECINFO_H
34	# include <execinfo.h>	27	# include <execinfo.h>
35	#endif	28	#endif
36		29
37	#include <plugin_common.h>
38	#include <sounds.h>
39	#include <cstdarg>	30	#include <cstdarg>
40	#include <sproto.h>	31	#include <typeinfo>
41		32
		33	#include "global.h"
42	#include "loader.h"	34	#include "loader.h"
		35	#include "../random_maps/random_map.h"
43	#include "cfperl.h"	36	#include "evthread.h"
44	#include "shstr.h"	37	#include "sproto.h"
45		38
46	#include <unistd.h>	39	#include <unistd.h>
47	#if _POSIX_MEMLOCK	40	#if _POSIX_MEMLOCK
48	# include <sys/mman.h>	41	# include <sys/mman.h>
49	#endif	42	#endif
50		43
		44	#if HAVE_MALLOC_H
		45	# include <malloc.h>
		46	#endif
		47
		48	#if !__GLIBC__
		49	# define malloc_trim(pad) -1
		50	#endif
		51
51	#include <EXTERN.h>	52	#include <EXTERN.h>
52	#include <perl.h>	53	#include <perl.h>
53	#include <XSUB.h>	54	#include <XSUB.h>
54		55
55	#include "CoroAPI.h"	56	#include "CoroAPI.h"
56	#include "perlxsi.c"	57	#include "perlxsi.c"
57		58
58	extern sint64 *levels; // the experience table	59	extern sint64 *levels; // the experience table
59		60
60	typedef object object_ornull;	61	typedef object_thawer &object_thawer_ref;
61	typedef maptile maptile_ornull;	62	typedef object_freezer &object_freezer_ref;
62
63	typedef char *octet_string;
64	typedef char *utf8_string;
65	typedef const char *const_octet_string;
66	typedef const char *const_utf8_string;
67		63
68	typedef std::string std__string;	64	typedef std::string std__string;
69		65
70	#if IVSIZE >= 8
71	typedef IV val64;
72	# define newSVval64 newSViv
73	# define SvVAL64 SvIV
74	#else
75	typedef double val64;
76	# define newSVval64 newSVnv
77	# define SvVAL64 SvNV
78	#endif
79
80	static f_plug_api gethook = cfapi_get_hooks;
81	static f_plug_api object_set_property = cfapi_object_set_property;
82	static f_plug_api object_insert = cfapi_object_insert;
83
84	static PerlInterpreter *perl;	66	static PerlInterpreter *perl;
85		67
86	double runtime;	68	tstamp NOW, runtime;
		69
		70	static int tick_inhibit;
		71	static int tick_pending;
87		72
88	global gbl_ev;	73	global gbl_ev;
89	static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map;	74	static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map;
90	static SV *sv_runtime, *sv_next_tick;	75	static SV *sv_runtime, *sv_tick_start, *sv_next_tick, *sv_now;
		76	static AV *av_reflect;
		77
		78	bitset<NUM_EVENT_TYPES> ev_want_event;
		79	bitset<NUM_TYPES> ev_want_type;
91		80
92	static HV	81	static HV
93	*stash_cf,	82	*stash_cf,
94	*stash_cf_object_wrap,	83	*stash_cf_object_wrap,
95	*stash_cf_object_player_wrap,	84	*stash_cf_object_player_wrap,
96	*stash_cf_player_wrap,	85	*stash_cf_player_wrap,
97	*stash_cf_map_wrap,	86	*stash_cf_map_wrap,
		87	*stash_cf_mapspace_wrap,
98	*stash_cf_client_wrap,	88	*stash_cf_client_wrap,
99	*stash_cf_arch_wrap,	89	*stash_cf_arch_wrap,
100	*stash_cf_party_wrap,	90	*stash_cf_party_wrap,
101	*stash_cf_region_wrap,	91	*stash_cf_region_wrap,
102	*stash_cf_living_wrap;	92	*stash_cf_living_wrap;
		93
		94	static SV
		95	*cv_cf_do_invoke,
		96	*cv_cf__can_merge,
		97	*cv_cf_client_send_msg,
		98	*cv_cf_tick,
		99	*cv_cf_match_match;
		100
		101	#ifndef newSVpv_utf8
		102	static inline SV *
		103	newSVpv_utf8 (const char *s)
		104	{
		105	if (!s)
		106	return newSV (0);
		107
		108	SV *sv = newSVpv (s, 0);
		109	SvUTF8_on (sv);
		110	return sv;
		111	}
		112	#endif
		113
		114	#ifndef newSVpvn_utf8
		115	static inline SV *
		116	newSVpvn_utf8 (const char *s, STRLEN l, int utf8)
		117	{
		118	if (!s)
		119	return newSV (0);
		120
		121	SV *sv = newSVpvn (s, l);
		122
		123	if (utf8)
		124	SvUTF8_on (sv);
		125
		126	return sv;
		127	}
		128	#endif
103		129
104	// helper cast function, returns super class * or 0	130	// helper cast function, returns super class * or 0
105	template<class super>	131	template<class super>
106	static super *	132	static super *
107	is_a (attachable *at)	133	is_a (attachable *at)
…		…
140	SvREFCNT_inc (self);	166	SvREFCNT_inc (self);
141	hv_clear (self);	167	hv_clear (self);
142	sv_unmagic ((SV *)self, PERL_MAGIC_ext);	168	sv_unmagic ((SV *)self, PERL_MAGIC_ext);
143	SvREFCNT_dec (self);	169	SvREFCNT_dec (self);
144		170
145	// self *must* be null now because thats sv_unmagic's job.	171	// self *must* be null now because that's sv_unmagic's job.
146	assert (!this->self);	172	assert (!this->self);
147	}	173	}
148	}	174	}
149		175
150	void	176	void
…		…
167	}	193	}
168		194
169	void	195	void
170	attachable::do_destroy ()	196	attachable::do_destroy ()
171	{	197	{
172	invoke (EVENT_ATTACHABLE_DESTROY, DT_END);	198	INVOKE_ATTACHABLE (DESTROY, this);
173		199
174	if (cb)	200	if (cb)
175	{	201	{
176	SvREFCNT_dec (cb);	202	SvREFCNT_dec (cb);
177	cb = 0;	203	cb = 0;
…		…
200	{	226	{
201	if (i >= mortals.size ())	227	if (i >= mortals.size ())
202	{	228	{
203	i = 0;	229	i = 0;
204		230
205	if (mortals.size () > 1000)	231	if (mortals.size () >= 512)
		232	{
		233	static int last_mortalcount;
		234	if (mortals.size () != last_mortalcount)
		235	{
		236	last_mortalcount = mortals.size ();
206	LOG (llevInfo, "mortal queue size (%d) exceeds 1000.\n", (int)mortals.size ());	237	LOG (llevInfo, "%d mortals.\n", (int)mortals.size ());
		238
		239	if (0)
		240	{
		241	for (int j = 0; j < mortals.size (); ++j)//D
		242	fprintf (stderr, "%d:%s %p ", j, &((object *)mortals[j])->name, mortals[j]);//D
		243	fprintf (stderr, "\n");//D
		244	}
		245	}
		246	}
207		247
208	break;	248	break;
209	}	249	}
210		250
211	attachable *obj = mortals [i];	251	attachable *obj = mortals [i];
…		…
232	delete obj;	272	delete obj;
233	}	273	}
234	}	274	}
235	}	275	}
236		276
		277	void
		278	attachable::set_key (const char *key, const char *value, bool is_utf8)
		279	{
		280	if (!self)
		281	self = newHV ();
		282
		283	if (value)
		284	hv_store (self, key, strlen (key), is_utf8 ? newSVpv_utf8 (value) : newSVpv (value, 0), 0);
		285	else
		286	hv_delete (self, key, strlen (key), G_DISCARD);
		287	}
		288
237	attachable &	289	attachable &
238	attachable::operator =(const attachable &src)	290	attachable::operator =(const attachable &src)
239	{	291	{
240	//if (self || cb)	292	//if (self || cb)
241	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));	293	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));
242		294
243	attach = src.attach;	295	attach = src.attach;
244	return *this;	296	return *this;
245	}	297	}
246		298
		299	template<typename T>
		300	static bool
		301	find_backref (void *ptr, T *obj)
		302	{
		303	char *s = (char *)obj;
		304	while (s < (char *)obj + sizeof (T))
		305	{
		306	if (ptr == *(void **)s)
		307	return true;
		308
		309	s += sizeof (void *); // assume natural alignment
		310	}
		311
		312	return false;
		313	}
		314
		315	// for debugging, find "live" objects containing this ptr
		316	void
		317	find_backref (void *ptr)
		318	{
		319	for_all_objects (op)
		320	if (find_backref (ptr, op))
		321	fprintf (stderr, "O %p %d:'%s'\n", op, op->count, &op->name);
		322
		323	for_all_players (pl)
		324	if (find_backref (ptr, pl))
		325	fprintf (stderr, "P %p\n", pl);
		326
		327	for_all_clients (ns)
		328	if (find_backref (ptr, ns))
		329	fprintf (stderr, "C %p\n", ns);
		330	}
		331
247	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	332	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
248		333
249	static SV *	334	static SV *
250	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())	335	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())
251	{	336	{
252	SV *sv;	337	SV *sv;
253		338
254	if (!ptr)	339	if (!ptr)
255	return &PL_sv_undef;	340	return newSV (0);
256		341
257	sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);	342	sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);
258	return sv_bless (newRV_noinc ((SV *)hv), stash);	343	return sv_bless (newRV_noinc ((SV *)hv), stash);
259	}	344	}
260		345
…		…
279		364
280	static SV *	365	static SV *
281	newSVattachable (attachable *obj, HV *stash)	366	newSVattachable (attachable *obj, HV *stash)
282	{	367	{
283	if (!obj)	368	if (!obj)
284	return &PL_sv_undef;	369	return newSV (0);
285		370
286	if (!obj->self)	371	if (!obj->self)
		372	obj->self = newHV ();
		373
		374	if (!SvOBJECT (obj->self))
287	{	375	{
288	obj->self = newHV ();
289	sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char *)obj, 0);	376	sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char *)obj, 0);
290		377
291	// now bless the object _once_	378	// now bless the object _once_
		379	//TODO: create a class registry with c++ type<=>perl name<=>stash and use it here and elsewhere
292	return sv_bless (newRV_inc ((SV *)obj->self), stash);	380	return sv_bless (newRV_inc ((SV *)obj->self), stash);
293	}	381	}
294	else	382	else
295	{	383	{
296	SV *sv = newRV_inc ((SV *)obj->self);	384	SV *sv = newRV_inc ((SV *)obj->self);
…		…
324	croak ("perl code used %s object, but C object is already destroyed, caught", klass);	412	croak ("perl code used %s object, but C object is already destroyed, caught", klass);
325		413
326	return (long)mg->mg_ptr;	414	return (long)mg->mg_ptr;
327	}	415	}
328		416
329	static long	417	static long noinline
330	SvPTR_ornull (SV *sv, const char *klass)	418	SvPTR_ornull (SV *sv, const char *klass)
331	{	419	{
332	if (SvOK (sv))	420	if (SvOK (sv))
333	return SvPTR (sv, klass);	421	return SvPTR (sv, klass);
334	else	422	else
335	return 0;	423	return 0;
336	}	424	}
337		425
338	inline SV *to_sv (const shstr & v) { return v ? newSVpvn ((const char *)v, v.length ()) : &PL_sv_undef; }	426	inline SV *to_sv (const shstr & v) { return newSVpvn_utf8 ((const char *)v, v.length (), 1); }
339	inline SV *to_sv (const char * v) { return newSVpv (v, 0); }	427	inline SV *to_sv (const char * v) { return v ? newSVpv (v, 0) : newSV (0); }
340	inline SV *to_sv (bool v) { return newSViv (v); }	428	inline SV *to_sv (bool v) { return newSViv (v); }
341	inline SV *to_sv ( signed char v) { return newSViv (v); }	429	inline SV *to_sv ( signed char v) { return newSViv (v); }
342	inline SV *to_sv (unsigned char v) { return newSViv (v); }	430	inline SV *to_sv (unsigned char v) { return newSViv (v); }
343	inline SV *to_sv ( signed short v) { return newSViv (v); }	431	inline SV *to_sv ( signed short v) { return newSViv (v); }
344	inline SV *to_sv (unsigned short v) { return newSVuv (v); }	432	inline SV *to_sv (unsigned short v) { return newSVuv (v); }
…		…
353	inline SV *to_sv (client * v) { return newSVattachable (v, stash_cf_client_wrap); }	441	inline SV *to_sv (client * v) { return newSVattachable (v, stash_cf_client_wrap); }
354	inline SV *to_sv (player * v) { return newSVattachable (v, stash_cf_player_wrap); }	442	inline SV *to_sv (player * v) { return newSVattachable (v, stash_cf_player_wrap); }
355	inline SV *to_sv (object * v) { return newSVattachable (v, v && v->type == PLAYER ? stash_cf_object_player_wrap : stash_cf_object_wrap); }	443	inline SV *to_sv (object * v) { return newSVattachable (v, v && v->type == PLAYER ? stash_cf_object_player_wrap : stash_cf_object_wrap); }
356	inline SV *to_sv (maptile * v) { return newSVattachable (v, stash_cf_map_wrap); }	444	inline SV *to_sv (maptile * v) { return newSVattachable (v, stash_cf_map_wrap); }
357	inline SV *to_sv (archetype * v) { return newSVattachable (v, stash_cf_arch_wrap); }	445	inline SV *to_sv (archetype * v) { return newSVattachable (v, stash_cf_arch_wrap); }
		446	inline SV *to_sv (region * v) { return newSVattachable (v, stash_cf_region_wrap); }
358	inline SV *to_sv (partylist * v) { return newSVptr (v, stash_cf_party_wrap); }	447	inline SV *to_sv (partylist * v) { return newSVptr (v, stash_cf_party_wrap); }
359	inline SV *to_sv (region * v) { return newSVptr (v, stash_cf_region_wrap); }
360	inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }	448	inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }
		449	inline SV *to_sv (mapspace * v) { return newSVptr (v, stash_cf_mapspace_wrap); }
361		450
362	inline SV *to_sv (object & v) { return to_sv (&v); }	451	inline SV *to_sv (object & v) { return to_sv (&v); }
363	inline SV *to_sv (living & v) { return to_sv (&v); }	452	inline SV *to_sv (living & v) { return to_sv (&v); }
364		453
365	inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); }	454	inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); }
366	inline SV *to_sv (const treasurelist *v) { return to_sv (v->name); }	455	inline SV *to_sv (const treasurelist *v) { return to_sv (v->name); }
367		456
		457	inline SV *to_sv (UUID v) { return newSVpv (v.c_str (), 0); }
		458
368	inline SV *to_sv (UUID v)	459	inline SV *to_sv (dynbuf * v)
369	{	460	{
370	char buf[128];	461	SV *sv = newSV (0);
371	snprintf (buf, 128, "<1.%" PRIx64 ">", v.seq);
372	return newSVpv (buf, 0);
373	}
374		462
		463	sv_upgrade (sv, SVt_PV);
		464	SvGROW (sv, v->size () + 1);
		465	SvPOK_only (sv);
		466	v->linearise (SvPVX (sv));
		467	SvCUR_set (sv, v->size ());
		468	*SvEND (sv) = 0;
		469
		470	return sv;
		471	}
		472
		473	inline SV *to_sv (dynbuf_text * v)
		474	{
		475	SV *sv = to_sv (static_cast<dynbuf *> (v));
		476	SvUTF8_on (sv);
		477	return sv;
		478	}
		479
375	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPV_nolen (sv) : 0; }	480	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPVutf8_nolen (sv) : 0; }
376	inline void sv_to (SV *sv, char * &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }	481	inline void sv_to (SV *sv, char * &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }
377	inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }	482	inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }
378	inline void sv_to (SV *sv, signed char &v) { v = SvIV (sv); }	483	inline void sv_to (SV *sv, signed char &v) { v = SvIV (sv); }
379	inline void sv_to (SV *sv, unsigned char &v) { v = SvIV (sv); }	484	inline void sv_to (SV *sv, unsigned char &v) { v = SvIV (sv); }
380	inline void sv_to (SV *sv, signed short &v) { v = SvIV (sv); }	485	inline void sv_to (SV *sv, signed short &v) { v = SvIV (sv); }
381	inline void sv_to (SV *sv, unsigned short &v) { v = SvIV (sv); }	486	inline void sv_to (SV *sv, unsigned short &v) { v = SvIV (sv); }
382	inline void sv_to (SV *sv, signed int &v) { v = SvIV (sv); }	487	inline void sv_to (SV *sv, signed int &v) { v = SvIV (sv); }
383	inline void sv_to (SV *sv, unsigned int &v) { v = SvUV (sv); }	488	inline void sv_to (SV *sv, unsigned int &v) { v = SvUV (sv); }
384	inline void sv_to (SV *sv, signed long &v) { v = SvIV (sv); }	489	inline void sv_to (SV *sv, signed long &v) { v = SvIV (sv); }
385	inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }	490	inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }
386	inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }	491	inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }
387	inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }	492	inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }
388	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }	493	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
389	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }	494	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }
390	inline void sv_to (SV *sv, client * &v) { v = (client *)(attachable *)SvPTR_ornull (sv, "cf::client"); }	495	inline void sv_to (SV *sv, client * &v) { v = (client *)(attachable *)SvPTR_ornull (sv, "cf::client"); }
391	inline void sv_to (SV *sv, player * &v) { v = (player *)(attachable *)SvPTR_ornull (sv, "cf::player"); }	496	inline void sv_to (SV *sv, player * &v) { v = (player *)(attachable *)SvPTR_ornull (sv, "cf::player"); }
392	inline void sv_to (SV *sv, object * &v) { v = (object *)(attachable *)SvPTR_ornull (sv, "cf::object"); }	497	inline void sv_to (SV *sv, object * &v) { v = (object *)(attachable *)SvPTR_ornull (sv, "cf::object"); }
393	inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)(attachable *)SvPTR_ornull (sv, "cf::arch"); }	498	inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)(attachable *)SvPTR_ornull (sv, "cf::arch"); }
394	inline void sv_to (SV *sv, maptile * &v) { v = (maptile *)(attachable *)SvPTR_ornull (sv, "cf::map"); }	499	inline void sv_to (SV *sv, maptile * &v) { v = (maptile *)(attachable *)SvPTR_ornull (sv, "cf::map"); }
		500	inline void sv_to (SV *sv, region * &v) { v = (region *)(attachable *)SvPTR_ornull (sv, "cf::region"); }
395	inline void sv_to (SV *sv, attachable * &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); }	501	inline void sv_to (SV *sv, attachable * &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); }
396	inline void sv_to (SV *sv, partylist * &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }	502	inline void sv_to (SV *sv, partylist * &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }
397	inline void sv_to (SV *sv, region * &v) { v = (region *)SvPTR_ornull (sv, "cf::region"); }
398	inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }	503	inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }
		504	inline void sv_to (SV *sv, mapspace * &v) { v = (mapspace *)SvPTR_ornull (sv, "cf::mapspace"); }
		505	inline void sv_to (SV *sv, object_freezer * &v) { v = (object_freezer *)SvPTR_ornull (sv, "cf::object::freezer"); }
		506	inline void sv_to (SV *sv, object_thawer * &v) { v = (object_thawer *)SvPTR_ornull (sv, "cf::object::thawer" ); }
399		507
400	//inline void sv_to (SV *sv, faceinfo * &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }	508	//inline void sv_to (SV *sv, faceinfo * &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }
401	inline void sv_to (SV *sv, treasurelist * &v) { v = treasurelist::find (SvPV_nolen (sv)); }	509	inline void sv_to (SV *sv, treasurelist * &v) { v = treasurelist::find (SvPV_nolen (sv)); }
402		510
403	template<class T>	511	template<class T>
404	inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }	512	inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }
405		513
406	template<int N>	514	template<int N>
407	inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); }	515	inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); }
408		516
409	inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); }	517	inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); }
410	inline void sv_to (SV *sv, petmode_t &v) { v = (petmode_t) SvIV (sv); }	518	inline void sv_to (SV *sv, petmode_t &v) { v = (petmode_t) SvIV (sv); }
411	inline void sv_to (SV *sv, usekeytype &v) { v = (usekeytype) SvIV (sv); }	519	inline void sv_to (SV *sv, usekeytype &v) { v = (usekeytype) SvIV (sv); }
412	inline void sv_to (SV *sv, unapplymode &v) { v = (unapplymode) SvIV (sv); }	520	inline void sv_to (SV *sv, unapplymode &v) { v = (unapplymode) SvIV (sv); }
413		521
414	inline void sv_to (SV *sv, std::string &v)	522	inline void sv_to (SV *sv, std::string &v)
415	{	523	{
416	STRLEN len;	524	STRLEN len;
417	char *data = SvPVbyte (sv, len);	525	char *data = SvPVbyte (sv, len);
418	v.assign (data, len);	526	v.assign (data, len);
419	}	527	}
420		528
421	inline void sv_to (SV *sv, UUID &v)	529	inline void sv_to (SV *sv, UUID &v)
422	{	530	{
423	unsigned int version;	531	if (!v.parse (SvPV_nolen (sv)))
424
425	if (2 != sscanf (SvPV_nolen (sv), "<%d.%" SCNx64 ">", &version, &v.seq) || 1 != version)
426	croak ("unparsable uuid: %s", SvPV_nolen (sv));	532	croak ("unparsable uuid: %s", SvPV_nolen (sv));
427	}	533	}
428		534
429	inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }	535	inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }
430		536
…		…
448	break;	554	break;
449		555
450	case DT_STRING:	556	case DT_STRING:
451	{	557	{
452	char *str = (char *)va_arg (ap, const char *);	558	char *str = (char *)va_arg (ap, const char *);
453	sv = str ? newSVpv (str, 0) : &PL_sv_undef;	559	sv = str ? newSVpv (str, 0) : newSV (0);
454	}	560	}
455	break;	561	break;
456		562
457	case DT_DATA:	563	case DT_DATA:
458	{	564	{
459	char *str = (char *)va_arg (ap, const void *);	565	char *str = (char *)va_arg (ap, const void *);
460	int len = va_arg (ap, int);	566	int len = va_arg (ap, int);
461	sv = str ? newSVpv (str, len) : &PL_sv_undef;	567	sv = str ? newSVpv (str, len) : newSV (0);
462	}	568	}
463	break;	569	break;
464		570
465	case DT_OBJECT:	571	case DT_OBJECT:
466	sv = to_sv (va_arg (ap, object *));	572	sv = to_sv (va_arg (ap, object *));
…		…
508	va_end (ap);	614	va_end (ap);
509		615
510	return sv;	616	return sv;
511	}	617	}
512		618
513	static SV *	619	// typemap support, mostly to avoid excessive inlining
514	newSVcfapi (int type, ...)	620	template<class type>
		621	static void noinline
		622	cf_obj_to (SV *arg, type &var)
515	{	623	{
516	SV *sv;	624	sv_to (arg, var);
		625	if (!var)
		626	croak ("must not pass invalid/null cf_obj here");
		627	}
517		628
518	va_list ap;	629	template<class object>
519	va_start (ap, type);	630	static void noinline
520		631	cf_obj_ornull_to (SV *arg, object *&var)
521	switch (type)	632	{
		633	if (SvOK (arg))
522	{	634	{
523	case CFAPI_INT: sv = newSViv (*va_arg (ap, int * )); break;	635	sv_to (arg, var);
524	case CFAPI_LONG: sv = newSVval64 (*va_arg (ap, sint64 *)); break;	636	if (!var)
525	case CFAPI_DOUBLE: sv = newSVnv (*va_arg (ap, double *)); break;	637	croak ("unable to convert perl object to C++ object");
526	case CFAPI_STRING: sv = newSVdt_va (ap, DT_STRING); break;
527	case CFAPI_POBJECT: sv = newSVdt_va (ap, DT_OBJECT); break;
528	case CFAPI_PMAP: sv = newSVdt_va (ap, DT_MAP ); break;
529	case CFAPI_PPLAYER: sv = newSVdt_va (ap, DT_PLAYER); break;
530	case CFAPI_PARCH: sv = newSVdt_va (ap, DT_ARCH ); break;
531	case CFAPI_PPARTY: sv = newSVdt_va (ap, DT_PARTY ); break;
532	case CFAPI_PREGION: sv = newSVdt_va (ap, DT_REGION); break;
533
534	default:
535	assert (("unhandled type in newSVcfapi", 0));
536	}	638	}
537		639	else
538	va_end (ap);	640	var = 0;
539
540	return sv;
541	}	641	}
542		642
543	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	643	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
544		644
545	SV *	645	SV *
…		…
551	return newRV_inc ((SV *)ext->cb);	651	return newRV_inc ((SV *)ext->cb);
552	}	652	}
553		653
554	/////////////////////////////////////////////////////////////////////////////	654	/////////////////////////////////////////////////////////////////////////////
555		655
556	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
557	{
558	return 0;
559	}
560
561	static CommArray_s rtn_cmd;
562
563	static int
564	runPluginCommand (object *obj, char *params)
565	{
566	return -1;
567	}
568
569	extern "C" void *cfperl_getPluginProperty (int *type, ...)
570	{
571	va_list args;
572	char *propname;
573	int i;
574	va_start (args, type);
575	propname = va_arg (args, char *);
576	//printf ("Property name: %s\n", propname);
577
578	if (!strcmp (propname, "command?"))
579	return NULL;
580	else if (!strcmp (propname, "Identification"))
581	{
582	va_end (args);
583	return (void *)PLUGIN_NAME;
584	}
585	else if (!strcmp (propname, "FullName"))
586	{
587	va_end (args);
588	return (void *)PLUGIN_VERSION;
589	}
590	else
591	va_end (args);
592
593	return NULL;
594	}
595
596	extern "C" int cfperl_postInitPlugin ()
597	{
598	int hooktype = 1;
599	int rtype = 0;
600
601	cf_init_plugin (gethook);
602
603	return 0;
604	}
605
606	extern "C" int cfperl_closePlugin ()
607	{
608	return 0;
609	}
610
611	void	656	void
612	cfperl_init ()	657	cfperl_init ()
613	{	658	{
		659	extern char **environ;
		660
614	PERL_SYS_INIT3 (&settings.argc, &settings.argv, 0);	661	PERL_SYS_INIT3 (&settings.argc, &settings.argv, &environ);
615	perl = perl_alloc ();	662	perl = perl_alloc ();
616	perl_construct (perl);	663	perl_construct (perl);
617		664
618	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;	665	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
619		666
620	const char *argv[] = {	667	const char *argv[] = {
621	settings.argv [0],	668	settings.argv [0],
622	"-e"	669	"-e0"
623	"use Event; use Coro;" // required for bootstrap
624	"cf->bootstrap;" // required for datadir :*>
625	"unshift @INC, cf::datadir ();"
626	"require cf;"
627	};	670	};
628		671
629	if (perl_parse (perl, xs_init, 2, (char **)argv, (char **)NULL)	672	if (perl_parse (perl, xs_init, 2, (char **)argv, environ)
630	|| perl_run (perl))	673	|| perl_run (perl))
631	{	674	{
632	printf ("unable to initialize perl-interpreter, aborting.\n");	675	printf ("unable to initialize perl-interpreter, aborting.\n");
633	exit (EXIT_FAILURE);	676	exit (EXIT_FAILURE);
634	}	677	}
635		678
		679	eval_pv (
		680	"#line 1 'cfperl init'\n"
		681	"use EV ();\n"
		682	"use Coro ();\n"
		683	"cf->bootstrap;\n"
		684	"unshift @INC, cf::datadir ();\n"
		685	"require cf;\n",
		686	0
		687	);
		688
		689	if (SvTRUE (ERRSV))
636	{	690	{
637	dSP;	691	printf ("unable to bootstrap perl, aborting:\n%s", SvPV_nolen (ERRSV));
638		692	exit (EXIT_FAILURE);
639	PUSHMARK (SP);
640	PUTBACK;
641	call_pv ("cf::init", G_DISCARD | G_VOID);
642	}	693	}
643	}	694	}
644		695
		696	void
645	void cfperl_main ()	697	cfperl_main ()
646	{	698	{
647	dSP;	699	dSP;
648		700
649	PUSHMARK (SP);	701	PUSHMARK (SP);
650	PUTBACK;	702	PUTBACK;
…		…
654	void	706	void
655	attachable::instantiate ()	707	attachable::instantiate ()
656	{	708	{
657	if (attach)	709	if (attach)
658	{	710	{
659	invoke (EVENT_ATTACHABLE_INSTANTIATE, ARG_STRING (attach), DT_END);	711	INVOKE_ATTACHABLE (INSTANTIATE, this, ARG_STRING (attach));
660	attach = 0;	712	attach = 0;
661	}	713	}
662	}	714	}
663		715
664	void	716	void
665	attachable::reattach ()	717	attachable::reattach ()
666	{	718	{
667	optimise ();	719	optimise ();
668	//TODO: check for _attachment's, very important for restarts	720	//TODO: check for _attachment's, very important for restarts
669	invoke (EVENT_ATTACHABLE_REATTACH, DT_END);	721	INVOKE_ATTACHABLE (REATTACH, this);
670	}	722	}
671		723
672	static event_klass klass_of[NUM_EVENT_TYPES] = {	724	static event_klass klass_of[NUM_EVENT_TYPES] = {
673	# define def(type,name) KLASS_ ## type,	725	# define def(type,name) KLASS_ ## type,
674	# include "eventinc.h"	726	# include "eventinc.h"
675	# undef def	727	# undef def
676	};	728	};
677		729
678	#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)	730	#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)
679		731
680	static void	732	static void noinline
681	gather_callbacks (AV *&callbacks, AV *registry, event_type event)	733	gather_callbacks (AV *&callbacks, AV *registry, event_type event)
682	{	734	{
683	// event must be in array	735	// event must be in array
684	if (event >= 0 && event <= AvFILLp (registry))	736	if (event >= 0 && event <= AvFILLp (registry))
685	{	737	{
…		…
717	}	769	}
718		770
719	void	771	void
720	global::gather_callbacks (AV *&callbacks, event_type event) const	772	global::gather_callbacks (AV *&callbacks, event_type event) const
721	{	773	{
722	::gather_callbacks (callbacks, cb_object, event);	774	::gather_callbacks (callbacks, cb_global, event);
723	}	775	}
724		776
725	void	777	void
726	object::gather_callbacks (AV *&callbacks, event_type event) const	778	object::gather_callbacks (AV *&callbacks, event_type event) const
727	{	779	{
728	if (subtype && type + subtype * NUM_SUBTYPES <= AvFILLp (cb_type))	780	if (subtype && type + subtype * NUM_TYPES <= AvFILLp (cb_type))
729	{	781	{
730	SV *registry = AvARRAY (cb_type)[type + subtype * NUM_SUBTYPES];	782	SV *registry = AvARRAY (cb_type)[type + subtype * NUM_TYPES];
731		783
732	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)	784	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
733	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);	785	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);
734	}	786	}
735		787
…		…
771	{	823	{
772	attachable::gather_callbacks (callbacks, event);	824	attachable::gather_callbacks (callbacks, event);
773	::gather_callbacks (callbacks, cb_map, event);	825	::gather_callbacks (callbacks, cb_map, event);
774	}	826	}
775		827
		828	static void noinline
		829	_recalc_want (bitset<NUM_EVENT_TYPES> &set, AV *registry)
		830	{
		831	for (int event = 0; event <= AvFILLp (registry); ++event)
		832	{
		833	SV *cbs_ = AvARRAY (registry)[event];
		834
		835	// element must be list of callback entries
		836	if (cbs_ && SvROK (cbs_) && SvTYPE (SvRV (cbs_)) == SVt_PVAV)
		837	{
		838	AV *cbs = (AV *)SvRV (cbs_);
		839
		840	// no callback entries, no callbacks to call
		841	if (AvFILLp (cbs) >= 0)
		842	set.set (event);
		843	}
		844	}
		845	}
		846
		847	// very slow and inefficient way to recalculate the global want bitsets
		848	static void
		849	_recalc_want ()
		850	{
		851	ev_want_event.reset ();
		852
		853	_recalc_want (ev_want_event, cb_global);
		854	_recalc_want (ev_want_event, cb_attachable);
		855	_recalc_want (ev_want_event, cb_object);
		856	_recalc_want (ev_want_event, cb_client);
		857	_recalc_want (ev_want_event, cb_player);
		858	_recalc_want (ev_want_event, cb_map);
		859
		860	ev_want_type.reset ();
		861
		862	for (int type = 0; type <= AvFILLp (cb_type); ++type)
		863	{
		864	SV *cbs_ = AvARRAY (cb_type)[type];
		865
		866	// element must be list of callback entries
		867	if (cbs_ && SvROK (cbs_) && SvTYPE (SvRV (cbs_)) == SVt_PVAV)
		868	{
		869	AV *cbs = (AV *)SvRV (cbs_);
		870
		871	// no callback entries, no callbacks to call
		872	if (AvFILLp (cbs) >= 0)
		873	ev_want_type.set (type % NUM_TYPES);
		874	}
		875	}
		876	}
		877
776	bool	878	bool
777	attachable::invoke (event_type event, ...)	879	attachable::invoke (event_type event, ...)
778	{	880	{
779	data_type dt;	881	data_type dt;
780	va_list ap;
781
782	va_start (ap, event);
783		882
784	// callback call ordering should be:	883	// callback call ordering should be:
785	// 1. per-object callback	884	// 1. per-object callback
786	// 2. per-class object	885	// 2. per-class object
787	// 3. per-type callback	886	// 3. per-type callback
…		…
791	gather_callbacks (callbacks, event);	890	gather_callbacks (callbacks, event);
792		891
793	// short-circuit processing if no callbacks found/defined	892	// short-circuit processing if no callbacks found/defined
794	if (!callbacks)	893	if (!callbacks)
795	return 0;	894	return 0;
		895
		896	va_list ap;
		897	va_start (ap, event);
796		898
797	CALL_BEGIN (3);	899	CALL_BEGIN (3);
798	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays	900	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays
799	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));	901	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));
800		902
…		…
824	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));	926	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
825	}	927	}
826		928
827	va_end (ap);	929	va_end (ap);
828		930
829	CALL_CALL ("cf::do_invoke", G_SCALAR);	931	CALL_CALL (cv_cf_do_invoke, G_SCALAR);
830	count = count > 0 ? POPi : 0;	932	count = count > 0 ? POPi : 0;
831		933
832	CALL_END;	934	CALL_END;
833		935
834	return count;	936	return count;
835	}	937	}
836		938
837	SV *	939	SV *
838	cfperl_result (int idx)	940	cfperl_result (int idx)
839	{	941	{
840	AV *av = get_av ("cfperl::invoke_results", 0);	942	AV *av = get_av ("cf::INVOKE_RESULTS", 0);
841	if (!av)	943	if (!av)
842	return &PL_sv_undef;	944	return &PL_sv_undef;
843		945
844	SV **sv = av_fetch (av, idx, 0);	946	SV **sv = av_fetch (av, idx, 0);
845	if (!sv)	947	if (!sv)
…		…
859	{	961	{
860	return SvNV (cfperl_result (idx));	962	return SvNV (cfperl_result (idx));
861	}	963	}
862		964
863	/////////////////////////////////////////////////////////////////////////////	965	/////////////////////////////////////////////////////////////////////////////
		966	// various c++ => perl glue functions
		967
		968	void
		969	cfperl_tick ()
		970	{
		971	tick_pending = 1;
		972
		973	if (tick_inhibit)
		974	return;
		975
		976	tick_pending = 0;
		977
		978	dSP;
		979
		980	PUSHMARK (SP);
		981	PUTBACK;
		982	call_pvsv (cv_cf_tick, G_DISCARD | G_VOID);
		983
		984	SvNV_set (sv_next_tick, get_next_tick ()); SvNOK_only (sv_next_tick);
		985	}
864		986
865	void	987	void
866	cfperl_emergency_save ()	988	cfperl_emergency_save ()
867	{	989	{
868	CALL_BEGIN (0);	990	CALL_BEGIN (0);
…		…
877	CALL_ARG (make_core);	999	CALL_ARG (make_core);
878	CALL_CALL ("cf::post_cleanup", G_VOID);	1000	CALL_CALL ("cf::post_cleanup", G_VOID);
879	CALL_END;	1001	CALL_END;
880	}	1002	}
881		1003
		1004	void
		1005	cfperl_make_book (object *book, int level)
		1006	{
		1007	CALL_BEGIN (2);
		1008	CALL_ARG (book);
		1009	CALL_ARG (level);
		1010	CALL_CALL ("ext::books::make_book", G_VOID);
		1011	CALL_END;
		1012	}
		1013
		1014	void
		1015	cfperl_send_msg (client *ns, int color, const char *type, const char *msg)
		1016	{
		1017	CALL_BEGIN (4);
		1018	CALL_ARG (ns);
		1019	CALL_ARG (type);
		1020	CALL_ARG_SV (newSVpv_utf8 (msg));
		1021	CALL_ARG (color);
		1022	CALL_CALL (cv_cf_client_send_msg, G_VOID);
		1023	CALL_END;
		1024	}
		1025
		1026	int
		1027	cfperl_can_merge (object *ob1, object *ob2)
		1028	{
		1029	int can;
		1030
		1031	CALL_BEGIN (2);
		1032	CALL_ARG (ob1);
		1033	CALL_ARG (ob2);
		1034	CALL_CALL (cv_cf__can_merge, G_SCALAR);
		1035	can = count && SvTRUE (TOPs);
		1036	CALL_END;
		1037
		1038	return can;
		1039	}
		1040
		1041	void
		1042	cfperl_mapscript_activate (object *ob, int state, object *activator, object *originator)
		1043	{
		1044	CALL_BEGIN (4);
		1045	CALL_ARG (ob);
		1046	CALL_ARG (state);
		1047	CALL_ARG (activator);
		1048	CALL_ARG (originator);
		1049	CALL_CALL ("cf::mapscript::activate", G_VOID);
		1050	CALL_END;
		1051	}
		1052
		1053	player *
		1054	player::find (const char *name)
		1055	{
		1056	CALL_BEGIN (1);
		1057	CALL_ARG (name);
		1058	CALL_CALL ("cf::player::find", G_SCALAR);
		1059
		1060	player *retval = 0;
		1061	if (count) sv_to (POPs, retval);
		1062
		1063	CALL_END;
		1064
		1065	return retval;
		1066	}
		1067
		1068	maptile *
		1069	find_style (const char *dirname, const char *stylename, int difficulty)
		1070	{
		1071	CALL_BEGIN (3);
		1072	CALL_ARG (dirname);
		1073	CALL_ARG (stylename);
		1074	CALL_ARG (difficulty);
		1075	CALL_CALL ("ext::map_random::find_style", G_SCALAR);
		1076
		1077	maptile *retval = 0;
		1078	if (count) sv_to (POPs, retval);
		1079
		1080	CALL_END;
		1081
		1082	return retval;
		1083	}
		1084
882	maptile *	1085	maptile *
883	maptile::find_sync (const char *path, maptile *origin)	1086	maptile::find_sync (const char *path, maptile *origin)
884	{	1087	{
885	CALL_BEGIN (2);	1088	CALL_BEGIN (2);
886	CALL_ARG (path);	1089	CALL_ARG (path);
887	CALL_ARG (origin);	1090	CALL_ARG (origin);
888	CALL_CALL ("cf::map::find_sync", G_SCALAR);	1091	CALL_CALL ("cf::map::find_sync", G_SCALAR);
889		1092
890	maptile *retval;	1093	maptile *retval = 0;
891
892	if (count)
893	sv_to (POPs, retval);	1094	if (count) sv_to (POPs, retval);
894	else
895	retval = 0;
896		1095
897	CALL_END;	1096	CALL_END;
898		1097
899	return retval;	1098	return retval;
900	}	1099	}
901		1100
902	maptile *	1101	maptile *
903	maptile::find_async (const char *path, maptile *origin)	1102	maptile::find_async (const char *path, maptile *origin, bool load)
904	{	1103	{
905	CALL_BEGIN (2);	1104	CALL_BEGIN (3);
906	CALL_ARG (path);	1105	CALL_ARG (path);
907	CALL_ARG (origin);	1106	CALL_ARG (origin);
		1107	CALL_ARG (load);
908	CALL_CALL ("cf::map::find_async", G_SCALAR);	1108	CALL_CALL ("cf::map::find_async", G_SCALAR);
909		1109
910	maptile *retval;	1110	maptile *retval = 0;
911
912	if (count)
913	sv_to (POPs, retval);	1111	if (count) sv_to (POPs, retval);
914	else
915	retval = 0;
916		1112
917	CALL_END;	1113	CALL_END;
918		1114
919	return retval;	1115	return retval;
920	}	1116	}
…		…
923	maptile::do_load_sync ()	1119	maptile::do_load_sync ()
924	{	1120	{
925	CALL_BEGIN (1);	1121	CALL_BEGIN (1);
926	CALL_ARG (this);	1122	CALL_ARG (this);
927	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);	1123	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);
928	CALL_END;
929	}
930
931	void
932	maptile::change_all_map_light (int change)
933	{
934	CALL_BEGIN (1);
935	CALL_ARG (change);
936	CALL_CALL ("cf::map::change_all_map_light", G_VOID);
937	CALL_END;	1124	CALL_END;
938	}	1125	}
939		1126
940	void	1127	void
941	object::enter_exit (object *exit)	1128	object::enter_exit (object *exit)
…		…
946	CALL_BEGIN (2);	1133	CALL_BEGIN (2);
947	CALL_ARG (this);	1134	CALL_ARG (this);
948	CALL_ARG (exit);	1135	CALL_ARG (exit);
949	CALL_CALL ("cf::object::player::enter_exit", G_VOID);	1136	CALL_CALL ("cf::object::player::enter_exit", G_VOID);
950	CALL_END;	1137	CALL_END;
		1138	}
		1139
		1140	void
		1141	object::player_goto (const char *path, int x, int y)
		1142	{
		1143	if (type != PLAYER)
		1144	return;
		1145
		1146	CALL_BEGIN (4);
		1147	CALL_ARG (this);
		1148	CALL_ARG (path);
		1149	CALL_ARG (x);
		1150	CALL_ARG (y);
		1151	CALL_CALL ("cf::object::player::goto", G_VOID);
		1152	CALL_END;
		1153	}
		1154
		1155	const char *
		1156	object::ref () const
		1157	{
		1158	if (type == PLAYER)
		1159	return format ("player/<1.%llx>/%s", (unsigned long long)uuid.seq, &name);
		1160	else
		1161	return 0;
		1162	}
		1163
		1164	object *
		1165	object::deref (const char *ref)
		1166	{
		1167	object *retval = 0;
		1168
		1169	if (ref)
		1170	{
		1171	CALL_BEGIN (1);
		1172	CALL_ARG (ref);
		1173	CALL_CALL ("cf::object::deref", G_SCALAR);
		1174
		1175	if (count)
		1176	sv_to (POPs, retval);
		1177
		1178	CALL_END;
		1179	}
		1180
		1181	return retval;
951	}	1182	}
952		1183
953	void	1184	void
954	log_backtrace (const char *msg)	1185	log_backtrace (const char *msg)
955	{	1186	{
…		…
964	CALL_CALL ("cf::_log_backtrace", G_VOID);	1195	CALL_CALL ("cf::_log_backtrace", G_VOID);
965	CALL_END;	1196	CALL_END;
966	#endif	1197	#endif
967	}	1198	}
968		1199
		1200	bool
		1201	is_match_expr (const char *expr)
		1202	{
		1203	return !strncmp (expr, "match ", sizeof ("match ") - 1);
		1204	}
		1205
		1206	bool
		1207	match (const char *expr, object *ob, object *self, object *source, object *originator)
		1208	{
		1209	if (!strncmp (expr, "match ", sizeof ("match ") - 1))
		1210	expr += sizeof ("match ") - 1;
		1211
		1212	CALL_BEGIN (5);
		1213	CALL_ARG (expr);
		1214	CALL_ARG (ob);
		1215	CALL_ARG (self);
		1216	CALL_ARG (source);
		1217	CALL_ARG (originator);
		1218	CALL_CALL (cv_cf_match_match, G_SCALAR);
		1219
		1220	bool matched = count && SvTRUE (TOPs);
		1221
		1222	CALL_END;
		1223
		1224	return matched;
		1225	}
		1226
969	/////////////////////////////////////////////////////////////////////////////	1227	/////////////////////////////////////////////////////////////////////////////
970		1228
971	struct EventAPI *watcher_base::GEventAPI;	1229	struct EVAPI *evapi::GEVAPI;
972	struct CoroAPI *coroapi::GCoroAPI;	1230	struct CoroAPI *coroapi::GCoroAPI;
973		1231
974	int coroapi::cede_counter;	1232	void
975	double (*coroapi::time)();
976	double coroapi::next_cede;
977
978	void coroapi::do_cede_to_tick ()	1233	coroapi::do_cede_to_tick ()
979	{	1234	{
980	cede_counter = 0;	1235	cede_pending = 0;
981
982	cede ();	1236	cede ();
983
984	next_cede += (TICK / CEDES_PER_TICK) * 0.99;
985	if (next_cede > SvNV (sv_next_tick) - 0.02)
986	next_cede = SvNV (sv_next_tick);
987	}
988
989	void coroapi::do_cede_every ()
990	{
991	cede_counter = 0;
992
993	if (coroapi::nready ())
994	coroapi::cede ();
995	}
996
997	void coroapi::do_cede_to_tick_every ()
998	{
999	cede_counter = 0;
1000
1001	cede_to_tick ();
1002	}	1237	}
1003		1238
1004	void	1239	void
1005	coroapi::wait_for_tick ()	1240	coroapi::wait_for_tick ()
1006	{	1241	{
…		…
1015	CALL_BEGIN (0);	1250	CALL_BEGIN (0);
1016	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);	1251	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);
1017	CALL_END;	1252	CALL_END;
1018	}	1253	}
1019		1254
		1255	void
		1256	iow::poll (int events)
		1257	{
		1258	if (events != this->events)
		1259	{
		1260	int active = ev_is_active ((ev_io *)this);
		1261	if (active) stop ();
		1262	ev_io_set ((ev_io *)this, fd, events);
		1263	if (active) start ();
		1264	}
		1265	}
		1266
1020	static void	1267	static void
1021	iw_dispatch (pe_event *ev)
1022	{
1023	iw *w = (iw *)ev->ext_data;
1024	w->call (*w);
1025	}
1026
1027	void
1028	iw::alloc ()
1029	{
1030	pe = GEventAPI->new_idle (0, 0);
1031
1032	WaREENTRANT_off (pe);
1033	pe->base.callback = (void *)iw_dispatch;
1034	pe->base.ext_data = (void *)this;
1035	}
1036
1037	static void iow_dispatch (pe_event *ev)
1038	{
1039	iow *w = (iow *)ev->ext_data;
1040	w->call (*w, ((pe_ioevent *)ev)->got);
1041	}
1042
1043	void
1044	iow::alloc ()
1045	{
1046	pe = GEventAPI->new_io (0, 0);
1047
1048	WaREENTRANT_off (pe);
1049	pe->base.callback = (void *)iow_dispatch;
1050	pe->base.ext_data = (void *)this;
1051
1052	pe->fd = -1;
1053	pe->poll = 0;
1054	}
1055
1056	void
1057	iow::fd (int fd)
1058	{
1059	pe->fd = fd;
1060	}
1061
1062	int
1063	iow::poll ()
1064	{
1065	return pe->poll;
1066	}
1067
1068	void
1069	iow::poll (int events)
1070	{
1071	if (pe->poll != events)
1072	{
1073	if (pe->poll) stop ();
1074	pe->poll = events;
1075	if (pe->poll) start ();
1076	}
1077	}
1078
1079	void
1080	_connect_to_perl ()	1268	_connect_to_perl_1 ()
1081	{	1269	{
1082	stash_cf = gv_stashpv ("cf" , 1);	1270	stash_cf = gv_stashpv ("cf", 1);
1083		1271
1084	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);	1272	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);
1085	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);	1273	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);
1086	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);	1274	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);
1087	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);	1275	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);
		1276	stash_cf_mapspace_wrap = gv_stashpv ("cf::mapspace::wrap" , 1);
1088	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);	1277	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);
1089	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);	1278	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
1090	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);	1279	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
1091	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);	1280	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
1092	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);	1281	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
1093		1282
		1283	sv_now = get_sv ("cf::NOW" , 1); SvUPGRADE (sv_now , SVt_NV);
1094	sv_runtime = get_sv ("cf::RUNTIME" , 1); sv_upgrade (sv_runtime , SVt_NV);	1284	sv_runtime = get_sv ("cf::RUNTIME" , 1); SvUPGRADE (sv_runtime , SVt_NV);
		1285	sv_tick_start = get_sv ("cf::TICK_START", 1); SvUPGRADE (sv_tick_start, SVt_NV);
1095	sv_next_tick = get_sv ("cf::NEXT_TICK", 1); sv_upgrade (sv_next_tick, SVt_NV);	1286	sv_next_tick = get_sv ("cf::NEXT_TICK" , 1); SvUPGRADE (sv_next_tick , SVt_NV);
1096		1287
1097	cb_global = get_av ("cf::CB_GLOBAL", 1);	1288	cb_global = get_av ("cf::CB_GLOBAL", 1);
1098	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);	1289	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
1099	cb_object = get_av ("cf::CB_OBJECT", 1);	1290	cb_object = get_av ("cf::CB_OBJECT", 1);
1100	cb_player = get_av ("cf::CB_PLAYER", 1);	1291	cb_player = get_av ("cf::CB_PLAYER", 1);
1101	cb_client = get_av ("cf::CB_CLIENT", 1);	1292	cb_client = get_av ("cf::CB_CLIENT", 1);
1102	cb_type = get_av ("cf::CB_TYPE" , 1);	1293	cb_type = get_av ("cf::CB_TYPE" , 1);
1103	cb_map = get_av ("cf::CB_MAP" , 1);	1294	cb_map = get_av ("cf::CB_MAP" , 1);
1104	}	1295	}
1105		1296
		1297	static void
		1298	_connect_to_perl_2 ()
		1299	{
		1300	cv_cf_do_invoke = (SV *)get_cv ("cf::do_invoke" , 0); assert (cv_cf_do_invoke);
		1301	cv_cf__can_merge = (SV *)get_cv ("cf::_can_merge" , 0); assert (cv_cf__can_merge);
		1302	cv_cf_client_send_msg = (SV *)get_cv ("cf::client::send_msg", 0); assert (cv_cf_client_send_msg);
		1303	cv_cf_tick = (SV *)get_cv ("cf::tick" , 0); assert (cv_cf_tick);
		1304	cv_cf_match_match = (SV *)get_cv ("cf::match::match" , 0); assert (cv_cf_match_match);
		1305	}
		1306
1106	MODULE = cf PACKAGE = cf PREFIX = cf_	1307	MODULE = cf PACKAGE = cf PREFIX = cf_
1107		1308
1108	BOOT:	1309	BOOT:
1109	{	1310	{
1110	I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;	1311	I_EV_API (PACKAGE); evapi::GEVAPI = GEVAPI;
1111	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;	1312	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
1112		1313
1113	_connect_to_perl ();	1314	_connect_to_perl_1 ();
1114		1315
1115	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));	1316	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
1116		1317
1117	{	1318	//{
1118	require_pv ("Time::HiRes");	1319	// require_pv ("Time::HiRes");
1119		1320	//
1120	SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);	1321	// SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
1121	if (!svp) croak ("Time::HiRes is required");	1322	// if (!svp) croak ("Time::HiRes is required");
1122	if (!SvIOK(*svp)) croak ("Time::NVtime isn’t a function pointer");	1323	// if (!SvIOK(*svp)) croak ("Time::NVtime isn’t a function pointer");
1123	coroapi::time = INT2PTR (double(*)(), SvIV(*svp));	1324	// coroapi::time = INT2PTR (double(*)(), SvIV(*svp));
1124	}	1325	//}
1125		1326
1126	static const struct {	1327	static const struct {
1127	const char *name;	1328	const char *name;
1128	IV iv;	1329	IV iv;
1129	} *civ, const_iv[] = {	1330	} *civ, const_iv[] = {
…		…
1134	const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)	1335	const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)
1135		1336
1136	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)	1337	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)
1137		1338
1138	const_iv (MAX_TIME)	1339	const_iv (MAX_TIME)
		1340	const_iv (MAXSOCKBUF)
1139		1341
1140	const_iv (NUM_BODY_LOCATIONS)	1342	const_iv (NUM_BODY_LOCATIONS)
1141	const_iv (body_range) const_iv (body_shield) const_iv (body_combat)	1343	const_iv (body_range) const_iv (body_shield) const_iv (body_combat)
1142	const_iv (body_arm) const_iv (body_torso) const_iv (body_head)	1344	const_iv (body_arm) const_iv (body_torso) const_iv (body_head)
1143	const_iv (body_neck) const_iv (body_skill) const_iv (body_finger)	1345	const_iv (body_neck) const_iv (body_skill) const_iv (body_finger)
…		…
1161	const_iv (MOOD_FLOOR) const_iv (EXIT) const_iv (ENCOUNTER) const_iv (SHOP_FLOOR)	1363	const_iv (MOOD_FLOOR) const_iv (EXIT) const_iv (ENCOUNTER) const_iv (SHOP_FLOOR)
1162	const_iv (SHOP_MAT) const_iv (RING) const_iv (FLOOR) const_iv (FLESH)	1364	const_iv (SHOP_MAT) const_iv (RING) const_iv (FLOOR) const_iv (FLESH)
1163	const_iv (INORGANIC) const_iv (SKILL_TOOL) const_iv (LIGHTER) const_iv (BUILDABLE_WALL)	1365	const_iv (INORGANIC) const_iv (SKILL_TOOL) const_iv (LIGHTER) const_iv (BUILDABLE_WALL)
1164	const_iv (MISC_OBJECT) const_iv (LAMP) const_iv (DUPLICATOR) const_iv (SPELLBOOK)	1366	const_iv (MISC_OBJECT) const_iv (LAMP) const_iv (DUPLICATOR) const_iv (SPELLBOOK)
1165	const_iv (CLOAK) const_iv (SPINNER) const_iv (GATE) const_iv (BUTTON)	1367	const_iv (CLOAK) const_iv (SPINNER) const_iv (GATE) const_iv (BUTTON)
1166	const_iv (CF_HANDLE) const_iv (HOLE) const_iv (TRAPDOOR) const_iv (SIGN)	1368	const_iv (T_HANDLE) const_iv (HOLE) const_iv (TRAPDOOR) const_iv (SIGN)
1167	const_iv (BOOTS) const_iv (GLOVES) const_iv (SPELL) const_iv (SPELL_EFFECT)	1369	const_iv (BOOTS) const_iv (GLOVES) const_iv (SPELL) const_iv (SPELL_EFFECT)
1168	const_iv (CONVERTER) const_iv (BRACERS) const_iv (POISONING) const_iv (SAVEBED)	1370	const_iv (CONVERTER) const_iv (BRACERS) const_iv (POISONING) const_iv (SAVEBED)
1169	const_iv (WAND) const_iv (SCROLL) const_iv (DIRECTOR) const_iv (GIRDLE)	1371	const_iv (WAND) const_iv (SCROLL) const_iv (DIRECTOR) const_iv (GIRDLE)
1170	const_iv (FORCE) const_iv (POTION_EFFECT) const_iv (EVENT_CONNECTOR) const_iv (CLOSE_CON)	1372	const_iv (FORCE) const_iv (POTION_EFFECT) const_iv (EVENT_CONNECTOR) const_iv (CLOSE_CON)
1171	const_iv (CONTAINER) const_iv (ARMOUR_IMPROVER) const_iv (WEAPON_IMPROVER) const_iv (SKILLSCROLL)	1373	const_iv (CONTAINER) const_iv (ARMOUR_IMPROVER) const_iv (WEAPON_IMPROVER) const_iv (SKILLSCROLL)
1172	const_iv (DEEP_SWAMP) const_iv (IDENTIFY_ALTAR) const_iv (MENU) const_iv (RUNE)	1374	const_iv (DEEP_SWAMP) const_iv (IDENTIFY_ALTAR) const_iv (MENU) const_iv (RUNE)
1173	const_iv (TRAP) const_iv (POWER_CRYSTAL) const_iv (CORPSE) const_iv (DISEASE)	1375	const_iv (TRAP) const_iv (POWER_CRYSTAL) const_iv (CORPSE) const_iv (DISEASE)
1174	const_iv (SYMPTOM) const_iv (BUILDER) const_iv (MATERIAL) const_iv (ITEM_TRANSFORMER)	1376	const_iv (SYMPTOM) const_iv (BUILDER) const_iv (MATERIAL) const_iv (ITEM_TRANSFORMER)
		1377	const_iv (MAPSCRIPT) const_iv (SAFE_GROUND)
1175		1378
1176	const_iv (NUM_SUBTYPES)	1379	const_iv (NUM_TYPES) const_iv (NUM_SUBTYPES)
1177		1380
1178	const_iv (ST_BD_BUILD) const_iv (ST_BD_REMOVE)	1381	const_iv (ST_BD_BUILD) const_iv (ST_BD_REMOVE)
1179	const_iv (ST_MAT_FLOOR) const_iv (ST_MAT_WALL) const_iv (ST_MAT_ITEM)	1382	const_iv (ST_MAT_FLOOR) const_iv (ST_MAT_WALL) const_iv (ST_MAT_ITEM)
1180		1383
1181	const_iv (AT_PHYSICAL) const_iv (AT_MAGIC) const_iv (AT_FIRE) const_iv (AT_ELECTRICITY)	1384	const_iv (AT_PHYSICAL) const_iv (AT_MAGIC) const_iv (AT_FIRE) const_iv (AT_ELECTRICITY)
…		…
1189	const_iv (WEAP_HIT) const_iv (WEAP_SLASH) const_iv (WEAP_PIERCE) const_iv (WEAP_CLEAVE)	1392	const_iv (WEAP_HIT) const_iv (WEAP_SLASH) const_iv (WEAP_PIERCE) const_iv (WEAP_CLEAVE)
1190	const_iv (WEAP_SLICE) const_iv (WEAP_STAB) const_iv (WEAP_WHIP) const_iv (WEAP_CRUSH)	1393	const_iv (WEAP_SLICE) const_iv (WEAP_STAB) const_iv (WEAP_WHIP) const_iv (WEAP_CRUSH)
1191	const_iv (WEAP_BLUD)	1394	const_iv (WEAP_BLUD)
1192		1395
1193	const_iv (FLAG_ALIVE) const_iv (FLAG_WIZ) const_iv (FLAG_REMOVED) const_iv (FLAG_FREED)	1396	const_iv (FLAG_ALIVE) const_iv (FLAG_WIZ) const_iv (FLAG_REMOVED) const_iv (FLAG_FREED)
1194	const_iv (FLAG_WAS_WIZ) const_iv (FLAG_APPLIED) const_iv (FLAG_UNPAID) const_iv (FLAG_USE_SHIELD)	1397	const_iv (FLAG_APPLIED) const_iv (FLAG_UNPAID) const_iv (FLAG_USE_SHIELD)
1195	const_iv (FLAG_NO_PICK) const_iv (FLAG_ANIMATE) const_iv (FLAG_MONSTER) const_iv (FLAG_FRIENDLY)	1398	const_iv (FLAG_NO_PICK) const_iv (FLAG_ANIMATE) const_iv (FLAG_MONSTER) const_iv (FLAG_FRIENDLY)
1196	const_iv (FLAG_GENERATOR) const_iv (FLAG_IS_THROWN) const_iv (FLAG_AUTO_APPLY) const_iv (FLAG_PLAYER_SOLD)	1399	const_iv (FLAG_GENERATOR) const_iv (FLAG_IS_THROWN) const_iv (FLAG_AUTO_APPLY) const_iv (FLAG_PLAYER_SOLD)
1197	const_iv (FLAG_SEE_INVISIBLE) const_iv (FLAG_CAN_ROLL) const_iv (FLAG_OVERLAY_FLOOR) const_iv (FLAG_IS_TURNABLE)	1400	const_iv (FLAG_SEE_INVISIBLE) const_iv (FLAG_CAN_ROLL) const_iv (FLAG_OVERLAY_FLOOR) const_iv (FLAG_IS_TURNABLE)
1198	const_iv (FLAG_IS_USED_UP) const_iv (FLAG_IDENTIFIED) const_iv (FLAG_REFLECTING) const_iv (FLAG_CHANGING)	1401	const_iv (FLAG_IS_USED_UP) const_iv (FLAG_IDENTIFIED) const_iv (FLAG_REFLECTING) const_iv (FLAG_CHANGING)
1199	const_iv (FLAG_SPLITTING) const_iv (FLAG_HITBACK) const_iv (FLAG_STARTEQUIP) const_iv (FLAG_BLOCKSVIEW)	1402	const_iv (FLAG_SPLITTING) const_iv (FLAG_HITBACK) const_iv (FLAG_STARTEQUIP) const_iv (FLAG_BLOCKSVIEW)
…		…
1209	const_iv (FLAG_CURSED) const_iv (FLAG_DAMNED) const_iv (FLAG_SEE_ANYWHERE) const_iv (FLAG_KNOWN_MAGICAL)	1412	const_iv (FLAG_CURSED) const_iv (FLAG_DAMNED) const_iv (FLAG_SEE_ANYWHERE) const_iv (FLAG_KNOWN_MAGICAL)
1210	const_iv (FLAG_KNOWN_CURSED) const_iv (FLAG_CAN_USE_SKILL) const_iv (FLAG_BEEN_APPLIED) const_iv (FLAG_READY_SCROLL)	1413	const_iv (FLAG_KNOWN_CURSED) const_iv (FLAG_CAN_USE_SKILL) const_iv (FLAG_BEEN_APPLIED) const_iv (FLAG_READY_SCROLL)
1211	const_iv (FLAG_USE_ROD) const_iv (FLAG_USE_HORN) const_iv (FLAG_MAKE_INVIS) const_iv (FLAG_INV_LOCKED)	1414	const_iv (FLAG_USE_ROD) const_iv (FLAG_USE_HORN) const_iv (FLAG_MAKE_INVIS) const_iv (FLAG_INV_LOCKED)
1212	const_iv (FLAG_IS_WOODED) const_iv (FLAG_IS_HILLY) const_iv (FLAG_READY_SKILL) const_iv (FLAG_READY_WEAPON)	1415	const_iv (FLAG_IS_WOODED) const_iv (FLAG_IS_HILLY) const_iv (FLAG_READY_SKILL) const_iv (FLAG_READY_WEAPON)
1213	const_iv (FLAG_NO_SKILL_IDENT) const_iv (FLAG_BLIND) const_iv (FLAG_SEE_IN_DARK) const_iv (FLAG_IS_CAULDRON)	1416	const_iv (FLAG_NO_SKILL_IDENT) const_iv (FLAG_BLIND) const_iv (FLAG_SEE_IN_DARK) const_iv (FLAG_IS_CAULDRON)
1214	const_iv (FLAG_NO_STEAL) const_iv (FLAG_ONE_HIT) const_iv (FLAG_CLIENT_SENT) const_iv (FLAG_BERSERK)	1417	const_iv (FLAG_NO_STEAL) const_iv (FLAG_ONE_HIT) const_iv (FLAG_DEBUG) const_iv (FLAG_BERSERK)
1215	const_iv (FLAG_NEUTRAL) const_iv (FLAG_NO_ATTACK) const_iv (FLAG_NO_DAMAGE) const_iv (FLAG_OBJ_ORIGINAL)	1418	const_iv (FLAG_NEUTRAL) const_iv (FLAG_NO_ATTACK) const_iv (FLAG_NO_DAMAGE) const_iv (FLAG_OBJ_ORIGINAL)
1216	const_iv (FLAG_OBJ_SAVE_ON_OVL) const_iv (FLAG_ACTIVATE_ON_PUSH) const_iv (FLAG_ACTIVATE_ON_RELEASE) const_iv (FLAG_IS_WATER)	1419	const_iv (FLAG_ACTIVATE_ON_PUSH) const_iv (FLAG_ACTIVATE_ON_RELEASE) const_iv (FLAG_IS_WATER) const_iv (FLAG_WIZLOOK)
1217	const_iv (FLAG_CONTENT_ON_GEN) const_iv (FLAG_IS_A_TEMPLATE) const_iv (FLAG_IS_BUILDABLE)	1420	const_iv (FLAG_CONTENT_ON_GEN) const_iv (FLAG_IS_A_TEMPLATE) const_iv (FLAG_IS_BUILDABLE)
1218	const_iv (FLAG_DESTROY_ON_DEATH) const_iv (FLAG_NO_MAP_SAVE)	1421	const_iv (FLAG_DESTROY_ON_DEATH) const_iv (FLAG_NO_MAP_SAVE)
1219		1422
1220	const_iv (NDI_BLACK) const_iv (NDI_WHITE) const_iv (NDI_NAVY) const_iv (NDI_RED)	1423	const_iv (NDI_BLACK) const_iv (NDI_WHITE) const_iv (NDI_NAVY) const_iv (NDI_RED)
1221	const_iv (NDI_ORANGE) const_iv (NDI_BLUE) const_iv (NDI_DK_ORANGE) const_iv (NDI_GREEN)	1424	const_iv (NDI_ORANGE) const_iv (NDI_BLUE) const_iv (NDI_DK_ORANGE) const_iv (NDI_GREEN)
1222	const_iv (NDI_LT_GREEN) const_iv (NDI_GREY) const_iv (NDI_BROWN) const_iv (NDI_GOLD)	1425	const_iv (NDI_LT_GREEN) const_iv (NDI_GREY) const_iv (NDI_BROWN) const_iv (NDI_GOLD)
1223	const_iv (NDI_TAN) const_iv (NDI_MAX_COLOR) const_iv (NDI_COLOR_MASK) const_iv (NDI_UNIQUE)	1426	const_iv (NDI_TAN) const_iv (NDI_MAX_COLOR) const_iv (NDI_COLOR_MASK) const_iv (NDI_UNIQUE)
1224	const_iv (NDI_ALL)	1427	const_iv (NDI_ALL) const_iv (NDI_DEF) const_iv (NDI_REPLY) const_iv (NDI_CLIENT_MASK)
		1428	const_iv (NDI_NOCREATE) const_iv (NDI_CLEAR) const_iv (NDI_VERBATIM)
1225		1429
1226	const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE)	1430	const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE)
1227	const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF)	1431	const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF)
1228		1432
1229	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_DAMAGE)	1433	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_DAMAGE)
		1434
		1435	const_iv (SP_RAISE_DEAD)
		1436	const_iv (SP_RUNE)
		1437	const_iv (SP_MAKE_MARK)
		1438	const_iv (SP_BOLT)
		1439	const_iv (SP_BULLET)
		1440	const_iv (SP_EXPLOSION)
		1441	const_iv (SP_CONE)
		1442	const_iv (SP_BOMB)
		1443	const_iv (SP_WONDER)
		1444	const_iv (SP_SMITE)
		1445	const_iv (SP_MAGIC_MISSILE)
		1446	const_iv (SP_SUMMON_GOLEM)
		1447	const_iv (SP_DIMENSION_DOOR)
		1448	const_iv (SP_MAGIC_MAPPING)
		1449	const_iv (SP_MAGIC_WALL)
		1450	const_iv (SP_DESTRUCTION)
		1451	const_iv (SP_PERCEIVE_SELF)
		1452	const_iv (SP_WORD_OF_RECALL)
		1453	const_iv (SP_INVISIBLE)
		1454	const_iv (SP_PROBE)
		1455	const_iv (SP_HEALING)
		1456	const_iv (SP_CREATE_FOOD)
		1457	const_iv (SP_EARTH_TO_DUST)
		1458	const_iv (SP_CHANGE_ABILITY)
		1459	const_iv (SP_BLESS)
		1460	const_iv (SP_CURSE)
		1461	const_iv (SP_SUMMON_MONSTER)
		1462	const_iv (SP_CHARGING)
		1463	const_iv (SP_POLYMORPH)
		1464	const_iv (SP_ALCHEMY)
		1465	const_iv (SP_REMOVE_CURSE)
		1466	const_iv (SP_IDENTIFY)
		1467	const_iv (SP_DETECTION)
		1468	const_iv (SP_MOOD_CHANGE)
		1469	const_iv (SP_MOVING_BALL)
		1470	const_iv (SP_SWARM)
		1471	const_iv (SP_CHANGE_MANA)
		1472	const_iv (SP_DISPEL_RUNE)
		1473	const_iv (SP_CREATE_MISSILE)
		1474	const_iv (SP_CONSECRATE)
		1475	const_iv (SP_ANIMATE_WEAPON)
		1476	const_iv (SP_LIGHT)
		1477	const_iv (SP_CHANGE_MAP_LIGHT)
		1478	const_iv (SP_FAERY_FIRE)
		1479	const_iv (SP_CAUSE_DISEASE)
		1480	const_iv (SP_AURA)
		1481	const_iv (SP_TOWN_PORTAL)
		1482	const_iv (SP_PARTY_SPELL)
1230		1483
1231	const_iv (F_APPLIED) const_iv (F_LOCATION) const_iv (F_UNPAID) const_iv (F_MAGIC)	1484	const_iv (F_APPLIED) const_iv (F_LOCATION) const_iv (F_UNPAID) const_iv (F_MAGIC)
1232	const_iv (F_CURSED) const_iv (F_DAMNED) const_iv (F_OPEN) const_iv (F_NOPICK)	1485	const_iv (F_CURSED) const_iv (F_DAMNED) const_iv (F_OPEN) const_iv (F_NOPICK)
1233	const_iv (F_LOCKED)	1486	const_iv (F_LOCKED)
1234		1487
1235	const_iv (F_BUY) const_iv (F_SHOP) const_iv (F_SELL)	1488	const_iv (F_BUY) const_iv (F_SHOP) const_iv (F_SELL)
1236		1489
1237	const_iv (P_BLOCKSVIEW) const_iv (P_PLAYER) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE)	1490	const_iv (P_BLOCKSVIEW) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE)
1238	const_iv (P_NO_CLERIC) const_iv (P_OUT_OF_MAP) const_iv (P_NEW_MAP) const_iv (P_UPTODATE)	1491	const_iv (P_NO_CLERIC) const_iv (P_OUT_OF_MAP) const_iv (P_NEW_MAP) const_iv (P_UPTODATE)
1239		1492
1240	const_iv (UP_OBJ_INSERT) const_iv (UP_OBJ_REMOVE) const_iv (UP_OBJ_CHANGE) const_iv (UP_OBJ_FACE)	1493	const_iv (UP_OBJ_INSERT) const_iv (UP_OBJ_REMOVE) const_iv (UP_OBJ_CHANGE) const_iv (UP_OBJ_FACE)
1241		1494
1242	const_iv (INS_NO_MERGE) const_iv (INS_ABOVE_FLOOR_ONLY) const_iv (INS_NO_WALK_ON)	1495	const_iv (INS_NO_MERGE) const_iv (INS_ABOVE_FLOOR_ONLY) const_iv (INS_NO_WALK_ON)
1243	const_iv (INS_ON_TOP) const_iv (INS_BELOW_ORIGINATOR) const_iv (INS_MAP_LOAD)	1496	const_iv (INS_ON_TOP) const_iv (INS_BELOW_ORIGINATOR)
1244		1497
1245	const_iv (WILL_APPLY_HANDLE) const_iv (WILL_APPLY_TREASURE) const_iv (WILL_APPLY_EARTHWALL)	1498	const_iv (WILL_APPLY_HANDLE) const_iv (WILL_APPLY_TREASURE) const_iv (WILL_APPLY_EARTHWALL)
1246	const_iv (WILL_APPLY_DOOR) const_iv (WILL_APPLY_FOOD)	1499	const_iv (WILL_APPLY_DOOR) const_iv (WILL_APPLY_FOOD)
1247		1500
1248	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)	1501	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)
…		…
1282	const_iv (ATNR_PARALYZE) const_iv (ATNR_TURN_UNDEAD) const_iv (ATNR_FEAR) const_iv (ATNR_CANCELLATION)	1535	const_iv (ATNR_PARALYZE) const_iv (ATNR_TURN_UNDEAD) const_iv (ATNR_FEAR) const_iv (ATNR_CANCELLATION)
1283	const_iv (ATNR_DEPLETE) const_iv (ATNR_DEATH) const_iv (ATNR_CHAOS) const_iv (ATNR_COUNTERSPELL)	1536	const_iv (ATNR_DEPLETE) const_iv (ATNR_DEATH) const_iv (ATNR_CHAOS) const_iv (ATNR_COUNTERSPELL)
1284	const_iv (ATNR_GODPOWER) const_iv (ATNR_HOLYWORD) const_iv (ATNR_BLIND) const_iv (ATNR_INTERNAL)	1537	const_iv (ATNR_GODPOWER) const_iv (ATNR_HOLYWORD) const_iv (ATNR_BLIND) const_iv (ATNR_INTERNAL)
1285	const_iv (ATNR_LIFE_STEALING) const_iv (ATNR_DISEASE)	1538	const_iv (ATNR_LIFE_STEALING) const_iv (ATNR_DISEASE)
1286		1539
1287	const_iv (MAP_IN_MEMORY) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)	1540	const_iv (MAP_ACTIVE) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)
		1541	const_iv (MAP_INACTIVE)
1288		1542
1289	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)	1543	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)
1290	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)	1544	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)
		1545
		1546	const_iv (VERSION_CS) const_iv (VERSION_SC)
1291		1547
1292	const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)	1548	const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)
1293		1549
1294	const_iv (ST_DEAD) const_iv (ST_SETUP) const_iv (ST_PLAYING) const_iv (ST_CUSTOM)	1550	const_iv (ST_DEAD) const_iv (ST_SETUP) const_iv (ST_PLAYING) const_iv (ST_CUSTOM)
1295		1551
…		…
1305		1561
1306	const_iv (SYMMETRY_RANDOM) const_iv (SYMMETRY_NONE) const_iv (SYMMETRY_X)	1562	const_iv (SYMMETRY_RANDOM) const_iv (SYMMETRY_NONE) const_iv (SYMMETRY_X)
1307	const_iv (SYMMETRY_Y) const_iv (SYMMETRY_XY)	1563	const_iv (SYMMETRY_Y) const_iv (SYMMETRY_XY)
1308		1564
1309	const_iv (GT_ENVIRONMENT) const_iv (GT_INVISIBLE) const_iv (GT_STARTEQUIP)	1565	const_iv (GT_ENVIRONMENT) const_iv (GT_INVISIBLE) const_iv (GT_STARTEQUIP)
1310	const_iv (GT_APPLY) const_iv (GT_ONLY_GOOD) const_iv (GT_UPDATE_INV)	1566	const_iv (GT_APPLY) const_iv (GT_ONLY_GOOD) const_iv (GT_MINIMAL)
1311	const_iv (GT_MINIMAL)	1567
		1568	const_iv (FT_FACE) const_iv (FT_MUSIC) const_iv (FT_SOUND)
		1569	const_iv (FT_RSRC) const_iv (FT_NUM)
1312	};	1570	};
1313		1571
1314	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	1572	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1315	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));	1573	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1316		1574
…		…
1333	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));	1591	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));
1334	av_push (event, newSViv (eiv->klass));	1592	av_push (event, newSViv (eiv->klass));
1335	av_store (av, eiv->iv, newRV_noinc ((SV *)event));	1593	av_store (av, eiv->iv, newRV_noinc ((SV *)event));
1336	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));	1594	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));
1337	}	1595	}
1338	}
1339		1596
		1597	// used by autogenerated BOOT sections from genacc
		1598	av_reflect = get_av ("cf::REFLECT", 1);
		1599	}
		1600
		1601	void _gv_clear (SV *gv)
		1602	CODE:
		1603	assert (SvTYPE (gv) == SVt_PVGV);
		1604	# define f(sv) { SV *sv_ = (SV *)(sv); sv = 0; SvREFCNT_dec (sv_); }
		1605	f (GvGP (gv)->gp_form);
		1606	f (GvGP (gv)->gp_io);
		1607	f (GvGP (gv)->gp_sv);
		1608	f (GvGP (gv)->gp_av);
		1609	f (GvGP (gv)->gp_hv);
		1610	f (GvGP (gv)->gp_cv);
		1611	GvCVGEN (gv) = 0;
		1612	GvMULTI_off (gv);
		1613	# undef f
		1614
1340	void _connect_to_perl ()	1615	void _connect_to_perl_1 ()
1341		1616
		1617	void _connect_to_perl_2 ()
		1618
		1619	void _recalc_want ()
		1620
		1621	# not used by default anymore
1342	void _global_reattach ()	1622	void _global_reattach ()
1343	CODE:	1623	CODE:
1344	{	1624	{
1345	// reattach to all attachable objects in the game.	1625	// reattach to all attachable objects in the game.
1346	for_all_clients (ns)	1626	for_all_clients (ns)
1347	ns->reattach ();	1627	ns->reattach ();
1348		1628
1349	for_all_objects (op)	1629	for_all_objects (op)
1350	op->reattach ();	1630	op->reattach ();
1351	}	1631	}
1352
1353	void _post_tick ()
1354	CODE:
1355	coroapi::next_cede = SvNV (sv_next_tick) - TICK * (1. - 1. / CEDES_PER_TICK);
1356		1632
1357	# support function for map-world.ext	1633	# support function for map-world.ext
1358	void _quantise (SV *data_sv, SV *plt_sv)	1634	void _quantise (SV *data_sv, SV *plt_sv)
1359	CODE:	1635	CODE:
1360	{	1636	{
…		…
1394	}	1670	}
1395		1671
1396	SvCUR_set (data_sv, dst - SvPVX (data_sv));	1672	SvCUR_set (data_sv, dst - SvPVX (data_sv));
1397	}	1673	}
1398		1674
		1675	void init_anim ()
		1676
		1677	void init_globals ()
		1678
		1679	void init_experience ()
		1680
		1681	void init_attackmess ()
		1682
		1683	void init_dynamic ()
		1684
		1685	void load_settings ()
		1686
		1687	void load_materials ()
		1688
		1689	void init_uuid ()
		1690	CODE:
		1691	UUID::init ();
		1692
		1693	void init_signals ()
		1694
		1695	void init_commands ()
		1696
		1697	void init_skills ()
		1698
		1699	void init_beforeplay ()
		1700
		1701	void evthread_start (int aiofd)
		1702
		1703	void cede_to_tick ()
		1704	CODE:
		1705	coroapi::cede_to_tick ();
		1706
		1707	NV till_tick ()
		1708	CODE:
		1709	RETVAL = SvNVX (sv_next_tick) - now ();
		1710	OUTPUT:
		1711	RETVAL
		1712
		1713	int tick_inhibit ()
		1714	CODE:
		1715	RETVAL = tick_inhibit;
		1716	OUTPUT:
		1717	RETVAL
		1718
		1719	void tick_inhibit_inc ()
		1720	CODE:
		1721	++tick_inhibit;
		1722
		1723	void tick_inhibit_dec ()
		1724	CODE:
		1725	if (!--tick_inhibit)
		1726	if (tick_pending)
		1727	{
		1728	ev_async_send (EV_DEFAULT, &tick_watcher);
		1729	coroapi::cede ();
		1730	}
		1731
		1732	void server_tick ()
		1733	CODE:
		1734	{
		1735	NOW = ev_now (EV_DEFAULT);
		1736	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1737	SvNV_set (sv_tick_start, NOW); SvNOK_only (sv_tick_start);
		1738	runtime = SvNVX (sv_runtime);
		1739
		1740	server_tick ();
		1741
		1742	NOW = ev_time ();
		1743	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1744	runtime += TICK;
		1745	SvNV_set (sv_runtime, runtime); SvNOK_only (sv_runtime);
		1746	}
		1747
1399	NV floor (NV x)	1748	NV floor (NV x)
1400		1749
1401	NV ceil (NV x)	1750	NV ceil (NV x)
1402		1751
1403	NV rndm (...)	1752	NV rndm (...)
		1753	ALIAS:
		1754	rmg_rndm = 1
1404	CODE:	1755	CODE:
		1756	{
		1757	rand_gen &gen = ix ? rmg_rndm : rndm;
1405	switch (items)	1758	switch (items)
1406	{	1759	{
1407	case 0: RETVAL = rndm (); break;	1760	case 0: RETVAL = gen (); break;
1408	case 1: RETVAL = rndm (SvUV (ST (0))); break;	1761	case 1: RETVAL = gen (SvUV (ST (0))); break;
1409	case 2: RETVAL = rndm (SvIV (ST (0)), SvIV (ST (1))); break;	1762	case 2: RETVAL = gen (SvIV (ST (0)), SvIV (ST (1))); break;
1410	default: croak ("cf::rndm requires none, one or two parameters."); break;	1763	default: croak ("cf::rndm requires none, one or two parameters."); break;
1411	}	1764	}
		1765	}
1412	OUTPUT:	1766	OUTPUT:
1413	RETVAL	1767	RETVAL
1414		1768
1415	NV clamp (NV value, NV min_value, NV max_value)	1769	NV clamp (NV value, NV min_value, NV max_value)
1416	CODE:	1770	CODE:
…		…
1422	CODE:	1776	CODE:
1423	RETVAL = lerp (value, min_in, max_in, min_out, max_out);	1777	RETVAL = lerp (value, min_in, max_in, min_out, max_out);
1424	OUTPUT:	1778	OUTPUT:
1425	RETVAL	1779	RETVAL
1426		1780
1427	void cede_to_tick ()	1781	void weaken (...)
1428	CODE:	1782	PROTOTYPE: @
1429	coroapi::cede_to_tick ();	1783	CODE:
1430		1784	while (items > 0)
1431	void server_tick ()	1785	sv_rvweaken (ST (--items));
1432	CODE:
1433	runtime = SvNVx (sv_runtime);
1434	server_tick ();
1435		1786
1436	void	1787	void
1437	log_backtrace (utf8_string msg)	1788	log_backtrace (utf8_string msg)
1438		1789
1439	void	1790	void
…		…
1444	octet_string path_combine (octet_string base, octet_string path)	1795	octet_string path_combine (octet_string base, octet_string path)
1445	PROTOTYPE: $$	1796	PROTOTYPE: $$
1446		1797
1447	octet_string path_combine_and_normalize (octet_string base, octet_string path)	1798	octet_string path_combine_and_normalize (octet_string base, octet_string path)
1448	PROTOTYPE: $$	1799	PROTOTYPE: $$
1449
1450	const_octet_string
1451	get_maps_directory (octet_string path)
1452	PROTOTYPE: $
1453	ALIAS: maps_directory = 0
1454	CODE:
1455	RETVAL = create_pathname (path);
1456	OUTPUT: RETVAL
1457		1800
1458	void	1801	void
1459	sub_generation_inc ()	1802	sub_generation_inc ()
1460	CODE:	1803	CODE:
1461	PL_sub_generation++;	1804	PL_sub_generation++;
…		…
1486		1829
1487	void abort ()	1830	void abort ()
1488		1831
1489	void reset_signals ()	1832	void reset_signals ()
1490		1833
1491	void fork_abort (octet_string cause = "cf::fork_abort")	1834	void fork_abort (const_octet_string cause = "cf::fork_abort")
1492		1835
1493	void cleanup (octet_string cause, bool make_core = false)	1836	void cleanup (const_octet_string cause, bool make_core = false)
1494		1837
1495	void emergency_save ()	1838	void emergency_save ()
1496		1839
1497	void _exit (int status = EXIT_SUCCESS)	1840	void _exit (int status = EXIT_SUCCESS)
1498		1841
1499	UV sv_2watcher (SV *w)
1500	CODE:
1501	RETVAL = (UV)GEventAPI->sv_2watcher (w);
1502	OUTPUT:
1503	RETVAL
1504
1505	#if _POSIX_MEMLOCK	1842	#if _POSIX_MEMLOCK
1506		1843
1507	int mlockall (int flags = MCL_CURRENT | MCL_FUTURE)	1844	int mlockall (int flags = MCL_CURRENT | MCL_FUTURE)
		1845	INIT:
		1846	#if __GLIBC__
		1847	mallopt (M_TOP_PAD, 1024 * 1024);
		1848	mallopt (M_MMAP_THRESHOLD, 1024 * 1024 * 128);
		1849	mallopt (M_MMAP_MAX, 0); // likely bug-workaround, also frees memory
		1850	mallopt (M_PERTURB, 0xee); // bug-workaround for linux glibc+mlockall+calloc
		1851	#endif
1508		1852
1509	int munlockall ()	1853	int munlockall ()
1510		1854
1511	#endif	1855	#endif
		1856
		1857	int
		1858	malloc_trim (IV pad = 0)
		1859
		1860	void
		1861	mallinfo ()
		1862	PPCODE:
		1863	{
		1864	#if __GLIBC__
		1865	struct mallinfo mai = mallinfo ();
		1866	EXTEND (SP, 10*2);
		1867	PUSHs (sv_2mortal (newSVpv ("arena" , 0))); PUSHs (sv_2mortal (newSViv (mai.arena)));
		1868	PUSHs (sv_2mortal (newSVpv ("ordblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.ordblks)));
		1869	PUSHs (sv_2mortal (newSVpv ("smblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.smblks)));
		1870	PUSHs (sv_2mortal (newSVpv ("hblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblks)));
		1871	PUSHs (sv_2mortal (newSVpv ("hblkhd" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblkhd)));
		1872	PUSHs (sv_2mortal (newSVpv ("usmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.usmblks)));
		1873	PUSHs (sv_2mortal (newSVpv ("fsmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.fsmblks)));
		1874	PUSHs (sv_2mortal (newSVpv ("uordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.uordblks)));
		1875	PUSHs (sv_2mortal (newSVpv ("fordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.fordblks)));
		1876	PUSHs (sv_2mortal (newSVpv ("keepcost", 0))); PUSHs (sv_2mortal (newSViv (mai.keepcost)));
		1877	#endif
		1878	EXTEND (SP, 5*2);
		1879	PUSHs (sv_2mortal (newSVpv ("slice_alloc", 0))); PUSHs (sv_2mortal (newSVuv (slice_alloc)));
		1880	PUSHs (sv_2mortal (newSVpv ("shstr_alloc", 0))); PUSHs (sv_2mortal (newSVuv (shstr_alloc)));
		1881	PUSHs (sv_2mortal (newSVpv ("objects" , 0))); PUSHs (sv_2mortal (newSVuv (objects.size () * sizeof (object))));
		1882	PUSHs (sv_2mortal (newSVpv ("sv_count" , 0))); PUSHs (sv_2mortal (newSVuv (PL_sv_count)));
		1883	PUSHs (sv_2mortal (newSVpv ("sv_objcount", 0))); PUSHs (sv_2mortal (newSVuv (PL_sv_objcount)));
		1884	}
1512		1885
1513	int find_animation (utf8_string text)	1886	int find_animation (utf8_string text)
1514	PROTOTYPE: $	1887	PROTOTYPE: $
1515		1888
1516	int random_roll (int min, int max, object *op, int goodbad);	1889	int random_roll (int min, int max, object *op, int goodbad);
…		…
1554	RETVAL = newSVpv (resist_plus[atnr], 0);	1927	RETVAL = newSVpv (resist_plus[atnr], 0);
1555	else	1928	else
1556	XSRETURN_UNDEF;	1929	XSRETURN_UNDEF;
1557	OUTPUT: RETVAL	1930	OUTPUT: RETVAL
1558		1931
		1932	UUID
		1933	uuid_cur ()
		1934	CODE:
		1935	RETVAL = UUID::cur;
		1936	OUTPUT:
		1937	RETVAL
		1938
		1939	UUID
		1940	uuid_gen ()
		1941	CODE:
		1942	RETVAL = UUID::gen ();
		1943	OUTPUT:
		1944	RETVAL
		1945
		1946	val64
		1947	uuid_seq (UUID uuid)
		1948	CODE:
		1949	RETVAL = uuid.seq;
		1950	OUTPUT:
		1951	RETVAL
		1952
		1953	UUID
		1954	uuid_str (val64 seq)
		1955	CODE:
		1956	RETVAL.seq = seq;
		1957	OUTPUT:
		1958	RETVAL
		1959
		1960	void
		1961	coin_names ()
		1962	PPCODE:
		1963	EXTEND (SP, NUM_COINS);
		1964	for (int i = 0; i < NUM_COINS; ++i)
		1965	PUSHs (sv_2mortal (newSVpv (coins [i], 0)));
		1966
		1967	void
		1968	coin_archetypes ()
		1969	PPCODE:
		1970	EXTEND (SP, NUM_COINS);
		1971	for (int i = 0; i < NUM_COINS; ++i)
		1972	PUSHs (sv_2mortal (to_sv (archetype::find (coins [i]))));
		1973
1559	bool	1974	bool
1560	load_resource_file (octet_string filename)	1975	load_resource_file_ (octet_string filename)
		1976
		1977	void
		1978	fix_weight ()
1561		1979
1562	MODULE = cf PACKAGE = cf::attachable	1980	MODULE = cf PACKAGE = cf::attachable
1563		1981
1564	int	1982	int
1565	valid (SV *obj)	1983	valid (SV *obj)
…		…
1583	#object *mortals (U32 index)	2001	#object *mortals (U32 index)
1584	# CODE:	2002	# CODE:
1585	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;	2003	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;
1586	# OUTPUT: RETVAL	2004	# OUTPUT: RETVAL
1587		2005
1588	INCLUDE: $PERL $srcdir/genacc attachable ../include/cfperl.h |	2006	INCLUDE: $PERL $srcdir/genacc attachable ../include/util.h ../include/cfperl.h |
1589		2007
1590	MODULE = cf PACKAGE = cf::global	2008	MODULE = cf PACKAGE = cf::global
1591		2009
1592	int invoke (SV *klass, int event, ...)	2010	int invoke (SV *klass, int event, ...)
1593	CODE:	2011	CODE:
…		…
1629	object *actives (U32 index)	2047	object *actives (U32 index)
1630	CODE:	2048	CODE:
1631	RETVAL = index < actives.size () ? actives [index] : 0;	2049	RETVAL = index < actives.size () ? actives [index] : 0;
1632	OUTPUT: RETVAL	2050	OUTPUT: RETVAL
1633		2051
		2052	int mortals_size ()
		2053	CODE:
		2054	RETVAL = attachable::mortals.size ();
		2055	OUTPUT: RETVAL
		2056
1634	const char *slot_save_name (U32 slot)	2057	const char *slot_use_name (U32 slot)
1635	ALIAS:	2058	ALIAS:
1636	slot_use_name = 1
1637	slot_nonuse_name = 2	2059	slot_nonuse_name = 1
1638	CODE:	2060	CODE:
1639	{	2061	{
1640	if (slot >= NUM_BODY_LOCATIONS)	2062	if (slot >= NUM_BODY_LOCATIONS)
1641	croak ("body slot index out of range");	2063	croak ("body slot index out of range");
1642		2064
1643	switch (ix)	2065	switch (ix)
1644	{	2066	{
1645	case 0: RETVAL = body_locations[slot].save_name; break;
1646	case 1: RETVAL = body_locations[slot].use_name; break;	2067	case 0: RETVAL = body_locations[slot].use_name; break;
1647	case 2: RETVAL = body_locations[slot].nonuse_name; break;	2068	case 1: RETVAL = body_locations[slot].nonuse_name; break;
1648	}	2069	}
1649	}	2070	}
1650	OUTPUT:	2071	OUTPUT:
1651	RETVAL	2072	RETVAL
1652		2073
…		…
1654		2075
1655	object *head (object *op)	2076	object *head (object *op)
1656	PROTOTYPE: $	2077	PROTOTYPE: $
1657	CODE:	2078	CODE:
1658	RETVAL = op->head_ ();	2079	RETVAL = op->head_ ();
1659	OUTPUT: RETVAL
1660
1661	int is_head (object *op)
1662	PROTOTYPE: $
1663	CODE:
1664	RETVAL = op->head_ () == op;
1665	OUTPUT: RETVAL	2080	OUTPUT: RETVAL
1666		2081
1667	void	2082	void
1668	inv (object *obj)	2083	inv (object *obj)
1669	PROTOTYPE: $	2084	PROTOTYPE: $
1670	PPCODE:	2085	PPCODE:
1671	{	2086	{
1672	object *o;
1673	for (o = obj->inv; o; o = o->below)	2087	for (object *o = obj->inv; o; o = o->below)
1674	XPUSHs (sv_2mortal (to_sv (o)));	2088	XPUSHs (sv_2mortal (to_sv (o)));
1675	}	2089	}
1676		2090
1677	void	2091	void
1678	set_animation (object *op, int idx)	2092	set_animation (object *op, int idx)
…		…
1691	CODE:	2105	CODE:
1692	{	2106	{
1693	if (slot >= NUM_BODY_LOCATIONS)	2107	if (slot >= NUM_BODY_LOCATIONS)
1694	croak ("body slot index out of range");	2108	croak ("body slot index out of range");
1695		2109
1696	RETVAL = ix ? op->slot[slot].info : op->slot[slot].used;	2110	RETVAL = ix ? op->slot[slot].used : op->slot[slot].info;
1697		2111
1698	if (items > 2)	2112	if (items > 2)
1699	if (ix)	2113	if (ix)
		2114	op->slot[slot].used = value;
		2115	else
1700	op->slot[slot].info = value;	2116	op->slot[slot].info = value;
1701	else
1702	op->slot[slot].used = value;
1703	}	2117	}
1704	OUTPUT:	2118	OUTPUT:
1705	RETVAL	2119	RETVAL
1706		2120
1707	object *find_best_object_match (object *op, utf8_string match)	2121	object *find_best_object_match (object *op, utf8_string match)
…		…
1709	object *find_marked_object (object *op)	2123	object *find_marked_object (object *op)
1710		2124
1711	int need_identify (object *obj);	2125	int need_identify (object *obj);
1712		2126
1713	int apply_shop_mat (object *shop_mat, object *op);	2127	int apply_shop_mat (object *shop_mat, object *op);
1714
1715	int move_player (object *op, int dir)
1716	CODE:
1717	RETVAL = move_player (op, dir);
1718	OUTPUT:
1719	RETVAL
1720		2128
1721	int move (object *op, int dir, object *originator = op)	2129	int move (object *op, int dir, object *originator = op)
1722	CODE:	2130	CODE:
1723	RETVAL = move_ob (op, dir, originator);	2131	RETVAL = move_ob (op, dir, originator);
1724	OUTPUT:	2132	OUTPUT:
…		…
1732	CODE:	2140	CODE:
1733	player_apply_below (op);	2141	player_apply_below (op);
1734		2142
1735	int cast_heal (object *op, object *caster, object *spell, int dir = 0)	2143	int cast_heal (object *op, object *caster, object *spell, int dir = 0)
1736		2144
1737	object *cf_object_present_archname_inside (object *op, utf8_string whatstr)
1738
1739	int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)
1740
1741	int cf_object_change_map (object *op, int x, int y, maptile *map)
1742
1743	#//TODO
1744	object *clone_ (object *op, int recursive = 0)
1745	CODE:
1746	if (recursive)
1747	RETVAL = object_create_clone (op);
1748	else
1749	{
1750	RETVAL = object::create ();
1751	op->copy_to (RETVAL);
1752	}
1753	OUTPUT: RETVAL
1754
1755	int pay_item (object *op, object *buyer)	2145	int pay_item (object *op, object *buyer)
1756	CODE:	2146	CODE:
1757	RETVAL = pay_for_item (op, buyer);	2147	RETVAL = pay_for_item (op, buyer);
1758	OUTPUT: RETVAL	2148	OUTPUT: RETVAL
1759		2149
…		…
1793		2183
1794	void drop (object *who, object *op)	2184	void drop (object *who, object *op)
1795		2185
1796	void pick_up (object *who, object *op)	2186	void pick_up (object *who, object *op)
1797		2187
1798	int cf_object_teleport (object *op, maptile *map, int x, int y)
1799
1800	void update_object (object *op, int action)	2188	void update_object (object *op, int action)
1801		2189
1802	object *cf_create_object_by_name (utf8_string name)
1803
1804	void change_exp (object *op, uint64 exp, utf8_string skill_name = 0, int flag = 0)	2190	void change_exp (object *op, uint64 exp, utf8_string skill_name = 0, int flag = 0)
1805		2191
1806	void player_lvl_adj (object *who, object *skill = 0)	2192	void player_lvl_adj (object *who, object *skill = 0)
1807		2193
1808	int kill_object (object *op, int dam = 0, object *hitter = 0, int type = AT_PHYSICAL)	2194	int kill_object (object *op, int dam = 0, object *hitter = 0, int type = AT_PHYSICAL)
1809		2195
1810	int calc_skill_exp (object *who, object *op, object *skill);	2196	int calc_skill_exp (object *who, object *op, object *skill);
1811		2197
1812	void push_button (object *op);	2198	void push_button (object *op, object *originator);
1813		2199
1814	void use_trigger (object *op);	2200	void use_trigger (object *op, object *originator);
1815		2201
1816	void add_button_link (object *button, maptile *map, int connected);	2202	void handle_apply_yield (object *op);
1817		2203
1818	void remove_button_link (object *op);	2204	int convert_item (object *item, object *converter);
1819		2205
1820		2206
1821	MODULE = cf PACKAGE = cf::object PREFIX = cf_	2207	MODULE = cf PACKAGE = cf::object PREFIX = cf_
1822
1823	object *cf_insert_ob_in_ob (object *ob, object *where)
1824		2208
1825	# no clean way to get an object from an archetype - stupid idiotic	2209	# no clean way to get an object from an archetype - stupid idiotic
1826	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.	2210	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.
1827		2211
1828	object *new (utf8_string archetype = 0)	2212	object *new (utf8_string archetype = 0)
1829	PROTOTYPE: ;$	2213	PROTOTYPE: ;$
1830	CODE:	2214	CODE:
1831	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();	2215	RETVAL = archetype ? get_archetype (archetype) : object::create ();
1832	OUTPUT:	2216	OUTPUT:
1833	RETVAL	2217	RETVAL
1834		2218
		2219	object *find_object (U32 tag)
		2220
		2221	# TODO: nuke
1835	object *insert_ob_in_map_at (object *ob, maptile *where, object_ornull *orig, int flag, int x, int y)	2222	object *insert_ob_in_map_at (object *ob, maptile *where, object_ornull *orig, int flag, int x, int y)
1836	PROTOTYPE: $$$$$$	2223	PROTOTYPE: $$$$$$
1837	CODE:	2224	CODE:
1838	{	2225	{
1839	int unused_type;	2226	RETVAL = insert_ob_in_map_at (ob, where, orig, flag, x, y);
1840	RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);
1841	}	2227	}
1842		2228
1843	player *contr (object *op)	2229	shstr
1844	CODE:	2230	object::kv_get (shstr key)
1845	RETVAL = op->contr;
1846	OUTPUT: RETVAL
1847		2231
1848	const_utf8_string get_ob_key_value (object *op, utf8_string key)	2232	void
		2233	object::kv_del (shstr key)
1849		2234
1850	bool set_ob_key_value (object *op, utf8_string key, utf8_string value = 0, int add_key = 1)	2235	void
		2236	object::kv_set (shstr key, shstr value)
1851		2237
1852	object *get_nearest_player (object *ob)	2238	object *get_nearest_player (object *ob)
1853	ALIAS: nearest_player = 0	2239	ALIAS: nearest_player = 0
1854	PREINIT:	2240	PREINIT:
1855	extern object *get_nearest_player (object *);	2241	extern object *get_nearest_player (object *);
…		…
1857	void rangevector (object *ob, object *other, int flags = 0)	2243	void rangevector (object *ob, object *other, int flags = 0)
1858	PROTOTYPE: $$;$	2244	PROTOTYPE: $$;$
1859	PPCODE:	2245	PPCODE:
1860	{	2246	{
1861	rv_vector rv;	2247	rv_vector rv;
		2248
		2249	PUTBACK;
1862	get_rangevector (ob, other, &rv, flags);	2250	get_rangevector (ob, other, &rv, flags);
		2251	SPAGAIN;
		2252
1863	EXTEND (SP, 5);	2253	EXTEND (SP, 5);
1864	PUSHs (newSVuv (rv.distance));	2254	PUSHs (newSVuv (rv.distance));
1865	PUSHs (newSViv (rv.distance_x));	2255	PUSHs (newSViv (rv.distance_x));
1866	PUSHs (newSViv (rv.distance_y));	2256	PUSHs (newSViv (rv.distance_y));
1867	PUSHs (newSViv (rv.direction));	2257	PUSHs (newSViv (rv.direction));
1868	PUSHs (newSVcfapi (CFAPI_POBJECT, rv.part));	2258	PUSHs (to_sv (rv.part));
1869	}	2259	}
1870		2260
1871	bool on_same_map_as (object *ob, object *other)	2261	bool on_same_map_as (object *ob, object *other)
1872	CODE:	2262	CODE:
1873	RETVAL = on_same_map (ob, other);	2263	RETVAL = on_same_map (ob, other);
…		…
1877	base_name (object *op, int plural = op->nrof > 1)	2267	base_name (object *op, int plural = op->nrof > 1)
1878	CODE:	2268	CODE:
1879	RETVAL = query_base_name (op, plural);	2269	RETVAL = query_base_name (op, plural);
1880	OUTPUT: RETVAL	2270	OUTPUT: RETVAL
1881		2271
1882	object *decrease_ob_nr (object *op, unsigned long i)	2272	# return the tail of an object, excluding itself
		2273	void
		2274	tail (object *op)
		2275	PPCODE:
		2276	while ((op = op->more))
		2277	XPUSHs (sv_2mortal (to_sv (op)));
1883		2278
1884	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_	2279	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_
1885		2280
1886	player *player (object *op)	2281	player *player (object *op)
1887	CODE:	2282	CODE:
1888	RETVAL = op->contr;	2283	RETVAL = op->contr;
1889	OUTPUT: RETVAL	2284	OUTPUT: RETVAL
1890		2285
		2286	bool move_player (object *op, int dir)
		2287
1891	void check_score (object *op)	2288	void check_score (object *op)
1892		2289
1893	void message (object *op, utf8_string txt, int flags = NDI_ORANGE | NDI_UNIQUE)	2290	void message (object *op, utf8_string txt, int flags = NDI_ORANGE | NDI_UNIQUE)
1894	CODE:	2291	CODE:
1895	new_draw_info (flags, 0, op, txt);	2292	new_draw_info (flags, 0, op, txt);
1896		2293
1897	object *cf_player_send_inventory (object *op)
1898
1899	octet_string cf_player_get_ip (object *op)
1900	ALIAS: ip = 0
1901
1902	object *cf_player_get_marked_item (object *op)
1903	ALIAS: marked_item = 0
1904
1905	void cf_player_set_marked_item (object *op, object *ob)
1906
1907	partylist *cf_player_get_party (object *op)
1908	ALIAS: party = 0
1909
1910	void cf_player_set_party (object *op, partylist *party)
1911
1912	void kill_player (object *op)	2294	void kill_player (object *op)
1913		2295
		2296	void esrv_send_item (object *pl, object *item)
		2297
1914	void esrv_update_item (object *op, int what, object *item)	2298	void esrv_update_item (object *pl, int what, object *item)
1915	C_ARGS: what, op, item	2299	C_ARGS: what, pl, item
1916		2300
1917	void clear_los (object *op)	2301	void esrv_del_item (object *pl, int tag)
		2302	C_ARGS: pl->contr, tag
1918		2303
1919	int command_summon (object *op, utf8_string params)	2304	int command_summon (object *op, utf8_string params)
1920		2305
1921	int command_arrest (object *op, utf8_string params)	2306	int command_arrest (object *op, utf8_string params)
1922		2307
…		…
1941	pl->ob->stats.hp = pl->ob->stats.maxhp;	2326	pl->ob->stats.hp = pl->ob->stats.maxhp;
1942	pl->ob->stats.sp = pl->ob->stats.maxsp;	2327	pl->ob->stats.sp = pl->ob->stats.maxsp;
1943	pl->ob->stats.grace = pl->ob->stats.maxgrace;	2328	pl->ob->stats.grace = pl->ob->stats.maxgrace;
1944	pl->orig_stats = pl->ob->stats;	2329	pl->orig_stats = pl->ob->stats;
1945		2330
1946	void cf_player_move (player *pl, int dir)	2331	# should only be temporary
		2332	void esrv_new_player (player *pl)
1947		2333
1948	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);	2334	#d# TODO: replace by blocked_los accessor, fix code using this
1949
1950	bool	2335	bool
1951	cell_visible (player *pl, int dx, int dy)	2336	cell_visible (player *pl, int dx, int dy)
1952	CODE:	2337	CODE:
1953	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2	2338	RETVAL = pl->blocked_los (dx, dy) != LOS_BLOCKED;
1954	&& !pl->blocked_los [dx + pl->ns->mapx / 2][dy + pl->ns->mapy / 2];
1955	OUTPUT:	2339	OUTPUT:
1956	RETVAL	2340	RETVAL
1957		2341
1958	void	2342	void
1959	send (player *pl, SV *packet)	2343	send (player *pl, SV *packet)
1960	CODE:	2344	CODE:
1961	{	2345	{
1962	STRLEN len;	2346	STRLEN len;
1963	char *buf = SvPVbyte (packet, len);	2347	char *buf = SvPVbyte (packet, len);
1964		2348
		2349	if (len > MAXSOCKBUF)
		2350	pl->failmsg ("[packet too long for client]");
1965	if (pl->ns)	2351	else if (pl->ns)
1966	pl->ns->send_packet (buf, len);	2352	pl->ns->send_packet (buf, len);
1967	}	2353	}
1968
1969	int
1970	listening (player *pl, int new_value = -1)
1971	CODE:
1972	RETVAL = pl->listening;
1973	if (new_value >= 0)
1974	pl->listening = new_value;
1975	OUTPUT:
1976	RETVAL
1977		2354
1978	void savebed (player *pl, SV *map_path = 0, SV *x = 0, SV *y = 0)	2355	void savebed (player *pl, SV *map_path = 0, SV *x = 0, SV *y = 0)
1979	PROTOTYPE: $;$$$	2356	PROTOTYPE: $;$$$
1980	PPCODE:	2357	PPCODE:
1981	if (GIMME_V != G_VOID)	2358	if (GIMME_V != G_VOID)
…		…
2006	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);	2383	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);
2007	OUTPUT: RETVAL	2384	OUTPUT: RETVAL
2008		2385
2009	SV *registry (maptile *map)	2386	SV *registry (maptile *map)
2010		2387
		2388	void
		2389	find_tagged_objects (maptile *map, utf8_string tag = 0)
		2390	PPCODE:
		2391	{
		2392	if (!map->spaces)
		2393	XSRETURN_EMPTY;
		2394
		2395	if (tag)
		2396	{
		2397	shstr_cmp tag_ (tag);
		2398
		2399	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2400	for (object *op = ms->bot; op; op = op->above)
		2401	if (op->tag == tag_)
		2402	XPUSHs (sv_2mortal (to_sv (op)));
		2403	}
		2404	else
		2405	{
		2406	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2407	for (object *op = ms->bot; op; op = op->above)
		2408	if (op->tag)
		2409	XPUSHs (sv_2mortal (to_sv (op)));
		2410	}
		2411	}
		2412
2011	INCLUDE: $PERL $srcdir/genacc maptile ../include/map.h |	2413	INCLUDE: $PERL $srcdir/genacc maptile ../include/map.h |
		2414
		2415	void
		2416	adjust_daylight ()
		2417	CODE:
		2418	maptile::adjust_daylight ();
		2419
		2420	int
		2421	outdoor_darkness (int darkness = 0)
		2422	CODE:
		2423	RETVAL = maptile::outdoor_darkness;
		2424	if (items)
		2425	maptile::outdoor_darkness = darkness;
		2426	OUTPUT:
		2427	RETVAL
2012		2428
2013	void	2429	void
2014	maptile::instantiate ()	2430	maptile::instantiate ()
2015		2431
2016	maptile *new ()	2432	maptile *new ()
…		…
2092	palette = SvRV (palette);	2508	palette = SvRV (palette);
2093		2509
2094	STRLEN idxlen;	2510	STRLEN idxlen;
2095	const uint8_t *idx = (const uint8_t *)SvPVbyte (data, idxlen);	2511	const uint8_t *idx = (const uint8_t *)SvPVbyte (data, idxlen);
2096		2512
2097	region **regionmap = (region **)malloc (	2513	region_ptr *regionmap = new region_ptr [av_len ((AV *)palette) + 1];
2098	(av_len ((AV *)palette) + 1) * sizeof (region *));
2099	uint8_t *regions = salloc<uint8_t> (THIS->size ());	2514	uint8_t *regions = salloc<uint8_t> (THIS->size ());
2100		2515
2101	for (int i = av_len ((AV *)palette) + 1; i--; )	2516	for (int i = av_len ((AV *)palette) + 1; i--; )
2102	regionmap [i] = region::find (	2517	regionmap [i] = region::find (SvPVutf8_nolen (*av_fetch ((AV *)palette, i, 1)));
2103	SvPVutf8_nolen (*av_fetch ((AV *)palette, i, 1)));
2104		2518
2105	for (int y = 0; y < THIS->height; ++y)	2519	for (int y = 0; y < THIS->height; ++y)
2106	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);	2520	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);
2107		2521
2108	sfree (THIS->regions, THIS->size ());	2522	sfree (THIS->regions, THIS->size ());
2109	free (THIS->regionmap);	2523	delete [] THIS->regionmap;
2110		2524
2111	THIS->regions = regions;	2525	THIS->regions = regions;
2112	THIS->regionmap = regionmap;	2526	THIS->regionmap = regionmap;
2113	}	2527	}
2114		2528
2115	void	2529	void
2116	maptile::create_region_treasure ()	2530	maptile::create_region_treasure ()
2117	CODE:	2531	CODE:
2118	{
2119	object *op = object::create ();
2120	op->type = FLOOR;
2121	op->map = THIS;
2122
2123	for (int x = 0; x < THIS->width; ++x)	2532	for (int x = 0; x < THIS->width; ++x)
2124	for (int y = 0; y < THIS->height; ++y)	2533	for (int y = 0; y < THIS->height; ++y)
2125	{	2534	{
2126	region *rgn = THIS->region (x, y);	2535	region *rgn = THIS->region (x, y);
2127		2536
2128	//fprintf (stderr, "%d,%d %f %p\n", x, y, rgn->treasure_density,rgn->treasure);//D	2537	//fprintf (stderr, "%d,%d %f %p\n", x, y, rgn->treasure_density,rgn->treasure);//D
		2538	if (object *op = THIS->at (x, y).top)
2129	if (rgn->treasure && rndm () < rgn->treasure_density)	2539	if (rgn->treasure && rndm () < rgn->treasure_density)
2130	{
2131	op->x = x;
2132	op->y = y;
2133	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);	2540	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);
2134	}
2135	}	2541	}
2136		2542
2137	op->destroy ();
2138	}
2139
2140	void play_sound_map (maptile *map, int x, int y, int sound_num)
2141
2142	int out_of_map (maptile *map, int x, int y)	2543	int out_of_map (maptile *map, int x, int y)
2143		2544
2144	void	2545	void
2145	trigger (maptile *map, long connection, bool state = true)	2546	find_link (maptile *map, shstr_tmp connection)
2146	CODE:
2147	activate_connection (map, connection, state);
2148
2149	void
2150	get_connection (maptile *map, long connection)
2151	PPCODE:	2547	PPCODE:
2152	oblinkpt *obp = get_connection_links (map, connection);	2548	if (oblinkpt *obp = map->find_link (connection))
2153	if (obp)
2154	for (objectlink *ol = obp->link; ol; ol = ol->next)	2549	for (objectlink *ol = obp->link; ol; ol = ol->next)
2155	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, (object *)ol->ob)));	2550	XPUSHs (sv_2mortal (to_sv ((object *)ol->ob)));
2156
2157	object *cf_map_insert_object_there (maptile *where, object *op, object *originator, int flags)
2158
2159	object *cf_map_insert_object (maptile *where, object* op, int x, int y)
2160
2161	object* cf_map_present_arch_by_name (maptile *map, const char* str, int nx, int ny)
2162	C_ARGS: str, map, nx, ny
2163		2551
2164	void	2552	void
2165	get_map_flags (maptile *map, int x, int y)	2553	get_map_flags (maptile *map, int x, int y)
2166	PPCODE:	2554	PPCODE:
2167	{	2555	{
2168	maptile *nmap = 0;	2556	maptile *nmap = 0;
2169	I16 nx = 0, ny = 0;	2557	I16 nx = 0, ny = 0;
		2558
		2559	PUTBACK;
2170	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);	2560	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
		2561	SPAGAIN;
2171		2562
2172	EXTEND (SP, 4);	2563	EXTEND (SP, 4);
2173	PUSHs (sv_2mortal (newSViv (flags)));	2564	PUSHs (sv_2mortal (newSViv (flags)));
2174		2565
2175	if (GIMME_V == G_ARRAY)	2566	if (GIMME_V == G_ARRAY)
2176	{	2567	{
2177	PUSHs (sv_2mortal (newSVcfapi (CFAPI_PMAP, nmap)));	2568	PUSHs (sv_2mortal (to_sv (nmap)));
2178	PUSHs (sv_2mortal (newSViv (nx)));	2569	PUSHs (sv_2mortal (newSViv (nx)));
2179	PUSHs (sv_2mortal (newSViv (ny)));	2570	PUSHs (sv_2mortal (newSViv (ny)));
2180	}	2571	}
2181	}	2572	}
2182		2573
		2574	mapspace *
		2575	ms (maptile *map, unsigned int x, unsigned int y)
		2576	PROTOTYPE: $$$
		2577	CODE:
		2578	{
		2579	maptile *nmap = 0;
		2580	I16 nx, ny;
		2581
		2582	PUTBACK;
		2583	get_map_flags (map, &nmap, x, y, &nx, &ny);
		2584	SPAGAIN;
		2585
		2586	if (!nmap)
		2587	XSRETURN_UNDEF;
		2588
		2589	RETVAL = &nmap->at (nx, ny);
		2590	}
		2591	OUTPUT:
		2592	RETVAL
		2593
2183	void	2594	void
2184	at (maptile *map, unsigned int x, unsigned int y)	2595	at (maptile *map, unsigned int x, unsigned int y)
2185	PROTOTYPE: $$$	2596	PROTOTYPE: $$$
2186	PPCODE:	2597	PPCODE:
2187	{	2598	{
2188	object *o;
2189	maptile *nmap = 0;	2599	maptile *nmap = 0;
2190	I16 nx, ny;	2600	I16 nx, ny;
2191		2601
		2602	PUTBACK;
2192	get_map_flags (map, &nmap, x, y, &nx, &ny);	2603	get_map_flags (map, &nmap, x, y, &nx, &ny);
		2604	SPAGAIN;
2193		2605
2194	if (nmap)	2606	if (nmap)
2195	for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)	2607	for (object *o = nmap->at (nx, ny).bot; o; o = o->above)
2196	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));	2608	XPUSHs (sv_2mortal (to_sv (o)));
2197	}	2609	}
2198		2610
2199	SV *	2611	SV *
2200	bot_at (maptile *obj, unsigned int x, unsigned int y)	2612	bot_at (maptile *map, unsigned int x, unsigned int y)
2201	PROTOTYPE: $$$	2613	PROTOTYPE: $$$
2202	ALIAS:	2614	ALIAS:
2203	top_at = 1	2615	top_at = 1
2204	flags_at = 2	2616	flags_at = 2
2205	light_at = 3	2617	light_at = 3
2206	move_block_at = 4	2618	move_block_at = 4
2207	move_slow_at = 5	2619	move_slow_at = 5
2208	move_on_at = 6	2620	move_on_at = 6
2209	move_off_at = 7	2621	move_off_at = 7
2210	INIT:
2211	if (x >= obj->width || y >= obj->height) XSRETURN_UNDEF;
2212	CODE:	2622	CODE:
		2623	{
		2624	sint16 nx = x;
		2625	sint16 ny = y;
		2626
		2627	if (!xy_normalise (map, nx, ny))
		2628	XSRETURN_UNDEF;
		2629
		2630	mapspace &ms = map->at (nx, ny);
		2631
		2632	ms.update ();
		2633
2213	switch (ix)	2634	switch (ix)
2214	{	2635	{
2215	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;	2636	case 0: RETVAL = to_sv (ms.bot ); break;
2216	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;	2637	case 1: RETVAL = to_sv (ms.top ); break;
2217	case 2: RETVAL = newSVuv ( GET_MAP_FLAGS (obj, x, y)); break;	2638	case 2: RETVAL = newSVuv (ms.flags_ ); break;
2218	case 3: RETVAL = newSViv ( GET_MAP_LIGHT (obj, x, y)); break;	2639	case 3: RETVAL = newSViv (ms.light ); break;
2219	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;	2640	case 4: RETVAL = newSVuv (ms.move_block); break;
2220	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;	2641	case 5: RETVAL = newSVuv (ms.move_slow ); break;
2221	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;	2642	case 6: RETVAL = newSVuv (ms.move_on ); break;
2222	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;	2643	case 7: RETVAL = newSVuv (ms.move_off ); break;
2223	}	2644	}
		2645	}
2224	OUTPUT: RETVAL	2646	OUTPUT: RETVAL
2225
2226	void fix_walls (maptile *map, int x, int y)
2227
2228	void fix_walls_around (maptile *map, int x, int y)
2229		2647
2230	# worst xs function of my life	2648	# worst xs function of my life
2231	bool	2649	bool
2232	_create_random_map (\	2650	_create_random_map (\
2233	maptile *self,\	2651	maptile *self,\
…		…
2301	rmp.decoroptions = decoroptions;	2719	rmp.decoroptions = decoroptions;
2302	rmp.orientation = orientation;	2720	rmp.orientation = orientation;
2303	rmp.origin_y = origin_y;	2721	rmp.origin_y = origin_y;
2304	rmp.origin_x = origin_x;	2722	rmp.origin_x = origin_x;
2305	rmp.random_seed = random_seed;	2723	rmp.random_seed = random_seed;
2306	rmp.total_map_hp = total_map_hp;	2724	rmp.total_map_hp = (uint64_t) total_map_hp;
2307	rmp.map_layout_style = map_layout_style;	2725	rmp.map_layout_style = map_layout_style;
2308	rmp.treasureoptions = treasureoptions;	2726	rmp.treasureoptions = treasureoptions;
2309	rmp.symmetry_used = symmetry_used;	2727	rmp.symmetry_used = symmetry_used;
2310	rmp.region = region;	2728	rmp.region = region;
2311	rmp.custom = custom;	2729	rmp.custom = custom;
…		…
2313	RETVAL = self->generate_random_map (&rmp);	2731	RETVAL = self->generate_random_map (&rmp);
2314	}	2732	}
2315	OUTPUT:	2733	OUTPUT:
2316	RETVAL	2734	RETVAL
2317		2735
		2736	MODULE = cf PACKAGE = cf::mapspace
		2737
		2738	INCLUDE: $PERL $srcdir/genacc mapspace ../include/map.h |
		2739
2318	MODULE = cf PACKAGE = cf::arch	2740	MODULE = cf PACKAGE = cf::arch
2319		2741
2320	archetype *find (utf8_string name)	2742	int archetypes_size ()
2321	CODE:	2743	CODE:
2322	RETVAL = archetype::find (name);	2744	RETVAL = archetypes.size ();
2323	OUTPUT:	2745	OUTPUT: RETVAL
2324	RETVAL
2325		2746
2326	archetype *first()	2747	archetype *archetypes (U32 index)
2327	PROTOTYPE:	2748	CODE:
2328	CODE:	2749	RETVAL = index < archetypes.size () ? archetypes [index] : 0;
2329	RETVAL = first_archetype;	2750	OUTPUT: RETVAL
		2751
		2752	object *instantiate (archetype *arch)
		2753	CODE:
		2754	RETVAL = arch_to_object (arch);
		2755	OUTPUT:
2330	OUTPUT: RETVAL	2756	RETVAL
2331		2757
2332	INCLUDE: $PERL $srcdir/genacc archetype ../include/object.h |	2758	INCLUDE: $PERL $srcdir/genacc archetype ../include/object.h |
2333		2759
2334	MODULE = cf PACKAGE = cf::party	2760	MODULE = cf PACKAGE = cf::party
2335		2761
…		…
2353	PROTOTYPE: $	2779	PROTOTYPE: $
2354	CODE:	2780	CODE:
2355	RETVAL = region::find (name);	2781	RETVAL = region::find (name);
2356	OUTPUT: RETVAL	2782	OUTPUT: RETVAL
2357		2783
2358	region *find_fuzzy (utf8_string name)
2359	PROTOTYPE: $
2360	CODE:
2361	RETVAL = region::find_fuzzy (name);
2362	OUTPUT: RETVAL
2363
2364	int specificity (region *rgn)	2784	int specificity (region *rgn)
2365	CODE:	2785	CODE:
2366	RETVAL = 0;	2786	RETVAL = 0;
2367	while (rgn = rgn->parent)	2787	while (rgn = rgn->parent)
2368	RETVAL++;	2788	RETVAL++;
…		…
2404	CODE:	2824	CODE:
2405	{	2825	{
2406	STRLEN len;	2826	STRLEN len;
2407	char *buf = SvPVbyte (packet, len);	2827	char *buf = SvPVbyte (packet, len);
2408		2828
		2829	if (len > MAXSOCKBUF)
		2830	{
		2831	// ugly
		2832	if (THIS->pl)
		2833	THIS->pl->failmsg ("[packet too long for client]");
		2834	}
		2835	else
2409	THIS->send_packet (buf, len);	2836	THIS->send_packet (buf, len);
2410	}	2837	}
		2838
		2839	faceidx
		2840	client::need_face (utf8_string name, int pri = 0)
		2841	CODE:
		2842	RETVAL = face_find (name, 0);
		2843	if (RETVAL)
		2844	{
		2845	THIS->send_face (RETVAL, pri);
		2846	THIS->flush_fx ();
		2847	}
		2848	OUTPUT:
		2849	RETVAL
		2850
		2851	int
		2852	client::fx_want (int idx, int value = -1)
		2853	CODE:
		2854	if (0 < idx && idx < FT_NUM)
		2855	{
		2856	RETVAL = THIS->fx_want [idx];
		2857	if (items > 2)
		2858	THIS->fx_want [idx] = value;
		2859	}
		2860	else
		2861	RETVAL = 0;
		2862	OUTPUT:
		2863	RETVAL
		2864
		2865	MODULE = cf PACKAGE = cf::sound PREFIX = sound_
		2866
		2867	faceidx sound_find (utf8_string name)
		2868
		2869	void sound_set (utf8_string str, faceidx face)
		2870
		2871	# dire hack
		2872	void old_sound_index (int idx, faceidx face)
		2873	CODE:
		2874	extern faceidx old_sound_index [SOUND_CAST_SPELL_0];
		2875	old_sound_index [idx] = face;
2411		2876
2412	MODULE = cf PACKAGE = cf::face PREFIX = face_	2877	MODULE = cf PACKAGE = cf::face PREFIX = face_
2413		2878
2414	#INCLUDE: $PERL $srcdir/genacc faceset ../include/face.h |	2879	#INCLUDE: $PERL $srcdir/genacc faceset ../include/face.h |
2415		2880
…		…
2431	if (!strcmp (name, BLANK_FACE_NAME)) blank_face = RETVAL;	2896	if (!strcmp (name, BLANK_FACE_NAME)) blank_face = RETVAL;
2432	if (!strcmp (name, EMPTY_FACE_NAME)) empty_face = RETVAL;	2897	if (!strcmp (name, EMPTY_FACE_NAME)) empty_face = RETVAL;
2433	}	2898	}
2434	OUTPUT: RETVAL	2899	OUTPUT: RETVAL
2435		2900
2436	void set (faceidx idx, int visibility, int magicmap)	2901	void set_type (faceidx idx, int value)
2437	CODE:	2902	ALIAS:
2438	faceinfo *f = face_info (idx);	2903	set_type = 0
2439	assert (f);	2904	set_visibility = 1
2440	f->visibility = visibility;	2905	set_magicmap = 2
2441	f->magicmap = magicmap;	2906	set_smooth = 3
2442		2907	set_smoothlevel = 4
2443	void set_smooth (faceidx idx, faceidx smooth, int smoothlevel)
2444	CODE:	2908	CODE:
2445	faceinfo *f = face_info (idx); assert (f);	2909	faceinfo *f = face_info (idx); assert (f);
2446	f->smooth = smooth;	2910	switch (ix)
2447	f->smoothlevel = smoothlevel;	2911	{
		2912	case 0: f->type = value; break;
		2913	case 1: f->visibility = value; break;
		2914	case 2: f->magicmap = value; break;
		2915	case 3: f->smooth = value; break;
		2916	case 4: f->smoothlevel = value; break;
		2917	}
2448		2918
2449	void set_data (faceidx idx, int faceset, SV *data, SV *chksum)	2919	void set_data (faceidx idx, int faceset, SV *data, SV *chksum)
2450	CODE:	2920	CODE:
2451	{	2921	{
2452	facedata *d = face_data (idx, faceset);	2922	faceinfo *f = face_info (idx); assert (f);
2453	assert (d);	2923	facedata *d = &(faceset ? f->data64 : f->data32);
2454	sv_to (data, d->data);	2924	sv_to (data, d->data);
2455	STRLEN clen;	2925	STRLEN clen;
2456	char *cdata = SvPVbyte (chksum, clen);	2926	char *cdata = SvPVbyte (chksum, clen);
2457	clen = min (CHKSUM_SIZE, clen);	2927	clen = min (CHKSUM_SIZE, clen);
2458		2928
…		…
2468	ns->force_newmap = true;	2938	ns->force_newmap = true;
2469	}	2939	}
2470	}	2940	}
2471	}	2941	}
2472		2942
		2943	int get_data_size (faceidx idx, int faceset = 0)
		2944	CODE:
		2945	facedata *d = face_data (idx, faceset);
		2946	if (!d) XSRETURN_UNDEF;
		2947	RETVAL = d->data.size ();
		2948	OUTPUT:
		2949	RETVAL
		2950
		2951	SV *get_chksum (faceidx idx, int faceset = 0)
		2952	CODE:
		2953	facedata *d = face_data (idx, faceset);
		2954	if (!d) XSRETURN_UNDEF;
		2955	RETVAL = newSVpvn ((char *)d->chksum, CHKSUM_SIZE);
		2956	OUTPUT:
		2957	RETVAL
		2958
		2959	SV *get_data (faceidx idx, int faceset = 0)
		2960	CODE:
		2961	facedata *d = face_data (idx, faceset);
		2962	if (!d) XSRETURN_UNDEF;
		2963	RETVAL = newSVpvn (d->data.data (), d->data.length ());
		2964	OUTPUT:
		2965	RETVAL
		2966
2473	void invalidate (faceidx idx)	2967	void invalidate (faceidx idx)
2474	CODE:	2968	CODE:
2475	for_all_clients (ns)	2969	for_all_clients (ns)
2476	{	2970	{
2477	ns->faces_sent [idx] = false;	2971	ns->faces_sent [idx] = false;
…		…
2520	void invalidate_all ()	3014	void invalidate_all ()
2521	CODE:	3015	CODE:
2522	for_all_clients (ns)	3016	for_all_clients (ns)
2523	ns->anims_sent.reset ();	3017	ns->anims_sent.reset ();
2524		3018
		3019	MODULE = cf PACKAGE = cf::object::freezer
		3020
		3021	INCLUDE: $PERL $srcdir/genacc object_freezer ../include/cfperl.h |
		3022
		3023	SV *
		3024	new (char *klass)
		3025	CODE:
		3026	RETVAL = newSVptr (new object_freezer, gv_stashpv ("cf::object::freezer", 1));
		3027	OUTPUT: RETVAL
		3028
		3029	void
		3030	DESTROY (SV *sv)
		3031	CODE:
		3032	object_freezer *self;
		3033	sv_to (sv, self);
		3034	delete self;
		3035
		3036	MODULE = cf PACKAGE = cf::object::thawer
		3037
		3038	INCLUDE: $PERL $srcdir/genacc object_thawer ../include/cfperl.h |
		3039
		3040	SV *
		3041	new_from_file (char *klass, octet_string path)
		3042	CODE:
		3043	object_thawer *f = new object_thawer (path);
		3044	if (!*f)
		3045	{
		3046	delete f;
		3047	XSRETURN_UNDEF;
		3048	}
		3049	RETVAL = newSVptr (f, gv_stashpv ("cf::object::thawer", 1));
		3050	OUTPUT: RETVAL
		3051
		3052	void
		3053	DESTROY (SV *sv)
		3054	CODE:
		3055	object_thawer *self;
		3056	sv_to (sv, self);
		3057	delete self;
		3058
		3059	void
		3060	extract_tags (object_thawer *self)
		3061	PPCODE:
		3062	while (self->kw != KW_EOF)
		3063	{
		3064	PUTBACK;
		3065	coroapi::cede_to_tick ();
		3066	SPAGAIN;
		3067
		3068	if (self->kw == KW_tag)
		3069	XPUSHs (sv_2mortal (newSVpv_utf8 (self->get_str ())));
		3070
		3071	self->skip ();
		3072	}
		3073

Diff Legend

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