ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/server/cfperl.xs
(Generate patch)

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.237 by root, Mon Jul 23 23:46:03 2007 UTC vs.
Revision 1.316 by root, Thu Jan 8 04:35:05 2009 UTC

1/* 1/*
2 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG. 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (©) 2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team 4 * Copyright (©) 2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2001-2005,2007 by Chachkoff Yann 5 * Copyright (©) 2001-2005,2007 by Chachkoff Yann
6 * Copyright (©) 2006,2007 by Marc Lehmann <cf@schmorp.de> 6 * Copyright (©) 2006,2007 by Marc Lehmann <cf@schmorp.de>
7 * 7 *
8 * Crossfire TRT is free software: you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by 9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or 10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version. 11 * (at your option) any later version.
12 * 12 *
13 * This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
… …
16 * GNU General Public License for more details. 16 * GNU General Public License for more details.
17 * 17 *
18 * You should have received a copy of the GNU General Public License 18 * You should have received a copy of the GNU General Public License
19 * along with this program. If not, see <http://www.gnu.org/licenses/>. 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 * 20 *
21 * The authors can be reached via e-mail to <crossfire@schmorp.de> 21 * The authors can be reached via e-mail to <support@deliantra.net>
22 */ 22 */
23 23
24#include "autoconf.h" 24#include "autoconf.h"
25
26#define PLUGIN_NAME "perl"
27#define PLUGIN_VERSION "cfperl 0.5"
28
29#define CEDES_PER_TICK 5
30 25
31#if HAVE_EXECINFO_H 26#if HAVE_EXECINFO_H
32# include <execinfo.h> 27# include <execinfo.h>
33#endif 28#endif
34 29
35#include <plugin_common.h>
36#include <sounds.h>
37#include <cstdarg> 30#include <cstdarg>
38#include <sproto.h> 31#include <typeinfo>
39 32
33#include "global.h"
40#include "loader.h" 34#include "loader.h"
35#include "../random_maps/random_map.h"
41#include "cfperl.h" 36#include "evthread.h"
42#include "shstr.h" 37#include "sproto.h"
43 38
44#include <unistd.h> 39#include <unistd.h>
45#if _POSIX_MEMLOCK 40#if _POSIX_MEMLOCK
46# include <sys/mman.h> 41# include <sys/mman.h>
47#endif 42#endif
48 43
44#if HAVE_MALLOC_H
45# include <malloc.h>
46#endif
47
48#if !__GLIBC__
49# define malloc_trim(pad) -1
50#endif
51
49#include <EXTERN.h> 52#include <EXTERN.h>
50#include <perl.h> 53#include <perl.h>
51#include <XSUB.h> 54#include <XSUB.h>
52 55
53#include "CoroAPI.h" 56#include "CoroAPI.h"
54#include "perlxsi.c" 57#include "perlxsi.c"
55 58
56extern sint64 *levels; // the experience table 59extern sint64 *levels; // the experience table
57 60
58typedef object object_ornull; 61typedef object_thawer &object_thawer_ref;
59typedef maptile maptile_ornull; 62typedef object_freezer &object_freezer_ref;
60
61typedef char *octet_string;
62typedef char *utf8_string;
63typedef const char *const_octet_string;
64typedef const char *const_utf8_string;
65 63
66typedef std::string std__string; 64typedef std::string std__string;
67 65
68#if IVSIZE >= 8
69 typedef IV val64;
70# define newSVval64 newSViv
71# define SvVAL64 SvIV
72#else
73 typedef double val64;
74# define newSVval64 newSVnv
75# define SvVAL64 SvNV
76#endif
77
78static f_plug_api gethook = cfapi_get_hooks;
79static f_plug_api object_insert = cfapi_object_insert;
80
81static PerlInterpreter *perl; 66static PerlInterpreter *perl;
82 67
83tstamp NOW, runtime; 68tstamp NOW, runtime;
69
70static int tick_inhibit;
71static int tick_pending;
84 72
85global gbl_ev; 73global gbl_ev;
86static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map; 74static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map;
87static SV *sv_runtime, *sv_next_tick; 75static SV *sv_runtime, *sv_tick_start, *sv_next_tick, *sv_now;
88 76
89bitset<NUM_EVENT_TYPES> ev_want_event; 77bitset<NUM_EVENT_TYPES> ev_want_event;
90bitset<NUM_TYPES> ev_want_type; 78bitset<NUM_TYPES> ev_want_type;
91 79
92static HV 80static HV
93 *stash_cf, 81 *stash_cf,
94 *stash_cf_object_wrap, 82 *stash_cf_object_wrap,
95 *stash_cf_object_player_wrap, 83 *stash_cf_object_player_wrap,
96 *stash_cf_player_wrap, 84 *stash_cf_player_wrap,
97 *stash_cf_map_wrap, 85 *stash_cf_map_wrap,
86 *stash_cf_mapspace_wrap,
98 *stash_cf_client_wrap, 87 *stash_cf_client_wrap,
99 *stash_cf_arch_wrap, 88 *stash_cf_arch_wrap,
100 *stash_cf_party_wrap, 89 *stash_cf_party_wrap,
101 *stash_cf_region_wrap, 90 *stash_cf_region_wrap,
102 *stash_cf_living_wrap; 91 *stash_cf_living_wrap;
92
93#ifndef newSVpv_utf8
94static inline SV *
95newSVpv_utf8 (const char *s)
96{
97 if (!s)
98 return newSV (0);
99
100 SV *sv = newSVpv (s, 0);
101 SvUTF8_on (sv);
102 return sv;
103}
104#endif
105
106#ifndef newSVpvn_utf8
107static inline SV *
108newSVpvn_utf8 (const char *s, STRLEN l, int utf8)
109{
110 if (!s)
111 return newSV (0);
112
113 SV *sv = newSVpvn (s, l);
114
115 if (utf8)
116 SvUTF8_on (sv);
117
118 return sv;
119}
120#endif
103 121
104// helper cast function, returns super class * or 0 122// helper cast function, returns super class * or 0
105template<class super> 123template<class super>
106static super * 124static super *
107is_a (attachable *at) 125is_a (attachable *at)
… …
140 SvREFCNT_inc (self); 158 SvREFCNT_inc (self);
141 hv_clear (self); 159 hv_clear (self);
142 sv_unmagic ((SV *)self, PERL_MAGIC_ext); 160 sv_unmagic ((SV *)self, PERL_MAGIC_ext);
143 SvREFCNT_dec (self); 161 SvREFCNT_dec (self);
144 162
145 // self *must* be null now because thats sv_unmagic's job. 163 // self *must* be null now because that's sv_unmagic's job.
146 assert (!this->self); 164 assert (!this->self);
147 } 165 }
148} 166}
149 167
150void 168void
… …
247 } 265 }
248 } 266 }
249} 267}
250 268
251void 269void
252attachable::set_key (const char *key, const char *value) 270attachable::set_key (const char *key, const char *value, bool is_utf8)
253{ 271{
254 if (!self) 272 if (!self)
255 self = newHV (); 273 self = newHV ();
256 274
257 if (value) 275 if (value)
258 hv_store (self, key, strlen (key), newSVpv (value, 0), 0); 276 hv_store (self, key, strlen (key), is_utf8 ? newSVpv_utf8 (value) : newSVpv (value, 0), 0);
259 else 277 else
260 hv_delete (self, key, strlen (key), G_DISCARD); 278 hv_delete (self, key, strlen (key), G_DISCARD);
261} 279}
262 280
263attachable & 281attachable &
… …
310newSVptr (void *ptr, HV *stash, HV *hv = newHV ()) 328newSVptr (void *ptr, HV *stash, HV *hv = newHV ())
311{ 329{
312 SV *sv; 330 SV *sv;
313 331
314 if (!ptr) 332 if (!ptr)
315 return &PL_sv_undef; 333 return newSV (0);
316 334
317 sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0); 335 sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);
318 return sv_bless (newRV_noinc ((SV *)hv), stash); 336 return sv_bless (newRV_noinc ((SV *)hv), stash);
319} 337}
320 338
… …
339 357
340static SV * 358static SV *
341newSVattachable (attachable *obj, HV *stash) 359newSVattachable (attachable *obj, HV *stash)
342{ 360{
343 if (!obj) 361 if (!obj)
344 return &PL_sv_undef; 362 return newSV (0);
345 363
346 if (!obj->self) 364 if (!obj->self)
347 obj->self = newHV (); 365 obj->self = newHV ();
348 366
349 if (!SvOBJECT (obj->self)) 367 if (!SvOBJECT (obj->self))
… …
387 croak ("perl code used %s object, but C object is already destroyed, caught", klass); 405 croak ("perl code used %s object, but C object is already destroyed, caught", klass);
388 406
389 return (long)mg->mg_ptr; 407 return (long)mg->mg_ptr;
390} 408}
391 409
392static long 410static long noinline
393SvPTR_ornull (SV *sv, const char *klass) 411SvPTR_ornull (SV *sv, const char *klass)
394{ 412{
395 if (SvOK (sv)) 413 if (SvOK (sv))
396 return SvPTR (sv, klass); 414 return SvPTR (sv, klass);
397 else 415 else
398 return 0; 416 return 0;
399} 417}
400 418
401static inline SV *
402newSVpv_utf8 (const char *s)
403{
404 SV *sv = newSVpv (s, 0);
405 SvUTF8_on (sv);
406 return sv;
407}
408
409static inline SV *
410newSVpvn_utf8 (const char *s, STRLEN l)
411{
412 SV *sv = newSVpvn (s, l);
413 SvUTF8_on (sv);
414 return sv;
415}
416
417inline SV *to_sv (const shstr & v) { return v ? newSVpvn_utf8 ((const char *)v, v.length ()) : &PL_sv_undef; } 419inline SV *to_sv (const shstr & v) { return newSVpvn_utf8 ((const char *)v, v.length (), 1); }
418inline SV *to_sv (const char * v) { return newSVpv (v, 0); } 420inline SV *to_sv (const char * v) { return v ? newSVpv (v, 0) : newSV (0); }
419inline SV *to_sv (bool v) { return newSViv (v); } 421inline SV *to_sv (bool v) { return newSViv (v); }
420inline SV *to_sv ( signed char v) { return newSViv (v); } 422inline SV *to_sv ( signed char v) { return newSViv (v); }
421inline SV *to_sv (unsigned char v) { return newSViv (v); } 423inline SV *to_sv (unsigned char v) { return newSViv (v); }
422inline SV *to_sv ( signed short v) { return newSViv (v); } 424inline SV *to_sv ( signed short v) { return newSViv (v); }
423inline SV *to_sv (unsigned short v) { return newSVuv (v); } 425inline SV *to_sv (unsigned short v) { return newSVuv (v); }
… …
435inline SV *to_sv (maptile * v) { return newSVattachable (v, stash_cf_map_wrap); } 437inline SV *to_sv (maptile * v) { return newSVattachable (v, stash_cf_map_wrap); }
436inline SV *to_sv (archetype * v) { return newSVattachable (v, stash_cf_arch_wrap); } 438inline SV *to_sv (archetype * v) { return newSVattachable (v, stash_cf_arch_wrap); }
437inline SV *to_sv (region * v) { return newSVattachable (v, stash_cf_region_wrap); } 439inline SV *to_sv (region * v) { return newSVattachable (v, stash_cf_region_wrap); }
438inline SV *to_sv (partylist * v) { return newSVptr (v, stash_cf_party_wrap); } 440inline SV *to_sv (partylist * v) { return newSVptr (v, stash_cf_party_wrap); }
439inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); } 441inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }
442inline SV *to_sv (mapspace * v) { return newSVptr (v, stash_cf_mapspace_wrap); }
440 443
441inline SV *to_sv (object & v) { return to_sv (&v); } 444inline SV *to_sv (object & v) { return to_sv (&v); }
442inline SV *to_sv (living & v) { return to_sv (&v); } 445inline SV *to_sv (living & v) { return to_sv (&v); }
443 446
444inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); } 447inline SV *to_sv (const std::string & v) { return newSVpvn (v.data (), v.size ()); }
445inline SV *to_sv (const treasurelist *v) { return to_sv (v->name); } 448inline SV *to_sv (const treasurelist *v) { return to_sv (v->name); }
446 449
450inline SV *to_sv (UUID v) { return newSVpv (v.c_str (), 0); }
451
447inline SV *to_sv (UUID v) 452inline SV *to_sv (dynbuf * v)
448{ 453{
449 char buf[128]; 454 SV *sv = newSV (0);
450 snprintf (buf, 128, "<1.%" PRIx64 ">", v.seq);
451 return newSVpv (buf, 0);
452}
453 455
456 sv_upgrade (sv, SVt_PV);
457 SvGROW (sv, v->size () + 1);
458 SvPOK_only (sv);
459 v->linearise (SvPVX (sv));
460 SvCUR_set (sv, v->size ());
461 *SvEND (sv) = 0;
462
463 return sv;
464}
465
466inline SV *to_sv (dynbuf_text * v)
467{
468 SV *sv = to_sv (static_cast<dynbuf *> (v));
469 SvUTF8_on (sv);
470 return sv;
471}
472
454inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPVutf8_nolen (sv) : 0; } 473inline void sv_to (SV *sv, shstr &v) { v = SvOK (sv) ? SvPVutf8_nolen (sv) : 0; }
455inline void sv_to (SV *sv, char * &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; } 474inline void sv_to (SV *sv, char * &v) { free (v); v = SvOK (sv) ? strdup (SvPV_nolen (sv)) : 0; }
456inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); } 475inline void sv_to (SV *sv, bool &v) { v = SvIV (sv); }
457inline void sv_to (SV *sv, signed char &v) { v = SvIV (sv); } 476inline void sv_to (SV *sv, signed char &v) { v = SvIV (sv); }
458inline void sv_to (SV *sv, unsigned char &v) { v = SvIV (sv); } 477inline void sv_to (SV *sv, unsigned char &v) { v = SvIV (sv); }
459inline void sv_to (SV *sv, signed short &v) { v = SvIV (sv); } 478inline void sv_to (SV *sv, signed short &v) { v = SvIV (sv); }
460inline void sv_to (SV *sv, unsigned short &v) { v = SvIV (sv); } 479inline void sv_to (SV *sv, unsigned short &v) { v = SvIV (sv); }
461inline void sv_to (SV *sv, signed int &v) { v = SvIV (sv); } 480inline void sv_to (SV *sv, signed int &v) { v = SvIV (sv); }
462inline void sv_to (SV *sv, unsigned int &v) { v = SvUV (sv); } 481inline void sv_to (SV *sv, unsigned int &v) { v = SvUV (sv); }
463inline void sv_to (SV *sv, signed long &v) { v = SvIV (sv); } 482inline void sv_to (SV *sv, signed long &v) { v = SvIV (sv); }
464inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); } 483inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }
465inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); } 484inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }
466inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); } 485inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }
467inline void sv_to (SV *sv, float &v) { v = SvNV (sv); } 486inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
468inline void sv_to (SV *sv, double &v) { v = SvNV (sv); } 487inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }
469inline void sv_to (SV *sv, client * &v) { v = (client *)(attachable *)SvPTR_ornull (sv, "cf::client"); } 488inline void sv_to (SV *sv, client * &v) { v = (client *)(attachable *)SvPTR_ornull (sv, "cf::client"); }
470inline void sv_to (SV *sv, player * &v) { v = (player *)(attachable *)SvPTR_ornull (sv, "cf::player"); } 489inline void sv_to (SV *sv, player * &v) { v = (player *)(attachable *)SvPTR_ornull (sv, "cf::player"); }
471inline void sv_to (SV *sv, object * &v) { v = (object *)(attachable *)SvPTR_ornull (sv, "cf::object"); } 490inline void sv_to (SV *sv, object * &v) { v = (object *)(attachable *)SvPTR_ornull (sv, "cf::object"); }
472inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)(attachable *)SvPTR_ornull (sv, "cf::arch"); } 491inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)(attachable *)SvPTR_ornull (sv, "cf::arch"); }
473inline void sv_to (SV *sv, maptile * &v) { v = (maptile *)(attachable *)SvPTR_ornull (sv, "cf::map"); } 492inline void sv_to (SV *sv, maptile * &v) { v = (maptile *)(attachable *)SvPTR_ornull (sv, "cf::map"); }
474inline void sv_to (SV *sv, region * &v) { v = (region *)(attachable *)SvPTR_ornull (sv, "cf::region"); } 493inline void sv_to (SV *sv, region * &v) { v = (region *)(attachable *)SvPTR_ornull (sv, "cf::region"); }
475inline void sv_to (SV *sv, attachable * &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); } 494inline void sv_to (SV *sv, attachable * &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); }
476inline void sv_to (SV *sv, partylist * &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); } 495inline void sv_to (SV *sv, partylist * &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }
477inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); } 496inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }
497inline void sv_to (SV *sv, mapspace * &v) { v = (mapspace *)SvPTR_ornull (sv, "cf::mapspace"); }
498inline void sv_to (SV *sv, object_freezer * &v) { v = (object_freezer *)SvPTR_ornull (sv, "cf::object::freezer"); }
499inline void sv_to (SV *sv, object_thawer * &v) { v = (object_thawer *)SvPTR_ornull (sv, "cf::object::thawer" ); }
478 500
479//inline void sv_to (SV *sv, faceinfo * &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; } 501//inline void sv_to (SV *sv, faceinfo * &v) { v = &faces [face_find (SvPV_nolen (sv), 0)]; }
480inline void sv_to (SV *sv, treasurelist * &v) { v = treasurelist::find (SvPV_nolen (sv)); } 502inline void sv_to (SV *sv, treasurelist * &v) { v = treasurelist::find (SvPV_nolen (sv)); }
481 503
482template<class T> 504template<class T>
483inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; } 505inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }
484 506
485template<int N> 507template<int N>
486inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); } 508inline void sv_to (SV *sv, char (&v)[N]) { assign (v, SvPV_nolen (sv)); }
487 509
488inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); } 510inline void sv_to (SV *sv, bowtype_t &v) { v = (bowtype_t) SvIV (sv); }
489inline void sv_to (SV *sv, petmode_t &v) { v = (petmode_t) SvIV (sv); } 511inline void sv_to (SV *sv, petmode_t &v) { v = (petmode_t) SvIV (sv); }
490inline void sv_to (SV *sv, usekeytype &v) { v = (usekeytype) SvIV (sv); } 512inline void sv_to (SV *sv, usekeytype &v) { v = (usekeytype) SvIV (sv); }
491inline void sv_to (SV *sv, unapplymode &v) { v = (unapplymode) SvIV (sv); } 513inline void sv_to (SV *sv, unapplymode &v) { v = (unapplymode) SvIV (sv); }
492 514
493inline void sv_to (SV *sv, std::string &v) 515inline void sv_to (SV *sv, std::string &v)
494{ 516{
495 STRLEN len; 517 STRLEN len;
496 char *data = SvPVbyte (sv, len); 518 char *data = SvPVbyte (sv, len);
497 v.assign (data, len); 519 v.assign (data, len);
498} 520}
499 521
500inline void sv_to (SV *sv, UUID &v) 522inline void sv_to (SV *sv, UUID &v)
501{ 523{
502 unsigned int version; 524 if (!v.parse (SvPV_nolen (sv)))
503
504 if (2 != sscanf (SvPV_nolen (sv), "<%d.%" SCNx64 ">", &version, &v.seq) || 1 != version)
505 croak ("unparsable uuid: %s", SvPV_nolen (sv)); 525 croak ("unparsable uuid: %s", SvPV_nolen (sv));
506} 526}
507 527
508inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); } 528inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }
509 529
… …
527 break; 547 break;
528 548
529 case DT_STRING: 549 case DT_STRING:
530 { 550 {
531 char *str = (char *)va_arg (ap, const char *); 551 char *str = (char *)va_arg (ap, const char *);
532 sv = str ? newSVpv (str, 0) : &PL_sv_undef; 552 sv = str ? newSVpv (str, 0) : newSV (0);
533 } 553 }
534 break; 554 break;
535 555
536 case DT_DATA: 556 case DT_DATA:
537 { 557 {
538 char *str = (char *)va_arg (ap, const void *); 558 char *str = (char *)va_arg (ap, const void *);
539 int len = va_arg (ap, int); 559 int len = va_arg (ap, int);
540 sv = str ? newSVpv (str, len) : &PL_sv_undef; 560 sv = str ? newSVpv (str, len) : newSV (0);
541 } 561 }
542 break; 562 break;
543 563
544 case DT_OBJECT: 564 case DT_OBJECT:
545 sv = to_sv (va_arg (ap, object *)); 565 sv = to_sv (va_arg (ap, object *));
… …
587 va_end (ap); 607 va_end (ap);
588 608
589 return sv; 609 return sv;
590} 610}
591 611
592static SV * 612// typemap support, mostly to avoid excessive inlining
593newSVcfapi (int type, ...) 613template<class type>
614static void noinline
615cf_obj_to (SV *arg, type &var)
594{ 616{
595 SV *sv; 617 sv_to (arg, var);
618 if (!var)
619 croak ("must not pass invalid/null cf_obj here");
620}
596 621
597 va_list ap; 622template<class object>
598 va_start (ap, type); 623static void noinline
599 624cf_obj_ornull_to (SV *arg, object *&var)
600 switch (type) 625{
626 if (SvOK (arg))
601 { 627 {
602 case CFAPI_INT: sv = newSViv (*va_arg (ap, int * )); break; 628 sv_to (arg, var);
603 case CFAPI_LONG: sv = newSVval64 (*va_arg (ap, sint64 *)); break; 629 if (!var)
604 case CFAPI_DOUBLE: sv = newSVnv (*va_arg (ap, double *)); break; 630 croak ("unable to convert perl object to C++ object");
605 case CFAPI_STRING: sv = newSVdt_va (ap, DT_STRING); break;
606 case CFAPI_POBJECT: sv = newSVdt_va (ap, DT_OBJECT); break;
607 case CFAPI_PMAP: sv = newSVdt_va (ap, DT_MAP ); break;
608 case CFAPI_PPLAYER: sv = newSVdt_va (ap, DT_PLAYER); break;
609 case CFAPI_PARCH: sv = newSVdt_va (ap, DT_ARCH ); break;
610 case CFAPI_PPARTY: sv = newSVdt_va (ap, DT_PARTY ); break;
611 case CFAPI_PREGION: sv = newSVdt_va (ap, DT_REGION); break;
612
613 default:
614 assert (("unhandled type in newSVcfapi", 0));
615 } 631 }
616 632 else
617 va_end (ap); 633 var = 0;
618
619 return sv;
620} 634}
621 635
622////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 636//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
623 637
624SV * 638SV *
… …
630 return newRV_inc ((SV *)ext->cb); 644 return newRV_inc ((SV *)ext->cb);
631} 645}
632 646
633///////////////////////////////////////////////////////////////////////////// 647/////////////////////////////////////////////////////////////////////////////
634 648
635extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
636{
637 return 0;
638}
639
640static CommArray_s rtn_cmd;
641
642static int
643runPluginCommand (object *obj, char *params)
644{
645 return -1;
646}
647
648extern "C" void *cfperl_getPluginProperty (int *type, ...)
649{
650 va_list args;
651 char *propname;
652 int i;
653 va_start (args, type);
654 propname = va_arg (args, char *);
655 //printf ("Property name: %s\n", propname);
656
657 if (!strcmp (propname, "command?"))
658 return NULL;
659 else if (!strcmp (propname, "Identification"))
660 {
661 va_end (args);
662 return (void *)PLUGIN_NAME;
663 }
664 else if (!strcmp (propname, "FullName"))
665 {
666 va_end (args);
667 return (void *)PLUGIN_VERSION;
668 }
669 else
670 va_end (args);
671
672 return NULL;
673}
674
675extern "C" int cfperl_postInitPlugin ()
676{
677 int hooktype = 1;
678 int rtype = 0;
679
680 cf_init_plugin (gethook);
681
682 return 0;
683}
684
685extern "C" int cfperl_closePlugin ()
686{
687 return 0;
688}
689
690void 649void
691cfperl_init () 650cfperl_init ()
692{ 651{
652 extern char **environ;
653
693 PERL_SYS_INIT3 (&settings.argc, &settings.argv, 0); 654 PERL_SYS_INIT3 (&settings.argc, &settings.argv, &environ);
694 perl = perl_alloc (); 655 perl = perl_alloc ();
695 perl_construct (perl); 656 perl_construct (perl);
696 657
697 PL_exit_flags |= PERL_EXIT_DESTRUCT_END; 658 PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
698 659
699 const char *argv[] = { 660 const char *argv[] = {
700 settings.argv [0], 661 settings.argv [0],
701 "-e" 662 "-e0"
702 "use Event; use Coro;" // required for bootstrap
703 "cf->bootstrap;" // required for datadir :*>
704 "unshift @INC, cf::datadir ();"
705 "require cf;"
706 }; 663 };
707 664
708 if (perl_parse (perl, xs_init, 2, (char **)argv, (char **)NULL) 665 if (perl_parse (perl, xs_init, 2, (char **)argv, environ)
709 || perl_run (perl)) 666 || perl_run (perl))
710 { 667 {
711 printf ("unable to initialize perl-interpreter, aborting.\n"); 668 printf ("unable to initialize perl-interpreter, aborting.\n");
712 exit (EXIT_FAILURE); 669 exit (EXIT_FAILURE);
713 } 670 }
714 671
672 eval_pv (
673 "#line 1 'cfperl init'\n"
674 "use EV ();\n"
675 "use Coro ();\n"
676 "cf->bootstrap;\n"
677 "unshift @INC, cf::datadir ();\n"
678 "require cf;\n",
679 0
680 );
681
682 if (SvTRUE (ERRSV))
715 { 683 {
716 dSP; 684 printf ("unable to bootstrap perl, aborting:\n%s", SvPV_nolen (ERRSV));
717 685 exit (EXIT_FAILURE);
718 PUSHMARK (SP);
719 PUTBACK;
720 call_pv ("cf::init", G_DISCARD | G_VOID);
721 } 686 }
722} 687}
723 688
689void
724void cfperl_main () 690cfperl_main ()
725{ 691{
726 dSP; 692 dSP;
727 693
728 PUSHMARK (SP); 694 PUSHMARK (SP);
729 PUTBACK; 695 PUTBACK;
… …
754# undef def 720# undef def
755}; 721};
756 722
757#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE) 723#define KLASS_OF(event) (((unsigned int)event) < NUM_EVENT_TYPES ? klass_of [event] : KLASS_NONE)
758 724
759static void 725static void noinline
760gather_callbacks (AV *&callbacks, AV *registry, event_type event) 726gather_callbacks (AV *&callbacks, AV *registry, event_type event)
761{ 727{
762 // event must be in array 728 // event must be in array
763 if (event >= 0 && event <= AvFILLp (registry)) 729 if (event >= 0 && event <= AvFILLp (registry))
764 { 730 {
… …
850{ 816{
851 attachable::gather_callbacks (callbacks, event); 817 attachable::gather_callbacks (callbacks, event);
852 ::gather_callbacks (callbacks, cb_map, event); 818 ::gather_callbacks (callbacks, cb_map, event);
853} 819}
854 820
855void 821static void noinline
856_recalc_want (bitset<NUM_EVENT_TYPES> &set, AV *registry) 822_recalc_want (bitset<NUM_EVENT_TYPES> &set, AV *registry)
857{ 823{
858 for (int event = 0; event <= AvFILLp (registry); ++event) 824 for (int event = 0; event <= AvFILLp (registry); ++event)
859 { 825 {
860 SV *cbs_ = AvARRAY (registry)[event]; 826 SV *cbs_ = AvARRAY (registry)[event];
… …
870 } 836 }
871 } 837 }
872} 838}
873 839
874// very slow and inefficient way to recalculate the global want bitsets 840// very slow and inefficient way to recalculate the global want bitsets
875void 841static void
876_recalc_want () 842_recalc_want ()
877{ 843{
878 ev_want_event.reset (); 844 ev_want_event.reset ();
879 845
880 _recalc_want (ev_want_event, cb_global); 846 _recalc_want (ev_want_event, cb_global);
… …
988{ 954{
989 return SvNV (cfperl_result (idx)); 955 return SvNV (cfperl_result (idx));
990} 956}
991 957
992///////////////////////////////////////////////////////////////////////////// 958/////////////////////////////////////////////////////////////////////////////
959// various c++ => perl glue functions
960
961void
962cfperl_tick ()
963{
964 tick_pending = 1;
965
966 if (tick_inhibit)
967 return;
968
969 tick_pending = 0;
970
971 dSP;
972
973 PUSHMARK (SP);
974 PUTBACK;
975 call_pv ("cf::tick", G_DISCARD | G_VOID);
976
977 SvNV_set (sv_next_tick, get_next_tick ()); SvNOK_only (sv_next_tick);
978}
993 979
994void 980void
995cfperl_emergency_save () 981cfperl_emergency_save ()
996{ 982{
997 CALL_BEGIN (0); 983 CALL_BEGIN (0);
… …
1043 CALL_END; 1029 CALL_END;
1044 1030
1045 return can; 1031 return can;
1046} 1032}
1047 1033
1034void
1035cfperl_mapscript_activate (object *ob, bool state, object *activator, object *originator)
1036{
1037 CALL_BEGIN (4);
1038 CALL_ARG (ob);
1039 CALL_ARG (state);
1040 CALL_ARG (activator);
1041 CALL_ARG (originator);
1042 CALL_CALL ("cf::mapscript::activate", G_VOID);
1043 CALL_END;
1044}
1045
1046player *
1047player::find (const char *name)
1048{
1049 CALL_BEGIN (1);
1050 CALL_ARG (name);
1051 CALL_CALL ("cf::player::find", G_SCALAR);
1052
1053 player *retval = 0;
1054 if (count) sv_to (POPs, retval);
1055
1056 CALL_END;
1057
1058 return retval;
1059}
1060
1061maptile *
1062find_style (const char *dirname, const char *stylename, int difficulty)
1063{
1064 CALL_BEGIN (3);
1065 CALL_ARG (dirname);
1066 CALL_ARG (stylename);
1067 CALL_ARG (difficulty);
1068 CALL_CALL ("ext::map_random::find_style", G_SCALAR);
1069
1070 maptile *retval = 0;
1071 if (count) sv_to (POPs, retval);
1072
1073 CALL_END;
1074
1075 return retval;
1076}
1077
1048maptile * 1078maptile *
1049maptile::find_sync (const char *path, maptile *origin) 1079maptile::find_sync (const char *path, maptile *origin)
1050{ 1080{
1051 CALL_BEGIN (2); 1081 CALL_BEGIN (2);
1052 CALL_ARG (path); 1082 CALL_ARG (path);
1053 CALL_ARG (origin); 1083 CALL_ARG (origin);
1054 CALL_CALL ("cf::map::find_sync", G_SCALAR); 1084 CALL_CALL ("cf::map::find_sync", G_SCALAR);
1055 1085
1056 maptile *retval; 1086 maptile *retval = 0;
1057
1058 if (count)
1059 sv_to (POPs, retval); 1087 if (count) sv_to (POPs, retval);
1060 else
1061 retval = 0;
1062 1088
1063 CALL_END; 1089 CALL_END;
1064 1090
1065 return retval; 1091 return retval;
1066} 1092}
1067 1093
1068maptile * 1094maptile *
1069maptile::find_async (const char *path, maptile *origin) 1095maptile::find_async (const char *path, maptile *origin, bool load)
1070{ 1096{
1071 CALL_BEGIN (2); 1097 CALL_BEGIN (3);
1072 CALL_ARG (path); 1098 CALL_ARG (path);
1073 CALL_ARG (origin); 1099 CALL_ARG (origin);
1100 CALL_ARG (load);
1074 CALL_CALL ("cf::map::find_async", G_SCALAR); 1101 CALL_CALL ("cf::map::find_async", G_SCALAR);
1075 1102
1076 maptile *retval; 1103 maptile *retval = 0;
1077
1078 if (count)
1079 sv_to (POPs, retval); 1104 if (count) sv_to (POPs, retval);
1080 else
1081 retval = 0;
1082 1105
1083 CALL_END; 1106 CALL_END;
1084 1107
1085 return retval; 1108 return retval;
1086} 1109}
… …
1089maptile::do_load_sync () 1112maptile::do_load_sync ()
1090{ 1113{
1091 CALL_BEGIN (1); 1114 CALL_BEGIN (1);
1092 CALL_ARG (this); 1115 CALL_ARG (this);
1093 CALL_CALL ("cf::map::do_load_sync", G_SCALAR); 1116 CALL_CALL ("cf::map::do_load_sync", G_SCALAR);
1094 CALL_END;
1095}
1096
1097void
1098maptile::change_all_map_light (int change)
1099{
1100 CALL_BEGIN (1);
1101 CALL_ARG (change);
1102 CALL_CALL ("cf::map::change_all_map_light", G_VOID);
1103 CALL_END; 1117 CALL_END;
1104} 1118}
1105 1119
1106void 1120void
1107object::enter_exit (object *exit) 1121object::enter_exit (object *exit)
… …
1112 CALL_BEGIN (2); 1126 CALL_BEGIN (2);
1113 CALL_ARG (this); 1127 CALL_ARG (this);
1114 CALL_ARG (exit); 1128 CALL_ARG (exit);
1115 CALL_CALL ("cf::object::player::enter_exit", G_VOID); 1129 CALL_CALL ("cf::object::player::enter_exit", G_VOID);
1116 CALL_END; 1130 CALL_END;
1131}
1132
1133void
1134object::player_goto (const char *path, int x, int y)
1135{
1136 if (type != PLAYER)
1137 return;
1138
1139 CALL_BEGIN (4);
1140 CALL_ARG (this);
1141 CALL_ARG (path);
1142 CALL_ARG (x);
1143 CALL_ARG (y);
1144 CALL_CALL ("cf::object::player::goto", G_VOID);
1145 CALL_END;
1146}
1147
1148const char *
1149object::ref () const
1150{
1151 if (type == PLAYER)
1152 return format ("player/<1.%llx>/%s", (unsigned long long)uuid.seq, &name);
1153 else
1154 return 0;
1155}
1156
1157object *
1158object::deref (const char *ref)
1159{
1160 object *retval = 0;
1161
1162 if (ref)
1163 {
1164 CALL_BEGIN (1);
1165 CALL_ARG (ref);
1166 CALL_CALL ("cf::object::deref", G_SCALAR);
1167
1168 if (count)
1169 sv_to (POPs, retval);
1170
1171 CALL_END;
1172 }
1173
1174 return retval;
1117} 1175}
1118 1176
1119void 1177void
1120log_backtrace (const char *msg) 1178log_backtrace (const char *msg)
1121{ 1179{
… …
1132#endif 1190#endif
1133} 1191}
1134 1192
1135///////////////////////////////////////////////////////////////////////////// 1193/////////////////////////////////////////////////////////////////////////////
1136 1194
1137struct EventAPI *watcher_base::GEventAPI; 1195struct EVAPI *evapi::GEVAPI;
1138struct CoroAPI *coroapi::GCoroAPI; 1196struct CoroAPI *coroapi::GCoroAPI;
1139 1197
1140int coroapi::cede_counter; 1198void
1141tstamp coroapi::next_cede;
1142
1143void coroapi::do_cede_to_tick () 1199coroapi::do_cede_to_tick ()
1144{ 1200{
1145 cede_counter = 0; 1201 cede_pending = 0;
1146
1147 cede (); 1202 cede ();
1148
1149 next_cede += (TICK / CEDES_PER_TICK) * 0.99;
1150 if (next_cede > SvNV (sv_next_tick) - 0.02)
1151 next_cede = SvNV (sv_next_tick);
1152}
1153
1154void coroapi::do_cede_every ()
1155{
1156 cede_counter = 0;
1157
1158 if (coroapi::nready ())
1159 coroapi::cede ();
1160}
1161
1162void coroapi::do_cede_to_tick_every ()
1163{
1164 cede_counter = 0;
1165
1166 cede_to_tick ();
1167} 1203}
1168 1204
1169void 1205void
1170coroapi::wait_for_tick () 1206coroapi::wait_for_tick ()
1171{ 1207{
… …
1180 CALL_BEGIN (0); 1216 CALL_BEGIN (0);
1181 CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD); 1217 CALL_CALL ("cf::wait_for_tick_begin", G_DISCARD);
1182 CALL_END; 1218 CALL_END;
1183} 1219}
1184 1220
1221void
1222iow::poll (int events)
1223{
1224 if (events != this->events)
1225 {
1226 int active = ev_is_active ((ev_io *)this);
1227 if (active) stop ();
1228 ev_io_set ((ev_io *)this, fd, events);
1229 if (active) start ();
1230 }
1231}
1232
1185static void 1233static void
1186iw_dispatch (pe_event *ev)
1187{
1188 iw *w = (iw *)ev->ext_data;
1189 w->call (*w);
1190}
1191
1192void
1193iw::alloc ()
1194{
1195 pe = GEventAPI->new_idle (0, 0);
1196
1197 WaREENTRANT_off (pe);
1198 pe->base.callback = (void *)iw_dispatch;
1199 pe->base.ext_data = (void *)this;
1200}
1201
1202static void iow_dispatch (pe_event *ev)
1203{
1204 iow *w = (iow *)ev->ext_data;
1205 w->call (*w, ((pe_ioevent *)ev)->got);
1206}
1207
1208void
1209iow::alloc ()
1210{
1211 pe = GEventAPI->new_io (0, 0);
1212
1213 WaREENTRANT_off (pe);
1214 pe->base.callback = (void *)iow_dispatch;
1215 pe->base.ext_data = (void *)this;
1216
1217 pe->fd = -1;
1218 pe->poll = 0;
1219}
1220
1221void
1222iow::fd (int fd)
1223{
1224 pe->fd = fd;
1225}
1226
1227int
1228iow::poll ()
1229{
1230 return pe->poll;
1231}
1232
1233void
1234iow::poll (int events)
1235{
1236 if (pe->poll != events)
1237 {
1238 if (pe->poll) stop ();
1239 pe->poll = events;
1240 if (pe->poll) start ();
1241 }
1242}
1243
1244void
1245_connect_to_perl () 1234_connect_to_perl ()
1246{ 1235{
1247 stash_cf = gv_stashpv ("cf" , 1); 1236 stash_cf = gv_stashpv ("cf", 1);
1248 1237
1249 stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1); 1238 stash_cf_object_wrap = gv_stashpv ("cf::object::wrap", 1);
1250 stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1); 1239 stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);
1251 stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1); 1240 stash_cf_player_wrap = gv_stashpv ("cf::player::wrap", 1);
1252 stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1); 1241 stash_cf_map_wrap = gv_stashpv ("cf::map::wrap" , 1);
1242 stash_cf_mapspace_wrap = gv_stashpv ("cf::mapspace::wrap" , 1);
1253 stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1); 1243 stash_cf_client_wrap = gv_stashpv ("cf::client::wrap", 1);
1254 stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1); 1244 stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
1255 stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1); 1245 stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
1256 stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1); 1246 stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
1257 stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1); 1247 stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
1258 1248
1249 sv_now = get_sv ("cf::NOW" , 1); SvUPGRADE (sv_now , SVt_NV);
1259 sv_runtime = get_sv ("cf::RUNTIME" , 1); sv_upgrade (sv_runtime , SVt_NV); 1250 sv_runtime = get_sv ("cf::RUNTIME" , 1); SvUPGRADE (sv_runtime , SVt_NV);
1251 sv_tick_start = get_sv ("cf::TICK_START", 1); SvUPGRADE (sv_tick_start, SVt_NV);
1260 sv_next_tick = get_sv ("cf::NEXT_TICK", 1); sv_upgrade (sv_next_tick, SVt_NV); 1252 sv_next_tick = get_sv ("cf::NEXT_TICK" , 1); SvUPGRADE (sv_next_tick , SVt_NV);
1261 1253
1262 cb_global = get_av ("cf::CB_GLOBAL", 1); 1254 cb_global = get_av ("cf::CB_GLOBAL", 1);
1263 cb_attachable = get_av ("cf::CB_ATTACHABLE", 1); 1255 cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
1264 cb_object = get_av ("cf::CB_OBJECT", 1); 1256 cb_object = get_av ("cf::CB_OBJECT", 1);
1265 cb_player = get_av ("cf::CB_PLAYER", 1); 1257 cb_player = get_av ("cf::CB_PLAYER", 1);
… …
1270 1262
1271MODULE = cf PACKAGE = cf PREFIX = cf_ 1263MODULE = cf PACKAGE = cf PREFIX = cf_
1272 1264
1273BOOT: 1265BOOT:
1274{ 1266{
1275 I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI; 1267 I_EV_API (PACKAGE); evapi::GEVAPI = GEVAPI;
1276 I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI; 1268 I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
1277 1269
1278 _connect_to_perl (); 1270 _connect_to_perl ();
1279 1271
1280 newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1)); 1272 newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
1281 1273
… …
1299 const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd) 1291 const_iv (Map0Cmd) const_iv (Map1Cmd) const_iv (Map1aCmd)
1300 1292
1301 const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y) 1293 const_iv (MAP_CLIENT_X) const_iv (MAP_CLIENT_Y)
1302 1294
1303 const_iv (MAX_TIME) 1295 const_iv (MAX_TIME)
1296 const_iv (MAXSOCKBUF)
1304 1297
1305 const_iv (NUM_BODY_LOCATIONS) 1298 const_iv (NUM_BODY_LOCATIONS)
1306 const_iv (body_range) const_iv (body_shield) const_iv (body_combat) 1299 const_iv (body_range) const_iv (body_shield) const_iv (body_combat)
1307 const_iv (body_arm) const_iv (body_torso) const_iv (body_head) 1300 const_iv (body_arm) const_iv (body_torso) const_iv (body_head)
1308 const_iv (body_neck) const_iv (body_skill) const_iv (body_finger) 1301 const_iv (body_neck) const_iv (body_skill) const_iv (body_finger)
… …
1335 const_iv (FORCE) const_iv (POTION_EFFECT) const_iv (EVENT_CONNECTOR) const_iv (CLOSE_CON) 1328 const_iv (FORCE) const_iv (POTION_EFFECT) const_iv (EVENT_CONNECTOR) const_iv (CLOSE_CON)
1336 const_iv (CONTAINER) const_iv (ARMOUR_IMPROVER) const_iv (WEAPON_IMPROVER) const_iv (SKILLSCROLL) 1329 const_iv (CONTAINER) const_iv (ARMOUR_IMPROVER) const_iv (WEAPON_IMPROVER) const_iv (SKILLSCROLL)
1337 const_iv (DEEP_SWAMP) const_iv (IDENTIFY_ALTAR) const_iv (MENU) const_iv (RUNE) 1330 const_iv (DEEP_SWAMP) const_iv (IDENTIFY_ALTAR) const_iv (MENU) const_iv (RUNE)
1338 const_iv (TRAP) const_iv (POWER_CRYSTAL) const_iv (CORPSE) const_iv (DISEASE) 1331 const_iv (TRAP) const_iv (POWER_CRYSTAL) const_iv (CORPSE) const_iv (DISEASE)
1339 const_iv (SYMPTOM) const_iv (BUILDER) const_iv (MATERIAL) const_iv (ITEM_TRANSFORMER) 1332 const_iv (SYMPTOM) const_iv (BUILDER) const_iv (MATERIAL) const_iv (ITEM_TRANSFORMER)
1333 const_iv (MAPSCRIPT) const_iv (SAFE_GROUND)
1340 1334
1341 const_iv (NUM_TYPES) const_iv (NUM_SUBTYPES) 1335 const_iv (NUM_TYPES) const_iv (NUM_SUBTYPES)
1342 1336
1343 const_iv (ST_BD_BUILD) const_iv (ST_BD_REMOVE) 1337 const_iv (ST_BD_BUILD) const_iv (ST_BD_REMOVE)
1344 const_iv (ST_MAT_FLOOR) const_iv (ST_MAT_WALL) const_iv (ST_MAT_ITEM) 1338 const_iv (ST_MAT_FLOOR) const_iv (ST_MAT_WALL) const_iv (ST_MAT_ITEM)
… …
1374 const_iv (FLAG_CURSED) const_iv (FLAG_DAMNED) const_iv (FLAG_SEE_ANYWHERE) const_iv (FLAG_KNOWN_MAGICAL) 1368 const_iv (FLAG_CURSED) const_iv (FLAG_DAMNED) const_iv (FLAG_SEE_ANYWHERE) const_iv (FLAG_KNOWN_MAGICAL)
1375 const_iv (FLAG_KNOWN_CURSED) const_iv (FLAG_CAN_USE_SKILL) const_iv (FLAG_BEEN_APPLIED) const_iv (FLAG_READY_SCROLL) 1369 const_iv (FLAG_KNOWN_CURSED) const_iv (FLAG_CAN_USE_SKILL) const_iv (FLAG_BEEN_APPLIED) const_iv (FLAG_READY_SCROLL)
1376 const_iv (FLAG_USE_ROD) const_iv (FLAG_USE_HORN) const_iv (FLAG_MAKE_INVIS) const_iv (FLAG_INV_LOCKED) 1370 const_iv (FLAG_USE_ROD) const_iv (FLAG_USE_HORN) const_iv (FLAG_MAKE_INVIS) const_iv (FLAG_INV_LOCKED)
1377 const_iv (FLAG_IS_WOODED) const_iv (FLAG_IS_HILLY) const_iv (FLAG_READY_SKILL) const_iv (FLAG_READY_WEAPON) 1371 const_iv (FLAG_IS_WOODED) const_iv (FLAG_IS_HILLY) const_iv (FLAG_READY_SKILL) const_iv (FLAG_READY_WEAPON)
1378 const_iv (FLAG_NO_SKILL_IDENT) const_iv (FLAG_BLIND) const_iv (FLAG_SEE_IN_DARK) const_iv (FLAG_IS_CAULDRON) 1372 const_iv (FLAG_NO_SKILL_IDENT) const_iv (FLAG_BLIND) const_iv (FLAG_SEE_IN_DARK) const_iv (FLAG_IS_CAULDRON)
1379 const_iv (FLAG_NO_STEAL) const_iv (FLAG_ONE_HIT) const_iv (FLAG_CLIENT_SENT) const_iv (FLAG_BERSERK) 1373 const_iv (FLAG_NO_STEAL) const_iv (FLAG_ONE_HIT) const_iv (FLAG_DEBUG) const_iv (FLAG_BERSERK)
1380 const_iv (FLAG_NEUTRAL) const_iv (FLAG_NO_ATTACK) const_iv (FLAG_NO_DAMAGE) const_iv (FLAG_OBJ_ORIGINAL) 1374 const_iv (FLAG_NEUTRAL) const_iv (FLAG_NO_ATTACK) const_iv (FLAG_NO_DAMAGE) const_iv (FLAG_OBJ_ORIGINAL)
1381 const_iv (FLAG_OBJ_SAVE_ON_OVL) const_iv (FLAG_ACTIVATE_ON_PUSH) const_iv (FLAG_ACTIVATE_ON_RELEASE) const_iv (FLAG_IS_WATER) 1375 const_iv (FLAG_ACTIVATE_ON_PUSH) const_iv (FLAG_ACTIVATE_ON_RELEASE) const_iv (FLAG_IS_WATER) const_iv (FLAG_WIZLOOK)
1382 const_iv (FLAG_CONTENT_ON_GEN) const_iv (FLAG_IS_A_TEMPLATE) const_iv (FLAG_IS_BUILDABLE) 1376 const_iv (FLAG_CONTENT_ON_GEN) const_iv (FLAG_IS_A_TEMPLATE) const_iv (FLAG_IS_BUILDABLE)
1383 const_iv (FLAG_DESTROY_ON_DEATH) const_iv (FLAG_NO_MAP_SAVE) 1377 const_iv (FLAG_DESTROY_ON_DEATH) const_iv (FLAG_NO_MAP_SAVE)
1384 1378
1385 const_iv (NDI_BLACK) const_iv (NDI_WHITE) const_iv (NDI_NAVY) const_iv (NDI_RED) 1379 const_iv (NDI_BLACK) const_iv (NDI_WHITE) const_iv (NDI_NAVY) const_iv (NDI_RED)
1386 const_iv (NDI_ORANGE) const_iv (NDI_BLUE) const_iv (NDI_DK_ORANGE) const_iv (NDI_GREEN) 1380 const_iv (NDI_ORANGE) const_iv (NDI_BLUE) const_iv (NDI_DK_ORANGE) const_iv (NDI_GREEN)
1387 const_iv (NDI_LT_GREEN) const_iv (NDI_GREY) const_iv (NDI_BROWN) const_iv (NDI_GOLD) 1381 const_iv (NDI_LT_GREEN) const_iv (NDI_GREY) const_iv (NDI_BROWN) const_iv (NDI_GOLD)
1388 const_iv (NDI_TAN) const_iv (NDI_MAX_COLOR) const_iv (NDI_COLOR_MASK) const_iv (NDI_UNIQUE) 1382 const_iv (NDI_TAN) const_iv (NDI_MAX_COLOR) const_iv (NDI_COLOR_MASK) const_iv (NDI_UNIQUE)
1389 const_iv (NDI_ALL) 1383 const_iv (NDI_ALL) const_iv (NDI_DEF) const_iv (NDI_REPLY) const_iv (NDI_CLIENT_MASK)
1384 const_iv (NDI_NOCREATE) const_iv (NDI_CLEAR) const_iv (NDI_VERBATIM)
1390 1385
1391 const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE) 1386 const_iv (UPD_LOCATION) const_iv (UPD_FLAGS) const_iv (UPD_WEIGHT) const_iv (UPD_FACE)
1392 const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF) 1387 const_iv (UPD_NAME) const_iv (UPD_ANIM) const_iv (UPD_ANIMSPEED) const_iv (UPD_NROF)
1393 1388
1394 const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_DAMAGE) 1389 const_iv (UPD_SP_MANA) const_iv (UPD_SP_GRACE) const_iv (UPD_SP_DAMAGE)
… …
1446 const_iv (F_CURSED) const_iv (F_DAMNED) const_iv (F_OPEN) const_iv (F_NOPICK) 1441 const_iv (F_CURSED) const_iv (F_DAMNED) const_iv (F_OPEN) const_iv (F_NOPICK)
1447 const_iv (F_LOCKED) 1442 const_iv (F_LOCKED)
1448 1443
1449 const_iv (F_BUY) const_iv (F_SHOP) const_iv (F_SELL) 1444 const_iv (F_BUY) const_iv (F_SHOP) const_iv (F_SELL)
1450 1445
1451 const_iv (P_BLOCKSVIEW) const_iv (P_PLAYER) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE) 1446 const_iv (P_BLOCKSVIEW) const_iv (P_NO_MAGIC) const_iv (P_IS_ALIVE)
1452 const_iv (P_NO_CLERIC) const_iv (P_OUT_OF_MAP) const_iv (P_NEW_MAP) const_iv (P_UPTODATE) 1447 const_iv (P_NO_CLERIC) const_iv (P_OUT_OF_MAP) const_iv (P_NEW_MAP) const_iv (P_UPTODATE)
1453 1448
1454 const_iv (UP_OBJ_INSERT) const_iv (UP_OBJ_REMOVE) const_iv (UP_OBJ_CHANGE) const_iv (UP_OBJ_FACE) 1449 const_iv (UP_OBJ_INSERT) const_iv (UP_OBJ_REMOVE) const_iv (UP_OBJ_CHANGE) const_iv (UP_OBJ_FACE)
1455 1450
1456 const_iv (INS_NO_MERGE) const_iv (INS_ABOVE_FLOOR_ONLY) const_iv (INS_NO_WALK_ON) 1451 const_iv (INS_NO_MERGE) const_iv (INS_ABOVE_FLOOR_ONLY) const_iv (INS_NO_WALK_ON)
1457 const_iv (INS_ON_TOP) const_iv (INS_BELOW_ORIGINATOR) const_iv (INS_MAP_LOAD) 1452 const_iv (INS_ON_TOP) const_iv (INS_BELOW_ORIGINATOR)
1458 1453
1459 const_iv (WILL_APPLY_HANDLE) const_iv (WILL_APPLY_TREASURE) const_iv (WILL_APPLY_EARTHWALL) 1454 const_iv (WILL_APPLY_HANDLE) const_iv (WILL_APPLY_TREASURE) const_iv (WILL_APPLY_EARTHWALL)
1460 const_iv (WILL_APPLY_DOOR) const_iv (WILL_APPLY_FOOD) 1455 const_iv (WILL_APPLY_DOOR) const_iv (WILL_APPLY_FOOD)
1461 1456
1462 const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE) 1457 const_iv (SAVE_MODE) const_iv (SAVE_DIR_MODE)
… …
1496 const_iv (ATNR_PARALYZE) const_iv (ATNR_TURN_UNDEAD) const_iv (ATNR_FEAR) const_iv (ATNR_CANCELLATION) 1491 const_iv (ATNR_PARALYZE) const_iv (ATNR_TURN_UNDEAD) const_iv (ATNR_FEAR) const_iv (ATNR_CANCELLATION)
1497 const_iv (ATNR_DEPLETE) const_iv (ATNR_DEATH) const_iv (ATNR_CHAOS) const_iv (ATNR_COUNTERSPELL) 1492 const_iv (ATNR_DEPLETE) const_iv (ATNR_DEATH) const_iv (ATNR_CHAOS) const_iv (ATNR_COUNTERSPELL)
1498 const_iv (ATNR_GODPOWER) const_iv (ATNR_HOLYWORD) const_iv (ATNR_BLIND) const_iv (ATNR_INTERNAL) 1493 const_iv (ATNR_GODPOWER) const_iv (ATNR_HOLYWORD) const_iv (ATNR_BLIND) const_iv (ATNR_INTERNAL)
1499 const_iv (ATNR_LIFE_STEALING) const_iv (ATNR_DISEASE) 1494 const_iv (ATNR_LIFE_STEALING) const_iv (ATNR_DISEASE)
1500 1495
1501 const_iv (MAP_IN_MEMORY) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING) 1496 const_iv (MAP_ACTIVE) const_iv (MAP_SWAPPED) const_iv (MAP_LOADING) const_iv (MAP_SAVING)
1497 const_iv (MAP_INACTIVE)
1502 1498
1503 const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT) 1499 const_iv (KLASS_ATTACHABLE) const_iv (KLASS_GLOBAL) const_iv (KLASS_OBJECT)
1504 const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP) 1500 const_iv (KLASS_CLIENT) const_iv (KLASS_PLAYER) const_iv (KLASS_MAP)
1501
1502 const_iv (VERSION_CS) const_iv (VERSION_SC)
1505 1503
1506 const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT) 1504 const_iv (CS_QUERY_YESNO) const_iv (CS_QUERY_SINGLECHAR) const_iv (CS_QUERY_HIDEINPUT)
1507 1505
1508 const_iv (ST_DEAD) const_iv (ST_SETUP) const_iv (ST_PLAYING) const_iv (ST_CUSTOM) 1506 const_iv (ST_DEAD) const_iv (ST_SETUP) const_iv (ST_PLAYING) const_iv (ST_CUSTOM)
1509 1507
… …
1519 1517
1520 const_iv (SYMMETRY_RANDOM) const_iv (SYMMETRY_NONE) const_iv (SYMMETRY_X) 1518 const_iv (SYMMETRY_RANDOM) const_iv (SYMMETRY_NONE) const_iv (SYMMETRY_X)
1521 const_iv (SYMMETRY_Y) const_iv (SYMMETRY_XY) 1519 const_iv (SYMMETRY_Y) const_iv (SYMMETRY_XY)
1522 1520
1523 const_iv (GT_ENVIRONMENT) const_iv (GT_INVISIBLE) const_iv (GT_STARTEQUIP) 1521 const_iv (GT_ENVIRONMENT) const_iv (GT_INVISIBLE) const_iv (GT_STARTEQUIP)
1524 const_iv (GT_APPLY) const_iv (GT_ONLY_GOOD) const_iv (GT_UPDATE_INV) 1522 const_iv (GT_APPLY) const_iv (GT_ONLY_GOOD) const_iv (GT_MINIMAL)
1525 const_iv (GT_MINIMAL) 1523
1524 const_iv (FT_FACE) const_iv (FT_MUSIC) const_iv (FT_SOUND)
1525 const_iv (FT_RSRC) const_iv (FT_NUM)
1526 }; 1526 };
1527 1527
1528 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 1528 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1529 newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv)); 1529 newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1530 1530
… …
1549 av_store (av, eiv->iv, newRV_noinc ((SV *)event)); 1549 av_store (av, eiv->iv, newRV_noinc ((SV *)event));
1550 newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv)); 1550 newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));
1551 } 1551 }
1552} 1552}
1553 1553
1554void _gv_clear (SV *gv)
1555 CODE:
1556 assert (SvTYPE (gv) == SVt_PVGV);
1557# define f(sv) { SV *sv_ = (SV *)(sv); sv = 0; SvREFCNT_dec (sv_); }
1558 f (GvGP (gv)->gp_form);
1559 f (GvGP (gv)->gp_io);
1560 f (GvGP (gv)->gp_sv);
1561 f (GvGP (gv)->gp_av);
1562 f (GvGP (gv)->gp_hv);
1563 f (GvGP (gv)->gp_cv);
1564 GvCVGEN (gv) = 0;
1565 GvMULTI_off (gv);
1566# undef f
1567
1554void _connect_to_perl () 1568void _connect_to_perl ()
1555 1569
1556void _recalc_want () 1570void _recalc_want ()
1557 1571
1572# not used by default anymore
1558void _global_reattach () 1573void _global_reattach ()
1559 CODE: 1574 CODE:
1560{ 1575{
1561 // reattach to all attachable objects in the game. 1576 // reattach to all attachable objects in the game.
1562 for_all_clients (ns) 1577 for_all_clients (ns)
… …
1606 } 1621 }
1607 1622
1608 SvCUR_set (data_sv, dst - SvPVX (data_sv)); 1623 SvCUR_set (data_sv, dst - SvPVX (data_sv));
1609} 1624}
1610 1625
1626void init_anim ()
1627
1628void init_globals ()
1629
1630void init_experience ()
1631
1632void init_attackmess ()
1633
1634void init_dynamic ()
1635
1636void load_settings ()
1637
1638void load_materials ()
1639
1640void init_uuid ()
1641 CODE:
1642 UUID::init ();
1643
1644void init_signals ()
1645
1646void init_commands ()
1647
1648void init_skills ()
1649
1650void init_beforeplay ()
1651
1652void evthread_start (int aiofd)
1653
1611void _post_tick () 1654void cede_to_tick ()
1612 CODE: 1655 CODE:
1613 coroapi::next_cede = SvNV (sv_next_tick) - TICK * (1. - 1. / CEDES_PER_TICK); 1656 coroapi::cede_to_tick ();
1614 1657
1615NV till_cede () 1658NV till_tick ()
1616 CODE: 1659 CODE:
1617 RETVAL = coroapi::next_cede - now (); 1660 RETVAL = SvNVX (sv_next_tick) - now ();
1618 OUTPUT: 1661 OUTPUT:
1619 RETVAL 1662 RETVAL
1620 1663
1621NV till_tick () 1664int tick_inhibit ()
1622 CODE: 1665 CODE:
1623 RETVAL = SvNV (sv_next_tick) - now (); 1666 RETVAL = tick_inhibit;
1624 OUTPUT: 1667 OUTPUT:
1625 RETVAL 1668 RETVAL
1626 1669
1670void tick_inhibit_inc ()
1671 CODE:
1672 ++tick_inhibit;
1673
1674void tick_inhibit_dec ()
1675 CODE:
1676 if (!--tick_inhibit)
1677 if (tick_pending)
1678 {
1679 ev_async_send (EV_DEFAULT, &tick_watcher);
1680 coroapi::cede ();
1681 }
1682
1683void server_tick ()
1684 CODE:
1685{
1686 NOW = ev_now (EV_DEFAULT);
1687 SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
1688 SvNV_set (sv_tick_start, NOW); SvNOK_only (sv_tick_start);
1689 runtime = SvNVX (sv_runtime);
1690
1691 server_tick ();
1692
1693 NOW = ev_time ();
1694 SvNV_set (sv_now, NOW); SvNOK_only (sv_now);
1695 runtime += TICK;
1696 SvNV_set (sv_runtime, runtime); SvNOK_only (sv_runtime);
1697}
1698
1627NV floor (NV x) 1699NV floor (NV x)
1628 1700
1629NV ceil (NV x) 1701NV ceil (NV x)
1630 1702
1631NV rndm (...) 1703NV rndm (...)
1704 ALIAS:
1705 rmg_rndm = 1
1632 CODE: 1706 CODE:
1707{
1708 rand_gen &gen = ix ? rmg_rndm : rndm;
1633 switch (items) 1709 switch (items)
1634 { 1710 {
1635 case 0: RETVAL = rndm (); break; 1711 case 0: RETVAL = gen (); break;
1636 case 1: RETVAL = rndm (SvUV (ST (0))); break; 1712 case 1: RETVAL = gen (SvUV (ST (0))); break;
1637 case 2: RETVAL = rndm (SvIV (ST (0)), SvIV (ST (1))); break; 1713 case 2: RETVAL = gen (SvIV (ST (0)), SvIV (ST (1))); break;
1638 default: croak ("cf::rndm requires none, one or two parameters."); break; 1714 default: croak ("cf::rndm requires none, one or two parameters."); break;
1639 } 1715 }
1716}
1640 OUTPUT: 1717 OUTPUT:
1641 RETVAL 1718 RETVAL
1642 1719
1643NV clamp (NV value, NV min_value, NV max_value) 1720NV clamp (NV value, NV min_value, NV max_value)
1644 CODE: 1721 CODE:
… …
1650 CODE: 1727 CODE:
1651 RETVAL = lerp (value, min_in, max_in, min_out, max_out); 1728 RETVAL = lerp (value, min_in, max_in, min_out, max_out);
1652 OUTPUT: 1729 OUTPUT:
1653 RETVAL 1730 RETVAL
1654 1731
1655void cede_to_tick () 1732void weaken (...)
1656 CODE: 1733 PROTOTYPE: @
1657 coroapi::cede_to_tick (); 1734 CODE:
1658 1735 while (items > 0)
1659void server_tick () 1736 sv_rvweaken (ST (--items));
1660 CODE:
1661 NOW = now ();
1662 runtime = SvNVx (sv_runtime);
1663 server_tick ();
1664 1737
1665void 1738void
1666log_backtrace (utf8_string msg) 1739log_backtrace (utf8_string msg)
1667 1740
1668void 1741void
… …
1673octet_string path_combine (octet_string base, octet_string path) 1746octet_string path_combine (octet_string base, octet_string path)
1674 PROTOTYPE: $$ 1747 PROTOTYPE: $$
1675 1748
1676octet_string path_combine_and_normalize (octet_string base, octet_string path) 1749octet_string path_combine_and_normalize (octet_string base, octet_string path)
1677 PROTOTYPE: $$ 1750 PROTOTYPE: $$
1678
1679const_octet_string
1680get_maps_directory (octet_string path)
1681 PROTOTYPE: $
1682 ALIAS: maps_directory = 0
1683 CODE:
1684 RETVAL = create_pathname (path);
1685 OUTPUT: RETVAL
1686 1751
1687void 1752void
1688sub_generation_inc () 1753sub_generation_inc ()
1689 CODE: 1754 CODE:
1690 PL_sub_generation++; 1755 PL_sub_generation++;
… …
1715 1780
1716void abort () 1781void abort ()
1717 1782
1718void reset_signals () 1783void reset_signals ()
1719 1784
1720void fork_abort (octet_string cause = "cf::fork_abort") 1785void fork_abort (const_octet_string cause = "cf::fork_abort")
1721 1786
1722void cleanup (octet_string cause, bool make_core = false) 1787void cleanup (const_octet_string cause, bool make_core = false)
1723 1788
1724void emergency_save () 1789void emergency_save ()
1725 1790
1726void _exit (int status = EXIT_SUCCESS) 1791void _exit (int status = EXIT_SUCCESS)
1727 1792
1728UV sv_2watcher (SV *w)
1729 CODE:
1730 RETVAL = (UV)GEventAPI->sv_2watcher (w);
1731 OUTPUT:
1732 RETVAL
1733
1734#if _POSIX_MEMLOCK 1793#if _POSIX_MEMLOCK
1735 1794
1736int mlockall (int flags = MCL_CURRENT | MCL_FUTURE) 1795int mlockall (int flags = MCL_CURRENT | MCL_FUTURE)
1796 INIT:
1797#if __GLIBC__
1798 mallopt (M_TOP_PAD, 1024 * 1024);
1799 mallopt (M_MMAP_THRESHOLD, 1024 * 1024 * 128);
1800 mallopt (M_MMAP_MAX, 0); // likely bug-workaround, also frees memory
1801 mallopt (M_PERTURB, 0xee); // bug-workaround for linux glibc+mlockall+calloc
1802#endif
1737 1803
1738int munlockall () 1804int munlockall ()
1739 1805
1740#endif 1806#endif
1807
1808int
1809malloc_trim (IV pad = 0)
1810
1811void
1812mallinfo ()
1813 PPCODE:
1814{
1815#if __GLIBC__
1816 struct mallinfo mai = mallinfo ();
1817 EXTEND (SP, 10*2);
1818 PUSHs (sv_2mortal (newSVpv ("arena" , 0))); PUSHs (sv_2mortal (newSViv (mai.arena)));
1819 PUSHs (sv_2mortal (newSVpv ("ordblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.ordblks)));
1820 PUSHs (sv_2mortal (newSVpv ("smblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.smblks)));
1821 PUSHs (sv_2mortal (newSVpv ("hblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblks)));
1822 PUSHs (sv_2mortal (newSVpv ("hblkhd" , 0))); PUSHs (sv_2mortal (newSViv (mai.hblkhd)));
1823 PUSHs (sv_2mortal (newSVpv ("usmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.usmblks)));
1824 PUSHs (sv_2mortal (newSVpv ("fsmblks" , 0))); PUSHs (sv_2mortal (newSViv (mai.fsmblks)));
1825 PUSHs (sv_2mortal (newSVpv ("uordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.uordblks)));
1826 PUSHs (sv_2mortal (newSVpv ("fordblks", 0))); PUSHs (sv_2mortal (newSViv (mai.fordblks)));
1827 PUSHs (sv_2mortal (newSVpv ("keepcost", 0))); PUSHs (sv_2mortal (newSViv (mai.keepcost)));
1828#endif
1829 EXTEND (SP, 5*2);
1830 PUSHs (sv_2mortal (newSVpv ("slice_alloc", 0))); PUSHs (sv_2mortal (newSVuv (slice_alloc)));
1831 PUSHs (sv_2mortal (newSVpv ("shstr_alloc", 0))); PUSHs (sv_2mortal (newSVuv (shstr_alloc)));
1832 PUSHs (sv_2mortal (newSVpv ("objects" , 0))); PUSHs (sv_2mortal (newSVuv (objects.size () * sizeof (object))));
1833 PUSHs (sv_2mortal (newSVpv ("sv_count" , 0))); PUSHs (sv_2mortal (newSVuv (PL_sv_count)));
1834 PUSHs (sv_2mortal (newSVpv ("sv_objcount", 0))); PUSHs (sv_2mortal (newSVuv (PL_sv_objcount)));
1835}
1741 1836
1742int find_animation (utf8_string text) 1837int find_animation (utf8_string text)
1743 PROTOTYPE: $ 1838 PROTOTYPE: $
1744 1839
1745int random_roll (int min, int max, object *op, int goodbad); 1840int random_roll (int min, int max, object *op, int goodbad);
… …
1783 RETVAL = newSVpv (resist_plus[atnr], 0); 1878 RETVAL = newSVpv (resist_plus[atnr], 0);
1784 else 1879 else
1785 XSRETURN_UNDEF; 1880 XSRETURN_UNDEF;
1786 OUTPUT: RETVAL 1881 OUTPUT: RETVAL
1787 1882
1883UUID
1884uuid_cur ()
1885 CODE:
1886 RETVAL = UUID::cur;
1887 OUTPUT:
1888 RETVAL
1889
1890UUID
1891uuid_gen ()
1892 CODE:
1893 RETVAL = UUID::gen ();
1894 OUTPUT:
1895 RETVAL
1896
1897val64
1898uuid_seq (UUID uuid)
1899 CODE:
1900 RETVAL = uuid.seq;
1901 OUTPUT:
1902 RETVAL
1903
1904UUID
1905uuid_str (val64 seq)
1906 CODE:
1907 RETVAL.seq = seq;
1908 OUTPUT:
1909 RETVAL
1910
1911void
1912coin_names ()
1913 PPCODE:
1914 EXTEND (SP, NUM_COINS);
1915 for (int i = 0; i < NUM_COINS; ++i)
1916 PUSHs (sv_2mortal (newSVpv (coins [i], 0)));
1917
1918void
1919coin_archetypes ()
1920 PPCODE:
1921 EXTEND (SP, NUM_COINS);
1922 for (int i = 0; i < NUM_COINS; ++i)
1923 PUSHs (sv_2mortal (to_sv (archetype::find (coins [i]))));
1924
1788bool 1925bool
1789load_resource_file (octet_string filename) 1926load_resource_file_ (octet_string filename)
1927
1928void
1929fix_weight ()
1790 1930
1791MODULE = cf PACKAGE = cf::attachable 1931MODULE = cf PACKAGE = cf::attachable
1792 1932
1793int 1933int
1794valid (SV *obj) 1934valid (SV *obj)
… …
1812#object *mortals (U32 index) 1952#object *mortals (U32 index)
1813# CODE: 1953# CODE:
1814# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0; 1954# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;
1815# OUTPUT: RETVAL 1955# OUTPUT: RETVAL
1816 1956
1817INCLUDE: $PERL $srcdir/genacc attachable ../include/cfperl.h | 1957INCLUDE: $PERL $srcdir/genacc attachable ../include/util.h ../include/cfperl.h |
1818 1958
1819MODULE = cf PACKAGE = cf::global 1959MODULE = cf PACKAGE = cf::global
1820 1960
1821int invoke (SV *klass, int event, ...) 1961int invoke (SV *klass, int event, ...)
1822 CODE: 1962 CODE:
… …
1858object *actives (U32 index) 1998object *actives (U32 index)
1859 CODE: 1999 CODE:
1860 RETVAL = index < actives.size () ? actives [index] : 0; 2000 RETVAL = index < actives.size () ? actives [index] : 0;
1861 OUTPUT: RETVAL 2001 OUTPUT: RETVAL
1862 2002
2003int mortals_size ()
2004 CODE:
2005 RETVAL = attachable::mortals.size ();
2006 OUTPUT: RETVAL
2007
1863const char *slot_use_name (U32 slot) 2008const char *slot_use_name (U32 slot)
1864 ALIAS: 2009 ALIAS:
1865 slot_nonuse_name = 1 2010 slot_nonuse_name = 1
1866 CODE: 2011 CODE:
1867{ 2012{
… …
1888void 2033void
1889inv (object *obj) 2034inv (object *obj)
1890 PROTOTYPE: $ 2035 PROTOTYPE: $
1891 PPCODE: 2036 PPCODE:
1892{ 2037{
1893 object *o;
1894 for (o = obj->inv; o; o = o->below) 2038 for (object *o = obj->inv; o; o = o->below)
1895 XPUSHs (sv_2mortal (to_sv (o))); 2039 XPUSHs (sv_2mortal (to_sv (o)));
1896} 2040}
1897 2041
1898void 2042void
1899set_animation (object *op, int idx) 2043set_animation (object *op, int idx)
… …
1931 2075
1932int need_identify (object *obj); 2076int need_identify (object *obj);
1933 2077
1934int apply_shop_mat (object *shop_mat, object *op); 2078int apply_shop_mat (object *shop_mat, object *op);
1935 2079
1936int move_player (object *op, int dir)
1937 CODE:
1938 RETVAL = move_player (op, dir);
1939 OUTPUT:
1940 RETVAL
1941
1942int move (object *op, int dir, object *originator = op) 2080int move (object *op, int dir, object *originator = op)
1943 CODE: 2081 CODE:
1944 RETVAL = move_ob (op, dir, originator); 2082 RETVAL = move_ob (op, dir, originator);
1945 OUTPUT: 2083 OUTPUT:
1946 RETVAL 2084 RETVAL
… …
1953 CODE: 2091 CODE:
1954 player_apply_below (op); 2092 player_apply_below (op);
1955 2093
1956int cast_heal (object *op, object *caster, object *spell, int dir = 0) 2094int cast_heal (object *op, object *caster, object *spell, int dir = 0)
1957 2095
1958object *cf_object_present_archname_inside (object *op, utf8_string whatstr)
1959
1960int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)
1961
1962int cf_object_change_map (object *op, int x, int y, maptile *map)
1963
1964#//TODO
1965object *clone_ (object *op, int recursive = 0)
1966 CODE:
1967 if (recursive)
1968 RETVAL = object_create_clone (op);
1969 else
1970 {
1971 RETVAL = object::create ();
1972 op->copy_to (RETVAL);
1973 }
1974 OUTPUT: RETVAL
1975
1976int pay_item (object *op, object *buyer) 2096int pay_item (object *op, object *buyer)
1977 CODE: 2097 CODE:
1978 RETVAL = pay_for_item (op, buyer); 2098 RETVAL = pay_for_item (op, buyer);
1979 OUTPUT: RETVAL 2099 OUTPUT: RETVAL
1980 2100
… …
2014 2134
2015void drop (object *who, object *op) 2135void drop (object *who, object *op)
2016 2136
2017void pick_up (object *who, object *op) 2137void pick_up (object *who, object *op)
2018 2138
2019int cf_object_teleport (object *op, maptile *map, int x, int y)
2020
2021void update_object (object *op, int action) 2139void update_object (object *op, int action)
2022 2140
2023object *cf_create_object_by_name (utf8_string name)
2024
2025void change_exp (object *op, uint64 exp, utf8_string skill_name = 0, int flag = 0) 2141void change_exp (object *op, uint64 exp, utf8_string skill_name = 0, int flag = 0)
2026 2142
2027void player_lvl_adj (object *who, object *skill = 0) 2143void player_lvl_adj (object *who, object *skill = 0)
2028 2144
2029int kill_object (object *op, int dam = 0, object *hitter = 0, int type = AT_PHYSICAL) 2145int kill_object (object *op, int dam = 0, object *hitter = 0, int type = AT_PHYSICAL)
2030 2146
2031int calc_skill_exp (object *who, object *op, object *skill); 2147int calc_skill_exp (object *who, object *op, object *skill);
2032 2148
2033void push_button (object *op); 2149void push_button (object *op, object *originator);
2034 2150
2035void use_trigger (object *op); 2151void use_trigger (object *op, object *originator);
2036
2037void add_button_link (object *button, maptile *map, int connected);
2038
2039void remove_button_link (object *op);
2040 2152
2041void handle_apply_yield (object *op); 2153void handle_apply_yield (object *op);
2042 2154
2043 2155
2044MODULE = cf PACKAGE = cf::object PREFIX = cf_ 2156MODULE = cf PACKAGE = cf::object PREFIX = cf_
2045
2046object *cf_insert_ob_in_ob (object *ob, object *where)
2047 2157
2048# no clean way to get an object from an archetype - stupid idiotic 2158# no clean way to get an object from an archetype - stupid idiotic
2049# dumb kludgy misdesigned plug-in api slowly gets on my nerves. 2159# dumb kludgy misdesigned plug-in api slowly gets on my nerves.
2050 2160
2051object *new (utf8_string archetype = 0) 2161object *new (utf8_string archetype = 0)
… …
2060# TODO: nuke 2170# TODO: nuke
2061object *insert_ob_in_map_at (object *ob, maptile *where, object_ornull *orig, int flag, int x, int y) 2171object *insert_ob_in_map_at (object *ob, maptile *where, object_ornull *orig, int flag, int x, int y)
2062 PROTOTYPE: $$$$$$ 2172 PROTOTYPE: $$$$$$
2063 CODE: 2173 CODE:
2064{ 2174{
2065 int unused_type; 2175 RETVAL = insert_ob_in_map_at (ob, where, orig, flag, x, y);
2066 RETVAL = (object *)object_insert (&unused_type, ob, 0, where, orig, flag, x, y);
2067} 2176}
2068 2177
2069const_utf8_string get_ob_key_value (object *op, utf8_string key) 2178shstr
2179object::kv_get (shstr key)
2070 2180
2071bool set_ob_key_value (object *op, utf8_string key, utf8_string value = 0, int add_key = 1) 2181void
2182object::kv_del (shstr key)
2183
2184void
2185object::kv_set (shstr key, shstr value)
2072 2186
2073object *get_nearest_player (object *ob) 2187object *get_nearest_player (object *ob)
2074 ALIAS: nearest_player = 0 2188 ALIAS: nearest_player = 0
2075 PREINIT: 2189 PREINIT:
2076 extern object *get_nearest_player (object *); 2190 extern object *get_nearest_player (object *);
… …
2078void rangevector (object *ob, object *other, int flags = 0) 2192void rangevector (object *ob, object *other, int flags = 0)
2079 PROTOTYPE: $$;$ 2193 PROTOTYPE: $$;$
2080 PPCODE: 2194 PPCODE:
2081{ 2195{
2082 rv_vector rv; 2196 rv_vector rv;
2197
2198 PUTBACK;
2083 get_rangevector (ob, other, &rv, flags); 2199 get_rangevector (ob, other, &rv, flags);
2200 SPAGAIN;
2201
2084 EXTEND (SP, 5); 2202 EXTEND (SP, 5);
2085 PUSHs (newSVuv (rv.distance)); 2203 PUSHs (newSVuv (rv.distance));
2086 PUSHs (newSViv (rv.distance_x)); 2204 PUSHs (newSViv (rv.distance_x));
2087 PUSHs (newSViv (rv.distance_y)); 2205 PUSHs (newSViv (rv.distance_y));
2088 PUSHs (newSViv (rv.direction)); 2206 PUSHs (newSViv (rv.direction));
2089 PUSHs (newSVcfapi (CFAPI_POBJECT, rv.part)); 2207 PUSHs (to_sv (rv.part));
2090} 2208}
2091 2209
2092bool on_same_map_as (object *ob, object *other) 2210bool on_same_map_as (object *ob, object *other)
2093 CODE: 2211 CODE:
2094 RETVAL = on_same_map (ob, other); 2212 RETVAL = on_same_map (ob, other);
… …
2098base_name (object *op, int plural = op->nrof > 1) 2216base_name (object *op, int plural = op->nrof > 1)
2099 CODE: 2217 CODE:
2100 RETVAL = query_base_name (op, plural); 2218 RETVAL = query_base_name (op, plural);
2101 OUTPUT: RETVAL 2219 OUTPUT: RETVAL
2102 2220
2103object *decrease_ob_nr (object *op, unsigned long i) 2221# return the tail of an object, excluding itself
2222void
2223tail (object *op)
2224 PPCODE:
2225 while ((op = op->more))
2226 XPUSHs (sv_2mortal (to_sv (op)));
2104 2227
2105MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_ 2228MODULE = cf PACKAGE = cf::object::player PREFIX = cf_player_
2106 2229
2107player *player (object *op) 2230player *player (object *op)
2108 CODE: 2231 CODE:
2109 RETVAL = op->contr; 2232 RETVAL = op->contr;
2110 OUTPUT: RETVAL 2233 OUTPUT: RETVAL
2111 2234
2235bool move_player (object *op, int dir)
2236
2112void check_score (object *op) 2237void check_score (object *op)
2113 2238
2114void message (object *op, utf8_string txt, int flags = NDI_ORANGE | NDI_UNIQUE) 2239void message (object *op, utf8_string txt, int flags = NDI_ORANGE | NDI_UNIQUE)
2115 CODE: 2240 CODE:
2116 new_draw_info (flags, 0, op, txt); 2241 new_draw_info (flags, 0, op, txt);
2117 2242
2118void kill_player (object *op) 2243void kill_player (object *op)
2119 2244
2245void esrv_send_item (object *pl, object *item)
2246
2120void esrv_update_item (object *op, int what, object *item) 2247void esrv_update_item (object *pl, int what, object *item)
2121 C_ARGS: what, op, item 2248 C_ARGS: what, pl, item
2249
2250void esrv_del_item (object *pl, int tag)
2251 C_ARGS: pl->contr, tag
2122 2252
2123int command_summon (object *op, utf8_string params) 2253int command_summon (object *op, utf8_string params)
2124 2254
2125int command_arrest (object *op, utf8_string params) 2255int command_arrest (object *op, utf8_string params)
2126 2256
… …
2145 pl->ob->stats.hp = pl->ob->stats.maxhp; 2275 pl->ob->stats.hp = pl->ob->stats.maxhp;
2146 pl->ob->stats.sp = pl->ob->stats.maxsp; 2276 pl->ob->stats.sp = pl->ob->stats.maxsp;
2147 pl->ob->stats.grace = pl->ob->stats.maxgrace; 2277 pl->ob->stats.grace = pl->ob->stats.maxgrace;
2148 pl->orig_stats = pl->ob->stats; 2278 pl->orig_stats = pl->ob->stats;
2149 2279
2150void clear_los (player *pl) 2280# should only be temporary
2281void esrv_new_player (player *pl)
2151 2282
2152void cf_player_move (player *pl, int dir) 2283#d# TODO: replace by blocked_los accessor, fix code using this
2153
2154void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);
2155
2156bool 2284bool
2157cell_visible (player *pl, int dx, int dy) 2285cell_visible (player *pl, int dx, int dy)
2158 CODE: 2286 CODE:
2159 RETVAL = FABS (dx) <= pl->ns->mapx / 2 && FABS (dy) <= pl->ns->mapy / 2 2287 RETVAL = pl->blocked_los (dx, dy) != LOS_BLOCKED;
2160 && !pl->blocked_los [dx + pl->ns->mapx / 2][dy + pl->ns->mapy / 2];
2161 OUTPUT: 2288 OUTPUT:
2162 RETVAL 2289 RETVAL
2163 2290
2164void 2291void
2165send (player *pl, SV *packet) 2292send (player *pl, SV *packet)
2166 CODE: 2293 CODE:
2167{ 2294{
2168 STRLEN len; 2295 STRLEN len;
2169 char *buf = SvPVbyte (packet, len); 2296 char *buf = SvPVbyte (packet, len);
2170 2297
2298 if (len > MAXSOCKBUF)
2299 pl->failmsg ("[packet too long for client]");
2171 if (pl->ns) 2300 else if (pl->ns)
2172 pl->ns->send_packet (buf, len); 2301 pl->ns->send_packet (buf, len);
2173} 2302}
2174
2175int
2176listening (player *pl, int new_value = -1)
2177 CODE:
2178 RETVAL = pl->listening;
2179 if (new_value >= 0)
2180 pl->listening = new_value;
2181 OUTPUT:
2182 RETVAL
2183 2303
2184void savebed (player *pl, SV *map_path = 0, SV *x = 0, SV *y = 0) 2304void savebed (player *pl, SV *map_path = 0, SV *x = 0, SV *y = 0)
2185 PROTOTYPE: $;$$$ 2305 PROTOTYPE: $;$$$
2186 PPCODE: 2306 PPCODE:
2187 if (GIMME_V != G_VOID) 2307 if (GIMME_V != G_VOID)
… …
2212 RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END); 2332 RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);
2213 OUTPUT: RETVAL 2333 OUTPUT: RETVAL
2214 2334
2215SV *registry (maptile *map) 2335SV *registry (maptile *map)
2216 2336
2337void
2338find_tagged_objects (maptile *map, utf8_string tag = 0)
2339 PPCODE:
2340{
2341 if (!map->spaces)
2342 XSRETURN_EMPTY;
2343
2344 if (tag)
2345 {
2346 shstr_cmp tag_ (tag);
2347
2348 for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
2349 for (object *op = ms->bot; op; op = op->above)
2350 if (op->tag == tag_)
2351 XPUSHs (sv_2mortal (to_sv (op)));
2352 }
2353 else
2354 {
2355 for (mapspace *ms = map->spaces + map->size (); ms-- > map->spaces; )
2356 for (object *op = ms->bot; op; op = op->above)
2357 if (op->tag)
2358 XPUSHs (sv_2mortal (to_sv (op)));
2359 }
2360}
2361
2217INCLUDE: $PERL $srcdir/genacc maptile ../include/map.h | 2362INCLUDE: $PERL $srcdir/genacc maptile ../include/map.h |
2363
2364void
2365adjust_daylight ()
2366 CODE:
2367 maptile::adjust_daylight ();
2218 2368
2219void 2369void
2220maptile::instantiate () 2370maptile::instantiate ()
2221 2371
2222maptile *new () 2372maptile *new ()
… …
2317} 2467}
2318 2468
2319void 2469void
2320maptile::create_region_treasure () 2470maptile::create_region_treasure ()
2321 CODE: 2471 CODE:
2322{
2323 object *op = object::create ();
2324 op->type = FLOOR;
2325 op->map = THIS;
2326
2327 for (int x = 0; x < THIS->width; ++x) 2472 for (int x = 0; x < THIS->width; ++x)
2328 for (int y = 0; y < THIS->height; ++y) 2473 for (int y = 0; y < THIS->height; ++y)
2329 { 2474 {
2330 region *rgn = THIS->region (x, y); 2475 region *rgn = THIS->region (x, y);
2331 2476
2332 //fprintf (stderr, "%d,%d %f %p\n", x, y, rgn->treasure_density,rgn->treasure);//D 2477 //fprintf (stderr, "%d,%d %f %p\n", x, y, rgn->treasure_density,rgn->treasure);//D
2478 if (object *op = THIS->at (x, y).top)
2333 if (rgn->treasure && rndm () < rgn->treasure_density) 2479 if (rgn->treasure && rndm () < rgn->treasure_density)
2334 {
2335 op->x = x;
2336 op->y = y;
2337 create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty); 2480 create_treasure (rgn->treasure, op, GT_ENVIRONMENT, THIS->difficulty);
2338 }
2339 } 2481 }
2340 2482
2341 op->destroy ();
2342}
2343
2344void play_sound_map (maptile *map, int x, int y, int sound_num)
2345
2346int out_of_map (maptile *map, int x, int y) 2483int out_of_map (maptile *map, int x, int y)
2347 2484
2348void 2485void
2349trigger (maptile *map, long connection, bool state = true) 2486find_link (maptile *map, shstr_tmp connection)
2350 CODE:
2351 activate_connection (map, connection, state);
2352
2353void
2354get_connection (maptile *map, long connection)
2355 PPCODE: 2487 PPCODE:
2356 oblinkpt *obp = get_connection_links (map, connection); 2488 if (oblinkpt *obp = map->find_link (connection))
2357 if (obp)
2358 for (objectlink *ol = obp->link; ol; ol = ol->next) 2489 for (objectlink *ol = obp->link; ol; ol = ol->next)
2359 XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, (object *)ol->ob))); 2490 XPUSHs (sv_2mortal (to_sv ((object *)ol->ob)));
2360
2361object *cf_map_insert_object_there (maptile *where, object *op, object *originator, int flags)
2362
2363object *cf_map_insert_object (maptile *where, object* op, int x, int y)
2364
2365object* cf_map_present_arch_by_name (maptile *map, const char* str, int nx, int ny)
2366 C_ARGS: str, map, nx, ny
2367 2491
2368void 2492void
2369get_map_flags (maptile *map, int x, int y) 2493get_map_flags (maptile *map, int x, int y)
2370 PPCODE: 2494 PPCODE:
2371{ 2495{
2372 maptile *nmap = 0; 2496 maptile *nmap = 0;
2373 I16 nx = 0, ny = 0; 2497 I16 nx = 0, ny = 0;
2498
2499 PUTBACK;
2374 int flags = get_map_flags (map, &nmap, x, y, &nx, &ny); 2500 int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
2501 SPAGAIN;
2375 2502
2376 EXTEND (SP, 4); 2503 EXTEND (SP, 4);
2377 PUSHs (sv_2mortal (newSViv (flags))); 2504 PUSHs (sv_2mortal (newSViv (flags)));
2378 2505
2379 if (GIMME_V == G_ARRAY) 2506 if (GIMME_V == G_ARRAY)
2380 { 2507 {
2381 PUSHs (sv_2mortal (newSVcfapi (CFAPI_PMAP, nmap))); 2508 PUSHs (sv_2mortal (to_sv (nmap)));
2382 PUSHs (sv_2mortal (newSViv (nx))); 2509 PUSHs (sv_2mortal (newSViv (nx)));
2383 PUSHs (sv_2mortal (newSViv (ny))); 2510 PUSHs (sv_2mortal (newSViv (ny)));
2384 } 2511 }
2385} 2512}
2386 2513
2514mapspace *
2515ms (maptile *map, unsigned int x, unsigned int y)
2516 PROTOTYPE: $$$
2517 CODE:
2518{
2519 maptile *nmap = 0;
2520 I16 nx, ny;
2521
2522 PUTBACK;
2523 get_map_flags (map, &nmap, x, y, &nx, &ny);
2524 SPAGAIN;
2525
2526 if (!nmap)
2527 XSRETURN_UNDEF;
2528
2529 RETVAL = &nmap->at (nx, ny);
2530}
2531 OUTPUT:
2532 RETVAL
2533
2387void 2534void
2388at (maptile *map, unsigned int x, unsigned int y) 2535at (maptile *map, unsigned int x, unsigned int y)
2389 PROTOTYPE: $$$ 2536 PROTOTYPE: $$$
2390 PPCODE: 2537 PPCODE:
2391{ 2538{
2392 object *o;
2393 maptile *nmap = 0; 2539 maptile *nmap = 0;
2394 I16 nx, ny; 2540 I16 nx, ny;
2395 2541
2542 PUTBACK;
2396 get_map_flags (map, &nmap, x, y, &nx, &ny); 2543 get_map_flags (map, &nmap, x, y, &nx, &ny);
2544 SPAGAIN;
2397 2545
2398 if (nmap) 2546 if (nmap)
2399 for (o = GET_MAP_OB (nmap, nx, ny); o; o = o->above) 2547 for (object *o = nmap->at (nx, ny).bot; o; o = o->above)
2400 XPUSHs (sv_2mortal (newSVcfapi (CFAPI_POBJECT, o))); 2548 XPUSHs (sv_2mortal (to_sv (o)));
2401} 2549}
2402 2550
2403SV * 2551SV *
2404bot_at (maptile *obj, unsigned int x, unsigned int y) 2552bot_at (maptile *map, unsigned int x, unsigned int y)
2405 PROTOTYPE: $$$ 2553 PROTOTYPE: $$$
2406 ALIAS: 2554 ALIAS:
2407 top_at = 1 2555 top_at = 1
2408 flags_at = 2 2556 flags_at = 2
2409 light_at = 3 2557 light_at = 3
2410 move_block_at = 4 2558 move_block_at = 4
2411 move_slow_at = 5 2559 move_slow_at = 5
2412 move_on_at = 6 2560 move_on_at = 6
2413 move_off_at = 7 2561 move_off_at = 7
2414 INIT:
2415 if (x >= obj->width || y >= obj->height) XSRETURN_UNDEF;
2416 CODE: 2562 CODE:
2563{
2564 sint16 nx = x;
2565 sint16 ny = y;
2566
2567 if (!xy_normalise (map, nx, ny))
2568 XSRETURN_UNDEF;
2569
2570 mapspace &ms = map->at (nx, ny);
2571
2572 ms.update ();
2573
2417 switch (ix) 2574 switch (ix)
2418 { 2575 {
2419 case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB (obj, x, y)); break; 2576 case 0: RETVAL = to_sv (ms.bot ); break;
2420 case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP (obj, x, y)); break; 2577 case 1: RETVAL = to_sv (ms.top ); break;
2421 case 2: RETVAL = newSVuv ( GET_MAP_FLAGS (obj, x, y)); break; 2578 case 2: RETVAL = newSVuv (ms.flags_ ); break;
2422 case 3: RETVAL = newSViv ( GET_MAP_LIGHT (obj, x, y)); break; 2579 case 3: RETVAL = newSViv (ms.light ); break;
2423 case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break; 2580 case 4: RETVAL = newSVuv (ms.move_block); break;
2424 case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break; 2581 case 5: RETVAL = newSVuv (ms.move_slow ); break;
2425 case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break; 2582 case 6: RETVAL = newSVuv (ms.move_on ); break;
2426 case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break; 2583 case 7: RETVAL = newSVuv (ms.move_off ); break;
2427 } 2584 }
2585}
2428 OUTPUT: RETVAL 2586 OUTPUT: RETVAL
2429 2587
2430void fix_walls (maptile *map, int x, int y) 2588void fix_walls (maptile *map, int x, int y)
2431 2589
2432void fix_walls_around (maptile *map, int x, int y) 2590void fix_walls_around (maptile *map, int x, int y)
… …
2517 RETVAL = self->generate_random_map (&rmp); 2675 RETVAL = self->generate_random_map (&rmp);
2518} 2676}
2519 OUTPUT: 2677 OUTPUT:
2520 RETVAL 2678 RETVAL
2521 2679
2680MODULE = cf PACKAGE = cf::mapspace
2681
2682INCLUDE: $PERL $srcdir/genacc mapspace ../include/map.h |
2683
2522MODULE = cf PACKAGE = cf::arch 2684MODULE = cf PACKAGE = cf::arch
2523
2524archetype *find (utf8_string name)
2525 CODE:
2526 RETVAL = archetype::find (name);
2527 OUTPUT:
2528 RETVAL
2529 2685
2530int archetypes_size () 2686int archetypes_size ()
2531 CODE: 2687 CODE:
2532 RETVAL = archetypes.size (); 2688 RETVAL = archetypes.size ();
2533 OUTPUT: RETVAL 2689 OUTPUT: RETVAL
… …
2567 PROTOTYPE: $ 2723 PROTOTYPE: $
2568 CODE: 2724 CODE:
2569 RETVAL = region::find (name); 2725 RETVAL = region::find (name);
2570 OUTPUT: RETVAL 2726 OUTPUT: RETVAL
2571 2727
2572region *find_fuzzy (utf8_string name)
2573 PROTOTYPE: $
2574 CODE:
2575 RETVAL = region::find_fuzzy (name);
2576 OUTPUT: RETVAL
2577
2578int specificity (region *rgn) 2728int specificity (region *rgn)
2579 CODE: 2729 CODE:
2580 RETVAL = 0; 2730 RETVAL = 0;
2581 while (rgn = rgn->parent) 2731 while (rgn = rgn->parent)
2582 RETVAL++; 2732 RETVAL++;
… …
2618 CODE: 2768 CODE:
2619{ 2769{
2620 STRLEN len; 2770 STRLEN len;
2621 char *buf = SvPVbyte (packet, len); 2771 char *buf = SvPVbyte (packet, len);
2622 2772
2773 if (len > MAXSOCKBUF)
2774 {
2775 // ugly
2776 if (THIS->pl)
2777 THIS->pl->failmsg ("[packet too long for client]");
2778 }
2779 else
2623 THIS->send_packet (buf, len); 2780 THIS->send_packet (buf, len);
2624} 2781}
2625 2782
2626faceidx 2783faceidx
2627client::find_face (utf8_string name, faceidx defidx = 0) 2784client::need_face (utf8_string name, int pri = 0)
2628 CODE: 2785 CODE:
2629 RETVAL = face_find (name, defidx); 2786 RETVAL = face_find (name, 0);
2787 if (RETVAL)
2788 {
2630 THIS->send_face (RETVAL); 2789 THIS->send_face (RETVAL, pri);
2631 THIS->flush_fx (); 2790 THIS->flush_fx ();
2791 }
2632 OUTPUT: 2792 OUTPUT:
2633 RETVAL 2793 RETVAL
2794
2795int
2796client::fx_want (int idx, int value = -1)
2797 CODE:
2798 if (0 < idx && idx < FT_NUM)
2799 {
2800 RETVAL = THIS->fx_want [idx];
2801 if (items > 2)
2802 THIS->fx_want [idx] = value;
2803 }
2804 else
2805 RETVAL = 0;
2806 OUTPUT:
2807 RETVAL
2808
2809MODULE = cf PACKAGE = cf::sound PREFIX = sound_
2810
2811faceidx sound_find (utf8_string name)
2812
2813void sound_set (utf8_string str, faceidx face)
2814
2815# dire hack
2816void old_sound_index (int idx, faceidx face)
2817 CODE:
2818 extern faceidx old_sound_index [SOUND_CAST_SPELL_0];
2819 old_sound_index [idx] = face;
2634 2820
2635MODULE = cf PACKAGE = cf::face PREFIX = face_ 2821MODULE = cf PACKAGE = cf::face PREFIX = face_
2636 2822
2637#INCLUDE: $PERL $srcdir/genacc faceset ../include/face.h | 2823#INCLUDE: $PERL $srcdir/genacc faceset ../include/face.h |
2638 2824
… …
2698 } 2884 }
2699} 2885}
2700 2886
2701int get_data_size (faceidx idx, int faceset = 0) 2887int get_data_size (faceidx idx, int faceset = 0)
2702 CODE: 2888 CODE:
2703 facedata *d = face_data (idx, faceset); assert (d); 2889 facedata *d = face_data (idx, faceset);
2890 if (!d) XSRETURN_UNDEF;
2704 RETVAL = d->data.size (); 2891 RETVAL = d->data.size ();
2705 OUTPUT: 2892 OUTPUT:
2706 RETVAL 2893 RETVAL
2707 2894
2708SV *get_chksum (faceidx idx, int faceset = 0) 2895SV *get_chksum (faceidx idx, int faceset = 0)
2709 CODE: 2896 CODE:
2710 facedata *d = face_data (idx, faceset); assert (d); 2897 facedata *d = face_data (idx, faceset);
2898 if (!d) XSRETURN_UNDEF;
2711 RETVAL = newSVpvn ((char *)d->chksum, CHKSUM_SIZE); 2899 RETVAL = newSVpvn ((char *)d->chksum, CHKSUM_SIZE);
2900 OUTPUT:
2901 RETVAL
2902
2903SV *get_data (faceidx idx, int faceset = 0)
2904 CODE:
2905 facedata *d = face_data (idx, faceset);
2906 if (!d) XSRETURN_UNDEF;
2907 RETVAL = newSVpvn (d->data.data (), d->data.length ());
2712 OUTPUT: 2908 OUTPUT:
2713 RETVAL 2909 RETVAL
2714 2910
2715void invalidate (faceidx idx) 2911void invalidate (faceidx idx)
2716 CODE: 2912 CODE:
… …
2762void invalidate_all () 2958void invalidate_all ()
2763 CODE: 2959 CODE:
2764 for_all_clients (ns) 2960 for_all_clients (ns)
2765 ns->anims_sent.reset (); 2961 ns->anims_sent.reset ();
2766 2962
2963MODULE = cf PACKAGE = cf::object::freezer
2964
2965INCLUDE: $PERL $srcdir/genacc object_freezer ../include/cfperl.h |
2966
2967SV *
2968new (char *klass)
2969 CODE:
2970 RETVAL = newSVptr (new object_freezer, gv_stashpv ("cf::object::freezer", 1));
2971 OUTPUT: RETVAL
2972
2973void
2974DESTROY (SV *sv)
2975 CODE:
2976 object_freezer *self;
2977 sv_to (sv, self);
2978 delete self;
2979
2980MODULE = cf PACKAGE = cf::object::thawer
2981
2982INCLUDE: $PERL $srcdir/genacc object_thawer ../include/cfperl.h |
2983
2984SV *
2985new_from_file (char *klass, octet_string path)
2986 CODE:
2987 object_thawer *f = new object_thawer (path);
2988 if (!*f)
2989 {
2990 delete f;
2991 XSRETURN_UNDEF;
2992 }
2993 RETVAL = newSVptr (f, gv_stashpv ("cf::object::thawer", 1));
2994 OUTPUT: RETVAL
2995
2996void
2997DESTROY (SV *sv)
2998 CODE:
2999 object_thawer *self;
3000 sv_to (sv, self);
3001 delete self;
3002
3003void
3004extract_tags (object_thawer *self)
3005 PPCODE:
3006 while (self->kw != KW_EOF)
3007 {
3008 PUTBACK;
3009 coroapi::cede_to_tick ();
3010 SPAGAIN;
3011
3012 if (self->kw == KW_tag)
3013 XPUSHs (sv_2mortal (newSVpv_utf8 (self->get_str ())));
3014
3015 self->skip ();
3016 }
3017

Diff Legend

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