Merge e1c5578324 into 69f694d47c

- Added ObjectRotate and ArrayRotate methods for rotating key-value pairs in JSON objects and arrays, respectively
- Introduced GetValCount method to retrieve the total number of values in immutable JSON documents
- Renamed all Float-related methods to Double in C++ interface (IJsonManager) for better precision clarity
- Fixed TypeAccess configuration in handle type registration to allow external extensions to create JSON handles by properly setting HTypeAccess_Create flag
- Renamed GetHandleType to GetJsonHandleType for better clarity and consistency
- Updated documentation to clarify usage and performance considerations for new methods
- Enhanced tests to cover rotation functionality and value counting in various JSON structures

AMBuildScript

@@ -678,6 +678,7 @@ else:
     'extensions/tf2/AMBuilder',
     'extensions/topmenus/AMBuilder',
     'extensions/updater/AMBuilder',
+    'extensions/json/AMBuilder',
   ]
 
   if builder.backend == 'amb2':

extensions/json/AMBuilder

@@ -0,0 +1,28 @@
+# vim: set sts=2 ts=8 sw=2 tw=99 et ft=python:
+import os
+
+for cxx in builder.targets:
+  binary = SM.ExtLibrary(builder, cxx, 'json.ext')
+  if binary.compiler.family == 'gcc' or binary.compiler.family == 'clang':
+    binary.compiler.cxxflags += ['-fno-rtti']
+    binary.compiler.cflags += ['-fPIC']
+  elif binary.compiler.family == 'msvc':
+    binary.compiler.cxxflags += ['/GR-']
+
+  binary.compiler.defines += [
+    'YYJSON_DISABLE_INCR_READER',
+  ]
+
+  binary.compiler.cxxincludes += [
+    os.path.join(builder.sourcePath, 'extensions', 'json', 'yyjson'),
+  ]
+
+  binary.sources += [
+    'extension.cpp',
+    'JsonManager.cpp',
+    'JsonNatives.cpp',
+    'yyjson/yyjson.c',
+    '../../public/smsdk_ext.cpp',
+  ]
+
+  SM.extensions += [builder.Add(binary)]

extensions/json/JsonManager.h

