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.181 by root, Tue Apr 3 00:21:38 2007 UTC

…		…
4		4
5	/*	5	/*
6	* This code is placed under the GNU General Public Licence (GPL)	6	* This code is placed under the GNU General Public Licence (GPL)
7	*	7	*
8	* Copyright (C) 2001-2005 by Chachkoff Yann	8	* Copyright (C) 2001-2005 by Chachkoff Yann
9	* Copyright (C) 2006 by Marc Lehmann <cf@schmorp.de>	9	* Copyright (C) 2006,2007 by Marc Lehmann <cf@schmorp.de>
10	*	10	*
11	* This program is free software; you can redistribute it and/or modify	11	* This program is free software; you can redistribute it and/or modify
12	* it under the terms of the GNU General Public License as published by	12	* it under the terms of the GNU General Public License as published by
13	* the Free Software Foundation; either version 2 of the License, or	13	* the Free Software Foundation; either version 2 of the License, or
14	* (at your option) any later version.	14	* (at your option) any later version.
…		…
29	#include <plugin_common.h>	29	#include <plugin_common.h>
30	#include <sounds.h>	30	#include <sounds.h>
31	#include <cstdarg>	31	#include <cstdarg>
32	#include <sproto.h>	32	#include <sproto.h>
33		33
		34	#include "loader.h"
34	#include "cfperl.h"	35	#include "cfperl.h"
35	#include "shstr.h"	36	#include "shstr.h"
		37
		38	#include <unistd.h>
		39	#if _POSIX_MEMLOCK
		40	# include <sys/mman.h>
		41	#endif
36		42
37	#include <EXTERN.h>	43	#include <EXTERN.h>
38	#include <perl.h>	44	#include <perl.h>
39	#include <XSUB.h>	45	#include <XSUB.h>
40		46
…		…
60	static f_plug_api object_set_property = cfapi_object_set_property;	66	static f_plug_api object_set_property = cfapi_object_set_property;
61	static f_plug_api object_insert = cfapi_object_insert;	67	static f_plug_api object_insert = cfapi_object_insert;
62		68
63	static PerlInterpreter *perl;	69	static PerlInterpreter *perl;
64		70
		71	double runtime;
		72
65	global gbl_ev;	73	global gbl_ev;
66	static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map;	74	static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map;
		75	static SV *sv_runtime;
67		76
68	static HV	77	static HV
69	*stash_cf,	78	*stash_cf,
70	*stash_cf_object_wrap,	79	*stash_cf_object_wrap,
71	*stash_cf_object_player_wrap,	80	*stash_cf_object_player_wrap,
…		…
91		100
92	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	101	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
93		102
94	unordered_vector<attachable *> attachable::mortals;	103	unordered_vector<attachable *> attachable::mortals;
95		104
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 ()	105	attachable::~attachable ()
108	{	106	{
109	assert (!(flags & F_BORROWED));//D//TODO//remove when stable	107	flags |=0x3300;//D
110	#if 0
111	assert (!rc_next);
112	assert (!refcnt);	108	assert (!self);
113	#endif	109	assert (!cb);
		110	}
		111
		112	int
		113	attachable::refcnt_cnt () const
		114	{
		115	return refcnt + (self ? SvREFCNT (self) - 1 : 0);
		116	}
		117
		118	void
		119	attachable::sever_self ()
		120	{
		121	if (HV *self = this->self)
		122	{
		123	// keep a refcount because sv_unmagic might call attachable_free,
		124	// which might clear self, causing sv_unmagic to crash on a now
		125	// invalid object.
		126	SvREFCNT_inc (self);
		127	hv_clear (self);
		128	sv_unmagic ((SV *)self, PERL_MAGIC_ext);
		129	SvREFCNT_dec (self);
		130
		131	// self *must* be null now because thats sv_unmagic's job.
		132	assert (!this->self);
		133	flags |= 0x80; // severed //D
		134	}
		135	}
		136
		137	void
		138	attachable::optimise ()
		139	{
		140	if (self
		141	&& SvREFCNT (self) == 1
		142	&& !HvTOTALKEYS (self))
		143	flags |= 0x40,//D
		144	sever_self ();
114	}	145	}
115		146
116	// check wether the object really is dead	147	// check wether the object really is dead
117	void	148	void
118	attachable::do_check ()	149	attachable::do_check ()
119	{	150	{
120	if (refcnt > 0)	151	if (refcnt_cnt () > 0)
121	return;	152	return;
122		153
123	// try to unborrow the refcnt from perl	154	destroy ();
124	if (flags & F_BORROWED)	155	}
		156
		157	void
		158	attachable::do_destroy ()
		159	{
		160	invoke (EVENT_ATTACHABLE_DESTROY, DT_END);
		161
		162	if (cb)
125	{	163	{
126	assert (self);//D//TODO//remove when stable	164	SvREFCNT_dec (cb);
127	flags &= ~F_BORROWED;	165	cb = 0;
128	refcnt_inc ();	166	}
		167
		168	if (self)
		169	sever_self ();
		170
		171	flags |= 0x20; //D
		172	mortals.push_back (this);
		173	}
		174
		175	void
		176	attachable::destroy ()
		177	{
		178	if (destroyed ())
		179	return;
		180
		181	flags |= F_DESTROYED;
		182	do_destroy ();
		183	}
		184
		185	void
		186	attachable::check_mortals ()
		187	{
		188	static int i = 0;
		189
		190	for (;;)
		191	{
		192	if (i >= mortals.size ())
		193	{
		194	i = 0;
		195
		196	if (mortals.size () > 1000)
		197	fprintf (stderr, "mortal queue size (%d) exceeds 1000.\n", (int)mortals.size ());
		198
		199	break;
		200	}
		201
		202	attachable *obj = mortals [i];
		203
		204	obj->refcnt_chk (); // unborrow from perl, if necessary
		205
		206	//if (obj->refcnt > 0 || obj->self)
		207	if (obj->refcnt || obj->self)
		208	{
		209	//printf ("%p rc %d\n", obj, obj->refcnt_cnt ());//D
		210	++i; // further delay freeing
		211
		212	if (!(i & 0x3ff))
		213	break;
		214	}
		215	else
		216	{
		217	mortals.erase (i);
		218	delete obj;
		219	}
		220	}
		221	}
		222
		223	attachable &
		224	attachable::operator =(const attachable &src)
		225	{
		226	//if (self || cb)
		227	//INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));
		228
		229	attach = src.attach;
		230	return *this;
		231	}
		232
		233	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		234
		235	static SV *
		236	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())
		237	{
		238	SV *sv;
		239
		240	if (!ptr)
		241	return &PL_sv_undef;
		242
		243	sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);
		244	return sv_bless (newRV_noinc ((SV *)hv), stash);
		245	}
		246
		247	static int
		248	attachable_free (pTHX_ SV *sv, MAGIC *mg)
		249	{
		250	attachable *at = (attachable *)mg->mg_ptr;
		251
		252	//TODO: check if transaction behaviour is really required here
		253	if (SV *self = (SV *)at->self)
		254	{
		255	at->self = 0;
129	SvREFCNT_dec (self);	256	SvREFCNT_dec (self);
130	}	257	}
131		258
132	if (refcnt > 0 || self)	259	// next line makes sense, but most objects still have refcnt 0 by default
		260	//at->refcnt_chk ();
133	return;	261	return 0;
134
135	destroy ();
136	}	262	}
137		263
138	void	264	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		265
195	static SV *	266	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)	267	newSVattachable (attachable *obj, HV *stash)
221	{	268	{
222	if (!obj)	269	if (!obj)
223	return &PL_sv_undef;	270	return &PL_sv_undef;
224		271
225	if (!obj->self)	272	if (!obj->self)
226	{	273	{
227	obj->self = newHV ();	274	obj->self = newHV ();
228	sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &vtbl_attachable, (char *)obj, 0);	275	sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char *)obj, 0);
		276	obj->flags |= (obj->flags & 0xc0) << 8;
		277	obj->flags &= ~0xc0;//D
		278	obj->flags |= 0x10;//D
229		279
230	// borrow the refcnt from the object	280	// now bless the object _once_
231	obj->flags |= attachable::F_BORROWED;	281	return sv_bless (newRV_inc ((SV *)obj->self), stash);
232	obj->refcnt_dec ();
233	}	282	}
		283	else
		284	{
		285	SV *sv = newRV_inc ((SV *)obj->self);
234		286
235	return sv_bless (newRV_inc ((SV *)obj->self), stash);	287	if (Gv_AMG (stash)) // handle overload correctly, as the perl core does not
		288	SvAMAGIC_on (sv);
		289
		290	return sv;
		291	}
236	}	292	}
237		293
238	static void	294	static void
239	clearSVptr (SV *sv)	295	clearSVptr (SV *sv)
240	{	296	{
…		…
293	inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }	349	inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }
294		350
295	inline SV *to_sv (object & v) { return to_sv (&v); }	351	inline SV *to_sv (object & v) { return to_sv (&v); }
296	inline SV *to_sv (living & v) { return to_sv (&v); }	352	inline SV *to_sv (living & v) { return to_sv (&v); }
297		353
298	//TODO:
299	inline SV *to_sv (New_Face * v) { return to_sv (v->name); }	354	//inline SV *to_sv (faceinfo * v) { return to_sv (v->name); }
300	inline SV *to_sv (treasurelist * v) { return to_sv (v->name); }	355	inline SV *to_sv (treasurelist * v) { return to_sv (v->name); }
		356	inline SV *to_sv (std::string & v) { return newSVpvn (v.data (), v.size ()); }
301		357
302	inline SV *to_sv (UUID v)	358	inline SV *to_sv (UUID v)
303	{	359	{
304	char buf[128];	360	char buf[128];
305	snprintf (buf, 128, "<1,%" PRIx64 ">", v.seq);	361	snprintf (buf, 128, "<1.%" PRIx64 ">", v.seq);
306	return newSVpv (buf, 0);	362	return newSVpv (buf, 0);
307	}	363	}
308		364
309	inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPV_nolen (sv) : 0; }	365	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; }	366	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); }	375	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); }	376	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); }	377	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); }	378	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
323	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }	379	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"); }	380	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"); }	381	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"); }	382	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"); }	383	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"); }	384	inline void sv_to (SV *sv, maptile * &v) { v = (maptile *)(attachable *)SvPTR_ornull (sv, "cf::map"); }
		385	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"); }	386	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"); }	387	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"); }	388	inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }
332		389
333	inline void sv_to (SV *sv, New_Face * &v) { v = &new_faces[FindFace (SvPV_nolen (sv), 0)]; } //TODO	390	//inline void sv_to (SV *sv, faceinfo * &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }
334	inline void sv_to (SV *sv, treasurelist * &v) { v = find_treasurelist (SvPV_nolen (sv)); } // TODO	391	inline void sv_to (SV *sv, treasurelist * &v) { v = find_treasurelist (SvPV_nolen (sv)); }
335		392
336	template<class T>	393	template<class T>
337	inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }	394	inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }
338		395
339	template<int N>	396	template<int N>
…		…
342	inline void sv_to (SV *sv, rangetype &v) { v = (rangetype) SvIV (sv); }	399	inline void sv_to (SV *sv, rangetype &v) { v = (rangetype) SvIV (sv); }
343	inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); }	400	inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); }
344	inline void sv_to (SV *sv, petmode_t &v) { v = (petmode_t) SvIV (sv); }	401	inline void sv_to (SV *sv, petmode_t &v) { v = (petmode_t) SvIV (sv); }
345	inline void sv_to (SV *sv, usekeytype &v) { v = (usekeytype) SvIV (sv); }	402	inline void sv_to (SV *sv, usekeytype &v) { v = (usekeytype) SvIV (sv); }
346	inline void sv_to (SV *sv, unapplymode &v) { v = (unapplymode) SvIV (sv); }	403	inline void sv_to (SV *sv, unapplymode &v) { v = (unapplymode) SvIV (sv); }
		404
		405	inline void sv_to (SV *sv, std::string &v)
		406	{
		407	STRLEN len;
		408	char *data = SvPVbyte (sv, len);
		409	v.assign (data, len);
		410	}
347		411
348	inline void sv_to (SV *sv, UUID &v)	412	inline void sv_to (SV *sv, UUID &v)
349	{	413	{
350	unsigned int version;	414	unsigned int version;
351		415
…		…
474	{	538	{
475	if (!ext->cb)	539	if (!ext->cb)
476	ext->cb = newAV ();	540	ext->cb = newAV ();
477		541
478	return newRV_inc ((SV *)ext->cb);	542	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	}	543	}
864		544
865	/////////////////////////////////////////////////////////////////////////////	545	/////////////////////////////////////////////////////////////////////////////
866		546
867	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)	547	extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
…		…
926	perl = perl_alloc ();	606	perl = perl_alloc ();
927	perl_construct (perl);	607	perl_construct (perl);
928		608
929	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;	609	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
930		610
931	char *argv[] = {	611	const char *argv[] = {
932	"",	612	"",
933	"-e"	613	"-e"
934	"use Event; use Coro;" // required for bootstrap	614	"use Event; use Coro;" // required for bootstrap
935	"cf->bootstrap;" // required for datadir :*>	615	"cf->bootstrap;" // required for datadir :*>
936	"unshift @INC, cf::datadir ();"	616	"unshift @INC, cf::datadir ();"
937	"require cf;"	617	"require cf;"
938	};	618	};
939		619
940	if (perl_parse (perl, xs_init, 2, argv, (char **)NULL) || perl_run (perl))	620	if (perl_parse (perl, xs_init, 2, (char **)argv, (char **)NULL)
		621	|| perl_run (perl))
941	{	622	{
942	printf ("unable to initialize perl-interpreter, aborting.\n");	623	printf ("unable to initialize perl-interpreter, aborting.\n");
943	exit (EXIT_FAILURE);	624	exit (EXIT_FAILURE);
944	}	625	}
		626
		627	{
		628	dSP;
		629
		630	PUSHMARK (SP);
		631	PUTBACK;
		632	call_pv ("cf::init", G_DISCARD | G_VOID);
		633	}
945	}	634	}
946		635
947	void cfperl_main ()	636	void cfperl_main ()
948	{	637	{
949	dSP;	638	dSP;
…		…
1094		783
1095	// short-circuit processing if no callbacks found/defined	784	// short-circuit processing if no callbacks found/defined
1096	if (!callbacks)	785	if (!callbacks)
1097	return 0;	786	return 0;
1098		787
1099	dSP;	788	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	789	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays
1107	PUSHs (sv_2mortal (newRV_noinc ((SV *)callbacks)));	790	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));
1108		791
1109	//TODO: unhack	792	//TODO: unhack
1110	if (object *op = is_a<object>(this)) PUSHs (sv_2mortal (newSVdt (DT_OBJECT, op)));	793	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)));	794	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)));	795	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)));	796	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*/;	797	else if (global *gl = is_a<global>(this)) /*nop*/;
1115	else	798	else
1116	abort (); //TODO	799	abort (); //TODO
1117		800
1118	for (;;)	801	for (;;)
…		…
1132	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));	815	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
1133	}	816	}
1134		817
1135	va_end (ap);	818	va_end (ap);
1136		819
1137	PUTBACK;	820	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;	821	count = count > 0 ? POPi : 0;
1142		822
1143	FREETMPS;	823	CALL_END;
1144	LEAVE;
1145		824
1146	return count;	825	return count;
1147	}	826	}
1148		827
1149	SV *	828	SV *
…		…
1172	return SvNV (cfperl_result (idx));	851	return SvNV (cfperl_result (idx));
1173	}	852	}
1174		853
1175	/////////////////////////////////////////////////////////////////////////////	854	/////////////////////////////////////////////////////////////////////////////
1176		855
		856	void
		857	cfperl_emergency_save ()
		858	{
		859	CALL_BEGIN (0);
		860	CALL_CALL ("cf::emergency_save", G_VOID);
		861	CALL_END;
		862	}
		863
		864	void
		865	cfperl_cleanup (int make_core)
		866	{
		867	CALL_BEGIN (1);
		868	CALL_ARG (make_core);
		869	CALL_CALL ("cf::post_cleanup", G_VOID);
		870	CALL_END;
		871	}
		872
		873	maptile *
		874	maptile::find_sync (const char *path, maptile *origin)
		875	{
		876	CALL_BEGIN (2);
		877	CALL_ARG (path);
		878	CALL_ARG (origin);
		879	CALL_CALL ("cf::map::find_sync", G_SCALAR);
		880
		881	maptile *retval;
		882
		883	if (count)
		884	sv_to (POPs, retval);
		885	else
		886	retval = 0;
		887
		888	CALL_END;
		889
		890	return retval;
		891	}
		892
		893	maptile *
		894	maptile::find_async (const char *path, maptile *origin)
		895	{
		896	CALL_BEGIN (2);
		897	CALL_ARG (path);
		898	CALL_ARG (origin);
		899	CALL_CALL ("cf::map::find_async", G_SCALAR);
		900
		901	maptile *retval;
		902
		903	if (count)
		904	sv_to (POPs, retval);
		905	else
		906	retval = 0;
		907
		908	CALL_END;
		909
		910	return retval;
		911	}
		912
		913	void
		914	maptile::do_load_sync ()
		915	{
		916	CALL_BEGIN (1);
		917	CALL_ARG (this);
		918	CALL_CALL ("cf::map::do_load_sync", G_SCALAR);
		919	CALL_END;
		920	}
		921
		922	void
		923	maptile::change_all_map_light (int change)
		924	{
		925	CALL_BEGIN (1);
		926	CALL_ARG (change);
		927	CALL_CALL ("cf::map::change_all_map_light", G_VOID);
		928	CALL_END;
		929	}
		930
		931	void
		932	object::enter_exit (object *exit)
		933	{
		934	if (type != PLAYER)
		935	return;
		936
		937	CALL_BEGIN (2);
		938	CALL_ARG (this);
		939	CALL_ARG (exit);
		940	CALL_CALL ("cf::object::player::enter_exit", G_VOID);
		941	CALL_END;
		942	}
		943
		944	/////////////////////////////////////////////////////////////////////////////
		945
