Posts by hedgehogform

package hedgehogform.machines

// import net.risingworld.api.assets.ModelAsset
import net.risingworld.api.Plugin
import net.risingworld.api.assets.AssetBundle
import net.risingworld.api.assets.MaterialAsset
import net.risingworld.api.assets.PrefabAsset
import net.risingworld.api.assets.TextureAsset
import net.risingworld.api.events.EventMethod
import net.risingworld.api.events.Listener
import net.risingworld.api.events.player.PlayerSpawnEvent
import net.risingworld.api.objects.Player
import net.risingworld.api.utils.Layer
import net.risingworld.api.utils.Vector3f
import net.risingworld.api.worldelements.Prefab

// import net.risingworld.api.worldelements.Model

fun formatPrint(message: String) {
    println("[${ModInfo.name}] $message")
}

open class PrefabManager {
    companion object {
        // AssetBundle approach
        private var assetBundle: AssetBundle? = null
        private val prefabAssets = mutableMapOf<String, PrefabAsset>()
        private var bakeMaterial: MaterialAsset? = null
        private var bakeTexture: TextureAsset? = null
        private val spawnedPrefabs = mutableMapOf<Player, MutableList<Prefab>>()
        var isInitialized: Boolean = false
            private set
    }

    fun initialize(bundlePath: String, prefabNames: List<String>) {
        assetBundle = AssetBundle.loadFromFile(bundlePath)
        if (assetBundle == null) {
            formatPrint("[FAIL] Failed to load asset bundle from $bundlePath")
            isInitialized = false
            return
        }

        val allAssets = assetBundle!!.allAssetNames
        formatPrint("[OK] Asset bundle loaded with assets: ${allAssets.toList()}")

        // Print each asset for debugging
        allAssets.forEach { asset ->
            formatPrint("[DEBUG] Found asset: $asset")
        }

        // Load the BakeTexture texture from the bundle
        val texturePath = allAssets.firstOrNull { it.contains("BakeTexture", ignoreCase = true) }
        if (texturePath != null) {
            try {
                formatPrint("[DEBUG] Loading texture: BakeTexture from $texturePath")
                bakeTexture = TextureAsset.loadFromAssetBundle(assetBundle!!, texturePath)
                formatPrint("[OK] Loaded BakeTexture texture")

                // Create a material and assign the texture to it
                bakeMaterial = MaterialAsset.create("BakeTextureMaterial")
                bakeMaterial!!.setTexture(bakeTexture)
                formatPrint("[OK] Created material and assigned BakeTexture")
            } catch (e: Exception) {
                formatPrint("[WARN] Failed to load BakeTexture: ${e.message}")
            }
        } else {
            formatPrint("[WARN] BakeTexture not found in bundle")
        }

        // Load all prefab assets immediately
        prefabNames.forEach { prefabName ->
            val assetPath = allAssets.firstOrNull { it.contains(prefabName, ignoreCase = false) }

            if (assetPath != null) {
                try {
                    formatPrint("[DEBUG] Loading prefab asset: $prefabName from $assetPath")
                    val prefabAsset = PrefabAsset.loadFromAssetBundle(assetBundle!!, assetPath)
                    formatPrint("[DEBUG] Successfully loaded prefab asset: $prefabName")
                    prefabAssets[prefabName] = prefabAsset
                } catch (e: Exception) {
                    formatPrint("[WARN] Exception while loading prefab: ${e.message}")
                }

                formatPrint("[OK] Loaded prefab asset: $prefabName from $assetPath")
            } else {
                formatPrint("[WARN] Prefab \"$prefabName\" not found in bundle")
            }
        }

        isInitialized = true
    }

