ViewVC Help

View File | Revision Log | Show Annotations | Download File

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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.249 by root, Thu Sep 6 07:00:05 2007 UTC vs.
Revision 1.369 by root, Wed Apr 14 02:31:24 2010 UTC

1	/*	1	/*
2	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (©) 2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team	4	* Copyright (©) 2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2001-2005,2007 by Chachkoff Yann
6	* Copyright (©) 2006,2007 by Marc Lehmann <cf@schmorp.de>
7	*	5	*
8	* Crossfire TRT is free software: you can redistribute it and/or modify	6	* Deliantra is free software: you can redistribute it and/or modify it under
9	* it under the terms of the GNU General Public License as published by	7	* the terms of the Affero GNU General Public License as published by the
10	* the Free Software Foundation, either version 3 of the License, or	8	* Free Software Foundation, either version 3 of the License, or (at your
11	* (at your option) any later version.	9	* option) any later version.
12	*	10	*
13	* This program is distributed in the hope that it will be useful,	11	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	14	* GNU General Public License for more details.
17	*	15	*
18	* You should have received a copy of the GNU General Public License	16	* You should have received a copy of the Affero GNU General Public License
19	* along with this program. If not, see <http://www.gnu.org/licenses/>.	17	* and the GNU General Public License along with this program. If not, see
		18	* <http://www.gnu.org/licenses/>.
20	*	19	*
21	* The authors can be reached via e-mail to <crossfire@schmorp.de>	20	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	21	*/
23		22
24	#include "autoconf.h"	23	#include "autoconf.h"
25
26	#define PLUGIN_NAME "perl"
27	#define PLUGIN_VERSION "cfperl 0.5"
28
29	#define CEDES_PER_TICK 5
30		24
31	#if HAVE_EXECINFO_H	25	#if HAVE_EXECINFO_H
32	# include <execinfo.h>	26	# include <execinfo.h>
33	#endif	27	#endif
34		28
35	#include <plugin_common.h>
36	#include <sounds.h>
37	#include <cstdarg>	29	#include <cstdarg>
		30	#include <typeinfo>
		31
		32	#include "global.h"
		33	#include "../random_maps/random_map.h"
		34	#include "evthread.h"
38	#include <sproto.h>	35	#include "sproto.h"
39
40	#include "loader.h"
41	#include "cfperl.h"
42	#include "shstr.h"
43		36
44	#include <unistd.h>	37	#include <unistd.h>
45	#if _POSIX_MEMLOCK	38	#if _POSIX_MEMLOCK
46	# include <sys/mman.h>	39	# include <sys/mman.h>
47	#endif	40	#endif
48		41
		42	#if HAVE_MALLOC_H
		43	# include <malloc.h>
		44	#endif
		45
		46	#if !__GLIBC__
		47	# define malloc_trim(pad) -1
		48	#endif
		49
49	#include <EXTERN.h>	50	#include <EXTERN.h>
50	#include <perl.h>	51	#include <perl.h>
51	#include <XSUB.h>	52	#include <XSUB.h>
52		53
53	#include "CoroAPI.h"	54	#include "CoroAPI.h"
…		…
58	typedef object_thawer &object_thawer_ref;	59	typedef object_thawer &object_thawer_ref;
59	typedef object_freezer &object_freezer_ref;	60	typedef object_freezer &object_freezer_ref;
60		61
61	typedef std::string std__string;	62	typedef std::string std__string;
62		63
63	#if IVSIZE >= 8
64	typedef IV val64;
65	# define newSVval64 newSViv
66	# define SvVAL64 SvIV
67	#else
68	typedef double val64;
69	# define newSVval64 newSVnv
70	# define SvVAL64 SvNV
71	#endif
72
73	static f_plug_api gethook = cfapi_get_hooks;
74	static f_plug_api object_insert = cfapi_object_insert;
75
76	static PerlInterpreter *perl;	64	static PerlInterpreter *perl;
77		65
78	tstamp NOW, runtime;	66	tstamp NOW, runtime;
		67
		68	static int tick_inhibit;
		69	static int tick_pending;
79		70
80	global gbl_ev;	71	global gbl_ev;
81	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;
82	static SV *sv_runtime, *sv_next_tick;	73	static SV *sv_runtime, *sv_tick_start, *sv_next_tick, *sv_now;
		74	static AV *av_reflect;
83		75
84	bitset<NUM_EVENT_TYPES> ev_want_event;	76	bitset<NUM_EVENT_TYPES> ev_want_event;
85	bitset<NUM_TYPES> ev_want_type;	77	bitset<NUM_TYPES> ev_want_type;
86		78
87	static HV	79	static HV
88	*stash_cf,	80	*stash_cf,
89	*stash_cf_object_wrap,	81	*stash_cf_object_wrap,
90	*stash_cf_object_player_wrap,	82	*stash_cf_object_player_wrap,
91	*stash_cf_player_wrap,	83	*stash_cf_player_wrap,
92	*stash_cf_map_wrap,	84	*stash_cf_map_wrap,
		85	*stash_cf_mapspace_wrap,
93	*stash_cf_client_wrap,	86	*stash_cf_client_wrap,
94	*stash_cf_arch_wrap,	87	*stash_cf_arch_wrap,
95	*stash_cf_party_wrap,	88	*stash_cf_party_wrap,
96	*stash_cf_region_wrap,	89	*stash_cf_region_wrap,
97	*stash_cf_living_wrap;	90	*stash_cf_living_wrap;
98		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
99	static inline SV *	100	static SV *
100	newSVpv_utf8 (const char *s)	101	newSVpv_utf8 (const char *s)
101	{	102	{
		103	if (!s)
		104	return newSV (0);
		105
102	SV *sv = newSVpv (s, 0);	106	SV *sv = newSVpv (s, 0);
103	SvUTF8_on (sv);	107	SvUTF8_on (sv);
104	return sv;	108	return sv;
105	}	109	}
		110	#endif
106		111
		112	#ifndef newSVpvn_utf8
107	static inline SV *	113	static SV *
108	newSVpvn_utf8 (const char *s, STRLEN l)	114	newSVpvn_utf8 (const char *s, STRLEN l, int utf8)
109	{	115	{
		116	if (!s)
		117	return newSV (0);
		118
110	SV *sv = newSVpvn (s, l);	119	SV *sv = newSVpvn (s, l);
		120
		121	if (utf8)
111	SvUTF8_on (sv);	122	SvUTF8_on (sv);
		123
112	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);
113	}	142	}
114		143
115	// helper cast function, returns super class * or 0	144	// helper cast function, returns super class * or 0
116	template<class super>	145	template<class super>
117	static super *	146	static super *
…		…
151	SvREFCNT_inc (self);	180	SvREFCNT_inc (self);
152	hv_clear (self);	181	hv_clear (self);
153	sv_unmagic ((SV *)self, PERL_MAGIC_ext);	182	sv_unmagic ((SV *)self, PERL_MAGIC_ext);
154	SvREFCNT_dec (self);	183	SvREFCNT_dec (self);
155		184
156	// self *must* be null now because thats sv_unmagic's job.	185	// self *must* be null now because that's sv_unmagic's job.
157	assert (!this->self);	186	assert (!this->self);
158	}	187	}
159	}	188	}
160		189
161	void	190	void
…		…
195	attachable::destroy ()	224	attachable::destroy ()
196	{	225	{
197	if (destroyed ())	226	if (destroyed ())
198	return;	227	return;
199		228
200	flags |= F_DESTROYED;	229	attachable_flags |= F_DESTROYED;
201	do_destroy ();	230	do_destroy ();
202	sever_self ();	231	sever_self ();
		232	}
		233
		234	void
		235	attachable::do_delete ()
		236	{
		237	delete this;
203	}	238	}
204		239
205	void	240	void
206	attachable::check_mortals ()	241	attachable::check_mortals ()
207	{	242	{
…		…
223		258
224	if (0)	259	if (0)
225	{	260	{
226	for (int j = 0; j < mortals.size (); ++j)//D	261	for (int j = 0; j < mortals.size (); ++j)//D
227	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
228	fprintf (stderr, "\n");//D	264	fprintf (stderr, "\n");//D
229	}	265	}
230	}	266	}
231	}	267	}
232		268
…		…
252	}	288	}
253	else	289	else
254	{	290	{
255	mortals.erase (i);	291	mortals.erase (i);
256	obj->sever_self ();	292	obj->sever_self ();
257	delete obj;	293	obj->do_delete ();
258	}	294	}
259	}	295	}
260	}	296	}
261		297
262	void	298	void
…		…
279		315
280	attach = src.attach;	316	attach = src.attach;
281	return *this;	317	return *this;
282	}	318	}
283		319
		320	#if 0
284	template<typename T>	321	template<typename T>
285	static bool	322	static bool
286	find_backref (void *ptr, T *obj)	323	find_backref (void *ptr, T *obj)
287	{	324	{
288	char *s = (char *)obj;	325	char *s = (char *)obj;
…		…
296		333
297	return false;	334	return false;
298	}	335	}
299		336
300	// for debugging, find "live" objects containing this ptr	337	// for debugging, find "live" objects containing this ptr
301	void	338	static void
302	find_backref (void *ptr)	339	find_backref (void *ptr)
303	{	340	{
304	for_all_objects (op)	341	for_all_objects (op)
305	if (find_backref (ptr, op))	342	if (find_backref (ptr, op))
306	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);
…		…
310	fprintf (stderr, "P %p\n", pl);	347	fprintf (stderr, "P %p\n", pl);
311		348
312	for_all_clients (ns)	349	for_all_clients (ns)
313	if (find_backref (ptr, ns))	350	if (find_backref (ptr, ns))
314	fprintf (stderr, "C %p\n", ns);	351	fprintf (stderr, "C %p\n", ns);
315
316	}	352	}
		353	#endif
317		354
318	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	355	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
319		356
320	static SV *	357	static SV *
321	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())	358	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())
322	{	359	{
323	SV *sv;	360	SV *sv;
324		361
325	if (!ptr)	362	if (!ptr)
326	return &PL_sv_undef;	363	return newSV (0);
327		364
328	sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);	365	sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);
329	return sv_bless (newRV_noinc ((SV *)hv), stash);	366	return sv_bless (newRV_noinc ((SV *)hv), stash);
330	}	367	}
331		368
…		…
350		387
351	static SV *	388	static SV *
352	newSVattachable (attachable *obj, HV *stash)	389	newSVattachable (attachable *obj, HV *stash)
353	{	390	{
354	if (!obj)	391	if (!obj)
355	return &PL_sv_undef;	392	return newSV (0);
356		393
357	if (!obj->self)	394	if (!obj->self)
358	obj->self = newHV ();	395	obj->self = newHV ();
359		396
360	if (!SvOBJECT (obj->self))	397	if (!SvOBJECT (obj->self))
…		…
374		411
375	return sv;	412	return sv;
376	}	413	}
377	}	414	}
378		415
		416	#if 0 // unused
