scawful/yaze
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' into rom-test-hex-nums

Browse Source
This commit is contained in:
Justin Scofield
2022-08-16 15:16:21 -04:00
committed by GitHub
parent a94e44b33d d2675ee59d
commit dba500809a
30 changed files with 265 additions and 335 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
CMakeLists.txt
View File

@@ -22,6 +22,21 @@ set(ABSL_PROPAGATE_CXX_STD ON)
set(ABSL_CXX_STANDARD 17)
set(ABSL_USE_GOOGLETEST_HEAD ON)
set(ABSL_ENABLE_INSTALL ON)
set(
ABSL_TARGETS
absl::strings
absl::flags
absl::status
absl::statusor
absl::examine_stack
absl::stacktrace
absl::base
absl::config
absl::core_headers
absl::raw_logging_internal
absl::failure_signal_handler
absl::flat_hash_map
)
# Video Libraries -------------------------------------------------------------
find_package(PNG REQUIRED)

17
docs/dev-setup-windows.md Normal file
View File

@@ -0,0 +1,17 @@
For VSCode users, use the following CMake extensions with MinGW-w64
https://marketplace.visualstudio.com/items?itemName=twxs.cmake
https://marketplace.visualstudio.com/items?itemName=ms-vscode.cmake-tools
https://www.msys2.org/
Add to environment variables `C:\msys64\mingw64\bin`
Install the following packages using `pacman -S <package-name>`
`mingw-w64-x86_64-gcc`
`mingw-w64-x86_64-gcc-libs`
`mingw-w64-x86_64-cmake`
`mingw-w64-x86_64-glew`
`mingw-w64-x86_64-lib-png`

26
src/CMakeLists.txt
View File