    fun spawnPrefab(prefabName: String, player: Player) {
        if (!isInitialized) {
            formatPrint("[WARN] PrefabManager not initialized, cannot spawn \"$prefabName\"")
            return
        }

        val prefabAsset = prefabAssets[prefabName]
        if (prefabAsset == null) {
            formatPrint("[FAIL] Prefab \"$prefabName\" not found in cache")
            return
        }

        // Calculate spawn position in front of the player at eye level
        val forward = player.viewDirection.normalize()
        val spawnPosition = player.position.add(forward.x * 3f, 1.5f, forward.z * 3f)
        formatPrint("[DEBUG] Spawning at position: $spawnPosition")

        val prefab = Prefab()
        prefab.setPrefab(prefabAsset)

        formatPrint("[DEBUG] Created prefab instance and assigned asset")

        // Add to player to "instantiate" it into the game world
        formatPrint("[DEBUG] Adding prefab to player game object...")
        player.addGameObject(prefab)

        // Now configure the instantiated prefab
        val scale = Vector3f(1f, 1f, 1f)
        prefab.setLocalScale("", scale)
        formatPrint("[DEBUG] Set scale to: $scale")

        prefab.setLayer(Layer.OBJECT)
        formatPrint("[DEBUG] Set layer to OBJECT")

        prefab.setLocalPosition(null, spawnPosition)
        formatPrint("[DEBUG] Set position to: $spawnPosition")

        // Apply the BakeTexture material
        if (bakeMaterial != null) {
            try {
                prefab.setMaterial("", bakeMaterial)
                formatPrint("[DEBUG] Applied BakeTexture material to prefab")
            } catch (e: Exception) {
                formatPrint("[WARN] Could not apply BakeTexture material: ${e.message}")
            }
        } else {
            formatPrint("[WARN] BakeTexture material not available")
        }

        // Enable physics: set isKinematic to false and useGravity to true on Rigidbody
        // Note: isKinematic = false allows physics forces, collisions, and player interaction
        try {
            prefab.setComponentProperty("", "Rigidbody", "isKinematic", false)
            formatPrint("[DEBUG] Set Rigidbody isKinematic to false (physics enabled)")

            prefab.setComponentProperty("", "Rigidbody", "useGravity", true)
            formatPrint("[DEBUG] Set Rigidbody useGravity to true")

            // Set mass to make it easier to push (lower mass = easier to move)
            prefab.setComponentProperty("", "Rigidbody", "mass", 10.0f)
            formatPrint("[DEBUG] Set Rigidbody mass to 10.0")

            // Set drag to prevent sliding too much
            prefab.setComponentProperty("", "Rigidbody", "drag", 0.5f)
            formatPrint("[DEBUG] Set Rigidbody drag to 0.5")

            // Set angular drag to prevent excessive spinning
            prefab.setComponentProperty("", "Rigidbody", "angularDrag", 0.5f)
            formatPrint("[DEBUG] Set Rigidbody angularDrag to 0.5")
        } catch (e: Exception) {
            formatPrint("[WARN] Could not set Rigidbody properties: ${e.message}")
        }

        // Activate the prefab
        prefab.setActive("", true)
        formatPrint("[DEBUG] Set prefab active")

        val playerPrefabs = spawnedPrefabs.getOrPut(player) { mutableListOf() }
        playerPrefabs.add(prefab)

        formatPrint("[OK] Spawned \"$prefabName\" at ${spawnPosition}")
    }

    fun playAnimation(prefab: Prefab, animationName: String) {
        // Use setAnimatorTrigger to trigger an animation
        prefab.setAnimatorTrigger("", animationName)
        formatPrint("[INFO] Triggered animation: $animationName")
    }

    fun setAnimatorParameter(prefab: Prefab, parameter: String, value: Any) {
        when (value) {
            is Float -> prefab.setAnimatorParameter("", parameter, value)
            is Int -> prefab.setAnimatorParameter("", parameter, value)
            is Boolean -> prefab.setAnimatorParameter("", parameter, value)
            else ->
                    formatPrint(
                            "[WARN] Unsupported animator parameter type: ${value::class.simpleName}"
                    )
        }
        formatPrint("[INFO] Set animator parameter '$parameter' to $value")
    }

    fun startAnimation(prefab: Prefab) {
        prefab.startAnimatorPlayback("")
        formatPrint("[INFO] Started animator playback")
    }

    fun stopAnimation(prefab: Prefab) {
        prefab.stopAnimatorPlayback("")
        formatPrint("[INFO] Stopped animator playback")
    }

