summaryrefslogtreecommitdiffstats
path: root/source
diff options
context:
space:
mode:
Diffstat (limited to 'source')
-rw-r--r--source/ChunkDef.h49
-rw-r--r--source/NBT.cpp9
-rw-r--r--source/NBT.h4
-rw-r--r--source/WSSAnvil.cpp314
-rw-r--r--source/WSSAnvil.h35
-rw-r--r--source/cBlockEntity.h11
-rw-r--r--source/cChestEntity.cpp2
-rw-r--r--source/cFile.cpp20
-rw-r--r--source/cFile.h3
-rw-r--r--source/cMakeDir.cpp6
-rw-r--r--source/cMakeDir.h13
11 files changed, 431 insertions, 35 deletions
diff --git a/source/ChunkDef.h b/source/ChunkDef.h
index 647f9b51e..837a515b5 100644
--- a/source/ChunkDef.h
+++ b/source/ChunkDef.h
@@ -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.
*/
diff --git a/source/NBT.cpp b/source/NBT.cpp
index af420cd27..ba2f3d0f6 100644
--- a/source/NBT.cpp
+++ b/source/NBT.cpp
@@ -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;
diff --git a/source/NBT.h b/source/NBT.h
index 6d3ecebd9..f63e1fea1 100644
--- a/source/NBT.h
+++ b/source/NBT.h
@@ -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);
diff --git a/source/WSSAnvil.cpp b/source/WSSAnvil.cpp
index 6520a7c95..1b916a63e 100644
--- a/source/WSSAnvil.cpp
+++ b/source/WSSAnvil.cpp
@@ -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,7 +26,7 @@ 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
@@ -30,8 +34,128 @@ Since only the header is actually in the memory, this number can be high, but st
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// 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
- return false;
+ 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,9 +646,18 @@ 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());
- m_File.Close();
- return;
+ // 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;
+}
diff --git a/source/WSSAnvil.h b/source/WSSAnvil.h
index 1052d0e5a..37d813f28 100644
--- a/source/WSSAnvil.h
+++ b/source/WSSAnvil.h
@@ -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);
diff --git a/source/cBlockEntity.h b/source/cBlockEntity.h
index 3f0190c77..8a9e51f56 100644
--- a/source/cBlockEntity.h
+++ b/source/cBlockEntity.h
@@ -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;
diff --git a/source/cChestEntity.cpp b/source/cChestEntity.cpp
index f1a99b8c3..e1976836b 100644
--- a/source/cChestEntity.cpp
+++ b/source/cChestEntity.cpp
@@ -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 ];
}
diff --git a/source/cFile.cpp b/source/cFile.cpp
index 5ea71107a..cd61800e2 100644
--- a/source/cFile.cpp
+++ b/source/cFile.cpp
@@ -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();
+}
+
+
+
+
diff --git a/source/cFile.h b/source/cFile.h
index 390847eaf..567c98219 100644
--- a/source/cFile.h
+++ b/source/cFile.h
@@ -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;
diff --git a/source/cMakeDir.cpp b/source/cMakeDir.cpp
index 8c43a7d92..a28b3a088 100644
--- a/source/cMakeDir.cpp
+++ b/source/cMakeDir.cpp
@@ -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
}
diff --git a/source/cMakeDir.h b/source/cMakeDir.h
index 378df2a36..f109e17dd 100644
--- a/source/cMakeDir.h
+++ b/source/cMakeDir.h
@@ -1,7 +1,16 @@
+
#pragma once
+
+
+
+
class cMakeDir
{
public:
- static void MakeDir( const char* a_Directory );
-}; \ No newline at end of file
+ static void MakeDir(const AString & a_Directory);
+};
+
+
+
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-01 13:04:32 +0100