Add report abuse, mute, ban and black mark systems (#1041)

* feat: add report abuse, mute, ban and black mark systems

* chore: clean up pass

* feat: add black marks on mute and ban

Mutes add one black mark, bans two (including offline bans), so
punishments accumulate toward the permanent punishment limit.
Report-issued mutes record the rule broken.

* fix: ban adds a single black mark

Appending two identical marks in the same millisecond caused
duplicate entries to be dropped.

* fix: register Reports in Koin module

ReportAbuse script injected Reports but no single was bound,
causing NoDefinitionFoundException at startup.

* Update game/src/main/kotlin/content/social/report/Mute.kt

Co-authored-by: Greg <GregHib@users.noreply.github.com>

* refactor: store punishments as epoch seconds

Longs aren't supported by the variable format system; sub-second
precision isn't needed for mutes, bans, black marks or reports.
Switch them to epoch seconds (Int), with PERMANENT as Int.MAX_VALUE.
Chat message evidence keeps millisecond precision.

* refactor: rename permban command to perm_ban for consistency

* Fix type mismatch on time

* Stop force logout from reconnecting

---------

Co-authored-by: Greg <GregHib@users.noreply.github.com>
Co-authored-by: Ebp90 <40249395+Ebp90@users.noreply.github.com>

Author: 3 people

data/entity/player/dialogue/dialogue.ifaces.toml

@@ -258,6 +258,9 @@ id = 5
 [.close_quick_chat]
 id = 4
 
+[.chat_line0]
+id = "180-279"
+
 [dialogue_select2_models]
 id = 140
 type = "dialogue_box"

data/entity/player/modal/chat_box/chat_box.ifaces.toml

@@ -34,3 +34,6 @@ type = "chat_box"
 id = 754
 type = "private_chat"
 
+[.line1]
+id = "1-5"
+

data/social/report/report.ifaces.toml

@@ -13,3 +13,12 @@ id = 110
 [report_abuse]
 id = 594
 
+[.mute_confirm]
+id = 8
+
+[.mute_entry]
+id = 52
+
+[.mute_select]
+id = 66
+

data/social/report/report.vars.toml

@@ -0,0 +1,10 @@
+[muted_until]
+format = "int"
+persist = true
+
+[banned_until]
+format = "int"
+persist = true
+
+[black_marks]
+persist = true

database/src/main/kotlin/world/gregs/voidps/storage/DatabaseStorage.kt

@@ -5,6 +5,7 @@ import com.zaxxer.hikari.HikariDataSource
 import org.jetbrains.exposed.sql.*
 import org.jetbrains.exposed.sql.SqlExpressionBuilder.inList
 import org.jetbrains.exposed.sql.transactions.transaction
+import world.gregs.voidps.engine.data.AbuseReport
 import world.gregs.voidps.engine.data.PlayerSave
 import world.gregs.voidps.engine.data.Storage
 import world.gregs.voidps.engine.data.config.AccountDefinition
@@ -200,6 +201,19 @@ class DatabaseStorage : Storage {
         saveHistories(accounts, playerIds)
     }
 
+    override fun saveReport(report: AbuseReport): Unit = transaction {
+        ReportsTable.insert {
+            it[reporter] = report.reporter
+            it[reported] = report.reported
+            it[rule] = report.rule
+            it[ruleName] = report.ruleName
+            it[mute] = report.mute
+            it[suggestion] = report.suggestion
+            it[time] = report.time
+            it[evidence] = report.evidence
+        }
+    }
+
     override fun exists(accountName: String): Boolean = transaction {
         val lower = accountName.lowercase()
         AccountsTable
@@ -565,7 +579,7 @@ class DatabaseStorage : Storage {
             }
         }
 
-        internal val tables = arrayOf(AccountsTable, ExperienceTable, LevelsTable, VariablesTable, InventoriesTable, OffersTable, ActiveOffersTable, PlayerHistoryTable, ClaimsTable, ItemHistoryTable)
+        internal val tables = arrayOf(AccountsTable, ExperienceTable, LevelsTable, VariablesTable, InventoriesTable, OffersTable, ActiveOffersTable, PlayerHistoryTable, ClaimsTable, ItemHistoryTable, ReportsTable)
 
         private const val TYPE_STRING = 0.toByte()
         private const val TYPE_INT = 1.toByte()

database/src/main/kotlin/world/gregs/voidps/storage/Tables.kt

@@ -157,6 +157,20 @@ internal object ClaimsTable : Table("grand_exchange_claims") {
     val coins = integer("coins")
 }
 
+internal object ReportsTable : Table("abuse_reports") {
+    val id = integer("id").autoIncrement().uniqueIndex()
+    val reporter = varchar("reporter", 12)
+    val reported = text("reported")
+    val rule = integer("rule")
+    val ruleName = text("rule_name")
+    val mute = bool("mute")
+    val suggestion = text("suggestion")
+    val time = integer("time")
+    val evidence = array<String>("evidence")
+
+    override val primaryKey = PrimaryKey(id, name = "pk_report_id")
+}
+
 internal object ItemHistoryTable : Table("grand_exchange_item_history") {
     val item = text("item")
     val timestamp = long("timestamp")

database/src/test/kotlin/world/gregs/voidps/storage/DatabaseStorageTest.kt

@@ -5,11 +5,41 @@ import org.jetbrains.exposed.sql.selectAll
 import org.jetbrains.exposed.sql.transactions.transaction
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
+import world.gregs.voidps.engine.data.AbuseReport
+import kotlin.test.assertEquals
 
 class DatabaseStorageTest : StorageTest(), DatabaseTest {
 
     override val storage = DatabaseStorage()
 
+    @Test
+    fun `Store an abuse report`() {
+        val report = AbuseReport(
+            reporter = "mod_steve",
+            reported = "Durial321",
+            rule = 6,
+            ruleName = "Macroing",
+            mute = true,
+            suggestion = "extra info",
+            time = 1234567890,
+            evidence = listOf("[00:00:01] public: free armour trimming", "[00:00:02] public: selling gf"),
+        )
+
+        storage.saveReport(report)
+
+        transaction {
+            val row = ReportsTable.selectAll().single()
+            assertEquals(report.reporter, row[ReportsTable.reporter])
+            assertEquals(report.reported, row[ReportsTable.reported])
+            assertEquals(report.rule, row[ReportsTable.rule])
+            assertEquals(report.ruleName, row[ReportsTable.ruleName])
+            assertEquals(report.mute, row[ReportsTable.mute])
+            assertEquals(report.suggestion, row[ReportsTable.suggestion])
+            assertEquals(report.time, row[ReportsTable.time])
+            assertEquals(report.evidence, row[ReportsTable.evidence])
+        }
+    }
+
     @Test
     fun `Saving variable with invalid format throws exception`() {
         assertThrows<IllegalArgumentException> {

engine/src/main/kotlin/world/gregs/voidps/engine/client/PlayerAccountLoader.kt

@@ -55,7 +55,12 @@ class PlayerAccountLoader(
                 client.disconnect(Response.GAME_UPDATE)
                 return null
             }
-            var player = storage.load(username)?.toPlayer()
+            val save = storage.load(username)
+            if (save != null && banned(save.variables)) {
+                client.disconnect(Response.ACCOUNT_DISABLED)
+                return null
+            }
+            var player = save?.toPlayer()
             if (player == null) {
                 if (!Settings["development.accountCreation", false]) {
                     client.disconnect(Response.INVALID_CREDENTIALS)
@@ -73,6 +78,11 @@ class PlayerAccountLoader(
         }
     }
 
+    private fun banned(variables: Map<String, Any>): Boolean {
+        val until = (variables["banned_until"] as? Number)?.toInt() ?: return false
+        return until > (System.currentTimeMillis() / 1000).toInt()
+    }
+
     suspend fun connect(player: Player, client: Client, displayMode: Int = 0, viewport: Boolean = true) {
         if (!accounts.setup(player, client, displayMode, viewport)) {
             logger.warn { "Error setting up account" }

engine/src/main/kotlin/world/gregs/voidps/engine/client/instruction/InstructionHandlers.kt

@@ -50,6 +50,7 @@ class InstructionHandlers(
     var chatTypeChangeHandler: ChatTypeChange.(Player) -> Unit = empty()
     var clanChatKickHandler: ClanChatKick.(Player) -> Unit = empty()
     var clanChatRankHandler: ClanChatRank.(Player) -> Unit = empty()
+    var reportAbuseHandler: ReportAbuse.(Player) -> Unit = empty()
 
     private fun <I : Instruction> empty(): I.(Player) -> Unit {
         val logger = InlineLogger("InstructionHandler")
@@ -98,6 +99,7 @@ class InstructionHandlers(
             is ChatTypeChange -> chatTypeChangeHandler.invoke(instruction, player)
             is ClanChatKick -> clanChatKickHandler.invoke(instruction, player)
             is ClanChatRank -> clanChatRankHandler.invoke(instruction, player)
+            is ReportAbuse -> reportAbuseHandler.invoke(instruction, player)
             is SongEnd -> songEndHandler.invoke(instruction, player)
             else -> return false
         }
@@ -132,6 +134,7 @@ inline fun <reified I : Instruction> instruction(noinline handler: I.(Player) ->
         ChatTypeChange::class -> get<InstructionHandlers>().chatTypeChangeHandler = handler as ChatTypeChange.(Player) -> Unit
         ClanChatKick::class -> get<InstructionHandlers>().clanChatKickHandler = handler as ClanChatKick.(Player) -> Unit
         ClanChatRank::class -> get<InstructionHandlers>().clanChatRankHandler = handler as ClanChatRank.(Player) -> Unit
+        ReportAbuse::class -> get<InstructionHandlers>().reportAbuseHandler = handler as ReportAbuse.(Player) -> Unit
         else -> throw UnsupportedOperationException("Unknown Instruction type: ${I::class}")
     }
 }

engine/src/main/kotlin/world/gregs/voidps/engine/data/AbuseReport.kt

@@ -0,0 +1,23 @@
+package world.gregs.voidps.engine.data
+
+/**
+ * A player submitted report about another player breaking a rule
+ * @param reporter Account name of the player filing the report
+ * @param reported Display name of the accused player as submitted
+ * @param rule Identifier of the rule broken
+ * @param ruleName Readable name of the rule broken
+ * @param mute Whether a moderator requested the accused be muted
+ * @param suggestion Additional text submitted with the report
+ * @param time Epoch second timestamp the report was received
+ * @param evidence Recent chat messages sent by the accused player
+ */
+data class AbuseReport(
+    val reporter: String,
+    val reported: String,
+    val rule: Int,
+    val ruleName: String,
+    val mute: Boolean,
+    val suggestion: String,
+    val time: Int,
+    val evidence: List<String>,
+)