silkedit 0.1.3 → 0.1.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
    
        checksums.yaml
    CHANGED
    
    | @@ -1,7 +1,7 @@ | |
| 1 1 | 
             
            ---
         | 
| 2 2 | 
             
            SHA256:
         | 
| 3 | 
            -
              metadata.gz:  | 
| 4 | 
            -
              data.tar.gz:  | 
| 3 | 
            +
              metadata.gz: a7f3339a4438bd794c4ed860bba4216a0b4bb018fdaa570d72f66e69388e975a
         | 
| 4 | 
            +
              data.tar.gz: d4a14494a7d827fd61c91e48f3b98500fc9c072f5718da7e504a14fc7f0ecb4c
         | 
| 5 5 | 
             
            SHA512:
         | 
| 6 | 
            -
              metadata.gz:  | 
| 7 | 
            -
              data.tar.gz:  | 
| 6 | 
            +
              metadata.gz: dc0d913626bbe4eb89b3b7d684642202ccbe02b73de78d5bfacf6cd11ed034a922e4c8011acb31a57b23c5f84b5d409babf7f91cb888462833783c47c3ac4134
         | 
| 7 | 
            +
              data.tar.gz: 5b4ee244c35db3d4eec09e6202f450f9681edfbec1a2c25d81ae3f27a3e3b724c9924dfbe78c3296cdeb8173ace4c698346943af8305550e67dac7e308e77ce9
         | 
| @@ -31,7 +31,7 @@ module Silkedit::Cheat | |
| 31 31 | 
             
                    merge_hash(data[k], cheat[k])
         | 
| 32 32 | 
             
                  elsif should_merge_arrays && cheat[k].is_a?(Array) && data[k].is_a?(Array)
         | 
| 33 33 | 
             
                    if cheat[k][0].is_a?(Hash)
         | 
| 34 | 
            -
                      merge_arrays_by_hash_keys(data[k], cheat[k])
         | 
| 34 | 
            +
                      data[k] = merge_arrays_by_hash_keys(data[k], cheat[k])
         | 
| 35 35 | 
             
                    else
         | 
| 36 36 | 
             
                      data[k].merge!(cheat[k])
         | 
| 37 37 | 
             
                      data[k].uniq!
         | 
| @@ -44,7 +44,11 @@ module Silkedit::Cheat | |
| 44 44 | 
             
              end
         | 
| 45 45 |  | 
| 46 46 | 
             
              def self.merge_arrays_by_hash_keys(data, cheat)
         | 
| 47 | 
            -
                return  | 
| 47 | 
            +
                return data unless data.is_a?(Array) && cheat.is_a?(Array) && cheat.first.is_a?(Hash)
         | 
| 48 | 
            +
                if data.empty?
         | 
| 49 | 
            +
                  data = cheat
         | 
| 50 | 
            +
                  return data
         | 
| 51 | 
            +
                end
         | 
| 48 52 | 
             
                # First determine the primary key(s) for the object
         | 
| 49 53 | 
             
                pkeys = []
         | 
| 50 54 | 
             
                [%w[Name], %w[sceneData ID]].each do |pkey_arr|
         | 
| @@ -58,7 +62,7 @@ module Silkedit::Cheat | |
| 58 62 | 
             
                    data << c
         | 
| 59 63 | 
             
                  end
         | 
| 60 64 | 
             
                end
         | 
| 61 | 
            -
                 | 
| 65 | 
            +
                data
         | 
| 62 66 | 
             
              end
         | 
| 63 67 |  | 
| 64 68 | 
             
              def self.verify_hash(data, reqs)
         | 
| @@ -117,5 +117,11 @@ module Silkedit::Cheat | |
| 117 117 | 
             
                  Rbcli.log.info "Toggling permadeath mode #{toggle ? 'ON' : 'OFF'}", 'CHEATS'
         | 
| 118 118 | 
             
                  @data['playerData']['permadeathMode'] = toggle ? 1 : 0
         | 
| 119 119 | 
             
                end
         | 
| 120 | 
            +
             | 
| 121 | 
            +
                def toggle_fly_mode
         | 
| 122 | 
            +
                  toggle = @data['playerData']['infiniteAirJump'] == false
         | 
| 123 | 
            +
                  Rbcli.log.info "Toggling fly mode #{toggle ? 'ON' : 'OFF'}", 'CHEATS'
         | 
| 124 | 
            +
                  @data['playerData']['infiniteAirJump'] = toggle ? true : false
         | 
| 125 | 
            +
                end
         | 
| 120 126 | 
             
              end
         | 
| 121 127 | 
             
            end
         | 
| @@ -770,6 +770,58 @@ cheats: | |
| 770 770 | 
             
                          Amount: 1
         | 
| 771 771 | 
             
                          IsSeenMask: 0
         | 
| 772 772 | 
             
                          AmountWhileHidden: 0
         | 
| 773 | 
            +
              ability_dash:
         | 
| 774 | 
            +
                data:
         | 
| 775 | 
            +
                  playerData:
         | 
