exits.c-Dateireferenz

#include <sys_debug.h>
#include <config.h>
#include <thing/properties.h>
#include <moving.h>
#include <defines.h>
#include <daemon.h>
#include <doorroom.h>
#include <routingd.h>
#include <exploration.h>
#include <room/exits.h>

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

gehe zum Quellcode dieser Datei

Makrodefinitionen
#define	NEED_PROTOTYPES
#define	NUMBERS   ({ "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht" })
Funktionen
static mapping	rescueExit ()
static mapping	_set_exits (mapping map_ldfied)
static mapping	_query_exits ()
static int	_set_special_exits (mapping map_ldfied)
static mapping	_query_special_exits ()
void	reset ()
protected void	create ()
protected void	create_super ()
void	AddExit (mixed cmd, mixed room)
void	RemoveExit (mixed cmd)
void	AddSpecialExit (mixed cmd, mixed functionname)
void	RemoveSpecialExit (mixed cmd)
varargs string	GetExits (object viewer)
void	init ()
int	_normalfunction ()
static string	_MakePath (string str)

---

Makro-Dokumentation

#define NEED_PROTOTYPES

Definiert in Zeile 24 der Datei exits.c.

#define NUMBERS   ({ "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht" })

Definiert in Zeile 38 der Datei exits.c.

Wird benutzt von GetExits().

---

Dokumentation der Funktionen

static string _MakePath

(

string

str

)

[static]

Definiert in Zeile 292 der Datei exits.c.

Benutzt MASTER und REAL_UID.

Wird benutzt von AddExit().

{
  string *comp;

  comp = explode( object_name(this_object()), "/" ) - ({""});
  
   switch( str[0] ){
   case '.':
       str = "/" + implode( comp[0..<2], "/" ) + "/" + str;
       break;
       
   case '~':
       str = "/" + comp[0] + "/" + (comp[0] == "d" ? comp[1] + "/" : "")
           +REAL_UID(this_object()) + str[1..];
       break;
   }
   
   return MASTER->_get_path( str, getuid(this_object()) );
}

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

int _normalfunction

(

)

Definiert in Zeile 246 der Datei exits.c.

Benutzt EP_EXIT, GiveEP(), M_GO, message, P_EXITS und Query().

{
    string verb, destroom;
    mixed message;
    int ret;

    verb = query_verb();
    destroom = (Query(P_EXITS) || ([]))[verb]; // hier kein rescueExit !!

    if ( !destroom )
        return 0;
    
    if ( closurep(destroom) ){
        ret = funcall( destroom, verb );
        
        if (ret)
            GiveEP( EP_EXIT, verb );
        
        return ret;
    }
    
    message = explode( destroom, "#" );
    
    if ( sizeof(message) == 2 ){
        destroom = message[1];
        message = message[0];
    } 
    else
        if( member( ({ "sueden", "suedwesten", "westen",
                       "nordwesten", "norden", "nordosten", "osten",
                       "suedosten" }), verb ) != -1 )
            message = "nach " + capitalize(verb);
        else if ( member( ({ "oben", "unten" }), verb ) != -1 )
            message = "nach " + verb;
        else
            message = verb;
    
    ret = this_player()->move( destroom, M_GO, message );
    
    if (ret)
        GiveEP( EP_EXIT, verb );
    
    return ret;
}

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

static mapping _query_exits

(

)

[static]

Definiert in Zeile 61 der Datei exits.c.

Benutzt DOOR_MASTER, exits, i, m_delete(), P_DOOR_INFOS, P_EXITS, Query(), QueryProp() und rescueExit().

{
    mapping exits;
    mixed key;
    int i;

    if( (!previous_object() || object_name(previous_object()) != DOOR_MASTER)
        && QueryProp(P_DOOR_INFOS) )
        call_other( DOOR_MASTER, "init_doors" );
    
    key = m_indices( exits = (Query(P_EXITS) || rescueExit()) );
    
    for ( i = sizeof(key); i--; )
        if( !stringp(exits[key[i]]) )
            exits = m_delete( exits, key[i] );
    
    return exits;
}

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

