daily pastebin goal
26%
SHARE
TWEET

Untitled

a guest Jan 4th, 2018 25 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <fstream>
  2. #include <vector>
  3. #include <stdint.h>
  4.  
  5. int main(int argc, char **argv)
  6. {
  7.     auto filename = argv[1];
  8.  
  9.     std::ifstream ifs{ filename, std::ios::binary | std::ios::ate };
  10.     std::ifstream::pos_type pos = ifs.tellg();
  11.    
  12.     auto size = (size_t)pos;
  13.     std::vector<char> file_bytes;
  14.  
  15.     file_bytes.resize(size);
  16.  
  17.     ifs.seekg(0, std::ios::beg);
  18.     ifs.read(file_bytes.data(), size);
  19.     ifs.close();
  20.  
  21.     auto krName = std::string(filename).substr(0, strlen(filename) - 4) + ".kr";
  22.  
  23. #pragma pack(push, 1)
  24.     struct GrscHeader
  25.     {
  26.         char magic[4];
  27.         struct
  28.         {
  29.             uint8_t major;
  30.             uint8_t minor;
  31.         } version;
  32.         uint32_t num_subs;
  33.         uint32_t unknown_2;
  34.     };
  35.  
  36.     struct GrscSubHeader
  37.     {
  38.         char resource_name[80];
  39.         int32_t unknown_1;
  40.         int32_t unknown_2;
  41.         char actor_name[80];
  42.         uint32_t num_commands;
  43.     };
  44.  
  45.     struct GrscCmdHeader
  46.     {
  47.         int32_t priority;
  48.         int32_t unknown_1;
  49.         uint32_t command_length;
  50.     };
  51. #pragma pack(pop)
  52.  
  53.     struct GrscCmd
  54.     {
  55.         const GrscCmdHeader *header;
  56.         std::string command;
  57.     };
  58.  
  59.     struct GrscSub
  60.     {
  61.         const GrscSubHeader *header;
  62.         std::vector<GrscCmd> commands;
  63.     };
  64.  
  65.     const char *cur_ptr = file_bytes.data();
  66.  
  67.     auto header = reinterpret_cast<const GrscHeader *>(cur_ptr);
  68.  
  69.     cur_ptr += sizeof(*header);
  70.  
  71.     std::vector<GrscSub> subs;
  72.  
  73.     for (int i = 0; i < (int)header->num_subs; i++)
  74.     {
  75.         GrscSub sub;
  76.  
  77.         sub.header = reinterpret_cast<const GrscSubHeader *>(cur_ptr);
  78.  
  79.         cur_ptr += sizeof(GrscSubHeader);
  80.        
  81.         for (int j = 0; j < sub.header->num_commands; j++)
  82.         {
  83.             GrscCmd cmd;
  84.  
  85.             cmd.header = reinterpret_cast<const GrscCmdHeader *>(cur_ptr);
  86.  
  87.             cur_ptr += sizeof(GrscCmdHeader);
  88.  
  89.             cmd.command = std::string(cur_ptr, cur_ptr + cmd.header->command_length);
  90.  
  91.             cur_ptr += cmd.header->command_length;
  92.  
  93.             sub.commands.emplace_back(cmd);
  94.         }
  95.  
  96.         subs.emplace_back(sub);
  97.     }
  98.  
  99.     std::vector<std::string> strings{};
  100.  
  101.     for (const auto &sub : subs)
  102.     {
  103.         for (const auto &cmd : sub.commands)
  104.         {
  105.             const auto &str = cmd.command;
  106.  
  107.             int cur_offset = 0;
  108.             bool in_str = false;
  109.             bool is_next_escaped = false;
  110.             int offset_begin = 0;
  111.  
  112.             while (cur_offset < str.length())
  113.             {
  114.                 if (in_str && is_next_escaped)
  115.                 {
  116.                     is_next_escaped = false;
  117.                 }
  118.                 if (in_str && str[cur_offset] == '\\')
  119.                 {
  120.                     is_next_escaped = true;
  121.                 }
  122.                 else if (str[cur_offset] == '"')
  123.                 {
  124.                     if (in_str)
  125.                     {
  126.                         strings.emplace_back(std::string(str.substr(offset_begin, cur_offset - offset_begin)));
  127.                     }
  128.                     else
  129.                     {
  130.                         offset_begin = cur_offset + 1;
  131.                     }
  132.  
  133.                     in_str = !in_str;
  134.                 }
  135.  
  136.                 cur_offset++;
  137.             }
  138.  
  139.             if (in_str)
  140.             {
  141.                 printf("Warning: something might have gone wrong!");
  142.             }
  143.         }
  144.     }
  145.  
  146.     printf("Bytes read %d / %d", (int)(cur_ptr - file_bytes.data()), file_bytes.size());
  147.  
  148.     std::ofstream ofs{ krName, std::ios::binary | std::ios::beg };
  149.    
  150.     for (auto &str : strings)
  151.     {
  152.         ofs.write(str.c_str(), str.length());
  153.         ofs.write("\x0D\x0A", 2);
  154.     }
  155.  
  156.     ofs.close();
  157.  
  158.     return 0;
  159. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top