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

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.369 by root, Wed Apr 14 02:31:24 2010 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.369 by root, Wed Apr 14 02:31:24 2010 UTC