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.106 by root, Sat Dec 23 15:49:40 2006 UTC vs.
Revision 1.157 by root, Sun Jan 28 00:20: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
		46	#include "CoroAPI.h"
41	#include "perlxsi.c"	47	#include "perlxsi.c"
42		48
43	extern sint64 *levels; // the experience table	49	extern sint64 *levels; // the experience table
44		50
45	typedef object object_ornull;	51	typedef object object_ornull;
…		…
59	static f_plug_api object_set_property = cfapi_object_set_property;	65	static f_plug_api object_set_property = cfapi_object_set_property;
60	static f_plug_api object_insert = cfapi_object_insert;	66	static f_plug_api object_insert = cfapi_object_insert;
61		67
62	static PerlInterpreter *perl;	68	static PerlInterpreter *perl;
63		69
		70	double runtime;
		71
		72	global gbl_ev;
64	static AV *cb_global, *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;
		75
		76	static HV
		77	*stash_cf,
		78	*stash_cf_object_wrap,
		79	*stash_cf_object_player_wrap,
		80	*stash_cf_player_wrap,
		81	*stash_cf_map_wrap,
		82	*stash_cf_client_wrap,
		83	*stash_cf_arch_wrap,
		84	*stash_cf_party_wrap,
		85	*stash_cf_region_wrap,
		86	*stash_cf_living_wrap;
		87
		88	// helper cast function, returns super class * or 0
		89	template<class super>
		90	static super *
		91	is_a (attachable *at)
		92	{
		93	//return dynamic_cast<super *>(at); // slower, safer
		94	if (typeid (*at) == typeid (super))
		95	return static_cast<super *>(at);
		96	else
		97	return 0;
		98	}
65		99
66	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	100	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
67		101
		102	unordered_vector<attachable *> attachable::mortals;
		103
		104	attachable::~attachable ()
		105	{
		106	assert (!self);
		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 ();
		141	}
		142
		143	// check wether the object really is dead
		144	void
		145	attachable::do_check ()
		146	{
		147	if (refcnt_cnt () > 0)
		148	return;
		149
		150	destroy ();
		151	}
		152
		153	void
		154	attachable::do_destroy ()
		155	{
		156	invoke (EVENT_ATTACHABLE_DESTROY, DT_END);
		157
		158	if (cb)
		159	{
		160	SvREFCNT_dec (cb);
		161	cb = 0;
		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
68	static SV *	230	static SV *
69	newSVptr (void *ptr, const char *klass, HV *hv = newHV ())	231	newSVptr (void *ptr, HV *stash, HV *hv = newHV ())
70	{	232	{
71	SV *sv;	233	SV *sv;
72		234
73	if (!ptr)	235	if (!ptr)
74	return &PL_sv_undef;	236	return &PL_sv_undef;
75		237
76	sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0);	238	sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);
77	return sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));	239	return sv_bless (newRV_noinc ((SV *)hv), stash);
78	}	240	}
79		241
80	template<class attachable>	242	static int
81	SV *	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;
		251	SvREFCNT_dec (self);
		252	}
		253
		254	// next line makes sense, but most objects still have refcnt 0 by default
		255	//at->refcnt_chk ();
		256	return 0;
		257	}
		258
		259	MGVTBL attachable::vtbl = {0, 0, 0, 0, attachable_free};
		260
		261	static SV *
82	newSVattachable (attachable *obj, const char *klass)	262	newSVattachable (attachable *obj, HV *stash)
83	{	263	{
84	if (!obj)	264	if (!obj)
85	return &PL_sv_undef;	265	return &PL_sv_undef;
86		266
87	if (!obj->self)	267	if (!obj->self)
88	obj->self = newSVptr (obj, klass);	268	{
		269	obj->self = newHV ();
		270	sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char *)obj, 0);
89		271
90	return newSVsv (obj->self);	272	// now bless the object _once_
		273	return sv_bless (newRV_inc ((SV *)obj->self), stash);
		274	}
		275	else
		276	{
		277	SV *sv = newRV_inc ((SV *)obj->self);
		278
		279	if (Gv_AMG (stash)) // handle overload correctly, as the perl core does not
		280	SvAMAGIC_on (sv);
		281
		282	return sv;
		283	}
