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.113 by root, Tue Dec 26 08:54:59 2006 UTC vs.
Revision 1.160 by elmex, Wed Jan 31 14:11:02 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::sever_self ()
		118	{
		119	if (HV *self = this->self)
		120	{
		121	// keep a refcount because sv_unmagic might call attachable_free,
		122	// which might clear self, causing sv_unmagic to crash on a now
		123	// invalid object.
		124	SvREFCNT_inc (self);
		125	hv_clear (self);
		126	sv_unmagic ((SV *)self, PERL_MAGIC_ext);
		127	SvREFCNT_dec (self);
		128
		129	// self *must* be null now because thats sv_unmagic's job.
		130	assert (!this->self);
		131	}
		132	}
		133
		134	void
		135	attachable::optimise ()
		136	{
		137	if (self
		138	&& SvREFCNT (self) == 1
		139	&& !HvTOTALKEYS (self))
		140	sever_self ();
114	}	141	}
115		142
116	// check wether the object really is dead	143	// check wether the object really is dead
117	void	144	void
118	attachable::do_check ()	145	attachable::do_check ()
119	{	146	{
120	if (refcnt > 0)	147	if (refcnt_cnt () > 0)
121	return;	148	return;
122		149
123	// try to unborrow the refcnt from perl	150	destroy ();
124	if (flags & F_BORROWED)	151	}
		152
		153	void
		154	attachable::do_destroy ()
		155	{
		156	invoke (EVENT_ATTACHABLE_DESTROY, DT_END);
		157
		158	if (cb)
125	{	159	{
126	assert (self);//D//TODO//remove when stable
127	flags &= ~F_BORROWED;
128	refcnt_inc ();
129	SvREFCNT_dec (self);	160	SvREFCNT_dec (cb);
		161	cb = 0;
130	}	162	}
131		163
132	if (refcnt > 0 || self)	164	if (self)
133	return;	165	sever_self ();
134		166
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);	167	mortals.push_back (this);
145	}	168	}
146		169
147	void	170	void
148	attachable::destroy ()	171	attachable::destroy ()
…		…
152		175
153	flags |= F_DESTROYED;	176	flags |= F_DESTROYED;
154	do_destroy ();	177	do_destroy ();
155	}	178	}
156		179
		180	void
157	void attachable::check_mortals ()	181	attachable::check_mortals ()
158	{	182	{
159	for (int i = 0; i < mortals.size (); )	183	static int i = 0;
		184
		185	for (;;)
160	{	186	{
		187	if (i >= mortals.size ())
		188	{
		189	i = 0;
		190
		191	if (mortals.size () > 1000)
		192	fprintf (stderr, "mortal queue size (%d) exceeds 1000.\n", (int)mortals.size ());
		193
		194	break;
		195	}
		196
161	attachable *obj = mortals [i];	197	attachable *obj = mortals [i];
162		198
163	obj->refcnt_chk (); // unborrow from perl, if necessary	199	obj->refcnt_chk (); // unborrow from perl, if necessary
164		200
		201	//if (obj->refcnt > 0 || obj->self)
165	if (obj->refcnt || obj->self)	202	if (obj->refcnt || obj->self)
166	{	203	{
167	#if 0	204	//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	205	++i; // further delay freeing
		206
		207	if (!(i & 0x3ff))
		208	break;
173	}//D	209	}
174	else	210	else
175	{	211	{
176	//Dfprintf (stderr, "deleteing %d:%p:%s\n", i, obj,typeid (*obj).name ());//D
177	mortals.erase (i);	212	mortals.erase (i);
178	delete obj;	213	delete obj;
179	}	214	}
180	}	215	}
181	}	216	}
…		…
206		241
207	static int	242	static int
208	attachable_free (pTHX_ SV *sv, MAGIC *mg)	243	attachable_free (pTHX_ SV *sv, MAGIC *mg)
209	{	244	{
210	attachable *at = (attachable *)mg->mg_ptr;	245	attachable *at = (attachable *)mg->mg_ptr;
211	assert (!(at->flags & attachable::F_BORROWED));//D//TODO//remove when stable	246
		247	//TODO: check if transaction behaviour is really required here
		248	if (SV *self = (SV *)at->self)
		249	{
212	at->self = 0;	250	at->self = 0;
		251	SvREFCNT_dec (self);
		252	}
		253
213	// next line makes sense, but most objects still have refcnt 0 by default	254	// next line makes sense, but most objects still have refcnt 0 by default
214	//at->refcnt_chk ();	255	//at->refcnt_chk ();
215	return 0;	256	return 0;
216	}	257	}
217		258
218	static MGVTBL vtbl_attachable = {0, 0, 0, 0, attachable_free};	259	MGVTBL attachable::vtbl = {0, 0, 0, 0, attachable_free};
219		260
220	SV *	261	static SV *
221	newSVattachable (attachable *obj, HV *stash)	262	newSVattachable (attachable *obj, HV *stash)
222	{	263	{
223	if (!obj)	264	if (!obj)
224	return &PL_sv_undef;	265	return &PL_sv_undef;
225		266
226	if (!obj->self)	267	if (!obj->self)
227	{	268	{
228	obj->self = newHV ();	269	obj->self = newHV ();
229	sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &vtbl_attachable, (char *)obj, 0);	270	sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char *)obj, 0);
230		271
231	// borrow the refcnt from the object	272	// now bless the object _once_
232	obj->flags |= attachable::F_BORROWED;	273	return sv_bless (newRV_inc ((SV *)obj->self), stash);
233	obj->refcnt_dec ();
234	}	274	}
		275	else
		276	{
		277	SV *sv = newRV_inc ((SV *)obj->self);
235		278
236	return sv_bless (newRV_inc ((SV *)obj->self), stash);	279	if (Gv_AMG (stash)) // handle overload correctly, as the perl core does not
		280	SvAMAGIC_on (sv);
		281
		282	return sv;
		283	}
