//  raum.c  -- Das Rohgeruest eines Seherhauses.
//
//  Grundobjekt (c) 1994 Boing@MorgenGrauen
//  Abschliessen und Rauswerfen von Jof
//  Fuer Aenderungen ab dem 06.10.94 verantwortlich: Wargon
//  Ab 03.02.98 Wurzel
//
// $Id: raum.c,v 1.5 2003/11/15 14:03:58 mud Exp $
#pragma strong_types,rtt_checks

#include "haus.h"

inherit "/std/room";
inherit USERCMD;    // selbstdefinierte Kommandos
inherit LOSA;       // Load() und Save()
inherit "/mail/nedit";

#include <wizlevels.h>
#include <properties.h>
#include <defines.h>
#include <moving.h>

static mixed detail;
static string owner;
static int flag, csaved;
static int raumNr;
static string *ausgaenge = ({ "oben", "norden", "nordosten", "osten", "suedosten",
                  "unten", "sueden", "suedwesten", "westen", "nordwesten" });

// Prototypes fuer Funktionen aus LOSA
varargs void Save(int crunched);
void Load();

// Prototype
// Falls noetig, mache einen Notausgang, falls nicht loesche vorhandenen
void make_emergency_exit();

// ersetzt @@ durch **
private string normstr(string str)
{
  return implode(explode(str,"@@"),"**");
}

