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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.225 by root, Sat Jun 30 03:00:55 2007 UTC vs.
Revision 1.369 by root, Wed Apr 14 02:31:24 2010 UTC

…		…
1	/*	1	/*
2	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (©) 2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team	4	* Copyright (©) 2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2001-2005,2007 by Chachkoff Yann
6	* Copyright (©) 2006,2007 by Marc Lehmann <cf@schmorp.de>
7	*	5	*
8	* Crossfire TRT is free software; you can redistribute it and/or modify it	6	* Deliantra is free software: you can redistribute it and/or modify it under
9	* under the terms of the GNU General Public License as published by the Free	7	* the terms of the Affero GNU General Public License as published by the
10	* Software Foundation; either version 2 of the License, or (at your option)	8	* Free Software Foundation, either version 3 of the License, or (at your
11	* any later version.	9	* option) any later version.
12	*	10	*
13	* This program is distributed in the hope that it will be useful, but	11	* This program is distributed in the hope that it will be useful,
14	* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* for more details.	14	* GNU General Public License for more details.
17	*	15	*
18	* You should have received a copy of the GNU General Public License along	16	* You should have received a copy of the Affero GNU General Public License
19	* with Crossfire TRT; if not, write to the Free Software Foundation, Inc. 51	17	* and the GNU General Public License along with this program. If not, see
20	* Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA	18	* <http://www.gnu.org/licenses/>.
21	*	19	*
22	* The authors can be reached via e-mail to <crossfire@schmorp.de>	20	* The authors can be reached via e-mail to <support@deliantra.net>
23	*/	21	*/
24		22
25	#include "autoconf.h"	23	#include "autoconf.h"
26
27	#define PLUGIN_NAME "perl"
28	#define PLUGIN_VERSION "cfperl 0.5"
29
30	#define CEDES_PER_TICK 5
31		24
32	#if HAVE_EXECINFO_H	25	#if HAVE_EXECINFO_H
33	# include <execinfo.h>	26	# include <execinfo.h>
34	#endif	27	#endif
35		28
36	#include <plugin_common.h>
37	#include <sounds.h>
38	#include <cstdarg>	29	#include <cstdarg>
		30	#include <typeinfo>
		31
		32	#include "global.h"
		33	#include "../random_maps/random_map.h"
		34	#include "evthread.h"
39	#include <sproto.h>	35	#include "sproto.h"
40
41	#include "loader.h"
42	#include "cfperl.h"
43	#include "shstr.h"
44		36
45	#include <unistd.h>	37	#include <unistd.h>
46	#if _POSIX_MEMLOCK	38	#if _POSIX_MEMLOCK
47	# include <sys/mman.h>	39	# include <sys/mman.h>
48	#endif	40	#endif
49		41
		42	#if HAVE_MALLOC_H
		43	# include <malloc.h>
		44	#endif
		45
		46	#if !__GLIBC__
		47	# define malloc_trim(pad) -1
		48	#endif
		49
50	#include <EXTERN.h>	50	#include <EXTERN.h>
51	#include <perl.h>	51	#include <perl.h>
52	#include <XSUB.h>	52	#include <XSUB.h>
53		53
54	#include "CoroAPI.h"	54	#include "CoroAPI.h"
55	#include "perlxsi.c"	55	#include "perlxsi.c"
56		56
57	extern sint64 *levels; // the experience table	57	extern sint64 *levels; // the experience table
58		58
59	typedef object object_ornull;	59	typedef object_thawer &object_thawer_ref;
60	typedef maptile maptile_ornull;	60	typedef object_freezer &object_freezer_ref;
61
62	typedef char *octet_string;
63	typedef char *utf8_string;
64	typedef const char *const_octet_string;
65	typedef const char *const_utf8_string;
66		61
67	typedef std::string std__string;	62	typedef std::string std__string;
68		63
69	#if IVSIZE >= 8
70	typedef IV val64;
71	# define newSVval64 newSViv
72	# define SvVAL64 SvIV
73	#else
74	typedef double val64;
75	# define newSVval64 newSVnv
76	# define SvVAL64 SvNV
77	#endif
78
79	static f_plug_api gethook = cfapi_get_hooks;
80	static f_plug_api object_insert = cfapi_object_insert;
81
82	static PerlInterpreter *perl;	64	static PerlInterpreter *perl;
83		65
84	tstamp NOW, runtime;	66	tstamp NOW, runtime;
		67
		68	static int tick_inhibit;
		69	static int tick_pending;
85		70
86	global gbl_ev;	71	global gbl_ev;
87	static AV cb_global, cb_attachable, cb_object, cb_player, cb_client, cb_type, *cb_map;	72	static AV cb_global, cb_attachable, cb_object, cb_player, cb_client, cb_type, *cb_map;
88	static SV sv_runtime, sv_next_tick;	73	static SV sv_runtime, sv_tick_start, sv_next_tick, sv_now;
		74	static AV *av_reflect;
89		75
90	bitset<NUM_EVENT_TYPES> ev_want_event;	76	bitset<NUM_EVENT_TYPES> ev_want_event;
91	bitset<NUM_TYPES> ev_want_type;	77	bitset<NUM_TYPES> ev_want_type;
92		78
93	static HV	79	static HV
94	*stash_cf,	80	*stash_cf,
95	*stash_cf_object_wrap,	81	*stash_cf_object_wrap,
96	*stash_cf_object_player_wrap,	82	*stash_cf_object_player_wrap,
97	*stash_cf_player_wrap,	83	*stash_cf_player_wrap,
98	*stash_cf_map_wrap,	84	*stash_cf_map_wrap,
		85	*stash_cf_mapspace_wrap,
99	*stash_cf_client_wrap,	86	*stash_cf_client_wrap,
100	*stash_cf_arch_wrap,	87	*stash_cf_arch_wrap,
101	*stash_cf_party_wrap,	88	*stash_cf_party_wrap,
102	*stash_cf_region_wrap,	89	*stash_cf_region_wrap,
103	*stash_cf_living_wrap;	90	*stash_cf_living_wrap;
		91
		92	static SV
		93	*cv_cf_do_invoke,
		94	*cv_cf__can_merge,
		95	*cv_cf_client_send_msg,
		96	*cv_cf_tick,
		97	*cv_cf_match_match;
		98
		99	#ifndef newSVpv_utf8
		100	static SV *
		101	newSVpv_utf8 (const char *s)
		102	{
		103	if (!s)
		104	return newSV (0);
		105
		106	SV *sv = newSVpv (s, 0);
		107	SvUTF8_on (sv);
		108	return sv;
		109	}
		110	#endif
		111
		112	#ifndef newSVpvn_utf8
		113	static SV *
		114	newSVpvn_utf8 (const char *s, STRLEN l, int utf8)
		115	{
		116	if (!s)
		117	return newSV (0);
		118
		119	SV *sv = newSVpvn (s, l);
		120
		121	if (utf8)
		122	SvUTF8_on (sv);
		123
		124	return sv;
		125	}
		126	#endif
		127
		128	static noinline utf8_string
		129	cfSvPVutf8_nolen (SV *sv)
		130	{
		131	SvGETMAGIC (sv);
		132
		133	if (SvPOK (sv))
		134	{
		135	if (!SvUTF8 (sv))
		136	sv_utf8_upgrade_nomg (sv);
		137
		138	return SvPVX (sv);
		139	}
		140
		141	return SvPV_nolen (sv);
		142	}
104		143
105	// helper cast function, returns super class * or 0	144	// helper cast function, returns super class * or 0
106	template<class super>	145	template<class super>
107	static super *	146	static super *
108	is_a (attachable *at)	147	is_a (attachable *at)
141	SvREFCNT_inc (self);	180	SvREFCNT_inc (self);
142	hv_clear (self);	181	hv_clear (self);
143	sv_unmagic ((SV *)self, PERL_MAGIC_ext);	182	sv_unmagic ((SV *)self, PERL_MAGIC_ext);
144	SvREFCNT_dec (self);	183	SvREFCNT_dec (self);
145		184
146	// self must be null now because thats sv_unmagic's job.	185	// self must be null now because that's sv_unmagic's job.
147	assert (!this->self);	186	assert (!this->self);
148	}	187	}
149	}	188	}
150		189
151	void	190	void
…		…
185	attachable::destroy ()	224	attachable::destroy ()
186	{	225	{
187	if (destroyed ())	226	if (destroyed ())
188	return;	227	return;
189		228
190	flags \|= F_DESTROYED;	229	attachable_flags \|= F_DESTROYED;
191	do_destroy ();	230	do_destroy ();
192	sever_self ();	231	sever_self ();
		232	}
		233
		234	void
		235	attachable::do_delete ()
		236	{
		237	delete this;
193	}	238	}
194		239
195	void	240	void
196	attachable::check_mortals ()	241	attachable::check_mortals ()
197	{	242	{
…		…
213		258
214	if (0)	259	if (0)
215	{	260	{
216	for (int j = 0; j < mortals.size (); ++j)//D	261	for (int j = 0; j < mortals.size (); ++j)//D
217	fprintf (stderr, "%d:%s %p ", j, &((object *)mortals[j])->name, mortals[j]);//D	262	fprintf (stderr, "%d:%s %p ", j, &((object *)mortals[j])->name, mortals[j]);//D
		263
218	fprintf (stderr, "\n");//D	264	fprintf (stderr, "\n");//D
219	}	265	}
220	}	266	}
221	}	267	}
222		268
…		…
242	}	288	}
243	else	289	else
244	{	290	{
245	mortals.erase (i);	291	mortals.erase (i);
246	obj->sever_self ();	292	obj->sever_self ();
247	delete obj;	293	obj->do_delete ();
248	}	294	}
249	}	295	}
250	}	296	}
251		297
		298	void
		299	attachable::set_key (const char key, const char value, bool is_utf8)
		300	{
		301	if (!self)
		302	self = newHV ();
		303
		304	if (value)
		305	hv_store (self, key, strlen (key), is_utf8 ? newSVpv_utf8 (value) : newSVpv (value, 0), 0);
		306	else
		307	hv_delete (self, key, strlen (key), G_DISCARD);
		308	}
		309
252	attachable &	310	attachable &
253	attachable::operator =(const attachable &src)	311	attachable::operator =(const attachable &src)
254	{	312	{
255	//if (self \|\| cb)	313	//if (self \|\| cb)
256	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));	314	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));
257		315
258	attach = src.attach;	316	attach = src.attach;
259	return *this;	317	return *this;
260	}	318	}
261		319
		320	#if 0
262	template<typename T>	321	template<typename T>
263	static bool	322	static bool
264	find_backref (void ptr, T obj)	323	find_backref (void ptr, T obj)
265	{	324	{
266	char s = (char )obj;	325	char s = (char )obj;
…		…
274		333
275	return false;	334	return false;
276	}	335	}
277		336
278	// for debugging, find "live" objects containing this ptr	337	// for debugging, find "live" objects containing this ptr
279	void	338	static void
280	find_backref (void *ptr)	339	find_backref (void *ptr)
281	{	340	{
282	for_all_objects (op)	341	for_all_objects (op)
283	if (find_backref (ptr, op))	342	if (find_backref (ptr, op))
284	fprintf (stderr, "O %p %d:'%s'\n", op, op->count, &op->name);	343	fprintf (stderr, "O %p %d:'%s'\n", op, op->count, &op->name);
…		…
288	fprintf (stderr, "P %p\n", pl);	347	fprintf (stderr, "P %p\n", pl);
289		348
290	for_all_clients (ns)	349	for_all_clients (ns)
291	if (find_backref (ptr, ns))	350	if (find_backref (ptr, ns))
292	fprintf (stderr, "C %p\n", ns);	351	fprintf (stderr, "C %p\n", ns);
293
294	}	352	}
		353	#endif
295		354
296	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	355	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
297		356
298	static SV *	357	static SV *
299	newSVptr (void ptr, HV stash, HV *hv = newHV ())	358	newSVptr (void ptr, HV stash, HV *hv = newHV ())
300	{	359	{
301	SV *sv;	360	SV *sv;
302		361
303	if (!ptr)	362	if (!ptr)
304	return &PL_sv_undef;	363	return newSV (0);
305		364
306	sv_magicext ((SV )hv, 0, PERL_MAGIC_ext, 0, (char )ptr, 0);	365	sv_magicext ((SV )hv, 0, PERL_MAGIC_ext, 0, (char )ptr, 0);
307	return sv_bless (newRV_noinc ((SV *)hv), stash);	366	return sv_bless (newRV_noinc ((SV *)hv), stash);
308	}	367	}
309		368
…		…
328		387
329	static SV *	388	static SV *
330	newSVattachable (attachable obj, HV stash)	389	newSVattachable (attachable obj, HV stash)
331	{	390	{
332	if (!obj)	391	if (!obj)
333	return &PL_sv_undef;	392	return newSV (0);
334		393
335	if (!obj->self)	394	if (!obj->self)
		395	obj->self = newHV ();
		396
		397	if (!SvOBJECT (obj->self))
336	{	398	{
337	obj->self = newHV ();
338	sv_magicext ((SV )obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char )obj, 0);	399	sv_magicext ((SV )obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char )obj, 0);
339		400
340	// now bless the object _once_	401	// now bless the object _once_
		402	//TODO: create a class registry with c++ type<=>perl name<=>stash and use it here and elsewhere
341	return sv_bless (newRV_inc ((SV *)obj->self), stash);	403	return sv_bless (newRV_inc ((SV *)obj->self), stash);
342	}	404	}
343	else	405	else
344	{	406	{
345	SV sv = newRV_inc ((SV )obj->self);	407	SV sv = newRV_inc ((SV )obj->self);
…		…
349		411
350	return sv;	412	return sv;
351	}	413	}
352	}	414	}
353		415
		416	#if 0 // unused
354	static void	417	static void
355	clearSVptr (SV *sv)	418	clearSVptr (SV *sv)
356	{	419	{
357	if (SvROK (sv))	420	if (SvROK (sv))
358	sv = SvRV (sv);	421	sv = SvRV (sv);
359		422
360	hv_clear ((HV *)sv);	423	hv_clear ((HV *)sv);
361	sv_unmagic (sv, PERL_MAGIC_ext);	424	sv_unmagic (sv, PERL_MAGIC_ext);
362	}	425	}
		426	#endif
		427
		428	static long
		429	SvPTR_nc (SV *sv)
		430	{
		431	sv = SvRV (sv);
		432
		433	// very important shortcut
		434	if (expect_true (SvMAGIC (sv) && SvMAGIC (sv)->mg_type == PERL_MAGIC_ext))
		435	return (long)SvMAGIC (sv)->mg_ptr;
		436
		437	if (MAGIC *mg = mg_find (sv, PERL_MAGIC_ext))
		438	return (long)mg->mg_ptr;
		439
		440	croak ("perl code used object, but C object is already destroyed, caught");
		441	}
