Beispiel #1
0
QString MainWindow::getWorldName(const AString & a_Path)
{
	AString levelData = cFile::ReadWholeFile(a_Path + "/level.dat");
	if (levelData.empty())
	{
		// No such file / no data
		return QString();
	}

	AString uncompressed;
	if (UncompressStringGZIP(levelData.data(), levelData.size(), uncompressed) != Z_OK)
	{
		return QString();
	}
	cParsedNBT nbt(uncompressed.data(), uncompressed.size());
	if (!nbt.IsValid())
	{
		return QString();
	}
	AString name = nbt.GetName(1);
	int levelNameTag = nbt.FindTagByPath(nbt.GetRoot(), "Data\\LevelName");
	if ((levelNameTag <= 0) || (nbt.GetType(levelNameTag) != TAG_String))
	{
		return QString();
	}
	return QString::fromStdString(nbt.GetString(levelNameTag));
}
Beispiel #2
0
int Mineserver::Network_Protocol_Notch_Packet_0x33::_write(Mineserver::Network_Protocol_Notch_PacketStream& ps, const Mineserver::Network_Message& message)
{
  const Mineserver::Network_Message_Chunk* msg = static_cast<const Mineserver::Network_Message_Chunk*>(&message);

  Mineserver::NBT nbt(Mineserver::NBT::TAG_COMPOUND);

  nbt.Insert("Blocks", new Mineserver::NBT(Mineserver::NBT::TAG_BYTE_ARRAY));
  nbt.Insert("Data", new Mineserver::NBT(Mineserver::NBT::TAG_BYTE_ARRAY));
  nbt.Insert("SkyLight", new Mineserver::NBT(Mineserver::NBT::TAG_BYTE_ARRAY));
  nbt.Insert("BlockLight", new Mineserver::NBT(Mineserver::NBT::TAG_BYTE_ARRAY));
  nbt.Insert("HeightMap", new Mineserver::NBT(Mineserver::NBT::TAG_BYTE_ARRAY));
  nbt.Insert("Entities", new Mineserver::NBT(Mineserver::NBT::TAG_LIST, Mineserver::NBT::TAG_COMPOUND));
  nbt.Insert("TileEntities", new Mineserver::NBT(Mineserver::NBT::TAG_LIST, Mineserver::NBT::TAG_COMPOUND));
  nbt.Insert("LastUpdate", new Mineserver::NBT(Mineserver::NBT::TAG_LONG));
  nbt.Insert("xPos", new Mineserver::NBT(Mineserver::NBT::TAG_INT));
  nbt.Insert("zPos", new Mineserver::NBT(Mineserver::NBT::TAG_INT));
  nbt.Insert("TerrainPopulated", new Mineserver::NBT(Mineserver::NBT::TAG_BYTE));

  *nbt["xPos"] = static_cast<int32_t>(msg->chunk->x);
  *nbt["zPos"] = static_cast<int32_t>(msg->chunk->z);

  std::vector<uint8_t>* blockType = nbt["Blocks"]->GetByteArray();
  std::vector<uint8_t>* blockMeta = nbt["Data"]->GetByteArray();
  std::vector<uint8_t>* lightSky = nbt["SkyLight"]->GetByteArray();
  std::vector<uint8_t>* lightBlock = nbt["BlockLight"]->GetByteArray();

  blockType->resize(128*16*16);
  blockMeta->resize(128*16*8);
  lightSky->resize(128*16*8);
  lightBlock->resize(128*16*8);

  for (int y = 0; y < 128; ++y) {
    for (int z = 0; z < 16; ++z) {
      for (int x = 0; x < 16; x += 2) {
        (*blockType)[y+(z*128)+(x*128*16)] = msg->chunk->getBlockType(x, y, z);
        (*blockType)[y+(z*128)+(x*128*16)+1] = msg->chunk->getBlockType(x+1, y, z);
        (*blockMeta)[y+(z*128)+((x/2)*128*8)] = (msg->chunk->getBlockMeta(x, y, z) << 4) + msg->chunk->getBlockMeta(x+1, y, z);
        (*lightSky)[y+(z*128)+((x/2)*128*8)] = (msg->chunk->getLightSky(x, y, z) << 4) + msg->chunk->getLightSky(x+1, y, z);
        (*lightBlock)[y+(z*128)+((x/2)*128*8)] = (msg->chunk->getLightBlock(x, y, z) << 4) + msg->chunk->getLightBlock(x+1, y, z);
      }
    }
  }

  std::vector<uint8_t> data;

  nbt.Write(data);
  int16_t bytes = data.size();

  printf("NBT data is %d bytes\n", bytes);

  ps << msg->mid << msg->posX << msg->posY << msg->posZ << msg->sizeX << msg->sizeY << msg->sizeZ << bytes;
  ps.bytesFrom(data);

  return STATE_GOOD;
}
void ChunkLoader::run()
{
	int rx=x>>5;
	int rz=z>>5;

	QFile f(path+"/region/r."+QString::number(rx)+"."+QString::number(rz)+".mca");
	if (!f.open(QIODevice::ReadOnly)) //no chunks in this region
	{
		emit loaded(x,z);
		return;
	}
	//map header into memory
	uchar *header=f.map(0,4096);
	int offset=4*((x&31)+(z&31)*32);
	int coffset=(header[offset]<<16)|(header[offset+1]<<8)|header[offset+2];
	int numSectors=header[offset+3];
	f.unmap(header);

	if (coffset==0) // no chunk
	{
		f.close();
		emit loaded(x,z);
		return;
	}

	uchar *raw=f.map(coffset*4096,numSectors*4096);
	if (raw == NULL)
	{
		f.close();
		emit loaded(x, z);
		return;
	}
	NBT nbt(raw);
	ChunkID id(x,z);
	mutex.lock();
	Chunk *chunk=cache[id];
	if (chunk)
		chunk->load(nbt);
	mutex.unlock();
	f.unmap(raw);
	f.close();

	emit loaded(x,z);
}