ViewVC Help

View File | Revision Log | Show Annotations | Download File

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

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.246 by root, Thu Aug 30 07:28:25 2007 UTC vs.
Revision 1.302 by root, Mon Sep 22 23:57:48 2008 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 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2001-2005,2007 by Chachkoff Yann	5	* Copyright (©) 2001-2005,2007 by Chachkoff Yann
6	* Copyright (©) 2006,2007 by Marc Lehmann <cf@schmorp.de>	6	* Copyright (©) 2006,2007 by Marc Lehmann <cf@schmorp.de>
7	*	7	*
8	* Crossfire TRT is free software: you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
10	* the Free Software Foundation, either version 3 of the License, or	10	* the Free Software Foundation, either version 3 of the License, or
11	* (at your option) any later version.	11	* (at your option) any later version.
12	*	12	*
13	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
…		…
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
19	* along with this program. If not, see <http://www.gnu.org/licenses/>.	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
20	*	20	*
21	* The authors can be reached via e-mail to <crossfire@schmorp.de>	21	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	22	*/
23		23
24	#include "autoconf.h"	24	#include "autoconf.h"
25
26	#define PLUGIN_NAME "perl"
27	#define PLUGIN_VERSION "cfperl 0.5"
28
29	#define CEDES_PER_TICK 5
30		25
31	#if HAVE_EXECINFO_H	26	#if HAVE_EXECINFO_H
32	# include <execinfo.h>	27	# include <execinfo.h>
33	#endif	28	#endif
34		29
35	#include <plugin_common.h>
36	#include <sounds.h>
37	#include <cstdarg>	30	#include <cstdarg>
38	#include <sproto.h>	31	#include <typeinfo>
39		32
		33	#include "global.h"
40	#include "loader.h"	34	#include "loader.h"
		35	#include "../random_maps/random_map.h"
41	#include "cfperl.h"	36	#include "evthread.h"
42	#include "shstr.h"	37	#include "sproto.h"
43		38
44	#include <unistd.h>	39	#include <unistd.h>
45	#if _POSIX_MEMLOCK	40	#if _POSIX_MEMLOCK
46	# include <sys/mman.h>	41	# include <sys/mman.h>
47	#endif	42	#endif
48		43
		44	#if HAVE_MALLOC_H
		45	# include <malloc.h>
		46	#endif
		47
		48	#if !__GLIBC__
		49	# define malloc_trim(pad) -1
		50	#endif
		51
49	#include <EXTERN.h>	52	#include <EXTERN.h>
50	#include <perl.h>	53	#include <perl.h>
51	#include <XSUB.h>	54	#include <XSUB.h>
52		55
53	#include "CoroAPI.h"	56	#include "CoroAPI.h"
54	#include "perlxsi.c"	57	#include "perlxsi.c"
55		58
56	extern sint64 *levels; // the experience table	59	extern sint64 *levels; // the experience table
57		60
58	typedef object object_ornull;	61	typedef object_thawer &object_thawer_ref;
59	typedef maptile maptile_ornull;	62	typedef object_freezer &object_freezer_ref;
60
61	typedef char *octet_string;
62	typedef char *utf8_string;
63	typedef const char *const_octet_string;
64	typedef const char *const_utf8_string;
65		63
66	typedef std::string std__string;	64	typedef std::string std__string;
67		65
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;	66	static PerlInterpreter *perl;
82		67
83	tstamp NOW, runtime;	68	tstamp NOW, runtime;
		69
		70	static int tick_inhibit;
		71	static int tick_pending;
84		72
85	global gbl_ev;	73	global gbl_ev;
86	static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map;	74	static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map;
87	static SV *sv_runtime, *sv_next_tick;	75	static SV *sv_runtime, *sv_tick_start, *sv_next_tick, *sv_now;
88		76
89	bitset<NUM_EVENT_TYPES> ev_want_event;	77	bitset<NUM_EVENT_TYPES> ev_want_event;
90	bitset<NUM_TYPES> ev_want_type;	78	bitset<NUM_TYPES> ev_want_type;
91		79
92	static HV	80	static HV
93	*stash_cf,	81	*stash_cf,
94	*stash_cf_object_wrap,	82	*stash_cf_object_wrap,
95	*stash_cf_object_player_wrap,	83	*stash_cf_object_player_wrap,
96	*stash_cf_player_wrap,	84	*stash_cf_player_wrap,
97	*stash_cf_map_wrap,	85	*stash_cf_map_wrap,
		86	*stash_cf_mapspace_wrap,
98	*stash_cf_client_wrap,	87	*stash_cf_client_wrap,
99	*stash_cf_arch_wrap,	88	*stash_cf_arch_wrap,
100	*stash_cf_party_wrap,	89	*stash_cf_party_wrap,
101	*stash_cf_region_wrap,	90	*stash_cf_region_wrap,
102	*stash_cf_living_wrap;	91	*stash_cf_living_wrap;
103		92
104	static inline SV *	93	static inline SV *
105	newSVpv_utf8 (const char *s)	94	newSVpv_utf8 (const char *s)
106	{	95	{
		96	if (!s)
		97	return newSV (0);
		98
107	SV *sv = newSVpv (s, 0);	99	SV *sv = newSVpv (s, 0);
108	SvUTF8_on (sv);	100	SvUTF8_on (sv);
109	return sv;	101	return sv;
110	}	102	}
111		103
112	static inline SV *	104	static inline SV *
113	newSVpvn_utf8 (const char *s, STRLEN l)	105	newSVpvn_utf8 (const char *s, STRLEN l)
114	{	106	{
		107	if (!s)
		108	return newSV (0);
		109
115	SV *sv = newSVpvn (s, l);	110	SV *sv = newSVpvn (s, l);
116	SvUTF8_on (sv);	111	SvUTF8_on (sv);
117	return sv;	112	return sv;
118	}	113	}
119		114
…		…
326	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())	321	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())
327	{	322	{
328	SV *sv;	323	SV *sv;
329		324
330	if (!ptr)	325	if (!ptr)
331	return &PL_sv_undef;	326	return newSV (0);
332		327
333	sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);	328	sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);
334	return sv_bless (newRV_noinc ((SV *)hv), stash);	329	return sv_bless (newRV_noinc ((SV *)hv), stash);
335	}	330	}
336		331
…		…
355		350
356	static SV *	351	static SV *
357	newSVattachable (attachable *obj, HV *stash)	352	newSVattachable (attachable *obj, HV *stash)
358	{	353	{
359	if (!obj)	354	if (!obj)
360	return &PL_sv_undef;	355	return newSV (0);
361		356
362	if (!obj->self)	357	if (!obj->self)
363	obj->self = newHV ();	358	obj->self = newHV ();
364		359
365	if (!SvOBJECT (obj->self))	360	if (!SvOBJECT (obj->self))
…		…
412	return SvPTR (sv, klass);	407	return SvPTR (sv, klass);
413	else	408	else
414	return 0;	409	return 0;
415	}	410	}
416		411
417	inline SV *to_sv (const shstr & v) { return v ? newSVpvn_utf8 ((const char *)v, v.length ()) : &PL_sv_undef; }	412	inline SV *to_sv (const shstr & v) { return newSVpvn_utf8 ((const char *)v, v.length ()); }
418	inline SV *to_sv (const char * v) { return newSVpv (v, 0); }	413	inline SV *to_sv (const char * v) { return v ? newSVpv (v, 0) : newSV (0); }
419	inline SV *to_sv (bool v) { return newSViv (v); }	414	inline SV *to_sv (bool v) { return newSViv (v); }
420	inline SV *to_sv ( signed char v) { return newSViv (v); }	415	inline SV *to_sv ( signed char v) { return newSViv (v); }
421	inline SV *to_sv (unsigned char v) { return newSViv (v); }	416	inline SV *to_sv (unsigned char v) { return newSViv (v); }
422	inline SV *to_sv ( signed short v) { return newSViv (v); }	417	inline SV *to_sv ( signed short v) { return newSViv (v); }
423	inline SV *to_sv (unsigned short v) { return newSVuv (v); }	418	inline SV *to_sv (unsigned short v) { return newSVuv (v); }
…		…
435	inline SV *to_sv (maptile * v) { return newSVattachable (v, stash_cf_map_wrap); }	430	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); }	431	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); }	432	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); }	433	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); }	434	inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }
		435	inline SV *to_sv (mapspace * v) { return newSVptr (v, stash_cf_mapspace_wrap); }
440		436
441	inline SV *to_sv (object & v) { return to_sv (&v); }	437	inline SV *to_sv (object & v) { return to_sv (&v); }
442	inline SV *to_sv (living & v) { return to_sv (&v); }	438	inline SV *to_sv (living & v) { return to_sv (&v); }
443		439
444	inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); }	440	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); }	441	inline SV *to_sv (const treasurelist *v) { return to_sv (v->name); }
446		442
		443	inline SV *to_sv (UUID v) { return newSVpv (v.c_str (), 0); }
		444
447	inline SV *to_sv (UUID v)	445	inline SV *to_sv (dynbuf * v)
448	{	446	{
449	char buf[128];	447	SV *sv = newSV (0);
450	snprintf (buf, 128, "<1.%" PRIx64 ">", v.seq);
451	return newSVpv (buf, 0);
452	}
453		448
		449	sv_upgrade (sv, SVt_PV);
		450	SvGROW (sv, v->size () + 1);
		451	SvPOK_only (sv);
		452	v->linearise (SvPVX (sv));
		453	SvCUR_set (sv, v->size ());
		454	*SvEND (sv) = 0;
		455
		456	return sv;
		457	}
		458
		459	inline SV *to_sv (dynbuf_text * v)
		460	{
		461	SV *sv = to_sv (static_cast<dynbuf *> (v));
		462	SvUTF8_on (sv);
		463	return sv;
		464	}
		465