363		442
364	static long	443	static long
365	SvPTR (SV sv, const char klass)	444	SvPTR (SV sv, const char klass)
366	{	445	{
367	if (!sv_derived_from (sv, klass))	446	if (!sv_derived_from (sv, klass))
368	croak ("object of type %s expected", klass);	447	croak ("object of type %s expected", klass);
369		448
370	MAGIC *mg = mg_find (SvRV (sv), PERL_MAGIC_ext);	449	return SvPTR_nc (sv);
371
372	if (!mg)
373	croak ("perl code used %s object, but C object is already destroyed, caught", klass);
374
375	return (long)mg->mg_ptr;
376	}	450	}
377		451
378	static long	452	static long noinline
379	SvPTR_ornull (SV sv, const char klass)	453	SvPTR_ornull (SV sv, const char klass)
380	{	454	{
381	if (SvOK (sv))	455	if (expect_false (!SvOK (sv))) return 0;
		456
382	return SvPTR (sv, klass);	457	return SvPTR (sv, klass);
383	else
384	return 0;
385	}	458	}
386		459
387	static inline SV *	460	static long noinline
388	newSVpv_utf8 (const char *s)	461	SvPTR_ornull_client (SV *sv)
389	{	462	{
		463	if (expect_false (!SvOK (sv))) return 0;
		464
		465	if (!SvROK (sv)
		466	\|\| (SvSTASH (SvRV (sv)) != stash_cf_client_wrap
		467	&& !sv_derived_from (sv, "cf::client")))
		468	croak ("object of type cf::client expected");
		469
		470	return SvPTR_nc (sv);
		471	}
		472
		473	static long noinline
		474	SvPTR_ornull_object (SV *sv)
		475	{
		476	if (expect_false (!SvOK (sv))) return 0;
		477
		478	if (!SvROK (sv)
		479	\|\| (SvSTASH (SvRV (sv)) != stash_cf_object_wrap
		480	&& SvSTASH (SvRV (sv)) != stash_cf_object_player_wrap
		481	&& SvSTASH (SvRV (sv)) != stash_cf_arch_wrap
		482	&& !sv_derived_from (sv, "cf::object")))
		483	croak ("object of type cf::object expected");
		484
		485	return SvPTR_nc (sv);
		486	}
		487
		488	static long noinline
		489	SvPTR_ornull_player (SV *sv)
		490	{
		491	if (expect_false (!SvOK (sv))) return 0;
		492
		493	if (!SvROK (sv)
		494	\|\| (SvSTASH (SvRV (sv)) != stash_cf_player_wrap
		495	&& !sv_derived_from (sv, "cf::player")))
		496	croak ("object of type cf::player expected");
		497
		498	return SvPTR_nc (sv);
		499	}
		500
		501	static inline SV to_sv (const shstr & v) { return newSVpvn_utf8 ((const char )v, v.length (), 1); }
		502	static inline SV to_sv (const char v) { return v ? newSVpv (v, 0) : newSV (0); }
		503	static inline SV *to_sv (bool v) { return newSViv (v); }
		504	static inline SV *to_sv ( signed char v) { return newSViv (v); }
		505	static inline SV *to_sv (unsigned char v) { return newSViv (v); }
		506	static inline SV *to_sv ( signed short v) { return newSViv (v); }
		507	static inline SV *to_sv (unsigned short v) { return newSVuv (v); }
		508	static inline SV *to_sv ( signed int v) { return newSViv (v); }
		509	static inline SV *to_sv (unsigned int v) { return newSVuv (v); }
		510	static inline SV *to_sv ( signed long v) { return newSViv (v); }
		511	static inline SV *to_sv (unsigned long v) { return newSVuv (v); }
		512	static inline SV *to_sv ( signed long long v) { return newSVval64 (v); }
		513	static inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }
		514	static inline SV *to_sv (float v) { return newSVnv (v); }
		515	static inline SV *to_sv (double v) { return newSVnv (v); }
		516	static inline SV to_sv (client v) { return newSVattachable (v, stash_cf_client_wrap); }
		517	static inline SV to_sv (player v) { return newSVattachable (v, stash_cf_player_wrap); }
		518	static inline SV to_sv (object v) { return newSVattachable (v, v && v->type == PLAYER ? stash_cf_object_player_wrap : stash_cf_object_wrap); }
		519	static inline SV to_sv (maptile v) { return newSVattachable (v, stash_cf_map_wrap); }
		520	static inline SV to_sv (archetype v) { return newSVattachable (v, stash_cf_arch_wrap); }
		521	static inline SV to_sv (region v) { return newSVattachable (v, stash_cf_region_wrap); }
		522	static inline SV to_sv (partylist v) { return newSVptr (v, stash_cf_party_wrap); }
		523	static inline SV to_sv (living v) { return newSVptr (v, stash_cf_living_wrap); }
		524	static inline SV to_sv (mapspace v) { return newSVptr (v, stash_cf_mapspace_wrap); }
		525
		526	static inline SV *to_sv (object & v) { return to_sv (&v); }
		527	static inline SV *to_sv (living & v) { return to_sv (&v); }
		528
		529	static inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); }
		530	static inline SV to_sv (const treasurelist v) { return to_sv (v->name); }
		531
		532	static inline SV *to_sv (UUID v) { return newSVpv (v.c_str (), 0); }
		533
		534	static inline SV to_sv (dynbuf v)
		535	{
390	SV *sv = newSVpv (s, 0);	536	SV *sv = newSV (0);
		537
		538	sv_upgrade (sv, SVt_PV);
		539	SvGROW (sv, v->size () + 1);
		540	SvPOK_only (sv);
		541	v->linearise (SvPVX (sv));
		542	SvCUR_set (sv, v->size ());
		543	*SvEND (sv) = 0;
		544
		545	return sv;
		546	}
		547
		548	static inline SV to_sv (dynbuf_text v)
		549	{
		550	SV sv = to_sv (static_cast<dynbuf > (v));
391	SvUTF8_on (sv);	551	SvUTF8_on (sv);
392	return sv;	552	return sv;
393	}	553	}
394		554
395	static inline SV *
396	newSVpvn_utf8 (const char *s, STRLEN l)
397	{
398	SV *sv = newSVpvn (s, l);
399	SvUTF8_on (sv);
400	return sv;
401	}
402
403	inline SV to_sv (const shstr & v) { return v ? newSVpvn_utf8 ((const char )v, v.length ()) : &PL_sv_undef; }
404	inline SV to_sv (const char v) { return newSVpv (v, 0); }
405	inline SV *to_sv (bool v) { return newSViv (v); }
406	inline SV *to_sv ( signed char v) { return newSViv (v); }
407	inline SV *to_sv (unsigned char v) { return newSViv (v); }
408	inline SV *to_sv ( signed short v) { return newSViv (v); }
409	inline SV *to_sv (unsigned short v) { return newSVuv (v); }
410	inline SV *to_sv ( signed int v) { return newSViv (v); }
411	inline SV *to_sv (unsigned int v) { return newSVuv (v); }
412	inline SV *to_sv ( signed long v) { return newSViv (v); }
413	inline SV *to_sv (unsigned long v) { return newSVuv (v); }
414	inline SV *to_sv ( signed long long v) { return newSVval64 (v); }
415	inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }
416	inline SV *to_sv (float v) { return newSVnv (v); }
417	inline SV *to_sv (double v) { return newSVnv (v); }
418	inline SV to_sv (client v) { return newSVattachable (v, stash_cf_client_wrap); }
419	inline SV to_sv (player v) { return newSVattachable (v, stash_cf_player_wrap); }
420	inline SV to_sv (object v) { return newSVattachable (v, v && v->type == PLAYER ? stash_cf_object_player_wrap : stash_cf_object_wrap); }
421	inline SV to_sv (maptile v) { return newSVattachable (v, stash_cf_map_wrap); }
422	inline SV to_sv (archetype v) { return newSVattachable (v, stash_cf_arch_wrap); }
423	inline SV to_sv (partylist v) { return newSVptr (v, stash_cf_party_wrap); }
424	inline SV to_sv (region v) { return newSVptr (v, stash_cf_region_wrap); }
425	inline SV to_sv (living v) { return newSVptr (v, stash_cf_living_wrap); }
426
427	inline SV *to_sv (object & v) { return to_sv (&v); }
428	inline SV *to_sv (living & v) { return to_sv (&v); }
429
430	inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); }
431	inline SV to_sv (const treasurelist v) { return to_sv (v->name); }
432
433	inline SV *to_sv (UUID v)
434	{
435	char buf[128];
436	snprintf (buf, 128, "<1.%" PRIx64 ">", v.seq);
437	return newSVpv (buf, 0);
438	}
439
440	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPVutf8_nolen (sv) : 0; }	555	static inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? cfSvPVutf8_nolen (sv) : 0; }
441	inline void sv_to (SV sv, char &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }	556	static inline void sv_to (SV sv, char &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }
442	inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }	557	static inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }
443	inline void sv_to (SV *sv, signed char &v) { v = SvIV (sv); }	558	static inline void sv_to (SV *sv, signed char &v) { v = SvIV (sv); }
444	inline void sv_to (SV *sv, unsigned char &v) { v = SvIV (sv); }	559	static inline void sv_to (SV *sv, unsigned char &v) { v = SvIV (sv); }
445	inline void sv_to (SV *sv, signed short &v) { v = SvIV (sv); }	560	static inline void sv_to (SV *sv, signed short &v) { v = SvIV (sv); }
446	inline void sv_to (SV *sv, unsigned short &v) { v = SvIV (sv); }	561	static inline void sv_to (SV *sv, unsigned short &v) { v = SvIV (sv); }
447	inline void sv_to (SV *sv, signed int &v) { v = SvIV (sv); }	562	static inline void sv_to (SV *sv, signed int &v) { v = SvIV (sv); }
448	inline void sv_to (SV *sv, unsigned int &v) { v = SvUV (sv); }	563	static inline void sv_to (SV *sv, unsigned int &v) { v = SvUV (sv); }
449	inline void sv_to (SV *sv, signed long &v) { v = SvIV (sv); }	564	static inline void sv_to (SV *sv, signed long &v) { v = SvIV (sv); }
450	inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }	565	static inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }
451	inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }	566	static inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }
452	inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }	567	static inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }
453	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }	568	static inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
454	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }	569	static inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }
455	inline void sv_to (SV sv, client &v) { v = (client )(attachable )SvPTR_ornull (sv, "cf::client"); }	570	static inline void sv_to (SV sv, client &v) { v = (client ) (attachable )SvPTR_ornull_client (sv); }
456	inline void sv_to (SV sv, player &v) { v = (player )(attachable )SvPTR_ornull (sv, "cf::player"); }	571	static inline void sv_to (SV sv, player &v) { v = (player ) (attachable )SvPTR_ornull_player (sv); }
457	inline void sv_to (SV sv, object &v) { v = (object )(attachable )SvPTR_ornull (sv, "cf::object"); }	572	static inline void sv_to (SV sv, object &v) { v = (object ) (attachable )SvPTR_ornull_object (sv); }
458	inline void sv_to (SV sv, archetype &v) { v = (archetype )(attachable )SvPTR_ornull (sv, "cf::arch"); }	573	static inline void sv_to (SV sv, archetype &v) { v = (archetype )(attachable )SvPTR_ornull (sv, "cf::arch"); }
459	inline void sv_to (SV sv, maptile &v) { v = (maptile )(attachable )SvPTR_ornull (sv, "cf::map"); }	574	static inline void sv_to (SV sv, maptile &v) { v = (maptile ) (attachable )SvPTR_ornull (sv, "cf::map"); }
		575	static inline void sv_to (SV sv, region &v) { v = (region ) (attachable )SvPTR_ornull (sv, "cf::region"); }
460	inline void sv_to (SV sv, attachable &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); }	576	static inline void sv_to (SV sv, attachable &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); }
461	inline void sv_to (SV sv, partylist &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }	577	static inline void sv_to (SV sv, partylist &v) { v = (partylist *) SvPTR_ornull (sv, "cf::party"); }
462	inline void sv_to (SV sv, region &v) { v = (region *)SvPTR_ornull (sv, "cf::region"); }
463	inline void sv_to (SV sv, living &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }	578	static inline void sv_to (SV sv, living &v) { v = (living *) SvPTR_ornull (sv, "cf::living"); }
		579	static inline void sv_to (SV sv, mapspace &v) { v = (mapspace *) SvPTR_ornull (sv, "cf::mapspace"); }
		580	static inline void sv_to (SV sv, object_freezer &v) { v = (object_freezer *) SvPTR_ornull (sv, "cf::object::freezer"); }
		581	static inline void sv_to (SV sv, object_thawer &v) { v = (object_thawer *) SvPTR_ornull (sv, "cf::object::thawer" ); }
464		582
465	//inline void sv_to (SV sv, faceinfo &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }	583	//static inline void sv_to (SV sv, faceinfo &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }
466	inline void sv_to (SV sv, treasurelist &v) { v = treasurelist::find (SvPV_nolen (sv)); }	584	static inline void sv_to (SV sv, treasurelist &v) { v = treasurelist::find (SvPV_nolen (sv)); }
467		585
468	template<class T>	586	template<class T>
469	inline void sv_to (SV sv, refptr<T> &v) { T tmp; sv_to (sv, tmp); v = tmp; }	587	static inline void sv_to (SV sv, refptr<T> &v) { T tmp; sv_to (sv, tmp); v = tmp; }
470		588
471	template<int N>	589	template<int N>
472	inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); }	590	static inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); }
473		591
474	inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); }	592	static inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); }
475	inline void sv_to (SV *sv, petmode_t &v) { v = (petmode_t) SvIV (sv); }	593	static inline void sv_to (SV *sv, petmode_t &v) { v = (petmode_t) SvIV (sv); }
476	inline void sv_to (SV *sv, usekeytype &v) { v = (usekeytype) SvIV (sv); }	594	static inline void sv_to (SV *sv, usekeytype &v) { v = (usekeytype) SvIV (sv); }
477	inline void sv_to (SV *sv, unapplymode &v) { v = (unapplymode) SvIV (sv); }	595	static inline void sv_to (SV *sv, unapplymode &v) { v = (unapplymode) SvIV (sv); }
478		596
479	inline void sv_to (SV *sv, std::string &v)	597	static inline void sv_to (SV *sv, std::string &v)
480	{	598	{
481	STRLEN len;	599	STRLEN len;
482	char *data = SvPVbyte (sv, len);	600	char *data = SvPVbyte (sv, len);
483	v.assign (data, len);	601	v.assign (data, len);
484	}	602	}
485		603
486	inline void sv_to (SV *sv, UUID &v)	604	static inline void sv_to (SV *sv, UUID &v)
487	{	605	{
488	unsigned int version;	606	if (!v.parse (SvPV_nolen (sv)))
489
490	if (2 != sscanf (SvPV_nolen (sv), "<%d.%" SCNx64 ">", &version, &v.seq) \|\| 1 != version)
491	croak ("unparsable uuid: %s", SvPV_nolen (sv));	607	croak ("unparsable uuid: %s", SvPV_nolen (sv));
492	}	608	}
493		609
494	inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }	610	static inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }
495		611
496	static SV *	612	static SV *
497	newSVdt_va (va_list &ap, data_type type)	613	newSVdt_va (va_list &ap, data_type type)
498	{	614	{
499	SV *sv;	615	SV *sv;
…		…
513	break;	629	break;
514		630
515	case DT_STRING:	631	case DT_STRING:
516	{	632	{
517	char str = (char )va_arg (ap, const char *);	633	char str = (char )va_arg (ap, const char *);
518	sv = str ? newSVpv (str, 0) : &PL_sv_undef;	634	sv = str ? newSVpv (str, 0) : newSV (0);
519	}	635	}
520	break;	636	break;
521		637
522	case DT_DATA:	638	case DT_DATA:
523	{	639	{
524	char str = (char )va_arg (ap, const void *);	640	char str = (char )va_arg (ap, const void *);
525	int len = va_arg (ap, int);	641	int len = va_arg (ap, int);
526	sv = str ? newSVpv (str, len) : &PL_sv_undef;	642	sv = str ? newSVpv (str, len) : newSV (0);
527	}	643	}
528	break;	644	break;
529		645
530	case DT_OBJECT:	646	case DT_OBJECT:
531	sv = to_sv (va_arg (ap, object *));	647	sv = to_sv (va_arg (ap, object *));
…		…
573	va_end (ap);	689	va_end (ap);
574		690
575	return sv;	691	return sv;
576	}	692	}
577		693
		694	// typemap support, mostly to avoid excessive inlining
		695	template<class type>
		696	static void noinline
		697	cf_obj_to (SV *arg, type &var)
		698	{
		699	sv_to (arg, var);
		700	if (!var)
		701	croak ("must not pass invalid/null cf_obj here");
		702	}
		703
		704	template<class object>
		705	static void noinline
		706	cf_obj_ornull_to (SV arg, object &var)
		707	{
		708	if (SvOK (arg))
		709	{
		710	sv_to (arg, var);
		711	if (!var)
		712	croak ("unable to convert perl object to C++ object");
		713	}
		714	else
		715	var = 0;
		716	}
		717
		718	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		719
578	static SV *	720	static SV *
579	newSVcfapi (int type, ...)
580	{
581	SV *sv;
582
583	va_list ap;
584	va_start (ap, type);
585
586	switch (type)
587	{
588	case CFAPI_INT: sv = newSViv (va_arg (ap, int )); break;
589	case CFAPI_LONG: sv = newSVval64 (va_arg (ap, sint64 )); break;
590	case CFAPI_DOUBLE: sv = newSVnv (va_arg (ap, double )); break;
591	case CFAPI_STRING: sv = newSVdt_va (ap, DT_STRING); break;
592	case CFAPI_POBJECT: sv = newSVdt_va (ap, DT_OBJECT); break;
593	case CFAPI_PMAP: sv = newSVdt_va (ap, DT_MAP ); break;
594	case CFAPI_PPLAYER: sv = newSVdt_va (ap, DT_PLAYER); break;
595	case CFAPI_PARCH: sv = newSVdt_va (ap, DT_ARCH ); break;
596	case CFAPI_PPARTY: sv = newSVdt_va (ap, DT_PARTY ); break;
597	case CFAPI_PREGION: sv = newSVdt_va (ap, DT_REGION); break;
598
599	default:
600	assert (("unhandled type in newSVcfapi", 0));
601	}
602
603	va_end (ap);
604
605	return sv;
606	}
607
608	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
609
610	SV *
611	registry (attachable *ext)	721	registry (attachable *ext)
612	{	722	{
613	if (!ext->cb)	723	if (!ext->cb)
614	ext->cb = newAV ();	724	ext->cb = newAV ();
615		725
616	return newRV_inc ((SV *)ext->cb);	726	return newRV_inc ((SV *)ext->cb);
617	}	727	}
618		728
619	/////////////////////////////////////////////////////////////////////////////	729	/////////////////////////////////////////////////////////////////////////////
620		730
621	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
622	{
623	return 0;
624	}
625
626	static CommArray_s rtn_cmd;
627
628	static int
629	runPluginCommand (object obj, char params)
630	{
631	return -1;
632	}
633
634	extern "C" void cfperl_getPluginProperty (int type, ...)
635	{
636	va_list args;
637	char *propname;
638	int i;
639	va_start (args, type);
640	propname = va_arg (args, char *);
641	//printf ("Property name: %s\n", propname);
642
643	if (!strcmp (propname, "command?"))
644	return NULL;
645	else if (!strcmp (propname, "Identification"))
646	{
647	va_end (args);
648	return (void *)PLUGIN_NAME;
649	}
650	else if (!strcmp (propname, "FullName"))
651	{
652	va_end (args);
653	return (void *)PLUGIN_VERSION;
654	}
655	else
656	va_end (args);
657
658	return NULL;
659	}
660
661	extern "C" int cfperl_postInitPlugin ()
662	{
663	int hooktype = 1;
664	int rtype = 0;
665
666	cf_init_plugin (gethook);
667
668	return 0;
669	}
670
671	extern "C" int cfperl_closePlugin ()
672	{
673	return 0;
674	}
675
676	void	731	void
677	cfperl_init ()	732	cfperl_init ()
678	{	733	{
		734	extern char **environ;
		735
679	PERL_SYS_INIT3 (&settings.argc, &settings.argv, 0);	736	PERL_SYS_INIT3 (&settings.argc, &settings.argv, &environ);
680	perl = perl_alloc ();	737	perl = perl_alloc ();
681	perl_construct (perl);	738	perl_construct (perl);
682		739
683	PL_exit_flags \|= PERL_EXIT_DESTRUCT_END;	740	PL_exit_flags \|= PERL_EXIT_DESTRUCT_END;
684		741
685	const char *argv[] = {	742	const char *argv[] = {
686	settings.argv [0],	743	settings.argv [0],
687	"-e"	744	"-e0"
688	"use Event; use Coro;" // required for bootstrap
689	"cf->bootstrap;" // required for datadir :*>
690	"unshift @INC, cf::datadir ();"
691	"require cf;"
692	};	745	};
693		746
694	if (perl_parse (perl, xs_init, 2, (char )argv, (char )NULL)	747	if (perl_parse (perl, xs_init, 2, (char **)argv, environ)
695	\|\| perl_run (perl))	748	\|\| perl_run (perl))
696	{	749	{
697	printf ("unable to initialize perl-interpreter, aborting.\n");	750	printf ("unable to initialize perl-interpreter, aborting.\n");
698	exit (EXIT_FAILURE);	751	exit (EXIT_FAILURE);
699	}	752	}
700		753
		754	eval_pv (
		755	"#line 1 'cfperl init'\n"
		756	"use EV ();\n"
		757	"use Coro ();\n"
		758	"cf->bootstrap;\n"
		759	"unshift @INC, cf::datadir ();\n"
		760	"require cf;\n",
		761	0
		762	);
		763
		764	if (SvTRUE (ERRSV))
701	{	765	{
702	dSP;	766	printf ("unable to bootstrap perl, aborting:\n%s", SvPV_nolen (ERRSV));
703		767	exit (EXIT_FAILURE);
704	PUSHMARK (SP);
705	PUTBACK;
706	call_pv ("cf::init", G_DISCARD \| G_VOID);
707	}	768	}
708	}	769	}
709		770
		771	void