91	}	284	}
92		285
93	static void	286	static void
94	clearSVptr (SV *sv)	287	clearSVptr (SV *sv)
95	{	288	{
…		…
136	inline SV *to_sv (unsigned long v) { return newSVuv (v); }	329	inline SV *to_sv (unsigned long v) { return newSVuv (v); }
137	inline SV *to_sv ( signed long long v) { return newSVval64 (v); }	330	inline SV *to_sv ( signed long long v) { return newSVval64 (v); }
138	inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }	331	inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }
139	inline SV *to_sv (float v) { return newSVnv (v); }	332	inline SV *to_sv (float v) { return newSVnv (v); }
140	inline SV *to_sv (double v) { return newSVnv (v); }	333	inline SV *to_sv (double v) { return newSVnv (v); }
141	inline SV *to_sv (client * v) { return newSVattachable (v, "cf::client::wrap"); }	334	inline SV *to_sv (client * v) { return newSVattachable (v, stash_cf_client_wrap); }
142	inline SV *to_sv (player * v) { return newSVattachable (v, "cf::player::wrap"); }	335	inline SV *to_sv (player * v) { return newSVattachable (v, stash_cf_player_wrap); }
143	inline SV *to_sv (object * v) { return newSVattachable (v, v && v->type == PLAYER ? "cf::object::player::wrap" : "cf::object::wrap"); }	336	inline SV *to_sv (object * v) { return newSVattachable (v, v && v->type == PLAYER ? stash_cf_object_player_wrap : stash_cf_object_wrap); }
144	inline SV *to_sv (maptile * v) { return newSVattachable (v, "cf::map::wrap"); }	337	inline SV *to_sv (maptile * v) { return newSVattachable (v, stash_cf_map_wrap); }
145	inline SV *to_sv (archetype * v) { return newSVptr (v, "cf::arch::wrap"); }	338	inline SV *to_sv (archetype * v) { return newSVattachable (v, stash_cf_arch_wrap); }
146	inline SV *to_sv (partylist * v) { return newSVptr (v, "cf::party::wrap"); }	339	inline SV *to_sv (partylist * v) { return newSVptr (v, stash_cf_party_wrap); }
147	inline SV *to_sv (region * v) { return newSVptr (v, "cf::region::wrap"); }	340	inline SV *to_sv (region * v) { return newSVptr (v, stash_cf_region_wrap); }
148	inline SV *to_sv (living * v) { return newSVptr (v, "cf::living::wrap"); }	341	inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }
149		342
150	inline SV *to_sv (object & v) { return to_sv (&v); }	343	inline SV *to_sv (object & v) { return to_sv (&v); }
151	inline SV *to_sv (living & v) { return to_sv (&v); }	344	inline SV *to_sv (living & v) { return to_sv (&v); }
152		345
153	//TODO:
154	inline SV *to_sv (New_Face * v) { return to_sv (v->name); }	346	inline SV *to_sv (facetile * v) { return to_sv (v->name); }
155	inline SV *to_sv (treasurelist * v) { return to_sv (v->name); }	347	inline SV *to_sv (treasurelist * v) { return to_sv (v->name); }
156		348
157	inline SV *to_sv (UUID v)	349	inline SV *to_sv (UUID v)
158	{	350	{
159	char buf[128];	351	char buf[128];
…		…
174	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); }
175	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); }
176	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); }
177	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }	369	inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
178	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }	370	inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }
179	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"); }
180	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"); }
181	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"); }
182	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"); }
183	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"); }
184	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"); }
185	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"); }
186	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"); }
187		380
188	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)]; }
189	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)); }
190		383
191	template<class T>	384	template<class T>
192	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; }
193		386
194	template<int N>	387	template<int N>
…		…
206		399
207	if (2 != sscanf (SvPV_nolen (sv), "<%d.%" SCNx64 ">", &version, &v.seq) || 1 != version)	400	if (2 != sscanf (SvPV_nolen (sv), "<%d.%" SCNx64 ">", &version, &v.seq) || 1 != version)
208	croak ("unparsable uuid: %s", SvPV_nolen (sv));	401	croak ("unparsable uuid: %s", SvPV_nolen (sv));
209	}	402	}
210		403
211	inline void sv_to (SV *sv, object::flags_t::reference v) { v = boolSV (sv); }	404	inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }
212		405
213	static SV *	406	static SV *
214	newSVdt_va (va_list &ap, data_type type)	407	newSVdt_va (va_list &ap, data_type type)
215	{	408	{
216	SV *sv;	409	SV *sv;
…		…
323	}	516	}
324		517
325	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	518	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
326		519
327	SV *	520	SV *
328	registry (attachable_base *ext)	521	registry (attachable *ext)
329	{	522	{
330	if (!ext->cb)	523	if (!ext->cb)
331	ext->cb = newAV ();	524	ext->cb = newAV ();
332		525
333	return newRV_inc ((SV *)ext->cb);	526	return newRV_inc ((SV *)ext->cb);
334	}
335
336	void attachable_base::clear ()
337	{
338	if (self)
339	{
340	if (cb)
341	if (SvROK (*av_fetch (cb, EVENT_OBJECT_DESTROY, 1)))
342	INVOKE_OBJECT (DESTROY, static_cast<object *>(this));
343	else if (SvROK (*av_fetch (cb, EVENT_MAP_DESTROY, 1)))
344	INVOKE_MAP (DESTROY, static_cast<maptile *>(this));
345
346	// disconnect Perl from C, to avoid crashes
347	sv_unmagic (SvRV ((SV *)self), PERL_MAGIC_ext);
348
349	// clear the perl hash, might or might not be a good idea
350	hv_clear ((HV *)SvRV ((SV *)self));
351
352	SvREFCNT_dec (self);
353	self = 0;
354	}
355
356	if (cb)
357	{
358	SvREFCNT_dec (cb);
359	cb = 0;
360	}
361
362	attach = 0;
363	}
364
365	void attachable_base::optimise ()
366	{
367	if (!self)
368	return;
369
370	HV *hv = (HV *)SvRV ((SV *)self);
371
372	if (SvREFCNT ((SV *)self) == 1
373	&& SvREFCNT ((SV *)hv) == 1
374	&& !HvTOTALKEYS (hv))
375	{
376	SvREFCNT_dec ((SV *)self);
377	self = 0;
378	}
379	}
380
381	void attachable_base::instantiate (data_type type, void *obj)
382	{
383	dSP;
384	ENTER;
385	SAVETMPS;
386	PUSHMARK (SP);
387	EXTEND (SP, 2);
388	PUSHs (sv_2mortal (newSVdt (type, obj)));
389	PUSHs (sv_2mortal (newSVpv (attach, 0)));
390
391	attach = 0;
392
393	PUTBACK;
394	call_pv ("cf::instantiate", G_DISCARD | G_VOID | G_EVAL);
395	FREETMPS;
396	LEAVE;
397
398	switch (type)
399	{
400	case DT_OBJECT: INVOKE_OBJECT (INSTANTIATE, obj); break;
401	case DT_MAP: INVOKE_MAP (INSTANTIATE, obj); break;
402	}
403	}
404
405	/////////////////////////////////////////////////////////////////////////////
406
407	void reattach (data_type type, void *obj)
408	{
409	//TODO only do this when the object has _attachment's
410
411	dSP;
412	ENTER;
413	SAVETMPS;
414	PUSHMARK (SP);
415	XPUSHs (sv_2mortal (newSVdt (type, obj)));
416	PUTBACK;
417	call_pv ("cf::reattach", G_DISCARD | G_VOID | G_EVAL);
418	FREETMPS;
419	LEAVE;
420
421	switch (type)
422	{
423	case DT_OBJECT: INVOKE_OBJECT (REATTACH, obj); break;
424	case DT_PLAYER: INVOKE_PLAYER (REATTACH, obj); break;
425	case DT_CLIENT: INVOKE_CLIENT (REATTACH, obj); break;
426	case DT_MAP: INVOKE_MAP (REATTACH, obj); break;
427	}
428	}
429
430	template<class subclass>
431	void reattach (attachable<subclass> *obj)
432	{
433	obj->optimise ();
434
435	if (obj->self)
436	reattach ((data_type) cftype<subclass>::dt, (subclass *)obj);
437	}
438
439	#include "kw_hash.h"
440
441	object_freezer::object_freezer ()
442	: dynbuf (128 * 1024, 64 * 1024)
443	{
444	av = newAV ();
445	}
446
447	object_freezer::~object_freezer ()
448	{
449	SvREFCNT_dec (av);
450	}
451
452	void object_freezer::put (attachable_base *ext)
453	{
454	ext->optimise ();
455
456	if (ext->self)
457	{
458	int idx = AvFILLp ((AV *)av) + 1;
459	av_store (av, idx, SvREFCNT_inc (ext->self));
460
461	add ((void *)"oid ", 4);
462	add ((sint32)idx);
463	add ('\n');
464	}
465	}
466
467	bool object_freezer::save (const char *filename)
468	{
469	dSP;
470	ENTER;
471	SAVETMPS;
472	PUSHMARK (SP);
473	EXTEND (SP, 3);
474	PUSHs (sv_2mortal (newSVpv (filename, 0)));
475	PUSHs (sv_2mortal (newRV_noinc (newSVpvn ((char *)linearise (), size ()))));
476	PUSHs (sv_2mortal (newRV_inc ((SV *)av)));
477	PUTBACK;
478	call_pv ("cf::object_freezer_save", G_VOID | G_DISCARD | G_EVAL);
479	FREETMPS;
480	LEAVE;
481	}
482
483	char *object_freezer::as_string ()
484	{
485	dSP;
486	ENTER;
487	SAVETMPS;
488	PUSHMARK (SP);
489	EXTEND (SP, 3);
490	PUSHs (sv_2mortal (newRV_noinc (newSVpvn ((char *)linearise (), size ()))));
491	PUSHs (sv_2mortal (newRV_inc ((SV *)av)));
492	PUTBACK;
493
494	char *res = call_pv ("cf::object_freezer_as_string", G_SCALAR | G_EVAL) > 0
495	? strdup (SvPVbyte_nolen (POPs))
496	: strdup ("[fatal error]");
497
498	FREETMPS;
499	LEAVE;
500
501	return res;
502	}
503
504	int fprintf (object_freezer &freezer, const char *format, ...)
505	{
506	va_list ap;
507
508	va_start (ap, format);
509
510	int len = vsnprintf ((char *)freezer.force (1024), 1024, format, ap);
511
512	if (len >= 0)
513	freezer.alloc (len);
514
515	va_end (ap);
516	}
517
518	int fputs (const char *s, object_freezer &freezer)
519	{
520	freezer.add (s);
521	}
522
523	static const char thawer_eof[] = "\n\n\n\0\0\0";
524
525	object_thawer::object_thawer (const char *filename)
526	{
527	static const char eof[] = "\n\n\n\0\0\0";
528
529	av = 0;
530	text = 0;
531	line = 0;
532
533	if (filename)
534	{
535	dSP;
536	ENTER;
537	SAVETMPS;
538	PUSHMARK (SP);
539	XPUSHs (sv_2mortal (newSVpv (filename, 0)));
540	PUTBACK;
541
542	if (2 == call_pv ("cf::object_thawer_load", G_ARRAY | G_EVAL))
543	{
544	SPAGAIN;
545
546	// second value - perl objects
547	{
548	SV *sv = POPs;
549	if (SvROK (sv))
550	av = (AV *)SvREFCNT_inc (SvRV (sv));
551	}
552
553	// first value - text part, pad with 3 zeroes
554	{
555	SV *sv = POPs;
556	STRLEN len;
557	char *sv_ = SvPVbyte (sv, len);
558	text = newSV (len + sizeof (eof));
559	SvCUR_set (text, len);
560	memcpy (SvPVX (text), sv_, len);
561	memcpy (SvEND (text), eof, sizeof (eof)); // just to be sure
562
563	line = SvPVX (text);
564	}
565	}
566
567	PUTBACK;
568	FREETMPS;
569	LEAVE;
570	}
571	}
572
573	object_thawer::object_thawer (const char *data, AV *perlav)
574	{
575	av = perlav;
576	text = newSVpv (data, 0);
577	sv_catpv (text, thawer_eof);
578	line = SvPVbyte_nolen (text);
579	}
580
581	void object_thawer::get (data_type type, void *obj, attachable_base *ext, int oid)
582	{
583	if (!av || oid < 0) // this is actually an error of sorts
584	return;
585
586	// we have to "re-instantiate"/reattach to an object, so nuke ext->attach
587	ext->clear ();
588
589	SV **svp = av_fetch ((AV *)av, oid, 0);
590
591	if (!svp || !SvROK (*svp))
592	{
593	printf ("trying to thaw duplicate or never-issued oid %d, ignoring.\n", oid);
594	return;
595	}
596
597	ext->self = *svp; *svp = &PL_sv_undef;
598	sv_magic (SvRV (ext->self), 0, PERL_MAGIC_ext, (char *)obj, 0);
599
600	reattach (type, obj);
601	}
602
603	object_thawer::~object_thawer ()
604	{
605	if (text) SvREFCNT_dec (text);
606	if (av) SvREFCNT_dec (av);
607	}
608
609	char *fgets (char *s, int n, object_thawer &thawer)
610	{
611	char *p = thawer.line;
612	char *q = s;
613
614	if (!p)
615	return 0;
616
617	while (--n)
618	{
619	if (!*p)
620	break;
621
622	*q++ = *p;
623
624	if (*p++ == '\n')
625	break;
626	}
627
628	*q = 0;
629	thawer.line = p;
630
631	return s == q ? 0 : s;
632	}
633
634	keyword object_thawer::get_kv ()
635	{
636	if (!line)
637	return KW_EOF;
638
639	for (;;)
640	{
641	char *p = line;
642
643	if (!*p)
644	return KW_EOF;
645
646	// parse keyword
647	while (*p > ' ')
648	p++;
649
650	int klen = p - line;
651
652	if (*p++ != '\n')
653	{
654	// parse value
655	while (*(unsigned char *)p <= ' ' && *p != '\n') // skip 0x01 .. 0x20
656	++p;
657
658	last_value = p;
659
660	while (*p != '\n')
661	p++;
662
663	*p++ = 0;
664	}
665	else
666	last_value = 0;
667
668	line [klen] = 0;
669	keyword_idx *kw = kw_lex::match (line, klen);
670
671	//printf ("KV %d<%s,%s>\n", kw ? kw->index : 0, line, last_value);//D
672
673	if (kw)
674	{
675	line = p;
676	return kw->index;
677	}
678	else if (!*line || *line == '#')
679	{
680	// empty/comment line
681	line = p;
682	}
683	else
684	return KW_ERROR;
685	}
686	}
687
688	void object_thawer::get (shstr &sh) const
689	{
690	if (last_value)
691	sh = last_value;
692	else
693	{
694	sh = "<value missing>";
695	LOG (llevError, "keyword requires value: <%s>\n", line);//TODO: add filename
696	}
697	}
698
699	void object_thawer::get_ml (keyword kend, shstr &sh)
700	{
701	char kw[128];
702
703	int klen = keyword_len [kend];
704
705	kw [0] = '\n';
706	memcpy (kw + 1, keyword_str [kend], klen);
707	kw [klen + 1] = '\n';
708	kw [klen + 2] = 0;
709
710	// first test for completely empty msg... "endXXX\n"
711	if (!strncmp (line, kw + 1, klen + 1))
712	{
713	sh = 0;
714
715	line += klen + 1;
716
717	return;
718	}
719	else
720	{
721	// multi-line strings are delimited by "\nendXXX\n" or "endXXX\n" (NULL)
722
723	char *end = strstr (line, kw);
724
725	if (!end)
726	{
727	sh = 0;
728	return;
729	}
730
731	*end = 0;
732	sh = line;
733
734	line = end + keyword_len [kend] + 1;
735
736	while (*line++ != '\n')
737	;
738	}
739	}
740
741	sint32 object_thawer::get_sint32 () const
742	{
743	char *p = last_value;
744
745	if (!p)
746	return 0;
747
748	sint32 val = 0;
749	bool negate;
750
751	if (*p == '-')
752	{
753	negate = true;
754	++p;
755	}
756	else
757	negate = false;
758
759	do
760	{
761	val *= 10;
762	val += *p++ - '0';
763	}
764	while (*p);
765
766	return negate ? -val : val;
767	}
768
769	sint64 object_thawer::get_sint64 () const
770	{
771	return last_value ? atoll (last_value) : 0;
772	}
773
774	double object_thawer::get_double () const
775	{
776	return last_value ? atof (last_value) : 0;
777	}	527	}
778		528
779	/////////////////////////////////////////////////////////////////////////////	529	/////////////////////////////////////////////////////////////////////////////
780		530
781	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)
…		…
843	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;	593	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
844		594
845	char *argv[] = {	595	char *argv[] = {
846	"",	596	"",
847	"-e"	597	"-e"
848	"use Event;" // required for bootstrap	598	"use Event; use Coro;" // required for bootstrap
849	"cf->bootstrap;" // required for datadir :*>	599	"cf->bootstrap;" // required for datadir :*>
850	"unshift @INC, cf::datadir ();"	600	"unshift @INC, cf::datadir ();"
851	"require cf;"	601	"require cf;"
852	};	602	};
853		603
854	if (perl_parse (perl, xs_init, 2, argv, (char **)NULL) || perl_run (perl))	604	if (perl_parse (perl, xs_init, 2, argv, (char **)NULL) || perl_run (perl))
…		…
863	dSP;	613	dSP;
864		614
865	PUSHMARK (SP);	615	PUSHMARK (SP);
866	PUTBACK;	616	PUTBACK;
867	call_pv ("cf::main", G_DISCARD | G_VOID);	617	call_pv ("cf::main", G_DISCARD | G_VOID);
		618	}
		619
		620	void
		621	attachable::instantiate ()
		622	{
		623	if (attach)
		624	{
		625	invoke (EVENT_ATTACHABLE_INSTANTIATE, ARG_STRING (attach), DT_END);
		626	attach = 0;
		627	}
		628	}
		629
		630	void
		631	attachable::reattach ()
		632	{
		633	optimise ();
		634	//TODO: check for _attachment's, very important for restarts
		635	invoke (EVENT_ATTACHABLE_REATTACH, DT_END);
868	}	636	}
869		637
870	static event_klass klass_of[NUM_EVENT_TYPES] = {	638	static event_klass klass_of[NUM_EVENT_TYPES] = {
871	# define def(type,name) KLASS_ ## type,	639	# define def(type,name) KLASS_ ## type,
872	# include "eventinc.h"	640	# include "eventinc.h"
…		…
903	}	671	}
904	}	672	}
905	}	673	}
906	}	674	}
907		675
		676	void
		677	attachable::gather_callbacks (AV *&callbacks, event_type event) const
		678	{
		679	::gather_callbacks (callbacks, cb_attachable, event);
		680
		681	if (cb)
		682	::gather_callbacks (callbacks, cb, event);
		683	}
		684
		685	void
		686	global::gather_callbacks (AV *&callbacks, event_type event) const
		687	{
		688	::gather_callbacks (callbacks, cb_object, event);
		689	}
		690
		691	void
		692	object::gather_callbacks (AV *&callbacks, event_type event) const
		693	{
		694	if (subtype && type + subtype * NUM_SUBTYPES <= AvFILLp (cb_type))
		695	{
		696	SV *registry = AvARRAY (cb_type)[type + subtype * NUM_SUBTYPES];
		697
		698	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
		699	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);
		700	}
		701
		702	if (type <= AvFILLp (cb_type))
		703	{
		704	SV *registry = AvARRAY (cb_type)[type];
		705
		706	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
		707	::gather_callbacks (callbacks, (AV *)SvRV (registry), event);
		708	}
		709
		710	attachable::gather_callbacks (callbacks, event);
		711	::gather_callbacks (callbacks, cb_object, event);
		712	}
		713
		714	void
		715	archetype::gather_callbacks (AV *&callbacks, event_type event) const
		716	{
		717	attachable::gather_callbacks (callbacks, event);
		718	//TODO//::gather_callbacks (callbacks, cb_archetype, event);
		719	}
		720
		721	void
		722	client::gather_callbacks (AV *&callbacks, event_type event) const
		723	{
		724	attachable::gather_callbacks (callbacks, event);
		725	::gather_callbacks (callbacks, cb_client, event);
		726	}
		727
		728	void
		729	player::gather_callbacks (AV *&callbacks, event_type event) const
		730	{
		731	attachable::gather_callbacks (callbacks, event);
		732	::gather_callbacks (callbacks, cb_player, event);
		733	}
		734
		735	void
		736	maptile::gather_callbacks (AV *&callbacks, event_type event) const
		737	{
		738	attachable::gather_callbacks (callbacks, event);
		739	::gather_callbacks (callbacks, cb_map, event);
		740	}
		741
		742	bool