379	static void	417	static void
380	clearSVptr (SV *sv)	418	clearSVptr (SV *sv)
381	{	419	{
382	if (SvROK (sv))	420	if (SvROK (sv))
383	sv = SvRV (sv);	421	sv = SvRV (sv);
384		422
385	hv_clear ((HV *)sv);	423	hv_clear ((HV *)sv);
386	sv_unmagic (sv, PERL_MAGIC_ext);	424	sv_unmagic (sv, PERL_MAGIC_ext);
387	}	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	}
388		442
389	static long	443	static long
390	SvPTR (SV *sv, const char *klass)	444	SvPTR (SV *sv, const char *klass)
391	{	445	{
392	if (!sv_derived_from (sv, klass))	446	if (!sv_derived_from (sv, klass))
393	croak ("object of type %s expected", klass);	447	croak ("object of type %s expected", klass);
394		448
395	MAGIC *mg = mg_find (SvRV (sv), PERL_MAGIC_ext);	449	return SvPTR_nc (sv);
396
397	if (!mg)
398	croak ("perl code used %s object, but C object is already destroyed, caught", klass);
399
400	return (long)mg->mg_ptr;
401	}	450	}
402		451
403	static long	452	static long noinline
404	SvPTR_ornull (SV *sv, const char *klass)	453	SvPTR_ornull (SV *sv, const char *klass)
405	{	454	{
406	if (SvOK (sv))	455	if (expect_false (!SvOK (sv))) return 0;
		456
407	return SvPTR (sv, klass);	457	return SvPTR (sv, klass);
408	else
409	return 0;
410	}	458	}
411		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
412	inline SV *to_sv (const shstr & v) { return v ? newSVpvn_utf8 ((const char *)v, v.length ()) : &PL_sv_undef; }	501	static inline SV *to_sv (const shstr & v) { return newSVpvn_utf8 ((const char *)v, v.length (), 1); }
413	inline SV *to_sv (const char * v) { return v ? newSVpv (v, 0) : &PL_sv_undef; }	502	static inline SV *to_sv (const char * v) { return v ? newSVpv (v, 0) : newSV (0); }
414	inline SV *to_sv (bool v) { return newSViv (v); }	503	static inline SV *to_sv (bool v) { return newSViv (v); }
415	inline SV *to_sv ( signed char v) { return newSViv (v); }	504	static inline SV *to_sv ( signed char v) { return newSViv (v); }
416	inline SV *to_sv (unsigned char v) { return newSViv (v); }	505	static inline SV *to_sv (unsigned char v) { return newSViv (v); }
417	inline SV *to_sv ( signed short v) { return newSViv (v); }	506	static inline SV *to_sv ( signed short v) { return newSViv (v); }
418	inline SV *to_sv (unsigned short v) { return newSVuv (v); }	507	static inline SV *to_sv (unsigned short v) { return newSVuv (v); }
419	inline SV *to_sv ( signed int v) { return newSViv (v); }	508	static inline SV *to_sv ( signed int v) { return newSViv (v); }
420	inline SV *to_sv (unsigned int v) { return newSVuv (v); }	509	static inline SV *to_sv (unsigned int v) { return newSVuv (v); }
421	inline SV *to_sv ( signed long v) { return newSViv (v); }	510	static inline SV *to_sv ( signed long v) { return newSViv (v); }
422	inline SV *to_sv (unsigned long v) { return newSVuv (v); }	511	static inline SV *to_sv (unsigned long v) { return newSVuv (v); }
423	inline SV *to_sv ( signed long long v) { return newSVval64 (v); }	512	static inline SV *to_sv ( signed long long v) { return newSVval64 (v); }
424	inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }	513	static inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }
425	inline SV *to_sv (float v) { return newSVnv (v); }	514	static inline SV *to_sv (float v) { return newSVnv (v); }
426	inline SV *to_sv (double v) { return newSVnv (v); }	515	static inline SV *to_sv (double v) { return newSVnv (v); }
427	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); }
428	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); }
429	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); }
430	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); }
431	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); }
432	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); }
433	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); }
434	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); }
435		525
436	inline SV *to_sv (object & v) { return to_sv (&v); }	526	static inline SV *to_sv (object & v) { return to_sv (&v); }
437	inline SV *to_sv (living & v) { return to_sv (&v); }	527	static inline SV *to_sv (living & v) { return to_sv (&v); }
438		528
439	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 ()); }
440	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); }
441		531
442	inline SV *to_sv (UUID v)	532	static inline SV *to_sv (UUID v) { return newSVpv (v.c_str (), 0); }
443	{
444	char buf[128];
445	snprintf (buf, 128, "<1.%" PRIx64 ">", v.seq);
446	return newSVpv (buf, 0);
447	}
448		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
449	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; }
450	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; }
451	inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }	557	static inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }
452	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); }
453	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); }
454	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); }
455	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); }
456	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); }
457	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); }
458	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); }
459	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); }
460	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); }
461	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); }
462	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }	568	static inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
463	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }	569	static inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }
464	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); }
465	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); }
466	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); }
467	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"); }
468	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"); }
469	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"); }
470	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"); }
471	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"); }
472	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"); }
473	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"); }
474	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" ); }
475		582
476	//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)]; }
477	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)); }
478		585
479	template<class T>	586	template<class T>
480	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; }
481		588
482	template<int N>	589	template<int N>
483	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)); }
484		591
485	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); }
486	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); }
487	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); }
488	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); }
489		596
490	inline void sv_to (SV *sv, std::string &v)	597	static inline void sv_to (SV *sv, std::string &v)
491	{	598	{
492	STRLEN len;	599	STRLEN len;
493	char *data = SvPVbyte (sv, len);	600	char *data = SvPVbyte (sv, len);
494	v.assign (data, len);	601	v.assign (data, len);
495	}	602	}
496		603
497	inline void sv_to (SV *sv, UUID &v)	604	static inline void sv_to (SV *sv, UUID &v)
498	{	605	{
499	unsigned int version;	606	if (!v.parse (SvPV_nolen (sv)))
500
501	if (2 != sscanf (SvPV_nolen (sv), "<%d.%" SCNx64 ">", &version, &v.seq) || 1 != version)
502	croak ("unparsable uuid: %s", SvPV_nolen (sv));	607	croak ("unparsable uuid: %s", SvPV_nolen (sv));
503	}	608	}
504		609
505	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); }
506		611
507	static SV *	612	static SV *
508	newSVdt_va (va_list &ap, data_type type)	613	newSVdt_va (va_list &ap, data_type type)
509	{	614	{
510	SV *sv;	615	SV *sv;
…		…
524	break;	629	break;
525		630
526	case DT_STRING:	631	case DT_STRING:
527	{	632	{
528	char *str = (char *)va_arg (ap, const char *);	633	char *str = (char *)va_arg (ap, const char *);
529	sv = str ? newSVpv (str, 0) : &PL_sv_undef;	634	sv = str ? newSVpv (str, 0) : newSV (0);
530	}	635	}
531	break;	636	break;
532		637
533	case DT_DATA:	638	case DT_DATA:
534	{	639	{
535	char *str = (char *)va_arg (ap, const void *);	640	char *str = (char *)va_arg (ap, const void *);
536	int len = va_arg (ap, int);	641	int len = va_arg (ap, int);
537	sv = str ? newSVpv (str, len) : &PL_sv_undef;	642	sv = str ? newSVpv (str, len) : newSV (0);
538	}	643	}
539	break;	644	break;
540		645
541	case DT_OBJECT:	646	case DT_OBJECT:
542	sv = to_sv (va_arg (ap, object *));	647	sv = to_sv (va_arg (ap, object *));
…		…
584	va_end (ap);	689	va_end (ap);
585		690
586	return sv;	691	return sv;
587	}	692	}
588		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
		718	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		719
589	static SV *	720	static SV *
590	newSVcfapi (int type, ...)
591	{
592	SV *sv;
593
594	va_list ap;
595	va_start (ap, type);
596
597	switch (type)
598	{
599	case CFAPI_INT: sv = newSViv (*va_arg (ap, int * )); break;
600	case CFAPI_LONG: sv = newSVval64 (*va_arg (ap, sint64 *)); break;
601	case CFAPI_DOUBLE: sv = newSVnv (*va_arg (ap, double *)); break;
602	case CFAPI_STRING: sv = newSVdt_va (ap, DT_STRING); break;
603	case CFAPI_POBJECT: sv = newSVdt_va (ap, DT_OBJECT); break;
604	case CFAPI_PMAP: sv = newSVdt_va (ap, DT_MAP ); break;
605	case CFAPI_PPLAYER: sv = newSVdt_va (ap, DT_PLAYER); break;
606	case CFAPI_PARCH: sv = newSVdt_va (ap, DT_ARCH ); break;
607	case CFAPI_PPARTY: sv = newSVdt_va (ap, DT_PARTY ); break;
608	case CFAPI_PREGION: sv = newSVdt_va (ap, DT_REGION); break;
609
610	default:
611	assert (("unhandled type in newSVcfapi", 0));
612	}
613
614	va_end (ap);
615
616	return sv;
617	}
618
619	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
620
621	SV *
622	registry (attachable *ext)	721	registry (attachable *ext)
623	{	722	{
624	if (!ext->cb)	723	if (!ext->cb)
625	ext->cb = newAV ();	724	ext->cb = newAV ();
626		725
627	return newRV_inc ((SV *)ext->cb);	726	return newRV_inc ((SV *)ext->cb);
628	}	727	}
629		728
630	/////////////////////////////////////////////////////////////////////////////	729	/////////////////////////////////////////////////////////////////////////////
631		730
632	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
633	{
634	return 0;
635	}
636
637	static CommArray_s rtn_cmd;
638
639	static int
640	runPluginCommand (object *obj, char *params)
641	{
642	return -1;
643	}
644
645	extern "C" void *cfperl_getPluginProperty (int *type, ...)
646	{
647	va_list args;
648	char *propname;
649	int i;
650	va_start (args, type);
651	propname = va_arg (args, char *);
652	//printf ("Property name: %s\n", propname);
653
654	if (!strcmp (propname, "command?"))
655	return NULL;
656	else if (!strcmp (propname, "Identification"))
657	{
658	va_end (args);
659	return (void *)PLUGIN_NAME;
660	}
661	else if (!strcmp (propname, "FullName"))
662	{
663	va_end (args);
664	return (void *)PLUGIN_VERSION;
665	}
666	else
667	va_end (args);
668
669	return NULL;
670	}
671
672	extern "C" int cfperl_postInitPlugin ()
673	{
674	int hooktype = 1;
675	int rtype = 0;
676
677	cf_init_plugin (gethook);
678
679	return 0;
680	}
681
682	extern "C" int cfperl_closePlugin ()
683	{
684	return 0;
685	}
686
687	void	731	void
688	cfperl_init ()	732	cfperl_init ()
689	{	733	{
		734	extern char **environ;
		735
690	PERL_SYS_INIT3 (&settings.argc, &settings.argv, 0);	736	PERL_SYS_INIT3 (&settings.argc, &settings.argv, &environ);
691	perl = perl_alloc ();	737	perl = perl_alloc ();
692	perl_construct (perl);	738	perl_construct (perl);
693		739
694	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;	740	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
695		741
696	const char *argv[] = {	742	const char *argv[] = {
697	settings.argv [0],	743	settings.argv [0],
698	"-e"	744	"-e0"
699	"use Event; use Coro;" // required for bootstrap
700	"cf->bootstrap;" // required for datadir :*>
701	"unshift @INC, cf::datadir ();"
702	"require cf;"
703	};	745	};
704		746
705	if (perl_parse (perl, xs_init, 2, (char **)argv, (char **)NULL)	747	if (perl_parse (perl, xs_init, 2, (char **)argv, environ)
706	|| perl_run (perl))	748	|| perl_run (perl))
707	{	749	{
708	printf ("unable to initialize perl-interpreter, aborting.\n");	750	printf ("unable to initialize perl-interpreter, aborting.\n");
709	exit (EXIT_FAILURE);	751	exit (EXIT_FAILURE);
710	}	752	}
711		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))
712	{	765	{
713	dSP;	766	printf ("unable to bootstrap perl, aborting:\n%s", SvPV_nolen (ERRSV));
714		767	exit (EXIT_FAILURE);
715	PUSHMARK (SP);
716	PUTBACK;
717	call_pv ("cf::init", G_DISCARD | G_VOID);
718	}	768	}
719	}	769	}
720		770
		771	void