710	void cfperl_main ()	772	cfperl_main ()
711	{	773	{
712	dSP;	774	dSP;
713		775
714	PUSHMARK (SP);	776	PUSHMARK (SP);
715	PUTBACK;	777	PUTBACK;
…		…
740	# undef def	802	# undef def
741	};	803	};
742		804
743	#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)	805	#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)
744		806
745	static void	807	static void noinline
746	gather_callbacks (AV &callbacks, AV registry, event_type event)	808	gather_callbacks (AV &callbacks, AV registry, event_type event)
747	{	809	{
748	// event must be in array	810	// event must be in array
749	if (event >= 0 && event <= AvFILLp (registry))	811	if (event >= 0 && event <= AvFILLp (registry))
750	{	812	{
…		…
836	{	898	{
837	attachable::gather_callbacks (callbacks, event);	899	attachable::gather_callbacks (callbacks, event);
838	::gather_callbacks (callbacks, cb_map, event);	900	::gather_callbacks (callbacks, cb_map, event);
839	}	901	}
840		902
841	void	903	static void noinline
842	_recalc_want (bitset<NUM_EVENT_TYPES> &set, AV *registry)	904	_recalc_want (bitset<NUM_EVENT_TYPES> &set, AV *registry)
843	{	905	{
844	for (int event = 0; event <= AvFILLp (registry); ++event)	906	for (int event = 0; event <= AvFILLp (registry); ++event)
845	{	907	{
846	SV *cbs_ = AvARRAY (registry)[event];	908	SV *cbs_ = AvARRAY (registry)[event];
…		…
856	}	918	}
857	}	919	}
858	}	920	}
859		921
860	// very slow and inefficient way to recalculate the global want bitsets	922	// very slow and inefficient way to recalculate the global want bitsets
861	void	923	static void
862	_recalc_want ()	924	_recalc_want ()
863	{	925	{
864	ev_want_event.reset ();	926	ev_want_event.reset ();
865		927
866	_recalc_want (ev_want_event, cb_global);	928	_recalc_want (ev_want_event, cb_global);
…		…
939	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));	1001	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
940	}	1002	}
941		1003
942	va_end (ap);	1004	va_end (ap);
943		1005
944	CALL_CALL ("cf::do_invoke", G_SCALAR);	1006	CALL_CALL (cv_cf_do_invoke, G_SCALAR);
945	count = count > 0 ? POPi : 0;	1007	count = count > 0 ? POPi : 0;
946		1008
947	CALL_END;	1009	CALL_END;
948		1010
949	return count;	1011	return count;
950	}	1012	}
951		1013
952	SV *	1014	static SV *
953	cfperl_result (int idx)	1015	cfperl_result (int idx)
954	{	1016	{
955	AV *av = get_av ("cfperl::invoke_results", 0);	1017	AV *av = get_av ("cf::INVOKE_RESULTS", 0);
956	if (!av)	1018	if (!av)
957	return &PL_sv_undef;	1019	return &PL_sv_undef;
958		1020
959	SV **sv = av_fetch (av, idx, 0);	1021	SV **sv = av_fetch (av, idx, 0);
960	if (!sv)	1022	if (!sv)
…		…
974	{	1036	{
975	return SvNV (cfperl_result (idx));	1037	return SvNV (cfperl_result (idx));
976	}	1038	}
977		1039
978	/////////////////////////////////////////////////////////////////////////////	1040	/////////////////////////////////////////////////////////////////////////////
		1041	// various c++ => perl glue functions
		1042
		1043	void
		1044	cfperl_tick ()
		1045	{
		1046	tick_pending = 1;
		1047
		1048	if (tick_inhibit)
		1049	return;
		1050
		1051	tick_pending = 0;
		1052
		1053	dSP;
		1054
		1055	PUSHMARK (SP);
		1056	PUTBACK;
		1057	call_pvsv (cv_cf_tick, G_DISCARD \| G_VOID);
		1058
		1059	SvNV_set (sv_next_tick, get_next_tick ()); SvNOK_only (sv_next_tick);
		1060	}
979		1061
980	void	1062	void
981	cfperl_emergency_save ()	1063	cfperl_emergency_save ()
982	{	1064	{
983	CALL_BEGIN (0);	1065	CALL_BEGIN (0);
…		…
1003	CALL_CALL ("ext::books::make_book", G_VOID);	1085	CALL_CALL ("ext::books::make_book", G_VOID);
1004	CALL_END;	1086	CALL_END;
1005	}	1087	}
1006		1088
1007	void	1089	void
1008	cfperl_send_msg (client ns, int color, const char type, const char *msg)	1090	cfperl_send_msg (client *ns, int color, const_utf8_string type, const_utf8_string msg)
1009	{	1091	{
1010	CALL_BEGIN (4);	1092	CALL_BEGIN (4);
1011	CALL_ARG (ns);	1093	CALL_ARG (ns);
1012	CALL_ARG (color);
1013	CALL_ARG (type);	1094	CALL_ARG (type);
1014	CALL_ARG_SV (newSVpv_utf8 (msg));	1095	CALL_ARG_SV (newSVpv_utf8 (msg));
		1096	CALL_ARG (color);
1015	CALL_CALL ("cf::client::send_msg", G_VOID);	1097	CALL_CALL (cv_cf_client_send_msg, G_VOID);
1016	CALL_END;	1098	CALL_END;
1017	}	1099	}
1018		1100
		1101	int
		1102	cfperl_can_merge (object ob1, object ob2)
		1103	{
		1104	int can;
		1105
		1106	CALL_BEGIN (2);
		1107	CALL_ARG (ob1);
		1108	CALL_ARG (ob2);
		1109	CALL_CALL (cv_cf__can_merge, G_SCALAR);
		1110	can = count && SvTRUE (TOPs);
		1111	CALL_END;
		1112
		1113	return can;
		1114	}
		1115
		1116	void
		1117	cfperl_mapscript_activate (object ob, int state, object activator, object *originator)
		1118	{
		1119	CALL_BEGIN (4);
		1120	CALL_ARG (ob);
		1121	CALL_ARG (state);
		1122	CALL_ARG (activator);
		1123	CALL_ARG (originator);
		1124	CALL_CALL ("cf::mapscript::activate", G_VOID);
		1125	CALL_END;
		1126	}
		1127
		1128	player *
		1129	player::find (const_utf8_string name)
		1130	{
		1131	CALL_BEGIN (1);
		1132	CALL_ARG (name);
		1133	CALL_CALL ("cf::player::find", G_SCALAR);
		1134
		1135	player *retval = 0;
		1136	if (count) sv_to (POPs, retval);
		1137
		1138	CALL_END;
		1139
		1140	return retval;
		1141	}
		1142
1019	maptile *	1143	maptile *
		1144	find_style (const_utf8_string dirname, const_utf8_string stylename, int difficulty, bool recurse)
		1145	{
		1146	CALL_BEGIN (4);
		1147	CALL_ARG (dirname);
		1148	CALL_ARG (stylename);
		1149	CALL_ARG (difficulty);
		1150	CALL_ARG (recurse);
		1151	CALL_CALL ("ext::map_random::find_style", G_SCALAR);
		1152
		1153	maptile *retval = 0;
		1154	if (count) sv_to (POPs, retval);
		1155
		1156	CALL_END;
		1157
		1158	return retval;
		1159	}
		1160
		1161	maptile *
1020	maptile::find_sync (const char path, maptile origin)	1162	maptile::find_sync (const_utf8_string path, maptile *origin)
1021	{	1163	{
1022	CALL_BEGIN (2);	1164	CALL_BEGIN (2);
1023	CALL_ARG (path);	1165	CALL_ARG (path);
1024	CALL_ARG (origin);	1166	CALL_ARG (origin);
1025	CALL_CALL ("cf::map::find_sync", G_SCALAR);	1167	CALL_CALL ("cf::map::find_sync", G_SCALAR);
1026		1168
1027	maptile *retval;	1169	maptile *retval = 0;
1028
1029	if (count)
1030	sv_to (POPs, retval);	1170	if (count) sv_to (POPs, retval);
1031	else
1032	retval = 0;
1033		1171
1034	CALL_END;	1172	CALL_END;
1035		1173
1036	return retval;	1174	return retval;
1037	}	1175	}
1038		1176
1039	maptile *	1177	maptile *
1040	maptile::find_async (const char path, maptile origin)	1178	maptile::find_async (const_utf8_string path, maptile *origin, bool load)
1041	{	1179	{
1042	CALL_BEGIN (2);	1180	CALL_BEGIN (3);
1043	CALL_ARG (path);	1181	CALL_ARG (path);
1044	CALL_ARG (origin);	1182	CALL_ARG (origin);
		1183	CALL_ARG (load);
1045	CALL_CALL ("cf::map::find_async", G_SCALAR);	1184	CALL_CALL ("cf::map::find_async", G_SCALAR);
1046		1185
1047	maptile *retval;	1186	maptile *retval = 0;
1048
1049	if (count)
1050	sv_to (POPs, retval);	1187	if (count) sv_to (POPs, retval);
1051	else
1052	retval = 0;
1053		1188
1054	CALL_END;	1189	CALL_END;
1055		1190
1056	return retval;	1191	return retval;
1057	}	1192	}
…		…
1060	maptile::do_load_sync ()	1195	maptile::do_load_sync ()
1061	{	1196	{
1062	CALL_BEGIN (1);	1197	CALL_BEGIN (1);
1063	CALL_ARG (this);	1198	CALL_ARG (this);
1064	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);	1199	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);
1065	CALL_END;
1066	}
1067
1068	void
1069	maptile::change_all_map_light (int change)
1070	{
1071	CALL_BEGIN (1);
1072	CALL_ARG (change);
1073	CALL_CALL ("cf::map::change_all_map_light", G_VOID);
1074	CALL_END;	1200	CALL_END;
1075	}	1201	}
1076		1202
1077	void	1203	void
1078	object::enter_exit (object *exit)	1204	object::enter_exit (object *exit)
…		…
1086	CALL_CALL ("cf::object::player::enter_exit", G_VOID);	1212	CALL_CALL ("cf::object::player::enter_exit", G_VOID);
1087	CALL_END;	1213	CALL_END;
1088	}	1214	}
1089		1215
1090	void	1216	void
1091	log_backtrace (const char *msg)	1217	object::player_goto (const_utf8_string path, int x, int y)
		1218	{
		1219	if (type != PLAYER)
		1220	return;
		1221
		1222	CALL_BEGIN (4);
		1223	CALL_ARG (this);
		1224	CALL_ARG (path);
		1225	CALL_ARG (x);
		1226	CALL_ARG (y);
		1227	CALL_CALL ("cf::object::player::goto", G_VOID);
		1228	CALL_END;
		1229	}
		1230
		1231	const_utf8_string
		1232	object::ref () const
		1233	{
		1234	if (type == PLAYER)
		1235	return format ("player/<1.%llx>/%s", (unsigned long long)uuid.seq, &name);
		1236	else
		1237	// TODO: should be able to save references within the same map, at least
		1238	return 0;
		1239	}
		1240
		1241	object *
		1242	object::deref (const_utf8_string ref)
		1243	{
		1244	object *retval = 0;
		1245
		1246	if (ref)
		1247	{
		1248	CALL_BEGIN (1);
		1249	CALL_ARG (ref);
		1250	CALL_CALL ("cf::object::deref", G_SCALAR);
		1251
		1252	if (count)
		1253	sv_to (POPs, retval);
		1254
		1255	CALL_END;
		1256	}
		1257
		1258	return retval;
		1259	}
		1260
		1261	void
		1262	log_backtrace (const_utf8_string msg)
1092	{	1263	{
1093	#if HAVE_BACKTRACE	1264	#if HAVE_BACKTRACE
1094	void *addr [20];	1265	void *addr [20];
1095	int size = backtrace (addr, 20);	1266	int size = backtrace (addr, 20);
1096		1267
…		…
1101	CALL_CALL ("cf::_log_backtrace", G_VOID);	1272	CALL_CALL ("cf::_log_backtrace", G_VOID);
1102	CALL_END;	1273	CALL_END;
1103	#endif	1274	#endif
1104	}	1275	}
1105		1276
		1277	bool
		1278	is_match_expr (const_utf8_string expr)
		1279	{
		1280	return !strncmp (expr, "match ", sizeof ("match ") - 1);
		1281	}
		1282
		1283	bool
		1284	match (const_utf8_string expr, object ob, object self, object source, object originator)
		1285	{
		1286	if (!strncmp (expr, "match ", sizeof ("match ") - 1))
		1287	expr += sizeof ("match ") - 1;
		1288
		1289	CALL_BEGIN (5);
		1290	CALL_ARG (expr);
		1291	CALL_ARG (ob);
		1292	CALL_ARG (self);
		1293	CALL_ARG (source);
		1294	CALL_ARG (originator);
		1295	CALL_CALL (cv_cf_match_match, G_SCALAR);
		1296
		1297	bool matched = count && SvTRUE (TOPs);
		1298
		1299	CALL_END;
		1300
		1301	return matched;
		1302	}
		1303
		1304	object *
		1305	match_one (const_utf8_string expr, object ob, object self, object source, object originator)
		1306	{
		1307	if (!strncmp (expr, "match ", sizeof ("match ") - 1))
		1308	expr += sizeof ("match ") - 1;
		1309
		1310	CALL_BEGIN (5);
		1311	CALL_ARG (expr);
		1312	CALL_ARG (ob);
		1313	CALL_ARG (self);
		1314	CALL_ARG (source);
		1315	CALL_ARG (originator);
		1316	CALL_CALL (cv_cf_match_match, G_ARRAY);
		1317
		1318	object *one = 0;
		1319
		1320	if (count)
		1321	sv_to (TOPs, one);
		1322
		1323	CALL_END;
		1324
		1325	return one;
		1326	}
		1327
1106	/////////////////////////////////////////////////////////////////////////////	1328	/////////////////////////////////////////////////////////////////////////////
1107		1329
1108	struct EventAPI *watcher_base::GEventAPI;	1330	struct EVAPI *evapi::GEVAPI;
1109	struct CoroAPI *coroapi::GCoroAPI;	1331	struct CoroAPI *coroapi::GCoroAPI;
1110		1332
1111	int coroapi::cede_counter;	1333	void
1112	tstamp coroapi::next_cede;
1113
1114	void coroapi::do_cede_to_tick ()	1334	coroapi::do_cede_to_tick ()
1115	{	1335	{
1116	cede_counter = 0;	1336	cede_pending = 0;
1117
1118	cede ();	1337	cede ();
1119
1120	next_cede += (TICK / CEDES_PER_TICK) * 0.99;
1121	if (next_cede > SvNV (sv_next_tick) - 0.02)
1122	next_cede = SvNV (sv_next_tick);
1123	}
1124
1125	void coroapi::do_cede_every ()
1126	{
1127	cede_counter = 0;
1128
1129	if (coroapi::nready ())
1130	coroapi::cede ();
1131	}
1132
1133	void coroapi::do_cede_to_tick_every ()
1134	{
1135	cede_counter = 0;
1136
1137	cede_to_tick ();
1138	}	1338	}
1139		1339
1140	void	1340	void
1141	coroapi::wait_for_tick ()	1341	coroapi::wait_for_tick ()
1142	{	1342	{
…		…
1151	CALL_BEGIN (0);	1351	CALL_BEGIN (0);
1152	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);	1352	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);
1153	CALL_END;	1353	CALL_END;
1154	}	1354	}
1155		1355
		1356	void
		1357	iow::poll (int events)
		1358	{
		1359	if (events != this->events)
		1360	{
		1361	int active = ev_is_active ((ev_io *)this);
		1362	if (active) stop ();
		1363	ev_io_set ((ev_io *)this, fd, events);
		1364	if (active) start ();
		1365	}
		1366	}
		1367
1156	static void	1368	static void
1157	iw_dispatch (pe_event *ev)
1158	{
1159	iw w = (iw )ev->ext_data;
1160	w->call (*w);
1161	}
1162
1163	void
1164	iw::alloc ()
1165	{
1166	pe = GEventAPI->new_idle (0, 0);
1167
1168	WaREENTRANT_off (pe);
1169	pe->base.callback = (void *)iw_dispatch;
1170	pe->base.ext_data = (void *)this;
1171	}
1172
1173	static void iow_dispatch (pe_event *ev)
1174	{
1175	iow w = (iow )ev->ext_data;
1176	w->call (w, ((pe_ioevent )ev)->got);
1177	}
1178
1179	void
1180	iow::alloc ()
1181	{
1182	pe = GEventAPI->new_io (0, 0);
1183
1184	WaREENTRANT_off (pe);
1185	pe->base.callback = (void *)iow_dispatch;
1186	pe->base.ext_data = (void *)this;
1187
1188	pe->fd = -1;
1189	pe->poll = 0;
1190	}
1191
1192	void
1193	iow::fd (int fd)
1194	{
1195	pe->fd = fd;
1196	}
1197
1198	int
1199	iow::poll ()
1200	{
1201	return pe->poll;
1202	}
1203
1204	void
1205	iow::poll (int events)
1206	{
1207	if (pe->poll != events)
1208	{
1209	if (pe->poll) stop ();
1210	pe->poll = events;
1211	if (pe->poll) start ();
1212	}
1213	}
1214
1215	void
1216	_connect_to_perl ()	1369	_connect_to_perl_1 ()
1217	{	1370	{
1218	stash_cf = gv_stashpv ("cf" , 1);	1371	stash_cf = gv_stashpv ("cf", 1);
1219		1372
1220	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);	1373	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);
1221	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);	1374	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);
1222	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);	1375	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);
1223	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);	1376	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);
		1377	stash_cf_mapspace_wrap = gv_stashpv ("cf::mapspace::wrap" , 1);
1224	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);	1378	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);
1225	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);	1379	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
1226	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);	1380	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
1227	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);	1381	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
1228	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);	1382	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
1229		1383
		1384	sv_now = get_sv ("cf::NOW" , 1); SvUPGRADE (sv_now , SVt_NV);
1230	sv_runtime = get_sv ("cf::RUNTIME" , 1); sv_upgrade (sv_runtime , SVt_NV);	1385	sv_runtime = get_sv ("cf::RUNTIME" , 1); SvUPGRADE (sv_runtime , SVt_NV);
		1386	sv_tick_start = get_sv ("cf::TICK_START", 1); SvUPGRADE (sv_tick_start, SVt_NV);