237	}	284	}
238		285
239	static void	286	static void
240	clearSVptr (SV *sv)	287	clearSVptr (SV *sv)
241	{	288	{
…		…
294	inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }	341	inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }
295		342
296	inline SV *to_sv (object & v) { return to_sv (&v); }	343	inline SV *to_sv (object & v) { return to_sv (&v); }
297	inline SV *to_sv (living & v) { return to_sv (&v); }	344	inline SV *to_sv (living & v) { return to_sv (&v); }
298		345
299	//TODO:
300	inline SV *to_sv (New_Face * v) { return to_sv (v->name); }	346	inline SV *to_sv (facetile * v) { return to_sv (v->name); }
301	inline SV *to_sv (treasurelist * v) { return to_sv (v->name); }	347	inline SV *to_sv (treasurelist * v) { return to_sv (v->name); }
302		348
303	inline SV *to_sv (UUID v)	349	inline SV *to_sv (UUID v)
304	{	350	{
305	char buf[128];	351	char buf[128];
306	snprintf (buf, 128, "<1,%" PRIx64 ">", v.seq);	352	snprintf (buf, 128, "<1.%" PRIx64 ">", v.seq);
307	return newSVpv (buf, 0);	353	return newSVpv (buf, 0);
308	}	354	}
309		355
310	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPV_nolen (sv) : 0; }	356	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPV_nolen (sv) : 0; }
311	inline void sv_to (SV *sv, char * &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }	357	inline void sv_to (SV *sv, char * &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }
…		…
320	inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }	366	inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }
321	inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }	367	inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }
322	inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }	368	inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }
323	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }	369	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
324	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }	370	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }
325	inline void sv_to (SV *sv, client * &v) { v = (client *)SvPTR_ornull (sv, "cf::client"); }	371	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 *)SvPTR_ornull (sv, "cf::player"); }	372	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 *)SvPTR_ornull (sv, "cf::object"); }	373	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 *)SvPTR_ornull (sv, "cf::arch"); }	374	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 *)SvPTR_ornull (sv, "cf::map"); }	375	inline void sv_to (SV *sv, maptile * &v) { v = (maptile *)(attachable *)SvPTR_ornull (sv, "cf::map"); }
		376	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"); }	377	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"); }	378	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"); }	379	inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }
333		380
334	inline void sv_to (SV *sv, New_Face * &v) { v = &new_faces[FindFace (SvPV_nolen (sv), 0)]; } //TODO	381	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	382	inline void sv_to (SV *sv, treasurelist * &v) { v = find_treasurelist (SvPV_nolen (sv)); }
336		383
337	template<class T>	384	template<class T>
338	inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }	385	inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }
339		386
340	template<int N>	387	template<int N>
…		…
475	{	522	{
476	if (!ext->cb)	523	if (!ext->cb)
477	ext->cb = newAV ();	524	ext->cb = newAV ();
478		525
479	return newRV_inc ((SV *)ext->cb);	526	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	}	527	}
865		528
866	/////////////////////////////////////////////////////////////////////////////	529	/////////////////////////////////////////////////////////////////////////////
867		530
868	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)	531	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
…		…
1095		758
1096	// short-circuit processing if no callbacks found/defined	759	// short-circuit processing if no callbacks found/defined
1097	if (!callbacks)	760	if (!callbacks)
1098	return 0;	761	return 0;
1099		762
1100	dSP;	763	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	764	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays
1108	PUSHs (sv_2mortal (newRV_noinc ((SV *)callbacks)));	765	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));
1109		766
1110	//TODO: unhack	767	//TODO: unhack
1111	if (object *op = is_a<object>(this)) PUSHs (sv_2mortal (newSVdt (DT_OBJECT, op)));	768	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)));	769	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)));	770	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)));	771	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*/;	772	else if (global *gl = is_a<global>(this)) /*nop*/;
1116	else	773	else
1117	abort (); //TODO	774	abort (); //TODO
1118		775
1119	for (;;)	776	for (;;)
…		…
1133	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));	790	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
1134	}	791	}
1135		792
1136	va_end (ap);	793	va_end (ap);
1137		794
1138	PUTBACK;	795	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;	796	count = count > 0 ? POPi : 0;
1143		797
1144	FREETMPS;	798	CALL_END;
1145	LEAVE;
1146		799
1147	return count;	800	return count;
1148	}	801	}
1149		802
1150	SV *	803	SV *
…		…
1173	return SvNV (cfperl_result (idx));	826	return SvNV (cfperl_result (idx));
1174	}	827	}
1175		828
1176	/////////////////////////////////////////////////////////////////////////////	829	/////////////////////////////////////////////////////////////////////////////
1177		830
		831	void
		832	cfperl_emergency_save ()
		833	{
		834	CALL_BEGIN (0);
		835	CALL_CALL ("cf::emergency_save", G_VOID);
		836	CALL_END;
		837	}
		838
		839	maptile *
		840	maptile::find_sync (const char *path, maptile *origin)
		841	{
		842	CALL_BEGIN (2);
		843	CALL_ARG (path);
		844	CALL_ARG (origin);
		845	CALL_CALL ("cf::map::find_sync", G_SCALAR);
		846
		847	maptile *retval;
		848
		849	if (count)
		850	sv_to (POPs, retval);
		851	else
		852	retval = 0;
		853
		854	CALL_END;
		855
		856	return retval;
		857	}
		858
		859	maptile *
		860	maptile::find_async (const char *path, maptile *origin)
		861	{
		862	CALL_BEGIN (2);
		863	CALL_ARG (path);
		864	CALL_ARG (origin);
		865	CALL_CALL ("cf::map::find_async", G_SCALAR);
		866
		867	maptile *retval;
		868
		869	if (count)
		870	sv_to (POPs, retval);
		871	else
		872	retval = 0;
		873
		874	CALL_END;
		875
		876	return retval;
		877	}
		878
		879	void
		880	maptile::do_load_sync ()
		881	{
		882	CALL_BEGIN (1);
		883	CALL_ARG (this);
		884	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);
		885	CALL_END;
		886	}
		887
		888	void
		889	maptile::change_all_map_light (int change)
		890	{
		891	CALL_BEGIN (1);
		892	CALL_ARG (change);
		893	CALL_CALL ("cf::map::change_all_map_light", G_VOID);
		894	CALL_END;
		895	}
		896
		897	void
		898	object::enter_exit (object *exit)
		899	{
		900	if (type != PLAYER)
		901	return;
		902
		903	CALL_BEGIN (2);
		904	CALL_ARG (this);
		905	CALL_ARG (exit);
		906	CALL_CALL ("cf::object::player::enter_exit", G_VOID);
		907	CALL_END;
		908	}
		909
		910	/////////////////////////////////////////////////////////////////////////////
		911
