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.115 by root, Wed Dec 27 13:13:47 2006 UTC vs.
Revision 1.153 by root, Fri Jan 26 20:59:57 2007 UTC

…		…
32	#include <sproto.h>	32	#include <sproto.h>
33		33
34	#include "cfperl.h"	34	#include "cfperl.h"
35	#include "shstr.h"	35	#include "shstr.h"
36		36
		37	#include <unistd.h>
		38	#if _POSIX_MEMLOCK
		39	# include <sys/mman.h>
		40	#endif
		41
37	#include <EXTERN.h>	42	#include <EXTERN.h>
38	#include <perl.h>	43	#include <perl.h>
39	#include <XSUB.h>	44	#include <XSUB.h>
40		45
41	#include "CoroAPI.h"	46	#include "CoroAPI.h"
…		…
60	static f_plug_api object_set_property = cfapi_object_set_property;	65	static f_plug_api object_set_property = cfapi_object_set_property;
61	static f_plug_api object_insert = cfapi_object_insert;	66	static f_plug_api object_insert = cfapi_object_insert;
62		67
63	static PerlInterpreter *perl;	68	static PerlInterpreter *perl;
64		69
		70	double runtime;
		71
65	global gbl_ev;	72	global gbl_ev;
66	static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map;	73	static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map;
		74	static SV *sv_runtime;
67		75
68	static HV	76	static HV
69	*stash_cf,	77	*stash_cf,
70	*stash_cf_object_wrap,	78	*stash_cf_object_wrap,
71	*stash_cf_object_player_wrap,	79	*stash_cf_object_player_wrap,
…		…
91		99
92	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	100	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
93		101
94	unordered_vector<attachable *> attachable::mortals;	102	unordered_vector<attachable *> attachable::mortals;
95		103
96	#if 0
97	attachable *attachable::rc_first;
98
99	attachable::attachable ()
100	{
101	refcnt = 0;
102	rc_next = rc_first;
103	rc_first = this;
104	}
105	#endif
106
107	attachable::~attachable ()	104	attachable::~attachable ()
108	{	105	{
109	assert (!(flags & F_BORROWED));//D//TODO//remove when stable
110	#if 0
111	assert (!rc_next);
112	assert (!refcnt);	106	assert (!self);
113	#endif	107	assert (!cb);
		108	}
		109
		110	int
		111	attachable::refcnt_cnt () const
		112	{
		113	return refcnt + (self ? SvREFCNT (self) - 1 : 0);
		114	}
		115
		116	void
		117	attachable::optimise ()
		118	{
		119	if (self
		120	&& SvREFCNT (self) == 1
		121	&& !HvTOTALKEYS (self))
		122	{
		123	sv_unmagic ((SV *)self, PERL_MAGIC_ext);
		124	assert (!self);
		125	}
114	}	126	}
115		127
116	// check wether the object really is dead	128	// check wether the object really is dead
117	void	129	void
118	attachable::do_check ()	130	attachable::do_check ()
119	{	131	{
120	if (refcnt > 0)	132	if (refcnt_cnt () > 0)
121	return;	133	return;
122		134
123	// try to unborrow the refcnt from perl	135	destroy ();
124	if (flags & F_BORROWED)	136	}
		137
		138	void
		139	attachable::do_destroy ()
		140	{
		141	invoke (EVENT_ATTACHABLE_DESTROY, DT_END);
		142
		143	if (cb)
125	{	144	{
126	assert (self);//D//TODO//remove when stable
127	flags &= ~F_BORROWED;
128	refcnt_inc ();
129	SvREFCNT_dec (self);	145	SvREFCNT_dec (cb);
		146	cb = 0;
130	}	147	}
131		148
132	if (refcnt > 0 || self)	149	if (self)
133	return;	150	{
		151	hv_clear (self);
		152	sv_unmagic ((SV *)self, PERL_MAGIC_ext);
		153	// self is now 0
		154	assert (!self);//D//TODO remove soon
		155	}
134		156
135	destroy ();
136	}
137
138	void
139	attachable::do_destroy ()
140	{
141	invoke (EVENT_ATTACHABLE_DESTROY, DT_END);
142
143	//TODO: call generic destroy callback
144	mortals.push_back (this);	157	mortals.push_back (this);
145	}	158	}
146		159
147	void	160	void
148	attachable::destroy ()	161	attachable::destroy ()
…		…
152		165
153	flags |= F_DESTROYED;	166	flags |= F_DESTROYED;
154	do_destroy ();	167	do_destroy ();
155	}	168	}
156		169
		170	void
157	void attachable::check_mortals ()	171	attachable::check_mortals ()
158	{	172	{
159	for (int i = 0; i < mortals.size (); )	173	static int i = 0;
		174
		175	for (;;)
160	{	176	{
		177	if (i >= mortals.size ())
		178	{
		179	i = 0;
		180
		181	if (mortals.size () > 1000)
		182	fprintf (stderr, "mortal queue size (%d) exceeds 1000.\n", (int)mortals.size ());
		183
		184	break;
		185	}
		186
161	attachable *obj = mortals [i];	187	attachable *obj = mortals [i];
162		188
163	obj->refcnt_chk (); // unborrow from perl, if necessary	189	obj->refcnt_chk (); // unborrow from perl, if necessary
164		190
		191	//if (obj->refcnt > 0 || obj->self)
165	if (obj->refcnt || obj->self)	192	if (obj->refcnt || obj->self)
166	{	193	{
167	#if 0	194	//printf ("%p rc %d\n", obj, obj->refcnt_cnt ());//D
168	if (mortals.size() > 5)fprintf (stderr, "%d delaying %d:%p:%s %d (self %p:%d)\n", time(0),i, obj, typeid (*obj).name (),
169	obj->refcnt, obj->self, obj->self ? SvREFCNT(obj->self): - 1);//D
170	#endif
171
172	++i; // further delay freeing	195	++i; // further delay freeing
		196
		197	if (!(i & 0x3ff))
		198	break;
173	}//D	199	}
174	else	200	else
175	{	201	{
176	//Dfprintf (stderr, "deleteing %d:%p:%s\n", i, obj,typeid (*obj).name ());//D
177	mortals.erase (i);	202	mortals.erase (i);
178	delete obj;	203	delete obj;
179	}	204	}
180	}	205	}
181	}	206	}
…		…
206		231
207	static int	232	static int
208	attachable_free (pTHX_ SV *sv, MAGIC *mg)	233	attachable_free (pTHX_ SV *sv, MAGIC *mg)
209	{	234	{
210	attachable *at = (attachable *)mg->mg_ptr;	235	attachable *at = (attachable *)mg->mg_ptr;
211	assert (!(at->flags & attachable::F_BORROWED));//D//TODO//remove when stable	236
		237	//TODO: check if transaction behaviour is really required here
		238	if (SV *self = (SV *)at->self)
		239	{
212	at->self = 0;	240	at->self = 0;
		241	SvREFCNT_dec (self);
		242	}
		243
213	// next line makes sense, but most objects still have refcnt 0 by default	244	// next line makes sense, but most objects still have refcnt 0 by default
214	//at->refcnt_chk ();	245	//at->refcnt_chk ();
215	return 0;	246	return 0;
216	}	247	}
217		248
218	static MGVTBL vtbl_attachable = {0, 0, 0, 0, attachable_free};	249	MGVTBL attachable::vtbl = {0, 0, 0, 0, attachable_free};
219		250
220	SV *	251	static SV *
221	newSVattachable (attachable *obj, HV *stash)	252	newSVattachable (attachable *obj, HV *stash)
222	{	253	{
223	if (!obj)	254	if (!obj)
224	return &PL_sv_undef;	255	return &PL_sv_undef;
225		256
226	if (!obj->self)	257	if (!obj->self)
227	{	258	{
228	obj->self = newHV ();	259	obj->self = newHV ();
229	sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &vtbl_attachable, (char *)obj, 0);	260	sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char *)obj, 0);
230		261
231	// borrow the refcnt from the object	262	// now bless the object _once_
232	obj->flags |= attachable::F_BORROWED;	263	return sv_bless (newRV_inc ((SV *)obj->self), stash);
233	obj->refcnt_dec ();
234	}	264	}
		265	else
		266	{
		267	SV *sv = newRV_inc ((SV *)obj->self);
235		268
236	return sv_bless (newRV_inc ((SV *)obj->self), stash);	269	if (Gv_AMG (stash)) // handle overload correctly, as the perl core does not
		270	SvAMAGIC_on (sv);
		271
		272	return sv;
		273	}
