Back to Home

ESO Lua File v101050

ingame/timedactivities/timedactivities_shared.lua

[◄ back to folders ]
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
local CHECKBOX_CLAIM_THRESHOLD = 0
ZO_TimedActivities_Shared = ZO_InitializingObject:Subclass()
function ZO_TimedActivities_Shared:Initialize(control)
    self.control = control
    self.sceneFragment = ZO_FadeSceneFragment:New(control)
end
-- Gamepad and keyboard get there from different directions, but both have a route to OnDeferredInitialize
function ZO_TimedActivities_Shared:OnDeferredInitialize()
    self.availableActivityTypes = TIMED_ACTIVITIES_MANAGER:GetAvailableActivityTypes()
    local function OnRefreshAvailability(availableActivityTypes)
        self.availableActivityTypes = availableActivityTypes
        self:RefreshAvailability()
        self:UpdateKeybinds()
    end
    local function OnActivitiesUpdated()
        self:MarkDirty()
        self:RefreshNewIndicators()
        self:UpdateKeybinds()
    end
    local function OnSeenActivitiesUpdated()
        self:RefreshNewIndicators()
    end
    local function OnRerollCostReset()
        self:UpdateKeybinds()
    end
    TIMED_ACTIVITIES_MANAGER:RegisterCallback("OnRefreshAvailability", OnRefreshAvailability)
    TIMED_ACTIVITIES_MANAGER:RegisterCallback("OnActivitiesUpdated", OnActivitiesUpdated)
    TIMED_ACTIVITIES_MANAGER:RegisterCallback("OnActivityUpdated", OnActivitiesUpdated)
    TIMED_ACTIVITIES_MANAGER:RegisterCallback("SeenActivitiesUpdated", OnSeenActivitiesUpdated)
    TIMED_ACTIVITIES_MANAGER:RegisterCallback("RerollCostReset", OnRerollCostReset)
    local function OnCurrencyUpdated(_, currencyType)
        if not self.control:IsHidden() then
            if currencyType == CURT_TOME_CHALLENGE_REROLLS or currencyType == CURT_MONEY then
                self:OnRerollCurrencyUpdated()
                self:UpdateKeybinds()
            end
        end
    end
    self.control:RegisterForEvent(EVENT_CURRENCY_UPDATE, OnCurrencyUpdated)
end
function ZO_TimedActivities_Shared:InitializeRefreshGroups()
    self.refreshGroups = ZO_Refresh:New()
    self.refreshGroups:AddRefreshGroup("FullUpdate", {
        RefreshAll = function()
            self:Refresh()
        end,
    })
    self:MarkDirty()
    self.control:SetHandler("OnUpdate", function()
        self.refreshGroups:UpdateRefreshGroups()
    end, "Refresh")
end
function ZO_TimedActivities_Shared:IsActivityTypeAvailable(activityType)
    return self.availableActivityTypes[activityType]
end
function ZO_TimedActivities_Shared:GetCurrentActivityType()
    return self.currentActivityType
end
function ZO_TimedActivities_Shared:GetCurrentActivityTypeString()
    return GetString("SI_TIMEDACTIVITYTYPE", self.currentActivityType)
end
ZO_TimedActivities_Shared:MUST_IMPLEMENT("SelectActivityTypeCategory")
ZO_TimedActivities_Shared:MUST_IMPLEMENT("UpdateKeybinds")
function ZO_TimedActivities_Shared:SetCurrentActivityType(activityType)
    if activityType ~= self.currentActivityType then
        -- Order matters:
        self.currentActivityType = activityType
        self:MarkDirty()
    end
end
function ZO_TimedActivities_Shared:GetCurrentActivityTypeTimeRemainingString()
    local timeRemainingS = TIMED_ACTIVITIES_MANAGER:GetTimedActivityTypeTimeRemainingSeconds(self.currentActivityType)
    if timeRemainingS > 0 then
        return ZO_FormatTime(timeRemainingS, TIME_FORMAT_STYLE_SHOW_LARGEST_TWO_UNITS, TIME_FORMAT_PRECISION_SECONDS, TIME_FORMAT_DIRECTION_DESCENDING)
    end
    return ""
end
function ZO_TimedActivities_Shared:MarkDirty()
    self.refreshGroups:RefreshAll("FullUpdate")
end
function ZO_TimedActivities_Shared:Refresh()
    self:RefreshList(currentActivityType, activityEntries)
