silkedit 0.1.0

data/lib/commands/journal.rb

@@ -0,0 +1,34 @@
+Rbcli.command 'journal' do
+  description 'Manages the journal of enemy kills'
+  usage '[list|listmissing|complete|killsonly]'
+  parameter :showimages, 'Show images of the enemies', short: 'i', type: :bool, default: false
+  action do |opts, params, args, config, env|
+    command = args.first
+    if command.nil? || command.empty? || !%w[list listmissing complete killsonly].include?(command)
+      Rbcli.log.error "Must specify an action as one of: listall, listmissing, complete, killsonly"
+      next
+    end
+
+    s = Silkedit::Savegame::SaveFile.new(:silksong, opts[:savenum])
+    s.load_from_dat
+    c = Silkedit::Cheat::Engine.new(s.data)
+
+    case command
+    when 'listall'
+      c.enemy_list(only_missing: false, show_images: params[:showimages])
+    when 'listmissing'
+      c.enemy_list(only_missing: true, show_images: params[:showimages])
+    when 'complete'
+      c.update_journal(should_update_kills_only: false)
+      s.direct_backup
+      s.save_to_dat
+    when 'killsonly'
+      c.update_journal(should_update_kills_only: true)
+      s.direct_backup
+      s.save_to_dat
+    else
+      raise "Unknown command: #{command}"
+    end
+
+  end
+end

data/lib/commands/permasave_permaload.rb

@@ -0,0 +1,62 @@
+Rbcli.command 'permasave' do
+  description 'Saves a local copy of a game into the config to restore later.'
+  parameter :name, 'Name to give the savegame', short: :n, type: :string, required: true
+  action do |opts, params, args, config, env|
+    permasave_file = config[:permasave_file_location][Silkedit::Sys.os]
+    permasave_file = permasave_file.gsub('%APPDATA%', ENV['APPDATA'] || ENV['LOCALAPPDATA']) if Silkedit::Sys.os == :windows
+    permasave_file = File.expand_path(permasave_file)
+    unless File.exist?(permasave_file)
+      FileUtils.cp(File.join(Silkedit::LIBDIR, 'config', 'silksong', 'permasaves.yaml'), permasave_file)
+    end
+    permasaves = YAML.safe_load_file(permasave_file)
+    Rbcli.log.fatal('Permasaves file is corrupt. Please delete or fix it and try again.', exit_status: 1) unless permasaves.is_a?(Hash)
+
+    params[:name] = params[:name].downcase
+    if permasaves.key?(params[:name])
+      Rbcli.log.warn "Found existing permasave: #{params[:name]}"
+      next unless Silkedit::Sys.yes_no?('Overwrite?')
+    end
+
+    s = Silkedit::Savegame::SaveFile.new(:silksong, opts[:savenum])
+    s.load_from_dat
+    permasaves[params[:name]] = YAML.safe_dump(s.data).compress
+    File.write(permasave_file, YAML.safe_dump(permasaves))
+
+    Rbcli.log.info "Permasave #{params[:name]} saved from slot #{opts[:savenum]}"
+  end
+end
+
+Rbcli.command 'permaload' do
+  description 'Restores a permasave into the slot'
+  parameter :name, 'Name of the permasave to load', short: :n, type: :string, required: false
+  parameter :list, 'List all permasaves', short: :l, type: :bool, default: false
+  action do |opts, params, args, config, env|
+    permasave_file = config[:permasave_file_location][Silkedit::Sys.os]
+    permasave_file = permasave_file.gsub('%APPDATA%', ENV['APPDATA'] || ENV['LOCALAPPDATA']) if Silkedit::Sys.os == :windows
+    permasave_file = File.expand_path(permasave_file)
+    unless File.exist?(permasave_file)
+      FileUtils.cp(File.join(Silkedit::LIBDIR, 'config', 'silksong', 'permasaves.yaml'), permasave_file)
+    end
+    permasaves = YAML.safe_load_file(permasave_file)
+    Rbcli.log.fatal('Permasaves file is corrupt. Please delete or fix it and try again.', exit_status: 1) unless permasaves.is_a?(Hash)
+
+    if !params[:name] && !params[:list]
+      Rbcli.log.warn 'Must provide a permasave name to load, or use --(l)ist to list all permasaves.'
+      next
+    elsif params[:list]
+      Rbcli.log.info permasaves.keys.join("\n")
+      next
+    end
+    params[:name] = params[:name].downcase
+
+    s = Silkedit::Savegame::SaveFile.new(:silksong, opts[:savenum])
+    if permasaves.is_a?(Hash) && permasaves.key?(params[:name])
+      s.data = YAML.safe_load(permasaves[params[:name]].decompress)
+      s.data['profileID'] = opts[:savenum].to_i
+      s.save_to_dat
+      Rbcli.log.info "Permasave #{params[:name]} loaded to slot #{opts[:savenum]}."
+    else
+      Rbcli.log.warn "Permasave #{params[:name]} does not exist. Exiting."
+    end
+  end
+end

