Fixes

Revert "Merge pull request #53 from 457R0/main"

This reverts commit 8aa31e819b, reversing
changes made to af27fc4933.

.gitignore

@@ -10,3 +10,12 @@ app/src/main/res/values/keys.xml
 app/src/test/resources/com/github/nacabaro/vbhelper/source/com.bandai.vitalbraceletarena.apk
 
 app/src/test/resources/com/github/nacabaro/vbhelper/source/classes.dex
+
+app/src/main/java/com/github/nacabaro/vbhelper/battle/Battle_Sprites_Reference/
+
+app/src/main/assets/battle_sprites
+app/src/main/assets/extracted_audio
+
+API-ACR122USAM-2.01.pdf
+
+build/

README.md

@@ -1,38 +1,69 @@
 # VBHelper
 
-## Developer Setup
+Application to interact with the Vital series, VB, VH, VBC and VBBE.
 
-1. Clone vb-nfc-reader (https://github.com/cfogrady/lib-vb-nfc)
-2. Run vb-nfc-reader/publishToMavenLocal gradle task in the lib-vb-nfc project.
-3. Clone vb-dim-reader (https://github.com/cfogrady/vb-dim-reader)
-4. Run publishToMavenLocal gradle task in the vb-dim-reader project.
-5. Create res/values/keys.xml within the app module.
-6. Populate with:
-```
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <string name="password1">beHmacKey1</string>
-    <string name="password2">beHmacKey2</string>
-    <string name="decryptionKey">aesKey</string>
-    <integer-array name="substitutionArray">
-        <item>0</item>
-        <item>1</item>
-        <item>2</item>
-        <item>3</item>
-        <item>4</item>
-        <item>5</item>
-        <item>6</item>
-        <item>7</item>
-        <item>8</item>
-        <item>9</item>
-        <item>10</item>
-        <item>11</item>
-        <item>12</item>
-        <item>13</item>
-        <item>14</item>
-        <item>15</item>
-    </integer-array>
-</resources>
-```
-7. Replace the values in the keys.xml file with those extracted from the original app.
-8. Run
+## Current state of the project
+
+Right now the project is still under development, and until further notice, any database updates will result in having to erase application data.
+
+This document will be updated once the application does not need any more database resets.
+
+## Features
+
+As of now, the project allows you to read characters, view characters stats, and send them back to your watch. 
+
+You can also apply items to the characters read, such as special missions, or change timers, and store characters in the storage section.
+
+You also earn new items every time an item such as a special mission (VB only) or a character completes an in-app adventure mission.
+
+App also comes with a dex that will update every time a new character is added, and allows you to see evolution requirements and current adventure stage in the watch.
+
+## How to set up
+
+1. Download the latest version for VB Arena APK from a trustworthy source. If your download is a standalone APK, continue to step 2. Otherwise, if your download is an XAPK, do the following:
+
+    1. Using your phone file manager, rename the XAPK file to ZIP, and extract its contents. You can also do this with any other device, such as Windows, macOS and Linux. 
+
+    2. Once the files are extracted, look for an APK called `com.bandai.vitalbraceletarena.apk`. Copy it somewhere else, you will need it.
+
+2. Install an APK release for VB Helper. You will find the releases [here](http://github.com/nacabaro/vbhelper/releases). Download the latest release and install its APK.
+
+    Note, in the current stage of the project, you will have to delete the old application from your device. If the app keeps crashing after installing, clear application data and storage.
+
+3. Import secrets in the app. These secrets will allow the app to talk to the watch. On the main screen, click on the gear icon, then `Import secrets`.
+    
+    You will be prompted to choose a file. Choose the APK file that was previously obtained.
+
+4. Import cards. Due to copyright laws, we cannot offer the characters and sprites themselves in the application. In order to import the cards do the following.
+
+    1. Using your own DiM/BEm cards, dump the cards to your device. You can get an in-depth tutorial in [here](http://mrblinky.net/digimon/vb/dimcardtool/dimcardtool.html). You can download the dump tool from [here](http://mrblinky.net/digimon/vb/dimcardtool/)
+
+    2. Once installed the tool and drivers, open the tool, connect your DiM/BEm reader hardware to yout computer and click on Read card.
+
+    3. Transfer the resulting file to your mobile device. You can put them anywhere, as long as they are accessible. My recommendation is to put them under a folder called `Cards` in your `Internal storage` or `SD Card`
+
+    4. In the app, click on import card. Next choose the BIN file corresponding to the card you want to import.
+
+    **Note: if you do not import the card, whenever you attempt to read a character from th watch, the character you read will get deleted.** 
+
+5. App will now be ready to be used.
+
+## Planned features
+
+- Online battles, undegoing development by `lightheel`.
+
+- VitalWear compatibility, undergoing development by `cfogrady`.
+
+- Support for multiple languages, not yet started.
+
+- Database backup/restore.
+
+## Credits
+
+- `cyanic` for helping us understand more about the VB connection protocol.
+
+- `cfogrady` for making both [`VB-DIM-Reader`](https://github.com/cfogrady/VB-DIM-Reader) and [`lib-vb-nfc`](https://github.com/cfogrady/lib-vb-nfc)
+
+- `lightheel` for working on the online component in the application, both server and battle client.
+
+- `shvstrz` for the app icon.

app/build.gradle.kts

@@ -1,21 +1,23 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
 plugins {
     alias(libs.plugins.android.application)
     alias(libs.plugins.kotlin.android)
     alias(libs.plugins.kotlin.compose)
-    id("com.google.devtools.ksp") version "2.0.21-1.0.27"
+    id("com.google.devtools.ksp") version "2.3.2"
     id("com.google.protobuf")
 }
 
 android {
     namespace = "com.github.nacabaro.vbhelper"
-    compileSdk = 35
+    compileSdk = 36
 
     defaultConfig {
         applicationId = "com.github.nacabaro.vbhelper"
         minSdk = 28
-        targetSdk = 35
+        targetSdk = 36
         versionCode = 1
-        versionName = "1.0"
+        versionName = "Alpha 0.6.3"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
@@ -33,9 +35,7 @@ android {
         sourceCompatibility = JavaVersion.VERSION_11
         targetCompatibility = JavaVersion.VERSION_11
     }
-    kotlinOptions {
-        jvmTarget = "11"
-    }
+
     buildFeatures {
         compose = true
     }
@@ -45,6 +45,12 @@ android {
     }
 }
 
+kotlin {
+    compilerOptions {
+        jvmTarget = JvmTarget.JVM_11
+    }
+}
+
 protobuf {
     protoc {
         artifact = "com.google.protobuf:protoc:4.27.0"
@@ -68,10 +74,13 @@ dependencies {
     implementation(libs.androidx.room.runtime)
     implementation(libs.vb.nfc.reader)
     implementation(libs.dim.reader)
-    ksp(libs.androidx.room.compiler)
-    annotationProcessor(libs.androidx.room.compiler)
     implementation(libs.androidx.core.ktx)
-    implementation("androidx.room:room-ktx:2.6.1")
+    implementation(libs.androidx.room.ktx)
+    implementation(libs.androidx.datastore.preferences)
+    implementation(libs.androidx.navigation.compose)
+    implementation(libs.material)
+    implementation(libs.protobuf.javalite)
+    implementation(libs.androidx.compose.material)
     implementation(libs.androidx.lifecycle.runtime.ktx)
     implementation(libs.androidx.activity.compose)
     implementation(platform(libs.androidx.compose.bom))
@@ -80,15 +89,33 @@ dependencies {
     implementation(libs.androidx.ui.graphics)
     implementation(libs.androidx.ui.tooling.preview)
     implementation(libs.androidx.material3)
+    implementation(libs.androidx.compose.material.icons.extended)
+
+    debugImplementation(libs.androidx.ui.tooling)
+    debugImplementation(libs.androidx.ui.test.manifest)
+
     testImplementation(libs.junit)
+
+    ksp(libs.androidx.room.compiler)
+    annotationProcessor(libs.androidx.room.compiler)
+
     androidTestImplementation(libs.androidx.junit)
     androidTestImplementation(libs.androidx.espresso.core)
     androidTestImplementation(platform(libs.androidx.compose.bom))
     androidTestImplementation(libs.androidx.ui.test.junit4)
+
     debugImplementation(libs.androidx.ui.tooling)
     debugImplementation(libs.androidx.ui.test.manifest)
     implementation("androidx.navigation:navigation-compose:2.7.0")
     implementation("com.google.android.material:material:1.2.0")
     implementation(libs.protobuf.javalite)
     implementation("androidx.compose.material:material")
+    implementation("androidx.datastore:datastore-preferences:1.1.7")
+
+    implementation("com.squareup.retrofit2:retrofit:2.9.0")
+    implementation("com.squareup.retrofit2:converter-gson:2.9.0")
+    implementation("com.google.code.gson:gson:2.10.1")
+
+    // HTTP request logging
+    implementation("com.squareup.okhttp3:logging-interceptor:4.11.0")
 }

app/src/main/AndroidManifest.xml

@@ -4,6 +4,11 @@
 
     <uses-permission android:name="android.permission.NFC" />
     <uses-feature android:name="android.hardware.nfc" android:required="true" />
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE"
+        tools:ignore="ScopedStorage" />
 
     <application
         android:name=".di.VBHelper"
@@ -15,6 +20,7 @@
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
         android:theme="@style/Theme.VBHelper"
+        android:usesCleartextTraffic="true"
         tools:targetApi="31">
         <activity
             android:name=".MainActivity"
@@ -26,6 +32,19 @@
 
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+                <data android:scheme="vbhelper" android:host="auth" />
+            </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+                <data android:scheme="http" android:host="localhost" android:port="8080" android:pathPrefix="/authenticate" />
+                <data android:scheme="http" android:host="127.0.0.1" android:port="8080" android:pathPrefix="/authenticate" />
+            </intent-filter>
         </activity>
     </application>
 

app/src/main/java/com/github/nacabaro/vbhelper/MainActivity.kt

@@ -1,43 +1,26 @@
 package com.github.nacabaro.vbhelper
 
-import android.content.Intent
 import android.os.Bundle
 import android.util.Log
-import android.widget.Toast
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
-import androidx.activity.result.ActivityResultLauncher
-import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.runtime.Composable
-import androidx.lifecycle.lifecycleScope
-import com.github.cfogrady.vb.dim.card.BemCard
-import com.github.cfogrady.vb.dim.card.DimReader
 import com.github.nacabaro.vbhelper.navigation.AppNavigation
-import com.github.cfogrady.vbnfc.be.BENfcCharacter
-import com.github.cfogrady.vbnfc.data.NfcCharacter
-import com.github.cfogrady.vbnfc.vb.VBNfcCharacter
 import com.github.nacabaro.vbhelper.di.VBHelper
-import com.github.nacabaro.vbhelper.domain.characters.Card
-import com.github.nacabaro.vbhelper.domain.Sprites
-import com.github.nacabaro.vbhelper.domain.characters.Character
-import com.github.nacabaro.vbhelper.domain.device_data.BECharacterData
-import com.github.nacabaro.vbhelper.domain.device_data.UserCharacter
 import com.github.nacabaro.vbhelper.navigation.AppNavigationHandlers
+import com.github.nacabaro.vbhelper.screens.homeScreens.HomeScreenControllerImpl
+import com.github.nacabaro.vbhelper.screens.itemsScreen.ItemsScreenControllerImpl
 import com.github.nacabaro.vbhelper.screens.scanScreen.ScanScreenControllerImpl
 import com.github.nacabaro.vbhelper.screens.settingsScreen.SettingsScreenControllerImpl
+import com.github.nacabaro.vbhelper.screens.adventureScreen.AdventureScreenControllerImpl
+import com.github.nacabaro.vbhelper.screens.cardScreen.CardScreenControllerImpl
+import com.github.nacabaro.vbhelper.screens.spriteViewer.SpriteViewerControllerImpl
+import com.github.nacabaro.vbhelper.screens.storageScreen.StorageScreenControllerImpl
 import com.github.nacabaro.vbhelper.ui.theme.VBHelperTheme
-import com.github.nacabaro.vbhelper.utils.DeviceType
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.launch
-import java.util.GregorianCalendar
+
 
 class MainActivity : ComponentActivity() {
-
-    private var nfcCharacter = MutableStateFlow<NfcCharacter?>(null)
-
-    private lateinit var activityResultLauncher: ActivityResultLauncher<Intent>
-
     private val onActivityLifecycleListeners = HashMap<String, ActivityLifecycleListener>()
 
     private fun registerActivityLifecycleListener(key: String, activityLifecycleListener: ActivityLifecycleListener) {
@@ -52,25 +35,40 @@ class MainActivity : ComponentActivity() {
     }
 
     override fun onCreate(savedInstanceState: Bundle?) {
-        registerFileActivityResult()
-
         val application = applicationContext as VBHelper
         val scanScreenController = ScanScreenControllerImpl(
             application.container.dataStoreSecretsRepository.secretsFlow,
-            this::handleReceivedNfcCharacter,
             this,
             this::registerActivityLifecycleListener,
             this::unregisterActivityLifecycleListener
         )
         val settingsScreenController = SettingsScreenControllerImpl(this)
+        val itemsScreenController = ItemsScreenControllerImpl(this)
+        val adventureScreenController = AdventureScreenControllerImpl(this)
+        val storageScreenController = StorageScreenControllerImpl(this)
+        val homeScreenController = HomeScreenControllerImpl(this)
+        val spriteViewerController = SpriteViewerControllerImpl(this)
+        val cardScreenController = CardScreenControllerImpl(this)
 
         super.onCreate(savedInstanceState)
+
         enableEdgeToEdge()
+
         setContent {
             VBHelperTheme {
-                MainApplication(scanScreenController, settingsScreenController)
+                MainApplication(
+                    scanScreenController = scanScreenController,
+                    settingsScreenController = settingsScreenController,
+                    itemsScreenController = itemsScreenController,
+                    adventureScreenController = adventureScreenController,
+                    homeScreenController = homeScreenController,
+                    storageScreenController = storageScreenController,
+                    spriteViewerController = spriteViewerController,
+                    cardScreenController = cardScreenController
+                )
             }
         }
+
         Log.i("MainActivity", "Activity onCreated")
     }
 
@@ -90,238 +88,28 @@ class MainActivity : ComponentActivity() {
         }
     }
 
-    private fun registerFileActivityResult() {
-        activityResultLauncher = registerForActivityResult(
-            ActivityResultContracts.StartActivityForResult()
-        ) {
-            lifecycleScope.launch {
-                val application = applicationContext as VBHelper
-                val storageRepository = application.container.db
-
-                if (it.resultCode != RESULT_OK) {
-                    Toast.makeText(applicationContext, "Import operation cancelled.", Toast.LENGTH_SHORT).show()
-                }
-                val contentResolver = applicationContext.contentResolver
-                val inputStream = contentResolver.openInputStream(it.data!!.data!!)
-                inputStream.use { fileReader ->
-                    val dimReader = DimReader()
-                    val card = dimReader.readCard(fileReader, false)
-
-                    Log.i("MainActivity", "Card name: ${card is BemCard}")
-
-                    val cardModel = Card(
-                        dimId = card.header.dimId,
-                        logo = card.spriteData.sprites[0].pixelData,
-                        name = card.spriteData.text, // TODO Make user write card name
-                        stageCount = card.adventureLevels.levels.size,
-                        logoHeight = card.spriteData.sprites[0].height,
-                        logoWidth = card.spriteData.sprites[0].width,
-                        isBEm = card is BemCard
-                    )
-
-                    val dimId = storageRepository
-                        .dimDao()
-                        .insertNewDim(cardModel)
-
-                    val characters = card.characterStats.characterEntries
-
-                    var spriteCounter = when (card is BemCard) {
-                        true -> 55
-                        false -> 10
-                    }
-
-                    val domainCharacters = mutableListOf<Character>()
-
-                    for (index in 0 until characters.size) {
-                        domainCharacters.add(
-                            Character(
-                                dimId = dimId,
-                                monIndex = index,
-                                name = card.spriteData.sprites[spriteCounter].pixelData,
-                                stage = characters[index].stage,
-                                attribute = characters[index].attribute,
-                                baseHp = characters[index].hp,
-                                baseBp = characters[index].dp,
-                                baseAp = characters[index].ap,
-                                sprite1 = card.spriteData.sprites[spriteCounter + 1].pixelData,
-                                sprite2 = card.spriteData.sprites[spriteCounter + 2].pixelData,
-                                nameWidth = card.spriteData.sprites[spriteCounter].width,
-                                nameHeight = card.spriteData.sprites[spriteCounter].height,
-                                spritesWidth = card.spriteData.sprites[spriteCounter + 1].width,
-                                spritesHeight = card.spriteData.sprites[spriteCounter + 1].height
-                            )
-                        )
-
-                        // TODO: Improve this
-                        if (card is BemCard) {
-                            spriteCounter += 14
-                        } else {
-                            when (index) {
-                                0 -> spriteCounter += 6
-                                1 -> spriteCounter += 7
-                                else -> spriteCounter += 14
-                            }
-                        }
-                    }
-
-                    storageRepository
-                        .characterDao()
-                        .insertCharacter(*domainCharacters.toTypedArray())
-
-                    val sprites = card.spriteData.sprites.map { sprite ->
-                        Sprites(
-                            id = 0,
-                            sprite = sprite.pixelData,
-                            width = sprite.width,
-                            height = sprite.height
-                        )
-                    }
-                    storageRepository
-                        .characterDao()
-                        .insertSprite(*sprites.toTypedArray())
-                }
-                inputStream?.close()
-                Toast.makeText(applicationContext, "Import successful!", Toast.LENGTH_SHORT).show()
-            }
-        }
-    }
-
     @Composable
     private fun MainApplication(
         scanScreenController: ScanScreenControllerImpl,
-        settingsScreenController: SettingsScreenControllerImpl
+        settingsScreenController: SettingsScreenControllerImpl,
+        itemsScreenController: ItemsScreenControllerImpl,
+        adventureScreenController: AdventureScreenControllerImpl,
+        storageScreenController: StorageScreenControllerImpl,
+        homeScreenController: HomeScreenControllerImpl,
+        spriteViewerController: SpriteViewerControllerImpl,
+        cardScreenController: CardScreenControllerImpl
     ) {
-
         AppNavigation(
             applicationNavigationHandlers = AppNavigationHandlers(
                 settingsScreenController,
                 scanScreenController,
-            ),
-            onClickImportCard = {
-                val intent = Intent(Intent.ACTION_OPEN_DOCUMENT).apply {
-                    addCategory(Intent.CATEGORY_OPENABLE)
-                    type = "*/*"
-                }
-                activityResultLauncher.launch(intent)
-            }
-        )
-    }
-
-    private fun handleReceivedNfcCharacter(character: NfcCharacter): String {
-        nfcCharacter.value = character
-
-        val importStatus = addCharacterScannedIntoDatabase()
-
-        return importStatus
-    }
-
-    //
-    /*
-    TODO:
-    - Support for regular VB
-
-    The good news is that the theory behind inserting to the database should be working
-    now, it's a matter of implementing the functionality to parse dim/bem cards and use my
-    domain model.
-     */
-    private fun addCharacterScannedIntoDatabase(): String {
-        val application = applicationContext as VBHelper
-        val storageRepository = application.container.db
-
-        val dimData = storageRepository
-            .dimDao()
-            .getDimById(nfcCharacter.value!!.dimId.toInt())
-
-        if (dimData == null) return "Card not found"
-
-        val cardCharData = storageRepository
-            .characterDao()
-            .getCharacterByMonIndex(nfcCharacter.value!!.charIndex.toInt(), dimData.id)
-
-        val characterData = UserCharacter(
-            charId = cardCharData.id,
-            stage = nfcCharacter.value!!.stage.toInt(),
-            attribute = nfcCharacter.value!!.attribute,
-            ageInDays = nfcCharacter.value!!.ageInDays.toInt(),
-            nextAdventureMissionStage = nfcCharacter.value!!.nextAdventureMissionStage.toInt(),
-            mood = nfcCharacter.value!!.mood.toInt(),
-            vitalPoints = nfcCharacter.value!!.vitalPoints.toInt(),
-            transformationCountdown = nfcCharacter.value!!.transformationCountdownInMinutes.toInt(),
-            injuryStatus = nfcCharacter.value!!.injuryStatus,
-            trophies = nfcCharacter.value!!.trophies.toInt(),
-            currentPhaseBattlesWon = nfcCharacter.value!!.currentPhaseBattlesWon.toInt(),
-            currentPhaseBattlesLost = nfcCharacter.value!!.currentPhaseBattlesLost.toInt(),
-            totalBattlesWon = nfcCharacter.value!!.totalBattlesWon.toInt(),
-            totalBattlesLost = nfcCharacter.value!!.totalBattlesLost.toInt(),
-            activityLevel = nfcCharacter.value!!.activityLevel.toInt(),
-            heartRateCurrent = nfcCharacter.value!!.heartRateCurrent.toInt(),
-            characterType = when (nfcCharacter.value) {
-                is BENfcCharacter -> DeviceType.BEDevice
-                else -> DeviceType.VBDevice
-            },
-            isActive = true
-        )
-
-        storageRepository
-            .userCharacterDao()
-            .clearActiveCharacter()
-
-        val characterId: Long = storageRepository
-            .userCharacterDao()
-            .insertCharacterData(characterData)
-
-        if (nfcCharacter.value is BENfcCharacter) {
-            val beCharacter = nfcCharacter.value as BENfcCharacter
-            val extraCharacterData = BECharacterData(
-                id = characterId,
-                trainingHp = beCharacter.trainingHp.toInt(),
-                trainingAp = beCharacter.trainingAp.toInt(),
-                trainingBp = beCharacter.trainingBp.toInt(),
-                remainingTrainingTimeInMinutes = beCharacter.remainingTrainingTimeInMinutes.toInt(),
-                itemEffectActivityLevelValue = beCharacter.itemEffectActivityLevelValue.toInt(),
-                itemEffectMentalStateValue = beCharacter.itemEffectMentalStateValue.toInt(),
-                itemEffectMentalStateMinutesRemaining = beCharacter.itemEffectMentalStateMinutesRemaining.toInt(),
-                itemEffectActivityLevelMinutesRemaining = beCharacter.itemEffectActivityLevelMinutesRemaining.toInt(),
-                itemEffectVitalPointsChangeValue = beCharacter.itemEffectVitalPointsChangeValue.toInt(),
-                itemEffectVitalPointsChangeMinutesRemaining = beCharacter.itemEffectVitalPointsChangeMinutesRemaining.toInt(),
-                abilityRarity = beCharacter.abilityRarity,
-                abilityType = beCharacter.abilityType.toInt(),
-                abilityBranch = beCharacter.abilityBranch.toInt(),
-                abilityReset = beCharacter.abilityReset.toInt(),
-                rank = beCharacter.abilityReset.toInt(),
-                itemType = beCharacter.itemType.toInt(),
-                itemMultiplier = beCharacter.itemMultiplier.toInt(),
-                itemRemainingTime = beCharacter.itemRemainingTime.toInt(),
-                otp0 = "", //beCharacter.value!!.otp0.toString(),
-                otp1 = "", //beCharacter.value!!.otp1.toString(),
-                minorVersion = beCharacter.characterCreationFirmwareVersion.minorVersion.toInt(),
-                majorVersion = beCharacter.characterCreationFirmwareVersion.majorVersion.toInt(),
+                itemsScreenController,
+                adventureScreenController,
+                storageScreenController,
+                homeScreenController,
+                spriteViewerController,
+                cardScreenController
             )
-
-            storageRepository
-                .userCharacterDao()
-                .insertBECharacterData(extraCharacterData)
-
-            val transformationHistoryWatch = beCharacter.transformationHistory
-            transformationHistoryWatch.map { item ->
-                if (item.toCharIndex.toInt() != 255) {
-                    val date = GregorianCalendar(item.year.toInt(), item.month.toInt(), item.day.toInt())
-                        .time
-                        .time
-
-                    storageRepository
-                        .characterDao()
-                        .insertTransformation(characterId, item.toCharIndex.toInt(), dimData.id, date)
-
-                    storageRepository
-                        .dexDao()
-                        .insertCharacter(item.toCharIndex.toInt(), dimData.id, date)
-                }
-            }
-        } else if (nfcCharacter.value is VBNfcCharacter) {
-            return "Not implemented yet"
-        }
-
-        return "Done reading character!"
+        )
     }
 }

app/src/main/java/com/github/nacabaro/vbhelper/battle/APIBattleCharacter.kt

@@ -0,0 +1,14 @@
+package com.github.nacabaro.vbhelper.battle
+
+data class APIBattleCharacter(
+    val name: String,
+    val namekey: String,
+    val charaId: String,
+    val stage: Int,
+    val attribute: Int,
+    val baseHp: Int,
+    val currentHp: Int,
+    val baseBp: Float,
+    val baseAp: Float,
+    val displayName: String? = null
+)

app/src/main/java/com/github/nacabaro/vbhelper/battle/AnimatedSpriteImage.kt

@@ -0,0 +1,82 @@
+package com.github.nacabaro.vbhelper.battle
+
+import androidx.compose.foundation.Image
+import androidx.compose.runtime.*
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalContext
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.delay
+
+@Composable
+fun AnimatedSpriteImage(
+    characterId: String,
+    animationType: DigimonAnimationType = DigimonAnimationType.IDLE,
+    modifier: Modifier = Modifier,
+    contentScale: ContentScale = ContentScale.Fit,
+    reloadMappings: Boolean = false,
+    animationOffset: Long = 0L // New parameter for offsetting animation timing
+) {
+    val context = LocalContext.current
+    val spriteManager = remember { IndividualSpriteManager(context) }
+    
+    // Calculate frame offset based on animation offset
+    // 750ms is the idle animation duration, so we calculate how many frames to offset
+    val frameOffset = if (animationOffset > 0L) {
+        // Convert time offset to frame offset (2 frames per cycle, 750ms per frame)
+        ((animationOffset / 750L) * 2).toInt()
+    } else {
+        0
+    }
+    
+    val animationStateMachine = remember { DigimonAnimationStateMachine(characterId, context, frameOffset, animationOffset) }
+    val coroutineScope = rememberCoroutineScope()
+    
+    var bitmap by remember { mutableStateOf<android.graphics.Bitmap?>(null) }
+    
+    // Reload mappings when reloadMappings parameter changes
+    LaunchedEffect(reloadMappings) {
+        if (reloadMappings) {
+            animationStateMachine.reloadMappings()
+        }
+    }
+    
+    // Start the animation when the component is first created
+    LaunchedEffect(characterId) {
+        coroutineScope.launch {
+            animationStateMachine.playIdleAnimation()
+        }
+    }
+    
+    // Change animation when animationType changes
+    LaunchedEffect(animationType) {
+        coroutineScope.launch {
+            if (animationType == DigimonAnimationType.IDLE) {
+                animationStateMachine.playIdleAnimation()
+            } else {
+                animationStateMachine.playAnimation(animationType)
+            }
+        }
+    }
+    
+    // Update sprite when animation state changes
+    LaunchedEffect(animationStateMachine.currentFrameNumber) {
+        val frameNumber = animationStateMachine.getCurrentFrame()
+
+        bitmap = spriteManager.loadSpriteFrame(characterId, frameNumber)
+        
+        if (bitmap == null) {
+            println("Failed to load animated sprite frame: $frameNumber for character: $characterId")
+        }
+    }
+    
+    bitmap?.let { bmp ->
+        Image(
+            bitmap = bmp.asImageBitmap(),
+            contentDescription = "Animated Sprite: $characterId - ${animationStateMachine.currentAnimation}",
+            modifier = modifier,
+            contentScale = contentScale
+        )
+    }
+} 

app/src/main/java/com/github/nacabaro/vbhelper/battle/ArenaBattleSystem.kt

@@ -0,0 +1,385 @@
+package com.github.nacabaro.vbhelper.battle
+
+import android.util.Log
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.State
+
+class ArenaBattleSystem {
+    companion object {
+        private const val TAG = "ArenaBattleSystem"
+    }
+
+    // Attack phases: 0=Idle, 1=Player attack on player screen, 2=Player attack on opponent screen, 
+    // 3=Opponent attack on opponent screen, 4=Opponent attack on player screen
+    private var _attackPhase by mutableStateOf(0)
+    val attackPhase: Int get() = _attackPhase
+
+    private var _attackProgress by mutableStateOf(0f)
+    val attackProgress: Float get() = _attackProgress
+
+    private var _isPlayerAttacking by mutableStateOf(false)
+    val isPlayerAttacking: Boolean get() = _isPlayerAttacking
+
+    private var _attackIsHit by mutableStateOf(false)
+    val attackIsHit: Boolean get() = _attackIsHit
+
+    private var _isAttackButtonEnabled by mutableStateOf(true)
+    val isAttackButtonEnabled: Boolean get() = _isAttackButtonEnabled
+
+    private var _currentView by mutableStateOf(0)
+    val currentView: Int get() = _currentView
+
+    private var _playerHP by mutableStateOf(100f)
+    val playerHP: Float get() = _playerHP
+
+    private var _opponentHP by mutableStateOf(100f)
+    val opponentHP: Float get() = _opponentHP
+
+    private var _isBattleOver by mutableStateOf(false)
+    val isBattleOver: Boolean get() = _isBattleOver
+
+    private var _critBarProgress by mutableStateOf(0)
+    val critBarProgress: Int get() = _critBarProgress
+
+    // Dodge animation states
+    private var _isDodging by mutableStateOf(false)
+    val isDodging: Boolean get() = _isDodging
+
+    private var _dodgeProgress by mutableStateOf(0f)
+    val dodgeProgress: Float get() = _dodgeProgress
+
+    private var _dodgeDirection by mutableStateOf(1f) // 1f = up, -1f = down
+    val dodgeDirection: Float get() = _dodgeDirection
+
+    private var _isHit by mutableStateOf(false)
+    val isHit: Boolean get() = _isHit
+
+    private var _hitProgress by mutableStateOf(0f)
+    val hitProgress: Float get() = _hitProgress
+
+    // Separate states for player and opponent
+    private var _isPlayerDodging by mutableStateOf(false)
+    val isPlayerDodging: Boolean get() = _isPlayerDodging
+
+    private var _isOpponentDodging by mutableStateOf(false)
+    val isOpponentDodging: Boolean get() = _isOpponentDodging
+
+    // Separate dodge progress and direction for player and opponent
+    private var _playerDodgeProgress by mutableStateOf(0f)
+    val playerDodgeProgress: Float get() = _playerDodgeProgress
+
+    private var _playerDodgeDirection by mutableStateOf(1f)
+    val playerDodgeDirection: Float get() = _playerDodgeDirection
+
+    private var _opponentDodgeProgress by mutableStateOf(0f)
+    val opponentDodgeProgress: Float get() = _opponentDodgeProgress
+
+    private var _opponentDodgeDirection by mutableStateOf(1f)
+    val opponentDodgeDirection: Float get() = _opponentDodgeDirection
+
+    private var _isPlayerHit by mutableStateOf(false)
+    val isPlayerHit: Boolean get() = _isPlayerHit
+
+    private var _isOpponentHit by mutableStateOf(false)
+    val isOpponentHit: Boolean get() = _isOpponentHit
+
+    // Delayed hit states for SLEEP animation timing
+    private var _isPlayerHitDelayed by mutableStateOf(false)
+    val isPlayerHitDelayed: Boolean get() = _isPlayerHitDelayed
+
+    private var _isOpponentHitDelayed by mutableStateOf(false)
+    val isOpponentHitDelayed: Boolean get() = _isOpponentHitDelayed
+
+    // Delayed shake states for shake animation timing
+    private var _isPlayerShakeDelayed by mutableStateOf(false)
+    val isPlayerShakeDelayed: Boolean get() = _isPlayerShakeDelayed
+
+    private var _isOpponentShakeDelayed by mutableStateOf(false)
+    val isOpponentShakeDelayed: Boolean get() = _isOpponentShakeDelayed
+
+    // Counter-attack tracking
+    private var _shouldCounterAttack by mutableStateOf(false)
+    val shouldCounterAttack: Boolean get() = _shouldCounterAttack
+
+    private var _counterAttackIsHit by mutableStateOf(false)
+    val counterAttackIsHit: Boolean get() = _counterAttackIsHit
+
+    // Separate tracking for opponent attack result
+    private var _opponentAttackIsHit by mutableStateOf(false)
+    val opponentAttackIsHit: Boolean get() = _opponentAttackIsHit
+
+    fun startPlayerAttack() {
+        _attackPhase = 1
+        _attackProgress = 0f
+        _isPlayerAttacking = true
+        _isAttackButtonEnabled = false
+        _currentView = 0
+    }
+
+    fun startOpponentAttack() {
+        _attackPhase = 3
+        _attackProgress = 0f
+        _isPlayerAttacking = false
+        _currentView = 1
+    }
+
+    fun advanceAttackPhase() {
+        _attackPhase++
+        _attackProgress = 0f
+    }
+
+    fun setAttackProgress(progress: Float) {
+        _attackProgress = progress
+    }
+
+    fun setAttackHitState(isHit: Boolean) {
+        _attackIsHit = isHit
+    }
+
+    fun switchToView(view: Int) {
+        _currentView = view
+    }
+
+    fun enableAttackButton() {
+        _isAttackButtonEnabled = true
+    }
+
+    fun applyDamage(isPlayer: Boolean, damage: Float) {
+        if (isPlayer) {
+            _playerHP = (_playerHP - damage).coerceAtLeast(0f)
+        } else {
+            _opponentHP = (_opponentHP - damage).coerceAtLeast(0f)
+        }
+    }
+
+    fun updateHPFromAPI(playerHP: Float, opponentHP: Float) {
+        _playerHP = playerHP
+        _opponentHP = opponentHP
+    }
+
+    fun initializeHP(playerHP: Float, opponentHP: Float) {
+        _playerHP = playerHP
+        _opponentHP = opponentHP
+    }
+
+    fun completeAttackAnimation(playerDamage: Float = 0f, opponentDamage: Float = 0f) {
+        if (playerDamage > 0f) {
+            applyDamage(true, playerDamage)
+        }
+        if (opponentDamage > 0f) {
+            applyDamage(false, opponentDamage)
+        }
+    }
+
+    fun resetAttackState() {
+        _attackPhase = 0
+        _attackProgress = 0f
+        _isPlayerAttacking = false
+        _attackIsHit = false
+        _currentView = 0
+        _isDodging = false
+        _dodgeProgress = 0f
+        _dodgeDirection = 1f
+        _isHit = false
+        _hitProgress = 0f
+        _isPlayerDodging = false
+        _isOpponentDodging = false
+        _playerDodgeProgress = 0f
+        _playerDodgeDirection = 1f
+        _opponentDodgeProgress = 0f
+        _opponentDodgeDirection = 1f
+        _isPlayerHit = false
+        _isOpponentHit = false
+        _isPlayerHitDelayed = false
+        _isOpponentHitDelayed = false
+        _isPlayerShakeDelayed = false
+        _isOpponentShakeDelayed = false
+        _shouldCounterAttack = false
+        _counterAttackIsHit = false
+        _opponentAttackIsHit = false
+    }
+
+    fun checkBattleOver(): Boolean {
+        return _playerHP <= 0f || _opponentHP <= 0f
+    }
+
+    fun endBattle() {
+        _isBattleOver = true
+    }
+
+    fun updateCritBarProgress(progress: Int) {
+        _critBarProgress = progress
+        //Log.d(TAG, "Updated crit bar progress: $progress")
+    }
+
+    // Dodge animation methods
+    fun startDodge() {
+        _isDodging = true
+        _dodgeProgress = 0f
+        _dodgeDirection = 1f // Start moving up
+    }
+
+    fun setDodgeProgress(progress: Float) {
+        _dodgeProgress = progress
+    }
+
+    fun setDodgeDirection(direction: Float) {
+        _dodgeDirection = direction
+    }
+
+    fun endDodge() {
+        _isDodging = false
+        _dodgeProgress = 0f
+    }
+
+    // Hit animation methods
+    fun startHit() {
+        _isHit = true
+        _hitProgress = 0f
+    }
+
+    fun setHitProgress(progress: Float) {
+        _hitProgress = progress
+    }
+
+    fun endHit() {
+        _isHit = false
+        _hitProgress = 0f
+    }
+
+    // Player-specific dodge methods
+    fun startPlayerDodge() {
+        _isPlayerDodging = true
+        _playerDodgeProgress = 0f
+        _playerDodgeDirection = 1f
+    }
+
+    fun endPlayerDodge() {
+        _isPlayerDodging = false
+        _playerDodgeProgress = 0f
+    }
+
+    fun setPlayerDodgeProgress(progress: Float) {
+        _playerDodgeProgress = progress
+    }
+
+    fun setPlayerDodgeDirection(direction: Float) {
+        _playerDodgeDirection = direction
+    }
+
+    // Opponent-specific dodge methods
+    fun startOpponentDodge() {
+        _isOpponentDodging = true
+        _opponentDodgeProgress = 0f
+        _opponentDodgeDirection = 1f
+    }
+
+    fun endOpponentDodge() {
+        _isOpponentDodging = false
+        _opponentDodgeProgress = 0f
+    }
+
+    fun setOpponentDodgeProgress(progress: Float) {
+        _opponentDodgeProgress = progress
+    }
+
+    fun setOpponentDodgeDirection(direction: Float) {
+        _opponentDodgeDirection = direction
+    }
+
+    // Player-specific hit methods
+    fun startPlayerHit() {
+        _isPlayerHit = true
+        _hitProgress = 0f
+    }
+
+    fun startPlayerHitDelayed() {
+        _isPlayerHitDelayed = true
+    }
+
+    fun endPlayerHit() {
+        _isPlayerHit = false
+        _hitProgress = 0f
+    }
+
+    fun endPlayerHitDelayed() {
+        _isPlayerHitDelayed = false
+    }
+
+    // Opponent-specific hit methods
+    fun startOpponentHit() {
+        _isOpponentHit = true
+        _hitProgress = 0f
+    }
+
+    fun startOpponentHitDelayed() {
+        _isOpponentHitDelayed = true
+    }
+
+    fun endOpponentHit() {
+        _isOpponentHit = false
+        _hitProgress = 0f
+    }
+
+    fun endOpponentHitDelayed() {
+        _isOpponentHitDelayed = false
+    }
+
+    // Delayed shake methods
+    fun startPlayerShakeDelayed() {
+        _isPlayerShakeDelayed = true
+    }
+
+    fun endPlayerShakeDelayed() {
+        _isPlayerShakeDelayed = false
+    }
+
+    fun startOpponentShakeDelayed() {
+        _isOpponentShakeDelayed = true
+    }
+
+    fun endOpponentShakeDelayed() {
+        _isOpponentShakeDelayed = false
+    }
+
+    // Combined method to handle attack result
+    fun handleAttackResult(isHit: Boolean) {
+        _attackIsHit = isHit
+        if (isHit) {
+            // Player attack hit - opponent gets hit
+            startOpponentHit()
+        } else {
+            // Player attack missed - opponent dodges
+            startOpponentDodge()
+        }
+    }
+
+    // Method to handle opponent attack result
+    fun handleOpponentAttackResult(isHit: Boolean) {
+        _opponentAttackIsHit = isHit
+        if (isHit) {
+            // Opponent attack hit - player gets hit
+            startPlayerHit()
+        } else {
+            // Opponent attack missed - player dodges
+            startPlayerDodge()
+        }
+    }
+
+    // Counter-attack methods
+    fun setupCounterAttack(isHit: Boolean) {
+        _shouldCounterAttack = true
+        _counterAttackIsHit = isHit
+    }
+
+    fun startCounterAttack() {
+        _attackPhase = 3
+        _attackProgress = 0f
+        _isPlayerAttacking = false
+        _currentView = 1
+        _opponentAttackIsHit = _counterAttackIsHit
+    }
+} 

app/src/main/java/com/github/nacabaro/vbhelper/battle/AttackSpriteManager.kt

@@ -0,0 +1,151 @@
+package com.github.nacabaro.vbhelper.battle
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.os.Environment
+import com.google.gson.Gson
+import java.io.File
+
+data class CharacterData(
+    val name: String,
+    val charaId: String,
+    val smalefilename: String,
+    val laugeFileName: String
+)
+
+data class CharacterDataResponse(
+    val name: String,
+    val type: String,
+    val source_file: String,
+    val collection: String,
+    val unity_collection_id: String,
+    val relative_path: String,
+    val all_attributes: CharacterDataAttributes
+)
+
+data class CharacterDataAttributes(
+    val DataList: List<String>
+)
+
+class AttackSpriteManager(private val context: Context) {
+    private val gson = Gson()
+    private val characterDataCache = mutableMapOf<String, CharacterData>()
+    
+    // Get the external storage directory for attack sprites
+    private fun getAttackTexturesBaseDir(): File {
+        val externalDir = android.os.Environment.getExternalStorageDirectory()
+        return File(externalDir, "VBHelper/battle_sprites/extracted_atksprites")
+    }
+    
+    fun getAttackSprite(characterId: String, isLarge: Boolean = false): Bitmap? {
+        println("AttackSpriteManager: Getting attack sprite for characterId=$characterId, isLarge=$isLarge")
+        try {
+            // Get character data
+            val characterData = getCharacterData(characterId) ?: return null
+            // Determine which attack file to use
+            val attackFileName = if (isLarge) {
+                characterData.laugeFileName
+            } else {
+                characterData.smalefilename
+            }
+            
+            // Skip if no attack file
+            if (attackFileName == "0") {
+                println("AttackSpriteManager: Skipping attack file (filename is '0')")
+                return null
+            }
+            
+            // Load the attack sprite from external storage
+            val attackFile = File(getAttackTexturesBaseDir(), "$attackFileName.png")
+            
+            return if (attackFile.exists()) {
+                val bitmap = BitmapFactory.decodeFile(attackFile.absolutePath)
+                bitmap
+            } else {
+                println("AttackSpriteManager: Attack file does not exist")
+                null
+            }
+        } catch (e: Exception) {
+            println("AttackSpriteManager: Exception occurred: ${e.message}")
+            e.printStackTrace()
+            return null
+        }
+    }
+    
+    private fun getCharacterData(characterId: String): CharacterData? {
+        // Check cache first
+        if (characterDataCache.containsKey(characterId)) {
+            return characterDataCache[characterId]
+        }
+        
+        try {
+            // Load character data from JSON file in external storage
+            val externalDir = android.os.Environment.getExternalStorageDirectory()
+            val characterDataFile = File(externalDir, "VBHelper/battle_sprites/extracted_digimon_stats/character_data/CharacterData.json")
+            
+            if (!characterDataFile.exists()) {
+                println("AttackSpriteManager: Character data file does not exist, using default data")
+                // For now, return a default character data
+                val characterData = CharacterData(
+                    name = characterId,
+                    charaId = characterId,
+                    smalefilename = "atk_s_02", // Default small attack
+                    laugeFileName = "atk_l_04"   // Default large attack
+                )
+                
+                characterDataCache[characterId] = characterData
+                return characterData
+            }
+            
+            val jsonContent = characterDataFile.readText()
+            
+            // Parse the JSON response
+            val response = gson.fromJson(jsonContent, CharacterDataResponse::class.java)
+            
+            // Search through the DataList for the matching characterId
+            for (characterString in response.all_attributes.DataList) {
+                // Extract charaId from the string format: "<UnknownObject<Character> id=0, charaId='dim000_mon03', ...>"
+                val charaIdMatch = Regex("charaId='([^']+)'").find(characterString)
+                if (charaIdMatch != null) {
+                    val foundCharaId = charaIdMatch.groupValues[1]
+                    if (foundCharaId == characterId) {
+                        // Extract smalefilename and laugeFileName
+                        val smallFileMatch = Regex("smalefilename='([^']+)'").find(characterString)
+                        val largeFileMatch = Regex("laugeFileName='([^']+)'").find(characterString)
+                        
+                        val smallFileName = smallFileMatch?.groupValues?.get(1) ?: "0"
+                        val largeFileName = largeFileMatch?.groupValues?.get(1) ?: "0"
+                        
+                        val characterData = CharacterData(
+                            name = characterId,
+                            charaId = characterId,
+                            smalefilename = smallFileName,
+                            laugeFileName = largeFileName
+                        )
+                        
+                        characterDataCache[characterId] = characterData
+                        return characterData
+                    }
+                }
+            }
+            
+            // If character not found, return default data
+            println("AttackSpriteManager: Character not found in JSON, using default data")
+            val characterData = CharacterData(
+                name = characterId,
+                charaId = characterId,
+                smalefilename = "atk_s_02", // Default small attack
+                laugeFileName = "atk_l_04"   // Default large attack
+            )
+            
+            characterDataCache[characterId] = characterData
+            return characterData
+            
+        } catch (e: Exception) {
+            println("AttackSpriteManager: Exception in getCharacterData: ${e.message}")
+            e.printStackTrace()
+            return null
+        }
+    }
+} 

app/src/main/java/com/github/nacabaro/vbhelper/battle/AuthInterceptor.kt

@@ -0,0 +1,31 @@
+package com.github.nacabaro.vbhelper.battle
+
+import okhttp3.Interceptor
+import okhttp3.Response
+
+/**
+ * OkHttp interceptor that adds Authorization header to API requests.
+ * Skips adding header for auth endpoints.
+ */
+class AuthInterceptor(private val token: String) : Interceptor {
+    override fun intercept(chain: Interceptor.Chain): Response {
+        val originalRequest = chain.request()
+        
+        // Skip adding auth header for auth endpoints
+        if (originalRequest.url.encodedPath.startsWith("/api/auth")) {
+            return chain.proceed(originalRequest)
+        }
+        
+        // Add authentication header for game endpoints
+        // Use X-Session-Token header (preferred) or Authorization: Bearer
+        val authenticatedRequest = originalRequest.newBuilder()
+            .header("X-Session-Token", token)
+            .build()
+        
+        // Debug: Log which header is being used (first few chars of token for security)
+        val tokenPreview = if (token.length > 8) "${token.take(4)}...${token.takeLast(4)}" else "***"
+        println("AuthInterceptor: Adding X-Session-Token header (token: $tokenPreview)")
+        
+        return chain.proceed(authenticatedRequest)
+    }
+}

app/src/main/java/com/github/nacabaro/vbhelper/battle/AuthService.kt

@@ -0,0 +1,14 @@
+package com.github.nacabaro.vbhelper.battle
+
+import retrofit2.Call
+import retrofit2.http.Body
+import retrofit2.http.POST
+
+interface AuthService {
+    @POST("api/auth/validate")
+    fun validate(@Body request: AuthenticateRequest): Call<AuthenticateResponse>
+    
+    @POST("api/auth/login")
+    fun login(@Body request: AuthenticateRequest): Call<AuthenticateResponse>
+}
+

app/src/main/java/com/github/nacabaro/vbhelper/battle/AuthenticateRequest.kt

@@ -0,0 +1,6 @@
+package com.github.nacabaro.vbhelper.battle
+
+data class AuthenticateRequest(
+    val userToken: String
+)
+

app/src/main/java/com/github/nacabaro/vbhelper/battle/AuthenticateResponse.kt

@@ -0,0 +1,21 @@
+package com.github.nacabaro.vbhelper.battle
+
+data class AdditionalInfo(
+    val avatar: String? = null,
+    val id: Long? = null,
+    val name: String? = null,
+    val status: String? = null
+)
+
+data class UserInfo(
+    val userId: String? = null,
+    val additionalInfo: AdditionalInfo? = null
+)
+
+data class AuthenticateResponse(
+    val success: Boolean,
+    val message: String? = null,
+    val userInfo: UserInfo? = null,
+    val sessionToken: String? = null
+)
+

app/src/main/java/com/github/nacabaro/vbhelper/battle/BattleAuthContainer.kt

@@ -0,0 +1,16 @@
+package com.github.nacabaro.vbhelper.battle
+
+import android.content.Context
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.preferencesDataStore
+import com.github.nacabaro.vbhelper.source.AuthRepository
+
+private const val BATTLE_AUTH_PREFERENCES_NAME = "battle_auth_preferences"
+val Context.battleAuthStore: androidx.datastore.core.DataStore<Preferences> by preferencesDataStore(
+    name = BATTLE_AUTH_PREFERENCES_NAME
+)
+
+class BattleAuthContainer(private val context: Context) {
+    val authRepository: AuthRepository = AuthRepository(context.battleAuthStore)
+}
+

app/src/main/java/com/github/nacabaro/vbhelper/battle/BattleSpriteManager.kt

@@ -0,0 +1,181 @@
+package com.github.nacabaro.vbhelper.battle
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.os.Environment
+import com.google.gson.Gson
+import java.io.File
+
+data class SpriteMapping(
+    val atlas_name: String,
+    val atlas_file: String,
+    val texture: TextureInfo,
+    val sprites: List<String>
+)
+
+data class TextureInfo(
+    val name: String,
+    val file: String,
+    val path_id: Long
+)
+
+data class SpriteData(
+    val name: String,
+    val atlas_name: String,
+    val m_Name: String,
+    val texture_rect: TextureRect
+)
+
+data class TextureRect(
+    val height: Float,
+    val width: Float,
+    val x: Float,
+    val y: Float
+)
+
+class BattleSpriteManager(private val context: Context) {
+    private val gson = Gson()
+    private val spriteCache = mutableMapOf<String, Bitmap>()
+    
+    // Get the external storage directory for sprite files
+    private fun getSpriteBaseDir(): File {
+        val externalDir = android.os.Environment.getExternalStorageDirectory()
+        return File(externalDir, "VBHelper/battle_sprites/extracted_assets")
+    }
+    
+    fun loadSprite(spriteName: String, atlasName: String): Bitmap? {
+        val cacheKey = "${spriteName}_${atlasName}"
+        
+        // Check cache first
+        if (spriteCache.containsKey(cacheKey)) {
+            return spriteCache[cacheKey]
+        }
+        
+        // Debug: Check if base directory exists
+        val spriteBaseDir = getSpriteBaseDir()
+        if (!spriteBaseDir.exists()) {
+            println("Sprite base directory does not exist: ${spriteBaseDir.absolutePath}")
+            return null
+        }
+        
+        println("Sprite base directory exists: ${spriteBaseDir.absolutePath}")
+        println("Available directories: ${spriteBaseDir.listFiles()?.map { it.name }}")
+        
+        try {
+            // Load the PNG texture file directly using the atlas name
+            val textureFile = File(spriteBaseDir, "extracted_textures/${atlasName}.png")
+            
+            if (!textureFile.exists()) {
+                println("Texture file not found: ${textureFile.absolutePath}")
+                return null
+            }
+            
+            val fullBitmap = BitmapFactory.decodeFile(textureFile.absolutePath)
+            if (fullBitmap == null) {
+                println("Failed to decode texture file: ${textureFile.absolutePath}")
+                return null
+            }
+            
+            // Load the specific sprite data file
+            val spriteDataFile = File(spriteBaseDir, "sprites/${spriteName}.json")
+            if (!spriteDataFile.exists()) {
+                println("Sprite data file not found: ${spriteDataFile.absolutePath}")
+                return null
+            }
+            
+            val spriteDataJson = spriteDataFile.readText()
+            val spriteData = gson.fromJson(spriteDataJson, SpriteData::class.java)
+            
+            // Debug: Print sprite coordinates
+            println("Sprite coordinates: x=${spriteData.texture_rect.x}, y=${spriteData.texture_rect.y}, width=${spriteData.texture_rect.width}, height=${spriteData.texture_rect.height}")
+            println("Texture dimensions: width=${fullBitmap.width}, height=${fullBitmap.height}")
+            
+            // Calculate the correct Y coordinate (inverted coordinate system)
+            val correctedY = fullBitmap.height - spriteData.texture_rect.y.toInt() - spriteData.texture_rect.height.toInt()
+            
+            // Extract the sprite from the atlas using texture_rect coordinates
+            val spriteBitmap = Bitmap.createBitmap(
+                fullBitmap,
+                spriteData.texture_rect.x.toInt(),
+                correctedY,
+                spriteData.texture_rect.width.toInt(),
+                spriteData.texture_rect.height.toInt()
+            )
+            
+            // Ensure the bitmap is not scaled and has proper quality
+            val finalBitmap = if (spriteBitmap.width != spriteData.texture_rect.width.toInt() || 
+                                  spriteBitmap.height != spriteData.texture_rect.height.toInt()) {
+                // If the bitmap was scaled during creation, create a new one with exact dimensions
+                Bitmap.createScaledBitmap(spriteBitmap, 
+                    spriteData.texture_rect.width.toInt(), 
+                    spriteData.texture_rect.height.toInt(), 
+                    false) // false = no filtering/interpolation
+            } else {
+                spriteBitmap
+            }
+            
+            println("Extracted sprite dimensions: ${finalBitmap.width}x${finalBitmap.height}")
+            
+            // Cache the result
+            spriteCache[cacheKey] = finalBitmap
+            
+            return finalBitmap
+            
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return null
+        }
+    }
+    
+    fun clearCache() {
+        spriteCache.clear()
+    }
+    
+    // Helper method to get available sprites for an atlas
+    fun getAvailableSprites(atlasName: String): List<String> {
+        try {
+            val spritesDir = File(getSpriteBaseDir(), "sprites")
+            if (!spritesDir.exists()) {
+                return emptyList()
+            }
+            
+            val spriteFiles = spritesDir.listFiles { file ->
+                file.name.startsWith("${atlasName}_sprite_") && file.name.endsWith(".json")
+            } ?: emptyArray()
+            
+            return spriteFiles.map { file ->
+                // Extract sprite number from filename (e.g., "dim000_mon01_sprite_00.json" -> "00")
+                val spriteNumber = file.name.substringAfter("_sprite_").substringBefore(".json")
+                spriteNumber
+            }.sorted()
+            
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return emptyList()
+        }
+    }
+    
+    // Helper method to get available atlases
+    fun getAvailableAtlases(): List<String> {
+        try {
+            val texturesDir = File(getSpriteBaseDir(), "extracted_textures")
+            if (!texturesDir.exists()) {
+                return emptyList()
+            }
+            
+            val textureFiles = texturesDir.listFiles { file ->
+                file.name.endsWith(".png")
+            } ?: emptyArray()
+            
+            return textureFiles.map { file ->
+                // Extract atlas name from filename (e.g., "dim000_mon01.png" -> "dim000_mon01")
+                file.name.substringBefore(".png")
+            }.sorted()
+            
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return emptyList()
+        }
+    }
+}

app/src/main/java/com/github/nacabaro/vbhelper/battle/DigimonAnimationState.kt

@@ -0,0 +1,167 @@
+package com.github.nacabaro.vbhelper.battle
+
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import kotlinx.coroutines.delay
+import android.content.Context
+import java.io.File
+
+enum class DigimonAnimationType {
+    IDLE,
+    IDLE2,
+    WALK,
+    WALK2,
+    RUN,
+    RUN2,
+    WORKOUT,
+    WORKOUT2,
+    HAPPY,
+    SLEEP,
+    ATTACK,
+    FLEE
+}
+
+data class AnimationState(
+    val type: DigimonAnimationType,
+    val frameNumber: Int, // 1-12 for individual PNG files
+    val duration: Long = 100L, // Duration in milliseconds
+    val loop: Boolean = true
+)
+
+class DigimonAnimationStateMachine(
+    private val characterId: String,
+    private val context: Context,
+    private val initialFrameOffset: Int = 0, // New parameter for offsetting the starting frame
+    private val timingOffset: Long = 0L // New parameter for offsetting the timing
+) {
+    var currentAnimation by mutableStateOf<DigimonAnimationType>(DigimonAnimationType.IDLE)
+        private set
+    
+    var currentFrameNumber by mutableStateOf(1)
+        private set
+    
+    var isPlaying by mutableStateOf(false)
+        private set
+    
+    // Direct mapping of frame numbers (1-12) to animation types
+    // This is based on the standard Digimon sprite frame order
+    private val frameToAnimationType = mapOf(
+        1 to DigimonAnimationType.IDLE,
+        2 to DigimonAnimationType.IDLE2,
+        3 to DigimonAnimationType.WALK,
+        4 to DigimonAnimationType.WALK2,
+        5 to DigimonAnimationType.RUN,
+        6 to DigimonAnimationType.RUN2,
+        7 to DigimonAnimationType.WORKOUT,
+        8 to DigimonAnimationType.WORKOUT2,
+        9 to DigimonAnimationType.HAPPY,
+        10 to DigimonAnimationType.SLEEP,
+        11 to DigimonAnimationType.ATTACK,
+        12 to DigimonAnimationType.FLEE
+    )
+    
+    // Reverse mapping for getting frame numbers for each animation type
+    private val animationTypeToFrames = frameToAnimationType.entries.groupBy({ it.value }, { it.key })
+    
+    // Animation durations for each type
+    private val animationDurations = mapOf(
+        DigimonAnimationType.IDLE to 750L,
+        DigimonAnimationType.IDLE2 to 750L,
+        DigimonAnimationType.WALK to 200L,
+        DigimonAnimationType.WALK2 to 200L,
+        DigimonAnimationType.RUN to 150L,
+        DigimonAnimationType.RUN2 to 150L,
+        DigimonAnimationType.WORKOUT to 300L,
+        DigimonAnimationType.WORKOUT2 to 300L,
+        DigimonAnimationType.HAPPY to 400L,
+        DigimonAnimationType.SLEEP to 1500L,
+        DigimonAnimationType.ATTACK to 650L,
+        DigimonAnimationType.FLEE to 150L
+    )
+
+    /*
+    init {
+        println("Initialized DigimonAnimationStateMachine for character: $characterId with frame offset: $initialFrameOffset, timing offset: $timingOffset")
+        println("Available animation types: ${animationTypeToFrames.keys}")
+    }
+    */
+    
+    suspend fun playAnimation(animationType: DigimonAnimationType) {
+        if (currentAnimation == animationType && isPlaying) {
+            return // Already playing this animation
+        }
+        
+        currentAnimation = animationType
+        isPlaying = true
+        
+        val frameNumbers = animationTypeToFrames[animationType] ?: listOf(1)
+        val duration = animationDurations[animationType] ?: 100L
+        
+        // For non-looping animations like ATTACK, play once and return to IDLE
+        if (animationType == DigimonAnimationType.ATTACK) {
+            currentFrameNumber = frameNumbers.firstOrNull() ?: 1
+            delay(duration)
+            playAnimation(DigimonAnimationType.IDLE)
+        } else {
+            // For looping animations, cycle through frames
+            var frameIndex = 0
+            while (isPlaying && currentAnimation == animationType) {
+                val frameNumber = frameNumbers[frameIndex % frameNumbers.size]
+                currentFrameNumber = frameNumber
+                delay(duration)
+                frameIndex++
+            }
+        }
+    }
+    
+    // Special method for idle animation that cycles between IDLE and IDLE2
+    suspend fun playIdleAnimation() {
+        if (currentAnimation == DigimonAnimationType.IDLE && isPlaying) {
+            return // Already playing idle animation
+        }
+        
+        currentAnimation = DigimonAnimationType.IDLE
+        isPlaying = true
+
+        val idleFrames = animationTypeToFrames[DigimonAnimationType.IDLE] ?: listOf(1)
+        val idle2Frames = animationTypeToFrames[DigimonAnimationType.IDLE2] ?: listOf(2)
+        
+        // Combine frames for cycling idle animation
+        val combinedFrames = (idleFrames + idle2Frames).distinct()
+        
+        val duration = animationDurations[DigimonAnimationType.IDLE] ?: 500L
+        
+        // Apply initial timing offset
+        if (timingOffset > 0L) {
+            delay(timingOffset)
+        }
+        
+        // Cycle through idle frames, starting from the offset
+        var frameIndex = initialFrameOffset
+        while (isPlaying && currentAnimation == DigimonAnimationType.IDLE) {
+            val frameNumber = combinedFrames[frameIndex % combinedFrames.size]
+            currentFrameNumber = frameNumber
+            delay(duration)
+            frameIndex++
+        }
+    }
+    
+    fun stopAnimation() {
+        isPlaying = false
+    }
+    
+    fun getCurrentFrame(): Int {
+        return currentFrameNumber
+    }
+    
+    fun getCurrentCharacterId(): String {
+        return characterId
+    }
+    
+    // Method to reload mappings (useful for testing)
+    fun reloadMappings() {
+        println("Reloading mappings for character: $characterId")
+        // No need to reload since we use direct frame mapping
+    }
+} 

app/src/main/java/com/github/nacabaro/vbhelper/battle/HitEffectComposables.kt

@@ -0,0 +1,120 @@
+package com.github.nacabaro.vbhelper.battle
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.size
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+
+@Composable
+fun HitEffectOverlay(
+    isVisible: Boolean,
+    modifier: Modifier = Modifier,
+    isPlayerScreen: Boolean = false,
+    onAnimationComplete: () -> Unit = {}
+) {
+    if (!isVisible) return
+    
+    val context = LocalContext.current
+    val configuration = LocalConfiguration.current
+    val isLandscapeMode = configuration.orientation == android.content.res.Configuration.ORIENTATION_LANDSCAPE
+    val hitEffectManager = remember { HitEffectSpriteManager(context) }
+    val coroutineScope = rememberCoroutineScope()
+    
+    var currentFrame by remember { mutableStateOf(0) }
+    var currentSprite by remember { mutableStateOf<android.graphics.Bitmap?>(null) }
+    var animationProgress by remember { mutableStateOf(0f) }
+    var scale by remember { mutableStateOf(0.5f) }
+    var alpha by remember { mutableStateOf(1f) }
+    
+    LaunchedEffect(isVisible) {
+        if (isVisible) {
+            
+            // Add delay before starting hit effect animation
+            delay(400) // Increased from 200ms to 400ms delay before hit effect appears
+            
+            // Randomly choose between hit_01, hit_02, and hit_02_white
+            val hitSpriteName = when (kotlin.random.Random.nextInt(3)) {
+                0 -> "hit_01"
+                1 -> "hit_02"
+                else -> "hit_02_white"
+            }
+            currentSprite = hitEffectManager.loadHitSprite(hitSpriteName)
+            
+            if (currentSprite != null) {
+                // Animate the hit effect
+                animationProgress = 0f
+                scale = 0.5f
+                alpha = 1f
+                
+                // Scale up animation - slowed down
+                while (scale < 1.2f) {
+                    scale += 0.05f  // Reduced from 0.1f to 0.05f
+                    delay(32)       // Increased from 16ms to 32ms
+                }
+                
+                // Hold for a moment - increased duration
+                delay(300)  // Increased from 100ms to 300ms
+                
+                // Fade out - slowed down
+                while (alpha > 0f) {
+                    alpha -= 0.03f  // Reduced from 0.05f to 0.03f
+                    delay(32)       // Increased from 16ms to 32ms
+                }
+                
+                println("DEBUG: Hit effect animation completed")
+                onAnimationComplete()
+            } else {
+                println("DEBUG: Failed to load hit sprite")
+                onAnimationComplete()
+            }
+        }
+    }
+    
+    currentSprite?.let { sprite ->
+        Box(
+            modifier = modifier.fillMaxSize(),
+            contentAlignment = Alignment.Center
+        ) {
+            Image(
+                bitmap = sprite.asImageBitmap(),
+                contentDescription = "Hit Effect",
+                modifier = Modifier
+                    .size((sprite.width * scale).dp, (sprite.height * scale).dp)
+                    .offset(
+                        x = if (isPlayerScreen) {
+                            // On player screen, position further to the left
+                            if (isLandscapeMode) {
+                                // In landscape mode, move even further left for player screen
+                                (-sprite.width * scale / 2 - 300).dp
+                            } else {
+                                // In portrait mode, use original positioning
+                                (-sprite.width * scale / 2 - 100).dp
+                            }
+                        } else {
+                            // On enemy screen, position further to the right
+                            if (isLandscapeMode) {
+                                // In landscape mode, move even further right for enemy screen
+                                (-sprite.width * scale / 2 + 350).dp
+                            } else {
+                                // In portrait mode, use original positioning
+                                (-sprite.width * scale / 2 + 150).dp
+                            }
+                        },
+                        y = (-sprite.height * scale / 2 + 40).dp  // Position lower on screen (was -60, now +40)
+                    ),
+                contentScale = ContentScale.Fit
+            )
+        }
+    }
+}

app/src/main/java/com/github/nacabaro/vbhelper/battle/HitEffectSpriteManager.kt

@@ -0,0 +1,172 @@
+package com.github.nacabaro.vbhelper.battle
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Rect
+import android.os.Environment
+import java.io.File
+
+class HitEffectSpriteManager(private val context: Context) {
+    private val spriteCache = mutableMapOf<String, Bitmap>()
+    
+    // Get the external storage directory for hit effect sprites
+    private fun getHitSpritesDir(): File {
+        val externalDir = android.os.Environment.getExternalStorageDirectory()
+        return File(externalDir, "VBHelper/battle_sprites/extracted_hit_sprites")
+    }
+    
+    /**
+     * Load a hit sprite (hit_01.png, hit_02.png, hit_02_white.png)
+     * @param spriteName The sprite name (e.g., "hit_01", "hit_02", "hit_02_white")
+     * @return Bitmap of the hit sprite, or null if not found
+     */
+    fun loadHitSprite(spriteName: String): Bitmap? {
+        val cacheKey = "hit_$spriteName"
+        
+        // Check cache first
+        if (spriteCache.containsKey(cacheKey)) {
+            return spriteCache[cacheKey]
+        }
+        
+        try {
+            val hitSpritesDir = getHitSpritesDir()
+            val spriteFile = File(hitSpritesDir, "$spriteName.png")
+            
+            if (!spriteFile.exists()) {
+                println("Hit sprite file not found: ${spriteFile.absolutePath}")
+                return null
+            }
+            
+            val bitmap = BitmapFactory.decodeFile(spriteFile.absolutePath)
+            if (bitmap == null) {
+                println("Failed to decode hit sprite file: ${spriteFile.absolutePath}")
+                return null
+            }
+            
+            // Cache the result
+            spriteCache[cacheKey] = bitmap
+            
+            return bitmap
+            
+        } catch (e: Exception) {
+            println("Error loading hit sprite: ${e.message}")
+            e.printStackTrace()
+            return null
+        }
+    }
+    
+    /**
+     * Load a damage effect sprite from spritesheet
+     * @param spritesheetName The spritesheet name (e.g., "dmg_ef1", "dmg_ef2")
+     * @param frameIndex The frame index (0-3 for dmg_ef1 and dmg_ef2, 0 for dmg_ef3)
+     * @return Bitmap of the damage effect frame, or null if not found
+     */
+    fun loadDamageEffectSprite(spritesheetName: String, frameIndex: Int = 0): Bitmap? {
+        val cacheKey = "dmg_${spritesheetName}_frame_${frameIndex}"
+        
+        // Check cache first
+        if (spriteCache.containsKey(cacheKey)) {
+            return spriteCache[cacheKey]
+        }
+        
+        try {
+            val spritesheetFile = File(getHitSpritesDir(), "$spritesheetName.png")
+            
+            if (!spritesheetFile.exists()) {
+                println("Damage effect spritesheet not found: ${spritesheetFile.absolutePath}")
+                return null
+            }
+            
+            val spritesheet = BitmapFactory.decodeFile(spritesheetFile.absolutePath)
+            if (spritesheet == null) {
+                println("Failed to decode damage effect spritesheet: ${spritesheetFile.absolutePath}")
+                return null
+            }
+            
+            // Extract frame from spritesheet
+            val frameBitmap = when (spritesheetName) {
+                "dmg_ef1", "dmg_ef2" -> {
+                    // These are 2x2 spritesheets (4 frames)
+                    val frameWidth = spritesheet.width / 2
+                    val frameHeight = spritesheet.height / 2
+                    val row = frameIndex / 2
+                    val col = frameIndex % 2
+                    val x = col * frameWidth
+                    val y = row * frameHeight
+                    Bitmap.createBitmap(spritesheet, x, y, frameWidth, frameHeight)
+                }
+                "dmg_ef3" -> {
+                    // This is a single sprite
+                    spritesheet
+                }
+                else -> {
+                    println("Unknown spritesheet name: $spritesheetName")
+                    return null
+                }
+            }
+            
+            println("Successfully loaded damage effect frame: $spritesheetName frame $frameIndex (${frameBitmap.width}x${frameBitmap.height})")
+            
+            // Cache the result
+            spriteCache[cacheKey] = frameBitmap
+            
+            return frameBitmap
+            
+        } catch (e: Exception) {
+            println("Error loading damage effect sprite: ${e.message}")
+            e.printStackTrace()
+            return null
+        }
+    }
+    
+    /**
+     * Get all available hit sprites
+     * @return List of hit sprite names (without .png extension)
+     */
+    fun getAvailableHitSprites(): List<String> {
+        val hitSpritesDir = getHitSpritesDir()
+        
+        if (!hitSpritesDir.exists()) {
+            return emptyList()
+        }
+        
+        return hitSpritesDir.listFiles { file ->
+            file.name.startsWith("hit_") && file.name.endsWith(".png")
+        }?.map { file ->
+            file.name.substringBefore(".png")
+        }?.sorted() ?: emptyList()
+    }
+    
+    /**
+     * Get available damage effect spritesheet names
+     * @return List of available damage effect spritesheet names
+     */
+    fun getAvailableDamageEffectSpritesheets(): List<String> {
+        try {
+            if (!getHitSpritesDir().exists()) {
+                return emptyList()
+            }
+            
+            val dmgFiles = getHitSpritesDir().listFiles { file ->
+                file.name.startsWith("dmg_ef") && file.name.endsWith(".png")
+            } ?: emptyArray()
+            
+            return dmgFiles.map { file ->
+                file.name.substringBefore(".png")
+            }.sorted()
+            
+        } catch (e: Exception) {
+            println("Error getting available damage effect spritesheets: ${e.message}")
+            e.printStackTrace()
+            return emptyList()
+        }
+    }
+    
+    /**
+     * Clear the sprite cache
+     */
+    fun clearCache() {
+        spriteCache.clear()
+    }
+}

app/src/main/java/com/github/nacabaro/vbhelper/battle/IndividualSpriteManager.kt

@@ -0,0 +1,132 @@
+package com.github.nacabaro.vbhelper.battle
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.os.Environment
+import java.io.File
+
+class IndividualSpriteManager(private val context: Context) {
+    private val spriteCache = mutableMapOf<String, Bitmap>()
+    
+    // Get the external storage directory for sprite files
+    private fun getSpriteBaseDir(): File {
+        val externalDir = android.os.Environment.getExternalStorageDirectory()
+        return File(externalDir, "VBHelper/battle_sprites/extracted_assets/sprites")
+    }
+    
+    /**
+     * Load a specific sprite frame for a character
+     * @param characterId The character ID (e.g., "dim012_mon03")
+     * @param frameNumber The frame number (1-12)
+     * @return Bitmap of the sprite frame, or null if not found
+     */
+    fun loadSpriteFrame(characterId: String, frameNumber: Int): Bitmap? {
+        val cacheKey = "${characterId}_frame_${frameNumber}"
+        
+        // Check cache first
+        if (spriteCache.containsKey(cacheKey)) {
+            return spriteCache[cacheKey]
+        }
+        
+        // Debug: Check if base directory exists
+        val spriteBaseDir = getSpriteBaseDir()
+        if (!spriteBaseDir.exists()) {
+            println("Sprite base directory does not exist: ${spriteBaseDir.absolutePath}")
+            return null
+        }
+        
+        try {
+            // Construct the sprite file path
+            val spriteFileName = "${characterId}_${String.format("%02d", frameNumber)}.png"
+            val spriteFile = File(spriteBaseDir, "$characterId/$spriteFileName")
+            
+            if (!spriteFile.exists()) {
+                println("Sprite file not found: ${spriteFile.absolutePath}")
+                return null
+            }
+            
+            // Load the PNG file directly
+            val bitmap = BitmapFactory.decodeFile(spriteFile.absolutePath)
+            if (bitmap == null) {
+                println("Failed to decode sprite file: ${spriteFile.absolutePath}")
+                return null
+            }
+            
+            // Cache the result
+            spriteCache[cacheKey] = bitmap
+            
+            return bitmap
+            
+        } catch (e: Exception) {
+            println("Error loading sprite frame: ${e.message}")
+            e.printStackTrace()
+            return null
+        }
+    }
+    
+    /**
+     * Get all available sprite frames for a character
+     * @param characterId The character ID
+     * @return List of frame numbers (1-12) that exist for this character
+     */
+    fun getAvailableFrames(characterId: String): List<Int> {
+        val spriteBaseDir = getSpriteBaseDir()
+        val characterDir = File(spriteBaseDir, characterId)
+        
+        if (!characterDir.exists()) {
+            return emptyList()
+        }
+        
+        val spriteFiles = characterDir.listFiles { file ->
+            file.name.startsWith("${characterId}_") && file.name.endsWith(".png")
+        } ?: emptyArray()
+        
+        return spriteFiles.mapNotNull { file ->
+            val fileName = file.name
+            val frameMatch = Regex("${characterId}_(\\d{2})\\.png").find(fileName)
+            frameMatch?.groupValues?.get(1)?.toIntOrNull()
+        }.sorted()
+    }
+    
+    /**
+     * Get all available character IDs
+     * @return List of character IDs that have sprite directories
+     */
+    fun getAvailableCharacters(): List<String> {
+        val spriteBaseDir = getSpriteBaseDir()
+        
+        if (!spriteBaseDir.exists()) {
+            return emptyList()
+        }
+        
+        return spriteBaseDir.listFiles { file ->
+            file.isDirectory && file.listFiles()?.any { it.name.endsWith(".png") } == true
+        }?.map { it.name }?.sorted() ?: emptyList()
+    }
+    
+    /**
+     * Clear the sprite cache
+     */
+    fun clearCache() {
+        spriteCache.clear()
+    }
+    
+    /**
+     * Check if a character has sprite files
+     * @param characterId The character ID to check
+     * @return true if the character has sprite files, false otherwise
+     */
+    fun hasCharacterSprites(characterId: String): Boolean {
+        val characterDir = File(getSpriteBaseDir(), characterId)
+        if (!characterDir.exists()) {
+            return false
+        }
+        
+        val spriteFiles = characterDir.listFiles { file ->
+            file.name.startsWith("${characterId}_") && file.name.endsWith(".png")
+        } ?: emptyArray()
+        
+        return spriteFiles.isNotEmpty()
+    }
+} 

app/src/main/java/com/github/nacabaro/vbhelper/battle/OpponentService.kt

@@ -0,0 +1,13 @@
+package com.github.nacabaro.vbhelper.battle
+
+import retrofit2.Call
+import retrofit2.http.GET
+import retrofit2.http.Query
+
+interface OpponentService {
+    @GET("api/opponents")
+    // This method returns a Call object with a generic
+    // type of DataModel, which represents
+    // the data model for the response.
+    fun getopponents(@Query("stage") stage: String): Call<OpponentsDataModel>
+}

app/src/main/java/com/github/nacabaro/vbhelper/battle/OpponentsDataModel.kt

@@ -0,0 +1,5 @@
+package com.github.nacabaro.vbhelper.battle
+
+data class OpponentsDataModel (
+    val opponentsList: ArrayList<APIBattleCharacter>
+):java.io.Serializable

app/src/main/java/com/github/nacabaro/vbhelper/battle/PVPDataModel.kt

@@ -0,0 +1,16 @@
+package com.github.nacabaro.vbhelper.battle
+
+data class PVPDataModel (
+    val status: String,
+    val state: Int,
+    val currentRound: Int,
+    val playerHP: Int,
+    val opponentHP: Int,
+    val playerAttackHit: Boolean,
+    val playerAttackDamage: Int,
+    val opponentAttackDamage: Int,
+    val winner: String,
+    val opponentCharaId: String? = null,  // Server provides opponent's charaId from the match
+    val playerMaxHP: Int? = null,  // Server should provide max HP for resumed matches
+    val opponentMaxHP: Int? = null  // Server should provide max HP for resumed matches
+):java.io.Serializable

app/src/main/java/com/github/nacabaro/vbhelper/battle/PVPService.kt

@@ -0,0 +1,22 @@
+package com.github.nacabaro.vbhelper.battle
+
+import retrofit2.Call
+import retrofit2.http.GET
+import retrofit2.http.Query
+
+interface PVPService {
+    @GET("api/pvp")
+    // This method returns a Call object with a generic
+    // type of DataModel, which represents
+    // the data model for the response.
+    fun getwinner(
+        @Query("apiStage") apiStage: Int, 
+        @Query("playerID") playerID: Long, 
+        @Query("playerDigi") playerDigi: String, 
+        @Query("playerStage") playerStage: Int, 
+        @Query("critBar") critBar: Int, 
+        @Query("opponentDigi") opponentDigi: String, 
+        @Query("opponentStage") opponentStage: Int,
+        @Query("action") action: String? = null  // Optional: "quit" or "rejoin"
+    ): Call<PVPDataModel>
+}

app/src/main/java/com/github/nacabaro/vbhelper/battle/RetrofitHelper.kt

@@ -0,0 +1,377 @@
+package com.github.nacabaro.vbhelper.battle
+
+import android.content.Context
+import retrofit2.Retrofit
+import android.widget.Toast
+import retrofit2.*
+import retrofit2.converter.gson.GsonConverterFactory
+import okhttp3.OkHttpClient
+import okhttp3.logging.HttpLoggingInterceptor
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import com.github.nacabaro.vbhelper.battle.BattleAuthContainer
+
+class RetrofitHelper {
+    
+    /**
+     * Creates an OkHttpClient with authentication interceptor for game endpoints.
+     * Requires a non-null, non-empty token.
+     */
+    private fun createAuthenticatedClient(token: String): OkHttpClient {
+        val loggingInterceptor = HttpLoggingInterceptor().apply {
+            level = HttpLoggingInterceptor.Level.BODY
+        }
+        
+        return OkHttpClient.Builder()
+            .addInterceptor(AuthInterceptor(token))
+            .addInterceptor(loggingInterceptor)
+            .build()
+    }
+    
+    /**
+     * Gets the session token from AuthRepository for API calls.
+     * Falls back to nacatech token if session token is not available (backward compatibility).
+     */
+    private fun getAuthToken(context: Context): String? {
+        return try {
+            val authContainer = BattleAuthContainer(context)
+            runBlocking {
+                // Prefer session token, fall back to nacatech token for backward compatibility
+                val sessionToken = authContainer.authRepository.sessionToken.first()
+                if (!sessionToken.isNullOrEmpty()) {
+                    println("RetrofitHelper: Using sessionToken for API call")
+                    sessionToken
+                } else {
+                    // Fallback to nacatech token (slower, but works)
+                    val nacatechToken = authContainer.authRepository.authToken.first()
+                    if (!nacatechToken.isNullOrEmpty()) {
+                        println("RetrofitHelper: No sessionToken found, falling back to nacatechToken")
+                    }
+                    nacatechToken
+                }
+            }
+        } catch (e: Exception) {
+            println("RetrofitHelper: Error getting auth token: ${e.message}")
+            null
+        }
+    }
+    
+    /**
+     * Creates a Retrofit instance with authentication for game endpoints.
+     */
+    private fun createAuthenticatedRetrofit(context: Context): Retrofit? {
+        val token = getAuthToken(context)
+        if (token.isNullOrEmpty()) {
+            println("RetrofitHelper: No auth token available")
+            return null
+        }
+        
+        val client = createAuthenticatedClient(token)
+        return Retrofit.Builder()
+            .baseUrl("http://battle.io-void.com:8080/")
+            .client(client)
+            .addConverterFactory(GsonConverterFactory.create())
+            .build()
+    }
+    
+    /**
+     * Handles HTTP error responses (401, 403, 429).
+     * For 401/403, clears authentication state to trigger re-authentication.
+     */
+    private fun handleErrorResponse(context: Context, response: Response<*>, errorMessage: String) {
+        when (response.code()) {
+            401 -> {
+                println("RetrofitHelper: Authentication failed (401) - token may be expired")
+                clearAuthAndNotify(context, "Authentication failed. Please log in again.")
+            }
+            403 -> {
+                println("RetrofitHelper: Access forbidden (403) - token may be expired or invalid")
+                // 403 could mean expired token, so clear auth state to trigger re-authentication
+                clearAuthAndNotify(context, "Session expired. Please log in again.")
+            }
+            429 -> {
+                println("RetrofitHelper: Rate limit exceeded (429)")
+                Toast.makeText(context, "Too many requests. Please wait a moment.", Toast.LENGTH_SHORT).show()
+            }
+            else -> {
+                println("RetrofitHelper: API error (${response.code()}): $errorMessage")
+                Toast.makeText(context, "Request failed: ${response.code()}", Toast.LENGTH_SHORT).show()
+            }
+        }
+    }
+    
+    /**
+     * Clears authentication state and shows a message.
+     * This will trigger BattlesScreen to detect the auth state change and open the login page.
+     */
+    private fun clearAuthAndNotify(context: Context, message: String) {
+        try {
+            val authContainer = BattleAuthContainer(context)
+            CoroutineScope(Dispatchers.IO).launch {
+                authContainer.authRepository.logout()
+                println("RetrofitHelper: Cleared authentication state due to expired/invalid token")
+            }
+            Toast.makeText(context, message, Toast.LENGTH_LONG).show()
+        } catch (e: Exception) {
+            println("RetrofitHelper: Error clearing auth state: ${e.message}")
+            Toast.makeText(context, message, Toast.LENGTH_LONG).show()
+        }
+    }
+
+    fun getOpponents(context: Context, stage: String, callback: (OpponentsDataModel) -> Unit) {
+        //println("RetrofitHelper: Starting API call for stage: $stage")
+
+        try {
+            // Create an authenticated Retrofit instance
+            val retrofit = createAuthenticatedRetrofit(context)
+            if (retrofit == null) {
+                println("RetrofitHelper: Cannot create authenticated Retrofit - no token available")
+                Toast.makeText(context, "Authentication required. Please log in.", Toast.LENGTH_SHORT).show()
+                return
+            }
+
+            // Create an ApiService instance from the Retrofit instance.
+            val service: OpponentService = retrofit.create<OpponentService>(OpponentService::class.java)
+            //println("RetrofitHelper: Service created")
+
+            // Call the getopponents() method of the ApiService
+            // to make an API request.
+            val call: Call<OpponentsDataModel> = service.getopponents(stage)
+            //println("RetrofitHelper: API call created, enqueueing...")
+
+            // Use the enqueue() method of the Call object to
+            // make an asynchronous API request.
+            call.enqueue(object : Callback<OpponentsDataModel> {
+                override fun onFailure(call: Call<OpponentsDataModel>, t: Throwable) {
+                    println("RetrofitHelper: API call failed: ${t.message}")
+                    t.printStackTrace()
+                    Toast.makeText(context, "Request Fail", Toast.LENGTH_SHORT).show()
+                }
+
+                override fun onResponse(call: Call<OpponentsDataModel>, response: Response<OpponentsDataModel>) {
+                    println("RetrofitHelper: API response received - Code: ${response.code()}")
+                    println("RetrofitHelper: Response body: ${response.body()}")
+
+                    if(response.isSuccessful){
+                        //println("RetrofitHelper: Response successful, calling callback")
+                        val opponentsList: OpponentsDataModel = response.body() as OpponentsDataModel
+                        callback(opponentsList)
+                    } else {
+                        val errorBody = response.errorBody()?.string()
+                        println("RetrofitHelper: Response not successful - Error: $errorBody")
+                        handleErrorResponse(context, response, errorBody ?: "Unknown error")
+                    }
+                }
+            })
+        } catch (e: Exception) {
+            println("RetrofitHelper: Exception in getOpponents: ${e.message}")
+            e.printStackTrace()
+            Toast.makeText(context, "Request failed: ${e.message}", Toast.LENGTH_SHORT).show()
+        }
+    }
+
+    /*
+    fun getCombatWinner(context: Context, stage: String, callback: (CombatDataModel) -> Unit) {
+
+        // Create a Retrofit instance with the base URL and
+        // a GsonConverterFactory for parsing the response.
+        val retrofit: Retrofit = Retrofit.Builder().baseUrl("http://battle.io-void.com:8080/").addConverterFactory(
+            GsonConverterFactory.create()).build()
+
+        // Create an ApiService instance from the Retrofit instance.
+        val service: CombatService = retrofit.create<CombatService>(CombatService::class.java)
+
+        // Call the getwinner() method of the ApiService
+        // to make an API request.
+        val call: Call<CombatDataModel> = service.getwinner(stage)
+
+        // Use the enqueue() method of the Call object to
+        // make an asynchronous API request.
+        call.enqueue(object : Callback<CombatDataModel> {
+            // This is an anonymous inner class that implements the Callback interface.
+
+            override fun onFailure(call: Call<CombatDataModel>, t: Throwable) {
+                // This method is called when the API request fails.
+                Toast.makeText(context, "Request Fail", Toast.LENGTH_SHORT).show()
+            }
+
+            override fun onResponse(call: Call<CombatDataModel>, response: Response<CombatDataModel>) {
+                // This method is called when the API response is received successfully.
+
+                if(response.isSuccessful){
+                    // If the response is successful, parse the
+                    // response body to a DataModel object.
+                    val winner: CombatDataModel = response.body() as CombatDataModel
+
+                    // Call the callback function with the DataModel
+                    // object as a parameter.
+                    callback(winner)
+                }
+            }
+        })
+    }
+
+    fun getBattleWinner(context: Context, playerDigi: String, playerStage: Int, opponentDigi: String, opponentStage: Int, callback: (BattleDataModel) -> Unit) {
+
+        // Create a Retrofit instance with the base URL and
+        // a GsonConverterFactory for parsing the response.
+        val retrofit: Retrofit = Retrofit.Builder().baseUrl("http://battle.io-void.com:8080/").addConverterFactory(
+            GsonConverterFactory.create()).build()
+
+        // Create an ApiService instance from the Retrofit instance.
+        val service: BattleService = retrofit.create<BattleService>(BattleService::class.java)
+
+        // Call the getwinner() method of the ApiService
+        // to make an API request.
+        val call: Call<BattleDataModel> = service.getwinner(playerDigi, playerStage, opponentDigi, opponentStage)
+
+        // Use the enqueue() method of the Call object to
+        // make an asynchronous API request.
+        call.enqueue(object : Callback<BattleDataModel> {
+            // This is an anonymous inner class that implements the Callback interface.
+
+            override fun onFailure(call: Call<BattleDataModel>, t: Throwable) {
+                // This method is called when the API request fails.
+                Toast.makeText(context, "Request Fail", Toast.LENGTH_SHORT).show()
+            }
+
+            override fun onResponse(call: Call<BattleDataModel>, response: Response<BattleDataModel>) {
+                // This method is called when the API response is received successfully.
+
+                if(response.isSuccessful){
+                    // If the response is successful, parse the
+                    // response body to a DataModel object.
+                    val winner: BattleDataModel = response.body() as BattleDataModel
+
+                    // Call the callback function with the DataModel
+                    // object as a parameter.
+                    callback(winner)
+                }
+            }
+        })
+    }
+     */
+
+    fun getPVPWinner(context: Context, apiStage: Int, playerID: Long, playerDigi: String, playerStage: Int, critBar: Int, opponentDigi: String, opponentStage: Int, callback: (PVPDataModel) -> Unit) {
+        getPVPWinner(context, apiStage, playerID, playerDigi, playerStage, critBar, opponentDigi, opponentStage, null, callback)
+    }
+
+    fun getPVPWinner(context: Context, apiStage: Int, playerID: Long, playerDigi: String, playerStage: Int, critBar: Int, opponentDigi: String, opponentStage: Int, action: String?, callback: (PVPDataModel) -> Unit) {
+
+        try {
+            // Create an authenticated Retrofit instance
+            val retrofit = createAuthenticatedRetrofit(context)
+            if (retrofit == null) {
+                println("RetrofitHelper: Cannot create authenticated Retrofit - no token available")
+                Toast.makeText(context, "Authentication required. Please log in.", Toast.LENGTH_SHORT).show()
+                return
+            }
+
+            // Create an ApiService instance from the Retrofit instance.
+            val service: PVPService = retrofit.create<PVPService>(PVPService::class.java)
+
+            // Call the getwinner() method of the ApiService
+            // to make an API request.
+            val call: Call<PVPDataModel> = service.getwinner(apiStage, playerID, playerDigi, playerStage, critBar, opponentDigi, opponentStage, action)
+
+            // Use the enqueue() method of the Call object to
+            // make an asynchronous API request.
+            call.enqueue(object : Callback<PVPDataModel> {
+                // This is an anonymous inner class that implements the Callback interface.
+
+                override fun onFailure(call: Call<PVPDataModel>, t: Throwable) {
+                    // This method is called when the API request fails.
+                    println("RetrofitHelper: PVP API call failed: ${t.message}")
+                    t.printStackTrace()
+                    Toast.makeText(context, "Request Fail", Toast.LENGTH_SHORT).show()
+                }
+
+                override fun onResponse(call: Call<PVPDataModel>, response: Response<PVPDataModel>) {
+                    // This method is called when the API response is received successfully.
+                    println("RetrofitHelper: PVP API response received - Code: ${response.code()}")
+
+                    if(response.isSuccessful){
+                        // If the response is successful, parse the
+                        // response body to a DataModel object.
+                        val apiResults: PVPDataModel = response.body() as PVPDataModel
+
+                        // Call the callback function with the DataModel
+                        // object as a parameter.
+                        callback(apiResults)
+                    } else {
+                        val errorBody = response.errorBody()?.string()
+                        println("RetrofitHelper: PVP API response not successful - Code: ${response.code()}, Error: $errorBody")
+                        handleErrorResponse(context, response, errorBody ?: "Unknown error")
+                    }
+                }
+            })
+        } catch (e: Exception) {
+            println("RetrofitHelper: Exception in getPVPWinner: ${e.message}")
+            e.printStackTrace()
+            Toast.makeText(context, "Request failed: ${e.message}", Toast.LENGTH_SHORT).show()
+        }
+    }
+
+    fun authenticate(context: Context, token: String, callback: (AuthenticateResponse) -> Unit) {
+        //println("RetrofitHelper: Starting validate API call with token: $token")
+        
+        if (token.isEmpty()) {
+            println("RetrofitHelper: ERROR - Token is empty!")
+            Toast.makeText(context, "Authentication failed: Token is empty", Toast.LENGTH_SHORT).show()
+            return
+        }
+
+        try {
+            // Add logging interceptor to see the actual HTTP request
+            val loggingInterceptor = HttpLoggingInterceptor().apply {
+                level = HttpLoggingInterceptor.Level.BODY
+            }
+            val okHttpClient = OkHttpClient.Builder()
+                .addInterceptor(loggingInterceptor)
+                .build()
+            
+            val retrofit: Retrofit = Retrofit.Builder()
+                .baseUrl("http://battle.io-void.com:8080/")
+                .client(okHttpClient)
+                .addConverterFactory(GsonConverterFactory.create())
+                .build()
+
+            val service: AuthService = retrofit.create<AuthService>(AuthService::class.java)
+            val request = AuthenticateRequest(userToken = token)
+            // Use login endpoint instead of validate to get sessionToken
+            val call: Call<AuthenticateResponse> = service.login(request)
+
+            call.enqueue(object : Callback<AuthenticateResponse> {
+                override fun onFailure(call: Call<AuthenticateResponse>, t: Throwable) {
+                    println("RetrofitHelper: Validate API call failed: ${t.message}")
+                    t.printStackTrace()
+                    Toast.makeText(context, "Authentication failed: ${t.message}", Toast.LENGTH_SHORT).show()
+                }
+
+                override fun onResponse(call: Call<AuthenticateResponse>, response: Response<AuthenticateResponse>) {
+
+                    if (response.isSuccessful) {
+                        val authResponse: AuthenticateResponse? = response.body()
+                        if (authResponse != null) {
+                            callback(authResponse)
+                        } else {
+                            println("RetrofitHelper: Validation failed: Invalid response body")
+                            Toast.makeText(context, "Authentication failed: Invalid response", Toast.LENGTH_SHORT).show()
+                        }
+                    } else {
+                        val errorBody = response.errorBody()?.string()
+                        println("RetrofitHelper: Validate response not successful - Code: ${response.code()}, Error: $errorBody")
+                        Toast.makeText(context, "Authentication failed: ${response.code()}", Toast.LENGTH_SHORT).show()
+                    }
+                }
+            })
+        } catch (e: Exception) {
+            println("RetrofitHelper: Exception in validate: ${e.message}")
+            e.printStackTrace()
+            Toast.makeText(context, "Authentication failed: ${e.message}", Toast.LENGTH_SHORT).show()
+        }
+    }
+}

app/src/main/java/com/github/nacabaro/vbhelper/battle/SpriteFileManager.kt

@@ -0,0 +1,328 @@
+package com.github.nacabaro.vbhelper.battle
+
+import android.content.Context
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import java.io.FileInputStream
+
+class SpriteFileManager(private val context: Context) {
+    
+    // Get the external storage directory where files are already located
+    fun getExternalSpriteBaseDir(): File {
+        val externalDir = android.os.Environment.getExternalStorageDirectory()
+        return File(externalDir, "VBHelper/battle_sprites")
+    }
+    
+    // Get the internal storage directory for sprite files
+    private fun getInternalSpriteBaseDir(): File {
+        return File(context.filesDir, "battle_sprites")
+    }
+    
+    fun copySpriteFilesToInternalStorage() {
+        try {
+            println("Starting sprite file copy process from external storage to internal storage...")
+            
+            val externalDir = getExternalSpriteBaseDir()
+            val internalDir = getInternalSpriteBaseDir()
+            
+            // Check if external directory exists
+            if (!externalDir.exists()) {
+                println("External sprite directory does not exist: ${externalDir.absolutePath}")
+                return
+            }
+            
+            println("External sprite directory exists: ${externalDir.absolutePath}")
+            println("Copying to internal storage: ${internalDir.absolutePath}")
+            
+            // Create internal directory if it doesn't exist
+            if (!internalDir.exists()) {
+                val created = internalDir.mkdirs()
+                println("Created internal sprite directory: $created")
+            }
+            
+            // Copy all subdirectories from external to internal storage
+            val externalFiles = externalDir.listFiles()
+            if (externalFiles != null) {
+                println("Found ${externalFiles.size} items in external directory")
+                externalFiles.forEach { item ->
+                    val targetItem = File(internalDir, item.name)
+                    if (item.isDirectory) {
+                        println("Copying directory: ${item.name}")
+                        copyDirectory(item, targetItem)
+                    } else {
+                        println("Copying file: ${item.name}")
+                        copyFile(item, targetItem)
+                    }
+                }
+            }
+            
+            println("Sprite files copied successfully to internal storage: ${internalDir.absolutePath}")
+            
+        } catch (e: Exception) {
+            println("Error copying sprite files to internal storage: ${e.message}")
+            e.printStackTrace()
+        }
+    }
+    
+    fun copySpriteFilesToExternalStorage() {
+        try {
+            println("Starting sprite file copy process to external storage...")
+            
+            // Debug: List what's in the assets directory
+            val assetManager = context.assets
+            val battleSpritesFiles = assetManager.list("battle_sprites")
+            println("battle_sprites directory in assets contains: ${battleSpritesFiles?.joinToString(", ")}")
+            
+            val extractedAssetsFiles = assetManager.list("battle_sprites/extracted_assets")
+            println("battle_sprites/extracted_assets directory in assets contains: ${extractedAssetsFiles?.joinToString(", ")}")
+            
+            // Check specifically for extracted_atksprites in assets (now directly under battle_sprites)
+            val atkspritesInAssets = assetManager.list("battle_sprites/extracted_atksprites")
+            println("extracted_atksprites in assets contains: ${atkspritesInAssets?.size ?: 0} files")
+            if (atkspritesInAssets != null && atkspritesInAssets.isNotEmpty()) {
+                println("First few attack files in assets: ${atkspritesInAssets.take(5).joinToString(", ")}")
+            }
+            
+            // Check for extracted_battlebgs in assets (now directly under battle_sprites)
+            val battlebgsInAssets = assetManager.list("battle_sprites/extracted_battlebgs")
+            println("extracted_battlebgs in assets contains: ${battlebgsInAssets?.size ?: 0} files")
+            if (battlebgsInAssets != null && battlebgsInAssets.isNotEmpty()) {
+                println("First few battle background files in assets: ${battlebgsInAssets.take(5).joinToString(", ")}")
+            }
+            
+            // Try to list all possible subdirectories in battle_sprites
+            println("Checking all possible subdirectories in battle_sprites...")
+            battleSpritesFiles?.forEach { subdir ->
+                try {
+                    val subdirFiles = assetManager.list("battle_sprites/$subdir")
+                    println("  $subdir contains: ${subdirFiles?.size ?: 0} files")
+                    if (subdirFiles != null && subdirFiles.isNotEmpty()) {
+                        println("    First few files: ${subdirFiles.take(3).joinToString(", ")}")
+                    }
+                } catch (e: Exception) {
+                    println("  Error listing $subdir: ${e.message}")
+                }
+            }
+            
+            // Create the base directory for battle_sprites in external storage
+            val battleSpritesDir = getExternalSpriteBaseDir()
+            if (!battleSpritesDir.exists()) {
+                battleSpritesDir.mkdirs()
+                println("Created battle_sprites directory in external storage: ${battleSpritesDir.absolutePath}")
+            } else {
+                println("battle_sprites directory already exists in external storage: ${battleSpritesDir.absolutePath}")
+            }
+            
+            // Copy all subdirectories from battle_sprites assets to external storage
+            println("Copying all battle_sprites subdirectories to external storage...")
+            battleSpritesFiles?.forEach { subdir ->
+                val sourcePath = "battle_sprites/$subdir"
+                val targetDir = File(battleSpritesDir, subdir)
+                println("Copying $sourcePath to ${targetDir.absolutePath}")
+                copyAssetDirectory(sourcePath, targetDir)
+            }
+            
+            println("Sprite files copied successfully to external storage: ${battleSpritesDir.absolutePath}")
+            
+            // Verify that attack sprites were copied
+            val atkspritesDir = File(battleSpritesDir, "extracted_atksprites")
+            if (atkspritesDir.exists()) {
+                val attackFiles = atkspritesDir.listFiles()
+                println("Attack sprites directory exists with ${attackFiles?.size ?: 0} files")
+                if (attackFiles != null && attackFiles.isNotEmpty()) {
+                    println("First few attack files: ${attackFiles.take(5).map { it.name }}")
+                }
+            } else {
+                println("WARNING: extracted_atksprites directory does not exist!")
+                // List what's actually in the battle_sprites directory
+                val battleSpritesContents = battleSpritesDir.listFiles()
+                println("battle_sprites directory contains: ${battleSpritesContents?.map { it.name }?.joinToString(", ")}")
+            }
+            
+            // Verify that battle backgrounds were copied
+            val battlebgsDir = File(battleSpritesDir, "extracted_battlebgs")
+            if (battlebgsDir.exists()) {
+                val bgFiles = battlebgsDir.listFiles()
+                println("Battle backgrounds directory exists with ${bgFiles?.size ?: 0} files")
+                if (bgFiles != null && bgFiles.isNotEmpty()) {
+                    println("First few battle background files: ${bgFiles.take(5).map { it.name }}")
+                }
+            } else {
+                println("WARNING: extracted_battlebgs directory does not exist!")
+            }
+            
+        } catch (e: Exception) {
+            println("Error copying sprite files to external storage: ${e.message}")
+            e.printStackTrace()
+        }
+    }
+    
+    private fun copyAssetDirectory(assetPath: String, targetDir: File) {
+        try {
+            val assetManager = context.assets
+            val files = assetManager.list(assetPath) ?: return
+            
+            println("Copying asset directory: $assetPath (${files.size} items)")
+            println("Files found: ${files.joinToString(", ")}")
+            
+            for (file in files) {
+                val assetFilePath = if (assetPath.isEmpty()) file else "$assetPath/$file"
+                val targetFile = File(targetDir, file)
+                
+                // Create subdirectories if needed
+                if (targetFile.parentFile != null && !targetFile.parentFile!!.exists()) {
+                    targetFile.parentFile!!.mkdirs()
+                }
+                
+                // Check if it's a directory by trying to list its contents
+                try {
+                    val subFiles = assetManager.list(assetFilePath)
+                    if (subFiles != null && subFiles.isNotEmpty()) {
+                        // It's a directory, create it and copy contents
+                        println("Copying subdirectory: $assetFilePath (${subFiles.size} files)")
+                        if (!targetFile.exists()) {
+                            targetFile.mkdirs()
+                        }
+                        copyAssetDirectory(assetFilePath, targetFile)
+                    } else {
+                        // It's a file, copy it
+                        copyAssetFile(assetFilePath, targetFile)
+                    }
+                } catch (e: Exception) {
+                    // If we can't list contents, it's probably a file
+                    println("Treating $assetFilePath as file (could not list contents)")
+                    copyAssetFile(assetFilePath, targetFile)
+                }
+            }
+            
+            // Special handling for extracted_atksprites - try to copy it directly if it wasn't found
+            if (assetPath == "battle_sprites/extracted_assets") {
+                println("Special handling: Checking for extracted_atksprites directory...")
+                try {
+                    val atkspritesFiles = assetManager.list("battle_sprites/extracted_assets/extracted_atksprites")
+                    if (atkspritesFiles != null && atkspritesFiles.isNotEmpty()) {
+                        println("Found extracted_atksprites with ${atkspritesFiles.size} files")
+                        val atkspritesDir = File(targetDir, "extracted_atksprites")
+                        if (!atkspritesDir.exists()) {
+                            atkspritesDir.mkdirs()
+                        }
+                        copyAssetDirectory("battle_sprites/extracted_assets/extracted_atksprites", atkspritesDir)
+                    } else {
+                        println("extracted_atksprites directory not found in assets")
+                    }
+                } catch (e: Exception) {
+                    println("Error checking extracted_atksprites: ${e.message}")
+                }
+            }
+            
+        } catch (e: Exception) {
+            println("Error copying asset directory $assetPath: ${e.message}")
+            e.printStackTrace()
+        }
+    }
+    
+    private fun copyDirectory(sourceDir: File, targetDir: File) {
+        if (!targetDir.exists()) {
+            targetDir.mkdirs()
+        }
+        
+        val files = sourceDir.listFiles()
+        if (files != null) {
+            files.forEach { file ->
+                val targetFile = File(targetDir, file.name)
+                if (file.isDirectory) {
+                    copyDirectory(file, targetFile)
+                } else {
+                    copyFile(file, targetFile)
+                }
+            }
+        }
+    }
+    
+    private fun copyFile(sourceFile: File, targetFile: File) {
+        try {
+            val inputStream = FileInputStream(sourceFile)
+            val outputStream = FileOutputStream(targetFile)
+            
+            inputStream.copyTo(outputStream)
+            inputStream.close()
+            outputStream.close()
+            
+            println("Copied: ${sourceFile.name} -> ${targetFile.absolutePath}")
+        } catch (e: IOException) {
+            println("Error copying file ${sourceFile.name}: ${e.message}")
+        }
+    }
+    
+    private fun copyAssetFile(assetPath: String, targetFile: File) {
+        try {
+            val inputStream = context.assets.open(assetPath)
+            val outputStream = FileOutputStream(targetFile)
+            
+            inputStream.copyTo(outputStream)
+            inputStream.close()
+            outputStream.close()
+            
+            println("Copied: $assetPath -> ${targetFile.absolutePath}")
+        } catch (e: IOException) {
+            println("Error copying asset file $assetPath: ${e.message}")
+        }
+    }
+    
+    fun checkSpriteFilesExist(): Boolean {
+        val battleSpritesDir = getExternalSpriteBaseDir()
+        val extractedAssetsDir = File(battleSpritesDir, "extracted_assets")
+        val extractedStatsDir = File(battleSpritesDir, "extracted_digimon_stats")
+        val atkspritesDir = File(battleSpritesDir, "extracted_atksprites")
+        val battlebgsDir = File(battleSpritesDir, "extracted_battlebgs")
+        
+        val battleSpritesExist = battleSpritesDir.exists() && battleSpritesDir.listFiles()?.isNotEmpty() == true
+        val assetsExist = extractedAssetsDir.exists() && extractedAssetsDir.listFiles()?.isNotEmpty() == true
+        val statsExist = extractedStatsDir.exists() && extractedStatsDir.listFiles()?.isNotEmpty() == true
+        val atkspritesExist = atkspritesDir.exists() && atkspritesDir.listFiles()?.isNotEmpty() == true
+        val battlebgsExist = battlebgsDir.exists() && battlebgsDir.listFiles()?.isNotEmpty() == true
+
+        /*
+        println("Checking sprite files exist in external storage:")
+        println("  battle_sprites exists: $battleSpritesExist")
+        println("  extracted_assets exists: $assetsExist")
+        println("  extracted_digimon_stats exists: $statsExist")
+        println("  extracted_atksprites exists: $atkspritesExist")
+        println("  extracted_battlebgs exists: $battlebgsExist")
+        */
+        
+        return battleSpritesExist && assetsExist && statsExist && atkspritesExist && battlebgsExist
+    }
+    
+    fun clearSpriteFiles() {
+        try {
+            val battleSpritesDir = getInternalSpriteBaseDir()
+            
+            if (battleSpritesDir.exists()) {
+                deleteDirectory(battleSpritesDir)
+                println("Cleared battle_sprites directory from internal storage")
+            }
+            
+        } catch (e: Exception) {
+            println("Error clearing sprite files: ${e.message}")
+            e.printStackTrace()
+        }
+    }
+    
+    private fun deleteDirectory(directory: File) {
+        if (directory.exists()) {
+            val files = directory.listFiles()
+            if (files != null) {
+                for (file in files) {
+                    if (file.isDirectory) {
+                        deleteDirectory(file)
+                    } else {
+                        file.delete()
+                    }
+                }
+            }
+            directory.delete()
+        }
+    }
+} 

app/src/main/java/com/github/nacabaro/vbhelper/battle/SpriteImage.kt

@@ -0,0 +1,38 @@
+package com.github.nacabaro.vbhelper.battle
+
+import androidx.compose.foundation.Image
+import androidx.compose.runtime.*
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalContext
+
+@Composable
+fun SpriteImage(
+    characterId: String,
+    frameNumber: Int,
+    modifier: Modifier = Modifier,
+    contentScale: ContentScale = ContentScale.Fit
+) {
+    val context = LocalContext.current
+    val spriteManager = remember { IndividualSpriteManager(context) }
+    
+    var bitmap by remember { mutableStateOf<android.graphics.Bitmap?>(null) }
+    
+    LaunchedEffect(characterId, frameNumber) {
+        println("Loading sprite frame: $frameNumber for character: $characterId")
+        bitmap = spriteManager.loadSpriteFrame(characterId, frameNumber)
+        if (bitmap == null) {
+            println("Failed to load sprite frame: $frameNumber for character: $characterId")
+        }
+    }
+    
+    bitmap?.let { bmp ->
+        Image(
+            bitmap = bmp.asImageBitmap(),
+            contentDescription = "Sprite: $characterId frame $frameNumber",
+            modifier = modifier,
+            contentScale = contentScale
+        )
+    }
+}

app/src/main/java/com/github/nacabaro/vbhelper/components/AttackSpriteImage.kt

@@ -0,0 +1,45 @@
+package com.github.nacabaro.vbhelper.battle
+
+import android.graphics.Bitmap
+import androidx.compose.foundation.Image
+import androidx.compose.runtime.*
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalContext
+import com.github.nacabaro.vbhelper.battle.AttackSpriteManager
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+@Composable
+fun AttackSpriteImage(
+    characterId: String,
+    isLarge: Boolean = false,
+    modifier: Modifier = Modifier,
+    contentScale: ContentScale = ContentScale.Fit
+) {
+    var bitmap by remember { mutableStateOf<Bitmap?>(null) }
+    val coroutineScope = rememberCoroutineScope()
+    val context = LocalContext.current
+    
+    LaunchedEffect(characterId, isLarge) {
+        //println("AttackSpriteImage: Loading attack sprite for characterId=$characterId, isLarge=$isLarge")
+        coroutineScope.launch {
+            val attackSpriteManager = AttackSpriteManager(context)
+            val loadedBitmap = withContext(Dispatchers.IO) {
+                attackSpriteManager.getAttackSprite(characterId, isLarge)
+            }
+            bitmap = loadedBitmap
+        }
+    }
+    
+    bitmap?.let { bmp ->
+        Image(
+            bitmap = bmp.asImageBitmap(),
+            contentDescription = "Attack Sprite",
+            modifier = modifier,
+            contentScale = contentScale
+        )
+    }
+} 

app/src/main/java/com/github/nacabaro/vbhelper/components/CharacterEntry.kt

@@ -1,16 +1,19 @@
 package com.github.nacabaro.vbhelper.components
 
-import android.util.Log
 import android.widget.Toast
 import androidx.compose.foundation.Image
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.aspectRatio
+import androidx.compose.foundation.layout.fillMaxHeight
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.material3.Card
+import androidx.compose.material3.CardColors
+import androidx.compose.material3.CardDefaults
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
@@ -18,58 +21,91 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.ColorFilter
 import androidx.compose.ui.graphics.FilterQuality
 import androidx.compose.ui.graphics.asImageBitmap
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
 import com.github.nacabaro.vbhelper.utils.BitmapData
 import com.github.nacabaro.vbhelper.utils.getBitmap
 import androidx.compose.ui.graphics.Shape
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.TextUnit
+import com.github.cfogrady.vbnfc.vb.SpecialMission
+import com.github.nacabaro.vbhelper.R
+import com.github.nacabaro.vbhelper.domain.device_data.SpecialMissions
 import com.github.nacabaro.vbhelper.utils.getObscuredBitmap
-import java.nio.ByteBuffer
+import androidx.compose.ui.res.stringResource
+
 
 @Composable
 fun CharacterEntry(
     icon: BitmapData,
-    obscure: Boolean = false,
     modifier: Modifier = Modifier,
+    cardIcon: BitmapData? = null,
+    obscure: Boolean = false,
+    disabled: Boolean = false,
     shape: Shape = MaterialTheme.shapes.medium,
-    multiplier: Int = 3,
+    multiplier: Int = 4,
+    cardColors: CardColors = CardDefaults.cardColors(
+        containerColor = MaterialTheme.colorScheme.surfaceContainerHighest
+    ),
     onClick: () -> Unit = {  }
 ) {
     val bitmap = remember (icon.bitmap) {
         if(obscure) icon.getObscuredBitmap() else icon.getBitmap()
     }
+    val iconSizeMultiplier = 3
     val imageBitmap = remember(bitmap) { bitmap.asImageBitmap() }
     val density: Float = LocalContext.current.resources.displayMetrics.density
     val dpSize = (icon.width * multiplier / density).dp
 
     Card(
         shape = shape,
-        onClick = onClick,
+        onClick = when (disabled) {
+            true -> { {} }
+            false -> onClick
+        },
         modifier = modifier
             .aspectRatio(1f)
-            .padding(8.dp)
+            .padding(8.dp),
+        colors = cardColors
     ) {
         Box(
             contentAlignment = Alignment.BottomCenter,
             modifier = Modifier
                 .fillMaxSize()
-                .padding(16.dp)
+                .padding(4.dp)
         ) {
             Image(
                 bitmap = imageBitmap,
                 contentDescription = "Icon",
                 filterQuality = FilterQuality.None,
+                colorFilter = when (obscure) {
+                    true -> ColorFilter.tint(color = MaterialTheme.colorScheme.secondary)
+                    false -> null
+                },
                 modifier = Modifier
                     .size(dpSize)
+                    .align(Alignment.BottomCenter)
             )
+
+            if (cardIcon != null) {
+                val bitmap = remember (icon.bitmap) { cardIcon.getBitmap() }
+                val iconBitmap = remember(bitmap) { bitmap.asImageBitmap() }
+                val dpSize = (icon.width * iconSizeMultiplier /density).dp
+
+                Image(
+                    bitmap = iconBitmap,
+                    contentDescription = "Card icon",
+                    filterQuality = FilterQuality.None,
+                    modifier = Modifier
+                        .size(dpSize)
+                        .align(Alignment.BottomEnd)
+                        .padding(8.dp)
+                )
+            }
         }
     }
 }
@@ -79,8 +115,6 @@ fun ItemDisplay(
     icon: Int,
     textValue: String,
     modifier: Modifier = Modifier,
-    iconSize: Dp = 48.dp,
-    textSize: TextUnit = 24.sp,
     definition: String = "",
 ) {
     val context = LocalContext.current
@@ -101,16 +135,128 @@ fun ItemDisplay(
                 painter = painterResource(icon),
                 contentDescription = "Vitals",
                 modifier = Modifier
+                    .fillMaxSize(0.5f)
                     .padding(8.dp)
-                    .size(iconSize)
             )
             Text(
                 text = textValue,
                 textAlign = TextAlign.Center,
-                fontSize = textSize,
                 fontFamily = MaterialTheme.typography.titleLarge.fontFamily,
-                fontWeight = FontWeight.Bold
+                fontWeight = FontWeight.Bold,
             )
         }
     }
+}
+
+@Composable
+fun SpecialMissionsEntry(
+    specialMission: SpecialMissions,
+    modifier: Modifier = Modifier,
+    onClickMission: (Long) -> Unit = {  },
+    onClickCollect: (Long) -> Unit = {  }
+) {
+    val textValue = when (specialMission.missionType) {
+        SpecialMission.Type.NONE -> stringResource(R.string.special_mission_none)
+        SpecialMission.Type.STEPS -> stringResource(
+            R.string.special_mission_steps,
+            specialMission.goal
+        )
+        SpecialMission.Type.BATTLES -> stringResource(
+            R.string.special_mission_battles,
+            specialMission.goal
+        )
+        SpecialMission.Type.WINS -> stringResource(
+            R.string.special_mission_wins,
+            specialMission.goal
+        )
+        SpecialMission.Type.VITALS -> stringResource(
+            R.string.special_mission_vitals,
+            specialMission.goal
+        )
+    }
+
+    val progress = if (specialMission.status == SpecialMission.Status.COMPLETED) {
+        specialMission.goal
+    } else {
+        specialMission.progress
+    }
+
+    val completion = when (specialMission.missionType) {
+        SpecialMission.Type.NONE -> ""
+        SpecialMission.Type.STEPS -> stringResource(
+            R.string.special_mission_steps_progress,
+            progress
+        )
+        SpecialMission.Type.BATTLES -> stringResource(
+            R.string.special_mission_battles_progress,
+            progress
+        )
+        SpecialMission.Type.WINS -> stringResource(
+            R.string.special_mission_wins_progress,
+            progress
+        )
+        SpecialMission.Type.VITALS -> stringResource(
+            R.string.special_mission_vitals_progress,
+            progress
+        )
+    }
+
+    val icon = when (specialMission.missionType) {
+        SpecialMission.Type.NONE -> R.drawable.baseline_free_24
+        SpecialMission.Type.STEPS -> R.drawable.baseline_agility_24
+        SpecialMission.Type.BATTLES -> R.drawable.baseline_swords_24
+        SpecialMission.Type.WINS -> R.drawable.baseline_trophy_24
+        SpecialMission.Type.VITALS -> R.drawable.baseline_vitals_24
+    }
+
+    val color = when (specialMission.status)
+    {
+        SpecialMission.Status.IN_PROGRESS -> MaterialTheme.colorScheme.secondary
+        SpecialMission.Status.COMPLETED -> MaterialTheme.colorScheme.primary
+        SpecialMission.Status.FAILED -> MaterialTheme.colorScheme.error
+        else -> MaterialTheme.colorScheme.surfaceContainerHighest
+    }
+
+    Card(
+        modifier = modifier,
+        shape = androidx.compose.material.MaterialTheme.shapes.small,
+        onClick = if (specialMission.status == SpecialMission.Status.COMPLETED) {
+            { onClickCollect(specialMission.id) }
+        } else if (specialMission.status == SpecialMission.Status.UNAVAILABLE) {
+            { }
+        } else {
+            { onClickMission(specialMission.id) }
+        },
+        colors = CardDefaults.cardColors(
+            containerColor = color
+        )
+
+    ) {
+        Row (
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(8.dp),
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(16.dp)
+        ) {
+            Icon(
+                painter = painterResource(icon),
+                contentDescription = stringResource(R.string.special_mission_icon_content_description),
+                modifier = Modifier
+                    .fillMaxHeight()
+                    .padding(16.dp)
+            )
+            Column {
+                Text(
+                    text = textValue,
+                    fontFamily = MaterialTheme.typography.titleLarge.fontFamily,
+                    fontWeight = FontWeight.Bold,
+                )
+                Text(
+                    text = completion,
+                    fontFamily = MaterialTheme.typography.titleSmall.fontFamily,
+                )
+            }
+        }
+    }
 }

app/src/main/java/com/github/nacabaro/vbhelper/components/TopBanner.kt

@@ -23,7 +23,9 @@ fun TopBanner(
     modifier: Modifier = Modifier,
     onGearClick: (() -> Unit)? = null,
     onBackClick: (() -> Unit)? = null,
-    onScanClick: (() -> Unit)? = null
+    onScanClick: (() -> Unit)? = null,
+    onAdventureClick: (() -> Unit)? = null,
+    onModifyClick: (() -> Unit)? = null
 ) {
     Box( // Use Box to overlay elements
         modifier = modifier
@@ -36,29 +38,51 @@ fun TopBanner(
             textAlign = TextAlign.Center,
             fontSize = 24.sp,
             modifier = Modifier
-                .align(Alignment.Center) // Center the text
+                .align(Alignment.Center)
         )
          if (onGearClick != null) {
             IconButton(
                 onClick = onGearClick,
                 modifier = Modifier
-                    .align(Alignment.CenterEnd) // Place gear icon at the end
+                    .align(Alignment.CenterEnd)
             ) {
                 Icon(
-                    painter = painterResource(R.drawable.baseline_settings_24), // Use a gear icon
+                    painter = painterResource(R.drawable.baseline_settings_24),
                     contentDescription = "Settings"
                 )
             }
-        }
+        } else if (onAdventureClick != null) {
+            IconButton(
+                onClick = onAdventureClick,
+                modifier = Modifier
+                    .align(Alignment.CenterEnd)
+            ) {
+                Icon(
+                    painter = painterResource(R.drawable.baseline_fort_24),
+                    contentDescription = "Adventure"
+                )
+            }
+        } else if (onModifyClick != null) {
+             IconButton(
+                 onClick = onModifyClick,
+                 modifier = Modifier
+                     .align(Alignment.CenterEnd)
+             ) {
+                 Icon(
+                     painter = painterResource(R.drawable.baseline_edit_24),
+                     contentDescription = "Adventure"
+                 )
+             }
+         }
 
         if (onScanClick != null) {
             IconButton(
                 onClick = onScanClick,
                 modifier = Modifier
-                    .align(Alignment.CenterStart) // Place gear icon at the end
+                    .align(Alignment.CenterStart)
             ) {
                 Icon(
-                    painter = painterResource(R.drawable.baseline_nfc_24), // Use a gear icon
+                    painter = painterResource(R.drawable.baseline_nfc_24),
                     contentDescription = "Scan"
                 )
             }
@@ -66,10 +90,10 @@ fun TopBanner(
             IconButton(
                 onClick = onBackClick,
                 modifier = Modifier
-                    .align(Alignment.CenterStart) // Place gear icon at the end
+                    .align(Alignment.CenterStart)
             ) {
                 Icon(
-                    painter = painterResource(R.drawable.baseline_arrow_back_24), // Use a gear icon
+                    painter = painterResource(R.drawable.baseline_arrow_back_24),
                     contentDescription = "Settings"
                 )
             }

app/src/main/java/com/github/nacabaro/vbhelper/daos/AdventureDao.kt

@@ -0,0 +1,48 @@
+package com.github.nacabaro.vbhelper.daos
+
+import androidx.room.Dao
+import androidx.room.Query
+import com.github.nacabaro.vbhelper.dtos.CharacterDtos
+import kotlinx.coroutines.flow.Flow
+
+
+@Dao
+interface AdventureDao {
+    @Query("""
+        INSERT INTO Adventure (characterId, originalDuration, finishesAdventure)
+        VALUES (:characterId, :originalDuration, strftime('%s', 'now') + :timeInSeconds)
+    """)
+    fun insertNewAdventure(characterId: Long, originalDuration: Long, timeInSeconds: Long)
+
+    @Query("""
+        SELECT COUNT(*) FROM Adventure
+    """)
+    fun getAdventureCount(): Int
+
+    @Query(
+        """
+        SELECT
+            uc.*,
+            c.stage,
+            c.attribute,
+            s.spriteIdle1 AS spriteIdle,
+            s.width AS spriteWidth,
+            s.height AS spriteHeight,
+            d.isBEm as isBemCard,
+            a.finishesAdventure AS finishesAdventure,
+            a.originalDuration AS originalTimeInMinutes
+        FROM UserCharacter uc
+        JOIN CardCharacter c ON uc.charId = c.id
+        JOIN Sprite s ON s.id = c.spriteId
+        JOIN Card d ON c.cardId = d.id
+        JOIN Adventure a ON uc.id = a.characterId
+    """
+    )
+    fun getAdventureCharacters(): Flow<List<CharacterDtos.AdventureCharacterWithSprites>>
+
+    @Query("""
+        DELETE FROM Adventure
+        WHERE characterId = :characterId
+    """)
+    suspend fun deleteAdventure(characterId: Long)
+}

app/src/main/java/com/github/nacabaro/vbhelper/daos/CardAdventureDao.kt

@@ -0,0 +1,59 @@
+package com.github.nacabaro.vbhelper.daos
+
+import androidx.room.Dao
+import androidx.room.Query
+import com.github.nacabaro.vbhelper.dtos.CardDtos
+import kotlinx.coroutines.flow.Flow
+
+@Dao
+interface CardAdventureDao {
+    @Query("""
+        INSERT INTO 
+            CardAdventure (cardId, characterId, steps, bossAp, bossHp, bossDp, bossBp)
+        SELECT
+            :cardId,
+            cc.id,
+            :steps,
+            :bossAp,
+            :bossHp,
+            :bossDp,
+            :bossBp
+        FROM
+            CardCharacter cc
+        WHERE
+            cc.charaIndex = :characterId AND
+            cc.cardId = :cardId
+    """)
+    suspend fun insertNewAdventure(
+        cardId: Long,
+        characterId: Int,
+        steps: Int,
+        bossAp: Int,
+        bossHp: Int,
+        bossDp: Int,
+        bossBp: Int?
+    )
+
+    @Query("""
+        SELECT
+            cc.nameSprite as characterName,
+            cc.nameWidth as characterNameWidth,
+            cc.nameHeight as characterNameHeight,
+            s.spriteIdle1 as characterIdleSprite,
+            s.width as characterIdleSpriteWidth,
+            s.height as characterIdleSpriteHeight,
+            ca.bossAp as characterAp,
+            ca.bossBp as characterBp,
+            ca.bossDp as characterDp,
+            ca.bossHp as characterHp,
+            ca.steps as steps
+        FROM CardCharacter cc
+        JOIN Sprite s ON cc.spriteId = s.id
+        JOIN CardAdventure ca ON cc.id = ca.characterId
+        WHERE
+            cc.cardId = :cardId
+    """)
+    fun getAdventureForCard(
+        cardId: Long
+    ): Flow<List<CardDtos.CardAdventureWithSprites>>
+}

app/src/main/java/com/github/nacabaro/vbhelper/daos/CardDao.kt

@@ -0,0 +1,49 @@
+package com.github.nacabaro.vbhelper.daos
+
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+import com.github.nacabaro.vbhelper.domain.card.Card
+import com.github.nacabaro.vbhelper.dtos.CardDtos
+import kotlinx.coroutines.flow.Flow
+
+@Dao
+interface CardDao {
+    @Insert(onConflict = OnConflictStrategy.IGNORE)
+    suspend fun insertNewCard(card: Card): Long
+
+    @Query("SELECT * FROM Card WHERE cardId = :id")
+    fun getCardByCardId(id: Int): List<Card>
+
+    @Query("SELECT * FROM Card WHERE id = :id")
+    fun getCardById(id: Long): Card?
+
+    @Query(
+        """
+        SELECT ca.* 
+        FROM Card ca
+        JOIN CardCharacter ch ON ca.id = ch.cardId
+        JOIN UserCharacter uc ON ch.id = uc.charId
+        WHERE uc.id = :id
+    """
+    )
+    fun getCardByCharacterId(id: Long): Flow<Card>
+
+    @Query("UPDATE Card SET name = :newName WHERE id = :id")
+    suspend fun renameCard(id: Int, newName: String)
+
+    @Query("DELETE FROM Card WHERE id = :id")
+    suspend fun deleteCard(id: Long)
+
+    @Query("""
+        SELECT 
+            c.logo as cardIcon,
+            c.logoWidth as cardIconWidth,
+            c.logoHeight as cardIconHeight
+        FROM Card c
+        JOIN CardCharacter cc ON cc.cardId = c.id
+        WHERE cc.id = :charaId
+    """)
+    fun getCardIconByCharaId(charaId: Long): Flow<CardDtos.CardIcon>
+}

app/src/main/java/com/github/nacabaro/vbhelper/daos/CardFusionsDao.kt

@@ -0,0 +1,48 @@
+package com.github.nacabaro.vbhelper.daos
+
+import androidx.room.Dao
+import androidx.room.Query
+import com.github.cfogrady.vbnfc.data.NfcCharacter
+import com.github.nacabaro.vbhelper.dtos.CharacterDtos
+import kotlinx.coroutines.flow.Flow
+
+@Dao
+interface CardFusionsDao {
+    @Query("""
+        INSERT INTO
+            CardFusions (
+                fromCharaId,
+                attribute,
+                toCharaId
+            )
+        SELECT
+            (SELECT id FROM CardCharacter WHERE cardId = :cardId AND charaIndex = :fromCharaId),
+            :attribute,
+            (SELECT id FROM CardCharacter WHERE cardId = :cardId AND charaIndex = :toCharaId)
+    """)
+    suspend fun insertNewFusion(
+        cardId: Long,
+        fromCharaId: Int,
+        attribute: NfcCharacter.Attribute,
+        toCharaId: Int
+    )
+
+    @Query("""
+        SELECT 
+            cf.toCharaId as charaId,
+            cf.fromCharaId as fromCharaId,
+            s.spriteIdle1 as spriteIdle,
+            cc.attribute as attribute,
+            s.width as spriteWidth,
+            s.height as spriteHeight,
+            d.discoveredOn as discoveredOn,
+            cf.attribute as fusionAttribute
+        FROM CardFusions cf
+        JOIN CardCharacter cc ON cc.id = cf.toCharaId
+        JOIN Sprite s ON s.id = cc.id
+        LEFT JOIN Dex d ON d.id = cc.id
+        WHERE cf.fromCharaId = :charaId
+        ORDER BY cc.charaIndex
+    """)
+    fun getFusionsForCharacter(charaId: Long): Flow<List<CharacterDtos.FusionsWithSpritesAndObtained>>
+}

app/src/main/java/com/github/nacabaro/vbhelper/daos/CardProgressDao.kt

@@ -0,0 +1,29 @@
+package com.github.nacabaro.vbhelper.daos
+
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.Query
+import com.github.nacabaro.vbhelper.domain.card.CardProgress
+import com.github.nacabaro.vbhelper.dtos.CharacterDtos
+import kotlinx.coroutines.flow.Flow
+
+@Dao
+interface CardProgressDao {
+    @Query("""
+        UPDATE CardProgress 
+        SET 
+            currentStage = :currentStage, 
+            unlocked = :unlocked
+        WHERE cardId = :cardId AND
+            currentStage < :currentStage
+    """)
+    fun updateCardProgress(currentStage: Int, cardId: Long, unlocked: Boolean)
+
+    @Query(
+        "SELECT currentStage FROM CardProgress WHERE cardId = :cardId"
+    )
+    fun getCardProgress(cardId: Long): Flow<Int>
+
+    @Insert
+    fun insertCardProgress(cardProgress: CardProgress)
+}

app/src/main/java/com/github/nacabaro/vbhelper/daos/CharacterDao.kt

@@ -3,49 +3,88 @@ package com.github.nacabaro.vbhelper.daos
 import androidx.room.Dao
 import androidx.room.Insert
 import androidx.room.Query
-import com.github.nacabaro.vbhelper.domain.characters.Character
-import com.github.nacabaro.vbhelper.domain.Sprites
+import com.github.nacabaro.vbhelper.domain.card.CardCharacter
+import com.github.nacabaro.vbhelper.domain.characters.Sprite
 import com.github.nacabaro.vbhelper.dtos.CharacterDtos
+import kotlinx.coroutines.flow.Flow
 
 @Dao
 interface CharacterDao {
     @Insert
-    suspend fun insertCharacter(vararg characterData: Character)
+    suspend fun insertCharacter(vararg characterData: CardCharacter)
 
-    @Query("SELECT * FROM Character")
-    suspend fun getAllCharacters(): List<Character>
-
-    @Query("SELECT * FROM Character WHERE dimId = :dimId")
-    suspend fun getCharacterByDimId(dimId: Int): List<Character>
-
-    @Query("SELECT * FROM Character WHERE monIndex = :monIndex AND dimId = :dimId LIMIT 1")
-    fun getCharacterByMonIndex(monIndex: Int, dimId: Long): Character
+    @Query("SELECT * FROM CardCharacter WHERE charaIndex = :monIndex AND cardId = :dimId LIMIT 1")
+    fun getCharacterByMonIndex(monIndex: Int, dimId: Long): CardCharacter
 
     @Insert
-    suspend fun insertSprite(vararg sprite: Sprites)
-
-    @Query("SELECT * FROM Sprites")
-    suspend fun getAllSprites(): List<Sprites>
+    suspend fun insertSprite(vararg sprite: Sprite)
 
     @Query(
         """
         SELECT 
-            d.dimId as cardId,
-            c.monIndex as charId
-        FROM Character c
+            d.cardId as cardId,
+            c.charaIndex as charId,
+            c.stage as stage,
+            c.attribute as attribute,
+            cp.currentStage as currentStage
+        FROM CardCharacter c
         JOIN UserCharacter uc ON c.id = uc.charId
-        JOIN Card d ON c.dimId = d.id
-        WHERE uc.id = :charId
+        JOIN Card d ON c.cardId = d.id
+        JOIN CardProgress cp ON d.id = cp.cardId
+        WHERE c.id = :charId
     """
     )
-    suspend fun getCharacterInfo(charId: Long): CharacterDtos.DiMInfo
+    suspend fun getCharacterInfo(charId: Long): CharacterDtos.CardCharacterInfo
 
-    @Query("""
-        INSERT INTO TransformationHistory(monId, stageId, transformationDate)
-        VALUES 
-            (:monId, 
-            (SELECT id FROM Character WHERE monIndex = :stage AND dimId = :dimId),
-            :transformationDate)
-    """)
-    fun insertTransformation(monId: Long, stage: Int, dimId: Long, transformationDate: Long)
+    @Query(
+        """
+        INSERT INTO PossibleTransformations (charaId, requiredVitals, requiredTrophies, requiredBattles, requiredWinRate, changeTimerHours, requiredAdventureLevelCompleted, toCharaId)
+        SELECT
+            (SELECT id FROM CardCharacter WHERE charaIndex = :fromChraraIndex AND cardId = :cardId),
+            :requiredVitals,
+            :requiredTrophies,
+            :requiredBattles,
+            :requiredWinRate,
+            :changeTimerHours,
+            :requiredAdventureLevelCompleted,
+            (SELECT id FROM CardCharacter WHERE charaIndex = :toChraraIndex AND cardId = :cardId)
+    """
+    )
+    suspend fun insertPossibleTransformation(
+        fromChraraIndex: Int,
+        toChraraIndex: Int,
+        cardId: Long,
+        requiredVitals: Int,
+        requiredTrophies: Int,
+        requiredBattles: Int,
+        changeTimerHours: Int,
+        requiredWinRate: Int,
+        requiredAdventureLevelCompleted: Int
+    )
+
+    @Query(
+        """
+        SELECT 
+            pt.charaId as fromCharaId,
+            pt.toCharaId as charaId,
+            s.spriteIdle1 as spriteIdle,
+            s.width as spriteWidth,
+            s.height as spriteHeight,
+            d.discoveredOn as discoveredOn,
+            pt.requiredTrophies as requiredTrophies,
+            pt.requiredVitals as requiredVitals,
+            pt.requiredBattles as requiredBattles,
+            pt.requiredWinRate as requiredWinRate,
+            pt.changeTimerHours as changeTimerHours,
+            pt.requiredAdventureLevelCompleted as requiredAdventureLevelCompleted
+        FROM
+            PossibleTransformations pt
+        JOIN CardCharacter c on pt.toCharaId = c.id
+        JOIN Sprite s ON s.id = c.spriteId
+        LEFT JOIN Dex d ON d.id = pt.toCharaId
+        WHERE
+            pt.charaId = :characterId
+    """
+    )
+    fun getEvolutionRequirementsForCard(characterId: Long): Flow<List<CharacterDtos.EvolutionRequirementsWithSpritesAndObtained>>
 }

app/src/main/java/com/github/nacabaro/vbhelper/daos/DexDao.kt

@@ -4,41 +4,57 @@ import androidx.room.Dao
 import androidx.room.Query
 import com.github.nacabaro.vbhelper.dtos.CardDtos
 import com.github.nacabaro.vbhelper.dtos.CharacterDtos
+import kotlinx.coroutines.flow.Flow
 
 @Dao
 interface DexDao {
-    @Query("""
+    @Query(
+        """
         INSERT OR IGNORE INTO Dex(id, discoveredOn)
         VALUES (
-            (SELECT id FROM Character WHERE monIndex = :charIndex AND dimId = :cardId), 
+            (SELECT id FROM CardCharacter WHERE charaIndex = :charIndex AND cardId = :cardId), 
             :discoveredOn
         )
-    """)
+    """
+    )
     fun insertCharacter(charIndex: Int, cardId: Long, discoveredOn: Long)
 
-    @Query("""
+    @Query(
+        """
         SELECT 
             c.id AS id,
-            c.sprite1 AS spriteIdle,
-            c.spritesWidth AS spriteWidth,
-            c.spritesHeight AS spriteHeight,
-            d.discoveredOn AS discoveredOn
-        FROM character c
+            s.spriteIdle1 AS spriteIdle,
+            s.width AS spriteWidth,
+            s.height AS spriteHeight,
+            c.nameSprite AS nameSprite,
+            c.nameWidth AS nameSpriteWidth,
+            c.nameHeight AS nameSpriteHeight,
+            d.discoveredOn AS discoveredOn,
+            c.baseHp as baseHp,
+            c.baseBp as baseBp,
+            c.baseAp as baseAp,
+            c.stage as stage,
+            c.attribute as attribute
+        FROM CardCharacter c
+        JOIN Sprite s ON c.spriteId = s.id
         LEFT JOIN dex d ON c.id = d.id
-        WHERE c.dimId = :cardId
-    """)
-    suspend fun getSingleCardProgress(cardId: Long): List<CharacterDtos.CardProgress>
+        WHERE c.cardId = :cardId
+    """
+    )
+    fun getSingleCardProgress(cardId: Long): Flow<List<CharacterDtos.CardCharaProgress>>
 
-    @Query("""
+    @Query(
+        """
         SELECT 
             c.id as cardId,
             c.name as cardName,
             c.logo as cardLogo,
             c.logoWidth as logoWidth,
             c.logoHeight as logoHeight, 
-            (SELECT COUNT(*) FROM Character cc WHERE cc.dimId = c.id) AS totalCharacters,
-            (SELECT COUNT(*) FROM Dex d JOIN Character cc ON d.id = cc.id WHERE cc.dimId = c.id AND d.discoveredOn IS NOT NULL) AS obtainedCharacters
+            (SELECT COUNT(*) FROM CardCharacter cc WHERE cc.cardId = c.id) AS totalCharacters,
+            (SELECT COUNT(*) FROM Dex d JOIN CardCharacter cc ON d.id = cc.id WHERE cc.cardId = c.id AND d.discoveredOn IS NOT NULL) AS obtainedCharacters
         FROM Card c
-    """)
-    suspend fun getCardsWithProgress(): List<CardDtos.CardProgress>
+    """
+    )
+    fun getCardsWithProgress(): Flow<List<CardDtos.CardProgress>>
 }

app/src/main/java/com/github/nacabaro/vbhelper/daos/DiMDao.kt

@@ -1,19 +0,0 @@
-package com.github.nacabaro.vbhelper.daos
-
-import androidx.room.Dao
-import androidx.room.Insert
-import androidx.room.OnConflictStrategy
-import androidx.room.Query
-import com.github.nacabaro.vbhelper.domain.characters.Card
-
-@Dao
-interface DiMDao {
-    @Insert(onConflict = OnConflictStrategy.IGNORE)
-    suspend fun insertNewDim(card: Card): Long
-
-    @Query("SELECT * FROM Card")
-    suspend fun getAllDims(): List<Card>
-
-    @Query("SELECT * FROM Card WHERE dimId = :id")
-    fun getDimById(id: Int): Card?
-}

app/src/main/java/com/github/nacabaro/vbhelper/daos/DiMProgressDao.kt

@@ -1,11 +0,0 @@
-package com.github.nacabaro.vbhelper.daos
-
-import androidx.room.Dao
-import androidx.room.Upsert
-import com.github.nacabaro.vbhelper.domain.DimProgress
-
-@Dao
-interface DiMProgressDao {
-    @Upsert
-    suspend fun updateDimProgress(vararg dimProgress: DimProgress)
-}

app/src/main/java/com/github/nacabaro/vbhelper/daos/ItemDao.kt

@@ -0,0 +1,54 @@
+package com.github.nacabaro.vbhelper.daos
+
+import androidx.room.Dao
+import androidx.room.Query
+import com.github.nacabaro.vbhelper.dtos.ItemDtos
+import kotlinx.coroutines.flow.Flow
+
+@Dao
+interface ItemDao {
+    @Query(
+        """
+        SELECT *
+        FROM Items
+        ORDER BY Items.itemIcon ASC
+    """
+    )
+    fun getAllItems(): Flow<List<ItemDtos.ItemsWithQuantities>>
+
+    @Query(
+        """
+        SELECT *
+        FROM Items
+        WHERE quantity > 0
+    """
+    )
+    fun getAllUserItems(): Flow<List<ItemDtos.ItemsWithQuantities>>
+
+    @Query(
+        """
+        SELECT *
+        FROM Items
+        WHERE Items.id = :itemId
+    """
+    )
+    suspend fun getItem(itemId: Long): ItemDtos.ItemsWithQuantities
+
+    @Query(
+        """
+        UPDATE Items
+        SET quantity = quantity - 1
+        WHERE id = :itemId
+    """
+    )
+    suspend fun useItem(itemId: Long)
+
+    @Query(
+        """
+        UPDATE Items
+        SET quantity = quantity + :itemAmount
+        WHERE id = :itemId
+    """
+    )
+    suspend fun purchaseItem(itemId: Long, itemAmount: Int)
+}

app/src/main/java/com/github/nacabaro/vbhelper/daos/SpecialMissionDao.kt

@@ -0,0 +1,24 @@
+package com.github.nacabaro.vbhelper.daos
+
+import androidx.room.Dao
+import androidx.room.Query
+import com.github.nacabaro.vbhelper.domain.device_data.SpecialMissions
+import kotlinx.coroutines.flow.Flow
+
+@Dao
+interface SpecialMissionDao {
+    @Query("""
+        UPDATE SpecialMissions SET 
+            missionType = "NONE",
+            status = "UNAVAILABLE"
+        WHERE id = :id
+    """)
+    suspend fun clearSpecialMission(id: Long)
+
+    @Query("""
+        SELECT *
+        FROM SpecialMissions
+        WHERE id = :id
+    """)
+    fun getSpecialMission(id: Long): Flow<SpecialMissions>
+}

app/src/main/java/com/github/nacabaro/vbhelper/daos/SpriteDao.kt

@@ -0,0 +1,16 @@
+package com.github.nacabaro.vbhelper.daos
+
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+import com.github.nacabaro.vbhelper.domain.characters.Sprite
+
+@Dao
+interface SpriteDao {
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    fun insertSprite(sprite: Sprite): Long
+
+    @Query("SELECT * FROM Sprite")
+    suspend fun getAllSprites(): List<Sprite>
+}

app/src/main/java/com/github/nacabaro/vbhelper/daos/UserCharacterDao.kt

@@ -4,10 +4,16 @@ import androidx.room.Dao
 import androidx.room.Insert
 import androidx.room.OnConflictStrategy
 import androidx.room.Query
+import androidx.room.Upsert
+import com.github.nacabaro.vbhelper.domain.card.CardCharacter
 import com.github.nacabaro.vbhelper.domain.device_data.UserCharacter
 import com.github.nacabaro.vbhelper.domain.device_data.BECharacterData
+import com.github.nacabaro.vbhelper.domain.device_data.SpecialMissions
 import com.github.nacabaro.vbhelper.domain.device_data.TransformationHistory
+import com.github.nacabaro.vbhelper.domain.device_data.VBCharacterData
+import com.github.nacabaro.vbhelper.domain.device_data.VitalsHistory
 import com.github.nacabaro.vbhelper.dtos.CharacterDtos
+import kotlinx.coroutines.flow.Flow
 
 @Dao
 interface UserCharacterDao {
@@ -17,60 +23,127 @@ interface UserCharacterDao {
     @Insert
     fun insertBECharacterData(characterData: BECharacterData)
 
+    @Insert
+    fun insertVBCharacterData(characterData: VBCharacterData)
+
+    @Upsert
+    fun updateCharacter(character: UserCharacter)
+
+    @Upsert
+    fun updateBECharacterData(characterData: BECharacterData)
+
     @Insert(onConflict = OnConflictStrategy.REPLACE)
     fun insertTransformationHistory(vararg transformationHistory: TransformationHistory)
 
-    @Query("""
+    @Upsert
+    fun insertSpecialMissions(vararg specialMissions: SpecialMissions)
+
+    @Query(
+        """
         SELECT 
             c.id AS id,
-            c.sprite1 AS spriteIdle,
-            c.spritesWidth AS spriteWidth,
-            c.spritesHeight AS spriteHeight,
-            c.monIndex AS monIndex, 
+            s.spriteIdle1 AS spriteIdle,
+            s.width AS spriteWidth,
+            s.height AS spriteHeight,
+            c.charaIndex AS monIndex, 
             t.transformationDate AS transformationDate
         FROM TransformationHistory t 
-        JOIN Character c ON c.id = t.stageId
+        JOIN CardCharacter c ON c.id = t.stageId
+        JOIN Sprite s ON s.id = c.spriteId
         WHERE monId = :monId
-    """)
-    fun getTransformationHistory(monId: Long): List<CharacterDtos.TransformationHistory>?
+    """
+    )
+    fun getTransformationHistory(monId: Long): Flow<List<CharacterDtos.TransformationHistory>>
 
     @Query(
         """
         SELECT
             uc.*,
-            c.sprite1 AS spriteIdle,
-            c.spritesWidth AS spriteWidth,
-            c.spritesHeight AS spriteHeight,
-            d.isBEm as isBemCard
+            c.stage,
+            c.attribute,
+            s.spriteIdle1 AS spriteIdle,
+            s.spriteIdle2 AS spriteIdle2,
+            s.width AS spriteWidth,
+            s.height AS spriteHeight,
+            c.nameSprite as nameSprite,
+            c.nameWidth as nameSpriteWidth,
+            c.nameHeight as nameSpriteHeight,
+            d.isBEm as isBemCard,
+            a.characterId = uc.id as isInAdventure,
+            uc.isActive as active
         FROM UserCharacter uc
-        JOIN Character c ON uc.charId = c.id
-        JOIN Card d ON c.dimId = d.id
+        JOIN CardCharacter c ON uc.charId = c.id
+        JOIN Card d ON  d.id = c.cardId
+        JOIN Sprite s ON s.id = c.spriteId
+        LEFT JOIN Adventure a ON a.characterId = uc.id
         """
     )
-    suspend fun getAllCharacters(): List<CharacterDtos.CharacterWithSprites>
+    fun getAllCharacters(): Flow<List<CharacterDtos.CharacterWithSprites>>
+
+    @Query(
+        """
+        SELECT
+            uc.*,
+            c.stage,
+            c.attribute,
+            s.spriteIdle1 AS spriteIdle,
+            s.spriteIdle2 AS spriteIdle2,
+            s.width AS spriteWidth,
+            s.height AS spriteHeight,
+            c.nameSprite as nameSprite,
+            c.nameWidth as nameSpriteWidth,
+            c.nameHeight as nameSpriteHeight,
+            d.isBEm as isBemCard,
+            a.characterId = uc.id as isInAdventure,
+            uc.isActive as active
+        FROM UserCharacter uc
+        JOIN CardCharacter c ON uc.charId = c.id
+        JOIN Card d ON c.cardId = d.id
+        JOIN Sprite s ON s.id = c.spriteId
+        LEFT JOIN Adventure a ON a.characterId = uc.id
+        WHERE uc.id = :id
+    """
+    )
+    suspend fun getCharacterWithSprites(id: Long): CharacterDtos.CharacterWithSprites
 
     @Query("SELECT * FROM UserCharacter WHERE id = :id")
     suspend fun getCharacter(id: Long): UserCharacter
 
     @Query("SELECT * FROM BECharacterData WHERE id = :id")
-    suspend fun getBeData(id: Long): BECharacterData
+    fun getBeData(id: Long): Flow<BECharacterData>
+
+    @Query("SELECT * FROM VBCharacterData WHERE id = :id")
+    fun getVbData(id: Long): Flow<VBCharacterData>
+
+    @Query("SELECT * FROM SpecialMissions WHERE characterId = :id")
+    fun getSpecialMissions(id: Long): Flow<List<SpecialMissions>>
 
     @Query(
         """
         SELECT
             uc.*,
-            c.sprite1 AS spriteIdle,
-            c.spritesWidth AS spriteWidth,
-            c.spritesHeight AS spriteHeight,
-            d.isBEm as isBemCard
+            c.stage,
+            c.attribute,
+            s.spriteIdle1 AS spriteIdle,
+            s.spriteIdle2 AS spriteIdle2,
+            s.width AS spriteWidth,
+            s.height AS spriteHeight,
+            c.nameSprite as nameSprite,
+            c.nameWidth as nameSpriteWidth,
+            c.nameHeight as nameSpriteHeight,
+            d.isBEm as isBemCard,
+            a.characterId as isInAdventure,
+            uc.isActive as active
         FROM UserCharacter uc
-        JOIN Character c ON uc.charId = c.id
-        JOIN Card d ON c.dimId = d.id
+        JOIN CardCharacter c ON uc.charId = c.id
+        JOIN Card d ON c.cardId = d.id
+        JOIN Sprite s ON s.id = c.spriteId
+        LEFT JOIN Adventure a ON a.characterId = uc.id
         WHERE uc.isActive = 1
         LIMIT 1
     """
     )
-    suspend fun getActiveCharacter(): CharacterDtos.CharacterWithSprites?
+    fun getActiveCharacter(): Flow<CharacterDtos.CharacterWithSprites?>
 
     @Query("DELETE FROM UserCharacter WHERE id = :id")
     fun deleteCharacterById(id: Long)
@@ -80,4 +153,85 @@ interface UserCharacterDao {
 
     @Query("UPDATE UserCharacter SET isActive = 1 WHERE id = :id")
     fun setActiveCharacter(id: Long)
+
+    @Query(
+        """
+        SELECT c.*
+        FROM CardCharacter c
+        join UserCharacter uc on c.id = uc.charId
+        where uc.id = :charId
+        LIMIT 1
+        """
+    )
+    suspend fun getCharacterInfo(charId: Long): CardCharacter
+
+
+    @Query(
+        """
+        INSERT INTO TransformationHistory(monId, stageId, transformationDate)
+        VALUES 
+            (:monId, 
+            (SELECT id FROM CardCharacter WHERE charaIndex = :stage AND cardId = :dimId),
+            :transformationDate)
+    """
+    )
+    fun insertTransformation(monId: Long, stage: Int, dimId: Long, transformationDate: Long)
+
+    @Upsert
+    fun insertVitals(vararg vitalsHistory: VitalsHistory)
+
+    @Query("""SELECT * FROM VitalsHistory WHERE charId = :charId ORDER BY id ASC""")
+    suspend fun getVitalsHistory(charId: Long): List<VitalsHistory>
+
+    @Query(
+        """
+        SELECT
+            uc.*,
+            c.stage,
+            c.attribute,
+            s.spriteIdle1 AS spriteIdle,
+            s.spriteIdle2 AS spriteIdle2,
+            s.width AS spriteWidth,
+            s.height AS spriteHeight,
+            c.nameSprite as nameSprite,
+            c.nameWidth as nameSpriteWidth,
+            c.nameHeight as nameSpriteHeight,
+            d.isBEm as isBemCard,
+            a.characterId = uc.id as isInAdventure,
+            uc.isActive as active
+        FROM UserCharacter uc
+        JOIN CardCharacter c ON uc.charId = c.id
+        JOIN Card d ON  d.id = c.cardId
+        JOIN Sprite s ON s.id = c.spriteId
+        LEFT JOIN Adventure a ON a.characterId = uc.id
+        WHERE uc.characterType = "BEDevice"
+        """
+    )
+    suspend fun getBECharacters(): List<CharacterDtos.CharacterWithSprites>
+
+    @Query(
+        """
+        SELECT
+            uc.*,
+            c.stage,
+            c.attribute,
+            s.spriteIdle1 AS spriteIdle,
+            s.spriteIdle2 AS spriteIdle2,
+            s.width AS spriteWidth,
+            s.height AS spriteHeight,
+            c.nameSprite as nameSprite,
+            c.nameWidth as nameSpriteWidth,
+            c.nameHeight as nameSpriteHeight,
+            d.isBEm as isBemCard,
+            a.characterId = uc.id as isInAdventure,
+            uc.isActive as active
+        FROM UserCharacter uc
+        JOIN CardCharacter c ON uc.charId = c.id
+        JOIN Card d ON  d.id = c.cardId
+        JOIN Sprite s ON s.id = c.spriteId
+        LEFT JOIN Adventure a ON a.characterId = uc.id
+        WHERE uc.characterType = "VBDevice"
+        """
+    )
+    suspend fun getVBDimCharacters(): List<CharacterDtos.CharacterWithSprites>
 }

app/src/main/java/com/github/nacabaro/vbhelper/database/AppDatabase.kt

@@ -2,33 +2,67 @@ package com.github.nacabaro.vbhelper.database
 
 import androidx.room.Database
 import androidx.room.RoomDatabase
+import com.github.nacabaro.vbhelper.daos.AdventureDao
+import com.github.nacabaro.vbhelper.daos.CardAdventureDao
 import com.github.nacabaro.vbhelper.daos.CharacterDao
 import com.github.nacabaro.vbhelper.daos.DexDao
-import com.github.nacabaro.vbhelper.daos.DiMDao
+import com.github.nacabaro.vbhelper.daos.CardDao
+import com.github.nacabaro.vbhelper.daos.CardFusionsDao
+import com.github.nacabaro.vbhelper.daos.CardProgressDao
+import com.github.nacabaro.vbhelper.daos.ItemDao
+import com.github.nacabaro.vbhelper.daos.SpecialMissionDao
+import com.github.nacabaro.vbhelper.daos.SpriteDao
 import com.github.nacabaro.vbhelper.daos.UserCharacterDao
-import com.github.nacabaro.vbhelper.domain.characters.Character
-import com.github.nacabaro.vbhelper.domain.characters.Card
-import com.github.nacabaro.vbhelper.domain.Sprites
+import com.github.nacabaro.vbhelper.domain.card.Background
+import com.github.nacabaro.vbhelper.domain.card.CardCharacter
+import com.github.nacabaro.vbhelper.domain.card.Card
+import com.github.nacabaro.vbhelper.domain.card.CardAdventure
+import com.github.nacabaro.vbhelper.domain.card.CardFusions
+import com.github.nacabaro.vbhelper.domain.card.CardProgress
+import com.github.nacabaro.vbhelper.domain.card.PossibleTransformations
+import com.github.nacabaro.vbhelper.domain.characters.Sprite
+import com.github.nacabaro.vbhelper.domain.characters.Adventure
 import com.github.nacabaro.vbhelper.domain.characters.Dex
 import com.github.nacabaro.vbhelper.domain.device_data.BECharacterData
+import com.github.nacabaro.vbhelper.domain.device_data.SpecialMissions
 import com.github.nacabaro.vbhelper.domain.device_data.TransformationHistory
 import com.github.nacabaro.vbhelper.domain.device_data.UserCharacter
+import com.github.nacabaro.vbhelper.domain.device_data.VBCharacterData
+import com.github.nacabaro.vbhelper.domain.device_data.VitalsHistory
+import com.github.nacabaro.vbhelper.domain.items.Items
 
 @Database(
     version = 1,
     entities = [
         Card::class,
-        Character::class,
-        Sprites::class,
+        CardProgress::class,
+        CardCharacter::class,
+        CardAdventure::class,
+        CardFusions::class,
+        Sprite::class,
         UserCharacter::class,
         BECharacterData::class,
+        VBCharacterData::class,
+        SpecialMissions::class,
         TransformationHistory::class,
-        Dex::class
+        VitalsHistory::class,
+        Dex::class,
+        Items::class,
+        Adventure::class,
+        Background::class,
+        PossibleTransformations::class
     ]
 )
 abstract class AppDatabase : RoomDatabase() {
-    abstract fun dimDao(): DiMDao
+    abstract fun cardDao(): CardDao
+    abstract fun cardProgressDao(): CardProgressDao
     abstract fun characterDao(): CharacterDao
     abstract fun userCharacterDao(): UserCharacterDao
     abstract fun dexDao(): DexDao
+    abstract fun itemDao(): ItemDao
+    abstract fun adventureDao(): AdventureDao
+    abstract fun spriteDao(): SpriteDao
+    abstract fun specialMissionDao(): SpecialMissionDao
+    abstract fun cardAdventureDao(): CardAdventureDao
+    abstract fun cardFusionsDao(): CardFusionsDao
 }

app/src/main/java/com/github/nacabaro/vbhelper/di/AppContainer.kt

@@ -1,9 +1,11 @@
 package com.github.nacabaro.vbhelper.di
 
 import com.github.nacabaro.vbhelper.database.AppDatabase
+import com.github.nacabaro.vbhelper.source.CurrencyRepository
 import com.github.nacabaro.vbhelper.source.DataStoreSecretsRepository
 
 interface AppContainer {
     val db: AppDatabase
     val dataStoreSecretsRepository: DataStoreSecretsRepository
+    val currencyRepository: CurrencyRepository
 }

app/src/main/java/com/github/nacabaro/vbhelper/di/DefaultAppContainer.kt

@@ -1,20 +1,27 @@
 import android.content.Context
 import androidx.datastore.core.DataStore
 import androidx.datastore.dataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.preferencesDataStore
 import androidx.room.Room
 import com.github.nacabaro.vbhelper.database.AppDatabase
 import com.github.nacabaro.vbhelper.di.AppContainer
+import com.github.nacabaro.vbhelper.source.CurrencyRepository
 import com.github.nacabaro.vbhelper.source.DataStoreSecretsRepository
 import com.github.nacabaro.vbhelper.source.SecretsSerializer
 import com.github.nacabaro.vbhelper.source.proto.Secrets
 
 private const val SECRETS_DATA_STORE_NAME = "secrets.pb"
-
+private const val USER_PREFERENCES_NAME = "user_preferences"
 val Context.secretsStore: DataStore<Secrets> by dataStore(
     fileName = SECRETS_DATA_STORE_NAME,
     serializer = SecretsSerializer
 )
 
+val Context.currencyStore: DataStore<Preferences> by preferencesDataStore(
+    name = USER_PREFERENCES_NAME
+)
+
 class DefaultAppContainer(private val context: Context) : AppContainer {
 
     override val db: AppDatabase by lazy {
@@ -22,10 +29,13 @@ class DefaultAppContainer(private val context: Context) : AppContainer {
             context = context,
             klass = AppDatabase::class.java,
             "internalDb"
-        ).build()
+        )
+            .createFromAsset("items.db")
+            .build()
     }
 
     override val dataStoreSecretsRepository = DataStoreSecretsRepository(context.secretsStore)
 
+    override val currencyRepository = CurrencyRepository(context.currencyStore)
 }
 

app/src/main/java/com/github/nacabaro/vbhelper/domain/DimProgress.kt

@@ -1,29 +0,0 @@
-package com.github.nacabaro.vbhelper.domain
-
-import androidx.room.Entity
-import androidx.room.ForeignKey
-import androidx.room.PrimaryKey
-import com.github.nacabaro.vbhelper.domain.characters.Card
-
-@Entity(
-    foreignKeys = [
-        ForeignKey(
-            entity = User::class,
-            parentColumns = ["id"],
-            childColumns = ["userId"],
-            onDelete = ForeignKey.CASCADE
-        ),
-        ForeignKey(
-            entity = Card::class,
-            parentColumns = ["id"],
-            childColumns = ["dimId"],
-            onDelete = ForeignKey.CASCADE
-        )
-    ]
-)
-data class DimProgress(
-    @PrimaryKey val dimId: Int,
-    @PrimaryKey val userId: Int,
-    val currentStage: Int,
-    val unlocked: Boolean
-)

app/src/main/java/com/github/nacabaro/vbhelper/domain/Evolutions.kt

@@ -3,7 +3,6 @@ package com.github.nacabaro.vbhelper.domain
 import androidx.room.Entity
 import androidx.room.ForeignKey
 import androidx.room.PrimaryKey
-import com.github.nacabaro.vbhelper.domain.characters.Character
 
 @Entity(
     foreignKeys = [

app/src/main/java/com/github/nacabaro/vbhelper/domain/Sprites.kt

@@ -1,12 +0,0 @@
-package com.github.nacabaro.vbhelper.domain
-
-import androidx.room.Entity
-import androidx.room.PrimaryKey
-
-@Entity
-data class Sprites(
-    @PrimaryKey(autoGenerate = true) val id : Int,
-    val sprite: ByteArray,
-    val width: Int,
-    val height: Int
-)

app/src/main/java/com/github/nacabaro/vbhelper/domain/UserMonsters.kt

@@ -3,7 +3,6 @@ package com.github.nacabaro.vbhelper.domain
 import androidx.room.Entity
 import androidx.room.ForeignKey
 import androidx.room.PrimaryKey
-import com.github.nacabaro.vbhelper.domain.characters.Character
 
 @Entity(
     foreignKeys = [

app/src/main/java/com/github/nacabaro/vbhelper/domain/card/Background.kt

@@ -0,0 +1,23 @@
+package com.github.nacabaro.vbhelper.domain.card
+
+import androidx.room.Entity
+import androidx.room.ForeignKey
+import androidx.room.PrimaryKey
+
+@Entity(
+    foreignKeys = [
+        ForeignKey(
+            entity = Card::class,
+            parentColumns = ["id"],
+            childColumns = ["cardId"],
+            onDelete = ForeignKey.CASCADE
+        )
+    ]
+)
+data class Background (
+    @PrimaryKey(autoGenerate = true) val id: Long,
+    val cardId: Long,
+    val background: ByteArray,
+    val backgroundWidth: Int,
+    val backgroundHeight: Int
+)

app/src/main/java/com/github/nacabaro/vbhelper/domain/card/Card.kt

@@ -1,4 +1,4 @@
-package com.github.nacabaro.vbhelper.domain.characters
+package com.github.nacabaro.vbhelper.domain.card
 
 import androidx.room.Entity
 import androidx.room.PrimaryKey
@@ -7,7 +7,7 @@ import androidx.room.PrimaryKey
 data class Card(
     @PrimaryKey(autoGenerate = true)
     val id: Long = 0,
-    val dimId: Int,
+    val cardId: Int,
     val logo: ByteArray,
     val logoWidth: Int,
     val logoHeight: Int,

app/src/main/java/com/github/nacabaro/vbhelper/domain/card/CardAdventure.kt

@@ -0,0 +1,32 @@
+package com.github.nacabaro.vbhelper.domain.card
+
+import androidx.room.Entity
+import androidx.room.ForeignKey
+import androidx.room.PrimaryKey
+
+@Entity(
+    foreignKeys = [
+        ForeignKey(
+            entity = CardCharacter::class,
+            parentColumns = ["id"],
+            childColumns = ["characterId"],
+            onDelete = ForeignKey.CASCADE
+        ),
+        ForeignKey(
+            entity = Card::class,
+            parentColumns = ["id"],
+            childColumns = ["cardId"],
+            onDelete = ForeignKey.CASCADE
+        )
+    ]
+)
+data class CardAdventure(
+    @PrimaryKey(autoGenerate = true) val id: Long = 0,
+    val cardId: Long,
+    val characterId: Long,
+    val steps: Int,
+    val bossHp: Int,
+    val bossAp: Int,
+    val bossDp: Int,
+    val bossBp: Int?
+)

app/src/main/java/com/github/nacabaro/vbhelper/domain/card/CardCharacter.kt

@@ -0,0 +1,44 @@
+package com.github.nacabaro.vbhelper.domain.card
+
+import androidx.room.Entity
+import androidx.room.ForeignKey
+import androidx.room.PrimaryKey
+import com.github.cfogrady.vbnfc.data.NfcCharacter
+import com.github.nacabaro.vbhelper.domain.characters.Sprite
+
+@Entity(
+    foreignKeys = [
+        ForeignKey(
+            entity = Card::class,
+            parentColumns = ["id"],
+            childColumns = ["cardId"],
+            onDelete = ForeignKey.CASCADE
+        ),
+        ForeignKey(
+            entity = Sprite::class,
+            parentColumns = ["id"],
+            childColumns = ["spriteId"],
+            onDelete = ForeignKey.CASCADE
+        )
+    ]
+)
+
+/*
+ * Character represents a character on a card. There should only be one of these per dimId
+ * and monIndex.
+ * TODO: Customs will mean this should be unique per cardName and monIndex
+ */
+data class CardCharacter (
+    @PrimaryKey(autoGenerate = true) val id: Long = 0,
+    val cardId: Long,
+    val spriteId: Long,
+    val charaIndex: Int,
+    val stage: Int, // These should be replaced with enums
+    val attribute: NfcCharacter.Attribute, // This one too
+    val baseHp: Int,
+    val baseBp: Int,
+    val baseAp: Int,
+    val nameSprite: ByteArray,
+    val nameWidth: Int,
+    val nameHeight: Int
+)

app/src/main/java/com/github/nacabaro/vbhelper/domain/card/CardFusions.kt

@@ -0,0 +1,29 @@
+package com.github.nacabaro.vbhelper.domain.card
+
+import androidx.room.Entity
+import androidx.room.ForeignKey
+import androidx.room.PrimaryKey
+import com.github.cfogrady.vbnfc.data.NfcCharacter
+
+@Entity(
+    foreignKeys = [
+        ForeignKey(
+            entity = CardCharacter::class,
+            parentColumns = ["id"],
+            childColumns = ["fromCharaId"],
+            onDelete = ForeignKey.CASCADE
+        ),
+        ForeignKey(
+            entity = CardCharacter::class,
+            parentColumns = ["id"],
+            childColumns = ["toCharaId"],
+            onDelete = ForeignKey.CASCADE
+        )
+    ]
+)
+data class CardFusions(
+    @PrimaryKey(autoGenerate = true) val id: Long,
+    val fromCharaId: Long,
+    val attribute: NfcCharacter.Attribute,
+    val toCharaId: Long
+)

app/src/main/java/com/github/nacabaro/vbhelper/domain/card/CardProgress.kt

@@ -0,0 +1,21 @@
+package com.github.nacabaro.vbhelper.domain.card
+
+import androidx.room.Entity
+import androidx.room.ForeignKey
+import androidx.room.PrimaryKey
+
+@Entity(
+    foreignKeys = [
+        ForeignKey(
+            entity = Card::class,
+            parentColumns = ["id"],
+            childColumns = ["cardId"],
+            onDelete = ForeignKey.CASCADE
+        )
+    ]
+)
+data class CardProgress(
+    @PrimaryKey val cardId: Long,
+    val currentStage: Int,
+    val unlocked: Boolean
+)

app/src/main/java/com/github/nacabaro/vbhelper/domain/card/PossibleTransformations.kt

@@ -0,0 +1,33 @@
+package com.github.nacabaro.vbhelper.domain.card
+
+import androidx.room.Entity
+import androidx.room.ForeignKey
+import androidx.room.PrimaryKey
+
+@Entity(
+    foreignKeys = [
+        ForeignKey(
+            entity = CardCharacter::class,
+            parentColumns = ["id"],
+            childColumns = ["charaId"],
+            onDelete = ForeignKey.CASCADE
+        ),
+        ForeignKey(
+            entity = CardCharacter::class,
+            parentColumns = ["id"],
+            childColumns = ["toCharaId"],
+            onDelete = ForeignKey.CASCADE
+        )
+    ]
+)
+data class PossibleTransformations (
+    @PrimaryKey(autoGenerate = true) val id: Long = 0,
+    var charaId: Long,
+    val requiredVitals: Int,
+    val requiredTrophies: Int,
+    val requiredBattles: Int,
+    val requiredWinRate: Int,
+    val changeTimerHours: Int,
+    val requiredAdventureLevelCompleted: Int,
+    val toCharaId: Long?
+)

app/src/main/java/com/github/nacabaro/vbhelper/domain/characters/Adventure.kt

@@ -0,0 +1,22 @@
+package com.github.nacabaro.vbhelper.domain.characters
+
+import androidx.room.Entity
+import androidx.room.ForeignKey
+import androidx.room.PrimaryKey
+import com.github.nacabaro.vbhelper.domain.device_data.UserCharacter
+
+@Entity(
+    foreignKeys = [
+        ForeignKey(
+            entity = UserCharacter::class,
+            parentColumns = ["id"],
+            childColumns = ["characterId"],
+            onDelete = ForeignKey.CASCADE
+        )
+    ]
+)
+data class Adventure(
+    @PrimaryKey val characterId: Long,
+    val originalDuration: Long,
+    val finishesAdventure: Long
+)

app/src/main/java/com/github/nacabaro/vbhelper/domain/characters/Character.kt

@@ -1,33 +0,0 @@
-package com.github.nacabaro.vbhelper.domain.characters
-
-import androidx.room.Entity
-import androidx.room.PrimaryKey
-import androidx.room.ForeignKey
-
-@Entity(
-    foreignKeys = [
-        ForeignKey(
-            entity = Card::class,
-            parentColumns = ["id"],
-            childColumns = ["dimId"],
-            onDelete = ForeignKey.CASCADE
-        )
-    ]
-)
-data class Character (
-    @PrimaryKey(autoGenerate = true) val id: Long = 0,
-    val dimId: Long,
-    val monIndex: Int,
-    val name: ByteArray,
-    val stage: Int, // These should be replaced with enums
-    val attribute: Int, // This one too
-    val baseHp: Int,
-    val baseBp: Int,
-    val baseAp: Int,
-    val sprite1: ByteArray,
-    val sprite2: ByteArray,
-    val nameWidth: Int,
-    val nameHeight: Int,
-    val spritesWidth: Int,
-    val spritesHeight: Int
-)

app/src/main/java/com/github/nacabaro/vbhelper/domain/characters/Dex.kt

@@ -3,11 +3,12 @@ package com.github.nacabaro.vbhelper.domain.characters
 import androidx.room.Entity
 import androidx.room.ForeignKey
 import androidx.room.PrimaryKey
+import com.github.nacabaro.vbhelper.domain.card.CardCharacter
 
 @Entity(
     foreignKeys = [
         ForeignKey(
-            entity = Character::class,
+            entity = CardCharacter::class,
             parentColumns = ["id"],
             childColumns = ["id"],
             onDelete = ForeignKey.CASCADE

app/src/main/java/com/github/nacabaro/vbhelper/domain/characters/Sprite.kt

@@ -0,0 +1,23 @@
+package com.github.nacabaro.vbhelper.domain.characters
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+
+@Entity
+data class Sprite(
+    @PrimaryKey(autoGenerate = true) val id : Int = 0,
+    val spriteIdle1: ByteArray,
+    val spriteIdle2: ByteArray,
+    val spriteWalk1: ByteArray,
+    val spriteWalk2: ByteArray,
+    val spriteRun1: ByteArray,
+    val spriteRun2: ByteArray,
+    val spriteTrain1: ByteArray,
+    val spriteTrain2: ByteArray,
+    val spriteHappy: ByteArray,
+    val spriteSleep: ByteArray,
+    val spriteAttack: ByteArray,
+    val spriteDodge: ByteArray,
+    val width: Int,
+    val height: Int
+)

app/src/main/java/com/github/nacabaro/vbhelper/domain/device_data/BECharacterData.kt

@@ -20,7 +20,7 @@ data class BECharacterData (
     val trainingHp: Int,
     val trainingAp: Int,
     val trainingBp: Int,
-    val remainingTrainingTimeInMinutes: Int,
+    var remainingTrainingTimeInMinutes: Int,
     val itemEffectMentalStateValue: Int,
     val itemEffectMentalStateMinutesRemaining: Int,
     val itemEffectActivityLevelValue: Int,
@@ -32,9 +32,9 @@ data class BECharacterData (
     val abilityBranch: Int,
     val abilityReset: Int,
     val rank: Int,
-    val itemType: Int,
-    val itemMultiplier: Int,
-    val itemRemainingTime: Int,
+    var itemType: Int,
+    var itemMultiplier: Int,
+    var itemRemainingTime: Int,
     val otp0: String,
     val otp1: String,
     val minorVersion: Int,

app/src/main/java/com/github/nacabaro/vbhelper/domain/device_data/SpecialMissions.kt

@@ -0,0 +1,28 @@
+package com.github.nacabaro.vbhelper.domain.device_data
+
+import androidx.room.Entity
+import androidx.room.ForeignKey
+import androidx.room.PrimaryKey
+import com.github.cfogrady.vbnfc.vb.SpecialMission
+
+@Entity(
+    foreignKeys = [
+        ForeignKey(
+            entity = UserCharacter::class,
+            parentColumns = ["id"],
+            childColumns = ["characterId"],
+            onDelete = ForeignKey.CASCADE
+        )
+    ]
+)
+data class SpecialMissions (
+    @PrimaryKey(autoGenerate = true) var id: Long = 0,
+    var characterId: Long,
+    var goal: Int,
+    val watchId: Int,
+    val progress: Int,
+    val status: SpecialMission.Status,
+    val timeElapsedInMinutes: Int,
+    val timeLimitInMinutes: Int,
+    val missionType: SpecialMission.Type
+)

app/src/main/java/com/github/nacabaro/vbhelper/domain/device_data/TransformationHistory.kt

@@ -3,7 +3,7 @@ package com.github.nacabaro.vbhelper.domain.device_data
 import androidx.room.Entity
 import androidx.room.ForeignKey
 import androidx.room.PrimaryKey
-import com.github.nacabaro.vbhelper.domain.characters.Character
+import com.github.nacabaro.vbhelper.domain.card.CardCharacter
 
 @Entity(
     foreignKeys = [
@@ -14,7 +14,7 @@ import com.github.nacabaro.vbhelper.domain.characters.Character
             onDelete = ForeignKey.CASCADE
         ),
         ForeignKey(
-            entity = Character::class,
+            entity = CardCharacter::class,
             parentColumns = ["id"],
             childColumns = ["stageId"],
             onDelete = ForeignKey.CASCADE

app/src/main/java/com/github/nacabaro/vbhelper/domain/device_data/UserCharacter.kt

@@ -5,25 +5,25 @@ import androidx.room.ForeignKey
 import androidx.room.PrimaryKey
 import com.github.cfogrady.vbnfc.data.NfcCharacter
 import com.github.nacabaro.vbhelper.utils.DeviceType
-import com.github.nacabaro.vbhelper.domain.characters.Character
+import com.github.nacabaro.vbhelper.domain.card.CardCharacter
 
 @Entity(
     foreignKeys = [
         ForeignKey(
-            entity = Character::class,
+            entity = CardCharacter::class,
             parentColumns = ["id"],
             childColumns = ["charId"],
             onDelete = ForeignKey.CASCADE
         )
     ]
 )
+/**
+ * UserCharacter represents and instance of a character. The charId should map to a Character
+ */
 data class UserCharacter (
     @PrimaryKey(autoGenerate = true) val id: Long = 0,
     var charId: Long,
-    var stage: Int,
-    var attribute: NfcCharacter.Attribute,
     var ageInDays: Int,
-    var nextAdventureMissionStage: Int, // next adventure mission stage on the character's dim
     var mood: Int,
     var vitalPoints: Int,
     var transformationCountdown: Int,

app/src/main/java/com/github/nacabaro/vbhelper/domain/device_data/VBCharacterData.kt

@@ -1,4 +1,21 @@
 package com.github.nacabaro.vbhelper.domain.device_data
 
-class VBCharacterData {
-}
+import androidx.room.Entity
+import androidx.room.ForeignKey
+import androidx.room.PrimaryKey
+
+@Entity(
+    foreignKeys = [
+        ForeignKey(
+            entity = UserCharacter::class,
+            parentColumns = ["id"],
+            childColumns = ["id"],
+            onDelete = ForeignKey.CASCADE
+        )
+    ]
+)
+data class VBCharacterData (
+    @PrimaryKey val id: Long,
+    val generation: Int,
+    val totalTrophies: Int
+)

app/src/main/java/com/github/nacabaro/vbhelper/domain/device_data/VitalsHistory.kt

@@ -0,0 +1,24 @@
+package com.github.nacabaro.vbhelper.domain.device_data
+
+import androidx.room.Entity
+import androidx.room.ForeignKey
+import androidx.room.PrimaryKey
+
+@Entity(
+    foreignKeys = [
+        ForeignKey(
+            entity = UserCharacter::class,
+            parentColumns = ["id"],
+            childColumns = ["charId"],
+            onDelete = ForeignKey.CASCADE
+        )
+    ]
+)
+data class VitalsHistory (
+    @PrimaryKey(autoGenerate = true) val id: Long = 0,
+    val charId: Long,
+    val year: Int,
+    val month: Int,
+    val day: Int,
+    val vitalPoints: Int
+)

app/src/main/java/com/github/nacabaro/vbhelper/domain/items/Items.kt

@@ -0,0 +1,23 @@
+package com.github.nacabaro.vbhelper.domain.items
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+
+enum class ItemType {
+    VBITEM,
+    BEITEM,
+    UNIVERSAL,
+    SPECIALMISSION
+}
+
+@Entity
+data class Items(
+    @PrimaryKey val id: Long,
+    val name: String,
+    val description: String,
+    val itemIcon: Int,
+    val itemLength: Int,
+    val price: Int,
+    val quantity: Int,
+    val itemType: ItemType
+)

app/src/main/java/com/github/nacabaro/vbhelper/dtos/CardDtos.kt

@@ -10,4 +10,24 @@ object CardDtos {
         val totalCharacters: Int,
         val obtainedCharacters: Int,
     )
+
+    data class CardAdventureWithSprites (
+        val characterName: ByteArray,
+        val characterNameWidth: Int,
+        val characterNameHeight: Int,
+        val characterIdleSprite: ByteArray,
+        val characterIdleSpriteWidth: Int,
+        val characterIdleSpriteHeight: Int,
+        val characterAp: Int,
+        val characterBp: Int?,
+        val characterDp: Int,
+        val characterHp: Int,
+        val steps: Int,
+    )
+
+    data class CardIcon (
+        val cardIcon: ByteArray,
+        val cardIconWidth: Int,
+        val cardIconHeight: Int
+    )
 }

app/src/main/java/com/github/nacabaro/vbhelper/dtos/CharacterDtos.kt

@@ -11,7 +11,76 @@ object CharacterDtos {
         var stage: Int,
         var attribute: NfcCharacter.Attribute,
         var ageInDays: Int,
-        var nextAdventureMissionStage: Int, // next adventure mission stage on the character's dim
+        var mood: Int,
+        var vitalPoints: Int,
+        var transformationCountdown: Int,
+        var injuryStatus: NfcCharacter.InjuryStatus,
+        var trophies: Int,
+        var currentPhaseBattlesWon: Int,
+        var currentPhaseBattlesLost: Int,
+        var totalBattlesWon: Int,
+        var totalBattlesLost: Int,
+        var activityLevel: Int,
+        var heartRateCurrent: Int,
+        var characterType: DeviceType,
+        val spriteIdle: ByteArray,
+        val spriteIdle2: ByteArray,
+        val spriteWidth: Int,
+        val spriteHeight: Int,
+        val nameSprite: ByteArray,
+        val nameSpriteWidth: Int,
+        val nameSpriteHeight: Int,
+        val isBemCard: Boolean,
+        val isInAdventure: Boolean,
+        val active: Boolean
+    )
+
+    data class CardCharacterInfo(
+        val cardId: Long,
+        val charId: Int,
+        val stage: Int,
+        val attribute: NfcCharacter.Attribute,
+        val currentStage: Int
+    )
+
+    data class TransformationHistory(
+        val id: Long,
+        val spriteIdle: ByteArray,
+        val spriteWidth: Int,
+        val spriteHeight: Int,
+        val monIndex: Int,
+        val transformationDate: Long
+    )
+
+    data class CardCharaProgress(
+        val id: Long,
+        val spriteIdle: ByteArray,
+        val spriteWidth: Int,
+        val spriteHeight: Int,
+        val nameSprite: ByteArray,
+        val nameSpriteWidth: Int,
+        val nameSpriteHeight: Int,
+        val discoveredOn: Long?,
+        val baseHp: Int,
+        val baseBp: Int,
+        val baseAp: Int,
+        val stage: Int,
+        val attribute: NfcCharacter.Attribute,
+    )
+
+    data class CardProgress(
+        val id: Long,
+        val spriteIdle: ByteArray,
+        val spriteWidth: Int,
+        val spriteHeight: Int,
+    )
+
+    data class AdventureCharacterWithSprites(
+        var id: Long = 0,
+        var charId: Long,
+        var stage: Int,
+        var attribute: NfcCharacter.Attribute,
+        var ageInDays: Int,
         var mood: Int,
         var vitalPoints: Int,
         var transformationCountdown: Int,
@@ -27,28 +96,33 @@ object CharacterDtos {
         val spriteIdle: ByteArray,
         val spriteWidth: Int,
         val spriteHeight: Int,
-        val isBemCard: Boolean
+        val isBemCard: Boolean,
+        val finishesAdventure: Long,
+        val originalTimeInMinutes: Long
     )
 
-    data class DiMInfo(
-        val cardId: Int,
-        val charId: Int
-    )
-
-    data class TransformationHistory(
-        val id: Long,
+    data class EvolutionRequirementsWithSpritesAndObtained(
+        val charaId: Long,
+        val fromCharaId: Long,
         val spriteIdle: ByteArray,
         val spriteWidth: Int,
         val spriteHeight: Int,
-        val monIndex: Int,
-        val transformationDate: Long
+        val discoveredOn: Long?,
+        val requiredTrophies: Int,
+        val requiredVitals: Int,
+        val requiredBattles: Int,
+        val requiredWinRate: Int,
+        val changeTimerHours: Int,
+        val requiredAdventureLevelCompleted: Int
     )
 
-    data class CardProgress(
-        val id: Long,
+    data class FusionsWithSpritesAndObtained(
+        val charaId: Long,
+        val fromCharaId: Long,
         val spriteIdle: ByteArray,
         val spriteWidth: Int,
         val spriteHeight: Int,
-        val discoveredOn: Long?
+        val discoveredOn: Long?,
+        val fusionAttribute: NfcCharacter.Attribute
     )
 }

app/src/main/java/com/github/nacabaro/vbhelper/dtos/ItemDtos.kt

@@ -0,0 +1,27 @@
+package com.github.nacabaro.vbhelper.dtos
+
+import com.github.nacabaro.vbhelper.domain.items.ItemType
+
+
+object ItemDtos {
+    data class ItemsWithQuantities(
+        val id: Long,
+        val name: String,
+        val description: String,
+        val itemIcon: Int,
+        val itemLength: Int,
+        val price: Int,
+        val quantity: Int,
+        val itemType: ItemType
+    )
+
+    data class PurchasedItem(
+        val itemId: Long,
+        val itemName: String,
+        val itemDescription: String,
+        val itemIcon: Int,
+        val itemLength: Int,
+        val itemAmount: Int,
+        val itemType: ItemType
+    )
+}

app/src/main/java/com/github/nacabaro/vbhelper/navigation/AppNavigation.kt

@@ -1,33 +1,59 @@
 package com.github.nacabaro.vbhelper.navigation
 
+import androidx.compose.animation.core.tween
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.Scaffold
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
 import androidx.navigation.compose.NavHost
 import androidx.navigation.compose.composable
 import androidx.navigation.compose.rememberNavController
+import com.github.nacabaro.vbhelper.di.VBHelper
 import com.github.nacabaro.vbhelper.screens.BattlesScreen
-import com.github.nacabaro.vbhelper.screens.DexScreen
-import com.github.nacabaro.vbhelper.screens.DiMScreen
+import com.github.nacabaro.vbhelper.screens.cardScreen.CardsScreen
+import com.github.nacabaro.vbhelper.screens.cardScreen.CardViewScreen
 import com.github.nacabaro.vbhelper.screens.homeScreens.HomeScreen
-import com.github.nacabaro.vbhelper.screens.ItemsScreen
+import com.github.nacabaro.vbhelper.screens.itemsScreen.ItemsScreen
 import com.github.nacabaro.vbhelper.screens.scanScreen.ScanScreen
 import com.github.nacabaro.vbhelper.screens.scanScreen.ScanScreenControllerImpl
 import com.github.nacabaro.vbhelper.screens.settingsScreen.SettingsScreen
-import com.github.nacabaro.vbhelper.screens.SpriteViewer
-import com.github.nacabaro.vbhelper.screens.StorageScreen
+import com.github.nacabaro.vbhelper.screens.spriteViewer.SpriteViewer
+import com.github.nacabaro.vbhelper.screens.homeScreens.HomeScreenControllerImpl
+import com.github.nacabaro.vbhelper.screens.storageScreen.StorageScreen
+import com.github.nacabaro.vbhelper.screens.itemsScreen.ChooseCharacterScreen
+import com.github.nacabaro.vbhelper.screens.itemsScreen.ItemsScreenControllerImpl
 import com.github.nacabaro.vbhelper.screens.settingsScreen.SettingsScreenControllerImpl
+import com.github.nacabaro.vbhelper.screens.adventureScreen.AdventureScreen
+import com.github.nacabaro.vbhelper.screens.adventureScreen.AdventureScreenControllerImpl
+import com.github.nacabaro.vbhelper.screens.cardScreen.CardAdventureScreen
+import com.github.nacabaro.vbhelper.screens.cardScreen.CardScreenControllerImpl
+import com.github.nacabaro.vbhelper.screens.settingsScreen.CreditsScreen
+import com.github.nacabaro.vbhelper.screens.spriteViewer.SpriteViewerControllerImpl
+import com.github.nacabaro.vbhelper.screens.storageScreen.StorageScreenControllerImpl
+import com.github.nacabaro.vbhelper.source.StorageRepository
 
 data class AppNavigationHandlers(
     val settingsScreenController: SettingsScreenControllerImpl,
     val scanScreenController: ScanScreenControllerImpl,
+    val itemsScreenController: ItemsScreenControllerImpl,
+    val adventureScreenController: AdventureScreenControllerImpl,
+    val storageScreenController: StorageScreenControllerImpl,
+    val homeScreenController: HomeScreenControllerImpl,
+    val spriteViewerController: SpriteViewerControllerImpl,
+    val cardScreenController: CardScreenControllerImpl
 )
 
 @Composable
 fun AppNavigation(
     applicationNavigationHandlers: AppNavigationHandlers,
-    onClickImportCard: () -> Unit,
 ) {
     val navController = rememberNavController()
 
@@ -39,55 +65,81 @@ fun AppNavigation(
         NavHost(
             navController = navController,
             startDestination = NavigationItems.Home.route,
+            enterTransition = {
+                fadeIn(
+                    animationSpec = tween(200)
+                )
+            },
+            exitTransition = {
+                fadeOut(
+                    animationSpec = tween(200)
+                )
+            },
             modifier = Modifier
                 .padding(contentPadding)
+
         ) {
             composable(NavigationItems.Battles.route) {
                 BattlesScreen()
             }
             composable(NavigationItems.Home.route) {
                 HomeScreen(
-                    navController = navController
+                    navController = navController,
+                    homeScreenController = applicationNavigationHandlers.homeScreenController
                 )
             }
             composable(NavigationItems.Storage.route) {
                 StorageScreen(
-                    navController = navController
+                    navController = navController,
+                    adventureScreenController = applicationNavigationHandlers.adventureScreenController,
+                    storageScreenController = applicationNavigationHandlers.storageScreenController
                 )
             }
             composable(NavigationItems.Scan.route) {
                 val characterIdString = it.arguments?.getString("characterId")
-                val characterId = characterIdString?.toLongOrNull()
+                var characterId by remember { mutableStateOf(characterIdString?.toLongOrNull()) }
+                val launchedFromHomeScreen = (characterIdString?.toLongOrNull() == null)
+
+                if (characterId == null) {
+                    val context = LocalContext.current.applicationContext as VBHelper
+                    val storageRepository = StorageRepository(context.container.db)
+                    val characterData by storageRepository.getActiveCharacter().collectAsState(null)
+                    if (characterData != null) {
+                        characterId = characterData!!.id
+                    }
+                }
 
                 ScanScreen(
                     navController = navController,
                     scanScreenController = applicationNavigationHandlers.scanScreenController,
-                    characterId = characterId
+                    characterId = characterId,
+                    launchedFromHomeScreen = launchedFromHomeScreen
                 )
             }
             composable(NavigationItems.Dex.route) {
-                DexScreen(
-                    navController = navController
+                CardsScreen(
+                    navController = navController,
+                    cardScreenController = applicationNavigationHandlers.cardScreenController
                 )
             }
             composable(NavigationItems.Settings.route) {
                 SettingsScreen(
                     navController = navController,
-                    settingsScreenController = applicationNavigationHandlers.settingsScreenController,
-                    onClickImportCard = onClickImportCard,
+                    settingsScreenController = applicationNavigationHandlers.settingsScreenController
                 )
             }
             composable(NavigationItems.Viewer.route) {
                 SpriteViewer(
-                    navController = navController
+                    navController = navController,
+                    spriteViewerController = applicationNavigationHandlers.spriteViewerController
                 )
             }
             composable(NavigationItems.CardView.route) {
                 val cardId = it.arguments?.getString("cardId")
                 if (cardId != null) {
-                    DiMScreen(
+                    CardViewScreen(
                         navController = navController,
-                        dimId = cardId.toLong()
+                        cardId = cardId.toLong()
                     )
                 }
             }
@@ -96,6 +148,40 @@ fun AppNavigation(
                     navController = navController
                 )
             }
+            composable(NavigationItems.ApplyItem.route) {
+                val itemId = it.arguments?.getString("itemId")
+                if (itemId != null) {
+                    ChooseCharacterScreen(
+                        itemsScreenController = applicationNavigationHandlers
+                            .itemsScreenController,
+                        navController = navController,
+                        itemId = itemId.toLong()
+                    )
+                }
+            }
+            composable(NavigationItems.Adventure.route) {
+                AdventureScreen(
+                    navController = navController,
+                    storageScreenController = applicationNavigationHandlers
+                        .adventureScreenController
+                )
+            }
+            composable(NavigationItems.Credits.route) {
+                CreditsScreen(
+                    navController = navController
+                )
+            }
+            composable(NavigationItems.CardAdventure.route) {
+                val cardId = it.arguments?.getString("cardId")
+                if (cardId != null) {
+                    CardAdventureScreen(
+                        navController = navController,
+                        cardId = cardId.toLong(),
+                        cardScreenController = applicationNavigationHandlers
+                            .cardScreenController
+                    )
+                }
+            }
         }
     }
 }

app/src/main/java/com/github/nacabaro/vbhelper/navigation/BottomNavigationBar.kt

@@ -8,7 +8,7 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.res.painterResource
 import androidx.navigation.NavController
 import androidx.navigation.compose.currentBackStackEntryAsState
-
+import androidx.compose.ui.res.stringResource
 
 @Composable
 fun BottomNavigationBar(navController: NavController) {
@@ -19,14 +19,15 @@ fun BottomNavigationBar(navController: NavController) {
         NavigationItems.Dex,
         NavigationItems.Storage,
     )
+
     NavigationBar {
         val currentBackStackEntry = navController.currentBackStackEntryAsState()
         val currentRoute = currentBackStackEntry.value?.destination?.route
 
         items.forEach { item ->
             NavigationBarItem (
-                icon = { Icon(painter = painterResource(item.icon), contentDescription = item.label) },
-                label = { Text(item.label) },
+                icon = { Icon(painter = painterResource(item.icon), contentDescription = stringResource(item.label)) },
+                label = { Text(text = stringResource(item.label)) },
                 selected = currentRoute == item.route,
                 onClick = {
                     navController.navigate(item.route) {

app/src/main/java/com/github/nacabaro/vbhelper/navigation/NavigationItems.kt

@@ -1,19 +1,101 @@
 package com.github.nacabaro.vbhelper.navigation
 
 import com.github.nacabaro.vbhelper.R
+import androidx.annotation.DrawableRes
+import androidx.annotation.StringRes
 
-sealed class NavigationItems (
-    var route: String,
-    var icon: Int,
-    var label: String
+sealed class NavigationItems(
+    val route: String,
+    @DrawableRes val icon: Int,
+    @StringRes val label: Int
 ) {
-    object Scan : NavigationItems("Scan/{characterId}", R.drawable.baseline_nfc_24, "Scan")
-    object Battles : NavigationItems("Battle", R.drawable.baseline_swords_24, "Battle")
-    object Home : NavigationItems("Home", R.drawable.baseline_cottage_24, "Home")
-    object Dex : NavigationItems("Dex", R.drawable.baseline_menu_book_24, "Dex")
-    object Storage : NavigationItems("Storage", R.drawable.baseline_catching_pokemon_24, "Storage")
-    object Settings : NavigationItems("Settings", R.drawable.baseline_settings_24, "Settings")
-    object Viewer : NavigationItems("Viewer", R.drawable.baseline_image_24, "Viewer")
-    object CardView : NavigationItems("Card/{cardId}", R.drawable.baseline_image_24, "Card")
-    object Items : NavigationItems("Items", R.drawable.baseline_data_24, "Items")
+    object Scan : NavigationItems(
+        "Scan/{characterId}",
+        R.drawable.baseline_nfc_24,
+        R.string.nav_scan
+    )
+
+    object Battles : NavigationItems(
+        "Battle",
+        R.drawable.baseline_swords_24,
+        R.string.nav_battle
+    )
+
+    object Home : NavigationItems(
+        "Home",
+        R.drawable.baseline_cottage_24,
+        R.string.nav_home
+    )
+
+    object Dex : NavigationItems(
+        "Dex",
+        R.drawable.baseline_menu_book_24,
+        R.string.nav_dex
+    )
+
+    object CardAdventure : NavigationItems(
+        "CardAdventure/{cardId}",
+        R.drawable.baseline_fort_24,
+        R.string.nav_card_adventure
+    )
+
+    object Storage : NavigationItems(
+        "Storage",
+        R.drawable.baseline_catching_pokemon_24,
+        R.string.nav_storage
+    )
+
+    object Settings : NavigationItems(
+        "Settings",
+        R.drawable.baseline_settings_24,
+        R.string.nav_settings
+    )
+
+    object Viewer : NavigationItems(
+        "Viewer",
+        R.drawable.baseline_image_24,
+        R.string.nav_viewer
+    )
+
+    object CardView : NavigationItems(
+        "Card/{cardId}",
+        R.drawable.baseline_image_24,
+        R.string.nav_card
+    )
+
+    object Items : NavigationItems(
+        "Items",
+        R.drawable.baseline_data_24,
+        R.string.nav_items
+    )
+
+    object MyItems : NavigationItems(
+        "MyItems",
+        R.drawable.baseline_data_24,
+        R.string.nav_my_items
+    )
+
+    object ItemsStore : NavigationItems(
+        "ItemsStore",
+        R.drawable.baseline_data_24,
+        R.string.nav_items_store
+    )
+
+    object ApplyItem : NavigationItems(
+        "ApplyItem/{itemId}",
+        R.drawable.baseline_data_24,
+        R.string.nav_apply_item
+    )
+
+    object Adventure : NavigationItems(
+        "Adventure",
+        R.drawable.baseline_fort_24,
+        R.string.nav_adventure
+    )
+
+    object Credits : NavigationItems(
+        "Credits",
+        R.drawable.baseline_data_24,
+        R.string.nav_credits
+    )
 }

app/src/main/java/com/github/nacabaro/vbhelper/screens/DexScreen.kt

@@ -1,84 +0,0 @@
-package com.github.nacabaro.vbhelper.screens
-
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.items
-import androidx.compose.material3.Scaffold
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.unit.dp
-import androidx.navigation.NavController
-import com.github.nacabaro.vbhelper.utils.BitmapData
-import com.github.nacabaro.vbhelper.components.DexDiMEntry
-import com.github.nacabaro.vbhelper.components.TopBanner
-import com.github.nacabaro.vbhelper.di.VBHelper
-import com.github.nacabaro.vbhelper.domain.characters.Card
-import com.github.nacabaro.vbhelper.dtos.CardDtos
-import com.github.nacabaro.vbhelper.navigation.NavigationItems
-import com.github.nacabaro.vbhelper.source.DexRepository
-import kotlinx.coroutines.launch
-
-@Composable
-fun DexScreen(
-    navController: NavController
-) {
-    val coroutineScope = rememberCoroutineScope()
-    val application = LocalContext.current.applicationContext as VBHelper
-    val dexRepository = DexRepository(application.container.db)
-
-    val cardList = remember { mutableStateOf<List<CardDtos.CardProgress>>(emptyList()) }
-
-    LaunchedEffect(dexRepository) {
-        coroutineScope.launch {
-            val newDimList = dexRepository.getAllDims()
-            cardList.value = newDimList // Replace the entire list atomically
-        }
-    }
-
-    Scaffold (
-        topBar = {
-            TopBanner(
-                text = "Discovered characters",
-                onGearClick = {
-                    navController.navigate(NavigationItems.Viewer.route)
-                }
-            )
-        }
-    ) { contentPadding ->
-        LazyColumn (
-            modifier = Modifier
-                .padding(top = contentPadding.calculateTopPadding())
-        ) {
-            items(cardList.value) {
-                DexDiMEntry(
-                    name = it.cardName,
-                    logo = BitmapData(
-                        bitmap = it.cardLogo,
-                        width = it.logoWidth,
-                        height = it.logoHeight
-                    ),
-                    onClick = {
-                        navController
-                            .navigate(
-                                NavigationItems
-                                    .CardView.route
-                                    .replace("{cardId}", "${it.cardId}")
-                            )
-                    },
-                    obtainedCharacters = it.obtainedCharacters,
-                    totalCharacters = it.totalCharacters,
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(8.dp)
-                )
-            }
-        }
-    }
-}
-

app/src/main/java/com/github/nacabaro/vbhelper/screens/ItemsScreen.kt

@@ -1,12 +0,0 @@
-package com.github.nacabaro.vbhelper.screens
-
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.navigation.NavController
-
-@Composable
-fun ItemsScreen(
-    navController: NavController
-) {
-    Text(text = "Items")
-}

app/src/main/java/com/github/nacabaro/vbhelper/screens/StorageScreen.kt

@@ -1,196 +0,0 @@
-package com.github.nacabaro.vbhelper.screens
-
-import android.util.Log
-import androidx.compose.foundation.gestures.Orientation
-import androidx.compose.foundation.gestures.scrollable
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.lazy.grid.GridCells
-import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
-import androidx.compose.foundation.lazy.grid.items
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.foundation.verticalScroll
-import androidx.compose.material3.Button
-import androidx.compose.material3.Card
-import androidx.compose.material3.Scaffold
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.window.Dialog
-import androidx.compose.ui.window.DialogProperties
-import androidx.navigation.NavController
-import com.github.nacabaro.vbhelper.components.CharacterEntry
-import com.github.nacabaro.vbhelper.components.TopBanner
-import com.github.nacabaro.vbhelper.di.VBHelper
-import com.github.nacabaro.vbhelper.domain.device_data.UserCharacter
-import com.github.nacabaro.vbhelper.dtos.CharacterDtos
-import com.github.nacabaro.vbhelper.navigation.NavigationItems
-import com.github.nacabaro.vbhelper.source.StorageRepository
-import com.github.nacabaro.vbhelper.utils.BitmapData
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-
-
-@Composable
-fun StorageScreen(
-    navController: NavController
-) {
-    val coroutineScope = rememberCoroutineScope()
-    val application = LocalContext.current.applicationContext as VBHelper
-    val storageRepository = StorageRepository(application.container.db)
-    val monList = remember { mutableStateOf<List<CharacterDtos.CharacterWithSprites>>(emptyList()) }
-
-    var selectedCharacter by remember { mutableStateOf<Long?>(null) }
-
-    LaunchedEffect(storageRepository) {
-        coroutineScope.launch {
-            val characterList = storageRepository.getAllCharacters()
-            monList.value = characterList
-        }
-    }
-
-    Scaffold (
-        topBar = { TopBanner(text = "My Digimon") }
-    ) { contentPadding ->
-        if (monList.value.isEmpty()) {
-            Column (
-                horizontalAlignment = Alignment.CenterHorizontally,
-                verticalArrangement = Arrangement.Center,
-                modifier = Modifier
-                    .padding(top = contentPadding.calculateTopPadding())
-                    .fillMaxSize()
-            ) {
-                Text(
-                    text = "Nothing to see here",
-                    textAlign = TextAlign.Center,
-                    modifier = Modifier
-                )
-            }
-        }
-
-        LazyVerticalGrid(
-            columns = GridCells.Fixed(3),
-            modifier = Modifier
-                .scrollable(state = rememberScrollState(), orientation = Orientation.Vertical)
-                .padding(top = contentPadding.calculateTopPadding())
-        ) {
-            items(monList.value) { index ->
-                CharacterEntry(
-                    icon = BitmapData(
-                        bitmap = index.spriteIdle,
-                        width = index.spriteWidth,
-                        height = index.spriteHeight
-                    ),
-                    onClick = {
-                        selectedCharacter = index.id
-                    }
-                )
-
-                if (selectedCharacter != null) {
-                    StorageDialog(
-                        characterId = selectedCharacter!!,
-                        onDismissRequest = { selectedCharacter = null },
-                        onClickSetActive = {
-                            coroutineScope.launch {
-                                withContext(Dispatchers.IO) {
-                                    storageRepository.setActiveCharacter(selectedCharacter!!)
-                                    selectedCharacter = null
-                                }
-                                navController.navigate(NavigationItems.Home.route)
-                            }
-                        },
-                        onSendToBracelet = {
-                            navController.navigate(
-                                NavigationItems.Scan.route.replace(
-                                    "{characterId}",
-                                    selectedCharacter.toString()
-                                )
-                            )
-                        }
-                    )
-                }
-            }
-        }
-    }
-}
-
-@Composable
-fun StorageDialog(
-    characterId: Long,
-    onDismissRequest: () -> Unit,
-    onSendToBracelet: () -> Unit,
-    onClickSetActive: () -> Unit
-) {
-    val coroutineScope = rememberCoroutineScope()
-    val application = LocalContext.current.applicationContext as VBHelper
-    val storageRepository = StorageRepository(application.container.db)
-    val character = remember { mutableStateOf<UserCharacter?>(null) }
-
-    LaunchedEffect(storageRepository) {
-        coroutineScope.launch {
-            character.value = storageRepository.getSingleCharacter(characterId)
-        }
-    }
-
-    Dialog(
-        onDismissRequest = onDismissRequest,
-        properties = DialogProperties(
-            dismissOnBackPress = true,
-            dismissOnClickOutside = true
-        )
-    ) {
-        Card(
-            shape = RoundedCornerShape(16.dp)
-        ) {
-            Column (
-                modifier = Modifier
-                    .padding(16.dp)
-            ) {
-                if (character.value != null) {
-                    Text(
-                        text = character.value?.toString() ?: "Loading...",
-                        textAlign = TextAlign.Center,
-                        modifier = Modifier
-                            .padding(8.dp)
-                    )
-                }
-                Row (
-                    modifier = Modifier
-                        .verticalScroll(rememberScrollState())
-                ) {
-                    Button(
-                        onClick = onSendToBracelet
-                    ) {
-                        Text(text = "Send to bracelet")
-                    }
-                    Button(
-                        onClick = onClickSetActive
-                    ) {
-                        Text(text = "Set active")
-                    }
-                    Button(
-                        onClick = onDismissRequest
-                    ) {
-                        Text(text = "Close")
-                    }
-                }
-            }
-        }
-    }
-}

app/src/main/java/com/github/nacabaro/vbhelper/screens/adventureScreen/AdventureEntry.kt

@@ -0,0 +1,68 @@
+package com.github.nacabaro.vbhelper.screens.adventureScreen
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.material3.Text
+import androidx.compose.material3.Card
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.FilterQuality
+import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.unit.dp
+import com.github.nacabaro.vbhelper.utils.BitmapData
+import com.github.nacabaro.vbhelper.utils.getBitmap
+import java.util.Locale
+
+@Composable
+fun AdventureEntry(
+    icon: BitmapData,
+    timeLeft: Long,
+    modifier: Modifier = Modifier,
+    onClick: () -> Unit
+) {
+    val bitmap = remember (icon.bitmap) { icon.getBitmap() }
+    val imageBitmap = remember(bitmap) { bitmap.asImageBitmap() }
+    val density: Float = LocalContext.current.resources.displayMetrics.density
+    val dpSize = (icon.width * 4 / density).dp
+
+    Card(
+        onClick = onClick,
+        modifier = modifier
+            .padding(8.dp)
+            .fillMaxWidth()
+    ) {
+        Row(
+            modifier = Modifier
+                .padding(8.dp)
+                .height(96.dp)
+        ) {
+            Image(
+                bitmap = imageBitmap,
+                contentDescription = null,
+                filterQuality = FilterQuality.None,
+                modifier = Modifier
+                    .size(dpSize)
+            )
+            Text(
+                text = when {
+                    timeLeft < 0 -> "Adventure finished"
+                    else -> "Time left: ${formatSeconds(timeLeft)}"
+                }
+            )
+        }
+    }
+}
+
+fun formatSeconds(totalSeconds: Long): String {
+    val hours = totalSeconds / 3600
+    val minutes = (totalSeconds % 3600) / 60
+    val seconds = totalSeconds % 60
+
+    return String.format(Locale.getDefault(), "%02d:%02d:%02d", hours, minutes, seconds)
+}

app/src/main/java/com/github/nacabaro/vbhelper/screens/adventureScreen/AdventureScreen.kt

@@ -0,0 +1,141 @@
+package com.github.nacabaro.vbhelper.screens.adventureScreen
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.produceState
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.navigation.NavController
+import com.github.nacabaro.vbhelper.screens.itemsScreen.ObtainedItemDialog
+import com.github.nacabaro.vbhelper.components.TopBanner
+import com.github.nacabaro.vbhelper.di.VBHelper
+import com.github.nacabaro.vbhelper.dtos.CharacterDtos
+import com.github.nacabaro.vbhelper.dtos.ItemDtos
+import com.github.nacabaro.vbhelper.navigation.NavigationItems
+import com.github.nacabaro.vbhelper.source.StorageRepository
+import com.github.nacabaro.vbhelper.utils.BitmapData
+import kotlinx.coroutines.delay
+import java.time.Instant
+import com.github.nacabaro.vbhelper.R
+
+@Composable
+fun AdventureScreen(
+    navController: NavController,
+    storageScreenController: AdventureScreenControllerImpl
+) {
+    val application = LocalContext.current.applicationContext as VBHelper
+    val database = application.container.db
+    val storageRepository = StorageRepository(database)
+    val characterList by storageRepository.getAdventureCharacters().collectAsState(emptyList())
+
+    var obtainedItem by remember {
+        mutableStateOf<ItemDtos.PurchasedItem?>(null)
+    }
+    var obtainedCurrency by remember {
+        mutableStateOf(0)
+    }
+
+    val currentTime by produceState(initialValue = Instant.now().epochSecond) {
+        while (true) {
+            value = Instant.now().epochSecond
+            delay(1000)
+        }
+    }
+
+    var cancelAdventureDialog by remember {
+        mutableStateOf<CharacterDtos.AdventureCharacterWithSprites?>(null)
+    }
+
+    Scaffold(
+        topBar = {
+            TopBanner(
+                text = stringResource(R.string.adventure_title),
+                onBackClick = {
+                    navController.popBackStack()
+                }
+            )
+        }
+    ) { contentPadding ->
+        if (characterList.isEmpty()) {
+            Column(
+                verticalArrangement = Arrangement.Center,
+                horizontalAlignment = Alignment.CenterHorizontally,
+                modifier = Modifier
+                    .padding(top = contentPadding.calculateTopPadding())
+                    .fillMaxSize()
+            ) {
+                Text(text = stringResource(R.string.adventure_empty_state))
+            }
+        } else {
+            LazyColumn(
+                modifier = Modifier
+                    .padding(top = contentPadding.calculateTopPadding())
+            ) {
+                items(characterList) {
+                    AdventureEntry(
+                        icon = BitmapData(
+                            bitmap = it.spriteIdle,
+                            width = it.spriteWidth,
+                            height = it.spriteHeight
+                        ),
+                        timeLeft = it.finishesAdventure - currentTime,
+                        onClick = {
+                            if (it.finishesAdventure < currentTime) {
+                                storageScreenController
+                                    .getItemFromAdventure(it.id) { adventureResult, generatedCurrency ->
+                                        obtainedItem = adventureResult
+                                        obtainedCurrency = generatedCurrency
+                                    }
+                            } else {
+                                cancelAdventureDialog = it
+                            }
+                        }
+                    )
+                }
+            }
+        }
+    }
+
+    if (obtainedItem != null) {
+        ObtainedItemDialog(
+            obtainedItem = obtainedItem!!,
+            obtainedCurrency = obtainedCurrency,
+            onClickDismiss = {
+                obtainedItem = null
+            }
+        )
+    }
+
+    if (cancelAdventureDialog != null) {
+        CancelAdventureDialog(
+            characterSprite = BitmapData(
+                bitmap = cancelAdventureDialog!!.spriteIdle,
+                width = cancelAdventureDialog!!.spriteWidth,
+                height = cancelAdventureDialog!!.spriteHeight
+            ),
+            onDismissRequest = {
+                cancelAdventureDialog = null
+            },
+            onClickConfirm = {
+                storageScreenController.cancelAdventure(cancelAdventureDialog!!.id) {
+                    navController.navigate(NavigationItems.Storage.route)
+                }
+                cancelAdventureDialog = null
+            }
+        )
+    }
+}

app/src/main/java/com/github/nacabaro/vbhelper/screens/adventureScreen/AdventureScreenController.kt

@@ -0,0 +1,9 @@
+package com.github.nacabaro.vbhelper.screens.adventureScreen
+
+import com.github.nacabaro.vbhelper.dtos.ItemDtos
+
+interface AdventureScreenController {
+    fun sendCharacterToAdventure(characterId: Long, timeInMinutes: Long)
+    fun getItemFromAdventure(characterId: Long, onResult: (ItemDtos.PurchasedItem, Int) -> Unit)
+    fun cancelAdventure(characterId: Long, onResult: () -> Unit)
+}

app/src/main/java/com/github/nacabaro/vbhelper/screens/adventureScreen/AdventureScreenControllerImpl.kt

@@ -0,0 +1,113 @@
+package com.github.nacabaro.vbhelper.screens.adventureScreen
+
+import android.widget.Toast
+import androidx.activity.ComponentActivity
+import androidx.lifecycle.lifecycleScope
+import com.github.nacabaro.vbhelper.di.VBHelper
+import com.github.nacabaro.vbhelper.dtos.ItemDtos
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import kotlin.math.roundToInt
+import kotlin.random.Random
+
+class AdventureScreenControllerImpl(
+    private val componentActivity: ComponentActivity,
+) : AdventureScreenController {
+    private val application = componentActivity.applicationContext as VBHelper
+    private val database = application.container.db
+
+    override fun sendCharacterToAdventure(characterId: Long, timeInMinutes: Long) {
+        val finishesAdventureAt = timeInMinutes * 60
+        componentActivity.lifecycleScope.launch(Dispatchers.IO) {
+            val characterData = database
+                .userCharacterDao()
+                .getCharacter(characterId)
+
+            if (characterData.isActive) {
+                database
+                    .userCharacterDao()
+                    .clearActiveCharacter()
+            }
+
+            database
+                .adventureDao()
+                .insertNewAdventure(characterId, timeInMinutes, finishesAdventureAt)
+        }
+    }
+
+    override fun getItemFromAdventure(
+        characterId: Long,
+        onResult: (ItemDtos.PurchasedItem, Int) -> Unit
+    ) {
+        componentActivity.lifecycleScope.launch(Dispatchers.IO) {
+            database
+                .adventureDao()
+                .deleteAdventure(characterId)
+
+            val generatedCurrency = generateRandomCurrency()
+
+            val generatedItem = generateItem(characterId)
+
+            onResult(generatedItem, generatedCurrency)
+        }
+    }
+
+    private suspend fun generateRandomCurrency(): Int {
+        val currentValue = application.container.currencyRepository.currencyValue.first()
+        val random = (2..6).random() * 1000
+        application.container.currencyRepository.setCurrencyValue(currentValue + random)
+
+        return random
+    }
+
+    override fun cancelAdventure(characterId: Long, onResult: () -> Unit) {
+        componentActivity.lifecycleScope.launch(Dispatchers.IO) {
+            database
+                .adventureDao()
+                .deleteAdventure(characterId)
+
+            componentActivity
+                .runOnUiThread {
+                    Toast.makeText(
+                        componentActivity,
+                        "Adventure canceled",
+                        Toast.LENGTH_SHORT
+                    ).show()
+                    onResult()
+                }
+
+        }
+    }
+
+    private suspend fun generateItem(characterId: Long): ItemDtos.PurchasedItem {
+        val character = database
+            .userCharacterDao()
+            .getCharacterInfo(characterId)
+
+        val randomItem = database
+            .itemDao()
+            .getAllItems()
+            .first()
+            .random()
+
+        val random = ((Random.nextFloat() * character.stage) + 3).roundToInt()
+
+        database
+            .itemDao()
+            .purchaseItem(
+                itemId = randomItem.id,
+                itemAmount = random
+            )
+
+        return ItemDtos.PurchasedItem(
+            itemId = randomItem.id,
+            itemAmount = random,
+            itemName = randomItem.name,
+            itemIcon = randomItem.itemIcon,
+            itemLength = randomItem.itemLength,
+            itemDescription = randomItem.description,
+            itemType = randomItem.itemType
+        )
+    }
+}

app/src/main/java/com/github/nacabaro/vbhelper/screens/adventureScreen/CancelAdventureDialog.kt

@@ -0,0 +1,73 @@
+package com.github.nacabaro.vbhelper.screens.adventureScreen
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.material3.Button
+import androidx.compose.material3.Card
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.FilterQuality
+import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Dialog
+import com.github.nacabaro.vbhelper.utils.BitmapData
+import com.github.nacabaro.vbhelper.utils.getBitmap
+
+@Composable
+fun CancelAdventureDialog(
+    characterSprite: BitmapData,
+    onDismissRequest: () -> Unit,
+    onClickConfirm: () -> Unit
+) {
+    val bitmap = remember (characterSprite) { characterSprite.getBitmap() }
+    val imageBitmap = remember(bitmap) { bitmap.asImageBitmap() }
+    val density: Float = LocalContext.current.resources.displayMetrics.density
+    val dpSize = (characterSprite.width * 4 / density).dp
+
+    Dialog(
+        onDismissRequest = onDismissRequest
+    ) {
+        Card {
+            Column(
+                modifier = Modifier
+                    .padding(16.dp)
+            ) {
+                Row {
+                    Image(
+                        bitmap = imageBitmap,
+                        contentDescription = null,
+                        filterQuality = FilterQuality.None,
+                        modifier = Modifier
+                            .size(dpSize)
+                    )
+                    Text(
+                        text = "Are you sure you want to cancel this character's adventure?"
+                    )
+                }
+                Row(
+                    modifier = Modifier
+                        .padding(8.dp)
+                ) {
+                    Button(
+                        onClick = onClickConfirm
+                    ) {
+                        Text(text = "Confirm")
+                    }
+                    Spacer(modifier = Modifier.padding(4.dp))
+                    Button(
+                        onClick = onDismissRequest
+                    ) {
+                        Text(text = "Dismiss")
+                    }
+                }
+            }
+        }
+    }
+}

app/src/main/java/com/github/nacabaro/vbhelper/screens/cardScreen/CardAdventureEntry.kt

@@ -0,0 +1,122 @@
+package com.github.nacabaro.vbhelper.screens.cardScreen
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardColors
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.contentColorFor
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.ColorFilter
+import androidx.compose.ui.graphics.FilterQuality
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.unit.dp
+import com.github.nacabaro.vbhelper.dtos.CardDtos
+import com.github.nacabaro.vbhelper.utils.BitmapData
+import com.github.nacabaro.vbhelper.utils.getImageBitmap
+
+@Composable
+fun CardAdventureEntry(
+    cardAdventureEntry: CardDtos.CardAdventureWithSprites,
+    obscure: Boolean
+) {
+    val charaImageBitmapData = BitmapData(
+        bitmap = cardAdventureEntry.characterIdleSprite,
+        width = cardAdventureEntry.characterIdleSpriteWidth,
+        height = cardAdventureEntry.characterIdleSpriteHeight
+    ).getImageBitmap(
+        context = LocalContext.current,
+        multiplier = 4,
+        obscure = obscure
+    )
+
+    val nameImageBitmapData = BitmapData(
+        bitmap = cardAdventureEntry.characterName,
+        width = cardAdventureEntry.characterNameWidth,
+        height = cardAdventureEntry.characterNameHeight
+    ).getImageBitmap(
+        context = LocalContext.current,
+        multiplier = 3,
+        obscure = obscure
+    )
+
+    Card (
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(8.dp)
+    ) {
+        Row (
+            modifier = Modifier
+                .padding(8.dp)
+        ){
+            Card (
+                colors = CardColors(
+                    containerColor = MaterialTheme.colorScheme.surfaceVariant,
+                    contentColor = MaterialTheme.colorScheme.contentColorFor(
+                        backgroundColor = MaterialTheme.colorScheme.surfaceVariant,
+                    ),
+                    disabledContainerColor = MaterialTheme.colorScheme.surfaceVariant,
+                    disabledContentColor = MaterialTheme.colorScheme.contentColorFor(
+                        backgroundColor = MaterialTheme.colorScheme.surfaceVariant,
+                    )
+                )
+            ) {
+                Image(
+                    bitmap = charaImageBitmapData.imageBitmap,
+                    contentDescription = "Icon",
+                    modifier = Modifier
+                        .size(charaImageBitmapData.dpWidth)
+                        .padding(8.dp),
+                    colorFilter = when (obscure) {
+                        true -> ColorFilter.tint(color = MaterialTheme.colorScheme.secondary)
+                        false -> null
+                    },
+                    filterQuality = FilterQuality.None
+                )
+            }
+
+            Spacer(modifier = Modifier.padding(8.dp))
+
+            Column {
+                if (!obscure) {
+                    Image(
+                        bitmap = nameImageBitmapData.imageBitmap,
+                        contentDescription = "Icon",
+                        modifier = Modifier
+                            .width(nameImageBitmapData.dpWidth)
+                            .height(nameImageBitmapData.dpHeight),
+                        filterQuality = FilterQuality.None
+                    )
+
+                    Spacer(modifier = Modifier.padding(4.dp))
+
+                    Text(
+                        text = "HP: ${cardAdventureEntry.characterHp}, DP: ${cardAdventureEntry.characterDp}, AP: ${cardAdventureEntry.characterAp}"
+                    )
+                    if (cardAdventureEntry.characterBp != null) {
+                        Text(text = "BP: ${cardAdventureEntry.characterBp}")
+                    }
+                    Text(text = "Steps: ${cardAdventureEntry.steps}")
+                } else {
+                    Text(text = "????????????????")
+                    Text(
+                        text = "HP: -, BP: -, AP: -"
+                    )
+                    if (cardAdventureEntry.characterBp != null) {
+                        Text(text = "DP: -")
+                    }
+                    Text(text = "Steps: -")
+                }
+            }
+        }
+    }
+}

app/src/main/java/com/github/nacabaro/vbhelper/screens/cardScreen/CardAdventureScreen.kt

@@ -0,0 +1,54 @@
+package com.github.nacabaro.vbhelper.screens.cardScreen
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.Scaffold
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.navigation.NavController
+import com.github.nacabaro.vbhelper.components.TopBanner
+import androidx.compose.ui.res.stringResource
+import com.github.nacabaro.vbhelper.R
+
+
+@Composable
+fun CardAdventureScreen(
+    navController: NavController,
+    cardScreenController: CardScreenControllerImpl,
+    cardId: Long
+) {
+    val cardAdventureMissions by cardScreenController
+        .getCardAdventureMissions(cardId)
+        .collectAsState(emptyList())
+    val currentCardAdventure by cardScreenController
+        .getCardProgress(cardId)
+        .collectAsState(0)
+
+    Scaffold (
+        topBar = {
+            TopBanner(
+                text = stringResource(R.string.card_adventure_missions_title),
+                onBackClick = {
+                    navController.popBackStack()
+                }
+            )
+        }
+    ) { contentPadding ->
+        Column (
+            modifier = Modifier
+                .padding(top = contentPadding.calculateTopPadding())
+                .verticalScroll(state = rememberScrollState())
+        ) {
+            cardAdventureMissions.mapIndexed { index, it ->
+                CardAdventureEntry(
+                    cardAdventureEntry = it,
+                    obscure = index > currentCardAdventure - 1
+                )
+            }
+        }
+    }
+}

app/src/main/java/com/github/nacabaro/vbhelper/screens/cardScreen/CardEntry.kt

@@ -0,0 +1,116 @@
+package com.github.nacabaro.vbhelper.screens.cardScreen
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Delete
+import androidx.compose.material.icons.filled.Edit
+import androidx.compose.material3.Card
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.FilterQuality
+import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.unit.dp
+import com.github.nacabaro.vbhelper.utils.BitmapData
+import com.github.nacabaro.vbhelper.utils.getBitmap
+import androidx.compose.ui.res.stringResource
+import com.github.nacabaro.vbhelper.R
+
+
+@Composable
+fun CardEntry(
+    name: String,
+    logo: BitmapData,
+    obtainedCharacters: Int,
+    totalCharacters: Int,
+    onClick: () -> Unit,
+    displayModify: Boolean,
+    onClickModify: () -> Unit,
+    onClickDelete: () -> Unit,
+    modifier: Modifier = Modifier
+) {
+    val bitmap = remember (logo.bitmap) { logo.getBitmap() }
+    val imageBitmap = remember(bitmap) { bitmap.asImageBitmap() }
+    val density: Float = LocalContext.current.resources.displayMetrics.density
+    val dpSize = (logo.width * 4 / density).dp
+
+    Card (
+        shape = MaterialTheme.shapes.medium,
+        modifier = modifier,
+        onClick = if (!displayModify) {
+            onClick
+        } else {
+            {  }
+        }
+    ) {
+        Row (
+            horizontalArrangement = Arrangement.Start,
+            verticalAlignment = Alignment.CenterVertically,
+            modifier = Modifier
+                .padding(8.dp)
+        ) {
+            Image (
+                bitmap = imageBitmap,
+                contentDescription = name,
+                filterQuality = FilterQuality.None,
+                modifier = Modifier
+                    .padding(8.dp)
+                    .size(dpSize)
+            )
+            Column(
+                modifier = Modifier
+                    .padding(8.dp)
+                    .weight(1f)
+            ) {
+                Text(
+                    text = name,
+                    modifier = Modifier
+                )
+                Text(
+                    text = stringResource(
+                        R.string.card_entry_characters_obtained,
+                        obtainedCharacters,
+                        totalCharacters
+                    ),
+                    fontFamily = MaterialTheme.typography.labelSmall.fontFamily,
+                    fontSize = MaterialTheme.typography.labelSmall.fontSize,
+                    modifier = Modifier
+                )
+            }
+            if (displayModify) {
+                Row (
+                    modifier = Modifier,
+                    horizontalArrangement = Arrangement.End,
+                ) {
+                    IconButton(
+                        onClick = onClickModify
+                    ) {
+                        Icon(
+                            imageVector = Icons.Default.Edit,
+                            contentDescription = stringResource(R.string.card_entry_edit)
+                        )
+                    }
+                    IconButton(
+                        onClick = onClickDelete
+                    ) {
+                        Icon(
+                            imageVector = Icons.Default.Delete,
+                            contentDescription = stringResource(R.string.card_entry_delete)
+                        )
+                    }
+                }
+            }
+        }
+    }
+}

app/src/main/java/com/github/nacabaro/vbhelper/screens/cardScreen/CardScreenController.kt

@@ -0,0 +1,13 @@
+package com.github.nacabaro.vbhelper.screens.cardScreen
+
+import com.github.nacabaro.vbhelper.dtos.CardDtos
+import com.github.nacabaro.vbhelper.dtos.CharacterDtos
+import kotlinx.coroutines.flow.Flow
+
+interface CardScreenController {
+    fun renameCard(cardId: Long, newName: String, onRenamed: (String) -> Unit)
+    fun deleteCard(cardId: Long, onDeleted: () -> Unit)
+    fun getCardAdventureMissions(cardId: Long): Flow<List<CardDtos.CardAdventureWithSprites>>
+    fun getCardProgress(cardId: Long): Flow<Int>
+    fun getFusionsForCharacters(characterId: Long): Flow<List<CharacterDtos.FusionsWithSpritesAndObtained>>
+}

app/src/main/java/com/github/nacabaro/vbhelper/screens/cardScreen/CardScreenControllerImpl.kt

@@ -0,0 +1,55 @@
+package com.github.nacabaro.vbhelper.screens.cardScreen
+
+import androidx.activity.ComponentActivity
+import androidx.lifecycle.lifecycleScope
+import com.github.nacabaro.vbhelper.di.VBHelper
+import com.github.nacabaro.vbhelper.dtos.CardDtos
+import com.github.nacabaro.vbhelper.dtos.CharacterDtos
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.launch
+
+class CardScreenControllerImpl(
+    private val componentActivity: ComponentActivity,
+) : CardScreenController {
+    private val application = componentActivity.applicationContext as VBHelper
+    private val database = application.container.db
+
+    override fun renameCard(cardId: Long, newName: String, onRenamed: (String) -> Unit) {
+        componentActivity.lifecycleScope.launch {
+            database
+                .cardDao()
+                .renameCard(cardId.toInt(), newName)
+
+            onRenamed(newName)
+        }
+    }
+
+    override fun deleteCard(cardId: Long, onDeleted: () -> Unit) {
+        componentActivity.lifecycleScope.launch {
+            database
+                .cardDao()
+                .deleteCard(cardId)
+
+            onDeleted()
+        }
+    }
+
+    override fun getCardAdventureMissions(cardId: Long): Flow<List<CardDtos.CardAdventureWithSprites>> {
+        return database
+            .cardAdventureDao()
+            .getAdventureForCard(cardId)
+    }
+
+    override fun getCardProgress(cardId: Long): Flow<Int> {
+        return database
+            .cardProgressDao()
+            .getCardProgress(cardId)
+    }
+
+    override fun getFusionsForCharacters(characterId: Long): Flow<List<CharacterDtos.FusionsWithSpritesAndObtained>> {
+        return database
+            .cardFusionsDao()
+            .getFusionsForCharacter(characterId)
+    }
+
+}

app/src/main/java/com/github/nacabaro/vbhelper/screens/cardScreen/CardViewScreen.kt

@@ -1,49 +1,57 @@
-package com.github.nacabaro.vbhelper.screens
+package com.github.nacabaro.vbhelper.screens.cardScreen
 
 import androidx.compose.foundation.lazy.grid.GridCells
 import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
 import androidx.compose.foundation.lazy.grid.items
 import androidx.compose.material3.Scaffold
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
 import androidx.navigation.NavController
 import com.github.nacabaro.vbhelper.utils.BitmapData
 import com.github.nacabaro.vbhelper.components.CharacterEntry
 import com.github.nacabaro.vbhelper.components.TopBanner
-import com.github.nacabaro.vbhelper.domain.characters.Character
 import com.github.nacabaro.vbhelper.di.VBHelper
 import com.github.nacabaro.vbhelper.dtos.CharacterDtos
+import com.github.nacabaro.vbhelper.navigation.NavigationItems
+import com.github.nacabaro.vbhelper.screens.cardScreen.dialogs.DexCharaDetailsDialog
 import com.github.nacabaro.vbhelper.source.DexRepository
-import kotlinx.coroutines.launch
+import com.github.nacabaro.vbhelper.R
+
 
 @Composable
-fun DiMScreen(
+fun CardViewScreen(
     navController: NavController,
-    dimId: Long
+    cardId: Long
 ) {
-    val coroutineScope = rememberCoroutineScope()
     val application = LocalContext.current.applicationContext as VBHelper
     val dexRepository = DexRepository(application.container.db)
 
-    val characterList = remember { mutableStateOf<List<CharacterDtos.CardProgress>>(emptyList()) }
+    val characterList by dexRepository.getCharactersByCardId(cardId).collectAsState(emptyList())
 
-    LaunchedEffect(dexRepository) {
-        coroutineScope.launch {
-            val newCharacterList = dexRepository.getCharactersByDimId(dimId)
-            characterList.value = newCharacterList
-        }
-    }
+    val selectedCharacter = remember { mutableStateOf<CharacterDtos.CardCharaProgress?>(null) }
 
     Scaffold (
         topBar = {
             TopBanner(
-                text = "Discovered characters",
+                text = stringResource(R.string.card_view_discovered_characters),
                 onBackClick = {
                     navController.popBackStack()
+                },
+                onAdventureClick = {
+                    navController
+                        .navigate(route = NavigationItems
+                            .CardAdventure
+                            .route
+                            .replace(
+                                "{cardId}",
+                                cardId.toString()
+                            )
+                        )
                 }
             )
         }
@@ -52,9 +60,11 @@ fun DiMScreen(
             columns = GridCells.Fixed(3),
             contentPadding = contentPadding
         ) {
-            items(characterList.value) { character ->
+            items(characterList) { character ->
                 CharacterEntry(
-                    onClick = {  },
+                    onClick = {
+                        selectedCharacter.value = character
+                    },
                     obscure = character.discoveredOn == null,
                     icon = BitmapData(
                         bitmap = character.spriteIdle,
@@ -64,5 +74,15 @@ fun DiMScreen(
                 )
             }
         }
+
+        if (selectedCharacter.value != null) {
+            DexCharaDetailsDialog(
+                currentChara = selectedCharacter.value!!,
+                obscure = selectedCharacter.value!!.discoveredOn == null,
+                onClickClose = {
+                    selectedCharacter.value = null
+                }
+            )
+        }
     }
 }

app/src/main/java/com/github/nacabaro/vbhelper/screens/cardScreen/CardsScreen.kt

@@ -0,0 +1,137 @@
+package com.github.nacabaro.vbhelper.screens.cardScreen
+
+import android.util.Log
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material3.Scaffold
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.unit.dp
+import androidx.navigation.NavController
+import com.github.nacabaro.vbhelper.utils.BitmapData
+import com.github.nacabaro.vbhelper.components.TopBanner
+import com.github.nacabaro.vbhelper.di.VBHelper
+import com.github.nacabaro.vbhelper.dtos.CardDtos
+import com.github.nacabaro.vbhelper.navigation.NavigationItems
+import com.github.nacabaro.vbhelper.screens.cardScreen.dialogs.CardDeleteDialog
+import com.github.nacabaro.vbhelper.screens.cardScreen.dialogs.CardRenameDialog
+import com.github.nacabaro.vbhelper.source.DexRepository
+import androidx.compose.ui.res.stringResource
+import com.github.nacabaro.vbhelper.R
+
+@Composable
+fun CardsScreen(
+    navController: NavController,
+    cardScreenController: CardScreenControllerImpl
+) {
+    val application = LocalContext.current.applicationContext as VBHelper
+    val dexRepository = DexRepository(application.container.db)
+    val cardList by dexRepository.getAllDims().collectAsState(emptyList())
+
+    val selectedCard = remember { mutableStateOf<CardDtos.CardProgress?>(null) }
+    var clickedDelete by remember { mutableStateOf(false) }
+    var clickedRename by remember { mutableStateOf(false) }
+
+    var modifyCards by remember { mutableStateOf(false) }
+
+    Scaffold (
+        topBar = {
+            TopBanner(
+                text = stringResource(R.string.cards_my_cards_title),
+                onModifyClick = {
+                    modifyCards = !modifyCards
+                }
+            )
+        }
+    ) { contentPadding ->
+        LazyColumn (
+            modifier = Modifier
+                .padding(top = contentPadding.calculateTopPadding())
+        ) {
+            items(cardList) {
+                CardEntry(
+                    name = it.cardName,
+                    logo = BitmapData(
+                        bitmap = it.cardLogo,
+                        width = it.logoWidth,
+                        height = it.logoHeight
+                    ),
+                    onClick = {
+                        navController
+                            .navigate(
+                                NavigationItems
+                                    .CardView.route
+                                    .replace("{cardId}", "${it.cardId}")
+                            )
+                    },
+                    obtainedCharacters = it.obtainedCharacters,
+                    totalCharacters = it.totalCharacters,
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(8.dp),
+                    displayModify = modifyCards,
+                    onClickModify = {
+                        selectedCard.value = it
+                        clickedRename = true
+                    },
+                    onClickDelete = {
+                        selectedCard.value = it
+                        clickedDelete = true
+                    }
+                )
+            }
+        }
+    }
+
+    if (clickedRename) {
+        CardRenameDialog(
+            onDismiss = {
+                clickedRename = false
+                selectedCard.value = null
+            },
+            onRename = { newName ->
+                Log.d("CardsScreen", "New name: $newName")
+                Log.d("CardsScreen", "Card: ${selectedCard.value.toString()}")
+                cardScreenController
+                    .renameCard(
+                        cardId = selectedCard.value!!.cardId,
+                        newName = newName,
+                        onRenamed = {
+                            clickedRename = false
+                            selectedCard.value = null
+                        }
+                    )
+            },
+            currentName = selectedCard.value!!.cardName
+        )
+    }
+
+    if (clickedDelete) {
+        CardDeleteDialog(
+            cardName = selectedCard.value!!.cardName,
+            onDismiss = {
+                clickedDelete = false
+                selectedCard.value = null
+            },
+            onConfirm = {
+                cardScreenController
+                    .deleteCard(
+                        cardId = selectedCard.value!!.cardId,
+                        onDeleted = {
+                            clickedDelete = false
+                            selectedCard.value = null
+                        }
+                    )
+            }
+        )
+    }
+}
+

app/src/main/java/com/github/nacabaro/vbhelper/screens/cardScreen/dialogs/CardDeleteDialog.kt

@@ -0,0 +1,51 @@
+package com.github.nacabaro.vbhelper.screens.cardScreen.dialogs
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Button
+import androidx.compose.material3.Card
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Dialog
+
+@Composable
+fun CardDeleteDialog(
+    cardName: String,
+    onDismiss: () -> Unit,
+    onConfirm: () -> Unit
+) {
+    Dialog(
+        onDismissRequest = onDismiss
+
+    ) {
+        Card ( ) {
+            Column (
+                modifier = Modifier
+                    .padding(16.dp)
+            ) {
+                Text(text = "Are you sure you want to delete $cardName. This action will also delete all the characters raised from this card.")
+                Spacer(modifier = Modifier.padding(8.dp))
+                Row {
+                    Button(
+                        onClick = {
+                            onDismiss()
+                        }
+                    ) {
+                        Text(text = "Confirm")
+                    }
+                    Button(
+                        onClick = {
+                            onConfirm()
+                        }
+                    ) {
+                        Text(text = "Delete")
+                    }
+                }
+            }
+        }
+    }
+}

app/src/main/java/com/github/nacabaro/vbhelper/screens/cardScreen/dialogs/CardRenameDialog.kt

@@ -0,0 +1,52 @@
+package com.github.nacabaro.vbhelper.screens.cardScreen.dialogs
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Button
+import androidx.compose.material3.Card
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextField
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Dialog
+
+@Composable
+fun CardRenameDialog(
+    onDismiss: () -> Unit,
+    onRename: (String) -> Unit,
+    currentName: String
+) {
+    var cardName by remember { mutableStateOf(currentName) }
+
+    Dialog(
+        onDismissRequest = onDismiss
+
+    ) {
+        Card ( ) {
+            Column (
+                modifier = Modifier
+                    .padding(16.dp)
+            ) {
+                TextField(
+                    value = cardName,
+                    onValueChange = { cardName = it }
+                )
+                Spacer(modifier = Modifier.padding(8.dp))
+                Button(
+                    onClick = {
+                        onRename(cardName)
+                        onDismiss()
+                    }
+                ) {
+                    Text(text = "Rename")
+                }
+            }
+        }
+    }
+}

app/src/main/java/com/github/nacabaro/vbhelper/screens/cardScreen/dialogs/DexCharaDetailsDialog.kt

@@ -0,0 +1,287 @@
+package com.github.nacabaro.vbhelper.screens.cardScreen.dialogs
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.material3.Button
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardColors
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.contentColorFor
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.ColorFilter
+import androidx.compose.ui.graphics.FilterQuality
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Dialog
+import com.github.nacabaro.vbhelper.di.VBHelper
+import com.github.nacabaro.vbhelper.dtos.CharacterDtos
+import com.github.nacabaro.vbhelper.source.DexRepository
+import com.github.nacabaro.vbhelper.utils.BitmapData
+import com.github.nacabaro.vbhelper.utils.getImageBitmap
+import androidx.compose.ui.res.stringResource
+import com.github.nacabaro.vbhelper.R
+
+@Composable
+fun DexCharaDetailsDialog(
+    currentChara: CharacterDtos.CardCharaProgress,
+    obscure: Boolean,
+    onClickClose: () -> Unit
+) {
+    val nameMultiplier = 3
+    val charaMultiplier = 4
+
+    val application = LocalContext.current.applicationContext as VBHelper
+    val database = application.container.db
+    val dexRepository = DexRepository(database)
+
+    var showFusions by remember { mutableStateOf(false) }
+
+    val currentCharaPossibleTransformations by dexRepository
+        .getCharacterPossibleTransformations(currentChara.id)
+        .collectAsState(emptyList())
+
+    val currentCharaPossibleFusions by dexRepository
+        .getCharacterPossibleFusions(currentChara.id)
+        .collectAsState(emptyList())
+
+    val romanNumeralsStage = when (currentChara.stage) {
+        1 -> "II"
+        2 -> "III"
+        3 -> "IV"
+        4 -> "V"
+        5 -> "VI"
+        6 -> "VII"
+        else -> "I"
+    }
+
+    val charaBitmapData = BitmapData(
+        bitmap = currentChara.spriteIdle,
+        width = currentChara.spriteWidth,
+        height = currentChara.spriteHeight
+    )
+    val charaImageBitmapData = charaBitmapData.getImageBitmap(
+        context = LocalContext.current,
+        multiplier = charaMultiplier,
+        obscure = obscure
+    )
+
+    val nameBitmapData = BitmapData(
+        bitmap = currentChara.nameSprite,
+        width = currentChara.nameSpriteWidth,
+        height = currentChara.nameSpriteHeight
+    )
+    val nameImageBitmapData = nameBitmapData.getImageBitmap(
+        context = LocalContext.current,
+        multiplier = nameMultiplier,
+        obscure = obscure
+    )
+
+    Dialog(
+        onDismissRequest = onClickClose
+    ) {
+        Card (
+            modifier = Modifier
+                .fillMaxWidth()
+        ) {
+            Column (
+                modifier = Modifier
+                    .padding(16.dp)
+            ) {
+                Row (
+                    verticalAlignment = Alignment.CenterVertically,
+                    modifier = Modifier
+                ) {
+                    Card (
+                        colors = CardColors(
+                            containerColor = MaterialTheme.colorScheme.surfaceVariant,
+                            contentColor = MaterialTheme.colorScheme.contentColorFor(
+                                backgroundColor = MaterialTheme.colorScheme.surfaceVariant,
+                            ),
+                            disabledContainerColor = MaterialTheme.colorScheme.surfaceVariant,
+                            disabledContentColor = MaterialTheme.colorScheme.contentColorFor(
+                                backgroundColor = MaterialTheme.colorScheme.surfaceVariant,
+                            )
+                        )
+                    ) {
+                        Image(
+                            bitmap = charaImageBitmapData.imageBitmap,
+                            contentDescription = stringResource(R.string.dex_chara_icon_description),
+                            modifier = Modifier
+                                .size(charaImageBitmapData.dpWidth)
+                                .padding(8.dp),
+                            colorFilter = when (obscure) {
+                                true -> ColorFilter.tint(color = MaterialTheme.colorScheme.secondary)
+                                false -> null
+                            },
+                            filterQuality = FilterQuality.None
+                        )
+                    }
+                    Spacer(
+                        modifier = Modifier
+                            .padding(16.dp)
+                    )
+                    if (!obscure) {
+                        Column {
+                            Image(
+                                bitmap = nameImageBitmapData.imageBitmap,
+                                contentDescription = stringResource(R.string.dex_chara_name_icon_description),
+                                modifier = Modifier
+                                    .width(nameImageBitmapData.dpWidth)
+                                    .height(nameImageBitmapData.dpHeight),
+                                filterQuality = FilterQuality.None
+                            )
+                            Spacer(modifier = Modifier.padding(4.dp))
+                            if (currentChara.baseHp != 65535) {
+                                Text(
+                                    text = stringResource(
+                                        R.string.dex_chara_stats,
+                                        currentChara.baseHp,
+                                        currentChara.baseBp,
+                                        currentChara.baseAp
+                                    )
+                                )
+                                Text(
+                                    text = stringResource(
+                                        R.string.dex_chara_stage_attribute,
+                                        romanNumeralsStage,
+                                        currentChara.attribute.toString().substring(0, 2)
+                                    )
+                                )
+                            }
+                        }
+                    } else {
+                        Column {
+                            Text(stringResource(R.string.dex_chara_unknown_name))
+                            Spacer(modifier = Modifier.padding(4.dp))
+                            Text(stringResource(R.string.dex_chara_stage_attribute_unknown))
+                            Text(stringResource(R.string.dex_chara_stats_unknown))
+                        }
+                    }
+                }
+                Spacer(modifier = Modifier.padding(16.dp))
+                Column {
+                    currentCharaPossibleTransformations.map {
+                        val selectedCharaBitmap = BitmapData(
+                            bitmap = it.spriteIdle,
+                            width = it.spriteWidth,
+                            height = it.spriteHeight
+                        )
+                        val selectedCharaImageBitmap = selectedCharaBitmap.getImageBitmap(
+                            context = LocalContext.current,
+                            multiplier = 4,
+                            obscure = it.discoveredOn == null
+                        )
+
+                        Card (
+                            modifier = Modifier
+                                .padding(vertical = 8.dp)
+                        ) {
+                            Row (
+                                verticalAlignment = Alignment.CenterVertically,
+                                modifier = Modifier
+                                    .fillMaxWidth()
+                            ) {
+                                Card (
+                                    colors = CardColors(
+                                        containerColor = MaterialTheme.colorScheme.surfaceVariant,
+                                        contentColor = MaterialTheme.colorScheme.contentColorFor(
+                                            backgroundColor = MaterialTheme.colorScheme.surfaceVariant,
+                                        ),
+                                        disabledContainerColor = MaterialTheme.colorScheme.surfaceVariant,
+                                        disabledContentColor = MaterialTheme.colorScheme.contentColorFor(
+                                            backgroundColor = MaterialTheme.colorScheme.surfaceVariant,
+                                        )
+                                    )
+                                ) {
+                                    Image(
+                                        bitmap = selectedCharaImageBitmap.imageBitmap,
+                                        contentDescription = stringResource(R.string.dex_chara_icon_description),
+                                        modifier = Modifier
+                                            .size(selectedCharaImageBitmap.dpWidth)
+                                            .padding(8.dp),
+                                        colorFilter = when (it.discoveredOn == null) {
+                                            true -> ColorFilter.tint(color = MaterialTheme.colorScheme.secondary)
+                                            false -> null
+                                        },
+                                        filterQuality = FilterQuality.None
+                                    )
+                                }
+                                Spacer(
+                                    modifier = Modifier
+                                        .padding(16.dp)
+                                )
+                                Column {
+                                    Text(
+                                        text = stringResource(
+                                            R.string.dex_chara_requirements,
+                                            it.requiredTrophies,
+                                            it.requiredBattles,
+                                            it.requiredVitals,
+                                            it.requiredWinRate,
+                                            it.changeTimerHours
+                                        )
+                                    )
+                                    Text(
+                                        text = stringResource(
+                                            R.string.dex_chara_adventure_level,
+                                            it.requiredAdventureLevelCompleted + 1
+                                        )
+                                    )
+                                }
+                            }
+                        }
+                    }
+                }
+
+                Row {
+                    if (currentCharaPossibleFusions.isNotEmpty()) {
+                        Button(
+                            onClick = {
+                                showFusions = true
+                            }
+                        ) {
+                            Text(stringResource(R.string.dex_chara_fusions_button))
+                        }
+                    }
+
+                    Spacer(
+                        modifier = Modifier
+                            .padding(4.dp)
+                    )
+
+                    Button(
+                        onClick = onClickClose
+                    ) {
+                        Text(stringResource(R.string.dex_chara_close_button))
+                    }
+                }
+            }
+        }
+    }
+
+    if (showFusions) {
+        DexCharaFusionsDialog(
+            currentChara = currentChara,
+            currentCharaPossibleFusions = currentCharaPossibleFusions,
+            onClickDismiss = {
+                showFusions = false
+            },
+            obscure = obscure
+        )
+    }
+}

app/src/main/java/com/github/nacabaro/vbhelper/screens/cardScreen/dialogs/DexCharaFusionsDialog.kt

@@ -0,0 +1,191 @@
+package com.github.nacabaro.vbhelper.screens.cardScreen.dialogs
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.material3.Button
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardColors
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.contentColorFor
+import androidx.compose.runtime.Composable
+import com.github.nacabaro.vbhelper.dtos.CharacterDtos
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.ColorFilter
+import androidx.compose.ui.graphics.FilterQuality
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Dialog
+import com.github.nacabaro.vbhelper.utils.BitmapData
+import com.github.nacabaro.vbhelper.utils.getImageBitmap
+
+@Composable
+fun DexCharaFusionsDialog(
+    currentChara: CharacterDtos.CardCharaProgress,
+    currentCharaPossibleFusions: List<CharacterDtos.FusionsWithSpritesAndObtained>,
+    obscure: Boolean,
+    onClickDismiss: () -> Unit,
+) {
+    val nameMultiplier = 3
+    val charaMultiplier = 4
+
+    val charaBitmapData = BitmapData(
+        bitmap = currentChara.spriteIdle,
+        width = currentChara.spriteWidth,
+        height = currentChara.spriteHeight
+    )
+    val charaImageBitmapData = charaBitmapData.getImageBitmap(
+        context = LocalContext.current,
+        multiplier = charaMultiplier,
+        obscure = obscure
+    )
+
+    val nameBitmapData = BitmapData(
+        bitmap = currentChara.nameSprite,
+        width = currentChara.nameSpriteWidth,
+        height = currentChara.nameSpriteHeight
+    )
+    val nameImageBitmapData = nameBitmapData.getImageBitmap(
+        context = LocalContext.current,
+        multiplier = nameMultiplier,
+        obscure = obscure
+    )
+
+    Dialog(
+        onDismissRequest = onClickDismiss,
+    ) {
+        Card(
+            modifier = Modifier
+                .fillMaxWidth()
+        ) {
+            Column(
+                modifier = Modifier
+                    .padding(16.dp)
+            ) {
+                Row {
+                    Card (
+                        colors = CardColors(
+                            containerColor = MaterialTheme.colorScheme.surfaceVariant,
+                            contentColor = MaterialTheme.colorScheme.contentColorFor(
+                                backgroundColor = MaterialTheme.colorScheme.surfaceVariant,
+                            ),
+                            disabledContainerColor = MaterialTheme.colorScheme.surfaceVariant,
+                            disabledContentColor = MaterialTheme.colorScheme.contentColorFor(
+                                backgroundColor = MaterialTheme.colorScheme.surfaceVariant,
+                            )
+                        )
+                    ) {
+                        Image(
+                            bitmap = charaImageBitmapData.imageBitmap,
+                            contentDescription = "Icon",
+                            modifier = Modifier
+                                .size(charaImageBitmapData.dpWidth)
+                                .padding(8.dp),
+                            colorFilter = when (obscure) {
+                                true -> ColorFilter.tint(color = MaterialTheme.colorScheme.secondary)
+                                false -> null
+                            },
+                            filterQuality = FilterQuality.None
+                        )
+                    }
+
+                    Spacer(
+                        modifier = Modifier
+                            .padding(16.dp)
+                    )
+
+                    if (!obscure) {
+                        Column {
+                            Image(
+                                bitmap = nameImageBitmapData.imageBitmap,
+                                contentDescription = "Icon",
+                                modifier = Modifier
+                                    .width(nameImageBitmapData.dpWidth)
+                                    .height(nameImageBitmapData.dpHeight),
+                                filterQuality = FilterQuality.None
+                            )
+                        }
+                    } else {
+                        Column {
+                            Text(text = "????????????????")
+                        }
+                    }
+                }
+
+                Spacer(modifier = Modifier.padding(16.dp))
+                Column {
+                    currentCharaPossibleFusions.map {
+                        val selectedCharaBitmap = BitmapData(
+                            bitmap = it.spriteIdle,
+                            width = it.spriteWidth,
+                            height = it.spriteHeight
+                        )
+                        val selectedCharaImageBitmap = selectedCharaBitmap.getImageBitmap(
+                            context = LocalContext.current,
+                            multiplier = 4,
+                            obscure = it.discoveredOn == null
+                        )
+
+                        Card (
+                            modifier = Modifier
+                                .padding(vertical = 8.dp)
+                        ) {
+                            Row (
+                                verticalAlignment = Alignment.CenterVertically,
+                                modifier = Modifier
+                                    .fillMaxWidth()
+                            ) {
+                                Card (
+                                    colors = CardColors(
+                                        containerColor = MaterialTheme.colorScheme.surfaceVariant,
+                                        contentColor = MaterialTheme.colorScheme.contentColorFor(
+                                            backgroundColor = MaterialTheme.colorScheme.surfaceVariant,
+                                        ),
+                                        disabledContainerColor = MaterialTheme.colorScheme.surfaceVariant,
+                                        disabledContentColor = MaterialTheme.colorScheme.contentColorFor(
+                                            backgroundColor = MaterialTheme.colorScheme.surfaceVariant,
+                                        )
+                                    )
+                                ) {
+                                    Image(
+                                        bitmap = selectedCharaImageBitmap.imageBitmap,
+                                        contentDescription = "Icon",
+                                        modifier = Modifier
+                                            .size(selectedCharaImageBitmap.dpWidth)
+                                            .padding(8.dp),
+                                        colorFilter = when (it.discoveredOn == null) {
+                                            true -> ColorFilter.tint(color = MaterialTheme.colorScheme.secondary)
+                                            false -> null
+                                        },
+                                        filterQuality = FilterQuality.None
+                                    )
+                                }
+                                Spacer(
+                                    modifier = Modifier
+                                        .padding(16.dp)
+                                )
+                                Column {
+                                    Text("Combine with ${it.fusionAttribute}")
+                                }
+                            }
+                        }
+                    }
+                }
+
+                Button(
+                    onClick = onClickDismiss
+                ) {
+                    Text("Close")
+                }
+            }
+        }
+    }
+}

app/src/main/java/com/github/nacabaro/vbhelper/screens/homeScreens/BetaWarning.kt

@@ -0,0 +1,48 @@
+package com.github.nacabaro.vbhelper.screens.homeScreens
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Button
+import androidx.compose.material3.Card
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Dialog
+import com.github.nacabaro.vbhelper.R
+
+@Composable
+fun BetaWarning(
+    onDismissRequest: () -> Unit
+) {
+    Dialog(
+        onDismissRequest = onDismissRequest
+    ) {
+        Card {
+            Column(
+                modifier = Modifier
+                    .padding(16.dp)
+            ) {
+                Text(
+                    text = stringResource(R.string.beta_warning_message_main)
+                )
+                Spacer(modifier = Modifier.padding(8.dp))
+                Text(
+                    text = stringResource(R.string.beta_warning_message_compatibility)
+                )
+                Spacer(modifier = Modifier.padding(8.dp))
+                Text(
+                    text = stringResource(R.string.beta_warning_message_thanks)
+                )
+                Spacer(modifier = Modifier.padding(8.dp))
+                Button(
+                    onClick = onDismissRequest
+                ) {
+                    Text(text = stringResource(R.string.beta_warning_button_dismiss))
+                }
+            }
+        }
+    }
+}

app/src/main/java/com/github/nacabaro/vbhelper/screens/homeScreens/HomeScreen.kt

@@ -1,56 +1,121 @@
 package com.github.nacabaro.vbhelper.screens.homeScreens
 
-import android.util.Log
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Button
+import androidx.compose.material3.Card
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Dialog
 import androidx.navigation.NavController
 import com.github.nacabaro.vbhelper.components.TopBanner
 import com.github.nacabaro.vbhelper.di.VBHelper
 import com.github.nacabaro.vbhelper.utils.DeviceType
 import com.github.nacabaro.vbhelper.domain.device_data.BECharacterData
 import com.github.nacabaro.vbhelper.domain.device_data.VBCharacterData
-import com.github.nacabaro.vbhelper.dtos.CharacterDtos
+import com.github.nacabaro.vbhelper.dtos.ItemDtos
 import com.github.nacabaro.vbhelper.navigation.NavigationItems
+import com.github.nacabaro.vbhelper.screens.homeScreens.screens.BEBEmHomeScreen
+import com.github.nacabaro.vbhelper.screens.homeScreens.screens.BEDiMHomeScreen
+import com.github.nacabaro.vbhelper.screens.homeScreens.screens.VBDiMHomeScreen
+import com.github.nacabaro.vbhelper.screens.itemsScreen.ObtainedItemDialog
 import com.github.nacabaro.vbhelper.source.StorageRepository
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
+import com.github.nacabaro.vbhelper.R
+import com.github.nacabaro.vbhelper.dtos.CardDtos
+import com.github.nacabaro.vbhelper.source.CardRepository
+import com.github.nacabaro.vbhelper.utils.BitmapData
+import kotlinx.coroutines.flow.flowOf
+import kotlin.collections.emptyList
 
 @Composable
 fun HomeScreen(
-    navController: NavController
+    navController: NavController,
+    homeScreenController: HomeScreenControllerImpl
 ) {
     val application = LocalContext.current.applicationContext as VBHelper
     val storageRepository = StorageRepository(application.container.db)
-    val activeMon = remember { mutableStateOf<CharacterDtos.CharacterWithSprites?>(null) }
-    val transformationHistory = remember { mutableStateOf<List<CharacterDtos.TransformationHistory>?>(null) }
-    val beData = remember { mutableStateOf<BECharacterData?>(null) }
-    val vbData = remember { mutableStateOf<VBCharacterData?>(null) }
+    val cardRepository = CardRepository(application.container.db)
 
-    LaunchedEffect(storageRepository, activeMon) {
-        withContext(Dispatchers.IO) {
-            activeMon.value = storageRepository.getActiveCharacter()
-            if (activeMon.value != null) {
-                beData.value = storageRepository.getCharacterBeData(activeMon.value!!.id)
-                transformationHistory.value = storageRepository.getTransformationHistory(activeMon.value!!.id)
+    val activeMon by storageRepository
+        .getActiveCharacter()
+        .collectAsState(initial = null)
+
+    val cardIconData by (
+        activeMon
+            ?.let { chara ->
+                cardRepository.getCardIconByCharaId(chara.charId)
+            }
+            ?: flowOf<CardDtos.CardIcon?>(null)
+    ).collectAsState(initial = null)
+
+    val transformationHistory by (
+        activeMon
+            ?.let { chara ->
+                storageRepository.getTransformationHistory(chara.id)
+            }
+            ?: flowOf(emptyList())
+    ).collectAsState(initial = emptyList())
+
+    val vbSpecialMissions by (
+        activeMon
+            ?.takeIf { it.characterType == DeviceType.VBDevice }
+            ?.let { chara ->
+                storageRepository.getSpecialMissions(chara.id)
+            }
+            ?: flowOf(emptyList())
+    ).collectAsState(initial = emptyList())
+
+    val vbData by (
+        activeMon
+            ?.takeIf { it.characterType == DeviceType.VBDevice }
+            ?.let { chara ->
+                storageRepository.getCharacterVbData(chara.id)
+            }
+            ?: flowOf<VBCharacterData?>(null)
+    ).collectAsState(initial = null)
+
+    val beData by (
+        activeMon
+            ?.takeIf { it.characterType == DeviceType.BEDevice }
+            ?.let { chara ->
+                storageRepository.getCharacterBeData(chara.id)
+            }
+            ?: flowOf<BECharacterData?>(null)
+    ).collectAsState(initial = null)
+
+    var adventureMissionsFinished by rememberSaveable { mutableStateOf(false) }
+    var betaWarning by rememberSaveable { mutableStateOf(true) }
+    var collectedItem by remember { mutableStateOf<ItemDtos.PurchasedItem?>(null) }
+    var collectedCurrency by remember { mutableStateOf<Int?>(null) }
+
+    LaunchedEffect(true) {
+        homeScreenController
+            .didAdventureMissionsFinish {
+                adventureMissionsFinished = it
             }
-        }
     }
 
     Scaffold (
         topBar = {
             TopBanner(
-                text = "VB Helper",
+                text = stringResource(R.string.home_title),
                 onScanClick = {
                     navController.navigate(NavigationItems.Scan.route)
                 },
@@ -60,7 +125,7 @@ fun HomeScreen(
             )
         }
     ) { contentPadding ->
-        if (activeMon.value == null || (beData.value == null && vbData.value == null) || transformationHistory.value == null) {
+        if (activeMon == null || (beData == null && vbData == null) || cardIconData == null || transformationHistory.isEmpty()) {
             Column (
                 horizontalAlignment = Alignment.CenterHorizontally,
                 verticalArrangement = Arrangement.Center,
@@ -68,35 +133,93 @@ fun HomeScreen(
                     .fillMaxSize()
                     .padding(top = contentPadding.calculateTopPadding())
             ) {
-                Text(text = "Nothing to see here")
+                Text(text = stringResource(R.string.adventure_empty_state))
             }
         } else {
-            if (activeMon.value!!.isBemCard) {
-                Log.d("HomeScreen", "BEDeviceBEm")
+            val cardIcon = BitmapData(
+                bitmap = cardIconData!!.cardIcon,
+                width = cardIconData!!.cardIconWidth,
+                height = cardIconData!!.cardIconHeight
+            )
+
+            if (activeMon!!.isBemCard && beData != null) {
                 BEBEmHomeScreen(
-                    activeMon = activeMon.value!!,
-                    beData = beData.value!!,
-                    transformationHistory = transformationHistory.value!!,
-                    contentPadding = contentPadding
+                    activeMon = activeMon!!,
+                    beData = beData!!,
+                    transformationHistory = transformationHistory,
+                    contentPadding = contentPadding,
+                    cardIcon = cardIcon
                 )
-            } else if (!activeMon.value!!.isBemCard && activeMon.value!!.characterType == DeviceType.BEDevice) {
-                Log.d("HomeScreen", "BEDevice")
+            } else if (!activeMon!!.isBemCard && activeMon!!.characterType == DeviceType.BEDevice && beData != null) {
                 BEDiMHomeScreen(
-                    activeMon = activeMon.value!!,
-                    beData = beData.value!!,
-                    transformationHistory = transformationHistory.value!!,
-                    contentPadding = contentPadding
+                    activeMon = activeMon!!,
+                    beData = beData!!,
+                    transformationHistory = transformationHistory,
+                    contentPadding = contentPadding,
+                    cardIcon = cardIcon
                 )
-            } else {
+            } else if (vbData != null) {
                 VBDiMHomeScreen(
-                    activeMon = activeMon.value!!,
-                    vbData = vbData.value!!,
-                    transformationHistory = transformationHistory.value!!,
-                    contentPadding = contentPadding
+                    activeMon = activeMon!!,
+                    vbData = vbData!!,
+                    transformationHistory = transformationHistory,
+                    contentPadding = contentPadding,
+                    specialMissions = vbSpecialMissions,
+                    homeScreenController = homeScreenController,
+                    onClickCollect = { item, currency ->
+                        collectedItem = item
+                        collectedCurrency = currency
+                    },
+                    cardIcon = cardIcon
                 )
             }
         }
     }
+
+    if (collectedItem != null) {
+        ObtainedItemDialog(
+            obtainedItem = collectedItem!!,
+            obtainedCurrency = collectedCurrency!!,
+            onClickDismiss = {
+                collectedItem = null
+                collectedCurrency = null
+            }
+        )
+    }
+
+    if (adventureMissionsFinished) {
+        Dialog(
+            onDismissRequest = { adventureMissionsFinished = false },
+        ) {
+            Card {
+                Column(
+                    modifier = Modifier
+                        .padding(16.dp)
+                ) {
+                    Text(
+                        text = stringResource(R.string.home_adventure_mission_finished),
+                        textAlign = TextAlign.Center
+                    )
+                    Button(
+                        onClick = {
+                            adventureMissionsFinished = false
+                        },
+                        modifier = Modifier
+                            .padding(8.dp)
+                            .fillMaxWidth()
+                    ) {
+                        Text(text = stringResource(R.string.beta_warning_button_dismiss))
+                    }
+                }
+            }
+        }
+    }
+
+    if (betaWarning) {
+        BetaWarning {
+            betaWarning = false
+        }
+    }
 }
 
 

app/src/main/java/com/github/nacabaro/vbhelper/screens/homeScreens/HomeScreenController.kt

@@ -0,0 +1,8 @@
+package com.github.nacabaro.vbhelper.screens.homeScreens
+
+import com.github.nacabaro.vbhelper.dtos.ItemDtos
+
+interface HomeScreenController {
+    fun didAdventureMissionsFinish(onCompletion: (Boolean) -> Unit)
+    fun clearSpecialMission(missionId: Long, onCleared: (ItemDtos.PurchasedItem?, Int?) -> Unit)
+}

app/src/main/java/com/github/nacabaro/vbhelper/screens/homeScreens/HomeScreenControllerImpl.kt

@@ -0,0 +1,83 @@
+package com.github.nacabaro.vbhelper.screens.homeScreens
+
+import androidx.activity.ComponentActivity
+import androidx.lifecycle.lifecycleScope
+import com.github.cfogrady.vbnfc.vb.SpecialMission
+import com.github.nacabaro.vbhelper.di.VBHelper
+import com.github.nacabaro.vbhelper.dtos.ItemDtos
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import java.time.Instant
+import kotlin.math.roundToInt
+import kotlin.random.Random
+
+class HomeScreenControllerImpl(
+    private val componentActivity: ComponentActivity,
+): HomeScreenController {
+    private val application = componentActivity.applicationContext as VBHelper
+    private val database = application.container.db
+
+    override fun didAdventureMissionsFinish(onCompletion: (Boolean) -> Unit) {
+        componentActivity.lifecycleScope.launch {
+            val currentTime = Instant.now().epochSecond
+            val adventureCharacters = database
+                .adventureDao()
+                .getAdventureCharacters()
+                .first()
+
+            val finishedAdventureCharacters = adventureCharacters.filter { character ->
+                character.finishesAdventure <= currentTime
+            }
+
+            onCompletion(finishedAdventureCharacters.isNotEmpty())
+        }
+    }
+
+    override fun clearSpecialMission(missionId: Long, onCleared: (ItemDtos.PurchasedItem?, Int?) -> Unit) {
+        componentActivity.lifecycleScope.launch {
+            val missionStatus = database
+                .specialMissionDao()
+                .getSpecialMission(missionId)
+                .first()
+
+            database
+                .specialMissionDao()
+                .clearSpecialMission(missionId)
+
+            if (missionStatus.status == SpecialMission.Status.COMPLETED) {
+                val randomItem = database
+                    .itemDao()
+                    .getAllItems()
+                    .first()
+                    .random()
+
+                val randomItemAmount = (Random.nextFloat() * 5).roundToInt()
+
+                database
+                    .itemDao()
+                    .purchaseItem(
+                        itemId = randomItem.id,
+                        itemAmount = randomItemAmount
+                    )
+
+                val purchasedItem = ItemDtos.PurchasedItem(
+                    itemId = randomItem.id,
+                    itemName = randomItem.name,
+                    itemDescription = randomItem.description,
+                    itemIcon = randomItem.itemIcon,
+                    itemLength = randomItem.itemLength,
+                    itemAmount = randomItemAmount,
+                    itemType = randomItem.itemType
+                )
+
+                val randomAmount = (2..6).random() * 1000
+                val currentCurrency = application.container.currencyRepository.currencyValue.first()
+                application.container.currencyRepository.setCurrencyValue(currentCurrency + randomAmount)
+
+                onCleared(purchasedItem, randomAmount)
+            } else {
+                onCleared(null, null)
+            }
+        }
+    }
+}