using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using UnityEngine;
|
namespace Snxxz.UI
|
{
|
public class OperationBase
|
{
|
public OperationDate startDate;
|
public OperationDate endDate;
|
public List<OperationTime> times = new List<OperationTime>();
|
|
/// <summary>
|
/// 是否每日重置
|
/// </summary>
|
public bool dayReset = false;
|
/// <summary>
|
/// 0-0点重置，1-5点重置
|
/// </summary>
|
public int resetType = 0;
|
|
public const int DayResetHour = 5;
|
|
public bool stepTimeNotify = false;
|
public bool stepDateNotify = false;
|
|
public bool inTimeNotify = false;
|
public bool inDateNotify = false;
|
|
public int inAdvanceMinute = 0;
|
public bool inAdvanceNotify = false;
|
|
public int limitLv;
|
|
public bool allDay
|
{
|
get { return times.Count <= 0; }
|
}
|
|
public int totalDays
|
{
|
get { return endDate - startDate; }
|
}
|
|
public bool IsLastDay
|
{
|
get
|
{
|
return IndexOfDays(TimeUtility.ServerNow) == totalDays;
|
}
|
}
|
|
public bool InTime(DateTime time)
|
{
|
if (!InDay(time))
|
{
|
return false;
|
}
|
if (allDay)
|
{
|
return InDayResetTime(time);
|
}
|
for (int i = 0; i < times.Count; i++)
|
{
|
if (times[i].InTime(time))
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
|
bool InDayResetTime(DateTime time)
|
{
|
if (!InDay(time))
|
{
|
return false;
|
}
|
switch (resetType)
|
{
|
case 0:
|
{
|
return true;
|
}
|
case 1:
|
{
|
var indexOfDays = IndexOfDays(time);
|
if (indexOfDays == 0)
|
{
|
return time.Hour >= DayResetHour;
|
}
|
if (indexOfDays == totalDays)
|
{
|
return time.Hour < DayResetHour;
|
}
|
if (indexOfDays < totalDays)
|
{
|
return true;
|
}
|
}
|
break;
|
case 2:
|
{
|
var indexOfDays = IndexOfDays(time);
|
if (indexOfDays == 0)
|
{
|
return time.Hour >= DayResetHour;
|
}
|
return true;
|
}
|
|
}
|
return false;
|
}
|
|
public bool InDay(DateTime time)
|
{
|
OperationDate date = new OperationDate()
|
{
|
year = time.Year,
|
month = time.Month,
|
day = time.Day,
|
};
|
return date >= startDate && date <= endDate;
|
}
|
|
protected int IndexOfDays(DateTime time)
|
{
|
if (!InDay(time))
|
{
|
return -1;
|
}
|
DateTime s = new DateTime(startDate.year, startDate.month, startDate.day);
|
return (time - s).Days;
|
}
|
|
protected virtual int IndexOfTime(DateTime time, int compare = 0)
|
{
|
if (allDay)
|
{
|
if (!dayReset)
|
{
|
return 0;
|
}
|
var index = Mathf.Max(0, IndexOfDays(time));
|
switch (resetType)
|
{
|
case 0:
|
return index;
|
case 1:
|
case 2:
|
return time.Hour < DayResetHour ? Mathf.Max(0, index - 1) : index;
|
default:
|
return index;
|
}
|
}
|
else
|
{
|
var index = 0;
|
bool equalCompare = false;
|
for (int i = 0; i < times.Count; i++)
|
{
|
if (times[i].InTime(time))
|
{
|
index = i;
|
break;
|
}
|
if (!equalCompare && times[i].CompareTime(TimeUtility.ServerNow) == compare)
|
{
|
index = i;
|
equalCompare = true;
|
}
|
}
|
return index;
|
}
|
}
|
|
public int GetSurplusTime(DateTime time)
|
{
|
var seconds = 0;
|
if (InTime(time))
|
{
|
if (allDay)
|
{
|
seconds += GetSurplusDayResetTime(time);
|
}
|
else
|
{
|
for (int i = 0; i < times.Count; i++)
|
{
|
if (times[i].InTime(time))
|
{
|
seconds += times[i] - time;
|
break;
|
}
|
}
|
}
|
}
|
return seconds;
|
}
|
|
int GetSurplusDayResetTime(DateTime time)
|
{
|
switch (resetType)
|
{
|
case 0:
|
case 2:
|
return (int)(endDate.AddSeconds(24 * 60 * 60) - time).TotalSeconds;
|
case 1:
|
var endTime = new DateTime(endDate.year, endDate.month, endDate.day, DayResetHour, 0, 0);
|
return (int)(endTime - time).TotalSeconds;
|
}
|
return 0;
|
}
|
|
public bool InAdvanceTime(DateTime time)
|
{
|
if (inAdvanceMinute <= 0)
|
{
|
return false;
|
}
|
var advanceSeconds = inAdvanceMinute * 60;
|
var beforeStartSeconds = GetSecondsBeforeStart(time);
|
return beforeStartSeconds > 0 && beforeStartSeconds <= advanceSeconds;
|
}
|
|
public int GetSecondsBeforeStart(DateTime time)
|
{
|
var seconds = 0;
|
if (InTime(time))
|
{
|
return 0;
|
}
|
if (allDay)
|
{
|
var startHour = 0;
|
switch (resetType)
|
{
|
case 0:
|
startHour = 0;
|
break;
|
case 1:
|
case 2:
|
startHour = DayResetHour;
|
break;
|
}
|
var startTime = new DateTime(startDate.year, startDate.month, startDate.day, startHour, 0, 0);
|
seconds = Mathf.CeilToInt((float)(startTime - time).TotalSeconds);
|
}
|
else
|
{
|
var index = IndexOfDays(time);
|
var date = startDate.AddDays(index);
|
for (int i = 0; i < times.Count; i++)
|
{
|
var startTime = new DateTime(date.year, date.month, date.day, times[i].startHour, times[i].startMinute, 0);
|
seconds = Mathf.CeilToInt((float)(startTime - time).TotalSeconds);
|
if (seconds > 0)
|
{
|
break;
|
}
|
}
|
}
|
return seconds;
|
}
|
|
public int GetResetSurplusTime()
|
{
|
var time = TimeUtility.ServerNow;
|
if (!InTime(time))
|
{
|
return 0;
|
}
|
var seconds = 0;
|
if (allDay)
|
{
|
if (!dayReset)
|
{
|
return GetSurplusTime(time);
|
}
|
switch (resetType)
|
{
|
case 0:
|
{
|
DateTime endOperationTime = new DateTime(TimeUtility.Year, TimeUtility.Month,
|
TimeUtility.Day, 0, 0, 0);
|
endOperationTime = endOperationTime.AddDays(1);
|
seconds = (int)(endOperationTime - TimeUtility.ServerNow).TotalSeconds;
|
}
|
break;
|
case 1:
|
{
|
DateTime endOperationTime = new DateTime(TimeUtility.Year, TimeUtility.Month,
|
TimeUtility.Day, DayResetHour, 0, 0);
|
if (time.Hour >= DayResetHour)
|
{
|
endOperationTime = endOperationTime.AddDays(1);
|
}
|
seconds = (int)(endOperationTime - TimeUtility.ServerNow).TotalSeconds;
|
}
|
break;
|
case 2:
|
{
|
var indexOfDays = IndexOfDays(time);
|
DateTime endOperationTime = DateTime.Now;
|
if (indexOfDays == totalDays)
|
{
|
if (time.Hour >= DayResetHour)
|
{
|
endOperationTime = new DateTime(TimeUtility.Year, TimeUtility.Month,
|
TimeUtility.Day, 0, 0, 0);
|
endOperationTime = endOperationTime.AddDays(1);
|
}
|
else
|
{
|
endOperationTime = new DateTime(TimeUtility.Year, TimeUtility.Month,
|
TimeUtility.Day, DayResetHour, 0, 0);
|
}
|
}
|
else
|
{
|
endOperationTime = new DateTime(TimeUtility.Year, TimeUtility.Month,
|
TimeUtility.Day, DayResetHour, 0, 0);
|
if (time.Hour >= DayResetHour)
|
{
|
endOperationTime = endOperationTime.AddDays(1);
|
}
|
}
|
seconds = (int)(endOperationTime - TimeUtility.ServerNow).TotalSeconds;
|
}
|
break;
|
}
|
}
|
else
|
{
|
for (int i = 0; i < times.Count; i++)
|
{
|
if (times[i].InTime(time))
|
{
|
DateTime endOperationTime = new DateTime(TimeUtility.Year, TimeUtility.Month,
|
TimeUtility.Day, times[i].endHour, times[i].endMinute, 0);
|
seconds = (int)(endOperationTime - TimeUtility.ServerNow).TotalSeconds;
|
break;
|
}
|
}
|
}
|
return seconds;
|
}
|
|
public virtual string ToDisplayTime()
|
{
|
return string.Empty;
|
}
|
|
public virtual void Reset()
|
{
|
stepTimeNotify = false;
|
stepDateNotify = false;
|
inTimeNotify = false;
|
inDateNotify = false;
|
dayReset = false;
|
resetType = 0;
|
limitLv = 0;
|
inAdvanceNotify = false;
|
inAdvanceMinute = 0;
|
times.Clear();
|
}
|
|
public virtual bool SatisfyOpenCondition()
|
{
|
return PlayerDatas.Instance.baseData.LV >= limitLv;
|
}
|
}
|
}
|
