doors.c-Dateireferenz

#include <config.h>
#include <thing/properties.h>
#include <language.h>
#include <defines.h>
#include <doorroom.h>

Include-Abhängigkeitsdiagramm für doors.c:

gehe zum Quellcode dieser Datei

Makrodefinitionen
#define	NEED_PROTOTYPES
Funktionen
varargs void	AddCmd (mixed cmd, mixed func, mixed flag, mixed cmdid)
void	AddExit (mixed cmd, mixed room)
void	AddSpecialExit (mixed cmd, mixed functionname)
void	RemoveSpecialExit (mixed cmd)
protected void	create ()
protected void	create_super ()
varargs int	NewDoor (mixed cmds, string dest, mixed ids, mixed props)
void	init ()
void	reset ()
int	oeffnen (string str)
int	schliessen (string str)
varargs int	go_door (string str)
int	set_doors (string *cmds, int open)
string	special_detail_doors (string key)

---

Makro-Dokumentation

#define NEED_PROTOTYPES

Definiert in Zeile 13 der Datei doors.c.

---

Dokumentation der Funktionen

varargs void AddCmd	(	mixed	cmd,
		mixed	func,
		mixed	flag,
		mixed	cmdid
	)

Definiert in Zeile 55 der Datei commands.c.

Benutzt added_cmds, cl und i.

Wird benutzt von create(), MakeDrink() und SetTravelCmds().

                                                                    {
 int i,j;
 closure cl;
 mixed *rule;

 // potentielle AddCmd mit Regel?
 if(stringp(cmd)) {
  // eine Regel? - aufsplitten
  if((i=member(cmd,'&'))>0) {
   // ... in Array mit Verknuepfungselementen
   rule=explode(cmd[(i+1)..],"&");
   j=sizeof(rule);
   // ... in Array mit Arrays mit Alternativelementen:
   // "p|q&r|s" -> ({ ({"p","q"}), ({"r","s"}} })
   while(j--)
    rule[j]=explode(rule[j],"|");

   // Regeln von Kommandoverben abschneiden
   cmd=cmd[0..(i-1)];
  }
  // Kommandoverben extrahieren
  cmd=explode(cmd,"|");

  // Satz von Regeln existiert: Aufsplitten von Fehlermeldungen
  if(rule)
   if(stringp(flag)) {
    mixed *fail;
    // in einfaches Array mit jeweiligen Fehlermeldungen
    fail=explode(flag,"|");
    j=0;
    i=sizeof(fail);
    while(j<i) {
     // write - Fehlermeldung entdeckt - Position ggf. eintragen
     if(member(fail[j],'^')>=0 && !intp(fail[<1]))
      fail+=({j});
     if(member(fail[j],'@')>=0) {
      int s;
      flag=regexplode(fail[j], "@WE[A-SU]*[0-9]");
      s=sizeof(flag);
      while((s-=2)>0) {
       int tmpint;
       tmpint=flag[s][<1]-'1';
       if(tmpint<0 || tmpint>j)
        raise_error(sprintf(
         "AddCmd: error-message %d contains out-of-bounds @WExx-rule.\n",j+1));
      }
     }
     j++;
    }
    // "Was?|Wie das?" -> ({"Was?","Wie das?"})
    // "Was?|Wie das?^|Womit das?|Worauf das?^@WER1 macht was." ->
    //  ({"Was?",
    //    "Wie das?^Womit das?",
    //            "Worauf das?^@WER1 macht was.",1})
    flag=sizeof(fail);
    if(flag && flag<sizeof(rule))
     raise_error(
      "AddCmd: number of error-messages does not match number of rules.\n");
    flag=fail; // ueberschreiben mit den parsefreundlichen Format
  } else if(flag)
   raise_error("AddCmd: rules exist but flags are not an error-string.\n");
 } // end if(stringp(cmd)) ... kein Regelstring vorhanden

 // kein Kommandoarray gewesen noch erzeugt?
 if(!pointerp(cmd))
   raise_error("AddCmd: missing string/pointer-parameter for command.\n");

 // Closure aus einem String erzeugen, wenn moeglich und sicher
 // (function_exists() filtert unnoetigerweise auch reine "static" funs,
 //  die genaue Pruefung ueber functionlist() kostet jedoch zuviel)
 if(stringp(func) &&
    (!extern_call() || function_exists(func,this_object())) &&
    closurep(cl=symbol_function(func,this_object())))
  func=cl;

 // jedes einzelne Verb mit seinen Regeln und Funktionen eintragen
 i=sizeof(cmd);
 if(!added_cmds) added_cmds=m_allocate(i,4);
 while(i--) {
  string str;
  str=cmd[i];
  if(!func)
   if(extern_call()) func=previous_object();
   else func=this_object();
  if(!member(added_cmds,str))
   added_cmds+=([str:allocate(0);allocate(0);allocate(0);0]);
  // existierendes Verb ergaenzen
  added_cmds[str,0]+=({func});
  added_cmds[str,1]+=({flag});
  added_cmds[str,2]+=({rule});
  // ggf. id in das ID-Mapping eintragen
  if(cmdid) {
   mixed *tmp;
   j=sizeof((string*)added_cmds[str,0]);
   tmp=added_cmds[str,3]||allocate(j);
   if(sizeof(tmp)<j) tmp+=allocate(j-sizeof(tmp));
   tmp[<1]=cmdid;
   added_cmds[str,3]=tmp;
  }
 }
}

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void AddExit	(	mixed	cmd,
		mixed	room
	)