908	bool cfperl_invoke (event_type event, ...)	743	attachable::invoke (event_type event, ...)
909	{	744	{
910	data_type dt;	745	data_type dt;
911	va_list ap;	746	va_list ap;
912		747
913	va_start (ap, event);	748	va_start (ap, event);
914		749
915	AV *callbacks = 0;
916
917	object *op;
918	player *pl;
919	maptile *map;
920	client *ns;
921
922	// callback call ordering is:	750	// callback call ordering should be:
923	// 1. per-object callback	751	// 1. per-object callback
924	// 2. per-class object	752	// 2. per-class object
925	// 3. per-type callback	753	// 3. per-type callback
926	// 4. global callbacks	754	// 4. global callbacks
927		755
		756	AV *callbacks = 0;
928	gather_callbacks (callbacks, cb_global, event);	757	gather_callbacks (callbacks, event);
929
930	switch (KLASS_OF (event))
931	{
932	case KLASS_GLOBAL:
933	break;
934
935	case KLASS_OBJECT:
936	dt = (data_type) va_arg (ap, int);
937	assert (("first argument must be of type object", dt == DT_OBJECT));
938	op = va_arg (ap, object *);
939
940	if (op->cb)
941	gather_callbacks (callbacks, op->cb, event);
942
943	if (op->type)
944	{
945	if (op->subtype && op->type + op->subtype * NUM_SUBTYPES <= AvFILLp (cb_type))
946	{
947	SV *registry = AvARRAY (cb_type)[op->type + op->subtype * NUM_SUBTYPES];
948
949	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
950	gather_callbacks (callbacks, (AV *)SvRV (registry), event);
951	}
952
953	if (op->type <= AvFILLp (cb_type))
954	{
955	SV *registry = AvARRAY (cb_type)[op->type];
956
957	if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
958	gather_callbacks (callbacks, (AV *)SvRV (registry), event);
959	}
960	}
961
962	gather_callbacks (callbacks, cb_object, event);
963
964	break;
965
966	case KLASS_PLAYER:
967	dt = (data_type) va_arg (ap, int);
968	assert (("first argument must be of type player", dt == DT_PLAYER));
969	pl = va_arg (ap, player *);
970
971	if (pl->cb)
972	gather_callbacks (callbacks, pl->cb, event);
973
974	gather_callbacks (callbacks, cb_player, event);
975	break;
976
977	case KLASS_MAP:
978	dt = (data_type) va_arg (ap, int);
979	assert (("first argument must be of type object", dt == DT_MAP));
980	map = va_arg (ap, maptile *);
981
982	if (map->cb)
983	gather_callbacks (callbacks, map->cb, event);
984
985	gather_callbacks (callbacks, cb_map, event);
986	break;
987
988	case KLASS_CLIENT:
989	dt = (data_type) va_arg (ap, int);
990	assert (("first argument must be of type client", dt == DT_CLIENT));
991	ns = va_arg (ap, client *);
992
993	if (ns->cb)
994	gather_callbacks (callbacks, ns->cb, event);
995
996	gather_callbacks (callbacks, cb_client, event);
997	break;
998
999	default:
1000	assert (("unsupported event klass in cfperl_invoke", 0));
1001	}
1002		758
1003	// short-circuit processing if no callbacks found/defined	759	// short-circuit processing if no callbacks found/defined
1004	if (!callbacks)	760	if (!callbacks)
1005	return 0;	761	return 0;
1006		762
1007	dSP;	763	CALL_BEGIN (3);
1008	ENTER;
1009	SAVETMPS;
1010
1011	PUSHMARK (SP);
1012	EXTEND (SP, 3);
1013
1014	PUSHs (sv_2mortal (newSViv (event))); // only used for debugging nowadays	764	CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays
1015	PUSHs (sv_2mortal (newRV_noinc ((SV *)callbacks)));	765	CALL_ARG_SV (newRV_noinc ((SV *)callbacks));
1016		766
1017	switch (KLASS_OF (event))	767	//TODO: unhack
1018	{	768	if (object *op = is_a<object>(this)) CALL_ARG_SV (newSVdt (DT_OBJECT, op));
1019	case KLASS_OBJECT: PUSHs (sv_2mortal (newSVdt (DT_OBJECT, op))); break;	769	else if (player *pl = is_a<player>(this)) CALL_ARG_SV (newSVdt (DT_PLAYER, pl));
1020	case KLASS_PLAYER: PUSHs (sv_2mortal (newSVdt (DT_PLAYER, pl))); break;	770	else if (client *ns = is_a<client>(this)) CALL_ARG_SV (newSVdt (DT_CLIENT, ns));
1021	case KLASS_CLIENT: PUSHs (sv_2mortal (newSVdt (DT_CLIENT, ns))); break;	771	else if (maptile *m = is_a<maptile>(this)) CALL_ARG_SV (newSVdt (DT_MAP, m));
1022	case KLASS_MAP: PUSHs (sv_2mortal (newSVdt (DT_MAP, map))); break;	772	else if (global *gl = is_a<global>(this)) /*nop*/;
1023	}	773	else
		774	abort (); //TODO
1024		775
1025	for (;;)	776	for (;;)
1026	{	777	{
1027	dt = (data_type) va_arg (ap, int);	778	dt = (data_type) va_arg (ap, int);
1028		779
1029	if (dt == DT_END)	780	if (dt == DT_END)
1030	break;	781	break;
1031
1032	if (dt == DT_AV)	782	else if (dt == DT_AV)
1033	{	783	{
1034	AV *av = va_arg (ap, AV *);	784	AV *av = va_arg (ap, AV *);
1035		785
1036	for (int i = 0; i <= av_len (av); ++i)	786	for (int i = 0; i <= av_len (av); ++i)
1037	XPUSHs (*av_fetch (av, i, 1));	787	XPUSHs (*av_fetch (av, i, 1));
…		…
1040	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));	790	XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
1041	}	791	}
1042		792
1043	va_end (ap);	793	va_end (ap);
1044		794
1045	PUTBACK;	795	CALL_CALL ("cf::do_invoke", G_SCALAR);
1046	int count = call_pv ("cf::do_invoke", G_SCALAR | G_EVAL);
1047	SPAGAIN;
1048
1049	count = count > 0 ? POPi : 0;	796	count = count > 0 ? POPi : 0;
1050		797
1051	FREETMPS;	798	CALL_END;
1052	LEAVE;
1053		799
1054	return count;	800	return count;
1055	}	801	}
1056		802
1057	SV *	803	SV *
…		…
1080	return SvNV (cfperl_result (idx));	826	return SvNV (cfperl_result (idx));
1081	}	827	}
1082		828
1083	/////////////////////////////////////////////////////////////////////////////	829	/////////////////////////////////////////////////////////////////////////////
1084		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
1085	struct EventAPI *watcher_base::GEventAPI;	912	struct EventAPI *watcher_base::GEventAPI;
		913	struct CoroAPI *coroapi::GCoroAPI;
		914
		915	int coroapi::cede_counter;
