Anvil storage writing (Basic storage is working, NO entities except for chests are working! Don't use for real servers)
git-svn-id: http://mc-server.googlecode.com/svn/trunk@475 0a769ca7-a7f5-676a-18bf-c427514a06d6
This commit is contained in:
madmaxoft@gmail.com
parent
60b5f4b66b
commit
9cb8872851
@ -235,9 +235,12 @@ public:
|
||||
class cChunkDataCollector :
|
||||
public cChunkDataCallback
|
||||
{
|
||||
protected:
|
||||
public:
|
||||
|
||||
BLOCKTYPE m_BlockData[cChunkDef::BlockDataSize];
|
||||
|
||||
protected:
|
||||
|
||||
virtual void BlockTypes(const BLOCKTYPE * a_BlockTypes) override
|
||||
{
|
||||
memcpy(m_BlockData, a_BlockTypes, cChunkDef::NumBlocks);
|
||||
@ -266,6 +269,50 @@ protected:
|
||||
|
||||
|
||||
|
||||
/** A simple implementation of the cChunkDataCallback interface that collects all block data into a separate buffers
|
||||
*/
|
||||
class cChunkDataSeparateCollector :
|
||||
public cChunkDataCallback
|
||||
{
|
||||
public:
|
||||
|
||||
BLOCKTYPE m_BlockTypes[cChunkDef::NumBlocks];
|
||||
|
||||
// TODO: These should be NIBBLETYPE:
|
||||
BLOCKTYPE m_BlockMetas[cChunkDef::NumBlocks / 2];
|
||||
BLOCKTYPE m_BlockLight[cChunkDef::NumBlocks / 2];
|
||||
BLOCKTYPE m_BlockSkyLight[cChunkDef::NumBlocks / 2];
|
||||
|
||||
protected:
|
||||
|
||||
virtual void BlockTypes(const BLOCKTYPE * a_BlockTypes) override
|
||||
{
|
||||
memcpy(m_BlockTypes, a_BlockTypes, sizeof(m_BlockTypes));
|
||||
}
|
||||
|
||||
|
||||
virtual void BlockMeta(const BLOCKTYPE * a_BlockMeta) override
|
||||
{
|
||||
memcpy(m_BlockMetas, a_BlockMeta, sizeof(m_BlockMetas));
|
||||
}
|
||||
|
||||
|
||||
virtual void BlockLight(const BLOCKTYPE * a_BlockLight) override
|
||||
{
|
||||
memcpy(m_BlockLight, a_BlockLight, sizeof(m_BlockLight));
|
||||
}
|
||||
|
||||
|
||||
virtual void BlockSkyLight(const BLOCKTYPE * a_BlockSkyLight) override
|
||||
{
|
||||
memcpy(m_BlockSkyLight, a_BlockSkyLight, sizeof(m_BlockSkyLight));
|
||||
}
|
||||
} ;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/** Interface class used for comparing clients of two chunks.
|
||||
Used primarily for entity moving while both chunks are locked.
|
||||
*/
|
||||
|
||||
@ -74,7 +74,7 @@ cNBTTag * cNBTTag::CreateTag(cNBTTag * a_Parent, eTagType a_Type, const AString
|
||||
case TAG_Double: return new cNBTDouble (a_Parent, a_Name);
|
||||
case TAG_ByteArray: return new cNBTByteArray(a_Parent, a_Name);
|
||||
case TAG_String: return new cNBTString (a_Parent, a_Name);
|
||||
case TAG_List: return new cNBTList (a_Parent, a_Name);
|
||||
case TAG_List: return new cNBTList (a_Parent, a_Name, TAG_End);
|
||||
case TAG_Compound: return new cNBTCompound (a_Parent, a_Name);
|
||||
default:
|
||||
{
|
||||
@ -128,8 +128,8 @@ void cNBTList::Clear(void)
|
||||
int cNBTList::Add(cNBTTag * iTag)
|
||||
{
|
||||
// Catch usage errors while debugging:
|
||||
ASSERT(m_ChildrenType != TAG_End);
|
||||
ASSERT(iTag->GetType() == m_ChildrenType);
|
||||
ASSERT(m_ChildrenType != TAG_End); // Didn't call SetChildrenType()
|
||||
ASSERT(iTag->GetType() == m_ChildrenType); // Child of different type
|
||||
|
||||
// Catch errors while running:
|
||||
if (m_ChildrenType == TAG_End)
|
||||
@ -535,12 +535,11 @@ int cNBTParser::ReadTag(const char ** a_Data, int * a_Length, cNBTTag::eTagType
|
||||
{
|
||||
char ItemType;
|
||||
RETURN_INT_IF_FAILED(ReadByte (a_Data, a_Length, ItemType));
|
||||
cNBTList * List = new cNBTList(a_Parent, a_Name);
|
||||
cNBTList * List = new cNBTList(a_Parent, a_Name, (cNBTTag::eTagType)ItemType);
|
||||
if (List == NULL)
|
||||
{
|
||||
return ERROR_NOT_ENOUGH_MEMORY;
|
||||
}
|
||||
RETURN_INT_IF_FAILED(List->SetChildrenType((cNBTTag::eTagType)ItemType));
|
||||
RETURN_INT_IF_FAILED(ReadList(a_Data, a_Length, List));
|
||||
*a_Tag = List;
|
||||
return ERROR_SUCCESS;
|
||||
|
||||
@ -109,8 +109,8 @@ class cNBTList :
|
||||
eTagType m_ChildrenType;
|
||||
|
||||
public:
|
||||
cNBTList(cNBTTag * a_Parent) : cNBTTag(a_Parent, TAG_List), m_ChildrenType(TAG_End) {}
|
||||
cNBTList(cNBTTag * a_Parent, const AString & a_Name) : cNBTTag(a_Parent, TAG_List, a_Name), m_ChildrenType(TAG_End) {}
|
||||
cNBTList(cNBTTag * a_Parent, eTagType a_ChildrenType) : cNBTTag(a_Parent, TAG_List), m_ChildrenType(a_ChildrenType) {}
|
||||
cNBTList(cNBTTag * a_Parent, const AString & a_Name, eTagType a_ChildrenType) : cNBTTag(a_Parent, TAG_List, a_Name), m_ChildrenType(a_ChildrenType) {}
|
||||
virtual ~cNBTList() {Clear(); }
|
||||
|
||||
void Clear (void);
|
||||
|
||||
@ -11,6 +11,10 @@
|
||||
#include "BlockID.h"
|
||||
#include "cChestEntity.h"
|
||||
#include "cItem.h"
|
||||
#include "StringCompression.h"
|
||||
#include "cEntity.h"
|
||||
#include "cBlockEntity.h"
|
||||
#include "cMakeDir.h"
|
||||
|
||||
|
||||
|
||||
@ -22,16 +26,136 @@ Since only the header is actually in the memory, this number can be high, but st
|
||||
#define MAX_MCA_FILES 32
|
||||
|
||||
/// The maximum size of an inflated chunk
|
||||
#define CHUNK_INFLATE_MAX 128 KiB
|
||||
#define CHUNK_INFLATE_MAX 256 KiB
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// cNBTChunkSerializer
|
||||
|
||||
class cNBTChunkSerializer :
|
||||
public cChunkDataSeparateCollector
|
||||
{
|
||||
public:
|
||||
cNBTChunkSerializer(cNBTList * a_Entities, cNBTList * a_TileEntities) :
|
||||
m_Entities(a_Entities),
|
||||
m_TileEntities(a_TileEntities)
|
||||
{
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
/* From cChunkDataSeparateCollector we inherit:
|
||||
- m_BlockTypes[]
|
||||
- m_BlockMetas[]
|
||||
- m_BlockLight[]
|
||||
- m_BlockSkyLight[]
|
||||
*/
|
||||
|
||||
// TODO: Biomes
|
||||
|
||||
// We need to save entities and blockentities into NBT
|
||||
cNBTList * m_Entities; // Tag where entities will be saved
|
||||
cNBTList * m_TileEntities; // Tag where block-entities will be saved
|
||||
|
||||
|
||||
cNBTCompound * AddBasicTileEntity(cBlockEntity * a_Entity, const char * a_EntityTypeID)
|
||||
{
|
||||
cNBTCompound * res = new cNBTCompound(m_TileEntities);
|
||||
res->Add(new cNBTInt (res, "x", a_Entity->GetPosX()));
|
||||
res->Add(new cNBTInt (res, "y", a_Entity->GetPosY()));
|
||||
res->Add(new cNBTInt (res, "z", a_Entity->GetPosZ()));
|
||||
res->Add(new cNBTString(res, "id", a_EntityTypeID));
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
void AddItem(cNBTList * a_Items, cItem * a_Item, int a_Slot)
|
||||
{
|
||||
cNBTCompound * Tag = new cNBTCompound(a_Items);
|
||||
Tag->Add(new cNBTShort(Tag, "id", a_Item->m_ItemID));
|
||||
Tag->Add(new cNBTShort(Tag, "Damage", a_Item->m_ItemHealth));
|
||||
Tag->Add(new cNBTByte (Tag, "Count", a_Item->m_ItemCount));
|
||||
Tag->Add(new cNBTByte (Tag, "Slot", a_Slot));
|
||||
}
|
||||
|
||||
|
||||
void AddChestEntity(cChestEntity * a_Entity)
|
||||
{
|
||||
cNBTCompound * Base = AddBasicTileEntity(a_Entity, "chest");
|
||||
cNBTList * Items = new cNBTList(Base, "Items", cNBTTag::TAG_Compound);
|
||||
Base->Add(Items);
|
||||
for (int i = 0; i < cChestEntity::c_ChestHeight * cChestEntity::c_ChestWidth; i++)
|
||||
{
|
||||
cItem * Item = a_Entity->GetSlot(i);
|
||||
if ((Item == NULL) || Item->IsEmpty())
|
||||
{
|
||||
continue;
|
||||
}
|
||||
AddItem(Items, Item, i);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
virtual void Entity(cEntity * a_Entity) override
|
||||
{
|
||||
// TODO: Add entity into NBT:
|
||||
}
|
||||
|
||||
|
||||
virtual void BlockEntity(cBlockEntity * a_Entity)
|
||||
{
|
||||
// Add tile-entity into NBT:
|
||||
switch (a_Entity->GetBlockType())
|
||||
{
|
||||
case E_BLOCK_CHEST: AddChestEntity((cChestEntity *)a_Entity); break;
|
||||
default:
|
||||
{
|
||||
ASSERT(!"Unhandled block entity saved into Anvil");
|
||||
}
|
||||
}
|
||||
}
|
||||
} ; // class cNBTChunkSerializer
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// cWSSAnvil:
|
||||
|
||||
cWSSAnvil::cWSSAnvil(cWorld * a_World) :
|
||||
super(a_World)
|
||||
{
|
||||
// Create a level.dat file for mapping tools, if it doesn't already exist:
|
||||
AString fnam;
|
||||
Printf(fnam, "%s/level.dat", a_World->GetName().c_str());
|
||||
if (!cFile::Exists(fnam))
|
||||
{
|
||||
std::auto_ptr<cNBTCompound> Root(new cNBTCompound(NULL));
|
||||
cNBTCompound * Data = new cNBTCompound(Root.get());
|
||||
Root->Add(Data);
|
||||
Data->Add(new cNBTInt(Data, "SpawnX", (int)(a_World->GetSpawnX())));
|
||||
Data->Add(new cNBTInt(Data, "SpawnY", (int)(a_World->GetSpawnY())));
|
||||
Data->Add(new cNBTInt(Data, "SpawnZ", (int)(a_World->GetSpawnZ())));
|
||||
AString Uncompressed;
|
||||
cNBTSerializer::Serialize(Root.get(), Uncompressed);
|
||||
gzFile gz = gzopen(fnam.c_str(), "wb");
|
||||
if (gz != NULL)
|
||||
{
|
||||
gzwrite(gz, Uncompressed.data(), Uncompressed.size());
|
||||
}
|
||||
gzclose(gz);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
cWSSAnvil::~cWSSAnvil()
|
||||
{
|
||||
cCSLock Lock(m_CS);
|
||||
@ -63,8 +187,18 @@ bool cWSSAnvil::LoadChunk(const cChunkCoords & a_Chunk)
|
||||
|
||||
bool cWSSAnvil::SaveChunk(const cChunkCoords & a_Chunk)
|
||||
{
|
||||
// TODO: We're read-only for now
|
||||
AString ChunkData;
|
||||
if (!SaveChunkToData(a_Chunk, ChunkData))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (!SetChunkData(a_Chunk, ChunkData))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// Everything successful
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
@ -86,6 +220,21 @@ bool cWSSAnvil::GetChunkData(const cChunkCoords & a_Chunk, AString & a_Data)
|
||||
|
||||
|
||||
|
||||
bool cWSSAnvil::SetChunkData(const cChunkCoords & a_Chunk, const AString & a_Data)
|
||||
{
|
||||
cCSLock Lock(m_CS);
|
||||
cMCAFile * File = LoadMCAFile(a_Chunk);
|
||||
if (File == NULL)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
return File->SetChunkData(a_Chunk, a_Data);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
cWSSAnvil::cMCAFile * cWSSAnvil::LoadMCAFile(const cChunkCoords & a_Chunk)
|
||||
{
|
||||
// ASSUME m_CS is locked
|
||||
@ -111,7 +260,9 @@ cWSSAnvil::cMCAFile * cWSSAnvil::LoadMCAFile(const cChunkCoords & a_Chunk)
|
||||
|
||||
// Load it anew:
|
||||
AString FileName;
|
||||
Printf(FileName, "%s/r.%d.%d.mca", m_World->GetName().c_str(), RegionX, RegionZ);
|
||||
Printf(FileName, "%s/region", m_World->GetName().c_str());
|
||||
cMakeDir::MakeDir(FileName);
|
||||
AppendPrintf(FileName, "/r.%d.%d.mca", RegionX, RegionZ);
|
||||
cMCAFile * f = new cMCAFile(FileName, RegionX, RegionZ);
|
||||
if (f == NULL)
|
||||
{
|
||||
@ -167,6 +318,23 @@ bool cWSSAnvil::LoadChunkFromData(const cChunkCoords & a_Chunk, const AString &
|
||||
|
||||
|
||||
|
||||
bool cWSSAnvil::SaveChunkToData(const cChunkCoords & a_Chunk, AString & a_Data)
|
||||
{
|
||||
std::auto_ptr<cNBTTree> Tree(SaveChunkToNBT(a_Chunk));
|
||||
if (Tree.get() == NULL)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
AString Uncompressed;
|
||||
cNBTSerializer::Serialize(Tree.get(), Uncompressed);
|
||||
CompressString(Uncompressed.data(), Uncompressed.size(), a_Data);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
bool cWSSAnvil::LoadChunkFromNBT(const cChunkCoords & a_Chunk, cNBTTag & a_NBT)
|
||||
{
|
||||
// The data arrays, in MCA-native y/z/x ordering (will be reordered for the final chunk data)
|
||||
@ -299,6 +467,50 @@ bool cWSSAnvil::LoadChunkFromNBT(const cChunkCoords & a_Chunk, cNBTTag & a_NBT)
|
||||
|
||||
|
||||
|
||||
cNBTTag * cWSSAnvil::SaveChunkToNBT(const cChunkCoords & a_Chunk)
|
||||
{
|
||||
std::auto_ptr<cNBTCompound> res(new cNBTCompound(NULL));
|
||||
cNBTCompound * Level = new cNBTCompound(res.get(), "Level");
|
||||
res->Add(Level);
|
||||
cNBTList * Entities = new cNBTList(Level, "Entities", cNBTTag::TAG_Compound);
|
||||
Level->Add(Entities);
|
||||
cNBTList * TileEntities = new cNBTList(Level, "TileEntities", cNBTTag::TAG_Compound);
|
||||
Level->Add(TileEntities);
|
||||
cNBTChunkSerializer Serializer(Entities, TileEntities);
|
||||
if (!m_World->GetChunkData(a_Chunk.m_ChunkX, a_Chunk.m_ChunkY, a_Chunk.m_ChunkZ, Serializer))
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
Level->Add(new cNBTInt(Level, "xPos", a_Chunk.m_ChunkX));
|
||||
Level->Add(new cNBTInt(Level, "zPos", a_Chunk.m_ChunkZ));
|
||||
|
||||
// TODO: Save biomes:
|
||||
// Level->Add(new cNBTByteArray(Level, "Biomes", AString(Serializer.m_Biomes, sizeof(Serializer.m_Biomes));
|
||||
|
||||
// Save blockdata:
|
||||
cNBTList * Sections = new cNBTList(Level, "Sections", cNBTTag::TAG_Compound);
|
||||
Level->Add(Sections);
|
||||
int SliceSizeBlock = cChunkDef::Width * cChunkDef::Width * 16;
|
||||
int SliceSizeNibble = SliceSizeBlock / 2;
|
||||
for (int Y = 0; Y < 16; Y++)
|
||||
{
|
||||
cNBTCompound * Slice = new cNBTCompound(Sections);
|
||||
Sections->Add(Slice);
|
||||
Slice->Add(new cNBTByteArray(Slice, "Blocks", AString(Serializer.m_BlockTypes + Y * SliceSizeBlock, SliceSizeBlock)));
|
||||
Slice->Add(new cNBTByteArray(Slice, "Data", AString(Serializer.m_BlockMetas + Y * SliceSizeNibble, SliceSizeNibble)));
|
||||
Slice->Add(new cNBTByteArray(Slice, "SkyLight", AString(Serializer.m_BlockSkyLight + Y * SliceSizeNibble, SliceSizeNibble)));
|
||||
Slice->Add(new cNBTByteArray(Slice, "BlockLight", AString(Serializer.m_BlockLight + Y * SliceSizeNibble, SliceSizeNibble)));
|
||||
Slice->Add(new cNBTByte(Slice, "Y", Y));
|
||||
}
|
||||
|
||||
return res.release();
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cWSSAnvil::LoadEntitiesFromNBT(cEntityList & a_Entitites, const cNBTList * a_NBT)
|
||||
{
|
||||
// TODO: Load the entities
|
||||
@ -423,7 +635,7 @@ bool cWSSAnvil::GetBlockEntityNBTPos(const cNBTCompound * a_NBT, int & a_X, int
|
||||
cWSSAnvil::cMCAFile::cMCAFile(const AString & a_FileName, int a_RegionX, int a_RegionZ) :
|
||||
m_RegionX(a_RegionX),
|
||||
m_RegionZ(a_RegionZ),
|
||||
m_File(a_FileName, cFile::fmRead),
|
||||
m_File(a_FileName, cFile::fmReadWrite),
|
||||
m_FileName(a_FileName)
|
||||
{
|
||||
if (!m_File.IsOpen())
|
||||
@ -434,10 +646,19 @@ cWSSAnvil::cMCAFile::cMCAFile(const AString & a_FileName, int a_RegionX, int a_R
|
||||
// Load the header:
|
||||
if (m_File.Read(m_Header, sizeof(m_Header)) != sizeof(m_Header))
|
||||
{
|
||||
LOGWARNING("Cannot read MCA header from file \"%s\", chunks in that file will be lost", m_FileName.c_str());
|
||||
// Cannot read the header - perhaps the file has just been created?
|
||||
// Try writing a NULL header (both chunk offsets and timestamps):
|
||||
memset(m_Header, 0, sizeof(m_Header));
|
||||
if (
|
||||
(m_File.Write(m_Header, sizeof(m_Header)) != sizeof(m_Header)) ||
|
||||
(m_File.Write(m_Header, sizeof(m_Header)) != sizeof(m_Header))
|
||||
)
|
||||
{
|
||||
LOGWARNING("Cannot process MCA header in file \"%s\", chunks in that file will be lost", m_FileName.c_str());
|
||||
m_File.Close();
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -492,3 +713,80 @@ bool cWSSAnvil::cMCAFile::GetChunkData(const cChunkCoords & a_Chunk, AString & a
|
||||
|
||||
|
||||
|
||||
|
||||
bool cWSSAnvil::cMCAFile::SetChunkData(const cChunkCoords & a_Chunk, const AString & a_Data)
|
||||
{
|
||||
if (!m_File.IsOpen())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
int LocalX = a_Chunk.m_ChunkX % 32;
|
||||
if (LocalX < 0)
|
||||
{
|
||||
LocalX = 32 + LocalX;
|
||||
}
|
||||
int LocalZ = a_Chunk.m_ChunkZ % 32;
|
||||
if (LocalZ < 0)
|
||||
{
|
||||
LocalZ = 32 + LocalZ;
|
||||
}
|
||||
|
||||
unsigned ChunkSector = FindFreeLocation(LocalX, LocalZ, a_Data);
|
||||
|
||||
// Store the chunk data:
|
||||
m_File.Seek(ChunkSector * 4096);
|
||||
unsigned ChunkSize = htonl(a_Data.size() + 1);
|
||||
if (m_File.Write(&ChunkSize, 4) != 4)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
char CompressionType = 2;
|
||||
if (m_File.Write(&CompressionType, 1) != 1)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (m_File.Write(a_Data.data(), a_Data.size()) != a_Data.size())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// Store the header:
|
||||
ChunkSize = (a_Data.size() + MCA_CHUNK_HEADER_LENGTH + 4095) / 4096; // Round data size *up* to nearest 4KB sector, make it a sector number
|
||||
ASSERT(ChunkSize < 256);
|
||||
m_Header[LocalX + 32 * LocalZ] = htonl((ChunkSector << 8) | ChunkSize);
|
||||
m_File.Seek(0);
|
||||
if (m_File.Write(m_Header, sizeof(m_Header)) != sizeof(m_Header))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
unsigned cWSSAnvil::cMCAFile::FindFreeLocation(int a_LocalX, int a_LocalZ, const AString & a_Data)
|
||||
{
|
||||
// See if it fits the current location:
|
||||
unsigned ChunkLocation = ntohl(m_Header[a_LocalX + 32 * a_LocalZ]);
|
||||
unsigned ChunkLen = ChunkLocation & 0xff;
|
||||
if (a_Data.size() + MCA_CHUNK_HEADER_LENGTH <= (ChunkLen * 4096))
|
||||
{
|
||||
return ChunkLocation >> 8;
|
||||
}
|
||||
|
||||
// Doesn't fit, append to the end of file (we're wasting a lot of space, TODO: fix this later)
|
||||
unsigned MaxLocation = 2 << 8; // Minimum sector is #2 - after the headers
|
||||
for (int i = 0; i < ARRAYCOUNT(m_Header); i++)
|
||||
{
|
||||
ChunkLocation = ntohl(m_Header[i]);
|
||||
ChunkLocation = ChunkLocation + ((ChunkLocation & 0xff) << 8); // Add the number of sectors used; don't care about the 4th byte
|
||||
if (MaxLocation < ChunkLocation)
|
||||
{
|
||||
MaxLocation = ChunkLocation;
|
||||
}
|
||||
} // for i - m_Header[]
|
||||
return MaxLocation >> 8;
|
||||
}
|
||||
|
||||
@ -16,8 +16,14 @@
|
||||
|
||||
enum
|
||||
{
|
||||
// The MCA header is 8 KiB
|
||||
MCA_HEADER_SIZE = 8192,
|
||||
/// Maximum number of chunks in an MCA file - also the count of the header items
|
||||
MCA_MAX_CHUNKS = 32 * 32,
|
||||
|
||||
/// The MCA header is 8 KiB
|
||||
MCA_HEADER_SIZE = MCA_MAX_CHUNKS * 8,
|
||||
|
||||
/// There are 5 bytes of header in front of each chunk
|
||||
MCA_CHUNK_HEADER_LENGTH = 5,
|
||||
} ;
|
||||
|
||||
|
||||
@ -40,7 +46,7 @@ class cWSSAnvil :
|
||||
|
||||
public:
|
||||
|
||||
cWSSAnvil(cWorld * a_World) : super(a_World) {}
|
||||
cWSSAnvil(cWorld * a_World);
|
||||
virtual ~cWSSAnvil();
|
||||
|
||||
protected:
|
||||
@ -51,7 +57,9 @@ protected:
|
||||
|
||||
cMCAFile(const AString & a_FileName, int a_RegionX, int a_RegionZ);
|
||||
|
||||
bool GetChunkData(const cChunkCoords & a_Chunk, AString & a_Data);
|
||||
bool GetChunkData (const cChunkCoords & a_Chunk, AString & a_Data);
|
||||
bool SetChunkData (const cChunkCoords & a_Chunk, const AString & a_Data);
|
||||
bool EraseChunkData(const cChunkCoords & a_Chunk);
|
||||
|
||||
int GetRegionX (void) const {return m_RegionX; }
|
||||
int GetRegionZ (void) const {return m_RegionZ; }
|
||||
@ -66,23 +74,36 @@ protected:
|
||||
|
||||
// The header, copied from the file so we don't have to seek to it all the time
|
||||
// First 1024 entries are chunk locations - the 3 + 1 byte sector-offset and sector-count
|
||||
// The next 1024 entries are chunk timestamps - unused in MCS
|
||||
unsigned m_Header[MCA_HEADER_SIZE / sizeof(unsigned)];
|
||||
unsigned m_Header[MCA_MAX_CHUNKS];
|
||||
|
||||
// Chunk timestamps, following the chunk headers, are unused by MCS
|
||||
|
||||
/// Finds a free location large enough to hold a_Data. Gets a hint of the chunk coords, places the data there if it fits. Returns the sector number.
|
||||
unsigned FindFreeLocation(int a_LocalX, int a_LocalZ, const AString & a_Data);
|
||||
} ;
|
||||
typedef std::list<cMCAFile *> cMCAFiles;
|
||||
|
||||
cCriticalSection m_CS;
|
||||
cMCAFiles m_Files; // a MRU cache of MCA files
|
||||
|
||||
/// Gets chunk data from the correct file; locks CS as needed
|
||||
/// Gets chunk data from the correct file; locks file CS as needed
|
||||
bool GetChunkData(const cChunkCoords & a_Chunk, AString & a_Data);
|
||||
|
||||
/// Sets chunk data into the correct file; locks file CS as needed
|
||||
bool SetChunkData(const cChunkCoords & a_Chunk, const AString & a_Data);
|
||||
|
||||
/// Loads the chunk from the data (no locking needed)
|
||||
bool LoadChunkFromData(const cChunkCoords & a_Chunk, const AString & a_Data);
|
||||
|
||||
/// Saves the chunk into datastream (no locking needed)
|
||||
bool SaveChunkToData(const cChunkCoords & a_Chunk, AString & a_Data);
|
||||
|
||||
/// Loads the chunk from NBT data (no locking needed)
|
||||
bool LoadChunkFromNBT(const cChunkCoords & a_Chunk, cNBTTag & a_NBT);
|
||||
|
||||
/// Saves the chunk into NBT data; returns NULL for failure
|
||||
cNBTTag * SaveChunkToNBT(const cChunkCoords & a_Chunk);
|
||||
|
||||
/// Loads the chunk's entities from NBT data (a_NBT is the Level\\Entities list tag; may be NULL)
|
||||
void LoadEntitiesFromNBT(cEntityList & a_Entitites, const cNBTList * a_NBT);
|
||||
|
||||
|
||||
@ -34,10 +34,10 @@ class cPacket;
|
||||
class cBlockEntity
|
||||
{
|
||||
protected:
|
||||
cBlockEntity(ENUM_BLOCK_ID a_BlockType, int a_X, int a_Y, int a_Z, cWorld * a_World)
|
||||
: m_PosX( a_X )
|
||||
, m_PosY( a_Y )
|
||||
, m_PosZ( a_Z )
|
||||
cBlockEntity(ENUM_BLOCK_ID a_BlockType, int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World)
|
||||
: m_PosX( a_BlockX )
|
||||
, m_PosY( a_BlockY )
|
||||
, m_PosZ( a_BlockZ )
|
||||
, m_BlockType( a_BlockType )
|
||||
, m_World( a_World )
|
||||
{}
|
||||
@ -45,6 +45,7 @@ public:
|
||||
virtual ~cBlockEntity() {};
|
||||
virtual void Destroy() {};
|
||||
|
||||
// Position, in absolute block coordinates:
|
||||
int GetPosX() { return m_PosX; }
|
||||
int GetPosY() { return m_PosY; }
|
||||
int GetPosZ() { return m_PosZ; }
|
||||
@ -78,7 +79,7 @@ public:
|
||||
virtual cPacket * GetPacket(void) {return NULL; }
|
||||
|
||||
protected:
|
||||
int m_PosX; // Position in block coordinates
|
||||
int m_PosX; // Position in absolute block coordinates
|
||||
int m_PosY;
|
||||
int m_PosZ;
|
||||
|
||||
|
||||
@ -27,7 +27,7 @@ cChestEntity::cChestEntity(int a_X, int a_Y, int a_Z, cWorld * a_World)
|
||||
, m_TopChest( false )
|
||||
, m_JoinedChest( NULL )
|
||||
{
|
||||
m_Content = new cItem[ c_ChestHeight*c_ChestWidth ];
|
||||
m_Content = new cItem[ c_ChestHeight * c_ChestWidth ];
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -69,7 +69,7 @@ bool cFile::Open(const AString & iFileName, EMode iMode)
|
||||
{
|
||||
case fmRead: Mode = "rb"; break;
|
||||
case fmWrite: Mode = "wb"; break;
|
||||
case fmReadWrite: Mode = "ab+"; break;
|
||||
case fmReadWrite: Mode = "rb+"; break;
|
||||
default:
|
||||
{
|
||||
ASSERT(!"Unhandled file mode");
|
||||
@ -77,6 +77,14 @@ bool cFile::Open(const AString & iFileName, EMode iMode)
|
||||
}
|
||||
}
|
||||
m_File = fopen(iFileName.c_str(), Mode);
|
||||
if ((m_File == NULL) && (iMode == fmReadWrite))
|
||||
{
|
||||
// Fix for MS not following C spec, opening "a" mode files for writing at the end only
|
||||
// The file open operation has been tried with "read update", fails if file not found
|
||||
// So now we know either the file doesn't exist or we don't have rights, no need to worry about file contents.
|
||||
// Simply re-open for read-writing, erasing existing contents:
|
||||
m_File = fopen(iFileName.c_str(), "wb+");
|
||||
}
|
||||
return (m_File != NULL);
|
||||
}
|
||||
|
||||
@ -251,3 +259,13 @@ int cFile::ReadRestOfFile(AString & a_Contents)
|
||||
|
||||
|
||||
|
||||
|
||||
bool cFile::Exists(const AString & a_FileName)
|
||||
{
|
||||
cFile test(a_FileName, fmRead);
|
||||
return test.IsOpen();
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -86,6 +86,9 @@ public:
|
||||
/// Reads the file from current position till EOF into an AString; returns the number of bytes read or -1 for error
|
||||
int ReadRestOfFile(AString & a_Contents);
|
||||
|
||||
/// Returns true if the file specified exists
|
||||
static bool Exists(const AString & a_FileName);
|
||||
|
||||
private:
|
||||
#ifdef USE_STDIO_FILE
|
||||
FILE * m_File;
|
||||
|
||||
@ -7,16 +7,16 @@
|
||||
|
||||
|
||||
|
||||
void cMakeDir::MakeDir( const char* a_Directory )
|
||||
void cMakeDir::MakeDir(const AString & a_Directory)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
SECURITY_ATTRIBUTES Attrib;
|
||||
Attrib.nLength = sizeof(SECURITY_ATTRIBUTES);
|
||||
Attrib.lpSecurityDescriptor = NULL;
|
||||
Attrib.bInheritHandle = false;
|
||||
::CreateDirectory(a_Directory, &Attrib);
|
||||
::CreateDirectory(a_Directory.c_str(), &Attrib);
|
||||
#else
|
||||
mkdir(a_Directory, S_IRWXU | S_IRWXG | S_IRWXO);
|
||||
mkdir(a_Directory.c_str(), S_IRWXU | S_IRWXG | S_IRWXO);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
@ -1,7 +1,16 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
class cMakeDir
|
||||
{
|
||||
public:
|
||||
static void MakeDir( const char* a_Directory );
|
||||
static void MakeDir(const AString & a_Directory);
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user