454	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPVutf8_nolen (sv) : 0; }	466	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPVutf8_nolen (sv) : 0; }
455	inline void sv_to (SV *sv, char * &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }	467	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); }	468	inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }
457	inline void sv_to (SV *sv, signed char &v) { v = SvIV (sv); }	469	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); }	470	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); }	471	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); }	472	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); }	473	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); }	474	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); }	475	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); }	476	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); }	477	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); }	478	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); }	479	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
468	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }	480	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"); }	481	inline void sv_to (SV *sv, client * &v) { v = (client *)(attachable *)SvPTR_ornull (sv, "cf::client"); }
470	inline void sv_to (SV *sv, player * &v) { v = (player *)(attachable *)SvPTR_ornull (sv, "cf::player"); }	482	inline void sv_to (SV *sv, player * &v) { v = (player *)(attachable *)SvPTR_ornull (sv, "cf::player"); }
471	inline void sv_to (SV *sv, object * &v) { v = (object *)(attachable *)SvPTR_ornull (sv, "cf::object"); }	483	inline void sv_to (SV *sv, object * &v) { v = (object *)(attachable *)SvPTR_ornull (sv, "cf::object"); }
472	inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)(attachable *)SvPTR_ornull (sv, "cf::arch"); }	484	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"); }	485	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"); }	486	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"); }	487	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"); }	488	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"); }	489	inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }
		490	inline void sv_to (SV *sv, mapspace * &v) { v = (mapspace *)SvPTR_ornull (sv, "cf::mapspace"); }
		491	inline void sv_to (SV *sv, object_freezer * &v) { v = (object_freezer *)SvPTR_ornull (sv, "cf::object::freezer"); }
		492	inline void sv_to (SV *sv, object_thawer * &v) { v = (object_thawer *)SvPTR_ornull (sv, "cf::object::thawer" ); }
478		493
479	//inline void sv_to (SV *sv, faceinfo * &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }	494	//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)); }	495	inline void sv_to (SV *sv, treasurelist * &v) { v = treasurelist::find (SvPV_nolen (sv)); }
481		496
482	template<class T>	497	template<class T>
483	inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }	498	inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }
484		499
485	template<int N>	500	template<int N>
486	inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); }	501	inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); }
487		502
488	inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); }	503	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); }	504	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); }	505	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); }	506	inline void sv_to (SV *sv, unapplymode &v) { v = (unapplymode) SvIV (sv); }
492		507
493	inline void sv_to (SV *sv, std::string &v)	508	inline void sv_to (SV *sv, std::string &v)
494	{	509	{
495	STRLEN len;	510	STRLEN len;
496	char *data = SvPVbyte (sv, len);	511	char *data = SvPVbyte (sv, len);
497	v.assign (data, len);	512	v.assign (data, len);
498	}	513	}
499		514
500	inline void sv_to (SV *sv, UUID &v)	515	inline void sv_to (SV *sv, UUID &v)
501	{	516	{
502	unsigned int version;	517	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));	518	croak ("unparsable uuid: %s", SvPV_nolen (sv));
506	}	519	}
507		520
508	inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }	521	inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }
509		522
…		…
527	break;	540	break;
528		541
529	case DT_STRING:	542	case DT_STRING:
530	{	543	{
531	char *str = (char *)va_arg (ap, const char *);	544	char *str = (char *)va_arg (ap, const char *);
532	sv = str ? newSVpv (str, 0) : &PL_sv_undef;	545	sv = str ? newSVpv (str, 0) : newSV (0);
533	}	546	}
534	break;	547	break;
535		548
536	case DT_DATA:	549	case DT_DATA:
537	{	550	{
538	char *str = (char *)va_arg (ap, const void *);	551	char *str = (char *)va_arg (ap, const void *);
539	int len = va_arg (ap, int);	552	int len = va_arg (ap, int);
540	sv = str ? newSVpv (str, len) : &PL_sv_undef;	553	sv = str ? newSVpv (str, len) : newSV (0);
541	}	554	}
542	break;	555	break;
543		556
544	case DT_OBJECT:	557	case DT_OBJECT:
545	sv = to_sv (va_arg (ap, object *));	558	sv = to_sv (va_arg (ap, object *));
…		…
587	va_end (ap);	600	va_end (ap);
588		601
589	return sv;	602	return sv;
590	}	603	}
591		604
592	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	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	605	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
623		606
624	SV *	607	SV *
625	registry (attachable *ext)	608	registry (attachable *ext)
626	{	609	{
…		…
630	return newRV_inc ((SV *)ext->cb);	613	return newRV_inc ((SV *)ext->cb);
631	}	614	}
632		615
633	/////////////////////////////////////////////////////////////////////////////	616	/////////////////////////////////////////////////////////////////////////////
634		617
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	618	void
691	cfperl_init ()	619	cfperl_init ()
692	{	620	{
		621	extern char **environ;
		622
693	PERL_SYS_INIT3 (&settings.argc, &settings.argv, 0);	623	PERL_SYS_INIT3 (&settings.argc, &settings.argv, &environ);
694	perl = perl_alloc ();	624	perl = perl_alloc ();
695	perl_construct (perl);	625	perl_construct (perl);
696		626
697	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;	627	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
698		628
699	const char *argv[] = {	629	const char *argv[] = {
700	settings.argv [0],	630	settings.argv [0],
701	"-e"	631	"-e"
702	"use Event; use Coro;" // required for bootstrap	632	"use EV; use Coro;" // required for bootstrap
703	"cf->bootstrap;" // required for datadir :*>	633	"cf->bootstrap;" // required for datadir :*>
704	"unshift @INC, cf::datadir ();"	634	"unshift @INC, cf::datadir ();"
705	"require cf;"	635	"require cf;"
706	};	636	};
707		637
708	if (perl_parse (perl, xs_init, 2, (char **)argv, (char **)NULL)	638	if (perl_parse (perl, xs_init, 2, (char **)argv, environ)
709	|| perl_run (perl))	639	|| perl_run (perl))
710	{	640	{
711	printf ("unable to initialize perl-interpreter, aborting.\n");	641	printf ("unable to initialize perl-interpreter, aborting.\n");
712	exit (EXIT_FAILURE);	642	exit (EXIT_FAILURE);
713	}	643	}
…		…
988	{	918	{
989	return SvNV (cfperl_result (idx));	919	return SvNV (cfperl_result (idx));
990	}	920	}
991		921
992	/////////////////////////////////////////////////////////////////////////////	922	/////////////////////////////////////////////////////////////////////////////
		923	// various c++ => perl glue functions
		924
		925	void cfperl_tick ()
		926	{
		927	tick_pending = 1;
		928
		929	if (tick_inhibit)
		930	return;
		931
		932	tick_pending = 0;
		933
		934	dSP;
		935
		936	PUSHMARK (SP);
		937	PUTBACK;
		938	call_pv ("cf::tick", G_DISCARD | G_VOID);
		939
		940	SvNV_set (sv_next_tick, get_next_tick ()); SvNOK_only (sv_next_tick);
		941	}
993		942
994	void	943	void
995	cfperl_emergency_save ()	944	cfperl_emergency_save ()
996	{	945	{
997	CALL_BEGIN (0);	946	CALL_BEGIN (0);
…		…
1050	{	999	{
1051	CALL_BEGIN (1);	1000	CALL_BEGIN (1);
1052	CALL_ARG (name);	1001	CALL_ARG (name);
1053	CALL_CALL ("cf::player::find", G_SCALAR);	1002	CALL_CALL ("cf::player::find", G_SCALAR);
1054		1003
1055	player *retval;	1004	player *retval = 0;
1056
1057	if (count)
1058	sv_to (POPs, retval);	1005	if (count) sv_to (POPs, retval);
1059	else	1006
1060	retval = 0;	1007	CALL_END;
		1008
		1009	return retval;
		1010	}
		1011
		1012	maptile *
		1013	find_style (const char *dirname, const char *stylename, int difficulty)
		1014	{
		1015	CALL_BEGIN (3);
		1016	CALL_ARG (dirname);
		1017	CALL_ARG (stylename);
		1018	CALL_ARG (difficulty);
		1019	CALL_CALL ("ext::map_random::find_style", G_SCALAR);
		1020
		1021	maptile *retval = 0;
		1022	if (count) sv_to (POPs, retval);
1061		1023
1062	CALL_END;	1024	CALL_END;
1063		1025
1064	return retval;	1026	return retval;
1065	}	1027	}
…		…
1070	CALL_BEGIN (2);	1032	CALL_BEGIN (2);
1071	CALL_ARG (path);	1033	CALL_ARG (path);
1072	CALL_ARG (origin);	1034	CALL_ARG (origin);
1073	CALL_CALL ("cf::map::find_sync", G_SCALAR);	1035	CALL_CALL ("cf::map::find_sync", G_SCALAR);
1074		1036
1075	maptile *retval;	1037	maptile *retval = 0;
1076
1077	if (count)
1078	sv_to (POPs, retval);	1038	if (count) sv_to (POPs, retval);
1079	else
1080	retval = 0;
1081		1039
1082	CALL_END;	1040	CALL_END;
1083		1041
1084	return retval;	1042	return retval;
1085	}	1043	}
…		…
1091	CALL_ARG (path);	1049	CALL_ARG (path);
1092	CALL_ARG (origin);	1050	CALL_ARG (origin);
1093	CALL_ARG (load);	1051	CALL_ARG (load);
1094	CALL_CALL ("cf::map::find_async", G_SCALAR);	1052	CALL_CALL ("cf::map::find_async", G_SCALAR);
1095		1053
1096	maptile *retval;	1054	maptile *retval = 0;
1097
1098	if (count)
1099	sv_to (POPs, retval);	1055	if (count) sv_to (POPs, retval);
1100	else
1101	retval = 0;
1102		1056
1103	CALL_END;	1057	CALL_END;
1104		1058
1105	return retval;	1059	return retval;
1106	}	1060	}
…		…
1132	CALL_BEGIN (2);	1086	CALL_BEGIN (2);
1133	CALL_ARG (this);	1087	CALL_ARG (this);
1134	CALL_ARG (exit);	1088	CALL_ARG (exit);
1135	CALL_CALL ("cf::object::player::enter_exit", G_VOID);	1089	CALL_CALL ("cf::object::player::enter_exit", G_VOID);
1136	CALL_END;	1090	CALL_END;
		1091	}
		1092
		1093	void
		1094	object::player_goto (const char *path, int x, int y)
		1095	{
		1096	if (type != PLAYER)
		1097	return;
		1098
		1099	CALL_BEGIN (4);
		1100	CALL_ARG (this);
		1101	CALL_ARG (path);
		1102	CALL_ARG (x);
		1103	CALL_ARG (y);
		1104	CALL_CALL ("cf::object::player::goto", G_VOID);
		1105	CALL_END;
		1106	}
		1107
		1108	const char *
		1109	object::ref () const
		1110	{
		1111	if (type == PLAYER)
		1112	return format ("player/<1.%llx>/%s", (unsigned long long)uuid.seq, &name);
		1113	else
		1114	return 0;
		1115	}
		1116
		1117	object *
		1118	object::deref (const char *ref)
		1119	{
		1120	object *retval = 0;
		1121
		1122	if (ref)
		1123	{
		1124	CALL_BEGIN (1);
		1125	CALL_ARG (ref);
		1126	CALL_CALL ("cf::object::deref", G_SCALAR);
		1127
		1128	if (count)
		1129	sv_to (POPs, retval);
		1130
		1131	CALL_END;
		1132	}
		1133
		1134	return retval;
1137	}	1135	}
1138		1136
1139	void	1137	void
1140	log_backtrace (const char *msg)	1138	log_backtrace (const char *msg)
1141	{	1139	{
…		…
1152	#endif	1150	#endif
1153	}	1151	}
1154		1152
1155	/////////////////////////////////////////////////////////////////////////////	1153	/////////////////////////////////////////////////////////////////////////////
1156		1154
1157	struct EventAPI *watcher_base::GEventAPI;	1155	struct EVAPI *evapi::GEVAPI;
1158	struct CoroAPI *coroapi::GCoroAPI;	1156	struct CoroAPI *coroapi::GCoroAPI;
1159
1160	int coroapi::cede_counter;
1161	tstamp coroapi::next_cede;
1162		1157
1163	void coroapi::do_cede_to_tick ()	1158	void coroapi::do_cede_to_tick ()
1164	{	1159	{
1165	cede_counter = 0;	1160	cede_pending = 0;
1166
1167	cede ();	1161	cede ();
1168
1169	next_cede += (TICK / CEDES_PER_TICK) * 0.99;
1170	if (next_cede > SvNV (sv_next_tick) - 0.02)
1171	next_cede = SvNV (sv_next_tick);
1172	}
1173
1174	void coroapi::do_cede_every ()
1175	{
1176	cede_counter = 0;
1177
1178	if (coroapi::nready ())
1179	coroapi::cede ();
1180	}
1181
1182	void coroapi::do_cede_to_tick_every ()
1183	{
1184	cede_counter = 0;
1185
1186	cede_to_tick ();
1187	}	1162	}
1188		1163
1189	void	1164	void
1190	coroapi::wait_for_tick ()	1165	coroapi::wait_for_tick ()
1191	{	1166	{
…		…
1200	CALL_BEGIN (0);	1175	CALL_BEGIN (0);
1201	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);	1176	CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);
1202	CALL_END;	1177	CALL_END;
1203	}	1178	}
1204		1179
1205	static void
1206	iw_dispatch (pe_event *ev)
1207	{
1208	iw *w = (iw *)ev->ext_data;
1209	w->call (*w);
1210	}
1211
1212	void
1213	iw::alloc ()
1214	{
1215	pe = GEventAPI->new_idle (0, 0);
1216
1217	WaREENTRANT_off (pe);
1218	pe->base.callback = (void *)iw_dispatch;
1219	pe->base.ext_data = (void *)this;
1220	}
1221
1222	static void iow_dispatch (pe_event *ev)
1223	{
1224	iow *w = (iow *)ev->ext_data;
1225	w->call (*w, ((pe_ioevent *)ev)->got);
1226	}
1227
1228	void
1229	iow::alloc ()
1230	{
1231	pe = GEventAPI->new_io (0, 0);
1232
1233	WaREENTRANT_off (pe);
1234	pe->base.callback = (void *)iow_dispatch;
1235	pe->base.ext_data = (void *)this;
1236
1237	pe->fd = -1;
1238	pe->poll = 0;
1239	}
1240
1241	void
1242	iow::fd (int fd)
1243	{
1244	pe->fd = fd;
1245	}
1246
1247	int
1248	iow::poll ()
1249	{
1250	return pe->poll;
1251	}
1252
1253	void	1180	void
1254	iow::poll (int events)	1181	iow::poll (int events)
1255	{	1182	{
1256	if (pe->poll != events)	1183	if (events != this->events)
1257	{	1184	{
		1185	int active = ev_is_active ((ev_io *)this);
1258	if (pe->poll) stop ();	1186	if (active) stop ();
1259	pe->poll = events;	1187	ev_io_set ((ev_io *)this, fd, events);
1260	if (pe->poll) start ();	1188	if (active) start ();
1261	}	1189	}
1262	}	1190	}
1263		1191
1264	void	1192	void
1265	_connect_to_perl ()	1193	_connect_to_perl ()
1266	{	1194	{
1267	stash_cf = gv_stashpv ("cf" , 1);	1195	stash_cf = gv_stashpv ("cf", 1);
1268		1196
1269	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);	1197	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);
1270	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);	1198	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);
1271	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);	1199	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);
1272	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);	1200	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);
		1201	stash_cf_mapspace_wrap = gv_stashpv ("cf::mapspace::wrap" , 1);
