Guest User

inindo SRAM map as c++ structs/enum

a guest
May 23rd, 2020
52
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #ifndef inc_save
  2. #define inc_save
  3.  
  4. #include "types.h"
  5. #include "enumerations.h"
  6.  
  7. #pragma pack(push)
  8. #pragma pack(1)
  9. namespace inindo
  10. {
  11.     enum lineup_t : u08
  12.     {
  13.         front_right,
  14.         front_center,
  15.         front_left,
  16.         rear_right,
  17.         rear_center,
  18.         rear_left,
  19.     };
  20.  
  21.     enum location_type_t : u08
  22.     {
  23.         castle,
  24.         inn,
  25.         tea,
  26.         unk,
  27.     };
  28.  
  29.     enum game_mode_t : u08
  30.     {
  31.         normal,
  32.         sorcerer,
  33.     };
  34.  
  35.     struct state_data_t
  36.     {
  37.         // 000
  38.         u08 head[2];
  39.         struct date_t
  40.         {
  41.             // 002
  42.             u08 year;
  43.             // 003
  44.             u08 month;
  45.             // 004
  46.             u08 day;
  47.             // 005
  48.             u08 time;
  49.         } date;
  50.         // 006
  51.         u08 unk0;
  52.         // 007
  53.         // energy left before rest needed
  54.         // max 180 = 60 time units * 3 days
  55.         u08 wakefulness;
  56.         // 008
  57.         // unknown
  58.         // 009
  59.         // high nibble = step (8)
  60.         // low nibble = facing direction (NWES = 0123)
  61.         // 00a
  62.         // unknown
  63.         u08 unk1[3];
  64.         // 00b
  65.         u16 unk2[2];
  66.         // 00f
  67.         struct party_t
  68.         {
  69.             // 00f
  70.             struct location_t
  71.             {
  72.                 // world (nihon) map position
  73.                 // 00f
  74.                 u16 w[4];
  75.                 // sub-map position (town, dungeon, ...)
  76.                 // 017
  77.                 u16 x;
  78.                 // 019
  79.                 u16 y;
  80.             } location;
  81.             // 01b
  82.             u16 gold;
  83.             // 01d
  84.             u08 size;
  85.             // 01e
  86.             u08 member_id[3];
  87.             // combat formation
  88.             // 021
  89.             lineup_t lineup[3];
  90.             // 024
  91.             struct flags_t
  92.             {
  93.                 // poison shows over injury
  94.                 u08 poison : 1;
  95.                 u08 injury : 1;
  96.                 // aphrodisia (eel extract) shows over poison or injury
  97.                 // makes you walk in random directions (?)
  98.                 // shows as "blind" in the US version
  99.                 // has own icon in the Japanese version
  100.                 u08 aphrodisia : 1;
  101.                 // other bits show up as injury (?)
  102.                 u08 unk45678 : 5;
  103.             } flags[3];
  104.             // 027
  105.             item_id_t inventory[3][15];
  106.         } party;
  107.         //
  108.         struct pawn_t
  109.         {
  110.             u08 thousand_gold;
  111.             item_id_t slot[31];
  112.         } pawn;
  113.         //
  114.         struct bingo_t
  115.         {
  116.             u16 lowclass_chips;
  117.             u16 highclass_chips;
  118.         } bingo;
  119.         // 078
  120.         u08 player_level;
  121.         // 079
  122.         u16 unk3[24];
  123.         // 0a9
  124.         char name[11];
  125.         // 0b4
  126.         struct character_status_t
  127.         {
  128.             // static (ROM) character description index
  129.             u08 character_index;
  130.             // linked list starting from location flags
  131.             // status index, not description index
  132.             // +01 = b5
  133.             u08 with_index;
  134.             // +02 = b6
  135.             u16 max_health;
  136.             // +04 = b8
  137.             u16 health;
  138.             // +06 = ba
  139.             u16 max_energy;
  140.             // +08 = bc
  141.             u16 energy;
  142.             // +0a = be
  143.             u16 exp_needed;
  144.             // +0c = c0
  145.             u08 level;
  146.             // +0d = c1
  147.             struct flags_bitset_t
  148.             {
  149.                 location_type_t location_type : 2;
  150.                 u08 unk345678 : 6;
  151.             } flags;
  152.             // +0e = c2
  153.             u08 familiarity;
  154.             // +0f = c3
  155.             u08 intelligence;
  156.             // +10 = c4
  157.             u08 speed;
  158.             // +11 = c5
  159.             u08 luck;
  160.             // +12 = c6
  161.             u16 magic;
  162.             // +14 = c8
  163.             u08 defense;
  164.             // +15 = c9
  165.             u08 resist;
  166.             // +16 = ca
  167.             u08 power;
  168.             // +17 = cb - cf
  169.             item_id_t equipped[5];
  170.             // +1c = d0 - d2
  171.             u08 ai_data[3];
  172.             // +1f = d3
  173.             struct ai_status_t
  174.             {
  175.                 character_ai_command_t command : 4;
  176.                 u08 congeniality : 2;
  177.                 u08 unk : 2;
  178.             } ai_status;
  179.         } status[63];
  180.         // 894
  181.         u08 generals[104];
  182.         // 8fc
  183.         struct ruler_t
  184.         {
  185.             // general ID
  186.             // index in data.general (?)
  187.             u08 id;
  188.             // generals in home province (?)
  189.             u08 generals;
  190.         } rulers[16];
  191.  
  192.         // 91c
  193.         struct province_t
  194.         {
  195.             // 00
  196.             u08 ruler;
  197.             // 01
  198.             u08 daimyo;
  199.             // 02
  200.             u16 gold;
  201.             // 04
  202.             u16 rice;
  203.             // 06
  204.             u16 soldiers;
  205.             // 08
  206.             u08 arms;
  207.             // 09
  208.             u08 training;
  209.             // 0a
  210.             u08 person[3];
  211.             // 0d
  212.             u08 trust[3];
  213.             struct ai_status_t
  214.             {
  215.                 // 10
  216.                 province_id_t target_province : 5;
  217.                 province_ai_algorithm_t algorithm : 3;
  218.                 // 11
  219.                 u08 people : 2;
  220.                 province_ai_command_t command : 2;
  221.                 u08 unk : 4;
  222.             } ai_status;
  223.         } province[30];
  224.         // b38
  225.         struct location_flags_t
  226.         {
  227.             // linked list end via status indices
  228.             u08 visitor : 8;
  229.             u16 unk1 : 15;
  230.             // the player has visited this location
  231.             u16 visited : 1;
  232.         } location[48];
  233.         // bc8
  234.         // most even bytes = 0, few change to 2
  235.         u08 unk5[828];
  236.         // f04
  237.         // game flags
  238.         // 0 - 17: 0 (null), 1 (active) or 2 (complete)
  239.         // 18 is game mode: 0 (normal), 1 (magical)
  240.         // 19 is unknown
  241.         u08 flag[20];
  242.     };
  243.  
  244.     // container that implements checksum functions
  245.     struct save_container_t
  246.     {
  247.         u16 compute_checksum(const void *pdata, int length)
  248.         {
  249.             u08 *p = (u08 *)pdata;
  250.             u16 checksum = 0;
  251.             for (int i = 0; i < length; i++) {
  252.                 checksum += p[i];
  253.             }
  254.             return checksum;
  255.         }
  256.        
  257.         bool fix_checksum()
  258.         {
  259.             const int game_data_size = sizeof(state_data_t);
  260.             ASSERT(game_data_size == 3864);
  261.             u16 new_checksum = compute_checksum(&state, game_data_size);
  262.             if (new_checksum == checksum) {
  263.                 return false;
  264.             } else {
  265.                 checksum = new_checksum;
  266.                 return true;
  267.             }
  268.         }
  269.  
  270.         bool is_dirty()
  271.         {
  272.             const int game_data_size = sizeof(state_data_t);
  273.             ASSERT(game_data_size == 3864);
  274.             u16 new_checksum = compute_checksum(&state, game_data_size);
  275.             return (new_checksum != checksum);
  276.         }
  277.  
  278.         void write(const char *filename);
  279.  
  280.         // 000
  281.         state_data_t state;
  282.         // f18
  283.         u16 checksum;
  284.         // f1a
  285.         char koei[4];
  286.         // f1e
  287.         u08 padding[226];
  288.     };
  289. };
  290. #pragma pack(pop)
  291.  
  292. #endif
RAW Paste Data Copied