hytale 0.0.1 → 0.1.1

data/lib/hytale/client/memories.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    class Memories
+      attr_reader :data, :path
+
+      def initialize(data, path: nil)
+        @data = data
+        @path = path
+      end
+
+      def all
+        @all ||= (data["Memories"] || []).map { |mem| NPCMemory.new(mem) }
+      end
+
+      def count
+        all.size
+      end
+
+      def find_by_role(role)
+        all.find { |mem| mem.npc_role == role }
+      end
+
+      def find_all_by_location(location)
+        all.select { |mem| mem.location&.include?(location) }
+      end
+
+      def roles
+        all.map(&:npc_role).uniq.sort
+      end
+
+      def locations
+        all.map(&:location).compact.uniq.sort
+      end
+
+      def each(&)
+        all.each(&)
+      end
+
+      include Enumerable
+
+      def to_a = all
+      def to_h = data
+
+      class << self
+        def load(path)
+          raise NotFoundError, "Memories file not found: #{path}" unless File.exist?(path)
+
+          json = File.read(path)
+          data = JSON.parse(json)
+          new(data, path: path)
+        rescue JSON::ParserError => e
+          raise ParseError, "Failed to parse memories: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/hytale/client/npc_memory.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    class NPCMemory
+      attr_reader :data
+
+      def initialize(data)
+        @data = data
+      end
+
+      def id = data["Id"]
+      def npc_role = data["NPCRole"]
+      def translation_key = data["TranslationKey"]
+      def name_overridden? = data["IsMemoriesNameOverridden"]
+
+      def captured_at
+        timestamp = data["CapturedTimestamp"]
+        timestamp ? Time.at(timestamp / 1000.0) : nil
+      end
+
+      def location_key = data["FoundLocationNameKey"]
+
+      def location
+        location_key&.split(".")&.last
+      end
+
+      def friendly_name
+        npc_role&.gsub("_", " ")
+      end
+
+      def to_s
+        "#{friendly_name} found at #{location}"
+      end
+
+      def to_h = data
+    end
+  end
+end

data/lib/hytale/client/permissions.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    class Permissions
+      attr_reader :data, :path
+
+      def initialize(data, path: nil)
+        @data = data
+        @path = path
+      end
+
+      def users
+        data["users"] || {}
+      end
+
+      def groups
+        data["groups"] || {}
+      end
+
+      def user_groups(uuid)
+        users.dig(uuid, "groups") || []
+      end
+
+      def group_permissions(group_name)
+        groups[group_name] || []
+      end
+
+      def user_permissions(uuid)
+        user_groups(uuid).flat_map { |g| group_permissions(g) }.uniq
+      end
+
+      def op?(uuid)
+        user_groups(uuid).include?("OP") || user_permissions(uuid).include?("*")
+      end
+
+      def to_h = data
+
+      class << self
+        def load(path)
+          raise NotFoundError, "Permissions file not found: #{path}" unless File.exist?(path)
+
+          json = File.read(path)
+          data = JSON.parse(json)
+          new(data, path: path)
+        rescue JSON::ParserError => e
+          raise ParseError, "Failed to parse permissions: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/hytale/client/player/entity_stats.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    class Player
+      class EntityStats
+        attr_reader :data
+
+        def initialize(data)
+          @data = data
+        end
+
+        def version = data["Version"]
+
+        def health
+          stat("Health")
+        end
+
+        def max_health
+          base = health || 0
+          modifier = stat_modifier("Health", "Armor_ADDITIVE") || 0
+
+          base + modifier
+        end
+
+        def stamina = stat("Stamina")
+        def oxygen = stat("Oxygen")
+        def mana = stat("Mana")
+
+        def stat(name)
+          data.dig("Stats", name, "Value")
+        end
+
+        def stat_modifier(stat_name, modifier_name)
+          data.dig("Stats", stat_name, "Modifiers", modifier_name, "Amount")
+        end
+
+        def all_stats
+          (data["Stats"] || {}).transform_values { |v| v["Value"] }
+        end
+
+        def to_h = data
+      end
+    end
+  end
+end

