libwz 0.1.0

package/src/Properties/WzRawDataProperty.cpp

@@ -0,0 +1,116 @@
+#include "wz/Properties/WzRawDataProperty.h"
+#include <algorithm>
+#include <mutex>
+#include "wz/Util/WzBinaryReader.h"
+#include "wz/Util/WzBinaryWriter.h"
+#include "wz/WzImage.h"
+
+namespace wz {
+
+WzRawDataProperty::WzRawDataProperty(const std::string& name,
+                                     WzBinaryReader* reader,
+                                     uint8_t type)
+    : wzReader_(reader), type_(type), properties_(this) {
+  SetName(name);
+}
+
+WzRawDataProperty::~WzRawDataProperty() = default;
+
+Result<void> WzRawDataProperty::WriteValue(WzBinaryWriter* writer) const {
+  auto* self = const_cast<WzRawDataProperty*>(this);
+  auto data = self->GetBytes(false);
+  if (!data.has_value()) return std::unexpected(data.error());
+
+  writer->WriteStringValue(RAW_DATA_HEADER,
+                           WzImage::WzImageHeaderByte_WithoutOffset,
+                           WzImage::WzImageHeaderByte_WithOffset);
+  writer->WriteByte(type_);
+  if (type_ == 1) {
+    if (properties_.size() > 0) {
+      writer->WriteByte(1);
+      auto result = WzImageProperty::WritePropertyList(writer, properties_);
+      if (!result.has_value()) return result;
+    } else {
+      writer->WriteByte(0);
+    }
+  }
+  writer->WriteCompressedInt(static_cast<int32_t>(data.value().size()));
+  if (!writer->BaseStream().Write(data.value().data(), data.value().size())) {
+    return std::unexpected(Error::IoError("Failed to write raw data property"));
+  }
+  return {};
+}
+
+Result<void> WzRawDataProperty::AddProperty(WzImageProperty* prop) {
+  return AddProperty(std::unique_ptr<WzImageProperty>(prop));
+}
+
+Result<void> WzRawDataProperty::AddProperty(
+    std::unique_ptr<WzImageProperty> prop) {
+  if (!prop) return {};
+  prop->SetParent(this);
+  properties_.Add(std::move(prop));
+  MarkParentImageChanged();
+  return {};
+}
+
+Result<std::unique_ptr<WzImageProperty>> WzRawDataProperty::RemoveProperty(
+    const std::string& propertyName) {
+  for (size_t i = 0; i < properties_.size(); i++) {
+    if (properties_[i]->Name() == propertyName) {
+      auto removed = properties_.Remove(properties_[i]);
+      MarkParentImageChanged();
+      return removed;
+    }
+  }
+  return std::unique_ptr<WzImageProperty>();
+}
+
+Result<std::unique_ptr<WzImageProperty>> WzRawDataProperty::RemoveProperty(
+    WzImageProperty* prop) {
+  auto removed = properties_.Remove(prop);
+  if (removed) MarkParentImageChanged();
+  return removed;
+}
+
+Result<void> WzRawDataProperty::ClearProperties() {
+  if (properties_.size() == 0) return {};
+  properties_.clear();
+  MarkParentImageChanged();
+  return {};
+}
+
+void WzRawDataProperty::Parse(bool parseNow) {
+  length_ = wzReader_->ReadCompressedInt();
+  rawDataOffset_ = wzReader_->Position();
+  if (parseNow)
+    (void)GetBytes(true);
+  else
+    wzReader_->SetPosition(rawDataOffset_ + length_);
+}
+
+Result<std::vector<uint8_t>> WzRawDataProperty::GetBytes() {
+  return GetBytes(false);
+}
+
+Result<std::vector<uint8_t>> WzRawDataProperty::GetBytes(bool saveInMemory) {
+  std::unique_lock<std::recursive_mutex> lock;
+  if (wzReader_) {
+    lock = std::unique_lock<std::recursive_mutex>(wzReader_->Mutex());
+  }
+  if (!bytes_.empty()) return bytes_;
+  if (!wzReader_)
+    return std::unexpected(Error::DataError("No reader for raw data property"));
+
+  auto currentPos = wzReader_->Position();
+  wzReader_->SetPosition(rawDataOffset_);
+  bytes_ = wzReader_->ReadBytes(length_);
+  wzReader_->SetPosition(currentPos);
+
+  if (saveInMemory) return bytes_;
+  auto result = bytes_;
+  bytes_.clear();
+  return result;
+}
+
+}  // namespace wz

