action.hpp

Go to the documentation of this file.

#pragma once
 
#include <map>
#include <set>
 
#include "NNL/common/fixed_type.hpp"
#include "NNL/common/io.hpp"
#include "NNL/game_asset/behavior/action_common.hpp"
#include "NNL/utility/math.hpp"
#include "tsl/ordered_map.h"
 
namespace nnl {

namespace action {
 
constexpr u16 kNumAnimFuncNSUNI = 0x1C;  
 
constexpr u16 kNumEffectFuncNSUNI = 0x26;  
 
constexpr u16 kNumAnimFuncNSLAR = 0x14;  
 
constexpr u16 kNumEffectFuncNSLAR = 0xC;  

enum class AnimationFunction : u16 {
  kEnd = 0,   
  kNext = 1,  
  kGoto = 2,  
  // 3 NULL, causes a crash
  // 4 NULL, causes a crash
  kTransitionToAnimation5 = 5,  
  kTransitionToAnimation6 = 6,  
  kEndAnimationPlayback = 7,    
  kInitAnimationPlayback = 8,   
  kSetFlags = 9,                
  kInitCountdown = 0xA,         
  kCheckCountdown = 0xB,        
  kSetBossHitTarget = 0xC,      
  kUnkD = 0xD,                  
  kSetAnimSpeed = 0xE,          
  kPlayAnimation = 0xF,         
  kSetAnimStartFrame = 0x10,    
  kUnk11 = 0x11,                
  kUnk12 = 0x12,                
  kUnk13 = 0x13,                
  // NSUNI ONLY:
  kSetMeshGroupVisib = 0x14,     
  kWaitAfter = 0x15,             
  kWaitBefore = 0x16,            
  kEnableTextureSwap = 0x17,     
  kDisableTextureSwap = 0x18,    
  kEnableEffect = 0x19,          
  kUnk1A = 0x1A,                 
  kSetComboTransitFrames = 0x1B  
};

union AnimationNode {
  NNL_PACK(struct {
    AnimationFunction function;  
    u8 next_main_node;           
    bool flag;                   
  })
  main;  
 
  u8 args[4];  
};
 
static_assert(sizeof(AnimationNode) == 0x4);

enum class EffectFunction : u8 {
  kEnd = 0,                 
  kSetFlags1 = 1,           
  kEnableEffect = 2,        
  kOpacityTransition3 = 3,  
  kOpacityTransition4 = 4,  
  // 5 NULL
  kOpacityTransition6 = 6,  
  kPlaySFX = 7,             
  kPlaySFXRND = 8,          
  // 9 NULL
  kPlayUVAnim = 0xA,          
  kOpacityTransitionB = 0xB,  
  kUnkC = 0xC,                
  kNextD = 0xD,               
  kNextE = 0xE,               
  kNextF = 0xF,               
  kUnk10 = 0x10,              
  kUnk11 = 0x11,              
  kUnk12 = 0x12,              
  kSetFlags13 = 0x13,         
  // NSUNI only:
  kEnableEffect14 = 0x14,       
  kSetFlags15 = 0x15,           
  kSetFlags16 = 0x16,           
  kUnk17 = 0x17,                
  kUnk18 = 0x18,                
  kSlowdown = 0x19,             
  kEnableDisplayEffect = 0x1A,  
  kEnableEffect1B = 0x1B,       
  kUnk1C = 0x1C,                
  kAnimateCamera = 0x1D,        
  kMoveRootBone = 0x1E,         
  kAnimateCamera1F = 0x1F,      
  kSetMeshGroupVisib = 0x20,    
  kEnableJutsuEffect = 0x21,    
  kSetTextureSwapStat = 0x22,   
  kSetFlags23 = 0x23,           
  kUnk24 = 0x24,                
  kUnk25 = 0x25                 
 
};

union EffectNode {
  NNL_PACK(struct {
    EffectFunction function;  
    u8 next_main_node;        
    u16 frame_ticks;          
  })
  main;
 
  u8 args[4];  
};
 
static_assert(sizeof(EffectNode) == 0x4);

struct Action {
  std::string name = "";                       
  std::vector<AnimationNode> animation_nodes;  
 