1273	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);	1202	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);
1274	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);	1203	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
1275	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);	1204	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
1276	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);	1205	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
1277	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);	1206	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
1278		1207
		1208	sv_now = get_sv ("cf::NOW" , 1); SvUPGRADE (sv_now , SVt_NV);
1279	sv_runtime = get_sv ("cf::RUNTIME" , 1); sv_upgrade (sv_runtime , SVt_NV);	1209	sv_runtime = get_sv ("cf::RUNTIME" , 1); SvUPGRADE (sv_runtime , SVt_NV);
		1210	sv_tick_start = get_sv ("cf::TICK_START", 1); SvUPGRADE (sv_tick_start, SVt_NV);
1280	sv_next_tick = get_sv ("cf::NEXT_TICK", 1); sv_upgrade (sv_next_tick, SVt_NV);	1211	sv_next_tick = get_sv ("cf::NEXT_TICK" , 1); SvUPGRADE (sv_next_tick , SVt_NV);
1281		1212
1282	cb_global = get_av ("cf::CB_GLOBAL", 1);	1213	cb_global = get_av ("cf::CB_GLOBAL", 1);
1283	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);	1214	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
1284	cb_object = get_av ("cf::CB_OBJECT", 1);	1215	cb_object = get_av ("cf::CB_OBJECT", 1);
1285	cb_player = get_av ("cf::CB_PLAYER", 1);	1216	cb_player = get_av ("cf::CB_PLAYER", 1);
…		…
1290		1221
1291	MODULE = cf PACKAGE = cf PREFIX = cf_	1222	MODULE = cf PACKAGE = cf PREFIX = cf_
1292		1223
1293	BOOT:	1224	BOOT:
1294	{	1225	{
1295	I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;	1226	I_EV_API (PACKAGE); evapi::GEVAPI = GEVAPI;
1296	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;	1227	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
1297		1228
1298	_connect_to_perl ();	1229	_connect_to_perl ();
1299		1230
1300	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));	1231	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
1301		1232
…		…
1319	const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)	1250	const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)
1320		1251
1321	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)	1252	const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)
1322		1253
1323	const_iv (MAX_TIME)	1254	const_iv (MAX_TIME)
		1255	const_iv (MAXSOCKBUF)