721	void cfperl_main ()	772	cfperl_main ()
722	{	773	{
723	dSP;	774	dSP;
724		775
725	PUSHMARK (SP);	776	PUSHMARK (SP);
726	PUTBACK;	777	PUTBACK;
…		…
751	# undef def	802	# undef def
752	};	803	};
753		804
754	#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)
755		806
756	static void	807	static void noinline
757	gather_callbacks (AV *&callbacks, AV *registry, event_type event)	808	gather_callbacks (AV *&callbacks, AV *registry, event_type event)
758	{	809	{
759	// event must be in array	810	// event must be in array
760	if (event >= 0 && event <= AvFILLp (registry))	811	if (event >= 0 && event <= AvFILLp (registry))
761	{	812	{
…		…
847	{	898	{
848	attachable::gather_callbacks (callbacks, event);	899	attachable::gather_callbacks (callbacks, event);
849	::gather_callbacks (callbacks, cb_map, event);	900	::gather_callbacks (callbacks, cb_map, event);
850	}	901	}
851		902
852	void	903	static void noinline
853	_recalc_want (bitset<NUM_EVENT_TYPES> &set, AV *registry)	904	_recalc_want (bitset<NUM_EVENT_TYPES> &set, AV *registry)
854	{	905	{
855	for (int event = 0; event <= AvFILLp (registry); ++event)	906	for (int event = 0; event <= AvFILLp (registry); ++event)
856	{	907	{
857	SV *cbs_ = AvARRAY (registry)[event];	908	SV *cbs_ = AvARRAY (registry)[event];
…		…
867	}	918	}
868	}	919	}
869	}	920	}
870		921
871	// very slow and inefficient way to recalculate the global want bitsets	922	// very slow and inefficient way to recalculate the global want bitsets
872	void	923	static void
873	_recalc_want ()	924	_recalc_want ()
874	{	925	{
875	ev_want_event.reset ();	926	ev_want_event.reset ();
876		927
877	_recalc_want (ev_want_event, cb_global);	928	_recalc_want (ev_want_event, cb_global);
…		…
950	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));	1001	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
951	}	1002	}
952		1003
953	va_end (ap);	1004	va_end (ap);
954		1005
955	CALL_CALL ("cf::do_invoke", G_SCALAR);	1006	CALL_CALL (cv_cf_do_invoke, G_SCALAR);
956	count = count > 0 ? POPi : 0;	1007	count = count > 0 ? POPi : 0;
957		1008
958	CALL_END;	1009	CALL_END;
959		1010
960	return count;	1011	return count;
961	}	1012	}
962		1013
963	SV *	1014	static SV *
964	cfperl_result (int idx)	1015	cfperl_result (int idx)
965	{	1016	{
966	AV *av = get_av ("cf::INVOKE_RESULTS", 0);	1017	AV *av = get_av ("cf::INVOKE_RESULTS", 0);
967	if (!av)	1018	if (!av)
968	return &PL_sv_undef;	1019	return &PL_sv_undef;
…		…
986	return SvNV (cfperl_result (idx));	1037	return SvNV (cfperl_result (idx));
987	}	1038	}
988		1039
989	/////////////////////////////////////////////////////////////////////////////	1040	/////////////////////////////////////////////////////////////////////////////
990	// 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	}
991		1061
992	void	1062	void
993	cfperl_emergency_save ()	1063	cfperl_emergency_save ()
994	{	1064	{
995	CALL_BEGIN (0);	1065	CALL_BEGIN (0);
…		…
1015	CALL_CALL ("ext::books::make_book", G_VOID);	1085	CALL_CALL ("ext::books::make_book", G_VOID);
1016	CALL_END;	1086	CALL_END;
1017	}	1087	}
1018		1088
1019	void	1089	void
1020	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)
1021	{	1091	{
1022	CALL_BEGIN (4);	1092	CALL_BEGIN (4);
1023	CALL_ARG (ns);	1093	CALL_ARG (ns);
1024	CALL_ARG (type);	1094	CALL_ARG (type);
1025	CALL_ARG_SV (newSVpv_utf8 (msg));	1095	CALL_ARG_SV (newSVpv_utf8 (msg));
1026	CALL_ARG (color);	1096	CALL_ARG (color);
1027	CALL_CALL ("cf::client::send_msg", G_VOID);	1097	CALL_CALL (cv_cf_client_send_msg, G_VOID);
1028	CALL_END;	1098	CALL_END;
1029	}	1099	}
1030		1100
1031	int	1101	int
1032	cfperl_can_merge (object *ob1, object *ob2)	1102	cfperl_can_merge (object *ob1, object *ob2)
…		…
1034	int can;	1104	int can;
1035		1105
1036	CALL_BEGIN (2);	1106	CALL_BEGIN (2);
1037	CALL_ARG (ob1);	1107	CALL_ARG (ob1);
1038	CALL_ARG (ob2);	1108	CALL_ARG (ob2);
1039	CALL_CALL ("cf::_can_merge", G_SCALAR);	1109	CALL_CALL (cv_cf__can_merge, G_SCALAR);
1040	can = count && SvTRUE (TOPs);	1110	can = count && SvTRUE (TOPs);
1041	CALL_END;	1111	CALL_END;
1042		1112
1043	return can;	1113	return can;
1044	}	1114	}
1045		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
1046	player *	1128	player *
1047	player::find (const char *name)	1129	player::find (const_utf8_string name)
1048	{	1130	{
1049	CALL_BEGIN (1);	1131	CALL_BEGIN (1);
1050	CALL_ARG (name);	1132	CALL_ARG (name);
1051	CALL_CALL ("cf::player::find", G_SCALAR);	1133	CALL_CALL ("cf::player::find", G_SCALAR);
1052		1134
1053	player *retval;	1135	player *retval = 0;
1054
1055	if (count)
1056	sv_to (POPs, retval);	1136	if (count) sv_to (POPs, retval);
1057	else
1058	retval = 0;
1059		1137
1060	CALL_END;	1138	CALL_END;
1061		1139
1062	return retval;	1140	return retval;
1063	}	1141	}
1064		1142
1065	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 *
1066	maptile::find_sync (const char *path, maptile *origin)	1162	maptile::find_sync (const_utf8_string path, maptile *origin)
1067	{	1163	{
1068	CALL_BEGIN (2);	1164	CALL_BEGIN (2);
1069	CALL_ARG (path);	1165	CALL_ARG (path);
1070	CALL_ARG (origin);	1166	CALL_ARG (origin);
1071	CALL_CALL ("cf::map::find_sync", G_SCALAR);	1167	CALL_CALL ("cf::map::find_sync", G_SCALAR);
1072		1168
1073	maptile *retval;	1169	maptile *retval = 0;
1074
1075	if (count)
1076	sv_to (POPs, retval);	1170	if (count) sv_to (POPs, retval);
1077	else
1078	retval = 0;
1079		1171
1080	CALL_END;	1172	CALL_END;
1081		1173
1082	return retval;	1174	return retval;
1083	}	1175	}
1084		1176
1085	maptile *	1177	maptile *
1086	maptile::find_async (const char *path, maptile *origin, bool load)	1178	maptile::find_async (const_utf8_string path, maptile *origin, bool load)
1087	{	1179	{
1088	CALL_BEGIN (3);	1180	CALL_BEGIN (3);
1089	CALL_ARG (path);	1181	CALL_ARG (path);
1090	CALL_ARG (origin);	1182	CALL_ARG (origin);
1091	CALL_ARG (load);	1183	CALL_ARG (load);
1092	CALL_CALL ("cf::map::find_async", G_SCALAR);	1184	CALL_CALL ("cf::map::find_async", G_SCALAR);
1093		1185
1094	maptile *retval;	1186	maptile *retval = 0;
1095
1096	if (count)
1097	sv_to (POPs, retval);	1187	if (count) sv_to (POPs, retval);
1098	else
1099	retval = 0;
1100		1188
1101	CALL_END;	1189	CALL_END;
1102		1190
1103	return retval;	1191	return retval;
1104	}	1192	}
…		…
1107	maptile::do_load_sync ()	1195	maptile::do_load_sync ()
1108	{	1196	{
1109	CALL_BEGIN (1);	1197	CALL_BEGIN (1);
1110	CALL_ARG (this);	1198	CALL_ARG (this);
1111	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);	1199	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);
1112	CALL_END;
1113	}
1114
1115	void
1116	maptile::change_all_map_light (int change)
1117	{
1118	CALL_BEGIN (1);
1119	CALL_ARG (change);
1120	CALL_CALL ("cf::map::change_all_map_light", G_VOID);
1121	CALL_END;	1200	CALL_END;
1122	}	1201	}
1123		1202
1124	void	1203	void
1125	object::enter_exit (object *exit)	1204	object::enter_exit (object *exit)
…		…
1132	CALL_ARG (exit);	1211	CALL_ARG (exit);
1133	CALL_CALL ("cf::object::player::enter_exit", G_VOID);	1212	CALL_CALL ("cf::object::player::enter_exit", G_VOID);
1134	CALL_END;	1213	CALL_END;
1135	}	1214	}
1136		1215
1137	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
1138	object::ref () const	1232	object::ref () const
1139	{	1233	{
1140	if (type == PLAYER)	1234	if (type == PLAYER)
1141	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);
1142	else	1236	else
		1237	// TODO: should be able to save references within the same map, at least
1143	return 0;	1238	return 0;
1144	}	1239	}
1145		1240
1146	object *	1241	object *
1147	object::deref (const char *ref)	1242	object::deref (const_utf8_string ref)
1148	{	1243	{
1149	object *retval = 0;	1244	object *retval = 0;
1150		1245
1151	if (ref)	1246	if (ref)
1152	{	1247	{
…		…
1162		1257
1163	return retval;	1258	return retval;
1164	}	1259	}
1165		1260
1166	void	1261	void
1167	log_backtrace (const char *msg)	1262	log_backtrace (const_utf8_string msg)
1168	{	1263	{
1169	#if HAVE_BACKTRACE	1264	#if HAVE_BACKTRACE
1170	void *addr [20];	1265	void *addr [20];
1171	int size = backtrace (addr, 20);	1266	int size = backtrace (addr, 20);
1172		1267
…		…
1177	CALL_CALL ("cf::_log_backtrace", G_VOID);	1272	CALL_CALL ("cf::_log_backtrace", G_VOID);
1178	CALL_END;	1273	CALL_END;
1179	#endif	1274	#endif
1180	}	1275	}
1181		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
1182	/////////////////////////////////////////////////////////////////////////////	1328	/////////////////////////////////////////////////////////////////////////////
1183		1329
1184	struct EventAPI *watcher_base::GEventAPI;	1330	struct EVAPI *evapi::GEVAPI;
1185	struct CoroAPI *coroapi::GCoroAPI;	1331	struct CoroAPI *coroapi::GCoroAPI;
1186		1332
1187	int coroapi::cede_counter;	1333	void
1188	tstamp coroapi::next_cede;
1189
1190	void coroapi::do_cede_to_tick ()	1334	coroapi::do_cede_to_tick ()
1191	{	1335	{
1192	cede_counter = 0;	1336	cede_pending = 0;
1193
1194	cede ();	1337	cede ();
1195
1196	next_cede += (TICK / CEDES_PER_TICK) * 0.99;
1197	if (next_cede > SvNV (sv_next_tick) - 0.02)
1198	next_cede = SvNV (sv_next_tick);
1199	}
1200
1201	void coroapi::do_cede_every ()
1202	{
1203	cede_counter = 0;
1204
1205	if (coroapi::nready ())
1206	coroapi::cede ();
1207	}
1208
1209	void coroapi::do_cede_to_tick_every ()
1210	{
1211	cede_counter = 0;
1212
1213	cede_to_tick ();
1214	}	1338	}
1215		1339
1216	void	1340	void
1217	coroapi::wait_for_tick ()	1341	coroapi::wait_for_tick ()
1218	{	1342	{
…		…
1227	CALL_BEGIN (0);	1351	CALL_BEGIN (0);
1228	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);	1352	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);
1229	CALL_END;	1353	CALL_END;
1230	}	1354	}
1231		1355
		1356	void
		1357	iow::poll (int events)
		1358	{
		1359	if (events != this->events)
		1360	{
		1361	int active = ev_is_active ((ev_io *)this);
		1362	if (active) stop ();
		1363	ev_io_set ((ev_io *)this, fd, events);
		1364	if (active) start ();
		1365	}
		1366	}
		1367
1232	static void	1368	static void
1233	iw_dispatch (pe_event *ev)
1234	{
1235	iw *w = (iw *)ev->ext_data;
1236	w->call (*w);
1237	}
1238
1239	void
1240	iw::alloc ()
1241	{
1242	pe = GEventAPI->new_idle (0, 0);
1243
1244	WaREENTRANT_off (pe);
1245	pe->base.callback = (void *)iw_dispatch;
1246	pe->base.ext_data = (void *)this;
1247	}
1248
1249	static void iow_dispatch (pe_event *ev)
1250	{
1251	iow *w = (iow *)ev->ext_data;
1252	w->call (*w, ((pe_ioevent *)ev)->got);
1253	}
1254
1255	void
1256	iow::alloc ()
1257	{
1258	pe = GEventAPI->new_io (0, 0);
1259
1260	WaREENTRANT_off (pe);
1261	pe->base.callback = (void *)iow_dispatch;
1262	pe->base.ext_data = (void *)this;
1263
1264	pe->fd = -1;
1265	pe->poll = 0;
1266	}
1267
1268	void
1269	iow::fd (int fd)
1270	{
1271	pe->fd = fd;
1272	}
1273
1274	int
1275	iow::poll ()
1276	{
1277	return pe->poll;
1278	}
1279
1280	void
1281	iow::poll (int events)
1282	{
1283	if (pe->poll != events)
1284	{
1285	if (pe->poll) stop ();
1286	pe->poll = events;
1287	if (pe->poll) start ();
1288	}
1289	}
1290
1291	void
1292	_connect_to_perl ()	1369	_connect_to_perl_1 ()
1293	{	1370	{
1294	stash_cf = gv_stashpv ("cf" , 1);	1371	stash_cf = gv_stashpv ("cf", 1);
1295		1372
1296	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);	1373	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);
1297	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);
1298	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);	1375	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);
1299	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);
1300	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);	1378	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);
1301	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);	1379	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
1302	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);	1380	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
1303	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);	1381	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
1304	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);	1382	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
1305		1383
		1384	sv_now = get_sv ("cf::NOW" , 1); SvUPGRADE (sv_now , SVt_NV);
