pathd.c-Dateireferenz

#include <wizlevels.h>
#include <player.h>
#include <properties.h>
#include <rooms.h>
#include <moving.h>

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

gehe zum Quellcode dieser Datei

Makrodefinitionen
#define	LOGNAME   "PATHD"
#define	SAVEFILE   "/p/daemon/save/pathd"
#define	DEBUG
#define	NEEDED   10
#define	TIMEOUT_NEW   604800
#define	TIMEOUT_OLD   2592000
#define	NORMAL   0
#define	SPECIAL   1
#define	COMMAND   2
#define	COST_EXITS   ({ 1, 10, 100 })
#define	COST_MANY   3
#define	COST_FEW   5
#define	COST_ONE   10
#define	DBG(x)
#define	LOG(x)   log_file( "PATHD", (x), 100000 );
#define	ALLOWED   ({"zook","vanion","rumata","zesstra"})
#define	MATCH(x, y)   (sizeof(regexp(x,y)))
Funktionen
public void	create ()
public void	add_paths (string *connections)
public int	search_for_path (string from, string to)
public varargs void	show_pathmap (string path)
public varargs int	show_statistic (int verbose, int silent)
public int	change_pathmap (string pfad, mixed *verbindungen)
public mapping	get_pathmap ()
public void	reset ()
public varargs int	remove (int silent)
public varargs int	query_prevent_shadow (object ob)
static int	insert_paths (mixed *path)
static mixed *	format_paths (string path)
static void	_search (string fname, string start)
private string	_get_prefix (string path)
private void	_add_deadend (string fname, string sackgasse)
private int	_is_deadend (string fname, string room)
private void	_rate_path (string fname, string *path, int *idx)
private int	_connection_okay (string fname, mixed *connection, int idx, string from)
static void	cleanup_data (string *names, int idx)
public mapping	get_rooms ()
Variablen
mapping	pathmap
static mapping	searchlist
static int	time_to_clean_up
static int	rooms_checked
static int	conns_checked

---

Makro-Dokumentation

#define ALLOWED   ({"zook","vanion","rumata","zesstra"})

Definiert in Zeile 241 der Datei pathd.c.

#define COMMAND   2

Definiert in Zeile 31 der Datei pathd.c.

Wird benutzt von format_paths() und udp_channel().

#define COST_EXITS   ({ 1, 10, 100 })

Definiert in Zeile 34 der Datei pathd.c.

Wird benutzt von _rate_path().

#define COST_FEW   5

Definiert in Zeile 36 der Datei pathd.c.

Wird benutzt von _rate_path().

#define COST_MANY   3

Definiert in Zeile 35 der Datei pathd.c.

Wird benutzt von _rate_path().

#define COST_ONE   10

Definiert in Zeile 37 der Datei pathd.c.

Wird benutzt von _rate_path().

#define DBG

(

x

)

Definiert in Zeile 43 der Datei pathd.c.

Wird benutzt von _connection_okay(), _rate_path(), _search(), do_update(), RemoveTmpProp() und SetTmpProp().

#define DEBUG

Definiert in Zeile 21 der Datei pathd.c.

#define LOG

(

x

)

log_file( "PATHD", (x), 100000 );

Definiert in Zeile 46 der Datei pathd.c.

#define LOGNAME   "PATHD"

Definiert in Zeile 19 der Datei pathd.c.

#define MATCH	(	x,
		y		)	(sizeof(regexp(x,y)))

Definiert in Zeile 242 der Datei pathd.c.

Wird benutzt von get_pathmap().

#define NEEDED   10

Definiert in Zeile 24 der Datei pathd.c.

Wird benutzt von insert_paths().

#define NORMAL   0

Definiert in Zeile 29 der Datei pathd.c.

Wird benutzt von format_paths() und x_long().

#define SAVEFILE   "/p/daemon/save/pathd"

Definiert in Zeile 20 der Datei pathd.c.

#define SPECIAL   1

Definiert in Zeile 30 der Datei pathd.c.

