silkedit 0.1.10

data/lib/silkedit/cheats/cheatengine.rb

@@ -0,0 +1,33 @@
+module Silkedit::Cheat
+  class Engine
+    def initialize(savedata)
+      @data = savedata
+      game = detect_game(@data)
+      @modules = %w[Cheats Zoner Journaler].map { |type| [type, Silkedit::Cheat.const_get("#{game}#{type}")]}.to_h
+      @modules.each_value { |mod| self.extend(mod) }
+    end
+
+    def apply_cheat(cheat, *args)
+      return :no_cheat unless cheat_exists?(cheat.to_s)
+      self.send(cheat.to_sym, *args)
+    end
+
+    def apply_cheats(cheats)
+      cheats.map { |cheat| apply_cheat(cheat) }
+    end
+
+    def list_cheats
+      @modules['Cheats'].instance_methods.map(&:to_s).sort
+    end
+
+    def cheat_exists?(cheat)
+      list_cheats.include?(cheat)
+    end
+
+    private
+
+    def detect_game(data = nil)
+      (data || @data).key?('firstGeo') ? 'HollowKnight' : 'Silksong'
+    end
+  end
+end

data/lib/silkedit/cheats/hollow_knight_cheats.rb

@@ -0,0 +1,5 @@
+  module Silkedit::Cheat
+    module HollowKnightCheats
+
+    end
+  end

data/lib/silkedit/cheats/merger.rb

@@ -0,0 +1,107 @@
+module Silkedit::Cheat
+  def self.merge_cheat(data, cheat, should_merge_arrays: true, force_soft_reqs: false, enforce_min_act: false)
+    # 1. Check act requirement
+    game_act = self.get_game_act(data)
+    Rbcli.log.debug "Game act is #{game_act}, required act is #{cheat['min_act']}", 'CHEATS'
+    return :failed_act_check if enforce_min_act && cheat.key?('min_act') && game_act < cheat['min_act']
+
+    # 2. Check hard reqs and abort if not met
+    if cheat.key?('hard_reqs') && !cheat['hard_reqs'].nil? && !cheat['hard_reqs'].empty?
+      return :failed_hard_reqs unless verify_hash(data, cheat['hard_reqs'])
+    end
+
+    # 3. Check soft reqs, and either queue them to be applied or abort
+    queue_soft_reqs = false
+    if cheat.key?('soft_reqs') && !cheat['soft_reqs'].nil? && !cheat['soft_reqs'].empty?
+      unless verify_hash(data, cheat['soft_reqs'])
+        return :failed_soft_reqs unless force_soft_reqs
+        queue_soft_reqs = true
+      end
+    end
+
+    # 4. Apply cheat
+    self.merge_hash(data, cheat['soft_reqs'], should_merge_arrays: true) if queue_soft_reqs
+    self.merge_hash(data, cheat['data'], should_merge_arrays: should_merge_arrays)
+    :success
+  end
+
+  def self.merge_hash(data, cheat, should_merge_arrays: true)
+    cheat.each_key do |k|
+      if cheat[k].is_a?(Hash) && data[k].is_a?(Hash)
+        merge_hash(data[k], cheat[k])
+      elsif should_merge_arrays && cheat[k].is_a?(Array) && data[k].is_a?(Array)
+        if cheat[k][0].is_a?(Hash)
+          data[k] = merge_arrays_by_hash_keys(data[k], cheat[k])
+        else
+          data[k].merge!(cheat[k])
+          data[k].uniq!
+        end
+      else
+        data[k] = cheat[k]
+      end
+    end
+    true
+  end
+
+  def self.merge_arrays_by_hash_keys(data, cheat)
+    return data unless data.is_a?(Array) && cheat.is_a?(Array) && cheat.first.is_a?(Hash)
+    if data.empty?
+      data = cheat
+      return data
+    end
+    # First determine the primary key(s) for the object
+    pkeys = []
+    [%w[Name], %w[SceneName ID]].each do |pkey_arr|
+      pkeys = pkey_arr if pkey_arr.all? { |k| data.first.key?(k) || cheat.first.key?(k) }
+    end
+    cheat.each do |c|
+      idx = data.find_index { |d| d.is_a?(Hash) && pkeys.all? { |k| d.key?(k) && d[k] == c[k] } }
+      if idx
+        self.merge_hash(data[idx], c, should_merge_arrays: true)
+      else
+        data << c
+      end
+    end
+    data
+  end
+
+  def self.verify_hash(data, reqs)
+    reqs.each_key do |k|
+      if reqs[k].is_a?(Hash) && data[k].is_a?(Hash)
+        return false unless verify_hash(data[k], reqs[k])
+      elsif reqs[k].is_a?(Array) && data[k].is_a?(Array)
+        if reqs[k].first.is_a?(Hash)
+          return false unless verify_array_of_hashes(data[k], reqs[k])
+        else
+          return false unless reqs[k].all? { |r| data[k].include?(r) }
+        end
+      else
+        return false unless data[k] == reqs[k]
+      end
+    end
+    true
+  end
+
+  def self.verify_array_of_hashes(data, reqs)
+    # First determine the primary key(s) for the object
+    pkeys = []
+    [%w[Name], %w[SceneName ID]].each do |pkey_arr|
+      pkeys = pkey_arr if pkey_arr.all? { |k| data.first.key?(k) || reqs.first.key?(k) }
+    end
+    reqs.each do |r|
+      idx = data.find_index { |d| d.is_a?(Hash) && pkeys.all? { |k| d.key?(k) && d[k] == r[k] } }
+      return false unless idx && self.verify_hash(data[idx], r)
+    end
+    true
+  end
+
+  def self.get_game_act(data)
+    if %w[act3MapUpdated act3_wokeup].any? { |c| data['playerData'][c] }
+      3
+    elsif %w[act2started visitedCitadel defeatedLastJudge].any? { |c| data['playerData'][c] }
+      2
+    else
+      1
+    end
+  end
+end

