Enhance JKLM Bomb Party game with customizable difficulty and syllable display
// ==UserScript==
// @name JKLM Hardcore Enhanced
// @namespace http://tampermonkey.net/
// @version 2024-08-02
// @license MIT
// @description Enhance JKLM Bomb Party game with customizable difficulty and syllable display
// @author SÜSSWASSERZIERFISCH
// @match https://*.jklm.fun/games/bombparty/
// @icon https://www.google.com/s2/favicons?sz=64&domain=jklm.fun
// @run-at document-start
// @grant GM_xmlhttpRequest
// @connect huggingface.co
// ==/UserScript==
(function() {
'use strict';
// Global variables
let silben_obj = {};
let silben_list = [];
let silben_map = new Map();
let einstellungen = {};
let enabled = false;
let selfID = -1;
let currentModifiedSyllable = "";
let originalSyllable = "";
// Pseudo alphabet mapping
const pseudoAlphabetArray = ["𝖠","𝖡","𝖢","𝖣","𝖤","𝖥","𝖦","𝖧","𝖨","𝖩","𝖪","𝖫","𝖬","𝖭","𝖮","𝖯","𝖰","𝖱","𝖲","𝖳","𝖴","𝖵","𝖶","𝖷","𝖸","𝖹"];
const normalAlphabetArray = ["A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"];
const SILLABLE_URL = 'https://huggingface.co/susswasserzierfisch/silben-modell/resolve/main/silben.tsv';
const DEFAULT_SETTINGS = {
enabled: true,
min: 50,
max: 500,
showSolution: false,
letters: [3, 4],
prepend: true
};
// Convert normal text to pseudo alphabet
function toPseudoAlphabet(text) {
return text.toUpperCase().split('').map(char => {
const index = normalAlphabetArray.indexOf(char);
return index !== -1 ? pseudoAlphabetArray[index] : char;
}).join('');
}
// Simulate typing function
function simulateType(text, isSend) {
if (typeof socket !== 'undefined' && socket.emit) {
socket.emit("setWord", text, isSend);
}
}
// Send chat message function
function sendChatMessage(message) {
if (typeof socket !== 'undefined' && socket.emit) {
socket.emit("chat", message);
}
}
// Helper function to extract only letters, apostrophes, and hyphens
function extractValidChars(text) {
return text.replace(/[^a-zA-Z'-]/g, '').toLowerCase();
}
// Helper function to check if text contains syllable
function containsSyllable(text, syllable) {
const cleanText = extractValidChars(text);
const cleanSyllable = extractValidChars(syllable);
return cleanText.includes(cleanSyllable);
}
// Initialize the script
function init() {
loadSettings();
if (localStorage.silben) {
loadSilben(localStorage.silben);
setupUI();
} else {
fetchSilben();
}
}
// Fetch syllables data from the server
function fetchSilben() {
GM_xmlhttpRequest({
method: 'GET',
url: SILLABLE_URL,
headers: { 'Accept': 'application/json' },
onload: function(response) {
if (response.status === 200) {
try {
localStorage.silben = response.responseText;
loadSilben(localStorage.silben);
setupUI();
} catch (e) {
console.error("Failed to process syllables data:", e);
}
} else {
console.error("Failed to fetch syllables data. Status:", response.status);
}
},
onerror: function(error) {
console.error("Error fetching syllables data:", error);
}
});
}
// Load settings from localStorage
function loadSettings() {
einstellungen = JSON.parse(localStorage.einstellungen || JSON.stringify(DEFAULT_SETTINGS));
enabled = einstellungen.enabled;
}
// Load syllables data and build the syllables map
function loadSilben(silben) {
silben.split("\n").forEach(line => {
let [silbe, count, solution] = line.split("\t");
if (silbe && count) {
silben_obj[silbe] = { count, solution };
silben_list.push([silbe, count]);
}
});
silben_map = buildSilbenMap(silben_list);
}
// Build a map of syllables for quick lookup
function buildSilbenMap(silben_list) {
const silbenMap = new Map();
for (const [silbe, value] of silben_list) {
for (let i = 0; i < silbe.length; i++) {
for (let j = i + 1; j <= silbe.length; j++) {
const subsilbe = silbe.substring(i, j);
if (!silbenMap.has(subsilbe)) {
silbenMap.set(subsilbe, []);
}
silbenMap.get(subsilbe).push([silbe, value]);
}
}
}
return silbenMap;
}
// Set up the user interface
function setupUI() {
if (document.querySelector("#hardcore-settings")) return;
const hardcoreSettings = document.createElement("div");
hardcoreSettings.id = "hardcore-settings";
hardcoreSettings.className = "setting rule hardcoreSettings";
hardcoreSettings.innerHTML = `
<div class="label" data-text="hardcoreMode">⚔️ Hardcore-Addon</div>
<div class="info">Hardcore-Addon Aktivieren?</div>
<div class="field">
<input type="checkbox" id="hardcore-toggle">
</div>
<div class="info">Aktivierte Buchstabenzahlen</div>
<div class="field">
<div class="bonusAlphabetField">
<div class="bonusLetterField">
3 <input type="checkbox" id="hardcore-letter-3">
</div>
<div class="bonusLetterField">
4 <input type="checkbox" id="hardcore-letter-4">
</div>
<div class="bonusLetterField">
5 <input type="checkbox" id="hardcore-letter-5">
</div>
</div>
</div>
<div class="info">Silbenschwierigkeit</div>
<div class="field">
<table>
<tbody>
<tr>
<th>Min:</th>
<td class="range">
<input type="number" id="min-number" min="1" max="50000">
<input type="range" id="min-range" min="1" max="5000">
</td>
</tr>
<tr>
<th>Max:</th>
<td class="range">
<input type="number" id="max-number" min="1" max="50000">
<input type="range" id="max-range" min="1" max="5000">
</td>
</tr>
</tbody>
</table>
</div>
<div class="info">Silbe voranstellen?</div>
<div class="field">
<input type="checkbox" id="prepend-toggle">
</div>`;
// Wait for the rules element to exist
const waitForRules = setInterval(() => {
const rulesElement = document.querySelector(".rules");
if (rulesElement) {
rulesElement.appendChild(hardcoreSettings);
setupEventListeners();
clearInterval(waitForRules);
}
}, 100);
}
// Set up event listeners for UI elements
function setupEventListeners() {
const minNumber = document.querySelector("#min-number");
const minRange = document.querySelector("#min-range");
const maxNumber = document.querySelector("#max-number");
const maxRange = document.querySelector("#max-range");
const toggleCheckbox = document.querySelector("#hardcore-toggle");
const letter3Checkbox = document.querySelector("#hardcore-letter-3");
const letter4Checkbox = document.querySelector("#hardcore-letter-4");
const letter5Checkbox = document.querySelector("#hardcore-letter-5");
const prependCheckbox = document.querySelector("#prepend-toggle");
if (!minNumber || !toggleCheckbox) return;
// Set initial values
minNumber.value = minRange.value = einstellungen.min;
maxNumber.value = maxRange.value = einstellungen.max;
toggleCheckbox.checked = einstellungen.enabled;
letter3Checkbox.checked = einstellungen.letters.includes(3);
letter4Checkbox.checked = einstellungen.letters.includes(4);
letter5Checkbox.checked = einstellungen.letters.includes(5);
prependCheckbox.checked = einstellungen.prepend;
// Event listeners
minNumber.addEventListener("input", () => updateMinMax('min', minNumber, minRange));
minRange.addEventListener("input", () => updateMinMax('min', minRange, minNumber));
maxNumber.addEventListener("input", () => updateMinMax('max', maxNumber, maxRange));
maxRange.addEventListener("input", () => updateMinMax('max', maxRange, maxNumber));
toggleCheckbox.addEventListener("change", () => {
einstellungen.enabled = toggleCheckbox.checked;
enabled = einstellungen.enabled;
updateSettings();
});
letter3Checkbox.addEventListener("change", () => updateLetters(3, letter3Checkbox.checked));
letter4Checkbox.addEventListener("change", () => updateLetters(4, letter4Checkbox.checked));
letter5Checkbox.addEventListener("change", () => updateLetters(5, letter5Checkbox.checked));
prependCheckbox.addEventListener("change", () => {
einstellungen.prepend = prependCheckbox.checked;
updateSettings();
});
}
// Update min/max values in settings
function updateMinMax(type, primary, secondary) {
secondary.value = primary.value;
einstellungen[type] = parseInt(primary.value, 10);
updateSettings();
}
// Update enabled letters in settings
function updateLetters(letter, isChecked) {
if (isChecked) {
if (!einstellungen.letters.includes(letter)) {
einstellungen.letters.push(letter);
}
} else {
einstellungen.letters = einstellungen.letters.filter(l => l !== letter);
}
updateSettings();
}
// Save settings to localStorage
function updateSettings() {
localStorage.einstellungen = JSON.stringify(einstellungen);
}
// Choose a syllable based on enabled letters and difficulty range
function silbeWahlen(subsilbe) {
if (!enabled) return subsilbe;
const candidates = (silben_map.get(subsilbe) || []).filter(silbe => {
const syllableLength = silbe[0].length;
const syllableValue = parseInt(silbe[1], 10);
return einstellungen.letters.includes(syllableLength) &&
syllableValue >= einstellungen.min &&
syllableValue <= einstellungen.max;
});
if (candidates.length > 0) {
let randomIndex = Math.floor(Math.random() * candidates.length);
return candidates[randomIndex][0];
}
return subsilbe;
}
// Utility function to split the incoming string
function splitString(input) {
const regex = /^(\d+)(.*)/;
const match = input.match(regex);
return match ? { digits: match[1], rest: match[2] } : { digits: null, rest: input };
}
function modifySend(data) {
try {
let { digits, rest } = splitString(data);
// Check if there's actually JSON data to parse
if (!rest || rest.length === 0) {
return data;
}
let json = JSON.parse(rest);
// Check if this is a setWord message
if (data.includes("setWord") && json.length >= 3) {
console.log("HELLO", data);
console.log("Original JSON:", json);
// The structure is ["setWord", word, isSend]
let userInput = json[1]; // The word is at index 1
let isSend = json[2]; // The boolean is at index 2
// Fix 2: Don't modify if input starts with '/'
if (userInput && typeof userInput === 'string' && userInput.startsWith('/')) {
return data;
}
// Updated logic: Prevent sending if word contains original syllable but not modified one
if (userInput && typeof userInput === 'string' && originalSyllable && currentModifiedSyllable) {
const containsOriginal = containsSyllable(userInput, originalSyllable);
const containsModified = containsSyllable(userInput, currentModifiedSyllable);
// If word contains original syllable but not the modified one, prevent sending
if (containsOriginal && !containsModified) {
json[2] = false; // Set isSend to false
}
// If word doesn't contain original syllable at all, allow sending (don't change isSend)
// If word contains modified syllable, allow sending (don't change isSend)
}
// Check if userInput exists and currentModifiedSyllable is valid
if (userInput &&
typeof userInput === 'string' &&
userInput.length < 30 &&
currentModifiedSyllable &&
currentModifiedSyllable !== originalSyllable &&
currentModifiedSyllable.trim() !== '' &&
enabled &&
einstellungen.prepend) {
let pseudoSyllable = toPseudoAlphabet(currentModifiedSyllable.toUpperCase());
let modifiedInput = `(${pseudoSyllable}) ${userInput}`;
// Only prepend the syllable if the final result is 30 characters or less
if (modifiedInput.length <= 30) {
json[1] = modifiedInput;
console.log("MODIFIED!", json);
return digits + JSON.stringify(json);
}
}
}
} catch (err) {
console.log("Failed to modify send:", err);
}
// Always return the original data if no modification was made
return data;
}
// Modify incoming string messages after receiving
function modifyReceive(data) {
let { digits, rest } = splitString(data);
// Check if there's actually JSON data to parse
if (!rest || rest.length === 0) {
return data;
}
try {
let json = JSON.parse(rest);
if (data.includes("nextTurn") && json.length >= 3) {
let [, targetUser, newSilbe] = json;
originalSyllable = newSilbe;
if (targetUser === selfID) {
currentModifiedSyllable = silbeWahlen(newSilbe.toUpperCase()).toLowerCase();
// Send the modified syllable in pseudo alphabet immediately only if enabled and prepend is on
if (currentModifiedSyllable !== originalSyllable && enabled && einstellungen.prepend) {
let pseudoSyllable = toPseudoAlphabet(currentModifiedSyllable.toUpperCase());
setTimeout(() => {
sendChatMessage(`(${pseudoSyllable})`);
}, 100);
}
// Fix 3: Automatically write the syllable when turn starts only if enabled and prepend is on
if (enabled && einstellungen.prepend) {
setTimeout(() => {
simulateType(currentModifiedSyllable, false);
}, 150);
}
newSilbe = currentModifiedSyllable;
}
json[2] = newSilbe;
return digits + JSON.stringify(json);
}
if (data.includes("syllable") && json.length >= 2 && json[1] && json[1].currentPlayerPeerId !== undefined) {
let targetUser = json[1].currentPlayerPeerId;
let newSilbe = json[1].syllable;
originalSyllable = newSilbe;
if (targetUser === selfID) {
currentModifiedSyllable = silbeWahlen(newSilbe.toUpperCase()).toLowerCase();
// Send the modified syllable in pseudo alphabet immediately only if enabled and prepend is on
if (currentModifiedSyllable !== originalSyllable && enabled && einstellungen.prepend) {
let pseudoSyllable = toPseudoAlphabet(currentModifiedSyllable.toUpperCase());
setTimeout(() => {
sendChatMessage(`(${pseudoSyllable})`);
}, 100);
}
// Fix 3: Automatically write the syllable when turn starts only if enabled and prepend is on
if (enabled && einstellungen.prepend) {
setTimeout(() => {
simulateType(currentModifiedSyllable, false);
}, 150);
}
json[1].syllable = currentModifiedSyllable;
}
return digits + JSON.stringify(json);
}
if (data.includes("selfPeerId") && json.length >= 2 && json[1] && json[1].selfPeerId !== undefined) {
selfID = json[1].selfPeerId;
}
} catch (err) {
console.log("Failed to parse JSON:", err);
}
return data;
}
// Override the WebSocket send method
const originalSend = WebSocket.prototype.send;
WebSocket.prototype.send = function(...args) {
let [dataToSend] = args;
if (typeof dataToSend === 'string') {
console.log("[WebSocket Interceptor] Sending:", dataToSend);
dataToSend = modifySend(dataToSend);
args[0] = dataToSend;
}
return originalSend.apply(this, args);
};
// Intercept incoming WebSocket messages
function interceptWebSocketMessages() {
let originalDescriptor = Object.getOwnPropertyDescriptor(MessageEvent.prototype, "data");
Object.defineProperty(MessageEvent.prototype, "data", {
get: function() {
let originalData = originalDescriptor.get.call(this);
if (this.currentTarget instanceof WebSocket && typeof originalData === 'string') {
console.log("[WebSocket Interceptor] Received:", originalData);
return modifyReceive(originalData);
}
return originalData;
}
});
}
// Initialize the script
init();
interceptWebSocketMessages();
})();