    fun cleanup() {
        formatPrint("[STOP] Cleaning up spawned prefabs...")

        spawnedPrefabs.forEach { (player, prefabs) ->
            prefabs.forEach { prefab ->
                runCatching { player.removeGameObject(prefab) }.onFailure {
                    formatPrint("[WARN] Could not remove prefab: ${it.message}")
                }
            }
        }
        spawnedPrefabs.clear()
        prefabAssets.clear()
        bakeMaterial = null
        bakeTexture = null
        // assetBundle?.dispose() // Don't call: will cause crash
        assetBundle = null
        isInitialized = false

        formatPrint("[STOP] Cleanup complete.")
    }
}

open class MachinesPlugin : Plugin(), Listener {
    private val prefabManager = PrefabManager()

    override fun onEnable() {
        formatPrint("[START] ${ModInfo.name} v${ModInfo.version} is starting up.")

        // Load box prefab from AssetBundle with BakeTexture material
        val bundlePath = "${getPath()}/assets/box.bundle"
        val prefabNames = listOf("boxprefab")
        prefabManager.initialize(bundlePath, prefabNames)

        registerEventListener(MyListener(prefabManager))

        formatPrint("[OK] Plugin successfully loaded!")
    }

    override fun onDisable() {
        prefabManager.cleanup()
        formatPrint("[STOP] Plugin disabled")
    }
}

class MyListener(private val prefabManager: PrefabManager) : Listener {
    @EventMethod
    fun onPlayerSpawn(event: PlayerSpawnEvent) {
        val player = event.player ?: return
        prefabManager.spawnPrefab("boxprefab", player)
    }
}

package hedgehogform.machines

import net.risingworld.api.Plugin
import net.risingworld.api.assets.AssetBundle
import net.risingworld.api.assets.PrefabAsset
import net.risingworld.api.events.EventMethod
import net.risingworld.api.events.Listener
import net.risingworld.api.events.player.PlayerSpawnEvent
import net.risingworld.api.objects.Player
import net.risingworld.api.utils.Layer
import net.risingworld.api.worldelements.Prefab

fun formatPrint(message: String) {
    println("[${ModInfo.name}] $message")
}

open class PrefabManager {
    companion object {
        private var assetBundle: AssetBundle? = null
        private val prefabCache = mutableMapOf<String, PrefabAsset>()
        private val spawnedPrefabs = mutableMapOf<Player, MutableList<Prefab>>()
        var isInitialized: Boolean = false
            private set
    }

    fun initialize(bundlePath: String) {
        assetBundle = AssetBundle.loadFromFile(bundlePath)
        if (assetBundle == null) {
            formatPrint("[FAIL] Failed to load asset bundle from $bundlePath")
            isInitialized = false
            return
        }

        formatPrint("[OK] Asset bundle loaded with assets: ${assetBundle!!.allAssetNames.toList()}")
        isInitialized = true
    }

