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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.210 by root, Sat May 19 00:08:12 2007 UTC vs.
Revision 1.371 by root, Thu Apr 15 02:51:39 2010 UTC

…		…
1	/*	1	/*
2	* CrossFire, A Multiplayer game	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* This code is placed under the GNU General Public Licence (GPL)	4	* Copyright (©) 2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	*	5	*
6	* Copyright (C) 2001-2005 by Chachkoff Yann
7	* Copyright (C) 2006,2007 by Marc Lehmann <cf@schmorp.de>
8	*
9	* This program is free software; you can redistribute it and/or modify	6	* Deliantra is free software: you can redistribute it and/or modify it under
10	* 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
11	* the Free Software Foundation; either version 2 of the License, or	8	* Free Software Foundation, either version 3 of the License, or (at your
12	* (at your option) any later version.	9	* option) any later version.
13	*	10	*
14	* 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,
15	* but WITHOUT ANY WARRANTY; without even the implied warranty of	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	* GNU General Public License for more details.	14	* GNU General Public License for more details.
18	*	15	*
19	* 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
20	* along with this program; if not, write to the Free Software	17	* and the GNU General Public License along with this program. If not, see
21	* Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA	18	* <http://www.gnu.org/licenses/>.
		19	*
		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"
54	#include "perlxsi.c"	55	#include "perlxsi.c"
55		56
56	extern sint64 *levels; // the experience table	57	extern sint64 *levels; // the experience table
57		58
58	typedef object object_ornull;	59	typedef object_thawer &object_thawer_ref;
59	typedef maptile maptile_ornull;	60	typedef object_freezer &object_freezer_ref;
60
61	typedef char *octet_string;
62	typedef char *utf8_string;
63	typedef const char *const_octet_string;
64	typedef const char *const_utf8_string;
65		61
66	typedef std::string std__string;	62	typedef std::string std__string;
67		63
68	#if IVSIZE >= 8
69	typedef IV val64;
70	# define newSVval64 newSViv
71	# define SvVAL64 SvIV
72	#else
73	typedef double val64;
74	# define newSVval64 newSVnv
75	# define SvVAL64 SvNV
76	#endif
77
78	static f_plug_api gethook = cfapi_get_hooks;
79	static f_plug_api object_set_property = cfapi_object_set_property;
80	static f_plug_api object_insert = cfapi_object_insert;
81
82	static PerlInterpreter *perl;	64	static PerlInterpreter *perl;
83		65
84	double runtime;	66	tstamp NOW, runtime;
		67
		68	static int tick_inhibit;
		69	static int tick_pending;
85		70
86	global gbl_ev;	71	global gbl_ev;
87	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;
88	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;
89		75
90	bitset<NUM_EVENT_TYPES> ev_want_event;	76	bitset<NUM_EVENT_TYPES> ev_want_event;
91	bitset<NUM_TYPES> ev_want_type;	77	bitset<NUM_TYPES> ev_want_type;
92		78
93	static HV	79	static HV
94	*stash_cf,	80	*stash_cf,
95	*stash_cf_object_wrap,	81	*stash_cf_object_wrap,
96	*stash_cf_object_player_wrap,	82	*stash_cf_object_player_wrap,
97	*stash_cf_player_wrap,	83	*stash_cf_player_wrap,
98	*stash_cf_map_wrap,	84	*stash_cf_map_wrap,
		85	*stash_cf_mapspace_wrap,
99	*stash_cf_client_wrap,	86	*stash_cf_client_wrap,
100	*stash_cf_arch_wrap,	87	*stash_cf_arch_wrap,
101	*stash_cf_party_wrap,	88	*stash_cf_party_wrap,
102	*stash_cf_region_wrap,	89	*stash_cf_region_wrap,
103	*stash_cf_living_wrap;	90	*stash_cf_living_wrap;
		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
		100	static SV *
		101	newSVpv_utf8 (const char *s)
		102	{
		103	if (!s)
		104	return newSV (0);
		105
		106	SV *sv = newSVpv (s, 0);
		107	SvUTF8_on (sv);
		108	return sv;
		109	}
		110	#endif
		111
		112	#ifndef newSVpvn_utf8
		113	static SV *
		114	newSVpvn_utf8 (const char *s, STRLEN l, int utf8)
		115	{
		116	if (!s)
		117	return newSV (0);
		118
		119	SV *sv = newSVpvn (s, l);
		120
		121	if (utf8)
		122	SvUTF8_on (sv);
		123
		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);
		142	}
104		143
105	// helper cast function, returns super class * or 0	144	// helper cast function, returns super class * or 0
106	template<class super>	145	template<class super>
107	static super *	146	static super *
108	is_a (attachable *at)	147	is_a (attachable *at)
141	SvREFCNT_inc (self);	180	SvREFCNT_inc (self);
142	hv_clear (self);	181	hv_clear (self);
143	sv_unmagic ((SV *)self, PERL_MAGIC_ext);	182	sv_unmagic ((SV *)self, PERL_MAGIC_ext);
144	SvREFCNT_dec (self);	183	SvREFCNT_dec (self);
145		184
146	// self must be null now because thats sv_unmagic's job.	185	// self must be null now because that's sv_unmagic's job.
147	assert (!this->self);	186	assert (!this->self);
148	}	187	}
149	}	188	}
150		189
151	void	190	void
…		…
168	}	207	}
169		208
170	void	209	void
171	attachable::do_destroy ()	210	attachable::do_destroy ()
172	{	211	{
173	invoke (EVENT_ATTACHABLE_DESTROY, DT_END);	212	INVOKE_ATTACHABLE (DESTROY, this);
174		213
175	if (cb)	214	if (cb)
176	{	215	{
177	SvREFCNT_dec (cb);	216	SvREFCNT_dec (cb);
178	cb = 0;	217	cb = 0;
…		…
185	attachable::destroy ()	224	attachable::destroy ()
186	{	225	{
187	if (destroyed ())	226	if (destroyed ())
188	return;	227	return;
189		228
190	flags \|= F_DESTROYED;	229	attachable_flags \|= F_DESTROYED;
191	do_destroy ();	230	do_destroy ();
192	sever_self ();	231	sever_self ();
		232	}
		233
		234	void
		235	attachable::do_delete ()
		236	{
		237	delete this;
193	}	238	}
194		239
195	void	240	void
196	attachable::check_mortals ()	241	attachable::check_mortals ()
197	{	242	{
…		…
201	{	246	{
202	if (i >= mortals.size ())	247	if (i >= mortals.size ())
203	{	248	{
204	i = 0;	249	i = 0;
205		250
206	if (mortals.size () > 1000)	251	if (mortals.size () >= 512)
		252	{
		253	static int last_mortalcount;
		254	if (mortals.size () != last_mortalcount)
		255	{
		256	last_mortalcount = mortals.size ();
207	LOG (llevInfo, "mortal queue size (%d) exceeds 1000.\n", (int)mortals.size ());	257	LOG (llevInfo, "%d mortals.\n", (int)mortals.size ());
		258
		259	if (0)
		260	{
		261	for (int j = 0; j < mortals.size (); ++j)//D
		262	fprintf (stderr, "%d:%s %p ", j, &((object *)mortals[j])->name, mortals[j]);//D
		263
		264	fprintf (stderr, "\n");//D
		265	}
		266	}
		267	}
208		268
209	break;	269	break;
210	}	270	}
211		271
212	attachable *obj = mortals [i];	272	attachable *obj = mortals [i];
…		…
228	}	288	}
229	else	289	else
230	{	290	{
231	mortals.erase (i);	291	mortals.erase (i);
232	obj->sever_self ();	292	obj->sever_self ();
233	delete obj;	293	obj->do_delete ();
234	}	294	}
235	}	295	}
236	}	296	}
237		297
		298	void
		299	attachable::set_key (const char key, const char value, bool is_utf8)
		300	{
		301	if (!self)
		302	self = newHV ();
		303
		304	if (value)
		305	hv_store (self, key, strlen (key), is_utf8 ? newSVpv_utf8 (value) : newSVpv (value, 0), 0);
		306	else
		307	hv_delete (self, key, strlen (key), G_DISCARD);
		308	}
		309
238	attachable &	310	attachable &
239	attachable::operator =(const attachable &src)	311	attachable::operator =(const attachable &src)
240	{	312	{
241	//if (self \|\| cb)	313	//if (self \|\| cb)
242	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));	314	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));
243		315
244	attach = src.attach;	316	attach = src.attach;
245	return *this;	317	return *this;
246	}	318	}
247		319
		320	#if 0
		321	template<typename T>
		322	static bool
		323	find_backref (void ptr, T obj)
		324	{
		325	char s = (char )obj;
		326	while (s < (char *)obj + sizeof (T))
		327	{
		328	if (ptr == (void *)s)
		329	return true;
		330
		331	s += sizeof (void *); // assume natural alignment
		332	}
		333
		334	return false;
		335	}
		336
		337	// for debugging, find "live" objects containing this ptr
		338	static void
		339	find_backref (void *ptr)
		340	{
		341	for_all_objects (op)
		342	if (find_backref (ptr, op))
		343	fprintf (stderr, "O %p %d:'%s'\n", op, op->count, &op->name);
		344
		345	for_all_players (pl)
		346	if (find_backref (ptr, pl))
		347	fprintf (stderr, "P %p\n", pl);
		348
		349	for_all_clients (ns)
		350	if (find_backref (ptr, ns))
		351	fprintf (stderr, "C %p\n", ns);
		352	}
		353	#endif
		354
248	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	355	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
249		356
250	static SV *	357	static SV *
251	newSVptr (void ptr, HV stash, HV *hv = newHV ())	358	newSVptr (void ptr, HV stash, HV *hv = newHV ())
252	{	359	{
253	SV *sv;	360	SV *sv;
254		361
255	if (!ptr)	362	if (!ptr)
256	return &PL_sv_undef;	363	return newSV (0);
257		364
258	sv_magicext ((SV )hv, 0, PERL_MAGIC_ext, 0, (char )ptr, 0);	365	sv_magicext ((SV )hv, 0, PERL_MAGIC_ext, 0, (char )ptr, 0);
259	return sv_bless (newRV_noinc ((SV *)hv), stash);	366	return sv_bless (newRV_noinc ((SV *)hv), stash);
260	}	367	}
261		368
…		…
280		387
281	static SV *	388	static SV *
282	newSVattachable (attachable obj, HV stash)	389	newSVattachable (attachable obj, HV stash)
283	{	390	{
284	if (!obj)	391	if (!obj)
285	return &PL_sv_undef;	392	return newSV (0);
286		393
287	if (!obj->self)	394	if (!obj->self)
		395	obj->self = newHV ();
		396
		397	if (!SvOBJECT (obj->self))
288	{	398	{
289	obj->self = newHV ();
290	sv_magicext ((SV )obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char )obj, 0);	399	sv_magicext ((SV )obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char )obj, 0);
291		400
292	// now bless the object _once_	401	// now bless the object _once_
		402	//TODO: create a class registry with c++ type<=>perl name<=>stash and use it here and elsewhere
293	return sv_bless (newRV_inc ((SV *)obj->self), stash);	403	return sv_bless (newRV_inc ((SV *)obj->self), stash);
294	}	404	}
295	else	405	else
296	{	406	{
297	SV sv = newRV_inc ((SV )obj->self);	407	SV sv = newRV_inc ((SV )obj->self);
…		…
301		411
302	return sv;	412	return sv;
303	}	413	}
304	}	414	}
305		415
		416	#if 0 // unused
306	static void	417	static void
307	clearSVptr (SV *sv)	418	clearSVptr (SV *sv)
308	{	419	{
309	if (SvROK (sv))	420	if (SvROK (sv))
310	sv = SvRV (sv);	421	sv = SvRV (sv);
311		422
312	hv_clear ((HV *)sv);	423	hv_clear ((HV *)sv);
313	sv_unmagic (sv, PERL_MAGIC_ext);	424	sv_unmagic (sv, PERL_MAGIC_ext);
314	}	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	}
315		442
316	static long	443	static long
317	SvPTR (SV sv, const char klass)	444	SvPTR (SV sv, const char klass)
318	{	445	{
319	if (!sv_derived_from (sv, klass))	446	if (!sv_derived_from (sv, klass))
320	croak ("object of type %s expected", klass);	447	croak ("object of type %s expected", klass);
321		448
322	MAGIC *mg = mg_find (SvRV (sv), PERL_MAGIC_ext);	449	return SvPTR_nc (sv);
323
324	if (!mg)
325	croak ("perl code used %s object, but C object is already destroyed, caught", klass);
326
327	return (long)mg->mg_ptr;
328	}	450	}
329		451
330	static long	452	static long noinline
331	SvPTR_ornull (SV sv, const char klass)	453	SvPTR_ornull (SV sv, const char klass)
332	{	454	{
333	if (SvOK (sv))	455	if (expect_false (!SvOK (sv))) return 0;
		456
334	return SvPTR (sv, klass);	457	return SvPTR (sv, klass);
335	else
336	return 0;
337	}	458	}
338		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
339	inline SV to_sv (const shstr & v) { return v ? newSVpvn ((const char )v, v.length ()) : &PL_sv_undef; }	501	static inline SV to_sv (const shstr & v) { return newSVpvn_utf8 ((const char )v, v.length (), 1); }
340	inline SV to_sv (const char v) { return newSVpv (v, 0); }	502	static inline SV to_sv (const char v) { return v ? newSVpv (v, 0) : newSV (0); }
341	inline SV *to_sv (bool v) { return newSViv (v); }	503	static inline SV *to_sv (bool v) { return newSViv (v); }
342	inline SV *to_sv ( signed char v) { return newSViv (v); }	504	static inline SV *to_sv ( signed char v) { return newSViv (v); }
343	inline SV *to_sv (unsigned char v) { return newSViv (v); }	505	static inline SV *to_sv (unsigned char v) { return newSViv (v); }
344	inline SV *to_sv ( signed short v) { return newSViv (v); }	506	static inline SV *to_sv ( signed short v) { return newSViv (v); }
345	inline SV *to_sv (unsigned short v) { return newSVuv (v); }	507	static inline SV *to_sv (unsigned short v) { return newSVuv (v); }
346	inline SV *to_sv ( signed int v) { return newSViv (v); }	508	static inline SV *to_sv ( signed int v) { return newSViv (v); }
347	inline SV *to_sv (unsigned int v) { return newSVuv (v); }	509	static inline SV *to_sv (unsigned int v) { return newSVuv (v); }
348	inline SV *to_sv ( signed long v) { return newSViv (v); }	510	static inline SV *to_sv ( signed long v) { return newSViv (v); }
349	inline SV *to_sv (unsigned long v) { return newSVuv (v); }	511	static inline SV *to_sv (unsigned long v) { return newSVuv (v); }
350	inline SV *to_sv ( signed long long v) { return newSVval64 (v); }	512	static inline SV *to_sv ( signed long long v) { return newSVval64 (v); }
351	inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }	513	static inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }
352	inline SV *to_sv (float v) { return newSVnv (v); }	514	static inline SV *to_sv (float v) { return newSVnv (v); }
353	inline SV *to_sv (double v) { return newSVnv (v); }	515	static inline SV *to_sv (double v) { return newSVnv (v); }
354	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); }
355	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); }
356	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); }
357	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); }
358	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); }
		521	static inline SV to_sv (region v) { return newSVattachable (v, stash_cf_region_wrap); }
359	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); }
360	inline SV to_sv (region v) { return newSVptr (v, stash_cf_region_wrap); }
361	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); }
362		525
363	inline SV *to_sv (object & v) { return to_sv (&v); }	526	static inline SV *to_sv (object & v) { return to_sv (&v); }
364	inline SV *to_sv (living & v) { return to_sv (&v); }	527	static inline SV *to_sv (living & v) { return to_sv (&v); }
365		528
366	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 ()); }
367	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); }
368		531
369	inline SV *to_sv (UUID v)	532	static inline SV *to_sv (UUID v) { return newSVpv (v.c_str (), 0); }
370	{
371	char buf[128];
372	snprintf (buf, 128, "<1.%" PRIx64 ">", v.seq);
373	return newSVpv (buf, 0);
374	}
375		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
376	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPV_nolen (sv) : 0; }	555	static inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? cfSvPVutf8_nolen (sv) : 0; }
377	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; }
378	inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }	557	static inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }
379	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); }
380	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); }
381	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); }
382	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); }
383	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); }
384	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); }
385	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); }
386	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); }
387	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); }
388	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); }
389	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }	568	static inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
390	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }	569	static inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }
391	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); }
392	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); }
393	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); }
394	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"); }
395	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"); }
		575	static inline void sv_to (SV sv, region &v) { v = (region ) (attachable )SvPTR_ornull (sv, "cf::region"); }
396	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"); }
397	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"); }
398	inline void sv_to (SV sv, region &v) { v = (region *)SvPTR_ornull (sv, "cf::region"); }
399	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"); }
		580	static inline void sv_to (SV sv, object_freezer &v) { v = (object_freezer *) SvPTR_ornull (sv, "cf::object::freezer"); }
		581	static inline void sv_to (SV sv, object_thawer &v) { v = (object_thawer *) SvPTR_ornull (sv, "cf::object::thawer" ); }
400		582
401	//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)]; }
402	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)); }
403		585
404	template<class T>	586	template<class T>
405	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; }
406		588
407	template<int N>	589	template<int N>
408	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)); }
409		591
410	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); }
411	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); }
412	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); }
413	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); }
414		596
415	inline void sv_to (SV *sv, std::string &v)	597	static inline void sv_to (SV *sv, std::string &v)
416	{	598	{
417	STRLEN len;	599	STRLEN len;
418	char *data = SvPVbyte (sv, len);	600	char *data = SvPVbyte (sv, len);
419	v.assign (data, len);	601	v.assign (data, len);
420	}	602	}
421		603
422	inline void sv_to (SV *sv, UUID &v)	604	static inline void sv_to (SV *sv, UUID &v)
423	{	605	{
424	unsigned int version;	606	if (!v.parse (SvPV_nolen (sv)))
425
426	if (2 != sscanf (SvPV_nolen (sv), "<%d.%" SCNx64 ">", &version, &v.seq) \|\| 1 != version)
427	croak ("unparsable uuid: %s", SvPV_nolen (sv));	607	croak ("unparsable uuid: %s", SvPV_nolen (sv));
428	}	608	}
429		609
430	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); }
431		611
432	static SV *	612	static SV *
433	newSVdt_va (va_list &ap, data_type type)	613	newSVdt_va (va_list &ap, data_type type)
434	{	614	{
435	SV *sv;	615	SV *sv;
…		…
449	break;	629	break;
450		630
451	case DT_STRING:	631	case DT_STRING:
452	{	632	{
453	char str = (char )va_arg (ap, const char *);	633	char str = (char )va_arg (ap, const char *);
454	sv = str ? newSVpv (str, 0) : &PL_sv_undef;	634	sv = str ? newSVpv (str, 0) : newSV (0);
455	}	635	}
456	break;	636	break;
457		637
458	case DT_DATA:	638	case DT_DATA:
459	{	639	{
460	char str = (char )va_arg (ap, const void *);	640	char str = (char )va_arg (ap, const void *);
461	int len = va_arg (ap, int);	641	int len = va_arg (ap, int);
462	sv = str ? newSVpv (str, len) : &PL_sv_undef;	642	sv = str ? newSVpv (str, len) : newSV (0);
463	}	643	}
464	break;	644	break;
465		645
466	case DT_OBJECT:	646	case DT_OBJECT:
467	sv = to_sv (va_arg (ap, object *));	647	sv = to_sv (va_arg (ap, object *));
…		…
509	va_end (ap);	689	va_end (ap);
510		690
511	return sv;	691	return sv;
512	}	692	}
513		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
514	static SV *	720	static SV *
515	newSVcfapi (int type, ...)
516	{
517	SV *sv;
518
519	va_list ap;
520	va_start (ap, type);
521
522	switch (type)
523	{
524	case CFAPI_INT: sv = newSViv (va_arg (ap, int )); break;
525	case CFAPI_LONG: sv = newSVval64 (va_arg (ap, sint64 )); break;
526	case CFAPI_DOUBLE: sv = newSVnv (va_arg (ap, double )); break;
527	case CFAPI_STRING: sv = newSVdt_va (ap, DT_STRING); break;
528	case CFAPI_POBJECT: sv = newSVdt_va (ap, DT_OBJECT); break;
529	case CFAPI_PMAP: sv = newSVdt_va (ap, DT_MAP ); break;
530	case CFAPI_PPLAYER: sv = newSVdt_va (ap, DT_PLAYER); break;
531	case CFAPI_PARCH: sv = newSVdt_va (ap, DT_ARCH ); break;
532	case CFAPI_PPARTY: sv = newSVdt_va (ap, DT_PARTY ); break;
533	case CFAPI_PREGION: sv = newSVdt_va (ap, DT_REGION); break;
534
535	default:
536	assert (("unhandled type in newSVcfapi", 0));
537	}
538
539	va_end (ap);
540
541	return sv;
542	}
543
544	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
545
546	SV *
547	registry (attachable *ext)	721	registry (attachable *ext)
548	{	722	{
549	if (!ext->cb)	723	if (!ext->cb)
550	ext->cb = newAV ();	724	ext->cb = newAV ();
551		725
552	return newRV_inc ((SV *)ext->cb);	726	return newRV_inc ((SV *)ext->cb);
553	}	727	}
554		728
555	/////////////////////////////////////////////////////////////////////////////	729	/////////////////////////////////////////////////////////////////////////////
556		730
557	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
558	{
559	return 0;
560	}
561
562	static CommArray_s rtn_cmd;
563
564	static int
565	runPluginCommand (object obj, char params)
566	{
567	return -1;
568	}
569
570	extern "C" void cfperl_getPluginProperty (int type, ...)
571	{
572	va_list args;
573	char *propname;
574	int i;
575	va_start (args, type);
576	propname = va_arg (args, char *);
577	//printf ("Property name: %s\n", propname);
578
579	if (!strcmp (propname, "command?"))
580	return NULL;
581	else if (!strcmp (propname, "Identification"))
582	{
583	va_end (args);
584	return (void *)PLUGIN_NAME;
585	}
586	else if (!strcmp (propname, "FullName"))
587	{
588	va_end (args);
589	return (void *)PLUGIN_VERSION;
590	}
591	else
592	va_end (args);
593
594	return NULL;
595	}
596
597	extern "C" int cfperl_postInitPlugin ()
598	{
599	int hooktype = 1;
600	int rtype = 0;
601
602	cf_init_plugin (gethook);
603
604	return 0;
605	}
606
607	extern "C" int cfperl_closePlugin ()
608	{
609	return 0;
610	}
611
612	void	731	void
613	cfperl_init ()	732	cfperl_init ()
614	{	733	{
		734	extern char **environ;
		735
615	PERL_SYS_INIT3 (&settings.argc, &settings.argv, 0);	736	PERL_SYS_INIT3 (&settings.argc, &settings.argv, &environ);
616	perl = perl_alloc ();	737	perl = perl_alloc ();
617	perl_construct (perl);	738	perl_construct (perl);
618		739
619	PL_exit_flags \|= PERL_EXIT_DESTRUCT_END;	740	PL_exit_flags \|= PERL_EXIT_DESTRUCT_END;
620		741
621	const char *argv[] = {	742	const char *argv[] = {
622	settings.argv [0],	743	settings.argv [0],
623	"-e"	744	"-e0"
624	"use Event; use Coro;" // required for bootstrap
625	"cf->bootstrap;" // required for datadir :*>
626	"unshift @INC, cf::datadir ();"
627	"require cf;"
628	};	745	};
629		746
630	if (perl_parse (perl, xs_init, 2, (char )argv, (char )NULL)	747	if (perl_parse (perl, xs_init, 2, (char **)argv, environ)
631	\|\| perl_run (perl))	748	\|\| perl_run (perl))
632	{	749	{
633	printf ("unable to initialize perl-interpreter, aborting.\n");	750	printf ("unable to initialize perl-interpreter, aborting.\n");
634	exit (EXIT_FAILURE);	751	exit (EXIT_FAILURE);
635	}	752	}
636		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))
637	{	765	{
638	dSP;	766	printf ("unable to bootstrap perl, aborting:\n%s", SvPV_nolen (ERRSV));
639		767	exit (EXIT_FAILURE);
640	PUSHMARK (SP);
641	PUTBACK;
642	call_pv ("cf::init", G_DISCARD \| G_VOID);
643	}	768	}
644	}	769	}
645		770
		771	void
646	void cfperl_main ()	772	cfperl_main ()
647	{	773	{
648	dSP;	774	dSP;
649		775
650	PUSHMARK (SP);	776	PUSHMARK (SP);
651	PUTBACK;	777	PUTBACK;
…		…
655	void	781	void
656	attachable::instantiate ()	782	attachable::instantiate ()
657	{	783	{
658	if (attach)	784	if (attach)
659	{	785	{
660	invoke (EVENT_ATTACHABLE_INSTANTIATE, ARG_STRING (attach), DT_END);	786	INVOKE_ATTACHABLE (INSTANTIATE, this, ARG_STRING (attach));
661	attach = 0;	787	attach = 0;
662	}	788	}
663	}	789	}
664		790
665	void	791	void
666	attachable::reattach ()	792	attachable::reattach ()
667	{	793	{
668	optimise ();	794	optimise ();
669	//TODO: check for _attachment's, very important for restarts	795	//TODO: check for _attachment's, very important for restarts
670	invoke (EVENT_ATTACHABLE_REATTACH, DT_END);	796	INVOKE_ATTACHABLE (REATTACH, this);
671	}	797	}
672		798
673	static event_klass klass_of[NUM_EVENT_TYPES] = {	799	static event_klass klass_of[NUM_EVENT_TYPES] = {
674	# define def(type,name) KLASS_ ## type,	800	# define def(type,name) KLASS_ ## type,
675	# include "eventinc.h"	801	# include "eventinc.h"
676	# undef def	802	# undef def
677	};	803	};
678		804
679	#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)
680		806
681	static void	807	static void noinline
682	gather_callbacks (AV &callbacks, AV registry, event_type event)	808	gather_callbacks (AV &callbacks, AV registry, event_type event)
683	{	809	{
684	// event must be in array	810	// event must be in array
685	if (event >= 0 && event <= AvFILLp (registry))	811	if (event >= 0 && event <= AvFILLp (registry))
686	{	812	{
…		…
772	{	898	{
773	attachable::gather_callbacks (callbacks, event);	899	attachable::gather_callbacks (callbacks, event);
774	::gather_callbacks (callbacks, cb_map, event);	900	::gather_callbacks (callbacks, cb_map, event);
775	}	901	}
776		902
777	void	903	static void noinline
778	_recalc_want (bitset<NUM_EVENT_TYPES> &set, AV *registry)	904	_recalc_want (bitset<NUM_EVENT_TYPES> &set, AV *registry)
779	{	905	{
780	for (int event = 0; event <= AvFILLp (registry); ++event)	906	for (int event = 0; event <= AvFILLp (registry); ++event)
781	{	907	{
782	SV *cbs_ = AvARRAY (registry)[event];	908	SV *cbs_ = AvARRAY (registry)[event];
…		…
792	}	918	}
793	}	919	}
794	}	920	}
795		921
796	// very slow and inefficient way to recalculate the global want bitsets	922	// very slow and inefficient way to recalculate the global want bitsets
797	void	923	static void
798	_recalc_want ()	924	_recalc_want ()
799	{	925	{
800	ev_want_event.reset ();	926	ev_want_event.reset ();
801		927
802	_recalc_want (ev_want_event, cb_global);	928	_recalc_want (ev_want_event, cb_global);
…		…
823	}	949	}
824	}	950	}
825	}	951	}
826		952
827	bool	953	bool
828	attachable::vinvoke (event_type event, va_list &ap)	954	attachable::invoke (event_type event, ...)
829	{	955	{
830	data_type dt;	956	data_type dt;
831		957
832	// callback call ordering should be:	958	// callback call ordering should be:
833	// 1. per-object callback	959	// 1. per-object callback
…		…
839	gather_callbacks (callbacks, event);	965	gather_callbacks (callbacks, event);
840		966
841	// short-circuit processing if no callbacks found/defined	967	// short-circuit processing if no callbacks found/defined
842	if (!callbacks)	968	if (!callbacks)
843	return 0;	969	return 0;
		970
		971	va_list ap;
		972	va_start (ap, event);
844		973
845	CALL_BEGIN (3);	974	CALL_BEGIN (3);
846	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays	975	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays
847	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));	976	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));
848		977
…		…
872	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));	1001	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
873	}	1002	}
874		1003
875	va_end (ap);	1004	va_end (ap);
876		1005
877	CALL_CALL ("cf::do_invoke", G_SCALAR);	1006	CALL_CALL (cv_cf_do_invoke, G_SCALAR);
878	count = count > 0 ? POPi : 0;	1007	count = count > 0 ? POPi : 0;
879		1008
880	CALL_END;	1009	CALL_END;
881		1010
882	return count;	1011	return count;
883	}	1012	}
884		1013
885	SV *	1014	static SV *
886	cfperl_result (int idx)	1015	cfperl_result (int idx)
887	{	1016	{
888	AV *av = get_av ("cfperl::invoke_results", 0);	1017	AV *av = get_av ("cf::INVOKE_RESULTS", 0);
889	if (!av)	1018	if (!av)
890	return &PL_sv_undef;	1019	return &PL_sv_undef;
891		1020
892	SV **sv = av_fetch (av, idx, 0);	1021	SV **sv = av_fetch (av, idx, 0);
893	if (!sv)	1022	if (!sv)
…		…
907	{	1036	{
908	return SvNV (cfperl_result (idx));	1037	return SvNV (cfperl_result (idx));
909	}	1038	}
910		1039
911	/////////////////////////////////////////////////////////////////////////////	1040	/////////////////////////////////////////////////////////////////////////////
		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	}
912		1061
913	void	1062	void
914	cfperl_emergency_save ()	1063	cfperl_emergency_save ()
915	{	1064	{
916	CALL_BEGIN (0);	1065	CALL_BEGIN (0);
…		…
925	CALL_ARG (make_core);	1074	CALL_ARG (make_core);
926	CALL_CALL ("cf::post_cleanup", G_VOID);	1075	CALL_CALL ("cf::post_cleanup", G_VOID);
927	CALL_END;	1076	CALL_END;
928	}	1077	}
929		1078
		1079	void
		1080	cfperl_make_book (object *book, int level)
		1081	{
		1082	CALL_BEGIN (2);
		1083	CALL_ARG (book);
		1084	CALL_ARG (level);
		1085	CALL_CALL ("ext::books::make_book", G_VOID);
		1086	CALL_END;
		1087	}
		1088
		1089	void
		1090	cfperl_send_msg (client *ns, int color, const_utf8_string type, const_utf8_string msg)
		1091	{
		1092	CALL_BEGIN (4);
		1093	CALL_ARG (ns);
		1094	CALL_ARG (type);
		1095	CALL_ARG_SV (newSVpv_utf8 (msg));
		1096	CALL_ARG (color);
		1097	CALL_CALL (cv_cf_client_send_msg, G_VOID);
		1098	CALL_END;
		1099	}
		1100
		1101	int
		1102	cfperl_can_merge (object ob1, object ob2)
		1103	{
		1104	int can;
		1105
		1106	CALL_BEGIN (2);
		1107	CALL_ARG (ob1);
		1108	CALL_ARG (ob2);
		1109	CALL_CALL (cv_cf__can_merge, G_SCALAR);
		1110	can = count && SvTRUE (TOPs);
		1111	CALL_END;
		1112
		1113	return can;
		1114	}
		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
		1128	player *
		1129	player::find (const_utf8_string name)
		1130	{
		1131	CALL_BEGIN (1);
		1132	CALL_ARG (name);
		1133	CALL_CALL ("cf::player::find", G_SCALAR);
		1134
		1135	player *retval = 0;
		1136	if (count) sv_to (POPs, retval);
		1137
		1138	CALL_END;
		1139
		1140	return retval;
		1141	}
		1142
930	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 *
931	maptile::find_sync (const char path, maptile origin)	1162	maptile::find_sync (const_utf8_string path, maptile *origin)
932	{	1163	{
933	CALL_BEGIN (2);	1164	CALL_BEGIN (2);
934	CALL_ARG (path);	1165	CALL_ARG (path);
935	CALL_ARG (origin);	1166	CALL_ARG (origin);
936	CALL_CALL ("cf::map::find_sync", G_SCALAR);	1167	CALL_CALL ("cf::map::find_sync", G_SCALAR);
937		1168
938	maptile *retval;	1169	maptile *retval = 0;
939
940	if (count)
941	sv_to (POPs, retval);	1170	if (count) sv_to (POPs, retval);
942	else
943	retval = 0;
944		1171
945	CALL_END;	1172	CALL_END;
946		1173
947	return retval;	1174	return retval;
948	}	1175	}
949		1176
950	maptile *	1177	maptile *
951	maptile::find_async (const char path, maptile origin)	1178	maptile::find_async (const_utf8_string path, maptile *origin, bool load)
952	{	1179	{
953	CALL_BEGIN (2);	1180	CALL_BEGIN (3);
954	CALL_ARG (path);	1181	CALL_ARG (path);
955	CALL_ARG (origin);	1182	CALL_ARG (origin);
		1183	CALL_ARG (load);
956	CALL_CALL ("cf::map::find_async", G_SCALAR);	1184	CALL_CALL ("cf::map::find_async", G_SCALAR);
957		1185
958	maptile *retval;	1186	maptile *retval = 0;
959
960	if (count)
961	sv_to (POPs, retval);	1187	if (count) sv_to (POPs, retval);
962	else
963	retval = 0;
964		1188
965	CALL_END;	1189	CALL_END;
966		1190
967	return retval;	1191	return retval;
968	}	1192	}
…		…
971	maptile::do_load_sync ()	1195	maptile::do_load_sync ()
972	{	1196	{
973	CALL_BEGIN (1);	1197	CALL_BEGIN (1);
974	CALL_ARG (this);	1198	CALL_ARG (this);
975	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);	1199	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);
976	CALL_END;
977	}
978
979	void
980	maptile::change_all_map_light (int change)
981	{
982	CALL_BEGIN (1);
983	CALL_ARG (change);
984	CALL_CALL ("cf::map::change_all_map_light", G_VOID);
985	CALL_END;	1200	CALL_END;
986	}	1201	}
987		1202
988	void	1203	void
989	object::enter_exit (object *exit)	1204	object::enter_exit (object *exit)
…		…
997	CALL_CALL ("cf::object::player::enter_exit", G_VOID);	1212	CALL_CALL ("cf::object::player::enter_exit", G_VOID);
998	CALL_END;	1213	CALL_END;
999	}	1214	}
1000		1215
1001	void	1216	void
1002	log_backtrace (const char *msg)	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
		1232	object::ref () const
		1233	{
		1234	if (type == PLAYER)
		1235	return format ("player/<1.%llx>/%s", (unsigned long long)uuid.seq, &name);
		1236	else
		1237	// TODO: should be able to save references within the same map, at least
		1238	return 0;
		1239	}
		1240
		1241	object *
		1242	object::deref (const_utf8_string ref)
		1243	{
		1244	object *retval = 0;
		1245
		1246	if (ref)
		1247	{
		1248	CALL_BEGIN (1);
		1249	CALL_ARG (ref);
		1250	CALL_CALL ("cf::object::deref", G_SCALAR);
		1251
		1252	if (count)
		1253	sv_to (POPs, retval);
		1254
		1255	CALL_END;
		1256	}
		1257
		1258	return retval;
		1259	}
		1260
		1261	void
		1262	log_backtrace (const_utf8_string msg)
1003	{	1263	{
1004	#if HAVE_BACKTRACE	1264	#if HAVE_BACKTRACE
1005	void *addr [20];	1265	void *addr [20];
1006	int size = backtrace (addr, 20);	1266	int size = backtrace (addr, 20);
1007		1267
…		…
1012	CALL_CALL ("cf::_log_backtrace", G_VOID);	1272	CALL_CALL ("cf::_log_backtrace", G_VOID);
1013	CALL_END;	1273	CALL_END;
1014	#endif	1274	#endif
1015	}	1275	}
1016		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
1017	/////////////////////////////////////////////////////////////////////////////	1328	/////////////////////////////////////////////////////////////////////////////
1018		1329
1019	struct EventAPI *watcher_base::GEventAPI;	1330	struct EVAPI *evapi::GEVAPI;
1020	struct CoroAPI *coroapi::GCoroAPI;	1331	struct CoroAPI *coroapi::GCoroAPI;
1021		1332
1022	int coroapi::cede_counter;	1333	void
1023	double (*coroapi::time)();
1024	double coroapi::next_cede;
1025
1026	void coroapi::do_cede_to_tick ()	1334	coroapi::do_cede_to_tick ()
1027	{	1335	{
1028	cede_counter = 0;	1336	cede_pending = 0;
1029
1030	cede ();	1337	cede ();
1031
1032	next_cede += (TICK / CEDES_PER_TICK) * 0.99;
1033	if (next_cede > SvNV (sv_next_tick) - 0.02)
1034	next_cede = SvNV (sv_next_tick);
1035	}
1036
1037	void coroapi::do_cede_every ()
1038	{
1039	cede_counter = 0;
1040
1041	if (coroapi::nready ())
1042	coroapi::cede ();
1043	}
1044
1045	void coroapi::do_cede_to_tick_every ()
1046	{
1047	cede_counter = 0;
1048
1049	cede_to_tick ();
1050	}	1338	}
1051		1339
1052	void	1340	void
1053	coroapi::wait_for_tick ()	1341	coroapi::wait_for_tick ()
1054	{	1342	{
…		…
1063	CALL_BEGIN (0);	1351	CALL_BEGIN (0);
1064	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);	1352	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);
1065	CALL_END;	1353	CALL_END;
1066	}	1354	}
1067		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
1068	static void	1368	static void
1069	iw_dispatch (pe_event *ev)
1070	{
1071	iw w = (iw )ev->ext_data;
1072	w->call (*w);
1073	}
1074
1075	void
1076	iw::alloc ()
1077	{
1078	pe = GEventAPI->new_idle (0, 0);
1079
1080	WaREENTRANT_off (pe);
1081	pe->base.callback = (void *)iw_dispatch;
1082	pe->base.ext_data = (void *)this;
1083	}
1084
1085	static void iow_dispatch (pe_event *ev)
1086	{
1087	iow w = (iow )ev->ext_data;
1088	w->call (w, ((pe_ioevent )ev)->got);
1089	}
1090
1091	void
1092	iow::alloc ()
1093	{
1094	pe = GEventAPI->new_io (0, 0);
1095
1096	WaREENTRANT_off (pe);
1097	pe->base.callback = (void *)iow_dispatch;
1098	pe->base.ext_data = (void *)this;
1099
1100	pe->fd = -1;
1101	pe->poll = 0;
1102	}
1103
1104	void
1105	iow::fd (int fd)
1106	{
1107	pe->fd = fd;
1108	}
1109
1110	int
1111	iow::poll ()
1112	{
1113	return pe->poll;
1114	}
1115
1116	void
1117	iow::poll (int events)
1118	{
1119	if (pe->poll != events)
1120	{
1121	if (pe->poll) stop ();
1122	pe->poll = events;
1123	if (pe->poll) start ();
1124	}
1125	}
1126
1127	void
1128	_connect_to_perl ()	1369	_connect_to_perl_1 ()
1129	{	1370	{
1130	stash_cf = gv_stashpv ("cf" , 1);	1371	stash_cf = gv_stashpv ("cf", 1);
1131		1372
1132	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);	1373	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);
1133	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);
1134	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);	1375	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);
1135	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);
1136	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);	1378	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);
1137	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);	1379	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
1138	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);	1380	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
1139	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);	1381	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
1140	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);	1382	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
1141		1383
		1384	sv_now = get_sv ("cf::NOW" , 1); SvUPGRADE (sv_now , SVt_NV);
1142	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);
1143	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);
1144		1388
1145	cb_global = get_av ("cf::CB_GLOBAL", 1);	1389	cb_global = get_av ("cf::CB_GLOBAL", 1);
1146	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);	1390	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
1147	cb_object = get_av ("cf::CB_OBJECT", 1);	1391	cb_object = get_av ("cf::CB_OBJECT", 1);
1148	cb_player = get_av ("cf::CB_PLAYER", 1);	1392	cb_player = get_av ("cf::CB_PLAYER", 1);
1149	cb_client = get_av ("cf::CB_CLIENT", 1);	1393	cb_client = get_av ("cf::CB_CLIENT", 1);
1150	cb_type = get_av ("cf::CB_TYPE" , 1);	1394	cb_type = get_av ("cf::CB_TYPE" , 1);
1151	cb_map = get_av ("cf::CB_MAP" , 1);	1395	cb_map = get_av ("cf::CB_MAP" , 1);
1152	}	1396	}
1153		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
1154	MODULE = cf PACKAGE = cf PREFIX = cf_	1408	MODULE = cf PACKAGE = cf PREFIX = cf_
1155		1409
1156	BOOT:	1410	BOOT:
1157	{	1411	{
1158	I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;	1412	I_EV_API (PACKAGE); evapi::GEVAPI = GEVAPI;
1159	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;	1413	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
1160		1414
1161	_connect_to_perl ();	1415	_connect_to_perl_1 ();
1162		1416
1163	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));	1417	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
1164		1418
1165	{	1419	//{
1166	require_pv ("Time::HiRes");	1420	// require_pv ("Time::HiRes");
1167		1421	//
1168	SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);	1422	// SV **svp = hv_fetch (PL_modglobal, "Time::NVtime", 12, 0);
1169	if (!svp) croak ("Time::HiRes is required");	1423	// if (!svp) croak ("Time::HiRes is required");
1170	if (!SvIOK(*svp)) croak ("Time::NVtime isn’t a function pointer");	1424	// if (!SvIOK(*svp)) croak ("Time::NVtime isn’t a function pointer");
1171	coroapi::time = INT2PTR (double()(), SvIV(svp));	1425	// coroapi::time = INT2PTR (double()(), SvIV(svp));
1172	}	1426	//}
1173		1427
1174	static const struct {	1428	static const struct {
1175	const char *name;	1429	const char *name;
1176	IV iv;	1430	IV iv;
1177	} *civ, const_iv[] = {	1431	} *civ, const_iv[] = {
1178	# 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
1179	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)
1180	const_iv (logBacktrace)	1442	const_iv (logBacktrace)
1181		1443
1182	const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)	1444	const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)
1183		1445
1184	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)	1446	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)
1185		1447
1186	const_iv (MAX_TIME)	1448	const_iv (MAX_TIME)
1187		1449	const_iv (MAXSOCKBUF)
1188	const_iv (NUM_BODY_LOCATIONS)
1189	const_iv (body_range) const_iv (body_shield) const_iv (body_combat)
1190	const_iv (body_arm) const_iv (body_torso) const_iv (body_head)
1191	const_iv (body_neck) const_iv (body_skill) const_iv (body_finger)
1192	const_iv (body_shoulder) const_iv (body_foot) const_iv (body_hand)
1193	const_iv (body_wrist) const_iv (body_waist)
1194
1195	const_iv (PLAYER) const_iv (TRANSPORT) const_iv (ROD) const_iv (TREASURE)
1196	const_iv (POTION) const_iv (FOOD) const_iv (POISON) const_iv (BOOK)
1197	const_iv (CLOCK) const_iv (ARROW) const_iv (BOW) const_iv (WEAPON)
1198	const_iv (ARMOUR) const_iv (PEDESTAL) const_iv (ALTAR) const_iv (LOCKED_DOOR)
1199	const_iv (SPECIAL_KEY) const_iv (MAP) const_iv (DOOR) const_iv (KEY)
1200	const_iv (TIMED_GATE) const_iv (TRIGGER) const_iv (GRIMREAPER) const_iv (MAGIC_EAR)
1201	const_iv (TRIGGER_BUTTON) const_iv (TRIGGER_ALTAR) const_iv (TRIGGER_PEDESTAL) const_iv (SHIELD)
1202	const_iv (HELMET) const_iv (HORN) const_iv (MONEY) const_iv (CLASS)
1203	const_iv (GRAVESTONE) const_iv (AMULET) const_iv (PLAYERMOVER) const_iv (TELEPORTER)
1204	const_iv (CREATOR) const_iv (SKILL) const_iv (EARTHWALL) const_iv (GOLEM)
1205	const_iv (THROWN_OBJ) const_iv (BLINDNESS) const_iv (GOD) const_iv (DETECTOR)
1206	const_iv (TRIGGER_MARKER) const_iv (DEAD_OBJECT) const_iv (DRINK) const_iv (MARKER)
1207	const_iv (HOLY_ALTAR) const_iv (PLAYER_CHANGER) const_iv (BATTLEGROUND) const_iv (PEACEMAKER)
1208	const_iv (GEM) const_iv (FIREWALL) const_iv (ANVIL) const_iv (CHECK_INV)
1209	const_iv (MOOD_FLOOR) const_iv (EXIT) const_iv (ENCOUNTER) const_iv (SHOP_FLOOR)
1210	const_iv (SHOP_MAT) const_iv (RING) const_iv (FLOOR) const_iv (FLESH)
1211	const_iv (INORGANIC) const_iv (SKILL_TOOL) const_iv (LIGHTER) const_iv (BUILDABLE_WALL)
1212	const_iv (MISC_OBJECT) const_iv (LAMP) const_iv (DUPLICATOR) const_iv (SPELLBOOK)
1213	const_iv (CLOAK) const_iv (SPINNER) const_iv (GATE) const_iv (BUTTON)
1214	const_iv (CF_HANDLE) const_iv (HOLE) const_iv (TRAPDOOR) const_iv (SIGN)
1215	const_iv (BOOTS) const_iv (GLOVES) const_iv (SPELL) const_iv (SPELL_EFFECT)
1216	const_iv (CONVERTER) const_iv (BRACERS) const_iv (POISONING) const_iv (SAVEBED)
1217	const_iv (WAND) const_iv (SCROLL) const_iv (DIRECTOR) const_iv (GIRDLE)
1218	const_iv (FORCE) const_iv (POTION_EFFECT) const_iv (EVENT_CONNECTOR) const_iv (CLOSE_CON)
1219	const_iv (CONTAINER) const_iv (ARMOUR_IMPROVER) const_iv (WEAPON_IMPROVER) const_iv (SKILLSCROLL)
1220	const_iv (DEEP_SWAMP) const_iv (IDENTIFY_ALTAR) const_iv (MENU) const_iv (RUNE)
1221	const_iv (TRAP) const_iv (POWER_CRYSTAL) const_iv (CORPSE) const_iv (DISEASE)
1222	const_iv (SYMPTOM) const_iv (BUILDER) const_iv (MATERIAL) const_iv (ITEM_TRANSFORMER)
1223
1224	const_iv (NUM_TYPES) const_iv (NUM_SUBTYPES)
1225
1226	const_iv (ST_BD_BUILD) const_iv (ST_BD_REMOVE)
1227	const_iv (ST_MAT_FLOOR) const_iv (ST_MAT_WALL) const_iv (ST_MAT_ITEM)
1228
1229	const_iv (AT_PHYSICAL) const_iv (AT_MAGIC) const_iv (AT_FIRE) const_iv (AT_ELECTRICITY)
1230	const_iv (AT_COLD) const_iv (AT_CONFUSION) const_iv (AT_ACID) const_iv (AT_DRAIN)
1231	const_iv (AT_WEAPONMAGIC) const_iv (AT_GHOSTHIT) const_iv (AT_POISON) const_iv (AT_SLOW)
1232	const_iv (AT_PARALYZE) const_iv (AT_TURN_UNDEAD) const_iv (AT_FEAR) const_iv (AT_CANCELLATION)
1233	const_iv (AT_DEPLETE) const_iv (AT_DEATH) const_iv (AT_CHAOS) const_iv (AT_COUNTERSPELL)
1234	const_iv (AT_GODPOWER) const_iv (AT_HOLYWORD) const_iv (AT_BLIND) const_iv (AT_INTERNAL)
1235	const_iv (AT_LIFE_STEALING) const_iv (AT_DISEASE)
1236
1237	const_iv (WEAP_HIT) const_iv (WEAP_SLASH) const_iv (WEAP_PIERCE) const_iv (WEAP_CLEAVE)
1238	const_iv (WEAP_SLICE) const_iv (WEAP_STAB) const_iv (WEAP_WHIP) const_iv (WEAP_CRUSH)
1239	const_iv (WEAP_BLUD)
1240
1241	const_iv (FLAG_ALIVE) const_iv (FLAG_WIZ) const_iv (FLAG_REMOVED) const_iv (FLAG_FREED)
1242	const_iv (FLAG_APPLIED) const_iv (FLAG_UNPAID) const_iv (FLAG_USE_SHIELD)
1243	const_iv (FLAG_NO_PICK) const_iv (FLAG_ANIMATE) const_iv (FLAG_MONSTER) const_iv (FLAG_FRIENDLY)
1244	const_iv (FLAG_GENERATOR) const_iv (FLAG_IS_THROWN) const_iv (FLAG_AUTO_APPLY) const_iv (FLAG_PLAYER_SOLD)
1245	const_iv (FLAG_SEE_INVISIBLE) const_iv (FLAG_CAN_ROLL) const_iv (FLAG_OVERLAY_FLOOR) const_iv (FLAG_IS_TURNABLE)
1246	const_iv (FLAG_IS_USED_UP) const_iv (FLAG_IDENTIFIED) const_iv (FLAG_REFLECTING) const_iv (FLAG_CHANGING)
1247	const_iv (FLAG_SPLITTING) const_iv (FLAG_HITBACK) const_iv (FLAG_STARTEQUIP) const_iv (FLAG_BLOCKSVIEW)
1248	const_iv (FLAG_UNDEAD) const_iv (FLAG_SCARED) const_iv (FLAG_UNAGGRESSIVE) const_iv (FLAG_REFL_MISSILE)
1249	const_iv (FLAG_REFL_SPELL) const_iv (FLAG_NO_MAGIC) const_iv (FLAG_NO_FIX_PLAYER) const_iv (FLAG_IS_LIGHTABLE)
1250	const_iv (FLAG_TEAR_DOWN) const_iv (FLAG_RUN_AWAY) const_iv (FLAG_PICK_UP) const_iv (FLAG_UNIQUE)
1251	const_iv (FLAG_NO_DROP) const_iv (FLAG_WIZCAST) const_iv (FLAG_CAST_SPELL) const_iv (FLAG_USE_SCROLL)
1252	const_iv (FLAG_USE_RANGE) const_iv (FLAG_USE_BOW) const_iv (FLAG_USE_ARMOUR) const_iv (FLAG_USE_WEAPON)
1253	const_iv (FLAG_USE_RING) const_iv (FLAG_READY_RANGE) const_iv (FLAG_READY_BOW) const_iv (FLAG_XRAYS)
1254	const_iv (FLAG_NO_APPLY) const_iv (FLAG_IS_FLOOR) const_iv (FLAG_LIFESAVE) const_iv (FLAG_NO_STRENGTH)
1255	const_iv (FLAG_SLEEP) const_iv (FLAG_STAND_STILL) const_iv (FLAG_RANDOM_MOVE) const_iv (FLAG_ONLY_ATTACK)
1256	const_iv (FLAG_CONFUSED) const_iv (FLAG_STEALTH) const_iv (FLAG_WIZPASS) const_iv (FLAG_IS_LINKED)
1257	const_iv (FLAG_CURSED) const_iv (FLAG_DAMNED) const_iv (FLAG_SEE_ANYWHERE) const_iv (FLAG_KNOWN_MAGICAL)
1258	const_iv (FLAG_KNOWN_CURSED) const_iv (FLAG_CAN_USE_SKILL) const_iv (FLAG_BEEN_APPLIED) const_iv (FLAG_READY_SCROLL)
1259	const_iv (FLAG_USE_ROD) const_iv (FLAG_USE_HORN) const_iv (FLAG_MAKE_INVIS) const_iv (FLAG_INV_LOCKED)
1260	const_iv (FLAG_IS_WOODED) const_iv (FLAG_IS_HILLY) const_iv (FLAG_READY_SKILL) const_iv (FLAG_READY_WEAPON)
1261	const_iv (FLAG_NO_SKILL_IDENT) const_iv (FLAG_BLIND) const_iv (FLAG_SEE_IN_DARK) const_iv (FLAG_IS_CAULDRON)
1262	const_iv (FLAG_NO_STEAL) const_iv (FLAG_ONE_HIT) const_iv (FLAG_CLIENT_SENT) const_iv (FLAG_BERSERK)
1263	const_iv (FLAG_NEUTRAL) const_iv (FLAG_NO_ATTACK) const_iv (FLAG_NO_DAMAGE) const_iv (FLAG_OBJ_ORIGINAL)
1264	const_iv (FLAG_OBJ_SAVE_ON_OVL) const_iv (FLAG_ACTIVATE_ON_PUSH) const_iv (FLAG_ACTIVATE_ON_RELEASE) const_iv (FLAG_IS_WATER)
1265	const_iv (FLAG_CONTENT_ON_GEN) const_iv (FLAG_IS_A_TEMPLATE) const_iv (FLAG_IS_BUILDABLE)
1266	const_iv (FLAG_DESTROY_ON_DEATH) const_iv (FLAG_NO_MAP_SAVE)
1267
1268	const_iv (NDI_BLACK) const_iv (NDI_WHITE) const_iv (NDI_NAVY) const_iv (NDI_RED)
1269	const_iv (NDI_ORANGE) const_iv (NDI_BLUE) const_iv (NDI_DK_ORANGE) const_iv (NDI_GREEN)
1270	const_iv (NDI_LT_GREEN) const_iv (NDI_GREY) const_iv (NDI_BROWN) const_iv (NDI_GOLD)
1271	const_iv (NDI_TAN) const_iv (NDI_MAX_COLOR) const_iv (NDI_COLOR_MASK) const_iv (NDI_UNIQUE)
1272	const_iv (NDI_ALL)
1273		1450
1274	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)
1275	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)
1276		1453
1277	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)
1278		1455
1279	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)
1280	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)
1281	const_iv (F_LOCKED)	1458	const_iv (F_LOCKED)
1282		1459
1283	const_iv (F_BUY) const_iv (F_SHOP) const_iv (F_SELL)
1284
1285	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)
1286	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)
1287		1462
1288	const_iv (UP_OBJ_INSERT) const_iv (UP_OBJ_REMOVE) const_iv (UP_OBJ_CHANGE) const_iv (UP_OBJ_FACE)
1289
1290	const_iv (INS_NO_MERGE) const_iv (INS_ABOVE_FLOOR_ONLY) const_iv (INS_NO_WALK_ON)
1291	const_iv (INS_ON_TOP) const_iv (INS_BELOW_ORIGINATOR) const_iv (INS_MAP_LOAD)
1292
1293	const_iv (WILL_APPLY_HANDLE) const_iv (WILL_APPLY_TREASURE) const_iv (WILL_APPLY_EARTHWALL)
1294	const_iv (WILL_APPLY_DOOR) const_iv (WILL_APPLY_FOOD)
1295
1296	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)	1463	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)
1297
1298	const_iv (M_PAPER) const_iv (M_IRON) const_iv (M_GLASS) const_iv (M_LEATHER)
1299	const_iv (M_WOOD) const_iv (M_ORGANIC) const_iv (M_STONE) const_iv (M_CLOTH)
1300	const_iv (M_ADAMANT) const_iv (M_LIQUID) const_iv (M_SOFT_METAL) const_iv (M_BONE)
1301	const_iv (M_ICE) const_iv (M_SPECIAL)
1302		1464
1303	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)
1304	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)
1305		1467
1306	const_iv (SK_LOCKPICKING) const_iv (SK_HIDING) const_iv (SK_SMITHERY) const_iv (SK_BOWYER)
1307	const_iv (SK_JEWELER) const_iv (SK_ALCHEMY) const_iv (SK_STEALING) const_iv (SK_LITERACY)
1308	const_iv (SK_BARGAINING) const_iv (SK_JUMPING) const_iv (SK_DET_MAGIC) const_iv (SK_ORATORY)
1309	const_iv (SK_SINGING) const_iv (SK_DET_CURSE) const_iv (SK_FIND_TRAPS) const_iv (SK_MEDITATION)
1310	const_iv (SK_PUNCHING) const_iv (SK_FLAME_TOUCH) const_iv (SK_KARATE) const_iv (SK_CLIMBING)
1311	const_iv (SK_WOODSMAN) const_iv (SK_INSCRIPTION) const_iv (SK_ONE_HANDED_WEAPON) const_iv (SK_MISSILE_WEAPON)
1312	const_iv (SK_THROWING) const_iv (SK_USE_MAGIC_ITEM) const_iv (SK_DISARM_TRAPS) const_iv (SK_SET_TRAP)
1313	const_iv (SK_THAUMATURGY) const_iv (SK_PRAYING) const_iv (SK_CLAWING) const_iv (SK_LEVITATION)
1314	const_iv (SK_SUMMONING) const_iv (SK_PYROMANCY) const_iv (SK_EVOCATION) const_iv (SK_SORCERY)
1315	const_iv (SK_TWO_HANDED_WEAPON) const_iv (SK_SPARK_TOUCH) const_iv (SK_SHIVER) const_iv (SK_ACID_SPLASH)
1316	const_iv (SK_POISON_NAIL)
1317
1318	const_iv (SOUND_NEW_PLAYER) const_iv (SOUND_FIRE_ARROW) const_iv (SOUND_LEARN_SPELL) const_iv (SOUND_FUMBLE_SPELL)
1319	const_iv (SOUND_WAND_POOF) const_iv (SOUND_OPEN_DOOR) const_iv (SOUND_PUSH_PLAYER) const_iv (SOUND_PLAYER_HITS1)
1320	const_iv (SOUND_PLAYER_HITS2) const_iv (SOUND_PLAYER_HITS3) const_iv (SOUND_PLAYER_HITS4) const_iv (SOUND_PLAYER_IS_HIT1)
1321	const_iv (SOUND_PLAYER_IS_HIT2) const_iv (SOUND_PLAYER_IS_HIT3) const_iv (SOUND_PLAYER_KILLS) const_iv (SOUND_PET_IS_KILLED)
1322	const_iv (SOUND_PLAYER_DIES) const_iv (SOUND_OB_EVAPORATE) const_iv (SOUND_OB_EXPLODE) const_iv (SOUND_CLOCK)
1323	const_iv (SOUND_TURN_HANDLE) const_iv (SOUND_FALL_HOLE) const_iv (SOUND_DRINK_POISON) const_iv (SOUND_CAST_SPELL_0)
1324
1325	const_iv (PREFER_LOW) const_iv (PREFER_HIGH)
1326
1327	const_iv (ATNR_PHYSICAL) const_iv (ATNR_MAGIC) const_iv (ATNR_FIRE) const_iv (ATNR_ELECTRICITY)
1328	const_iv (ATNR_COLD) const_iv (ATNR_CONFUSION) const_iv (ATNR_ACID) const_iv (ATNR_DRAIN)
1329	const_iv (ATNR_WEAPONMAGIC) const_iv (ATNR_GHOSTHIT) const_iv (ATNR_POISON) const_iv (ATNR_SLOW)
1330	const_iv (ATNR_PARALYZE) const_iv (ATNR_TURN_UNDEAD) const_iv (ATNR_FEAR) const_iv (ATNR_CANCELLATION)
1331	const_iv (ATNR_DEPLETE) const_iv (ATNR_DEATH) const_iv (ATNR_CHAOS) const_iv (ATNR_COUNTERSPELL)
1332	const_iv (ATNR_GODPOWER) const_iv (ATNR_HOLYWORD) const_iv (ATNR_BLIND) const_iv (ATNR_INTERNAL)
1333	const_iv (ATNR_LIFE_STEALING) const_iv (ATNR_DISEASE)
1334
1335	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)
1336		1470
1337	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)
1338	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)
1339		1473
1340	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)
1341		1475
1342	const_iv (ST_DEAD) const_iv (ST_SETUP) const_iv (ST_PLAYING) const_iv (ST_CUSTOM)
1343
1344	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)
1345
1346	// random map generator
1347	const_iv (LAYOUT_NONE) const_iv (LAYOUT_ONION) const_iv (LAYOUT_MAZE) const_iv (LAYOUT_SPIRAL)
1348	const_iv (LAYOUT_ROGUELIKE) const_iv (LAYOUT_SNAKE) const_iv (LAYOUT_SQUARE_SPIRAL)
1349
1350	const_iv (RMOPT_RANDOM) const_iv (RMOPT_CENTERED) const_iv (RMOPT_LINEAR)
1351	const_iv (RMOPT_BOTTOM_C) const_iv (RMOPT_BOTTOM_R) const_iv (RMOPT_IRR_SPACE)
1352	const_iv (RMOPT_WALL_OFF) const_iv (RMOPT_WALLS_ONLY) const_iv (RMOPT_NO_DOORS)
1353
1354	const_iv (SYMMETRY_RANDOM) const_iv (SYMMETRY_NONE) const_iv (SYMMETRY_X)
1355	const_iv (SYMMETRY_Y) const_iv (SYMMETRY_XY)
1356
1357	const_iv (GT_ENVIRONMENT) const_iv (GT_INVISIBLE) const_iv (GT_STARTEQUIP)
1358	const_iv (GT_APPLY) const_iv (GT_ONLY_GOOD) const_iv (GT_UPDATE_INV)
1359	const_iv (GT_MINIMAL)
1360	};	1477	};
1361		1478
1362	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; )
1363	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));	1480	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1364		1481
…		…
1381	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));	1498	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));
1382	av_push (event, newSViv (eiv->klass));	1499	av_push (event, newSViv (eiv->klass));
1383	av_store (av, eiv->iv, newRV_noinc ((SV *)event));	1500	av_store (av, eiv->iv, newRV_noinc ((SV *)event));
1384	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));	1501	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));
1385	}	1502	}
1386	}
1387		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
1388	void _connect_to_perl ()	1522	void _connect_to_perl_1 ()
		1523
		1524	void _connect_to_perl_2 ()
1389		1525
1390	void _recalc_want ()	1526	void _recalc_want ()
1391		1527
		1528	# not used by default anymore
1392	void _global_reattach ()	1529	void _global_reattach ()
1393	CODE:	1530	CODE:
1394	{	1531	{
1395	// reattach to all attachable objects in the game.	1532	// reattach to all attachable objects in the game.
1396	for_all_clients (ns)	1533	for_all_clients (ns)
1397	ns->reattach ();	1534	ns->reattach ();
1398		1535
1399	for_all_objects (op)	1536	for_all_objects (op)
1400	op->reattach ();	1537	op->reattach ();
1401	}	1538	}
1402
1403	void _post_tick ()
1404	CODE:
1405	coroapi::next_cede = SvNV (sv_next_tick) - TICK * (1. - 1. / CEDES_PER_TICK);
1406		1539
1407	# support function for map-world.ext	1540	# support function for map-world.ext
1408	void _quantise (SV data_sv, SV plt_sv)	1541	void _quantise (SV data_sv, SV plt_sv)
1409	CODE:	1542	CODE:
1410	{	1543	{
…		…
1444	}	1577	}
1445		1578
1446	SvCUR_set (data_sv, dst - SvPVX (data_sv));	1579	SvCUR_set (data_sv, dst - SvPVX (data_sv));
1447	}	1580	}
1448		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
		1608	void cede_to_tick ()
		1609	CODE:
		1610	coroapi::cede_to_tick ();
		1611
		1612	NV till_tick ()
		1613	CODE:
		1614	RETVAL = SvNVX (sv_next_tick) - now ();
		1615	OUTPUT:
		1616	RETVAL
		1617
		1618	int tick_inhibit ()
		1619	CODE:
		1620	RETVAL = tick_inhibit;
		1621	OUTPUT:
		1622	RETVAL
		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
1449	NV floor (NV x)	1655	NV floor (NV x)
1450		1656
1451	NV ceil (NV x)	1657	NV ceil (NV x)
1452		1658
1453	NV rndm (...)	1659	NV rndm (...)
		1660	ALIAS:
		1661	rmg_rndm = 1
1454	CODE:	1662	CODE:
		1663	{
		1664	rand_gen &gen = ix ? rmg_rndm : rndm;
1455	switch (items)	1665	switch (items)
1456	{	1666	{
1457	case 0: RETVAL = rndm (); break;	1667	case 0: RETVAL = gen (); break;
1458	case 1: RETVAL = rndm (SvUV (ST (0))); break;	1668	case 1: RETVAL = gen (SvUV (ST (0))); break;
1459	case 2: RETVAL = rndm (SvIV (ST (0)), SvIV (ST (1))); break;	1669	case 2: RETVAL = gen (SvIV (ST (0)), SvIV (ST (1))); break;
1460	default: croak ("cf::rndm requires none, one or two parameters."); break;	1670	default: croak ("cf::rndm requires zero, one or two parameters."); break;
1461	}	1671	}
		1672	}
1462	OUTPUT:	1673	OUTPUT:
1463	RETVAL	1674	RETVAL
1464		1675
1465	NV clamp (NV value, NV min_value, NV max_value)	1676	NV clamp (NV value, NV min_value, NV max_value)
1466	CODE:	1677	CODE:
…		…
1472	CODE:	1683	CODE:
1473	RETVAL = lerp (value, min_in, max_in, min_out, max_out);	1684	RETVAL = lerp (value, min_in, max_in, min_out, max_out);
1474	OUTPUT:	1685	OUTPUT:
1475	RETVAL	1686	RETVAL
1476		1687
1477	void cede_to_tick ()	1688	const char *ordinal (int i)
1478	CODE:
1479	coroapi::cede_to_tick ();
1480		1689
1481	void server_tick ()	1690	void weaken (...)
1482	CODE:	1691	PROTOTYPE: @
1483	runtime = SvNVx (sv_runtime);	1692	CODE:
1484	server_tick ();	1693	while (items > 0)
		1694	sv_rvweaken (ST (--items));
1485		1695
1486	void	1696	void log_suspend ()
		1697
		1698	void log_resume ()
		1699
1487	log_backtrace (utf8_string msg)	1700	void log_backtrace (utf8_string msg)
1488		1701
1489	void
1490	LOG (int flags, utf8_string msg)	1702	void LOG (int flags, utf8_string msg)
1491	PROTOTYPE: $$	1703	PROTOTYPE: $$
1492	C_ARGS: flags, "%s", msg	1704	C_ARGS: flags, "%s", msg
1493		1705
1494	octet_string path_combine (octet_string base, octet_string path)	1706	octet_string path_combine (octet_string base, octet_string path)
1495	PROTOTYPE: $$	1707	PROTOTYPE: $$
1496		1708
1497	octet_string path_combine_and_normalize (octet_string base, octet_string path)	1709	octet_string path_combine_and_normalize (octet_string base, octet_string path)
1498	PROTOTYPE: $$	1710	PROTOTYPE: $$
1499
1500	const_octet_string
1501	get_maps_directory (octet_string path)
1502	PROTOTYPE: $
1503	ALIAS: maps_directory = 0
1504	CODE:
1505	RETVAL = create_pathname (path);
1506	OUTPUT: RETVAL
1507		1711
1508	void	1712	void
1509	sub_generation_inc ()	1713	sub_generation_inc ()
1510	CODE:	1714	CODE:
1511	PL_sub_generation++;	1715	PL_sub_generation++;
…		…
1536		1740
1537	void abort ()	1741	void abort ()
1538		1742
1539	void reset_signals ()	1743	void reset_signals ()
1540		1744
1541	void fork_abort (octet_string cause = "cf::fork_abort")	1745	void fork_abort (const_octet_string cause = "cf::fork_abort")
1542		1746
1543	void cleanup (octet_string cause, bool make_core = false)	1747	void cleanup (const_octet_string cause, bool make_core = false)
1544		1748
1545	void emergency_save ()	1749	void emergency_save ()
1546		1750
1547	void _exit (int status = EXIT_SUCCESS)	1751	void _exit (int status = EXIT_SUCCESS)
1548		1752
1549	UV sv_2watcher (SV *w)
1550	CODE:
1551	RETVAL = (UV)GEventAPI->sv_2watcher (w);
1552	OUTPUT:
1553	RETVAL
1554
1555	#if _POSIX_MEMLOCK	1753	#if _POSIX_MEMLOCK
1556		1754
1557	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
1558		1763
1559	int munlockall ()	1764	int munlockall ()
1560		1765
1561	#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	}
1562		1796
1563	int find_animation (utf8_string text)	1797	int find_animation (utf8_string text)
1564	PROTOTYPE: $	1798	PROTOTYPE: $
1565		1799
1566	int random_roll (int min, int max, object *op, int goodbad);	1800	int random_roll (int min, int max, object *op, int goodbad);
…		…
1604	RETVAL = newSVpv (resist_plus[atnr], 0);	1838	RETVAL = newSVpv (resist_plus[atnr], 0);
1605	else	1839	else
1606	XSRETURN_UNDEF;	1840	XSRETURN_UNDEF;
1607	OUTPUT: RETVAL	1841	OUTPUT: RETVAL
1608		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
1609	bool	1885	bool
1610	load_resource_file (octet_string filename)	1886	load_resource_file_ (octet_string filename)
		1887
		1888	void
		1889	fix_weight ()
1611		1890
1612	MODULE = cf PACKAGE = cf::attachable	1891	MODULE = cf PACKAGE = cf::attachable
1613		1892
1614	int	1893	int
1615	valid (SV *obj)	1894	valid (SV *obj)
…		…
1619	RETVAL	1898	RETVAL
1620		1899
1621	void	1900	void
1622	debug_trace (attachable *obj, bool on = true)	1901	debug_trace (attachable *obj, bool on = true)
1623	CODE:	1902	CODE:
1624	obj->flags &= ~attachable::F_DEBUG_TRACE;	1903	obj->attachable_flags &= ~attachable::F_DEBUG_TRACE;
1625	if (on)	1904	if (on)
1626	obj->flags \|= attachable::F_DEBUG_TRACE;	1905	obj->attachable_flags \|= attachable::F_DEBUG_TRACE;
1627		1906
1628	int mortals_size ()	1907	int mortals_size ()
1629	CODE:	1908	CODE:
1630	RETVAL = attachable::mortals.size ();	1909	RETVAL = attachable::mortals.size ();
1631	OUTPUT: RETVAL	1910	OUTPUT: RETVAL
…		…
1633	#object *mortals (U32 index)	1912	#object *mortals (U32 index)
1634	# CODE:	1913	# CODE:
1635	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;	1914	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;
1636	# OUTPUT: RETVAL	1915	# OUTPUT: RETVAL
1637		1916
1638	INCLUDE: $PERL $srcdir/genacc attachable ../include/cfperl.h \|	1917	INCLUDE: $PERL $srcdir/genacc attachable $srcdir/../include/util.h $srcdir/../include/cfperl.h \|
1639		1918
1640	MODULE = cf PACKAGE = cf::global	1919	MODULE = cf PACKAGE = cf::global
1641		1920
1642	int invoke (SV *klass, int event, ...)	1921	int invoke (SV *klass, int event, ...)
1643	CODE:	1922	CODE:
…		…
1647	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);
1648	OUTPUT: RETVAL	1927	OUTPUT: RETVAL
1649		1928
1650	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_	1929	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
1651		1930
1652	INCLUDE: $PERL $srcdir/genacc object ../include/object.h \|	1931	INCLUDE: $PERL $srcdir/genacc object $srcdir/../include/object.h \|
1653		1932
1654	int invoke (object *op, int event, ...)	1933	int invoke (object *op, int event, ...)
1655	CODE:	1934	CODE:
1656	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");
1657	AV av = (AV )sv_2mortal ((SV *)newAV ());	1936	AV av = (AV )sv_2mortal ((SV *)newAV ());
…		…
1679	object *actives (U32 index)	1958	object *actives (U32 index)
1680	CODE:	1959	CODE:
1681	RETVAL = index < actives.size () ? actives [index] : 0;	1960	RETVAL = index < actives.size () ? actives [index] : 0;
1682	OUTPUT: RETVAL	1961	OUTPUT: RETVAL
1683		1962
1684	const char *slot_save_name (U32 slot)	1963	int mortals_size ()
		1964	CODE:
		1965	RETVAL = attachable::mortals.size ();
		1966	OUTPUT: RETVAL
		1967
		1968	const_utf8_string slot_use_name (U32 slot)
1685	ALIAS:	1969	ALIAS:
1686	slot_use_name = 1
1687	slot_nonuse_name = 2	1970	slot_nonuse_name = 1
1688	CODE:	1971	CODE:
1689	{	1972	{
1690	if (slot >= NUM_BODY_LOCATIONS)	1973	if (slot >= NUM_BODY_LOCATIONS)
1691	croak ("body slot index out of range");	1974	croak ("body slot index out of range");
1692		1975
1693	switch (ix)	1976	switch (ix)
1694	{	1977	{
1695	case 0: RETVAL = body_locations[slot].save_name; break;
1696	case 1: RETVAL = body_locations[slot].use_name; break;	1978	case 0: RETVAL = body_locations[slot].use_name; break;
1697	case 2: RETVAL = body_locations[slot].nonuse_name; break;	1979	case 1: RETVAL = body_locations[slot].nonuse_name; break;
1698	}	1980	}
1699	}	1981	}
1700	OUTPUT:	1982	OUTPUT:
1701	RETVAL	1983	RETVAL
1702		1984
…		…
1704		1986
1705	object head (object op)	1987	object head (object op)
1706	PROTOTYPE: $	1988	PROTOTYPE: $
1707	CODE:	1989	CODE:
1708	RETVAL = op->head_ ();	1990	RETVAL = op->head_ ();
1709	OUTPUT: RETVAL
1710
1711	int is_head (object *op)
1712	PROTOTYPE: $
1713	CODE:
1714	RETVAL = op->head_ () == op;
1715	OUTPUT: RETVAL	1991	OUTPUT: RETVAL
1716		1992
1717	void	1993	void
1718	inv (object *obj)	1994	inv (object *obj)
1719	PROTOTYPE: $	1995	PROTOTYPE: $
1720	PPCODE:	1996	PPCODE:
1721	{	1997	{
1722	object *o;
1723	for (o = obj->inv; o; o = o->below)	1998	for (object *o = obj->inv; o; o = o->below)
1724	XPUSHs (sv_2mortal (to_sv (o)));	1999	XPUSHs (sv_2mortal (to_sv (o)));
1725	}	2000	}
1726		2001
1727	void	2002	void
1728	set_animation (object *op, int idx)	2003	set_animation (object *op, int idx)
…		…
1754	OUTPUT:	2029	OUTPUT:
1755	RETVAL	2030	RETVAL
1756		2031
1757	object find_best_object_match (object op, utf8_string match)	2032	object find_best_object_match (object op, utf8_string match)
1758		2033
1759	object find_marked_object (object op)
1760
1761	int need_identify (object *obj);
1762
1763	int apply_shop_mat (object shop_mat, object op);	2034	int apply_shop_mat (object shop_mat, object op);
1764		2035
1765	int move_player (object *op, int dir)	2036	int move (object op, int dir, object originator = op)
1766	CODE:	2037	CODE:
1767	RETVAL = move_player (op, dir);	2038	RETVAL = op->move (dir, originator);
1768	OUTPUT:	2039	OUTPUT:
1769	RETVAL	2040	RETVAL
1770		2041
1771	int move (object op, int dir, object originator = op)
1772	CODE:
1773	RETVAL = move_ob (op, dir, originator);
1774	OUTPUT:
1775	RETVAL
1776
1777	void apply (object applier, object applied, int flags = 0)
1778	CODE:
1779	manual_apply (applied, applier, flags);
1780
1781	void apply_below (object *op)	2042	void apply_below (object *op)
1782	CODE:	2043	CODE:
1783	player_apply_below (op);	2044	player_apply_below (op);
1784		2045
1785	int cast_heal (object op, object caster, object *spell, int dir = 0)	2046	int cast_heal (object op, object caster, object *spell, int dir = 0)
1786		2047
1787	object cf_object_present_archname_inside (object op, utf8_string whatstr)	2048	int casting_level (object caster, object spell)
1788
1789	int cf_object_transfer (object op, int x, int y, int r = 0, object_ornull orig = 0)
1790
1791	int cf_object_change_map (object op, int x, int y, maptile map)
1792
1793	#//TODO
1794	object clone_ (object op, int recursive = 0)
1795	CODE:
1796	if (recursive)
1797	RETVAL = object_create_clone (op);
1798	else
1799	{
1800	RETVAL = object::create ();
1801	op->copy_to (RETVAL);
1802	}
1803	OUTPUT: RETVAL
1804		2049
1805	int pay_item (object op, object buyer)	2050	int pay_item (object op, object buyer)
1806	CODE:	2051	CODE:
1807	RETVAL = pay_for_item (op, buyer);	2052	RETVAL = pay_for_item (op, buyer);
1808	OUTPUT: RETVAL	2053	OUTPUT: RETVAL
…		…
1843		2088
1844	void drop (object who, object op)	2089	void drop (object who, object op)
1845		2090
1846	void pick_up (object who, object op)	2091	void pick_up (object who, object op)
1847		2092
1848	int cf_object_teleport (object op, maptile map, int x, int y)
1849
1850	void update_object (object *op, int action)	2093	void update_object (object *op, int action)
1851		2094
1852	object *cf_create_object_by_name (utf8_string name)
1853
1854	void change_exp (object *op, uint64 exp, utf8_string skill_name = 0, int flag = 0)	2095	void change_exp (object *op, uint64 exp, utf8_string skill_name = 0, int flag = 0)
1855		2096
1856	void player_lvl_adj (object who, object skill = 0)	2097	void player_lvl_adj (object who, object skill = 0)
1857		2098
1858	int kill_object (object op, int dam = 0, object hitter = 0, int type = AT_PHYSICAL)	2099	int kill_object (object op, int dam = 0, object hitter = 0, int type = AT_PHYSICAL)
1859		2100
1860	int calc_skill_exp (object who, object op, object *skill);	2101	int calc_skill_exp (object who, object op, object *skill)
1861		2102
1862	void push_button (object *op);	2103	void push_button (object op, object originator)
1863		2104
1864	void use_trigger (object *op);	2105	void use_trigger (object op, object originator)
1865		2106
1866	void add_button_link (object button, maptile map, int connected);	2107	void handle_apply_yield (object *op)
1867		2108
1868	void remove_button_link (object *op);	2109	int convert_item (object item, object converter)
1869		2110
		2111	void fix_generated_item (object op, object creator, int difficulty, int max_magic, int flags);
1870		2112
1871	MODULE = cf PACKAGE = cf::object PREFIX = cf_	2113	MODULE = cf PACKAGE = cf::object PREFIX = cf_
1872
1873	object cf_insert_ob_in_ob (object ob, object *where)
1874		2114
1875	# no clean way to get an object from an archetype - stupid idiotic	2115	# no clean way to get an object from an archetype - stupid idiotic
1876	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.	2116	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.
1877		2117
1878	object *new (utf8_string archetype = 0)	2118	object *new (utf8_string archetype = 0)
1879	PROTOTYPE: ;$	2119	PROTOTYPE: ;$
1880	CODE:	2120	CODE:
1881	RETVAL = archetype ? get_archetype (archetype) : cf_create_object ();	2121	RETVAL = archetype ? get_archetype (archetype) : object::create ();
1882	OUTPUT:	2122	OUTPUT:
1883	RETVAL	2123	RETVAL
1884		2124
		2125	object generate (utf8_string arch, object creator)
		2126	CODE:
		2127	object *obj = get_archetype (arch);
		2128	fix_generated_item (obj, creator, 0, 0, GT_MINIMAL);
		2129	RETVAL = obj;
		2130	OUTPUT:
		2131	RETVAL
		2132
		2133	object *find_object (U32 tag)
		2134
		2135	object *find_object_uuid (UUID i)
		2136
		2137	# TODO: nuke
1885	object insert_ob_in_map_at (object ob, maptile where, object_ornull orig, int flag, int x, int y)	2138	object insert_ob_in_map_at (object ob, maptile where, object_ornull orig, int flag, int x, int y)
1886	PROTOTYPE: $$$$$$	2139	PROTOTYPE: $$$$$$
1887	CODE:	2140	CODE:
1888	{	2141	{
1889	int unused_type;	2142	RETVAL = insert_ob_in_map_at (ob, where, orig, flag, x, y);
1890	RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);
1891	}
1892		2143
1893	player contr (object op)	2144	if (RETVAL->destroyed ())
1894	CODE:
1895	RETVAL = op->contr;	2145	RETVAL = 0;
1896	OUTPUT: RETVAL	2146	}
1897		2147
1898	const_utf8_string get_ob_key_value (object *op, utf8_string key)	2148	shstr
		2149	object::kv_get (shstr key)
1899		2150
1900	bool set_ob_key_value (object *op, utf8_string key, utf8_string value = 0, int add_key = 1)	2151	void
		2152	object::kv_del (shstr key)
		2153
		2154	void
		2155	object::kv_set (shstr key, shstr value)
1901		2156
1902	object get_nearest_player (object ob)	2157	object get_nearest_player (object ob)
1903	ALIAS: nearest_player = 0	2158	ALIAS: nearest_player = 0
1904	PREINIT:	2159	PREINIT:
1905	extern object get_nearest_player (object );	2160	extern object get_nearest_player (object );
…		…
1907	void rangevector (object ob, object other, int flags = 0)	2162	void rangevector (object ob, object other, int flags = 0)
1908	PROTOTYPE: $$;$	2163	PROTOTYPE: $$;$
1909	PPCODE:	2164	PPCODE:
1910	{	2165	{
1911	rv_vector rv;	2166	rv_vector rv;
		2167
1912	get_rangevector (ob, other, &rv, flags);	2168	get_rangevector (ob, other, &rv, flags);
		2169
1913	EXTEND (SP, 5);	2170	EXTEND (SP, 5);
1914	PUSHs (newSVuv (rv.distance));	2171	PUSHs (sv_2mortal (newSVuv (rv.distance)));
1915	PUSHs (newSViv (rv.distance_x));	2172	PUSHs (sv_2mortal (newSViv (rv.distance_x)));
1916	PUSHs (newSViv (rv.distance_y));	2173	PUSHs (sv_2mortal (newSViv (rv.distance_y)));
1917	PUSHs (newSViv (rv.direction));	2174	PUSHs (sv_2mortal (newSViv (rv.direction)));
1918	PUSHs (newSVcfapi (CFAPI_POBJECT, rv.part));	2175	PUSHs (sv_2mortal (to_sv (rv.part)));
1919	}	2176	}
1920		2177
1921	bool on_same_map_as (object ob, object other)	2178	bool on_same_map_as (object ob, object other)
1922	CODE:	2179	CODE:
1923	RETVAL = on_same_map (ob, other);	2180	RETVAL = on_same_map (ob, other);
…		…
1927	base_name (object *op, int plural = op->nrof > 1)	2184	base_name (object *op, int plural = op->nrof > 1)
1928	CODE:	2185	CODE:
1929	RETVAL = query_base_name (op, plural);	2186	RETVAL = query_base_name (op, plural);
1930	OUTPUT: RETVAL	2187	OUTPUT: RETVAL
1931		2188
1932	object decrease_ob_nr (object op, unsigned long i)	2189	# return the tail of an object, excluding itself
		2190	void
		2191	tail (object *op)
		2192	PPCODE:
		2193	while ((op = op->more))
		2194	XPUSHs (sv_2mortal (to_sv (op)));
1933		2195
1934	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_	2196	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_
1935		2197
1936	player player (object op)	2198	player player (object op)
1937	CODE:	2199	CODE:
1938	RETVAL = op->contr;	2200	RETVAL = op->contr;
1939	OUTPUT: RETVAL	2201	OUTPUT: RETVAL
1940		2202
1941	void check_score (object *op)	2203	bool move_player (object *op, int dir)
1942		2204
1943	void message (object *op, utf8_string txt, int flags = NDI_ORANGE \| NDI_UNIQUE)	2205	void message (object *op, utf8_string txt, int flags = NDI_ORANGE \| NDI_UNIQUE)
1944	CODE:	2206	CODE:
1945	new_draw_info (flags, 0, op, txt);	2207	new_draw_info (flags, 0, op, txt);
1946		2208
1947	object cf_player_send_inventory (object op)
1948
1949	octet_string cf_player_get_ip (object *op)
1950	ALIAS: ip = 0
1951
1952	object cf_player_get_marked_item (object op)
1953	ALIAS: marked_item = 0
1954
1955	void cf_player_set_marked_item (object op, object ob)
1956
1957	partylist cf_player_get_party (object op)
1958	ALIAS: party = 0
1959
1960	void cf_player_set_party (object op, partylist party)
1961
1962	void kill_player (object *op)	2209	void kill_player (object *op)
1963		2210
		2211	void esrv_send_item (object pl, object item)
		2212
1964	void esrv_update_item (object op, int what, object item)	2213	void esrv_update_item (object pl, int what, object item)
1965	C_ARGS: what, op, item	2214	C_ARGS: what, pl, item
1966		2215
1967	void clear_los (object *op)	2216	void esrv_del_item (object *pl, int tag)
		2217	C_ARGS: pl->contr, tag
1968		2218
1969	int command_summon (object *op, utf8_string params)	2219	int command_summon (object *op, utf8_string params)
1970		2220
1971	int command_arrest (object *op, utf8_string params)	2221	int command_arrest (object *op, utf8_string params)
1972		2222
1973		2223
1974	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_	2224	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
1975		2225
1976	INCLUDE: $PERL $srcdir/genacc player ../include/player.h \|	2226	INCLUDE: $PERL $srcdir/genacc player $srcdir/../include/player.h \|
1977		2227
1978	int invoke (player *pl, int event, ...)	2228	int invoke (player *pl, int event, ...)
1979	CODE:	2229	CODE:
1980	if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");	2230	if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");
1981	AV av = (AV )sv_2mortal ((SV *)newAV ());	2231	AV av = (AV )sv_2mortal ((SV *)newAV ());
…		…
1991	pl->ob->stats.hp = pl->ob->stats.maxhp;	2241	pl->ob->stats.hp = pl->ob->stats.maxhp;
1992	pl->ob->stats.sp = pl->ob->stats.maxsp;	2242	pl->ob->stats.sp = pl->ob->stats.maxsp;
1993	pl->ob->stats.grace = pl->ob->stats.maxgrace;	2243	pl->ob->stats.grace = pl->ob->stats.maxgrace;
1994	pl->orig_stats = pl->ob->stats;	2244	pl->orig_stats = pl->ob->stats;
1995		2245
1996	void cf_player_move (player *pl, int dir)	2246	# should only be temporary
		2247	void esrv_new_player (player *pl)
1997		2248
1998	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);	2249	#d# TODO: replace by blocked_los accessor, fix code using this
1999
2000	bool	2250	bool
2001	cell_visible (player *pl, int dx, int dy)	2251	cell_visible (player *pl, int dx, int dy)
2002	CODE:	2252	CODE:
2003	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2	2253	RETVAL = pl->blocked_los (dx, dy) != LOS_BLOCKED;
2004	&& !pl->blocked_los [dx + pl->ns->mapx / 2][dy + pl->ns->mapy / 2];
2005	OUTPUT:	2254	OUTPUT:
2006	RETVAL	2255	RETVAL
2007		2256
2008	void	2257	void
2009	send (player pl, SV packet)	2258	send (player pl, SV packet)
2010	CODE:	2259	CODE:
2011	{	2260	{
2012	STRLEN len;	2261	STRLEN len;
2013	char *buf = SvPVbyte (packet, len);	2262	char *buf = SvPVbyte (packet, len);
2014		2263
		2264	if (len > MAXSOCKBUF)
		2265	pl->failmsg ("[packet too long for client]");
2015	if (pl->ns)	2266	else if (pl->ns)
2016	pl->ns->send_packet (buf, len);	2267	pl->ns->send_packet (buf, len);
2017	}	2268	}
2018
2019	int
2020	listening (player *pl, int new_value = -1)
2021	CODE:
2022	RETVAL = pl->listening;
2023	if (new_value >= 0)
2024	pl->listening = new_value;
2025	OUTPUT:
2026	RETVAL
2027		2269
2028	void savebed (player pl, SV map_path = 0, SV x = 0, SV y = 0)	2270	void savebed (player pl, SV map_path = 0, SV x = 0, SV y = 0)
2029	PROTOTYPE: $;$$$	2271	PROTOTYPE: $;$$$
2030	PPCODE:	2272	PPCODE:
2031	if (GIMME_V != G_VOID)	2273	if (GIMME_V != G_VOID)
…		…
2056	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);	2298	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);
2057	OUTPUT: RETVAL	2299	OUTPUT: RETVAL
2058		2300
2059	SV registry (maptile map)	2301	SV registry (maptile map)
2060		2302
		2303	void
		2304	find_tagged_objects (maptile *map, utf8_string tag = 0)
		2305	PPCODE:
		2306	{
		2307	if (!map->spaces)
		2308	XSRETURN_EMPTY;
		2309
		2310	if (tag)
		2311	{
		2312	shstr_cmp tag_ (tag);
		2313
		2314	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2315	for (object *op = ms->bot; op; op = op->above)
		2316	if (op->tag == tag_)
		2317	XPUSHs (sv_2mortal (to_sv (op)));
		2318	}
		2319	else
		2320	{
		2321	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2322	for (object *op = ms->bot; op; op = op->above)
		2323	if (op->tag)
		2324	XPUSHs (sv_2mortal (to_sv (op)));
		2325	}
		2326	}
		2327
2061	INCLUDE: $PERL $srcdir/genacc maptile ../include/map.h \|	2328	INCLUDE: $PERL $srcdir/genacc maptile $srcdir/../include/map.h \|
		2329
		2330	void
		2331	adjust_daylight ()
		2332	CODE:
		2333	maptile::adjust_daylight ();
		2334
		2335	int
		2336	outdoor_darkness (int darkness = 0)
		2337	CODE:
		2338	RETVAL = maptile::outdoor_darkness;
		2339	if (items)
		2340	maptile::outdoor_darkness = darkness;
		2341	OUTPUT:
		2342	RETVAL
2062		2343
2063	void	2344	void
2064	maptile::instantiate ()	2345	maptile::instantiate ()
2065		2346
2066	maptile *new ()	2347	maptile *new ()
…		…
2098	for (int x = 0; x < THIS->width; ++x)	2379	for (int x = 0; x < THIS->width; ++x)
2099	for (int y = 0; y < THIS->height; ++y)	2380	for (int y = 0; y < THIS->height; ++y)
2100	{	2381	{
2101	for (object *op = THIS->at (x, y).bot; op; op = op->above)	2382	for (object *op = THIS->at (x, y).bot; op; op = op->above)
2102	if (op->flag [FLAG_IS_FLOOR])	2383	if (op->flag [FLAG_IS_FLOOR])
2103	goto skip_space;	2384	goto skip;
2104		2385
2105	{	2386	{
2106	int offs = offset + y * stride + x;	2387	int offs = offset + y * stride + x;
		2388
2107	if (IN_RANGE_EXC (offs, 0, idxlen))	2389	if (IN_RANGE_EXC (offs, 0, idxlen))
2108	{	2390	{
2109	if (SV *elem = av_fetch ((AV )palette, idx [offs], 0))	2391	if (SV *elem = av_fetch ((AV )palette, idx [offs], 0))
2110	{	2392	{
2111	object ob = get_archetype (SvPVutf8_nolen (elem));	2393	object ob = get_archetype (cfSvPVutf8_nolen (elem));
2112	ob->flag [FLAG_NO_MAP_SAVE] = true;	2394	ob->flag [FLAG_NO_MAP_SAVE] = true;
2113	THIS->insert (ob, x, y, 0, INS_ABOVE_FLOOR_ONLY);	2395	THIS->insert (ob, x, y, 0, INS_ABOVE_FLOOR_ONLY);
2114		2396
2115	if (ob->randomitems)	2397	if (ob->randomitems && !ob->above)
2116	{	2398	{
2117	if (!ob->above)
2118	{
2119	ob->create_treasure (ob->randomitems);	2399	ob->create_treasure (ob->randomitems);
2120		2400
2121	for (object *op = ob->above; op; op = op->above)	2401	for (object *op = ob->above; op; op = op->above)
2122	op->flag [FLAG_NO_MAP_SAVE] = true;	2402	op->flag [FLAG_NO_MAP_SAVE] = true;
2123	}	2403	// TODO: if this is a pickable object, then the item
2124		2404	// will at a bit weird - saving inside the player
2125	ob->randomitems = 0;	2405	// will clear the flag, but when the player drops
		2406	// it without logging out, it keeps the flag.
		2407	// nobody ahs reported this, but this can be rather
		2408	// annoying on persistent maps.
2126	}	2409	}
2127	}	2410	}
2128	}	2411	}
2129	}	2412	}
2130		2413
2131	skip_space: ;	2414	skip: ;
2132	}	2415	}
2133	}	2416	}
2134		2417
2135	void	2418	void
2136	maptile::set_regiondata (SV data, int offset, int stride, SV palette)	2419	maptile::set_regiondata (SV data, int offset, int stride, SV palette)
…		…
2142	palette = SvRV (palette);	2425	palette = SvRV (palette);
2143		2426
2144	STRLEN idxlen;	2427	STRLEN idxlen;
2145	const uint8_t idx = (const uint8_t )SvPVbyte (data, idxlen);	2428	const uint8_t idx = (const uint8_t )SvPVbyte (data, idxlen);
2146		2429
2147	region regionmap = (region )malloc (	2430	region_ptr regionmap = new region_ptr [av_len ((AV )palette) + 1];
2148	(av_len ((AV )palette) + 1) sizeof (region *));
2149	uint8_t *regions = salloc<uint8_t> (THIS->size ());	2431	uint8_t *regions = salloc<uint8_t> (THIS->size ());
2150		2432
2151	for (int i = av_len ((AV *)palette) + 1; i--; )	2433	for (int i = av_len ((AV *)palette) + 1; i--; )
2152	regionmap [i] = region::find (	2434	regionmap [i] = region::find (cfSvPVutf8_nolen (av_fetch ((AV )palette, i, 1)));
2153	SvPVutf8_nolen (av_fetch ((AV )palette, i, 1)));
2154		2435
2155	for (int y = 0; y < THIS->height; ++y)	2436	for (int y = 0; y < THIS->height; ++y)
2156	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);	2437	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);
2157		2438
2158	sfree (THIS->regions, THIS->size ());	2439	sfree (THIS->regions, THIS->size ());
2159	free (THIS->regionmap);	2440	delete [] THIS->regionmap;
2160		2441
2161	THIS->regions = regions;	2442	THIS->regions = regions;
2162	THIS->regionmap = regionmap;	2443	THIS->regionmap = regionmap;
2163	}	2444	}
2164		2445
2165	void	2446	void
2166	maptile::create_region_treasure ()	2447	maptile::create_region_treasure ()
2167	CODE:	2448	CODE:
2168	{
2169	object *op = object::create ();
2170	op->type = FLOOR;
2171	op->map = THIS;
2172
2173	for (int x = 0; x < THIS->width; ++x)	2449	for (int x = 0; x < THIS->width; ++x)
2174	for (int y = 0; y < THIS->height; ++y)	2450	for (int y = 0; y < THIS->height; ++y)
2175	{	2451	{
2176	region *rgn = THIS->region (x, y);	2452	region *rgn = THIS->region (x, y);
2177		2453
2178	//fprintf (stderr, "%d,%d %f %p\n", x, y, rgn->treasure_density,rgn->treasure);//D	2454	//fprintf (stderr, "%d,%d %f %p\n", x, y, rgn->treasure_density,rgn->treasure);//D
		2455	if (object *op = THIS->at (x, y).top)
2179	if (rgn->treasure && rndm () < rgn->treasure_density)	2456	if (rgn->treasure && rndm () < rgn->treasure_density)
2180	{
2181	op->x = x;
2182	op->y = y;
2183	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);	2457	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);
2184	}
2185	}	2458	}
2186		2459
2187	op->destroy ();
2188	}
2189
2190	void play_sound_map (maptile *map, int x, int y, int sound_num)
2191
2192	int out_of_map (maptile *map, int x, int y)	2460	int out_of_map (maptile *map, int x, int y)
2193		2461
2194	void	2462	void
2195	trigger (maptile *map, long connection, bool state = true)	2463	find_link (maptile *map, shstr_tmp connection)
2196	CODE:
2197	activate_connection (map, connection, state);
2198
2199	void
2200	get_connection (maptile *map, long connection)
2201	PPCODE:	2464	PPCODE:
2202	oblinkpt *obp = get_connection_links (map, connection);	2465	if (oblinkpt *obp = map->find_link (connection))
2203	if (obp)
2204	for (objectlink *ol = obp->link; ol; ol = ol->next)	2466	for (objectlink *ol = obp->link; ol; ol = ol->next)
2205	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, (object *)ol->ob)));	2467	XPUSHs (sv_2mortal (to_sv ((object *)ol->ob)));
2206
2207	object cf_map_insert_object_there (maptile where, object op, object originator, int flags)
2208
2209	object cf_map_insert_object (maptile where, object* op, int x, int y)
2210
2211	object* cf_map_present_arch_by_name (maptile map, const char str, int nx, int ny)
2212	C_ARGS: str, map, nx, ny
2213		2468
2214	void	2469	void
2215	get_map_flags (maptile *map, int x, int y)	2470	get_map_flags (maptile *map, int x, int y)
2216	PPCODE:	2471	PPCODE:
2217	{	2472	{
2218	maptile *nmap = 0;	2473	maptile *nmap = 0;
2219	I16 nx = 0, ny = 0;	2474	I16 nx = 0, ny = 0;
		2475
		2476	PUTBACK;
2220	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);	2477	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
		2478	SPAGAIN;
2221		2479
2222	EXTEND (SP, 4);	2480	EXTEND (SP, 4);
2223	PUSHs (sv_2mortal (newSViv (flags)));	2481	PUSHs (sv_2mortal (newSViv (flags)));
2224		2482
2225	if (GIMME_V == G_ARRAY)	2483	if (GIMME_V == G_ARRAY)
2226	{	2484	{
2227	PUSHs (sv_2mortal (newSVcfapi (CFAPI_PMAP, nmap)));	2485	PUSHs (sv_2mortal (to_sv (nmap)));
2228	PUSHs (sv_2mortal (newSViv (nx)));	2486	PUSHs (sv_2mortal (newSViv (nx)));
2229	PUSHs (sv_2mortal (newSViv (ny)));	2487	PUSHs (sv_2mortal (newSViv (ny)));
2230	}	2488	}
2231	}	2489	}
2232		2490
		2491	mapspace *
		2492	ms (maptile *map, unsigned int x, unsigned int y)
		2493	PROTOTYPE: $$$
		2494	CODE:
		2495	{
		2496	maptile *nmap = 0;
		2497	I16 nx, ny;
		2498
		2499	PUTBACK;
		2500	get_map_flags (map, &nmap, x, y, &nx, &ny);
		2501	SPAGAIN;
		2502
		2503	if (!nmap)
		2504	XSRETURN_UNDEF;
		2505
		2506	RETVAL = &nmap->at (nx, ny);
		2507	}
		2508	OUTPUT:
		2509	RETVAL
		2510
2233	void	2511	void
2234	at (maptile *map, unsigned int x, unsigned int y)	2512	at (maptile *map, unsigned int x, unsigned int y)
2235	PROTOTYPE: $$$	2513	PROTOTYPE: $$$
2236	PPCODE:	2514	PPCODE:
2237	{	2515	{
2238	object *o;
2239	maptile *nmap = 0;	2516	maptile *nmap = 0;
2240	I16 nx, ny;	2517	I16 nx, ny;
2241		2518
		2519	PUTBACK;
2242	get_map_flags (map, &nmap, x, y, &nx, &ny);	2520	get_map_flags (map, &nmap, x, y, &nx, &ny);
		2521	SPAGAIN;
2243		2522
2244	if (nmap)	2523	if (nmap)
2245	for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)	2524	for (object *o = nmap->at (nx, ny).bot; o; o = o->above)
2246	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));	2525	XPUSHs (sv_2mortal (to_sv (o)));
2247	}	2526	}
2248		2527
2249	SV *	2528	SV *
2250	bot_at (maptile *obj, unsigned int x, unsigned int y)	2529	bot_at (maptile *map, unsigned int x, unsigned int y)
2251	PROTOTYPE: $$$	2530	PROTOTYPE: $$$
2252	ALIAS:	2531	ALIAS:
2253	top_at = 1	2532	top_at = 1
2254	flags_at = 2	2533	flags_at = 2
2255	light_at = 3	2534	light_at = 3
2256	move_block_at = 4	2535	move_block_at = 4
2257	move_slow_at = 5	2536	move_slow_at = 5
2258	move_on_at = 6	2537	move_on_at = 6
2259	move_off_at = 7	2538	move_off_at = 7
2260	INIT:
2261	if (x >= obj->width \|\| y >= obj->height) XSRETURN_UNDEF;
2262	CODE:	2539	CODE:
		2540	{
		2541	sint16 nx = x;
		2542	sint16 ny = y;
		2543
		2544	if (!xy_normalise (map, nx, ny))
		2545	XSRETURN_UNDEF;
		2546
		2547	mapspace &ms = map->at (nx, ny);
		2548
		2549	ms.update ();
		2550
2263	switch (ix)	2551	switch (ix)
2264	{	2552	{
2265	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;	2553	case 0: RETVAL = to_sv (ms.bot ); break;
2266	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;	2554	case 1: RETVAL = to_sv (ms.top ); break;
2267	case 2: RETVAL = newSVuv ( GET_MAP_FLAGS (obj, x, y)); break;	2555	case 2: RETVAL = newSVuv (ms.flags_ ); break;
2268	case 3: RETVAL = newSViv ( GET_MAP_LIGHT (obj, x, y)); break;	2556	case 3: RETVAL = newSViv (ms.light ); break;
2269	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;	2557	case 4: RETVAL = newSVuv (ms.move_block); break;
2270	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;	2558	case 5: RETVAL = newSVuv (ms.move_slow ); break;
2271	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;	2559	case 6: RETVAL = newSVuv (ms.move_on ); break;
2272	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;	2560	case 7: RETVAL = newSVuv (ms.move_off ); break;
2273	}	2561	}
		2562	}
2274	OUTPUT: RETVAL	2563	OUTPUT: RETVAL
2275
2276	void fix_walls (maptile *map, int x, int y)
2277
2278	void fix_walls_around (maptile *map, int x, int y)
2279		2564
2280	# worst xs function of my life	2565	# worst xs function of my life
2281	bool	2566	bool
2282	_create_random_map (\	2567	_create_random_map (\
2283	maptile *self,\	2568	maptile *self,\
…		…
2287	utf8_string monsterstyle,\	2572	utf8_string monsterstyle,\
2288	utf8_string treasurestyle,\	2573	utf8_string treasurestyle,\
2289	utf8_string layoutstyle,\	2574	utf8_string layoutstyle,\
2290	utf8_string doorstyle,\	2575	utf8_string doorstyle,\
2291	utf8_string decorstyle,\	2576	utf8_string decorstyle,\
		2577	utf8_string miningstyle,\
2292	utf8_string origin_map,\	2578	utf8_string origin_map,\
2293	utf8_string final_map,\	2579	utf8_string final_map,\
2294	utf8_string exitstyle,\	2580	utf8_string exitstyle,\
2295	utf8_string this_map,\	2581	utf8_string this_map,\
2296	utf8_string exit_on_final_map,\	2582	utf8_string exit_on_final_map,\
…		…
2328	assign (rmp.monsterstyle , monsterstyle);	2614	assign (rmp.monsterstyle , monsterstyle);
2329	assign (rmp.treasurestyle , treasurestyle);	2615	assign (rmp.treasurestyle , treasurestyle);
2330	assign (rmp.layoutstyle , layoutstyle);	2616	assign (rmp.layoutstyle , layoutstyle);
2331	assign (rmp.doorstyle , doorstyle);	2617	assign (rmp.doorstyle , doorstyle);
2332	assign (rmp.decorstyle , decorstyle);	2618	assign (rmp.decorstyle , decorstyle);
		2619	assign (rmp.miningstyle , miningstyle);
2333	assign (rmp.exitstyle , exitstyle);	2620	assign (rmp.exitstyle , exitstyle);
2334	assign (rmp.exit_on_final_map, exit_on_final_map);	2621	assign (rmp.exit_on_final_map, exit_on_final_map);
2335		2622
2336	rmp.origin_map = origin_map;	2623	rmp.origin_map = origin_map;
2337	rmp.final_map = final_map;	2624	rmp.final_map = final_map;
…		…
2351	rmp.decoroptions = decoroptions;	2638	rmp.decoroptions = decoroptions;
2352	rmp.orientation = orientation;	2639	rmp.orientation = orientation;
2353	rmp.origin_y = origin_y;	2640	rmp.origin_y = origin_y;
2354	rmp.origin_x = origin_x;	2641	rmp.origin_x = origin_x;
2355	rmp.random_seed = random_seed;	2642	rmp.random_seed = random_seed;
2356	rmp.total_map_hp = total_map_hp;	2643	rmp.total_map_hp = (uint64_t) total_map_hp;
2357	rmp.map_layout_style = map_layout_style;	2644	rmp.map_layout_style = map_layout_style;
2358	rmp.treasureoptions = treasureoptions;	2645	rmp.treasureoptions = treasureoptions;
2359	rmp.symmetry_used = symmetry_used;	2646	rmp.symmetry_used = symmetry_used;
2360	rmp.region = region;	2647	rmp.region = region;
2361	rmp.custom = custom;	2648	rmp.custom = custom;
…		…
2363	RETVAL = self->generate_random_map (&rmp);	2650	RETVAL = self->generate_random_map (&rmp);
2364	}	2651	}
2365	OUTPUT:	2652	OUTPUT:
2366	RETVAL	2653	RETVAL
2367		2654
		2655	MODULE = cf PACKAGE = cf::mapspace
		2656
		2657	INCLUDE: $PERL $srcdir/genacc mapspace $srcdir/../include/map.h \|
		2658
2368	MODULE = cf PACKAGE = cf::arch	2659	MODULE = cf PACKAGE = cf::arch
2369		2660
2370	archetype *find (utf8_string name)	2661	int archetypes_size ()
2371	CODE:	2662	CODE:
2372	RETVAL = archetype::find (name);	2663	RETVAL = archetypes.size ();
2373	OUTPUT:
2374	RETVAL
2375
2376	archetype *first()
2377	PROTOTYPE:
2378	CODE:
2379	RETVAL = first_archetype;
2380	OUTPUT: RETVAL	2664	OUTPUT: RETVAL
2381		2665
		2666	archetype *archetypes (U32 index)
		2667	CODE:
		2668	RETVAL = index < archetypes.size () ? archetypes [index] : 0;
		2669	OUTPUT: RETVAL
		2670
2382	INCLUDE: $PERL $srcdir/genacc archetype ../include/object.h \|	2671	INCLUDE: $PERL $srcdir/genacc archetype $srcdir/../include/object.h \|
2383		2672
2384	MODULE = cf PACKAGE = cf::party	2673	MODULE = cf PACKAGE = cf::party
2385		2674
2386	partylist *first ()	2675	partylist *first ()
2387	PROTOTYPE:	2676	PROTOTYPE:
2388	CODE:	2677	CODE:
2389	RETVAL = get_firstparty ();	2678	RETVAL = get_firstparty ();
2390	OUTPUT: RETVAL	2679	OUTPUT: RETVAL
2391		2680
2392	INCLUDE: $PERL $srcdir/genacc partylist ../include/player.h \|	2681	INCLUDE: $PERL $srcdir/genacc partylist $srcdir/../include/player.h \|
2393		2682
2394	MODULE = cf PACKAGE = cf::region	2683	MODULE = cf PACKAGE = cf::region
2395		2684
2396	void	2685	void
2397	list ()	2686	list ()
…		…
2403	PROTOTYPE: $	2692	PROTOTYPE: $
2404	CODE:	2693	CODE:
2405	RETVAL = region::find (name);	2694	RETVAL = region::find (name);
2406	OUTPUT: RETVAL	2695	OUTPUT: RETVAL
2407		2696
2408	region *find_fuzzy (utf8_string name)
2409	PROTOTYPE: $
2410	CODE:
2411	RETVAL = region::find_fuzzy (name);
2412	OUTPUT: RETVAL
2413
2414	int specificity (region *rgn)	2697	int specificity (region *rgn)
2415	CODE:	2698	CODE:
2416	RETVAL = 0;	2699	RETVAL = 0;
2417	while (rgn = rgn->parent)	2700	while (rgn = rgn->parent)
2418	RETVAL++;	2701	RETVAL++;
2419	OUTPUT: RETVAL	2702	OUTPUT: RETVAL
2420		2703
2421	INCLUDE: $PERL $srcdir/genacc region ../include/region.h \|	2704	INCLUDE: $PERL $srcdir/genacc region $srcdir/../include/region.h \|
2422		2705
2423	MODULE = cf PACKAGE = cf::living	2706	MODULE = cf PACKAGE = cf::living
2424		2707
2425	INCLUDE: $PERL $srcdir/genacc living ../include/living.h \|	2708	INCLUDE: $PERL $srcdir/genacc living $srcdir/../include/living.h \|
2426		2709
2427	MODULE = cf PACKAGE = cf::settings	2710	MODULE = cf PACKAGE = cf::settings
2428		2711
2429	INCLUDE: $PERL $srcdir/genacc Settings ../include/global.h \|	2712	INCLUDE: $PERL $srcdir/genacc Settings $srcdir/../include/global.h \|
2430		2713
2431	MODULE = cf PACKAGE = cf::client	2714	MODULE = cf PACKAGE = cf::client
2432		2715
2433	INCLUDE: $PERL $srcdir/genacc client ../include/client.h \|	2716	INCLUDE: $PERL $srcdir/genacc client $srcdir/../include/client.h \|
2434		2717
2435	int invoke (client *ns, int event, ...)	2718	int invoke (client *ns, int event, ...)
2436	CODE:	2719	CODE:
2437	if (KLASS_OF (event) != KLASS_CLIENT) croak ("event class must be CLIENT");	2720	if (KLASS_OF (event) != KLASS_CLIENT) croak ("event class must be CLIENT");
2438	AV av = (AV )sv_2mortal ((SV *)newAV ());	2721	AV av = (AV )sv_2mortal ((SV *)newAV ());
…		…
2454	CODE:	2737	CODE:
2455	{	2738	{
2456	STRLEN len;	2739	STRLEN len;
2457	char *buf = SvPVbyte (packet, len);	2740	char *buf = SvPVbyte (packet, len);
2458		2741
		2742	if (len > MAXSOCKBUF)
		2743	{
		2744	// ugly
		2745	if (THIS->pl)
		2746	THIS->pl->failmsg ("[packet too long for client]");
		2747	}
		2748	else
2459	THIS->send_packet (buf, len);	2749	THIS->send_packet (buf, len);
2460	}	2750	}
		2751
		2752	faceidx
		2753	client::need_face (utf8_string name, int pri = 0)
		2754	CODE:
		2755	RETVAL = face_find (name, 0);
		2756	if (RETVAL)
		2757	{
		2758	THIS->send_face (RETVAL, pri);
		2759	THIS->flush_fx ();
		2760	}
		2761	OUTPUT:
		2762	RETVAL
		2763
		2764	int
		2765	client::fx_want (int idx, int value = -1)
		2766	CODE:
		2767	if (0 < idx && idx < FT_NUM)
		2768	{
		2769	RETVAL = THIS->fx_want [idx];
		2770	if (items > 2)
		2771	THIS->fx_want [idx] = value;
		2772	}
		2773	else
		2774	RETVAL = 0;
		2775	OUTPUT:
		2776	RETVAL
		2777
		2778	MODULE = cf PACKAGE = cf::sound PREFIX = sound_
		2779
		2780	faceidx sound_find (utf8_string name)
		2781
		2782	void sound_set (utf8_string str, faceidx face)
		2783
		2784	# dire hack
		2785	void old_sound_index (int idx, faceidx face)
		2786	CODE:
		2787	extern faceidx old_sound_index [SOUND_CAST_SPELL_0];
		2788	old_sound_index [idx] = face;
2461		2789
2462	MODULE = cf PACKAGE = cf::face PREFIX = face_	2790	MODULE = cf PACKAGE = cf::face PREFIX = face_
2463		2791
2464	#INCLUDE: $PERL $srcdir/genacc faceset ../include/face.h \|	2792	#INCLUDE: $PERL $srcdir/genacc faceset $srcdir/../include/face.h \|
2465		2793
2466	faceidx face_find (utf8_string name, faceidx defidx = 0)	2794	faceidx face_find (utf8_string name, faceidx defidx = 0)
2467		2795
2468	faceidx alloc (utf8_string name)	2796	faceidx alloc (utf8_string name)
2469	CODE:	2797	CODE:
…		…
2476	while (!RETVAL); // crude way to leave index 0	2804	while (!RETVAL); // crude way to leave index 0
2477		2805
2478	faces [RETVAL].name = name;	2806	faces [RETVAL].name = name;
2479	facehash.insert (std::make_pair (faces [RETVAL].name, RETVAL));	2807	facehash.insert (std::make_pair (faces [RETVAL].name, RETVAL));
2480		2808
2481	if (!strcmp (name, BLANK_FACE_NAME)) blank_face = RETVAL;	2809	if (!strcmp (name, BLANK_FACE_NAME )) blank_face = RETVAL;
2482	if (!strcmp (name, EMPTY_FACE_NAME)) empty_face = RETVAL;	2810	if (!strcmp (name, EMPTY_FACE_NAME )) empty_face = RETVAL;
		2811	if (!strcmp (name, MAGICMOUTH_FACE_NAME)) magicmouth_face = RETVAL;
2483	}	2812	}
2484	OUTPUT: RETVAL	2813	OUTPUT: RETVAL
2485		2814
2486	void set (faceidx idx, int visibility, int magicmap)	2815	void set_type (faceidx idx, int value)
2487	CODE:	2816	ALIAS:
2488	faceinfo *f = face_info (idx);	2817	set_type = 0
2489	assert (f);	2818	set_visibility = 1
2490	f->visibility = visibility;	2819	set_magicmap = 2
2491	f->magicmap = magicmap;	2820	set_smooth = 3
2492		2821	set_smoothlevel = 4
2493	void set_smooth (faceidx idx, faceidx smooth, int smoothlevel)
2494	CODE:	2822	CODE:
2495	faceinfo *f = face_info (idx); assert (f);	2823	faceinfo *f = face_info (idx); assert (f);
2496	f->smooth = smooth;	2824	switch (ix)
2497	f->smoothlevel = smoothlevel;	2825	{
		2826	case 0: f->type = value; break;
		2827	case 1: f->visibility = value; break;
		2828	case 2: f->magicmap = value; break;
		2829	case 3: f->smooth = value; break;
		2830	case 4: f->smoothlevel = value; break;
		2831	}
2498		2832
2499	void set_data (faceidx idx, int faceset, SV data, SV chksum)	2833	void set_data (faceidx idx, int faceset, SV data, SV chksum)
2500	CODE:	2834	CODE:
2501	{	2835	{
2502	facedata *d = face_data (idx, faceset);	2836	faceinfo *f = face_info (idx); assert (f);
2503	assert (d);	2837	facedata *d = &(faceset ? f->data64 : f->data32);
2504	sv_to (data, d->data);	2838	sv_to (data, d->data);
2505	STRLEN clen;	2839	STRLEN clen;
2506	char *cdata = SvPVbyte (chksum, clen);	2840	char *cdata = SvPVbyte (chksum, clen);
2507	clen = min (CHKSUM_SIZE, clen);	2841	clen = min (CHKSUM_MAXLEN, clen);
2508		2842
		2843	assert (("cf::face::set_data must be called with a non-empty checksum", clen));
		2844
2509	if (memcmp (d->chksum, cdata, clen))	2845	if (clen != d->chksum_len \|\| memcmp (d->chksum, cdata, clen))
2510	{	2846	{
		2847	d->chksum_len = clen;
2511	memcpy (d->chksum, cdata, clen);	2848	memcpy (d->chksum, cdata, clen);
2512		2849
2513	// invalidate existing client face info	2850	// invalidate existing client face info
2514	for_all_clients (ns)	2851	for_all_clients (ns)
2515	if (ns->faceset == faceset)	2852	if (ns->faceset == faceset)
…		…
2518	ns->force_newmap = true;	2855	ns->force_newmap = true;
2519	}	2856	}
2520	}	2857	}
2521	}	2858	}
2522		2859
		2860	int get_data_size (faceidx idx, int faceset = 0)
		2861	CODE:
		2862	facedata *d = face_data (idx, faceset);
		2863	if (!d) XSRETURN_UNDEF;
		2864	RETVAL = d->data.size ();
		2865	OUTPUT:
		2866	RETVAL
		2867
		2868	SV *get_chksum (faceidx idx, int faceset = 0)
		2869	CODE:
		2870	facedata *d = face_data (idx, faceset);
		2871	if (!d) XSRETURN_UNDEF;
		2872	RETVAL = newSVpvn ((char *)d->chksum, d->chksum_len);
		2873	OUTPUT:
		2874	RETVAL
		2875
		2876	SV *get_data (faceidx idx, int faceset = 0)
		2877	CODE:
		2878	facedata *d = face_data (idx, faceset);
		2879	if (!d) XSRETURN_UNDEF;
		2880	RETVAL = newSVpvn (d->data.data (), d->data.length ());
		2881	OUTPUT:
		2882	RETVAL
		2883
2523	void invalidate (faceidx idx)	2884	void invalidate (faceidx idx)
2524	CODE:	2885	CODE:
2525	for_all_clients (ns)	2886	for_all_clients (ns)
2526	{	2887	{
2527	ns->faces_sent [idx] = false;	2888	ns->faces_sent [idx] = false;
…		…
2536	ns->force_newmap = true;	2897	ns->force_newmap = true;
2537	}	2898	}
2538		2899
2539	MODULE = cf PACKAGE = cf::anim PREFIX = anim_	2900	MODULE = cf PACKAGE = cf::anim PREFIX = anim_
2540		2901
2541	#INCLUDE: $PERL $srcdir/genacc faceset ../include/anim.h \|	2902	#INCLUDE: $PERL $srcdir/genacc faceset $srcdir/../include/anim.h \|
2542		2903
2543	animidx anim_find (utf8_string name)	2904	animidx anim_find (utf8_string name)
2544	CODE:	2905	CODE:
2545	RETVAL = animation::find (name).number;	2906	RETVAL = animation::find (name).number;
2546	OUTPUT: RETVAL	2907	OUTPUT: RETVAL
…		…
2561	}	2922	}
2562	else	2923	else
2563	anim = &animation::create (name, av_len (av) + 1, facings);	2924	anim = &animation::create (name, av_len (av) + 1, facings);
2564		2925
2565	for (int i = 0; i < anim->num_animations; ++i)	2926	for (int i = 0; i < anim->num_animations; ++i)
2566	anim->faces [i] = face_find (SvPVutf8_nolen (*av_fetch (av, i, 1)));	2927	anim->faces [i] = face_find (cfSvPVutf8_nolen (*av_fetch (av, i, 1)));
2567	}	2928	}
2568	OUTPUT: RETVAL	2929	OUTPUT: RETVAL
2569		2930
2570	void invalidate_all ()	2931	void invalidate_all ()
2571	CODE:	2932	CODE:
2572	for_all_clients (ns)	2933	for_all_clients (ns)
2573	ns->anims_sent.reset ();	2934	ns->anims_sent.reset ();
2574		2935
		2936	MODULE = cf PACKAGE = cf::object::freezer
		2937
		2938	INCLUDE: $PERL $srcdir/genacc object_freezer $srcdir/../include/cfperl.h \|
		2939
		2940	SV *
		2941	new (char *klass)
		2942	CODE:
		2943	RETVAL = newSVptr (new object_freezer, gv_stashpv ("cf::object::freezer", 1));
		2944	OUTPUT: RETVAL
		2945
		2946	void
		2947	DESTROY (SV *sv)
		2948	CODE:
		2949	object_freezer *self;
		2950	sv_to (sv, self);
		2951	delete self;
		2952
		2953	MODULE = cf PACKAGE = cf::object::thawer
		2954
		2955	INCLUDE: $PERL $srcdir/genacc object_thawer $srcdir/../include/cfperl.h \|
		2956
		2957	SV *
		2958	new_from_file (char *klass, octet_string path)
		2959	CODE:
		2960	object_thawer *f = new object_thawer (path);
		2961	if (!*f)
		2962	{
		2963	delete f;
		2964	XSRETURN_UNDEF;
		2965	}
		2966	RETVAL = newSVptr (f, gv_stashpv ("cf::object::thawer", 1));
		2967	OUTPUT: RETVAL
		2968
		2969	void
		2970	DESTROY (SV *sv)
		2971	CODE:
		2972	object_thawer *self;
		2973	sv_to (sv, self);
		2974	delete self;
		2975
		2976	void
		2977	extract_tags (object_thawer *self)
		2978	PPCODE:
		2979	while (self->kw != KW_EOF)
		2980	{
		2981	PUTBACK;
		2982	coroapi::cede_to_tick ();
		2983	SPAGAIN;
		2984
		2985	if (self->kw == KW_tag)
		2986	XPUSHs (sv_2mortal (newSVpv_utf8 (self->get_str ())));
		2987
		2988	self->skip ();
		2989	}
		2990

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.210 by root, Sat May 19 00:08:12 2007 UTC vs. Revision 1.371 by root, Thu Apr 15 02:51:39 2010 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.210 by root, Sat May 19 00:08:12 2007 UTC vs.
Revision 1.371 by root, Thu Apr 15 02:51:39 2010 UTC