/*
* Inherit for hot food.
* Sightblinder, February 2002.
*
* $Id: hotfood.c,v 1.3 2003/03/25 15:32:15 sightblinder Exp sightblinder $
* $Log: hotfood.c,v $
* Revision 1.3 2003/03/25 15:32:15 sightblinder
* added $Log$
*
*/
/**
*
* <BR>
* This is an inherit for hot food which cools down,
* based on the temperature of the room in which it
* finds itself and any containers it might be in.
* <P>
* It performs just as normal food, apart from the following:
* <P>
* - If eaten while still hot it will cause the consumer to warm up for
* a period of time.
* <P>
* - It only decays once it has finished cooling.
* <P>
* It's cooling level can be checked by query_cool_level(). This
* starts at a value of twenty times the original weight of the
* hot food and determines how long it takes to cool down. Larger items
* cool more slowly.
* <P>
* The level of cooling is shown in the long and short of the object.
* These are created using query_short_rotten_adjective and
* query_long_decay_level, and are based on the percentage by which it has
* cooled.
* <P>
*
* Differant messages can be displayed when the food is eaten hot or cold
* These can be set using set_hot_eat_message() and set_cold_eat_message()
* Messages can also be set for eating bites of food where appropriate
* using setup_cold_eat_piece_messages() and setup_hot_eat_piece_messages()
*
* @author Sightblinder
*
*/
#include <bits_controller.h>
#include <weather.h>
inherit "/obj/food";
#define WARM 10 /* By how much eating this will warm you */
#define WARM_TIME 60 /* For how long eating this will warm you */
#define COOL_RATE_DEFAULT 10 /* The default cool rate, initially corresponding
* to 100 seconds for something of weight 1 to
* cool away to nothing in a 20 deg. C
* environment
*/
/* GLOBAL VARIABLES */
private int _cool_level; /* this represents the amount left to cool.
A value of 1 = stone cold. */
private int _cool_rate; /* This determines how quickly the item cools
by controlling the frequency of the cooling
call.*/
private int _purchase_time; /* The time the food was bought. Used to
* calculate how much it has cooled by. */
private mixed _hot_eat_message; /* The messeage returned when the food is
* eaten while still hot. */
private mixed _cold_eat_message; /* The messeage returned when the food is
* eaten while cold. */
private mixed _hot_eat_piece_message; /* Messages returned by */
private mixed _hot_eat_amt_message; /* setup_eat_piece_messages when */
private mixed _hot_eat_last_message; /* dealing with hot or cold food. */
private mixed _cold_eat_piece_message; /* */
private mixed _cold_eat_amt_message; /* */
private mixed _cold_eat_last_message; /* */
/* FUNCTION PROTOTYPES */
void create();
void set_cool_rate( int rate );
void set_cool_level(int level);
int query_cool_rate();
int query_cool_level();
protected void do_cool();
void set_hot_eat_mess(mixed messages);
void set_cold_eat_mess(mixed messages);
mixed query_hot_eat_mess();
mixed query_cold_eat_mess();
void setup_cold_eat_piece_messages(mixed piece, mixed amt, mixed last);
void setup_hot_eat_piece_messages(mixed piece, mixed amt, mixed last);
mixed query_hot_eat_amt_message;
mixed query_hot_eat_piece_message;
mixed query_hot_last_message;
mixed query_cold_eat_amt_message;
mixed query_cold_eat_piece_message;
mixed query_cold_last_message;
/**
* @ignore yes
*/
void create() {
do_setup++;
::create();
do_setup--;
_cool_rate = COOL_RATE_DEFAULT;
set_decay_speed( 1 );
if ( !do_setup ) this_object()->setup();
_cool_level = ( this_object()->query_weight() ) * 20;
_purchase_time = time();
}/* create() */
/**
* This function sets the current cooling rate for the food. This will
* have no real affect on the cooling of the food, as the cool rate is
*recalculated regularly.
*
* @param rate The new rate of cooling
*
* @see query_cool_rate()
*
*/
void set_cool_rate( int rate ) {
_cool_rate = rate;
} /* set_cool_rate */
/**
* This function returns the current rate of cooling of the hot food.
*
* @return The current cooling rate of the food.
*
* @see set_cool_rate()
*
*/
int query_cool_rate() {
return _cool_rate;
} /* query_cool_rate */
/**
* This function returns the current cool level of the food. This value
* starts at twenty times the original weight of the object, and decreases
* in time, as the food cools. 1 = stone cold.
*
* @return The current cool level of the food.
*/
int query_cool_level() {
return _cool_level;
} /* query_cool_level */
/**
* This function returns the adjective appended to the food's
* short description, describing how cooled or decayed it is.
*
* @return The adjectives added to the food's short describing its
* state of cooling or decay if already cold.
* @see query_long_decay_level()
*/
string query_short_rotten_adjective() {
string ret;
if (this_object()->query_cool_level() == 7){
return ("cold " + ::query_short_rotten_adjective());
}
_cool_level = (time() - _purchase_time)/_cool_rate;
ret = "";
switch ( _cool_level ) {
case 0..1:
ret="piping hot " + ret;
break;
case 2:
ret = "slightly cooled " + ret;
break;
case 3:
ret = "partially cooled " + ret;
break;
case 4:
ret = "half cooled " + ret;
break;
case 5:
ret = "mostly cooled " + ret;
break;
case 6:
ret = "almost completely cooled " + ret;
break;
default:
ret ="stone cold " + ret;
break;
}
return ret;
} /* query_short_rotten_adjective */
/**
* This function provides words for the food's long description,
* showing how cooled or decayed the object is.
*
* @return The words appended to the food's long, showing its state of
* cooling, or decay if it's already cold.
*
* @see query_short_rotten_adjective()
*/
string query_long_decay_level() {
string ret;
int flag;
if(query_collective() && query_amount() > 1 ) flag = 1;
if (this_object()->query_cool_level() == 7){
return ("It is stone cold. " + ::query_long_decay_level());
}
ret = "";
_cool_level = (time() - _purchase_time)/_cool_rate;
switch ( _cool_level) {
case 0..1:
ret += (flag?
"They have not yet begun to cool.\n":
"It has not yet begun to cool.\n");
break;
case 2:
ret += (flag?
"They have cooled slightly.\n":
"It has cooled slightly.\n");
break;
case 3:
ret += (flag?
"They have partially cooled.\n":
"It has partially cooled.\n");
break;
case 4:
ret += (flag?
"They are half cooled.\n":
"It is half cooled.\n");
break;
case 5:
ret += (flag?
"They have mostly cooled.\n":
"It has mostly cooled.\n");
break;
case 6:
ret += (flag?
"They are almost completely cold.\n":
"It is almost completely cold.\n");
break;
default:
ret += (flag?
"They are stone cold.\n":
"It is stone cold.\n");
break;
}
return ret;
} /* query_long_decay_level */
/*
* If the food is still hot make the person warm for a while when they eat
* it. Then inherit normal eat stuff.
*/
/**
* @ignore yes
*/
varargs int do_eat( int no_mess ) {
int current_warmth;
int remaining_time;
int new_warmth;
int new_time;
if(this_object()->query_cool_level() >= 7 ){
if (this_object()->query_weight_per_bite()){
setup_eat_piece_messages(this_object()->query_cold_eat_piece_message(),
this_object()->query_cold_eat_amt_message(),
this_object()->query_cold_eat_last_message());
}
else {
set_eat_mess( this_object()->query_cold_eat_message() );
}
return( ::do_eat( no_mess ));
}
if(this_player()->query_property("warmth")){
current_warmth = this_player() -> query_property("warmth");
remaining_time = this_player() -> query_property_time_left("warmth");
new_warmth = current_warmth+WARM;
new_time = (remaining_time + WARM_TIME)*0.75;
this_player()->add_property( "warmth",new_warmth,new_time);
}
else{
this_player()->add_property("warmth",WARM,WARM_TIME);
}
if(this_object()->query_weight_per_bite()){
setup_eat_piece_messages(this_object()->query_hot_eat_piece_message(),
this_object()->query_hot_eat_amt_message(),
this_object()->query_hot_eat_last_message());
}
else{
set_eat_mess( this_object()->query_hot_eat_message() );
}
return( ::do_eat( no_mess ) );
} /* do_eat() */
/* This function sets up the message seen by the player when they eat the food
* while it is still hot.
* <P>
* @param The message displayed when the food is eaten hot.
* <P>
* @see query_hot_eat_message(), set_cold_eat_message(),
* @see query_cold_eat_message().
*/
void set_hot_eat_message(mixed messages){
_hot_eat_message = messages;
}
/* This function sets up the message seen by the player when they eat the food
* when it is cold.
* <P>
* @param The message displayed when the food is eaten cold.
* <P>
* @see query_cold_eat_message(), set_hot_eat_message(),
* @see query_hot_eat_message().
*/
void set_cold_eat_message(mixed messages){
_cold_eat_message = messages;
}
/* This function sets up the message seen by the player when they eat the food
* while it is still hot.
* <P>
* @return The message displayed when the food is eaten hot.
* <P>
* @see set_hot_eat_message(), set_cold_eat_message(),
* @see query_cold_eat_message().
*/
mixed query_hot_eat_message(){
return _hot_eat_message;
}
/* This function sets up the message seen by the player when they eat the food
* when it is cold.
* <P>
* @return The message displayed when the food is eaten cold.
* <P>
* @see set_cold_eat_message(), set_hot_eat_message(),
* @see query_hot_eat_message().
*/
mixed query_cold_eat_message(){
return _cold_eat_message;
}
void setup_hot_eat_piece_messages(mixed piece, mixed amt, mixed last) {
_hot_eat_piece_message = piece;
_hot_eat_amt_message = amt;
_hot_eat_last_message = last;
}
void setup_cold_eat_piece_messages(mixed piece, mixed amt, mixed last) {
_cold_eat_piece_message = piece;
_cold_eat_amt_message = amt;
_cold_eat_last_message = last;
}
mixed query_cold_eat_piece_message(){
return _cold_eat_piece_message;
}
mixed query_cold_eat_amt_message(){
return _cold_eat_amt_message;
}
mixed query_cold_eat_last_message(){
return _cold_eat_last_message;
}
mixed query_hot_eat_piece_message(){
return _hot_eat_piece_message;
}
mixed query_hot_eat_amt_message(){
return _hot_eat_amt_message;
}
mixed query_hot_eat_last_message(){
return _hot_eat_last_message;
}
/**
* @ignore yes
*/
mixed *stats(){
mixed *args;
args =::stats() + ({ ({ "cool level", _cool_level }),
({ "cool rate", _cool_rate }),
({ "purchase time", _purchase_time }) });
return args;
}/* stats() */
/*
* This section covers all the loading of global variables
*/
/**
* @ignore yes
*/
mapping int_query_static_auto_load(){
return ([ "::" : ::int_query_static_auto_load(),
"cool_level" : _cool_level,
"cool rate" : _cool_rate,
"purchase time" : _purchase_time ]);
} /* int_query_static_auto_load() */
/**
* @ignore yes
*/
mapping query_static_auto_load(){
if ( ( base_name( this_object() ) != "/obj/food" )
&& !query_continuous() ) {
return 0;
}
return int_query_static_auto_load();
} /* query_static_auto_load() */
/**
* @ignore yes
*/
void init_static_arg( mapping map ){
if ( !mapp( map ) ) return;
if ( map[ "::" ] ) ::init_static_arg( map[ "::" ] );
_cool_level = map[ "cool_level" ];
_cool_rate = map[ "cool rate" ];
_purchase_time = map [ "purchase time" ];
} /* init_static_arg() */
/**
* @ignore yes
*/
mapping query_dynamic_auto_load(){
return ([ "::" : ::query_dynamic_auto_load(),
"cool_level" : _cool_level,
"cool rate" : _cool_rate,
"purchase time" : _purchase_time ]);
} /* query_dynamic_auto_load() */
/**
* @ignore yes
*/
void init_dynamic_arg( mapping map, object ){
if ( !mapp( map ) ) return;
if ( map[ "::" ] ) ::init_dynamic_arg( map[ "::" ] );
_cool_level = map[ "cool_level" ];
_cool_rate = map[ "cool rate" ];
_purchase_time = map [ "purchase time" ];
} /* init_dynamic_arg() */
/*
* This is all masked stuff from /obj/food.c which stops
* hot food from decaying while it's still hot.
*/
/*
* Food wont decay untill it's cold. Then it decays in normal fashion.
*/
/**
* @ignore yes
*/
void do_decay() {
if (this_object()->query_cool_level()>1) return;
::do_decay();
} /* do_decay */
/**
* @ignore yes
*/
int query_decays() {
if (this_object()->query_cool_level()>1) return 0;
return 1;
} /* query_decays() */
/**
* @ignore yes
*/
int query_decay_speed() {
if (this_object()->query_cool_level()>1) return 0;
return (::query_decay_speed());
} /* query_decay_speed() */
/**
* @ignore yes
*/
int query_decay_level() {
if (this_object()->query_cool_level()>1) return 0;
return (::query_decay_level());
} /* query_decay_level() */
/**
* @ignore yes
*/
void set_decay_speed( int decay ) {
if (this_object()->query_cool_level()>1) return( ::set_decay_speed( 0 ) );
return( ::set_decay_speed( 7200 ) );
} /* set_decay_speed() */
/* Mask set_main_plural() cos it breaks the short descriptions if its been
* set, so we leave it to the pluralizer to sort out. If it turns out this
* messes things up too much for object names then it will need to be modified
* to mask the values returned by query_multiple_short(). Yes it's a hack,
* but the best I could do at the time.
*/
/**
* @ignore yes
*/
void set_main_plural(mixed str) {
return;
}
