
P_SPELLS
********


NAME
====

   P_SPELLS                      "spells"


DEFINIERT IN
============

   /sys/properties.h


BESCHREIBUNG
============

   Array mit den Daten der NPC-Spells mit folgendem Aufbau:

   ({ ({ int spellrate, mapping sinfo, string TextForEnemy,
         string TextForOthers }), ... })

   Der Datentyp ist demzufolge < <int|mapping|string>* >*.

   Pro Spell, der mit AddSpell() eingetragen wurde, ist ein Datenarray
   enthalten.


HINWEIS
=======

   Bitte nicht von Hand setzen, sondern immer AddSpell() verwenden.


SIEHE AUCH:
===========

   AddSpell(L), P_SPELLRATE
