威纶通九宫格解锁触摸屏

// defs
const SectionInterval = 100;
const SectionCount = 3; // for both horizontal and vertical directions
const NumberCount = SectionCount * SectionCount;
const NumberSensibleWidth = 50;
const encoder = new TextEncoder();
const MatchResult = {
    Undetermined: 0,
    Success: 1,
    Failure: 2,
};

// assign JS object to 'self'
var self = this;

// sets up UI
var patternCanvas = new Canvas();
var floatLineCanvas = new Canvas();
var mouseArea = new MouseArea();
self.widget.add(patternCanvas);
self.widget.add(floatLineCanvas);
self.widget.add(mouseArea);

initNumberSensibleRect();
reset();

mouseArea.on('mousedown', (mouseEvent) => {
    setMatchResult(MatchResult.Undetermined);

    let num = hitTest(mouseEvent);
    if (num >= 0) {
        addNumberToPattern(num);
    }
});

mouseArea.on('mousemove', (mouseEvent) => {
    clearFloatLine();

    // new number?
    let num = hitTest(mouseEvent);
    if (num >= 0 && !isNumberInPattern(num)) {
        addNumberToPattern(num);
    } else if (self.pattern.length > 0 && self.pattern.length < NumberCount) {
        addFloatLine(mouseEvent);
    }
});

mouseArea.on('mouseup', (mouseEvent) => {
    outputPattern();
    outputMatchResult();
    reset();
});

//===================================================================
function initNumberSensibleRect() {
    self.numberSensibleRect = new Array(NumberCount);

    for (let x = 0; x < SectionCount; x++) {
        for (let y = 0; y < SectionCount; y++) {
            let dot = x + y * SectionCount;
            self.numberSensibleRect[dot] = {
                x: x * SectionInterval + SectionInterval / 2 - NumberSensibleWidth / 2,
                y: y * SectionInterval + SectionInterval / 2 - NumberSensibleWidth / 2,
                width: NumberSensibleWidth,
                height: NumberSensibleWidth
            };
        }
    }
}

function reset() {
    console.log('[reset]');
    self.pattern = [];
    updateNumberValues();
    clearCanvas(patternCanvas);
    clearCanvas(floatLineCanvas);
}

function hitTest(mouseEvent) {

    for (let i = 0; i < self.numberSensibleRect.length; ++i) {
        let sensibleRect = self.numberSensibleRect[i];
        if (mouseEvent.x >= sensibleRect.x && mouseEvent.x < (sensibleRect.x + sensibleRect.width) &&
            mouseEvent.y >= sensibleRect.y && mouseEvent.y < (sensibleRect.y + sensibleRect.height)) {
            return i;
        }
    }

    return -1;
}

function addNumberToPattern(num) {
    self.pattern.push(num);
    console.log('[addNumberToPattern] pattern =', self.pattern);

    updateNumberValues();
    updatePatternCanvas();
}

function isNumberInPattern(num) {
    return (self.pattern.indexOf(num) >= 0);
}

function clearCanvas(canvas) {
    canvas.clearRect(0, 0, canvas.width, canvas.height);
}

function updatePatternCanvas() {
    if (self.pattern.length >= 2) {
        let canvas = patternCanvas;
        let startingPoint = pointFromNumber(self.pattern[0]);

        clearCanvas(canvas);
        canvas.strokeStyle = self.config.lineColor;
        canvas.lineWidth = 3;
        canvas.beginPath();
        canvas.moveTo(startingPoint.x, startingPoint.y);

        for (let i = 1; i < self.pattern.length; i++) {
            let point = pointFromNumber(self.pattern[i]);
            canvas.lineTo(point.x, point.y);
        }

        canvas.stroke();
    }
}

function addFloatLine(mouseEvent) {
    if (self.pattern.length > 0) {
        let canvas = floatLineCanvas;
        let lastPoint = pointFromNumber(self.pattern[self.pattern.length - 1]);

        canvas.strokeStyle = self.config.lineColor;
        canvas.lineWidth = 3;
        canvas.beginPath();
        canvas.moveTo(lastPoint.x, lastPoint.y);
        canvas.lineTo(mouseEvent.x, mouseEvent.y);
        canvas.stroke();
    }
}

function clearFloatLine() {
    clearCanvas(floatLineCanvas);
}

function outputPattern() {
    // prepare pattern string
    let strPattern = '';
    self.pattern.forEach((num) => {
        strPattern += (num + 1);
    });
    console.log('[outputPattern] pattern =', strPattern);

    // output pattern to address
    let encodedPattern = encoder.encode(strPattern);
    let bufferSize = driver.Address.getDataTypeSize(self.config.savedPatternSub.address.dataType) * self.config.savedPatternSub.length;
    let buffer = new ArrayBuffer(bufferSize);
    let data = new Uint8Array(buffer);
    data.set(encodedPattern);

    driver.setData(self.config.patternAddress, buffer);
    self.patternDataBuffer = buffer;
}

function setMatchResult(value) {
    driver.setData(self.config.matchResultAddress, value);
}

function outputMatchResult() {
    setMatchResult(isBufferEqualTo(self.patternDataBuffer, self.config.savedPatternSub.latestData.buffer)
        ? MatchResult.Success
        : MatchResult.Failure);
}

function updateNumberValues() {
    let values = new Array(NumberCount);
    values.fill(0);

    self.pattern.forEach((num) => {
        values[num] = 1;
    });

    driver.setData(self.config.numberValueAddress, values);
}

function pointFromNumber(num) {
    let x = num % SectionCount;
    let y = Math.floor(num / SectionCount);

    return {
        x: x * SectionInterval + SectionInterval / 2,
        y: y * SectionInterval + SectionInterval / 2
    };
}

function isBufferEqualTo(lhs, rhs) {
    if (lhs.byteLength == rhs.byteLength) {
        let lhs_array = new Uint8Array(lhs);
        let rhs_array = new Uint8Array(rhs);

        for (let i = 0; i < lhs_array.length ; i++) {
            if (lhs_array[i] != rhs_array[i]) {
                return false;
            }
        }

        return true;
    } else {
        return false;
    }
}