feat: Add NP/Star Conditions, Update Target Dialog, and Skill Priority Drag-Sort on Spam Screen

app/src/main/java/io/github/fate_grand_automata/imaging/DroidCvPattern.kt

@@ -1,6 +1,8 @@
 package io.github.fate_grand_automata.imaging
 
 import android.graphics.Bitmap
+import io.github.lib_automata.Axis
+import io.github.lib_automata.Hsv
 import io.github.lib_automata.Match
 import io.github.lib_automata.Pattern
 import io.github.lib_automata.Region
@@ -200,6 +202,98 @@ class DroidCvPattern(
         return DroidCvPattern(mask)
     }
 
+    override fun getAverageBrightness(): Double {
+        return if (mat.channels() == 3) {
+            Mat().use { gray ->
+                Imgproc.cvtColor(mat, gray, Imgproc.COLOR_BGR2GRAY)
+                Core.mean(gray).`val`[0]
+            }
+        } else {
+            Core.mean(mat).`val`[0]
+        }
+    }
+
+    override fun getMinMaxBrightness(): Pair<Double, Double> {
+        return if (mat.channels() == 3) {
+            Mat().use { gray ->
+                Imgproc.cvtColor(mat, gray, Imgproc.COLOR_BGR2GRAY)
+                val minMax = Core.minMaxLoc(gray)
+                Pair(minMax.minVal, minMax.maxVal)
+            }
+        } else {
+            val minMax = Core.minMaxLoc(mat)
+            Pair(minMax.minVal, minMax.maxVal)
+        }
+    }
+
+
+    override fun isSaturationAndValueOver(sThresh: Double, vThresh: Double): Boolean {
+        Mat().use { hsv ->
+            Imgproc.cvtColor(mat, hsv, Imgproc.COLOR_BGR2HSV)
+            val mean = Core.mean(hsv)
+            val meanS = mean.`val`[1]
+            val meanV = mean.`val`[2]
+            return meanS >= sThresh && meanV >= vThresh
+        }
+    }
+    private fun Hsv.scalar() = Scalar(h, s, v)
+
+    override fun getHsvAverage(): Hsv =
+        Mat().use { hsv ->
+            Imgproc.cvtColor(mat, hsv, Imgproc.COLOR_BGR2HSV)
+            Core.mean(hsv).`val`.let { (h, s, v, _) ->
+                Hsv(h, s, v)
+            }
+        }
+
+    override fun normalizeByHsv(lower: Hsv, upper: Hsv, invert: Boolean): Pattern {
+        val normalized = Mat().also { resultMat ->
+            Mat().use { maskMat ->
+                Imgproc.cvtColor(mat, maskMat, Imgproc.COLOR_BGR2HSV)
+                Core.inRange(maskMat, lower.scalar(), upper.scalar(), maskMat)
+                Core.bitwise_and(mat, mat, resultMat, maskMat)
+            }
+
+            Imgproc.cvtColor(resultMat, resultMat, Imgproc.COLOR_BGR2GRAY)
+            Imgproc.threshold(
+                resultMat,
+                resultMat,
+                0.0,
+                255.0,
+                Imgproc.THRESH_BINARY + Imgproc.THRESH_OTSU)
+
+            if (invert) {
+                Core.bitwise_not(resultMat, resultMat)
+            }
+        }
+
+        return DroidCvPattern(normalized, tag = tag)
+    }
+
+    override fun cropWhiteRegion(
+        pad: Int
+    ): Pattern = Mat().use { coords ->
+        Core.bitwise_not(mat, coords)
+
+        // If no non-zero pixels, return the full binary image
+        if (coords.empty()) {
+            return this
+        }
+
+        val rect = Imgproc.boundingRect(coords)
+
+        val xStart = maxOf(rect.x - pad, 0)
+        val yStart = maxOf(rect.y - pad, 0)
+        val xEnd = minOf(rect.x + rect.width + pad, mat.cols())
+        val yEnd = minOf(rect.y + rect.height + pad, mat.rows())
+
+        // Crop to ROI and return as DroidCvPattern
+        DroidCvPattern(
+            mat.submat(Rect(xStart, yStart, xEnd - xStart, yEnd - yStart)).clone(),
+            tag = tag
+        )
+    }
+
     /**
      * Flood fills the mat.
      */
@@ -259,4 +353,51 @@ class DroidCvPattern(
         }
         return holePoints
     }
