ESO Lua File v100015

ingame/lfg/zo_activityfinderroot_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
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
local GROUP_TYPE_TO_MAX_SIZE =
{
    [LFG_GROUP_TYPE_REGULAR] = SMALL_GROUP_SIZE_THRESHOLD,
    [LFG_GROUP_TYPE_MEDIUM] = RAID_GROUP_SIZE_THRESHOLD,
    [LFG_GROUP_TYPE_LARGE] = GROUP_SIZE_MAX,
}
local function LFGLevelSort(entry1, entry2)
    if entry1.championPointsMin ~= entry2.championPointsMin then
        return entry1.championPointsMin < entry2.championPointsMin
    elseif entry1.levelMin ~= entry2.levelMin then
        return entry1.levelMin < entry2.levelMin
    elseif entry1.championPointsMax ~= entry2.championPointsMax then
        return entry1.championPointsMax < entry2.championPointsMax
    elseif entry1.levelMax ~= entry2.levelMax then
        return entry1.levelMax < entry2.levelMax
    else
        return entry1.rawName < entry2.rawName
    end
end
local function GetLFGEntryStringKeyboard(rawName, activityType)
    if activityType == LFG_ACTIVITY_MASTER_DUNGEON then
        return zo_iconTextFormat(GetVeteranIcon(), "100%", "100%", rawName)
    else
        return zo_strformat(SI_LFG_ACTIVITY_NAME, rawName)
    end
end
local function GetLFGEntryStringGamepad(rawName, activityType)
    if activityType == LFG_ACTIVITY_MASTER_DUNGEON then
        return zo_strformat(GetString(SI_GAMEPAD_ACTIVITY_FINDER_VETERAN_LOCATION_FORMAT), rawName)
    else
        return zo_strformat(SI_LFG_ACTIVITY_NAME, rawName)
    end
end
local function GetLevelOrChampionPointsRequirementText(levelMin, levelMax, pointsMin, pointsMax)
    local playerChampionPoints = GetUnitChampionPoints("player")
    
    if playerChampionPoints > 0 or levelMin == GetMaxLevel() then
        if playerChampionPoints < pointsMin then
            return zo_strformat(SI_LFG_LOCK_REASON_PLAYER_MIN_CHAMPION_REQUIREMENT, pointsMin)
        elseif playerChampionPoints > pointsMax then
            return zo_strformat(SI_LFG_LOCK_REASON_PLAYER_MAX_CHAMPION_REQUIREMENT, pointsMax)
        end
    else
        local playerLevel = GetUnitLevel("player")
    
        if playerLevel < levelMin then
            return zo_strformat(SI_LFG_LOCK_REASON_PLAYER_MIN_LEVEL_REQUIREMENT, levelMin)
        elseif playerLevel > levelMax then
            return zo_strformat(SI_LFG_LOCK_REASON_PLAYER_MAX_LEVEL_REQUIREMENT, levelMax)
        end
    end
end
local function IsPreferredRoleSelected()
    local isDPS, isHeal, isTank = GetPlayerRoles()
    return isDPS or isHeal or isTank
end
local function CreateLocationData(activityType, lfgIndex)
    local name, levelMin, levelMax, championPointsMin, championPointsMax, groupType, minNumMembers, description = GetLFGOption(activityType, lfgIndex)
    local descriptionTextureSmallKeyboard, descriptionTextureLargeKeyboard = GetLFGOptionKeyboardDescriptionTextures(activityType, lfgIndex)
    local descriptionTextureGamepad = GetLFGOptionGamepadDescriptionTexture(activityType, lfgIndex)
    local requiredCollectible = GetRequiredLFGCollectibleId(activityType, lfgIndex)
    return
    {
        activityType = activityType,
        lfgIndex = lfgIndex,
        nameKeyboard = GetLFGEntryStringKeyboard(name, activityType),
        nameGamepad = GetLFGEntryStringGamepad(name, activityType),
        rawName = name,
        description = description,
        descriptionTextureSmallKeyboard = descriptionTextureSmallKeyboard,
        descriptionTextureLargeKeyboard = descriptionTextureLargeKeyboard,
        descriptionTextureGamepad = descriptionTextureGamepad,
        levelMin = levelMin,
        levelMax = levelMax,
        championPointsMin = championPointsMin,
        championPointsMax = championPointsMax,
        groupType = groupType,
        minGroupSize = minNumMembers,
        maxGroupSize = GetGroupSizeFromLFGGroupType(groupType),
        requiredCollectible = requiredCollectible,
    }