package/src/Properties/WzShortProperty.cpp

@@ -0,0 +1,12 @@
+#include "wz/Properties/WzShortProperty.h"
+#include "wz/Util/WzBinaryWriter.h"
+
+namespace wz {
+
+Result<void> WzShortProperty::WriteValue(WzBinaryWriter* writer) const {
+  writer->WriteByte(2);
+  writer->WriteInt16(value_);
+  return {};
+}
+
+}  // namespace wz

package/src/Properties/WzStringProperty.cpp

@@ -0,0 +1,44 @@
+#include "wz/Properties/WzStringProperty.h"
+#include <cerrno>
+#include <cstdint>
+#include <cstdlib>
+#include <limits>
+#include "wz/Util/WzBinaryWriter.h"
+
+namespace wz {
+
+Result<void> WzStringProperty::WriteValue(WzBinaryWriter* writer) const {
+  writer->WriteByte(8);
+  writer->WriteStringValue(value_, 0x00, 0x01);
+  return {};
+}
+
+static int64_t safeParseInt64(const std::string& s) {
+  char* end = nullptr;
+  errno = 0;
+  auto v = std::strtoll(s.c_str(), &end, 10);
+  if (errno != 0 || end == s.c_str() || *end != '\0') return 0;
+  return static_cast<int64_t>(v);
+}
+
+template <typename T>
+static T safeParseInteger(const std::string& s) {
+  int64_t value = safeParseInt64(s);
+  if (value < std::numeric_limits<T>::min() ||
+      value > std::numeric_limits<T>::max()) {
+    return 0;
+  }
+  return static_cast<T>(value);
+}
+
+int32_t WzStringProperty::GetInt() const {
+  return safeParseInteger<int32_t>(value_);
+}
+int16_t WzStringProperty::GetShort() const {
+  return safeParseInteger<int16_t>(value_);
+}
+int64_t WzStringProperty::GetLong() const {
+  return safeParseInt64(value_);
+}
+
+}  // namespace wz

package/src/Properties/WzSubProperty.cpp

