hytale 0.0.1 → 0.1.1

data/lib/hytale/client/block_type.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    # Represents a type of block (e.g., "Rock_Stone", "Soil_Grass")
+    # This is the definition/template of a block type with texture and category info.
+    # For positioned blocks in the world, see Block.
+    class BlockType
+      attr_reader :id
+
+      def initialize(id)
+        @id = id
+      end
+
+      def category
+        parts = id.split("_")
+
+        parts.first if parts.any?
+      end
+
+      def subcategory
+        parts = id.split("_")
+
+        parts[1] if parts.length > 2
+      end
+
+      def name
+        id.tr("_", " ")
+      end
+
+      def state_definition?
+        id.start_with?("*")
+      end
+
+      def base_id
+        state_definition? ? id[1..] : id
+      end
+
+      def texture_name
+        "#{base_id}.png"
+      end
+
+      def texture_path
+        find_texture_path || Assets.block_texture_path(texture_name)
+      end
+
+      def texture_exists?
+        !!find_texture_path
+      end
+
+      def texture_data
+        path = find_texture_path
+
+        return nil unless path
+
+        relative_path = path.sub("#{Assets.cache_path}/", "")
+
+        Assets.read(relative_path)
+      end
+
+      private
+
+      def find_texture_path
+        path = Assets.block_texture_path(texture_name)
+
+        return path if File.exist?(path)
+
+        variants = [
+          "#{base_id}_Sunny",
+          "#{base_id}_Deep",
+          "#{base_id}_Top",
+          "#{base_id}_Side",
+          base_id,
+        ]
+
+        variants.each do |variant|
+          path = Assets.block_texture_path("#{variant}.png")
+          return path if File.exist?(path)
+        end
+
+        nil
+      end
+
+      public
+
+      def to_s
+        "BlockType: #{name}"
+      end
+
+      def inspect
+        "#<Hytale::Client::BlockType id=#{id.inspect}>"
+      end
+
+      def to_h
+        {
+          id: id,
+          category: category,
+          name: name,
+          texture_path: texture_path,
+        }
+      end
+
+      def ==(other)
+        other.is_a?(BlockType) && other.id == id
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def hash
+        id.hash
+      end
+
+      class << self
+        def all
+          @all ||= load_all_blocks
+        end
+
+        def find(id)
+          all.find { |block| block.id == id }
+        end
+
+        def where(category: nil, subcategory: nil)
+          results = all
+          results = results.select { |b| b.category == category } if category
+          results = results.select { |b| b.subcategory == subcategory } if subcategory
+
+          results
+        end
+
+        def categories
+          all.map(&:category).compact.uniq.sort
+        end
+
+        def subcategories
+          all.map(&:subcategory).compact.uniq.sort
+        end
+
+        def count
+          all.count
+        end
+
+        def reload!
+          @all = nil
+        end
+
+        def all_textures
+          Assets.block_textures
+        end
+
+        private
+
+        def load_all_blocks
+          texture_names = Assets.block_textures
+
+          block_ids = texture_names
+                      .reject { |t| t.start_with?("T_") }  # Helper textures (T_Crack_*, etc.)
+                      .reject { |t| t.start_with?("_") }   # Internal textures
+                      .reject { |t| t.end_with?("_GS") }   # Greyscale variants
+                      .uniq
+                      .sort
+
+          block_ids.map { |id| new(id) }
+        end
+      end
+    end
+  end
+end