237	}	274	}
238		275
239	static void	276	static void
240	clearSVptr (SV *sv)	277	clearSVptr (SV *sv)
241	{	278	{
…		…
294	inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }	331	inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }
295		332
296	inline SV *to_sv (object & v) { return to_sv (&v); }	333	inline SV *to_sv (object & v) { return to_sv (&v); }
297	inline SV *to_sv (living & v) { return to_sv (&v); }	334	inline SV *to_sv (living & v) { return to_sv (&v); }
298		335
299	//TODO:
300	inline SV *to_sv (New_Face * v) { return to_sv (v->name); }	336	inline SV *to_sv (facetile * v) { return to_sv (v->name); }
301	inline SV *to_sv (treasurelist * v) { return to_sv (v->name); }	337	inline SV *to_sv (treasurelist * v) { return to_sv (v->name); }
302		338
303	inline SV *to_sv (UUID v)	339	inline SV *to_sv (UUID v)
304	{	340	{
305	char buf[128];	341	char buf[128];
…		…
325	inline void sv_to (SV *sv, client * &v) { v = (client *)(attachable *)SvPTR_ornull (sv, "cf::client"); }	361	inline void sv_to (SV *sv, client * &v) { v = (client *)(attachable *)SvPTR_ornull (sv, "cf::client"); }
326	inline void sv_to (SV *sv, player * &v) { v = (player *)(attachable *)SvPTR_ornull (sv, "cf::player"); }	362	inline void sv_to (SV *sv, player * &v) { v = (player *)(attachable *)SvPTR_ornull (sv, "cf::player"); }
327	inline void sv_to (SV *sv, object * &v) { v = (object *)(attachable *)SvPTR_ornull (sv, "cf::object"); }	363	inline void sv_to (SV *sv, object * &v) { v = (object *)(attachable *)SvPTR_ornull (sv, "cf::object"); }
328	inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)(attachable *)SvPTR_ornull (sv, "cf::arch"); }	364	inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)(attachable *)SvPTR_ornull (sv, "cf::arch"); }
329	inline void sv_to (SV *sv, maptile * &v) { v = (maptile *)(attachable *)SvPTR_ornull (sv, "cf::map"); }	365	inline void sv_to (SV *sv, maptile * &v) { v = (maptile *)(attachable *)SvPTR_ornull (sv, "cf::map"); }
		366	inline void sv_to (SV *sv, attachable * &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); }
