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.126 by root, Thu Jan 4 16:19:32 2007 UTC vs.
Revision 1.153 by root, Fri Jan 26 20:59:57 2007 UTC

… …
99 99
100////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 100//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
101 101
102unordered_vector<attachable *> attachable::mortals; 102unordered_vector<attachable *> attachable::mortals;
103 103
104#if 0
105attachable *attachable::rc_first;
106
107attachable::attachable ()
108{
109 refcnt = 0;
110 rc_next = rc_first;
111 rc_first = this;
112}
113#endif
114
115attachable::~attachable () 104attachable::~attachable ()
116{ 105{
117 assert (!(flags & F_BORROWED));//D//TODO//remove when stable
118#if 0
119 assert (!rc_next);
120 assert (!refcnt); 106 assert (!self);
121#endif 107 assert (!cb);
108}
109
110int
111attachable::refcnt_cnt () const
112{
113 return refcnt + (self ? SvREFCNT (self) - 1 : 0);
114}
115
116void
117attachable::optimise ()
118{
119 if (self
120 && SvREFCNT (self) == 1
121 && !HvTOTALKEYS (self))
122 {
123 sv_unmagic ((SV *)self, PERL_MAGIC_ext);
124 assert (!self);
125 }
122} 126}
123 127
124// check wether the object really is dead 128// check wether the object really is dead
125void 129void
126attachable::do_check () 130attachable::do_check ()
127{ 131{
128 if (refcnt > 0) 132 if (refcnt_cnt () > 0)
129 return; 133 return;
130 134
131 // try to unborrow the refcnt from perl 135 destroy ();
132 if (flags & F_BORROWED) 136}
137
138void
139attachable::do_destroy ()
140{
141 invoke (EVENT_ATTACHABLE_DESTROY, DT_END);
142
143 if (cb)
133 { 144 {
134 assert (self);//D//TODO//remove when stable
135 flags &= ~F_BORROWED;
136 refcnt_inc ();
137 SvREFCNT_dec (self); 145 SvREFCNT_dec (cb);
146 cb = 0;
138 } 147 }
139 148
140 if (refcnt > 0 || self) 149 if (self)
141 return; 150 {
151 hv_clear (self);
152 sv_unmagic ((SV *)self, PERL_MAGIC_ext);
153 // self is now 0
154 assert (!self);//D//TODO remove soon
155 }
142 156
143 destroy ();
144}
145
146void
147attachable::do_destroy ()
148{
149 invoke (EVENT_ATTACHABLE_DESTROY, DT_END);
150
151 //TODO: call generic destroy callback
152 mortals.push_back (this); 157 mortals.push_back (this);
153} 158}
154 159
155void 160void
156attachable::destroy () 161attachable::destroy ()
… …
160 165
161 flags |= F_DESTROYED; 166 flags |= F_DESTROYED;
162 do_destroy (); 167 do_destroy ();
163} 168}
164 169
170void
165void attachable::check_mortals () 171attachable::check_mortals ()
166{ 172{
167 for (int i = 0; i < mortals.size (); ) 173 static int i = 0;
174
175 for (;;)
168 { 176 {
177 if (i >= mortals.size ())
178 {
179 i = 0;
180
181 if (mortals.size () > 1000)
182 fprintf (stderr, "mortal queue size (%d) exceeds 1000.\n", (int)mortals.size ());
183
184 break;
185 }
186
169 attachable *obj = mortals [i]; 187 attachable *obj = mortals [i];
170 188
171 obj->refcnt_chk (); // unborrow from perl, if necessary 189 obj->refcnt_chk (); // unborrow from perl, if necessary
172 190
191 //if (obj->refcnt > 0 || obj->self)
173 if (obj->refcnt || obj->self) 192 if (obj->refcnt || obj->self)
174 { 193 {
175#if 0 194//printf ("%p rc %d\n", obj, obj->refcnt_cnt ());//D
176 if (mortals.size() > 5)fprintf (stderr, "%d delaying %d:%p:%s %d (self %p:%d)\n", time(0),i, obj, typeid (*obj).name (),
177 obj->refcnt, obj->self, obj->self ? SvREFCNT(obj->self): - 1);//D
178#endif
179
180 ++i; // further delay freeing 195 ++i; // further delay freeing
196
197 if (!(i & 0x3ff))
198 break;
181 }//D 199 }
182 else 200 else
183 { 201 {
184 //Dfprintf (stderr, "deleteing %d:%p:%s\n", i, obj,typeid (*obj).name ());//D
185 mortals.erase (i); 202 mortals.erase (i);
186 delete obj; 203 delete obj;
187 } 204 }
188 } 205 }
189} 206}
… …
214 231
215static int 232static int
216attachable_free (pTHX_ SV *sv, MAGIC *mg) 233attachable_free (pTHX_ SV *sv, MAGIC *mg)
217{ 234{
218 attachable *at = (attachable *)mg->mg_ptr; 235 attachable *at = (attachable *)mg->mg_ptr;
219 assert (!(at->flags & attachable::F_BORROWED));//D//TODO//remove when stable 236
237 //TODO: check if transaction behaviour is really required here
238 if (SV *self = (SV *)at->self)
239 {
220 at->self = 0; 240 at->self = 0;
241 SvREFCNT_dec (self);
242 }
243
221 // next line makes sense, but most objects still have refcnt 0 by default 244 // next line makes sense, but most objects still have refcnt 0 by default
222 //at->refcnt_chk (); 245 //at->refcnt_chk ();
223 return 0; 246 return 0;
224} 247}
225 248
… …
234 if (!obj->self) 257 if (!obj->self)
235 { 258 {
236 obj->self = newHV (); 259 obj->self = newHV ();
237 sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char *)obj, 0); 260 sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char *)obj, 0);
238 261
239 // borrow the refcnt from the object 262 // now bless the object _once_
240 obj->flags |= attachable::F_BORROWED; 263 return sv_bless (newRV_inc ((SV *)obj->self), stash);
241 obj->refcnt_dec ();
242 } 264 }
265 else
266 {
267 SV *sv = newRV_inc ((SV *)obj->self);
243 268
244 return sv_bless (newRV_inc ((SV *)obj->self), stash); 269 if (Gv_AMG (stash)) // handle overload correctly, as the perl core does not
270 SvAMAGIC_on (sv);
271
272 return sv;
273 }
245} 274}
246 275
247static void 276static void
248clearSVptr (SV *sv) 277clearSVptr (SV *sv)
249{ 278{
… …
302inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); } 331inline SV *to_sv (living * v) { return newSVptr (v, stash_cf_living_wrap); }
303 332
304inline SV *to_sv (object & v) { return to_sv (&v); } 333inline SV *to_sv (object & v) { return to_sv (&v); }
305inline SV *to_sv (living & v) { return to_sv (&v); } 334inline SV *to_sv (living & v) { return to_sv (&v); }
306 335
307//TODO:
308inline SV *to_sv (New_Face * v) { return to_sv (v->name); } 336inline SV *to_sv (facetile * v) { return to_sv (v->name); }
309inline SV *to_sv (treasurelist * v) { return to_sv (v->name); } 337inline SV *to_sv (treasurelist * v) { return to_sv (v->name); }
310 338
311inline SV *to_sv (UUID v) 339inline SV *to_sv (UUID v)
312{ 340{
313 char buf[128]; 341 char buf[128];
… …
333inline void sv_to (SV *sv, client * &v) { v = (client *)(attachable *)SvPTR_ornull (sv, "cf::client"); } 361inline void sv_to (SV *sv, client * &v) { v = (client *)(attachable *)SvPTR_ornull (sv, "cf::client"); }
334inline void sv_to (SV *sv, player * &v) { v = (player *)(attachable *)SvPTR_ornull (sv, "cf::player"); } 362inline void sv_to (SV *sv, player * &v) { v = (player *)(attachable *)SvPTR_ornull (sv, "cf::player"); }
335inline void sv_to (SV *sv, object * &v) { v = (object *)(attachable *)SvPTR_ornull (sv, "cf::object"); } 363inline void sv_to (SV *sv, object * &v) { v = (object *)(attachable *)SvPTR_ornull (sv, "cf::object"); }
336inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)(attachable *)SvPTR_ornull (sv, "cf::arch"); } 364inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)(attachable *)SvPTR_ornull (sv, "cf::arch"); }
337inline void sv_to (SV *sv, maptile * &v) { v = (maptile *)(attachable *)SvPTR_ornull (sv, "cf::map"); } 365inline void sv_to (SV *sv, maptile * &v) { v = (maptile *)(attachable *)SvPTR_ornull (sv, "cf::map"); }
366inline void sv_to (SV *sv, attachable * &v) { v = (attachable *)SvPTR_ornull (sv, "cf::attachable"); }
338inline void sv_to (SV *sv, partylist * &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); } 367inline void sv_to (SV *sv, partylist * &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }
339inline void sv_to (SV *sv, region * &v) { v = (region *)SvPTR_ornull (sv, "cf::region"); } 368inline void sv_to (SV *sv, region * &v) { v = (region *)SvPTR_ornull (sv, "cf::region"); }
340inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); } 369inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }
341 370
342inline void sv_to (SV *sv, New_Face * &v) { v = &new_faces[FindFace (SvPV_nolen (sv), 0)]; } //TODO 371inline void sv_to (SV *sv, facetile * &v) { v = &new_faces[FindFace (SvPV_nolen (sv), 0)]; }
343inline void sv_to (SV *sv, treasurelist * &v) { v = find_treasurelist (SvPV_nolen (sv)); } // TODO 372inline void sv_to (SV *sv, treasurelist * &v) { v = find_treasurelist (SvPV_nolen (sv)); }
344 373
345template<class T> 374template<class T>
346inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; } 375inline void sv_to (SV *sv, refptr<T> &v) { T *tmp; sv_to (sv, tmp); v = tmp; }
347 376
348template<int N> 377template<int N>
… …
483{ 512{
484 if (!ext->cb) 513 if (!ext->cb)
485 ext->cb = newAV (); 514 ext->cb = newAV ();
486 515
487 return newRV_inc ((SV *)ext->cb); 516 return newRV_inc ((SV *)ext->cb);
488}
489
490#if 0
491void attachable::clear ()
492{
493 if (self)
494 {
495 // disconnect Perl from C, to avoid crashes
496 sv_unmagic (SvRV ((SV *)self), PERL_MAGIC_ext);
497
498 // clear the perl hash, might or might not be a good idea
499 hv_clear ((HV *)SvRV ((SV *)self));
500
501 SvREFCNT_dec (self);
502 self = 0;
503 }
504
505 if (cb)
506 {
507 SvREFCNT_dec (cb);
508 cb = 0;
509 }
510
511 attach = 0;
512}
513#endif
514
515void attachable::optimise ()
516{
517 if (self
518 && SvREFCNT (self) == 1
519 && !HvTOTALKEYS (self))
520 {
521 flags &= ~F_BORROWED;
522 refcnt_inc ();
523 SvREFCNT_dec ((SV *)self);
524 }
525} 517}
526 518
527///////////////////////////////////////////////////////////////////////////// 519/////////////////////////////////////////////////////////////////////////////
528 520
529extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr) 521extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
… …
825} 817}
826 818
827///////////////////////////////////////////////////////////////////////////// 819/////////////////////////////////////////////////////////////////////////////
828 820
829void 821void
830maptile::emergency_save () 822cfperl_emergency_save ()
831{ 823{
832 CALL_BEGIN (0); 824 CALL_BEGIN (0);
833 CALL_CALL ("cf::map::emergency_save", G_VOID); 825 CALL_CALL ("cf::emergency_save", G_VOID);
834 CALL_END; 826 CALL_END;
835} 827}
836 828
837maptile * 829maptile *
838maptile::find_sync (const char *path, maptile *origin) 830maptile::find_sync (const char *path, maptile *origin)
839{ 831{
840 CALL_BEGIN (2); 832 CALL_BEGIN (2);
841 CALL_ARG (path); 833 CALL_ARG (path);
842 CALL_ARG (origin); 834 CALL_ARG (origin);
843 CALL_CALL ("cf::map::find_sync", G_SCALAR); 835 CALL_CALL ("cf::map::find_sync", G_SCALAR);
836
837 maptile *retval;
838
839 if (count)
840 sv_to (POPs, retval);
841 else
842 retval = 0;
843
844 CALL_END;
845
846 return retval;
847}
848
849maptile *
850maptile::find_async (const char *path, maptile *origin)
851{
852 CALL_BEGIN (2);
853 CALL_ARG (path);
854 CALL_ARG (origin);
855 CALL_CALL ("cf::map::find_async", G_SCALAR);
844 856
845 maptile *retval; 857 maptile *retval;
846 858
847 if (count) 859 if (count)
848 sv_to (POPs, retval); 860 sv_to (POPs, retval);
… …
901void 913void
902iw::alloc () 914iw::alloc ()
903{ 915{
904 pe = GEventAPI->new_idle (0, 0); 916 pe = GEventAPI->new_idle (0, 0);
905 917
918 WaREENTRANT_off (pe);
906 pe->base.callback = (void *)iw_dispatch; 919 pe->base.callback = (void *)iw_dispatch;
907 pe->base.ext_data = (void *)this; 920 pe->base.ext_data = (void *)this;
908} 921}
909 922
910static void iow_dispatch (pe_event *ev) 923static void iow_dispatch (pe_event *ev)
… …
916void 929void
917iow::alloc () 930iow::alloc ()
918{ 931{
919 pe = GEventAPI->new_io (0, 0); 932 pe = GEventAPI->new_io (0, 0);
920 933
934 WaREENTRANT_off (pe);
921 pe->base.callback = (void *)iow_dispatch; 935 pe->base.callback = (void *)iow_dispatch;
922 pe->base.ext_data = (void *)this; 936 pe->base.ext_data = (void *)this;
923 937
924 pe->fd = -1; 938 pe->fd = -1;
925 pe->poll = 0; 939 pe->poll = 0;
… …
1253 const_iv (FLAG_ACTIVATE_ON_RELEASE) 1267 const_iv (FLAG_ACTIVATE_ON_RELEASE)
1254 const_iv (FLAG_IS_WATER) 1268 const_iv (FLAG_IS_WATER)
1255 const_iv (FLAG_CONTENT_ON_GEN) 1269 const_iv (FLAG_CONTENT_ON_GEN)
1256 const_iv (FLAG_IS_A_TEMPLATE) 1270 const_iv (FLAG_IS_A_TEMPLATE)
1257 const_iv (FLAG_IS_BUILDABLE) 1271 const_iv (FLAG_IS_BUILDABLE)
1272 const_iv (FLAG_DESTROY_ON_DEATH)
1273 const_iv (FLAG_NO_MAP_SAVE)
1258 1274
1259 const_iv (NDI_BLACK) 1275 const_iv (NDI_BLACK)
1260 const_iv (NDI_WHITE) 1276 const_iv (NDI_WHITE)
1261 const_iv (NDI_NAVY) 1277 const_iv (NDI_NAVY)
1262 const_iv (NDI_RED) 1278 const_iv (NDI_RED)
… …
1447 const_iv (ATNR_BLIND) 1463 const_iv (ATNR_BLIND)
1448 const_iv (ATNR_INTERNAL) 1464 const_iv (ATNR_INTERNAL)
1449 const_iv (ATNR_LIFE_STEALING) 1465 const_iv (ATNR_LIFE_STEALING)
1450 const_iv (ATNR_DISEASE) 1466 const_iv (ATNR_DISEASE)
1451 1467
1452 const_iv (MAP_FLUSH)
1453 const_iv (MAP_PLAYER_UNIQUE)
1454 const_iv (MAP_BLOCK)
1455 const_iv (MAP_STYLE)
1456 const_iv (MAP_OVERLAY)
1457
1458 const_iv (MAP_IN_MEMORY) 1468 const_iv (MAP_IN_MEMORY)
1459 const_iv (MAP_SWAPPED) 1469 const_iv (MAP_SWAPPED)
1460 const_iv (MAP_LOADING) 1470 const_iv (MAP_LOADING)
1461 const_iv (MAP_SAVING) 1471 const_iv (MAP_SAVING)
1462 1472
… …
1475 const_iv (ST_SETUP) 1485 const_iv (ST_SETUP)
1476 const_iv (ST_PLAYING) 1486 const_iv (ST_PLAYING)
1477 const_iv (ST_CUSTOM) 1487 const_iv (ST_CUSTOM)
1478 1488
1479 const_iv (ST_CHANGE_CLASS) 1489 const_iv (ST_CHANGE_CLASS)
1480 const_iv (ST_CONFIRM_QUIT)
1481 const_iv (ST_GET_PARTY_PASSWORD)
1482 1490
1483 const_iv (IO_HEADER) 1491 const_iv (IO_HEADER)
1484 const_iv (IO_OBJECTS) 1492 const_iv (IO_OBJECTS)
1485 const_iv (IO_UNIQUES) 1493 const_iv (IO_UNIQUES)
1486 1494
… …
1540 1548
1541void _global_reattach () 1549void _global_reattach ()
1542 CODE: 1550 CODE:
1543{ 1551{
1544 // reattach to all attachable objects in the game. 1552 // reattach to all attachable objects in the game.
1545 for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i) 1553 for_all_clients (ns)
1546 (*i)->reattach (); 1554 ns->reattach ();
1547 1555
1548 for_all_players (pl) 1556 for_all_players (pl)
1549 pl->reattach (); 1557 pl->reattach ();
1550 1558
1551 //TODO 1559 //TODO
1552 //for (map_container::iterator i = maps.begin (); i != maps.end (); ++i) 1560 //for (map_container::iterator i = maps.begin (); i != maps.end (); ++i)
1553 // i->second->reattach (); 1561 // i->second->reattach ();
1554 1562
1555 for (object *op = object::first; op; op = op->next) 1563 for_all_objects (op)
1556 op->reattach (); 1564 op->reattach ();
1557} 1565}
1558 1566
1559NV floor (NV x) 1567NV floor (NV x)
1560 1568
1561NV ceil (NV x) 1569NV ceil (NV x)
1570
1571NV rndm (...)
1572 CODE:
1573 switch (items)
1574 {
1575 case 0: RETVAL = rndm (); break;
1576 case 1: RETVAL = rndm (SvUV (ST (0))); break;
1577 case 2: RETVAL = rndm (SvIV (ST (0)), SvIV (ST (1))); break;
1578 default: croak ("cf::rndm requires none, one or two parameters."); break;
1579 }
1580 OUTPUT:
1581 RETVAL
1562 1582
1563void server_tick () 1583void server_tick ()
1564 CODE: 1584 CODE:
1565 runtime = SvNVx (sv_runtime); 1585 runtime = SvNVx (sv_runtime);
1566 server_tick (); 1586 server_tick ();
… …
1613 } 1633 }
1614 OUTPUT: RETVAL 1634 OUTPUT: RETVAL
1615 1635
1616void abort () 1636void abort ()
1617 1637
1638void fork_abort (char *cause = "cf::fork_abort")
1639
1640void cleanup (const char *cause, bool make_core = false)
1641
1618void emergency_save () 1642void emergency_save ()
1643
1644UV sv_2watcher (SV *w)
1645 CODE:
1646 RETVAL = (UV)GEventAPI->sv_2watcher (w);
1647 OUTPUT:
1648 RETVAL
1619 1649
1620void _exit (int status = 0) 1650void _exit (int status = 0)
1621 1651
1622#if _POSIX_MEMLOCK 1652#if _POSIX_MEMLOCK
1623 1653
… …
1680 CODE: 1710 CODE:
1681 RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext); 1711 RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
1682 OUTPUT: 1712 OUTPUT:
1683 RETVAL 1713 RETVAL
1684 1714
1685#bool 1715int mortals_size ()
1686#destroyed (attachable *at) 1716 CODE:
1687# 1717 RETVAL = attachable::mortals.size ();
1688#void 1718 OUTPUT: RETVAL
1689#destroy (attachable *at) 1719
1720#object *mortals (U32 index)
1721# CODE:
1722# RETVAL = index < attachable::mortals.size () ? attachable::mortals [index] : 0;
1723# OUTPUT: RETVAL
1724
1725INCLUDE: $PERL genacc attachable ../include/cfperl.h |
1690 1726
1691MODULE = cf PACKAGE = cf::global 1727MODULE = cf PACKAGE = cf::global
1692 1728
1693int invoke (SV *klass, int event, ...) 1729int invoke (SV *klass, int event, ...)
1694 CODE: 1730 CODE:
… …
1710 RETVAL = op->invoke ((event_type)event, ARG_AV (av), DT_END); 1746 RETVAL = op->invoke ((event_type)event, ARG_AV (av), DT_END);
1711 OUTPUT: RETVAL 1747 OUTPUT: RETVAL
1712 1748
1713SV *registry (object *op) 1749SV *registry (object *op)
1714 1750
1715void mortals () 1751int objects_size ()
1716 PPCODE: 1752 CODE:
1717 EXTEND (SP, object::mortals.size ());
1718 for (AUTODECL (i, object::mortals.begin ()); i != object::mortals.end (); ++i)
1719 PUSHs (to_sv (*i));
1720
1721object *first ()
1722 CODE:
1723 RETVAL = object::first; 1753 RETVAL = objects.size ();
1754 OUTPUT: RETVAL
1755
1756object *objects (U32 index)
1757 CODE:
1758 RETVAL = index < objects.size () ? objects [index] : 0;
1759 OUTPUT: RETVAL
1760
1761int actives_size ()
1762 CODE:
1763 RETVAL = actives.size ();
1764 OUTPUT: RETVAL
1765
1766object *actives (U32 index)
1767 CODE:
1768 RETVAL = index < actives.size () ? actives [index] : 0;
1724 OUTPUT: RETVAL 1769 OUTPUT: RETVAL
1725 1770
1726# missing properties 1771# missing properties
1727 1772
1728object *head (object *op) 1773object *head (object *op)
1729 PROTOTYPE: $ 1774 PROTOTYPE: $
1730 CODE: 1775 CODE:
1731 RETVAL = op->head ? op->head : op; 1776 RETVAL = op->head_ ();
1732 OUTPUT: RETVAL 1777 OUTPUT: RETVAL
1733 1778
1734int is_head (object *op) 1779int is_head (object *op)
1735 PROTOTYPE: $ 1780 PROTOTYPE: $
1736 CODE: 1781 CODE:
1737 RETVAL = !op->head; 1782 RETVAL = op->head_ () == op;
1738 OUTPUT: RETVAL 1783 OUTPUT: RETVAL
1739 1784
1740void 1785void
1741inv (object *obj) 1786inv (object *obj)
1742 PROTOTYPE: $ 1787 PROTOTYPE: $
… …
1833 1878
1834void drop (object *who, object *op) 1879void drop (object *who, object *op)
1835 1880
1836void pick_up (object *who, object *op) 1881void pick_up (object *who, object *op)
1837 1882
1838object *cf_object_insert_object (object *op, object *container)
1839
1840object *cf_object_insert_in_ob (object *ob, object *where)
1841
1842int cf_object_teleport (object *op, maptile *map, int x, int y) 1883int cf_object_teleport (object *op, maptile *map, int x, int y)
1843 1884
1844void update_object (object *op, int action) 1885void update_object (object *op, int action)
1845 1886
1846object *cf_create_object_by_name (const char *name) 1887object *cf_create_object_by_name (const char *name)
… …
1965void esrv_update_item (object *op, int what, object *item) 2006void esrv_update_item (object *op, int what, object *item)
1966 C_ARGS: what, op, item 2007 C_ARGS: what, op, item
1967 2008
1968void clear_los (object *op) 2009void clear_los (object *op)
1969 2010
1970int command_teleport (object *op, char *params)
1971
1972int command_summon (object *op, char *params) 2011int command_summon (object *op, char *params)
1973 2012
1974int command_arrest (object *op, char *params) 2013int command_arrest (object *op, char *params)
1975 2014
1976int command_kick (object *op, char *params) 2015int command_kick (object *op, char *params)
… …
1997 CODE: 2036 CODE:
1998 pl->ob->stats.hp = pl->ob->stats.maxhp; 2037 pl->ob->stats.hp = pl->ob->stats.maxhp;
1999 pl->ob->stats.sp = pl->ob->stats.maxsp; 2038 pl->ob->stats.sp = pl->ob->stats.maxsp;
2000 pl->ob->stats.grace = pl->ob->stats.maxgrace; 2039 pl->ob->stats.grace = pl->ob->stats.maxgrace;
2001 pl->orig_stats = pl->ob->stats; 2040 pl->orig_stats = pl->ob->stats;
2002
2003player *cf_player_find (char *name)
2004 PROTOTYPE: $
2005 2041
2006void cf_player_move (player *pl, int dir) 2042void cf_player_move (player *pl, int dir)
2007 2043
2008void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0); 2044void play_sound_player_only (player *pl, int soundnum, int x = 0, int y = 0);
2009 2045
… …
2055 if (y) sv_to (y, pl->bed_y); 2091 if (y) sv_to (y, pl->bed_y);
2056 2092
2057void 2093void
2058list () 2094list ()
2059 PPCODE: 2095 PPCODE:
2060 for (player *pl = first_player; pl; pl = pl->next) 2096 for_all_players (pl)
2061 XPUSHs (sv_2mortal (to_sv (pl))); 2097 XPUSHs (sv_2mortal (to_sv (pl)));
2062
2063bool
2064peaceful (player *pl, bool new_setting = 0)
2065 PROTOTYPE: $;$
2066 CODE:
2067 RETVAL = pl->peaceful;
2068 if (items > 1)
2069 pl->peaceful = new_setting;
2070 OUTPUT:
2071 RETVAL
2072
2073living *
2074orig_stats (player *pl)
2075 CODE:
2076 RETVAL = &pl->orig_stats;
2077 OUTPUT: RETVAL
2078
2079living *
2080last_stats (player *pl)
2081 CODE:
2082 RETVAL = &pl->last_stats;
2083 OUTPUT: RETVAL
2084 2098
2085 2099
2086MODULE = cf PACKAGE = cf::map PREFIX = cf_map_ 2100MODULE = cf PACKAGE = cf::map PREFIX = cf_map_
2087 2101
2088int invoke (maptile *map, int event, ...) 2102int invoke (maptile *map, int event, ...)
… …
2104 PROTOTYPE: 2118 PROTOTYPE:
2105 CODE: 2119 CODE:
2106 RETVAL = new maptile; 2120 RETVAL = new maptile;
2107 OUTPUT: 2121 OUTPUT:
2108 RETVAL 2122 RETVAL
2109
2110void
2111maptile::destroy ()
2112 2123
2113void 2124void
2114maptile::players () 2125maptile::players ()
2115 PPCODE: 2126 PPCODE:
2116 if (GIMME_V == G_SCALAR) 2127 if (GIMME_V == G_SCALAR)
… …
2146 2157
2147object* cf_map_present_arch_by_name (maptile *map, const char* str, int nx, int ny) 2158object* cf_map_present_arch_by_name (maptile *map, const char* str, int nx, int ny)
2148 C_ARGS: str, map, nx, ny 2159 C_ARGS: str, map, nx, ny
2149 2160
2150void 2161void
2151cf_map_normalise (maptile *map, int x, int y) 2162get_map_flags (maptile *map, int x, int y)
2152 PPCODE: 2163 PPCODE:
2153{ 2164{
2154 maptile *nmap = 0; 2165 maptile *nmap = 0;
2155 I16 nx = 0, ny = 0; 2166 I16 nx = 0, ny = 0;
2156 int flags = get_map_flags (map, &nmap, x, y, &nx, &ny); 2167 int flags = get_map_flags (map, &nmap, x, y, &nx, &ny);
… …
2218 CODE: 2229 CODE:
2219 RETVAL = get_name_of_region_for_map (m); 2230 RETVAL = get_name_of_region_for_map (m);
2220 OUTPUT: RETVAL 2231 OUTPUT: RETVAL
2221 2232
2222# worst xs function of my life 2233# worst xs function of my life
2223maptile * 2234bool
2224_create_random_map (\ 2235_create_random_map (\
2225 char *path,\ 2236 maptile *self,\
2226 char *wallstyle,\ 2237 char *wallstyle,\
2227 char *wall_name,\ 2238 char *wall_name,\
2228 char *floorstyle,\ 2239 char *floorstyle,\
2229 char *monsterstyle,\ 2240 char *monsterstyle,\
2230 char *treasurestyle,\ 2241 char *treasurestyle,\
… …
2234 char *origin_map,\ 2245 char *origin_map,\
2235 char *final_map,\ 2246 char *final_map,\
2236 char *exitstyle,\ 2247 char *exitstyle,\
2237 char *this_map,\ 2248 char *this_map,\
2238 char *exit_on_final_map,\ 2249 char *exit_on_final_map,\
2239 int Xsize,\ 2250 int xsize,\
2240 int Ysize,\ 2251 int ysize,\
2241 int expand2x,\ 2252 int expand2x,\
2242 int layoutoptions1,\ 2253 int layoutoptions1,\
2243 int layoutoptions2,\ 2254 int layoutoptions2,\
2244 int layoutoptions3,\ 2255 int layoutoptions3,\
2245 int symmetry,\ 2256 int symmetry,\
… …
2250 int dungeon_depth,\ 2261 int dungeon_depth,\
2251 int decoroptions,\ 2262 int decoroptions,\
2252 int orientation,\ 2263 int orientation,\
2253 int origin_y,\ 2264 int origin_y,\
2254 int origin_x,\ 2265 int origin_x,\
2255 int random_seed,\ 2266 U32 random_seed,\
2256 val64 total_map_hp,\ 2267 val64 total_map_hp,\
2257 int map_layout_style,\ 2268 int map_layout_style,\
2258 int treasureoptions,\ 2269 int treasureoptions,\
2259 int symmetry_used,\ 2270 int symmetry_used,\
2260 region *region\ 2271 region *region,\
2272 char *custom\
2261) 2273)
2262 CODE: 2274 CODE:
2263{ 2275{
2264 random_map_params rmp; 2276 random_map_params rmp;
2265 2277
… …
2275 assign (rmp.exit_on_final_map, exit_on_final_map); 2287 assign (rmp.exit_on_final_map, exit_on_final_map);
2276 2288
2277 rmp.origin_map = origin_map; 2289 rmp.origin_map = origin_map;
2278 rmp.final_map = final_map; 2290 rmp.final_map = final_map;
2279 rmp.this_map = this_map; 2291 rmp.this_map = this_map;
2280 rmp.Xsize = Xsize; 2292 rmp.xsize = xsize;
2281 rmp.Ysize = Ysize; 2293 rmp.ysize = ysize;
2282 rmp.expand2x = expand2x; 2294 rmp.expand2x = expand2x;
2283 rmp.layoutoptions1 = layoutoptions1; 2295 rmp.layoutoptions1 = layoutoptions1;
2284 rmp.layoutoptions2 = layoutoptions2; 2296 rmp.layoutoptions2 = layoutoptions2;
2285 rmp.layoutoptions3 = layoutoptions3; 2297 rmp.layoutoptions3 = layoutoptions3;
2286 rmp.symmetry = symmetry; 2298 rmp.symmetry = symmetry;
… …
2297 rmp.total_map_hp = total_map_hp; 2309 rmp.total_map_hp = total_map_hp;
2298 rmp.map_layout_style = map_layout_style; 2310 rmp.map_layout_style = map_layout_style;
2299 rmp.treasureoptions = treasureoptions; 2311 rmp.treasureoptions = treasureoptions;
2300 rmp.symmetry_used = symmetry_used; 2312 rmp.symmetry_used = symmetry_used;
2301 rmp.region = region; 2313 rmp.region = region;
2314 rmp.custom = custom;
2302 2315
2303 RETVAL = generate_random_map (path, &rmp); 2316 RETVAL = self->generate_random_map (&rmp);
2304} 2317}
2305 OUTPUT: 2318 OUTPUT:
2306 RETVAL 2319 RETVAL
2307 2320
2308MODULE = cf PACKAGE = cf::arch 2321MODULE = cf PACKAGE = cf::arch
… …
2384 char *buf = SvPVbyte (packet, len); 2397 char *buf = SvPVbyte (packet, len);
2385 2398
2386 THIS->send_packet (buf, len); 2399 THIS->send_packet (buf, len);
2387} 2400}
2388 2401
2389void
2390client::destroy ()
2391

Diff Legend

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