Отслеживание мышки

import * as Frame from '../../FrameExt'
import { Color, Vec2 } from '../../Utils'

const COLOR = new Color(0, 0, 0, 0.1)

export class MouseDetectGrid extends Frame.SimpleEmpty {
    constructor(cols: number, rows: number){
        super()
        
        this.__grid_btn = []
        this.__grid_tool = []
        for (let x = 0; x < cols; x++){
            this.__grid_btn.push([])
            this.__grid_tool.push([])
            for (let y = 0; y < rows; y++){
                let btn = new Frame.GlueTextButton()
                this.__grid_btn[x].push(btn)
                btn.parent = this
                btn.color = COLOR

                let tool = new Frame.Backdrop()
                this.__grid_tool[x].push(tool)
                tool.visible = false
                tool.color = new Color(0, 0, 0, 0)
                BlzFrameSetTooltip(btn.handle, tool.handle)
            }
        }
    }

    getMousePos(){
        for (let x = 0; x < this.__grid_btn.length; x++){
            for (let y = 0; y < this.__grid_btn[x].length; y++){
                let tool = this.__grid_tool[x][y]
                if (tool.visible){
                    let btn = this.__grid_btn[x][y]
                    return $multi(true, this.pos.add(btn.pos), btn.size)
                }
            }
        }
        return $multi(false, this.pos, this.size)
    }

    protected _set_size(size: Vec2){
        super._set_size(size)

        let btn_size = new Vec2(size.x / this.__grid_btn.length,
                                size.y / this.__grid_btn[0].length)
        for (let x = 0; x < this.__grid_btn.length; x++){
            for (let y = 0; y < this.__grid_btn[x].length; y++){
                this.__grid_btn[x][y].size = btn_size
                this.__grid_btn[x][y].pos = new Vec2(x * btn_size.x, y * btn_size.y)
            }
        }

    }

    private __grid_btn: Frame.GlueTextButton[][]
    private __grid_tool: Frame.Backdrop[][]
}

import * as Frame from '../../FrameExt'
import { hTimer } from '../../Handle'
import { Vec2 } from '../../Utils'

import { MouseDetectGrid } from './Grid'

const STEP_TIME = 0.025
const GRID_SIZE = 8
const ROI_SIZE = 3

export class MouseDetector {
    constructor(){
        this.precision = 0.01
        this.__pos = Frame.Screen.pos
        this.__size = Frame.Screen.size

        this.__grid = new MouseDetectGrid(GRID_SIZE, GRID_SIZE)

        let t = new hTimer()
        t.addAction(() => {
            this.__pos = Frame.Screen.pos
            this.__size = Frame.Screen.size
            this.__grid.pos = this.__pos
            this.__grid.size = this.__size
            this.__getBetterPos()
        })

        let period = STEP_TIME
        let tmp = this.precision
        while (tmp < Frame.Screen.size.x){
            tmp *= GRID_SIZE / ROI_SIZE
            period += STEP_TIME
        }

        t.start(period, true)
    }

    getMouse(){
        return this.__pos
    }

    private __getBetterPos(){
        let t = new hTimer()
        t.addAction(() => {
            t.destroy()
            let found: boolean
            [found, this.__pos, this.__size] = this.__grid.getMousePos()

            if (!found){
                return
            }

            this.__grid.pos = this.__pos.sub(this.__size.mult((ROI_SIZE - 1) / 2))
            this.__grid.size = this.__size.mult(ROI_SIZE)

            print(this.__pos.toString(), this.__size.toString())

            if (this.__size.x > this.precision || this.__size.y > this.precision){
                this.__getBetterPos()
            }
        })
        t.start(STEP_TIME, false)
    }

    precision: number

    private __pos: Vec2
    private __size: Vec2

    private __grid: MouseDetectGrid
}