data/lib/commands/unpack_repack.rb

@@ -0,0 +1,27 @@
+Rbcli.command 'unpack' do
+  description 'Unpacks a save file or backup to JSON/YAML for manual editing'
+  parameter :backup_seq, 'Sequence number for the backup to unpack', short: :b, type: :integer
+  action do |opts, params, args, config, env|
+    s = Silkedit::Savegame::SaveFile.new(:silksong, opts[:savenum])
+    if params[:backup_seq].nil?
+      s.load_from_dat
+      s.save_to_json
+      Rbcli.log.info 'Unpacked savefile to json/yaml'
+    else
+      s.load_from_backup(seq_number: params[:backup_seq])
+      s.save_to_json
+      Rbcli.log.info "Unpacked backup ##{params[:backup_seq]}"
+    end
+  end
+end
+
+Rbcli.command 'repack' do
+  description 'Packs the JSON/YAML to the savefile'
+  action do |opts, params, args, config, env|
+    s = Silkedit::Savegame::SaveFile.new(:silksong, opts[:savenum])
+    s.load_from_json
+    s.direct_backup
+    s.save_to_dat
+    Rbcli.log.info 'Repacked savefile from json/yaml'
+  end
+end

data/lib/commands/zone_mkzone.rb

@@ -0,0 +1,102 @@
+Rbcli.command 'zone' do
+  description 'Zones the character to a different respawn point'
+  usage '<zone> (--(f)orce)'
+  parameter :force, 'Force select a spawn point even when requirements are not met. Changes may be made to your savegave.', type: :bool, default: false
+  parameter :list, 'Display the full list of zones to select from', type: :bool, default: false
+  action do |opts, params, args, config, env|
+    s = Silkedit::Savegame::SaveFile.new(:silksong, opts[:savenum])
+    s.load_from_dat
+    c = Silkedit::Cheat::Engine.new(s.data)
+
+    display_simple_zone_list = lambda do |list, cols|
+      display_set = []
+      rows = (c.list_shortcuts.length / cols.to_f).ceil
+      row_idx = 0
+      max_rows = rows - 1
+      c.list_shortcuts.length.times do |i|
+        display_set[row_idx] ||= []
+        display_set[row_idx] << c.list_shortcuts.keys[i]
+        row_idx += 1
+        row_idx = 0 if row_idx > max_rows
+      end
+      display_set.map { |row| row.map { |z| z.rjust(15) }.join(' ') }.join("\n")
+    end
+
+    display_detailed_zone_list = lambda do |list|
+      max_shortcut_length = list.map { |zone| (zone[:shortcut] || '').length }.max
+      formatter = "%-#{max_shortcut_length}s %3s %s"
+      final_string = ''
+      final_string << format(formatter, 'Shortcut', 'Act', 'Zone') + "\n"
+      final_string << list.map { |zone| format(formatter, zone[:shortcut], zone[:min_act], zone[:slug]) }.join("\n")
+      final_string
+    end
+
+    if args.empty? || params[:list]
+      Rbcli.log.info 'Shortcuts:'
+      Rbcli.log.info display_simple_zone_list.call(c.list_shortcuts, 5)
+    end
+
+    if params[:list]
+      Rbcli.log.info ''
+      Rbcli.log.info 'Zones:'
+      Rbcli.log.info display_detailed_zone_list.call(c.list_zones)
+    end
+
+    Rbcli.exit(0) if args.empty? || params[:list]
+
+    status = c.zone_to(args.first, force_soft_reqs: params[:force], enforce_min_act: !params[:force])
+    case status
+    when :no_zone
+      Rbcli.log.info "Could not zone to #{args.first}: Specified spawn point does not exist"
+      Rbcli.log.info 'Did you mean one of these?'
+      possible_zones = c.list_zones.select { |zone| zone[:slug].include?(args.first) || !zone[:shortcut].nil? && zone[:shortcut].include?(args.first) }
+      Rbcli.log.info display_detailed_zone_list.call(possible_zones)
+    when :failed_act_check
+      Rbcli.log.warn "Could not zone to #{args.first}: The player is in the wrong act. Use --(f)orce to override."
+    when :failed_soft_reqs
+      Rbcli.log.warn "Could not zone to #{args.first}: Soft requirements not met. Use --(f)orce to apply the required changes."
+    when :failed_hard_reqs
+      Rbcli.log.error "Could not zone to #{args.first}: Hard requirements not met. Zoning here would cause errors."
+    when :success
+      s.direct_backup
+      s.save_to_dat
+      Rbcli.log.info "Zoned to #{args.first}"
+    else
+      raise "Unknown status: #{status}"
+    end
+  end
+end
+
+Rbcli.command 'mkzone' do
+  description 'Adds a new spawn point to the library'
+  usage '<slug>'
+  parameter :slug, 'The slug of the zone to add', type: :string
+  parameter :act, 'Override default act detection', type: :integer
+  parameter :shortcut, 'Provide a shorter slug as a shortcut for the zone', short: 'o', type: :string
+  parameter :force, 'Force overwrite of existing zone', type: :bool, default: false
+  action do |opts, params, args, config, env|
+    if params[:slug].nil?
+      Rbcli.log.error 'Must provide a zone slug'
+      next
+    end
+
+    s = Silkedit::Savegame::SaveFile.new(:silksong, opts[:savenum])
+    s.load_from_dat
+    c = Silkedit::Cheat::Engine.new(s.data)
+
+    status = c.save_current_zone(params[:slug], params[:shortcut], params[:act], overwrite: params[:force])
+
+    case status
+    when :badname
+      Rbcli.log.error 'Invalid zone name. Zones must be formatted as: region.target'
+    when :badact
+      Rbcli.log.error 'Invalid act number. Act must be between 1 and 3, or leave blank for autodetection.'
+    when :badshortcut
+      Rbcli.log.error 'Invalid shortcut. Shortcuts must not have a period (.) in them.'
+    when :success
+      Rbcli.log.info "Added #{params[:slug]} to zonelist."
+    else
+      Rbcli.log.error "Duplicate zone found: #{status}. Use --(f)orce to overwrite."
+    end
+  end
+end