1324		1256
1325	const_iv (NUM_BODY_LOCATIONS)	1257	const_iv (NUM_BODY_LOCATIONS)
1326	const_iv (body_range) const_iv (body_shield) const_iv (body_combat)	1258	const_iv (body_range) const_iv (body_shield) const_iv (body_combat)
1327	const_iv (body_arm) const_iv (body_torso) const_iv (body_head)	1259	const_iv (body_arm) const_iv (body_torso) const_iv (body_head)
1328	const_iv (body_neck) const_iv (body_skill) const_iv (body_finger)	1260	const_iv (body_neck) const_iv (body_skill) const_iv (body_finger)
…		…
1394	const_iv (FLAG_CURSED) const_iv (FLAG_DAMNED) const_iv (FLAG_SEE_ANYWHERE) const_iv (FLAG_KNOWN_MAGICAL)	1326	const_iv (FLAG_CURSED) const_iv (FLAG_DAMNED) const_iv (FLAG_SEE_ANYWHERE) const_iv (FLAG_KNOWN_MAGICAL)
1395	const_iv (FLAG_KNOWN_CURSED) const_iv (FLAG_CAN_USE_SKILL) const_iv (FLAG_BEEN_APPLIED) const_iv (FLAG_READY_SCROLL)	1327	const_iv (FLAG_KNOWN_CURSED) const_iv (FLAG_CAN_USE_SKILL) const_iv (FLAG_BEEN_APPLIED) const_iv (FLAG_READY_SCROLL)
1396	const_iv (FLAG_USE_ROD) const_iv (FLAG_USE_HORN) const_iv (FLAG_MAKE_INVIS) const_iv (FLAG_INV_LOCKED)	1328	const_iv (FLAG_USE_ROD) const_iv (FLAG_USE_HORN) const_iv (FLAG_MAKE_INVIS) const_iv (FLAG_INV_LOCKED)
1397	const_iv (FLAG_IS_WOODED) const_iv (FLAG_IS_HILLY) const_iv (FLAG_READY_SKILL) const_iv (FLAG_READY_WEAPON)	1329	const_iv (FLAG_IS_WOODED) const_iv (FLAG_IS_HILLY) const_iv (FLAG_READY_SKILL) const_iv (FLAG_READY_WEAPON)
1398	const_iv (FLAG_NO_SKILL_IDENT) const_iv (FLAG_BLIND) const_iv (FLAG_SEE_IN_DARK) const_iv (FLAG_IS_CAULDRON)	1330	const_iv (FLAG_NO_SKILL_IDENT) const_iv (FLAG_BLIND) const_iv (FLAG_SEE_IN_DARK) const_iv (FLAG_IS_CAULDRON)
1399	const_iv (FLAG_NO_STEAL) const_iv (FLAG_ONE_HIT) const_iv (FLAG_CLIENT_SENT) const_iv (FLAG_BERSERK)	1331	const_iv (FLAG_NO_STEAL) const_iv (FLAG_ONE_HIT) const_iv (FLAG_DEBUG) const_iv (FLAG_BERSERK)
1400	const_iv (FLAG_NEUTRAL) const_iv (FLAG_NO_ATTACK) const_iv (FLAG_NO_DAMAGE) const_iv (FLAG_OBJ_ORIGINAL)	1332	const_iv (FLAG_NEUTRAL) const_iv (FLAG_NO_ATTACK) const_iv (FLAG_NO_DAMAGE) const_iv (FLAG_OBJ_ORIGINAL)
1401	const_iv (FLAG_ACTIVATE_ON_PUSH) const_iv (FLAG_ACTIVATE_ON_RELEASE) const_iv (FLAG_IS_WATER)	1333	const_iv (FLAG_ACTIVATE_ON_PUSH) const_iv (FLAG_ACTIVATE_ON_RELEASE) const_iv (FLAG_IS_WATER)
1402	const_iv (FLAG_CONTENT_ON_GEN) const_iv (FLAG_IS_A_TEMPLATE) const_iv (FLAG_IS_BUILDABLE)	1334	const_iv (FLAG_CONTENT_ON_GEN) const_iv (FLAG_IS_A_TEMPLATE) const_iv (FLAG_IS_BUILDABLE)
1403	const_iv (FLAG_DESTROY_ON_DEATH) const_iv (FLAG_NO_MAP_SAVE)	1335	const_iv (FLAG_DESTROY_ON_DEATH) const_iv (FLAG_NO_MAP_SAVE)
1404		1336
1405	const_iv (NDI_BLACK) const_iv (NDI_WHITE) const_iv (NDI_NAVY) const_iv (NDI_RED)	1337	const_iv (NDI_BLACK) const_iv (NDI_WHITE) const_iv (NDI_NAVY) const_iv (NDI_RED)
1406	const_iv (NDI_ORANGE) const_iv (NDI_BLUE) const_iv (NDI_DK_ORANGE) const_iv (NDI_GREEN)	1338	const_iv (NDI_ORANGE) const_iv (NDI_BLUE) const_iv (NDI_DK_ORANGE) const_iv (NDI_GREEN)
1407	const_iv (NDI_LT_GREEN) const_iv (NDI_GREY) const_iv (NDI_BROWN) const_iv (NDI_GOLD)	1339	const_iv (NDI_LT_GREEN) const_iv (NDI_GREY) const_iv (NDI_BROWN) const_iv (NDI_GOLD)
1408	const_iv (NDI_TAN) const_iv (NDI_MAX_COLOR) const_iv (NDI_COLOR_MASK) const_iv (NDI_UNIQUE)	1340	const_iv (NDI_TAN) const_iv (NDI_MAX_COLOR) const_iv (NDI_COLOR_MASK) const_iv (NDI_UNIQUE)
1409	const_iv (NDI_ALL) const_iv (NDI_DEF) const_iv (NDI_REPLY) const_iv (NDI_CLIENT_MASK)	1341	const_iv (NDI_ALL) const_iv (NDI_DEF) const_iv (NDI_REPLY) const_iv (NDI_CLIENT_MASK)
1410	const_iv (NDI_NOCREATE)	1342	const_iv (NDI_NOCREATE) const_iv (NDI_CLEAR) const_iv (NDI_VERBATIM)
1411		1343
1412	const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE)	1344	const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE)
1413	const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF)	1345	const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF)
1414		1346
1415	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_DAMAGE)	1347	const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_DAMAGE)
…		…
1467	const_iv (F_CURSED) const_iv (F_DAMNED) const_iv (F_OPEN) const_iv (F_NOPICK)	1399	const_iv (F_CURSED) const_iv (F_DAMNED) const_iv (F_OPEN) const_iv (F_NOPICK)
1468	const_iv (F_LOCKED)	1400	const_iv (F_LOCKED)
1469		1401
1470	const_iv (F_BUY) const_iv (F_SHOP) const_iv (F_SELL)	1402	const_iv (F_BUY) const_iv (F_SHOP) const_iv (F_SELL)
1471		1403
1472	const_iv (P_BLOCKSVIEW) const_iv (P_PLAYER) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE)	1404	const_iv (P_BLOCKSVIEW) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE)
1473	const_iv (P_NO_CLERIC) const_iv (P_OUT_OF_MAP) const_iv (P_NEW_MAP) const_iv (P_UPTODATE)	1405	const_iv (P_NO_CLERIC) const_iv (P_OUT_OF_MAP) const_iv (P_NEW_MAP) const_iv (P_UPTODATE)
1474		1406
1475	const_iv (UP_OBJ_INSERT) const_iv (UP_OBJ_REMOVE) const_iv (UP_OBJ_CHANGE) const_iv (UP_OBJ_FACE)	1407	const_iv (UP_OBJ_INSERT) const_iv (UP_OBJ_REMOVE) const_iv (UP_OBJ_CHANGE) const_iv (UP_OBJ_FACE)
1476		1408
1477	const_iv (INS_NO_MERGE) const_iv (INS_ABOVE_FLOOR_ONLY) const_iv (INS_NO_WALK_ON)	1409	const_iv (INS_NO_MERGE) const_iv (INS_ABOVE_FLOOR_ONLY) const_iv (INS_NO_WALK_ON)
1478	const_iv (INS_ON_TOP) const_iv (INS_BELOW_ORIGINATOR) const_iv (INS_MAP_LOAD)	1410	const_iv (INS_ON_TOP) const_iv (INS_BELOW_ORIGINATOR)
1479		1411
1480	const_iv (WILL_APPLY_HANDLE) const_iv (WILL_APPLY_TREASURE) const_iv (WILL_APPLY_EARTHWALL)	1412	const_iv (WILL_APPLY_HANDLE) const_iv (WILL_APPLY_TREASURE) const_iv (WILL_APPLY_EARTHWALL)
1481	const_iv (WILL_APPLY_DOOR) const_iv (WILL_APPLY_FOOD)	1413	const_iv (WILL_APPLY_DOOR) const_iv (WILL_APPLY_FOOD)
1482		1414
1483	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)	1415	const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)
…		…
1517	const_iv (ATNR_PARALYZE) const_iv (ATNR_TURN_UNDEAD) const_iv (ATNR_FEAR) const_iv (ATNR_CANCELLATION)	1449	const_iv (ATNR_PARALYZE) const_iv (ATNR_TURN_UNDEAD) const_iv (ATNR_FEAR) const_iv (ATNR_CANCELLATION)
1518	const_iv (ATNR_DEPLETE) const_iv (ATNR_DEATH) const_iv (ATNR_CHAOS) const_iv (ATNR_COUNTERSPELL)	1450	const_iv (ATNR_DEPLETE) const_iv (ATNR_DEATH) const_iv (ATNR_CHAOS) const_iv (ATNR_COUNTERSPELL)
1519	const_iv (ATNR_GODPOWER) const_iv (ATNR_HOLYWORD) const_iv (ATNR_BLIND) const_iv (ATNR_INTERNAL)	1451	const_iv (ATNR_GODPOWER) const_iv (ATNR_HOLYWORD) const_iv (ATNR_BLIND) const_iv (ATNR_INTERNAL)
1520	const_iv (ATNR_LIFE_STEALING) const_iv (ATNR_DISEASE)	1452	const_iv (ATNR_LIFE_STEALING) const_iv (ATNR_DISEASE)
1521		1453
1522	const_iv (MAP_IN_MEMORY) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)	1454	const_iv (MAP_ACTIVE) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)
		1455	const_iv (MAP_INACTIVE)
1523		1456
1524	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)	1457	const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)
1525	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)	1458	const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)
		1459
		1460	const_iv (VERSION_CS) const_iv (VERSION_SC)