1306	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);
1307	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);
1308		1388
1309	cb_global = get_av ("cf::CB_GLOBAL", 1);	1389	cb_global = get_av ("cf::CB_GLOBAL", 1);
1310	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);	1390	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
1311	cb_object = get_av ("cf::CB_OBJECT", 1);	1391	cb_object = get_av ("cf::CB_OBJECT", 1);
1312	cb_player = get_av ("cf::CB_PLAYER", 1);	1392	cb_player = get_av ("cf::CB_PLAYER", 1);
1313	cb_client = get_av ("cf::CB_CLIENT", 1);	1393	cb_client = get_av ("cf::CB_CLIENT", 1);
1314	cb_type = get_av ("cf::CB_TYPE" , 1);	1394	cb_type = get_av ("cf::CB_TYPE" , 1);
1315	cb_map = get_av ("cf::CB_MAP" , 1);	1395	cb_map = get_av ("cf::CB_MAP" , 1);
1316	}	1396	}
1317		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
1318	MODULE = cf PACKAGE = cf PREFIX = cf_	1408	MODULE = cf PACKAGE = cf PREFIX = cf_
1319		1409
1320	BOOT:	1410	BOOT:
1321	{	1411	{
1322	I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;	1412	I_EV_API (PACKAGE); evapi::GEVAPI = GEVAPI;
1323	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;	1413	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
1324		1414
1325	_connect_to_perl ();	1415	_connect_to_perl_1 ();
1326		1416
1327	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));	1417	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
1328		1418
1329	//{	1419	//{
1330	// require_pv ("Time::HiRes");	1420	// require_pv ("Time::HiRes");
…		…
1338	static const struct {	1428	static const struct {
1339	const char *name;	1429	const char *name;
1340	IV iv;	1430	IV iv;
1341	} *civ, const_iv[] = {	1431	} *civ, const_iv[] = {
1342	# 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
1343	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)
1344	const_iv (logBacktrace)	1442	const_iv (logBacktrace)
1345		1443
1346	const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)	1444	const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)
1347		1445
1348	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)	1446	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)
1349		1447
1350	const_iv (MAX_TIME)	1448	const_iv (MAX_TIME)
1351		1449	const_iv (MAXSOCKBUF)
1352	const_iv (NUM_BODY_LOCATIONS)
1353	const_iv (body_range) const_iv (body_shield) const_iv (body_combat)
1354	const_iv (body_arm) const_iv (body_torso) const_iv (body_head)
1355	const_iv (body_neck) const_iv (body_skill) const_iv (body_finger)
1356	const_iv (body_shoulder) const_iv (body_foot) const_iv (body_hand)
1357	const_iv (body_wrist) const_iv (body_waist)
1358
1359	const_iv (PLAYER) const_iv (TRANSPORT) const_iv (ROD) const_iv (TREASURE)
1360	const_iv (POTION) const_iv (FOOD) const_iv (POISON) const_iv (BOOK)
1361	const_iv (CLOCK) const_iv (ARROW) const_iv (BOW) const_iv (WEAPON)
1362	const_iv (ARMOUR) const_iv (PEDESTAL) const_iv (ALTAR) const_iv (LOCKED_DOOR)
1363	const_iv (SPECIAL_KEY) const_iv (MAP) const_iv (DOOR) const_iv (KEY)
1364	const_iv (TIMED_GATE) const_iv (TRIGGER) const_iv (GRIMREAPER) const_iv (MAGIC_EAR)
1365	const_iv (TRIGGER_BUTTON) const_iv (TRIGGER_ALTAR) const_iv (TRIGGER_PEDESTAL) const_iv (SHIELD)
1366	const_iv (HELMET) const_iv (HORN) const_iv (MONEY) const_iv (CLASS)
1367	const_iv (GRAVESTONE) const_iv (AMULET) const_iv (PLAYERMOVER) const_iv (TELEPORTER)
1368	const_iv (CREATOR) const_iv (SKILL) const_iv (EARTHWALL) const_iv (GOLEM)
1369	const_iv (THROWN_OBJ) const_iv (BLINDNESS) const_iv (GOD) const_iv (DETECTOR)
1370	const_iv (TRIGGER_MARKER) const_iv (DEAD_OBJECT) const_iv (DRINK) const_iv (MARKER)
1371	const_iv (HOLY_ALTAR) const_iv (PLAYER_CHANGER) const_iv (BATTLEGROUND) const_iv (PEACEMAKER)
1372	const_iv (GEM) const_iv (FIREWALL) const_iv (ANVIL) const_iv (CHECK_INV)
1373	const_iv (MOOD_FLOOR) const_iv (EXIT) const_iv (ENCOUNTER) const_iv (SHOP_FLOOR)
1374	const_iv (SHOP_MAT) const_iv (RING) const_iv (FLOOR) const_iv (FLESH)
1375	const_iv (INORGANIC) const_iv (SKILL_TOOL) const_iv (LIGHTER) const_iv (BUILDABLE_WALL)
1376	const_iv (MISC_OBJECT) const_iv (LAMP) const_iv (DUPLICATOR) const_iv (SPELLBOOK)
1377	const_iv (CLOAK) const_iv (SPINNER) const_iv (GATE) const_iv (BUTTON)
1378	const_iv (CF_HANDLE) const_iv (HOLE) const_iv (TRAPDOOR) const_iv (SIGN)
1379	const_iv (BOOTS) const_iv (GLOVES) const_iv (SPELL) const_iv (SPELL_EFFECT)
1380	const_iv (CONVERTER) const_iv (BRACERS) const_iv (POISONING) const_iv (SAVEBED)
1381	const_iv (WAND) const_iv (SCROLL) const_iv (DIRECTOR) const_iv (GIRDLE)
1382	const_iv (FORCE) const_iv (POTION_EFFECT) const_iv (EVENT_CONNECTOR) const_iv (CLOSE_CON)
1383	const_iv (CONTAINER) const_iv (ARMOUR_IMPROVER) const_iv (WEAPON_IMPROVER) const_iv (SKILLSCROLL)
1384	const_iv (DEEP_SWAMP) const_iv (IDENTIFY_ALTAR) const_iv (MENU) const_iv (RUNE)
1385	const_iv (TRAP) const_iv (POWER_CRYSTAL) const_iv (CORPSE) const_iv (DISEASE)
1386	const_iv (SYMPTOM) const_iv (BUILDER) const_iv (MATERIAL) const_iv (ITEM_TRANSFORMER)
1387
1388	const_iv (NUM_TYPES) const_iv (NUM_SUBTYPES)
1389
1390	const_iv (ST_BD_BUILD) const_iv (ST_BD_REMOVE)
1391	const_iv (ST_MAT_FLOOR) const_iv (ST_MAT_WALL) const_iv (ST_MAT_ITEM)
1392
1393	const_iv (AT_PHYSICAL) const_iv (AT_MAGIC) const_iv (AT_FIRE) const_iv (AT_ELECTRICITY)
1394	const_iv (AT_COLD) const_iv (AT_CONFUSION) const_iv (AT_ACID) const_iv (AT_DRAIN)
1395	const_iv (AT_WEAPONMAGIC) const_iv (AT_GHOSTHIT) const_iv (AT_POISON) const_iv (AT_SLOW)
1396	const_iv (AT_PARALYZE) const_iv (AT_TURN_UNDEAD) const_iv (AT_FEAR) const_iv (AT_CANCELLATION)
1397	const_iv (AT_DEPLETE) const_iv (AT_DEATH) const_iv (AT_CHAOS) const_iv (AT_COUNTERSPELL)
1398	const_iv (AT_GODPOWER) const_iv (AT_HOLYWORD) const_iv (AT_BLIND) const_iv (AT_INTERNAL)
1399	const_iv (AT_LIFE_STEALING) const_iv (AT_DISEASE)
1400
1401	const_iv (WEAP_HIT) const_iv (WEAP_SLASH) const_iv (WEAP_PIERCE) const_iv (WEAP_CLEAVE)
1402	const_iv (WEAP_SLICE) const_iv (WEAP_STAB) const_iv (WEAP_WHIP) const_iv (WEAP_CRUSH)
1403	const_iv (WEAP_BLUD)
1404
1405	const_iv (FLAG_ALIVE) const_iv (FLAG_WIZ) const_iv (FLAG_REMOVED) const_iv (FLAG_FREED)
1406	const_iv (FLAG_APPLIED) const_iv (FLAG_UNPAID) const_iv (FLAG_USE_SHIELD)
1407	const_iv (FLAG_NO_PICK) const_iv (FLAG_ANIMATE) const_iv (FLAG_MONSTER) const_iv (FLAG_FRIENDLY)
1408	const_iv (FLAG_GENERATOR) const_iv (FLAG_IS_THROWN) const_iv (FLAG_AUTO_APPLY) const_iv (FLAG_PLAYER_SOLD)
1409	const_iv (FLAG_SEE_INVISIBLE) const_iv (FLAG_CAN_ROLL) const_iv (FLAG_OVERLAY_FLOOR) const_iv (FLAG_IS_TURNABLE)
1410	const_iv (FLAG_IS_USED_UP) const_iv (FLAG_IDENTIFIED) const_iv (FLAG_REFLECTING) const_iv (FLAG_CHANGING)
1411	const_iv (FLAG_SPLITTING) const_iv (FLAG_HITBACK) const_iv (FLAG_STARTEQUIP) const_iv (FLAG_BLOCKSVIEW)
1412	const_iv (FLAG_UNDEAD) const_iv (FLAG_SCARED) const_iv (FLAG_UNAGGRESSIVE) const_iv (FLAG_REFL_MISSILE)
1413	const_iv (FLAG_REFL_SPELL) const_iv (FLAG_NO_MAGIC) const_iv (FLAG_NO_FIX_PLAYER) const_iv (FLAG_IS_LIGHTABLE)
1414	const_iv (FLAG_TEAR_DOWN) const_iv (FLAG_RUN_AWAY) const_iv (FLAG_PICK_UP) const_iv (FLAG_UNIQUE)
1415	const_iv (FLAG_NO_DROP) const_iv (FLAG_WIZCAST) const_iv (FLAG_CAST_SPELL) const_iv (FLAG_USE_SCROLL)
1416	const_iv (FLAG_USE_RANGE) const_iv (FLAG_USE_BOW) const_iv (FLAG_USE_ARMOUR) const_iv (FLAG_USE_WEAPON)
1417	const_iv (FLAG_USE_RING) const_iv (FLAG_READY_RANGE) const_iv (FLAG_READY_BOW) const_iv (FLAG_XRAYS)
1418	const_iv (FLAG_NO_APPLY) const_iv (FLAG_IS_FLOOR) const_iv (FLAG_LIFESAVE) const_iv (FLAG_NO_STRENGTH)
1419	const_iv (FLAG_SLEEP) const_iv (FLAG_STAND_STILL) const_iv (FLAG_RANDOM_MOVE) const_iv (FLAG_ONLY_ATTACK)
1420	const_iv (FLAG_CONFUSED) const_iv (FLAG_STEALTH) const_iv (FLAG_WIZPASS) const_iv (FLAG_IS_LINKED)
1421	const_iv (FLAG_CURSED) const_iv (FLAG_DAMNED) const_iv (FLAG_SEE_ANYWHERE) const_iv (FLAG_KNOWN_MAGICAL)
1422	const_iv (FLAG_KNOWN_CURSED) const_iv (FLAG_CAN_USE_SKILL) const_iv (FLAG_BEEN_APPLIED) const_iv (FLAG_READY_SCROLL)
1423	const_iv (FLAG_USE_ROD) const_iv (FLAG_USE_HORN) const_iv (FLAG_MAKE_INVIS) const_iv (FLAG_INV_LOCKED)
1424	const_iv (FLAG_IS_WOODED) const_iv (FLAG_IS_HILLY) const_iv (FLAG_READY_SKILL) const_iv (FLAG_READY_WEAPON)
1425	const_iv (FLAG_NO_SKILL_IDENT) const_iv (FLAG_BLIND) const_iv (FLAG_SEE_IN_DARK) const_iv (FLAG_IS_CAULDRON)
1426	const_iv (FLAG_NO_STEAL) const_iv (FLAG_ONE_HIT) const_iv (FLAG_CLIENT_SENT) const_iv (FLAG_BERSERK)
1427	const_iv (FLAG_NEUTRAL) const_iv (FLAG_NO_ATTACK) const_iv (FLAG_NO_DAMAGE) const_iv (FLAG_OBJ_ORIGINAL)
1428	const_iv (FLAG_ACTIVATE_ON_PUSH) const_iv (FLAG_ACTIVATE_ON_RELEASE) const_iv (FLAG_IS_WATER)
1429	const_iv (FLAG_CONTENT_ON_GEN) const_iv (FLAG_IS_A_TEMPLATE) const_iv (FLAG_IS_BUILDABLE)
1430	const_iv (FLAG_DESTROY_ON_DEATH) const_iv (FLAG_NO_MAP_SAVE)
1431
1432	const_iv (NDI_BLACK) const_iv (NDI_WHITE) const_iv (NDI_NAVY) const_iv (NDI_RED)
1433	const_iv (NDI_ORANGE) const_iv (NDI_BLUE) const_iv (NDI_DK_ORANGE) const_iv (NDI_GREEN)
1434	const_iv (NDI_LT_GREEN) const_iv (NDI_GREY) const_iv (NDI_BROWN) const_iv (NDI_GOLD)
1435	const_iv (NDI_TAN) const_iv (NDI_MAX_COLOR) const_iv (NDI_COLOR_MASK) const_iv (NDI_UNIQUE)
1436	const_iv (NDI_ALL) const_iv (NDI_DEF) const_iv (NDI_REPLY) const_iv (NDI_CLIENT_MASK)
1437	const_iv (NDI_NOCREATE)
1438		1450
1439	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)
1440	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)
1441		1453
1442	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)
1443
1444	const_iv (SP_RAISE_DEAD)
1445	const_iv (SP_RUNE)
1446	const_iv (SP_MAKE_MARK)
1447	const_iv (SP_BOLT)
1448	const_iv (SP_BULLET)
1449	const_iv (SP_EXPLOSION)
1450	const_iv (SP_CONE)
1451	const_iv (SP_BOMB)
1452	const_iv (SP_WONDER)
1453	const_iv (SP_SMITE)
1454	const_iv (SP_MAGIC_MISSILE)
1455	const_iv (SP_SUMMON_GOLEM)
1456	const_iv (SP_DIMENSION_DOOR)
1457	const_iv (SP_MAGIC_MAPPING)
1458	const_iv (SP_MAGIC_WALL)
1459	const_iv (SP_DESTRUCTION)
1460	const_iv (SP_PERCEIVE_SELF)
1461	const_iv (SP_WORD_OF_RECALL)
1462	const_iv (SP_INVISIBLE)
1463	const_iv (SP_PROBE)
1464	const_iv (SP_HEALING)
1465	const_iv (SP_CREATE_FOOD)
1466	const_iv (SP_EARTH_TO_DUST)
1467	const_iv (SP_CHANGE_ABILITY)
1468	const_iv (SP_BLESS)
1469	const_iv (SP_CURSE)
1470	const_iv (SP_SUMMON_MONSTER)
1471	const_iv (SP_CHARGING)
1472	const_iv (SP_POLYMORPH)
1473	const_iv (SP_ALCHEMY)
1474	const_iv (SP_REMOVE_CURSE)
1475	const_iv (SP_IDENTIFY)
1476	const_iv (SP_DETECTION)
1477	const_iv (SP_MOOD_CHANGE)
1478	const_iv (SP_MOVING_BALL)
1479	const_iv (SP_SWARM)
1480	const_iv (SP_CHANGE_MANA)
1481	const_iv (SP_DISPEL_RUNE)
1482	const_iv (SP_CREATE_MISSILE)
1483	const_iv (SP_CONSECRATE)
1484	const_iv (SP_ANIMATE_WEAPON)
1485	const_iv (SP_LIGHT)
1486	const_iv (SP_CHANGE_MAP_LIGHT)
1487	const_iv (SP_FAERY_FIRE)
1488	const_iv (SP_CAUSE_DISEASE)
1489	const_iv (SP_AURA)
1490	const_iv (SP_TOWN_PORTAL)
1491	const_iv (SP_PARTY_SPELL)
1492		1455
1493	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)
1494	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)
1495	const_iv (F_LOCKED)	1458	const_iv (F_LOCKED)
1496		1459
1497	const_iv (F_BUY) const_iv (F_SHOP) const_iv (F_SELL)
1498
1499	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)
1500	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)
1501		1462
1502	const_iv (UP_OBJ_INSERT) const_iv (UP_OBJ_REMOVE) const_iv (UP_OBJ_CHANGE) const_iv (UP_OBJ_FACE)
1503
1504	const_iv (INS_NO_MERGE) const_iv (INS_ABOVE_FLOOR_ONLY) const_iv (INS_NO_WALK_ON)
1505	const_iv (INS_ON_TOP) const_iv (INS_BELOW_ORIGINATOR) const_iv (INS_MAP_LOAD)
1506
1507	const_iv (WILL_APPLY_HANDLE) const_iv (WILL_APPLY_TREASURE) const_iv (WILL_APPLY_EARTHWALL)
1508	const_iv (WILL_APPLY_DOOR) const_iv (WILL_APPLY_FOOD)
1509
1510	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)	1463	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)
1511
1512	const_iv (M_PAPER) const_iv (M_IRON) const_iv (M_GLASS) const_iv (M_LEATHER)
1513	const_iv (M_WOOD) const_iv (M_ORGANIC) const_iv (M_STONE) const_iv (M_CLOTH)
1514	const_iv (M_ADAMANT) const_iv (M_LIQUID) const_iv (M_SOFT_METAL) const_iv (M_BONE)
1515	const_iv (M_ICE) const_iv (M_SPECIAL)
1516		1464
1517	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)
1518	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)
1519		1467
1520	const_iv (SK_LOCKPICKING) const_iv (SK_HIDING) const_iv (SK_SMITHERY) const_iv (SK_BOWYER)
1521	const_iv (SK_JEWELER) const_iv (SK_ALCHEMY) const_iv (SK_STEALING) const_iv (SK_LITERACY)
1522	const_iv (SK_BARGAINING) const_iv (SK_JUMPING) const_iv (SK_DET_MAGIC) const_iv (SK_ORATORY)
1523	const_iv (SK_SINGING) const_iv (SK_DET_CURSE) const_iv (SK_FIND_TRAPS) const_iv (SK_MEDITATION)
1524	const_iv (SK_PUNCHING) const_iv (SK_FLAME_TOUCH) const_iv (SK_KARATE) const_iv (SK_CLIMBING)
1525	const_iv (SK_WOODSMAN) const_iv (SK_INSCRIPTION) const_iv (SK_ONE_HANDED_WEAPON) const_iv (SK_MISSILE_WEAPON)
1526	const_iv (SK_THROWING) const_iv (SK_USE_MAGIC_ITEM) const_iv (SK_DISARM_TRAPS) const_iv (SK_SET_TRAP)
1527	const_iv (SK_THAUMATURGY) const_iv (SK_PRAYING) const_iv (SK_CLAWING) const_iv (SK_LEVITATION)
1528	const_iv (SK_SUMMONING) const_iv (SK_PYROMANCY) const_iv (SK_EVOCATION) const_iv (SK_SORCERY)
1529	const_iv (SK_TWO_HANDED_WEAPON) const_iv (SK_SPARK_TOUCH) const_iv (SK_SHIVER) const_iv (SK_ACID_SPLASH)
1530	const_iv (SK_POISON_NAIL)
1531
1532	const_iv (SOUND_NEW_PLAYER) const_iv (SOUND_FIRE_ARROW) const_iv (SOUND_LEARN_SPELL) const_iv (SOUND_FUMBLE_SPELL)
1533	const_iv (SOUND_WAND_POOF) const_iv (SOUND_OPEN_DOOR) const_iv (SOUND_PUSH_PLAYER) const_iv (SOUND_PLAYER_HITS1)
1534	const_iv (SOUND_PLAYER_HITS2) const_iv (SOUND_PLAYER_HITS3) const_iv (SOUND_PLAYER_HITS4) const_iv (SOUND_PLAYER_IS_HIT1)
1535	const_iv (SOUND_PLAYER_IS_HIT2) const_iv (SOUND_PLAYER_IS_HIT3) const_iv (SOUND_PLAYER_KILLS) const_iv (SOUND_PET_IS_KILLED)
1536	const_iv (SOUND_PLAYER_DIES) const_iv (SOUND_OB_EVAPORATE) const_iv (SOUND_OB_EXPLODE) const_iv (SOUND_CLOCK)
1537	const_iv (SOUND_TURN_HANDLE) const_iv (SOUND_FALL_HOLE) const_iv (SOUND_DRINK_POISON) const_iv (SOUND_CAST_SPELL_0)
1538
1539	const_iv (PREFER_LOW) const_iv (PREFER_HIGH)
1540
1541	const_iv (ATNR_PHYSICAL) const_iv (ATNR_MAGIC) const_iv (ATNR_FIRE) const_iv (ATNR_ELECTRICITY)
1542	const_iv (ATNR_COLD) const_iv (ATNR_CONFUSION) const_iv (ATNR_ACID) const_iv (ATNR_DRAIN)
1543	const_iv (ATNR_WEAPONMAGIC) const_iv (ATNR_GHOSTHIT) const_iv (ATNR_POISON) const_iv (ATNR_SLOW)
1544	const_iv (ATNR_PARALYZE) const_iv (ATNR_TURN_UNDEAD) const_iv (ATNR_FEAR) const_iv (ATNR_CANCELLATION)
1545	const_iv (ATNR_DEPLETE) const_iv (ATNR_DEATH) const_iv (ATNR_CHAOS) const_iv (ATNR_COUNTERSPELL)
1546	const_iv (ATNR_GODPOWER) const_iv (ATNR_HOLYWORD) const_iv (ATNR_BLIND) const_iv (ATNR_INTERNAL)
1547	const_iv (ATNR_LIFE_STEALING) const_iv (ATNR_DISEASE)
1548
1549	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)
1550		1470
1551	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)
1552	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)
1553		1473
1554	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)
1555		1475
1556	const_iv (ST_DEAD) const_iv (ST_SETUP) const_iv (ST_PLAYING) const_iv (ST_CUSTOM)
1557
1558	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)
1559
1560	// random map generator
1561	const_iv (LAYOUT_NONE) const_iv (LAYOUT_ONION) const_iv (LAYOUT_MAZE) const_iv (LAYOUT_SPIRAL)
1562	const_iv (LAYOUT_ROGUELIKE) const_iv (LAYOUT_SNAKE) const_iv (LAYOUT_SQUARE_SPIRAL)
1563
1564	const_iv (RMOPT_RANDOM) const_iv (RMOPT_CENTERED) const_iv (RMOPT_LINEAR)
1565	const_iv (RMOPT_BOTTOM_C) const_iv (RMOPT_BOTTOM_R) const_iv (RMOPT_IRR_SPACE)
1566	const_iv (RMOPT_WALL_OFF) const_iv (RMOPT_WALLS_ONLY) const_iv (RMOPT_NO_DOORS)
1567
1568	const_iv (SYMMETRY_RANDOM) const_iv (SYMMETRY_NONE) const_iv (SYMMETRY_X)
1569	const_iv (SYMMETRY_Y) const_iv (SYMMETRY_XY)
1570
1571	const_iv (GT_ENVIRONMENT) const_iv (GT_INVISIBLE) const_iv (GT_STARTEQUIP)
1572	const_iv (GT_APPLY) const_iv (GT_ONLY_GOOD) const_iv (GT_UPDATE_INV)
1573	const_iv (GT_MINIMAL)
1574
1575	const_iv (FT_FACE) const_iv (FT_MUSIC) const_iv (FT_SOUND)
1576	const_iv (FT_RSRC) const_iv (FT_NUM)
1577	};	1477	};
1578		1478
1579	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; )
1580	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));	1480	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1581		1481
…		…
1598	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));	1498	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));
1599	av_push (event, newSViv (eiv->klass));	1499	av_push (event, newSViv (eiv->klass));
1600	av_store (av, eiv->iv, newRV_noinc ((SV *)event));	1500	av_store (av, eiv->iv, newRV_noinc ((SV *)event));
1601	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));	1501	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));
1602	}	1502	}
1603	}
1604		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
1605	void _connect_to_perl ()	1522	void _connect_to_perl_1 ()
		1523
		1524	void _connect_to_perl_2 ()
