/** * A nice file to allow you to setup an object as being holdable. To deal * with this inheritable you only need to define the method held_this_item * if you wish to do anything when the item is held. * @author Pinkfish * @started Wed Feb 2 15:38:10 PST 2000 */ #include <move_failures.h> private int _my_limb; private nosave int _no_limbs; private object _holder; int held_this_item( int held, object holder, mixed arg ); void set_no_limbs( int num ); void create() { _no_limbs = 1; } /* create() */ /** @ignore yes */ mapping query_static_auto_load() { return ( _no_limbs ? ([ "no limbs" : _no_limbs ]) : ([ ]) ); } /* query_static_auto_load() */ /** @ignore yes */ void init_static_arg( mapping arg ) { if( !arg ) return; if( arg["no limbs"] ) set_no_limbs( arg["no limbs"] ); } /* init_static_arg() */ /** @ignore yes */ mapping query_dynamic_auto_load() { return ([ "limb" : ( _holder ? _my_limb : -1 ), ]); } /* query_dynamic_auto_load() */ /** @ignore yes */ void init_dynamic_arg( mapping arg, mixed new_arg ) { if( !arg ) return; if( arg["limb"] != -1 ) { call_out( function( int pos, mapping arg, mixed new_arg ) { if( environment() ) environment()->set_hold( TO, pos ); held_this_item( 2, environment(), new_arg ); }, 0, arg["limb"], arg, new_arg ); } } /* init_dynamic_arg() */ /** * This method is called by the inheritable when the object is change from * being held to unheld, or vica versa. This should be used to turn on * and off light sources and so on. The method will also be called with * a 2 if the object was held and we are doing an initialisation sequence. * @param held 1 if the item is held, 0 if not, 2 if held on init * @param holder this is person already holding it when removed, new holder when held * @param arg an argument use in the autoloading, passed into init_dynamic_arg * @return 1 if the hold/remove was successful */ int held_this_item( int held, object holder, mixed arg ) { return 1; } /* held_this_item() */ /** * This method is called from the living object when we are held or * unheld. * @param ob the person holding us * @param limb the limb we are being held in */ int set_holder( object ob, int limb ) { TO->remove_hide_invis( "concealed" ); if( _holder && ( !ob || ob != _holder ) ) if( !held_this_item( 0, _holder, 0 ) ) return 0; if( ob ) if( !held_this_item( 1, ob, 0 ) ) return 0; _holder = ob; _my_limb = limb; return 1; } /* set_holder() */ /** * This method returns the number of limbs that the object uses. * @return the number of limbs the object uses when held */ int query_no_limbs() { return _no_limbs; } /** * This method sets the number of limbs the object uses when held. * @param num the number of limbs */ void set_no_limbs(int num) { if( num < 0 ) return; _no_limbs = num; } /* set_no_limbs() */ /** * This method should be called by the upper level moves. The result * needs to be check, if it is not MOVE_OK then the move should be * stopped. * @param ob the object to move */ int move( mixed ob) { if( ob != _holder && _holder ) if( !sizeof( _holder->set_unhold( TO ) ) ) return MOVE_NO_UNHOLD; return MOVE_OK; } /* move() */ /** * This method returns the person who is holding the object. * @return the person holding the object * @ignore yes */ object query_wielded() { return _holder; } /** * This method returns the person who is holding the object. * @return the person holding the object */ object query_holder() { return _holder; } /** * This method deals with removing ourselves as a holder when dested. * @ignore yes */ void dest_me() { if( _holder ) _holder->set_unhold(TO); } /* dest_me() */ /** * * Attempts to free up enough limbs for this_object to be held. If * items are dropped to make this possible, who is notified. If * enough limbs are freed, attempts to hold this_object. If the position * is undefined (ie: not specified) then it will try and choose a limb * by itself. * <p> * The return numbers are the limb numbers that were used by holding the * item. * <p> * hold_item: As designed by Tannah! * @param who The living object trying to hold this one. * @param pos the position to hold the item in * @return the an (int *) if successful or ({ }) if not enough limbs are freed */ varargs int *hold_item( object who, int pos ) { object ob; object *held_things; object *dropped_things = ({ }); /* If a particular position is specified, put that position at * the front of the queueueue, continue from it to the end, then * start at the beginning */ if( !undefinedp( pos ) && pos != -1 ) { /* is the position number valid? */ if( pos < 0 || pos >= sizeof( who->query_holding() ) ) return ({ }); /* is there already something in that hand that can't be put down? */ ob = who->query_holding()[ pos ]; if( ob ) { if( !sizeof( who->set_unhold( ob ) ) ) return ({}); else dropped_things += ({ ob }); } /* all is well...continue on */ held_things = who->query_holding()[pos..] + who->query_holding()[0..pos-1]; } /* Otherwise use the standard order */ else { held_things = who->query_holding(); pos = -1; } tell_creator( who, "FL: %d, NL: %d, ob: %O\n", who->query_free_limbs(), TO->query_no_limbs(), TO ); tell_creator( who, "Dropped things: %O\n", dropped_things ); /* Try to put down enough things to hold this object */ for( int i = 0; who->query_free_limbs() < TO->query_no_limbs() && i < sizeof( held_things ); i++ ) { tell_creator( who, "Freeing limbs.\n" ); ob = held_things[i]; //We stopped holding something if( ob && sizeof( who->set_unhold( ob ) ) ) dropped_things += ({ ob }); } /* Tell the player what he's put down: */ if( sizeof( dropped_things ) ) tell_object( who, "You put down " + query_multiple_short( dropped_things ) + ".\n" ); /* Can he hold the item now? */ if( who->query_free_limbs() >= TO->query_no_limbs() ) { //Excellent! return who->set_hold( TO, pos ); } tell_object( who, "You can't free up enough limbs to use "+ TO->a_short() + ".\n" ); return ({ }); // Nope, he can't. } /* hold_item() */