data/lib/silkedit/cheats/silksong_cheats.rb

@@ -0,0 +1,161 @@
+require 'yaml'
+
+module Silkedit::Cheat
+  module SilksongCheats
+    @cheatdata = YAML.safe_load_file(File.join(Silkedit::LIBDIR, 'config', 'silksong', 'cheatdata.yaml'), symbolize_names: false)
+    @cheatdata['cheats'].each do |cheat, cht_data|
+      next if self.instance_methods.include?(cheat.to_sym)
+      self.define_method(cheat.to_sym) do
+        Rbcli.log.info "Applying cheat #{cheat}", 'CHEATS'
+        Silkedit::Cheat.merge_cheat(@data, cht_data, should_merge_arrays: true)
+      end
+    end
+
+    def unkill
+      Rbcli.log.info 'Reviving from death', 'CHEATS'
+      if @data['playerData']['permadeathMode'] == 2
+        @data['playerData']['permadeathMode'] = 1
+      end
+      @data['playerData']['geo'] += @data['playerData']['HeroCorpseMoneyPool']
+      @data['playerData']['HeroDeathScenePos'] = { 'x' => 0.0, 'y' => 0.0 }
+      @data['playerData']['HeroDeathSceneSize'] = { 'x' => 0.0, 'y' => 0.0 }
+      @data['playerData']['HeroCorpseType'] = 0
+      @data['playerData']['HeroCorpseMoneyPool'] = 0
+      @data['playerData']['hazardRespawnFacing'] = 0
+      @data['playerData']['IsSilkSpoolBroken'] = false
+      @data['playerData'].delete('HeroCorpseMarkerGuid')
+      @data['playerData'].delete('HeroCorpseScene')
+    end
+
+    def refresh
+      self.max_shards
+      self.max_liquids
+    end
+
+    def max_everything
+      backup_data = @data.dup
+      result = %w[
+        max_health
+        max_silk
+        max_weapon
+        max_tool_upgrades
+        max_liquids
+        all_abilities
+        all_crests
+        all_crest_unlocks
+        all_eva_upgrades
+        all_spells
+        all_tools
+        give_consumables
+        max_rosaries
+        max_shards
+      ].map { |cht| self.send(cht.to_sym) }
+      if result.all?(:success)
+        :success
+      else
+        @data = backup_data
+        result.reject { |r| r == :success }.first
+      end
+    end
+
+    def max_shards
+      Rbcli.log.info 'Applying cheat max_shards', 'CHEATS'
+      @data['playerData']['ShellShards'] = 400 + (@data['playerData']['ToolPouchUpgrades'] || 0) * 100
+      :success
+    end
+
+    def all_crests
+      cheatdata = Silkedit::Cheat::SilksongCheats.module_eval { @cheatdata }
+      Rbcli.log.info "Applying cheat all_crests", 'CHEATS'
+      Silkedit::Cheat.merge_cheat(@data, cheatdata['reference']['all_crests'], should_merge_arrays: true)
+      %w[CurrentCrestID PreviousCrestID].each do |equip|
+        %w[Hunter Hunter_v2].each do |hunter_crest_version|
+          @data['playerData'][equip] = 'Hunter_v3' if @data['playerData'][equip] == hunter_crest_version
+        end
+      end
+      :success
+    end
+
+    def all_crest_unlocks
+      Rbcli.log.info 'Applying cheat all_crest_unlocks', 'CHEATS'
+      cheatdata = Silkedit::Cheat::SilksongCheats.module_eval { @cheatdata }
+      @data['playerData']['ToolEquips']['savedData'].each do |crest|
+        if crest['Data']['Slots'].nil? || crest['Data']['Slots'].empty?
+          newcrest = cheatdata['reference']['full_crests']['playerData']['ToolEquips']['savedData'].find { |c| c['Name'] == crest['Name'] }
+          next if newcrest.nil?
+          crest['Data'] = {} if crest['Data'].nil?
+          crest['Data']['Slots'] = newcrest['Data']['Slots'] if newcrest.key?('Data') && newcrest['Data'].key?('Slots')
+        end
+        crest['Data']['Slots'].each { |slot| slot['IsUnlocked'] = true }
+      end
+      :success
+    end
+
+    def overcharge_tools
+      Rbcli.log.info "Applying cheat overcharge_tools", 'CHEATS'
+      @data['playerData']['Tools']['savedData'].each do |tool|
+        tool['Data']['AmountLeft'] = 1000
+      end
+      :success
+    end
+
+    def toggle_map_reveal
+      @data['playerData']['mapAllRooms'] = !@data['playerData']['mapAllRooms']
+      Rbcli.log.info "Full map reveal is #{@data['playerData']['mapAllRooms'] ? 'enabled' : 'disabled'}", 'CHEATS'
+      :success
+    end
+
+    def toggle_flea_reveal
+      flea_keys = @data['playerData'].keys.select { |k| k.start_with?('hasPinFlea') }
+      is_enabled = flea_keys.all? { |k| @data['playerData'][k] }
+      flea_keys.each { |k| @data[k] = !is_enabled }
+      Rbcli.log.info "Flea locations are #{is_enabled ? 'hidden' : 'revealed'} on map", 'CHEATS'
+      :success
+    end
+
+    def toggle_cloakless
+      if @data['playerData']['CurrentCrestID'] != 'Cloakless'
+        Rbcli.log.info 'Going cloakless', 'CHEATS'
+        @data['playerData']['TempGeoStore'] = @data['playerData']['geo']
+        @data['playerData']['geo'] = 0
+        @data['playerData']['TempShellShardStore'] = @data['playerData']['ShellShards']
+        @data['playerData']['ShellShards'] = 0
+        @data['playerData']['PreviousCrestID'] = @data['playerData']['CurrentCrestID']
+        @data['playerData']['CurrentCrestID'] = 'Cloakless'
+        @data['playerData']['slab_cloak_battle_encountered'] = false
+        @data['playerData']['slab_cloak_battle_completed'] = false
+        @data['playerData']['IsSilkSpoolBroken'] = true
+        unless @data['playerData']['ToolEquips']['savedData'].find { |e| e['Name'] == 'Cloakless' }
+          cheatdata = Silkedit::Cheat::SilksongCheats.module_eval { @cheatdata }
+          @data['playerData']['ToolEquips']['savedData'].append(cheatdata['reference']['cloakless']['playerData']['ToolEquips']['savedData'].first)
+        end
+      else
+        Rbcli.log.info 'Recovering cloak', 'CHEATS'
+        @data['playerData']['geo'] = @data['playerData']['TempGeoStore']
+        @data['playerData']['TempGeoStore'] = 0
+        @data['playerData']['ShellShards'] = @data['playerData']['TempShellShardStore']
+        @data['playerData']['TempShellShardStore'] = 0
+        @data['playerData']['CurrentCrestID'] = @data['playerData']['PreviousCrestID']
+        @data['playerData']['PreviousCrestID'] = 'Cloakless'
+        # @data['playerData']['slab_cloak_battle_encountered'] = true
+        # @data['playerData']['slab_cloak_battle_completed'] = true
+        @data['playerData']['IsSilkSpoolBroken'] = false
+      end
+      :success
+    end
+
+    def toggle_permadeath_mode
+      toggle = @data['playerData']['permadeathMode'] == 0
+      Rbcli.log.info "Toggling permadeath mode #{toggle ? 'ON' : 'OFF'}", 'CHEATS'
+      @data['playerData']['permadeathMode'] = toggle ? 1 : 0
+      :success
+    end
+
+    def toggle_fly_mode
+      toggle = @data['playerData']['infiniteAirJump'] == false
+      Rbcli.log.info "Toggling fly mode #{toggle ? 'ON' : 'OFF'}", 'CHEATS'
+      @data['playerData']['infiniteAirJump'] = toggle ? true : false
+      :success
+    end
+  end
+end

