rodecomp/Source/Resource/Sprites/ActionResource.cpp

#include "Client/Application/ErrorDialog.h"
#include "File/File.h"
#include "Render/DeviceContext/DCSurface.h"
#include "Resource/Sprites/ActionResource.h"
#include "Resource/Bitmap/BitmapResource.h"
#include "Resource/ResourceByteReader.h"
#include "Resource/ResourceMgr.h"
#include "Resource/Sprites/SpriteResource.h"

#include "Utility/Math/ScalarConversion.h"
#include <algorithm>
#include <cstring>

namespace {
  // INLINED
  int RelativeCoordinate(int position, int extent, float scale) {
    const int center = extent / 2 + extent % 2;
    const float offset = static_cast<float>(center) * scale;
    const float coordinate = static_cast<float>(position) - offset;

    return TruncateToInt(coordinate / scale);
  }
}

// OFFSET: 0x00745FB0
// FUNCTION: fn_07767
CActRes::CActRes() {
  this->maximumCells = 0;
}

// INLINED
CActRes::~CActRes() = default;

// OFFSET: 0x007436B0
// FUNCTION: fn_07749
CActRes* CActRes::Create() {
  return new CActRes;
}

// OFFSET: 0x007437B0
// FUNCTION: fn_07750
bool CActRes::Load(const char* name) {
  CFile file;
  if (!file.Open(name, 0, true, false)) {
    ShowErrorDialog(GetRenderSystemHolder()->system, (std::string("Cannot find File : ") + std::string(name)).c_str(), 0);
    return false;
  }

  struct Header {
    std::uint16_t magic;
    std::uint16_t version;
    std::uint16_t count;
    unsigned char reserved[10];
  } header;
  file.Read(&header, sizeof(header));

  if (header.magic != 0x4341) {
    ShowErrorDialog(GetRenderSystemHolder()->system, "Illegal file format", 0);
    ShowErrorDialog(GetRenderSystemHolder()->system, name, 0);
    file.Close();

    return false;
  }

  std::string spriteName(name);
  spriteName.resize(spriteName.size() - 4);
  spriteName.append(".spr", 4);

  if (header.version > 0x0205) {
    ShowErrorDialog(GetRenderSystemHolder()->system, "Unsupported Version. Content may be corrupted", 0);
    file.Close();
    return false;
  }

  this->Unload();
  this->animations.resize(header.count);
  this->speeds.resize(header.count, 4.0f);

  for (unsigned animationIndex = 0; animationIndex < this->animations.size(); ++animationIndex) {
    std::vector<ActionFrame>& animation = this->animations[animationIndex];
    int frameCount;
    file.Read(&frameCount, sizeof(frameCount));
    animation.resize(frameCount);

    for (int frameIndex = 0; frameIndex < frameCount; ++frameIndex) {
      std::int32_t range1[4];
      std::int32_t range2[4];
      file.Read(range1, sizeof(range1));
      file.Read(range2, sizeof(range2));
      int cellCount;
      file.Read(&cellCount, sizeof(cellCount));
      ActionFrame& frame = animation[frameIndex];
      frame.sound = -1;
      frame.cellCount = cellCount;
      frame.cells.resize(std::min(static_cast<unsigned>(cellCount), 1000u));
      frame.anchors.clear();
      frame.anchorCount = 0;
      std::memcpy(frame.rangeBounds, range1, sizeof(range1));
      std::memcpy(frame.rangeBounds + 4, range2, sizeof(range2));
      if (this->maximumCells < cellCount) {
        this->maximumCells = cellCount;
      }

      for (int index = 0; index < cellCount; ++index) {
        SpriteFrameCell& cell = frame.cells[index];

        if (header.version < 0x0200) {
          file.Read(&cell, 16);
          cell.color = 0xFFFFFFFFu;
          cell.scaleX = 1.0f;
          cell.scaleY = 1.0f;
          cell.rotation = 0;
          cell.imageType = 0;
          continue;
        }

        if (header.version < 0x0204) {
          struct LegacyCell {
            std::int32_t x;
            std::int32_t y;
            std::int32_t image;
            std::int32_t mirrored;
            std::uint32_t color;
            float scale;
            std::int32_t rotation;
            std::int32_t imageType;
          } legacy;
          file.Read(&legacy, sizeof(legacy));
          cell = {legacy.x, legacy.y, legacy.image, legacy.mirrored, legacy.color, legacy.scale, legacy.scale, legacy.rotation, legacy.imageType};
        } else {
          file.Read(&cell, sizeof(cell));
        }

        if (header.version >= 0x0205) {
          int width;
          int height;
          file.Read(&width, sizeof(width));
          file.Read(&height, sizeof(height));

          if (cell.image != -1) {
            cell.x = RelativeCoordinate(cell.x, width, cell.scaleX);
            cell.y = RelativeCoordinate(cell.y, height, cell.scaleY);
          }
        } else if (cell.image != -1) {
          auto* sprite = static_cast<CSprRes*>(ResourceMgr::Instance().Load(spriteName.c_str()));

          if (sprite) {
            const SpriteRleImage* image = sprite->images[cell.imageType][cell.image];

            if (image) {
              const int width = image->width * (image->doubleWidth != 0 ? 2 : 1);
              const int height = image->height * (image->doubleHeight != 0 ? 2 : 1);
              cell.x = RelativeCoordinate(cell.x, width, cell.scaleX);
              cell.y = RelativeCoordinate(cell.y, height, cell.scaleY);
            }
          }
        }
      }

      if (header.version >= 0x0200) {
        file.Read(&frame.sound, sizeof(frame.sound));

        if (header.version == 0x0200) {
          frame.sound = -1;
        }
      }

      if (header.version >= 0x0203) {
        int count;
        file.Read(&count, sizeof(count));
        frame.anchorCount = count;
        frame.anchors.resize(static_cast<unsigned>(count));

        for (int index = 0; index < count; ++index) {
          struct AnchorRecord {
            int unused;
            ActionAnchor anchor;
          } anchor;
          file.Read(&anchor, sizeof(anchor));
          frame.anchors[index] = anchor.anchor;
        }
      }
    }
  }

  if (header.version >= 0x0201) {
    int count;
    file.Read(&count, sizeof(count));
    this->sounds.resize(static_cast<unsigned>(count));

    for (int index = 0; index < count; ++index) {
      char sound[40];
      file.Read(sound, sizeof(sound));
      this->sounds[index] = sound;
    }
  }

  if (header.version >= 0x0202) {
    for (int index = 0; index < header.count; ++index) {
      file.Read(&this->speeds[index], sizeof(float));
    }
  }

  file.Close();
  return true;
}

