RepoMirrors
/
basin
mirror of https://github.com/basinserver/basin/
1
0
Fork 0
Code Issues Releases Wiki Activity
basin/src/packet.c

2026 lines
87 KiB
C
Raw Blame History

#include "basin/packet.h"
#include <basin/globals.h>
#include <basin/inventory.h>
#include <basin/network.h>
#include <basin/nbt.h>
#include <basin/connection.h>
#include <basin/world.h>
#include <basin/player.h>
#include <avuna/string.h>
#include <stdint.h>
#include <zlib.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <zlib.h>
#include <errno.h>
#include <string.h>
#include <pthread.h>
#include <time.h>
#include <math.h>
struct packet* packet_new(struct mempool* pool, int32_t id) {
struct packet* packet = pcalloc(pool, sizeof(struct packet));
packet->pool = pool;
packet->id = id;
return packet;
}
#define ADRX if(rx == 0) goto rer;pbuf += rx;ps -= rx;
#define ADX(x) pbuf += x;ps -= x;
#define CPS(x) if(ps < x) goto rer;
#define CPS_OPT(x) if(ps >= x) {
#define ENS(x) if(ps-pi < x) { ps += (x > 256 ? x + 1024 : 1024); pktbuf = prealloc(packet->pool, pktbuf - 10, ps + 10) + 10; }
ssize_t packet_read(struct connection* conn, unsigned char* buf, size_t buflen, struct packet* packet) {
void* pktbuf = buf;
int32_t pktlen = (int32_t) buflen;
if (conn->compression_state >= 0) {
int32_t decompressed_length = 0;
int read_length = readVarInt(&decompressed_length, pktbuf, buflen);
if (read_length == 0) goto rer;
pktlen -= read_length;
pktbuf += read_length;
if (decompressed_length > 0 && pktlen > 0) {
pktlen = decompressed_length;
void* decompressed = pmalloc(packet->pool, (size_t) decompressed_length);
z_stream strm;
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
strm.opaque = Z_NULL;
int dr = 0;
if ((dr = inflateInit(&strm)) != Z_OK) {
errlog(conn->server->logger, "Compression initialization error!\n");
goto rer;
}
strm.avail_in = (uInt) pktlen;
strm.next_in = pktbuf;
strm.avail_out = (uInt) decompressed_length;
strm.next_out = decompressed;
do {
dr = inflate(&strm, Z_FINISH);
if (dr == Z_STREAM_ERROR) {
printf("Compression Read Error\n");
goto rer;
}
strm.avail_out = (uInt) (pktlen - strm.total_out);
strm.next_out = decompressed + strm.total_out;
} while (strm.avail_in > 0 || strm.total_out < pktlen);
inflateEnd(&strm);
pktbuf = decompressed;
pktlen = decompressed_length;
}
}
if (pktbuf == NULL) return 0;
unsigned char* pbuf = (unsigned char*) pktbuf;
size_t ps = (size_t) pktlen;
int32_t id = 0;
size_t t = (size_t) readVarInt(&id, pbuf, ps);
pbuf += t;
ps -= t;
packet->id = id;
int rx = 0;
if (conn->protocol_state == STATE_HANDSHAKE) {
if (id == PKT_HANDSHAKE_SERVER_HANDSHAKE) {
//protocol_version
rx = readVarInt(&packet->data.handshake_server.handshake.protocol_version, pbuf, ps);
ADRX
//server_address
rx = readString(packet->pool, &packet->data.handshake_server.handshake.server_address, pbuf, ps);
ADRX
//server_port
CPS(2)
memcpy(&packet->data.handshake_server.handshake.server_port, pbuf, 2);
swapEndian(&packet->data.handshake_server.handshake.server_port, 2);
ADX(2)
//next_state
rx = readVarInt(&packet->data.handshake_server.handshake.next_state, pbuf, ps);
ADRX
}
} else if (conn->protocol_state == STATE_PLAY) {
if (id == PKT_PLAY_SERVER_TELEPORTCONFIRM) {
//teleport_id
rx = readVarInt(&packet->data.play_server.teleportconfirm.teleport_id, pbuf, ps);
ADRX
} else if (id == PKT_PLAY_SERVER_TABCOMPLETE) {
//text
rx = readString(packet->pool, &packet->data.play_server.tabcomplete.text, pbuf, ps);
ADRX
//assume_command
CPS(1)
memcpy(&packet->data.play_server.tabcomplete.assume_command, pbuf, 1);
ADX(1)
//has_position
CPS(1)
memcpy(&packet->data.play_server.tabcomplete.has_position, pbuf, 1);
ADX(1)
//looked_at_block
CPS_OPT(8)
memcpy(&packet->data.play_server.tabcomplete.looked_at_block, pbuf, 8);
swapEndian(&packet->data.play_server.tabcomplete.looked_at_block, 8);
ADX(8)
}
} else if (id == PKT_PLAY_SERVER_CHATMESSAGE) {
//message
rx = readString(packet->pool, &packet->data.play_server.chatmessage.message, pbuf, ps);
ADRX
} else if (id == PKT_PLAY_SERVER_CLIENTSTATUS) {
//action_id
rx = readVarInt(&packet->data.play_server.clientstatus.action_id, pbuf, ps);
ADRX
} else if (id == PKT_PLAY_SERVER_CLIENTSETTINGS) {
//locale
rx = readString(packet->pool, &packet->data.play_server.clientsettings.locale, pbuf, ps);
ADRX
//view_distance
CPS(1)
memcpy(&packet->data.play_server.clientsettings.view_distance, pbuf, 1);
ADX(1)
//chat_mode
rx = readVarInt(&packet->data.play_server.clientsettings.chat_mode, pbuf, ps);
ADRX
//chat_colors
CPS(1)
memcpy(&packet->data.play_server.clientsettings.chat_colors, pbuf, 1);
ADX(1)
//displayed_skin_parts
CPS(1)
memcpy(&packet->data.play_server.clientsettings.displayed_skin_parts, pbuf, 1);
ADX(1)
//main_hand
rx = readVarInt(&packet->data.play_server.clientsettings.main_hand, pbuf, ps);
ADRX
} else if (id == PKT_PLAY_SERVER_CONFIRMTRANSACTION) {
//window_id
CPS(1)
memcpy(&packet->data.play_server.confirmtransaction.window_id, pbuf, 1);
ADX(1)
//action_number
CPS(2)
memcpy(&packet->data.play_server.confirmtransaction.action_number, pbuf, 2);
swapEndian(&packet->data.play_server.confirmtransaction.action_number, 2);
ADX(2)
//accepted
CPS(1)
memcpy(&packet->data.play_server.confirmtransaction.accepted, pbuf, 1);
ADX(1)
} else if (id == PKT_PLAY_SERVER_ENCHANTITEM) {
//window_id
CPS(1)
memcpy(&packet->data.play_server.enchantitem.window_id, pbuf, 1);
ADX(1)
//enchantment
CPS(1)
memcpy(&packet->data.play_server.enchantitem.enchantment, pbuf, 1);
ADX(1)
} else if (id == PKT_PLAY_SERVER_CLICKWINDOW) {
//window_id
CPS(1)
memcpy(&packet->data.play_server.clickwindow.window_id, pbuf, 1);
ADX(1)
//slot
CPS(2)
memcpy(&packet->data.play_server.clickwindow.slot, pbuf, 2);
swapEndian(&packet->data.play_server.clickwindow.slot, 2);
ADX(2)
//button
CPS(1)
memcpy(&packet->data.play_server.clickwindow.button, pbuf, 1);
ADX(1)
//action_number
CPS(2)
memcpy(&packet->data.play_server.clickwindow.action_number, pbuf, 2);
swapEndian(&packet->data.play_server.clickwindow.action_number, 2);
ADX(2)
//mode
rx = readVarInt(&packet->data.play_server.clickwindow.mode, pbuf, ps);
ADRX
//clicked_item
rx = readSlot(packet->pool, &packet->data.play_server.clickwindow.clicked_item, pbuf, ps);
ADRX
} else if (id == PKT_PLAY_SERVER_CLOSEWINDOW) {
//window_id
CPS(1)
memcpy(&packet->data.play_server.closewindow.window_id, pbuf, 1);
ADX(1)
} else if (id == PKT_PLAY_SERVER_PLUGINMESSAGE) {
//channel
rx = readString(packet->pool, &packet->data.play_server.pluginmessage.channel, pbuf, ps);
ADRX
//data
CPS(ps)
packet->data.play_server.pluginmessage.data = pmalloc(packet->pool, ps);
memcpy(packet->data.play_server.pluginmessage.data, pbuf, ps);
ADX(ps)
} else if (id == PKT_PLAY_SERVER_USEENTITY) {
//target
rx = readVarInt(&packet->data.play_server.useentity.target, pbuf, ps);
ADRX
//type
rx = readVarInt(&packet->data.play_server.useentity.type, pbuf, ps);
ADRX
//target_x
CPS_OPT(4)
memcpy(&packet->data.play_server.useentity.target_x, pbuf, 4);
swapEndian(&packet->data.play_server.useentity.target_x, 4);
ADX(4)
}
//target_y
CPS_OPT(4)
memcpy(&packet->data.play_server.useentity.target_y, pbuf, 4);
swapEndian(&packet->data.play_server.useentity.target_y, 4);
ADX(4)
}
//target_z
CPS_OPT(4)
memcpy(&packet->data.play_server.useentity.target_z, pbuf, 4);
swapEndian(&packet->data.play_server.useentity.target_z, 4);
ADX(4)
}
//hand
CPS_OPT(1)
rx = readVarInt(&packet->data.play_server.useentity.hand, pbuf, ps);
ADRX
}
} else if (id == PKT_PLAY_SERVER_KEEPALIVE) {
//keep_alive_id
rx = readVarInt(&packet->data.play_server.keepalive.keep_alive_id, pbuf, ps);
ADRX
} else if (id == PKT_PLAY_SERVER_PLAYERPOSITION) {
//x
CPS(8)
memcpy(&packet->data.play_server.playerposition.x, pbuf, 8);
swapEndian(&packet->data.play_server.playerposition.x, 8);
ADX(8)
//feet_y
CPS(8)
memcpy(&packet->data.play_server.playerposition.feet_y, pbuf, 8);
swapEndian(&packet->data.play_server.playerposition.feet_y, 8);
ADX(8)
//z
CPS(8)
memcpy(&packet->data.play_server.playerposition.z, pbuf, 8);
swapEndian(&packet->data.play_server.playerposition.z, 8);
ADX(8)
//on_ground
CPS(1)
memcpy(&packet->data.play_server.playerposition.on_ground, pbuf, 1);
ADX(1)
} else if (id == PKT_PLAY_SERVER_PLAYERPOSITIONANDLOOK) {
//x
CPS(8)
memcpy(&packet->data.play_server.playerpositionandlook.x, pbuf, 8);
swapEndian(&packet->data.play_server.playerpositionandlook.x, 8);
ADX(8)
//feet_y
CPS(8)
memcpy(&packet->data.play_server.playerpositionandlook.feet_y, pbuf, 8);
swapEndian(&packet->data.play_server.playerpositionandlook.feet_y, 8);
ADX(8)
//z
CPS(8)
memcpy(&packet->data.play_server.playerpositionandlook.z, pbuf, 8);
swapEndian(&packet->data.play_server.playerpositionandlook.z, 8);
ADX(8)
//yaw
CPS(4)
memcpy(&packet->data.play_server.playerpositionandlook.yaw, pbuf, 4);
swapEndian(&packet->data.play_server.playerpositionandlook.yaw, 4);
ADX(4)
//pitch
CPS(4)
memcpy(&packet->data.play_server.playerpositionandlook.pitch, pbuf, 4);
swapEndian(&packet->data.play_server.playerpositionandlook.pitch, 4);
ADX(4)
//on_ground
CPS(1)
memcpy(&packet->data.play_server.playerpositionandlook.on_ground, pbuf, 1);
ADX(1)
} else if (id == PKT_PLAY_SERVER_PLAYERLOOK) {
//yaw
CPS(4)
memcpy(&packet->data.play_server.playerlook.yaw, pbuf, 4);
swapEndian(&packet->data.play_server.playerlook.yaw, 4);
ADX(4)
//pitch
CPS(4)
memcpy(&packet->data.play_server.playerlook.pitch, pbuf, 4);
swapEndian(&packet->data.play_server.playerlook.pitch, 4);
ADX(4)
//on_ground
CPS(1)
memcpy(&packet->data.play_server.playerlook.on_ground, pbuf, 1);
ADX(1)
} else if (id == PKT_PLAY_SERVER_PLAYER) {
//on_ground
CPS(1)
memcpy(&packet->data.play_server.player.on_ground, pbuf, 1);
ADX(1)
} else if (id == PKT_PLAY_SERVER_VEHICLEMOVE) {
//x
CPS(8)
memcpy(&packet->data.play_server.vehiclemove.x, pbuf, 8);
swapEndian(&packet->data.play_server.vehiclemove.x, 8);
ADX(8)
//y
CPS(8)
memcpy(&packet->data.play_server.vehiclemove.y, pbuf, 8);
swapEndian(&packet->data.play_server.vehiclemove.y, 8);
ADX(8)
//z
CPS(8)
memcpy(&packet->data.play_server.vehiclemove.z, pbuf, 8);
swapEndian(&packet->data.play_server.vehiclemove.z, 8);
ADX(8)
//yaw
CPS(4)
memcpy(&packet->data.play_server.vehiclemove.yaw, pbuf, 4);
swapEndian(&packet->data.play_server.vehiclemove.yaw, 4);
ADX(4)
//pitch
CPS(4)
memcpy(&packet->data.play_server.vehiclemove.pitch, pbuf, 4);
swapEndian(&packet->data.play_server.vehiclemove.pitch, 4);
ADX(4)
} else if (id == PKT_PLAY_SERVER_STEERBOAT) {
//right_paddle_turning
CPS(1)
memcpy(&packet->data.play_server.steerboat.right_paddle_turning, pbuf, 1);
ADX(1)
//left_paddle_turning
CPS(1)
memcpy(&packet->data.play_server.steerboat.left_paddle_turning, pbuf, 1);
ADX(1)
} else if (id == PKT_PLAY_SERVER_PLAYERABILITIES) {
//flags
CPS(1)
memcpy(&packet->data.play_server.playerabilities.flags, pbuf, 1);
ADX(1)
//flying_speed
CPS(4)
memcpy(&packet->data.play_server.playerabilities.flying_speed, pbuf, 4);
swapEndian(&packet->data.play_server.playerabilities.flying_speed, 4);
ADX(4)
//walking_speed
CPS(4)
memcpy(&packet->data.play_server.playerabilities.walking_speed, pbuf, 4);
swapEndian(&packet->data.play_server.playerabilities.walking_speed, 4);
ADX(4)
} else if (id == PKT_PLAY_SERVER_PLAYERDIGGING) {
//status
rx = readVarInt(&packet->data.play_server.playerdigging.status, pbuf, ps);
ADRX
//location
CPS(8)
memcpy(&packet->data.play_server.playerdigging.location, pbuf, 8);
swapEndian(&packet->data.play_server.playerdigging.location, 8);
ADX(8)
//face
CPS(1)
memcpy(&packet->data.play_server.playerdigging.face, pbuf, 1);
ADX(1)
} else if (id == PKT_PLAY_SERVER_ENTITYACTION) {
//entity_id
rx = readVarInt(&packet->data.play_server.entityaction.entity_id, pbuf, ps);
ADRX
//action_id
rx = readVarInt(&packet->data.play_server.entityaction.action_id, pbuf, ps);
ADRX
//jump_boost
rx = readVarInt(&packet->data.play_server.entityaction.jump_boost, pbuf, ps);
ADRX
} else if (id == PKT_PLAY_SERVER_STEERVEHICLE) {
//sideways
CPS(4)
memcpy(&packet->data.play_server.steervehicle.sideways, pbuf, 4);
swapEndian(&packet->data.play_server.steervehicle.sideways, 4);
ADX(4)
//forward
CPS(4)
memcpy(&packet->data.play_server.steervehicle.forward, pbuf, 4);
swapEndian(&packet->data.play_server.steervehicle.forward, 4);
ADX(4)
//flags
CPS(1)
memcpy(&packet->data.play_server.steervehicle.flags, pbuf, 1);
ADX(1)
} else if (id == PKT_PLAY_SERVER_RESOURCEPACKSTATUS) {
//result
rx = readVarInt(&packet->data.play_server.resourcepackstatus.result, pbuf, ps);
ADRX
} else if (id == PKT_PLAY_SERVER_HELDITEMCHANGE) {
//slot
CPS(2)
memcpy(&packet->data.play_server.helditemchange.slot, pbuf, 2);
swapEndian(&packet->data.play_server.helditemchange.slot, 2);
ADX(2)
} else if (id == PKT_PLAY_SERVER_CREATIVEINVENTORYACTION) {
//slot
CPS(2)
memcpy(&packet->data.play_server.creativeinventoryaction.slot, pbuf, 2);
swapEndian(&packet->data.play_server.creativeinventoryaction.slot, 2);
ADX(2)
//clicked_item
rx = readSlot(packet->pool, &packet->data.play_server.creativeinventoryaction.clicked_item, pbuf, ps);
ADRX
} else if (id == PKT_PLAY_SERVER_UPDATESIGN) {
//location
CPS(8)
memcpy(&packet->data.play_server.updatesign.location, pbuf, 8);
swapEndian(&packet->data.play_server.updatesign.location, 8);
ADX(8)
//line_1
rx = readString(packet->pool, &packet->data.play_server.updatesign.line_1, pbuf, ps);
ADRX
//line_2
rx = readString(packet->pool, &packet->data.play_server.updatesign.line_2, pbuf, ps);
ADRX
//line_3
rx = readString(packet->pool, &packet->data.play_server.updatesign.line_3, pbuf, ps);
ADRX
//line_4
rx = readString(packet->pool, &packet->data.play_server.updatesign.line_4, pbuf, ps);
ADRX
} else if (id == PKT_PLAY_SERVER_ANIMATION) {
//hand
rx = readVarInt(&packet->data.play_server.animation.hand, pbuf, ps);
ADRX
} else if (id == PKT_PLAY_SERVER_SPECTATE) {
//target_player
CPS(16)
memcpy(&packet->data.play_server.spectate.target_player, pbuf, 16);
swapEndian(&packet->data.play_server.spectate.target_player, 16);
ADX(16)
} else if (id == PKT_PLAY_SERVER_PLAYERBLOCKPLACEMENT) {
//location
CPS(8)
memcpy(&packet->data.play_server.playerblockplacement.location, pbuf, 8);
swapEndian(&packet->data.play_server.playerblockplacement.location, 8);
ADX(8)
//face
rx = readVarInt(&packet->data.play_server.playerblockplacement.face, pbuf, ps);
ADRX
//hand
rx = readVarInt(&packet->data.play_server.playerblockplacement.hand, pbuf, ps);
ADRX
//cursor_position_x
if (conn->protocol_version > 210) {
CPS(4)
memcpy(&packet->data.play_server.playerblockplacement.cursor_position_x, pbuf, 4);
swapEndian(&packet->data.play_server.playerblockplacement.cursor_position_x, 4);
ADX(4)
} else {
CPS(1)
uint8_t tmp = (uint8_t)(packet->data.play_server.playerblockplacement.cursor_position_x * 15.);
memcpy(&tmp, pbuf, 1);
ADX(1)
}
//cursor_position_y
if (conn->protocol_version > 210) {
CPS(4)
memcpy(&packet->data.play_server.playerblockplacement.cursor_position_y, pbuf, 4);
swapEndian(&packet->data.play_server.playerblockplacement.cursor_position_y, 4);
ADX(4)
} else {
CPS(1)
uint8_t tmp = (uint8_t)(packet->data.play_server.playerblockplacement.cursor_position_y * 15.);
memcpy(&tmp, pbuf, 1);
ADX(1)
}
//cursor_position_z
if (conn->protocol_version > 210) {
CPS(4)
memcpy(&packet->data.play_server.playerblockplacement.cursor_position_z, pbuf, 4);
swapEndian(&packet->data.play_server.playerblockplacement.cursor_position_z, 4);
ADX(4)
} else {
CPS(1)
uint8_t tmp = (uint8_t)(packet->data.play_server.playerblockplacement.cursor_position_z * 15.);
memcpy(&tmp, pbuf, 1);
ADX(1)
}
} else if (id == PKT_PLAY_SERVER_USEITEM) {
//hand
rx = readVarInt(&packet->data.play_server.useitem.hand, pbuf, ps);
ADRX
}
} else if (conn->protocol_state == STATE_STATUS) {
if (id == PKT_STATUS_SERVER_REQUEST) {
} else if (id == PKT_STATUS_SERVER_PING) {
//payload
CPS(8)
memcpy(&packet->data.status_server.ping.payload, pbuf, 8);
swapEndian(&packet->data.status_server.ping.payload, 8);
ADX(8)
}
} else if (conn->protocol_state == STATE_LOGIN) {
if (id == PKT_LOGIN_SERVER_LOGINSTART) {
//name
rx = readString(packet->pool, &packet->data.login_server.loginstart.name, pbuf, ps);
ADRX
} else if (id == PKT_LOGIN_SERVER_ENCRYPTIONRESPONSE) {
//shared_secret_length
rx = readVarInt(&packet->data.login_server.encryptionresponse.shared_secret_length, pbuf, ps);
ADRX
//shared_secret
CPS(packet->data.login_server.encryptionresponse.shared_secret_length)
packet->data.login_server.encryptionresponse.shared_secret = pmalloc(packet->pool,
(size_t) packet->data.login_server.encryptionresponse.shared_secret_length);
memcpy(packet->data.login_server.encryptionresponse.shared_secret, pbuf,
(size_t) packet->data.login_server.encryptionresponse.shared_secret_length);
ADX(packet->data.login_server.encryptionresponse.shared_secret_length)
//verify_token_length
rx = readVarInt((int32_t*) &packet->data.login_server.encryptionresponse.verify_token_length, pbuf, ps);
ADRX
//verify_token
CPS(packet->data.login_server.encryptionresponse.verify_token_length)
packet->data.login_server.encryptionresponse.verify_token = pmalloc(packet->pool, packet->data.login_server.encryptionresponse.verify_token_length);
memcpy(packet->data.login_server.encryptionresponse.verify_token, pbuf, packet->data.login_server.encryptionresponse.verify_token_length);
ADX(packet->data.login_server.encryptionresponse.verify_token_length)
}
}
goto rx;
rer: ;
pfree(packet->pool);
return -1;
rx: ;
pfree(packet->pool);
return buflen;
}
ssize_t packet_write(struct connection* conn, struct packet* packet) {
if (conn->protocol_state == STATE_PLAY && packet->id == PKT_PLAY_CLIENT_CHUNKDATA) {
if (world_get_chunk(conn->player->world, packet->data.play_client.chunkdata.cx, packet->data.play_client.chunkdata.cz) == NULL) return 0;
}
unsigned char* pktbuf = pmalloc(packet->pool, 522);
pktbuf += 10;
size_t ps = 512;
size_t pi = 0;
size_t slb = 0;
int32_t id = packet->id;
ENS(4)
pi += writeVarInt(id, pktbuf + pi);
if (conn->protocol_state == STATE_HANDSHAKE) {
} else if (conn->protocol_state == STATE_PLAY) {
//printf("write %i\n", id);
if (id == PKT_PLAY_CLIENT_SPAWNOBJECT) {
//entity_id
ENS(4)
pi += writeVarInt(packet->data.play_client.spawnobject.entity_id, pktbuf + pi);
//object_uuid
ENS(16)
memcpy(pktbuf + pi, &packet->data.play_client.spawnobject.object_uuid, 16);
swapEndian(pktbuf + pi, 16);
pi += 16;
//type
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.spawnobject.type, 1);
pi += 1;
//x
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.spawnobject.x, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//y
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.spawnobject.y, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//z
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.spawnobject.z, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//pitch
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.spawnobject.pitch, 1);
pi += 1;
//yaw
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.spawnobject.yaw, 1);
pi += 1;
//data
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.spawnobject.data, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//velocity_x
ENS(2)
memcpy(pktbuf + pi, &packet->data.play_client.spawnobject.velocity_x, 2);
swapEndian(pktbuf + pi, 2);
pi += 2;
//velocity_y
ENS(2)
memcpy(pktbuf + pi, &packet->data.play_client.spawnobject.velocity_y, 2);
swapEndian(pktbuf + pi, 2);
pi += 2;
//velocity_z
ENS(2)
memcpy(pktbuf + pi, &packet->data.play_client.spawnobject.velocity_z, 2);
swapEndian(pktbuf + pi, 2);
pi += 2;
} else if (id == PKT_PLAY_CLIENT_SPAWNEXPERIENCEORB) {
//entity_id
ENS(4)
pi += writeVarInt(packet->data.play_client.spawnexperienceorb.entity_id, pktbuf + pi);
//x
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.spawnexperienceorb.x, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//y
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.spawnexperienceorb.y, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//z
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.spawnexperienceorb.z, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//count
ENS(2)
memcpy(pktbuf + pi, &packet->data.play_client.spawnexperienceorb.count, 2);
swapEndian(pktbuf + pi, 2);
pi += 2;
} else if (id == PKT_PLAY_CLIENT_SPAWNGLOBALENTITY) {
//entity_id
ENS(4)
pi += writeVarInt(packet->data.play_client.spawnglobalentity.entity_id, pktbuf + pi);
//type
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.spawnglobalentity.type, 1);
pi += 1;
//x
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.spawnglobalentity.x, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//y
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.spawnglobalentity.y, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//z
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.spawnglobalentity.z, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
} else if (id == PKT_PLAY_CLIENT_SPAWNMOB) {
//entity_id
ENS(4)
pi += writeVarInt(packet->data.play_client.spawnmob.entity_id, pktbuf + pi);
//entity_uuid
ENS(16)
memcpy(pktbuf + pi, &packet->data.play_client.spawnmob.entity_uuid, 16);
swapEndian(pktbuf + pi, 16);
pi += 16;
//type
if (conn->protocol_version > 210) {
ENS(4)
pi += writeVarInt(packet->data.play_client.spawnmob.type, pktbuf + pi);
} else {
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.spawnmob.type, 1);
pi += 1;
}
//x
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.spawnmob.x, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//y
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.spawnmob.y, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//z
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.spawnmob.z, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//yaw
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.spawnmob.yaw, 1);
pi += 1;
//pitch
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.spawnmob.pitch, 1);
pi += 1;
//head_pitch
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.spawnmob.head_pitch, 1);
pi += 1;
//velocity_x
ENS(2)
memcpy(pktbuf + pi, &packet->data.play_client.spawnmob.velocity_x, 2);
swapEndian(pktbuf + pi, 2);
pi += 2;
//velocity_y
ENS(2)
memcpy(pktbuf + pi, &packet->data.play_client.spawnmob.velocity_y, 2);
swapEndian(pktbuf + pi, 2);
pi += 2;
//velocity_z
ENS(2)
memcpy(pktbuf + pi, &packet->data.play_client.spawnmob.velocity_z, 2);
swapEndian(pktbuf + pi, 2);
pi += 2;
//metadata
ENS(packet->data.play_client.spawnmob.metadata.metadata_size)
memcpy(pktbuf + pi, packet->data.play_client.spawnmob.metadata.metadata, packet->data.play_client.spawnmob.metadata.metadata_size);
pi += packet->data.play_client.spawnmob.metadata.metadata_size;
} else if (id == PKT_PLAY_CLIENT_SPAWNPAINTING) {
//entity_id
ENS(4)
pi += writeVarInt(packet->data.play_client.spawnpainting.entity_id, pktbuf + pi);
//entity_uuid
ENS(16)
memcpy(pktbuf + pi, &packet->data.play_client.spawnpainting.entity_uuid, 16);
swapEndian(pktbuf + pi, 16);
pi += 16;
//title
slb = strlen(packet->data.play_client.spawnpainting.title) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.spawnpainting.title, pktbuf + pi, ps - pi);
//location
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.spawnpainting.location, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//direction
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.spawnpainting.direction, 1);
pi += 1;
} else if (id == PKT_PLAY_CLIENT_SPAWNPLAYER) {
//entity_id
ENS(4)
pi += writeVarInt(packet->data.play_client.spawnplayer.entity_id, pktbuf + pi);
//player_uuid
ENS(16)
memcpy(pktbuf + pi, &packet->data.play_client.spawnplayer.player_uuid, 16);
swapEndian(pktbuf + pi, 16);
pi += 16;
//x
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.spawnplayer.x, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//y
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.spawnplayer.y, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//z
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.spawnplayer.z, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//yaw
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.spawnplayer.yaw, 1);
pi += 1;
//pitch
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.spawnplayer.pitch, 1);
pi += 1;
//metadata
ENS(packet->data.play_client.spawnplayer.metadata.metadata_size)
memcpy(pktbuf + pi, packet->data.play_client.spawnplayer.metadata.metadata, packet->data.play_client.spawnplayer.metadata.metadata_size);
pi += packet->data.play_client.spawnplayer.metadata.metadata_size;
} else if (id == PKT_PLAY_CLIENT_ANIMATION) {
//entity_id
ENS(4)
pi += writeVarInt(packet->data.play_client.animation.entity_id, pktbuf + pi);
//animation
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.animation.animation, 1);
pi += 1;
} else if (id == PKT_PLAY_CLIENT_STATISTICS) {
//TODO: Manual Implementation
} else if (id == PKT_PLAY_CLIENT_BLOCKBREAKANIMATION) {
//entity_id
ENS(4)
pi += writeVarInt(packet->data.play_client.blockbreakanimation.entity_id, pktbuf + pi);
//location
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.blockbreakanimation.location, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//destroy_stage
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.blockbreakanimation.destroy_stage, 1);
pi += 1;
} else if (id == PKT_PLAY_CLIENT_UPDATEBLOCKENTITY) {
//location
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.updateblockentity.location, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//action
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.updateblockentity.action, 1);
pi += 1;
//nbt_data
ENS(512)
pi += nbt_write(packet->data.play_client.updateblockentity.nbt_data, pktbuf + pi, ps - pi);
} else if (id == PKT_PLAY_CLIENT_BLOCKACTION) {
//location
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.blockaction.location, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//action_id_byte_1
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.blockaction.action_id, 1);
pi += 1;
//action_param_byte_2
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.blockaction.action_param, 1);
pi += 1;
//block_type
ENS(4)
pi += writeVarInt(packet->data.play_client.blockaction.block_type, pktbuf + pi);
} else if (id == PKT_PLAY_CLIENT_BLOCKCHANGE) {
//location
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.blockchange.location, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//block_id
ENS(4)
pi += writeVarInt(packet->data.play_client.blockchange.block_id, pktbuf + pi);
} else if (id == PKT_PLAY_CLIENT_BOSSBAR) {
//TODO: Manual Implementation
} else if (id == PKT_PLAY_CLIENT_SERVERDIFFICULTY) {
//difficulty
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.serverdifficulty.difficulty, 1);
pi += 1;
} else if (id == PKT_PLAY_CLIENT_TABCOMPLETE) {
//count
ENS(4)
pi += writeVarInt(packet->data.play_client.tabcomplete.count, pktbuf + pi);
//matches
for (int32_t i = 0; i < packet->data.play_client.tabcomplete.count; i++) {
slb = strlen(packet->data.play_client.tabcomplete.matches[i]) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.tabcomplete.matches[i], pktbuf + pi, ps - pi);
}
} else if (id == PKT_PLAY_CLIENT_CHATMESSAGE) {
//json_data
slb = strlen(packet->data.play_client.chatmessage.json_data) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.chatmessage.json_data, pktbuf + pi, ps - pi);
//position
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.chatmessage.position, 1);
pi += 1;
} else if (id == PKT_PLAY_CLIENT_MULTIBLOCKCHANGE) {
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.multiblockchange.chunk_x, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.multiblockchange.chunk_z, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
ENS(4)
pi += writeVarInt(packet->data.play_client.multiblockchange.record_count, pktbuf + pi);
for (int32_t i = 0; i < packet->data.play_client.multiblockchange.record_count; i++) {
ENS(2)
memcpy(pktbuf + pi, ((uint8_t*) &packet->data.play_client.multiblockchange.records[i]), 2);
swapEndian(pktbuf + pi, 2);
pi += 2;
ENS(4)
pi += writeVarInt(packet->data.play_client.multiblockchange.records[i].block_id, pktbuf + pi);
}
} else if (id == PKT_PLAY_CLIENT_CONFIRMTRANSACTION) {
//window_id
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.confirmtransaction.window_id, 1);
pi += 1;
//action_number
ENS(2)
memcpy(pktbuf + pi, &packet->data.play_client.confirmtransaction.action_number, 2);
swapEndian(pktbuf + pi, 2);
pi += 2;
//accepted
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.confirmtransaction.accepted, 1);
pi += 1;
} else if (id == PKT_PLAY_CLIENT_CLOSEWINDOW) {
//window_id
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.closewindow.window_id, 1);
pi += 1;
} else if (id == PKT_PLAY_CLIENT_OPENWINDOW) {
//window_id
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.openwindow.window_id, 1);
pi += 1;
//window_type
slb = strlen(packet->data.play_client.openwindow.window_type) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.openwindow.window_type, pktbuf + pi, ps - pi);
//window_title
slb = strlen(packet->data.play_client.openwindow.window_title) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.openwindow.window_title, pktbuf + pi, ps - pi);
//number_of_slots
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.openwindow.number_of_slots, 1);
pi += 1;
//entity_id
if (str_eq(packet->data.play_client.openwindow.window_type, "EntityHorse")) {
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.openwindow.entity_id, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
}
} else if (id == PKT_PLAY_CLIENT_WINDOWITEMS) {
//window_id
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.windowitems.window_id, 1);
pi += 1;
//count
ENS(2)
memcpy(pktbuf + pi, &packet->data.play_client.windowitems.count, 2);
swapEndian(pktbuf + pi, 2);
pi += 2;
//slot_data
for (int16_t i = 0; i < packet->data.play_client.windowitems.count; i++) {
ENS(512)
pi += writeSlot(&packet->data.play_client.windowitems.slot_data[i], pktbuf + pi, ps - pi);
}
} else if (id == PKT_PLAY_CLIENT_WINDOWPROPERTY) {
//window_id
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.windowproperty.window_id, 1);
pi += 1;
//property
ENS(2)
memcpy(pktbuf + pi, &packet->data.play_client.windowproperty.property, 2);
swapEndian(pktbuf + pi, 2);
pi += 2;
//value
ENS(2)
memcpy(pktbuf + pi, &packet->data.play_client.windowproperty.value, 2);
swapEndian(pktbuf + pi, 2);
pi += 2;
} else if (id == PKT_PLAY_CLIENT_SETSLOT) {
//window_id
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.setslot.window_id, 1);
pi += 1;
//slot
ENS(2)
memcpy(pktbuf + pi, &packet->data.play_client.setslot.slot, 2);
swapEndian(pktbuf + pi, 2);
pi += 2;
//slot_data
ENS(512)
pi += writeSlot(&packet->data.play_client.setslot.slot_data, pktbuf + pi, ps - pi);
} else if (id == PKT_PLAY_CLIENT_SETCOOLDOWN) {
//item_id
ENS(4)
pi += writeVarInt(packet->data.play_client.setcooldown.item_id, pktbuf + pi);
//cooldown_ticks
ENS(4)
pi += writeVarInt(packet->data.play_client.setcooldown.cooldown_ticks, pktbuf + pi);
} else if (id == PKT_PLAY_CLIENT_PLUGINMESSAGE) {
//channel
slb = strlen(packet->data.play_client.pluginmessage.channel) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.pluginmessage.channel, pktbuf + pi, ps - pi);
//data
ENS(packet->data.play_client.pluginmessage.data_size)
memcpy(pktbuf + pi, packet->data.play_client.pluginmessage.data, packet->data.play_client.pluginmessage.data_size);
pi += packet->data.play_client.pluginmessage.data_size;
} else if (id == PKT_PLAY_CLIENT_NAMEDSOUNDEFFECT) {
//sound_name
slb = strlen(packet->data.play_client.namedsoundeffect.sound_name) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.namedsoundeffect.sound_name, pktbuf + pi, ps - pi);
//sound_category
ENS(4)
pi += writeVarInt(packet->data.play_client.namedsoundeffect.sound_category, pktbuf + pi);
//effect_position_x
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.namedsoundeffect.effect_position_x, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//effect_position_y
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.namedsoundeffect.effect_position_y, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//effect_position_z
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.namedsoundeffect.effect_position_z, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//volume
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.namedsoundeffect.volume, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//pitch
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.namedsoundeffect.pitch, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
} else if (id == PKT_PLAY_CLIENT_DISCONNECT) {
//reason
slb = strlen(packet->data.play_client.disconnect.reason) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.disconnect.reason, pktbuf + pi, ps - pi);
} else if (id == PKT_PLAY_CLIENT_ENTITYSTATUS) {
//entity_id
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.entitystatus.entity_id, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//entity_status
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.entitystatus.entity_status, 1);
pi += 1;
} else if (id == PKT_PLAY_CLIENT_EXPLOSION) {
//x
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.explosion.x, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//y
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.explosion.y, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//z
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.explosion.z, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//radius
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.explosion.radius, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//record_count
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.explosion.record_count, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//records
ENS(packet->data.play_client.explosion.record_count * 3)
memcpy(pktbuf + pi, packet->data.play_client.explosion.records,
(size_t) (packet->data.play_client.explosion.record_count * 3));
pi += packet->data.play_client.explosion.record_count * 3;
//player_motion_x
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.explosion.player_motion_x, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//player_motion_y
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.explosion.player_motion_y, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//player_motion_z
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.explosion.player_motion_z, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
} else if (id == PKT_PLAY_CLIENT_UNLOADCHUNK) {
//chunk_x
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.unloadchunk.chunk_x, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//chunk_z
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.unloadchunk.chunk_z, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//packet->data.play_client.unloadchunk.ch->playersLoaded--;
} else if (id == PKT_PLAY_CLIENT_CHANGEGAMESTATE) {
//reason
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.changegamestate.reason, 1);
pi += 1;
//value
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.changegamestate.value, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
} else if (id == PKT_PLAY_CLIENT_KEEPALIVE) {
//keep_alive_id
ENS(4)
pi += writeVarInt(packet->data.play_client.keepalive.keep_alive_id, pktbuf + pi);
} else if (id == PKT_PLAY_CLIENT_CHUNKDATA) {
//chunk_x
ENS(4)
int32_t cx = packet->data.play_client.chunkdata.data->x;
int32_t cz = packet->data.play_client.chunkdata.data->z;
memcpy(pktbuf + pi, &cx, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//chunk_z
ENS(4)
memcpy(pktbuf + pi, &cz, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//ground_up_continuous
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.chunkdata.ground_up_continuous, 1);
pi += 1;
//primary_bit_mask
uint16_t primary_bit_mask = 0;
int32_t ccs = 0;
for (int ymj = 0; ymj < 16; ymj++) {
if (packet->data.play_client.chunkdata.data->sections[ymj] == NULL) continue;
primary_bit_mask |= (uint16_t) pow(2, ymj);
ccs += packet->data.play_client.chunkdata.data->sections[ymj]->bits_per_block * 512 + 4 + 2048;
if (packet->data.play_client.chunkdata.data->sections[ymj]->skyLight != NULL) ccs += 2048;
for (int i = 0; i < packet->data.play_client.chunkdata.data->sections[ymj]->palette_count; i++) {
ccs += getVarIntSize(packet->data.play_client.chunkdata.data->sections[ymj]->palette[i]);
}
}
ENS(4)
pi += writeVarInt(primary_bit_mask, pktbuf + pi);
//size
ENS(4)
pi += writeVarInt(ccs + (packet->data.play_client.chunkdata.ground_up_continuous ? 256 : 0), pktbuf + pi);
//data
for (int ymj = 0; ymj < 16; ymj++) {
if (packet->data.play_client.chunkdata.data->sections[ymj] == NULL) continue;
uint8_t bpb = packet->data.play_client.chunkdata.data->sections[ymj]->bits_per_block;
ENS(1)
memcpy(pktbuf + pi, &bpb, 1);
pi += 1;
ENS(4)
pi += writeVarInt(
(int32_t) (bpb < 9 ? packet->data.play_client.chunkdata.data->sections[ymj]->palette_count : 0), pktbuf + pi);
for (int i = 0; i < packet->data.play_client.chunkdata.data->sections[ymj]->palette_count; i++) {
ENS(4)
pi += writeVarInt(packet->data.play_client.chunkdata.data->sections[ymj]->palette[i], pktbuf + pi);
}
ENS(4)
pi += writeVarInt(bpb * 64, pktbuf + pi);
ENS(bpb * 512)
memcpy(pktbuf + pi, packet->data.play_client.chunkdata.data->sections[ymj]->blocks, bpb * 512);
int64_t* es = (int64_t*) (pktbuf + pi);
for (int i = 0; i < bpb * 64; i++) {
swapEndian(&es[i], 8);
}
pi += bpb * 512;
ENS(2048);
memcpy(pktbuf + pi, packet->data.play_client.chunkdata.data->sections[ymj]->blockLight, 2048);
//memset(pktbuf + pi, 0xFF, 2048);
pi += 2048;
if (packet->data.play_client.chunkdata.data->sections[ymj]->skyLight != NULL) {
ENS(2048);
memcpy(pktbuf + pi, packet->data.play_client.chunkdata.data->sections[ymj]->skyLight, 2048);
//memset(pktbuf + pi, 0xFF, 2048);
pi += 2048;
}
}
//biomes
if (packet->data.play_client.chunkdata.ground_up_continuous) {
ENS(256)
memcpy(pktbuf + pi, packet->data.play_client.chunkdata.data->biomes, 256);
pi += 256;
}
//number_of_block_entities
ENS(4)
pi += writeVarInt(packet->data.play_client.chunkdata.number_of_block_entities, pktbuf + pi);
//block_entities
for (int32_t i = 0; i < packet->data.play_client.chunkdata.number_of_block_entities; i++) {
ENS(512)
pi += nbt_write(packet->data.play_client.chunkdata.block_entities[i], pktbuf + pi, ps - pi);
}
} else if (id == PKT_PLAY_CLIENT_EFFECT) {
//effect_id
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.effect.effect_id, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//location
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.effect.location, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//data
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.effect.data, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//disable_relative_volume
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.effect.disable_relative_volume, 1);
pi += 1;
} else if (id == PKT_PLAY_CLIENT_PARTICLE) {
//particle_id
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.particle.particle_id, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//long_distance
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.particle.long_distance, 1);
pi += 1;
//x
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.particle.x, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//y
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.particle.y, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//z
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.particle.z, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//offset_x
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.particle.offset_x, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//offset_y
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.particle.offset_y, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//offset_z
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.particle.offset_z, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//particle_data
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.particle.particle_data, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//particle_count
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.particle.particle_count, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//data
/* TODO: Array
ENS(4)
pi += writeVarInt(packet->data.play_client.particle.data, pktbuf + pi);
*/
} else if (id == PKT_PLAY_CLIENT_JOINGAME) {
//entity_id
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.joingame.entity_id, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//gamemode
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.joingame.gamemode, 1);
pi += 1;
//dimension
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.joingame.dimension, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//difficulty
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.joingame.difficulty, 1);
pi += 1;
//max_players
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.joingame.max_players, 1);
pi += 1;
//level_type
slb = strlen(packet->data.play_client.joingame.level_type) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.joingame.level_type, pktbuf + pi, ps - pi);
//reduced_debug_info
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.joingame.reduced_debug_info, 1);
pi += 1;
} else if (id == PKT_PLAY_CLIENT_MAP) {
//TODO: Manual Implementation
} else if (id == PKT_PLAY_CLIENT_ENTITYRELATIVEMOVE) {
//entity_id
ENS(4)
pi += writeVarInt(packet->data.play_client.entityrelativemove.entity_id, pktbuf + pi);
//delta_x
ENS(2)
memcpy(pktbuf + pi, &packet->data.play_client.entityrelativemove.delta_x, 2);
swapEndian(pktbuf + pi, 2);
pi += 2;
//delta_y
ENS(2)
memcpy(pktbuf + pi, &packet->data.play_client.entityrelativemove.delta_y, 2);
swapEndian(pktbuf + pi, 2);
pi += 2;
//delta_z
ENS(2)
memcpy(pktbuf + pi, &packet->data.play_client.entityrelativemove.delta_z, 2);
swapEndian(pktbuf + pi, 2);
pi += 2;
//on_ground
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.entityrelativemove.on_ground, 1);
pi += 1;
} else if (id == PKT_PLAY_CLIENT_ENTITYLOOKANDRELATIVEMOVE) {
//entity_id
ENS(4)
pi += writeVarInt(packet->data.play_client.entitylookandrelativemove.entity_id, pktbuf + pi);
//delta_x
ENS(2)
memcpy(pktbuf + pi, &packet->data.play_client.entitylookandrelativemove.delta_x, 2);
swapEndian(pktbuf + pi, 2);
pi += 2;
//delta_y
ENS(2)
memcpy(pktbuf + pi, &packet->data.play_client.entitylookandrelativemove.delta_y, 2);
swapEndian(pktbuf + pi, 2);
pi += 2;
//delta_z
ENS(2)
memcpy(pktbuf + pi, &packet->data.play_client.entitylookandrelativemove.delta_z, 2);
swapEndian(pktbuf + pi, 2);
pi += 2;
//yaw
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.entitylookandrelativemove.yaw, 1);
pi += 1;
//pitch
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.entitylookandrelativemove.pitch, 1);
pi += 1;
//on_ground
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.entitylookandrelativemove.on_ground, 1);
pi += 1;
} else if (id == PKT_PLAY_CLIENT_ENTITYLOOK) {
//entity_id
ENS(4)
pi += writeVarInt(packet->data.play_client.entitylook.entity_id, pktbuf + pi);
//yaw
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.entitylook.yaw, 1);
pi += 1;
//pitch
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.entitylook.pitch, 1);
pi += 1;
//on_ground
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.entitylook.on_ground, 1);
pi += 1;
} else if (id == PKT_PLAY_CLIENT_ENTITY) {
//entity_id
ENS(4)
pi += writeVarInt(packet->data.play_client.entity.entity_id, pktbuf + pi);
} else if (id == PKT_PLAY_CLIENT_VEHICLEMOVE) {
//x
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.vehiclemove.x, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//y
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.vehiclemove.y, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//z
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.vehiclemove.z, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//yaw
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.vehiclemove.yaw, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//pitch
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.vehiclemove.pitch, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
} else if (id == PKT_PLAY_CLIENT_OPENSIGNEDITOR) {
//location
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.opensigneditor.location, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
} else if (id == PKT_PLAY_CLIENT_PLAYERABILITIES) {
//flags
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.playerabilities.flags, 1);
pi += 1;
//flying_speed
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.playerabilities.flying_speed, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//field_of_view_modifier
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.playerabilities.field_of_view_modifier, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
} else if (id == PKT_PLAY_CLIENT_COMBATEVENT) {
//TODO: Manual Implementation
} else if (id == PKT_PLAY_CLIENT_PLAYERLISTITEM) {
//action_id
ENS(4)
pi += writeVarInt(packet->data.play_client.playerlistitem.action_id, pktbuf + pi);
//number_of_players
ENS(4)
pi += writeVarInt(packet->data.play_client.playerlistitem.number_of_players, pktbuf + pi);
for (int32_t i = 0; i < packet->data.play_client.playerlistitem.number_of_players; i++) {
ENS(16)
memcpy(pktbuf + pi, &packet->data.play_client.playerlistitem.players[i].uuid, 16);
swapEndian(pktbuf + pi, 16);
pi += 16;
if (packet->data.play_client.playerlistitem.action_id == 0) {
slb = strlen(packet->data.play_client.playerlistitem.players[i].action.addplayer.name) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.playerlistitem.players[i].action.addplayer.name, pktbuf + pi, ps - pi);
ENS(4)
pi += writeVarInt(packet->data.play_client.playerlistitem.players[i].action.addplayer.number_of_properties, pktbuf + pi);
for (int32_t x = 0; x < packet->data.play_client.playerlistitem.players[i].action.addplayer.number_of_properties; x++) {
slb = strlen(packet->data.play_client.playerlistitem.players[i].action.addplayer.properties[x].name) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.playerlistitem.players[i].action.addplayer.properties[x].name, pktbuf + pi, ps - pi);
slb = strlen(packet->data.play_client.playerlistitem.players[i].action.addplayer.properties[x].value) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.playerlistitem.players[i].action.addplayer.properties[x].value, pktbuf + pi, ps - pi);
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.playerlistitem.players[i].action.addplayer.properties[x].isSigned, 1);
pi += 1;
if (packet->data.play_client.playerlistitem.players[i].action.addplayer.properties[x].isSigned) {
slb = strlen(packet->data.play_client.playerlistitem.players[i].action.addplayer.properties[x].signature) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.playerlistitem.players[i].action.addplayer.properties[x].signature, pktbuf + pi, ps - pi);
}
}
ENS(4)
pi += writeVarInt(packet->data.play_client.playerlistitem.players[i].action.addplayer.gamemode, pktbuf + pi);
ENS(4)
pi += writeVarInt(packet->data.play_client.playerlistitem.players[i].action.addplayer.ping, pktbuf + pi);
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.playerlistitem.players[i].action.addplayer.has_display_name, 1);
pi += 1;
if (packet->data.play_client.playerlistitem.players[i].action.addplayer.has_display_name) {
slb = strlen(packet->data.play_client.playerlistitem.players[i].action.addplayer.display_name) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.playerlistitem.players[i].action.addplayer.display_name, pktbuf + pi, ps - pi);
}
} else if (packet->data.play_client.playerlistitem.action_id == 1) {
ENS(4)
pi += writeVarInt(packet->data.play_client.playerlistitem.players[i].action.updategamemode_gamemode, pktbuf + pi);
} else if (packet->data.play_client.playerlistitem.action_id == 2) {
ENS(4)
pi += writeVarInt(packet->data.play_client.playerlistitem.players[i].action.updatelatency_ping, pktbuf + pi);
} else if (packet->data.play_client.playerlistitem.action_id == 3) {
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.playerlistitem.players[i].action.updatedisplayname.has_display_name, 1);
pi += 1;
if (packet->data.play_client.playerlistitem.players[i].action.updatedisplayname.has_display_name) {
slb = strlen(packet->data.play_client.playerlistitem.players[i].action.updatedisplayname.display_name) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.playerlistitem.players[i].action.updatedisplayname.display_name, pktbuf + pi, ps - pi);
}
} else if (packet->data.play_client.playerlistitem.action_id == 4) {
//none
}
}
} else if (id == PKT_PLAY_CLIENT_PLAYERPOSITIONANDLOOK) {
//x
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.playerpositionandlook.x, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//y
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.playerpositionandlook.y, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//z
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.playerpositionandlook.z, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//yaw
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.playerpositionandlook.yaw, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//pitch
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.playerpositionandlook.pitch, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//flags
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.playerpositionandlook.flags, 1);
pi += 1;
//teleport_id
ENS(4)
pi += writeVarInt(packet->data.play_client.playerpositionandlook.teleport_id, pktbuf + pi);
} else if (id == PKT_PLAY_CLIENT_USEBED) {
//entity_id
ENS(4)
pi += writeVarInt(packet->data.play_client.usebed.entity_id, pktbuf + pi);
//location
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.usebed.location, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
} else if (id == PKT_PLAY_CLIENT_DESTROYENTITIES) {
//count
ENS(4)
pi += writeVarInt(packet->data.play_client.destroyentities.count, pktbuf + pi);
//entity_ids
ENS(4 * packet->data.play_client.destroyentities.count)
for (size_t i = 0; i < packet->data.play_client.destroyentities.count; i++)
pi += writeVarInt(packet->data.play_client.destroyentities.entity_ids[i], pktbuf + pi);
} else if (id == PKT_PLAY_CLIENT_REMOVEENTITYEFFECT) {
//entity_id
ENS(4)
pi += writeVarInt(packet->data.play_client.removeentityeffect.entity_id, pktbuf + pi);
//effect_id
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.removeentityeffect.effect_id, 1);
pi += 1;
} else if (id == PKT_PLAY_CLIENT_RESOURCEPACKSEND) {
//url
slb = strlen(packet->data.play_client.resourcepacksend.url) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.resourcepacksend.url, pktbuf + pi, ps - pi);
//hash
slb = strlen(packet->data.play_client.resourcepacksend.hash) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.resourcepacksend.hash, pktbuf + pi, ps - pi);
} else if (id == PKT_PLAY_CLIENT_RESPAWN) {
//dimension
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.respawn.dimension, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//difficulty
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.respawn.difficulty, 1);
pi += 1;
//gamemode
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.respawn.gamemode, 1);
pi += 1;
//level_type
slb = strlen(packet->data.play_client.respawn.level_type) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.respawn.level_type, pktbuf + pi, ps - pi);
} else if (id == PKT_PLAY_CLIENT_ENTITYHEADLOOK) {
//entity_id
ENS(4)
pi += writeVarInt(packet->data.play_client.entityheadlook.entity_id, pktbuf + pi);
//head_yaw
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.entityheadlook.head_yaw, 1);
pi += 1;
} else if (id == PKT_PLAY_CLIENT_WORLDBORDER) {
//TODO: Manual Implementation
} else if (id == PKT_PLAY_CLIENT_CAMERA) {
//camera_id
ENS(4)
pi += writeVarInt(packet->data.play_client.camera.camera_id, pktbuf + pi);
} else if (id == PKT_PLAY_CLIENT_HELDITEMCHANGE) {
//slot
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.helditemchange.slot, 1);
pi += 1;
} else if (id == PKT_PLAY_CLIENT_DISPLAYSCOREBOARD) {
//position
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.displayscoreboard.position, 1);
pi += 1;
//score_name
slb = strlen(packet->data.play_client.displayscoreboard.score_name) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.displayscoreboard.score_name, pktbuf + pi, ps - pi);
} else if (id == PKT_PLAY_CLIENT_ENTITYMETADATA) {
//entity_id
ENS(4)
pi += writeVarInt(packet->data.play_client.entitymetadata.entity_id, pktbuf + pi);
//metadata
ENS(packet->data.play_client.entitymetadata.metadata.metadata_size)
memcpy(pktbuf + pi, packet->data.play_client.entitymetadata.metadata.metadata, packet->data.play_client.entitymetadata.metadata.metadata_size);
pi += packet->data.play_client.entitymetadata.metadata.metadata_size;
} else if (id == PKT_PLAY_CLIENT_ATTACHENTITY) {
//attached_entity_id
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.attachentity.attached_entity_id, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//holding_entity_id
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.attachentity.holding_entity_id, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
} else if (id == PKT_PLAY_CLIENT_ENTITYVELOCITY) {
//entity_id
ENS(4)
pi += writeVarInt(packet->data.play_client.entityvelocity.entity_id, pktbuf + pi);
//velocity_x
ENS(2)
memcpy(pktbuf + pi, &packet->data.play_client.entityvelocity.velocity_x, 2);
swapEndian(pktbuf + pi, 2);
pi += 2;
//velocity_y
ENS(2)
memcpy(pktbuf + pi, &packet->data.play_client.entityvelocity.velocity_y, 2);
swapEndian(pktbuf + pi, 2);
pi += 2;
//velocity_z
ENS(2)
memcpy(pktbuf + pi, &packet->data.play_client.entityvelocity.velocity_z, 2);
swapEndian(pktbuf + pi, 2);
pi += 2;
} else if (id == PKT_PLAY_CLIENT_ENTITYEQUIPMENT) {
//entity_id
ENS(4)
pi += writeVarInt(packet->data.play_client.entityequipment.entity_id, pktbuf + pi);
//slot
ENS(4)
pi += writeVarInt(packet->data.play_client.entityequipment.slot, pktbuf + pi);
//item
ENS(512)
pi += writeSlot(&packet->data.play_client.entityequipment.item, pktbuf + pi, ps - pi);
} else if (id == PKT_PLAY_CLIENT_SETEXPERIENCE) {
//experience_bar
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.setexperience.experience_bar, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//level
ENS(4)
pi += writeVarInt(packet->data.play_client.setexperience.level, pktbuf + pi);
//total_experience
ENS(4)
pi += writeVarInt(packet->data.play_client.setexperience.total_experience, pktbuf + pi);
} else if (id == PKT_PLAY_CLIENT_UPDATEHEALTH) {
//health
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.updatehealth.health, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//food
ENS(4)
pi += writeVarInt(packet->data.play_client.updatehealth.food, pktbuf + pi);
//food_saturation
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.updatehealth.food_saturation, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
} else if (id == PKT_PLAY_CLIENT_SCOREBOARDOBJECTIVE) {
//objective_name
slb = strlen(packet->data.play_client.scoreboardobjective.objective_name) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.scoreboardobjective.objective_name, pktbuf + pi, ps - pi);
//mode
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.scoreboardobjective.mode, 1);
pi += 1;
//objective_value
/* TODO: Optional
slb = strlen(packet->data.play_client.scoreboardobjective.objective_value) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.scoreboardobjective.objective_value, pktbuf + pi, ps - pi);
*/
//type
/* TODO: Optional
slb = strlen(packet->data.play_client.scoreboardobjective.type) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.scoreboardobjective.type, pktbuf + pi, ps - pi);
*/
} else if (id == PKT_PLAY_CLIENT_SETPASSENGERS) {
//entity_id
ENS(4)
pi += writeVarInt(packet->data.play_client.setpassengers.entity_id, pktbuf + pi);
//passenger_count
ENS(4)
pi += writeVarInt(packet->data.play_client.setpassengers.passenger_count, pktbuf + pi);
//passengers
/* TODO: Array
ENS(4)
pi += writeVarInt(packet->data.play_client.setpassengers.passengers, pktbuf + pi);
*/
} else if (id == PKT_PLAY_CLIENT_TEAMS) {
//TODO: Manual Implementation
} else if (id == PKT_PLAY_CLIENT_UPDATESCORE) {
//score_name
slb = strlen(packet->data.play_client.updatescore.score_name) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.updatescore.score_name, pktbuf + pi, ps - pi);
//action
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.updatescore.action, 1);
pi += 1;
//objective_name
slb = strlen(packet->data.play_client.updatescore.objective_name) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.updatescore.objective_name, pktbuf + pi, ps - pi);
//value
/* TODO: Optional
ENS(4)
pi += writeVarInt(packet->data.play_client.updatescore.value, pktbuf + pi);
*/
} else if (id == PKT_PLAY_CLIENT_SPAWNPOSITION) {
//location
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.spawnposition.location, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
} else if (id == PKT_PLAY_CLIENT_TIMEUPDATE) {
//world_age
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.timeupdate.world_age, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//time_of_day
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.timeupdate.time_of_day, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
} else if (id == PKT_PLAY_CLIENT_TITLE) {
//TODO: Manual Implementation
} else if (id == PKT_PLAY_CLIENT_SOUNDEFFECT) {
//sound_id
ENS(4)
pi += writeVarInt(packet->data.play_client.soundeffect.sound_id, pktbuf + pi);
//sound_category
ENS(4)
pi += writeVarInt(packet->data.play_client.soundeffect.sound_category, pktbuf + pi);
//effect_position_x
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.soundeffect.effect_position_x, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//effect_position_y
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.soundeffect.effect_position_y, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//effect_position_z
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.soundeffect.effect_position_z, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//volume
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.soundeffect.volume, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
//pitch
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.soundeffect.pitch, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
} else if (id == PKT_PLAY_CLIENT_PLAYERLISTHEADERANDFOOTER) {
//header
slb = strlen(packet->data.play_client.playerlistheaderandfooter.header) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.playerlistheaderandfooter.header, pktbuf + pi, ps - pi);
//footer
slb = strlen(packet->data.play_client.playerlistheaderandfooter.footer) + 4;
ENS(slb)
pi += writeString(packet->data.play_client.playerlistheaderandfooter.footer, pktbuf + pi, ps - pi);
} else if (id == PKT_PLAY_CLIENT_COLLECTITEM) {
//collected_entity_id
ENS(4)
pi += writeVarInt(packet->data.play_client.collectitem.collected_entity_id, pktbuf + pi);
//collector_entity_id
ENS(4)
pi += writeVarInt(packet->data.play_client.collectitem.collector_entity_id, pktbuf + pi);
//pickup_item_count
if (conn->protocol_version > 210) {
ENS(4)
pi += writeVarInt(packet->data.play_client.collectitem.pickup_item_count, pktbuf + pi);
}
} else if (id == PKT_PLAY_CLIENT_ENTITYTELEPORT) {
//entity_id
ENS(4)
pi += writeVarInt(packet->data.play_client.entityteleport.entity_id, pktbuf + pi);
//x
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.entityteleport.x, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//y
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.entityteleport.y, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//z
ENS(8)
memcpy(pktbuf + pi, &packet->data.play_client.entityteleport.z, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
//yaw
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.entityteleport.yaw, 1);
pi += 1;
//pitch
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.entityteleport.pitch, 1);
pi += 1;
//on_ground
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.entityteleport.on_ground, 1);
pi += 1;
} else if (id == PKT_PLAY_CLIENT_ENTITYPROPERTIES) {
//entity_id
ENS(4)
pi += writeVarInt(packet->data.play_client.entityproperties.entity_id, pktbuf + pi);
ENS(4)
memcpy(pktbuf + pi, &packet->data.play_client.entityproperties.number_of_properties, 4);
swapEndian(pktbuf + pi, 4);
pi += 4;
for (int32_t i = 0; i < packet->data.play_client.entityproperties.number_of_properties; i++) {
struct entity_property* property = &packet->data.play_client.entityproperties.properties[i];
slb = strlen(property->key) + 4;
ENS(slb)
pi += writeString(property->key, pktbuf + pi, ps - pi);
ENS(8)
memcpy(pktbuf + pi, &property->value, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
ENS(4)
pi += writeVarInt(property->number_of_modifiers, pktbuf + pi);
for (int32_t x = 0; x < property->number_of_modifiers; x++) {
struct entity_property_modifier* epm = &property->modifiers[x];
ENS(16)
memcpy(pktbuf + pi, &epm->uuid, 16);
swapEndian(pktbuf + pi, 16);
pi += 16;
ENS(8)
memcpy(pktbuf + pi, &epm->amount, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
ENS(1)
memcpy(pktbuf + pi, &epm->operation, 1);
pi += 1;
}
}
} else if (id == PKT_PLAY_CLIENT_ENTITYEFFECT) {
//entity_id
ENS(4)
pi += writeVarInt(packet->data.play_client.entityeffect.entity_id, pktbuf + pi);
//effect_id
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.entityeffect.effect_id, 1);
pi += 1;
//amplifier
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.entityeffect.amplifier, 1);
pi += 1;
//duration
ENS(4)
pi += writeVarInt(packet->data.play_client.entityeffect.duration, pktbuf + pi);
//flags
ENS(1)
memcpy(pktbuf + pi, &packet->data.play_client.entityeffect.flags, 1);
pi += 1;
}
} else if (conn->protocol_state == STATE_STATUS) {
if (id == PKT_STATUS_CLIENT_RESPONSE) {
//json_response
slb = strlen(packet->data.status_client.response.json_response) + 4;
ENS(slb)
pi += writeString(packet->data.status_client.response.json_response, pktbuf + pi, ps - pi);
} else if (id == PKT_STATUS_CLIENT_PONG) {
//payload
ENS(8)
memcpy(pktbuf + pi, &packet->data.status_client.pong.payload, 8);
swapEndian(pktbuf + pi, 8);
pi += 8;
}
} else if (conn->protocol_state == STATE_LOGIN) {
if (id == PKT_LOGIN_CLIENT_DISCONNECT) {
//reason
slb = strlen(packet->data.login_client.disconnect.reason) + 4;
ENS(slb)
pi += writeString(packet->data.login_client.disconnect.reason, pktbuf + pi, ps - pi);
} else if (id == PKT_LOGIN_CLIENT_ENCRYPTIONREQUEST) {
//server_id
slb = strlen(packet->data.login_client.encryptionrequest.server_id) + 4;
ENS(slb)
pi += writeString(packet->data.login_client.encryptionrequest.server_id, pktbuf + pi, ps - pi);
//public_key_length
ENS(4)
pi += writeVarInt(packet->data.login_client.encryptionrequest.public_key_length, pktbuf + pi);
//public_key
ENS(packet->data.login_client.encryptionrequest.public_key_length)
memcpy(pktbuf + pi, packet->data.login_client.encryptionrequest.public_key,
(size_t) packet->data.login_client.encryptionrequest.public_key_length);
pi += packet->data.login_client.encryptionrequest.public_key_length;
//verify_token_length
ENS(4)
pi += writeVarInt(packet->data.login_client.encryptionrequest.verify_token_length, pktbuf + pi);
//verify_token
ENS(packet->data.login_client.encryptionrequest.verify_token_length)
memcpy(pktbuf + pi, packet->data.login_client.encryptionrequest.verify_token,
(size_t) packet->data.login_client.encryptionrequest.verify_token_length);
pi += packet->data.login_client.encryptionrequest.verify_token_length;
} else if (id == PKT_LOGIN_CLIENT_LOGINSUCCESS) {
//uuid
slb = strlen(packet->data.login_client.loginsuccess.uuid) + 4;
ENS(slb)
pi += writeString(packet->data.login_client.loginsuccess.uuid, pktbuf + pi, ps - pi);
//username
slb = strlen(packet->data.login_client.loginsuccess.username) + 4;
ENS(slb)
pi += writeString(packet->data.login_client.loginsuccess.username, pktbuf + pi, ps - pi);
} else if (id == PKT_LOGIN_CLIENT_SETCOMPRESSION) {
//threshold
ENS(4)
pi += writeVarInt(packet->data.login_client.setcompression.threshold, pktbuf + pi);
}
}
int fpll = getVarIntSize(pi);
void* wrt = NULL;
size_t wrt_s = 0;
unsigned char prep[10];
uint8_t preps = 0;
if (conn->compression_state >= 0 && (pi + fpll > conn->compression_state + 1) && (pi + fpll) <= 2097152) {
z_stream strm;
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
strm.opaque = Z_NULL;
int dr = 0;
if ((dr = deflateInit2(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 31, 8, Z_DEFAULT_STRATEGY)) != Z_OK) { // TODO: configurable level?
goto rret;
}
strm.avail_in = (uInt) pi;
strm.next_in = pktbuf;
size_t cc = pi + 32;
void* cdata = pmalloc(packet->pool, cc + 10);
size_t ts = 0;
strm.avail_out = (uInt) (cc - ts);
strm.next_out = cdata + ts;
do {
dr = deflate(&strm, Z_FINISH);
ts = strm.total_out;
if (ts >= cc) {
cc *= 2;
cdata = prealloc(packet->pool, cdata - 10, cc + 10) + 10;
}
if (dr == Z_STREAM_ERROR) {
goto rret;
}
strm.avail_out = (uInt) (cc - ts);
strm.next_out = cdata + ts;
} while (strm.avail_out == 0);
deflateEnd(&strm);
preps += writeVarInt((int32_t) (ts + getVarIntSize((int32_t) pi)), prep + preps);
preps += writeVarInt((int32_t) pi, prep + preps);
wrt = cdata;
wrt_s = ts;
} else if (conn->compression_state >= 0) {
preps += writeVarInt((int32_t) (pi + getVarIntSize(0)), prep + preps);
preps += writeVarInt(0, prep + preps);
wrt = pktbuf;
wrt_s = pi;
} else {
preps += writeVarInt((int32_t) pi, prep + preps);
wrt = pktbuf;
wrt_s = pi;
}
if (preps >= 10) goto rret;
void* xfer_address = wrt - 10;
// ^ explode
wrt -= preps; // preallocated!
memcpy(wrt, prep, preps);
wrt_s += preps;
if (conn->aes_ctx_enc != NULL) {
size_t encrypted_length = wrt_s + 32; // 16 extra just in case
void* encrypted = pmalloc(packet->pool, encrypted_length);
if (EVP_EncryptUpdate(conn->aes_ctx_enc, encrypted, &encrypted_length, wrt, (int) wrt_s) != 1) {
wrt_s = (size_t) -1;
goto rret;
}
xfer_address = wrt = encrypted;
wrt_s = encrypted_length;
}
pxfer(packet->pool, conn->managed_conn->write_buffer.pool, xfer_address);
buffer_push_partial(&conn->managed_conn->write_buffer, xfer_address, wrt, wrt_s);
rret: ;
return wrt_s;
}
Reference in New Issue View Git Blame Copy Permalink