static mapping _query_special_exits

(

)

[static]

Definiert in Zeile 87 der Datei exits.c.

Benutzt exits, i, m_delete(), P_EXITS, Query() und rescueExit().

{
    mapping exits;
    mixed key;
    int i;

    key = m_indices( exits = (Query(P_EXITS) || rescueExit()) );
    
    for ( i = sizeof(key); i--; )
        if( stringp(exits[key[i]]) )
            exits = m_delete( exits, key[i] );
    
    return exits;
}

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

static mapping _set_exits

(

mapping

map_ldfied

)

[static]

Definiert in Zeile 53 der Datei exits.c.

Benutzt P_EXITS und Set().

{
    if( mappingp(map_ldfied) )
        return Set( P_EXITS, map_ldfied );
    return 0;
}

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

static int _set_special_exits

(

mapping

map_ldfied

)

[static]

Definiert in Zeile 81 der Datei exits.c.

{
    return -1;
}

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 107 der Datei exits.c.

Benutzt P_EXITS und SetProp().

{
  SetProp( P_EXITS, ([]) );
}

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

protected void create_super

(

)

Definiert in Zeile 112 der Datei exits.c.

Benutzt set_next_reset().

                              {
  set_next_reset(-1);
}

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

varargs string GetExits

(

object

viewer

)

Definiert in Zeile 197 der Datei exits.c.

Benutzt break_string(), DOOR_MASTER, exits, i, NUMBERS, P_DOOR_INFOS, P_EXITS, P_HIDE_EXITS, Query(), QueryProp() und rescueExit().

{
    int n, i;
    string exits, *indices, *hidden;
  
    if ( QueryProp(P_DOOR_INFOS) )
        call_other( DOOR_MASTER, "init_doors" );

    indices = m_indices( Query(P_EXITS) || rescueExit() );
    
    if ( pointerp(hidden = QueryProp(P_HIDE_EXITS)) )
        indices -= hidden;
  
    n = sizeof( indices );
    
    switch (n){
    case 0:
        return "Es gibt keine sichtbaren Ausgaenge.\n";
        
    case 1:
        return "Es gibt einen sichtbaren Ausgang: " + indices[0] + ".\n";
        
    case 2: case 3: case 4: case 5: case 6: case 7: case 8:
        exits = "Es gibt " + NUMBERS[n-2] + " sichtbare Ausgaenge: ";
        break;
        
    default:
        exits = "Es gibt viele sichtbare Ausgaenge: ";
    }
    
    for ( i = 0; i < n-2; i++ )
        exits += indices[i] + ", ";
    
    exits += indices[n-2] + " und " + indices[n-1] + ".";
    
    return break_string( exits, 78 );
}

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

void init

(

)

Definiert in Zeile 238 der Datei exits.c.

{
    if ( environment(this_player()) == this_object() )
        add_action( "_normalfunction", "", 1 );
}

void RemoveExit

(

mixed

cmd

)

Definiert in Zeile 153 der Datei exits.c.

Benutzt i, m_delete(), P_EXITS, Query(), rescueExit(), Set() und SetProp().

Wird benutzt von RemoveSpecialExit().

{
    mapping exita;
    int i;
  
    if ( !cmd ) {
        SetProp(P_EXITS, ([]) );
        return;
    }

    if ( !pointerp(cmd) )
        cmd = ({ cmd });

    exita = Query(P_EXITS) || rescueExit();
    
    for( i = sizeof(cmd); i--; )
        exita = m_delete( exita, cmd[i] );
  
    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 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:

static mapping rescueExit

(

)

[static]

Definiert in Zeile 43 der Datei exits.c.

Wird benutzt von _query_exits(), _query_special_exits(), AddExit(), GetExits() und RemoveExit().

{
  catch(raise_error(sprintf(
                  "room/exits.c: Forgotten ::create()? "
                  "P_EXITS in %O is 0!\n", this_object()));publish); 

  return ([]);
}

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

void reset

(

void

)

Definiert in Zeile 103 der Datei exits.c.

{}