@@ -0,0 +1,587 @@
+#ifndef _INCLUDE_JSONMANAGER_H_
+#define _INCLUDE_JSONMANAGER_H_
+
+#include <IJsonManager.h>
+#include <yyjson.h>
+#include <random>
+#include <memory>
+#include <charconv>
+
+/**
+ * @brief Base class for intrusive reference counting
+ *
+ * Objects inheriting from this class can be managed by RefPtr.
+ * Reference count starts at 0 and is incremented when RefPtr takes ownership.
+ */
+class RefCounted {
+private:
+	mutable size_t ref_count_ = 0;
+
+protected:
+	virtual ~RefCounted() = default;
+	RefCounted() = default;
+
+	RefCounted(const RefCounted &) = delete;
+	RefCounted &operator=(const RefCounted &) = delete;
+
+	RefCounted(RefCounted &&) noexcept : ref_count_(0) {}
+	RefCounted &operator=(RefCounted &&) noexcept { return *this; }
+
+public:
+	void add_ref() const noexcept { ++ref_count_; }
+
+	void release() const noexcept {
+		assert(ref_count_ > 0 && "Reference count underflow");
+		if (--ref_count_ == 0) {
+			delete this;
+		}
+	}
+
+	size_t use_count() const noexcept { return ref_count_; }
+};
+
+/**
+ * @brief Smart pointer for intrusive reference counting
+ *
+ * Similar to std::shared_ptr but uses intrusive reference counting.
+ * Automatically manages object lifetime through add_ref() and release().
+ * @warning This implementation is not thread-safe. It must only be used
+ *          in single-threaded contexts or with external synchronization.
+ */
+template <typename T> class RefPtr {
+private:
+	T *ptr_;
+
+public:
+	RefPtr() noexcept : ptr_(nullptr) {}
+
+	explicit RefPtr(T *p) noexcept : ptr_(p) {
+		if (ptr_)
+			ptr_->add_ref();
+	}
+
+	RefPtr(const RefPtr &other) noexcept : ptr_(other.ptr_) {
+		if (ptr_)
+			ptr_->add_ref();
+	}
+
+	RefPtr(RefPtr &&other) noexcept : ptr_(other.ptr_) { other.ptr_ = nullptr; }
+
+	~RefPtr() {
+		if (ptr_)
+			ptr_->release();
+	}
+
+	RefPtr &operator=(const RefPtr &other) noexcept {
+		if (ptr_ != other.ptr_) {
+			if (other.ptr_)
+				other.ptr_->add_ref();
+			if (ptr_)
+				ptr_->release();
+			ptr_ = other.ptr_;
+		}
+		return *this;
+	}
+
+	RefPtr &operator=(RefPtr &&other) noexcept {
+		if (this != &other) {
+			if (ptr_)
+				ptr_->release();
+			ptr_ = other.ptr_;
+			other.ptr_ = nullptr;
+		}
+		return *this;
+	}
+
+	RefPtr &operator=(T *p) noexcept {
+		reset(p);
+		return *this;
+	}
+
+	T *operator->() const noexcept { return ptr_; }
+	T &operator*() const noexcept { return *ptr_; }
+	T *get() const noexcept { return ptr_; }
+
+	explicit operator bool() const noexcept { return ptr_ != nullptr; }
+
+	size_t use_count() const noexcept { return ptr_ ? ptr_->use_count() : 0; }
+
+	void reset(T *p = nullptr) noexcept {
+		if (ptr_ != p) {
+			if (p)
+				p->add_ref();
+			if (ptr_)
+				ptr_->release();
+			ptr_ = p;
+		}
+	}
+
+	bool operator==(const RefPtr &other) const noexcept { return ptr_ == other.ptr_; }
+	bool operator!=(const RefPtr &other) const noexcept { return ptr_ != other.ptr_; }
+	bool operator==(std::nullptr_t) const noexcept { return ptr_ == nullptr; }
+	bool operator!=(std::nullptr_t) const noexcept { return ptr_ != nullptr; }
+};
+
+/**
+ * @brief Factory function to create RefPtr from new object
+ */
+template <typename T, typename... Args> RefPtr<T> make_ref(Args &&...args) {
+	return RefPtr<T>(new T(std::forward<Args>(args)...));
+}
+
+/**
+ * @brief Wrapper for yyjson_mut_doc with intrusive reference counting
+ */
+class RefCountedMutDoc : public RefCounted {
+private:
+	yyjson_mut_doc *doc_;
+
+public:
+	explicit RefCountedMutDoc(yyjson_mut_doc *doc) noexcept : doc_(doc) {}
+
+	RefCountedMutDoc(const RefCountedMutDoc &) = delete;
+	RefCountedMutDoc &operator=(const RefCountedMutDoc &) = delete;
+
+	~RefCountedMutDoc() noexcept override {
+		if (doc_) {
+			yyjson_mut_doc_free(doc_);
+		}
+	}
+
+	yyjson_mut_doc *get() const noexcept { return doc_; }
+};
+
+/**
+ * @brief Wrapper for yyjson_doc with intrusive reference counting
+ */
+class RefCountedImmutableDoc : public RefCounted {
+private:
+	yyjson_doc *doc_;
+
+public:
+	explicit RefCountedImmutableDoc(yyjson_doc *doc) noexcept : doc_(doc) {}
+
+	RefCountedImmutableDoc(const RefCountedImmutableDoc &) = delete;
+	RefCountedImmutableDoc &operator=(const RefCountedImmutableDoc &) = delete;
+
+	~RefCountedImmutableDoc() noexcept override {
+		if (doc_) {
+			yyjson_doc_free(doc_);
+		}
+	}
+
+	yyjson_doc *get() const noexcept { return doc_; }
+};
+
+/**
+ * @brief JSON value wrapper
+ *
+ * Wraps json mutable/immutable documents and values.
+ * Used as the primary data type for JSON operations.
+ */
+class JsonValue {
+public:
+	JsonValue() = default;
+	~JsonValue() = default;
+
+	JsonValue(const JsonValue&) = delete;
+	JsonValue& operator=(const JsonValue&) = delete;
+
+	void ResetObjectIterator() {
+		m_iterInitialized = false;
+	}
+
+	void ResetArrayIterator() {
+		m_iterInitialized = false;
+		m_arrayIndex = 0;
+	}
+
+	bool IsMutable() const {
+		return m_pDocument_mut != nullptr;
+	}
+
+	bool IsImmutable() const {
+		return m_pDocument != nullptr;
+	}
+
+	size_t GetDocumentRefCount() const {
+		if (m_pDocument_mut) {
+			return m_pDocument_mut.use_count();
+		} else if (m_pDocument) {
+			return m_pDocument.use_count();
+		}
+		return 0;
+	}
+
+	// Mutable document
+	RefPtr<RefCountedMutDoc> m_pDocument_mut;
+	yyjson_mut_val* m_pVal_mut{ nullptr };
+
+	// Immutable document
+	RefPtr<RefCountedImmutableDoc> m_pDocument;
+	yyjson_val* m_pVal{ nullptr };
+
+	// Mutable document iterators
+	yyjson_mut_obj_iter m_iterObj;
+	yyjson_mut_arr_iter m_iterArr;
+
+	// Immutable document iterators
+	yyjson_obj_iter m_iterObjImm;
+	yyjson_arr_iter m_iterArrImm;
+
+	Handle_t m_handle{ BAD_HANDLE };
+	size_t m_arrayIndex{ 0 };
+	size_t m_readSize{ 0 };
+	bool m_iterInitialized{ false };
+};
+
+/**
+ * @brief Array iterator wrapper
+ *
+ * Wraps yyjson_arr_iter and yyjson_mut_arr_iter for array iteration.
+ */
+class JsonArrIter {
+public:
+	JsonArrIter() = default;
+	~JsonArrIter() = default;
+
+	JsonArrIter(const JsonArrIter&) = delete;
+	JsonArrIter& operator=(const JsonArrIter&) = delete;
+
+	bool IsMutable() const {
+		return m_isMutable;
+	}
+
+	RefPtr<RefCountedMutDoc> m_pDocument_mut;
+	RefPtr<RefCountedImmutableDoc> m_pDocument;
+
+	yyjson_mut_arr_iter m_iterMut;
+	yyjson_arr_iter m_iterImm;
+	yyjson_mut_val* m_rootMut{ nullptr };
+	yyjson_val* m_rootImm{ nullptr };
+
+	Handle_t m_handle{ BAD_HANDLE };
+	bool m_isMutable{ false };
+	bool m_initialized{ false };
+};
+
+/**
+ * @brief Object iterator wrapper
+ *
+ * Wraps yyjson_obj_iter and yyjson_mut_obj_iter for object iteration.
+ */
+class JsonObjIter {
+public:
+	JsonObjIter() = default;
+	~JsonObjIter() = default;
+
+	JsonObjIter(const JsonObjIter&) = delete;
+	JsonObjIter& operator=(const JsonObjIter&) = delete;
+
+	bool IsMutable() const {
+		return m_isMutable;
+	}
+
+	RefPtr<RefCountedMutDoc> m_pDocument_mut;
+	RefPtr<RefCountedImmutableDoc> m_pDocument;
+
+	yyjson_mut_obj_iter m_iterMut;
+	yyjson_obj_iter m_iterImm;
+	yyjson_mut_val* m_rootMut{ nullptr };
+	yyjson_val* m_rootImm{ nullptr };
+
+	void* m_currentKey{ nullptr };
+
+	Handle_t m_handle{ BAD_HANDLE };
+	bool m_isMutable{ false };
+	bool m_initialized{ false };
+};
+
+class JsonManager : public IJsonManager
+{
+public:
+	JsonManager();
+	~JsonManager();
+
+public:
+	// ========== Document Operations ==========
+	virtual JsonValue* ParseJSON(const char* json_str, bool is_file, bool is_mutable,
+		yyjson_read_flag read_flg, char* error, size_t error_size) override;
+	virtual bool WriteToString(JsonValue* handle, char* buffer, size_t buffer_size,
+		yyjson_write_flag write_flg, size_t* out_size) override;
+	virtual char* WriteToStringPtr(JsonValue* handle, yyjson_write_flag write_flg, size_t* out_size) override;
+	virtual JsonValue* ApplyJsonPatch(JsonValue* target, JsonValue* patch, bool result_mutable,
+		char* error, size_t error_size) override;
+	virtual bool JsonPatchInPlace(JsonValue* target, JsonValue* patch,
+		char* error, size_t error_size) override;
+	virtual JsonValue* ApplyMergePatch(JsonValue* target, JsonValue* patch, bool result_mutable,
+		char* error, size_t error_size) override;
+	virtual bool MergePatchInPlace(JsonValue* target, JsonValue* patch,
+		char* error, size_t error_size) override;
+	virtual bool WriteToFile(JsonValue* handle, const char* path, yyjson_write_flag write_flg,
+		char* error, size_t error_size) override;
+	virtual bool Equals(JsonValue* handle1, JsonValue* handle2) override;
+	virtual bool EqualsStr(JsonValue* handle, const char* str) override;
+	virtual JsonValue* DeepCopy(JsonValue* targetDoc, JsonValue* sourceValue) override;
+	virtual const char* GetTypeDesc(JsonValue* handle) override;
+	virtual size_t GetSerializedSize(JsonValue* handle, yyjson_write_flag write_flg) override;
+	virtual JsonValue* ToMutable(JsonValue* handle) override;
+	virtual JsonValue* ToImmutable(JsonValue* handle) override;
+	virtual yyjson_type GetType(JsonValue* handle) override;
+	virtual yyjson_subtype GetSubtype(JsonValue* handle) override;
+	virtual bool IsArray(JsonValue* handle) override;
+	virtual bool IsObject(JsonValue* handle) override;
+	virtual bool IsInt(JsonValue* handle) override;
+	virtual bool IsUint(JsonValue* handle) override;
+	virtual bool IsSint(JsonValue* handle) override;
+	virtual bool IsNum(JsonValue* handle) override;
+	virtual bool IsBool(JsonValue* handle) override;
+	virtual bool IsTrue(JsonValue* handle) override;
+	virtual bool IsFalse(JsonValue* handle) override;
+	virtual bool IsFloat(JsonValue* handle) override;
+	virtual bool IsStr(JsonValue* handle) override;
+	virtual bool IsNull(JsonValue* handle) override;
+	virtual bool IsCtn(JsonValue* handle) override;
+	virtual bool IsMutable(JsonValue* handle) override;
+	virtual bool IsImmutable(JsonValue* handle) override;
+	virtual size_t GetReadSize(JsonValue* handle) override;
+	virtual size_t GetRefCount(JsonValue* handle) override;
+	virtual size_t GetValCount(JsonValue* handle) override;
+
+	// ========== Object Operations ==========
+	virtual JsonValue* ObjectInit() override;
+	virtual JsonValue* ObjectInitWithStrings(const char** pairs, size_t count) override;
+	virtual JsonValue* ObjectParseString(const char* str, yyjson_read_flag read_flg,
+		char* error, size_t error_size) override;
+	virtual JsonValue* ObjectParseFile(const char* path, yyjson_read_flag read_flg,
+		char* error, size_t error_size) override;
+	virtual size_t ObjectGetSize(JsonValue* handle) override;
+	virtual bool ObjectGetKey(JsonValue* handle, size_t index, const char** out_key) override;
+	virtual JsonValue* ObjectGetValueAt(JsonValue* handle, size_t index) override;
+	virtual JsonValue* ObjectGet(JsonValue* handle, const char* key) override;
+	virtual bool ObjectGetBool(JsonValue* handle, const char* key, bool* out_value) override;
+	virtual bool ObjectGetDouble(JsonValue* handle, const char* key, double* out_value) override;
+	virtual bool ObjectGetInt(JsonValue* handle, const char* key, int* out_value) override;
+	virtual bool ObjectGetInt64(JsonValue* handle, const char* key, std::variant<int64_t, uint64_t>* out_value) override;
+	virtual bool ObjectGetString(JsonValue* handle, const char* key, const char** out_str, size_t* out_len) override;
+	virtual bool ObjectIsNull(JsonValue* handle, const char* key, bool* out_is_null) override;
+	virtual bool ObjectHasKey(JsonValue* handle, const char* key, bool use_pointer) override;
+	virtual bool ObjectRenameKey(JsonValue* handle, const char* old_key, const char* new_key, bool allow_duplicate) override;
+	virtual bool ObjectSet(JsonValue* handle, const char* key, JsonValue* value) override;
+	virtual bool ObjectSetBool(JsonValue* handle, const char* key, bool value) override;
+	virtual bool ObjectSetDouble(JsonValue* handle, const char* key, double value) override;
+	virtual bool ObjectSetInt(JsonValue* handle, const char* key, int value) override;
+	virtual bool ObjectSetInt64(JsonValue* handle, const char* key, std::variant<int64_t, uint64_t> value) override;
+	virtual bool ObjectSetNull(JsonValue* handle, const char* key) override;
+	virtual bool ObjectSetString(JsonValue* handle, const char* key, const char* value) override;
+	virtual bool ObjectRemove(JsonValue* handle, const char* key) override;
+	virtual bool ObjectClear(JsonValue* handle) override;
+	virtual bool ObjectSort(JsonValue* handle, JSON_SORT_ORDER sort_mode) override;
+	virtual bool ObjectRotate(JsonValue* handle, size_t idx) override;
+
+	// ========== Array Operations ==========
+	virtual JsonValue* ArrayInit() override;
+	virtual JsonValue* ArrayInitWithStrings(const char** strings, size_t count) override;
+	virtual JsonValue* ArrayInitWithInt32(const int32_t* values, size_t count) override;
+	virtual JsonValue* ArrayInitWithInt64(const char** values, size_t count,
+		char* error, size_t error_size) override;
+	virtual JsonValue* ArrayInitWithBool(const bool* values, size_t count) override;
+	virtual JsonValue* ArrayInitWithDouble(const double* values, size_t count) override;
+	virtual JsonValue* ArrayParseString(const char* str, yyjson_read_flag read_flg,
+		char* error, size_t error_size) override;
+	virtual JsonValue* ArrayParseFile(const char* path, yyjson_read_flag read_flg,
+		char* error, size_t error_size) override;
+	virtual size_t ArrayGetSize(JsonValue* handle) override;
+	virtual JsonValue* ArrayGet(JsonValue* handle, size_t index) override;
+	virtual JsonValue* ArrayGetFirst(JsonValue* handle) override;
+	virtual JsonValue* ArrayGetLast(JsonValue* handle) override;
+	virtual bool ArrayGetBool(JsonValue* handle, size_t index, bool* out_value) override;
+	virtual bool ArrayGetDouble(JsonValue* handle, size_t index, double* out_value) override;
+	virtual bool ArrayGetInt(JsonValue* handle, size_t index, int* out_value) override;
+	virtual bool ArrayGetInt64(JsonValue* handle, size_t index, std::variant<int64_t, uint64_t>* out_value) override;
+	virtual bool ArrayGetString(JsonValue* handle, size_t index, const char** out_str, size_t* out_len) override;
+	virtual bool ArrayIsNull(JsonValue* handle, size_t index) override;
+	virtual bool ArrayReplace(JsonValue* handle, size_t index, JsonValue* value) override;
+	virtual bool ArrayReplaceBool(JsonValue* handle, size_t index, bool value) override;
+	virtual bool ArrayReplaceDouble(JsonValue* handle, size_t index, double value) override;
+	virtual bool ArrayReplaceInt(JsonValue* handle, size_t index, int value) override;
+	virtual bool ArrayReplaceInt64(JsonValue* handle, size_t index, std::variant<int64_t, uint64_t> value) override;
+	virtual bool ArrayReplaceNull(JsonValue* handle, size_t index) override;
+	virtual bool ArrayReplaceString(JsonValue* handle, size_t index, const char* value) override;
+	virtual bool ArrayAppend(JsonValue* handle, JsonValue* value) override;
+	virtual bool ArrayAppendBool(JsonValue* handle, bool value) override;
+	virtual bool ArrayAppendDouble(JsonValue* handle, double value) override;
+	virtual bool ArrayAppendInt(JsonValue* handle, int value) override;
+	virtual bool ArrayAppendInt64(JsonValue* handle, std::variant<int64_t, uint64_t> value) override;
+	virtual bool ArrayAppendNull(JsonValue* handle) override;
+	virtual bool ArrayAppendString(JsonValue* handle, const char* value) override;
+	virtual bool ArrayInsert(JsonValue* handle, size_t index, JsonValue* value) override;
+	virtual bool ArrayInsertBool(JsonValue* handle, size_t index, bool value) override;
+	virtual bool ArrayInsertInt(JsonValue* handle, size_t index, int value) override;
+	virtual bool ArrayInsertInt64(JsonValue* handle, size_t index, std::variant<int64_t, uint64_t> value) override;
+	virtual bool ArrayInsertDouble(JsonValue* handle, size_t index, double value) override;
+	virtual bool ArrayInsertString(JsonValue* handle, size_t index, const char* value) override;
+	virtual bool ArrayInsertNull(JsonValue* handle, size_t index) override;
+	virtual bool ArrayPrepend(JsonValue* handle, JsonValue* value) override;
+	virtual bool ArrayPrependBool(JsonValue* handle, bool value) override;
+	virtual bool ArrayPrependInt(JsonValue* handle, int value) override;
+	virtual bool ArrayPrependInt64(JsonValue* handle, std::variant<int64_t, uint64_t> value) override;
+	virtual bool ArrayPrependDouble(JsonValue* handle, double value) override;
+	virtual bool ArrayPrependString(JsonValue* handle, const char* value) override;
+	virtual bool ArrayPrependNull(JsonValue* handle) override;
+	virtual bool ArrayRemove(JsonValue* handle, size_t index) override;
+	virtual bool ArrayRemoveFirst(JsonValue* handle) override;
+	virtual bool ArrayRemoveLast(JsonValue* handle) override;
+	virtual bool ArrayRemoveRange(JsonValue* handle, size_t start_index, size_t count) override;
+	virtual bool ArrayClear(JsonValue* handle) override;
+	virtual int ArrayIndexOfBool(JsonValue* handle, bool search_value) override;
+	virtual int ArrayIndexOfString(JsonValue* handle, const char* search_value) override;
+	virtual int ArrayIndexOfInt(JsonValue* handle, int search_value) override;
+	virtual int ArrayIndexOfInt64(JsonValue* handle, std::variant<int64_t, uint64_t> search_value) override;
+	virtual int ArrayIndexOfDouble(JsonValue* handle, double search_value) override;
+	virtual bool ArraySort(JsonValue* handle, JSON_SORT_ORDER sort_mode) override;
+	virtual bool ArrayRotate(JsonValue* handle, size_t idx) override;
+
+	// ========== Value Operations ==========
+	virtual JsonValue* Pack(const char* format, IPackParamProvider* param_provider, char* error, size_t error_size) override;
+	virtual JsonValue* CreateBool(bool value) override;
+	virtual JsonValue* CreateDouble(double value) override;
+	virtual JsonValue* CreateInt(int value) override;
+	virtual JsonValue* CreateInt64(std::variant<int64_t, uint64_t> value) override;
+	virtual JsonValue* CreateNull() override;
+	virtual JsonValue* CreateString(const char* value) override;
+	virtual bool GetBool(JsonValue* handle, bool* out_value) override;
+	virtual bool GetDouble(JsonValue* handle, double* out_value) override;
+	virtual bool GetInt(JsonValue* handle, int* out_value) override;
+	virtual bool GetInt64(JsonValue* handle, std::variant<int64_t, uint64_t>* out_value) override;
+	virtual bool GetString(JsonValue* handle, const char** out_str, size_t* out_len) override;
+
+	// ========== Pointer Operations ==========
+	virtual JsonValue* PtrGet(JsonValue* handle, const char* path, char* error, size_t error_size) override;
+	virtual bool PtrGetBool(JsonValue* handle, const char* path, bool* out_value, char* error, size_t error_size) override;
+	virtual bool PtrGetDouble(JsonValue* handle, const char* path, double* out_value, char* error, size_t error_size) override;
+	virtual bool PtrGetInt(JsonValue* handle, const char* path, int* out_value, char* error, size_t error_size) override;
+	virtual bool PtrGetInt64(JsonValue* handle, const char* path, std::variant<int64_t, uint64_t>* out_value, char* error, size_t error_size) override;
+	virtual bool PtrGetString(JsonValue* handle, const char* path, const char** out_str, size_t* out_len, char* error, size_t error_size) override;
+	virtual bool PtrGetIsNull(JsonValue* handle, const char* path, bool* out_is_null, char* error, size_t error_size) override;
+	virtual bool PtrGetLength(JsonValue* handle, const char* path, size_t* out_len, char* error, size_t error_size) override;
+	virtual bool PtrSet(JsonValue* handle, const char* path, JsonValue* value, char* error, size_t error_size) override;
+	virtual bool PtrSetBool(JsonValue* handle, const char* path, bool value, char* error, size_t error_size) override;
+	virtual bool PtrSetDouble(JsonValue* handle, const char* path, double value, char* error, size_t error_size) override;
+	virtual bool PtrSetInt(JsonValue* handle, const char* path, int value, char* error, size_t error_size) override;
+	virtual bool PtrSetInt64(JsonValue* handle, const char* path, std::variant<int64_t, uint64_t> value, char* error, size_t error_size) override;
+	virtual bool PtrSetString(JsonValue* handle, const char* path, const char* value, char* error, size_t error_size) override;
+	virtual bool PtrSetNull(JsonValue* handle, const char* path, char* error, size_t error_size) override;
+	virtual bool PtrAdd(JsonValue* handle, const char* path, JsonValue* value, char* error, size_t error_size) override;
+	virtual bool PtrAddBool(JsonValue* handle, const char* path, bool value, char* error, size_t error_size) override;
+	virtual bool PtrAddDouble(JsonValue* handle, const char* path, double value, char* error, size_t error_size) override;
+	virtual bool PtrAddInt(JsonValue* handle, const char* path, int value, char* error, size_t error_size) override;
+	virtual bool PtrAddInt64(JsonValue* handle, const char* path, std::variant<int64_t, uint64_t> value, char* error, size_t error_size) override;
+	virtual bool PtrAddString(JsonValue* handle, const char* path, const char* value, char* error, size_t error_size) override;
+	virtual bool PtrAddNull(JsonValue* handle, const char* path, char* error, size_t error_size) override;
+	virtual bool PtrRemove(JsonValue* handle, const char* path, char* error, size_t error_size) override;
+	virtual JsonValue* PtrTryGet(JsonValue* handle, const char* path) override;
+	virtual bool PtrTryGetBool(JsonValue* handle, const char* path, bool* out_value) override;
+	virtual bool PtrTryGetDouble(JsonValue* handle, const char* path, double* out_value) override;
+	virtual bool PtrTryGetInt(JsonValue* handle, const char* path, int* out_value) override;
+	virtual bool PtrTryGetInt64(JsonValue* handle, const char* path, std::variant<int64_t, uint64_t>* out_value) override;
+	virtual bool PtrTryGetString(JsonValue* handle, const char* path, const char** out_str, size_t* out_len) override;
+
+	// ========== Iterator Operations ==========
+	virtual bool ObjectForeachNext(JsonValue* handle, const char** out_key,
+	                                size_t* out_key_len, JsonValue** out_value) override;
+	virtual bool ArrayForeachNext(JsonValue* handle, size_t* out_index,
+	                               JsonValue** out_value) override;
+	virtual bool ObjectForeachKeyNext(JsonValue* handle, const char** out_key,
+	                                   size_t* out_key_len) override;
+	virtual bool ArrayForeachIndexNext(JsonValue* handle, size_t* out_index) override;
+
+	// ========== Array Iterator Operations ==========
+	virtual JsonArrIter* ArrIterInit(JsonValue* handle) override;
+	virtual JsonArrIter* ArrIterWith(JsonValue* handle) override;
+	virtual bool ArrIterReset(JsonArrIter* iter) override;
+	virtual JsonValue* ArrIterNext(JsonArrIter* iter) override;
+	virtual bool ArrIterHasNext(JsonArrIter* iter) override;
+	virtual size_t ArrIterGetIndex(JsonArrIter* iter) override;
+	virtual void* ArrIterRemove(JsonArrIter* iter) override;
+
+	// ========== Object Iterator Operations ==========
+	virtual JsonObjIter* ObjIterInit(JsonValue* handle) override;
+	virtual JsonObjIter* ObjIterWith(JsonValue* handle) override;
+	virtual bool ObjIterReset(JsonObjIter* iter) override;
+	virtual void* ObjIterNext(JsonObjIter* iter) override;
+	virtual bool ObjIterHasNext(JsonObjIter* iter) override;
+	virtual JsonValue* ObjIterGetVal(JsonObjIter* iter, void* key) override;
+	virtual JsonValue* ObjIterGet(JsonObjIter* iter, const char* key) override;
+	virtual size_t ObjIterGetIndex(JsonObjIter* iter) override;
+	virtual void* ObjIterRemove(JsonObjIter* iter) override;
+	virtual bool ObjIterGetKeyString(JsonObjIter* iter, void* key, const char** out_str, size_t* out_len = nullptr) override;
+
+	// ========== Iterator Release Operations ==========
+	virtual void ReleaseArrIter(JsonArrIter* iter) override;
+	virtual void ReleaseObjIter(JsonObjIter* iter) override;
+
+	// ========== Iterator Handle Type Operations ==========
+	virtual HandleType_t GetArrIterHandleType() override;
+	virtual HandleType_t GetObjIterHandleType() override;
+	virtual JsonArrIter* GetArrIterFromHandle(IPluginContext* pContext, Handle_t handle) override;
+	virtual JsonObjIter* GetObjIterFromHandle(IPluginContext* pContext, Handle_t handle) override;
+
+	// ========== Release Operations ==========
+	virtual void Release(JsonValue* value) override;
+
+	// ========== Handle Type Operations ==========
+	virtual HandleType_t GetJsonHandleType() override;
+
+	// ========== Handle Operations ==========
+	virtual JsonValue* GetValueFromHandle(IPluginContext* pContext, Handle_t handle) override;
+
+	// ========== Number Read/Write Operations ==========
+	virtual JsonValue* ReadNumber(const char* dat, uint32_t read_flg = 0,
+		char* error = nullptr, size_t error_size = 0, size_t* out_consumed = nullptr) override;
+	virtual bool WriteNumber(JsonValue* handle, char* buffer, size_t buffer_size,
+		size_t* out_written = nullptr) override;
+
+	// ========== Floating-Point Format Operations ==========
+	virtual bool SetFpToFloat(JsonValue* handle, bool flt) override;
+	virtual bool SetFpToFixed(JsonValue* handle, int prec) override;
+
+	// ========== Direct Value Modification Operations ==========
+	virtual bool SetBool(JsonValue* handle, bool value) override;
+	virtual bool SetInt(JsonValue* handle, int value) override;
+	virtual bool SetInt64(JsonValue* handle, std::variant<int64_t, uint64_t> value) override;
+	virtual bool SetDouble(JsonValue* handle, double value) override;
+	virtual bool SetString(JsonValue* handle, const char* value) override;
+	virtual bool SetNull(JsonValue* handle) override;
+
+	virtual bool ParseInt64Variant(const char* value, std::variant<int64_t, uint64_t>* out_value,
+		char* error = nullptr, size_t error_size = 0) override;
+
+private:
+	std::random_device m_randomDevice;
+	std::mt19937 m_randomGenerator;
+
+	// Helper methods
+	static std::unique_ptr<JsonValue> CreateWrapper();
+	static RefPtr<RefCountedMutDoc> WrapDocument(yyjson_mut_doc* doc);
+	static RefPtr<RefCountedMutDoc> CopyDocument(yyjson_doc* doc);
+	static RefPtr<RefCountedMutDoc> CreateDocument();
+	static RefPtr<RefCountedImmutableDoc> WrapImmutableDocument(yyjson_doc* doc);
+	static RefPtr<RefCountedMutDoc> CloneValueToMutable(JsonValue* value);
+
+	// Pack helper methods
+	static const char* SkipSeparators(const char* ptr);
+	static yyjson_mut_val* PackImpl(yyjson_mut_doc* doc, const char* format,
+	                                 IPackParamProvider* provider, char* error,
+	                                 size_t error_size, const char** out_end_ptr);
+
+	// PtrTryGet helper methods
+	struct PtrGetValueResult {
+		yyjson_mut_val* mut_val{ nullptr };
+		yyjson_val* imm_val{ nullptr };
+		bool success{ false };
+	};
+	static PtrGetValueResult PtrGetValueInternal(JsonValue* handle, const char* path);
+};
+
+#endif // _INCLUDE_JSONMANAGER_H_

