[AN-HACKATON] 해커톤 작업한거 develop 에 머지

android/app/src/main/AndroidManifest.xml

@@ -3,7 +3,7 @@
     xmlns:tools="http://schemas.android.com/tools">
 
     <uses-permission android:name="android.permission.INTERNET" />
-    <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
 
     <application
         android:name=".PokeRogueHelperApp"
@@ -12,10 +12,13 @@
         android:fullBackupContent="@xml/backup_rules"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
-        android:roundIcon="@mipmap/ic_launcher_round"
+        android:roundIcon="@mipmap/ic_poke_icon"
         android:supportsRtl="true"
         android:theme="@style/Theme.PokeRogueHelper"
         tools:targetApi="31">
+        <activity
+            android:name=".presentation.poketmon2.PokemonActivity"
+            android:exported="true" />
         <activity
             android:name=".presentation.home.HomeActivity"
             android:exported="true">
@@ -28,6 +31,14 @@
         <activity
             android:name=".presentation.type.TypeActivity"
             android:exported="false" />
+
+        <activity
+            android:name=".presentation.ability.AbilityActivity"
+            android:exported="false" />
+
+        <activity
+            android:name=".presentation.ability.detail.AbilityDetailActivity"
+            android:exported="false" />
     </application>
 
 </manifest>

android/app/src/main/java/poke/rogue/helper/data/datasource/LocalTypeDataSource.kt

@@ -0,0 +1,38 @@
+package poke.rogue.helper.data.datasource
+
+import poke.rogue.helper.data.model.TypeMatchedResult
+import poke.rogue.helper.local.DummyTypeData
+
+class LocalTypeDataSource(private val typeData: DummyTypeData = DummyTypeData) {
+    fun findAllTypesAgainstAttackingType(attackingTypeId: Int): List<TypeMatchedResult> {
+        val allResult = typeData.typeMatchedTable[attackingTypeId]
+        val resultMap = allResult.withIndex().groupBy({ it.value }, { typeData.allTypes[it.index] })
+        val result =
+            resultMap.entries.map {
+                    (matchedResult, types) ->
+                TypeMatchedResult(matchedResult, types)
+            }
+        return result
+    }
+
+    fun findAllTypesAgainstDefendingType(defendingTypeId: Int): List<TypeMatchedResult> {
+        val allResult = typeData.typeMatchedTable.map { it[defendingTypeId] }
+        val resultMap = allResult.withIndex().groupBy({ it.value }, { typeData.allTypes[it.index] })
+        val result =
+            resultMap.entries.map {
+                    (matchedResult, types) ->
+                TypeMatchedResult(matchedResult, types)
+            }
+        return result
+    }
+
+    fun findMatchedTypeResult(
+        attackingTypeId: Int,
+        defendingTypeId: Int,
+    ): TypeMatchedResult {
+        return TypeMatchedResult(
+            typeData.typeMatchedTable[attackingTypeId][defendingTypeId],
+            listOf(typeData.allTypes.get(defendingTypeId)),
+        )
+    }
+}

android/app/src/main/java/poke/rogue/helper/data/model/TypeMatchedResult.kt

@@ -0,0 +1,3 @@
+package poke.rogue.helper.data.model
+
+data class TypeMatchedResult(val matchedResult: MatchedResult, val types: List<TypeInfo>)

android/app/src/main/java/poke/rogue/helper/data/repository/TypeRepository.kt

@@ -0,0 +1,26 @@
+package poke.rogue.helper.data.repository
+
+import poke.rogue.helper.data.datasource.LocalTypeDataSource
+import poke.rogue.helper.data.model.MatchedResult
+import poke.rogue.helper.data.model.TypeMatchedResult
+
+class TypeRepository(private val localTypeDataSource: LocalTypeDataSource) {
+    fun findResultAgainstMyType(myTypeId: Int): List<TypeMatchedResult> {
+        return localTypeDataSource.findAllTypesAgainstAttackingType(myTypeId)
+            .filter { it.matchedResult != MatchedResult.NORMAL }
+    }
+
+    fun findResultAgainstOpponent(opponentTypeId: Int): List<TypeMatchedResult> {
+        return localTypeDataSource.findAllTypesAgainstDefendingType(opponentTypeId)
+            .filter { it.matchedResult != MatchedResult.NORMAL }
+    }
+
+    fun findMatchedResult(
+        myTypeId: Int,
+        opponentTypeIds: List<Int>,
+    ): List<TypeMatchedResult> {
+        return opponentTypeIds.map {
+            localTypeDataSource.findMatchedTypeResult(myTypeId, it)
+        }.filter { it.matchedResult != MatchedResult.NORMAL }
+    }
+}