// liefert kommagetrennte Teile ohne zusaetzliche Leerzeichen
// "Bla blubb ,  foo bar,blubber" => ({ "Bla blubb", "foo bar", "blubber" })
private string *brk(string str)
{
  string *t1;

  t1 = explode(str, ",");
  map(t1, #'trim /*'*/);
  return t1;
}

// teste Befehl
private int befCheck(string bef)
{
  // Befehl enthaelt Leerzeichen => return 0
  if (member(bef, ' ') > -1)
    return 0;

  // Befehl ist bereits Kommando (ausser Oeffnen/Schliessen)
  // oder Richtung inclusive "raus" in die kein Ausgang fuehrt
  // => return 0
  if (member(m_indices(QueryProp(P_COMMANDS)) -
                       ({"oeffne","schliess","schliesse"}), bef) > -1
      || (member(ausgaenge+({"raus"}), bef) > -1
          && member(m_indices(QueryProp(P_EXITS)), bef) == -1))
    return 0;

  return 1;
}

// Test auf Hausbesitzer
int tp_owner_check()
{
  if(getuid(this_player()) != owner)
  {
    notify_fail( "Das ist nicht Dein Haus!\n" );
    return 0;
  }
  return 1;
}

// Test auf Hausbesitzer oder Person mit Erlaubnis
int allowed_check(object _test)
{
   string *ext;

   ext = VERWALTER->HausProp(owner, HP_ALLOWED) + ({ capitalize(owner) });
   if(member(ext, capitalize(getuid(_test))) < 0)
   {
     return 0;
   }
   else
   {
     return 1;
   }
}

// Funktion ersetzt durch tp_owner_check() und allowed_check(object _test)
// falls allowed == 0 => test ob this_player() Hausbesitzer
// falls allowed != 0 => test ob allowed/this_player() Hausbesitzer
//                       oder Person mit Erlaubnis
deprecated varargs int owner_check(mixed allowed)
{
  object test;

  if(objectp(allowed) && query_once_interactive(allowed))
  {
    // Parameter ist Spieler
    test = allowed;
  }
  else
  {
    // ansonsten TP
    test = this_player();
  }
  
  if(allowed)
  {
    // Test auf Hausbesitzer oder Person mit Erlaubnis
    if(!allowed_check(test))
    {
      notify_fail( "Das darfst Du in diesem Haus nicht!\n" );
      return 0;
    }
  }
  else if(getuid(test) != owner)
  {
    // Test auf Hausbesitzer
    notify_fail( "Das ist nicht Dein Haus!\n" );
    return 0;
  }
  // Erlaubnis OK
  return 1;
}

// Gestaltet Meldung aus Texten in einem Array:
// array leer               -> melde Text in none
// array hat ein Element    -> melde Text in one und ersetze %s durch Element
// array hat viele Elemente -> melde Text in many und danach
//                             sortierte Aufzaehlung der Elemente
// flag gesetztes Bit 2: Aufzaehlung nur mit Komma, kein 'und'
// flag gesetztes Bit 1: Meldung wird als String returnt, sonst per write ausgegeben
varargs string arr_out(mixed array, string none, string one, string many, int flag)
{
  string tmp, lastsep;
  mixed arr;

  switch(sizeof(array))
  {
    case 0:
      tmp = none;
      break;
    case 1:
      tmp = sprintf(one, array[0]);
      break;
    default:
      tmp = many;
      arr = sort_array(array, #'> /*'*/);
      lastsep = (flag & 2) ? ", " : " und ";
      tmp += CountUp(arr, ", ", lastsep)+".";
      break;
  }
  if (flag & 1)
    return(break_string(tmp, 75, 0, 1));
  else
    write(break_string(tmp, 75, 0, 1));

  return 0;
}

protected void create()
{
  if (!clonep(this_object()) && object_name(this_object())==(RAUM)) {
      set_next_reset(-1);
      return;
  }
  room::create();
  usercmd::create();
  losa::create();

  Set(P_INT_LONG, SAVE, F_MODE_AS);
  Set(P_INT_SHORT, SAVE, F_MODE_AS);
  Set(P_EXITS, SAVE, F_MODE_AS);
  Set(P_DETAILS, SAVE, F_MODE_AS);
  Set(P_READ_DETAILS, SAVE, F_MODE_AS);
  Set(P_LIGHT, SAVE, F_MODE_AS);

  SetProp(P_IDS, ({"raum","sehe\rhaus"}));
  SetProp(P_NAME, "Haus");
  SetProp(P_GENDER, 0);
  SetProp(P_TRANSPARENT, 0);
  SetProp(P_NOGET, 1);
  SetProp(P_LIGHT, 1);
  SetProp(P_INDOORS, 1);

  AddCmd( ({ "beschreib", "beschreibe" }), "beschreiben" );
  AddCmd("uebersicht", "uebersicht");
  AddCmd("ausgang", "ausgang");
  AddCmd( ({"loesche", "loesch"}), "loesch");
  AddCmd( ({"wirf", "werf", "werfe" }), "wirf");
  AddCmd( ({"sperr", "sperre"}), "sperren");
  AddCmd( ({"kopier", "kopiere" }), "kopieren");
  AddCmd("licht", "licht");
  AddCmd( ({"aendere", "aender" }), "aendern");
  AddCmd( ({"meldung", "meldungen"}), "report");
}

void init()
{
	object haus;
  
  room::init();
  nedit::init_rescue();

  // Magier betritt fremdes Seherhaus
  if (query_once_interactive(PL) && IS_LEARNER(PL) && getuid(PL) != owner) {
    if (PL->QueryProp(P_INVIS))
      // Magier invis => im Raum melden
      tell_room(this_object(),
          capitalize(getuid(PL))+" betritt unsichtbar den Raum.\n",
          ({PL}));

    if ((haus = load_object(HAUSNAME(owner))) &&
        (haus->QueryProp(H_DOORSTAT) & D_LOCKED))
      // Tuer ist zu => Magier einen Hinweis geben
      tell_object(PL, " ******* ACHTUNG *********************************\n *\n * "+
        capitalize(owner)+" moechte vielleicht ungestoert bleiben!\n *\n"
        " ******* ACHTUNG *********************************\n");
  }
}
  
int PreventInsertLiving(object ob)
{  
  return 0;
}

// Gegenstaende kommen in den Raum
void NotifyInsert(object ob, object oldenv)
{
	object *found;

	if (!objectp(ob)) return;
	
	if (ob->QueryProp(H_FURNITURE)!=0)
	{ 
    // das was reinkam ist ein autoload Moebelstueck
    // betrachte alle schon vorhandenen autoload Moebelstuecke
      found = filter_objects(all_inventory(this_object()),
		        "QueryProp", H_FURNITURE);
	  if (sizeof(found)>=MAX_FURNITURE_PER_ROOM)        
      {
      // Maximal-Anzahl vorhandener autoload Seherhausmoebel ist schon
      // erreicht
	    tell_object(this_player(), break_string(
	      "Ein Raum kann nur "+MAX_FURNITURE_PER_ROOM+" rebootfeste "
	      "Moebel speichern. Hier befinden sich schon "+
	      CountUp(map_objects(found, "name"))+"."));
	    return 0;
      }
      
      queued_save(); // Speichern vorbereiten (falls mehrere Objekte 
                     // gedroppt werden, wird so ein overflow verhindert.
	}
}

// Gegenstaende verlassen den Raum
void NotifyLeave(object ob, object dest)
{
	if (!ob &&!objectp(ob)) return 0;
	
  // rebootfestes Moebelstueck verlaesst den Raum
	if (ob->QueryProp(H_FURNITURE)!=0)
	{	
    // Speichern vorbereiten (falls mehrere Objekte 
    // gedroppt werden, wird so ein overflow verhindert.
		queued_save();
	}
	return 0;
}

void
reset()
{
  room::reset();
  losa::reset();
  // Wenn ein Notausgang vorhanden ist, checken, ob der noch noetig ist.
  if (member(m_indices(QueryProp(P_EXITS)),"notausgang")!=-1)
  {
      make_emergency_exit();
  }
}

int clean_up(int arg)
{
  mixed inv;

  if (arg > 1)
    return 1;

  losa::reset();  // Evtl. gepackt speichern...

  // nichts im Raum oder nur leere Seherhaustruhe => Raum kann weg
  if ((sizeof(inv=all_inventory()) == 0) ||
      (sizeof(inv) == 1 && inv[0]->id(TRUHE) &&
       sizeof(all_inventory(inv[0]))==0))
    remove(1);

  return 0;
}

// Haeufungen von gleichen Objekten sind hier egal => nix tun
protected varargs void remove_multiple(int limit) {}


// Spieler wird im Raum Netztot
void BecomesNetDead(object pl)
{
//  Nicht erlaubte Spieler werden rausgeworfen, alle anderen bleiben drin.
  if(!allowed_check(pl))
    pl->move(VERWALTER->HausProp(owner, HP_ENV), M_GO, 0, "schlafwandelt heraus", "schlafwandelt herein" );
}


/* Ist dieser Raum ein Ausgang? */
int is_exit(string path)
{ 
  return (sizeof(path) > 4) && (path[<5..] == "raum0");
}

/*Pruefung, ob es einen Hausausgang gibt*/
int room_has_exit() {

    string room = object_name(this_object());
  // sind wir schon in einem Hauptraum mit Ausgang?
    if (is_exit(room)) return 1;

    mapping r_todo = ([room]);
    mapping r_done = ([:0]);
    /* Die Schleife hat maximal 9 * Anzahl der verb. Haeuser Durchlaeufe */
    while (sizeof(r_todo))
    {
      mapping r_exits = ([]);

      // naechsten Raumpfad abarbeiten, d.h. dessen Ausgaenge betrachten
      room = m_indices(r_todo)[0];
      // abgearbeiteten Raumpfad von r_todo nach r_done schieben
      r_done += ([room]);
      m_delete(r_todo, room);

      // alle Ausgaenge betrachten
      foreach(string command, string subpath : room->QueryProp(P_EXITS))
      {
        // Notausgaenge nicht betrachten, da 'echte' Ausgaenge gesucht sind
        if(command != "notausgang")
          // alle anderen Ausgaenge sammeln
          r_exits += ([ subpath ]);
      }
      // nur Raumpfade die noch nicht abgearbeitet sind testen
      r_exits -= r_done;
      // ist da ein Hauptraum (der dann Ausgang liefert) dabei?
      if (sizeof(filter_indices(r_exits, #'is_exit/*'*/)))
        return 1;

      // neue Raumpfade in die TODO-Liste aufnehmen
      r_todo += r_exits;
    }
    return 0;
}

// damit man Spieler nicht durch Entfernen von Ausgaengen einsperren kann
// werden bei Bedarf Notausgaenge in den Hauptraum ergaenzt
void make_emergency_exit()
{
  // Ist der Raum weder Hauptraum mit Ausgang noch fuehrt ein Weg dorthin?
  // dann Notausgang machen
  if(!room_has_exit())
  {
    // tell_room(this_object(),"DEBUG: Ein Notausgang wurde angelegt.\n");
    room::AddExit("notausgang",
      "durch den Notausgang#"+to_string(this_object())[0..<2]+"0");
  }
  else
  {
    // nicht mehr benoetigten Notausgang entfernen
    room::RemoveExit("notausgang");
  }
}

// ruft direkt das geerbte AddExit auf, ohne ggf. einen Notausgang zu
// erzeugen. Das wird vom Haus und vom Verwalter benutzt, um Ausgaenge zu
// erzeugen. Das ist noetig, weil der Notausgangmechanismus noch nicht
// funktoniert, wenn der Raum gerade geladen wird (hat noch nicht den
// endgueltigen Namen) und der Check waere ohnehin unnoetig.
public void AddExitNoCheck(mixed cmd, mixed dest)
{
  room::AddExit(cmd, dest);
}

// Wird benutzt beim Laden von Raeumen, um alle Ausgaenge zu loeschen. Dabei
// darf _kein_ Notausgang erstellt werden.
void RemoveExitNoCheck(mixed cmd)
{
  room::RemoveExit(cmd);
}

// beim Ausgang setzten testen ob vorhanderner Notausgang noch benoetigt wird
void AddExit(mixed cmd, mixed dest)
{
  room::AddExit(cmd, dest);

  if (member(m_indices(QueryProp(P_EXITS)),"notausgang")!=-1)
  {
    // loescht Notausgang falls nicht mehr benoetigt
     make_emergency_exit();
  }
}

// beim Ausgang loeschen testen ob Notausgang benoetigt wird
void RemoveExit(mixed cmd)
{
  room::RemoveExit(cmd);
  // setzt Notausgang falls benoetigt
  make_emergency_exit();
}

// der Langbeschreibung werden alle unsichtbaren Magier
// (ausgenommen Seherhausbesitzer) in Klammern angefuegt
varargs string int_long(mixed viewer, mixed viewpoint, int flags)
{
  string ret;
  object *inv;
  string *tmp;

  ret = ::int_long(viewer, viewpoint, flags);

  // nur was machen wenn der Betrachter im Raum ist
  if (!ret || !objectp(viewer) || environment(viewer) != this_object())
    return ret;

  if(viewpoint == 0)
    viewpoint = ({ viewer });
  else if(!pointerp(viewpoint))
    viewpoint = ({ viewpoint });

  // alle Lebewesen ausser denen aus deren Sicht betrachtet wird
  inv = filter(all_inventory(this_object()),#'interactive) - viewpoint;
  foreach(object pl : inv)
  {
    // raussuchen wer ausser Seherhausbesitzer unsichtbar ist
    if(pl && IS_LEARNER(pl) && pl->QueryProp(P_INVIS) && getuid(pl)!=owner)
    {
      // Name in Klammer sammeln
      tmp += ({ "("+capitalize(getuid(pl))+")" });
    }
  }
  return ret + break_string(CountUp(tmp), 78);
}
/*
// TODO: Testen ob das hier nicht das Standard-Verhalten ist
int lies(string str)
{
  string txt;

  notify_fail("Was moechtest Du lesen?\n");
  if (!str) return 0;

  if (this_player()->CannotSee())
    return 1;
  if (txt = QueryProp(P_READ_DETAILS)[str]) {
    this_player()->More(txt);
    return 1;
  }
  return 0;
}
*/
// Aktion Lebewesen oder Gegenstaende aus dem Haus werfen
int wirf(string str)
{
  string wen, args;
  object pl, target, *list, tp, to;

  tp = this_player();
  to = this_object();
  args = tp->_unparsed_args(1);

  // klappt nur vor Ort und mit der passenden Syntax
  if ((environment(tp)!=to) ||
      !args || args == "" ||
      (sscanf(args,"%s raus",wen) != 1) )
    return 0;
  // Raum, in dem das Haus steht, ermitteln
  target=find_object(VERWALTER->HausProp(owner, HP_ENV));
  if (!target) {
    notify_fail("Dieses Haus steht leider gerade in einem "
                "Fehler im Raum-Zeit-Gefuege.\n");
    return 0;
  }
  // Rauswerfen darf nur der Besitzer
  if (!tp_owner_check()) {
    notify_fail("Aber Du kannst doch niemanden aus dem Haus von "+capitalize(owner)+" werfen!\n");
    return 0;
  }
  if (wen=="alle") {
    // alle Lebewesen ausser tp (== Hausbesitzer)
    list=filter(all_inventory(to),#'living)-({tp,0});//')
    if (sizeof(list)==0) {
      notify_fail("Aber Du bist doch allein in Deinem Haus!\n");
      return 0;
    }
  } else if (wen == "alles") {
    // alle Gegenstaende ausser Lebewesen und Moebel
    // (Seherhaustruhe, Autoloader-Moebel oder Seherhaus-Moebel)
    list = filter(all_inventory(to),
                  function int(object ob)
                  {
                      return objectp(ob) &&
                             !living(ob) &&
                             !ob->id(TRUHE) &&
                          // TODO Test auf nicht Seherhausmoebel von August
                             strstr(load_name(ob),"/d/seher/haeuser/moebel/")
                               == 0;
                  } );

    if (sizeof(list)==0) {
      notify_fail("Aber hier ist nichts zum wegwerfen!\n");
      return 0;
    }
  } else {
    pl=present(wen,to);
    if (!pl) {
      notify_fail("So jemanden sehe ich hier nicht.\n");
      return 0;
    }
    else if (pl->id(TRUHE) ||
             // TODO Test auf Seherhausmoebel von August
              strstr(load_name(pl),"/d/seher/haeuser/moebel/")==0
             ) {
      notify_fail("Du kannst "+pl->name(WEN)+" nicht wegwerfen!\n" );
      return 0;
    }
    list=({pl});
  }
  string msg_wen = sprintf("%s wirft Dich aus %s Haus.\n",
                           tp->Name(WER),
                           tp->QueryPossPronoun(NEUTER,WEM));
  // fuer alle rauszuwerfenden Opfer Meldungen machen und rausbewegen
  foreach(object ob : list)
  {
    tell_object(ob, msg_wen);
    tell_room(target,
        sprintf("%s kommt in hohem Bogen aus dem Haus von %s geflogen.\n",
                 ob->Name(WER),tp->name(WEM)));
    ob->move(target,M_SILENT|M_GO);
    tell_room(to,sprintf("%s wirft %s aus %s Haus.\n",
                    tp->Name(WER),
                    ob->name(WEN),tp->QueryPossPronoun(NEUTER,WEM)),
              ({tp}));
    printf("Du wirfst %s aus Deinem Haus.\n",ob->name(WEN));
    // Verfolger abmelden, damit sie nicht gleich zurueckkommen
    // TODO wenn man einzelne Lebewesen rauswirft kann das ja auch
    // ein Verfolger von einem anderen Gast sein...
    tp->RemovePursuer(ob);
  }
  return 1;
}

// Besitzer und Raumnummer fuer diesen Raum setzen
varargs string SetOwner(string o, int num)
{
  // Default Kurz- und Langbeschreibung setzen
  SetProp(P_INT_SHORT, "Im Haus von "+capitalize(o));
  SetProp(P_INT_LONG, "Ein total leerer Raum.\n");
  // Raumnummer und Besitzer merken
  raumNr = num;
  return owner = o;
}

// Liefert den Besitzer
// falls withNr != 0 mit angehaengter Raumnummer
varargs string QueryOwner(int withNr)
{
  return (withNr ? owner+raumNr : owner);
}

// Prototype
static int befEingabe(string *bef);

// Aktion zum Beschreiben des Raumes
varargs int
beschreiben(string str, int f)
{
  string *parts;
  int sp, ret;

  // nur der Besitzer darf
  if(!tp_owner_check())
    return 0;

  if (!f && (!(str=UP_ARGS(this_player())) || str == "")) {
    notify_fail("Was willst Du denn beschreiben?\n" );
    return 0;
  }

  sp = sizeof(parts = old_explode(str, " "));
  // je nachdem was beschrieben wird, setze detail und flag
  // und starte damit Editor, bzw. behandle Befehle extra
  detail = 0;
  flag = f;

  switch(parts[0][0..3]) {
    case "raum":      // Lang- oder Kurzbeschreibung
    case "haus":
      if (sp == 1 || parts[1] == "lang")
    flag |= LANG;
      else if (parts[1] == "kurz")
    flag |= KURZ;
      printf("Bitte %sbeschreibung des %s eingeben.\n", (flag & LANG ? "Lang" : "Kurz"), (flag & AUSSEN ? "Hauses" : "Raumes") );
      break;
    case "deta":      // Details
      if (sp==1) {
    notify_fail("Welches Detail willst Du denn beschreiben?\n");
    return 0;
      }
      flag |= DETAIL;
      str = implode(parts[1..]," ");
      write( "Bitte Beschreibung fuer '"+str+"' eingeben.\n");
      break;
    case "lesb":      // lesbare Details
      notify_fail("Welches lesbare Detail willst Du denn beschreiben?\n");
      if (sp == 1) return 0;
      if (parts[1] == "details" || parts[1] == "detail") {
    if (sp == 2) return 0;
    str = implode(parts[2..]," ");
      }
      else
    str = implode(parts[1..]," ");
      flag |= RDETAIL;
      write( "Bitte Beschreibung fuer '"+str+"' eingeben.\n");
      break;
    case "befe":      // Befehle
      ret = 0;
      if (sp == 1)
    notify_fail("Welchen Befehl willst Du denn beschreiben?\n");
      else
    ret = befEingabe(brk(implode(parts[1..]," ")));
      return ret;
      break;
    default:
      notify_fail("Das kannst Du nicht beschreiben! Eine Liste der Dinge, die Du hier\n"
         +"beschreiben kannst, erhaeltst Du mit 'hilfe beschreibe'.\n" );
      return 0;
      break;
  }
  detail = brk(str);
  write( "(Beenden mit . oder **, Abbruch mit ~q)\n" );
  nedit( "beschreibung" );
  return 1;
}

// nedit von beschreibe xxx
static void beschreibung(string str)
{
  if (!str) {
    write("Nichts geaendert!\n");
    return;
  }

  str = normstr(str);

  if (flag & LANG)
  {
    // Langbeschreibung
    if (sizeof(explode(str,"\n")) > 100
        || sizeof(str) > 7800)
    {
      // ueber 100 Zeilen oder ueber 7800 Zeichen
      write( "Das ist fuer eine Langbeschreibung zu lang!\n"
             "Sorry, bitte denke Dir eine andere Langbeschreibung aus.\n" );
      return;
    }
    if (flag & AUSSEN) {
      // Langbeschreibung vom Haus
      object haus;
      haus = find_object(HAUSNAME(owner));
      haus->SetProp(P_LONG, str);
      haus->Save();
    }
    else
      // Langbeschreibung von diesem Raum
      SetProp(P_INT_LONG, str);
  }
  else if (flag & KURZ) {
    // Kurzbeschreibung vom Raum
    if (sizeof(old_explode(str,"\n")) > 1 || sizeof(old_explode(str,".")) > 2 || sizeof(str) > 75) {
      write( "Das ist fuer eine Kurzbeschreibung zu lang!\nSorry, bitte denke Dir eine andere Kurzbeschreibung aus.\n" );
      return;
    }
    else
      // Vanion, 27.07.02, Bugfix
      // Die Zeile buggte, wenn man "." oder "\n" oder "\n." oder sowas
      // in str hat. (also z.B. bei "beschreibe raum kurz <return> .")
      // SetProp(P_INT_SHORT, old_explode(old_explode(str,"\n")[0],".")[0]);
      SetProp(P_INT_SHORT, explode(explode(str,"\n")[0],".")[0]);
  }
  else if (flag & DETAIL)
    // Raum-Detail
    AddDetail(detail, str);
  else if (flag & RDETAIL)
    // lesbares Raum-Detail
    AddReadDetail(detail, str);
  else {
    write( "Huch! Unbekanntes Flag ("+flag+")... Sag mal "
          + CountUp(MAINTAINER, ", ", " oder ")
          + " Bescheid...\n");
    return;
  }

  write("OK.\n");
  Save();
}

// wird in beschreiben(str, int) 'beschreibe befehl' aufgerufen
static int befEingabe(string *befehle)
{
  string* com = ({});

  notify_fail("Kein Befehl zum Beschreiben uebrig... ;)\n");
  foreach(string bef : befehle)
  {
    // schon vorhandener Befehl (ausser oeffnen/schlissen),
    // Richtung ohne zugehoerigen Ausgang,
    // oder Befehl enthaelt Leerzeichen 
    if (!befCheck(bef))
      write("Der Befehl '"+bef+"' kann nicht beschrieben werden!\n");
    else
      com += ({ bef });
  }
  if (!sizeof(com))
    return 0;

  arr_out(com, 0, "Zu beschreibender Befehl: %s",
          "Zu beschreibende Befehle:\n");

  write( "Bitte Parameter eingeben (evtl. durch Kommata getrennt).\n]");
  input_to("getBefParam", 0, com);
  return 1;
}

// input_to aus befEingabe(string) zu beschreibe befehl ...
static void getBefParam(string param, string *bef)
{
  string txt = "Gib nun bitte den Text ein, der fuer diesen Befehl "
      "ausgegeben werden soll.\n";

  // Fuehrende und abschliessende Leerzeichen entfernen
  if (param)
    param = trim(param);

  if (!param || param == "")
    // kein Parameter, z.b. bei beschreibe befehl klopfe 
    detail = ({ bef, "" });
  else if (param == "@NF@" || param == "@nf@") {
    // Parameter fuer notify fail zum Ersetzen von Wie bitte?
    // z.B. bei beschreibe befehl druecke
    // fuer danach Du kannst hier kein @PARA druecken, nur den Knopf!
    detail = ({ bef, 1 });
    txt = "Gib nun bitte den Text ein, der als Fehlermeldung "
          "ausgegeben werden soll.\n@PARA dient dabei als Platzhalter fuer "
          "die ungueltige Eingabe.\n";
  }
  else
    // sonstige Parameter
    // z.B. knopf, klingel bei beschreibe befehl druecke
    detail = ({ bef }) + brk(lower_case(param));

  printf(txt+"(Beenden mit . oder **, Abbruch mit ~q)\n");
  nedit("getBefText");
}

// Prototype
private string preparse(string str, string *invalid);

// nedit fuer die Eingabe der Texte  (Fehlermeldung/Meldungen) fuer den Befehl
static void getBefText(string text)
{
  string my, *txt, *warn;
  mixed bef;

  if (!text || text == "") {
    write("** Abbruch! **\n");
    detail = 0;
    return;
  }
  // gemerktes Befehls-Array
  bef = detail[0];

  txt = old_explode(text, "@@\n");

  warn = ({});

  // Meldung an this_player() parsen und in warn falsche Platzhalter sammeln
  my = preparse(txt[0], &warn);
  string other = 0;
  if (sizeof(txt) > 1)
    // Meldung an andere parsen und in warn falsche Platzhalter sammeln
    other = preparse(txt[1], &warn);

  AddUserCmd(bef, (stringp(detail[1]) ? detail[1..] : ({ "@NF@" })), my, other);
  Save();
  arr_out(warn, "OK.", "WARNUNG! Ungueltiger Platzhalter: %s",
               "WARNUNG! Ungueltige Platzhalter: ");

  detail = 0;
}

// check, ob an Position pos in txt ein Buchstabe aus dem array choice steht
// return 0 falls nicht, prefix + Position des Buchstabens in choice ansonsten
// check_placeholder(({"R","S","M","N"}), 2, "WESSEN", "X"); -> X1
string check_placeholder(string* choice, int pos, string txt, string prefix)
{
   int idx;
    
   if(sizeof(txt) < pos+1 ||
      ((idx=member(choice, txt[pos..pos])) < 0))
   {
     return 0;
   }
   else
   {
     return prefix+to_string(idx);
   }
}

// Dann drueckt @PWER den Knopf -> Dann drueckt @P0 den Knopf
private string preparse(string str, string *invalid)
{
  string *txt;

  txt = explode(str, "@");
  // fuer jeden Textteil nach einem @
  // suche Ersatz fuer den Begriff direkt nach dem @
  // AN: wuerde es nicht theoretisch reichen, hier nur bis i>0
  // runterzuzaehlen? Das erste Element des Arrays ist immer irrelevant, weil
  // entweder Leerstring oder kein zu ersetzender Ausdruck.
  for (int i=sizeof(txt)-1; i>=0; i--) {
    int warn = 0;
    string rpl = 0;
    // falls Teil zu kurz nix ersetzen
    if (sizeof(txt[i])<3)
      continue;
    // anhand der ersten Buchstaben, Ersatz bestimmen
    // warn signalisiert, ob dies schiefging:
    switch(txt[i][0..1]) {
    case "WE":  // Name
      // WER      -> W0
      // WES(SEN) -> W1
      // WEM      -> W2
      // WEN      -> W3
      rpl = check_placeholder(({"R","S","M","N"}), 2, txt[i], "W");  
      warn = !rpl;
      break;
    case "PW":  // Personalpronomen
      // PWER      -> P0
      // PWES(SEN) -> P1
      // PWEM      -> P2
      // PWEN      -> P3
      rpl = check_placeholder(({"R","S","M","N"}), 3, txt[i], "P");  
      warn = !rpl;
      break;
    case "BN":  // Possessivpronomen
    case "BM":
    case "BF":
      // BNSWER      -> B000  BMSWER      -> B010  BFSWER      -> B020
      // BNSWES(SEN) -> B100  BMSWES(SEN) -> B110  BFSWES(SEN) -> B120
      // BNSWEM      -> B200  BMSWEM      -> B210  BFSWEM      -> B220
      // BNSWEN      -> B300  BMSWEN      -> B310  BFSWEN      -> B320
      // 
      // BNPWER      -> B001  BMPWER      -> B011  BFPWER      -> B021
      // BNPWES(SEN) -> B101  BMPWES(SEN) -> B111  BFPWES(SEN) -> B121
      // BNPWEM      -> B201  BMPWEM      -> B211  BFPWEM      -> B221
      rpl = check_placeholder(({"R","S","M","N"}), 5, txt[i], "B");
      warn = !rpl;
      if(!warn)
      {
        rpl = check_placeholder(({"N","M","F"}), 1, txt[i], rpl);
        warn = !rpl;
        if(!warn)
        {
          rpl = check_placeholder(({"S","P"}), 2, txt[i], rpl);
          warn = !rpl;
        }
      }
      break;
    case "PA":
      // PARA -> F
      // kein Ersatz, sondern Textteil hier direkt ersetzen:
      if(sizeof(txt[i]) > 4)
        txt[i] = "F"+txt[i][4..];
      break;
    default:
      // kein Ersatz, nix aendern
      warn = 0;
      rpl = 0;
    }

    // falls Ersatz vorhanden, ersetze Pronomen durch ""+rpl und lasse den Rest t2[2] wie ist
    if (rpl) {
      string* t2;
      warn = sizeof(t2 = regexplode(txt[i], "(WER|WESSEN|WEM|WEN)")) < 2;
      if (!warn) {
        t2[1] = rpl;
        t2[0] = "";
        txt[i] = implode(t2, "");
      }
    }
    // falls es Probleme gab, diese merken
    if (warn)
      invalid += ({ "@"+old_explode(txt[i]," ")[0] });

  } // for (i=sizeof(txt)-1; i>=0; i--)
  // die eventuelle teilweise ersetzetn Teile wieder zusammenfuegen
  return implode(txt, "@");
}

static void loesch_alles(string str)
{
  if (str == "ja" || str == "Ja") {
    RemoveDetail(0);
    RemoveReadDetail(0);
    //SetProp(P_READ_DETAILS, ([]));
    SetProp(H_COMMANDS, ([]));
    write( "OK, alle Details, lesbaren Details und Befehle geloescht!\n" );
    Save();
  }
  else
    write( "Nichts geloescht!\n" );
}

static void loesch_etwas(string str, string prop)
{
  if (str == "ja" || str == "Ja") {
    if ( prop == P_DETAILS )
      RemoveDetail(0);
    else if ( prop == P_READ_DETAILS )
      RemoveReadDetail(0);
    else
      SetProp(prop, ([]));
    write("OK.\n");
    Save();
  }
  else
    write( "Nichts geloescht!\n" );
}

int loesch(string str)
{
  string *s, *t, p, q;
  int i, ret;
  mapping com;

  if (!tp_owner_check())
    return 0;

  if (!(str=UP_ARGS(this_player())) || str == "") {
    notify_fail("Welches Detail oder welchen Befehl moechtest Du loeschen?\n");
    return 0;
  }

  if (str == "alles") {
    write( "Wirklich alles loeschen (ja/nein)?\n]");
    input_to("loesch_alles");
    return 1;
  }

  if(str=="meldungen") {
    if(file_size(PATH+"rep/"+owner+".rep")>0) {
      rm(PATH+"rep/"+owner+".rep");
      write("Meldungen geloescht.\n");
    }else{
      write("Keine Meldungen gefunden.\n");
    }
    return 1;
  }

  s = brk(str);
  s = ({ (t=old_explode(s[0], " "))[0] })+({ implode(t[1..]," ") })+s[1..];
  ret = 1;
  flag = 0;

  switch(s[0]) {
    case "detail":
      s = s[1..];
      flag |= DETAIL;
      break;
    case "lesbar":
      flag |= RDETAIL;
      s = s[1..];
      break;
    case "lesbares":
    case "lesbare":
      flag |= RDETAIL;
      if (s[1][0..5] =="detail") {
    s = ({ old_explode(s[1]," ")[<1] });
    if (sizeof(s)>2)
      s += s[2..];
      }
      else
    s = s[1..];
      break;
    case "befehl":
      s = s[1..];
      break;
    case "alle":
      switch (s[1]) {
      case "details":
    q = "Details";
    p = P_DETAILS;
    break;
      case "lesbaren details":
    q = "lesbaren Details";
    p = P_READ_DETAILS;
    break;
      case "befehle":
    q = "Befehle";
    p = H_COMMANDS;
    break;
      default:
    write("Du kannst alle Befehle, alle Details und alle lesbaren Details loeschen!\n");
    return 1;
      }
      printf("Wirklich alle %s loeschen (ja/nein)?\n]", q);
      input_to("loesch_etwas", 0, p);
      return 1;
    default:
      flag |= (DETAIL|RDETAIL);
      ret = 0;  // Koennte auch ein Artikel in der Zeitung sein...
      break;
  }
  for (i=sizeof(s)-1; i>=0; i--) {
    if (!flag) {  // Befehl soll geloescht werden...
      if (member(com=Query(H_COMMANDS), s[i])) {
    com = m_copy_delete(com, s[i]);
    write("Befehl '"+s[i]+"' wurde geloescht.\n");
      }
      else if (sizeof(t=old_explode(s[i], " ")) > 1 &&
           member(com, t[0]) &&
           member(com[t[0]], p=implode(t[1..], " "))) {
    com[t[0]] = m_copy_delete(com[t[0]], p);
    write("Befehl '"+s[i]+"' wurde geloescht.\n");
      }
      Set(H_COMMANDS, com);
    }
    else {
      if (flag & DETAIL) {
    if (!QueryProp(P_DETAILS)[s[i]])
      notify_fail("Das Detail '"+s[i]+"' gibt es nicht.\n");
    else {
      RemoveDetail(s[i]);
      write("Detail '"+s[i]+"' wurde geloescht.\n");
      ret = 1;
    }
      }
      if (flag & RDETAIL) {
    if (!QueryProp(P_READ_DETAILS)[s[i]])
      notify_fail("Das lesbare Detail '"+s[i]+"' gibt es nicht.\n");
    else {
      RemoveReadDetail(s[i]);
      write("Lesbares Detail '"+s[i]+"' wurde geloescht.\n");
      ret = 1;
    }
      }
    }
  }
  Save();
  return ret;
}

int ausgang(string str)
{
  int nr, maxNr, hin, zurueck;
  string hier, da, ext;
  closure hausProp;
  mapping known_exits;

  if (!tp_owner_check()) {
    return 0;
  }

  hier = da = 0;
  hausProp = symbol_function("HausProp",VERWALTER);

  if (!(str=UP_ARGS(this_player())) ||
      (sscanf(str, "%s %d", hier, nr) != 2 &&
       sscanf(str, "%s %s %d",hier, ext, nr) != 3) ) {
    notify_fail( "Syntax: ausgang <richtung> [name] <nr>\n" );
    return 0;
  }

  if (ext) {
    if (funcall(hausProp, ext, HP_ENV) != funcall(hausProp, owner, HP_ENV)) {
      printf("Das Haus von %s steht nicht im gleichen Raum wie Dein Haus!\n",
             capitalize(ext));
      return 1;
    }
    else
      da = RAUMNAME(ext, nr);

    // der allowed_check() wird im Eingangsraum des Zielhauses aufgerufen,
    // da wir von anderen Raumen noch nicht wissen, ob sie ueberhaupt
    // existieren.
    if (!(RAUMNAME(ext, 0)->allowed_check(this_player()))) {
      printf("Du darfst keinen Ausgang von Deinem Haus zu dem von %s legen!\n",
             capitalize(ext));
      return 1;
    }
  }
  else {
    ext = owner;
    da = RAUMNAME(ext, nr);
  }

  maxNr = funcall(hausProp, ext, HP_ROOMS);

  if ( (hin = member(ausgaenge, lower_case(hier))) < 0) {
    arr_out(ausgaenge, 0, 0, "Es sind nur folgende Ausgaenge moeglich:\n" );
    return 1;
  }
  else
    zurueck = (hin + sizeof(ausgaenge)/2) % sizeof(ausgaenge);

  hier = RAUMNAME(owner, raumNr);

  // Kopie des Ausgaenge-Mappings erzeugen
  known_exits=deep_copy(QueryProp(P_EXITS));
  // und den Notausgang entfernen. Somit bleiben nur die zu betrachtenden 
  // Ausgaenge ueber.
  known_exits["notausgang"]=0;

  if (nr < 0 || nr > maxNr)
    printf( "Die Nummer darf sich nur im Bereich zwischen 0 und %d bewegen!\n",
            maxNr );
  else if ( ext == owner && nr == raumNr)
    printf( "Aber dies IST Raum %d!\n", raumNr );
  else if (member(m_indices(known_exits), ausgaenge[hin]) != -1)
    write( "Aus diesem Raum fuehrt schon ein Ausgang in diese Richtung!\n" );
  //else if (member(m_values(QueryProp(P_EXITS)), da) != -1)
  // Notausgang wird hier zwar geloescht, aber im AddExit
  // gibt's eh einen neuen, so das noetig ist, V*
  else if (member(m_values(known_exits), da) != -1)
    printf( "Es gibt hier schon einen Ausgang zu Raum %d!\n", nr );
  else if (member(m_indices(da->QueryProp(P_EXITS)), ausgaenge[zurueck]) != -1)
    printf( "Es fuehrt schon irgendwo ein Ausgang in Richtung '%s'\n"
            "nach Raum %d!\n", ausgaenge[hin], nr);
  else {
    AddExit( ausgaenge[hin], da );
    Save();
    da->AddExit(ausgaenge[zurueck], hier);
    da->Save();
    printf( "OK, der Ausgang '%s' zum Raum %d wurde eingerichtet.\n",
            ausgaenge[hin], nr );
  }
  return 1;
}

int
sperren(string str)
{
  mapping ex, cmds;
  int hin, zurueck;

  if (!tp_owner_check())
    return 0;

  if (!(str=UP_ARGS(this_player())) || str == "") {
    notify_fail( "Syntax: sperre <ausgang>\n" );
    return 0;
  }
  str = lower_case(str);
  ex = QueryProp(P_EXITS);

  if (raumNr == 0 && str == "raus") {
    write( "Du kannst doch nicht Deine Haustuer loeschen!\n" );
    return 1;
  }
  if (!member(ex,str) || (hin = member(ausgaenge,str)) < 0) {
    printf( "Es gibt hier keinen Ausgang '%s'!\n", str);
    return 1;
  }
  else
    zurueck = (hin + sizeof(ausgaenge)/2) % sizeof(ausgaenge);

  ex[str]->RemoveExit(ausgaenge[zurueck]);
  tell_room(find_object(ex[str]), sprintf("Der Ausgang '%s' verschwindet ploetzlich...\n", ausgaenge[zurueck]));
  cmds = ex[str]->QueryProp(H_COMMANDS);
  cmds = m_copy_delete(cmds, ausgaenge[zurueck]);
  ex[str]->SetProp(H_COMMANDS, cmds);
  ex[str]->Save();
  RemoveExit(str);
  cmds = QueryProp(H_COMMANDS);
  cmds = m_copy_delete(cmds, str);
  SetProp(H_COMMANDS, cmds);
  Save();
  printf( "OK, der Ausgang '%s' wurde entfernt.\n", str );

  Save();

  return 1;
}

varargs int
uebersicht(string dummy, string pre)
{
  string *xc, *xd, o, raus, str;
  mixed *com;
  mapping tmp;
  int i,j,k;

  if ( (getuid(this_player()) != owner) &&
       !(PATH+"access_rights")->access_rights(geteuid(this_player()), "") )
    return 0;

  i = VERWALTER->HausProp(owner, HP_ROOMS);

  if (i)
    str = sprintf( "Dein Haus verfuegt ueber %d Raeume.\nDu stehst in Raum %d (%s).\n\n", i+1, raumNr, QueryProp(P_INT_SHORT) );
  else
    str = sprintf( "Dein Haus verfuegt ueber einen Raum (%s)\n\n", QueryProp(P_INT_SHORT));

  str += arr_out(m_indices(QueryProp(P_DETAILS)),
         "Du hast keine Details beschrieben.",
         "Du hast das Detail '%s' beschrieben.",
         "Du hast folgende Details beschrieben:\n", 1 );

  str += ("\n" + arr_out(m_indices(QueryProp(P_READ_DETAILS)),
         "Du hast keine lesbaren Details beschrieben.",
         "Du hast das lesbare Detail '%s' beschrieben.",
         "Du hast folgende lesbaren Details beschrieben:\n", 1 ) );

  tmp = Query(H_COMMANDS);
  xc = sort_array(m_indices(tmp),#'<);
  if (!sizeof(xc))
    str += ("\nDu hast keine Befehle beschrieben.\n");
  else {
    if (sizeof(xc) == 1 && sizeof(xd=m_indices(tmp[xc[0]])) == 1)
      str += ("\nDu hast den Befehl '"+
          xc[0]+((xd[0] == "") ? "" : " "+xd[0])+
          "' beschrieben.\n");
    else {
      str += "\nDu hast folgende Befehle beschrieben:\n";

      for (com = ({}), j=sizeof(xc)-1; j >= 0; j--) {
    xd = sort_array(m_indices(tmp[xc[j]])-({"@NF@"}),#'>);
    if ((sizeof(xd) > 1) && (xd[0] == "")) {
      raus = "* "+xc[j]+", "+xc[j]+" ";
      xd = xd[1..];
    }
    else
      raus = "* "+xc[j]+" ";

    str += arr_out(xd, "", raus+"%s", raus, 3);
      }
    }
  }

  raus = (member(QueryProp(P_EXITS),"raus") ? "raus: Nach draussen.\n" : 0 );
  tmp = m_copy_delete(QueryProp(P_EXITS), "raus");
  m_delete(tmp, "notausgang");
  xc = m_indices(tmp);
  xd = m_values(tmp);

  if (!sizeof(xc) && !raus)
    str += "\nES GIBT KEINE AUSGAENGE!\n";
  else {
    str +=  "\nEs gibt folgende Ausgaenge:\n";
    for (i=sizeof(xc)-1; i>=0; i--)
      str += sprintf( "%s: Nach Raum %d %s(%s).\n",
             xc[i],
             (j=to_int(xd[i][<1..])),
             (((o=old_explode(xd[i],"/")[<1][0..<6])==owner) ?
             "" : "von "+capitalize(o)+" "),
             xd[i]->QueryProp(P_INT_SHORT) );
  }
  str += ((raus||"")+(pre||""));
  this_player()->More(str);
  return 1;
}

int kopieren(string str)
{
  string was, alt, n, *neu, *par, err;
  mixed das;
  mapping com;

  if (!tp_owner_check())
    return 0;

  notify_fail("'kopiere detail <von> nach <nach>' oder\n"
         +"'kopiere lesbares detail <von> nach <nach>' oder\n"
         +"'kopiere befehl <befehl> [<parameter>] nach <befehl> [<parameter>]'!\n");

  if (!(str=UP_ARGS(this_player())) || str == "")
    return 0;

  neu = old_explode(str, " ");
  was = neu[0][0..5];
  if (was == "detail" || was == "befehl")
    str = implode(neu[1..], " ");
  else if (was == "lesbar")
    str = implode(neu[2..], " ");
  else
    return 0;

  if (sscanf(str, "%s nach %s", alt, n) != 2)
    return 0;

  neu = brk(n);
  switch(was) {
    case "detail":
      err = "Detail";
      if (das = GetDetail(alt)) {
    AddDetail(neu, das);
    Save();
      }
      break;
    case "lesbar":
      err = "lesbares Detail";
      if (das = QueryProp(P_READ_DETAILS)[alt]) {
    AddReadDetail(neu, das);
    Save();
      }
      break;
    case "befehl":
      err = "Befehl";
      was = (par=old_explode(alt, " "))[0];
      if (member(com=QueryProp(H_COMMANDS),was)) {
    int i;
    if (sizeof(par) == 1) { // <bef> nach <bef1,bef2,...>
      das = com[was];
      for (i=sizeof(neu)-1; i>=0; i--) {
        if (befCheck(neu[i])) {
          if (com[neu[i]])
        com[neu[i]] += das;
          else
        com += ([ neu[i] : das ]);
        }
        else
          write("Ungueltiger Befehl: '"+neu[i]+"'.\n");
      }
    }
    else {        // <bef> <parameter> nach <bef1,bef2,...>
      alt = implode(par[1..]-({""})," ");
      if (das = com[was][alt]) {
        for (i=sizeof(neu)-1; i>=0; i--) {
          if (befCheck(neu[i])) {
        das = ([ alt : com[was][alt];com[was][alt,1] ]);
        if (com[neu[i]])
          com[neu[i]] += das;
        else
          com += ([ neu[i] : das ]);
          }
          else {
        par = old_explode(neu[i], " ");
        n = par[0];
        if (befCheck(n)) {
          das = ([ implode(par[1..], " ") : com[was][alt];com[was][alt,1] ]);
          if (com[n])
            com[n] += das;
          else
            com += ([ n : das ]);
        }
        else
          write("Ungueltiger Befehl: '"+neu[i]+"'.\n");
          }
        }
      }
    }
    Save();
      }
      break;
    default:
      write( "Du kannst nur Details, lesbare Details und Befehle kopieren!\n" );
      return 1;
  }
  if (!das)
    printf( "Kann %s '%s' nicht finden!\n", err, alt);
  else
    write( "OK!\n" );

  return 1;
}

int licht(string str)
{
  int ll, tl;

  if (!allowed_check(this_player()))
    return 0;

  if (!str || (str != "an" && str != "aus")) {
    notify_fail("Syntax: 'licht an' oder 'licht aus'\n");
    return 0;
  }

  ll = QueryProp(P_LIGHT);
  tl = PL->QueryProp(P_PLAYER_LIGHT);

  switch(str) {
  case "an":
    if (tl > 0)
      write("Aber es ist doch schon hell!\n");
    else {
      SetProp(P_LIGHT, 1);
      tell_room(this_object(), "Es wird wieder hell.\n");
    }
    break;
  case "aus":
    if (tl <= 0)
      write("Aber es ist doch schon dunkel!\n");
    else {
      SetProp(P_LIGHT, 0);
      tell_room(this_object(), "Es wird dunkel.\n");
    }
    break;
  }
  return 1;
}

#define CASUS ({ "WER", "WESSEN", "WEM", "WEN" })
static string rpXchg(string s)
{
  int c,p,g;

  switch(s[0..1]) {
    case "@W":
      c = to_int(s[2..2]);
      return ("@"+CASUS[c]);
    case "@P":
      c = to_int(s[2..2]);
      return ("@P"+CASUS[c]);
    case "@B":
      c = to_int(s[2..2]);
      g = to_int(s[3..3]);
      p = to_int(s[4..4]);
      return ("@B"+({"N", "M", "F"})[g]+({"S", "P"})[p]+CASUS[c]);
    case "@F":
      return "@PARA";
  }
  return s;
}

private string reParse(string s1, string s2)
{
  string *p;

  if (s2)
    s1 = s1+"@@\n"+s2;

  p = regexplode(s1, "(@W[0-3]|@P[0-3]|@B[0-3][0-2][0-1])");
  p = map(p, #'rpXchg);
  return implode(p, "");
}

private string getPreText(string prop, string expr)
{
  mixed crunched;
  int i;

  crunched = VERWALTER->PCrunch(QueryProp(prop));
  if (!crunched || !pointerp(crunched))
    return 0;

  if (prop == H_COMMANDS && strstr(expr, " ") < 0)
    expr = expr+" ";

  for (i=sizeof(crunched)-1; i>=0; i--)
    if (member(crunched[i][0], expr) >= 0)
      break;

  if (i<0)
    return 0;

  detail = crunched[i][0];

  if (prop == H_COMMANDS)
    return reParse(crunched[i][1], crunched[i][2]);
  else
    return crunched[i][1];
}

varargs int
aendern(string str, int f)
{
  string *parts, pre;
  int sp, sr, ret;

  if (!tp_owner_check())
    return 0;

  if (!f && (!(str=UP_ARGS(this_player())) || str == "")) {
    notify_fail("Was willst Du denn aendern?\n" );
    return 0;
  }

  sp = sizeof(parts = old_explode(str, " "));
  sr = sizeof(brk(str));
  detail = 0;
  flag = f;

  switch(parts[0][0..3]) {
    case "raum":      // Lang- oder Kurzbeschreibung
    case "haus":
      if (sp == 1 || parts[1] == "lang")
    flag |= LANG;
      else if (parts[1] == "kurz") {
    write("Nimm dazu doch bitte 'beschreibe'!\n");
    return 1;
      }
      pre = ((flag & AUSSEN) ? (find_object(HAUSNAME(owner)))->QueryProp(P_LONG) : QueryProp(P_INT_LONG));
      break;
    case "meld":
      if (file_size(REPFILE(owner)) > 0)
    pre = read_file(REPFILE(owner));
      else {
    write("Ich finde keine Meldungen aus Deinem Haus!\n");
    return 1;
      }
      flag |= REPORT;
      break;
    case "deta":      // Details
      if (sp==1) {
    notify_fail("Welches Detail willst Du denn aendern?\n");
    return 0;
      }
      if (sr>1) {
    notify_fail("Du kannst immer nur ein Detail aendern!\n");
    return 0;
      }
      flag |= DETAIL;
      pre = getPreText(P_DETAILS, implode(parts[1..], " "));
      break;
    case "lesb":      // lesbare Details
      notify_fail("Welches lesbare Detail willst Du denn aendern?\n");
      if (sp == 1) return 0;
      if ((parts[1] == "details" || parts[1] == "detail") && (sp==2))
    return 0;
      if (sr>1) {
    notify_fail("Du kannst immer nur ein lesbares Detail aendern!\n");
    return 0;
      }
      flag |= RDETAIL;
      pre = getPreText(P_READ_DETAILS, implode(parts[1..], " "));
      break;
    case "befe":      // Befehle
      ret = 0;
      if (sp == 1) {
    notify_fail("Welchen Befehl willst Du denn aendern?\n");
    return 0;
      }
      if (sr>1) {
    notify_fail("Du kannst immer nur einen Befehl aendern!\n");
    return 0;
      }
      flag |= BEFEHL;
      pre = getPreText(H_COMMANDS, implode(parts[1..], " "));
      break;
    default:
      notify_fail("Das kannst Du nicht aendern! Eine Liste der Dinge, die Du hier aendern\n"
         +"kannst, erhaeltst Du mit 'hilfe aendere'.\n" );
      return 0;
      break;
  }
  if (!pre)
    write("Hm, sowas ist hier noch nicht beschrieben...\n");
  else {
    write( "Aendere nun den Text.\n(Beenden mit . oder **, Abbruch mit ~q, Hilfe mit ~h)\n" );
    nedit( "aenderung", pre );
  }
  return 1;
}

void aenderung(string str)
{
  string *warn;

  if (!str) {
    write("Nichts geaendert!\n");
    return;
  }

  if (flag && !(flag & BEFEHL))
    str = normstr(str);

  warn = ({ });

  if (flag & LANG) {
    if (flag & AUSSEN) {
      object haus;
      haus = find_object(HAUSNAME(owner));
      haus->SetProp(P_LONG, str);
      haus->Save();
    }
    else
      SetProp(P_INT_LONG, str);
  }
  else if (flag & DETAIL) {
    if (str == "")
      RemoveDetail(detail);
    else
      AddDetail(detail, str);
  }
  else if (flag & RDETAIL) {
    if (str == "")
      RemoveReadDetail(detail);
    else
      AddReadDetail(detail, str);
  }
  else if (flag & BEFEHL) {
    if (str == "")
      RemUserCmd(detail);
    else {
      string *s;

      s = old_explode(preparse(str, &warn), "@@\n");
      if (sizeof(s) > 1 && s[1] != "")
    AddUserCmd(detail, 0, normstr(s[0]), normstr(s[1]));
      else
    AddUserCmd(detail, 0, normstr(s[0]), 0);
    }
  }
  else if (flag & REPORT) {
    rm(REPFILE(owner));
    if (str != "")
      write_file(REPFILE(owner), str);
  }
  else
    write( "Huch! Unbekanntes Flag ("+flag+")... Sag mal Wargon Bescheid...\n");

  arr_out(warn, "OK.", "WARNUNG! Ungueltiger Platzhalter: %s",
               "WARNUNG! Ungueltige Platzhalter: ");
  Save();
}

int SmartLog(string ofile, string typ, string msg, string date)
{
  object home;

  // speichere Meldung im Rep-Log des Seherhaus-Besitzers
  write_file(REPFILE(owner), sprintf("%s von %s in Raum %d (%s):\n%s\n",
                     typ,
                     capitalize(getuid(this_player())),
                     raumNr,
                     date,
                     break_string(msg,78)));

  if (IS_LEARNER(owner)) {
    log_file("report/"+owner+".rep",
         sprintf("MELDUNG von %s im Seherhaus, Raum %d (%s):\n"
             +"Bitte zur Kenntnis nehmen! (Mit dem Befehl 'meldungen')  -Wargon\n",
             capitalize(getuid(this_player())),
             raumNr,
             date));
  }

  // erhoehe im Hauptraum den Rep-Zaehler und speichere
  home = load_object(RAUMNAME(owner,0));
  home->Set(H_REPORT, home->Query(H_REPORT)+1);
  home->Save();

  return 1;
}

static int report(string str)
{
  string rep, *lines;
  int rNum, l, s;

  if (!allowed_check(this_player()))
    return 0;

  if (file_size(REPFILE(owner)) <= 0) {
    write( "Keine Meldungen zu finden... Du bist wunschlos gluecklich.\n" );
    return 1;
  }
  rep = read_file(REPFILE(owner));

  if (!rep) {
    write( "Oha! Die Datei mit den Meldungen ist zu gross! Sag doch bitte mal\n"
      +"Wargon Bescheid!\n");
    return 1;
  }

  if (str) {
    string d, *new, *tmp, prev;
    int nr, nextNr, m;

    if (str == "hier")
      rNum = raumNr;
    else
      rNum = to_int(str);

    if (rNum > VERWALTER->HausProp(owner, HP_ROOMS)) {
      write( "So viele Raeume hast Du gar nicht!\n");
      return 1;
    }

    lines = old_explode(rep, "\n");
    s = sizeof(lines);
    for (l=0; prev == 0; l++)
      if (sscanf(lines[l], "%s von %s in Raum %d %s:", d, d, nr, d)==4)
    prev=lines[l];

    for ( new = ({}), tmp=({}); l<s; l++) {
      m=sscanf(lines[l], "%s von %s in Raum %d %s:", d, d, nextNr, d);
      if (m != 4 && nr == rNum)
    tmp += ({ lines[l] });

      if (m==4) {
    if (sizeof(tmp)) {
      new = new + ({ prev }) + tmp;
      tmp = ({});
    }
    nr = nextNr;
    prev = lines[l];
      }
    }
    if (sizeof(tmp))
      new = new + ({prev}) + tmp;
    rep = implode(new, "\n");
  }

  this_player()->More(rep);
  return 1;
}

// $Log: raum.c,v $
// Revision 1.5  2003/11/15 14:03:58  mud
// Lichtaenderungen von Zook
//
// Revision 1.4  2003/02/17 20:00:00  mud
// Im Reset wird nun getestet, ob der Raum einen Ausgang in einen Null-Raum
// hat. Dies wurde notwengig, damit Spieler nicht in Seherhaeuser eingesperrt 
// werden koennen. Die Funktionen AddExit(), RemoveExit() und Reset starten 
// gegebenenfalls den Ausgangstest. Einige Funs mussten leicht angepasst 
// werden.
// Die Funktionen room_has_exit() und is_exit() wurden von Vardion@MG 
// entwickelt und zur Verfuegung gestellt. - Vanion
//
// Revision 1.3  2001/02/04 21:21:34  mud
// (brk,getBefParam): Vorkehrungen gegen fuehrende und schliessende
// Leerzeichen in Befehlsparametern und anderen Listen.
//
// Revision 1.2  2001/01/01 18:17:47  mud
// (ausgang): Wenn ein Ausgang zu einem anderen Seherhaus gelegt wird,
// wird die Erlaubnis in dessen Eingangsraum abgefragt, und nicht in
// dem angeforderten Zielraum (der Eingangsraum existiert auf jeden
// Fall, der Zielraum vielleicht nicht).
//
// Revision 1.1.1.1  2000/08/20 20:22:42  mud
// Ins CVS eingecheckt
//
// 04.02.98 Meldungen koennen geloescht werden.
//
// Revision 2.16  1997/11/15 19:33:23  Wargon
// arr_out(), preparse(): kleine Bugfixes
//
// Revision 2.15  1997/10/06 15:24:38  Wargon
// Unsichtbare Magier melden/anzeigen
// Meldung beim Betreten abgeschlossener Haeuser fuer Magier
//
// Revision 2.14  1996/02/21  18:12:47  Wargon
// SmartLog() rein, dafuer die eigenen Rueckmeldungsbefehle raus
//
// Revision 2.13  1995/10/31  12:56:16  Wargon
// Rueckmeldungen fuer Objekte werden ans Spielerobjekt weitergegeben.
//
// Revision 2.12  1995/08/07  18:35:12  Wargon
// Einige Bugs bei "aendere" behoben.
//
// Revision 2.11  1995/06/29  08:57:05  Wargon
// Hausbesitzer, die schon Magier sind, bekommen bei Rueckmeldungen auch einen
// Eintrag in ihr /log/report/xyz.rep-File
// "licht an/aus" ist seit 2.9 drin ;)
//
// Revision 2.10  1995/06/28  08:59:57  Wargon
// Neue Befehle aendere, meldungen fuer den Hausbesitzer.
// typo, bug/fehler, idee werden dem Haus-.rep-File zugefuehrt.
// Jetzt koennen die Seher ihre Typos selber fixen! ;^)
//
// Revision 2.9  1995/06/20  07:49:15  Wargon
// *** empty log message ***
//
// Revision 2.8  1995/04/21  10:48:39  Wargon
// Bugfix in beschreiben(), wenn die Hausaussenbeschreibung
// verlangt wird (war schon seit Ewigkeiten buggy... ;)
//
// Revision 2.7  1995/04/21  08:55:32  Wargon
// Load()/Save() und eigene Kommandos ausgelagert.
// Kommandos koennen mit notify_fail() versehen werden.
//
// Revision 2.6  1995/03/07  13:55:36  Wargon
// Add/RemUserCmd(), Beschreibungen werden bei reset()/clean_up()
// gepackt gespeichert.
// Bei Kommandos nur noch more(), wenn es auch noetig ist.
//
// Revision 2.5  1995/02/27  20:48:26  Wargon
// Kleine Schoenheitsfehler in selbstdefinierten Befehlen beseitigt.
//
// Revision 2.4  1995/02/22  21:30:52  Wargon
// Noch mehr Aenderungen an den Befehlen:
// - Preparsing der Platzhalter
// - Platzhalter fuer Possessivpronomen
// - Meldung fuer Ausfuehrenden wird geMore()t
// - Rassen- und Geschlechtespezifische Meldungen moeglich
// - Auch fuer Ausgaenge koennen Befehle definiert werden
//   (nur fuer existierende; wird der Ausgang gesperrt, wird auch
//   der Befehl geloescht)
// Im Zuge des Preparsings hat sich die Befehlauswertung etwas
// vereinfacht.
//
// Revision 2.3  1995/02/20  22:15:44  Wargon
// READ_DETAILS werden jetzt mit More() ausgegeben.
// Selbstdefinierte Befehle: mit @PWER, ... koennen die Personalpronomina
// eingebaut werden; Einbau jetzt auch in die Meldung fuer den Ausloeser
// moeglich; _unparsed_args() in der Auswertung.
//
// Revision 2.2  1995/02/15  11:23:04  Wargon
// NEU: Selbstdefinierbare Befehle.
//
// Revision 2.1  1995/02/04  15:02:36  Wargon
// Die Truhe wird nun ueber die Property CHEST verwaltet. Der AddItem()-
// Aufruf wurde deshalb von create() nach Load() verlegt. Geladen wird
// sie nur, wenn das Load() von Hausverwalter erfolgte.
// clean_up(), wenn Raum leer ist oder nur eine leere Truhe drin steht.
//
// Revision 2.0  1995/02/01  20:36:49  Wargon
// Entruempelt und Massnahmen fuer _unparse_args() getroffen.