Dota-Zombie-Invasion/scripts/vscripts/contracts/contract_match_manager.lua

local ____lualib = require("lualib_bundle")
local __TS__Class = ____lualib.__TS__Class
local Map = ____lualib.Map
local __TS__New = ____lualib.__TS__New
local __TS__ArrayMap = ____lualib.__TS__ArrayMap
local __TS__ObjectKeys = ____lualib.__TS__ObjectKeys
local __TS__ArrayFind = ____lualib.__TS__ArrayFind
local __TS__ArraySome = ____lualib.__TS__ArraySome
local __TS__ArrayFilter = ____lualib.__TS__ArrayFilter
local ____exports = {}
local ____contract_steam_compare = require("contracts.contract_steam_compare")
local compareSteamIdDecimalString = ____contract_steam_compare.compareSteamIdDecimalString
local ____contract_backend_adapter = require("contracts.contract_backend_adapter")
local clampContractMultiplierFromBackend = ____contract_backend_adapter.clampContractMultiplierFromBackend
local contractAdapterFinalizeContractVoting = ____contract_backend_adapter.contractAdapterFinalizeContractVoting
local contractAdapterGetPlayerContracts = ____contract_backend_adapter.contractAdapterGetPlayerContracts
local contractAdapterLinkSessionToMatch = ____contract_backend_adapter.contractAdapterLinkSessionToMatch
local contractAdapterNominate = ____contract_backend_adapter.contractAdapterNominate
local contractAdapterSaveDroppedContract = ____contract_backend_adapter.contractAdapterSaveDroppedContract
local contractAdapterVote = ____contract_backend_adapter.contractAdapterVote
local requestIdDrop = ____contract_backend_adapter.requestIdDrop
local requestIdFinalize = ____contract_backend_adapter.requestIdFinalize
local requestIdLinkMatch = ____contract_backend_adapter.requestIdLinkMatch
local requestIdNominate = ____contract_backend_adapter.requestIdNominate
local requestIdVote = ____contract_backend_adapter.requestIdVote
local ____contract_drop_config = require("contracts.contract_drop_config")
local rollContractDropTier = ____contract_drop_config.rollContractDropTier
local ____contract_generator = require("contracts.contract_generator")
local generateContractDraft = ____contract_generator.generateContractDraft
local NET_TABLE = "contract_match"
local NET_KEY = "state"
local FINALIZE_TIMEOUT_SEC = 10
____exports.ContractMatchManager = __TS__Class()
local ContractMatchManager = ____exports.ContractMatchManager
ContractMatchManager.name = "ContractMatchManager"
ContractMatchManager.____file_path = "scripts/vscripts/contracts/contract_match_manager.lua"
function ContractMatchManager.prototype.____constructor(self)
    self.listenersRegistered = false
    self.inventoryBySteam = __TS__New(Map)
    self.candidates = {}
    self.votesByVoterSteam = {}
    self.nominateOrderSeq = 0
    self.publicState = {
        contract_session_id = "",
        phase = "voting",
        candidates = {},
        vote_counts = {},
        active_contract = nil,
        contract_multiplier = 1
    }
    self.confirmedActiveContract = nil
    self.confirmedMultiplier = 1
    self.finalizeResolved = false
    self.finalizeAttemptSerial = 0
    self.activeFinalizeAttempt = 0
    self.linkMatchDone = false
    self.dropRollIndex = 0
end
function ContractMatchManager.getInstance(self)
    if not ____exports.ContractMatchManager.instance then
        ____exports.ContractMatchManager.instance = __TS__New(____exports.ContractMatchManager)
    end
    return ____exports.ContractMatchManager.instance