1606		1525
1607	void _recalc_want ()	1526	void _recalc_want ()
1608		1527
		1528	# not used by default anymore
1609	void _global_reattach ()	1529	void _global_reattach ()
1610	CODE:	1530	CODE:
1611	{	1531	{
1612	// reattach to all attachable objects in the game.	1532	// reattach to all attachable objects in the game.
1613	for_all_clients (ns)	1533	for_all_clients (ns)
…		…
1657	}	1577	}
1658		1578
1659	SvCUR_set (data_sv, dst - SvPVX (data_sv));	1579	SvCUR_set (data_sv, dst - SvPVX (data_sv));
1660	}	1580	}
1661		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
1662	void _post_tick ()	1608	void cede_to_tick ()
1663	CODE:	1609	CODE:
1664	coroapi::next_cede = SvNV (sv_next_tick) - TICK * (1. - 1. / CEDES_PER_TICK);	1610	coroapi::cede_to_tick ();
1665		1611
1666	NV till_cede ()	1612	NV till_tick ()
1667	CODE:	1613	CODE:
1668	RETVAL = coroapi::next_cede - now ();	1614	RETVAL = SvNVX (sv_next_tick) - now ();
1669	OUTPUT:	1615	OUTPUT:
1670	RETVAL	1616	RETVAL
1671		1617
1672	NV till_tick ()	1618	int tick_inhibit ()
1673	CODE:	1619	CODE:
1674	RETVAL = SvNV (sv_next_tick) - now ();	1620	RETVAL = tick_inhibit;
1675	OUTPUT:	1621	OUTPUT:
1676	RETVAL	1622	RETVAL
1677		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
1678	NV floor (NV x)	1655	NV floor (NV x)
1679		1656
1680	NV ceil (NV x)	1657	NV ceil (NV x)
1681		1658
1682	NV rndm (...)	1659	NV rndm (...)
		1660	ALIAS:
		1661	rmg_rndm = 1
1683	CODE:	1662	CODE:
		1663	{
		1664	rand_gen &gen = ix ? rmg_rndm : rndm;
1684	switch (items)	1665	switch (items)
1685	{	1666	{
1686	case 0: RETVAL = rndm (); break;	1667	case 0: RETVAL = gen (); break;
1687	case 1: RETVAL = rndm (SvUV (ST (0))); break;	1668	case 1: RETVAL = gen (SvUV (ST (0))); break;
1688	case 2: RETVAL = rndm (SvIV (ST (0)), SvIV (ST (1))); break;	1669	case 2: RETVAL = gen (SvIV (ST (0)), SvIV (ST (1))); break;
1689	default: croak ("cf::rndm requires none, one or two parameters."); break;	1670	default: croak ("cf::rndm requires zero, one or two parameters."); break;
1690	}	1671	}
		1672	}
1691	OUTPUT:	1673	OUTPUT:
1692	RETVAL	1674	RETVAL
1693		1675
1694	NV clamp (NV value, NV min_value, NV max_value)	1676	NV clamp (NV value, NV min_value, NV max_value)
1695	CODE:	1677	CODE:
…		…
1701	CODE:	1683	CODE:
1702	RETVAL = lerp (value, min_in, max_in, min_out, max_out);	1684	RETVAL = lerp (value, min_in, max_in, min_out, max_out);
1703	OUTPUT:	1685	OUTPUT:
1704	RETVAL	1686	RETVAL
1705		1687
1706	void cede_to_tick ()	1688	const char *ordinal (int i)
1707	CODE:
1708	coroapi::cede_to_tick ();
1709		1689
1710	void server_tick ()	1690	void weaken (...)
1711	CODE:	1691	PROTOTYPE: @
1712	NOW = now ();	1692	CODE:
1713	runtime = SvNVx (sv_runtime);	1693	while (items > 0)
1714	server_tick ();	1694	sv_rvweaken (ST (--items));
1715		1695
1716	void	1696	void log_suspend ()
		1697
		1698	void log_resume ()
		1699
1717	log_backtrace (utf8_string msg)	1700	void log_backtrace (utf8_string msg)
1718		1701
1719	void
1720	LOG (int flags, utf8_string msg)	1702	void LOG (int flags, utf8_string msg)
1721	PROTOTYPE: $$	1703	PROTOTYPE: $$
1722	C_ARGS: flags, "%s", msg	1704	C_ARGS: flags, "%s", msg
1723		1705
1724	octet_string path_combine (octet_string base, octet_string path)	1706	octet_string path_combine (octet_string base, octet_string path)
1725	PROTOTYPE: $$	1707	PROTOTYPE: $$
…		…
1758		1740
1759	void abort ()	1741	void abort ()
1760		1742
1761	void reset_signals ()	1743	void reset_signals ()
1762		1744
1763	void fork_abort (octet_string cause = "cf::fork_abort")	1745	void fork_abort (const_octet_string cause = "cf::fork_abort")
1764		1746
1765	void cleanup (octet_string cause, bool make_core = false)	1747	void cleanup (const_octet_string cause, bool make_core = false)
1766		1748
1767	void emergency_save ()	1749	void emergency_save ()
1768		1750
1769	void _exit (int status = EXIT_SUCCESS)	1751	void _exit (int status = EXIT_SUCCESS)
1770		1752
1771	UV sv_2watcher (SV *w)
1772	CODE:
1773	RETVAL = (UV)GEventAPI->sv_2watcher (w);
1774	OUTPUT:
1775	RETVAL
1776
1777	#if _POSIX_MEMLOCK	1753	#if _POSIX_MEMLOCK
1778		1754
1779	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
1780		1763
1781	int munlockall ()	1764	int munlockall ()
1782		1765
1783	#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	}
1784		1796
1785	int find_animation (utf8_string text)	1797	int find_animation (utf8_string text)
1786	PROTOTYPE: $	1798	PROTOTYPE: $
1787		1799
1788	int random_roll (int min, int max, object *op, int goodbad);	1800	int random_roll (int min, int max, object *op, int goodbad);
…		…
1826	RETVAL = newSVpv (resist_plus[atnr], 0);	1838	RETVAL = newSVpv (resist_plus[atnr], 0);
1827	else	1839	else
1828	XSRETURN_UNDEF;	1840	XSRETURN_UNDEF;
1829	OUTPUT: RETVAL	1841	OUTPUT: RETVAL
1830		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
1831	bool	1885	bool
1832	load_resource_file (octet_string filename)	1886	load_resource_file_ (octet_string filename)
		1887
		1888	void
		1889	fix_weight ()