end
------------------
--Initialization--
------------------
ActivityFinderRoot_Manager = ZO_CallbackObject:Subclass()
function ActivityFinderRoot_Manager:New(...)
    local singleton = ZO_CallbackObject.New(self)
    singleton:Initialize(...)
    return singleton
end
function ActivityFinderRoot_Manager:Initialize()
    self.groupSize = 0
    self.activityQueueOnCooldown = false
    self.activityQueueCooldownExpiresAtS = 0
end
function ActivityFinderRoot_Manager:RegisterForEvents()
    local function ClearSelections()
        self:ClearSelections()
    end
    local function MarkDataDirty()
        self:MarkDataDirty()
    end
    function UpdateGroupStatus()
        self:UpdateGroupStatus()
    end
    function OnLevelUpdate(eventCode, unitTag)
        if unitTag == "player" or ZO_Group_IsGroupUnitTag(unitTag) then
            self:MarkDataDirty()
            self:FireCallbacks("OnLevelUpdate")
        end
    end
    function OnCooldownsUpdate()
        local wasActivityQueueOnCooldown = self.activityQueueOnCooldown
        local activityQueueCooldownTimeRemaining = GetActivityQueueCooldownTimeRemainingSeconds()
        self.activityQueueOnCooldown = activityQueueCooldownTimeRemaining > 0
        self.activityQueueCooldownExpiresAtS = activityQueueCooldownTimeRemaining + GetFrameTimeSeconds()
        if self.activityQueueOnCooldown ~= wasActivityQueueOnCooldown then
            self:MarkDataDirty()
        end
        self:FireCallbacks("OnCooldownsUpdate")
    end
    function OnPlayerActivate()
        UpdateGroupStatus()
        OnCooldownsUpdate()
    end
    EVENT_MANAGER:RegisterForEvent("ActivityFinderRoot_Manager", EVENT_ACTIVITY_FINDER_STATUS_UPDATE, function(eventCode, ...) self:OnActivityFinderStatusUpdate(...) end)
    EVENT_MANAGER:RegisterForEvent("ActivityFinderRoot_Manager", EVENT_ACTIVITY_FINDER_COOLDOWNS_UPDATE, OnCooldownsUpdate)
    EVENT_MANAGER:RegisterForEvent("ActivityFinderRoot_Manager", EVENT_CURRENT_CAMPAIGN_CHANGED, MarkDataDirty)
    EVENT_MANAGER:RegisterForEvent("ActivityFinderRoot_Manager", EVENT_COLLECTION_UPDATED, MarkDataDirty)
    EVENT_MANAGER:RegisterForEvent("ActivityFinderRoot_Manager", EVENT_COLLECTIBLE_UPDATED, MarkDataDirty)
    --We should clear selections when switching filters, but we won't necessarily clear them when closing scenes
    --However, we can't ensure that gamepad and keyboard will stay on the same filter, so we'll clear selections when switching between modes
    --This won't require rechecking lock statuses
    EVENT_MANAGER:RegisterForEvent("ActivityFinderRoot_Manager", EVENT_GAMEPAD_PREFERRED_MODE_CHANGED, ClearSelections)
    EVENT_MANAGER:RegisterForEvent("ActivityFinderRoot_Manager", EVENT_LEVEL_UPDATE, OnLevelUpdate)
    EVENT_MANAGER:RegisterForEvent("ActivityFinderRoot_Manager", EVENT_CHAMPION_POINT_UPDATE, OnLevelUpdate)
    
    EVENT_MANAGER:RegisterForEvent("ActivityFinderRoot_Manager", EVENT_PLAYER_ACTIVATED, OnPlayerActivate)
    EVENT_MANAGER:RegisterForEvent("ActivityFinderRoot_Manager", EVENT_GROUP_MEMBER_LEFT, UpdateGroupStatus)
    EVENT_MANAGER:RegisterForEvent("ActivityFinderRoot_Manager", EVENT_UNIT_CREATED, function(eventCode, unitTag) 
        if ZO_Group_IsGroupUnitTag(unitTag) then
            self:UpdateGroupStatus()
        end
    end)
    EVENT_MANAGER:RegisterForEvent("ActivityFinderRoot_Manager", EVENT_GROUP_UPDATE, UpdateGroupStatus)
    EVENT_MANAGER:RegisterForEvent("ActivityFinderRoot_Manager", EVENT_LEADER_UPDATE, UpdateGroupStatus)
    EVENT_MANAGER:RegisterForUpdate("ActivityFinderRoot_Manager", 0, function() self:OnUpdate() end)