data/lib/config/config.rb

@@ -0,0 +1,28 @@
+Rbcli::Configurate.config do
+  ##### Config (Optional) #####
+  # The built-in config will automatically pull in a config file to a hash and vice versa
+  # It can either be used immutably (as user-defined configuration) and/or to store application state
+  #
+  #   file:                 <string> or <array>            (Required) Provide either a specific config file location or a hierarchy to search. If creating a :null type of config this can be omitted.
+  #   type:                 (:yaml|:json|:ini|:toml|:null) (Optional) Select which backend/file format to use. If the file has an associated extension (i.e. '.yaml') then this can be omitted.
+  #   schema_file:          <string>                       (Optional) The file location of a JSON Schema (https://json-schema.org). If provided, the config will automatically be validated. (default: nil)
+  #   schema_hash:          <string>                       (Optional) If you'd like to provide a JSON schema hash directly instead, do it here. May not use `schema_hash` and `schema_file` together. (default: nil)
+  #   save_on_exit:         (true|false)                   (Optional) Save changes to the config file on exit (default: false)
+  #   create_if_not_exists: (true|false)                   (Optional) Create the file using default values if it is not found on the system (default: false)
+  #   suppress_errors:      (true|false)                   (Optional) If set to false, the application will halt on any errors in loading the config. If set to true, defaults will be provided (default: true)
+  #   banner:               <string>                       (Optional) Define a banner to be placed at the top of the config file on disk. Note that it will only be written to backends that support comments
+  #   defaults:             <hash>                         (Optional) Defaults set here will be provided to your application if any values are missing in the config.
+  #                                                                     They will also be used to create new config files when the flag `create_if_not_exists` is set to true.
+  #   skeleton:             <string>                       (Optional) If a skeleton is provided, it will be used as the config source when creating new config files on disk instead of the defaults. (default: nil)`
+  #                                                                     Please provide the text exactly as you want the user to see it in the config file (plus the banner if provided).
+  file [File.join(Silkedit::LIBDIR, 'config', 'silkedit.yaml')]
+  type :yaml
+  # schema_file nil
+  # schema_hash nil
+  save_on_exit false
+  create_if_not_exists false
+  suppress_errors true
+  # banner nil
+  # defaults({ editor_command: "vi '%FILE%'", permasaves: {} })
+  # skeleton "eJzT1dXlSsvPt1JISiziAhFWSYlVAD1hBjs=".decompress
+end