extensions/json/extension.cpp

@@ -0,0 +1,88 @@
+#include "extension.h"
+#include "JsonManager.h"
+
+JsonExtension g_JsonExt;
+SMEXT_LINK(&g_JsonExt);
+
+HandleType_t g_JsonType;
+HandleType_t g_ArrIterType;
+HandleType_t g_ObjIterType;
+JsonHandler g_JsonHandler;
+ArrIterHandler g_ArrIterHandler;
+ObjIterHandler g_ObjIterHandler;
+IJsonManager* g_pJsonManager;
+
+bool JsonExtension::SDK_OnLoad(char* error, size_t maxlen, bool late)
+{
+	sharesys->AddNatives(myself, g_JsonNatives);
+	sharesys->RegisterLibrary(myself, "json");
+
+	HandleAccess haDefault;
+	handlesys->InitAccessDefaults(nullptr, &haDefault);
+	haDefault.access[HandleAccess_Read] = 0;
+	haDefault.access[HandleAccess_Delete] = 0;
+
+	TypeAccess taDefault;
+	handlesys->InitAccessDefaults(&taDefault, nullptr);
+	taDefault.access[HTypeAccess_Create] = true;
+
+	HandleError err;
+	g_JsonType = handlesys->CreateType("JSON", &g_JsonHandler, 0, &taDefault, &haDefault, myself->GetIdentity(), &err);
+
+	if (!g_JsonType) {
+		snprintf(error, maxlen, "Failed to create JSON handle type (err: %d)", err);
+		return false;
+	}
+
+	g_ArrIterType = handlesys->CreateType("JSONArrIter", &g_ArrIterHandler, 0, &taDefault, &haDefault, myself->GetIdentity(), &err);
+	if (!g_ArrIterType) {
+		snprintf(error, maxlen, "Failed to create JSONArrIter handle type (err: %d)", err);
+		return false;
+	}
+
+	g_ObjIterType = handlesys->CreateType("JSONObjIter", &g_ObjIterHandler, 0, &taDefault, &haDefault, myself->GetIdentity(), &err);
+	if (!g_ObjIterType) {
+		snprintf(error, maxlen, "Failed to create JSONObjIter handle type (err: %d)", err);
+		return false;
+	}
+
+	if (g_pJsonManager) {
+		delete g_pJsonManager;
+		g_pJsonManager = nullptr;
+	}
+
+	g_pJsonManager = new(std::nothrow) JsonManager();
+	if (!g_pJsonManager) {
+		snprintf(error, maxlen, "Failed to create JSON manager instance");
+		return false;
+	}
+
+	return sharesys->AddInterface(myself, g_pJsonManager);
+}
+
+void JsonExtension::SDK_OnUnload()
+{
+	handlesys->RemoveType(g_JsonType, myself->GetIdentity());
+	handlesys->RemoveType(g_ArrIterType, myself->GetIdentity());
+	handlesys->RemoveType(g_ObjIterType, myself->GetIdentity());
+
+	if (g_pJsonManager) {
+		delete g_pJsonManager;
+		g_pJsonManager = nullptr;
+	}
+}
+
+void JsonHandler::OnHandleDestroy(HandleType_t type, void* object)
+{
+	delete (JsonValue*)object;
+}
+
+void ArrIterHandler::OnHandleDestroy(HandleType_t type, void* object)
+{
+	delete (JsonArrIter*)object;
+}
+
+void ObjIterHandler::OnHandleDestroy(HandleType_t type, void* object)
+{
+	delete (JsonObjIter*)object;
+}