1833		1890
1834	MODULE = cf PACKAGE = cf::attachable	1891	MODULE = cf PACKAGE = cf::attachable
1835		1892
1836	int	1893	int
1837	valid (SV *obj)	1894	valid (SV *obj)
…		…
1841	RETVAL	1898	RETVAL
1842		1899
1843	void	1900	void
1844	debug_trace (attachable *obj, bool on = true)	1901	debug_trace (attachable *obj, bool on = true)
1845	CODE:	1902	CODE:
1846	obj->flags &= ~attachable::F_DEBUG_TRACE;	1903	obj->attachable_flags &= ~attachable::F_DEBUG_TRACE;
1847	if (on)	1904	if (on)
1848	obj->flags |= attachable::F_DEBUG_TRACE;	1905	obj->attachable_flags |= attachable::F_DEBUG_TRACE;
1849		1906
1850	int mortals_size ()	1907	int mortals_size ()
1851	CODE:	1908	CODE:
1852	RETVAL = attachable::mortals.size ();	1909	RETVAL = attachable::mortals.size ();
1853	OUTPUT: RETVAL	1910	OUTPUT: RETVAL
…		…
1855	#object *mortals (U32 index)	1912	#object *mortals (U32 index)
1856	# CODE:	1913	# CODE:
1857	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;	1914	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;
1858	# OUTPUT: RETVAL	1915	# OUTPUT: RETVAL
1859		1916
1860	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 |
1861		1918
1862	MODULE = cf PACKAGE = cf::global	1919	MODULE = cf PACKAGE = cf::global
1863		1920
1864	int invoke (SV *klass, int event, ...)	1921	int invoke (SV *klass, int event, ...)
1865	CODE:	1922	CODE:
…		…
1869	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);
1870	OUTPUT: RETVAL	1927	OUTPUT: RETVAL
1871		1928
1872	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_	1929	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
1873		1930
1874	INCLUDE: $PERL $srcdir/genacc object ../include/object.h |	1931	INCLUDE: $PERL $srcdir/genacc object $srcdir/../include/object.h |
1875		1932
1876	int invoke (object *op, int event, ...)	1933	int invoke (object *op, int event, ...)
1877	CODE:	1934	CODE:
1878	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");
1879	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	1936	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
1901	object *actives (U32 index)	1958	object *actives (U32 index)
1902	CODE:	1959	CODE:
1903	RETVAL = index < actives.size () ? actives [index] : 0;	1960	RETVAL = index < actives.size () ? actives [index] : 0;
1904	OUTPUT: RETVAL	1961	OUTPUT: RETVAL
1905		1962
		1963	int mortals_size ()
		1964	CODE:
		1965	RETVAL = attachable::mortals.size ();
		1966	OUTPUT: RETVAL
		1967
1906	const char *slot_use_name (U32 slot)	1968	const_utf8_string slot_use_name (U32 slot)
1907	ALIAS:	1969	ALIAS:
1908	slot_nonuse_name = 1	1970	slot_nonuse_name = 1
1909	CODE:	1971	CODE:
1910	{	1972	{
1911	if (slot >= NUM_BODY_LOCATIONS)	1973	if (slot >= NUM_BODY_LOCATIONS)
…		…
1931	void	1993	void
1932	inv (object *obj)	1994	inv (object *obj)
1933	PROTOTYPE: $	1995	PROTOTYPE: $
1934	PPCODE:	1996	PPCODE:
1935	{	1997	{
1936	object *o;
1937	for (o = obj->inv; o; o = o->below)	1998	for (object *o = obj->inv; o; o = o->below)
1938	XPUSHs (sv_2mortal (to_sv (o)));	1999	XPUSHs (sv_2mortal (to_sv (o)));
1939	}	2000	}
1940		2001
1941	void	2002	void
1942	set_animation (object *op, int idx)	2003	set_animation (object *op, int idx)
…		…
1974		2035
1975	int need_identify (object *obj);	2036	int need_identify (object *obj);
1976		2037
1977	int apply_shop_mat (object *shop_mat, object *op);	2038	int apply_shop_mat (object *shop_mat, object *op);
1978		2039
1979	int move_player (object *op, int dir)	2040	int move (object *op, int dir, object *originator = op)
1980	CODE:	2041	CODE:
1981	RETVAL = move_player (op, dir);	2042	RETVAL = op->move (dir, originator);
1982	OUTPUT:	2043	OUTPUT:
1983	RETVAL	2044	RETVAL
1984		2045
1985	int move (object *op, int dir, object *originator = op)
1986	CODE:
1987	RETVAL = move_ob (op, dir, originator);
1988	OUTPUT:
1989	RETVAL
1990
1991	void apply (object *applier, object *applied, int flags = 0)
1992	CODE:
1993	manual_apply (applied, applier, flags);
1994
1995	void apply_below (object *op)	2046	void apply_below (object *op)
1996	CODE:	2047	CODE:
1997	player_apply_below (op);	2048	player_apply_below (op);
1998		2049
1999	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)
2000		2051
2001	object *cf_object_present_archname_inside (object *op, utf8_string whatstr)	2052	int casting_level (object *caster, object *spell)
2002
2003	int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)
2004
2005	int cf_object_change_map (object *op, int x, int y, maptile *map)
2006
2007	#//TODO
2008	object *clone_ (object *op, int recursive = 0)
2009	CODE:
2010	if (recursive)
2011	RETVAL = object_create_clone (op);
2012	else
2013	{
2014	RETVAL = object::create ();
2015	op->copy_to (RETVAL);
2016	}
2017	OUTPUT: RETVAL
2018		2053
2019	int pay_item (object *op, object *buyer)	2054	int pay_item (object *op, object *buyer)
2020	CODE:	2055	CODE:
2021	RETVAL = pay_for_item (op, buyer);	2056	RETVAL = pay_for_item (op, buyer);
2022	OUTPUT: RETVAL	2057	OUTPUT: RETVAL
…		…
2057		2092
2058	void drop (object *who, object *op)	2093	void drop (object *who, object *op)
2059		2094
2060	void pick_up (object *who, object *op)	2095	void pick_up (object *who, object *op)
2061		2096
2062	int cf_object_teleport (object *op, maptile *map, int x, int y)
2063
2064	void update_object (object *op, int action)	2097	void update_object (object *op, int action)
2065		2098
2066	object *cf_create_object_by_name (utf8_string name)
2067
2068	void change_exp (object *op, uint64 exp, utf8_string skill_name = 0, int flag = 0)	2099	void change_exp (object *op, uint64 exp, utf8_string skill_name = 0, int flag = 0)
2069		2100
2070	void player_lvl_adj (object *who, object *skill = 0)	2101	void player_lvl_adj (object *who, object *skill = 0)
2071		2102
2072	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)
2073		2104
2074	int calc_skill_exp (object *who, object *op, object *skill);	2105	int calc_skill_exp (object *who, object *op, object *skill)
2075		2106
2076	void push_button (object *op);	2107	void push_button (object *op, object *originator)
2077		2108
2078	void use_trigger (object *op);	2109	void use_trigger (object *op, object *originator)
2079		2110
2080	void add_button_link (object *button, maptile *map, int connected);
2081
2082	void remove_button_link (object *op);
2083
2084	void handle_apply_yield (object *op);	2111	void handle_apply_yield (object *op)
2085		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);
2086		2116
2087	MODULE = cf PACKAGE = cf::object PREFIX = cf_	2117	MODULE = cf PACKAGE = cf::object PREFIX = cf_
2088
2089	object *cf_insert_ob_in_ob (object *ob, object *where)
2090		2118
2091	# 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
2092	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.	2120	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.
2093		2121
2094	object *new (utf8_string archetype = 0)	2122	object *new (utf8_string archetype = 0)
…		…
2096	CODE:	2124	CODE:
2097	RETVAL = archetype ? get_archetype (archetype) : object::create ();	2125	RETVAL = archetype ? get_archetype (archetype) : object::create ();
2098	OUTPUT:	2126	OUTPUT:
2099	RETVAL	2127	RETVAL
2100		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
2101	object *find_object (U32 tag)	2137	object *find_object (U32 tag)
		2138
		2139	object *find_object_uuid (UUID i)
2102		2140
2103	# TODO: nuke	2141	# TODO: nuke
2104	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)
2105	PROTOTYPE: $$$$$$	2143	PROTOTYPE: $$$$$$
2106	CODE:	2144	CODE:
2107	{	2145	{
2108	int unused_type;	2146	RETVAL = insert_ob_in_map_at (ob, where, orig, flag, x, y);
2109	RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);
2110	}
2111		2147
2112	const_utf8_string get_ob_key_value (object *op, utf8_string key)	2148	if (RETVAL->destroyed ())
		2149	RETVAL = 0;
		2150	}
2113		2151
2114	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)
2115		2160
2116	object *get_nearest_player (object *ob)	2161	object *get_nearest_player (object *ob)
2117	ALIAS: nearest_player = 0	2162	ALIAS: nearest_player = 0
2118	PREINIT:	2163	PREINIT:
2119	extern object *get_nearest_player (object *);	2164	extern object *get_nearest_player (object *);
…		…
2121	void rangevector (object *ob, object *other, int flags = 0)	2166	void rangevector (object *ob, object *other, int flags = 0)
2122	PROTOTYPE: $$;$	2167	PROTOTYPE: $$;$
2123	PPCODE:	2168	PPCODE:
2124	{	2169	{
2125	rv_vector rv;	2170	rv_vector rv;
		2171
2126	get_rangevector (ob, other, &rv, flags);	2172	get_rangevector (ob, other, &rv, flags);
		2173
2127	EXTEND (SP, 5);	2174	EXTEND (SP, 5);
2128	PUSHs (newSVuv (rv.distance));	2175	PUSHs (sv_2mortal (newSVuv (rv.distance)));
2129	PUSHs (newSViv (rv.distance_x));	2176	PUSHs (sv_2mortal (newSViv (rv.distance_x)));
2130	PUSHs (newSViv (rv.distance_y));	2177	PUSHs (sv_2mortal (newSViv (rv.distance_y)));
2131	PUSHs (newSViv (rv.direction));	2178	PUSHs (sv_2mortal (newSViv (rv.direction)));
2132	PUSHs (newSVcfapi (CFAPI_POBJECT, rv.part));	2179	PUSHs (sv_2mortal (to_sv (rv.part)));
2133	}	2180	}
2134		2181
2135	bool on_same_map_as (object *ob, object *other)	2182	bool on_same_map_as (object *ob, object *other)
2136	CODE:	2183	CODE:
2137	RETVAL = on_same_map (ob, other);	2184	RETVAL = on_same_map (ob, other);
…		…
2141	base_name (object *op, int plural = op->nrof > 1)	2188	base_name (object *op, int plural = op->nrof > 1)
2142	CODE:	2189	CODE:
2143	RETVAL = query_base_name (op, plural);	2190	RETVAL = query_base_name (op, plural);
2144	OUTPUT: RETVAL	2191	OUTPUT: RETVAL
2145		2192
2146	object *decrease_ob_nr (object *op, unsigned long i)	2193	# return the tail of an object, excluding itself
		2194	void
		2195	tail (object *op)
		2196	PPCODE:
		2197	while ((op = op->more))
		2198	XPUSHs (sv_2mortal (to_sv (op)));
2147		2199
2148	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_	2200	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_
2149		2201
2150	player *player (object *op)	2202	player *player (object *op)
2151	CODE:	2203	CODE:
2152	RETVAL = op->contr;	2204	RETVAL = op->contr;
2153	OUTPUT: RETVAL	2205	OUTPUT: RETVAL
2154		2206
2155	void check_score (object *op)	2207	bool move_player (object *op, int dir)
2156		2208
2157	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)
2158	CODE:	2210	CODE:
2159	new_draw_info (flags, 0, op, txt);	2211	new_draw_info (flags, 0, op, txt);
2160		2212
2161	void kill_player (object *op)	2213	void kill_player (object *op)
2162		2214
		2215	void esrv_send_item (object *pl, object *item)
		2216
2163	void esrv_update_item (object *op, int what, object *item)	2217	void esrv_update_item (object *pl, int what, object *item)
2164	C_ARGS: what, op, item	2218	C_ARGS: what, pl, item
		2219
		2220	void esrv_del_item (object *pl, int tag)
		2221	C_ARGS: pl->contr, tag
2165		2222
2166	int command_summon (object *op, utf8_string params)	2223	int command_summon (object *op, utf8_string params)
2167		2224
2168	int command_arrest (object *op, utf8_string params)	2225	int command_arrest (object *op, utf8_string params)
2169		2226
2170		2227
2171	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_	2228	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
2172		2229
2173	INCLUDE: $PERL $srcdir/genacc player ../include/player.h |	2230	INCLUDE: $PERL $srcdir/genacc player $srcdir/../include/player.h |
2174		2231
2175	int invoke (player *pl, int event, ...)	2232	int invoke (player *pl, int event, ...)
2176	CODE:	2233	CODE:
2177	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");
2178	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	2235	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
2188	pl->ob->stats.hp = pl->ob->stats.maxhp;	2245	pl->ob->stats.hp = pl->ob->stats.maxhp;
2189	pl->ob->stats.sp = pl->ob->stats.maxsp;	2246	pl->ob->stats.sp = pl->ob->stats.maxsp;
2190	pl->ob->stats.grace = pl->ob->stats.maxgrace;	2247	pl->ob->stats.grace = pl->ob->stats.maxgrace;
2191	pl->orig_stats = pl->ob->stats;	2248	pl->orig_stats = pl->ob->stats;
2192		2249
2193	void clear_los (player *pl)	2250	# should only be temporary
		2251	void esrv_new_player (player *pl)
