Added public files
Roughly added all public files. Probably missed some, though.
diff --git a/std/container/items.c b/std/container/items.c
new file mode 100644
index 0000000..9961bfe
--- /dev/null
+++ b/std/container/items.c
@@ -0,0 +1,256 @@
+// MorgenGrauen MUDlib
+//
+// container/items.c -- creating extra items in room
+//
+// $Id: items.c 8811 2014-05-09 17:30:37Z Zesstra $
+
+// extra items handling
+//
+// AddItem(string filename, int refresh)
+// Clones an item and puts it into the room. <refresh> may be
+// on of the following:
+// REFRESH_NONE: No refresh done until reboot.
+// REFRESH_DESTRUCT: Refresh on reset if item was destructed.
+// REFRESH_REMOVE: Refresh on reset if item was removed from room.
+// REFRESH_ALWAYS: Create a new clone on every reset.
+//
+// The commands are implemented as properties P_ITEMS as mapping. They are
+// stored locally (_set_xx) as mapping to speed up the routines
+// in this module.
+//
+// Format of key and data in the P_ITEMS mapping:
+//
+// ([ key1 : refresh1; obp1; arr1, ..., keyn : refreshn; obpn; arrn ])
+
+#include <sys_debug.h>
+#pragma strict_types
+#pragma save_types
+#pragma range_check
+#pragma no_clone
+#pragma pedantic
+
+#define NEED_PROTOTYPES
+#include <thing/properties.h>
+#include <rooms.h>
+#include <container.h>
+#undef NEED_PROTOTYPES
+#include <defines.h>
+#include <config.h>
+#include <properties.h>
+#include <moving.h>
+#include <daemon.h>
+
+protected void create()
+{
+ Set( P_ITEMS, ({}) );
+ Set( P_ITEMS, SECURED, F_MODE_AS );
+
+ OBJECTD->QueryObject(); // querying general objects
+}
+
+protected void create_super() {
+ set_next_reset(-1);
+}
+
+/* Kram zum Aufraeumen von multiplen gleichen Items im Container. */
+private object removeable_ob( object ob )
+{
+ if ( !query_once_interactive(ob) && !living(ob) )
+ return ob;
+
+ return 0;
+}
+
+protected varargs void remove_multiple(int limit, mixed fun)
+{
+ object *inh = all_inventory(this_object()) - ({0});
+
+ inh = filter( inh, #'removeable_ob );
+ foreach(mixed item : QueryProp(P_ITEMS))
+ inh -= ({ item[0] });
+
+ if (!stringp(fun) && !closurep(fun))
+ fun = "description_id";
+ inh = unique_array(inh, fun, 0);
+ foreach(mixed arr: inh)
+ {
+ if (sizeof(arr) <= limit)
+ continue;
+ catch(call_other(arr[limit ..], "remove"); publish);
+ }
+}
+
+
+/* Item handling */
+public varargs object AddItem( mixed filename, int refresh, mixed props )
+{
+ string file;
+ object ob;
+ int i;
+
+ if( pointerp(filename) ) {
+ for( i = sizeof(filename); i--; )
+ filename[i] = (string)master()->_get_path( filename[i], "?" );
+
+ file = filename[random( sizeof(filename) )];
+ }
+ else
+ file = filename = (string)master()->_get_path( filename, "?" );
+
+ if ( props == 1 )
+ catch(ob = load_object( file); publish);
+ else
+ catch(ob = clone_object(file); publish);
+
+ if (objectp(ob)) {
+ ob->move( this_object(), M_NOCHECK|M_NO_ATTACK );
+ // mit Absicht keine Pruefung aufs Move, wenns nicht geht, solls 2s
+ // spaeter auf der Ebene buggen, weil praktisch niemand im create() das
+ // Ergebnis vom AddItem() prueft.
+ }
+
+ // In P_ITEMS vermerken, es sei denn, REFRESH_NONE ist gegeben, in dem
+ // Fall ist die Speicherung voellig unnoetig.
+ // TODO: Pruefen, ob das wirklich problemlos geht. Bis dahin werden auch
+ // TODO::REFRESH_NONE-Items vermerkt. (s. clean_up() in /std/room.c)
+ //if (!(refresh & REFRESH_NONE)) {
+ SetProp( P_ITEMS, QueryProp(P_ITEMS) +
+ ({ ({ ob, // RITEM_OBJECT
+ filename, // RITEM_FILE
+ refresh // RITEM_REFRESH
+ }) +
+ ((mappingp(props) || props == 1) ? ({ props }) : ({})) }) );
+ //}
+
+ if ( ob && mappingp(props) )
+ walk_mapping( props, symbol_function( "SetProp", ob ) );
+
+ return ob;
+}
+
+
+private void ri_rem_ob( object ob )
+{
+ object *inv;
+ int i;
+
+ if ( objectp(ob) && present(ob, this_object()) ) {
+ inv = deep_inventory(ob);
+
+ for ( i = sizeof(inv); i--; )
+ if ( inv[i] ) {
+ inv[i]->remove(1);
+
+ if ( inv[i] )
+ destruct(inv[i]);
+ }
+
+ ob->remove(1);
+
+ if ( ob )
+ destruct(ob);
+ }
+}
+
+
+private int ri_filter( mixed *ritem, mixed file )
+{
+ object ob, *inv;
+ int i;
+
+ ob = ritem[RITEM_OBJECT];
+
+ if ( stringp(file) && ritem[RITEM_FILE] == file )
+ return ri_rem_ob(ob), 0;
+ else if ( pointerp(ritem[RITEM_FILE]) && pointerp(file) &&
+ sizeof(file & ritem[RITEM_FILE]) == sizeof(ritem[RITEM_FILE]) )
+ return ri_rem_ob(ob), 0;
+
+ return 1;
+}
+
+
+public void RemoveItem( mixed filename )
+{
+ mixed *items;
+ int i;
+
+ if ( !pointerp(items = QueryProp(P_ITEMS)) || !sizeof(items) )
+ return;
+
+ if ( pointerp(filename) )
+ for ( i = sizeof(filename); i--; )
+ filename[i] = (string)master()->_get_path( filename[i], "?" );
+ else
+ filename = (string)master()->_get_path( filename, "?" );
+
+ SetProp( P_ITEMS, filter( items, #'ri_filter/*'*/, filename ) );
+}
+
+
+private mixed _do_refresh( mixed item )
+{
+ string file;
+ object ob;
+
+ if ( !pointerp(item) || item[RITEM_REFRESH] == REFRESH_NONE )
+ return item;
+
+ if ( pointerp(item[RITEM_FILE]) )
+ file = item[RITEM_FILE][random( sizeof(item[RITEM_FILE]) )];
+ else
+ file = item[RITEM_FILE];
+
+ switch( item[RITEM_REFRESH] ){
+ case REFRESH_MOVE_HOME:
+ if ( objectp(item[RITEM_OBJECT]) &&
+ environment(item[RITEM_OBJECT]) != ME ) {
+ item[RITEM_OBJECT]->move( ME, M_GO|M_NO_ATTACK );
+ break;
+ }
+
+ // fall through
+ case REFRESH_DESTRUCT:
+ if ( objectp(item[RITEM_OBJECT]) )
+ break; // else FALL THROUGH
+
+ case REFRESH_REMOVE:
+ if ( objectp(item[RITEM_OBJECT]) &&
+ environment(item[RITEM_OBJECT]) == ME )
+ break; // else FALL THROUGH
+
+ default:
+ if ( sizeof(item) > RITEM_PROPS && item[RITEM_PROPS] == 1 ) {
+ ob = load_object(file);
+ }
+ else
+ ob = clone_object(file);
+
+ ob->move( ME, M_NOCHECK|M_NO_ATTACK );
+ break;
+ }
+
+ if ( ob ){
+ item[RITEM_OBJECT] = ob;
+
+ if ( sizeof(item) > RITEM_PROPS && mappingp(item[RITEM_PROPS]) )
+ walk_mapping( item[RITEM_PROPS], symbol_function( "SetProp", ob ) );
+ }
+
+ return item;
+}
+
+
+// reset handling: check how the items should be refreshed.
+void reset()
+{
+ mixed *items;
+
+ if ( !pointerp(items = QueryProp(P_ITEMS)) ){
+ SetProp( P_ITEMS, ({}) );
+ return;
+ }
+
+ SetProp( P_ITEMS, map( items, #'_do_refresh/*'*/ ) - ({0}) );
+}
+