data/lib/hytale/client/config.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    module Config
+      class << self
+        def data_path
+          @data_path ||= default_data_path
+        end
+
+        attr_writer :data_path, :assets_cache_path
+
+        def reset!
+          @data_path = nil
+        end
+
+        def default_data_path
+          case RUBY_PLATFORM
+          when /darwin/
+            File.expand_path("~/Library/Application Support/Hytale")
+          when /mswin|mingw|cygwin/
+            File.join(ENV.fetch("APPDATA", ""), "Hytale")
+          when /linux/
+            File.expand_path("~/.local/share/Hytale")
+          else
+            raise Error, "Unsupported platform: #{RUBY_PLATFORM}"
+          end
+        end
+
+        def user_data_path
+          File.join(data_path, "UserData")
+        end
+
+        def settings_path
+          File.join(user_data_path, "Settings.json")
+        end
+
+        def saves_path
+          File.join(user_data_path, "Saves")
+        end
+
+        def logs_path
+          File.join(user_data_path, "Logs")
+        end
+
+        def telemetry_path
+          File.join(user_data_path, "Telemetry")
+        end
+
+        def launcher_log_path
+          File.join(data_path, "hytale-launcher.log")
+        end
+
+        def install_path
+          File.join(data_path, "install")
+        end
+
+        def prefab_cache_path
+          File.join(user_data_path, "PrefabCache")
+        end
+
+        def player_skins_path
+          File.join(user_data_path, "CachedPlayerSkins")
+        end
+
+        def avatar_previews_path
+          File.join(user_data_path, "CachedAvatarPreviews")
+        end
+
+        def prefabs_path
+          pattern = File.join(prefab_cache_path, "*", "Server", "Prefabs")
+          dirs = Dir.glob(pattern)
+
+          dirs.first
+        end
+
+        def assets_path
+          pattern = File.join(install_path, "release", "package", "game", "*", "Assets.zip")
+          files = Dir.glob(pattern)
+
+          files.first
+        end
+
+        def assets_cache_path
+          @assets_cache_path ||= File.expand_path("assets", gem_root)
+        end
+
+        def gem_root
+          File.expand_path("../../..", __dir__)
+        end
+
+        def exists?
+          File.directory?(data_path)
+        end
+      end
+    end
+  end
+end