Wird benutzt von format_paths().

#define TIMEOUT_NEW   604800

Definiert in Zeile 25 der Datei pathd.c.

Wird benutzt von cleanup_data().

#define TIMEOUT_OLD   2592000

Definiert in Zeile 26 der Datei pathd.c.

Wird benutzt von cleanup_data().

---

Dokumentation der Funktionen

private void _add_deadend	(	string	fname,
		string	sackgasse
	)

Definiert in Zeile 560 der Datei pathd.c.

Benutzt searchlist.

Wird benutzt von _search().

{
    if ( sizeof(searchlist[fname, 8]) < 9999 )
        searchlist[fname, 8] += ({sackgasse});
    else if ( sizeof(searchlist[fname, 9]) < 9999 )
        searchlist[fname, 9] += ({sackgasse});
    else
        searchlist[fname, 10] += ({sackgasse});
}

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

private int _connection_okay	(	string	fname,
		mixed *	connection,
		int	idx,
		string	from
	)

Definiert in Zeile 634 der Datei pathd.c.

Benutzt _is_deadend(), DBG und searchlist.

Wird benutzt von _search().

{
    int i;

    // Eine Verbindung in eine (schon getestete) Sackgasse brauchen wir
    // nicht noch einmal zu testen.
    if ( _is_deadend(fname, connections[idx][0]) ){
        DBG( sprintf( "Raum %O ->| %O!", from, connections[idx][0] ) );
        return 0;
    }

    // Kann der Spieler diese Verbindung ueberhaupt nutzen (Seherlevel)?
    if ( pointerp(connections[idx][2][ searchlist[fname, 3] ]) &&
         !sizeof(connections[idx][2][ searchlist[fname, 3] ]) )
        return 0;

    // Ist der Spieler in der richtigen (Para-)Welt?
    if ( connections[idx][5] != searchlist[fname, 4] )
        return 0;

    // Wenn es zu einem Verb mehrere Zielraeume gibt, kann mit dem Ausgang
    // keine Route geplant werden.
    for ( i = sizeof(connections); i--; )
        if ( i != idx && connections[i][1] == connections[idx][1]
             && connections[i][5] == connections[idx][5] ){
            DBG( sprintf( "Mehrdeutiges Verb %O in Raum %O!",
                          connections[i][1], from ) );
            return 0;
        }
    
    return 1;
}

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

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

private string _get_prefix

(

string

path

)

Definiert in Zeile 541 der Datei pathd.c.

Wird benutzt von _rate_path(), _search(), change_pathmap(), insert_paths() und show_pathmap().

{
    string *tmp;

    tmp = explode( path, "/" );

    // Bei Raeumen unterhalb von /d/* wird /d/region/magiername benutzt
    if ( path[0..2] == "/d/" )
        return implode( tmp[0..3], "/" );
    // Ansonsten die ersten beiden Teilpfade, falls soviele vorhanden sind
    else if ( sizeof(tmp) < 4 )
        return implode( tmp[0..1], "/" );
    else
        return implode( tmp[0..2], "/" );
}

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

private int _is_deadend	(	string	fname,
		string	room
	)

Definiert in Zeile 572 der Datei pathd.c.

Benutzt searchlist.

Wird benutzt von _connection_okay().

{
    return sizeof( ({room}) & (searchlist[fname, 8] + searchlist[fname, 9]
                               + searchlist[fname, 10]) );
}

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

private void _rate_path	(	string	fname,
		string *	path,
		int *	idx
	)

Definiert in Zeile 580 der Datei pathd.c.

Benutzt _get_prefix(), COST_EXITS, COST_FEW, COST_MANY, COST_ONE, DBG, pathmap und searchlist.

Wird benutzt von _search().