end
function ContractMatchManager.prototype.init(self)
    if self.listenersRegistered or type(CustomGameEventManager) == "nil" then
        return
    end
    CustomGameEventManager:RegisterListener(
        "invasion_contracts_request",
        function(_src, data)
            local pid = data.PlayerID
            self:onContractsRequest(pid)
        end
    )
    CustomGameEventManager:RegisterListener(
        "invasion_contract_nominate",
        function(_src, data)
            local pid = data.PlayerID
            local ____tostring_1 = tostring
            local ____data_contract_instance_id_0 = data.contract_instance_id
            if ____data_contract_instance_id_0 == nil then
                ____data_contract_instance_id_0 = ""
            end
            local cid = ____tostring_1(____data_contract_instance_id_0)
            self:onNominate(pid, cid)
        end
    )
    CustomGameEventManager:RegisterListener(
        "invasion_contract_vote",
        function(_src, data)
            local pid = data.PlayerID
            local ____tostring_3 = tostring
            local ____data_contract_instance_id_2 = data.contract_instance_id
            if ____data_contract_instance_id_2 == nil then
                ____data_contract_instance_id_2 = ""
            end
            local cid = ____tostring_3(____data_contract_instance_id_2)
            self:onVote(pid, cid)
        end
    )
    self.listenersRegistered = true
    self:syncNetTable()
end
function ContractMatchManager.prototype.getConfirmedContractMultiplier(self)
    return self.confirmedMultiplier
end
function ContractMatchManager.prototype.getConfirmedActiveContract(self)
    return self.confirmedActiveContract
end
function ContractMatchManager.prototype.tryLinkSessionToBackendMatch(self, backendMatchId)
    local sid = self:getOrCreateSessionId()
    local mid = backendMatchId
    if not mid or self.linkMatchDone then
        return
    end
    local rid = requestIdLinkMatch(nil, sid, mid)
    contractAdapterLinkSessionToMatch(
        nil,
        sid,
        rid,
        mid,
        function(____, ok)
            if ok then
                self.linkMatchDone = true
                print((("[ContractMatchManager] link-match ok session=" .. sid) .. " match=") .. mid)
            end
        end
    )