@@ -0,0 +1,129 @@
+#include "wz/Properties/WzSubProperty.h"
+#include <algorithm>
+#include <cctype>
+#include "wz/Util/WzBinaryWriter.h"
+#include "wz/WzImage.h"
+
+namespace wz {
+
+WzSubProperty::WzSubProperty() : properties_(this) {}
+WzSubProperty::WzSubProperty(const std::string& name) : properties_(this) {
+  SetName(name);
+}
+
+WzSubProperty::~WzSubProperty() = default;
+
+Result<void> WzSubProperty::WriteValue(WzBinaryWriter* writer) const {
+  const bool isLuaProperty =
+      properties_.size() == 1 &&
+      properties_[0]->PropertyType() == WzPropertyType::Lua;
+  if (!isLuaProperty) {
+    writer->WriteStringValue("Property",
+                             WzImage::WzImageHeaderByte_WithoutOffset,
+                             WzImage::WzImageHeaderByte_WithOffset);
+  }
+  return WzImageProperty::WritePropertyList(writer, properties_);
+}
+
+Result<void> WzSubProperty::AddProperty(WzImageProperty* prop) {
+  return AddProperty(std::unique_ptr<WzImageProperty>(prop));
+}
+
+Result<void> WzSubProperty::AddProperty(std::unique_ptr<WzImageProperty> prop) {
+  if (!prop) return {};
+  prop->SetParent(this);
+  properties_.Add(std::move(prop));
+  MarkParentImageChanged();
+  return {};
+}
+
+Result<std::unique_ptr<WzImageProperty>> WzSubProperty::RemoveProperty(
+    const std::string& propertyName) {
+  for (size_t i = 0; i < properties_.size(); i++) {
+    if (properties_[i]->Name() == propertyName) {
+      auto removed = properties_.Remove(properties_[i]);
+      MarkParentImageChanged();
+      return removed;
+    }
+  }
+  return std::unique_ptr<WzImageProperty>();
+}
+
+Result<std::unique_ptr<WzImageProperty>> WzSubProperty::RemoveProperty(
+    WzImageProperty* prop) {
+  auto removed = properties_.Remove(prop);
+  if (removed) MarkParentImageChanged();
+  return removed;
+}
+
+Result<void> WzSubProperty::ClearProperties() {
+  if (properties_.size() == 0) return {};
+  properties_.clear();
+  MarkParentImageChanged();
+  return {};
+}
+
+WzImageProperty* WzSubProperty::operator[](const std::string& name) {
+  std::string lower = name;
+  std::transform(
+      lower.begin(), lower.end(), lower.begin(), [](unsigned char c) {
+        return static_cast<char>(std::tolower(c));
+      });
+  for (auto* prop : properties_) {
+    std::string n = prop->Name();
+    std::transform(n.begin(), n.end(), n.begin(), [](unsigned char c) {
+      return static_cast<char>(std::tolower(c));
+    });
+    if (n == lower) return prop;
+  }
+  return nullptr;
+}
+
+WzImageProperty* WzSubProperty::GetFromPath(const std::string& path) {
+  std::vector<std::string> segments;
+  size_t start = 0;
+  while (true) {
+    size_t end = path.find('/', start);
+    if (end == std::string::npos) break;
+    if (end > start) segments.push_back(path.substr(start, end - start));
+    start = end + 1;
+  }
+  segments.push_back(path.substr(start));
+
+  if (segments.empty()) return nullptr;
+
+  if (segments[0] == "..") {
+    auto* parent = Parent();
+    if (!parent) return nullptr;
+
+    std::string remaining;
+    for (size_t i = 1; i < segments.size(); i++) {
+      if (i > 1) remaining += '/';
+      remaining += segments[i];
+    }
+
+    auto parentType = parent->ObjectType();
+    if (parentType == WzObjectType::Image)
+      return static_cast<WzImage*>(parent)->GetFromPath(remaining);
+    if (parentType == WzObjectType::Property)
+      return static_cast<WzImageProperty*>(parent)->GetFromPath(remaining);
+    return nullptr;
+  }
+
+  WzImageProperty* ret = this;
+  for (const auto& seg : segments) {
+    if (!ret || !ret->WzProperties()) return nullptr;
+    WzImageProperty* found = nullptr;
+    for (auto* p : *ret->WzProperties()) {
+      if (p && p->Name() == seg) {
+        found = p;
+        break;
+      }
+    }
+    if (!found) return nullptr;
+    ret = found;
+  }
+  return ret;
+}
+
+}  // namespace wz

package/src/Properties/WzUOLProperty.cpp