end
function ActivityFinderRoot_Manager:InitializeLocationData()
    local locationsLookupData = {}
    local sortedLocationsData = {}
    local randomActivityTypeGroupSizeRanges = {}
    for activityType = LFG_ACTIVITY_MIN_VALUE, LFG_ACTIVITY_MAX_VALUE do
        local numOptions = GetNumLFGOptions(activityType)
        if numOptions > 0 then
            local lookupActivityData = {}
            local sortedActivityData = {}
            local minGroupSize, maxGroupSize
            for lfgIndex = 1, numOptions do
                local data = CreateLocationData(activityType, lfgIndex)
                table.insert(lookupActivityData, data)
                table.insert(sortedActivityData, data)
                if not minGroupSize or minGroupSize > data.minGroupSize then
                    minGroupSize = data.minGroupSize
                end
                if not maxGroupSize or maxGroupSize < data.maxGroupSize then
                    maxGroupSize = data.maxGroupSize
                end
            end
        
            table.sort(sortedActivityData, LFGLevelSort)
            locationsLookupData[activityType] = lookupActivityData
            sortedLocationsData[activityType] = sortedActivityData
            randomActivityTypeGroupSizeRanges[activityType] = { min = minGroupSize, max = maxGroupSize }
        end
    end
    self.sortedLocationsData = sortedLocationsData
    self.locationsLookupData = locationsLookupData
    self.randomActivityTypeGroupSizeRanges = randomActivityTypeGroupSizeRanges
    self.numSelected = 0
    self.randomActivityTypeLockReasons = {}
    self.randomActivitySelections = {}
end
-----------
--Updates--
-----------
function ActivityFinderRoot_Manager:OnUpdate()
    if self.dataDirty then
        self:ClearAndUpdate()
    end
end
function ActivityFinderRoot_Manager:MarkDataDirty()
    self.dataDirty = true
end
function ActivityFinderRoot_Manager:UpdateGroupStatus()
    local wasGrouped = self.playerIsGrouped
    local wasLeader = self.playerIsLeader
    self.playerIsGrouped = IsUnitGrouped("player")
    self.playerIsLeader = IsUnitGroupLeader("player")
    self.groupSize = GetGroupSize()
    local groupStateChanged = wasGrouped ~= self.playerIsGrouped or wasLeader ~= self.playerIsLeader
    if groupStateChanged then
        self:FireCallbacks("OnUpdateGroupStatus", wasGrouped, self.playerIsGrouped, wasLeader, self.playerIsLeader)
    end
    self:MarkDataDirty()
end
function ActivityFinderRoot_Manager:GetGroupStatus()
    return self.playerIsGrouped, self.playerIsLeader, self.groupSize