1526		1461
1527	const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)	1462	const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)
1528		1463
1529	const_iv (ST_DEAD) const_iv (ST_SETUP) const_iv (ST_PLAYING) const_iv (ST_CUSTOM)	1464	const_iv (ST_DEAD) const_iv (ST_SETUP) const_iv (ST_PLAYING) const_iv (ST_CUSTOM)
1530		1465
…		…
1540		1475
1541	const_iv (SYMMETRY_RANDOM) const_iv (SYMMETRY_NONE) const_iv (SYMMETRY_X)	1476	const_iv (SYMMETRY_RANDOM) const_iv (SYMMETRY_NONE) const_iv (SYMMETRY_X)
1542	const_iv (SYMMETRY_Y) const_iv (SYMMETRY_XY)	1477	const_iv (SYMMETRY_Y) const_iv (SYMMETRY_XY)
1543		1478
1544	const_iv (GT_ENVIRONMENT) const_iv (GT_INVISIBLE) const_iv (GT_STARTEQUIP)	1479	const_iv (GT_ENVIRONMENT) const_iv (GT_INVISIBLE) const_iv (GT_STARTEQUIP)
1545	const_iv (GT_APPLY) const_iv (GT_ONLY_GOOD) const_iv (GT_UPDATE_INV)	1480	const_iv (GT_APPLY) const_iv (GT_ONLY_GOOD) const_iv (GT_MINIMAL)
1546	const_iv (GT_MINIMAL)
1547		1481
1548	const_iv (FT_FACE) const_iv (FT_MUSIC) const_iv (FT_SOUND)	1482	const_iv (FT_FACE) const_iv (FT_MUSIC) const_iv (FT_SOUND)
1549	const_iv (FT_RSRC) const_iv (FT_NUM)	1483	const_iv (FT_RSRC) const_iv (FT_NUM)
1550	};	1484	};
1551		1485
…		…
1573	av_store (av, eiv->iv, newRV_noinc ((SV *)event));	1507	av_store (av, eiv->iv, newRV_noinc ((SV *)event));
1574	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));	1508	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));
1575	}	1509	}
1576	}	1510	}
1577		1511
		1512	void _gv_clear (SV *gv)
		1513	CODE:
		1514	assert (SvTYPE (gv) == SVt_PVGV);
		1515	# define f(sv) { SV *sv_ = (SV *)(sv); sv = 0; SvREFCNT_dec (sv_); }
		1516	f (GvGP (gv)->gp_form);
		1517	f (GvGP (gv)->gp_io);
		1518	f (GvGP (gv)->gp_sv);
		1519	f (GvGP (gv)->gp_av);
		1520	f (GvGP (gv)->gp_hv);
		1521	f (GvGP (gv)->gp_cv);
		1522	GvCVGEN (gv) = 0;
		1523	GvMULTI_off (gv);
		1524	# undef f
		1525
		1526
1578	void _connect_to_perl ()	1527	void _connect_to_perl ()
1579		1528
1580	void _recalc_want ()	1529	void _recalc_want ()
1581		1530
1582	void _global_reattach ()	1531	void _global_reattach ()
…		…
1630	}	1579	}
1631		1580
1632	SvCUR_set (data_sv, dst - SvPVX (data_sv));	1581	SvCUR_set (data_sv, dst - SvPVX (data_sv));
1633	}	1582	}
1634		1583
		1584	void evthread_start (int aiofd)
		1585
1635	void _post_tick ()	1586	void cede_to_tick ()
1636	CODE:	1587	CODE:
1637	coroapi::next_cede = SvNV (sv_next_tick) - TICK * (1. - 1. / CEDES_PER_TICK);	1588	coroapi::cede_to_tick ();
1638		1589
1639	NV till_cede ()	1590	NV till_tick ()
1640	CODE:	1591	CODE:
1641	RETVAL = coroapi::next_cede - now ();	1592	RETVAL = SvNVX (sv_next_tick) - now ();
1642	OUTPUT:	1593	OUTPUT:
1643	RETVAL	1594	RETVAL
1644		1595
1645	NV till_tick ()	1596	int tick_inhibit ()
1646	CODE:	1597	CODE:
1647	RETVAL = SvNV (sv_next_tick) - now ();	1598	RETVAL = tick_inhibit;
1648	OUTPUT:	1599	OUTPUT:
1649	RETVAL	1600	RETVAL
1650		1601
		1602	void tick_inhibit_inc ()
		1603	CODE:
		1604	++tick_inhibit;
		1605
		1606	void tick_inhibit_dec ()
		1607	CODE:
		1608	if (!--tick_inhibit)
		1609	if (tick_pending)
		1610	{
		1611	ev_async_send (EV_DEFAULT, &tick_watcher);
		1612	coroapi::cede ();
		1613	}
		1614
		1615	void server_tick ()
		1616	CODE:
		1617	{
		1618	NOW = ev_now (EV_DEFAULT);
		1619	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1620	SvNV_set (sv_tick_start, NOW); SvNOK_only (sv_tick_start);
		1621	runtime = SvNVX (sv_runtime);
		1622
		1623	server_tick ();
		1624
		1625	NOW = ev_time ();
		1626	SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
		1627	runtime += TICK;
		1628	SvNV_set (sv_runtime, runtime); SvNOK_only (sv_runtime);
		1629	}
		1630
1651	NV floor (NV x)	1631	NV floor (NV x)
1652		1632
1653	NV ceil (NV x)	1633	NV ceil (NV x)
1654		1634
1655	NV rndm (...)	1635	NV rndm (...)
		1636	ALIAS:
		1637	rmg_rndm = 1
1656	CODE:	1638	CODE:
		1639	{
		1640	rand_gen &gen = ix ? rmg_rndm : rndm;
1657	switch (items)	1641	switch (items)
1658	{	1642	{
1659	case 0: RETVAL = rndm (); break;	1643	case 0: RETVAL = gen (); break;
1660	case 1: RETVAL = rndm (SvUV (ST (0))); break;	1644	case 1: RETVAL = gen (SvUV (ST (0))); break;
1661	case 2: RETVAL = rndm (SvIV (ST (0)), SvIV (ST (1))); break;	1645	case 2: RETVAL = gen (SvIV (ST (0)), SvIV (ST (1))); break;
1662	default: croak ("cf::rndm requires none, one or two parameters."); break;	1646	default: croak ("cf::rndm requires none, one or two parameters."); break;
1663	}	1647	}
		1648	}
1664	OUTPUT:	1649	OUTPUT:
1665	RETVAL	1650	RETVAL
1666		1651
1667	NV clamp (NV value, NV min_value, NV max_value)	1652	NV clamp (NV value, NV min_value, NV max_value)
1668	CODE:	1653	CODE:
…		…
1674	CODE:	1659	CODE:
1675	RETVAL = lerp (value, min_in, max_in, min_out, max_out);	1660	RETVAL = lerp (value, min_in, max_in, min_out, max_out);
1676	OUTPUT:	1661	OUTPUT:
1677	RETVAL	1662	RETVAL
1678		1663
1679	void cede_to_tick ()	1664	void weaken (...)
1680	CODE:	1665	PROTOTYPE: @
1681	coroapi::cede_to_tick ();	1666	CODE:
1682		1667	while (items > 0)
1683	void server_tick ()	1668	sv_rvweaken (ST (--items));
1684	CODE:
1685	NOW = now ();
1686	runtime = SvNVx (sv_runtime);
1687	server_tick ();
1688		1669
1689	void	1670	void
1690	log_backtrace (utf8_string msg)	1671	log_backtrace (utf8_string msg)
1691		1672
1692	void	1673	void
…		…
1731		1712
1732	void abort ()	1713	void abort ()
1733		1714
1734	void reset_signals ()	1715	void reset_signals ()
1735		1716
1736	void fork_abort (octet_string cause = "cf::fork_abort")	1717	void fork_abort (const_octet_string cause = "cf::fork_abort")
1737		1718
1738	void cleanup (octet_string cause, bool make_core = false)	1719	void cleanup (const_octet_string cause, bool make_core = false)
1739		1720
1740	void emergency_save ()	1721	void emergency_save ()
1741		1722
1742	void _exit (int status = EXIT_SUCCESS)	1723	void _exit (int status = EXIT_SUCCESS)
1743		1724
1744	UV sv_2watcher (SV *w)
1745	CODE:
1746	RETVAL = (UV)GEventAPI->sv_2watcher (w);
1747	OUTPUT:
1748	RETVAL
1749
1750	#if _POSIX_MEMLOCK	1725	#if _POSIX_MEMLOCK
1751		1726
1752	int mlockall (int flags = MCL_CURRENT | MCL_FUTURE)	1727	int mlockall (int flags = MCL_CURRENT | MCL_FUTURE)
		1728	INIT:
		1729	#if __GLIBC__
		1730	mallopt (M_TOP_PAD, 1024 * 1024);
		1731	mallopt (M_MMAP_THRESHOLD, 1024 * 1024 * 128);
		1732	mallopt (M_MMAP_MAX, 0); // likely bug-workaround, also frees memory
		1733	mallopt (M_PERTURB, 0xee); // bug-workaround for linux glibc+mlockall+calloc
		1734	#endif