@@ -0,0 +1,136 @@
+#include "wz/Properties/WzUOLProperty.h"
+#include <algorithm>
+#include "wz/Util/WzBinaryWriter.h"
+#include "wz/WzDirectory.h"
+#include "wz/WzFile.h"
+#include "wz/WzImage.h"
+
+namespace wz {
+WzUOLProperty::WzUOLProperty(const std::string& name, const std::string& value)
+    : val_(value) {
+  SetName(name);
+}
+
+Result<void> WzUOLProperty::WriteValue(WzBinaryWriter* writer) const {
+  writer->WriteStringValue("UOL",
+                           WzImage::WzImageHeaderByte_WithoutOffset,
+                           WzImage::WzImageHeaderByte_WithOffset);
+  writer->WriteByte(0);
+  writer->WriteStringValue(val_, 0x00, 0x01);
+  return {};
+}
+
+WzObject* WzUOLProperty::LinkValue() const {
+  if (linkVal_) return linkVal_;
+
+  auto* self = const_cast<WzUOLProperty*>(this);
+
+  std::vector<std::string> paths;
+  size_t start = 0, end;
+  while ((end = val_.find('/', start)) != std::string::npos) {
+    paths.push_back(val_.substr(start, end - start));
+    start = end + 1;
+  }
+  paths.push_back(val_.substr(start));
+  if (paths.empty()) return nullptr;
+
+  WzObject* linkVal;
+  size_t i = 0;
+  if (paths[0] != "..") {
+    linkVal = self->GetTopMostWzImage();
+  } else {
+    linkVal = self->Parent();
+  }
+
+  for (; i < paths.size() && linkVal; i++) {
+    const std::string& path = paths[i];
+    if (path == "..") {
+      linkVal = linkVal->Parent();
+      continue;
+    }
+
+    if (linkVal->ObjectType() == WzObjectType::Property) {
+      auto* prop = static_cast<WzImageProperty*>(linkVal);
+      linkVal = (*prop)[path];
+    } else if (linkVal->ObjectType() == WzObjectType::Image) {
+      auto* img = static_cast<WzImage*>(linkVal);
+      linkVal = (*img)[path];
+    } else if (linkVal->ObjectType() == WzObjectType::Directory) {
+      auto* dir = static_cast<WzDirectory*>(linkVal);
+      if (path.size() >= 4 &&
+          std::equal(path.end() - 4, path.end(), ".img", [](char a, char b) {
+            return std::tolower(a) == b;
+          })) {
+        linkVal = (*dir)[path];
+      } else {
+        linkVal = (*dir)[path + ".img"];
+      }
+    }
+  }
+  linkVal_ = linkVal;
+  return linkVal;
+}
+
+WzPropertyCollection* WzUOLProperty::WzProperties() {
+  WzObject* lv = LinkValue();
+  if (lv && lv->ObjectType() == WzObjectType::Property)
+    return static_cast<WzImageProperty*>(lv)->WzProperties();
+  return nullptr;
+}
+
+WzImageProperty* WzUOLProperty::operator[](const std::string& name) {
+  WzObject* lv = LinkValue();
+  if (!lv) return nullptr;
+  if (lv->ObjectType() == WzObjectType::Property)
+    return (*static_cast<WzImageProperty*>(lv))[name];
+  if (lv->ObjectType() == WzObjectType::Image)
+    return (*static_cast<WzImage*>(lv))[name];
+  return nullptr;
+}
+
+WzImageProperty* WzUOLProperty::GetFromPath(const std::string& path) {
+  WzObject* lv = LinkValue();
+  if (!lv) return nullptr;
+  if (lv->ObjectType() == WzObjectType::Property)
+    return static_cast<WzImageProperty*>(lv)->GetFromPath(path);
+  if (lv->ObjectType() == WzObjectType::Image)
+    return static_cast<WzImage*>(lv)->GetFromPath(path);
+  return nullptr;
+}
+
+int32_t WzUOLProperty::GetInt() const {
+  WzObject* lv = LinkValue();
+  return lv ? lv->GetInt() : 0;
+}
+
+int16_t WzUOLProperty::GetShort() const {
+  WzObject* lv = LinkValue();
+  return lv ? lv->GetShort() : 0;
+}
+
+int64_t WzUOLProperty::GetLong() const {
+  WzObject* lv = LinkValue();
+  return lv ? lv->GetLong() : 0;
+}
+
+float WzUOLProperty::GetFloat() const {
+  WzObject* lv = LinkValue();
+  return lv ? lv->GetFloat() : 0.0f;
+}
+
+double WzUOLProperty::GetDouble() const {
+  WzObject* lv = LinkValue();
+  return lv ? lv->GetDouble() : 0.0;
+}
+
+std::string WzUOLProperty::GetString() const {
+  WzObject* lv = LinkValue();
+  return lv ? lv->GetString() : val_;
+}
+
+Result<std::vector<uint8_t>> WzUOLProperty::GetBytes() {
+  WzObject* lv = LinkValue();
+  if (lv) return lv->GetBytes();
+  return std::unexpected(Error::DataError("UOL link resolution failed"));
+}
+}  // namespace wz

