problème avec le aslivedata que j'arrive pas a import

ShakeAndCraft/app/build.gradle

@@ -38,7 +38,7 @@ android {
 apply plugin: 'kotlin-kapt'
 
 dependencies {
-
+    implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.5.1"
     implementation 'androidx.core:core-ktx:1.7.0'
     implementation 'androidx.appcompat:appcompat:1.4.1'
     implementation 'com.google.android.material:material:1.5.0'
@@ -52,5 +52,5 @@ dependencies {
     implementation 'androidx.vectordrawable:vectordrawable:1.1.0'
     kapt 'androidx.room:room-compiler:2.5.1'
     implementation 'androidx.room:room-ktx:2.5.1'
-    implementation 'androdx.room:room-runtime:2.5.1'
+    implementation 'androidx.room:room-runtime:2.5.1'
 }

ShakeAndCraft/app/src/main/java/com/example/shakecraft/PlayerApplication.kt

@@ -0,0 +1,8 @@
+package com.example.shakecraft
+
+import android.app.Application
+import com.example.shakecraft.data.DataBase
+
+class PlayerApplication: Application(){
+    val database: DataBase by lazy { DataBase.getInstance(this) }
+}

ShakeAndCraft/app/src/main/java/com/example/shakecraft/PlayerViewModel.kt

@@ -0,0 +1,60 @@
+package com.example.shakecraft
+
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.asLiveData
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
+import androidx.lifecycle.viewModelScope
+import com.example.shakecraft.data.PlayerDao
+import com.example.shakecraft.model.Player
+import kotlinx.coroutines.launch
+
+class PlayerViewModel(private val playerDao: PlayerDao): ViewModel() {
+    val player:LiveData<Player> = playerDao.getPlayer()
+        .asLiveData()
+    fun updatePlayer(
+        Id: Int,
+        pseudo: String,
+        level: Int,
+        xp: Int,
+        image: Int,
+        rank: String,
+    ){
+        val updatePlayer= getUpdatePlayerEntry(Id, pseudo, level, xp, image, rank)
+        updatePlayer(updatePlayer)
+    }
+
+    private fun updatePlayer(player: Player) {
+        viewModelScope.launch{
+            playerDao.update(player)
+        }
+    }
+
+    private fun getUpdatePlayerEntry(
+        Id: Int,
+        pseudo: String,
+        level: Int,
+        xp: Int,
+        image: Int,
+        rank: String,
+    ): Player {
+        return Player(
+            id= Id,
+            pseudo= pseudo,
+            level= level,
+            xp= xp,
+            image= image,
+            rank= rank,
+        )
+    }
+}
+
+class PlayerViewModelFactory(private val playerDao: PlayerDao): ViewModelProvider.Factory{
+    fun <T : ViewModel?> create(modelClass: Class<T>): T {
+        if (modelClass.isAssignableFrom(PlayerViewModel::class.java)){
+            @Suppress("UNCHECKED_CAST")
+            return PlayerViewModel(playerDao) as T
+        }
+        throw IllegalArgumentException("Unknown ViewModel class")
+    }
+}

ShakeAndCraft/app/src/main/java/com/example/shakecraft/data/PlayerDao.kt

@@ -1,14 +1,21 @@
 package com.example.shakecraft.data
 
-import androidx.room.Query
+import androidx.room.*
 import com.example.shakecraft.model.Player
 import kotlinx.coroutines.flow.Flow
-import java.util.List
 
+@Dao
 interface PlayerDao {
-    @Query("SELECT * from Player ")
-    fun getBoss(): Flow<List<Player>>
 
-    @Query("SELECT * from Player WHERE name = :name")
+    @Query("SELECT * FROM Player")
-    fun getBoss(name : String): Flow<Player>
+    fun getPlayer(): Flow<Player>
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insert(player: Player)
+
+    @Update
+    suspend fun update(player: Player)
+
+    @Delete
+    suspend fun delete(player: Player)
 }

ShakeAndCraft/app/src/main/java/com/example/shakecraft/model/Inventory.kt

@@ -1,46 +0,0 @@
-package com.example.shakecraft.model
-
-class Inventory() {
-    var items: MutableList<Item> = mutableListOf()
-
-    fun addItem(item: Item) {
-        val findItem = items.find { it.type.name == item.type.name }
-
-        if(findItem!= null){
-            println("findItem n: "+findItem.stack+" item nb:"+item.stack)
-            findItem.stack += item.stack
-        }
-        else{items.add(Item(type = item.type, stack = item.stack))}
-    }
-
-    fun hasItem(item: Item) : Boolean{
-        for (inventoryItem in items){
-            if(inventoryItem.type.name == item.type.name && inventoryItem.stack >= item.stack){
-                return true
-            }
-        }
-        return false
-    }
-
-
-    fun craft(recipe: Recipe) : Boolean{
-        println("test")
-        for (ingredient in recipe.ingredients) {
-            val searchedItem = items.find { it.type.name == ingredient.type.name }
-            if(searchedItem != null) {
-                searchedItem.stack -= ingredient.stack
-                if (searchedItem.stack == 0){
-                    items.remove(searchedItem)
-                }
-                println(ingredient.type.name)
-                if (recipe.item.type.name == "Open Treasure"){
-                    addItem(Generator.generateTreasure())
-                    return true
-                }
-            }
-        }
-        println("item:"+recipe.item.stack)
-        addItem(recipe.item)
-        return true
-    }
-}

ShakeAndCraft/app/src/main/java/com/example/shakecraft/model/Player.kt

@@ -17,9 +17,10 @@ class Player() {
     var xp: Int = 0
     @ColumnInfo(name = "image")
     val image: Int = R.drawable.player_image
-    @ColumnInfo(index = true)
+    @ColumnInfo(name = "rank")
     var rank: String = "Beginner"
-    val inventory: Inventory= Inventory()
+    //@ColumnInfo(name = "items") Je ne sais pas comment faire pour stocker la liste dans la BDD
+    var items: MutableList<Item> = mutableListOf()
 
 
     fun changeRank(){
@@ -37,7 +38,6 @@ class Player() {
         }
     }
 
-
     fun gainXp(xp: Int) {
         this.xp += xp
         if (this.xp >= this.level *100){
@@ -47,4 +47,44 @@ class Player() {
         }
     }
 
+    fun addItem(item: Item) {
+        val findItem = items.find { it.type.name == item.type.name }
+
+        if(findItem!= null){
+            println("findItem n: "+findItem.stack+" item nb:"+item.stack)
+            findItem.stack += item.stack
+        }
+        else{items.add(Item(type = item.type, stack = item.stack))}
+    }
+
+    fun hasItem(item: Item) : Boolean{
+        for (playerItem in items){
+            if(playerItem.type.name == item.type.name && playerItem.stack >= item.stack){
+                return true
+            }
+        }
+        return false
+    }
+
+
+    fun craft(recipe: Recipe) : Boolean{
+        println("test")
+        for (ingredient in recipe.ingredients) {
+            val searchedItem = items.find { it.type.name == ingredient.type.name }
+            if(searchedItem != null) {
+                searchedItem.stack -= ingredient.stack
+                if (searchedItem.stack == 0){
+                    items.remove(searchedItem)
+                }
+                println(ingredient.type.name)
+                if (recipe.item.type.name == "Open Treasure"){
+                    addItem(Generator.generateTreasure())
+                    return true
+                }
+            }
+        }
+        println("item:"+recipe.item.stack)
+        addItem(recipe.item)
+        return true
+    }
 }

ShakeAndCraft/app/src/main/java/com/example/shakecraft/model/RecipeManager.kt

@@ -64,27 +64,23 @@ class RecipeManager {
         )
 
 
-
+        fun isCraftable(recipe: Recipe, player :Player): Boolean{
-
-
-
-        fun isCraftable(recipe: Recipe, inventory: Inventory): Boolean{
             for (ingredient in recipe.ingredients) {
-                if (!inventory.hasItem(ingredient)) {
+                if (!player.hasItem(ingredient)) {
                     return false
                 }
             }
             return true
         }
 
-        fun HowManyCraftable(recipe: Recipe, inventory: Inventory): Int{
+        fun HowManyCraftable(recipe: Recipe, player : Player): Int{
             val divisedList = mutableListOf<Int>()
-            if(isCraftable(recipe,inventory)==false)
+            if(!isCraftable(recipe,player))
                 return 0
             else{
                 for(element in recipe.ingredients){
                     println("cc")
-                    val itemSearch = inventory.items.find { it.type.name == element.type.name }
+                    val itemSearch = player.items.find { it.type.name == element.type.name }
                     if(itemSearch!= null)
                         divisedList.add(itemSearch.stack / element.stack)
                 }