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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.267 by root, Mon Dec 17 08:03:22 2007 UTC vs.
Revision 1.322 by root, Sun Oct 11 18:18:04 2009 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 Marc Alexander Lehmann / Robin Redeker / the Deliantra team	4	* Copyright (©) 2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2001-2005,2007 by Chachkoff Yann	5	* Copyright (©) 2001-2005,2007 by Chachkoff Yann
6	* Copyright (©) 2006,2007 by Marc Lehmann <cf@schmorp.de>	6	* Copyright (©) 2006,2007 by Marc Lehmann <cf@schmorp.de>
7	*	7	*
8	* Deliantra is free software: you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
21	* The authors can be reached via e-mail to <support@deliantra.net>	21	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	22	*/
23		23
24	#include "autoconf.h"	24	#include "autoconf.h"
25		25
26	#define PLUGIN_NAME "perl"
27	#define PLUGIN_VERSION "cfperl 0.5"
28
29	#define CEDES_PER_TICK 5
30
31	#if HAVE_EXECINFO_H	26	#if HAVE_EXECINFO_H
32	# include <execinfo.h>	27	# include <execinfo.h>
33	#endif	28	#endif
34		29
35	#include <cstdarg>	30	#include <cstdarg>
		31	#include <typeinfo>
36		32
37	#include "global.h"	33	#include "global.h"
38	#include "loader.h"	34	#include "loader.h"
39	#include "../random_maps/random_map.h"	35	#include "../random_maps/random_map.h"
		36	#include "evthread.h"
40	#include <sproto.h>	37	#include "sproto.h"
41		38
42	#include <unistd.h>	39	#include <unistd.h>
43	#if _POSIX_MEMLOCK	40	#if _POSIX_MEMLOCK
44	# include <sys/mman.h>	41	# include <sys/mman.h>
45	#endif	42	#endif
46		43
47	#if HAVE_MALLOC_H	44	#if HAVE_MALLOC_H
48	# include <malloc.h>	45	# include <malloc.h>
49	#endif	46	#endif
50		47
		48	#if !__GLIBC__
		49	# define malloc_trim(pad) -1
		50	#endif
		51
51	#include <EXTERN.h>	52	#include <EXTERN.h>
52	#include <perl.h>	53	#include <perl.h>
53	#include <XSUB.h>	54	#include <XSUB.h>
54		55
55	#include "CoroAPI.h"	56	#include "CoroAPI.h"
…		…
60	typedef object_thawer &object_thawer_ref;	61	typedef object_thawer &object_thawer_ref;
61	typedef object_freezer &object_freezer_ref;	62	typedef object_freezer &object_freezer_ref;
62		63
63	typedef std::string std__string;	64	typedef std::string std__string;
64		65
65	#if IVSIZE >= 8
66	typedef IV val64;
67	# define newSVval64 newSViv
68	# define SvVAL64 SvIV
69	#else
70	typedef double val64;
71	# define newSVval64 newSVnv
72	# define SvVAL64 SvNV
73	#endif
74
75	static PerlInterpreter *perl;	66	static PerlInterpreter *perl;
76		67
77	tstamp NOW, runtime;	68	tstamp NOW, runtime;
		69
		70	static int tick_inhibit;
		71	static int tick_pending;
78		72
79	global gbl_ev;	73	global gbl_ev;
80	static AV cb_global, cb_attachable, cb_object, cb_player, cb_client, cb_type, *cb_map;	74	static AV cb_global, cb_attachable, cb_object, cb_player, cb_client, cb_type, *cb_map;
81	static SV sv_runtime, sv_next_tick, *sv_now;	75	static SV sv_runtime, sv_tick_start, sv_next_tick, sv_now;
		76	static AV *av_reflect;
82		77
83	bitset<NUM_EVENT_TYPES> ev_want_event;	78	bitset<NUM_EVENT_TYPES> ev_want_event;
84	bitset<NUM_TYPES> ev_want_type;	79	bitset<NUM_TYPES> ev_want_type;
85		80
86	static HV	81	static HV
87	*stash_cf,	82	*stash_cf,
88	*stash_cf_object_wrap,	83	*stash_cf_object_wrap,
89	*stash_cf_object_player_wrap,	84	*stash_cf_object_player_wrap,
90	*stash_cf_player_wrap,	85	*stash_cf_player_wrap,
91	*stash_cf_map_wrap,	86	*stash_cf_map_wrap,
		87	*stash_cf_mapspace_wrap,
92	*stash_cf_client_wrap,	88	*stash_cf_client_wrap,
93	*stash_cf_arch_wrap,	89	*stash_cf_arch_wrap,
94	*stash_cf_party_wrap,	90	*stash_cf_party_wrap,
95	*stash_cf_region_wrap,	91	*stash_cf_region_wrap,
96	*stash_cf_living_wrap;	92	*stash_cf_living_wrap;
97		93
		94	#ifndef newSVpv_utf8
98	static inline SV *	95	static inline SV *
99	newSVpv_utf8 (const char *s)	96	newSVpv_utf8 (const char *s)
100	{	97	{
101	if (!s)	98	if (!s)
102	return newSV (0);	99	return newSV (0);
103		100
104	SV *sv = newSVpv (s, 0);	101	SV *sv = newSVpv (s, 0);
105	SvUTF8_on (sv);	102	SvUTF8_on (sv);
106	return sv;	103	return sv;
107	}	104	}
		105	#endif
108		106
		107	#ifndef newSVpvn_utf8
109	static inline SV *	108	static inline SV *
110	newSVpvn_utf8 (const char *s, STRLEN l)	109	newSVpvn_utf8 (const char *s, STRLEN l, int utf8)
111	{	110	{
112	if (!s)	111	if (!s)
113	return newSV (0);	112	return newSV (0);
114		113
115	SV *sv = newSVpvn (s, l);	114	SV *sv = newSVpvn (s, l);
		115
		116	if (utf8)
116	SvUTF8_on (sv);	117	SvUTF8_on (sv);
		118
117	return sv;	119	return sv;
118	}	120	}
		121	#endif
119		122
120	// helper cast function, returns super class * or 0	123	// helper cast function, returns super class * or 0
121	template<class super>	124	template<class super>
122	static super *	125	static super *
123	is_a (attachable *at)	126	is_a (attachable *at)
…		…
156	SvREFCNT_inc (self);	159	SvREFCNT_inc (self);
157	hv_clear (self);	160	hv_clear (self);
158	sv_unmagic ((SV *)self, PERL_MAGIC_ext);	161	sv_unmagic ((SV *)self, PERL_MAGIC_ext);
159	SvREFCNT_dec (self);	162	SvREFCNT_dec (self);
160		163
161	// self must be null now because thats sv_unmagic's job.	164	// self must be null now because that's sv_unmagic's job.
162	assert (!this->self);	165	assert (!this->self);
163	}	166	}
164	}	167	}
165		168
166	void	169	void
…		…
315	fprintf (stderr, "P %p\n", pl);	318	fprintf (stderr, "P %p\n", pl);
316		319
317	for_all_clients (ns)	320	for_all_clients (ns)
318	if (find_backref (ptr, ns))	321	if (find_backref (ptr, ns))
319	fprintf (stderr, "C %p\n", ns);	322	fprintf (stderr, "C %p\n", ns);
320
321	}	323	}
322		324
323	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	325	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
324		326
325	static SV *	327	static SV *
…		…
403	croak ("perl code used %s object, but C object is already destroyed, caught", klass);	405	croak ("perl code used %s object, but C object is already destroyed, caught", klass);
404		406
405	return (long)mg->mg_ptr;	407	return (long)mg->mg_ptr;
406	}	408	}
407		409
408	static long	410	static long noinline
409	SvPTR_ornull (SV sv, const char klass)	411	SvPTR_ornull (SV sv, const char klass)
410	{	412	{
411	if (SvOK (sv))	413	if (SvOK (sv))
412	return SvPTR (sv, klass);	414	return SvPTR (sv, klass);
413	else	415	else
414	return 0;	416	return 0;
415	}	417	}
416		418
417	inline SV to_sv (const shstr & v) { return newSVpvn_utf8 ((const char )v, v.length ()); }	419	inline SV to_sv (const shstr & v) { return newSVpvn_utf8 ((const char )v, v.length (), 1); }
418	inline SV to_sv (const char v) { return v ? newSVpv (v, 0) : newSV (0); }	420	inline SV to_sv (const char v) { return v ? newSVpv (v, 0) : newSV (0); }
419	inline SV *to_sv (bool v) { return newSViv (v); }	421	inline SV *to_sv (bool v) { return newSViv (v); }
420	inline SV *to_sv ( signed char v) { return newSViv (v); }	422	inline SV *to_sv ( signed char v) { return newSViv (v); }
421	inline SV *to_sv (unsigned char v) { return newSViv (v); }	423	inline SV *to_sv (unsigned char v) { return newSViv (v); }
422	inline SV *to_sv ( signed short v) { return newSViv (v); }	424	inline SV *to_sv ( signed short v) { return newSViv (v); }
…		…
435	inline SV to_sv (maptile v) { return newSVattachable (v, stash_cf_map_wrap); }	437	inline SV to_sv (maptile v) { return newSVattachable (v, stash_cf_map_wrap); }
436	inline SV to_sv (archetype v) { return newSVattachable (v, stash_cf_arch_wrap); }	438	inline SV to_sv (archetype v) { return newSVattachable (v, stash_cf_arch_wrap); }
437	inline SV to_sv (region v) { return newSVattachable (v, stash_cf_region_wrap); }	439	inline SV to_sv (region v) { return newSVattachable (v, stash_cf_region_wrap); }
438	inline SV to_sv (partylist v) { return newSVptr (v, stash_cf_party_wrap); }	440	inline SV to_sv (partylist v) { return newSVptr (v, stash_cf_party_wrap); }
439	inline SV to_sv (living v) { return newSVptr (v, stash_cf_living_wrap); }	441	inline SV to_sv (living v) { return newSVptr (v, stash_cf_living_wrap); }
		442	inline SV to_sv (mapspace v) { return newSVptr (v, stash_cf_mapspace_wrap); }
