doormaster.c-Dateireferenz

#include <properties.h>
#include <defines.h>
#include <moving.h>
#include <language.h>
#include <doorroom.h>
Include-Abhängigkeitsdiagramm für doormaster.c:

gehe zum Quellcode dieser Datei

Makrodefinitionen

#define NEED_PROTOTYPES

Funktionen

int oeffnen (string str)
mapping QueryAllDoors ()
int QueryDoorStatus (string dest)
void SetDoorStatus (string dest, int x)
void create ()
varargs int remove (int silent)
varargs int NewDoor (mixed cmds, string dest, mixed ids, mixed props)
void init_doors ()
string look_doors ()
static void door_message (object room, string dname, int dgender, string msg)
static void door_message_other (string source, string dest, string msg)
void reset_doors ()
static varargs int exec_func2 (string dest, mixed func)
varargs int go_door (string str)
int schliessen (string str)
string special_detail_doors (string key)

Variablen

inherit std thing
private mapping door_status
private int id_zaehler

Makro-Dokumentation

#define NEED_PROTOTYPES

Definiert in Zeile 6 der Datei doormaster.c.

Dokumentation der Funktionen

void create (  ) 

Definiert in Zeile 43 der Datei doormaster.c.

Benutzt door_status, id_zaehler und IS_CLONE.

00043               {
00044   door_status=([]);
00045   id_zaehler=0;
00046   if (IS_CLONE(this_object())) remove();
00047 }

static void door_message ( object  room,
string  dname,
int  dgender,
string  msg 
) [static]

Definiert in Zeile 167 der Datei doormaster.c.

Benutzt ob(), P_ARTICLE, P_GENDER, P_NAME und WER.

Wird benutzt von door_message_other() und reset_doors().

00167                                                                              {
00168   object ob;
00169 
00170   // printf("%O,%O,%O,%O\n",room,dname,dgender,msg);
00171   if (!room || !dname || !msg) return;
00172   ob=this_object();
00173   ob->SetProp(P_NAME,dname);
00174   ob->SetProp(P_GENDER,dgender);
00175   ob->SetProp(P_ARTICLE,1);
00176   tell_room(room,capitalize(ob->name(WER))+msg+"\n");
00177 }

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

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

static void door_message_other ( string  source,
string  dest,
string  msg 
) [static]

Definiert in Zeile 179 der Datei doormaster.c.

Benutzt D_DEST, D_GENDER, D_NAME, door_message(), env(), i, info und P_DOOR_INFOS.

Wird benutzt von oeffnen(), reset_doors() und schliessen().

00179                                                                        {
00180   mixed info;
00181   object env;
00182   int i;
00183 
00184   // printf("%O %O %O\n",source,dest,msg);
00185   if (!source || !dest || !msg) return;
00186   if (!objectp(env=find_object(dest))) return;
00187   if (!pointerp(info=env->QueryProp(P_DOOR_INFOS))) return;
00188   for (i=sizeof(info)-1;i>=0;i--) {
00189     if (!mappingp(info[i])) continue;
00190     if (info[i][D_DEST]!=source) continue; // Andere Tuer zu diesem Raum
00191     door_message(env,info[i][D_NAME],info[i][D_GENDER],msg);
00192   }
00193 }

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

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

static varargs int exec_func2 ( string  dest,
mixed  func 
) [static]

Definiert in Zeile 242 der Datei doormaster.c.

Wird benutzt von go_door().

00242                                                        {
00243   if (!stringp(dest) || !stringp(func)) return 1;
00244   call_other(dest,func);
00245   return 1;
00246 }

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

varargs int go_door ( string  str  ) 

Definiert in Zeile 248 der Datei doormaster.c.

Benutzt D_CMDS, D_DEST, D_FUNC, D_FUNC2, D_GENDER, D_IDS, D_MSGS, D_NAME, D_OPEN_WITH_MOVE, D_TESTFUNC, dest(), dkey, door_status, env(), exec_func2(), i, info, M_GO, member_array(), notify_fail(), ob(), oeffnen(), P_ARTICLE, P_DOOR_INFOS, P_GENDER, P_NAME, pl und WER.