1231	sv_next_tick = get_sv ("cf::NEXT_TICK", 1); sv_upgrade (sv_next_tick, SVt_NV);	1387	sv_next_tick = get_sv ("cf::NEXT_TICK" , 1); SvUPGRADE (sv_next_tick , SVt_NV);
1232		1388
1233	cb_global = get_av ("cf::CB_GLOBAL", 1);	1389	cb_global = get_av ("cf::CB_GLOBAL", 1);
1234	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);	1390	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
1235	cb_object = get_av ("cf::CB_OBJECT", 1);	1391	cb_object = get_av ("cf::CB_OBJECT", 1);
1236	cb_player = get_av ("cf::CB_PLAYER", 1);	1392	cb_player = get_av ("cf::CB_PLAYER", 1);
1237	cb_client = get_av ("cf::CB_CLIENT", 1);	1393	cb_client = get_av ("cf::CB_CLIENT", 1);
1238	cb_type = get_av ("cf::CB_TYPE" , 1);	1394	cb_type = get_av ("cf::CB_TYPE" , 1);
1239	cb_map = get_av ("cf::CB_MAP" , 1);	1395	cb_map = get_av ("cf::CB_MAP" , 1);
1240	}	1396	}
1241		1397
		1398	static void
		1399	_connect_to_perl_2 ()
		1400	{
		1401	cv_cf_do_invoke = (SV *)get_cv ("cf::do_invoke" , 0); assert (cv_cf_do_invoke);
		1402	cv_cf__can_merge = (SV *)get_cv ("cf::_can_merge" , 0); assert (cv_cf__can_merge);
		1403	cv_cf_client_send_msg = (SV *)get_cv ("cf::client::send_msg", 0); assert (cv_cf_client_send_msg);
		1404	cv_cf_tick = (SV *)get_cv ("cf::tick" , 0); assert (cv_cf_tick);
		1405	cv_cf_match_match = (SV *)get_cv ("cf::match::match" , 0); assert (cv_cf_match_match);
		1406	}
		1407
1242	MODULE = cf PACKAGE = cf PREFIX = cf_	1408	MODULE = cf PACKAGE = cf PREFIX = cf_
1243		1409
1244	BOOT:	1410	BOOT:
1245	{	1411	{
1246	I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;	1412	I_EV_API (PACKAGE); evapi::GEVAPI = GEVAPI;
1247	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;	1413	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
1248		1414
1249	_connect_to_perl ();	1415	_connect_to_perl_1 ();
1250		1416
1251	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));	1417	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
1252		1418
1253	//{	1419	//{
1254	// require_pv ("Time::HiRes");	1420	// require_pv ("Time::HiRes");
…		…
1262	static const struct {	1428	static const struct {
1263	const char *name;	1429	const char *name;
1264	IV iv;	1430	IV iv;
1265	} *civ, const_iv[] = {	1431	} *civ, const_iv[] = {
1266	# define const_iv(name) { # name, (IV)name },	1432	# define const_iv(name) { # name, (IV)name },
		1433	# include "const_iv.h"
		1434	# define def(uc, lc, name, plus, change) const_iv (AT_ ## uc) const_iv (ATNR_ ## uc)
		1435	# include "attackinc.h"
		1436	# undef def
		1437	# define def(uc, flags) const_iv (SK_ ## uc)
		1438	# include "skillinc.h"
		1439	# undef def
		1440
1267	const_iv (llevError) const_iv (llevInfo) const_iv (llevDebug) const_iv (llevMonster)	1441	const_iv (llevError) const_iv (llevInfo) const_iv (llevDebug) const_iv (llevMonster)
1268	const_iv (logBacktrace)	1442	const_iv (logBacktrace)
1269		1443
1270	const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)	1444	const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)
1271		1445
1272	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)	1446	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)
1273		1447
1274	const_iv (MAX_TIME)	1448	const_iv (MAX_TIME)
1275		1449	const_iv (MAXSOCKBUF)
1276	const_iv (NUM_BODY_LOCATIONS)
1277	const_iv (body_range) const_iv (body_shield) const_iv (body_combat)
1278	const_iv (body_arm) const_iv (body_torso) const_iv (body_head)
1279	const_iv (body_neck) const_iv (body_skill) const_iv (body_finger)
1280	const_iv (body_shoulder) const_iv (body_foot) const_iv (body_hand)
1281	const_iv (body_wrist) const_iv (body_waist)
1282
1283	const_iv (PLAYER) const_iv (TRANSPORT) const_iv (ROD) const_iv (TREASURE)
1284	const_iv (POTION) const_iv (FOOD) const_iv (POISON) const_iv (BOOK)
1285	const_iv (CLOCK) const_iv (ARROW) const_iv (BOW) const_iv (WEAPON)
1286	const_iv (ARMOUR) const_iv (PEDESTAL) const_iv (ALTAR) const_iv (LOCKED_DOOR)
1287	const_iv (SPECIAL_KEY) const_iv (MAP) const_iv (DOOR) const_iv (KEY)
1288	const_iv (TIMED_GATE) const_iv (TRIGGER) const_iv (GRIMREAPER) const_iv (MAGIC_EAR)
1289	const_iv (TRIGGER_BUTTON) const_iv (TRIGGER_ALTAR) const_iv (TRIGGER_PEDESTAL) const_iv (SHIELD)
1290	const_iv (HELMET) const_iv (HORN) const_iv (MONEY) const_iv (CLASS)
1291	const_iv (GRAVESTONE) const_iv (AMULET) const_iv (PLAYERMOVER) const_iv (TELEPORTER)
1292	const_iv (CREATOR) const_iv (SKILL) const_iv (EARTHWALL) const_iv (GOLEM)
1293	const_iv (THROWN_OBJ) const_iv (BLINDNESS) const_iv (GOD) const_iv (DETECTOR)
1294	const_iv (TRIGGER_MARKER) const_iv (DEAD_OBJECT) const_iv (DRINK) const_iv (MARKER)
1295	const_iv (HOLY_ALTAR) const_iv (PLAYER_CHANGER) const_iv (BATTLEGROUND) const_iv (PEACEMAKER)
1296	const_iv (GEM) const_iv (FIREWALL) const_iv (ANVIL) const_iv (CHECK_INV)
1297	const_iv (MOOD_FLOOR) const_iv (EXIT) const_iv (ENCOUNTER) const_iv (SHOP_FLOOR)
1298	const_iv (SHOP_MAT) const_iv (RING) const_iv (FLOOR) const_iv (FLESH)
1299	const_iv (INORGANIC) const_iv (SKILL_TOOL) const_iv (LIGHTER) const_iv (BUILDABLE_WALL)
1300	const_iv (MISC_OBJECT) const_iv (LAMP) const_iv (DUPLICATOR) const_iv (SPELLBOOK)
1301	const_iv (CLOAK) const_iv (SPINNER) const_iv (GATE) const_iv (BUTTON)
1302	const_iv (CF_HANDLE) const_iv (HOLE) const_iv (TRAPDOOR) const_iv (SIGN)
1303	const_iv (BOOTS) const_iv (GLOVES) const_iv (SPELL) const_iv (SPELL_EFFECT)
1304	const_iv (CONVERTER) const_iv (BRACERS) const_iv (POISONING) const_iv (SAVEBED)
1305	const_iv (WAND) const_iv (SCROLL) const_iv (DIRECTOR) const_iv (GIRDLE)
1306	const_iv (FORCE) const_iv (POTION_EFFECT) const_iv (EVENT_CONNECTOR) const_iv (CLOSE_CON)
1307	const_iv (CONTAINER) const_iv (ARMOUR_IMPROVER) const_iv (WEAPON_IMPROVER) const_iv (SKILLSCROLL)
1308	const_iv (DEEP_SWAMP) const_iv (IDENTIFY_ALTAR) const_iv (MENU) const_iv (RUNE)
1309	const_iv (TRAP) const_iv (POWER_CRYSTAL) const_iv (CORPSE) const_iv (DISEASE)
1310	const_iv (SYMPTOM) const_iv (BUILDER) const_iv (MATERIAL) const_iv (ITEM_TRANSFORMER)
1311
1312	const_iv (NUM_TYPES) const_iv (NUM_SUBTYPES)
1313
1314	const_iv (ST_BD_BUILD) const_iv (ST_BD_REMOVE)
1315	const_iv (ST_MAT_FLOOR) const_iv (ST_MAT_WALL) const_iv (ST_MAT_ITEM)
1316
1317	const_iv (AT_PHYSICAL) const_iv (AT_MAGIC) const_iv (AT_FIRE) const_iv (AT_ELECTRICITY)
1318	const_iv (AT_COLD) const_iv (AT_CONFUSION) const_iv (AT_ACID) const_iv (AT_DRAIN)
1319	const_iv (AT_WEAPONMAGIC) const_iv (AT_GHOSTHIT) const_iv (AT_POISON) const_iv (AT_SLOW)
1320	const_iv (AT_PARALYZE) const_iv (AT_TURN_UNDEAD) const_iv (AT_FEAR) const_iv (AT_CANCELLATION)
1321	const_iv (AT_DEPLETE) const_iv (AT_DEATH) const_iv (AT_CHAOS) const_iv (AT_COUNTERSPELL)
1322	const_iv (AT_GODPOWER) const_iv (AT_HOLYWORD) const_iv (AT_BLIND) const_iv (AT_INTERNAL)
1323	const_iv (AT_LIFE_STEALING) const_iv (AT_DISEASE)
1324
1325	const_iv (WEAP_HIT) const_iv (WEAP_SLASH) const_iv (WEAP_PIERCE) const_iv (WEAP_CLEAVE)
1326	const_iv (WEAP_SLICE) const_iv (WEAP_STAB) const_iv (WEAP_WHIP) const_iv (WEAP_CRUSH)
1327	const_iv (WEAP_BLUD)
1328
1329	const_iv (FLAG_ALIVE) const_iv (FLAG_WIZ) const_iv (FLAG_REMOVED) const_iv (FLAG_FREED)
1330	const_iv (FLAG_APPLIED) const_iv (FLAG_UNPAID) const_iv (FLAG_USE_SHIELD)
1331	const_iv (FLAG_NO_PICK) const_iv (FLAG_ANIMATE) const_iv (FLAG_MONSTER) const_iv (FLAG_FRIENDLY)
1332	const_iv (FLAG_GENERATOR) const_iv (FLAG_IS_THROWN) const_iv (FLAG_AUTO_APPLY) const_iv (FLAG_PLAYER_SOLD)
1333	const_iv (FLAG_SEE_INVISIBLE) const_iv (FLAG_CAN_ROLL) const_iv (FLAG_OVERLAY_FLOOR) const_iv (FLAG_IS_TURNABLE)
1334	const_iv (FLAG_IS_USED_UP) const_iv (FLAG_IDENTIFIED) const_iv (FLAG_REFLECTING) const_iv (FLAG_CHANGING)
1335	const_iv (FLAG_SPLITTING) const_iv (FLAG_HITBACK) const_iv (FLAG_STARTEQUIP) const_iv (FLAG_BLOCKSVIEW)
1336	const_iv (FLAG_UNDEAD) const_iv (FLAG_SCARED) const_iv (FLAG_UNAGGRESSIVE) const_iv (FLAG_REFL_MISSILE)
1337	const_iv (FLAG_REFL_SPELL) const_iv (FLAG_NO_MAGIC) const_iv (FLAG_NO_FIX_PLAYER) const_iv (FLAG_IS_LIGHTABLE)
1338	const_iv (FLAG_TEAR_DOWN) const_iv (FLAG_RUN_AWAY) const_iv (FLAG_PICK_UP) const_iv (FLAG_UNIQUE)
1339	const_iv (FLAG_NO_DROP) const_iv (FLAG_WIZCAST) const_iv (FLAG_CAST_SPELL) const_iv (FLAG_USE_SCROLL)
1340	const_iv (FLAG_USE_RANGE) const_iv (FLAG_USE_BOW) const_iv (FLAG_USE_ARMOUR) const_iv (FLAG_USE_WEAPON)
1341	const_iv (FLAG_USE_RING) const_iv (FLAG_READY_RANGE) const_iv (FLAG_READY_BOW) const_iv (FLAG_XRAYS)
1342	const_iv (FLAG_NO_APPLY) const_iv (FLAG_IS_FLOOR) const_iv (FLAG_LIFESAVE) const_iv (FLAG_NO_STRENGTH)
1343	const_iv (FLAG_SLEEP) const_iv (FLAG_STAND_STILL) const_iv (FLAG_RANDOM_MOVE) const_iv (FLAG_ONLY_ATTACK)
1344	const_iv (FLAG_CONFUSED) const_iv (FLAG_STEALTH) const_iv (FLAG_WIZPASS) const_iv (FLAG_IS_LINKED)
1345	const_iv (FLAG_CURSED) const_iv (FLAG_DAMNED) const_iv (FLAG_SEE_ANYWHERE) const_iv (FLAG_KNOWN_MAGICAL)
1346	const_iv (FLAG_KNOWN_CURSED) const_iv (FLAG_CAN_USE_SKILL) const_iv (FLAG_BEEN_APPLIED) const_iv (FLAG_READY_SCROLL)
1347	const_iv (FLAG_USE_ROD) const_iv (FLAG_USE_HORN) const_iv (FLAG_MAKE_INVIS) const_iv (FLAG_INV_LOCKED)
1348	const_iv (FLAG_IS_WOODED) const_iv (FLAG_IS_HILLY) const_iv (FLAG_READY_SKILL) const_iv (FLAG_READY_WEAPON)
1349	const_iv (FLAG_NO_SKILL_IDENT) const_iv (FLAG_BLIND) const_iv (FLAG_SEE_IN_DARK) const_iv (FLAG_IS_CAULDRON)
1350	const_iv (FLAG_NO_STEAL) const_iv (FLAG_ONE_HIT) const_iv (FLAG_CLIENT_SENT) const_iv (FLAG_BERSERK)
1351	const_iv (FLAG_NEUTRAL) const_iv (FLAG_NO_ATTACK) const_iv (FLAG_NO_DAMAGE) const_iv (FLAG_OBJ_ORIGINAL)
1352	const_iv (FLAG_OBJ_SAVE_ON_OVL) const_iv (FLAG_ACTIVATE_ON_PUSH) const_iv (FLAG_ACTIVATE_ON_RELEASE) const_iv (FLAG_IS_WATER)
1353	const_iv (FLAG_CONTENT_ON_GEN) const_iv (FLAG_IS_A_TEMPLATE) const_iv (FLAG_IS_BUILDABLE)
1354	const_iv (FLAG_DESTROY_ON_DEATH) const_iv (FLAG_NO_MAP_SAVE)
1355
1356	const_iv (NDI_BLACK) const_iv (NDI_WHITE) const_iv (NDI_NAVY) const_iv (NDI_RED)
1357	const_iv (NDI_ORANGE) const_iv (NDI_BLUE) const_iv (NDI_DK_ORANGE) const_iv (NDI_GREEN)
1358	const_iv (NDI_LT_GREEN) const_iv (NDI_GREY) const_iv (NDI_BROWN) const_iv (NDI_GOLD)
1359	const_iv (NDI_TAN) const_iv (NDI_MAX_COLOR) const_iv (NDI_COLOR_MASK) const_iv (NDI_UNIQUE)
1360	const_iv (NDI_ALL)
1361		1450
1362	const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE)	1451	const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE)
1363	const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF)	1452	const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF)
1364		1453
1365	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_DAMAGE)	1454	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_LEVEL)
1366
1367	const_iv (SP_RAISE_DEAD)
1368	const_iv (SP_RUNE)
1369	const_iv (SP_MAKE_MARK)
1370	const_iv (SP_BOLT)
1371	const_iv (SP_BULLET)
1372	const_iv (SP_EXPLOSION)
1373	const_iv (SP_CONE)
1374	const_iv (SP_BOMB)
1375	const_iv (SP_WONDER)
1376	const_iv (SP_SMITE)
1377	const_iv (SP_MAGIC_MISSILE)
1378	const_iv (SP_SUMMON_GOLEM)
1379	const_iv (SP_DIMENSION_DOOR)
1380	const_iv (SP_MAGIC_MAPPING)
1381	const_iv (SP_MAGIC_WALL)
1382	const_iv (SP_DESTRUCTION)
1383	const_iv (SP_PERCEIVE_SELF)
1384	const_iv (SP_WORD_OF_RECALL)
1385	const_iv (SP_INVISIBLE)
1386	const_iv (SP_PROBE)
1387	const_iv (SP_HEALING)
1388	const_iv (SP_CREATE_FOOD)
1389	const_iv (SP_EARTH_TO_DUST)
1390	const_iv (SP_CHANGE_ABILITY)
1391	const_iv (SP_BLESS)
1392	const_iv (SP_CURSE)
1393	const_iv (SP_SUMMON_MONSTER)
1394	const_iv (SP_CHARGING)
1395	const_iv (SP_POLYMORPH)
1396	const_iv (SP_ALCHEMY)
1397	const_iv (SP_REMOVE_CURSE)
1398	const_iv (SP_IDENTIFY)
1399	const_iv (SP_DETECTION)
1400	const_iv (SP_MOOD_CHANGE)
1401	const_iv (SP_MOVING_BALL)
1402	const_iv (SP_SWARM)
1403	const_iv (SP_CHANGE_MANA)
1404	const_iv (SP_DISPEL_RUNE)
1405	const_iv (SP_CREATE_MISSILE)
1406	const_iv (SP_CONSECRATE)
1407	const_iv (SP_ANIMATE_WEAPON)
1408	const_iv (SP_LIGHT)
1409	const_iv (SP_CHANGE_MAP_LIGHT)
1410	const_iv (SP_FAERY_FIRE)
1411	const_iv (SP_CAUSE_DISEASE)
1412	const_iv (SP_AURA)
1413	const_iv (SP_TOWN_PORTAL)
1414	const_iv (SP_PARTY_SPELL)
1415		1455
1416	const_iv (F_APPLIED) const_iv (F_LOCATION) const_iv (F_UNPAID) const_iv (F_MAGIC)	1456	const_iv (F_APPLIED) const_iv (F_LOCATION) const_iv (F_UNPAID) const_iv (F_MAGIC)
1417	const_iv (F_CURSED) const_iv (F_DAMNED) const_iv (F_OPEN) const_iv (F_NOPICK)	1457	const_iv (F_CURSED) const_iv (F_DAMNED) const_iv (F_OPEN) const_iv (F_NOPICK)
1418	const_iv (F_LOCKED)	1458	const_iv (F_LOCKED)
1419		1459
1420	const_iv (F_BUY) const_iv (F_SHOP) const_iv (F_SELL)
1421
1422	const_iv (P_BLOCKSVIEW) const_iv (P_PLAYER) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE)	1460	const_iv (P_BLOCKSVIEW) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE)
1423	const_iv (P_NO_CLERIC) const_iv (P_OUT_OF_MAP) const_iv (P_NEW_MAP) const_iv (P_UPTODATE)	1461	const_iv (P_NO_CLERIC) const_iv (P_OUT_OF_MAP) const_iv (P_NEW_MAP) const_iv (P_UPTODATE)
1424		1462
1425	const_iv (UP_OBJ_INSERT) const_iv (UP_OBJ_REMOVE) const_iv (UP_OBJ_CHANGE) const_iv (UP_OBJ_FACE)
1426
1427	const_iv (INS_NO_MERGE) const_iv (INS_ABOVE_FLOOR_ONLY) const_iv (INS_NO_WALK_ON)
1428	const_iv (INS_ON_TOP) const_iv (INS_BELOW_ORIGINATOR) const_iv (INS_MAP_LOAD)
1429
1430	const_iv (WILL_APPLY_HANDLE) const_iv (WILL_APPLY_TREASURE) const_iv (WILL_APPLY_EARTHWALL)
1431	const_iv (WILL_APPLY_DOOR) const_iv (WILL_APPLY_FOOD)
1432
1433	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)	1463	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)
1434
1435	const_iv (M_PAPER) const_iv (M_IRON) const_iv (M_GLASS) const_iv (M_LEATHER)
1436	const_iv (M_WOOD) const_iv (M_ORGANIC) const_iv (M_STONE) const_iv (M_CLOTH)
1437	const_iv (M_ADAMANT) const_iv (M_LIQUID) const_iv (M_SOFT_METAL) const_iv (M_BONE)
1438	const_iv (M_ICE) const_iv (M_SPECIAL)
1439		1464
1440	const_iv (SK_EXP_ADD_SKILL) const_iv (SK_EXP_TOTAL) const_iv (SK_EXP_NONE)	1465	const_iv (SK_EXP_ADD_SKILL) const_iv (SK_EXP_TOTAL) const_iv (SK_EXP_NONE)
1441	const_iv (SK_SUBTRACT_SKILL_EXP) const_iv (SK_EXP_SKILL_ONLY)	1466	const_iv (SK_SUBTRACT_SKILL_EXP) const_iv (SK_EXP_SKILL_ONLY)
1442		1467
1443	const_iv (SK_LOCKPICKING) const_iv (SK_HIDING) const_iv (SK_SMITHERY) const_iv (SK_BOWYER)
1444	const_iv (SK_JEWELER) const_iv (SK_ALCHEMY) const_iv (SK_STEALING) const_iv (SK_LITERACY)
1445	const_iv (SK_BARGAINING) const_iv (SK_JUMPING) const_iv (SK_DET_MAGIC) const_iv (SK_ORATORY)
1446	const_iv (SK_SINGING) const_iv (SK_DET_CURSE) const_iv (SK_FIND_TRAPS) const_iv (SK_MEDITATION)
1447	const_iv (SK_PUNCHING) const_iv (SK_FLAME_TOUCH) const_iv (SK_KARATE) const_iv (SK_CLIMBING)
1448	const_iv (SK_WOODSMAN) const_iv (SK_INSCRIPTION) const_iv (SK_ONE_HANDED_WEAPON) const_iv (SK_MISSILE_WEAPON)
1449	const_iv (SK_THROWING) const_iv (SK_USE_MAGIC_ITEM) const_iv (SK_DISARM_TRAPS) const_iv (SK_SET_TRAP)
1450	const_iv (SK_THAUMATURGY) const_iv (SK_PRAYING) const_iv (SK_CLAWING) const_iv (SK_LEVITATION)
1451	const_iv (SK_SUMMONING) const_iv (SK_PYROMANCY) const_iv (SK_EVOCATION) const_iv (SK_SORCERY)
1452	const_iv (SK_TWO_HANDED_WEAPON) const_iv (SK_SPARK_TOUCH) const_iv (SK_SHIVER) const_iv (SK_ACID_SPLASH)
1453	const_iv (SK_POISON_NAIL)
1454
1455	const_iv (SOUND_NEW_PLAYER) const_iv (SOUND_FIRE_ARROW) const_iv (SOUND_LEARN_SPELL) const_iv (SOUND_FUMBLE_SPELL)
1456	const_iv (SOUND_WAND_POOF) const_iv (SOUND_OPEN_DOOR) const_iv (SOUND_PUSH_PLAYER) const_iv (SOUND_PLAYER_HITS1)
1457	const_iv (SOUND_PLAYER_HITS2) const_iv (SOUND_PLAYER_HITS3) const_iv (SOUND_PLAYER_HITS4) const_iv (SOUND_PLAYER_IS_HIT1)
1458	const_iv (SOUND_PLAYER_IS_HIT2) const_iv (SOUND_PLAYER_IS_HIT3) const_iv (SOUND_PLAYER_KILLS) const_iv (SOUND_PET_IS_KILLED)
1459	const_iv (SOUND_PLAYER_DIES) const_iv (SOUND_OB_EVAPORATE) const_iv (SOUND_OB_EXPLODE) const_iv (SOUND_CLOCK)
1460	const_iv (SOUND_TURN_HANDLE) const_iv (SOUND_FALL_HOLE) const_iv (SOUND_DRINK_POISON) const_iv (SOUND_CAST_SPELL_0)
1461
1462	const_iv (PREFER_LOW) const_iv (PREFER_HIGH)
1463
1464	const_iv (ATNR_PHYSICAL) const_iv (ATNR_MAGIC) const_iv (ATNR_FIRE) const_iv (ATNR_ELECTRICITY)
1465	const_iv (ATNR_COLD) const_iv (ATNR_CONFUSION) const_iv (ATNR_ACID) const_iv (ATNR_DRAIN)
1466	const_iv (ATNR_WEAPONMAGIC) const_iv (ATNR_GHOSTHIT) const_iv (ATNR_POISON) const_iv (ATNR_SLOW)
1467	const_iv (ATNR_PARALYZE) const_iv (ATNR_TURN_UNDEAD) const_iv (ATNR_FEAR) const_iv (ATNR_CANCELLATION)
1468	const_iv (ATNR_DEPLETE) const_iv (ATNR_DEATH) const_iv (ATNR_CHAOS) const_iv (ATNR_COUNTERSPELL)
1469	const_iv (ATNR_GODPOWER) const_iv (ATNR_HOLYWORD) const_iv (ATNR_BLIND) const_iv (ATNR_INTERNAL)
1470	const_iv (ATNR_LIFE_STEALING) const_iv (ATNR_DISEASE)
1471
1472	const_iv (MAP_IN_MEMORY) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)	1468	const_iv (MAP_ACTIVE) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)
		1469	const_iv (MAP_INACTIVE)