440		443
441	inline SV *to_sv (object & v) { return to_sv (&v); }	444	inline SV *to_sv (object & v) { return to_sv (&v); }
442	inline SV *to_sv (living & v) { return to_sv (&v); }	445	inline SV *to_sv (living & v) { return to_sv (&v); }
443		446
444	inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); }	447	inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); }
445	inline SV to_sv (const treasurelist v) { return to_sv (v->name); }	448	inline SV to_sv (const treasurelist v) { return to_sv (v->name); }
446		449
		450	inline SV *to_sv (UUID v) { return newSVpv (v.c_str (), 0); }
		451
447	inline SV *to_sv (UUID v)	452	inline SV to_sv (dynbuf v)
448	{	453	{
449	char buf[128];	454	SV *sv = newSV (0);
450	snprintf (buf, 128, "<1.%" PRIx64 ">", v.seq);	455
451	return newSVpv (buf, 0);	456	sv_upgrade (sv, SVt_PV);
		457	SvGROW (sv, v->size () + 1);
		458	SvPOK_only (sv);
		459	v->linearise (SvPVX (sv));
		460	SvCUR_set (sv, v->size ());
		461	*SvEND (sv) = 0;
		462
		463	return sv;
		464	}
		465
		466	inline SV to_sv (dynbuf_text v)
		467	{
		468	SV sv = to_sv (static_cast<dynbuf > (v));
		469	SvUTF8_on (sv);
		470	return sv;
452	}	471	}
453		472
454	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPVutf8_nolen (sv) : 0; }	473	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPVutf8_nolen (sv) : 0; }
455	inline void sv_to (SV sv, char &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }	474	inline void sv_to (SV sv, char &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }
456	inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }	475	inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }
…		…
473	inline void sv_to (SV sv, maptile &v) { v = (maptile )(attachable )SvPTR_ornull (sv, "cf::map"); }	492	inline void sv_to (SV sv, maptile &v) { v = (maptile )(attachable )SvPTR_ornull (sv, "cf::map"); }
474	inline void sv_to (SV sv, region &v) { v = (region )(attachable )SvPTR_ornull (sv, "cf::region"); }	493	inline void sv_to (SV sv, region &v) { v = (region )(attachable )SvPTR_ornull (sv, "cf::region"); }
475	inline void sv_to (SV sv, attachable &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); }	494	inline void sv_to (SV sv, attachable &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); }
476	inline void sv_to (SV sv, partylist &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }	495	inline void sv_to (SV sv, partylist &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }
477	inline void sv_to (SV sv, living &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }	496	inline void sv_to (SV sv, living &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }
		497	inline void sv_to (SV sv, mapspace &v) { v = (mapspace *)SvPTR_ornull (sv, "cf::mapspace"); }
478	inline void sv_to (SV sv, object_freezer &v) { v = (object_freezer *)SvPTR_ornull (sv, "cf::object::freezer"); }	498	inline void sv_to (SV sv, object_freezer &v) { v = (object_freezer *)SvPTR_ornull (sv, "cf::object::freezer"); }
479	inline void sv_to (SV sv, object_thawer &v) { v = (object_thawer *)SvPTR_ornull (sv, "cf::object::thawer" ); }	499	inline void sv_to (SV sv, object_thawer &v) { v = (object_thawer *)SvPTR_ornull (sv, "cf::object::thawer" ); }
480		500
481	//inline void sv_to (SV sv, faceinfo &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }	501	//inline void sv_to (SV sv, faceinfo &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }
482	inline void sv_to (SV sv, treasurelist &v) { v = treasurelist::find (SvPV_nolen (sv)); }	502	inline void sv_to (SV sv, treasurelist &v) { v = treasurelist::find (SvPV_nolen (sv)); }
…		…
499	v.assign (data, len);	519	v.assign (data, len);
500	}	520	}
501		521
502	inline void sv_to (SV *sv, UUID &v)	522	inline void sv_to (SV *sv, UUID &v)
503	{	523	{
504	unsigned int version;	524	if (!v.parse (SvPV_nolen (sv)))
505
506	if (2 != sscanf (SvPV_nolen (sv), "<%d.%" SCNx64 ">", &version, &v.seq) \|\| 1 != version)
507	croak ("unparsable uuid: %s", SvPV_nolen (sv));	525	croak ("unparsable uuid: %s", SvPV_nolen (sv));
508	}	526	}
509		527
510	inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }	528	inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }
511		529
…		…
589	va_end (ap);	607	va_end (ap);
590		608
591	return sv;	609	return sv;
592	}	610	}
593		611
		612	// typemap support, mostly to avoid excessive inlining
		613	template<class type>
		614	static void noinline
		615	cf_obj_to (SV *arg, type &var)
		616	{
		617	sv_to (arg, var);
		618	if (!var)
		619	croak ("must not pass invalid/null cf_obj here");
		620	}
		621
		622	template<class object>
		623	static void noinline
		624	cf_obj_ornull_to (SV arg, object &var)
		625	{
		626	if (SvOK (arg))
		627	{
		628	sv_to (arg, var);
		629	if (!var)
		630	croak ("unable to convert perl object to C++ object");
		631	}
		632	else
		633	var = 0;
		634	}
		635
