/** Assemble an NMEA GPRMC message and send it out NMEA USARTs. * NMEA RMC contains minimum GPS data * * \param nav_meas Pointer to navigation_measurement struct. * \param soln Pointer to gnss_solution struct * \param gps_t Pointer to the current GPS Time */ void nmea_gprmc(const navigation_measurement_t *nav_meas, const gnss_solution *soln, const gps_time_t *gps_t) { /* NMEA Parameters * Ex. * $GPRMC,220516,A,5133.82,N,00042.24,W,173.8,231.8,130694,004.2,W*70 * | | | | | | | | | | | | | * Command | | Lat N/S | | | | Date Stamp | W/E | * Time (UTC) | Long W/E | True Course | Cksum * Validity (A-OK) Speed Variation * Variation is ignored as we have no way to maintain that information * currently */ time_t unix_t; struct tm t; unix_t = gps2time(*gps_t); gmtime_r(&unix_t, &t); double frac_s = fmod(gps_t->tow, 1.0); s16 lat_deg = R2D * (soln->pos_llh[0]); double lat_min = MINUTES(soln->pos_llh[0]); s16 lon_deg = R2D * (soln->pos_llh[1]); double lon_min = MINUTES(soln->pos_llh[1]); lat_deg = abs(lat_deg); lon_deg = abs(lon_deg); char lat_dir = soln->pos_llh[0] < 0 ? 'S' : 'N'; char lon_dir = soln->pos_llh[1] < 0 ? 'W' : 'E'; float velocity; float x,y,z; x = soln->vel_ned[0]; y = soln->vel_ned[1]; z = soln->vel_ned[2]; float course = atan2(y,x); /* Conversion to magnitue knots */ velocity = MS2KNOTTS(x,y,z); double az, el; wgsecef2azel(nav_meas[0].sat_pos, soln->pos_ecef, &az, &el); char buf[100]; u8 n = sprintf(buf, "$GPRMC,%02d%02d%06.3f,A," /* Command, Time (UTC), Valid */ "%02d%010.7f,%c,%03d%010.7f,%c," /* Lat/Lon */ "%06.2f,%05.1f," /* Speed, Course */ "%02d%02d%02d," /* Date Stamp */ ",", /* Variation */ t.tm_hour, t.tm_min, t.tm_sec + frac_s, lat_deg, lat_min, lat_dir, lon_deg, lon_min, lon_dir, velocity, course * R2D, t.tm_mday, t.tm_mon, t.tm_year-100); u8 sum = nmea_checksum(buf); sprintf(buf + n, "*%02X\r\n", sum); nmea_output(buf); }
void starttourn(void) { int i, j; struct planet *pl; char s[80]; opentlog(); for (i = 0, pl = &planets[i]; i < NUMPLANETS; i++, pl++) { for (j = 0; j < MAXTEAM + 1; j++) { pl->pl_tinfo[j].timestamp = 0; /* doesn't work? */ pl->pl_hinfo = (PL_TYPE(*pl) == PLSTAR) ? ALLTEAM : pl->pl_owner; } } status->clock = 0; explode_everyone(KTOURNSTART, 0); tlog_all(); status2->league++; status2->leagueticksleft = MINUTES(configvals->regulation_minutes); /* version team names configured time date */ pmessage(" ", 0, MALL, UMPIRE); sprintf(s, "Timer started -- %d minutes remaining", status2->leagueticksleft / MINUTES(1)); pmessage(s, 0, MALL, UMPIRE); pmessage(" ", 0, MALL, UMPIRE); }
void timestr( struct timeval *tv, char *ts, size_t size, int format) { double usec = (double)tv->tv_usec / 1000000.0; if (format & TERSE_FIXED_TIME) { if (!HOURS(tv->tv_sec)) { snprintf(ts, size, "%u:%02u.%02u", (unsigned int) MINUTES(tv->tv_sec), (unsigned int) SECONDS(tv->tv_sec), (unsigned int) (usec * 100)); return; } format |= VERBOSE_FIXED_TIME; /* fallback if hours needed */ } if ((format & VERBOSE_FIXED_TIME) || tv->tv_sec) { snprintf(ts, size, "%u:%02u:%02u.%02u", (unsigned int) HOURS(tv->tv_sec), (unsigned int) MINUTES(tv->tv_sec), (unsigned int) SECONDS(tv->tv_sec), (unsigned int) (usec * 100)); } else { snprintf(ts, size, "0.%04u sec", (unsigned int) (usec * 10000)); } }
int recipe::print_time( WINDOW *w, int ypos, int xpos, int width, nc_color col, int batch ) const { const int turns = batch_time( batch ) / 100; std::string text; if( turns < MINUTES( 1 ) ) { const int seconds = std::max( 1, turns * 6 ); text = string_format( ngettext( "%d second", "%d seconds", seconds ), seconds ); } else { const int minutes = ( turns % HOURS( 1 ) ) / MINUTES( 1 ); const int hours = turns / HOURS( 1 ); if( hours == 0 ) { text = string_format( ngettext( "%d minute", "%d minutes", minutes ), minutes ); } else if( minutes == 0 ) { text = string_format( ngettext( "%d hour", "%d hours", hours ), hours ); } else { const std::string h = string_format( ngettext( "%d hour", "%d hours", hours ), hours ); const std::string m = string_format( ngettext( "%d minute", "%d minutes", minutes ), minutes ); //~ A time duration: first is hours, second is minutes, e.g. "4 hours" "6 minutes" text = string_format( _( "%1$s and %2$s" ), h.c_str(), m.c_str() ); } } text = string_format( _( "Time to complete: %s" ), text.c_str() ); return fold_and_print( w, ypos, xpos, width, col, text ); }
std::string to_string( const time_duration &d ) { const int turns = to_turns<int>( d ); int divider = 0; if( turns > MINUTES( 1 ) && turns < calendar::INDEFINITELY_LONG ) { if( turns < HOURS( 1 ) ) { divider = MINUTES( 1 ); } else if( turns < DAYS( 1 ) ) { divider = HOURS( 1 ); } else { divider = DAYS( 1 ); } } const int remainder = divider ? turns % divider : 0; if( remainder != 0 ) { //~ %1$s - greater units of time (e.g. 3 hours), %2$s - lesser units of time (e.g. 11 minutes). return string_format( _( "%1$s and %2$s" ), to_string_clipped( time_duration::from_turns( turns ) ), to_string_clipped( time_duration::from_turns( remainder ) ) ); } return to_string_clipped( d ); }
////// Funnels. weather_sum sum_conditions( const calendar &startturn, const calendar &endturn, const tripoint &location ) { int tick_size = MINUTES(1); weather_sum data; for( calendar turn(startturn); turn < endturn; turn += tick_size ) { const int diff = endturn - startturn; if( diff <= 0 ) { return data; } else if( diff < 10 ) { tick_size = 1; } else if( diff > DAYS(7) ) { tick_size = HOURS(1); } else { tick_size = MINUTES(1); } const auto wtype = g->weather_gen->get_weather_conditions( point( location.x, location.y ), turn ); proc_weather_sum( wtype, data, turn, tick_size ); } return data; }
mon_id MonsterGroupManager::GetMonsterFromGroup( std::string group, std::vector <mtype*> *mtypes, int *quantity, int turn ) { int roll = rng(1, 1000); MonsterGroup g = monsterGroupMap[group]; for (FreqDef_iter it = g.monsters.begin(); it != g.monsters.end(); ++it) { if((turn == -1 || (turn + 900 >= MINUTES(STARTING_MINUTES) + HOURS((*mtypes)[it->first]->difficulty))) && (!OPTIONS["CLASSIC_ZOMBIES"] || (*mtypes)[it->first]->in_category(MC_CLASSIC) || (*mtypes)[it->first]->in_category(MC_WILDLIFE))) { //Not too hard for us (or we dont care) if(it->second.first >= roll) { if( quantity) { *quantity -= it->second.second; } return it->first; } else { roll -= it->second.first; } } } if ((turn + 900 < MINUTES(STARTING_MINUTES) + HOURS((*mtypes)[g.defaultMonster]->difficulty)) && (!OPTIONS["STATIC_SPAWN"])) { return mon_null; } else { return g.defaultMonster; } }
/** Assemble a NMEA GPGGA message and send it out NMEA USARTs. * NMEA GPGGA message contains Global Positioning System Fix Data. * * \param soln Pointer to gnss_solution struct. * \param dops Pointer to dops_t struct. */ void nmea_gpgga(const double pos_llh[3], const gps_time_t *gps_t, u8 n_used, u8 fix_type, double hdop) { time_t unix_t; struct tm t; unix_t = gps2time(*gps_t); gmtime_r(&unix_t, &t); double frac_s = fmod(gps_t->tow, 1.0); s16 lat_deg = R2D * (pos_llh[0]); double lat_min = MINUTES(pos_llh[0]); s16 lon_deg = R2D * (pos_llh[1]); double lon_min = MINUTES(pos_llh[1]); lat_deg = abs(lat_deg); lon_deg = abs(lon_deg); char lat_dir = pos_llh[0] < 0 ? 'S' : 'N'; char lon_dir = pos_llh[1] < 0 ? 'W' : 'E'; NMEA_SENTENCE_START(120); NMEA_SENTENCE_PRINTF("$GPGGA,%02d%02d%06.3f," "%02d%010.7f,%c,%03d%010.7f,%c," "%01d,%02d,%.1f,%.2f,M,,M,,", t.tm_hour, t.tm_min, t.tm_sec + frac_s, lat_deg, lat_min, lat_dir, lon_deg, lon_min, lon_dir, fix_type, n_used, hdop, pos_llh[2] ); NMEA_SENTENCE_DONE(); }
std::string calendar::print_duration( int turns ) { std::string res; if( turns < MINUTES( 1 ) ) { int sec = std::max( 1, turns * 6 ); res += string_format( ngettext( "%d second", "%d seconds", sec ), sec ); } else if( turns < HOURS( 1 ) ) { int min = turns / MINUTES( 1 ); int sec = turns % MINUTES( 1 ); res += string_format( ngettext( "%d minute", "%d minutes", min ), min ); if( sec ) { res += string_format( ngettext( " and %d second", " and %d seconds", sec ), sec ); } } else if( turns < DAYS( 1 ) ) { int hour = turns / HOURS( 1 ); int min = turns % HOURS( 1 ); res += string_format( ngettext( "%d hour", "%d hours", hour ), hour ); if( min ) { res += string_format( ngettext( " and %d minute", " and %d minutes", min ), min ); } } else { int day = turns / DAYS( 1 ); int hour = turns % DAYS( 1 ); res += string_format( ngettext( "%d day", "%d days", day ), day ); if( hour ) { res += string_format( ngettext( " and %d hour", " and %d hours", hour ), hour ); } } return res; }
/** Assemble an NMEA GPGLL message and send it out NMEA USARTs. * NMEA GLL contains course and speed * * \param soln Pointer to gnss_solution struct * \param gpt_t Pointer to the current GPS Time */ void nmea_gpgll(const gnss_solution *soln, const gps_time_t *gps_t) { /* NMEA Parameters for GPGLL * Ex. * $GPGLL,5133.81,N,00042.25,W,225444,A*75 * | | | | | | | * Command | N/S Lon E/W | Valid * LAT UTC */ time_t unix_t; struct tm t; unix_t = gps2time(*gps_t); gmtime_r(&unix_t, &t); double frac_s = fmod(gps_t->tow, 1.0); s16 lat_deg = R2D * (soln->pos_llh[0]); double lat_min = MINUTES(soln->pos_llh[0]); s16 lon_deg = R2D * (soln->pos_llh[1]); double lon_min = MINUTES(soln->pos_llh[1]); lat_deg = abs(lat_deg); lon_deg = abs(lon_deg); char lat_dir = soln->pos_llh[0] < 0 ? 'S' : 'N'; char lon_dir = soln->pos_llh[1] < 0 ? 'W' : 'E'; NMEA_SENTENCE_START(120); NMEA_SENTENCE_PRINTF("$GPGLL," "%02d%010.7f,%c,%03d%010.7f,%c," /* Lat/Lon */ "%02d%02d%06.3f,A", /* Time (UTC), Valid */ lat_deg, lat_min, lat_dir, lon_deg, lon_min, lon_dir, t.tm_hour, t.tm_min, t.tm_sec + frac_s); NMEA_SENTENCE_DONE(); }
/** Assemble an NMEA GPRMC message and send it out NMEA USARTs. * NMEA RMC contains minimum GPS data * * \param soln Pointer to gnss_solution struct * \param gps_t Pointer to the current GPS Time */ void nmea_gprmc(const gnss_solution *soln, const gps_time_t *gps_t) { /* NMEA Parameters * Ex. * $GPRMC,220516,A,5133.82,N,00042.24,W,173.8,231.8,130694,004.2,W*70 * | | | | | | | | | | | | | * Command | | Lat N/S | | | | Date Stamp | W/E | * Time (UTC) | Long W/E | True Course | Cksum * Validity (A-OK) Speed Variation * Variation is ignored as we have no way to maintain that information * currently */ time_t unix_t; struct tm t; unix_t = gps2time(*gps_t); gmtime_r(&unix_t, &t); double frac_s = fmod(gps_t->tow, 1.0); s16 lat_deg = R2D * (soln->pos_llh[0]); double lat_min = MINUTES(soln->pos_llh[0]); s16 lon_deg = R2D * (soln->pos_llh[1]); double lon_min = MINUTES(soln->pos_llh[1]); lat_deg = abs(lat_deg); lon_deg = abs(lon_deg); char lat_dir = soln->pos_llh[0] < 0 ? 'S' : 'N'; char lon_dir = soln->pos_llh[1] < 0 ? 'W' : 'E'; float velocity; float x,y,z; x = soln->vel_ned[0]; y = soln->vel_ned[1]; z = soln->vel_ned[2]; float course = atan2(y,x); /* Conversion to magnitue knots */ velocity = MS2KNOTTS(x,y,z); NMEA_SENTENCE_START(140); NMEA_SENTENCE_PRINTF( "$GPRMC,%02d%02d%06.3f,A," /* Command, Time (UTC), Valid */ "%02d%010.7f,%c,%03d%010.7f,%c," /* Lat/Lon */ "%06.2f,%05.1f," /* Speed, Course */ "%02d%02d%02d," /* Date Stamp */ ",", /* Variation */ t.tm_hour, t.tm_min, t.tm_sec + frac_s, lat_deg, lat_min, lat_dir, lon_deg, lon_min, lon_dir, velocity, course * R2D, t.tm_mday, t.tm_mon + 1, t.tm_year % 100); NMEA_SENTENCE_DONE(); }
std::string calendar::print_approx_duration( int turns, bool verbose ) { const auto make_result = [verbose]( int turns, const char *verbose_str, const char *short_str ) { return string_format( verbose ? verbose_str : short_str, print_clipped_duration( turns ).c_str() ); }; int divider = 0; int vicinity = 0; if( turns > DAYS( 1 ) ) { divider = DAYS( 1 ); vicinity = HOURS( 2 ); } else if( turns > HOURS( 1 ) ) { divider = HOURS( 1 ); vicinity = MINUTES( 5 ); } // Minutes and seconds can be estimated precisely. if( divider != 0 ) { const int remainder = turns % divider; if( remainder >= divider - vicinity ) { turns += divider; } else if( remainder > vicinity ) { if( remainder < divider / 2 ) { //~ %s - time (e.g. 2 hours). return make_result( turns, _( "more than %s" ), ">%s" ); } else { //~ %s - time (e.g. 2 hours). return make_result( turns + divider, _( "less than %s" ), "<%s" ); } } } //~ %s - time (e.g. 2 hours). return make_result( turns, _( "about %s" ), "%s" ); }
void activity_handlers::vibe_do_turn( player_activity *act, player *p ) { //Using a vibrator takes time, not speed act->moves_left -= 100; item &vibrator_item = p->i_at(act->position); if( (p->is_wearing("rebreather")) || (p->is_wearing("rebreather_xl")) || (p->is_wearing("mask_h20survivor")) ) { act->moves_left = 0; add_msg(m_bad, _("You have trouble breathing, and stop.")); } //Deduct 1 battery charge for every minute using the vibrator if( calendar::once_every(MINUTES(1)) ) { vibrator_item.charges--; p->add_morale(MORALE_FEELING_GOOD, 4, 320); //4 points/min, one hour to fill // 1:1 fatigue:morale ratio, so maxing the morale is possible but will take // you pretty close to Dead Tired from a well-rested state. p->fatigue += 4; } if( vibrator_item.charges == 0 ) { act->moves_left = 0; add_msg(m_info, _("The %s runs out of batteries."), vibrator_item.tname().c_str()); } if( p->fatigue >= DEAD_TIRED ) { // Dead Tired: different kind of relaxation needed act->moves_left = 0; add_msg(m_info, _("You're too tired to continue.")); } // Vibrator requires that you be able to move around, stretch, etc, so doesn't play // well with roots. Sorry. :-( p->pause(); }
void calendar::sync() { year = turn_number / year_turns(); season = season_type(turn_number / DAYS(season_length()) % 4); day = turn_number / DAYS(1) % season_length(); hour = turn_number / HOURS(1) % 24; minute = turn_number / MINUTES(1) % 60; second = (turn_number * 6) % 60; }
void calendar::sync() { const int sl = season_length(); year = turn_number / DAYS(sl * 4); season = season_type(turn_number / DAYS(sl) % 4); day = turn_number / DAYS(1) % sl; hour = turn_number / HOURS(1) % 24; minute = turn_number / MINUTES(1) % 60; second = (turn_number * 6) % 60; }
const char * timestr(int t) { static char s[80]; if (DAY(t) > 0) (void)snprintf(s, sizeof s, "%dd+%02dhrs", DAY(t), HOUR(t)); else if (HOUR(t) > 0) (void)snprintf(s, sizeof s, "%d:%02d:%02d", HOUR(t), MINUTES(t), SEC(t)); else if (MINUTES(t) > 0) (void)snprintf(s, sizeof s, "%d:%02d", MINUTES(t), SEC(t)); else if (SEC(t) > 0) (void)snprintf(s, sizeof s, ":%02d", SEC(t)); else *s = '\0'; return (s); }
/** Assemble a NMEA GPGGA message and send it out NMEA USARTs. * NMEA GPGGA message contains Global Positioning System Fix Data. * * \param soln Pointer to gnss_solution struct. * \param dops Pointer to dops_t struct. */ void nmea_gpgga(const double pos_llh[3], const gps_time_t *gps_t, u8 n_used, u8 fix_type, double hdop) { time_t unix_t; struct tm t; unix_t = gps2time(*gps_t); gmtime_r(&unix_t, &t); double frac_s = fmod(gps_t->tow, 1.0); s16 lat_deg = R2D * (pos_llh[0]); double lat_min = MINUTES(pos_llh[0]); s16 lon_deg = R2D * (pos_llh[1]); double lon_min = MINUTES(pos_llh[1]); lat_deg = abs(lat_deg); lon_deg = abs(lon_deg); char lat_dir = pos_llh[0] < 0 ? 'S' : 'N'; char lon_dir = pos_llh[1] < 0 ? 'W' : 'E'; char buf[80]; u8 n = sprintf(buf, "$GPGGA,%02d%02d%06.3f," "%02d%010.7f,%c,%03d%010.7f,%c," "%01d,%02d,%.1f,%.2f,M,,M,,", t.tm_hour, t.tm_min, t.tm_sec + frac_s, lat_deg, lat_min, lat_dir, lon_deg, lon_min, lon_dir, fix_type, n_used, hdop, pos_llh[2] ); u8 sum = nmea_checksum(buf); sprintf(buf + n, "*%02X\r\n", sum); nmea_output(buf); }
/** Assemble an NMEA GPGLL message and send it out NMEA USARTs. * NMEA GLL contains course and speed * * \param soln Pointer to gnss_solution struct * \param gpt_t Pointer to the current GPS Time */ void nmea_gpgll(const gnss_solution *soln, const gps_time_t *gps_t) { /* NMEA Parameters for GPGLL * Ex. * $GPGLL,5133.81,N,00042.25,W,225444,A*75 * | | | | | | | * Command | N/S Lon E/W | Valid * LAT UTC */ time_t unix_t; struct tm t; unix_t = gps2time(*gps_t); gmtime_r(&unix_t, &t); double frac_s = fmod(gps_t->tow, 1.0); s16 lat_deg = R2D * (soln->pos_llh[0]); double lat_min = MINUTES(soln->pos_llh[0]); s16 lon_deg = R2D * (soln->pos_llh[1]); double lon_min = MINUTES(soln->pos_llh[1]); lat_deg = abs(lat_deg); lon_deg = abs(lon_deg); char lat_dir = soln->pos_llh[0] < 0 ? 'S' : 'N'; char lon_dir = soln->pos_llh[1] < 0 ? 'W' : 'E'; char buf[80]; u8 n = sprintf(buf, "$GPGLL," "%02d%010.7f,%c,%03d%010.7f,%c," /* Lat/Lon */ "%02d%02d%06.3f,A", /* Time (UTC), Valid */ lat_deg, lat_min, lat_dir, lon_deg, lon_min, lon_dir, t.tm_hour, t.tm_min, t.tm_sec + frac_s); u8 sum = nmea_checksum(buf); sprintf(buf + n, "*%02X\r\n", sum); nmea_output(buf); }
std::string calendar::print_duration( int turns ) { int divider = 0; if( turns > MINUTES( 1 ) && turns < INDEFINITELY_LONG ) { if( turns < HOURS( 1 ) ) { divider = MINUTES( 1 ); } else if( turns < DAYS( 1 ) ) { divider = HOURS( 1 ); } else { divider = DAYS( 1 ); } } const int remainder = divider ? turns % divider : 0; if( remainder != 0 ) { //~ %1$s - greater units of time (e.g. 3 hours), %2$s - lesser units of time (e.g. 11 minutes). return string_format( _( "%1$s and %2$s" ), print_clipped_duration( turns ).c_str(), print_clipped_duration( remainder ).c_str() ); } return print_clipped_duration( turns ); }
void udtourny(void) { int trem; char buf[120]; if (!status2->league) return; /* server is configured for league play */ if (status2->league == 1) return; /* we're still prepping */ trem = --status2->leagueticksleft; switch (status2->league) { case 2: /* the 1-minute pre tourney warm up. */ if (trem == SECONDS(5)) pmessage("5 seconds to tournament start", -1, MALL, UMPIRE); else if (trem == SECONDS(2)) pmessage("Hold on to your hats. Everybody dies!", -1, MALL, UMPIRE); else if (trem <= 0) { starttourn(); } break; case 3: /* full-on T-mode */ buf[0] = 0; if (trem % MINUTES(20) == 0 || (trem < MINUTES(20) && 0 == trem % MINUTES(5)) || (trem < MINUTES(5) && 0 == trem % MINUTES(1))) { sprintf(buf, "There are %d minutes remaining in regulation play", trem / MINUTES(1)); } else if (trem < MINUTES(1) && 0 == trem % SECONDS(10)) { sprintf(buf, "There are %d seconds remaining in regulation play", trem / SECONDS(1)); } if (buf[0]) pmessage(buf, -1, MALL, UMPIRE); if (trem <= 0) /* maybe go into overtime */ endtourn(); break; case 4: /* overtime, not implemented */ break; } }
std::string construction::get_time_string() const { const int turns = adjusted_time() / 100; std::string text; if( turns < MINUTES( 1 ) ) { const int seconds = std::max( 1, turns * 6 ); text = string_format( ngettext( "%d second", "%d seconds", seconds ), seconds ); } else { const int minutes = ( turns % HOURS( 1 ) ) / MINUTES( 1 ); const int hours = turns / HOURS( 1 ); if( hours == 0 ) { text = string_format( ngettext( "%d minute", "%d minutes", minutes ), minutes ); } else if( minutes == 0 ) { text = string_format( ngettext( "%d hour", "%d hours", hours ), hours ); } else { const std::string h = string_format( ngettext( "%d hour", "%d hours", hours ), hours ); const std::string m = string_format( ngettext( "%d minute", "%d minutes", minutes ), minutes ); //~ A time duration: first is hours, second is minutes, e.g. "4 hours" "6 minutes" text = string_format( _( "%1$s and %2$s" ), h.c_str(), m.c_str() ); } } text = string_format( _( "Time to complete: %s" ), text.c_str() ); return text; }
int ween_time_is_valid(ween_time_constraint_t *c, size_t n) { time_t now = time(NULL); struct tm tm; size_t i; if (! localtime_r(&now, &tm)) { return true; } for (i = 0; i < n; i++) { if (day_is_valid(&tm, c[i].within_days_of)) { unsigned now = MINUTES(tm.tm_hour, tm.tm_min); unsigned start = MINUTES(c[i].start_h, c[i].start_m); unsigned end = MINUTES(c[i].end_h, c[i].end_m); if (start <= now && now < end) { return true; } } } return false; }
void calendar::sync() { const int sl = season_length(); year = turn_number / DAYS(sl * 4); if( eternal_season ) { season = initial_season; } else { season = season_type(turn_number / DAYS(sl) % 4); } day = turn_number / DAYS(1) % sl; hour = turn_number / HOURS(1) % 24; minute = turn_number / MINUTES(1) % 60; second = (turn_number * 6) % 60; }
mon_id MonsterGroupManager::GetMonsterFromGroup(std::string group, std::vector <mtype*> *mtypes, int turn) { int roll = rng(1, 1000); MonsterGroup g = monsterGroupMap[group]; for (FreqDef_iter it = g.monsters.begin(); it != g.monsters.end(); ++it) { if((turn == -1 || (turn + 900 >= MINUTES(STARTING_MINUTES) + (*mtypes)[it->first]->difficulty)) && (!OPTIONS[OPT_CLASSIC_ZOMBIES] || (*mtypes)[it->first]->in_category(MC_CLASSIC) || (*mtypes)[it->first]->in_category(MC_WILDLIFE))) { //Not too hard for us (or we dont care) if(it->second >= roll) return it->first; else roll -= it->second; } } return g.defaultMonster; }
/* internal public functions ================================================ */ void vBatInit (void) { vBatChargeInit(); vAdcInit(); if (xTaskProcess == 0) { xTaskProcess = xTaskCreate ( xTaskConvertMs (MINUTES(BAT_PROCESS_INTERVAL_MIN)), prvvTaskProcess); } if (xTaskMonitor == 0) { xTaskMonitor = xTaskCreate (xTaskConvertMs (BAT_MONITOR_INTERVAL_MS), prvvTaskMonitor); } prvvSetToIdle(); vTaskStart (xTaskMonitor); }
void calendar::sync() { const int sl = to_days<int>( season_length() ); year = turn_number / DAYS(sl * 4); if( eternal_season() ) { // If we use calendar::start to determine the initial season, and the user shortens the season length // mid-game, the result could be the wrong season! season = initial_season; } else { season = season_type(turn_number / DAYS(sl) % 4); } day = turn_number / DAYS(1) % sl; hour = turn_number / HOURS(1) % 24; minute = turn_number / MINUTES(1) % 60; second = (turn_number * 6) % 60; }
void activity_handlers::burrow_do_turn(player_activity *act, player *p) { if( calendar::turn % MINUTES(1) == 0 ) { // each turn is too much //~ Sound of a Rat mutant burrowing! sounds::sound( act->placement, 10, _("ScratchCrunchScrabbleScurry.") ); if( act->moves_left <= 91000 && act->moves_left > 89000 ) { p->add_msg_if_player(m_info, _("You figure it'll take about an hour and a half at this rate.")); } if( act->moves_left <= 71000 && act->moves_left > 69000 ) { p->add_msg_if_player(m_info, _("About an hour left to go.")); } if( act->moves_left <= 31000 && act->moves_left > 29000 ) { p->add_msg_if_player(m_info, _("Shouldn't be more than half an hour or so now!")); } if( act->moves_left <= 11000 && act->moves_left > 9000 ) { p->add_msg_if_player(m_info, _("Almost there! Ten more minutes of work and you'll be through.")); } } }
std::string calendar::print_clipped_duration( int turns ) { if( turns >= INDEFINITELY_LONG ) { return _( "forever" ); } if( turns < MINUTES( 1 ) ) { const int sec = FULL_SECONDS_IN( turns ); return string_format( ngettext( "%d second", "%d seconds", sec ), sec ); } else if( turns < HOURS( 1 ) ) { const int min = FULL_MINUTES_IN( turns ); return string_format( ngettext( "%d minute", "%d minutes", min ), min ); } else if( turns < DAYS( 1 ) ) { const int hour = FULL_HOURS_IN( turns ); return string_format( ngettext( "%d hour", "%d hours", hour ), hour ); } const int day = FULL_DAYS_IN( turns ); return string_format( ngettext( "%d day", "%d days", day ), day ); }
void calendar::sync() { const int sl = season_length(); year = turn_number / DAYS(sl * 4); static const std::string eternal = "ETERNAL_SEASON"; if( get_option<bool>( eternal ) ) { // If we use calendar::start to determine the initial season, and the user shortens the season length // mid-game, the result could be the wrong season! season = initial_season; } else { season = season_type(turn_number / DAYS(sl) % 4); } day = turn_number / DAYS(1) % sl; hour = turn_number / HOURS(1) % 24; minute = turn_number / MINUTES(1) % 60; second = (turn_number * 6) % 60; }
void activity_handlers::game_do_turn( player_activity *act, player *p ) { //Gaming takes time, not speed act->moves_left -= 100; item &game_item = p->i_at(act->position); //Deduct 1 battery charge for every minute spent playing if( calendar::once_every(MINUTES(1)) ) { game_item.charges--; p->add_morale(MORALE_GAME, 1, 100); //1 points/min, almost 2 hours to fill } if( game_item.charges == 0 ) { act->moves_left = 0; add_msg(m_info, _("The %s runs out of batteries."), game_item.tname().c_str()); } p->rooted(); p->pause(); }