mirror of
https://wiilab.wiimart.org/wiimart/wiimart-extension
synced 2025-09-03 20:11:04 +02:00
648 lines
20 KiB
JavaScript
648 lines
20 KiB
JavaScript
// classDefinitions.js (This code runs in the page's main world)
|
|
|
|
// IMPORTANT: This script will now receive URLs via window.postMessage from the content script.
|
|
|
|
// These will be populated by the message listener
|
|
let _wiiShopSoundUrls_ = [];
|
|
let _wiiShopBgmUrl_ = '';
|
|
let _bgmInitiallyEnabled = false; // This flag will also be passed via postMessage if needed, or handled by content.js
|
|
let _bgmAlreadyPlaying = false; // This flag can be managed internally by wiiSound
|
|
|
|
// Add a variable to track the current status (matching your original logic)
|
|
let _currentstatus = "";
|
|
|
|
// --- Listener for messages from the content script ---
|
|
window.addEventListener('message', (event) => {
|
|
// Ensure the message is from our extension and the correct type
|
|
if (event.source === window && event.data && event.data.type === "WII_SHOP_EXTENSION_INIT") {
|
|
_wiiShopSoundUrls_ = event.data.soundUrls;
|
|
_wiiShopBgmUrl_ = event.data.bgmUrl;
|
|
_bgmInitiallyEnabled = event.data.bgmInitiallyEnabled; // Capture this if needed in classDefinitions.js
|
|
console.log("classDefinitions.js received URLs and initial BGM state from content script.");
|
|
|
|
// If you need to trigger BGM playback from *within* classDefinitions.js based on initial state, do it here
|
|
// However, your content.js already handles this by sending a message to the background, which is better.
|
|
// The _bgmInitiallyEnabled flag is now more for reference within this script if needed by other logic.
|
|
}
|
|
});
|
|
|
|
|
|
// Existing global variables exposed (these remain the same as your original)
|
|
var ecsUrl = "";
|
|
var iasUrl = "";
|
|
var ccsUrl = "";
|
|
var ucsUrl = "";
|
|
var tid = "";
|
|
var tsz = "";
|
|
var ttmdsz = "";
|
|
var lv = "";
|
|
|
|
window.ecsUrl = ecsUrl;
|
|
window.iasUrl = iasUrl;
|
|
window.ccsUrl = ccsUrl;
|
|
window.ucsUrl = ucsUrl;
|
|
window.tid = tid;
|
|
window.tsz = tsz;
|
|
window.ttmdsz = ttmdsz;
|
|
window.lv = lv;
|
|
window._currentstatus = _currentstatus; // Expose _currentstatus to the global scope
|
|
|
|
|
|
// Define the trace function
|
|
const trace = function(...args) {
|
|
if (typeof extensionStorage !== 'undefined' && typeof extensionStorage.slog === 'function') {
|
|
extensionStorage.slog(args.map(a => String(a)).join(' '));
|
|
}
|
|
console.log(...args);
|
|
};
|
|
|
|
// --- extensionStorage (remains largely the same, but will include sendMessageToBackground) ---
|
|
const storageCache = {};
|
|
const STORAGE_ENDPOINT = '/_extension_storage'; // This endpoint must be intercepted by background.js
|
|
|
|
const extensionStorage = {
|
|
set: (key, value) => {
|
|
storageCache[key] = value;
|
|
fetch(`${STORAGE_ENDPOINT}?set_key=${encodeURIComponent(key)}&set_value=${encodeURIComponent(value)}`)
|
|
.catch(e => console.error("[Page] Error sending storage_set:", e));
|
|
},
|
|
|
|
get: (key) => {
|
|
if (key in storageCache) return storageCache[key];
|
|
|
|
const request = new XMLHttpRequest();
|
|
// Use synchronous XHR for get, which is fine in page context
|
|
request.open('GET', `${STORAGE_ENDPOINT}?get=${encodeURIComponent(key)}`, false);
|
|
try {
|
|
request.send(null);
|
|
if (request.status === 200 || request.status === 0) { // status 0 for local file access in some contexts
|
|
const data = JSON.parse(request.responseText);
|
|
storageCache[key] = data.value;
|
|
return data.value;
|
|
}
|
|
} catch (e) {
|
|
console.error("[Page] Error getting storage via XMLHttpRequest:", e);
|
|
}
|
|
return null;
|
|
},
|
|
|
|
slog: (message) => {
|
|
fetch(`${STORAGE_ENDPOINT}?set_key=slogs&set_value=${encodeURIComponent(message)}`)
|
|
.catch(e => console.error("[Page] Error sending slog:", e));
|
|
},
|
|
|
|
getLogs: () => {
|
|
return extensionStorage.get('logs') || [];
|
|
},
|
|
|
|
clearLogs: () => {
|
|
fetch(`${STORAGE_ENDPOINT}?clogs=true`)
|
|
.catch(e => console.error("[Page] Error sending clearLogs:", e));
|
|
storageCache.logs = [];
|
|
},
|
|
|
|
spts: (points) => {
|
|
const pointsToAdd = parseInt(points) || 0;
|
|
if (pointsToAdd > 0) {
|
|
fetch(`${STORAGE_ENDPOINT}?set_key=spts&set_value=${pointsToAdd}`)
|
|
.catch(e => console.error("[Page] Error sending spts:", e));
|
|
}
|
|
},
|
|
|
|
getpts: () => {
|
|
const points = extensionStorage.get('pts');
|
|
return parseInt(points) || 0;
|
|
},
|
|
|
|
clearpts: () => {
|
|
fetch(`${STORAGE_ENDPOINT}?cpts=true`)
|
|
.catch(e => console.error("[Page] Error sending clearpts:", e));
|
|
storageCache.pts = 0;
|
|
},
|
|
|
|
// New method to send messages to the background script for BGM control
|
|
sendMessageToBackground: async (message) => {
|
|
let url = `${STORAGE_ENDPOINT}?action=${encodeURIComponent(message.action)}`;
|
|
if (message.bgmUrl) {
|
|
url += `&bgmUrl=${encodeURIComponent(message.bgmUrl)}`;
|
|
}
|
|
try {
|
|
await fetch(url);
|
|
} catch (e) {
|
|
console.error(`[Page] Error sending BGM command '${message.action}':`, e);
|
|
}
|
|
}
|
|
};
|
|
|
|
window.extensionStorage = extensionStorage;
|
|
|
|
console.log("Current points (from injected script):", extensionStorage.getpts());
|
|
console.log("Trace loaded (from injected script):", extensionStorage.getLogs());
|
|
|
|
|
|
// Define the ECommerceInterface class
|
|
class ECommerceInterface {
|
|
constructor() {
|
|
const unwantedPath = "/oss/serv/CheckRegistered.jsp";
|
|
if (window.location.pathname === unwantedPath) {
|
|
console.log("Do nothing...");
|
|
}
|
|
trace("ECommerceInterface initialized");
|
|
}
|
|
|
|
getTicketInfos(titleId) {
|
|
return {
|
|
length: 1,
|
|
get: function(index) {
|
|
if (index === 0) {
|
|
return {
|
|
deviceId: 222222,
|
|
limits: null
|
|
};
|
|
}
|
|
return null;
|
|
}
|
|
};
|
|
}
|
|
getTitleInfo(titleid) {
|
|
if (titleid === "0001000248414241") {
|
|
return {
|
|
titleId: titleid,
|
|
isOnDevice: true,
|
|
version: 21,
|
|
isTmdPresent: true,
|
|
occupiedUserBlocks: 0,
|
|
occupiedUserInodes: 0,
|
|
occupiedSysBlocks: 1599,
|
|
occupiedSysInodes: 23
|
|
}
|
|
} else {
|
|
return {
|
|
titleId: titleid,
|
|
isOnDevice: false,
|
|
version: 0,
|
|
isTmdPresent: false,
|
|
occupiedUserBlocks: 0,
|
|
occupiedUserInodes: 0,
|
|
occupiedSysBlocks: 0,
|
|
occupiedSysInodes: 0
|
|
}
|
|
}
|
|
}
|
|
getLog() {
|
|
return extensionStorage.getLogs() || "";
|
|
}
|
|
|
|
getPoints() {
|
|
return extensionStorage.getpts() || 0;
|
|
}
|
|
|
|
setPoints(newPoints) {
|
|
if (!Number.isInteger(newPoints)) {
|
|
newPoints = parseInt(newPoints, 10);
|
|
}
|
|
|
|
if (isNaN(newPoints)) {
|
|
console.error("Invalid points value provided:", newPoints);
|
|
return;
|
|
}
|
|
|
|
extensionStorage.spts(newPoints);
|
|
trace("Points updated to: " + extensionStorage.getpts());
|
|
}
|
|
|
|
loadPoints() {
|
|
console.log("nah i dont load points, they alr loaded");
|
|
}
|
|
|
|
cancelOperation() {
|
|
console.log("bro what do you want me to cancel");
|
|
}
|
|
|
|
setWebSvcUrls(ecsuri, iasuri) {
|
|
window.ecsUrl = ecsuri;
|
|
window.iasUrl = iasuri;
|
|
}
|
|
|
|
setContentUrls(ccsuri, ucsuri) {
|
|
window.ccsUrl = ccsuri;
|
|
window.ucsUrl = ucsuri;
|
|
}
|
|
|
|
getCachedBalance() {
|
|
window._currentstatus = "getCachedBalance"
|
|
const storedPoints = window.localStorage.getItem('points');
|
|
if (storedPoints) {
|
|
return parseInt(storedPoints, 10);
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
refreshCachedBalance() {
|
|
window._currentstatus = "refreshCachedBalance"
|
|
return {
|
|
status: 0,
|
|
operation: "refreshCachedBalance",
|
|
description: "",
|
|
phase: 7,
|
|
isCancelRequested: "false",
|
|
downloadedSize: 0,
|
|
totalSize: 0,
|
|
errCode: 0,
|
|
errInfo: null,
|
|
};
|
|
}
|
|
|
|
checkDeviceStatus() {
|
|
window._currentstatus = "checkDeviceStatus";
|
|
return {
|
|
status: 0,
|
|
operation: "checkDeviceStatus",
|
|
description: "",
|
|
phase: 17,
|
|
isCancelRequested: "false",
|
|
downloadedSize: 0,
|
|
totalSize: 0,
|
|
errCode: 0,
|
|
errInfo: null,
|
|
};
|
|
}
|
|
|
|
getDeviceInfo() {
|
|
return {
|
|
country: "US",
|
|
region: "USA",
|
|
isParentalControlEnabled: false,
|
|
userAge: 20,
|
|
language: "fr",
|
|
accountId: "659247864",
|
|
deviceId: "4587571479",
|
|
serial: "PC156494873",
|
|
maxUserInodes: 200000,
|
|
usedUserInodes: 100000,
|
|
freeChannelAppCount: 41,
|
|
blockSize: 536870912,
|
|
totalBlocks: 65536,
|
|
usedBlocks: 0,
|
|
totalSysBlocks: 65536,
|
|
usedSysBlocks: 0,
|
|
titleId: "0001000248414241",
|
|
accountCountry: "CA",
|
|
deviceCode: "0302167078436756",
|
|
accountDeviceCode: "0302167078436756",
|
|
isKeyPairConfirmed: function() { return true; },
|
|
registrationStatus: "R",
|
|
};
|
|
}
|
|
setSessionValue(key, value) {
|
|
extensionStorage.set(key, value);
|
|
}
|
|
getSessionValue(key) {
|
|
return extensionStorage.get(key);
|
|
}
|
|
pubKeyEncrypt(nah) {
|
|
console.log("behonest this is not required: " + nah);
|
|
return nah;
|
|
}
|
|
purchasePoints(pointsToBuy, itemId, price, payment, taxes, purchaseInfo, discount) {
|
|
this.setPoints(pointsToBuy);
|
|
return 100;
|
|
}
|
|
getProgress() {
|
|
var downsize = 0;
|
|
if (window._currentstatus === "checkRegistration") {
|
|
downsize = 727;
|
|
} else if (window._currentstatus === "syncRegistration") {
|
|
downsize = 913;
|
|
} else if (window._currentstatus === "checkDeviceStatus") {
|
|
downsize = 846;
|
|
} else if (window._currentstatus === "refreshCachedBalance") {
|
|
downsize = 731;
|
|
} else {
|
|
downsize = 0;
|
|
}
|
|
return {
|
|
"status": 0,
|
|
"operation": window._currentstatus,
|
|
"description": "",
|
|
"phase": 2,
|
|
"isCancelRequested": false,
|
|
"downloadedSize": downsize,
|
|
"totalSize": 0,
|
|
"errCode": 0,
|
|
"errInfo": null
|
|
};
|
|
}
|
|
checkRegistration() {
|
|
window._currentstatus = "checkRegistration";
|
|
return {
|
|
"status": 0,
|
|
"operation": "checkRegistration",
|
|
"description": "",
|
|
"phase": 11,
|
|
"isCancelRequested": false,
|
|
"downloadedSize": 0,
|
|
"totalSize": 0,
|
|
"errCode": 0,
|
|
"errInfo": null
|
|
};
|
|
}
|
|
syncRegistration(value) {
|
|
console.log("idk what to do with this: " + value);
|
|
window._currentstatus = "syncRegistration";
|
|
return {
|
|
"status": 0,
|
|
"operation": "syncRegistration",
|
|
"description": "",
|
|
"phase": 18,
|
|
"isCancelRequested": false,
|
|
"downloadedSize": 0,
|
|
"totalSize": 0,
|
|
"errCode": 0,
|
|
"errInfo": null
|
|
};
|
|
}
|
|
getWeakToken() {
|
|
return "iamaweaktoken";
|
|
}
|
|
getVersion() {
|
|
return parseInt("21");
|
|
}
|
|
request(value) {
|
|
if (value === "checkRegistration") {
|
|
return this.checkRegistration();
|
|
} else if (value === "checkDeviceStatus") {
|
|
return this.checkDeviceStatus();
|
|
} else if (value === "refreshCachedBalance") {
|
|
return this.refreshCachedBalance();
|
|
} else if (value === "getCachedBalance") {
|
|
return this.getCachedBalance();
|
|
}
|
|
}
|
|
}
|
|
|
|
class wiiShop {
|
|
constructor() {
|
|
trace("wiiShop initialized");
|
|
return "isok";
|
|
}
|
|
connecting = null;
|
|
retry() {
|
|
window.location.pathname = "/oss/serv/W_01.jsp";
|
|
}
|
|
endWaiting() {
|
|
console.log("Currently does nothing endwaiting");
|
|
}
|
|
enableHRP() {
|
|
console.log("Does Jack shit homebuttonenabler");
|
|
}
|
|
disableHRP() {
|
|
console.log("Does jack shit home button disabler")
|
|
}
|
|
sleep(duration) {
|
|
return new Promise(resolve => setTimeout(resolve, duration));
|
|
}
|
|
async beginWaiting(seconds) {
|
|
if (seconds == null) {
|
|
seconds = 3;
|
|
}
|
|
if (typeof seconds === 'string') {
|
|
const parsedValue = parseInt(seconds, 10);
|
|
if (isNaN(parsedValue) || parsedValue.toString() !== seconds) {
|
|
console.error("Invalid input: Please provide a valid integer value.");
|
|
return;
|
|
}
|
|
seconds = parsedValue;
|
|
}
|
|
|
|
if (!Number.isInteger(seconds)) {
|
|
console.error("Invalid input: Please provide an integer value.");
|
|
return;
|
|
}
|
|
|
|
let duration;
|
|
|
|
duration = (seconds < 10) ? seconds * 1000 : seconds;
|
|
|
|
await this.sleep(duration);
|
|
console.log("Wait complete!");
|
|
}
|
|
isCompatibleMode() {
|
|
return true;
|
|
}
|
|
launchCode = 0;
|
|
}
|
|
|
|
class wiiSound {
|
|
// These will now be populated by the message listener
|
|
static audioUrls = [];
|
|
static bgmUrl = '';
|
|
static currentBgmAudio = null; // Stays static to manage a single BGM instance
|
|
|
|
constructor() {
|
|
trace("wiiSound initialized");
|
|
// No need to copy _injected variables here, as they'll be populated by the message listener
|
|
}
|
|
|
|
playSE(snd) {
|
|
// Ensure URLs are available before attempting to play
|
|
if (!_wiiShopSoundUrls_ || _wiiShopSoundUrls_.length === 0) {
|
|
console.warn("Audio URLs not yet loaded. Cannot play sound effect.");
|
|
return;
|
|
}
|
|
|
|
const soundIndex = parseInt(snd, 10);
|
|
if (isNaN(soundIndex) || soundIndex < 1 || soundIndex >= _wiiShopSoundUrls_.length) {
|
|
console.warn("Invalid sound index for wiiSound.playSE:", snd);
|
|
return;
|
|
}
|
|
|
|
const audioUrl = _wiiShopSoundUrls_[soundIndex];
|
|
if (!audioUrl) {
|
|
console.warn("No audio URL found for sound index:", soundIndex);
|
|
return;
|
|
}
|
|
|
|
const audio = new Audio(audioUrl);
|
|
audio.style.display = 'none';
|
|
audio.play()
|
|
.then(() => {
|
|
console.log('Wii Shop Sound played:', soundIndex, audioUrl);
|
|
})
|
|
.catch(error => {
|
|
console.error('Error playing Wii Shop Sound:', soundIndex, audioUrl, error);
|
|
});
|
|
}
|
|
|
|
playBGM() {
|
|
// Use an internal flag for _bgmAlreadyPlaying
|
|
if (_bgmAlreadyPlaying === true) {
|
|
return "nah mate, i aint playin for ya, im already playin";
|
|
} else {
|
|
_bgmAlreadyPlaying = true;
|
|
if (wiiSound.currentBgmAudio && !wiiSound.currentBgmAudio.paused) {
|
|
wiiSound.currentBgmAudio.pause();
|
|
wiiSound.currentBgmAudio.currentTime = 0;
|
|
console.log('Stopped previous BGM.');
|
|
}
|
|
|
|
// Ensure BGM URL is available to send via extensionStorage
|
|
if (!_wiiShopBgmUrl_) {
|
|
console.warn("No BGM URL available to send to background script.");
|
|
return;
|
|
}
|
|
|
|
// Use extensionStorage.sendMessageToBackground to control BGM in background
|
|
if (typeof window.extensionStorage !== 'undefined' && typeof window.extensionStorage.sendMessageToBackground === 'function') {
|
|
window.extensionStorage.sendMessageToBackground({
|
|
action: "playBGM",
|
|
bgmUrl: _wiiShopBgmUrl_
|
|
}).then(() => {
|
|
trace('Request to play BGM sent to background script via extensionStorage.');
|
|
}).catch(error => {
|
|
console.error('Error sending playBGM message to background via extensionStorage:', error);
|
|
});
|
|
} else {
|
|
console.warn("window.extensionStorage.sendMessageToBackground not available for playBGM.");
|
|
}
|
|
}
|
|
}
|
|
|
|
stopBGM() {
|
|
// Use an internal flag for _bgmAlreadyPlaying
|
|
if (_bgmAlreadyPlaying === true) {
|
|
_bgmAlreadyPlaying = false; // Reset the flag
|
|
// Send a message to background via extensionStorage to stop BGM
|
|
if (typeof window.extensionStorage !== 'undefined' && typeof window.extensionStorage.sendMessageToBackground === 'function') {
|
|
window.extensionStorage.sendMessageToBackground({
|
|
action: "stopBGM"
|
|
}).then(() => {
|
|
trace('Request to stop BGM sent to background script via extensionStorage.');
|
|
}).catch(error => {
|
|
console.error('Error sending stopBGM message to background via extensionStorage:', error);
|
|
});
|
|
} else {
|
|
console.warn("window.extensionStorage.sendMessageToBackground not available for stopBGM.");
|
|
}
|
|
} else {
|
|
return "wtf do you want me to stop eh?";
|
|
}
|
|
}
|
|
}
|
|
|
|
class wiiKeyboard {
|
|
constructor() {
|
|
trace("wiiKeyboard initialized");
|
|
}
|
|
}
|
|
|
|
class ECCreditCardEncryptedPayment {
|
|
constructor(smth) {
|
|
this.smth = smth;
|
|
}
|
|
}
|
|
|
|
class ECPrice {
|
|
constructor(uhh, ahh) {
|
|
return uhh;
|
|
}
|
|
}
|
|
|
|
class wiiSDCard {
|
|
constructor() {
|
|
return;
|
|
}
|
|
}
|
|
|
|
class wiiNwc24 {
|
|
constructor() {
|
|
return;
|
|
}
|
|
sendable() {
|
|
return true;
|
|
}
|
|
mailErrNo() {
|
|
return null;
|
|
}
|
|
errMsg() {
|
|
return null;
|
|
}
|
|
getFriendNum() {
|
|
return 5;
|
|
}
|
|
getFriendInfo(fnm, data) {
|
|
if (typeof fnm === 'string') {
|
|
const parsedValue = parseInt(fnm, 10);
|
|
if (isNaN(parsedValue) || parsedValue.toString() !== fnm) {
|
|
console.error("Invalid input: Please provide a valid integer value.");
|
|
return;
|
|
}
|
|
fnm = parsedValue;
|
|
}
|
|
if (data == "name") {
|
|
if (fnm == 0) {
|
|
return "User1";
|
|
} else if (fnm == 1) {
|
|
return "User2";
|
|
} else if (fnm == 2) {
|
|
return "User3";
|
|
} else if (fnm == 3) {
|
|
return "User4";
|
|
} else if (fnm == 4) {
|
|
return "User5";
|
|
}
|
|
}
|
|
if (data == "userId") {
|
|
if (fnm == 0) {
|
|
return "3630753603591712";
|
|
} else if (fnm == 1) {
|
|
return "3630753603591712";
|
|
} else if (fnm == 2) {
|
|
return "3630753603591712";
|
|
} else if (fnm == 3) {
|
|
return "3630753603591712";
|
|
} else if (fnm == 4) {
|
|
return "3630753603591712";
|
|
}
|
|
}
|
|
if (data == "miiImage") {
|
|
return "111"
|
|
}
|
|
}
|
|
myUserId = "0302167078436756";
|
|
}
|
|
class wiiDlTask {
|
|
constructor() {
|
|
trace("WiiDlTask init");
|
|
}
|
|
addDownloadTask(url, interval){
|
|
trace("yes i got it dw i will download it :tro:");
|
|
}
|
|
}
|
|
class wiiMii {
|
|
constructor() {
|
|
trace("wiiMii init");
|
|
}
|
|
}
|
|
window.ECommerceInterface = ECommerceInterface;
|
|
window.ECCreditCardEncryptedPayment = ECCreditCardEncryptedPayment;
|
|
window.ECPrice = ECPrice;
|
|
window.wiiKeyboard = wiiKeyboard;
|
|
window.wiiShop = wiiShop;
|
|
window.wiiSound = wiiSound;
|
|
window.wiiMii = wiiMii;
|
|
window.wiiDlTask = wiiDlTask;
|
|
window.wiiNwc24 = wiiNwc24;
|
|
window.wiiSDCard = wiiSDCard;
|
|
|
|
if (_bgmInitiallyEnabled) {
|
|
// Use a short delay or an event listener to ensure all page elements are ready
|
|
// and to potentially work around immediate autoplay blocks (though not guaranteed).
|
|
document.addEventListener('DOMContentLoaded', () => {
|
|
if (window.wiiSound) {
|
|
const soundInstance = new window.wiiSound();
|
|
soundInstance.playBGM();
|
|
}
|
|
});
|
|
} |