594	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	636	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
595		637
596	SV *	638	SV *
597	registry (attachable *ext)	639	registry (attachable *ext)
598	{	640	{
…		…
605	/////////////////////////////////////////////////////////////////////////////	647	/////////////////////////////////////////////////////////////////////////////
606		648
607	void	649	void
608	cfperl_init ()	650	cfperl_init ()
609	{	651	{
		652	extern char **environ;
		653
610	PERL_SYS_INIT3 (&settings.argc, &settings.argv, 0);	654	PERL_SYS_INIT3 (&settings.argc, &settings.argv, &environ);
611	perl = perl_alloc ();	655	perl = perl_alloc ();
612	perl_construct (perl);	656	perl_construct (perl);
613		657
614	PL_exit_flags \|= PERL_EXIT_DESTRUCT_END;	658	PL_exit_flags \|= PERL_EXIT_DESTRUCT_END;
615		659
616	const char *argv[] = {	660	const char *argv[] = {
617	settings.argv [0],	661	settings.argv [0],
618	"-e"	662	"-e0"
619	"use EV; use Coro;" // required for bootstrap
620	"cf->bootstrap;" // required for datadir :*>
621	"unshift @INC, cf::datadir ();"
622	"require cf;"
623	};	663	};
624		664
625	if (perl_parse (perl, xs_init, 2, (char )argv, (char )NULL)	665	if (perl_parse (perl, xs_init, 2, (char **)argv, environ)
626	\|\| perl_run (perl))	666	\|\| perl_run (perl))
627	{	667	{
628	printf ("unable to initialize perl-interpreter, aborting.\n");	668	printf ("unable to initialize perl-interpreter, aborting.\n");
629	exit (EXIT_FAILURE);	669	exit (EXIT_FAILURE);
630	}	670	}
631		671
		672	eval_pv (
		673	"#line 1 'cfperl init'\n"
		674	"use EV ();\n"
		675	"use Coro ();\n"
		676	"cf->bootstrap;\n"
		677	"unshift @INC, cf::datadir ();\n"
		678	"require cf;\n",
		679	0
		680	);
		681
		682	if (SvTRUE (ERRSV))
632	{	683	{
633	dSP;	684	printf ("unable to bootstrap perl, aborting:\n%s", SvPV_nolen (ERRSV));
634		685	exit (EXIT_FAILURE);
635	PUSHMARK (SP);
636	PUTBACK;
637	call_pv ("cf::init", G_DISCARD \| G_VOID);
638	}	686	}
639	}	687	}
640		688
		689	void
641	void cfperl_main ()	690	cfperl_main ()
642	{	691	{
643	dSP;	692	dSP;
644		693
645	PUSHMARK (SP);	694	PUSHMARK (SP);
646	PUTBACK;	695	PUTBACK;
…		…
671	# undef def	720	# undef def
672	};	721	};
673		722
674	#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)	723	#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)
675		724
676	static void	725	static void noinline
677	gather_callbacks (AV &callbacks, AV registry, event_type event)	726	gather_callbacks (AV &callbacks, AV registry, event_type event)
678	{	727	{
679	// event must be in array	728	// event must be in array
680	if (event >= 0 && event <= AvFILLp (registry))	729	if (event >= 0 && event <= AvFILLp (registry))
681	{	730	{
…		…
767	{	816	{
768	attachable::gather_callbacks (callbacks, event);	817	attachable::gather_callbacks (callbacks, event);
769	::gather_callbacks (callbacks, cb_map, event);	818	::gather_callbacks (callbacks, cb_map, event);
770	}	819	}
771		820
772	void	821	static void noinline
773	_recalc_want (bitset<NUM_EVENT_TYPES> &set, AV *registry)	822	_recalc_want (bitset<NUM_EVENT_TYPES> &set, AV *registry)
774	{	823	{
775	for (int event = 0; event <= AvFILLp (registry); ++event)	824	for (int event = 0; event <= AvFILLp (registry); ++event)
776	{	825	{
777	SV *cbs_ = AvARRAY (registry)[event];	826	SV *cbs_ = AvARRAY (registry)[event];
…		…
787	}	836	}
788	}	837	}
789	}	838	}
790		839
791	// very slow and inefficient way to recalculate the global want bitsets	840	// very slow and inefficient way to recalculate the global want bitsets
792	void	841	static void
793	_recalc_want ()	842	_recalc_want ()
794	{	843	{
795	ev_want_event.reset ();	844	ev_want_event.reset ();
796		845
797	_recalc_want (ev_want_event, cb_global);	846	_recalc_want (ev_want_event, cb_global);
…		…
908		957
909	/////////////////////////////////////////////////////////////////////////////	958	/////////////////////////////////////////////////////////////////////////////
910	// various c++ => perl glue functions	959	// various c++ => perl glue functions
911		960
912	void	961	void
		962	cfperl_tick ()
		963	{
		964	tick_pending = 1;
		965
		966	if (tick_inhibit)
		967	return;
		968
		969	tick_pending = 0;
		970
		971	dSP;
		972
		973	PUSHMARK (SP);
		974	PUTBACK;
		975	call_pv ("cf::tick", G_DISCARD \| G_VOID);
		976
		977	SvNV_set (sv_next_tick, get_next_tick ()); SvNOK_only (sv_next_tick);
		978	}
		979
		980	void
913	cfperl_emergency_save ()	981	cfperl_emergency_save ()
914	{	982	{
915	CALL_BEGIN (0);	983	CALL_BEGIN (0);
916	CALL_CALL ("cf::emergency_save", G_VOID);	984	CALL_CALL ("cf::emergency_save", G_VOID);
917	CALL_END;	985	CALL_END;
…		…
961	CALL_END;	1029	CALL_END;
962		1030
963	return can;	1031	return can;
964	}	1032	}
965		1033
		1034	void
		1035	cfperl_mapscript_activate (object ob, int state, object activator, object *originator)
		1036	{
		1037	CALL_BEGIN (4);
		1038	CALL_ARG (ob);
		1039	CALL_ARG (state);
		1040	CALL_ARG (activator);
		1041	CALL_ARG (originator);
		1042	CALL_CALL ("cf::mapscript::activate", G_VOID);
		1043	CALL_END;
		1044	}
		1045
966	player *	1046	player *
967	player::find (const char *name)	1047	player::find (const char *name)
968	{	1048	{
969	CALL_BEGIN (1);	1049	CALL_BEGIN (1);
970	CALL_ARG (name);	1050	CALL_ARG (name);
971	CALL_CALL ("cf::player::find", G_SCALAR);	1051	CALL_CALL ("cf::player::find", G_SCALAR);
972		1052
973	player *retval;	1053	player *retval = 0;
974
975	if (count)
976	sv_to (POPs, retval);	1054	if (count) sv_to (POPs, retval);
977	else	1055
978	retval = 0;	1056	CALL_END;
		1057
		1058	return retval;
		1059	}
		1060
		1061	maptile *
		1062	find_style (const char dirname, const char stylename, int difficulty)
		1063	{
		1064	CALL_BEGIN (3);
		1065	CALL_ARG (dirname);
		1066	CALL_ARG (stylename);
		1067	CALL_ARG (difficulty);
		1068	CALL_CALL ("ext::map_random::find_style", G_SCALAR);
		1069
		1070	maptile *retval = 0;
		1071	if (count) sv_to (POPs, retval);
979		1072
980	CALL_END;	1073	CALL_END;
981		1074
982	return retval;	1075	return retval;
983	}	1076	}
…		…
988	CALL_BEGIN (2);	1081	CALL_BEGIN (2);
989	CALL_ARG (path);	1082	CALL_ARG (path);
990	CALL_ARG (origin);	1083	CALL_ARG (origin);
991	CALL_CALL ("cf::map::find_sync", G_SCALAR);	1084	CALL_CALL ("cf::map::find_sync", G_SCALAR);
992		1085
993	maptile *retval;	1086	maptile *retval = 0;
994
995	if (count)
996	sv_to (POPs, retval);	1087	if (count) sv_to (POPs, retval);
997	else
998	retval = 0;
999		1088
1000	CALL_END;	1089	CALL_END;
1001		1090
1002	return retval;	1091	return retval;
1003	}	1092	}
…		…
1009	CALL_ARG (path);	1098	CALL_ARG (path);
1010	CALL_ARG (origin);	1099	CALL_ARG (origin);
1011	CALL_ARG (load);	1100	CALL_ARG (load);
1012	CALL_CALL ("cf::map::find_async", G_SCALAR);	1101	CALL_CALL ("cf::map::find_async", G_SCALAR);
1013		1102
1014	maptile *retval;	1103	maptile *retval = 0;
1015
1016	if (count)
1017	sv_to (POPs, retval);	1104	if (count) sv_to (POPs, retval);
1018	else
1019	retval = 0;
1020		1105
1021	CALL_END;	1106	CALL_END;
1022		1107
1023	return retval;	1108	return retval;
1024	}	1109	}
…		…
1031	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);	1116	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);
1032	CALL_END;	1117	CALL_END;
1033	}	1118	}
1034		1119
1035	void	1120	void
1036	maptile::change_all_map_light (int change)
1037	{
1038	CALL_BEGIN (1);
1039	CALL_ARG (change);
1040	CALL_CALL ("cf::map::change_all_map_light", G_VOID);
1041	CALL_END;
1042	}
1043
1044	void
1045	object::enter_exit (object *exit)	1121	object::enter_exit (object *exit)
1046	{	1122	{
1047	if (type != PLAYER)	1123	if (type != PLAYER)
1048	return;	1124	return;
1049		1125
1050	CALL_BEGIN (2);	1126	CALL_BEGIN (2);
1051	CALL_ARG (this);	1127	CALL_ARG (this);
1052	CALL_ARG (exit);	1128	CALL_ARG (exit);
1053	CALL_CALL ("cf::object::player::enter_exit", G_VOID);	1129	CALL_CALL ("cf::object::player::enter_exit", G_VOID);
		1130	CALL_END;
		1131	}
		1132
		1133	void
		1134	object::player_goto (const char *path, int x, int y)
		1135	{
		1136	if (type != PLAYER)
		1137	return;
		1138
		1139	CALL_BEGIN (4);
		1140	CALL_ARG (this);
		1141	CALL_ARG (path);
		1142	CALL_ARG (x);
		1143	CALL_ARG (y);
		1144	CALL_CALL ("cf::object::player::goto", G_VOID);
1054	CALL_END;	1145	CALL_END;
1055	}	1146	}
1056		1147
1057	const char *	1148	const char *
1058	object::ref () const	1149	object::ref () const
…		…
1097	CALL_CALL ("cf::_log_backtrace", G_VOID);	1188	CALL_CALL ("cf::_log_backtrace", G_VOID);
1098	CALL_END;	1189	CALL_END;
1099	#endif	1190	#endif
1100	}	1191	}
1101		1192
		1193	bool is_match_expr (const char *expr)
		1194	{
		1195	return !strncmp (expr, "match ", sizeof ("match ") - 1);
		1196	}
		1197
		1198	bool match (const char expr, object ob, object self, object source, object *originator)
		1199	{
		1200	bool matched;
		1201
		1202	CALL_BEGIN (5);
		1203	CALL_ARG (expr);
		1204	CALL_ARG (ob);
		1205	CALL_ARG (self);
		1206	CALL_ARG (source);
		1207	CALL_ARG (originator);
		1208	CALL_CALL ("cf::match::match", G_SCALAR);
		1209
		1210	matched = count && SvTRUE (POPs);
		1211
		1212	CALL_END;
		1213
		1214	return matched;
		1215	}
		1216
1102	/////////////////////////////////////////////////////////////////////////////	1217	/////////////////////////////////////////////////////////////////////////////
1103		1218
1104	struct EVAPI *evapi::GEVAPI;	1219	struct EVAPI *evapi::GEVAPI;
1105	struct CoroAPI *coroapi::GCoroAPI;	1220	struct CoroAPI *coroapi::GCoroAPI;
1106		1221
1107	int coroapi::cede_counter;	1222	void
1108	tstamp coroapi::next_cede;
1109
1110	void coroapi::do_cede_to_tick ()	1223	coroapi::do_cede_to_tick ()
1111	{	1224	{
1112	cede_counter = 0;	1225	cede_pending = 0;
1113
1114	cede ();	1226	cede ();
1115
1116	next_cede += (TICK / CEDES_PER_TICK) * 0.99;
1117	if (next_cede > SvNVx (sv_next_tick) - 0.02)
1118	next_cede = SvNVx (sv_next_tick);
1119	}
1120
1121	void coroapi::do_cede_every ()
1122	{
1123	cede_counter = 0;
1124
1125	if (coroapi::nready ())
1126	coroapi::cede ();
1127	}
1128
1129	void coroapi::do_cede_to_tick_every ()
1130	{
1131	cede_counter = 0;
1132
1133	cede_to_tick ();
1134	}	1227	}
1135		1228
1136	void	1229	void
1137	coroapi::wait_for_tick ()	1230	coroapi::wait_for_tick ()
1138	{	1231	{
…		…
1159	ev_io_set ((ev_io *)this, fd, events);	1252	ev_io_set ((ev_io *)this, fd, events);
1160	if (active) start ();	1253	if (active) start ();
1161	}	1254	}
1162	}	1255	}
1163		1256
1164	void	1257	static void
1165	_connect_to_perl ()	1258	_connect_to_perl ()
1166	{	1259	{
1167	stash_cf = gv_stashpv ("cf" , 1);	1260	stash_cf = gv_stashpv ("cf", 1);
1168		1261
1169	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);	1262	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);
1170	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);	1263	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);
1171	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);	1264	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);
1172	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);	1265	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);
		1266	stash_cf_mapspace_wrap = gv_stashpv ("cf::mapspace::wrap" , 1);
1173	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);	1267	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);
1174	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);	1268	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
1175	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);	1269	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
1176	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);	1270	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
1177	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);	1271	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
1178		1272
1179	sv_now = get_sv ("cf::NOW" , 1); sv_upgrade (sv_now , SVt_NV);	1273	sv_now = get_sv ("cf::NOW" , 1); SvUPGRADE (sv_now , SVt_NV);
1180	sv_runtime = get_sv ("cf::RUNTIME" , 1); sv_upgrade (sv_runtime , SVt_NV);	1274	sv_runtime = get_sv ("cf::RUNTIME" , 1); SvUPGRADE (sv_runtime , SVt_NV);
		1275	sv_tick_start = get_sv ("cf::TICK_START", 1); SvUPGRADE (sv_tick_start, SVt_NV);
