924 lines
26 KiB
C#
924 lines
26 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using UnityEngine;
|
|
using UnityEngine.SceneManagement;
|
|
|
|
public sealed class DailyTaskService : MonoBehaviour
|
|
{
|
|
public static DailyTaskService Instance { get; private set; }
|
|
|
|
public event Action OnTasksChanged;
|
|
|
|
private enum ProgressCombineMode
|
|
{
|
|
Sum,
|
|
Max
|
|
}
|
|
|
|
private const float OnlineDurationFlushStepSeconds = 5f;
|
|
|
|
private readonly Queue<DailyTaskEventData> pendingEvents = new Queue<DailyTaskEventData>();
|
|
private readonly Dictionary<string, userTasksPool.TaskDefinition> definitionById = new Dictionary<string, userTasksPool.TaskDefinition>(StringComparer.Ordinal);
|
|
|
|
private DailyTaskSaveData saveData;
|
|
private userTasksPool configuredTaskPool;
|
|
private int configuredTaskMaxSize = 5;
|
|
private int configuredRefreshMaxTimes = 3;
|
|
private bool initialized;
|
|
private bool appFocused = true;
|
|
private float pendingOnlineDurationSeconds;
|
|
|
|
[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
|
|
private static void Bootstrap()
|
|
{
|
|
EnsureInstance();
|
|
}
|
|
|
|
public static DailyTaskService EnsureInstance()
|
|
{
|
|
if (Instance != null)
|
|
{
|
|
return Instance;
|
|
}
|
|
|
|
var host = new GameObject("__daily_task_service");
|
|
host.hideFlags = HideFlags.HideInHierarchy | HideFlags.HideInInspector;
|
|
DontDestroyOnLoad(host);
|
|
Instance = host.AddComponent<DailyTaskService>();
|
|
return Instance;
|
|
}
|
|
|
|
private void Awake()
|
|
{
|
|
if (Instance != null && Instance != this)
|
|
{
|
|
Destroy(gameObject);
|
|
return;
|
|
}
|
|
|
|
Instance = this;
|
|
DontDestroyOnLoad(gameObject);
|
|
SceneManager.sceneLoaded -= OnSceneLoaded;
|
|
SceneManager.sceneLoaded += OnSceneLoaded;
|
|
InitializeStorageIfNeeded();
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
if (!Application.isPlaying || !appFocused)
|
|
{
|
|
return;
|
|
}
|
|
|
|
pendingOnlineDurationSeconds += Time.unscaledDeltaTime;
|
|
if (pendingOnlineDurationSeconds >= OnlineDurationFlushStepSeconds)
|
|
{
|
|
float flushSeconds = Mathf.Floor(pendingOnlineDurationSeconds);
|
|
pendingOnlineDurationSeconds = Mathf.Max(0f, pendingOnlineDurationSeconds - flushSeconds);
|
|
ReportEvent(new DailyTaskEventData
|
|
{
|
|
taskType = userTasksPool.TaskType.OnlineDuration,
|
|
amount = flushSeconds
|
|
});
|
|
}
|
|
}
|
|
|
|
private void OnApplicationFocus(bool hasFocus)
|
|
{
|
|
appFocused = hasFocus;
|
|
if (!hasFocus)
|
|
{
|
|
FlushPendingOnlineDuration();
|
|
}
|
|
}
|
|
|
|
private void OnApplicationPause(bool pauseStatus)
|
|
{
|
|
if (pauseStatus)
|
|
{
|
|
FlushPendingOnlineDuration();
|
|
}
|
|
}
|
|
|
|
private void OnApplicationQuit()
|
|
{
|
|
FlushPendingOnlineDuration();
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
if (Instance == this)
|
|
{
|
|
FlushPendingOnlineDuration();
|
|
SceneManager.sceneLoaded -= OnSceneLoaded;
|
|
}
|
|
}
|
|
|
|
public void Configure(userTasksPool taskPool, int taskMaxSize, int refreshMaxTimes)
|
|
{
|
|
configuredTaskPool = taskPool;
|
|
configuredTaskMaxSize = Mathf.Max(1, taskMaxSize);
|
|
configuredRefreshMaxTimes = Mathf.Max(0, refreshMaxTimes);
|
|
RebuildDefinitionIndex();
|
|
EnsureTodayTasks();
|
|
FlushPendingEvents();
|
|
NotifyTasksChanged();
|
|
}
|
|
|
|
public IReadOnlyList<DailyTaskViewData> GetActiveTaskViews()
|
|
{
|
|
EnsureTodayTasks();
|
|
|
|
var result = new List<DailyTaskViewData>();
|
|
if (saveData == null || saveData.activeTasks == null)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
for (int i = 0; i < saveData.activeTasks.Count; i++)
|
|
{
|
|
var runtimeEntry = saveData.activeTasks[i];
|
|
if (runtimeEntry == null || string.IsNullOrEmpty(runtimeEntry.taskID))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
userTasksPool.TaskDefinition definition;
|
|
if (!definitionById.TryGetValue(runtimeEntry.taskID, out definition))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
result.Add(new DailyTaskViewData
|
|
{
|
|
definition = definition,
|
|
runtimeEntry = runtimeEntry
|
|
});
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public void ReportEvent(DailyTaskEventData eventData)
|
|
{
|
|
InitializeStorageIfNeeded();
|
|
if (!IsConfigured())
|
|
{
|
|
pendingEvents.Enqueue(eventData);
|
|
return;
|
|
}
|
|
|
|
EnsureTodayTasks();
|
|
|
|
bool changed = ApplyEventToTrackedProgress(eventData);
|
|
|
|
if (saveData != null && saveData.activeTasks != null)
|
|
{
|
|
for (int i = 0; i < saveData.activeTasks.Count; i++)
|
|
{
|
|
var runtimeEntry = saveData.activeTasks[i];
|
|
if (runtimeEntry == null || runtimeEntry.isClaimed)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
userTasksPool.TaskDefinition definition;
|
|
if (!definitionById.TryGetValue(runtimeEntry.taskID, out definition))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (!IsEventMatch(definition, eventData))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
float nextProgress = CalculateProgressForDefinition(definition);
|
|
bool nextCompleted = nextProgress >= Mathf.Max(0.0001f, definition.targetValue);
|
|
|
|
if (!Mathf.Approximately(runtimeEntry.progress, nextProgress) || runtimeEntry.isCompleted != nextCompleted)
|
|
{
|
|
runtimeEntry.progress = nextProgress;
|
|
runtimeEntry.isCompleted = nextCompleted;
|
|
changed = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (changed)
|
|
{
|
|
Save();
|
|
NotifyTasksChanged();
|
|
}
|
|
}
|
|
|
|
public bool TryRefreshTasks()
|
|
{
|
|
if (!IsConfigured())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
EnsureTodayTasks();
|
|
if (saveData.refreshUsedCount >= configuredRefreshMaxTimes)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
saveData.refreshUsedCount += 1;
|
|
StampRefreshUsage();
|
|
GenerateDailyTasks();
|
|
Save();
|
|
NotifyTasksChanged();
|
|
return true;
|
|
}
|
|
|
|
public int GetRemainingRefreshCount()
|
|
{
|
|
EnsureTodayTasks();
|
|
return Mathf.Max(0, configuredRefreshMaxTimes - (saveData != null ? saveData.refreshUsedCount : 0));
|
|
}
|
|
|
|
public bool TryClaimReward(string taskID, Player_SO playerData, out string failureMessage)
|
|
{
|
|
failureMessage = string.Empty;
|
|
if (string.IsNullOrWhiteSpace(taskID))
|
|
{
|
|
failureMessage = "任务参数无效";
|
|
return false;
|
|
}
|
|
|
|
EnsureTodayTasks();
|
|
|
|
DailyTaskRuntimeEntry runtimeEntry;
|
|
userTasksPool.TaskDefinition definition;
|
|
if (!TryGetTaskPair(taskID, out runtimeEntry, out definition))
|
|
{
|
|
failureMessage = "未找到任务";
|
|
return false;
|
|
}
|
|
|
|
if (!runtimeEntry.isCompleted)
|
|
{
|
|
failureMessage = "任务尚未完成";
|
|
return false;
|
|
}
|
|
|
|
if (runtimeEntry.isClaimed)
|
|
{
|
|
failureMessage = "奖励已领取";
|
|
return false;
|
|
}
|
|
|
|
if (!TryGrantReward(definition, playerData, out failureMessage))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
runtimeEntry.isClaimed = true;
|
|
Save();
|
|
NotifyTasksChanged();
|
|
return true;
|
|
}
|
|
|
|
public int ClaimAllAvailableRewards(Player_SO playerData, out string failureMessage)
|
|
{
|
|
failureMessage = string.Empty;
|
|
EnsureTodayTasks();
|
|
|
|
int claimedCount = 0;
|
|
var taskIds = new List<string>();
|
|
var views = GetActiveTaskViews();
|
|
for (int i = 0; i < views.Count; i++)
|
|
{
|
|
var runtimeEntry = views[i].runtimeEntry;
|
|
if (runtimeEntry == null || !runtimeEntry.isCompleted || runtimeEntry.isClaimed)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
taskIds.Add(runtimeEntry.taskID);
|
|
}
|
|
|
|
for (int i = 0; i < taskIds.Count; i++)
|
|
{
|
|
string claimError;
|
|
if (!TryClaimReward(taskIds[i], playerData, out claimError))
|
|
{
|
|
if (claimedCount <= 0)
|
|
{
|
|
failureMessage = claimError;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
claimedCount += 1;
|
|
}
|
|
|
|
if (claimedCount <= 0 && string.IsNullOrEmpty(failureMessage))
|
|
{
|
|
failureMessage = "暂无可领取奖励";
|
|
}
|
|
|
|
return claimedCount;
|
|
}
|
|
|
|
private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
|
|
{
|
|
if (string.Equals(scene.name, "UI_UI", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
DailyTaskEventHub.ReportLogin();
|
|
}
|
|
}
|
|
|
|
private void InitializeStorageIfNeeded()
|
|
{
|
|
if (initialized)
|
|
{
|
|
return;
|
|
}
|
|
|
|
saveData = DailyTaskSaveService.Load() ?? new DailyTaskSaveData();
|
|
EnsureRuntimeCollections();
|
|
initialized = true;
|
|
}
|
|
|
|
private void EnsureTodayTasks()
|
|
{
|
|
InitializeStorageIfNeeded();
|
|
|
|
if (!IsConfigured())
|
|
{
|
|
return;
|
|
}
|
|
|
|
bool timeStateChanged;
|
|
int effectiveTodayStamp = GetEffectiveTodayStamp(out timeStateChanged);
|
|
string todayKey = FormatDateKey(effectiveTodayStamp);
|
|
if (saveData == null)
|
|
{
|
|
saveData = new DailyTaskSaveData();
|
|
}
|
|
|
|
EnsureRuntimeCollections();
|
|
|
|
bool needRegenerate = saveData.dateStamp != effectiveTodayStamp
|
|
|| !string.Equals(saveData.dateKey, todayKey, StringComparison.Ordinal)
|
|
|| saveData.activeTasks == null
|
|
|| saveData.activeTasks.Count == 0;
|
|
|
|
if (!needRegenerate)
|
|
{
|
|
EnsureAccumulatedProgressCompatibility();
|
|
if (timeStateChanged)
|
|
{
|
|
Save();
|
|
}
|
|
return;
|
|
}
|
|
|
|
saveData.dateKey = todayKey;
|
|
saveData.dateStamp = effectiveTodayStamp;
|
|
saveData.refreshUsedCount = 0;
|
|
saveData.accumulatedProgress = new List<DailyTaskAccumulatedProgress>();
|
|
saveData.uniqueIntProgress = new List<DailyTaskUniqueIntProgress>();
|
|
GenerateDailyTasks();
|
|
Save();
|
|
}
|
|
|
|
private void GenerateDailyTasks()
|
|
{
|
|
if (saveData == null)
|
|
{
|
|
saveData = new DailyTaskSaveData();
|
|
}
|
|
|
|
saveData.activeTasks = new List<DailyTaskRuntimeEntry>();
|
|
|
|
var candidates = configuredTaskPool.tasks
|
|
.Where(t => t != null && t.addToTaskPool && !string.IsNullOrWhiteSpace(t.taskID) && t.selectionWeight > 0)
|
|
.ToList();
|
|
|
|
if (candidates.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
int pickCount = Mathf.Min(configuredTaskMaxSize, candidates.Count);
|
|
int dateSeed = saveData.dateStamp > 0 ? saveData.dateStamp : GetLocalDateStamp(DateTime.Now);
|
|
var random = new System.Random(unchecked(dateSeed + saveData.refreshUsedCount * 397));
|
|
var selectedDefinitions = new List<userTasksPool.TaskDefinition>();
|
|
|
|
while (selectedDefinitions.Count < pickCount && candidates.Count > 0)
|
|
{
|
|
int totalWeight = candidates.Sum(t => Mathf.Max(1, t.selectionWeight));
|
|
int roll = random.Next(0, totalWeight);
|
|
int cumulative = 0;
|
|
int selectedIndex = 0;
|
|
for (int i = 0; i < candidates.Count; i++)
|
|
{
|
|
cumulative += Mathf.Max(1, candidates[i].selectionWeight);
|
|
if (roll < cumulative)
|
|
{
|
|
selectedIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
selectedDefinitions.Add(candidates[selectedIndex]);
|
|
candidates.RemoveAt(selectedIndex);
|
|
}
|
|
|
|
for (int i = 0; i < selectedDefinitions.Count; i++)
|
|
{
|
|
var definition = selectedDefinitions[i];
|
|
float currentProgress = CalculateProgressForDefinition(definition);
|
|
saveData.activeTasks.Add(new DailyTaskRuntimeEntry
|
|
{
|
|
taskID = definition.taskID,
|
|
progress = currentProgress,
|
|
isCompleted = currentProgress >= Mathf.Max(0.0001f, definition.targetValue),
|
|
isClaimed = false
|
|
});
|
|
}
|
|
}
|
|
|
|
private bool IsConfigured()
|
|
{
|
|
return configuredTaskPool != null && definitionById.Count > 0;
|
|
}
|
|
|
|
private void RebuildDefinitionIndex()
|
|
{
|
|
definitionById.Clear();
|
|
if (configuredTaskPool == null || configuredTaskPool.tasks == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < configuredTaskPool.tasks.Count; i++)
|
|
{
|
|
var definition = configuredTaskPool.tasks[i];
|
|
if (definition == null || string.IsNullOrWhiteSpace(definition.taskID))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (!definitionById.ContainsKey(definition.taskID))
|
|
{
|
|
definitionById.Add(definition.taskID, definition);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void EnsureAccumulatedProgressCompatibility()
|
|
{
|
|
EnsureRuntimeCollections();
|
|
|
|
if (saveData.accumulatedProgress.Count > 0 || saveData.activeTasks == null || saveData.activeTasks.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
bool changed = false;
|
|
for (int i = 0; i < saveData.activeTasks.Count; i++)
|
|
{
|
|
var runtimeEntry = saveData.activeTasks[i];
|
|
if (runtimeEntry == null || string.IsNullOrWhiteSpace(runtimeEntry.taskID))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
userTasksPool.TaskDefinition definition;
|
|
if (!definitionById.TryGetValue(runtimeEntry.taskID, out definition))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (definition.taskType == userTasksPool.TaskType.DifferentSongs)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
changed |= AddOrCombineProgress(definition.taskType, Mathf.Max(0f, runtimeEntry.progress), GetCombineMode(definition.taskType));
|
|
}
|
|
|
|
if (changed)
|
|
{
|
|
Save();
|
|
}
|
|
}
|
|
|
|
private void FlushPendingEvents()
|
|
{
|
|
if (!IsConfigured())
|
|
{
|
|
return;
|
|
}
|
|
|
|
while (pendingEvents.Count > 0)
|
|
{
|
|
ReportEvent(pendingEvents.Dequeue());
|
|
}
|
|
}
|
|
|
|
private bool ApplyEventToTrackedProgress(DailyTaskEventData eventData)
|
|
{
|
|
switch (eventData.taskType)
|
|
{
|
|
case userTasksPool.TaskType.Login:
|
|
case userTasksPool.TaskType.PlaySong:
|
|
case userTasksPool.TaskType.FullCombo:
|
|
case userTasksPool.TaskType.WatchStory:
|
|
case userTasksPool.TaskType.UseItem:
|
|
case userTasksPool.TaskType.ShareGame:
|
|
{
|
|
bool changed = AddOrCombineProgress(eventData.taskType, Mathf.Max(1f, eventData.amount), ProgressCombineMode.Sum);
|
|
if (eventData.taskType == userTasksPool.TaskType.PlaySong && eventData.songID > 0)
|
|
{
|
|
changed |= AddUniqueIntValue(userTasksPool.TaskType.DifferentSongs, eventData.songID);
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
case userTasksPool.TaskType.TotalScore:
|
|
case userTasksPool.TaskType.SpendCoins:
|
|
case userTasksPool.TaskType.GameDuration:
|
|
case userTasksPool.TaskType.OnlineDuration:
|
|
return AddOrCombineProgress(eventData.taskType, Mathf.Max(0f, eventData.amount), ProgressCombineMode.Sum);
|
|
case userTasksPool.TaskType.SingleRunCombo:
|
|
case userTasksPool.TaskType.SingleRunScore:
|
|
return AddOrCombineProgress(eventData.taskType, Mathf.Max(0f, eventData.amount), ProgressCombineMode.Max);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private static bool IsEventMatch(userTasksPool.TaskDefinition definition, DailyTaskEventData eventData)
|
|
{
|
|
if (definition == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (definition.taskType == eventData.taskType)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return definition.taskType == userTasksPool.TaskType.DifferentSongs && eventData.taskType == userTasksPool.TaskType.PlaySong;
|
|
}
|
|
|
|
private float CalculateProgressForDefinition(userTasksPool.TaskDefinition definition)
|
|
{
|
|
if (definition == null)
|
|
{
|
|
return 0f;
|
|
}
|
|
|
|
float targetValue = Mathf.Max(0.0001f, definition.targetValue);
|
|
switch (definition.taskType)
|
|
{
|
|
case userTasksPool.TaskType.DifferentSongs:
|
|
return Mathf.Min(GetUniqueIntCount(userTasksPool.TaskType.DifferentSongs), targetValue);
|
|
default:
|
|
return Mathf.Min(Mathf.Max(0f, GetAccumulatedProgress(definition.taskType)), targetValue);
|
|
}
|
|
}
|
|
|
|
private bool AddOrCombineProgress(userTasksPool.TaskType taskType, float amount, ProgressCombineMode combineMode)
|
|
{
|
|
EnsureRuntimeCollections();
|
|
|
|
int taskTypeValue = (int)taskType;
|
|
for (int i = 0; i < saveData.accumulatedProgress.Count; i++)
|
|
{
|
|
var entry = saveData.accumulatedProgress[i];
|
|
if (entry == null || entry.taskType != taskTypeValue)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
float nextValue = combineMode == ProgressCombineMode.Max
|
|
? Mathf.Max(entry.progress, amount)
|
|
: Mathf.Max(0f, entry.progress + amount);
|
|
|
|
if (Mathf.Approximately(entry.progress, nextValue))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
entry.progress = nextValue;
|
|
return true;
|
|
}
|
|
|
|
saveData.accumulatedProgress.Add(new DailyTaskAccumulatedProgress
|
|
{
|
|
taskType = taskTypeValue,
|
|
progress = Mathf.Max(0f, amount)
|
|
});
|
|
return true;
|
|
}
|
|
|
|
private float GetAccumulatedProgress(userTasksPool.TaskType taskType)
|
|
{
|
|
if (saveData == null || saveData.accumulatedProgress == null)
|
|
{
|
|
return 0f;
|
|
}
|
|
|
|
int taskTypeValue = (int)taskType;
|
|
for (int i = 0; i < saveData.accumulatedProgress.Count; i++)
|
|
{
|
|
var entry = saveData.accumulatedProgress[i];
|
|
if (entry == null || entry.taskType != taskTypeValue)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
return Mathf.Max(0f, entry.progress);
|
|
}
|
|
|
|
return 0f;
|
|
}
|
|
|
|
private bool AddUniqueIntValue(userTasksPool.TaskType taskType, int value)
|
|
{
|
|
if (value <= 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
EnsureRuntimeCollections();
|
|
int taskTypeValue = (int)taskType;
|
|
for (int i = 0; i < saveData.uniqueIntProgress.Count; i++)
|
|
{
|
|
var entry = saveData.uniqueIntProgress[i];
|
|
if (entry == null || entry.taskType != taskTypeValue)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (entry.values == null)
|
|
{
|
|
entry.values = new List<int>();
|
|
}
|
|
|
|
if (entry.values.Contains(value))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
entry.values.Add(value);
|
|
return true;
|
|
}
|
|
|
|
saveData.uniqueIntProgress.Add(new DailyTaskUniqueIntProgress
|
|
{
|
|
taskType = taskTypeValue,
|
|
values = new List<int> { value }
|
|
});
|
|
return true;
|
|
}
|
|
|
|
private int GetUniqueIntCount(userTasksPool.TaskType taskType)
|
|
{
|
|
if (saveData == null || saveData.uniqueIntProgress == null)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int taskTypeValue = (int)taskType;
|
|
for (int i = 0; i < saveData.uniqueIntProgress.Count; i++)
|
|
{
|
|
var entry = saveData.uniqueIntProgress[i];
|
|
if (entry == null || entry.taskType != taskTypeValue || entry.values == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
return entry.values.Count;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
private static ProgressCombineMode GetCombineMode(userTasksPool.TaskType taskType)
|
|
{
|
|
switch (taskType)
|
|
{
|
|
case userTasksPool.TaskType.SingleRunCombo:
|
|
case userTasksPool.TaskType.SingleRunScore:
|
|
return ProgressCombineMode.Max;
|
|
default:
|
|
return ProgressCombineMode.Sum;
|
|
}
|
|
}
|
|
|
|
private void EnsureRuntimeCollections()
|
|
{
|
|
if (saveData == null)
|
|
{
|
|
saveData = new DailyTaskSaveData();
|
|
}
|
|
|
|
if (saveData.activeTasks == null)
|
|
{
|
|
saveData.activeTasks = new List<DailyTaskRuntimeEntry>();
|
|
}
|
|
|
|
if (saveData.accumulatedProgress == null)
|
|
{
|
|
saveData.accumulatedProgress = new List<DailyTaskAccumulatedProgress>();
|
|
}
|
|
|
|
if (saveData.uniqueIntProgress == null)
|
|
{
|
|
saveData.uniqueIntProgress = new List<DailyTaskUniqueIntProgress>();
|
|
}
|
|
}
|
|
|
|
private int GetEffectiveTodayStamp(out bool stateChanged)
|
|
{
|
|
stateChanged = false;
|
|
if (saveData == null)
|
|
{
|
|
saveData = new DailyTaskSaveData();
|
|
}
|
|
|
|
int currentStamp = GetLocalDateStamp(DateTime.Now);
|
|
long nowLocalTicks = DateTime.Now.Ticks;
|
|
long nowUtcTicks = DateTime.UtcNow.Ticks;
|
|
|
|
if (saveData.trustedDateStamp <= 0)
|
|
{
|
|
saveData.trustedDateStamp = currentStamp;
|
|
stateChanged = true;
|
|
}
|
|
else if (currentStamp < saveData.trustedDateStamp)
|
|
{
|
|
saveData.timeRollbackDetections += 1;
|
|
currentStamp = saveData.trustedDateStamp;
|
|
stateChanged = true;
|
|
}
|
|
else if (currentStamp > saveData.trustedDateStamp)
|
|
{
|
|
saveData.trustedDateStamp = currentStamp;
|
|
stateChanged = true;
|
|
}
|
|
|
|
if (saveData.lastSeenLocalTicks != nowLocalTicks)
|
|
{
|
|
saveData.lastSeenLocalTicks = nowLocalTicks;
|
|
stateChanged = true;
|
|
}
|
|
|
|
if (saveData.lastSeenUtcTicks != nowUtcTicks)
|
|
{
|
|
saveData.lastSeenUtcTicks = nowUtcTicks;
|
|
stateChanged = true;
|
|
}
|
|
|
|
return Mathf.Max(currentStamp, saveData.trustedDateStamp);
|
|
}
|
|
|
|
private void StampRefreshUsage()
|
|
{
|
|
saveData.lastRefreshDateStamp = saveData.dateStamp;
|
|
saveData.lastRefreshLocalTicks = DateTime.Now.Ticks;
|
|
saveData.lastRefreshUtcTicks = DateTime.UtcNow.Ticks;
|
|
}
|
|
|
|
private bool TryGetTaskPair(string taskID, out DailyTaskRuntimeEntry runtimeEntry, out userTasksPool.TaskDefinition definition)
|
|
{
|
|
runtimeEntry = null;
|
|
definition = null;
|
|
|
|
if (saveData == null || saveData.activeTasks == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
for (int i = 0; i < saveData.activeTasks.Count; i++)
|
|
{
|
|
var candidate = saveData.activeTasks[i];
|
|
if (candidate == null || !string.Equals(candidate.taskID, taskID, StringComparison.Ordinal))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
userTasksPool.TaskDefinition matchedDefinition;
|
|
if (!definitionById.TryGetValue(candidate.taskID, out matchedDefinition))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
runtimeEntry = candidate;
|
|
definition = matchedDefinition;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static bool TryGrantReward(userTasksPool.TaskDefinition definition, Player_SO playerData, out string failureMessage)
|
|
{
|
|
failureMessage = string.Empty;
|
|
if (definition == null)
|
|
{
|
|
failureMessage = "任务定义无效";
|
|
return false;
|
|
}
|
|
|
|
if (definition.rewardAmount <= 0)
|
|
{
|
|
failureMessage = "奖励数量无效";
|
|
return false;
|
|
}
|
|
|
|
switch (definition.rewardType)
|
|
{
|
|
case userTasksPool.RewardType.coins:
|
|
{
|
|
var wallet = PlayerEconomyLedger.EnsureInstance();
|
|
if (playerData != null)
|
|
{
|
|
wallet.AttachPlayerData(playerData);
|
|
}
|
|
|
|
wallet.AddCoins(definition.rewardAmount);
|
|
return true;
|
|
}
|
|
case userTasksPool.RewardType.expBottle:
|
|
{
|
|
var bottleLedger = ExpBottleLedger.EnsureInstance();
|
|
if (playerData != null)
|
|
{
|
|
bottleLedger.AttachPlayerData(playerData);
|
|
}
|
|
|
|
bottleLedger.Add(definition.rewardExpBottleKind, definition.rewardAmount);
|
|
return true;
|
|
}
|
|
case userTasksPool.RewardType.dushMaterial:
|
|
{
|
|
var materialLedger = DushMaterialLedger.EnsureInstance();
|
|
if (playerData != null)
|
|
{
|
|
materialLedger.AttachPlayerData(playerData);
|
|
}
|
|
|
|
materialLedger.Add(definition.rewardDushMaterialKind, definition.rewardAmount);
|
|
return true;
|
|
}
|
|
default:
|
|
failureMessage = "暂不支持该奖励类型";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private void FlushPendingOnlineDuration()
|
|
{
|
|
if (pendingOnlineDurationSeconds <= 0f)
|
|
{
|
|
return;
|
|
}
|
|
|
|
float flushSeconds = pendingOnlineDurationSeconds;
|
|
pendingOnlineDurationSeconds = 0f;
|
|
ReportEvent(new DailyTaskEventData
|
|
{
|
|
taskType = userTasksPool.TaskType.OnlineDuration,
|
|
amount = flushSeconds
|
|
});
|
|
}
|
|
|
|
private static int GetLocalDateStamp(DateTime dateTime)
|
|
{
|
|
return dateTime.Year * 10000 + dateTime.Month * 100 + dateTime.Day;
|
|
}
|
|
|
|
private static string FormatDateKey(int dateStamp)
|
|
{
|
|
int year = dateStamp / 10000;
|
|
int month = (dateStamp / 100) % 100;
|
|
int day = dateStamp % 100;
|
|
return year.ToString("D4") + "-" + month.ToString("D2") + "-" + day.ToString("D2");
|
|
}
|
|
|
|
private void Save()
|
|
{
|
|
DailyTaskSaveService.Save(saveData);
|
|
}
|
|
|
|
private void NotifyTasksChanged()
|
|
{
|
|
if (OnTasksChanged != null)
|
|
{
|
|
OnTasksChanged();
|
|
}
|
|
}
|
|
}
|