rsgt 0.0.1

data/lib/rsgt/multipacker/config_processor.rb

@@ -0,0 +1,44 @@
+require "yaml"
+
+module RSGuitarTech
+  class Multipacker
+    class ConfigProcessor
+
+      attr_accessor :config
+
+      def initialize(opts)
+        @config = YAML.load_file opts[:config]
+        @packed = []
+      end
+
+      def process!
+        config["repacks"].each do |config_data|
+          packer = packer_for config_data
+          packer.process!
+          packer.send(:psarcs).each do |packed_psarc|
+            @packed << packed_psarc.split("/").last.split(" _m").first
+          end
+        end
+      end
+
+    private
+
+      def packer_for(config_data)
+        RSGuitarTech::Multipacker.new(
+          title:      config_data["title"],
+          directory:  config_data["directory"],
+          unpack_dir: config_data["unpack_dir"],
+          repack_dir: config_data["repack_dir"],
+          dest_dir:   config["destination"],
+          options:    {
+            reset_unpack: config_data["options"]["reset_unpack"],
+            reset_repack: config_data["options"]["reset_repack"]
+          },
+          filters: {
+            reject: @packed
+          }
+        )
+      end
+    end
+  end
+end

data/lib/rsgt/repacker.rb

@@ -0,0 +1,37 @@
+module RSGuitarTech
+  class Repacker
+
+    attr_accessor :psarc, :opts, :unpacked
+
+    def initialize(opts)
+      @psarc = File.expand_path(opts.delete :psarc)
+      @opts  = opts
+    end
+
+    def repack!
+      UnpackedPSARC.from_psarc(psarc, opts) do |unpacked|
+        repack_vocals(unpacked) if opts[:vocals_xml]
+        repack_audio(unpacked)  if opts[:audio]
+        unpacked.repack!
+      end
+    end
+
+  private
+
+    def repack_vocals(unpacked)
+      puts ".. Converting .xml to .sng"
+      CommandRunner.run! RSCustomSongToolkit.xml2sng(
+        manifest: unpacked.manifest(:vocals),
+        input:    opts[:vocals_xml]
+      )
+    end
+
+    def repack_audio(unpacked)
+      puts ".. Converting audio to .wem"
+      WWiseConverter.new(opts[:audio], opts).convert! do |converter|
+        FileUtils.cp converter.results[:main],    unpacked.audio_track
+        FileUtils.cp converter.results[:preview], unpacked.audio_track(track: :preview) if opts[:preview]
+      end
+    end
+  end
+end

data/lib/rsgt/rs_custom_song_toolkit.rb

@@ -0,0 +1,41 @@
+module RSGuitarTech
+  class RSCustomSongToolkit
+
+    PCB_PATH = "/Applications/RocksmithCustomSongToolkit.app/Contents/Resources/packed_codebooks_aoTuV_603.bin"
+
+    def self.ww2ogg(file)
+      base_cmd "ww2ogg", [file, "--pcb", PCB_PATH]
+    end
+
+    def self.revorb(file)
+      base_cmd "revorb", [file]
+    end
+
+    def self.sng2xml(manifest:, input:)
+      sng2014 "--sng2xml", manifest: manifest, input: input
+    end
+
+    def self.xml2sng(manifest:, input:)
+      sng2014 "--xml2sng", manifest: manifest, input: input
+    end
+
+  private
+
+    def self.sng2014(cmd, manifest:, input:, arrangement: "Vocal", platform: "Mac")
+      base_cmd "sng2014", [
+        cmd,
+        "--manifest=#{manifest}",
+        "--input=#{input}",
+        "--arrangement=#{arrangement}",
+        "--platform=#{platform}"
+      ]
+    end
+
+    def self.base_cmd(tool, args)
+      [
+        "wine",
+        "/Applications/RocksmithCustomSongToolkit.app/Contents/Resources/#{tool}.exe"
+      ] + args
+    end
+  end
+end

data/lib/rsgt/saved_game.rb

@@ -0,0 +1,37 @@
+module RSGuitarTech
+  class SavedGame
+
+    attr_accessor :json, :filename
+
+    def self.from(filename)
+      file    = File.open filename
+      profile = RSGuitarTech::EncryptedSteamFile.read(file)
+      self.new(profile.uncompressed_json, filename)
+    end
+
+    def initialize(json, filename)
+      @json     = json
+      @filename = filename
+    end
+
+    def options
+      json["Options"]
+    end
+
+    def statistics
+      @statistics ||= Statistics.new(json["Stats"])
+    end
+
+    def song_statistics
+      @song_statistics ||= SongCollection.new(Statistics, json["Stats"]["Songs"])
+    end
+
+    def score_attack
+      @score_attack ||= SongCollection.new(ScoreAttack, json["SongsSA"])
+    end
+
+    def learn_a_song
+      @learn_a_song ||= SongCollection.new(LearnASong, json["Songs"])
+    end
+  end
+end

