avscs
1177 lines
30 KiB
JavaScript
1177 lines
30 KiB
JavaScript
window.addEventListener("beforeunload", function (e) {
|
|
console.log("skibidi");
|
|
e.preventDefault();
|
|
});
|
|
|
|
var isMobile = false;
|
|
var postRunDone = false;
|
|
var gameGuid = null;
|
|
var gameStarted = false;
|
|
var startupTimeStr = "";
|
|
var firebaseApp = null;
|
|
var firebaseStorage = null;
|
|
var singleGameBlob = null;
|
|
var singleGameReadCounts = false;
|
|
var singleGameReadLedger = false;
|
|
var loadProgressFrac = 0;
|
|
var gameDownloadProgressFrac = 0;
|
|
var portraitStretch = false;
|
|
var prerollDone = true;
|
|
window.addEventListener("DOMContentLoaded", domContentLoaded);
|
|
window.addEventListener("load", function () {
|
|
let guid = getGameGuidString();
|
|
if (guid != "") {
|
|
downloadLinkedGame(guid);
|
|
}
|
|
if (inIframe()) {
|
|
document.addEventListener("click", (ev) => {
|
|
let canvas = document.getElementById("canvas");
|
|
if (canvas) {
|
|
canvas.focus();
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
function inIframe() {
|
|
try {
|
|
return window.self !== window.top;
|
|
} catch (e) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
function updateLoadProgress() {
|
|
let guid = getGameGuidString();
|
|
let progressMaxValue = guid == "" ? 100 : 200;
|
|
let progressElement = document.getElementById("progress");
|
|
if (progressElement) {
|
|
progressElement.value = Math.round(
|
|
(loadProgressFrac + gameDownloadProgressFrac) * 100,
|
|
);
|
|
progressElement.max = progressMaxValue;
|
|
}
|
|
if (loadProgressFrac >= 1 && (guid == "" || gameDownloadProgressFrac >= 1)) {
|
|
console.log("Loading done");
|
|
showPlayButton();
|
|
}
|
|
}
|
|
|
|
function downloadLinkedGame(guid) {
|
|
// let sref = firebaseStorage.ref(`games/${guid}`);
|
|
const fakeProgress = function () {
|
|
if (gameDownloadProgressFrac < 1) {
|
|
gameDownloadProgressFrac += 0.1;
|
|
if (gameDownloadProgressFrac > 0.95) {
|
|
gameDownloadProgressFrac = 0.95;
|
|
} else {
|
|
setTimeout(fakeProgress, 200);
|
|
}
|
|
updateLoadProgress();
|
|
}
|
|
};
|
|
fakeProgress();
|
|
// sref.getDownloadURL().then((url) => {
|
|
var url = `./${getMeta("fancade:guid")}`;
|
|
simpleLogC("Got download url " + url);
|
|
let xhr = new XMLHttpRequest();
|
|
xhr.responseType = "blob";
|
|
xhr.onload = (event) => {
|
|
let blob = xhr.response;
|
|
singleGameBlob = blob;
|
|
gameDownloadProgressFrac = 1;
|
|
updateLoadProgress();
|
|
};
|
|
xhr.onerror = function () {
|
|
simpleLogC("Unable to download file, XMLHttpRequest error");
|
|
showLoadError("Unable to load game");
|
|
};
|
|
xhr.open("GET", url);
|
|
xhr.send();
|
|
}
|
|
|
|
var showPlayButtonAttempts = 0;
|
|
|
|
function showPlayButton() {
|
|
checkStartGame();
|
|
}
|
|
|
|
function domContentLoaded() {
|
|
let canvas = document.getElementById("canvas");
|
|
canvas.addEventListener("contextmenu", stopContextMenu);
|
|
if (!postRunDone) {
|
|
resizeCanvas(false);
|
|
}
|
|
let vanityUrl = getMeta("fancade:vanity_url");
|
|
if (vanityUrl.length > 0) {
|
|
history.replaceState({}, "", vanityUrl);
|
|
}
|
|
window.addEventListener("blur", (ev) => setGameFocus(false));
|
|
window.addEventListener("focus", (ev) => setGameFocus(true));
|
|
canvas.onpointerdown = beginPointerDrag;
|
|
canvas.onpointerup = endPointerDrag;
|
|
}
|
|
|
|
function beginPointerDrag(e) {
|
|
let canvas = document.getElementById("canvas");
|
|
canvas.setPointerCapture(e.pointerId);
|
|
}
|
|
|
|
function endPointerDrag(e) {
|
|
let canvas = document.getElementById("canvas");
|
|
canvas.releasePointerCapture(e.pointerId);
|
|
}
|
|
|
|
function setGameFocus(f) {
|
|
if (postRunDone) {
|
|
Module.ccall("set_game_focus", "v", ["number"], [f]);
|
|
}
|
|
}
|
|
|
|
function canBeGameGuid(str) {
|
|
return str && str.match("([A-F]|[0-9]){16}");
|
|
}
|
|
|
|
function getGameGuidString() {
|
|
if (gameGuid != null) {
|
|
return gameGuid;
|
|
}
|
|
gameGuid = "";
|
|
let str = window.location.href;
|
|
if (str) {
|
|
for (let i = 0; i <= str.length - 16; i++) {
|
|
let subStr = str.substr(i, 16);
|
|
if (canBeGameGuid(subStr)) {
|
|
gameGuid = subStr;
|
|
}
|
|
}
|
|
}
|
|
if (gameGuid == "") {
|
|
str = getMeta("fancade:guid");
|
|
if (canBeGameGuid(str)) {
|
|
gameGuid = str;
|
|
}
|
|
}
|
|
if (gameGuid == "") {
|
|
str = parseUrlArgument("override_guid");
|
|
if (canBeGameGuid(str)) {
|
|
gameGuid = str;
|
|
}
|
|
}
|
|
return gameGuid;
|
|
}
|
|
|
|
function getMeta(metaName) {
|
|
const metas = document.getElementsByTagName("meta");
|
|
for (let i = 0; i < metas.length; i++) {
|
|
if (metas[i].getAttribute("name") === metaName) {
|
|
return metas[i].getAttribute("content");
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
|
|
function getCSSRgb(color) {
|
|
return `rgb(${Math.round(color[0])}, ${Math.round(color[1])}, ${Math.round(color[2])})`;
|
|
}
|
|
|
|
let lastGradientStyleStr = "";
|
|
let lastDeepLinkLoadFraction = 0;
|
|
|
|
function getGradientStr(frac) {
|
|
let fromColor = [frac * 0x70, frac * 0xe1, frac * 0xfd];
|
|
let toColor = [frac * 0x00, frac * 0xa2, frac * 0xff];
|
|
let str = `linear-gradient(135deg, ${getCSSRgb(fromColor)}, ${getCSSRgb(toColor)})`;
|
|
return str;
|
|
}
|
|
|
|
function setDeepLinkLoadingFraction(frac) {
|
|
let gradient = document.getElementById("gradient");
|
|
let str = getGradientStr(frac);
|
|
if (lastGradientStyleStr != str) {
|
|
lastGradientStyleStr = str;
|
|
gradient.style.backgroundImage = str;
|
|
}
|
|
lastDeepLinkLoadFraction = frac;
|
|
}
|
|
|
|
function hideOverlayGradient() {
|
|
var gradient = document.getElementById("gradient");
|
|
gradient.style.display = "none";
|
|
}
|
|
|
|
var showedStartGameError = false;
|
|
|
|
function checkStartGame() {
|
|
console.log("Checking if the game should start...");
|
|
try {
|
|
if (prerollDone) {
|
|
console.log("Preroll done, hiding overlay");
|
|
var playContent = document.getElementById("play_content");
|
|
playContent.style.display = "none";
|
|
let guid = getGameGuidString();
|
|
if (guid == "") {
|
|
hideOverlayGradient();
|
|
} else {
|
|
setDeepLinkLoadingFraction(0.0);
|
|
}
|
|
window.addEventListener("beforeunload", function (event) {
|
|
Module.ccall("app_terminate_if_necessary", "v");
|
|
});
|
|
window.addEventListener("unload", function (event) {
|
|
Module.ccall("app_terminate_if_necessary", "v");
|
|
});
|
|
document.addEventListener("visibilitychange", function () {
|
|
if (document.visibilityState === "visible") {
|
|
Module.ccall("app_resume", "v");
|
|
} else {
|
|
Module.ccall("app_pause", "v");
|
|
}
|
|
});
|
|
Module.ccall("user_accepted_and_clicked", "v");
|
|
gameStarted = true;
|
|
setTimeout(updateStretchButton, 3000);
|
|
try {
|
|
localStorage.setItem("accepted-pp", "yes");
|
|
} catch (err3) {}
|
|
}
|
|
} catch (err) {
|
|
if (!showedStartGameError) {
|
|
let foundModuleAsm = false;
|
|
let additionalInfo = "";
|
|
try {
|
|
if (Module["asm"]) {
|
|
foundModuleAsm = true;
|
|
}
|
|
} catch (err2) {}
|
|
if (!foundModuleAsm) {
|
|
additionalInfo += "Could not find Module.asm";
|
|
}
|
|
// alert(`Error when starting game. Try to reload the page. Error message: ${err}. ${additionalInfo}`);
|
|
showedStartGameError = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
function simpleLogC(str) {
|
|
if (postRunDone) {
|
|
Module.ccall("log_simple", "v", ["string"], [str]);
|
|
} else {
|
|
console.log(str);
|
|
}
|
|
}
|
|
|
|
function appErrorC(code, str) {
|
|
if (postRunDone) {
|
|
Module.ccall("app_error", "v", ["number", "string"], [code, str]);
|
|
} else {
|
|
console.error(str, code);
|
|
}
|
|
}
|
|
|
|
function simpleAppErrorC(str) {
|
|
appErrorC(1, str);
|
|
}
|
|
|
|
function parseUrlArgument(name) {
|
|
let result = "";
|
|
let str = window.location.search;
|
|
if (str.length > 0 && str[0] == "?") {
|
|
var arr = str.substr(1).split("&");
|
|
for (let i = 0; i < arr.length; i++) {
|
|
if (arr[i].startsWith(name + "=")) {
|
|
result = arr[i].substr(name.length + 1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function parseUrlArgumentInt(name) {
|
|
let str = parseUrlArgument(name);
|
|
let parsed = parseInt(str);
|
|
if (isNaN(parsed)) {
|
|
return 0;
|
|
} else {
|
|
return parsed;
|
|
}
|
|
}
|
|
|
|
function getStartInEditMode() {
|
|
return parseUrlArgumentInt("edit");
|
|
}
|
|
|
|
function getUrlLevelIndex() {
|
|
let path = window.location.pathname.substr(1);
|
|
let slashIndex = path.indexOf("/");
|
|
if (slashIndex >= 0 && path.length > slashIndex + 1) {
|
|
let levelIndexStr = path.substring(slashIndex + 1);
|
|
let slashIndex2 = levelIndexStr.indexOf("/");
|
|
if (slashIndex2 >= 0) {
|
|
levelIndexStr = levelIndexStr.substring(0, slashIndex2);
|
|
}
|
|
let levelIndex = parseInt(levelIndexStr);
|
|
if (!isNaN(levelIndex)) {
|
|
return levelIndex - 1;
|
|
}
|
|
}
|
|
let level = parseUrlArgumentInt("lv");
|
|
if (level > 0) {
|
|
return level - 1;
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
function resizeCanvas(informC) {
|
|
let fullscreen = !!document.fullscreenElement;
|
|
let iw = window.innerWidth;
|
|
let ih = window.innerHeight;
|
|
let canvas = document.getElementById("canvas");
|
|
let border = document.getElementById("canvas_border");
|
|
let maxW = parseUrlArgumentInt("max_w");
|
|
let maxH = parseUrlArgumentInt("max_h");
|
|
let aspectRatioW = parseUrlArgumentInt("ar_w");
|
|
let aspectRatioH = parseUrlArgumentInt("ar_h");
|
|
let targetW = maxW;
|
|
let targetH = maxH;
|
|
let forceWidth = false;
|
|
let forceHeight = false;
|
|
let forceAr = false;
|
|
if (stretchMode || fullscreen) {
|
|
targetW = iw;
|
|
targetH = ih;
|
|
} else {
|
|
if (targetW <= 0) {
|
|
targetW = 1024;
|
|
} else {
|
|
forceWidth = true;
|
|
}
|
|
if (targetH <= 0) {
|
|
targetH = 768;
|
|
} else {
|
|
forceHeight = true;
|
|
}
|
|
if (aspectRatioW < 0.01) {
|
|
aspectRatioW = 16.0;
|
|
} else {
|
|
forceAr = true;
|
|
}
|
|
if (aspectRatioH < 0.01) {
|
|
aspectRatioH = 9.0;
|
|
} else {
|
|
forceAr = true;
|
|
}
|
|
let ar = aspectRatioH / aspectRatioW;
|
|
let fitWithinLimits = function () {
|
|
targetW = Math.min(targetW, iw);
|
|
if (forceWidth) {
|
|
targetW = Math.min(maxW, targetW);
|
|
}
|
|
targetH = Math.min(targetH, ih);
|
|
if (forceHeight) {
|
|
targetH = Math.min(maxH, targetH);
|
|
}
|
|
};
|
|
let enforceAr = function () {
|
|
if (forceAr) {
|
|
if (forceWidth) {
|
|
targetH = targetW * ar;
|
|
if (targetH > ih) {
|
|
targetH = ih;
|
|
targetW = targetH / ar;
|
|
}
|
|
} else if (forceHeight) {
|
|
targetW = targetH / ar;
|
|
if (targetW > iw) {
|
|
targetW = iw;
|
|
targetH = targetW * ar;
|
|
}
|
|
} else {
|
|
targetH = ih;
|
|
targetW = targetH / ar;
|
|
if (targetW > iw) {
|
|
targetW = iw;
|
|
targetH = targetW * ar;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
fitWithinLimits();
|
|
enforceAr();
|
|
}
|
|
let styleW = targetW;
|
|
let styleH = targetH;
|
|
if (iw < targetW || ih < targetH) {
|
|
styleW = Math.min(iw, targetW);
|
|
styleH = Math.min(ih, targetH);
|
|
}
|
|
// let bottom = document.getElementById("bottom_content");
|
|
// let bottom_text = document.getElementById("bottom_text");
|
|
let styleMarginTop = 0;
|
|
let spaceLeftW = iw - styleW;
|
|
let spaceLeftH = ih - styleH;
|
|
let threshold1 = 90;
|
|
let threshold2 = 150;
|
|
portraitStretch = false;
|
|
if (!forceAr && !forceHeight && !forceWidth && ih > iw) {
|
|
if (spaceLeftH <= threshold1) {
|
|
styleH = ih;
|
|
spaceLeftH = 0;
|
|
portraitStretch = true;
|
|
} else if (spaceLeftH > threshold2) {
|
|
spaceLeftH = threshold2 + 1;
|
|
styleH = ih - spaceLeftH;
|
|
}
|
|
}
|
|
canvas.width = styleW * window.devicePixelRatio;
|
|
canvas.height = styleH * window.devicePixelRatio;
|
|
border.style.marginTop = styleMarginTop + "px";
|
|
let gradient = document.getElementById("gradient");
|
|
let webViewContent = document.getElementById("webview_content");
|
|
[gradient, webViewContent].forEach((e) => {
|
|
if (e) {
|
|
e.style.left = (iw - styleW) * 0.5 + "px";
|
|
}
|
|
});
|
|
[canvas, gradient, webViewContent].forEach((e) => {
|
|
if (e) {
|
|
e.style.width = styleW + "px";
|
|
e.style.height = styleH + "px";
|
|
e.style.borderRadius = (spaceLeftW > 0 && spaceLeftH > 0 ? 20 : 0) + "px";
|
|
}
|
|
});
|
|
if (gameStarted) {
|
|
updateStretchButton();
|
|
}
|
|
if (informC) {
|
|
Module.ccall(
|
|
"update_screen_size",
|
|
"v",
|
|
["number", "number", "number"],
|
|
[canvas.width, canvas.height, window.devicePixelRatio],
|
|
);
|
|
}
|
|
}
|
|
|
|
function updateStretchButton() {}
|
|
|
|
function stopContextMenu(event) {
|
|
event.preventDefault();
|
|
return false;
|
|
}
|
|
|
|
var Module = {
|
|
locateFile: function (path, prefix) {
|
|
if (prefix == "") {
|
|
return cndHref + path;
|
|
}
|
|
return prefix + path;
|
|
},
|
|
preRun: [
|
|
function () {
|
|
isMobile = window.matchMedia(
|
|
"only screen and (max-width: 760px)",
|
|
).matches;
|
|
},
|
|
],
|
|
postRun: [
|
|
function () {
|
|
document.onfullscreenchange = function () {
|
|
setTimeout(function () {
|
|
resizeCanvas(true);
|
|
if (document.fullscreenElement) {
|
|
let canvas = document.getElementById("canvas");
|
|
simpleLogC("Canvas size " + canvas.width + " x " + canvas.height);
|
|
Module.ccall(
|
|
"update_screen_size",
|
|
"v",
|
|
["number", "number", "number"],
|
|
[canvas.width, canvas.height, 1],
|
|
);
|
|
}
|
|
}, 500);
|
|
};
|
|
window.addEventListener("resize", (event) => resizeCanvas(true), false);
|
|
resizeCanvas(true);
|
|
window.addEventListener("keydown", (e) => {
|
|
ccall("keydown_browser", "v", ["string"], [e.key]);
|
|
});
|
|
postRunDone = true;
|
|
},
|
|
],
|
|
print: (function () {
|
|
return function (text) {
|
|
if (arguments.length > 1)
|
|
text = Array.prototype.slice.call(arguments).join(" ");
|
|
console.log(text);
|
|
};
|
|
})(),
|
|
printErr: function (text) {
|
|
if (arguments.length > 1)
|
|
text = Array.prototype.slice.call(arguments).join(" ");
|
|
// console.error(text);
|
|
},
|
|
canvas: (function () {
|
|
var canvas = document.getElementById("canvas");
|
|
canvas.addEventListener(
|
|
"webglcontextlost",
|
|
function (e) {
|
|
e.preventDefault();
|
|
Module.ccall("app_set_opengl_context_lost", "v", ["number"], [1]);
|
|
},
|
|
false,
|
|
);
|
|
canvas.addEventListener(
|
|
"webglcontextrestored",
|
|
function (event) {
|
|
Module.ccall("opengl_resume", "v");
|
|
},
|
|
false,
|
|
);
|
|
return canvas;
|
|
})(),
|
|
setStatus: function (text) {
|
|
if (!Module.setStatus.last)
|
|
Module.setStatus.last = { time: Date.now(), text: "" };
|
|
if (text === Module.setStatus.last.text) return;
|
|
var m = text.match(/([^(]+)\((\d+(\.\d+)?)\/(\d+)\)/);
|
|
var now = Date.now();
|
|
if (m && now - Module.setStatus.last.time < 30) return;
|
|
Module.setStatus.last.time = now;
|
|
Module.setStatus.last.text = text;
|
|
if (m) {
|
|
text = m[1];
|
|
loadProgressFrac = parseInt(m[2]) / parseInt(m[4]);
|
|
} else {
|
|
loadProgressFrac = 1;
|
|
}
|
|
updateLoadProgress();
|
|
},
|
|
totalDependencies: 0,
|
|
monitorRunDependencies: function (left) {
|
|
this.totalDependencies = Math.max(this.totalDependencies, left);
|
|
},
|
|
};
|
|
|
|
function showLoadError(message) {
|
|
var parent = document.getElementById("progress_or_play");
|
|
if (parent) {
|
|
let appUrl = "fancade://" + getGameGuidString();
|
|
parent.innerHTML = `<p><span class='error_message' >${message}</span></p><p><a href="${appUrl}" >Open App</p>`;
|
|
}
|
|
}
|
|
|
|
function _0x1ceb() {
|
|
const _0x5f25ad = [
|
|
"2000305oVxWyY",
|
|
"686700tkWHPR",
|
|
"ve.firebas",
|
|
"0ce9326294",
|
|
"1050172fKCxPn",
|
|
"authDomain",
|
|
"play.fanca",
|
|
"8SmfUBU",
|
|
"4111296606",
|
|
"26959uKbAvx",
|
|
".firebasei",
|
|
"log",
|
|
"4671756ELFxwd",
|
|
"apiKey",
|
|
"AIzaSyCRF7",
|
|
"10451kBRaIk",
|
|
"ted",
|
|
"databaseUR",
|
|
"6CaPmCM",
|
|
"1:41112966",
|
|
"Init\x20fireb",
|
|
"eapp.com",
|
|
"de.com",
|
|
"fancade-te",
|
|
"initialize",
|
|
"ket",
|
|
"hostname",
|
|
"storageBuc",
|
|
"1040RObBZp",
|
|
"Firebase\x20a",
|
|
"4962500TLledR",
|
|
"ase\x20basic",
|
|
"1:48916779",
|
|
"CkDJK04eg9",
|
|
"70b8b73550",
|
|
"AIzaSyCHBB",
|
|
"lready\x20ini",
|
|
"projectId",
|
|
"d20cSQ3tta",
|
|
"tTP1ujjZB5",
|
|
"measuremen",
|
|
"location",
|
|
"vCCgA0kP0",
|
|
"G-PLPTPCSG",
|
|
"fancade-li",
|
|
"0603:web:4",
|
|
"enderId",
|
|
"st.firebas",
|
|
"startsWith",
|
|
"e486f96159",
|
|
"App",
|
|
"st.appspot",
|
|
"messagingS",
|
|
"ncade-test",
|
|
"7261:web:d",
|
|
"9gmY_zlPE",
|
|
"tId",
|
|
"est",
|
|
"storage",
|
|
"ScBil1Xrzq",
|
|
"78bcd94429",
|
|
"o.com",
|
|
"appId",
|
|
"ve.appspot",
|
|
"4891677972",
|
|
".com",
|
|
"firebase_t",
|
|
"ncade-live",
|
|
"https://fa",
|
|
];
|
|
_0x1ceb = function () {
|
|
return _0x5f25ad;
|
|
};
|
|
return _0x1ceb();
|
|
}
|
|
|
|
(function (_0x3a211d, _0x2d1f99) {
|
|
const _0x55d3c4 = _0xb104,
|
|
_0x4e66f6 = _0x3a211d();
|
|
while (!![]) {
|
|
try {
|
|
const _0xa7ed29 =
|
|
(parseInt(_0x55d3c4(0x20f)) / 0x1) *
|
|
(parseInt(_0x55d3c4(0x20d)) / 0x2) +
|
|
parseInt(_0x55d3c4(0x207)) / 0x3 +
|
|
parseInt(_0x55d3c4(0x20a)) / 0x4 +
|
|
(parseInt(_0x55d3c4(0x206)) / 0x5) *
|
|
(-parseInt(_0x55d3c4(0x1d3)) / 0x6) +
|
|
(-parseInt(_0x55d3c4(0x1d0)) / 0x7) *
|
|
(-parseInt(_0x55d3c4(0x1dd)) / 0x8) +
|
|
-parseInt(_0x55d3c4(0x212)) / 0x9 +
|
|
parseInt(_0x55d3c4(0x1df)) / 0xa;
|
|
if (_0xa7ed29 === _0x2d1f99) break;
|
|
else _0x4e66f6["push"](_0x4e66f6["shift"]());
|
|
} catch (_0x270315) {
|
|
_0x4e66f6["push"](_0x4e66f6["shift"]());
|
|
}
|
|
}
|
|
})(_0x1ceb, 0x5a72a);
|
|
|
|
function _0xb104(_0x3f408f, _0x150f92) {
|
|
const _0x1ceb20 = _0x1ceb();
|
|
return (
|
|
(_0xb104 = function (_0xb104a3, _0x57e5c1) {
|
|
_0xb104a3 = _0xb104a3 - 0x1d0;
|
|
let _0x32c9c2 = _0x1ceb20[_0xb104a3];
|
|
return _0x32c9c2;
|
|
}),
|
|
_0xb104(_0x3f408f, _0x150f92)
|
|
);
|
|
}
|
|
|
|
var rewardedShowFunc = null;
|
|
var calledRewardedShow = false;
|
|
var notifications = [];
|
|
var webViewIframe = null;
|
|
var storedScripts = [];
|
|
var webviewDomLoaded = false;
|
|
var fsSyncStatus = "";
|
|
|
|
function postStored() {
|
|
for (var i = 0; i < storedScripts.length; i++) {
|
|
webViewIframe.contentWindow.postMessage("eval:" + storedScripts[i], "*");
|
|
}
|
|
storedScripts = [];
|
|
}
|
|
|
|
function onWebviewDomContentLoaded() {
|
|
webviewDomLoaded = true;
|
|
postStored();
|
|
}
|
|
|
|
function webViewPostMessage(message) {
|
|
Module.ccall("app_webview_message", "v", ["string"], [message]);
|
|
}
|
|
|
|
function webViewError(type, message) {
|
|
webViewPostMessage(`error|${type}|${message}`);
|
|
}
|
|
|
|
// 鍏抽棴闈瀋anvas鐨勪俊鎭紝濡傚叧鍗�
|
|
function webViewClose() {
|
|
try {
|
|
var content = document.getElementById("webview_content");
|
|
content.style.display = "none";
|
|
if (content.contains(webViewIframe)) {
|
|
webviewDomLoaded = false;
|
|
webViewIframe.contentWindow.removeEventListener(
|
|
"DOMContentLoaded",
|
|
onWebviewDomContentLoaded,
|
|
);
|
|
content.removeChild(webViewIframe);
|
|
}
|
|
setTimeout(function () {
|
|
Module.ccall("set_game_focus", "v", ["number"], [true]);
|
|
}, 100);
|
|
} catch (err) {
|
|
webViewError("unknown", err);
|
|
}
|
|
}
|
|
|
|
// 灞曠ず闈瀋anvas鐨勪俊鎭紝濡傚叧鍗�
|
|
function webViewOpen(path) {
|
|
try {
|
|
let arr = readLocalFile(path);
|
|
let html = new TextDecoder("utf-8").decode(arr);
|
|
html = html.replace(
|
|
'url("/webapp/baloo2.woff")',
|
|
`url("${cndHref}baloo2.woff")`,
|
|
);
|
|
html = html.replace("common.js", "");
|
|
html = html.replace("common.css", "");
|
|
if (webViewIframe == null) {
|
|
window.onmessage = function (e) {
|
|
webViewPostMessage(e.data);
|
|
};
|
|
}
|
|
var content = document.getElementById("webview_content");
|
|
content.style.display = "block";
|
|
webViewIframe = document.createElement("iframe");
|
|
webViewIframe.classList.add("webview");
|
|
webViewIframe.allowtransparency = true;
|
|
content.appendChild(webViewIframe);
|
|
webViewIframe.contentWindow.document.open();
|
|
webviewDomLoaded = false;
|
|
webViewIframe.contentWindow.addEventListener(
|
|
"DOMContentLoaded",
|
|
onWebviewDomContentLoaded,
|
|
);
|
|
webViewIframe.contentWindow.document.write(html);
|
|
webViewIframe.contentWindow.document.close();
|
|
} catch (err) {
|
|
webViewError("unknown", err);
|
|
}
|
|
}
|
|
function webViewExecuteJS(jsString) {
|
|
try {
|
|
if (!webviewDomLoaded) {
|
|
storedScripts.push(jsString);
|
|
} else {
|
|
webViewIframe.contentWindow.postMessage("eval:" + jsString, "*");
|
|
}
|
|
} catch (err) {
|
|
webViewError("unknown", err);
|
|
}
|
|
}
|
|
|
|
function getHostname() {
|
|
let hostname = window.location.hostname.split(":")[0];
|
|
let lengthBytes = lengthBytesUTF8(hostname) + 1;
|
|
let stringOnWasmHeap = _malloc(lengthBytes);
|
|
stringToUTF8(hostname, stringOnWasmHeap, lengthBytes);
|
|
return stringOnWasmHeap;
|
|
}
|
|
|
|
function getGameGuidArgument() {
|
|
let guid = getGameGuidString();
|
|
let lengthBytes = lengthBytesUTF8(guid) + 1;
|
|
let stringOnWasmHeap = _malloc(lengthBytes);
|
|
stringToUTF8(guid, stringOnWasmHeap, lengthBytes);
|
|
return stringOnWasmHeap;
|
|
}
|
|
|
|
function writeLocalFile(buffer, pathDevice) {
|
|
let arr = new Uint8Array(buffer);
|
|
let stream = FS.open(pathDevice, "w");
|
|
FS.write(stream, arr, 0, arr.length, 0);
|
|
FS.close(stream);
|
|
}
|
|
|
|
function readLocalFile(path) {
|
|
let stream = FS.open(path, "r");
|
|
FS.llseek(stream, 0, 2);
|
|
let fileSize = stream.position;
|
|
FS.llseek(stream, 0, 0);
|
|
let buf = new Uint8Array(fileSize);
|
|
FS.read(stream, buf, 0, fileSize, 0);
|
|
FS.close(stream);
|
|
return buf;
|
|
}
|
|
|
|
function downloadFileInBrowser(path) {
|
|
if (path) {
|
|
let buf = readLocalFile(path);
|
|
let blob = new Blob([buf.buffer], { type: "application/octet-stream" });
|
|
let fileUrl = URL.createObjectURL(blob);
|
|
var pom = document.createElement("a");
|
|
pom.href = fileUrl;
|
|
let filename = "game";
|
|
let index = path.lastIndexOf("/");
|
|
if (index >= 0) {
|
|
filename = path.substr(index + 1);
|
|
}
|
|
pom.setAttribute("download", filename);
|
|
if (document.createEvent) {
|
|
var event = document.createEvent("MouseEvents");
|
|
event.initEvent("click", true, true);
|
|
pom.dispatchEvent(event);
|
|
} else {
|
|
pom.click();
|
|
}
|
|
}
|
|
}
|
|
|
|
function fetchUrl(url, id, useToken) {}
|
|
|
|
function adInit() {}
|
|
|
|
function firebasePause() {}
|
|
|
|
function firebaseResume() {}
|
|
|
|
function adInterstitialLoad() {
|
|
Module.ccall("ad_interstitial_on_loaded", "v", ["number"], [1]);
|
|
}
|
|
|
|
function adInterstitialShow() {
|
|
console.log("adInterstitialShow");
|
|
window.GameBridgeSDK.commercialBreak().then((done) => {
|
|
setGameFocus(true);
|
|
Module.ccall("ad_interstitial_on_showed", "v", ["number"], [1]);
|
|
});
|
|
}
|
|
|
|
function adRewardedLoad() {
|
|
simpleLogC("adRewardedLoad()");
|
|
calledRewardedShow = false;
|
|
window.GameBridgeSDK.rewardedBreak().then((done) => {
|
|
setGameFocus(true);
|
|
rewardedShowFunc = null;
|
|
calledRewardedShow = false;
|
|
if (done) {
|
|
Module.ccall("ad_rewarded_on_loaded", "v", ["number"], [1]);
|
|
} else {
|
|
Module.ccall("ad_rewarded_on_showed", "v", ["number"], [0]);
|
|
}
|
|
});
|
|
}
|
|
|
|
// 鍒嗕韩鏂规硶
|
|
function showShareFileModal() {
|
|
Module.ccall("share_file_finished", "v", ["number"], [1]);
|
|
}
|
|
|
|
// 杩斿洖鏂规硶
|
|
function showStoreLinkModal(
|
|
text,
|
|
callbackId,
|
|
showAppStoreButtons,
|
|
showExitButtons,
|
|
) {
|
|
console.log("showStoreLinkModal====", this);
|
|
}
|
|
function adRewardedShow() {
|
|
if (rewardedShowFunc != null) {
|
|
calledRewardedShow = true;
|
|
rewardedShowFunc();
|
|
} else {
|
|
Module.ccall("ad_rewarded_on_showed", "v", ["number"], [0]);
|
|
}
|
|
}
|
|
|
|
function firebaseDeinit() {}
|
|
|
|
function firebaseRemoteConfigFetch() {
|
|
Module.ccall("set_ad_freq", "v", ["number"], [0]);
|
|
//Module.ccall("set_ad_duration_offline", "v", ["number"], [0]);
|
|
}
|
|
|
|
function getServerTimeSeconds() {
|
|
const xhr = new XMLHttpRequest();
|
|
xhr.onload = (event) => {
|
|
let timeStr = xhr.getResponseHeader("Date");
|
|
let date = new Date(timeStr);
|
|
let timezoneDiff = new Date(1970, 0, 1).getTime();
|
|
let millis = date.getTime() - timezoneDiff;
|
|
Module.ccall("ntp_set_server_time", "v", ["number"], [millis / 1000]);
|
|
};
|
|
xhr.onerror = function () {
|
|
simpleLogC("Error when fetching server time");
|
|
};
|
|
xhr.open("GET", "/");
|
|
xhr.setRequestHeader("Content-Type", "text/html");
|
|
xhr.send("");
|
|
}
|
|
|
|
function firebaseWriteNick(nick, name) {}
|
|
|
|
function firebaseReadGems() {}
|
|
|
|
function firebaseWriteGems(gems) {}
|
|
|
|
function firebaseWriteBuys(guid, timeStr, gems) {}
|
|
|
|
let dailyRewardInProgress = false;
|
|
let dailyRewardGems = 0;
|
|
let checkedDailyRewardPossibleTime = 0;
|
|
let dailyRewardPossible = false;
|
|
|
|
function writeDailyReward(gems) {
|
|
if (!dailyRewardPossible) {
|
|
return;
|
|
}
|
|
dailyRewardGems = gems;
|
|
if (dailyRewardInProgress) {
|
|
return;
|
|
}
|
|
dailyRewardInProgress = true;
|
|
}
|
|
|
|
function firebaseReadVersion(guid) {}
|
|
|
|
function firebaseUpload(
|
|
pathImage,
|
|
pathGame,
|
|
guid,
|
|
title,
|
|
description,
|
|
seconds,
|
|
storagePrefix,
|
|
) {}
|
|
|
|
function firebaseReadGame(hi, guid) {}
|
|
|
|
function firebaseReadCounts(hi, guid, incPlay) {
|
|
if (guid == getGameGuidString()) {
|
|
singleGameReadCounts = true;
|
|
}
|
|
}
|
|
|
|
function firebaseReadLedger(hi, guid) {
|
|
if (guid == getGameGuidString()) {
|
|
singleGameReadLedger = true;
|
|
}
|
|
}
|
|
|
|
function firebaseWriteLedger(guid, action, remove, seconds) {}
|
|
|
|
function firebaseSendBugReport(pathLocal, filename) {}
|
|
|
|
function firebaseSyncUpload(pathLocal) {}
|
|
|
|
function firebaseSyncDownload(pathLocal) {}
|
|
|
|
function firebaseUpdateScores(guid, li, score, lowerIsBetter) {}
|
|
|
|
function firebaseSendPasswordResetEmail(email) {
|
|
firebaseAuth.sendPasswordResetEmail(email).then(
|
|
(result) => {
|
|
Module.ccall("menu_on_password_reset_email_sent", "v");
|
|
},
|
|
(error) => {
|
|
simpleLogC("Reset password fail " + error.message);
|
|
simpleAppErrorC(error.message);
|
|
},
|
|
);
|
|
}
|
|
|
|
function firebaseSignout() {
|
|
firebaseAuth.signOut();
|
|
}
|
|
|
|
function firebaseSignedInEmail() {
|
|
if (firebaseAuth.currentUser.isAnonymous) return 0;
|
|
var lengthBytes = lengthBytesUTF8(firebaseAuth.currentUser.email) + 1;
|
|
var stringOnWasmHeap = _malloc(lengthBytes);
|
|
stringToUTF8(firebaseAuth.currentUser.email, stringOnWasmHeap, lengthBytes);
|
|
return stringOnWasmHeap;
|
|
}
|
|
|
|
function firebaseMerge(email, password, merge) {
|
|
if (merge) {
|
|
simpleLogC("Signing in and merging");
|
|
} else {
|
|
simpleLogC("Signing in without merging");
|
|
firebaseAuth.currentUser.delete().then(
|
|
(result) => {
|
|
firebaseAuth.signInWithEmailAndPassword(email, password).then(
|
|
(result) => {},
|
|
(error) => {
|
|
simpleLogC("User sign in after delete user fail " + error.message);
|
|
appErrorC(1007, error.message);
|
|
},
|
|
);
|
|
},
|
|
(error) => {
|
|
simpleLogC("Delete user fail " + error.message);
|
|
appErrorC(1006, error.message);
|
|
},
|
|
);
|
|
}
|
|
}
|
|
|
|
function firebaseDeleteCurrentUser(email, password) {
|
|
simpleLogC("Signing in and deleting");
|
|
firebaseAuth.signInWithEmailAndPassword(email, password).then(
|
|
(result) => {
|
|
firebaseAuth.currentUser.delete().then(
|
|
(result) => {},
|
|
(error) => {
|
|
simpleLogC("Delete user fail " + error.message);
|
|
appErrorC(1006, error.message);
|
|
},
|
|
);
|
|
},
|
|
(error) => {
|
|
simpleLogC("Sign in fail " + error.message);
|
|
appErrorC(1007, error.message);
|
|
},
|
|
);
|
|
}
|
|
|
|
function firebaseSignIn(email, pwd) {
|
|
simpleLogC("firebaseSignIn()");
|
|
firebaseAuth.signInWithEmailAndPassword(email, pwd).then(
|
|
(result) => {
|
|
Module.ccall("set_user_state", "v", ["number"], [3]);
|
|
Module.ccall("app_on_signin", "v");
|
|
},
|
|
(error) => {
|
|
simpleLogC("Sign in fail " + error.message);
|
|
appErrorC(1007, error.message);
|
|
},
|
|
);
|
|
}
|
|
|
|
function firebaseLinkUser(email, pwd) {
|
|
simpleLogC("firebaseLinkUser()");
|
|
let c = firebase.auth.EmailAuthProvider.credential(email, pwd);
|
|
firebaseAuth.currentUser.linkWithCredential(c).then(
|
|
(result) => {
|
|
Module.ccall("set_user_state", "v", ["number"], [3]);
|
|
Module.ccall("app_on_signin", "v");
|
|
},
|
|
(error) => {
|
|
simpleLogC("Link with credential failed");
|
|
if (error.code == "auth/email-already-in-use") {
|
|
simpleLogC("Email in use");
|
|
appErrorC(1003, "An account with this email already exists");
|
|
} else if (error.code == "auth/wrong-password") {
|
|
simpleLogC("Email in use, wrong password");
|
|
appErrorC(1003, "An account with this email already exists");
|
|
} else if (error.code == "auth/weak-password") {
|
|
simpleLogC("Password too weak");
|
|
appErrorC(1003, "Password too weak, please try a stronger password");
|
|
} else {
|
|
simpleLogC(
|
|
"Other error received when linking with credentials " +
|
|
error.message +
|
|
" " +
|
|
error.code,
|
|
);
|
|
appErrorC(1003, error.message + " " + error.code);
|
|
}
|
|
},
|
|
);
|
|
}
|
|
|
|
function firebaseSigninAnonymous() {
|
|
firebaseAuth.signInAnonymously().then(
|
|
(result) => {},
|
|
(error) => {
|
|
appErrorC(1001, error.message);
|
|
},
|
|
);
|
|
}
|
|
|
|
async function performRequest(url, useToken, parseJson) {}
|
|
|
|
function firebaseInit() {}
|
|
|
|
function writeGameBlob(blob, pathDevice, guid) {
|
|
blob.arrayBuffer().then((buffer) => {
|
|
writeLocalFile(buffer, pathDevice);
|
|
FS.syncfs(false, function (err) {
|
|
if (err) {
|
|
simpleLogC("syncfs error " + err);
|
|
}
|
|
Module.ccall(
|
|
"game_download_finished",
|
|
"v",
|
|
["string", "string", "number"],
|
|
[pathDevice, guid, 1],
|
|
);
|
|
});
|
|
});
|
|
}
|
|
|
|
function firebaseDownload(pathServer, pathDevice, guid) {
|
|
if (
|
|
guid == getGameGuidString() &&
|
|
!pathDevice.endsWith(".webp") &&
|
|
singleGameBlob != null
|
|
) {
|
|
writeGameBlob(singleGameBlob, pathDevice, guid);
|
|
return;
|
|
}
|
|
simpleLogC(`firebaseDownload('${pathServer}', '${pathDevice}', '${guid}'')`);
|
|
|
|
let xhr = new XMLHttpRequest();
|
|
xhr.responseType = "blob";
|
|
xhr.onload = (event) => {
|
|
let blob = xhr.response;
|
|
writeGameBlob(blob, pathDevice, guid);
|
|
};
|
|
xhr.onerror = function () {
|
|
simpleLogC("Unable to download file, XMLHttpRequest error");
|
|
Module.ccall(
|
|
"game_download_finished",
|
|
"v",
|
|
["string", "string", "number"],
|
|
[pathDevice, guid, 0],
|
|
);
|
|
};
|
|
xhr.open("GET", url);
|
|
xhr.send();
|
|
}
|
|
|
|
function currentTimeSecondsRound() {
|
|
return Math.round(Date.now() / 1000);
|
|
}
|
|
|
|
function firebaseQueryGames(hi, heading, limit, next) {}
|
|
|
|
function firebaseAnalyticsPlay(
|
|
page,
|
|
score,
|
|
wi,
|
|
guid,
|
|
version,
|
|
li,
|
|
score_type,
|
|
daily_done,
|
|
game_time,
|
|
crowns,
|
|
) {
|
|
let params = {};
|
|
if (page != -1) params["page"] = page;
|
|
if (wi != -1) params["world"] = wi;
|
|
params["guid"] = guid;
|
|
if (version != -1) params["version"] = version;
|
|
params["level"] = li;
|
|
if (score_type != 0) params["score"] = score;
|
|
if (page == 5) params["daily"] = daily_done;
|
|
if (game_time != -1) params["time"] = game_time / 60;
|
|
if (crowns != -1) params["crowns"] = crowns;
|
|
// firebaseAnalytics.logEvent("play", params);
|
|
}
|
|
|