Definiert in Zeile 116 der Datei exits.c.

Benutzt _MakePath(), i, msg(), P_EXITS, Query(), rescueExit(), ROUTER und Set().

Wird benutzt von AddSpecialExit(), create() und move().

{
    int i;
    mapping exita;
  
    exita = Query(P_EXITS) || rescueExit();
    
    if ( !closurep(room) ){
        int s;
        string msg;
        object router;
    
        if( (s = member(room, '#')) != -1 ){
            msg  = room[0..s];
            room = room[s+1..];
        }
        else
            msg = "";
        
        room = _MakePath(room);

        if ( !clonep(this_object()) && objectp(router = find_object(ROUTER)) )
            router->RegisterExit( object_name(this_object()), cmd, room );
    
        room = msg + room;
    }
    
    if( !pointerp(cmd) )
        exita += ([ cmd : room ]);
    else 
        for( i = sizeof(cmd); i--; )
            exita += ([ cmd[i] : room ]);

    Set( P_EXITS, exita );
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void AddSpecialExit	(	mixed	cmd,
		mixed	functionname
	)

Definiert in Zeile 175 der Datei exits.c.

Benutzt AddExit().

Wird benutzt von set_doors().

{
    
    if ( stringp(functionname) )
        functionname = symbol_function( functionname, this_object() );
    
    if ( !closurep(functionname) ) {
                catch(raise_error(sprintf( "method %O doesn't exist\n",
                                functionname)); publish);
                return;
    }
    
    AddExit( cmd, functionname );
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

protected void create

(

)

Definiert in Zeile 28 der Datei doors.c.

Benutzt P_DOOR_INFOS und SetProp().

{
  SetProp(P_DOOR_INFOS,0);
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

protected void create_super

(

)

Definiert in Zeile 33 der Datei doors.c.

Benutzt set_next_reset().

                              {
  set_next_reset(-1);
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

varargs int go_door

(

string

str

)

Definiert in Zeile 123 der Datei doors.c.

Benutzt DOOR_MASTER, P_DOOR_INFOS und QueryProp().

{
  if (!QueryProp(P_DOOR_INFOS))
    return 0;
  if (call_other(DOOR_MASTER,"go_door",query_verb()))
    return 1;
  return 0;
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

void init

(

)

Definiert in Zeile 84 der Datei doors.c.

Benutzt cmds, D_CMDS, i, info, P_DOOR_INFOS und QueryProp().

{
  mixed *info;
  string *cmds;
  int i,j;

  if (!pointerp(info=(mixed *)QueryProp(P_DOOR_INFOS))) return;
  add_action("oeffnen","oeffne");
  add_action("schliessen","schliesse");
  add_action("schliessen","schliess");
  for (i=sizeof(info)-1;i>=0;i--) {
    cmds=(string *)(info[i][D_CMDS]);
    for (j=sizeof(cmds)-1;j>=0;j--)
      add_action("go_door",cmds[j]);
    // Befehle IMMER anfuegen, gechecked wird sowieso erst beim Durchgehen.
  }
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

varargs int NewDoor	(	mixed	cmds,
		string	dest,
		mixed	ids,
		mixed	props
	)

Definiert in Zeile 37 der Datei doors.c.

Benutzt DOOR_MASTER.

{
/*
  cmds: Befehl(e), um durch die Tuer zu gehen (String oder Array von Strings)
  dest: Zielraum
  ids:  Id(s) der Tuer, default "tuer" (String, Array von Strings oder 0)
  props: besondere Eigenschaften der Tuer (optional)
  Array mit Paaren Nummer der Eigenschaft, Inhalt
  definierte Properties sind:
  D_FLAGS:  Flags wie bei Sir's Tueren
  default: DOOR_CLOSED | DOOR_RESET_CL
  Bei Schluesseln wird getestet, ob der String, den
  QueryDoorKey zurueckliefert, gleich
  "raumname1:raumname2" ist, wobei raumname1,2 die
  kompletten Filenamen der beiden Raeume in sortierter
  Reihenfolge sind.
  D_LONG:   lange Beschreibung der Tuer
  default: "Eine Tuer.\n"
  D_SHORT:  kurze Beschreibung der Tuer, wird an die Raumbeschreibung
  angefuegt, wobei %s durch geoeffnet bzw. geschlossen
  ersetzt wird.
  default: "Eine %se Tuer. "
  D_NAME:   Name, der beim Oeffnen/Schliessen und bei Fehlermeldungen
  angezeigt wird.
  default: "Tuer"
  D_GENDER: default: FEMALE
  D_FUNC:   Funktion, die im Raum aufgerufen werden soll, wenn die
  Tuer erfolgreich durchschritten wird.
  default: 0
  D_MSGS:   Falls String: ausgegebene Richtung fuer move
  Falls Array: ({direction, textout, textin}) fuer move
  default: 0

  Beispiel:
  NewDoor("norden","/players/rochus/room/test2","portal",
  ({D_NAME,"Portal",
  D_GENDER,NEUTER,
  D_SHORT,"Im Norden siehst Du ein %ses Portal. ",
  D_LONG,"Das Portal ist einfach nur gigantisch.\n"
  }));

*/

  if (!cmds || !dest) return 0;
  return call_other(DOOR_MASTER,"NewDoor",cmds,dest,ids,props);
}

int oeffnen

(

string

str

)

Definiert in Zeile 108 der Datei doors.c.

Benutzt DOOR_MASTER, P_DOOR_INFOS und QueryProp().

{
  if (!str || !QueryProp(P_DOOR_INFOS))
    return 0;
  return (int) call_other(DOOR_MASTER,"oeffnen",str);
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

void RemoveSpecialExit

(

mixed

cmd

)

Definiert in Zeile 191 der Datei exits.c.

Benutzt RemoveExit().

Wird benutzt von set_doors().

{
    RemoveExit( cmd );
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void reset

(

void

)

Definiert in Zeile 102 der Datei doors.c.

Benutzt DOOR_MASTER, P_DOOR_INFOS und QueryProp().

{
  if (QueryProp(P_DOOR_INFOS))
    call_other(DOOR_MASTER,"reset_doors");
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

int schliessen

(

string

str

)

Definiert in Zeile 115 der Datei doors.c.

Benutzt DOOR_MASTER, P_DOOR_INFOS und QueryProp().

{
  if (!str || !QueryProp(P_DOOR_INFOS))
    return 0;
  return (int) call_other(DOOR_MASTER,"schliessen",str);
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

int set_doors	(	string *	cmds,
		int	open
	)

Definiert in Zeile 132 der Datei doors.c.

Benutzt AddSpecialExit(), DOOR_MASTER und RemoveSpecialExit().

{
  int j;
  
  if (!previous_object())
    return 0;
  if (object_name(previous_object())!=DOOR_MASTER)
    return 0;
  // Andere sollen nicht rumpfuschen.
  if (!this_player()) return 0;
  if (environment(this_player())!=this_object())
    return 0;
  // Ist sowieso keiner da...
  if (!pointerp(cmds))
    return 0;
  if (open)
    AddSpecialExit(cmds,"go_door");
  else
    RemoveSpecialExit(cmds);
  for (j=sizeof(cmds)-1;j>=0;j--)
    add_action("go_door",cmds[j]);
}

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

string special_detail_doors

(

string

key

)

Definiert in Zeile 159 der Datei doors.c.

Benutzt DOOR_MASTER.

                                       {
  return DOOR_MASTER->special_detail_doors(key);
}