1177	struct EventAPI *watcher_base::GEventAPI;	946	struct EventAPI *watcher_base::GEventAPI;
		947	struct CoroAPI *coroapi::GCoroAPI;
		948
		949	int coroapi::cede_counter;
1178		950
1179	static void iw_dispatch (pe_event *ev)	951	static void iw_dispatch (pe_event *ev)
1180	{	952	{
1181	iw *w = (iw *)ev->ext_data;	953	iw *w = (iw *)ev->ext_data;
1182	w->call (*w);	954	w->call (*w);
…		…
1185	void	957	void
1186	iw::alloc ()	958	iw::alloc ()
1187	{	959	{
1188	pe = GEventAPI->new_idle (0, 0);	960	pe = GEventAPI->new_idle (0, 0);
1189		961
		962	WaREENTRANT_off (pe);
1190	pe->base.callback = (void *)iw_dispatch;	963	pe->base.callback = (void *)iw_dispatch;
1191	pe->base.ext_data = (void *)this;	964	pe->base.ext_data = (void *)this;
1192	}	965	}
1193		966
1194	static void iow_dispatch (pe_event *ev)	967	static void iow_dispatch (pe_event *ev)
…		…
1200	void	973	void
1201	iow::alloc ()	974	iow::alloc ()
1202	{	975	{
1203	pe = GEventAPI->new_io (0, 0);	976	pe = GEventAPI->new_io (0, 0);
1204		977
		978	WaREENTRANT_off (pe);
1205	pe->base.callback = (void *)iow_dispatch;	979	pe->base.callback = (void *)iow_dispatch;
1206	pe->base.ext_data = (void *)this;	980	pe->base.ext_data = (void *)this;
1207		981
1208	pe->fd = -1;	982	pe->fd = -1;
1209	pe->poll = 0;	983	pe->poll = 0;
…		…
1245	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);	1019	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
1246	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);	1020	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
1247	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);	1021	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
1248	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);	1022	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
1249		1023
		1024	sv_runtime = get_sv ("cf::RUNTIME", 1);
		1025	sv_upgrade (sv_runtime, SVt_NV);
		1026
