function createProtocol() {
var proto = new ProtoDef();
proto.addTypes(require('../datatypes/minecraft'));
proto.addTypes(protocol);
return proto;
}
function createProtocol(state,direction,version,customPackets)
{
const proto = new ProtoDef();
proto.addTypes(minecraft);
const mcData=require("minecraft-data")(version);
recursiveAddTypes(proto,merge(mcData.protocol,get(customPackets,[mcData.version.majorVersion])),[state,direction]);
return proto;
}
function writeChannel (channel, params) {
debug('write custom payload ' + channel + ' ' + params)
client.write('custom_payload', {
channel: channel,
data: proto.createPacketBuffer(channel, params)
})
}
function registerChannel (name, parser, custom) {
if (custom) {
client.writeChannel('REGISTER', name)
}
if (parser) proto.addType(name, parser)
channels.push(name)
if (channels.length === 1) { client.on('custom_payload', onCustomPayload) }
}
test.subtypes.forEach((subtype, i) => {
var type = test.type + "_" + i;
proto.addType(type, subtype.type);
subtype.values = transformValues(test.type, subtype.values);
subtype.type = type;
subTypes.push(subtype);
});
client.writeBatch=function(packets) {
const payload=zlib.deflateSync(batchProto.createPacketBuffer("insideBatch",
packets.map(packet =>
client.encapsulatedPacketSerializer.createPacketBuffer(packet).slice(1))));
client.writeMCPE("batch",{
payload:payload
});
}
function onCustomPayload(packet) {
var channel = channels.find(function(channel) {
return channel === packet.channel;
});
if (channel) {
if (proto.types[channel])
packet.data = proto.parsePacketBuffer(channel, packet.data).data;
client.emit(channel, packet.data);
}
}
function onCustomPayload (packet) {
const channel = channels.find(function (channel) {
return channel === packet.channel
})
if (channel) {
if (proto.types[channel]) { packet.data = proto.parsePacketBuffer(channel, packet.data).data }
debug('read custom payload ' + channel + ' ' + packet.data)
client.emit(channel, packet.data)
}
}
module.exports = function(client, options) {
var mcdata = require('minecraft-data')(options.version);
var channels = [];
var proto = new ProtoDef();
proto.addTypes(mcdata.protocol.types);
proto.addTypes(minecraft);
client.registerChannel = registerChannel;
client.unregisterChannel = unregisterChannel;
return client;
function registerChannel(name, parser) {
if (parser) proto.addType(name, parser);
channels.push(name);
if (channels.length === 1)
client.on('custom_payload', onCustomPayload);
}
function unregisterChannel(channel) {
var index = channels.find(function(name) {
return channel === name;
});
if (index) {
proto.types[channel] = undefined;
channels.splice(index, 1);
if (channels.length === 0)
client.removeListener('custom_payload', onCustomPayload);
}
}
function onCustomPayload(packet) {
var channel = channels.find(function(channel) {
return channel === packet.channel;
});
if (channel) {
if (proto.types[channel])
packet.data = proto.parsePacketBuffer(channel, packet.data).data;
client.emit(channel, packet.data);
}
}
};
'use strict';
const assert = require('assert');
const raknet = require('raknet');
const fs = require('fs');
const path = require('path');
const zlib = require('zlib');
const ProtoDef = require('protodef').ProtoDef;
const batchProto=new ProtoDef();
batchProto.addTypes(require("./datatypes/minecraft"));
batchProto.addType("insideBatch",["endOfArray",{"type":["buffer",{"countType":"i32"}]}]);
function createClient(options) {
assert.ok(options, 'options is required');
var port = options.port || 19132;
var host = options.host || 'localhost';
assert.ok(options.username, 'username is required');
options.customPackets=require('../data/protocol');
options.customTypes=require('./datatypes/minecraft');
var client=raknet.createClient(options);
client.username = options.username;
client.on('mcpe',packet => client.emit(packet.name,packet.params))
client.writeMCPE=(name,packet) => {
client.writeEncapsulated('mcpe',{
name:name,
params:packet
});
};
function createProto(le) {
var proto = new ProtoDef();
proto.addType("compound",compound);
proto.addTypes(JSON.parse(le ? leNbtJson : nbtJson));
return proto;
}
module.exports = function (client, options) {
const mcdata = require('minecraft-data')(options.version || require('../version').defaultVersion)
const channels = []
const proto = new ProtoDef()
proto.addTypes(mcdata.protocol.types)
proto.addTypes(minecraft)
proto.addType('registerarr', [readDumbArr, writeDumbArr, sizeOfDumbArr])
client.registerChannel = registerChannel
client.unregisterChannel = unregisterChannel
client.writeChannel = writeChannel
client.registerChannel('REGISTER', ['registerarr', []])
client.registerChannel('UNREGISTER', ['registerarr', []])
function registerChannel (name, parser, custom) {
if (custom) {
client.writeChannel('REGISTER', name)
}
if (parser) proto.addType(name, parser)
channels.push(name)
if (channels.length === 1) { client.on('custom_payload', onCustomPayload) }
}
function unregisterChannel (channel, custom) {
if (custom) {
client.writeChannel('UNREGISTER', channel)
}
const index = channels.find(function (name) {
return channel === name
})
if (index) {
proto.types[channel] = undefined
channels.splice(index, 1)
if (channels.length === 0) { client.removeListener('custom_payload', onCustomPayload) }
}
}
function onCustomPayload (packet) {
const channel = channels.find(function (channel) {
return channel === packet.channel
})
if (channel) {
if (proto.types[channel]) { packet.data = proto.parsePacketBuffer(channel, packet.data).data }
debug('read custom payload ' + channel + ' ' + packet.data)
client.emit(channel, packet.data)
}
}
function writeChannel (channel, params) {
debug('write custom payload ' + channel + ' ' + params)
client.write('custom_payload', {
channel: channel,
data: proto.createPacketBuffer(channel, params)
})
}
function readDumbArr (buf, offset) {
const ret = {
value: [],
size: 0
}
let results
while (offset < buf.length) {
if (buf.indexOf(0x0, offset) === -1) { results = this.read(buf, offset, 'restBuffer', {}) } else { results = this.read(buf, offset, 'cstring', {}) }
ret.size += results.size
ret.value.push(results.value.toString())
offset += results.size
}
return ret
}
function writeDumbArr (value, buf, offset) {
// TODO: Remove trailing \0
value.forEach(function (v) {
offset += this.write(v, buf, offset, 'cstring', {})
})
return offset
}
function sizeOfDumbArr (value) {
return value.reduce((acc, v) => acc + this.sizeOf(v, 'cstring', {}), 0)
}
}
"name": "params",
"type": [
"switch",
{
"compareTo": "name",
"fields": {
"entity_look": "entity_look"
}
}
]
}
]
]
};
var proto = new ProtoDef();
proto.addTypes(example_protocol);
var parser = new Parser(proto, "packet");
var serializer = new Serializer(proto, "packet");
serializer.write({
name: "entity_look",
params: {
"entityId": 1,
"yaw": 1,
"pitch": 1,
"onGround": true
}
});
serializer.pipe(parser);
function parseUncompressed(data) {
return proto.parsePacketBuffer("nbt",data).data;
}
function writeUncompressed(value) {
return proto.createPacketBuffer("nbt",value);
}
var zlib = require('zlib');
var hasGzipHeader = function(data){
var result=true;
if(data[0]!=0x1f) result=false;
if(data[1]!=0x8b) result=false;
return result;
};
var ProtoDef=require("protodef").ProtoDef;
var proto=new ProtoDef();
proto.addType("compound",require("./compound").compound);
proto.addTypes(require("./nbt.json"));
function writeUncompressed(value) {
return proto.createPacketBuffer("nbt",value);
}
function parseUncompressed(data) {
return proto.parsePacketBuffer("nbt",data).data;
}
function parse(data, callback) {
if (hasGzipHeader(data)) {
zlib.gunzip(data, function(error, uncompressed) {
if (error) {
callback(error, data);
} else {
callback(null, parseUncompressed(uncompressed));
}
client.on('batch', function(packet) {
var buf = zlib.inflateSync(packet.payload);
var packets=batchProto.parsePacketBuffer("insideBatch",buf).data;
packets.forEach(packet => client.readEncapsulatedPacket(Buffer.concat([new Buffer([0x8e]),packet])));
});
const ProtoDef = require('protodef').ProtoDef
const Serializer = require('protodef').Serializer
const Parser = require('protodef').Parser
const exampleProtocol = require('./full_protocol_example.json')
const proto = new ProtoDef()
proto.addProtocol(exampleProtocol, ['login', 'toClient'])
const parser = new Parser(proto, 'packet')
const serializer = new Serializer(proto, 'packet')
serializer.write({
name: 'success',
params: {
'uuid': 'some uuid',
'username': '******'
}
})
parser.on('error', function (err) {
console.log(err.stack)
console.log(err.buffer)
})
serializer.pipe(parser)
parser.on('data', function (chunk) {
console.log(JSON.stringify(chunk.data, null, 2))
})
function registerChannel(name, parser) {
if (parser) proto.addType(name, parser);
channels.push(name);
if (channels.length === 1)
client.on('custom_payload', onCustomPayload);
}