Убрать сложные тексты из режима Обычный!

ё ё ё ё!!! у меня появилось ПРЕДЛОЖЕНИЕ! а что если вам как и мне забить болтяру на плохие тексты на КГ а катать только удобные! оооууу! Я так делаю уже 24 года ТУТ!

С помощью GPT 3.0 я создал два скрипта с половиной и они будут просто вам выдавать приятные тексты! ЭТО БУДУЩЕЕ МАФАКА!

Для начала небольшая демонстрация без музыки и спецэффектов!! :
[url="https://youtu.be/39zA9OQ1Hu4"]https://youtu.be/39zA9OQ1Hu4[/url]

[u]Визуальная часть[/u]
[img]https://i.ibb.co/x1Y7QWK/image.png[/img]

Суть!
1) Нужно два разных браузера
2) Устанавливаем  Tampermonkey
3) в Tampermonkey устанавливаем ТРИ СКРИПТА!

[b]Первый[/b]:

[code]
// ==UserScript==
// @name         good_race
// @namespace    http://tampermonkey.net/
// @version      0.1
// @description  try to take over the world!
// @author       You
// @match        https://klavogonki.ru/gamelist*
// @icon         data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==
// @grant        none
// ==/UserScript==

(function() {
    'use strict';

    window.addEventListener('load', () => { addButton('GOOD RACE!', selectReadFn)})

function addButton(text, onclick, cssObj) {
        cssObj = cssObj || {position: 'relative', width: '100px', bottom: '10%', top: '2%', left:'-15%', 'z-index': 1}
        let button = document.createElement('button'), btnStyle = button.style
        document.body.appendChild(button)
        button.innerHTML = text
        button.onclick = onclick
        return button
}

function selectReadFn() {
location.href = 'https://klavogonki.ru/create/?gametype=normal&type=private&level_from=1&level_to=9&timeout=5&submit=1';
}

})();
[/code]

[b]Второй[/b]:
[code]
// ==UserScript==
// @name         show zaezi chatlogs
// @namespace    http://tampermonkey.net/
// @version      0.1
// @description  try to take over the world!
// @author       You
// @match        https://klavogonki.ru/g/*
// @icon         data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==
// @grant        none
// ==/UserScript==



(function() {
    'use strict';

    setInterval(function(){

var iks = document.getElementsByClassName('rc')[3];
var prog = iks.textContent;
var pars = prog.match(/\d+/g);
var z = Number(pars[0]);
var x= Number(pars[1]);
var url = window.location.href;



var NewGame = 'https://klavogonki.ru/create/?gametype=normal&type=private&level_from=1&level_to=9&timeout=5&submit=1';

if (z ==0|| z ==2 ||z ==1 ||z ==3) {


    console.log(url,'OK', z,x);



    document.location.href = NewGame;

}

else {document.location.href = NewGame;}


},900);

})();
[/code]

[b]Третий[/b] (Это официальный скрипт отображающий сложность текста) :
[code]
// ==UserScript==
// @name         prognoz
// @namespace    http://tampermonkey.net/
// @version      0.1
// @description  try to take over the world!
// @author       You
// @match        https://klavogonki.ru/g/*
// @icon         https://www.google.com/s2/favicons?sz=64&domain=klavogonki.ru
// @grant        none
// ==/UserScript==