1178	struct EventAPI *watcher_base::GEventAPI;	912	struct EventAPI *watcher_base::GEventAPI;
		913	struct CoroAPI *coroapi::GCoroAPI;
		914
		915	int coroapi::cede_counter;
1179		916
1180	static void iw_dispatch (pe_event *ev)	917	static void iw_dispatch (pe_event *ev)
1181	{	918	{
1182	iw *w = (iw *)ev->ext_data;	919	iw *w = (iw *)ev->ext_data;
1183	w->call (*w);	920	w->call (*w);
…		…
1186	void	923	void
1187	iw::alloc ()	924	iw::alloc ()
1188	{	925	{
1189	pe = GEventAPI->new_idle (0, 0);	926	pe = GEventAPI->new_idle (0, 0);
1190		927
		928	WaREENTRANT_off (pe);
1191	pe->base.callback = (void *)iw_dispatch;	929	pe->base.callback = (void *)iw_dispatch;
1192	pe->base.ext_data = (void *)this;	930	pe->base.ext_data = (void *)this;
1193	}	931	}
1194		932
1195	static void iow_dispatch (pe_event *ev)	933	static void iow_dispatch (pe_event *ev)
…		…
1201	void	939	void
1202	iow::alloc ()	940	iow::alloc ()
1203	{	941	{
1204	pe = GEventAPI->new_io (0, 0);	942	pe = GEventAPI->new_io (0, 0);
1205		943
		944	WaREENTRANT_off (pe);
1206	pe->base.callback = (void *)iow_dispatch;	945	pe->base.callback = (void *)iow_dispatch;
1207	pe->base.ext_data = (void *)this;	946	pe->base.ext_data = (void *)this;
1208		947
1209	pe->fd = -1;	948	pe->fd = -1;
1210	pe->poll = 0;	949	pe->poll = 0;
…		…
1246	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);	985	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
1247	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);	986	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
1248	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);	987	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
1249	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);	988	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
1250		989
		990	sv_runtime = get_sv ("cf::RUNTIME", 1);
		991	sv_upgrade (sv_runtime, SVt_NV);
		992
