Download maps from inventory too and folder name convention

Author: Avanatiker

src/main/kotlin/com/lambda/client/module/modules/misc/MapDownloader.kt

@@ -1,10 +1,13 @@
 package com.lambda.client.module.modules.misc
 
+import com.lambda.client.LambdaMod
 import com.lambda.client.event.SafeClientEvent
 import com.lambda.client.module.Category
 import com.lambda.client.module.Module
+import com.lambda.client.util.FolderUtils
 import com.lambda.client.util.TickTimer
 import com.lambda.client.util.TimeUnit
+import com.lambda.client.util.items.inventorySlots
 import com.lambda.client.util.text.MessageSendHelper
 import com.lambda.client.util.threads.defaultScope
 import com.lambda.client.util.threads.runSafe
@@ -25,59 +28,73 @@ import java.security.MessageDigest
 import javax.imageio.ImageIO
 
 internal object MapDownloader : Module(
-    name = "Map Downloader",
+    name = "MapDownloader",
     category = Category.MISC,
     description = "Downloads maps in item frames in your render distance to file."
 ) {
 
-    private var scale by setting("Scale", 1, 1..20, 1)
-    private var saveDelay by setting("Save delay", 0.2, 0.1..2.0, 0.1)
+    private val scale by setting("Scale", 1, 1..20, 1, description = "Higher scale results in higher storage use!")
+    private val saveMapsFromEntity by setting("Save maps from entity", true)
+    private val saveMapsFromInventory by setting("Save maps from inventory", true, description = "When rendering a new map it will save one image for every map update!")
+    private val saveDelay by setting("Save delay", 0.2, 0.1..2.0, 0.1, unit = " s")
+    private val openImageFolder = setting("Open Image Folder...", false)
     private val pendingHashes = mutableSetOf<String>()
     private var existingHashes = mutableSetOf<String>()
-    private var pendingTasks = mutableSetOf<Triple<MapData, String, Int>>()
-    private val mapPath = "mapImages${File.separator}"
+    private var pendingTasks = mutableSetOf<MapInfo>()
     private val secTimer = TickTimer(TimeUnit.SECONDS)
     private val milliSecTimer = TickTimer(TimeUnit.MILLISECONDS)
 
     init {
-        val directory = File(mapPath)
-        if (!directory.exists()) {
-            directory.mkdir()
-        }
-
         existingHashes = getExistingHashes()
 
         safeListener<TickEvent.ClientTickEvent> {
-            if (it.phase == TickEvent.Phase.START) {
-                if (secTimer.tick(10)) existingHashes = getExistingHashes()
-                if (pendingTasks.isNotEmpty()
-                    && milliSecTimer.tick((saveDelay * 1000).toInt())) {
-                    pendingTasks.firstOrNull()?.let { triple ->
-                        defaultScope.launch {
-                            runSafe {
-                                renderAndSaveMapImage(triple.first, triple.second, triple.third)
-                            }
+            if (it.phase != TickEvent.Phase.START) return@safeListener
+
+            if (secTimer.tick(10)) existingHashes = getExistingHashes()
+
+            if (pendingTasks.isNotEmpty()
+                && milliSecTimer.tick((saveDelay * 1000).toInt())
+            ) {
+                val directory = File(FolderUtils.mapImagesFolder)
+                if (!directory.exists()) {
+                    directory.mkdir()
+                }
+
+                pendingTasks.firstOrNull()?.let { mapInfo ->
+                    defaultScope.launch {
+                        runSafe {
+                            renderAndSaveMapImage(mapInfo)
+                            LambdaMod.LOG.info("Saved map - name: ${mapInfo.name} id: ${mapInfo.id}")
                         }
-                        pendingTasks.remove(triple)
                     }
+                    pendingTasks.remove(mapInfo)
                 }
-
-                getMaps()
             }
+
+            getMaps()
+        }
+
+        openImageFolder.consumers.add { _, it ->
+            if (it) FolderUtils.openFolder(FolderUtils.mapImagesFolder)
+            false
         }
     }
 
     private fun getExistingHashes(): MutableSet<String> {
         val alreadyConverted = mutableSetOf<String>()
 
-        File(mapPath).walk().filter {
+        File(FolderUtils.mapImagesFolder).walk().filter {
             it.name.endsWith(".png")
         }.forEach { file ->
             val nameArr = file.name.split("_")
             if (nameArr.isNotEmpty()) {
                 alreadyConverted.add(nameArr[0])
             }
         }
+
+        // to exclude the empty map
+        alreadyConverted.add("ce338fe6899778aacfc28414f2d9498b")
+
         return alreadyConverted
     }
 
@@ -91,27 +108,39 @@ internal object MapDownloader : Module(
     }
 
     private fun SafeClientEvent.getMaps() {
-        world.loadedEntityList
+        if (saveMapsFromEntity) world.loadedEntityList
             .filterIsInstance<EntityItemFrame>()
             .filter { it.displayedItem.item == Items.FILLED_MAP }
             .forEach {
                 (it.displayedItem.item as ItemMap).getMapData(it.displayedItem, world)?.let { mapData ->
-                    MessageDigest.getInstance("MD5")?.let { md ->
-                        val hash = md.digest(mapData.colors).toHex()
+                    handleMap(mapData, it.displayedItem.displayName, it.displayedItem.itemDamage)
+                }
+            }
 
-                        if (!existingHashes.contains(hash) && !pendingHashes.contains(hash)) {
-                            pendingHashes.add(hash)
-                            pendingTasks.add(Triple(mapData, hash, it.displayedItem.itemDamage))
-                        }
-                    } ?: run {
-                        MessageSendHelper.sendChatMessage("$chatName Can't find MD5 instance.")
-                        disable()
-                    }
+        if (saveMapsFromInventory) player.inventorySlots.forEach {
+            if (it.stack.item is ItemMap) {
+                (it.stack.item as ItemMap).getMapData(it.stack, world)?.let { mapData ->
+                    handleMap(mapData, it.stack.displayName, it.stack.itemDamage)
                 }
             }
+        }
+    }
+
+    private fun handleMap(data: MapData, name: String, id: Int) {
+        MessageDigest.getInstance("MD5")?.let { md ->
+            val hash = md.digest(data.colors).toHex()
+
+            if (!existingHashes.contains(hash) && !pendingHashes.contains(hash)) {
+                pendingHashes.add(hash)
+                pendingTasks.add(MapInfo(data, name, id, hash))
+            }
+        } ?: run {
+            MessageSendHelper.sendChatMessage("$chatName Can't find MD5 instance.")
+            disable()
+        }
     }
 
-    private fun SafeClientEvent.renderAndSaveMapImage(mapData: MapData, hash: String, mapID: Int) {
+    private fun SafeClientEvent.renderAndSaveMapImage(mapInfo: MapInfo) {
         val finalSize = 128 * scale
 
         var countPos = 0
@@ -122,15 +151,17 @@ internal object MapDownloader : Module(
 
         repeat(128) { i ->
             repeat(128) { j ->
-                mapData.colors[countPos].toUByte().let { mapColor(it).let { it1 -> img.setRGB(j, i, it1.rgb) } }
+                mapInfo.data.colors[countPos].toUByte().let {
+                    mapColor(it).let { color -> img.setRGB(j, i, color.rgb) }
+                }
                 countPos++
             }
         }
 
         try {
             val resized = BufferedImage(finalSize, finalSize, img.type)
             val g = resized.createGraphics()
-            val loc = "${mapPath}${hash}_id_${mapID}_server_${player.connection.networkManager.remoteAddress.toString().split('/')[0]?:"local"}.png"
+            val loc = "${FolderUtils.mapImagesFolder}${mapInfo.hash}_name_${mapInfo.name.replace(File.separator, "")}_id_${mapInfo.id}_${if (mc.isIntegratedServerRunning) "local" else "server_${player.connection.networkManager.remoteAddress.toString().replace("/", "_").replace(":", "_")}"}.png"
             g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
                 RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR)
             g.drawImage(img, 0, 0, finalSize, finalSize, 0, 0, img.width,
@@ -141,9 +172,11 @@ internal object MapDownloader : Module(
             ex.printStackTrace()
         }
 
-        pendingHashes.remove(hash)
-        existingHashes.add(hash)
+        pendingHashes.remove(mapInfo.hash)
+        existingHashes.add(mapInfo.hash)
     }
 
     private fun ByteArray.toHex(): String = joinToString(separator = "") { eachByte -> "%02x".format(eachByte) }
+
+    data class MapInfo(val data: MapData, val name: String, val id: Int, val hash: String)
 }

src/main/kotlin/com/lambda/client/module/modules/player/PacketLogger.kt

@@ -8,6 +8,7 @@ import com.lambda.client.event.listener.listener
 import com.lambda.client.mixin.extension.*
 import com.lambda.client.module.Category
 import com.lambda.client.module.Module
+import com.lambda.client.module.modules.misc.MapDownloader.setting
 import com.lambda.client.util.FolderUtils
 import com.lambda.client.util.TickTimer
 import com.lambda.client.util.TimeUnit
@@ -42,6 +43,7 @@ object PacketLogger : Module(
     private val ignoreUnknown by setting("Ignore Unknown Packets", false, description = "Ignore packets that aren't explicitly handled.")
     private val ignoreChat by setting("Ignore Chat", true, description = "Ignore chat packets.")
     private val ignoreCancelled by setting("Ignore Cancelled", true, description = "Ignore cancelled packets.")
+    private val openLogFolder = setting("Open Log Folder...", false)
 
     private val fileTimeFormatter = DateTimeFormatter.ofPattern("HH-mm-ss_SSS")
 
@@ -133,6 +135,11 @@ object PacketLogger : Module(
 
             sendPacket(it.packet)
         }
+
+        openLogFolder.consumers.add { _, it ->
+            if (it) FolderUtils.openFolder(FolderUtils.logFolder)
+            false
+        }
     }
 
     private fun receivePacket(packet: Packet<*>) {

src/main/kotlin/com/lambda/client/module/modules/render/NewChunks.kt

@@ -50,7 +50,8 @@ object NewChunks : Module(
     private val saveOption by setting("Save Option", SaveOption.EXTRA_FOLDER, { saveNewChunks })
     private val saveInRegionFolder by setting("In Region", false, { saveNewChunks })
     private val alsoSaveNormalCoords by setting("Save Normal Coords", false, { saveNewChunks })
-    private val closeFile = setting("CloseFile", false, { saveNewChunks })
+    private val closeFile = setting("Close file", false, { saveNewChunks })
+    private val openNewChunksFolder = setting("Open NewChunks Folder...", false, { saveNewChunks })
     private val yOffset by setting("Y Offset", 0, -256..256, 4, fineStep = 1, description = "Render offset in Y axis")
     private val color by setting("Color", ColorHolder(255, 64, 64, 200), description = "Highlighting color")
     private val thickness by setting("Thickness", 1.5f, 0.1f..4.0f, 0.1f, description = "Thickness of the highlighting square")
@@ -249,7 +250,8 @@ object NewChunks : Module(
             if (saveInRegionFolder) {
                 file = File(file, "region")
             }
-            file = File(file, "newChunkLogs")
+
+            file = File(file, "logs")
             val date = SimpleDateFormat("yyyy-MM-dd_HH-mm-ss").format(Date())
             file = File(file, mc.session.username + "_" + date + ".csv") // maybe don't safe the name, actually. But I also don't want to make another option...
             val filePath = file.toPath()
@@ -284,45 +286,10 @@ object NewChunks : Module(
                 rV = File(rV, "saves")
                 rV = File(rV, folderName)
             }
-            SaveOption.NHACK_WDL -> {
-                folderName = nHackInetName
-                rV = File(rV, "config")
-                rV = File(rV, "wdl-saves")
-                rV = File(rV, folderName)
-
-                // extra because name might be different
-                if (!rV.exists()) {
-                    MessageSendHelper.sendWarningMessage("$chatName nhack wdl directory doesnt exist: $folderName")
-                    MessageSendHelper.sendWarningMessage("$chatName creating the directory now. It is recommended to update the ip")
-                }
-            }
         }
         return rV.toPath()
     }
 
-    // if there is no port then we have to manually include the standard port..
-    private val nHackInetName: String
-        get() {
-            var folderName = mc.currentServerData?.serverIP ?: "Offline"
-            if (SystemUtils.IS_OS_WINDOWS) {
-                folderName = folderName.replace(":", "_")
-            }
-            if (hasNoPort(folderName)) {
-                folderName += "_25565" // if there is no port then we have to manually include the standard port..
-            }
-            return folderName
-        }
-
-    private fun hasNoPort(ip: String): Boolean {
-        if (!ip.contains("_")) {
-            return true
-        }
-        val sp = ip.split("_").toTypedArray()
-        val ending = sp[sp.size - 1]
-        // if it is numeric it means it might be a port...
-        return ending.toIntOrNull() != null
-    }
-
     // p2.x > p1.x and p2.y > p1.y is assumed
     private fun isSquareInRadius(p1: Vec2d, p2: Vec2d, radius: Float): Boolean {
         val x = if (p1.x + p2.x > 0) p2.x else p1.x
@@ -334,28 +301,12 @@ object NewChunks : Module(
         return Vec2d((x shl 4).toDouble(), (z shl 4).toDouble()).minus(playerOffset).div(scale.toDouble())
     }
 
-    fun getChunks(): ConcurrentHashMap<ChunkPos, Long> {
-        return chunks
-    }
-
-    fun addChunk(chunk: ChunkPos) {
-        chunks[chunk] = System.currentTimeMillis()
-    }
-
-    fun addChunk(chunk: ChunkPos, time: Long) {
-        chunks[chunk] = time
-    }
-
-    fun removeChunk(chunk: ChunkPos) {
-        chunks.remove(chunk)
-    }
-
     private fun saveNewChunk(log: PrintWriter?, data: String) {
         log!!.println(data)
     }
 
     private enum class SaveOption {
-        EXTRA_FOLDER, LITE_LOADER_WDL, NHACK_WDL
+        EXTRA_FOLDER, LITE_LOADER_WDL
     }
 
     @Suppress("unused")
@@ -375,7 +326,7 @@ object NewChunks : Module(
         var ip: String? = null
         fun testChangeAndUpdate(event: SafeClientEvent): Boolean {
             if (testChange(event)) {
-                // so we dont have to do this process again next time
+                // so we don't have to do this process again next time
                 update(event)
                 return true
             }
@@ -409,5 +360,10 @@ object NewChunks : Module(
                 closeFile.value = false
             }
         }
+
+        openNewChunksFolder.consumers.add { _, it ->
+            if (it) FolderUtils.openFolder(FolderUtils.newChunksFolder)
+            false
+        }
     }
 }

src/main/kotlin/com/lambda/client/util/FolderUtils.kt

@@ -44,7 +44,11 @@ object FolderUtils {
 
     @JvmStatic
     val newChunksFolder
-        get() = "${lambdaFolder}newChunks${File.separator}"
+        get() = "${lambdaFolder}new-chunks${File.separator}"
+
+    @JvmStatic
+    val mapImagesFolder
+        get() = "${lambdaFolder}map-images${File.separator}"
 
     /**
      * Opens the given path using the right library based on OS