    fun spawnPrefab(prefabName: String, player: Player) {
        val bundle = assetBundle
        if (!isInitialized || bundle == null) {
            formatPrint("[WARN] PrefabManager not initialized, cannot spawn \"$prefabName\"")
            return
        }

        formatPrint("[DEBUG] Looking for prefab: $prefabName")
        formatPrint("[DEBUG] Available assets: ${bundle.allAssetNames.joinToString()}")

        val prefabAsset =
                prefabCache.getOrPut(prefabName) {
                    val assetPath =
                            bundle.allAssetNames.firstOrNull {
                                it.contains(prefabName, ignoreCase = true)
                            }
                                    ?: run {
                                        formatPrint(
                                                "[FAIL] Prefab \"$prefabName\" not found in bundle"
                                        )
                                        return
                                    }
                    formatPrint("[DEBUG] Found asset at path: $assetPath")
                    PrefabAsset.loadFromAssetBundle(bundle, assetPath)
                }

        val prefab = Prefab(prefabAsset)

        // Spawn in front of the player at eye level
        val forward = player.viewDirection.normalize()
        val spawnPosition = player.position.add(forward.x * 3f, 1.5f, forward.z * 3f)
        formatPrint("[DEBUG] Spawning at position: $spawnPosition")

        // Set scale to make sure it's visible
        val scale = net.risingworld.api.utils.Vector3f(1f, 1f, 1f)
        prefab.setLocalScale("", scale)
        formatPrint("[DEBUG] Set scale to: $scale")

        // Set layer to ITEM for proper physics collision
        prefab.setLayer(Layer.OBJECT)
        formatPrint("[DEBUG] Set layer to ITEM")

        // Set position using setLocalPosition with null parent (world space)
        prefab.setLocalPosition(null, spawnPosition)

        // Make Rigidbody kinematic so it doesn't fall
        try {
            prefab.setComponentProperty("", "Rigidbody", "isKinematic", true)
            prefab.setComponentProperty("", "Rigidbody", "useGravity", false)
            formatPrint("[DEBUG] Set Rigidbody to kinematic")
        } catch (e: Exception) {
            formatPrint("[WARN] Could not set Rigidbody properties: ${e.message}")
        }

        prefab.setActive("", true)

        // Add to player
        formatPrint("[DEBUG] Adding to player game object...")
        player.addGameObject(prefab)

        // Try adding a light component to make it more visible
        try {
            prefab.addComponent("", "Light")
            prefab.setComponentProperty("", "Light", "range", 10f)
            prefab.setComponentProperty("", "Light", "intensity", 2f)
            formatPrint("[DEBUG] Added light component")
        } catch (e: Exception) {
            formatPrint("[WARN] Could not add light: ${e.message}")
        }

        // Set default animation to Idle
        // formatPrint("[DEBUG] Setting Idle animation...")
        // prefab.setAnimatorTrigger("", "Idle") // Commented out - test without animation first

        val playerPrefabs = spawnedPrefabs.getOrPut(player) { mutableListOf() }
        playerPrefabs.add(prefab)

        formatPrint("[OK] Spawned \"$prefabName\" at ${spawnPosition}")
    }

    fun playAnimation(prefab: Prefab, animationName: String) {
        // Use setAnimatorTrigger to trigger an animation
        prefab.setAnimatorTrigger("", animationName)
        formatPrint("[INFO] Triggered animation: $animationName")
    }

    fun setAnimatorParameter(prefab: Prefab, parameter: String, value: Any) {
        when (value) {
            is Float -> prefab.setAnimatorParameter("", parameter, value)
            is Int -> prefab.setAnimatorParameter("", parameter, value)
            is Boolean -> prefab.setAnimatorParameter("", parameter, value)
            else ->
                    formatPrint(
                            "[WARN] Unsupported animator parameter type: ${value::class.simpleName}"
                    )
        }
        formatPrint("[INFO] Set animator parameter '$parameter' to $value")
    }

    fun startAnimation(prefab: Prefab) {
        prefab.startAnimatorPlayback("")
        formatPrint("[INFO] Started animator playback")
    }

    fun stopAnimation(prefab: Prefab) {
        prefab.stopAnimatorPlayback("")
        formatPrint("[INFO] Stopped animator playback")
    }

    fun cleanup() {
        formatPrint("[STOP] Cleaning up spawned prefabs...")

        spawnedPrefabs.forEach { (player, prefabs) ->
            prefabs.forEach { prefab ->
                runCatching { player.removeGameObject(prefab) }.onFailure {
                    formatPrint("[WARN] Could not remove prefab: ${it.message}")
                }
            }
        }

        spawnedPrefabs.clear()
        prefabCache.clear()
        // assetBundle?.dispose() // Don't call: will cause crash
        assetBundle = null
        isInitialized = false

        formatPrint("[STOP] Cleanup complete.")
    }
}

open class MachinesPlugin : Plugin(), Listener {
    private val prefabManager = PrefabManager()

    override fun onEnable() {
        formatPrint("[START] ${ModInfo.name} v${ModInfo.version} is starting up.")

        val bundlePath = "${getPath()}/assets/cube.bundle"
        prefabManager.initialize(bundlePath)

        registerEventListener(MyListener(prefabManager))

        formatPrint("[OK] Plugin successfully loaded!")
    }

    override fun onDisable() {
        prefabManager.cleanup()
        formatPrint("[STOP] Plugin disabled")
    }
}

class MyListener(private val prefabManager: PrefabManager) : Listener {
    @EventMethod
    fun onPlayerSpawn(event: PlayerSpawnEvent) {
        val player = event.player ?: return
        prefabManager.spawnPrefab("bundlecube", player)
    }
}