hytale 0.0.1 → 0.1.1

data/lib/hytale/client/launcher_log.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    class LauncherLog
+      attr_reader :path
+
+      def initialize(path)
+        @path = path
+      end
+
+      def content
+        @content ||= File.read(path)
+      end
+
+      def lines
+        @lines ||= content.lines.map(&:chomp)
+      end
+
+      def entries
+        @entries ||= lines.filter_map { |line| LauncherLogEntry.parse(line) }
+      end
+
+      def errors
+        entries.select(&:error?)
+      end
+
+      def warnings
+        entries.select(&:warn?)
+      end
+
+      def info
+        entries.select(&:info?)
+      end
+
+      def game_launches
+        entries.select { |e| e.message&.include?("starting game process") }
+      end
+
+      def updates
+        entries.select { |e| e.message&.include?("applying update") }
+      end
+
+      def current_version
+        version_entry = entries.reverse.find { |e| e.message&.include?("starting hytale-launcher") }
+        version_entry&.attributes&.[]("version")
+      end
+
+      def current_profile_uuid
+        profile_entry = entries.reverse.find { |e| e.message&.include?("setting current profile") }
+
+        return nil unless profile_entry
+
+        profile_entry.message&.match(/to (\S+)/)&.[](1)
+      end
+
+      def current_channel
+        channel_entry = entries.reverse.find { |e| e.message&.include?("setting channel") }
+
+        return nil unless channel_entry
+
+        channel_entry.attributes&.[]("channel")
+      end
+
+      def last_game_launch
+        game_launches.last
+      end
+
+      def sessions
+        sessions = []
+        current_session = nil
+
+        entries.each do |entry|
+          if entry.message&.include?("starting hytale-launcher")
+            current_session = LauncherLogSession.new(entry.timestamp)
+            sessions << current_session
+          end
+          current_session&.add_entry(entry)
+        end
+
+        sessions
+      end
+
+      def each(&)
+        entries.each(&)
+      end
+
+      include Enumerable
+
+      class << self
+        def load(path: Config.launcher_log_path)
+          raise NotFoundError, "Launcher log not found: #{path}" unless File.exist?(path)
+
+          new(path)
+        end
+      end
+    end
+  end
+end