{
    int cost, size, i, tmp;
    mixed buf;

    for ( i = 0, size = sizeof(path) - 1; i < size; i++ ){
        buf = pathmap[ _get_prefix(path[i]) ][ path[i] ][ idx[i] ];
        // Die Art des benutzten Ausgangs zaehlt hinein ...
        tmp = COST_EXITS[ buf[3] ];

        // ... sowie die Zahl der Benutzer (selten benutzte Ausgaenge koennten
        // Haken haben)
        switch ( pointerp(buf[2][ searchlist[fname, 3] ]) ?
                 sizeof(buf[2][ searchlist[fname, 3] ]) : -1 ){
        case 0:
            // Wenn den Ausgang noch keiner benutzt hat, ist das keine gueltige
            // Verbindung. Also schoen teuer machen.
            tmp = 100000;
            break;

        case 1..2:
            tmp *= COST_ONE;
            break;

        case 3..5:
            tmp *= COST_FEW;
            break;

        case 6..10:
            tmp *= COST_MANY;
            break;

        default:
            // -1 fuer viel benutzte Ausgaenge sowie alles andere bei Bugs ;^)
            break;
        }
        
        cost += tmp;
    }

    DBG( sprintf( "Route mit %O Raeumen gefunden, Kosten %O.",
                  sizeof(path), cost ) );
    
    // Bei Erfolg die Route sowie ihre Kosten speichern
    if ( cost < searchlist[fname, 7] ){
        DBG( "Die Route ist die bisher kuerzeste!" );
        searchlist[fname, 5] = path[0..];
        searchlist[fname, 6] = idx[0..];
        searchlist[fname, 7] = cost;
    }
}

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

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

static void _search	(	string	fname,
		string	start
	)			[static]

Definiert in Zeile 453 der Datei pathd.c.

Benutzt _add_deadend(), _connection_okay(), _get_prefix(), _rate_path(), call_out(), conns_checked, DBG, m_delete(), pathmap, rooms_checked und searchlist.

Wird benutzt von search_for_path().

{
    string from, to, *path;
    int lvl, *idx;
    mixed *tmp;

    from = start;
    path = searchlist[fname, 0];
    idx = searchlist[fname, 1];
    to = searchlist[fname, 2];
    lvl = searchlist[fname, 3];

    // Eigentlich macht man sowas mit einer handlichen kleinen eleganten
    // Rekursion. Leider begrenzt der Driver die maximale Rekursionstiefe
    // aber auf einen indiskutablen Wert. Deshalb bauen wir also eine
    // grosse lange haessliche Schleife ...
    do {
        if ( from == to )
            // Ist die gefundene Verbindung die kuerzeste?
            _rate_path( fname, path + ({ from }), idx );
        else if ( !sizeof(path & ({ from })) ){
            // Sofern wir keinen Kreis gelaufen sind, neuen Raum uebernehmen.
            DBG( sprintf( "Uebernehme Raum %O.", from ) );
            path += ({ from });
            idx += ({ -1 });
            rooms_checked++;
        }
        else
            DBG( sprintf( "In Raum %O war ich schon!", from ) );

        do {
            // So lange der aktuelle Raum keine noch nicht getesteten Ausgaenge
            // mehr hat, wieder einen Raum zurueck gehen.
            while ( sizeof(idx) && idx[<1] + 1 >=
                    sizeof(pathmap[ _get_prefix(path[<1]) ][ path[<1] ]) ){
                // Den Raum als "Sackgasse" markieren ...
                DBG( sprintf( "Markiere %O als Sackgasse.", path[<1] ) );
                _add_deadend( fname, path[<1] );
                // ... und einen Schritt zurueck gehen.
                path[<1..<1] = ({});
                idx[<1..<1] = ({});
            }

            // Den kleinsten noch nicht getesteten Ausgang nehmen.
            if ( sizeof(idx) ){
                tmp = pathmap[ _get_prefix(path[<1]) ][ path[<1] ];
                from = tmp[ ++idx[<1] ][0];
                DBG( sprintf( "Teste Verbindung nach %O.", from ) );
                conns_checked++;
            }
            
            // Das Spielchen geht so lange, bis wir einen 'gueltigen' Ausgang
            // gefunden haben.
         } while ( sizeof(idx) &&
                   !_connection_okay( fname, tmp, idx[<1], path[<1] ) );

        // Es wird so lange getestet, bis es keinen Raum mehr gibt, zu dem
        // man zurueckgehen koennte.
    } while ( sizeof(idx) && get_eval_cost() > 600000 );

    // Ist eigentlich nicht notwendig, da wir mit Referenzen arbeiten.
    // Aber sicher ist sicher. ;^)
    searchlist[fname, 0] = path;
    searchlist[fname, 1] = idx;

    // Erst, wenn wir saemtliche moeglichen Verbindungen durchgetestet haben,
    // sind wir fertig. Ansonsten sind nur die Evalticks ausgegangen.
    if ( sizeof(idx) ){
        DBG( sprintf( "Splitte bei %O Evalticks. Pfad hat momentan %O Raeume.",
                      get_eval_cost(), sizeof(path) ) );
        DBG( sprintf( "Getestete Raeume %O, Verbindungen %O, Sackgassen %O",
                      rooms_checked, conns_checked,
                      sizeof(searchlist[fname, 8] + searchlist[fname, 9]
                             + searchlist[fname, 10]) ) );
        call_out( "_search", 0, fname, from );
    }
    else {
        DBG( sprintf("Suche fertig! Gefundener Weg: %O, Kosten: %O\n",
                     searchlist[fname, 5], searchlist[fname, 7] ) );

        efun::m_delete( searchlist, fname );
    }
}

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

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