extensions/json/extension.h

@@ -0,0 +1,42 @@
+#ifndef _INCLUDE_SOURCEMOD_EXTENSION_PROPER_H_
+#define _INCLUDE_SOURCEMOD_EXTENSION_PROPER_H_
+
+#include "smsdk_ext.h"
+#include "IJsonManager.h"
+
+class JsonExtension : public SDKExtension
+{
+public:
+	virtual bool SDK_OnLoad(char *error, size_t maxlength, bool late);
+	virtual void SDK_OnUnload();
+};
+
+class JsonHandler : public IHandleTypeDispatch
+{
+public:
+	void OnHandleDestroy(HandleType_t type, void *object);
+};
+
+class ArrIterHandler : public IHandleTypeDispatch
+{
+public:
+	void OnHandleDestroy(HandleType_t type, void *object);
+};
+
+class ObjIterHandler : public IHandleTypeDispatch
+{
+public:
+	void OnHandleDestroy(HandleType_t type, void *object);
+};
+
+extern JsonExtension g_JsonExt;
+extern HandleType_t g_JsonType;
+extern HandleType_t g_ArrIterType;
+extern HandleType_t g_ObjIterType;
+extern JsonHandler g_JsonHandler;
+extern ArrIterHandler g_ArrIterHandler;
+extern ObjIterHandler g_ObjIterHandler;
+extern const sp_nativeinfo_t g_JsonNatives[];
+extern IJsonManager* g_pJsonManager;
+
+#endif // _INCLUDE_SOURCEMOD_EXTENSION_PROPER_H_

