/* -*- LPC -*- */
/*
* $Locker: $
* $Id: multiple_short.c,v 1.14 2001/03/12 06:04:25 pinkfish Exp $
* $Log: multiple_short.c,v $
* Revision 1.14 2001/03/12 06:04:25 pinkfish
* Fix up some problems in the code...
*
* Revision 1.13 2001/03/12 06:03:23 pinkfish
* Fix up some issues with multiple short.
*
* Revision 1.12 2001/03/09 02:21:56 pinkfish
* Add in some docs.
*
* Revision 1.11 2001/03/08 12:24:24 taffyd
* Fixed up the fixes for the fixes for the fixes.
*
* Revision 1.10 2001/03/08 08:56:01 pinkfish
* Fix up issues with multiple short.
*
* Revision 1.9 2001/03/08 01:08:31 pinkfish
* Fix up some interesting things with query_multiple_short.
*
* Revision 1.8 2001/03/07 23:50:39 pinkfish
* Make it handle dark as an extra paramebert.
* Add ina dark check.
*
* Revision 1.7 2000/07/09 08:29:56 shrike
* Made it aware of the quiet flags to the short functions.
*
* Revision 1.6 2000/04/25 22:15:30 pinkfish
* Make the no_dollars arg work as it shold.
*
* Revision 1.5 2000/04/25 22:06:41 pinkfish
* Make it really do no_dollars translations.
*
* Revision 1.4 1998/07/24 05:02:43 pinkfish
* Some changes and some not so pleasant changes...
*
* Revision 1.3 1998/06/30 01:07:32 pinkfish
* Change it so that the functions get calle don the object itselt to handle
* things with variable short descriptions.
*
* Revision 1.2 1998/03/24 07:28:59 pinkfish
* Add some docs to make the simulefuns more usefully lookupable.
*
* Revision 1.1 1998/01/06 05:13:15 ceres
* Initial revision
*
*/
/**
* Cotains some simul_efuns.
* @author Pinkfish
*/
/**
* Returns a nice string which looks like "Frog, fish and chicken". This
* takes in an array of objects and or strings and returns a message
* like that shown above. It also does things like adding the number of
* each type at the start of the function.
* <p>
* This function has two main uses: to produce the control codes for a
* set of objects and to produce a nice list from a set of strings.
* The "type" argument is optional and may be "a", "the", "one" or
* "poss", defaulting to "a": it determines which of a_short,
* the_short, one_short or poss_short will be used to make the control
* code sequence for the objects in "args". If all of the elements of
* "args" are objects, it simply returns the block control code for
* the relevant shorts of the objects. Otherwise, it looks through
* the elements one at a time, replacing objects by the result of
* calling the relevant short function on them; finally it
* concatenates the elements with commas between each pair, except
* between the last pair which have " and " between them. Since the
* output will contain processing codes if there are any objects in
* "args", it should be passed through convert_message before being
* stored.
* <p>
* If you pass in a 1 for the 'quiet' flag, it will not take any of the
* objects out of hiding.
*
* @param args the array to do the processing on
* @param type the type of short to use "a", "the", "one", "poss"
* @param no_dollars this forces the output to be a real string
* @param quiet do not bring the objects out of hiding
* @param dark how dark it is, used to hide object lists in the dark
* @return the processed string
*/
varargs string query_multiple_short( mixed *args, string type,
int no_dollars, int quiet,
int dark ) {
int i;
//int found_object;
string func;
string ret;
// If it is dark, we want it to not see the objects.
if (no_dollars && sizeof(args) && objectp(args[0]) && undefinedp(dark) &&
this_player() && environment(this_player())) {
dark = this_player()->check_dark(environment(this_player())->query_light());
if (dark) {
return "some objects you cannot make out";
}
}
args = copy(args);
if ( !type ) {
type = "a";
}
for ( i = 0; i < sizeof( args ); i++ ) {
if ( !objectp( args[ i ] ) ) {
break;
}
}
/*
* Changed to use a function instead of the fast direct method to handle
* the problem where things with variable shorts are used in multiple
* lists.
*/
func = type + "_short";
if ( i == sizeof( args ) && !no_dollars) {
for ( i = 0; i < sizeof( args ); i++ ) {
args[ i ] = call_other(args[ i ], func, quiet);
//args[ i ] = "$"+ type +"_short:"+ file_name( args[ i ] ) +"$";
}
return "$M$"+ implode( args, "" ) +"$M$";
}
for ( i = 0; i < sizeof( args ); i++ ) {
if ( objectp( args[ i ] ) ) {
args[ i ] = call_other(args[ i ], func, quiet);
//args[ i ] = "$"+ type +"_short:"+ file_name( args[ i ] ) +"$";
} else if ( pointerp( args[ i ] ) ) {
/* This may still be used somewhere. */
args[ i ] = "$"+ type +"_short:"+ file_name( args[ i ][ 1 ] ) +"$";
}/* else if (stringp(args[ i ]) && !no_dollars) {
args[ i ] = "$mirror_short:" + args[i] + "$";
} */
}
//if (!no_dollars) {
//return "$M$"+ implode( args, "" ) +"$M$";
//}
i = sizeof( args );
switch ( i ) {
case 0 :
return "";
case 1 :
ret = args[ 0 ];
break;
default :
ret = implode( args[ 0 .. i - 2 ], ", " ) +" and "+ args[ i - 1 ];
break;
}
if (no_dollars) {
if (this_player()) {
return this_player()->convert_message(ret);
} else {
return "/global/player"->convert_message(ret);
}
}
return ret;
} /* query_multiple_short() */
