float calendar::sunlight() const
{
const time_duration now = time_past_midnight( *this );
const time_duration sunrise = time_past_midnight( this->sunrise() );
const time_duration sunset = time_past_midnight( this->sunset() );
double daylight_level = current_daylight_level();
int current_phase = int(moon());
if ( current_phase > int(MOON_PHASE_MAX)/2 ) {
current_phase = int(MOON_PHASE_MAX) - current_phase;
}
int moonlight = 1 + int(current_phase * MOONLIGHT_PER_QUARTER);
if( now > sunset + twilight_duration || now < sunrise ) { // Night
return moonlight;
} else if( now >= sunrise && now <= sunrise + twilight_duration ) {
const double percent = ( now - sunrise ) / twilight_duration;
return double(moonlight) * (1. - percent) + daylight_level * percent;
} else if( now >= sunset && now <= sunset + twilight_duration ) {
const double percent = ( now - sunset ) / twilight_duration;
return daylight_level * (1. - percent) + double(moonlight) * percent;
} else {
return daylight_level;
}
}
bool calendar::is_night() const
{
const time_duration now = time_past_midnight( *this );
const time_duration sunrise = time_past_midnight( this->sunrise() );
const time_duration sunset = time_past_midnight( this->sunset() );
return now > sunset + twilight_duration || now < sunrise;
}
std::string to_string_time_of_day( const time_point &p )
{
const int hour = hour_of_day<int>( p );
const int minute = minute_of_hour<int>( p );
// TODO: add a to_seconds function?
const int second = ( to_turns<int>( time_past_midnight( p ) ) * 6 ) % 60;
const std::string format_type = get_option<std::string>( "24_HOUR" );
if( format_type == "military" ) {
return string_format( "%02d%02d.%02d", hour, minute, second );
} else if( format_type == "24h" ) {
//~ hour:minute (24hr time display)
return string_format( _( "%02d:%02d:%02d" ), hour, minute, second );
} else {
int hour_param = hour % 12;
if( hour_param == 0 ) {
hour_param = 12;
}
// Padding is removed as necessary to prevent clipping with SAFE notification in wide sidebar mode
const std::string padding = hour_param < 10 ? " " : "";
if( hour < 12 ) {
return string_format( _( "%d:%02d:%02d%sAM" ), hour_param, minute, second, padding );
} else {
return string_format( _( "%d:%02d:%02d%sPM" ), hour_param, minute, second, padding );
}
}
}
static std::string print_time_just_hour( const time_point &p )
{
const int hour = to_hours<int>( time_past_midnight( p ) );
int hour_param = hour % 12;
if( hour_param == 0 ) {
hour_param = 12;
}
return string_format( hour < 12 ? _( "%d AM" ) : _( "%d PM" ), hour_param );
}
w_point weather_generator::get_weather( const tripoint &location, const time_point &t,
unsigned seed ) const
{
const double x( location.x /
2000.0 ); // Integer x position / widening factor of the Perlin function.
const double y( location.y /
2000.0 ); // Integer y position / widening factor of the Perlin function.
const double z( to_turn<int>( t + calendar::season_length() ) /
2000.0 ); // Integer turn / widening factor of the Perlin function.
const double dayFraction = time_past_midnight( t ) / 1_days;
//limit the random seed during noise calculation, a large value flattens the noise generator to zero
//Windows has a rand limit of 32768, other operating systems can have higher limits
const unsigned modSEED = seed % 32768;
// Noise factors
double T( raw_noise_4d( x, y, z, modSEED ) * 4.0 );
double H( raw_noise_4d( x, y, z / 5, modSEED + 101 ) );
double H2( raw_noise_4d( x, y, z, modSEED + 151 ) / 4 );
double P( raw_noise_4d( x, y, z / 3, modSEED + 211 ) * 70 );
double A( raw_noise_4d( x, y, z, modSEED ) * 8.0 );
double W;
const double now( ( time_past_new_year( t ) + calendar::season_length() / 2 ) /
calendar::year_length() ); // [0,1)
const double ctn( cos( tau * now ) );
// Temperature variation
const double mod_t( 0 ); // TODO: make this depend on latitude and altitude?
const double current_t( base_temperature +
mod_t ); // Current baseline temperature. Degrees Celsius.
const double seasonal_variation( ctn * -1 ); // Start and end at -1 going up to 1 in summer.
const double season_atenuation( ctn / 2 + 1 ); // Harsh winter nights, hot summers.
const double season_dispersion( pow( 2,
ctn + 1 ) - 2.3 ); // Make summers peak faster and winters not perma-frozen.
const double daily_variation( cos( tau * dayFraction - tau / 8 ) * -1 * season_atenuation / 2 +
season_dispersion * -1 ); // Day-night temperature variation.
T += current_t; // Add baseline to the noise.
T += seasonal_variation * 8 * exp( -pow( current_t * 2.7 / 10 - 0.5,
2 ) ); // Add season curve offset to account for the winter-summer difference in day-night difference.
T += daily_variation * 8 * exp( -pow( current_t / 30,
2 ) ); // Add daily variation scaled to the inverse of the current baseline. A very specific and finicky adjustment curve.
T = T * 9 / 5 + 32; // Convert to imperial. =|
// Humidity variation
const double mod_h( 0 );
const double current_h( base_humidity + mod_h );
H = std::max( std::min( ( ctn / 10.0 + ( -pow( H, 2 ) * 3 + H2 ) ) * current_h / 2.0 + current_h,
100.0 ),
0.0 ); // Humidity stays mostly at the mean level, but has low peaks rarely. It's a percentage.
// Pressure variation
P += seasonal_variation * 20 +
base_pressure; // Pressure is mostly random, but a bit higher on summer and lower on winter. In millibars.
// Wind power
W = std::max( 0, 1020 - static_cast<int>( P ) );
// Acid rains
const double acid_content = base_acid * A;
bool acid = acid_content >= 1.0;
return w_point {T, H, P, W, acid};
}
