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.197 by root, Fri Apr 27 03:38:33 2007 UTC vs.
Revision 1.314 by root, Thu Jan 1 20:49:48 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	*
		4	* Copyright (©) 2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
8	* Copyright (C) 2001-2005 by Chachkoff Yann	5	* Copyright (©) 2001-2005,2007 by Chachkoff Yann
9	* Copyright (C) 2006,2007 by Marc Lehmann <cf@schmorp.de>	6	* Copyright (©) 2006,2007 by Marc Lehmann <cf@schmorp.de>
10	*	7	*
11	* This program is free software; you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify
12	* it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
13	* the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation, either version 3 of the License, or
14	* (at your option) any later version.	11	* (at your option) any later version.
15	*	12	*
16	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
17	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19	* GNU General Public License for more details.	16	* GNU General Public License for more details.
20	*	17	*
21	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
22	* along with this program; if not, write to the Free Software	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
23	* Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA	20	*
		21	* The authors can be reached via e-mail to <support@deliantra.net>
24	*/	22	*/
25		23
26	#define PLUGIN_NAME "perl"	24	#include "autoconf.h"
27	#define PLUGIN_VERSION "cfperl 0.5"
28		25
29	#define CEDES_PER_TICK 5	26	#if HAVE_EXECINFO_H
		27	# include <execinfo.h>
		28	#endif
30		29
31	#include <plugin_common.h>
32	#include <sounds.h>
33	#include <cstdarg>	30	#include <cstdarg>
34	#include <sproto.h>	31	#include <typeinfo>
35		32
		33	#include "global.h"
36	#include "loader.h"	34	#include "loader.h"
		35	#include "../random_maps/random_map.h"
37	#include "cfperl.h"	36	#include "evthread.h"
38	#include "shstr.h"	37	#include "sproto.h"
39		38
40	#include <unistd.h>	39	#include <unistd.h>
41	#if _POSIX_MEMLOCK	40	#if _POSIX_MEMLOCK
42	# include <sys/mman.h>	41	# include <sys/mman.h>
43	#endif	42	#endif
44		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
45	#include <EXTERN.h>	52	#include <EXTERN.h>
46	#include <perl.h>	53	#include <perl.h>
47	#include <XSUB.h>	54	#include <XSUB.h>
48		55
49	#include "CoroAPI.h"	56	#include "CoroAPI.h"
50	#include "perlxsi.c"	57	#include "perlxsi.c"
51		58
52	extern sint64 *levels; // the experience table	59	extern sint64 *levels; // the experience table
53		60
54	typedef object object_ornull;	61	typedef object_thawer &object_thawer_ref;
55	typedef maptile maptile_ornull;	62	typedef object_freezer &object_freezer_ref;
56
57	typedef char *octet_string;
58	typedef char *utf8_string;
59	typedef const char *const_octet_string;
60	typedef const char *const_utf8_string;
61		63
62	typedef std::string std__string;	64	typedef std::string std__string;
63		65
64	#if IVSIZE >= 8
65	typedef IV val64;
66	# define newSVval64 newSViv
67	# define SvVAL64 SvIV
68	#else
69	typedef double val64;
70	# define newSVval64 newSVnv
71	# define SvVAL64 SvNV
72	#endif
73
74	static f_plug_api gethook = cfapi_get_hooks;
75	static f_plug_api object_set_property = cfapi_object_set_property;
76	static f_plug_api object_insert = cfapi_object_insert;
77
78	static PerlInterpreter *perl;	66	static PerlInterpreter *perl;
79		67
80	double runtime;	68	tstamp NOW, runtime;
		69
		70	static int tick_inhibit;
		71	static int tick_pending;
81		72
82	global gbl_ev;	73	global gbl_ev;
83	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;
84	static SV *sv_runtime, *sv_next_tick;	75	static SV *sv_runtime, *sv_tick_start, *sv_next_tick, *sv_now;
		76
		77	bitset<NUM_EVENT_TYPES> ev_want_event;
		78	bitset<NUM_TYPES> ev_want_type;
85		79
86	static HV	80	static HV
87	*stash_cf,	81	*stash_cf,
88	*stash_cf_object_wrap,	82	*stash_cf_object_wrap,
89	*stash_cf_object_player_wrap,	83	*stash_cf_object_player_wrap,
90	*stash_cf_player_wrap,	84	*stash_cf_player_wrap,
91	*stash_cf_map_wrap,	85	*stash_cf_map_wrap,
		86	*stash_cf_mapspace_wrap,
92	*stash_cf_client_wrap,	87	*stash_cf_client_wrap,
93	*stash_cf_arch_wrap,	88	*stash_cf_arch_wrap,
94	*stash_cf_party_wrap,	89	*stash_cf_party_wrap,
95	*stash_cf_region_wrap,	90	*stash_cf_region_wrap,
96	*stash_cf_living_wrap;	91	*stash_cf_living_wrap;
		92
		93	#ifndef newSVpv_utf8
		94	static inline SV *
		95	newSVpv_utf8 (const char *s)
		96	{
		97	if (!s)
		98	return newSV (0);
		99
		100	SV *sv = newSVpv (s, 0);
		101	SvUTF8_on (sv);
		102	return sv;
		103	}
		104	#endif
		105
		106	#ifndef newSVpvn_utf8
		107	static inline SV *
		108	newSVpvn_utf8 (const char *s, STRLEN l, int utf8)
		109	{
		110	if (!s)
		111	return newSV (0);
		112
		113	SV *sv = newSVpvn (s, l);
		114
		115	if (utf8)
		116	SvUTF8_on (sv);
		117
		118	return sv;
		119	}
		120	#endif
97		121
98	// helper cast function, returns super class * or 0	122	// helper cast function, returns super class * or 0
99	template<class super>	123	template<class super>
100	static super *	124	static super *
101	is_a (attachable *at)	125	is_a (attachable *at)
…		…
134	SvREFCNT_inc (self);	158	SvREFCNT_inc (self);
135	hv_clear (self);	159	hv_clear (self);
136	sv_unmagic ((SV *)self, PERL_MAGIC_ext);	160	sv_unmagic ((SV *)self, PERL_MAGIC_ext);
137	SvREFCNT_dec (self);	161	SvREFCNT_dec (self);
138		162
139	// self *must* be null now because thats sv_unmagic's job.	163	// self *must* be null now because that's sv_unmagic's job.
140	assert (!this->self);	164	assert (!this->self);
141	}	165	}
142	}	166	}
143		167
144	void	168	void
…		…
161	}	185	}
162		186
163	void	187	void
164	attachable::do_destroy ()	188	attachable::do_destroy ()
165	{	189	{
166	invoke (EVENT_ATTACHABLE_DESTROY, DT_END);	190	INVOKE_ATTACHABLE (DESTROY, this);
167		191
168	if (cb)	192	if (cb)
169	{	193	{
170	SvREFCNT_dec (cb);	194	SvREFCNT_dec (cb);
171	cb = 0;	195	cb = 0;
…		…
180	if (destroyed ())	204	if (destroyed ())
181	return;	205	return;
182		206
183	flags |= F_DESTROYED;	207	flags |= F_DESTROYED;
184	do_destroy ();	208	do_destroy ();
		209	sever_self ();
185	}	210	}
186		211
187	void	212	void
188	attachable::check_mortals ()	213	attachable::check_mortals ()
189	{	214	{
…		…
193	{	218	{
194	if (i >= mortals.size ())	219	if (i >= mortals.size ())
195	{	220	{
196	i = 0;	221	i = 0;
197		222
198	if (mortals.size () > 1000)	223	if (mortals.size () >= 512)
		224	{
		225	static int last_mortalcount;
		226	if (mortals.size () != last_mortalcount)
		227	{
		228	last_mortalcount = mortals.size ();
199	LOG (llevInfo, "mortal queue size (%d) exceeds 1000.\n", (int)mortals.size ());	229	LOG (llevInfo, "%d mortals.\n", (int)mortals.size ());
		230
		231	if (0)
		232	{
		233	for (int j = 0; j < mortals.size (); ++j)//D
		234	fprintf (stderr, "%d:%s %p ", j, &((object *)mortals[j])->name, mortals[j]);//D
		235	fprintf (stderr, "\n");//D
		236	}
		237	}
		238	}
200		239
201	break;	240	break;
202	}	241	}
203		242
204	attachable *obj = mortals [i];	243	attachable *obj = mortals [i];
…		…
209	LOG (llevError, "check_mortals: object '%s' still has self\n", typeid (obj).name ());	248	LOG (llevError, "check_mortals: object '%s' still has self\n", typeid (obj).name ());
210	obj->sever_self ();	249	obj->sever_self ();
211	}	250	}
212	#endif	251	#endif
213		252
214	if (obj->refcnt_cnt ())	253	if (obj->refcnt)
215	{	254	{
216	++i; // further delay freeing	255	++i; // further delay freeing
217		256
218	if (!(i & 0x3ff))	257	if (!(i & 0x3ff))
219	break;	258	break;
…		…
225	delete obj;	264	delete obj;
226	}	265	}
227	}	266	}
228	}	267	}
229		268
		269	void
		270	attachable::set_key (const char *key, const char *value, bool is_utf8)
		271	{
		272	if (!self)
		273	self = newHV ();
		274
		275	if (value)
		276	hv_store (self, key, strlen (key), is_utf8 ? newSVpv_utf8 (value) : newSVpv (value, 0), 0);
		277	else
		278	hv_delete (self, key, strlen (key), G_DISCARD);
		279	}
		280
230	attachable &	281	attachable &
231	attachable::operator =(const attachable &src)	282	attachable::operator =(const attachable &src)
232	{	283	{
233	//if (self || cb)	284	//if (self || cb)
234	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));	285	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));
235		286
236	attach = src.attach;	287	attach = src.attach;
237	return *this;	288	return *this;
238	}	289	}
239		290
		291	template<typename T>
		292	static bool
		293	find_backref (void *ptr, T *obj)
		294	{
		295	char *s = (char *)obj;
		296	while (s < (char *)obj + sizeof (T))
		297	{
		298	if (ptr == *(void **)s)
		299	return true;
		300
		301	s += sizeof (void *); // assume natural alignment
		302	}
		303
		304	return false;
		305	}
		306
		307	// for debugging, find "live" objects containing this ptr
		308	void
		309	find_backref (void *ptr)
		310	{
		311	for_all_objects (op)
		312	if (find_backref (ptr, op))
		313	fprintf (stderr, "O %p %d:'%s'\n", op, op->count, &op->name);
		314
		315	for_all_players (pl)
		316	if (find_backref (ptr, pl))
		317	fprintf (stderr, "P %p\n", pl);
		318
		319	for_all_clients (ns)
		320	if (find_backref (ptr, ns))
		321	fprintf (stderr, "C %p\n", ns);
		322
		323	}
		324
240	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	325	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
241		326
242	static SV *	327	static SV *
243	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())	328	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())
244	{	329	{
245	SV *sv;	330	SV *sv;
246		331
247	if (!ptr)	332	if (!ptr)
248	return &PL_sv_undef;	333	return newSV (0);
249		334
250	sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);	335	sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);
251	return sv_bless (newRV_noinc ((SV *)hv), stash);	336	return sv_bless (newRV_noinc ((SV *)hv), stash);
252	}	337	}
253		338
…		…
272		357
273	static SV *	358	static SV *
274	newSVattachable (attachable *obj, HV *stash)	359	newSVattachable (attachable *obj, HV *stash)
275	{	360	{
276	if (!obj)	361	if (!obj)
277	return &PL_sv_undef;	362	return newSV (0);
278		363
279	if (!obj->self)	364	if (!obj->self)
		365	obj->self = newHV ();
		366
		367	if (!SvOBJECT (obj->self))
280	{	368	{
281	obj->self = newHV ();
282	sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char *)obj, 0);	369	sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char *)obj, 0);
283		370
284	// now bless the object _once_	371	// now bless the object _once_
		372	//TODO: create a class registry with c++ type<=>perl name<=>stash and use it here and elsewhere
285	return sv_bless (newRV_inc ((SV *)obj->self), stash);	373	return sv_bless (newRV_inc ((SV *)obj->self), stash);
286	}	374	}
287	else	375	else
288	{	376	{
289	SV *sv = newRV_inc ((SV *)obj->self);	377	SV *sv = newRV_inc ((SV *)obj->self);
…		…
317	croak ("perl code used %s object, but C object is already destroyed, caught", klass);	405	croak ("perl code used %s object, but C object is already destroyed, caught", klass);
318		406
319	return (long)mg->mg_ptr;	407	return (long)mg->mg_ptr;
320	}	408	}
321		409
322	static long	410	static long noinline
323	SvPTR_ornull (SV *sv, const char *klass)	411	SvPTR_ornull (SV *sv, const char *klass)
324	{	412	{
325	if (SvOK (sv))	413	if (SvOK (sv))
326	return SvPTR (sv, klass);	414	return SvPTR (sv, klass);
327	else	415	else
328	return 0;	416	return 0;
329	}	417	}
330		418
331	inline SV *to_sv (const shstr & v) { return v ? newSVpvn ((const char *)v, v.length ()) : &PL_sv_undef; }	419	inline SV *to_sv (const shstr & v) { return newSVpvn_utf8 ((const char *)v, v.length (), 1); }
332	inline SV *to_sv (const char * v) { return newSVpv (v, 0); }	420	inline SV *to_sv (const char * v) { return v ? newSVpv (v, 0) : newSV (0); }
333	inline SV *to_sv (bool v) { return newSViv (v); }	421	inline SV *to_sv (bool v) { return newSViv (v); }
334	inline SV *to_sv ( signed char v) { return newSViv (v); }	422	inline SV *to_sv ( signed char v) { return newSViv (v); }
335	inline SV *to_sv (unsigned char v) { return newSViv (v); }	423	inline SV *to_sv (unsigned char v) { return newSViv (v); }
336	inline SV *to_sv ( signed short v) { return newSViv (v); }	424	inline SV *to_sv ( signed short v) { return newSViv (v); }
337	inline SV *to_sv (unsigned short v) { return newSVuv (v); }	425	inline SV *to_sv (unsigned short v) { return newSVuv (v); }
…		…
346	inline SV *to_sv (client * v) { return newSVattachable (v, stash_cf_client_wrap); }	434	inline SV *to_sv (client * v) { return newSVattachable (v, stash_cf_client_wrap); }
347	inline SV *to_sv (player * v) { return newSVattachable (v, stash_cf_player_wrap); }	435	inline SV *to_sv (player * v) { return newSVattachable (v, stash_cf_player_wrap); }
348	inline SV *to_sv (object * v) { return newSVattachable (v, v && v->type == PLAYER ? stash_cf_object_player_wrap : stash_cf_object_wrap); }	436	inline SV *to_sv (object * v) { return newSVattachable (v, v && v->type == PLAYER ? stash_cf_object_player_wrap : stash_cf_object_wrap); }
349	inline SV *to_sv (maptile * v) { return newSVattachable (v, stash_cf_map_wrap); }	437	inline SV *to_sv (maptile * v) { return newSVattachable (v, stash_cf_map_wrap); }
350	inline SV *to_sv (archetype * v) { return newSVattachable (v, stash_cf_arch_wrap); }	438	inline SV *to_sv (archetype * v) { return newSVattachable (v, stash_cf_arch_wrap); }
		439	inline SV *to_sv (region * v) { return newSVattachable (v, stash_cf_region_wrap); }
351	inline SV *to_sv (partylist * v) { return newSVptr (v, stash_cf_party_wrap); }	440	inline SV *to_sv (partylist * v) { return newSVptr (v, stash_cf_party_wrap); }
352	inline SV *to_sv (region * v) { return newSVptr (v, stash_cf_region_wrap); }
353	inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }	441	inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }
		442	inline SV *to_sv (mapspace * v) { return newSVptr (v, stash_cf_mapspace_wrap); }