data/lib/hytale/client/cosmetics.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    class Cosmetics
+      CATALOG_PATH = "Cosmetics/CharacterCreator"
+
+      CATALOG_FILES = {
+        body_characteristics: "BodyCharacteristics.json",
+        capes: "Capes.json",
+        ear_accessories: "EarAccessory.json",
+        ears: "Ears.json",
+        eyebrows: "Eyebrows.json",
+        eyes: "Eyes.json",
+        face_accessories: "FaceAccessory.json",
+        faces: "Faces.json",
+        facial_hair: "FacialHair.json",
+        gloves: "Gloves.json",
+        haircuts: "Haircuts.json",
+        head_accessories: "HeadAccessory.json",
+        mouths: "Mouths.json",
+        overpants: "Overpants.json",
+        overtops: "Overtops.json",
+        pants: "Pants.json",
+        shoes: "Shoes.json",
+        skin_features: "SkinFeatures.json",
+        undertops: "Undertops.json",
+        underwear: "Underwear.json",
+      }.freeze
+
+      class << self
+        def catalog(type)
+          @catalogs ||= {}
+          @catalogs[type] ||= load_catalog(type)
+        end
+
+        # Handle format like "VikinManBun.BrownDark" - split off the color variant
+        def find(type, id)
+          base_id = id.to_s.split(".").first
+
+          catalog(type)&.find { |item| item["Id"] == base_id }
+        end
+
+        def texture_path(type, id)
+          item = find(type, id)
+          return nil unless item
+
+          variant_name = variant(id)
+
+          if variant_name && item["Textures"]
+            variant_data = item["Textures"][variant_name]
+
+            return Assets.cached_path("Common/#{variant_data["Texture"]}") if variant_data && variant_data["Texture"]
+          end
+
+          texture = item["GreyscaleTexture"] || item["Texture"]
+
+          return nil unless texture
+
+          Assets.cached_path("Common/#{texture}")
+        end
+
+        def model_path(type, id)
+          item = find(type, id)
+          return nil unless item
+
+          model = item["Model"]
+          return nil unless model
+
+          Assets.cached_path("Common/#{model}")
+        end
+
+        def variant(id)
+          parts = id.to_s.split(".")
+
+          parts.length > 1 ? parts[1..].join(".") : nil
+        end
+
+        private
+
+        def load_catalog(type)
+          filename = CATALOG_FILES[type]
+          return nil unless filename
+
+          path = Assets.cached_path("#{CATALOG_PATH}/#{filename}")
+          return nil unless File.exist?(path)
+
+          JSON.parse(File.read(path))
+        rescue JSON::ParserError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/hytale/client/item_type.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Hytale
+  module Client
+    # Represents a type of item with its full definition from game assets
+    # This includes stats, recipes, quality, etc.
+    class ItemType
+      ITEMS_PATH = "Server/Item/Items"
+      ICONS_PATH = "Common/Icons/ItemsGenerated"
+
+      attr_reader :id
+
+      def initialize(id, data: nil)
+        @id = id
+        @data = data
+      end
+
+      def data
+        @data ||= load_definition
+      end
+
+      def name(locale: nil)
+        if locale
+          Locale.item_name(id, locale: locale) || id.tr("_", " ")
+        else
+          Locale.item_name(id) || id.tr("_", " ")
+        end
+      end
+
+      def description(locale: nil)
+        if locale
+          Locale.item_description(id, locale: locale)
+        else
+          Locale.item_description(id)
+        end
+      end
+
+      def category
+        parts = id.split("_")
+
+        parts.first if parts.any?
+      end
+
+      def subcategory
+        parts = id.split("_")
+
+        parts[1] if parts.length > 2
+      end
+
+      def parent
+        data&.dig("Parent")
+      end
+
+      def quality
+        data&.dig("Quality")
+      end
+
+      def item_level
+        data&.dig("ItemLevel")
+      end
+
+      def max_durability
+        data&.dig("MaxDurability")
+      end
+
+      def max_stack_size
+        data&.dig("MaxStackSize")
+      end
+
+      def recipe
+        data&.dig("Recipe")
+      end
+
+      def recipe_inputs
+        recipe&.dig("Input") || []
+      end
+
+      def recipe_time
+        recipe&.dig("TimeSeconds")
+      end
+
+      def model_path
+        data&.dig("Model")
+      end
+
+      def texture_path
+        data&.dig("Texture")
+      end
+
+      def icon_relative_path
+        data&.dig("Icon")
+      end
+
+      def icon_path
+        @icon_path ||= find_icon_path
+      end
+
+      def icon_exists?
+        path = icon_path
+        path && File.exist?(path)
+      end
+
+      def definition_exists?
+        !!find_definition_path
+      end
+
+      def to_s
+        "ItemType: #{name}"
+      end
+
+      def inspect
+        "#<Hytale::Client::ItemType id=#{id.inspect} quality=#{quality.inspect}>"
+      end
+
+      def to_h
+        {
+          id: id,
+          name: name,
+          category: category,
+          quality: quality,
+          item_level: item_level,
+          max_durability: max_durability,
+          icon_path: icon_path,
+        }
+      end
+
+      def ==(other)
+        other.is_a?(ItemType) && other.id == id
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def hash
+        id.hash
+      end
+
+      class << self
+        def all
+          @all ||= load_all_items
+        end
+
+        def find(id)
+          all.find { |item| item.id == id }
+        end
+
+        def where(category: nil, quality: nil)
+          results = all
+
+          results = results.select { |i| i.category == category } if category
+          results = results.select { |i| i.quality == quality } if quality
+
+          results
+        end
+
+        def categories
+          all.map(&:category).compact.uniq.sort
+        end
+
+        def qualities
+          all.map(&:quality).compact.uniq.sort
+        end
+
+        def count
+          all.count
+        end
+
+        def reload!
+          @all = nil
+          @definition_paths = nil
+        end
+
+        def definition_paths
+          @definition_paths ||= Assets.list(ITEMS_PATH)
+                                      .select { |f| f.end_with?(".json") }
+                                      .to_h { |f| [File.basename(f, ".json"), f] }
+        end
+
+        private
+
+        def load_all_items
+          icon_ids = Assets.item_icons
+          definition_ids = definition_paths.keys
+          all_ids = (icon_ids + definition_ids).uniq.sort
+
+          all_ids.map { |id| new(id) }
+        end
+      end
+
+      private
+
+      def find_icon_path
+        path = Assets.item_icon_path(id)
+
+        return path if File.exist?(path)
+
+        variations = generate_icon_variations
+
+        variations.each do |variation|
+          path = Assets.item_icon_path(variation)
+
+          return path if File.exist?(path)
+        end
+
+        if id.start_with?("EditorTool_")
+          tool_name = id.sub("EditorTool_", "")
+          path = Assets.cached_path("Common/Icons/Items/EditorTools/#{tool_name}.png")
+
+          return path if File.exist?(path)
+        end
+
+        nil
+      end
+
+      def generate_icon_variations
+        variations = []
+
+        variations << id.gsub("Shortbow", "Bow") if id.include?("Shortbow")
+        variations << id.gsub("Longbow", "Bow") if id.include?("Longbow")
+        variations << id.gsub("Longsword", "Sword") if id.include?("Longsword")
+
+        variations
+      end
+
+      def find_definition_path
+        self.class.definition_paths[id]
+      end
+
+      def load_definition
+        relative_path = find_definition_path
+
+        return nil unless relative_path
+
+        Assets.extract(relative_path)
+        full_path = Assets.cached_path(relative_path)
+
+        return nil unless File.exist?(full_path)
+
+        JSON.parse(File.read(full_path))
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end

