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.109 by root, Mon Dec 25 11:25:49 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	160	SvREFCNT_dec (cb);
127	flags &= ~F_BORROWED;	161	cb = 0;
128	refcnt_inc ();	162	}
		163
		164	if (self)
		165	sever_self ();
		166
		167	mortals.push_back (this);
		168	}
		169
		170	void
		171	attachable::destroy ()
		172	{
		173	if (destroyed ())
		174	return;
		175
		176	flags |= F_DESTROYED;
		177	do_destroy ();
		178	}
		179
		180	void
		181	attachable::check_mortals ()
		182	{
		183	static int i = 0;
		184
		185	for (;;)
		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
		197	attachable *obj = mortals [i];
		198
		199	obj->refcnt_chk (); // unborrow from perl, if necessary
		200
		201	//if (obj->refcnt > 0 || obj->self)
		202	if (obj->refcnt || obj->self)
		203	{
		204	//printf ("%p rc %d\n", obj, obj->refcnt_cnt ());//D
		205	++i; // further delay freeing
		206
		207	if (!(i & 0x3ff))
		208	break;
		209	}
		210	else
		211	{
		212	mortals.erase (i);
		213	delete obj;
		214	}
		215	}
		216	}
		217
		218	attachable &
		219	attachable::operator =(const attachable &src)
		220	{
		221	//if (self || cb)
		222	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));
		223
		224	attach = src.attach;
		225	return *this;
		226	}
		227
		228	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		229
		230	static SV *
		231	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())
		232	{
		233	SV *sv;
		234
		235	if (!ptr)
		236	return &PL_sv_undef;
		237
		238	sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);
		239	return sv_bless (newRV_noinc ((SV *)hv), stash);
		240	}
		241
		242	static int
		243	attachable_free (pTHX_ SV *sv, MAGIC *mg)
		244	{
		245	attachable *at = (attachable *)mg->mg_ptr;
		246
		247	//TODO: check if transaction behaviour is really required here
		248	if (SV *self = (SV *)at->self)
		249	{
		250	at->self = 0;
129	SvREFCNT_dec (self);	251	SvREFCNT_dec (self);
130	}	252	}
131		253
132	if (refcnt > 0 || self)	254	// next line makes sense, but most objects still have refcnt 0 by default
		255	//at->refcnt_chk ();