354		443
355	inline SV *to_sv (object & v) { return to_sv (&v); }	444	inline SV *to_sv (object & v) { return to_sv (&v); }
356	inline SV *to_sv (living & v) { return to_sv (&v); }	445	inline SV *to_sv (living & v) { return to_sv (&v); }
357		446
358	inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); }	447	inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); }
359	inline SV *to_sv (const treasurelist *v) { return to_sv (v->name); }	448	inline SV *to_sv (const treasurelist *v) { return to_sv (v->name); }
360		449
		450	inline SV *to_sv (UUID v) { return newSVpv (v.c_str (), 0); }
		451
361	inline SV *to_sv (UUID v)	452	inline SV *to_sv (dynbuf * v)
362	{	453	{
363	char buf[128];	454	SV *sv = newSV (0);
364	snprintf (buf, 128, "<1.%" PRIx64 ">", v.seq);
365	return newSVpv (buf, 0);
366	}
367		455
		456	sv_upgrade (sv, SVt_PV);
		457	SvGROW (sv, v->size () + 1);
		458	SvPOK_only (sv);
		459	v->linearise (SvPVX (sv));
		460	SvCUR_set (sv, v->size ());
		461	*SvEND (sv) = 0;
		462
		463	return sv;
		464	}
		465
		466	inline SV *to_sv (dynbuf_text * v)
		467	{
		468	SV *sv = to_sv (static_cast<dynbuf *> (v));
		469	SvUTF8_on (sv);
		470	return sv;
		471	}
		472
368	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPV_nolen (sv) : 0; }	473	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPVutf8_nolen (sv) : 0; }
369	inline void sv_to (SV *sv, char * &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }	474	inline void sv_to (SV *sv, char * &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }
370	inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }	475	inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }
371	inline void sv_to (SV *sv, signed char &v) { v = SvIV (sv); }	476	inline void sv_to (SV *sv, signed char &v) { v = SvIV (sv); }
372	inline void sv_to (SV *sv, unsigned char &v) { v = SvIV (sv); }	477	inline void sv_to (SV *sv, unsigned char &v) { v = SvIV (sv); }
373	inline void sv_to (SV *sv, signed short &v) { v = SvIV (sv); }	478	inline void sv_to (SV *sv, signed short &v) { v = SvIV (sv); }
374	inline void sv_to (SV *sv, unsigned short &v) { v = SvIV (sv); }	479	inline void sv_to (SV *sv, unsigned short &v) { v = SvIV (sv); }
375	inline void sv_to (SV *sv, signed int &v) { v = SvIV (sv); }	480	inline void sv_to (SV *sv, signed int &v) { v = SvIV (sv); }
376	inline void sv_to (SV *sv, unsigned int &v) { v = SvUV (sv); }	481	inline void sv_to (SV *sv, unsigned int &v) { v = SvUV (sv); }
377	inline void sv_to (SV *sv, signed long &v) { v = SvIV (sv); }	482	inline void sv_to (SV *sv, signed long &v) { v = SvIV (sv); }
378	inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }	483	inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }
379	inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }	484	inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }
380	inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }	485	inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }
381	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }	486	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
382	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }	487	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }
383	inline void sv_to (SV *sv, client * &v) { v = (client *)(attachable *)SvPTR_ornull (sv, "cf::client"); }	488	inline void sv_to (SV *sv, client * &v) { v = (client *)(attachable *)SvPTR_ornull (sv, "cf::client"); }
384	inline void sv_to (SV *sv, player * &v) { v = (player *)(attachable *)SvPTR_ornull (sv, "cf::player"); }	489	inline void sv_to (SV *sv, player * &v) { v = (player *)(attachable *)SvPTR_ornull (sv, "cf::player"); }
385	inline void sv_to (SV *sv, object * &v) { v = (object *)(attachable *)SvPTR_ornull (sv, "cf::object"); }	490	inline void sv_to (SV *sv, object * &v) { v = (object *)(attachable *)SvPTR_ornull (sv, "cf::object"); }
386	inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)(attachable *)SvPTR_ornull (sv, "cf::arch"); }	491	inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)(attachable *)SvPTR_ornull (sv, "cf::arch"); }
387	inline void sv_to (SV *sv, maptile * &v) { v = (maptile *)(attachable *)SvPTR_ornull (sv, "cf::map"); }	492	inline void sv_to (SV *sv, maptile * &v) { v = (maptile *)(attachable *)SvPTR_ornull (sv, "cf::map"); }
		493	inline void sv_to (SV *sv, region * &v) { v = (region *)(attachable *)SvPTR_ornull (sv, "cf::region"); }
388	inline void sv_to (SV *sv, attachable * &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); }	494	inline void sv_to (SV *sv, attachable * &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); }
389	inline void sv_to (SV *sv, partylist * &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }	495	inline void sv_to (SV *sv, partylist * &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }
390	inline void sv_to (SV *sv, region * &v) { v = (region *)SvPTR_ornull (sv, "cf::region"); }
391	inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }	496	inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }
		497	inline void sv_to (SV *sv, mapspace * &v) { v = (mapspace *)SvPTR_ornull (sv, "cf::mapspace"); }
		498	inline void sv_to (SV *sv, object_freezer * &v) { v = (object_freezer *)SvPTR_ornull (sv, "cf::object::freezer"); }
		499	inline void sv_to (SV *sv, object_thawer * &v) { v = (object_thawer *)SvPTR_ornull (sv, "cf::object::thawer" ); }
392		500
393	//inline void sv_to (SV *sv, faceinfo * &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }	501	//inline void sv_to (SV *sv, faceinfo * &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }
394	inline void sv_to (SV *sv, treasurelist * &v) { v = treasurelist::find (SvPV_nolen (sv)); }	502	inline void sv_to (SV *sv, treasurelist * &v) { v = treasurelist::find (SvPV_nolen (sv)); }
395		503
396	template<class T>	504	template<class T>
397	inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }	505	inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }
398		506
399	template<int N>	507	template<int N>
400	inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); }	508	inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); }
401		509
402	inline void sv_to (SV *sv, rangetype &v) { v = (rangetype) SvIV (sv); }
403	inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); }	510	inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); }
404	inline void sv_to (SV *sv, petmode_t &v) { v = (petmode_t) SvIV (sv); }	511	inline void sv_to (SV *sv, petmode_t &v) { v = (petmode_t) SvIV (sv); }
405	inline void sv_to (SV *sv, usekeytype &v) { v = (usekeytype) SvIV (sv); }	512	inline void sv_to (SV *sv, usekeytype &v) { v = (usekeytype) SvIV (sv); }
406	inline void sv_to (SV *sv, unapplymode &v) { v = (unapplymode) SvIV (sv); }	513	inline void sv_to (SV *sv, unapplymode &v) { v = (unapplymode) SvIV (sv); }
407		514
408	inline void sv_to (SV *sv, std::string &v)	515	inline void sv_to (SV *sv, std::string &v)
409	{	516	{
410	STRLEN len;	517	STRLEN len;
411	char *data = SvPVbyte (sv, len);	518	char *data = SvPVbyte (sv, len);
412	v.assign (data, len);	519	v.assign (data, len);
413	}	520	}
414		521
415	inline void sv_to (SV *sv, UUID &v)	522	inline void sv_to (SV *sv, UUID &v)
416	{	523	{
417	unsigned int version;	524	if (!v.parse (SvPV_nolen (sv)))
418
419	if (2 != sscanf (SvPV_nolen (sv), "<%d.%" SCNx64 ">", &version, &v.seq) || 1 != version)
420	croak ("unparsable uuid: %s", SvPV_nolen (sv));	525	croak ("unparsable uuid: %s", SvPV_nolen (sv));
421	}	526	}
422		527
423	inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }	528	inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }
424		529
…		…
442	break;	547	break;
443		548
444	case DT_STRING:	549	case DT_STRING:
445	{	550	{
446	char *str = (char *)va_arg (ap, const char *);	551	char *str = (char *)va_arg (ap, const char *);
447	sv = str ? newSVpv (str, 0) : &PL_sv_undef;	552	sv = str ? newSVpv (str, 0) : newSV (0);
448	}	553	}
449	break;	554	break;
450		555
451	case DT_DATA:	556	case DT_DATA:
452	{	557	{
453	char *str = (char *)va_arg (ap, const void *);	558	char *str = (char *)va_arg (ap, const void *);
454	int len = va_arg (ap, int);	559	int len = va_arg (ap, int);
455	sv = str ? newSVpv (str, len) : &PL_sv_undef;	560	sv = str ? newSVpv (str, len) : newSV (0);
456	}	561	}
457	break;	562	break;
458		563
459	case DT_OBJECT:	564	case DT_OBJECT:
460	sv = to_sv (va_arg (ap, object *));	565	sv = to_sv (va_arg (ap, object *));
…		…
502	va_end (ap);	607	va_end (ap);
503		608
504	return sv;	609	return sv;
505	}	610	}
506		611
507	static SV *	612	// typemap support, mostly to avoid excessive inlining
508	newSVcfapi (int type, ...)	613	template<class type>
		614	static void noinline
		615	cf_obj_to (SV *arg, type &var)
509	{	616	{
510	SV *sv;	617	sv_to (arg, var);
		618	if (!var)
		619	croak ("must not pass invalid/null cf_obj here");
		620	}
511		621
512	va_list ap;	622	template<class object>
513	va_start (ap, type);	623	static void noinline
514		624	cf_obj_ornull_to (SV *arg, object *&var)
515	switch (type)	625	{
		626	if (SvOK (arg))
516	{	627	{
517	case CFAPI_INT: sv = newSViv (*va_arg (ap, int * )); break;	628	sv_to (arg, var);
518	case CFAPI_LONG: sv = newSVval64 (*va_arg (ap, sint64 *)); break;	629	if (!var)
519	case CFAPI_DOUBLE: sv = newSVnv (*va_arg (ap, double *)); break;	630	croak ("unable to convert perl object to C++ object");
520	case CFAPI_STRING: sv = newSVdt_va (ap, DT_STRING); break;
521	case CFAPI_POBJECT: sv = newSVdt_va (ap, DT_OBJECT); break;
522	case CFAPI_PMAP: sv = newSVdt_va (ap, DT_MAP ); break;
523	case CFAPI_PPLAYER: sv = newSVdt_va (ap, DT_PLAYER); break;
524	case CFAPI_PARCH: sv = newSVdt_va (ap, DT_ARCH ); break;
525	case CFAPI_PPARTY: sv = newSVdt_va (ap, DT_PARTY ); break;
526	case CFAPI_PREGION: sv = newSVdt_va (ap, DT_REGION); break;
527
528	default:
529	assert (("unhandled type in newSVcfapi", 0));
530	}	631	}
531		632	else
532	va_end (ap);	633	var = 0;
533
534	return sv;
535	}	634	}
536		635
537	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	636	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
538		637
539	SV *	638	SV *
…		…
545	return newRV_inc ((SV *)ext->cb);	644	return newRV_inc ((SV *)ext->cb);
546	}	645	}
547		646
548	/////////////////////////////////////////////////////////////////////////////	647	/////////////////////////////////////////////////////////////////////////////
549		648
550	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
551	{
552	return 0;
553	}
554
555	static CommArray_s rtn_cmd;
556
557	static int
558	runPluginCommand (object *obj, char *params)
559	{
560	return -1;
561	}
562
563	extern "C" void *cfperl_getPluginProperty (int *type, ...)
564	{
565	va_list args;
566	char *propname;
567	int i;
568	va_start (args, type);
569	propname = va_arg (args, char *);
570	//printf ("Property name: %s\n", propname);
571
572	if (!strcmp (propname, "command?"))
573	return NULL;
574	else if (!strcmp (propname, "Identification"))
575	{
576	va_end (args);
577	return (void *)PLUGIN_NAME;
578	}
579	else if (!strcmp (propname, "FullName"))
580	{
581	va_end (args);
582	return (void *)PLUGIN_VERSION;
583	}
584	else
585	va_end (args);
586
587	return NULL;
588	}
589
590	extern "C" int cfperl_postInitPlugin ()
591	{
592	int hooktype = 1;
593	int rtype = 0;
594
595	cf_init_plugin (gethook);
596
597	return 0;
598	}
599
600	extern "C" int cfperl_closePlugin ()
601	{
602	return 0;
603	}
604
605	void	649	void
606	cfperl_init ()	650	cfperl_init ()
607	{	651	{
		652	extern char **environ;
		653
608	PERL_SYS_INIT3 (&settings.argc, &settings.argv, 0);	654	PERL_SYS_INIT3 (&settings.argc, &settings.argv, &environ);
609	perl = perl_alloc ();	655	perl = perl_alloc ();
610	perl_construct (perl);	656	perl_construct (perl);
611		657
612	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;	658	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
613		659
614	const char *argv[] = {	660	const char *argv[] = {
615	"",	661	settings.argv [0],
616	"-e"	662	"-e0"
617	"use Event; use Coro;" // required for bootstrap
618	"cf->bootstrap;" // required for datadir :*>
619	"unshift @INC, cf::datadir ();"
620	"require cf;"
621	};	663	};
622		664
623	if (perl_parse (perl, xs_init, 2, (char **)argv, (char **)NULL)	665	if (perl_parse (perl, xs_init, 2, (char **)argv, environ)
624	|| perl_run (perl))	666	|| perl_run (perl))
625	{	667	{
626	printf ("unable to initialize perl-interpreter, aborting.\n");	668	printf ("unable to initialize perl-interpreter, aborting.\n");
627	exit (EXIT_FAILURE);	669	exit (EXIT_FAILURE);
628	}	670	}
629		671
		672	eval_pv (
		673	"#line 1 'cfperl init'\n"
		674	"use EV ();\n"
		675	"use Coro ();\n"
		676	"cf->bootstrap;\n"
		677	"unshift @INC, cf::datadir ();\n"
		678	"require cf;\n",
		679	0
		680	);
		681
		682	if (SvTRUE (ERRSV))
630	{	683	{
631	dSP;	684	printf ("unable to bootstrap perl, aborting:\n%s", SvPV_nolen (ERRSV));
632		685	exit (EXIT_FAILURE);
633	PUSHMARK (SP);
634	PUTBACK;
635	call_pv ("cf::init", G_DISCARD | G_VOID);
636	}	686	}
637	}	687	}
638		688
		689	void