330	inline void sv_to (SV *sv, partylist * &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }	367	inline void sv_to (SV *sv, partylist * &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }
331	inline void sv_to (SV *sv, region * &v) { v = (region *)SvPTR_ornull (sv, "cf::region"); }	368	inline void sv_to (SV *sv, region * &v) { v = (region *)SvPTR_ornull (sv, "cf::region"); }
332	inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }	369	inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }
333		370
334	inline void sv_to (SV *sv, New_Face * &v) { v = &new_faces[FindFace (SvPV_nolen (sv), 0)]; } //TODO	371	inline void sv_to (SV *sv, facetile * &v) { v = &new_faces[FindFace (SvPV_nolen (sv), 0)]; }
335	inline void sv_to (SV *sv, treasurelist * &v) { v = find_treasurelist (SvPV_nolen (sv)); } // TODO	372	inline void sv_to (SV *sv, treasurelist * &v) { v = find_treasurelist (SvPV_nolen (sv)); }
336		373
337	template<class T>	374	template<class T>
338	inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }	375	inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }
339		376
340	template<int N>	377	template<int N>
…		…
475	{	512	{
476	if (!ext->cb)	513	if (!ext->cb)
477	ext->cb = newAV ();	514	ext->cb = newAV ();
478		515
479	return newRV_inc ((SV *)ext->cb);	516	return newRV_inc ((SV *)ext->cb);
480	}
481
482	#if 0
483	void attachable::clear ()
484	{
485	if (self)
486	{
487	// disconnect Perl from C, to avoid crashes
488	sv_unmagic (SvRV ((SV *)self), PERL_MAGIC_ext);
489
490	// clear the perl hash, might or might not be a good idea
491	hv_clear ((HV *)SvRV ((SV *)self));
492
493	SvREFCNT_dec (self);
494	self = 0;
495	}
496
497	if (cb)
498	{
499	SvREFCNT_dec (cb);
500	cb = 0;
501	}
502
503	attach = 0;
504	}
505	#endif
506
507	void attachable::optimise ()
508	{
509	if (self
510	&& SvREFCNT (self) == 1
511	&& !HvTOTALKEYS (self))
512	{
513	flags &= ~F_BORROWED;
514	refcnt_inc ();
515	SvREFCNT_dec ((SV *)self);
516	}
517	}
518
519	/////////////////////////////////////////////////////////////////////////////
520
521	#include "kw_hash.h"
522
523	object_freezer::object_freezer ()
524	: dynbuf (128 * 1024, 64 * 1024)
525	{
526	av = newAV ();
527	}
528
529	object_freezer::~object_freezer ()
530	{
531	SvREFCNT_dec (av);
532	}
533
534	void object_freezer::put (attachable *ext)
535	{
536	ext->optimise ();
537
538	if (ext->self)
539	{
540	int idx = AvFILLp ((AV *)av) + 1;
541	av_store (av, idx, newRV_inc ((SV *)ext->self));
542
543	add ((void *)"oid ", 4);
544	add ((sint32)idx);
545	add ('\n');
546	}
547	}
548
549	bool object_freezer::save (const char *filename)
550	{
551	dSP;
552	ENTER;
553	SAVETMPS;
554	PUSHMARK (SP);
555	EXTEND (SP, 3);
556	PUSHs (sv_2mortal (newSVpv (filename, 0)));
557	PUSHs (sv_2mortal (newRV_noinc (newSVpvn ((char *)linearise (), size ()))));
558	PUSHs (sv_2mortal (newRV_inc ((SV *)av)));
559	PUTBACK;
560	call_pv ("cf::object_freezer_save", G_VOID | G_DISCARD | G_EVAL);
561	FREETMPS;
562	LEAVE;
563	}
564
565	char *object_freezer::as_string ()
566	{
567	dSP;
568	ENTER;
569	SAVETMPS;
570	PUSHMARK (SP);
571	EXTEND (SP, 3);
572	PUSHs (sv_2mortal (newRV_noinc (newSVpvn ((char *)linearise (), size ()))));
573	PUSHs (sv_2mortal (newRV_inc ((SV *)av)));
574	PUTBACK;
575
576	char *res = call_pv ("cf::object_freezer_as_string", G_SCALAR | G_EVAL) > 0
577	? strdup (SvPVbyte_nolen (POPs))
578	: strdup ("[fatal error]");
579
580	FREETMPS;
581	LEAVE;
582
583	return res;
584	}
585
586	int fprintf (object_freezer &freezer, const char *format, ...)
587	{
588	va_list ap;
589
590	va_start (ap, format);
591
592	int len = vsnprintf ((char *)freezer.force (1024), 1024, format, ap);
593
594	if (len >= 0)
595	freezer.alloc (len);
596
597	va_end (ap);
598	}
599
600	int fputs (const char *s, object_freezer &freezer)
601	{
602	freezer.add (s);
603	}
604
605	static const char thawer_eof[] = "\n\n\n\0\0\0";
606
607	object_thawer::object_thawer (const char *filename)
608	{
609	static const char eof[] = "\n\n\n\0\0\0";
610
611	av = 0;
612	text = 0;
613	line = 0;
614
615	if (filename)
616	{
617	dSP;
618	ENTER;
619	SAVETMPS;
620	PUSHMARK (SP);
621	XPUSHs (sv_2mortal (newSVpv (filename, 0)));
622	PUTBACK;
623
624	if (2 == call_pv ("cf::object_thawer_load", G_ARRAY | G_EVAL))
625	{
626	SPAGAIN;
627
628	// second value - perl objects
629	{
630	SV *sv = POPs;
631	if (SvROK (sv))
632	av = (AV *)SvREFCNT_inc (SvRV (sv));
633	}
634
635	// first value - text part, pad with 3 zeroes
636	{
637	SV *sv = POPs;
638	STRLEN len;
639	char *sv_ = SvPVbyte (sv, len);
640	text = newSV (len + sizeof (eof));
641	SvCUR_set (text, len);
642	memcpy (SvPVX (text), sv_, len);
643	memcpy (SvEND (text), eof, sizeof (eof)); // just to be sure
644
645	line = SvPVX (text);
646	}
647	}
648
649	PUTBACK;
650	FREETMPS;
651	LEAVE;
652	}
653	}
654
655	object_thawer::object_thawer (const char *data, AV *perlav)
656	{
657	av = perlav;
658	text = newSVpv (data, 0);
659	sv_catpv (text, thawer_eof);
660	line = SvPVbyte_nolen (text);
661	}
662
663	void object_thawer::get (attachable *obj, int oid)
664	{
665	if (!av || oid < 0) // this is actually an error of sorts
666	return;
667
668	// object must be virgin
669	assert (!obj->self);
670
671	SV **svp = av_fetch ((AV *)av, oid, 0);
672
673	if (!svp || !SvROK (*svp))
674	{
675	printf ("trying to thaw duplicate or never-issued oid %d, ignoring.\n", oid);
676	return;
677	}
678
679	obj->self = (HV *)SvRV (*svp);
680	SvRV_set (*svp, &PL_sv_undef);
681
682	sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &vtbl_attachable, (char *)obj, 0);
683	obj->reattach ();
684
685	// borrow a refcount for the perl object
686	obj->flags |= attachable::F_BORROWED;
687	obj->refcnt_dec ();
688	}
689
690	object_thawer::~object_thawer ()
691	{
692	if (text) SvREFCNT_dec (text);
693	if (av) SvREFCNT_dec (av);
694	}
695
696	char *fgets (char *s, int n, object_thawer &thawer)
697	{
698	char *p = thawer.line;
699	char *q = s;
700
701	if (!p)
702	return 0;
703
704	while (--n)
705	{
706	if (!*p)
707	break;
708
709	*q++ = *p;
710
711	if (*p++ == '\n')
712	break;
713	}
714
715	*q = 0;
716	thawer.line = p;
717
718	return s == q ? 0 : s;
719	}
720
721	keyword object_thawer::get_kv ()
722	{
723	if (!line)
724	return KW_EOF;
725
726	for (;;)
727	{
728	char *p = line;
729
730	if (!*p)
731	return KW_EOF;
732
733	// parse keyword
734	while (*p > ' ')
735	p++;
736
737	int klen = p - line;
738
739	if (*p++ != '\n')
740	{
741	// parse value
742	while (*(unsigned char *)p <= ' ' && *p != '\n') // skip 0x01 .. 0x20
743	++p;
744
745	last_value = p;
746
747	while (*p != '\n')
748	p++;
749
750	*p++ = 0;
751	}
752	else
753	last_value = 0;
754
755	line [klen] = 0;
756	keyword_idx *kw = kw_lex::match (line, klen);
757
758	//printf ("KV %d<%s,%s>\n", kw ? kw->index : 0, line, last_value);//D
759
760	if (kw)
761	{
762	line = p;
763	return kw->index;
764	}
765	else if (!*line || *line == '#')
766	{
767	// empty/comment line
768	line = p;
769	}
770	else
771	return KW_ERROR;
772	}
773	}
774
775	void object_thawer::get (shstr &sh) const
776	{
777	if (last_value)
778	sh = last_value;
779	else
780	{
781	sh = "<value missing>";
782	LOG (llevError, "keyword requires value: <%s>\n", line);//TODO: add filename
783	}
784	}
785
786	void object_thawer::get_ml (keyword kend, shstr &sh)
787	{
788	char kw[128];
789
790	int klen = keyword_len [kend];
791
792	kw [0] = '\n';
793	memcpy (kw + 1, keyword_str [kend], klen);
794	kw [klen + 1] = '\n';
795	kw [klen + 2] = 0;
796
797	// first test for completely empty msg... "endXXX\n"
798	if (!strncmp (line, kw + 1, klen + 1))
799	{
800	sh = 0;
801
802	line += klen + 1;
803
804	return;
805	}
806	else
807	{
808	// multi-line strings are delimited by "\nendXXX\n" or "endXXX\n" (NULL)
809
810	char *end = strstr (line, kw);
811
812	if (!end)
813	{
814	sh = 0;
815	return;
816	}
817
818	*end = 0;
819	sh = line;
820
821	line = end + keyword_len [kend] + 1;
822
823	while (*line++ != '\n')
824	;
825	}
826	}
827
828	sint32 object_thawer::get_sint32 () const
829	{
830	char *p = last_value;
831
832	if (!p)
833	return 0;
834
835	sint32 val = 0;
836	bool negate;
837
838	if (*p == '-')
839	{
840	negate = true;
841	++p;
842	}
843	else
844	negate = false;
845
846	do
847	{
848	val *= 10;
849	val += *p++ - '0';
850	}
851	while (*p);
852
853	return negate ? -val : val;
854	}
855
856	sint64 object_thawer::get_sint64 () const
857	{
858	return last_value ? atoll (last_value) : 0;
859	}
860
861	double object_thawer::get_double () const
862	{
863	return last_value ? atof (last_value) : 0;
864	}	517	}
865		518
866	/////////////////////////////////////////////////////////////////////////////	519	/////////////////////////////////////////////////////////////////////////////
867		520
868	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)	521	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
…		…
1095		748
1096	// short-circuit processing if no callbacks found/defined	749	// short-circuit processing if no callbacks found/defined
1097	if (!callbacks)	750	if (!callbacks)
1098	return 0;	751	return 0;
1099		752
1100	dSP;	753	CALL_BEGIN (3);
1101	ENTER;
1102	SAVETMPS;
1103
1104	PUSHMARK (SP);
1105	EXTEND (SP, 3);
1106
1107	PUSHs (sv_2mortal (newSViv (event))); // only used for debugging nowadays	754	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays
1108	PUSHs (sv_2mortal (newRV_noinc ((SV *)callbacks)));	755	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));
1109		756
1110	//TODO: unhack	757	//TODO: unhack
1111	if (object *op = is_a<object>(this)) PUSHs (sv_2mortal (newSVdt (DT_OBJECT, op)));	758	if (object *op = is_a<object>(this)) CALL_ARG_SV (newSVdt (DT_OBJECT, op));
1112	else if (player *pl = is_a<player>(this)) PUSHs (sv_2mortal (newSVdt (DT_PLAYER, pl)));	759	else if (player *pl = is_a<player>(this)) CALL_ARG_SV (newSVdt (DT_PLAYER, pl));
1113	else if (client *ns = is_a<client>(this)) PUSHs (sv_2mortal (newSVdt (DT_CLIENT, ns)));	760	else if (client *ns = is_a<client>(this)) CALL_ARG_SV (newSVdt (DT_CLIENT, ns));
1114	else if (maptile *m = is_a<maptile>(this)) PUSHs (sv_2mortal (newSVdt (DT_MAP, m)));	761	else if (maptile *m = is_a<maptile>(this)) CALL_ARG_SV (newSVdt (DT_MAP, m));
1115	else if (global *gl = is_a<global>(this)) /*nop*/;	762	else if (global *gl = is_a<global>(this)) /*nop*/;
1116	else	763	else
1117	abort (); //TODO	764	abort (); //TODO
1118		765
1119	for (;;)	766	for (;;)
…		…
1133	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));	780	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
1134	}	781	}
1135		782
1136	va_end (ap);	783	va_end (ap);
1137		784
1138	PUTBACK;	785	CALL_CALL ("cf::do_invoke", G_SCALAR);
1139	int count = call_pv ("cf::do_invoke", G_SCALAR | G_EVAL);
1140	SPAGAIN;
1141
1142	count = count > 0 ? POPi : 0;	786	count = count > 0 ? POPi : 0;
1143		787
1144	FREETMPS;	788	CALL_END;
1145	LEAVE;
1146		789
1147	return count;	790	return count;
1148	}	791	}
1149		792
1150	SV *	793	SV *
…		…
1173	return SvNV (cfperl_result (idx));	816	return SvNV (cfperl_result (idx));
1174	}	817	}
1175		818
1176	/////////////////////////////////////////////////////////////////////////////	819	/////////////////////////////////////////////////////////////////////////////
1177		820
		821	void
		822	cfperl_emergency_save ()
		823	{
		824	CALL_BEGIN (0);
		825	CALL_CALL ("cf::emergency_save", G_VOID);
		826	CALL_END;
		827	}
		828
		829	maptile *
		830	maptile::find_sync (const char *path, maptile *origin)
		831	{
		832	CALL_BEGIN (2);
		833	CALL_ARG (path);
		834	CALL_ARG (origin);
		835	CALL_CALL ("cf::map::find_sync", G_SCALAR);
		836
		837	maptile *retval;
		838
		839	if (count)
		840	sv_to (POPs, retval);
		841	else
		842	retval = 0;
		843
		844	CALL_END;
		845
		846	return retval;
		847	}
		848
		849	maptile *
		850	maptile::find_async (const char *path, maptile *origin)
		851	{
		852	CALL_BEGIN (2);
		853	CALL_ARG (path);
		854	CALL_ARG (origin);
		855	CALL_CALL ("cf::map::find_async", G_SCALAR);
		856
		857	maptile *retval;
		858
		859	if (count)
		860	sv_to (POPs, retval);
		861	else
		862	retval = 0;
		863
		864	CALL_END;
		865
		866	return retval;
		867	}
		868
		869	void
		870	maptile::do_load_sync ()
		871	{
		872	CALL_BEGIN (1);
		873	CALL_ARG (this);
		874	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);
		875	CALL_END;
		876	}
		877
		878	void
		879	maptile::change_all_map_light (int change)
		880	{
		881	CALL_BEGIN (1);
		882	CALL_ARG (change);
		883	CALL_CALL ("cf::map::change_all_map_light", G_VOID);
		884	CALL_END;
		885	}
		886
		887	void
		888	object::enter_exit (object *exit)
		889	{
		890	if (type != PLAYER)
		891	return;
		892
		893	CALL_BEGIN (2);
		894	CALL_ARG (this);
		895	CALL_ARG (exit);
		896	CALL_CALL ("cf::object::player::enter_exit", G_VOID);
		897	CALL_END;
		898	}
		899
		900	/////////////////////////////////////////////////////////////////////////////
		901
