items.c-Dateireferenz

#include <sys_debug.h>
#include <thing/properties.h>
#include <rooms.h>
#include <container.h>
#include <defines.h>
#include <config.h>
#include <moving.h>
#include <daemon.h>
Include-Abhängigkeitsdiagramm für items.c:

gehe zum Quellcode dieser Datei

Makrodefinitionen

#define NEED_PROTOTYPES

Funktionen

protected void create ()
protected void create_super ()
private object removeable_ob (object ob)
private int _sortfunc (mixed *a, mixed *b)
protected varargs void remove_multiple (int limit, mixed fun)
public varargs object AddItem (mixed filename, int refresh, mixed props)
private void ri_rem_ob (object ob)
private int ri_filter (mixed *ritem, mixed file)
public void RemoveItem (mixed filename)
private mixed _do_refresh (mixed item)
void reset ()

Makro-Dokumentation

#define NEED_PROTOTYPES

Definiert in Zeile 32 der Datei items.c.

Dokumentation der Funktionen

private mixed _do_refresh ( mixed  item  ) 

Definiert in Zeile 223 der Datei items.c.

Benutzt M_GO, M_NO_ATTACK, M_NOCHECK, ME, REFRESH_DESTRUCT, REFRESH_MOVE_HOME, REFRESH_NONE, REFRESH_REMOVE, RITEM_FILE, RITEM_OBJECT, RITEM_PROPS und RITEM_REFRESH.

00224 {
00225     string file;
00226     object ob;
00227 
00228     if ( !pointerp(item) || item[RITEM_REFRESH] == REFRESH_NONE )
00229         return item;
00230 
00231     if ( pointerp(item[RITEM_FILE]) ) 
00232         file = item[RITEM_FILE][random( sizeof(item[RITEM_FILE]) )];
00233     else
00234         file = item[RITEM_FILE];
00235 
00236     switch( item[RITEM_REFRESH] ){
00237     case REFRESH_MOVE_HOME:
00238         if ( objectp(item[RITEM_OBJECT]) &&
00239              environment(item[RITEM_OBJECT]) != ME ) {
00240             item[RITEM_OBJECT]->move( ME, M_GO|M_NO_ATTACK );
00241             break;
00242         }
00243         
00244     // fall through
00245     case REFRESH_DESTRUCT:
00246         if ( objectp(item[RITEM_OBJECT]) ) 
00247             break; // else FALL THROUGH
00248         
00249     case REFRESH_REMOVE:
00250         if ( objectp(item[RITEM_OBJECT]) &&
00251              environment(item[RITEM_OBJECT]) == ME )
00252             break; // else FALL THROUGH
00253         
00254     default:
00255         if ( sizeof(item) > RITEM_PROPS && item[RITEM_PROPS] == 1 ) {
00256             ob = load_object(file);
00257         }
00258         else
00259             ob = clone_object(file);
00260 
00261         ob->move( ME, M_NOCHECK|M_NO_ATTACK );
00262         break;
00263     }
00264     
00265     if ( ob ){
00266         item[RITEM_OBJECT] = ob;
00267         
00268         if ( sizeof(item) > RITEM_PROPS && mappingp(item[RITEM_PROPS]) )
00269             walk_mapping( item[RITEM_PROPS], symbol_function( "SetProp", ob ) );
00270     }
00271     
00272     return item;
00273 }

private int _sortfunc ( mixed *  a,
mixed *  b 
)

Definiert in Zeile 65 der Datei items.c.

Wird benutzt von remove_multiple().

00066 {
00067     return a[0] < b[0];
00068 }

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

public varargs object AddItem ( mixed  filename,
int  refresh,
mixed  props 
)

Definiert in Zeile 117 der Datei items.c.

Benutzt file(), i, M_NO_ATTACK, M_NOCHECK, master, ob(), P_ITEMS, QueryProp() und SetProp().

Wird benutzt von create().

00118 {
00119     string file;
00120     object ob;
00121     int i;
00122 
00123     if( pointerp(filename) ) {
00124         for( i = sizeof(filename); i--; )
00125             filename[i] = (string)master()->_get_path( filename[i], "?" );
00126         
00127         file = filename[random( sizeof(filename) )];
00128     }
00129     else 
00130         file = filename = (string)master()->_get_path( filename, "?" );
00131     
00132     if ( props == 1 )
00133         catch(ob = load_object( file); publish);
00134     else
00135                 catch(ob = clone_object(file); publish);
00136     
00137     if (objectp(ob)) {
00138       ob->move( this_object(), M_NOCHECK|M_NO_ATTACK );
00139       // mit Absicht keine Pruefung aufs Move, wenns nicht geht, solls 2s
00140       // spaeter auf der Ebene buggen, weil praktisch niemand im create() das
00141       // Ergebnis vom AddItem() prueft.
00142     }
00143 
00144     // In P_ITEMS vermerken, es sei denn, REFRESH_NONE ist gegeben, in dem
00145     // Fall ist die Speicherung voellig unnoetig.
00146     // TODO: Pruefen, ob das wirklich problemlos geht. Bis dahin werden auch
00147     // TODO::REFRESH_NONE-Items vermerkt. (s. clean_up() in /std/room.c)
00148     //if (!(refresh & REFRESH_NONE)) {
00149       SetProp( P_ITEMS, QueryProp(P_ITEMS) +
00150              ({ ({ ob,        // RITEM_OBJECT
00151                    filename,  // RITEM_FILE
00152                    refresh    // RITEM_REFRESH
00153                        }) +
00154                     ((mappingp(props) || props == 1) ? ({ props }) : ({})) }) );
00155     //}
00156 
00157     if ( ob && mappingp(props) ) 
00158         walk_mapping( props, symbol_function( "SetProp", ob ) );
00159     
00160     return ob;
00161 }

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 43 der Datei items.c.