1086		916
1087	static void iw_dispatch (pe_event *ev)	917	static void iw_dispatch (pe_event *ev)
1088	{	918	{
1089	iw *w = (iw *)ev->ext_data;	919	iw *w = (iw *)ev->ext_data;
1090	w->call (*w);	920	w->call (*w);
…		…
1093	void	923	void
1094	iw::alloc ()	924	iw::alloc ()
1095	{	925	{
1096	pe = GEventAPI->new_idle (0, 0);	926	pe = GEventAPI->new_idle (0, 0);
1097		927
		928	WaREENTRANT_off (pe);
1098	pe->base.callback = (void *)iw_dispatch;	929	pe->base.callback = (void *)iw_dispatch;
1099	pe->base.ext_data = (void *)this;	930	pe->base.ext_data = (void *)this;
1100	}	931	}
1101		932
1102	static void iow_dispatch (pe_event *ev)	933	static void iow_dispatch (pe_event *ev)
…		…
1108	void	939	void
1109	iow::alloc ()	940	iow::alloc ()
1110	{	941	{
1111	pe = GEventAPI->new_io (0, 0);	942	pe = GEventAPI->new_io (0, 0);
1112		943
		944	WaREENTRANT_off (pe);
1113	pe->base.callback = (void *)iow_dispatch;	945	pe->base.callback = (void *)iow_dispatch;
1114	pe->base.ext_data = (void *)this;	946	pe->base.ext_data = (void *)this;
1115		947
1116	pe->fd = -1;	948	pe->fd = -1;
1117	pe->poll = 0;	949	pe->poll = 0;
…		…
1138	pe->poll = events;	970	pe->poll = events;
1139	if (pe->poll) start ();	971	if (pe->poll) start ();
1140	}	972	}
1141	}	973	}
1142		974
		975	void
		976	_connect_to_perl ()
		977	{
		978	stash_cf = gv_stashpv ("cf" , 1);
		979
		980	stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);
		981	stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);
		982	stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);
		983	stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);
		984	stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);
		985	stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
		986	stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
		987	stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
		988	stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
		989
		990	sv_runtime = get_sv ("cf::RUNTIME", 1);
		991	sv_upgrade (sv_runtime, SVt_NV);
		992
		993	cb_global = get_av ("cf::CB_GLOBAL", 1);
		994	cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
		995	cb_object = get_av ("cf::CB_OBJECT", 1);
		996	cb_player = get_av ("cf::CB_PLAYER", 1);
		997	cb_client = get_av ("cf::CB_CLIENT", 1);
		998	cb_type = get_av ("cf::CB_TYPE" , 1);
		999	cb_map = get_av ("cf::CB_MAP" , 1);
		1000	}
		1001