end
-- To be overridden and use the return to populate the platform list format
function ZO_TimedActivities_Shared:RefreshList()
    local currentActivityType = self:GetCurrentActivityType()
    local activityTypeFilters
    if currentActivityType == TIMED_ACTIVITY_TYPE_WEEKLY then
        activityTypeFilters = { ZO_TimedActivityData.IsWeeklyActivity }
    elseif currentActivityType == TIMED_ACTIVITY_TYPE_SEASONAL then
        activityTypeFilters = { ZO_TimedActivityData.IsSeasonalActivity }
    end
    local activityEntries = {}
    for index, activityData in TIMED_ACTIVITIES_MANAGER:ActivitiesIterator(activityTypeFilters) do
        table.insert(activityEntries, ZO_EntryData:New(activityData))
    end
    return currentActivityType, activityEntries
end
function ZO_TimedActivities_Shared:RefreshAvailability()
    local activityType = self:GetCurrentActivityType()
    local isAvailable = self:IsActivityTypeAvailable(activityType)
    local emptyMessage = nil
    if not isAvailable then
        local activityTypeName = GetString("SI_TIMEDACTIVITYTYPE", activityType)
        emptyMessage = zo_strformat(SI_TIMED_ACTIVITIES_EMPTY_LIST, activityTypeName)
    end
    return isAvailable, emptyMessage
end
function ZO_TimedActivities_Shared:RefreshNewIndicators()
    local showIndicator
    showIndicator = TIMED_ACTIVITIES_MANAGER:HasClaimableTimedActivities(TIMED_ACTIVITY_TYPE_WEEKLY) or TIMED_ACTIVITIES_MANAGER:HasNewTimedActivities(TIMED_ACTIVITY_TYPE_WEEKLY)
    self.weeklyNewIndicatorTexture:SetHidden(not showIndicator)
    showIndicator = TIMED_ACTIVITIES_MANAGER:HasClaimableTimedActivities(TIMED_ACTIVITY_TYPE_SEASONAL) or TIMED_ACTIVITIES_MANAGER:HasNewTimedActivities(TIMED_ACTIVITY_TYPE_SEASONAL)
    self.seasonalNewIndicatorTexture:SetHidden(not showIndicator)
end
function ZO_TimedActivities_Shared.SetupClaimProgress(timedActivityData, claimableLabel, checkboxControlPool)
    checkboxControlPool:ReleaseAllObjects()
    local isFullyClaimedOrExpired = timedActivityData:IsFullyClaimedOrExpired()
    local numTimesClaimed = timedActivityData:GetNumTimesClaimed()
    local totalNumTimesClaimable = timedActivityData:GetTotalNumTimesClaimable()
    if totalNumTimesClaimable <= CHECKBOX_CLAIM_THRESHOLD then
        if totalNumTimesClaimable == 0 then
            claimableLabel:SetText(GetString(SI_TIMED_ACTIVITY_INFINITELY_REPEATABLE))
        else
            claimableLabel:SetText(" ") -- Force a height so the time remaining label can anchor nicely
        end
        local previousCheckboxControl = nil
        for i = 1, totalNumTimesClaimable do
            local checkboxControl = checkboxControlPool:AcquireObject()
            checkboxControl:SetParent(claimableLabel)
            if previousCheckboxControl then
                checkboxControl:SetAnchor(BOTTOMLEFT, previousCheckboxControl, BOTTOMRIGHT, 5)
            else
                checkboxControl:SetAnchor(BOTTOMLEFT, claimableLabel)
            end
            if i <= numTimesClaimed then
                checkboxControl:SetCheckState(TRISTATE_CHECK_BUTTON_CHECKED)
            else
                checkboxControl:SetCheckState(TRISTATE_CHECK_BUTTON_UNCHECKED)
            end
            ZO_ReadonlyCheckButton_SetEnableState(checkboxControl, not isFullyClaimedOrExpired)
            previousCheckboxControl = checkboxControl
        end
    else
        local formatter = isFullyClaimedOrExpired and SI_TIMED_ACTIVITY_CLAIMED_PROGRESS_DISABLED or SI_TIMED_ACTIVITY_CLAIMED_PROGRESS
        claimableLabel:SetText(zo_strformat(formatter, numTimesClaimed, totalNumTimesClaimable))
    end
    local claimableLabelColor = isFullyClaimedOrExpired and ZO_NORMAL_TEXT:GetDim() or ZO_NORMAL_TEXT
    claimableLabel:SetColor(claimableLabelColor:UnpackRGBA())