end
function ActivityFinderRoot_Manager:UpdateLocationData()
    --Determine lock status for each location
    local inAGroup = IsUnitGrouped("player")
    local isLeader = IsUnitGroupLeader("player")
    local isRoleSelected = IsPreferredRoleSelected()
    ZO_ClearTable(self.randomActivityTypeLockReasons)
    for activityType, locationsByActivity in pairs(self.locationsLookupData) do
        local activityIsAvA = activityType == LFG_ACTIVITY_AVA
        local isPlayerInAvAWorld = IsPlayerInAvAWorld()
        local anyEligible = false
        local anyLockReason = nil
        for index, location in ipairs(locationsByActivity) do
            location.isLocked = true
            location.countsForAverageRoleTime = not activityIsAvA
            if self.activityQueueOnCooldown then
                location.lockReasonText = GetString(SI_LFG_LOCK_REASON_QUEUE_COOLDOWN_CONCISE)
            elseif location.requiredCollectible ~= 0 and not IsCollectibleUnlocked(location.requiredCollectible) then
                location.lockReasonText = zo_strformat(SI_LFG_LOCK_REASON_DLC_NOT_UNLOCKED, GetCollectibleName(location.requiredCollectible))
                location.countsForAverageRoleTime = false
            elseif not isRoleSelected then
                location.lockReasonText = GetString(SI_LFG_LOCK_REASON_NO_ROLES_SELECTED)
            elseif activityIsAvA and not isPlayerInAvAWorld then
                location.lockReasonText = GetString(SI_LFG_LOCK_REASON_NOT_IN_AVA)
            elseif not activityIsAvA and isPlayerInAvAWorld then
                location.lockReasonText = GetString(SI_LFG_LOCK_REASON_IN_AVA)
            else
                location.playerMeetsLevelRequirements = DoesPlayerMeetLFGLevelRequirements(activityType, index)
                location.groupMeetsLevelRequirements = DoesGroupMeetLFGLevelRequirements(activityType, index)
    
                local groupTooLarge = self.groupSize > GROUP_TYPE_TO_MAX_SIZE[location.groupType]
                if groupTooLarge then
                    location.lockReasonText = GetString(SI_LFG_LOCK_REASON_GROUP_TOO_LARGE)
                elseif not location.playerMeetsLevelRequirements then
                    location.lockReasonText = GetLevelOrChampionPointsRequirementText(location.levelMin, location.levelMax, location.championPointsMin, location.championPointsMax)
                    location.countsForAverageRoleTime = false
                elseif inAGroup and not location.groupMeetsLevelRequirements then
                    location.lockReasonText = GetString(SI_LFG_LOCK_REASON_GROUP_LOCATION_LEVEL_REQUIREMENTS)
                elseif inAGroup and not isLeader then
                    location.lockReasonText = GetString(SI_LFG_LOCK_REASON_NOT_LEADER)
                else
                    location.isLocked = false
                    location.lockReasonText = ""
                    anyEligible = true
                end
            end
            if location.lockReasonText ~= "" then
                anyLockReason = location.lockReasonText
            end
        end
        if anyEligible then
            self.randomActivityTypeLockReasons[activityType] = nil
        else
            self.randomActivityTypeLockReasons[activityType] = anyLockReason
        end
    end
    self:FireCallbacks("OnUpdateLocationData")
end
function ActivityFinderRoot_Manager:ClearSelections()
    for activityType, locationsByActivity in pairs(self.locationsLookupData) do
        self.randomActivitySelections[activityType] = false
        for index, location in ipairs(locationsByActivity) do
            location.isSelected = false
        end
    end
    
    self.numSelected = GetNumLFGRequests()
    for i = 1, self.numSelected do
        local activityType, index = GetLFGRequestInfo(i)
        local location = self.locationsLookupData[activityType][index]
        location.isSelected = true
    end
end
function ActivityFinderRoot_Manager:ClearAndUpdate()
    --A clear and update is required when the selections may change due to requirement changes. (Ex: a group member
    --joins that doesn't meet the level requirement of a location already selected. The location needs to be unselected
    --and locked, and then all other locations need to be refreshed again in case they are now unlocked. Instead of
    --nesting refreshes, just clear and update when an event occurs that can lead to this.)
    self.dataDirty = false
end
function ActivityFinderRoot_Manager:OnActivityFinderStatusUpdate(status)
    self.activityFinderStatus = status
    self:FireCallbacks("OnActivityFinderStatusUpdate", status)
end
-------------
--Accessors--
-------------
function ActivityFinderRoot_Manager:GetLocationsData(activityType)
    if activityType then
        return self.sortedLocationsData[activityType]
    else
        return self.sortedLocationsData
    end
end
function ActivityFinderRoot_Manager:GetLocation(activityType, lfgIndex)
    local locationsByActivity = self.locationsLookupData[activityType]
    if locationsByActivity then
        local location = locationsByActivity[lfgIndex]
        if location then
            return location
        end
    end
    assert(false) --We should never be asking for a location using a bad activity or lfgIndex, fix the code that called this