1178	struct EventAPI *watcher_base::GEventAPI;	902	struct EventAPI *watcher_base::GEventAPI;
		903	struct CoroAPI *coroapi::GCoroAPI;
		904
		905	int coroapi::cede_counter;
1179		906
1180	static void iw_dispatch (pe_event *ev)	907	static void iw_dispatch (pe_event *ev)
1181	{	908	{
1182	iw *w = (iw *)ev->ext_data;	909	iw *w = (iw *)ev->ext_data;
1183	w->call (*w);	910	w->call (*w);
…		…
1186	void	913	void
1187	iw::alloc ()	914	iw::alloc ()
1188	{	915	{
1189	pe = GEventAPI->new_idle (0, 0);	916	pe = GEventAPI->new_idle (0, 0);
1190		917
		918	WaREENTRANT_off (pe);
1191	pe->base.callback = (void *)iw_dispatch;	919	pe->base.callback = (void *)iw_dispatch;
1192	pe->base.ext_data = (void *)this;	920	pe->base.ext_data = (void *)this;
1193	}	921	}
1194		922
1195	static void iow_dispatch (pe_event *ev)	923	static void iow_dispatch (pe_event *ev)
…		…
1201	void	929	void
1202	iow::alloc ()	930	iow::alloc ()
1203	{	931	{
1204	pe = GEventAPI->new_io (0, 0);	932	pe = GEventAPI->new_io (0, 0);
1205		933
		934	WaREENTRANT_off (pe);
1206	pe->base.callback = (void *)iow_dispatch;	935	pe->base.callback = (void *)iow_dispatch;
1207	pe->base.ext_data = (void *)this;	936	pe->base.ext_data = (void *)this;
1208		937
1209	pe->fd = -1;	938	pe->fd = -1;
1210	pe->poll = 0;	939	pe->poll = 0;
…		…
1246	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);	975	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
1247	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);	976	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
1248	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);	977	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
1249	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);	978	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
1250		979
		980	sv_runtime = get_sv ("cf::RUNTIME", 1);
		981	sv_upgrade (sv_runtime, SVt_NV);
		982