data/lib/rsgt/saved_game/learn_a_song/song.rb

@@ -0,0 +1,46 @@
+module RSGuitarTech
+  class SavedGame
+    module LearnASong
+
+      DynamicDifficulty = Struct.new(:avg, :phrases, :level_up) do
+        # Avg = one of [0.0, 1.0, 2.0, 3.0, 4.0]
+        # Phrases = a whole big thing
+        # LevelUp = array of tiny floats
+      end
+
+      PlaynextStats = Struct.new(:timestamp, :phrase_iterations, :chords, :articulations, :phrases) do
+        # TimeStamp = duh
+        # PhraseIterations
+        # Chords
+        # Articulations
+        # Phrases
+      end
+
+      class Song
+        attr_accessor :id, :timestamp, :dynamic_difficulty, :play_next_stats
+
+        def self.from(key, json)
+          self.new(
+            id:                  key,
+            timestamp:           json["TimeStamp"],
+            dynamic_difficulty:  json["DynamicDifficulty"],
+            play_next_stats:     json["PlaynextStats"]
+          )
+        end
+
+        def initialize(id:, timestamp:, dynamic_difficulty:, play_next_stats:)
+          @id                 = id
+          @timestamp          = timestamp
+          @dynamic_difficulty = dynamic_difficulty
+          @play_next_stats    = play_next_stats
+        end
+
+        def ==(other)
+          return false if other == nil
+
+          id == other.id
+        end
+      end
+    end
+  end
+end

data/lib/rsgt/saved_game/score_attack/song.rb

@@ -0,0 +1,38 @@
+module RSGuitarTech
+  class SavedGame
+    module ScoreAttack
+
+      PICKS = {
+        2.0 => "Bronze",
+        3.0 => "Silver",
+        4.0 => "Gold",
+        5.0 => "Platinum",
+      }
+
+      DIFFICULTIES = %w{Easy Medium Hard Master}
+
+      class Song
+        attr_accessor :id, :timestamp, :play_count, :picks, :high_scores
+
+        def self.from(key, json)
+          self.new(
+            id:          key,
+            timestamp:   json["TimeStamp"],
+            play_count:  json["PlayCount"],
+            picks:       json["Badges"],
+            high_scores: json["HighScores"],
+          )
+        end
+
+        def initialize(id:, timestamp:, play_count:, picks:, high_scores:)
+          @id, @timestamp, @play_count, @picks, @high_scores = id, timestamp, play_count, picks, high_scores
+        end
+
+        def ==(other)
+          return false if other == nil
+          id == other.id
+        end
+      end
+    end
+  end
+end

data/lib/rsgt/saved_game/song_collection.rb

@@ -0,0 +1,16 @@
+module RSGuitarTech
+  class SavedGame
+    class SongCollection
+      attr_accessor :collection
+
+      delegate :values, :[], to: :collection
+
+      def initialize(klass, json)
+        @collection = json.inject({}) do |memo, (key, value)|
+          memo[key] = klass::Song.from(key, value)
+          memo
+        end
+      end
+    end
+  end
+end

data/lib/rsgt/saved_game/statistics.rb