639	void cfperl_main ()	690	cfperl_main ()
640	{	691	{
641	dSP;	692	dSP;
642		693
643	PUSHMARK (SP);	694	PUSHMARK (SP);
644	PUTBACK;	695	PUTBACK;
…		…
648	void	699	void
649	attachable::instantiate ()	700	attachable::instantiate ()
650	{	701	{
651	if (attach)	702	if (attach)
652	{	703	{
653	invoke (EVENT_ATTACHABLE_INSTANTIATE, ARG_STRING (attach), DT_END);	704	INVOKE_ATTACHABLE (INSTANTIATE, this, ARG_STRING (attach));
654	attach = 0;	705	attach = 0;
655	}	706	}
656	}	707	}
657		708
658	void	709	void
659	attachable::reattach ()	710	attachable::reattach ()
660	{	711	{
661	optimise ();	712	optimise ();
662	//TODO: check for _attachment's, very important for restarts	713	//TODO: check for _attachment's, very important for restarts
663	invoke (EVENT_ATTACHABLE_REATTACH, DT_END);	714	INVOKE_ATTACHABLE (REATTACH, this);
664	}	715	}
665		716
666	static event_klass klass_of[NUM_EVENT_TYPES] = {	717	static event_klass klass_of[NUM_EVENT_TYPES] = {
667	# define def(type,name) KLASS_ ## type,	718	# define def(type,name) KLASS_ ## type,
668	# include "eventinc.h"	719	# include "eventinc.h"
669	# undef def	720	# undef def
670	};	721	};
671		722
672	#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)	723	#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)
673		724
674	static void	725	static void noinline
675	gather_callbacks (AV *&callbacks, AV *registry, event_type event)	726	gather_callbacks (AV *&callbacks, AV *registry, event_type event)
676	{	727	{
677	// event must be in array	728	// event must be in array
678	if (event >= 0 && event <= AvFILLp (registry))	729	if (event >= 0 && event <= AvFILLp (registry))
679	{	730	{
…		…
711	}	762	}
712		763
713	void	764	void
714	global::gather_callbacks (AV *&callbacks, event_type event) const	765	global::gather_callbacks (AV *&callbacks, event_type event) const
715	{	766	{
716	::gather_callbacks (callbacks, cb_object, event);	767	::gather_callbacks (callbacks, cb_global, event);
717	}	768	}
718		769
719	void	770	void
720	object::gather_callbacks (AV *&callbacks, event_type event) const	771	object::gather_callbacks (AV *&callbacks, event_type event) const
721	{	772	{
722	if (subtype && type + subtype * NUM_SUBTYPES <= AvFILLp (cb_type))	773	if (subtype && type + subtype * NUM_TYPES <= AvFILLp (cb_type))
723	{	774	{
724	SV *registry = AvARRAY (cb_type)[type + subtype * NUM_SUBTYPES];	775	SV *registry = AvARRAY (cb_type)[type + subtype * NUM_TYPES];
725		776
726	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)	777	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
727	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);	778	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);
728	}	779	}
729		780
…		…
765	{	816	{
766	attachable::gather_callbacks (callbacks, event);	817	attachable::gather_callbacks (callbacks, event);
767	::gather_callbacks (callbacks, cb_map, event);	818	::gather_callbacks (callbacks, cb_map, event);
768	}	819	}
769		820
		821	static void noinline
		822	_recalc_want (bitset<NUM_EVENT_TYPES> &set, AV *registry)
		823	{
		824	for (int event = 0; event <= AvFILLp (registry); ++event)
		825	{
		826	SV *cbs_ = AvARRAY (registry)[event];
		827
		828	// element must be list of callback entries
		829	if (cbs_ && SvROK (cbs_) && SvTYPE (SvRV (cbs_)) == SVt_PVAV)
		830	{
		831	AV *cbs = (AV *)SvRV (cbs_);
		832
		833	// no callback entries, no callbacks to call
		834	if (AvFILLp (cbs) >= 0)
		835	set.set (event);
		836	}
		837	}
		838	}
		839
		840	// very slow and inefficient way to recalculate the global want bitsets
		841	static void
		842	_recalc_want ()
		843	{
		844	ev_want_event.reset ();
		845
		846	_recalc_want (ev_want_event, cb_global);
		847	_recalc_want (ev_want_event, cb_attachable);
		848	_recalc_want (ev_want_event, cb_object);
		849	_recalc_want (ev_want_event, cb_client);
		850	_recalc_want (ev_want_event, cb_player);
		851	_recalc_want (ev_want_event, cb_map);
		852
		853	ev_want_type.reset ();
		854
		855	for (int type = 0; type <= AvFILLp (cb_type); ++type)
		856	{
		857	SV *cbs_ = AvARRAY (cb_type)[type];
		858
		859	// element must be list of callback entries
		860	if (cbs_ && SvROK (cbs_) && SvTYPE (SvRV (cbs_)) == SVt_PVAV)
		861	{
		862	AV *cbs = (AV *)SvRV (cbs_);
		863
		864	// no callback entries, no callbacks to call
		865	if (AvFILLp (cbs) >= 0)
		866	ev_want_type.set (type % NUM_TYPES);
		867	}
		868	}
		869	}
		870
770	bool	871	bool
771	attachable::invoke (event_type event, ...)	872	attachable::invoke (event_type event, ...)
772	{	873	{
773	data_type dt;	874	data_type dt;
774	va_list ap;
775
776	va_start (ap, event);
777		875
778	// callback call ordering should be:	876	// callback call ordering should be:
779	// 1. per-object callback	877	// 1. per-object callback
780	// 2. per-class object	878	// 2. per-class object
781	// 3. per-type callback	879	// 3. per-type callback
…		…
785	gather_callbacks (callbacks, event);	883	gather_callbacks (callbacks, event);
786		884
787	// short-circuit processing if no callbacks found/defined	885	// short-circuit processing if no callbacks found/defined
788	if (!callbacks)	886	if (!callbacks)
789	return 0;	887	return 0;
		888
		889	va_list ap;
		890	va_start (ap, event);
790		891
791	CALL_BEGIN (3);	892	CALL_BEGIN (3);
792	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays	893	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays
793	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));	894	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));
794		895
…		…
829	}	930	}
830		931
831	SV *	932	SV *
832	cfperl_result (int idx)	933	cfperl_result (int idx)
833	{	934	{
834	AV *av = get_av ("cfperl::invoke_results", 0);	935	AV *av = get_av ("cf::INVOKE_RESULTS", 0);
835	if (!av)	936	if (!av)
836	return &PL_sv_undef;	937	return &PL_sv_undef;
837		938
838	SV **sv = av_fetch (av, idx, 0);	939	SV **sv = av_fetch (av, idx, 0);
839	if (!sv)	940	if (!sv)
…		…
853	{	954	{
854	return SvNV (cfperl_result (idx));	955	return SvNV (cfperl_result (idx));
855	}	956	}
856		957
857	/////////////////////////////////////////////////////////////////////////////	958	/////////////////////////////////////////////////////////////////////////////
		959	// various c++ => perl glue functions
		960
		961	void
		962	cfperl_tick ()
		963	{
		964	tick_pending = 1;
		965
		966	if (tick_inhibit)
		967	return;
		968
		969	tick_pending = 0;
		970
		971	dSP;
		972
		973	PUSHMARK (SP);
		974	PUTBACK;
		975	call_pv ("cf::tick", G_DISCARD | G_VOID);
		976
		977	SvNV_set (sv_next_tick, get_next_tick ()); SvNOK_only (sv_next_tick);
		978	}
858		979
859	void	980	void
860	cfperl_emergency_save ()	981	cfperl_emergency_save ()
861	{	982	{
862	CALL_BEGIN (0);	983	CALL_BEGIN (0);
…		…
871	CALL_ARG (make_core);	992	CALL_ARG (make_core);
872	CALL_CALL ("cf::post_cleanup", G_VOID);	993	CALL_CALL ("cf::post_cleanup", G_VOID);
873	CALL_END;	994	CALL_END;
874	}	995	}
875		996
		997	void
		998	cfperl_make_book (object *book, int level)
		999	{
		1000	CALL_BEGIN (2);
		1001	CALL_ARG (book);
		1002	CALL_ARG (level);
		1003	CALL_CALL ("ext::books::make_book", G_VOID);
		1004	CALL_END;
		1005	}
		1006
		1007	void
		1008	cfperl_send_msg (client *ns, int color, const char *type, const char *msg)
		1009	{
		1010	CALL_BEGIN (4);
		1011	CALL_ARG (ns);
		1012	CALL_ARG (type);
		1013	CALL_ARG_SV (newSVpv_utf8 (msg));
		1014	CALL_ARG (color);
		1015	CALL_CALL ("cf::client::send_msg", G_VOID);
		1016	CALL_END;
		1017	}
		1018
		1019	int
		1020	cfperl_can_merge (object *ob1, object *ob2)
		1021	{
		1022	int can;
		1023
		1024	CALL_BEGIN (2);
		1025	CALL_ARG (ob1);
		1026	CALL_ARG (ob2);
		1027	CALL_CALL ("cf::_can_merge", G_SCALAR);
		1028	can = count && SvTRUE (TOPs);
		1029	CALL_END;
		1030
		1031	return can;
		1032	}
		1033
		1034	player *
		1035	player::find (const char *name)
		1036	{
		1037	CALL_BEGIN (1);
		1038	CALL_ARG (name);
		1039	CALL_CALL ("cf::player::find", G_SCALAR);
		1040
		1041	player *retval = 0;
		1042	if (count) sv_to (POPs, retval);
		1043
		1044	CALL_END;
		1045
		1046	return retval;
		1047	}
		1048
		1049	maptile *
		1050	find_style (const char *dirname, const char *stylename, int difficulty)
		1051	{
		1052	CALL_BEGIN (3);
		1053	CALL_ARG (dirname);
		1054	CALL_ARG (stylename);
		1055	CALL_ARG (difficulty);
		1056	CALL_CALL ("ext::map_random::find_style", G_SCALAR);
		1057
		1058	maptile *retval = 0;
		1059	if (count) sv_to (POPs, retval);
		1060
		1061	CALL_END;
		1062
		1063	return retval;
		1064	}
		1065
876	maptile *	1066	maptile *
877	maptile::find_sync (const char *path, maptile *origin)	1067	maptile::find_sync (const char *path, maptile *origin)
878	{	1068	{
879	CALL_BEGIN (2);	1069	CALL_BEGIN (2);
880	CALL_ARG (path);	1070	CALL_ARG (path);
881	CALL_ARG (origin);	1071	CALL_ARG (origin);
882	CALL_CALL ("cf::map::find_sync", G_SCALAR);	1072	CALL_CALL ("cf::map::find_sync", G_SCALAR);
883		1073
884	maptile *retval;	1074	maptile *retval = 0;
885
886	if (count)
887	sv_to (POPs, retval);	1075	if (count) sv_to (POPs, retval);
888	else
889	retval = 0;
890		1076
891	CALL_END;	1077	CALL_END;
892		1078
893	return retval;	1079	return retval;
894	}	1080	}
895		1081
896	maptile *	1082	maptile *
897	maptile::find_async (const char *path, maptile *origin)	1083	maptile::find_async (const char *path, maptile *origin, bool load)
898	{	1084	{
899	CALL_BEGIN (2);	1085	CALL_BEGIN (3);
900	CALL_ARG (path);	1086	CALL_ARG (path);
901	CALL_ARG (origin);	1087	CALL_ARG (origin);
		1088	CALL_ARG (load);
902	CALL_CALL ("cf::map::find_async", G_SCALAR);	1089	CALL_CALL ("cf::map::find_async", G_SCALAR);
903		1090
904	maptile *retval;	1091	maptile *retval = 0;
905
906	if (count)
907	sv_to (POPs, retval);	1092	if (count) sv_to (POPs, retval);
908	else
909	retval = 0;
910		1093
911	CALL_END;	1094	CALL_END;
912		1095
913	return retval;	1096	return retval;
914	}	1097	}
…		…
917	maptile::do_load_sync ()	1100	maptile::do_load_sync ()
918	{	1101	{
919	CALL_BEGIN (1);	1102	CALL_BEGIN (1);
920	CALL_ARG (this);	1103	CALL_ARG (this);
921	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);	1104	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);
922	CALL_END;
923	}
924
925	void
926	maptile::change_all_map_light (int change)
927	{
928	CALL_BEGIN (1);
929	CALL_ARG (change);
930	CALL_CALL ("cf::map::change_all_map_light", G_VOID);
931	CALL_END;	1105	CALL_END;
932	}	1106	}
933		1107
934	void	1108	void
935	object::enter_exit (object *exit)	1109	object::enter_exit (object *exit)
…		…
942	CALL_ARG (exit);	1116	CALL_ARG (exit);
943	CALL_CALL ("cf::object::player::enter_exit", G_VOID);	1117	CALL_CALL ("cf::object::player::enter_exit", G_VOID);
944	CALL_END;	1118	CALL_END;
945	}	1119	}
946		1120
		1121	void
		1122	object::player_goto (const char *path, int x, int y)
		1123	{
		1124	if (type != PLAYER)
		1125	return;
		1126
		1127	CALL_BEGIN (4);
		1128	CALL_ARG (this);
		1129	CALL_ARG (path);
		1130	CALL_ARG (x);
		1131	CALL_ARG (y);
		1132	CALL_CALL ("cf::object::player::goto", G_VOID);
		1133	CALL_END;
		1134	}
		1135
		1136	const char *
		1137	object::ref () const
		1138	{
		1139	if (type == PLAYER)
		1140	return format ("player/<1.%llx>/%s", (unsigned long long)uuid.seq, &name);
		1141	else
		1142	return 0;
		1143	}
		1144
		1145	object *
		1146	object::deref (const char *ref)
		1147	{
		1148	object *retval = 0;
		1149
		1150	if (ref)
		1151	{
		1152	CALL_BEGIN (1);
		1153	CALL_ARG (ref);
		1154	CALL_CALL ("cf::object::deref", G_SCALAR);
		1155
		1156	if (count)
		1157	sv_to (POPs, retval);
		1158
		1159	CALL_END;
		1160	}
		1161
		1162	return retval;
		1163	}
		1164
		1165	void
		1166	log_backtrace (const char *msg)
		1167	{
		1168	#if HAVE_BACKTRACE
		1169	void *addr [20];
		1170	int size = backtrace (addr, 20);
		1171
		1172	CALL_BEGIN (size);
		1173	CALL_ARG (msg);
		1174	for (int i = 0; i < size; ++i)
		1175	CALL_ARG ((IV)addr [i]);
		1176	CALL_CALL ("cf::_log_backtrace", G_VOID);
		1177	CALL_END;
		1178	#endif
		1179	}
		1180
947	/////////////////////////////////////////////////////////////////////////////	1181	/////////////////////////////////////////////////////////////////////////////
948		1182
949	struct EventAPI *watcher_base::GEventAPI;	1183	struct EVAPI *evapi::GEVAPI;
950	struct CoroAPI *coroapi::GCoroAPI;	1184	struct CoroAPI *coroapi::GCoroAPI;
951		1185
952	int coroapi::cede_counter;	1186	void
953	double (*coroapi::time)();
954	double coroapi::next_cede;
955
956	void coroapi::do_cede_to_tick ()	1187	coroapi::do_cede_to_tick ()
957	{	1188	{
958	cede_counter = 0;	1189	cede_pending = 0;
959
960	cede ();	1190	cede ();
961
962	next_cede += (TICK / CEDES_PER_TICK) * 0.99;
963	if (next_cede > SvNV (sv_next_tick) - 0.02)
964	next_cede = SvNV (sv_next_tick);
965	}
966
967	void coroapi::do_cede_every ()
968	{
969	cede_counter = 0;
970
971	if (coroapi::nready ())
972	coroapi::cede ();
973	}
974
975	void coroapi::do_cede_to_tick_every ()
976	{
977	cede_counter = 0;
978
979	cede_to_tick ();
980	}	1191	}
981		1192
982	void	1193	void
983	coroapi::wait_for_tick ()	1194	coroapi::wait_for_tick ()
984	{	1195	{
…		…
993	CALL_BEGIN (0);	1204	CALL_BEGIN (0);
994	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);	1205	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);
995	CALL_END;	1206	CALL_END;
996	}	1207	}
997		1208
		1209	void
		1210	iow::poll (int events)
		1211	{
		1212	if (events != this->events)
		1213	{
		1214	int active = ev_is_active ((ev_io *)this);
		1215	if (active) stop ();
		1216	ev_io_set ((ev_io *)this, fd, events);
		1217	if (active) start ();
		1218	}
		1219	}
		1220
998	static void	1221	static void
999	iw_dispatch (pe_event *ev)
1000	{
1001	iw *w = (iw *)ev->ext_data;
1002	w->call (*w);
1003	}
1004
1005	void
1006	iw::alloc ()
1007	{
1008	pe = GEventAPI->new_idle (0, 0);
1009
1010	WaREENTRANT_off (pe);
1011	pe->base.callback = (void *)iw_dispatch;
1012	pe->base.ext_data = (void *)this;
1013	}
1014
1015	static void iow_dispatch (pe_event *ev)
1016	{
1017	iow *w = (iow *)ev->ext_data;
1018	w->call (*w, ((pe_ioevent *)ev)->got);
1019	}
1020
1021	void
1022	iow::alloc ()
1023	{
1024	pe = GEventAPI->new_io (0, 0);
1025
1026	WaREENTRANT_off (pe);
1027	pe->base.callback = (void *)iow_dispatch;
1028	pe->base.ext_data = (void *)this;
1029
1030	pe->fd = -1;
1031	pe->poll = 0;
1032	}
1033
1034	void
1035	iow::fd (int fd)
1036	{
1037	pe->fd = fd;
1038	}
1039
1040	int
1041	iow::poll ()
1042	{
1043	return pe->poll;
1044	}
1045
1046	void
1047	iow::poll (int events)
1048	{
1049	if (pe->poll != events)
1050	{
1051	if (pe->poll) stop ();
1052	pe->poll = events;
1053	if (pe->poll) start ();
1054	}
1055	}
1056
1057	void
1058	_connect_to_perl ()	1222	_connect_to_perl ()
1059	{	1223	{
1060	stash_cf = gv_stashpv ("cf" , 1);	1224	stash_cf = gv_stashpv ("cf", 1);
1061		1225
1062	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);	1226	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);
1063	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);	1227	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);
1064	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);	1228	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);
1065	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);	1229	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);
		1230	stash_cf_mapspace_wrap = gv_stashpv ("cf::mapspace::wrap" , 1);