1181	sv_next_tick = get_sv ("cf::NEXT_TICK", 1); sv_upgrade (sv_next_tick, SVt_NV);	1276	sv_next_tick = get_sv ("cf::NEXT_TICK" , 1); SvUPGRADE (sv_next_tick , SVt_NV);
1182		1277
1183	cb_global = get_av ("cf::CB_GLOBAL", 1);	1278	cb_global = get_av ("cf::CB_GLOBAL", 1);
1184	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);	1279	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
1185	cb_object = get_av ("cf::CB_OBJECT", 1);	1280	cb_object = get_av ("cf::CB_OBJECT", 1);
1186	cb_player = get_av ("cf::CB_PLAYER", 1);	1281	cb_player = get_av ("cf::CB_PLAYER", 1);
1187	cb_client = get_av ("cf::CB_CLIENT", 1);	1282	cb_client = get_av ("cf::CB_CLIENT", 1);
1188	cb_type = get_av ("cf::CB_TYPE" , 1);	1283	cb_type = get_av ("cf::CB_TYPE" , 1);
1189	cb_map = get_av ("cf::CB_MAP" , 1);	1284	cb_map = get_av ("cf::CB_MAP" , 1);
		1285
		1286	av_reflect = get_av ("cf::REFLECT" , 1);
1190	}	1287	}
1191		1288
1192	MODULE = cf PACKAGE = cf PREFIX = cf_	1289	MODULE = cf PACKAGE = cf PREFIX = cf_
1193		1290
1194	BOOT:	1291	BOOT:
…		…
1257	const_iv (FORCE) const_iv (POTION_EFFECT) const_iv (EVENT_CONNECTOR) const_iv (CLOSE_CON)	1354	const_iv (FORCE) const_iv (POTION_EFFECT) const_iv (EVENT_CONNECTOR) const_iv (CLOSE_CON)
1258	const_iv (CONTAINER) const_iv (ARMOUR_IMPROVER) const_iv (WEAPON_IMPROVER) const_iv (SKILLSCROLL)	1355	const_iv (CONTAINER) const_iv (ARMOUR_IMPROVER) const_iv (WEAPON_IMPROVER) const_iv (SKILLSCROLL)
1259	const_iv (DEEP_SWAMP) const_iv (IDENTIFY_ALTAR) const_iv (MENU) const_iv (RUNE)	1356	const_iv (DEEP_SWAMP) const_iv (IDENTIFY_ALTAR) const_iv (MENU) const_iv (RUNE)
1260	const_iv (TRAP) const_iv (POWER_CRYSTAL) const_iv (CORPSE) const_iv (DISEASE)	1357	const_iv (TRAP) const_iv (POWER_CRYSTAL) const_iv (CORPSE) const_iv (DISEASE)
1261	const_iv (SYMPTOM) const_iv (BUILDER) const_iv (MATERIAL) const_iv (ITEM_TRANSFORMER)	1358	const_iv (SYMPTOM) const_iv (BUILDER) const_iv (MATERIAL) const_iv (ITEM_TRANSFORMER)
		1359	const_iv (MAPSCRIPT) const_iv (SAFE_GROUND)
1262		1360
1263	const_iv (NUM_TYPES) const_iv (NUM_SUBTYPES)	1361	const_iv (NUM_TYPES) const_iv (NUM_SUBTYPES)
1264		1362
1265	const_iv (ST_BD_BUILD) const_iv (ST_BD_REMOVE)	1363	const_iv (ST_BD_BUILD) const_iv (ST_BD_REMOVE)
1266	const_iv (ST_MAT_FLOOR) const_iv (ST_MAT_WALL) const_iv (ST_MAT_ITEM)	1364	const_iv (ST_MAT_FLOOR) const_iv (ST_MAT_WALL) const_iv (ST_MAT_ITEM)
…		…
1296	const_iv (FLAG_CURSED) const_iv (FLAG_DAMNED) const_iv (FLAG_SEE_ANYWHERE) const_iv (FLAG_KNOWN_MAGICAL)	1394	const_iv (FLAG_CURSED) const_iv (FLAG_DAMNED) const_iv (FLAG_SEE_ANYWHERE) const_iv (FLAG_KNOWN_MAGICAL)
1297	const_iv (FLAG_KNOWN_CURSED) const_iv (FLAG_CAN_USE_SKILL) const_iv (FLAG_BEEN_APPLIED) const_iv (FLAG_READY_SCROLL)	1395	const_iv (FLAG_KNOWN_CURSED) const_iv (FLAG_CAN_USE_SKILL) const_iv (FLAG_BEEN_APPLIED) const_iv (FLAG_READY_SCROLL)
1298	const_iv (FLAG_USE_ROD) const_iv (FLAG_USE_HORN) const_iv (FLAG_MAKE_INVIS) const_iv (FLAG_INV_LOCKED)	1396	const_iv (FLAG_USE_ROD) const_iv (FLAG_USE_HORN) const_iv (FLAG_MAKE_INVIS) const_iv (FLAG_INV_LOCKED)
1299	const_iv (FLAG_IS_WOODED) const_iv (FLAG_IS_HILLY) const_iv (FLAG_READY_SKILL) const_iv (FLAG_READY_WEAPON)	1397	const_iv (FLAG_IS_WOODED) const_iv (FLAG_IS_HILLY) const_iv (FLAG_READY_SKILL) const_iv (FLAG_READY_WEAPON)
1300	const_iv (FLAG_NO_SKILL_IDENT) const_iv (FLAG_BLIND) const_iv (FLAG_SEE_IN_DARK) const_iv (FLAG_IS_CAULDRON)	1398	const_iv (FLAG_NO_SKILL_IDENT) const_iv (FLAG_BLIND) const_iv (FLAG_SEE_IN_DARK) const_iv (FLAG_IS_CAULDRON)
1301	const_iv (FLAG_NO_STEAL) const_iv (FLAG_ONE_HIT) const_iv (FLAG_CLIENT_SENT) const_iv (FLAG_BERSERK)	1399	const_iv (FLAG_NO_STEAL) const_iv (FLAG_ONE_HIT) const_iv (FLAG_DEBUG) const_iv (FLAG_BERSERK)
1302	const_iv (FLAG_NEUTRAL) const_iv (FLAG_NO_ATTACK) const_iv (FLAG_NO_DAMAGE) const_iv (FLAG_OBJ_ORIGINAL)	1400	const_iv (FLAG_NEUTRAL) const_iv (FLAG_NO_ATTACK) const_iv (FLAG_NO_DAMAGE) const_iv (FLAG_OBJ_ORIGINAL)
1303	const_iv (FLAG_ACTIVATE_ON_PUSH) const_iv (FLAG_ACTIVATE_ON_RELEASE) const_iv (FLAG_IS_WATER)	1401	const_iv (FLAG_ACTIVATE_ON_PUSH) const_iv (FLAG_ACTIVATE_ON_RELEASE) const_iv (FLAG_IS_WATER) const_iv (FLAG_WIZLOOK)
1304	const_iv (FLAG_CONTENT_ON_GEN) const_iv (FLAG_IS_A_TEMPLATE) const_iv (FLAG_IS_BUILDABLE)	1402	const_iv (FLAG_CONTENT_ON_GEN) const_iv (FLAG_IS_A_TEMPLATE) const_iv (FLAG_IS_BUILDABLE)
1305	const_iv (FLAG_DESTROY_ON_DEATH) const_iv (FLAG_NO_MAP_SAVE)	1403	const_iv (FLAG_DESTROY_ON_DEATH) const_iv (FLAG_NO_MAP_SAVE)
1306		1404
1307	const_iv (NDI_BLACK) const_iv (NDI_WHITE) const_iv (NDI_NAVY) const_iv (NDI_RED)	1405	const_iv (NDI_BLACK) const_iv (NDI_WHITE) const_iv (NDI_NAVY) const_iv (NDI_RED)
1308	const_iv (NDI_ORANGE) const_iv (NDI_BLUE) const_iv (NDI_DK_ORANGE) const_iv (NDI_GREEN)	1406	const_iv (NDI_ORANGE) const_iv (NDI_BLUE) const_iv (NDI_DK_ORANGE) const_iv (NDI_GREEN)
1309	const_iv (NDI_LT_GREEN) const_iv (NDI_GREY) const_iv (NDI_BROWN) const_iv (NDI_GOLD)	1407	const_iv (NDI_LT_GREEN) const_iv (NDI_GREY) const_iv (NDI_BROWN) const_iv (NDI_GOLD)
1310	const_iv (NDI_TAN) const_iv (NDI_MAX_COLOR) const_iv (NDI_COLOR_MASK) const_iv (NDI_UNIQUE)	1408	const_iv (NDI_TAN) const_iv (NDI_MAX_COLOR) const_iv (NDI_COLOR_MASK) const_iv (NDI_UNIQUE)
1311	const_iv (NDI_ALL) const_iv (NDI_DEF) const_iv (NDI_REPLY) const_iv (NDI_CLIENT_MASK)	1409	const_iv (NDI_ALL) const_iv (NDI_DEF) const_iv (NDI_REPLY) const_iv (NDI_CLIENT_MASK)
1312	const_iv (NDI_NOCREATE) const_iv (NDI_CLEAR)	1410	const_iv (NDI_NOCREATE) const_iv (NDI_CLEAR) const_iv (NDI_VERBATIM)
1313		1411
1314	const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE)	1412	const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE)
1315	const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF)	1413	const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF)
1316		1414
1317	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_DAMAGE)	1415	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_DAMAGE)
…		…
1369	const_iv (F_CURSED) const_iv (F_DAMNED) const_iv (F_OPEN) const_iv (F_NOPICK)	1467	const_iv (F_CURSED) const_iv (F_DAMNED) const_iv (F_OPEN) const_iv (F_NOPICK)
1370	const_iv (F_LOCKED)	1468	const_iv (F_LOCKED)
1371		1469
1372	const_iv (F_BUY) const_iv (F_SHOP) const_iv (F_SELL)	1470	const_iv (F_BUY) const_iv (F_SHOP) const_iv (F_SELL)
1373		1471
1374	const_iv (P_BLOCKSVIEW) const_iv (P_PLAYER) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE)	1472	const_iv (P_BLOCKSVIEW) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE)
1375	const_iv (P_NO_CLERIC) const_iv (P_OUT_OF_MAP) const_iv (P_NEW_MAP) const_iv (P_UPTODATE)	1473	const_iv (P_NO_CLERIC) const_iv (P_OUT_OF_MAP) const_iv (P_NEW_MAP) const_iv (P_UPTODATE)
1376		1474
1377	const_iv (UP_OBJ_INSERT) const_iv (UP_OBJ_REMOVE) const_iv (UP_OBJ_CHANGE) const_iv (UP_OBJ_FACE)	1475	const_iv (UP_OBJ_INSERT) const_iv (UP_OBJ_REMOVE) const_iv (UP_OBJ_CHANGE) const_iv (UP_OBJ_FACE)
1378		1476
1379	const_iv (INS_NO_MERGE) const_iv (INS_ABOVE_FLOOR_ONLY) const_iv (INS_NO_WALK_ON)	1477	const_iv (INS_NO_MERGE) const_iv (INS_ABOVE_FLOOR_ONLY) const_iv (INS_NO_WALK_ON)
…		…
1419	const_iv (ATNR_PARALYZE) const_iv (ATNR_TURN_UNDEAD) const_iv (ATNR_FEAR) const_iv (ATNR_CANCELLATION)	1517	const_iv (ATNR_PARALYZE) const_iv (ATNR_TURN_UNDEAD) const_iv (ATNR_FEAR) const_iv (ATNR_CANCELLATION)
1420	const_iv (ATNR_DEPLETE) const_iv (ATNR_DEATH) const_iv (ATNR_CHAOS) const_iv (ATNR_COUNTERSPELL)	1518	const_iv (ATNR_DEPLETE) const_iv (ATNR_DEATH) const_iv (ATNR_CHAOS) const_iv (ATNR_COUNTERSPELL)
1421	const_iv (ATNR_GODPOWER) const_iv (ATNR_HOLYWORD) const_iv (ATNR_BLIND) const_iv (ATNR_INTERNAL)	1519	const_iv (ATNR_GODPOWER) const_iv (ATNR_HOLYWORD) const_iv (ATNR_BLIND) const_iv (ATNR_INTERNAL)
1422	const_iv (ATNR_LIFE_STEALING) const_iv (ATNR_DISEASE)	1520	const_iv (ATNR_LIFE_STEALING) const_iv (ATNR_DISEASE)
1423		1521
1424	const_iv (MAP_IN_MEMORY) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)	1522	const_iv (MAP_ACTIVE) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)
		1523	const_iv (MAP_INACTIVE)