2194		2252
2195	void cf_player_move (player *pl, int dir)	2253	#d# TODO: replace by blocked_los accessor, fix code using this
2196
2197	bool	2254	bool
2198	cell_visible (player *pl, int dx, int dy)	2255	cell_visible (player *pl, int dx, int dy)
2199	CODE:	2256	CODE:
2200	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2	2257	RETVAL = pl->blocked_los (dx, dy) != LOS_BLOCKED;
2201	&& !pl->blocked_los [dx + pl->ns->mapx / 2][dy + pl->ns->mapy / 2];
2202	OUTPUT:	2258	OUTPUT:
2203	RETVAL	2259	RETVAL
2204		2260
2205	void	2261	void
2206	send (player *pl, SV *packet)	2262	send (player *pl, SV *packet)
2207	CODE:	2263	CODE:
2208	{	2264	{
2209	STRLEN len;	2265	STRLEN len;
2210	char *buf = SvPVbyte (packet, len);	2266	char *buf = SvPVbyte (packet, len);
2211		2267
		2268	if (len > MAXSOCKBUF)
		2269	pl->failmsg ("[packet too long for client]");
2212	if (pl->ns)	2270	else if (pl->ns)
2213	pl->ns->send_packet (buf, len);	2271	pl->ns->send_packet (buf, len);
2214	}	2272	}
2215
2216	int
2217	listening (player *pl, int new_value = -1)
2218	CODE:
2219	RETVAL = pl->listening;
2220	if (new_value >= 0)
2221	pl->listening = new_value;
2222	OUTPUT:
2223	RETVAL
2224		2273
2225	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)
2226	PROTOTYPE: $;$$$	2275	PROTOTYPE: $;$$$
2227	PPCODE:	2276	PPCODE:
2228	if (GIMME_V != G_VOID)	2277	if (GIMME_V != G_VOID)
…		…
2253	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);	2302	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);
2254	OUTPUT: RETVAL	2303	OUTPUT: RETVAL
2255		2304
2256	SV *registry (maptile *map)	2305	SV *registry (maptile *map)
2257		2306
		2307	void
		2308	find_tagged_objects (maptile *map, utf8_string tag = 0)
		2309	PPCODE:
		2310	{
		2311	if (!map->spaces)
		2312	XSRETURN_EMPTY;
		2313
		2314	if (tag)
		2315	{
		2316	shstr_cmp tag_ (tag);
		2317
		2318	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2319	for (object *op = ms->bot; op; op = op->above)
		2320	if (op->tag == tag_)
		2321	XPUSHs (sv_2mortal (to_sv (op)));
		2322	}
		2323	else
		2324	{
		2325	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2326	for (object *op = ms->bot; op; op = op->above)
		2327	if (op->tag)
		2328	XPUSHs (sv_2mortal (to_sv (op)));
		2329	}
		2330	}
		2331
2258	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
2259		2347
2260	void	2348	void
2261	maptile::instantiate ()	2349	maptile::instantiate ()
2262		2350
2263	maptile *new ()	2351	maptile *new ()
…		…
2295	for (int x = 0; x < THIS->width; ++x)	2383	for (int x = 0; x < THIS->width; ++x)
2296	for (int y = 0; y < THIS->height; ++y)	2384	for (int y = 0; y < THIS->height; ++y)
2297	{	2385	{
2298	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)
2299	if (op->flag [FLAG_IS_FLOOR])	2387	if (op->flag [FLAG_IS_FLOOR])
2300	goto skip_space;	2388	goto skip;
2301		2389
2302	{	2390	{
2303	int offs = offset + y * stride + x;	2391	int offs = offset + y * stride + x;
		2392
2304	if (IN_RANGE_EXC (offs, 0, idxlen))	2393	if (IN_RANGE_EXC (offs, 0, idxlen))
2305	{	2394	{
2306	if (SV **elem = av_fetch ((AV *)palette, idx [offs], 0))	2395	if (SV **elem = av_fetch ((AV *)palette, idx [offs], 0))
2307	{	2396	{
2308	object *ob = get_archetype (SvPVutf8_nolen (*elem));	2397	object *ob = get_archetype (cfSvPVutf8_nolen (*elem));
2309	ob->flag [FLAG_NO_MAP_SAVE] = true;	2398	ob->flag [FLAG_NO_MAP_SAVE] = true;
2310	THIS->insert (ob, x, y, 0, INS_ABOVE_FLOOR_ONLY);	2399	THIS->insert (ob, x, y, 0, INS_ABOVE_FLOOR_ONLY);
2311		2400
2312	if (ob->randomitems)	2401	if (ob->randomitems && !ob->above)
2313	{	2402	{
2314	if (!ob->above)
2315	{
2316	ob->create_treasure (ob->randomitems);	2403	ob->create_treasure (ob->randomitems);
2317		2404
2318	for (object *op = ob->above; op; op = op->above)	2405	for (object *op = ob->above; op; op = op->above)
2319	op->flag [FLAG_NO_MAP_SAVE] = true;	2406	op->flag [FLAG_NO_MAP_SAVE] = true;
2320	}	2407	// TODO: if this is a pickable object, then the item
2321		2408	// will at a bit weird - saving inside the player
2322	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.
2323	}	2413	}
2324	}	2414	}
2325	}	2415	}
2326	}	2416	}
2327		2417
2328	skip_space: ;	2418	skip: ;
2329	}	2419	}
2330	}	2420	}
2331		2421
2332	void	2422	void
2333	maptile::set_regiondata (SV *data, int offset, int stride, SV *palette)	2423	maptile::set_regiondata (SV *data, int offset, int stride, SV *palette)
…		…
2343		2433
2344	region_ptr *regionmap = new region_ptr [av_len ((AV *)palette) + 1];	2434	region_ptr *regionmap = new region_ptr [av_len ((AV *)palette) + 1];
2345	uint8_t *regions = salloc<uint8_t> (THIS->size ());	2435	uint8_t *regions = salloc<uint8_t> (THIS->size ());
2346		2436
2347	for (int i = av_len ((AV *)palette) + 1; i--; )	2437	for (int i = av_len ((AV *)palette) + 1; i--; )
2348	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)));
2349		2439
2350	for (int y = 0; y < THIS->height; ++y)	2440	for (int y = 0; y < THIS->height; ++y)
2351	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);	2441	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);
2352		2442
2353	sfree (THIS->regions, THIS->size ());	2443	sfree (THIS->regions, THIS->size ());
…		…
2358	}	2448	}
2359		2449
2360	void	2450	void
2361	maptile::create_region_treasure ()	2451	maptile::create_region_treasure ()
2362	CODE:	2452	CODE:
2363	{
2364	object *op = object::create ();
2365	op->type = FLOOR;
2366	op->map = THIS;
2367
2368	for (int x = 0; x < THIS->width; ++x)	2453	for (int x = 0; x < THIS->width; ++x)
2369	for (int y = 0; y < THIS->height; ++y)	2454	for (int y = 0; y < THIS->height; ++y)
2370	{	2455	{
2371	region *rgn = THIS->region (x, y);	2456	region *rgn = THIS->region (x, y);
2372		2457
2373	//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)
2374	if (rgn->treasure && rndm () < rgn->treasure_density)	2460	if (rgn->treasure && rndm () < rgn->treasure_density)
2375	{
2376	op->x = x;
2377	op->y = y;
2378	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);	2461	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);
2379	}
2380	}	2462	}
2381		2463
2382	op->destroy ();
2383	}
2384
2385	int out_of_map (maptile *map, int x, int y)	2464	int out_of_map (maptile *map, int x, int y)
2386		2465
2387	void	2466	void
2388	trigger (maptile *map, long connection, bool state = true)	2467	find_link (maptile *map, shstr_tmp connection)
2389	CODE:
2390	activate_connection (map, connection, state);
2391
2392	void
2393	get_connection (maptile *map, long connection)
2394	PPCODE:	2468	PPCODE:
2395	oblinkpt *obp = get_connection_links (map, connection);	2469	if (oblinkpt *obp = map->find_link (connection))
2396	if (obp)
2397	for (objectlink *ol = obp->link; ol; ol = ol->next)	2470	for (objectlink *ol = obp->link; ol; ol = ol->next)
2398	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, (object *)ol->ob)));	2471	XPUSHs (sv_2mortal (to_sv ((object *)ol->ob)));
2399
2400	object *cf_map_insert_object_there (maptile *where, object *op, object *originator, int flags)
2401
2402	object *cf_map_insert_object (maptile *where, object* op, int x, int y)
2403
2404	object* cf_map_present_arch_by_name (maptile *map, const char* str, int nx, int ny)
2405	C_ARGS: str, map, nx, ny
2406		2472
2407	void	2473	void
2408	get_map_flags (maptile *map, int x, int y)	2474	get_map_flags (maptile *map, int x, int y)
2409	PPCODE:	2475	PPCODE:
2410	{	2476	{
2411	maptile *nmap = 0;	2477	maptile *nmap = 0;
2412	I16 nx = 0, ny = 0;	2478	I16 nx = 0, ny = 0;
		2479
		2480	PUTBACK;
2413	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;
2414		2483
2415	EXTEND (SP, 4);	2484	EXTEND (SP, 4);
2416	PUSHs (sv_2mortal (newSViv (flags)));	2485	PUSHs (sv_2mortal (newSViv (flags)));
2417		2486
2418	if (GIMME_V == G_ARRAY)	2487	if (GIMME_V == G_ARRAY)
2419	{	2488	{
2420	PUSHs (sv_2mortal (newSVcfapi (CFAPI_PMAP, nmap)));	2489	PUSHs (sv_2mortal (to_sv (nmap)));
2421	PUSHs (sv_2mortal (newSViv (nx)));	2490	PUSHs (sv_2mortal (newSViv (nx)));
2422	PUSHs (sv_2mortal (newSViv (ny)));	2491	PUSHs (sv_2mortal (newSViv (ny)));
2423	}	2492	}
2424	}	2493	}
2425		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
2426	void	2515	void
2427	at (maptile *map, unsigned int x, unsigned int y)	2516	at (maptile *map, unsigned int x, unsigned int y)
2428	PROTOTYPE: $$$	2517	PROTOTYPE: $$$
2429	PPCODE:	2518	PPCODE:
2430	{	2519	{
2431	object *o;
2432	maptile *nmap = 0;	2520	maptile *nmap = 0;
2433	I16 nx, ny;	2521	I16 nx, ny;
2434		2522
		2523	PUTBACK;
2435	get_map_flags (map, &nmap, x, y, &nx, &ny);	2524	get_map_flags (map, &nmap, x, y, &nx, &ny);
		2525	SPAGAIN;
2436		2526
2437	if (nmap)	2527	if (nmap)
2438	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)
2439	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));	2529	XPUSHs (sv_2mortal (to_sv (o)));
2440	}	2530	}
2441		2531
2442	SV *	2532	SV *
2443	bot_at (maptile *obj, unsigned int x, unsigned int y)	2533	bot_at (maptile *map, unsigned int x, unsigned int y)
2444	PROTOTYPE: $$$	2534	PROTOTYPE: $$$
2445	ALIAS:	2535	ALIAS:
2446	top_at = 1	2536	top_at = 1
2447	flags_at = 2	2537	flags_at = 2
2448	light_at = 3	2538	light_at = 3
2449	move_block_at = 4	2539	move_block_at = 4
2450	move_slow_at = 5	2540	move_slow_at = 5
2451	move_on_at = 6	2541	move_on_at = 6
2452	move_off_at = 7	2542	move_off_at = 7
2453	INIT:
2454	if (x >= obj->width || y >= obj->height) XSRETURN_UNDEF;
2455	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
2456	switch (ix)	2555	switch (ix)
2457	{	2556	{
2458	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;	2557	case 0: RETVAL = to_sv (ms.bot ); break;
2459	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;	2558	case 1: RETVAL = to_sv (ms.top ); break;
2460	case 2: RETVAL = newSVuv ( GET_MAP_FLAGS (obj, x, y)); break;	2559	case 2: RETVAL = newSVuv (ms.flags_ ); break;
2461	case 3: RETVAL = newSViv ( GET_MAP_LIGHT (obj, x, y)); break;	2560	case 3: RETVAL = newSViv (ms.light ); break;
2462	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;	2561	case 4: RETVAL = newSVuv (ms.move_block); break;
2463	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;	2562	case 5: RETVAL = newSVuv (ms.move_slow ); break;
2464	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;	2563	case 6: RETVAL = newSVuv (ms.move_on ); break;
2465	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;	2564	case 7: RETVAL = newSVuv (ms.move_off ); break;
2466	}	2565	}
		2566	}
2467	OUTPUT: RETVAL	2567	OUTPUT: RETVAL
2468
2469	void fix_walls (maptile *map, int x, int y)
2470
2471	void fix_walls_around (maptile *map, int x, int y)
2472		2568
2473	# worst xs function of my life	2569	# worst xs function of my life
2474	bool	2570	bool
2475	_create_random_map (\	2571	_create_random_map (\
2476	maptile *self,\	2572	maptile *self,\
…		…
2480	utf8_string monsterstyle,\	2576	utf8_string monsterstyle,\
2481	utf8_string treasurestyle,\	2577	utf8_string treasurestyle,\
2482	utf8_string layoutstyle,\	2578	utf8_string layoutstyle,\
2483	utf8_string doorstyle,\	2579	utf8_string doorstyle,\
2484	utf8_string decorstyle,\	2580	utf8_string decorstyle,\
		2581	utf8_string miningstyle,\
2485	utf8_string origin_map,\	2582	utf8_string origin_map,\
2486	utf8_string final_map,\	2583	utf8_string final_map,\
2487	utf8_string exitstyle,\	2584	utf8_string exitstyle,\
2488	utf8_string this_map,\	2585	utf8_string this_map,\
2489	utf8_string exit_on_final_map,\	2586	utf8_string exit_on_final_map,\
…		…
2521	assign (rmp.monsterstyle , monsterstyle);	2618	assign (rmp.monsterstyle , monsterstyle);
2522	assign (rmp.treasurestyle , treasurestyle);	2619	assign (rmp.treasurestyle , treasurestyle);
2523	assign (rmp.layoutstyle , layoutstyle);	2620	assign (rmp.layoutstyle , layoutstyle);
2524	assign (rmp.doorstyle , doorstyle);	2621	assign (rmp.doorstyle , doorstyle);
2525	assign (rmp.decorstyle , decorstyle);	2622	assign (rmp.decorstyle , decorstyle);
		2623	assign (rmp.miningstyle , miningstyle);
2526	assign (rmp.exitstyle , exitstyle);	2624	assign (rmp.exitstyle , exitstyle);
2527	assign (rmp.exit_on_final_map, exit_on_final_map);	2625	assign (rmp.exit_on_final_map, exit_on_final_map);
2528		2626
2529	rmp.origin_map = origin_map;	2627	rmp.origin_map = origin_map;
2530	rmp.final_map = final_map;	2628	rmp.final_map = final_map;
…		…
2556	RETVAL = self->generate_random_map (&rmp);	2654	RETVAL = self->generate_random_map (&rmp);
2557	}	2655	}
2558	OUTPUT:	2656	OUTPUT:
2559	RETVAL	2657	RETVAL
2560		2658
		2659	MODULE = cf PACKAGE = cf::mapspace
		2660
		2661	INCLUDE: $PERL $srcdir/genacc mapspace $srcdir/../include/map.h |
		2662