end
function ContractMatchManager.prototype.beginFinalizeForDifficulty(self, leader, backendMatchId, onWorldApplyReady)
    if leader ~= "impossible" then
        self.confirmedActiveContract = nil
        self.confirmedMultiplier = 1
        self.publicState.phase = "locked_without_contract"
        self.publicState.active_contract = nil
        self.publicState.contract_multiplier = 1
        self.publicState.public_error_code = nil
        self:syncNetTable()
        onWorldApplyReady(nil)
        return
    end
    self.finalizeAttemptSerial = self.finalizeAttemptSerial + 1
    local attempt = self.finalizeAttemptSerial
    self.activeFinalizeAttempt = attempt
    self.finalizeResolved = false
    self.publicState.phase = "finalizing"
    self.publicState.public_error_code = nil
    self:syncNetTable()
    Timers:CreateTimer(
        FINALIZE_TIMEOUT_SEC,
        function()
            if self.finalizeResolved then
                return nil
            end
            if self.activeFinalizeAttempt ~= attempt then
                return nil
            end
            if self.publicState.phase ~= "finalizing" then
                return nil
            end
            print("[ContractMatchManager] finalize timeout attempt=" .. tostring(attempt))
            self:applyFinalizeFailure(attempt, "contracts_finalize_failed", onWorldApplyReady)
            return nil
        end
    )
    local sid = self:getOrCreateSessionId()
    local matchId = backendMatchId or nil
    local localWinner = self:computeLocalWinnerContractId()
    local candSnap = __TS__ArrayMap(
        self.candidates,
        function(____, c) return {contract_instance_id = c.contract_instance_id, owner_steam_id = c.owner_steam_id, nominated_at = c.nominated_at, nominated_order = c.nominated_order} end
    )
    local voteSnap = {}
    for ____, voter in ipairs(__TS__ObjectKeys(self.votesByVoterSteam)) do
        local cid = self.votesByVoterSteam[voter]
        if cid ~= nil and cid ~= "" then
            voteSnap[#voteSnap + 1] = {voter_steam_id = voter, contract_instance_id = cid}
        end
    end
    local rid = requestIdFinalize(nil, sid)
    contractAdapterFinalizeContractVoting(
        nil,
        sid,
        rid,
        matchId,
        localWinner,
        candSnap,
        voteSnap,
        function(____, resp, httpOk)
            if self.finalizeResolved then
                print("[ContractMatchManager] finalize HTTP late ignored attempt=" .. tostring(attempt))
                return
            end
            if self.activeFinalizeAttempt ~= attempt then
                print("[ContractMatchManager] finalize HTTP stale attempt=" .. tostring(attempt))
                return
            end
            if self.publicState.phase ~= "finalizing" then
                print("[ContractMatchManager] finalize HTTP wrong phase")
                return
            end
            if not httpOk or not resp or not resp.ok then
                print("[ContractMatchManager] finalize HTTP/body fail attempt=" .. tostring(attempt))
                self:applyFinalizeFailure(attempt, "contracts_finalize_failed", onWorldApplyReady)
                return
            end
            local mult = clampContractMultiplierFromBackend(nil, resp.contract_multiplier)
            if mult == nil then
                print("[ContractMatchManager] finalize invalid multiplier raw=" .. tostring(resp.contract_multiplier))
                self:applyFinalizeFailure(attempt, "contracts_finalize_failed", onWorldApplyReady)
                return
            end
            self.finalizeResolved = true
            self.confirmedMultiplier = mult
            self.confirmedActiveContract = resp.active_contract or nil
            self.publicState.active_contract = self.confirmedActiveContract
            self.publicState.contract_multiplier = mult
            self.publicState.phase = self.confirmedActiveContract and "locked" or "locked_without_contract"
            self.publicState.public_error_code = nil
            self:syncNetTable()
            onWorldApplyReady(nil)
        end
    )
end
function ContractMatchManager.prototype.processImpossibleVictoryDrops(self, allowPersistedDrop)
    if not allowPersistedDrop then
        print("[ContractMatchManager] drop skipped: match end rewards / stats blocked")
        return
    end
    do
        local i = 0
        while i < DOTA_MAX_PLAYERS do
            do
                local pid = i
                if not PlayerResource:IsValidPlayerID(pid) or not PlayerResource:IsValidPlayer(pid) or PlayerResource:IsFakeClient(pid) then
                    goto __continue34
                end
                local steam = tostring(PlayerResource:GetSteamAccountID(pid))
                local tier = rollContractDropTier(nil)
                if tier <= 0 then
                    goto __continue34
                end
                self.dropRollIndex = self.dropRollIndex + 1
                local draftId = (((("draft_" .. self:getOrCreateSessionId()) .. "_") .. steam) .. "_") .. tostring(self.dropRollIndex)
                local draft = generateContractDraft(nil, steam, tier, draftId)
                local rid = requestIdDrop(
                    nil,
                    self:getOrCreateSessionId(),
                    steam,
                    self.dropRollIndex
                )
                contractAdapterSaveDroppedContract(
                    nil,
                    steam,
                    rid,
                    draft,
                    function(____, canonical, ok)
                        if not ok or not canonical then
                            print("[ContractMatchManager] drop save failed steam=" .. steam)
                            return
                        end
                        if type(CustomGameEventManager) ~= "nil" then
                            local pl = PlayerResource:GetPlayer(pid)
                            if pl then
                                CustomGameEventManager:Send_ServerToPlayer(pl, "invasion_contract_drop_result", {ok = true, contract = canonical})
                            end
                        end
                    end
                )
            end
            ::__continue34::
            i = i + 1
        end
    end
end
function ContractMatchManager.prototype.getOrCreateSessionId(self)
    if not self.sessionId then
        local t = math.floor(GameRules:GetGameTime() * 1000)
        self.sessionId = (("cs_" .. tostring(t)) .. "_") .. tostring(RandomInt(100000, 999999))
        self.publicState.contract_session_id = self.sessionId
    end
    return self.sessionId
end
function ContractMatchManager.prototype.onContractsRequest(self, playerId)
    if not PlayerResource:IsValidPlayerID(playerId) or not PlayerResource:IsValidPlayer(playerId) then
        return
    end
    local steam = tostring(PlayerResource:GetSteamAccountID(playerId))
    contractAdapterGetPlayerContracts(
        nil,
        steam,
        function(____, list, err)
            if list == nil then
                self:sendInventory(playerId, nil, "contracts_load_failed", true)
                return
            end
            self.inventoryBySteam:set(steam, list)
            self:sendInventory(playerId, list, nil, true)
        end
    )
end
function ContractMatchManager.prototype.sendInventory(self, playerId, contracts, errorCode, done)
    if type(CustomGameEventManager) == "nil" then
        return
    end
    local payload = {contracts = contracts, loading_done = done}
    if errorCode then
        payload.error_code = errorCode
    end
    local pl = PlayerResource:GetPlayer(playerId)
    if pl then
        CustomGameEventManager:Send_ServerToPlayer(pl, "invasion_contracts_inventory", payload)
    end
end
function ContractMatchManager.prototype.onNominate(self, playerId, contractInstanceId)
    if self.publicState.phase ~= "voting" then
        print("[ContractMatchManager] nominate rejected phase=" .. self.publicState.phase)
        return
    end
    if not contractInstanceId or #contractInstanceId == 0 then
        return
    end
    if not PlayerResource:IsValidPlayerID(playerId) or not PlayerResource:IsValidPlayer(playerId) then
        return
    end
    local steam = tostring(PlayerResource:GetSteamAccountID(playerId))
    local inv = self.inventoryBySteam:get(steam)
    local ____opt_4 = inv
    local found = ____opt_4 and __TS__ArrayFind(
        inv,
        function(____, c) return c.contract_instance_id == contractInstanceId end
    )
    if not found or found.is_broken or found.owner_steam_id ~= steam then
        self:syncNetTableErrorFlash("contracts_invalid_contract")
        return
    end
    local sid = self:getOrCreateSessionId()
    local rid = requestIdNominate(nil, sid, steam, contractInstanceId)
    contractAdapterNominate(
        nil,
        sid,
        rid,
        steam,
        contractInstanceId,
        function(____, ok)
            if not ok then
                print((("[ContractMatchManager] nominate HTTP fail steam=" .. steam) .. " id=") .. contractInstanceId)
                self:syncNetTableErrorFlash("contracts_invalid_contract")
                return
            end
            self:removeCandidateByOwner(steam)
            self.nominateOrderSeq = self.nominateOrderSeq + 1
            local pub = {
                contract_instance_id = contractInstanceId,
                owner_steam_id = steam,
                nominated_at = GameRules:GetGameTime(),
                nominated_order = self.nominateOrderSeq,
                name = found.name,
                tier = found.tier
            }
            local ____self_candidates_6 = self.candidates
            ____self_candidates_6[#____self_candidates_6 + 1] = pub
            self.votesByVoterSteam[steam] = contractInstanceId
            self:rebuildVoteCounts()
            self:syncNetTable()
        end
    )
end
function ContractMatchManager.prototype.onVote(self, playerId, contractInstanceId)
    if self.publicState.phase ~= "voting" then
        print("[ContractMatchManager] vote rejected phase=" .. self.publicState.phase)
        return
    end
    if not contractInstanceId then
        return
    end
    if not PlayerResource:IsValidPlayerID(playerId) or not PlayerResource:IsValidPlayer(playerId) then
        return
    end
    local voter = tostring(PlayerResource:GetSteamAccountID(playerId))
    local exists = __TS__ArraySome(
        self.candidates,
        function(____, c) return c.contract_instance_id == contractInstanceId end
    )
    if not exists then
        self:syncNetTableErrorFlash("contracts_vote_rejected")
        return
    end
    local sid = self:getOrCreateSessionId()
    local rid = requestIdVote(nil, sid, voter, contractInstanceId)
    contractAdapterVote(
        nil,
        sid,
        rid,
        voter,
        contractInstanceId,
        function(____, ok)
            if not ok then
                print("[ContractMatchManager] vote HTTP fail voter=" .. voter)
                self:syncNetTableErrorFlash("contracts_vote_rejected")
                return
            end
            self.votesByVoterSteam[voter] = contractInstanceId
            self:rebuildVoteCounts()
            self:syncNetTable()
        end
    )
end
function ContractMatchManager.prototype.removeCandidateByOwner(self, steam)
    self.candidates = __TS__ArrayFilter(
        self.candidates,
        function(____, c) return c.owner_steam_id ~= steam end
    )
end
function ContractMatchManager.prototype.rebuildVoteCounts(self)
    local counts = {}
    for ____, voter in ipairs(__TS__ObjectKeys(self.votesByVoterSteam)) do
        local cid = self.votesByVoterSteam[voter]
        if cid ~= nil and cid ~= "" then
            counts[cid] = (counts[cid] or 0) + 1
        end
    end
    self.publicState.vote_counts = counts
    self.publicState.candidates = self.candidates
end
function ContractMatchManager.prototype.computeLocalWinnerContractId(self)
    if #self.candidates == 0 then
        return nil
    end
    local counts = {}
    for ____, voter in ipairs(__TS__ObjectKeys(self.votesByVoterSteam)) do
        local cid = self.votesByVoterSteam[voter]
        if cid ~= nil and cid ~= "" then
            counts[cid] = (counts[cid] or 0) + 1
        end
    end
    local totalVotes = 0
    for ____, k in ipairs(__TS__ObjectKeys(counts)) do
        totalVotes = totalVotes + (counts[k] or 0)
    end
    if totalVotes == 0 then
        return nil
    end
    local bestIds = {}
    local bestVotes = -1
    for ____, cid in ipairs(__TS__ObjectKeys(counts)) do
        local n = counts[cid] or 0
        if n > bestVotes then
            bestVotes = n
            bestIds = {cid}
        elseif n == bestVotes then
            bestIds[#bestIds + 1] = cid
        end
    end
    if #bestIds == 1 then
        return bestIds[1]
    end
    return self:pickTieBreakContractId(bestIds)
end
function ContractMatchManager.prototype.pickTieBreakContractId(self, ids)
    local byId = {}
    for ____, c in ipairs(self.candidates) do
        byId[c.contract_instance_id] = c
    end
    local best = ids[1]
    do
        local i = 1
        while i < #ids do
            local cur = ids[i + 1]
            if self:compareCandidatesForTie(byId[cur], byId[best], cur, best) < 0 then
                best = cur
            end
            i = i + 1
        end
    end
    return best
end
function ContractMatchManager.prototype.compareCandidatesForTie(self, ca, cb, idA, idB)
    if not ca or not cb then
        return 0
    end
    if ca.nominated_order ~= cb.nominated_order then
        return ca.nominated_order < cb.nominated_order and -1 or 1
    end
    local steamCmp = compareSteamIdDecimalString(nil, ca.owner_steam_id, cb.owner_steam_id)
    if steamCmp ~= 0 then
        return steamCmp
    end
    if idA < idB then
        return -1
    end
    if idA > idB then
        return 1
    end
    return 0
end
function ContractMatchManager.prototype.applyFinalizeFailure(self, attempt, code, onWorldApplyReady)
    if self.finalizeResolved then
        return
    end
    if self.activeFinalizeAttempt ~= attempt then
        return
    end
    if self.activeFinalizeAttempt ~= attempt then
        return
    end
    self.finalizeResolved = true
    self.confirmedActiveContract = nil
    self.confirmedMultiplier = 1
    self.publicState.active_contract = nil
    self.publicState.contract_multiplier = 1
    self.publicState.phase = "finalize_error"
    self.publicState.public_error_code = code
    self:syncNetTable()
    onWorldApplyReady(nil)
end
function ContractMatchManager.prototype.syncNetTableErrorFlash(self, code)
    self.publicState.public_error_code = code
    self:syncNetTable()
    Timers:CreateTimer(
        0.1,
        function()
            self.publicState.public_error_code = nil
            self:syncNetTable()
            return nil
        end
    )
end
function ContractMatchManager.prototype.syncNetTable(self)
    if type(CustomNetTables) == "nil" then
        return
    end
    self.publicState.candidates = self.candidates
    self:rebuildVoteCounts()
    if not self.publicState.contract_session_id and self.sessionId then
        self.publicState.contract_session_id = self.sessionId
    end
    CustomNetTables:SetTableValue(NET_TABLE, NET_KEY, self.publicState)
end
return ____exports