data/lib/config/envvars.rb

@@ -0,0 +1,23 @@
+Rbcli::Configurate.envvars do
+  ##### Environment Variable Parsing (Optional) #####
+  # The envvars module can pull in all environment variables with a given
+  # prefix and organize them into a hash structure based on name.
+  # It will also parse the string values and convert them to the proper type (Integer, Boolean, etc)
+  # Any values set here will be treated as defaults and made available when a variable is missing
+  #
+  # For example, these two environment variables:
+  #   SILKEDIT_TERM_HEIGHT=40
+  #   SILKEDIT_TERM_WIDTH=120
+  # Would be declared here as:
+  #   prefix 'SILKEDIT'
+  #   envvar 'TERM_HEIGHT', 40
+  #   envvar 'TERM_WIDTH', 120
+  # And get loaded into the env hash as:
+  #   { term: { height: 40, width: 120 } }
+  #
+  # If the prefix is unset or equal to nil, the environment variables specified here will
+  # be loaded without one.
+  prefix 'SILKEDIT'
+  envvar 'SAVENUM', nil
+  envvar 'DEVELOPMENT', false
+end

data/lib/config/hooks.rb

@@ -0,0 +1,22 @@
+Rbcli::Configurate.hooks do
+  ##### Hooks (Optional) #####
+  # These hooks are scheduled on the Rbcli execution engine to run
+  # Pre- and Post- the command specified. They are executed after
+  # everything else has been initialized, so the runtime configuration
+  # values are all made available, as they will appear to the command.
+  #
+  # These are good for parsing and/or doing transformations on the provided
+  # configuration before passing them to the command, and for cleaning
+  # up your environment afterwards.
+  pre_execute do |opts, params, args, config, env|
+    opts[:savenum] = env[:savenum] if opts[:savenum].nil? && !env[:savenum].nil?
+
+    if !opts[:savenum].is_a?(Integer) || opts[:savenum] < 1 || opts[:savenum] > 4
+      Rbcli.log.fatal 'A savegame index between 1-4 must be specified either via the command line (-s #) or environment variable (SILKEDIT_SAVENUM=#). See help (-h) for details.', exit_status: 24
+    end
+  end
+
+  # post_execute do |opts, params, args, config, env|
+  #   Rbcli.log.info "I'm done running the command!"
+  # end
+end

data/lib/config/logger.rb

@@ -0,0 +1,36 @@
+Rbcli::Configurate.logger do
+  ##### Logger (Optional) #####
+  # The Rbcli logger is a wrapper around the standard Ruby `Logger` library
+  # It is recommended that - unless you want to use specialized output libraries (such as ncurses) - that all
+  #    of your application output is directed through the logger. This will allow for easy formatting and redirection
+  #    no matter how your application is run.
+  #
+  # Valid targets are: :stdout, :stderr, "/path/to/a/file", or an IO or StringIO object   (Default: :stdout)
+  # Valid levels are: :debug, :info, :warn, :error, :fatal, :unknown, :any                (Default: :info)
+  # Valid formats are: :display, :simple, :full, :ruby, :json, :apache, :lolcat           (Default: :display)
+  #
+  # The first three formats are designed to cover most use cases:
+  #   display:   For display on a terminal, with user interaction
+  #   simple:    For display on a terminal, for a developer
+  #   full:      For logging to a file, or using log collection software
+  # The next three are for specialized integrations in case you already have log collection configured:
+  #   ruby:      Default ruby logger format
+  #   json:      Each line is a JSON object
+  #   apache:    Follows the standard Apache log format
+  # As for :lolcat... if you can't guess what it does then give it a shot
+  logger target: :stdout, level: :info, format: :display
+  # Custom formats can also be defined here.
+  # Declaring a format here will not switch to it. However, if
+  # the `format` keyword is used without providing a Proc, it will switch
+  # to that format.
+  #
+  #   Format switch:      format :json
+  #   Format definition:  format :foo, Proc.new { |severity, datetime, progname, msg| "Foo! " + msg }
+  #
+  # You can also switch formats mid-execution by calling this method on
+  # the logger object itself.
+  #
+  #   Rbcli.log.format :json
+  #
+  # format :foo, Proc.new { |severity, datetime, progname, msg| "Foo! " + msg }
+end

data/lib/config/parser.rb