// OFFSET: 0x007445A0
// FUNCTION: fn_07751
void CActRes::Unload() {
  this->animations.clear();
  this->sounds.clear();
}

// OFFSET: 0x00746F80
// FUNCTION: fn_07783
const std::vector<ActionFrame>& CActRes::Animation(unsigned index) const {
  if (index < this->animations.size()) {
    return this->animations[index];
  }

  // STATIC: 0x0138D700
  // GLOBAL: gl_25519
  static const std::vector<ActionFrame> missingAnimation;
  return missingAnimation;
}

// OFFSET: 0x00747050
// FUNCTION: fn_07784
const SpriteFrameCell& ActionFrame::Cell(unsigned index) const {
  if (index < this->cells.size()) {
    return this->cells[index];
  }

  // STATIC: 0x0132A1A8
  static const SpriteFrameCell missing{0, 0, -1, 0, 0xFFFFFFFFu, 1.0f, 1.0f, 0, 0};
  return missing;
}

// OFFSET: 0x00747090
// FUNCTION: fn_07785
float CActRes::Speed(unsigned index) const {
  if (index < this->speeds.size()) {
    return this->speeds[index];
  }

  return 4.0f;
}

// OFFSET: 0x007470E0
// FUNCTION: fn_07786
const char* CActRes::Sound(unsigned index) const {
  return index < this->sounds.size() ? this->sounds[index].c_str() : "";
}

// OFFSET: 0x00747170
// FUNCTION: fn_07787
const ActionFrame& CActRes::Frame(unsigned animation, unsigned frame) const {
  const auto& frames = this->Animation(animation);
  if (frame < frames.size()) {
    return frames[frame];
  }
  if (!frames.empty()) {
    return frames.front();
  }

  // GLOBAL: gl_24507
  static const ActionFrame missing;
  return missing;
}

// OFFSET: 0x00747370
// FUNCTION: fn_07788
unsigned CActRes::FrameCount(unsigned animation) const {
  const auto& frames = this->Animation(animation);
  return (std::max)(static_cast<unsigned>(frames.size()), 1u);
}

// INLINED
CActRes::CActRes(const char* extension, const char* prefix) {
  ResourceMgr::Instance().Register(extension, prefix, this);
}

// GLOBAL: gl_25546
CActRes g_actPrototype("act", "sprite\\");