/** * * This object handles all the inventory listing for rooms, when long() is * called. * It should convert like this: ({ /w/terano/womble#1234, /std/object#1324, * /global/creator#2523 }) into "Lady Midnite is standing here.\nA key and a * womble are floating happily.\n" * * @author Lynscar * @change Deutha * Added in support for the one_short, the_short stuff. Also added * in the 'last' stuff I think. * @change Pinkfish * Added in support for positions. * @change Terano * Rewrote removing all the foreachs, and getting rid of chicken and last * variables. Should be much nicer now. */ #include <position.h> // Comment me out to use the old process_non_living() code. #define NEW_PROCESS_NON_LIVING 1 mixed *process_living( object *int_livings ); string process_non_living( object *int_non_livings, int start ); /** * This method returns a string contents of description of the container. * NB: TP is _not_ included in the array if (s)he is present. * The ignore_living flag tells us if we should process living * objects as different or not. If we do not process them as * different (as you do in room descriptions), then this flag should * be 0. This is so that living objects can be kept an an * inventory of a player without stuff it up. ie: Pets. * @param start the start message before the contents * @param things the things to give the message for * @param ignore_living treat livings differently * @return a string contents description */ varargs string query_contents( string start, object *things, int ignore_living ) { object *livings = ({ }), *non_livings = ({ }); mixed *bits; string return_string = ""; int groups; // Sort into living and non-living if( stringp( start ) ) return_string = start; if( !arrayp( things ) ) { things = TO->find_inv_match( "", TP ); things -= ({ TP }); things = filter( things, (: ENV( $1 ) == TO :) ); } if( !sizeof( things ) ) return ""; if( !ignore_living ) { livings = filter( things, (: living( $1 ) :) ); non_livings = things - livings; } else non_livings = things; // Process the livings if( sizeof( livings ) ) { bits = process_living( livings ); return_string += bits[ 0 ]; groups = bits[1]; } // Process the non-livings if( sizeof( non_livings ) ) return_string += process_non_living( non_livings, groups ); // Return the built string - Yay! if( return_string == "" ) return return_string; else return return_string = TP->colour_event("inventory", "") + return_string[0..<2] + "%^RESET%^\n"; } /* query_contents() */ /** @ignore yes */ /* Internally process living objects and return a string. */ mixed *process_living( object *int_livings ) { int i; mapping positions = ([ ]); object live_temp; string my_pos, int_ret_string = "", *all_positions, current_pos, ministring; foreach( live_temp in int_livings ) { if( undefinedp( my_pos = live_temp->query_position_short() ) ) my_pos = POSITION_DEFAULT; if( undefinedp( positions[ my_pos ] ) ) positions[ my_pos ] = ({ live_temp }); else positions[ my_pos ] += ({ live_temp }); } // Sort into positions // For each position, build a ministring and add it all_positions = keys( positions ); i = 0; foreach( current_pos in all_positions ) { if( i == 0 ) { ministring = "$C$$M$"; } else { ministring = "$M$"; } foreach( live_temp in positions[ current_pos ] ) { if( !live_temp->query_visible( TP ) ) { continue; } ministring += live_temp->a_short(); } /* If more than one living */ if( !positions[current_pos][0]->query_position_dont_use_is_are()) { if( sizeof( positions[ current_pos ] ) > 1 || positions[ current_pos ][0]->group_object() ) { if( positions[ current_pos ][0]->query_position_multiple() ) { ministring += "$M$ are each " + current_pos; } else { ministring += "$M$ are " + current_pos; } } else { ministring += "$M$ is " + current_pos; } } else { ministring += "$M$ " + current_pos; } switch( current_pos ) { case SITTING: case STANDING: case KNEELING: case SWIMMING: case LYING: case MEDITATING: case CROUCHING: ministring += " here"; default: i++; if( i < sizeof(all_positions) - 1 ) ministring += ", "; else if( i < sizeof(all_positions) ) ministring += " and "; else ministring += ".\n"; int_ret_string += ministring; continue; } } return ({ int_ret_string, sizeof( all_positions ) }) ; } /* process_living() */ /** @ignore */ string process_non_living( object *non_livings, int start ) { mapping positions; string position, here, *room_items; object *items, item, *bulk; int i; if( !sizeof(non_livings) ) return ""; here = TO->query_property( "here" ); if( !here ) return query_multiple_short( non_livings ) + ".\n"; positions = unique_mapping( non_livings, (: $1->query_property( "there" ) :) ); if ( positions[ 0 ] ) { positions[ here ] = positions[ 0 ]; map_delete( positions, 0 ); } i = start; room_items = ({ }); foreach( position, items in positions ) { bulk = ({ }); foreach( item in items ) { if ( item->query_continuous() && item->query_how_many() > 1 && item->query_property("determinate") != "some " ) { // How do we make sure this all gets arranged properly...? room_items += ({ item->a_short() + " are " + position }); } else { bulk += ({ item }); } } if ( sizeof( bulk ) ) { room_items += ({ "$M$" + implode( bulk->a_short(), "" ) + "$M$ " + "$V$" + i + "=is,are$V$ " + position }); } i++; } return "$C$" + query_multiple_short( room_items ) + ".\n"; } /* process_non_living() */ /** * This method prints out the contents of the object matching. * @param word the string to match */ void list_contents( string words ) { write( query_contents( words ) ); } /** @ignore */ int query_last() { log_file( "CUTELAST", "(%s) %s called query_last.\n", ctime( time() ), file_name( TO ) ); return 0; } /* query_last() */ /** @ignore */ void adjust_last( int wibble ) { log_file( "CUTELAST", "(%s) %s called adjust_last.\n", ctime( time() ), file_name( TO ) ); return; } /* adjust_last() */