1251	cb_global = get_av ("cf::CB_GLOBAL", 1);	983	cb_global = get_av ("cf::CB_GLOBAL", 1);
1252	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);	984	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
1253	cb_object = get_av ("cf::CB_OBJECT", 1);	985	cb_object = get_av ("cf::CB_OBJECT", 1);
1254	cb_player = get_av ("cf::CB_PLAYER", 1);	986	cb_player = get_av ("cf::CB_PLAYER", 1);
1255	cb_client = get_av ("cf::CB_CLIENT", 1);	987	cb_client = get_av ("cf::CB_CLIENT", 1);
…		…
1261		993
1262	BOOT:	994	BOOT:
1263	{	995	{
1264	_connect_to_perl ();	996	_connect_to_perl ();
1265		997
1266	I_EVENT_API (PACKAGE);
1267	watcher_base::GEventAPI = GEventAPI;	998	I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;
1268	I_CORO_API (PACKAGE);	999	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
1269		1000
1270	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));	1001	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
1271		1002
1272	static const struct {	1003	static const struct {
1273	const char *name;	1004	const char *name;
…		…
1536	const_iv (FLAG_ACTIVATE_ON_RELEASE)	1267	const_iv (FLAG_ACTIVATE_ON_RELEASE)
1537	const_iv (FLAG_IS_WATER)	1268	const_iv (FLAG_IS_WATER)
1538	const_iv (FLAG_CONTENT_ON_GEN)	1269	const_iv (FLAG_CONTENT_ON_GEN)
1539	const_iv (FLAG_IS_A_TEMPLATE)	1270	const_iv (FLAG_IS_A_TEMPLATE)
1540	const_iv (FLAG_IS_BUILDABLE)	1271	const_iv (FLAG_IS_BUILDABLE)
		1272	const_iv (FLAG_DESTROY_ON_DEATH)
		1273	const_iv (FLAG_NO_MAP_SAVE)
1541		1274
1542	const_iv (NDI_BLACK)	1275	const_iv (NDI_BLACK)
1543	const_iv (NDI_WHITE)	1276	const_iv (NDI_WHITE)
1544	const_iv (NDI_NAVY)	1277	const_iv (NDI_NAVY)
1545	const_iv (NDI_RED)	1278	const_iv (NDI_RED)
…		…
1587	const_iv (P_BLOCKSVIEW)	1320	const_iv (P_BLOCKSVIEW)
1588	const_iv (P_PLAYER)	1321	const_iv (P_PLAYER)
1589	const_iv (P_NO_MAGIC)	1322	const_iv (P_NO_MAGIC)
1590	const_iv (P_IS_ALIVE)	1323	const_iv (P_IS_ALIVE)
1591	const_iv (P_NO_CLERIC)	1324	const_iv (P_NO_CLERIC)
1592	const_iv (P_NEED_UPDATE)
1593	const_iv (P_OUT_OF_MAP)	1325	const_iv (P_OUT_OF_MAP)
1594	const_iv (P_NEW_MAP)	1326	const_iv (P_NEW_MAP)
		1327	const_iv (P_UPTODATE)
1595		1328
1596	const_iv (UP_OBJ_INSERT)	1329	const_iv (UP_OBJ_INSERT)
1597	const_iv (UP_OBJ_REMOVE)	1330	const_iv (UP_OBJ_REMOVE)
1598	const_iv (UP_OBJ_CHANGE)	1331	const_iv (UP_OBJ_CHANGE)
1599	const_iv (UP_OBJ_FACE)	1332	const_iv (UP_OBJ_FACE)
…		…
1730	const_iv (ATNR_BLIND)	1463	const_iv (ATNR_BLIND)
1731	const_iv (ATNR_INTERNAL)	1464	const_iv (ATNR_INTERNAL)
1732	const_iv (ATNR_LIFE_STEALING)	1465	const_iv (ATNR_LIFE_STEALING)
1733	const_iv (ATNR_DISEASE)	1466	const_iv (ATNR_DISEASE)
1734		1467
1735	const_iv (MAP_FLUSH)
1736	const_iv (MAP_PLAYER_UNIQUE)
1737	const_iv (MAP_BLOCK)
1738	const_iv (MAP_STYLE)
1739	const_iv (MAP_OVERLAY)
1740
1741	const_iv (MAP_IN_MEMORY)	1468	const_iv (MAP_IN_MEMORY)
1742	const_iv (MAP_SWAPPED)	1469	const_iv (MAP_SWAPPED)
1743	const_iv (MAP_LOADING)	1470	const_iv (MAP_LOADING)
1744	const_iv (MAP_SAVING)	1471	const_iv (MAP_SAVING)
1745		1472
…		…
1758	const_iv (ST_SETUP)	1485	const_iv (ST_SETUP)
1759	const_iv (ST_PLAYING)	1486	const_iv (ST_PLAYING)
1760	const_iv (ST_CUSTOM)	1487	const_iv (ST_CUSTOM)
1761		1488
1762	const_iv (ST_CHANGE_CLASS)	1489	const_iv (ST_CHANGE_CLASS)
1763	const_iv (ST_CONFIRM_QUIT)	1490
1764	const_iv (ST_GET_PARTY_PASSWORD)	1491	const_iv (IO_HEADER)
		1492	const_iv (IO_OBJECTS)
		1493	const_iv (IO_UNIQUES)
		1494
		1495	// random map generator
		1496	const_iv (LAYOUT_NONE)
		1497	const_iv (LAYOUT_ONION)
		1498	const_iv (LAYOUT_MAZE)
		1499	const_iv (LAYOUT_SPIRAL)
		1500	const_iv (LAYOUT_ROGUELIKE)
		1501	const_iv (LAYOUT_SNAKE)
		1502	const_iv (LAYOUT_SQUARE_SPIRAL)
		1503
		1504	const_iv (RMOPT_RANDOM)
		1505	const_iv (RMOPT_CENTERED)
		1506	const_iv (RMOPT_LINEAR)
		1507	const_iv (RMOPT_BOTTOM_C)
		1508	const_iv (RMOPT_BOTTOM_R)
		1509	const_iv (RMOPT_IRR_SPACE)
		1510	const_iv (RMOPT_WALL_OFF)
		1511	const_iv (RMOPT_WALLS_ONLY)
		1512	const_iv (RMOPT_NO_DOORS)
		1513
		1514	const_iv (SYMMETRY_RANDOM)
		1515	const_iv (SYMMETRY_NONE)
		1516	const_iv (SYMMETRY_X)
		1517	const_iv (SYMMETRY_Y)
		1518	const_iv (SYMMETRY_XY)
1765	};	1519	};
1766		1520
1767	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	1521	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1768	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));	1522	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1769		1523
…		…
1794		1548
1795	void _global_reattach ()	1549	void _global_reattach ()
1796	CODE:	1550	CODE:
1797	{	1551	{
1798	// reattach to all attachable objects in the game.	1552	// reattach to all attachable objects in the game.
1799	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)	1553	for_all_clients (ns)
1800	(*i)->reattach ();	1554	ns->reattach ();
1801		1555
1802	for_all_players (pl)	1556	for_all_players (pl)
1803	pl->reattach ();	1557	pl->reattach ();
1804		1558
1805	for_all_maps (m)	1559	//TODO
1806	m->reattach ();	1560	//for (map_container::iterator i = maps.begin (); i != maps.end (); ++i)
		1561	// i->second->reattach ();
1807		1562
1808	for (object *op = object::first; op; op = op->next)	1563	for_all_objects (op)
1809	op->reattach ();	1564	op->reattach ();
1810	}	1565	}
1811		1566
1812	NV floor (NV x)	1567	NV floor (NV x)
1813		1568
1814	NV ceil (NV x)	1569	NV ceil (NV x)
1815		1570
		1571	NV rndm (...)
		1572	CODE:
		1573	switch (items)
		1574	{
		1575	case 0: RETVAL = rndm (); break;
		1576	case 1: RETVAL = rndm (SvUV (ST (0))); break;
		1577	case 2: RETVAL = rndm (SvIV (ST (0)), SvIV (ST (1))); break;
		1578	default: croak ("cf::rndm requires none, one or two parameters."); break;
		1579	}
		1580	OUTPUT:
		1581	RETVAL
		1582
1816	void server_tick ()	1583	void server_tick ()
		1584	CODE:
		1585	runtime = SvNVx (sv_runtime);
		1586	server_tick ();
1817		1587
1818	void	1588	void
1819	LOG (int level, char *msg)	1589	LOG (int level, char *msg)
1820	PROTOTYPE: $$	1590	PROTOTYPE: $$
1821	C_ARGS: (LogLevel)level, "%s", msg	1591	C_ARGS: (LogLevel)level, "%s", msg
…		…
1861	case 5: RETVAL = settings.playerdir; break;	1631	case 5: RETVAL = settings.playerdir; break;
1862	case 6: RETVAL = settings.datadir ; break;	1632	case 6: RETVAL = settings.datadir ; break;
1863	}	1633	}
1864	OUTPUT: RETVAL	1634	OUTPUT: RETVAL
1865		1635
		1636	void abort ()
		1637
		1638	void fork_abort (char *cause = "cf::fork_abort")
		1639
		1640	void cleanup (const char *cause, bool make_core = false)
		1641
		1642	void emergency_save ()
		1643
		1644	UV sv_2watcher (SV *w)
		1645	CODE:
		1646	RETVAL = (UV)GEventAPI->sv_2watcher (w);
		1647	OUTPUT:
		1648	RETVAL
		1649
1866	void _exit (int status = 0)	1650	void _exit (int status = 0)
		1651
		1652	#if _POSIX_MEMLOCK
		1653
		1654	int mlockall (int flags = MCL_CURRENT | MCL_FUTURE)
		1655
		1656	int munlockall ()
		1657
		1658	#endif