1473		1470
1474	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)	1471	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)
1475	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)	1472	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)
1476		1473
1477	const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)	1474	const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)
1478		1475
1479	const_iv (ST_DEAD) const_iv (ST_SETUP) const_iv (ST_PLAYING) const_iv (ST_CUSTOM)
1480
1481	const_iv (IO_HEADER) const_iv (IO_OBJECTS) const_iv (IO_UNIQUES)	1476	const_iv (IO_HEADER) const_iv (IO_OBJECTS) const_iv (IO_UNIQUES)
1482
1483	// random map generator
1484	const_iv (LAYOUT_NONE) const_iv (LAYOUT_ONION) const_iv (LAYOUT_MAZE) const_iv (LAYOUT_SPIRAL)
1485	const_iv (LAYOUT_ROGUELIKE) const_iv (LAYOUT_SNAKE) const_iv (LAYOUT_SQUARE_SPIRAL)
1486
1487	const_iv (RMOPT_RANDOM) const_iv (RMOPT_CENTERED) const_iv (RMOPT_LINEAR)
1488	const_iv (RMOPT_BOTTOM_C) const_iv (RMOPT_BOTTOM_R) const_iv (RMOPT_IRR_SPACE)
1489	const_iv (RMOPT_WALL_OFF) const_iv (RMOPT_WALLS_ONLY) const_iv (RMOPT_NO_DOORS)
1490
1491	const_iv (SYMMETRY_RANDOM) const_iv (SYMMETRY_NONE) const_iv (SYMMETRY_X)
1492	const_iv (SYMMETRY_Y) const_iv (SYMMETRY_XY)
1493
1494	const_iv (GT_ENVIRONMENT) const_iv (GT_INVISIBLE) const_iv (GT_STARTEQUIP)
1495	const_iv (GT_APPLY) const_iv (GT_ONLY_GOOD) const_iv (GT_UPDATE_INV)
1496	const_iv (GT_MINIMAL)
1497	};	1477	};
1498		1478
1499	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	1479	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1500	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));	1480	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1501		1481
…		…
1518	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));	1498	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));
1519	av_push (event, newSViv (eiv->klass));	1499	av_push (event, newSViv (eiv->klass));
1520	av_store (av, eiv->iv, newRV_noinc ((SV *)event));	1500	av_store (av, eiv->iv, newRV_noinc ((SV *)event));
1521	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));	1501	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));
1522	}	1502	}
1523	}
1524		1503
		1504	// used by autogenerated BOOT sections from genacc
		1505	av_reflect = get_av ("cf::REFLECT", 1);
		1506	}
		1507
		1508	void _gv_clear (SV *gv)
		1509	CODE:
		1510	assert (SvTYPE (gv) == SVt_PVGV);
		1511	# define f(sv) { SV sv_ = (SV )(sv); sv = 0; SvREFCNT_dec (sv_); }
		1512	f (GvGP (gv)->gp_form);
		1513	f (GvGP (gv)->gp_io);
		1514	f (GvGP (gv)->gp_sv);
		1515	f (GvGP (gv)->gp_av);
		1516	f (GvGP (gv)->gp_hv);
		1517	f (GvGP (gv)->gp_cv);
		1518	GvCVGEN (gv) = 0;
		1519	GvMULTI_off (gv);
		1520	# undef f
		1521
1525	void _connect_to_perl ()	1522	void _connect_to_perl_1 ()
		1523
		1524	void _connect_to_perl_2 ()
1526		1525
1527	void _recalc_want ()	1526	void _recalc_want ()
1528		1527
		1528	# not used by default anymore
1529	void _global_reattach ()	1529	void _global_reattach ()
1530	CODE:	1530	CODE:
1531	{	1531	{
1532	// reattach to all attachable objects in the game.	1532	// reattach to all attachable objects in the game.
1533	for_all_clients (ns)	1533	for_all_clients (ns)
1534	ns->reattach ();	1534	ns->reattach ();
1535		1535
1536	for_all_objects (op)	1536	for_all_objects (op)
1537	op->reattach ();	1537	op->reattach ();
1538	}	1538	}
1539
1540	void _post_tick ()
1541	CODE:
1542	coroapi::next_cede = SvNV (sv_next_tick) - TICK * (1. - 1. / CEDES_PER_TICK);
1543		1539
1544	# support function for map-world.ext	1540	# support function for map-world.ext
1545	void _quantise (SV data_sv, SV plt_sv)	1541	void _quantise (SV data_sv, SV plt_sv)
1546	CODE:	1542	CODE:
1547	{	1543	{
…		…
1581	}	1577	}
1582		1578
1583	SvCUR_set (data_sv, dst - SvPVX (data_sv));	1579	SvCUR_set (data_sv, dst - SvPVX (data_sv));
1584	}	1580	}
1585		1581
		1582	void init_anim ()
		1583
		1584	void init_globals ()
		1585
		1586	void init_experience ()
		1587
		1588	void init_attackmess ()
		1589
		1590	void init_dynamic ()
		1591
		1592	void load_settings ()
		1593
		1594	void load_materials ()
		1595
		1596	void init_uuid ()
		1597	CODE:
		1598	UUID::init ();
		1599
		1600	void init_signals ()
		1601
		1602	void init_skills ()
		1603
		1604	void init_beforeplay ()
		1605
		1606	void evthread_start (int aiofd)
		1607
		1608	void cede_to_tick ()
		1609	CODE:
		1610	coroapi::cede_to_tick ();
		1611
		1612	NV till_tick ()
		1613	CODE:
		1614	RETVAL = SvNVX (sv_next_tick) - now ();
		1615	OUTPUT:
		1616	RETVAL
		1617
		1618	int tick_inhibit ()
		1619	CODE:
		1620	RETVAL = tick_inhibit;
		1621	OUTPUT:
		1622	RETVAL
		1623
		1624	void tick_inhibit_inc ()
		1625	CODE:
		1626	++tick_inhibit;
		1627
		1628	void tick_inhibit_dec ()
		1629	CODE:
		1630	if (!--tick_inhibit)
		1631	if (tick_pending)
		1632	{
		1633	ev_async_send (EV_DEFAULT, &tick_watcher);
		1634	coroapi::cede ();
		1635	}
		1636
		1637	void server_tick ()
		1638	CODE:
		1639	{
		1640	ev_now_update (EV_DEFAULT);
		1641	NOW = ev_now (EV_DEFAULT);
		1642	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1643	SvNV_set (sv_tick_start, NOW); SvNOK_only (sv_tick_start);
		1644	runtime = SvNVX (sv_runtime);
		1645
		1646	server_tick ();
		1647
		1648	ev_now_update (EV_DEFAULT);
		1649	NOW = ev_now (EV_DEFAULT);
		1650	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1651	runtime += TICK;
		1652	SvNV_set (sv_runtime, runtime); SvNOK_only (sv_runtime);
		1653	}
		1654
1586	NV floor (NV x)	1655	NV floor (NV x)
1587		1656
1588	NV ceil (NV x)	1657	NV ceil (NV x)
1589		1658
1590	NV rndm (...)	1659	NV rndm (...)
		1660	ALIAS:
		1661	rmg_rndm = 1
1591	CODE:	1662	CODE:
		1663	{
		1664	rand_gen &gen = ix ? rmg_rndm : rndm;
1592	switch (items)	1665	switch (items)
1593	{	1666	{
1594	case 0: RETVAL = rndm (); break;	1667	case 0: RETVAL = gen (); break;
1595	case 1: RETVAL = rndm (SvUV (ST (0))); break;	1668	case 1: RETVAL = gen (SvUV (ST (0))); break;
1596	case 2: RETVAL = rndm (SvIV (ST (0)), SvIV (ST (1))); break;	1669	case 2: RETVAL = gen (SvIV (ST (0)), SvIV (ST (1))); break;
1597	default: croak ("cf::rndm requires none, one or two parameters."); break;	1670	default: croak ("cf::rndm requires zero, one or two parameters."); break;
1598	}	1671	}
		1672	}
1599	OUTPUT:	1673	OUTPUT:
1600	RETVAL	1674	RETVAL
1601		1675
1602	NV clamp (NV value, NV min_value, NV max_value)	1676	NV clamp (NV value, NV min_value, NV max_value)
1603	CODE:	1677	CODE:
…		…
1609	CODE:	1683	CODE:
1610	RETVAL = lerp (value, min_in, max_in, min_out, max_out);	1684	RETVAL = lerp (value, min_in, max_in, min_out, max_out);
1611	OUTPUT:	1685	OUTPUT:
1612	RETVAL	1686	RETVAL
1613		1687
1614	void cede_to_tick ()	1688	const char *ordinal (int i)
1615	CODE:
1616	coroapi::cede_to_tick ();
1617		1689
1618	void server_tick ()	1690	void weaken (...)
1619	CODE:	1691	PROTOTYPE: @
1620	NOW = now ();	1692	CODE:
1621	runtime = SvNVx (sv_runtime);	1693	while (items > 0)
1622	server_tick ();	1694	sv_rvweaken (ST (--items));
1623		1695
1624	void	1696	void log_suspend ()
		1697
		1698	void log_resume ()
		1699
1625	log_backtrace (utf8_string msg)	1700	void log_backtrace (utf8_string msg)
1626		1701
1627	void
1628	LOG (int flags, utf8_string msg)	1702	void LOG (int flags, utf8_string msg)
1629	PROTOTYPE: $$	1703	PROTOTYPE: $$
1630	C_ARGS: flags, "%s", msg	1704	C_ARGS: flags, "%s", msg
1631		1705
1632	octet_string path_combine (octet_string base, octet_string path)	1706	octet_string path_combine (octet_string base, octet_string path)
1633	PROTOTYPE: $$	1707	PROTOTYPE: $$
1634		1708
1635	octet_string path_combine_and_normalize (octet_string base, octet_string path)	1709	octet_string path_combine_and_normalize (octet_string base, octet_string path)
1636	PROTOTYPE: $$	1710	PROTOTYPE: $$
1637
1638	const_octet_string
1639	get_maps_directory (octet_string path)
1640	PROTOTYPE: $
1641	ALIAS: maps_directory = 0
1642	CODE:
1643	RETVAL = create_pathname (path);
1644	OUTPUT: RETVAL
1645		1711
1646	void	1712	void
1647	sub_generation_inc ()	1713	sub_generation_inc ()
1648	CODE:	1714	CODE:
1649	PL_sub_generation++;	1715	PL_sub_generation++;
…		…
1674		1740
1675	void abort ()	1741	void abort ()
1676		1742
1677	void reset_signals ()	1743	void reset_signals ()
1678		1744
1679	void fork_abort (octet_string cause = "cf::fork_abort")	1745	void fork_abort (const_octet_string cause = "cf::fork_abort")
1680		1746
1681	void cleanup (octet_string cause, bool make_core = false)	1747	void cleanup (const_octet_string cause, bool make_core = false)
1682		1748
1683	void emergency_save ()	1749	void emergency_save ()
1684		1750
1685	void _exit (int status = EXIT_SUCCESS)	1751	void _exit (int status = EXIT_SUCCESS)
1686		1752
1687	UV sv_2watcher (SV *w)
1688	CODE:
1689	RETVAL = (UV)GEventAPI->sv_2watcher (w);
1690	OUTPUT:
1691	RETVAL
1692
1693	#if _POSIX_MEMLOCK	1753	#if _POSIX_MEMLOCK
1694		1754
1695	int mlockall (int flags = MCL_CURRENT \| MCL_FUTURE)	1755	int mlockall (int flags = MCL_CURRENT \| MCL_FUTURE)
		1756	INIT:
		1757	#if __GLIBC__
		1758	mallopt (M_TOP_PAD, 1024 * 1024);
		1759	mallopt (M_MMAP_THRESHOLD, 1024 * 1024 * 128);
		1760	mallopt (M_MMAP_MAX, 0); // likely bug-workaround, also frees memory
		1761	mallopt (M_PERTURB, 0xee); // bug-workaround for linux glibc+mlockall+calloc
		1762	#endif