133	return;	256	return 0;
134
135	destroy ();
136	}	257	}
137		258
138	void	259	MGVTBL attachable::vtbl = {0, 0, 0, 0, attachable_free};
139	attachable::do_destroy ()
140	{
141	invoke (EVENT_ATTACHABLE_DESTROY, DT_END);
142
143	//TODO: call generic destroy callback
144	mortals.push_back (this);
145	}
146
147	void
148	attachable::destroy ()
149	{
150	if (destroyed ())
151	return;
152
153	flags |= F_DESTROYED;
154	do_destroy ();
155	}
156
157	void attachable::check_mortals ()
158	{
159	for (int i = 0; i < mortals.size (); )
160	{
161	attachable *obj = mortals [i];
162
163	obj->refcnt_chk (); // unborrow from perl, if necessary
164
165	if (obj->refcnt || obj->self)
166	{
167	#if 0
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
173	}//D
174	else
175	{
176	//Dfprintf (stderr, "deleteing %d:%p:%s\n", i, obj,typeid (*obj).name ());//D
177	delete obj;
178	mortals.erase (i);
179	}
180	}
181	}
182
183	attachable &
184	attachable::operator =(const attachable &src)
185	{
186	//if (self || cb)
187	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));
188
189	attach = src.attach;
190	return *this;
191	}
192
193	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
194		260
195	static SV *	261	static SV *
196	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())
197	{
198	SV *sv;
199
200	if (!ptr)
201	return &PL_sv_undef;
202
203	sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);
204	return sv_bless (newRV_noinc ((SV *)hv), stash);
205	}
206
207	static int
208	attachable_free (pTHX_ SV *sv, MAGIC *mg)
209	{
210	attachable *at = (attachable *)mg->mg_ptr;
211	assert (!(at->flags & attachable::F_BORROWED));//D//TODO//remove when stable
212	at->self = 0;
213	at->refcnt_chk ();
214	return 0;
215	}
216
217	static MGVTBL vtbl_attachable = {0, 0, 0, 0, attachable_free};
218
219	SV *
220	newSVattachable (attachable *obj, HV *stash)	262	newSVattachable (attachable *obj, HV *stash)
221	{	263	{
222	if (!obj)	264	if (!obj)
223	return &PL_sv_undef;	265	return &PL_sv_undef;
224		266
225	if (!obj->self)	267	if (!obj->self)
226	{	268	{
227	obj->self = newHV ();	269	obj->self = newHV ();
228	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);
229		271
230	// borrow the refcnt from the object	272	// now bless the object _once_
231	obj->flags |= attachable::F_BORROWED;	273	return sv_bless (newRV_inc ((SV *)obj->self), stash);
232	obj->refcnt_dec ();
233	}	274	}
		275	else
		276	{
		277	SV *sv = newRV_inc ((SV *)obj->self);
234		278
235	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	}
236	}	284	}
237		285
238	static void	286	static void
239	clearSVptr (SV *sv)	287	clearSVptr (SV *sv)
240	{	288	{
…		…
293	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); }
294		342
295	inline SV *to_sv (object & v) { return to_sv (&v); }	343	inline SV *to_sv (object & v) { return to_sv (&v); }
296	inline SV *to_sv (living & v) { return to_sv (&v); }	344	inline SV *to_sv (living & v) { return to_sv (&v); }
297		345
298	//TODO:
299	inline SV *to_sv (New_Face * v) { return to_sv (v->name); }	346	inline SV *to_sv (facetile * v) { return to_sv (v->name); }
300	inline SV *to_sv (treasurelist * v) { return to_sv (v->name); }	347	inline SV *to_sv (treasurelist * v) { return to_sv (v->name); }
301		348
302	inline SV *to_sv (UUID v)	349	inline SV *to_sv (UUID v)
303	{	350	{
304	char buf[128];	351	char buf[128];
305	snprintf (buf, 128, "<1,%" PRIx64 ">", v.seq);	352	snprintf (buf, 128, "<1.%" PRIx64 ">", v.seq);
306	return newSVpv (buf, 0);	353	return newSVpv (buf, 0);
307	}	354	}
308		355
309	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; }
310	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; }
…		…
319	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); }
320	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); }
321	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); }
322	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }	369	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
323	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }	370	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }
324	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"); }
325	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"); }
326	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"); }
327	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"); }
328	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"); }
329	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"); }
330	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"); }
331	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"); }
332		380
333	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)]; }
334	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)); }
335		383
336	template<class T>	384	template<class T>
337	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; }
338		386
339	template<int N>	387	template<int N>
…		…
474	{	522	{
475	if (!ext->cb)	523	if (!ext->cb)
476	ext->cb = newAV ();	524	ext->cb = newAV ();
477		525
478	return newRV_inc ((SV *)ext->cb);	526	return newRV_inc ((SV *)ext->cb);
479	}
480
481	#if 0
482	void attachable::clear ()
483	{
484	if (self)
485	{
486	// disconnect Perl from C, to avoid crashes
487	sv_unmagic (SvRV ((SV *)self), PERL_MAGIC_ext);
488
489	// clear the perl hash, might or might not be a good idea
490	hv_clear ((HV *)SvRV ((SV *)self));
491
492	SvREFCNT_dec (self);
493	self = 0;
494	}
495
496	if (cb)
497	{
498	SvREFCNT_dec (cb);
499	cb = 0;
500	}
501
502	attach = 0;
503	}
504	#endif
505
506	void attachable::optimise ()
507	{
508	if (self
509	&& SvREFCNT (self) == 1
510	&& !HvTOTALKEYS (self))
511	{
512	flags &= ~F_BORROWED;
513	refcnt_inc ();
514	SvREFCNT_dec ((SV *)self);
515	}
516	}
517
518	/////////////////////////////////////////////////////////////////////////////
519
520	#include "kw_hash.h"
521
522	object_freezer::object_freezer ()
523	: dynbuf (128 * 1024, 64 * 1024)
524	{
525	av = newAV ();
526	}
527
528	object_freezer::~object_freezer ()
529	{
530	SvREFCNT_dec (av);
531	}
532
533	void object_freezer::put (attachable *ext)
534	{
535	ext->optimise ();
536
537	if (ext->self)
538	{
539	int idx = AvFILLp ((AV *)av) + 1;
540	av_store (av, idx, newRV_inc ((SV *)ext->self));
541
542	add ((void *)"oid ", 4);
543	add ((sint32)idx);
544	add ('\n');
545	}
546	}
547
548	bool object_freezer::save (const char *filename)
549	{
550	dSP;
551	ENTER;
552	SAVETMPS;
553	PUSHMARK (SP);
554	EXTEND (SP, 3);
555	PUSHs (sv_2mortal (newSVpv (filename, 0)));
556	PUSHs (sv_2mortal (newRV_noinc (newSVpvn ((char *)linearise (), size ()))));
557	PUSHs (sv_2mortal (newRV_inc ((SV *)av)));
558	PUTBACK;
559	call_pv ("cf::object_freezer_save", G_VOID | G_DISCARD | G_EVAL);
560	FREETMPS;
561	LEAVE;
562	}
563
564	char *object_freezer::as_string ()
565	{
566	dSP;
567	ENTER;
568	SAVETMPS;
569	PUSHMARK (SP);
570	EXTEND (SP, 3);
571	PUSHs (sv_2mortal (newRV_noinc (newSVpvn ((char *)linearise (), size ()))));
572	PUSHs (sv_2mortal (newRV_inc ((SV *)av)));
573	PUTBACK;
574
575	char *res = call_pv ("cf::object_freezer_as_string", G_SCALAR | G_EVAL) > 0
576	? strdup (SvPVbyte_nolen (POPs))
577	: strdup ("[fatal error]");
578
579	FREETMPS;
580	LEAVE;
581
582	return res;
583	}
584
585	int fprintf (object_freezer &freezer, const char *format, ...)
586	{
587	va_list ap;
588
589	va_start (ap, format);
590
591	int len = vsnprintf ((char *)freezer.force (1024), 1024, format, ap);
592
593	if (len >= 0)
594	freezer.alloc (len);
595
596	va_end (ap);
597	}
598
599	int fputs (const char *s, object_freezer &freezer)
600	{
601	freezer.add (s);
602	}
603
604	static const char thawer_eof[] = "\n\n\n\0\0\0";
605
606	object_thawer::object_thawer (const char *filename)
607	{
608	static const char eof[] = "\n\n\n\0\0\0";
609
610	av = 0;
611	text = 0;
612	line = 0;
613
614	if (filename)
615	{
616	dSP;
617	ENTER;
618	SAVETMPS;
619	PUSHMARK (SP);
620	XPUSHs (sv_2mortal (newSVpv (filename, 0)));
621	PUTBACK;
622
623	if (2 == call_pv ("cf::object_thawer_load", G_ARRAY | G_EVAL))
624	{
625	SPAGAIN;
626
627	// second value - perl objects
628	{
629	SV *sv = POPs;
630	if (SvROK (sv))
631	av = (AV *)SvREFCNT_inc (SvRV (sv));
632	}
633
634	// first value - text part, pad with 3 zeroes
635	{
636	SV *sv = POPs;
637	STRLEN len;
638	char *sv_ = SvPVbyte (sv, len);
639	text = newSV (len + sizeof (eof));
640	SvCUR_set (text, len);
641	memcpy (SvPVX (text), sv_, len);
642	memcpy (SvEND (text), eof, sizeof (eof)); // just to be sure
643
644	line = SvPVX (text);
645	}
646	}
647
648	PUTBACK;
649	FREETMPS;
650	LEAVE;
651	}
652	}
653
654	object_thawer::object_thawer (const char *data, AV *perlav)
655	{
656	av = perlav;
657	text = newSVpv (data, 0);
658	sv_catpv (text, thawer_eof);
659	line = SvPVbyte_nolen (text);
660	}
661
662	void object_thawer::get (attachable *obj, int oid)
663	{
664	if (!av || oid < 0) // this is actually an error of sorts
665	return;
666
667	// object must be virgin
668	assert (!obj->self);
669
670	SV **svp = av_fetch ((AV *)av, oid, 0);
671
672	if (!svp || !SvROK (*svp))
673	{
674	printf ("trying to thaw duplicate or never-issued oid %d, ignoring.\n", oid);
675	return;
676	}
677
678	obj->self = (HV *)SvRV (*svp);
679	SvRV_set (*svp, &PL_sv_undef);
680
681	sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &vtbl_attachable, (char *)obj, 0);
682	obj->reattach ();
683
684	// borrow a refcount for the perl object
685	obj->flags |= attachable::F_BORROWED;
686	obj->refcnt_dec ();
687	}
688
689	object_thawer::~object_thawer ()
690	{
691	if (text) SvREFCNT_dec (text);
692	if (av) SvREFCNT_dec (av);
693	}
694
695	char *fgets (char *s, int n, object_thawer &thawer)
696	{
697	char *p = thawer.line;
698	char *q = s;
699
700	if (!p)
701	return 0;
702
703	while (--n)
704	{
705	if (!*p)
706	break;
707
708	*q++ = *p;
709
710	if (*p++ == '\n')
711	break;
712	}
713
714	*q = 0;
715	thawer.line = p;
716
717	return s == q ? 0 : s;
718	}
719
720	keyword object_thawer::get_kv ()
721	{
722	if (!line)
723	return KW_EOF;
724
725	for (;;)
726	{
727	char *p = line;
728
729	if (!*p)
730	return KW_EOF;
731
732	// parse keyword
733	while (*p > ' ')
734	p++;
735
736	int klen = p - line;
737
738	if (*p++ != '\n')
739	{
740	// parse value
741	while (*(unsigned char *)p <= ' ' && *p != '\n') // skip 0x01 .. 0x20
742	++p;
743
744	last_value = p;
745
746	while (*p != '\n')
747	p++;
748
749	*p++ = 0;
750	}
751	else
752	last_value = 0;
753
754	line [klen] = 0;
755	keyword_idx *kw = kw_lex::match (line, klen);
756
757	//printf ("KV %d<%s,%s>\n", kw ? kw->index : 0, line, last_value);//D
758
759	if (kw)
760	{
761	line = p;
762	return kw->index;
763	}
764	else if (!*line || *line == '#')
765	{
766	// empty/comment line
767	line = p;
768	}
769	else
770	return KW_ERROR;
771	}
772	}
773
774	void object_thawer::get (shstr &sh) const
775	{
776	if (last_value)
777	sh = last_value;
778	else
779	{
780	sh = "<value missing>";
781	LOG (llevError, "keyword requires value: <%s>\n", line);//TODO: add filename
782	}
783	}
784
785	void object_thawer::get_ml (keyword kend, shstr &sh)
786	{
787	char kw[128];
788
789	int klen = keyword_len [kend];
790
791	kw [0] = '\n';
792	memcpy (kw + 1, keyword_str [kend], klen);
793	kw [klen + 1] = '\n';
794	kw [klen + 2] = 0;
795
796	// first test for completely empty msg... "endXXX\n"
797	if (!strncmp (line, kw + 1, klen + 1))
798	{
799	sh = 0;
800
801	line += klen + 1;
802
803	return;
804	}
805	else
806	{
807	// multi-line strings are delimited by "\nendXXX\n" or "endXXX\n" (NULL)
808
809	char *end = strstr (line, kw);
810
811	if (!end)
812	{
813	sh = 0;
814	return;
815	}
816
817	*end = 0;
818	sh = line;
819
820	line = end + keyword_len [kend] + 1;
821
822	while (*line++ != '\n')
823	;
824	}
825	}
826
827	sint32 object_thawer::get_sint32 () const
828	{
829	char *p = last_value;
830
831	if (!p)
832	return 0;
833
834	sint32 val = 0;
835	bool negate;
836
837	if (*p == '-')
838	{
839	negate = true;
840	++p;
841	}
842	else
843	negate = false;
844
845	do
846	{
847	val *= 10;
848	val += *p++ - '0';
849	}
850	while (*p);
851
852	return negate ? -val : val;
853	}
854
855	sint64 object_thawer::get_sint64 () const
856	{
857	return last_value ? atoll (last_value) : 0;
858	}
859
860	double object_thawer::get_double () const
861	{
862	return last_value ? atof (last_value) : 0;
863	}	527	}
864		528
865	/////////////////////////////////////////////////////////////////////////////	529	/////////////////////////////////////////////////////////////////////////////
866		530
867	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)
…		…
1094		758
1095	// short-circuit processing if no callbacks found/defined	759	// short-circuit processing if no callbacks found/defined
1096	if (!callbacks)	760	if (!callbacks)
1097	return 0;	761	return 0;
1098		762
1099	dSP;	763	CALL_BEGIN (3);
1100	ENTER;
1101	SAVETMPS;
1102
1103	PUSHMARK (SP);
1104	EXTEND (SP, 3);
1105
1106	PUSHs (sv_2mortal (newSViv (event))); // only used for debugging nowadays	764	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays
1107	PUSHs (sv_2mortal (newRV_noinc ((SV *)callbacks)));	765	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));
1108		766
1109	//TODO: unhack	767	//TODO: unhack
1110	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));
1111	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));
1112	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));
1113	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));
1114	else if (global *gl = is_a<global>(this)) /*nop*/;	772	else if (global *gl = is_a<global>(this)) /*nop*/;
1115	else	773	else
1116	abort (); //TODO	774	abort (); //TODO
1117		775
1118	for (;;)	776	for (;;)
…		…
1132	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));	790	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
1133	}	791	}
1134		792
1135	va_end (ap);	793	va_end (ap);
1136		794
1137	PUTBACK;	795	CALL_CALL ("cf::do_invoke", G_SCALAR);
1138	int count = call_pv ("cf::do_invoke", G_SCALAR | G_EVAL);
1139	SPAGAIN;
1140
1141	count = count > 0 ? POPi : 0;	796	count = count > 0 ? POPi : 0;
1142		797
1143	FREETMPS;	798	CALL_END;
1144	LEAVE;
1145		799
1146	return count;	800	return count;
1147	}	801	}
1148		802
1149	SV *	803	SV *
…		…
1172	return SvNV (cfperl_result (idx));	826	return SvNV (cfperl_result (idx));
1173	}	827	}
1174		828
1175	/////////////////////////////////////////////////////////////////////////////	829	/////////////////////////////////////////////////////////////////////////////
1176		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
1177	struct EventAPI *watcher_base::GEventAPI;	912	struct EventAPI *watcher_base::GEventAPI;
		913	struct CoroAPI *coroapi::GCoroAPI;
		914
		915	int coroapi::cede_counter;