1250	cb_global = get_av ("cf::CB_GLOBAL", 1);	1027	cb_global = get_av ("cf::CB_GLOBAL", 1);
1251	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);	1028	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
1252	cb_object = get_av ("cf::CB_OBJECT", 1);	1029	cb_object = get_av ("cf::CB_OBJECT", 1);
1253	cb_player = get_av ("cf::CB_PLAYER", 1);	1030	cb_player = get_av ("cf::CB_PLAYER", 1);
1254	cb_client = get_av ("cf::CB_CLIENT", 1);	1031	cb_client = get_av ("cf::CB_CLIENT", 1);
…		…
1260		1037
1261	BOOT:	1038	BOOT:
1262	{	1039	{
1263	_connect_to_perl ();	1040	_connect_to_perl ();
1264		1041
1265	I_EVENT_API (PACKAGE);
1266	watcher_base::GEventAPI = GEventAPI;	1042	I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;
1267	I_CORO_API (PACKAGE);	1043	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
1268		1044
1269	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));	1045	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
1270		1046
1271	static const struct {	1047	static const struct {
1272	const char *name;	1048	const char *name;
…		…
1275	# define const_iv(name) { # name, (IV)name },	1051	# define const_iv(name) { # name, (IV)name },
1276	const_iv (llevError)	1052	const_iv (llevError)
1277	const_iv (llevInfo)	1053	const_iv (llevInfo)
1278	const_iv (llevDebug)	1054	const_iv (llevDebug)
1279	const_iv (llevMonster)	1055	const_iv (llevMonster)
		1056
		1057	const_iv (Map0Cmd)
		1058	const_iv (Map1Cmd)
		1059	const_iv (Map1aCmd)
		1060
		1061	const_iv (MAP_CLIENT_X)
		1062	const_iv (MAP_CLIENT_Y)
1280		1063
1281	const_iv (MAX_TIME)	1064	const_iv (MAX_TIME)
1282	const_iv (PLAYER)	1065	const_iv (PLAYER)
1283	const_iv (TRANSPORT)	1066	const_iv (TRANSPORT)
1284	const_iv (ROD)	1067	const_iv (ROD)
…		…
1535	const_iv (FLAG_ACTIVATE_ON_RELEASE)	1318	const_iv (FLAG_ACTIVATE_ON_RELEASE)
1536	const_iv (FLAG_IS_WATER)	1319	const_iv (FLAG_IS_WATER)
1537	const_iv (FLAG_CONTENT_ON_GEN)	1320	const_iv (FLAG_CONTENT_ON_GEN)
1538	const_iv (FLAG_IS_A_TEMPLATE)	1321	const_iv (FLAG_IS_A_TEMPLATE)
1539	const_iv (FLAG_IS_BUILDABLE)	1322	const_iv (FLAG_IS_BUILDABLE)
		1323	const_iv (FLAG_DESTROY_ON_DEATH)
		1324	const_iv (FLAG_NO_MAP_SAVE)
1540		1325
1541	const_iv (NDI_BLACK)	1326	const_iv (NDI_BLACK)
1542	const_iv (NDI_WHITE)	1327	const_iv (NDI_WHITE)
1543	const_iv (NDI_NAVY)	1328	const_iv (NDI_NAVY)
1544	const_iv (NDI_RED)	1329	const_iv (NDI_RED)
…		…
1586	const_iv (P_BLOCKSVIEW)	1371	const_iv (P_BLOCKSVIEW)
1587	const_iv (P_PLAYER)	1372	const_iv (P_PLAYER)
1588	const_iv (P_NO_MAGIC)	1373	const_iv (P_NO_MAGIC)
1589	const_iv (P_IS_ALIVE)	1374	const_iv (P_IS_ALIVE)
1590	const_iv (P_NO_CLERIC)	1375	const_iv (P_NO_CLERIC)
1591	const_iv (P_NEED_UPDATE)
1592	const_iv (P_OUT_OF_MAP)	1376	const_iv (P_OUT_OF_MAP)
1593	const_iv (P_NEW_MAP)	1377	const_iv (P_NEW_MAP)
		1378	const_iv (P_UPTODATE)
1594		1379
1595	const_iv (UP_OBJ_INSERT)	1380	const_iv (UP_OBJ_INSERT)
1596	const_iv (UP_OBJ_REMOVE)	1381	const_iv (UP_OBJ_REMOVE)
1597	const_iv (UP_OBJ_CHANGE)	1382	const_iv (UP_OBJ_CHANGE)
1598	const_iv (UP_OBJ_FACE)	1383	const_iv (UP_OBJ_FACE)
…		…
1729	const_iv (ATNR_BLIND)	1514	const_iv (ATNR_BLIND)
1730	const_iv (ATNR_INTERNAL)	1515	const_iv (ATNR_INTERNAL)
1731	const_iv (ATNR_LIFE_STEALING)	1516	const_iv (ATNR_LIFE_STEALING)
1732	const_iv (ATNR_DISEASE)	1517	const_iv (ATNR_DISEASE)
1733		1518
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)	1519	const_iv (MAP_IN_MEMORY)
1741	const_iv (MAP_SWAPPED)	1520	const_iv (MAP_SWAPPED)
1742	const_iv (MAP_LOADING)	1521	const_iv (MAP_LOADING)
1743	const_iv (MAP_SAVING)	1522	const_iv (MAP_SAVING)
1744		1523
…		…
1757	const_iv (ST_SETUP)	1536	const_iv (ST_SETUP)
1758	const_iv (ST_PLAYING)	1537	const_iv (ST_PLAYING)
1759	const_iv (ST_CUSTOM)	1538	const_iv (ST_CUSTOM)
1760		1539
1761	const_iv (ST_CHANGE_CLASS)	1540	const_iv (ST_CHANGE_CLASS)
1762	const_iv (ST_CONFIRM_QUIT)	1541
1763	const_iv (ST_GET_PARTY_PASSWORD)	1542	const_iv (IO_HEADER)
		1543	const_iv (IO_OBJECTS)
		1544	const_iv (IO_UNIQUES)
		1545
		1546	// random map generator
		1547	const_iv (LAYOUT_NONE)
		1548	const_iv (LAYOUT_ONION)
		1549	const_iv (LAYOUT_MAZE)
		1550	const_iv (LAYOUT_SPIRAL)
		1551	const_iv (LAYOUT_ROGUELIKE)
		1552	const_iv (LAYOUT_SNAKE)
		1553	const_iv (LAYOUT_SQUARE_SPIRAL)
		1554
		1555	const_iv (RMOPT_RANDOM)
		1556	const_iv (RMOPT_CENTERED)
		1557	const_iv (RMOPT_LINEAR)
		1558	const_iv (RMOPT_BOTTOM_C)
		1559	const_iv (RMOPT_BOTTOM_R)
		1560	const_iv (RMOPT_IRR_SPACE)
		1561	const_iv (RMOPT_WALL_OFF)
		1562	const_iv (RMOPT_WALLS_ONLY)
		1563	const_iv (RMOPT_NO_DOORS)
		1564
		1565	const_iv (SYMMETRY_RANDOM)
		1566	const_iv (SYMMETRY_NONE)
		1567	const_iv (SYMMETRY_X)
		1568	const_iv (SYMMETRY_Y)
		1569	const_iv (SYMMETRY_XY)
1764	};	1570	};
1765		1571
1766	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	1572	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1767	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));	1573	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1768		1574
…		…
1793		1599
1794	void _global_reattach ()	1600	void _global_reattach ()
1795	CODE:	1601	CODE:
1796	{	1602	{
1797	// reattach to all attachable objects in the game.	1603	// reattach to all attachable objects in the game.
1798	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)	1604	for_all_clients (ns)
1799	(*i)->reattach ();	1605	ns->reattach ();
1800		1606
1801	for (player *pl = first_player; pl; pl = pl->next)	1607	for_all_objects (op)
1802	pl->reattach ();
1803
1804	for (maptile *m = first_map; m; m = m->next)
1805	m->reattach ();
1806
1807	for (object *op = object::first; op; op = op->next)
1808	op->reattach ();	1608	op->reattach ();
1809	}	1609	}
1810		1610
1811	NV floor (NV x)	1611	NV floor (NV x)
1812		1612
1813	NV ceil (NV x)	1613	NV ceil (NV x)
1814		1614
		1615	NV rndm (...)
		1616	CODE:
		1617	switch (items)
		1618	{
		1619	case 0: RETVAL = rndm (); break;
		1620	case 1: RETVAL = rndm (SvUV (ST (0))); break;
		1621	case 2: RETVAL = rndm (SvIV (ST (0)), SvIV (ST (1))); break;
		1622	default: croak ("cf::rndm requires none, one or two parameters."); break;
		1623	}
		1624	OUTPUT:
		1625	RETVAL
		1626
