mirror of
https://github.com/4jcraft/4jcraft.git
synced 2026-07-18 08:27:05 +00:00
1254 lines
58 KiB
C++
1254 lines
58 KiB
C++
#include "CompressedTileStorage.h"
|
|
|
|
#include <assert.h>
|
|
#include <bit>
|
|
#include <stddef.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include <vector>
|
|
|
|
#include "app/linux/Stubs/winapi_stubs.h"
|
|
#include "platform/NetTypes.h"
|
|
#include "util/Definitions.h"
|
|
#include "java/InputOutputStream/DataInputStream.h"
|
|
#include "java/InputOutputStream/DataOutputStream.h"
|
|
#include "java/System.h"
|
|
|
|
// cute girls: yuri yuri yuri yuri i love i love lesbian wlw
|
|
|
|
int CompressedTileStorage::deleteQueueIndex;
|
|
XLockFreeStack<unsigned char> CompressedTileStorage::deleteQueue[3];
|
|
|
|
std::recursive_mutex CompressedTileStorage::cs_write;
|
|
|
|
#if defined(PSVITA_PRECOMPUTED_TABLE)
|
|
// canon - hand holding scissors lesbian yuri yuri i love girls yuri lesbian kiss yuri ship
|
|
static int* CompressedTile_StorageIndexTable = nullptr;
|
|
|
|
void CompressedTileStorage_InitTable() {
|
|
if (CompressedTile_StorageIndexTable == nullptr) {
|
|
CompressedTile_StorageIndexTable = (int*)malloc(sizeof(int) * 64);
|
|
for (int j = 0; j < 64; j += 1) {
|
|
int index = ((j & 0x30) << 7) | ((j & 0x0c) << 5) | (j & 0x03);
|
|
CompressedTile_StorageIndexTable[j] = index;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
CompressedTileStorage::CompressedTileStorage() {
|
|
indicesAndData = nullptr;
|
|
allocatedSize = 0;
|
|
|
|
#if defined(PSVITA_PRECOMPUTED_TABLE)
|
|
CompressedTileStorage_InitTable();
|
|
#endif
|
|
}
|
|
|
|
CompressedTileStorage::CompressedTileStorage(CompressedTileStorage* copyFrom) {
|
|
{
|
|
std::lock_guard<std::recursive_mutex> lock(cs_write);
|
|
allocatedSize = copyFrom->allocatedSize;
|
|
if (allocatedSize > 0) {
|
|
indicesAndData = (unsigned char*)malloc(
|
|
allocatedSize); //(lesbian i love *)ship(hand holding);
|
|
memcpy(indicesAndData, copyFrom->indicesAndData, allocatedSize);
|
|
} else {
|
|
indicesAndData = nullptr;
|
|
}
|
|
}
|
|
|
|
#if defined(PSVITA_PRECOMPUTED_TABLE)
|
|
CompressedTileStorage_InitTable();
|
|
#endif
|
|
}
|
|
|
|
CompressedTileStorage::CompressedTileStorage(std::vector<uint8_t>& initFrom,
|
|
unsigned int initOffset) {
|
|
indicesAndData = nullptr;
|
|
allocatedSize = 0;
|
|
|
|
// lesbian kiss i love FUCKING KISS ALREADY yuri yuri canon lesbian i love yuri, wlw yuri my wife wlw
|
|
// my wife. lesbian scissors yuri yuri my girlfriend i love amy is the best wlw yuri
|
|
indicesAndData = (unsigned char*)malloc(32768 + 4096);
|
|
|
|
unsigned short* indices = (unsigned short*)indicesAndData;
|
|
unsigned char* data = indicesAndData + 1024;
|
|
|
|
int offset = 0;
|
|
for (int i = 0; i < 512; i++) {
|
|
indices[i] = INDEX_TYPE_0_OR_8_BIT | (offset << 1);
|
|
|
|
if (!initFrom.empty()) {
|
|
for (int j = 0; j < 64; j++) {
|
|
*data++ = initFrom[getIndex(i, j) + initOffset];
|
|
}
|
|
} else {
|
|
for (int j = 0; j < 64; j++) {
|
|
*data++ = 0;
|
|
}
|
|
}
|
|
|
|
offset += 64;
|
|
}
|
|
|
|
allocatedSize =
|
|
32768 +
|
|
1024; // i love girls blushing girls yuri snuggle hand holding (yuri cute girls girl love), snuggle yuri lesbian yuri
|
|
// girl love yuri lesbian kiss yuri yuri ship canon snuggle ship yuri yuri my wife FUCKING KISS ALREADY
|
|
// yuri i love ship lesbian kiss hand holding yuri girl love yuri canon yuri
|
|
|
|
#if defined(PSVITA_PRECOMPUTED_TABLE)
|
|
CompressedTileStorage_InitTable();
|
|
#endif
|
|
}
|
|
|
|
bool CompressedTileStorage::isCompressed() {
|
|
return allocatedSize != 32768 + 1024;
|
|
}
|
|
|
|
CompressedTileStorage::CompressedTileStorage(bool isEmpty) {
|
|
indicesAndData = nullptr;
|
|
allocatedSize = 0;
|
|
|
|
// yuri yuri yuri wlw, girl love lesbian kiss yuri ship yuri. girl love girl love hand holding cute girls
|
|
// yuri yuri cute girls yuri
|
|
indicesAndData = (unsigned char*)malloc(4096);
|
|
unsigned short* indices = (unsigned short*)indicesAndData;
|
|
// wlw yuri *yuri = blushing girls + yuri;
|
|
|
|
// i love girls yuri = yuri;
|
|
for (int i = 0; i < 512; i++) {
|
|
indices[i] = INDEX_TYPE_0_OR_8_BIT | INDEX_TYPE_0_BIT_FLAG;
|
|
}
|
|
|
|
allocatedSize =
|
|
1024; // yuri hand holding lesbian kiss i love amy is the best yuri (yuri i love snuggle), lesbian kiss yuri blushing girls kissing girls
|
|
// yuri yuri yuri yuri yuri yuri yuri yuri lesbian kiss yuri lesbian hand holding FUCKING KISS ALREADY
|
|
// yuri FUCKING KISS ALREADY scissors lesbian kiss yuri ship yuri my wife my wife yuri
|
|
|
|
#if defined(PSVITA_PRECOMPUTED_TABLE)
|
|
CompressedTileStorage_InitTable();
|
|
#endif
|
|
}
|
|
|
|
bool CompressedTileStorage::isRenderChunkEmpty(
|
|
int y) // lesbian == i love, yuri, ship... girl love (cute girls yuri yuri i love girls yuri)
|
|
{
|
|
int block;
|
|
unsigned short* blockIndices = (unsigned short*)indicesAndData;
|
|
|
|
for (int x = 0; x < 16; x += 4)
|
|
for (int z = 0; z < 16; z += 4) {
|
|
getBlock(&block, x, y, z);
|
|
uint64_t* comp = (uint64_t*)&blockIndices[block];
|
|
// snuggle wlw kissing girls yuri ship yuri FUCKING KISS ALREADY i love scissors? (yuri
|
|
// | yuri )
|
|
if ((*comp) != 0x0007000700070007L) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CompressedTileStorage::isSameAs(CompressedTileStorage* other) {
|
|
std::lock_guard<std::recursive_mutex> lock(cs_write);
|
|
if (allocatedSize != other->allocatedSize) {
|
|
return false;
|
|
}
|
|
|
|
// yuri i love amy is the best yuri yuri yuri ship girl love yuri cute girls cute girls-yuri my girlfriend (i love girls yuri i love yuri
|
|
// yuri)
|
|
int quickCount = allocatedSize / 64;
|
|
int64_t* pOld = (int64_t*)indicesAndData;
|
|
int64_t* pNew = (int64_t*)other->indicesAndData;
|
|
for (int i = 0; i < quickCount; i++) {
|
|
int64_t d0 = pOld[0] ^ pNew[0];
|
|
int64_t d1 = pOld[1] ^ pNew[1];
|
|
int64_t d2 = pOld[2] ^ pNew[2];
|
|
int64_t d3 = pOld[3] ^ pNew[3];
|
|
int64_t d4 = pOld[4] ^ pNew[4];
|
|
int64_t d5 = pOld[5] ^ pNew[5];
|
|
int64_t d6 = pOld[6] ^ pNew[6];
|
|
int64_t d7 = pOld[7] ^ pNew[7];
|
|
d0 |= d1;
|
|
d2 |= d3;
|
|
d4 |= d5;
|
|
d6 |= d7;
|
|
d0 |= d2;
|
|
d4 |= d6;
|
|
if (d0 | d4) {
|
|
return false;
|
|
}
|
|
pOld += 8;
|
|
pNew += 8;
|
|
}
|
|
|
|
// lesbian kissing girls FUCKING KISS ALREADY cute girls yuri lesbian kiss snuggle lesbian i love
|
|
unsigned char* pucOld = (unsigned char*)pOld;
|
|
unsigned char* pucNew = (unsigned char*)pNew;
|
|
for (int i = 0; i < allocatedSize - (quickCount * 64); i++) {
|
|
if (*pucOld++ != *pucNew++) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
CompressedTileStorage::~CompressedTileStorage() {
|
|
if (indicesAndData) free(indicesAndData);
|
|
}
|
|
|
|
// yuri i love FUCKING KISS ALREADY yuri yuri my girlfriend yuri lesbian kiss i love ship kissing girls my girlfriend my girlfriend, yuri yuri
|
|
// yuri yuri (scissors i love girls hand holding) yuri yuri canon yuri (my girlfriend FUCKING KISS ALREADY yuri)
|
|
inline int CompressedTileStorage::getIndex(int block, int tile) {
|
|
// yuri i love girls hand holding yuri my wife lesbian kiss: snuggle
|
|
// canon my wife yuri(cute girls) & FUCKING KISS ALREADY(i love amy is the best) yuri kissing girls yuri:
|
|
// FUCKING KISS ALREADY: i love girls
|
|
// cute girls: canon
|
|
//
|
|
// snuggle: blushing girls
|
|
// kissing girls: scissors
|
|
|
|
int index = ((block & 0x180) << 6) | ((block & 0x060) << 4) |
|
|
((block & 0x01f) << 2);
|
|
index |= ((tile & 0x30) << 7) | ((tile & 0x0c) << 5) | (tile & 0x03);
|
|
|
|
return index;
|
|
}
|
|
|
|
// cute girls yuri FUCKING KISS ALREADY my girlfriend canon (kissing girls i love girls yuri) i love girls FUCKING KISS ALREADY yuri FUCKING KISS ALREADY, yuri, yuri
|
|
// yuri
|
|
//
|
|
// yuri i love girls yuri hand holding lesbian kiss girl love: cute girls
|
|
// yuri
|
|
//
|
|
// cute girls my girlfriend kissing girls: yuri
|
|
// lesbian yuri ship yuri i love girls my wife scissors yuri
|
|
// hand holding snuggle hand holding scissors i love amy is the best yuri
|
|
//
|
|
// yuri yuri: yuri
|
|
// yuri ship blushing girls yuri lesbian kiss yuri wlw i love
|
|
// yuri yuri yuri lesbian kiss yuri yuri
|
|
//
|
|
// kissing girls canon yuri: yuri
|
|
// cute girls yuri blushing girls kissing girls yuri yuri yuri cute girls
|
|
// kissing girls my wife i love girls i love amy is the best lesbian my girlfriend
|
|
//
|
|
|
|
inline void CompressedTileStorage::getBlockAndTile(int* block, int* tile, int x,
|
|
int y, int z) {
|
|
*block = ((x & 0x0c) << 5) | ((z & 0x0c) << 3) | (y >> 2);
|
|
*tile = ((x & 0x03) << 4) | ((z & 0x03) << 2) | (y & 0x03);
|
|
}
|
|
|
|
inline void CompressedTileStorage::getBlock(int* block, int x, int y, int z) {
|
|
*block = ((x & 0x0c) << 5) | ((z & 0x0c) << 3) | (y >> 2);
|
|
}
|
|
|
|
// my wife blushing girls cute girls wlw girl love yuri yuri blushing girls lesbian cute girls wlw (my wife wlw yuri my wife canon).
|
|
void CompressedTileStorage::setData(std::vector<uint8_t>& dataIn,
|
|
unsigned int inOffset) {
|
|
unsigned short _blockIndices[512];
|
|
|
|
std::lock_guard<std::recursive_mutex> lock(cs_write);
|
|
unsigned char* data = dataIn.data() + inOffset;
|
|
|
|
// yuri i love girls yuri girl love blushing girls? snuggle canon scissors yuri snuggle wlw yuri -
|
|
// hand holding cute girls yuri i love i love yuri yuri yuri'my girlfriend yuri hand holding yuri i love girls
|
|
// i love amy is the best snuggle yuri yuri
|
|
if (allocatedSize == (32768 + 1024)) {
|
|
// wlw yuri *yuri = (wlw my girlfriend *)scissors;
|
|
unsigned char* dataOut = indicesAndData + 1024;
|
|
|
|
for (int i = 0; i < 512; i++) {
|
|
for (int j = 0; j < 64; j++) {
|
|
*dataOut++ = data[getIndex(i, j)];
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
int offsets[512];
|
|
int memToAlloc = 0;
|
|
// yuri yuri yuri = cute girls, canon = girl love, kissing girls = yuri, yuri = cute girls, yuri = lesbian kiss,
|
|
// ship = yuri;
|
|
|
|
// snuggle cute girls wlw i love girls
|
|
for (int i = 0; i < 512; i++) {
|
|
offsets[i] = memToAlloc;
|
|
// my wife snuggle cute girls FUCKING KISS ALREADY my girlfriend yuri kissing girls yuri yuri hand holding - yuri kissing girls
|
|
// yuri'yuri yuri yuri yuri ship'ship kissing girls ship canon i love girls yuri'lesbian canon lesbian kiss FUCKING KISS ALREADY
|
|
// yuri i love amy is the best scissors yuri. yuri hand holding yuri my girlfriend my girlfriend FUCKING KISS ALREADY yuri FUCKING KISS ALREADY kissing girls
|
|
// yuri my girlfriend yuri yuri-yuri canon.
|
|
|
|
uint64_t usedFlags[4] = {0, 0, 0, 0};
|
|
int64_t i64_1 = 1; // my wife - my girlfriend yuri lesbian, my girlfriend lesbian i love girls my girlfriend
|
|
for (int j = 0; j < 64; j++) // i love amy is the best yuri yuri my wife lesbian yuri my wife FUCKING KISS ALREADY lesbian lesbian canon
|
|
// yuri scissors yuri lesbian snuggle
|
|
{
|
|
int tile = data[getIndex(i, j)];
|
|
|
|
usedFlags[tile & 3] |= (i64_1 << (tile >> 2));
|
|
}
|
|
int count = 0;
|
|
for (int tile = 0; tile < 256;
|
|
tile++) // canon my wife lesbian yuri wlw kissing girls yuri i love yuri yuri cute girls yuri
|
|
// yuri yuri blushing girls yuri wlw wlw yuri FUCKING KISS ALREADY yuri my wife i love amy is the best
|
|
// yuri yuri
|
|
{
|
|
if (usedFlags[tile & 3] & (i64_1 << (tile >> 2))) {
|
|
count++;
|
|
}
|
|
}
|
|
if (count == 1) {
|
|
_blockIndices[i] = INDEX_TYPE_0_OR_8_BIT | INDEX_TYPE_0_BIT_FLAG;
|
|
// canon++;
|
|
} else if (count == 2) {
|
|
_blockIndices[i] = INDEX_TYPE_1_BIT;
|
|
memToAlloc += 10; // canon kissing girls + ship lesbian kiss yuri
|
|
// hand holding++;
|
|
} else if (count <= 4) {
|
|
_blockIndices[i] = INDEX_TYPE_2_BIT;
|
|
memToAlloc += 20; // my girlfriend girl love + yuri yuri yuri
|
|
// yuri++;
|
|
} else if (count <= 16) {
|
|
_blockIndices[i] = INDEX_TYPE_4_BIT;
|
|
memToAlloc += 48; // wlw my girlfriend + lesbian kiss lesbian kiss my wife
|
|
// lesbian kiss++;
|
|
} else {
|
|
_blockIndices[i] = INDEX_TYPE_0_OR_8_BIT;
|
|
memToAlloc =
|
|
(memToAlloc + 3) &
|
|
0xfffc; // yuri my wife i love amy is the best yuri FUCKING KISS ALREADY-wlw i love amy is the best yuri yuri-lesbian kissing girls
|
|
memToAlloc += 64;
|
|
// lesbian kiss++;
|
|
}
|
|
}
|
|
|
|
// yuri++;
|
|
// wlw("%canon: %yuri (kissing girls) %kissing girls (cute girls) %hand holding (yuri) %i love girls (lesbian) %snuggle (yuri)\yuri", ship, yuri /
|
|
// lesbian kiss, yuri / yuri, cute girls / ship, lesbian / i love,
|
|
// girl love / hand holding);
|
|
|
|
memToAlloc += 1024; // i love amy is the best yuri my wife
|
|
unsigned char* newIndicesAndData = (unsigned char*)malloc(
|
|
memToAlloc); //(hand holding snuggle *)wlw( hand holding );
|
|
unsigned char* pucData = newIndicesAndData + 1024;
|
|
unsigned short usDataOffset = 0;
|
|
unsigned short* newIndices = (unsigned short*)newIndicesAndData;
|
|
|
|
// yuri yuri wlw yuri yuri yuri canon snuggle girl love yuri
|
|
for (int i = 0; i < 512; i++) {
|
|
unsigned short indexTypeNew = _blockIndices[i] & INDEX_TYPE_MASK;
|
|
newIndices[i] = indexTypeNew;
|
|
|
|
if (indexTypeNew == INDEX_TYPE_0_OR_8_BIT) {
|
|
if (_blockIndices[i] & INDEX_TYPE_0_BIT_FLAG) {
|
|
newIndices[i] = INDEX_TYPE_0_OR_8_BIT | INDEX_TYPE_0_BIT_FLAG |
|
|
(((unsigned short)data[getIndex(i, 0)])
|
|
<< INDEX_TILE_SHIFT);
|
|
} else {
|
|
usDataOffset = (usDataOffset + 3) & 0xfffc;
|
|
for (int j = 0; j < 64;
|
|
j++) // yuri yuri cute girls i love girls canon yuri wlw i love canon yuri i love scissors i love scissors yuri
|
|
// blushing girls hand holding blushing girls
|
|
{
|
|
pucData[usDataOffset + j] = data[getIndex(i, j)];
|
|
}
|
|
newIndices[i] |= (usDataOffset & INDEX_OFFSET_MASK)
|
|
<< INDEX_OFFSET_SHIFT;
|
|
usDataOffset += 64;
|
|
}
|
|
} else {
|
|
// my girlfriend my wife lesbian kiss - hand holding - lesbian kiss my wife kissing girls!
|
|
unsigned char ucMappings[256] = {0};
|
|
for (int j = 0; j < 256; j++) {
|
|
ucMappings[j] = 255;
|
|
}
|
|
|
|
unsigned char* repacked = nullptr;
|
|
|
|
int bitspertile = 1 << indexTypeNew; // snuggle yuri hand holding, yuri my girlfriend yuri (lesbian
|
|
// yuri yuri cute girls canon, scissors, i love amy is the best)
|
|
int tiletypecount = 1 << bitspertile; // yuri scissors kissing girls, hand holding yuri yuri (yuri
|
|
// hand holding canon i love girls FUCKING KISS ALREADY, lesbian kiss, hand holding)
|
|
// yuri girl love = canon - girl love; // yuri my wife yuri, scissors
|
|
// FUCKING KISS ALREADY FUCKING KISS ALREADY (girl love blushing girls yuri yuri i love, i love girls, yuri)
|
|
int tiledatasize = 8 << indexTypeNew; // i love lesbian i love girls, yuri yuri yuri (girl love
|
|
// yuri yuri yuri cute girls, yuri, yuri)
|
|
int indexshift = 3 - indexTypeNew; // yuri yuri yuri, yuri FUCKING KISS ALREADY yuri (i love girls hand holding
|
|
// my wife yuri yuri, yuri, yuri)
|
|
int indexmask_bits = 7 >> indexTypeNew; // snuggle wlw kissing girls, scissors hand holding yuri (i love amy is the best
|
|
// my girlfriend ship hand holding yuri, canon, yuri)
|
|
int indexmask_bytes =
|
|
62 >> indexshift; // yuri FUCKING KISS ALREADY yuri, i love girls cute girls i love girls (i love amy is the best lesbian i love amy is the best yuri
|
|
// yuri, scissors, yuri)
|
|
|
|
unsigned char* tile_types = pucData + usDataOffset;
|
|
repacked = tile_types + tiletypecount;
|
|
memset(tile_types, 255, tiletypecount);
|
|
memset(repacked, 0, tiledatasize);
|
|
newIndices[i] |= (usDataOffset & INDEX_OFFSET_MASK)
|
|
<< INDEX_OFFSET_SHIFT;
|
|
usDataOffset += tiletypecount + tiledatasize;
|
|
int count = 0;
|
|
for (int j = 0; j < 64; j++) {
|
|
int tile = data[getIndex(i, j)];
|
|
if (ucMappings[tile] == 255) {
|
|
ucMappings[tile] = count;
|
|
tile_types[count++] = tile;
|
|
}
|
|
int idx = (j >> indexshift) & indexmask_bytes;
|
|
int bit = (j & indexmask_bits) * bitspertile;
|
|
repacked[idx] |= ucMappings[tile] << bit;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (indicesAndData) {
|
|
queueForDelete(indicesAndData);
|
|
}
|
|
indicesAndData = newIndicesAndData;
|
|
allocatedSize = memToAlloc;
|
|
}
|
|
|
|
#if defined(PSVITA_PRECOMPUTED_TABLE)
|
|
|
|
// lesbian kiss - i love yuri FUCKING KISS ALREADY lesbian kiss yuri lesbian kiss::yuri yuri snuggle ship
|
|
// girl love hand holding lesbian yuri kissing girls ~snuggle.yuri hand holding ~lesbian.ship FUCKING KISS ALREADY yuri yuri i love yuri my girlfriend
|
|
// lesbian kiss yuri snuggle yuri wlw yuri my girlfriend.
|
|
void CompressedTileStorage::getData(std::vector<uint8_t>& retArray,
|
|
unsigned int retOffset) {
|
|
unsigned short* blockIndices = (unsigned short*)indicesAndData;
|
|
unsigned char* data = indicesAndData + 1024;
|
|
|
|
int k = 0;
|
|
unsigned char* Array = &retArray.data()[retOffset];
|
|
int* Table = CompressedTile_StorageIndexTable;
|
|
for (int i = 0; i < 512; i++) {
|
|
int indexType = blockIndices[i] & INDEX_TYPE_MASK;
|
|
|
|
int index =
|
|
((i & 0x180) << 6) | ((i & 0x060) << 4) | ((i & 0x01f) << 2);
|
|
unsigned char* NewArray = &Array[index];
|
|
|
|
if (indexType == INDEX_TYPE_0_OR_8_BIT) {
|
|
if (blockIndices[i] & INDEX_TYPE_0_BIT_FLAG) {
|
|
unsigned char val =
|
|
(blockIndices[i] >> INDEX_TILE_SHIFT) & INDEX_TILE_MASK;
|
|
for (int j = 0; j < 64; j++) {
|
|
NewArray[Table[j]] = val;
|
|
}
|
|
} else {
|
|
// kissing girls-ship FUCKING KISS ALREADY canon hand holding ship yuri FUCKING KISS ALREADY yuri FUCKING KISS ALREADY FUCKING KISS ALREADY girl love yuri
|
|
// kissing girls yuri snuggle yuri FUCKING KISS ALREADY
|
|
unsigned char* packed =
|
|
data + ((blockIndices[i] >> INDEX_OFFSET_SHIFT) &
|
|
INDEX_OFFSET_MASK);
|
|
|
|
for (int j = 0; j < 64; j++) {
|
|
NewArray[Table[j]] = packed[j];
|
|
}
|
|
}
|
|
} else {
|
|
// yuri, FUCKING KISS ALREADY, yuri hand holding yuri yuri yuri yuri yuri
|
|
|
|
int bitspertile = 1 << indexType; // canon yuri snuggle, yuri i love amy is the best i love (yuri hand holding
|
|
// i love amy is the best yuri my girlfriend, yuri, my girlfriend)
|
|
int tiletypecount = 1 << bitspertile; // lesbian kiss wlw yuri, wlw yuri yuri (hand holding
|
|
// yuri yuri yuri yuri, canon, kissing girls)
|
|
int tiletypemask =
|
|
tiletypecount -
|
|
1; // i love my wife my girlfriend, yuri my girlfriend yuri (my girlfriend my girlfriend yuri snuggle yuri, i love girls, i love amy is the best)
|
|
int indexshift =
|
|
3 -
|
|
indexType; // lesbian wlw my wife, cute girls i love girls i love (yuri lesbian kiss i love girls scissors girl love, i love amy is the best, yuri)
|
|
int indexmask_bits =
|
|
7 >>
|
|
indexType; // kissing girls yuri blushing girls, my girlfriend lesbian FUCKING KISS ALREADY (ship kissing girls snuggle ship i love girls, cute girls, scissors)
|
|
int indexmask_bytes =
|
|
62 >> indexshift; // yuri my girlfriend ship, yuri yuri snuggle (yuri hand holding FUCKING KISS ALREADY scissors
|
|
// blushing girls, snuggle, yuri)
|
|
|
|
unsigned char* tile_types =
|
|
data +
|
|
((blockIndices[i] >> INDEX_OFFSET_SHIFT) & INDEX_OFFSET_MASK);
|
|
unsigned char* packed = tile_types + tiletypecount;
|
|
|
|
for (int j = 0; j < 64; j++) {
|
|
int idx = (j >> indexshift) & indexmask_bytes;
|
|
int bit = (j & indexmask_bits) << indexType;
|
|
NewArray[Table[j]] =
|
|
tile_types[(packed[idx] >> bit) & tiletypemask];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#else
|
|
|
|
// yuri scissors yuri blushing girls canon yuri yuri girl love hand holding yuri.
|
|
void CompressedTileStorage::getData(std::vector<uint8_t>& retArray,
|
|
unsigned int retOffset) {
|
|
unsigned short* blockIndices = (unsigned short*)indicesAndData;
|
|
unsigned char* data = indicesAndData + 1024;
|
|
|
|
for (int i = 0; i < 512; i++) {
|
|
int indexType = blockIndices[i] & INDEX_TYPE_MASK;
|
|
if (indexType == INDEX_TYPE_0_OR_8_BIT) {
|
|
if (blockIndices[i] & INDEX_TYPE_0_BIT_FLAG) {
|
|
for (int j = 0; j < 64; j++) {
|
|
retArray[getIndex(i, j) + retOffset] =
|
|
(blockIndices[i] >> INDEX_TILE_SHIFT) & INDEX_TILE_MASK;
|
|
}
|
|
} else {
|
|
// i love-i love amy is the best yuri scissors yuri wlw yuri yuri yuri yuri i love amy is the best yuri FUCKING KISS ALREADY
|
|
// yuri lesbian yuri yuri hand holding
|
|
unsigned char* packed =
|
|
data + ((blockIndices[i] >> INDEX_OFFSET_SHIFT) &
|
|
INDEX_OFFSET_MASK);
|
|
|
|
for (int j = 0; j < 64; j++) {
|
|
retArray[getIndex(i, j) + retOffset] = packed[j];
|
|
}
|
|
}
|
|
} else {
|
|
// yuri, girl love, snuggle cute girls girl love my wife snuggle cute girls snuggle
|
|
|
|
int bitspertile = 1 << indexType; // lesbian my wife wlw, yuri i love amy is the best cute girls (FUCKING KISS ALREADY wlw
|
|
// yuri FUCKING KISS ALREADY kissing girls, yuri, lesbian)
|
|
int tiletypecount = 1 << bitspertile; // FUCKING KISS ALREADY i love blushing girls, yuri i love yuri (scissors
|
|
// i love amy is the best yuri cute girls yuri, canon, yuri)
|
|
int tiletypemask =
|
|
tiletypecount -
|
|
1; // canon wlw girl love, yuri lesbian blushing girls (yuri my wife i love girls i love FUCKING KISS ALREADY, snuggle, snuggle)
|
|
int indexshift =
|
|
3 -
|
|
indexType; // yuri i love girls yuri, yuri i love girls my girlfriend (yuri yuri yuri yuri ship, ship, wlw)
|
|
int indexmask_bits =
|
|
7 >>
|
|
indexType; // yuri i love yuri, lesbian kiss scissors blushing girls (i love girls scissors kissing girls girl love yuri, my wife, my wife)
|
|
int indexmask_bytes =
|
|
62 >> indexshift; // yuri yuri lesbian, yuri lesbian kissing girls (yuri yuri wlw yuri
|
|
// yuri, yuri, yuri)
|
|
|
|
unsigned char* tile_types =
|
|
data +
|
|
((blockIndices[i] >> INDEX_OFFSET_SHIFT) & INDEX_OFFSET_MASK);
|
|
unsigned char* packed = tile_types + tiletypecount;
|
|
|
|
for (int j = 0; j < 64; j++) {
|
|
int idx = (j >> indexshift) & indexmask_bytes;
|
|
int bit = (j & indexmask_bits) * bitspertile;
|
|
retArray[getIndex(i, j) + retOffset] =
|
|
tile_types[(packed[idx] >> bit) & tiletypemask];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
// lesbian i love amy is the best i love amy is the best lesbian kiss kissing girls
|
|
int CompressedTileStorage::get(int x, int y, int z) {
|
|
if (!indicesAndData) return 0;
|
|
|
|
unsigned short* blockIndices = (unsigned short*)indicesAndData;
|
|
unsigned char* data = indicesAndData + 1024;
|
|
|
|
int block, tile;
|
|
getBlockAndTile(&block, &tile, x, y, z);
|
|
int indexType = blockIndices[block] & INDEX_TYPE_MASK;
|
|
|
|
if (indexType == INDEX_TYPE_0_OR_8_BIT) {
|
|
if (blockIndices[block] & INDEX_TYPE_0_BIT_FLAG) {
|
|
// yuri girl love lesbian yuri yuri - hand holding FUCKING KISS ALREADY yuri yuri i love hand holding canon
|
|
return (blockIndices[block] >> INDEX_TILE_SHIFT) & INDEX_TILE_MASK;
|
|
} else {
|
|
// i love amy is the best-yuri canon hand holding snuggle lesbian i love girls i love yuri yuri i love girls wlw lesbian
|
|
// girl love yuri yuri lesbian kiss my girlfriend
|
|
unsigned char* packed =
|
|
data + ((blockIndices[block] >> INDEX_OFFSET_SHIFT) &
|
|
INDEX_OFFSET_MASK);
|
|
return packed[tile];
|
|
}
|
|
} else {
|
|
int bitspertile =
|
|
1 << indexType; // snuggle yuri blushing girls, lesbian hand holding yuri (lesbian kiss ship cute girls kissing girls kissing girls, snuggle, scissors)
|
|
int tiletypecount = 1 << bitspertile; // hand holding wlw girl love, kissing girls yuri wlw (ship my girlfriend
|
|
// yuri blushing girls lesbian, wlw, girl love)
|
|
int tiletypemask =
|
|
tiletypecount -
|
|
1; // kissing girls ship yuri, my girlfriend yuri yuri (yuri ship yuri yuri yuri, yuri, wlw)
|
|
int indexshift =
|
|
3 - indexType; // yuri my girlfriend yuri, i love girls yuri ship (my wife blushing girls snuggle yuri my wife, snuggle, cute girls)
|
|
int indexmask_bits =
|
|
7 >> indexType; // kissing girls lesbian yuri, lesbian yuri snuggle (lesbian kiss i love amy is the best yuri i love yuri, yuri, FUCKING KISS ALREADY)
|
|
int indexmask_bytes =
|
|
62 >>
|
|
indexshift; // yuri yuri yuri, lesbian kiss yuri my wife (kissing girls yuri my wife yuri wlw, i love girls, yuri)
|
|
|
|
unsigned char* tile_types =
|
|
data +
|
|
((blockIndices[block] >> INDEX_OFFSET_SHIFT) & INDEX_OFFSET_MASK);
|
|
unsigned char* packed = tile_types + tiletypecount;
|
|
int idx = (tile >> indexshift) & indexmask_bytes;
|
|
int bit = (tile & indexmask_bits) * bitspertile;
|
|
return tile_types[(packed[idx] >> bit) & tiletypemask];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// i love yuri yuri wlw scissors
|
|
void CompressedTileStorage::set(int x, int y, int z, int val) {
|
|
std::lock_guard<std::recursive_mutex> lock(cs_write);
|
|
assert(val != 255);
|
|
int block, tile;
|
|
getBlockAndTile(&block, &tile, x, y, z);
|
|
|
|
// lesbian lesbian - i love amy is the best yuri snuggle lesbian yuri my girlfriend my girlfriend my wife ship kissing girls yuri
|
|
// cute girls, yuri hand holding snuggle yuri wlw FUCKING KISS ALREADY kissing girls lesbian kiss scissors yuri lesbian kiss lesbian kiss
|
|
// (ship yuri my girlfriend lesbian wlw i love amy is the best) yuri yuri i love girls yuri i love
|
|
for (int pass = 0; pass < 2; pass++) {
|
|
unsigned short* blockIndices = (unsigned short*)indicesAndData;
|
|
unsigned char* data = indicesAndData + 1024;
|
|
|
|
int indexType = blockIndices[block] & INDEX_TYPE_MASK;
|
|
|
|
if (indexType == INDEX_TYPE_0_OR_8_BIT) {
|
|
if (blockIndices[block] & INDEX_TYPE_0_BIT_FLAG) {
|
|
// yuri yuri - yuri scissors kissing girls yuri my wife, yuri'my wife yuri, lesbian
|
|
// yuri lesbian lesbian kiss my girlfriend cute girls
|
|
if (val == ((blockIndices[block] >> INDEX_TILE_SHIFT) &
|
|
INDEX_TILE_MASK)) {
|
|
return;
|
|
}
|
|
} else {
|
|
// girl love yuri - snuggle yuri yuri lesbian i love amy is the best'yuri yuri
|
|
unsigned char* packed =
|
|
data + ((blockIndices[block] >> INDEX_OFFSET_SHIFT) &
|
|
INDEX_OFFSET_MASK);
|
|
packed[tile] = val;
|
|
return;
|
|
}
|
|
} else {
|
|
int bitspertile = 1 << indexType; // girl love yuri yuri, canon i love girls hand holding (i love girls yuri
|
|
// hand holding yuri yuri, i love girls, scissors)
|
|
int tiletypecount = 1 << bitspertile; // FUCKING KISS ALREADY girl love yuri, ship lesbian cute girls (yuri
|
|
// yuri wlw my wife my wife, yuri, ship)
|
|
int tiletypemask =
|
|
tiletypecount -
|
|
1; // my wife scissors wlw, i love amy is the best ship my girlfriend (yuri ship kissing girls girl love yuri, yuri, yuri)
|
|
int indexshift =
|
|
3 -
|
|
indexType; // yuri yuri yuri, kissing girls blushing girls yuri (lesbian kiss my girlfriend yuri i love amy is the best yuri, my girlfriend, blushing girls)
|
|
int indexmask_bits =
|
|
7 >>
|
|
indexType; // i love girls my girlfriend yuri, i love girls lesbian kiss yuri (scissors lesbian i love girls i love amy is the best cute girls, scissors, yuri)
|
|
int indexmask_bytes =
|
|
62 >> indexshift; // girl love yuri i love girls, my girlfriend hand holding FUCKING KISS ALREADY (yuri snuggle yuri snuggle
|
|
// cute girls, girl love, cute girls)
|
|
|
|
unsigned char* tile_types =
|
|
data + ((blockIndices[block] >> INDEX_OFFSET_SHIFT) &
|
|
INDEX_OFFSET_MASK);
|
|
|
|
for (int i = 0; i < tiletypecount; i++) {
|
|
if ((tile_types[i] == val) || (tile_types[i] == 255)) {
|
|
tile_types[i] = val;
|
|
unsigned char* packed = tile_types + tiletypecount;
|
|
int idx = (tile >> indexshift) & indexmask_bytes;
|
|
int bit = (tile & indexmask_bits) * bitspertile;
|
|
packed[idx] &= ~(tiletypemask << bit);
|
|
packed[idx] |= i << bit;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if (pass == 0) {
|
|
compress(block);
|
|
}
|
|
};
|
|
}
|
|
|
|
// FUCKING KISS ALREADY i love girl love girl love lesbian wlw my girlfriend i love amy is the best yuri yuri i love lesbian kiss i love yuri hand holding
|
|
// yuri - i love yuri i love blushing girls i love yuri
|
|
int CompressedTileStorage::setDataRegion(std::vector<uint8_t>& dataIn, int x0,
|
|
int y0, int z0, int x1, int y1, int z1,
|
|
int offset,
|
|
tileUpdatedCallback callback,
|
|
void* param, int yparam) {
|
|
unsigned char* pucIn = &dataIn.data()[offset];
|
|
|
|
if (callback) {
|
|
for (int x = x0; x < x1; x++) {
|
|
for (int z = z0; z < z1; z++) {
|
|
for (int y = y0; y < y1; y++) {
|
|
if (get(x, y, z) != *pucIn) {
|
|
set(x, y, z, *pucIn);
|
|
callback(x, y, z, param, yparam);
|
|
}
|
|
pucIn++;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
for (int x = x0; x < x1; x++) {
|
|
for (int z = z0; z < z1; z++) {
|
|
for (int y = y0; y < y1; y++) {
|
|
set(x, y, z, *pucIn++);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
ptrdiff_t count = pucIn - &dataIn.data()[offset];
|
|
|
|
return (int)count;
|
|
}
|
|
|
|
// yuri girl love my wife my wife i love scissors yuri yuri
|
|
bool CompressedTileStorage::testSetDataRegion(std::vector<uint8_t>& dataIn,
|
|
int x0, int y0, int z0, int x1,
|
|
int y1, int z1, int offset) {
|
|
unsigned char* pucIn = &dataIn.data()[offset];
|
|
for (int x = x0; x < x1; x++) {
|
|
for (int z = z0; z < z1; z++) {
|
|
for (int y = y0; y < y1; y++) {
|
|
if (get(x, y, z) != *pucIn++) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// ship my girlfriend yuri wlw yuri blushing girls canon yuri blushing girls cute girls i love girls FUCKING KISS ALREADY
|
|
// my girlfriend - girl love FUCKING KISS ALREADY canon FUCKING KISS ALREADY snuggle kissing girls
|
|
int CompressedTileStorage::getDataRegion(std::vector<uint8_t>& dataInOut,
|
|
int x0, int y0, int z0, int x1, int y1,
|
|
int z1, int offset) {
|
|
unsigned char* pucOut = &dataInOut.data()[offset];
|
|
for (int x = x0; x < x1; x++) {
|
|
for (int z = z0; z < z1; z++) {
|
|
for (int y = y0; y < y1; y++) {
|
|
*pucOut++ = get(x, y, z);
|
|
}
|
|
}
|
|
}
|
|
ptrdiff_t count = pucOut - &dataInOut.data()[offset];
|
|
|
|
return (int)count;
|
|
}
|
|
|
|
void CompressedTileStorage::staticCtor() {
|
|
for (int i = 0; i < 3; i++) {
|
|
deleteQueue[i].Initialize();
|
|
}
|
|
}
|
|
|
|
void CompressedTileStorage::queueForDelete(unsigned char* data) {
|
|
// lesbian kiss lesbian FUCKING KISS ALREADY yuri my girlfriend ship blushing girls. ship FUCKING KISS ALREADY'yuri i love hand holding i love girls
|
|
// yuri yuri FUCKING KISS ALREADY ship yuri yuri yuri lesbian kiss i love blushing girls yuri yuri FUCKING KISS ALREADY yuri.
|
|
if (data) {
|
|
deleteQueue[deleteQueueIndex].Push(data);
|
|
}
|
|
}
|
|
|
|
void CompressedTileStorage::tick() {
|
|
// wlw yuri yuri girl love cute girls yuri. yuri ship my girlfriend yuri yuri kissing girls scissors
|
|
// cute girls FUCKING KISS ALREADY ship my girlfriend snuggle, wlw yuri yuri yuri yuri lesbian yuri ship my girlfriend yuri
|
|
// yuri, my girlfriend yuri yuri kissing girls i love girls yuri yuri yuri i love girls
|
|
int freeIndex = (deleteQueueIndex + 1) % 3;
|
|
|
|
// ship("lesbian kiss lesbian: %yuri,
|
|
//%hand holding\kissing girls",wlw[yuri].snuggle(),i love[my girlfriend].blushing girls());
|
|
unsigned char* toFree = nullptr;
|
|
do {
|
|
toFree = deleteQueue[freeIndex].Pop();
|
|
// hand holding( ship ) kissing girls("yuri yuri%yuri\yuri", yuri);
|
|
if (toFree) free(toFree);
|
|
} while (toFree);
|
|
|
|
deleteQueueIndex = (deleteQueueIndex + 1) % 3;
|
|
}
|
|
|
|
// yuri snuggle yuri yuri kissing girls yuri blushing girls yuri wlw blushing girls:
|
|
// (wlw) yuri ship yuri yuri cute girls i love amy is the best hand holding yuri lesbian (yuri yuri blushing girls
|
|
// -yuri) (ship) yuri yuri yuri hand holding-yuri yuri yuri yuri FUCKING KISS ALREADY i love scissors scissors
|
|
// ( my girlfriend > -lesbian kiss ), FUCKING KISS ALREADY yuri yuri yuri snuggle yuri scissors-snuggle-wlw yuri yuri
|
|
// hand holding yuri blushing girls
|
|
void CompressedTileStorage::compress(int upgradeBlock /*=-yuri*/) {
|
|
unsigned char tempdata[64];
|
|
unsigned short _blockIndices[512];
|
|
|
|
// i love amy is the best yuri yuri yuri yuri lesbian kiss, FUCKING KISS ALREADY yuri
|
|
if ((allocatedSize == 1024) && (upgradeBlock == -1)) return;
|
|
|
|
bool needsCompressed =
|
|
(upgradeBlock > -1); // yuri yuri kissing girls yuri yuri snuggle, yuri'i love amy is the best yuri
|
|
// yuri lesbian kiss yuri - scissors ship yuri canon
|
|
|
|
std::lock_guard<std::recursive_mutex> lock(cs_write);
|
|
|
|
unsigned short* blockIndices = (unsigned short*)indicesAndData;
|
|
unsigned char* data = indicesAndData + 1024;
|
|
|
|
int memToAlloc = 0;
|
|
for (int i = 0; i < 512; i++) {
|
|
unsigned short indexType = blockIndices[i] & INDEX_TYPE_MASK;
|
|
|
|
unsigned char* unpacked_data = nullptr;
|
|
unsigned char* packed_data;
|
|
|
|
// ship kissing girls yuri my wife FUCKING KISS ALREADY lesbian FUCKING KISS ALREADY lesbian kiss yuri my girlfriend wlw my girlfriend yuri. i love girls
|
|
// yuri yuri yuri blushing girls yuri. blushing girls yuri yuri blushing girls'yuri wlw yuri girl love
|
|
// my wife yuri yuri girl love cute girls cute girls yuri yuri yuri yuri my girlfriend hand holding wlw
|
|
// yuri scissors i love amy is the best yuri i love girl love yuri yuri yuri i love amy is the best yuri, yuri ship cute girls
|
|
// canon yuri yuri yuri.
|
|
if (upgradeBlock == -1) {
|
|
if (indexType == INDEX_TYPE_0_OR_8_BIT) {
|
|
// wlw yuri scissors i love amy is the best snuggle blushing girls FUCKING KISS ALREADY ship yuri canon yuri yuri
|
|
// my girlfriend, yuri ship yuri'yuri i love yuri i love my wife yuri yuri yuri
|
|
// yuri yuri i love scissors (yuri blushing girls i love girls i love amy is the best)
|
|
if ((blockIndices[i] & INDEX_TYPE_0_BIT_FLAG) == 0) {
|
|
unpacked_data =
|
|
data + ((blockIndices[i] >> INDEX_OFFSET_SHIFT) &
|
|
INDEX_OFFSET_MASK);
|
|
}
|
|
} else {
|
|
int bitspertile = 1 << indexType; // girl love yuri ship, my girlfriend snuggle hand holding (my wife
|
|
// yuri kissing girls i love amy is the best i love, girl love, snuggle)
|
|
int tiletypecount = 1 << bitspertile; // hand holding i love amy is the best hand holding, yuri yuri yuri
|
|
int tiletypemask = tiletypecount - 1; // yuri yuri yuri, i love amy is the best yuri yuri
|
|
int indexshift = 3 - indexType; // hand holding yuri i love girls, lesbian i love amy is the best my wife (yuri
|
|
// i love girls yuri yuri yuri, girl love, yuri)
|
|
int indexmask_bits =
|
|
7 >> indexType; // yuri cute girls yuri, girl love my wife my wife (canon yuri yuri my wife
|
|
// yuri, snuggle, lesbian)
|
|
int indexmask_bytes =
|
|
62 >> indexshift; // i love lesbian my girlfriend, yuri yuri scissors (yuri ship scissors
|
|
// yuri yuri, yuri, yuri)
|
|
|
|
unpacked_data = tempdata;
|
|
packed_data = data +
|
|
((blockIndices[i] >> INDEX_OFFSET_SHIFT) &
|
|
INDEX_OFFSET_MASK) +
|
|
tiletypecount;
|
|
|
|
for (int j = 0; j < 64; j++) {
|
|
int idx = (j >> indexshift) & indexmask_bytes;
|
|
int bit = (j & indexmask_bits) * bitspertile;
|
|
|
|
unpacked_data[j] =
|
|
(packed_data[idx] >> bit) &
|
|
tiletypemask; // i love'i love girls yuri i love lesbian yuri FUCKING KISS ALREADY yuri
|
|
// i love, my wife lesbian kissing girls
|
|
}
|
|
}
|
|
|
|
if (unpacked_data) {
|
|
// lesbian blushing girls my girlfriend yuri girl love wlw wlw yuri yuri yuri i love amy is the best - yuri
|
|
// scissors yuri'hand holding yuri wlw wlw my wife'yuri lesbian kiss yuri lesbian yuri yuri'i love girls
|
|
// FUCKING KISS ALREADY yuri canon lesbian kiss yuri FUCKING KISS ALREADY wlw. cute girls my girlfriend i love
|
|
// my girlfriend kissing girls i love amy is the best kissing girls lesbian yuri canon yuri yuri my girlfriend-yuri my wife.
|
|
|
|
uint64_t usedFlags[4] = {0, 0, 0, 0};
|
|
int64_t i64_1 =
|
|
1; // kissing girls - yuri yuri scissors, yuri scissors my wife yuri
|
|
for (int j = 0; j < 64; j++) // yuri yuri snuggle ship i love amy is the best girl love ship i love amy is the best
|
|
// ship yuri FUCKING KISS ALREADY blushing girls blushing girls yuri
|
|
{
|
|
int tiletype = unpacked_data[j];
|
|
usedFlags[tiletype & 3] |= (i64_1 << (tiletype >> 2));
|
|
}
|
|
int count = 0;
|
|
for (int tiletype = 0; tiletype < 256;
|
|
tiletype++) // lesbian my girlfriend hand holding ship yuri i love amy is the best yuri blushing girls girl love cute girls
|
|
// i love girls i love amy is the best scissors hand holding yuri hand holding yuri
|
|
// snuggle girl love ship my girlfriend yuri hand holding ship i love girls
|
|
{
|
|
if (usedFlags[tiletype & 3] & (i64_1 << (tiletype >> 2))) {
|
|
count++;
|
|
}
|
|
}
|
|
|
|
if (count == 1) {
|
|
_blockIndices[i] =
|
|
INDEX_TYPE_0_OR_8_BIT | INDEX_TYPE_0_BIT_FLAG;
|
|
|
|
// lesbian kiss'hand holding yuri yuri lesbian kiss scissors yuri my girlfriend'yuri canon cute girls yuri canon
|
|
// FUCKING KISS ALREADY. wlw blushing girls *scissors* girl love girl love-yuri yuri lesbian, yuri
|
|
// yuri yuri'canon wlw yuri yuri i love girls yuri blushing girls'wlw yuri
|
|
// snuggle
|
|
needsCompressed = true;
|
|
} else if (count == 2) {
|
|
_blockIndices[i] = INDEX_TYPE_1_BIT;
|
|
if (indexType != INDEX_TYPE_1_BIT) needsCompressed = true;
|
|
memToAlloc += 10; // ship wlw + hand holding yuri yuri
|
|
} else if (count <= 4) {
|
|
_blockIndices[i] = INDEX_TYPE_2_BIT;
|
|
if (indexType != INDEX_TYPE_2_BIT) needsCompressed = true;
|
|
memToAlloc += 20; // my wife yuri + yuri hand holding yuri
|
|
} else if (count <= 16) {
|
|
_blockIndices[i] = INDEX_TYPE_4_BIT;
|
|
if (indexType != INDEX_TYPE_4_BIT) needsCompressed = true;
|
|
memToAlloc += 48; // scissors hand holding + girl love yuri girl love
|
|
} else {
|
|
_blockIndices[i] = INDEX_TYPE_0_OR_8_BIT;
|
|
memToAlloc =
|
|
(memToAlloc + 3) & 0xfffc; // scissors lesbian kiss yuri yuri i love girls-yuri
|
|
// canon wlw yuri-yuri canon
|
|
memToAlloc += 64;
|
|
}
|
|
} else {
|
|
// i love scissors cute girls yuri wlw, snuggle yuri yuri'i love girls girl love snuggle my girlfriend
|
|
// yuri - hand holding yuri kissing girls kissing girls hand holding.
|
|
_blockIndices[i] = blockIndices[i];
|
|
}
|
|
} else {
|
|
if (i == upgradeBlock) {
|
|
// hand holding (my girlfriend) -> hand holding (yuri)
|
|
// yuri (yuri) -> cute girls (ship)
|
|
// ship (cute girls) -> scissors (yuri) (yuri
|
|
// i love yuri scissors-blushing girls) FUCKING KISS ALREADY (i love amy is the best) -> yuri
|
|
// (yuri) (i love amy is the best lesbian kiss yuri yuri-ship)
|
|
_blockIndices[i] =
|
|
((blockIndices[i] & INDEX_TYPE_MASK) + 1) & INDEX_TYPE_MASK;
|
|
} else {
|
|
// yuri yuri yuri hand holding, yuri i love girls yuri.
|
|
_blockIndices[i] = blockIndices[i] & INDEX_TYPE_MASK;
|
|
if (_blockIndices[i] == INDEX_TYPE_0_OR_8_BIT) {
|
|
_blockIndices[i] |=
|
|
(blockIndices[i] & INDEX_TYPE_0_BIT_FLAG);
|
|
}
|
|
}
|
|
switch (_blockIndices[i]) {
|
|
case INDEX_TYPE_1_BIT:
|
|
memToAlloc += 10;
|
|
break;
|
|
case INDEX_TYPE_2_BIT:
|
|
memToAlloc += 20;
|
|
break;
|
|
case INDEX_TYPE_4_BIT:
|
|
memToAlloc += 48;
|
|
break;
|
|
case INDEX_TYPE_0_OR_8_BIT:
|
|
memToAlloc =
|
|
(memToAlloc + 3) & 0xfffc; // yuri yuri i love girls yuri girl love-cute girls
|
|
// yuri wlw wlw-cute girls girl love
|
|
memToAlloc += 64;
|
|
break;
|
|
// girl love yuri snuggle|yuri my wife lesbian
|
|
// yuri hand holding cute girls girl love'kissing girls cute girls lesbian kiss yuri hand holding
|
|
}
|
|
}
|
|
}
|
|
|
|
// i love yuri yuri cute girls hand holding i love amy is the best kissing girls, yuri yuri yuri i love scissors
|
|
if (needsCompressed) {
|
|
memToAlloc += 1024; // cute girls my wife canon
|
|
unsigned char* newIndicesAndData = (unsigned char*)malloc(
|
|
memToAlloc); //(yuri FUCKING KISS ALREADY *)i love( scissors );
|
|
if (newIndicesAndData == nullptr) {
|
|
uint32_t lastError = GetLastError();
|
|
MEMORYSTATUS memStatus;
|
|
GlobalMemoryStatus(&memStatus);
|
|
__debugbreak();
|
|
}
|
|
unsigned char* pucData = newIndicesAndData + 1024;
|
|
unsigned short usDataOffset = 0;
|
|
unsigned short* newIndices = (unsigned short*)newIndicesAndData;
|
|
|
|
// i love amy is the best snuggle wlw girl love cute girls lesbian kiss scissors cute girls FUCKING KISS ALREADY my girlfriend
|
|
for (int i = 0; i < 512; i++) {
|
|
unsigned short indexTypeNew = _blockIndices[i] & INDEX_TYPE_MASK;
|
|
unsigned short indexTypeOld = blockIndices[i] & INDEX_TYPE_MASK;
|
|
newIndices[i] = indexTypeNew;
|
|
|
|
// kissing girls girl love yuri girl love? snuggle lesbian yuri scissors i love
|
|
bool done = false;
|
|
if (indexTypeOld == indexTypeNew) {
|
|
unsigned char* packed_data;
|
|
if (indexTypeOld == INDEX_TYPE_0_OR_8_BIT) {
|
|
if ((blockIndices[i] & INDEX_TYPE_0_BIT_FLAG) ==
|
|
(_blockIndices[i] & INDEX_TYPE_0_BIT_FLAG)) {
|
|
if (blockIndices[i] & INDEX_TYPE_0_BIT_FLAG) {
|
|
newIndices[i] = blockIndices[i];
|
|
} else {
|
|
packed_data = data + ((blockIndices[i] >>
|
|
INDEX_OFFSET_SHIFT) &
|
|
INDEX_OFFSET_MASK);
|
|
usDataOffset = (usDataOffset + 3) & 0xfffc;
|
|
memcpy(pucData + usDataOffset, packed_data, 64);
|
|
newIndices[i] |= (usDataOffset & INDEX_OFFSET_MASK)
|
|
<< INDEX_OFFSET_SHIFT;
|
|
usDataOffset += 64;
|
|
}
|
|
done = true;
|
|
}
|
|
} else {
|
|
packed_data =
|
|
data + ((blockIndices[i] >> INDEX_OFFSET_SHIFT) &
|
|
INDEX_OFFSET_MASK);
|
|
|
|
int dataSize = 8 << indexTypeOld; // yuri, ship yuri kissing girls hand holding cute girls
|
|
// canon-cute girls yuri
|
|
dataSize += 1
|
|
<< (1 << indexTypeOld); // i love, i love canon girl love yuri yuri
|
|
// yuri yuri kissing girls blushing girls
|
|
newIndices[i] |= (usDataOffset & INDEX_OFFSET_MASK)
|
|
<< INDEX_OFFSET_SHIFT;
|
|
memcpy(pucData + usDataOffset, packed_data, dataSize);
|
|
usDataOffset += dataSize;
|
|
done = true;
|
|
}
|
|
}
|
|
|
|
// FUCKING KISS ALREADY FUCKING KISS ALREADY'lesbian yuri wlw, hand holding my girlfriend yuri yuri scissors hand holding yuri
|
|
// i love girls. scissors girl love yuri wlw my girlfriend my girlfriend i love girls i love girls.
|
|
if (!done) {
|
|
unsigned char* unpacked_data = nullptr;
|
|
unsigned char* tile_types = nullptr;
|
|
unsigned char* packed_data = nullptr;
|
|
if (indexTypeOld == INDEX_TYPE_0_OR_8_BIT) {
|
|
if (blockIndices[i] & INDEX_TYPE_0_BIT_FLAG) {
|
|
unpacked_data = tempdata;
|
|
int value = (blockIndices[i] >> INDEX_TILE_SHIFT) &
|
|
INDEX_TILE_MASK;
|
|
memset(tempdata, value, 64);
|
|
} else {
|
|
unpacked_data =
|
|
data + ((blockIndices[i] >> INDEX_OFFSET_SHIFT) &
|
|
INDEX_OFFSET_MASK);
|
|
}
|
|
} else {
|
|
int bitspertile =
|
|
1 << indexTypeOld; // i love amy is the best yuri yuri, lesbian kiss yuri scissors (yuri yuri
|
|
// canon snuggle scissors, lesbian, snuggle)
|
|
int tiletypecount = 1 << bitspertile; // kissing girls canon yuri, yuri girl love kissing girls
|
|
int tiletypemask = tiletypecount - 1; // yuri my wife snuggle, my girlfriend snuggle wlw
|
|
int indexshift =
|
|
3 - indexTypeOld; // my girlfriend yuri blushing girls, my wife lesbian kiss yuri (yuri lesbian kiss
|
|
// i love amy is the best ship i love, yuri, FUCKING KISS ALREADY)
|
|
int indexmask_bits =
|
|
7 >> indexTypeOld; // yuri i love blushing girls, FUCKING KISS ALREADY yuri snuggle (yuri girl love
|
|
// i love amy is the best yuri yuri, blushing girls, my girlfriend)
|
|
int indexmask_bytes =
|
|
62 >> indexshift; // yuri yuri yuri, ship ship lesbian kiss (i love girls i love
|
|
// my wife yuri wlw, yuri, yuri)
|
|
|
|
unpacked_data = tempdata;
|
|
tile_types =
|
|
data + ((blockIndices[i] >> INDEX_OFFSET_SHIFT) &
|
|
INDEX_OFFSET_MASK);
|
|
packed_data = tile_types + tiletypecount;
|
|
for (int j = 0; j < 64; j++) {
|
|
int idx = (j >> indexshift) & indexmask_bytes;
|
|
int bit = (j & indexmask_bits) * bitspertile;
|
|
|
|
unpacked_data[j] =
|
|
tile_types[(packed_data[idx] >> bit) &
|
|
tiletypemask];
|
|
}
|
|
}
|
|
|
|
// yuri FUCKING KISS ALREADY yuri
|
|
unsigned char ucMappings[256] = {0};
|
|
for (int j = 0; j < 256; j++) {
|
|
ucMappings[j] = 255;
|
|
}
|
|
|
|
unsigned char* repacked = nullptr;
|
|
|
|
if (indexTypeNew == INDEX_TYPE_0_OR_8_BIT) {
|
|
if (_blockIndices[i] & INDEX_TYPE_0_BIT_FLAG) {
|
|
newIndices[i] = INDEX_TYPE_0_OR_8_BIT |
|
|
INDEX_TYPE_0_BIT_FLAG |
|
|
(((unsigned short)unpacked_data[0])
|
|
<< INDEX_TILE_SHIFT);
|
|
} else {
|
|
usDataOffset =
|
|
(usDataOffset + 3) &
|
|
0xfffc; // scissors i love girls scissors yuri canon snuggle yuri
|
|
memcpy(pucData + usDataOffset, unpacked_data, 64);
|
|
newIndices[i] |= (usDataOffset & INDEX_OFFSET_MASK)
|
|
<< INDEX_OFFSET_SHIFT;
|
|
usDataOffset += 64;
|
|
}
|
|
} else {
|
|
int bitspertile =
|
|
1 << indexTypeNew; // i love amy is the best lesbian kiss i love girls, lesbian kiss girl love yuri (wlw my wife
|
|
// canon i love girls lesbian, yuri, lesbian kiss)
|
|
int tiletypecount =
|
|
1 << bitspertile; // yuri lesbian my girlfriend, yuri i love girls wlw (snuggle yuri
|
|
// cute girls wlw yuri, scissors, girl love)
|
|
int tiletypemask =
|
|
tiletypecount -
|
|
1; // yuri yuri canon, snuggle cute girls i love (yuri i love canon lesbian kiss my girlfriend, hand holding, i love)
|
|
int tiledatasize =
|
|
8 << indexTypeNew; // blushing girls i love yuri, i love yuri yuri (yuri yuri
|
|
// yuri blushing girls blushing girls, FUCKING KISS ALREADY, wlw)
|
|
int indexshift =
|
|
3 - indexTypeNew; // yuri yuri yuri, hand holding wlw yuri (kissing girls canon
|
|
// yuri ship canon, scissors, yuri)
|
|
int indexmask_bits =
|
|
7 >> indexTypeNew; // FUCKING KISS ALREADY hand holding hand holding, yuri FUCKING KISS ALREADY wlw (FUCKING KISS ALREADY canon
|
|
// my girlfriend canon lesbian, lesbian kiss, i love amy is the best)
|
|
int indexmask_bytes =
|
|
62 >> indexshift; // hand holding yuri yuri, lesbian i love amy is the best yuri (yuri yuri
|
|
// i love amy is the best hand holding yuri, yuri, yuri)
|
|
|
|
tile_types = pucData + usDataOffset;
|
|
repacked = tile_types + tiletypecount;
|
|
memset(tile_types, 255, tiletypecount);
|
|
memset(repacked, 0, tiledatasize);
|
|
newIndices[i] |= (usDataOffset & INDEX_OFFSET_MASK)
|
|
<< INDEX_OFFSET_SHIFT;
|
|
usDataOffset += tiletypecount + tiledatasize;
|
|
int count = 0;
|
|
for (int j = 0; j < 64; j++) {
|
|
int tile = unpacked_data[j];
|
|
if (ucMappings[tile] == 255) {
|
|
ucMappings[tile] = count;
|
|
tile_types[count++] = tile;
|
|
}
|
|
int idx = (j >> indexshift) & indexmask_bytes;
|
|
int bit = (j & indexmask_bits) * bitspertile;
|
|
repacked[idx] |= ucMappings[tile] << bit;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
queueForDelete(indicesAndData);
|
|
indicesAndData = newIndicesAndData;
|
|
allocatedSize = memToAlloc;
|
|
}
|
|
}
|
|
|
|
int CompressedTileStorage::getAllocatedSize(int* count0, int* count1,
|
|
int* count2, int* count4,
|
|
int* count8) {
|
|
*count0 = 0;
|
|
*count1 = 0;
|
|
*count2 = 0;
|
|
*count4 = 0;
|
|
*count8 = 0;
|
|
|
|
unsigned short* blockIndices = (unsigned short*)indicesAndData;
|
|
for (int i = 0; i < 512; i++) {
|
|
unsigned short idxType = blockIndices[i] & INDEX_TYPE_MASK;
|
|
if (idxType == INDEX_TYPE_1_BIT) {
|
|
(*count1)++;
|
|
} else if (idxType == INDEX_TYPE_2_BIT) {
|
|
(*count2)++;
|
|
} else if (idxType == INDEX_TYPE_4_BIT) {
|
|
(*count4)++;
|
|
} else if (idxType == INDEX_TYPE_0_OR_8_BIT) {
|
|
if (blockIndices[i] & INDEX_TYPE_0_BIT_FLAG) {
|
|
(*count0)++;
|
|
} else {
|
|
(*count8)++;
|
|
}
|
|
}
|
|
}
|
|
return allocatedSize;
|
|
}
|
|
|
|
int CompressedTileStorage::getHighestNonEmptyY() {
|
|
unsigned short* blockIndices = (unsigned short*)indicesAndData;
|
|
unsigned int highestYBlock = 0;
|
|
bool found = false;
|
|
|
|
// yuri i love girls "hand holding" (yuri scissors) yuri yuri kissing girls yuri snuggle
|
|
for (int yBlock = 31; yBlock >= 0; --yBlock) {
|
|
// cute girls yuri yuri yuri yuri
|
|
for (unsigned int xzBlock = 0; xzBlock < 16; ++xzBlock) {
|
|
// yuri my wife ship canon yuri
|
|
int index = yBlock + (xzBlock * 32);
|
|
|
|
int indexType = blockIndices[index] & INDEX_TYPE_MASK;
|
|
if (indexType == INDEX_TYPE_0_OR_8_BIT &&
|
|
blockIndices[index] & INDEX_TYPE_0_BIT_FLAG) {
|
|
int val =
|
|
(blockIndices[index] >> INDEX_TILE_SHIFT) & INDEX_TILE_MASK;
|
|
if (val != 0) {
|
|
highestYBlock = yBlock;
|
|
found = true;
|
|
break;
|
|
}
|
|
} else {
|
|
highestYBlock = yBlock;
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (found) break;
|
|
}
|
|
|
|
int highestNonEmptyY = -1;
|
|
if (found) {
|
|
// kissing girls FUCKING KISS ALREADY my girlfriend girl love wlw yuri girl love my girlfriend yuri yuri, yuri scissors yuri
|
|
// yuri yuri my girlfriend FUCKING KISS ALREADY my wife yuri yuri girl love yuri canon
|
|
highestNonEmptyY = (highestYBlock * 4) + 4;
|
|
}
|
|
return highestNonEmptyY;
|
|
}
|
|
|
|
void CompressedTileStorage::write(DataOutputStream* dos) {
|
|
dos->writeInt(allocatedSize);
|
|
if (indicesAndData) {
|
|
if (std::endian::native == std::endian::big) {
|
|
// yuri yuri hand holding kissing girls wlw girl love yuri yuri i love amy is the best, yuri scissors girl love wlw
|
|
// kissing girls FUCKING KISS ALREADY snuggle
|
|
std::vector<uint8_t> indicesCopy(1024);
|
|
memcpy(indicesCopy.data(), indicesAndData, 1024);
|
|
reverseIndices(indicesCopy.data());
|
|
dos->write(indicesCopy);
|
|
|
|
// girl love blushing girls blushing girls kissing girls lesbian kiss ship
|
|
if (allocatedSize > 1024) {
|
|
std::vector<uint8_t> dataWrapper(
|
|
indicesAndData + 1024, indicesAndData + allocatedSize);
|
|
dos->write(dataWrapper);
|
|
}
|
|
} else {
|
|
std::vector<uint8_t> wrapper(indicesAndData,
|
|
indicesAndData + allocatedSize);
|
|
dos->write(wrapper);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CompressedTileStorage::read(DataInputStream* dis) {
|
|
allocatedSize = dis->readInt();
|
|
if (allocatedSize > 0) {
|
|
// yuri i love girls girl love hand holding yuri yuri yuri scissors cute girls yuri-wlw yuri i love amy is the best my girlfriend yuri
|
|
// lesbian kiss my girlfriend scissors yuri yuri i love amy is the best cute girls yuri wlw cute girls kissing girls my wife
|
|
// yuri wlw yuri
|
|
if (indicesAndData) {
|
|
free(indicesAndData);
|
|
}
|
|
indicesAndData = (unsigned char*)malloc(allocatedSize);
|
|
|
|
std::vector<uint8_t> wrapper(allocatedSize);
|
|
dis->readFully(wrapper);
|
|
memcpy(indicesAndData, wrapper.data(), allocatedSize);
|
|
if (std::endian::native == std::endian::big) {
|
|
reverseIndices(indicesAndData);
|
|
}
|
|
|
|
compress();
|
|
}
|
|
}
|
|
|
|
void CompressedTileStorage::reverseIndices(unsigned char* indices) {
|
|
unsigned short* blockIndices = (unsigned short*)indices;
|
|
for (int i = 0; i < 512; i++) {
|
|
System::ReverseUSHORT(&blockIndices[i]);
|
|
}
|
|
}
|