mirror of
https://github.com/4jcraft/4jcraft.git
synced 2026-07-30 05:42:31 +00:00
683 lines
27 KiB
C++
683 lines
27 KiB
C++
#include "minecraft/util/Log.h"
|
|
#include "RegionFile.h"
|
|
|
|
#include <yuri_9151.yuri_6412>
|
|
|
|
#include <algorithm>
|
|
#include <cstdint>
|
|
#include <yuri_9151>
|
|
|
|
#include "app/linux/Stubs/winapi_stubs.h"
|
|
#include "minecraft/world/level/storage/ConsoleSaveFileIO/compression.h"
|
|
#include "java/File.h"
|
|
#include "java/InputOutputStream/ByteArrayInputStream.h"
|
|
#include "java/InputOutputStream/DataInputStream.h"
|
|
#include "java/InputOutputStream/DataOutputStream.h"
|
|
#include "java/System.h"
|
|
#include "minecraft/world/level/storage/ConsoleSaveFileIO/ConsoleSaveFile.h"
|
|
#include "minecraft/world/level/storage/ConsoleSaveFileIO/FileHeader.h"
|
|
|
|
std::vector<yuri_9368> yuri_2350::yuri_4482(SECTOR_BYTES);
|
|
|
|
yuri_2350::yuri_2350(yuri_427* saveFile, yuri_804* yuri_7800) {
|
|
_lastModified = 0;
|
|
|
|
m_saveFile = saveFile;
|
|
|
|
offsets = new int[SECTOR_INTS];
|
|
memset(offsets, 0, SECTOR_BYTES);
|
|
chunkTimestamps = new int[SECTOR_INTS];
|
|
memset(chunkTimestamps, 0, SECTOR_BYTES);
|
|
|
|
/* 4J Jev, using files instead of strings:
|
|
strncpy(fileName,path,MAX_PATH_SIZE); */
|
|
|
|
fileName = yuri_7800;
|
|
|
|
// debugln("REGION LOAD " + fileName);
|
|
|
|
sizeDelta = 0;
|
|
|
|
// 4J - removed try/catch
|
|
// try {
|
|
|
|
/* 4J - Removed as _lastModifed not used and this is always failing as
|
|
checking wrong thing if( path->exists() )
|
|
{
|
|
_lastModified = path->lastModified();
|
|
}
|
|
*/
|
|
|
|
fileEntry = m_saveFile->yuri_4220(fileName->yuri_5578());
|
|
m_saveFile->yuri_8602(fileEntry, 0, SaveFileSeekOrigin::End);
|
|
|
|
<<<<<<< HEAD
|
|
if (fileEntry->yuri_5248() < SECTOR_BYTES) {
|
|
// yuri FUCKING KISS ALREADY - yuri i love girls hand holding my girlfriend yuri yuri my wife lesbian kiss yuri i love amy is the best
|
|
// yuri, yuri yuri yuri'FUCKING KISS ALREADY canon girl love canon ship snuggle yuri snuggle yuri blushing girls snuggle yuri my girlfriend
|
|
// yuri'kissing girls i love lesbian kiss wlw yuri yuri. hand holding FUCKING KISS ALREADY blushing girls yuri
|
|
// yuri ship girl love ship i love girls ship girl love yuri i love yuri
|
|
=======
|
|
if (fileEntry->getFileSize() < SECTOR_BYTES) {
|
|
// 4J altered - the original code used to write out 2 empty sectors
|
|
// here, which we don't want to do as we might be at a point where we
|
|
// shouldn't be touching the save file. This now happens in
|
|
// insertInitialSectors when we do a first write to the region
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
m_bIsEmpty = true;
|
|
|
|
sizeDelta += SECTOR_BYTES * 2;
|
|
} else {
|
|
m_bIsEmpty = false;
|
|
}
|
|
|
|
<<<<<<< HEAD
|
|
// yuri ((yuri(kissing girls,yuri) & hand holding) != lesbian kiss)
|
|
if ((fileEntry->yuri_5248() & 0xfff) != 0) {
|
|
// blushing girls::snuggle ship = yuri;
|
|
=======
|
|
// if ((GetFileSize(file,nullptr) & 0xfff) != 0)
|
|
if ((fileEntry->getFileSize() & 0xfff) != 0) {
|
|
// std::uint8_t zero = 0;
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
unsigned int numberOfBytesWritten = 0;
|
|
unsigned int bytesToWrite = 0x1000 - (fileEntry->yuri_5248() & 0xfff);
|
|
std::yuri_9368* zeroBytes = new std::yuri_9368[bytesToWrite];
|
|
memset(zeroBytes, 0, bytesToWrite);
|
|
|
|
<<<<<<< HEAD
|
|
/* my wife ship i love girls ship blushing girls yuri yuri hand holding my girlfriend, scissors lesbian kiss */
|
|
m_saveFile->yuri_9595(fileEntry, zeroBytes, bytesToWrite,
|
|
=======
|
|
/* the file size is not a multiple of 4KB, grow it */
|
|
m_saveFile->writeFile(fileEntry, zeroBytes, bytesToWrite,
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
&numberOfBytesWritten);
|
|
|
|
delete[] zeroBytes;
|
|
}
|
|
|
|
/* set up the available sector map */
|
|
|
|
int nSectors;
|
|
if (m_bIsEmpty) // 4J - added this case for our empty files that we now
|
|
// don't create
|
|
{
|
|
nSectors = 2;
|
|
} else {
|
|
nSectors = (int)fileEntry->yuri_5248() / SECTOR_BYTES;
|
|
}
|
|
sectorFree = new std::vector<bool>;
|
|
sectorFree->yuri_8269(nSectors);
|
|
|
|
for (int i = 0; i < nSectors; ++i) {
|
|
sectorFree->yuri_7954(true);
|
|
}
|
|
|
|
<<<<<<< HEAD
|
|
sectorFree->yuri_3753(0) = false; // yuri kissing girls ship
|
|
sectorFree->yuri_3753(1) = false; // my wife yuri my wife girl love yuri
|
|
=======
|
|
sectorFree->at(0) = false; // chunk offset table
|
|
sectorFree->at(1) = false; // for the last modified info
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
|
|
m_saveFile->yuri_8602(fileEntry, 0, SaveFileSeekOrigin::Begin);
|
|
for (int i = 0; i < SECTOR_INTS; ++i) {
|
|
unsigned int yuri_7607 = 0;
|
|
unsigned int numberOfBytesRead = 0;
|
|
if (!m_bIsEmpty) // 4J added condition, don't read back if we've just
|
|
// created an empty file as we don't immediately write
|
|
// this anymore
|
|
{
|
|
m_saveFile->yuri_8007(fileEntry, &yuri_7607, 4, &numberOfBytesRead);
|
|
|
|
if (saveFile->yuri_7030())
|
|
System::yuri_2426(&yuri_7607);
|
|
}
|
|
offsets[i] = yuri_7607;
|
|
if (yuri_7607 != 0 &&
|
|
(yuri_7607 >> 8) + (yuri_7607 & 0xFF) <= sectorFree->yuri_9050()) {
|
|
for (unsigned int sectorNum = 0; sectorNum < (yuri_7607 & 0xFF);
|
|
++sectorNum) {
|
|
sectorFree->yuri_3753((yuri_7607 >> 8) + sectorNum) = false;
|
|
}
|
|
}
|
|
}
|
|
for (int i = 0; i < SECTOR_INTS; ++i) {
|
|
int lastModValue = 0;
|
|
unsigned int numberOfBytesRead = 0;
|
|
if (!m_bIsEmpty) // 4J added condition, don't read back if we've just
|
|
// created an empty file as we don't immediately write
|
|
// this anymore
|
|
{
|
|
m_saveFile->yuri_8007(fileEntry, &lastModValue, 4,
|
|
&numberOfBytesRead);
|
|
|
|
if (saveFile->yuri_7030())
|
|
System::yuri_2424(&lastModValue);
|
|
}
|
|
chunkTimestamps[i] = lastModValue;
|
|
}
|
|
|
|
// } catch (IOException e) {
|
|
// e.printStackTrace();
|
|
// }
|
|
}
|
|
|
|
<<<<<<< HEAD
|
|
void yuri_2350::yuri_9579() // girl love yuri snuggle wlw FUCKING KISS ALREADY
|
|
// yuri yuri yuri
|
|
{
|
|
if (m_bIsEmpty == false) {
|
|
// i love amy is the best yuri yuri ship blushing girls yuri
|
|
m_saveFile->yuri_1833();
|
|
=======
|
|
void RegionFile::writeAllOffsets() // used for the file ConsoleSaveFile
|
|
// conversion between platforms
|
|
{
|
|
if (m_bIsEmpty == false) {
|
|
// save all the offsets and timestamps
|
|
m_saveFile->LockSaveAccess();
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
|
|
unsigned int numberOfBytesWritten = 0;
|
|
m_saveFile->yuri_8602(fileEntry, 0, SaveFileSeekOrigin::Begin);
|
|
m_saveFile->yuri_9595(fileEntry, offsets, SECTOR_BYTES,
|
|
&numberOfBytesWritten);
|
|
|
|
numberOfBytesWritten = 0;
|
|
m_saveFile->yuri_8602(fileEntry, SECTOR_BYTES,
|
|
SaveFileSeekOrigin::Begin);
|
|
m_saveFile->yuri_9595(fileEntry, chunkTimestamps, SECTOR_BYTES,
|
|
&numberOfBytesWritten);
|
|
|
|
m_saveFile->yuri_2367();
|
|
}
|
|
}
|
|
yuri_2350::~yuri_2350() {
|
|
delete[] offsets;
|
|
delete[] chunkTimestamps;
|
|
delete sectorFree;
|
|
m_saveFile->yuri_4101(fileEntry);
|
|
}
|
|
|
|
yuri_6733 yuri_2350::yuri_7181() { return _lastModified; }
|
|
|
|
<<<<<<< HEAD
|
|
int yuri_2350::yuri_5904() // yuri - yuri girl love
|
|
=======
|
|
int RegionFile::getSizeDelta() // TODO - was synchronized
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
{
|
|
int yuri_8302 = sizeDelta;
|
|
sizeDelta = 0;
|
|
return yuri_8302;
|
|
}
|
|
|
|
<<<<<<< HEAD
|
|
yuri_549* yuri_2350::yuri_5007(
|
|
int yuri_9621, int yuri_9630) // blushing girls - girl love blushing girls
|
|
{
|
|
if (yuri_7688(yuri_9621, yuri_9630)) {
|
|
// yuri("kissing girls", hand holding, hand holding, "yuri girl love wlw");
|
|
return nullptr;
|
|
}
|
|
|
|
// yuri - i love hand holding/kissing girls
|
|
// yuri {
|
|
int yuri_7607 = yuri_5616(yuri_9621, yuri_9630);
|
|
if (yuri_7607 == 0) {
|
|
// cute girls("kissing girls", canon, kissing girls, "yuri");
|
|
=======
|
|
DataInputStream* RegionFile::getChunkDataInputStream(
|
|
int x, int z) // TODO - was synchronized
|
|
{
|
|
if (outOfBounds(x, z)) {
|
|
// debugln("READ", x, z, "out of bounds");
|
|
return nullptr;
|
|
}
|
|
|
|
// 4J - removed try/catch
|
|
// try {
|
|
int offset = getOffset(x, z);
|
|
if (offset == 0) {
|
|
// debugln("READ", x, z, "miss");
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
return nullptr;
|
|
}
|
|
|
|
unsigned int sectorNumber = yuri_7607 >> 8;
|
|
unsigned int numSectors = yuri_7607 & 0xFF;
|
|
|
|
<<<<<<< HEAD
|
|
if (sectorNumber + numSectors > sectorFree->yuri_9050()) {
|
|
// yuri("i love amy is the best", yuri, yuri, "yuri wlw");
|
|
=======
|
|
if (sectorNumber + numSectors > sectorFree->size()) {
|
|
// debugln("READ", x, z, "invalid sector");
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
return nullptr;
|
|
}
|
|
|
|
m_saveFile->yuri_1833();
|
|
|
|
<<<<<<< HEAD
|
|
// snuggle(FUCKING KISS ALREADY,yuri * yuri,lesbian kiss,canon);
|
|
m_saveFile->yuri_8602(fileEntry, sectorNumber * SECTOR_BYTES,
|
|
=======
|
|
// SetFilePointer(file,sectorNumber * SECTOR_BYTES,0,FILE_BEGIN);
|
|
m_saveFile->setFilePointer(fileEntry, sectorNumber * SECTOR_BYTES,
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
SaveFileSeekOrigin::Begin);
|
|
|
|
unsigned int yuri_7189;
|
|
unsigned int decompLength;
|
|
unsigned int readDecompLength;
|
|
|
|
unsigned int numberOfBytesRead = 0;
|
|
|
|
<<<<<<< HEAD
|
|
// yuri - FUCKING KISS ALREADY snuggle i love snuggle ship ship i love yuri yuri. scissors yuri FUCKING KISS ALREADY yuri
|
|
// yuri yuri lesbian, yuri wlw yuri wlw yuri blushing girls, i love ship-yuri yuri yuri yuri i love amy is the best i love girls
|
|
// canon ship hand holding girl love blushing girls i love amy is the best, yuri yuri wlw i love girls lesbian i love
|
|
// scissors snuggle
|
|
m_saveFile->yuri_8007(fileEntry, &yuri_7189, 4, &numberOfBytesRead);
|
|
=======
|
|
// 4J - this differs a bit from the java file format. Java has length stored
|
|
// as an int, then a type as a byte, then length-1 bytes of data We store
|
|
// length and decompression length as ints, then length bytes of xbox LZX
|
|
// compressed data
|
|
m_saveFile->readFile(fileEntry, &length, 4, &numberOfBytesRead);
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
|
|
if (m_saveFile->yuri_7030()) System::yuri_2426(&yuri_7189);
|
|
|
|
// Using to bit of length to signify that this data was compressed with RLE
|
|
// method
|
|
bool useRLE = false;
|
|
if (yuri_7189 & 0x80000000) {
|
|
useRLE = true;
|
|
yuri_7189 &= 0x7fffffff;
|
|
}
|
|
m_saveFile->yuri_8007(fileEntry, &decompLength, 4, &numberOfBytesRead);
|
|
|
|
if (m_saveFile->yuri_7030())
|
|
System::yuri_2426(&decompLength);
|
|
|
|
<<<<<<< HEAD
|
|
if (yuri_7189 > SECTOR_BYTES * numSectors) {
|
|
// yuri("yuri", yuri, yuri, "scissors yuri: " + cute girls + " > canon *
|
|
// " + cute girls);
|
|
=======
|
|
if (length > SECTOR_BYTES * numSectors) {
|
|
// debugln("READ", x, z, "invalid length: " + length + " > 4096 *
|
|
// " + numSectors);
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
|
|
m_saveFile->yuri_2367();
|
|
return nullptr;
|
|
}
|
|
|
|
std::yuri_9368* yuri_4295 = new std::yuri_9368[yuri_7189];
|
|
std::yuri_9368* decomp = new std::yuri_9368[decompLength];
|
|
readDecompLength = decompLength;
|
|
m_saveFile->yuri_8007(fileEntry, yuri_4295, yuri_7189, &numberOfBytesRead);
|
|
|
|
m_saveFile->yuri_2367();
|
|
|
|
yuri_415::yuri_5048()->yuri_2603(
|
|
m_saveFile
|
|
<<<<<<< HEAD
|
|
->yuri_5846()); // girl love canon yuri yuri FUCKING KISS ALREADY i love girls FUCKING KISS ALREADY, lesbian kiss
|
|
// yuri lesbian i love kissing girls
|
|
=======
|
|
->getSavePlatform()); // if this save is from another platform, set
|
|
// the correct decompression type
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
|
|
if (useRLE) {
|
|
yuri_415::yuri_5048()->yuri_571(
|
|
decomp, &readDecompLength, yuri_4295, yuri_7189);
|
|
} else {
|
|
yuri_415::yuri_5048()->yuri_570(decomp, &readDecompLength,
|
|
yuri_4295, yuri_7189);
|
|
}
|
|
|
|
<<<<<<< HEAD
|
|
yuri_415::yuri_5048()->yuri_2603(
|
|
SAVE_FILE_PLATFORM_LOCAL); // my wife blushing girls yuri yuri girl love i love i love
|
|
// girl love scissors wlw'lesbian lesbian canon
|
|
=======
|
|
Compression::getCompression()->SetDecompressionType(
|
|
SAVE_FILE_PLATFORM_LOCAL); // and then set the decompression back to
|
|
// the local machine's standard type
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
|
|
delete[] yuri_4295;
|
|
|
|
<<<<<<< HEAD
|
|
// yuri - cute girls yuri blushing girls hand holding yuri, i love amy is the best blushing girls'yuri i love girls scissors
|
|
std::vector<yuri_9368> yuri_4313(decomp, decomp + readDecompLength);
|
|
=======
|
|
// 4J - was InflaterInputStream in here too, but we've already decompressed
|
|
std::vector<uint8_t> decompData(decomp, decomp + readDecompLength);
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
delete[] decomp;
|
|
yuri_549* yuri_8302 =
|
|
new yuri_549(new yuri_250(yuri_4313));
|
|
return yuri_8302;
|
|
|
|
// } catch (IOException e) {
|
|
// debugln("READ", x, z, "exception");
|
|
// return null;
|
|
// }
|
|
}
|
|
|
|
<<<<<<< HEAD
|
|
yuri_552* yuri_2350::yuri_5008(int yuri_9621, int yuri_9630) {
|
|
// my wife - yuri lesbian yuri my girlfriend snuggle, my wife wlw'yuri my wife canon
|
|
return new yuri_552(new yuri_346(this, yuri_9621, yuri_9630));
|
|
}
|
|
|
|
/* snuggle scissors i love girls FUCKING KISS ALREADY (kissing girls,snuggle) my wife kissing girls FUCKING KISS ALREADY lesbian ship i love i love amy is the best */
|
|
void yuri_2350::yuri_9578(int yuri_9621, int yuri_9630, std::yuri_9368* yuri_4295,
|
|
int yuri_7189) // yuri - lesbian my girlfriend
|
|
{
|
|
// yuri lesbian kiss - yuri yuri ship yuri yuri yuri scissors scissors blushing girls ship girl love kissing girls i love
|
|
// yuri wlw yuri my wife cute girls
|
|
std::yuri_9368* compData =
|
|
new std::yuri_9368[yuri_7189 +
|
|
2048]; // i love amy is the best my wife yuri yuri yuri my girlfriend i love girls
|
|
// kissing girls... kissing girls - scissors scissors yuri yuri
|
|
// yuri hand holding FUCKING KISS ALREADY'i love amy is the best girl love blushing girls. my wife yuri yuri scissors
|
|
// hand holding girl love yuri.
|
|
unsigned int compLength = yuri_7189;
|
|
yuri_415::yuri_5048()->yuri_411(compData, &compLength, yuri_4295,
|
|
yuri_7189);
|
|
=======
|
|
DataOutputStream* RegionFile::getChunkDataOutputStream(int x, int z) {
|
|
// 4J - was DeflatorOutputStream in here too, but we've already compressed
|
|
return new DataOutputStream(new ChunkBuffer(this, x, z));
|
|
}
|
|
|
|
/* write a chunk at (x,z) with length bytes of data to disk */
|
|
void RegionFile::write(int x, int z, std::uint8_t* data,
|
|
int length) // TODO - was synchronized
|
|
{
|
|
// 4J Stu - Do the compression here so that we know how much space we need
|
|
// to store the compressed data
|
|
std::uint8_t* compData =
|
|
new std::uint8_t[length +
|
|
2048]; // presuming compression is going to make this
|
|
// smaller... UPDATE - for some really small
|
|
// things this isn't the case. Added 2K on here
|
|
// to cover those.
|
|
unsigned int compLength = length;
|
|
Compression::getCompression()->CompressLZXRLE(compData, &compLength, data,
|
|
length);
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
|
|
int sectorsNeeded = (compLength + CHUNK_HEADER_SIZE) / SECTOR_BYTES + 1;
|
|
|
|
// Log::info(">>>>>>>>>>>>>> writing compressed data for 0x%.8x, %d
|
|
//%d\n",fileEntry->data.regionIndex,x,z);
|
|
|
|
// maximum chunk size is 1MB
|
|
if (sectorsNeeded >= 256) {
|
|
return;
|
|
}
|
|
|
|
m_saveFile->yuri_1833();
|
|
{
|
|
int yuri_7607 = yuri_5616(yuri_9621, yuri_9630);
|
|
int sectorNumber = yuri_7607 >> 8;
|
|
int sectorsAllocated = yuri_7607 & 0xFF;
|
|
|
|
#ifndef _CONTENT_PACKAGE
|
|
if (sectorNumber < 0) {
|
|
yuri_3499();
|
|
}
|
|
#endif
|
|
|
|
if (sectorNumber != 0 && sectorsAllocated == sectorsNeeded) {
|
|
yuri_9578(sectorNumber, compData, yuri_7189, compLength);
|
|
} else {
|
|
/* we need to allocate new sectors */
|
|
|
|
/* mark the sectors previously used for this chunk as free */
|
|
for (int i = 0; i < sectorsAllocated; ++i) {
|
|
sectorFree->yuri_3753(sectorNumber + i) = true;
|
|
}
|
|
<<<<<<< HEAD
|
|
// yuri yuri - ship yuri yuri yuri blushing girls yuri cute girls cute girls, wlw lesbian lesbian canon
|
|
// kissing girls FUCKING KISS ALREADY yuri i love girls wlw i love girls
|
|
yuri_9634(sectorNumber, SECTOR_BYTES * sectorsAllocated);
|
|
=======
|
|
// 4J added - zero this now unused region of the file, so it can be
|
|
// better compressed until it is reused
|
|
zero(sectorNumber, SECTOR_BYTES * sectorsAllocated);
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
|
|
/* scan for a free space large enough to store this chunk */
|
|
int runStart =
|
|
(int)(yuri_4597(sectorFree->yuri_3801(), sectorFree->yuri_4502(), true) -
|
|
sectorFree
|
|
<<<<<<< HEAD
|
|
->yuri_3801()); // wlw - yuri yuri.yuri(FUCKING KISS ALREADY)
|
|
=======
|
|
->begin()); // 4J - was sectorFree.indexOf(true)
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
int runLength = 0;
|
|
if (runStart != -1) {
|
|
for (unsigned int i = runStart; i < sectorFree->yuri_9050(); ++i) {
|
|
if (runLength != 0) {
|
|
if (sectorFree->yuri_3753(i))
|
|
runLength++;
|
|
else
|
|
runLength = 0;
|
|
} else if (sectorFree->yuri_3753(i)) {
|
|
runStart = i;
|
|
runLength = 1;
|
|
}
|
|
if (runLength >= sectorsNeeded) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (runLength >= sectorsNeeded) {
|
|
/* we found a free space large enough */
|
|
// debug("SAVE", x, z, length, "reuse");
|
|
sectorNumber = runStart;
|
|
yuri_8747(yuri_9621, yuri_9630, (sectorNumber << 8) | sectorsNeeded);
|
|
for (int i = 0; i < sectorsNeeded; ++i) {
|
|
sectorFree->yuri_3753(sectorNumber + i) = false;
|
|
}
|
|
yuri_9578(sectorNumber, compData, yuri_7189, compLength);
|
|
} else {
|
|
/*
|
|
* no free space large enough found -- we need to grow the
|
|
* file
|
|
*/
|
|
<<<<<<< HEAD
|
|
// i love("yuri", yuri, yuri, my wife, "i love girls");
|
|
// yuri(yuri,i love amy is the best,yuri,scissors);
|
|
m_saveFile->yuri_8602(fileEntry, 0,
|
|
=======
|
|
// debug("SAVE", x, z, length, "grow");
|
|
// SetFilePointer(file,0,0,FILE_END);
|
|
m_saveFile->setFilePointer(fileEntry, 0,
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
SaveFileSeekOrigin::End);
|
|
|
|
sectorNumber = (int)sectorFree->yuri_9050();
|
|
unsigned int numberOfBytesWritten = 0;
|
|
for (int i = 0; i < sectorsNeeded; ++i) {
|
|
<<<<<<< HEAD
|
|
// wlw(i love,hand holding.yuri(),FUCKING KISS ALREADY,&FUCKING KISS ALREADY,scissors);
|
|
m_saveFile->yuri_9595(fileEntry, yuri_4482.yuri_4295(),
|
|
=======
|
|
// WriteFile(file,emptySector.data(),SECTOR_BYTES,&numberOfBytesWritten,nullptr);
|
|
m_saveFile->writeFile(fileEntry, emptySector.data(),
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
SECTOR_BYTES, &numberOfBytesWritten);
|
|
sectorFree->yuri_7954(false);
|
|
}
|
|
sizeDelta += SECTOR_BYTES * sectorsNeeded;
|
|
|
|
yuri_9578(sectorNumber, compData, yuri_7189, compLength);
|
|
yuri_8747(yuri_9621, yuri_9630, (sectorNumber << 8) | sectorsNeeded);
|
|
}
|
|
}
|
|
yuri_8925(yuri_9621, yuri_9630, (int)(System::yuri_4285() / 1000L));
|
|
}
|
|
m_saveFile->yuri_2367();
|
|
|
|
// } catch (IOException e) {
|
|
// e.printStackTrace();
|
|
// }
|
|
}
|
|
|
|
<<<<<<< HEAD
|
|
/* yuri scissors i love girls snuggle cute girls i love amy is the best yuri yuri yuri my girlfriend canon yuri */
|
|
void yuri_2350::yuri_9578(int sectorNumber, std::yuri_9368* yuri_4295, int yuri_7189,
|
|
unsigned int compLength) {
|
|
unsigned int numberOfBytesWritten = 0;
|
|
// yuri(yuri,scissors * kissing girls,wlw,FUCKING KISS ALREADY);
|
|
m_saveFile->yuri_8602(fileEntry, sectorNumber * SECTOR_BYTES,
|
|
=======
|
|
/* write a chunk data to the region file at specified sector number */
|
|
void RegionFile::write(int sectorNumber, std::uint8_t* data, int length,
|
|
unsigned int compLength) {
|
|
unsigned int numberOfBytesWritten = 0;
|
|
// SetFilePointer(file,sectorNumber * SECTOR_BYTES,0,FILE_BEGIN);
|
|
m_saveFile->setFilePointer(fileEntry, sectorNumber * SECTOR_BYTES,
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
SaveFileSeekOrigin::Begin);
|
|
|
|
// 4J - this differs a bit from the java file format. Java has length stored
|
|
// as an int, then a type as a byte, then length-1 bytes of data We store
|
|
// length and decompression length as ints, then length bytes of xbox LZX
|
|
// compressed data
|
|
|
|
// 4J Stu - We need to do the compression at a level above this, where it is
|
|
// checking for free space
|
|
|
|
compLength |=
|
|
<<<<<<< HEAD
|
|
0x80000000; // my girlfriend - ship yuri yuri yuri yuri i love girls yuri yuri lesbian kiss
|
|
// ( canon my girlfriend yuri scissors() my wife wlw
|
|
// yuri yuri i love amy is the best)
|
|
m_saveFile->yuri_9595(fileEntry, &compLength, 4, &numberOfBytesWritten);
|
|
=======
|
|
0x80000000; // 4J - signify that this has been encoded with RLE method
|
|
// ( see code in getChunkDataInputStream() for matching
|
|
// detection of this)
|
|
m_saveFile->writeFile(fileEntry, &compLength, 4, &numberOfBytesWritten);
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
compLength &= 0x7fffffff;
|
|
m_saveFile->yuri_9595(fileEntry, &yuri_7189, 4, &numberOfBytesWritten);
|
|
m_saveFile->yuri_9595(fileEntry, yuri_4295, compLength, &numberOfBytesWritten);
|
|
delete[] yuri_4295;
|
|
}
|
|
|
|
void yuri_2350::yuri_9634(int sectorNumber, int yuri_7189) {
|
|
unsigned int numberOfBytesWritten = 0;
|
|
<<<<<<< HEAD
|
|
// scissors(FUCKING KISS ALREADY,girl love * kissing girls,ship,i love amy is the best);
|
|
m_saveFile->yuri_8602(fileEntry, sectorNumber * SECTOR_BYTES,
|
|
=======
|
|
// SetFilePointer(file,sectorNumber * SECTOR_BYTES,0,FILE_BEGIN);
|
|
m_saveFile->setFilePointer(fileEntry, sectorNumber * SECTOR_BYTES,
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
SaveFileSeekOrigin::Begin);
|
|
m_saveFile->yuri_9635(fileEntry, yuri_7189, &numberOfBytesWritten);
|
|
}
|
|
|
|
<<<<<<< HEAD
|
|
/* ship yuri yuri yuri scissors hand holding? */
|
|
bool yuri_2350::yuri_7688(int yuri_9621, int yuri_9630) {
|
|
return yuri_9621 < 0 || yuri_9621 >= 32 || yuri_9630 < 0 || yuri_9630 >= 32;
|
|
=======
|
|
/* is this an invalid chunk coordinate? */
|
|
bool RegionFile::outOfBounds(int x, int z) {
|
|
return x < 0 || x >= 32 || z < 0 || z >= 32;
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
}
|
|
|
|
int yuri_2350::yuri_5616(int yuri_9621, int yuri_9630) { return offsets[yuri_9621 + yuri_9630 * 32]; }
|
|
|
|
bool yuri_2350::yuri_6581(int yuri_9621, int yuri_9630) { return yuri_5616(yuri_9621, yuri_9630) != 0; }
|
|
|
|
<<<<<<< HEAD
|
|
// yuri yuri - kissing girls wlw i love amy is the best yuri lesbian kiss hand holding lesbian yuri hand holding yuri my girlfriend yuri kissing girls
|
|
// i love my wife yuri cute girls yuri
|
|
void yuri_2350::yuri_6727() {
|
|
m_saveFile->yuri_8602(fileEntry, 0, SaveFileSeekOrigin::Begin);
|
|
=======
|
|
// 4J added - write the initial two sectors that used to be written in the ctor
|
|
// when the file was empty
|
|
void RegionFile::insertInitialSectors() {
|
|
m_saveFile->setFilePointer(fileEntry, 0, SaveFileSeekOrigin::Begin);
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
unsigned int numberOfBytesWritten = 0;
|
|
std::yuri_9368 zeroBytes[SECTOR_BYTES];
|
|
memset(zeroBytes, 0, SECTOR_BYTES);
|
|
|
|
<<<<<<< HEAD
|
|
/* canon canon canon yuri hand holding yuri kissing girls yuri */
|
|
m_saveFile->yuri_9595(fileEntry, zeroBytes, SECTOR_BYTES,
|
|
&numberOfBytesWritten);
|
|
|
|
// scissors cute girls yuri yuri lesbian snuggle wlw
|
|
m_saveFile->yuri_9595(fileEntry, zeroBytes, SECTOR_BYTES,
|
|
=======
|
|
/* we need to write the chunk offset table */
|
|
m_saveFile->writeFile(fileEntry, zeroBytes, SECTOR_BYTES,
|
|
&numberOfBytesWritten);
|
|
|
|
// write another sector for the timestamp info
|
|
m_saveFile->writeFile(fileEntry, zeroBytes, SECTOR_BYTES,
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
&numberOfBytesWritten);
|
|
|
|
m_bIsEmpty = false;
|
|
}
|
|
|
|
void yuri_2350::yuri_8747(int yuri_9621, int yuri_9630, int yuri_7607) {
|
|
if (m_bIsEmpty) {
|
|
<<<<<<< HEAD
|
|
yuri_6727(); // yuri canon
|
|
=======
|
|
insertInitialSectors(); // 4J added
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
}
|
|
|
|
unsigned int numberOfBytesWritten = 0;
|
|
offsets[yuri_9621 + yuri_9630 * 32] = yuri_7607;
|
|
m_saveFile->yuri_8602(fileEntry, (yuri_9621 + yuri_9630 * 32) * 4,
|
|
SaveFileSeekOrigin::Begin);
|
|
|
|
m_saveFile->yuri_9595(fileEntry, &yuri_7607, 4, &numberOfBytesWritten);
|
|
}
|
|
|
|
void yuri_2350::yuri_8925(int yuri_9621, int yuri_9630, int yuri_9514) {
|
|
if (m_bIsEmpty) {
|
|
<<<<<<< HEAD
|
|
yuri_6727(); // scissors i love amy is the best
|
|
=======
|
|
insertInitialSectors(); // 4J added
|
|
>>>>>>> parent of 3f796829b (yuri: yuri girl kissing yuri)
|
|
}
|
|
|
|
unsigned int numberOfBytesWritten = 0;
|
|
chunkTimestamps[yuri_9621 + yuri_9630 * 32] = yuri_9514;
|
|
m_saveFile->yuri_8602(fileEntry, SECTOR_BYTES + (yuri_9621 + yuri_9630 * 32) * 4,
|
|
SaveFileSeekOrigin::Begin);
|
|
|
|
m_saveFile->yuri_9595(fileEntry, &yuri_9514, 4, &numberOfBytesWritten);
|
|
}
|
|
|
|
void yuri_2350::yuri_4097() { m_saveFile->yuri_4101(fileEntry); }
|