data/lib/silkedit/cheats/silksong_enemyjournal.rb

@@ -0,0 +1,120 @@
+require 'open-uri'
+require 'nokogiri'
+
+module Silkedit::Cheat
+  module SilksongJournaler
+    @enemylist = YAML.safe_load_file(File.join(Silkedit::LIBDIR, 'config', 'silksong', 'enemylist.yaml'), symbolize_names: false)
+
+    def update_journal(should_update_kills_only: true)
+      enemylist = Silkedit::Cheat::SilksongJournaler.module_eval { @enemylist }
+      Rbcli.log.info 'Applying ', 'JOURNAL'
+      enemylist['playerData']['EnemyJournalKillData']['list'].sort_by { |known_enemy| known_enemy['Position']}.each do |known_enemy|
+        sleep 0.01
+        player_enemy = @data['playerData']['EnemyJournalKillData']['list'].find { |i| i['Name'] == known_enemy['Name'] }
+        self.display_enemy(known_enemy, player_enemy, show_images: false)
+        if player_enemy.nil?
+          if should_update_kills_only
+            Rbcli.log.info "    Not Seen. Skipping.".colorize(:grey)
+          else
+            new_entry = {
+              'Name' => known_enemy['Name'],
+              'Record' => {
+                'Kills' => known_enemy['Record']['Kills'],
+                'HasBeenSeen' => false
+              } }
+            @data['playerData']['EnemyJournalKillData']['list'].append(new_entry)
+            Rbcli.log.info "    Added to journal.".colorize(:magenta)
+          end
+        elsif player_enemy['Record']['Kills'] < known_enemy['Record']['Kills']
+          next if (known_enemy['Record']['Kills'] < 10) && !Silkedit::Sys.yes_no?("    Set #{known_enemy['GameName'].colorize(:blue)} kills from #{player_enemy['Record']['Kills'].to_s.colorize(:red)} to #{known_enemy['Record']['Kills'].to_s.colorize(:green)}?")
+          player_enemy['Record']['Kills'] = known_enemy['Record']['Kills']
+          player_enemy['Record']['HasBeenSeen'] = true
+          Rbcli.log.info "    Updated kills.".colorize(:cyan)
+        else
+          Rbcli.log.info "    Already Completed.".colorize(:green)
+        end
+      end
+    end
+
+    def enemy_list(only_missing: false, show_images: false)
+      enemylist = Silkedit::Cheat::SilksongJournaler.module_eval { @enemylist }
+      enemylist['playerData']['EnemyJournalKillData']['list'].sort_by { |known_enemy| known_enemy['Position']}.each do |known_enemy|
+        player_enemy = @data['playerData']['EnemyJournalKillData']['list'].find { |i| i['Name'] == known_enemy['Name'] }
+        left = player_enemy.nil? ? known_enemy['Record']['Kills'] : known_enemy['Record']['Kills'] - player_enemy['Record']['Kills']
+        left = 0 if left < 0
+        next if only_missing && left <= 0
+        self.display_enemy(known_enemy, player_enemy, show_images: show_images)
+      end
+    end
+
+    private
+
+    def display_enemy(known_enemy, player_enemy, show_images: false)
+      self.show_enemy_image(known_enemy['GameName']) if show_images
+      left = player_enemy.nil? ? known_enemy['Record']['Kills'] : known_enemy['Record']['Kills'] - player_enemy['Record']['Kills']
+      left = 0 if left < 0
+      e_complete = left <= 0 ? '*'.colorize(:cyan) : ' '
+      e_number = known_enemy['Position'].to_s.rjust(3)
+      e_name = known_enemy['GameName'].ljust(27).colorize(:blue).bold
+      e_seen = player_enemy.nil? ? 'N'.colorize(:red) : 'Y'.colorize(:green)
+      e_kills = (player_enemy.nil? ? 0 : player_enemy['Record']['Kills']).to_s.rjust(4).colorize(:green)
+      e_req = known_enemy['Record']['Kills'].to_s.rjust(4).colorize(:blue)
+      e_need = left.to_s.rjust(4).colorize(left <= 0 ? :cyan : :red)
+      Rbcli.log.info "#{e_number}. #{e_complete} #{e_name} Seen? #{e_seen} Kills: #{e_kills} Needed: #{e_req} Left: #{e_need}"
+    end
+
+    def show_enemy_image(name)
+      `which imgcat > /dev/null 2>&1`
+      return false unless $?.success?
+      enemy_name = name.gsub(' ', '_')
+      # enemy_image_directory = File.expand_path(Rbcli::Warehouse.get(:config, :parsedopts)[:images_directory])
+      enemy_image_directory = File.join(Silkedit::LIBDIR, 'images', 'silksong')
+      cached_image_option_1 = File.join(enemy_image_directory, "#{enemy_name}.png")
+      cached_image_option_2 = File.join(enemy_image_directory, "#{enemy_name}_(Silksong).png")
+
+      command = "imgcat '%s'"
+
+      if File.exist?(cached_image_option_1)
+        system(format(command, cached_image_option_1))
+      elsif File.exist?(cached_image_option_2)
+        system(format(command, cached_image_option_2))
+      else
+        got_image = self.get_large_enemy_image(enemy_name, cached_image_option_1)
+        got_image = self.get_large_enemy_image("#{enemy_name}_(Silksong)", cached_image_option_2) unless got_image
+        show_enemy_image(name) if got_image
+      end
+    end
+
+    def get_large_enemy_image(enemy_name, desired_filename)
+      begin
+        page_url = "https://hollowknight.wiki/w/#{enemy_name}"
+        html = URI.open(page_url, 'User-Agent' => 'Ruby/Nokogiri').read
+        doc = Nokogiri::HTML(html)
+        img = doc.at_css('img.pi-image-thumbnail')
+        return false unless img
+
+        raw = img['src'] || img['data-src'] || img['srcset']
+        return false unless raw && !raw.strip.empty?
+
+        raw = raw.split(',').first.split(/\s+/).first
+        image_url = if raw.start_with?('//')
+                      "https:#{raw}"
+                    elsif raw =~ %r{\Ahttps?://}
+                      raw
+                    else
+                      URI.join(page_url, raw).to_s
+                    end
+        URI.open(image_url, 'rb', 'User-Agent' => 'Ruby/Nokogiri') do |image_io|
+          FileUtils.mkdir_p(File.dirname(desired_filename)) unless File.directory?(File.dirname(desired_filename))
+          File.open(desired_filename, 'wb') do |file|
+            IO.copy_stream(image_io, file)
+          end
+        end
+        return true
+      rescue StandardError => _e
+        return false
+      end
+    end
+
+  end
+end

data/lib/silkedit/cheats/silksong_zoner.rb

@@ -0,0 +1,98 @@
+module Silkedit::Cheat
+  module SilksongZoner
+    @zonedata = YAML.safe_load_file(File.join(Silkedit::LIBDIR, 'config', 'silksong', 'zones.yaml'), symbolize_names: false)
+    @shortcuts = @zonedata['_shortcuts']
+    @zonelist = @zonedata.reject { |k, _v| k.start_with?('_') }.to_a.map do |region, r_values|
+      r_values.map do |spawnpoint, data|
+        {
+          "slug" => "#{region}.#{spawnpoint}",
+          "shortcut" => @shortcuts.values.include?("#{region}.#{spawnpoint}") ? @shortcuts.key("#{region}.#{spawnpoint}") : nil
+        }.merge(data)
+      end
+    end.flatten
+
+    def list_zones
+      zonelist = Silkedit::Cheat::SilksongZoner.module_eval { @zonelist }
+      zonelist.map { |z| z.select { |k, _v| %w[slug shortcut min_act].include?(k) }.transform_keys(&:to_sym) }
+    end
+
+    def list_shortcuts
+      Silkedit::Cheat::SilksongZoner.module_eval { @shortcuts }
+    end
+
+    def zone_to(zone, force_soft_reqs: false, enforce_min_act: true)
+      zonedata = Silkedit::Cheat::SilksongZoner.module_eval { @zonedata }
+      zonelist = Silkedit::Cheat::SilksongZoner.module_eval { @zonelist }
+      shortcuts = Silkedit::Cheat::SilksongZoner.module_eval { @shortcuts }
+      Rbcli.log.info "Zoning to #{zone}", 'ZONER'
+      return self.zone_to(shortcuts[zone], force_soft_reqs: force_soft_reqs, enforce_min_act: enforce_min_act) if shortcuts.key?(zone)
+      return :no_zone unless zonelist.find { |z| z['slug'] == zone }
+      region, target = zone.split('.')
+      Silkedit::Cheat.merge_cheat(
+        @data,
+        zonedata[region][target],
+        should_merge_arrays: true,
+        force_soft_reqs: force_soft_reqs,
+        enforce_min_act: enforce_min_act
+      )
+    end
+
+    def save_current_zone(name, shortcut = nil, act_override = nil, overwrite: false)
+      region, target = name.downcase.split('.')
+      return :badname unless region && target
+      return :badact if !act_override.nil? && (act_override < 1 || act_override > 3)
+      return :badshortcut if !shortcut.nil? && shortcut.include?('.')
+
+      zone = {
+        'data' => {
+          'playerData' => {
+            'atBench' => @data['playerData']['atBench'],
+            'respawnScene' => @data['playerData']['respawnScene'],
+            'mapZone' => @data['playerData']['mapZone'],
+            'extraRestZone' => @data['playerData']['extraRestZone'],
+            'respawnMarkerName' => @data['playerData']['respawnMarkerName'],
+            'respawnType' => @data['playerData']['respawnType'],
+            'hazardRespawnFacing' => @data['playerData']['hazardRespawnFacing'],
+          }
+        },
+        'soft_reqs' => {},
+        'hard_reqs' => {},
+        'min_act' => act_override || Silkedit::Cheat.get_game_act(@data)
+      }
+
+      rosarylock = @data['sceneData']['persistentBools']['serializedList'].find { |i| i['SceneName'] == @data['playerData']['respawnScene'] && i['ID'] == 'bell_toll_machine' }
+      zone['soft_reqs'].merge!({'sceneData' => {'persistentBools' => {'serializedList' => [rosarylock]}}}) unless rosarylock.nil?
+      leverlock = @data['sceneData']['persistentInts']['serializedList'].find { |i| i['SceneName'] == @data['playerData']['respawnScene'] && i['ID'].include?('Bellshrine Sequence') }
+      zone['soft_reqs'].merge!({'sceneData' => {'persistentInts' => {'serializedList' => [leverlock]}}}) unless leverlock.nil?
+
+      zonedata = Silkedit::Cheat::SilksongZoner.module_eval { @zonedata }
+      zonelist = Silkedit::Cheat::SilksongZoner.module_eval { @zonelist }
+      known_zone_idx = zonelist.find_index do |known_zone|
+        known_zone['data']['playerData']['respawnScene'] == zone['data']['playerData']['respawnScene'] &&
+        known_zone['data']['playerData']['respawnMarkerName'] == zone['data']['playerData']['respawnMarkerName']
+      end
+
+      if known_zone_idx
+        if overwrite
+          old_region, old_target = zonelist[known_zone_idx]['slug'].split('.')
+          zonedata[old_region].delete(old_target)
+          zonedata.delete(old_region) if zonedata[old_region].empty?
+        else
+          return zonelist[known_zone_idx]['slug']
+        end
+      end
+
+      zonedata[region] ||= {}
+      zonedata[region][target] = zone
+      zonedata[region] = zonedata[region].sort_by { |k, _v| k }.to_h
+      zonedata = zonedata.sort_by { |k, _v| k }.to_h
+
+      if shortcut
+        zonedata['_shortcuts'][shortcut] = "#{region}.#{target}"
+      end
+
+      File.write(File.join(Silkedit::LIBDIR, 'config', 'silksong', 'zones.yaml'), YAML.safe_dump(zonedata))
+      :success
+    end
+  end
+end

data/lib/silkedit/config/savegame.yaml

@@ -0,0 +1,13 @@
+---
+savegame_directory:
+  hollow_knight:
+    macos: '~/Library/Application Support/unity.Team Cherry.Hollow Knight'
+    linux: '~/.config/unity3d/Team Cherry/Hollow Knight'
+    windows: '%UserProfile%\AppData\LocalLow\Team Cherry\Hollow Knight'
+  silksong:
+    macos: '~/Library/Application Support/unity.Team-Cherry.Silksong/%STEAMID%'
+    linux: '~/.config/unity3d/Team Cherry/Hollow Knight Silksong/%STEAMID%'
+    windows: '%USERPROFILE%/AppData/LocalLow/Team Cherry/Hollow Knight Silksong/%STEAMID%'
+max_backups: 5
+use_yaml: true
+aes_key: 'UKu52ePUBwetZ9wNX88o54dnfKRu0T1l'

data/lib/silkedit/config/silkedit.yaml

@@ -0,0 +1,6 @@
+---
+editor_command: vi '%FILE%'
+permasave_file_location:
+  macos: '~/.silkedit.yaml'
+  linux: '~/.silkedit.yaml'
+  windows: '%APPDATA%\silkedit\silkedit.yaml'