DieInstance.ttslua

require('ge_tts.License')

local Class = require('ge_tts.Class')
local EventManager = require('ge_tts.EventManager')
local Instance = require('ge_tts.Instance')
local Object = require('ge_tts.Object')
local Vector3 = require('ge_tts.Vector3')

---@class ge_tts__DieInstance : ge_tts__Instance

---@class ge_tts__static_DieInstance : ge_tts__static_Instance
---@overload fun(savedState: ge_tts__Instance_SavedState): ge_tts__DieInstance
---@overload fun(object: tts__Object): ge_tts__DieInstance
---@overload fun(guid: string, container: tts__Container): ge_tts__DieInstance
---@overload fun(objectOrSavedState: tts__Object | ge_tts__Instance_SavedState): ge_tts__DieInstance
---@overload fun(objectOrGuidOrSavedState: tts__Object | string | ge_tts__Instance_SavedState, nilOrContainer: nil | tts__Container): ge_tts__DieInstance
local DieInstance = {}

DieInstance.TYPE = 'Die'

setmetatable(DieInstance, {
    ---@param class self
    ---@param objectOrGuidOrSavedState tts__Object | string | ge_tts__Instance_SavedState
    ---@param nilOrContainer nil | tts__Container
    __call = function(class, objectOrGuidOrSavedState, nilOrContainer)
        local self = --[[---@type ge_tts__DieInstance]] Class.parentConstructor(self, Instance)(
            objectOrGuidOrSavedState,
            nilOrContainer
        )

        self.getObject().registerCollisions()

        ---@param value number | string
        ---@param playerColor nil | tts__PlayerColor
        function self.onRolled(value, playerColor)
        end

        ---@param value number | string
        ---@param playerColor nil | tts__PlayerColor
        function self.onRotationValueUpdated(value, playerColor)
        end

        return self
    end,
    __index = Instance,
})

local MIN_ROLL_ANGULAR_VELOCITY_SQUARED = 2 * math.pi * math.pi

---@type table<tts__Object, true>
local monitoredDice = {}

---@param object tts__Object
---@param playerColor nil | tts__PlayerColor
---@param isRandomizing boolean
local onObjectUpdating = function(object, playerColor, isRandomizing)
    if monitoredDice[object] or object.type ~= Object.Type.Die then
        return
    end

    local instance = Instance.getOneInstance(object)

    if instance and (--[[---@type ge_tts__DieInstance]] instance).onRolled ~= nil then
        local dieInstance = (--[[---@type ge_tts__DieInstance]] instance)
        local initialRotationValue = object.getRotationValue()
        local isRolling = isRandomizing

        monitoredDice[object] = true

        local onRollDetected = function()
            Wait.condition(function()
                monitoredDice[object] = nil

                if object ~= nil then
                    local value = object.getRotationValue()
                    dieInstance.onRolled(value, playerColor)
                    dieInstance.onRotationValueUpdated(value, playerColor)
                end
            end, function()
                return object == nil or object.resting
            end)
        end

        if isRolling then
            Wait.frames(function()
                onRollDetected()
            end)
        else
            local minRandomizeYVelocity = 1.5 * (math.abs(Physics.getGravity().y) ^ 0.5)

            Wait.condition(function()
                if isRolling then
                    onRollDetected()
                else
                    if object ~= nil then
                        local value = object.getRotationValue()

                        if value ~= initialRotationValue then
                            dieInstance.onRotationValueUpdated(value, playerColor)
                        end
                    end
                    monitoredDice[object] = nil
                end
            end, function()
                if object == nil or object.resting then
                    return true
                end

                isRolling = not object.isSmoothMoving() and object.held_by_color == nil and (
                    (object.getRotationValue() ~= initialRotationValue and Vector3.lengthSquared(object.getAngularVelocity()) > MIN_ROLL_ANGULAR_VELOCITY_SQUARED)
                        or object.getVelocity().y > minRandomizeYVelocity
                )

                return isRolling
            end, 20)
        end
    end
end

---@param playerColor nil | tts__PlayerColor
---@param object tts__Object
local function onObjectDrop(playerColor, object)
    onObjectUpdating(object, playerColor, false)
end

---@param registeredObject tts__Object
local function onObjectCollisionExit(registeredObject)
    onObjectUpdating(registeredObject, nil, false)
end

---@param object tts__Object
---@param playerColor tts__PlayerColor
local function onObjectRandomize(object, playerColor)
    onObjectUpdating(object, playerColor, true)
end

EventManager.addHandler('onObjectRandomize', onObjectRandomize)
EventManager.addHandler('onObjectDrop', onObjectDrop)
EventManager.addHandler('onObjectCollisionExit', onObjectCollisionExit)

return DieInstance