data/lib/hytale/client/player/inventory.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    class Player
+      class Inventory
+        attr_reader :data
+
+        def initialize(data)
+          @data = data
+        end
+
+        def version = data["Version"]
+
+        def storage
+          @storage ||= ItemStorage.new(data["Storage"] || {})
+        end
+
+        def backpack
+          @backpack ||= ItemStorage.new(data["Backpack"] || {})
+        end
+
+        def hotbar
+          @hotbar ||= ItemStorage.new(data["HotBar"] || {})
+        end
+
+        def armor
+          @armor ||= ItemStorage.new(data["Armor"] || {})
+        end
+
+        def utility
+          @utility ||= ItemStorage.new(data["Utility"] || {})
+        end
+
+        def tools
+          @tools ||= ItemStorage.new(data["Tool"] || {})
+        end
+
+        def active_hotbar_slot = data["ActiveHotbarSlot"]
+        def sort_type = data["SortType"]
+
+        def backpack?
+          backpack&.simple?
+        end
+
+        def all_items
+          [storage, backpack, hotbar, armor, utility, tools].flat_map(&:items)
+        end
+
+        def to_h = data
+      end
+    end
+  end
+end

data/lib/hytale/client/player/item.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    class Player
+      class Item
+        attr_reader :data, :slot
+
+        def initialize(data, slot: nil)
+          @data = data
+          @slot = slot
+        end
+
+        def id = data["Id"]
+        def name = id&.gsub("_", " ")
+        def type = ItemType.find(id) || ItemType.new(id)
+        def quantity = data["Quantity"]
+        def durability = data["Durability"]
+        def max_durability = data["MaxDurability"]
+
+        def durability_percent
+          return nil unless durability && max_durability&.positive?
+
+          (durability / max_durability * 100).round(1)
+        end
+
+        def damaged?
+          durability && max_durability && durability < max_durability
+        end
+
+        def icon_path
+          find_icon_path || Assets.item_icon_path(id)
+        end
+
+        def icon_exists?
+          !!find_icon_path
+        end
+
+        private
+
+        def find_icon_path
+          path = Assets.item_icon_path(id)
+          return path if File.exist?(path)
+
+          variations = generate_icon_variations(id)
+
+          variations.each do |variation|
+            path = Assets.item_icon_path(variation)
+            return path if File.exist?(path)
+          end
+
+          alternate_paths = generate_alternate_paths(id)
+
+          alternate_paths.each do |alt_path|
+            full_path = Assets.cached_path(alt_path)
+            return full_path if File.exist?(full_path)
+          end
+
+          nil
+        end
+
+        def generate_icon_variations(item_id)
+          variations = []
+
+          variations << item_id.gsub("Shortbow", "Bow") if item_id.include?("Shortbow")
+
+          variations << item_id.gsub("Longbow", "Bow") if item_id.include?("Longbow")
+
+          variations << item_id.gsub("Longsword", "Sword") if item_id.include?("Longsword")
+
+          variations
+        end
+
+        def generate_alternate_paths(item_id)
+          paths = []
+
+          # EditorTool_Paint -> Common/Icons/Items/EditorTools/Paint.png
+          if item_id.start_with?("EditorTool_")
+            tool_name = item_id.sub("EditorTool_", "")
+
+            paths << "Common/Icons/Items/EditorTools/#{tool_name}.png"
+          end
+
+          paths
+        end
+
+        public
+
+        def to_s
+          string = name.to_s
+
+          string += " x#{quantity}" if quantity && quantity > 1
+          string += " (#{durability_percent}%)" if durability_percent && durability_percent < 100
+
+          string
+        end
+
+        def to_h = data
+      end
+    end
+  end
+end

data/lib/hytale/client/player/item_storage.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    class Player
+      class ItemStorage
+        attr_reader :data
+
+        def initialize(data)
+          @data = data
+        end
+
+        def capacity = data["Capacity"]
+        def type = data["Id"]
+
+        def empty?
+          type == "Empty"
+        end
+
+        def simple?
+          type == "Simple"
+        end
+
+        def items
+          (data["Items"] || {}).map do |slot, item_data|
+            Item.new(item_data, slot: slot.to_i)
+          end
+        end
+
+        def [](slot)
+          item_data = data.dig("Items", slot.to_s)
+
+          Item.new(item_data, slot: slot) if item_data
+        end
+
+        def to_h = data
+      end
+    end
+  end
+end

