Added public files
Roughly added all public files. Probably missed some, though.
diff --git a/std/armour/combat.c b/std/armour/combat.c
new file mode 100644
index 0000000..e688131
--- /dev/null
+++ b/std/armour/combat.c
@@ -0,0 +1,228 @@
+// MorgenGrauen MUDlib
+//
+// armour/combat.c -- armour standard object
+//
+// $Id: combat.c 9092 2015-01-19 23:57:50Z Zesstra $
+
+#pragma strict_types
+#pragma save_types
+#pragma no_clone
+#pragma pedantic
+#pragma range_check
+
+#define NEED_PROTOTYPES
+
+#include <thing/properties.h>
+#include <thing/commands.h>
+#include <thing/description.h>
+#include <config.h>
+#include <combat.h>
+#include <language.h>
+#include <defines.h>
+#include <new_skills.h>
+
+
+// Globale Variablen
+private nosave closure defend_cl;
+private nosave mapping resistance_strengths=([]);
+
+void create() {
+ // Einige Grundwerte setzen
+ Set(P_ARMOUR_TYPE, AT_ILLEGAL, F_VALUE);
+ Set(P_LAST_USE,time(),F_VALUE);
+}
+
+// Die Funktion, die den Schutzwert berechnet, den die Ruestung bietet
+int QueryDefend(string|string* dam_type, int|mapping spell, object enemy)
+{
+ int prot;
+ mixed def_func;
+ object pl;
+ // Zum Cachen von spell[EINFO_DEFEND], haeufiges Lookup aus dem Mapping
+ // koennte unnoetig Zeit kosten.
+ mapping einfo;
+
+ // AT_MISC-Ruetungen schuetzen normalerweise gar nicht...
+ if (QueryProp(P_ARMOUR_TYPE)==AT_MISC) {
+ // es sei denn, sie haben eine spezielle DefendFunc
+ if (!closurep(defend_cl)) return(0);
+ }
+ else {
+ // ansonsten Ruestungsschutz ermitteln und in EINFO_DEFEND vermerken.
+ // (Beides fuer AT_MISC in jedem Fall unnoetig)
+
+ // Ruestungen schuetzen nur gegen physikalischen Schaden
+ if ((!spell || (mappingp(spell) && spell[SP_PHYSICAL_ATTACK]))
+ && sizeof(filter(dam_type,PHYSICAL_DAMAGE_TYPES)))
+ {
+ // Schutz bestimmen, Minimum 1, aber nur wenn P_AC > 0
+ int pac = QueryProp(P_AC);
+ if (pac > 0)
+ prot = (pac/4 + random(pac*3/4 + 1)) || 1 ;
+ object stat = find_object("/d/erzmagier/zesstra/pacstat");
+ if (stat)
+ stat->acstat(QueryProp(P_ARMOUR_TYPE),prot,
+ random(pac)+1);
+
+ // ruestungschutz an defendfunc weitermelden
+ if (mappingp(spell) &&
+ mappingp(einfo=spell[EINFO_DEFEND])) {
+ // Schutz d. akt. Ruestung vermerken.
+ einfo[DEFEND_CUR_ARMOUR_PROT]=prot;
+ // daten der Ruestung vermerken.
+ if (mappingp(einfo[DEFEND_ARMOURS])) {
+ einfo[DEFEND_ARMOURS][ME,DEF_ARMOUR_PROT]=prot;
+ }
+ } // ende vom if (mapping(spell) ...)
+ } // ende vom if (phys Schaden)
+
+ } // ende vom else (wenn kein AT_MISC)
+
+ // Ist eine DefendFunc gesetzt, wird diese ausgewertet
+ if (closurep(defend_cl)) {
+ if (!objectp(get_type_info(defend_cl,2))) {
+ // Closure gesetzt, aber nicht gueltig, schauen, ob wir sie neu
+ // erstellen koennen.
+ if (objectp(def_func=QueryProp(P_DEFEND_FUNC))) {
+ defend_cl=symbol_function("DefendFunc",def_func);
+ }
+ // sonst loeschen, um spaeter diesen Zweig ganz zu sparen.
+ else defend_cl=0;
+ }
+ // BTW: Es ist ok, wenn defend_cl jetzt 0 ist, dann liefert funcall()
+ // auch 0.
+ // Bei Netztoten keine (zurueckschlagende) DefendFunc
+ if (objectp(pl=QueryProp(P_WORN)) && (!query_once_interactive(pl) ||
+ interactive(pl)) ) {
+ // Der Rueckgabewert der DefendFunc wird zum Schutz addiert
+ prot += funcall(defend_cl, dam_type, spell, enemy);
+ // leider kann die DefendFunc jetzt auch noch das Objekt zerstoert
+ // haben...
+ if (!objectp(this_object()))
+ return prot;
+ }
+ }
+
+ // Zeitpunkt der letzten Benutzung ausgeben
+ SetProp(P_LAST_USE,time());
+
+ // Berechneten Schutz zurueckgeben
+ return prot;
+}
+
+// Es duerfen nur "legale" Ruestungstypen gesetzt werden, ansonsten
+// wird AT_ILLEGAL gesetzt.
+static mixed _set_armour_type(mixed type ) {
+ if (!COMBAT_MASTER->valid_armour_type(type))
+ {
+ Set(P_ARMOUR_TYPE, (type=AT_ILLEGAL), F_VALUE);
+ }
+ else
+ {
+ Set(P_ARMOUR_TYPE, type);
+ }
+ AddId(type);
+
+ resistance_strengths=([]);
+ return type;
+}
+
+
+// Wird etwas an P_DEFEND_FUNC geaendert, muss die zugehoerige closure
+// neu erstellt werden.
+static object _set_defend_func(object arg) {
+ if (objectp(arg) &&
+ closurep(defend_cl=symbol_function("DefendFunc",arg))) {
+ return Set(P_DEFEND_FUNC, arg, F_VALUE);
+ }
+ defend_cl=0;
+ return(Set(P_DEFEND_FUNC, 0, F_VALUE));
+}
+
+// Auch Ruestungen koennen einen Schadenstyp haben. Dieser kann als string
+// oder array angegeben werden, wird aber intern auf jeden Fall als
+// array gespeichert.
+static mixed _set_dam_type(mixed arg) {
+ if (pointerp(arg))
+ {
+ return Set(P_DAM_TYPE, arg, F_VALUE);
+ }
+ else if (stringp(arg))
+ {
+ return Set(P_DAM_TYPE, ({ arg }), F_VALUE);
+ }
+ return Query(P_DAM_TYPE, F_VALUE);
+}
+
+// Ruestungen koennen Resistenzen setzen. Diese werden jedoch nicht wie
+// "normale" Resistenzen gesetzt, sondern als Prozentwerte der fuer diesen
+// Typ maximal zulaesigen Resistenz. Die Aenderung der Resistenzen darf
+// nur durch die Ruestung selbst erfolgen.
+// Beispiel: ([DT_FIRE: 100, DT_WATER: -150])
+// max. Feuerresistenz, 1.5fache Anfaelligkeit
+static mixed _set_resistance_strengths(mixed resmap) {
+ float max_res;
+ object worn_by;
+
+ // Es duerfen nur mappings angegeben werden
+ if (!mappingp(resmap))
+ {
+ return -1;
+ }
+
+ // die Maxwerte muessen jeweils durch -100 geteilt sein, da hinterher
+ // mit der Prozentzahl multipliziert wird und die angabe der Vorzeichen
+ // hier umgekehrt wie bei den "normalen" Resistenzen ist. Der
+ // Maximalwert ist vom Ruestungstyp abhaengig.
+ switch (QueryProp(P_ARMOUR_TYPE))
+ {
+ case AT_CLOAK :
+ case AT_RING :
+ case AT_AMULET : max_res=-0.0010;
+ break;
+ case AT_SHIELD :
+ case AT_ARMOUR : max_res=-0.0015;
+ break;
+ default : max_res=-0.0005;
+ }
+
+ // Resistenz-Mapping aktualisieren
+ resistance_strengths=([]);
+ foreach(string damtype, int res: resmap)
+ {
+ if (!intp(res)) res=to_int(res);
+ // Mehr als 100 Prozent ist nicht erlaubt
+ if (res>100)
+ {
+ res=100;
+ }
+ else if (res<0)
+ {
+ res=(res/4)*5;
+ // Man kann auch nicht beliebig negativ werden
+ if (res<-1000)
+ {
+ res=-1000;
+ }
+ }
+ // Der Resistenzwert berechnet sich aus dem Produkt des
+ // Maximalwertes und der Prozentzahl
+ resistance_strengths[damtype]=res*max_res;
+ }
+
+ // Werden die Resistenzen bei einer getragenen Ruestung geaendert,
+ // muss der Traeger davon natuerlich beeinflusst werden.
+ if (objectp(worn_by=QueryProp(P_WORN)))
+ {
+ worn_by->AddResistanceModifier(resistance_strengths,
+ QueryProp(P_ARMOUR_TYPE));
+ }
+ return resistance_strengths;
+}
+
+// Bei einem QueryProp(P_RESISTANCE_STRENGTHS) soll das aktuelle
+// Resistenzen-Mapping zurueckgegeben werden
+static mapping _query_resistance_strengths() {
+ return (resistance_strengths||([]));
+}
+