1696		1763
1697	int munlockall ()	1764	int munlockall ()
1698		1765
1699	#endif	1766	#endif
		1767
		1768	int
		1769	malloc_trim (IV pad = 0)
		1770
		1771	void
		1772	mallinfo ()
		1773	PPCODE:
		1774	{
		1775	#if __GLIBC__
		1776	struct mallinfo mai = mallinfo ();
		1777	EXTEND (SP, 10*2);
		1778	PUSHs (sv_2mortal (newSVpv ("arena" , 0))); PUSHs (sv_2mortal (newSViv (mai.arena)));
		1779	PUSHs (sv_2mortal (newSVpv ("ordblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.ordblks)));
		1780	PUSHs (sv_2mortal (newSVpv ("smblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.smblks)));
		1781	PUSHs (sv_2mortal (newSVpv ("hblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblks)));
		1782	PUSHs (sv_2mortal (newSVpv ("hblkhd" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblkhd)));
		1783	PUSHs (sv_2mortal (newSVpv ("usmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.usmblks)));
		1784	PUSHs (sv_2mortal (newSVpv ("fsmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.fsmblks)));
		1785	PUSHs (sv_2mortal (newSVpv ("uordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.uordblks)));
		1786	PUSHs (sv_2mortal (newSVpv ("fordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.fordblks)));
		1787	PUSHs (sv_2mortal (newSVpv ("keepcost", 0))); PUSHs (sv_2mortal (newSViv (mai.keepcost)));
		1788	#endif
		1789	EXTEND (SP, 5*2);
		1790	PUSHs (sv_2mortal (newSVpv ("slice_alloc", 0))); PUSHs (sv_2mortal (newSVuv (slice_alloc)));
		1791	PUSHs (sv_2mortal (newSVpv ("shstr_alloc", 0))); PUSHs (sv_2mortal (newSVuv (shstr_alloc)));
		1792	PUSHs (sv_2mortal (newSVpv ("objects" , 0))); PUSHs (sv_2mortal (newSVuv (objects.size () * sizeof (object))));
		1793	PUSHs (sv_2mortal (newSVpv ("sv_count" , 0))); PUSHs (sv_2mortal (newSVuv (PL_sv_count)));
		1794	PUSHs (sv_2mortal (newSVpv ("sv_objcount", 0))); PUSHs (sv_2mortal (newSVuv (PL_sv_objcount)));
		1795	}
1700		1796
1701	int find_animation (utf8_string text)	1797	int find_animation (utf8_string text)
1702	PROTOTYPE: $	1798	PROTOTYPE: $
1703		1799
1704	int random_roll (int min, int max, object *op, int goodbad);	1800	int random_roll (int min, int max, object *op, int goodbad);
…		…
1742	RETVAL = newSVpv (resist_plus[atnr], 0);	1838	RETVAL = newSVpv (resist_plus[atnr], 0);
1743	else	1839	else
1744	XSRETURN_UNDEF;	1840	XSRETURN_UNDEF;
1745	OUTPUT: RETVAL	1841	OUTPUT: RETVAL
1746		1842
		1843	UUID
		1844	uuid_cur ()
		1845	CODE:
		1846	RETVAL = UUID::cur;
		1847	OUTPUT:
		1848	RETVAL
		1849
		1850	UUID
		1851	uuid_gen ()
		1852	CODE:
		1853	RETVAL = UUID::gen ();
		1854	OUTPUT:
		1855	RETVAL
		1856
		1857	val64
		1858	uuid_seq (UUID uuid)
		1859	CODE:
		1860	RETVAL = uuid.seq;
		1861	OUTPUT:
		1862	RETVAL
		1863
		1864	UUID
		1865	uuid_str (val64 seq)
		1866	CODE:
		1867	RETVAL.seq = seq;
		1868	OUTPUT:
		1869	RETVAL
		1870
		1871	void
		1872	coin_names ()
		1873	PPCODE:
		1874	EXTEND (SP, NUM_COINS);
		1875	for (int i = 0; i < NUM_COINS; ++i)
		1876	PUSHs (sv_2mortal (newSVpv (coins [i], 0)));
		1877
		1878	void
		1879	coin_archetypes ()
		1880	PPCODE:
		1881	EXTEND (SP, NUM_COINS);
		1882	for (int i = 0; i < NUM_COINS; ++i)
		1883	PUSHs (sv_2mortal (to_sv (archetype::find (coins [i]))));
		1884
1747	bool	1885	bool
1748	load_resource_file (octet_string filename)	1886	load_resource_file_ (octet_string filename)
		1887
		1888	void
		1889	fix_weight ()
1749		1890
1750	MODULE = cf PACKAGE = cf::attachable	1891	MODULE = cf PACKAGE = cf::attachable
1751		1892
1752	int	1893	int
1753	valid (SV *obj)	1894	valid (SV *obj)
…		…
1757	RETVAL	1898	RETVAL
1758		1899
1759	void	1900	void
1760	debug_trace (attachable *obj, bool on = true)	1901	debug_trace (attachable *obj, bool on = true)
1761	CODE:	1902	CODE:
1762	obj->flags &= ~attachable::F_DEBUG_TRACE;	1903	obj->attachable_flags &= ~attachable::F_DEBUG_TRACE;
1763	if (on)	1904	if (on)
1764	obj->flags \|= attachable::F_DEBUG_TRACE;	1905	obj->attachable_flags \|= attachable::F_DEBUG_TRACE;
1765		1906
1766	int mortals_size ()	1907	int mortals_size ()
1767	CODE:	1908	CODE:
1768	RETVAL = attachable::mortals.size ();	1909	RETVAL = attachable::mortals.size ();
1769	OUTPUT: RETVAL	1910	OUTPUT: RETVAL
…		…
1771	#object *mortals (U32 index)	1912	#object *mortals (U32 index)
1772	# CODE:	1913	# CODE:
1773	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;	1914	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;
1774	# OUTPUT: RETVAL	1915	# OUTPUT: RETVAL
1775		1916
1776	INCLUDE: $PERL $srcdir/genacc attachable ../include/cfperl.h \|	1917	INCLUDE: $PERL $srcdir/genacc attachable $srcdir/../include/util.h $srcdir/../include/cfperl.h \|
1777		1918
1778	MODULE = cf PACKAGE = cf::global	1919	MODULE = cf PACKAGE = cf::global
1779		1920
1780	int invoke (SV *klass, int event, ...)	1921	int invoke (SV *klass, int event, ...)
1781	CODE:	1922	CODE:
…		…
1785	RETVAL = gbl_ev.invoke ((event_type)event, ARG_AV (av), DT_END);	1926	RETVAL = gbl_ev.invoke ((event_type)event, ARG_AV (av), DT_END);
1786	OUTPUT: RETVAL	1927	OUTPUT: RETVAL
1787		1928
1788	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_	1929	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
1789		1930
1790	INCLUDE: $PERL $srcdir/genacc object ../include/object.h \|	1931	INCLUDE: $PERL $srcdir/genacc object $srcdir/../include/object.h \|
1791		1932
1792	int invoke (object *op, int event, ...)	1933	int invoke (object *op, int event, ...)
1793	CODE:	1934	CODE:
1794	if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");	1935	if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");
1795	AV av = (AV )sv_2mortal ((SV *)newAV ());	1936	AV av = (AV )sv_2mortal ((SV *)newAV ());
…		…
1817	object *actives (U32 index)	1958	object *actives (U32 index)
1818	CODE:	1959	CODE:
1819	RETVAL = index < actives.size () ? actives [index] : 0;	1960	RETVAL = index < actives.size () ? actives [index] : 0;
1820	OUTPUT: RETVAL	1961	OUTPUT: RETVAL
1821		1962
		1963	int mortals_size ()
		1964	CODE:
		1965	RETVAL = attachable::mortals.size ();
		1966	OUTPUT: RETVAL
		1967
1822	const char *slot_use_name (U32 slot)	1968	const_utf8_string slot_use_name (U32 slot)
1823	ALIAS:	1969	ALIAS:
1824	slot_nonuse_name = 1	1970	slot_nonuse_name = 1
1825	CODE:	1971	CODE:
1826	{	1972	{
1827	if (slot >= NUM_BODY_LOCATIONS)	1973	if (slot >= NUM_BODY_LOCATIONS)
…		…
1847	void	1993	void
1848	inv (object *obj)	1994	inv (object *obj)
1849	PROTOTYPE: $	1995	PROTOTYPE: $
1850	PPCODE:	1996	PPCODE:
1851	{	1997	{
1852	object *o;
1853	for (o = obj->inv; o; o = o->below)	1998	for (object *o = obj->inv; o; o = o->below)
1854	XPUSHs (sv_2mortal (to_sv (o)));	1999	XPUSHs (sv_2mortal (to_sv (o)));
1855	}	2000	}
1856		2001
1857	void	2002	void
1858	set_animation (object *op, int idx)	2003	set_animation (object *op, int idx)
…		…
1890		2035
1891	int need_identify (object *obj);	2036	int need_identify (object *obj);
1892		2037
1893	int apply_shop_mat (object shop_mat, object op);	2038	int apply_shop_mat (object shop_mat, object op);
1894		2039
1895	int move_player (object *op, int dir)	2040	int move (object op, int dir, object originator = op)
1896	CODE:	2041	CODE:
1897	RETVAL = move_player (op, dir);	2042	RETVAL = op->move (dir, originator);
1898	OUTPUT:	2043	OUTPUT:
1899	RETVAL	2044	RETVAL
1900		2045
1901	int move (object op, int dir, object originator = op)
1902	CODE:
1903	RETVAL = move_ob (op, dir, originator);
1904	OUTPUT:
1905	RETVAL
1906
1907	void apply (object applier, object applied, int flags = 0)
1908	CODE:
1909	manual_apply (applied, applier, flags);
1910
1911	void apply_below (object *op)	2046	void apply_below (object *op)
1912	CODE:	2047	CODE:
1913	player_apply_below (op);	2048	player_apply_below (op);
1914		2049
1915	int cast_heal (object op, object caster, object *spell, int dir = 0)	2050	int cast_heal (object op, object caster, object *spell, int dir = 0)
1916		2051
1917	object cf_object_present_archname_inside (object op, utf8_string whatstr)	2052	int casting_level (object caster, object spell)
1918
1919	int cf_object_transfer (object op, int x, int y, int r = 0, object_ornull orig = 0)
1920
1921	int cf_object_change_map (object op, int x, int y, maptile map)
1922
1923	#//TODO
1924	object clone_ (object op, int recursive = 0)
1925	CODE:
1926	if (recursive)
1927	RETVAL = object_create_clone (op);
1928	else
1929	{
1930	RETVAL = object::create ();
1931	op->copy_to (RETVAL);
1932	}
1933	OUTPUT: RETVAL
1934		2053
1935	int pay_item (object op, object buyer)	2054	int pay_item (object op, object buyer)
1936	CODE:	2055	CODE:
1937	RETVAL = pay_for_item (op, buyer);	2056	RETVAL = pay_for_item (op, buyer);
1938	OUTPUT: RETVAL	2057	OUTPUT: RETVAL
…		…
1973		2092
1974	void drop (object who, object op)	2093	void drop (object who, object op)
1975		2094
1976	void pick_up (object who, object op)	2095	void pick_up (object who, object op)
1977		2096
1978	int cf_object_teleport (object op, maptile map, int x, int y)
1979
1980	void update_object (object *op, int action)	2097	void update_object (object *op, int action)
1981		2098
1982	object *cf_create_object_by_name (utf8_string name)
1983
1984	void change_exp (object *op, uint64 exp, utf8_string skill_name = 0, int flag = 0)	2099	void change_exp (object *op, uint64 exp, utf8_string skill_name = 0, int flag = 0)
1985		2100
1986	void player_lvl_adj (object who, object skill = 0)	2101	void player_lvl_adj (object who, object skill = 0)
1987		2102
1988	int kill_object (object op, int dam = 0, object hitter = 0, int type = AT_PHYSICAL)	2103	int kill_object (object op, int dam = 0, object hitter = 0, int type = AT_PHYSICAL)
1989		2104
1990	int calc_skill_exp (object who, object op, object *skill);	2105	int calc_skill_exp (object who, object op, object *skill)
1991		2106
1992	void push_button (object *op);	2107	void push_button (object op, object originator)
1993		2108
1994	void use_trigger (object *op);	2109	void use_trigger (object op, object originator)
1995		2110
1996	void add_button_link (object button, maptile map, int connected);	2111	void handle_apply_yield (object *op)
1997		2112
1998	void remove_button_link (object *op);	2113	int convert_item (object item, object converter)
1999		2114
		2115	void fix_generated_item (object op, object creator, int difficulty, int max_magic, int flags);
2000		2116
2001	MODULE = cf PACKAGE = cf::object PREFIX = cf_	2117	MODULE = cf PACKAGE = cf::object PREFIX = cf_
2002
2003	object cf_insert_ob_in_ob (object ob, object *where)
2004		2118
2005	# no clean way to get an object from an archetype - stupid idiotic	2119	# no clean way to get an object from an archetype - stupid idiotic
2006	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.	2120	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.
2007		2121
2008	object *new (utf8_string archetype = 0)	2122	object *new (utf8_string archetype = 0)
…		…
2010	CODE:	2124	CODE:
2011	RETVAL = archetype ? get_archetype (archetype) : object::create ();	2125	RETVAL = archetype ? get_archetype (archetype) : object::create ();
2012	OUTPUT:	2126	OUTPUT:
2013	RETVAL	2127	RETVAL
2014		2128
		2129	object generate (utf8_string arch, object creator)
		2130	CODE:
		2131	object *obj = get_archetype (arch);
		2132	fix_generated_item (obj, creator, 0, 0, GT_MINIMAL);
		2133	RETVAL = obj;
		2134	OUTPUT:
		2135	RETVAL
		2136
2015	object *find_object (U32 tag)	2137	object *find_object (U32 tag)
		2138
		2139	object *find_object_uuid (UUID i)
2016		2140
2017	# TODO: nuke	2141	# TODO: nuke
2018	object insert_ob_in_map_at (object ob, maptile where, object_ornull orig, int flag, int x, int y)	2142	object insert_ob_in_map_at (object ob, maptile where, object_ornull orig, int flag, int x, int y)
2019	PROTOTYPE: $$$$$$	2143	PROTOTYPE: $$$$$$
2020	CODE:	2144	CODE:
2021	{	2145	{
2022	int unused_type;	2146	RETVAL = insert_ob_in_map_at (ob, where, orig, flag, x, y);
2023	RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);
2024	}
2025		2147
2026	const_utf8_string get_ob_key_value (object *op, utf8_string key)	2148	if (RETVAL->destroyed ())
		2149	RETVAL = 0;
		2150	}
2027		2151
2028	bool set_ob_key_value (object *op, utf8_string key, utf8_string value = 0, int add_key = 1)	2152	shstr
		2153	object::kv_get (shstr key)
		2154
		2155	void
		2156	object::kv_del (shstr key)
		2157
		2158	void
		2159	object::kv_set (shstr key, shstr value)
2029		2160
2030	object get_nearest_player (object ob)	2161	object get_nearest_player (object ob)
2031	ALIAS: nearest_player = 0	2162	ALIAS: nearest_player = 0
2032	PREINIT:	2163	PREINIT:
2033	extern object get_nearest_player (object );	2164	extern object get_nearest_player (object );
…		…
2035	void rangevector (object ob, object other, int flags = 0)	2166	void rangevector (object ob, object other, int flags = 0)
2036	PROTOTYPE: $$;$	2167	PROTOTYPE: $$;$
2037	PPCODE:	2168	PPCODE:
2038	{	2169	{
2039	rv_vector rv;	2170	rv_vector rv;
		2171
2040	get_rangevector (ob, other, &rv, flags);	2172	get_rangevector (ob, other, &rv, flags);
		2173
2041	EXTEND (SP, 5);	2174	EXTEND (SP, 5);
2042	PUSHs (newSVuv (rv.distance));	2175	PUSHs (sv_2mortal (newSVuv (rv.distance)));
2043	PUSHs (newSViv (rv.distance_x));	2176	PUSHs (sv_2mortal (newSViv (rv.distance_x)));
2044	PUSHs (newSViv (rv.distance_y));	2177	PUSHs (sv_2mortal (newSViv (rv.distance_y)));
2045	PUSHs (newSViv (rv.direction));	2178	PUSHs (sv_2mortal (newSViv (rv.direction)));
2046	PUSHs (newSVcfapi (CFAPI_POBJECT, rv.part));	2179	PUSHs (sv_2mortal (to_sv (rv.part)));
2047	}	2180	}
2048		2181
2049	bool on_same_map_as (object ob, object other)	2182	bool on_same_map_as (object ob, object other)
2050	CODE:	2183	CODE:
2051	RETVAL = on_same_map (ob, other);	2184	RETVAL = on_same_map (ob, other);
…		…
2055	base_name (object *op, int plural = op->nrof > 1)	2188	base_name (object *op, int plural = op->nrof > 1)
2056	CODE:	2189	CODE:
2057	RETVAL = query_base_name (op, plural);	2190	RETVAL = query_base_name (op, plural);
2058	OUTPUT: RETVAL	2191	OUTPUT: RETVAL
2059		2192
2060	object decrease_ob_nr (object op, unsigned long i)	2193	# return the tail of an object, excluding itself
		2194	void
		2195	tail (object *op)
		2196	PPCODE:
		2197	while ((op = op->more))
		2198	XPUSHs (sv_2mortal (to_sv (op)));
2061		2199
2062	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_	2200	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_
2063		2201
2064	player player (object op)	2202	player player (object op)
2065	CODE:	2203	CODE:
2066	RETVAL = op->contr;	2204	RETVAL = op->contr;
2067	OUTPUT: RETVAL	2205	OUTPUT: RETVAL
2068		2206
2069	void check_score (object *op)	2207	bool move_player (object *op, int dir)
2070		2208
2071	void message (object *op, utf8_string txt, int flags = NDI_ORANGE \| NDI_UNIQUE)	2209	void message (object *op, utf8_string txt, int flags = NDI_ORANGE \| NDI_UNIQUE)
2072	CODE:	2210	CODE:
2073	new_draw_info (flags, 0, op, txt);	2211	new_draw_info (flags, 0, op, txt);
2074		2212
2075	void kill_player (object *op)	2213	void kill_player (object *op)
2076		2214
		2215	void esrv_send_item (object pl, object item)
		2216
2077	void esrv_update_item (object op, int what, object item)	2217	void esrv_update_item (object pl, int what, object item)
2078	C_ARGS: what, op, item	2218	C_ARGS: what, pl, item
		2219
		2220	void esrv_del_item (object *pl, int tag)
		2221	C_ARGS: pl->contr, tag
2079		2222
2080	int command_summon (object *op, utf8_string params)	2223	int command_summon (object *op, utf8_string params)
2081		2224
2082	int command_arrest (object *op, utf8_string params)	2225	int command_arrest (object *op, utf8_string params)
2083		2226
2084		2227
2085	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_	2228	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
2086		2229
2087	INCLUDE: $PERL $srcdir/genacc player ../include/player.h \|	2230	INCLUDE: $PERL $srcdir/genacc player $srcdir/../include/player.h \|
2088		2231
2089	int invoke (player *pl, int event, ...)	2232	int invoke (player *pl, int event, ...)
2090	CODE:	2233	CODE:
2091	if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");	2234	if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");
2092	AV av = (AV )sv_2mortal ((SV *)newAV ());	2235	AV av = (AV )sv_2mortal ((SV *)newAV ());
…		…
2102	pl->ob->stats.hp = pl->ob->stats.maxhp;	2245	pl->ob->stats.hp = pl->ob->stats.maxhp;
2103	pl->ob->stats.sp = pl->ob->stats.maxsp;	2246	pl->ob->stats.sp = pl->ob->stats.maxsp;
2104	pl->ob->stats.grace = pl->ob->stats.maxgrace;	2247	pl->ob->stats.grace = pl->ob->stats.maxgrace;
2105	pl->orig_stats = pl->ob->stats;	2248	pl->orig_stats = pl->ob->stats;
2106		2249
2107	void clear_los (player *pl)	2250	# should only be temporary
		2251	void esrv_new_player (player *pl)
2108		2252
2109	void cf_player_move (player *pl, int dir)	2253	#d# TODO: replace by blocked_los accessor, fix code using this
2110
2111	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);
2112
2113	bool	2254	bool
2114	cell_visible (player *pl, int dx, int dy)	2255	cell_visible (player *pl, int dx, int dy)
2115	CODE:	2256	CODE:
2116	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2	2257	RETVAL = pl->blocked_los (dx, dy) != LOS_BLOCKED;
2117	&& !pl->blocked_los [dx + pl->ns->mapx / 2][dy + pl->ns->mapy / 2];
2118	OUTPUT:	2258	OUTPUT:
2119	RETVAL	2259	RETVAL
2120		2260
2121	void	2261	void
2122	send (player pl, SV packet)	2262	send (player pl, SV packet)
2123	CODE:	2263	CODE:
2124	{	2264	{
2125	STRLEN len;	2265	STRLEN len;
2126	char *buf = SvPVbyte (packet, len);	2266	char *buf = SvPVbyte (packet, len);
2127		2267
		2268	if (len > MAXSOCKBUF)
		2269	pl->failmsg ("[packet too long for client]");
2128	if (pl->ns)	2270	else if (pl->ns)
2129	pl->ns->send_packet (buf, len);	2271	pl->ns->send_packet (buf, len);
2130	}	2272	}
2131
2132	int
2133	listening (player *pl, int new_value = -1)
2134	CODE:
2135	RETVAL = pl->listening;
2136	if (new_value >= 0)
2137	pl->listening = new_value;
2138	OUTPUT:
2139	RETVAL
2140		2273
2141	void savebed (player pl, SV map_path = 0, SV x = 0, SV y = 0)	2274	void savebed (player pl, SV map_path = 0, SV x = 0, SV y = 0)
2142	PROTOTYPE: $;$$$	2275	PROTOTYPE: $;$$$
2143	PPCODE:	2276	PPCODE:
2144	if (GIMME_V != G_VOID)	2277	if (GIMME_V != G_VOID)
…		…
2169	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);	2302	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);
2170	OUTPUT: RETVAL	2303	OUTPUT: RETVAL
2171		2304
2172	SV registry (maptile map)	2305	SV registry (maptile map)
2173		2306
		2307	void
		2308	find_tagged_objects (maptile *map, utf8_string tag = 0)
		2309	PPCODE:
		2310	{
		2311	if (!map->spaces)
		2312	XSRETURN_EMPTY;
		2313
		2314	if (tag)
		2315	{
		2316	shstr_cmp tag_ (tag);
		2317
		2318	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2319	for (object *op = ms->bot; op; op = op->above)
		2320	if (op->tag == tag_)
		2321	XPUSHs (sv_2mortal (to_sv (op)));
		2322	}
		2323	else
		2324	{
		2325	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2326	for (object *op = ms->bot; op; op = op->above)
		2327	if (op->tag)
		2328	XPUSHs (sv_2mortal (to_sv (op)));
		2329	}
		2330	}
		2331
2174	INCLUDE: $PERL $srcdir/genacc maptile ../include/map.h \|	2332	INCLUDE: $PERL $srcdir/genacc maptile $srcdir/../include/map.h \|
		2333
		2334	void
		2335	adjust_daylight ()
		2336	CODE:
		2337	maptile::adjust_daylight ();
		2338
		2339	int
		2340	outdoor_darkness (int darkness = 0)
		2341	CODE:
		2342	RETVAL = maptile::outdoor_darkness;
		2343	if (items)
		2344	maptile::outdoor_darkness = darkness;
		2345	OUTPUT:
		2346	RETVAL
2175		2347
2176	void	2348	void
2177	maptile::instantiate ()	2349	maptile::instantiate ()
2178		2350
2179	maptile *new ()	2351	maptile *new ()
…		…
2211	for (int x = 0; x < THIS->width; ++x)	2383	for (int x = 0; x < THIS->width; ++x)
2212	for (int y = 0; y < THIS->height; ++y)	2384	for (int y = 0; y < THIS->height; ++y)
2213	{	2385	{
2214	for (object *op = THIS->at (x, y).bot; op; op = op->above)	2386	for (object *op = THIS->at (x, y).bot; op; op = op->above)
2215	if (op->flag [FLAG_IS_FLOOR])	2387	if (op->flag [FLAG_IS_FLOOR])
2216	goto skip_space;	2388	goto skip;
2217		2389
2218	{	2390	{
2219	int offs = offset + y * stride + x;	2391	int offs = offset + y * stride + x;
		2392
2220	if (IN_RANGE_EXC (offs, 0, idxlen))	2393	if (IN_RANGE_EXC (offs, 0, idxlen))
2221	{	2394	{
2222	if (SV *elem = av_fetch ((AV )palette, idx [offs], 0))	2395	if (SV *elem = av_fetch ((AV )palette, idx [offs], 0))
2223	{	2396	{
2224	object ob = get_archetype (SvPVutf8_nolen (elem));	2397	object ob = get_archetype (cfSvPVutf8_nolen (elem));
2225	ob->flag [FLAG_NO_MAP_SAVE] = true;	2398	ob->flag [FLAG_NO_MAP_SAVE] = true;
2226	THIS->insert (ob, x, y, 0, INS_ABOVE_FLOOR_ONLY);	2399	THIS->insert (ob, x, y, 0, INS_ABOVE_FLOOR_ONLY);
2227		2400
2228	if (ob->randomitems)	2401	if (ob->randomitems && !ob->above)
2229	{	2402	{
2230	if (!ob->above)
2231	{
2232	ob->create_treasure (ob->randomitems);	2403	ob->create_treasure (ob->randomitems);
2233		2404
2234	for (object *op = ob->above; op; op = op->above)	2405	for (object *op = ob->above; op; op = op->above)
2235	op->flag [FLAG_NO_MAP_SAVE] = true;	2406	op->flag [FLAG_NO_MAP_SAVE] = true;
2236	}	2407	// TODO: if this is a pickable object, then the item
2237		2408	// will at a bit weird - saving inside the player
2238	ob->randomitems = 0;	2409	// will clear the flag, but when the player drops
		2410	// it without logging out, it keeps the flag.
		2411	// nobody ahs reported this, but this can be rather
		2412	// annoying on persistent maps.
2239	}	2413	}
2240	}	2414	}
2241	}	2415	}
2242	}	2416	}
2243		2417
2244	skip_space: ;	2418	skip: ;
2245	}	2419	}
2246	}	2420	}
2247		2421
2248	void	2422	void
2249	maptile::set_regiondata (SV data, int offset, int stride, SV palette)	2423	maptile::set_regiondata (SV data, int offset, int stride, SV palette)
…		…
2255	palette = SvRV (palette);	2429	palette = SvRV (palette);
2256		2430
2257	STRLEN idxlen;	2431	STRLEN idxlen;
2258	const uint8_t idx = (const uint8_t )SvPVbyte (data, idxlen);	2432	const uint8_t idx = (const uint8_t )SvPVbyte (data, idxlen);
2259		2433
2260	region regionmap = (region )malloc (	2434	region_ptr regionmap = new region_ptr [av_len ((AV )palette) + 1];
2261	(av_len ((AV )palette) + 1) sizeof (region *));
2262	uint8_t *regions = salloc<uint8_t> (THIS->size ());	2435	uint8_t *regions = salloc<uint8_t> (THIS->size ());
2263		2436
2264	for (int i = av_len ((AV *)palette) + 1; i--; )	2437	for (int i = av_len ((AV *)palette) + 1; i--; )
2265	regionmap [i] = region::find (	2438	regionmap [i] = region::find (cfSvPVutf8_nolen (av_fetch ((AV )palette, i, 1)));
2266	SvPVutf8_nolen (av_fetch ((AV )palette, i, 1)));
2267		2439
2268	for (int y = 0; y < THIS->height; ++y)	2440	for (int y = 0; y < THIS->height; ++y)
2269	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);	2441	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);
2270		2442
2271	sfree (THIS->regions, THIS->size ());	2443	sfree (THIS->regions, THIS->size ());
2272	free (THIS->regionmap);	2444	delete [] THIS->regionmap;
2273		2445
2274	THIS->regions = regions;	2446	THIS->regions = regions;
2275	THIS->regionmap = regionmap;	2447	THIS->regionmap = regionmap;
2276	}	2448	}
2277		2449
2278	void	2450	void
2279	maptile::create_region_treasure ()	2451	maptile::create_region_treasure ()
2280	CODE:	2452	CODE:
2281	{
2282	object *op = object::create ();
2283	op->type = FLOOR;
2284	op->map = THIS;
2285
2286	for (int x = 0; x < THIS->width; ++x)	2453	for (int x = 0; x < THIS->width; ++x)
2287	for (int y = 0; y < THIS->height; ++y)	2454	for (int y = 0; y < THIS->height; ++y)
2288	{	2455	{
2289	region *rgn = THIS->region (x, y);	2456	region *rgn = THIS->region (x, y);
2290		2457
2291	//fprintf (stderr, "%d,%d %f %p\n", x, y, rgn->treasure_density,rgn->treasure);//D	2458	//fprintf (stderr, "%d,%d %f %p\n", x, y, rgn->treasure_density,rgn->treasure);//D
		2459	if (object *op = THIS->at (x, y).top)
2292	if (rgn->treasure && rndm () < rgn->treasure_density)	2460	if (rgn->treasure && rndm () < rgn->treasure_density)
2293	{
2294	op->x = x;
2295	op->y = y;
2296	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);	2461	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);
2297	}
2298	}	2462	}
2299		2463
2300	op->destroy ();
2301	}
2302
2303	void play_sound_map (maptile *map, int x, int y, int sound_num)
2304
2305	int out_of_map (maptile *map, int x, int y)	2464	int out_of_map (maptile *map, int x, int y)
2306		2465
2307	void	2466	void
2308	trigger (maptile *map, long connection, bool state = true)	2467	find_link (maptile *map, shstr_tmp connection)
2309	CODE:
2310	activate_connection (map, connection, state);
2311
2312	void
2313	get_connection (maptile *map, long connection)
2314	PPCODE:	2468	PPCODE:
2315	oblinkpt *obp = get_connection_links (map, connection);	2469	if (oblinkpt *obp = map->find_link (connection))
2316	if (obp)
2317	for (objectlink *ol = obp->link; ol; ol = ol->next)	2470	for (objectlink *ol = obp->link; ol; ol = ol->next)
2318	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, (object *)ol->ob)));	2471	XPUSHs (sv_2mortal (to_sv ((object *)ol->ob)));
2319
2320	object cf_map_insert_object_there (maptile where, object op, object originator, int flags)
2321
2322	object cf_map_insert_object (maptile where, object* op, int x, int y)
2323
2324	object* cf_map_present_arch_by_name (maptile map, const char str, int nx, int ny)
2325	C_ARGS: str, map, nx, ny
2326		2472
2327	void	2473	void
2328	get_map_flags (maptile *map, int x, int y)	2474	get_map_flags (maptile *map, int x, int y)
2329	PPCODE:	2475	PPCODE:
2330	{	2476	{
2331	maptile *nmap = 0;	2477	maptile *nmap = 0;
2332	I16 nx = 0, ny = 0;	2478	I16 nx = 0, ny = 0;
		2479
		2480	PUTBACK;
2333	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);	2481	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
		2482	SPAGAIN;
2334		2483
2335	EXTEND (SP, 4);	2484	EXTEND (SP, 4);
2336	PUSHs (sv_2mortal (newSViv (flags)));	2485	PUSHs (sv_2mortal (newSViv (flags)));
2337		2486
2338	if (GIMME_V == G_ARRAY)	2487	if (GIMME_V == G_ARRAY)
2339	{	2488	{
2340	PUSHs (sv_2mortal (newSVcfapi (CFAPI_PMAP, nmap)));	2489	PUSHs (sv_2mortal (to_sv (nmap)));
2341	PUSHs (sv_2mortal (newSViv (nx)));	2490	PUSHs (sv_2mortal (newSViv (nx)));
2342	PUSHs (sv_2mortal (newSViv (ny)));	2491	PUSHs (sv_2mortal (newSViv (ny)));
2343	}	2492	}
2344	}	2493	}
2345		2494
		2495	mapspace *
		2496	ms (maptile *map, unsigned int x, unsigned int y)
		2497	PROTOTYPE: $$$
		2498	CODE:
		2499	{
		2500	maptile *nmap = 0;
		2501	I16 nx, ny;
		2502
		2503	PUTBACK;
		2504	get_map_flags (map, &nmap, x, y, &nx, &ny);
		2505	SPAGAIN;
		2506
		2507	if (!nmap)
		2508	XSRETURN_UNDEF;
		2509
		2510	RETVAL = &nmap->at (nx, ny);
		2511	}
		2512	OUTPUT:
		2513	RETVAL
		2514
2346	void	2515	void
2347	at (maptile *map, unsigned int x, unsigned int y)	2516	at (maptile *map, unsigned int x, unsigned int y)
2348	PROTOTYPE: $$$	2517	PROTOTYPE: $$$
2349	PPCODE:	2518	PPCODE:
2350	{	2519	{
2351	object *o;
2352	maptile *nmap = 0;	2520	maptile *nmap = 0;
2353	I16 nx, ny;	2521	I16 nx, ny;
2354		2522
		2523	PUTBACK;
2355	get_map_flags (map, &nmap, x, y, &nx, &ny);	2524	get_map_flags (map, &nmap, x, y, &nx, &ny);
		2525	SPAGAIN;
2356		2526
2357	if (nmap)	2527	if (nmap)
2358	for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)	2528	for (object *o = nmap->at (nx, ny).bot; o; o = o->above)
2359	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));	2529	XPUSHs (sv_2mortal (to_sv (o)));
2360	}	2530	}
2361		2531
2362	SV *	2532	SV *
2363	bot_at (maptile *obj, unsigned int x, unsigned int y)	2533	bot_at (maptile *map, unsigned int x, unsigned int y)
2364	PROTOTYPE: $$$	2534	PROTOTYPE: $$$
2365	ALIAS:	2535	ALIAS:
2366	top_at = 1	2536	top_at = 1
2367	flags_at = 2	2537	flags_at = 2
2368	light_at = 3	2538	light_at = 3
2369	move_block_at = 4	2539	move_block_at = 4
2370	move_slow_at = 5	2540	move_slow_at = 5
2371	move_on_at = 6	2541	move_on_at = 6
2372	move_off_at = 7	2542	move_off_at = 7
2373	INIT:
2374	if (x >= obj->width \|\| y >= obj->height) XSRETURN_UNDEF;
2375	CODE:	2543	CODE:
		2544	{
		2545	sint16 nx = x;
		2546	sint16 ny = y;
		2547
		2548	if (!xy_normalise (map, nx, ny))
		2549	XSRETURN_UNDEF;
		2550
		2551	mapspace &ms = map->at (nx, ny);
		2552
		2553	ms.update ();
		2554
2376	switch (ix)	2555	switch (ix)
2377	{	2556	{
2378	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;	2557	case 0: RETVAL = to_sv (ms.bot ); break;
2379	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;	2558	case 1: RETVAL = to_sv (ms.top ); break;
2380	case 2: RETVAL = newSVuv ( GET_MAP_FLAGS (obj, x, y)); break;	2559	case 2: RETVAL = newSVuv (ms.flags_ ); break;
2381	case 3: RETVAL = newSViv ( GET_MAP_LIGHT (obj, x, y)); break;	2560	case 3: RETVAL = newSViv (ms.light ); break;
2382	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;	2561	case 4: RETVAL = newSVuv (ms.move_block); break;
2383	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;	2562	case 5: RETVAL = newSVuv (ms.move_slow ); break;
2384	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;	2563	case 6: RETVAL = newSVuv (ms.move_on ); break;
2385	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;	2564	case 7: RETVAL = newSVuv (ms.move_off ); break;
2386	}	2565	}
		2566	}
2387	OUTPUT: RETVAL	2567	OUTPUT: RETVAL
2388
2389	void fix_walls (maptile *map, int x, int y)
2390
2391	void fix_walls_around (maptile *map, int x, int y)
2392		2568
2393	# worst xs function of my life	2569	# worst xs function of my life
2394	bool	2570	bool
2395	_create_random_map (\	2571	_create_random_map (\
2396	maptile *self,\	2572	maptile *self,\
…		…
2400	utf8_string monsterstyle,\	2576	utf8_string monsterstyle,\
2401	utf8_string treasurestyle,\	2577	utf8_string treasurestyle,\
2402	utf8_string layoutstyle,\	2578	utf8_string layoutstyle,\
2403	utf8_string doorstyle,\	2579	utf8_string doorstyle,\
2404	utf8_string decorstyle,\	2580	utf8_string decorstyle,\
		2581	utf8_string miningstyle,\
2405	utf8_string origin_map,\	2582	utf8_string origin_map,\
2406	utf8_string final_map,\	2583	utf8_string final_map,\
2407	utf8_string exitstyle,\	2584	utf8_string exitstyle,\
2408	utf8_string this_map,\	2585	utf8_string this_map,\
2409	utf8_string exit_on_final_map,\	2586	utf8_string exit_on_final_map,\
…		…
2441	assign (rmp.monsterstyle , monsterstyle);	2618	assign (rmp.monsterstyle , monsterstyle);
2442	assign (rmp.treasurestyle , treasurestyle);	2619	assign (rmp.treasurestyle , treasurestyle);
2443	assign (rmp.layoutstyle , layoutstyle);	2620	assign (rmp.layoutstyle , layoutstyle);
2444	assign (rmp.doorstyle , doorstyle);	2621	assign (rmp.doorstyle , doorstyle);
2445	assign (rmp.decorstyle , decorstyle);	2622	assign (rmp.decorstyle , decorstyle);
		2623	assign (rmp.miningstyle , miningstyle);
2446	assign (rmp.exitstyle , exitstyle);	2624	assign (rmp.exitstyle , exitstyle);
2447	assign (rmp.exit_on_final_map, exit_on_final_map);	2625	assign (rmp.exit_on_final_map, exit_on_final_map);
2448		2626
2449	rmp.origin_map = origin_map;	2627	rmp.origin_map = origin_map;
2450	rmp.final_map = final_map;	2628	rmp.final_map = final_map;
…		…
2476	RETVAL = self->generate_random_map (&rmp);	2654	RETVAL = self->generate_random_map (&rmp);
2477	}	2655	}
2478	OUTPUT:	2656	OUTPUT:
2479	RETVAL	2657	RETVAL
2480		2658
		2659	MODULE = cf PACKAGE = cf::mapspace
		2660
		2661	INCLUDE: $PERL $srcdir/genacc mapspace $srcdir/../include/map.h \|
		2662
2481	MODULE = cf PACKAGE = cf::arch	2663	MODULE = cf PACKAGE = cf::arch
2482
2483	archetype *find (utf8_string name)
2484	CODE:
2485	RETVAL = archetype::find (name);
2486	OUTPUT:
2487	RETVAL
2488		2664
2489	int archetypes_size ()	2665	int archetypes_size ()
2490	CODE:	2666	CODE:
2491	RETVAL = archetypes.size ();	2667	RETVAL = archetypes.size ();
2492	OUTPUT: RETVAL	2668	OUTPUT: RETVAL
…		…
2494	archetype *archetypes (U32 index)	2670	archetype *archetypes (U32 index)
2495	CODE:	2671	CODE:
2496	RETVAL = index < archetypes.size () ? archetypes [index] : 0;	2672	RETVAL = index < archetypes.size () ? archetypes [index] : 0;
2497	OUTPUT: RETVAL	2673	OUTPUT: RETVAL
2498		2674
2499	object instantiate (archetype arch)
2500	CODE:
2501	RETVAL = arch_to_object (arch);
2502	OUTPUT:
2503	RETVAL
2504
2505	INCLUDE: $PERL $srcdir/genacc archetype ../include/object.h \|	2675	INCLUDE: $PERL $srcdir/genacc archetype $srcdir/../include/object.h \|
2506		2676
2507	MODULE = cf PACKAGE = cf::party	2677	MODULE = cf PACKAGE = cf::party
2508		2678
2509	partylist *first ()	2679	partylist *first ()
2510	PROTOTYPE:	2680	PROTOTYPE:
2511	CODE:	2681	CODE:
2512	RETVAL = get_firstparty ();	2682	RETVAL = get_firstparty ();
2513	OUTPUT: RETVAL	2683	OUTPUT: RETVAL
2514		2684
2515	INCLUDE: $PERL $srcdir/genacc partylist ../include/player.h \|	2685	INCLUDE: $PERL $srcdir/genacc partylist $srcdir/../include/player.h \|
2516		2686
2517	MODULE = cf PACKAGE = cf::region	2687	MODULE = cf PACKAGE = cf::region
2518		2688
2519	void	2689	void
2520	list ()	2690	list ()
…		…
2526	PROTOTYPE: $	2696	PROTOTYPE: $
2527	CODE:	2697	CODE:
2528	RETVAL = region::find (name);	2698	RETVAL = region::find (name);
2529	OUTPUT: RETVAL	2699	OUTPUT: RETVAL
2530		2700
2531	region *find_fuzzy (utf8_string name)
2532	PROTOTYPE: $
2533	CODE:
2534	RETVAL = region::find_fuzzy (name);
2535	OUTPUT: RETVAL
2536
2537	int specificity (region *rgn)	2701	int specificity (region *rgn)
2538	CODE:	2702	CODE:
2539	RETVAL = 0;	2703	RETVAL = 0;
2540	while (rgn = rgn->parent)	2704	while (rgn = rgn->parent)
2541	RETVAL++;	2705	RETVAL++;
2542	OUTPUT: RETVAL	2706	OUTPUT: RETVAL
2543		2707
2544	INCLUDE: $PERL $srcdir/genacc region ../include/region.h \|	2708	INCLUDE: $PERL $srcdir/genacc region $srcdir/../include/region.h \|
2545		2709
2546	MODULE = cf PACKAGE = cf::living	2710	MODULE = cf PACKAGE = cf::living
2547		2711
2548	INCLUDE: $PERL $srcdir/genacc living ../include/living.h \|	2712	INCLUDE: $PERL $srcdir/genacc living $srcdir/../include/living.h \|
2549		2713
2550	MODULE = cf PACKAGE = cf::settings	2714	MODULE = cf PACKAGE = cf::settings
2551		2715
2552	INCLUDE: $PERL $srcdir/genacc Settings ../include/global.h \|	2716	INCLUDE: $PERL $srcdir/genacc Settings $srcdir/../include/global.h \|
2553		2717
2554	MODULE = cf PACKAGE = cf::client	2718	MODULE = cf PACKAGE = cf::client
2555		2719
2556	INCLUDE: $PERL $srcdir/genacc client ../include/client.h \|	2720	INCLUDE: $PERL $srcdir/genacc client $srcdir/../include/client.h \|
2557		2721
2558	int invoke (client *ns, int event, ...)	2722	int invoke (client *ns, int event, ...)
2559	CODE:	2723	CODE:
2560	if (KLASS_OF (event) != KLASS_CLIENT) croak ("event class must be CLIENT");	2724	if (KLASS_OF (event) != KLASS_CLIENT) croak ("event class must be CLIENT");
2561	AV av = (AV )sv_2mortal ((SV *)newAV ());	2725	AV av = (AV )sv_2mortal ((SV *)newAV ());
…		…
2577	CODE:	2741	CODE:
2578	{	2742	{
2579	STRLEN len;	2743	STRLEN len;
2580	char *buf = SvPVbyte (packet, len);	2744	char *buf = SvPVbyte (packet, len);
2581		2745
		2746	if (len > MAXSOCKBUF)
		2747	{
		2748	// ugly
		2749	if (THIS->pl)
		2750	THIS->pl->failmsg ("[packet too long for client]");
		2751	}
		2752	else
2582	THIS->send_packet (buf, len);	2753	THIS->send_packet (buf, len);
2583	}	2754	}
		2755
		2756	faceidx
		2757	client::need_face (utf8_string name, int pri = 0)
		2758	CODE:
		2759	RETVAL = face_find (name, 0);
		2760	if (RETVAL)
		2761	{
		2762	THIS->send_face (RETVAL, pri);
		2763	THIS->flush_fx ();
		2764	}
		2765	OUTPUT:
		2766	RETVAL
		2767
		2768	int
		2769	client::fx_want (int idx, int value = -1)
		2770	CODE:
		2771	if (0 < idx && idx < FT_NUM)
		2772	{
		2773	RETVAL = THIS->fx_want [idx];
		2774	if (items > 2)
		2775	THIS->fx_want [idx] = value;
		2776	}
		2777	else
		2778	RETVAL = 0;
		2779	OUTPUT:
		2780	RETVAL
		2781
		2782	MODULE = cf PACKAGE = cf::sound PREFIX = sound_
		2783
		2784	faceidx sound_find (utf8_string name)
		2785
		2786	void sound_set (utf8_string str, faceidx face)
		2787
		2788	# dire hack
		2789	void old_sound_index (int idx, faceidx face)
		2790	CODE:
		2791	extern faceidx old_sound_index [SOUND_CAST_SPELL_0];
		2792	old_sound_index [idx] = face;
2584		2793
2585	MODULE = cf PACKAGE = cf::face PREFIX = face_	2794	MODULE = cf PACKAGE = cf::face PREFIX = face_
2586		2795
2587	#INCLUDE: $PERL $srcdir/genacc faceset ../include/face.h \|	2796	#INCLUDE: $PERL $srcdir/genacc faceset $srcdir/../include/face.h \|
2588		2797
2589	faceidx face_find (utf8_string name, faceidx defidx = 0)	2798	faceidx face_find (utf8_string name, faceidx defidx = 0)
2590		2799
2591	faceidx alloc (utf8_string name)	2800	faceidx alloc (utf8_string name)
2592	CODE:	2801	CODE:
…		…
2599	while (!RETVAL); // crude way to leave index 0	2808	while (!RETVAL); // crude way to leave index 0
2600		2809
2601	faces [RETVAL].name = name;	2810	faces [RETVAL].name = name;
2602	facehash.insert (std::make_pair (faces [RETVAL].name, RETVAL));	2811	facehash.insert (std::make_pair (faces [RETVAL].name, RETVAL));
2603		2812
2604	if (!strcmp (name, BLANK_FACE_NAME)) blank_face = RETVAL;	2813	if (!strcmp (name, BLANK_FACE_NAME )) blank_face = RETVAL;
2605	if (!strcmp (name, EMPTY_FACE_NAME)) empty_face = RETVAL;	2814	if (!strcmp (name, EMPTY_FACE_NAME )) empty_face = RETVAL;
		2815	if (!strcmp (name, MAGICMOUTH_FACE_NAME)) magicmouth_face = RETVAL;
2606	}	2816	}
2607	OUTPUT: RETVAL	2817	OUTPUT: RETVAL
2608		2818
2609	void set (faceidx idx, int visibility, int magicmap)	2819	void set_type (faceidx idx, int value)
2610	CODE:	2820	ALIAS:
2611	faceinfo *f = face_info (idx);	2821	set_type = 0
2612	assert (f);	2822	set_visibility = 1
2613	f->visibility = visibility;	2823	set_magicmap = 2
2614	f->magicmap = magicmap;	2824	set_smooth = 3
2615		2825	set_smoothlevel = 4
2616	void set_smooth (faceidx idx, faceidx smooth, int smoothlevel)
2617	CODE:	2826	CODE:
2618	faceinfo *f = face_info (idx); assert (f);	2827	faceinfo *f = face_info (idx); assert (f);
2619	f->smooth = smooth;	2828	switch (ix)
2620	f->smoothlevel = smoothlevel;	2829	{
		2830	case 0: f->type = value; break;
		2831	case 1: f->visibility = value; break;
		2832	case 2: f->magicmap = value; break;
		2833	case 3: f->smooth = value; break;
		2834	case 4: f->smoothlevel = value; break;
		2835	}