data/lib/hytale/client/player/player_memory.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    class Player
+      class PlayerMemory
+        attr_reader :data
+
+        def initialize(data)
+          @data = data
+        end
+
+        def id = data["Id"]
+        def npc_role = data["NPCRole"]
+        def translation_key = data["TranslationKey"]
+        def name_overridden? = data["IsMemoriesNameOverridden"]
+        def captured_at = data["CapturedTimestamp"] ? Time.at(data["CapturedTimestamp"] / 1000.0) : nil
+        def location_key = data["FoundLocationNameKey"]
+
+        def location
+          location_key&.split(".")&.last
+        end
+
+        def to_s = "#{npc_role} (#{location})"
+        def to_h = data
+      end
+    end
+  end
+end

data/lib/hytale/client/player/position.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    class Player
+      Position = Data.define(:x, :y, :z) do
+        def to_s = "(#{x&.round(2)}, #{y&.round(2)}, #{z&.round(2)})"
+        def to_a = [x, y, z]
+      end
+    end
+  end
+end

data/lib/hytale/client/player/rotation.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    class Player
+      Rotation = Data.define(:pitch, :yaw, :roll) do
+        def to_s = "(pitch: #{pitch&.round(2)}, yaw: #{yaw&.round(2)}, roll: #{roll&.round(2)})"
+      end
+    end
+  end
+end

data/lib/hytale/client/player/vector3.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    class Player
+      Vector3 = Data.define(:x, :y, :z) do
+        def to_s = "(#{x&.round(4)}, #{y&.round(4)}, #{z&.round(4)})"
+        def magnitude = Math.sqrt(((x || 0)**2) + ((y || 0)**2) + ((z || 0)**2))
+      end
+    end
+  end
+end

data/lib/hytale/client/player.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    class Player
+      attr_reader :data, :uuid, :path
+
+      def initialize(data, uuid:, path: nil)
+        @data = data
+        @uuid = uuid
+        @path = path
+      end
+
+      def components
+        data["Components"] || {}
+      end
+
+      def name
+        components.dig("Nameplate", "Text") || components.dig("DisplayName", "DisplayName", "RawText")
+      end
+
+      def position
+        transform = components["Transform"] || {}
+        pos = transform["Position"] || {}
+        Position.new(pos["X"], pos["Y"], pos["Z"])
+      end
+
+      def rotation
+        transform = components["Transform"] || {}
+        rot = transform["Rotation"] || {}
+        Rotation.new(rot["Pitch"], rot["Yaw"], rot["Roll"])
+      end
+
+      def velocity
+        vel = components.dig("Velocity", "Velocity") || {}
+        Vector3.new(vel["X"], vel["Y"], vel["Z"])
+      end
+
+      def stats
+        @stats ||= EntityStats.new(components["EntityStats"] || {})
+      end
+
+      def inventory
+        @inventory ||= Inventory.new(components.dig("Player", "Inventory") || {})
+      end
+
+      def player_data
+        components["Player"] || {}
+      end
+
+      def game_mode
+        player_data["GameMode"]
+      end
+
+      def current_world
+        player_data.dig("PlayerData", "World")
+      end
+
+      def discovered_zones
+        @discovered_zones ||= (player_data.dig("PlayerData", "DiscoveredZones") || []).map do |id|
+          Hytale::Client::Zone::Region.new(id)
+        end
+      end
+
+      def respawn_points
+        player_data.dig("PlayerData", "PerWorldData", "default", "RespawnPoints") || []
+      end
+
+      def memories
+        @memories ||= (components.dig("PlayerMemories", "Memories") || []).map do |mem|
+          PlayerMemory.new(mem)
+        end
+      end
+
+      def skin
+        @skin ||= PlayerSkin.find(uuid)
+      end
+
+      def avatar_preview_path
+        skin&.avatar_preview_path
+      end
+
+      def to_h
+        data
+      end
+
+      class << self
+        def load(path)
+          raise NotFoundError, "Player file not found: #{path}" unless File.exist?(path)
+
+          uuid = File.basename(path, ".json")
+          json = File.read(path)
+          data = JSON.parse(json)
+          new(data, uuid: uuid, path: path)
+        rescue JSON::ParserError => e
+          raise ParseError, "Failed to parse player data: #{e.message}"
+        end
+      end
+    end
+  end
+end