1815	void server_tick ()	1627	void server_tick ()
		1628	CODE:
		1629	runtime = SvNVx (sv_runtime);
		1630	server_tick ();
1816		1631
1817	void	1632	void
1818	LOG (int level, char *msg)	1633	LOG (int level, char *msg)
1819	PROTOTYPE: $$	1634	PROTOTYPE: $$
1820	C_ARGS: (LogLevel)level, "%s", msg	1635	C_ARGS: (LogLevel)level, "%s", msg
…		…
1836	void	1651	void
1837	sub_generation_inc ()	1652	sub_generation_inc ()
1838	CODE:	1653	CODE:
1839	PL_sub_generation++;	1654	PL_sub_generation++;
1840		1655
1841	char *	1656	const char *
1842	mapdir ()	1657	mapdir ()
1843	PROTOTYPE:	1658	PROTOTYPE:
1844	ALIAS:	1659	ALIAS:
1845	mapdir = 0	1660	mapdir = 0
1846	uniquedir = 1	1661	uniquedir = 1
…		…
1860	case 5: RETVAL = settings.playerdir; break;	1675	case 5: RETVAL = settings.playerdir; break;
1861	case 6: RETVAL = settings.datadir ; break;	1676	case 6: RETVAL = settings.datadir ; break;
1862	}	1677	}
1863	OUTPUT: RETVAL	1678	OUTPUT: RETVAL
1864		1679
		1680	void abort ()
		1681
		1682	void fork_abort (char *cause = "cf::fork_abort")
		1683
		1684	void cleanup (const char *cause, bool make_core = false)
		1685
		1686	void emergency_save ()
		1687
