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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.269 by root, Fri Feb 1 15:54:08 2008 UTC vs.
Revision 1.433 by root, Wed Dec 5 19:13:21 2018 UTC

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.269 by root, Fri Feb 1 15:54:08 2008 UTC vs. Revision 1.433 by root, Wed Dec 5 19:13:21 2018 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.269 by root, Fri Feb 1 15:54:08 2008 UTC vs.
Revision 1.433 by root, Wed Dec 5 19:13:21 2018 UTC