Added public files
Roughly added all public files. Probably missed some, though.
diff --git a/std/armour/wear.c b/std/armour/wear.c
new file mode 100644
index 0000000..fef87c5
--- /dev/null
+++ b/std/armour/wear.c
@@ -0,0 +1,260 @@
+// MorgenGrauen MUDlib
+//
+// armour/wear.c -- armour standard object
+//
+// $Id: combat.c 6243 2007-03-15 21:10:21Z Zesstra $
+
+#pragma strict_types
+#pragma save_types
+#pragma no_clone
+#pragma pedantic
+#pragma range_check
+
+inherit "/std/clothing/wear";
+
+#define NEED_PROTOTYPES
+
+#include <thing/properties.h>
+#include <living/combat.h>
+#include <living/attributes.h>
+#include <language.h>
+#include <defines.h>
+#include <armour.h>
+
+// Uebernimmt viele wesentliche Eigenschaften aus der Kleidung, daher werden
+// hier auch nur div. Funktionen ueberschrieben, die sich leicht
+// unterschiedlich zur Kleidung verhalten.
+
+// Globale Variablen
+private nosave int logged;
+
+protected void create() {
+ ::create();
+ // P_DAMAGED laesst sich zwar (noch) von aussen setzen, aber bitte nur ueber
+ // die hier definierte Setmethode.
+ // TODO: Direktes Setzen von P_DAMAGED entfernen.
+ Set(P_DAMAGED, PROTECTED, F_MODE_AS);
+}
+
+/* Wenn eine Ruestung vom gleichen Typ im Array ist, gebe diese zurueck. */
+private object TestType(object *armours) {
+ mixed type;
+
+ // Den eigenen Typ feststellen
+ type = QueryProp(P_ARMOUR_TYPE);
+
+ // Zerstoerte Objekte aussortieren
+ armours-=({0});
+
+ foreach(object armour: armours)
+ {
+ if (type==(armour->QueryProp(P_ARMOUR_TYPE)))
+ {
+ // Ruestung vom gleichen Typ gefunden -> zurueckgeben
+ return armour;
+ }
+ }
+ // Keine Ruestung vom gleichen Typ gefunden, also 0 zurueckgeben
+ return 0;
+}
+
+// liefert 1 zurueck, wenn der Spieler die ruestung anziehen darf, 0 sonst.
+protected int _check_wear_restrictions(int silent, int all) {
+ mixed type,res;
+ object *armours;
+
+ type = QueryProp(P_ARMOUR_TYPE);
+
+ // Das DoWear() der Kleidung prueft auf genuegend freie Haende,
+ // prueft aber den Fall nicht ab, ob man hier ein Schild hat, was laut Prop
+ // weniger als eine Hand belegt. Daher hier nachholen und korrigieren. Und
+ // direkt mal loggen, damit das gefixt wird.
+ if ( (type==AT_SHIELD) && QueryProp(P_NR_HANDS)<1 ) {
+ SetProp(P_NR_HANDS,1);
+ log_file("INVALID_SHIELD",
+ sprintf("Fixme: AT_SHIELD item without valid P_NR_HANDS: %O\n",
+ object_name()));
+ }
+
+ armours=(object*)PL->QueryProp(P_ARMOURS) - ({0});
+
+ // Von jedem Ruestungstyp ausser AT_MISC kann man immer nur ein
+ // Teil tragen
+ if ( (type!=AT_MISC) && (res=TestType(armours)) && objectp(res)) {
+ msg(break_string(sprintf(
+ "Du traegst bereits %s als Schutz der Sorte %s.",
+ res->name(WEN,1), type),78,
+ (all?(Name(WER)+": "):0)), all);
+ return(-1);
+ }
+
+ // Ruestungen vom Typ AT_ILLEGAL oder solche mit einem fuer ihren
+ // Ruestungstyp zu hohen Schutzwert koennen nicht angezogen werden
+ if ( (type==AT_ILLEGAL) || (QueryProp(P_AC)>VALID_ARMOUR_CLASS[type])) {
+ write("Ungueltiger Ruestungstyp, bitte Erzmagier verstaendigen.\n");
+ "/p/daemon/ruestungen"->RegisterArmour();
+ return(-2);
+ }
+
+ // Ruestungen, die ein oder mehrere Attribut veraendern und gegen
+ // das gesetzte Limit verstossen, haben keine Wirkung bezueglich der
+ // Attribute. Dies gibt aber nur ne Meldung aus, angezogen werden darf sie
+ // trotzdem.
+ if (mappingp(res=QueryProp(P_M_ATTR_MOD)) && PL->TestLimitViolation(res) ) {
+ write(break_string(sprintf(
+ "Irgendetwas an Deiner Ausruestung verhindert, dass Du Dich mit "
+ "%s so richtig wohl fuehlst.",name(WEM,1)),78,
+ (all?(Name(WER)+": "):0)));
+ }
+
+ // dann mal aus der Kleidung geerbte Pruefungen ausfuehren und Ergebnis
+ // liefern.
+ return ::_check_wear_restrictions(silent,all);
+}
+
+protected void _informwear(int silent, int all) {
+
+ // Ruestungen koennen Resistenzen beeinflussen
+ PL->AddResistanceModifier(QueryProp(P_RESISTANCE_STRENGTHS),
+ QueryProp(P_ARMOUR_TYPE));
+
+ // Ruestungen koennen Attribute aendern/blockieren. Also muessen diese
+ // nach dem Anziehen aktualisiert werden
+ PL->register_modifier(ME);
+ PL->UpdateAttributes();
+
+ // P_TOTAL_AC im Traeger updaten (fuer Query()s)
+ PL->QueryProp(P_TOTAL_AC);
+
+ // Alle Ruestungen werden im awmaster registriert, sobald sie von
+ // einem Spieler gezueckt werden
+ if (!logged && query_once_interactive(PL)) {
+ call_other("/secure/awmaster","RegisterArmour",ME);
+ logged=1;
+ }
+ // noch das aus der Kleidung rufen, damit die Anziehmeldungen auch kommen.
+ // ausserdem laeuft das Anstosses von InformWear() von dort.
+ ::_informwear(silent,all);
+}
+
+
+protected int _check_unwear_restrictions(object worn_by, int silent,
+ int all) {
+ // liefert >=0 zureck, wenn die Kleidung/Ruestung ausgezogen werden kann,
+ // <0 sonst.
+
+ // Schilde belegen (mindestens) eine Hand. Hngl. Wenn man diesen bloeden
+ // Check nicht machen muesste, koennte man sich die ganze Funktion sparen.
+ // Hmpfgrmpfl. Achja, raise_error(), weil das eigentlich ja nicht vorkommen
+ // sollte und gefixt werden soll. Das geht naemlich nur, wenn jemand diese
+ // Prop geaendert, waehrend der Spieler das Schild getragen hatte.
+ if ( (QueryProp(P_ARMOUR_TYPE)==AT_SHIELD) &&
+ QueryProp(P_NR_HANDS)<1 ) {
+ raise_error(sprintf("Fixme: AT_SHIELD beim Ausziehen ohne P_NR_HANDS: %O",
+ object_name()));
+ }
+
+ // Ausziehcheck der Kleidung machen
+ return ::_check_unwear_restrictions(worn_by,silent,all);
+}
+
+protected void _informunwear(object worn_by, int silent, int all) {
+ mixed res;
+ // Gesetzte Resistenzen loeschen
+ worn_by->RemoveResistanceModifier(res=QueryProp(P_ARMOUR_TYPE));
+
+ // Ruestungen koennen Attribute aendern/blockieren. Also muessen diese
+ // nach dem Ausziehen aktualisiert werden
+ worn_by->deregister_modifiers(ME);
+ worn_by->UpdateAttributes();
+
+ // P_TOTAL_AC im Traeger updaten
+ worn_by->QueryProp(P_TOTAL_AC);
+
+ // die geerbte Funktion aus der Kleindung gibt noch meldungen aus und ruft
+ // Informunwear().
+ ::_informunwear(worn_by,silent,all);
+}
+
+// Funktion, die das "trage"/"ziehe * an"-Kommando auswertet
+varargs int do_wear(string str, int silent) {
+ int all;
+
+ // Hat der Spieler "trage alles" eingegeben?
+ all=(str=="alles" || str=="alle ruestungen");
+
+ return(_do_wear(str,silent,all));
+}
+
+// Die Funktion, die das "ziehe * aus"-Kommando auswertet
+varargs int do_unwear(string str, int silent) {
+ int all;
+
+ all=(str=="alles" || str=="alle ruestungen");
+ return(_do_unwear(str,silent,all));
+}
+
+
+// Objekte, die die Beschaedigung einer Ruestung durch direktes Setzen von
+// P_DAMAGED durchfuehren, werden im awmaster geloggt
+static mixed _set_item_damaged(mixed arg) {
+ if (arg && !intp(arg))
+ {
+ return Query(P_DAMAGED, F_VALUE);
+ }
+
+ if (previous_object(1))
+ call_other("/secure/awmaster","RegisterDamager",
+ previous_object(1),QueryProp(P_DAMAGED),arg);
+
+ return Set(P_DAMAGED, arg, F_VALUE);
+}
+
+// Will man eine Ruestung beschaedigen oder reparieren, so macht man das
+// am besten ueber die Funktion Damage(argument). Positive Argumente
+// bedeuten eine Beschaedigung, negative eine Reparatur. Der Rueckgabewert
+// ist die wirklich durchgefuehrte Aenderung des Beschaedigungswertes
+int Damage(int new_dam) {
+ int ac,maximum,old_dam;
+ object w;
+
+ if (!new_dam || !intp(new_dam)) {
+ return 0;
+ }
+
+ if ( (ac=QueryProp(P_AC))<=0 && (new_dam>0) ) {
+ // Sonst wuerde Beschaedigung zur Reparatur fuehren
+ return 0;
+ }
+
+ // Min-AC und MAX_AC beachten
+ if ((ac-new_dam) < MIN_ARMOUR_CLASS) {
+ new_dam = ac-MIN_ARMOUR_CLASS;
+ }
+ else if ((ac-new_dam) >
+ (maximum=VALID_ARMOUR_CLASS[QueryProp(P_ARMOUR_TYPE)])) {
+ new_dam = ac-maximum;
+ }
+
+ // Nie mehr als 100% reparieren
+ if ( ((old_dam=QueryProp(P_DAMAGED))<-new_dam) && (new_dam<0) ) {
+ new_dam=-old_dam;
+ }
+
+ // Aenderungen an der Ruestungsklasse und dem Beschaedigungswert
+ // durchfuehren
+ SetProp(P_AC,(ac-new_dam));
+ // eigene Set-Methode umgehen
+ Set(P_DAMAGED,(old_dam+new_dam),F_VALUE);
+
+ // P_TOTAL_AC im Traeger updaten, wenn vorhanden
+ if (objectp(w=QueryProp(P_WORN)))
+ w->QueryProp(P_TOTAL_AC);
+
+ // Rueckgabewert: Durchgefuehrte Aenderung an P_DAMAGE
+ return new_dam;
+}
+
+public status IsArmour() {return 1;}
+public status IsClothing() {return 0;}
+