Greasy Fork is available in English.
MvP
当前为
// ==UserScript==
// @name x-Surf
// @namespace Hack Studio
// @version v0.1
// @description MvP
// @author 2k09__
// @match *://moomoo.io/*
// @grant none
// ==/UserScript==
/*
.88. .88. .88. .88. .88.
.88. .88. .88. .88. .88..88.
.88. .88. .88 .88. .88.
.88. .88. .88. .88.
.88. .88.
*/
function serialize(data) {
const pow32 = 0x100000000;
let floatBuffer, floatView;
let array = new Uint8Array(128);
let length = 0;
append(data);
return array.subarray(0, length);
function append(data) {
switch (typeof data) {
case "undefined":
appendNull(data);
break;
case "boolean":
appendBoolean(data);
break;
case "number":
appendNumber(data);
break;
case "string":
appendString(data);
break;
case "object":
if (data === null) {
appendNull(data);
} else if (data instanceof Date) {
appendDate(data);
} else if (Array.isArray(data)) {
appendArray(data);
} else if (data instanceof Uint8Array || data instanceof Uint8ClampedArray) {
appendBinArray(data);
} else if (data instanceof Int8Array || data instanceof Int16Array || data instanceof Uint16Array ||
data instanceof Int32Array || data instanceof Uint32Array ||
data instanceof Float32Array || data instanceof Float64Array) {
appendArray(data);
} else {
appendObject(data);
};
break;
};
};
function appendNull(data) {
appendByte(0xc0);
};
function appendBoolean(data) {
appendByte(data ? 0xc3 : 0xc2);
};
function appendNumber(data) {
if (isFinite(data) && Math.floor(data) === data) {
if (data >= 0 && data <= 0x7f) {
appendByte(data);
} else if (data < 0 && data >= -0x20) {
appendByte(data);
} else if (data > 0 && data <= 0xff) { // uint8
appendBytes([0xcc, data]);
} else if (data >= -0x80 && data <= 0x7f) { // int8
appendBytes([0xd0, data]);
} else if (data > 0 && data <= 0xffff) { // uint16
appendBytes([0xcd, data >>> 8, data]);
} else if (data >= -0x8000 && data <= 0x7fff) { // int16
appendBytes([0xd1, data >>> 8, data]);
} else if (data > 0 && data <= 0xffffffff) { // uint32
appendBytes([0xce, data >>> 24, data >>> 16, data >>> 8, data]);
} else if (data >= -0x80000000 && data <= 0x7fffffff) { // int32
appendBytes([0xd2, data >>> 24, data >>> 16, data >>> 8, data]);
} else if (data > 0 && data <= 0xffffffffffffffff) { // uint64
let hi = data / pow32;
let lo = data % pow32;
appendBytes([0xd3, hi >>> 24, hi >>> 16, hi >>> 8, hi, lo >>> 24, lo >>> 16, lo >>> 8, lo]);
} else if (data >= -0x8000000000000000 && data <= 0x7fffffffffffffff) { // int64
appendByte(0xd3);
appendInt64(data);
} else if (data < 0) { // below int64
appendBytes([0xd3, 0x80, 0, 0, 0, 0, 0, 0, 0]);
} else { // above uint64
appendBytes([0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
};
} else {
if (!floatView) {
floatBuffer = new ArrayBuffer(8);
floatView = new DataView(floatBuffer);
};
floatView.setFloat64(0, data);
appendByte(0xcb);
appendBytes(new Uint8Array(floatBuffer));
};
};
function appendString(data) {
let bytes = encodeUtf8(data);
let length = bytes.length;
if (length <= 0x1f) {
appendByte(0xa0 + length);
} else if (length <= 0xff) {
appendBytes([0xd9, length]);
} else if (length <= 0xffff) {
appendBytes([0xda, length >>> 8, length]);
} else {
appendBytes([0xdb, length >>> 24, length >>> 16, length >>> 8, length]);
};
appendBytes(bytes);
};
function appendArray(data) {
let length = data.length;
if (length <= 0xf) {
appendByte(0x90 + length);
} else if (length <= 0xffff) {
appendBytes([0xdc, length >>> 8, length]);
} else {
appendBytes([0xdd, length >>> 24, length >>> 16, length >>> 8, length]);
};
for (let index = 0; index < length; index++) {
append(data[index]);
};
};
function appendBinArray(data) {
let length = data.length;
if (length <= 0xf) {
appendBytes([0xc4, length]);
} else if (length <= 0xffff) {
appendBytes([0xc5, length >>> 8, length]);
} else {
appendBytes([0xc6, length >>> 24, length >>> 16, length >>> 8, length]);
};
appendBytes(data);
};
function appendObject(data) {
let length = 0;
for (let key in data) length++;
if (length <= 0xf) {
appendByte(0x80 + length);
} else if (length <= 0xffff) {
appendBytes([0xde, length >>> 8, length]);
} else {
appendBytes([0xdf, length >>> 24, length >>> 16, length >>> 8, length]);
};
for (let key in data) {
append(key);
append(data[key]);
};
};
function appendDate(data) {
let sec = data.getTime() / 1000;
if (data.getMilliseconds() === 0 && sec >= 0 && sec < 0x100000000) { // 32 bit seconds
appendBytes([0xd6, 0xff, sec >>> 24, sec >>> 16, sec >>> 8, sec]);
}
else if (sec >= 0 && sec < 0x400000000) { // 30 bit nanoseconds, 34 bit seconds
let ns = data.getMilliseconds() * 1000000;
appendBytes([0xd7, 0xff, ns >>> 22, ns >>> 14, ns >>> 6, ((ns << 2) >>> 0) | (sec / pow32), sec >>> 24, sec >>> 16, sec >>> 8, sec]);
}
else { // 32 bit nanoseconds, 64 bit seconds, negative values allowed
let ns = data.getMilliseconds() * 1000000;
appendBytes([0xc7, 12, 0xff, ns >>> 24, ns >>> 16, ns >>> 8, ns]);
appendInt64(sec);
};
};
function appendByte(byte) {
if (array.length < length + 1) {
let newLength = array.length * 2;
while (newLength < length + 1)
newLength *= 2;
let newArray = new Uint8Array(newLength);
newArray.set(array);
array = newArray;
};
array[length] = byte;
length++;
};
function appendBytes(bytes) {
if (array.length < length + bytes.length) {
let newLength = array.length * 2;
while (newLength < length + bytes.length)
newLength *= 2;
let newArray = new Uint8Array(newLength);
newArray.set(array);
array = newArray;
};
array.set(bytes, length);
length += bytes.length;
};
function appendInt64(value) {
let hi, lo;
if (value >= 0) {
hi = value / pow32;
lo = value % pow32;
}
else {
value++;
hi = Math.abs(value) / pow32;
lo = Math.abs(value) % pow32;
hi = ~hi;
lo = ~lo;
};
appendBytes([hi >>> 24, hi >>> 16, hi >>> 8, hi, lo >>> 24, lo >>> 16, lo >>> 8, lo]);
};
};
function deserialize(array) {
const pow32 = 0x100000000; // 2^32
let pos = 0;
if (array instanceof ArrayBuffer) {
array = new Uint8Array(array);
};
if (typeof array !== "object" || typeof array.length === "undefined") {
throw new Error("Invalid argument type: Expected a byte array (Array or Uint8Array) to deserialize.");
};
if (!array.length) {
throw new Error("Invalid argument: The byte array to deserialize is empty.");
};
if (!(array instanceof Uint8Array)) {
array = new Uint8Array(array);
};
let data = read();
if (pos < array.length) {
};
return data;
function read() {
const byte = array[pos++];
if (byte >= 0x00 && byte <= 0x7f) return byte; // positive fixint
if (byte >= 0x80 && byte <= 0x8f) return readMap(byte - 0x80); // fixmap
if (byte >= 0x90 && byte <= 0x9f) return readArray(byte - 0x90); // fixarray
if (byte >= 0xa0 && byte <= 0xbf) return readStr(byte - 0xa0); // fixstr
if (byte === 0xc0) return null; // nil
if (byte === 0xc1) throw new Error("Invalid byte code 0xc1 found."); // never used
if (byte === 0xc2) return false // false
if (byte === 0xc3) return true; // true
if (byte === 0xc4) return readBin(-1, 1); // bin 8
if (byte === 0xc5) return readBin(-1, 2); // bin 16
if (byte === 0xc6) return readBin(-1, 4); // bin 32
if (byte === 0xc7) return readExt(-1, 1); // ext 8
if (byte === 0xc8) return readExt(-1, 2); // ext 16
if (byte === 0xc9) return readExt(-1, 4) // ext 32
if (byte === 0xca) return readFloat(4); // float 32
if (byte === 0xcb) return readFloat(8); // float 64
if (byte === 0xcc) return readUInt(1); // uint 8
if (byte === 0xcd) return readUInt(2); // uint 16
if (byte === 0xce) return readUInt(4); // uint 32
if (byte === 0xcf) return readUInt(8) // uint 64
if (byte === 0xd0) return readInt(1); // int 8
if (byte === 0xd1) return readInt(2); // int 16
if (byte === 0xd2) return readInt(4); // int 32
if (byte === 0xd3) return readInt(8); // int 64
if (byte === 0xd4) return readExt(1); // fixext 1
if (byte === 0xd5) return readExt(2); // fixext 2
if (byte === 0xd6) return readExt(4); // fixext 4
if (byte === 0xd7) return readExt(8); // fixext 8
if (byte === 0xd8) return readExt(16); // fixext 16
if (byte === 0xd9) return readStr(-1, 1); // str 8
if (byte === 0xda) return readStr(-1, 2); // str 16
if (byte === 0xdb) return readStr(-1, 4); // str 32
if (byte === 0xdc) return readArray(-1, 2); // array 16
if (byte === 0xdd) return readArray(-1, 4); // array 32
if (byte === 0xde) return readMap(-1, 2); // map 16
if (byte === 0xdf) return readMap(-1, 4); // map 32
if (byte >= 0xe0 && byte <= 0xff) return byte - 256; // negative fixint
console.debug("msgpack array:", array);
throw new Error("Invalid byte value '" + byte + "' at index " + (pos - 1) + " in the MessagePack binary data (length " + array.length + "): Expecting a range of 0 to 255. This is not a byte array.");
};
function readInt(size) {
let value = 0;
let first = true;
while (size-- > 0) {
if (first) {
let byte = array[pos++];
value += byte & 0x7f;
if (byte & 0x80) {
value -= 0x80;
};
first = false;
}
else {
value *= 256;
value += array[pos++];
};
};
return value;
};
function readUInt(size) {
let value = 0;
while (size-- > 0) {
value *= 256;
value += array[pos++];
};
return value;
};
function readFloat(size) {
let view = new DataView(array.buffer, pos, size);
pos += size;
if (size === 4) {
return view.getFloat32(0, false);
};
if (size === 8) {
return view.getFloat64(0, false);
};
};
function readBin(size, lengthSize) {
if (size < 0) size = readUInt(lengthSize);
let data = array.subarray(pos, pos + size);
pos += size;
return data;
};
function readMap(size, lengthSize) {
if (size < 0) size = readUInt(lengthSize);
let data = {};
while (size-- > 0) {
let key = read();
data[key] = read();
};
return data;
};
function readArray(size, lengthSize) {
if (size < 0) size = readUInt(lengthSize);
let data = [];
while (size-- > 0) {
data.push(read());
};
return data;
};
function readStr(size, lengthSize) {
if (size < 0) size = readUInt(lengthSize);
let start = pos;
pos += size;
return decodeUtf8(array, start, size);
};
function readExt(size, lengthSize) {
if (size < 0) size = readUInt(lengthSize);
let type = readUInt(1);
let data = readBin(size);
switch (type) {
case 255:
return readExtDate(data);
};
return { type: type, data: data };
};
function readExtDate(data) {
if (data.length === 4) {
let sec = ((data[0] << 24) >>> 0) +
((data[1] << 16) >>> 0) +
((data[2] << 8) >>> 0) +
data[3];
return new Date(sec * 1000);
};
if (data.length === 8) {
let ns = ((data[0] << 22) >>> 0) +
((data[1] << 14) >>> 0) +
((data[2] << 6) >>> 0) +
(data[3] >>> 2);
let sec = ((data[3] & 0x3) * pow32) +
((data[4] << 24) >>> 0) +
((data[5] << 16) >>> 0) +
((data[6] << 8) >>> 0) +
data[7];
return new Date(sec * 1000 + ns / 1000000);
};
if (data.length === 12) {
let ns = ((data[0] << 24) >>> 0) +
((data[1] << 16) >>> 0) +
((data[2] << 8) >>> 0) +
data[3];
pos -= 8;
let sec = readInt(8);
return new Date(sec * 1000 + ns / 1000000);
};
throw new Error("Invalid data length for a date value.");
};
};
function encodeUtf8(str) {
let ascii = true, length = str.length;
for (let x = 0; x < length; x++) {
if (str.charCodeAt(x) > 127) {
ascii = false;
break;
};
};
let i = 0, bytes = new Uint8Array(str.length * (ascii ? 1 : 4));
for (let ci = 0; ci !== length; ci++) {
let c = str.charCodeAt(ci);
if (c < 128) {
bytes[i++] = c;
continue;
};
if (c < 2048) {
bytes[i++] = c >> 6 | 192;
}
else {
if (c > 0xd7ff && c < 0xdc00) {
if (++ci >= length)
throw new Error("UTF-8 encode: incomplete surrogate pair");
let c2 = str.charCodeAt(ci);
if (c2 < 0xdc00 || c2 > 0xdfff)
throw new Error("UTF-8 encode: second surrogate character 0x" + c2.toString(16) + " at index " + ci + " out of range");
c = 0x10000 + ((c & 0x03ff) << 10) + (c2 & 0x03ff);
bytes[i++] = c >> 18 | 240;
bytes[i++] = c >> 12 & 63 | 128;
}
else bytes[i++] = c >> 12 | 224;
bytes[i++] = c >> 6 & 63 | 128;
};
bytes[i++] = c & 63 | 128;
};
return ascii ? bytes : bytes.subarray(0, i);
};
function decodeUtf8(bytes, start, length) {
let i = start, str = "";
length += start;
while (i < length) {
let c = bytes[i++];
if (c > 127) {
if (c > 191 && c < 224) {
if (i >= length)
throw new Error("UTF-8 decode: incomplete 2-byte sequence");
c = (c & 31) << 6 | bytes[i++] & 63;
}
else if (c > 223 && c < 240) {
if (i + 1 >= length)
throw new Error("UTF-8 decode: incomplete 3-byte sequence");
c = (c & 15) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63;
}
else if (c > 239 && c < 248) {
if (i + 2 >= length)
throw new Error("UTF-8 decode: incomplete 4-byte sequence");
c = (c & 7) << 18 | (bytes[i++] & 63) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63;
}
else throw new Error("UTF-8 decode: unknown multibyte start 0x" + c.toString(16) + " at index " + (i - 1));
};
if (c <= 0xffff) str += String.fromCharCode(c);
else if (c <= 0x10ffff) {
c -= 0x10000;
str += String.fromCharCode(c >> 10 | 0xd800)
str += String.fromCharCode(c & 0x3FF | 0xdc00)
}
else throw new Error("UTF-8 decode: code point 0x" + c.toString(16) + " exceeds UTF-16 reach");
};
return str;
};
let msgpack = {
serialize: serialize,
deserialize: deserialize,
encode: serialize,
decode: deserialize
};
if (typeof module === "object" && module && typeof module.exports === "object") {
module.exports = msgpack;
}
else {
window[window.msgpackJsName || "msgpack"] = msgpack;
};
let myPlayer = {
name: null,
id: null,
sid: null,
health: null,
maxHealth: null,
damage: null,
attackSpeed: null,
attackRange: null,
isSkull: null,
team: null,
isLeader: null,
recours: null,
weapon: null,
weaponIndex: null,
weaponVariant: null,
buildIndex: null,
clan: null,
x: null,
y: null
};
let enemy = {
name: null,
id: null,
damage: null,
isLeader: null,
isSkull: null,
x: null,
y: null,
clan: null,
team: null,
weapon: null,
weaponIndex: null,
weaponVariant: null
};
localStorage.moofoll = !0;
const Surf = window.Surf;
Surf.addEventListener("updatehealth", (data) => {
let sid = data[0]
let health = data[1]
if (Surf.myPlayer.sid === sid && health < 100) {
let food = Surf.myPlayer.inventory.food;
if(health < 100 && health > 79) {
buyAndEquipHat(12);
buyAndEquipAccesory(11);
setTimeout(() => {
Surf.myPlayer.place(food);
}, 90);
} else if(health < 80 && health > 59) {
buyAndEquipHat(11);
buyAndEquipAccesory(21);
setTimeout(() => {
Surf.myPlayer.place(food);
Surf.myPlayer.place(food);
}, 90);
} else if(health < 60 && health > 39) {
buyAndEquipHat(7);
buyAndEquipAccesory(13);
Surf.myPlayer.place(food);
Surf.myPlayer.place(food);
} else if(health < 40 && health > 0) {
buyAndEquipHat(6);
buyAndEquipAccesory(13);
Surf.myPlayer.place(food);
Surf.myPlayer.place(food);
};
};
});
function placeV() {
// Spike
Surf.placeObject("spike", Surf.mousePosition);
};
function placeF() {
// Trap
Surf.placeObject("trap", Surf.mousePosition);
};
function placeN() {
// Windmill
Surf.placeObject("windmill", Surf.mousePosition);
};
function placeT() {
// Wall
Surf.placeObject("wall", Surf.mousePosition);
};
function placeH() {
// Turret && Teleporter
Surf.placeObject("turret", "teleporter", Surf.mousePosition);
};
function placeL() {
// Spawpad
Surf.placeObject("spawpad", Surf.mousePosition);
};
document.addEventListener("keydown", function(event) {
switch (event.key) {
case "v":
placeV();
break;
case "f":
placeF();
break;
case "n":
placeN();
break;
case "t":
placeT();
break;
case "h":
placeH();
break;
case "l":
placeL();
break;
};
});
var hpElement = document.createElement("div");
hpElement.style.position = "absolute";
hpElement.style.bottom = "10px";
hpElement.style.left = "50%";
hpElement.style.transform = "translateX(-50%)";
hpElement.style.fontSize = "24px";
hpElement.style.fontWeight = "bold";
hpElement.style.color = "black";
hpElement.style.textShadow = "0 0 10px black";
document.body.appendChild(hpElement);
setInterval(function() {
hpElement.textContent = `${myPlayer.hp} / 100`;
}, 1000 / 60);
document.addEventListener("DOMSubtreeModified", function() {
var usernameElements = document.querySelectorAll(".username");
for (var i = 0; i < usernameElements.length; i++) {
if (usernameElements[i].textContent === "tester") {
usernameElements[i].textContent = "x-Surf";
myPlayer.skinColor = "#87CEEB";
};
};
});
function instaKill() {
Surf.buy("BullsHelmet", "BloodWings");
Surf.equip("BullsHelmet", "BloodWings");
Surf.buy("TurretGear", "CorruptXWings");
Surf.equip("TurretGear", "CorruptXWings");
attackWithBothWeapons();
Surf.buy("SamuraiArmor", "AngelWings");
Surf.equip("SamuraiArmor", "AngelWings");
Surf.weapon("secondary");
Surf.buy("BoosterHat", "MonkeyTail");
Surf.equip("BoosterHat", "MonkeyTail");
Surf.weapon("primary");
if (isOnSurface()) {
} else if (isInLake()) {
Surf.buy("FlipperHat", "MonkeyTail");
Surf.equip("FlipperHat", "MonkeyTail");
} else if (isInSnow()) {
Surf.buy("WinterCap", "MonkeyTail");
Surf.equip("WinterCap", "MonkeyTail");
};
sendMessage("OLDUN LAN OC!");
};
function attackWithBothWeapons() {
document.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true, view: window, detail: 0, screenX: window.innerWidth / 2, screenY: window.innerHeight / 2, clientX: window.innerWidth / 2, clientY: window.innerHeight / 2 }));
document.dispatchEvent(new MouseEvent("contextmenu", { bubbles: true, cancelable: true, view: window, detail: 0, screenX: window.innerWidth / 2, screenY: window.innerHeight / 2, clientX: window.innerWidth / 2, clientY: window.innerHeight / 2 }));
};
function sendMessage(message) {
//...
};
var weaponBar = document.createElement("div");
weaponBar.style.position = "absolute";
weaponBar.style.top = "10px";
weaponBar.style.left = "50%";
weaponBar.style.transform = "translateX(-50%)";
weaponBar.style.width = "200px";
weaponBar.style.height = "20px";
weaponBar.style.background = "#F7DC6F";
weaponBar.style.borderRadius = "10px";
weaponBar.style.padding = "2px";
weaponBar.style.display = "flex";
weaponBar.style.justifyContent = "space-between";
var primaryWeaponBar = document.createElement("div");
primaryWeaponBar.style.width = "50%";
primaryWeaponBar.style.height = "100%";
primaryWeaponBar.style.background = "#F7DC6F";
primaryWeaponBar.style.borderRadius = "10px 0 0 10px";
primaryWeaponBar.style.padding = "2px";
primaryWeaponBar.textContent = "Primary";
weaponBar.appendChild(primaryWeaponBar);
var secondaryWeaponBar = document.createElement("div");
secondaryWeaponBar.style.width = "50%";
secondaryWeaponBar.style.height = "100%";
secondaryWeaponBar.style.background = "#F7DC6F";
secondaryWeaponBar.style.borderRadius = "0 10px 10px 0";
secondaryWeaponBar.style.padding = "2px";
secondaryWeaponBar.textContent = "Secondary";
weaponBar.appendChild(secondaryWeaponBar);
document.body.appendChild(weaponBar);
function autoHat() {
if (enemy.isNear()) {
Surf.equip("SpikeGear");
Surf.equip("Corrupt X Wings");
} else {
Surf.equip("SoldierHelmet");
Surf.equip("MonkeyTail");
};
};
function autoBreak() {
if (Surf.detectTrap()) {
setInterval(function() {
Surf.equip("AppleCap");
Surf.equip("MonkeyTail");
setTimeout(function() {
Surf.equip("BarbarianArmor");
Surf.equip("ShadowWings");
}, 2000);
}, 4000);
};
};
function autoAttack() {
if (enemy.isNear()) {
Surf.buy("BullsHelmet");
Surf.equip("BullsHelmet");
Surf.buy("AngelWings");
Surf.equip("AngelWings");
} else {
Surf.buy("BoosterHat");
Surf.equip("BoosterHat")
Surf.buy("MonkeyTail")
Surf.equip("MonkeyTail")
Surf.attack();
};
};
setInterval(autoAttack, 500); // 500ms
let ws,
msgpack5 = window.msgpack,
prevCount = 0;
const attachWebSocketListener = e => {
e.addEventListener("message", hookWS);
};
const hookWS = e => {
// You can add actions related to WebSocket messages here
};
const sendPacket = e => {
if (ws) {
ws.send(msgpack5.encode(e));
};
};
const chat = e => {
sendPacket(["6", [e]]);
};
WebSocket.prototype.oldSend = WebSocket.prototype.send;
WebSocket.prototype.send = function (e) {
if (!ws) {
[document.ws, ws] = [this, this];
attachWebSocketListener(this);
};
this.oldSend(e);
};
const handleMutations = mutationsList => {
for (const mutation of mutationsList) {
if (mutation.target.id === "killCounter") {
const count = parseInt(mutation.target.innerText, 10) || 0;
if (count > prevCount) {
chat("x-Surf v0.1");
} else {
chat("+".kills);
prevCount = count;
}
}
}
};
const observer = new MutationObserver(handleMutations);
observer.observe(document, {
subtree: true,
childList: true
});
let id = {};
let shownIds = {};
function showIdAbovePlayer() {
let player = Surf.getPlayer();
if (player.type === "animal") {
let id = player.animalId;
} else if (player.type === "myPlayer") {
let id = player.myPlayerId;
} else if (player.type === "enemy") {
let id = player.enemyId;
} else if (player.type === "ally") {
let id = player.allyId;
};
if (!shownIds[id]) {
Surf.drawText(id, player.position.x, player.position.y - 20);
shownIds[id] = true;
};
};