backups/4jcraft
1
0
Fork 0
mirror of https://github.com/4jcraft/4jcraft.git synced 2026-04-24 16:13:51 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
4jcraft/Minecraft.World/Level/Storage/MapItemSavedData.cpp
Tropical e45151ae64 refactor: expand AUTO_VAR macro
2026-03-29 23:59:05 -05:00

582 lines
23 KiB
C++
Raw Blame History

#include "../../Platform/stdafx.h"
#include "../../Headers/com.mojang.nbt.h"
#include "../../Headers/net.minecraft.world.entity.player.h"
#include "../../Headers/net.minecraft.world.item.h"
#include "MapItemSavedData.h"
#include "../../../Minecraft.Client/Network/PlayerList.h"
#include "../../../Minecraft.Client/MinecraftServer.h"
#include "../../../Minecraft.Client/Player/ServerPlayer.h"
#include "../../Headers/net.minecraft.world.level.h"
#include "../../Headers/net.minecraft.world.level.storage.h"
#include "../../../Minecraft.Client/Network/PlayerConnection.h"
const int MapItemSavedData::END_PORTAL_DECORATION_KEY = -1;
// 4J added entityId param
MapItemSavedData::MapDecoration::MapDecoration(char img, char x, char y,
char rot, int entityId,
bool visible) {
this->img = img;
this->x = x;
this->y = y;
this->rot = rot;
this->entityId = entityId;
this->visible = visible;
}
MapItemSavedData::HoldingPlayer::HoldingPlayer(std::shared_ptr<Player> player,
const MapItemSavedData* parent)
: parent(parent), player(player) {
// inited outside of ctor
rowsDirtyMin = intArray(MapItem::IMAGE_WIDTH);
rowsDirtyMax = intArray(MapItem::IMAGE_WIDTH);
tick = 0;
sendPosTick = 0;
step = 0;
hasSentInitial = false;
// java ctor
// this->player = player;
for (unsigned int i = 0; i < rowsDirtyMin.length; i++) {
rowsDirtyMin[i] = 0;
rowsDirtyMax[i] = MapItem::IMAGE_HEIGHT - 1;
}
}
MapItemSavedData::HoldingPlayer::~HoldingPlayer() {
delete rowsDirtyMin.data;
delete rowsDirtyMax.data;
delete lastSentDecorations.data;
}
charArray MapItemSavedData::HoldingPlayer::nextUpdatePacket(
std::shared_ptr<ItemInstance> itemInstance) {
if (!hasSentInitial) {
charArray data(2);
data[0] = HEADER_METADATA;
data[1] = parent->scale;
hasSentInitial = true;
return data;
}
if (--sendPosTick < 0) {
sendPosTick = 4;
unsigned int playerDecorationsSize = (int)parent->decorations.size();
unsigned int nonPlayerDecorationsSize =
(int)parent->nonPlayerDecorations.size();
charArray data =
charArray((playerDecorationsSize + nonPlayerDecorationsSize) *
DEC_PACKET_BYTES +
1);
data[0] = 1;
for (unsigned int i = 0; i < parent->decorations.size(); i++) {
MapDecoration* md = parent->decorations.at(i);
#if defined(_LARGE_WORLDS)
data[i * DEC_PACKET_BYTES + 1] = (char)(md->img);
data[i * DEC_PACKET_BYTES + 8] = (char)(md->rot & 0xF);
#else
data[i * DEC_PACKET_BYTES + 1] =
(char)((md->img << 4) | (md->rot & 0xF));
#endif
data[i * DEC_PACKET_BYTES + 2] = md->x;
data[i * DEC_PACKET_BYTES + 3] = md->y;
data[i * DEC_PACKET_BYTES + 4] = md->entityId & 0xFF;
data[i * DEC_PACKET_BYTES + 5] = (md->entityId >> 8) & 0xFF;
data[i * DEC_PACKET_BYTES + 6] = (md->entityId >> 16) & 0xFF;
data[i * DEC_PACKET_BYTES + 7] = (md->entityId >> 24) & 0x7F;
data[i * DEC_PACKET_BYTES + 7] |= md->visible ? 0x80 : 0x0;
}
unsigned int dataIndex = playerDecorationsSize;
for (auto it = parent->nonPlayerDecorations.begin();
it != parent->nonPlayerDecorations.end(); ++it) {
MapDecoration* md = it->second;
#if defined(_LARGE_WORLDS)
data[dataIndex * DEC_PACKET_BYTES + 1] = (char)(md->img);
data[dataIndex * DEC_PACKET_BYTES + 8] = (char)(md->rot & 0xF);
#else
data[dataIndex * DEC_PACKET_BYTES + 1] =
(char)((md->img << 4) | (md->rot & 0xF));
#endif
data[dataIndex * DEC_PACKET_BYTES + 2] = md->x;
data[dataIndex * DEC_PACKET_BYTES + 3] = md->y;
data[dataIndex * DEC_PACKET_BYTES + 4] = md->entityId & 0xFF;
data[dataIndex * DEC_PACKET_BYTES + 5] = (md->entityId >> 8) & 0xFF;
data[dataIndex * DEC_PACKET_BYTES + 6] =
(md->entityId >> 16) & 0xFF;
data[dataIndex * DEC_PACKET_BYTES + 7] =
(md->entityId >> 24) & 0x7F;
data[dataIndex * DEC_PACKET_BYTES + 7] |= md->visible ? 0x80 : 0x0;
++dataIndex;
}
bool thesame = !itemInstance->isFramed();
if (lastSentDecorations.data == NULL ||
lastSentDecorations.length != data.length) {
thesame = false;
} else {
for (unsigned int i = 0; i < data.length; i++) {
if (data[i] != lastSentDecorations[i]) {
thesame = false;
break;
}
}
}
if (!thesame) {
if (lastSentDecorations.data != NULL) {
delete[] lastSentDecorations.data;
}
// Make a copy of data, as the calling function presumes it can
// destroy the returned data
lastSentDecorations = charArray(data.length);
memcpy(lastSentDecorations.data, data.data, data.length);
return data;
}
delete[] data.data; // 4jcraft, changed to []
}
std::shared_ptr<ServerPlayer> servPlayer =
std::dynamic_pointer_cast<ServerPlayer>(player);
for (int d = 0; d < 10; d++) {
int column = (tick++ * 11) % (MapItem::IMAGE_WIDTH);
if (rowsDirtyMin[column] >= 0) {
int len = rowsDirtyMax[column] - rowsDirtyMin[column] + 1;
int min = rowsDirtyMin[column];
charArray data = charArray(len + 3);
data[0] = HEADER_COLOURS;
data[1] = (char)column;
data[2] = (char)min;
for (unsigned int y = 0; y < data.length - 3; y++) {
data[y + 3] =
parent->colors[(y + min) * MapItem::IMAGE_WIDTH + column];
}
rowsDirtyMax[column] = -1;
rowsDirtyMin[column] = -1;
return data;
}
}
return charArray();
}
MapItemSavedData::MapItemSavedData(const std::wstring& id) : SavedData(id) {
x = z = 0;
dimension = 0;
scale = 0;
colors = byteArray(MapItem::IMAGE_WIDTH * MapItem::IMAGE_HEIGHT);
}
MapItemSavedData::~MapItemSavedData() {
delete colors.data;
for (unsigned int i = 0; i < decorations.size(); i++) {
delete decorations[i];
}
}
void MapItemSavedData::load(CompoundTag* tag) {
dimension = tag->getByte(L"dimension");
x = tag->getInt(L"xCenter");
z = tag->getInt(L"zCenter");
scale = tag->getByte(L"scale");
if (scale < 0) scale = 0;
if (scale > MAX_SCALE) scale = MAX_SCALE;
int width = tag->getShort(L"width");
int height = tag->getShort(L"height");
if (width == MapItem::IMAGE_WIDTH && height == MapItem::IMAGE_HEIGHT) {
colors = tag->getByteArray(L"colors");
} else {
byteArray newColors = tag->getByteArray(L"colors");
// 4J
if (colors.data != NULL) {
delete[] colors.data;
}
// End4J
colors = byteArray(MapItem::IMAGE_WIDTH * MapItem::IMAGE_HEIGHT);
int xo = (MapItem::IMAGE_WIDTH - width) / 2;
int yo = (MapItem::IMAGE_HEIGHT - height) / 2;
for (int y = 0; y < height; y++) {
int yt = y + yo;
if (yt < 0 && yt >= MapItem::IMAGE_HEIGHT) continue;
for (int x = 0; x < width; x++) {
int xt = x + xo;
if (xt < 0 && xt >= MapItem::IMAGE_WIDTH) continue;
colors[xt + yt * MapItem::IMAGE_WIDTH] =
newColors[x + y * width];
}
}
}
}
void MapItemSavedData::save(CompoundTag* tag) {
tag->putByte(L"dimension", dimension);
tag->putInt(L"xCenter", x);
tag->putInt(L"zCenter", z);
tag->putByte(L"scale", scale);
tag->putShort(L"width", (short)MapItem::IMAGE_WIDTH);
tag->putShort(L"height", (short)MapItem::IMAGE_HEIGHT);
tag->putByteArray(L"colors", colors);
}
void MapItemSavedData::tickCarriedBy(std::shared_ptr<Player> player,
std::shared_ptr<ItemInstance> item) {
if (carriedByPlayers.find(player) == carriedByPlayers.end()) {
std::shared_ptr<HoldingPlayer> hp =
std::shared_ptr<HoldingPlayer>(new HoldingPlayer(player, this));
carriedByPlayers.insert(
playerHoldingPlayerMapType::value_type(player, hp));
carriedBy.push_back(hp);
}
for (unsigned int i = 0; i < decorations.size(); i++) {
delete decorations[i];
}
decorations.clear();
// 4J Stu - Put this block back in if you want to display entity positions
// on a map (see below)
bool addedPlayers = false;
for (auto it = carriedBy.begin(); it != carriedBy.end();) {
std::shared_ptr<HoldingPlayer> hp = *it;
// 4J Stu - Players in the same dimension as an item frame with a map
// need to be sent this data, so don't remove them
if (hp->player->removed) //|| (!hp->player->inventory->contains(item)
//&& !item->isFramed() ))
{
auto it2 = carriedByPlayers.find(
(std::shared_ptr<Player>)hp->player);
if (it2 != carriedByPlayers.end()) {
carriedByPlayers.erase(it2);
}
it = carriedBy.erase(find(carriedBy.begin(), carriedBy.end(), hp));
} else {
++it;
Level* playerLevel = hp->player->level;
if (!playerLevel->isClientSide && hp->player->dimension == 0 &&
(playerLevel->getLevelData()->getHasStrongholdEndPortal() ||
playerLevel->getLevelData()->getHasStronghold())) {
bool atLeastOnePlayerInTheEnd = false;
PlayerList* players =
MinecraftServer::getInstance()->getPlayerList();
for (auto it3 = players->players.begin();
it3 != players->players.end(); ++it3) {
std::shared_ptr<ServerPlayer> serverPlayer = *it3;
if (serverPlayer->dimension == 1) {
atLeastOnePlayerInTheEnd = true;
break;
}
}
auto currentPortalDecoration =
nonPlayerDecorations.find(END_PORTAL_DECORATION_KEY);
if (currentPortalDecoration == nonPlayerDecorations.end() &&
atLeastOnePlayerInTheEnd) {
float origX = 0.0f;
float origZ = 0.0f;
if (playerLevel->getLevelData()
->getHasStrongholdEndPortal()) {
origX = playerLevel->getLevelData()
->getXStrongholdEndPortal();
origZ = playerLevel->getLevelData()
->getZStrongholdEndPortal();
} else {
origX = playerLevel->getLevelData()->getXStronghold()
<< 4;
origZ = playerLevel->getLevelData()->getZStronghold()
<< 4;
}
float xd = (float)(origX - x) / (1 << scale);
float yd = (float)(origZ - z) / (1 << scale);
char x = (char)(xd * 2 + 0.5);
char y = (char)(yd * 2 + 0.5);
int size = MAP_SIZE - 1;
#if defined(_LARGE_WORLDS)
if (xd < -size || yd < -size || xd > size || yd > size) {
if (xd <= -size) x = (uint8_t)(size * 2 + 2.5);
if (yd <= -size) y = (uint8_t)(size * 2 + 2.5);
if (xd >= size) x = (uint8_t)(size * 2 + 1);
if (yd >= size) y = (uint8_t)(size * 2 + 1);
}
#endif
// decorations.push_back(new MapDecoration(4, x, y, 0));
nonPlayerDecorations.insert(
std::unordered_map<int, MapDecoration*>::value_type(
END_PORTAL_DECORATION_KEY,
new MapDecoration(
4, x, y, 0, END_PORTAL_DECORATION_KEY, true)));
} else if (currentPortalDecoration !=
nonPlayerDecorations.end() &&
!atLeastOnePlayerInTheEnd) {
delete currentPortalDecoration->second;
nonPlayerDecorations.erase(currentPortalDecoration);
}
}
if (item->isFramed()) {
// addDecoration(1, player.level, "frame-" +
// item.getFrame().entityId, item.getFrame().xTile,
// item.getFrame().zTile, item.getFrame().dir * 90);
if (nonPlayerDecorations.find(item->getFrame()->entityId) ==
nonPlayerDecorations.end()) {
float xd =
(float)(item->getFrame()->xTile - x) / (1 << scale);
float yd =
(float)(item->getFrame()->zTile - z) / (1 << scale);
char x = (char)(xd * 2 + 0.5);
char y = (char)(yd * 2 + 0.5);
int size = MAP_SIZE - 1;
char rot = (char)((item->getFrame()->dir * 90) * 16 / 360);
if (dimension < 0) {
int s =
(int)(playerLevel->getLevelData()->getDayTime() /
10);
rot = (char)((s * s * 34187121 + s * 121) >> 15 & 15);
}
#if defined(_LARGE_WORLDS)
if (xd < -size || yd < -size || xd > size || yd > size) {
if (xd <= -size) x = (uint8_t)(size * 2 + 2.5);
if (yd <= -size) y = (uint8_t)(size * 2 + 2.5);
if (xd >= size) x = (uint8_t)(size * 2 + 1);
if (yd >= size) y = (uint8_t)(size * 2 + 1);
}
#endif
// decorations.push_back(new MapDecoration(7, x, y, 0));
nonPlayerDecorations.insert(
std::unordered_map<int, MapDecoration*>::value_type(
item->getFrame()->entityId,
new MapDecoration(12, x, y, rot,
item->getFrame()->entityId,
true)));
}
}
// 4J Stu - Put this block back in if you want to display entity
// positions on a map (see above as well)
// 4J-PB - display all the players in the map
// For the xbox, x and z are 0
if (hp->player->dimension == this->dimension && !addedPlayers) {
addedPlayers = true;
PlayerList* players =
MinecraftServer::getInstance()->getPlayerList();
for (auto it3 = players->players.begin();
it3 != players->players.end(); ++it3) {
std::shared_ptr<ServerPlayer> decorationPlayer = *it3;
if (decorationPlayer != NULL &&
decorationPlayer->dimension == this->dimension) {
float xd =
(float)(decorationPlayer->x - x) / (1 << scale);
float yd =
(float)(decorationPlayer->z - z) / (1 << scale);
char x = (char)(xd * 2);
char y = (char)(yd * 2);
int size = MAP_SIZE; // - 1;
char rot;
char imgIndex;
#if defined(_LARGE_WORLDS)
if (xd > -size && yd > -size && xd <= size &&
yd <= size)
#endif
{
rot =
(char)(decorationPlayer->yRot * 16 / 360 + 0.5);
if (dimension < 0) {
int s = (int)(playerLevel->getLevelData()
->getDayTime() /
10);
rot =
(char)((s * s * 34187121 + s * 121) >> 15 &
15);
}
// 4J Stu - As we have added new icons for players
// on a new row below other icons used in Java we
// need to move our index to the next row
imgIndex = (int)decorationPlayer->getPlayerIndex();
if (imgIndex > 3) imgIndex += 4;
}
#if defined(_LARGE_WORLDS)
else // if (abs(xd) < MAP_SIZE * 5 && abs(yd) <
// MAP_SIZE * 5)
{
// 4J Stu - As we have added new icons for players
// on a new row below other icons used in Java we
// need to move our index to the next row
imgIndex = (int)decorationPlayer->getPlayerIndex();
if (imgIndex > 3) imgIndex += 4;
imgIndex += 16; // Add 16 to indicate that it's on
// the next texture
rot = 0;
size--; // Added to match the old adjusted size
if (xd <= -size) x = (uint8_t)(size * 2 + 2.5);
if (yd <= -size) y = (uint8_t)(size * 2 + 2.5);
if (xd >= size) x = (uint8_t)(size * 2 + 1);
if (yd >= size) y = (uint8_t)(size * 2 + 1);
}
#endif
MemSect(45);
decorations.push_back(new MapDecoration(
imgIndex, x, y, rot, decorationPlayer->entityId,
(decorationPlayer == hp->player ||
decorationPlayer->canShowOnMaps())));
MemSect(0);
}
}
}
// float xd = (float) (hp->player->x - x) / (1 <<
// scale); float yd = (float) (hp->player->z - z) /
// (1 << scale); int ww = 64;
// int hh = 64; if (xd >= -ww && yd >= -hh && xd
// <= ww && yd <= hh)
// {
// char img = 0;
// char x = (char) (xd * 2 + 0.5);
// char y = (char) (yd * 2 + 0.5);
// char rot = (char) (player->yRot * 16 /
// 360 + 0.5); if (dimension < 0)
// {
// int s = step / 10;
// rot = (char) ((s * s * 34187121
// + s * 121) >> 15 & 15);
// }
// if (hp->player->dimension ==
// this->dimension)
// {
// decorations.push_back(new
// MapDecoration(img, x, y, rot));
// }
// }
}
}
}
charArray MapItemSavedData::getUpdatePacket(
std::shared_ptr<ItemInstance> itemInstance, Level* level,
std::shared_ptr<Player> player) {
auto it = carriedByPlayers.find(player);
if (it == carriedByPlayers.end()) return charArray();
std::shared_ptr<HoldingPlayer> hp = it->second;
return hp->nextUpdatePacket(itemInstance);
}
void MapItemSavedData::setDirty(int x, int y0, int y1) {
SavedData::setDirty();
auto itEnd = carriedBy.end();
for (auto it = carriedBy.begin(); it != itEnd; it++) {
std::shared_ptr<HoldingPlayer> hp = *it; // carriedBy.at(i);
if (hp->rowsDirtyMin[x] < 0 || hp->rowsDirtyMin[x] > y0)
hp->rowsDirtyMin[x] = y0;
if (hp->rowsDirtyMax[x] < 0 || hp->rowsDirtyMax[x] < y1)
hp->rowsDirtyMax[x] = y1;
}
}
void MapItemSavedData::handleComplexItemData(charArray& data) {
if (data[0] == HEADER_COLOURS) {
int xx = data[1] & 0xff;
int yy = data[2] & 0xff;
for (unsigned int y = 0; y < data.length - 3; y++) {
colors[(y + yy) * MapItem::IMAGE_WIDTH + xx] = data[y + 3];
}
setDirty();
} else if (data[0] == HEADER_DECORATIONS) {
for (unsigned int i = 0; i < decorations.size(); i++) {
delete decorations[i];
}
decorations.clear();
for (unsigned int i = 0; i < (data.length - 1) / DEC_PACKET_BYTES;
i++) {
#if defined(_LARGE_WORLDS)
char img = data[i * DEC_PACKET_BYTES + 1];
char rot = data[i * DEC_PACKET_BYTES + 8];
#else
// 4J-PB - this gives the wrong result
char img =
(char)((((int)data[i * DEC_PACKET_BYTES + 1]) & 0xF0) >> 4);
char rot = (char)(data[i * DEC_PACKET_BYTES + 1] & 0xF);
#endif
char x = data[i * DEC_PACKET_BYTES + 2];
char y = data[i * DEC_PACKET_BYTES + 3];
int entityId =
(((int)data[i * DEC_PACKET_BYTES + 4]) & 0xFF) |
((((int)data[i * DEC_PACKET_BYTES + 5]) & 0xFF) << 8) |
((((int)data[i * DEC_PACKET_BYTES + 6]) & 0xFF) << 16) |
((((int)data[i * DEC_PACKET_BYTES + 7]) & 0x7F) << 24);
bool visible = (data[i * DEC_PACKET_BYTES + 7] & 0x80) != 0;
decorations.push_back(
new MapDecoration(img, x, y, rot, entityId, visible));
}
} else if (data[0] == HEADER_METADATA) {
scale = data[1];
}
}
std::shared_ptr<MapItemSavedData::HoldingPlayer>
MapItemSavedData::getHoldingPlayer(std::shared_ptr<Player> player) {
std::shared_ptr<HoldingPlayer> hp = nullptr;
auto it = carriedByPlayers.find(player);
if (it == carriedByPlayers.end()) {
hp = std::shared_ptr<HoldingPlayer>(new HoldingPlayer(player, this));
carriedByPlayers[player] = hp;
carriedBy.push_back(hp);
} else {
hp = it->second;
}
return hp;
}
// 4J Added
// We only have one map per player per dimension, so if they pickup someone
// elses map we merge their map data with ours so that we can see everything
// that they discovered but still only have one map data ourself
void MapItemSavedData::mergeInMapData(
std::shared_ptr<MapItemSavedData> dataToAdd) {
int w = MapItem::IMAGE_WIDTH;
int h = MapItem::IMAGE_HEIGHT;
for (int x = 0; x < w; x++) {
int yd0 = 255;
int yd1 = 0;
for (int z = 0; z < h; z++) {
uint8_t oldColor = colors[x + z * w];
uint8_t newColor = dataToAdd->colors[x + z * w];
if (oldColor == 0 && oldColor != newColor) {
if (yd0 > z) yd0 = z;
if (yd1 < z) yd1 = z;
colors[x + z * w] = newColor;
}
}
if (yd0 <= yd1) {
setDirty(x, yd0, yd1);
}
}
}
void MapItemSavedData::removeItemFrameDecoration(
std::shared_ptr<ItemInstance> item) {
auto frameDecoration =
nonPlayerDecorations.find(item->getFrame()->entityId);
if (frameDecoration != nonPlayerDecorations.end()) {
delete frameDecoration->second;
nonPlayerDecorations.erase(frameDecoration);
}
}
Reference in a new issue View git blame Copy permalink