unknown
4202 lines
112 KiB
JavaScript
4202 lines
112 KiB
JavaScript
/* --------------------------------------------------------------- */
|
|
/* lceproxy.js */
|
|
/* --------------------------------------------------------------- */
|
|
|
|
//beware that there are a lot of magic numbers, need to do a refractor soon.
|
|
|
|
const dgram = require("dgram");
|
|
const net = require("net");
|
|
const mc = require("minecraft-protocol");
|
|
const {
|
|
GAME_PORT,
|
|
WIN64_LAN_DISCOVERY_PORT,
|
|
MINECRAFT_NET_VERSION,
|
|
LOBBY_NAME,
|
|
} = require("../constants");
|
|
|
|
const PacketWriter = require("./packetwriter");
|
|
const PacketReader = require("./packetreader");
|
|
const LANBroadcast = require("./lanbroadcast");
|
|
const recipeData = require("./mappings/recipemapping");
|
|
const {
|
|
createEntityTypeMapping,
|
|
createItemMapping,
|
|
createBlockMapping,
|
|
} = require("./mappings");
|
|
const { compressRLE } = require("./utils/chunk");
|
|
const { encodeVarInt } = require("./utils");
|
|
const { normalizeYaw } = require("./utils/rotation");
|
|
const { readItemInstance } = require("./utils/items");
|
|
const { readItem, writeItem, writeItemNBT } = require("./utils/items");
|
|
const packetSenders = require("./packets/senders");
|
|
const connectToJavaServerFunc = require("./javaclienthandler");
|
|
|
|
//please stfu node
|
|
process.removeAllListeners("warning");
|
|
process.on("warning", (warning) => {
|
|
if (warning.name === "DeprecationWarning") return;
|
|
console.warn(warning.name, warning.message);
|
|
});
|
|
|
|
const zlib = require("zlib");
|
|
const fs = require("fs");
|
|
const path = require("path");
|
|
|
|
class LCEProxy {
|
|
constructor() {
|
|
this.clients = [];
|
|
this.udpSocket = null;
|
|
this.tcpServers = [];
|
|
this.broadcastInterval = null;
|
|
this.broadcasts = [];
|
|
this.serverConfigs = [];
|
|
this.nextSmallId = 1;
|
|
this.usedSmallIds = new Set();
|
|
|
|
this.openChests = new Map();
|
|
this.clientChests = new Map();
|
|
|
|
this.javaBlockMapping = createBlockMapping();
|
|
this.javaItemMapping = createItemMapping();
|
|
this.javaEntityTypeMapping = createEntityTypeMapping();
|
|
|
|
this.validLCEPackets = new Set([
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
|
|
0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
|
|
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
|
|
0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
|
|
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x3c, 0x3d, 0x3e, 0x46, 0x64,
|
|
0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x82, 0x83, 0x85,
|
|
0x96, 0x97, 0x98, 0x9a, 0x9d, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce,
|
|
0xcf, 0xd0, 0xd1, 0xfa, 0xfc, 0xfd, 0xfe, 0xff, 0xaa, 0xac,
|
|
]);
|
|
}
|
|
|
|
mapJavaBlockToLCE(javaBlockId) {
|
|
if (this.javaBlockMapping[javaBlockId] !== undefined) {
|
|
return this.javaBlockMapping[javaBlockId];
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
mapJavaParticleToLCE(particleId) {
|
|
const particleMap = {
|
|
0: "explode",
|
|
1: "largeexplode",
|
|
2: "hugeexplosion",
|
|
3: "fireworksSpark",
|
|
4: "bubble",
|
|
5: "splash",
|
|
6: "wake",
|
|
7: "suspended",
|
|
8: "depthsuspend",
|
|
9: "crit",
|
|
10: "magicCrit",
|
|
11: "smoke",
|
|
12: "largesmoke",
|
|
13: "spell",
|
|
14: "instantSpell",
|
|
15: "mobSpell",
|
|
16: "mobSpellAmbient",
|
|
17: "witchMagic",
|
|
18: "dripWater",
|
|
19: "dripLava",
|
|
20: "angryVillager",
|
|
21: "happyVillager",
|
|
22: "townaura",
|
|
23: "note",
|
|
24: "portal",
|
|
25: "enchantmenttable",
|
|
26: "flame",
|
|
27: "lava",
|
|
28: "footstep",
|
|
29: "cloud",
|
|
30: "reddust",
|
|
31: "snowballpoof",
|
|
32: "snowshovel",
|
|
33: "slime",
|
|
34: "heart",
|
|
35: "barrier",
|
|
36: "iconcrack",
|
|
37: "blockcrack",
|
|
38: "blockdust",
|
|
39: "droplet",
|
|
40: "take",
|
|
41: "mobappearance",
|
|
42: "dragonbreath",
|
|
43: "endrod",
|
|
44: "damageindicator",
|
|
45: "sweepattack",
|
|
};
|
|
|
|
return particleMap[particleId] || null;
|
|
}
|
|
|
|
mapJavaItemToLCE(javaItemId) {
|
|
if (javaItemId >= 0 && javaItemId <= 255) {
|
|
return this.mapJavaBlockToLCE(javaItemId);
|
|
}
|
|
|
|
if (this.javaItemMapping[javaItemId] !== undefined) {
|
|
return this.javaItemMapping[javaItemId];
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
mapLCEItemToJava(lceItemId) {
|
|
if (lceItemId >= 0 && lceItemId <= 255) {
|
|
return this.mapLCEBlockToJava(lceItemId);
|
|
}
|
|
|
|
if (
|
|
(lceItemId >= 256 && lceItemId <= 421) ||
|
|
(lceItemId >= 2256 && lceItemId <= 2267)
|
|
) {
|
|
for (const [javaId, lceId] of Object.entries(this.javaItemMapping)) {
|
|
if (lceId === lceItemId) {
|
|
return parseInt(javaId);
|
|
}
|
|
}
|
|
return lceItemId;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
mapLCEBlockToJava(lceBlockId) {
|
|
for (const [javaId, lceId] of Object.entries(this.javaBlockMapping)) {
|
|
if (lceId === lceBlockId) {
|
|
return parseInt(javaId);
|
|
}
|
|
}
|
|
|
|
if (lceBlockId >= 0 && lceBlockId <= 174) {
|
|
return lceBlockId;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
async start() {
|
|
this.startBroadcasting();
|
|
this.startTCPServer();
|
|
|
|
console.log("\nProxy is now running!");
|
|
console.log("Press Ctrl+C to stop.\n");
|
|
}
|
|
|
|
startBroadcasting() {
|
|
this.udpSocket = dgram.createSocket("udp4");
|
|
this.udpSocket.bind(() => {
|
|
this.udpSocket.setBroadcast(true);
|
|
});
|
|
|
|
this.lobbyBroadcast = new LANBroadcast(LOBBY_NAME, GAME_PORT);
|
|
|
|
this.broadcastInterval = setInterval(() => {
|
|
this.lobbyBroadcast.setPlayerCount(Math.max(1, this.clients.length));
|
|
this.udpSocket.send(
|
|
this.lobbyBroadcast.buffer,
|
|
0,
|
|
this.lobbyBroadcast.buffer.length,
|
|
WIN64_LAN_DISCOVERY_PORT,
|
|
"255.255.255.255",
|
|
);
|
|
}, 1000);
|
|
}
|
|
|
|
startTCPServer() {
|
|
const tcpServer = net.createServer((socket) => {
|
|
socket.setNoDelay(true);
|
|
|
|
let smallId = 0;
|
|
while (this.usedSmallIds.has(smallId) && smallId <= 8) {
|
|
smallId++;
|
|
}
|
|
|
|
if (smallId > 8) {
|
|
socket.destroy();
|
|
return;
|
|
}
|
|
|
|
this.usedSmallIds.add(smallId);
|
|
|
|
const client = {
|
|
socket: socket,
|
|
smallId: smallId,
|
|
buffer: Buffer.alloc(0),
|
|
state: "prelogin",
|
|
javaClient: null,
|
|
breakingBlock: null,
|
|
javaPlayers: new Map(),
|
|
nextLceEntityId: 100,
|
|
javaToLceEntityId: new Map(),
|
|
javaEntities: new Map(),
|
|
serverConfig: null,
|
|
inLobby: true,
|
|
};
|
|
|
|
this.clients.push(client);
|
|
|
|
const smallIdBuffer = Buffer.from([smallId]);
|
|
socket.write(smallIdBuffer);
|
|
|
|
socket.on("data", (data) => {
|
|
this.handleClientData(client, data);
|
|
});
|
|
|
|
socket.on("end", () => {
|
|
this.removeClient(client);
|
|
});
|
|
|
|
socket.on("error", (err) => {
|
|
this.removeClient(client);
|
|
});
|
|
|
|
socket.on("close", () => {
|
|
if (this.clients.indexOf(client) > -1) {
|
|
this.removeClient(client);
|
|
}
|
|
});
|
|
});
|
|
|
|
tcpServer.listen(GAME_PORT, () => {
|
|
/* do nothing */
|
|
});
|
|
|
|
this.tcpServers.push(tcpServer);
|
|
}
|
|
|
|
getPacketDataSize(packetId, data, offset) {
|
|
switch (packetId) {
|
|
case 0x00:
|
|
return 0;
|
|
|
|
case 0x0a:
|
|
return 10;
|
|
|
|
case 0x0b:
|
|
let size = 4 + 1 + 4 + 1;
|
|
if (offset + size + 2 <= data.length) {
|
|
const itemId = data.readInt16BE(offset + size);
|
|
size += 2;
|
|
if (itemId !== -1) {
|
|
size += 1 + 2;
|
|
}
|
|
size += 4 + 4 + 4;
|
|
}
|
|
return size;
|
|
|
|
case 0x0c:
|
|
return data.length - offset >= 7 + 2 ? 7 : 7;
|
|
|
|
case 0x0d:
|
|
const remaining = data.length - offset;
|
|
if (remaining >= 41) return 41;
|
|
if (remaining >= 33) return 33;
|
|
if (remaining >= 9) return 9;
|
|
return remaining;
|
|
|
|
case 0x0e:
|
|
return 12;
|
|
|
|
case 0x07:
|
|
return 9;
|
|
|
|
//this retarded packet wasted hours of my life because it was being bundled with others...
|
|
//for some reason we don't receive this packet if the player is doing nothing besides hitting - 4J what the fuck did you do to this poor packet.
|
|
case 0x12:
|
|
return 5;
|
|
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
//thanks 0x12
|
|
calculatePacketSize(packetId, data, offset) {
|
|
try {
|
|
switch (packetId) {
|
|
case 0x00:
|
|
return 0;
|
|
|
|
case 0x0a:
|
|
return 1 + 1;
|
|
|
|
case 0x0b:
|
|
return 1 + 33;
|
|
|
|
case 0x0c:
|
|
return 1 + 9;
|
|
|
|
case 0x0d:
|
|
if (offset >= data.length) return null;
|
|
const remainingInBundle = data.length - offset;
|
|
if (remainingInBundle < 42) return remainingInBundle;
|
|
return 42;
|
|
|
|
case 0x0e:
|
|
return 1 + 1 + 4 + 1 + 4 + 1;
|
|
|
|
case 0x07:
|
|
return 1 + 4 + 4 + 1;
|
|
|
|
case 0x12:
|
|
return 1 + 4 + 1;
|
|
|
|
case 0x0f:
|
|
let useItemSize = 1 + 4 + 1 + 4 + 1;
|
|
if (offset + useItemSize + 2 <= data.length) {
|
|
const itemId = data.readInt16BE(offset + useItemSize);
|
|
useItemSize += 2;
|
|
if (itemId !== -1) {
|
|
useItemSize += 1;
|
|
useItemSize += 2;
|
|
}
|
|
}
|
|
useItemSize += 1 + 1 + 1;
|
|
return useItemSize;
|
|
|
|
case 0x10:
|
|
return 1 + 2;
|
|
|
|
case 0x13:
|
|
return 1 + 9;
|
|
|
|
case 0x1b:
|
|
return 1 + 10;
|
|
|
|
case 0x66:
|
|
let containerClickSize = 1 + 1 + 2 + 1 + 2 + 1;
|
|
if (offset + containerClickSize + 2 <= data.length) {
|
|
const itemId = data.readInt16BE(offset + containerClickSize);
|
|
containerClickSize += 2;
|
|
if (itemId !== -1) {
|
|
containerClickSize += 1;
|
|
containerClickSize += 2;
|
|
}
|
|
}
|
|
return containerClickSize;
|
|
|
|
case 0x6a:
|
|
return 1 + 4;
|
|
|
|
case 0x6b:
|
|
return 1 + 8;
|
|
|
|
case 0x65:
|
|
return 1 + 1;
|
|
|
|
case 0xcd:
|
|
return 1 + 1;
|
|
|
|
case 0x98:
|
|
return 1 + 4;
|
|
|
|
case 0x82:
|
|
try {
|
|
let signSize = 1 + 4 + 2 + 4 + 1 + 1;
|
|
let pos = offset + 1 + 4 + 2 + 4 + 1 + 1;
|
|
for (let i = 0; i < 4; i++) {
|
|
if (pos + 2 > data.length) return null;
|
|
const strLen = data.readInt16BE(pos);
|
|
pos += 2;
|
|
signSize += 2 + strLen * 2;
|
|
pos += strLen * 2;
|
|
}
|
|
return signSize;
|
|
} catch (err) {
|
|
return null;
|
|
}
|
|
|
|
case 0x85:
|
|
return 1 + 1 + 4 + 4 + 4;
|
|
|
|
default:
|
|
return null;
|
|
}
|
|
} catch (err) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
handleClientData(client, data) {
|
|
try {
|
|
client.buffer = Buffer.concat([client.buffer, data]);
|
|
|
|
while (client.buffer.length >= 4) {
|
|
const packetLength = client.buffer.readUInt32BE(0);
|
|
|
|
if (client.buffer.length < 4 + packetLength) {
|
|
break;
|
|
}
|
|
|
|
const packetData = client.buffer.slice(4, 4 + packetLength);
|
|
client.buffer = client.buffer.slice(4 + packetLength);
|
|
|
|
const packetId = packetData[0];
|
|
|
|
const expectedSize = this.calculatePacketSize(packetId, packetData, 0);
|
|
if (expectedSize > 0 && packetData.length > expectedSize) {
|
|
let offset = 0;
|
|
while (offset < packetData.length) {
|
|
const bundledPacketId = packetData[offset];
|
|
const bundledSize = this.calculatePacketSize(
|
|
bundledPacketId,
|
|
packetData,
|
|
offset,
|
|
);
|
|
if (bundledSize <= 0 || offset + bundledSize > packetData.length) {
|
|
break;
|
|
}
|
|
|
|
const singlePacket = packetData.slice(offset, offset + bundledSize);
|
|
this.processPacket(
|
|
client,
|
|
bundledPacketId,
|
|
singlePacket,
|
|
offset > 0,
|
|
);
|
|
offset += bundledSize;
|
|
}
|
|
} else {
|
|
this.processPacket(client, packetId, packetData, false);
|
|
}
|
|
}
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
|
|
processPacket(client, packetId, packetData, isBundled = false) {
|
|
switch (packetId) {
|
|
case 0x02: //PreLoginPacket
|
|
this.handlePreLogin(client, packetData);
|
|
break;
|
|
case 0xab: //AuthResponsePacket (171)
|
|
if (client.state === "login") {
|
|
this.handleAuthResponse(client, packetData);
|
|
}
|
|
break;
|
|
case 0x01: //LoginPacket
|
|
this.handleLogin(client, packetData);
|
|
break;
|
|
case 0x00: //KeepAlive
|
|
if (client.state === "prelogin") {
|
|
this.handleKeepAlive(client, packetData);
|
|
}
|
|
break;
|
|
case 0x07: //InteractPacket - 7
|
|
if (client.state === "play") {
|
|
this.handleInteract(client, packetData);
|
|
}
|
|
break;
|
|
case 0x12: //AnimatePacket - 18
|
|
if (client.state === "play") {
|
|
this.handleAnimate(client, packetData, isBundled);
|
|
}
|
|
break;
|
|
case 0x0d: //MovePlayerPacket (pos & rot)
|
|
if (client.state === "play") {
|
|
this.handleMovePlayer(client, packetData);
|
|
}
|
|
break;
|
|
case 0x0a: //base (onGround/isFlying)
|
|
case 0x0b: //pos
|
|
case 0x0c: //rot
|
|
if (client.state === "play") {
|
|
this.handlePlayerMovement(client, packetId, packetData);
|
|
}
|
|
break;
|
|
case 0x03:
|
|
if (client.state === "play") {
|
|
this.handleChat(client, packetData);
|
|
}
|
|
break;
|
|
case 0x0e:
|
|
if (client.state === "play") {
|
|
this.handlePlayerAction(client, packetData, isBundled);
|
|
}
|
|
break;
|
|
case 0x0f: //UseItemPacket - 15
|
|
if (client.state === "play") {
|
|
this.handleUseItem(client, packetData);
|
|
}
|
|
break;
|
|
case 0x10: //SetCarriedItemPacket - 16
|
|
if (client.state === "play") {
|
|
this.handleSetCarriedItem(client, packetData);
|
|
}
|
|
break;
|
|
case 0x13: //PlayerCommandPacket - 19
|
|
if (client.state === "play") {
|
|
this.handlePlayerCommand(client, packetData);
|
|
}
|
|
break;
|
|
case 0x1b: //PlayerInputPacket - 27
|
|
if (client.state === "play") {
|
|
this.handlePlayerInput(client, packetData);
|
|
}
|
|
break;
|
|
case 0x65: //ContainerClosePacket - 101
|
|
if (client.state === "play") {
|
|
this.handleContainerClose(client, packetData);
|
|
}
|
|
break;
|
|
case 0x66: //ContainerClickPacket - 102
|
|
if (client.state === "play") {
|
|
this.handleContainerClick(client, packetData);
|
|
}
|
|
break;
|
|
case 0x6a: //ContainerAckPacket - 106
|
|
if (client.state === "play") {
|
|
this.handleContainerAck(client, packetData);
|
|
}
|
|
break;
|
|
case 0x96:
|
|
if (client.state === "play") {
|
|
this.handleCraftItem(client, packetData);
|
|
}
|
|
break;
|
|
case 0x97: //TradeItemPacket - 151
|
|
if (client.state === "play") {
|
|
this.handleTradeItem(client, packetData);
|
|
}
|
|
break;
|
|
case 0x98:
|
|
break;
|
|
//case 0x9E: //JavaCraftingPacket - 158
|
|
// if (client.state === 'play') {
|
|
// this.handleJavaCrafting(client, packetData);
|
|
// }
|
|
// break;
|
|
case 0xfa: //CustomPayloadPacket - 250
|
|
if (client.state === "play") {
|
|
this.handleCustomPayload(client, packetData);
|
|
}
|
|
break;
|
|
case 0x82:
|
|
if (client.state === "play") {
|
|
this.handleSignUpdate(client, packetData);
|
|
}
|
|
break;
|
|
case 0x6b: //SetCreativeModeSlotPacket - 107
|
|
if (client.state === "play") {
|
|
this.handleSetCreativeModeSlot(client, packetData);
|
|
}
|
|
break;
|
|
case 0xcd: //ClientCommandPacket - 205
|
|
if (client.state === "play") {
|
|
this.handleClientCommand(client, packetData);
|
|
}
|
|
break;
|
|
case 0xff: //DisconnectPacket - 255
|
|
this.handleDisconnect(client, packetData);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
handlePreLogin(client, data) {
|
|
const reader = new PacketReader(data.slice(1));
|
|
const netcodeVersion = reader.readShort();
|
|
const loginKey = reader.readString();
|
|
|
|
client.state = "login";
|
|
client._netcodeVersion = netcodeVersion;
|
|
|
|
const writer = new PacketWriter();
|
|
writer.writeShort(MINECRAFT_NET_VERSION);
|
|
writer.writeString("SESSION_ID_" + client.smallId);
|
|
writer.writeByte(0); //friendsOnly
|
|
writer.writeInt(0); //ugcPlayersVersion
|
|
writer.writeByte(0); //playerCount
|
|
|
|
for (let i = 0; i < 14; i++) writer.writeByte(0); //uniqueSaveName
|
|
|
|
let serverSettings = 0;
|
|
|
|
//difficulty
|
|
//0=Peaceful, 1=Easy, 2=Normal, 3=Hard
|
|
serverSettings |= 1;
|
|
|
|
//friends of friends (off)
|
|
//serverSettings |= 0x00000004;
|
|
|
|
//gamertags (on)
|
|
serverSettings |= 0x00000008;
|
|
|
|
//0=Survival, 1=Creative, 2=Adventure
|
|
//survival=leave bits clear (0)
|
|
//creative=serverSettings |= 0x00000010;
|
|
|
|
//level type (OFF=Default, ON=Flat)
|
|
//serverSettings |= 0x00000040; //uncomment for flat
|
|
|
|
//structures (on)
|
|
serverSettings |= 0x00000080;
|
|
|
|
//bonus chest (off)
|
|
//serverSettings |= 0x00000100;
|
|
|
|
//pvp (on)
|
|
serverSettings |= 0x00000400;
|
|
|
|
//trust players (on)
|
|
serverSettings |= 0x00000800;
|
|
|
|
//tnt (on)
|
|
serverSettings |= 0x00001000;
|
|
|
|
//spread fire (on)
|
|
serverSettings |= 0x00002000;
|
|
|
|
writer.writeInt(serverSettings);
|
|
writer.writeByte(0); //hostIndex
|
|
writer.writeInt(0); //texturePackId
|
|
|
|
this.sendPacket(client, 0x02, writer.toBuffer());
|
|
if (client._netcodeVersion >= 561) {
|
|
client.authState = "waitingResponse";
|
|
setImmediate(() => this._sendAuthSchemePacket(client));
|
|
} else {
|
|
client.authState = "done";
|
|
}
|
|
}
|
|
|
|
_sendAuthSchemePacket(client) {
|
|
const chars = "0123456789abcdef";
|
|
let serverId = "";
|
|
for (let i = 0; i < 20; i++)
|
|
serverId += chars[Math.floor(Math.random() * 16)];
|
|
client._authServerId = serverId;
|
|
|
|
const schemes = ["offline"];
|
|
client._authSchemes = schemes;
|
|
|
|
const writer = new PacketWriter();
|
|
writer.writeShort(schemes.length);
|
|
for (const s of schemes) writer.writeString(s);
|
|
writer.writeString(serverId);
|
|
this.sendPacket(client, 0xaa, writer.toBuffer());
|
|
}
|
|
|
|
handleAuthResponse(client, data) {
|
|
if (client.authState !== "waitingResponse") return;
|
|
|
|
const reader = new PacketReader(data.slice(1));
|
|
const chosenScheme = reader.readString();
|
|
const mojangUuid = reader.readString();
|
|
const username = reader.readString();
|
|
|
|
const validSchemes = client._authSchemes || ["mojang", "offline"];
|
|
if (!validSchemes.includes(chosenScheme)) {
|
|
this._sendAuthResult(client, false, "", "", "Invalid auth scheme");
|
|
return;
|
|
}
|
|
|
|
if (chosenScheme === "offline") {
|
|
const crypto = require("crypto");
|
|
const hash = crypto
|
|
.createHash("md5")
|
|
.update("OfflinePlayer:" + username)
|
|
.digest();
|
|
hash[6] = (hash[6] & 0x0f) | 0x30;
|
|
hash[8] = (hash[8] & 0x3f) | 0x80;
|
|
const h = hash.toString("hex");
|
|
const offlineUuid =
|
|
h.slice(0, 8) +
|
|
"-" +
|
|
h.slice(8, 12) +
|
|
"-" +
|
|
h.slice(12, 16) +
|
|
"-" +
|
|
h.slice(16, 20) +
|
|
"-" +
|
|
h.slice(20, 32);
|
|
client.authUuid = offlineUuid;
|
|
client.authUsername = username || "Player";
|
|
client.authState = "done";
|
|
this._sendAuthResult(client, true, offlineUuid, client.authUsername, "");
|
|
} else {
|
|
const msAuth = require("./auth");
|
|
const finish = () => {
|
|
const raw = msAuth.uuid || "";
|
|
const uuid = raw.includes("-")
|
|
? raw
|
|
: raw.slice(0, 8) +
|
|
"-" +
|
|
raw.slice(8, 12) +
|
|
"-" +
|
|
raw.slice(12, 16) +
|
|
"-" +
|
|
raw.slice(16, 20) +
|
|
"-" +
|
|
raw.slice(20, 32);
|
|
client.authUuid = uuid;
|
|
client.authUsername = msAuth.username;
|
|
client.authState = "done";
|
|
this._sendAuthResult(client, true, uuid, msAuth.username, "");
|
|
};
|
|
if (msAuth.isAuthenticated()) {
|
|
finish();
|
|
} else {
|
|
msAuth
|
|
.authenticate()
|
|
.then(finish)
|
|
.catch(() => {
|
|
this._sendAuthResult(
|
|
client,
|
|
false,
|
|
"",
|
|
"",
|
|
"Authentication failed",
|
|
);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
_sendAuthResult(client, success, uuid, username, errorMessage) {
|
|
const writer = new PacketWriter();
|
|
writer.writeBoolean(success);
|
|
writer.writeString(uuid);
|
|
writer.writeString(username);
|
|
writer.writeString(errorMessage);
|
|
writer.writeString("");
|
|
writer.writeInt(0);
|
|
this.sendPacket(client, 0xac, writer.toBuffer());
|
|
if (!success) setTimeout(() => this.disconnectClient(client, 2), 200);
|
|
}
|
|
|
|
handleLogin(client, data) {
|
|
if (client.authState !== "done") {
|
|
this.disconnectClient(client, 2);
|
|
return;
|
|
}
|
|
|
|
const reader = new PacketReader(data.slice(1));
|
|
const clientVersion = reader.readInt();
|
|
const username = reader.readString();
|
|
|
|
client.state = "login";
|
|
client.username = username;
|
|
|
|
if (client.javaClient) {
|
|
const oldJavaClient = client.javaClient;
|
|
client.javaClient = null;
|
|
oldJavaClient.removeAllListeners();
|
|
oldJavaClient.on("error", () => {
|
|
/* do nothing */
|
|
});
|
|
try {
|
|
oldJavaClient.end();
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
|
|
this.enterLobby(client);
|
|
}
|
|
|
|
sendChatToClient(client, text) {
|
|
const writer = new PacketWriter();
|
|
writer.writeShort(0);
|
|
writer.writeShort(0x10);
|
|
writer.writeString(text);
|
|
this.sendPacket(client, 0x03, writer.toBuffer());
|
|
}
|
|
|
|
enterLobby(client, message) {
|
|
client.inLobby = true;
|
|
client.javaGameMode = 2;
|
|
client.javaDimension = 0;
|
|
client.javaSpawnX = 0.5;
|
|
client.javaSpawnY = 65.0;
|
|
client.javaSpawnZ = 0.5;
|
|
client.javaYaw = 0;
|
|
client.javaPitch = 0;
|
|
client.javaPlayers = new Map();
|
|
client.javaEntities = new Map();
|
|
client.javaToLceEntityId = new Map();
|
|
client.nextLceEntityId = 100;
|
|
client.loadedChunks = new Set();
|
|
client.heldSlot = 0;
|
|
client.inventory = {};
|
|
client._windowInventories = {};
|
|
client._currentChest = null;
|
|
client._deadEntities = new Set();
|
|
client._destroyedEntities = new Set();
|
|
client._dyingPlayers = new Map();
|
|
client._lastJavaPackets = [];
|
|
client._bookGUI = null;
|
|
client._craftingInProgress = false;
|
|
client._pendingAttacks = new Set();
|
|
client._lastAttacks = new Map();
|
|
client._itemUseState = {};
|
|
client.openWindowId = null;
|
|
client.openWindowType = null;
|
|
client.isRiding = false;
|
|
client.abilities = {};
|
|
client.serverConfig = null;
|
|
|
|
client.state = "play";
|
|
this.sendLCELoginResponse(client);
|
|
|
|
for (const other of this.clients) {
|
|
if (other === client || other.state !== "play" || other.inLobby) continue;
|
|
this.sendAddPlayerPacket(client, {
|
|
entityId: other.smallId,
|
|
name: other.username || "Player",
|
|
x: other.playerX || 0,
|
|
y: other.playerY || 65,
|
|
z: other.playerZ || 0,
|
|
yaw: other.playerYaw || 0,
|
|
pitch: other.playerPitch || 0,
|
|
});
|
|
}
|
|
|
|
for (const other of this.clients) {
|
|
if (other === client || other.state !== "play" || other.inLobby) continue;
|
|
this.sendAddPlayerPacket(other, {
|
|
entityId: client.smallId,
|
|
name: client.username || "Player",
|
|
x: 0.5,
|
|
y: 65,
|
|
z: 0.5,
|
|
yaw: 0,
|
|
pitch: 0,
|
|
});
|
|
}
|
|
|
|
for (let cx = -2; cx <= 2; cx++) {
|
|
for (let cz = -2; cz <= 2; cz++) {
|
|
this.sendFlatChunk(client, cx, cz);
|
|
}
|
|
}
|
|
|
|
const welcomeDelay = message ? 200 : 500;
|
|
if (message) {
|
|
setTimeout(() => {
|
|
this.sendChatToClient(client, message);
|
|
}, 200);
|
|
}
|
|
setTimeout(
|
|
() => {
|
|
this.sendChatToClient(
|
|
client,
|
|
"Welcome to LegacyCrossPlay - developed by @DeveloperExotic!",
|
|
);
|
|
},
|
|
message ? 600 : 500,
|
|
);
|
|
setTimeout(
|
|
() => {
|
|
this.sendChatToClient(
|
|
client,
|
|
"Type /lce connect <ip> to join a Java Edition server",
|
|
);
|
|
},
|
|
message ? 900 : 800,
|
|
);
|
|
}
|
|
|
|
sendLCELoginResponse(client) {
|
|
const writer = new PacketWriter();
|
|
writer.writeInt(client.smallId); //entityId
|
|
|
|
//we use these later
|
|
client.lcePlayerEntityId = client.smallId;
|
|
writer.writeString(""); //username
|
|
writer.writeString("default"); //levelTypeName
|
|
writer.writeLong(0); //seed
|
|
writer.writeInt(client.javaGameMode || 0); //gamemode (synced from java server)
|
|
const dimension = client.javaDimension || 0;
|
|
writer.writeByte(dimension & 0xff); //dimension
|
|
//nether/end use 128 height, overworld uses 256
|
|
const loginMapHeight = dimension === 0 ? 256 : 128;
|
|
writer.writeByte(loginMapHeight - 1); //mapHeight sent as (height - 1)
|
|
writer.writeByte(8); //maxPlayers
|
|
writer.writeLong(0); //offlineXuid
|
|
writer.writeLong(0); //onlineXuid
|
|
writer.writeBoolean(false); //friendsOnlyUGC
|
|
writer.writeInt(0); //ugcPlayersVersion
|
|
writer.writeByte(1); //difficulty (hardcoded to Easy)
|
|
writer.writeInt(0); //multiplayerInstanceId
|
|
writer.writeByte(client.smallId); //playerIndex
|
|
writer.writeInt(0); //playerSkinId
|
|
writer.writeInt(0); //playerCapeId
|
|
writer.writeBoolean(false); //isGuest
|
|
writer.writeBoolean(false); //newSeaLevel
|
|
writer.writeInt(0); //uiGamePrivileges
|
|
writer.writeShort(864); //xzSize
|
|
writer.writeByte(8); //hellScale
|
|
|
|
this.sendPacket(client, 0x01, writer.toBuffer());
|
|
this.sendPostLoginPackets(client);
|
|
}
|
|
|
|
sendPostLoginPackets(client) {
|
|
const spawnX = Math.floor(client.javaSpawnX || 0);
|
|
const spawnY = Math.floor(client.javaSpawnY || 65);
|
|
const spawnZ = Math.floor(client.javaSpawnZ || 0);
|
|
|
|
const spawnWriter = new PacketWriter();
|
|
spawnWriter.writeInt(spawnX);
|
|
spawnWriter.writeInt(spawnY);
|
|
spawnWriter.writeInt(spawnZ);
|
|
this.sendPacket(client, 6, spawnWriter.toBuffer());
|
|
|
|
const abilitiesWriter = new PacketWriter();
|
|
const invulnerable = client.abilities?.invulnerable || false;
|
|
const flying = client.abilities?.flying || false;
|
|
const canFly =
|
|
client.abilities?.canFly ||
|
|
client.gameMode === 1 ||
|
|
client.gameMode === 3;
|
|
const instabuild = client.gameMode === 1; //dunno why this controls the bow requiring arrows on LCE, but it does
|
|
let bitfield = 0;
|
|
if (invulnerable) bitfield |= 1;
|
|
if (flying) bitfield |= 2;
|
|
if (canFly) bitfield |= 4;
|
|
if (instabuild) bitfield |= 8;
|
|
abilitiesWriter.writeByte(bitfield);
|
|
abilitiesWriter.writeFloat(0.05); //flySpeed
|
|
abilitiesWriter.writeFloat(0.1); //walkSpeed
|
|
this.sendPacket(client, 202, abilitiesWriter.toBuffer());
|
|
|
|
const carriedWriter = new PacketWriter();
|
|
carriedWriter.writeShort(0); //selectedSlot
|
|
this.sendPacket(client, 16, carriedWriter.toBuffer());
|
|
|
|
const lceSpawnY = (client.javaSpawnY || 65.0) + 1.65; //lce has an eye offset of 1.62, added 3 so we don't spawn in the ground
|
|
const moveWriter = new PacketWriter();
|
|
moveWriter.writeDouble(client.javaSpawnX || 0.5);
|
|
moveWriter.writeDouble(lceSpawnY); //feet position with offset
|
|
moveWriter.writeDouble(lceSpawnY + 1.62); //eye height above feet
|
|
moveWriter.writeDouble(client.javaSpawnZ || 0.5);
|
|
moveWriter.writeFloat(client.javaYaw || 0.0);
|
|
moveWriter.writeFloat(client.javaPitch || 0.0);
|
|
moveWriter.writeByte(0x01); //onGround
|
|
const movePayload = moveWriter.toBuffer();
|
|
|
|
this.sendPacket(client, 0x0d, movePayload);
|
|
|
|
//translating between 1.8 and 1.9+ servers for viaversion requires a position packet from the
|
|
//client to generate the TeleportConfirm packet that 1.9+ servers expect before accepting movement.
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
client.javaClient.write("position_look", {
|
|
x: client.javaSpawnX || 0.5,
|
|
y: client.javaSpawnY || 65.0,
|
|
z: client.javaSpawnZ || 0.5,
|
|
yaw: client.javaYaw || 0.0,
|
|
pitch: client.javaPitch || 0.0,
|
|
onGround: true,
|
|
});
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
|
|
const timeWriter = new PacketWriter();
|
|
timeWriter.writeLong(1000); //gameTime (world age)
|
|
timeWriter.writeLong(6000); //dayTime
|
|
this.sendPacket(client, 4, timeWriter.toBuffer());
|
|
//console.log("YEEEEEEEEEEEEEEEEEEE");
|
|
}
|
|
|
|
mapJavaEntityIdToLce(client, javaEntityId) {
|
|
if (!client.javaToLceEntityId.has(javaEntityId)) {
|
|
const lceEntityId = client.nextLceEntityId++;
|
|
if (lceEntityId > 32767) {
|
|
return 100;
|
|
}
|
|
client.javaToLceEntityId.set(javaEntityId, lceEntityId);
|
|
}
|
|
return client.javaToLceEntityId.get(javaEntityId);
|
|
}
|
|
|
|
sendMovePlayerPacket(client, x, y, z, yaw, pitch) {
|
|
const lceY = y + 1.65;
|
|
const moveWriter = new PacketWriter();
|
|
moveWriter.writeDouble(x);
|
|
moveWriter.writeDouble(lceY); //feet position with offset
|
|
moveWriter.writeDouble(lceY + 1.62); //eye height above feet
|
|
moveWriter.writeDouble(z);
|
|
moveWriter.writeFloat(yaw);
|
|
moveWriter.writeFloat(pitch);
|
|
moveWriter.writeByte(0x01); //onGround
|
|
this.sendPacket(client, 0x0d, moveWriter.toBuffer());
|
|
}
|
|
|
|
sendTexturePacket(client, textureName, textureData) {
|
|
if (!client || !client.socket || client.socket.destroyed) {
|
|
return;
|
|
}
|
|
const writer = new PacketWriter();
|
|
writer.writeUTF(textureName);
|
|
writer.writeShort(textureData.length);
|
|
writer.writeBytes(textureData);
|
|
|
|
this.sendPacket(client, 0x9a, writer.toBuffer());
|
|
}
|
|
|
|
sendTextureChangePacket(client, entityId, textureName, textureType = 0) {
|
|
if (!client || !client.socket || client.socket.destroyed) {
|
|
return;
|
|
}
|
|
const writer = new PacketWriter();
|
|
writer.writeInt(entityId);
|
|
writer.writeByte(textureType);
|
|
writer.writeUTF(textureName);
|
|
|
|
this.sendPacket(client, 0x9d, writer.toBuffer());
|
|
}
|
|
|
|
sendAddPlayerPacket(client, playerInfo) {
|
|
let playerName = playerInfo.name || "undefined";
|
|
if (playerInfo.isNPC) {
|
|
playerName = "";
|
|
}
|
|
if (playerName.length > 20) {
|
|
playerName = playerName.substring(0, 20);
|
|
}
|
|
if (playerName.length === 0 && !playerInfo.isNPC) {
|
|
playerName = "undefined";
|
|
}
|
|
|
|
const writer = new PacketWriter();
|
|
writer.writeInt(playerInfo.entityId);
|
|
writer.writeString(playerName);
|
|
|
|
//pos
|
|
writer.writeInt(Math.floor(playerInfo.x * 32));
|
|
writer.writeInt(Math.floor(playerInfo.y * 32));
|
|
writer.writeInt(Math.floor(playerInfo.z * 32));
|
|
|
|
//rot
|
|
const yRotByte = Math.floor(((playerInfo.yaw % 360) / 360) * 256) & 0xff;
|
|
const xRotByte = Math.floor(((playerInfo.pitch % 360) / 360) * 256) & 0xff;
|
|
writer.writeByte(yRotByte);
|
|
writer.writeByte(xRotByte);
|
|
writer.writeByte(yRotByte); //yHeadRot
|
|
|
|
writer.writeShort(0); //carriedItem
|
|
writer.writeLong(0); //xuid
|
|
writer.writeLong(0); //OnlineXuid
|
|
writer.writeByte(0); //playerIndex
|
|
const skinIdToSend = playerInfo.skinId || 0;
|
|
|
|
writer.writeInt(skinIdToSend); //skinId
|
|
writer.writeInt(0); //capeId
|
|
writer.writeInt(0); //uiGamePrivileges
|
|
|
|
const sharedFlagsHeader = (0 << 5) | 0;
|
|
writer.writeByte(sharedFlagsHeader);
|
|
writer.writeByte(0);
|
|
|
|
const airSupplyHeader = (1 << 5) | 1;
|
|
writer.writeByte(airSupplyHeader);
|
|
writer.writeShort(300);
|
|
|
|
const healthHeader = (3 << 5) | 6;
|
|
writer.writeByte(healthHeader);
|
|
writer.writeFloat(20.0);
|
|
|
|
const effectColorHeader = (2 << 5) | 7;
|
|
writer.writeByte(effectColorHeader);
|
|
writer.writeInt(0);
|
|
|
|
const effectAmbienceHeader = (0 << 5) | 8;
|
|
writer.writeByte(effectAmbienceHeader);
|
|
writer.writeByte(0);
|
|
|
|
const arrowCountHeader = (0 << 5) | 9;
|
|
writer.writeByte(arrowCountHeader);
|
|
writer.writeByte(0);
|
|
|
|
const playerFlagsHeader = (0 << 5) | 16;
|
|
writer.writeByte(playerFlagsHeader);
|
|
writer.writeByte(0);
|
|
|
|
const absorptionHeader = (3 << 5) | 17;
|
|
writer.writeByte(absorptionHeader);
|
|
writer.writeFloat(0.0);
|
|
|
|
const scoreHeader = (2 << 5) | 18;
|
|
writer.writeByte(scoreHeader);
|
|
writer.writeInt(0);
|
|
|
|
writer.writeByte(0x7f);
|
|
|
|
this.sendPacket(client, 0x14, writer.toBuffer());
|
|
|
|
if (playerInfo.customTextureName) {
|
|
this.sendTextureChangePacket(
|
|
client,
|
|
playerInfo.entityId,
|
|
playerInfo.customTextureName,
|
|
);
|
|
}
|
|
}
|
|
|
|
sendMoveEntityPacket(client, playerInfo) {
|
|
//MoveEntityPacket can only handle movements of ~4 blocks
|
|
//just teleport for simplicity
|
|
this.sendTeleportEntityPacket(client, playerInfo);
|
|
}
|
|
|
|
sendTeleportEntityPacket(client, playerInfo) {
|
|
const writer = new PacketWriter();
|
|
writer.writeShort(playerInfo.entityId);
|
|
|
|
//pos
|
|
writer.writeInt(Math.floor(playerInfo.x * 32));
|
|
writer.writeInt(Math.floor(playerInfo.y * 32));
|
|
writer.writeInt(Math.floor(playerInfo.z * 32));
|
|
|
|
//rot
|
|
const yRotByte = Math.floor(((playerInfo.yaw % 360) / 360) * 256) & 0xff;
|
|
const xRotByte = Math.floor(((playerInfo.pitch % 360) / 360) * 256) & 0xff;
|
|
writer.writeByte(yRotByte);
|
|
writer.writeByte(xRotByte);
|
|
|
|
this.sendPacket(client, 34, writer.toBuffer()); //TeleportEntityPacket
|
|
|
|
this.sendRotateHeadPacket(client, playerInfo);
|
|
}
|
|
|
|
sendRotateHeadPacket(client, playerInfo) {
|
|
const writer = new PacketWriter();
|
|
writer.writeInt(playerInfo.entityId);
|
|
|
|
const yHeadRotByte =
|
|
Math.floor(((playerInfo.yaw % 360) / 360) * 256) & 0xff;
|
|
writer.writeByte(yHeadRotByte);
|
|
|
|
this.sendPacket(client, 35, writer.toBuffer()); //RotateHeadPacket
|
|
}
|
|
|
|
getJavaEntityType(typeId) {
|
|
const typeMap = {
|
|
50: "Creeper",
|
|
51: "Skeleton",
|
|
52: "Spider",
|
|
53: "Giant",
|
|
54: "Zombie",
|
|
55: "Slime",
|
|
56: "Ghast",
|
|
57: "PigZombie",
|
|
58: "Enderman",
|
|
59: "CaveSpider",
|
|
60: "Silverfish",
|
|
61: "Blaze",
|
|
62: "LavaSlime",
|
|
63: "EnderDragon",
|
|
64: "WitherBoss",
|
|
65: "Bat",
|
|
66: "Witch",
|
|
90: "Pig",
|
|
91: "Sheep",
|
|
92: "Cow",
|
|
93: "Chicken",
|
|
94: "Squid",
|
|
101: "Rabbit",
|
|
95: "Wolf",
|
|
96: "MushroomCow",
|
|
97: "SnowMan",
|
|
98: "Ozelot",
|
|
99: "VillagerGolem",
|
|
100: "EntityHorse",
|
|
120: "Villager",
|
|
71: "ItemFrame",
|
|
};
|
|
return typeMap[typeId] || "Unknown";
|
|
}
|
|
|
|
sendAddMobPacket(client, entityInfo) {
|
|
return packetSenders.sendAddMobPacket(this, client, entityInfo);
|
|
}
|
|
sendAddEntityPacket(client, entityInfo) {
|
|
return packetSenders.sendAddEntityPacket(this, client, entityInfo);
|
|
}
|
|
sendMoveEntityPacketForEntity(client, entity, dX, dY, dZ, includeRotation) {
|
|
return packetSenders.sendMoveEntityPacketForEntity(
|
|
this,
|
|
client,
|
|
entity,
|
|
dX,
|
|
dY,
|
|
dZ,
|
|
includeRotation,
|
|
);
|
|
}
|
|
sendTeleportEntityPacketForEntity(client, entity) {
|
|
return packetSenders.sendTeleportEntityPacketForEntity(
|
|
this,
|
|
client,
|
|
entity,
|
|
);
|
|
}
|
|
sendRotateEntityPacketForEntity(client, entity) {
|
|
return packetSenders.sendRotateEntityPacketForEntity(this, client, entity);
|
|
}
|
|
sendRotateHeadPacketForEntity(client, entity) {
|
|
return packetSenders.sendRotateHeadPacketForEntity(this, client, entity);
|
|
}
|
|
sendEntityMetadataPacket(client, entity, metadata) {
|
|
return packetSenders.sendEntityMetadataPacket(
|
|
this,
|
|
client,
|
|
entity,
|
|
metadata,
|
|
);
|
|
}
|
|
sendSetEntityMotionPacket(client, entity) {
|
|
return packetSenders.sendSetEntityMotionPacket(this, client, entity);
|
|
}
|
|
sendEntityEventPacket(client, entity, eventId) {
|
|
return packetSenders.sendEntityEventPacket(this, client, entity, eventId);
|
|
}
|
|
sendSetEquippedItemPacket(client, entity, slot, item) {
|
|
return packetSenders.sendSetEquippedItemPacket(
|
|
this,
|
|
client,
|
|
entity,
|
|
slot,
|
|
item,
|
|
);
|
|
}
|
|
sendSetItemDataPacket(client, entity, itemData) {
|
|
return packetSenders.sendSetItemDataPacket(this, client, entity, itemData);
|
|
}
|
|
sendSetItemFrameDataPacket(client, entity, itemData, rotation) {
|
|
return packetSenders.sendSetItemFrameDataPacket(
|
|
this,
|
|
client,
|
|
entity,
|
|
itemData,
|
|
rotation,
|
|
);
|
|
}
|
|
sendSetEntityDataPacket(client, entity) {
|
|
return packetSenders.sendSetEntityDataPacket(this, client, entity);
|
|
}
|
|
sendUpdateAttributesPacket(client, entity) {
|
|
return packetSenders.sendUpdateAttributesPacket(this, client, entity);
|
|
}
|
|
sendSetEntityLinkPacket(client, sourceId, destId, linkType) {
|
|
return packetSenders.sendSetEntityLinkPacket(
|
|
this,
|
|
client,
|
|
sourceId,
|
|
destId,
|
|
linkType,
|
|
);
|
|
}
|
|
|
|
sendLevelSoundPacket(client, soundId, x, y, z, volume, pitch) {
|
|
return packetSenders.sendLevelSoundPacket(
|
|
this,
|
|
client,
|
|
soundId,
|
|
x,
|
|
y,
|
|
z,
|
|
volume,
|
|
pitch,
|
|
);
|
|
}
|
|
sendLevelParticlesPacket(
|
|
client,
|
|
name,
|
|
x,
|
|
y,
|
|
z,
|
|
xDist,
|
|
yDist,
|
|
zDist,
|
|
maxSpeed,
|
|
count,
|
|
) {
|
|
return packetSenders.sendLevelParticlesPacket(
|
|
this,
|
|
client,
|
|
name,
|
|
x,
|
|
y,
|
|
z,
|
|
xDist,
|
|
yDist,
|
|
zDist,
|
|
maxSpeed,
|
|
count,
|
|
);
|
|
}
|
|
sendTileUpdatePacket(client, x, y, z, blockId, metadata) {
|
|
return packetSenders.sendTileUpdatePacket(
|
|
this,
|
|
client,
|
|
x,
|
|
y,
|
|
z,
|
|
blockId,
|
|
metadata,
|
|
);
|
|
}
|
|
|
|
sendContainerOpenPacket(client, packet) {
|
|
return packetSenders.sendContainerOpenPacket(this, client, packet);
|
|
}
|
|
|
|
sendVillagerTrades(client, windowId, packetData) {
|
|
return packetSenders.sendVillagerTrades(this, client, windowId, packetData);
|
|
}
|
|
|
|
sendBookAsChestGUI(client, bookItem) {
|
|
if (!bookItem.nbt) {
|
|
return;
|
|
}
|
|
|
|
let bookTitle = "Book";
|
|
if (bookItem.nbt.value && bookItem.nbt.value.title) {
|
|
bookTitle = bookItem.nbt.value.title.value || "Book";
|
|
}
|
|
|
|
let pages = [];
|
|
if (bookItem.nbt.value && bookItem.nbt.value.pages) {
|
|
if (
|
|
bookItem.nbt.value.pages.value &&
|
|
bookItem.nbt.value.pages.value.value
|
|
) {
|
|
pages = bookItem.nbt.value.pages.value.value;
|
|
} else if (Array.isArray(bookItem.nbt.value.pages)) {
|
|
pages = bookItem.nbt.value.pages;
|
|
}
|
|
}
|
|
|
|
if (pages.length === 0) {
|
|
return;
|
|
}
|
|
|
|
if (!client._bookGUI) {
|
|
client._bookGUI = {
|
|
pages: pages,
|
|
currentPage: 0,
|
|
clickActions: {},
|
|
bookTitle: bookTitle,
|
|
};
|
|
} else {
|
|
client._bookGUI.clickActions = {};
|
|
client._bookGUI.bookTitle = bookTitle;
|
|
}
|
|
|
|
const windowId = 1;
|
|
client.openWindowId = windowId;
|
|
client.openWindowType = "minecraft:chest";
|
|
|
|
const fakeOpenPacket = {
|
|
windowId: windowId,
|
|
inventoryType: "minecraft:chest",
|
|
slotCount: 54,
|
|
windowTitle: JSON.stringify({
|
|
text: `Written Book (${bookTitle})`,
|
|
extra: [],
|
|
}),
|
|
};
|
|
|
|
this.sendContainerOpenPacket(client, fakeOpenPacket);
|
|
|
|
this.updateBookGUIContents(client, windowId);
|
|
}
|
|
|
|
updateBookGUIContents(client, windowId) {
|
|
if (!client._bookGUI) return;
|
|
|
|
const currentPage = client._bookGUI.currentPage;
|
|
const pages = client._bookGUI.pages;
|
|
const pageContent = pages[currentPage];
|
|
|
|
const items = [];
|
|
for (let i = 0; i < 54; i++) {
|
|
items.push({ blockId: -1 });
|
|
}
|
|
|
|
if (currentPage > 0) {
|
|
items[48] = {
|
|
blockId: 35,
|
|
itemCount: 1,
|
|
itemDamage: 14,
|
|
displayName: "Previous Page",
|
|
};
|
|
}
|
|
|
|
if (currentPage < pages.length - 1) {
|
|
items[50] = {
|
|
blockId: 35,
|
|
itemCount: 1,
|
|
itemDamage: 5,
|
|
displayName: "Next Page",
|
|
};
|
|
}
|
|
|
|
try {
|
|
const pageText = JSON.parse(pageContent);
|
|
|
|
let lines = [];
|
|
if (Array.isArray(pageText)) {
|
|
lines = pageText;
|
|
} else if (pageText.extra) {
|
|
lines = pageText.extra;
|
|
} else {
|
|
lines = [pageText];
|
|
}
|
|
|
|
let slotIndex = 0;
|
|
for (let i = 0; i < lines.length && slotIndex < 36; i++) {
|
|
const line = lines[i];
|
|
let text = "";
|
|
let clickAction = null;
|
|
|
|
if (typeof line === "string") {
|
|
text = line;
|
|
} else if (line && typeof line === "object") {
|
|
if (line.text) {
|
|
text = line.text;
|
|
}
|
|
if (line.extra && Array.isArray(line.extra)) {
|
|
for (const extraPart of line.extra) {
|
|
if (typeof extraPart === "string") {
|
|
text += extraPart;
|
|
} else if (extraPart.text) {
|
|
text += extraPart.text;
|
|
}
|
|
|
|
if (extraPart.clickEvent) {
|
|
clickAction = {
|
|
type: extraPart.clickEvent.action,
|
|
value: extraPart.clickEvent.value,
|
|
};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
text = text.replace(/§[0-9a-fk-or]/gi, "").replace(/\\n/g, "\n");
|
|
|
|
const textLines = text
|
|
.split("\n")
|
|
.map((l) => l.trim())
|
|
.filter((l) => l.length > 0 && l !== " ");
|
|
|
|
for (const textLine of textLines) {
|
|
if (slotIndex >= 36) break;
|
|
|
|
if (textLine.length > 0 && textLine !== " ") {
|
|
let itemId = 339;
|
|
let itemDamage = 0;
|
|
let isEnchanted = false;
|
|
|
|
if (clickAction) {
|
|
if (clickAction.type === "open_url") {
|
|
itemId = 345;
|
|
itemDamage = 0;
|
|
} else if (clickAction.type === "run_command") {
|
|
itemId = 340;
|
|
itemDamage = 0;
|
|
}
|
|
isEnchanted = true;
|
|
}
|
|
|
|
const chunks = [];
|
|
for (let pos = 0; pos < textLine.length; pos += 32) {
|
|
chunks.push(textLine.substring(pos, pos + 32));
|
|
}
|
|
|
|
for (const chunk of chunks) {
|
|
if (slotIndex >= 36) break;
|
|
|
|
items[slotIndex] = {
|
|
blockId: itemId,
|
|
itemCount: 1,
|
|
itemDamage: itemDamage,
|
|
displayName: chunk,
|
|
enchanted: isEnchanted,
|
|
};
|
|
|
|
if (clickAction) {
|
|
client._bookGUI.clickActions[slotIndex] = clickAction;
|
|
}
|
|
|
|
slotIndex++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} catch (err) {
|
|
items[0] = {
|
|
blockId: 339,
|
|
itemCount: 1,
|
|
itemDamage: 0,
|
|
displayName: "Error loading page",
|
|
};
|
|
}
|
|
|
|
let itemCount = 0;
|
|
for (let i = 0; i < items.length; i++) {
|
|
if (items[i].blockId !== -1) {
|
|
itemCount++;
|
|
}
|
|
}
|
|
|
|
const PacketWriter = require("./packetwriter");
|
|
const invWriter = new PacketWriter();
|
|
invWriter.writeByte(windowId);
|
|
invWriter.writeShort(items.length);
|
|
|
|
for (const item of items) {
|
|
this.writeItem(invWriter, item);
|
|
}
|
|
|
|
this.sendPacket(client, 0x68, invWriter.toBuffer());
|
|
}
|
|
|
|
//debug
|
|
sendFlatChunk(client, chunkX, chunkZ) {
|
|
const xs = 16;
|
|
const ys = 256;
|
|
const zs = 16;
|
|
const blockCount = xs * ys * zs;
|
|
const halfBlockCount = blockCount / 2;
|
|
const biomeSize = xs * zs;
|
|
const rawSize = blockCount + 3 * halfBlockCount + biomeSize;
|
|
|
|
const rawData = Buffer.alloc(rawSize);
|
|
let offset = 0;
|
|
|
|
for (let y = 0; y < ys; y++) {
|
|
for (let z = 0; z < zs; z++) {
|
|
for (let x = 0; x < xs; x++) {
|
|
let blockId = 0;
|
|
|
|
if (y < 65) {
|
|
blockId = 1;
|
|
}
|
|
if (y === 64) {
|
|
blockId = 2;
|
|
}
|
|
rawData[offset++] = blockId;
|
|
}
|
|
}
|
|
}
|
|
|
|
const metadataOffset = offset;
|
|
for (let x = 0; x < xs; x++) {
|
|
for (let z = 0; z < zs; z++) {
|
|
for (let yPair = 0; yPair < ys / 2; yPair++) {
|
|
rawData[offset++] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (let x = 0; x < xs; x++) {
|
|
for (let z = 0; z < zs; z++) {
|
|
for (let yPair = 0; yPair < ys / 2; yPair++) {
|
|
rawData[offset++] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (let x = 0; x < xs; x++) {
|
|
for (let z = 0; z < zs; z++) {
|
|
for (let yPair = 0; yPair < ys / 2; yPair++) {
|
|
rawData[offset++] = 0xff;
|
|
}
|
|
}
|
|
}
|
|
for (let i = 0; i < biomeSize; i++) {
|
|
rawData[offset++] = 1;
|
|
}
|
|
|
|
const rleCompressed = compressRLE(rawData);
|
|
const compressed = zlib.deflateSync(rleCompressed, { level: 6 });
|
|
|
|
const writer = new PacketWriter();
|
|
|
|
writer.writeByte(0x01);
|
|
|
|
const worldX = chunkX * 16;
|
|
const worldY = 0;
|
|
const worldZ = chunkZ * 16;
|
|
|
|
writer.writeInt(worldX);
|
|
writer.writeShort(worldY);
|
|
writer.writeInt(worldZ);
|
|
|
|
writer.writeByte(xs - 1);
|
|
writer.writeByte(ys - 1);
|
|
writer.writeByte(zs - 1);
|
|
|
|
const levelIdx = 0;
|
|
const sizeAndLevel = compressed.length | (levelIdx << 30);
|
|
writer.writeInt(sizeAndLevel);
|
|
|
|
const payload = writer.toBuffer();
|
|
const fullPayload = Buffer.concat([payload, compressed]);
|
|
|
|
const visWriter = new PacketWriter();
|
|
visWriter.writeInt(chunkX);
|
|
visWriter.writeInt(chunkZ);
|
|
visWriter.writeByte(1);
|
|
this.sendPacket(client, 0x32, visWriter.toBuffer());
|
|
|
|
const chunkKey = `${chunkX},${chunkZ}`;
|
|
if (client.loadedChunks) {
|
|
client.loadedChunks.add(chunkKey);
|
|
}
|
|
|
|
this.sendPacket(client, 0x33, fullPayload);
|
|
}
|
|
|
|
handleKeepAlive(client, data) {
|
|
const reader = new PacketReader(data.slice(1));
|
|
const keepAliveId = reader.readInt();
|
|
|
|
const writer = new PacketWriter();
|
|
writer.writeInt(keepAliveId);
|
|
this.sendPacket(client, 0x00, writer.toBuffer());
|
|
}
|
|
|
|
handleInteract(client, packetData) {
|
|
const reader = new PacketReader(packetData.slice(1));
|
|
const sourceId = reader.readInt();
|
|
const targetId = reader.readInt();
|
|
const action = reader.readByte();
|
|
|
|
if (action === 0) {
|
|
const heldSlot = client.heldSlot || 0;
|
|
const heldItem = client.inventory
|
|
? client.inventory[36 + heldSlot]
|
|
: null;
|
|
const heldItemId = heldItem ? heldItem.blockId : -1;
|
|
|
|
const nonInteractiveItems = [
|
|
346, //fishing rod
|
|
261, //bow
|
|
//foods
|
|
260,
|
|
297,
|
|
282,
|
|
350,
|
|
349,
|
|
360,
|
|
363,
|
|
365,
|
|
366,
|
|
320,
|
|
357,
|
|
391,
|
|
392,
|
|
393,
|
|
394,
|
|
//potions
|
|
373,
|
|
438,
|
|
//buckets (except milk)
|
|
326,
|
|
327,
|
|
//ender pearl, snowball, egg
|
|
368,
|
|
332,
|
|
344,
|
|
];
|
|
|
|
if (nonInteractiveItems.includes(heldItemId)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (client._destroyedEntities && client._destroyedEntities.has(targetId)) {
|
|
return;
|
|
}
|
|
|
|
if (action === 1) {
|
|
const now = Date.now();
|
|
if (!client._lastAttacks) client._lastAttacks = new Map();
|
|
|
|
const lastAttackTime = client._lastAttacks.get(targetId) || 0;
|
|
if (now - lastAttackTime < 500) {
|
|
return;
|
|
}
|
|
client._lastAttacks.set(targetId, now);
|
|
|
|
if (client._lastAttacks.size > 100) {
|
|
const oldestEntry = Array.from(client._lastAttacks.entries()).sort(
|
|
(a, b) => a[1] - b[1],
|
|
)[0];
|
|
client._lastAttacks.delete(oldestEntry[0]);
|
|
}
|
|
}
|
|
|
|
const targetEntity = Array.from(client.javaEntities.values()).find(
|
|
(e) => e.entityId === targetId,
|
|
);
|
|
const entityType = targetEntity
|
|
? `${targetEntity.javaType}(${targetEntity.type})`
|
|
: "UNKNOWN";
|
|
|
|
let targetJavaId = -1;
|
|
|
|
for (const [javaId, entity] of client.javaEntities) {
|
|
if (entity.entityId === targetId) {
|
|
if (client._deadEntities && client._deadEntities.has(javaId)) {
|
|
return;
|
|
}
|
|
targetJavaId = javaId;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (const [uuid, player] of client.javaPlayers) {
|
|
if (player.entityId === targetId && player.spawned) {
|
|
targetJavaId = player.javaEntityId;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (targetJavaId !== -1 && client.javaClient) {
|
|
let entityExists = client.javaEntities.has(targetJavaId);
|
|
if (!entityExists) {
|
|
for (const [uuid, player] of client.javaPlayers) {
|
|
if (player.javaEntityId === targetJavaId && player.spawned) {
|
|
entityExists = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!entityExists) {
|
|
return;
|
|
}
|
|
|
|
if (action === 1) {
|
|
if (!client._pendingAttacks) client._pendingAttacks = new Set();
|
|
|
|
if (client._pendingAttacks.has(targetJavaId)) {
|
|
return;
|
|
}
|
|
|
|
client._pendingAttacks.add(targetJavaId);
|
|
|
|
setTimeout(() => {
|
|
if (client._pendingAttacks) {
|
|
client._pendingAttacks.delete(targetJavaId);
|
|
}
|
|
}, 150);
|
|
|
|
client.javaClient.write("use_entity", {
|
|
target: targetJavaId,
|
|
mouse: 1,
|
|
sneaking: false,
|
|
});
|
|
} else {
|
|
client.javaClient.write("use_entity", {
|
|
target: targetJavaId,
|
|
mouse: 0,
|
|
sneaking: false,
|
|
});
|
|
}
|
|
} else {
|
|
const allEntities = Array.from(client.javaEntities.values()).map(
|
|
(e) => `LCE:${e.entityId}=Java:${e.javaEntityId}(${e.javaType})`,
|
|
);
|
|
}
|
|
}
|
|
|
|
handleAnimate(client, packetData, isBundled = false) {
|
|
try {
|
|
const reader = new PacketReader(packetData.slice(1));
|
|
const entityId = reader.readInt();
|
|
const action = reader.readByte();
|
|
|
|
if (client.javaClient && action === 1) {
|
|
client.javaClient.write("arm_animation", {
|
|
hand: 0,
|
|
});
|
|
|
|
const targetEntity = this.raycastEntity(client);
|
|
if (targetEntity) {
|
|
const heldSlot = client.heldSlot || 0;
|
|
const heldItem = client.inventory
|
|
? client.inventory[36 + heldSlot]
|
|
: null;
|
|
const heldItemId = heldItem ? heldItem.blockId : -1;
|
|
|
|
const useItems = [
|
|
346, //fishing rod
|
|
261, //bow
|
|
];
|
|
|
|
if (useItems.includes(heldItemId)) {
|
|
return;
|
|
}
|
|
const entity = client.javaEntities.get(targetEntity);
|
|
let isPlayer = false;
|
|
|
|
if (!entity) {
|
|
for (const [uuid, player] of client.javaPlayers) {
|
|
if (player.javaEntityId === targetEntity && player.spawned) {
|
|
isPlayer = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!isPlayer) {
|
|
return;
|
|
}
|
|
} else {
|
|
if (!entity.spawnTime) {
|
|
return;
|
|
}
|
|
|
|
const now = Date.now();
|
|
const timeSinceSpawn = now - entity.spawnTime;
|
|
if (timeSinceSpawn < 500) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (client._deadEntities && client._deadEntities.has(targetEntity)) {
|
|
return;
|
|
}
|
|
|
|
if (!client._pendingAttacks) client._pendingAttacks = new Set();
|
|
if (client._pendingAttacks.has(targetEntity)) {
|
|
return;
|
|
}
|
|
|
|
client._pendingAttacks.add(targetEntity);
|
|
setTimeout(() => {
|
|
if (client._pendingAttacks) {
|
|
client._pendingAttacks.delete(targetEntity);
|
|
}
|
|
}, 150);
|
|
|
|
client.javaClient.write("use_entity", {
|
|
target: targetEntity,
|
|
mouse: 1,
|
|
sneaking: false,
|
|
});
|
|
}
|
|
}
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
|
|
raycastEntity(client) {
|
|
if (!client.playerX || !client.playerYaw || !client.playerPitch) {
|
|
return null;
|
|
}
|
|
|
|
const playerX = client.playerX;
|
|
const playerY = client.playerY + 1.62; //eye height
|
|
const playerZ = client.playerZ;
|
|
const yaw = client.playerYaw;
|
|
const pitch = client.playerPitch;
|
|
|
|
const yawRad = ((yaw + 90) * Math.PI) / 180;
|
|
const pitchRad = (pitch * Math.PI) / 180;
|
|
|
|
const dirX = Math.cos(pitchRad) * Math.cos(yawRad);
|
|
const dirY = -Math.sin(pitchRad);
|
|
const dirZ = Math.cos(pitchRad) * Math.sin(yawRad);
|
|
|
|
//max hit distance
|
|
const maxDistance = 10.0;
|
|
let closestEntity = null;
|
|
let closestDistance = maxDistance;
|
|
|
|
for (const [javaId, entity] of client.javaEntities) {
|
|
if (!entity.x || !entity.y || !entity.z) continue;
|
|
|
|
const isLivingEntity =
|
|
(entity.type >= 48 && entity.type <= 66) || //monsters
|
|
(entity.type >= 90 && entity.type <= 100) || //animals
|
|
entity.type === 120; //villagers
|
|
if (!isLivingEntity) continue;
|
|
|
|
const entityX = entity.x;
|
|
const entityY = entity.y + 1.0; //probably the center
|
|
const entityZ = entity.z;
|
|
|
|
const toEntityX = entityX - playerX;
|
|
const toEntityY = entityY - playerY;
|
|
const toEntityZ = entityZ - playerZ;
|
|
|
|
const distance = Math.sqrt(
|
|
toEntityX * toEntityX + toEntityY * toEntityY + toEntityZ * toEntityZ,
|
|
);
|
|
|
|
if (distance > maxDistance || distance > closestDistance) continue;
|
|
|
|
const dot =
|
|
(toEntityX * dirX + toEntityY * dirY + toEntityZ * dirZ) / distance;
|
|
|
|
//hit fov
|
|
if (dot > 0.97) {
|
|
closestEntity = javaId;
|
|
closestDistance = distance;
|
|
}
|
|
}
|
|
|
|
for (const [uuid, player] of client.javaPlayers) {
|
|
if (!player.spawned || !player.x || !player.y || !player.z) continue;
|
|
if (!player.javaEntityId) continue;
|
|
|
|
const playerEntityX = player.x;
|
|
const playerEntityY = player.y + 1.0; //probably the center
|
|
const playerEntityZ = player.z;
|
|
|
|
const toPlayerX = playerEntityX - playerX;
|
|
const toPlayerY = playerEntityY - playerY;
|
|
const toPlayerZ = playerEntityZ - playerZ;
|
|
|
|
const distance = Math.sqrt(
|
|
toPlayerX * toPlayerX + toPlayerY * toPlayerY + toPlayerZ * toPlayerZ,
|
|
);
|
|
|
|
if (distance > maxDistance || distance > closestDistance) continue;
|
|
|
|
const dot =
|
|
(toPlayerX * dirX + toPlayerY * dirY + toPlayerZ * dirZ) / distance;
|
|
|
|
//hit fov
|
|
if (dot > 0.97) {
|
|
closestEntity = player.javaEntityId;
|
|
closestDistance = distance;
|
|
}
|
|
}
|
|
|
|
return closestEntity;
|
|
}
|
|
|
|
handleMovePlayer(client, data) {
|
|
const reader = new PacketReader(data.slice(1));
|
|
const dataSize = data.length - 1;
|
|
|
|
let x, y, yView, z, yRot, xRot, onGround;
|
|
|
|
if (dataSize >= 33) {
|
|
x = reader.readDouble();
|
|
y = reader.readDouble();
|
|
yView = reader.readDouble();
|
|
z = reader.readDouble();
|
|
|
|
if (dataSize >= 41) {
|
|
yRot = reader.readFloat();
|
|
xRot = reader.readFloat();
|
|
} else {
|
|
yRot = client.lastYaw || 0;
|
|
xRot = client.lastPitch || 0;
|
|
}
|
|
onGround = reader.readByte();
|
|
} else if (dataSize >= 9) {
|
|
yRot = reader.readFloat();
|
|
xRot = reader.readFloat();
|
|
onGround = reader.readByte();
|
|
|
|
x = client.playerX || 0;
|
|
y = client.playerY || 0;
|
|
yView = y;
|
|
z = client.playerZ || 0;
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
const normalizedYaw = normalizeYaw(yRot);
|
|
|
|
client.playerX = x;
|
|
client.playerY = y;
|
|
client.playerZ = z;
|
|
client.playerYaw = normalizedYaw;
|
|
client.playerPitch = xRot;
|
|
|
|
client.lastYaw = normalizedYaw;
|
|
client.lastPitch = xRot;
|
|
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
client.javaClient.write("position_look", {
|
|
x: x,
|
|
y: y,
|
|
z: z,
|
|
yaw: normalizedYaw,
|
|
pitch: xRot,
|
|
onGround: onGround !== 0,
|
|
});
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
}
|
|
|
|
handleUseItem(client, data) {
|
|
const reader = new PacketReader(data.slice(1));
|
|
const x = reader.readInt();
|
|
const y = reader.readByte();
|
|
const z = reader.readInt();
|
|
const face = reader.readByte();
|
|
|
|
const itemId = reader.readShort();
|
|
|
|
let itemCount = 0;
|
|
let itemAux = 0;
|
|
if (itemId !== -1) {
|
|
itemCount = reader.readByte();
|
|
itemAux = reader.readShort();
|
|
}
|
|
|
|
const clickX = reader.readByte() / 32.0;
|
|
const clickY = reader.readByte() / 32.0;
|
|
const clickZ = reader.readByte() / 32.0;
|
|
|
|
if (x !== -1 && y !== -1 && z !== -1 && face >= 0 && face <= 5) {
|
|
client._lastBlockClicked = { x, y, z };
|
|
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
let javaItemId = -1;
|
|
if (itemId !== -1) {
|
|
javaItemId = this.mapLCEItemToJava(itemId);
|
|
}
|
|
|
|
let heldItem;
|
|
if (javaItemId !== -1 && javaItemId !== 0) {
|
|
heldItem = {
|
|
blockId: javaItemId,
|
|
itemCount: itemCount || 1,
|
|
itemDamage: itemAux || 0,
|
|
};
|
|
} else {
|
|
heldItem = {
|
|
blockId: -1,
|
|
itemCount: 0,
|
|
itemDamage: 0,
|
|
};
|
|
}
|
|
|
|
const javaFace = face;
|
|
|
|
const cursorX = Math.floor(clickX * 16);
|
|
const cursorY = Math.floor(clickY * 16);
|
|
const cursorZ = Math.floor(clickZ * 16);
|
|
|
|
client.javaClient.write("block_place", {
|
|
location: { x: x, y: y, z: z },
|
|
direction: javaFace,
|
|
heldItem: heldItem,
|
|
cursorX: cursorX,
|
|
cursorY: cursorY,
|
|
cursorZ: cursorZ,
|
|
});
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
} else {
|
|
//LCE also sends InteractPacket separately for entity interaction, so we ignore that
|
|
if (client.javaClient) {
|
|
if (itemId !== -1) {
|
|
client._lastHeldItem = {
|
|
itemId: itemId,
|
|
itemCount: itemCount,
|
|
itemAux: itemAux,
|
|
};
|
|
}
|
|
|
|
const useItemId =
|
|
itemId !== -1
|
|
? itemId
|
|
: client._lastHeldItem
|
|
? client._lastHeldItem.itemId
|
|
: -1;
|
|
const useItemCount =
|
|
itemId !== -1
|
|
? itemCount
|
|
: client._lastHeldItem
|
|
? client._lastHeldItem.itemCount
|
|
: 0;
|
|
const useItemAux =
|
|
itemId !== -1
|
|
? itemAux
|
|
: client._lastHeldItem
|
|
? client._lastHeldItem.itemAux
|
|
: 0;
|
|
|
|
if (useItemId !== -1) {
|
|
const javaItemId = this.mapLCEItemToJava(useItemId);
|
|
|
|
if (javaItemId !== -1 && javaItemId !== 0) {
|
|
const continuousUseItems = { 261: "bow", 346: "fishing_rod" };
|
|
const itemName = continuousUseItems[javaItemId];
|
|
|
|
if (itemName) {
|
|
if (!client._itemUseState) client._itemUseState = {};
|
|
const now = Date.now();
|
|
const lastUse = client._itemUseState[javaItemId] || 0;
|
|
|
|
if (now - lastUse > 100) {
|
|
const heldItem = {
|
|
blockId: javaItemId,
|
|
itemCount: useItemCount || 1,
|
|
itemDamage: useItemAux || 0,
|
|
};
|
|
|
|
client.javaClient.write("block_place", {
|
|
location: { x: -1, y: 255, z: -1 },
|
|
direction: -1,
|
|
heldItem: heldItem,
|
|
cursorX: 0,
|
|
cursorY: 0,
|
|
cursorZ: 0,
|
|
});
|
|
|
|
client._itemUseState[javaItemId] = now;
|
|
}
|
|
} else {
|
|
const heldItem = {
|
|
blockId: javaItemId,
|
|
itemCount: useItemCount || 1,
|
|
itemDamage: useItemAux || 0,
|
|
};
|
|
|
|
try {
|
|
const blockPlacePacket = {
|
|
location: { x: -1, y: 255, z: -1 },
|
|
direction: -1,
|
|
heldItem: heldItem,
|
|
cursorX: 0,
|
|
cursorY: 0,
|
|
cursorZ: 0,
|
|
};
|
|
client.javaClient.write("block_place", blockPlacePacket);
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
handleChat(client, data) {
|
|
const reader = new PacketReader(data.slice(1));
|
|
const messageType = reader.readShort();
|
|
const packedCounts = reader.readShort();
|
|
|
|
const stringCount = (packedCounts >> 4) & 0xf;
|
|
const intCount = (packedCounts >> 0) & 0xf;
|
|
|
|
if (stringCount > 0) {
|
|
const message = reader.readString();
|
|
|
|
if (message && message.startsWith("/lce ")) {
|
|
this.handleCommand(client, message);
|
|
return;
|
|
}
|
|
|
|
if (message && message.startsWith("/")) {
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
client.javaClient.write("chat", { message });
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (
|
|
client.javaClient &&
|
|
client.javaClient.write &&
|
|
message &&
|
|
message.length > 0
|
|
) {
|
|
try {
|
|
client.javaClient.write("chat", { message });
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
handleCommand(client, message) {
|
|
const parts = message.trim().split(/\s+/);
|
|
const cmd = parts[1]?.toLowerCase();
|
|
|
|
if (cmd === "connect") {
|
|
if (parts.length !== 3) {
|
|
this.sendChatToClient(client, "Command not valid");
|
|
return;
|
|
}
|
|
|
|
const arg = parts[2];
|
|
const colonCount = (arg.match(/:/g) || []).length;
|
|
if (colonCount > 1) {
|
|
this.sendChatToClient(client, "Command not valid");
|
|
return;
|
|
}
|
|
|
|
let host, port;
|
|
if (colonCount === 1) {
|
|
const split = arg.split(":");
|
|
host = split[0];
|
|
port = parseInt(split[1], 10);
|
|
if (!host || isNaN(port) || port < 1 || port > 65535) {
|
|
this.sendChatToClient(client, "Command not valid");
|
|
return;
|
|
}
|
|
} else {
|
|
host = arg;
|
|
port = 25565;
|
|
}
|
|
|
|
const displayAddr = colonCount === 1 ? arg : `${host}:${port}`;
|
|
this.sendChatToClient(client, `Connecting to ${displayAddr}`);
|
|
|
|
if (client.javaClient) {
|
|
const old = client.javaClient;
|
|
client.javaClient = null;
|
|
old.removeAllListeners();
|
|
old.on("error", () => {
|
|
/* do nothing */
|
|
});
|
|
try {
|
|
old.end();
|
|
} catch (e) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
|
|
client.inLobby = false;
|
|
client.state = "login";
|
|
client.serverConfig = {
|
|
host,
|
|
port,
|
|
name: displayAddr,
|
|
cracked: !(
|
|
client.useLinkedAccount !== false &&
|
|
require("./auth").hasCachedAccount()
|
|
),
|
|
};
|
|
|
|
this.connectToJavaServer(client);
|
|
} else if (cmd === "disconnect") {
|
|
if (parts.length !== 2) {
|
|
this.sendChatToClient(client, "Command not valid");
|
|
return;
|
|
}
|
|
if (client.inLobby || !client.javaClient) {
|
|
this.sendChatToClient(client, "Command not valid");
|
|
return;
|
|
}
|
|
const old = client.javaClient;
|
|
client.javaClient = null;
|
|
old.removeAllListeners();
|
|
old.on("error", () => {
|
|
/* do nothing */
|
|
});
|
|
try {
|
|
old.end();
|
|
} catch (e) {
|
|
/* do nothing */
|
|
}
|
|
this.enterLobby(client, "Disconnected from server");
|
|
} else if (cmd === "link") {
|
|
if (parts.length !== 2) {
|
|
this.sendChatToClient(client, "Usage: /lce link");
|
|
return;
|
|
}
|
|
const msAuth = require("./auth");
|
|
if (msAuth.hasCachedAccount()) {
|
|
this.sendChatToClient(client, "You already have an account linked!");
|
|
return;
|
|
}
|
|
this.sendChatToClient(client, "Starting Microsoft authentication...");
|
|
let linkInterval = null;
|
|
msAuth
|
|
.authenticate((data) => {
|
|
const code =
|
|
data.userCode ||
|
|
data.user_code ||
|
|
(data.message && data.message.match(/[A-Z0-9]{8,}/)?.[0]) ||
|
|
"???";
|
|
const msg = `To link your account, head to https://www.microsoft.com/link and enter code ${code}`;
|
|
this.sendChatToClient(client, msg);
|
|
linkInterval = setInterval(
|
|
() => this.sendChatToClient(client, msg),
|
|
1000,
|
|
);
|
|
})
|
|
.then(() => {
|
|
if (linkInterval) {
|
|
clearInterval(linkInterval);
|
|
linkInterval = null;
|
|
}
|
|
this.sendChatToClient(
|
|
client,
|
|
`Account successfully linked as ${msAuth.username}, you may now reconnect to the server`,
|
|
);
|
|
this.sendChatToClient(
|
|
client,
|
|
"Use /lce unlink to unlink your account",
|
|
);
|
|
this.sendChatToClient(
|
|
client,
|
|
"Or use /lce uselink <true/false> to toggle using your linked account",
|
|
);
|
|
})
|
|
.catch((err) => {
|
|
if (linkInterval) {
|
|
clearInterval(linkInterval);
|
|
linkInterval = null;
|
|
}
|
|
this.sendChatToClient(
|
|
client,
|
|
`Failed to link account: ${err.message || err}`,
|
|
);
|
|
});
|
|
} else if (cmd === "unlink") {
|
|
if (parts.length !== 2) {
|
|
this.sendChatToClient(client, "Usage: /lce unlink");
|
|
return;
|
|
}
|
|
const msAuth = require("./auth");
|
|
msAuth.unlink();
|
|
this.sendChatToClient(client, "Java Edition account unlinked.");
|
|
} else if (cmd === "uselink") {
|
|
if (parts.length !== 3 || (parts[2] !== "true" && parts[2] !== "false")) {
|
|
this.sendChatToClient(client, "Usage: /lce uselink <true/false>");
|
|
return;
|
|
}
|
|
client.useLinkedAccount = parts[2] === "true";
|
|
this.sendChatToClient(
|
|
client,
|
|
`Using linked account: ${client.useLinkedAccount}`,
|
|
);
|
|
} else {
|
|
this.sendChatToClient(
|
|
client,
|
|
"Command not valid. Use /lce connect <ip> or /lce disconnect",
|
|
);
|
|
}
|
|
}
|
|
|
|
handlePlayerAction(client, data, isBundled = false) {
|
|
const reader = new PacketReader(data.slice(1));
|
|
const action = reader.readByte();
|
|
const x = reader.readInt();
|
|
const y = reader.readByte();
|
|
const z = reader.readInt();
|
|
const face = reader.readByte();
|
|
|
|
//0=START_DESTROY_BLOCK
|
|
//1=ABORT_DESTROY_BLOCK
|
|
//2=STOP_DESTROY_BLOCK
|
|
//3=DROP_ALL_ITEMS
|
|
//4=DROP_ITEM
|
|
//5=RELEASE_USE_ITEM
|
|
|
|
if (action === 0) {
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
client.javaClient.write("block_dig", {
|
|
status: 0,
|
|
location: { x: x, y: y, z: z },
|
|
face: face >= 0 ? face : 1,
|
|
});
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
} else if (action === 1) {
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
client.javaClient.write("block_dig", {
|
|
status: 1,
|
|
location: { x: x, y: y, z: z },
|
|
face: face >= 0 ? face : 1,
|
|
});
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
} else if (action === 2) {
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
client.javaClient.write("block_dig", {
|
|
status: 2,
|
|
location: { x: x, y: y, z: z },
|
|
face: face >= 0 ? face : 1,
|
|
});
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
} else if (action === 3 || action === 4) {
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
const javaStatus = action === 4 ? 4 : 3;
|
|
const packet = {
|
|
status: javaStatus,
|
|
location: { x: 0, y: 0, z: 0 },
|
|
face: 0,
|
|
};
|
|
client.javaClient.write("block_dig", packet);
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
} else if (action === 5) {
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
client.javaClient.write("block_dig", {
|
|
status: 5,
|
|
location: { x: x, y: y, z: z },
|
|
face: face,
|
|
});
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
handleSetCarriedItem(client, data) {
|
|
const reader = new PacketReader(data.slice(1));
|
|
const slot = reader.readShort();
|
|
|
|
if (slot < 0 || slot > 8) {
|
|
return;
|
|
}
|
|
|
|
client.heldSlot = slot;
|
|
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
client.javaClient.write("held_item_slot", {
|
|
slotId: slot,
|
|
});
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
}
|
|
|
|
handlePlayerInput(client, data) {
|
|
const reader = new PacketReader(data.slice(1));
|
|
const xxa = reader.readFloat();
|
|
const yya = reader.readFloat();
|
|
const isJumping = reader.readBoolean();
|
|
const isSneaking = reader.readBoolean();
|
|
|
|
client.isSneaking = isSneaking;
|
|
|
|
//broken
|
|
if (isSneaking && client.javaClient && client.javaClient.write) {
|
|
try {
|
|
client.javaClient.write("steer_vehicle", {
|
|
sideways: 0,
|
|
forward: 0,
|
|
jump: false,
|
|
unmount: true,
|
|
});
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
}
|
|
|
|
handlePlayerCommand(client, data) {
|
|
const reader = new PacketReader(data.slice(1));
|
|
const entityId = reader.readInt();
|
|
const action = reader.readByte();
|
|
const actionData = reader.readInt();
|
|
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
let javaAction = -1;
|
|
|
|
if (action === 1) {
|
|
javaAction = 0;
|
|
if (client.isRiding) {
|
|
client.javaClient.write("steer_vehicle", {
|
|
sideways: 0,
|
|
forward: 0,
|
|
jump: false,
|
|
unmount: true,
|
|
});
|
|
}
|
|
} else if (action === 2) {
|
|
javaAction = 1; //java: STOP_SNEAKING
|
|
} else if (action === 3) {
|
|
javaAction = 2; //java: LEAVE_BED
|
|
} else if (action === 4) {
|
|
javaAction = 3; //java: START_SPRINTING
|
|
} else if (action === 5) {
|
|
javaAction = 4; //java: STOP_SPRINTING
|
|
} else if (action === 8) {
|
|
javaAction = 5; //java: RIDING_JUMP (open horse inventory)
|
|
} else if (action === 9) {
|
|
javaAction = 6; //java: OPEN_INVENTORY
|
|
}
|
|
|
|
if (javaAction !== -1) {
|
|
client.javaClient.write("entity_action", {
|
|
entityId: entityId,
|
|
actionId: javaAction,
|
|
jumpBoost: actionData || 0,
|
|
});
|
|
}
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
}
|
|
|
|
handlePlayerInput(client, data) {
|
|
const reader = new PacketReader(data.slice(1));
|
|
const xxa = reader.readFloat();
|
|
const yya = reader.readFloat();
|
|
const isJumping = reader.readBoolean();
|
|
const isSneaking = reader.readBoolean();
|
|
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
if (client.isRiding) {
|
|
if (isSneaking && !client.sentSneak) {
|
|
client.sentSneak = true;
|
|
client.javaClient.write("entity_action", {
|
|
entityId: client.javaPlayerEntityId,
|
|
actionId: 0,
|
|
jumpBoost: 0,
|
|
});
|
|
return;
|
|
}
|
|
|
|
if (!isSneaking) {
|
|
client.sentSneak = false;
|
|
}
|
|
|
|
if (xxa !== 0 || yya !== 0 || isJumping) {
|
|
client.javaClient.write("steer_vehicle", {
|
|
sideways: xxa,
|
|
forward: yya,
|
|
jump: isJumping,
|
|
unmount: false,
|
|
});
|
|
}
|
|
}
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
}
|
|
|
|
handleContainerClose(client, data) {
|
|
const reader = new PacketReader(data.slice(1));
|
|
const containerId = reader.readByte();
|
|
|
|
if (client.openWindowId === containerId) {
|
|
client.openWindowType = null;
|
|
client.openWindowId = null;
|
|
}
|
|
|
|
if (client._currentChest && client._currentChest.windowId === containerId) {
|
|
const posKey = client._currentChest.posKey;
|
|
const chestData = this.openChests.get(posKey);
|
|
|
|
if (chestData) {
|
|
chestData.clients.delete(client);
|
|
|
|
if (chestData.clients.size === 0) {
|
|
this.openChests.delete(posKey);
|
|
}
|
|
}
|
|
|
|
if (this.clientChests.has(client)) {
|
|
this.clientChests.get(client).delete(posKey);
|
|
}
|
|
|
|
delete client._currentChest;
|
|
}
|
|
|
|
if (client._bookGUI && containerId === client.openWindowId) {
|
|
delete client._bookGUI;
|
|
return;
|
|
}
|
|
|
|
//LCE uses special window IDs
|
|
//-1=crafting table in inventory
|
|
//-2=creative inventory
|
|
//java doesn't send close packets for these, so we'll just skip them
|
|
if (containerId < 0) {
|
|
return;
|
|
}
|
|
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
client.javaClient.write("close_window", {
|
|
windowId: containerId,
|
|
});
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
}
|
|
|
|
handleCustomPayload(client, data) {
|
|
const reader = new PacketReader(data.slice(1));
|
|
const identifier = reader.readString();
|
|
const length = reader.readShort();
|
|
|
|
const stringByteLength = identifier.length * 2;
|
|
const offset = 1 + 2 + stringByteLength + 2;
|
|
const payloadData = data.slice(offset, offset + length);
|
|
|
|
if (identifier === "MC|ItemName") {
|
|
const nameLength = payloadData.readUInt16BE(0);
|
|
const nameData = payloadData.slice(2, 2 + nameLength);
|
|
const itemName = nameData.toString("utf8");
|
|
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
const stringBytes = Buffer.from(itemName, "utf8");
|
|
|
|
const varintLength = encodeVarInt(stringBytes.length);
|
|
const stringBuffer = Buffer.concat([varintLength, stringBytes]);
|
|
|
|
client._anvilItemName = itemName;
|
|
|
|
try {
|
|
const payloadPacket = {
|
|
channel: "MC|ItemName",
|
|
data: stringBuffer,
|
|
};
|
|
client.javaClient.write("custom_payload", payloadPacket);
|
|
} catch (writeErr) {
|
|
throw writeErr;
|
|
}
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
} else if (identifier === "MC|TrSel") {
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
client.javaClient.write("custom_payload", {
|
|
channel: "MC|TrSel",
|
|
data: payloadData,
|
|
});
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
} else if (identifier === "MC|BEdit" || identifier === "MC|BSign") {
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
client.javaClient.write("custom_payload", {
|
|
channel: identifier,
|
|
data: payloadData,
|
|
});
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
placeTradeItems(client, windowId, tradeInfo, offerIndex) {
|
|
//very broken, java requires you to send clicks with the current item in the slot
|
|
//we have to track inventory and update it after each click, but this is complicated
|
|
if (!client.javaClient) return;
|
|
|
|
if (!client._windowInventories || !client._windowInventories[windowId]) {
|
|
return;
|
|
}
|
|
|
|
const inventory = client._windowInventories[windowId];
|
|
|
|
const findItem = (requiredItem) => {
|
|
for (let slot = 3; slot <= 38; slot++) {
|
|
const item = inventory[slot];
|
|
if (item && item.blockId === requiredItem.blockId) {
|
|
if (item.itemCount >= requiredItem.itemCount) {
|
|
return slot;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
const input1Slot = tradeInfo.input1 ? findItem(tradeInfo.input1) : null;
|
|
const input2Slot = tradeInfo.input2 ? findItem(tradeInfo.input2) : null;
|
|
|
|
if (tradeInfo.input1 && !input1Slot) {
|
|
console.error(0);
|
|
return;
|
|
}
|
|
|
|
if (tradeInfo.input2 && !input2Slot) {
|
|
console.error(1);
|
|
return;
|
|
}
|
|
|
|
const clickSequence = [];
|
|
|
|
if (input1Slot) {
|
|
const item1 = inventory[input1Slot];
|
|
const hasRemainder = item1.itemCount > tradeInfo.input1.itemCount;
|
|
|
|
clickSequence.push(
|
|
{
|
|
slot: input1Slot,
|
|
item: item1,
|
|
mode: 0,
|
|
desc: `pickup ${item1.itemCount} from slot ${input1Slot}`,
|
|
},
|
|
{
|
|
slot: 0,
|
|
item: null,
|
|
mode: 0,
|
|
desc: `place ${tradeInfo.input1.itemCount} in trade slot 0`,
|
|
},
|
|
);
|
|
|
|
if (hasRemainder) {
|
|
clickSequence.push({
|
|
slot: input1Slot,
|
|
item: null,
|
|
mode: 0,
|
|
desc: `return extra to slot ${input1Slot}`,
|
|
});
|
|
}
|
|
|
|
clickSequence._updateSlot = input1Slot;
|
|
clickSequence._updateItem = item1;
|
|
clickSequence._usedCount = tradeInfo.input1.itemCount;
|
|
}
|
|
|
|
let targetSlot = null;
|
|
for (let slot = 30; slot <= 38; slot++) {
|
|
if (!inventory[slot] || inventory[slot].blockId === -1) {
|
|
targetSlot = slot;
|
|
break;
|
|
}
|
|
}
|
|
if (!targetSlot) {
|
|
for (let slot = 3; slot <= 29; slot++) {
|
|
if (!inventory[slot] || inventory[slot].blockId === -1) {
|
|
targetSlot = slot;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (targetSlot) {
|
|
clickSequence.push(
|
|
{
|
|
slot: 2,
|
|
item: tradeInfo.output,
|
|
mode: 0,
|
|
desc: `pick up trade result from slot 2`,
|
|
},
|
|
{
|
|
slot: targetSlot,
|
|
item: null,
|
|
mode: 0,
|
|
desc: `place trade result in slot ${targetSlot}`,
|
|
},
|
|
);
|
|
}
|
|
|
|
let delay = 0;
|
|
clickSequence.forEach((click) => {
|
|
setTimeout(() => {
|
|
const action = client.windowClickAction++;
|
|
|
|
try {
|
|
let itemParam;
|
|
if (click.item) {
|
|
itemParam = {
|
|
blockId: click.item.blockId,
|
|
itemCount: click.item.itemCount,
|
|
itemDamage: click.item.itemDamage || 0,
|
|
};
|
|
} else {
|
|
itemParam = { blockId: -1 };
|
|
}
|
|
|
|
const clickMode = click.mode !== undefined ? click.mode : 0;
|
|
|
|
client.javaClient.write("window_click", {
|
|
windowId: windowId,
|
|
slot: click.slot,
|
|
mouseButton: 0,
|
|
action: action,
|
|
mode: clickMode,
|
|
item: itemParam,
|
|
});
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}, delay);
|
|
delay += 75;
|
|
});
|
|
|
|
if (clickSequence._updateSlot) {
|
|
const remainingCount =
|
|
clickSequence._updateItem.itemCount - clickSequence._usedCount;
|
|
if (remainingCount > 0) {
|
|
inventory[clickSequence._updateSlot] = {
|
|
blockId: clickSequence._updateItem.blockId,
|
|
itemCount: remainingCount,
|
|
itemDamage: clickSequence._updateItem.itemDamage,
|
|
};
|
|
} else {
|
|
delete inventory[clickSequence._updateSlot];
|
|
}
|
|
}
|
|
|
|
const totalDelay = delay;
|
|
setTimeout(() => {
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
client.javaClient.write("window_click", {
|
|
windowId: windowId,
|
|
slot: -999,
|
|
mouseButton: 0,
|
|
action: client.windowClickAction++,
|
|
mode: 0,
|
|
item: { blockId: -1 },
|
|
});
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
|
|
setTimeout(() => {
|
|
client._tradeInProgress = false;
|
|
}, 200);
|
|
}, totalDelay + 100);
|
|
}
|
|
|
|
handleCraftItem(client, data) {
|
|
const debugLog = false;
|
|
if (client._craftingInProgress) {
|
|
if (debugLog) console.log("craft already in progress ignoring");
|
|
return;
|
|
}
|
|
|
|
const reader = new PacketReader(data.slice(1));
|
|
const uid = reader.readShort();
|
|
const recipeId = reader.readInt();
|
|
//console.log(recipeId);
|
|
|
|
const grid = recipeData[recipeId] || [
|
|
"none",
|
|
"none",
|
|
"none",
|
|
"none",
|
|
"none",
|
|
"none",
|
|
"none",
|
|
"none",
|
|
"none",
|
|
];
|
|
|
|
if (!client.inventory) {
|
|
if (debugLog) console.log("no inventory");
|
|
client._craftingInProgress = false;
|
|
return;
|
|
}
|
|
|
|
if (debugLog) console.log("id", recipeId);
|
|
client._craftingInProgress = true;
|
|
this.tryPlaceItemsInCraftingGrid(client, grid, recipeId);
|
|
}
|
|
handleJavaCrafting(client, data) {
|
|
/* do nothing */
|
|
}
|
|
|
|
getCraftingResult(grid) {
|
|
const craftingResults = {
|
|
0: { resultItemId: 5, resultCount: 4 },
|
|
1: { resultItemId: 5, resultCount: 4 },
|
|
2: { resultItemId: 5, resultCount: 4 },
|
|
3: { resultItemId: 5, resultCount: 4 },
|
|
4: { resultItemId: 280, resultCount: 4 },
|
|
44: { resultItemId: 58, resultCount: 1 },
|
|
46: { resultItemId: 54, resultCount: 1 },
|
|
};
|
|
|
|
const recipeStr = grid.join(",");
|
|
for (const [recipeId, recipe] of Object.entries(recipeData)) {
|
|
if (recipe.join(",") === recipeStr) {
|
|
return craftingResults[recipeId];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
craftItemDirectly(client, grid, recipeId) {
|
|
if (!client.javaClient || !client.javaClient.write) {
|
|
return;
|
|
}
|
|
|
|
const craftingResults = this.getCraftingResult(grid);
|
|
if (!craftingResults) {
|
|
return;
|
|
}
|
|
|
|
const { resultItemId, resultCount } = craftingResults;
|
|
|
|
const requiredItems = this.findRequiredItems(client, grid);
|
|
if (!requiredItems) {
|
|
return;
|
|
}
|
|
|
|
requiredItems.forEach((req) => {
|
|
if (!req) return;
|
|
const slot = req.sourceSlot;
|
|
const item = client.inventory[slot];
|
|
if (item && item.itemCount > 1) {
|
|
item.itemCount--;
|
|
client.inventory[slot] = item;
|
|
} else {
|
|
client.inventory[slot] = { blockId: -1, itemCount: 0, itemDamage: 0 };
|
|
}
|
|
});
|
|
|
|
let addedToExisting = false;
|
|
for (let slot = 9; slot < 45; slot++) {
|
|
const item = client.inventory[slot];
|
|
if (item && item.blockId === resultItemId && item.itemCount < 64) {
|
|
item.itemCount = Math.min(64, (item.itemCount || 0) + resultCount);
|
|
client.inventory[slot] = item;
|
|
addedToExisting = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!addedToExisting) {
|
|
for (let slot = 9; slot < 45; slot++) {
|
|
const item = client.inventory[slot];
|
|
if (!item || item.blockId === -1) {
|
|
client.inventory[slot] = {
|
|
blockId: resultItemId,
|
|
itemCount: resultCount,
|
|
itemDamage: 0,
|
|
};
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (let i = 0; i < 45; i++) {
|
|
const item = client.inventory[i] || {
|
|
blockId: -1,
|
|
itemCount: 0,
|
|
itemDamage: 0,
|
|
};
|
|
try {
|
|
client.javaClient.write("set_slot", {
|
|
windowId: 0,
|
|
slot: i,
|
|
item: item,
|
|
});
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
}
|
|
|
|
tryPlaceItemsInCraftingGrid(client, grid, recipeId) {
|
|
const debugLog = false;
|
|
if (debugLog) console.log("placing items");
|
|
const itemNameToDamage = {
|
|
wool: 0,
|
|
orange_wool: 1,
|
|
magenta_wool: 2,
|
|
light_blue_wool: 3,
|
|
yellow_wool: 4,
|
|
lime_wool: 5,
|
|
pink_wool: 6,
|
|
gray_wool: 7,
|
|
light_gray_wool: 8,
|
|
cyan_wool: 9,
|
|
purple_wool: 10,
|
|
blue_wool: 11,
|
|
brown_wool: 12,
|
|
green_wool: 13,
|
|
red_wool: 14,
|
|
black_wool: 15,
|
|
};
|
|
|
|
const itemNameToJavaId = {
|
|
oak_log: 17,
|
|
birch_log: 17,
|
|
spruce_log: 17,
|
|
jungle_log: 17,
|
|
acacia_log: 162,
|
|
dark_oak_log: 162,
|
|
any_log: [17, 162],
|
|
any_plank: 5,
|
|
oak_plank: 5,
|
|
birch_planks: 5,
|
|
spruce_planks: 5,
|
|
jungle_planks: 5,
|
|
stick: 280,
|
|
cobblestone: 4,
|
|
iron_ingot: 265,
|
|
diamond: 264,
|
|
gold_ingot: 266,
|
|
any_wool: 35,
|
|
wool: 35,
|
|
sand: 12,
|
|
sandstone: 24,
|
|
sandstone_slab: 44,
|
|
quartz_slab: 44,
|
|
quartz_block: 155,
|
|
stone: 1,
|
|
nether_brick: 112,
|
|
snowball: 332,
|
|
clay: 337,
|
|
brick: 336,
|
|
nether_quartz: 406,
|
|
book: 340,
|
|
obsidian: 49,
|
|
iron_block: 42,
|
|
blaze_rod: 369,
|
|
chest: 54,
|
|
tripwire_hook: 131,
|
|
ender_eye: 381,
|
|
mossy_cobblestone: 48,
|
|
stonebrick: 98,
|
|
brick_block: 45,
|
|
charcoal: 263,
|
|
coal: 263,
|
|
glowstone: 348,
|
|
gunpowder: 289,
|
|
blaze_powder: 377,
|
|
pumpkin: 86,
|
|
torch: 50,
|
|
redstone: 331,
|
|
ender_pearl: 368,
|
|
slime_ball: 341,
|
|
paper: 339,
|
|
compass: 345,
|
|
apple: 260,
|
|
gold_block: 41,
|
|
gold_nugget: 371,
|
|
melon: 360,
|
|
carrot: 391,
|
|
brown_mushroom: 39,
|
|
red_mushroom: 40,
|
|
bowl: 281,
|
|
wheat: 296,
|
|
cocoa_beans: 351,
|
|
flint: 318,
|
|
string: 287,
|
|
fishing_rod: 346,
|
|
feather: 288,
|
|
glass: 20,
|
|
any_slab: 44,
|
|
inc_sac: 351,
|
|
red_dye: 351,
|
|
green_dye: 351,
|
|
lapis: 351,
|
|
purple_dye: 351,
|
|
cyan_dye: 351,
|
|
light_gray_dye: 351,
|
|
gray_dye: 351,
|
|
pink_dye: 351,
|
|
lime_dye: 351,
|
|
yellow_dye: 351,
|
|
light_blue_dye: 351,
|
|
magenta_dye: 351,
|
|
orange_dye: 351,
|
|
bone_meal: 351,
|
|
dandelion: 37,
|
|
rose: 38,
|
|
orange_wool: 35,
|
|
magenta_wool: 35,
|
|
light_blue_wool: 35,
|
|
yellow_wool: 35,
|
|
lime_wool: 35,
|
|
pink_wool: 35,
|
|
gray_wool: 35,
|
|
light_gray_wool: 35,
|
|
cyan_wool: 35,
|
|
purple_wool: 35,
|
|
blue_wool: 35,
|
|
brown_wool: 35,
|
|
green_wool: 35,
|
|
red_wool: 35,
|
|
black_wool: 35,
|
|
};
|
|
|
|
const requiredItems = [];
|
|
let allItemsFound = true;
|
|
const slotUsageCount = new Map();
|
|
|
|
for (let i = 0; i < 9; i++) {
|
|
const requiredItem = grid[i];
|
|
if (requiredItem === "none") {
|
|
requiredItems[i] = null;
|
|
continue;
|
|
}
|
|
|
|
const javaItemId = itemNameToJavaId[requiredItem];
|
|
if (!javaItemId) {
|
|
if (debugLog) console.log("could not find item for", requiredItem);
|
|
allItemsFound = false;
|
|
continue;
|
|
}
|
|
|
|
const acceptedIds = Array.isArray(javaItemId) ? javaItemId : [javaItemId];
|
|
if (debugLog)
|
|
console.log("looking for", requiredItem, "with id(s)", acceptedIds);
|
|
|
|
let foundSlot = null;
|
|
const windowId = client.openWindowId || 0;
|
|
const isCraftingTable =
|
|
client.openWindowType === "minecraft:crafting_table";
|
|
|
|
const inventoryToSearch =
|
|
isCraftingTable &&
|
|
client._windowInventories &&
|
|
client._windowInventories[windowId]
|
|
? client._windowInventories[windowId]
|
|
: client.inventory;
|
|
|
|
const startSlot = isCraftingTable ? 10 : 9;
|
|
const endSlot = isCraftingTable ? 46 : 45;
|
|
|
|
for (let slot = startSlot; slot < endSlot; slot++) {
|
|
const item = inventoryToSearch[slot];
|
|
if (item && acceptedIds.includes(item.blockId)) {
|
|
const requiredDamage = itemNameToDamage[requiredItem];
|
|
if (
|
|
requiredDamage !== undefined &&
|
|
item.itemDamage !== requiredDamage
|
|
) {
|
|
if (debugLog)
|
|
console.log(
|
|
"found item at slot",
|
|
slot,
|
|
"but damage does not match. need",
|
|
requiredDamage,
|
|
"got",
|
|
item.itemDamage,
|
|
);
|
|
continue;
|
|
}
|
|
if (debugLog) console.log("found", requiredItem, "at slot", slot);
|
|
|
|
const itemCount = item.itemCount || 1;
|
|
const usedCount = slotUsageCount.get(slot) || 0;
|
|
|
|
if (usedCount < itemCount) {
|
|
foundSlot = slot;
|
|
let gridSlot;
|
|
if (isCraftingTable) {
|
|
gridSlot = i + 1;
|
|
} else {
|
|
const slot2x2Map = { 0: 1, 1: 2, 3: 3, 4: 4 };
|
|
gridSlot = slot2x2Map[i] || i + 1;
|
|
}
|
|
|
|
requiredItems[i] = {
|
|
sourceSlot: slot,
|
|
itemId: item.blockId,
|
|
gridSlot: gridSlot,
|
|
};
|
|
slotUsageCount.set(slot, usedCount + 1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!foundSlot) {
|
|
if (debugLog)
|
|
console.log("could not find", requiredItem, "in inventory");
|
|
allItemsFound = false;
|
|
}
|
|
}
|
|
|
|
if (!allItemsFound) {
|
|
if (debugLog) console.log("not all items found");
|
|
client._craftingInProgress = false;
|
|
return;
|
|
}
|
|
|
|
if (debugLog) console.log("all items found, placing");
|
|
this.placeItemsInGrid(client, requiredItems);
|
|
}
|
|
|
|
placeItemsInGrid(client, requiredItems) {
|
|
const debugLog = false;
|
|
if (!client.javaClient || !client.javaClient.write) {
|
|
client._craftingInProgress = false;
|
|
return;
|
|
}
|
|
if (debugLog) console.log("placing", requiredItems.length, "items");
|
|
|
|
if (!client.windowClickAction) {
|
|
client.windowClickAction = 1;
|
|
}
|
|
|
|
const clicks = [];
|
|
const slotGroups = new Map();
|
|
|
|
for (let i = 0; i < requiredItems.length; i++) {
|
|
if (!requiredItems[i]) continue;
|
|
const { sourceSlot, gridSlot, itemId } = requiredItems[i];
|
|
|
|
if (!slotGroups.has(sourceSlot)) {
|
|
slotGroups.set(sourceSlot, []);
|
|
}
|
|
slotGroups.get(sourceSlot).push({ gridSlot, itemId });
|
|
}
|
|
|
|
let lastSourceSlot = null;
|
|
let lastSourceItem = null;
|
|
|
|
for (const [sourceSlot, gridSlots] of slotGroups) {
|
|
const windowId = client.openWindowId || 0;
|
|
const isCraftingTable =
|
|
client.openWindowType === "minecraft:crafting_table";
|
|
|
|
const inventoryToUse =
|
|
isCraftingTable &&
|
|
client._windowInventories &&
|
|
client._windowInventories[windowId]
|
|
? client._windowInventories[windowId]
|
|
: client.inventory;
|
|
|
|
const sourceItem = inventoryToUse[sourceSlot];
|
|
if (!sourceItem) continue;
|
|
|
|
lastSourceSlot = sourceSlot;
|
|
lastSourceItem = sourceItem;
|
|
|
|
clicks.push({
|
|
windowId: windowId,
|
|
slot: sourceSlot,
|
|
mouseButton: 0,
|
|
action: client.windowClickAction++,
|
|
mode: 0,
|
|
item: sourceItem,
|
|
});
|
|
|
|
for (const { gridSlot, itemId } of gridSlots) {
|
|
clicks.push({
|
|
windowId: windowId,
|
|
slot: gridSlot,
|
|
mouseButton: 1,
|
|
action: client.windowClickAction++,
|
|
mode: 0,
|
|
item: { blockId: -1, itemCount: 0, itemDamage: 0 },
|
|
});
|
|
}
|
|
|
|
if (gridSlots.length < sourceItem.itemCount) {
|
|
clicks.push({
|
|
windowId: windowId,
|
|
slot: sourceSlot,
|
|
mouseButton: 0,
|
|
action: client.windowClickAction++,
|
|
mode: 0,
|
|
item: { blockId: -1, itemCount: 0, itemDamage: 0 },
|
|
});
|
|
}
|
|
}
|
|
|
|
let cursorState = { blockId: -1, itemCount: 0 };
|
|
|
|
const tempListener = (packet) => {
|
|
if (packet.windowId === 0) {
|
|
const slotName =
|
|
packet.slot === 0
|
|
? "RESULT"
|
|
: packet.slot >= 1 && packet.slot <= 9
|
|
? `GRID ${packet.slot}`
|
|
: `INV ${packet.slot}`;
|
|
}
|
|
if (packet.windowId === -1 && packet.slot === -1) {
|
|
const oldCursor = `${cursorState.blockId}:${cursorState.itemCount}`;
|
|
cursorState = packet.item || { blockId: -1, itemCount: 0 };
|
|
const newCursor = `${cursorState.blockId}:${cursorState.itemCount}`;
|
|
}
|
|
};
|
|
client.javaClient.on("set_slot", tempListener);
|
|
|
|
setTimeout(() => {
|
|
client.javaClient.removeListener("set_slot", tempListener);
|
|
}, 100);
|
|
|
|
let delay = 0;
|
|
clicks.forEach((click, index) => {
|
|
setTimeout(() => {
|
|
try {
|
|
client.javaClient.write("window_click", click);
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}, delay);
|
|
delay += 1;
|
|
});
|
|
|
|
const usedGridSlots = requiredItems.filter((r) => r).map((r) => r.gridSlot);
|
|
|
|
setTimeout(() => {
|
|
this.checkCraftingResult(client, usedGridSlots);
|
|
}, delay + 50);
|
|
}
|
|
|
|
checkCraftingResult(client, usedGridSlots) {
|
|
const debugLog = false;
|
|
if (debugLog) console.log("checking crafting result");
|
|
const windowId = client.openWindowId || 0;
|
|
|
|
const checkForResult = () => {
|
|
const inventoryToCheck =
|
|
windowId !== 0 &&
|
|
client._windowInventories &&
|
|
client._windowInventories[windowId]
|
|
? client._windowInventories[windowId]
|
|
: client.inventory;
|
|
|
|
if (debugLog) console.log("slot 0 content", inventoryToCheck[0]);
|
|
|
|
if (!inventoryToCheck || !inventoryToCheck[0]) {
|
|
if (debugLog) console.log("no result slot found");
|
|
return null;
|
|
}
|
|
|
|
const resultItem = inventoryToCheck[0];
|
|
const itemId = resultItem.blockId;
|
|
|
|
if (itemId === -1 || itemId === null || itemId === undefined) {
|
|
if (debugLog) console.log("no valid result item");
|
|
return null;
|
|
}
|
|
|
|
if (debugLog) console.log("found result item:", itemId);
|
|
return resultItem;
|
|
};
|
|
|
|
const resultItem = checkForResult();
|
|
if (resultItem) {
|
|
this.takeCraftedItemAndClear(client, usedGridSlots);
|
|
return;
|
|
}
|
|
|
|
let handledResult = false;
|
|
const resultListener = (packet) => {
|
|
if (packet.windowId === windowId && packet.slot === 0) {
|
|
if (packet.item && packet.item.blockId !== -1) {
|
|
if (client.javaClient) {
|
|
client.javaClient.removeListener("set_slot", resultListener);
|
|
}
|
|
|
|
if (!handledResult) {
|
|
handledResult = true;
|
|
if (debugLog)
|
|
console.log("received set_slot for result, taking item");
|
|
setTimeout(() => {
|
|
this.takeCraftedItemAndClear(client, usedGridSlots);
|
|
}, 50);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
if (client.javaClient) {
|
|
client.javaClient.on("set_slot", resultListener);
|
|
|
|
setTimeout(() => {
|
|
if (client.javaClient) {
|
|
client.javaClient.removeListener("set_slot", resultListener);
|
|
}
|
|
|
|
if (!handledResult) {
|
|
const finalCheck = checkForResult();
|
|
if (finalCheck) {
|
|
handledResult = true;
|
|
this.takeCraftedItemAndClear(client, usedGridSlots);
|
|
} else {
|
|
client._craftingInProgress = false;
|
|
}
|
|
}
|
|
}, 150);
|
|
}
|
|
}
|
|
|
|
takeCraftedItemAndClear(client, usedGridSlots) {
|
|
const debugLog = false;
|
|
if (debugLog) console.log("taking crafted item and clearing grid");
|
|
if (!client.javaClient || !client.javaClient.write) {
|
|
if (debugLog) console.log("no java client available");
|
|
client._craftingInProgress = false;
|
|
return;
|
|
}
|
|
|
|
if (!client.windowClickAction) {
|
|
client.windowClickAction = 1;
|
|
}
|
|
|
|
const windowId = client.openWindowId || 0;
|
|
const isCraftingTable = windowId !== 0;
|
|
const inventoryToCheck =
|
|
isCraftingTable &&
|
|
client._windowInventories &&
|
|
client._windowInventories[windowId]
|
|
? client._windowInventories[windowId]
|
|
: client.inventory;
|
|
|
|
const resultItem = inventoryToCheck[0];
|
|
if (!resultItem || resultItem.blockId === -1) {
|
|
return;
|
|
}
|
|
|
|
const resultItemId = resultItem.blockId;
|
|
const resultCount = resultItem.itemCount || 1;
|
|
|
|
const slotsWithSameItem = [];
|
|
const slotRange = isCraftingTable ? [10, 46] : [9, 45];
|
|
for (let slot = slotRange[0]; slot < slotRange[1]; slot++) {
|
|
const item = inventoryToCheck[slot];
|
|
if (item && item.blockId === resultItemId) {
|
|
slotsWithSameItem.push({
|
|
slot: slot,
|
|
count: item.itemCount || 1,
|
|
hasSpace: (item.itemCount || 1) < 64,
|
|
});
|
|
}
|
|
}
|
|
|
|
const targetSlots = [];
|
|
let remainingCount = resultCount;
|
|
|
|
for (const slotInfo of slotsWithSameItem) {
|
|
if (slotInfo.hasSpace && remainingCount > 0) {
|
|
const spaceAvailable = 64 - slotInfo.count;
|
|
const amountToPlace = Math.min(spaceAvailable, remainingCount);
|
|
targetSlots.push({ slot: slotInfo.slot, amount: amountToPlace });
|
|
remainingCount -= amountToPlace;
|
|
}
|
|
}
|
|
|
|
if (remainingCount > 0) {
|
|
const hotbarSlots = isCraftingTable
|
|
? [37, 38, 39, 40, 41, 42, 43, 44, 45]
|
|
: [36, 37, 38, 39, 40, 41, 42, 43, 44];
|
|
for (const slot of hotbarSlots) {
|
|
if (remainingCount <= 0) break;
|
|
const item = inventoryToCheck[slot];
|
|
if (!item || item.blockId === -1) {
|
|
const amountToPlace = Math.min(64, remainingCount);
|
|
targetSlots.push({ slot: slot, amount: amountToPlace });
|
|
remainingCount -= amountToPlace;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (remainingCount > 0) {
|
|
const mainInvSlots = isCraftingTable
|
|
? [
|
|
10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
|
|
27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
|
|
]
|
|
: [
|
|
9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
|
|
26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
|
|
];
|
|
for (const slot of mainInvSlots) {
|
|
if (remainingCount <= 0) break;
|
|
const item = inventoryToCheck[slot];
|
|
if (!item || item.blockId === -1) {
|
|
const amountToPlace = Math.min(64, remainingCount);
|
|
targetSlots.push({ slot: slot, amount: amountToPlace });
|
|
remainingCount -= amountToPlace;
|
|
}
|
|
}
|
|
}
|
|
|
|
setTimeout(() => {
|
|
try {
|
|
client.javaClient.write("window_click", {
|
|
windowId: windowId,
|
|
slot: -999,
|
|
mouseButton: 0,
|
|
action: client.windowClickAction++,
|
|
mode: 0,
|
|
item: { blockId: -1, itemCount: 0, itemDamage: 0 },
|
|
});
|
|
if (debugLog) console.log("clicked slot -999");
|
|
} catch (err) {}
|
|
|
|
setTimeout(() => {
|
|
try {
|
|
client.javaClient.write("window_click", {
|
|
windowId: windowId,
|
|
slot: 0,
|
|
mouseButton: 0,
|
|
action: client.windowClickAction++,
|
|
mode: 1,
|
|
item: resultItem,
|
|
});
|
|
if (debugLog) console.log("shift clicked result");
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}, 1);
|
|
}, 1);
|
|
|
|
setTimeout(() => {
|
|
setTimeout(() => {
|
|
let foundPlanks = false;
|
|
for (let i = 9; i < 45; i++) {
|
|
const item = client.inventory[i];
|
|
if (item && item.blockId === 5) {
|
|
foundPlanks = true;
|
|
}
|
|
}
|
|
|
|
const inventoryToCheck =
|
|
windowId !== 0 &&
|
|
client._windowInventories &&
|
|
client._windowInventories[windowId]
|
|
? client._windowInventories[windowId]
|
|
: client.inventory;
|
|
|
|
if (debugLog) console.log("clearing grid slots", usedGridSlots);
|
|
usedGridSlots.forEach((gridSlot, index) => {
|
|
setTimeout(() => {
|
|
const gridItem = inventoryToCheck[gridSlot];
|
|
if (gridItem && gridItem.blockId !== -1) {
|
|
try {
|
|
client.javaClient.write("window_click", {
|
|
windowId: windowId,
|
|
slot: gridSlot,
|
|
mouseButton: 0,
|
|
action: client.windowClickAction++,
|
|
mode: 1,
|
|
item: gridItem,
|
|
});
|
|
if (debugLog) console.log("shift clicked grid", gridSlot);
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
} else {
|
|
if (debugLog) console.log("grid slot", gridSlot, "already empty");
|
|
}
|
|
}, index * 1);
|
|
});
|
|
}, 1);
|
|
}, 1);
|
|
|
|
setTimeout(() => {
|
|
if (debugLog) console.log("craft complete clearing flag");
|
|
client._craftingInProgress = false;
|
|
}, 200);
|
|
}
|
|
|
|
placeCraftingItems(
|
|
client,
|
|
windowId,
|
|
itemsToPlace,
|
|
inventoryWindow,
|
|
startAction,
|
|
) {
|
|
/* do nothing - but keep this here so nothing breaks */
|
|
}
|
|
|
|
sendInventoryUpdate(client) {
|
|
if (!client.inventory || !client.javaClient) {
|
|
return;
|
|
}
|
|
|
|
for (let i = 0; i < 45; i++) {
|
|
const item = client.inventory[i];
|
|
const PacketWriter = require("./packetwriter");
|
|
const slotWriter = new PacketWriter();
|
|
slotWriter.writeByte(0);
|
|
slotWriter.writeShort(i);
|
|
this.writeItem(slotWriter, item);
|
|
this.sendPacket(client, 0x67, slotWriter.toBuffer());
|
|
}
|
|
}
|
|
|
|
//LCE automatically accepts a trade, whilst java requires items in specific slots
|
|
//we should write a server plugin that handles this because lazy
|
|
handleTradeItem(client, data) {
|
|
/* do nothing */
|
|
}
|
|
|
|
handleContainerAck(client, data) {
|
|
const reader = new PacketReader(data.slice(1));
|
|
const windowId = reader.readByte();
|
|
const action = reader.readShort();
|
|
const accepted = reader.readBoolean();
|
|
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
client.javaClient.write("transaction", {
|
|
windowId: windowId,
|
|
action: action,
|
|
accepted: accepted,
|
|
});
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
}
|
|
|
|
handleContainerClick(client, data) {
|
|
const reader = new PacketReader(data.slice(1));
|
|
const containerId = reader.readByte();
|
|
const slotNum = reader.readShort();
|
|
const buttonNum = reader.readByte();
|
|
const uid = reader.readShort();
|
|
const clickType = reader.readByte();
|
|
|
|
const item = this.readItemWithNBT(reader);
|
|
|
|
if (client._bookGUI && containerId === client.openWindowId) {
|
|
if (slotNum === 48 && client._bookGUI.currentPage > 0) {
|
|
client._bookGUI.currentPage--;
|
|
this.updateBookGUIContents(client, containerId);
|
|
return;
|
|
}
|
|
|
|
if (
|
|
slotNum === 50 &&
|
|
client._bookGUI.currentPage < client._bookGUI.pages.length - 1
|
|
) {
|
|
client._bookGUI.currentPage++;
|
|
this.updateBookGUIContents(client, containerId);
|
|
return;
|
|
}
|
|
|
|
if (
|
|
client._bookGUI.clickActions &&
|
|
client._bookGUI.clickActions[slotNum]
|
|
) {
|
|
const action = client._bookGUI.clickActions[slotNum];
|
|
|
|
if (action.type === "run_command" && action.value) {
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
client.javaClient.write("chat", { message: action.value });
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
|
|
const PacketWriter = require("./packetwriter");
|
|
const writer = new PacketWriter();
|
|
writer.writeByte(containerId & 0xff);
|
|
this.sendPacket(client, 0x65, writer.toBuffer());
|
|
delete client._bookGUI;
|
|
}
|
|
}
|
|
|
|
const PacketWriter = require("./packetwriter");
|
|
const rejectWriter = new PacketWriter();
|
|
rejectWriter.writeByte(containerId & 0xff);
|
|
rejectWriter.writeShort(uid);
|
|
rejectWriter.writeBoolean(false);
|
|
this.sendPacket(client, 0x6a, rejectWriter.toBuffer());
|
|
return;
|
|
}
|
|
|
|
//0=Normal click
|
|
//1=Shift click
|
|
//2=Number key (hotbar swap)
|
|
//3=Middle click (creative)
|
|
//4=Drop
|
|
//5=Drag
|
|
//6=Double click
|
|
|
|
let javaItem = null;
|
|
if (item) {
|
|
const javaItemId = this.mapLCEItemToJava(item.blockId);
|
|
if (javaItemId !== null) {
|
|
javaItem = {
|
|
blockId: javaItemId,
|
|
itemCount: item.itemCount,
|
|
itemDamage: item.itemDamage,
|
|
};
|
|
if (item.nbt) {
|
|
javaItem.nbtData = this.convertLCENBTToJava(item.nbt);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
//luckily both LCE and java use slot -999 for dropping items outside inventory window
|
|
let finalMode = clickType;
|
|
let finalButton = buttonNum;
|
|
|
|
const clickPacket = {
|
|
windowId: containerId,
|
|
slot: slotNum,
|
|
mouseButton: finalButton,
|
|
action: uid,
|
|
mode: finalMode,
|
|
item: javaItem || { blockId: -1 },
|
|
};
|
|
client.javaClient.write("window_click", clickPacket);
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
}
|
|
|
|
handleSignUpdate(client, data) {
|
|
const reader = new PacketReader(data.slice(1));
|
|
const x = reader.readInt();
|
|
const y = reader.readShort();
|
|
const z = reader.readInt();
|
|
const verified = reader.readBoolean();
|
|
const censored = reader.readBoolean();
|
|
|
|
const text1 = reader.readUtf();
|
|
const text2 = reader.readUtf();
|
|
const text3 = reader.readUtf();
|
|
const text4 = reader.readUtf();
|
|
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
client.javaClient.write("update_sign", {
|
|
location: { x: x, y: y, z: z },
|
|
text1: JSON.stringify({ text: text1 }),
|
|
text2: JSON.stringify({ text: text2 }),
|
|
text3: JSON.stringify({ text: text3 }),
|
|
text4: JSON.stringify({ text: text4 }),
|
|
});
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
}
|
|
|
|
handleSetCreativeModeSlot(client, data) {
|
|
const reader = new PacketReader(data.slice(1));
|
|
const slotNum = reader.readShort();
|
|
const item = this.readItemWithNBT(reader);
|
|
|
|
let javaItem = null;
|
|
if (item) {
|
|
const javaItemId = this.mapLCEItemToJava(item.blockId);
|
|
if (javaItemId !== null) {
|
|
javaItem = {
|
|
blockId: javaItemId,
|
|
itemCount: item.itemCount,
|
|
itemDamage: item.itemDamage || 0,
|
|
};
|
|
if (item.nbt) {
|
|
javaItem.nbtData = this.convertLCENBTToJava(item.nbt);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
client.javaClient.write("set_creative_slot", {
|
|
slot: slotNum,
|
|
item: javaItem || { blockId: -1 },
|
|
});
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
}
|
|
|
|
handleClientCommand(client, data) {
|
|
const reader = new PacketReader(data.slice(1));
|
|
const action = reader.readByte();
|
|
|
|
if (action === 1) {
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
client.javaClient.write("client_command", {
|
|
payload: 0,
|
|
});
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
handleDisconnect(client, data) {
|
|
const reader = new PacketReader(data.slice(1));
|
|
const reason = reader.readInt();
|
|
|
|
if (this.clientChests.has(client)) {
|
|
const openChestKeys = this.clientChests.get(client);
|
|
for (const posKey of openChestKeys) {
|
|
const chestData = this.openChests.get(posKey);
|
|
if (chestData) {
|
|
chestData.clients.delete(client);
|
|
|
|
if (chestData.clients.size === 0) {
|
|
this.openChests.delete(posKey);
|
|
}
|
|
}
|
|
}
|
|
this.clientChests.delete(client);
|
|
}
|
|
|
|
this.removeClient(client);
|
|
|
|
if (client.socket && !client.socket.destroyed) {
|
|
client.socket.destroy();
|
|
}
|
|
}
|
|
|
|
handlePlayerMovement(client, packetId, data) {
|
|
const reader = new PacketReader(data.slice(1));
|
|
const dataSize = data.length - 1;
|
|
|
|
let x, y, yView, z, yRot, xRot, onGround;
|
|
|
|
switch (packetId) {
|
|
case 0x0b: //MovePlayerPacket (pos)
|
|
if (dataSize < 33) {
|
|
return;
|
|
}
|
|
x = reader.readDouble();
|
|
y = reader.readDouble();
|
|
yView = reader.readDouble();
|
|
z = reader.readDouble();
|
|
onGround = reader.readByte();
|
|
|
|
client.playerX = x;
|
|
client.playerY = y;
|
|
client.playerZ = z;
|
|
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
client.javaClient.write("position_look", {
|
|
x: x,
|
|
y: y,
|
|
z: z,
|
|
yaw: client.lastYaw || 0,
|
|
pitch: client.lastPitch || 0,
|
|
onGround: onGround !== 0,
|
|
});
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 0x0c: //MovePlayerPacket (rot)
|
|
if (dataSize < 9) {
|
|
return;
|
|
}
|
|
yRot = reader.readFloat();
|
|
xRot = reader.readFloat();
|
|
onGround = reader.readByte();
|
|
|
|
const normalizedYaw = normalizeYaw(yRot);
|
|
|
|
client.playerYaw = normalizedYaw;
|
|
client.playerPitch = xRot;
|
|
|
|
client.lastYaw = normalizedYaw;
|
|
client.lastPitch = xRot;
|
|
|
|
if (client.javaClient && client.javaClient.write) {
|
|
try {
|
|
client.javaClient.write("look", {
|
|
yaw: normalizedYaw,
|
|
pitch: xRot,
|
|
onGround: onGround !== 0,
|
|
});
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
readItem(reader) {
|
|
return readItem(reader);
|
|
}
|
|
|
|
readItemWithNBT(reader) {
|
|
const itemId = reader.readShort();
|
|
if (itemId === -1) {
|
|
return null;
|
|
}
|
|
const count = reader.readByte();
|
|
const damage = reader.readShort();
|
|
|
|
if (reader.offset + 2 > reader.buffer.length) {
|
|
return {
|
|
blockId: itemId,
|
|
itemCount: count,
|
|
itemDamage: damage,
|
|
nbt: null,
|
|
};
|
|
}
|
|
|
|
const nbtLength = reader.readShort();
|
|
|
|
let nbt = null;
|
|
if (nbtLength > 0 && reader.offset + nbtLength <= reader.buffer.length) {
|
|
const nbtBytes = reader.readBytes(nbtLength);
|
|
nbt = nbtBytes;
|
|
}
|
|
|
|
return {
|
|
blockId: itemId,
|
|
itemCount: count,
|
|
itemDamage: damage,
|
|
nbt: nbt,
|
|
};
|
|
}
|
|
|
|
convertLCENBTToJava(nbtBytes) {
|
|
try {
|
|
const zlib = require("zlib");
|
|
const decompressed = zlib.gunzipSync(nbtBytes);
|
|
const nbtReader = new PacketReader(decompressed);
|
|
const rootTag = this.readNBTTag(nbtReader);
|
|
return rootTag;
|
|
} catch (err) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
readNBTTag(reader) {
|
|
const type = reader.readByte();
|
|
if (type === 0) return null;
|
|
const name = reader.readUTF();
|
|
return this.readNBTPayload(reader, type, name);
|
|
}
|
|
|
|
readNBTPayload(reader, type, name) {
|
|
switch (type) {
|
|
case 1:
|
|
return { type: "byte", name, value: reader.readByte() };
|
|
case 2:
|
|
return { type: "short", name, value: reader.readShort() };
|
|
case 3:
|
|
return { type: "int", name, value: reader.readInt() };
|
|
case 8:
|
|
return { type: "string", name, value: reader.readUTF() };
|
|
case 9:
|
|
const listType = reader.readByte();
|
|
const listSize = reader.readInt();
|
|
const listItems = [];
|
|
for (let i = 0; i < listSize; i++) {
|
|
listItems.push(this.readNBTPayload(reader, listType, ""));
|
|
}
|
|
return {
|
|
type: "list",
|
|
name,
|
|
value: { type: listType, value: listItems },
|
|
};
|
|
case 10:
|
|
const compound = {};
|
|
while (true) {
|
|
const tagType = reader.readByte();
|
|
if (tagType === 0) break;
|
|
const tagName = reader.readUTF();
|
|
compound[tagName] = this.readNBTPayload(reader, tagType, tagName);
|
|
}
|
|
return { type: "compound", name, value: compound };
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
writeItemNBT(writer, item) {
|
|
return writeItemNBT(writer, item);
|
|
}
|
|
|
|
writeItem(writer, item) {
|
|
return writeItem(writer, item, this.mapJavaItemToLCE.bind(this));
|
|
}
|
|
|
|
sendPacket(client, packetId, payload) {
|
|
if (!this.validLCEPackets.has(packetId)) {
|
|
return;
|
|
}
|
|
|
|
if (!payload || !Buffer.isBuffer(payload)) {
|
|
return;
|
|
}
|
|
|
|
if (client.socket.destroyed) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const packetData = Buffer.concat([Buffer.from([packetId]), payload]);
|
|
const lengthPrefix = Buffer.allocUnsafe(4);
|
|
lengthPrefix.writeUInt32BE(packetData.length, 0);
|
|
|
|
const fullPacket = Buffer.concat([lengthPrefix, packetData]);
|
|
|
|
if (fullPacket.length > 1000000) {
|
|
return;
|
|
}
|
|
|
|
if (!client._packetQueue) {
|
|
client._packetQueue = [];
|
|
client._sending = false;
|
|
}
|
|
|
|
client._packetQueue.push(fullPacket);
|
|
|
|
if (!client._sending) {
|
|
client._sending = true;
|
|
setImmediate(() => {
|
|
while (client._packetQueue.length > 0 && !client.socket.destroyed) {
|
|
const pkt = client._packetQueue.shift();
|
|
client.socket.write(pkt);
|
|
}
|
|
client._sending = false;
|
|
});
|
|
}
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
|
|
disconnectClient(client, reason = 0) {
|
|
const reasonMap = {
|
|
0: "Generic disconnect",
|
|
2: "Connection lost",
|
|
10: "Kicked/Banned",
|
|
20: "Timeout",
|
|
23: "Server full",
|
|
};
|
|
const reasonText = reasonMap[reason] || `Unknown (${reason})`;
|
|
|
|
if (client.socket && !client.socket.destroyed) {
|
|
try {
|
|
const writer = new PacketWriter();
|
|
writer.writeInt(reason);
|
|
this.sendPacket(client, 0xff, writer.toBuffer());
|
|
setTimeout(() => {
|
|
this.removeClient(client);
|
|
}, 100);
|
|
return;
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
this.removeClient(client);
|
|
}
|
|
|
|
removeClient(client) {
|
|
if (client._removing) {
|
|
return;
|
|
}
|
|
client._removing = true;
|
|
|
|
if (this.clientChests.has(client)) {
|
|
const openChestKeys = this.clientChests.get(client);
|
|
for (const posKey of openChestKeys) {
|
|
const chestData = this.openChests.get(posKey);
|
|
if (chestData) {
|
|
chestData.clients.delete(client);
|
|
|
|
if (chestData.clients.size === 0) {
|
|
this.openChests.delete(posKey);
|
|
}
|
|
}
|
|
}
|
|
this.clientChests.delete(client);
|
|
}
|
|
|
|
const index = this.clients.indexOf(client);
|
|
if (index > -1) {
|
|
this.clients.splice(index, 1);
|
|
}
|
|
|
|
if (client.smallId !== undefined) {
|
|
this.usedSmallIds.delete(client.smallId);
|
|
}
|
|
|
|
if (client.javaClient) {
|
|
const oldJavaClient = client.javaClient;
|
|
client.javaClient = null;
|
|
|
|
oldJavaClient.removeAllListeners();
|
|
oldJavaClient.on("error", () => {
|
|
/* do nothing */
|
|
});
|
|
try {
|
|
oldJavaClient.end();
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
|
|
if (client.socket && !client.socket.destroyed) {
|
|
try {
|
|
client.socket.destroy();
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
}
|
|
|
|
async connectToJavaServer(client) {
|
|
try {
|
|
return await connectToJavaServerFunc(this, client);
|
|
} catch (err) {
|
|
/* do nothing */
|
|
}
|
|
}
|
|
|
|
stop() {
|
|
if (this.broadcastInterval) {
|
|
clearInterval(this.broadcastInterval);
|
|
}
|
|
|
|
if (this.udpSocket) {
|
|
this.udpSocket.close();
|
|
}
|
|
|
|
if (this.tcpServers && this.tcpServers.length > 0) {
|
|
this.tcpServers.forEach((server) => server.close());
|
|
}
|
|
|
|
this.clients.forEach((client) => {
|
|
this.disconnectClient(client, 2);
|
|
});
|
|
}
|
|
}
|
|
|
|
module.exports = LCEProxy;
|
|
/* --------------------------------------------------------------- */
|