1066	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);	1231	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);
1067	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);	1232	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
1068	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);	1233	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
1069	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);	1234	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
1070	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);	1235	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
1071		1236
		1237	sv_now = get_sv ("cf::NOW" , 1); SvUPGRADE (sv_now , SVt_NV);
1072	sv_runtime = get_sv ("cf::RUNTIME" , 1); sv_upgrade (sv_runtime , SVt_NV);	1238	sv_runtime = get_sv ("cf::RUNTIME" , 1); SvUPGRADE (sv_runtime , SVt_NV);
		1239	sv_tick_start = get_sv ("cf::TICK_START", 1); SvUPGRADE (sv_tick_start, SVt_NV);
1073	sv_next_tick = get_sv ("cf::NEXT_TICK", 1); sv_upgrade (sv_next_tick, SVt_NV);	1240	sv_next_tick = get_sv ("cf::NEXT_TICK" , 1); SvUPGRADE (sv_next_tick , SVt_NV);
1074		1241
1075	cb_global = get_av ("cf::CB_GLOBAL", 1);	1242	cb_global = get_av ("cf::CB_GLOBAL", 1);
1076	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);	1243	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
1077	cb_object = get_av ("cf::CB_OBJECT", 1);	1244	cb_object = get_av ("cf::CB_OBJECT", 1);
1078	cb_player = get_av ("cf::CB_PLAYER", 1);	1245	cb_player = get_av ("cf::CB_PLAYER", 1);
…		…
1083		1250
1084	MODULE = cf PACKAGE = cf PREFIX = cf_	1251	MODULE = cf PACKAGE = cf PREFIX = cf_
1085		1252
1086	BOOT:	1253	BOOT:
1087	{	1254	{
1088	I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;	1255	I_EV_API (PACKAGE); evapi::GEVAPI = GEVAPI;
1089	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;	1256	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
1090		1257
1091	_connect_to_perl ();	1258	_connect_to_perl ();
1092		1259
1093	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));	1260	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
1094		1261
1095	{	1262	//{
1096	require_pv ("Time::HiRes");	1263	// require_pv ("Time::HiRes");
1097		1264	//
1098	SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);	1265	// SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
1099	if (!svp) croak ("Time::HiRes is required");	1266	// if (!svp) croak ("Time::HiRes is required");
1100	if (!SvIOK(*svp)) croak ("Time::NVtime isn’t a function pointer");	1267	// if (!SvIOK(*svp)) croak ("Time::NVtime isn’t a function pointer");
1101	coroapi::time = INT2PTR (double(*)(), SvIV(*svp));	1268	// coroapi::time = INT2PTR (double(*)(), SvIV(*svp));
1102	}	1269	//}
1103		1270
1104	static const struct {	1271	static const struct {
1105	const char *name;	1272	const char *name;
1106	IV iv;	1273	IV iv;
1107	} *civ, const_iv[] = {	1274	} *civ, const_iv[] = {
1108	# define const_iv(name) { # name, (IV)name },	1275	# define const_iv(name) { # name, (IV)name },
1109	const_iv (llevError) const_iv (llevInfo) const_iv (llevDebug) const_iv (llevMonster)	1276	const_iv (llevError) const_iv (llevInfo) const_iv (llevDebug) const_iv (llevMonster)
		1277	const_iv (logBacktrace)
1110		1278
1111	const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)	1279	const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)
1112		1280
1113	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)	1281	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)
1114		1282
1115	const_iv (MAX_TIME)	1283	const_iv (MAX_TIME)
		1284	const_iv (MAXSOCKBUF)
		1285
		1286	const_iv (NUM_BODY_LOCATIONS)
		1287	const_iv (body_range) const_iv (body_shield) const_iv (body_combat)
		1288	const_iv (body_arm) const_iv (body_torso) const_iv (body_head)
		1289	const_iv (body_neck) const_iv (body_skill) const_iv (body_finger)
		1290	const_iv (body_shoulder) const_iv (body_foot) const_iv (body_hand)
		1291	const_iv (body_wrist) const_iv (body_waist)
1116		1292
1117	const_iv (PLAYER) const_iv (TRANSPORT) const_iv (ROD) const_iv (TREASURE)	1293	const_iv (PLAYER) const_iv (TRANSPORT) const_iv (ROD) const_iv (TREASURE)
1118	const_iv (POTION) const_iv (FOOD) const_iv (POISON) const_iv (BOOK)	1294	const_iv (POTION) const_iv (FOOD) const_iv (POISON) const_iv (BOOK)
1119	const_iv (CLOCK) const_iv (ARROW) const_iv (BOW) const_iv (WEAPON)	1295	const_iv (CLOCK) const_iv (ARROW) const_iv (BOW) const_iv (WEAPON)
1120	const_iv (ARMOUR) const_iv (PEDESTAL) const_iv (ALTAR) const_iv (LOCKED_DOOR)	1296	const_iv (ARMOUR) const_iv (PEDESTAL) const_iv (ALTAR) const_iv (LOCKED_DOOR)
…		…
1141	const_iv (CONTAINER) const_iv (ARMOUR_IMPROVER) const_iv (WEAPON_IMPROVER) const_iv (SKILLSCROLL)	1317	const_iv (CONTAINER) const_iv (ARMOUR_IMPROVER) const_iv (WEAPON_IMPROVER) const_iv (SKILLSCROLL)
1142	const_iv (DEEP_SWAMP) const_iv (IDENTIFY_ALTAR) const_iv (MENU) const_iv (RUNE)	1318	const_iv (DEEP_SWAMP) const_iv (IDENTIFY_ALTAR) const_iv (MENU) const_iv (RUNE)
1143	const_iv (TRAP) const_iv (POWER_CRYSTAL) const_iv (CORPSE) const_iv (DISEASE)	1319	const_iv (TRAP) const_iv (POWER_CRYSTAL) const_iv (CORPSE) const_iv (DISEASE)
1144	const_iv (SYMPTOM) const_iv (BUILDER) const_iv (MATERIAL) const_iv (ITEM_TRANSFORMER)	1320	const_iv (SYMPTOM) const_iv (BUILDER) const_iv (MATERIAL) const_iv (ITEM_TRANSFORMER)
1145		1321
1146	const_iv (NUM_SUBTYPES)	1322	const_iv (NUM_TYPES) const_iv (NUM_SUBTYPES)
1147		1323
1148	const_iv (ST_BD_BUILD) const_iv (ST_BD_REMOVE)	1324	const_iv (ST_BD_BUILD) const_iv (ST_BD_REMOVE)
1149	const_iv (ST_MAT_FLOOR) const_iv (ST_MAT_WALL) const_iv (ST_MAT_ITEM)	1325	const_iv (ST_MAT_FLOOR) const_iv (ST_MAT_WALL) const_iv (ST_MAT_ITEM)
1150		1326
1151	const_iv (AT_PHYSICAL) const_iv (AT_MAGIC) const_iv (AT_FIRE) const_iv (AT_ELECTRICITY)	1327	const_iv (AT_PHYSICAL) const_iv (AT_MAGIC) const_iv (AT_FIRE) const_iv (AT_ELECTRICITY)
…		…
1159	const_iv (WEAP_HIT) const_iv (WEAP_SLASH) const_iv (WEAP_PIERCE) const_iv (WEAP_CLEAVE)	1335	const_iv (WEAP_HIT) const_iv (WEAP_SLASH) const_iv (WEAP_PIERCE) const_iv (WEAP_CLEAVE)
1160	const_iv (WEAP_SLICE) const_iv (WEAP_STAB) const_iv (WEAP_WHIP) const_iv (WEAP_CRUSH)	1336	const_iv (WEAP_SLICE) const_iv (WEAP_STAB) const_iv (WEAP_WHIP) const_iv (WEAP_CRUSH)
1161	const_iv (WEAP_BLUD)	1337	const_iv (WEAP_BLUD)
1162		1338
1163	const_iv (FLAG_ALIVE) const_iv (FLAG_WIZ) const_iv (FLAG_REMOVED) const_iv (FLAG_FREED)	1339	const_iv (FLAG_ALIVE) const_iv (FLAG_WIZ) const_iv (FLAG_REMOVED) const_iv (FLAG_FREED)
1164	const_iv (FLAG_WAS_WIZ) const_iv (FLAG_APPLIED) const_iv (FLAG_UNPAID) const_iv (FLAG_USE_SHIELD)	1340	const_iv (FLAG_APPLIED) const_iv (FLAG_UNPAID) const_iv (FLAG_USE_SHIELD)
1165	const_iv (FLAG_NO_PICK) const_iv (FLAG_ANIMATE) const_iv (FLAG_MONSTER) const_iv (FLAG_FRIENDLY)	1341	const_iv (FLAG_NO_PICK) const_iv (FLAG_ANIMATE) const_iv (FLAG_MONSTER) const_iv (FLAG_FRIENDLY)
1166	const_iv (FLAG_GENERATOR) const_iv (FLAG_IS_THROWN) const_iv (FLAG_AUTO_APPLY) const_iv (FLAG_PLAYER_SOLD)	1342	const_iv (FLAG_GENERATOR) const_iv (FLAG_IS_THROWN) const_iv (FLAG_AUTO_APPLY) const_iv (FLAG_PLAYER_SOLD)
1167	const_iv (FLAG_SEE_INVISIBLE) const_iv (FLAG_CAN_ROLL) const_iv (FLAG_OVERLAY_FLOOR) const_iv (FLAG_IS_TURNABLE)	1343	const_iv (FLAG_SEE_INVISIBLE) const_iv (FLAG_CAN_ROLL) const_iv (FLAG_OVERLAY_FLOOR) const_iv (FLAG_IS_TURNABLE)
1168	const_iv (FLAG_IS_USED_UP) const_iv (FLAG_IDENTIFIED) const_iv (FLAG_REFLECTING) const_iv (FLAG_CHANGING)	1344	const_iv (FLAG_IS_USED_UP) const_iv (FLAG_IDENTIFIED) const_iv (FLAG_REFLECTING) const_iv (FLAG_CHANGING)
1169	const_iv (FLAG_SPLITTING) const_iv (FLAG_HITBACK) const_iv (FLAG_STARTEQUIP) const_iv (FLAG_BLOCKSVIEW)	1345	const_iv (FLAG_SPLITTING) const_iv (FLAG_HITBACK) const_iv (FLAG_STARTEQUIP) const_iv (FLAG_BLOCKSVIEW)
…		…
1179	const_iv (FLAG_CURSED) const_iv (FLAG_DAMNED) const_iv (FLAG_SEE_ANYWHERE) const_iv (FLAG_KNOWN_MAGICAL)	1355	const_iv (FLAG_CURSED) const_iv (FLAG_DAMNED) const_iv (FLAG_SEE_ANYWHERE) const_iv (FLAG_KNOWN_MAGICAL)
1180	const_iv (FLAG_KNOWN_CURSED) const_iv (FLAG_CAN_USE_SKILL) const_iv (FLAG_BEEN_APPLIED) const_iv (FLAG_READY_SCROLL)	1356	const_iv (FLAG_KNOWN_CURSED) const_iv (FLAG_CAN_USE_SKILL) const_iv (FLAG_BEEN_APPLIED) const_iv (FLAG_READY_SCROLL)
1181	const_iv (FLAG_USE_ROD) const_iv (FLAG_USE_HORN) const_iv (FLAG_MAKE_INVIS) const_iv (FLAG_INV_LOCKED)	1357	const_iv (FLAG_USE_ROD) const_iv (FLAG_USE_HORN) const_iv (FLAG_MAKE_INVIS) const_iv (FLAG_INV_LOCKED)
1182	const_iv (FLAG_IS_WOODED) const_iv (FLAG_IS_HILLY) const_iv (FLAG_READY_SKILL) const_iv (FLAG_READY_WEAPON)	1358	const_iv (FLAG_IS_WOODED) const_iv (FLAG_IS_HILLY) const_iv (FLAG_READY_SKILL) const_iv (FLAG_READY_WEAPON)
1183	const_iv (FLAG_NO_SKILL_IDENT) const_iv (FLAG_BLIND) const_iv (FLAG_SEE_IN_DARK) const_iv (FLAG_IS_CAULDRON)	1359	const_iv (FLAG_NO_SKILL_IDENT) const_iv (FLAG_BLIND) const_iv (FLAG_SEE_IN_DARK) const_iv (FLAG_IS_CAULDRON)
1184	const_iv (FLAG_NO_STEAL) const_iv (FLAG_ONE_HIT) const_iv (FLAG_CLIENT_SENT) const_iv (FLAG_BERSERK)	1360	const_iv (FLAG_NO_STEAL) const_iv (FLAG_ONE_HIT) const_iv (FLAG_DEBUG) const_iv (FLAG_BERSERK)
1185	const_iv (FLAG_NEUTRAL) const_iv (FLAG_NO_ATTACK) const_iv (FLAG_NO_DAMAGE) const_iv (FLAG_OBJ_ORIGINAL)	1361	const_iv (FLAG_NEUTRAL) const_iv (FLAG_NO_ATTACK) const_iv (FLAG_NO_DAMAGE) const_iv (FLAG_OBJ_ORIGINAL)
1186	const_iv (FLAG_OBJ_SAVE_ON_OVL) const_iv (FLAG_ACTIVATE_ON_PUSH) const_iv (FLAG_ACTIVATE_ON_RELEASE) const_iv (FLAG_IS_WATER)	1362	const_iv (FLAG_ACTIVATE_ON_PUSH) const_iv (FLAG_ACTIVATE_ON_RELEASE) const_iv (FLAG_IS_WATER) const_iv (FLAG_WIZLOOK)
1187	const_iv (FLAG_CONTENT_ON_GEN) const_iv (FLAG_IS_A_TEMPLATE) const_iv (FLAG_IS_BUILDABLE)	1363	const_iv (FLAG_CONTENT_ON_GEN) const_iv (FLAG_IS_A_TEMPLATE) const_iv (FLAG_IS_BUILDABLE)
1188	const_iv (FLAG_DESTROY_ON_DEATH) const_iv (FLAG_NO_MAP_SAVE)	1364	const_iv (FLAG_DESTROY_ON_DEATH) const_iv (FLAG_NO_MAP_SAVE)
1189		1365
1190	const_iv (NDI_BLACK) const_iv (NDI_WHITE) const_iv (NDI_NAVY) const_iv (NDI_RED)	1366	const_iv (NDI_BLACK) const_iv (NDI_WHITE) const_iv (NDI_NAVY) const_iv (NDI_RED)
1191	const_iv (NDI_ORANGE) const_iv (NDI_BLUE) const_iv (NDI_DK_ORANGE) const_iv (NDI_GREEN)	1367	const_iv (NDI_ORANGE) const_iv (NDI_BLUE) const_iv (NDI_DK_ORANGE) const_iv (NDI_GREEN)
1192	const_iv (NDI_LT_GREEN) const_iv (NDI_GREY) const_iv (NDI_BROWN) const_iv (NDI_GOLD)	1368	const_iv (NDI_LT_GREEN) const_iv (NDI_GREY) const_iv (NDI_BROWN) const_iv (NDI_GOLD)
1193	const_iv (NDI_TAN) const_iv (NDI_MAX_COLOR) const_iv (NDI_COLOR_MASK) const_iv (NDI_UNIQUE)	1369	const_iv (NDI_TAN) const_iv (NDI_MAX_COLOR) const_iv (NDI_COLOR_MASK) const_iv (NDI_UNIQUE)
1194	const_iv (NDI_ALL)	1370	const_iv (NDI_ALL) const_iv (NDI_DEF) const_iv (NDI_REPLY) const_iv (NDI_CLIENT_MASK)
		1371	const_iv (NDI_NOCREATE) const_iv (NDI_CLEAR) const_iv (NDI_VERBATIM)
