// Calendar Functions
public virtual TimeStruct DayToCalendar(int day)
{
TimeStruct ts = new TimeStruct();
ts.Date = day;
return(ts);
}
public void ManualUpdate(TimeStruct timeStruct)
{
foreach (var node in m_UpdateCallbacks)
{
node.callback(timeStruct);
}
}
private void UpdateRunningResourceLoadingTasks(TimeStruct timeStruct)
{
foreach (var resourceLoadingTask in m_RunningResourceLoadingTasks)
{
resourceLoadingTask.OnUpdate(timeStruct);
}
}
void UpdateOnInterface()
{
TimeStruct remainingTime = new TimeStruct();
remainingTime.SetTime(Mathf.Max(0, time.GetSeconds() - (int)currentTime));
timerText.text = "Time Left: " + remainingTime.minutes.ToString("00") + ":" + remainingTime.seconds.ToString("00");
}
private void UpdateRunningAssetLoadingTasks(TimeStruct timeStruct)
{
foreach (var assetLoadingTask in m_RunningAssetLoadingTasks)
{
assetLoadingTask.OnUpdate(timeStruct);
}
}
// Calendar Functions
public override TimeStruct DayToCalendar(int day)
{
TimeStruct ts = new TimeStruct();
ts.Date = day;
return(ts);
}
private void UpdateDisplay()
{
display.WriteCentered("Power management", LCDColor.Grey);
display.Write("");
display.WriteCentered("Solar power status", new LCDColor(1, 1, 2));
display.Write(" Currently " + solarState.GetName());
display.Write(" Output: " + SolarDisplay.FormatRatio(solarManager.MaxOutput, solarManager.MaxHistoricalOutput));
display.DrawRatio(solarManager.MaxOutput, solarManager.MaxHistoricalOutput);
display.Write("");
display.Write("");
display.WriteCentered("Main batteries status", new LCDColor(1, 1, 2));
WriteBatteryStatus(mainBatteriesManager);
display.Write("");
display.Write("");
display.WriteCentered("Connected batteries status", new LCDColor(1, 1, 2));
WriteBatteryStatus(connectedBatteriesManager);
display.Write("");
display.Write("");
display.WriteCentered("Time management", new LCDColor(1, 1, 2));
TimeStruct time = dayTracker.GetTime();
display.Write("Time of day: " + time.GetTime().ToString());
display.Write("Length of day: " + time.GetDayLength().ToString());
display.Write(solarManager.GetOutputHistory());
display.Flush();
}
protected override void Update(TimeStruct timeStruct)
{
switch (Status)
{
case AssetCacheStatus.Loading:
if (!string.IsNullOrEmpty(m_LoadingTask.ErrorMessage))
{
ErrorMessage = m_LoadingTask.ErrorMessage;
InternalLog.DebugFormat("[AssetCache Update] {0} loading fail.", Path);
FailAndNotify();
}
else if (m_LoadingTask.IsDone)
{
AssetObject = m_LoadingTask.AssetObject;
InternalLog.DebugFormat("[AssetCache Update] {0} loading success.", Path);
SucceedAndNotify();
}
else
{
if (LoadingProgress != m_LastLoadingProgress)
{
m_LastLoadingProgress = LoadingProgress;
ProgressAndNotify();
}
}
break;
}
}
public void dostounix_Test(int month, int day, int year, int hour, int minute, int second)
{
//Reset State
Reset();
fakeClock.Now = new DateTime(year, month, day, hour, minute, second);
var expectedUnixDate = ((DateTimeOffset)fakeClock.Now).ToUnixTimeSeconds();
var inputDateStruct = new DateStruct(fakeClock.Now);
var inputTimeStruct = new TimeStruct(fakeClock.Now);
//Set Argument Values to be Passed In
var dateStringPointer = mbbsEmuMemoryCore.AllocateVariable("DATE_STRING", (DateStruct.Size));
mbbsEmuMemoryCore.SetArray(dateStringPointer, inputDateStruct.Data);
var timeStringPointer = mbbsEmuMemoryCore.AllocateVariable("TIME_STRING", TimeStruct.Size);
mbbsEmuMemoryCore.SetArray(timeStringPointer, inputTimeStruct.Data);
//Execute Test
ExecuteApiTest(HostProcess.ExportedModules.Majorbbs.Segment, DOSTOUNIX_ORDINAL, new List <FarPtr> {
dateStringPointer, timeStringPointer
});
//Verify Results
Assert.Equal(expectedUnixDate, mbbsEmuCpuRegisters.GetLong());
}
protected override void Update(TimeStruct timeStruct)
{
switch (Status)
{
case ResourceCacheStatus.Loading:
if (!string.IsNullOrEmpty(m_LoadingTask.ErrorMessage))
{
ErrorMessage = m_LoadingTask.ErrorMessage;
InternalLog.DebugFormat("[ResourceCache Update] {0} loading fail", Path);
FailAndNotify();
}
else if (m_LoadingTask.IsDone)
{
ResourceObject = m_LoadingTask.ResourceObject;
InternalLog.DebugFormat("[ResourceCache Update] {0} loading success", Path);
SucceedAndNotify();
}
break;
default:
break;
}
}
public string FormatString(string format)
{
if (format == null || format.Trim().Length == 0)
{
format = "YY-MM-DD hh:mm:ss AP";
}
TimeStruct ts = TickToTimeStruct(m_Tick);
format = format.Replace("YYYY", ts.Year.ToString("0000"));
format = format.Replace("YYY", ts.Year.ToString("000"));
format = format.Replace("YY", ts.Year.ToString("00"));
format = format.Replace("Y", ts.Year.ToString("0"));
format = format.Replace("MM", ts.Month.ToString("00"));
format = format.Replace("M", ts.Month.ToString("0"));
format = format.Replace("DD", ts.Date.ToString("00"));
format = format.Replace("D", ts.Date.ToString("0"));
format = format.Replace("hh", ts.Hour.ToString("00"));
format = format.Replace("h", ts.Hour.ToString("0"));
format = format.Replace("mm", ts.Minute.ToString("00"));
format = format.Replace("ss", ts.Second.ToString("00"));
format = format.Replace("AP", ((ts.Hour < c_Day2Hour / 2) ? "" : ""));
return(format);
}
// Update is called once per frame
void Update()
{
secondsPassed = Time.time - startTime;
TimeStruct time = new TimeStruct(secondsPassed);
text.text = time.timeString;
}
public void UpdateYourTime(TimeStruct time)
{
YourTime.text = time.timeString;
if (PlayerPrefs.GetFloat(bestTime) > time.totalTime)
{
PlayerPrefs.SetFloat(bestTime, time.totalTime);
}
}
public override void Update(TimeStruct timeStruct)
{
TimeUsed += timeStruct.UnscaledDeltaTime;
if (TimeUsed > m_UnscaledTimeNeeded)
{
ErrorCode = DownloadErrorCode.Unknown;
}
}
public TimeStruct GetValue()
{
TimeStruct timeStruct = new TimeStruct();
timeStruct.Seconds = int.Parse(_optionSecondsValue.Text);
timeStruct.Minutes = int.Parse(_optionMinutesValue.Text);
return(timeStruct);
}
protected override void OnUpdate(TimeStruct timeStruct)
{
GetChannels(m_CopiedChannels);
foreach (var channel in m_CopiedChannels)
{
channel.Update(timeStruct);
}
}
public void ResetTimer(int seconds = 10, int minutes = 0)
{
currentTime = 0;
timerActive = true;
timeOver = false;
time = new TimeStruct();
time.SetTime(minutes, seconds);
}
public void Update(TimeStruct timeStruct)
{
GetChannels(m_CopiedChannels);
foreach (var channel in m_CopiedChannels)
{
channel.Update(timeStruct);
}
}
void FixedUpdate()
{
TS = format_Time((float)Time.time);
TribeAge.text = "Session time : " + TS.formattedString; // shows the session's age
DayNightCycle();
MousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
MousePos.y = UIPlane;
Cursor_Mouset.position = MousePos;
}
public override void DoTests()
{
TimeStruct time = new TimeStruct {
Time = new TimeEstimation {
Length = 5.5
}
};
AssertEqual(time.GetTime().ToString(), "05:30", "Wrong formatting of time");
}
public long TimeStructToTick(TimeStruct ts)
{
int day = CalendarToDay(ts);
return(((long)(day * Day2Sec)
+ (long)(ts.Hour * Hour2Sec)
+ (long)(ts.Minute * c_Min2Sec)
+ (long)(ts.Second)) * c_Sec2Tick
+ (long)(ts.Millisecond * c_Millisec2Tick));
}
public void Update(TimeStruct timeStruct)
{
var webRequest = m_WebRequestAsyncOperation.webRequest;
if (webRequest.isNetworkError)
{
ErrorCode = DownloadErrorCode.Network;
ErrorMessage = m_WebRequestAsyncOperation.webRequest.error;
return;
}
}
private void UpdateTickDelegates(TimeStruct timeStruct)
{
m_TempTickDelegates.Clear();
m_TempTickDelegates.AddRange(m_TickDelegates);
foreach (var dele in m_TempTickDelegates)
{
dele(timeStruct);
}
m_TempTickDelegates.Clear();
}
/// <summary>
/// Jank victory condition wahooooo
/// </summary>
public void RaiseKillCount()
{
killCount++;
if (killCount >= enemyCount)
{
Time.timeScale = 0;
TimeStruct ts = new TimeStruct(timer.secondsPassed);
WinText.SetActive(true);
WinText.GetComponent <WinText>().UpdateYourTime(ts);
}
}
// Start is called before the first frame update
void OnEnable()
{
if (!PlayerPrefs.HasKey(bestTime))
{
PlayerPrefs.SetFloat(bestTime, float.MaxValue);
}
BestTime = transform.Find("Best Time").GetComponent <Text>();
YourTime = transform.Find("Your Time").GetComponent <Text>();
TimeStruct bestTimeStruct = new TimeStruct(PlayerPrefs.GetFloat(bestTime));
BestTime.text = bestTimeStruct.timeString;
}
public void SetTime(int year, int month, int date, int hour, int minute, int second, int millisecond)
{
TimeStruct ts = new TimeStruct();
ts.Year = year;
ts.Month = month;
ts.Date = date;
ts.Hour = hour;
ts.Minute = minute;
ts.Second = second;
ts.Millisecond = millisecond;
m_Tick = TimeStructToTick(ts);
}
public void Update(TimeStruct timeStruct)
{
if (IsDone)
{
return;
}
m_TimeUsed += timeStruct.UnscaledDeltaTime;
RealDownloadedSize = m_StartByteIndex + (long)(m_TimeUsed * Size / TimeNeeded);
if (RealDownloadedSize + m_StartByteIndex > Size)
{
RealDownloadedSize = Size - m_StartByteIndex;
IsDone = true;
}
}
public override void Update(TimeStruct timeStruct)
{
TimeUsed += timeStruct.UnscaledDeltaTime;
if (TimeUsed > m_UnscaledTimeNeeded)
{
if (Info.Value.Size > 0 && Info.Value.Size != DownloadedSize)
{
ErrorCode = DownloadErrorCode.WrongSize;
}
else
{
IsDone = true;
}
}
}
internal void Update(TimeStruct timeStruct)
{
ReleaseAssetAccessors();
UpdateRunningAssetLoadingTasks(timeStruct);
UpdateRunningResourceLoadingTasks(timeStruct);
UpdateTickDelegates(timeStruct);
ReleaseUnretainedAssetCaches();
if (m_ShouldForceUnloadUnusedResources ||
timeStruct.UnscaledTime - m_LastReleaseResourcesTime > m_Owner.ReleaseResourceInterval)
{
m_LastReleaseResourcesTime = timeStruct.UnscaledTime;
m_ShouldForceUnloadUnusedResources = false;
ReleaseUnusedResourceCaches();
}
}
protected override void Update(TimeStruct timeStruct)
{
switch (Status)
{
case AssetCacheStatus.WaitingForSlot:
if (IsScene)
{
SucceedAndNotify();
}
else if (Owner.m_RunningAssetLoadingTasks.Count < Owner.m_RunningAssetLoadingTasks.Capacity)
{
m_LoadingTask = Owner.RunAssetLoadingTask(Path, Owner.EnsureResourceCache(ResourcePath).ResourceObject);
CoreLog.DebugFormat("[AssetCache Update] {0} start loading.", Path);
Status = AssetCacheStatus.Loading;
}
break;
case AssetCacheStatus.Loading:
if (!string.IsNullOrEmpty(m_LoadingTask.ErrorMessage))
{
ErrorMessage = m_LoadingTask.ErrorMessage;
CoreLog.DebugFormat("[AssetCache Update] {0} loading fail.", Path);
FailAndNotify();
}
else if (m_LoadingTask.IsDone)
{
AssetObject = m_LoadingTask.AssetObject;
CoreLog.DebugFormat("[AssetCache Update] {0} loading success.", Path);
SucceedAndNotify();
}
else
{
if (LoadingProgress != m_LastLoadingProgress)
{
m_LastLoadingProgress = LoadingProgress;
ProgressAndNotify();
}
}
break;
}
}