2621		2836
2622	void set_data (faceidx idx, int faceset, SV data, SV chksum)	2837	void set_data (faceidx idx, int faceset, SV data, SV chksum)
2623	CODE:	2838	CODE:
2624	{	2839	{
2625	facedata *d = face_data (idx, faceset);	2840	faceinfo *f = face_info (idx); assert (f);
2626	assert (d);	2841	facedata *d = &(faceset ? f->data64 : f->data32);
2627	sv_to (data, d->data);	2842	sv_to (data, d->data);
2628	STRLEN clen;	2843	STRLEN clen;
2629	char *cdata = SvPVbyte (chksum, clen);	2844	char *cdata = SvPVbyte (chksum, clen);
2630	clen = min (CHKSUM_SIZE, clen);	2845	clen = min (CHKSUM_MAXLEN, clen);
2631		2846
		2847	assert (("cf::face::set_data must be called with a non-empty checksum", clen));
		2848
2632	if (memcmp (d->chksum, cdata, clen))	2849	if (clen != d->chksum_len \|\| memcmp (d->chksum, cdata, clen))
2633	{	2850	{
		2851	d->chksum_len = clen;
2634	memcpy (d->chksum, cdata, clen);	2852	memcpy (d->chksum, cdata, clen);
2635		2853
2636	// invalidate existing client face info	2854	// invalidate existing client face info
2637	for_all_clients (ns)	2855	for_all_clients (ns)
2638	if (ns->faceset == faceset)	2856	if (ns->faceset == faceset)
…		…
2641	ns->force_newmap = true;	2859	ns->force_newmap = true;
2642	}	2860	}
2643	}	2861	}
2644	}	2862	}
2645		2863
		2864	int get_data_size (faceidx idx, int faceset = 0)
		2865	CODE:
		2866	facedata *d = face_data (idx, faceset);
		2867	if (!d) XSRETURN_UNDEF;
		2868	RETVAL = d->data.size ();
		2869	OUTPUT:
		2870	RETVAL
		2871
		2872	SV *get_chksum (faceidx idx, int faceset = 0)
		2873	CODE:
		2874	facedata *d = face_data (idx, faceset);
		2875	if (!d) XSRETURN_UNDEF;
		2876	RETVAL = newSVpvn ((char *)d->chksum, d->chksum_len);
		2877	OUTPUT:
		2878	RETVAL
		2879
		2880	SV *get_data (faceidx idx, int faceset = 0)
		2881	CODE:
		2882	facedata *d = face_data (idx, faceset);
		2883	if (!d) XSRETURN_UNDEF;
		2884	RETVAL = newSVpvn (d->data.data (), d->data.length ());
		2885	OUTPUT:
		2886	RETVAL
		2887