| 776 | 
            +
                    hasDash: true
         | 
| 777 | 
            +
                    HasSeenDash: true
         | 
| 778 | 
            +
              ability_doublejump:
         | 
| 779 | 
            +
                data:
         | 
| 780 | 
            +
                  playerData:
         | 
| 781 | 
            +
                    hasDoubleJump: true
         | 
| 782 | 
            +
              ability_drift:
         | 
| 783 | 
            +
                data:
         | 
| 784 | 
            +
                  playerData:
         | 
| 785 | 
            +
                    hasBrolly: true
         | 
| 786 | 
            +
              ability_walljump:
         | 
| 787 | 
            +
                data:
         | 
| 788 | 
            +
                  playerData:
         | 
| 789 | 
            +
                    hasWalljump: true
         | 
| 790 | 
            +
                    HasSeenWalljump: true
         | 
| 791 | 
            +
              ability_needolin:
         | 
| 792 | 
            +
                data:
         | 
| 793 | 
            +
                  playerData:
         | 
| 794 | 
            +
                    hasNeedolin: true
         | 
| 795 | 
            +
                    HasSeenNeedolin: true
         | 
| 796 | 
            +
              ability_needolin_up:
         | 
| 797 | 
            +
                data:
         | 
| 798 | 
            +
                  playerData:
         | 
| 799 | 
            +
                    hasNeedolinMemoryPowerup: true
         | 
| 800 | 
            +
                    HasSeenNeedolinUp: true
         | 
| 801 | 
            +
              ability_needolin_down:
         | 
| 802 | 
            +
                data:
         | 
| 803 | 
            +
                  playerData:
         | 
| 804 | 
            +
                    UnlockedFastTravelTeleport: true
         | 
| 805 | 
            +
                    HasSeenNeedolinDown: true
         | 
| 806 | 
            +
              ability_harpoon:
         | 
| 807 | 
            +
                data:
         | 
| 808 | 
            +
                  playerData:
         | 
| 809 | 
            +
                    hasHarpoonDash: true
         | 
| 810 | 
            +
                    HasSeenHarpoon: true
         | 
| 811 | 
            +
              ability_charge_weapon:
         | 
| 812 | 
            +
                data:
         | 
| 813 | 
            +
                  playerData:
         | 
| 814 | 
            +
                    hasChargeSlash: true
         | 
| 815 | 
            +
              ability_silkspecial:
         | 
| 816 | 
            +
                data:
         | 
| 817 | 
            +
                  playerData:
         | 
| 818 | 
            +
                    hasSilkSpecial: true
         | 
| 819 | 
            +
                    HasSeenSilkSpecial: true
         | 
| 820 | 
            +
              ability_superjump:
         | 
| 821 | 
            +
                data:
         | 
| 822 | 
            +
                  playerData:
         | 
| 823 | 
            +
                    hasSuperJump: true
         | 
| 824 | 
            +
                    HasSeenSuperJump: true
         | 
| 773 825 | 
             
              quill_none:
         | 
| 774 826 | 
             
                data:
         | 
| 775 827 | 
             
                  playerData:
         | 
| @@ -7,49 +7,50 @@ module Silkedit::Savegame | |
| 7 7 |  | 
| 8 8 | 
             
                  diff = nil
         | 
| 9 9 |  | 
| 10 | 
            -
                  if old.is_a?(Hash)
         | 
| 10 | 
            +
                  if old.is_a?(Hash) || new.is_a?(Hash)
         | 
| 11 11 | 
             
                    diff = {}
         | 
| 12 12 | 
             
                    (old.keys + new.keys).uniq.each do |k|
         | 
| 13 13 | 
             
                      itemdiff = mkdiff(old[k], new[k])
         | 
| 14 14 | 
             
                      diff[k] = itemdiff unless itemdiff.nil? || itemdiff.empty?
         | 
| 15 15 | 
             
                    end
         | 
| 16 | 
            -
                  elsif old.is_a?(Array)
         | 
| 16 | 
            +
                  elsif old.is_a?(Array) || new.is_a?(Array)
         | 
| 17 17 | 
             
                    diff = []
         | 
| 18 | 
            -
                    if old.first.is_a?(Hash)
         | 
| 19 | 
            -
             | 
| 20 | 
            -
             | 
| 21 | 
            -
             | 
| 22 | 
            -
             | 
| 23 | 
            -
                       | 
| 24 | 
            -
             | 
| 25 | 
            -
             | 
| 26 | 
            -
             | 
| 27 | 
            -
             | 
| 28 | 
            -
                       | 
| 29 | 
            -
             | 
| 30 | 
            -
             | 
| 31 | 
            -
             | 
| 32 | 
            -
             | 
| 33 | 
            -
             | 
| 34 | 
            -
             | 
| 35 | 
            -
             | 
| 36 | 
            -
             | 
| 37 | 
            -
                           | 
| 38 | 
            -
                           | 
| 39 | 
            -
                          keycomps.each { |k| newobj[k] = o[k] }
         | 