@@ -0,0 +1,91 @@
+module RSGuitarTech
+  class SavedGame
+    class Statistics
+
+      attr_accessor :json
+
+      def initialize(json)
+        @json = json
+      end
+
+      # Timing Section
+      def session_seconds
+        json['SessionTime']
+      end
+
+      def las_seconds
+        json['TimePlayed']
+      end
+
+      def games_seconds
+        json['GuitarcadePlayedTime'].map(&:values).flatten.inject(&:+)
+      end
+
+      def lesson_second
+        json['TimePlayedAndLesson'] - las_seconds
+      end
+
+      def rs_seconds
+        session_seconds + las_seconds + games_seconds + lesson_second
+      end
+
+      # / Timing Section
+
+      def missions_completed
+        json['TotalNumMissionCompletions'].to_i
+      end
+
+      def session_count
+        json['SessionCnt'].to_i
+      end
+
+      def songs_played_count
+        json['SongsPlayedCount'].to_i
+      end
+
+      def songs_mastered_count
+        json['NumSongsMastered'].to_i
+      end
+
+      def dlc_played_count
+        json['DLCPlayedCount'].to_i
+      end
+
+      def songs_lead_played_count
+        json['SongsLeadPlayedCount'].to_i
+      end
+
+      def songs_rhythm_played_count
+        json['SongsRhythmPlayedCount'].to_i
+      end
+
+      def songs_bass_played_count
+        json['SongsBassPlayedCount'].to_i
+      end
+
+      def session_mission_time
+        json['SessionMissionTime']
+      end
+
+      def longest_streak
+        json['Streak'].to_i
+      end
+
+      def sa_songs_played_hard
+        json['SASongsPlayedHardAndMore'].to_i
+      end
+
+      def sa_songs_played_master
+        json['SASongsPlayedMaster'].to_i
+      end
+
+      def sa_songs_cleared_hard
+        json['SANumSongsClearedHard'].to_i
+      end
+
+      def sa_songs_cleared_master
+        json['SANumSongsClearedMaster'].to_i
+      end
+    end
+  end
+end

data/lib/rsgt/saved_game/statistics/song.rb

@@ -0,0 +1,58 @@
+module RSGuitarTech
+  class SavedGame
+    class Statistics
+
+      class Song
+        ATTRIBUTES = *%i{
+          id date_sa sa_platinum_point_awarded mastery_last sa_play_count played_count accuracy_global date_las accuracy_chords
+          mastery_previous mastery_peak mastery_previous_peak streak sa_win_count sa_general_point_awarded articulation_accuracy
+          chords_accuracies sa_fail_count score_attack_play_count
+        }
+
+        attr_accessor *ATTRIBUTES
+
+        def self.from(key, json)
+          sa_play_count = json["SAPlayCount"].map(&:values).flatten rescue []
+          self.new(
+            id:                        key,
+            date_sa:                   json["DateSA"],
+            sa_platinum_point_awarded: json["SAPlatinumPointAwarded"],
+            mastery_last:              json["MasteryLast"],
+            sa_play_count:             sa_play_count,
+            played_count:              json["PlayedCount"],
+            accuracy_global:           json["AccuracyGlobal"],
+            date_las:                  json["DateLAS"],
+            accuracy_chords:           json["AccuracyChords"],
+            mastery_previous:          json["MasteryPrevious"],
+            mastery_peak:              json["MasteryPeak"],
+            mastery_previous_peak:     json["MasteryPreviousPeak"],
+            streak:                    json["Streak"],
+            sa_win_count:              json["SAWinCount"],
+            sa_general_point_awarded:  json["SAGeneralPointAwarded"],
+            articulation_accuracy:     json["ArticulationAccuracy"],
+            chords_accuracies:         json["ChordsAccuracies"],
+            sa_fail_count:             json["SAFailCount"],
+            score_attack_play_count:   json["ScoreAttack_PlayCount"]
+          )
+        end
+
+        def self.nil_song
+          self.new(
+            ATTRIBUTES.inject({}) { |memo, attr| memo[attr] = nil; memo }
+          )
+        end
+
+        def initialize(args)
+          args.each do |k, v|
+            self.send("#{k}=", v)
+          end
+        end
+
+        def ==(other)
+          return false if other == nil
+          id == other.id
+        end
+      end
+    end
+  end
+end

data/lib/rsgt/steam.rb

@@ -0,0 +1,45 @@
+module RSGuitarTech
+  class Steam
+
+    ROCKSMITH2014_APP_ID = 221680
+
+    def save_file
+      "#{base_path}#{save_filename}"
+    end
+
+    def save_filename
+      "#{unique_id}_PRFLDB"
+    end
+
+    def local_profiles
+      "#{base_path}LocalProfiles.json"
+    end
+
+    # Uplay junk
+    def crd
+      "#{base_path}crd"
+    end
+
+    def unique_id
+      @unique_id ||= begin
+        file = File.open local_profiles
+        data = RSGuitarTech::EncryptedSteamFile.read(file)
+        data.uncompressed_json['Profiles'].first['UniqueID']
+      end
+    end
+
+  private
+
+    def base_path
+      "#{steam_path}#{steam_id}/#{ROCKSMITH2014_APP_ID}/remote/"
+    end
+
+    def steam_path
+      "/Users/#{`whoami`.strip}/Library/Application\ Support/Steam/userdata/"
+    end
+
+    def steam_id
+      Dir["#{steam_path}/*"].first.match(/\/(\d+)$/)[1]
+    end
+  end
+end