2646	void invalidate (faceidx idx)	2888	void invalidate (faceidx idx)
2647	CODE:	2889	CODE:
2648	for_all_clients (ns)	2890	for_all_clients (ns)
2649	{	2891	{
2650	ns->faces_sent [idx] = false;	2892	ns->faces_sent [idx] = false;
…		…
2659	ns->force_newmap = true;	2901	ns->force_newmap = true;
2660	}	2902	}
2661		2903
2662	MODULE = cf PACKAGE = cf::anim PREFIX = anim_	2904	MODULE = cf PACKAGE = cf::anim PREFIX = anim_
2663		2905
2664	#INCLUDE: $PERL $srcdir/genacc faceset ../include/anim.h \|	2906	#INCLUDE: $PERL $srcdir/genacc faceset $srcdir/../include/anim.h \|
2665		2907
2666	animidx anim_find (utf8_string name)	2908	animidx anim_find (utf8_string name)
2667	CODE:	2909	CODE:
2668	RETVAL = animation::find (name).number;	2910	RETVAL = animation::find (name).number;
2669	OUTPUT: RETVAL	2911	OUTPUT: RETVAL
…		…
2684	}	2926	}
2685	else	2927	else
2686	anim = &animation::create (name, av_len (av) + 1, facings);	2928	anim = &animation::create (name, av_len (av) + 1, facings);
2687		2929
2688	for (int i = 0; i < anim->num_animations; ++i)	2930	for (int i = 0; i < anim->num_animations; ++i)
2689	anim->faces [i] = face_find (SvPVutf8_nolen (*av_fetch (av, i, 1)));	2931	anim->faces [i] = face_find (cfSvPVutf8_nolen (*av_fetch (av, i, 1)));
2690	}	2932	}
2691	OUTPUT: RETVAL	2933	OUTPUT: RETVAL
2692		2934
2693	void invalidate_all ()	2935	void invalidate_all ()
2694	CODE:	2936	CODE:
2695	for_all_clients (ns)	2937	for_all_clients (ns)
2696	ns->anims_sent.reset ();	2938	ns->anims_sent.reset ();
2697		2939
		2940	MODULE = cf PACKAGE = cf::object::freezer
		2941
		2942	INCLUDE: $PERL $srcdir/genacc object_freezer $srcdir/../include/cfperl.h \|
		2943
		2944	SV *
		2945	new (char *klass)
		2946	CODE:
		2947	RETVAL = newSVptr (new object_freezer, gv_stashpv ("cf::object::freezer", 1));
		2948	OUTPUT: RETVAL
		2949
		2950	void
		2951	DESTROY (SV *sv)
		2952	CODE:
		2953	object_freezer *self;
		2954	sv_to (sv, self);
		2955	delete self;
		2956
		2957	MODULE = cf PACKAGE = cf::object::thawer
		2958
		2959	INCLUDE: $PERL $srcdir/genacc object_thawer $srcdir/../include/cfperl.h \|
		2960
		2961	SV *
		2962	new_from_file (char *klass, octet_string path)
		2963	CODE:
		2964	object_thawer *f = new object_thawer (path);
		2965	if (!*f)
		2966	{
		2967	delete f;
		2968	XSRETURN_UNDEF;
		2969	}
		2970	RETVAL = newSVptr (f, gv_stashpv ("cf::object::thawer", 1));
		2971	OUTPUT: RETVAL
		2972
		2973	void
		2974	DESTROY (SV *sv)
		2975	CODE:
		2976	object_thawer *self;
		2977	sv_to (sv, self);
		2978	delete self;
		2979
		2980	void
		2981	extract_tags (object_thawer *self)
		2982	PPCODE:
		2983	while (self->kw != KW_EOF)
		2984	{
		2985	PUTBACK;
		2986	coroapi::cede_to_tick ();
		2987	SPAGAIN;
		2988
		2989	if (self->kw == KW_tag)
		2990	XPUSHs (sv_2mortal (newSVpv_utf8 (self->get_str ())));
		2991
		2992	self->skip ();
		2993	}
		2994

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.225 by root, Sat Jun 30 03:00:55 2007 UTC vs. Revision 1.369 by root, Wed Apr 14 02:31:24 2010 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.225 by root, Sat Jun 30 03:00:55 2007 UTC vs.
Revision 1.369 by root, Wed Apr 14 02:31:24 2010 UTC