data/lib/hytale/client/locale.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    # Provides localized strings from game language files
+    # Supports all available game languages
+    class Locale
+      DEFAULT_LOCALE = "en-US"
+
+      attr_reader :code, :language, :region
+
+      def initialize(code)
+        @code = code
+        @language, @region = code.split("-")
+      end
+
+      def translations
+        self.class.translations(code)
+      end
+
+      def t(key, fallback: true)
+        self.class.t(key, locale: code, fallback: fallback)
+      end
+
+      alias translate t
+
+      def zone_name(zone_id)
+        self.class.zone_name(zone_id, locale: code)
+      end
+
+      def region_name(region_id)
+        self.class.region_name(region_id, locale: code)
+      end
+
+      def item_name(item_id)
+        self.class.item_name(item_id, locale: code)
+      end
+
+      def item_description(item_id)
+        self.class.item_description(item_id, locale: code)
+      end
+
+      def zones
+        self.class.zones(locale: code)
+      end
+
+      def regions
+        self.class.regions(locale: code)
+      end
+
+      def to_s
+        code
+      end
+
+      def inspect
+        "#<Hytale::Client::Locale code=#{code.inspect}>"
+      end
+
+      class << self
+        def available
+          @available ||= detect_available_locales
+        end
+
+        def default
+          DEFAULT_LOCALE
+        end
+
+        def find(code)
+          return nil unless available.include?(code)
+
+          new(code)
+        end
+
+        def all
+          available.map { |code| new(code) }
+        end
+
+        # Get a translation by key
+        # @param key [String] The translation key (e.g., "map.region.Zone1_Tier1")
+        # @param locale [String] The locale to use (default: en-US)
+        # @param fallback [Boolean] If true, fall back to English when translation missing
+        # @return [String, nil] The translated string or nil if not found
+        def t(key, locale: DEFAULT_LOCALE, fallback: true)
+          result = translations(locale)[key]
+
+          # Fall back to English if translation missing and fallback enabled
+          result = translations(DEFAULT_LOCALE)[key] if result.nil? && fallback && locale != DEFAULT_LOCALE
+
+          result
+        end
+
+        alias translate t
+
+        # Get all translations for a locale
+        # @param locale [String] The locale (default: en-US)
+        # @return [Hash] Key-value hash of all translations
+        def translations(locale = DEFAULT_LOCALE)
+          @translations ||= {}
+          @translations[locale] ||= load_translations(locale)
+        end
+
+        # Get zone display name
+        # @param zone_id [String] The zone ID (e.g., "Emerald_Wilds")
+        # @param locale [String] The locale (default: en-US)
+        def zone_name(zone_id, locale: DEFAULT_LOCALE)
+          t("map.zone.#{zone_id}", locale: locale)
+        end
+
+        # Get region display name
+        # @param region_id [String] The region ID (e.g., "Zone1_Tier1")
+        # @param locale [String] The locale (default: en-US)
+        def region_name(region_id, locale: DEFAULT_LOCALE)
+          t("map.region.#{region_id}", locale: locale)
+        end
+
+        # Get item display name
+        # @param item_id [String] The item ID (e.g., "Weapon_Sword_Copper")
+        # @param locale [String] The locale (default: en-US)
+        def item_name(item_id, locale: DEFAULT_LOCALE)
+          t("items.#{item_id}.name", locale: locale)
+        end
+
+        # Get item description
+        # @param item_id [String] The item ID
+        # @param locale [String] The locale (default: en-US)
+        def item_description(item_id, locale: DEFAULT_LOCALE)
+          t("items.#{item_id}.description", locale: locale)
+        end
+
+        # Get all zone names
+        # @param locale [String] The locale (default: en-US)
+        # @return [Hash] zone_id => display_name
+        def zones(locale: DEFAULT_LOCALE)
+          prefix = "map.zone."
+          translations(locale)
+            .select { |k, _| k.start_with?(prefix) }
+            .transform_keys { |k| k.delete_prefix(prefix) }
+        end
+
+        # Get all region names
+        # @param locale [String] The locale (default: en-US)
+        # @return [Hash] region_id => display_name
+        def regions(locale: DEFAULT_LOCALE)
+          prefix = "map.region."
+          translations(locale)
+            .select { |k, _| k.start_with?(prefix) }
+            .transform_keys { |k| k.delete_prefix(prefix) }
+        end
+
+        # Search translations by key pattern
+        # @param pattern [Regexp, String] Pattern to match against keys
+        # @param locale [String] The locale (default: en-US)
+        # @return [Hash] Matching key-value pairs
+        def search(pattern, locale: DEFAULT_LOCALE)
+          pattern = Regexp.new(pattern) if pattern.is_a?(String)
+          translations(locale).select { |k, _| k.match?(pattern) }
+        end
+
+        # Clear cached translations and available locales
+        def reload!
+          @translations = nil
+          @available = nil
+        end
+
+        private
+
+        def detect_available_locales
+          Assets.list("Server/Languages")
+                .map { |f| f.split("/")[2] }
+                .uniq
+                .reject { |l| l.nil? || l.end_with?(".lang") }
+                .sort
+        end
+
+        def load_translations(locale)
+          result = {}
+
+          server_lang = load_lang_file("Server/Languages/#{locale}/server.lang")
+          result.merge!(server_lang) if server_lang
+
+          result
+        end
+
+        def load_lang_file(path)
+          return nil unless Assets.extract(path)
+
+          full_path = Assets.cached_path(path)
+
+          return nil unless File.exist?(full_path)
+
+          parse_lang_file(File.read(full_path))
+        rescue StandardError
+          nil
+        end
+
+        def parse_lang_file(content)
+          result = {}
+          current_key = nil
+          current_value = []
+          in_multiline = false
+
+          content.each_line do |line|
+            line = line.chomp
+
+            if in_multiline
+              if line.end_with?("\\")
+                current_value << line[0..-2]
+              else
+                current_value << line
+                result[current_key] = current_value.join("\n")
+                in_multiline = false
+                current_key = nil
+                current_value = []
+              end
+            elsif line =~ /^([a-zA-Z0-9_.]+)\s*=\s*(.*)$/
+              key = ::Regexp.last_match(1)
+              value = ::Regexp.last_match(2)
+
+              if value.end_with?("\\")
+                current_key = key
+                current_value = [value[0..-2]]
+                in_multiline = true
+              else
+                result[key] = value
+              end
+            end
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/hytale/client/map/block.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    class Map
+      # Represents a specific block at coordinates in the world.
+      # Contains a reference to its BlockType for texture/category info.
+      class Block
+        attr_reader :block_type, :x, :y, :z, :chunk
+
+        # @param block_type [BlockType] The type of this block
+        # @param x [Integer] Local X coordinate within chunk (0-15)
+        # @param y [Integer] Y coordinate (height)
+        # @param z [Integer] Local Z coordinate within chunk (0-15)
+        # @param chunk [Chunk, nil] The chunk this block belongs to
+        def initialize(block_type, x:, y:, z:, chunk: nil)
+          @block_type = block_type
+          @x = x
+          @y = y
+          @z = z
+          @chunk = chunk
+        end
+
+        def id
+          block_type.id
+        end
+
+        def name
+          block_type.name
+        end
+
+        def category
+          block_type.category
+        end
+
+        def subcategory
+          block_type.subcategory
+        end
+
+        def texture_path
+          block_type.texture_path
+        end
+
+        def texture_exists?
+          block_type.texture_exists?
+        end
+
+        def texture_data
+          block_type.texture_data
+        end
+
+        def world_x
+          return nil unless chunk&.world_x
+
+          chunk.world_x + x
+        end
+
+        def world_z
+          return nil unless chunk&.world_z
+
+          chunk.world_z + z
+        end
+
+        def world_y
+          y
+        end
+
+        def world_position
+          return nil unless world_x && world_z
+
+          [world_x, world_y, world_z]
+        end
+
+        def local_position
+          [x, y, z]
+        end
+
+        def empty?
+          id == "Empty" || id.start_with?("Air")
+        end
+
+        def solid?
+          !empty? && !liquid?
+        end
+
+        def liquid?
+          ["Water", "Lava"].include?(category)
+        end
+
+        def vegetation?
+          category == "Plant" || id.include?("Grass")
+        end
+
+        def to_s
+          position = world_position ? "(#{world_x}, #{world_y}, #{world_z})" : "(#{x}, #{y}, #{z})"
+
+          "Block: #{name} at #{position}"
+        end
+
+        def inspect
+          "#<Hytale::Client::Map::Block id=#{id.inspect} x=#{x} y=#{y} z=#{z}>"
+        end
+
+        def to_h
+          {
+            id: id,
+            name: name,
+            category: category,
+            x: x,
+            y: y,
+            z: z,
+            world_x: world_x,
+            world_y: world_y,
+            world_z: world_z,
+          }
+        end
+
+        def ==(other)
+          return false unless other.is_a?(Block)
+
+          other.id == id && other.x == x && other.y == y && other.z == z &&
+            other.chunk == chunk
+        end
+
+        def eql?(other)
+          self == other
+        end
+
+        def hash
+          [id, x, y, z, chunk&.object_id].hash
+        end
+      end
+    end
+  end
+end