1178		916
1179	static void iw_dispatch (pe_event *ev)	917	static void iw_dispatch (pe_event *ev)
1180	{	918	{
1181	iw *w = (iw *)ev->ext_data;	919	iw *w = (iw *)ev->ext_data;
1182	w->call (*w);	920	w->call (*w);
…		…
1185	void	923	void
1186	iw::alloc ()	924	iw::alloc ()
1187	{	925	{
1188	pe = GEventAPI->new_idle (0, 0);	926	pe = GEventAPI->new_idle (0, 0);
1189		927
		928	WaREENTRANT_off (pe);
1190	pe->base.callback = (void *)iw_dispatch;	929	pe->base.callback = (void *)iw_dispatch;
1191	pe->base.ext_data = (void *)this;	930	pe->base.ext_data = (void *)this;
1192	}	931	}
1193		932
1194	static void iow_dispatch (pe_event *ev)	933	static void iow_dispatch (pe_event *ev)
…		…
1200	void	939	void
1201	iow::alloc ()	940	iow::alloc ()
1202	{	941	{
1203	pe = GEventAPI->new_io (0, 0);	942	pe = GEventAPI->new_io (0, 0);
1204		943
		944	WaREENTRANT_off (pe);
1205	pe->base.callback = (void *)iow_dispatch;	945	pe->base.callback = (void *)iow_dispatch;
1206	pe->base.ext_data = (void *)this;	946	pe->base.ext_data = (void *)this;
1207		947
1208	pe->fd = -1;	948	pe->fd = -1;
1209	pe->poll = 0;	949	pe->poll = 0;
…		…
1245	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);	985	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
1246	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);	986	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
1247	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);	987	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
1248	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);	988	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
1249		989
		990	sv_runtime = get_sv ("cf::RUNTIME", 1);
		991	sv_upgrade (sv_runtime, SVt_NV);
		992