+
+    override fun countPixelsInHsvRange(
+        lower: Hsv,
+        upper: Hsv,
+        axis: Axis
+    ): Int {
+        val gray = Mat()
+        val mask = Mat()
+        val hsvMat = Mat()
+        try {
+            Imgproc.cvtColor(mat, hsvMat, Imgproc.COLOR_BGR2HSV)
+            Core.inRange(hsvMat, lower.scalar(), upper.scalar(), mask)
+            Core.bitwise_and(mat, mat, gray, mask)
+
+            Imgproc.cvtColor(gray, gray, Imgproc.COLOR_BGR2GRAY)
+            Imgproc.threshold(
+                gray, gray,
+                0.0, 255.0,
+                Imgproc.THRESH_BINARY + Imgproc.THRESH_OTSU
+            )
+
+            return when (axis) {
+                Axis.HORIZONTAL -> {
+                    var count = 0
+                    for (x in 0 until gray.cols()) {
+                        val col = gray.col(x)
+                        if (Core.countNonZero(col) > 0) count++
+                        col.release()
+                    }
+                    count
+                }
+                Axis.VERTICAL -> {
+                    var count = 0
+                    for (y in 0 until gray.rows()) {
+                        val row = gray.row(y)
+                        if (Core.countNonZero(row) > 0) count++
+                        row.release()
+                    }
+                    count
+                }
+            }
+        } finally {
+            gray.release()
+            mask.release()
+            hsvMat.release()
+        }
+    }
 }

app/src/main/java/io/github/fate_grand_automata/imaging/TesseractOcrService.kt

@@ -36,6 +36,37 @@ class TesseractOcrService @Inject constructor(
         }
     }
 
+    override fun detectNumberInBrackets(pattern: Pattern): String {
+        synchronized(tessApi) {
+            (pattern as DroidCvPattern).asBitmap().use { bmp ->
+                tessApi.setPageSegMode(TessBaseAPI.PageSegMode.PSM_SINGLE_WORD) // PSM 8
+                tessApi.setVariable(TessBaseAPI.VAR_CHAR_WHITELIST, "0123456789(){}AO")
+                tessApi.setImage(bmp)
+                val rawText = tessApi.utF8Text
+                tessApi.clear()
+
+                val normalized = buildString(rawText.length) {
+                    for (c in rawText) {
+                        append(
+                            when (c) {
+                                '{' -> '('
+                                '}' -> ')'
+                                'A' -> '4'
+                                'O' -> '0'
+                                else -> c
+                            }
+                        )
+                    }
+                }
+
+                val regex = Regex("""\(\s*[\d\s]+\s*\)""")
+                val match = regex.find(normalized) ?: return ""
+                val digitsOnly = match.value.replace("""[()\s]""".toRegex(), "")
+                return digitsOnly
+            }
+        }
+    }
+
     protected fun finalize() {
         tessApi.recycle()
     }

app/src/main/java/io/github/fate_grand_automata/ui/battle_config_item/BattleConfigScreen.kt

