ViewVC Help

View File | Revision Log | Show Annotations | Download File

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

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

Diff Legend

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