public void add_paths

(

string *

connections

)

Definiert in Zeile 96 der Datei pathd.c.

{
    mixed *paths;
    
    // keinen Aufruf per Hand bitte
    if ( !previous_object() || !this_player()
         || this_interactive() && getuid(this_interactive()) != "tiamak"
         || file_size( "/std/shells" +
                       explode( object_name(previous_object()), ":" )[0]
                       + ".c" ) < 1 )
        return;

    // Doppelte Wege rauswerfen
    paths = m_indices( mkmapping(connections) );
    // Daten zusammensuchen
    paths = map( paths, #'format_paths/*'*/ ) - ({0});
    // Neue Raeume eintragen
    filter( paths, #'insert_paths/*'*/ );
}

public int change_pathmap	(	string	pfad,
		mixed *	verbindungen
	)

Definiert in Zeile 219 der Datei pathd.c.

Benutzt _get_prefix() und pathmap.

{
    if ( !this_interactive() || getuid(this_interactive()) != "tiamak"
         || !previous_object() || getuid(previous_object()) != "tiamak" )
        return -1;

    if ( mappingp(verbindungen) ){
        if ( !pathmap[_get_prefix(pfad)] )
            return 0;
        
        pathmap[_get_prefix(pfad)] = verbindungen;
    }
    else {
        if ( !pathmap[_get_prefix(pfad)][pfad] )
            return 0;
        
        pathmap[_get_prefix(pfad)][pfad] = verbindungen;
    }

    return 1;
}

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

static void cleanup_data	(	string *	names,
		int	idx
	)			[static]

Definiert in Zeile 670 der Datei pathd.c.

Benutzt call_out(), dtime(), LOG, m_delete(), pathmap, show_statistic(), time_to_clean_up, TIMEOUT_NEW und TIMEOUT_OLD.

{
    int size, i, j, k, verbindungen;
    string *rooms;
    mixed *paths;

    size = sizeof(names);

    // Ein bisserl mitloggen, damit wir Schwachstellen im System auch finden.
    if ( !idx ){
        LOG( sprintf("=== %s: Starte cleanup_data(): %O Gebiete, %O Raeume "
                     + "...\n", dtime(time())[5..], size,
                     show_statistic(1, 1) ) );
    }
    else {
        LOG( sprintf("%s: Setze cleanup_data() fort.\n", dtime(time()))[5..] );
    }

    // Brav gesplittet, damit es kein Lag gibt.
    // Die Grenze ist recht hoch angesetzt, da immer gleich komplette
    // Teilbaeume aufgeraeumt werden.
    while ( get_eval_cost() > 600000 && idx < size ){
        rooms = sort_array( m_indices(pathmap[names[idx]]), #'</*'*/ );

        for ( i = sizeof(rooms); i--; ){
            paths = pathmap[names[idx]][rooms[i]];
            verbindungen = sizeof(paths);

            for ( j = verbindungen; j--; ){
                for ( k = 0; k < 2; k++ ){
                    // Diese Verbindung hat noch keiner genutzt bisher
                    if ( !paths[j][4][k] )
                        continue;
                    
                    if ( paths[j][2][k] == -1 // 'bekanntes' Gebiet
                         && time() - paths[j][4][k] > TIMEOUT_OLD ){
                        // LOG( sprintf("*** Loesche alte "
                        //             + (k ? "Seher" : "Spieler")
                        //             + "-Verbindung %O.\n", paths[j]) );
                        paths[j][2][k] = ({});
                        paths[j][4][k] = 0;
                    }
                    else if ( paths[j][2][k] != -1 // 'neues' Gebiet
                              && time() - paths[j][4][k] > TIMEOUT_NEW ){
                        paths[j][2][k] = ({});
                        paths[j][4][k] = 0;
                    }
                }
                
                // Wenn eine Verbindung weder von Spielern noch von Sehern
                // benutzt wurde in letzter Zeit, Verbindung ganz loeschen.
                if ( !paths[j][4][0] && !paths[j][4][1] ){
                    paths[j..j] = ({});
                    verbindungen--;
                }
            }

            // Ein Raum ohne Verbindungen frisst nur Platz in der Datenbank
            if ( !verbindungen ){
                // LOG( sprintf("*** Loesche kompletten Raum %O\n", rooms[i]) );
                efun::m_delete( pathmap[names[idx]], rooms[i] );
            }
            else
                pathmap[names[idx]][rooms[i]] = paths;
        }

        idx++;
    }

    if ( idx >= size ){
        time_to_clean_up = 95; // in ~24h wieder aufräumen
        LOG( sprintf("=== %s: Beende cleanup_data()! Uebrig: %O Raeume.\n",
                     dtime(time())[5..], show_statistic(1, 1) ) );
    }
    else {
        call_out( "cleanup_data", 20, names, idx );
        LOG( sprintf("%s: WARTE 20s bei Evalcost %O\n",
                     dtime(time())[5..], get_eval_cost()) );
    }
}

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

public void create

(

)

Definiert in Zeile 76 der Datei pathd.c.

Benutzt destruct(), pathmap, restore_object(), SAVEFILE und searchlist.

{
    // es darf nur einen daemon geben
    if ( clonep(this_object()) ){
        destruct(this_object());
        return;
    }
    
    // wir muessen das Savefile schreiben duerfen
    seteuid(getuid());
    
    if ( !restore_object(SAVEFILE) ){
        pathmap = ([]);
    }

    searchlist = ([]);
}

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

static mixed * format_paths

(

string

path

)

[static]

Definiert in Zeile 309 der Datei pathd.c.

Benutzt buf, COMMAND, crypt, exits, IS_LEARNER, M_GO, M_NOCHECK, M_TPORT, NORMAL, ob(), P_EXITS, P_IDS, P_SPECIAL_EXITS, P_TESTPLAYER, Query(), query_wiz_level() und SPECIAL.

{
    string tmp, uid, *buf;
    object ob;
    mapping exits;
    int art;
    
    // Magier und Testspieler koennen auch in nicht angeschlossene Gebiete
    // und werden deshalb nicht beachtet.
    if ( IS_LEARNER(previous_object(1)) ||
         IS_LEARNER(lower_case( previous_object(1)->Query(P_TESTPLAYER)||"" )) )
        return 0;

    // Alle Daten kommen als ein String mit '#' als Trenner an.
    // Muster: Startraum#Zielraum#Verb#Methode der Bewegung#Parawelt
    buf = explode( path, "#" );
    // Falls im Verb auch # vorkam (unwahrscheinlich, aber moeglich):
    buf[2..<3] = ({ implode( buf[2..<3], "#" ) });

    // Beim Verb endstaendige Leerzeichen sowie " 0" (kommt bei
    // _unparsed_args(), wenn keine weiteren Argumente vorhanden waren)
    // abschneiden.
    tmp = buf[2];
    if ( tmp[<1] == ' ' )
        tmp = tmp[0..<2];
    else if ( tmp[<2..] == " 0" )
        tmp = tmp[0..<3];

    // Wenn der Zielraum als String angegeben wurde, kann der fuehrende
    // Slash fehlen!
    if ( buf[1][0] != '/' )
        buf[1] = "/" + buf[1];

    // Zum Abfragen der zusaetzlichen Daten brauchen wir das Objekt selber
    if ( !objectp(ob = find_object(buf[0])) ){
        catch( load_object( buf[0]);publish );
        ob = find_object(buf[0]);
    }

    // Kleiner Hack - bei Transportern etc. ist 'ob' die nicht initialisierte
    // Blueprint. Jede Abfrage von P_EXITS wuerde nett auf -Debug scrollen.
    // Da P_IDS im create() auf jeden Fall auf ein Array gesetzt wird,
    // missbrauche ich das hier als "Ist initialisiert"-Flag.
    if ( !objectp(ob) || !ob->QueryProp(P_IDS) )
        return 0;

    // Art des Ausgangs feststellen. 
    if ( mappingp(exits = ob->QueryProp(P_EXITS)) && exits[tmp] )
        art = NORMAL;   // "normaler" Ausgang
    else if ( mappingp(exits = ob->QueryProp(P_SPECIAL_EXITS)) && exits[tmp] )
        art = SPECIAL;  // SpecialExit
    else {
        // Kommandos, die einen in einen anderen Raum bringen
        art = (int) buf[3];

        // Es zaehlen aber nur Bewegungen, die halbwegs "normal" aussehen
        if ( art & (M_TPORT | M_NOCHECK) || !(art & M_GO) )
            return 0;
        else
            art = COMMAND;
    }

    // Die UID der Spieler/Seher wird verschluesselt.
    // Schliesslich brauchen wir sie nur fuer statistische Zwecke und nicht,
    // um Bewegungsprofile zu erstellen.
    uid = getuid(previous_object(1));
    uid = crypt( uid, "w3" );

    // Start, Ziel, Verb, Wizlevel(TP), UID(TP), Art des Ausgangs, Parawelt
    return ({ buf[0], buf[1], tmp, query_wiz_level(previous_object(1)) ? 1 : 0,
                  uid, art, (int) buf[4] });
}

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

public mapping get_pathmap

(

)

Definiert in Zeile 245 der Datei pathd.c.

Benutzt ALLOWED, MATCH und pathmap.

{
  if ( !this_interactive() || !MATCH(ALLOWED,getuid(this_interactive()))
       || !previous_object() || !MATCH(ALLOWED,getuid(previous_object())))
        return ([]);

    return pathmap;
}

public mapping get_rooms

(

)

Definiert in Zeile 259 der Datei pathd.c.

Benutzt i und pathmap.

{
  string *submaps;
  mapping roommap;
  int i;

  roommap=([]);

  submaps=m_indices(pathmap);

  i=sizeof(submaps);
  
  while (i--)
    if (sizeof(m_indices(pathmap[submaps[i]])))
                    roommap[submaps[i]]=m_indices(pathmap[submaps[i]]);
  
  return roommap;                                   
}

static int insert_paths

(

mixed *

path

)

[static]

Definiert in Zeile 384 der Datei pathd.c.

Benutzt _get_prefix(), i, NEEDED und pathmap.

{
    string pre;
    mixed *conn, *tmp, *tme;
    int i;

    pre = _get_prefix(path[0]);

    // Falls noch gar kein Eintrag existiert, neu initialisieren
    if ( !mappingp(pathmap[pre]) )
        pathmap[pre] = ([]);

    if ( !pointerp(pathmap[pre][path[0]]) )
        pathmap[pre][path[0]] = ({});

    // Aufbau von 'path':
    // ({ Start, Ziel, Verb, Wizlevel(TP), UID(TP), Art des Ausgangs, Para })
    // Aufbau von 'conn':
    // ({ Ziel, Verb, ({ Spieler-UIDs, Seher-UIDs }), Art des Ausgangs,
    //   ({ Letztes Betreten durch Spieler, durch Seher }), Parawelt })
    
    // Alle Verbindungen des Raumes durchgehen
    conn = pathmap[pre][path[0]];
    for ( i = sizeof(conn); i--; )
        // Wenn Zielraum, Verb und Parawelt passen ...
        if ( conn[i][0] == path[1] && conn[i][1] == path[2]
             && conn[i][5] == path[6] ){

            // Wenn schon genug Leute diese Verbindung genutzt haben, einfach
            // nur die Zeit der letzten Benutzung aktualisieren.
            if ( conn[i][2][path[3]] == -1 ){
                conn[i][4][path[3]] = time();
                break;
            }
            // Ansonsten die (neue?) UID hinzufuegen und die Zeit aktualisieren.
            else {
                conn[i][2][path[3]] =
                    conn[i][2][path[3]] - ({ path[4] }) + ({ path[4] });
                if ( sizeof(conn[i][2][path[3]]) >= NEEDED )
                    conn[i][2][path[3]] = -1;

                conn[i][4][path[3]] = time();
                break;
            }
        }

    // Falls keine Verbindung gepasst hat, eine neue erzeugen.
    if ( i < 0 ) {
        tmp = ({ ({}), ({}) });
        tmp[path[3]] = ({ path[4] });
        tme = ({ 0, 0 });
        tme[path[3]] = time();

        // Aufbau siehe oben
        conn += ({ ({ path[1], path[2], tmp, path[5], tme, path[6] }) });
    }

    // Ist eigentlich notwendig, da wir mit Referenzen arbeiten.
    // Aber sicher ist sicher. ;^)
    pathmap[pre][path[0]] = conn;

    // Ob 0 oder 1 ist eigentlich total egal, da das Ergebnis-Array sowieso
    // verworfen wird.
    return 0;
}

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

public varargs int query_prevent_shadow

(

object

ob

)

Definiert in Zeile 302 der Datei pathd.c.

{
    return 1;
}

public varargs int remove

(

int

silent

)

Definiert in Zeile 291 der Datei pathd.c.

Benutzt destruct(), save_object() und SAVEFILE.

{
    // Vor dem Entfernen noch schnell die Datenbank sichern
    save_object(SAVEFILE);
    destruct(this_object());

    return 1;
}

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

public void reset

(

void

)

Definiert in Zeile 278 der Datei pathd.c.

Benutzt call_out(), pathmap, save_object(), SAVEFILE, set_next_reset() und time_to_clean_up.

{
    if ( time_to_clean_up <= 0 )
        // Einmal pro Tag Reset zum Aufraeumen der Datenbank
        call_out( "cleanup_data", 5,
                  sort_array(m_indices(pathmap), #'</*'*/), 0 );

    save_object(SAVEFILE);
    time_to_clean_up--;
    set_next_reset(900);
}

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

public int search_for_path	(	string	from,
		string	to
	)

Definiert in Zeile 118 der Datei pathd.c.

Benutzt _search(), conns_checked, P_PARA, query_wiz_level(), rooms_checked und searchlist.

{
    // Es laeuft schon eine Suche fuer diesen Spieler
    if ( !this_interactive() || searchlist[getuid(this_interactive())] )
        return -1;

    // UID, Raeume, Ausgangsnummern, Zielraum, Wizlevel, Parawelt,
    // kuerzeste Verbindung, Ausgangsnummern fuer die Verbindung,
    // Kosten der Verbindung, Sackgassen (drei Arrays wegen der 10k-Grenze)
    searchlist += ([ getuid(this_interactive()): ({ }); ({ }); to;
                     (query_wiz_level(this_interactive()) ? 1 : 0);
                     this_interactive()->QueryProp(P_PARA);
                     ({}); ({}); 100000000; ({}); ({}); ({}) ]);

    // Die eigentliche Suche starten
    rooms_checked = 0;
    conns_checked = 0;
    _search( getuid(this_interactive()), from );
    
    return 1;
}

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

public varargs void show_pathmap

(

string

path

)

Definiert in Zeile 145 der Datei pathd.c.

Benutzt _get_prefix() und pathmap.

{
    string pre;

    if ( path ){
        pre = _get_prefix(path);
    
        if ( pre == path )
            // Ganzen Teilbaum ausgeben
            printf( "Pathmap[%O]: %O\n", path, pathmap[path] );
        else
            // Nur Infos ueber einen Raum ausgeben
            printf( "Pathmap[%O]: %O\n", path,
                    pathmap[pre] ? pathmap[pre][path] : 0 );
    }
    else
        // Ohne Argument wird die gesamte Map ausgegeben.
        // Klappt aber eher nicht (mehr) wegen Buffer overflow. ;^)
        printf( "Pathmap: %O\n", pathmap );
}

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

public varargs int show_statistic	(	int	verbose,
		int	silent
	)

Definiert in Zeile 170 der Datei pathd.c.

Benutzt i, name und pathmap.

Wird benutzt von cleanup_data().

{
    int i, ges;
    string *ind, name;
    mapping m;

    if ( verbose ){ // Stur jeden Eintrag auflisten
        ind = sort_array( m_indices(pathmap), #'</*'*/ );
        for ( i = sizeof(ind); i--; ){
            if ( !silent )
                printf( "%-30s: %4d\n", ind[i], sizeof(pathmap[ind[i]]) );
            ges += sizeof(pathmap[ind[i]]);
        }
    }
    else {          // Regionen zusammenfassen
        ind = m_indices(pathmap);
        m = ([]);

        for ( i = sizeof(ind); i--; ){
            if ( ind[i][0..8] == "/players/" )
                // Alle Playerverzeichnisse zusammenfassen ...
                name = "/players";
            else
                // ... den Rest jeweils nach zwei Teilpfaden
                name = implode( explode( ind[i], "/" )[0..2], "/" );
            
            if ( !m[name] )
                m[name] = sizeof( pathmap[ind[i]] );
            else
                m[name] += sizeof( pathmap[ind[i]] );
        }

        ind = sort_array( m_indices(m), #'</*'*/ );
        for ( i = sizeof(ind); i--; ){
            if ( !silent )
                printf( "%-30s: %4d\n", ind[i], m[ind[i]] );
            ges += m[ind[i]];
        }
    }

    if ( !silent )
        printf( "\nGesamt: %d Raeume.\n", ges );

    return ges;
}

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

---

Variablen-Dokumentation

int conns_checked [static]

Definiert in Zeile 51 der Datei pathd.c.

Wird benutzt von _search() und search_for_path().

mapping pathmap

Definiert in Zeile 49 der Datei pathd.c.

Wird benutzt von _rate_path(), _search(), call_out(), change_pathmap(), cleanup_data(), create(), get_pathmap(), get_rooms(), insert_paths(), reset(), show_pathmap() und show_statistic().

int rooms_checked [static]

Definiert in Zeile 51 der Datei pathd.c.

Wird benutzt von _search() und search_for_path().

mapping searchlist [static]

Definiert in Zeile 50 der Datei pathd.c.

Wird benutzt von _add_deadend(), _connection_okay(), _is_deadend(), _rate_path(), _search(), create() und search_for_path().

int time_to_clean_up [static]

Definiert in Zeile 51 der Datei pathd.c.

Wird benutzt von cleanup_data() und reset().