1195		1372
1196	const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE)	1373	const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE)
1197	const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF)	1374	const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF)
1198		1375
1199	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_DAMAGE)	1376	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_DAMAGE)
		1377
		1378	const_iv (SP_RAISE_DEAD)
		1379	const_iv (SP_RUNE)
		1380	const_iv (SP_MAKE_MARK)
		1381	const_iv (SP_BOLT)
		1382	const_iv (SP_BULLET)
		1383	const_iv (SP_EXPLOSION)
		1384	const_iv (SP_CONE)
		1385	const_iv (SP_BOMB)
		1386	const_iv (SP_WONDER)
		1387	const_iv (SP_SMITE)
		1388	const_iv (SP_MAGIC_MISSILE)
		1389	const_iv (SP_SUMMON_GOLEM)
		1390	const_iv (SP_DIMENSION_DOOR)
		1391	const_iv (SP_MAGIC_MAPPING)
		1392	const_iv (SP_MAGIC_WALL)
		1393	const_iv (SP_DESTRUCTION)
		1394	const_iv (SP_PERCEIVE_SELF)
		1395	const_iv (SP_WORD_OF_RECALL)
		1396	const_iv (SP_INVISIBLE)
		1397	const_iv (SP_PROBE)
		1398	const_iv (SP_HEALING)
		1399	const_iv (SP_CREATE_FOOD)
		1400	const_iv (SP_EARTH_TO_DUST)
		1401	const_iv (SP_CHANGE_ABILITY)
		1402	const_iv (SP_BLESS)
		1403	const_iv (SP_CURSE)
		1404	const_iv (SP_SUMMON_MONSTER)
		1405	const_iv (SP_CHARGING)
		1406	const_iv (SP_POLYMORPH)
		1407	const_iv (SP_ALCHEMY)
		1408	const_iv (SP_REMOVE_CURSE)
		1409	const_iv (SP_IDENTIFY)
		1410	const_iv (SP_DETECTION)
		1411	const_iv (SP_MOOD_CHANGE)
		1412	const_iv (SP_MOVING_BALL)
		1413	const_iv (SP_SWARM)
		1414	const_iv (SP_CHANGE_MANA)
		1415	const_iv (SP_DISPEL_RUNE)
		1416	const_iv (SP_CREATE_MISSILE)
		1417	const_iv (SP_CONSECRATE)
		1418	const_iv (SP_ANIMATE_WEAPON)
		1419	const_iv (SP_LIGHT)
		1420	const_iv (SP_CHANGE_MAP_LIGHT)
		1421	const_iv (SP_FAERY_FIRE)
		1422	const_iv (SP_CAUSE_DISEASE)
		1423	const_iv (SP_AURA)
		1424	const_iv (SP_TOWN_PORTAL)
		1425	const_iv (SP_PARTY_SPELL)
1200		1426
1201	const_iv (F_APPLIED) const_iv (F_LOCATION) const_iv (F_UNPAID) const_iv (F_MAGIC)	1427	const_iv (F_APPLIED) const_iv (F_LOCATION) const_iv (F_UNPAID) const_iv (F_MAGIC)
1202	const_iv (F_CURSED) const_iv (F_DAMNED) const_iv (F_OPEN) const_iv (F_NOPICK)	1428	const_iv (F_CURSED) const_iv (F_DAMNED) const_iv (F_OPEN) const_iv (F_NOPICK)
1203	const_iv (F_LOCKED)	1429	const_iv (F_LOCKED)
1204		1430
1205	const_iv (F_BUY) const_iv (F_SHOP) const_iv (F_SELL)	1431	const_iv (F_BUY) const_iv (F_SHOP) const_iv (F_SELL)
1206		1432
1207	const_iv (P_BLOCKSVIEW) const_iv (P_PLAYER) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE)	1433	const_iv (P_BLOCKSVIEW) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE)
1208	const_iv (P_NO_CLERIC) const_iv (P_OUT_OF_MAP) const_iv (P_NEW_MAP) const_iv (P_UPTODATE)	1434	const_iv (P_NO_CLERIC) const_iv (P_OUT_OF_MAP) const_iv (P_NEW_MAP) const_iv (P_UPTODATE)
1209		1435
1210	const_iv (UP_OBJ_INSERT) const_iv (UP_OBJ_REMOVE) const_iv (UP_OBJ_CHANGE) const_iv (UP_OBJ_FACE)	1436	const_iv (UP_OBJ_INSERT) const_iv (UP_OBJ_REMOVE) const_iv (UP_OBJ_CHANGE) const_iv (UP_OBJ_FACE)
1211		1437
1212	const_iv (INS_NO_MERGE) const_iv (INS_ABOVE_FLOOR_ONLY) const_iv (INS_NO_WALK_ON)	1438	const_iv (INS_NO_MERGE) const_iv (INS_ABOVE_FLOOR_ONLY) const_iv (INS_NO_WALK_ON)
1213	const_iv (INS_ON_TOP) const_iv (INS_BELOW_ORIGINATOR) const_iv (INS_MAP_LOAD)	1439	const_iv (INS_ON_TOP) const_iv (INS_BELOW_ORIGINATOR)
1214		1440
1215	const_iv (WILL_APPLY_HANDLE) const_iv (WILL_APPLY_TREASURE) const_iv (WILL_APPLY_EARTHWALL)	1441	const_iv (WILL_APPLY_HANDLE) const_iv (WILL_APPLY_TREASURE) const_iv (WILL_APPLY_EARTHWALL)
1216	const_iv (WILL_APPLY_DOOR) const_iv (WILL_APPLY_FOOD)	1442	const_iv (WILL_APPLY_DOOR) const_iv (WILL_APPLY_FOOD)
1217		1443
1218	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)	1444	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)
…		…
1252	const_iv (ATNR_PARALYZE) const_iv (ATNR_TURN_UNDEAD) const_iv (ATNR_FEAR) const_iv (ATNR_CANCELLATION)	1478	const_iv (ATNR_PARALYZE) const_iv (ATNR_TURN_UNDEAD) const_iv (ATNR_FEAR) const_iv (ATNR_CANCELLATION)
1253	const_iv (ATNR_DEPLETE) const_iv (ATNR_DEATH) const_iv (ATNR_CHAOS) const_iv (ATNR_COUNTERSPELL)	1479	const_iv (ATNR_DEPLETE) const_iv (ATNR_DEATH) const_iv (ATNR_CHAOS) const_iv (ATNR_COUNTERSPELL)
1254	const_iv (ATNR_GODPOWER) const_iv (ATNR_HOLYWORD) const_iv (ATNR_BLIND) const_iv (ATNR_INTERNAL)	1480	const_iv (ATNR_GODPOWER) const_iv (ATNR_HOLYWORD) const_iv (ATNR_BLIND) const_iv (ATNR_INTERNAL)
1255	const_iv (ATNR_LIFE_STEALING) const_iv (ATNR_DISEASE)	1481	const_iv (ATNR_LIFE_STEALING) const_iv (ATNR_DISEASE)
1256		1482
1257	const_iv (MAP_IN_MEMORY) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)	1483	const_iv (MAP_ACTIVE) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)
		1484	const_iv (MAP_INACTIVE)
1258		1485
1259	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)	1486	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)
1260	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)	1487	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)
		1488
		1489	const_iv (VERSION_CS) const_iv (VERSION_SC)
1261		1490
1262	const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)	1491	const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)
1263		1492
1264	const_iv (ST_DEAD) const_iv (ST_SETUP) const_iv (ST_PLAYING) const_iv (ST_CUSTOM)	1493	const_iv (ST_DEAD) const_iv (ST_SETUP) const_iv (ST_PLAYING) const_iv (ST_CUSTOM)
1265		1494
…		…
1275		1504
1276	const_iv (SYMMETRY_RANDOM) const_iv (SYMMETRY_NONE) const_iv (SYMMETRY_X)	1505	const_iv (SYMMETRY_RANDOM) const_iv (SYMMETRY_NONE) const_iv (SYMMETRY_X)
1277	const_iv (SYMMETRY_Y) const_iv (SYMMETRY_XY)	1506	const_iv (SYMMETRY_Y) const_iv (SYMMETRY_XY)
1278		1507
1279	const_iv (GT_ENVIRONMENT) const_iv (GT_INVISIBLE) const_iv (GT_STARTEQUIP)	1508	const_iv (GT_ENVIRONMENT) const_iv (GT_INVISIBLE) const_iv (GT_STARTEQUIP)
1280	const_iv (GT_APPLY) const_iv (GT_ONLY_GOOD) const_iv (GT_UPDATE_INV)	1509	const_iv (GT_APPLY) const_iv (GT_ONLY_GOOD) const_iv (GT_MINIMAL)
1281	const_iv (GT_MINIMAL)	1510
		1511	const_iv (FT_FACE) const_iv (FT_MUSIC) const_iv (FT_SOUND)
		1512	const_iv (FT_RSRC) const_iv (FT_NUM)
1282	};	1513	};
1283		1514
1284	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	1515	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1285	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));	1516	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1286		1517
…		…
1305	av_store (av, eiv->iv, newRV_noinc ((SV *)event));	1536	av_store (av, eiv->iv, newRV_noinc ((SV *)event));
1306	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));	1537	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));
1307	}	1538	}
1308	}	1539	}
1309		1540
		1541	void _gv_clear (SV *gv)
		1542	CODE:
		1543	assert (SvTYPE (gv) == SVt_PVGV);
		1544	# define f(sv) { SV *sv_ = (SV *)(sv); sv = 0; SvREFCNT_dec (sv_); }
		1545	f (GvGP (gv)->gp_form);
		1546	f (GvGP (gv)->gp_io);
		1547	f (GvGP (gv)->gp_sv);
		1548	f (GvGP (gv)->gp_av);
		1549	f (GvGP (gv)->gp_hv);
		1550	f (GvGP (gv)->gp_cv);
		1551	GvCVGEN (gv) = 0;
		1552	GvMULTI_off (gv);
		1553	# undef f
		1554
1310	void _connect_to_perl ()	1555	void _connect_to_perl ()
1311		1556
		1557	void _recalc_want ()
		1558
		1559	# not used by default anymore
1312	void _global_reattach ()	1560	void _global_reattach ()
1313	CODE:	1561	CODE:
1314	{	1562	{
1315	// reattach to all attachable objects in the game.	1563	// reattach to all attachable objects in the game.
1316	for_all_clients (ns)	1564	for_all_clients (ns)
1317	ns->reattach ();	1565	ns->reattach ();
1318		1566
1319	for_all_objects (op)	1567	for_all_objects (op)
1320	op->reattach ();	1568	op->reattach ();
1321	}	1569	}
1322
1323	void _post_tick ()
1324	CODE:
1325	coroapi::next_cede = SvNV (sv_next_tick) - TICK * (1. - 1. / CEDES_PER_TICK);
1326		1570
1327	# support function for map-world.ext	1571	# support function for map-world.ext
1328	void _quantise (SV *data_sv, SV *plt_sv)	1572	void _quantise (SV *data_sv, SV *plt_sv)
1329	CODE:	1573	CODE:
1330	{	1574	{
…		…
1364	}	1608	}
1365		1609
1366	SvCUR_set (data_sv, dst - SvPVX (data_sv));	1610	SvCUR_set (data_sv, dst - SvPVX (data_sv));
1367	}	1611	}
1368		1612
		1613	void init_anim ()
		1614
		1615	void init_globals ()
		1616
		1617	void init_experience ()
		1618
		1619	void init_attackmess ()
		1620
		1621	void init_dynamic ()
		1622
		1623	void load_settings ()
		1624
		1625	void load_materials ()
		1626
		1627	void init_uuid ()
		1628	CODE:
		1629	UUID::init ();
		1630
		1631	void init_signals ()
		1632
		1633	void init_commands ()
		1634
		1635	void init_skills ()
		1636
		1637	void init_beforeplay ()
		1638
		1639	void evthread_start (int aiofd)
		1640
		1641	void cede_to_tick ()
		1642	CODE:
		1643	coroapi::cede_to_tick ();
		1644
		1645	NV till_tick ()
		1646	CODE:
		1647	RETVAL = SvNVX (sv_next_tick) - now ();
		1648	OUTPUT:
		1649	RETVAL
		1650
		1651	int tick_inhibit ()
		1652	CODE:
		1653	RETVAL = tick_inhibit;
		1654	OUTPUT:
		1655	RETVAL
		1656
		1657	void tick_inhibit_inc ()
		1658	CODE:
		1659	++tick_inhibit;
		1660
		1661	void tick_inhibit_dec ()
		1662	CODE:
		1663	if (!--tick_inhibit)
		1664	if (tick_pending)
		1665	{
		1666	ev_async_send (EV_DEFAULT, &tick_watcher);
		1667	coroapi::cede ();
		1668	}
		1669
		1670	void server_tick ()
		1671	CODE:
		1672	{
		1673	NOW = ev_now (EV_DEFAULT);
		1674	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1675	SvNV_set (sv_tick_start, NOW); SvNOK_only (sv_tick_start);
		1676	runtime = SvNVX (sv_runtime);
		1677
		1678	server_tick ();
		1679
		1680	NOW = ev_time ();
		1681	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1682	runtime += TICK;
		1683	SvNV_set (sv_runtime, runtime); SvNOK_only (sv_runtime);
		1684	}
		1685
1369	NV floor (NV x)	1686	NV floor (NV x)
1370		1687
1371	NV ceil (NV x)	1688	NV ceil (NV x)
1372		1689
1373	NV rndm (...)	1690	NV rndm (...)
		1691	ALIAS:
		1692	rmg_rndm = 1
1374	CODE:	1693	CODE:
		1694	{
		1695	rand_gen &gen = ix ? rmg_rndm : rndm;
1375	switch (items)	1696	switch (items)
1376	{	1697	{
1377	case 0: RETVAL = rndm (); break;	1698	case 0: RETVAL = gen (); break;
1378	case 1: RETVAL = rndm (SvUV (ST (0))); break;	1699	case 1: RETVAL = gen (SvUV (ST (0))); break;
1379	case 2: RETVAL = rndm (SvIV (ST (0)), SvIV (ST (1))); break;	1700	case 2: RETVAL = gen (SvIV (ST (0)), SvIV (ST (1))); break;
1380	default: croak ("cf::rndm requires none, one or two parameters."); break;	1701	default: croak ("cf::rndm requires none, one or two parameters."); break;
1381	}	1702	}
		1703	}
1382	OUTPUT:	1704	OUTPUT:
1383	RETVAL	1705	RETVAL
1384		1706
1385	void server_tick ()	1707	NV clamp (NV value, NV min_value, NV max_value)
1386	CODE:	1708	CODE:
1387	runtime = SvNVx (sv_runtime);	1709	RETVAL = clamp (value, min_value, max_value);
1388	server_tick ();	1710	OUTPUT:
		1711	RETVAL
1389		1712
		1713	NV lerp (NV value, NV min_in, NV max_in, NV min_out, NV max_out)
		1714	CODE:
		1715	RETVAL = lerp (value, min_in, max_in, min_out, max_out);
		1716	OUTPUT:
		1717	RETVAL
		1718
		1719	void weaken (...)
		1720	PROTOTYPE: @
		1721	CODE:
		1722	while (items > 0)
		1723	sv_rvweaken (ST (--items));
		1724
1390	void	1725	void
		1726	log_backtrace (utf8_string msg)
		1727
		1728	void