function embed() {
    var COMPLEXITY_TEXT = [
        "СУПЕР РЕКОРДНЫЙ ТЕКСТ",    // < 1
        "РЕКОРДНЫЙ ТЕКСТ",          // < 2
        "очень лёгкий текст",       // < 3
        "лёгкий текст",             // < 4
        "нормальный текст",         // < 5
        "нормальный текст",         // < 6
        "текст сложней нормального",// < 7
        "сложноватый текст",        // < 8
        "сложный текст",            // < 9
        "очень сложный текст",      // < 10
        "очень сложный текст",      // < 11
        "крайне сложный текст",     // < 12
        "крайне сложный текст",     // < 13
        "мега сложный текст",       // < 14
        "мега сложный текст",       // < 15
        "текст - жесть",            // < 16
        "текст - жесть",            // < 17
        "запредельная сложность"    // < 18
       ];

    // 2 letters combinations for the Russian language, ordered by their frequency. Only the first 791 most common combinations are included.
    // The rest will get the worst coefficient.
    var SYLLABLES = "тостнанопонеконираеналроовголипркаосерреотволаолтатьонваореллоеттеомодзавеилриатдеанлеогесдальитактиемасмеойсяныдообскмо" +
        "инчежесеамазтрмикиависвиедбысоманнимарсьчтслегнурутвбовыдииевсизейивикпеокэтхооеадожчабемушеспаяихияудкрочсидневчиляылкузнсапаты" +
        "дуульншиутнящежитсеесвыйрыопозекмнидаетуусичглужлуятлсвнийыеымезгабребтныхиражмыжадруюьсснлюпиечгднтбугрииахрярнабжнаюссучачьквл" +
        "ньумчноиугапывцеплщизвбиепгиешсмашблсуцишазджддвошбактврукицагайртежпуялупклдлвуурытоязолытккенсубещысянушвшдыувцаютишиггуйсшьох" +
        "хатяехядндчуьшзирьшкющибшлбягеясдьнквзземязыьюзуямзмрврмышиюкндснцухщайнявлнунбнюдркрсьефилкиоецпырдсычкущллржсрдяацзрзгузфоиаюб" +
        "счргязлжеоксвягнижшнджьяащвтоойтвкзлипдкящощхнуефебщхишовдтлыршувпзяоюсдчьыбьмжуфаршмлпяхрмпквяхнгцоофяецыбсынхвсхеяыкищаивьдцоц" +
        "якфрйднчьзрхыпычйчауафзбючмсюсяжзкэлпньтбъяюсюрлцущунюхулгеювмдттдеарюнщзьхлуабкмкгкэнчшдпеиыдэкъеыгтчйкммррячрплчъятттпштеуяржк" +
        "ягжоьцуйэрьбптоупппкоэйшефифрчрбмьсшяяюрхерцлднрызлткцсбдммбчоймбхпьддцвфлфущнжчьгзжнфтмюньчэмьдьицкпсдшйокжуятцйцтюхмсцйлуивввч" +
        "бвдчяцмряйхсэйдхщьюзаоккрзябыжмгсэтбсфюкбмвхюмнзмчэсмэжьчлбьяпьфлпффрэжбюлдбэдвцнвгчуэвгиулбяилмхтюцдздгшвоаюжьврфсжэвкэнжьодюсг" +
        "съмцююдъэпрщлздэыягвюшббэфюглвчргсфтаэкззсггшпуфтщйруошмжсззпчмвтхфыюхгтзъааяшбюбдэгуцйеншбжгмлэыцкшйзхэмфнбвщжрфстэлштъпцбшзтжл" +
        "иэнхйвшрыщьщжжтгкмжгйфтшэхзчтфвънлыивблхсзнэйбйабэлфэшхшьпэзюпкгжмпшбтзцйгчвгэмтйхбзмюйяэбтзфьзюшцюйфюйпкпмъюабцпюхьювкхгбщрхъвэ" +
        "пэчмзшмзбчууфнцзкдлщчжхгфэыумщгюфгкюгшжюшюбгнъщоцлццфммхюикъкбцнпбнмцмйикьнплъюепфъюдфлрьхцсмшкчххюфьркфжтмдвжзэцрхкфчгхсщюэшсцд" +
        "ччхчгпфбеэхдшээямжжэяугзшхвюйщфяжцээйюгфпвхпэожвчэтжцп";

    // Complexity weight for each character. Russian letters and special characters use different formulas, so even if you
    // see the same weights for some Russian letter and some special character, they will contribute different final weights.
    var CHAR_WEIGHTS = {
        "а": 105,   "б": 142,   "в": 119,   "г": 140,   "д": 125,   "е": 105,   "ж": 153,   "з": 142,   "и": 107,   "й": 150,
        "к": 122,   "л": 117,   "м": 122,   "н": 108,   "о": 100,   "п": 126,   "р": 118,   "с": 115,   "т": 110,   "у": 127,
        "ф": 155,   "х": 157,   "ц": 175,   "ч": 145,   "ш": 160,   "щ": 180,   "ъ": 200,   "ы": 140,   "ь": 137,   "э": 183,
        "ю": 167,   "я": 135,   "\n": 0.3,  " ": 0.3,   ".": 2.0,   ",": 2.5,   "!": 4.0,   "?": 3.0,   ":": 4.0,   ";": 4.5,
        "\"": 7.0,  "«": 5.0,   "»": 5.0,   "'": 9.0,   "_": 8.0,   "%": 8.0,   "—": 5.0,   "–": 5.0,   "-": 5.0,   "(": 5.0,
        ")": 5.0,   "*": 7.0,   "=": 7.0,   "+": 7.0,   "№": 5.0,   "#": 9.0,   "$": 9.0,   "&": 9.0,   "/": 9.0,   "\\": 10.0,
        "|": 10.0,  "<": 11.0,  ">": 11.0,  "@": 11.0,  "[": 11.0,  "]": 11.0,  "^": 11.0,  "~": 11.0,  "`": 11.0,  "{": 11.0,
        "}": 11.0,  "0": 5.0,   "1": 5.0,   "2": 5.0,   "3": 5.0,   "4": 5.0,   "5": 5.0,   "6": 5.0,   "7": 5.0,   "8": 5.0,
        "9": 5.0
    };

    // Spectrum canvas settings
    var CANVAS_HEIGHT = 12;
    var CANVAS_OPACITY  = 0.65;

    // This is the upper threshold for the spectrum complexity. Everything up will be pure red.
    var MAX_SPECTRUM_COMPLEXITY = 310;

    // This is the bottom threshold for the spectrum complexity. Everything down will be pure green.
    var MIN_SPECTRUM_COMPLEXITY = 120;

    var SPECTRUM_COMPLEXITY_RANGE = MAX_SPECTRUM_COMPLEXITY - MIN_SPECTRUM_COMPLEXITY;

    // If character is not found, then it will be treated as a special character with the given weight
    var UNKNOWN_CHAR_WEIGHT = 15.0;

    // All Russian letters, with the exception of the first one, in the word will get such default weight
    var DEFAULT_LETTER_WEIGHT = 100;

    // Characters for Russian language.
    var ALPHABETICAL_CHARACTERS = "абвгдеёжзийклмнопрстуфхцчшщъыьэюя";

    // If letter is a capital, we add such a number to its weight
    var CAPITAL_WEIGHT = 200.0;

    // If the some word has number of capitals more than this value, then we stop apply CAPITAL_COEF, because user will likely use Caps key
    var CAPS_LENGTH = 4;

    // If character is not part of Russian letters, we multiply weight by this number
    var SPECIAL_CHARACTER_COEF = 200.0;

    // Whole word's weight will get coefficient multiplied depending on its size. Longer words are harder to type.
    // If a word has only a single letter, then it will take longer to type it, because it doesn't have keys combination
    // with other letters.
    var WORD_LENGTH_COEF = [2.0, 1.0, 1.0, 1.0, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0];

    // Dictionary with 2 letters combinations and their frequency orders. We use associative array for search, because it is much faster (if it is hot),
    // than other approaches: String#indexOf, RegExp, Array#indexOf.
    var dictionary = {};

    // A flag for preventing clone panel creation:
    var initialized = false;

    // Saving the original prototype method:
    var proxied = window.XMLHttpRequest.prototype.send;

    window.XMLHttpRequest.prototype.send = function () {
        this.addEventListener('load', function () {
            try {
                var json = JSON.parse(this.responseText);
                if ('text' in json) {
                    createPanel(json.text.text);
                }
            } catch (e) {}
        }.bind(this));
        return proxied.apply(this, [].slice.call(arguments));
    };

    function createPanel (text) {
        if (initialized) {
            return false;
        }

        initialized = true;
        prepareDictionary();

        var complexityObject = getComplexity(text);
        var complexity = complexityObject.complexity.toFixed(2);



//console.log(getComplexity(text));
//console.log(text);



        var params = document.getElementById("params");
        if (params) {
            // We use wrapper only as a workaround to support KTS custom styles.
            // KTS changes panel style by ID. We use "statistics" ID, which is also used by another panel.
            // HTML 5 allows duplicate IDs. They just need to be in different subtrees. I don't like
            // such approach, but I fear it's the only way for now, unless we ask KTS developer to
            // include some lines into img/apply.js file.
            var wrapper = document.createElement("div");
            wrapper.id = "complexity-panel";

            var elem = document.createElement("div");
            elem.style.setProperty("background", "none repeat scroll 0 0 #F8F4E6", null);
            elem.style.setProperty("margin-top", "10px", null);
            elem.style.setProperty("margin-bottom", "10px", null);
            elem.id = "statistics";

            wrapper.appendChild(elem);
            params.parentNode.insertBefore(wrapper, params.nextSibling);

            elem.innerHTML = '<div class="r tl" title="v1.4"><div class="tr"><div class="bl"><div class="br"><div class="rc">' +
                '<h4>Прогноз сложности</h4>' +

                '<div><span style="font-size:17px;font-weight:bold;color:#333">' + (complexity >= 0 ? complexity.slice(0, -3) : '') + '</span>' +
                '<span style="font-size:14px;font-weight:bold;color:#666">' + (complexity >= 0 ? '.' + complexity.slice(-2) : 'N/A')+ '</span>' +
                '&nbsp;?&nbsp;' + (complexity >= 0 ? getComplexityText(complexity) : 'неприменимо к данному заезду') +

                '</div><div style="margin:10px 0 4px;background-color:white"id="spectrumCanvas"/>' +
                '</div></div></div></div></div>';

            // Add spectrum canvas to the panel
            if (complexity >= 0) {
                var spectrum = complexityObject.spectrum;
                smoothArray(spectrum, 10);

                var canvasDiv = document.getElementById("spectrumCanvas");

                var canvasElem = getSpectrumCanvas(spectrum, canvasDiv.clientWidth, CANVAS_HEIGHT);
                if (canvasElem != null) {
                    canvasDiv.appendChild(canvasElem);
                }
            }
        }
    }

    function prepareDictionary() {
        for (var i = 0; i < SYLLABLES.length; i += 2) {
            dictionary[SYLLABLES.substr(i, 2)] = i / 2;
        }
    }

    function getWordLengthCoef(length) {
        return WORD_LENGTH_COEF[(length < WORD_LENGTH_COEF.length) ? length - 1 : WORD_LENGTH_COEF.length - 1];
    }

    function getComplexityText(complexity) {
        var position = Math.floor(complexity);
        return COMPLEXITY_TEXT[(position < COMPLEXITY_TEXT.length) ? position : COMPLEXITY_TEXT.length - 1];
    }

    // Return string complexity and its spectrum. Return -1 for the complexity, if it can't be applied to the string.
    function getComplexity(str) {
        var complexity = 0.0;
        var wordLength = 0;
        var wordComplexity = 0;
        var capsLength = 0;
        var prevChar = "";
        var unknownCharNum = 0;
        var spectrum = [];
        var pos = 0;
        var wordComplexityPerCharacter, j;

        // Replace all "ё" occurrences to "е".
        str = str.split("ё").join("е");

        for (var i = 0; i < str.length; i++) {
            var char = str.charAt(i);
            var charLowerCase = char.toLowerCase();
            var weight;

            if (ALPHABETICAL_CHARACTERS.indexOf(charLowerCase) != -1) {
                // Alphabetical character
                wordLength++;

                if (wordLength === 1) {
                    // First letter in a word will get weight depending on its frequency
                    weight = CHAR_WEIGHTS[charLowerCase];
                } else {
                    // All the following letters in the word will get default weight. Their final weight will depend on the letters combination frequency.
                    weight = DEFAULT_LETTER_WEIGHT;
                }

                // All letters in the word, starting from the second, will apply coefficient depending on the 2 letters frequency
                if (wordLength > 1) {
                    var n = dictionary[prevChar + charLowerCase];
                    if (n == null) {
                        n = -3.75; // This is minimum value, which can be achieved by the following formula
                    }

                    // Such formula returns 2 letters frequency in the decimal logarithmic scale, e.g. "0" - most common, "-1",
                    // if frequency is 10 times less. Formula is a polynomial interpolation based on the experimental selection.
                    var syllableDifficulty = -7e-9 * Math.pow(n, 3) + 7e-6 * Math.pow(n, 2) - 0.0059 * n;

                    // Increase weight based on the difficulty
                    weight *= Math.pow(1 - syllableDifficulty, 1.3);
                }

                // Capitals are harder to type
                var isLowerCase = char === charLowerCase;
                if (!isLowerCase) {
                    capsLength++;

                    if (capsLength < CAPS_LENGTH) {
                        weight += CAPITAL_WEIGHT;
                    }
                } else {
                    capsLength = 0;
                }

                wordComplexity += weight;
                prevChar = charLowerCase;

            } else {
                // Special character (not part of Russian letters)

                // If we reached the end of the word, we need to calculate final word's weight depending on its length
                if (wordLength > 0) {
                    wordComplexity *= getWordLengthCoef(wordLength);
                    complexity += wordComplexity;
                    wordComplexityPerCharacter = wordComplexity / wordLength;

                    for(j = 0; j < wordLength; j++) {
                        spectrum[pos++] = wordComplexityPerCharacter;
                    }
                }

                wordComplexity = 0;
                capsLength = 0;
                wordLength = 0;

                weight = CHAR_WEIGHTS[charLowerCase];
                if (weight == null) {
                    weight = UNKNOWN_CHAR_WEIGHT;
                    unknownCharNum++;
                }

                weight *= SPECIAL_CHARACTER_COEF;
                complexity += weight;

                spectrum[pos++] = weight;
            }
        }

        // If text doesn't finish with the special character, we need to add last word's weight
        if (wordLength > 0) {
            wordComplexity *= getWordLengthCoef(wordLength);
            complexity += wordComplexity;

            wordComplexityPerCharacter = wordComplexity / wordLength;

            for(j = 0; j < wordLength; j++) {
                spectrum[pos++] = wordComplexityPerCharacter;
            }
        }

        // Complexity is per character
        if (str.length > 0) {
            complexity /= str.length;
        } else {
            return {complexity: 0, spectrum: spectrum};
        }

        // if number of unknown characters is more than 10%, then complexity value is inconsistent
        if (unknownCharNum / str.length > 0.1) {
            return {complexity: -1, spectrum: spectrum};
        }

        // Divide by theoretical complexity minimum in order to start our reference frame for complexity from 1
        complexity /= 160;
        if (complexity < 1) {
            complexity = 1;
        }

        complexity -= 1;
        complexity *= 20; // Scale complexity to readable values, so ~10 is close to usual hard complexity

        return {
            complexity: complexity,
            spectrum: spectrum
        };
    }

    // Function smooths (blurs) 1D array using flat convolution buffer. Algorithm complexity is O(N + power).
    function smoothArray(array, power) {
        var smoothedValue = 0;
        var fractions = [];
        var coef = 2 * power + 1;

        for (var i = 0; i < array.length + power; i++) {
            if (i >= coef) {
                smoothedValue -= fractions[i % coef];
            }

            if (i < array.length) {
                var value = array[i];
                smoothedValue += value;
                fractions[i % coef] = value;
            }

            if (i >= power) {
                var factor;

                if (i < array.length) {
                    factor = Math.min(i + 1, coef);
                } else {
                    factor = coef + array.length - i - 1;
                }

                array[i - power] = smoothedValue / factor;
            }
        }
    }

    // Function returns canvas with the given width and height. We paint spectrum on the canvas using values in the array.
    // Lowest values will be green. Middle will be yellow. Highest will be red.
    function getSpectrumCanvas(array, width, height) {
        var canvas = document.createElement('canvas');
        if (!canvas || !canvas.getContext) {
            // We are very sorry for our dinosaurs. God bless them.
            return null;
        }

        canvas.setAttribute('width', width);
        canvas.setAttribute('height', height);
        if(typeof G_vmlCanvasManager != 'undefined') {
            canvas = G_vmlCanvasManager.initElement(canvas);
        }

        var ctx = canvas.getContext("2d");
        // Too opaque spectrum burns eyes
        ctx.globalAlpha = CANVAS_OPACITY;
        // We need to scale to the given canvas width
        ctx.scale(width / array.length, 1);

        var r, g;
        for (var i = 0; i < array.length; i++) {
            // Apply the thresholds
            var value = Math.min(Math.max(array[i], MIN_SPECTRUM_COMPLEXITY), MAX_SPECTRUM_COMPLEXITY);

            // Scale complexity to 0 - 255 range
            var complexity = Math.floor(255 * (value - MIN_SPECTRUM_COMPLEXITY) / SPECTRUM_COMPLEXITY_RANGE);

            // Calculate red and green components. Blue will be always 0.
            r = Math.min(complexity * 2, 255);
            g = Math.min(2 * (255 - complexity), 255);

            // Paint vertical line
            ctx.strokeStyle="rgb(" + r + "," + g + ",0)";
            ctx.beginPath();
            ctx.moveTo(i, 0);
            ctx.lineTo(i, height);
            ctx.stroke();
        }

        return canvas;
    }
}