1867		1659
1868	int find_animation (char *text)	1660	int find_animation (char *text)
1869	PROTOTYPE: $	1661	PROTOTYPE: $
1870		1662
1871	int random_roll (int min, int max, object *op, int goodbad);	1663	int random_roll (int min, int max, object *op, int goodbad);
…		…
1918	CODE:	1710	CODE:
1919	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);	1711	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
1920	OUTPUT:	1712	OUTPUT:
1921	RETVAL	1713	RETVAL
1922		1714
1923	#bool	1715	int mortals_size ()
1924	#destroyed (attachable *at)	1716	CODE:
1925	#	1717	RETVAL = attachable::mortals.size ();
1926	#void	1718	OUTPUT: RETVAL
1927	#destroy (attachable *at)	1719
		1720	#object *mortals (U32 index)
		1721	# CODE:
		1722	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;
		1723	# OUTPUT: RETVAL
		1724
		1725	INCLUDE: $PERL genacc attachable ../include/cfperl.h |
1928		1726
1929	MODULE = cf PACKAGE = cf::global	1727	MODULE = cf PACKAGE = cf::global
1930		1728
1931	int invoke (SV *klass, int event, ...)	1729	int invoke (SV *klass, int event, ...)
1932	CODE:	1730	CODE:
…		…
1948	RETVAL = op->invoke ((event_type)event, ARG_AV (av), DT_END);	1746	RETVAL = op->invoke ((event_type)event, ARG_AV (av), DT_END);
1949	OUTPUT: RETVAL	1747	OUTPUT: RETVAL
1950		1748
1951	SV *registry (object *op)	1749	SV *registry (object *op)
1952		1750
1953	void mortals ()	1751	int objects_size ()
1954	PPCODE:	1752	CODE:
1955	EXTEND (SP, object::mortals.size ());
1956	for (AUTODECL (i, object::mortals.begin ()); i != object::mortals.end (); ++i)
1957	PUSHs (to_sv (*i));
1958
1959	object *first ()
1960	CODE:
1961	RETVAL = object::first;	1753	RETVAL = objects.size ();
		1754	OUTPUT: RETVAL
		1755
		1756	object *objects (U32 index)
		1757	CODE:
		1758	RETVAL = index < objects.size () ? objects [index] : 0;
		1759	OUTPUT: RETVAL
		1760
		1761	int actives_size ()
		1762	CODE:
		1763	RETVAL = actives.size ();
		1764	OUTPUT: RETVAL
		1765
		1766	object *actives (U32 index)
		1767	CODE:
		1768	RETVAL = index < actives.size () ? actives [index] : 0;
1962	OUTPUT: RETVAL	1769	OUTPUT: RETVAL
1963		1770
1964	# missing properties	1771	# missing properties
1965		1772
1966	object *head (object *op)	1773	object *head (object *op)
1967	PROTOTYPE: $	1774	PROTOTYPE: $
1968	CODE:	1775	CODE:
1969	RETVAL = op->head ? op->head : op;	1776	RETVAL = op->head_ ();
1970	OUTPUT: RETVAL	1777	OUTPUT: RETVAL
1971		1778
1972	int is_head (object *op)	1779	int is_head (object *op)
1973	PROTOTYPE: $	1780	PROTOTYPE: $
1974	CODE:	1781	CODE:
1975	RETVAL = !op->head;	1782	RETVAL = op->head_ () == op;
1976	OUTPUT: RETVAL	1783	OUTPUT: RETVAL
1977		1784
1978	void	1785	void
1979	inv (object *obj)	1786	inv (object *obj)
1980	PROTOTYPE: $	1787	PROTOTYPE: $
…		…
1988	void	1795	void
1989	set_animation (object *op, int idx)	1796	set_animation (object *op, int idx)
1990	CODE:	1797	CODE:
1991	SET_ANIMATION (op, idx);	1798	SET_ANIMATION (op, idx);
1992		1799
1993	void
1994	object::drain_stat ()
1995
1996	void
1997	object::drain_specific_stat (int stat)
1998
1999	void
2000	object::change_luck (int change)
2001
2002	void
2003	object::add_statbonus ()
2004
2005	void
2006	object::remove_statbonus ()
2007
2008	object *find_best_object_match (object *op, const char *match)	1800	object *find_best_object_match (object *op, const char *match)
2009		1801
2010	object *find_marked_object (object *op)	1802	object *find_marked_object (object *op)
2011		1803
2012	int need_identify (object *obj);	1804	int need_identify (object *obj);
…		…
2025		1817
2026	void apply_below (object *op)	1818	void apply_below (object *op)
2027	CODE:	1819	CODE:
2028	player_apply_below (op);	1820	player_apply_below (op);
2029		1821
2030	void remove (object *op)
2031	CODE:
2032	op->remove ();
2033
2034	void
2035	object::destroy (bool destroy_inventory = false)
2036
2037	void
2038	object::destroy_inv (bool drop_to_ground = false)
2039
2040	void
2041	object::set_speed (float speed)
2042
2043	object *cf_object_present_archname_inside (object *op, char *whatstr)	1822	object *cf_object_present_archname_inside (object *op, char *whatstr)
2044		1823
2045	int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)	1824	int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)
2046		1825
2047	int cf_object_change_map (object *op, int x, int y, maptile *map)	1826	int cf_object_change_map (object *op, int x, int y, maptile *map)
2048		1827
		1828	#//TODO