1391	LOG (int level, utf8_string msg)	1729	LOG (int flags, utf8_string msg)
1392	PROTOTYPE: $$	1730	PROTOTYPE: $$
1393	C_ARGS: (LogLevel)level, "%s", msg	1731	C_ARGS: flags, "%s", msg
1394		1732
1395	octet_string path_combine (octet_string base, octet_string path)	1733	octet_string path_combine (octet_string base, octet_string path)
1396	PROTOTYPE: $$	1734	PROTOTYPE: $$
1397		1735
1398	octet_string path_combine_and_normalize (octet_string base, octet_string path)	1736	octet_string path_combine_and_normalize (octet_string base, octet_string path)
1399	PROTOTYPE: $$	1737	PROTOTYPE: $$
1400
1401	const_octet_string
1402	get_maps_directory (octet_string path)
1403	PROTOTYPE: $
1404	ALIAS: maps_directory = 0
1405	CODE:
1406	RETVAL = create_pathname (path);
1407	OUTPUT: RETVAL
1408		1738
1409	void	1739	void
1410	sub_generation_inc ()	1740	sub_generation_inc ()
1411	CODE:	1741	CODE:
1412	PL_sub_generation++;	1742	PL_sub_generation++;
…		…
1435	}	1765	}
1436	OUTPUT: RETVAL	1766	OUTPUT: RETVAL
1437		1767
1438	void abort ()	1768	void abort ()
1439		1769
		1770	void reset_signals ()
		1771
1440	void fork_abort (octet_string cause = "cf::fork_abort")	1772	void fork_abort (const_octet_string cause = "cf::fork_abort")
1441		1773
1442	void cleanup (octet_string cause, bool make_core = false)	1774	void cleanup (const_octet_string cause, bool make_core = false)
1443		1775
1444	void emergency_save ()	1776	void emergency_save ()
1445		1777
1446	void _exit (int status = EXIT_SUCCESS)	1778	void _exit (int status = EXIT_SUCCESS)
1447		1779
1448	UV sv_2watcher (SV *w)
1449	CODE:
1450	RETVAL = (UV)GEventAPI->sv_2watcher (w);
1451	OUTPUT:
1452	RETVAL
1453
1454	#if _POSIX_MEMLOCK	1780	#if _POSIX_MEMLOCK
1455		1781
1456	int mlockall (int flags = MCL_CURRENT | MCL_FUTURE)	1782	int mlockall (int flags = MCL_CURRENT | MCL_FUTURE)
		1783	INIT:
		1784	#if __GLIBC__
		1785	mallopt (M_TOP_PAD, 1024 * 1024);
		1786	mallopt (M_MMAP_THRESHOLD, 1024 * 1024 * 128);
		1787	mallopt (M_MMAP_MAX, 0); // likely bug-workaround, also frees memory
		1788	mallopt (M_PERTURB, 0xee); // bug-workaround for linux glibc+mlockall+calloc
		1789	#endif