package/src/Properties/WzVectorProperty.cpp

@@ -0,0 +1,22 @@
+#include "wz/Properties/WzVectorProperty.h"
+#include "wz/Util/WzBinaryWriter.h"
+#include "wz/WzImage.h"
+
+namespace wz {
+
+WzVectorProperty::~WzVectorProperty() = default;
+
+Result<void> WzVectorProperty::WriteValue(WzBinaryWriter* writer) const {
+  if (!X || !Y) {
+    return std::unexpected(
+        Error::DataError("Cannot write Vector property without X and Y"));
+  }
+  writer->WriteStringValue("Shape2D#Vector2D",
+                           WzImage::WzImageHeaderByte_WithoutOffset,
+                           WzImage::WzImageHeaderByte_WithOffset);
+  writer->WriteCompressedInt(X->Value());
+  writer->WriteCompressedInt(Y->Value());
+  return {};
+}
+
+}  // namespace wz

package/src/Properties/WzVideoProperty.cpp

@@ -0,0 +1,115 @@
+#include "wz/Properties/WzVideoProperty.h"
+#include <algorithm>
+#include <mutex>
+#include "wz/Util/WzBinaryReader.h"
+#include "wz/Util/WzBinaryWriter.h"
+#include "wz/WzImage.h"
+
+namespace wz {
+
+WzVideoProperty::WzVideoProperty(const std::string& name,
+                                 WzBinaryReader* reader)
+    : wzReader_(reader), properties_(this) {
+  SetName(name);
+}
+
+WzVideoProperty::~WzVideoProperty() = default;
+
+Result<void> WzVideoProperty::WriteValue(WzBinaryWriter* writer) const {
+  auto* self = const_cast<WzVideoProperty*>(this);
+  auto data = self->GetBytes(false);
+  if (!data.has_value()) return std::unexpected(data.error());
+
+  writer->WriteStringValue(CANVAS_VIDEO_HEADER,
+                           WzImage::WzImageHeaderByte_WithoutOffset,
+                           WzImage::WzImageHeaderByte_WithOffset);
+  writer->WriteByte(0);
+  if (properties_.size() > 0) {
+    writer->WriteByte(1);
+    auto result = WzImageProperty::WritePropertyList(writer, properties_);
+    if (!result.has_value()) return result;
+  } else {
+    writer->WriteByte(0);
+  }
+  writer->WriteByte(static_cast<uint8_t>(type_));
+  writer->WriteCompressedInt(static_cast<int32_t>(data.value().size()));
+  if (!writer->BaseStream().Write(data.value().data(), data.value().size())) {
+    return std::unexpected(Error::IoError("Failed to write video property"));
+  }
+  return {};
+}
+
+Result<void> WzVideoProperty::AddProperty(WzImageProperty* prop) {
+  return AddProperty(std::unique_ptr<WzImageProperty>(prop));
+}
+
+Result<void> WzVideoProperty::AddProperty(
+    std::unique_ptr<WzImageProperty> prop) {
+  if (!prop) return {};
+  prop->SetParent(this);
+  properties_.Add(std::move(prop));
+  MarkParentImageChanged();
+  return {};
+}
+
+Result<std::unique_ptr<WzImageProperty>> WzVideoProperty::RemoveProperty(
+    const std::string& propertyName) {
+  for (size_t i = 0; i < properties_.size(); i++) {
+    if (properties_[i]->Name() == propertyName) {
+      auto removed = properties_.Remove(properties_[i]);
+      MarkParentImageChanged();
+      return removed;
+    }
+  }
+  return std::unique_ptr<WzImageProperty>();
+}
+
+Result<std::unique_ptr<WzImageProperty>> WzVideoProperty::RemoveProperty(
+    WzImageProperty* prop) {
+  auto removed = properties_.Remove(prop);
+  if (removed) MarkParentImageChanged();
+  return removed;
+}
+
+Result<void> WzVideoProperty::ClearProperties() {
+  if (properties_.size() == 0) return {};
+  properties_.clear();
+  MarkParentImageChanged();
+  return {};
+}
+
+void WzVideoProperty::Parse(bool parseNow) {
+  type_ = wzReader_->ReadByte();
+  length_ = wzReader_->ReadCompressedInt();
+  offset_ = wzReader_->Position();
+  if (parseNow)
+    (void)GetBytes(true);
+  else
+    wzReader_->SetPosition(offset_ + length_);
+}
+
+Result<std::vector<uint8_t>> WzVideoProperty::GetBytes() {
+  return GetBytes(false);
+}
+
+Result<std::vector<uint8_t>> WzVideoProperty::GetBytes(bool saveInMemory) {
+  std::unique_lock<std::recursive_mutex> lock;
+  if (wzReader_) {
+    lock = std::unique_lock<std::recursive_mutex>(wzReader_->Mutex());
+  }
+  if (!bytes_.empty()) return bytes_;
+  if (!wzReader_)
+    return std::unexpected(Error::DataError("No reader for video property"));
+
+  auto currentPos = wzReader_->Position();
+  wzReader_->SetPosition(offset_);
+  bytes_ = wzReader_->ReadBytes(length_);
+  wzReader_->SetPosition(currentPos);
+
+  if (saveInMemory) return bytes_;
+  auto result = bytes_;
+  bytes_.clear();
+  return result;
+}
+
+}  // namespace wz