1251	cb_global = get_av ("cf::CB_GLOBAL", 1);	993	cb_global = get_av ("cf::CB_GLOBAL", 1);
1252	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);	994	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
1253	cb_object = get_av ("cf::CB_OBJECT", 1);	995	cb_object = get_av ("cf::CB_OBJECT", 1);
1254	cb_player = get_av ("cf::CB_PLAYER", 1);	996	cb_player = get_av ("cf::CB_PLAYER", 1);
1255	cb_client = get_av ("cf::CB_CLIENT", 1);	997	cb_client = get_av ("cf::CB_CLIENT", 1);
…		…
1261		1003
1262	BOOT:	1004	BOOT:
1263	{	1005	{
1264	_connect_to_perl ();	1006	_connect_to_perl ();
1265		1007
1266	I_EVENT_API (PACKAGE);
1267	watcher_base::GEventAPI = GEventAPI;	1008	I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;
1268	I_CORO_API (PACKAGE);	1009	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
1269		1010
1270	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));	1011	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
1271		1012
1272	static const struct {	1013	static const struct {
1273	const char *name;	1014	const char *name;
…		…
1536	const_iv (FLAG_ACTIVATE_ON_RELEASE)	1277	const_iv (FLAG_ACTIVATE_ON_RELEASE)
1537	const_iv (FLAG_IS_WATER)	1278	const_iv (FLAG_IS_WATER)
1538	const_iv (FLAG_CONTENT_ON_GEN)	1279	const_iv (FLAG_CONTENT_ON_GEN)
1539	const_iv (FLAG_IS_A_TEMPLATE)	1280	const_iv (FLAG_IS_A_TEMPLATE)
1540	const_iv (FLAG_IS_BUILDABLE)	1281	const_iv (FLAG_IS_BUILDABLE)
		1282	const_iv (FLAG_DESTROY_ON_DEATH)
		1283	const_iv (FLAG_NO_MAP_SAVE)
1541		1284
1542	const_iv (NDI_BLACK)	1285	const_iv (NDI_BLACK)
1543	const_iv (NDI_WHITE)	1286	const_iv (NDI_WHITE)
1544	const_iv (NDI_NAVY)	1287	const_iv (NDI_NAVY)
1545	const_iv (NDI_RED)	1288	const_iv (NDI_RED)
…		…
1587	const_iv (P_BLOCKSVIEW)	1330	const_iv (P_BLOCKSVIEW)
1588	const_iv (P_PLAYER)	1331	const_iv (P_PLAYER)
1589	const_iv (P_NO_MAGIC)	1332	const_iv (P_NO_MAGIC)
1590	const_iv (P_IS_ALIVE)	1333	const_iv (P_IS_ALIVE)
1591	const_iv (P_NO_CLERIC)	1334	const_iv (P_NO_CLERIC)
1592	const_iv (P_NEED_UPDATE)
1593	const_iv (P_OUT_OF_MAP)	1335	const_iv (P_OUT_OF_MAP)
1594	const_iv (P_NEW_MAP)	1336	const_iv (P_NEW_MAP)
		1337	const_iv (P_UPTODATE)
1595		1338
1596	const_iv (UP_OBJ_INSERT)	1339	const_iv (UP_OBJ_INSERT)
1597	const_iv (UP_OBJ_REMOVE)	1340	const_iv (UP_OBJ_REMOVE)
1598	const_iv (UP_OBJ_CHANGE)	1341	const_iv (UP_OBJ_CHANGE)
1599	const_iv (UP_OBJ_FACE)	1342	const_iv (UP_OBJ_FACE)
…		…
1730	const_iv (ATNR_BLIND)	1473	const_iv (ATNR_BLIND)
1731	const_iv (ATNR_INTERNAL)	1474	const_iv (ATNR_INTERNAL)
1732	const_iv (ATNR_LIFE_STEALING)	1475	const_iv (ATNR_LIFE_STEALING)
1733	const_iv (ATNR_DISEASE)	1476	const_iv (ATNR_DISEASE)
1734		1477
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)	1478	const_iv (MAP_IN_MEMORY)
1742	const_iv (MAP_SWAPPED)	1479	const_iv (MAP_SWAPPED)
1743	const_iv (MAP_LOADING)	1480	const_iv (MAP_LOADING)
1744	const_iv (MAP_SAVING)	1481	const_iv (MAP_SAVING)
1745		1482
…		…
1758	const_iv (ST_SETUP)	1495	const_iv (ST_SETUP)
1759	const_iv (ST_PLAYING)	1496	const_iv (ST_PLAYING)
1760	const_iv (ST_CUSTOM)	1497	const_iv (ST_CUSTOM)
1761		1498
1762	const_iv (ST_CHANGE_CLASS)	1499	const_iv (ST_CHANGE_CLASS)
1763	const_iv (ST_CONFIRM_QUIT)	1500
1764	const_iv (ST_GET_PARTY_PASSWORD)	1501	const_iv (IO_HEADER)
		1502	const_iv (IO_OBJECTS)
		1503	const_iv (IO_UNIQUES)
		1504
		1505	// random map generator
		1506	const_iv (LAYOUT_NONE)
		1507	const_iv (LAYOUT_ONION)
		1508	const_iv (LAYOUT_MAZE)
		1509	const_iv (LAYOUT_SPIRAL)
		1510	const_iv (LAYOUT_ROGUELIKE)
		1511	const_iv (LAYOUT_SNAKE)
		1512	const_iv (LAYOUT_SQUARE_SPIRAL)
		1513
		1514	const_iv (RMOPT_RANDOM)
		1515	const_iv (RMOPT_CENTERED)
		1516	const_iv (RMOPT_LINEAR)
		1517	const_iv (RMOPT_BOTTOM_C)
		1518	const_iv (RMOPT_BOTTOM_R)
		1519	const_iv (RMOPT_IRR_SPACE)
		1520	const_iv (RMOPT_WALL_OFF)
		1521	const_iv (RMOPT_WALLS_ONLY)
		1522	const_iv (RMOPT_NO_DOORS)
		1523
		1524	const_iv (SYMMETRY_RANDOM)
		1525	const_iv (SYMMETRY_NONE)
		1526	const_iv (SYMMETRY_X)
		1527	const_iv (SYMMETRY_Y)
		1528	const_iv (SYMMETRY_XY)
1765	};	1529	};
1766		1530
1767	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	1531	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1768	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));	1532	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1769		1533
…		…
1794		1558
1795	void _global_reattach ()	1559	void _global_reattach ()
1796	CODE:	1560	CODE:
1797	{	1561	{
1798	// reattach to all attachable objects in the game.	1562	// reattach to all attachable objects in the game.
1799	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)	1563	for_all_clients (ns)
1800	(*i)->reattach ();	1564	ns->reattach ();
1801		1565
1802	for (player *pl = first_player; pl; pl = pl->next)	1566	for_all_players (pl)
1803	pl->reattach ();	1567	pl->reattach ();
1804		1568
1805	for (maptile *m = first_map; m; m = m->next)	1569	//TODO
1806	m->reattach ();	1570	//for (map_container::iterator i = maps.begin (); i != maps.end (); ++i)
		1571	// i->second->reattach ();
1807		1572
1808	for (object *op = object::first; op; op = op->next)	1573	for_all_objects (op)
1809	op->reattach ();	1574	op->reattach ();
1810	}	1575	}
1811		1576
1812	NV floor (NV x)	1577	NV floor (NV x)
1813		1578
1814	NV ceil (NV x)	1579	NV ceil (NV x)
1815		1580
		1581	NV rndm (...)
		1582	CODE:
		1583	switch (items)
		1584	{
		1585	case 0: RETVAL = rndm (); break;
		1586	case 1: RETVAL = rndm (SvUV (ST (0))); break;
		1587	case 2: RETVAL = rndm (SvIV (ST (0)), SvIV (ST (1))); break;
		1588	default: croak ("cf::rndm requires none, one or two parameters."); break;
		1589	}
		1590	OUTPUT:
		1591	RETVAL
		1592
1816	void server_tick ()	1593	void server_tick ()
		1594	CODE:
		1595	runtime = SvNVx (sv_runtime);
		1596	server_tick ();
1817		1597
1818	void	1598	void
1819	LOG (int level, char *msg)	1599	LOG (int level, char *msg)
1820	PROTOTYPE: $$	1600	PROTOTYPE: $$
1821	C_ARGS: (LogLevel)level, "%s", msg	1601	C_ARGS: (LogLevel)level, "%s", msg
…		…
1861	case 5: RETVAL = settings.playerdir; break;	1641	case 5: RETVAL = settings.playerdir; break;
1862	case 6: RETVAL = settings.datadir ; break;	1642	case 6: RETVAL = settings.datadir ; break;
1863	}	1643	}
1864	OUTPUT: RETVAL	1644	OUTPUT: RETVAL
1865		1645
		1646	void abort ()
		1647
		1648	void fork_abort (char *cause = "cf::fork_abort")
		1649
		1650	void cleanup (const char *cause, bool make_core = false)
		1651
		1652	void emergency_save ()
		1653
1866	void _exit (int status = 0)	1654	void _exit (int status = EXIT_SUCCESS)
		1655
		1656	UV sv_2watcher (SV *w)
		1657	CODE:
		1658	RETVAL = (UV)GEventAPI->sv_2watcher (w);
		1659	OUTPUT:
		1660	RETVAL
		1661
		1662	#if _POSIX_MEMLOCK
		1663
		1664	int mlockall (int flags = MCL_CURRENT | MCL_FUTURE)
		1665
		1666	int munlockall ()
		1667
		1668	#endif