1457		1790
1458	int munlockall ()	1791	int munlockall ()
1459		1792
1460	#endif	1793	#endif
		1794
		1795	int
		1796	malloc_trim (IV pad = 0)
		1797
		1798	void
		1799	mallinfo ()
		1800	PPCODE:
		1801	{
		1802	#if __GLIBC__
		1803	struct mallinfo mai = mallinfo ();
		1804	EXTEND (SP, 10*2);
		1805	PUSHs (sv_2mortal (newSVpv ("arena" , 0))); PUSHs (sv_2mortal (newSViv (mai.arena)));
		1806	PUSHs (sv_2mortal (newSVpv ("ordblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.ordblks)));
		1807	PUSHs (sv_2mortal (newSVpv ("smblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.smblks)));
		1808	PUSHs (sv_2mortal (newSVpv ("hblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblks)));
		1809	PUSHs (sv_2mortal (newSVpv ("hblkhd" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblkhd)));
		1810	PUSHs (sv_2mortal (newSVpv ("usmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.usmblks)));
		1811	PUSHs (sv_2mortal (newSVpv ("fsmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.fsmblks)));
		1812	PUSHs (sv_2mortal (newSVpv ("uordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.uordblks)));
		1813	PUSHs (sv_2mortal (newSVpv ("fordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.fordblks)));
		1814	PUSHs (sv_2mortal (newSVpv ("keepcost", 0))); PUSHs (sv_2mortal (newSViv (mai.keepcost)));
		1815	#endif
		1816	EXTEND (SP, 5*2);
		1817	PUSHs (sv_2mortal (newSVpv ("slice_alloc", 0))); PUSHs (sv_2mortal (newSVuv (slice_alloc)));
		1818	PUSHs (sv_2mortal (newSVpv ("shstr_alloc", 0))); PUSHs (sv_2mortal (newSVuv (shstr_alloc)));
		1819	PUSHs (sv_2mortal (newSVpv ("objects" , 0))); PUSHs (sv_2mortal (newSVuv (objects.size () * sizeof (object))));
		1820	PUSHs (sv_2mortal (newSVpv ("sv_count" , 0))); PUSHs (sv_2mortal (newSVuv (PL_sv_count)));
		1821	PUSHs (sv_2mortal (newSVpv ("sv_objcount", 0))); PUSHs (sv_2mortal (newSVuv (PL_sv_objcount)));
		1822	}
1461		1823
1462	int find_animation (utf8_string text)	1824	int find_animation (utf8_string text)
1463	PROTOTYPE: $	1825	PROTOTYPE: $
1464		1826
1465	int random_roll (int min, int max, object *op, int goodbad);	1827	int random_roll (int min, int max, object *op, int goodbad);
…		…
1503	RETVAL = newSVpv (resist_plus[atnr], 0);	1865	RETVAL = newSVpv (resist_plus[atnr], 0);
1504	else	1866	else
1505	XSRETURN_UNDEF;	1867	XSRETURN_UNDEF;
1506	OUTPUT: RETVAL	1868	OUTPUT: RETVAL
1507		1869
		1870	UUID
		1871	uuid_cur ()
		1872	CODE:
		1873	RETVAL = UUID::cur;
		1874	OUTPUT:
		1875	RETVAL
		1876
		1877	UUID
		1878	uuid_gen ()
		1879	CODE:
		1880	RETVAL = UUID::gen ();
		1881	OUTPUT:
		1882	RETVAL
		1883
		1884	val64
		1885	uuid_seq (UUID uuid)
		1886	CODE:
		1887	RETVAL = uuid.seq;
		1888	OUTPUT:
		1889	RETVAL
		1890
		1891	UUID
		1892	uuid_str (val64 seq)
		1893	CODE:
		1894	RETVAL.seq = seq;
		1895	OUTPUT:
		1896	RETVAL
		1897
		1898	void
		1899	coin_names ()
		1900	PPCODE:
		1901	EXTEND (SP, NUM_COINS);
		1902	for (int i = 0; i < NUM_COINS; ++i)
		1903	PUSHs (sv_2mortal (newSVpv (coins [i], 0)));
		1904
		1905	void
		1906	coin_archetypes ()
		1907	PPCODE:
		1908	EXTEND (SP, NUM_COINS);
		1909	for (int i = 0; i < NUM_COINS; ++i)
		1910	PUSHs (sv_2mortal (to_sv (archetype::find (coins [i]))));
		1911
1508	bool	1912	bool
1509	load_resource_file (octet_string filename)	1913	load_resource_file_ (octet_string filename)
		1914
		1915	void
		1916	fix_weight ()
1510		1917
1511	MODULE = cf PACKAGE = cf::attachable	1918	MODULE = cf PACKAGE = cf::attachable
1512		1919
1513	int	1920	int
1514	valid (SV *obj)	1921	valid (SV *obj)
…		…
1532	#object *mortals (U32 index)	1939	#object *mortals (U32 index)
1533	# CODE:	1940	# CODE:
1534	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;	1941	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;
1535	# OUTPUT: RETVAL	1942	# OUTPUT: RETVAL
1536		1943
1537	INCLUDE: $PERL $srcdir/genacc attachable ../include/cfperl.h |	1944	INCLUDE: $PERL $srcdir/genacc attachable ../include/util.h ../include/cfperl.h |
1538		1945
1539	MODULE = cf PACKAGE = cf::global	1946	MODULE = cf PACKAGE = cf::global
1540		1947
1541	int invoke (SV *klass, int event, ...)	1948	int invoke (SV *klass, int event, ...)
1542	CODE:	1949	CODE:
…		…
1578	object *actives (U32 index)	1985	object *actives (U32 index)
1579	CODE:	1986	CODE:
1580	RETVAL = index < actives.size () ? actives [index] : 0;	1987	RETVAL = index < actives.size () ? actives [index] : 0;
1581	OUTPUT: RETVAL	1988	OUTPUT: RETVAL
1582		1989
		1990	int mortals_size ()
		1991	CODE:
		1992	RETVAL = attachable::mortals.size ();
		1993	OUTPUT: RETVAL
		1994
		1995	const char *slot_use_name (U32 slot)
		1996	ALIAS:
		1997	slot_nonuse_name = 1
		1998	CODE:
		1999	{
		2000	if (slot >= NUM_BODY_LOCATIONS)
		2001	croak ("body slot index out of range");
		2002
		2003	switch (ix)
		2004	{
		2005	case 0: RETVAL = body_locations[slot].use_name; break;
		2006	case 1: RETVAL = body_locations[slot].nonuse_name; break;
		2007	}
		2008	}
		2009	OUTPUT:
		2010	RETVAL
		2011
1583	# missing properties	2012	# missing properties
1584		2013
1585	object *head (object *op)	2014	object *head (object *op)
1586	PROTOTYPE: $	2015	PROTOTYPE: $
1587	CODE:	2016	CODE:
1588	RETVAL = op->head_ ();	2017	RETVAL = op->head_ ();
1589	OUTPUT: RETVAL
1590
1591	int is_head (object *op)
1592	PROTOTYPE: $
1593	CODE:
1594	RETVAL = op->head_ () == op;
1595	OUTPUT: RETVAL	2018	OUTPUT: RETVAL
1596		2019
1597	void	2020	void
1598	inv (object *obj)	2021	inv (object *obj)
1599	PROTOTYPE: $	2022	PROTOTYPE: $
1600	PPCODE:	2023	PPCODE:
1601	{	2024	{
1602	object *o;
1603	for (o = obj->inv; o; o = o->below)	2025	for (object *o = obj->inv; o; o = o->below)
1604	XPUSHs (sv_2mortal (to_sv (o)));	2026	XPUSHs (sv_2mortal (to_sv (o)));
1605	}	2027	}
1606		2028
1607	void	2029	void
1608	set_animation (object *op, int idx)	2030	set_animation (object *op, int idx)
…		…
1613	num_animations (object *op)	2035	num_animations (object *op)
1614	CODE:	2036	CODE:
1615	RETVAL = NUM_ANIMATIONS (op);	2037	RETVAL = NUM_ANIMATIONS (op);
1616	OUTPUT: RETVAL	2038	OUTPUT: RETVAL
1617		2039
		2040	int slot_info (object *op, UV slot, int value = 0)
		2041	ALIAS:
		2042	slot_used = 1
		2043	CODE:
		2044	{
		2045	if (slot >= NUM_BODY_LOCATIONS)
		2046	croak ("body slot index out of range");
		2047
		2048	RETVAL = ix ? op->slot[slot].used : op->slot[slot].info;
		2049
		2050	if (items > 2)
		2051	if (ix)
		2052	op->slot[slot].used = value;
		2053	else
		2054	op->slot[slot].info = value;
		2055	}
		2056	OUTPUT:
		2057	RETVAL
		2058
1618	object *find_best_object_match (object *op, utf8_string match)	2059	object *find_best_object_match (object *op, utf8_string match)
1619		2060
1620	object *find_marked_object (object *op)	2061	object *find_marked_object (object *op)
1621		2062
1622	int need_identify (object *obj);	2063	int need_identify (object *obj);
1623		2064
1624	int apply_shop_mat (object *shop_mat, object *op);	2065	int apply_shop_mat (object *shop_mat, object *op);
1625
1626	int move_player (object *op, int dir)
1627	CODE:
1628	RETVAL = move_player (op, dir);
1629	OUTPUT:
1630	RETVAL
1631		2066
1632	int move (object *op, int dir, object *originator = op)	2067	int move (object *op, int dir, object *originator = op)
1633	CODE:	2068	CODE:
1634	RETVAL = move_ob (op, dir, originator);	2069	RETVAL = move_ob (op, dir, originator);
1635	OUTPUT:	2070	OUTPUT:
…		…
1643	CODE:	2078	CODE:
1644	player_apply_below (op);	2079	player_apply_below (op);
1645		2080
1646	int cast_heal (object *op, object *caster, object *spell, int dir = 0)	2081	int cast_heal (object *op, object *caster, object *spell, int dir = 0)
1647		2082
1648	object *cf_object_present_archname_inside (object *op, utf8_string whatstr)
1649
1650	int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)
1651
1652	int cf_object_change_map (object *op, int x, int y, maptile *map)
1653
1654	#//TODO
1655	object *clone_ (object *op, int recursive = 0)
1656	CODE:
1657	if (recursive)
1658	RETVAL = object_create_clone (op);
1659	else
1660	{
1661	RETVAL = object::create ();
1662	op->copy_to (RETVAL);
1663	}
1664	OUTPUT: RETVAL
1665
1666	int pay_item (object *op, object *buyer)	2083	int pay_item (object *op, object *buyer)
1667	CODE:	2084	CODE:
1668	RETVAL = pay_for_item (op, buyer);	2085	RETVAL = pay_for_item (op, buyer);
1669	OUTPUT: RETVAL	2086	OUTPUT: RETVAL
1670		2087
…		…
1704		2121
1705	void drop (object *who, object *op)	2122	void drop (object *who, object *op)
1706		2123
1707	void pick_up (object *who, object *op)	2124	void pick_up (object *who, object *op)
1708		2125
1709	int cf_object_teleport (object *op, maptile *map, int x, int y)
1710
1711	void update_object (object *op, int action)	2126	void update_object (object *op, int action)
1712		2127
1713	object *cf_create_object_by_name (utf8_string name)
1714
1715	void change_exp (object *op, uint64 exp, utf8_string skill_name = 0, int flag = 0)	2128	void change_exp (object *op, uint64 exp, utf8_string skill_name = 0, int flag = 0)
1716		2129
1717	void player_lvl_adj (object *who, object *skill = 0)	2130	void player_lvl_adj (object *who, object *skill = 0)
1718		2131
1719	int kill_object (object *op, int dam = 0, object *hitter = 0, int type = AT_PHYSICAL)	2132	int kill_object (object *op, int dam = 0, object *hitter = 0, int type = AT_PHYSICAL)
…		…
1726		2139
1727	void add_button_link (object *button, maptile *map, int connected);	2140	void add_button_link (object *button, maptile *map, int connected);
1728		2141
1729	void remove_button_link (object *op);	2142	void remove_button_link (object *op);
1730		2143
		2144	void handle_apply_yield (object *op);
		2145
1731		2146
1732	MODULE = cf PACKAGE = cf::object PREFIX = cf_	2147	MODULE = cf PACKAGE = cf::object PREFIX = cf_
1733
1734	object *cf_insert_ob_in_ob (object *ob, object *where)
1735		2148
1736	# no clean way to get an object from an archetype - stupid idiotic	2149	# no clean way to get an object from an archetype - stupid idiotic
1737	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.	2150	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.
1738		2151
1739	object *new (utf8_string archetype = 0)	2152	object *new (utf8_string archetype = 0)
1740	PROTOTYPE: ;$	2153	PROTOTYPE: ;$
1741	CODE:	2154	CODE:
1742	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();	2155	RETVAL = archetype ? get_archetype (archetype) : object::create ();
1743	OUTPUT:	2156	OUTPUT:
1744	RETVAL	2157	RETVAL
1745		2158
		2159	object *find_object (U32 tag)
		2160
		2161	# TODO: nuke
1746	object *insert_ob_in_map_at (object *ob, maptile *where, object_ornull *orig, int flag, int x, int y)	2162	object *insert_ob_in_map_at (object *ob, maptile *where, object_ornull *orig, int flag, int x, int y)
1747	PROTOTYPE: $$$$$$	2163	PROTOTYPE: $$$$$$
1748	CODE:	2164	CODE:
1749	{	2165	{
1750	int unused_type;	2166	RETVAL = insert_ob_in_map_at (ob, where, orig, flag, x, y);
1751	RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);
1752	}	2167	}
1753		2168
1754	player *contr (object *op)	2169	shstr
1755	CODE:	2170	object::kv_get (shstr key)
1756	RETVAL = op->contr;
1757	OUTPUT: RETVAL
1758		2171
1759	const_utf8_string get_ob_key_value (object *op, utf8_string key)	2172	void
		2173	object::kv_del (shstr key)
1760		2174
1761	bool set_ob_key_value (object *op, utf8_string key, utf8_string value = 0, int add_key = 1)	2175	void
		2176	object::kv_set (shstr key, shstr value)
1762		2177
1763	object *get_nearest_player (object *ob)	2178	object *get_nearest_player (object *ob)
1764	ALIAS: nearest_player = 0	2179	ALIAS: nearest_player = 0
1765	PREINIT:	2180	PREINIT:
1766	extern object *get_nearest_player (object *);	2181	extern object *get_nearest_player (object *);
…		…
1768	void rangevector (object *ob, object *other, int flags = 0)	2183	void rangevector (object *ob, object *other, int flags = 0)
1769	PROTOTYPE: $$;$	2184	PROTOTYPE: $$;$
1770	PPCODE:	2185	PPCODE:
1771	{	2186	{
1772	rv_vector rv;	2187	rv_vector rv;
		2188
		2189	PUTBACK;
1773	get_rangevector (ob, other, &rv, flags);	2190	get_rangevector (ob, other, &rv, flags);
		2191	SPAGAIN;
		2192
1774	EXTEND (SP, 5);	2193	EXTEND (SP, 5);
1775	PUSHs (newSVuv (rv.distance));	2194	PUSHs (newSVuv (rv.distance));
1776	PUSHs (newSViv (rv.distance_x));	2195	PUSHs (newSViv (rv.distance_x));
1777	PUSHs (newSViv (rv.distance_y));	2196	PUSHs (newSViv (rv.distance_y));
1778	PUSHs (newSViv (rv.direction));	2197	PUSHs (newSViv (rv.direction));
1779	PUSHs (newSVcfapi (CFAPI_POBJECT, rv.part));	2198	PUSHs (to_sv (rv.part));
1780	}	2199	}
1781		2200
1782	bool on_same_map_as (object *ob, object *other)	2201	bool on_same_map_as (object *ob, object *other)
1783	CODE:	2202	CODE:
1784	RETVAL = on_same_map (ob, other);	2203	RETVAL = on_same_map (ob, other);
…		…
1788	base_name (object *op, int plural = op->nrof > 1)	2207	base_name (object *op, int plural = op->nrof > 1)
1789	CODE:	2208	CODE:
1790	RETVAL = query_base_name (op, plural);	2209	RETVAL = query_base_name (op, plural);
1791	OUTPUT: RETVAL	2210	OUTPUT: RETVAL
1792		2211
1793	object *decrease_ob_nr (object *op, unsigned long i)	2212	# return the tail of an object, excluding itself
		2213	void
		2214	tail (object *op)
		2215	PPCODE:
		2216	while ((op = op->more))
		2217	XPUSHs (sv_2mortal (to_sv (op)));
1794		2218
1795	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_	2219	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_
1796		2220
1797	player *player (object *op)	2221	player *player (object *op)
1798	CODE:	2222	CODE:
1799	RETVAL = op->contr;	2223	RETVAL = op->contr;
1800	OUTPUT: RETVAL	2224	OUTPUT: RETVAL
1801		2225
		2226	bool move_player (object *op, int dir)
		2227
1802	void check_score (object *op)	2228	void check_score (object *op)
1803		2229
1804	void message (object *op, utf8_string txt, int flags = NDI_ORANGE | NDI_UNIQUE)	2230	void message (object *op, utf8_string txt, int flags = NDI_ORANGE | NDI_UNIQUE)
1805	CODE:	2231	CODE:
1806	new_draw_info (flags, 0, op, txt);	2232	new_draw_info (flags, 0, op, txt);
1807		2233
1808	object *cf_player_send_inventory (object *op)
1809
1810	octet_string cf_player_get_ip (object *op)
1811	ALIAS: ip = 0
1812
1813	object *cf_player_get_marked_item (object *op)
1814	ALIAS: marked_item = 0
1815
1816	void cf_player_set_marked_item (object *op, object *ob)
1817
1818	partylist *cf_player_get_party (object *op)
1819	ALIAS: party = 0
1820
1821	void cf_player_set_party (object *op, partylist *party)
1822
1823	void kill_player (object *op)	2234	void kill_player (object *op)
1824		2235
		2236	void esrv_send_item (object *pl, object *item)
		2237
1825	void esrv_update_item (object *op, int what, object *item)	2238	void esrv_update_item (object *pl, int what, object *item)
1826	C_ARGS: what, op, item	2239	C_ARGS: what, pl, item
1827		2240
1828	void clear_los (object *op)	2241	void esrv_del_item (object *pl, int tag)
		2242	C_ARGS: pl->contr, tag
1829		2243
1830	int command_summon (object *op, utf8_string params)	2244	int command_summon (object *op, utf8_string params)
1831		2245
1832	int command_arrest (object *op, utf8_string params)	2246	int command_arrest (object *op, utf8_string params)
1833		2247
…		…
1852	pl->ob->stats.hp = pl->ob->stats.maxhp;	2266	pl->ob->stats.hp = pl->ob->stats.maxhp;
1853	pl->ob->stats.sp = pl->ob->stats.maxsp;	2267	pl->ob->stats.sp = pl->ob->stats.maxsp;
1854	pl->ob->stats.grace = pl->ob->stats.maxgrace;	2268	pl->ob->stats.grace = pl->ob->stats.maxgrace;
1855	pl->orig_stats = pl->ob->stats;	2269	pl->orig_stats = pl->ob->stats;
1856		2270
1857	void cf_player_move (player *pl, int dir)	2271	# should only be temporary
		2272	void esrv_new_player (player *pl)
1858		2273
1859	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);	2274	#d# TODO: replace by blocked_los accessor, fix code using this
1860
1861	bool	2275	bool
1862	cell_visible (player *pl, int dx, int dy)	2276	cell_visible (player *pl, int dx, int dy)
1863	CODE:	2277	CODE:
1864	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2	2278	RETVAL = pl->blocked_los (dx, dy) != LOS_BLOCKED;
1865	&& !pl->blocked_los [dx + pl->ns->mapx / 2][dy + pl->ns->mapy / 2];
1866	OUTPUT:	2279	OUTPUT:
1867	RETVAL	2280	RETVAL
1868		2281
1869	void	2282	void
1870	send (player *pl, SV *packet)	2283	send (player *pl, SV *packet)
1871	CODE:	2284	CODE:
1872	{	2285	{
1873	STRLEN len;	2286	STRLEN len;
1874	char *buf = SvPVbyte (packet, len);	2287	char *buf = SvPVbyte (packet, len);
1875		2288
		2289	if (len > MAXSOCKBUF)
		2290	pl->failmsg ("[packet too long for client]");
1876	if (pl->ns)	2291	else if (pl->ns)
1877	pl->ns->send_packet (buf, len);	2292	pl->ns->send_packet (buf, len);
1878	}	2293	}
1879
1880	int
1881	listening (player *pl, int new_value = -1)
1882	CODE:
1883	RETVAL = pl->listening;
1884	if (new_value >= 0)
1885	pl->listening = new_value;
1886	OUTPUT:
1887	RETVAL
1888		2294
1889	void savebed (player *pl, SV *map_path = 0, SV *x = 0, SV *y = 0)	2295	void savebed (player *pl, SV *map_path = 0, SV *x = 0, SV *y = 0)
1890	PROTOTYPE: $;$$$	2296	PROTOTYPE: $;$$$
1891	PPCODE:	2297	PPCODE:
1892	if (GIMME_V != G_VOID)	2298	if (GIMME_V != G_VOID)
…		…
1917	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);	2323	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);
1918	OUTPUT: RETVAL	2324	OUTPUT: RETVAL
1919		2325
1920	SV *registry (maptile *map)	2326	SV *registry (maptile *map)
1921		2327
		2328	void
		2329	find_tagged_objects (maptile *map, utf8_string tag = 0)
		2330	PPCODE:
		2331	{
		2332	if (!map->spaces)
		2333	XSRETURN_EMPTY;
		2334
		2335	if (tag)
		2336	{
		2337	shstr_cmp tag_ (tag);
		2338
		2339	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2340	for (object *op = ms->bot; op; op = op->above)
		2341	if (op->tag == tag_)
		2342	XPUSHs (sv_2mortal (to_sv (op)));
		2343	}
		2344	else
		2345	{
		2346	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2347	for (object *op = ms->bot; op; op = op->above)
		2348	if (op->tag)
		2349	XPUSHs (sv_2mortal (to_sv (op)));
		2350	}
		2351	}
		2352
1922	INCLUDE: $PERL $srcdir/genacc maptile ../include/map.h |	2353	INCLUDE: $PERL $srcdir/genacc maptile ../include/map.h |
		2354
		2355	void
		2356	adjust_daylight ()
		2357	CODE:
		2358	maptile::adjust_daylight ();
1923		2359
1924	void	2360	void
1925	maptile::instantiate ()	2361	maptile::instantiate ()
1926		2362
1927	maptile *new ()	2363	maptile *new ()
…		…
1970	if (SV **elem = av_fetch ((AV *)palette, idx [offs], 0))	2406	if (SV **elem = av_fetch ((AV *)palette, idx [offs], 0))
1971	{	2407	{
1972	object *ob = get_archetype (SvPVutf8_nolen (*elem));	2408	object *ob = get_archetype (SvPVutf8_nolen (*elem));
1973	ob->flag [FLAG_NO_MAP_SAVE] = true;	2409	ob->flag [FLAG_NO_MAP_SAVE] = true;
1974	THIS->insert (ob, x, y, 0, INS_ABOVE_FLOOR_ONLY);	2410	THIS->insert (ob, x, y, 0, INS_ABOVE_FLOOR_ONLY);
		2411
		2412	if (ob->randomitems)
		2413	{
		2414	if (!ob->above)
		2415	{
		2416	ob->create_treasure (ob->randomitems);
		2417
		2418	for (object *op = ob->above; op; op = op->above)
		2419	op->flag [FLAG_NO_MAP_SAVE] = true;
		2420	}
		2421
		2422	ob->randomitems = 0;
		2423	}
1975	}	2424	}
1976	}	2425	}
1977	}	2426	}
1978		2427
1979	skip_space: ;	2428	skip_space: ;
…		…
1990	palette = SvRV (palette);	2439	palette = SvRV (palette);
1991		2440
1992	STRLEN idxlen;	2441	STRLEN idxlen;
1993	const uint8_t *idx = (const uint8_t *)SvPVbyte (data, idxlen);	2442	const uint8_t *idx = (const uint8_t *)SvPVbyte (data, idxlen);
1994		2443
1995	region **regionmap = (region **)malloc (	2444	region_ptr *regionmap = new region_ptr [av_len ((AV *)palette) + 1];
1996	(av_len ((AV *)palette) + 1) * sizeof (region *));
1997	uint8_t *regions = salloc<uint8_t> (THIS->size ());	2445	uint8_t *regions = salloc<uint8_t> (THIS->size ());
1998		2446
1999	for (int i = av_len ((AV *)palette) + 1; i--; )	2447	for (int i = av_len ((AV *)palette) + 1; i--; )
2000	regionmap [i] = region::find (	2448	regionmap [i] = region::find (SvPVutf8_nolen (*av_fetch ((AV *)palette, i, 1)));
2001	SvPVutf8_nolen (*av_fetch ((AV *)palette, i, 1)));
2002		2449
2003	for (int y = 0; y < THIS->height; ++y)	2450	for (int y = 0; y < THIS->height; ++y)
2004	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);	2451	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);
2005		2452
2006	sfree (THIS->regions, THIS->size ());	2453	sfree (THIS->regions, THIS->size ());
2007	free (THIS->regionmap);	2454	delete [] THIS->regionmap;
2008		2455
2009	THIS->regions = regions;	2456	THIS->regions = regions;
2010	THIS->regionmap = regionmap;	2457	THIS->regionmap = regionmap;
2011	}	2458	}
2012		2459
2013	void	2460	void
2014	maptile::create_region_treasure ()	2461	maptile::create_region_treasure ()
2015	CODE:	2462	CODE:
2016	{
2017	object *op = object::create ();
2018	op->type = FLOOR;
2019	op->map = THIS;
2020
2021	for (int x = 0; x < THIS->width; ++x)	2463	for (int x = 0; x < THIS->width; ++x)
2022	for (int y = 0; y < THIS->height; ++y)	2464	for (int y = 0; y < THIS->height; ++y)
2023	{	2465	{
2024	region *rgn = THIS->region (x, y);	2466	region *rgn = THIS->region (x, y);
2025		2467
2026	//fprintf (stderr, "%d,%d %f %p\n", x, y, rgn->treasure_density,rgn->treasure);//D	2468	//fprintf (stderr, "%d,%d %f %p\n", x, y, rgn->treasure_density,rgn->treasure);//D
		2469	if (object *op = THIS->at (x, y).top)
2027	if (rgn->treasure && rndm () < rgn->treasure_density)	2470	if (rgn->treasure && rndm () < rgn->treasure_density)
2028	{
2029	op->x = x;
2030	op->y = y;
2031	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);	2471	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);
2032	}
2033	}	2472	}
2034
2035	op->destroy ();
2036	}
2037
2038	void play_sound_map (maptile *map, int x, int y, int sound_num)
2039		2473
2040	int out_of_map (maptile *map, int x, int y)	2474	int out_of_map (maptile *map, int x, int y)
2041		2475
2042	void	2476	void
2043	trigger (maptile *map, long connection, bool state = true)	2477	trigger (maptile *map, long connection, bool state = true)
…		…
2048	get_connection (maptile *map, long connection)	2482	get_connection (maptile *map, long connection)
2049	PPCODE:	2483	PPCODE:
2050	oblinkpt *obp = get_connection_links (map, connection);	2484	oblinkpt *obp = get_connection_links (map, connection);
2051	if (obp)	2485	if (obp)
2052	for (objectlink *ol = obp->link; ol; ol = ol->next)	2486	for (objectlink *ol = obp->link; ol; ol = ol->next)
2053	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, (object *)ol->ob)));	2487	XPUSHs (sv_2mortal (to_sv ((object *)ol->ob)));
2054
2055	object *cf_map_insert_object_there (maptile *where, object *op, object *originator, int flags)
2056
2057	object *cf_map_insert_object (maptile *where, object* op, int x, int y)
2058
2059	object* cf_map_present_arch_by_name (maptile *map, const char* str, int nx, int ny)
2060	C_ARGS: str, map, nx, ny
2061		2488
2062	void	2489	void
2063	get_map_flags (maptile *map, int x, int y)	2490	get_map_flags (maptile *map, int x, int y)
2064	PPCODE:	2491	PPCODE:
2065	{	2492	{
2066	maptile *nmap = 0;	2493	maptile *nmap = 0;
2067	I16 nx = 0, ny = 0;	2494	I16 nx = 0, ny = 0;
		2495
		2496	PUTBACK;
2068	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);	2497	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
		2498	SPAGAIN;
2069		2499
2070	EXTEND (SP, 4);	2500	EXTEND (SP, 4);
2071	PUSHs (sv_2mortal (newSViv (flags)));	2501	PUSHs (sv_2mortal (newSViv (flags)));
2072		2502
2073	if (GIMME_V == G_ARRAY)	2503	if (GIMME_V == G_ARRAY)
2074	{	2504	{
2075	PUSHs (sv_2mortal (newSVcfapi (CFAPI_PMAP, nmap)));	2505	PUSHs (sv_2mortal (to_sv (nmap)));
2076	PUSHs (sv_2mortal (newSViv (nx)));	2506	PUSHs (sv_2mortal (newSViv (nx)));
2077	PUSHs (sv_2mortal (newSViv (ny)));	2507	PUSHs (sv_2mortal (newSViv (ny)));
2078	}	2508	}
2079	}	2509	}
2080		2510
		2511	mapspace *
		2512	ms (maptile *map, unsigned int x, unsigned int y)
		2513	PROTOTYPE: $$$
		2514	CODE:
		2515	{
		2516	maptile *nmap = 0;
		2517	I16 nx, ny;
		2518
		2519	PUTBACK;
		2520	get_map_flags (map, &nmap, x, y, &nx, &ny);
		2521	SPAGAIN;
		2522
		2523	if (!nmap)
		2524	XSRETURN_UNDEF;
		2525
		2526	RETVAL = &nmap->at (nx, ny);
		2527	}
		2528	OUTPUT:
		2529	RETVAL
		2530
2081	void	2531	void
2082	at (maptile *map, unsigned int x, unsigned int y)	2532	at (maptile *map, unsigned int x, unsigned int y)
2083	PROTOTYPE: $$$	2533	PROTOTYPE: $$$
2084	PPCODE:	2534	PPCODE:
2085	{	2535	{
2086	object *o;
2087	maptile *nmap = 0;	2536	maptile *nmap = 0;
2088	I16 nx, ny;	2537	I16 nx, ny;
2089		2538
		2539	PUTBACK;
2090	get_map_flags (map, &nmap, x, y, &nx, &ny);	2540	get_map_flags (map, &nmap, x, y, &nx, &ny);
		2541	SPAGAIN;
2091		2542
2092	if (nmap)	2543	if (nmap)
2093	for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)	2544	for (object *o = nmap->at (nx, ny).bot; o; o = o->above)
2094	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));	2545	XPUSHs (sv_2mortal (to_sv (o)));
2095	}	2546	}
2096		2547
2097	SV *	2548	SV *
2098	bot_at (maptile *obj, unsigned int x, unsigned int y)	2549	bot_at (maptile *map, unsigned int x, unsigned int y)
2099	PROTOTYPE: $$$	2550	PROTOTYPE: $$$
2100	ALIAS:	2551	ALIAS:
2101	top_at = 1	2552	top_at = 1
2102	flags_at = 2	2553	flags_at = 2
2103	light_at = 3	2554	light_at = 3
2104	move_block_at = 4	2555	move_block_at = 4
2105	move_slow_at = 5	2556	move_slow_at = 5
2106	move_on_at = 6	2557	move_on_at = 6
2107	move_off_at = 7	2558	move_off_at = 7
2108	INIT:
2109	if (x >= obj->width || y >= obj->height) XSRETURN_UNDEF;
2110	CODE:	2559	CODE:
		2560	{
		2561	sint16 nx = x;
		2562	sint16 ny = y;
		2563
		2564	if (!xy_normalise (map, nx, ny))
		2565	XSRETURN_UNDEF;
		2566
		2567	mapspace &ms = map->at (nx, ny);
		2568
		2569	ms.update ();
		2570
2111	switch (ix)	2571	switch (ix)
2112	{	2572	{
2113	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;	2573	case 0: RETVAL = to_sv (ms.bot ); break;
2114	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;	2574	case 1: RETVAL = to_sv (ms.top ); break;
2115	case 2: RETVAL = newSVuv ( GET_MAP_FLAGS (obj, x, y)); break;	2575	case 2: RETVAL = newSVuv (ms.flags_ ); break;
2116	case 3: RETVAL = newSViv ( GET_MAP_LIGHT (obj, x, y)); break;	2576	case 3: RETVAL = newSViv (ms.light ); break;
2117	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;	2577	case 4: RETVAL = newSVuv (ms.move_block); break;
2118	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;	2578	case 5: RETVAL = newSVuv (ms.move_slow ); break;
2119	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;	2579	case 6: RETVAL = newSVuv (ms.move_on ); break;
2120	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;	2580	case 7: RETVAL = newSVuv (ms.move_off ); break;
2121	}	2581	}
		2582	}
