341 lines
9.6 KiB
C++
341 lines
9.6 KiB
C++
#include "Overworld.h"
|
|
|
|
#include "Graphics/Tile.h"
|
|
|
|
namespace yaze {
|
|
namespace Application {
|
|
namespace Data {
|
|
|
|
using namespace Core;
|
|
using namespace Graphics;
|
|
|
|
Overworld::~Overworld() {
|
|
for (int i = 0; i < tiles32.size(); i++) {
|
|
free(allmapsTilesLW[i]);
|
|
free(allmapsTilesDW[i]);
|
|
free(allmapsTilesSP[i]);
|
|
}
|
|
free(allmapsTilesLW);
|
|
free(allmapsTilesDW);
|
|
free(allmapsTilesSP);
|
|
|
|
delete[] overworldMapPointer;
|
|
delete[] owactualMapPointer;
|
|
}
|
|
|
|
static TileInfo GetTilesInfo(ushort tile) {
|
|
// vhopppcc cccccccc
|
|
ushort o = 0;
|
|
ushort v = 0;
|
|
ushort h = 0;
|
|
ushort tid = (ushort)(tile & 0x3FF);
|
|
byte p = (byte)((tile >> 10) & 0x07);
|
|
|
|
o = (ushort)((tile & 0x2000) >> 13);
|
|
h = (ushort)((tile & 0x4000) >> 14);
|
|
v = (ushort)((tile & 0x8000) >> 15);
|
|
|
|
return TileInfo(tid, p, v, h, o);
|
|
}
|
|
|
|
void Overworld::Load(Utils::ROM rom) {
|
|
rom_ = rom;
|
|
for (int i = 0; i < 0x2B; i++) {
|
|
tileLeftEntrance.push_back(
|
|
rom_.ReadShort(Constants::overworldEntranceAllowedTilesLeft + (i * 2)));
|
|
tileRightEntrance.push_back(rom_.ReadShort(
|
|
Constants::overworldEntranceAllowedTilesRight + (i * 2)));
|
|
}
|
|
|
|
AssembleMap32Tiles();
|
|
AssembleMap16Tiles();
|
|
DecompressAllMapTiles();
|
|
|
|
// Map Initialization :
|
|
for (int i = 0; i < 160; i++) {
|
|
allmaps.push_back(OverworldMap(rom_, tiles16, (byte)i));
|
|
}
|
|
FetchLargeMaps();
|
|
LoadOverworldMap();
|
|
|
|
auto size = tiles16.size();
|
|
for (int i = 0; i < 160; i++) {
|
|
allmaps[i].BuildMap(mapParent, size, gameState, allmapsTilesLW,
|
|
allmapsTilesDW, allmapsTilesSP);
|
|
}
|
|
|
|
isLoaded = true;
|
|
}
|
|
|
|
ushort Overworld::GenerateTile32(int i, int k, int dimension) {
|
|
return (ushort)(rom_.GetRawData()[map32address[dimension] + k + (i)] +
|
|
(((rom_.GetRawData()[map32address[dimension] + (i) +
|
|
(k <= 1 ? 4 : 5)] >>
|
|
(k % 2 == 0 ? 4 : 0)) &
|
|
0x0F) *
|
|
256));
|
|
}
|
|
|
|
void Overworld::AssembleMap32Tiles() {
|
|
for (int i = 0; i < 0x33F0; i += 6) {
|
|
ushort tl, tr, bl, br;
|
|
for (int k = 0; k < 4; k++) {
|
|
tl = GenerateTile32(i, k, (int)Dimension::map32TilesTL);
|
|
tr = GenerateTile32(i, k, (int)Dimension::map32TilesTR);
|
|
bl = GenerateTile32(i, k, (int)Dimension::map32TilesBL);
|
|
br = GenerateTile32(i, k, (int)Dimension::map32TilesBR);
|
|
tiles32.push_back(Tile32(tl, tr, bl, br));
|
|
}
|
|
}
|
|
|
|
allmapsTilesLW = (ushort**)malloc(tiles32.size() * sizeof(ushort*));
|
|
for (int i = 0; i < tiles32.size(); i++)
|
|
allmapsTilesLW[i] = (ushort*)malloc(tiles32.size() * sizeof(ushort));
|
|
|
|
allmapsTilesDW = (ushort**)malloc(tiles32.size() * sizeof(ushort*));
|
|
for (int i = 0; i < tiles32.size(); i++)
|
|
allmapsTilesDW[i] = (ushort*)malloc(tiles32.size() * sizeof(ushort));
|
|
|
|
allmapsTilesSP = (ushort**)malloc(tiles32.size() * sizeof(ushort*));
|
|
for (int i = 0; i < tiles32.size(); i++)
|
|
allmapsTilesSP[i] = (ushort*)malloc(tiles32.size() * sizeof(ushort));
|
|
}
|
|
|
|
void Overworld::AssembleMap16Tiles() {
|
|
int tpos = Core::Constants::map16Tiles;
|
|
for (int i = 0; i < 4096; i += 1) // 3760
|
|
{
|
|
TileInfo t0 = GetTilesInfo((uintptr_t)rom_.GetRawData() + tpos);
|
|
tpos += 2;
|
|
TileInfo t1 = GetTilesInfo((uintptr_t)rom_.GetRawData() + tpos);
|
|
tpos += 2;
|
|
TileInfo t2 = GetTilesInfo((uintptr_t)rom_.GetRawData() + tpos);
|
|
tpos += 2;
|
|
TileInfo t3 = GetTilesInfo((uintptr_t)rom_.GetRawData() + tpos);
|
|
tpos += 2;
|
|
tiles16.push_back(Tile16(t0, t1, t2, t3));
|
|
}
|
|
}
|
|
|
|
void Overworld::DecompressAllMapTiles() {
|
|
int lowest = 0x0FFFFF;
|
|
int highest = 0x0F8000;
|
|
int sx = 0;
|
|
int sy = 0;
|
|
int c = 0;
|
|
for (int i = 0; i < 160; i++) {
|
|
int p1 = (rom_.GetRawData()[(Constants::compressedAllMap32PointersHigh) +
|
|
2 + (int)(3 * i)]
|
|
<< 16) +
|
|
(rom_.GetRawData()[(Constants::compressedAllMap32PointersHigh) +
|
|
1 + (int)(3 * i)]
|
|
<< 8) +
|
|
(rom_.GetRawData()[(Constants::compressedAllMap32PointersHigh +
|
|
(int)(3 * i))]);
|
|
p1 = rom_.SnesToPc(p1);
|
|
|
|
int p2 = (rom_.GetRawData()[(Constants::compressedAllMap32PointersLow) + 2 +
|
|
(int)(3 * i)]
|
|
<< 16) +
|
|
(rom_.GetRawData()[(Constants::compressedAllMap32PointersLow) + 1 +
|
|
(int)(3 * i)]
|
|
<< 8) +
|
|
(rom_.GetRawData()[(Constants::compressedAllMap32PointersLow +
|
|
(int)(3 * i))]);
|
|
p2 = rom_.SnesToPc(p2);
|
|
|
|
int ttpos = 0;
|
|
unsigned int compressedSize1 = 0;
|
|
unsigned int compressedSize2 = 0;
|
|
unsigned int compressedLength1 = 0;
|
|
unsigned int compressedLength2 = 0;
|
|
|
|
if (p1 >= highest) {
|
|
highest = p1;
|
|
}
|
|
if (p2 >= highest) {
|
|
highest = p2;
|
|
}
|
|
|
|
if (p1 <= lowest) {
|
|
if (p1 > 0x0F8000) {
|
|
lowest = p1;
|
|
}
|
|
}
|
|
if (p2 <= lowest) {
|
|
if (p2 > 0x0F8000) {
|
|
lowest = p2;
|
|
}
|
|
}
|
|
|
|
auto bytes = alttp_compressor_.DecompressOverworld(
|
|
rom_.GetRawData(), p2, 1000, &compressedSize1, &compressedLength1);
|
|
auto bytes2 = alttp_compressor_.DecompressOverworld(
|
|
rom_.GetRawData(), p1, 1000, &compressedSize2, &compressedLength2);
|
|
|
|
for (int y = 0; y < 16; y++) {
|
|
for (int x = 0; x < 16; x++) {
|
|
ushort tidD = (ushort)((bytes2[ttpos] << 8) + bytes[ttpos]);
|
|
|
|
int tpos = tidD;
|
|
if (tpos < tiles32.size()) {
|
|
if (i < 64) {
|
|
allmapsTilesLW[(x * 2) + (sx * 32)][(y * 2) + (sy * 32)] =
|
|
tiles32[tpos].tile0_;
|
|
allmapsTilesLW[(x * 2) + 1 + (sx * 32)][(y * 2) + (sy * 32)] =
|
|
tiles32[tpos].tile1_;
|
|
allmapsTilesLW[(x * 2) + (sx * 32)][(y * 2) + 1 + (sy * 32)] =
|
|
tiles32[tpos].tile2_;
|
|
allmapsTilesLW[(x * 2) + 1 + (sx * 32)][(y * 2) + 1 + (sy * 32)] =
|
|
tiles32[tpos].tile3_;
|
|
} else if (i < 128 && i >= 64) {
|
|
allmapsTilesDW[(x * 2) + (sx * 32)][(y * 2) + (sy * 32)] =
|
|
tiles32[tpos].tile0_;
|
|
allmapsTilesDW[(x * 2) + 1 + (sx * 32)][(y * 2) + (sy * 32)] =
|
|
tiles32[tpos].tile1_;
|
|
allmapsTilesDW[(x * 2) + (sx * 32)][(y * 2) + 1 + (sy * 32)] =
|
|
tiles32[tpos].tile2_;
|
|
allmapsTilesDW[(x * 2) + 1 + (sx * 32)][(y * 2) + 1 + (sy * 32)] =
|
|
tiles32[tpos].tile3_;
|
|
} else {
|
|
allmapsTilesSP[(x * 2) + (sx * 32)][(y * 2) + (sy * 32)] =
|
|
tiles32[tpos].tile0_;
|
|
allmapsTilesSP[(x * 2) + 1 + (sx * 32)][(y * 2) + (sy * 32)] =
|
|
tiles32[tpos].tile1_;
|
|
allmapsTilesSP[(x * 2) + (sx * 32)][(y * 2) + 1 + (sy * 32)] =
|
|
tiles32[tpos].tile2_;
|
|
allmapsTilesSP[(x * 2) + 1 + (sx * 32)][(y * 2) + 1 + (sy * 32)] =
|
|
tiles32[tpos].tile3_;
|
|
}
|
|
}
|
|
|
|
ttpos += 1;
|
|
}
|
|
}
|
|
|
|
sx++;
|
|
if (sx >= 8) {
|
|
sy++;
|
|
sx = 0;
|
|
}
|
|
|
|
c++;
|
|
if (c >= 64) {
|
|
sx = 0;
|
|
sy = 0;
|
|
c = 0;
|
|
}
|
|
}
|
|
|
|
std::cout << "MapPointers(lowest) : " << lowest << std::endl;
|
|
std::cout << "MapPointers(highest) : " << highest << std::endl;
|
|
}
|
|
|
|
void Overworld::FetchLargeMaps() {
|
|
for (int i = 128; i < 145; i++) {
|
|
mapParent[i] = 0;
|
|
}
|
|
|
|
mapParent[128] = 128;
|
|
mapParent[129] = 129;
|
|
mapParent[130] = 129;
|
|
mapParent[137] = 129;
|
|
mapParent[138] = 129;
|
|
mapParent[136] = 136;
|
|
allmaps[136].largeMap = false;
|
|
|
|
bool mapChecked[64];
|
|
for (int i = 0; i < 64; i++) {
|
|
mapChecked[i] = false;
|
|
}
|
|
int xx = 0;
|
|
int yy = 0;
|
|
while (true) {
|
|
int i = xx + (yy * 8);
|
|
if (mapChecked[i] == false) {
|
|
if (allmaps[i].largeMap == true) {
|
|
mapChecked[i] = true;
|
|
mapParent[i] = (byte)i;
|
|
mapParent[i + 64] = (byte)(i + 64);
|
|
|
|
mapChecked[i + 1] = true;
|
|
mapParent[i + 1] = (byte)i;
|
|
mapParent[i + 65] = (byte)(i + 64);
|
|
|
|
mapChecked[i + 8] = true;
|
|
mapParent[i + 8] = (byte)i;
|
|
mapParent[i + 72] = (byte)(i + 64);
|
|
|
|
mapChecked[i + 9] = true;
|
|
mapParent[i + 9] = (byte)i;
|
|
mapParent[i + 73] = (byte)(i + 64);
|
|
xx++;
|
|
} else {
|
|
mapParent[i] = (byte)i;
|
|
mapParent[i + 64] = (byte)(i + 64);
|
|
mapChecked[i] = true;
|
|
}
|
|
}
|
|
|
|
xx++;
|
|
if (xx >= 8) {
|
|
xx = 0;
|
|
yy += 1;
|
|
if (yy >= 8) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Overworld::LoadOverworldMap() {
|
|
overworldMapBitmap = new Bitmap(128, 128, overworldMapPointer);
|
|
overworldMapBitmap->Create(&overworldMapTexture);
|
|
owactualMapBitmap = new Bitmap(512, 512, owactualMapPointer);
|
|
owactualMapBitmap->Create(&owactualMapTexture);
|
|
|
|
// Mode 7
|
|
byte* ptr = overworldMapPointer;
|
|
|
|
int pos = 0;
|
|
for (int sy = 0; sy < 16; sy++) {
|
|
for (int sx = 0; sx < 16; sx++) {
|
|
for (int y = 0; y < 8; y++) {
|
|
for (int x = 0; x < 8; x++) {
|
|
ptr[x + (sx * 8) + (y * 128) + (sy * 1024)] =
|
|
rom_.GetRawData()[0x0C4000 + pos];
|
|
pos++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ColorPalette cp = overworldMapBitmap.Palette;
|
|
// for (int i = 0; i < 256; i += 2)
|
|
// {
|
|
// //55B27 = US LW
|
|
// //55C27 = US DW
|
|
// cp.Entries[i / 2] = getColor((short)((ROM.DATA[0x55B27 + i + 1] << 8) +
|
|
// ROM.DATA[0x55B27 + i]));
|
|
|
|
// int k = 0;
|
|
// int j = 0;
|
|
// for (int y = 10; y < 14; y++)
|
|
// {
|
|
// for (int x = 0; x < 15; x++)
|
|
// {
|
|
// cp.Entries[145 + k] = Palettes.globalSprite_Palettes[0][j];
|
|
// k++;
|
|
// j++;
|
|
// }
|
|
// k++;
|
|
// }
|
|
// }
|
|
|
|
// overworldMapBitmap.Palette = cp;
|
|
// owactualMapBitmap.Palette = cp;
|
|
}
|
|
|
|
} // namespace Data
|
|
} // namespace Application
|
|
} // namespace yaze
|