src/clock.c

   1 //
   2 // nazghul - an old-school RPG engine
   3 // Copyright (C) 2002, 2003 Gordon McNutt
   4 //
   5 // Thi program is free software; you can redistribute it and/or modify it
   6 // under the terms of the GNU General Public License as published by the Free
   7 // Software Foundation; either version 2 of the License, or (at your option)
   8 // any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful, but WITHOUT
  11 // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13 // more details.
  14 //
  15 // You should have received a copy of the GNU General Public License along with
  16 // this program; if not, write to the Free Foundation, Inc., 59 Temple Place,
  17 // Suite 330, Boston, MA 02111-1307 USA
  18 //
  19 // Gordon McNutt
  20 // gmcnutt@users.sourceforge.net
  21 //
  22 #include "sky.h"
  23 #include "clock.h"
  24 #include "screen.h"
  25 #include "common.h"
  26 #include "sprite.h"
  27 #include "place.h"
  28 #include "map.h"
  29 #include "player.h"
  30 #include "wq.h"
  31 #include "session.h"
  32
  33 #include <assert.h>
  34 #include <math.h>
  35
  36 #define Clock (Session->clock)
  37
  38 int clock_year(void)
  39 {
  40         return Clock.year;
  41 }
  42
  43 int clock_month(void)
  44 {
  45         return Clock.month;
  46 }
  47
  48 int clock_week(void)
  49 {
  50         return Clock.week;
  51 }
  52
  53 int clock_day(void)
  54 {
  55         return Clock.day;
  56 }
  57
  58 int clock_hour(void)
  59 {
  60         return Clock.hour;
  61 }
  62
  63 int clock_minute(void)
  64 {
  65         return Clock.min;
  66 }
  67
  68 int clock_tick(void)
  69 {
  70         return Clock.tick;
  71 }
  72
  73 unsigned int clock_time_of_day(void)
  74 {
  75         return (Clock.hour * 60 + Clock.min);
  76 }
  77
  78 unsigned int clock_time(void)
  79 {
  80         return Clock.total_minutes;
  81 }
  82
  83 void clock_advance(int ticks)
  84 {
  85         assert(Clock.tick < Clock.tick_to_change_time);
  86
  87         while (ticks-- > 0) {
  88
  89                 Clock.tick++;
  90
  91                 if (Clock.tick == Clock.tick_to_change_time) {
  92
  93                         Clock.total_minutes++;
  94                         Clock.tick = 0;
  95                         Clock.tick_to_change_time = CLOCK_TICKS_PER_MINUTE;
  96
  97                         Clock.min++;
  98                         if (Clock.min == MINUTES_PER_HOUR) {
  99                                 Clock.hour++;
 100                                 Clock.min = 0;
 101                                 if (Clock.hour == HOURS_PER_DAY) {
 102                                         Clock.day++;
 103                                         Clock.hour = 0;
 104                                         if (Clock.day == DAYS_PER_WEEK) {
 105                                                 Clock.week++;
 106                                                 Clock.day = 0;
 107                                                 if (Clock.week == WEEKS_PER_MONTH) {
 108                                                         Clock.month++;
 109                                                         Clock.week = 0;
 110                                                         if (Clock.month == MONTHS_PER_YEAR) {
 111                                                                 Clock.year++;
 112                                                                 Clock.month = 0;
 113                                                         }
 114                                                 }
 115                                         }
 116                                 }
 117                         }
 118                 }
 119         }
 120
 121         mapRepaintClock();
 122 }
 123
 124 char *time_HHMM_as_string(void)
 125 {
 126         static char str[] = "HH:MMPM";
 127         static int maxlen = strlen("HH:MMPM") + 1;
 128         int hr = Clock.hour;
 129         int min = Clock.min;
 130         int n;
 131
 132         hr = (hr > 12) ? (hr - 12) : hr;
 133         hr = (hr == 0) ? 12 : hr;
 134
 135         n = snprintf(str, maxlen, "%2d:%02d%2s",
 136                      hr, min, (Clock.hour >= 12) ? "PM" : "AM");
 137         assert(n != -1);
 138         return str;
 139 }                               // time_HHMM_as_string()
 140
 141 char *vague_time_as_string(void)
 142 {
 143         static char str[] = "late afternoon";
 144         static int maxlen = strlen("late afternoon") + 1;
 145         int hr = Clock.hour;
 146         int n;
 147
 148         if (hr < 4)
 149         {
 150                 n = snprintf(str, maxlen, "night");
 151         }
 152         else if (hr < 7)
 153         {
 154                 n = snprintf(str, maxlen, "early morning");
 155         }
 156         else if (hr < 11)
 157         {
 158                 n = snprintf(str, maxlen, "morning");
 159         }
 160         else if (hr < 13)
 161         {
 162                 n = snprintf(str, maxlen, "noon");
 163         }
 164         else if (hr < 15)
 165         {
 166                 n = snprintf(str, maxlen, "afternoon");
 167         }
 168         else if (hr < 18)
 169         {
 170                 n = snprintf(str, maxlen, "late afternoon");
 171         }
 172         else if (hr < 20)
 173         {
 174                 n = snprintf(str, maxlen, "evening");
 175         }
 176         else
 177         {
 178                 n = snprintf(str, maxlen, "night");
 179         }
 180         assert(n != -1);
 181         return str;
 182 }                               // vague_time_as_string()
 183
 184 char *time_YYYY_MM_DD_as_string(void)
 185 {
 186         static char str[] = "YYYY/MM/DD";
 187         static int maxlen = strlen("YYYY/MM/DD") + 1;
 188         int n = snprintf(str, maxlen, "%04d/%02d/%02d",
 189                          Clock.year, Clock.month, Clock.day);
 190         assert(n != -1);
 191         return str;
 192 }                               // time_YYYY_MM_DD_as_string()
 193
 194 #ifdef OTHER_TIME_STRING_FUNCTIONS
 195 char *time_YYYY_as_string(void)
 196 {
 197         static char str[] = "YYYY";
 198         static int maxlen = strlen("YYYY") + 1;
 199         int n = snprintf(str, maxlen, "%4d", Clock.year);
 200         assert(n != -1);
 201         return str;
 202 }
 203
 204 char *time_MM_as_string(void)
 205 {
 206         static char str[] = "MM";
 207         static int maxlen = strlen("MM") + 1;
 208         int n = snprintf(str, maxlen, "%2d", Clock.month);
 209         assert(n != -1);
 210         return str;
 211 }
 212
 213 char *time_DD_as_string(void)
 214 {
 215         static char str[] = "DD";
 216         static int maxlen = strlen("DD") + 1;
 217         int n = snprintf(str, maxlen, "%2d", Clock.day);
 218         assert(n != -1);
 219         return str;
 220 }
 221 #endif                          // OTHER_TIME_STRING_FUNCTIONS
 222
 223 // SAM:
 224 // A proper implementation of
 225 // month_name(), week_name(), day_name()
 226 // will wait until we have GhulScript
 227 // for week and month names and such.
 228 //
 229 const char *month_name(void)
 230 {
 231         int month = Clock.month;
 232         switch (month) {
 233         case 0:
 234                 return "1st Month";
 235         case 1:
 236                 return "2nd Month";
 237         case 2:
 238                 return "3rd Month";
 239         case 3:
 240                 return "4th Month";
 241         case 4:
 242                 return "5th Month";
 243         case 5:
 244                 return "6th Month";
 245         case 6:
 246                 return "7th Month";
 247         case 7:
 248                 return "8th Month";
 249         case 8:
 250                 return "9th Month";
 251         case 9:
 252                 return "10th Month";
 253         case 10:
 254                 return "11th Month";
 255         case 11:
 256                 return "12th Month";
 257         default:
 258                 assert(0);
 259         }
 260 }                               // month_name()
 261
 262 const char *week_name(void)
 263 {
 264         int week = Clock.week;
 265         switch (week) {
 266         case 0:
 267                 return "1st Week";
 268         case 1:
 269                 return "2nd Week";
 270         case 2:
 271                 return "3rd Week";
 272         case 3:
 273                 return "4th Week";
 274         default:
 275                 assert(0);
 276         }
 277 }                               // week_name()
 278
 279 const char *day_name(void)
 280 {
 281         int day = Clock.day;
 282         switch (day) {
 283         case 0:
 284                 return "1st Day";
 285         case 1:
 286                 return "2nd Day";
 287         case 2:
 288                 return "3rd Day";
 289         case 3:
 290                 return "4th Day";
 291         case 4:
 292                 return "5th Day";
 293         case 5:
 294                 return "6th Day";
 295         case 6:
 296                 return "7th Day";
 297         default:
 298                 assert(0);
 299         }
 300 }                               // day_name()
 301
 302 void clock_alarm_set(clock_alarm_t *alarm, unsigned int minutes)
 303 {
 304         *alarm = Clock.total_minutes + minutes;
 305 }
 306
 307 int clock_alarm_is_expired(clock_alarm_t *alarm)
 308 {
 309         return (Clock.total_minutes >= *alarm);
 310 }
 311
 312 int clock_alarm_remaining(clock_alarm_t *alarm)
 313 {
 314         if (Clock.total_minutes >= *alarm) return 0;
 315         return (*alarm - Clock.total_minutes);
 316 }
 317
 318 int is_noon(void)
 319 {
 320         return (Clock.hour == 12 && Clock.min == 0);
 321 }
 322
 323 int is_midnight(void)
 324 {
 325         return (Clock.hour == 0 && Clock.min == 0);
 326 }
 327
 328 #ifdef INCLUDE_UNUSED_CLOCK_ROUTINES
 329 void clock_reset(struct clock *clock)
 330 {
 331         memset(clock, 0, sizeof(*clock));
 332 }
 333
 334 void clock_set_alarm(struct clock *clock, struct clock *offset)
 335 {
 336
 337         /* Copy the current time */
 338         memcpy(clock, &Clock, sizeof(*clock));
 339
 340         /* Set the alarm to the current time plus the offset */
 341         clock->min += offset->min;
 342         if (clock->min >= MINUTES_PER_HOUR) {
 343                 offset->hour += clock->min / MINUTES_PER_HOUR;
 344                 clock->min %= MINUTES_PER_HOUR;
 345         }
 346
 347         clock->hour += offset->hour;
 348         if (clock->hour >= HOURS_PER_DAY) {
 349                 offset->day += clock->hour / HOURS_PER_DAY;
 350                 clock->hour %= HOURS_PER_DAY;
 351         }
 352
 353         clock->day += offset->day;
 354         if (clock->day >= DAYS_PER_WEEK) {
 355                 offset->week += clock->day / DAYS_PER_WEEK;
 356                 clock->day %= DAYS_PER_WEEK;
 357         }
 358
 359         clock->week += offset->week;
 360         if (clock->week >= WEEKS_PER_MONTH) {
 361                 offset->month += clock->week / WEEKS_PER_MONTH;
 362                 clock->week %= WEEKS_PER_MONTH;
 363         }
 364
 365         clock->month += offset->month;
 366         if (clock->month >= MONTHS_PER_YEAR) {
 367                 offset->year += clock->month / MONTHS_PER_YEAR;
 368                 clock->month %= MONTHS_PER_YEAR;
 369         }
 370
 371         clock->year += offset->year;
 372
 373         consolePrint("Set alarm for year %d, month %d, week %d, day %d, "
 374                      "hour %d, min %d\n", clock->year, clock->month,
 375                      clock->week, clock->day, clock->hour, clock->min);
 376 }
 377
 378 int clock_alarm_expired(struct clock *clock)
 379 {
 380         int total_minute;
 381
 382         total_minute  = (clock->year  - Clock.year)  * MINUTES_PER_YEAR;
 383         total_minute += (clock->month - Clock.month) * MINUTES_PER_MONTH;
 384         total_minute += (clock->week  - Clock.week)  * MINUTES_PER_WEEK;
 385         total_minute += (clock->day   - Clock.day)   * MINUTES_PER_DAY;
 386         total_minute += (clock->hour  - Clock.hour)  * MINUTES_PER_HOUR;
 387         total_minute += (clock->min   - Clock.min);
 388
 389         return (total_minute <= 0);
 390 }
 391 #endif // INCLUDE_UNUSED_CLOCK_ROUTINES