mirror of
https://github.com/TwilitRealm/dusklight
synced 2026-05-25 23:15:06 -04:00
MelonSpeedruns
1862 lines
77 KiB
C++
1862 lines
77 KiB
C++
#include "fmt/format.h"
|
|
#include "imgui.h"
|
|
#include "aurora/gfx.h"
|
|
|
|
#include "ImGuiConsole.hpp"
|
|
#include "ImGuiSaveEditor.hpp"
|
|
#include "ImGuiEventFlags.hpp"
|
|
|
|
#include "d/d_com_inf_game.h"
|
|
#include "d/d_item_data.h"
|
|
#include "d/d_meter2_info.h"
|
|
#include "d/d_save.h"
|
|
#include "d/actor/d_a_player.h"
|
|
|
|
#include <map>
|
|
|
|
namespace dusk {
|
|
enum ItemType {
|
|
ITEMTYPE_DEFAULT_e,
|
|
ITEMTYPE_EQUIP_e,
|
|
};
|
|
|
|
struct itemInfo {
|
|
std::string m_name;
|
|
u8 m_type = ITEMTYPE_DEFAULT_e;
|
|
};
|
|
|
|
std::map<int, itemInfo> itemMap = {
|
|
{ dItemNo_HEART_e, {"Heart"} },
|
|
{ dItemNo_GREEN_RUPEE_e, {"Green Rupee"} },
|
|
{ dItemNo_BLUE_RUPEE_e, {"Blue Rupee"} },
|
|
{ dItemNo_YELLOW_RUPEE_e, {"Yellow Rupee"} },
|
|
{ dItemNo_RED_RUPEE_e, {"Red Rupee"} },
|
|
{ dItemNo_PURPLE_RUPEE_e, {"Purple Rupee"} },
|
|
{ dItemNo_ORANGE_RUPEE_e, {"Orange Rupee"} },
|
|
{ dItemNo_SILVER_RUPEE_e, {"Silver Rupee"} },
|
|
{ dItemNo_S_MAGIC_e, {"Small Magic"} },
|
|
{ dItemNo_L_MAGIC_e, {"Large Magic"} },
|
|
{ dItemNo_BOMB_5_e, {"Bombs (5)"} },
|
|
{ dItemNo_BOMB_10_e, {"Bombs (10)"} },
|
|
{ dItemNo_BOMB_20_e, {"Bombs (20)"} },
|
|
{ dItemNo_BOMB_30_e, {"Bombs (30)"} },
|
|
{ dItemNo_ARROW_10_e, {"Arrows (10)"} },
|
|
{ dItemNo_ARROW_20_e, {"Arrows (20)"} },
|
|
{ dItemNo_ARROW_30_e, {"Arrows (30)"} },
|
|
{ dItemNo_ARROW_1_e, {"Arrows (1)"} },
|
|
{ dItemNo_PACHINKO_SHOT_e, {"Pumpkin Seeds"} },
|
|
{ dItemNo_NOENTRY_19_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_20_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_21_e, {"Reserved"} },
|
|
{ dItemNo_WATER_BOMB_5_e, {"Water Bombs (5)"} },
|
|
{ dItemNo_WATER_BOMB_10_e, {"Water Bombs (10)"} },
|
|
{ dItemNo_WATER_BOMB_20_e, {"Water Bombs (20)"} },
|
|
{ dItemNo_WATER_BOMB_30_e, {"Water Bombs (30)"} },
|
|
{ dItemNo_BOMB_INSECT_5_e, {"Bomblings (5)"} },
|
|
{ dItemNo_BOMB_INSECT_10_e, {"Bomblings (10)"} },
|
|
{ dItemNo_BOMB_INSECT_20_e, {"Bomblings (20)"} },
|
|
{ dItemNo_BOMB_INSECT_30_e, {"Bomblings (30)"} },
|
|
{ dItemNo_RECOVERY_FAILY_e, {"Fairy"} },
|
|
{ dItemNo_TRIPLE_HEART_e, {"Triple Hearts"} },
|
|
{ dItemNo_SMALL_KEY_e, {"Small Key"} },
|
|
{ dItemNo_KAKERA_HEART_e, {"Piece of Heart"} },
|
|
{ dItemNo_UTAWA_HEART_e, {"Heart Container"} },
|
|
{ dItemNo_MAP_e, {"Dungeon Map"} },
|
|
{ dItemNo_COMPUS_e, {"Compass"} },
|
|
{ dItemNo_DUNGEON_EXIT_e, {"Ooccoo Sr. (First Time)", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_BOSS_KEY_e, {"Boss Key"} },
|
|
{ dItemNo_DUNGEON_BACK_e, {"Ooccoo Jr.", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_SWORD_e, {"Ordon Sword"} },
|
|
{ dItemNo_MASTER_SWORD_e, {"Master Sword"} },
|
|
{ dItemNo_WOOD_SHIELD_e, {"Wooden Shield"} },
|
|
{ dItemNo_SHIELD_e, {"Ordon Shield"} },
|
|
{ dItemNo_HYLIA_SHIELD_e, {"Hylian Shield"} },
|
|
{ dItemNo_TKS_LETTER_e, {"Ooccoo's Note", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_WEAR_CASUAL_e, {"Ordon Clothes"} },
|
|
{ dItemNo_WEAR_KOKIRI_e, {"Hero's Clothes"} },
|
|
{ dItemNo_ARMOR_e, {"Magic Armor"} },
|
|
{ dItemNo_WEAR_ZORA_e, {"Zora Armor"} },
|
|
{ dItemNo_MAGIC_LV1_e, {"Magic Level 1"} },
|
|
{ dItemNo_DUNGEON_EXIT_2_e, {"Ooccoo Sr.", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_WALLET_LV1_e, {"Wallet"} },
|
|
{ dItemNo_WALLET_LV2_e, {"Big Wallet"} },
|
|
{ dItemNo_WALLET_LV3_e, {"Giant Wallet"} },
|
|
{ dItemNo_NOENTRY_55_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_56_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_57_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_58_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_59_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_60_e, {"Reserved"} },
|
|
{ dItemNo_ZORAS_JEWEL_e, {"Coral Earring", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_HAWK_EYE_e, {"Hawkeye", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_WOOD_STICK_e, {"Wooden Sword"} },
|
|
{ dItemNo_BOOMERANG_e, {"Gale Boomerang", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_SPINNER_e, {"Spinner", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_IRONBALL_e, {"Ball and Chain", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_BOW_e, {"Hero's Bow", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_HOOKSHOT_e, {"Clawshot", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_HVY_BOOTS_e, {"Iron Boots", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_COPY_ROD_e, {"Dominion Rod", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_W_HOOKSHOT_e, {"Double Clawshots", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_KANTERA_e, {"Lantern", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_LIGHT_SWORD_e, {"Light Sword"} },
|
|
{ dItemNo_FISHING_ROD_1_e, {"Fishing Rod", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_PACHINKO_e, {"Slingshot", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_COPY_ROD_2_e, {"Dominion Rod (Uncharged)"} },
|
|
{ dItemNo_NOENTRY_77_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_78_e, {"Reserved"} },
|
|
{ dItemNo_BOMB_BAG_LV2_e, {"Giant Bomb Bag"} },
|
|
{ dItemNo_BOMB_BAG_LV1_e, {"Empty Bomb Bag", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_BOMB_IN_BAG_e, {"Bomb Bag"} },
|
|
{ dItemNo_NOENTRY_82_e, {"Reserved"} },
|
|
{ dItemNo_LIGHT_ARROW_e, {"Light Arrow"} },
|
|
{ dItemNo_ARROW_LV1_e, {"Quiver"} },
|
|
{ dItemNo_ARROW_LV2_e, {"Big Quiver"} },
|
|
{ dItemNo_ARROW_LV3_e, {"Giant Quiver"} },
|
|
{ dItemNo_NOENTRY_87_e, {"Reserved"} },
|
|
{ dItemNo_LURE_ROD_e, {"Fishing Rod (Lure)"} },
|
|
{ dItemNo_BOMB_ARROW_e, {"Bomb Arrow"} },
|
|
{ dItemNo_HAWK_ARROW_e, {"Hawk Arrow"} },
|
|
{ dItemNo_BEE_ROD_e, {"Fishing Rod (Bee Larva)", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_JEWEL_ROD_e, {"Fishing Rod (Earring)", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_WORM_ROD_e, {"Fishing Rod (Worm)", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_JEWEL_BEE_ROD_e, {"Fishing Rod (Earring + Bee Larva)", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_JEWEL_WORM_ROD_e, {"Fishing Rod (Earring + Worm)", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_EMPTY_BOTTLE_e, {"Empty Bottle", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_RED_BOTTLE_e, {"Red Potion", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_GREEN_BOTTLE_e, {"Green Potion", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_BLUE_BOTTLE_e, {"Blue Potion", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_MILK_BOTTLE_e, {"Milk Bottle", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_HALF_MILK_BOTTLE_e, {"Half Milk Bottle", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_OIL_BOTTLE_e, {"Lantern Oil", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_WATER_BOTTLE_e, {"Water Bottle", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_OIL_BOTTLE_2_e, {"Lantern Oil (Scooped)"} },
|
|
{ dItemNo_RED_BOTTLE_2_e, {"Red Potion (Scooped)"} },
|
|
{ dItemNo_UGLY_SOUP_e, {"Nasty Soup", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_HOT_SPRING_e, {"Hotspring Water", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_FAIRY_e, {"Fairy", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_HOT_SPRING_2_e, {"Hotspring Water (Shop)"} },
|
|
{ dItemNo_OIL2_e, {"Lantern Refill (Scooped)"} },
|
|
{ dItemNo_OIL_e, {"Lantern Refill (Shop)"} },
|
|
{ dItemNo_NORMAL_BOMB_e, {"Bombs", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_WATER_BOMB_e, {"Water Bombs", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_POKE_BOMB_e, {"Bomblings", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_FAIRY_DROP_e, {"Great Fairy's Tears", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_WORM_e, {"Worm", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_DROP_BOTTLE_e, {"Great Fairy Tears (Jovani)"} },
|
|
{ dItemNo_BEE_CHILD_e, {"Bee Larva", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_CHUCHU_RARE_e, {"Rare Chu Jelly", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_CHUCHU_RED_e, {"Red Chu Jelly", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_CHUCHU_BLUE_e, {"Blue Chu Jelly", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_CHUCHU_GREEN_e, {"Green Chu Jelly", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_CHUCHU_YELLOW_e, {"Yellow Chu Jelly", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_CHUCHU_PURPLE_e, {"Purple Chu Jelly", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_LV1_SOUP_e, {"Simple Soup", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_LV2_SOUP_e, {"Good Soup", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_LV3_SOUP_e, {"Superb Soup", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_LETTER_e, {"Renado's Letter", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_BILL_e, {"Invoice", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_WOOD_STATUE_e, {"Wooden Statue", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_IRIAS_PENDANT_e, {"Ilia's Charm", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_HORSE_FLUTE_e, {"Horse Call", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_NOENTRY_133_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_134_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_135_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_136_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_137_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_138_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_139_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_140_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_141_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_142_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_143_e, {"Reserved"} },
|
|
{ dItemNo_RAFRELS_MEMO_e, {"Auru's Memo", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_ASHS_SCRIBBLING_e, {"Ashei's Sketch", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_NOENTRY_146_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_147_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_148_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_149_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_150_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_151_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_152_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_153_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_154_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_155_e, {"Reserved"} },
|
|
{ dItemNo_CHUCHU_YELLOW2_e, {"Lantern Refill (Yellow Chu)"} },
|
|
{ dItemNo_OIL_BOTTLE3_e, {"Lantern Oil (Coro)"} },
|
|
{ dItemNo_SHOP_BEE_CHILD_e, {"Bee Larve (Shop)"} },
|
|
{ dItemNo_CHUCHU_BLACK_e, {"Black Chu Jelly", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_LIGHT_DROP_e, {"Tear of Light"} },
|
|
{ dItemNo_DROP_CONTAINER_e, {"Vessel of Light (Faron)"} },
|
|
{ dItemNo_DROP_CONTAINER02_e, {"Vessel of Light (Eldin)"} },
|
|
{ dItemNo_DROP_CONTAINER03_e, {"Vessel of Light (Lanayru)"} },
|
|
{ dItemNo_FILLED_CONTAINER_e, {"Vessel of Light (Filled)"} },
|
|
{ dItemNo_MIRROR_PIECE_2_e, {"Mirror Shard (Snowpeak Ruins)"} },
|
|
{ dItemNo_MIRROR_PIECE_3_e, {"Mirror Shard (Temple of Time)"} },
|
|
{ dItemNo_MIRROR_PIECE_4_e, {"Mirror Shard (City in the Sky)"} },
|
|
{ dItemNo_NOENTRY_168_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_169_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_170_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_171_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_172_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_173_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_174_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_175_e, {"Reserved"} },
|
|
{ dItemNo_SMELL_YELIA_POUCH_e, {"Scent of Ilia"} },
|
|
{ dItemNo_SMELL_PUMPKIN_e, {"Pumpkin Scent"} },
|
|
{ dItemNo_SMELL_POH_e, {"Poe Scent"} },
|
|
{ dItemNo_SMELL_FISH_e, {"Reekfish Scent"} },
|
|
{ dItemNo_SMELL_CHILDREN_e, {"Youth's Scent"} },
|
|
{ dItemNo_SMELL_MEDICINE_e, {"Medicine Scent"} },
|
|
{ dItemNo_NOENTRY_182_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_183_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_184_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_185_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_186_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_187_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_188_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_189_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_190_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_191_e, {"Reserved"} },
|
|
{ dItemNo_M_BEETLE_e, {"Beetle (M)"} },
|
|
{ dItemNo_F_BEETLE_e, {"Beetle (F)"} },
|
|
{ dItemNo_M_BUTTERFLY_e, {"Butterfly (M)"} },
|
|
{ dItemNo_F_BUTTERFLY_e, {"Butterfly (F)"} },
|
|
{ dItemNo_M_STAG_BEETLE_e, {"Stag Beetle (M)"} },
|
|
{ dItemNo_F_STAG_BEETLE_e, {"Stag Beetle (F)"} },
|
|
{ dItemNo_M_GRASSHOPPER_e, {"Grasshopper (M)"} },
|
|
{ dItemNo_F_GRASSHOPPER_e, {"Grasshopper (F)"} },
|
|
{ dItemNo_M_NANAFUSHI_e, {"Phasmid (M)"} },
|
|
{ dItemNo_F_NANAFUSHI_e, {"Phasmid (F)"} },
|
|
{ dItemNo_M_DANGOMUSHI_e, {"Pill Bug (M)"} },
|
|
{ dItemNo_F_DANGOMUSHI_e, {"Pill Bug (F)"} },
|
|
{ dItemNo_M_MANTIS_e, {"Mantis (M)"} },
|
|
{ dItemNo_F_MANTIS_e, {"Mantis (F)"} },
|
|
{ dItemNo_M_LADYBUG_e, {"Ladybug (M)"} },
|
|
{ dItemNo_F_LADYBUG_e, {"Ladybug (F)"} },
|
|
{ dItemNo_M_SNAIL_e, {"Snail (M)"} },
|
|
{ dItemNo_F_SNAIL_e, {"Snail (F)"} },
|
|
{ dItemNo_M_DRAGONFLY_e, {"Dragonfly (M)"} },
|
|
{ dItemNo_F_DRAGONFLY_e, {"Dragonfly (F)"} },
|
|
{ dItemNo_M_ANT_e, {"Ant (M)"} },
|
|
{ dItemNo_F_ANT_e, {"Ant (F)"} },
|
|
{ dItemNo_M_MAYFLY_e, {"Mayfly (M)"} },
|
|
{ dItemNo_F_MAYFLY_e, {"Mayfly (F)"} },
|
|
{ dItemNo_NOENTRY_216_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_217_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_218_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_219_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_220_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_221_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_222_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_223_e, {"Reserved"} },
|
|
{ dItemNo_POU_SPIRIT_e, {"Poe Soul"} },
|
|
{ dItemNo_LENS_OF_TRUTH_e, {"Lens of Truth", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_NOENTRY_226_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_227_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_228_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_229_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_230_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_231_e, {"Reserved"} },
|
|
{ dItemNo_NOENTRY_232_e, {"Reserved"} },
|
|
{ dItemNo_ANCIENT_DOCUMENT_e, {"Ancient Sky Book", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_AIR_LETTER_e, {"Ancient Sky Book (Partial)", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_ANCIENT_DOCUMENT2_e, {"Ancient Sky Book (Filled)", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_LV7_DUNGEON_EXIT_e, {"Ooccoo Sr. (City in the Sky)"} },
|
|
{ dItemNo_LINKS_SAVINGS_e, {"Purple Rupee (Link's Savings)"} },
|
|
{ dItemNo_SMALL_KEY2_e, {"Small Key (North Faron Gate)"} },
|
|
{ dItemNo_POU_FIRE1_e, {"Poe Fire 1"} },
|
|
{ dItemNo_POU_FIRE2_e, {"Poe Fire 2"} },
|
|
{ dItemNo_POU_FIRE3_e, {"Poe Fire 3"} },
|
|
{ dItemNo_POU_FIRE4_e, {"Poe Fire 4"} },
|
|
{ dItemNo_BOSSRIDER_KEY_e, {"Hyrule Field Keys"} },
|
|
{ dItemNo_TOMATO_PUREE_e, {"Ordon Pumpkin", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_TASTE_e, {"Ordon Goat Cheese", ITEMTYPE_EQUIP_e} },
|
|
{ dItemNo_LV5_BOSS_KEY_e, {"Bedroom Key"} },
|
|
{ dItemNo_SURFBOARD_e, {"Surf Leaf"} },
|
|
{ dItemNo_KANTERA2_e, {"Lantern (Reclaimed)"} },
|
|
{ dItemNo_L2_KEY_PIECES1_e, {"Key Shard (1)"} },
|
|
{ dItemNo_L2_KEY_PIECES2_e, {"Key Shard (2)"} },
|
|
{ dItemNo_L2_KEY_PIECES3_e, {"Key Shard (3)"} },
|
|
{ dItemNo_KEY_OF_CARAVAN_e, {"Bulblin Camp Key"} },
|
|
{ dItemNo_LV2_BOSS_KEY_e, {"Goron Mines Boss Key"} },
|
|
{ dItemNo_KEY_OF_FILONE_e, {"South Faron Gate Key"} },
|
|
{ dItemNo_NONE_e, {"None"} },
|
|
};
|
|
|
|
static constexpr int BUG_SPECIES_COUNT = 12;
|
|
|
|
static const u8 sBugItemIds[BUG_SPECIES_COUNT * 2] = {
|
|
dItemNo_M_ANT_e, dItemNo_F_ANT_e,
|
|
dItemNo_M_MAYFLY_e, dItemNo_F_MAYFLY_e,
|
|
dItemNo_M_BEETLE_e, dItemNo_F_BEETLE_e,
|
|
dItemNo_M_MANTIS_e, dItemNo_F_MANTIS_e,
|
|
dItemNo_M_STAG_BEETLE_e, dItemNo_F_STAG_BEETLE_e,
|
|
dItemNo_M_DANGOMUSHI_e, dItemNo_F_DANGOMUSHI_e,
|
|
dItemNo_M_BUTTERFLY_e, dItemNo_F_BUTTERFLY_e,
|
|
dItemNo_M_LADYBUG_e, dItemNo_F_LADYBUG_e,
|
|
dItemNo_M_SNAIL_e, dItemNo_F_SNAIL_e,
|
|
dItemNo_M_NANAFUSHI_e, dItemNo_F_NANAFUSHI_e,
|
|
dItemNo_M_GRASSHOPPER_e, dItemNo_F_GRASSHOPPER_e,
|
|
dItemNo_M_DRAGONFLY_e, dItemNo_F_DRAGONFLY_e,
|
|
};
|
|
|
|
static const u16 sBugTurnInFlags[BUG_SPECIES_COUNT * 2] = {
|
|
dSv_event_flag_c::F_0421, dSv_event_flag_c::F_0422,
|
|
dSv_event_flag_c::F_0423, dSv_event_flag_c::F_0424,
|
|
dSv_event_flag_c::F_0401, dSv_event_flag_c::F_0402,
|
|
dSv_event_flag_c::F_0413, dSv_event_flag_c::F_0414,
|
|
dSv_event_flag_c::F_0405, dSv_event_flag_c::F_0406,
|
|
dSv_event_flag_c::F_0411, dSv_event_flag_c::F_0412,
|
|
dSv_event_flag_c::F_0403, dSv_event_flag_c::F_0404,
|
|
dSv_event_flag_c::F_0415, dSv_event_flag_c::F_0416,
|
|
dSv_event_flag_c::F_0417, dSv_event_flag_c::F_0418,
|
|
dSv_event_flag_c::F_0409, dSv_event_flag_c::F_0410,
|
|
dSv_event_flag_c::F_0407, dSv_event_flag_c::F_0408,
|
|
dSv_event_flag_c::F_0419, dSv_event_flag_c::F_0420,
|
|
};
|
|
|
|
static const char* sBugSpeciesNames[BUG_SPECIES_COUNT] = {
|
|
"Ant", "Dayfly", "Beetle", "Mantis",
|
|
"Stag Beetle", "Pill Bug", "Butterfly", "Ladybug",
|
|
"Snail", "Phasmid", "Grasshopper", "Dragonfly",
|
|
};
|
|
|
|
static constexpr int HIDDEN_SKILL_COUNT = 7;
|
|
|
|
static const u16 sHiddenSkillFlags[HIDDEN_SKILL_COUNT] = {
|
|
dSv_event_flag_c::F_0339, dSv_event_flag_c::F_0338,
|
|
dSv_event_flag_c::F_0340, dSv_event_flag_c::F_0341,
|
|
dSv_event_flag_c::F_0342, dSv_event_flag_c::F_0343,
|
|
dSv_event_flag_c::F_0344,
|
|
};
|
|
|
|
static const char* sHiddenSkillNames[HIDDEN_SKILL_COUNT] = {
|
|
"Ending Blow", "Shield Attack", "Back Slice", "Helm Splitter",
|
|
"Mortal Draw", "Jump Strike", "Great Spin",
|
|
};
|
|
|
|
static constexpr int LETTER_COUNT = 16;
|
|
|
|
static const char* sLetterSenders[LETTER_COUNT] = {
|
|
"Renado", "Ooccoo 1", "Ooccoo 2", "The Postman",
|
|
"Kakariko Goods", "Barnes 1", "Barnes 2", "Barnes Bombs",
|
|
"Malo Mart", "Telma", "Purlo", "From Jr.",
|
|
"Princess Agitha", "Lanayru Tourism", "Shad", "Yeta",
|
|
};
|
|
|
|
static constexpr int FISH_COUNT = 6;
|
|
|
|
static const struct {
|
|
u8 index;
|
|
const char* name;
|
|
} sFishSpecies[FISH_COUNT] = {
|
|
{ 3, "Ordon Catfish" },
|
|
{ 5, "Greengill" },
|
|
{ 4, "Reekfish" },
|
|
{ 0, "Hyrule Bass" },
|
|
{ 2, "Hylian Pike" },
|
|
{ 1, "Hylian Loach" },
|
|
};
|
|
|
|
static const char* sSwordNames[4] = {
|
|
"Ordon Sword", "Master Sword", "Wooden Sword", "Light Sword",
|
|
};
|
|
|
|
static const char* sShieldNames[3] = {
|
|
"Wooden Shield", "Ordon Shield", "Hylian Shield",
|
|
};
|
|
|
|
static const char* sFusedShadowNames[3] = {
|
|
"Forest Temple",
|
|
"Goron Mines",
|
|
"Lakebed Temple",
|
|
};
|
|
|
|
static const struct {
|
|
u8 index;
|
|
const char* name;
|
|
} sMirrorShards[3] = {
|
|
{ 1, "Snowpeak Ruins" },
|
|
{ 2, "Temple of Time" },
|
|
{ 3, "City in the Sky" },
|
|
};
|
|
|
|
static const struct {
|
|
u8 slot;
|
|
u8 item;
|
|
} sDefaultInventory[] = {
|
|
{ SLOT_0, dItemNo_BOOMERANG_e },
|
|
{ SLOT_1, dItemNo_KANTERA_e },
|
|
{ SLOT_2, dItemNo_SPINNER_e },
|
|
{ SLOT_3, dItemNo_HVY_BOOTS_e },
|
|
{ SLOT_4, dItemNo_BOW_e },
|
|
{ SLOT_5, dItemNo_HAWK_EYE_e },
|
|
{ SLOT_6, dItemNo_IRONBALL_e },
|
|
{ SLOT_8, dItemNo_COPY_ROD_e },
|
|
{ SLOT_9, dItemNo_HOOKSHOT_e },
|
|
{ SLOT_10, dItemNo_W_HOOKSHOT_e },
|
|
{ SLOT_11, dItemNo_EMPTY_BOTTLE_e },
|
|
{ SLOT_12, dItemNo_EMPTY_BOTTLE_e },
|
|
{ SLOT_13, dItemNo_EMPTY_BOTTLE_e },
|
|
{ SLOT_14, dItemNo_EMPTY_BOTTLE_e },
|
|
{ SLOT_15, dItemNo_NORMAL_BOMB_e },
|
|
{ SLOT_16, dItemNo_WATER_BOMB_e },
|
|
{ SLOT_17, dItemNo_POKE_BOMB_e },
|
|
{ SLOT_18, dItemNo_DUNGEON_EXIT_e },
|
|
{ SLOT_20, dItemNo_FISHING_ROD_1_e},
|
|
{ SLOT_21, dItemNo_HORSE_FLUTE_e },
|
|
{ SLOT_22, dItemNo_ANCIENT_DOCUMENT_e },
|
|
{ SLOT_23, dItemNo_PACHINKO_e },
|
|
{ SLOT_24, dItemNo_LENS_OF_TRUTH_e},
|
|
};
|
|
|
|
ImGuiSaveEditor::ImGuiSaveEditor() {}
|
|
|
|
void ImGuiSaveEditor::draw(bool& open) {
|
|
ImGuiIO& io = ImGui::GetIO();
|
|
ImGuiWindowFlags windowFlags =
|
|
ImGuiWindowFlags_NoResize | ImGuiWindowFlags_AlwaysAutoResize;
|
|
|
|
// ImGui::SetNextWindowBgAlpha(0.65f);
|
|
|
|
if (ImGui::Begin("Save Editor", &open, windowFlags)) {
|
|
if (ImGui::BeginTabBar("SaveEditorTabBar", ImGuiTabBarFlags_NoCloseWithMiddleMouseButton)) {
|
|
if (ImGui::BeginTabItem("Player Status")) {
|
|
drawPlayerStatusTab();
|
|
ImGui::EndTabItem();
|
|
}
|
|
|
|
if (ImGui::BeginTabItem("Location")) {
|
|
drawLocationTab();
|
|
ImGui::EndTabItem();
|
|
}
|
|
|
|
if (ImGui::BeginTabItem("Inventory")) {
|
|
drawInventoryTab();
|
|
ImGui::EndTabItem();
|
|
}
|
|
|
|
if (ImGui::BeginTabItem("Collection")) {
|
|
drawCollectionTab();
|
|
ImGui::EndTabItem();
|
|
}
|
|
|
|
if (ImGui::BeginTabItem("Flags")) {
|
|
drawFlagsTab();
|
|
ImGui::EndTabItem();
|
|
}
|
|
|
|
if (ImGui::BeginTabItem("Minigame")) {
|
|
drawMinigameTab();
|
|
ImGui::EndTabItem();
|
|
}
|
|
|
|
if (ImGui::BeginTabItem("Config")) {
|
|
drawConfigTab();
|
|
ImGui::EndTabItem();
|
|
}
|
|
|
|
ImGui::EndTabBar();
|
|
}
|
|
}
|
|
|
|
ImGui::End();
|
|
}
|
|
|
|
void InputScalarBE(const char* label, ImGuiDataType dataType, void* pData) {
|
|
switch (dataType) {
|
|
case ImGuiDataType_U16: {
|
|
u16 temp = *(BE(u16)*)pData;
|
|
if (ImGui::InputScalar(label, dataType, &temp)) {
|
|
*(BE(u16)*)pData = temp;
|
|
}
|
|
break;
|
|
}
|
|
case ImGuiDataType_S16: {
|
|
s16 temp = *(BE(s16)*)pData;
|
|
if (ImGui::InputScalar(label, dataType, &temp)) {
|
|
*(BE(s16)*)pData = temp;
|
|
}
|
|
break;
|
|
}
|
|
case ImGuiDataType_U32: {
|
|
u32 temp = *(BE(u32)*)pData;
|
|
if (ImGui::InputScalar(label, dataType, &temp)) {
|
|
*(BE(u32)*)pData = temp;
|
|
}
|
|
break;
|
|
}
|
|
case ImGuiDataType_S32: {
|
|
s32 temp = *(BE(s32)*)pData;
|
|
if (ImGui::InputScalar(label, dataType, &temp)) {
|
|
*(BE(s32)*)pData = temp;
|
|
}
|
|
break;
|
|
}
|
|
case ImGuiDataType_U64: {
|
|
u64 temp = *(BE(u64)*)pData;
|
|
if (ImGui::InputScalar(label, dataType, &temp)) {
|
|
*(BE(u64)*)pData = temp;
|
|
}
|
|
break;
|
|
}
|
|
case ImGuiDataType_S64: {
|
|
s64 temp = *(BE(s64)*)pData;
|
|
if (ImGui::InputScalar(label, dataType, &temp)) {
|
|
*(BE(s64)*)pData = temp;
|
|
}
|
|
break;
|
|
}
|
|
case ImGuiDataType_Float: {
|
|
f32 temp = *(BE(f32)*)pData;
|
|
if (ImGui::InputScalar(label, dataType, &temp)) {
|
|
*(BE(f32)*)pData = temp;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void genSelectItemComboBox(const char* label, u8& selectItemData) {
|
|
dSv_player_status_a_c& statusA = dComIfGs_getSaveData()->getPlayer().getPlayerStatusA();
|
|
dSv_player_item_c& item = dComIfGs_getSaveData()->getPlayer().getItem();
|
|
|
|
int currentSlotNo = selectItemData;
|
|
std::string defaultLabel =
|
|
currentSlotNo != 0xFF
|
|
? fmt::format("Slot {0} ({1})", currentSlotNo, itemMap.find(item.mItems[currentSlotNo])->second.m_name)
|
|
: "None";
|
|
|
|
// TODO: live update equips
|
|
if (ImGui::BeginCombo(label, defaultLabel.c_str())) {
|
|
if (ImGui::Selectable("None")) {
|
|
selectItemData = 0xFF;
|
|
}
|
|
|
|
for (int i = 0; i < 25; i++) {
|
|
u8 itemNo = item.mItems[i];
|
|
if (ImGui::Selectable(fmt::format("Slot {0} ({1})", i, itemMap.find(itemNo)->second.m_name).c_str())) {
|
|
selectItemData = i;
|
|
}
|
|
}
|
|
ImGui::EndCombo();
|
|
}
|
|
}
|
|
|
|
void ImGuiSaveEditor::drawPlayerStatusTab() {
|
|
const char* playerName = dComIfGs_getPlayerName();
|
|
ImGui::Text("Player Name: ");
|
|
ImGui::SameLine();
|
|
char nameBuffer[8];
|
|
snprintf(nameBuffer, sizeof(nameBuffer), "%s", playerName);
|
|
if (ImGui::InputText("##PlayerNameInput", nameBuffer, 8)) {
|
|
strcpy(dComIfGs_getPlayerName(), nameBuffer);
|
|
}
|
|
|
|
const char* horseName = dComIfGs_getHorseName();
|
|
ImGui::Text("Horse Name: ");
|
|
ImGui::SameLine();
|
|
char horseNameBuffer[8];
|
|
snprintf(horseNameBuffer, sizeof(horseNameBuffer), "%s", horseName);
|
|
if (ImGui::InputText("##HorseNameInput", horseNameBuffer, 8)) {
|
|
strcpy(dComIfGs_getHorseName(), horseNameBuffer);
|
|
}
|
|
|
|
ImGui::Separator();
|
|
|
|
dSv_player_status_a_c& statusA = dComIfGs_getSaveData()->getPlayer().getPlayerStatusA();
|
|
dSv_player_status_b_c& statusB = dComIfGs_getSaveData()->getPlayer().getPlayerStatusB();
|
|
|
|
InputScalarBE("Max Health", ImGuiDataType_U16, &statusA.mMaxLife);
|
|
InputScalarBE("Health", ImGuiDataType_U16, &statusA.mLife);
|
|
InputScalarBE("Rupees", ImGuiDataType_U16, &statusA.mRupee);
|
|
InputScalarBE("Max Oil", ImGuiDataType_U16, &statusA.mMaxOil);
|
|
InputScalarBE("Oil", ImGuiDataType_U16, &statusA.mOil);
|
|
|
|
genSelectItemComboBox("Equip X", statusA.mSelectItem[0]);
|
|
genSelectItemComboBox("Equip Y", statusA.mSelectItem[1]);
|
|
genSelectItemComboBox("Combo Equip X", statusA.mMixItem[0]);
|
|
genSelectItemComboBox("Combo Equip Y", statusA.mMixItem[1]);
|
|
|
|
|
|
if (ImGui::BeginCombo("Clothes", itemMap.find(statusA.mSelectEquip[0])->second.m_name.c_str())) {
|
|
if (ImGui::Selectable("Ordon Clothes")) {
|
|
dMeter2Info_setCloth(dItemNo_WEAR_CASUAL_e, false);
|
|
daPy_getPlayerActorClass()->setClothesChange(0);
|
|
}
|
|
if (ImGui::Selectable("Hero's Clothes")) {
|
|
dMeter2Info_setCloth(dItemNo_WEAR_KOKIRI_e, false);
|
|
daPy_getPlayerActorClass()->setClothesChange(0);
|
|
}
|
|
if (ImGui::Selectable("Zora Armor")) {
|
|
dMeter2Info_setCloth(dItemNo_WEAR_ZORA_e, false);
|
|
daPy_getPlayerActorClass()->setClothesChange(0);
|
|
}
|
|
if (ImGui::Selectable("Magic Armor")) {
|
|
dMeter2Info_setCloth(dItemNo_ARMOR_e, false);
|
|
daPy_getPlayerActorClass()->setClothesChange(0);
|
|
}
|
|
ImGui::EndCombo();
|
|
}
|
|
|
|
if (ImGui::BeginCombo("Sword", itemMap.find(statusA.mSelectEquip[1])->second.m_name.c_str())) {
|
|
if (ImGui::Selectable("None")) {
|
|
statusA.mSelectEquip[1] = dItemNo_NONE_e;
|
|
}
|
|
if (ImGui::Selectable("Wooden Sword")) {
|
|
statusA.mSelectEquip[1] = dItemNo_WOOD_STICK_e;
|
|
}
|
|
if (ImGui::Selectable("Ordon Sword")) {
|
|
statusA.mSelectEquip[1] = dItemNo_SWORD_e;
|
|
}
|
|
if (ImGui::Selectable("Master Sword")) {
|
|
statusA.mSelectEquip[1] = dItemNo_MASTER_SWORD_e;
|
|
}
|
|
if (ImGui::Selectable("Light Sword")) {
|
|
statusA.mSelectEquip[1] = dItemNo_LIGHT_SWORD_e;
|
|
}
|
|
ImGui::EndCombo();
|
|
}
|
|
|
|
if (ImGui::BeginCombo("Shield", itemMap.find(statusA.mSelectEquip[2])->second.m_name.c_str())) {
|
|
if (ImGui::Selectable("None")) {
|
|
statusA.mSelectEquip[2] = dItemNo_NONE_e;
|
|
}
|
|
if (ImGui::Selectable("Wooden Shield")) {
|
|
statusA.mSelectEquip[2] = dItemNo_SHIELD_e;
|
|
}
|
|
if (ImGui::Selectable("Ordon Shield")) {
|
|
statusA.mSelectEquip[2] = dItemNo_WOOD_SHIELD_e;
|
|
}
|
|
if (ImGui::Selectable("Hylian Shield")) {
|
|
statusA.mSelectEquip[2] = dItemNo_HYLIA_SHIELD_e;
|
|
}
|
|
ImGui::EndCombo();
|
|
}
|
|
|
|
if (ImGui::BeginCombo("Scent", itemMap.find(statusA.mSelectEquip[3])->second.m_name.c_str())) {
|
|
if (ImGui::Selectable("None")) {
|
|
statusA.mSelectEquip[3] = dItemNo_NONE_e;
|
|
}
|
|
if (ImGui::Selectable("Youth's Scent")) {
|
|
statusA.mSelectEquip[3] = dItemNo_SMELL_CHILDREN_e;
|
|
}
|
|
if (ImGui::Selectable("Scent of Ilia")) {
|
|
statusA.mSelectEquip[3] = dItemNo_SMELL_YELIA_POUCH_e;
|
|
}
|
|
if (ImGui::Selectable("Poe Scent")) {
|
|
statusA.mSelectEquip[3] = dItemNo_SMELL_POH_e;
|
|
}
|
|
if (ImGui::Selectable("Reekfish Scent")) {
|
|
statusA.mSelectEquip[3] = dItemNo_SMELL_FISH_e;
|
|
}
|
|
if (ImGui::Selectable("Medicine Scent")) {
|
|
statusA.mSelectEquip[3] = dItemNo_SMELL_MEDICINE_e;
|
|
}
|
|
ImGui::EndCombo();
|
|
}
|
|
|
|
const char* walletSizeNames[] = {
|
|
"Normal",
|
|
"Big",
|
|
"Giant",
|
|
};
|
|
int walletSize = statusA.getWalletSize();
|
|
if (ImGui::BeginCombo("Wallet Size", walletSizeNames[walletSize])) {
|
|
if (ImGui::Selectable(walletSizeNames[WALLET])) {
|
|
statusA.setWalletSize(WALLET);
|
|
}
|
|
if (ImGui::Selectable(walletSizeNames[BIG_WALLET])) {
|
|
statusA.setWalletSize(BIG_WALLET);
|
|
}
|
|
if (ImGui::Selectable(walletSizeNames[GIANT_WALLET])) {
|
|
statusA.setWalletSize(GIANT_WALLET);
|
|
}
|
|
ImGui::EndCombo();
|
|
}
|
|
|
|
if (ImGui::BeginCombo("Form", statusA.mTransformStatus == 0 ? "Human" : "Wolf")) {
|
|
if (ImGui::Selectable("Human")) {
|
|
statusA.mTransformStatus = TF_STATUS_HUMAN;
|
|
}
|
|
if (ImGui::Selectable("Wolf")) {
|
|
statusA.mTransformStatus = TF_STATUS_WOLF;
|
|
}
|
|
ImGui::EndCombo();
|
|
}
|
|
|
|
ImGui::Separator();
|
|
|
|
s32 hours = dKy_getdaytime_hour();
|
|
s32 min = dKy_getdaytime_minute();
|
|
ImGui::SetNextItemWidth(ImGui::GetFontSize() * 2);
|
|
if (ImGui::InputScalar("##TimeHours", ImGuiDataType_S32, &hours)) {
|
|
hours = std::clamp(hours, 0, 23);
|
|
statusB.setTime((hours * 15.0f) + (min / 60.0f * 15.0f));
|
|
}
|
|
|
|
ImGui::SameLine();
|
|
ImGui::Text(":");
|
|
ImGui::SameLine();
|
|
|
|
ImGui::SetNextItemWidth(ImGui::GetFontSize() * 2);
|
|
if (ImGui::InputScalar("Time##TimeMinutes", ImGuiDataType_S32, &min)) {
|
|
min = std::clamp(min, 0, 59);
|
|
statusB.setTime((hours * 15.0f) + (min / 60.0f * 15.0f));
|
|
}
|
|
|
|
InputScalarBE("Date", ImGuiDataType_U16, &statusB.mDate);
|
|
|
|
int transformLevel = 0;
|
|
for (int i = 0; i < 4; i++) {
|
|
if (statusB.mTransformLevelFlag & (1 << i)) {
|
|
transformLevel++;
|
|
}
|
|
}
|
|
if (ImGui::SliderInt("Transform Level", &transformLevel, 0, 3)) {
|
|
u8 newFlags = 0;
|
|
for (int i = 0; i < transformLevel; i++) {
|
|
newFlags |= (1 << i);
|
|
}
|
|
statusB.mTransformLevelFlag = newFlags;
|
|
}
|
|
|
|
int darkClearLevel = 0;
|
|
for (int i = 0; i < 4; i++) {
|
|
if (statusB.mDarkClearLevelFlag & (1 << i)) {
|
|
darkClearLevel++;
|
|
}
|
|
}
|
|
if (ImGui::SliderInt("Twilight Clear Level", &darkClearLevel, 0, 3)) {
|
|
u8 newFlags = 0;
|
|
for (int i = 0; i < darkClearLevel; i++) {
|
|
newFlags |= (1 << i);
|
|
}
|
|
statusB.mDarkClearLevelFlag = newFlags;
|
|
}
|
|
}
|
|
|
|
void ImGuiSaveEditor::drawLocationTab() {
|
|
dSv_player_return_place_c& returnPlace = dComIfGs_getSaveData()->getPlayer().getPlayerReturnPlace();
|
|
dSv_horse_place_c& horsePlace = dComIfGs_getSaveData()->getPlayer().getHorsePlace();
|
|
ImGui::Text("Save Location");
|
|
|
|
ImGui::Text("Stage: ");
|
|
ImGui::SameLine();
|
|
char nameBuffer[8];
|
|
snprintf(nameBuffer, sizeof(nameBuffer), "%s", returnPlace.mName);
|
|
if (ImGui::InputText("##SaveStageNameInput", nameBuffer, 8)) {
|
|
strcpy(returnPlace.mName, nameBuffer);
|
|
}
|
|
|
|
ImGui::Text("Room: ");
|
|
ImGui::SameLine();
|
|
int tempRoom = returnPlace.mRoomNo;
|
|
if (ImGui::InputInt("##SaveRoomInput", &tempRoom)) {
|
|
returnPlace.mRoomNo = tempRoom;
|
|
}
|
|
|
|
ImGui::Text("Spawn ID: ");
|
|
ImGui::SameLine();
|
|
int tempSpawn = returnPlace.mPlayerStatus;
|
|
if (ImGui::InputInt("##SaveSpawnInput", &tempSpawn)) {
|
|
returnPlace.mPlayerStatus = tempSpawn;
|
|
}
|
|
|
|
ImGui::Separator();
|
|
|
|
ImGui::Text("Horse Location");
|
|
|
|
ImGui::Text("Position: ");
|
|
ImGui::SameLine();
|
|
Vec tempPos = horsePlace.mPos;
|
|
if (ImGui::InputFloat3("##HorsePosition", &tempPos.x)) {
|
|
horsePlace.mPos.x = tempPos.x;
|
|
horsePlace.mPos.y = tempPos.y;
|
|
horsePlace.mPos.z = tempPos.z;
|
|
}
|
|
|
|
ImGui::Text("Angle: ");
|
|
ImGui::SameLine();
|
|
int tempAngle = horsePlace.mAngleY;
|
|
if (ImGui::InputInt("##HorsePosition", &tempAngle)) {
|
|
horsePlace.mAngleY = tempAngle;
|
|
}
|
|
|
|
ImGui::Text("Stage: ");
|
|
ImGui::SameLine();
|
|
char horseStageBuffer[8];
|
|
snprintf(horseStageBuffer, sizeof(horseStageBuffer), "%s", horsePlace.mName);
|
|
if (ImGui::InputText("##HorseStageNameInput", horseStageBuffer, 8)) {
|
|
strcpy(horsePlace.mName, horseStageBuffer);
|
|
}
|
|
|
|
ImGui::Text("Room: ");
|
|
ImGui::SameLine();
|
|
int tempHorseRoom = horsePlace.mRoomNo;
|
|
if (ImGui::InputInt("##HorseRoomInput", &tempHorseRoom)) {
|
|
horsePlace.mRoomNo = tempHorseRoom;
|
|
}
|
|
|
|
ImGui::Text("Spawn ID: ");
|
|
ImGui::SameLine();
|
|
int tempHorseSpawn = horsePlace.mSpawnId;
|
|
if (ImGui::InputInt("##HorseSpawnInput", &tempHorseSpawn)) {
|
|
horsePlace.mSpawnId = tempHorseSpawn;
|
|
}
|
|
}
|
|
|
|
static u8 getSlotDefault(int slot) {
|
|
for (size_t i = 0; i < sizeof(sDefaultInventory) / sizeof(sDefaultInventory[0]); i++) {
|
|
if (sDefaultInventory[i].slot == slot) {
|
|
return sDefaultInventory[i].item;
|
|
}
|
|
}
|
|
return dItemNo_NONE_e;
|
|
}
|
|
|
|
void ImGuiSaveEditor::drawInventoryTab() {
|
|
dSv_player_item_c& item = dComIfGs_getSaveData()->getPlayer().getItem();
|
|
|
|
if (ImGui::TreeNode("Item Wheel")) {
|
|
if (ImGui::Button("Default All##inv_default_all")) {
|
|
for (int slot = 0; slot < 25; slot++) {
|
|
dComIfGs_setItem(slot, getSlotDefault(slot));
|
|
}
|
|
}
|
|
ImGui::SameLine();
|
|
if (ImGui::Button("Clear All##inv_clear_all")) {
|
|
for (int slot = 0; slot < 25; slot++) {
|
|
dComIfGs_setItem(slot, dItemNo_NONE_e);
|
|
}
|
|
}
|
|
|
|
ImGuiBeginGroupPanel("Items", { 200, 100 });
|
|
for (int slot = 0; slot < 25; slot++) {
|
|
ImGui::Text("Slot %02d (%s): ", slot, itemMap.find(getSlotDefault(slot))->second.m_name.c_str());
|
|
ImGui::SameLine(240.0f);
|
|
if (ImGui::BeginCombo(fmt::format("##ItemComboBox{}", slot).c_str(), itemMap.find(item.mItems[slot])->second.m_name.c_str())) {
|
|
if (ImGui::Selectable("None")) {
|
|
dComIfGs_setItem(slot, dItemNo_NONE_e);
|
|
}
|
|
|
|
for (int i = 0; i < 254; i++) {
|
|
if (itemMap.find(i)->second.m_type != ITEMTYPE_EQUIP_e) continue;
|
|
|
|
if (ImGui::Selectable(fmt::format("{0}##item_{1}{2}", itemMap.find(i)->second.m_name, slot, i).c_str())) {
|
|
dComIfGs_setItem(slot, itemMap.find(i)->first);
|
|
}
|
|
}
|
|
ImGui::EndCombo();
|
|
}
|
|
ImGui::SameLine();
|
|
if (ImGui::SmallButton(fmt::format("Default##slot_d_{}", slot).c_str())) {
|
|
dComIfGs_setItem(slot, getSlotDefault(slot));
|
|
}
|
|
ImGui::SameLine();
|
|
if (ImGui::SmallButton(fmt::format("Clear##slot_c_{}", slot).c_str())) {
|
|
dComIfGs_setItem(slot, dItemNo_NONE_e);
|
|
}
|
|
}
|
|
ImGuiEndGroupPanel();
|
|
|
|
ImGui::TreePop();
|
|
}
|
|
|
|
if (ImGui::TreeNode("Get Item Flags")) {
|
|
for (int i = 0; i < 254; i++) {
|
|
if (itemMap.find(i)->second.m_name == "Reserved") continue;
|
|
|
|
bool flag = dComIfGs_isItemFirstBit(i);
|
|
if (ImGui::Checkbox(fmt::format("{0}##item_{1}", itemMap.find(i)->second.m_name, i).c_str(), &flag)) {
|
|
if (flag)
|
|
dComIfGs_onItemFirstBit(i);
|
|
else
|
|
dComIfGs_offItemFirstBit(i);
|
|
}
|
|
}
|
|
|
|
ImGui::TreePop();
|
|
}
|
|
|
|
dSv_player_item_record_c& itemRecord = dComIfGs_getSaveData()->getPlayer().getItemRecord();
|
|
dSv_player_item_max_c& itemMax = dComIfGs_getSaveData()->getPlayer().getItemMax();
|
|
|
|
ImGuiBeginGroupPanel("Item Max Capacities", { 200, 100 });
|
|
ImGui::InputScalar("Arrows Max", ImGuiDataType_U8, &itemMax.mItemMax[0]);
|
|
ImGui::InputScalar("Normal Bombs Max", ImGuiDataType_U8, &itemMax.mItemMax[1]);
|
|
ImGui::InputScalar("Water Bombs Max", ImGuiDataType_U8, &itemMax.mItemMax[2]);
|
|
ImGui::InputScalar("Bomblings Max", ImGuiDataType_U8, &itemMax.mItemMax[3]);
|
|
ImGuiEndGroupPanel();
|
|
|
|
ImGuiBeginGroupPanel("Item Amounts", { 200, 100 });
|
|
ImGui::InputScalar("Arrows Amount", ImGuiDataType_U8, &itemRecord.mArrowNum);
|
|
ImGui::InputScalar("Slingshot Amount", ImGuiDataType_U8, &itemRecord.mPachinkoNum);
|
|
ImGui::InputScalar("Bomb Bag 1 Amount", ImGuiDataType_U8, &itemRecord.mBombNum[0]);
|
|
ImGui::InputScalar("Bomb Bag 2 Amount", ImGuiDataType_U8, &itemRecord.mBombNum[1]);
|
|
ImGui::InputScalar("Bomb Bag 3 Amount", ImGuiDataType_U8, &itemRecord.mBombNum[2]);
|
|
ImGui::InputScalar("Bottle 1 Amount", ImGuiDataType_U8, &itemRecord.mBottleNum[0]);
|
|
ImGui::InputScalar("Bottle 2 Amount", ImGuiDataType_U8, &itemRecord.mBottleNum[1]);
|
|
ImGui::InputScalar("Bottle 3 Amount", ImGuiDataType_U8, &itemRecord.mBottleNum[2]);
|
|
ImGui::InputScalar("Bottle 4 Amount", ImGuiDataType_U8, &itemRecord.mBottleNum[3]);
|
|
ImGuiEndGroupPanel();
|
|
}
|
|
|
|
static inline void setItemFirstBit(u8 itemNo, bool owned) {
|
|
if (owned) {
|
|
dComIfGs_onItemFirstBit(itemNo);
|
|
} else {
|
|
dComIfGs_offItemFirstBit(itemNo);
|
|
}
|
|
}
|
|
|
|
static inline void setEventBit(u16 flag, bool on) {
|
|
if (on) {
|
|
dComIfGs_onEventBit(flag);
|
|
} else {
|
|
dComIfGs_offEventBit(flag);
|
|
}
|
|
}
|
|
|
|
static void setLetterGetFlag(int idx, bool received) {
|
|
dSv_letter_info_c& info = dComIfGs_getSaveData()->getPlayer().getLetterInfo();
|
|
if (received) {
|
|
if (dComIfGs_isLetterGetFlag(idx)) return;
|
|
dComIfGs_onLetterGetFlag(idx);
|
|
u8 slot = dMeter2Info_getRecieveLetterNum() - 1;
|
|
if (slot < 64) {
|
|
dComIfGs_setGetNumber(slot, (u8)(idx + 1));
|
|
}
|
|
} else {
|
|
if (!dComIfGs_isLetterGetFlag(idx)) return;
|
|
info.mLetterGetFlags[idx >> 5] &= ~(1u << (idx & 0x1F));
|
|
for (int j = 0; j < 64; j++) {
|
|
if (dComIfGs_getGetNumber(j) == idx + 1) {
|
|
for (int k = j; k < 63; k++) {
|
|
dComIfGs_setGetNumber(k, dComIfGs_getGetNumber(k + 1));
|
|
}
|
|
dComIfGs_setGetNumber(63, 0);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ImGuiSaveEditor::drawCollectionTab() {
|
|
if (ImGui::TreeNode("Equipment")) {
|
|
if (ImGui::TreeNode("Swords")) {
|
|
static u8 sword_list[] = {
|
|
dItemNo_SWORD_e,
|
|
dItemNo_MASTER_SWORD_e,
|
|
dItemNo_WOOD_STICK_e,
|
|
dItemNo_LIGHT_SWORD_e,
|
|
};
|
|
|
|
for (int i = 0; i < 4; i++) {
|
|
bool got = dComIfGs_isItemFirstBit(sword_list[i]) != 0;
|
|
if (ImGui::Checkbox(fmt::format("{0}##sword_{1}", sSwordNames[i], i).c_str(), &got)) {
|
|
if (got) dComIfGs_onItemFirstBit(sword_list[i]);
|
|
else dComIfGs_offItemFirstBit(sword_list[i]);
|
|
}
|
|
}
|
|
ImGui::TreePop();
|
|
}
|
|
|
|
if (ImGui::TreeNode("Shields")) {
|
|
static u8 shield_list[] = {
|
|
dItemNo_SHIELD_e,
|
|
dItemNo_WOOD_SHIELD_e,
|
|
dItemNo_HYLIA_SHIELD_e,
|
|
};
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
bool got = dComIfGs_isItemFirstBit(shield_list[i]) != 0;
|
|
if (ImGui::Checkbox(fmt::format("{0}##shield_{1}", sShieldNames[i], i).c_str(), &got)) {
|
|
if (got) dComIfGs_onItemFirstBit(shield_list[i]);
|
|
else dComIfGs_offItemFirstBit(shield_list[i]);
|
|
}
|
|
}
|
|
ImGui::TreePop();
|
|
}
|
|
|
|
// TODO: the game checks if you're in ranch clothes, and if so won't display any other tunics in the menu
|
|
// find a way to deal with this later
|
|
if (ImGui::TreeNode("Tunics")) {
|
|
bool ordonClothes = dComIfGs_isItemFirstBit(dItemNo_WEAR_CASUAL_e) != 0;
|
|
if (ImGui::Checkbox("Ordon Clothes##tunic_ordon", &ordonClothes)) {
|
|
setItemFirstBit(dItemNo_WEAR_CASUAL_e, ordonClothes);
|
|
}
|
|
|
|
bool greenTunic = dComIfGs_isCollectClothes(KOKIRI_CLOTHES_FLAG) != 0;
|
|
if (ImGui::Checkbox("Hero's Clothes##tunic_green", &greenTunic)) {
|
|
if (greenTunic) dComIfGs_setCollectClothes(KOKIRI_CLOTHES_FLAG);
|
|
else dComIfGs_offCollectClothes(KOKIRI_CLOTHES_FLAG);
|
|
}
|
|
|
|
bool zoraArmor = dComIfGs_isItemFirstBit(dItemNo_WEAR_ZORA_e) != 0;
|
|
if (ImGui::Checkbox("Zora Armor##tunic_zora", &zoraArmor)) {
|
|
setItemFirstBit(dItemNo_WEAR_ZORA_e, zoraArmor);
|
|
}
|
|
|
|
bool magicArmor = dComIfGs_isItemFirstBit(dItemNo_ARMOR_e) != 0;
|
|
if (ImGui::Checkbox("Magic Armor##tunic_magic", &magicArmor)) {
|
|
setItemFirstBit(dItemNo_ARMOR_e, magicArmor);
|
|
}
|
|
ImGui::TreePop();
|
|
}
|
|
ImGui::TreePop();
|
|
}
|
|
|
|
if (ImGui::TreeNode("Key Items")) {
|
|
if (ImGui::TreeNode("Fused Shadows")) {
|
|
for (int i = 0; i < 3; i++) {
|
|
bool got = dComIfGs_isCollectCrystal((u8)i) != 0;
|
|
if (ImGui::Checkbox(
|
|
fmt::format("{0}##fs_{1}", sFusedShadowNames[i], i).c_str(), &got)) {
|
|
if (got) dComIfGs_onCollectCrystal((u8)i);
|
|
else dComIfGs_offCollectCrystal((u8)i);
|
|
}
|
|
}
|
|
ImGui::Spacing();
|
|
if (ImGui::Button("All##fs_all")) {
|
|
for (int i = 0; i < 3; i++) dComIfGs_onCollectCrystal((u8)i);
|
|
}
|
|
ImGui::SameLine();
|
|
if (ImGui::Button("None##fs_clear")) {
|
|
for (int i = 0; i < 3; i++) dComIfGs_offCollectCrystal((u8)i);
|
|
}
|
|
ImGui::TreePop();
|
|
}
|
|
|
|
if (ImGui::TreeNode("Mirror Shards")) {
|
|
for (int i = 0; i < 3; i++) {
|
|
u8 idx = sMirrorShards[i].index;
|
|
bool got = dComIfGs_isCollectMirror(idx) != 0;
|
|
if (ImGui::Checkbox(
|
|
fmt::format("{0}##ms_{1}", sMirrorShards[i].name, i).c_str(), &got)) {
|
|
if (got) dComIfGs_onCollectMirror(idx);
|
|
else dComIfGs_offCollectMirror(idx);
|
|
}
|
|
}
|
|
ImGui::Spacing();
|
|
if (ImGui::Button("All##ms_all")) {
|
|
for (int i = 0; i < 3; i++) dComIfGs_onCollectMirror(sMirrorShards[i].index);
|
|
}
|
|
ImGui::SameLine();
|
|
if (ImGui::Button("None##ms_clear")) {
|
|
for (int i = 0; i < 3; i++) dComIfGs_offCollectMirror(sMirrorShards[i].index);
|
|
}
|
|
ImGui::TreePop();
|
|
}
|
|
ImGui::TreePop();
|
|
}
|
|
|
|
if (ImGui::TreeNode("Heart Pieces & Poe Souls")) {
|
|
if (ImGui::TreeNode("Poe Souls")) {
|
|
int poeCount = dComIfGs_getPohSpiritNum();
|
|
ImGui::Text("Collected:");
|
|
ImGui::SameLine();
|
|
ImGui::SetNextItemWidth(100.0f);
|
|
if (ImGui::InputInt("##poe_count", &poeCount)) {
|
|
if (poeCount < 0) poeCount = 0;
|
|
if (poeCount > 60) poeCount = 60;
|
|
dComIfGs_setPohSpiritNum((u8)poeCount);
|
|
}
|
|
ImGui::SameLine();
|
|
ImGui::TextDisabled("/ 60");
|
|
ImGui::Spacing();
|
|
if (ImGui::Button("All 60##poe_all")) {
|
|
dComIfGs_setPohSpiritNum(60);
|
|
}
|
|
ImGui::SameLine();
|
|
if (ImGui::Button("Clear##poe_clear")) {
|
|
dComIfGs_setPohSpiritNum(0);
|
|
}
|
|
ImGui::TreePop();
|
|
}
|
|
|
|
if (ImGui::TreeNode("Heart Pieces")) {
|
|
int maxLife = dComIfGs_getMaxLife();
|
|
int hearts = maxLife / 5;
|
|
int pieces = maxLife % 5;
|
|
ImGui::Text("Max Life:");
|
|
ImGui::SameLine();
|
|
ImGui::SetNextItemWidth(160.0f);
|
|
if (ImGui::InputInt("##max_life", &maxLife, 1, 5)) {
|
|
if (maxLife < 15) maxLife = 15;
|
|
if (maxLife > 100) maxLife = 100;
|
|
dComIfGs_setMaxLife((u8)maxLife);
|
|
u16 maxHealth = (dComIfGs_getMaxLife() / 5) * 4;
|
|
if (dComIfGs_getLife() > maxHealth) {
|
|
dComIfGs_setLife(maxHealth);
|
|
}
|
|
}
|
|
ImGui::SameLine();
|
|
ImGui::TextDisabled("(%d hearts + %d pieces)", hearts, pieces);
|
|
ImGui::Spacing();
|
|
if (ImGui::Button("3 Hearts##hp_min")) {
|
|
dComIfGs_setMaxLife(15);
|
|
dComIfGs_setLife(12);
|
|
}
|
|
ImGui::SameLine();
|
|
if (ImGui::Button("20 Hearts##hp_max")) {
|
|
dComIfGs_setMaxLife(100);
|
|
dComIfGs_setLife(80);
|
|
}
|
|
ImGui::TreePop();
|
|
}
|
|
ImGui::TreePop();
|
|
}
|
|
|
|
if (ImGui::TreeNode("Golden Bugs")) {
|
|
if (ImGui::BeginTable("GoldenBugTable", 5,
|
|
ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_RowBg)) {
|
|
ImGui::TableSetupColumn("Species");
|
|
ImGui::TableSetupColumn("Male");
|
|
ImGui::TableSetupColumn("Female");
|
|
ImGui::TableSetupColumn("M \xe2\x86\x92 Agitha"); // M → Agitha
|
|
ImGui::TableSetupColumn("F \xe2\x86\x92 Agitha"); // F → Agitha
|
|
ImGui::TableHeadersRow();
|
|
|
|
for (int species = 0; species < BUG_SPECIES_COUNT; species++) {
|
|
int maleIdx = species * 2;
|
|
int femaleIdx = species * 2 + 1;
|
|
u8 maleItem = sBugItemIds[maleIdx];
|
|
u8 femaleItem = sBugItemIds[femaleIdx];
|
|
u16 maleFlag = sBugTurnInFlags[maleIdx];
|
|
u16 femaleFlag = sBugTurnInFlags[femaleIdx];
|
|
|
|
ImGui::TableNextRow();
|
|
|
|
ImGui::TableSetColumnIndex(0);
|
|
ImGui::TextUnformatted(sBugSpeciesNames[species]);
|
|
|
|
ImGui::TableSetColumnIndex(1);
|
|
bool maleOwned = dComIfGs_isItemFirstBit(maleItem) != 0;
|
|
if (ImGui::Checkbox(fmt::format("##bugM_own_{}", species).c_str(), &maleOwned)) {
|
|
setItemFirstBit(maleItem, maleOwned);
|
|
}
|
|
|
|
ImGui::TableSetColumnIndex(2);
|
|
bool femaleOwned = dComIfGs_isItemFirstBit(femaleItem) != 0;
|
|
if (ImGui::Checkbox(fmt::format("##bugF_own_{}", species).c_str(), &femaleOwned)) {
|
|
setItemFirstBit(femaleItem, femaleOwned);
|
|
}
|
|
|
|
ImGui::TableSetColumnIndex(3);
|
|
bool maleGiven = dComIfGs_isEventBit(maleFlag) != 0;
|
|
if (ImGui::Checkbox(fmt::format("##bugM_giv_{}", species).c_str(), &maleGiven)) {
|
|
setEventBit(maleFlag, maleGiven);
|
|
}
|
|
|
|
ImGui::TableSetColumnIndex(4);
|
|
bool femaleGiven = dComIfGs_isEventBit(femaleFlag) != 0;
|
|
if (ImGui::Checkbox(fmt::format("##bugF_giv_{}", species).c_str(), &femaleGiven)) {
|
|
setEventBit(femaleFlag, femaleGiven);
|
|
}
|
|
}
|
|
|
|
ImGui::EndTable();
|
|
}
|
|
|
|
ImGui::Spacing();
|
|
if (ImGui::Button("Collect All##bugs_all")) {
|
|
for (int i = 0; i < BUG_SPECIES_COUNT * 2; i++) {
|
|
dComIfGs_onItemFirstBit(sBugItemIds[i]);
|
|
}
|
|
}
|
|
ImGui::SameLine();
|
|
if (ImGui::Button("Clear All##bugs_clear")) {
|
|
for (int i = 0; i < BUG_SPECIES_COUNT * 2; i++) {
|
|
dComIfGs_offItemFirstBit(sBugItemIds[i]);
|
|
dComIfGs_offEventBit(sBugTurnInFlags[i]);
|
|
}
|
|
}
|
|
ImGui::SameLine();
|
|
if (ImGui::Button("Give All to Agitha##bugs_giveall")) {
|
|
for (int i = 0; i < BUG_SPECIES_COUNT * 2; i++) {
|
|
dComIfGs_onEventBit(sBugTurnInFlags[i]);
|
|
}
|
|
}
|
|
ImGui::TreePop();
|
|
}
|
|
|
|
if (ImGui::TreeNode("Hidden Skills")) {
|
|
for (int i = 0; i < HIDDEN_SKILL_COUNT; i++) {
|
|
bool learned = dComIfGs_isEventBit(sHiddenSkillFlags[i]) != 0;
|
|
if (ImGui::Checkbox(
|
|
fmt::format("{0}##skill_{1}", sHiddenSkillNames[i], i).c_str(), &learned)) {
|
|
setEventBit(sHiddenSkillFlags[i], learned);
|
|
}
|
|
}
|
|
ImGui::Spacing();
|
|
if (ImGui::Button("Learn All##skills_all")) {
|
|
for (int i = 0; i < HIDDEN_SKILL_COUNT; i++) {
|
|
dComIfGs_onEventBit(sHiddenSkillFlags[i]);
|
|
}
|
|
}
|
|
ImGui::SameLine();
|
|
if (ImGui::Button("Forget All##skills_clear")) {
|
|
for (int i = 0; i < HIDDEN_SKILL_COUNT; i++) {
|
|
dComIfGs_offEventBit(sHiddenSkillFlags[i]);
|
|
}
|
|
}
|
|
ImGui::TreePop();
|
|
}
|
|
|
|
if (ImGui::TreeNode("Collection Logs")) {
|
|
if (ImGui::TreeNode("Postman Letters")) {
|
|
for (int i = 0; i < LETTER_COUNT; i++) {
|
|
bool had = dComIfGs_isLetterGetFlag(i) != 0;
|
|
if (ImGui::Checkbox(
|
|
fmt::format("{0}##letter_{1}", sLetterSenders[i], i).c_str(), &had)) {
|
|
setLetterGetFlag(i, had);
|
|
}
|
|
}
|
|
ImGui::Spacing();
|
|
if (ImGui::Button("Receive All##letters_all")) {
|
|
for (int i = 0; i < LETTER_COUNT; i++) setLetterGetFlag(i, true);
|
|
}
|
|
ImGui::SameLine();
|
|
if (ImGui::Button("Clear All##letters_clear")) {
|
|
for (int i = 0; i < LETTER_COUNT; i++) setLetterGetFlag(i, false);
|
|
}
|
|
ImGui::TreePop();
|
|
}
|
|
|
|
if (ImGui::TreeNode("Fishing Log")) {
|
|
dSv_fishing_info_c& fish = dComIfGs_getSaveData()->getPlayer().getFishingInfo();
|
|
if (ImGui::BeginTable("FishTable", 3,
|
|
ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_RowBg)) {
|
|
ImGui::TableSetupColumn("Species");
|
|
ImGui::TableSetupColumn("Caught");
|
|
ImGui::TableSetupColumn("Biggest (cm)");
|
|
ImGui::TableHeadersRow();
|
|
|
|
for (int i = 0; i < FISH_COUNT; i++) {
|
|
u8 idx = sFishSpecies[i].index;
|
|
ImGui::TableNextRow();
|
|
|
|
ImGui::TableSetColumnIndex(0);
|
|
ImGui::TextUnformatted(sFishSpecies[i].name);
|
|
|
|
ImGui::TableSetColumnIndex(1);
|
|
int count = dComIfGs_getFishNum(idx);
|
|
ImGui::SetNextItemWidth(100.0f);
|
|
if (ImGui::InputInt(fmt::format("##fish_c_{}", i).c_str(), &count, 1, 10)) {
|
|
if (count < 0) count = 0;
|
|
if (count > 999) count = 999;
|
|
fish.mFishCount[idx] = (u16)count;
|
|
}
|
|
|
|
ImGui::TableSetColumnIndex(2);
|
|
int size = dComIfGs_getFishSize(idx);
|
|
ImGui::SetNextItemWidth(100.0f);
|
|
if (ImGui::InputInt(fmt::format("##fish_s_{}", i).c_str(), &size, 1, 10)) {
|
|
if (size < 0) size = 0;
|
|
if (size > 255) size = 255;
|
|
dComIfGs_setFishSize(idx, (u8)size);
|
|
}
|
|
}
|
|
ImGui::EndTable();
|
|
}
|
|
ImGui::TreePop();
|
|
}
|
|
ImGui::TreePop();
|
|
}
|
|
}
|
|
|
|
void drawFlagList(const char* id, BE(u32)& flags) {
|
|
u32 tempFlagField = flags;
|
|
|
|
for (int i = 31; i >= 0; i--) {
|
|
if ((31 - i) % 8) {
|
|
ImGui::SameLine();
|
|
}
|
|
|
|
bool flag = tempFlagField & (1 << i);
|
|
if (ImGui::Checkbox(fmt::format("{0}{1}", id, i).c_str(), &flag)) {
|
|
if (flag)
|
|
tempFlagField |= (1 << i);
|
|
else
|
|
tempFlagField &= ~(1 << i);
|
|
|
|
flags = tempFlagField;
|
|
}
|
|
}
|
|
}
|
|
|
|
static inline void genDungeonItemCheckbox(dSv_memBit_c& membit, const char* label, int flag) {
|
|
bool tempFlag = membit.isDungeonItem(flag);
|
|
if (ImGui::Checkbox(label, &tempFlag)) {
|
|
if (tempFlag)
|
|
membit.onDungeonItem(flag);
|
|
else
|
|
membit.offDungeonItem(flag);
|
|
}
|
|
}
|
|
|
|
static void genCommonAreaFlags(dSv_memBit_c& membit) {
|
|
ImGui::SetCursorPosY(ImGui::GetCursorPosY() + 10.0f);
|
|
|
|
genDungeonItemCheckbox(membit, "Got Map", dSv_memBit_c::MAP);
|
|
ImGui::SameLine(230.0f);
|
|
genDungeonItemCheckbox(membit, "Got Compass", dSv_memBit_c::COMPASS);
|
|
|
|
genDungeonItemCheckbox(membit, "Got Boss Key", dSv_memBit_c::BOSS_KEY);
|
|
ImGui::SameLine(230.0f);
|
|
genDungeonItemCheckbox(membit, "Saw Boss Demo", dSv_memBit_c::STAGE_BOSS_DEMO);
|
|
|
|
genDungeonItemCheckbox(membit, "Got Heart Container", dSv_memBit_c::STAGE_LIFE);
|
|
ImGui::SameLine(230.0f);
|
|
genDungeonItemCheckbox(membit, "Defeated Boss", dSv_memBit_c::STAGE_BOSS_ENEMY);
|
|
|
|
genDungeonItemCheckbox(membit, "Defeated Miniboss", dSv_memBit_c::STAGE_BOSS_ENEMY_2);
|
|
ImGui::SameLine(230.0f);
|
|
genDungeonItemCheckbox(membit, "Got Ooccoo", dSv_memBit_c::OOCCOO_NOTE);
|
|
|
|
int keyTemp = membit.getKeyNum();
|
|
if (ImGui::SliderInt("Keys", &keyTemp, 0, 5)) {
|
|
membit.setKeyNum(keyTemp);
|
|
}
|
|
}
|
|
|
|
static void genMembitFlags(const char* id, dSv_memBit_c& membit) {
|
|
ImGuiBeginGroupPanel("Chest", { 100, 100 });
|
|
for (int j = 0; j < 2; j++) {
|
|
drawFlagList(fmt::format("##_tbox{}", j).c_str(), membit.mTbox[j]);
|
|
}
|
|
ImGuiEndGroupPanel();
|
|
|
|
ImVec2 post_tbox_cursor = ImGui::GetCursorPos();
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGuiBeginGroupPanel("Switch", { 100, 100 });
|
|
for (int j = 0; j < 4; j++) {
|
|
drawFlagList(fmt::format("##_switch{}", j).c_str(), membit.mSwitch[j]);
|
|
}
|
|
ImGuiEndGroupPanel();
|
|
|
|
ImVec2 post_switch_cursor = ImGui::GetCursorPos();
|
|
|
|
ImGui::SetCursorPos(post_tbox_cursor);
|
|
|
|
ImGuiBeginGroupPanel("Item", { 100, 100 });
|
|
for (int j = 0; j < 1; j++) {
|
|
drawFlagList(fmt::format("##_item{}", j).c_str(), membit.mItem[j]);
|
|
}
|
|
ImGuiEndGroupPanel();
|
|
ImVec2 post_item_custor = ImGui::GetCursorPos();
|
|
|
|
ImGui::SetCursorPos({post_item_custor.x, post_switch_cursor.y});
|
|
// genCommonAreaFlags(membit);
|
|
}
|
|
|
|
template <typename FlagIter, typename FlagTester>
|
|
requires requires(FlagIter a, FlagTester tester) {
|
|
--a; ++a; a < a; *a;
|
|
a + 1;
|
|
{ tester(*a) } -> std::convertible_to<bool>;
|
|
}
|
|
static void sortByFlags(FlagIter begin, FlagIter end, FlagTester&& flagTester) {
|
|
if (begin == end) return;
|
|
|
|
auto fullEnd = end;
|
|
|
|
// We want to find the location of where we can swap our `On` flags to.
|
|
// We're gonna put the `Off` bits first, and the `On` bits last. 0 < 1
|
|
// We can achieve this by skipping all the `On` bits at the end.
|
|
|
|
// backtrack until we find a bit that is off
|
|
while (begin < --end && flagTester(*end)) {
|
|
// move the end pointer back while we find on bits
|
|
}
|
|
|
|
// end should now be pointing to a bit that is off
|
|
while (begin < end) {
|
|
// if there's a flag that's on
|
|
if (flagTester(*begin)) {
|
|
// move it to the end
|
|
std::rotate(begin, begin + 1, fullEnd);
|
|
// move back the end of where we're checking
|
|
--end;
|
|
// begin will now point to the next piece of data
|
|
// because we've rotated the data >= begin to the left
|
|
} else {
|
|
// not on, check next flag
|
|
++begin;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void genAreaFlagTable(uint8_t areaIndex, dSv_memBit_c& membit) {
|
|
const auto LoadFlag = [&](const EventAreaFlags& flag) -> bool {
|
|
switch (flag.flag.type) {
|
|
case AreaFlagType::Item: {
|
|
return membit.isItem(flag.flag.flagID);
|
|
} break;
|
|
case AreaFlagType::Switch: {
|
|
return membit.isSwitch(flag.flag.flagID);
|
|
} break;
|
|
case AreaFlagType::Tbox: {
|
|
return membit.isTbox(flag.flag.flagID);
|
|
} break;
|
|
}
|
|
return false;
|
|
};
|
|
|
|
const auto SetFlag = [&](const AreaFlagInd& flag, bool set) -> void {
|
|
if (set) {
|
|
switch (flag.type) {
|
|
case AreaFlagType::Item: {
|
|
membit.onItem(flag.flagID);
|
|
} break;
|
|
case AreaFlagType::Switch: {
|
|
membit.onSwitch(flag.flagID);
|
|
} break;
|
|
case AreaFlagType::Tbox: {
|
|
membit.onTbox(flag.flagID);
|
|
} break;
|
|
}
|
|
} else {
|
|
switch (flag.type) {
|
|
case AreaFlagType::Item: {
|
|
membit.offItem(flag.flagID);
|
|
} break;
|
|
case AreaFlagType::Switch: {
|
|
membit.offSwitch(flag.flagID);
|
|
} break;
|
|
case AreaFlagType::Tbox: {
|
|
membit.offTbox(flag.flagID);
|
|
} break;
|
|
}
|
|
}
|
|
};
|
|
|
|
const auto LoadMultiByteFlag = [&](const AreaFlagMultibit& flag) -> uint8_t {
|
|
BE(u32)* areaFlags = nullptr;
|
|
switch (flag.type) {
|
|
case AreaFlagType::Item: {
|
|
areaFlags = membit.mItem;
|
|
} break;
|
|
case AreaFlagType::Switch: {
|
|
areaFlags = membit.mSwitch;
|
|
} break;
|
|
case AreaFlagType::Tbox: {
|
|
areaFlags = membit.mTbox;
|
|
} break;
|
|
}
|
|
assert(areaFlags != nullptr);
|
|
return (areaFlags[flag.index] & flag.mask) >> flag.shift;
|
|
};
|
|
|
|
const auto SetMultiByteFlag = [&](const AreaFlagMultibit& flag, uint8_t val) -> void {
|
|
BE(u32)* areaFlags = nullptr;
|
|
switch (flag.type) {
|
|
case AreaFlagType::Item: {
|
|
areaFlags = membit.mItem;
|
|
} break;
|
|
case AreaFlagType::Switch: {
|
|
areaFlags = membit.mSwitch;
|
|
} break;
|
|
case AreaFlagType::Tbox: {
|
|
areaFlags = membit.mTbox;
|
|
} break;
|
|
}
|
|
|
|
areaFlags[flag.index] &= ~flag.mask;
|
|
areaFlags[flag.index] |= (val << flag.shift) & flag.mask;
|
|
};
|
|
|
|
auto iter = imguiAreaFlagLookup.find(areaIndex);
|
|
if (iter == imguiAreaFlagLookup.end()) return;
|
|
|
|
auto& areaFlags = iter->second;
|
|
|
|
static ImGuiTextFilter filter;
|
|
filter.Draw(); // Search bar
|
|
|
|
ImVec2 flagTableSize = {700, 400};
|
|
if (ImGui::BeginTable("Area Flags", 3,
|
|
ImGuiTableFlags_ScrollY | ImGuiTableFlags_ScrollX |
|
|
ImGuiTableFlags_Sortable,
|
|
flagTableSize))
|
|
{
|
|
ImGui::TableSetupScrollFreeze(0, 1);
|
|
constexpr int COLUMN_FLAG = 0, COLUMN_BIT = 1, COLUMN_DESC = 2;
|
|
ImGui::TableSetupColumn("Flag");
|
|
ImGui::TableSetupColumn("Byte:Bit");
|
|
ImGui::TableSetupColumn("Description");
|
|
ImGui::TableHeadersRow();
|
|
|
|
// if we're sorting by whether the flag is set or not,
|
|
// we want to re-sort whenever a flag updates, which means every frame cuz we don't
|
|
// know when it changes. otherwise only re-sort when the sort is dirty
|
|
if (auto* sort = ImGui::TableGetSortSpecs();
|
|
sort != nullptr && sort->SpecsCount > 0 &&
|
|
(sort->SpecsDirty || sort->Specs[0].ColumnIndex == COLUMN_FLAG))
|
|
{
|
|
const auto column = sort->Specs[0].ColumnIndex;
|
|
const auto direction = sort->Specs[0].SortDirection;
|
|
|
|
// if we're sorting by flags, do special sort, regular sort is bad for sorting
|
|
// bools it can swap values that are the same, and that causes constant
|
|
// reordering
|
|
if (column == COLUMN_FLAG) {
|
|
if (direction == ImGuiSortDirection_Ascending) {
|
|
sortByFlags(std::begin(areaFlags.bitFlags), std::end(areaFlags.bitFlags),
|
|
LoadFlag);
|
|
} else {
|
|
sortByFlags(std::rbegin(areaFlags.bitFlags), std::rend(areaFlags.bitFlags),
|
|
LoadFlag);
|
|
}
|
|
} else {
|
|
const auto cmp = [column](const EventAreaFlags& l,
|
|
const EventAreaFlags& r) -> bool {
|
|
switch (column) {
|
|
case COLUMN_DESC:
|
|
return l.description < r.description;
|
|
case COLUMN_BIT:
|
|
return l.GetFlagID() < r.GetFlagID();
|
|
}
|
|
return false;
|
|
};
|
|
|
|
if (direction == ImGuiSortDirection_Ascending) {
|
|
std::sort(std::begin(areaFlags.bitFlags), std::end(areaFlags.bitFlags),
|
|
cmp);
|
|
} else {
|
|
std::sort(std::rbegin(areaFlags.bitFlags), std::rend(areaFlags.bitFlags),
|
|
cmp);
|
|
}
|
|
}
|
|
|
|
sort->SpecsDirty = false;
|
|
}
|
|
|
|
for (const auto& e : areaFlags.bitFlags) {
|
|
std::string formattedBitLocation =
|
|
fmt::format("{0:02X}:{1:02X}", e.byteIndex, e.bitIndex);
|
|
|
|
if (!filter.PassFilter(e.description.c_str()) &&
|
|
!filter.PassFilter(formattedBitLocation.c_str()))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
ImGui::TableNextRow();
|
|
ImGui::TableNextColumn();
|
|
bool flag = LoadFlag(e);
|
|
if (ImGui::Checkbox(fmt::format("##_unused_area_flag_{}", e.flag.flagID).c_str(), &flag)) {
|
|
SetFlag(e.flag, flag);
|
|
}
|
|
|
|
ImGui::TableNextColumn();
|
|
ImGui::TextUnformatted(formattedBitLocation.c_str());
|
|
ImGui::TableNextColumn();
|
|
ImGui::TextUnformatted(e.description.c_str());
|
|
}
|
|
ImGui::EndTable();
|
|
}
|
|
|
|
for (const auto& multiByteFlag : areaFlags.multibyteFlags) {
|
|
auto flagValue = LoadMultiByteFlag(multiByteFlag.flag);
|
|
|
|
const char* currentVal = "UNKNOWN";
|
|
|
|
auto enumValIter = multiByteFlag.enumValues.find(flagValue);
|
|
if (enumValIter != multiByteFlag.enumValues.end()) {
|
|
currentVal = enumValIter->second;
|
|
}
|
|
|
|
if (ImGui::BeginCombo(multiByteFlag.name, currentVal)) {
|
|
for (const auto& [val, name] : multiByteFlag.enumValues) {
|
|
if (ImGui::Selectable(name)) {
|
|
SetMultiByteFlag(multiByteFlag.flag, val);
|
|
}
|
|
}
|
|
ImGui::EndCombo();
|
|
}
|
|
}
|
|
|
|
genCommonAreaFlags(membit);
|
|
}
|
|
|
|
static void drawCurrentRegionFlags()
|
|
{
|
|
dSv_memBit_c& membit = g_dComIfG_gameInfo.info.mMemory.mBit;
|
|
auto* stageData = dComIfGp_getStageStagInfo();
|
|
if (!stageData)
|
|
return;
|
|
uint8_t stageIndex = dStage_stagInfo_GetSaveTbl(stageData);
|
|
|
|
genAreaFlagTable(stageIndex, membit);
|
|
|
|
if (ImGui::TreeNode("Flag Matrix")) {
|
|
genMembitFlags("##TempSceneFlags", membit);
|
|
ImGui::TreePop();
|
|
}
|
|
|
|
stage_stag_info_class* pstag = dComIfGp_getStageStagInfo();
|
|
if (pstag != nullptr) {
|
|
int stageNo = dStage_stagInfo_GetSaveTbl(pstag);
|
|
if (ImGui::Button("Save##SaveTempFlags")) {
|
|
dComIfGs_putSave(stageNo);
|
|
}
|
|
|
|
ImGui::SameLine();
|
|
|
|
if (ImGui::Button("Load##LoadSaveFlags")) {
|
|
dComIfGs_getSave(stageNo);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ImGuiSaveEditor::drawFlagsTab() {
|
|
if (ImGui::TreeNode("Current Region Flags")) {
|
|
drawCurrentRegionFlags();
|
|
ImGui::TreePop();
|
|
}
|
|
|
|
if (ImGui::TreeNode("Region Saved Flags")) {
|
|
static const std::map<uint8_t, const char*> regionNames = {
|
|
{ 0x00, "Ordon" },
|
|
{ 0x01, "Hyrule Sewers" },
|
|
{ 0x02, "Faron" },
|
|
{ 0x03, "Eldin" },
|
|
{ 0x04, "Lanayru" },
|
|
{ 0x06, "Hyrule Field" },
|
|
{ 0x07, "Sacred Grove" },
|
|
{ 0x08, "Snowpeak" },
|
|
{ 0x09, "Castle Town" },
|
|
{ 0x0A, "Gerudo Desert" },
|
|
{ 0x0B, "Fishing Pond" },
|
|
{ 0x10, "Forest Temple" },
|
|
{ 0x11, "Goron Mines" },
|
|
{ 0x12, "Lakebed Temple" },
|
|
{ 0x13, "Arbiter's Grounds" },
|
|
{ 0x14, "Snowpeak Ruins" },
|
|
{ 0x15, "Temple of Time" },
|
|
{ 0x16, "City in the Sky" },
|
|
{ 0x17, "Palace of Twilight" },
|
|
{ 0x18, "Hyrule Castle" },
|
|
{ 0x19, "Caves" },
|
|
{ 0x1A, "Lake Hylia Long Cave"},
|
|
{ 0x1B, "Grottos" }
|
|
};
|
|
|
|
if (m_selectedRegion.name == nullptr)
|
|
{
|
|
const auto& firstRegion = *regionNames.find(0);
|
|
m_selectedRegion = { firstRegion.first, firstRegion.second };
|
|
}
|
|
|
|
if (ImGui::BeginCombo("Region", m_selectedRegion.name)) {
|
|
for (const auto& [id, name] : regionNames) {
|
|
if (ImGui::Selectable(name)) {
|
|
m_selectedRegion = {id, name};
|
|
}
|
|
}
|
|
ImGui::EndCombo();
|
|
}
|
|
|
|
dSv_memBit_c& membit = dComIfGs_getSaveData()->mSave[m_selectedRegion.id].mBit;
|
|
|
|
genAreaFlagTable(m_selectedRegion.id, membit);
|
|
|
|
if (ImGui::TreeNode("Flag Matrix")) {
|
|
genMembitFlags("##SaveSceneFlags", membit);
|
|
|
|
ImGui::TreePop();
|
|
}
|
|
|
|
ImGui::TreePop();
|
|
}
|
|
|
|
if (ImGui::TreeNode("Event Flags")) {
|
|
dSv_event_c& event = dComIfGs_getSaveData()->mEvent;
|
|
|
|
static ImGuiTextFilter filter;
|
|
filter.Draw(); // Search bar
|
|
|
|
ImVec2 flagTableSize = {700, 400};
|
|
if (ImGui::BeginTable("Events", 4,
|
|
ImGuiTableFlags_ScrollY | ImGuiTableFlags_ScrollX | ImGuiTableFlags_Sortable,
|
|
flagTableSize))
|
|
{
|
|
ImGui::TableSetupScrollFreeze(0, 1);
|
|
constexpr int COLUMN_FLAG = 0, COLUMN_NAME = 1, COLUMN_LOC = 2, COLUMN_DESC = 3;
|
|
ImGui::TableSetupColumn("Flag");
|
|
ImGui::TableSetupColumn("Name");
|
|
ImGui::TableSetupColumn("Location");
|
|
ImGui::TableSetupColumn("Description");
|
|
ImGui::TableHeadersRow();
|
|
|
|
// if we're sorting by whether the flag is set or not,
|
|
// we want to re-sort whenever a flag updates, which means every frame cuz we don't know when it changes.
|
|
// otherwise only re-sort when the sort is dirty
|
|
if (auto* sort = ImGui::TableGetSortSpecs();
|
|
sort != nullptr && sort->SpecsCount > 0 &&
|
|
(sort->SpecsDirty || sort->Specs[0].ColumnIndex == COLUMN_FLAG))
|
|
{
|
|
const auto column = sort->Specs[0].ColumnIndex;
|
|
const auto direction = sort->Specs[0].SortDirection;
|
|
|
|
// if we're sorting by flags, do special sort, regular sort is bad for sorting bools
|
|
// it can swap values that are the same, and that causes constant reordering
|
|
if (column == COLUMN_FLAG) {
|
|
const auto testEventFunc = [&event](const duskImguiEventFlagEntry& flag) -> bool {
|
|
return event.isEventBit(flag.flagID);
|
|
};
|
|
|
|
if (direction == ImGuiSortDirection_Ascending) {
|
|
sortByFlags(std::begin(duskImguiEventFlags),
|
|
std::end(duskImguiEventFlags), testEventFunc);
|
|
} else {
|
|
sortByFlags(std::rbegin(duskImguiEventFlags),
|
|
std::rend(duskImguiEventFlags), testEventFunc);
|
|
}
|
|
} else {
|
|
const auto cmp = [column](const duskImguiEventFlagEntry& l,
|
|
const duskImguiEventFlagEntry& r) -> bool {
|
|
switch (column) {
|
|
case COLUMN_NAME: return l.flagName < r.flagName;
|
|
case COLUMN_LOC: return l.location < r.location;
|
|
case COLUMN_DESC: return l.description < r.description;
|
|
default: return false;
|
|
}
|
|
};
|
|
|
|
if (direction == ImGuiSortDirection_Ascending) {
|
|
std::sort(std::begin(duskImguiEventFlags),
|
|
std::end(duskImguiEventFlags), cmp);
|
|
} else {
|
|
std::sort(std::rbegin(duskImguiEventFlags),
|
|
std::rend(duskImguiEventFlags), cmp);
|
|
}
|
|
}
|
|
|
|
sort->SpecsDirty = false;
|
|
}
|
|
|
|
for (const auto& e : duskImguiEventFlags) {
|
|
if (!filter.PassFilter(e.location.c_str()) &&
|
|
!filter.PassFilter(e.description.c_str()) &&
|
|
!filter.PassFilter(e.flagName.c_str()))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
ImGui::TableNextRow();
|
|
ImGui::TableNextColumn();
|
|
bool flag = event.getEventReg(e.flagID);
|
|
if (ImGui::Checkbox(("##" + e.flagName).c_str(), &flag)) {
|
|
if (flag) {
|
|
event.onEventBit(e.flagID);
|
|
} else {
|
|
event.offEventBit(e.flagID);
|
|
}
|
|
}
|
|
|
|
ImGui::TableNextColumn();
|
|
ImGuiStringViewText(e.flagName);
|
|
ImGui::TableNextColumn();
|
|
ImGuiStringViewText(e.location);
|
|
ImGui::TableNextColumn();
|
|
ImGuiStringViewText(e.description);
|
|
}
|
|
ImGui::EndTable();
|
|
}
|
|
|
|
// event values that are stored as u8s in the event flags
|
|
for (const auto& e : duskImguiU8Events) {
|
|
int v = event.mEvent[e.byteInd];
|
|
if (ImGui::InputInt(e.description, &v)) {
|
|
v = std::clamp(v, 0, 0xff);
|
|
event.mEvent[e.byteInd] = (u8)v;
|
|
}
|
|
}
|
|
|
|
// event values that are stored as u16s in the event flags
|
|
for (const auto& e : duskImguiU16Events) {
|
|
int v = (event.mEvent[e.byteInd] << 8) | event.mEvent[e.byteInd + 1];
|
|
if (ImGui::InputInt(e.description, &v)) {
|
|
v = std::clamp(v, 0, 0xffff);
|
|
event.mEvent[e.byteInd] = (u8)(v >> 8);
|
|
event.mEvent[e.byteInd + 1] = (u8)v;
|
|
}
|
|
}
|
|
|
|
// event values that are stored as swapped u16s in the event flags
|
|
for (const auto& e : duskImguiSwappedU16Events) {
|
|
int v = (event.mEvent[e.byteInd + 1] << 8) | event.mEvent[e.byteInd];
|
|
if (ImGui::InputInt(e.description, &v)) {
|
|
v = std::clamp(v, 0, 0xffff);
|
|
event.mEvent[e.byteInd + 1] = (u8)(v >> 8);
|
|
event.mEvent[e.byteInd] = (u8)v;
|
|
}
|
|
}
|
|
|
|
if (ImGui::TreeNode("Event Matrix")) {
|
|
for (int e = 0; e < 255; e++) {
|
|
ImGui::Text("%03d ", e);
|
|
ImGui::SameLine(80.0f);
|
|
for (int i = 7; i >= 0; i--) {
|
|
bool flag = event.mEvent[e] & (1 << i);
|
|
if (ImGui::Checkbox(fmt::format("##event{0}{1}", e, i).c_str(), &flag)) {
|
|
if (flag)
|
|
event.mEvent[e] |= (1 << i);
|
|
else
|
|
event.mEvent[e] &= ~(1 << i);
|
|
}
|
|
ImGui::SameLine();
|
|
}
|
|
ImGui::NewLine();
|
|
}
|
|
ImGui::TreePop();
|
|
}
|
|
ImGui::TreePop();
|
|
}
|
|
}
|
|
|
|
void ImGuiSaveEditor::drawMinigameTab() {
|
|
dSv_MiniGame_c& minigame = dComIfGs_getSaveData()->getMiniGame();
|
|
InputScalarBE("STAR Game Time (Milliseconds)", ImGuiDataType_U32, &minigame.mHookGameTime);
|
|
InputScalarBE("Snowboard Race Time (Milliseconds)", ImGuiDataType_U32, &minigame.mRaceGameTime);
|
|
InputScalarBE("Fruit-Pop-Flight Score", ImGuiDataType_U32, &minigame.mBalloonScore);
|
|
}
|
|
|
|
void ImGuiSaveEditor::drawConfigTab() {
|
|
dSv_player_config_c& config = dComIfGs_getSaveData()->getPlayer().getConfig();
|
|
ImGui::Checkbox("Enable Vibration", (bool*)&config.mVibration);
|
|
|
|
static const char* kTargetTypeNames[] = {"Hold", "Switch"};
|
|
if (ImGui::BeginCombo("Target Type", kTargetTypeNames[config.mAttentionType])) {
|
|
if (ImGui::Selectable("Hold")) {
|
|
config.mAttentionType = 0;
|
|
}
|
|
if (ImGui::Selectable("Switch")) {
|
|
config.mAttentionType = 1;
|
|
}
|
|
ImGui::EndCombo();
|
|
}
|
|
|
|
static const char* kSoundModeNames[] = { "Mono", "Stereo", "Surround" };
|
|
const char* current = (config.mSoundMode < 3) ? kSoundModeNames[config.mSoundMode]
|
|
: "Unknown";
|
|
if (ImGui::BeginCombo("Sound", current)) {
|
|
for (u8 i = 0; i < 3; i++) {
|
|
bool selected = (config.mSoundMode == i);
|
|
if (ImGui::Selectable(kSoundModeNames[i], selected)) {
|
|
config.mSoundMode = i;
|
|
}
|
|
if (selected) ImGui::SetItemDefaultFocus();
|
|
}
|
|
ImGui::EndCombo();
|
|
}
|
|
}
|
|
}
|