@@ -214,7 +214,7 @@ private fun BattleConfigContent(
                                     contentAlignment = Alignment.Center
                                 ) {
                                     Text(
-                                        stringResource(R.string.p_spam_spam).uppercase(),
+                                        stringResource(R.string.spam_short).uppercase(),
                                         style = MaterialTheme.typography.bodySmall,
                                         modifier = Modifier
                                             .padding(16.dp, 5.dp)

app/src/main/java/io/github/fate_grand_automata/ui/drag_sort/DragSortAdapter.kt

@@ -13,31 +13,21 @@ import io.github.fate_grand_automata.R
 import io.github.fate_grand_automata.util.IItemTouchHelperAdapter
 import io.github.fate_grand_automata.util.IItemTouchHelperViewHolder
 
-class DragSortAdapter<T>(
-    private val items: MutableList<T>,
-    private val viewConfigGrabber: (T) -> ItemViewConfig
-) : RecyclerView.Adapter<DragSortAdapter.ViewHolder>(), IItemTouchHelperAdapter {
-    class ItemViewConfig(
-        @ColorInt val foregroundColor: Int,
-        @ColorInt val backgroundColor: Int,
-        val text: String
-    )
-
-    class ViewHolder(ItemView: View) : RecyclerView.ViewHolder(ItemView),
-        IItemTouchHelperViewHolder {
-        val textView: TextView = ItemView.findViewById(R.id.drag_sort_text)
-
+abstract class DragSortAdapterBase<T>(
+    protected val items: MutableList<T> = mutableListOf()
+) : RecyclerView.Adapter<DragSortAdapterBase.ViewHolder>(), IItemTouchHelperAdapter {
+    class ViewHolder(val containerView: View) :
+        RecyclerView.ViewHolder(containerView), IItemTouchHelperViewHolder {
         override fun onItemSelected() {}
-
         override fun onItemClear() {}
     }
 
     lateinit var itemTouchHelper: ItemTouchHelper
 
     @SuppressLint("ClickableViewAccessibility")
     override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
-        val view = LayoutInflater.from(parent.context)
-            .inflate(R.layout.drag_sort_item, parent, false)
+        val layout = getLayoutResId()
+        val view = LayoutInflater.from(parent.context).inflate(layout, parent, false)
 
         return ViewHolder(view).also { holder ->
             view.setOnTouchListener { _, event ->
@@ -49,21 +39,59 @@ class DragSortAdapter<T>(
         }
     }
 
+    private var prevSize = items.size
+
+    fun refreshIfDataChanged() {
+        if (prevSize != items.size) {
+            prevSize = items.size
+            notifyDataSetChanged()
+        }
+    }
+
     override fun getItemCount() = items.size
 
+    override fun onItemMove(From: Int, To: Int) {
+        items.slide(From, To)
+        notifyItemMoved(From, To)
+    }
+
+    abstract fun getLayoutResId(): Int
+    abstract override fun onBindViewHolder(holder: ViewHolder, position: Int)
+}
+
+class DragSortAdapter<T>(
+    items: MutableList<T>,
+    private val viewConfigGrabber: (T) -> ItemViewConfig
+) : DragSortAdapterBase<T>(items) {
+    class ItemViewConfig(
+        @ColorInt val foregroundColor: Int,
+        @ColorInt val backgroundColor: Int,
+        val text: String
+    )
+
+    override fun getLayoutResId() = R.layout.drag_sort_item
+
     override fun onBindViewHolder(holder: ViewHolder, position: Int) {
         val viewConfig = viewConfigGrabber(items[position])
 
-        holder.textView.text = viewConfig.text
+        val textView = holder.itemView.findViewById<TextView>(R.id.drag_sort_text)
+        textView.text = viewConfig.text
+        textView.setTextColor(viewConfig.foregroundColor)
         holder.itemView.setBackgroundColor(viewConfig.backgroundColor)
-        holder.textView.setTextColor(viewConfig.foregroundColor)
     }
+}
 
-    override fun onItemMove(From: Int, To: Int) {
-        val temp = items[From]
-        items[From] = items[To]
-        items[To] = temp
+private fun <T> MutableList<T>.slide(from: Int, to: Int) {
+    val item = this[from]
 
-        notifyItemMoved(From, To)
+    if (from < to) {
+        for (i in from until to) {
+            this[i] = this[i + 1]
+        }
+    } else {
+        for (i in from downTo to + 1) {
+            this[i] = this[i - 1]
+        }
     }
+    this[to] = item
 }

app/src/main/java/io/github/fate_grand_automata/ui/highlight/HighlightManager.kt

@@ -9,13 +9,15 @@ import io.github.lib_automata.HighlightColor
 import io.github.lib_automata.Region
 import javax.inject.Inject
 
+data class HighlightItem(val color: HighlightColor, val text: String? = null)
+
 @ServiceScoped
 class HighlightManager @Inject constructor() {
     private val tapperService by lazy {
         TapperService.instance ?: throw IllegalStateException("Accessibility service not running")
     }
 
-    private val regionsToHighlight = mutableMapOf<Region, HighlightColor>()
+    private val regionsToHighlight = mutableMapOf<Region, HighlightItem>()
 
     private val highlightView by lazy {
         HighlightView(tapperService, regionsToHighlight)
@@ -45,9 +47,9 @@ class HighlightManager @Inject constructor() {
         accessibilityWindowManager.removeView(highlightView)
     }
 
-    fun add(region: Region, color: HighlightColor) {
+    fun add(region: Region, color: HighlightColor, text: String?) {
         highlightView.post {
-            regionsToHighlight[region] = color
+            regionsToHighlight[region] = HighlightItem(color, text)
 
             highlightView.invalidate()
         }