extensions/json/smsdk_config.h

@@ -0,0 +1,17 @@
+#ifndef _INCLUDE_SOURCEMOD_EXTENSION_CONFIG_H_
+#define _INCLUDE_SOURCEMOD_EXTENSION_CONFIG_H_
+
+#define SMEXT_CONF_NAME			"SourceMod JSON Extension"
+#define SMEXT_CONF_DESCRIPTION	"Provide JSON Native"
+#define SMEXT_CONF_VERSION		"1.1.5e"
+#define SMEXT_CONF_AUTHOR		"ProjectSky"
+#define SMEXT_CONF_URL			"https://github.com/ProjectSky/sm-ext-yyjson"
+#define SMEXT_CONF_LOGTAG		"json"
+#define SMEXT_CONF_LICENSE		"GPL"
+#define SMEXT_CONF_DATESTRING	__DATE__
+
+#define SMEXT_LINK(name) SDKExtension *g_pExtensionIface = name;
+
+#define SMEXT_ENABLE_HANDLESYS
+
+#endif // _INCLUDE_SOURCEMOD_EXTENSION_CONFIG_H_

extensions/json/version.rc

@@ -0,0 +1,104 @@
+// Microsoft Visual C++ generated resource script.
+//
+//#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "winres.h"
+
+#include <sourcemod_version.h>
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION  SM_VERSION_FILE
+ PRODUCTVERSION SM_VERSION_FILE
+ FILEFLAGSMASK 0x17L
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x4L
+ FILETYPE 0x2L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "000004b0"
+        BEGIN
+            VALUE "Comments", "JSON Extension"
+            VALUE "FileDescription", "SourceMod JSON Extension"
+            VALUE "FileVersion", SM_VERSION_FILE
+            VALUE "InternalName", "SourceMod JSON Extension"
+            VALUE "LegalCopyright", "Copyright (c) 2004-2009, AlliedModders LLC"
+            VALUE "OriginalFilename", BINARY_NAME
+            VALUE "ProductName", "SourceMod JSON Extension"
+            VALUE "ProductVersion", SM_VERSION_STRING
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x0, 1200
+    END
+END
+
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE 
+BEGIN
+    "#include ""winres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+

