Greasy Fork is available in English.

Drawaria Letters in the Canvas Safe Version

Write text on the Drawaria canvas with sliders for position, improved UI, dark mode, and font size control

// ==UserScript==
// @name         Drawaria Letters in the Canvas Safe Version
// @namespace
// @version      2025-01-21
// @description  Write text on the Drawaria canvas with sliders for position, improved UI, dark mode, and font size control
// @author       You
// @match        *://drawaria.online/*
// @icon         https://www.google.com/s2/favicons?sz=64&domain=drawaria.online
// @license      MIT
// @grant        none
// @namespace https://greasyfork.org/users/1088100
// ==/UserScript==

(function() {
    'use strict';

    // List of predefined words
    const words = [
        "HELLO", "WORLD", "DRAW", "ARIA", "TEXT",
        "SCRIPT", "CANVAS", "COLOR", "SLIDER", "TOOL"
    ];

    // Adding Text Input and Controls with Sliders (Dark Mode)
    function addTextInput() {
        let container = document.createElement('div');
        container.id = 'drawaria-text-tool';
        container.style.cssText = `
            position: fixed;
            top: 10px;
            left: 10px;
            z-index: 1000;
            background: #222;
            padding: 15px;
            border: 1px solid #333;
            border-radius: 8px;
            display: flex;
            flex-direction: column;
            gap: 10px;
            box-shadow: 0 2px 10px rgba(0,0,0,0.3);
            font-family: Arial, sans-serif;
            color: #fff;
            width: 250px;
        `;

        // Title and Toggle Button
        let titleBar = document.createElement('div');
        titleBar.style.cssText = `
            display: flex;
            justify-content: space-between;
            align-items: center;
            cursor: pointer;
            padding: 5px;
            background: #333;
            border-radius: 8px 8px 0 0;
        `;

        let title = document.createElement('span');
        title.textContent = 'Letters In The Canvas';
        title.style.fontSize = '12px';

        let toggleButton = document.createElement('span');
        toggleButton.textContent = '▼';
        toggleButton.style.fontSize = '12px';
        toggleButton.style.marginLeft = '10px';

        titleBar.appendChild(title);
        titleBar.appendChild(toggleButton);
        container.appendChild(titleBar);

        // Content
        let content = document.createElement('div');
        content.id = 'drawaria-text-tool-content';
        content.style.display = 'none';

        // Word List with Scroll
        let wordListContainer = document.createElement('div');
        wordListContainer.style.cssText = `
            max-height: 150px;
            overflow-y: auto;
            border: 1px solid #444;
            border-radius: 4px;
            padding: 5px;
            background: #333;
        `;

        words.forEach(word => {
            let wordItem = document.createElement('div');
            wordItem.style.cssText = `
                display: flex;
                align-items: center;
                margin-bottom: 5px;
            `;

            let checkbox = document.createElement('input');
            checkbox.type = 'radio';
            checkbox.name = 'word-select';
            checkbox.value = word;
            checkbox.style.marginRight = '10px';

            let wordLabel = document.createElement('label');
            wordLabel.textContent = word;
            wordLabel.style.color = '#fff';

            checkbox.addEventListener('change', () => {
                if (checkbox.checked) {
                    // Deselect other checkboxes
                    document.querySelectorAll('input[name="word-select"]').forEach(otherCheckbox => {
                        if (otherCheckbox !== checkbox) {
                            otherCheckbox.checked = false;
                        }
                    });
                }
            });

            wordItem.appendChild(checkbox);
            wordItem.appendChild(wordLabel);
            wordListContainer.appendChild(wordItem);
        });

        // Color Input
        let colorLabel = createLabel('Color:', '#fff');
        let colorInput = createInput('color', '', '#000000', '#fff');
        colorInput.id = 'drawaria-color-input';
        colorInput.style.width = '40px';
        colorInput.style.height = '30px';

        // X Position Slider
        let xLabel = createLabel('X Position:', '#fff');
        let xSlider = createSlider(0.01, 0.95, 0.01, 0.10);
        xSlider.id = 'drawaria-x-slider';
        let xValueDisplay = createValueDisplay(xSlider);

        // Y Position Slider
        let yLabel = createLabel('Y Position:', '#fff');
        let ySlider = createSlider(0.01, 0.95, 0.01, 0.10);
        ySlider.id = 'drawaria-y-slider';
        let yValueDisplay = createValueDisplay(ySlider);

        // Thickness Slider (Font Size)
        let thicknessLabel = createLabel('Font Size:', '#fff');
        let thicknessSlider = createSlider(1, 10, 1, 1);
        thicknessSlider.id = 'drawaria-thickness-slider';
        let thicknessValueDisplay = createValueDisplay(thicknessSlider);

        // Direction Dropdown
        let directionLabel = createLabel('Direction:', '#fff');
        let directionInput = createSelect(['Left to Right', 'Right to Left', 'Top to Bottom', 'Bottom to Top']);
        directionInput.id = 'drawaria-direction-input';

        // Send Button
        let sendButton = createButton('Send Text', '#4CAF50', '#45a049');
        sendButton.addEventListener('click', sendText);

        // Erase Button
        let eraseButton = createButton('Erase Text', '#f44336', '#e53935');
        eraseButton.addEventListener('click', eraseText);

        content.appendChild(wordListContainer);
        content.appendChild(colorLabel);
        content.appendChild(colorInput);
        content.appendChild(xLabel);
        content.appendChild(xSlider);
        content.appendChild(xValueDisplay);
        content.appendChild(yLabel);
        content.appendChild(ySlider);
        content.appendChild(yValueDisplay);
        content.appendChild(thicknessLabel);
        content.appendChild(thicknessSlider);
        content.appendChild(thicknessValueDisplay);
        content.appendChild(directionLabel);
        content.appendChild(directionInput);
        content.appendChild(sendButton);
        content.appendChild(eraseButton);
        container.appendChild(content);
        document.body.appendChild(container);

        // Make the menu draggable
        let isDragging = false;
        let offsetX, offsetY;

        titleBar.addEventListener('mousedown', (e) => {
            isDragging = true;
            offsetX = e.clientX - container.getBoundingClientRect().left;
            offsetY = e.clientY - container.getBoundingClientRect().top;
        });

        document.addEventListener('mousemove', (e) => {
            if (isDragging) {
                container.style.left = `${e.clientX - offsetX}px`;
                container.style.top = `${e.clientY - offsetY}px`;
            }
        });

        document.addEventListener('mouseup', () => {
            isDragging = false;
        });

        // Toggle menu visibility
        titleBar.addEventListener('click', () => {
            if (content.style.display === 'none') {
                content.style.display = 'block';
                toggleButton.textContent = '▲';
            } else {
                content.style.display = 'none';
                toggleButton.textContent = '▼';
            }
        });
    }

    // Helper functions for UI creation
    function createLabel(text, color) {
        let label = document.createElement('label');
        label.textContent = text;
        label.style.color = color;
        return label;
    }

    function createInput(type, placeholder, bgColor, textColor) {
        let input = document.createElement('input');
        input.type = type;
        input.placeholder = placeholder;
        input.style.cssText = `
            padding: 8px;
            border-radius: 4px;
            border: 1px solid #444;
            background: ${bgColor};
            color: ${textColor};
        `;
        return input;
    }

    function createSlider(min, max, step, value) {
        let slider = document.createElement('input');
        slider.type = 'range';
        slider.min = min;
        slider.max = max;
        slider.step = step;
        slider.value = value;
        slider.style.width = '100%';
        return slider;
    }

    function createValueDisplay(slider) {
        let display = document.createElement('span');
        display.textContent = parseFloat(slider.value).toFixed(2);
        slider.addEventListener('input', () => {
            display.textContent = parseFloat(slider.value).toFixed(2);
        });
        return display;
    }

    function createSelect(options) {
        let select = document.createElement('select');
        select.style.cssText = `
            padding: 8px;
            border-radius: 4px;
            border: 1px solid #444;
            background: #333;
            color: #fff;
        `;
        options.forEach(option => {
            let opt = document.createElement('option');
            opt.value = option;
            opt.textContent = option;
            select.appendChild(opt);
        });
        return select;
    }

    function createButton(text, bgColor, hoverColor) {
        let button = document.createElement('button');
        button.textContent = text;
        button.style.cssText = `
            padding: 10px 15px;
            border-radius: 4px;
            background: ${bgColor};
            color: white;
            border: none;
            cursor: pointer;
            transition: background-color 0.3s;
        `;
        button.addEventListener('mouseover', () => {
            button.style.backgroundColor = hoverColor;
        });
        button.addEventListener('mouseout', () => {
            button.style.backgroundColor = bgColor;
        });
        return button;
    }

    // Sending Text Function
    function sendText() {
        let selectedWord = document.querySelector('input[name="word-select"]:checked');
        if (!selectedWord) return;

        let text = selectedWord.value;
        let color = document.getElementById('drawaria-color-input').value;
        let x = parseFloat(document.getElementById('drawaria-x-slider').value);
        let y = parseFloat(document.getElementById('drawaria-y-slider').value);
        let thickness = parseInt(document.getElementById('drawaria-thickness-slider').value);
        let direction = document.getElementById('drawaria-direction-input').value;

        if (text) {
            drawTextOnCanvas(text, x, y, color, direction, thickness);
        }
    }

    // Erasing Text Function
    function eraseText() {
        let selectedWord = document.querySelector('input[name="word-select"]:checked');
        if (!selectedWord) return;

        let text = selectedWord.value;
        let x = parseFloat(document.getElementById('drawaria-x-slider').value);
        let y = parseFloat(document.getElementById('drawaria-y-slider').value);
        let thickness = parseInt(document.getElementById('drawaria-thickness-slider').value);
        let direction = document.getElementById('drawaria-direction-input').value;

        if (text) {
            drawTextOnCanvas(text, x, y, '#FFFFFF', direction, thickness);
        }
    }

    // Drawing Text on Canvas
    function drawTextOnCanvas(text, x, y, color, direction, thickness) {
        const spacing = 0.05 * thickness; // Adjust spacing based on thickness
        for (let char of text) {
            drawCharacter(char, x, y, color, thickness);
            switch (direction) {
                case 'Left to Right':
                    x += spacing;
                    break;
                case 'Right to Left':
                    x -= spacing;
                    break;
                case 'Top to Bottom':
                    y += spacing;
                    break;
                case 'Bottom to Top':
                    y -= spacing;
                    break;
            }
        }
    }

    // Drawing Each Character
    function drawCharacter(char, x, y, color, thickness) {
        let commands = getCharacterCommands(char, x, y, thickness);
        commands.forEach(cmd => {
            sendDrawCommand(cmd[0], cmd[1], cmd[2], cmd[3], color);
        });
    }

    // Get Character Commands
    function getCharacterCommands(char, x, y, thickness) {
        const sizeFactor = thickness * 0.01; // Scale commands based on thickness
        switch (char) {
            case 'A':
                return [
                    [x, y + sizeFactor * 4, x + sizeFactor * 2, y], // Diagonal izquierda
                    [x + sizeFactor * 2, y, x + sizeFactor * 4, y + sizeFactor * 4], // Diagonal derecha
                    [x + sizeFactor * 1, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 2] // Barra horizontal
                ];
            case 'B':
                return [
                    [x, y, x, y + sizeFactor * 4], // Línea vertical
                    [x, y, x + sizeFactor * 3, y], // Parte superior
                    [x, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 2], // Parte media
                    [x, y + sizeFactor * 4, x + sizeFactor * 3, y + sizeFactor * 4], // Parte inferior
                    [x + sizeFactor * 3, y, x + sizeFactor * 3, y + sizeFactor * 2], // Línea vertical derecha superior
                    [x + sizeFactor * 3, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 4] // Línea vertical derecha inferior
                ];
            case 'C':
                return [
                    [x + sizeFactor * 3, y, x, y], // Parte superior
                    [x, y, x, y + sizeFactor * 4], // Línea vertical izquierda
                    [x, y + sizeFactor * 4, x + sizeFactor * 3, y + sizeFactor * 4] // Parte inferior
                ];
            case 'D':
                return [
                    [x, y, x, y + sizeFactor * 4], // Línea vertical
                    [x, y, x + sizeFactor * 3, y], // Parte superior
                    [x, y + sizeFactor * 4, x + sizeFactor * 3, y + sizeFactor * 4], // Parte inferior
                    [x + sizeFactor * 3, y, x + sizeFactor * 3, y + sizeFactor * 4] // Línea vertical derecha
                ];
            case 'E':
                return [
                    [x, y, x + sizeFactor * 3, y], // Parte superior
                    [x, y, x, y + sizeFactor * 4], // Línea vertical
                    [x, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 2], // Parte media
                    [x, y + sizeFactor * 4, x + sizeFactor * 3, y + sizeFactor * 4] // Parte inferior
                ];
            case 'F':
                return [
                    [x, y, x + sizeFactor * 3, y], // Parte superior
                    [x, y, x, y + sizeFactor * 4], // Línea vertical
                    [x, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 2] // Parte media
                ];
            case 'G':
                return [
                    [x + sizeFactor * 3, y, x, y], // Parte superior
                    [x, y, x, y + sizeFactor * 4], // Línea vertical izquierda
                    [x, y + sizeFactor * 4, x + sizeFactor * 3, y + sizeFactor * 4], // Parte inferior
                    [x + sizeFactor * 3, y + sizeFactor * 4, x + sizeFactor * 3, y + sizeFactor * 2], // Línea vertical derecha
                    [x + sizeFactor * 3, y + sizeFactor * 2, x + sizeFactor * 2, y + sizeFactor * 2] // Barra horizontal
                ];
            case 'H':
                return [
                    [x, y, x, y + sizeFactor * 4], // Línea vertical izquierda
                    [x + sizeFactor * 3, y, x + sizeFactor * 3, y + sizeFactor * 4], // Línea vertical derecha
                    [x, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 2] // Barra horizontal
                ];
            case 'I':
                return [
                    [x + sizeFactor * 1.5, y, x + sizeFactor * 1.5, y + sizeFactor * 4], // Línea vertical
                    [x, y, x + sizeFactor * 3, y], // Parte superior
                    [x, y + sizeFactor * 4, x + sizeFactor * 3, y + sizeFactor * 4] // Parte inferior
                ];
            case 'J':
                return [
                    [x + sizeFactor * 3, y, x + sizeFactor * 3, y + sizeFactor * 4], // Línea vertical
                    [x, y + sizeFactor * 4, x + sizeFactor * 3, y + sizeFactor * 4], // Parte inferior
                    [x, y + sizeFactor * 4, x, y + sizeFactor * 3] // Línea horizontal izquierda
                ];
            case 'K':
                return [
                    [x, y, x, y + sizeFactor * 4], // Línea vertical
                    [x, y + sizeFactor * 2, x + sizeFactor * 3, y], // Diagonal superior
                    [x, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 4] // Diagonal inferior
                ];
            case 'L':
                return [
                    [x, y, x, y + sizeFactor * 4], // Línea vertical
                    [x, y + sizeFactor * 4, x + sizeFactor * 3, y + sizeFactor * 4] // Parte inferior
                ];
            case 'M':
                return [
                    [x, y, x, y + sizeFactor * 4], // Línea vertical izquierda
                    [x, y, x + sizeFactor * 1.5, y + sizeFactor * 2], // Diagonal superior
                    [x + sizeFactor * 1.5, y + sizeFactor * 2, x + sizeFactor * 3, y], // Diagonal superior derecha
                    [x + sizeFactor * 3, y, x + sizeFactor * 3, y + sizeFactor * 4] // Línea vertical derecha
                ];
            case 'N':
                return [
                    [x, y, x, y + sizeFactor * 4], // Línea vertical izquierda
                    [x, y, x + sizeFactor * 3, y + sizeFactor * 4], // Diagonal
                    [x + sizeFactor * 3, y + sizeFactor * 4, x + sizeFactor * 3, y] // Línea vertical derecha
                ];
            case 'O':
                return [
                    [x, y, x, y + sizeFactor * 4], // Línea vertical izquierda
                    [x, y, x + sizeFactor * 3, y], // Parte superior
                    [x + sizeFactor * 3, y, x + sizeFactor * 3, y + sizeFactor * 4], // Línea vertical derecha
                    [x, y + sizeFactor * 4, x + sizeFactor * 3, y + sizeFactor * 4] // Parte inferior
                ];
            case 'P':
                return [
                    [x, y, x, y + sizeFactor * 4], // Línea vertical
                    [x, y, x + sizeFactor * 3, y], // Parte superior
                    [x + sizeFactor * 3, y, x + sizeFactor * 3, y + sizeFactor * 2], // Línea vertical derecha superior
                    [x, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 2] // Parte media
                ];
            case 'Q':
                return [
                    [x, y, x, y + sizeFactor * 4], // Línea vertical izquierda
                    [x, y, x + sizeFactor * 3, y], // Parte superior
                    [x + sizeFactor * 3, y, x + sizeFactor * 3, y + sizeFactor * 4], // Línea vertical derecha
                    [x, y + sizeFactor * 4, x + sizeFactor * 3, y + sizeFactor * 4], // Parte inferior
                    [x + sizeFactor * 2, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 4] // Cola de la Q
                ];
            case 'R':
                return [
                    [x, y, x, y + sizeFactor * 4], // Línea vertical
                    [x, y, x + sizeFactor * 3, y], // Parte superior
                    [x + sizeFactor * 3, y, x + sizeFactor * 3, y + sizeFactor * 2], // Línea vertical derecha superior
                    [x, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 2], // Parte media
                    [x, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 4] // Diagonal inferior
                ];
            case 'S':
                return [
                    [x, y, x + sizeFactor * 3, y], // Parte superior
                    [x, y, x, y + sizeFactor * 2], // Línea vertical izquierda superior
                    [x, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 2], // Parte media
                    [x + sizeFactor * 3, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 4], // Línea vertical derecha inferior
                    [x, y + sizeFactor * 4, x + sizeFactor * 3, y + sizeFactor * 4] // Parte inferior
                ];
            case 'T':
                return [
                    [x, y, x + sizeFactor * 3, y], // Parte superior
                    [x + sizeFactor * 1.5, y, x + sizeFactor * 1.5, y + sizeFactor * 4] // Línea vertical
                ];
            case 'U':
                return [
                    [x, y, x, y + sizeFactor * 4], // Línea vertical izquierda
                    [x, y + sizeFactor * 4, x + sizeFactor * 3, y + sizeFactor * 4], // Parte inferior
                    [x + sizeFactor * 3, y + sizeFactor * 4, x + sizeFactor * 3, y] // Línea vertical derecha
                ];
            case 'V':
                return [
                    [x, y, x + sizeFactor * 1.5, y + sizeFactor * 4], // Diagonal izquierda
                    [x + sizeFactor * 1.5, y + sizeFactor * 4, x + sizeFactor * 3, y] // Diagonal derecha
                ];
            case 'W':
                return [
                    [x, y, x, y + sizeFactor * 4], // Línea vertical izquierda
                    [x, y + sizeFactor * 4, x + sizeFactor * 1.5, y + sizeFactor * 2], // Diagonal inferior izquierda
                    [x + sizeFactor * 1.5, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 4], // Diagonal inferior derecha
                    [x + sizeFactor * 3, y + sizeFactor * 4, x + sizeFactor * 3, y] // Línea vertical derecha
                ];
            case 'X':
                return [
                    [x, y, x + sizeFactor * 3, y + sizeFactor * 4], // Diagonal principal
                    [x, y + sizeFactor * 4, x + sizeFactor * 3, y] // Diagonal secundaria
                ];
            case 'Y':
                return [
                    [x, y, x + sizeFactor * 1.5, y + sizeFactor * 2], // Diagonal superior izquierda
                    [x + sizeFactor * 1.5, y + sizeFactor * 2, x + sizeFactor * 3, y], // Diagonal superior derecha
                    [x + sizeFactor * 1.5, y + sizeFactor * 2, x + sizeFactor * 1.5, y + sizeFactor * 4] // Línea vertical
                ];
            case 'Z':
                return [
                    [x, y, x + sizeFactor * 3, y], // Parte superior
                    [x + sizeFactor * 3, y, x, y + sizeFactor * 4], // Diagonal
                    [x, y + sizeFactor * 4, x + sizeFactor * 3, y + sizeFactor * 4] // Parte inferior
                ];
            case '0':
                return [
                    [x, y, x + sizeFactor * 3, y], // Parte superior
                    [x + sizeFactor * 3, y, x + sizeFactor * 3, y + sizeFactor * 4], // Línea vertical derecha
                    [x + sizeFactor * 3, y + sizeFactor * 4, x, y + sizeFactor * 4], // Parte inferior
                    [x, y + sizeFactor * 4, x, y] // Línea vertical izquierda
                ];
            case '1':
                return [
                    [x + sizeFactor * 1, y, x + sizeFactor * 2, y], // Línea diagonal superior (--|)
                    [x + sizeFactor * 2, y, x + sizeFactor * 2, y + sizeFactor * 4], // Línea vertical principal (|)
                    [x, y + sizeFactor * 4, x + sizeFactor * 3, y + sizeFactor * 4] // Base horizontal (-----)
                ];
            case '2':
                return [
                    [x, y, x + sizeFactor * 3, y], // Parte superior
                    [x + sizeFactor * 3, y, x + sizeFactor * 3, y + sizeFactor * 2], // Línea vertical derecha superior
                    [x + sizeFactor * 3, y + sizeFactor * 2, x, y + sizeFactor * 2], // Parte media
                    [x, y + sizeFactor * 2, x, y + sizeFactor * 4], // Línea vertical izquierda inferior
                    [x, y + sizeFactor * 4, x + sizeFactor * 3, y + sizeFactor * 4] // Parte inferior
                ];
            case '3':
                return [
                    [x, y, x + sizeFactor * 3, y], // Parte superior
                    [x + sizeFactor * 3, y, x + sizeFactor * 3, y + sizeFactor * 4], // Línea vertical derecha
                    [x + sizeFactor * 3, y + sizeFactor * 4, x, y + sizeFactor * 4], // Parte inferior
                    [x, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 2] // Parte media
                ];
            case '4':
                return [
                    [x, y, x, y + sizeFactor * 2], // Línea vertical izquierda
                    [x, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 2], // Parte media
                    [x + sizeFactor * 3, y, x + sizeFactor * 3, y + sizeFactor * 4] // Línea vertical derecha
                ];
            case '5':
                return [
                    [x, y, x + sizeFactor * 3, y], // Parte superior
                    [x, y, x, y + sizeFactor * 2], // Línea vertical izquierda superior
                    [x, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 2], // Parte media
                    [x + sizeFactor * 3, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 4], // Línea vertical derecha inferior
                    [x + sizeFactor * 3, y + sizeFactor * 4, x, y + sizeFactor * 4] // Parte inferior
                ];
            case '6':
                return [
                    [x, y, x + sizeFactor * 3, y], // Parte superior
                    [x, y, x, y + sizeFactor * 4], // Línea vertical izquierda
                    [x, y + sizeFactor * 4, x + sizeFactor * 3, y + sizeFactor * 4], // Parte inferior
                    [x + sizeFactor * 3, y + sizeFactor * 4, x + sizeFactor * 3, y + sizeFactor * 2], // Línea vertical derecha inferior
                    [x + sizeFactor * 3, y + sizeFactor * 2, x, y + sizeFactor * 2] // Parte media
                ];
            case '7':
                return [
                    [x, y, x + sizeFactor * 3, y], // Parte superior
                    [x + sizeFactor * 3, y, x + sizeFactor * 3, y + sizeFactor * 4] // Línea vertical derecha
                ];
            case '8':
                return [
                    [x, y, x + sizeFactor * 3, y], // Parte superior
                    [x + sizeFactor * 3, y, x + sizeFactor * 3, y + sizeFactor * 4], // Línea vertical derecha
                    [x + sizeFactor * 3, y + sizeFactor * 4, x, y + sizeFactor * 4], // Parte inferior
                    [x, y + sizeFactor * 4, x, y], // Línea vertical izquierda
                    [x, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 2] // Parte media
                ];
            case '9':
                return [
                    [x, y, x + sizeFactor * 3, y], // Parte superior (---)
                    [x, y, x, y + sizeFactor * 2], // Línea vertical izquierda superior (|)
                    [x + sizeFactor * 3, y, x + sizeFactor * 3, y + sizeFactor * 2], // Línea vertical derecha superior (|)
                    [x, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 2], // Línea horizontal media (---)
                    [x + sizeFactor * 3, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 4], // Línea vertical derecha inferior (|)
                    [x + sizeFactor * 1, y + sizeFactor * 4, x + sizeFactor * 3, y + sizeFactor * 4] // Parte inferior (--)
                ];
            case '!':
                return [
                    [x + sizeFactor * 1.5, y, x + sizeFactor * 1.5, y + sizeFactor * 3], // Línea vertical
                    [x + sizeFactor * 1.5, y + sizeFactor * 3.5, x + sizeFactor * 1.5, y + sizeFactor * 4] // Punto
                ];
            case '?':
                return [
                    [x + sizeFactor * 1.5, y, x + sizeFactor * 3, y], // Parte superior horizontal
                    [x + sizeFactor * 3, y, x + sizeFactor * 3, y + sizeFactor * 1], // Línea vertical derecha
                    [x + sizeFactor * 3, y + sizeFactor * 1, x + sizeFactor * 1.5, y + sizeFactor * 2], // Diagonal hacia la izquierda
                    [x + sizeFactor * 1.5, y + sizeFactor * 2, x + sizeFactor * 1.5, y + sizeFactor * 3], // Línea vertical central
                    [x + sizeFactor * 1.5, y + sizeFactor * 3.5, x + sizeFactor * 1.5, y + sizeFactor * 3.5] // Punto inferior
                ];
            case '@':
                return [
                    [x + sizeFactor * 2, y, x, y + sizeFactor * 1], // Parte superior
                    [x, y + sizeFactor * 1, x + sizeFactor * 2, y + sizeFactor * 4], // Diagonal
                    [x + sizeFactor * 2, y + sizeFactor * 4, x + sizeFactor * 3, y + sizeFactor * 3], // Curva
                    [x + sizeFactor * 3, y + sizeFactor * 3, x + sizeFactor * 2, y + sizeFactor * 2], // Curva
                    [x + sizeFactor * 2, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 1], // Curva
                    [x + sizeFactor * 3, y + sizeFactor * 1, x + sizeFactor * 2, y] // Curva
                ];
            case '#':
                return [
                    [x + sizeFactor * 1, y, x + sizeFactor * 2, y], // Parte superior
                    [x + sizeFactor * 2, y, x + sizeFactor * 3, y], // Parte superior
                    [x, y + sizeFactor * 1, x + sizeFactor * 3, y + sizeFactor * 1], // Línea horizontal
                    [x + sizeFactor * 1, y + sizeFactor * 2, x + sizeFactor * 2, y + sizeFactor * 2], // Línea horizontal
                    [x + sizeFactor * 2, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 2], // Línea horizontal
                    [x, y + sizeFactor * 3, x + sizeFactor * 3, y + sizeFactor * 3], // Línea horizontal
                    [x + sizeFactor * 1, y + sizeFactor * 4, x + sizeFactor * 2, y + sizeFactor * 4], // Parte inferior
                    [x + sizeFactor * 2, y + sizeFactor * 4, x + sizeFactor * 3, y + sizeFactor * 4] // Parte inferior
                ];
            case '$':
                return [
                    [x + sizeFactor * 2, y, x, y + sizeFactor * 1], // Parte superior
                    [x, y + sizeFactor * 1, x + sizeFactor * 3, y + sizeFactor * 1], // Línea horizontal
                    [x + sizeFactor * 3, y + sizeFactor * 1, x + sizeFactor * 1, y + sizeFactor * 2], // Diagonal
                    [x + sizeFactor * 1, y + sizeFactor * 2, x + sizeFactor * 2, y + sizeFactor * 2], // Línea horizontal
                    [x + sizeFactor * 2, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 2], // Línea horizontal
                    [x + sizeFactor * 3, y + sizeFactor * 2, x, y + sizeFactor * 3], // Diagonal
                    [x, y + sizeFactor * 3, x + sizeFactor * 3, y + sizeFactor * 3], // Línea horizontal
                    [x + sizeFactor * 3, y + sizeFactor * 3, x + sizeFactor * 2, y + sizeFactor * 4], // Diagonal
                    [x + sizeFactor * 2, y + sizeFactor * 4, x + sizeFactor * 1, y + sizeFactor * 4] // Parte inferior
                ];
            case '%':
                return [
                    [x, y, x + sizeFactor * 1, y + sizeFactor * 1], // Diagonal superior
                    [x + sizeFactor * 1, y + sizeFactor * 1, x + sizeFactor * 2, y], // Diagonal superior
                    [x + sizeFactor * 2, y, x + sizeFactor * 3, y + sizeFactor * 1], // Diagonal superior
                    [x + sizeFactor * 3, y + sizeFactor * 1, x + sizeFactor * 3, y + sizeFactor * 2], // Línea vertical
                    [x + sizeFactor * 3, y + sizeFactor * 2, x + sizeFactor * 2, y + sizeFactor * 3], // Diagonal inferior
                    [x + sizeFactor * 2, y + sizeFactor * 3, x + sizeFactor * 1, y + sizeFactor * 2], // Diagonal inferior
                    [x + sizeFactor * 1, y + sizeFactor * 2, x, y + sizeFactor * 3], // Diagonal inferior
                    [x, y + sizeFactor * 3, x + sizeFactor * 1, y + sizeFactor * 4], // Diagonal inferior
                    [x + sizeFactor * 1, y + sizeFactor * 4, x + sizeFactor * 2, y + sizeFactor * 3], // Diagonal inferior
                    [x + sizeFactor * 2, y + sizeFactor * 3, x + sizeFactor * 3, y + sizeFactor * 4] // Diagonal inferior
                ];
            case '^':
                return [
                    [x + sizeFactor * 1, y + sizeFactor * 3, x, y + sizeFactor * 4], // Diagonal izquierda
                    [x, y + sizeFactor * 4, x + sizeFactor * 2, y + sizeFactor * 3], // Diagonal derecha
                    [x + sizeFactor * 2, y + sizeFactor * 3, x + sizeFactor * 3, y + sizeFactor * 4] // Diagonal derecha
                ];
            case '&':
                return [
                    [x + sizeFactor * 1, y, x + sizeFactor * 2, y + sizeFactor * 1], // Diagonal superior
                    [x + sizeFactor * 2, y + sizeFactor * 1, x + sizeFactor * 3, y], // Diagonal superior
                    [x + sizeFactor * 3, y, x + sizeFactor * 3, y + sizeFactor * 1], // Línea vertical
                    [x + sizeFactor * 3, y + sizeFactor * 1, x + sizeFactor * 2, y + sizeFactor * 2], // Diagonal
                    [x + sizeFactor * 2, y + sizeFactor * 2, x + sizeFactor * 1, y + sizeFactor * 1], // Diagonal
                    [x + sizeFactor * 1, y + sizeFactor * 1, x, y], // Diagonal
                    [x, y, x, y + sizeFactor * 1], // Línea vertical
                    [x, y + sizeFactor * 1, x + sizeFactor * 1, y + sizeFactor * 2], // Diagonal
                    [x + sizeFactor * 1, y + sizeFactor * 2, x + sizeFactor * 2, y + sizeFactor * 3], // Diagonal
                    [x + sizeFactor * 2, y + sizeFactor * 3, x + sizeFactor * 3, y + sizeFactor * 2], // Diagonal
                    [x + sizeFactor * 3, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 3], // Línea vertical
                    [x + sizeFactor * 3, y + sizeFactor * 3, x + sizeFactor * 2, y + sizeFactor * 4], // Diagonal
                    [x + sizeFactor * 2, y + sizeFactor * 4, x + sizeFactor * 1, y + sizeFactor * 3], // Diagonal
                    [x + sizeFactor * 1, y + sizeFactor * 3, x, y + sizeFactor * 4] // Diagonal
                ];
            case '*':
                return [
                    [x + sizeFactor * 1.5, y, x + sizeFactor * 1.5, y + sizeFactor * 4], // Línea vertical
                    [x, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 2], // Línea horizontal
                    [x, y + sizeFactor * 4, x + sizeFactor * 3, y] // Diagonal
                ];
            case '(':
                return [
                    [x + sizeFactor * 1, y, x, y + sizeFactor * 1], // Diagonal superior
                    [x, y + sizeFactor * 1, x, y + sizeFactor * 3], // Línea vertical
                    [x, y + sizeFactor * 3, x + sizeFactor * 1, y + sizeFactor * 4] // Diagonal inferior
                ];
            case ')':
                return [
                    [x + sizeFactor * 2, y, x + sizeFactor * 3, y + sizeFactor * 1], // Diagonal superior
                    [x + sizeFactor * 3, y + sizeFactor * 1, x + sizeFactor * 3, y + sizeFactor * 3], // Línea vertical
                    [x + sizeFactor * 3, y + sizeFactor * 3, x + sizeFactor * 2, y + sizeFactor * 4] // Diagonal inferior
                ];
            case '-':
                return [
                    [x, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 2] // Línea horizontal
                ];
            case '+':
                return [
                    [x + sizeFactor * 1.5, y, x + sizeFactor * 1.5, y + sizeFactor * 4], // Línea vertical
                    [x, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 2] // Línea horizontal
                ];
            case '=':
                return [
                    [x, y + sizeFactor * 1.5, x + sizeFactor * 3, y + sizeFactor * 1.5], // Línea horizontal superior
                    [x, y + sizeFactor * 2.5, x + sizeFactor * 3, y + sizeFactor * 2.5] // Línea horizontal inferior
                ];
            case '[':
                return [
                    [x, y, x, y + sizeFactor * 4], // Línea vertical
                    [x, y, x + sizeFactor * 1, y], // Parte superior
                    [x, y + sizeFactor * 4, x + sizeFactor * 1, y + sizeFactor * 4] // Parte inferior
                ];
            case ']':
                return [
                    [x + sizeFactor * 2, y, x + sizeFactor * 2, y + sizeFactor * 4], // Línea vertical
                    [x + sizeFactor * 2, y, x + sizeFactor * 3, y], // Parte superior
                    [x + sizeFactor * 2, y + sizeFactor * 4, x + sizeFactor * 3, y + sizeFactor * 4] // Parte inferior
                ];
            case '{':
                return [
                    [x + sizeFactor * 1, y, x, y + sizeFactor * 1], // Diagonal superior
                    [x, y + sizeFactor * 1, x, y + sizeFactor * 3], // Línea vertical
                    [x, y + sizeFactor * 3, x + sizeFactor * 1, y + sizeFactor * 4], // Diagonal inferior
                    [x + sizeFactor * 1, y, x + sizeFactor * 2, y], // Parte superior
                    [x + sizeFactor * 2, y + sizeFactor * 4, x + sizeFactor * 1, y + sizeFactor * 4] // Parte inferior
                ];
            case '}':
                return [
                    [x + sizeFactor * 2, y, x + sizeFactor * 3, y + sizeFactor * 1], // Diagonal superior
                    [x + sizeFactor * 3, y + sizeFactor * 1, x + sizeFactor * 3, y + sizeFactor * 3], // Línea vertical
                    [x + sizeFactor * 3, y + sizeFactor * 3, x + sizeFactor * 2, y + sizeFactor * 4], // Diagonal inferior
                    [x + sizeFactor * 2, y, x + sizeFactor * 1, y], // Parte superior
                    [x + sizeFactor * 1, y + sizeFactor * 4, x + sizeFactor * 2, y + sizeFactor * 4] // Parte inferior
                ];
            case '|':
                return [
                    [x + sizeFactor * 1.5, y, x + sizeFactor * 1.5, y + sizeFactor * 4] // Línea vertical
                ];
            case '\\':
                return [
                    [x, y, x + sizeFactor * 3, y + sizeFactor * 4] // Diagonal
                ];
            case ':':
                return [
                    [x + sizeFactor * 1.5, y + sizeFactor * 1, x + sizeFactor * 1.5, y + sizeFactor * 1.5], // Punto superior
                    [x + sizeFactor * 1.5, y + sizeFactor * 2.5, x + sizeFactor * 1.5, y + sizeFactor * 3] // Punto inferior
                ];
            case ';':
                return [
                    [x + sizeFactor * 1.5, y + sizeFactor * 1, x + sizeFactor * 1.5, y + sizeFactor * 1.5], // Punto superior
                    [x + sizeFactor * 1.5, y + sizeFactor * 2.5, x + sizeFactor * 1.5, y + sizeFactor * 3], // Punto inferior
                    [x + sizeFactor * 1.5, y + sizeFactor * 3, x, y + sizeFactor * 4] // Cola
                ];
            case '"':
                return [
                    [x + sizeFactor * 1, y + sizeFactor * 3, x, y + sizeFactor * 4], // Comilla izquierda
                    [x + sizeFactor * 2, y + sizeFactor * 3, x + sizeFactor * 3, y + sizeFactor * 4] // Comilla derecha
                ];
            case '\'':
                return [
                    [x + sizeFactor * 1.5, y + sizeFactor * 3, x + sizeFactor * 1.5, y + sizeFactor * 4] // Comilla simple
                ];
            case '<':
                return [
                    [x + sizeFactor * 3, y, x, y + sizeFactor * 2], // Diagonal superior
                    [x, y + sizeFactor * 2, x + sizeFactor * 3, y + sizeFactor * 4] // Diagonal inferior
                ];
            case '>':
                return [
                    [x, y, x + sizeFactor * 3, y + sizeFactor * 2], // Diagonal superior
                    [x + sizeFactor * 3, y + sizeFactor * 2, x, y + sizeFactor * 4] // Diagonal inferior
                ];
            case ',':
                return [
                    [x + sizeFactor * 1.5, y + sizeFactor * 3, x + sizeFactor * 1.5, y + sizeFactor * 4], // Línea vertical
                    [x + sizeFactor * 1.5, y + sizeFactor * 4, x, y + sizeFactor * 4.5] // Cola
                ];
            case '.':
                return [
                    [x + sizeFactor * 1.5, y + sizeFactor * 3, x + sizeFactor * 1.5, y + sizeFactor * 3.5] // Punto
                ];
            case '/':
                return [
                    [x + sizeFactor * 3, y, x, y + sizeFactor * 4] // Diagonal
                ];
            default:
                return []; // Default line for unknown characters
        }
    }

    // Sending Draw Command via WebSocket
    function sendDrawCommand(x1, y1, x2, y2, color) {
        let message = `42["drawcmd",0,[${x1},${y1},${x2},${y2},false,0,"${color}",0,0,{}]]`;
        window.sockets.forEach(socket => {
            if (socket.readyState === WebSocket.OPEN) {
                socket.send(message);
            }
        });
    }

    // Overriding WebSocket send method to capture sockets
    const originalSend = WebSocket.prototype.send;
    WebSocket.prototype.send = function (...args) {
        if (window.sockets.indexOf(this) === -1) {
            window.sockets.push(this);
        }
        return originalSend.call(this, ...args);
    };

    // Initializing
    window.sockets = [];
    addTextInput();
})();