hytale 0.0.1 → 0.1.1

data/lib/hytale/client/player_skin.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    class PlayerSkin
+      attr_reader :data, :uuid, :path
+
+      def initialize(data, uuid: nil, path: nil)
+        @data = data
+        @uuid = uuid
+        @path = path
+      end
+
+      def body_characteristic = data["bodyCharacteristic"]
+      def underwear = data["underwear"]
+      def face = data["face"]
+      def ears = data["ears"]
+      def mouth = data["mouth"]
+      def haircut = data["haircut"]
+      def facial_hair = data["facialHair"]
+      def eyebrows = data["eyebrows"]
+      def eyes = data["eyes"]
+      def pants = data["pants"]
+      def overpants = data["overpants"]
+      def undertop = data["undertop"]
+      def overtop = data["overtop"]
+      def shoes = data["shoes"]
+      def head_accessory = data["headAccessory"]
+      def face_accessory = data["faceAccessory"]
+      def ear_accessory = data["earAccessory"]
+      def skin_feature = data["skinFeature"]
+      def gloves = data["gloves"]
+      def cape = data["cape"]
+
+      def equipped_items
+        data.compact
+      end
+
+      def empty_slots
+        data.select { |_, v| v.nil? }.keys
+      end
+
+      def avatar_preview_path
+        return nil unless uuid
+
+        path = File.join(Config.avatar_previews_path, "#{uuid}.png")
+        File.exist?(path) ? path : nil
+      end
+
+      def avatar_preview_data
+        path = avatar_preview_path
+        return nil unless path
+
+        File.binread(path)
+      end
+
+      def haircut_texture_path
+        Cosmetics.texture_path(:haircuts, haircut)
+      end
+
+      def facial_hair_texture_path
+        Cosmetics.texture_path(:facial_hair, facial_hair)
+      end
+
+      def eyebrows_texture_path
+        Cosmetics.texture_path(:eyebrows, eyebrows)
+      end
+
+      def eyes_texture_path
+        Cosmetics.texture_path(:eyes, eyes)
+      end
+
+      def face_texture_path
+        Cosmetics.texture_path(:faces, face)
+      end
+
+      def pants_texture_path
+        Cosmetics.texture_path(:pants, pants)
+      end
+
+      def overpants_texture_path
+        Cosmetics.texture_path(:overpants, overpants)
+      end
+
+      def undertop_texture_path
+        Cosmetics.texture_path(:undertops, undertop)
+      end
+
+      def overtop_texture_path
+        Cosmetics.texture_path(:overtops, overtop)
+      end
+
+      def shoes_texture_path
+        Cosmetics.texture_path(:shoes, shoes)
+      end
+
+      def gloves_texture_path
+        Cosmetics.texture_path(:gloves, gloves)
+      end
+
+      def cape_texture_path
+        Cosmetics.texture_path(:capes, cape)
+      end
+
+      def head_accessory_texture_path
+        Cosmetics.texture_path(:head_accessories, head_accessory)
+      end
+
+      def face_accessory_texture_path
+        Cosmetics.texture_path(:face_accessories, face_accessory)
+      end
+
+      def ear_accessory_texture_path
+        Cosmetics.texture_path(:ear_accessories, ear_accessory)
+      end
+
+      def texture_paths
+        {
+          haircut: haircut_texture_path,
+          facial_hair: facial_hair_texture_path,
+          eyebrows: eyebrows_texture_path,
+          eyes: eyes_texture_path,
+          face: face_texture_path,
+          pants: pants_texture_path,
+          overpants: overpants_texture_path,
+          undertop: undertop_texture_path,
+          overtop: overtop_texture_path,
+          shoes: shoes_texture_path,
+          gloves: gloves_texture_path,
+          cape: cape_texture_path,
+          head_accessory: head_accessory_texture_path,
+          face_accessory: face_accessory_texture_path,
+          ear_accessory: ear_accessory_texture_path,
+        }.compact
+      end
+
+      def to_s
+        "PlayerSkin: #{uuid || "unknown"}"
+      end
+
+      def to_h
+        data
+      end
+
+      class << self
+        def load(path)
+          raise NotFoundError, "Player skin not found: #{path}" unless File.exist?(path)
+
+          json = File.read(path)
+          data = JSON.parse(json)
+          uuid = File.basename(path, ".json")
+
+          new(data, uuid: uuid, path: path)
+        rescue JSON::ParserError => e
+          raise ParseError, "Failed to parse player skin: #{e.message}"
+        end
+
+        def all
+          skins_path = Config.player_skins_path
+          return [] unless skins_path && File.directory?(skins_path)
+
+          Dir.glob(File.join(skins_path, "*.json")).map do |path|
+            load(path)
+          end
+        end
+
+        def find(uuid)
+          skins_path = Config.player_skins_path
+          return nil unless skins_path
+
+          path = File.join(skins_path, "#{uuid}.json")
+          return nil unless File.exist?(path)
+
+          load(path)
+        end
+      end
+    end
+  end
+end