| 40 | 
            -
                          diff.append(newobj.merge(itemdiff))
         | 
| 41 | 
            -
                        end
         | 
| 42 | 
            -
                        new.each do |n|
         | 
| 43 | 
            -
                          o = old.find { |e| keycomps.map { |k| e[k] == n[k] }.reduce { |a, b| a && b } }
         | 
| 44 | 
            -
                          next unless o.nil?
         | 
| 45 | 
            -
                          itemdiff = mkdiff(
         | 
| 46 | 
            -
                            nil,
         | 
| 47 | 
            -
                            n.reject { |k, _v| keycomps.include?(k) }
         | 
| 48 | 
            -
                          )
         | 
| 49 | 
            -
                          newobj = {}
         | 
| 50 | 
            -
                          keycomps.each { |k| newobj[k] = n[k] }
         | 
| 51 | 
            -
                          diff.append(newobj.merge(itemdiff))
         | 
| 18 | 
            +
                    if (old.first.is_a?(Hash) && old.first.key?('Name')) ||
         | 
| 19 | 
            +
                       (new.first.is_a?(Hash) && new.first.key?('Name'))
         | 
| 20 | 
            +
                      keycomps = %w[Name]
         | 
| 21 | 
            +
                    elsif (old.first.is_a?(Hash) && old.first.key?('SceneName') && old.first.key?('ID')) ||
         | 
| 22 | 
            +
                          (new.first.is_a?(Hash) && new.first.key?('SceneName') && new.first.key?('ID'))
         | 
| 23 | 
            +
                      keycomps = %w[SceneName ID]
         | 
| 24 | 
            +
                    elsif (old.first.is_a?(Hash) && old.first.key?('SceneName') && old.first.key?('EventType')) ||
         | 
| 25 | 
            +
                          (new.first.is_a?(Hash) && new.first.key?('SceneName') && new.first.key?('EventType'))
         | 
| 26 | 
            +
                      keycomps = %w[SceneName EventType]
         | 
| 27 | 
            +
                    else
         | 
| 28 | 
            +
                      keycomps = nil
         | 
| 29 | 
            +
                    end
         | 
| 30 | 
            +
                    if keycomps.nil?
         | 
| 31 | 
            +
                      diff = { old: old.reject { |e| new.include?(e) }, new: new.reject { |e| old.include?(e) } }
         | 
| 32 | 
            +
                      diff = nil if diff[:old].empty? && diff[:new].empty?
         | 
| 33 | 
            +
                    else
         | 
| 34 | 
            +
                      old.each do |o|
         | 
| 35 | 
            +
                        n = new.find { |e| keycomps.map { |k| e[k] == o[k] }.reduce { |a, b| a && b } }
         | 
| 36 | 
            +
                        if n.nil?
         | 
| 37 | 
            +
                          diff.append({new: n, old: o})
         | 
| 38 | 
            +
                          next
         | 
| 52 39 | 
             
                        end
         | 
| 40 | 
            +
                        itemdiff = mkdiff(
         | 
| 41 | 
            +
                          o.reject { |k, _v| keycomps.include?(k) },
         | 
| 42 | 
            +
                          n.nil? ? nil : n.reject { |k, _v| keycomps.include?(k) }
         | 
| 43 | 
            +
                        )
         | 
| 44 | 
            +
                        next if itemdiff.empty?
         | 
| 45 | 
            +
                        newobj = {}
         | 
| 46 | 
            +
                        keycomps.each { |k| newobj[k] = o[k] }
         | 
| 47 | 
            +
                        diff.append(newobj.merge(itemdiff))
         | 
| 48 | 
            +
                      end
         | 
| 49 | 
            +
                      new.each do |n|
         | 
| 50 | 
            +
                        o = old.find { |e| keycomps.map { |k| e[k] == n[k] }.reduce { |a, b| a && b } }
         | 
| 51 | 
            +
                        next unless o.nil?
         | 
| 52 | 
            +
                        diff.append({new: n, old: o})
         | 
| 53 | 
            +
                        next
         | 
| 53 54 | 
             
                      end
         | 
| 54 55 | 
             
                    end
         | 
| 55 56 | 
             
                  elsif old != new
         | 
| @@ -71,7 +72,7 @@ module Silkedit::Savegame | |
| 71 72 | 
             
                        if line[i] == '-' && blank_leadup
         | 
| 72 73 | 
             
                          colored_string += line[i].colorize(:yellow)
         | 
| 73 74 | 
             
                          i += 1
         | 
| 74 | 
            -
                        elsif line[i] == ':' && blank_leadup
         | 
| 75 | 
            +
                        elsif line[i] == ':' && (blank_leadup || line[0..i-1].sub('-', '').chars.map { |c| c == ' ' }.all?)
         | 
| 75 76 | 
             
                          j = i + line[i+1..-1].index(':')
         | 
| 76 77 | 
             
                          colored_string += line[i..j].colorize(:magenta)
         | 
| 77 78 | 
             
                          i += j - i + 1
         | 
    
        data/lib/silkedit/version.rb
    CHANGED