Benutzt F_MODE_AS, OBJECTD, P_ITEMS, SECURED und Set().

00044 { 
00045     Set( P_ITEMS, ({}) );
00046     Set( P_ITEMS, SECURED, F_MODE_AS );
00047     
00048     OBJECTD->QueryObject();  // querying general objects
00049 }

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

protected void create_super (  ) 

Definiert in Zeile 51 der Datei items.c.

Benutzt set_next_reset().

00051                               {
00052   set_next_reset(-1);
00053 }

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

protected varargs void remove_multiple ( int  limit,
mixed  fun 
)

Definiert in Zeile 71 der Datei items.c.

Benutzt _sortfunc() und destruct().

Wird benutzt von reset().

00072 {
00073     object *inh = all_inventory(this_object()) - ({0});
00074 
00075     inh = filter( inh, #'removeable_ob );
00076     foreach(mixed item : QueryProp(P_ITEMS))
00077       inh -= ({ item[0] });
00078  
00079 //TODO: nach Reboot #if entsorgen.
00080 #if __BOOT_TIME__ > 1233404298
00081     if (!stringp(fun) && !closurep(fun))
00082                 fun = "description_id";
00083     inh = unique_array(inh, fun, 0);
00084     foreach(mixed arr: inh) {
00085       if (sizeof(arr) <= limit)
00086                 continue;
00087       catch(call_other(arr[limit ..], "remove"); publish);
00088     }
00089 #else    
00090     // TODO: Den ganzen Quatsch da unten am besten durch unique_array()
00091     // ersetzen. Dazu muessen aber die Objekt erst ne entsprechende
00092     // ID-Funktion haben.
00093     foreach( mixed arr: &inh)  
00094       arr = ({ ( load_name(arr) + arr->short() + arr->long() ),
00095                                     arr });
00096 
00097     inh = sort_array( inh, #'_sortfunc/*'*/ );
00098     string ident = "";
00099     int j;
00100     foreach(mixed arr: inh) {
00101         if ( ident != arr[0] ){
00102             ident = arr[0];
00103             j = 1;
00104         } else {
00105             if ( ++j > limit && arr[1] ){
00106                 catch( arr[1]->remove();publish );
00107                 if ( arr[1] )
00108                     destruct( arr[1] );
00109             }
00110         }
00111     }
00112 #endif // __BOOT_TIME__
00113 }

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

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

private object removeable_ob ( object  ob  ) 

Definiert in Zeile 56 der Datei items.c.

00057 {
00058     if ( !query_once_interactive(ob) && !living(ob) )
00059         return ob;
00060 
00061     return 0;
00062 }

public void RemoveItem ( mixed  filename  ) 

Definiert in Zeile 205 der Datei items.c.

Benutzt items, master, P_ITEMS, QueryProp() und SetProp().

00206 {
00207     mixed *items;
00208     int i;
00209 
00210     if ( !pointerp(items = QueryProp(P_ITEMS)) || !sizeof(items) )
00211         return;
00212 
00213     if ( pointerp(filename) )
00214         for ( i = sizeof(filename); i--; )
00215             filename[i] = (string)master()->_get_path( filename[i], "?" );
00216     else
00217         filename = (string)master()->_get_path( filename, "?" );
00218   
00219     SetProp( P_ITEMS, filter( items, #'ri_filter/*'*/, filename ) );
00220 }

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

void reset ( void   ) 

Definiert in Zeile 277 der Datei items.c.

Benutzt items, P_ITEMS, QueryProp() und SetProp().

00278 {
00279     mixed *items;
00280 
00281     if ( !pointerp(items = QueryProp(P_ITEMS)) ){
00282         SetProp( P_ITEMS, ({}) );
00283         return;
00284     }
00285     
00286     SetProp( P_ITEMS, map( items, #'_do_refresh/*'*/ ) - ({0}) );
00287 }

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

private int ri_filter ( mixed *  ritem,
mixed  file 
)

Definiert in Zeile 188 der Datei items.c.

Benutzt inv(), ri_rem_ob(), RITEM_FILE und RITEM_OBJECT.

00189 {
00190     object ob, *inv;
00191     int i;
00192   
00193     ob = ritem[RITEM_OBJECT];
00194   
00195     if ( stringp(file) && ritem[RITEM_FILE] == file )
00196         return ri_rem_ob(ob), 0;
00197     else if ( pointerp(ritem[RITEM_FILE]) && pointerp(file) &&
00198               sizeof(file & ritem[RITEM_FILE]) == sizeof(ritem[RITEM_FILE]) )
00199         return ri_rem_ob(ob), 0;
00200 
00201     return 1;
00202 }

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

private void ri_rem_ob ( object  ob  ) 

Definiert in Zeile 164 der Datei items.c.

Benutzt destruct() und inv().

Wird benutzt von ri_filter().

00165 {
00166     object *inv;
00167     int i;
00168   
00169     if ( objectp(ob) && present(ob, this_object()) ) {
00170         inv = deep_inventory(ob);
00171         
00172         for ( i = sizeof(inv); i--; )
00173             if ( inv[i] ) {
00174                 inv[i]->remove(1);
00175                 
00176                 if ( inv[i] )
00177                     destruct(inv[i]);
00178             }
00179         
00180         ob->remove(1);
00181         
00182         if ( ob )
00183             destruct(ob);
00184     }
00185 }

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

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

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