package/src/Util/ListFileParser.cpp

@@ -0,0 +1,48 @@
+#include "wz/Util/ListFileParser.h"
+#include <limits>
+#include <memory>
+#include "wz/Util/WzBinaryReader.h"
+#include "wz/Util/WzPath.h"
+#include "wz/Util/WzStream.h"
+#include "wz/Util/WzTool.h"
+
+namespace wz {
+
+std::vector<std::string> ListFileParser::ParseListFile(
+    const std::string& filePath, WzMapleVersion version) {
+  return ParseListFile(filePath, WzTool::GetIvByMapleVersion(version));
+}
+
+std::vector<std::string> ListFileParser::ParseListFile(
+    const std::string& filePath, const std::array<uint8_t, 4>& WzIv) {
+  std::vector<std::string> listEntries;
+
+  WzFileStream fs;
+  if (!fs.Open(wz::to_path(filePath), "rb")) return listEntries;
+
+  WzBinaryReader reader(std::make_shared<WzFileDataSource>(&fs), WzIv);
+
+  while (reader.Available() > 0) {
+    int32_t len = reader.ReadInt32();
+    if (len < 0 || len > 100000) break;
+
+    std::u16string chars(static_cast<size_t>(len), u'\0');
+    for (int32_t i = 0; i < len; i++) {
+      chars[static_cast<size_t>(i)] = static_cast<char16_t>(reader.ReadInt16());
+    }
+    reader.ReadUInt16();
+
+    listEntries.push_back(reader.DecryptString(chars));
+  }
+
+  if (!listEntries.empty()) {
+    auto& lastEntry = listEntries.back();
+    if (!lastEntry.empty()) {
+      lastEntry.back() = 'g';
+    }
+  }
+
+  return listEntries;
+}
+
+}  // namespace wz