Back to Home

ESO Lua File v101042

publicallingames/chapterupgrade/chapterupgrade_manager.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
288
289
290
291
292
293
294
-----------------
-- Data Object --
-----------------
ZO_CHAPTER_UPGRADE_REWARD_TYPE =
{
    PRE_PURCHASE = 1,
    BASIC = 2,
    PRE_ORDER = 3,
}
ZO_ChapterUpgrade_Data = ZO_InitializingObject:Subclass()
function ZO_ChapterUpgrade_Data:Initialize(chapterUpgradeId)
    local _
    self.chapterUpgradeId = chapterUpgradeId
    self.marketProductId = 0
    self.collectibleId = GetChapterCollectibleId(chapterUpgradeId)
    self.name, _, self.collectibleIcon = GetCollectibleInfo(self.collectibleId)
    self.summary = GetChapterSummary(chapterUpgradeId)
    self.marketBackgroundImage = GetChapterMarketBackgroundFileImage(chapterUpgradeId)
    self.isNew = false
    self.discountPercent = 0
end
function ZO_ChapterUpgrade_Data:RefreshChapterUpgradeState()
    self.isPreRelease = IsChapterPreRelease(self.chapterUpgradeId)
    if self.isPreRelease then
        self.releaseDateString = GetChapterReleaseDateString(self.chapterUpgradeId)
    else
        self.releaseDateString = nil
    end
    self.isOwned = IsChapterOwned(self.chapterUpgradeId)
end
do
    local function RewardEntryComparator(leftData, rightData)
        if leftData.isStandardReward == rightData.isStandardReward and leftData.isCollectorsReward == rightData.isCollectorsReward then
            if leftData.rewardType == rightData.rewardType then
                --Fall back to def order
                return leftData.index < rightData.index
            else
                --Secondary ordering is reward type, basic comes before preorder
                return leftData.rewardType < rightData.rewardType
            end
        else
            -- Primary ordering is what edition the reward can be found in
            if (leftData.isStandardReward and leftData.isCollectorsReward) or not (rightData.isStandardReward or rightData.isCollectorsReward) then
                --If both editions are checked: first; If neither edition is checked: last
                return true
            elseif rightData.isStandardReward and rightData.isCollectorsReward then
                --If both editions are checked: first
                return false
            else
                --One has standard, the other has collector's, and collector's comes first
                return leftData.isCollectorsReward
            end
        end
    end
    local function AddRewardsData(rewardsTable, chapterUpgradeId, numRewardsFunction, rewardInfoFunction, rewardType)
        for i = 1, numRewardsFunction(chapterUpgradeId) do
            local marketProductId, isStandardReward, isCollectorsReward = rewardInfoFunction(chapterUpgradeId, i)
            local data =
            {
                index = i,
                marketProductId = marketProductId,
                displayName = zo_strformat(SI_MARKET_PRODUCT_NAME_FORMATTER, GetMarketProductDisplayName(marketProductId)),
                icon = GetMarketProductIcon(marketProductId),
                isStandardReward = isStandardReward,
                isCollectorsReward = isCollectorsReward,
                rewardType = rewardType,
            }
            table.insert(rewardsTable, data)
        end
        table.sort(rewardsTable, RewardEntryComparator)
    end
    function ZO_ChapterUpgrade_Data:PopulateRewardsData()
        self.prePurchaseRewards = {}
        AddRewardsData(self.prePurchaseRewards, self.chapterUpgradeId, GetNumChapterPrePurchaseRewards, GetChapterPrePurchaseRewardInfo, ZO_CHAPTER_UPGRADE_REWARD_TYPE.PRE_PURCHASE)
        self.preOrderRewards = {}
        AddRewardsData(self.preOrderRewards, self.chapterUpgradeId, GetNumChapterPreOrderRewards, GetChapterPreOrdereRewardInfo, ZO_CHAPTER_UPGRADE_REWARD_TYPE.PRE_ORDER)
        self.basicRewards = {}
        AddRewardsData(self.basicRewards, self.chapterUpgradeId, GetNumChapterBasicRewards, GetChapterBasicRewardInfo, ZO_CHAPTER_UPGRADE_REWARD_TYPE.BASIC)
        if self.isPreRelease then
            self.editionRewards = {}
            ZO_CombineNumericallyIndexedTables(self.editionRewards, self.basicRewards, self.preOrderRewards)
            table.sort(self.editionRewards, RewardEntryComparator)
        else
            self.editionRewards = self.basicRewards
        end
    end
