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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.237 by root, Mon Jul 23 23:46:03 2007 UTC vs.
Revision 1.375 by root, Sun Apr 18 05:08:14 2010 UTC

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

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.237 by root, Mon Jul 23 23:46:03 2007 UTC vs. Revision 1.375 by root, Sun Apr 18 05:08:14 2010 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.237 by root, Mon Jul 23 23:46:03 2007 UTC vs.
Revision 1.375 by root, Sun Apr 18 05:08:14 2010 UTC