1867		1669
1868	int find_animation (char *text)	1670	int find_animation (char *text)
1869	PROTOTYPE: $	1671	PROTOTYPE: $
1870		1672
1871	int random_roll (int min, int max, object *op, int goodbad);	1673	int random_roll (int min, int max, object *op, int goodbad);
…		…
1918	CODE:	1720	CODE:
1919	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);	1721	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
1920	OUTPUT:	1722	OUTPUT:
1921	RETVAL	1723	RETVAL
1922		1724
		1725	int mortals_size ()
		1726	CODE:
		1727	RETVAL = attachable::mortals.size ();
		1728	OUTPUT: RETVAL
		1729
		1730	#object *mortals (U32 index)
		1731	# CODE:
		1732	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;
		1733	# OUTPUT: RETVAL
		1734
		1735	INCLUDE: $PERL genacc attachable ../include/cfperl.h |
		1736
1923	MODULE = cf PACKAGE = cf::global	1737	MODULE = cf PACKAGE = cf::global
1924		1738
1925	int invoke (SV *klass, int event, ...)	1739	int invoke (SV *klass, int event, ...)
1926	CODE:	1740	CODE:
1927	if (KLASS_OF (event) != KLASS_GLOBAL) croak ("event class must be GLOBAL");	1741	if (KLASS_OF (event) != KLASS_GLOBAL) croak ("event class must be GLOBAL");
…		…
1942	RETVAL = op->invoke ((event_type)event, ARG_AV (av), DT_END);	1756	RETVAL = op->invoke ((event_type)event, ARG_AV (av), DT_END);
1943	OUTPUT: RETVAL	1757	OUTPUT: RETVAL
1944		1758
1945	SV *registry (object *op)	1759	SV *registry (object *op)
1946		1760
1947	void mortals ()	1761	int objects_size ()
1948	PPCODE:	1762	CODE:
1949	EXTEND (SP, object::mortals.size ());
1950	for (AUTODECL (i, object::mortals.begin ()); i != object::mortals.end (); ++i)
1951	PUSHs (to_sv (*i));
1952
1953	object *first ()
1954	CODE:
1955	RETVAL = object::first;	1763	RETVAL = objects.size ();
		1764	OUTPUT: RETVAL
		1765
		1766	object *objects (U32 index)
		1767	CODE:
		1768	RETVAL = index < objects.size () ? objects [index] : 0;
		1769	OUTPUT: RETVAL
		1770
		1771	int actives_size ()
		1772	CODE:
		1773	RETVAL = actives.size ();
		1774	OUTPUT: RETVAL
		1775
		1776	object *actives (U32 index)
		1777	CODE:
		1778	RETVAL = index < actives.size () ? actives [index] : 0;
1956	OUTPUT: RETVAL	1779	OUTPUT: RETVAL
1957		1780
1958	# missing properties	1781	# missing properties
1959		1782
1960	object *head (object *op)	1783	object *head (object *op)
1961	PROTOTYPE: $	1784	PROTOTYPE: $
1962	CODE:	1785	CODE:
1963	RETVAL = op->head ? op->head : op;	1786	RETVAL = op->head_ ();
1964	OUTPUT: RETVAL	1787	OUTPUT: RETVAL
1965		1788
1966	int is_head (object *op)	1789	int is_head (object *op)
1967	PROTOTYPE: $	1790	PROTOTYPE: $
1968	CODE:	1791	CODE:
1969	RETVAL = !op->head;	1792	RETVAL = op->head_ () == op;
1970	OUTPUT: RETVAL	1793	OUTPUT: RETVAL
1971		1794
1972	void	1795	void
1973	inv (object *obj)	1796	inv (object *obj)
1974	PROTOTYPE: $	1797	PROTOTYPE: $
…		…
1982	void	1805	void
1983	set_animation (object *op, int idx)	1806	set_animation (object *op, int idx)
1984	CODE:	1807	CODE:
1985	SET_ANIMATION (op, idx);	1808	SET_ANIMATION (op, idx);
1986		1809
1987	void	1810	int
1988	object::drain_stat ()	1811	num_animations (object *op)
1989		1812	CODE:
1990	void	1813	RETVAL = NUM_ANIMATIONS (op);
1991	object::drain_specific_stat (int stat)	1814	OUTPUT: RETVAL
1992
1993	void
1994	object::change_luck (int change)
1995
1996	void
1997	object::add_statbonus ()
1998
1999	void
2000	object::remove_statbonus ()
2001		1815
2002	object *find_best_object_match (object *op, const char *match)	1816	object *find_best_object_match (object *op, const char *match)
2003		1817
2004	object *find_marked_object (object *op)	1818	object *find_marked_object (object *op)
2005		1819
…		…
2019		1833
2020	void apply_below (object *op)	1834	void apply_below (object *op)
2021	CODE:	1835	CODE:
2022	player_apply_below (op);	1836	player_apply_below (op);
2023		1837
2024	void remove (object *op)
2025	CODE:
2026	op->remove ();
2027
2028	void
2029	object::destroy (bool destroy_inventory = false)
2030
2031	void
2032	object::destroy_inv (bool drop_to_ground = false)
2033
2034	void
2035	object::set_speed (float speed)
2036
2037	object *cf_object_present_archname_inside (object *op, char *whatstr)	1838	object *cf_object_present_archname_inside (object *op, char *whatstr)
2038		1839
2039	int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)	1840	int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)
2040		1841
2041	int cf_object_change_map (object *op, int x, int y, maptile *map)	1842	int cf_object_change_map (object *op, int x, int y, maptile *map)
2042		1843
		1844	#//TODO