1753		1735
1754	int munlockall ()	1736	int munlockall ()
1755		1737
1756	#endif	1738	#endif
		1739
		1740	int
		1741	malloc_trim (IV pad = 0)
		1742
		1743	void
		1744	mallinfo ()
		1745	PPCODE:
		1746	{
		1747	#if __GLIBC__
		1748	struct mallinfo mai = mallinfo ();
		1749	EXTEND (SP, 10*2);
		1750	PUSHs (sv_2mortal (newSVpv ("arena" , 0))); PUSHs (sv_2mortal (newSViv (mai.arena)));
		1751	PUSHs (sv_2mortal (newSVpv ("ordblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.ordblks)));
		1752	PUSHs (sv_2mortal (newSVpv ("smblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.smblks)));
		1753	PUSHs (sv_2mortal (newSVpv ("hblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblks)));
		1754	PUSHs (sv_2mortal (newSVpv ("hblkhd" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblkhd)));
		1755	PUSHs (sv_2mortal (newSVpv ("usmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.usmblks)));
		1756	PUSHs (sv_2mortal (newSVpv ("fsmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.fsmblks)));
		1757	PUSHs (sv_2mortal (newSVpv ("uordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.uordblks)));
		1758	PUSHs (sv_2mortal (newSVpv ("fordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.fordblks)));
		1759	PUSHs (sv_2mortal (newSVpv ("keepcost", 0))); PUSHs (sv_2mortal (newSViv (mai.keepcost)));
		1760	#endif
		1761	EXTEND (SP, 2*2);
		1762	PUSHs (sv_2mortal (newSVpv ("slice_alloc", 0))); PUSHs (sv_2mortal (newSVuv (slice_alloc)));
		1763	PUSHs (sv_2mortal (newSVpv ("shstr_alloc", 0))); PUSHs (sv_2mortal (newSVuv (shstr_alloc)));
		1764	PUSHs (sv_2mortal (newSVpv ("objects" , 0))); PUSHs (sv_2mortal (newSVuv (objects.size () * sizeof (object))));
		1765	}
1757		1766
1758	int find_animation (utf8_string text)	1767	int find_animation (utf8_string text)
1759	PROTOTYPE: $	1768	PROTOTYPE: $
1760		1769
1761	int random_roll (int min, int max, object *op, int goodbad);	1770	int random_roll (int min, int max, object *op, int goodbad);
…		…
1799	RETVAL = newSVpv (resist_plus[atnr], 0);	1808	RETVAL = newSVpv (resist_plus[atnr], 0);
1800	else	1809	else
1801	XSRETURN_UNDEF;	1810	XSRETURN_UNDEF;
1802	OUTPUT: RETVAL	1811	OUTPUT: RETVAL
1803		1812
		1813	UUID
		1814	uuid_cur ()
		1815	CODE:
		1816	RETVAL = UUID::cur;
		1817	OUTPUT:
		1818	RETVAL
		1819
		1820	UUID
		1821	uuid_gen ()
		1822	CODE:
		1823	RETVAL = UUID::gen ();
		1824	OUTPUT:
		1825	RETVAL
		1826
		1827	val64
		1828	uuid_seq (UUID uuid)
		1829	CODE:
		1830	RETVAL = uuid.seq;
		1831	OUTPUT:
		1832	RETVAL
		1833
		1834	UUID
		1835	uuid_str (val64 seq)
		1836	CODE:
		1837	RETVAL.seq = seq;
		1838	OUTPUT:
		1839	RETVAL
		1840
		1841	void
		1842	coin_names ()
		1843	PPCODE:
		1844	EXTEND (SP, NUM_COINS);
		1845	for (int i = 0; i < NUM_COINS; ++i)
		1846	PUSHs (sv_2mortal (newSVpv (coins [i], 0)));
		1847
		1848	void
		1849	coin_archetypes ()
		1850	PPCODE:
		1851	EXTEND (SP, NUM_COINS);
		1852	for (int i = 0; i < NUM_COINS; ++i)
		1853	PUSHs (sv_2mortal (to_sv (archetype::find (coins [i]))));
		1854
1804	bool	1855	bool
1805	load_resource_file (octet_string filename)	1856	load_resource_file_ (octet_string filename)
		1857
		1858	void
		1859	fix_weight ()
1806		1860
1807	MODULE = cf PACKAGE = cf::attachable	1861	MODULE = cf PACKAGE = cf::attachable
1808		1862
1809	int	1863	int
1810	valid (SV *obj)	1864	valid (SV *obj)
…		…
1874	object *actives (U32 index)	1928	object *actives (U32 index)
1875	CODE:	1929	CODE:
1876	RETVAL = index < actives.size () ? actives [index] : 0;	1930	RETVAL = index < actives.size () ? actives [index] : 0;
1877	OUTPUT: RETVAL	1931	OUTPUT: RETVAL
1878		1932
		1933	int mortals_size ()
		1934	CODE:
		1935	RETVAL = attachable::mortals.size ();
		1936	OUTPUT: RETVAL
		1937
1879	const char *slot_use_name (U32 slot)	1938	const char *slot_use_name (U32 slot)
1880	ALIAS:	1939	ALIAS:
1881	slot_nonuse_name = 1	1940	slot_nonuse_name = 1
1882	CODE:	1941	CODE:
1883	{	1942	{
…		…
1904	void	1963	void
1905	inv (object *obj)	1964	inv (object *obj)
1906	PROTOTYPE: $	1965	PROTOTYPE: $
1907	PPCODE:	1966	PPCODE:
1908	{	1967	{
1909	object *o;
1910	for (o = obj->inv; o; o = o->below)	1968	for (object *o = obj->inv; o; o = o->below)
1911	XPUSHs (sv_2mortal (to_sv (o)));	1969	XPUSHs (sv_2mortal (to_sv (o)));
1912	}	1970	}
1913		1971
1914	void	1972	void
1915	set_animation (object *op, int idx)	1973	set_animation (object *op, int idx)
…		…
1947		2005
1948	int need_identify (object *obj);	2006	int need_identify (object *obj);
1949		2007
1950	int apply_shop_mat (object *shop_mat, object *op);	2008	int apply_shop_mat (object *shop_mat, object *op);
1951		2009
1952	int move_player (object *op, int dir)
1953	CODE:
1954	RETVAL = move_player (op, dir);
1955	OUTPUT:
1956	RETVAL
1957
1958	int move (object *op, int dir, object *originator = op)	2010	int move (object *op, int dir, object *originator = op)
1959	CODE:	2011	CODE:
1960	RETVAL = move_ob (op, dir, originator);	2012	RETVAL = move_ob (op, dir, originator);
1961	OUTPUT:	2013	OUTPUT:
1962	RETVAL	2014	RETVAL
…		…
1969	CODE:	2021	CODE:
1970	player_apply_below (op);	2022	player_apply_below (op);
1971		2023
1972	int cast_heal (object *op, object *caster, object *spell, int dir = 0)	2024	int cast_heal (object *op, object *caster, object *spell, int dir = 0)
1973		2025
1974	object *cf_object_present_archname_inside (object *op, utf8_string whatstr)
1975
1976	int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)
1977
1978	int cf_object_change_map (object *op, int x, int y, maptile *map)
1979
1980	#//TODO
1981	object *clone_ (object *op, int recursive = 0)
1982	CODE:
1983	if (recursive)
1984	RETVAL = object_create_clone (op);
1985	else
1986	{
1987	RETVAL = object::create ();
1988	op->copy_to (RETVAL);
1989	}
1990	OUTPUT: RETVAL
1991
1992	int pay_item (object *op, object *buyer)	2026	int pay_item (object *op, object *buyer)
1993	CODE:	2027	CODE:
1994	RETVAL = pay_for_item (op, buyer);	2028	RETVAL = pay_for_item (op, buyer);
1995	OUTPUT: RETVAL	2029	OUTPUT: RETVAL
1996		2030
…		…
2030		2064
2031	void drop (object *who, object *op)	2065	void drop (object *who, object *op)
2032		2066
2033	void pick_up (object *who, object *op)	2067	void pick_up (object *who, object *op)
2034		2068
2035	int cf_object_teleport (object *op, maptile *map, int x, int y)
2036
2037	void update_object (object *op, int action)	2069	void update_object (object *op, int action)
2038		2070
2039	object *cf_create_object_by_name (utf8_string name)
2040
2041	void change_exp (object *op, uint64 exp, utf8_string skill_name = 0, int flag = 0)	2071	void change_exp (object *op, uint64 exp, utf8_string skill_name = 0, int flag = 0)
2042		2072
2043	void player_lvl_adj (object *who, object *skill = 0)	2073	void player_lvl_adj (object *who, object *skill = 0)
2044		2074
2045	int kill_object (object *op, int dam = 0, object *hitter = 0, int type = AT_PHYSICAL)	2075	int kill_object (object *op, int dam = 0, object *hitter = 0, int type = AT_PHYSICAL)
…		…
2056		2086
2057	void handle_apply_yield (object *op);	2087	void handle_apply_yield (object *op);
2058		2088
2059		2089
2060	MODULE = cf PACKAGE = cf::object PREFIX = cf_	2090	MODULE = cf PACKAGE = cf::object PREFIX = cf_
2061
2062	object *cf_insert_ob_in_ob (object *ob, object *where)
2063		2091
2064	# no clean way to get an object from an archetype - stupid idiotic	2092	# no clean way to get an object from an archetype - stupid idiotic
2065	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.	2093	# dumb kludgy misdesigned plug-in api slowly gets on my nerves.
2066		2094
2067	object *new (utf8_string archetype = 0)	2095	object *new (utf8_string archetype = 0)
…		…
2076	# TODO: nuke	2104	# TODO: nuke
2077	object *insert_ob_in_map_at (object *ob, maptile *where, object_ornull *orig, int flag, int x, int y)	2105	object *insert_ob_in_map_at (object *ob, maptile *where, object_ornull *orig, int flag, int x, int y)
2078	PROTOTYPE: $$$$$$	2106	PROTOTYPE: $$$$$$
2079	CODE:	2107	CODE:
2080	{	2108	{
2081	int unused_type;	2109	RETVAL = insert_ob_in_map_at (ob, where, orig, flag, x, y);
2082	RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);
2083	}	2110	}
2084		2111
2085	const_utf8_string get_ob_key_value (object *op, utf8_string key)	2112	shstr
		2113	object::kv_get (shstr key)
2086		2114
2087	bool set_ob_key_value (object *op, utf8_string key, utf8_string value = 0, int add_key = 1)	2115	void
		2116	object::kv_del (shstr key)
		2117
		2118	void
		2119	object::kv_set (shstr key, shstr value)
2088		2120
2089	object *get_nearest_player (object *ob)	2121	object *get_nearest_player (object *ob)
2090	ALIAS: nearest_player = 0	2122	ALIAS: nearest_player = 0
2091	PREINIT:	2123	PREINIT:
2092	extern object *get_nearest_player (object *);	2124	extern object *get_nearest_player (object *);
…		…
2094	void rangevector (object *ob, object *other, int flags = 0)	2126	void rangevector (object *ob, object *other, int flags = 0)
2095	PROTOTYPE: $$;$	2127	PROTOTYPE: $$;$
2096	PPCODE:	2128	PPCODE:
2097	{	2129	{
2098	rv_vector rv;	2130	rv_vector rv;
		2131
		2132	PUTBACK;
2099	get_rangevector (ob, other, &rv, flags);	2133	get_rangevector (ob, other, &rv, flags);
		2134	SPAGAIN;
		2135
2100	EXTEND (SP, 5);	2136	EXTEND (SP, 5);
2101	PUSHs (newSVuv (rv.distance));	2137	PUSHs (newSVuv (rv.distance));
2102	PUSHs (newSViv (rv.distance_x));	2138	PUSHs (newSViv (rv.distance_x));
2103	PUSHs (newSViv (rv.distance_y));	2139	PUSHs (newSViv (rv.distance_y));
2104	PUSHs (newSViv (rv.direction));	2140	PUSHs (newSViv (rv.direction));
2105	PUSHs (newSVcfapi (CFAPI_POBJECT, rv.part));	2141	PUSHs (to_sv (rv.part));
2106	}	2142	}
2107		2143
2108	bool on_same_map_as (object *ob, object *other)	2144	bool on_same_map_as (object *ob, object *other)
2109	CODE:	2145	CODE:
2110	RETVAL = on_same_map (ob, other);	2146	RETVAL = on_same_map (ob, other);
…		…
2114	base_name (object *op, int plural = op->nrof > 1)	2150	base_name (object *op, int plural = op->nrof > 1)
2115	CODE:	2151	CODE:
2116	RETVAL = query_base_name (op, plural);	2152	RETVAL = query_base_name (op, plural);
2117	OUTPUT: RETVAL	2153	OUTPUT: RETVAL
2118		2154
2119	object *decrease_ob_nr (object *op, unsigned long i)	2155	# return the tail of an object, excluding itself
		2156	void
		2157	tail (object *op)
		2158	PPCODE:
		2159	while ((op = op->more))
		2160	XPUSHs (sv_2mortal (to_sv (op)));
2120		2161
2121	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_	2162	MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_
2122		2163
2123	player *player (object *op)	2164	player *player (object *op)
2124	CODE:	2165	CODE:
2125	RETVAL = op->contr;	2166	RETVAL = op->contr;
2126	OUTPUT: RETVAL	2167	OUTPUT: RETVAL
2127		2168
		2169	bool move_player (object *op, int dir)
		2170
2128	void check_score (object *op)	2171	void check_score (object *op)
2129		2172
2130	void message (object *op, utf8_string txt, int flags = NDI_ORANGE | NDI_UNIQUE)	2173	void message (object *op, utf8_string txt, int flags = NDI_ORANGE | NDI_UNIQUE)
2131	CODE:	2174	CODE:
2132	new_draw_info (flags, 0, op, txt);	2175	new_draw_info (flags, 0, op, txt);
2133		2176
2134	void kill_player (object *op)	2177	void kill_player (object *op)
2135		2178
		2179	void esrv_send_item (object *pl, object *item)
		2180
2136	void esrv_update_item (object *op, int what, object *item)	2181	void esrv_update_item (object *pl, int what, object *item)
2137	C_ARGS: what, op, item	2182	C_ARGS: what, pl, item
		2183
		2184	void esrv_del_item (object *pl, int tag)
		2185	C_ARGS: pl->contr, tag
2138		2186
2139	int command_summon (object *op, utf8_string params)	2187	int command_summon (object *op, utf8_string params)
2140		2188
2141	int command_arrest (object *op, utf8_string params)	2189	int command_arrest (object *op, utf8_string params)
2142		2190
…		…
2163	pl->ob->stats.grace = pl->ob->stats.maxgrace;	2211	pl->ob->stats.grace = pl->ob->stats.maxgrace;
2164	pl->orig_stats = pl->ob->stats;	2212	pl->orig_stats = pl->ob->stats;
2165		2213
2166	void clear_los (player *pl)	2214	void clear_los (player *pl)
2167		2215
2168	void cf_player_move (player *pl, int dir)
2169
2170	bool	2216	bool
2171	cell_visible (player *pl, int dx, int dy)	2217	cell_visible (player *pl, int dx, int dy)
2172	CODE:	2218	CODE:
2173	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2	2219	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2
2174	&& !pl->blocked_los [dx + pl->ns->mapx / 2][dy + pl->ns->mapy / 2];	2220	&& !pl->blocked_los [dx + pl->ns->mapx / 2][dy + pl->ns->mapy / 2];
…		…
2180	CODE:	2226	CODE:
2181	{	2227	{
2182	STRLEN len;	2228	STRLEN len;
2183	char *buf = SvPVbyte (packet, len);	2229	char *buf = SvPVbyte (packet, len);
2184		2230
		2231	if (len > MAXSOCKBUF)
		2232	pl->failmsg ("[packet too long for client]");
2185	if (pl->ns)	2233	else if (pl->ns)
2186	pl->ns->send_packet (buf, len);	2234	pl->ns->send_packet (buf, len);
2187	}	2235	}
2188
2189	int
2190	listening (player *pl, int new_value = -1)
2191	CODE:
2192	RETVAL = pl->listening;
2193	if (new_value >= 0)
2194	pl->listening = new_value;
2195	OUTPUT:
2196	RETVAL
2197		2236
2198	void savebed (player *pl, SV *map_path = 0, SV *x = 0, SV *y = 0)	2237	void savebed (player *pl, SV *map_path = 0, SV *x = 0, SV *y = 0)
2199	PROTOTYPE: $;$$$	2238	PROTOTYPE: $;$$$
2200	PPCODE:	2239	PPCODE:
2201	if (GIMME_V != G_VOID)	2240	if (GIMME_V != G_VOID)
…		…
2226	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);	2265	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);
2227	OUTPUT: RETVAL	2266	OUTPUT: RETVAL
2228		2267
2229	SV *registry (maptile *map)	2268	SV *registry (maptile *map)
2230		2269
		2270	void
		2271	find_tagged_objects (maptile *map, utf8_string tag = 0)
		2272	PPCODE:
		2273	{
		2274	if (!map->spaces)
		2275	XSRETURN_EMPTY;
		2276
		2277	if (tag)
		2278	{
		2279	shstr_cmp tag_ (tag);
		2280
		2281	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2282	for (object *op = ms->bot; op; op = op->above)
		2283	if (op->tag == tag_)
		2284	XPUSHs (sv_2mortal (to_sv (op)));
		2285	}
		2286	else
		2287	{
		2288	for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
		2289	for (object *op = ms->bot; op; op = op->above)
		2290	if (op->tag)
		2291	XPUSHs (sv_2mortal (to_sv (op)));
		2292	}
		2293	}
		2294
2231	INCLUDE: $PERL $srcdir/genacc maptile ../include/map.h |	2295	INCLUDE: $PERL $srcdir/genacc maptile ../include/map.h |
2232		2296
2233	void	2297	void
2234	maptile::instantiate ()	2298	maptile::instantiate ()
2235		2299
…		…
2331	}	2395	}
2332		2396
2333	void	2397	void
2334	maptile::create_region_treasure ()	2398	maptile::create_region_treasure ()
2335	CODE:	2399	CODE:
2336	{
2337	object *op = object::create ();
2338	op->type = FLOOR;
2339	op->map = THIS;
2340
2341	for (int x = 0; x < THIS->width; ++x)	2400	for (int x = 0; x < THIS->width; ++x)
2342	for (int y = 0; y < THIS->height; ++y)	2401	for (int y = 0; y < THIS->height; ++y)
2343	{	2402	{
2344	region *rgn = THIS->region (x, y);	2403	region *rgn = THIS->region (x, y);
2345		2404
2346	//fprintf (stderr, "%d,%d %f %p\n", x, y, rgn->treasure_density,rgn->treasure);//D	2405	//fprintf (stderr, "%d,%d %f %p\n", x, y, rgn->treasure_density,rgn->treasure);//D
		2406	if (object *op = THIS->at (x, y).top)
2347	if (rgn->treasure && rndm () < rgn->treasure_density)	2407	if (rgn->treasure && rndm () < rgn->treasure_density)
2348	{
2349	op->x = x;
2350	op->y = y;
2351	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);	2408	create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);
2352	}
2353	}	2409	}
2354
2355	op->destroy ();
2356	}
2357		2410
2358	int out_of_map (maptile *map, int x, int y)	2411	int out_of_map (maptile *map, int x, int y)
2359		2412
2360	void	2413	void
2361	trigger (maptile *map, long connection, bool state = true)	2414	trigger (maptile *map, long connection, bool state = true)
…		…
2366	get_connection (maptile *map, long connection)	2419	get_connection (maptile *map, long connection)
2367	PPCODE:	2420	PPCODE:
2368	oblinkpt *obp = get_connection_links (map, connection);	2421	oblinkpt *obp = get_connection_links (map, connection);
2369	if (obp)	2422	if (obp)
2370	for (objectlink *ol = obp->link; ol; ol = ol->next)	2423	for (objectlink *ol = obp->link; ol; ol = ol->next)
2371	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, (object *)ol->ob)));	2424	XPUSHs (sv_2mortal (to_sv ((object *)ol->ob)));
2372
2373	object *cf_map_insert_object_there (maptile *where, object *op, object *originator, int flags)
2374
2375	object *cf_map_insert_object (maptile *where, object* op, int x, int y)
2376
2377	object* cf_map_present_arch_by_name (maptile *map, const char* str, int nx, int ny)
2378	C_ARGS: str, map, nx, ny
2379		2425
2380	void	2426	void
2381	get_map_flags (maptile *map, int x, int y)	2427	get_map_flags (maptile *map, int x, int y)
2382	PPCODE:	2428	PPCODE:
2383	{	2429	{
2384	maptile *nmap = 0;	2430	maptile *nmap = 0;
2385	I16 nx = 0, ny = 0;	2431	I16 nx = 0, ny = 0;
		2432
		2433	PUTBACK;
2386	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);	2434	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
		2435	SPAGAIN;
2387		2436
2388	EXTEND (SP, 4);	2437	EXTEND (SP, 4);
2389	PUSHs (sv_2mortal (newSViv (flags)));	2438	PUSHs (sv_2mortal (newSViv (flags)));
2390		2439
2391	if (GIMME_V == G_ARRAY)	2440	if (GIMME_V == G_ARRAY)
2392	{	2441	{
2393	PUSHs (sv_2mortal (newSVcfapi (CFAPI_PMAP, nmap)));	2442	PUSHs (sv_2mortal (to_sv (nmap)));
2394	PUSHs (sv_2mortal (newSViv (nx)));	2443	PUSHs (sv_2mortal (newSViv (nx)));
2395	PUSHs (sv_2mortal (newSViv (ny)));	2444	PUSHs (sv_2mortal (newSViv (ny)));
2396	}	2445	}
2397	}	2446	}
2398		2447
		2448	mapspace *
		2449	ms (maptile *map, unsigned int x, unsigned int y)
		2450	PROTOTYPE: $$$
		2451	CODE:
		2452	{
		2453	maptile *nmap = 0;
		2454	I16 nx, ny;
		2455
		2456	PUTBACK;
		2457	get_map_flags (map, &nmap, x, y, &nx, &ny);
		2458	SPAGAIN;
		2459
		2460	if (!nmap)
		2461	XSRETURN_UNDEF;
		2462
		2463	RETVAL = &nmap->at (nx, ny);
		2464	}
		2465	OUTPUT:
		2466	RETVAL
		2467
2399	void	2468	void
2400	at (maptile *map, unsigned int x, unsigned int y)	2469	at (maptile *map, unsigned int x, unsigned int y)
2401	PROTOTYPE: $$$	2470	PROTOTYPE: $$$
2402	PPCODE:	2471	PPCODE:
2403	{	2472	{
2404	object *o;
2405	maptile *nmap = 0;	2473	maptile *nmap = 0;
2406	I16 nx, ny;	2474	I16 nx, ny;
2407		2475
		2476	PUTBACK;
2408	get_map_flags (map, &nmap, x, y, &nx, &ny);	2477	get_map_flags (map, &nmap, x, y, &nx, &ny);
		2478	SPAGAIN;
2409		2479
2410	if (nmap)	2480	if (nmap)
2411	for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above)	2481	for (object *o = nmap->at (nx, ny).bot; o; o = o->above)
2412	XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o)));	2482	XPUSHs (sv_2mortal (to_sv (o)));
2413	}	2483	}
2414		2484
2415	SV *	2485	SV *
2416	bot_at (maptile *obj, unsigned int x, unsigned int y)	2486	bot_at (maptile *obj, unsigned int x, unsigned int y)
2417	PROTOTYPE: $$$	2487	PROTOTYPE: $$$
…		…
2426	INIT:	2496	INIT:
2427	if (x >= obj->width || y >= obj->height) XSRETURN_UNDEF;	2497	if (x >= obj->width || y >= obj->height) XSRETURN_UNDEF;
2428	CODE:	2498	CODE:
2429	switch (ix)	2499	switch (ix)
2430	{	2500	{
2431	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;	2501	case 0: RETVAL = to_sv (GET_MAP_OB (obj, x, y)); break;
2432	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;	2502	case 1: RETVAL = to_sv (GET_MAP_TOP (obj, x, y)); break;
2433	case 2: RETVAL = newSVuv ( GET_MAP_FLAGS (obj, x, y)); break;	2503	case 2: RETVAL = newSVuv (GET_MAP_FLAGS (obj, x, y)); break;
2434	case 3: RETVAL = newSViv ( GET_MAP_LIGHT (obj, x, y)); break;	2504	case 3: RETVAL = newSViv (GET_MAP_LIGHT (obj, x, y)); break;
2435	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;	2505	case 4: RETVAL = newSVuv (GET_MAP_MOVE_BLOCK (obj, x, y)); break;
2436	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;	2506	case 5: RETVAL = newSVuv (GET_MAP_MOVE_SLOW (obj, x, y)); break;
2437	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;	2507	case 6: RETVAL = newSVuv (GET_MAP_MOVE_ON (obj, x, y)); break;
2438	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;	2508	case 7: RETVAL = newSVuv (GET_MAP_MOVE_OFF (obj, x, y)); break;
2439	}	2509	}
2440	OUTPUT: RETVAL	2510	OUTPUT: RETVAL
2441		2511
2442	void fix_walls (maptile *map, int x, int y)	2512	void fix_walls (maptile *map, int x, int y)
2443		2513
…		…
2529	RETVAL = self->generate_random_map (&rmp);	2599	RETVAL = self->generate_random_map (&rmp);
2530	}	2600	}
2531	OUTPUT:	2601	OUTPUT:
2532	RETVAL	2602	RETVAL
2533		2603
		2604	MODULE = cf PACKAGE = cf::mapspace
		2605
		2606	INCLUDE: $PERL $srcdir/genacc mapspace ../include/map.h |
		2607
2534	MODULE = cf PACKAGE = cf::arch	2608	MODULE = cf PACKAGE = cf::arch
2535
2536	archetype *find (utf8_string name)
2537	CODE:
2538	RETVAL = archetype::find (name);
2539	OUTPUT:
2540	RETVAL
2541		2609
2542	int archetypes_size ()	2610	int archetypes_size ()
2543	CODE:	2611	CODE:
2544	RETVAL = archetypes.size ();	2612	RETVAL = archetypes.size ();
2545	OUTPUT: RETVAL	2613	OUTPUT: RETVAL
…		…
2630	CODE:	2698	CODE:
2631	{	2699	{
2632	STRLEN len;	2700	STRLEN len;
2633	char *buf = SvPVbyte (packet, len);	2701	char *buf = SvPVbyte (packet, len);
2634		2702
		2703	if (len > MAXSOCKBUF)
		2704	{
		2705	// ugly
		2706	if (THIS->pl)
		2707	THIS->pl->failmsg ("[packet too long for client]");
		2708	}
		2709	else
2635	THIS->send_packet (buf, len);	2710	THIS->send_packet (buf, len);
2636	}	2711	}
2637		2712
2638	faceidx	2713	faceidx
2639	client::need_face (utf8_string name, int pri = 0)	2714	client::need_face (utf8_string name, int pri = 0)
2640	CODE:	2715	CODE:
…		…
2739	}	2814	}
2740	}	2815	}
2741		2816
2742	int get_data_size (faceidx idx, int faceset = 0)	2817	int get_data_size (faceidx idx, int faceset = 0)
2743	CODE:	2818	CODE:
2744	facedata *d = face_data (idx, faceset); assert (d);	2819	facedata *d = face_data (idx, faceset);
		2820	if (!d) XSRETURN_UNDEF;
2745	RETVAL = d->data.size ();	2821	RETVAL = d->data.size ();
2746	OUTPUT:	2822	OUTPUT:
2747	RETVAL	2823	RETVAL
2748		2824
2749	SV *get_chksum (faceidx idx, int faceset = 0)	2825	SV *get_chksum (faceidx idx, int faceset = 0)
2750	CODE:	2826	CODE:
2751	facedata *d = face_data (idx, faceset); assert (d);	2827	facedata *d = face_data (idx, faceset);
		2828	if (!d) XSRETURN_UNDEF;
2752	RETVAL = newSVpvn ((char *)d->chksum, CHKSUM_SIZE);	2829	RETVAL = newSVpvn ((char *)d->chksum, CHKSUM_SIZE);
		2830	OUTPUT:
		2831	RETVAL
		2832
		2833	SV *get_data (faceidx idx, int faceset = 0)
		2834	CODE:
		2835	facedata *d = face_data (idx, faceset);
		2836	if (!d) XSRETURN_UNDEF;
		2837	RETVAL = newSVpvn (d->data.data (), d->data.length ());
2753	OUTPUT:	2838	OUTPUT:
2754	RETVAL	2839	RETVAL
2755		2840
2756	void invalidate (faceidx idx)	2841	void invalidate (faceidx idx)
2757	CODE:	2842	CODE:
…		…
2803	void invalidate_all ()	2888	void invalidate_all ()
2804	CODE:	2889	CODE:
2805	for_all_clients (ns)	2890	for_all_clients (ns)
2806	ns->anims_sent.reset ();	2891	ns->anims_sent.reset ();
2807		2892
		2893	MODULE = cf PACKAGE = cf::object::freezer
		2894
		2895	INCLUDE: $PERL $srcdir/genacc object_freezer ../include/cfperl.h |
		2896
		2897	SV *
		2898	new (char *klass)
		2899	CODE:
		2900	RETVAL = newSVptr (new object_freezer, gv_stashpv ("cf::object::freezer", 1));
		2901	OUTPUT: RETVAL
		2902
		2903	void
		2904	DESTROY (SV *sv)
		2905	CODE:
		2906	object_freezer *self;
		2907	sv_to (sv, self);
		2908	delete self;
		2909
		2910	MODULE = cf PACKAGE = cf::object::thawer
		2911
		2912	INCLUDE: $PERL $srcdir/genacc object_thawer ../include/cfperl.h |
		2913
		2914	SV *
		2915	new_from_file (char *klass, octet_string path)
		2916	CODE:
		2917	object_thawer *f = new object_thawer (path);
		2918	if (!*f)
		2919	{
		2920	delete f;
		2921	XSRETURN_UNDEF;
		2922	}
		2923	RETVAL = newSVptr (f, gv_stashpv ("cf::object::thawer", 1));
		2924	OUTPUT: RETVAL
		2925
		2926	void
		2927	DESTROY (SV *sv)
		2928	CODE:
		2929	object_thawer *self;
		2930	sv_to (sv, self);
		2931	delete self;
		2932
		2933	void
		2934	extract_tags (object_thawer *self)
		2935	PPCODE:
		2936	while (self->kw != KW_EOF)
		2937	{
		2938	PUTBACK;
		2939	coroapi::cede_to_tick ();
		2940	SPAGAIN;
		2941
		2942	if (self->kw == KW_tag)
		2943	XPUSHs (sv_2mortal (newSVpv_utf8 (self->get_str ())));
		2944
		2945	self->skip ();
		2946	}
		2947

Diff Legend

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