1250	cb_global = get_av ("cf::CB_GLOBAL", 1);	993	cb_global = get_av ("cf::CB_GLOBAL", 1);
1251	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);	994	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
1252	cb_object = get_av ("cf::CB_OBJECT", 1);	995	cb_object = get_av ("cf::CB_OBJECT", 1);
1253	cb_player = get_av ("cf::CB_PLAYER", 1);	996	cb_player = get_av ("cf::CB_PLAYER", 1);
1254	cb_client = get_av ("cf::CB_CLIENT", 1);	997	cb_client = get_av ("cf::CB_CLIENT", 1);
…		…
1260		1003
1261	BOOT:	1004	BOOT:
1262	{	1005	{
1263	_connect_to_perl ();	1006	_connect_to_perl ();
1264		1007
1265	I_EVENT_API (PACKAGE);
1266	watcher_base::GEventAPI = GEventAPI;	1008	I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;
1267	I_CORO_API (PACKAGE);	1009	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
1268		1010
1269	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));	1011	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
1270		1012
1271	static const struct {	1013	static const struct {
1272	const char *name;	1014	const char *name;
…		…
1535	const_iv (FLAG_ACTIVATE_ON_RELEASE)	1277	const_iv (FLAG_ACTIVATE_ON_RELEASE)
1536	const_iv (FLAG_IS_WATER)	1278	const_iv (FLAG_IS_WATER)
1537	const_iv (FLAG_CONTENT_ON_GEN)	1279	const_iv (FLAG_CONTENT_ON_GEN)
1538	const_iv (FLAG_IS_A_TEMPLATE)	1280	const_iv (FLAG_IS_A_TEMPLATE)
1539	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)
1540		1284
1541	const_iv (NDI_BLACK)	1285	const_iv (NDI_BLACK)
1542	const_iv (NDI_WHITE)	1286	const_iv (NDI_WHITE)
1543	const_iv (NDI_NAVY)	1287	const_iv (NDI_NAVY)
1544	const_iv (NDI_RED)	1288	const_iv (NDI_RED)
…		…
1586	const_iv (P_BLOCKSVIEW)	1330	const_iv (P_BLOCKSVIEW)
1587	const_iv (P_PLAYER)	1331	const_iv (P_PLAYER)
1588	const_iv (P_NO_MAGIC)	1332	const_iv (P_NO_MAGIC)
1589	const_iv (P_IS_ALIVE)	1333	const_iv (P_IS_ALIVE)
1590	const_iv (P_NO_CLERIC)	1334	const_iv (P_NO_CLERIC)
1591	const_iv (P_NEED_UPDATE)
1592	const_iv (P_OUT_OF_MAP)	1335	const_iv (P_OUT_OF_MAP)
1593	const_iv (P_NEW_MAP)	1336	const_iv (P_NEW_MAP)
		1337	const_iv (P_UPTODATE)
1594		1338
1595	const_iv (UP_OBJ_INSERT)	1339	const_iv (UP_OBJ_INSERT)
1596	const_iv (UP_OBJ_REMOVE)	1340	const_iv (UP_OBJ_REMOVE)
1597	const_iv (UP_OBJ_CHANGE)	1341	const_iv (UP_OBJ_CHANGE)
1598	const_iv (UP_OBJ_FACE)	1342	const_iv (UP_OBJ_FACE)
…		…
1729	const_iv (ATNR_BLIND)	1473	const_iv (ATNR_BLIND)
1730	const_iv (ATNR_INTERNAL)	1474	const_iv (ATNR_INTERNAL)
1731	const_iv (ATNR_LIFE_STEALING)	1475	const_iv (ATNR_LIFE_STEALING)
1732	const_iv (ATNR_DISEASE)	1476	const_iv (ATNR_DISEASE)
1733		1477
1734	const_iv (MAP_FLUSH)
1735	const_iv (MAP_PLAYER_UNIQUE)
1736	const_iv (MAP_BLOCK)
1737	const_iv (MAP_STYLE)
1738	const_iv (MAP_OVERLAY)
1739
1740	const_iv (MAP_IN_MEMORY)	1478	const_iv (MAP_IN_MEMORY)
1741	const_iv (MAP_SWAPPED)	1479	const_iv (MAP_SWAPPED)
1742	const_iv (MAP_LOADING)	1480	const_iv (MAP_LOADING)
1743	const_iv (MAP_SAVING)	1481	const_iv (MAP_SAVING)
1744		1482
…		…
1757	const_iv (ST_SETUP)	1495	const_iv (ST_SETUP)
1758	const_iv (ST_PLAYING)	1496	const_iv (ST_PLAYING)
1759	const_iv (ST_CUSTOM)	1497	const_iv (ST_CUSTOM)
1760		1498
1761	const_iv (ST_CHANGE_CLASS)	1499	const_iv (ST_CHANGE_CLASS)
1762	const_iv (ST_CONFIRM_QUIT)	1500
1763	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)
1764	};	1529	};
1765		1530
1766	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; )
1767	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));	1532	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1768		1533
…		…
1793		1558
1794	void _global_reattach ()	1559	void _global_reattach ()
1795	CODE:	1560	CODE:
1796	{	1561	{
1797	// reattach to all attachable objects in the game.	1562	// reattach to all attachable objects in the game.
1798	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)	1563	for_all_clients (ns)
1799	(*i)->reattach ();	1564	ns->reattach ();
1800		1565
1801	for (player *pl = first_player; pl; pl = pl->next)	1566	for_all_players (pl)
1802	pl->reattach ();	1567	pl->reattach ();
1803		1568
1804	for (maptile *m = first_map; m; m = m->next)	1569	//TODO
1805	m->reattach ();	1570	//for (map_container::iterator i = maps.begin (); i != maps.end (); ++i)
		1571	// i->second->reattach ();
1806		1572
1807	for (object *op = object::first; op; op = op->next)	1573	for_all_objects (op)
1808	op->reattach ();	1574	op->reattach ();
1809	}	1575	}
1810		1576
1811	NV floor (NV x)	1577	NV floor (NV x)
1812		1578
1813	NV ceil (NV x)	1579	NV ceil (NV x)
1814		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
1815	void server_tick ()	1593	void server_tick ()
		1594	CODE:
		1595	runtime = SvNVx (sv_runtime);
		1596	server_tick ();