extensions/json/yyjson/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 YaoYuan <ibireme@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gamedata/core.games/engine.blade.txt

@@ -21,32 +21,13 @@
 		
 		"Offsets"
 		{
-			/* Offset into LevelShutdown */
-			"gEntList"
-			{
-				"windows"	"11"
-			}
-
+			/* Blade Symphony has VSERVERTOOLS003, so we already have gEntList and only need the EntInfo offset from it */
+			/* It's the first member after the vtable */
 			"EntInfo"
 			{
-				"windows"	"4"	
-				"linux"		"4"
-				"mac"		"4"
-			}
-		}
-		
-		"Signatures"
-		{
-			"LevelShutdown"
-			{
-				"library"	"server"
-				"windows"	"\xE8\x2A\x2A\x2A\x2A\xE8\x2A\x2A\x2A\x2A\xB9\x2A\x2A\x2A\x2A\xE8\x2A\x2A\x2A\x2A\xE8"
-			}
-			"gEntList"
-			{
-				"library"	"server"
-				"linux"		"@gEntList"
-				"mac"		"@gEntList"
+				"windows"	"4"
+				"windows64"	"8"
+				"linux64"	"8"
 			}
 		}
 	}

gamedata/sdktools.games/engine.blade.txt

@@ -66,9 +66,8 @@
 			{
 				"library"	"server"
 				"windows"	"\x55\x8B\xEC\x81\xEC\x44\x01\x00\x00\x8B\xC1"
-				"windows64"	"\x4C\x89\x4C\x24\x20\x4C\x89\x44\x24\x18\x48\x89\x54\x24\x10\x48\x89\x4C\x24\x08\x48\x81\xEC\x78\x04\x00\x00"
+				"windows64"	"\x4C\x8B\xDC\x49\x89\x53\x10\x49\x89\x4B\x08\x55\x41\x55"
 				"linux64"	"\x55\x48\x89\xE5\x41\x57\x41\x56\x41\x55\x41\x54\x53\x48\x81\xEC\x88\x01\x00\x00\xF3\x0F\x11\x85\x94\xFE\xFF\xFF"
-				"mac64"		"\x55\x48\x89\xE5\x41\x57\x41\x56\x41\x55\x41\x54\x53\x48\x81\xEC\x78\x01\x00\x00\xF3\x0F\x11\x85\x9C\xFE\xFF\xFF"
 			}
 		}
 	}