/** * The basic container inheritable, please note this is *not* a container * like a bucket. This now allows things inside the container to * inform us that they should be used as part of the inventory of this * object. This means the contents of containers will look like they * are not inside containers to the outside world. * @author Pinkfish * @see /obj/container.c * @see /obj/baggage.c * @see /obj/vessel.c * @see /obj/clothing.c */ #include <move_failures.h> #include <player.h> #include <player_handler.h> inherit "/std/object"; inherit "/std/basic/cute_look"; inherit "/std/basic/export_inventory"; inherit "/global/auto_load"; private nosave int _max_weight; private nosave int _loc_weight; private nosave int _max_items; private nosave int _prevent_insert; private nosave string _ownership; private nosave object _player; private nosave int _n_tracked_items; private nosave int _tracking; void create() { registered_containers = ({ }); _n_tracked_items = 0; _tracking = 1; export_inventory::create(); object::create(); } /* create() */ /** * This method returns the maximum number of items that can * be carried in this container. * @return the maximum number of items * @see set_max_items() */ int query_max_items() { if(_max_items) return _max_items; if(_max_weight) return 4 * sqrt(_max_weight); return -1; } /** * This method sets the maximum number of items that can * be carried in this container. * @param number the new maximum number of items * @see query_max_items() */ void set_max_items( int number ) { _max_items = number; } /** * This method returns the maximum amount of weight that can * be carried in this container. * @return the maximum weight * @see set_max_weight() */ int query_max_weight() { return _max_weight; } /** * This method sets the maximum amount of weight that can * be carried in this container. * @param number the new maximum weight * @see query_max_weight() */ void set_max_weight( int number ) { _max_weight = number; } /** * This method returns the current local weight in this * container. * @return the local weight */ int query_loc_weight() { return _loc_weight; } /** * This method determins the current local weight from all the * objects inside the container * @see query_loc_weight() */ void update_loc_weight() { object thing; _loc_weight = 0; foreach ( thing in all_inventory( this_object() ) ) _loc_weight += (int)thing->query_complete_weight(); } /* update_loc_weight() */ /** * This method returns the complete weight of the object. This is the * weight of the container itself, plus the weight of the things * inside it * @return the complete_weight() * @see /std/basic/misc->query_weight() * @see query_loc_weight() */ int query_complete_weight() { return ::query_complete_weight() + _loc_weight; } /* query_complete_weight() */ /** * This method is called in the move functions, it adds extra * weight onto the object when something is moved inside it. * @return 1 if successfuly added * @param n the amount to add * @see /std/basic/misc->query_weight() */ int add_weight( int n ) { #ifdef 0 // This shouldn't be here should it? if ( _prevent_insert ) return 0; #endif if ( !_max_weight ) { _loc_weight += n; return 1; } if ( n + _loc_weight > _max_weight ) return 0; if ( !environment() ) { _loc_weight += n; return 1; } if ( !environment()->add_weight( n ) ) return 0; _loc_weight += n; return 1; } /* add_weight() */ /** * This returns who owns the container, if it set to 0 then no one * owns it. This is used in the theft determination for the object. * @return who owns the container * @see set_ownership() */ string query_ownership() { return _ownership; } /** * This sets who owns the container, if it set to 0 then no one * owns it. This is used in the theft determination for the object. * @param word who owns the container * @see query_ownership() */ void set_ownership( string word ) { if( word ) _ownership = lower_case( word ); else _ownership = word; } /** * This method checks to see if the object can be taken out of * us. * @param thing the object coming out * @param flag the move flag * @param dest the destination object * @see /std/basic/move.c * @return 1 if it can be taken out, 0 if not. */ int test_remove( object thing, int flag, mixed dest ) { int player; string str; if( !_ownership || !this_player() ) { return 1; } if( objectp( dest ) ) { dest = file_name( dest ); } if( dest == "/room/rubbish" || dest == "/room/vault" ) { return 1; } str = "Item " + file_name( this_object() ) + " accessed by " + this_player()->query_short() + " which belongs to $C$" + _ownership; // It's this_player's if( (string)this_player()->query_name() == _ownership ) { str += ". Taking items, no theft event."; log_file( "/w/trilogy/CONTAINER", str + "\n" ); return 1; } player = PLAYER_HANDLER->test_user( _ownership ); // Owner is a player if( player ) { // PK check, even if player is offline str += ", who is a player. "; if( !pk_check( this_player(), _ownership, 1 ) && environment( this_player() ) ) { str += "PK check succeded: Taking items, theft event triggered."; this_player()->zap_harry_shadow(); event( environment( this_player() ), "theft", this_player(), this_object(), ({ thing }) ); log_file( "/w/trilogy/CONTAINER", str + "\n" ); return 1; } else { // Cannot take stuff from NPK's containers str += "PK check failed: Cannot take items."; write( "An unseen force stays your hand.\n" ); log_file( "/w/trilogy/CONTAINER", str + "\n" ); return 0; } } else { // Owner not a player str += ", which is not a player. Taking items, theft event triggered."; this_player()->zap_harry_shadow(); event( environment( this_player() ), "theft", this_player(), this_object(), ({ thing }) ); log_file( "/w/trilogy/CONTAINER", str + "\n" ); return 1; } } /* test_remove() */ /** * This method allows things to be added into us. If we have an * environment check that for the ability to add into us. * @param ob the object being added * @param flag the add flags * @see /std/basic/move.c */ int test_add(object ob, int flag) { if(!_max_weight && !_max_items) return 1; // Prevent larger containers being placed in smaller ones if(ob->query_max_weight() > _max_weight - _loc_weight) { return 0; } // Prevent longer/wider objects being placed in shorter/thinner ones. // We check for a length/width greater than 1 since many items don't // have length/width yet. if(this_object()->query_length() > 1 && this_object()->query_length() < ob->query_length()) { return 0; } if(this_object()->query_width() > 1 && this_object()->query_width() < ob->query_width()) { return 0; } // Check if it's truly a container. If it is then count its inventory, // if not don't. if(ob->query_max_weight()) return ((sizeof(deep_inventory(this_object())) + sizeof(deep_inventory(ob))) < query_max_items()); else return sizeof(deep_inventory(this_object())) < query_max_items(); } /** * items21 stops this container from being put into other containers. * @see reset_prevent_insert() * @see query_prevent_insert() */ int set_prevent_insert() { _prevent_insert = 1; } /** * This allows this container to be put into other containers (default). * @see set_prevent_insert() * @see query_prevent_insert() */ int reset_prevent_insert() { _prevent_insert = 0; } /** * If this is true, this container cannot be put into other containers. * @see reset_prevent_insert() * @see set_prevent_insert() */ int query_prevent_insert() { return _prevent_insert; } /** @ignore yes */ varargs int move(mixed dest, mixed messin, mixed messout) { if (_prevent_insert && _loc_weight && !living(dest) && environment(dest)) return MOVE_INVALID_DEST; return object::move( dest, messin, messout ); } /* move() */ /** * This method finds the matching objects inside this object * that are visible to the looker. This will also use the * registered containers and add them into the array returned * (if visible and contained in the object). * @see /secure/simul_efun->find_match() * @param words the words matched on * @param looker who is looking * @see add_inventory_container() */ object *find_inv_match( string words, object looker ) { object *things; things = all_inventory( this_object() ); /* Remove the for loop and make this a touch faster. */ things = filter(things, (: $1->short(0) && (!$2 || $1->query_visible($2)) :), looker); return things; } /* find_inv_match() */ /** * This method handles the case where the return of the move flag is not * MOVE_OK. This can do whatever we want to make it work in a more useful * fashion. */ int do_restore_inventory_error(object ob, int move_flag) { object receipt; int ret; receipt = clone_object(PLAYER_RECEIPT); receipt->setup_receipt(ob); // Just in case it was too heavy. receipt->set_weight(0); ret = receipt->move(this_object()); if (ret != MOVE_OK) { // Bugger it. receipt->dest_me(); } else { move_flag = MOVE_OK; ob->move("/room/rubbish"); } return move_flag; } /* do_restore_inventory_error() */ /** * This method handles moving objects into the inventory from an auto * load. This should be over ridden by things inheriting us to * make sure that the objects can be moved into the inventory. It * should handle the bypassing of open/close/locked etc flags. * @param ob the object to move into ourselves */ protected int handle_restore_inventory(object ob) { /* The standard container needs to do nothing special. */ int move_flag; ob->disable_item_tracking(); move_flag = ob->move(this_object()); ob->enable_item_tracking(); if (move_flag != MOVE_OK) { // Turn it into a receipt and pop it in there ourselves. move_flag = do_restore_inventory_error(ob, move_flag); } return move_flag; } /* handle_restore_inventory() */ /** @ignore yes */ mixed stats() { return ::stats() + ({ ({ "loc_weight", query_loc_weight(), }), ({ "max_weight", query_max_weight(), }), ({ "max_items", query_max_items(), }), ({ "export invent", query_can_export_inventory() }), }); } /* stats() */ /** @ignore yes */ mapping int_query_static_auto_load() { mapping tmp; tmp = ::int_query_static_auto_load(); return ([ "::" : tmp, "max weight" : _max_weight, "prevent insert" : _prevent_insert, "can export inventory" : query_can_export_inventory(), ]); } /* int_query_static_auto_load() */ /** @ignore yes */ mapping query_dynamic_auto_load() { mixed inventory; // Create out auto load stuff. catch(inventory = create_auto_load( all_inventory( this_object() ), 0 ) ); return ([ "::" : object::query_dynamic_auto_load(), "inv" : inventory ]); } /* query_dynamic_auto_load() */ /** * This method is used in the auto loading sequence to set the * player who is loading the container. * @param thing the player loading the container * @see query_player() */ void set_player( object thing ) { ::set_player(thing); _player = thing; } /** * This method returns the player who is loading the container * during the autoload sequence. * @return the player who loaded the object */ object query_player() { return _player; } /** * This method enables item tracking * @see event_enter_tracked_item * @see disable_item_tracking */ nomask void enable_item_tracking() { _tracking = 1; } /** * This method disables item tracking * @see event_enter_tracked_item * @see enable_item_tracking */ nomask void disable_item_tracking() { _tracking = 0; } /** * This method handles the movement of the containers of this object. * Tracked items want to be notified if the container moves or anything * containing it does. The movement of the outmost moving container is * propagated down to all tracked items. * @param mover The outermost container object that moved * @param from The start environment of the outermost container * @param to The destination of the outermost container * @see event_enter_tracked_item */ nomask void event_container_move( object mover, mixed from, mixed to ) { if (_n_tracked_items) all_inventory()->event_container_move( mover, from, to ); } /** * This method is called from move to notify any tracked items contained of * the move using event_container_moved. * @param from start * @param to destination */ void event_move_object( mixed from, mixed to ) { if (_n_tracked_items && _tracking && !interactive()) { all_inventory()->event_container_move( this_object(), from, to ); if (objectp(from)) from->remove_tracked_items( _n_tracked_items ); if (objectp( to )) to->add_tracked_items( _n_tracked_items ); } } /** * This method is called to adjust the status reason. * occurences. * @see event_buried * @see event_player_quit * @see event_enter_tracked_item */ nomask void set_tracked_item_status_reason(string reason) { if (_n_tracked_items) all_inventory()->set_tracked_item_status( reason ); } /** * This method handles the addition of tracked items. * Tracked items want to be notified if the container moves. * @param n_items the number of tracked items added * @see remove_tracked_items * @see event_container_move */ nomask void add_tracked_items( int n_items ) { _n_tracked_items += n_items; if (environment()) environment()->add_tracked_items( n_items ); } /** * This method handles the removal of tracked items. * Tracked items want to be notified if the container moves. * @param n_items the number of tracked items removed * @see add_tracked_items * @see event_container_move */ nomask void remove_tracked_items( int n_items ) { _n_tracked_items -= n_items; if (environment()) environment()->remove_tracked_items( n_items ); } /** * This method returns the number of tracked item contained. * Tracked items want to be notified if the container moves. * @see add_tracked_items * @see event_container_move */ nomask int query_tracked_items() { return _n_tracked_items; } /** * This method allows the container to have stuff inside it checked. * @param looker the person doing the checking * @return 1 on success, 0 on failur */ int can_find_match_recurse_into(object looker) { object env; // // If the looked is one of our environments, then yes! they can. // env = environment(); while (env && !living(env) && env != looker && env != environment(looker)) { env = environment(looker); } return env == looker || env == environment(looker); } /* can_find_match_recurse_into() */ /** * This method checks to see if the find match code can actually * reference this object inside us. * @param thing the thing to reference * @param looker the person looking at it * @return 1 if they can, 0 if they cannot */ int can_find_match_reference_inside_object(object thing, object looker) { return 1; } /* can_find_match_reference_inside_object() */ /** @ignore yes */ void init_dynamic_arg( mapping bing, object ) { function f; if ( bing[ "::" ] ) { ::init_dynamic_arg( bing[ "::" ] ); } /* * Potential order of inventory generation problem here... Where the * upper parts of the container don't initialise until after we * return... */ if ( bing[ "inv" ] ) { f = (: handle_restore_inventory($1) :); if (!_player) { _player = this_player(); } if (_player) { load_auto_load_to_inventory( bing["inv"], this_object(), _player, f ); } else { load_auto_load_to_inventory( bing["inv"], this_object(), this_player(), f); } } } /* init_dynamic_arg() */ /** @ignore yes */ void init_static_arg( mapping bing ) { if ( bing[ "::" ] ) { ::init_static_arg( bing[ "::" ] ); } if ( !undefinedp( bing[ "max weight" ] ) ) { _max_weight = bing[ "max weight" ]; } if ( !undefinedp( bing[ "prevent insert" ] ) ) { _prevent_insert = bing[ "prevent insert" ]; } if (bing["can export inventory"]) { set_can_export_inventory(); } else { reset_can_export_inventory(); } } /* init_static_arg() */ /** @ignore yes */ mixed query_static_auto_load() { if (file_name(this_object())[0..13] == "/std/container") { return int_query_static_auto_load(); } return ([ ]); } /* query_static_auto_load() */ /** @ignore yes */ void dest_me() { foreach( object ob in all_inventory( this_object() ) ) { reset_eval_cost(); ob->dest_me(); } ::dest_me(); } /* dest_me() */