1816		1597
1817	void	1598	void
1818	LOG (int level, char *msg)	1599	LOG (int level, char *msg)
1819	PROTOTYPE: $$	1600	PROTOTYPE: $$
1820	C_ARGS: (LogLevel)level, "%s", msg	1601	C_ARGS: (LogLevel)level, "%s", msg
…		…
1860	case 5: RETVAL = settings.playerdir; break;	1641	case 5: RETVAL = settings.playerdir; break;
1861	case 6: RETVAL = settings.datadir ; break;	1642	case 6: RETVAL = settings.datadir ; break;
1862	}	1643	}
1863	OUTPUT: RETVAL	1644	OUTPUT: RETVAL
1864		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
1865	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
1866		1669
1867	int find_animation (char *text)	1670	int find_animation (char *text)
1868	PROTOTYPE: $	1671	PROTOTYPE: $
1869		1672
1870	int random_roll (int min, int max, object *op, int goodbad);	1673	int random_roll (int min, int max, object *op, int goodbad);
…		…
1917	CODE:	1720	CODE:
1918	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);	1721	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
1919	OUTPUT:	1722	OUTPUT:
1920	RETVAL	1723	RETVAL
1921		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
1922	MODULE = cf PACKAGE = cf::global	1737	MODULE = cf PACKAGE = cf::global
1923		1738
1924	int invoke (SV *klass, int event, ...)	1739	int invoke (SV *klass, int event, ...)
1925	CODE:	1740	CODE:
1926	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");
…		…
1941	RETVAL = op->invoke ((event_type)event, ARG_AV (av), DT_END);	1756	RETVAL = op->invoke ((event_type)event, ARG_AV (av), DT_END);
1942	OUTPUT: RETVAL	1757	OUTPUT: RETVAL
1943		1758
1944	SV *registry (object *op)	1759	SV *registry (object *op)
1945		1760
1946	void mortals ()	1761	int objects_size ()
1947	PPCODE:	1762	CODE:
1948	EXTEND (SP, object::mortals.size ());
1949	for (AUTODECL (i, object::mortals.begin ()); i != object::mortals.end (); ++i)
1950	PUSHs (to_sv (*i));
1951
1952	object *first ()
1953	CODE:
1954	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;
1955	OUTPUT: RETVAL	1779	OUTPUT: RETVAL
1956		1780
1957	# missing properties	1781	# missing properties
1958		1782
1959	object *head (object *op)	1783	object *head (object *op)
1960	PROTOTYPE: $	1784	PROTOTYPE: $
1961	CODE:	1785	CODE:
1962	RETVAL = op->head ? op->head : op;	1786	RETVAL = op->head_ ();
1963	OUTPUT: RETVAL	1787	OUTPUT: RETVAL
1964		1788
1965	int is_head (object *op)	1789	int is_head (object *op)
1966	PROTOTYPE: $	1790	PROTOTYPE: $
1967	CODE:	1791	CODE:
1968	RETVAL = !op->head;	1792	RETVAL = op->head_ () == op;
1969	OUTPUT: RETVAL	1793	OUTPUT: RETVAL
1970		1794
1971	void	1795	void
1972	inv (object *obj)	1796	inv (object *obj)
1973	PROTOTYPE: $	1797	PROTOTYPE: $
…		…
1981	void	1805	void
1982	set_animation (object *op, int idx)	1806	set_animation (object *op, int idx)
1983	CODE:	1807	CODE:
1984	SET_ANIMATION (op, idx);	1808	SET_ANIMATION (op, idx);
1985		1809
1986	void	1810	int
1987	object::drain_stat ()	1811	num_animations (object *op)
1988		1812	CODE:
1989	void	1813	RETVAL = NUM_ANIMATIONS (op);
1990	object::drain_specific_stat (int stat)	1814	OUTPUT: RETVAL
1991
1992	void
1993	object::change_luck (int change)
1994
1995	void
1996	object::add_statbonus ()
1997
1998	void
1999	object::remove_statbonus ()
2000		1815
2001	object *find_best_object_match (object *op, const char *match)	1816	object *find_best_object_match (object *op, const char *match)
2002		1817
2003	object *find_marked_object (object *op)	1818	object *find_marked_object (object *op)
2004		1819
…		…
2018		1833
2019	void apply_below (object *op)	1834	void apply_below (object *op)
2020	CODE:	1835	CODE:
2021	player_apply_below (op);	1836	player_apply_below (op);
2022		1837
2023	void remove (object *op)
2024	CODE:
2025	op->remove ();
2026
2027	void
2028	object::destroy (bool destroy_inventory = false)
2029
2030	void
2031	object::destroy_inv (bool drop_to_ground = false)
2032
2033	object *cf_object_present_archname_inside (object *op, char *whatstr)	1838	object *cf_object_present_archname_inside (object *op, char *whatstr)
2034		1839
2035	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)
2036		1841
2037	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)
2038		1843
		1844	#//TODO