1143	MODULE = cf PACKAGE = cf PREFIX = cf_	1002	MODULE = cf PACKAGE = cf PREFIX = cf_
1144		1003
1145	BOOT:	1004	BOOT:
1146	{	1005	{
1147	HV *stash = gv_stashpv ("cf", 1);	1006	_connect_to_perl ();
1148		1007
1149	I_EVENT_API (PACKAGE);
1150	watcher_base::GEventAPI = GEventAPI;	1008	I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;
		1009	I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
1151		1010
1152	newCONSTSUB (stash, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));	1011	newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
1153		1012
1154	static const struct {	1013	static const struct {
1155	const char *name;	1014	const char *name;
1156	IV iv;	1015	IV iv;
1157	} *civ, const_iv[] = {	1016	} *civ, const_iv[] = {
…		…
1418	const_iv (FLAG_ACTIVATE_ON_RELEASE)	1277	const_iv (FLAG_ACTIVATE_ON_RELEASE)
1419	const_iv (FLAG_IS_WATER)	1278	const_iv (FLAG_IS_WATER)
1420	const_iv (FLAG_CONTENT_ON_GEN)	1279	const_iv (FLAG_CONTENT_ON_GEN)
1421	const_iv (FLAG_IS_A_TEMPLATE)	1280	const_iv (FLAG_IS_A_TEMPLATE)
1422	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)
1423		1284
1424	const_iv (NDI_BLACK)	1285	const_iv (NDI_BLACK)
1425	const_iv (NDI_WHITE)	1286	const_iv (NDI_WHITE)
1426	const_iv (NDI_NAVY)	1287	const_iv (NDI_NAVY)
1427	const_iv (NDI_RED)	1288	const_iv (NDI_RED)
…		…
1469	const_iv (P_BLOCKSVIEW)	1330	const_iv (P_BLOCKSVIEW)
1470	const_iv (P_PLAYER)	1331	const_iv (P_PLAYER)
1471	const_iv (P_NO_MAGIC)	1332	const_iv (P_NO_MAGIC)
1472	const_iv (P_IS_ALIVE)	1333	const_iv (P_IS_ALIVE)
1473	const_iv (P_NO_CLERIC)	1334	const_iv (P_NO_CLERIC)
1474	const_iv (P_NEED_UPDATE)
1475	const_iv (P_OUT_OF_MAP)	1335	const_iv (P_OUT_OF_MAP)
1476	const_iv (P_NEW_MAP)	1336	const_iv (P_NEW_MAP)
		1337	const_iv (P_UPTODATE)
1477		1338
1478	const_iv (UP_OBJ_INSERT)	1339	const_iv (UP_OBJ_INSERT)
1479	const_iv (UP_OBJ_REMOVE)	1340	const_iv (UP_OBJ_REMOVE)
1480	const_iv (UP_OBJ_CHANGE)	1341	const_iv (UP_OBJ_CHANGE)
1481	const_iv (UP_OBJ_FACE)	1342	const_iv (UP_OBJ_FACE)
…		…
1612	const_iv (ATNR_BLIND)	1473	const_iv (ATNR_BLIND)
1613	const_iv (ATNR_INTERNAL)	1474	const_iv (ATNR_INTERNAL)
1614	const_iv (ATNR_LIFE_STEALING)	1475	const_iv (ATNR_LIFE_STEALING)
1615	const_iv (ATNR_DISEASE)	1476	const_iv (ATNR_DISEASE)
1616		1477
1617	const_iv (MAP_FLUSH)
1618	const_iv (MAP_PLAYER_UNIQUE)
1619	const_iv (MAP_BLOCK)
1620	const_iv (MAP_STYLE)
1621	const_iv (MAP_OVERLAY)
1622
1623	const_iv (MAP_IN_MEMORY)	1478	const_iv (MAP_IN_MEMORY)
1624	const_iv (MAP_SWAPPED)	1479	const_iv (MAP_SWAPPED)
1625	const_iv (MAP_LOADING)	1480	const_iv (MAP_LOADING)
1626	const_iv (MAP_SAVING)	1481	const_iv (MAP_SAVING)
1627		1482
		1483	const_iv (KLASS_ATTACHABLE)
1628	const_iv (KLASS_GLOBAL)	1484	const_iv (KLASS_GLOBAL)
1629	const_iv (KLASS_OBJECT)	1485	const_iv (KLASS_OBJECT)
1630	const_iv (KLASS_CLIENT)	1486	const_iv (KLASS_CLIENT)
1631	const_iv (KLASS_PLAYER)	1487	const_iv (KLASS_PLAYER)
1632	const_iv (KLASS_MAP)	1488	const_iv (KLASS_MAP)
…		…
1639	const_iv (ST_SETUP)	1495	const_iv (ST_SETUP)
1640	const_iv (ST_PLAYING)	1496	const_iv (ST_PLAYING)
1641	const_iv (ST_CUSTOM)	1497	const_iv (ST_CUSTOM)
1642		1498
1643	const_iv (ST_CHANGE_CLASS)	1499	const_iv (ST_CHANGE_CLASS)
1644	const_iv (ST_CONFIRM_QUIT)	1500
1645	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)
1646	};	1529	};
1647		1530
1648	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; )
1649	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));	1532	newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1650		1533
1651	static const struct {	1534	static const struct {
1652	const char *name;	1535	const char *name;
1653	int skip;	1536	int skip;
1654	IV klass;	1537	IV klass;
…		…
1665	{	1548	{
1666	AV *event = newAV ();	1549	AV *event = newAV ();
1667	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));	1550	av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));
1668	av_push (event, newSViv (eiv->klass));	1551	av_push (event, newSViv (eiv->klass));
1669	av_store (av, eiv->iv, newRV_noinc ((SV *)event));	1552	av_store (av, eiv->iv, newRV_noinc ((SV *)event));
1670	newCONSTSUB (stash, (char *)eiv->name, newSViv (eiv->iv));	1553	newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));
1671	}	1554	}
1672	}	1555	}
1673		1556
1674	void _init_vars ()	1557	void _connect_to_perl ()
1675	CODE:
1676	cb_global = get_av ("cf::CB_GLOBAL", 1);
1677	cb_object = get_av ("cf::CB_OBJECT", 1);
1678	cb_player = get_av ("cf::CB_PLAYER", 1);
1679	cb_client = get_av ("cf::CB_CLIENT", 1);
1680	cb_type = get_av ("cf::CB_TYPE" , 1);
1681	cb_map = get_av ("cf::CB_MAP" , 1);
1682		1558
1683	void _global_reattach ()	1559	void _global_reattach ()
1684	CODE:	1560	CODE:
1685	{	1561	{
1686	// reattach to all attachable objects in the game.	1562	// reattach to all attachable objects in the game.
1687	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)	1563	for_all_clients (ns)
1688	reattach (*i);	1564	ns->reattach ();
1689		1565
1690	for (player *pl = first_player; pl; pl = pl->next)	1566	for_all_players (pl)
1691	reattach (pl);	1567	pl->reattach ();
1692		1568
1693	for (maptile *map = first_map; map; map = map->next)	1569	//TODO
1694	reattach (map);	1570	//for (map_container::iterator i = maps.begin (); i != maps.end (); ++i)
		1571	// i->second->reattach ();
1695		1572
1696	for (object *op = object::first; op; op = op->next)	1573	for_all_objects (op)
1697	reattach (op);	1574	op->reattach ();
1698	}	1575	}
1699		1576
1700	NV floor (NV x)	1577	NV floor (NV x)
1701		1578
1702	NV ceil (NV x)	1579	NV ceil (NV x)
1703		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
1704	void server_tick ()	1593	void server_tick ()
		1594	CODE:
		1595	runtime = SvNVx (sv_runtime);
		1596	server_tick ();