1865	void _exit (int status = 0)	1688	void _exit (int status = EXIT_SUCCESS)
		1689
		1690	UV sv_2watcher (SV *w)
		1691	CODE:
		1692	RETVAL = (UV)GEventAPI->sv_2watcher (w);
		1693	OUTPUT:
		1694	RETVAL
		1695
		1696	#if _POSIX_MEMLOCK
		1697
		1698	int mlockall (int flags = MCL_CURRENT | MCL_FUTURE)
		1699
		1700	int munlockall ()
		1701
		1702	#endif
1866		1703
1867	int find_animation (char *text)	1704	int find_animation (char *text)
1868	PROTOTYPE: $	1705	PROTOTYPE: $
1869		1706
1870	int random_roll (int min, int max, object *op, int goodbad);	1707	int random_roll (int min, int max, object *op, int goodbad);
…		…
1908	RETVAL = newSVpv (resist_plus[atnr], 0);	1745	RETVAL = newSVpv (resist_plus[atnr], 0);
1909	else	1746	else
1910	XSRETURN_UNDEF;	1747	XSRETURN_UNDEF;
1911	OUTPUT: RETVAL	1748	OUTPUT: RETVAL
1912		1749
		1750	bool
		1751	load_resource_file (const char *filename)
		1752
1913	MODULE = cf PACKAGE = cf::attachable	1753	MODULE = cf PACKAGE = cf::attachable
1914		1754
1915	int	1755	int
1916	valid (SV *obj)	1756	valid (SV *obj)
1917	CODE:	1757	CODE:
1918	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);	1758	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
1919	OUTPUT:	1759	OUTPUT:
1920	RETVAL	1760	RETVAL
		1761
		1762	void
		1763	debug_trace (attachable *obj, bool on = true)
		1764	CODE:
		1765	obj->flags &= ~attachable::F_DEBUG_TRACE;
		1766	if (on)
		1767	obj->flags |= attachable::F_DEBUG_TRACE;
		1768
		1769	int mortals_size ()
		1770	CODE:
		1771	RETVAL = attachable::mortals.size ();
		1772	OUTPUT: RETVAL
		1773
		1774	#object *mortals (U32 index)
		1775	# CODE:
		1776	# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;
		1777	# OUTPUT: RETVAL
		1778
		1779	INCLUDE: $PERL $srcdir/genacc attachable ../include/cfperl.h |
1921		1780
1922	MODULE = cf PACKAGE = cf::global	1781	MODULE = cf PACKAGE = cf::global
1923		1782
1924	int invoke (SV *klass, int event, ...)	1783	int invoke (SV *klass, int event, ...)
1925	CODE:	1784	CODE:
…		…
1929	RETVAL = gbl_ev.invoke ((event_type)event, ARG_AV (av), DT_END);	1788	RETVAL = gbl_ev.invoke ((event_type)event, ARG_AV (av), DT_END);
1930	OUTPUT: RETVAL	1789	OUTPUT: RETVAL
1931		1790
1932	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_	1791	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
1933		1792
1934	INCLUDE: $PERL genacc object ../include/object.h |	1793	INCLUDE: $PERL $srcdir/genacc object ../include/object.h |
1935		1794
1936	int invoke (object *op, int event, ...)	1795	int invoke (object *op, int event, ...)
1937	CODE:	1796	CODE:
1938	if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");	1797	if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");
1939	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	1798	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
1941	RETVAL = op->invoke ((event_type)event, ARG_AV (av), DT_END);	1800	RETVAL = op->invoke ((event_type)event, ARG_AV (av), DT_END);
1942	OUTPUT: RETVAL	1801	OUTPUT: RETVAL
1943		1802
1944	SV *registry (object *op)	1803	SV *registry (object *op)
1945		1804
1946	void mortals ()	1805	int objects_size ()
1947	PPCODE:	1806	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;	1807	RETVAL = objects.size ();
		1808	OUTPUT: RETVAL
		1809
		1810	object *objects (U32 index)
		1811	CODE:
		1812	RETVAL = index < objects.size () ? objects [index] : 0;
		1813	OUTPUT: RETVAL
		1814
		1815	int actives_size ()
		1816	CODE:
		1817	RETVAL = actives.size ();
		1818	OUTPUT: RETVAL
		1819
		1820	object *actives (U32 index)
		1821	CODE:
		1822	RETVAL = index < actives.size () ? actives [index] : 0;
1955	OUTPUT: RETVAL	1823	OUTPUT: RETVAL
1956		1824
1957	# missing properties	1825	# missing properties
1958		1826
1959	object *head (object *op)	1827	object *head (object *op)
1960	PROTOTYPE: $	1828	PROTOTYPE: $
1961	CODE:	1829	CODE:
1962	RETVAL = op->head ? op->head : op;	1830	RETVAL = op->head_ ();
1963	OUTPUT: RETVAL	1831	OUTPUT: RETVAL
1964		1832
1965	int is_head (object *op)	1833	int is_head (object *op)
1966	PROTOTYPE: $	1834	PROTOTYPE: $
1967	CODE:	1835	CODE:
1968	RETVAL = !op->head;	1836	RETVAL = op->head_ () == op;
1969	OUTPUT: RETVAL	1837	OUTPUT: RETVAL
1970		1838
1971	void	1839	void
1972	inv (object *obj)	1840	inv (object *obj)
1973	PROTOTYPE: $	1841	PROTOTYPE: $
…		…
1981	void	1849	void
1982	set_animation (object *op, int idx)	1850	set_animation (object *op, int idx)
1983	CODE:	1851	CODE:
1984	SET_ANIMATION (op, idx);	1852	SET_ANIMATION (op, idx);
1985		1853
1986	void	1854	int
1987	object::drain_stat ()	1855	num_animations (object *op)
1988		1856	CODE:
1989	void	1857	RETVAL = NUM_ANIMATIONS (op);
1990	object::drain_specific_stat (int stat)	1858	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		1859
2001	object *find_best_object_match (object *op, const char *match)	1860	object *find_best_object_match (object *op, const char *match)
2002		1861
2003	object *find_marked_object (object *op)	1862	object *find_marked_object (object *op)
2004		1863
2005	int need_identify (object *obj);	1864	int need_identify (object *obj);
2006		1865
2007	int apply_shop_mat (object *shop_mat, object *op);	1866	int apply_shop_mat (object *shop_mat, object *op);
		1867
		1868	int move_player (object *op, int dir)
		1869	CODE:
		1870	RETVAL = move_player (op, dir);
		1871	OUTPUT:
		1872	RETVAL
2008		1873
2009	int move (object *op, int dir, object *originator = op)	1874	int move (object *op, int dir, object *originator = op)
2010	CODE:	1875	CODE:
2011	RETVAL = move_ob (op, dir, originator);	1876	RETVAL = move_ob (op, dir, originator);
2012	OUTPUT:	1877	OUTPUT:
…		…
2018		1883
2019	void apply_below (object *op)	1884	void apply_below (object *op)
2020	CODE:	1885	CODE:
2021	player_apply_below (op);	1886	player_apply_below (op);
2022		1887
2023	void remove (object *op)	1888	int cast_heal (object *op, object *caster, object *spell, int dir = 0)
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		1889
2033	object *cf_object_present_archname_inside (object *op, char *whatstr)	1890	object *cf_object_present_archname_inside (object *op, char *whatstr)
2034		1891
2035	int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)	1892	int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)
2036		1893
2037	int cf_object_change_map (object *op, int x, int y, maptile *map)	1894	int cf_object_change_map (object *op, int x, int y, maptile *map)
2038		1895
		1896	#//TODO