1425		1524
1426	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)	1525	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)
1427	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)	1526	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)
1428		1527
1429	const_iv (VERSION_CS) const_iv (VERSION_SC)	1528	const_iv (VERSION_CS) const_iv (VERSION_SC)
…		…
1444		1543
1445	const_iv (SYMMETRY_RANDOM) const_iv (SYMMETRY_NONE) const_iv (SYMMETRY_X)	1544	const_iv (SYMMETRY_RANDOM) const_iv (SYMMETRY_NONE) const_iv (SYMMETRY_X)
1446	const_iv (SYMMETRY_Y) const_iv (SYMMETRY_XY)	1545	const_iv (SYMMETRY_Y) const_iv (SYMMETRY_XY)
1447		1546
1448	const_iv (GT_ENVIRONMENT) const_iv (GT_INVISIBLE) const_iv (GT_STARTEQUIP)	1547	const_iv (GT_ENVIRONMENT) const_iv (GT_INVISIBLE) const_iv (GT_STARTEQUIP)
1449	const_iv (GT_APPLY) const_iv (GT_ONLY_GOOD) const_iv (GT_UPDATE_INV)	1548	const_iv (GT_APPLY) const_iv (GT_ONLY_GOOD) const_iv (GT_MINIMAL)
1450	const_iv (GT_MINIMAL)
1451		1549
1452	const_iv (FT_FACE) const_iv (FT_MUSIC) const_iv (FT_SOUND)	1550	const_iv (FT_FACE) const_iv (FT_MUSIC) const_iv (FT_SOUND)
1453	const_iv (FT_RSRC) const_iv (FT_NUM)	1551	const_iv (FT_RSRC) const_iv (FT_NUM)
1454	};	1552	};
1455		1553
…		…
1477	av_store (av, eiv->iv, newRV_noinc ((SV *)event));	1575	av_store (av, eiv->iv, newRV_noinc ((SV *)event));
1478	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));	1576	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));
1479	}	1577	}
1480	}	1578	}
1481		1579
		1580	void _gv_clear (SV *gv)
		1581	CODE:
		1582	assert (SvTYPE (gv) == SVt_PVGV);
		1583	# define f(sv) { SV sv_ = (SV )(sv); sv = 0; SvREFCNT_dec (sv_); }
		1584	f (GvGP (gv)->gp_form);
		1585	f (GvGP (gv)->gp_io);
		1586	f (GvGP (gv)->gp_sv);
		1587	f (GvGP (gv)->gp_av);
		1588	f (GvGP (gv)->gp_hv);
		1589	f (GvGP (gv)->gp_cv);
		1590	GvCVGEN (gv) = 0;
		1591	GvMULTI_off (gv);
		1592	# undef f
		1593
1482	void _connect_to_perl ()	1594	void _connect_to_perl ()
1483		1595
1484	void _recalc_want ()	1596	void _recalc_want ()
1485		1597
		1598	# not used by default anymore
1486	void _global_reattach ()	1599	void _global_reattach ()
1487	CODE:	1600	CODE:
1488	{	1601	{
1489	// reattach to all attachable objects in the game.	1602	// reattach to all attachable objects in the game.
1490	for_all_clients (ns)	1603	for_all_clients (ns)
…		…
1534	}	1647	}
1535		1648
1536	SvCUR_set (data_sv, dst - SvPVX (data_sv));	1649	SvCUR_set (data_sv, dst - SvPVX (data_sv));
1537	}	1650	}
1538		1651
		1652	void init_anim ()
		1653
		1654	void init_globals ()
		1655
		1656	void init_experience ()
		1657
		1658	void init_attackmess ()
		1659
		1660	void init_dynamic ()
		1661
		1662	void load_settings ()
		1663
		1664	void load_materials ()
		1665
		1666	void init_uuid ()
		1667	CODE:
		1668	UUID::init ();
		1669
		1670	void init_signals ()
		1671
		1672	void init_commands ()
		1673
		1674	void init_skills ()
		1675
		1676	void init_beforeplay ()
		1677
		1678	void evthread_start (int aiofd)
		1679
1539	void _post_tick ()	1680	void cede_to_tick ()
1540	CODE:	1681	CODE:
1541	coroapi::next_cede = SvNVx (sv_next_tick) - TICK * (1. - 1. / CEDES_PER_TICK);	1682	coroapi::cede_to_tick ();
1542		1683
1543	NV till_cede ()	1684	NV till_tick ()
1544	CODE:	1685	CODE:
1545	RETVAL = coroapi::next_cede - now ();	1686	RETVAL = SvNVX (sv_next_tick) - now ();
1546	OUTPUT:	1687	OUTPUT:
1547	RETVAL	1688	RETVAL
1548		1689
1549	NV till_tick ()	1690	int tick_inhibit ()
1550	CODE:	1691	CODE:
1551	RETVAL = SvNVx (sv_next_tick) - now ();	1692	RETVAL = tick_inhibit;
1552	OUTPUT:	1693	OUTPUT:
1553	RETVAL	1694	RETVAL
1554		1695
		1696	void tick_inhibit_inc ()
		1697	CODE:
		1698	++tick_inhibit;
		1699
		1700	void tick_inhibit_dec ()
		1701	CODE:
		1702	if (!--tick_inhibit)
		1703	if (tick_pending)
		1704	{
		1705	ev_async_send (EV_DEFAULT, &tick_watcher);
		1706	coroapi::cede ();
		1707	}
		1708
		1709	void server_tick ()
		1710	CODE:
		1711	{
		1712	NOW = ev_now (EV_DEFAULT);
		1713	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1714	SvNV_set (sv_tick_start, NOW); SvNOK_only (sv_tick_start);
		1715	runtime = SvNVX (sv_runtime);
		1716
		1717	server_tick ();
		1718
		1719	NOW = ev_time ();
		1720	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1721	runtime += TICK;
		1722	SvNV_set (sv_runtime, runtime); SvNOK_only (sv_runtime);
		1723	}
		1724
1555	NV floor (NV x)	1725	NV floor (NV x)
1556		1726
1557	NV ceil (NV x)	1727	NV ceil (NV x)
1558		1728
1559	NV rndm (...)	1729	NV rndm (...)
		1730	ALIAS:
		1731	rmg_rndm = 1
1560	CODE:	1732	CODE:
		1733	{
		1734	rand_gen &gen = ix ? rmg_rndm : rndm;
1561	switch (items)	1735	switch (items)
1562	{	1736	{
1563	case 0: RETVAL = rndm (); break;	1737	case 0: RETVAL = gen (); break;
1564	case 1: RETVAL = rndm (SvUV (ST (0))); break;	1738	case 1: RETVAL = gen (SvUV (ST (0))); break;
1565	case 2: RETVAL = rndm (SvIV (ST (0)), SvIV (ST (1))); break;	1739	case 2: RETVAL = gen (SvIV (ST (0)), SvIV (ST (1))); break;
1566	default: croak ("cf::rndm requires none, one or two parameters."); break;	1740	default: croak ("cf::rndm requires none, one or two parameters."); break;
1567	}	1741	}
		1742	}