end
function ZO_ChapterUpgrade_Data:SetMarketProductId(marketProductId)
    self.marketProductId = marketProductId
    self.isNew = select(4, GetMarketProductInfo(marketProductId))
    self.discountPercent = select(4, GetMarketProductPricingByPresentation(self.marketProductId))
end
function ZO_ChapterUpgrade_Data:GetChapterUpgradeId()
    return self.chapterUpgradeId
end
function ZO_ChapterUpgrade_Data:GetName()
    return self.name
end
function ZO_ChapterUpgrade_Data:GetFormattedName()
    return ZO_CachedStrFormat(SI_COLLECTIBLE_NAME_FORMATTER, self.name)
end
function ZO_ChapterUpgrade_Data:GetCollectibleIcon()
    return self.collectibleIcon
end
function ZO_ChapterUpgrade_Data:GetCollectibleId()
    return self.collectibleId
end
function ZO_ChapterUpgrade_Data:GetSummary()
    return self.summary
end
function ZO_ChapterUpgrade_Data:IsPreRelease()
    return self.isPreRelease
end
function ZO_ChapterUpgrade_Data:GetReleaseDateText()
    return self.releaseDateString
end
function ZO_ChapterUpgrade_Data:GetMarketBackgroundImage()
    return self.marketBackgroundImage
end
function ZO_ChapterUpgrade_Data:IsOwned()
    return self.isOwned
end
function ZO_ChapterUpgrade_Data:GetPurchasedState()
    if self.isOwned then
        return CHAPTER_PURCHASE_STATE_PURCHASED
    elseif self.isPreRelease then
        return CHAPTER_PURCHASE_STATE_PRE_PURCHASE
    else
        return CHAPTER_PURCHASE_STATE_UPGRADE
    end
end
function ZO_ChapterUpgrade_Data:HasMarketProductData()
    return self.marketProductId ~= 0
end
function ZO_ChapterUpgrade_Data:GetLTOTimeLeftInSeconds()
    if self:HasMarketProductData() then
        return GetMarketProductLTOTimeLeftInSeconds(self.marketProductId)
    end
    return 0
end
function ZO_ChapterUpgrade_Data:IsLimitedTime()
    local remainingTime = self:GetLTOTimeLeftInSeconds()
    return remainingTime > 0 and remainingTime <= ZO_ONE_MONTH_IN_SECONDS
end
function ZO_ChapterUpgrade_Data:GetDiscountPercent()
    return self.discountPercent
end
function ZO_ChapterUpgrade_Data:IsNew()
    return self.isNew
end
function ZO_ChapterUpgrade_Data:GetPrePurchaseRewards()
    return self.prePurchaseRewards
end
function ZO_ChapterUpgrade_Data:GetPreOrderRewards()
    return self.preOrderRewards
end
function ZO_ChapterUpgrade_Data:GetBasicRewards()
    return self.basicRewards
end
function ZO_ChapterUpgrade_Data:GetEditionRewards()
    return self.editionRewards