2122	OUTPUT: RETVAL	2583	OUTPUT: RETVAL
2123		2584
2124	void fix_walls (maptile *map, int x, int y)	2585	void fix_walls (maptile *map, int x, int y)
2125		2586
2126	void fix_walls_around (maptile *map, int x, int y)	2587	void fix_walls_around (maptile *map, int x, int y)
…		…
2199	rmp.decoroptions = decoroptions;	2660	rmp.decoroptions = decoroptions;
2200	rmp.orientation = orientation;	2661	rmp.orientation = orientation;
2201	rmp.origin_y = origin_y;	2662	rmp.origin_y = origin_y;
2202	rmp.origin_x = origin_x;	2663	rmp.origin_x = origin_x;
2203	rmp.random_seed = random_seed;	2664	rmp.random_seed = random_seed;
2204	rmp.total_map_hp = total_map_hp;	2665	rmp.total_map_hp = (uint64_t) total_map_hp;
2205	rmp.map_layout_style = map_layout_style;	2666	rmp.map_layout_style = map_layout_style;
2206	rmp.treasureoptions = treasureoptions;	2667	rmp.treasureoptions = treasureoptions;
2207	rmp.symmetry_used = symmetry_used;	2668	rmp.symmetry_used = symmetry_used;
2208	rmp.region = region;	2669	rmp.region = region;
2209	rmp.custom = custom;	2670	rmp.custom = custom;
…		…
2211	RETVAL = self->generate_random_map (&rmp);	2672	RETVAL = self->generate_random_map (&rmp);
2212	}	2673	}
2213	OUTPUT:	2674	OUTPUT:
2214	RETVAL	2675	RETVAL
2215		2676
		2677	MODULE = cf PACKAGE = cf::mapspace
		2678
		2679	INCLUDE: $PERL $srcdir/genacc mapspace ../include/map.h |
		2680
2216	MODULE = cf PACKAGE = cf::arch	2681	MODULE = cf PACKAGE = cf::arch
2217		2682
2218	archetype *find (utf8_string name)	2683	int archetypes_size ()
2219	CODE:	2684	CODE:
2220	RETVAL = archetype::find (name);	2685	RETVAL = archetypes.size ();
2221	OUTPUT:	2686	OUTPUT: RETVAL
2222	RETVAL
2223		2687
2224	archetype *first()	2688	archetype *archetypes (U32 index)
2225	PROTOTYPE:	2689	CODE:
2226	CODE:	2690	RETVAL = index < archetypes.size () ? archetypes [index] : 0;
2227	RETVAL = first_archetype;	2691	OUTPUT: RETVAL
		2692
		2693	object *instantiate (archetype *arch)
		2694	CODE:
		2695	RETVAL = arch_to_object (arch);
		2696	OUTPUT:
2228	OUTPUT: RETVAL	2697	RETVAL
2229		2698
2230	INCLUDE: $PERL $srcdir/genacc archetype ../include/object.h |	2699	INCLUDE: $PERL $srcdir/genacc archetype ../include/object.h |
2231		2700
2232	MODULE = cf PACKAGE = cf::party	2701	MODULE = cf PACKAGE = cf::party
2233		2702
…		…
2251	PROTOTYPE: $	2720	PROTOTYPE: $
2252	CODE:	2721	CODE:
2253	RETVAL = region::find (name);	2722	RETVAL = region::find (name);
2254	OUTPUT: RETVAL	2723	OUTPUT: RETVAL
2255		2724
2256	region *find_fuzzy (utf8_string name)
2257	PROTOTYPE: $
2258	CODE:
2259	RETVAL = region::find_fuzzy (name);
2260	OUTPUT: RETVAL
2261
2262	int specificity (region *rgn)	2725	int specificity (region *rgn)
2263	CODE:	2726	CODE:
2264	RETVAL = 0;	2727	RETVAL = 0;
2265	while (rgn = rgn->parent)	2728	while (rgn = rgn->parent)
2266	RETVAL++;	2729	RETVAL++;
…		…
2302	CODE:	2765	CODE:
2303	{	2766	{
2304	STRLEN len;	2767	STRLEN len;
2305	char *buf = SvPVbyte (packet, len);	2768	char *buf = SvPVbyte (packet, len);
2306		2769
		2770	if (len > MAXSOCKBUF)
		2771	{
		2772	// ugly
		2773	if (THIS->pl)
		2774	THIS->pl->failmsg ("[packet too long for client]");
		2775	}
		2776	else
2307	THIS->send_packet (buf, len);	2777	THIS->send_packet (buf, len);
2308	}	2778	}
		2779
		2780	faceidx
		2781	client::need_face (utf8_string name, int pri = 0)
		2782	CODE:
		2783	RETVAL = face_find (name, 0);
		2784	if (RETVAL)
		2785	{
		2786	THIS->send_face (RETVAL, pri);
		2787	THIS->flush_fx ();
		2788	}
		2789	OUTPUT:
		2790	RETVAL
		2791
		2792	int
		2793	client::fx_want (int idx, int value = -1)
		2794	CODE:
		2795	if (0 < idx && idx < FT_NUM)
		2796	{
		2797	RETVAL = THIS->fx_want [idx];
		2798	if (items > 2)
		2799	THIS->fx_want [idx] = value;
		2800	}
		2801	else
		2802	RETVAL = 0;
		2803	OUTPUT:
		2804	RETVAL
		2805
		2806	MODULE = cf PACKAGE = cf::sound PREFIX = sound_
		2807
		2808	faceidx sound_find (utf8_string name)
		2809
		2810	void sound_set (utf8_string str, faceidx face)
		2811
		2812	# dire hack
		2813	void old_sound_index (int idx, faceidx face)
		2814	CODE:
		2815	extern faceidx old_sound_index [SOUND_CAST_SPELL_0];
		2816	old_sound_index [idx] = face;
2309		2817
2310	MODULE = cf PACKAGE = cf::face PREFIX = face_	2818	MODULE = cf PACKAGE = cf::face PREFIX = face_
2311		2819
2312	#INCLUDE: $PERL $srcdir/genacc faceset ../include/face.h |	2820	#INCLUDE: $PERL $srcdir/genacc faceset ../include/face.h |
2313		2821
…		…
2329	if (!strcmp (name, BLANK_FACE_NAME)) blank_face = RETVAL;	2837	if (!strcmp (name, BLANK_FACE_NAME)) blank_face = RETVAL;
2330	if (!strcmp (name, EMPTY_FACE_NAME)) empty_face = RETVAL;	2838	if (!strcmp (name, EMPTY_FACE_NAME)) empty_face = RETVAL;
2331	}	2839	}
2332	OUTPUT: RETVAL	2840	OUTPUT: RETVAL
2333		2841
2334	void set (faceidx idx, int visibility, int magicmap)	2842	void set_type (faceidx idx, int value)
2335	CODE:	2843	ALIAS:
2336	faceinfo *f = face_info (idx);	2844	set_type = 0
2337	assert (f);	2845	set_visibility = 1
2338	f->visibility = visibility;	2846	set_magicmap = 2
2339	f->magicmap = magicmap;	2847	set_smooth = 3
2340		2848	set_smoothlevel = 4
2341	void set_smooth (faceidx idx, faceidx smooth, int smoothlevel)
2342	CODE:	2849	CODE:
2343	faceinfo *f = face_info (idx); assert (f);	2850	faceinfo *f = face_info (idx); assert (f);
2344	f->smooth = smooth;	2851	switch (ix)
2345	f->smoothlevel = smoothlevel;	2852	{
		2853	case 0: f->type = value; break;
		2854	case 1: f->visibility = value; break;
		2855	case 2: f->magicmap = value; break;
		2856	case 3: f->smooth = value; break;
		2857	case 4: f->smoothlevel = value; break;
		2858	}
2346		2859
2347	void set_data (faceidx idx, int faceset, SV *data, SV *chksum)	2860	void set_data (faceidx idx, int faceset, SV *data, SV *chksum)
2348	CODE:	2861	CODE:
2349	{	2862	{
2350	facedata *d = face_data (idx, faceset);	2863	faceinfo *f = face_info (idx); assert (f);
2351	assert (d);	2864	facedata *d = &(faceset ? f->data64 : f->data32);
2352	sv_to (data, d->data);	2865	sv_to (data, d->data);
2353	STRLEN clen;	2866	STRLEN clen;
2354	char *cdata = SvPVbyte (chksum, clen);	2867	char *cdata = SvPVbyte (chksum, clen);
2355	clen = min (CHKSUM_SIZE, clen);	2868	clen = min (CHKSUM_SIZE, clen);
2356		2869
…		…
2366	ns->force_newmap = true;	2879	ns->force_newmap = true;
2367	}	2880	}
2368	}	2881	}
2369	}	2882	}
2370		2883
		2884	int get_data_size (faceidx idx, int faceset = 0)
		2885	CODE:
		2886	facedata *d = face_data (idx, faceset);
		2887	if (!d) XSRETURN_UNDEF;
		2888	RETVAL = d->data.size ();
		2889	OUTPUT:
		2890	RETVAL
		2891
		2892	SV *get_chksum (faceidx idx, int faceset = 0)
		2893	CODE:
		2894	facedata *d = face_data (idx, faceset);
		2895	if (!d) XSRETURN_UNDEF;
		2896	RETVAL = newSVpvn ((char *)d->chksum, CHKSUM_SIZE);
		2897	OUTPUT:
		2898	RETVAL
		2899
		2900	SV *get_data (faceidx idx, int faceset = 0)
		2901	CODE:
		2902	facedata *d = face_data (idx, faceset);
		2903	if (!d) XSRETURN_UNDEF;
		2904	RETVAL = newSVpvn (d->data.data (), d->data.length ());
		2905	OUTPUT:
		2906	RETVAL
		2907
2371	void invalidate (faceidx idx)	2908	void invalidate (faceidx idx)
2372	CODE:	2909	CODE:
2373	for_all_clients (ns)	2910	for_all_clients (ns)
2374	{	2911	{
2375	ns->faces_sent [idx] = false;	2912	ns->faces_sent [idx] = false;
…		…
2418	void invalidate_all ()	2955	void invalidate_all ()
2419	CODE:	2956	CODE:
2420	for_all_clients (ns)	2957	for_all_clients (ns)
2421	ns->anims_sent.reset ();	2958	ns->anims_sent.reset ();
2422		2959
		2960	MODULE = cf PACKAGE = cf::object::freezer
		2961
		2962	INCLUDE: $PERL $srcdir/genacc object_freezer ../include/cfperl.h |
		2963
		2964	SV *
		2965	new (char *klass)
		2966	CODE:
		2967	RETVAL = newSVptr (new object_freezer, gv_stashpv ("cf::object::freezer", 1));
		2968	OUTPUT: RETVAL
		2969
		2970	void
		2971	DESTROY (SV *sv)
		2972	CODE:
		2973	object_freezer *self;
		2974	sv_to (sv, self);
		2975	delete self;
		2976
		2977	MODULE = cf PACKAGE = cf::object::thawer
		2978
		2979	INCLUDE: $PERL $srcdir/genacc object_thawer ../include/cfperl.h |
		2980
		2981	SV *
		2982	new_from_file (char *klass, octet_string path)
		2983	CODE:
		2984	object_thawer *f = new object_thawer (path);
		2985	if (!*f)
		2986	{
		2987	delete f;
		2988	XSRETURN_UNDEF;
		2989	}
		2990	RETVAL = newSVptr (f, gv_stashpv ("cf::object::thawer", 1));
		2991	OUTPUT: RETVAL
		2992
		2993	void
		2994	DESTROY (SV *sv)
		2995	CODE:
		2996	object_thawer *self;
		2997	sv_to (sv, self);
		2998	delete self;
		2999
		3000	void
		3001	extract_tags (object_thawer *self)
		3002	PPCODE:
		3003	while (self->kw != KW_EOF)
		3004	{
		3005	PUTBACK;
		3006	coroapi::cede_to_tick ();
		3007	SPAGAIN;
		3008
		3009	if (self->kw == KW_tag)
		3010	XPUSHs (sv_2mortal (newSVpv_utf8 (self->get_str ())));
		3011
		3012	self->skip ();
		3013	}
		3014

Diff Legend

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