end
function ActivityFinderRoot_Manager:GetAverageRoleTime(role)
    local lowestAverage
    for activityType, locationsByActivity in pairs(self.locationsLookupData) do
        for index, location in ipairs(locationsByActivity) do
            if location.countsForAverageRoleTime then
                local dataFound, averageForLocation = GetLFGAverageRoleTimeByActivity(activityType, index, role)
                if dataFound then
                    if lowestAverage then
                        lowestAverage = zo_min(lowestAverage, averageForLocation)
                    else
                        lowestAverage = averageForLocation
                    end
                end
            end
        end
    end
    return lowestAverage or 0
end
function ActivityFinderRoot_Manager:GetIsCurrentlyInQueue()
    return self.activityFinderStatus == ACTIVITY_FINDER_STATUS_QUEUED
end
function ActivityFinderRoot_Manager:ToggleLocationSelected(location)
    self:SetLocationSelected(location, not location.isSelected)
end
function ActivityFinderRoot_Manager:SetLocationSelected(location, selected)
    if location.isLocked or IsCurrentlySearchingForGroup() or location.isSelected == selected then
        return
    end
    location.isSelected = selected
    local delta = location.isSelected and 1 or -1
    self.numSelected = self.numSelected + delta
    self:FireCallbacks("OnSelectionsChanged")
end
function ActivityFinderRoot_Manager:ToggleActivityTypeSelected(activityType)
    self:SetActivityTypeSelected(activityType, not self.randomActivitySelections[activityType])
end
function ActivityFinderRoot_Manager:SetActivityTypeSelected(activityType, selected)
    if not self:CanChooseRandomForActivityType(activityType) or IsCurrentlySearchingForGroup() or self.randomActivitySelections[activityType] == selected then
        return
    end
    self.randomActivitySelections[activityType] = selected
    local delta = selected and 1 or -1
    self.numSelected = self.numSelected + delta
    self:FireCallbacks("OnSelectionsChanged")
end
function ActivityFinderRoot_Manager:IsActivityTypeSelected(activityType)
    return self.randomActivitySelections[activityType]
end
function ActivityFinderRoot_Manager:IsAnyLocationSelected()
    return self.numSelected > 0
end
function ActivityFinderRoot_Manager:CanChooseRandomForActivityType(activityType)
    return self.randomActivityTypeLockReasons[activityType] == nil
end
function ActivityFinderRoot_Manager:GetLockReasonForActivityType(activityType)
    return self.randomActivityTypeLockReasons[activityType]
end
function ActivityFinderRoot_Manager:GetGroupSizeRangeForActivityType(activityType)
    local groupSizeRangeTable = self.randomActivityTypeGroupSizeRanges[activityType]
    return groupSizeRangeTable.min, groupSizeRangeTable.max
end
function ActivityFinderRoot_Manager:IsActivityQueueOnCooldown()
    return self.activityQueueOnCooldown
end
function ActivityFinderRoot_Manager:GetActivityQueueCooldownExpireTimeS()
    return self.activityQueueCooldownExpiresAtS
end
function ActivityFinderRoot_Manager:StartSearch()
    if IsCurrentlySearchingForGroup() then
        return
    end
    if not IsPreferredRoleSelected() then
        ZO_AlertEvent(EVENT_ACTIVITY_QUEUE_RESULT, ACTIVITY_QUEUE_RESULT_NO_ROLES_SELECTED)
        return
    end
    --Add locations
    for activityType, locationsByActivity in pairs(self.locationsLookupData) do
        if self.randomActivitySelections[activityType] then
            AddGroupFinderSearchEntry(activityType)
        end
        for index, location in ipairs(locationsByActivity) do
            if location.isSelected then
                AddGroupFinderSearchEntry(activityType, index)
            end
        end
    end
    local result = StartGroupFinderSearch()
    if result ~= ACTIVITY_QUEUE_RESULT_SUCCESS then
        ZO_AlertEvent(EVENT_ACTIVITY_QUEUE_RESULT, result)
    end
end
function ActivityFinderRoot_Manager:HandleLFMPromptResponse(accept)
    --Any response should clear the prompt, but only acceptance sends the request
    if accept then
        SendLFMRequest()
    end
    self:FireCallbacks("OnHandleLFMPromptResponse")
end
 ZO_ACTIVITY_FINDER_ROOT_MANAGER = ActivityFinderRoot_Manager:New()