oldschool-toontown/toontown/ai/HolidayInfoYearly.py
2024-07-14 15:28:28 -05:00

174 lines
7.2 KiB
Python

"""
# File: HolidayInfoYearly.py
# Purpose: Coming Soon...
"""
# Toontown Specific Modules
from toontown.ai.HolidayInfo import *
# Python Specific Modules
import random
import time
import functools
class HolidayInfo_Yearly(HolidayInfo_Base):
"""
Stores all relevant information regarding an event,
such as the type of event.
"""
def __init__(self, holidayClass, dateList, displayOnCalendar):
"""
Purpose: Provides initial construction of the Monthly Holiday
Info object. It generates the list of times that
the holiday should be run every week.
Input: holidayClass - class type of the holiday, for
instance - Fireworks.
dateDict - a dictionary containing the Months,
which each have a dictionary of days with
their corresponding times.
{ Month.JULY: {31: [((9, 0, 0), (12, 0, 0))]} }
Holiday starts at 9am PST and ends at
12pm PST on July 31st of Every Year.
Output: None
"""
HolidayInfo_Base.__init__(self, holidayClass, displayOnCalendar)
dateElemIter = ModifiedIter(dateList)
for i in range(len(dateList)//2):
start = dateElemIter.current()
end = next(dateElemIter)
self.tupleList.append((start, end))
next(dateElemIter)
self.tupleList.sort(key=functools.cmp_to_key(cmpDates))
def getTime(self, date, t):
"""
Purpose: This method returns the time. Overrides the base
definiton of HolidayInfo.
Input: date - the current date represented as a tuple
Output: returns the time in secs based on date and t
"""
# t is of the form (month, day, hour, min, sec)
# date is of the form (year, month, day, weekday)
return time.mktime((date[0], # year
t[0], # month
t[1], # day
t[2], # hour
t[3], # second
t[4], # minute
0,
0,
-1))
def getNextHolidayTime(self, currTime):
"""
Purpose: This method finds the next appropriate time to
start this holiday. It searches through the list
of time tuples, and performs the necessary
computations for finding the time.
Input: currTime - current time
Output: returns the next start time of the holiday
"""
sCurrYear = time.localtime()[0]
eCurrYear = sCurrYear
for i in range(len(self.tupleList)):
sMonth = self.currElemIter.current()[0][0]
nMonth = self.currElemIter.peekNext()[0][0]
startTuple, endTuple = self.currElemIter.peekNext()
# If the end month is less than the start month, it is
# in the proceeding year. Adjust the end year accordingly.
# This assures that the proper time tuple will be chosen from
# the list.
if endTuple[0] < startTuple[0]:
eCurrYear += 1
if sMonth > nMonth:
# The holiday should be scheduled in the
# following year. There are two cases that
# may exist and they follow:
# Case 1: { May: [31], July: [(31)] }
# - Here, we end on July 31. The next
# time the holiday should start is on
# May 31, which would be in the following
# year.
# Case 2: { December: [(31, 1)], May: [31] }
# - Here, we end on January 1 of the new year,
# because this holiday spans from December
# to January. The next time the holiday should
# start is on May 31, which would be in the
# same year.
# Check to see if we are already in the next
# year due to overlapping holiday.
cMonth = time.localtime()[0]
if cMonth > nMonth:
# We have not crossed over into the new week
# as found in case 1.
sTime = self.getTime((sCurrYear+1,), startTuple)
eTime = self.getTime((eCurrYear+1,), endTuple)
else:
# We have already started the new year as found
# in case 2. Adjust time normally.
sTime = self.getTime((sCurrYear,), startTuple)
eTime = self.getTime((eCurrYear,), endTuple)
elif sMonth == nMonth:
sDay = self.currElemIter.current()[0][1]
nDay = self.currElemIter.peekNext()[0][1]
if sDay > nDay:
# Since the next day is less than the current day,
# then we have reached the end of the list and the next
# date should be in the proceeding year.
sTime = self.getTime((sCurrYear+1,), startTuple)
eTime = self.getTime((eCurrYear+1,), endTuple)
elif sDay == nDay:
# Since the next tuple is of the same day, we must check
# the time tuples to see if the next time is greater than
# the current. If it is, that means we have reached the end
# of the list and should go into the next year..
curr = self.currElemIter.current()[0]
time1 = (curr[2], curr[3], curr[4])
time2 = (startTuple[2], startTuple[3], startTuple[4])
if time1 > time2:
sTime = self.getTime((sCurrYear+1,), startTuple)
eTime = self.getTime((eCurrYear+1,), endTuple)
else:
sTime = self.getTime((sCurrYear,), startTuple)
eTime = self.getTime((eCurrYear,), endTuple)
else:
# We have not reached the end of the list, calculate times
# accordingly.
sTime = self.getTime((sCurrYear,), startTuple)
eTime = self.getTime((eCurrYear,), endTuple)
else:
# We have not reached the end of the list, calculate times
# accordingly.
sTime = self.getTime((sCurrYear,), startTuple)
eTime = self.getTime((eCurrYear,), endTuple)
next(self.currElemIter)
if (currTime < eTime):
return sTime
# We are back to the original element, thus we should
# schedule it for the next year.
start = self.currElemIter.current()[0]
return self.getTime((sCurrYear+1,), start)
def adjustDate(self, date):
"""
Purpose: This method adjusts the current day by a year. This
is typically called when an end time is less than
a start time.
Input: date - the date that needs to be adjusted
Output: None
"""
return (date[0]+1, date[1], date[2], date[3])