data/lib/hytale/client/launcher_log/launcher_log_entry.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    class LauncherLog
+      class LauncherLogEntry
+        attr_reader :timestamp, :level, :message, :raw
+
+        LOG_PATTERN = /^time=(\S+)\s+level=(\S+)\s+msg="([^"]*)"(.*)$/
+
+        def initialize(timestamp:, level:, message:, raw:)
+          @timestamp = timestamp
+          @level = level
+          @message = message
+          @raw = raw
+        end
+
+        def error? = level == "ERROR"
+        def warn? = level == "WARN"
+        def info? = level == "INFO"
+        def debug? = level == "DEBUG"
+
+        def attributes
+          attrs = {}
+
+          raw.scan(/(\w+)=(\S+|"[^"]*")/).each do |key, value|
+            next if ["time", "level", "msg"].include?(key)
+
+            attrs[key] = value.delete_prefix('"').delete_suffix('"')
+          end
+
+          attrs
+        end
+
+        def to_s
+          "[#{timestamp}] #{level}: #{message}"
+        end
+
+        class << self
+          def parse(line)
+            return nil unless (match = line.match(LOG_PATTERN))
+
+            timestamp = begin
+              Time.parse(match[1])
+            rescue StandardError
+              nil
+            end
+
+            level = match[2]
+            message = match[3]
+
+            new(timestamp: timestamp, level: level, message: message, raw: line)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hytale/client/launcher_log/launcher_log_session.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    class LauncherLog
+      class LauncherLogSession
+        attr_reader :started_at, :entries
+
+        def initialize(started_at)
+          @started_at = started_at
+          @entries = []
+        end
+
+        def add_entry(entry)
+          @entries << entry
+        end
+
+        def version
+          start_entry = entries.find { |e| e.message&.include?("starting hytale-launcher") }
+
+          start_entry&.attributes&.[]("version")
+        end
+
+        def profile_uuid
+          profile_entry = entries.find { |e| e.message&.include?("setting current profile") }
+
+          return nil unless profile_entry
+
+          profile_entry.message&.match(/to (\S+)/)&.[](1)
+        end
+
+        def game_launched?
+          entries.any? { |e| e.message&.include?("starting game process") }
+        end
+
+        def errors
+          entries.select(&:error?)
+        end
+
+        def duration
+          return nil if entries.empty?
+
+          last_time = entries.last.timestamp
+          first_time = entries.first.timestamp
+
+          return nil unless last_time && first_time
+
+          last_time - first_time
+        end
+
+        def to_s
+          "Session at #{started_at} (v#{version})"
+        end
+      end
+    end
+  end
+end