2039	object *clone (object *op, int recursive = 0)	1845	object *clone_ (object *op, int recursive = 0)
2040	CODE:	1846	CODE:
2041	if (recursive)	1847	if (recursive)
2042	RETVAL = object_create_clone (op);	1848	RETVAL = object_create_clone (op);
2043	else	1849	else
2044	{	1850	{
…		…
2088		1894
2089	void drop (object *who, object *op)	1895	void drop (object *who, object *op)
2090		1896
2091	void pick_up (object *who, object *op)	1897	void pick_up (object *who, object *op)
2092		1898
2093	object *cf_object_insert_object (object *op, object *container)
2094
2095	object *cf_object_insert_in_ob (object *ob, object *where)
2096
2097	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)
2098		1900
2099	void update_object (object *op, int action)	1901	void update_object (object *op, int action)
2100		1902
2101	object *cf_create_object_by_name (const char *name)	1903	object *cf_create_object_by_name (const char *name)
…		…
2148		1950
2149	player *contr (object *op)	1951	player *contr (object *op)
2150	CODE:	1952	CODE:
2151	RETVAL = op->contr;	1953	RETVAL = op->contr;
2152	OUTPUT: RETVAL	1954	OUTPUT: RETVAL
2153
2154	void
2155	object::roll_stats ()
2156
2157	void
2158	object::update_stats ()
2159
2160	void
2161	object::swap_stats (int a, int b)
2162		1955
2163	const char *get_ob_key_value (object *op, const char *key)	1956	const char *get_ob_key_value (object *op, const char *key)
2164		1957
2165	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)
2166		1959
…		…
2203	RETVAL = op->contr;	1996	RETVAL = op->contr;
2204	OUTPUT: RETVAL	1997	OUTPUT: RETVAL
2205		1998
2206	void check_score (object *op)	1999	void check_score (object *op)
2207		2000
2208	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);
2209		2004
2210	object *cf_player_send_inventory (object *op)	2005	object *cf_player_send_inventory (object *op)
2211		2006
2212	char *cf_player_get_ip (object *op)	2007	char *cf_player_get_ip (object *op)
2213	ALIAS: ip = 0	2008	ALIAS: ip = 0
…		…
2226		2021
2227	void esrv_update_item (object *op, int what, object *item)	2022	void esrv_update_item (object *op, int what, object *item)
2228	C_ARGS: what, op, item	2023	C_ARGS: what, op, item
2229		2024
2230	void clear_los (object *op)	2025	void clear_los (object *op)
2231
2232	int command_reset (object *op, char *params)
2233
2234	int command_teleport (object *op, char *params)
2235		2026
2236	int command_summon (object *op, char *params)	2027	int command_summon (object *op, char *params)
2237		2028
2238	int command_arrest (object *op, char *params)	2029	int command_arrest (object *op, char *params)
2239		2030
…		…
2254	RETVAL = pl->invoke ((event_type)event, ARG_AV (av), DT_END);	2045	RETVAL = pl->invoke ((event_type)event, ARG_AV (av), DT_END);
2255	OUTPUT: RETVAL	2046	OUTPUT: RETVAL
2256		2047
2257	SV *registry (player *pl)	2048	SV *registry (player *pl)
2258		2049
2259	player *
2260	create ()
2261	CODE:
2262	RETVAL = player::create ();
2263	OUTPUT:
2264	RETVAL
2265
2266	player *
2267	load (const char *path)
2268	CODE:
2269	RETVAL = player::load (path);
2270	OUTPUT:
2271	RETVAL
2272
2273	void
2274	player::save (bool final = false)
2275
2276	void
2277	player::connect (client *ns)
2278
2279	void	2050	void
2280	save_stats (player *pl)	2051	save_stats (player *pl)
2281	CODE:	2052	CODE:
2282	pl->ob->stats.hp = pl->ob->stats.maxhp;	2053	pl->ob->stats.hp = pl->ob->stats.maxhp;
2283	pl->ob->stats.sp = pl->ob->stats.maxsp;	2054	pl->ob->stats.sp = pl->ob->stats.maxsp;
2284	pl->ob->stats.grace = pl->ob->stats.maxgrace;	2055	pl->ob->stats.grace = pl->ob->stats.maxgrace;
2285	pl->orig_stats = pl->ob->stats;	2056	pl->orig_stats = pl->ob->stats;
2286
2287	player *cf_player_find (char *name)
2288	PROTOTYPE: $
2289		2057
2290	void cf_player_move (player *pl, int dir)	2058	void cf_player_move (player *pl, int dir)
2291		2059
2292	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);
2293		2061
…		…
2339	if (y) sv_to (y, pl->bed_y);	2107	if (y) sv_to (y, pl->bed_y);
2340		2108
2341	void	2109	void
2342	list ()	2110	list ()
2343	PPCODE:	2111	PPCODE:
2344	for (player *pl = first_player; pl; pl = pl->next)	2112	for_all_players (pl)
2345	XPUSHs (sv_2mortal (to_sv (pl)));	2113	XPUSHs (sv_2mortal (to_sv (pl)));
2346		2114
2347	bool
2348	peaceful (player *pl, bool new_setting = 0)
2349	PROTOTYPE: $;$
2350	CODE:
2351	RETVAL = pl->peaceful;
2352	if (items > 1)
2353	pl->peaceful = new_setting;
2354	OUTPUT:
2355	RETVAL
2356
2357	living *
2358	orig_stats (player *pl)
2359	CODE:
2360	RETVAL = &pl->orig_stats;
2361	OUTPUT: RETVAL
2362
2363	living *
2364	last_stats (player *pl)
2365	CODE:
2366	RETVAL = &pl->last_stats;
2367	OUTPUT: RETVAL
2368
2369		2115
2370	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_	2116	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_
2371
2372	maptile *first ()
2373	PROTOTYPE:
2374	CODE:
2375	RETVAL = first_map;
2376	OUTPUT: RETVAL
2377		2117
2378	int invoke (maptile *map, int event, ...)	2118	int invoke (maptile *map, int event, ...)
2379	CODE:	2119	CODE:
2380	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");
2381	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	2121	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
2385		2125
2386	SV *registry (maptile *map)	2126	SV *registry (maptile *map)
2387		2127
2388	INCLUDE: $PERL genacc maptile ../include/map.h |	2128	INCLUDE: $PERL genacc maptile ../include/map.h |
2389		2129
2390	maptile *new (int width, int height)	2130	void
		2131	maptile::instantiate ()
		2132
		2133	maptile *new ()