00248                                  {
00249   object env,pl,ob;
00250   mixed *info;
00251   string source,dest,dkey;
00252   int i;
00253 
00254   if (!str) return 0;
00255   if (!objectp(env=previous_object())) return 0;
00256   if (!objectp(pl=this_player())) return 0;
00257   info=env->QueryProp(P_DOOR_INFOS);
00258   if (!pointerp(info)) return 0;
00259 
00260   source=object_name(env);
00261   ob=this_object();
00262   ob->SetProp(P_ARTICLE,1);
00263   for (i=sizeof(info)-1;i>=0;i--) {
00264     if (!mappingp(info[i])) continue;
00265     if (member_array(str,info[i][D_CMDS])<0) continue;
00266     dest=info[i][D_DEST];
00267     dkey=((string)((source<dest)?(source+":"+dest):(dest+":"+source)));
00268     ob->SetProp(P_NAME,info[i][D_NAME]);
00269     ob->SetProp(P_GENDER,info[i][D_GENDER]);
00270     notify_fail(capitalize(ob->name(WER,1))+" ist geschlossen.\n");
00271     if((door_status[dkey]<=0) &&
00272        !info[i][D_OPEN_WITH_MOVE]) continue; // Tuer geschlossen
00273     if(door_status[dkey]<=0){
00274       // In diesem Fall versuchen, die Tuer zu oeffnen.
00275       oeffnen(info[i][D_IDS][0]);
00276     }
00277     notify_fail(capitalize(ob->name(WER,1))+" ist geschlossen.\n");
00278     if (door_status[dkey]<=0) continue; // Tuer immer noch zu.
00279     if (stringp(info[i][D_TESTFUNC]))
00280       if (call_other(env,info[i][D_TESTFUNC]))
00281                                 return 1; // Durchgang von der Tuer nicht erlaubt.
00282     if (stringp(info[i][D_FUNC]))
00283       call_other(env,info[i][D_FUNC]);
00284                 if (stringp(info[i][D_MSGS])) {
00285                   if (pl->move(dest,M_GO,info[i][D_MSGS])>0)
00286                                 return exec_func2(dest,info[i][D_FUNC2]);
00287                   else
00288                                 return 1;
00289                 }
00290                 if (pointerp(info[i][D_MSGS]) && sizeof(info[i][D_MSGS])>=3) {
00291                   if (pl->move(dest,M_GO,info[i][D_MSGS][0],
00292                                                                    info[i][D_MSGS][1],info[i][D_MSGS][2]))
00293                                 return exec_func2(dest,info[i][D_FUNC2]);
00294                   else
00295                                 return 1;
00296                 }
00297     if (pl->move(dest,M_GO,"nach "+capitalize(str)))
00298                   return exec_func2(dest,info[i][D_FUNC2]);
00299     return 1;
00300   }
00301   return 0;
00302 }

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

void init_doors (  ) 

Definiert in Zeile 111 der Datei doormaster.c.

Benutzt D_CMDS, D_DEST, dest(), dkey, door_status, env(), i, info und P_DOOR_INFOS.

Wird benutzt von look_doors(), oeffnen(), reset_doors() und schliessen().

00111                    {
00112   object env;
00113   mixed *info;
00114   string source,dest,dkey;
00115   int i;
00116 
00117   if (!objectp(env=previous_object())) return;
00118   info=env->QueryProp(P_DOOR_INFOS);
00119   if (!pointerp(info)) return;
00120 
00121   source=object_name(env);
00122   for (i=sizeof(info)-1;i>=0;i--) {
00123     if (!mappingp(info[i])) continue;
00124     dest=info[i][D_DEST];
00125     dkey=((string)((source<dest)?(source+":"+dest):(dest+":"+source)));
00126     env->set_doors(info[i][D_CMDS],(door_status[dkey]>0));
00127   }
00128 }

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

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

string look_doors (  ) 

Definiert in Zeile 130 der Datei doormaster.c.

Benutzt break_string(), D_DEST, D_SHORT, dest(), dkey, door_status, env(), i, info, init_doors() und P_DOOR_INFOS.

