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

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.281 by root, Tue Apr 22 07:01:47 2008 UTC vs. Revision 1.405 by root, Wed May 4 19:04:45 2011 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.281 by root, Tue Apr 22 07:01:47 2008 UTC vs.
Revision 1.405 by root, Wed May 4 19:04:45 2011 UTC