2039	object *clone (object *op, int recursive = 0)	1897	object *clone_ (object *op, int recursive = 0)
2040	CODE:	1898	CODE:
2041	if (recursive)	1899	if (recursive)
2042	RETVAL = object_create_clone (op);	1900	RETVAL = object_create_clone (op);
2043	else	1901	else
2044	{	1902	{
…		…
2088		1946
2089	void drop (object *who, object *op)	1947	void drop (object *who, object *op)
2090		1948
2091	void pick_up (object *who, object *op)	1949	void pick_up (object *who, object *op)
2092		1950
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)	1951	int cf_object_teleport (object *op, maptile *map, int x, int y)
2098		1952
2099	void update_object (object *op, int action)	1953	void update_object (object *op, int action)
2100		1954
2101	object *cf_create_object_by_name (const char *name)	1955	object *cf_create_object_by_name (const char *name)
…		…
2148		2002
2149	player *contr (object *op)	2003	player *contr (object *op)
2150	CODE:	2004	CODE:
2151	RETVAL = op->contr;	2005	RETVAL = op->contr;
2152	OUTPUT: RETVAL	2006	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		2007
2163	const char *get_ob_key_value (object *op, const char *key)	2008	const char *get_ob_key_value (object *op, const char *key)
2164		2009
2165	bool set_ob_key_value (object *op, const char *key, const char *value = 0, int add_key = 1)	2010	bool set_ob_key_value (object *op, const char *key, const char *value = 0, int add_key = 1)
2166		2011
…		…
2203	RETVAL = op->contr;	2048	RETVAL = op->contr;
2204	OUTPUT: RETVAL	2049	OUTPUT: RETVAL
2205		2050
2206	void check_score (object *op)	2051	void check_score (object *op)
2207		2052
2208	void cf_player_message (object *obj, char *txt, int flags = NDI_ORANGE | NDI_UNIQUE)	2053	void message (object *op, char *txt, int flags = NDI_ORANGE | NDI_UNIQUE)
		2054	CODE:
		2055	new_draw_info (flags, 0, op, txt);
2209		2056
2210	object *cf_player_send_inventory (object *op)	2057	object *cf_player_send_inventory (object *op)
2211		2058
2212	char *cf_player_get_ip (object *op)	2059	char *cf_player_get_ip (object *op)
2213	ALIAS: ip = 0	2060	ALIAS: ip = 0
…		…
2227	void esrv_update_item (object *op, int what, object *item)	2074	void esrv_update_item (object *op, int what, object *item)
2228	C_ARGS: what, op, item	2075	C_ARGS: what, op, item
2229		2076
2230	void clear_los (object *op)	2077	void clear_los (object *op)
2231		2078
2232	int command_reset (object *op, char *params)
2233
2234	int command_teleport (object *op, char *params)
2235
2236	int command_summon (object *op, char *params)	2079	int command_summon (object *op, char *params)
2237		2080
2238	int command_arrest (object *op, char *params)	2081	int command_arrest (object *op, char *params)
2239		2082
2240	int command_kick (object *op, char *params)
2241
2242	int command_banish (object *op, char *params)
2243
2244		2083
2245	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_	2084	MODULE = cf PACKAGE = cf::player PREFIX = cf_player_
2246		2085
2247	INCLUDE: $PERL genacc player ../include/player.h |	2086	INCLUDE: $PERL $srcdir/genacc player ../include/player.h |
2248		2087
2249	int invoke (player *pl, int event, ...)	2088	int invoke (player *pl, int event, ...)
2250	CODE:	2089	CODE:
2251	if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");	2090	if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");
2252	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	2091	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
2254	RETVAL = pl->invoke ((event_type)event, ARG_AV (av), DT_END);	2093	RETVAL = pl->invoke ((event_type)event, ARG_AV (av), DT_END);
2255	OUTPUT: RETVAL	2094	OUTPUT: RETVAL
2256		2095
2257	SV *registry (player *pl)	2096	SV *registry (player *pl)
2258		2097
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	2098	void
2280	save_stats (player *pl)	2099	save_stats (player *pl)
2281	CODE:	2100	CODE:
2282	pl->ob->stats.hp = pl->ob->stats.maxhp;	2101	pl->ob->stats.hp = pl->ob->stats.maxhp;
2283	pl->ob->stats.sp = pl->ob->stats.maxsp;	2102	pl->ob->stats.sp = pl->ob->stats.maxsp;
2284	pl->ob->stats.grace = pl->ob->stats.maxgrace;	2103	pl->ob->stats.grace = pl->ob->stats.maxgrace;
2285	pl->orig_stats = pl->ob->stats;	2104	pl->orig_stats = pl->ob->stats;
2286		2105
2287	player *cf_player_find (char *name)
2288	PROTOTYPE: $
2289
2290	void cf_player_move (player *pl, int dir)	2106	void cf_player_move (player *pl, int dir)
2291		2107
2292	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);	2108	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);
2293
2294	player *first ()
2295	CODE:
2296	RETVAL = first_player;
2297	OUTPUT: RETVAL
2298		2109
2299	bool	2110	bool
2300	cell_visible (player *pl, int dx, int dy)	2111	cell_visible (player *pl, int dx, int dy)
2301	CODE:	2112	CODE:
2302	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2	2113	RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2
…		…
2339	if (y) sv_to (y, pl->bed_y);	2150	if (y) sv_to (y, pl->bed_y);
2340		2151
2341	void	2152	void
2342	list ()	2153	list ()
2343	PPCODE:	2154	PPCODE:
2344	for (player *pl = first_player; pl; pl = pl->next)	2155	for_all_players (pl)
2345	XPUSHs (sv_2mortal (to_sv (pl)));	2156	XPUSHs (sv_2mortal (to_sv (pl)));
2346		2157
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		2158
2370	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_	2159	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_
2371
2372	maptile *first ()
2373	PROTOTYPE:
2374	CODE:
2375	RETVAL = first_map;
2376	OUTPUT: RETVAL
2377		2160
2378	int invoke (maptile *map, int event, ...)	2161	int invoke (maptile *map, int event, ...)
2379	CODE:	2162	CODE:
2380	if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");	2163	if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");
2381	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	2164	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
2383	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);	2166	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);
2384	OUTPUT: RETVAL	2167	OUTPUT: RETVAL
2385		2168
2386	SV *registry (maptile *map)	2169	SV *registry (maptile *map)
2387		2170
2388	INCLUDE: $PERL genacc maptile ../include/map.h |	2171	INCLUDE: $PERL $srcdir/genacc maptile ../include/map.h |
2389		2172
2390	maptile *new (int width, int height)	2173	void
		2174	maptile::instantiate ()
		2175
		2176	maptile *new ()
2391	PROTOTYPE:	2177	PROTOTYPE:
2392	CODE:	2178	CODE:
2393	{	2179	RETVAL = new maptile;
2394	RETVAL = get_empty_map (width, height);
2395	}
2396	OUTPUT:	2180	OUTPUT:
2397	RETVAL	2181	RETVAL
2398		2182
2399	void delete_map (maptile *map)	2183	void
		2184	maptile::players ()
		2185	PPCODE:
		2186	if (GIMME_V == G_SCALAR)
		2187	XPUSHs (sv_2mortal (to_sv (THIS->players)));
		2188	else if (GIMME_V == G_ARRAY)
		2189	{
		2190	EXTEND (SP, THIS->players);
		2191	for_all_players (pl)
		2192	if (pl->ob && pl->ob->map == THIS)
		2193	PUSHs (sv_2mortal (to_sv (pl->ob)));
		2194	}
