Assetbundle invisible

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)
    }
}