1705		1597
1706	void	1598	void
1707	LOG (int level, char *msg)	1599	LOG (int level, char *msg)
1708	PROTOTYPE: $$	1600	PROTOTYPE: $$
1709	C_ARGS: (LogLevel)level, "%s", msg	1601	C_ARGS: (LogLevel)level, "%s", msg
…		…
1749	case 5: RETVAL = settings.playerdir; break;	1641	case 5: RETVAL = settings.playerdir; break;
1750	case 6: RETVAL = settings.datadir ; break;	1642	case 6: RETVAL = settings.datadir ; break;
1751	}	1643	}
1752	OUTPUT: RETVAL	1644	OUTPUT: RETVAL
1753		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
1754	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
1755		1669
1756	int find_animation (char *text)	1670	int find_animation (char *text)
1757	PROTOTYPE: $	1671	PROTOTYPE: $
1758		1672
1759	int random_roll (int min, int max, object *op, int goodbad);	1673	int random_roll (int min, int max, object *op, int goodbad);
…		…
1806	CODE:	1720	CODE:
1807	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);	1721	RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
1808	OUTPUT:	1722	OUTPUT:
1809	RETVAL	1723	RETVAL
1810		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
1811	MODULE = cf PACKAGE = cf::global	1737	MODULE = cf PACKAGE = cf::global
1812		1738
1813	int invoke (SV *klass, int event, ...)	1739	int invoke (SV *klass, int event, ...)
1814	CODE:	1740	CODE:
1815	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");
1816	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	1742	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
1817	for (int i = 1; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));	1743	for (int i = 1; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
1818	RETVAL = INVOKE_((event_type)event, ARG_AV (av));	1744	RETVAL = gbl_ev.invoke ((event_type)event, ARG_AV (av), DT_END);
1819	OUTPUT: RETVAL	1745	OUTPUT: RETVAL
1820		1746
1821	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_	1747	MODULE = cf PACKAGE = cf::object PREFIX = cf_object_
1822		1748
1823	INCLUDE: $PERL genacc object ../include/object.h |	1749	INCLUDE: $PERL genacc object ../include/object.h |
…		…
1825	int invoke (object *op, int event, ...)	1751	int invoke (object *op, int event, ...)
1826	CODE:	1752	CODE:
1827	if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");	1753	if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");
1828	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	1754	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
1829	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));	1755	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
1830	RETVAL = INVOKE_((event_type)event, ARG_OBJECT (op), ARG_AV (av));	1756	RETVAL = op->invoke ((event_type)event, ARG_AV (av), DT_END);
1831	OUTPUT: RETVAL	1757	OUTPUT: RETVAL
1832		1758
1833	SV *registry (object *op)	1759	SV *registry (object *op)
1834		1760
1835	void mortals ()	1761	int objects_size ()
1836	PPCODE:	1762	CODE:
1837	EXTEND (SP, object::mortals.size ());
1838	for (AUTODECL (i, object::mortals.begin ()); i != object::mortals.end (); ++i)
1839	PUSHs (to_sv (*i));
1840
1841	object *first ()
1842	CODE:
1843	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;
1844	OUTPUT: RETVAL	1779	OUTPUT: RETVAL
1845		1780
1846	# missing properties	1781	# missing properties
1847		1782
1848	object *head (object *op)	1783	object *head (object *op)
1849	PROTOTYPE: $	1784	PROTOTYPE: $
1850	CODE:	1785	CODE:
1851	RETVAL = op->head ? op->head : op;	1786	RETVAL = op->head_ ();
1852	OUTPUT: RETVAL	1787	OUTPUT: RETVAL
1853		1788
1854	int is_head (object *op)	1789	int is_head (object *op)
1855	PROTOTYPE: $	1790	PROTOTYPE: $
1856	CODE:	1791	CODE:
1857	RETVAL = !op->head;	1792	RETVAL = op->head_ () == op;
1858	OUTPUT: RETVAL	1793	OUTPUT: RETVAL
1859		1794
1860	void	1795	void
1861	inv (object *obj)	1796	inv (object *obj)
1862	PROTOTYPE: $	1797	PROTOTYPE: $
…		…
1870	void	1805	void
1871	set_animation (object *op, int idx)	1806	set_animation (object *op, int idx)
1872	CODE:	1807	CODE:
1873	SET_ANIMATION (op, idx);	1808	SET_ANIMATION (op, idx);
1874		1809
1875	void
1876	object::drain_stat ()
1877
1878	void
1879	object::drain_specific_stat (int stat)
1880
1881	void
1882	object::change_luck (int change)
1883
1884	void
1885	object::add_statbonus ()
1886
1887	void
1888	object::remove_statbonus ()
1889
1890	object *find_best_object_match (object *op, const char *match)	1810	object *find_best_object_match (object *op, const char *match)
1891		1811
1892	object *find_marked_object (object *op)	1812	object *find_marked_object (object *op)
1893		1813
1894	int need_identify (const object *obj);	1814	int need_identify (object *obj);
1895		1815
1896	int apply_shop_mat (object *shop_mat, object *op);	1816	int apply_shop_mat (object *shop_mat, object *op);
1897		1817
1898	int move (object *op, int dir, object *originator = op)	1818	int move (object *op, int dir, object *originator = op)
1899	CODE:	1819	CODE:
…		…
1907		1827
1908	void apply_below (object *op)	1828	void apply_below (object *op)
1909	CODE:	1829	CODE:
1910	player_apply_below (op);	1830	player_apply_below (op);
1911		1831
1912	void remove (object *op)
1913	CODE:
1914	op->remove ();
1915
1916	void
1917	object::destroy (int recursive = 0)
1918
1919	object *cf_object_present_archname_inside (object *op, char *whatstr)	1832	object *cf_object_present_archname_inside (object *op, char *whatstr)
1920		1833
1921	int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)	1834	int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)
1922		1835
1923	int cf_object_change_map (object *op, int x, int y, maptile *map)	1836	int cf_object_change_map (object *op, int x, int y, maptile *map)
1924		1837
		1838	#//TODO