2049	object *clone (object *op, int recursive = 0)	1829	object *clone_ (object *op, int recursive = 0)
2050	CODE:	1830	CODE:
2051	if (recursive)	1831	if (recursive)
2052	RETVAL = object_create_clone (op);	1832	RETVAL = object_create_clone (op);
2053	else	1833	else
2054	{	1834	{
…		…
2098		1878
2099	void drop (object *who, object *op)	1879	void drop (object *who, object *op)
2100		1880
2101	void pick_up (object *who, object *op)	1881	void pick_up (object *who, object *op)
2102		1882
2103	object *cf_object_insert_object (object *op, object *container)
2104
2105	object *cf_object_insert_in_ob (object *ob, object *where)
2106
2107	int cf_object_teleport (object *op, maptile *map, int x, int y)	1883	int cf_object_teleport (object *op, maptile *map, int x, int y)
2108		1884
2109	void update_object (object *op, int action)	1885	void update_object (object *op, int action)
2110		1886
2111	object *cf_create_object_by_name (const char *name)	1887	object *cf_create_object_by_name (const char *name)
…		…
2158		1934
2159	player *contr (object *op)	1935	player *contr (object *op)
2160	CODE:	1936	CODE:
2161	RETVAL = op->contr;	1937	RETVAL = op->contr;
2162	OUTPUT: RETVAL	1938	OUTPUT: RETVAL
2163
2164	void
2165	object::roll_stats ()
2166
2167	void
2168	object::update_stats ()
2169
2170	void
2171	object::swap_stats (int a, int b)
2172		1939
2173	const char *get_ob_key_value (object *op, const char *key)	1940	const char *get_ob_key_value (object *op, const char *key)
2174		1941
2175	bool set_ob_key_value (object *op, const char *key, const char *value = 0, int add_key = 1)	1942	bool set_ob_key_value (object *op, const char *key, const char *value = 0, int add_key = 1)
2176		1943
…		…
2213	RETVAL = op->contr;	1980	RETVAL = op->contr;
2214	OUTPUT: RETVAL	1981	OUTPUT: RETVAL
2215		1982
2216	void check_score (object *op)	1983	void check_score (object *op)
2217		1984
2218	void cf_player_message (object *obj, char *txt, int flags = NDI_ORANGE | NDI_UNIQUE)	1985	void message (object *op, char *txt, int flags = NDI_ORANGE | NDI_UNIQUE)
		1986	CODE:
		1987	new_draw_info (flags, 0, op, txt);
2219		1988
2220	object *cf_player_send_inventory (object *op)	1989	object *cf_player_send_inventory (object *op)
2221		1990
2222	char *cf_player_get_ip (object *op)	1991	char *cf_player_get_ip (object *op)
2223	ALIAS: ip = 0	1992	ALIAS: ip = 0
…		…
2236		2005
2237	void esrv_update_item (object *op, int what, object *item)	2006	void esrv_update_item (object *op, int what, object *item)
2238	C_ARGS: what, op, item	2007	C_ARGS: what, op, item
2239		2008
2240	void clear_los (object *op)	2009	void clear_los (object *op)
2241
2242	int command_reset (object *op, char *params)
2243
2244	int command_teleport (object *op, char *params)
2245		2010
2246	int command_summon (object *op, char *params)	2011	int command_summon (object *op, char *params)
2247		2012
2248	int command_arrest (object *op, char *params)	2013	int command_arrest (object *op, char *params)
2249		2014
…		…
2264	RETVAL = pl->invoke ((event_type)event, ARG_AV (av), DT_END);	2029	RETVAL = pl->invoke ((event_type)event, ARG_AV (av), DT_END);
2265	OUTPUT: RETVAL	2030	OUTPUT: RETVAL
2266		2031
2267	SV *registry (player *pl)	2032	SV *registry (player *pl)
2268		2033
2269	player *
2270	create ()
2271	CODE:
2272	RETVAL = player::create ();
2273	OUTPUT:
2274	RETVAL
2275
2276	player *
2277	load (const char *path)
2278	CODE:
2279	RETVAL = player::load (path);
2280	OUTPUT:
2281	RETVAL
2282
2283	void
2284	player::save (bool final = false)
2285
2286	void
2287	player::connect (client *ns)
2288
2289	void	2034	void
2290	save_stats (player *pl)	2035	save_stats (player *pl)
2291	CODE:	2036	CODE:
2292	pl->ob->stats.hp = pl->ob->stats.maxhp;	2037	pl->ob->stats.hp = pl->ob->stats.maxhp;
2293	pl->ob->stats.sp = pl->ob->stats.maxsp;	2038	pl->ob->stats.sp = pl->ob->stats.maxsp;
2294	pl->ob->stats.grace = pl->ob->stats.maxgrace;	2039	pl->ob->stats.grace = pl->ob->stats.maxgrace;
2295	pl->orig_stats = pl->ob->stats;	2040	pl->orig_stats = pl->ob->stats;
2296
2297	player *cf_player_find (char *name)
2298	PROTOTYPE: $
2299		2041
2300	void cf_player_move (player *pl, int dir)	2042	void cf_player_move (player *pl, int dir)
2301		2043
2302	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);	2044	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);
2303		2045
…		…
2349	if (y) sv_to (y, pl->bed_y);	2091	if (y) sv_to (y, pl->bed_y);
2350		2092
2351	void	2093	void
2352	list ()	2094	list ()
2353	PPCODE:	2095	PPCODE:
2354	for (player *pl = first_player; pl; pl = pl->next)	2096	for_all_players (pl)
2355	XPUSHs (sv_2mortal (to_sv (pl)));	2097	XPUSHs (sv_2mortal (to_sv (pl)));
2356		2098
2357	bool
2358	peaceful (player *pl, bool new_setting = 0)
2359	PROTOTYPE: $;$
2360	CODE:
2361	RETVAL = pl->peaceful;
2362	if (items > 1)
2363	pl->peaceful = new_setting;
2364	OUTPUT:
2365	RETVAL
2366
2367	living *
2368	orig_stats (player *pl)
2369	CODE:
2370	RETVAL = &pl->orig_stats;
2371	OUTPUT: RETVAL
2372
2373	living *
2374	last_stats (player *pl)
2375	CODE:
2376	RETVAL = &pl->last_stats;
2377	OUTPUT: RETVAL
2378
2379		2099
2380	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_	2100	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_
2381
2382	maptile *first ()
2383	PROTOTYPE:
2384	CODE:
2385	RETVAL = first_map;
2386	OUTPUT: RETVAL
2387		2101
2388	int invoke (maptile *map, int event, ...)	2102	int invoke (maptile *map, int event, ...)
2389	CODE:	2103	CODE:
2390	if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");	2104	if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");
2391	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	2105	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
2395		2109
2396	SV *registry (maptile *map)	2110	SV *registry (maptile *map)
2397		2111
2398	INCLUDE: $PERL genacc maptile ../include/map.h |	2112	INCLUDE: $PERL genacc maptile ../include/map.h |
2399		2113
2400	maptile *new (int width, int height)	2114	void
		2115	maptile::instantiate ()
		2116
		2117	maptile *new ()
2401	PROTOTYPE:	2118	PROTOTYPE:
2402	CODE:	2119	CODE:
2403	{	2120	RETVAL = new maptile;
2404	RETVAL = get_empty_map (width, height);
2405	}
2406	OUTPUT:	2121	OUTPUT:
2407	RETVAL	2122	RETVAL
2408		2123
2409	void delete_map (maptile *map)	2124	void
2410		2125	maptile::players ()
2411	void clean_tmp_map (maptile *map)	2126	PPCODE:
		2127	if (GIMME_V == G_SCALAR)
		2128	XPUSHs (sv_2mortal (to_sv (THIS->players)));
		2129	else if (GIMME_V == G_ARRAY)
		2130	{
		2131	EXTEND (SP, THIS->players);
		2132	for_all_players (pl)
		2133	if (pl->ob && pl->ob->map == THIS)
		2134	PUSHs (sv_2mortal (to_sv (pl->ob)));
		2135	}
