ZhenShiXunYouJi2/Assets/Scripts/OngoingRewardManager.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using SUISS.Storage;
using SUISSEngine;
using UnityEngine;

public sealed class OngoingRewardManager : Singleton<OngoingRewardManager>
{
	//[DebuggerBrowsable(DebuggerBrowsableState.Never)]
	public event OngoingRewardManager.RewardAddedHandler RewardAdded;

	//[DebuggerBrowsable(DebuggerBrowsableState.Never)]
	public event OngoingRewardManager.RewardRemovedHandler RewardRemoved;

	private Dictionary<string, object> _storage
	{
		get
		{
			return Storage.Get(StorageLifecycle.Game).GetDictionary("OngoingRewardManager");
		}
	}

	public IEnumerable<IOngoingReward> ActiveRewards
	{
		get
		{
			Dictionary<string, object> storage = this._storage;
			if (!storage.ContainsKey("ActiveRewards"))
			{
				storage["ActiveRewards"] = new List<object>();
			}
			List<object> list = (List<object>)storage["ActiveRewards"];
			List<IOngoingReward> list2 = new List<IOngoingReward>();
			for (int i = 0; i < list.Count; i++)
			{
				object obj = list[i];
				IOngoingReward ongoingReward = obj as IOngoingReward;
				if (ongoingReward == null)
				{
					if (obj == null)
					{
						UnityEngine.Debug.LogError("The stored list of ongoing rewards contains an object of type 'null'.");
					}
					else
					{
						UnityEngine.Debug.LogError(string.Format("The stored list of ongoing rewards contains an object of type '{0}'.", obj.GetType()));
					}
				}
				else if (!ongoingReward.IsActive)
				{
					list.RemoveAt(i--);
				}
				else
				{
					list2.Add(ongoingReward);
				}
			}
			return list2;
		}
		private set
		{
			List<object> list = new List<object>();
			foreach (IOngoingReward item in value)
			{
				list.Add(item);
			}
			this._storage["ActiveRewards"] = list;
		}
	}

	public void AddReward(IOngoingReward reward)
	{
		IList<IOngoingReward> list = (IList<IOngoingReward>)this.ActiveRewards;
		bool flag = false;
		foreach (IOngoingReward ongoingReward in list)
		{
			if (ongoingReward.Add(reward))
			{
				flag = true;
				break;
			}
		}
		if (!flag)
		{
			list.Add(reward);
			reward.Run();
		}
		this.ActiveRewards = list;
		this.OnRewardAdded(reward);
	}

	public void RemoveReward(IOngoingReward reward)
	{
		IList<IOngoingReward> list = (IList<IOngoingReward>)this.ActiveRewards;
		list.Remove(reward);
		this.ActiveRewards = list;
		this.OnRewardRemoved(reward);
	}

	public void RemoveRewards(IEnumerable<IOngoingReward> rewards)
	{
		IList<IOngoingReward> list = (IList<IOngoingReward>)this.ActiveRewards;
		IList<IOngoingReward> list2 = new List<IOngoingReward>();
		foreach (IOngoingReward item in rewards)
		{
			int num = list.IndexOf(item);
			if (num != -1)
			{
				list.RemoveAt(num);
				list2.Add(item);
			}
		}
		this.ActiveRewards = list;
		foreach (IOngoingReward reward in list2)
		{
			this.OnRewardRemoved(reward);
		}
	}

	public bool RewardIsActive<RewardType>() where RewardType : class, IOngoingReward
	{
		RewardType rewardType = this.FindActiveReward<RewardType>(null);
		return rewardType != null && rewardType.IsActive;
	}

	public RewardType FindActiveReward<RewardType>(Predicate<RewardType> optionalPredicate = null) where RewardType : class, IOngoingReward
	{
		foreach (IOngoingReward ongoingReward in this.ActiveRewards)
		{
			RewardType rewardType = ongoingReward as RewardType;
			if (rewardType != null && (optionalPredicate == null || optionalPredicate(rewardType)))
			{
				return rewardType;
			}
		}
		return (RewardType)((object)null);
	}

	public IOngoingReward FindActiveReward(Predicate<IOngoingReward> predicate)
	{
		foreach (IOngoingReward ongoingReward in this.ActiveRewards)
		{
			if (predicate(ongoingReward))
			{
				return ongoingReward;
			}
		}
		return null;
	}

	public IEnumerable<IOngoingReward> FindActiveRewards(Predicate<IOngoingReward> predicate)
	{
		List<IOngoingReward> list = new List<IOngoingReward>();
		foreach (IOngoingReward ongoingReward in this.ActiveRewards)
		{
			if (predicate(ongoingReward))
			{
				list.Add(ongoingReward);
			}
		}
		return list;
	}

	private void OnRewardAdded(IOngoingReward reward)
	{
		if (this.RewardAdded != null)
		{
			this.RewardAdded(reward);
		}
	}

	private void OnRewardRemoved(IOngoingReward reward)
	{
		if (this.RewardRemoved != null)
		{
			this.RewardRemoved(reward);
		}
	}

	private const string StorageKey = "OngoingRewardManager";

	private const string ActiveRewardsKey = "ActiveRewards";

	public delegate void RewardAddedHandler(IOngoingReward reward);

	public delegate void RewardRemovedHandler(IOngoingReward reward);
}