Merge branch 'master' of https://github.com/open-goal/jak-project

Author: ImaDoor2785

CMakeLists.txt

@@ -195,6 +195,9 @@ if(WIN32)
 elseif(APPLE)
     set(CURL_USE_SECTRANSP ON) # native macOS SSL support
 else()
+    if(STATICALLY_LINK)
+        set(OPENSSL_USE_STATIC_LIBS TRUE)
+    endif()
     set(CURL_USE_OPENSSL ON) # not native, but seems to be the best choice for linux
 endif()
 include_directories(third-party/curl/include)

common/formatter/formatter.cpp

@@ -86,7 +86,7 @@ void apply_formatting_config(
       // circumstance, we do NOT do this sort of thing when formatting normal forms (cond/case pairs
       // are another similar situation)
       if (curr_node.formatting_config.has_constant_pairs) {
-        for (int i = 0; i < curr_node.refs.size(); i++) {
+        for (int i = 0; i < (int)curr_node.refs.size(); i++) {
           auto& child_ref = curr_node.refs.at(i);
           const auto type = child_ref.metadata.node_type;
           if (constant_types.find(type) == constant_types.end() &&
@@ -107,7 +107,7 @@ void apply_formatting_config(
     curr_node.formatting_config.indentation_width = hang_indentation_width(curr_node);
   }
   // iterate through the refs
-  for (int i = 0; i < curr_node.refs.size(); i++) {
+  for (int i = 0; i < (int)curr_node.refs.size(); i++) {
     auto& ref = curr_node.refs.at(i);
     if (!ref.token) {
       // If the child has a pre-defined configuration at that index, we pass it along
@@ -211,7 +211,7 @@ std::vector<std::string> apply_formatting(const FormatterTreeNode& curr_node,
   //
   // This means we may combine elements onto the same line in this step.
   std::vector<std::string> form_lines = {};
-  for (int i = 0; i < curr_node.refs.size(); i++) {
+  for (int i = 0; i < (int)curr_node.refs.size(); i++) {
     const auto& ref = curr_node.refs.at(i);
     // Add new line entry
     if (ref.token) {
@@ -227,20 +227,20 @@ std::vector<std::string> apply_formatting(const FormatterTreeNode& curr_node,
       // If it's not a token, we have to recursively build up the form
       // TODO - add the cursor_pos here
       const auto& lines = apply_formatting(ref, {}, cursor_pos);
-      for (int i = 0; i < lines.size(); i++) {
+      for (int i = 0; i < (int)lines.size(); i++) {
         const auto& line = lines.at(i);
         form_lines.push_back(fmt::format(
             "{}{}", str_util::repeat(ref.formatting_config.parent_mutable_extra_indent, " "),
             line));
       }
     }
     // If we are hanging forms, combine the first two forms onto the same line
-    if (i == curr_node.refs.size() - 1 && form_lines.size() > 1 &&
+    if (i == (int)curr_node.refs.size() - 1 && form_lines.size() > 1 &&
         (curr_node.formatting_config.hang_forms ||
          curr_node.formatting_config.combine_first_two_lines)) {
       form_lines.at(0) += fmt::format(" {}", form_lines.at(1));
       form_lines.erase(form_lines.begin() + 1);
-    } else if ((i + 1) < curr_node.refs.size()) {
+    } else if ((i + 1) < (int)curr_node.refs.size()) {
       const auto& next_ref = curr_node.refs.at(i + 1);
       // combine the next inline comment or constant pair
       if ((next_ref.metadata.node_type == "comment" && next_ref.metadata.is_inline) ||
@@ -267,7 +267,7 @@ std::vector<std::string> apply_formatting(const FormatterTreeNode& curr_node,
   // Consolidate any lines if the configuration requires it
   if (curr_node.formatting_config.inline_until_index != -1) {
     std::vector<std::string> new_form_lines = {};
-    for (int i = 0; i < form_lines.size(); i++) {
+    for (int i = 0; i < (int)form_lines.size(); i++) {
       if (i < curr_node.formatting_config.inline_until_index) {
         if (new_form_lines.empty()) {
           new_form_lines.push_back(form_lines.at(i));
@@ -296,7 +296,7 @@ std::vector<std::string> apply_formatting(const FormatterTreeNode& curr_node,
   if (inline_form) {
     form_lines = {fmt::format("{}", fmt::join(form_lines, " "))};
   } else {
-    for (int i = 0; i < form_lines.size(); i++) {
+    for (int i = 0; i < (int)form_lines.size(); i++) {
       if (i > 0) {
         auto& line = form_lines.at(i);
         line = fmt::format("{}{}",

common/formatter/rules/formatting_rules.cpp

@@ -39,7 +39,7 @@ bool should_insert_blank_line(const FormatterTreeNode& containing_node,
     return false;
   }
   // If the next form is a comment and is inline, don't insert a comment
-  if ((index + 1) < containing_node.refs.size() &&
+  if ((index + 1) < (int)containing_node.refs.size() &&
       containing_node.refs.at(index + 1).metadata.is_comment &&
       containing_node.refs.at(index + 1).metadata.is_inline) {
     return false;

common/formatter/rules/rule_config.cpp

@@ -22,13 +22,13 @@ FormFormattingConfig new_binding_rule() {
   auto binding_list_config = std::make_shared<FormFormattingConfig>();
   binding_list_config->hang_forms = false;
   binding_list_config->indentation_width = 1;
-  binding_list_config->indentation_width_for_index = [](FormFormattingConfig cfg, int index) {
+  binding_list_config->indentation_width_for_index = [](FormFormattingConfig /*cfg*/, int index) {
     if (index == 0) {
       return 0;
     }
     return 4;
   };
-  binding_list_config->should_prevent_inlining = [](FormFormattingConfig config, int num_refs) {
+  binding_list_config->should_prevent_inlining = [](FormFormattingConfig /*config*/, int num_refs) {
     // Only prevent inlining a binding list, if there are more than 1 bindings
     if (num_refs > 1) {
       return true;

common/formatter/rules/rule_config.h

@@ -17,14 +17,14 @@ struct FormFormattingConfig {
       2;  // 2 for a flow // TODO - also remove this, prefer storing the first node's width in the
           // metadata on the first pass, that's basically all this does
   std::function<int(FormFormattingConfig, int)> indentation_width_for_index =
-      [](FormFormattingConfig config, int index) { return config.indentation_width; };
+      [](FormFormattingConfig config, int /*index*/) { return config.indentation_width; };
   bool combine_first_two_lines =
       false;  // NOTE - basically hang, but will probably stick around after hang is gone
   int inline_until_index = -1;
   bool has_constant_pairs = false;
   bool prevent_inlining = false;
   std::function<bool(FormFormattingConfig, int num_refs)> should_prevent_inlining =
-      [](FormFormattingConfig config, int num_refs) { return config.prevent_inlining; };
+      [](FormFormattingConfig config, int /*num_refs*/) { return config.prevent_inlining; };
   int parent_mutable_extra_indent = 0;
   std::unordered_map<int, std::shared_ptr<FormFormattingConfig>> index_configs = {};
 };

common/type_system/TypeSystem.cpp

@@ -544,8 +544,15 @@ MethodInfo TypeSystem::override_method(Type* type,
     throw_typesystem_error("Trying to override a method that has no parent declaration");
   }
   // use the existing ID.
-  return type->add_method({existing_info.id, existing_info.name, existing_info.type,
-                           type->get_name(), existing_info.no_virtual, false, true, docstring});
+  return type->add_method({existing_info.id,
+                           existing_info.name,
+                           existing_info.type,
+                           type->get_name(),
+                           existing_info.no_virtual,
+                           false,
+                           true,
+                           docstring,
+                           {}});
 }
 
 MethodInfo TypeSystem::declare_method(const std::string& type_name,
@@ -596,8 +603,15 @@ MethodInfo TypeSystem::declare_method(Type* type,
     }
 
     // use the existing ID.
-    return type->add_method(
-        {existing_info.id, method_name, ts, type->get_name(), no_virtual, true, false, docstring});
+    return type->add_method({existing_info.id,
+                             method_name,
+                             ts,
+                             type->get_name(),
+                             no_virtual,
+                             true,
+                             false,
+                             docstring,
+                             {}});
   } else {
     if (got_existing) {
       // make sure we aren't changing anything.
@@ -627,8 +641,15 @@ MethodInfo TypeSystem::declare_method(Type* type,
       return existing_info;
     } else {
       // add a new method!
-      return type->add_method({get_next_method_id(type), method_name, ts, type->get_name(),
-                               no_virtual, false, false, docstring});
+      return type->add_method({get_next_method_id(type),
+                               method_name,
+                               ts,
+                               type->get_name(),
+                               no_virtual,
+                               false,
+                               false,
+                               docstring,
+                               {}});
     }
   }
 }
@@ -736,7 +757,8 @@ MethodInfo TypeSystem::add_new_method(Type* type,
 
     return existing;
   } else {
-    return type->add_new_method({0, "new", ts, type->get_name(), false, false, false, docstring});
+    return type->add_new_method(
+        {0, "new", ts, type->get_name(), false, false, false, docstring, {}});
   }
 }
 
@@ -2089,7 +2111,7 @@ std::optional<std::string> find_best_field_in_structure(const TypeSystem& ts,
   if (end_field == -1) {
     end_field = st->fields().size();
   }
-  for (size_t i = start_field; i < end_field; ++i) {
+  for (size_t i = start_field; i < (size_t)end_field; ++i) {
     const auto& field = st->fields().at(i);
     auto type = ts.lookup_type(field.type());
     if (field.is_dynamic() || field.offset() > offset || field.user_placed() != want_fixed) {

common/type_system/deftype.cpp

@@ -457,7 +457,7 @@ void declare_method(Type* type,
 void declare_state_methods(Type* type,
                            TypeSystem* type_system,
                            const goos::Object& def,
-                           StructureDefResult& struct_def) {
+                           StructureDefResult& /*struct_def*/) {
   for_each_in_list(def, [&](const goos::Object& _obj) {
     auto obj = &_obj;
     // either state-name or (state-name args...) or (state-name "docstring" args...)

common/util/FontUtils.cpp

@@ -550,6 +550,13 @@ static std::vector<ReplaceInfo> s_replace_info_jak1 = {
     {"E~Y~-6H~+2V,~Z", "Ę"},
     {"L~Y~-16H~+0V/~Z", "Ł"},
     {"Z~Y~-21H~-5Vº~Z", "Ż"},
+    {"E~Y~-20H~-5Vº~Z", "Ė"},
+    {"C~Y~-20H~-4Vˇ~Z", "Č"},
+    {"S~Y~-22H~-4Vˇ~Z", "Š"},
+    {"Z~Y~-22H~-4Vˇ~Z", "Ž"},
+    {"U~Y~-13H~+2V,~Z", "Ų"},
+    {"U~Y~-18H~-10V-~Z", "Ū"},
+    {"I~Y~-8H~+1V,~Z", "Į"},
 
     // tildes
     {"N~Y~-22H~-4V<TIL>~Z", "Ñ"},
@@ -919,6 +926,42 @@ static std::vector<ReplaceInfo> s_replace_info_jak2 = {
     {"N~Y~-6Hº~Z~+10H", "Nº"},
     {"~+4Vç~-4V", ",c"},
 
+    // added for translations TODO - check these for jak 2
+    {"O~Y~-25H~-1V/~Z", "Ø"},
+    {"o~Y~-23H~+4V/~Z", "ø"},
+    {"A~Y~-13H~+8V,~Z", "Ą"},
+    {"a~Y~-8H~+6V,~Z", "ą"},
+    {"E~Y~-6H~+8V,~Z", "Ę"},
+    {"e~Y~-10H~+7V,~Z", "ę"},
+    {"L~Y~-21H~+0V/~Z", "Ł"},
+    {"l~Y~-16H~+0V/~Z", "ł"},  // TODO - this one is ugly, font character addition (small slash)
+    {"Z~Y~-25H~-11Vº~Z", "Ż"},
+    {"z~Y~-23H~-5Vº~Z", "ż"},
+    {"a~Y~-25H~-5Vº~Z", "å"},
+    {"S~Y~-21H~-5V'~Z", "Ś"},
+    {"s~Y~-25H~-5V'~Z", "ś"},
+    {"n~Y~-25H~-5V'~Z", "ń"},
+    {"c~Y~-25H~-5V'~Z", "ć"},
+    {"o~Y~-24H~-4V<TIL>~Z", "õ"},
+    {"a~Y~-24H~-4V<TIL>~Z", "ã"},
+    {"O~Y~-28H~-4V'~-9H'~Z", "Ő"},
+    {"U~Y~-27H~-4V'~-12H'~Z", "Ű"},
+    {"o~Y~-28H~-4V'~-9H'~Z", "ő"},
+    {"E~Y~-22H~-11Vº~Z", "Ė"},
+    {"e~Y~-25H~-5Vº~Z", "ė"},
+    {"C~Y~-27H~-10Vˇ~Z", "Č"},
+    {"c~Y~-25H~-5Vˇ~Z", "č"},
+    {"S~Y~-24H~-10Vˇ~Z", "Š"},
+    {"s~Y~-22H~-4Vˇ~Z", "š"},
+    {"Z~Y~-25H~-10Vˇ~Z", "Ž"},
+    {"z~Y~-23H~-4Vˇ~Z", "ž"},
+    {"U~Y~-15H~+5V,~Z", "Ų"},
+    {"u~Y~-15H~+5V,~Z", "ų"},
+    {"U~Y~-20H~-18V-~Z", "Ū"},
+    {"u~Y~-18H~-15V-~Z", "ū"},
+    {"I~Y~-8H~+4V,~Z", "Į"},
+    {"i~Y~-8H~+4V,~Z", "į"},
+
     // tildes
     {"N~Y~-22H~-4V<TIL>~Z", "Ñ"},
     {"n~Y~-24H~-4V<TIL>~Z", "ñ"},
@@ -942,7 +985,7 @@ static std::vector<ReplaceInfo> s_replace_info_jak2 = {
     {"A~Y~-20H~-4V^~Z", "Â"},
     {"a~Y~-24H~-5V^~Z", "â"},
     {"E~Y~-20H~-5V^~Z", "Ê"},
-    {"e~Y~-25H~-4V^~Zt", "ê"},
+    {"e~Y~-25H~-4V^~Z", "ê"},
     {"I~Y~-19H~-5V^~Z", "Î"},
     {"i~Y~-19H~-8V^~Z", "î"},
     {"O~Y~-20H~-4V^~Z", "Ô"},

crowdin.yml

@@ -10,3 +10,5 @@ files:
       - "it"
       - "ja"
       - "en-GB"
+  - source: /game/assets/jak2/text/game_custom_text_en-US.json
+    translation: /game/assets/jak2/text/game_custom_text_%locale%.json

custom_levels/jak1/test-zone/test-zone.jsonc

@@ -36,7 +36,9 @@
 
   // All art groups you want to use in your custom level. Will add their models and corresponding textures to the FR3 file.
   // Note: You will still have to add them to your level's .gd file.
-  "art_groups": ["plat-ag"],
+  // Removed so that the release builds don't have to double-decompile the game
+  // "art_groups": ["plat-ag"],
+  "art_groups": [],
 
    // Any textures you want to include in your custom level. This is mainly useful for things such as the zoomer HUD,
    // which is not in the common level files and has no art group associated with it.
@@ -103,16 +105,16 @@
       "lump": {
         "name": "test-eco"
       }
-    },
-    {
-      "trans": [-7.41, 3.5, 28.42], // translation
-      "etype": "plat",  // actor type
-      "game_task": 0, // associated game task (for powercells, etc)
-      "quat": [0, 0, 0, 1], // quaternion
-      "bsphere": [-7.41, 3.5, 28.42, 10], // bounding sphere
-      "lump": {
-        "name": "test-plat"
-      }
     }
+    // {
+    //   "trans": [-7.41, 3.5, 28.42], // translation
+    //   "etype": "plat",  // actor type
+    //   "game_task": 0, // associated game task (for powercells, etc)
+    //   "quat": [0, 0, 0, 1], // quaternion
+    //   "bsphere": [-7.41, 3.5, 28.42, 10], // bounding sphere
+    //   "lump": {
+    //     "name": "test-plat"
+    //   }
+    // }
   ]
 }

custom_levels/jak2/test-zone/test-zone.jsonc

@@ -35,7 +35,9 @@
    "base_id": 100,
 
   // All art groups you want to use in your custom level. Will add their models and corresponding textures to the FR3 file.
-  "art_groups": ["prsn-torture-ag"],
+  // Removed so that the release builds don't have to double-decompile the game
+  //"art_groups": ["prsn-torture-ag"],
+  "art_groups": [],
 
    // Any textures you want to include in your custom level.
    // This is mainly useful for textures which are not in the common level files and have no art group associated with them.

decompiler/Disasm/InstructionDecode.cpp

@@ -37,7 +37,10 @@ struct OpcodeFields {
   uint32_t sa() { return (data >> 6) & 0x1f; }
 
   // 0 - 5
+  // TODO - remove once we update clang-format
+  // clang-format off
   uint32_t function() { return (data)&0x3f; }
+  // clang-format on
 
   ////////////////
   // Immediates //

decompiler/ObjectFile/ObjectFileDB_IR2.cpp

@@ -510,6 +510,20 @@ Value try_lookup(const std::unordered_map<Key, Value>& map, const Key& key) {
   }
 }
 
+const std::string* find_file_override_for_art_group(const Config& config,
+                                                    const std::string& obj_name,
+                                                    const std::string& type_name) {
+  // find file override for this type
+  auto it_file = config.art_group_file_override.find(obj_name);
+  if (it_file != config.art_group_file_override.end()) {
+    auto it_type = it_file->second.find(type_name);
+    if (it_type != it_file->second.end()) {
+      return &it_type->second;
+    }
+  }
+  return nullptr;
+}
+
 /*!
  * Analyze registers and determine the type in each register at each instruction.
  * - Figure out the type of each function, from configs.
@@ -550,15 +564,21 @@ void ObjectFileDB::ir2_type_analysis_pass(int seg, const Config& config, ObjectF
         if (func.guessed_name.kind == FunctionName::FunctionKind::V_STATE) {
           if (config.art_group_type_remap.find(func.guessed_name.type_name) !=
               config.art_group_type_remap.end()) {
-            func.ir2.env.set_art_group(config.art_group_type_remap.at(func.guessed_name.type_name));
+            auto ag_override =
+                find_file_override_for_art_group(config, obj_name, func.guessed_name.type_name);
+            func.ir2.env.set_art_group(
+                ag_override ? *ag_override
+                            : config.art_group_type_remap.at(func.guessed_name.type_name));
           } else {
             func.ir2.env.set_art_group(func.guessed_name.type_name + "-ag");
           }
         } else if (func.guessed_name.kind == FunctionName::FunctionKind::NV_STATE ||
                    func.type.try_get_tag("behavior").has_value()) {
           std::string type = func.type.get_tag("behavior");
           if (config.art_group_type_remap.find(type) != config.art_group_type_remap.end()) {
-            func.ir2.env.set_art_group(config.art_group_type_remap.at(type));
+            auto ag_override = find_file_override_for_art_group(config, obj_name, type);
+            func.ir2.env.set_art_group(ag_override ? *ag_override
+                                                   : config.art_group_type_remap.at(type));
           } else {
             func.ir2.env.set_art_group(type + "-ag");
           }

decompiler/config.cpp

@@ -297,6 +297,11 @@ Config make_config_via_json(nlohmann::json& json) {
   auto art_info_json = read_json_file_from_config(json, "art_info_file");
   config.art_group_type_remap =
       art_info_json.at("type_remap").get<std::unordered_map<std::string, std::string>>();
+  if (art_info_json.contains("file_override")) {
+    config.art_group_file_override =
+        art_info_json.at("file_override")
+            .get<std::unordered_map<std::string, std::unordered_map<std::string, std::string>>>();
+  }
   config.joint_node_hacks =
       art_info_json.at("joint_node_hacks").get<std::unordered_map<std::string, std::string>>();