mirror of
https://git.huckle.dev/Huckles-Minecraft-Archive/4jcraft.git
synced 2026-05-24 16:14:52 +00:00
chore: format Minecraft.World
This commit is contained in:
Tropical
@@ -7,69 +7,67 @@
|
||||
#include "../Headers/net.minecraft.world.item.h"
|
||||
#include "SyncedEntityData.h"
|
||||
|
||||
SynchedEntityData::SynchedEntityData()
|
||||
{
|
||||
m_isDirty = false;
|
||||
m_isEmpty = true;
|
||||
SynchedEntityData::SynchedEntityData() {
|
||||
m_isDirty = false;
|
||||
m_isEmpty = true;
|
||||
}
|
||||
|
||||
void SynchedEntityData::define(int id, int value)
|
||||
{
|
||||
MemSect(17);
|
||||
checkId(id);
|
||||
int type = TYPE_INT;
|
||||
std::shared_ptr<DataItem> dataItem = std::shared_ptr<DataItem>( new DataItem(type, id, value) );
|
||||
itemsById[id] = dataItem;
|
||||
MemSect(0);
|
||||
m_isEmpty = false;
|
||||
void SynchedEntityData::define(int id, int value) {
|
||||
MemSect(17);
|
||||
checkId(id);
|
||||
int type = TYPE_INT;
|
||||
std::shared_ptr<DataItem> dataItem =
|
||||
std::shared_ptr<DataItem>(new DataItem(type, id, value));
|
||||
itemsById[id] = dataItem;
|
||||
MemSect(0);
|
||||
m_isEmpty = false;
|
||||
}
|
||||
|
||||
void SynchedEntityData::define(int id, uint8_t value)
|
||||
{
|
||||
MemSect(17);
|
||||
checkId(id);
|
||||
int type = TYPE_BYTE;
|
||||
std::shared_ptr<DataItem> dataItem = std::shared_ptr<DataItem>( new DataItem(type, id, value) );
|
||||
itemsById[id] = dataItem;
|
||||
MemSect(0);
|
||||
m_isEmpty = false;
|
||||
void SynchedEntityData::define(int id, uint8_t value) {
|
||||
MemSect(17);
|
||||
checkId(id);
|
||||
int type = TYPE_BYTE;
|
||||
std::shared_ptr<DataItem> dataItem =
|
||||
std::shared_ptr<DataItem>(new DataItem(type, id, value));
|
||||
itemsById[id] = dataItem;
|
||||
MemSect(0);
|
||||
m_isEmpty = false;
|
||||
}
|
||||
|
||||
void SynchedEntityData::define(int id, short value)
|
||||
{
|
||||
MemSect(17);
|
||||
checkId(id);
|
||||
int type = TYPE_SHORT;
|
||||
std::shared_ptr<DataItem> dataItem = std::shared_ptr<DataItem>( new DataItem(type, id, value) );
|
||||
itemsById[id] = dataItem;
|
||||
MemSect(0);
|
||||
m_isEmpty = false;
|
||||
void SynchedEntityData::define(int id, short value) {
|
||||
MemSect(17);
|
||||
checkId(id);
|
||||
int type = TYPE_SHORT;
|
||||
std::shared_ptr<DataItem> dataItem =
|
||||
std::shared_ptr<DataItem>(new DataItem(type, id, value));
|
||||
itemsById[id] = dataItem;
|
||||
MemSect(0);
|
||||
m_isEmpty = false;
|
||||
}
|
||||
|
||||
void SynchedEntityData::define(int id, const std::wstring& value)
|
||||
{
|
||||
MemSect(17);
|
||||
checkId(id);
|
||||
int type = TYPE_STRING;
|
||||
std::shared_ptr<DataItem> dataItem = std::shared_ptr<DataItem>( new DataItem(type, id, value) );
|
||||
itemsById[id] = dataItem;
|
||||
MemSect(0);
|
||||
m_isEmpty = false;
|
||||
void SynchedEntityData::define(int id, const std::wstring& value) {
|
||||
MemSect(17);
|
||||
checkId(id);
|
||||
int type = TYPE_STRING;
|
||||
std::shared_ptr<DataItem> dataItem =
|
||||
std::shared_ptr<DataItem>(new DataItem(type, id, value));
|
||||
itemsById[id] = dataItem;
|
||||
MemSect(0);
|
||||
m_isEmpty = false;
|
||||
}
|
||||
|
||||
void SynchedEntityData::defineNULL(int id, void *pVal)
|
||||
{
|
||||
MemSect(17);
|
||||
checkId(id);
|
||||
int type = TYPE_ITEMINSTANCE;
|
||||
std::shared_ptr<DataItem> dataItem = std::shared_ptr<DataItem>( new DataItem(type, id, std::shared_ptr<ItemInstance>()) );
|
||||
itemsById[id] = dataItem;
|
||||
MemSect(0);
|
||||
m_isEmpty = false;
|
||||
void SynchedEntityData::defineNULL(int id, void* pVal) {
|
||||
MemSect(17);
|
||||
checkId(id);
|
||||
int type = TYPE_ITEMINSTANCE;
|
||||
std::shared_ptr<DataItem> dataItem = std::shared_ptr<DataItem>(
|
||||
new DataItem(type, id, std::shared_ptr<ItemInstance>()));
|
||||
itemsById[id] = dataItem;
|
||||
MemSect(0);
|
||||
m_isEmpty = false;
|
||||
}
|
||||
|
||||
void SynchedEntityData::checkId(int id)
|
||||
{
|
||||
void SynchedEntityData::checkId(int id) {
|
||||
#if 0
|
||||
if (id > MAX_ID_VALUE)
|
||||
{
|
||||
@@ -82,476 +80,411 @@ void SynchedEntityData::checkId(int id)
|
||||
#endif
|
||||
}
|
||||
|
||||
uint8_t SynchedEntityData::getByte(int id)
|
||||
{
|
||||
return itemsById[id]->getValue_byte();
|
||||
uint8_t SynchedEntityData::getByte(int id) {
|
||||
return itemsById[id]->getValue_byte();
|
||||
}
|
||||
|
||||
short SynchedEntityData::getShort(int id)
|
||||
{
|
||||
return itemsById[id]->getValue_short();
|
||||
short SynchedEntityData::getShort(int id) {
|
||||
return itemsById[id]->getValue_short();
|
||||
}
|
||||
|
||||
int SynchedEntityData::getInteger(int id)
|
||||
{
|
||||
return itemsById[id]->getValue_int();
|
||||
int SynchedEntityData::getInteger(int id) {
|
||||
return itemsById[id]->getValue_int();
|
||||
}
|
||||
|
||||
float SynchedEntityData::getFloat(int id)
|
||||
{
|
||||
assert(false); // 4J - not currently implemented
|
||||
return 0;
|
||||
float SynchedEntityData::getFloat(int id) {
|
||||
assert(false); // 4J - not currently implemented
|
||||
return 0;
|
||||
}
|
||||
|
||||
std::wstring SynchedEntityData::getString(int id)
|
||||
{
|
||||
return itemsById[id]->getValue_wstring();
|
||||
std::wstring SynchedEntityData::getString(int id) {
|
||||
return itemsById[id]->getValue_wstring();
|
||||
}
|
||||
|
||||
std::shared_ptr<ItemInstance> SynchedEntityData::getItemInstance(int id)
|
||||
{
|
||||
//assert(false); // 4J - not currently implemented
|
||||
return itemsById[id]->getValue_itemInstance();
|
||||
std::shared_ptr<ItemInstance> SynchedEntityData::getItemInstance(int id) {
|
||||
// assert(false); // 4J - not currently implemented
|
||||
return itemsById[id]->getValue_itemInstance();
|
||||
}
|
||||
|
||||
Pos *SynchedEntityData::getPos(int id)
|
||||
{
|
||||
assert(false); // 4J - not currently implemented
|
||||
return NULL;
|
||||
Pos* SynchedEntityData::getPos(int id) {
|
||||
assert(false); // 4J - not currently implemented
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void SynchedEntityData::set(int id, int value)
|
||||
{
|
||||
std::shared_ptr<DataItem> dataItem = itemsById[id];
|
||||
void SynchedEntityData::set(int id, int value) {
|
||||
std::shared_ptr<DataItem> dataItem = itemsById[id];
|
||||
|
||||
// update the value if it has changed
|
||||
if (value != dataItem->getValue_int())
|
||||
{
|
||||
dataItem->setValue(value);
|
||||
dataItem->setDirty(true);
|
||||
m_isDirty = true;
|
||||
}
|
||||
// update the value if it has changed
|
||||
if (value != dataItem->getValue_int()) {
|
||||
dataItem->setValue(value);
|
||||
dataItem->setDirty(true);
|
||||
m_isDirty = true;
|
||||
}
|
||||
}
|
||||
|
||||
void SynchedEntityData::set(int id, uint8_t value)
|
||||
{
|
||||
std::shared_ptr<DataItem> dataItem = itemsById[id];
|
||||
void SynchedEntityData::set(int id, uint8_t value) {
|
||||
std::shared_ptr<DataItem> dataItem = itemsById[id];
|
||||
|
||||
// update the value if it has changed
|
||||
if (value != dataItem->getValue_byte())
|
||||
{
|
||||
dataItem->setValue(value);
|
||||
dataItem->setDirty(true);
|
||||
m_isDirty = true;
|
||||
}
|
||||
// update the value if it has changed
|
||||
if (value != dataItem->getValue_byte()) {
|
||||
dataItem->setValue(value);
|
||||
dataItem->setDirty(true);
|
||||
m_isDirty = true;
|
||||
}
|
||||
}
|
||||
|
||||
void SynchedEntityData::set(int id, short value)
|
||||
{
|
||||
std::shared_ptr<DataItem> dataItem = itemsById[id];
|
||||
void SynchedEntityData::set(int id, short value) {
|
||||
std::shared_ptr<DataItem> dataItem = itemsById[id];
|
||||
|
||||
// update the value if it has changed
|
||||
if (value != dataItem->getValue_short())
|
||||
{
|
||||
dataItem->setValue(value);
|
||||
dataItem->setDirty(true);
|
||||
m_isDirty = true;
|
||||
}
|
||||
// update the value if it has changed
|
||||
if (value != dataItem->getValue_short()) {
|
||||
dataItem->setValue(value);
|
||||
dataItem->setDirty(true);
|
||||
m_isDirty = true;
|
||||
}
|
||||
}
|
||||
|
||||
void SynchedEntityData::set(int id, const std::wstring& value)
|
||||
{
|
||||
std::shared_ptr<DataItem> dataItem = itemsById[id];
|
||||
void SynchedEntityData::set(int id, const std::wstring& value) {
|
||||
std::shared_ptr<DataItem> dataItem = itemsById[id];
|
||||
|
||||
// update the value if it has changed
|
||||
if (value != dataItem->getValue_wstring())
|
||||
{
|
||||
dataItem->setValue(value);
|
||||
dataItem->setDirty(true);
|
||||
m_isDirty = true;
|
||||
}
|
||||
// update the value if it has changed
|
||||
if (value != dataItem->getValue_wstring()) {
|
||||
dataItem->setValue(value);
|
||||
dataItem->setDirty(true);
|
||||
m_isDirty = true;
|
||||
}
|
||||
}
|
||||
|
||||
void SynchedEntityData::set(int id, std::shared_ptr<ItemInstance> value)
|
||||
{
|
||||
std::shared_ptr<DataItem> dataItem = itemsById[id];
|
||||
void SynchedEntityData::set(int id, std::shared_ptr<ItemInstance> value) {
|
||||
std::shared_ptr<DataItem> dataItem = itemsById[id];
|
||||
|
||||
// update the value if it has changed
|
||||
if (value != dataItem->getValue_itemInstance())
|
||||
{
|
||||
dataItem->setValue(value);
|
||||
dataItem->setDirty(true);
|
||||
m_isDirty = true;
|
||||
}
|
||||
// update the value if it has changed
|
||||
if (value != dataItem->getValue_itemInstance()) {
|
||||
dataItem->setValue(value);
|
||||
dataItem->setDirty(true);
|
||||
m_isDirty = true;
|
||||
}
|
||||
}
|
||||
|
||||
void SynchedEntityData::markDirty(int id)
|
||||
{
|
||||
(*itemsById.find(id)).second->dirty = true;
|
||||
m_isDirty = true;
|
||||
void SynchedEntityData::markDirty(int id) {
|
||||
(*itemsById.find(id)).second->dirty = true;
|
||||
m_isDirty = true;
|
||||
}
|
||||
|
||||
bool SynchedEntityData::isDirty()
|
||||
bool SynchedEntityData::isDirty() { return m_isDirty; }
|
||||
|
||||
void SynchedEntityData::pack(
|
||||
std::vector<std::shared_ptr<DataItem> >* items,
|
||||
DataOutputStream* output) // TODO throws IOException
|
||||
{
|
||||
return m_isDirty;
|
||||
if (items != NULL) {
|
||||
AUTO_VAR(itEnd, items->end());
|
||||
for (AUTO_VAR(it, items->begin()); it != itEnd; it++) {
|
||||
std::shared_ptr<DataItem> dataItem = *it;
|
||||
writeDataItem(output, dataItem);
|
||||
}
|
||||
}
|
||||
|
||||
// add an eof
|
||||
output->writeByte(EOF_MARKER);
|
||||
}
|
||||
|
||||
void SynchedEntityData::pack(std::vector<std::shared_ptr<DataItem> > *items, DataOutputStream *output) // TODO throws IOException
|
||||
{
|
||||
std::vector<std::shared_ptr<SynchedEntityData::DataItem> >*
|
||||
SynchedEntityData::packDirty() {
|
||||
std::vector<std::shared_ptr<DataItem> >* result = NULL;
|
||||
|
||||
if (items != NULL)
|
||||
{
|
||||
AUTO_VAR(itEnd, items->end());
|
||||
for (AUTO_VAR(it, items->begin()); it != itEnd; it++)
|
||||
{
|
||||
std::shared_ptr<DataItem> dataItem = *it;
|
||||
writeDataItem(output, dataItem);
|
||||
}
|
||||
}
|
||||
if (m_isDirty) {
|
||||
AUTO_VAR(itEnd, itemsById.end());
|
||||
for (AUTO_VAR(it, itemsById.begin()); it != itEnd; it++) {
|
||||
std::shared_ptr<DataItem> dataItem = (*it).second;
|
||||
if (dataItem->isDirty()) {
|
||||
dataItem->setDirty(false);
|
||||
|
||||
// add an eof
|
||||
output->writeByte(EOF_MARKER);
|
||||
if (result == NULL) {
|
||||
result = new std::vector<std::shared_ptr<DataItem> >();
|
||||
}
|
||||
result->push_back(dataItem);
|
||||
}
|
||||
}
|
||||
}
|
||||
m_isDirty = false;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<SynchedEntityData::DataItem> > *SynchedEntityData::packDirty()
|
||||
void SynchedEntityData::packAll(DataOutputStream* output) // throws IOException
|
||||
{
|
||||
AUTO_VAR(itEnd, itemsById.end());
|
||||
for (AUTO_VAR(it, itemsById.begin()); it != itEnd; it++) {
|
||||
std::shared_ptr<DataItem> dataItem = (*it).second;
|
||||
writeDataItem(output, dataItem);
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<DataItem> > *result = NULL;
|
||||
|
||||
if (m_isDirty)
|
||||
{
|
||||
AUTO_VAR(itEnd, itemsById.end());
|
||||
for ( AUTO_VAR(it, itemsById.begin()); it != itEnd; it++ )
|
||||
{
|
||||
std::shared_ptr<DataItem> dataItem = (*it).second;
|
||||
if (dataItem->isDirty())
|
||||
{
|
||||
dataItem->setDirty(false);
|
||||
|
||||
if (result == NULL)
|
||||
{
|
||||
result = new std::vector<std::shared_ptr<DataItem> >();
|
||||
}
|
||||
result->push_back(dataItem);
|
||||
}
|
||||
}
|
||||
}
|
||||
m_isDirty = false;
|
||||
|
||||
return result;
|
||||
// add an eof
|
||||
output->writeByte(EOF_MARKER);
|
||||
}
|
||||
|
||||
void SynchedEntityData::packAll(DataOutputStream *output) // throws IOException
|
||||
{
|
||||
AUTO_VAR(itEnd, itemsById.end());
|
||||
for (AUTO_VAR(it, itemsById.begin()); it != itEnd; it++ )
|
||||
{
|
||||
std::shared_ptr<DataItem> dataItem = (*it).second;
|
||||
writeDataItem(output, dataItem);
|
||||
}
|
||||
std::vector<std::shared_ptr<SynchedEntityData::DataItem> >*
|
||||
SynchedEntityData::getAll() {
|
||||
std::vector<std::shared_ptr<DataItem> >* result = NULL;
|
||||
|
||||
// add an eof
|
||||
output->writeByte(EOF_MARKER);
|
||||
AUTO_VAR(itEnd, itemsById.end());
|
||||
for (AUTO_VAR(it, itemsById.begin()); it != itEnd; it++) {
|
||||
if (result == NULL) {
|
||||
result = new std::vector<std::shared_ptr<DataItem> >();
|
||||
}
|
||||
std::shared_ptr<DataItem> dataItem = (*it).second;
|
||||
result->push_back(dataItem);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<SynchedEntityData::DataItem> > *SynchedEntityData::getAll()
|
||||
void SynchedEntityData::writeDataItem(
|
||||
DataOutputStream* output,
|
||||
std::shared_ptr<DataItem> dataItem) // throws IOException
|
||||
{
|
||||
std::vector<std::shared_ptr<DataItem> > *result = NULL;
|
||||
// pack type and id
|
||||
int header = ((dataItem->getType() << TYPE_SHIFT) |
|
||||
(dataItem->getId() & MAX_ID_VALUE)) &
|
||||
0xff;
|
||||
output->writeByte(header);
|
||||
|
||||
AUTO_VAR(itEnd, itemsById.end());
|
||||
for (AUTO_VAR(it, itemsById.begin()); it != itEnd; it++ )
|
||||
{
|
||||
if (result == NULL)
|
||||
{
|
||||
result = new std::vector<std::shared_ptr<DataItem> >();
|
||||
}
|
||||
std::shared_ptr<DataItem> dataItem = (*it).second;
|
||||
result->push_back(dataItem);
|
||||
}
|
||||
// write value
|
||||
switch (dataItem->getType()) {
|
||||
case TYPE_BYTE:
|
||||
output->writeByte(dataItem->getValue_byte());
|
||||
break;
|
||||
case TYPE_INT:
|
||||
output->writeInt(dataItem->getValue_int());
|
||||
break;
|
||||
case TYPE_SHORT:
|
||||
output->writeShort(dataItem->getValue_short());
|
||||
break;
|
||||
case TYPE_STRING:
|
||||
Packet::writeUtf(dataItem->getValue_wstring(), output);
|
||||
break;
|
||||
case TYPE_ITEMINSTANCE: {
|
||||
std::shared_ptr<ItemInstance> instance =
|
||||
(std::shared_ptr<ItemInstance>)
|
||||
dataItem->getValue_itemInstance();
|
||||
Packet::writeItem(instance, output);
|
||||
} break;
|
||||
|
||||
return result;
|
||||
default:
|
||||
assert(false); // 4J - not implemented
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void SynchedEntityData::writeDataItem(DataOutputStream *output, std::shared_ptr<DataItem> dataItem) //throws IOException
|
||||
std::vector<std::shared_ptr<SynchedEntityData::DataItem> >*
|
||||
SynchedEntityData::unpack(DataInputStream* input) // throws IOException
|
||||
{
|
||||
// pack type and id
|
||||
int header = ((dataItem->getType() << TYPE_SHIFT) | (dataItem->getId() & MAX_ID_VALUE)) & 0xff;
|
||||
output->writeByte(header);
|
||||
std::vector<std::shared_ptr<DataItem> >* result = NULL;
|
||||
|
||||
// write value
|
||||
switch (dataItem->getType())
|
||||
{
|
||||
case TYPE_BYTE:
|
||||
output->writeByte( dataItem->getValue_byte());
|
||||
break;
|
||||
case TYPE_INT:
|
||||
output->writeInt( dataItem->getValue_int());
|
||||
break;
|
||||
case TYPE_SHORT:
|
||||
output->writeShort( dataItem->getValue_short());
|
||||
break;
|
||||
case TYPE_STRING:
|
||||
Packet::writeUtf(dataItem->getValue_wstring(), output);
|
||||
break;
|
||||
case TYPE_ITEMINSTANCE:
|
||||
{
|
||||
std::shared_ptr<ItemInstance> instance = (std::shared_ptr<ItemInstance> )dataItem->getValue_itemInstance();
|
||||
Packet::writeItem(instance, output);
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
assert(false); // 4J - not implemented
|
||||
break;
|
||||
}
|
||||
}
|
||||
int currentHeader = input->readByte();
|
||||
|
||||
std::vector<std::shared_ptr<SynchedEntityData::DataItem> > *SynchedEntityData::unpack(DataInputStream *input) //throws IOException
|
||||
{
|
||||
while (currentHeader != EOF_MARKER) {
|
||||
if (result == NULL) {
|
||||
result = new std::vector<std::shared_ptr<DataItem> >();
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<DataItem> > *result = NULL;
|
||||
// split type and id
|
||||
int itemType = (currentHeader & TYPE_MASK) >> TYPE_SHIFT;
|
||||
int itemId = (currentHeader & MAX_ID_VALUE);
|
||||
|
||||
int currentHeader = input->readByte();
|
||||
std::shared_ptr<DataItem> item = std::shared_ptr<DataItem>();
|
||||
switch (itemType) {
|
||||
case TYPE_BYTE: {
|
||||
uint8_t dataRead = input->readByte();
|
||||
item = std::shared_ptr<DataItem>(
|
||||
new DataItem(itemType, itemId, dataRead));
|
||||
} break;
|
||||
case TYPE_SHORT: {
|
||||
short dataRead = input->readShort();
|
||||
item = std::shared_ptr<DataItem>(
|
||||
new DataItem(itemType, itemId, dataRead));
|
||||
} break;
|
||||
case TYPE_INT: {
|
||||
int dataRead = input->readInt();
|
||||
item = std::shared_ptr<DataItem>(
|
||||
new DataItem(itemType, itemId, dataRead));
|
||||
} break;
|
||||
case TYPE_STRING:
|
||||
item = std::shared_ptr<DataItem>(new DataItem(
|
||||
itemType, itemId,
|
||||
Packet::readUtf(input, MAX_STRING_DATA_LENGTH)));
|
||||
break;
|
||||
case TYPE_ITEMINSTANCE: {
|
||||
item = std::shared_ptr<DataItem>(
|
||||
new DataItem(itemType, itemId, Packet::readItem(input)));
|
||||
} break;
|
||||
default:
|
||||
app.DebugPrintf(
|
||||
" ------ garbage data, or early end of stream due to an "
|
||||
"incomplete packet\n");
|
||||
delete result;
|
||||
return NULL;
|
||||
break;
|
||||
}
|
||||
result->push_back(item);
|
||||
|
||||
while (currentHeader != EOF_MARKER)
|
||||
{
|
||||
currentHeader = input->readByte();
|
||||
}
|
||||
|
||||
if (result == NULL)
|
||||
{
|
||||
result = new std::vector<std::shared_ptr<DataItem> >();
|
||||
}
|
||||
|
||||
// split type and id
|
||||
int itemType = (currentHeader & TYPE_MASK) >> TYPE_SHIFT;
|
||||
int itemId = (currentHeader & MAX_ID_VALUE);
|
||||
|
||||
std::shared_ptr<DataItem> item = std::shared_ptr<DataItem>();
|
||||
switch (itemType)
|
||||
{
|
||||
case TYPE_BYTE:
|
||||
{
|
||||
uint8_t dataRead = input->readByte();
|
||||
item = std::shared_ptr<DataItem>( new DataItem(itemType, itemId, dataRead) );
|
||||
}
|
||||
break;
|
||||
case TYPE_SHORT:
|
||||
{
|
||||
short dataRead = input->readShort();
|
||||
item = std::shared_ptr<DataItem>( new DataItem(itemType, itemId, dataRead) );
|
||||
}
|
||||
break;
|
||||
case TYPE_INT:
|
||||
{
|
||||
int dataRead = input->readInt();
|
||||
item = std::shared_ptr<DataItem>( new DataItem(itemType, itemId, dataRead) );
|
||||
}
|
||||
break;
|
||||
case TYPE_STRING:
|
||||
item = std::shared_ptr<DataItem>( new DataItem(itemType, itemId, Packet::readUtf(input, MAX_STRING_DATA_LENGTH)) );
|
||||
break;
|
||||
case TYPE_ITEMINSTANCE:
|
||||
{
|
||||
item = std::shared_ptr<DataItem>(new DataItem(itemType, itemId, Packet::readItem(input)));
|
||||
}
|
||||
break;
|
||||
default:
|
||||
app.DebugPrintf(" ------ garbage data, or early end of stream due to an incomplete packet\n");
|
||||
delete result;
|
||||
return NULL;
|
||||
break;
|
||||
}
|
||||
result->push_back(item);
|
||||
|
||||
currentHeader = input->readByte();
|
||||
}
|
||||
|
||||
return result;
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Assigns values from a list of data items.
|
||||
*
|
||||
* @param items
|
||||
*/
|
||||
* Assigns values from a list of data items.
|
||||
*
|
||||
* @param items
|
||||
*/
|
||||
|
||||
void SynchedEntityData::assignValues(std::vector<std::shared_ptr<DataItem> > *items)
|
||||
{
|
||||
AUTO_VAR(itEnd, items->end());
|
||||
for (AUTO_VAR(it, items->begin()); it != itEnd; it++)
|
||||
{
|
||||
std::shared_ptr<DataItem> item = *it;
|
||||
AUTO_VAR(itemFromId, itemsById.find(item->getId()));
|
||||
if (itemFromId != itemsById.end() )
|
||||
{
|
||||
switch(item->getType())
|
||||
{
|
||||
case TYPE_BYTE:
|
||||
itemFromId->second->setValue(item->getValue_byte());
|
||||
break;
|
||||
case TYPE_SHORT:
|
||||
itemFromId->second->setValue(item->getValue_short());
|
||||
break;
|
||||
case TYPE_INT:
|
||||
itemFromId->second->setValue(item->getValue_int());
|
||||
break;
|
||||
case TYPE_STRING:
|
||||
itemFromId->second->setValue(item->getValue_wstring());
|
||||
break;
|
||||
case TYPE_ITEMINSTANCE:
|
||||
itemFromId->second->setValue(item->getValue_itemInstance());
|
||||
break;
|
||||
default:
|
||||
assert(false); // 4J - not implemented
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
void SynchedEntityData::assignValues(
|
||||
std::vector<std::shared_ptr<DataItem> >* items) {
|
||||
AUTO_VAR(itEnd, items->end());
|
||||
for (AUTO_VAR(it, items->begin()); it != itEnd; it++) {
|
||||
std::shared_ptr<DataItem> item = *it;
|
||||
AUTO_VAR(itemFromId, itemsById.find(item->getId()));
|
||||
if (itemFromId != itemsById.end()) {
|
||||
switch (item->getType()) {
|
||||
case TYPE_BYTE:
|
||||
itemFromId->second->setValue(item->getValue_byte());
|
||||
break;
|
||||
case TYPE_SHORT:
|
||||
itemFromId->second->setValue(item->getValue_short());
|
||||
break;
|
||||
case TYPE_INT:
|
||||
itemFromId->second->setValue(item->getValue_int());
|
||||
break;
|
||||
case TYPE_STRING:
|
||||
itemFromId->second->setValue(item->getValue_wstring());
|
||||
break;
|
||||
case TYPE_ITEMINSTANCE:
|
||||
itemFromId->second->setValue(item->getValue_itemInstance());
|
||||
break;
|
||||
default:
|
||||
assert(false); // 4J - not implemented
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool SynchedEntityData::isEmpty()
|
||||
{
|
||||
return m_isEmpty;
|
||||
bool SynchedEntityData::isEmpty() { return m_isEmpty; }
|
||||
|
||||
int SynchedEntityData::getSizeInBytes() {
|
||||
int size = 1;
|
||||
|
||||
AUTO_VAR(itEnd, itemsById.end());
|
||||
for (AUTO_VAR(it, itemsById.begin()); it != itEnd; it++) {
|
||||
std::shared_ptr<DataItem> dataItem = (*it).second;
|
||||
|
||||
size += 1;
|
||||
|
||||
// write value
|
||||
switch (dataItem->getType()) {
|
||||
case TYPE_BYTE:
|
||||
size += 1;
|
||||
break;
|
||||
case TYPE_SHORT:
|
||||
size += 2;
|
||||
break;
|
||||
case TYPE_INT:
|
||||
size += 4;
|
||||
break;
|
||||
case TYPE_STRING:
|
||||
size += (int)dataItem->getValue_wstring().length() +
|
||||
2; // Estimate, assuming all ascii chars
|
||||
break;
|
||||
case TYPE_ITEMINSTANCE:
|
||||
// short + byte + short
|
||||
size += 2 + 1 + 2; // Estimate, assuming all ascii chars
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
return size;
|
||||
}
|
||||
|
||||
int SynchedEntityData::getSizeInBytes()
|
||||
{
|
||||
int size = 1;
|
||||
|
||||
AUTO_VAR(itEnd, itemsById.end());
|
||||
for (AUTO_VAR(it, itemsById.begin()); it != itEnd; it++ )
|
||||
{
|
||||
std::shared_ptr<DataItem> dataItem = (*it).second;
|
||||
|
||||
size += 1;
|
||||
|
||||
// write value
|
||||
switch (dataItem->getType())
|
||||
{
|
||||
case TYPE_BYTE:
|
||||
size += 1;
|
||||
break;
|
||||
case TYPE_SHORT:
|
||||
size += 2;
|
||||
break;
|
||||
case TYPE_INT:
|
||||
size += 4;
|
||||
break;
|
||||
case TYPE_STRING:
|
||||
size += (int)dataItem->getValue_wstring().length() + 2; // Estimate, assuming all ascii chars
|
||||
break;
|
||||
case TYPE_ITEMINSTANCE:
|
||||
// short + byte + short
|
||||
size += 2 + 1 + 2; // Estimate, assuming all ascii chars
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
return size;
|
||||
}
|
||||
|
||||
|
||||
//////////////////
|
||||
// DataItem class
|
||||
/////////////////
|
||||
|
||||
SynchedEntityData::DataItem::DataItem(int type, int id, int value) : type( type ), id( id )
|
||||
{
|
||||
this->value_int = value;
|
||||
this->dirty = true;
|
||||
SynchedEntityData::DataItem::DataItem(int type, int id, int value)
|
||||
: type(type), id(id) {
|
||||
this->value_int = value;
|
||||
this->dirty = true;
|
||||
}
|
||||
|
||||
SynchedEntityData::DataItem::DataItem(int type, int id, uint8_t value) : type( type ), id( id )
|
||||
{
|
||||
this->value_byte = value;
|
||||
this->dirty = true;
|
||||
SynchedEntityData::DataItem::DataItem(int type, int id, uint8_t value)
|
||||
: type(type), id(id) {
|
||||
this->value_byte = value;
|
||||
this->dirty = true;
|
||||
}
|
||||
|
||||
SynchedEntityData::DataItem::DataItem(int type, int id, short value) : type( type ), id( id )
|
||||
{
|
||||
this->value_short = value;
|
||||
this->dirty = true;
|
||||
SynchedEntityData::DataItem::DataItem(int type, int id, short value)
|
||||
: type(type), id(id) {
|
||||
this->value_short = value;
|
||||
this->dirty = true;
|
||||
}
|
||||
|
||||
SynchedEntityData::DataItem::DataItem(int type, int id, const std::wstring& value) : type( type ), id( id )
|
||||
{
|
||||
this->value_wstring = value;
|
||||
this->dirty = true;
|
||||
SynchedEntityData::DataItem::DataItem(int type, int id,
|
||||
const std::wstring& value)
|
||||
: type(type), id(id) {
|
||||
this->value_wstring = value;
|
||||
this->dirty = true;
|
||||
}
|
||||
|
||||
SynchedEntityData::DataItem::DataItem(int type, int id, std::shared_ptr<ItemInstance> itemInstance) : type( type ), id( id )
|
||||
{
|
||||
this->value_itemInstance = itemInstance;
|
||||
this->dirty = true;
|
||||
SynchedEntityData::DataItem::DataItem(
|
||||
int type, int id, std::shared_ptr<ItemInstance> itemInstance)
|
||||
: type(type), id(id) {
|
||||
this->value_itemInstance = itemInstance;
|
||||
this->dirty = true;
|
||||
}
|
||||
|
||||
int SynchedEntityData::DataItem::getId()
|
||||
{
|
||||
return id;
|
||||
int SynchedEntityData::DataItem::getId() { return id; }
|
||||
|
||||
void SynchedEntityData::DataItem::setValue(int value) {
|
||||
this->value_int = value;
|
||||
}
|
||||
|
||||
void SynchedEntityData::DataItem::setValue(int value)
|
||||
{
|
||||
this->value_int = value;
|
||||
void SynchedEntityData::DataItem::setValue(uint8_t value) {
|
||||
this->value_byte = value;
|
||||
}
|
||||
|
||||
void SynchedEntityData::DataItem::setValue(uint8_t value)
|
||||
{
|
||||
this->value_byte = value;
|
||||
void SynchedEntityData::DataItem::setValue(short value) {
|
||||
this->value_short = value;
|
||||
}
|
||||
|
||||
void SynchedEntityData::DataItem::setValue(short value)
|
||||
{
|
||||
this->value_short = value;
|
||||
void SynchedEntityData::DataItem::setValue(const std::wstring& value) {
|
||||
this->value_wstring = value;
|
||||
}
|
||||
|
||||
void SynchedEntityData::DataItem::setValue(const std::wstring& value)
|
||||
{
|
||||
this->value_wstring = value;
|
||||
void SynchedEntityData::DataItem::setValue(
|
||||
std::shared_ptr<ItemInstance> itemInstance) {
|
||||
this->value_itemInstance = itemInstance;
|
||||
}
|
||||
|
||||
void SynchedEntityData::DataItem::setValue(std::shared_ptr<ItemInstance> itemInstance)
|
||||
{
|
||||
this->value_itemInstance = itemInstance;
|
||||
int SynchedEntityData::DataItem::getValue_int() { return value_int; }
|
||||
|
||||
short SynchedEntityData::DataItem::getValue_short() { return value_short; }
|
||||
|
||||
uint8_t SynchedEntityData::DataItem::getValue_byte() { return value_byte; }
|
||||
|
||||
std::wstring SynchedEntityData::DataItem::getValue_wstring() {
|
||||
return value_wstring;
|
||||
}
|
||||
|
||||
int SynchedEntityData::DataItem::getValue_int()
|
||||
{
|
||||
return value_int;
|
||||
std::shared_ptr<ItemInstance>
|
||||
SynchedEntityData::DataItem::getValue_itemInstance() {
|
||||
return value_itemInstance;
|
||||
}
|
||||
|
||||
short SynchedEntityData::DataItem::getValue_short()
|
||||
{
|
||||
return value_short;
|
||||
}
|
||||
int SynchedEntityData::DataItem::getType() { return type; }
|
||||
|
||||
uint8_t SynchedEntityData::DataItem::getValue_byte()
|
||||
{
|
||||
return value_byte;
|
||||
}
|
||||
bool SynchedEntityData::DataItem::isDirty() { return dirty; }
|
||||
|
||||
std::wstring SynchedEntityData::DataItem::getValue_wstring()
|
||||
{
|
||||
return value_wstring;
|
||||
}
|
||||
|
||||
std::shared_ptr<ItemInstance> SynchedEntityData::DataItem::getValue_itemInstance()
|
||||
{
|
||||
return value_itemInstance;
|
||||
}
|
||||
|
||||
int SynchedEntityData::DataItem::getType()
|
||||
{
|
||||
return type;
|
||||
}
|
||||
|
||||
bool SynchedEntityData::DataItem::isDirty()
|
||||
{
|
||||
return dirty;
|
||||
}
|
||||
|
||||
void SynchedEntityData::DataItem::setDirty(bool dirty)
|
||||
{
|
||||
this->dirty = dirty;
|
||||
}
|
||||
void SynchedEntityData::DataItem::setDirty(bool dirty) { this->dirty = dirty; }
|
||||
|
||||
Reference in New Issue
Block a user