data/lib/hytale/client/prefab/palette_entry.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    class Prefab
+      class PaletteEntry
+        attr_reader :index, :name, :flags, :block_id, :extra
+
+        def initialize(index:, name:, flags:, block_id:, extra:)
+          @index = index
+          @name = name
+          @flags = flags
+          @block_id = block_id
+          @extra = extra
+        end
+
+        def state_definition?
+          name.start_with?("*")
+        end
+
+        def base_name
+          state_definition? ? name[1..] : name
+        end
+
+        def block_category
+          parts = name.split("_")
+
+          return parts[0] if parts.any?
+
+          nil
+        end
+
+        def to_s
+          "#{name} (ID: 0x#{format("%04X", block_id)})"
+        end
+
+        def to_h
+          {
+            index: index,
+            name: name,
+            flags: flags,
+            block_id: block_id,
+            extra: extra,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/hytale/client/prefab.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    # Parses .prefab.json.lpf files containing prefab structure data
+    #
+    # File format:
+    #   Header (21 bytes):
+    #     - Palette offset (2 bytes, BE) = typically 21
+    #     - Header value (2 bytes, BE) = typically 10
+    #     - Reserved/dimensions (10 bytes)
+    #     - Palette count (2 bytes, BE)
+    #     - Reserved (5 bytes)
+    #
+    #   Block Palette:
+    #     - N entries, each:
+    #       - String length (1 byte)
+    #       - Block name (N bytes)
+    #       - Flags (2 bytes, BE)
+    #       - Block ID (2 bytes, BE)
+    #       - Extra data (1 byte)
+    #
+    #   Placement Data:
+    #     - Block placement coordinates (format varies)
+    #
+    class Prefab
+      HEADER_SIZE = 21
+
+      attr_reader :path
+
+      def initialize(path)
+        @path = path
+        @data = nil
+        @header_parsed = false
+        @palette = nil
+      end
+
+      def filename
+        File.basename(path)
+      end
+
+      def name
+        filename.sub(/\.prefab\.json\.lpf$/, "")
+      end
+
+      def size
+        File.size(path)
+      end
+
+      def size_kb
+        (size / 1024.0).round(2)
+      end
+
+      def modified_at
+        File.mtime(path)
+      end
+
+      def palette_offset
+        parse_header unless @header_parsed
+        @palette_offset
+      end
+
+      def palette_count
+        parse_header unless @header_parsed
+        @palette_count
+      end
+
+      def palette
+        @palette ||= parse_palette
+      end
+
+      def block_names
+        palette.map(&:name)
+      end
+
+      def block_ids
+        palette.map(&:block_id)
+      end
+
+      def block_by_id(id)
+        palette.find { |entry| entry.block_id == id }
+      end
+
+      def block_by_name(name)
+        palette.find { |entry| entry.name == name }
+      end
+
+      def category
+        parts = path.split(File::SEPARATOR)
+        prefabs_index = parts.index("Prefabs")
+
+        return nil unless prefabs_index && parts.length > prefabs_index + 1
+
+        parts[prefabs_index + 1]
+      end
+
+      def subcategory
+        parts = path.split(File::SEPARATOR)
+        prefabs_index = parts.index("Prefabs")
+
+        return nil unless prefabs_index && parts.length > prefabs_index + 2
+
+        parts[prefabs_index + 2]
+      end
+
+      def to_s
+        "Prefab: #{name} (#{palette.size} block types, #{size_kb} KB)"
+      end
+
+      def to_h
+        {
+          name: name,
+          path: path,
+          size: size,
+          category: category,
+          palette: palette.map(&:to_h),
+        }
+      end
+
+      class << self
+        def load(path)
+          raise NotFoundError, "Prefab not found: #{path}" unless File.exist?(path)
+
+          new(path)
+        end
+      end
+
+      private
+
+      def data
+        @data ||= File.binread(path)
+      end
+
+      def parse_header
+        return if @header_parsed
+
+        @palette_offset = data[0, 2].unpack1("n")
+        # Bytes 2-3: header value (unused)
+        # Bytes 4-13: reserved/dimension data
+        @palette_count = data[14, 2].unpack1("n")
+
+        @header_parsed = true
+      end
+
+      def parse_palette
+        parse_header unless @header_parsed
+
+        entries = []
+        pos = @palette_offset
+
+        @palette_count.times do |index|
+          break if pos >= data.size
+
+          str_len = data[pos].ord
+          pos += 1
+
+          break if pos + str_len + 5 > data.size
+
+          name = data[pos, str_len]
+          pos += str_len
+
+          flags = data[pos, 2].unpack1("n")
+          pos += 2
+
+          block_id = data[pos, 2].unpack1("n")
+          pos += 2
+
+          extra = data[pos].ord
+          pos += 1
+
+          entries << PaletteEntry.new(
+            index: index,
+            name: name,
+            flags: flags,
+            block_id: block_id,
+            extra: extra
+          )
+        end
+
+        entries
+      end
+    end
+  end
+end

data/lib/hytale/client/process.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    class Process
+      attr_reader :pid, :started_at
+
+      def initialize(pid:, started_at: nil)
+        @pid = pid
+        @started_at = started_at
+      end
+
+      def running?
+        ::Process.kill(0, pid)
+        true
+      rescue Errno::ESRCH
+        false
+      rescue Errno::EPERM
+        true
+      end
+
+      class << self
+        def list
+          processes = []
+
+          case RUBY_PLATFORM
+          when /darwin/, /linux/
+            output = `pgrep -f "HytaleClient" 2>/dev/null`.strip
+
+            output.split("\n").each do |pid_str|
+              pid = pid_str.to_i
+              processes << new(pid: pid) if pid.positive?
+            end
+          when /mswin|mingw|cygwin/
+            output = `tasklist /FI "IMAGENAME eq HytaleClient.exe" /FO CSV 2>nul`.strip
+
+            output.split("\n").drop(1).each do |line|
+              parts = line.split(",")
+              pid = parts[1]&.tr('"', "")&.to_i
+              processes << new(pid: pid) if pid&.positive?
+            end
+          end
+
+          processes
+        end
+
+        def running?
+          list.any?
+        end
+
+        def find(pid)
+          list.find { |p| p.pid == pid }
+        end
+      end
+    end
+  end
+end

data/lib/hytale/client/save/backup.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    class Save
+      class Backup
+        attr_reader :path
+
+        def initialize(path)
+          @path = path
+        end
+
+        def filename
+          File.basename(path)
+        end
+
+        def size
+          File.size(path)
+        end
+
+        def size_mb
+          (size / 1024.0 / 1024.0).round(2)
+        end
+
+        # Parse from filename: 2026-01-13_17-36-28.zip
+        def created_at
+          match = filename.match(/(\d{4})-(\d{2})-(\d{2})_(\d{2})-(\d{2})-(\d{2})/)
+
+          return File.mtime(path) unless match
+
+          Time.new(
+            match[1].to_i, match[2].to_i, match[3].to_i,
+            match[4].to_i, match[5].to_i, match[6].to_i
+          )
+        end
+
+        def to_s
+          "Backup: #{filename} (#{size_mb} MB)"
+        end
+      end
+    end
+  end
+end

data/lib/hytale/client/save/server_log.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    class Save
+      class ServerLog
+        attr_reader :path
+
+        def initialize(path)
+          @path = path
+        end
+
+        def filename
+          File.basename(path)
+        end
+
+        def content
+          File.read(path)
+        end
+
+        def lines
+          content.lines
+        end
+
+        def created_at
+          match = filename.match(/(\d{4})-(\d{2})-(\d{2})_(\d{2})-(\d{2})-(\d{2})/)
+
+          return File.mtime(path) unless match
+
+          Time.new(
+            match[1].to_i, match[2].to_i, match[3].to_i,
+            match[4].to_i, match[5].to_i, match[6].to_i
+          )
+        end
+
+        def to_s
+          "ServerLog: #{filename}"
+        end
+      end
+    end
+  end
+end

data/lib/hytale/client/save.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Hytale
+  module Client
+    class Save
+      attr_reader :name, :path
+
+      def initialize(name, path: nil)
+        @name = name
+        @path = path || File.join(Config.saves_path, name)
+      end
+
+      def exists?
+        File.directory?(path)
+      end
+
+      def world(name = "default")
+        world_path = File.join(path, "universe", "worlds", name, "config.json")
+        World.load(world_path)
+      end
+
+      def map(world_name = "default")
+        Map.new(path, world_name: world_name)
+      end
+
+      def worlds
+        worlds_path = File.join(path, "universe", "worlds")
+
+        return [] unless File.directory?(worlds_path)
+
+        Dir.children(worlds_path)
+           .select { |d| File.directory?(File.join(worlds_path, d)) }
+           .map { |name| world(name) }
+      end
+
+      def world_names
+        worlds_path = File.join(path, "universe", "worlds")
+
+        return [] unless File.directory?(worlds_path)
+
+        Dir.children(worlds_path)
+           .select { |d| File.directory?(File.join(worlds_path, d)) }
+           .sort
+      end
+
+      def maps
+        world_names.map { |name| map(name) }
+      end
+
+      def players
+        players_path = File.join(path, "universe", "players")
+
+        return [] unless File.directory?(players_path)
+
+        Dir.glob(File.join(players_path, "*.json"))
+           .reject { |f| f.end_with?(".bak") }
+           .map { |f| Player.load(f) }
+      end
+
+      def player(uuid)
+        player_path = File.join(path, "universe", "players", "#{uuid}.json")
+        Player.load(player_path)
+      end
+
+      def memories
+        memories_path = File.join(path, "universe", "memories.json")
+
+        return Memories.new({}) unless File.exist?(memories_path)
+
+        Memories.load(memories_path)
+      end
+
+      def permissions
+        permissions_path = File.join(path, "permissions.json")
+
+        return Permissions.new({}) unless File.exist?(permissions_path)
+
+        Permissions.load(permissions_path)
+      end
+
+      def bans
+        bans_path = File.join(path, "bans.json")
+        return [] unless File.exist?(bans_path)
+
+        JSON.parse(File.read(bans_path))
+      end
+
+      def whitelist
+        whitelist_path = File.join(path, "whitelist.json")
+        return [] unless File.exist?(whitelist_path)
+
+        JSON.parse(File.read(whitelist_path))
+      end
+
+      def preview_path
+        File.join(path, "preview.png")
+      end
+
+      def preview_exists?
+        File.exist?(preview_path)
+      end
+
+      def backups
+        backup_path = File.join(path, "backup")
+        return [] unless File.directory?(backup_path)
+
+        Dir.glob(File.join(backup_path, "*.zip")).map do |f|
+          Backup.new(f)
+        end.sort_by(&:created_at).reverse
+      end
+
+      def logs
+        logs_path = File.join(path, "logs")
+        return [] unless File.directory?(logs_path)
+
+        Dir.glob(File.join(logs_path, "*.log")).map do |f|
+          ServerLog.new(f)
+        end.sort_by(&:created_at).reverse
+      end
+
+      def mods_path
+        File.join(path, "mods")
+      end
+
+      def mods
+        return [] unless File.directory?(mods_path)
+
+        Dir.children(mods_path).select { |d| File.directory?(File.join(mods_path, d)) }
+      end
+
+      def to_s
+        "Save: #{name}"
+      end
+
+      class << self
+        def all
+          return [] unless File.directory?(Config.saves_path)
+
+          Dir.children(Config.saves_path)
+             .select { |d| File.directory?(File.join(Config.saves_path, d)) }
+             .map { |name| new(name) }
+        end
+
+        def find(name)
+          save = new(name)
+          raise NotFoundError, "Save not found: #{name}" unless save.exists?
+
+          save
+        end
+
+        def exists?(name)
+          File.directory?(File.join(Config.saves_path, name))
+        end
+      end
+    end
+  end
+end