1568	OUTPUT:	1743	OUTPUT:
1569	RETVAL	1744	RETVAL
1570		1745
1571	NV clamp (NV value, NV min_value, NV max_value)	1746	NV clamp (NV value, NV min_value, NV max_value)
1572	CODE:	1747	CODE:
…		…
1578	CODE:	1753	CODE:
1579	RETVAL = lerp (value, min_in, max_in, min_out, max_out);	1754	RETVAL = lerp (value, min_in, max_in, min_out, max_out);
1580	OUTPUT:	1755	OUTPUT:
1581	RETVAL	1756	RETVAL
1582		1757
1583	void cede_to_tick ()	1758	void weaken (...)
1584	CODE:	1759	PROTOTYPE: @
1585	coroapi::cede_to_tick ();	1760	CODE:
1586		1761	while (items > 0)
1587	void server_tick ()	1762	sv_rvweaken (ST (--items));
1588	CODE:
1589	NOW = SvNVx (sv_now);
1590	runtime = SvNVx (sv_runtime);
1591	server_tick ();
1592		1763
1593	void	1764	void
1594	log_backtrace (utf8_string msg)	1765	log_backtrace (utf8_string msg)
1595		1766
1596	void	1767	void
…		…
1601	octet_string path_combine (octet_string base, octet_string path)	1772	octet_string path_combine (octet_string base, octet_string path)
1602	PROTOTYPE: $$	1773	PROTOTYPE: $$
1603		1774
1604	octet_string path_combine_and_normalize (octet_string base, octet_string path)	1775	octet_string path_combine_and_normalize (octet_string base, octet_string path)
1605	PROTOTYPE: $$	1776	PROTOTYPE: $$
1606
1607	void
1608	mallinfo ()
1609	PPCODE:
1610	{
1611	#if __GLIBC__
1612	struct mallinfo mai = mallinfo ();
1613	EXTEND (SP, 10*2);
1614	PUSHs (sv_2mortal (newSVpv ("arena" , 0))); PUSHs (sv_2mortal (newSViv (mai.arena)));
1615	PUSHs (sv_2mortal (newSVpv ("ordblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.ordblks)));
1616	PUSHs (sv_2mortal (newSVpv ("smblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.smblks)));
1617	PUSHs (sv_2mortal (newSVpv ("hblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblks)));
1618	PUSHs (sv_2mortal (newSVpv ("hblkhd" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblkhd)));
1619	PUSHs (sv_2mortal (newSVpv ("usmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.usmblks)));
1620	PUSHs (sv_2mortal (newSVpv ("fsmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.fsmblks)));
1621	PUSHs (sv_2mortal (newSVpv ("uordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.uordblks)));
1622	PUSHs (sv_2mortal (newSVpv ("fordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.fordblks)));
1623	PUSHs (sv_2mortal (newSVpv ("keepcost", 0))); PUSHs (sv_2mortal (newSViv (mai.keepcost)));
1624	#endif
1625	EXTEND (SP, 2*2);
1626	PUSHs (sv_2mortal (newSVpv ("slice_alloc", 0))); PUSHs (sv_2mortal (newSVuv (slice_alloc)));
1627	PUSHs (sv_2mortal (newSVpv ("shstr_alloc", 0))); PUSHs (sv_2mortal (newSVuv (shstr_alloc)));
1628	}
1629		1777
1630	void	1778	void
1631	sub_generation_inc ()	1779	sub_generation_inc ()
1632	CODE:	1780	CODE:
1633	PL_sub_generation++;	1781	PL_sub_generation++;
…		…
1658		1806
1659	void abort ()	1807	void abort ()
1660		1808
1661	void reset_signals ()	1809	void reset_signals ()
1662		1810
1663	void fork_abort (octet_string cause = "cf::fork_abort")	1811	void fork_abort (const_octet_string cause = "cf::fork_abort")
1664		1812
1665	void cleanup (octet_string cause, bool make_core = false)	1813	void cleanup (const_octet_string cause, bool make_core = false)
1666		1814
1667	void emergency_save ()	1815	void emergency_save ()
1668		1816
1669	void _exit (int status = EXIT_SUCCESS)	1817	void _exit (int status = EXIT_SUCCESS)
1670		1818
1671	#if _POSIX_MEMLOCK	1819	#if _POSIX_MEMLOCK
1672		1820
1673	int mlockall (int flags = MCL_CURRENT \| MCL_FUTURE)	1821	int mlockall (int flags = MCL_CURRENT \| MCL_FUTURE)
		1822	INIT:
		1823	#if __GLIBC__
		1824	mallopt (M_TOP_PAD, 1024 * 1024);
		1825	mallopt (M_MMAP_THRESHOLD, 1024 * 1024 * 128);
		1826	mallopt (M_MMAP_MAX, 0); // likely bug-workaround, also frees memory
		1827	mallopt (M_PERTURB, 0xee); // bug-workaround for linux glibc+mlockall+calloc
		1828	#endif
1674		1829
1675	int munlockall ()	1830	int munlockall ()
1676		1831
1677	#endif	1832	#endif
		1833
		1834	int
		1835	malloc_trim (IV pad = 0)
		1836
		1837	void
		1838	mallinfo ()
		1839	PPCODE:
		1840	{
		1841	#if __GLIBC__
		1842	struct mallinfo mai = mallinfo ();
		1843	EXTEND (SP, 10*2);
		1844	PUSHs (sv_2mortal (newSVpv ("arena" , 0))); PUSHs (sv_2mortal (newSViv (mai.arena)));
		1845	PUSHs (sv_2mortal (newSVpv ("ordblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.ordblks)));
		1846	PUSHs (sv_2mortal (newSVpv ("smblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.smblks)));
		1847	PUSHs (sv_2mortal (newSVpv ("hblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblks)));
		1848	PUSHs (sv_2mortal (newSVpv ("hblkhd" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblkhd)));
		1849	PUSHs (sv_2mortal (newSVpv ("usmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.usmblks)));
		1850	PUSHs (sv_2mortal (newSVpv ("fsmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.fsmblks)));
		1851	PUSHs (sv_2mortal (newSVpv ("uordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.uordblks)));
		1852	PUSHs (sv_2mortal (newSVpv ("fordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.fordblks)));
		1853	PUSHs (sv_2mortal (newSVpv ("keepcost", 0))); PUSHs (sv_2mortal (newSViv (mai.keepcost)));
		1854	#endif
		1855	EXTEND (SP, 5*2);
		1856	PUSHs (sv_2mortal (newSVpv ("slice_alloc", 0))); PUSHs (sv_2mortal (newSVuv (slice_alloc)));
		1857	PUSHs (sv_2mortal (newSVpv ("shstr_alloc", 0))); PUSHs (sv_2mortal (newSVuv (shstr_alloc)));
		1858	PUSHs (sv_2mortal (newSVpv ("objects" , 0))); PUSHs (sv_2mortal (newSVuv (objects.size () * sizeof (object))));
		1859	PUSHs (sv_2mortal (newSVpv ("sv_count" , 0))); PUSHs (sv_2mortal (newSVuv (PL_sv_count)));
		1860	PUSHs (sv_2mortal (newSVpv ("sv_objcount", 0))); PUSHs (sv_2mortal (newSVuv (PL_sv_objcount)));
		1861	}
1678		1862
1679	int find_animation (utf8_string text)	1863	int find_animation (utf8_string text)
1680	PROTOTYPE: $	1864	PROTOTYPE: $
1681		1865
1682	int random_roll (int min, int max, object *op, int goodbad);	1866	int random_roll (int min, int max, object *op, int goodbad);
…		…
1720	RETVAL = newSVpv (resist_plus[atnr], 0);	1904	RETVAL = newSVpv (resist_plus[atnr], 0);
1721	else	1905	else
1722	XSRETURN_UNDEF;	1906	XSRETURN_UNDEF;
1723	OUTPUT: RETVAL	1907	OUTPUT: RETVAL
1724		1908
		1909	UUID
		1910	uuid_cur ()
		1911	CODE:
		1912	RETVAL = UUID::cur;
		1913	OUTPUT:
		1914	RETVAL
		1915
		1916	UUID
		1917	uuid_gen ()
		1918	CODE:
		1919	RETVAL = UUID::gen ();
		1920	OUTPUT:
		1921	RETVAL
		1922
		1923	val64
		1924	uuid_seq (UUID uuid)
		1925	CODE:
		1926	RETVAL = uuid.seq;
		1927	OUTPUT:
		1928	RETVAL
		1929
		1930	UUID
		1931	uuid_str (val64 seq)
		1932	CODE:
		1933	RETVAL.seq = seq;
		1934	OUTPUT:
		1935	RETVAL
		1936
		1937	void
		1938	coin_names ()
		1939	PPCODE:
		1940	EXTEND (SP, NUM_COINS);
		1941	for (int i = 0; i < NUM_COINS; ++i)
		1942	PUSHs (sv_2mortal (newSVpv (coins [i], 0)));
		1943
		1944	void
		1945	coin_archetypes ()
		1946	PPCODE:
		1947	EXTEND (SP, NUM_COINS);
		1948	for (int i = 0; i < NUM_COINS; ++i)
		1949	PUSHs (sv_2mortal (to_sv (archetype::find (coins [i]))));
		1950
1725	bool	1951	bool
1726	load_resource_file (octet_string filename)	1952	load_resource_file_ (octet_string filename)
		1953
		1954	void
		1955	fix_weight ()
1727		1956
1728	MODULE = cf PACKAGE = cf::attachable	1957	MODULE = cf PACKAGE = cf::attachable
1729		1958
1730	int	1959	int
1731	valid (SV *obj)	1960	valid (SV *obj)
…		…
1795	object *actives (U32 index)	2024	object *actives (U32 index)
1796	CODE:	2025	CODE:
1797	RETVAL = index < actives.size () ? actives [index] : 0;	2026	RETVAL = index < actives.size () ? actives [index] : 0;
1798	OUTPUT: RETVAL	2027	OUTPUT: RETVAL
1799		2028
		2029	int mortals_size ()
		2030	CODE:
		2031	RETVAL = attachable::mortals.size ();
		2032	OUTPUT: RETVAL
		2033
1800	const char *slot_use_name (U32 slot)	2034	const char *slot_use_name (U32 slot)
1801	ALIAS:	2035	ALIAS:
1802	slot_nonuse_name = 1	2036	slot_nonuse_name = 1
1803	CODE:	2037	CODE:
1804	{	2038	{
…		…
1883	CODE:	2117	CODE:
1884	player_apply_below (op);	2118	player_apply_below (op);
1885		2119
1886	int cast_heal (object op, object caster, object *spell, int dir = 0)	2120	int cast_heal (object op, object caster, object *spell, int dir = 0)
1887		2121
1888	#//TODO
1889	object clone_ (object op, int recursive = 0)
1890	CODE:
1891	if (recursive)
1892	RETVAL = object_create_clone (op);
1893	else
1894	{
1895	RETVAL = object::create ();
1896	op->copy_to (RETVAL);
1897	}
1898	OUTPUT: RETVAL
1899
1900	int pay_item (object op, object buyer)	2122	int pay_item (object op, object buyer)
1901	CODE:	2123	CODE:
1902	RETVAL = pay_for_item (op, buyer);	2124	RETVAL = pay_for_item (op, buyer);
1903	OUTPUT: RETVAL	2125	OUTPUT: RETVAL
1904		2126
…		…
1948		2170
1949	int kill_object (object op, int dam = 0, object hitter = 0, int type = AT_PHYSICAL)	2171	int kill_object (object op, int dam = 0, object hitter = 0, int type = AT_PHYSICAL)
1950		2172
1951	int calc_skill_exp (object who, object op, object *skill);	2173	int calc_skill_exp (object who, object op, object *skill);
1952		2174
1953	void push_button (object *op);	2175	void push_button (object op, object originator);
1954		2176
1955	void use_trigger (object *op);	2177	void use_trigger (object op, object originator);
1956
1957	void add_button_link (object button, maptile map, int connected);
1958
1959	void remove_button_link (object *op);
1960		2178
1961	void handle_apply_yield (object *op);	2179	void handle_apply_yield (object *op);
		2180
		2181	int convert_item (object item, object converter);
1962		2182
1963		2183
1964	MODULE = cf PACKAGE = cf::object PREFIX = cf_	2184	MODULE = cf PACKAGE = cf::object PREFIX = cf_
1965		2185
1966	# no clean way to get an object from an archetype - stupid idiotic	2186	# no clean way to get an object from an archetype - stupid idiotic
…		…
1981	CODE:	2201	CODE:
1982	{	2202	{
1983	RETVAL = insert_ob_in_map_at (ob, where, orig, flag, x, y);	2203	RETVAL = insert_ob_in_map_at (ob, where, orig, flag, x, y);
1984	}	2204	}
1985		2205
1986	const_utf8_string get_ob_key_value (object *op, utf8_string key)	2206	shstr
		2207	object::kv_get (shstr key)
1987		2208
1988	bool set_ob_key_value (object *op, utf8_string key, utf8_string value = 0, int add_key = 1)	2209	void
		2210	object::kv_del (shstr key)
		2211
		2212	void
		2213	object::kv_set (shstr key, shstr value)
1989		2214
1990	object get_nearest_player (object ob)	2215	object get_nearest_player (object ob)
1991	ALIAS: nearest_player = 0	2216	ALIAS: nearest_player = 0
1992	PREINIT:	2217	PREINIT:
1993	extern object get_nearest_player (object );	2218	extern object get_nearest_player (object );
…		…
1995	void rangevector (object ob, object other, int flags = 0)	2220	void rangevector (object ob, object other, int flags = 0)
1996	PROTOTYPE: $$;$	2221	PROTOTYPE: $$;$
1997	PPCODE:	2222	PPCODE:
1998	{	2223	{
1999	rv_vector rv;	2224	rv_vector rv;
		2225
		2226	PUTBACK;
2000	get_rangevector (ob, other, &rv, flags);	2227	get_rangevector (ob, other, &rv, flags);
		2228	SPAGAIN;
		2229
2001	EXTEND (SP, 5);	2230	EXTEND (SP, 5);
2002	PUSHs (newSVuv (rv.distance));	2231	PUSHs (newSVuv (rv.distance));
2003	PUSHs (newSViv (rv.distance_x));	2232	PUSHs (newSViv (rv.distance_x));
2004	PUSHs (newSViv (rv.distance_y));	2233	PUSHs (newSViv (rv.distance_y));
2005	PUSHs (newSViv (rv.direction));	2234	PUSHs (newSViv (rv.direction));
…		…
2015	base_name (object *op, int plural = op->nrof > 1)	2244	base_name (object *op, int plural = op->nrof > 1)
2016	CODE:	2245	CODE:
2017	RETVAL = query_base_name (op, plural);	2246	RETVAL = query_base_name (op, plural);
2018	OUTPUT: RETVAL	2247	OUTPUT: RETVAL
2019		2248
2020	object decrease_ob_nr (object op, unsigned long i)
2021
2022	# return the tail of an object, excluding itself	2249	# return the tail of an object, excluding itself
2023	void	2250	void
2024	tail (object *op)	2251	tail (object *op)
2025	PPCODE:	2252	PPCODE:
2026	while ((op = op->more))	2253	while ((op = op->more))
…		…
2076	pl->ob->stats.hp = pl->ob->stats.maxhp;	2303	pl->ob->stats.hp = pl->ob->stats.maxhp;
2077	pl->ob->stats.sp = pl->ob->stats.maxsp;	2304	pl->ob->stats.sp = pl->ob->stats.maxsp;
2078	pl->ob->stats.grace = pl->ob->stats.maxgrace;	2305	pl->ob->stats.grace = pl->ob->stats.maxgrace;
2079	pl->orig_stats = pl->ob->stats;	2306	pl->orig_stats = pl->ob->stats;
2080		2307
2081	void clear_los (player *pl)	2308	# should only be temporary
		2309	void esrv_new_player (player *pl)
2082		2310
		2311	#d# TODO: replace by blocked_los accessor, fix code using this
2083	bool	2312	bool
2084	cell_visible (player *pl, int dx, int dy)	2313	cell_visible (player *pl, int dx, int dy)
2085	CODE:	2314	CODE:
2086	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2	2315	RETVAL = pl->blocked_los (dx, dy) != LOS_BLOCKED;
2087	&& !pl->blocked_los [dx + pl->ns->mapx / 2][dy + pl->ns->mapy / 2];
2088	OUTPUT:	2316	OUTPUT:
2089	RETVAL	2317	RETVAL
2090		2318
2091	void	2319	void
2092	send (player pl, SV packet)	2320	send (player pl, SV packet)
…		…
2098	if (len > MAXSOCKBUF)	2326	if (len > MAXSOCKBUF)
2099	pl->failmsg ("[packet too long for client]");	2327	pl->failmsg ("[packet too long for client]");
2100	else if (pl->ns)	2328	else if (pl->ns)
2101	pl->ns->send_packet (buf, len);	2329	pl->ns->send_packet (buf, len);
2102	}	2330	}
2103
2104	int
2105	listening (player *pl, int new_value = -1)
2106	CODE:
2107	RETVAL = pl->listening;
2108	if (new_value >= 0)
2109	pl->listening = new_value;
2110	OUTPUT:
2111	RETVAL
2112		2331
2113	void savebed (player pl, SV map_path = 0, SV x = 0, SV y = 0)	2332	void savebed (player pl, SV map_path = 0, SV x = 0, SV y = 0)
2114	PROTOTYPE: $;$$$	2333	PROTOTYPE: $;$$$
2115	PPCODE:	2334	PPCODE:
2116	if (GIMME_V != G_VOID)	2335	if (GIMME_V != G_VOID)
…		…
2169	}	2388	}
2170		2389
2171	INCLUDE: $PERL $srcdir/genacc maptile ../include/map.h \|	2390	INCLUDE: $PERL $srcdir/genacc maptile ../include/map.h \|
2172		2391
2173	void	2392	void
		2393	adjust_daylight ()
		2394	CODE:
		2395	maptile::adjust_daylight ();
		2396
		2397	int
		2398	outdoor_darkness (int darkness = 0)
		2399	CODE:
		2400	RETVAL = maptile::outdoor_darkness;
		2401	if (items)
		2402	maptile::outdoor_darkness = darkness;
		2403	OUTPUT:
		2404	RETVAL
		2405
		2406	void
2174	maptile::instantiate ()	2407	maptile::instantiate ()
2175		2408
2176	maptile *new ()	2409	maptile *new ()
2177	PROTOTYPE:	2410	PROTOTYPE:
2178	CODE:	2411	CODE:
…		…
2271	}	2504	}
2272		2505
2273	void	2506	void
2274	maptile::create_region_treasure ()	2507	maptile::create_region_treasure ()
2275	CODE:	2508	CODE:
2276	{
2277	object *op = object::create ();
2278	op->type = FLOOR;
2279	op->map = THIS;
2280
2281	for (int x = 0; x < THIS->width; ++x)	2509	for (int x = 0; x < THIS->width; ++x)
2282	for (int y = 0; y < THIS->height; ++y)	2510	for (int y = 0; y < THIS->height; ++y)
2283	{	2511	{
2284	region *rgn = THIS->region (x, y);	2512	region *rgn = THIS->region (x, y);
2285		2513
2286	//fprintf (stderr, "%d,%d %f %p\n", x, y, rgn->treasure_density,rgn->treasure);//D	2514	//fprintf (stderr, "%d,%d %f %p\n", x, y, rgn->treasure_density,rgn->treasure);//D
		2515	if (object *op = THIS->at (x, y).top)
2287	if (rgn->treasure && rndm () < rgn->treasure_density)	2516	if (rgn->treasure && rndm () < rgn->treasure_density)
2288	{
2289	op->x = x;
2290	op->y = y;
2291	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);	2517	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);
2292	}
2293	}	2518	}
2294		2519
2295	op->destroy ();
2296	}
2297
2298	int out_of_map (maptile *map, int x, int y)	2520	int out_of_map (maptile *map, int x, int y)
2299		2521
2300	void	2522	void
2301	trigger (maptile *map, long connection, bool state = true)	2523	find_link (maptile *map, shstr_tmp connection)
2302	CODE:
2303	activate_connection (map, connection, state);
2304
2305	void
2306	get_connection (maptile *map, long connection)
2307	PPCODE:	2524	PPCODE:
2308	oblinkpt *obp = get_connection_links (map, connection);	2525	if (oblinkpt *obp = map->find_link (connection))
2309	if (obp)
2310	for (objectlink *ol = obp->link; ol; ol = ol->next)	2526	for (objectlink *ol = obp->link; ol; ol = ol->next)
2311	XPUSHs (sv_2mortal (to_sv ((object *)ol->ob)));	2527	XPUSHs (sv_2mortal (to_sv ((object *)ol->ob)));
2312		2528
2313	void	2529	void
2314	get_map_flags (maptile *map, int x, int y)	2530	get_map_flags (maptile *map, int x, int y)
2315	PPCODE:	2531	PPCODE:
2316	{	2532	{
2317	maptile *nmap = 0;	2533	maptile *nmap = 0;
2318	I16 nx = 0, ny = 0;	2534	I16 nx = 0, ny = 0;
		2535
		2536	PUTBACK;
2319	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);	2537	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
		2538	SPAGAIN;
2320		2539
2321	EXTEND (SP, 4);	2540	EXTEND (SP, 4);
2322	PUSHs (sv_2mortal (newSViv (flags)));	2541	PUSHs (sv_2mortal (newSViv (flags)));
2323		2542
2324	if (GIMME_V == G_ARRAY)	2543	if (GIMME_V == G_ARRAY)
…		…
2327	PUSHs (sv_2mortal (newSViv (nx)));	2546	PUSHs (sv_2mortal (newSViv (nx)));
2328	PUSHs (sv_2mortal (newSViv (ny)));	2547	PUSHs (sv_2mortal (newSViv (ny)));
2329	}	2548	}
2330	}	2549	}
2331		2550
		2551	mapspace *
		2552	ms (maptile *map, unsigned int x, unsigned int y)
		2553	PROTOTYPE: $$$
		2554	CODE:
		2555	{
		2556	maptile *nmap = 0;
		2557	I16 nx, ny;
		2558
		2559	PUTBACK;
		2560	get_map_flags (map, &nmap, x, y, &nx, &ny);
		2561	SPAGAIN;
		2562
		2563	if (!nmap)
		2564	XSRETURN_UNDEF;
		2565
		2566	RETVAL = &nmap->at (nx, ny);
		2567	}
		2568	OUTPUT:
		2569	RETVAL
		2570
2332	void	2571	void
2333	at (maptile *map, unsigned int x, unsigned int y)	2572	at (maptile *map, unsigned int x, unsigned int y)
2334	PROTOTYPE: $$$	2573	PROTOTYPE: $$$
2335	PPCODE:	2574	PPCODE:
2336	{	2575	{
2337	object *o;
2338	maptile *nmap = 0;	2576	maptile *nmap = 0;
2339	I16 nx, ny;	2577	I16 nx, ny;
2340		2578
		2579	PUTBACK;
2341	get_map_flags (map, &nmap, x, y, &nx, &ny);	2580	get_map_flags (map, &nmap, x, y, &nx, &ny);
		2581	SPAGAIN;
2342		2582
2343	if (nmap)	2583	if (nmap)
2344	for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)	2584	for (object *o = nmap->at (nx, ny).bot; o; o = o->above)
2345	XPUSHs (sv_2mortal (to_sv (o)));	2585	XPUSHs (sv_2mortal (to_sv (o)));
2346	}	2586	}
2347		2587
2348	SV *	2588	SV *
2349	bot_at (maptile *obj, unsigned int x, unsigned int y)	2589	bot_at (maptile *map, unsigned int x, unsigned int y)
2350	PROTOTYPE: $$$	2590	PROTOTYPE: $$$
2351	ALIAS:	2591	ALIAS:
2352	top_at = 1	2592	top_at = 1
2353	flags_at = 2	2593	flags_at = 2
2354	light_at = 3	2594	light_at = 3
2355	move_block_at = 4	2595	move_block_at = 4
2356	move_slow_at = 5	2596	move_slow_at = 5
2357	move_on_at = 6	2597	move_on_at = 6
2358	move_off_at = 7	2598	move_off_at = 7
2359	INIT:
2360	if (x >= obj->width \|\| y >= obj->height) XSRETURN_UNDEF;
2361	CODE:	2599	CODE:
		2600	{
		2601	sint16 nx = x;
		2602	sint16 ny = y;
		2603
		2604	if (!xy_normalise (map, nx, ny))
		2605	XSRETURN_UNDEF;
		2606
		2607	mapspace &ms = map->at (nx, ny);
		2608
		2609	ms.update ();
		2610
2362	switch (ix)	2611	switch (ix)
2363	{	2612	{
2364	case 0: RETVAL = to_sv (GET_MAP_OB (obj, x, y)); break;	2613	case 0: RETVAL = to_sv (ms.bot ); break;
2365	case 1: RETVAL = to_sv (GET_MAP_TOP (obj, x, y)); break;	2614	case 1: RETVAL = to_sv (ms.top ); break;
2366	case 2: RETVAL = newSVuv (GET_MAP_FLAGS (obj, x, y)); break;	2615	case 2: RETVAL = newSVuv (ms.flags_ ); break;
2367	case 3: RETVAL = newSViv (GET_MAP_LIGHT (obj, x, y)); break;	2616	case 3: RETVAL = newSViv (ms.light ); break;
2368	case 4: RETVAL = newSVuv (GET_MAP_MOVE_BLOCK (obj, x, y)); break;	2617	case 4: RETVAL = newSVuv (ms.move_block); break;
2369	case 5: RETVAL = newSVuv (GET_MAP_MOVE_SLOW (obj, x, y)); break;	2618	case 5: RETVAL = newSVuv (ms.move_slow ); break;
2370	case 6: RETVAL = newSVuv (GET_MAP_MOVE_ON (obj, x, y)); break;	2619	case 6: RETVAL = newSVuv (ms.move_on ); break;
2371	case 7: RETVAL = newSVuv (GET_MAP_MOVE_OFF (obj, x, y)); break;	2620	case 7: RETVAL = newSVuv (ms.move_off ); break;
2372	}	2621	}
		2622	}
2373	OUTPUT: RETVAL	2623	OUTPUT: RETVAL
2374		2624
2375	void fix_walls (maptile *map, int x, int y)	2625	void fix_walls (maptile *map, int x, int y)
2376		2626
2377	void fix_walls_around (maptile *map, int x, int y)	2627	void fix_walls_around (maptile *map, int x, int y)
…		…
2462	RETVAL = self->generate_random_map (&rmp);	2712	RETVAL = self->generate_random_map (&rmp);
2463	}	2713	}
2464	OUTPUT:	2714	OUTPUT:
2465	RETVAL	2715	RETVAL
2466		2716
		2717	MODULE = cf PACKAGE = cf::mapspace
		2718
		2719	INCLUDE: $PERL $srcdir/genacc mapspace ../include/map.h \|
		2720
2467	MODULE = cf PACKAGE = cf::arch	2721	MODULE = cf PACKAGE = cf::arch
2468		2722
2469	int archetypes_size ()	2723	int archetypes_size ()
2470	CODE:	2724	CODE:
2471	RETVAL = archetypes.size ();	2725	RETVAL = archetypes.size ();
…		…
2504		2758
2505	region *find (utf8_string name)	2759	region *find (utf8_string name)
2506	PROTOTYPE: $	2760	PROTOTYPE: $
2507	CODE:	2761	CODE:
2508	RETVAL = region::find (name);	2762	RETVAL = region::find (name);
2509	OUTPUT: RETVAL
2510
2511	region *find_fuzzy (utf8_string name)
2512	PROTOTYPE: $
2513	CODE:
2514	RETVAL = region::find_fuzzy (name);
2515	OUTPUT: RETVAL	2763	OUTPUT: RETVAL
2516		2764
2517	int specificity (region *rgn)	2765	int specificity (region *rgn)
2518	CODE:	2766	CODE:
2519	RETVAL = 0;	2767	RETVAL = 0;
…		…
2793	extract_tags (object_thawer *self)	3041	extract_tags (object_thawer *self)
2794	PPCODE:	3042	PPCODE:
2795	while (self->kw != KW_EOF)	3043	while (self->kw != KW_EOF)
2796	{	3044	{
2797	PUTBACK;	3045	PUTBACK;
2798	coroapi::cede_to_tick_every (5000);	3046	coroapi::cede_to_tick ();
2799	SPAGAIN;	3047	SPAGAIN;
2800		3048
2801	if (self->kw == KW_tag)	3049	if (self->kw == KW_tag)
2802	XPUSHs (sv_2mortal (newSVpv_utf8 (self->get_str ())));	3050	XPUSHs (sv_2mortal (newSVpv_utf8 (self->get_str ())));
2803		3051

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.267 by root, Mon Dec 17 08:03:22 2007 UTC vs. Revision 1.322 by root, Sun Oct 11 18:18:04 2009 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.267 by root, Mon Dec 17 08:03:22 2007 UTC vs.
Revision 1.322 by root, Sun Oct 11 18:18:04 2009 UTC