2043	object *clone (object *op, int recursive = 0)	1845	object *clone_ (object *op, int recursive = 0)
2044	CODE:	1846	CODE:
2045	if (recursive)	1847	if (recursive)
2046	RETVAL = object_create_clone (op);	1848	RETVAL = object_create_clone (op);
2047	else	1849	else
2048	{	1850	{
…		…
2092		1894
2093	void drop (object *who, object *op)	1895	void drop (object *who, object *op)
2094		1896
2095	void pick_up (object *who, object *op)	1897	void pick_up (object *who, object *op)
2096		1898
2097	object *cf_object_insert_object (object *op, object *container)
2098
2099	object *cf_object_insert_in_ob (object *ob, object *where)
2100
2101	int cf_object_teleport (object *op, maptile *map, int x, int y)	1899	int cf_object_teleport (object *op, maptile *map, int x, int y)
2102		1900
2103	void update_object (object *op, int action)	1901	void update_object (object *op, int action)
2104		1902
2105	object *cf_create_object_by_name (const char *name)	1903	object *cf_create_object_by_name (const char *name)
…		…
2152		1950
2153	player *contr (object *op)	1951	player *contr (object *op)
2154	CODE:	1952	CODE:
2155	RETVAL = op->contr;	1953	RETVAL = op->contr;
2156	OUTPUT: RETVAL	1954	OUTPUT: RETVAL
2157
2158	void
2159	object::roll_stats ()
2160
2161	void
2162	object::update_stats ()
2163
2164	void
2165	object::swap_stats (int a, int b)
2166		1955
2167	const char *get_ob_key_value (object *op, const char *key)	1956	const char *get_ob_key_value (object *op, const char *key)
2168		1957
2169	bool set_ob_key_value (object *op, const char *key, const char *value = 0, int add_key = 1)	1958	bool set_ob_key_value (object *op, const char *key, const char *value = 0, int add_key = 1)
2170		1959
…		…
2207	RETVAL = op->contr;	1996	RETVAL = op->contr;
2208	OUTPUT: RETVAL	1997	OUTPUT: RETVAL
2209		1998
2210	void check_score (object *op)	1999	void check_score (object *op)
2211		2000
2212	void cf_player_message (object *obj, char *txt, int flags = NDI_ORANGE | NDI_UNIQUE)	2001	void message (object *op, char *txt, int flags = NDI_ORANGE | NDI_UNIQUE)
		2002	CODE:
		2003	new_draw_info (flags, 0, op, txt);
2213		2004
2214	object *cf_player_send_inventory (object *op)	2005	object *cf_player_send_inventory (object *op)
2215		2006
2216	char *cf_player_get_ip (object *op)	2007	char *cf_player_get_ip (object *op)
2217	ALIAS: ip = 0	2008	ALIAS: ip = 0
…		…
2230		2021
2231	void esrv_update_item (object *op, int what, object *item)	2022	void esrv_update_item (object *op, int what, object *item)
2232	C_ARGS: what, op, item	2023	C_ARGS: what, op, item
2233		2024
2234	void clear_los (object *op)	2025	void clear_los (object *op)
2235
2236	int command_reset (object *op, char *params)
2237
2238	int command_teleport (object *op, char *params)
2239		2026
2240	int command_summon (object *op, char *params)	2027	int command_summon (object *op, char *params)
2241		2028
2242	int command_arrest (object *op, char *params)	2029	int command_arrest (object *op, char *params)
2243		2030
…		…
2258	RETVAL = pl->invoke ((event_type)event, ARG_AV (av), DT_END);	2045	RETVAL = pl->invoke ((event_type)event, ARG_AV (av), DT_END);
2259	OUTPUT: RETVAL	2046	OUTPUT: RETVAL
2260		2047
2261	SV *registry (player *pl)	2048	SV *registry (player *pl)
2262		2049
2263	player *
2264	create ()
2265	CODE:
2266	RETVAL = player::create ();
2267	OUTPUT:
2268	RETVAL
2269
2270	player *
2271	load (const char *path)
2272	CODE:
2273	RETVAL = player::load (path);
2274	OUTPUT:
2275	RETVAL
2276
2277	void
2278	player::save (bool final = false)
2279
2280	void
2281	player::connect (client *ns)
2282
2283	void	2050	void
2284	save_stats (player *pl)	2051	save_stats (player *pl)
2285	CODE:	2052	CODE:
2286	pl->ob->stats.hp = pl->ob->stats.maxhp;	2053	pl->ob->stats.hp = pl->ob->stats.maxhp;
2287	pl->ob->stats.sp = pl->ob->stats.maxsp;	2054	pl->ob->stats.sp = pl->ob->stats.maxsp;
2288	pl->ob->stats.grace = pl->ob->stats.maxgrace;	2055	pl->ob->stats.grace = pl->ob->stats.maxgrace;
2289	pl->orig_stats = pl->ob->stats;	2056	pl->orig_stats = pl->ob->stats;
2290
2291	player *cf_player_find (char *name)
2292	PROTOTYPE: $
2293		2057
2294	void cf_player_move (player *pl, int dir)	2058	void cf_player_move (player *pl, int dir)
2295		2059
2296	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);	2060	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);
2297		2061
…		…
2343	if (y) sv_to (y, pl->bed_y);	2107	if (y) sv_to (y, pl->bed_y);
2344		2108
2345	void	2109	void
2346	list ()	2110	list ()
2347	PPCODE:	2111	PPCODE:
2348	for (player *pl = first_player; pl; pl = pl->next)	2112	for_all_players (pl)
2349	XPUSHs (sv_2mortal (to_sv (pl)));	2113	XPUSHs (sv_2mortal (to_sv (pl)));
2350		2114
2351	bool
2352	peaceful (player *pl, bool new_setting = 0)
2353	PROTOTYPE: $;$
2354	CODE:
2355	RETVAL = pl->peaceful;
2356	if (items > 1)
2357	pl->peaceful = new_setting;
2358	OUTPUT:
2359	RETVAL
2360
2361	living *
2362	orig_stats (player *pl)
2363	CODE:
2364	RETVAL = &pl->orig_stats;
2365	OUTPUT: RETVAL
2366
2367	living *
2368	last_stats (player *pl)
2369	CODE:
2370	RETVAL = &pl->last_stats;
2371	OUTPUT: RETVAL
2372
2373		2115
2374	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_	2116	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_
2375
2376	maptile *first ()
2377	PROTOTYPE:
2378	CODE:
2379	RETVAL = first_map;
2380	OUTPUT: RETVAL
2381		2117
2382	int invoke (maptile *map, int event, ...)	2118	int invoke (maptile *map, int event, ...)
2383	CODE:	2119	CODE:
2384	if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");	2120	if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");
2385	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	2121	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
2389		2125
2390	SV *registry (maptile *map)	2126	SV *registry (maptile *map)
2391		2127
2392	INCLUDE: $PERL genacc maptile ../include/map.h |	2128	INCLUDE: $PERL genacc maptile ../include/map.h |
2393		2129
2394	maptile *new (int width, int height)	2130	void
		2131	maptile::instantiate ()
		2132
		2133	maptile *new ()