@@ -36,6 +36,11 @@ set(
# Asar Assembly ---------------------------------------------------------------
add_subdirectory(lib/asar/src)
set(ASAR_GEN_EXE OFF)
set(ASAR_GEN_DLL ON)
set(ASAR_GEN_LIB OFF)
set(ASAR_GEN_EXE_TEST OFF)
set(ASAR_GEN_DLL_TEST OFF)
# yaze source files -----------------------------------------------------------
set(
@@ -84,7 +89,7 @@ set(
add_executable(
yaze
yaze.cc
app/yaze.cc
app/rom.cc
${YAZE_APP_ASM_SRC}
${YAZE_APP_CORE_SRC}
@@ -108,22 +113,6 @@ target_include_directories(
lib/asar/src/asar-dll-bindings/c
)
set(
ABSL_TARGETS
absl::strings
absl::flags
absl::status
absl::statusor
absl::examine_stack
absl::stacktrace
absl::base
absl::config
absl::core_headers
absl::raw_logging_internal
absl::failure_signal_handler
absl::flat_hash_map
)
set(SDL_TARGETS SDL2::SDL2)
if(WIN32 OR MINGW)
@@ -137,7 +126,8 @@ target_link_libraries(
${SDL_TARGETS}
${PNG_LIBRARIES}
${GLEW_LIBRARIES}
${OPENGL_LIBRARIES}
${OPENGL_LIBRARIES}
${CMAKE_DL_LIBS}
ImGui
)

23
src/app/asm/script.cc
View File

@@ -12,6 +12,7 @@
#include "absl/status/statusor.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "app/core/common.h"
#include "app/core/constants.h"
#include "app/rom.h"
@@ -19,15 +20,6 @@ namespace yaze {
namespace app {
namespace snes_asm {
static auto string_replace(std::string &str, const std::string &from,
const std::string &to) -> bool {
size_t start = str.find(from);
if (start == std::string::npos) return false;
str.replace(start, from.length(), to);
return true;
}
std::string GenerateBytePool(char mosaic_tiles[core::kNumOverworldMaps]) {
std::string to_return = "";
int column = 0;
@@ -64,6 +56,10 @@ std::string GenerateBytePool(char mosaic_tiles[core::kNumOverworldMaps]) {
}
absl::Status Script::ApplyPatchToROM(ROM &rom) {
if (patch_contents_.empty() || patch_filename_.empty()) {
return absl::InvalidArgumentError("No patch loaded!");
}
char *data = (char *)rom.data();
int size = rom.GetSize();
int count = 0;
@@ -76,7 +72,8 @@ absl::Status Script::ApplyPatchToROM(ROM &rom) {
}
absl::Status Script::GenerateMosaicChangeAssembly(
ROM &rom, char mosaic_tiles[core::kNumOverworldMaps], int routine_offset) {
ROM &rom, char mosaic_tiles[core::kNumOverworldMaps], int routine_offset,
int hook_offset) {
std::fstream file("assets/asm/mosaic_change.asm",
std::ios::out | std::ios::in);
if (!file.is_open()) {
@@ -89,12 +86,13 @@ absl::Status Script::GenerateMosaicChangeAssembly(
file.close();
auto assembly_string = assembly.str();
if (!string_replace(assembly_string, "<HOOK>", kMosaicChangeOffset)) {
if (!core::StringReplace(assembly_string, "<HOOK>", kMosaicChangeOffset)) {
return absl::InternalError(
"Mosaic template did not have proper `<HOOK>` to replace.");
}
if (!string_replace(
if (!core::StringReplace(
assembly_string, "<EXPANDED_SPACE>",
absl::StrFormat("$%x", routine_offset + kSNESToPCOffset))) {
return absl::InternalError(
@@ -102,6 +100,7 @@ absl::Status Script::GenerateMosaicChangeAssembly(
}
assembly_string += GenerateBytePool(mosaic_tiles);
patch_contents_ = assembly_string;
patch_filename_ = "assets/asm/mosaic_change_generated.asm";
std::ofstream new_file(patch_filename_, std::ios::out);
if (new_file.is_open()) {

16
src/app/asm/script.h
View File

@@ -23,16 +23,24 @@ namespace snes_asm {
const std::string kMosaicChangeOffset = "$02AADB";
constexpr int kSNESToPCOffset = 0x138000;
class Script {
class ScriptTemplate {
public:
virtual absl::Status ApplyPatchToROM(ROM& rom) = 0;
virtual absl::Status GenerateMosaicChangeAssembly(
ROM& rom, char mosaic_tiles[core::kNumOverworldMaps], int routine_offset,
int hook_offset = 0) = 0;
};
class Script : public ScriptTemplate {
public:
Script() { asar_init_with_dll_path("assets/libasar.dll"); }
absl::Status ApplyPatchToROM(ROM& rom) override;
absl::Status GenerateMosaicChangeAssembly(
ROM& rom, char mosaic_tiles[core::kNumOverworldMaps], int routine_offset);
ROM& rom, char mosaic_tiles[core::kNumOverworldMaps], int routine_offset,
int hook_offset = 0) override;
private:
absl::Status ApplyPatchToROM(ROM& rom);
int64_t patch_size_;
std::string patch_filename_;
std::string patch_contents_;

12
src/app/core/common.cc
View File

@@ -1,6 +1,7 @@
#include "common.h"
#include <cstdint>
#include <string>
namespace yaze {
namespace app {
@@ -19,7 +20,7 @@ int AddressFromBytes(uint8_t addr1, uint8_t addr2, uint8_t addr3) {
}
// hextodec has been imported from SNESDisasm to parse hex numbers
int HexToDec(char* input, int length) {
int HexToDec(char *input, int length) {
int result = 0;
int value;
int ceiling = length - 1;
@@ -48,6 +49,15 @@ int HexToDec(char* input, int length) {
return result;
}
bool StringReplace(std::string &str, const std::string &from,
const std::string &to) {
size_t start = str.find(from);
if (start == std::string::npos) return false;
str.replace(start, from.length(), to);
return true;
}
} // namespace core
} // namespace app
} // namespace yaze

3
src/app/core/common.h
View File

@@ -2,6 +2,7 @@
#define YAZE_CORE_COMMON_H
#include <cstdint>
#include <string>
namespace yaze {
namespace app {
@@ -10,6 +11,8 @@ namespace core {
unsigned int SnesToPc(unsigned int addr);
int AddressFromBytes(uint8_t addr1, uint8_t addr2, uint8_t addr3);
int HexToDec(char *input, int length);
bool StringReplace(std::string &str, const std::string &from,
const std::string &to);
} // namespace core
} // namespace app

103
src/app/core/constants.h
View File

@@ -26,8 +26,8 @@
#define MENU_ITEM2(w, v) if (ImGui::MenuItem(w, v))
#define CHECK_STATUS(w) \
if (!w.ok()) { \
return w; \
if (!w.ok()) { \
return w; \
}
using ushort = unsigned short;
@@ -39,9 +39,16 @@ namespace yaze {
namespace app {
namespace core {
//===========================================================================================
// ============================================================================
// Window Variables
// ============================================================================
constexpr int kScreenWidth = 1200;
constexpr int kScreenHeight = 800;
// ============================================================================
// 65816 LanguageDefinition
//===========================================================================================
// ============================================================================
static const char *const kKeywords[] = {
"ADC", "AND", "ASL", "BCC", "BCS", "BEQ", "BIT", "BMI", "BNE",
@@ -66,9 +73,9 @@ static const char *const kIdentifiers[] = {
"srand", "strcat", "strcmp", "strerror", "time", "tolower",
"toupper"};
//===========================================================================================
// ============================================================================
// Magic numbers
//===========================================================================================
// ============================================================================
/// Bit set for object priority
constexpr ushort TilePriorityBit = 0x2000;
@@ -96,9 +103,9 @@ constexpr int NumberOfMap32 = Map32PerScreen * kNumOverworldMaps;
constexpr int NumberOfOWSprites = 352;
constexpr int NumberOfColors = 3143;
// ===========================================================================================
// gfx
// ===========================================================================================
// ============================================================================
// Game Graphics
// ============================================================================
constexpr int tile_address = 0x1B52; // JP = Same
constexpr int tile_address_floor = 0x1B5A; // JP = Same
@@ -107,8 +114,9 @@ constexpr int subtype2_tiles = 0x83F0; // JP = Same
constexpr int subtype3_tiles = 0x84F0; // JP = Same
constexpr int gfx_animated_pointer = 0x10275; // JP 0x10624 //long pointer
constexpr int overworldgfxGroups2 = 0x6073; // 0x60B3
constexpr int gfx_1_pointer =
0x6790; // 2byte pointer bank 00 pc -> 0x4320 CF80 ; 004F80
// 2 byte pointer bank 00 pc -> 0x4320
constexpr int gfx_1_pointer = 0x6790; // CF80 ; 004F80
constexpr int gfx_2_pointer = 0x6795; // D05F ; 00505F
constexpr int gfx_3_pointer = 0x679A; // D13E ; 00513E
constexpr int hud_palettes = 0xDD660;
@@ -118,9 +126,9 @@ constexpr int kTilesheetWidth = 128;
constexpr int kTilesheetHeight = 32;
constexpr int kTilesheetDepth = 8;
// ===========================================================================================
// ============================================================================
// Overworld Related Variables
// ===========================================================================================
// ============================================================================
constexpr int compressedAllMap32PointersHigh = 0x1794D;
constexpr int compressedAllMap32PointersLow = 0x17B2D;
@@ -157,7 +165,6 @@ constexpr int overlayPointersBank = 0x0E;
constexpr int overworldTilesType = 0x71459;
constexpr int overworldMessages = 0x3F51D;
// TODO:
constexpr int overworldMusicBegining = 0x14303;
constexpr int overworldMusicZelda = 0x14303 + 0x40;
constexpr int overworldMusicMasterSword = 0x14303 + 0x80;
@@ -167,10 +174,11 @@ constexpr int overworldMusicDW = 0x14403;
constexpr int overworldEntranceAllowedTilesLeft = 0xDB8C1;
constexpr int overworldEntranceAllowedTilesRight = 0xDB917;
constexpr int overworldMapSize = 0x12844; // 0x00 = small maps, 0x20 = large
// maps
constexpr int overworldMapSizeHighByte =
0x12884; // 0x01 = small maps, 0x03 = large maps
// 0x00 = small maps, 0x20 = large maps
constexpr int overworldMapSize = 0x12844;
// 0x01 = small maps, 0x03 = large maps
constexpr int overworldMapSizeHighByte = 0x12884;
// relative to the WORLD + 0x200 per map
// large map that are not == parent id = same position as their parent!
@@ -184,9 +192,9 @@ constexpr int overworldTransitionPositionX = 0x12944;
constexpr int overworldScreenSize = 0x1788D;
//===========================================================================================
// ============================================================================
// Overworld Exits/Entrances Variables
//===========================================================================================
// ============================================================================
constexpr int OWExitRoomId = 0x15D8A; // 0x15E07 Credits sequences
// 105C2 Ending maps
// 105E2 Sprite Group Table for Ending
@@ -226,9 +234,10 @@ constexpr int OWExitUnk1Whirlpool = 0x16BF5; // JP = ;016E91
constexpr int OWExitUnk2Whirlpool = 0x16C17; // JP = ;016EB3
constexpr int OWWhirlpoolPosition = 0x16CF8; // JP = ;016F94
//===========================================================================================
// ============================================================================
// Dungeon Related Variables
//===========================================================================================
// ============================================================================
// That could be turned into a pointer :
constexpr int dungeons_palettes_groups = 0x75460; // JP 0x67DD0
constexpr int dungeons_main_bg_palette_pointers = 0xDEC4B; // JP Same
@@ -275,7 +284,6 @@ constexpr int doorPointers = 0xF83C0;
// doors
constexpr int door_gfx_up = 0x4D9E;
//
constexpr int door_gfx_down = 0x4E06;
constexpr int door_gfx_cavexit_down = 0x4E06;
constexpr int door_gfx_left = 0x4E66;
@@ -293,14 +301,17 @@ constexpr int text_data2 = 0x75F40;
constexpr int pointers_dictionaries = 0x74703;
constexpr int characters_width = 0x74ADF;
//===========================================================================================
// ============================================================================
// Dungeon Entrances Related Variables
//===========================================================================================
constexpr int entrance_room = 0x14813; // 0x14577 //word value for each room
// ============================================================================
// 0x14577 word value for each room
constexpr int entrance_room = 0x14813;
// 8 bytes per room, HU, FU, HD, FD, HL, FL, HR, FR
constexpr int entrance_scrolledge = 0x1491D; // 0x14681
constexpr int entrance_yscroll = 0x14D45; // 0x14AA9 //2bytes each room
constexpr int entrance_xscroll = 0x14E4F; // 0x14BB3 //2bytes
constexpr int entrance_yscroll = 0x14D45; // 0x14AA9 2 bytes each room
constexpr int entrance_xscroll = 0x14E4F; // 0x14BB3 2 bytes
constexpr int entrance_yposition = 0x14F59; // 0x14CBD 2bytes
constexpr int entrance_xposition = 0x15063; // 0x14DC7 2bytes
constexpr int entrance_camerayposition = 0x1516D; // 0x14ED1 2bytes
@@ -311,15 +322,17 @@ constexpr int entrance_blockset = 0x15381; // 0x150E5 1byte
constexpr int entrance_floor = 0x15406; // 0x1516A 1byte
constexpr int entrance_dungeon = 0x1548B; // 0x151EF 1byte (dungeon id)
constexpr int entrance_door = 0x15510; // 0x15274 1byte
// 1 byte, ---b ---a b = bg2, a = need to check -_-
// 1 byte, ---b ---a b = bg2, a = need to check
constexpr int entrance_ladderbg = 0x15595; // 0x152F9
constexpr int entrance_scrolling = 0x1561A; // 0x1537E //1byte --h- --v-
constexpr int entrance_scrolling = 0x1561A; // 0x1537E 1byte --h- --v-
constexpr int entrance_scrollquadrant = 0x1569F; // 0x15403 1byte
constexpr int entrance_exit = 0x15724; // 0x15488 //2byte word
constexpr int entrance_exit = 0x15724; // 0x15488 2byte word
constexpr int entrance_music = 0x1582E; // 0x15592
// word value for each room
constexpr int startingentrance_room = 0x15B6E; // 0x158D2
// 8 bytes per room, HU, FU, HD, FD, HL, FL, HR, FR
constexpr int startingentrance_scrolledge = 0x15B7C; // 0x158E0
constexpr int startingentrance_yscroll = 0x15BB4; // 0x14AA9 //2bytes each room
@@ -335,7 +348,7 @@ constexpr int startingentrance_dungeon = 0x15C16; // 0x151EF 1byte (dungeon id)
constexpr int startingentrance_door = 0x15C2B; // 0x15274 1byte
// 1 byte, ---b ---a b = bg2, a = need to check -_-
// 1 byte, ---b ---a b = bg2, a = need to check
constexpr int startingentrance_ladderbg = 0x15C1D; // 0x152F9
// 1byte --h- --v-
constexpr int startingentrance_scrolling = 0x15C24; // 0x1537E
@@ -365,24 +378,23 @@ constexpr int dungeons_endrooms = 0x792D;
constexpr int dungeons_bossrooms = 0x10954; // short value
// Bed Related Values (Starting location)
constexpr int bedPositionX = 0x039A37; // short value
constexpr int bedPositionY = 0x039A32; // short value
// short value (on 2 different bytes)
constexpr int bedPositionResetXLow = 0x02DE53;
constexpr int bedPositionResetXHigh = 0x02DE58; //^^^^^^
constexpr int bedPositionResetXHigh = 0x02DE58;
// short value (on 2 different bytes)
constexpr int bedPositionResetYLow = 0x02DE5D;
constexpr int bedPositionResetYHigh = 0x02DE62; //^^^^^^
constexpr int bedPositionResetYHigh = 0x02DE62;
constexpr int bedSheetPositionX = 0x0480BD; // short value
constexpr int bedSheetPositionY = 0x0480B8; // short value
//===========================================================================================
// ============================================================================
// Gravestones related variables
//===========================================================================================
// ============================================================================
constexpr int GravesYTilePos = 0x49968; // short (0x0F entries)
constexpr int GravesXTilePos = 0x49986; // short (0x0F entries)
@@ -396,9 +408,9 @@ constexpr int GravesCountOnY = 0x499E0; // Byte 0x09 entries
constexpr int GraveLinkSpecialHole = 0x46DD9; // short
constexpr int GraveLinkSpecialStairs = 0x46DE0; // short
//===========================================================================================
// ============================================================================
// Palettes Related Variables - This contain all the palettes of the game
//===========================================================================================
// ============================================================================
constexpr int overworldPaletteMain = 0xDE6C8;
constexpr int overworldPaletteAuxialiary = 0xDE86C;
constexpr int overworldPaletteAnimated = 0xDE604;
@@ -420,19 +432,23 @@ constexpr int hardcodedGrassLW = 0x5FEA9;
constexpr int hardcodedGrassDW = 0x05FEB3; // 0x7564F
constexpr int hardcodedGrassSpecial = 0x75640;
//===========================================================================================
// ============================================================================
// Dungeon Map Related Variables
//===========================================================================================
// ============================================================================
constexpr int dungeonMap_rooms_ptr = 0x57605; // 14 pointers of map data
constexpr int dungeonMap_floors = 0x575D9; // 14 words values
constexpr int dungeonMap_gfx_ptr = 0x57BE4; // 14 pointers of gfx data
// data start for floors/gfx MUST skip 575D9 to 57621 (pointers)
constexpr int dungeonMap_datastart = 0x57039;
// IF Byte = 0xB9 dungeon maps are not expanded
constexpr int dungeonMap_expCheck = 0x56652;
constexpr int dungeonMap_tile16 = 0x57009;
constexpr int dungeonMap_tile16Exp = 0x109010;
// 14 words values 0x000F = no boss
constexpr int dungeonMap_bossrooms = 0x56807;
constexpr int triforceVertices = 0x04FFD2; // group of 3, X, Y ,Z
@@ -440,9 +456,10 @@ constexpr int TriforceFaces = 0x04FFE4; // group of 5
constexpr int crystalVertices = 0x04FF98;
//===========================================================================================
// ============================================================================
// Names
//===========================================================================================
// ============================================================================
static const absl::string_view RoomEffect[] = {"Nothing",
"Nothing",
"Moving Floor",

6
src/app/core/controller.cc
View File

@@ -154,9 +154,9 @@ absl::Status Controller::CreateWindow() {
SDL_CreateWindow("Yet Another Zelda3 Editor", // window title
SDL_WINDOWPOS_UNDEFINED, // initial x position
SDL_WINDOWPOS_UNDEFINED, // initial y position
1200, // width, in pixels
800, // height, in pixels
SDL_WINDOW_RESIZABLE | SDL_WINDOW_OPENGL),
kScreenWidth, // width, in pixels
kScreenHeight, // height, in pixels
SDL_WINDOW_RESIZABLE),
sdl_deleter());
if (window_ == nullptr) {
return absl::InternalError(

5
src/app/editor/dungeon_editor.cc
View File

@@ -8,7 +8,10 @@ namespace editor {
void DungeonEditor::Update() {
DrawToolset();
canvas_.Update();
canvas_.DrawBackground();
canvas_.UpdateContext();
canvas_.DrawGrid();
canvas_.DrawOverlay();
}
void DungeonEditor::DrawToolset() {

10
src/app/editor/master_editor.cc
View File

@@ -188,12 +188,12 @@ void MasterEditor::DrawFileMenu() const {
void MasterEditor::DrawEditMenu() {
if (ImGui::BeginMenu("Edit")) {
MENU_ITEM2("Undo", "Ctrl+Z") {}
MENU_ITEM2("Redo", "Ctrl+Y") {}
MENU_ITEM2("Undo", "Ctrl+Z") { status_ = overworld_editor_.Undo(); }
MENU_ITEM2("Redo", "Ctrl+Y") { status_ = overworld_editor_.Redo(); }
ImGui::Separator();
MENU_ITEM2("Cut", "Ctrl+X") {}
MENU_ITEM2("Copy", "Ctrl+C") {}
MENU_ITEM2("Paste", "Ctrl+V") {}
MENU_ITEM2("Cut", "Ctrl+X") { status_ = overworld_editor_.Cut(); }
MENU_ITEM2("Copy", "Ctrl+C") { status_ = overworld_editor_.Copy(); }
MENU_ITEM2("Paste", "Ctrl+V") { status_ = overworld_editor_.Paste(); }
ImGui::Separator();
MENU_ITEM2("Find", "Ctrl+F") {}
ImGui::Separator();

5
src/app/editor/overworld_editor.h
View File

@@ -41,8 +41,11 @@ class OverworldEditor {
public:
void SetupROM(ROM &rom);
absl::Status Update();
absl::Status Undo() { return absl::UnimplementedError("Undo"); }
absl::Status Redo() { return absl::UnimplementedError("Redo"); }
absl::Status Cut() { return absl::UnimplementedError("Cut"); }
absl::Status Copy() { return absl::UnimplementedError("Copy"); }
absl::Status Paste() { return absl::UnimplementedError("Paste"); }
private:
absl::Status DrawToolset();

1
src/app/editor/palette_editor.cc
View File

@@ -14,7 +14,6 @@ namespace editor {
absl::Status PaletteEditor::Update() {
for (const auto &name : kPaletteCategoryNames) {
if (ImGui::TreeNode(name.data())) {
ImGui::SameLine();
if (ImGui::SmallButton("button")) {
}

2
src/app/editor/screen_editor.h
View File

@@ -23,8 +23,8 @@ static int overworldCustomMosaicArray = 0x1301F0;
class ScreenEditor {
public:
void SetupROM(ROM &rom) { rom_ = rom; }
ScreenEditor();
void SetupROM(ROM &rom) { rom_ = rom; }
void Update();
private:

6
src/app/rom.cc
View File

@@ -576,6 +576,7 @@ absl::Status ROM::LoadFromFile(const absl::string_view& filename) {
return absl::InternalError(
absl::StrCat("Could not open ROM file: ", filename));
}
size_ = std::filesystem::file_size(filename);
rom_data_.resize(size_);
for (auto i = 0; i < size_; ++i) {
@@ -583,9 +584,12 @@ absl::Status ROM::LoadFromFile(const absl::string_view& filename) {
file.read(&byte_to_read, sizeof(char));
rom_data_[i] = byte_to_read;
}
// copy ROM title
memcpy(title, rom_data_.data() + kTitleStringOffset, kTitleStringLength);
file.close();
is_loaded_ = true;
memcpy(title, rom_data_.data() + 32704, 20); // copy ROM title
return absl::OkStatus();
}

4
src/app/rom.h
View File

@@ -36,6 +36,8 @@ constexpr int kMaxLengthCompression = 1024;
constexpr int kNintendoMode1 = 0;
constexpr int kNintendoMode2 = 1;
constexpr int kTile32Num = 4432;
constexpr int kTitleStringOffset = 0x7FC0;
constexpr int kTitleStringLength = 20;
constexpr uchar kGraphicsBitmap[8] = {0x80, 0x40, 0x20, 0x10,
0x08, 0x04, 0x02, 0x01};
@@ -114,9 +116,9 @@ class ROM {
private:
long size_ = 0;
std::string filename_;
uchar title[21] = "ROM Not Loaded";
bool is_loaded_ = false;
std::string filename_;
Bytes rom_data_;
std::shared_ptr<SDL_Renderer> renderer_;

4
src/yaze.cc → src/app/yaze.cc
View File

@@ -1,4 +1,6 @@
#include "yaze.h"
#if defined(_WIN32)
#define main SDL_main
#endif
#include "absl/debugging/failure_signal_handler.h"
#include "absl/debugging/symbolize.h"

2
src/app/zelda3/overworld.cc
View File

@@ -26,7 +26,7 @@ absl::Status Overworld::Load(ROM &rom, uchar *ow_blockset) {
auto size = tiles16.size();
for (int i = 0; i < core::kNumOverworldMaps; ++i) {
auto map_status =
overworld_maps_[i].BuildMapV2(size, game_state_, map_parent_);
overworld_maps_[i].BuildMap(size, game_state_, map_parent_);
if (!map_status.ok()) {
return map_status;
}

133
src/app/zelda3/overworld_map.cc
View File

@@ -102,56 +102,8 @@ void OverworldMap::LoadAreaInfo() {
}
}
void OverworldMap::BuildMap(int count, int game_state, uchar* map_parent,
uchar* ow_blockset, OWMapTiles& map_tiles) {
if (large_map_) {
parent_ = map_parent[index_];
if (parent_ != index_ && !initialized_) {
if (index_ >= 0x80 && index_ <= 0x8A && index_ != 0x88) {
area_graphics_ =
rom_[core::overworldSpecialGFXGroup + (parent_ - 0x80)];
area_palette_ = rom_[core::overworldSpecialPALGroup + 1];
} else if (index_ == 0x88) {
area_graphics_ = 81;
area_palette_ = 0;
} else {
area_graphics_ = rom_[core::mapGfx + parent_];
area_palette_ = rom_[core::overworldMapPalette + parent_];
}
initialized_ = true;
}
}
if (!BuildTileset(game_state).ok()) {
std::cout << "BuildTileset failed" << std::endl;
}
BuildTiles16Gfx(count, ow_blockset); // build on GFX.mapgfx16Ptr
// int world = 0;
// if (index_ < 64) {
// map_tiles_ = map_tiles.light_world;
// } else if (index_ < 0x80 && index_ >= 0x40) {
// map_tiles_ = map_tiles.dark_world;
// world = 1;
// } else {
// map_tiles_ = map_tiles.special_world;
// world = 2;
// }
// int superY = ((index_ - (world * 64)) / 8);
// int superX = index_ - (world * 64) - (superY * 8);
// for (int y = 0; y < 32; y++) {
// for (int x = 0; x < 32; x++) {
// auto xt = x + (superX * 32);
// auto yt = y + (superY * 32);
// CopyTile8bpp16((x * 16), (y * 16), map_tiles_[xt][yt], ow_blockset);
// }
// }
}
absl::Status OverworldMap::BuildMapV2(int count, int game_state,
uchar* map_parent) {
absl::Status OverworldMap::BuildMap(int count, int game_state,
uchar* map_parent) {
if (large_map_) {
parent_ = map_parent[index_];
if (parent_ != index_ && !initialized_) {
@@ -176,12 +128,25 @@ absl::Status OverworldMap::BuildMapV2(int count, int game_state,
return tileset_status;
}
// int world = 0;
// if (index_ < 64) {
// world_ = 0;
// map_tiles_ = map_tiles.light_world;
// } else if (index_ < 0x80 && index_ >= 0x40) {
// world_ = 1;
// map_tiles_ = map_tiles.dark_world;
// world = 1;
// } else {
// world_ = 2;
// map_tiles_ = map_tiles.special_world;
// world = 2;
// }
// int superY = ((index_ - (world * 64)) / 8);
// int superX = index_ - (world * 64) - (superY * 8);
// for (int y = 0; y < 32; y++) {
// for (int x = 0; x < 32; x++) {
// auto xt = x + (superX * 32);
// auto yt = y + (superY * 32);
// CopyTile8bpp16((x * 16), (y * 16), map_tiles_[xt][yt], ow_blockset);
// }
// }
return absl::OkStatus();
@@ -248,40 +213,7 @@ absl::Status OverworldMap::BuildTileset(int game_state) {
return absl::OkStatus();
}
void OverworldMap::BuildTiles16Gfx(int count, uchar* ow_blockset) {
auto gfx_tile16_data = ow_blockset;
auto gfx_tile8_data = nullptr; // rom_.GetMasterGraphicsBin();
int offsets[] = {0, 8, 1024, 1032};
auto yy = 0;
auto xx = 0;
// number of tiles16 3748?
for (auto i = 0; i < count; i++) {
// 8x8 tile draw
// gfx8 = 4bpp so everyting is /2F
auto tiles = tiles16_[i];
for (auto tile = 0; tile < 4; tile++) {
gfx::TileInfo info = tiles16_[i].tiles_info[tile];
int offset = offsets[tile];
for (auto y = 0; y < 8; y++) {
for (auto x = 0; x < 4; x++) {
CopyTile(x, y, xx, yy, offset, info, gfx_tile16_data, gfx_tile8_data);
}
}
}
xx += 16;
if (xx >= 0x80) {
yy += 2048;
xx = 0;
}
}
}
absl::Status OverworldMap::BuildTiles16GfxV2(int count) {
absl::Status OverworldMap::BuildTiles16Gfx(int count) {
auto gfx_tile8_data = nullptr; // rom_.GetMasterGraphicsBin();
int offsets[] = {0, 8, 1024, 1032};
@@ -356,33 +288,6 @@ void OverworldMap::CopyTile8bpp16(int x, int y, int tile, uchar* ow_blockset) {
}
}
// EXPERIMENTAL ----------------------------------------------------------------
// map,current
void OverworldMap::CopyTileToMap(int x, int y, int xx, int yy, int offset,
gfx::TileInfo tile, uchar* gfx16Pointer,
uchar* gfx8Pointer) {
int mx = x;
int my = y;
uchar r = 0;
if (tile.horizontal_mirror_ != 0) {
mx = 3 - x;
r = 1;
}
if (tile.vertical_mirror_ != 0) {
my = 7 - y;
}
int tx = ((tile.id_ / 16) * 512) + ((tile.id_ - ((tile.id_ / 16) * 16)) * 4);
auto index = xx + (yy * 512) + offset + (mx * 2) + (my * 512);
auto pixel = gfx8Pointer[tx + (y * 64) + x];
gfx16Pointer[index + r ^ 1] = (uchar)((pixel & 0x0F) + tile.palette_ * 16);
gfx16Pointer[index + r] = (uchar)(((pixel >> 4) & 0x0F) + tile.palette_ * 16);
}
} // namespace zelda3
} // namespace app
} // namespace yaze

15
src/app/zelda3/overworld_map.h
View File

@@ -24,10 +24,7 @@ class OverworldMap {
public:
OverworldMap(int index, ROM& rom, const std::vector<gfx::Tile16>& tiles16);
void BuildMap(int count, int game_state, uchar* map_parent,
uchar* ow_blockset, OWMapTiles& map_tiles);
absl::Status BuildMapV2(int count, int game_state, uchar* map_parent);
absl::Status BuildMap(int count, int game_state, uchar* map_parent);
auto GetBitmap() { return bitmap_; }
auto GetCurrentGraphicsSet() { return current_graphics_sheet_set; }
@@ -36,21 +33,15 @@ class OverworldMap {
private:
void LoadAreaInfo();
void BuildTiles16Gfx(int count, uchar* ow_blockset);
absl::Status BuildTileset(int game_state);
absl::Status BuildTiles16GfxV2(int count);
absl::Status BuildTiles16Gfx(int count);
// TODO: Find the SDL_Surface way to do this.
void CopyTile(int x, int y, int xx, int yy, int offset, gfx::TileInfo tile,
uchar* gfx16Pointer, uchar* gfx8Pointer);
void CopyTile8bpp16(int x, int y, int tile, uchar* ow_blockset);
void CopyTileToMap(int x, int y, int xx, int yy, int offset,
gfx::TileInfo tile, uchar* gfx16Pointer,
uchar* gfx8Pointer);
void CopyTile8bpp16From8(int xP, int yP, int tileID, uchar* destbmpPtr);
int parent_ = 0;
int index_ = 0;
int world_ = 0;

83
src/gui/canvas.cc
View File

@@ -8,89 +8,6 @@
namespace yaze {
namespace gui {
void Canvas::Update() {
ImVec2 canvas_p0 = ImGui::GetCursorScreenPos();
if (!custom_canvas_size_) canvas_sz_ = ImGui::GetContentRegionAvail();
auto canvas_p1 =
ImVec2(canvas_p0.x + canvas_sz_.x, canvas_p0.y + canvas_sz_.y);
// Draw border and background color
const ImGuiIO &io = ImGui::GetIO();
ImDrawList *draw_list = ImGui::GetWindowDrawList();
draw_list->AddRectFilled(canvas_p0, canvas_p1, IM_COL32(32, 32, 32, 255));
draw_list->AddRect(canvas_p0, canvas_p1, IM_COL32(255, 255, 255, 255));
// This will catch our interactions
ImGui::InvisibleButton(
"canvas", canvas_sz_,
ImGuiButtonFlags_MouseButtonLeft | ImGuiButtonFlags_MouseButtonRight);
const bool is_hovered = ImGui::IsItemHovered(); // Hovered
const bool is_active = ImGui::IsItemActive(); // Held
const ImVec2 origin(canvas_p0.x + scrolling_.x,
canvas_p0.y + scrolling_.y); // Lock scrolled origin
const ImVec2 mouse_pos_in_canvas(io.MousePos.x - origin.x,
io.MousePos.y - origin.y);
// Add first and second point
if (is_hovered && !dragging_select_ &&
ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
points_.push_back(mouse_pos_in_canvas);
points_.push_back(mouse_pos_in_canvas);
dragging_select_ = true;
}
if (dragging_select_) {
points_.back() = mouse_pos_in_canvas;
if (!ImGui::IsMouseDown(ImGuiMouseButton_Left)) dragging_select_ = false;
}
// Pan (we use a zero mouse threshold when there's no context menu)
const float mouse_threshold_for_pan = enable_context_menu_ ? -1.0f : 0.0f;
if (is_active &&
ImGui::IsMouseDragging(ImGuiMouseButton_Right, mouse_threshold_for_pan)) {
scrolling_.x += io.MouseDelta.x;
scrolling_.y += io.MouseDelta.y;
}
// Context menu (under default mouse threshold)
ImVec2 drag_delta = ImGui::GetMouseDragDelta(ImGuiMouseButton_Right);
if (enable_context_menu_ && drag_delta.x == 0.0f && drag_delta.y == 0.0f)
ImGui::OpenPopupOnItemClick("context", ImGuiPopupFlags_MouseButtonRight);
if (ImGui::BeginPopup("context")) {
if (dragging_select_) points_.resize(points_.size() - 2);
dragging_select_ = false;
if (ImGui::MenuItem("Remove all", nullptr, false, points_.Size > 0)) {
points_.clear();
}
ImGui::EndPopup();
}
// Draw grid + all lines in the canvas
draw_list->PushClipRect(canvas_p0, canvas_p1, true);
if (enable_grid_) {
const float GRID_STEP = 64.0f;
for (float x = fmodf(scrolling_.x, GRID_STEP); x < canvas_sz_.x;
x += GRID_STEP)
draw_list->AddLine(ImVec2(canvas_p0.x + x, canvas_p0.y),
ImVec2(canvas_p0.x + x, canvas_p1.y),
IM_COL32(200, 200, 200, 40));
for (float y = fmodf(scrolling_.y, GRID_STEP); y < canvas_sz_.y;
y += GRID_STEP)
draw_list->AddLine(ImVec2(canvas_p0.x, canvas_p0.y + y),
ImVec2(canvas_p1.x, canvas_p0.y + y),
IM_COL32(200, 200, 200, 40));
}
for (int n = 0; n < points_.Size; n += 2) {
draw_list->AddRect(
ImVec2(origin.x + points_[n].x, origin.y + points_[n].y),
ImVec2(origin.x + points_[n + 1].x, origin.y + points_[n + 1].y),
IM_COL32(255, 255, 255, 255), 1.0f);
}
draw_list->PopClipRect();
}
void Canvas::DrawBackground(ImVec2 canvas_size) {
canvas_p0_ = ImGui::GetCursorScreenPos();
if (!custom_canvas_size_) canvas_sz_ = ImGui::GetContentRegionAvail();

2
src/gui/canvas.h
View File

@@ -15,8 +15,6 @@ class Canvas {
Canvas(ImVec2 canvas_size)
: custom_canvas_size_(true), canvas_sz_(canvas_size) {}
void Update();
void DrawBackground(ImVec2 canvas_size = ImVec2(0, 0));
void UpdateContext();
void DrawGrid(float grid_step = 64.0f);

2
src/gui/input.cc
View File

@@ -21,5 +21,5 @@ bool InputHexShort(const char* label, int* data) {
ImGuiInputTextFlags_CharsHexadecimal);
}
} // namespace Gui
} // namespace gui
} // namespace yaze

2
src/gui/input.h
View File

@@ -13,7 +13,7 @@ namespace gui {
IMGUI_API bool InputHex(const char* label, int* data);
IMGUI_API bool InputHexShort(const char* label, int* data);
} // namespace Gui
} // namespace gui
} // namespace yaze
#endif

2
src/lib/ImGuiFileDialog

Submodule src/lib/ImGuiFileDialog updated: 25780cf76e...7654d521db

2
src/lib/SDL

Submodule src/lib/SDL updated: dd2e318211...0cc8dfdb58

2
src/lib/abseil-cpp

Submodule src/lib/abseil-cpp updated: 0c92330442...59cba2b50d

12
src/yaze.h
View File

@@ -1,12 +0,0 @@
#ifndef YAZE_H
#define YAZE_H
#if defined(_WIN32)
#define main SDL_main
#endif
#include "absl/debugging/failure_signal_handler.h"
#include "absl/debugging/symbolize.h"
#include "app/core/controller.h"
#endif /* YAZE_H */

19
test/CMakeLists.txt
View File

@@ -14,37 +14,30 @@ add_executable(
yaze_test
yaze_test.cc
rom_test.cc
asm_test.cc
../src/app/rom.cc
../src/app/asm/script.cc
../src/app/gfx/bitmap.cc
../src/app/gfx/snes_tile.cc
../src/app/gfx/snes_palette.cc
../src/app/core/common.cc
../src/lib/asar/src/asar-dll-bindings/c/asardll.c
)
target_include_directories(
yaze_test PUBLIC
../src/lib/
../src/
../src/lib/
../src/lib/asar/src/asar-dll-bindings/c
${SDL_INCLUDE_DIRS}
)
target_link_libraries(
yaze_test
absl::strings
absl::flags
absl::status
absl::statusor
absl::failure_signal_handler
absl::examine_stack
absl::stacktrace
absl::base
absl::config
absl::core_headers
absl::raw_logging_internal
SDL2::SDL2
${ABSL_TARGETS}
${OPENGL_LIBRARIES}
asar-static
${CMAKE_DL_LIBS}
gmock_main
gmock
gtest_main

66
test/asm_test.cc Normal file
View File

@@ -0,0 +1,66 @@
#include <asardll.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <array>
#include <cstdint>
#include <fstream>
#include <sstream>
#include <string>
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "app/asm/script.h"
#include "app/core/constants.h"
#include "app/rom.h"
namespace yaze_test {
namespace asm_test {
using yaze::app::ROM;
using yaze::app::snes_asm::Script;
using ::testing::_;
using ::testing::ElementsAreArray;
using ::testing::Eq;
using ::testing::Return;
class MockScript : public Script {
public:
MOCK_METHOD(absl::Status, ApplyPatchToROM, (ROM & rom));
MOCK_METHOD(absl::Status, GenerateMosaicChangeAssembly,
(ROM & rom, char mosaic_tiles[yaze::app::core::kNumOverworldMaps],
int routine_offset, int hook_offset));
};
TEST(ASMTest, ApplyMosaicChangePatchOk) {
ROM rom;
MockScript script;
char mosaic_tiles[yaze::app::core::kNumOverworldMaps];
EXPECT_CALL(script, GenerateMosaicChangeAssembly(_, Eq(mosaic_tiles),
Eq(0x1301D0 + 0x138000), 0))
.WillOnce(Return(absl::OkStatus()));
EXPECT_CALL(script, ApplyPatchToROM(_)).WillOnce(Return(absl::OkStatus()));
EXPECT_THAT(script.GenerateMosaicChangeAssembly(rom, mosaic_tiles,
0x1301D0 + 0x138000, 0),
absl::OkStatus());
EXPECT_THAT(script.ApplyPatchToROM(rom), absl::OkStatus());
}
TEST(ASMTest, NoPatchLoadedError) {
ROM rom;
MockScript script;
EXPECT_CALL(script, ApplyPatchToROM(_))
.WillOnce(Return(absl::InvalidArgumentError("No patch loaded!")));
EXPECT_THAT(script.ApplyPatchToROM(rom),
absl::InvalidArgumentError("No patch loaded!"));
}
} // namespace asm_test
} // namespace yaze_test