597 时装特卖

lcy

16 小时以前 3575c016271e455cfaab964b98e3d4ef84ef75cb

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//修改成控制多个活动模块，如精彩活动模板1，精彩活动模板2
 
public class OpenServerActivityCenter : Singleton<OpenServerActivityCenter>
{
    public event Action openServerActivityStateChange;
 
    //{活动ID：活动接口}
    Dictionary<int, IOpenServerActivity> GameServerActivitys = new Dictionary<int, IOpenServerActivity>();
 
    public int selectFuncOrder = -1;
 
    public OpenServerActivityCenter()
    {
        TimeUtility.OnServerOpenDayRefresh -= OnServerOpenDayRefresh;
        TimeUtility.OnServerOpenDayRefresh += OnServerOpenDayRefresh;
    }
 
    public void Register(int funcOrder, IOpenServerActivity activity)
    {
        if (!GameServerActivitys.ContainsKey(funcOrder))
        {
            GameServerActivitys.Add(funcOrder, activity);
            activity.onStateUpdate -= OnStateUpdate;
            activity.onStateUpdate += OnStateUpdate;
        }
    }
 
    private void OnStateUpdate(int _order)
    {
        if (openServerActivityStateChange != null)
        {
            openServerActivityStateChange();
        }
    }
 
    private void OnServerOpenDayRefresh()
    {
        if (openServerActivityStateChange != null)
        {
            openServerActivityStateChange();
        }
    }
 
    public bool IsAnyActivityOpen(out int _functionOrder)
    {
        _functionOrder = 0;
        foreach (var _order in GameServerActivitys.Keys)
        {
            if (GameServerActivitys[_order].IsOpen || GameServerActivitys[_order].IsAdvance)
            {
                _functionOrder = _order;
                return true;
            }
        }
        return false;
    }
 
    public bool IsActivityOpen(int _funcOrder)
    {
        bool isOpen = false;
        if (GameServerActivitys.ContainsKey(_funcOrder))
        {
            isOpen = GameServerActivitys[_funcOrder].IsOpen || GameServerActivitys[_funcOrder].IsAdvance;
        }
 
        return isOpen;
    }
 
    public bool IsPriorityOpenOpen(int _funcOrder)
    {
        if (GameServerActivitys.ContainsKey(_funcOrder))
        {
            return GameServerActivitys[_funcOrder].priorityOpen;
        }
        return false;
    }
 
 
 
    public void ProcessErrorTip()
    {
        SysNotifyMgr.Instance.ShowTip("ActiveOutTime");
    }
}
 
public interface IOpenServerActivity
{
    bool IsOpen { get; }
    bool IsAdvance { get; }
    bool priorityOpen { get; }
 
    event Action<int> onStateUpdate;
}
 
public class ILOpenServerActivityProxy : IOpenServerActivity
{
    public bool IsOpen => funcIsOpen();
 
    public bool IsAdvance => funcIsAdvance();
 
    public bool priorityOpen => funcPriorityOpen();
 
    public event Action<int> onStateUpdate;
 
    private Func<bool> funcIsOpen;
    private Func<bool> funcIsAdvance;
    private Func<bool> funcPriorityOpen;
 
    public ILOpenServerActivityProxy(Func<bool> isOpen, Func<bool> isAdvance, Func<bool> priorityOpen)
    {
        funcIsOpen = isOpen;
        funcIsAdvance = isAdvance;
        funcPriorityOpen = priorityOpen;
    }
 
 
    public void StateUpdate(int id)
    {
        if (onStateUpdate != null)
        {
            onStateUpdate(id);
        }
    }
 
}