2395	PROTOTYPE:	2134	PROTOTYPE:
2396	CODE:	2135	CODE:
2397	{	2136	RETVAL = new maptile;
2398	RETVAL = get_empty_map (width, height);
2399	}
2400	OUTPUT:	2137	OUTPUT:
2401	RETVAL	2138	RETVAL
2402		2139
2403	void delete_map (maptile *map)	2140	void
		2141	maptile::players ()
		2142	PPCODE:
		2143	if (GIMME_V == G_SCALAR)
		2144	XPUSHs (sv_2mortal (to_sv (THIS->players)));
		2145	else if (GIMME_V == G_ARRAY)
		2146	{
		2147	EXTEND (SP, THIS->players);
		2148	for_all_players (pl)
		2149	if (pl->ob && pl->ob->map == THIS)
		2150	PUSHs (sv_2mortal (to_sv (pl->ob)));
		2151	}
2404		2152
2405	void clean_tmp_map (maptile *map)	2153	void
		2154	maptile::set_regiondata (SV *data, SV *plt)
		2155	CODE:
		2156	{
		2157	if (!SvROK (plt) || SvTYPE (SvRV (plt)) != SVt_PVAV)
		2158	croak ("maptile::set_regiondata needs arrayref as plt arg");
		2159
		2160	AV *av = (AV *)SvRV (plt);
		2161
		2162	region **regionmap = (region **)malloc ((av_len (av) + 1) * sizeof (region *));
		2163
		2164	for (int i = av_len (av) + 1; i--; )
		2165	regionmap [i] = region::find (SvPVutf8_nolen (*av_fetch (av, i, 1)));
		2166
		2167	THIS->regions = salloc<uint8_t> (THIS->size (), (uint8_t *)SvPVbyte_nolen (data));
		2168	THIS->regionmap = regionmap;
		2169	}
2406		2170
2407	void play_sound_map (maptile *map, int x, int y, int sound_num)	2171	void play_sound_map (maptile *map, int x, int y, int sound_num)
2408		2172
2409	int out_of_map (maptile *map, int x, int y)	2173	int out_of_map (maptile *map, int x, int y)
2410
2411	maptile *tile_map (maptile *map, unsigned int dir)
2412	CODE:
2413	RETVAL = dir < 4 ? map->tile_map [dir] : 0;
2414	OUTPUT:
2415	RETVAL
2416
2417	char *tile_path (maptile *map, unsigned int dir)
2418	CODE:
2419	if (dir >= 4)
2420	XSRETURN_UNDEF;
2421	RETVAL = map->tile_path [dir];
2422	OUTPUT:
2423	RETVAL
2424
2425	maptile *ready_map_name (char *name, int flags = 0)
2426	PROTOTYPE: $;$
2427	ALIAS:
2428	find = 0
2429	get_map = 1
2430
2431	maptile *has_been_loaded (char *name)
2432	PROTOTYPE: $
2433
2434	int in_memory (maptile *map)
2435	CODE:
2436	RETVAL = map->in_memory;
2437	OUTPUT:
2438	RETVAL
2439		2174
2440	void	2175	void
2441	trigger (maptile *map, long connection, bool state = true)	2176	trigger (maptile *map, long connection, bool state = true)
2442	CODE:	2177	CODE:
2443	activate_connection (map, connection, state);	2178	activate_connection (map, connection, state);
…		…
2456		2191
2457	object* cf_map_present_arch_by_name (maptile *map, const char* str, int nx, int ny)	2192	object* cf_map_present_arch_by_name (maptile *map, const char* str, int nx, int ny)
2458	C_ARGS: str, map, nx, ny	2193	C_ARGS: str, map, nx, ny
2459		2194
2460	void	2195	void
2461	cf_map_normalise (maptile *map, int x, int y)	2196	get_map_flags (maptile *map, int x, int y)
2462	PPCODE:	2197	PPCODE:
2463	{	2198	{
2464	maptile *nmap = 0;	2199	maptile *nmap = 0;
2465	I16 nx = 0, ny = 0;	2200	I16 nx = 0, ny = 0;
2466	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);	2201	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
…		…
2515	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;	2250	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;
2516	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;	2251	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;
2517	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;	2252	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;
2518	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;	2253	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;
2519	}	2254	}
2520	OUTPUT:	2255	OUTPUT: RETVAL
		2256
		2257	void fix_walls (maptile *map, int x, int y)
		2258
		2259	void fix_walls_around (maptile *map, int x, int y)
		2260
		2261	# worst xs function of my life
		2262	bool
		2263	_create_random_map (\
		2264	maptile *self,\
		2265	char *wallstyle,\
		2266	char *wall_name,\
		2267	char *floorstyle,\
		2268	char *monsterstyle,\
		2269	char *treasurestyle,\
		2270	char *layoutstyle,\
		2271	char *doorstyle,\
		2272	char *decorstyle,\
		2273	char *origin_map,\
		2274	char *final_map,\
		2275	char *exitstyle,\
		2276	char *this_map,\
		2277	char *exit_on_final_map,\
		2278	int xsize,\
		2279	int ysize,\
		2280	int expand2x,\
		2281	int layoutoptions1,\
		2282	int layoutoptions2,\
		2283	int layoutoptions3,\
		2284	int symmetry,\
		2285	int difficulty,\
		2286	int difficulty_given,\
		2287	float difficulty_increase,\
		2288	int dungeon_level,\
		2289	int dungeon_depth,\
		2290	int decoroptions,\
		2291	int orientation,\
		2292	int origin_y,\
		2293	int origin_x,\
		2294	U32 random_seed,\
		2295	val64 total_map_hp,\
		2296	int map_layout_style,\
		2297	int treasureoptions,\
		2298	int symmetry_used,\
		2299	region *region,\
		2300	char *custom\
		2301	)
		2302	CODE:
		2303	{
		2304	random_map_params rmp;
		2305
		2306	assign (rmp.wallstyle , wallstyle);
		2307	assign (rmp.wall_name , wall_name);
		2308	assign (rmp.floorstyle , floorstyle);
		2309	assign (rmp.monsterstyle , monsterstyle);
		2310	assign (rmp.treasurestyle , treasurestyle);
		2311	assign (rmp.layoutstyle , layoutstyle);
		2312	assign (rmp.doorstyle , doorstyle);
		2313	assign (rmp.decorstyle , decorstyle);
		2314	assign (rmp.exitstyle , exitstyle);
		2315	assign (rmp.exit_on_final_map, exit_on_final_map);
		2316
		2317	rmp.origin_map = origin_map;
		2318	rmp.final_map = final_map;
		2319	rmp.this_map = this_map;
		2320	rmp.xsize = xsize;
		2321	rmp.ysize = ysize;
		2322	rmp.expand2x = expand2x;
		2323	rmp.layoutoptions1 = layoutoptions1;
		2324	rmp.layoutoptions2 = layoutoptions2;
		2325	rmp.layoutoptions3 = layoutoptions3;
		2326	rmp.symmetry = symmetry;
		2327	rmp.difficulty = difficulty;
		2328	rmp.difficulty_given = difficulty_given;
		2329	rmp.difficulty_increase = difficulty_increase;
		2330	rmp.dungeon_level = dungeon_level;
		2331	rmp.dungeon_depth = dungeon_depth;
		2332	rmp.decoroptions = decoroptions;
		2333	rmp.orientation = orientation;
		2334	rmp.origin_y = origin_y;
		2335	rmp.origin_x = origin_x;
		2336	rmp.random_seed = random_seed;
		2337	rmp.total_map_hp = total_map_hp;
		2338	rmp.map_layout_style = map_layout_style;
		2339	rmp.treasureoptions = treasureoptions;
		2340	rmp.symmetry_used = symmetry_used;
		2341	rmp.region = region;
		2342	rmp.custom = custom;
		2343
		2344	RETVAL = self->generate_random_map (&rmp);
		2345	}
		2346	OUTPUT:
2521	RETVAL	2347	RETVAL
2522
2523	void fix_walls (maptile *map, int x, int y)
2524
2525	void fix_walls_around (maptile *map, int x, int y)
2526		2348
2527	MODULE = cf PACKAGE = cf::arch	2349	MODULE = cf PACKAGE = cf::arch
2528		2350
2529	archetype *find (const char *name)	2351	archetype *find (const char *name)
2530	CODE:	2352	CODE:
…		…
2546	PROTOTYPE:	2368	PROTOTYPE:
2547	CODE:	2369	CODE:
2548	RETVAL = get_firstparty ();	2370	RETVAL = get_firstparty ();
2549	OUTPUT: RETVAL	2371	OUTPUT: RETVAL
2550		2372
2551	partylist *next (partylist *party)	2373	INCLUDE: $PERL genacc partylist ../include/player.h |
2552	CODE:
2553	RETVAL = party->next;
2554	OUTPUT: RETVAL
2555
2556	const char *name (partylist *party)
2557	CODE:
2558	RETVAL = party->partyname;
2559	OUTPUT: RETVAL
2560
2561	const char *password (partylist *party)
2562	CODE:
2563	RETVAL = party->passwd;
2564	OUTPUT: RETVAL
2565		2374
2566	MODULE = cf PACKAGE = cf::region	2375	MODULE = cf PACKAGE = cf::region
2567		2376
2568	region *first ()	2377	region *first ()
2569	PROTOTYPE:	2378	PROTOTYPE:
2570	CODE:	2379	CODE:
2571	RETVAL = first_region;	2380	RETVAL = first_region;
2572	OUTPUT: RETVAL	2381	OUTPUT: RETVAL
2573		2382
2574	region *next (region *reg)	2383	region *find (char *name)
		2384	PROTOTYPE: $
2575	CODE:	2385	CODE:
2576	RETVAL = reg->next;	2386	RETVAL = region::find (name);
2577	OUTPUT: RETVAL	2387	OUTPUT: RETVAL
2578		2388
2579	const char *name (region *reg)	2389	INCLUDE: $PERL genacc region ../include/map.h |
2580	CODE:
2581	RETVAL = reg->name;
2582	OUTPUT: RETVAL
2583
2584	region *parent (region *reg)
2585	CODE:
2586	RETVAL = reg->parent;
2587	OUTPUT: RETVAL
2588
2589	const char *longname (region *reg)
2590	CODE:
2591	RETVAL = reg->longname;
2592	OUTPUT: RETVAL
2593
2594	const char *msg (region *reg)
2595	CODE:
2596	RETVAL = reg->msg;
2597	OUTPUT: RETVAL
2598		2390
2599	MODULE = cf PACKAGE = cf::living	2391	MODULE = cf PACKAGE = cf::living
2600		2392
2601	INCLUDE: $PERL genacc living ../include/living.h |	2393	INCLUDE: $PERL genacc living ../include/living.h |
2602		2394
…		…
2623	PPCODE:	2415	PPCODE:
2624	EXTEND (SP, clients.size ());	2416	EXTEND (SP, clients.size ());
2625	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)	2417	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
2626	PUSHs (sv_2mortal (to_sv (*i)));	2418	PUSHs (sv_2mortal (to_sv (*i)));
2627		2419
2628	client *
2629	create (int fd, const char *peername)
2630	CODE:
2631	RETVAL = client::create (fd, peername);
2632	OUTPUT:
2633	RETVAL
2634
2635	void	2420	void
2636	client::send_packet (SV *packet)	2421	client::send_packet (SV *packet)
2637	CODE:	2422	CODE:
2638	{	2423	{
2639	STRLEN len;	2424	STRLEN len;
2640	char *buf = SvPVbyte (packet, len);	2425	char *buf = SvPVbyte (packet, len);
2641		2426
2642	THIS->send_packet (buf, len);	2427	THIS->send_packet (buf, len);
2643	}	2428	}
2644		2429
2645	void
2646	client::destroy ()
2647

Diff Legend

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