/** * Bath house inheritable! * @author Taffyd * @started 30/04/00 12:08 */ #include <effect.h> #define SOAP_EFFECT "/std/effects/healing/antiseptic_soap" #define WET_EFFECT "/std/effects/other/wetness" /** * @ignore yes * Function prototypes! */ protected int add_wash_effect( string classification, function func ); protected int add_finished_func( function func ); protected void advanced_antiseptic( object ob, string classification, mixed arg, int effect_enum, object effect_ob ); protected void basic_cleaning( object ob, int effect_enum, string message ); protected void apply_soap( object ob, string *applied_effects ); protected void wet_person( object ob, string *applied_effects ); private mapping _wash; private function *_finished_funcs; /** @ignore yes */ void create() { _wash = ([ ]); _finished_funcs = ({ }); add_wash_effect( "body.smell", (: advanced_antiseptic :) ); add_wash_effect( "misc.ketchup", (: basic_cleaning( $1, $3, "The soap rinses the ketchup off your face." ) :) ); add_wash_effect( "object.label", (: basic_cleaning( $1, $3, "The labels stuck to your body peel off in the water." ) :) ); add_wash_effect( "body.frog-adhesive", (: basic_cleaning( $1, $3, "The frantic ribbiting fades away as the frog adhesive washes " "off." ) :) ); add_finished_func( (: apply_soap :) ); add_finished_func( (: wet_person :) ); this_object()->add_setup_wash_command(); } /* create() */ /** @ignore yes */ void init() { /* Call this function in this_object() to add any commands */ this_object()->add_init_wash_command(); } /* init() */ /** * This method adds an effect to be removed when washing here. * If the effect is matched, then func is evaluated. * @param classification the effect classification to match. * @param func the function to evaluate when the effect is matched. * @return 1 if the effect classification was added, 0 if it could not be * (most likely a duplicate effect classification). * @example * add_wash_effect( "body.smell", (: advanced_antiseptic :) ); * @example * add_wash_effect( "object.label", (: basic_cleaning( $1, $3, * "The labels stuck to your body peel off in the water." ) :) ); */ protected int add_wash_effect( string classification, function func ) { if ( !_wash[ classification ] ) { _wash[ classification ] = func; return 1; } return 0; } /* add_wash_effect() */ /** * This adds a function to be evalauted when all of the wash effects * have been evaluated. * @param func the function to be evaluated * @return 1 */ protected int add_finished_func( function func ) { _finished_funcs += ({ func }); return 1; } /* add_finish_func() */ /** * This returns a list of all the effect classifications that are currently * being managed. * @return an array of strings. */ public string *query_wash_classifications() { return keys( _wash ); } /* query_wash_classifications() */ /** * This method removes a wash effect. * @param the classification of the effect to be removed. * @return 1 if the effect was successfully removed, 0 if it wasn't. */ protected int remove_wash_effect( string classification ) { if ( _wash && _wash[ classification ] ) { map_delete( _wash, classification ); return 1; } return 0; } /* remove_wash_effect() */ /** * This is a basic cleaning method that can be used to remove a few * default things. */ protected void advanced_antiseptic( object ob, string classification, mixed arg, int effect_enum, object effect_ob ) { tell_object( ob, "The antiseptic power of the soap defeats " + effect_ob->smell_string( ob, arg ) + ".\n" ); ob->delete_effect( effect_enum ); } /* advanced_antiseptic() */ /** * This is a small cut down cleaning effect that displays a message. */ protected void basic_cleaning( object ob, int effect_enum, string message ) { tell_object( ob, message + "\n" ); ob->delete_effect( effect_enum ); } /* basic_cleaning() */ /** * This is the default finished func. It adds soap. */ protected void apply_soap( object ob, string *applied_effects ) { ob->add_effect( SOAP_EFFECT, 10000 ); } /* apply_soap() */ protected void wet_person( object ob, string *applied_effects ) { ob->add_effect( WET_EFFECT, 250 ); } /* wet_person() */ /** * This method washes a player. Any wash commands that are defined * must ultimately call this function, so that all of the wash * functions can be evaluated. * <p> * When an effect is found on the player for a matching wash effect * classification, the function specified is evaluated with the following * parameters: * <ul> * <li>ob, the player who is being washed * <li>classification, the classification of the effect that was matched. * <li>arg, the arguments to the effect. * <li>effect_enum, the position of the effect in the player's effect list. * <li>effect_ob, the object that the effect is found in. * </ul> * <p> * After this, the finished functions are evaluated with two arguments, the first * one being ob, the second one being an array of all the wash effect classifications * that were matched correctly. * @param ob the object to wash * @return 1 if the player was washed successfully, 0 if they weren't. */ public int wash_player( object ob ) { function func; string eff; string *cleaned; int *enums, eff_enum; cleaned = ({ }); foreach( eff, func in _wash ) { enums = ob->effects_matching( eff ); if ( sizeof( enums ) ) { foreach( eff_enum in enums ) { evaluate( func, ob, eff, ob->arg_of( eff_enum ), eff_enum, ob->eff_of( eff_enum ) ); } cleaned += ({ eff }); } } foreach( func in _finished_funcs ) { evaluate( func, ob, cleaned ); } return 1; } /* wash_player() */ int query_baths() { return 1; } /* query_baths() */