00130                      {
00131   object env;
00132   mixed *info, ds;
00133   string source,dkey,dest,res;
00134   int i, st;
00135 
00136   if (!objectp(env=previous_object())) return "";
00137   info=env->QueryProp(P_DOOR_INFOS);
00138   if (!pointerp(info)) return "";
00139   init_doors(); // Aktueller Zustand soll auch bei den Exits angezeigt werden
00140 
00141   source=object_name(env);res="";
00142   for (i=sizeof(info)-1;i>=0;i--) {
00143     if (!mappingp(info[i])) continue;
00144     dest=info[i][D_DEST];
00145     dkey=((string)((source<dest)?(source+":"+dest):(dest+":"+source)));
00146     if (stringp(info[i][D_SHORT])) {
00147       res+=sprintf(info[i][D_SHORT],
00148                                     ((string)((door_status[dkey]>0)?"geoeffnet":
00149                                                  (((string)((door_status[dkey]!=-1)?"ab":""))+"geschlossen"))));
00150                   if (strlen(res) && res[<1]!='\n')
00151                                 res+=" ";
00152                 }
00153     else if(mappingp(ds=info[i][D_SHORT])){
00154       st=door_status[dkey];
00155       if((st==-2) && !ds[st])st=-1;
00156       if(stringp(ds[st])){
00157         res += ds[st];
00158         if(strlen(ds[st]) && res[<1]!='\n')res+=" ";
00159       }
00160     }
00161   }
00162   if (res && res!="")
00163     return break_string(res,78,0,1);
00164   return res;
00165 }

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

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

Definiert in Zeile 51 der Datei doormaster.c.

Benutzt D_CMDS, D_DEST, D_FLAGS, D_GENDER, D_IDS, D_LONG, D_MAXPROPS, D_MINPROPS, D_NAME, D_SHORT, dkey, DOOR_CLOSED, DOOR_NEEDKEY, DOOR_OPEN, DOOR_RESET_CL, door_status, env(), FEMALE, i, id_zaehler, info und P_DOOR_INFOS.

00051                                                                      {
00052   object env;
00053   string source,dkey,sec_id;
00054   mixed *info2,zw;
00055   mapping info;
00056   int i;
00057 
00058   if (!objectp(env=previous_object())) return 0;
00059   if (!cmds || !dest) return 0;
00060   if (!ids) ids=({"tuer"});
00061   if (stringp(cmds)) cmds=({cmds});
00062   if (stringp(ids)) ids=({ids});
00063   if (!pointerp(cmds) || !pointerp(ids)) return 0;
00064   if (dest[0..0]!="/") dest="/"+dest;
00065   id_zaehler++;
00066   sec_id=sprintf("secure_id:door%d",id_zaehler);
00067 
00068   info=([D_DEST   : dest,
00069                  D_CMDS   : cmds,
00070                  D_IDS    : ({ sec_id }) + ids,
00071                  D_FLAGS  : (DOOR_CLOSED|DOOR_RESET_CL),
00072          D_LONG   : "Eine Tuer.\n",
00073                  D_SHORT  : "Eine %se Tuer. ",
00074                  D_NAME   : "Tuer",
00075                  D_GENDER : FEMALE]);
00076   source=object_name(env);
00077   dkey=((string)((source<dest)?(source+":"+dest):(dest+":"+source)));
00078 
00079   if (pointerp(props)) {
00080     for (i=0;i<sizeof(props)-1;i+=2)
00081       if (intp(props[i]) && props[i]>=D_MINPROPS && props[i]<=D_MAXPROPS)
00082         info[props[i]]=props[i+1];
00083   }
00084   else if(mappingp(props)){
00085     info += props;
00086   }
00087 
00088   if (!door_status[dkey]) {
00089     // Nur initialisieren, wenn Tuer noch nicht existiert.
00090     if (info[D_FLAGS] & DOOR_OPEN)
00091                   door_status[dkey]=1;
00092     if (info[D_FLAGS] & DOOR_CLOSED)
00093                   door_status[dkey]=((info[D_FLAGS] & DOOR_NEEDKEY)?-2:-1);
00094   }
00095   info2=env->QueryProp(P_DOOR_INFOS);
00096   if (!pointerp(info2))
00097     info2=({info});
00098   else
00099     info2+=({info});
00100   env->SetProp(P_DOOR_INFOS,info2);
00101 
00102   if(mappingp(info[D_LONG]) && pointerp(zw=m_indices(info[D_LONG])) &&
00103      sizeof(zw) && intp(zw[0]))
00104     env->AddSpecialDetail(ids,"special_detail_doors");
00105   else if(info[D_LONG] && info[D_LONG]!="")
00106     env->AddDetail(ids,info[D_LONG]);
00107 
00108   return 1;
00109 }

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

int oeffnen ( string  str  ) 

Definiert in Zeile 304 der Datei doormaster.c.

