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

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.256 by root, Wed Sep 12 11:10:11 2007 UTC vs. Revision 1.369 by root, Wed Apr 14 02:31:24 2010 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.256 by root, Wed Sep 12 11:10:11 2007 UTC vs.
Revision 1.369 by root, Wed Apr 14 02:31:24 2010 UTC