2561	MODULE = cf PACKAGE = cf::arch	2663	MODULE = cf PACKAGE = cf::arch
2562		2664
2563	int archetypes_size ()	2665	int archetypes_size ()
2564	CODE:	2666	CODE:
2565	RETVAL = archetypes.size ();	2667	RETVAL = archetypes.size ();
…		…
2568	archetype *archetypes (U32 index)	2670	archetype *archetypes (U32 index)
2569	CODE:	2671	CODE:
2570	RETVAL = index < archetypes.size () ? archetypes [index] : 0;	2672	RETVAL = index < archetypes.size () ? archetypes [index] : 0;
2571	OUTPUT: RETVAL	2673	OUTPUT: RETVAL
2572		2674
2573	object *instantiate (archetype *arch)
2574	CODE:
2575	RETVAL = arch_to_object (arch);
2576	OUTPUT:
2577	RETVAL
2578
2579	INCLUDE: $PERL $srcdir/genacc archetype ../include/object.h |	2675	INCLUDE: $PERL $srcdir/genacc archetype $srcdir/../include/object.h |
2580		2676
2581	MODULE = cf PACKAGE = cf::party	2677	MODULE = cf PACKAGE = cf::party
2582		2678
2583	partylist *first ()	2679	partylist *first ()
2584	PROTOTYPE:	2680	PROTOTYPE:
2585	CODE:	2681	CODE:
2586	RETVAL = get_firstparty ();	2682	RETVAL = get_firstparty ();
2587	OUTPUT: RETVAL	2683	OUTPUT: RETVAL
2588		2684
2589	INCLUDE: $PERL $srcdir/genacc partylist ../include/player.h |	2685	INCLUDE: $PERL $srcdir/genacc partylist $srcdir/../include/player.h |
2590		2686
2591	MODULE = cf PACKAGE = cf::region	2687	MODULE = cf PACKAGE = cf::region
2592		2688
2593	void	2689	void
2594	list ()	2690	list ()
…		…
2600	PROTOTYPE: $	2696	PROTOTYPE: $
2601	CODE:	2697	CODE:
2602	RETVAL = region::find (name);	2698	RETVAL = region::find (name);
2603	OUTPUT: RETVAL	2699	OUTPUT: RETVAL
2604		2700
2605	region *find_fuzzy (utf8_string name)
2606	PROTOTYPE: $
2607	CODE:
2608	RETVAL = region::find_fuzzy (name);
2609	OUTPUT: RETVAL
2610
2611	int specificity (region *rgn)	2701	int specificity (region *rgn)
2612	CODE:	2702	CODE:
2613	RETVAL = 0;	2703	RETVAL = 0;
2614	while (rgn = rgn->parent)	2704	while (rgn = rgn->parent)
2615	RETVAL++;	2705	RETVAL++;
2616	OUTPUT: RETVAL	2706	OUTPUT: RETVAL
2617		2707
2618	INCLUDE: $PERL $srcdir/genacc region ../include/region.h |	2708	INCLUDE: $PERL $srcdir/genacc region $srcdir/../include/region.h |
2619		2709
2620	MODULE = cf PACKAGE = cf::living	2710	MODULE = cf PACKAGE = cf::living
2621		2711
2622	INCLUDE: $PERL $srcdir/genacc living ../include/living.h |	2712	INCLUDE: $PERL $srcdir/genacc living $srcdir/../include/living.h |
2623		2713
2624	MODULE = cf PACKAGE = cf::settings	2714	MODULE = cf PACKAGE = cf::settings
2625		2715
2626	INCLUDE: $PERL $srcdir/genacc Settings ../include/global.h |	2716	INCLUDE: $PERL $srcdir/genacc Settings $srcdir/../include/global.h |
2627		2717
2628	MODULE = cf PACKAGE = cf::client	2718	MODULE = cf PACKAGE = cf::client
2629		2719
2630	INCLUDE: $PERL $srcdir/genacc client ../include/client.h |	2720	INCLUDE: $PERL $srcdir/genacc client $srcdir/../include/client.h |
2631		2721
2632	int invoke (client *ns, int event, ...)	2722	int invoke (client *ns, int event, ...)
2633	CODE:	2723	CODE:
2634	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");
2635	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	2725	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
2651	CODE:	2741	CODE:
2652	{	2742	{
2653	STRLEN len;	2743	STRLEN len;
2654	char *buf = SvPVbyte (packet, len);	2744	char *buf = SvPVbyte (packet, len);
2655		2745
		2746	if (len > MAXSOCKBUF)
		2747	{
		2748	// ugly
		2749	if (THIS->pl)
		2750	THIS->pl->failmsg ("[packet too long for client]");
		2751	}
		2752	else
2656	THIS->send_packet (buf, len);	2753	THIS->send_packet (buf, len);
2657	}	2754	}
2658		2755
2659	faceidx	2756	faceidx
2660	client::need_face (utf8_string name, int pri = 0)	2757	client::need_face (utf8_string name, int pri = 0)
2661	CODE:	2758	CODE:
…		…
2694	extern faceidx old_sound_index [SOUND_CAST_SPELL_0];	2791	extern faceidx old_sound_index [SOUND_CAST_SPELL_0];
2695	old_sound_index [idx] = face;	2792	old_sound_index [idx] = face;
2696		2793
2697	MODULE = cf PACKAGE = cf::face PREFIX = face_	2794	MODULE = cf PACKAGE = cf::face PREFIX = face_
2698		2795
2699	#INCLUDE: $PERL $srcdir/genacc faceset ../include/face.h |	2796	#INCLUDE: $PERL $srcdir/genacc faceset $srcdir/../include/face.h |
2700		2797
2701	faceidx face_find (utf8_string name, faceidx defidx = 0)	2798	faceidx face_find (utf8_string name, faceidx defidx = 0)
2702		2799
2703	faceidx alloc (utf8_string name)	2800	faceidx alloc (utf8_string name)
2704	CODE:	2801	CODE:
…		…
2711	while (!RETVAL); // crude way to leave index 0	2808	while (!RETVAL); // crude way to leave index 0
2712		2809
2713	faces [RETVAL].name = name;	2810	faces [RETVAL].name = name;
2714	facehash.insert (std::make_pair (faces [RETVAL].name, RETVAL));	2811	facehash.insert (std::make_pair (faces [RETVAL].name, RETVAL));
2715		2812
2716	if (!strcmp (name, BLANK_FACE_NAME)) blank_face = RETVAL;	2813	if (!strcmp (name, BLANK_FACE_NAME )) blank_face = RETVAL;
2717	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;
2718	}	2816	}
2719	OUTPUT: RETVAL	2817	OUTPUT: RETVAL
2720		2818
2721	void set_type (faceidx idx, int value)	2819	void set_type (faceidx idx, int value)
2722	ALIAS:	2820	ALIAS:
…		…
2742	faceinfo *f = face_info (idx); assert (f);	2840	faceinfo *f = face_info (idx); assert (f);
2743	facedata *d = &(faceset ? f->data64 : f->data32);	2841	facedata *d = &(faceset ? f->data64 : f->data32);
2744	sv_to (data, d->data);	2842	sv_to (data, d->data);
2745	STRLEN clen;	2843	STRLEN clen;
2746	char *cdata = SvPVbyte (chksum, clen);	2844	char *cdata = SvPVbyte (chksum, clen);
2747	clen = min (CHKSUM_SIZE, clen);	2845	clen = min (CHKSUM_MAXLEN, clen);
2748		2846
		2847	assert (("cf::face::set_data must be called with a non-empty checksum", clen));
		2848
2749	if (memcmp (d->chksum, cdata, clen))	2849	if (clen != d->chksum_len || memcmp (d->chksum, cdata, clen))
2750	{	2850	{
		2851	d->chksum_len = clen;
2751	memcpy (d->chksum, cdata, clen);	2852	memcpy (d->chksum, cdata, clen);
2752		2853
2753	// invalidate existing client face info	2854	// invalidate existing client face info
2754	for_all_clients (ns)	2855	for_all_clients (ns)
2755	if (ns->faceset == faceset)	2856	if (ns->faceset == faceset)
…		…
2760	}	2861	}
2761	}	2862	}
2762		2863
2763	int get_data_size (faceidx idx, int faceset = 0)	2864	int get_data_size (faceidx idx, int faceset = 0)
2764	CODE:	2865	CODE:
2765	facedata *d = face_data (idx, faceset); assert (d);	2866	facedata *d = face_data (idx, faceset);
		2867	if (!d) XSRETURN_UNDEF;
2766	RETVAL = d->data.size ();	2868	RETVAL = d->data.size ();
2767	OUTPUT:	2869	OUTPUT:
2768	RETVAL	2870	RETVAL
2769		2871
2770	SV *get_chksum (faceidx idx, int faceset = 0)	2872	SV *get_chksum (faceidx idx, int faceset = 0)
2771	CODE:	2873	CODE:
2772	facedata *d = face_data (idx, faceset); assert (d);	2874	facedata *d = face_data (idx, faceset);
		2875	if (!d) XSRETURN_UNDEF;
2773	RETVAL = newSVpvn ((char *)d->chksum, CHKSUM_SIZE);	2876	RETVAL = newSVpvn ((char *)d->chksum, d->chksum_len);
		2877	OUTPUT:
		2878	RETVAL
		2879
		2880	SV *get_data (faceidx idx, int faceset = 0)
		2881	CODE:
		2882	facedata *d = face_data (idx, faceset);
		2883	if (!d) XSRETURN_UNDEF;
		2884	RETVAL = newSVpvn (d->data.data (), d->data.length ());
2774	OUTPUT:	2885	OUTPUT:
2775	RETVAL	2886	RETVAL
2776		2887
2777	void invalidate (faceidx idx)	2888	void invalidate (faceidx idx)
2778	CODE:	2889	CODE:
…		…
2790	ns->force_newmap = true;	2901	ns->force_newmap = true;
2791	}	2902	}
2792		2903
2793	MODULE = cf PACKAGE = cf::anim PREFIX = anim_	2904	MODULE = cf PACKAGE = cf::anim PREFIX = anim_
2794		2905
2795	#INCLUDE: $PERL $srcdir/genacc faceset ../include/anim.h |	2906	#INCLUDE: $PERL $srcdir/genacc faceset $srcdir/../include/anim.h |
2796		2907
2797	animidx anim_find (utf8_string name)	2908	animidx anim_find (utf8_string name)
2798	CODE:	2909	CODE:
2799	RETVAL = animation::find (name).number;	2910	RETVAL = animation::find (name).number;
2800	OUTPUT: RETVAL	2911	OUTPUT: RETVAL
…		…
2815	}	2926	}
2816	else	2927	else
2817	anim = &animation::create (name, av_len (av) + 1, facings);	2928	anim = &animation::create (name, av_len (av) + 1, facings);
2818		2929
2819	for (int i = 0; i < anim->num_animations; ++i)	2930	for (int i = 0; i < anim->num_animations; ++i)
2820	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)));
2821	}	2932	}
2822	OUTPUT: RETVAL	2933	OUTPUT: RETVAL
2823		2934
2824	void invalidate_all ()	2935	void invalidate_all ()
2825	CODE:	2936	CODE:
2826	for_all_clients (ns)	2937	for_all_clients (ns)
2827	ns->anims_sent.reset ();	2938	ns->anims_sent.reset ();
2828		2939
2829	MODULE = cf PACKAGE = cf::object::freezer	2940	MODULE = cf PACKAGE = cf::object::freezer
2830		2941
2831	INCLUDE: $PERL $srcdir/genacc object_freezer ../include/cfperl.h |	2942	INCLUDE: $PERL $srcdir/genacc object_freezer $srcdir/../include/cfperl.h |
2832		2943
2833	SV *	2944	SV *
2834	new (char *klass)	2945	new (char *klass)
2835	CODE:	2946	CODE:
2836	RETVAL = newSVptr (new object_freezer, gv_stashpv ("cf::object::freezer", 1));	2947	RETVAL = newSVptr (new object_freezer, gv_stashpv ("cf::object::freezer", 1));
…		…
2843	sv_to (sv, self);	2954	sv_to (sv, self);
2844	delete self;	2955	delete self;
2845		2956
2846	MODULE = cf PACKAGE = cf::object::thawer	2957	MODULE = cf PACKAGE = cf::object::thawer
2847		2958
2848	INCLUDE: $PERL $srcdir/genacc object_thawer ../include/cfperl.h |	2959	INCLUDE: $PERL $srcdir/genacc object_thawer $srcdir/../include/cfperl.h |
2849		2960
2850	SV *	2961	SV *
2851	new_from_file (char *klass, octet_string path)	2962	new_from_file (char *klass, octet_string path)
2852	CODE:	2963	CODE:
2853	object_thawer *f = new object_thawer (path);	2964	object_thawer *f = new object_thawer (path);
…		…
2864	CODE:	2975	CODE:
2865	object_thawer *self;	2976	object_thawer *self;
2866	sv_to (sv, self);	2977	sv_to (sv, self);
2867	delete self;	2978	delete self;
2868		2979
		2980	void
		2981	extract_tags (object_thawer *self)
		2982	PPCODE:
		2983	while (self->kw != KW_EOF)
		2984	{
		2985	PUTBACK;
		2986	coroapi::cede_to_tick ();
		2987	SPAGAIN;
		2988
		2989	if (self->kw == KW_tag)
		2990	XPUSHs (sv_2mortal (newSVpv_utf8 (self->get_str ())));
		2991
		2992	self->skip ();
		2993	}
		2994

Diff Legend

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