Benutzt D_DEST, D_FLAGS, D_GENDER, D_IDS, D_NAME, dest(), dkey, door_message_other(), DOOR_NEEDKEY, door_status, env(), i, info, init_doors(), member_array(), notify_fail(), ob(), P_ARTICLE, P_DOOR_INFOS, P_GENDER, P_NAME, WEM, WEN und WER.

Wird benutzt von go_door().

00304                          {
00305   object env,schl,ob;
00306   mixed *info,s2;
00307   string source,dkey,dest,s1;
00308   int i;
00309 
00310   notify_fail("WAS willst Du oeffnen?\n");
00311   if (!str || !this_player()) return 0;
00312   notify_fail("Das kannst Du nicht oeffnen.\n");
00313   str=lower_case(str);
00314   if (sscanf(str,"%s mit %s",s1,s2)!=2)
00315     {s1=str;s2=0;}
00316   if (s2) {
00317     if (!(schl=present(lower_case(s2),this_player()))) {
00318       notify_fail("So einen Schluessel hast Du nicht.\n");
00319       return 0;
00320     } else {
00321       s2=schl->QueryDoorKey();
00322                   if (stringp(s2)) s2=({s2});
00323     }
00324   }
00325 
00326   if (!objectp(env=previous_object())) return 0;
00327   info=env->QueryProp(P_DOOR_INFOS);
00328   if (!pointerp(info)) return 0;
00329 
00330   source=object_name(env);
00331   ob=this_object();
00332   ob->SetProp(P_ARTICLE,1);
00333   for (i=sizeof(info)-1;i>=0;i--) {
00334     if (!mappingp(info[i])) continue;
00335     if (member_array(s1,info[i][D_IDS])<0) continue; // Falsche Tuer
00336     ob->SetProp(P_NAME,info[i][D_NAME]);
00337     ob->SetProp(P_GENDER,info[i][D_GENDER]);
00338     dest=info[i][D_DEST];
00339     dkey=((string)((source<dest)?(source+":"+dest):(dest+":"+source)));
00340     notify_fail(capitalize(ob->name(WER,1))+" ist doch schon geoeffnet!\n");
00341     if (door_status[dkey]>0)
00342       continue; // Eine andere Tuer koennte gemeint sein.
00343     if ((info[i][D_FLAGS] & DOOR_NEEDKEY) &&
00344                                 door_status[dkey]!=-1) { // abgeschlossen
00345       notify_fail("Du brauchst einen Schluessel, um "+ob->name(WEN,1)+" zu oeffnen.\n");
00346       if (!schl) continue; // Eine andere Tuer koennte gemeint sein.
00347       notify_fail(capitalize(schl->name(WER))+" passt nicht!\n");
00348       if (!pointerp(s2)) continue;
00349                   if (member(s2,dkey)<0) continue; // Koennte an einer anderen passen.
00350     }
00351     door_status[dkey]=1;
00352     init_doors();
00353     write("Du oeffnest "+ob->name(WEN)+".\n");
00354     say(capitalize(ob->name(WER))+" wird von "+this_player()->name(WEM)+
00355         " geoeffnet.\n");
00356     door_message_other(source,dest," wird von der anderen Seite geoeffnet.");
00357     return 1;
00358   }
00359   return 0;
00360 }

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

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

mapping QueryAllDoors (  ) 

Definiert in Zeile 19 der Datei doormaster.c.

Benutzt door_status.

00019 {return door_status;}

int QueryDoorStatus ( string  dest  ) 

Definiert in Zeile 21 der Datei doormaster.c.

Benutzt dkey, door_status und env().

00021                                  {
00022   string source,dkey;
00023   object env;
00024 
00025   if (!dest) return 0;
00026   if (!objectp(env=previous_object())) return 0;
00027   source=object_name(env);
00028   dkey=((string)((source<dest)?(source+":"+dest):(dest+":"+source)));
00029   return door_status[dkey];
00030 }

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

varargs int remove ( int  silent  ) 

Definiert in Zeile 49 der Datei doormaster.c.

00049 {return 0;}

void reset_doors (  ) 

Definiert in Zeile 195 der Datei doormaster.c.

Benutzt D_DEST, D_FLAGS, D_GENDER, D_NAME, D_RESET_MSG, dest(), dkey, door_message(), door_message_other(), DOOR_NEEDKEY, DOOR_RESET_CL, DOOR_RESET_OP, door_status, env(), i, info, init_doors(), msg() und P_DOOR_INFOS.