end
function ZO_TimedActivities_Shared.RefreshTimeRemaining(timedActivityData, timeRemainingLabel)
    local timeRemainingS = timedActivityData:GetTimeRemainingS()
    if timeRemainingS then
        local isFullyClaimed = timedActivityData:IsFullyClaimed()
        local timeRemainingText
        if timeRemainingS == 0 then
            timeRemainingText = zo_strformat(SI_TIMED_ACTIVITY_TIME_REMAINING, GetString(SI_TIMED_ACTIVITY_TIME_EXPIRED))
            timeRemainingText = ZO_ERROR_COLOR:ColorizeDim(timeRemainingText)
        else
            timeRemainingText = ZO_FormatTimeLargestTwo(timeRemainingS, TIME_FORMAT_STYLE_DESCRIPTIVE_MINIMAL)
            if isFullyClaimed then
                timeRemainingText = ZO_WHITE:ColorizeDim(timeRemainingText)
            else
                timeRemainingText = ZO_WHITE:Colorize(timeRemainingText)
            end
        end
        local timeRemainingColor = isFullyClaimed and ZO_NORMAL_TEXT:GetDim() or ZO_NORMAL_TEXT
        timeRemainingLabel:SetColor(timeRemainingColor:UnpackRGBA())
        timeRemainingLabel:SetText(zo_strformat(SI_TIMED_ACTIVITY_TIME_REMAINING, timeRemainingText))
        timeRemainingLabel:SetHidden(false)
        if timeRemainingS > ZO_ONE_DAY_IN_SECONDS + ZO_ONE_HOUR_IN_SECONDS then
            timeRemainingLabel.nextUpdateS = GetFrameTimeSeconds() + ZO_ONE_HOUR_IN_SECONDS
        elseif timeRemainingS > ZO_ONE_HOUR_IN_SECONDS + ZO_ONE_MINUTE_IN_SECONDS then
            timeRemainingLabel.nextUpdateS = GetFrameTimeSeconds() + ZO_ONE_MINUTE_IN_SECONDS
        else
            timeRemainingLabel.nextUpdateS = GetFrameTimeSeconds() + 1
        end
        if not timeRemainingLabel:IsHandlerSet("OnUpdate") then
            timeRemainingLabel:SetHandler("OnUpdate", function(_, frameTimeS)
                if frameTimeS > timeRemainingLabel.nextUpdateS then
                    ZO_TimedActivities_Shared.RefreshTimeRemaining(timedActivityData, timeRemainingLabel)
                end
            end)
        end
    else
        timeRemainingLabel:SetHidden(true)
    end
end
ZO_TimedActivities_Shared:MUST_IMPLEMENT("RefreshCurrentActivityInfo")
ZO_TimedActivities_Shared:MUST_IMPLEMENT("InitializeControls")
ZO_TimedActivities_Shared:MUST_IMPLEMENT("OnRerollCurrencyUpdated")
function ZO_TimedActivities_Shared:IsShowing()
    return not self.control:IsHidden()
end
function ZO_TimedActivities_Shared:OnShowing()
    if self.browseTimedActivityDataOnShow then
        self:BrowseToTimedActivityData(self.browseTimedActivityDataOnShow)
        self.browseTimedActivityDataOnShow = nil
    else
        self.refreshGroups:UpdateRefreshGroups()
    end
end
function ZO_TimedActivities_Shared:OnShown()
    TriggerTutorial(TUTORIAL_TRIGGER_TAMRIEL_TOMES_CHALLENGES_OPENED)
end
function ZO_TimedActivities_Shared:OnHiding()
    -- Can be overridden
end
function ZO_TimedActivities_Shared:OnHidden()
    -- Can be overridden
end
function ZO_TimedActivities_Shared:BrowseToTimedActivityData(timedActivityData)
    if not self:IsShowing() then
        self.browseTimedActivityDataOnShow = timedActivityData
        SCENE_MANAGER:Show(self:GetScene():GetName())
        return
    end
    self.selectTimedActivityDataOnRefresh = timedActivityData
    self:SelectActivityTypeCategory(timedActivityData:GetType())
    self:MarkDirty()
    self.refreshGroups:UpdateRefreshGroups()
end
function ZO_TimedActivities_Shared:TryRerollTimedActivity(timedActivityData)
    if not timedActivityData:CanReroll() then
        return
    end
    local currencyType, currencyCost = TIMED_ACTIVITIES_MANAGER.GetRerollCostCurrencyTypeAndCost()
    if currencyType == CURT_MONEY then
        ZO_Dialogs_ShowPlatformDialog(self.rerollDialogName, timedActivityData)
    else
        timedActivityData:Reroll()
    end
end