@@ -0,0 +1,34 @@
+Rbcli::Configurate.cli do
+  ##### Core Configuration (Required) #####
+  # appname          (Optional) - Defaults to the name of the executable
+  # author           (Optional) - A name or array of names
+  # email            (Optional) - An email for users to contact
+  # version          (Optional) - major.minor.patch notation, required if using update checks
+  # copyright_year   (Optional) - Self explanatory
+  # compatibility    (Optional) - Array of Operating Systems, devices, or other targets (For example: %w[MacOS Linux Ubuntu Windows Raspberry\ Pi]
+  # license          (Optional) - Convention is to use an identifier from here: https://spdx.org/licenses/
+  # helptext         (Optional) - Text that gets shown with --help or -h
+  appname nil
+  author ['Andrew Khoury']
+  email nil
+  version Silkedit::VERSION
+  copyright_year 2025
+  compatibility %w[MacOS Linux]
+  license 'GPL-3.0'
+  helptext 'This is a tool to quickly and easily edit savefiles for SilkSong.'
+  ##### CLI Options (Optional) #####
+  # These appear to commands as `opts`.
+  # Format:
+  #   opt :name, "Description"[, optional arguments ]
+  # Optional Arguments:
+  #   long: Specify the long form (--long) version of an argument. (Default: same as the name)
+  #   short: Specify the short form (-s) version of an argument. (Default: first letter of the name)
+  #   type: Specify the type. Valid options are :boolean, :float, :integer, :string, :io, :date. (Default: :boolean)
+  #     If the plural form of any of the above are used (i.e. ':strings') then the user can provide a comma-delimited list on the command line (--param=foo,bar)
+  #   required: If set to true, requires that this option is provided by the user. (Default: false)
+  #   multi: If set to true, allows the option to be provided multiple times (--param --param, or in short form, -pp). (Default: false)
+  #     When using this with a :boolean type, rather than returning `true` or `false`, it will return a count of the number of times the parameter was passed.
+  #   permitted: If set to an array, restricts input to the values within that array. (Default: nil (no restrictions))
+  opt :verbose, "Twice or more enables very-verbose output", multi: true
+  opt :savenum, "A number from 1-4, indicating which game save you'd like to address", short: 's', type: :integer
+end

data/lib/config/updatechecker.rb

@@ -0,0 +1,12 @@
+Rbcli::Configurate.updatechecker do
+  ##### Update Check (Optional) #####
+  # The application can warn users when a new version is released
+  # Checks can be done either by rubygems or by a Github repo
+  # Private servers for Github (enterprise) are supported
+  #
+  # Setting force_update to true will halt execution until it is updated
+  #
+  # For Github, an access_token is required for private repos. See: https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens
+  # gem 'silkedit', force_update: false, message: 'Please run `gem update silkedit` to upgrade to the latest version.'
+  # github 'repo/name', access_token: nil, enterprise_hostname: nil, force_update: false, message: 'Please download the latest version from Github'
+end

data/lib/silkedit/cheats/cheatengine.rb

@@ -0,0 +1,34 @@
+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 false unless cheat_exists?(cheat.to_s)
+      self.send(cheat.to_sym, *args)
+      true
+    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,103 @@
+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)
+          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 nil unless data.is_a?(Array) && cheat.is_a?(Array) && data.first.is_a?(Hash)
+    # First determine the primary key(s) for the object
+    pkeys = []
+    [%w[Name], %w[sceneData 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
+    true
+  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 data['playerData']['act3MapUpdated'] || data['playerData']['act3_wokeUp']
+      3
+    elsif data['playerData']['act2Started'] || data['playerData']['defeatedLastJudge']
+      2
+    else
+      1
+    end
+  end
+end

data/lib/silkedit/cheats/silksong_cheats.rb

@@ -0,0 +1,121 @@
+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
+      %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
+      ].each { |cht| self.send(cht.to_sym) }
+    end
+
+    def max_shards
+      Rbcli.log.info 'Applying cheat max_shards', 'CHEATS'
+      @data['playerData']['ShellShards'] = 400 + (@data['playerData']['ToolPouchUpgrades'] || 0) * 100
+    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
+    end
+
+    def toggle_map_reveal
+      @data['playerData']['mapAllRooms'] = !@data['playerData']['mapAllRooms']
+      Rbcli.log.info "Full map reveal is #{@data['playerData']['mapAllRooms'] ? 'enabled' : 'disabled'}", 'CHEATS'
+    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'
+    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
+    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
+    end
+  end
+end