  std::vector<EffectNode> effect_nodes;  
};

 
using ActionConfig = tsl::ordered_map<action::Id, Action>;

bool IsOfType(BufferView buffer);
 
bool IsOfType(const std::filesystem::path& path);
 
bool IsOfType(Reader& f);

ActionConfig Import(BufferView buffer);
 
ActionConfig Import(const std::filesystem::path& path);
 
ActionConfig Import(Reader& f);

[[nodiscard]] Buffer Export(const ActionConfig& action_config);
 
void Export(const ActionConfig& action_config, const std::filesystem::path& path);
 
void Export(const ActionConfig& action_config, Writer& f);  // Main


std::map<u16, std::set<std::string>> GetAnimationNames(const ActionConfig& action_config);

template <class... Ts, class Node>
inline std::tuple<Ts...> ReadArgs(std::size_t main_node_ind, const std::vector<Node>& nodes) {
  static_assert(std::is_same_v<Node, AnimationNode> || std::is_same_v<Node, EffectNode>, "not a node");
  std::tuple<Ts...> result;
  std::size_t offset = 0;
  std::apply(
      [&](auto&... args) {
        (([&]() {
           static_assert(std::is_trivially_copyable_v<std::remove_reference_t<decltype(args)>>);
           static_assert(sizeof(args) <= sizeof(Node));
 
           offset = utl::math::RoundNum(offset, sizeof(args));
 
           auto& main_node = nodes.at(main_node_ind).main;
 
           std::size_t required_size =
               main_node_ind + 1 + (utl::math::RoundNum(offset + sizeof(args), sizeof(Node)) / sizeof(Node));
 
           if (required_size > nodes.size())
             NNL_THROW(nnl::RangeError(NNL_SRCTAG("Read exceeds the size of available nodes")));
 
           if (sizeof(Node) + offset + sizeof(args) > main_node.next_main_node * sizeof(Node))
             NNL_THROW(nnl::RangeError(NNL_SRCTAG("Read exceeds the size of the argument nodes")));
 
           std::memcpy(&args, reinterpret_cast<const char*>(nodes.data() + main_node_ind + 1) + offset, sizeof(args));
 
           offset += sizeof(args);
         }()),
         ...);
      },
      result);
 
  return result;
}

template <class... Ts, class Node>
inline void WriteArgs(std::size_t main_node_ind, std::vector<Node>& nodes, const Ts&&... args) {
  static_assert(std::is_same_v<Node, AnimationNode> || std::is_same_v<Node, EffectNode>, "not a node");
  std::size_t offset = 0;
  (
      [&] {
        static_assert(std::is_trivially_copyable_v<std::remove_reference_t<decltype(args)>>);
 
        static_assert(sizeof(args) <= sizeof(Node));
 
        auto& main_node = nodes.at(main_node_ind).main;
 
        offset = utl::math::RoundNum(offset, sizeof(args));
 
        std::size_t required_size =
            main_node_ind + 1 + (utl::math::RoundNum(offset + sizeof(args), sizeof(Node)) / sizeof(Node));
 
        if (main_node.next_main_node != 0 &&
            sizeof(Node) + offset + sizeof(args) > main_node.next_main_node * sizeof(Node))
          NNL_THROW(nnl::RangeError(NNL_SRCTAG("Write exceeds the size of the argument nodes")));
 
        if (required_size > nodes.size()) {
          nodes.resize(required_size);
        }
 
        std::memcpy(reinterpret_cast<char*>(nodes.data() + main_node_ind + 1) + offset, &args, sizeof(args));
 
        offset += sizeof(args);
      }(),
      ...);
 
  std::size_t index_next_node = 1 + utl::math::RoundNum(offset, sizeof(Node)) / sizeof(Node);
 
  auto& main_node = nodes.at(main_node_ind).main;
 
  if (index_next_node > main_node.next_main_node) main_node.next_main_node = index_next_node;
}

template <class Node>
inline std::size_t NextNodeInd(std::size_t main_node_ind, const std::vector<Node>& nodes) {
  static_assert(std::is_same_v<Node, AnimationNode> || std::is_same_v<Node, EffectNode>, "not a node");
  const auto& main_node = nodes.at(main_node_ind).main;
  return main_node_ind + main_node.next_main_node;
}
  // Aux
 
namespace raw {
 
NNL_PACK(struct RActionCategory {
  u32 offset = 0;
  u32 num_actions = 0;
});
 
static_assert(sizeof(RActionCategory) == 0x8);
 
NNL_PACK(struct RHeader { RActionCategory action_categories[kNumActionCategories]; });
 
static_assert(sizeof(RHeader) == 0x20);
 
NNL_PACK(struct RAction {
  u16 offset_animation_nodes = 0;
  u16 offset_action_name = 0;
  u16 offset_effect_nodes = 0;
  u16 offset_unknown = 0;  // reserved?
});
 
static_assert(sizeof(RAction) == 0x8);
 
NNL_PACK(struct RAnimationNode {
  u16 index_function = 0;
  u8 next_main_node = 1;
  u8 unk_flag = 0;
});
 
static_assert(sizeof(RAnimationNode) == 0x4);
static_assert(sizeof(RAnimationNode) == sizeof(AnimationNode));
 
NNL_PACK(struct REffectNode {
  u8 index_function = 0;
  u8 next_main_node = 0;
  u16 time_tick = 0;
});
 
static_assert(sizeof(REffectNode) == 0x4);
static_assert(sizeof(REffectNode) == sizeof(EffectNode));
 
struct RActionConfig {
  RHeader header;
  // Maps of offsets (used in the structures) to their data:
  std::map<u32, std::vector<RAction>> actions;
  std::map<u16, std::vector<RAnimationNode>> animation_nodes;
  std::map<u16, std::string> action_names;
  std::map<u16, std::vector<REffectNode>> effect_nodes;
};
 
ActionConfig Convert(RActionConfig&& raction_config);
 
RActionConfig Parse(Reader& f);  // Raw
}  // namespace raw
}  // namespace action

}  // namespace nnl