2391	PROTOTYPE:	2134	PROTOTYPE:
2392	CODE:	2135	CODE:
2393	{	2136	RETVAL = new maptile;
2394	RETVAL = get_empty_map (width, height);
2395	}
2396	OUTPUT:	2137	OUTPUT:
2397	RETVAL	2138	RETVAL
2398		2139
2399	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	}
2400		2152
2401	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	}
2402		2170
2403	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)
2404		2172
2405	int out_of_map (maptile *map, int x, int y)	2173	int out_of_map (maptile *map, int x, int y)
2406
2407	maptile *tile_map (maptile *map, unsigned int dir)
2408	CODE:
2409	RETVAL = dir < 4 ? map->tile_map [dir] : 0;
2410	OUTPUT:
2411	RETVAL
2412
2413	char *tile_path (maptile *map, unsigned int dir)
2414	CODE:
2415	if (dir >= 4)
2416	XSRETURN_UNDEF;
2417	RETVAL = map->tile_path [dir];
2418	OUTPUT:
2419	RETVAL
2420
2421	maptile *ready_map_name (char *name, int flags = 0)
2422	PROTOTYPE: $;$
2423	ALIAS:
2424	find = 0
2425	get_map = 1
2426
2427	maptile *has_been_loaded (char *name)
2428	PROTOTYPE: $
2429
2430	int in_memory (maptile *map)
2431	CODE:
2432	RETVAL = map->in_memory;
2433	OUTPUT:
2434	RETVAL
2435		2174
2436	void	2175	void
2437	trigger (maptile *map, long connection, bool state = true)	2176	trigger (maptile *map, long connection, bool state = true)
2438	CODE:	2177	CODE:
2439	activate_connection (map, connection, state);	2178	activate_connection (map, connection, state);
…		…
2452		2191
2453	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)
2454	C_ARGS: str, map, nx, ny	2193	C_ARGS: str, map, nx, ny
2455		2194
2456	void	2195	void
2457	cf_map_normalise (maptile *map, int x, int y)	2196	get_map_flags (maptile *map, int x, int y)
2458	PPCODE:	2197	PPCODE:
2459	{	2198	{
2460	maptile *nmap = 0;	2199	maptile *nmap = 0;
2461	I16 nx = 0, ny = 0;	2200	I16 nx = 0, ny = 0;
2462	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);	2201	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
…		…
2498	move_block_at = 4	2237	move_block_at = 4
2499	move_slow_at = 5	2238	move_slow_at = 5
2500	move_on_at = 6	2239	move_on_at = 6
2501	move_off_at = 7	2240	move_off_at = 7
2502	INIT:	2241	INIT:
2503	if (x >= MAP_WIDTH (obj) || y >= MAP_HEIGHT (obj)) XSRETURN_UNDEF;	2242	if (x >= obj->width || y >= obj->height) XSRETURN_UNDEF;
2504	CODE:	2243	CODE:
2505	switch (ix)	2244	switch (ix)
2506	{	2245	{
2507	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;	2246	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;
2508	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;	2247	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;
…		…
2511	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;
2512	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;
2513	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;
2514	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;
2515	}	2254	}
2516	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:
2517	RETVAL	2347	RETVAL
2518
2519	void fix_walls (maptile *map, int x, int y)
2520
2521	void fix_walls_around (maptile *map, int x, int y)
2522		2348
2523	MODULE = cf PACKAGE = cf::arch	2349	MODULE = cf PACKAGE = cf::arch
2524		2350
2525	archetype *find (const char *name)	2351	archetype *find (const char *name)
2526	CODE:	2352	CODE:
…		…
2542	PROTOTYPE:	2368	PROTOTYPE:
2543	CODE:	2369	CODE:
2544	RETVAL = get_firstparty ();	2370	RETVAL = get_firstparty ();
2545	OUTPUT: RETVAL	2371	OUTPUT: RETVAL
2546		2372
2547	partylist *next (partylist *party)	2373	INCLUDE: $PERL genacc partylist ../include/player.h |
2548	CODE:
2549	RETVAL = party->next;
2550	OUTPUT: RETVAL
2551
2552	const char *name (partylist *party)
2553	CODE:
2554	RETVAL = party->partyname;
2555	OUTPUT: RETVAL
2556
2557	const char *password (partylist *party)
2558	CODE:
2559	RETVAL = party->passwd;
2560	OUTPUT: RETVAL
2561		2374
2562	MODULE = cf PACKAGE = cf::region	2375	MODULE = cf PACKAGE = cf::region
2563		2376
2564	region *first ()	2377	region *first ()
2565	PROTOTYPE:	2378	PROTOTYPE:
2566	CODE:	2379	CODE:
2567	RETVAL = first_region;	2380	RETVAL = first_region;
2568	OUTPUT: RETVAL	2381	OUTPUT: RETVAL
2569		2382
2570	region *next (region *reg)	2383	region *find (char *name)
		2384	PROTOTYPE: $
2571	CODE:	2385	CODE:
2572	RETVAL = reg->next;	2386	RETVAL = region::find (name);
2573	OUTPUT: RETVAL	2387	OUTPUT: RETVAL
2574		2388
2575	const char *name (region *reg)	2389	INCLUDE: $PERL genacc region ../include/map.h |
2576	CODE:
2577	RETVAL = reg->name;
2578	OUTPUT: RETVAL
2579
2580	region *parent (region *reg)
2581	CODE:
2582	RETVAL = reg->parent;
2583	OUTPUT: RETVAL
2584
2585	const char *longname (region *reg)
2586	CODE:
2587	RETVAL = reg->longname;
2588	OUTPUT: RETVAL
2589
2590	const char *msg (region *reg)
2591	CODE:
2592	RETVAL = reg->msg;
2593	OUTPUT: RETVAL
2594		2390
2595	MODULE = cf PACKAGE = cf::living	2391	MODULE = cf PACKAGE = cf::living
2596		2392
2597	INCLUDE: $PERL genacc living ../include/living.h |	2393	INCLUDE: $PERL genacc living ../include/living.h |
2598		2394
…		…
2619	PPCODE:	2415	PPCODE:
2620	EXTEND (SP, clients.size ());	2416	EXTEND (SP, clients.size ());
2621	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)	2417	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
2622	PUSHs (sv_2mortal (to_sv (*i)));	2418	PUSHs (sv_2mortal (to_sv (*i)));
2623		2419
2624	client *
2625	create (int fd, const char *peername)
2626	CODE:
2627	RETVAL = client::create (fd, peername);
2628	OUTPUT:
2629	RETVAL
2630
2631	void	2420	void
2632	client::send_packet (SV *packet)	2421	client::send_packet (SV *packet)
2633	CODE:	2422	CODE:
2634	{	2423	{
2635	STRLEN len;	2424	STRLEN len;
2636	char *buf = SvPVbyte (packet, len);	2425	char *buf = SvPVbyte (packet, len);
2637		2426
2638	THIS->send_packet (buf, len);	2427	THIS->send_packet (buf, len);
2639	}	2428	}
2640		2429
2641	void
2642	client::destroy ()
2643

Diff Legend

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