1925	object *clone (object *op, int recursive = 0)	1839	object *clone_ (object *op, int recursive = 0)
1926	CODE:	1840	CODE:
1927	if (recursive)	1841	if (recursive)
1928	RETVAL = object_create_clone (op);	1842	RETVAL = object_create_clone (op);
1929	else	1843	else
1930	{	1844	{
…		…
1963	OUTPUT: RETVAL	1877	OUTPUT: RETVAL
1964		1878
1965	int query_money (object *op)	1879	int query_money (object *op)
1966	ALIAS: money = 0	1880	ALIAS: money = 0
1967		1881
1968	int query_cost (object *op, object *who, int flags)	1882	val64 query_cost (object *op, object *who, int flags)
1969	ALIAS: cost = 0	1883	ALIAS: cost = 0
1970		1884
1971	void spring_trap (object *op, object *victim)	1885	void spring_trap (object *op, object *victim)
1972		1886
1973	int check_trigger (object *op, object *cause)	1887	int check_trigger (object *op, object *cause)
1974		1888
1975	void drop (object *who, object *op)	1889	void drop (object *who, object *op)
1976		1890
1977	void pick_up (object *who, object *op)	1891	void pick_up (object *who, object *op)
1978
1979	object *cf_object_insert_object (object *op, object *container)
1980
1981	object *cf_object_insert_in_ob (object *ob, object *where)
1982		1892
1983	int cf_object_teleport (object *op, maptile *map, int x, int y)	1893	int cf_object_teleport (object *op, maptile *map, int x, int y)
1984		1894
1985	void update_object (object *op, int action)	1895	void update_object (object *op, int action)
1986		1896
…		…
2034		1944
2035	player *contr (object *op)	1945	player *contr (object *op)
2036	CODE:	1946	CODE:
2037	RETVAL = op->contr;	1947	RETVAL = op->contr;
2038	OUTPUT: RETVAL	1948	OUTPUT: RETVAL
2039
2040	void
2041	object::roll_stats ()
2042
2043	void
2044	object::update_stats ()
2045
2046	void
2047	object::swap_stats (int a, int b)
2048		1949
2049	const char *get_ob_key_value (object *op, const char *key)	1950	const char *get_ob_key_value (object *op, const char *key)
2050		1951
2051	bool set_ob_key_value (object *op, const char *key, const char *value = 0, int add_key = 1)	1952	bool set_ob_key_value (object *op, const char *key, const char *value = 0, int add_key = 1)
2052		1953
…		…
2089	RETVAL = op->contr;	1990	RETVAL = op->contr;
2090	OUTPUT: RETVAL	1991	OUTPUT: RETVAL
2091		1992
2092	void check_score (object *op)	1993	void check_score (object *op)
2093		1994
2094	void cf_player_message (object *obj, char *txt, int flags = NDI_ORANGE | NDI_UNIQUE)	1995	void message (object *op, char *txt, int flags = NDI_ORANGE | NDI_UNIQUE)
		1996	CODE:
		1997	new_draw_info (flags, 0, op, txt);
2095		1998
2096	object *cf_player_send_inventory (object *op)	1999	object *cf_player_send_inventory (object *op)
2097		2000
2098	char *cf_player_get_ip (object *op)	2001	char *cf_player_get_ip (object *op)
2099	ALIAS: ip = 0	2002	ALIAS: ip = 0
…		…
2112		2015
2113	void esrv_update_item (object *op, int what, object *item)	2016	void esrv_update_item (object *op, int what, object *item)
2114	C_ARGS: what, op, item	2017	C_ARGS: what, op, item
2115		2018
2116	void clear_los (object *op)	2019	void clear_los (object *op)
2117
2118	int command_reset (object *op, char *params)
2119
2120	int command_teleport (object *op, char *params)
2121		2020
2122	int command_summon (object *op, char *params)	2021	int command_summon (object *op, char *params)
2123		2022
2124	int command_arrest (object *op, char *params)	2023	int command_arrest (object *op, char *params)
2125		2024
…		…
2135	int invoke (player *pl, int event, ...)	2034	int invoke (player *pl, int event, ...)
2136	CODE:	2035	CODE:
2137	if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");	2036	if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");
2138	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	2037	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
2139	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));	2038	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
2140	RETVAL = INVOKE_((event_type)event, ARG_PLAYER (pl), ARG_AV (av));	2039	RETVAL = pl->invoke ((event_type)event, ARG_AV (av), DT_END);
2141	OUTPUT: RETVAL	2040	OUTPUT: RETVAL
2142		2041
2143	SV *registry (player *pl)	2042	SV *registry (player *pl)
2144
2145	player *
2146	create ()
2147	CODE:
2148	RETVAL = player::create ();
2149	OUTPUT:
2150	RETVAL
2151
2152	player *
2153	load (const char *path)
2154	CODE:
2155	RETVAL = player::load (path);
2156	OUTPUT:
2157	RETVAL
2158
2159	void
2160	player::save (bool final = false)
2161
2162	void
2163	player::connect (client *ns)
2164		2043
2165	void	2044	void
2166	save_stats (player *pl)	2045	save_stats (player *pl)
2167	CODE:	2046	CODE:
2168	pl->ob->stats.hp = pl->ob->stats.maxhp;	2047	pl->ob->stats.hp = pl->ob->stats.maxhp;
2169	pl->ob->stats.sp = pl->ob->stats.maxsp;	2048	pl->ob->stats.sp = pl->ob->stats.maxsp;
2170	pl->ob->stats.grace = pl->ob->stats.maxgrace;	2049	pl->ob->stats.grace = pl->ob->stats.maxgrace;
2171	pl->orig_stats = pl->ob->stats;	2050	pl->orig_stats = pl->ob->stats;
2172
2173	player *cf_player_find (char *name)
2174	PROTOTYPE: $
2175		2051
2176	void cf_player_move (player *pl, int dir)	2052	void cf_player_move (player *pl, int dir)
2177		2053
2178	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);	2054	void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);
2179		2055
…		…
2225	if (y) sv_to (y, pl->bed_y);	2101	if (y) sv_to (y, pl->bed_y);
2226		2102
2227	void	2103	void
2228	list ()	2104	list ()
2229	PPCODE:	2105	PPCODE:
2230	for (player *pl = first_player; pl; pl = pl->next)	2106	for_all_players (pl)
2231	XPUSHs (sv_2mortal (to_sv (pl)));	2107	XPUSHs (sv_2mortal (to_sv (pl)));
2232		2108
2233	bool
2234	peaceful (player *pl, bool new_setting = 0)
2235	PROTOTYPE: $;$
2236	CODE:
2237	RETVAL = pl->peaceful;
2238	if (items > 1)
2239	pl->peaceful = new_setting;
2240	OUTPUT:
2241	RETVAL
2242
2243	living *
2244	orig_stats (player *pl)
2245	CODE:
2246	RETVAL = &pl->orig_stats;
2247	OUTPUT: RETVAL
2248
2249	living *
2250	last_stats (player *pl)
2251	CODE:
2252	RETVAL = &pl->last_stats;
2253	OUTPUT: RETVAL
2254
2255		2109
2256	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_	2110	MODULE = cf PACKAGE = cf::map PREFIX = cf_map_
2257
2258	maptile *first ()
2259	PROTOTYPE:
2260	CODE:
2261	RETVAL = first_map;
2262	OUTPUT: RETVAL
2263		2111
2264	int invoke (maptile *map, int event, ...)	2112	int invoke (maptile *map, int event, ...)
2265	CODE:	2113	CODE:
2266	if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");	2114	if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");
2267	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	2115	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
2268	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));	2116	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
2269	RETVAL = INVOKE_((event_type)event, ARG_MAP (map), ARG_AV (av));	2117	RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);
2270	OUTPUT: RETVAL	2118	OUTPUT: RETVAL
2271		2119
2272	SV *registry (maptile *map)	2120	SV *registry (maptile *map)
2273		2121
2274	INCLUDE: $PERL genacc maptile ../include/map.h |	2122	INCLUDE: $PERL genacc maptile ../include/map.h |
2275		2123
2276	maptile *new (int width, int height)	2124	void
		2125	maptile::instantiate ()
		2126
		2127	maptile *new ()
2277	PROTOTYPE:	2128	PROTOTYPE:
2278	CODE:	2129	CODE:
2279	{	2130	RETVAL = new maptile;
2280	RETVAL = get_empty_map (width, height);
2281	}
2282	OUTPUT:	2131	OUTPUT:
2283	RETVAL	2132	RETVAL
2284		2133
2285	void delete_map (maptile *map)	2134	void
		2135	maptile::players ()
		2136	PPCODE:
		2137	if (GIMME_V == G_SCALAR)
		2138	XPUSHs (sv_2mortal (to_sv (THIS->players)));
		2139	else if (GIMME_V == G_ARRAY)
		2140	{
		2141	EXTEND (SP, THIS->players);
		2142	for_all_players (pl)
		2143	if (pl->ob && pl->ob->map == THIS)
		2144	PUSHs (sv_2mortal (to_sv (pl->ob)));
		2145	}
2286		2146
2287	void clean_tmp_map (maptile *map)	2147	void
		2148	maptile::set_regiondata (SV *data, SV *plt)
		2149	CODE:
		2150	{
		2151	if (!SvROK (plt) || SvTYPE (SvRV (plt)) != SVt_PVAV)
		2152	croak ("maptile::set_regiondata needs arrayref as plt arg");
		2153
		2154	AV *av = (AV *)SvRV (plt);
		2155
		2156	region **regionmap = (region **)malloc ((av_len (av) + 1) * sizeof (region *));
		2157
		2158	for (int i = av_len (av) + 1; i--; )
		2159	regionmap [i] = region::find (SvPVutf8_nolen (*av_fetch (av, i, 1)));
		2160
		2161	THIS->regions = salloc<uint8_t> (THIS->size (), (uint8_t *)SvPVbyte_nolen (data));
		2162	THIS->regionmap = regionmap;
		2163	}
