app/build.gradle.kts

@@ -83,16 +83,10 @@ dependencies {
     implementation("androidx.navigation:navigation-fragment-ktx:2.7.6")
     implementation("androidx.navigation:navigation-ui-ktx:2.7.6")
 
-    // MPAndroidChart for progress visualization
-    implementation("com.github.PhilJay:MPAndroidChart:v3.1.0")
-
     // Room
     implementation("androidx.room:room-runtime:2.6.1")
     implementation("androidx.room:room-ktx:2.6.1")
     ksp("androidx.room:room-compiler:2.6.1")
-    
-    // Gson for JSON serialization
-    implementation("com.google.code.gson:gson:2.10.1")
 
     testImplementation("junit:junit:4.13.2")
     androidTestImplementation("androidx.test.ext:junit:1.1.5")

app/src/main/java/com/accidentalproductions/tetristats/TetriStatsApplication.kt

@@ -2,15 +2,11 @@ package com.accidentalproductions.tetristats
 
 import android.app.Application
 import androidx.room.Room
-import com.accidentalproductions.tetristats.data.ScalingFactorsManager
 import com.accidentalproductions.tetristats.data.ScoreDatabase
 
 class TetriStatsApplication : Application() {
     lateinit var database: ScoreDatabase
         private set
-        
-    lateinit var scalingFactorsManager: ScalingFactorsManager
-        private set
 
     override fun onCreate() {
         super.onCreate()
@@ -35,8 +31,5 @@ class TetriStatsApplication : Application() {
             .fallbackToDestructiveMigration()
             .build()
         }
-        
-        // Initialize the ScalingFactorsManager
-        scalingFactorsManager = ScalingFactorsManager(applicationContext)
     }
 } 

app/src/main/java/com/accidentalproductions/tetristats/data/ScalingFactors.kt

@@ -16,9 +16,7 @@ object ScalingFactors {
             "Tetris DS" to RangeScalingFactor(3.0, 3.3, 4.5),
             "Tetris Effect" to RangeScalingFactor(2.5, 3.8, 4.5),
             "Rosy Retrospection DX" to RangeScalingFactor(4.0, 1.5, 1.8),
-            "Apotris" to RangeScalingFactor(1.8, 3.8, 4.4),
-            "Modretro Tetris" to RangeScalingFactor(2.0, 2.5, 3.0),
-            "Tetris Mobile" to RangeScalingFactor(2.2, 2.8, 3.5)
+            "Apotris" to RangeScalingFactor(1.8, 3.8, 4.4)
         ),
         "Game Boy Tetris" to mapOf(
             "NES Tetris" to 1.33,
@@ -26,9 +24,7 @@ object ScalingFactors {
             "Tetris DS" to RangeScalingFactor(4.0, 2.0, 2.0),
             "Tetris Effect" to RangeScalingFactor(4.0, 2.3, 2.3),
             "Rosy Retrospection DX" to 1.1,
-            "Apotris" to RangeScalingFactor(1.33, 1.33, 2.33),
-            "Modretro Tetris" to RangeScalingFactor(1.5, 1.8, 2.0),
-            "Tetris Mobile" to RangeScalingFactor(1.6, 1.9, 2.1)
+            "Apotris" to RangeScalingFactor(1.33, 1.33, 2.33)
         ),
         "Tetris DX" to mapOf(
             "NES Tetris" to 1.33,
@@ -36,9 +32,7 @@ object ScalingFactors {
             "Tetris DS" to RangeScalingFactor(4.0, 2.0, 2.0),
             "Tetris Effect" to RangeScalingFactor(4.0, 2.3, 2.3),
             "Rosy Retrospection DX" to 1.1,
-            "Apotris" to RangeScalingFactor(1.33, 1.33, 2.33),
-            "Modretro Tetris" to RangeScalingFactor(1.5, 1.8, 2.0),
-            "Tetris Mobile" to RangeScalingFactor(1.6, 1.9, 2.1)
+            "Apotris" to RangeScalingFactor(1.33, 1.33, 2.33)
         ),
         "Tetris DS" to mapOf(
             "NES Tetris" to RangeScalingFactor(0.33, 0.3, 0.22),
@@ -46,9 +40,7 @@ object ScalingFactors {
             "Tetris DX" to RangeScalingFactor(0.25, 0.5, 0.5),
             "Tetris Effect" to RangeScalingFactor(0.83, 0.91, 1.0),
             "Rosy Retrospection DX" to RangeScalingFactor(0.25, 0.91, 0.67),
-            "Apotris" to RangeScalingFactor(0.33, 0.67, 0.9),
-            "Modretro Tetris" to RangeScalingFactor(0.4, 0.5, 0.6),
-            "Tetris Mobile" to RangeScalingFactor(0.45, 0.55, 0.65)
+            "Apotris" to RangeScalingFactor(0.33, 0.67, 0.9)
         ),
         "Tetris Effect" to mapOf(
             "NES Tetris" to RangeScalingFactor(0.4, 0.26, 0.22),
@@ -56,9 +48,7 @@ object ScalingFactors {
             "Tetris DX" to RangeScalingFactor(0.25, 0.43, 0.43),
             "Tetris DS" to RangeScalingFactor(1.2, 1.1, 1.0),
             "Rosy Retrospection DX" to RangeScalingFactor(0.25, 0.43, 0.57),
-            "Apotris" to RangeScalingFactor(0.33, 0.67, 0.85),
-            "Modretro Tetris" to RangeScalingFactor(0.45, 0.55, 0.65),
-            "Tetris Mobile" to RangeScalingFactor(0.5, 0.6, 0.7)
+            "Apotris" to RangeScalingFactor(0.33, 0.67, 0.85)
         ),
         "Rosy Retrospection DX" to mapOf(
             "NES Tetris" to RangeScalingFactor(0.25, 0.67, 0.57),
@@ -66,9 +56,7 @@ object ScalingFactors {
             "Tetris DX" to 0.91,
             "Tetris DS" to RangeScalingFactor(4.0, 1.5, 1.8),
             "Tetris Effect" to RangeScalingFactor(4.0, 2.3, 1.8),
-            "Apotris" to RangeScalingFactor(1.1, 0.67, 0.5),
-            "Modretro Tetris" to RangeScalingFactor(1.3, 1.5, 1.7),
-            "Tetris Mobile" to RangeScalingFactor(1.4, 1.6, 1.8)
+            "Apotris" to RangeScalingFactor(1.1, 0.67, 0.5)
         ),
         "Apotris" to mapOf(
             "NES Tetris" to RangeScalingFactor(0.56, 0.26, 0.23),
@@ -76,29 +64,7 @@ object ScalingFactors {
             "Tetris DX" to RangeScalingFactor(0.75, 0.75, 0.5),
             "Tetris DS" to RangeScalingFactor(3.0, 1.5, 1.0),
             "Tetris Effect" to RangeScalingFactor(3.0, 1.7, 1.2),
-            "Rosy Retrospection DX" to RangeScalingFactor(1.1, 0.67, 0.5),
-            "Modretro Tetris" to RangeScalingFactor(1.2, 0.9, 0.7),
-            "Tetris Mobile" to RangeScalingFactor(1.3, 1.0, 0.8)
-        ),
-        "Modretro Tetris" to mapOf(
-            "NES Tetris" to RangeScalingFactor(0.5, 0.4, 0.33),
-            "Game Boy Tetris" to RangeScalingFactor(0.67, 0.56, 0.5),
-            "Tetris DX" to RangeScalingFactor(0.67, 0.56, 0.5),
-            "Tetris DS" to RangeScalingFactor(2.5, 2.0, 1.67),
-            "Tetris Effect" to RangeScalingFactor(2.22, 1.82, 1.54),
-            "Rosy Retrospection DX" to RangeScalingFactor(0.77, 0.67, 0.59),
-            "Apotris" to RangeScalingFactor(0.83, 1.11, 1.43),
-            "Tetris Mobile" to RangeScalingFactor(1.1, 1.1, 1.1)
-        ),
-        "Tetris Mobile" to mapOf(
-            "NES Tetris" to RangeScalingFactor(0.45, 0.36, 0.29),
-            "Game Boy Tetris" to RangeScalingFactor(0.63, 0.53, 0.48),
-            "Tetris DX" to RangeScalingFactor(0.63, 0.53, 0.48),
-            "Tetris DS" to RangeScalingFactor(2.22, 1.82, 1.54),
-            "Tetris Effect" to RangeScalingFactor(2.0, 1.67, 1.43),
-            "Rosy Retrospection DX" to RangeScalingFactor(0.71, 0.63, 0.56),
-            "Apotris" to RangeScalingFactor(0.77, 1.0, 1.25),
-            "Modretro Tetris" to RangeScalingFactor(0.91, 0.91, 0.91)
+            "Rosy Retrospection DX" to RangeScalingFactor(1.1, 0.67, 0.5)
         )
     )
 

app/src/main/java/com/accidentalproductions/tetristats/data/ScalingFactorsManager.kt

@@ -1,166 +0,0 @@
-package com.accidentalproductions.tetristats.data
-
-import android.content.Context
-import android.content.SharedPreferences
-import com.google.gson.Gson
-import com.google.gson.reflect.TypeToken
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
-
-/**
- * Manages the learning and persistence of scaling factors based on user input
- */
-class ScalingFactorsManager(context: Context) {
-    
-    private val prefs: SharedPreferences = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
-    private val gson = Gson()
-    
-    // In-memory cache of learned factors
-    private var learnedFactors: MutableMap<String, MutableMap<String, LearningData>> = loadLearnedFactors()
-    
-    /**
-     * Updates the scaling factor based on a new sample provided by the user
-     * @param fromGame The source game
-     * @param toGame The target game
-     * @param fromScore The original score
-     * @param toScore The user-provided equivalent score
-     */
-    suspend fun updateScalingFactor(fromGame: String, toGame: String, fromScore: Int, toScore: Int) {
-        withContext(Dispatchers.IO) {
-            // Calculate the actual scaling factor from this sample
-            val actualFactor = toScore.toDouble() / fromScore.toDouble()
-            
-            // Get or create learning data for this game conversion
-            val gameFactors = learnedFactors.getOrPut(fromGame) { mutableMapOf() }
-            val learningData = gameFactors.getOrPut(toGame) { LearningData() }
-            
-            // Determine which bucket this score falls into
-            val bucket = when {
-                fromScore < 100000 -> ScoreBucket.LOW
-                fromScore < 500000 -> ScoreBucket.MID
-                else -> ScoreBucket.HIGH
-            }
-            
-            // Update the appropriate bucket
-            when (bucket) {
-                ScoreBucket.LOW -> {
-                    learningData.lowScoreSamples++
-                    learningData.lowScoreTotal += actualFactor
-                }
-                ScoreBucket.MID -> {
-                    learningData.midScoreSamples++
-                    learningData.midScoreTotal += actualFactor
-                }
-                ScoreBucket.HIGH -> {
-                    learningData.highScoreSamples++
-                    learningData.highScoreTotal += actualFactor
-                }
-            }
-            
-            // Save the updated data
-            saveLearnedFactors()
-        }
-    }
-    
-    /**
-     * Gets the learned scaling factor for a conversion, falling back to default if no samples
-     */
-    fun getLearnedScalingFactor(fromGame: String, toGame: String, score: Int): Double {
-        // Check if we have learned data for this conversion
-        val learningData = learnedFactors[fromGame]?.get(toGame)
-        
-        // If no learning data, fall back to default
-        if (learningData == null) {
-            return ScalingFactors.getScalingFactor(fromGame, toGame, score)
-        }
-        
-        // Determine which bucket this score falls into
-        return when {
-            score < 100000 -> {
-                if (learningData.lowScoreSamples > 0) {
-                    learningData.lowScoreTotal / learningData.lowScoreSamples
-                } else {
-                    ScalingFactors.getScalingFactor(fromGame, toGame, score)
-                }
-            }
-            score < 500000 -> {
-                if (learningData.midScoreSamples > 0) {
-                    learningData.midScoreTotal / learningData.midScoreSamples
-                } else {
-                    ScalingFactors.getScalingFactor(fromGame, toGame, score)
-                }
-            }
-            else -> {
-                if (learningData.highScoreSamples > 0) {
-                    learningData.highScoreTotal / learningData.highScoreSamples
-                } else {
-                    ScalingFactors.getScalingFactor(fromGame, toGame, score)
-                }
-            }
-        }
-    }
-    
-    /**
-     * Gets the number of samples collected for this game conversion
-     */
-    fun getSampleCount(fromGame: String, toGame: String): Int {
-        val learningData = learnedFactors[fromGame]?.get(toGame) ?: return 0
-        return learningData.lowScoreSamples + learningData.midScoreSamples + learningData.highScoreSamples
-    }
-    
-    /**
-     * Resets all learned scaling factors
-     */
-    suspend fun resetAllFactors() {
-        withContext(Dispatchers.IO) {
-            learnedFactors.clear()
-            saveLearnedFactors()
-        }
-    }
-    
-    /**
-     * Resets learned scaling factors for a specific game conversion
-     */
-    suspend fun resetFactors(fromGame: String, toGame: String) {
-        withContext(Dispatchers.IO) {
-            learnedFactors[fromGame]?.remove(toGame)
-            saveLearnedFactors()
-        }
-    }
-    
-    private fun loadLearnedFactors(): MutableMap<String, MutableMap<String, LearningData>> {
-        val json = prefs.getString(KEY_LEARNED_FACTORS, null) ?: return mutableMapOf()
-        val type = object : TypeToken<MutableMap<String, MutableMap<String, LearningData>>>() {}.type
-        return try {
-            gson.fromJson(json, type)
-        } catch (e: Exception) {
-            mutableMapOf()
-        }
-    }
-    
-    private fun saveLearnedFactors() {
-        val json = gson.toJson(learnedFactors)
-        prefs.edit().putString(KEY_LEARNED_FACTORS, json).apply()
-    }
-    
-    /**
-     * Data class to track learning progress for a specific game conversion
-     */
-    data class LearningData(
-        var lowScoreSamples: Int = 0,
-        var lowScoreTotal: Double = 0.0,
-        var midScoreSamples: Int = 0,
-        var midScoreTotal: Double = 0.0,
-        var highScoreSamples: Int = 0,
-        var highScoreTotal: Double = 0.0
-    )
-    
-    enum class ScoreBucket {
-        LOW, MID, HIGH
-    }
-    
-    companion object {
-        private const val PREFS_NAME = "ScalingFactorsPrefs"
-        private const val KEY_LEARNED_FACTORS = "learned_factors"
-    }
-} 

app/src/main/java/com/accidentalproductions/tetristats/data/ScoreDao.kt

@@ -12,15 +12,9 @@ interface ScoreDao {
     @Query("SELECT * FROM scores WHERE gameVersion = :gameVersion")
     fun getScoresForGame(gameVersion: String): LiveData<List<Score>>
 
-    @Query("SELECT * FROM scores WHERE gameVersion = :gameVersion ORDER BY dateRecorded ASC")
-    fun getScoresForGameByDate(gameVersion: String): LiveData<List<Score>>
-
     @Query("SELECT DISTINCT gameVersion FROM scores")
     fun getGamesWithScores(): LiveData<List<String>>
 
-    @Query("SELECT COUNT(*) FROM scores")
-    fun getTotalScoreCount(): LiveData<Int>
-
     @Query("SELECT AVG(scoreValue) FROM scores WHERE gameVersion = :gameVersion")
     fun getAverageScore(gameVersion: String): LiveData<Double>
 

app/src/main/java/com/accidentalproductions/tetristats/ui/entry/EntryFragment.kt

@@ -5,10 +5,8 @@ import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import android.widget.ArrayAdapter
-import android.widget.Toast
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.viewModels
-import androidx.recyclerview.widget.LinearLayoutManager
 import com.accidentalproductions.tetristats.data.Score
 import com.accidentalproductions.tetristats.databinding.FragmentEntryBinding
 
@@ -16,10 +14,6 @@ class EntryFragment : Fragment() {
     private var _binding: FragmentEntryBinding? = null
     private val binding get() = _binding!!
     private val viewModel: EntryViewModel by viewModels { EntryViewModelFactory(requireActivity().application) }
-    private lateinit var equivalentScoreAdapter: EquivalentScoreAdapter
-    
-    // Flag to track if we already showed the requirements toast
-    private var hasShownRequirementsToast = false
 
     override fun onCreateView(
         inflater: LayoutInflater,
@@ -34,74 +28,8 @@ class EntryFragment : Fragment() {
         super.onViewCreated(view, savedInstanceState)
 
         setupGameVersionDropdown()
-        setupRecyclerView()
+        setupScoreConverter()
         setupSubmitButton()
-        setupAutoAnalysis()
-    }
-    
-    override fun onResume() {
-        super.onResume()
-        // Refresh conversions when returning to this fragment
-        refreshConversions()
-    }
-    
-    /**
-     * Force refresh the conversions using the last submitted values
-     */
-    private fun refreshConversions() {
-        if (viewModel.showConversion.value == true) {
-            // If we have last submitted values, regenerate conversions
-            val game = viewModel.lastSubmittedGame.value
-            val score = viewModel.lastSubmittedScore.value
-            
-            if (game != null && score != null) {
-                viewModel.refreshEquivalentScores(game, score)
-                
-                // Make sure UI updates immediately by forcing an adapter refresh
-                viewModel.equivalentScores.value?.let { scores ->
-                    equivalentScoreAdapter.submitList(null)  // Clear first
-                    equivalentScoreAdapter.submitList(scores)  // Then add new list
-                }
-                
-                // Ensure card is visible
-                updateAnalysisCard()
-            }
-        }
-    }
-    
-    /**
-     * Update the analysis card visibility and contents based on current state
-     */
-    private fun updateAnalysisCard() {
-        if (viewModel.showConversion.value != true) {
-            binding.cardAnalysisResults.visibility = View.GONE
-            return
-        }
-        
-        val game = viewModel.lastSubmittedGame.value
-        val score = viewModel.lastSubmittedScore.value
-        
-        if (game != null && score != null) {
-            // Get the list of games with scores
-            val playedGames = viewModel.gamesWithScores.value ?: listOf()
-            
-            // Make sure we don't show the source game in the equivalent dropdown
-            val filteredGames = playedGames.filter { it != game }
-            if (filteredGames.isNotEmpty()) {
-                binding.textViewOriginalScore.text = "Your $game score of ${"%,d".format(score)} is equivalent to:"
-                binding.cardAnalysisResults.visibility = View.VISIBLE
-                
-                val filteredAdapter = ArrayAdapter(requireContext(), android.R.layout.simple_dropdown_item_1line, filteredGames)
-                binding.autoCompleteEquivalentGame.setAdapter(filteredAdapter)
-                
-                // Select first game by default
-                binding.autoCompleteEquivalentGame.setText(filteredGames[0], false)
-                viewModel.setSelectedEquivalentGame(filteredGames[0])
-            } else {
-                // If no other games to convert to, hide the card
-                binding.cardAnalysisResults.visibility = View.GONE
-            }
-        }
     }
 
     private fun setupGameVersionDropdown() {
@@ -112,85 +40,64 @@ class EntryFragment : Fragment() {
             "Tetris DS",
             "Tetris Effect",
             "Rosy Retrospection DX",
-            "Apotris",
-            "Modretro Tetris",
-            "Tetris Mobile"
+            "Apotris"
         )
         val adapter = ArrayAdapter(requireContext(), android.R.layout.simple_dropdown_item_1line, games)
         binding.autoCompleteGameVersion.setAdapter(adapter)
     }
-    
-    private fun setupRecyclerView() {
-        equivalentScoreAdapter = EquivalentScoreAdapter()
-        binding.recyclerViewEquivalentScores.apply {
-            adapter = equivalentScoreAdapter
-            layoutManager = LinearLayoutManager(context)
+
+    private fun setupScoreConverter() {
+        // Setup "From Game" dropdown with games that have scores
+        viewModel.gamesWithScores.observe(viewLifecycleOwner) { games ->
+            val adapter = ArrayAdapter(requireContext(), android.R.layout.simple_dropdown_item_1line, games)
+            binding.autoCompleteFromGame.setAdapter(adapter)
+        }
+
+        // Update score selection when game is selected
+        binding.autoCompleteFromGame.setOnItemClickListener { _, _, _, _ ->
+            val selectedGame = binding.autoCompleteFromGame.text.toString()
+            viewModel.setSelectedFromGame(selectedGame)
+            updateScoreDropdown(selectedGame)
+        }
+
+        // Setup "To Game" dropdown
+        val allGames = listOf(
+            "NES Tetris",
+            "Game Boy Tetris",
+            "Tetris DX",
+            "Tetris DS",
+            "Tetris Effect",
+            "Rosy Retrospection DX",
+            "Apotris"
+        )
+        val toGameAdapter = ArrayAdapter(requireContext(), android.R.layout.simple_dropdown_item_1line, allGames)
+        binding.autoCompleteToGame.setAdapter(toGameAdapter)
+
+        // Handle score conversion
+        binding.buttonConvert.setOnClickListener {
+            viewModel.convertScore()
+        }
+
+        // Observe converted score
+        viewModel.convertedScore.observe(viewLifecycleOwner) { score ->
+            binding.cardConvertedScore.visibility = View.VISIBLE
+            binding.textViewConvertedScore.text = "%,d".format(score)
+        }
+
+        // Update selected games
+        binding.autoCompleteToGame.setOnItemClickListener { _, _, _, _ ->
+            viewModel.setSelectedToGame(binding.autoCompleteToGame.text.toString())
         }
     }
-    
-    private fun setupAutoAnalysis() {
-        // Hide the analysis card by default
-        binding.cardAnalysisResults.visibility = View.GONE
-        
-        // Observe if we should show conversions
-        viewModel.showConversion.observe(viewLifecycleOwner) { shouldShow ->
-            // No need to show toast here - we'll do it only after score submission
-            if (shouldShow) {
-                // Update card when showConversion changes
-                updateAnalysisCard()
-            } else {
-                binding.cardAnalysisResults.visibility = View.GONE
-            }
-        }
-        
-        // Only setup equivalence UI when we have scores
-        viewModel.gamesWithScores.observe(viewLifecycleOwner) { games ->
-            // Setup the game dropdown for adding equivalents - only with played games
-            if (games.isNotEmpty()) {
-                // Update card when games list changes
-                updateAnalysisCard()
-            }
-        }
-        
-        // Update selected game
-        binding.autoCompleteEquivalentGame.setOnItemClickListener { _, _, _, _ ->
-            val selectedGame = binding.autoCompleteEquivalentGame.text.toString()
-            viewModel.setSelectedEquivalentGame(selectedGame)
-        }
-        
-        // Handle adding equivalent scores
-        binding.buttonAddEquivalent.setOnClickListener {
-            val equivalentScore = binding.editTextEquivalentScore.text.toString().toIntOrNull()
-            if (equivalentScore != null) {
-                viewModel.addEquivalentScore(equivalentScore)
-                binding.editTextEquivalentScore.text?.clear()
-                Toast.makeText(context, "Equivalent score added! The converter is learning.", Toast.LENGTH_SHORT).show()
-            } else {
-                Toast.makeText(context, "Please enter a valid score", Toast.LENGTH_SHORT).show()
-            }
-        }
-        
-        // Observe last submitted score details
-        viewModel.lastSubmittedGame.observe(viewLifecycleOwner) { _ ->
-            // Update the analysis card when last submitted game changes
-            updateAnalysisCard()
-        }
-        
-        // Observe last submitted score value
-        viewModel.lastSubmittedScore.observe(viewLifecycleOwner) { _ ->
-            // Update the analysis card when score changes
-            updateAnalysisCard()
-        }
-        
-        // Observe equivalent scores
-        viewModel.equivalentScores.observe(viewLifecycleOwner) { scores ->
-            if (scores.isNotEmpty()) {
-                // Force a clean update by clearing first
-                equivalentScoreAdapter.submitList(null)
-                equivalentScoreAdapter.submitList(scores)
-            } else if (viewModel.showConversion.value == true) {
-                // If we should be showing conversions but have no scores, probably no other games
-                binding.cardAnalysisResults.visibility = View.GONE
+
+    private fun updateScoreDropdown(gameVersion: String) {
+        viewModel.getScoresForGame(gameVersion).observe(viewLifecycleOwner) { scores ->
+            val scoreStrings = scores.map { "${it.scoreValue} (Level ${it.endLevel ?: "?"})"}
+            val adapter = ArrayAdapter(requireContext(), android.R.layout.simple_dropdown_item_1line, scoreStrings)
+            binding.spinnerScoreSelect.setAdapter(adapter)
+
+            binding.spinnerScoreSelect.setOnItemClickListener { _, _, position, _ ->
+                viewModel.setSelectedScore(scores[position])
             }
         }
     }
@@ -212,24 +119,6 @@ class EntryFragment : Fragment() {
                     linesCleared = linesCleared
                 )
                 clearInputs()
-                
-                // Force immediate refresh of conversions
-                if (viewModel.showConversion.value == false) {
-                    Toast.makeText(
-                        context,
-                        "Enter at least 3 scores across 2 different games to see conversions",
-                        Toast.LENGTH_LONG
-                    ).show()
-                } else {
-                    refreshConversions()
-                    
-                    // Scroll down to show the analysis results
-                    binding.root.post {
-                        binding.root.fullScroll(View.FOCUS_DOWN)
-                    }
-                }
-            } else {
-                Toast.makeText(context, "Please enter a game and score", Toast.LENGTH_SHORT).show()
             }
         }
     }

app/src/main/java/com/accidentalproductions/tetristats/ui/entry/EntryViewModel.kt

@@ -1,94 +1,49 @@
 package com.accidentalproductions.tetristats.ui.entry
 
 import android.app.Application
-import android.util.Log
 import androidx.lifecycle.*
-import com.accidentalproductions.tetristats.TetriStatsApplication
 import com.accidentalproductions.tetristats.data.Score
 import com.accidentalproductions.tetristats.data.ScoreDatabase
 import com.accidentalproductions.tetristats.data.ScalingFactors
-import com.accidentalproductions.tetristats.data.ScalingFactorsManager
 import kotlinx.coroutines.launch
 
 class EntryViewModel(application: Application) : AndroidViewModel(application) {
     private val database = ScoreDatabase.getDatabase(application)
     private val scoreDao = database.scoreDao()
-    private val scalingFactorsManager = (application as TetriStatsApplication).scalingFactorsManager
 
-    // All games list for reference
-    private val allGames = listOf(
-        "NES Tetris",
-        "Game Boy Tetris",
-        "Tetris DX",
-        "Tetris DS",
-        "Tetris Effect",
-        "Rosy Retrospection DX",
-        "Apotris",
-        "Modretro Tetris",
-        "Tetris Mobile"
-    )
-    
-    // Track user played games and score counts
     val gamesWithScores = scoreDao.getGamesWithScores()
-    val totalScoreCount = scoreDao.getTotalScoreCount()
     
-    // For auto-analysis
-    private val _lastSubmittedGame = MutableLiveData<String>()
-    private val _lastSubmittedScore = MutableLiveData<Int>()
-    private val _equivalentScores = MutableLiveData<List<EquivalentScore>>()
-    private val _showConversion = MutableLiveData<Boolean>(false)
-    
-    // Current game selection for learning
-    private val _selectedEquivalentGame = MutableLiveData<String>()
-    
-    val equivalentScores: LiveData<List<EquivalentScore>> = _equivalentScores
-    val lastSubmittedGame: LiveData<String> = _lastSubmittedGame
-    val lastSubmittedScore: LiveData<Int> = _lastSubmittedScore
-    val showConversion: LiveData<Boolean> = _showConversion
-    
-    init {
-        // Set up observers to update conversion criteria whenever relevant data changes
-        gamesWithScores.observeForever { 
-            checkConversionCriteria() 
-        }
-        
-        totalScoreCount.observeForever {
-            checkConversionCriteria()
-        }
-    }
+    private val _selectedFromGame = MutableLiveData<String>()
+    private val _selectedScore = MutableLiveData<Score>()
+    private val _selectedToGame = MutableLiveData<String>()
+    private val _convertedScore = MutableLiveData<Int>()
+
+    val convertedScore: LiveData<Int> = _convertedScore
 
     fun getScoresForGame(gameVersion: String): LiveData<List<Score>> {
         return scoreDao.getScoresForGame(gameVersion)
     }
-    
-    fun setSelectedEquivalentGame(game: String) {
-        _selectedEquivalentGame.value = game
+
+    fun setSelectedFromGame(game: String) {
+        _selectedFromGame.value = game
     }
 
-    /**
-     * Check if we should show conversions based on score count and game count
-     */
-    fun checkConversionCriteria() {
-        val scoreCount = totalScoreCount.value ?: 0
-        val gameCount = gamesWithScores.value?.size ?: 0
-        
-        // Only show conversions if there are at least 3 scores across at least 2 games
-        val shouldShow = scoreCount >= 3 && gameCount >= 2
-        
-        // For debugging
-        Log.d("TetriStats", "Checking conversion criteria: scores=$scoreCount, games=$gameCount, shouldShow=$shouldShow")
-        
-        _showConversion.postValue(shouldShow)
+    fun setSelectedScore(score: Score) {
+        _selectedScore.value = score
     }
-    
-    /**
-     * Force refresh the equivalent scores - use this to ensure UI has latest values
-     */
-    fun refreshEquivalentScores(fromGame: String, score: Int) {
-        // Only refresh if conversions should be showing
-        if (_showConversion.value == true) {
-            Log.d("TetriStats", "Refreshing equivalent scores for $fromGame score $score")
-            generateEquivalentScores(fromGame, score)
+
+    fun setSelectedToGame(game: String) {
+        _selectedToGame.value = game
+    }
+
+    fun convertScore() {
+        val fromGame = _selectedFromGame.value
+        val score = _selectedScore.value
+        val toGame = _selectedToGame.value
+
+        if (fromGame != null && score != null && toGame != null) {
+            val convertedScore = ScalingFactors.convertScore(fromGame, toGame, score.scoreValue)
+            _convertedScore.value = convertedScore
         }
     }
 
@@ -108,75 +63,8 @@ class EntryViewModel(application: Application) : AndroidViewModel(application) {
                 linesCleared = linesCleared
             )
             scoreDao.insert(newScore)
-            
-            // After inserting, update the last submitted values
-            _lastSubmittedGame.value = gameVersion  // Use immediate value change instead of postValue
-            _lastSubmittedScore.value = score      // Use immediate value change instead of postValue
-            
-            // Immediately check conversion criteria with current values
-            checkConversionCriteria()
-            
-            // Immediate refresh regardless if we just reached the criteria threshold
-            if (totalScoreCount.value ?: 0 >= 3 && (gamesWithScores.value?.size ?: 0) >= 2) {
-                generateEquivalentScores(gameVersion, score)
-            }
         }
     }
-    
-    /**
-     * Generates equivalent scores in played games based on the submitted score
-     */
-    private fun generateEquivalentScores(fromGame: String, score: Int) {
-        val playedGames = gamesWithScores.value ?: listOf()
-        val equivalents = mutableListOf<EquivalentScore>()
-        
-        // Generate equivalent scores for played games except the source game
-        for (game in playedGames) {
-            if (game != fromGame) {
-                // Get the learned scaling factor
-                val factor = scalingFactorsManager.getLearnedScalingFactor(fromGame, game, score)
-                val equivalentScore = (score * factor).toInt()
-                val sampleCount = scalingFactorsManager.getSampleCount(fromGame, game)
-                
-                equivalents.add(
-                    EquivalentScore(
-                        gameName = game,
-                        score = equivalentScore,
-                        sampleCount = sampleCount,
-                        usesDynamicFactor = sampleCount > 0
-                    )
-                )
-            }
-        }
-        
-        // Use setValue for immediate update on main thread rather than postValue
-        _equivalentScores.value = equivalents
-    }
-    
-    /**
-     * Add a learning sample with an equivalent score in another game
-     */
-    fun addEquivalentScore(equivalentScore: Int) {
-        val fromGame = _lastSubmittedGame.value
-        val originalScore = _lastSubmittedScore.value
-        val toGame = _selectedEquivalentGame.value
-
-        if (fromGame != null && originalScore != null && toGame != null) {
-            viewModelScope.launch {
-                scalingFactorsManager.updateScalingFactor(fromGame, toGame, originalScore, equivalentScore)
-                
-                // Regenerate the equivalent scores to update the UI
-                generateEquivalentScores(fromGame, originalScore)
-            }
-        }
-    }
-    
-    override fun onCleared() {
-        super.onCleared()
-        // Remove our observers to prevent leaks
-        gamesWithScores.removeObserver { checkConversionCriteria() }
-        totalScoreCount.removeObserver { checkConversionCriteria() }
-    }
 }
 
 class EntryViewModelFactory(private val application: Application) : ViewModelProvider.Factory {

app/src/main/java/com/accidentalproductions/tetristats/ui/entry/EquivalentScoreAdapter.kt

@@ -1,55 +0,0 @@
-package com.accidentalproductions.tetristats.ui.entry
-
-import android.view.LayoutInflater
-import android.view.ViewGroup
-import androidx.recyclerview.widget.DiffUtil
-import androidx.recyclerview.widget.ListAdapter
-import androidx.recyclerview.widget.RecyclerView
-import com.accidentalproductions.tetristats.databinding.ItemEquivalentScoreBinding
-
-class EquivalentScoreAdapter : ListAdapter<EquivalentScore, EquivalentScoreAdapter.ViewHolder>(EquivalentScoreDiffCallback()) {
-
-    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
-        val binding = ItemEquivalentScoreBinding.inflate(LayoutInflater.from(parent.context), parent, false)
-        return ViewHolder(binding)
-    }
-
-    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
-        holder.bind(getItem(position))
-    }
-
-    class ViewHolder(private val binding: ItemEquivalentScoreBinding) : RecyclerView.ViewHolder(binding.root) {
-        fun bind(item: EquivalentScore) {
-            binding.textViewGameName.text = item.gameName
-            binding.textViewEquivalentScore.text = "%,d".format(item.score)
-            
-            // Show sample count if any samples exist
-            if (item.sampleCount > 0) {
-                binding.textViewSampleCount.visibility = android.view.View.VISIBLE
-                binding.textViewSampleCount.text = "Based on ${item.sampleCount} learning ${if (item.sampleCount == 1) "sample" else "samples"}"
-            } else {
-                binding.textViewSampleCount.visibility = android.view.View.GONE
-            }
-        }
-    }
-}
-
-class EquivalentScoreDiffCallback : DiffUtil.ItemCallback<EquivalentScore>() {
-    override fun areItemsTheSame(oldItem: EquivalentScore, newItem: EquivalentScore): Boolean {
-        return oldItem.gameName == newItem.gameName
-    }
-
-    override fun areContentsTheSame(oldItem: EquivalentScore, newItem: EquivalentScore): Boolean {
-        return oldItem == newItem
-    }
-}
-
-/**
- * Data class representing an equivalent score in another game
- */
-data class EquivalentScore(
-    val gameName: String,
-    val score: Int,
-    val sampleCount: Int = 0,
-    val usesDynamicFactor: Boolean = false
-) 

app/src/main/java/com/accidentalproductions/tetristats/ui/stats/StatsFragment.kt

@@ -1,6 +1,5 @@
 package com.accidentalproductions.tetristats.ui.stats
 
-import android.graphics.Color
 import android.os.Bundle
 import android.view.LayoutInflater
 import android.view.View
@@ -9,16 +8,7 @@ import android.widget.ArrayAdapter
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.viewModels
 import androidx.recyclerview.widget.LinearLayoutManager
-import com.accidentalproductions.tetristats.R
 import com.accidentalproductions.tetristats.databinding.FragmentStatsBinding
-import com.github.mikephil.charting.components.XAxis
-import com.github.mikephil.charting.data.Entry
-import com.github.mikephil.charting.data.LineData
-import com.github.mikephil.charting.data.LineDataSet
-import com.github.mikephil.charting.formatter.ValueFormatter
-import java.text.SimpleDateFormat
-import java.util.Date
-import java.util.Locale
 
 class StatsFragment : Fragment() {
     private var _binding: FragmentStatsBinding? = null
@@ -40,7 +30,6 @@ class StatsFragment : Fragment() {
 
         setupRecyclerView()
         setupGameFilter()
-        setupProgressChart()
         observeStats()
     }
 
@@ -63,64 +52,6 @@ class StatsFragment : Fragment() {
             viewModel.setSelectedGame(selectedGame)
         }
     }
-    
-    private fun setupProgressChart() {
-        with(binding.chartProgress) {
-            description.isEnabled = false
-            legend.isEnabled = true
-            setTouchEnabled(true)
-            setDrawGridBackground(false)
-            isDragEnabled = true
-            setScaleEnabled(true)
-            setPinchZoom(true)
-            
-            axisRight.isEnabled = false
-            
-            xAxis.position = XAxis.XAxisPosition.BOTTOM
-            xAxis.granularity = 1f
-            xAxis.setDrawGridLines(false)
-            
-            axisLeft.setDrawGridLines(true)
-            axisLeft.axisMinimum = 0f
-        }
-    }
-
-    private fun updateProgressChart(scores: List<Entry>, dates: List<Long>) {
-        if (scores.isEmpty()) {
-            binding.chartProgress.clear()
-            binding.chartProgress.invalidate()
-            return
-        }
-        
-        val dataSet = LineDataSet(scores, "Score Progress").apply {
-            mode = LineDataSet.Mode.CUBIC_BEZIER
-            color = resources.getColor(R.color.tetris_navy, null)
-            lineWidth = 2f
-            setDrawCircles(true)
-            setCircleColor(resources.getColor(R.color.tetris_navy, null))
-            circleRadius = 4f
-            setDrawValues(false)
-            highLightColor = Color.rgb(244, 117, 117)
-        }
-        
-        val lineData = LineData(dataSet)
-        binding.chartProgress.data = lineData
-        
-        // Format X-axis labels (dates)
-        val dateFormat = SimpleDateFormat("MM/dd", Locale.getDefault())
-        binding.chartProgress.xAxis.valueFormatter = object : ValueFormatter() {
-            override fun getFormattedValue(value: Float): String {
-                val index = value.toInt()
-                return if (index >= 0 && index < dates.size) {
-                    dateFormat.format(Date(dates[index]))
-                } else {
-                    ""
-                }
-            }
-        }
-        
-        binding.chartProgress.invalidate()
-    }
 
     private fun observeStats() {
         viewModel.filteredScores.observe(viewLifecycleOwner) { scores ->
@@ -134,24 +65,6 @@ class StatsFragment : Fragment() {
         viewModel.highScore.observe(viewLifecycleOwner) { highScore ->
             binding.textViewHighScore.text = "%,d".format(highScore)
         }
-        
-        viewModel.scoresByDate.observe(viewLifecycleOwner) { scores ->
-            // Convert scores to entries for the chart
-            if (scores.isNotEmpty()) {
-                val entries = mutableListOf<Entry>()
-                val dates = mutableListOf<Long>()
-                
-                scores.forEachIndexed { index, score ->
-                    entries.add(Entry(index.toFloat(), score.scoreValue.toFloat()))
-                    dates.add(score.dateRecorded)
-                }
-                
-                updateProgressChart(entries, dates)
-            } else {
-                binding.chartProgress.clear()
-                binding.chartProgress.invalidate()
-            }
-        }
     }
 
     override fun onDestroyView() {

app/src/main/java/com/accidentalproductions/tetristats/ui/stats/StatsViewModel.kt

@@ -18,10 +18,6 @@ class StatsViewModel(application: Application) : AndroidViewModel(application) {
         scoreDao.getScoresForGame(game)
     }
 
-    val scoresByDate: LiveData<List<Score>> = _selectedGame.switchMap { game ->
-        scoreDao.getScoresForGameByDate(game)
-    }
-
     val averageScore: LiveData<Double> = _selectedGame.switchMap { game ->
         scoreDao.getAverageScore(game)
     }

app/src/main/java/com/accidentalproductions/tetristats/util/ScalingFactorAnalyzer.kt

@@ -96,27 +96,8 @@ class ScalingFactorAnalyzer {
         games.forEach { game ->
             code.appendLine("    \"$game\" to mapOf(")
             
-            // Only add factors for games that aren't the current game
             games.filter { it != game }.forEach { otherGame ->
-                val factor = if (game == baseGame) {
-                    // If this is the base game, use the inverse of the other game's factor
-                    factors[otherGame]?.let { RangeScalingFactor(1.0/it.low, 1.0/it.mid, 1.0/it.high) }
-                        ?: RangeScalingFactor(1.0, 1.0, 1.0)
-                } else {
-                    // If this isn't the base game, use the factor relative to the base game
-                    if (otherGame == baseGame) {
-                        factors[game] ?: RangeScalingFactor(1.0, 1.0, 1.0)
-                    } else {
-                        // For non-base game pairs, calculate the relative factor
-                        val baseFactor = factors[game] ?: RangeScalingFactor(1.0, 1.0, 1.0)
-                        val otherFactor = factors[otherGame] ?: RangeScalingFactor(1.0, 1.0, 1.0)
-                        RangeScalingFactor(
-                            baseFactor.low / otherFactor.low,
-                            baseFactor.mid / otherFactor.mid,
-                            baseFactor.high / otherFactor.high
-                        )
-                    }
-                }
+                val factor = factors[otherGame] ?: RangeScalingFactor(1.0, 1.0, 1.0)
                 code.appendLine("        \"$otherGame\" to RangeScalingFactor(${factor.low}, ${factor.mid}, ${factor.high}),")
             }
             

app/src/main/res/layout/fragment_entry.xml

@@ -112,12 +112,10 @@
             </LinearLayout>
         </com.google.android.material.card.MaterialCardView>
 
-        <!-- Automatic Analysis Card (hidden by default, shown after submission) -->
+        <!-- Score Converter Card -->
         <com.google.android.material.card.MaterialCardView
-            android:id="@+id/cardAnalysisResults"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
-            android:visibility="gone"
             app:cardElevation="4dp">
 
             <LinearLayout
@@ -129,81 +127,92 @@
                 <TextView
                     android:layout_width="wrap_content"
                     android:layout_height="wrap_content"
-                    android:text="Equivalent Scores in Other Games"
+                    android:text="Score Converter"
                     android:textAppearance="?attr/textAppearanceHeadline6"
                     android:layout_marginBottom="16dp"/>
 
-                <TextView
-                    android:id="@+id/textViewOriginalScore"
+                <com.google.android.material.textfield.TextInputLayout
                     android:layout_width="match_parent"
                     android:layout_height="wrap_content"
-                    android:textAppearance="?attr/textAppearanceSubtitle1"
                     android:layout_marginBottom="8dp"
-                    tools:text="Your NES Tetris score of 500,000 is equivalent to:"/>
+                    style="@style/Widget.MaterialComponents.TextInputLayout.OutlinedBox.ExposedDropdownMenu">
 
-                <androidx.recyclerview.widget.RecyclerView
-                    android:id="@+id/recyclerViewEquivalentScores"
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginBottom="8dp"/>
-
-                <!-- Learning feedback section -->
-                <TextView
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content"
-                    android:text="Improve Conversions"
-                    android:textAppearance="?attr/textAppearanceSubtitle1"
-                    android:layout_marginTop="16dp"
-                    android:layout_marginBottom="8dp"/>
-                
-                <TextView
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:text="Do you know the equivalent score in another game? Add it to help improve future conversions:"
-                    android:textAppearance="?attr/textAppearanceBody2"
-                    android:layout_marginBottom="8dp"/>
-
-                <LinearLayout
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:orientation="horizontal"
-                    android:layout_marginBottom="8dp">
-
-                    <com.google.android.material.textfield.TextInputLayout
-                        android:layout_width="0dp"
+                    <AutoCompleteTextView
+                        android:id="@+id/autoCompleteFromGame"
+                        android:layout_width="match_parent"
                         android:layout_height="wrap_content"
-                        android:layout_weight="1"
-                        android:layout_marginEnd="8dp"
-                        style="@style/Widget.MaterialComponents.TextInputLayout.OutlinedBox.ExposedDropdownMenu">
+                        android:hint="From Game"
+                        android:inputType="none"/>
+                </com.google.android.material.textfield.TextInputLayout>
 
-                        <AutoCompleteTextView
-                            android:id="@+id/autoCompleteEquivalentGame"
-                            android:layout_width="match_parent"
-                            android:layout_height="wrap_content"
-                            android:hint="Game"
-                            android:inputType="none"/>
-                    </com.google.android.material.textfield.TextInputLayout>
+                <com.google.android.material.textfield.TextInputLayout
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:layout_marginBottom="8dp"
+                    style="@style/Widget.MaterialComponents.TextInputLayout.OutlinedBox.ExposedDropdownMenu">
 
-                    <com.google.android.material.textfield.TextInputLayout
-                        android:layout_width="0dp"
+                    <AutoCompleteTextView
+                        android:id="@+id/spinnerScoreSelect"
+                        android:layout_width="match_parent"
                         android:layout_height="wrap_content"
-                        android:layout_weight="1"
-                        style="@style/Widget.MaterialComponents.TextInputLayout.OutlinedBox">
+                        android:hint="Select Score"
+                        android:inputType="none"/>
+                </com.google.android.material.textfield.TextInputLayout>
 
-                        <com.google.android.material.textfield.TextInputEditText
-                            android:id="@+id/editTextEquivalentScore"
-                            android:layout_width="match_parent"
-                            android:layout_height="wrap_content"
-                            android:hint="Score"
-                            android:inputType="number"/>
-                    </com.google.android.material.textfield.TextInputLayout>
-                </LinearLayout>
+                <com.google.android.material.textfield.TextInputLayout
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:layout_marginBottom="16dp"
+                    style="@style/Widget.MaterialComponents.TextInputLayout.OutlinedBox.ExposedDropdownMenu">
+
+                    <AutoCompleteTextView
+                        android:id="@+id/autoCompleteToGame"
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:hint="To Game"
+                        android:inputType="none"/>
+                </com.google.android.material.textfield.TextInputLayout>
 
                 <com.google.android.material.button.MaterialButton
-                    android:id="@+id/buttonAddEquivalent"
+                    android:id="@+id/buttonConvert"
                     android:layout_width="match_parent"
                     android:layout_height="wrap_content"
-                    android:text="Add Equivalent Score"/>
+                    android:text="Convert Score"
+                    android:layout_marginBottom="16dp"/>
+
+                <com.google.android.material.card.MaterialCardView
+                    android:id="@+id/cardConvertedScore"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:visibility="gone"
+                    app:cardBackgroundColor="@color/tetris_turquoise"
+                    app:cardElevation="2dp">
+
+                    <LinearLayout
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:orientation="vertical"
+                        android:padding="16dp">
+
+                        <TextView
+                            android:layout_width="wrap_content"
+                            android:layout_height="wrap_content"
+                            android:text="Converted Score"
+                            android:textColor="@color/tetris_navy"
+                            android:textAppearance="?attr/textAppearanceBody1"/>
+
+                        <TextView
+                            android:id="@+id/textViewConvertedScore"
+                            android:layout_width="match_parent"
+                            android:layout_height="wrap_content"
+                            android:layout_marginTop="8dp"
+                            android:gravity="center"
+                            android:textColor="@color/tetris_navy"
+                            android:textAppearance="?attr/textAppearanceHeadline4"
+                            tools:text="1,000,000"/>
+
+                    </LinearLayout>
+                </com.google.android.material.card.MaterialCardView>
 
             </LinearLayout>
         </com.google.android.material.card.MaterialCardView>

app/src/main/res/layout/fragment_stats.xml

@@ -31,33 +31,6 @@
                 android:inputType="none"/>
         </com.google.android.material.textfield.TextInputLayout>
 
-        <com.google.android.material.card.MaterialCardView
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:layout_marginBottom="16dp"
-            app:cardCornerRadius="8dp"
-            app:cardElevation="4dp">
-
-            <LinearLayout
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:orientation="vertical"
-                android:padding="16dp">
-
-                <TextView
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content"
-                    android:text="Progress Chart"
-                    android:textAppearance="?attr/textAppearanceSubtitle1" />
-
-                <com.github.mikephil.charting.charts.LineChart
-                    android:id="@+id/chartProgress"
-                    android:layout_width="match_parent"
-                    android:layout_height="200dp"
-                    android:layout_marginTop="8dp" />
-            </LinearLayout>
-        </com.google.android.material.card.MaterialCardView>
-
         <androidx.recyclerview.widget.RecyclerView
             android:id="@+id/recyclerViewScores"
             android:layout_width="match_parent"

app/src/main/res/layout/item_equivalent_score.xml

@@ -1,53 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<com.google.android.material.card.MaterialCardView xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:app="http://schemas.android.com/apk/res-auto"
-    xmlns:tools="http://schemas.android.com/tools"
-    android:layout_width="match_parent"
-    android:layout_height="wrap_content"
-    android:layout_marginBottom="8dp"
-    app:cardElevation="2dp"
-    app:cardCornerRadius="8dp">
-
-    <LinearLayout
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:orientation="vertical"
-        android:padding="12dp">
-
-        <LinearLayout
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:orientation="horizontal"
-            android:gravity="center_vertical">
-
-            <TextView
-                android:id="@+id/textViewGameName"
-                android:layout_width="0dp"
-                android:layout_height="wrap_content"
-                android:layout_weight="1"
-                android:textAppearance="?attr/textAppearanceSubtitle1"
-                android:textColor="@color/tetris_turquoise"
-                tools:text="Tetris DS" />
-
-            <TextView
-                android:id="@+id/textViewEquivalentScore"
-                android:layout_width="wrap_content"
-                android:layout_height="wrap_content"
-                android:textAppearance="?attr/textAppearanceHeadline6"
-                android:textStyle="bold"
-                android:textColor="@color/tetris_navy"
-                tools:text="1,500,000" />
-        </LinearLayout>
-
-        <TextView
-            android:id="@+id/textViewSampleCount"
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:textAppearance="?attr/textAppearanceCaption"
-            android:textStyle="italic"
-            android:textColor="@android:color/darker_gray"
-            android:layout_marginTop="4dp"
-            tools:text="Based on 3 learning samples" />
-
-    </LinearLayout>
-</com.google.android.material.card.MaterialCardView> 

app/src/main/res/menu/bottom_nav_menu.xml

@@ -16,4 +16,9 @@
         android:icon="@drawable/ic_stats_24"
         android:title="Stats" />
 
+    <item
+        android:id="@+id/navigation_analysis"
+        android:icon="@drawable/ic_analytics_24"
+        android:title="Analysis" />
+
 </menu>

app/src/main/res/navigation/mobile_navigation.xml

@@ -23,4 +23,10 @@
         android:label="Statistics"
         tools:layout="@layout/fragment_stats" />
 
+    <fragment
+        android:id="@+id/navigation_analysis"
+        android:name="com.accidentalproductions.tetristats.ui.analysis.ScalingFactorFragment"
+        android:label="Scaling Analysis"
+        tools:layout="@layout/fragment_scaling_factor" />
+
 </navigation>