end
-------------
-- Manager --
-------------
local ChapterUpgrade_Manager = ZO_InitializingCallbackObject:Subclass()
function ChapterUpgrade_Manager:Initialize()
    local currentChapterId = GetCurrentChapterUpgradeId()
    self.currentChapterData = ZO_ChapterUpgrade_Data:New(currentChapterId)
    self.chapterUpgradeDataList = {}
    self.chapterUpgradeDataById = {}
    self.marketState = GetMarketState(MARKET_DISPLAY_GROUP_CHAPTER_UPGRADE)
    local function OnMarketStateUpdated(eventCode, displayGroup, marketState)
        if displayGroup == MARKET_DISPLAY_GROUP_CHAPTER_UPGRADE then
            self.marketState = marketState
            self:RefreshChapterUpgradeData()
        end
    end
    local function OnCollectiblesUnlockStateChanged()
        self.currentChapterData:RefreshChapterUpgradeState()
        for _, data in ipairs(self.chapterUpgradeDataList) do
            data:RefreshChapterUpgradeState()
        end
    end
    EVENT_MANAGER:RegisterForEvent("ChapterUpgrade_Manager", EVENT_MARKET_STATE_UPDATED, OnMarketStateUpdated)
    EVENT_MANAGER:RegisterForEvent("ChapterUpgrade_Manager", EVENT_COLLECTIBLES_UNLOCK_STATE_CHANGED, OnCollectiblesUnlockStateChanged)
end
do
    local function ChapterUpgradeDataSort(left, right)
        local leftChapterUpgradeId = left:GetChapterUpgradeId()
        local rightChapterUpgradeId = right:GetChapterUpgradeId()
        local leftChapterEnum = GetChapterEnumFromUpgradeId(leftChapterUpgradeId)
        local rightChapterEnum = GetChapterEnumFromUpgradeId(rightChapterUpgradeId)
        if leftChapterEnum == rightChapterEnum then
            return leftChapterUpgradeId > rightChapterUpgradeId
        else
            return leftChapterEnum > rightChapterEnum
        end
    end
    function ChapterUpgrade_Manager:RefreshChapterUpgradeData()
        ZO_ClearNumericallyIndexedTable(self.chapterUpgradeDataList)
        ZO_ClearTable(self.chapterUpgradeDataById)
        local marketProductIds = { GetActiveChapterUpgradeMarketProductListings(MARKET_DISPLAY_GROUP_CHAPTER_UPGRADE) }
        for _, marketProductId in ipairs(marketProductIds) do
            local chapterUpgradeId = GetMarketProductChapterUpgradeId(marketProductId)
            -- Two entries for the same chapter id is undefined behavior, so just ignore duplicates
            if not self.chapterUpgradeDataById[chapterUpgradeId] then
                local chapterUpgradeData = ZO_ChapterUpgrade_Data:New(chapterUpgradeId)
                chapterUpgradeData:SetMarketProductId(marketProductId)
                table.insert(self.chapterUpgradeDataList, chapterUpgradeData)
                self.chapterUpgradeDataById[chapterUpgradeId] = chapterUpgradeData
            end
        end
        if #marketProductIds == 0 then
            --static fallback data
            table.insert(self.chapterUpgradeDataList, self.currentChapterData)
            self.chapterUpgradeDataById[self.currentChapterData:GetChapterUpgradeId()] = self.currentChapterData
        end
        table.sort(self.chapterUpgradeDataList, ChapterUpgradeDataSort)
        self:FireCallbacks("ChapterUpgradeDataUpdated")
    end
end
function ChapterUpgrade_Manager:GetChapterUpgradeDataByIndex(index)
    return self.chapterUpgradeDataList[index]
end
function ChapterUpgrade_Manager:GetChapterUpgradeDataById(chapterUpgradeId)
    return self.chapterUpgradeDataById[chapterUpgradeId]
end
function ChapterUpgrade_Manager:GetNumChapterUpgrades()
    return #self.chapterUpgradeDataList
end
function ChapterUpgrade_Manager:RequestPrepurchaseData()
    OpenMarket(MARKET_DISPLAY_GROUP_CHAPTER_UPGRADE)
end
function ChapterUpgrade_Manager:GetMarketState()
    return self.marketState
end
ZO_CHAPTER_UPGRADE_MANAGER = ChapterUpgrade_Manager:New()