00195                     {
00196   object env;
00197   mixed *info;
00198   string source,dest,dkey,msg;
00199   int i,j;
00200 
00201   if (!objectp(env=previous_object())) return;
00202   info=env->QueryProp(P_DOOR_INFOS);
00203   if (!pointerp(info)) return;
00204 
00205   source=object_name(env);
00206   for (i=sizeof(info)-1;i>=0;i--) {
00207     if (!mappingp(info[i])) continue;
00208     dest=info[i][D_DEST];
00209     dkey=((string)((source<dest)?(source+":"+dest):(dest+":"+source)));
00210 
00211 //              if (door_status[dkey]>-2 && door_status[dkey]<2) {
00212 //                if (door_status[dkey]>0)
00213 //                              door_status[dkey]=2;
00214 //                else
00215 //                              door_status[dkey]=-2;
00216 //                continue; // nur jeder 2. Reset wird ausgefuehrt.
00217 //              }
00218 
00219     if (info[i][D_FLAGS] & DOOR_RESET_CL) {
00220       // Tuer muss bei Reset geschlossen werden
00221       if (door_status[dkey]>0) {
00222         if(!msg=info[i][D_RESET_MSG])msg=" schliesst sich.";
00223         door_message(env,info[i][D_NAME],info[i][D_GENDER],msg);
00224         door_message_other(source,dest,msg);
00225       }
00226                   if (door_status[dkey]!=-2)
00227                                 door_status[dkey]=((info[i][D_FLAGS] & DOOR_NEEDKEY)?-2:-1);
00228     }
00229     if (info[i][D_FLAGS] & DOOR_RESET_OP) {
00230       // Tuer muss bei Reset geoeffnet werden
00231       if (door_status[dkey]<=0) {
00232         if(!msg=info[i][D_RESET_MSG])msg=" oeffnet sich.";
00233         door_message(env,info[i][D_NAME],info[i][D_GENDER],msg);
00234         door_message_other(source,dest,msg);
00235       }
00236       door_status[dkey]=1;
00237     }
00238   }
00239   init_doors();
00240 }

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

int schliessen ( string  str  ) 

Definiert in Zeile 362 der Datei doormaster.c.

Benutzt D_DEST, D_FLAGS, D_GENDER, D_IDS, D_NAME, dest(), dkey, DOOR_CLOSEKEY, door_message_other(), DOOR_NEEDKEY, door_status, env(), i, info, init_doors(), member_array(), notify_fail(), ob(), P_ARTICLE, P_DOOR_INFOS, P_GENDER, P_NAME, WEM, WEN und WER.

00362                             {
00363   object env,schl,ob;
00364   mixed *info,s2;
00365   string source,dkey,dest,s1;
00366   int i,abg;
00367 
00368   notify_fail("WAS willst Du schliessen?\n");
00369   if (!str || !this_player()) return 0;
00370   notify_fail("Das kannst Du nicht schliessen.\n");
00371   str=lower_case(str);
00372   if (sscanf(str,"%s mit %s",s1,s2)!=2)
00373     {s1=str;s2=0;}
00374   if (s2) {
00375     if (!(schl=present(lower_case(s2),this_player()))) {
00376       notify_fail("So einen Schluessel hast Du nicht.\n");
00377       return 0;
00378     } else {
00379       s2=schl->QueryDoorKey();
00380                   if (stringp(s2)) s2=({s2});
00381     }
00382   }
00383 
00384   if (!objectp(env=previous_object())) return 0;
00385   info=env->QueryProp(P_DOOR_INFOS);
00386   if (!pointerp(info)) return 0;
00387 
00388   source=object_name(env);
00389   ob=this_object();
00390   ob->SetProp(P_ARTICLE,1);
00391   abg=0;
00392   for (i=sizeof(info)-1;i>=0;i--) {
00393     if (!mappingp(info[i])) continue;
00394     if (member_array(s1,info[i][D_IDS])<0) continue; // Falsche Tuer
00395     ob->SetProp(P_NAME,info[i][D_NAME]);
00396     ob->SetProp(P_GENDER,info[i][D_GENDER]);
00397     dest=info[i][D_DEST];
00398     dkey=((string)((source<dest)?(source+":"+dest):(dest+":"+source)));
00399                 if (schl) {
00400                   notify_fail(capitalize(ob->name(WER,1))+" ist doch schon abgeschlossen!\n");
00401                   if (door_status[dkey]<=0 && door_status[dkey]!=-1)
00402                                 continue; // Eine andere Tuer koennte gemeint sein.
00403                   if (info[i][D_FLAGS] & DOOR_CLOSEKEY) { // Schluessel noetig?
00404                                 notify_fail(capitalize(schl->name(WER))+" passt nicht!\n");
00405                                 if (!pointerp(s2)) continue;
00406                                 if (member(s2,dkey)<0) continue; // Koennte an einer anderen passen.
00407                                 door_status[dkey]=-2;
00408                                 abg=1;  // Tuer wird richtig abgeschlossen
00409                   } else {
00410                                 door_status[dkey]=((info[i][D_FLAGS] & DOOR_NEEDKEY)?-2:-1);
00411                                 // ohne Schluessel abschliessbar
00412                   }
00413                 } else {
00414                   notify_fail(capitalize(ob->name(WER,1))+" ist doch schon geschlossen!\n");
00415                   if (door_status[dkey]<=0)
00416                                 continue; // Eine andere Tuer koennte gemeint sein.
00417                   if ((info[i][D_FLAGS] & DOOR_NEEDKEY) &&
00418                                   !(info[i][D_FLAGS] & DOOR_CLOSEKEY))
00419                                 door_status[dkey]=-2; // Abschliessbar, aber dazu schluessel unnoetig
00420                   else
00421                                 door_status[dkey]=-1;
00422                 }
00423                 init_doors();
00424                 write("Du schliesst "+ob->name(WEN)+
00425                                   ((string)(abg?" ab":""))+".\n");
00426                 say(capitalize(ob->name(WER))+" wird von "+this_player()->name(WEM)+
00427                                 ((string)(abg?" ab":" "))+"geschlossen.\n");
00428                 door_message_other(source,dest," wird von der anderen Seite "+
00429                                                                                    ((string)(abg?"ab":""))+"geschlossen.");
00430     return 1;
00431   }
00432   return 0;
00433 }

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