2400		2195
2401	void clean_tmp_map (maptile *map)	2196	void
		2197	maptile::add_underlay (SV *data, int offset, int stride, SV *palette)
		2198	CODE:
		2199	{
		2200	if (!SvROK (palette) || SvTYPE (SvRV (palette)) != SVt_PVAV)
		2201	croak ("maptile::add_underlay: palette must be arrayref");
		2202
		2203	palette = SvRV (palette);
		2204
		2205	STRLEN idxlen;
		2206	const uint8_t *idx = (const uint8_t *)SvPVbyte (data, idxlen);
		2207
		2208	for (int x = 0; x < THIS->width; ++x)
		2209	for (int y = 0; y < THIS->height; ++y)
		2210	{
		2211	for (object *op = THIS->at (x, y).bot; op; op = op->above)
		2212	if (op->flag [FLAG_IS_FLOOR])
		2213	goto skip_space;
		2214
		2215	{
		2216	int offs = offset + y * stride + x;
		2217	if (IN_RANGE_EXC (offs, 0, idxlen))
		2218	{
		2219	if (SV **elem = av_fetch ((AV *)palette, idx [offs], 0))
		2220	{
		2221	object *ob = get_archetype (SvPVutf8_nolen (*elem));
		2222	ob->flag [FLAG_NO_MAP_SAVE] = true;
		2223	THIS->insert (ob, x, y, 0, INS_ABOVE_FLOOR_ONLY);
		2224	}
		2225	}
		2226	}
		2227
		2228	skip_space: ;
		2229	}
		2230	}
		2231
		2232	void
		2233	maptile::set_regiondata (SV *data, int offset, int stride, SV *palette)
		2234	CODE:
		2235	{
		2236	if (!SvROK (palette) || SvTYPE (SvRV (palette)) != SVt_PVAV)
		2237	croak ("maptile::set_regiondata: palette must be arrayref");
		2238
		2239	palette = SvRV (palette);
		2240
		2241	STRLEN idxlen;
		2242	const uint8_t *idx = (const uint8_t *)SvPVbyte (data, idxlen);
		2243
		2244	region **regionmap = (region **)malloc (
		2245	(av_len ((AV *)palette) + 1) * sizeof (region *));
		2246	uint8_t *regions = salloc<uint8_t> (THIS->size ());
		2247
		2248	for (int i = av_len ((AV *)palette) + 1; i--; )
		2249	regionmap [i] = region::find (
		2250	SvPVutf8_nolen (*av_fetch ((AV *)palette, i, 1)));
		2251
		2252	for (int y = 0; y < THIS->height; ++y)
		2253	memcpy (regions + y * THIS->width, idx + offset + y * stride, THIS->width);
		2254
		2255	sfree (THIS->regions, THIS->size ());
		2256	free (THIS->regionmap);
		2257
		2258	THIS->regions = regions;
		2259	THIS->regionmap = regionmap;
		2260	}