2412		2136
2413	void play_sound_map (maptile *map, int x, int y, int sound_num)	2137	void play_sound_map (maptile *map, int x, int y, int sound_num)
2414		2138
2415	int out_of_map (maptile *map, int x, int y)	2139	int out_of_map (maptile *map, int x, int y)
2416
2417	maptile *tile_map (maptile *map, unsigned int dir)
2418	CODE:
2419	RETVAL = dir < 4 ? map->tile_map [dir] : 0;
2420	OUTPUT:
2421	RETVAL
2422
2423	char *tile_path (maptile *map, unsigned int dir)
2424	CODE:
2425	if (dir >= 4)
2426	XSRETURN_UNDEF;
2427	RETVAL = map->tile_path [dir];
2428	OUTPUT:
2429	RETVAL
2430
2431	maptile *ready_map_name (char *name, int flags = 0)
2432	PROTOTYPE: $;$
2433	ALIAS:
2434	find = 0
2435	get_map = 1
2436
2437	maptile *has_been_loaded (char *name)
2438	PROTOTYPE: $
2439
2440	int in_memory (maptile *map)
2441	CODE:
2442	RETVAL = map->in_memory;
2443	OUTPUT:
2444	RETVAL
2445		2140
2446	void	2141	void
2447	trigger (maptile *map, long connection, bool state = true)	2142	trigger (maptile *map, long connection, bool state = true)
2448	CODE:	2143	CODE:
2449	activate_connection (map, connection, state);	2144	activate_connection (map, connection, state);
…		…
2462		2157
2463	object* cf_map_present_arch_by_name (maptile *map, const char* str, int nx, int ny)	2158	object* cf_map_present_arch_by_name (maptile *map, const char* str, int nx, int ny)
2464	C_ARGS: str, map, nx, ny	2159	C_ARGS: str, map, nx, ny
2465		2160
2466	void	2161	void
2467	cf_map_normalise (maptile *map, int x, int y)	2162	get_map_flags (maptile *map, int x, int y)
2468	PPCODE:	2163	PPCODE:
2469	{	2164	{
2470	maptile *nmap = 0;	2165	maptile *nmap = 0;
2471	I16 nx = 0, ny = 0;	2166	I16 nx = 0, ny = 0;
2472	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);	2167	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
…		…
2521	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;	2216	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;
2522	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;	2217	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;
2523	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;	2218	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;
2524	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;	2219	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;
2525	}	2220	}
2526	OUTPUT:	2221	OUTPUT: RETVAL
		2222
		2223	void fix_walls (maptile *map, int x, int y)
		2224
		2225	void fix_walls_around (maptile *map, int x, int y)
		2226
		2227	const char *
		2228	region_name (maptile *m)
		2229	CODE:
		2230	RETVAL = get_name_of_region_for_map (m);
		2231	OUTPUT: RETVAL
		2232
		2233	# worst xs function of my life
		2234	bool
		2235	_create_random_map (\
		2236	maptile *self,\
		2237	char *wallstyle,\
		2238	char *wall_name,\
		2239	char *floorstyle,\
		2240	char *monsterstyle,\
		2241	char *treasurestyle,\
		2242	char *layoutstyle,\
		2243	char *doorstyle,\
		2244	char *decorstyle,\
		2245	char *origin_map,\
		2246	char *final_map,\
		2247	char *exitstyle,\
		2248	char *this_map,\
		2249	char *exit_on_final_map,\
		2250	int xsize,\
		2251	int ysize,\
		2252	int expand2x,\
		2253	int layoutoptions1,\
		2254	int layoutoptions2,\
		2255	int layoutoptions3,\
		2256	int symmetry,\
		2257	int difficulty,\
		2258	int difficulty_given,\
		2259	float difficulty_increase,\
		2260	int dungeon_level,\
		2261	int dungeon_depth,\
		2262	int decoroptions,\
		2263	int orientation,\
		2264	int origin_y,\
		2265	int origin_x,\
		2266	U32 random_seed,\
		2267	val64 total_map_hp,\
		2268	int map_layout_style,\
		2269	int treasureoptions,\
		2270	int symmetry_used,\
		2271	region *region,\
		2272	char *custom\
		2273	)
		2274	CODE:
		2275	{
		2276	random_map_params rmp;
		2277
		2278	assign (rmp.wallstyle , wallstyle);
		2279	assign (rmp.wall_name , wall_name);
		2280	assign (rmp.floorstyle , floorstyle);
		2281	assign (rmp.monsterstyle , monsterstyle);
		2282	assign (rmp.treasurestyle , treasurestyle);
		2283	assign (rmp.layoutstyle , layoutstyle);
		2284	assign (rmp.doorstyle , doorstyle);
		2285	assign (rmp.decorstyle , decorstyle);
		2286	assign (rmp.exitstyle , exitstyle);
		2287	assign (rmp.exit_on_final_map, exit_on_final_map);
		2288
		2289	rmp.origin_map = origin_map;
		2290	rmp.final_map = final_map;
		2291	rmp.this_map = this_map;
		2292	rmp.xsize = xsize;
		2293	rmp.ysize = ysize;
		2294	rmp.expand2x = expand2x;
		2295	rmp.layoutoptions1 = layoutoptions1;
		2296	rmp.layoutoptions2 = layoutoptions2;
		2297	rmp.layoutoptions3 = layoutoptions3;
		2298	rmp.symmetry = symmetry;
		2299	rmp.difficulty = difficulty;
		2300	rmp.difficulty_given = difficulty_given;
		2301	rmp.difficulty_increase = difficulty_increase;
		2302	rmp.dungeon_level = dungeon_level;
		2303	rmp.dungeon_depth = dungeon_depth;
		2304	rmp.decoroptions = decoroptions;
		2305	rmp.orientation = orientation;
		2306	rmp.origin_y = origin_y;
		2307	rmp.origin_x = origin_x;
		2308	rmp.random_seed = random_seed;
		2309	rmp.total_map_hp = total_map_hp;
		2310	rmp.map_layout_style = map_layout_style;
		2311	rmp.treasureoptions = treasureoptions;
		2312	rmp.symmetry_used = symmetry_used;
		2313	rmp.region = region;
		2314	rmp.custom = custom;
		2315
		2316	RETVAL = self->generate_random_map (&rmp);
		2317	}
		2318	OUTPUT:
2527	RETVAL	2319	RETVAL
2528
2529	void fix_walls (maptile *map, int x, int y)
2530
2531	void fix_walls_around (maptile *map, int x, int y)
2532		2320
2533	MODULE = cf PACKAGE = cf::arch	2321	MODULE = cf PACKAGE = cf::arch
2534		2322
2535	archetype *find (const char *name)	2323	archetype *find (const char *name)
2536	CODE:	2324	CODE:
…		…
2552	PROTOTYPE:	2340	PROTOTYPE:
2553	CODE:	2341	CODE:
2554	RETVAL = get_firstparty ();	2342	RETVAL = get_firstparty ();
2555	OUTPUT: RETVAL	2343	OUTPUT: RETVAL
2556		2344
2557	partylist *next (partylist *party)	2345	INCLUDE: $PERL genacc partylist ../include/player.h |
2558	CODE:
2559	RETVAL = party->next;
2560	OUTPUT: RETVAL
2561
2562	const char *name (partylist *party)
2563	CODE:
2564	RETVAL = party->partyname;
2565	OUTPUT: RETVAL
2566
2567	const char *password (partylist *party)
2568	CODE:
2569	RETVAL = party->passwd;
2570	OUTPUT: RETVAL
2571		2346
2572	MODULE = cf PACKAGE = cf::region	2347	MODULE = cf PACKAGE = cf::region
2573		2348
2574	region *first ()	2349	region *first ()
2575	PROTOTYPE:	2350	PROTOTYPE:
2576	CODE:	2351	CODE:
2577	RETVAL = first_region;	2352	RETVAL = first_region;
2578	OUTPUT: RETVAL	2353	OUTPUT: RETVAL
2579		2354
2580	region *next (region *reg)	2355	region *find (char *name)
		2356	PROTOTYPE: $
2581	CODE:	2357	CODE:
2582	RETVAL = reg->next;	2358	RETVAL = get_region_by_name (name);
2583	OUTPUT: RETVAL	2359	OUTPUT: RETVAL
2584		2360
2585	const char *name (region *reg)	2361	INCLUDE: $PERL genacc region ../include/map.h |
2586	CODE:
2587	RETVAL = reg->name;
2588	OUTPUT: RETVAL
2589
2590	region *parent (region *reg)
2591	CODE:
2592	RETVAL = reg->parent;
2593	OUTPUT: RETVAL
2594
2595	const char *longname (region *reg)
2596	CODE:
2597	RETVAL = reg->longname;
2598	OUTPUT: RETVAL
2599
2600	const char *msg (region *reg)
2601	CODE:
2602	RETVAL = reg->msg;
2603	OUTPUT: RETVAL
2604		2362
2605	MODULE = cf PACKAGE = cf::living	2363	MODULE = cf PACKAGE = cf::living
2606		2364
2607	INCLUDE: $PERL genacc living ../include/living.h |	2365	INCLUDE: $PERL genacc living ../include/living.h |
2608		2366
…		…
2629	PPCODE:	2387	PPCODE:
2630	EXTEND (SP, clients.size ());	2388	EXTEND (SP, clients.size ());
2631	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)	2389	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
2632	PUSHs (sv_2mortal (to_sv (*i)));	2390	PUSHs (sv_2mortal (to_sv (*i)));
2633		2391
2634	client *
2635	create (int fd, const char *peername)
2636	CODE:
2637	RETVAL = client::create (fd, peername);
2638	OUTPUT:
2639	RETVAL
2640
2641	void	2392	void
2642	client::send_packet (SV *packet)	2393	client::send_packet (SV *packet)
2643	CODE:	2394	CODE:
2644	{	2395	{
2645	STRLEN len;	2396	STRLEN len;
2646	char *buf = SvPVbyte (packet, len);	2397	char *buf = SvPVbyte (packet, len);
2647		2398
2648	THIS->send_packet (buf, len);	2399	THIS->send_packet (buf, len);
2649	}	2400	}
2650		2401
2651	void
2652	client::destroy ()
2653

Diff Legend

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