var inject = document.createElement("script");
inject.setAttribute("type", "text/javascript");
inject.appendChild(document.createTextNode("(" + embed + ")()"));
document.body.appendChild(inject);
[/code]

Теперь нужен еще один акаунт для БОТА, который и будет осуществлять поиск текста и показывать его в консоли для ВАС.

Итак заходим в новый акаунт (для бота) далее заходим в список заездов и нажимаем кнопку GOOD RACE! появившуюся снизу! Теперь заходим в Консоль браузера и выставляем две настройки: Сохранение журнала и фильтр по слову - ok

[img]https://i.ibb.co/FX9jbyf/1.png[/img]

Вот и делов-то, прошло примерно три с половиной дня, а ты уже разобрался! Ох молодец!

В скрипте номер ДВА можно выставлять настройки поиска сложности текста это происходит в строке
if (z ==0|| z ==2 ||z ==1 ||z ==3) если например эту строку поменять на if (z ==0 ||z ==1 ) то в консоли будут отображаться только тексты с сложностью 0 и 1. Но рекомендую именно делать сложность 0, 1, 2, 3 чтобы было из чего выбирать и не всем удобны тексты с низкой сложностью из за коротких слов и пробелов частых.

Если вдруг кто то хочет! за данное решение всех проблем на клавогонках! задонатить мне миллиарды денег, то можете обратиться к моему помошнику Даниэлю! Он мне обязательно всё передаст!