void SetDoorStatus ( string  dest,
int  x 
)

Definiert in Zeile 32 der Datei doormaster.c.

Benutzt dkey, door_status und env().

00032                                        {
00033   string source,dkey;
00034   object env;
00035 
00036   if (!dest) return;
00037   if (!objectp(env=previous_object())) return;
00038   source=object_name(env);
00039   dkey=((string)((source<dest)?(source+":"+dest):(dest+":"+source)));
00040   door_status[dkey]=x;
00041 }

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

string special_detail_doors ( string  key  ) 

Definiert in Zeile 434 der Datei doormaster.c.

Benutzt D_DEST, D_IDS, D_LONG, dest(), dkey, door_status, env(), i, info und P_DOOR_INFOS.

00434                                        {
00435   object env;
00436   mixed *info;
00437   mapping dl;
00438   int i, st;
00439   string source, dest, dkey;
00440 
00441   if(!objectp(env=previous_object()))return 0;
00442   if(!pointerp(info=env->QueryProp(P_DOOR_INFOS)))return 0;
00443   source=object_name(env);
00444 
00445   for(i=sizeof(info)-1;i>=0;i--){
00446     if(!mappingp(info[i]))continue;
00447     if(member(info[i][D_IDS],key)<0)continue;
00448     if(stringp(info[i][D_LONG]))return info[i][D_LONG];
00449     if(!mappingp(info[i][D_LONG]))continue;
00450     dl=info[i][D_LONG];
00451     dest=info[i][D_DEST];
00452     dkey=((string)((source<dest)?(source+":"+dest):(dest+":"+source)));
00453     st=door_status[dkey];
00454     if((st==-2) && !dl[-2])st=-1; /* Falls keine eigene Beschreibung
00455                                    * fuer abgeschlossene Tuer vorhanden */
00456     return dl[st];
00457   }
00458   return 0;
00459 }

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

Variablen-Dokumentation

private mapping door_status

Definiert in Zeile 13 der Datei doormaster.c.

Wird benutzt von create(), go_door(), init_doors(), look_doors(), NewDoor(), oeffnen(), QueryAllDoors(), QueryDoorStatus(), reset_doors(), schliessen(), SetDoorStatus() und special_detail_doors().

private int id_zaehler

Definiert in Zeile 14 der Datei doormaster.c.

Wird benutzt von create() und NewDoor().

inherit std thing

Definiert in Zeile 9 der Datei doormaster.c.

Erzeugt am Thu Jun 3 14:39:36 2010 für MorgenGrauen Mudlib von  doxygen 1.6.3