2288		2164
2289	void play_sound_map (maptile *map, int x, int y, int sound_num)	2165	void play_sound_map (maptile *map, int x, int y, int sound_num)
2290		2166
2291	int out_of_map (maptile *map, int x, int y)	2167	int out_of_map (maptile *map, int x, int y)
2292
2293	maptile *tile_map (maptile *map, unsigned int dir)
2294	CODE:
2295	RETVAL = dir < 4 ? map->tile_map [dir] : 0;
2296	OUTPUT:
2297	RETVAL
2298
2299	char *tile_path (maptile *map, unsigned int dir)
2300	CODE:
2301	if (dir >= 4)
2302	XSRETURN_UNDEF;
2303	RETVAL = map->tile_path [dir];
2304	OUTPUT:
2305	RETVAL
2306
2307	maptile *ready_map_name (char *name, int flags = 0)
2308	PROTOTYPE: $;$
2309	ALIAS:
2310	find = 0
2311	get_map = 1
2312
2313	maptile *has_been_loaded (char *name)
2314	PROTOTYPE: $
2315
2316	int in_memory (maptile *map)
2317	CODE:
2318	RETVAL = map->in_memory;
2319	OUTPUT:
2320	RETVAL
2321		2168
2322	void	2169	void
2323	trigger (maptile *map, long connection, bool state = true)	2170	trigger (maptile *map, long connection, bool state = true)
2324	CODE:	2171	CODE:
2325	activate_connection (map, connection, state);	2172	activate_connection (map, connection, state);
…		…
2338		2185
2339	object* cf_map_present_arch_by_name (maptile *map, const char* str, int nx, int ny)	2186	object* cf_map_present_arch_by_name (maptile *map, const char* str, int nx, int ny)
2340	C_ARGS: str, map, nx, ny	2187	C_ARGS: str, map, nx, ny
2341		2188
2342	void	2189	void
2343	cf_map_normalise (maptile *map, int x, int y)	2190	get_map_flags (maptile *map, int x, int y)
2344	PPCODE:	2191	PPCODE:
2345	{	2192	{
2346	maptile *nmap = 0;	2193	maptile *nmap = 0;
2347	I16 nx = 0, ny = 0;	2194	I16 nx = 0, ny = 0;
2348	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);	2195	int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
…		…
2384	move_block_at = 4	2231	move_block_at = 4
2385	move_slow_at = 5	2232	move_slow_at = 5
2386	move_on_at = 6	2233	move_on_at = 6
2387	move_off_at = 7	2234	move_off_at = 7
2388	INIT:	2235	INIT:
2389	if (x >= MAP_WIDTH (obj) || y >= MAP_HEIGHT (obj)) XSRETURN_UNDEF;	2236	if (x >= obj->width || y >= obj->height) XSRETURN_UNDEF;
2390	CODE:	2237	CODE:
2391	switch (ix)	2238	switch (ix)
2392	{	2239	{
2393	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;	2240	case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break;
2394	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;	2241	case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break;
…		…
2397	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;	2244	case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;
2398	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;	2245	case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;
2399	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;	2246	case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;
2400	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;	2247	case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;
2401	}	2248	}
2402	OUTPUT:	2249	OUTPUT: RETVAL
		2250
		2251	void fix_walls (maptile *map, int x, int y)
		2252
		2253	void fix_walls_around (maptile *map, int x, int y)
		2254
		2255	const char *
		2256	region_name (maptile *m)
		2257	CODE:
		2258	RETVAL = get_name_of_region_for_map (m);
		2259	OUTPUT: RETVAL
		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:
2403	RETVAL	2347	RETVAL
2404
2405	void fix_walls (maptile *map, int x, int y)
2406
2407	void fix_walls_around (maptile *map, int x, int y)
2408		2348
2409	MODULE = cf PACKAGE = cf::arch	2349	MODULE = cf PACKAGE = cf::arch
2410		2350
2411	archetype *find (const char *name)	2351	archetype *find (const char *name)
2412	CODE:	2352	CODE:
…		…
2428	PROTOTYPE:	2368	PROTOTYPE:
2429	CODE:	2369	CODE:
2430	RETVAL = get_firstparty ();	2370	RETVAL = get_firstparty ();
2431	OUTPUT: RETVAL	2371	OUTPUT: RETVAL
2432		2372
2433	partylist *next (partylist *party)	2373	INCLUDE: $PERL genacc partylist ../include/player.h |
2434	CODE:
2435	RETVAL = party->next;
2436	OUTPUT: RETVAL
2437
2438	const char *name (partylist *party)
2439	CODE:
2440	RETVAL = party->partyname;
2441	OUTPUT: RETVAL
2442
2443	const char *password (partylist *party)
2444	CODE:
2445	RETVAL = party->passwd;
2446	OUTPUT: RETVAL
2447		2374
2448	MODULE = cf PACKAGE = cf::region	2375	MODULE = cf PACKAGE = cf::region
2449		2376
2450	region *first ()	2377	region *first ()
2451	PROTOTYPE:	2378	PROTOTYPE:
2452	CODE:	2379	CODE:
2453	RETVAL = first_region;	2380	RETVAL = first_region;
2454	OUTPUT: RETVAL	2381	OUTPUT: RETVAL
2455		2382
2456	region *next (region *reg)	2383	region *find (char *name)
		2384	PROTOTYPE: $
2457	CODE:	2385	CODE:
2458	RETVAL = reg->next;	2386	RETVAL = region::find (name);
2459	OUTPUT: RETVAL	2387	OUTPUT: RETVAL
2460		2388
2461	const char *name (region *reg)	2389	INCLUDE: $PERL genacc region ../include/map.h |
2462	CODE:
2463	RETVAL = reg->name;
2464	OUTPUT: RETVAL
2465
2466	region *parent (region *reg)
2467	CODE:
2468	RETVAL = reg->parent;
2469	OUTPUT: RETVAL
2470
2471	const char *longname (region *reg)
2472	CODE:
2473	RETVAL = reg->longname;
2474	OUTPUT: RETVAL
2475
2476	const char *msg (region *reg)
2477	CODE:
2478	RETVAL = reg->msg;
2479	OUTPUT: RETVAL
2480		2390
2481	MODULE = cf PACKAGE = cf::living	2391	MODULE = cf PACKAGE = cf::living
2482		2392
2483	INCLUDE: $PERL genacc living ../include/living.h |	2393	INCLUDE: $PERL genacc living ../include/living.h |
2484		2394
…		…
2493	int invoke (client *ns, int event, ...)	2403	int invoke (client *ns, int event, ...)
2494	CODE:	2404	CODE:
2495	if (KLASS_OF (event) != KLASS_CLIENT) croak ("event class must be CLIENT");	2405	if (KLASS_OF (event) != KLASS_CLIENT) croak ("event class must be CLIENT");
2496	AV *av = (AV *)sv_2mortal ((SV *)newAV ());	2406	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
2497	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));	2407	for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
2498	RETVAL = INVOKE_((event_type)event, ARG_CLIENT (ns), ARG_AV (av));	2408	RETVAL = ns->invoke ((event_type)event, ARG_AV (av), DT_END);
2499	OUTPUT: RETVAL	2409	OUTPUT: RETVAL
2500		2410
2501	SV *registry (client *ns)	2411	SV *registry (client *ns)
2502		2412
2503	void	2413	void
…		…
2505	PPCODE:	2415	PPCODE:
2506	EXTEND (SP, clients.size ());	2416	EXTEND (SP, clients.size ());
2507	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)	2417	for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
2508	PUSHs (sv_2mortal (to_sv (*i)));	2418	PUSHs (sv_2mortal (to_sv (*i)));
2509		2419
2510	client *
2511	create (int fd, const char *peername)
2512	CODE:
2513	RETVAL = client::create (fd, peername);
2514	OUTPUT:
2515	RETVAL
2516
2517	void	2420	void
2518	client::send_packet (SV *packet)	2421	client::send_packet (SV *packet)
2519	CODE:	2422	CODE:
2520	{	2423	{
2521	STRLEN len;	2424	STRLEN len;
2522	char *buf = SvPVbyte (packet, len);	2425	char *buf = SvPVbyte (packet, len);
2523		2426
2524	THIS->send_packet (buf, len);	2427	THIS->send_packet (buf, len);
2525	}	2428	}
2526		2429
2527	void
2528	client::destroy ()
2529

Diff Legend

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