2402		2261
2403	void play_sound_map (maptile *map, int x, int y, int sound_num)	2262	void play_sound_map (maptile *map, int x, int y, int sound_num)
2404		2263
2405	int out_of_map (maptile *map, int x, int y)	2264	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		2265
2436	void	2266	void
2437	trigger (maptile *map, long connection, bool state = true)	2267	trigger (maptile *map, long connection, bool state = true)
2438	CODE:	2268	CODE:
2439	activate_connection (map, connection, state);	2269	activate_connection (map, connection, state);
…		…
2452		2282
2453	object* cf_map_present_arch_by_name (maptile *map, const char* str, int nx, int ny)	2283	object* cf_map_present_arch_by_name (maptile *map, const char* str, int nx, int ny)
2454	C_ARGS: str, map, nx, ny	2284	C_ARGS: str, map, nx, ny
2455		2285
2456	void	2286	void
2457	cf_map_normalise (maptile *map, int x, int y)	2287	get_map_flags (maptile *map, int x, int y)
2458	PPCODE:	2288	PPCODE:
2459	{	2289	{
2460	maptile *nmap = 0;	2290	maptile *nmap = 0;
2461	I16 nx = 0, ny = 0;	2291	I16 nx = 0, ny = 0;
2462	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);	2292	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
…		…
2498	move_block_at = 4	2328	move_block_at = 4
2499	move_slow_at = 5	2329	move_slow_at = 5
2500	move_on_at = 6	2330	move_on_at = 6
2501	move_off_at = 7	2331	move_off_at = 7
2502	INIT:	2332	INIT:
2503	if (x >= MAP_WIDTH (obj) || y >= MAP_HEIGHT (obj)) XSRETURN_UNDEF;	2333	if (x >= obj->width || y >= obj->height) XSRETURN_UNDEF;
2504	CODE:	2334	CODE:
2505	switch (ix)	2335	switch (ix)
2506	{	2336	{
2507	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;	2337	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;	2338	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;	2341	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;	2342	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;	2343	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;	2344	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;
2515	}	2345	}
2516	OUTPUT:	2346	OUTPUT: RETVAL
		2347
		2348	void fix_walls (maptile *map, int x, int y)
		2349
		2350	void fix_walls_around (maptile *map, int x, int y)
		2351
		2352	# worst xs function of my life
		2353	bool
		2354	_create_random_map (\
		2355	maptile *self,\
		2356	char *wallstyle,\
		2357	char *wall_name,\
		2358	char *floorstyle,\
		2359	char *monsterstyle,\
		2360	char *treasurestyle,\
		2361	char *layoutstyle,\
		2362	char *doorstyle,\
		2363	char *decorstyle,\
		2364	char *origin_map,\
		2365	char *final_map,\
		2366	char *exitstyle,\
		2367	char *this_map,\
		2368	char *exit_on_final_map,\
		2369	int xsize,\
		2370	int ysize,\
		2371	int expand2x,\
		2372	int layoutoptions1,\
		2373	int layoutoptions2,\
		2374	int layoutoptions3,\
		2375	int symmetry,\
		2376	int difficulty,\
		2377	int difficulty_given,\
		2378	float difficulty_increase,\
		2379	int dungeon_level,\
		2380	int dungeon_depth,\
		2381	int decoroptions,\
		2382	int orientation,\
		2383	int origin_y,\
		2384	int origin_x,\
		2385	U32 random_seed,\
		2386	val64 total_map_hp,\
		2387	int map_layout_style,\
		2388	int treasureoptions,\
		2389	int symmetry_used,\
		2390	region *region,\
		2391	char *custom\
		2392	)
		2393	CODE:
		2394	{
		2395	random_map_params rmp;
		2396
		2397	assign (rmp.wallstyle , wallstyle);
		2398	assign (rmp.wall_name , wall_name);
		2399	assign (rmp.floorstyle , floorstyle);
		2400	assign (rmp.monsterstyle , monsterstyle);
		2401	assign (rmp.treasurestyle , treasurestyle);
		2402	assign (rmp.layoutstyle , layoutstyle);
		2403	assign (rmp.doorstyle , doorstyle);
		2404	assign (rmp.decorstyle , decorstyle);
		2405	assign (rmp.exitstyle , exitstyle);
		2406	assign (rmp.exit_on_final_map, exit_on_final_map);
		2407
		2408	rmp.origin_map = origin_map;
		2409	rmp.final_map = final_map;
		2410	rmp.this_map = this_map;
		2411	rmp.xsize = xsize;
		2412	rmp.ysize = ysize;
		2413	rmp.expand2x = expand2x;
		2414	rmp.layoutoptions1 = layoutoptions1;
		2415	rmp.layoutoptions2 = layoutoptions2;
		2416	rmp.layoutoptions3 = layoutoptions3;
		2417	rmp.symmetry = symmetry;
		2418	rmp.difficulty = difficulty;
		2419	rmp.difficulty_given = difficulty_given;
		2420	rmp.difficulty_increase = difficulty_increase;
		2421	rmp.dungeon_level = dungeon_level;
		2422	rmp.dungeon_depth = dungeon_depth;
		2423	rmp.decoroptions = decoroptions;
		2424	rmp.orientation = orientation;
		2425	rmp.origin_y = origin_y;
		2426	rmp.origin_x = origin_x;
		2427	rmp.random_seed = random_seed;
		2428	rmp.total_map_hp = total_map_hp;
		2429	rmp.map_layout_style = map_layout_style;
		2430	rmp.treasureoptions = treasureoptions;
		2431	rmp.symmetry_used = symmetry_used;
		2432	rmp.region = region;
		2433	rmp.custom = custom;
		2434
		2435	RETVAL = self->generate_random_map (&rmp);
		2436	}
		2437	OUTPUT:
2517	RETVAL	2438	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		2439
2523	MODULE = cf PACKAGE = cf::arch	2440	MODULE = cf PACKAGE = cf::arch
2524		2441
2525	archetype *find (const char *name)	2442	archetype *find (const char *name)
2526	CODE:	2443	CODE:
…		…
2532	PROTOTYPE:	2449	PROTOTYPE:
2533	CODE:	2450	CODE:
2534	RETVAL = first_archetype;	2451	RETVAL = first_archetype;
2535	OUTPUT: RETVAL	2452	OUTPUT: RETVAL
2536		2453
2537	INCLUDE: $PERL genacc archetype ../include/object.h |	2454	INCLUDE: $PERL $srcdir/genacc archetype ../include/object.h |
2538		2455
2539	MODULE = cf PACKAGE = cf::party	2456	MODULE = cf PACKAGE = cf::party
2540		2457
2541	partylist *first ()	2458	partylist *first ()
2542	PROTOTYPE:	2459	PROTOTYPE:
2543	CODE:	2460	CODE:
2544	RETVAL = get_firstparty ();	2461	RETVAL = get_firstparty ();
2545	OUTPUT: RETVAL	2462	OUTPUT: RETVAL
2546		2463
2547	partylist *next (partylist *party)	2464	INCLUDE: $PERL $srcdir/genacc partylist ../include/player.h |
		2465
		2466	MODULE = cf PACKAGE = cf::region
		2467
		2468	void
		2469	list ()
		2470	PPCODE:
		2471	for_all_regions (rgn)
		2472	XPUSHs (sv_2mortal (to_sv (rgn)));
		2473
		2474	region *find (char *name)
		2475	PROTOTYPE: $
2548	CODE:	2476	CODE:
2549	RETVAL = party->next;	2477	RETVAL = region::find (name);
2550	OUTPUT: RETVAL	2478	OUTPUT: RETVAL
2551		2479
2552	const char *name (partylist *party)	2480	region *find_fuzzy (char *name)
		2481	PROTOTYPE: $
2553	CODE:	2482	CODE:
2554	RETVAL = party->partyname;	2483	RETVAL = region::find_fuzzy (name);
2555	OUTPUT: RETVAL	2484	OUTPUT: RETVAL
2556		2485
2557	const char *password (partylist *party)	2486	INCLUDE: $PERL $srcdir/genacc region ../include/map.h |
2558	CODE:
2559	RETVAL = party->passwd;
2560	OUTPUT: RETVAL
2561
2562	MODULE = cf PACKAGE = cf::region
2563
2564	region *first ()
2565	PROTOTYPE:
2566	CODE:
2567	RETVAL = first_region;
2568	OUTPUT: RETVAL
2569
2570	region *next (region *reg)
2571	CODE:
2572	RETVAL = reg->next;
2573	OUTPUT: RETVAL
2574
2575	const char *name (region *reg)
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		2487
2595	MODULE = cf PACKAGE = cf::living	2488	MODULE = cf PACKAGE = cf::living
2596		2489
2597	INCLUDE: $PERL genacc living ../include/living.h |	2490	INCLUDE: $PERL $srcdir/genacc living ../include/living.h |
2598		2491
2599	MODULE = cf PACKAGE = cf::settings	2492	MODULE = cf PACKAGE = cf::settings
2600		2493
2601	INCLUDE: $PERL genacc Settings ../include/global.h |	2494	INCLUDE: $PERL $srcdir/genacc Settings ../include/global.h |
2602		2495
2603	MODULE = cf PACKAGE = cf::client	2496	MODULE = cf PACKAGE = cf::client
2604		2497
2605	INCLUDE: $PERL genacc client ../include/client.h |	2498	INCLUDE: $PERL $srcdir/genacc client ../include/client.h |
2606		2499
2607	int invoke (client *ns, int event, ...)	2500	int invoke (client *ns, int event, ...)
2608	CODE:	2501	CODE:
2609	if (KLASS_OF (event) != KLASS_CLIENT) croak ("event class must be CLIENT");	2502	if (KLASS_OF (event) != KLASS_CLIENT) croak ("event class must be CLIENT");
2610	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	2503	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
…		…
2619	PPCODE:	2512	PPCODE:
2620	EXTEND (SP, clients.size ());	2513	EXTEND (SP, clients.size ());
2621	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)	2514	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
2622	PUSHs (sv_2mortal (to_sv (*i)));	2515	PUSHs (sv_2mortal (to_sv (*i)));
2623		2516
2624	client *
2625	create (int fd, const char *peername)
2626	CODE:
2627	RETVAL = client::create (fd, peername);
2628	OUTPUT:
2629	RETVAL
2630
2631	void	2517	void
2632	client::send_packet (SV *packet)	2518	client::send_packet (SV *packet)
2633	CODE:	2519	CODE:
2634	{	2520	{
2635	STRLEN len;	2521	STRLEN len;
2636	char *buf = SvPVbyte (packet, len);	2522	char *buf = SvPVbyte (packet, len);
2637		2523
2638	THIS->send_packet (buf, len);	2524	THIS->send_packet (buf, len);
2639	}	2525	}
2640		2526
2641	void	2527	MODULE = cf PACKAGE = cf::face PREFIX = face_
2642	client::destroy ()
2643		2528
		2529	INCLUDE: $PERL $srcdir/genacc faceset ../include/face.h |
		2530
		2531	faceidx face_find (const char *name, faceidx defidx = 0)
		2532
		2533	faceidx alloc (const char *name)
		2534	CODE:
		2535	{
		2536	do
		2537	{
		2538	RETVAL = faces.size ();
		2539	faces.resize (RETVAL + 1);
		2540	}
		2541	while (!RETVAL); // crude way to leave index 0
		2542
		2543	faces [RETVAL].name = name;
		2544	facehash.insert (std::make_pair (faces [RETVAL].name, RETVAL));
		2545
		2546	if (!strcmp (name, BLANK_FACE_NAME)) blank_face = RETVAL;
		2547	if (!strcmp (name, EMPTY_FACE_NAME)) empty_face = RETVAL;
		2548	}
		2549	OUTPUT: RETVAL
		2550
		2551	void set (faceidx idx, int visibility, int magicmap)
		2552	CODE:
		2553	faceinfo *f = face_info (idx);
		2554	assert (f);
		2555	f->visibility = visibility;
		2556	f->magicmap = magicmap;
		2557
		2558	void set_smooth (faceidx idx, faceidx smooth)
		2559	CODE:
		2560	faceinfo *f = face_info (idx);
		2561	assert (f);
		2562	f->smooth = smooth;
		2563
		2564	void set_data (faceidx idx, int faceset, SV *data, SV *chksum)
		2565	CODE:
		2566	facedata *d = face_data (idx, faceset);
		2567	assert (d);
		2568	sv_to (data, d->data);
		2569	STRLEN clen;
		2570	char *cdata = SvPVbyte (chksum, clen);
		2571	memcpy (d->chksum, cdata, min (CHKSUM_SIZE, clen));
		2572
		2573	void invalidate (faceidx idx)
		2574	CODE:
		2575	for_all_clients (ns)
		2576	ns->faces_sent [idx] = false;
		2577
		2578	void invalidate_all ()
		2579	CODE:
		2580	for_all_clients (ns)
		2581	ns->faces_sent.reset ();
		2582

Diff Legend

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