Проблемы с Kotlin и Wasm при создании игры

// Это работает в JVM, но не в Wasm
val typeParameters = myClass::class.typeParameters
val isSubtype = type1.isSubtypeOf(type2)

try {
    // Код, который может вызвать исключение
    val result = process(input)
} catch (t: Throwable) {
    // На JVM это работало, в Wasm - нет
    fallbackResult
}

// Каждый такой вызов требует пересечения границы Wasm-JS
document.getElementById("game-container").innerHTML = gameState.render()

// Приходится использовать обертки и доп. код для интеграции
suspend fun fetchGameAssets(): Assets {
    return suspendCancellableCoroutine { continuation ->
        js("fetch('/assets.json')")
            .then({ response -> response.json() })
            .then({ json -> continuation.resume(parseAssets(json)) })
            .catch({ error -> continuation.resumeWithException(Exception(error)) })
    }
}

fun generateChallenge(): Challenge {
    // Создает много временных объектов
    val fruits = generateRandomFruits(10)
    val operations = generateRandomOperations(3)
    val expectedResult = operations.fold(fruits) { acc, op -> op(acc) }
    return Challenge(fruits, operations, expectedResult)
}

class FruitPool {
    private val pool = mutableListOf<Fruit>()
    
    fun obtain(): Fruit = if (pool.isEmpty()) Fruit() else pool.removeAt(pool.size - 1)
    
    fun recycle(fruit: Fruit) {
        fruit.reset()
        pool.add(fruit)
    }
}

// Выглядит невинно, но каждый вызов - это дорогостоящая операция
fun updateGameElement() {
  js("document.getElementById('game-container').style.background = 'red'")
}

// В Kotlin
val fruits = listOf(Fruit("Apple"), Fruit("Banana"))
js("renderFruits")(fruits)
 
// В JavaScript
function renderFruits(fruits) {
  // Это не обычный массив JavaScript!
  console.log(Array.isArray(fruits)) // false
  // Поэтому методы массивов не работают как ожидалось
}

suspend fun fetchGameData(): GameData {
  return suspendCancellableCoroutine { continuation ->
    js("fetch('/api/game-data')")
      .then({ response -> response.json() })
      .then({ data -> continuation.resume(parseGameData(data)) })
      .catch({ error -> continuation.resumeWithException(RuntimeException(error.toString())) })
  }
}

@JsExport
fun handleGameClick(x: Int, y: Int) {
  // Обработка клика
}
 
fun setupEvents() {
  js("""
    document.getElementById('game-area').addEventListener('click', function(e) {
      window.handleGameClick(e.clientX, e.clientY);
    });
  """)
}

var lastFrameTime = 0.0
fun gameLoop(timestamp: Double) {
    val deltaTime = timestamp - lastFrameTime
    lastFrameTime = timestamp
    
    update(deltaTime)
    render()
    
    // Тут могут быть непредсказуемые задержки
    js("window.requestAnimationFrame")(::gameLoop)
}

fun updatePosition(obj: GameObject, dt: Float) {
  obj.velocity.y += GRAVITY * dt
  obj.position.x += obj.velocity.x * dt
  obj.position.y += obj.velocity.y * dt
}

// В JVM можно использовать нативные библиотеки для быстрых вычислений
// В Wasm - только чистый Kotlin
fun calculateCollision(a: Body, b: Body): Vector2 {
  // Сложные вычисления без нативных оптимизаций
  // работают медленнее в Wasm
}

// Этот код прекрасно работает на JVM/Android/iOS
val file = File("game_progress.save")
val data = file.readBytes()
// Но для Wasm аналога просто нет!

fun saveGameState(state: GameState) {
  js("""
    const request = indexedDB.open("MyGame", 1);
    request.onsuccess = function(event) {
      const db = event.target.result;
      const transaction = db.transaction(["saves"], "readwrite");
      const objectStore = transaction.objectStore("saves");
      objectStore.put({id: "current", data: /* как передать сюда Kotlin-объект? */});
    };
  """)
}

external interface CanvasRenderingContext2D {
    fun fillRect(x: Double, y: Double, w: Double, h: Double)
    fun clearRect(x: Double, y: Double, w: Double, h: Double)
    // И еще сотня методов, которые нужно объявить вручную
}
 
external fun getContext(canvas: HTMLCanvasElement, contextId: String): CanvasRenderingContext2D
 
fun initCanvas(): CanvasRenderingContext2D {
    val canvas = document.getElementById("gameCanvas") as HTMLCanvasElement
    return getContext(canvas, "2d")
}

fun createShader(gl: WebGLRenderingContext, type: Int, source: String): WebGLShader {
    val shader = gl.createShader(type)
    gl.shaderSource(shader, source)
    gl.compileShader(shader)
    
    // Проверка ошибок компиляции шейдера
    val success = gl.getShaderParameter(shader, gl.COMPILE_STATUS) as Boolean
    if (!success) {
        val infoLog = gl.getShaderInfoLog(shader)
        gl.deleteShader(shader)
        throw RuntimeException("Ошибка компиляции шейдера: $infoLog")
    }
    
    return shader
}

// По-настоящему общий код
fun processGameLogic(state: GameState): GameState {
  // Работает одинаково везде
}
 
// Общий интерфейс, разные реализации
expect class StorageManager {
  fun saveGame(data: GameData)
  fun loadGame(): GameData?
}
 
// Платформенно-зависимый код
actual class StorageManager actual constructor() {
  // На Android используем SharedPreferences
  // На iOS - UserDefaults
  // На Wasm... а вот тут начинаются проблемы!
}

// На Android/Desktop это работает
fun gameLoop() {
  while(isRunning) {
    update()
    render()
    Thread.sleep(16) // ~60 FPS
  }
}
 
// В Wasm нужно что-то типа:
fun setupGameLoop() {
  js("window.requestAnimationFrame")(::gameFrame)
}
 
fun gameFrame(timestamp: Double) {
  update()
  render()
  if(isRunning) {
    js("window.requestAnimationFrame")(::gameFrame)
  }
}

// Привычный жизненный цикл на Android
class GameActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // Инициализация игры
    }
    
    override fun onPause() {
        super.onPause()
        // Пауза игры
    }
    
    // И так далее...
}
 
// В Wasm приходится эмулировать это самостоятельно
fun main() {
    window.addEventListener("load", { initGame() })
    window.addEventListener("beforeunload", { saveGameState() })
    document.addEventListener("visibilitychange", { 
        if (document.visibilityState == "hidden") pauseGame()
        else resumeGame()
    })
}

// Реагирование на изменение размера окна
fun setupResizeListener() {
    window.addEventListener("resize", { 
        val width = window.innerWidth
        val height = window.innerHeight
        resizeGameElements(width, height)
    })
}

launch {
  val user = userRepository.fetchUser() // suspend функция
  val friends = friendsRepository.fetchFriendsFor(user) // еще одна suspend функция
  view.showUserWithFriends(user, friends)
}

suspend fun loadGameResources() {
  val textures = loadTextures()
  val sounds = loadSounds()
  val levels = loadLevels()
  return GameResources(textures, sounds, levels)
}

suspend fun fetchFromApi(): ApiResponse = suspendCoroutine { continuation ->
  js("fetch('/api/data')")
    .then({ response -> response.json() })
    .then({ data -> continuation.resume(parseApiResponse(data)) })
    .catch({ error -> continuation.resumeWithException(RuntimeException(error.toString())) })
}

// Примерный псевдокод, как это должно было бы работать
fun createWorker(): Worker {
  val worker = Worker("game-worker.js")
  worker.onmessage = { event -> handleWorkerResponse(event.data) }
  return worker
}
 
fun runTaskInWorker(worker: Worker, task: Task) {
  worker.postMessage(task) // Но как сериализовать Kotlin-объект?
}

fun processComplexTask(task: ComplexTask, onDone: (Result) -> Unit) {
  val chunks = task.splitIntoChunks(100)
  var currentChunk = 0
  
  fun processNextChunk() {
    if (currentChunk >= chunks.size) {
      onDone(task.combineResults())
      return
    }
    
    val chunk = chunks[currentChunk++]
    processChunk(chunk)
    js("setTimeout")(::processNextChunk, 0)
  }
  
  processNextChunk()
}

// Выглядит просто, но не работает напрямую
@Serializable
data class GameProgress(
    val completedLevels: List<Int>,
    val currentScore: Int,
    val unlockedFruits: Set<Fruit>
)
 
fun saveGameProgress(progress: GameProgress) {
    // Как это передать в JavaScript localStorage?
    val json = Json.encodeToString(progress)
    // А Fruit - это кастомный класс, как его сериализовать?
}

fun saveToLocalStorage(key: String, value: String) {
    js("window.localStorage.setItem")(key, value)
}
 
fun loadFromLocalStorage(key: String): String? {
    return js("window.localStorage.getItem")(key) as? String
}

// Упрощенная версия, с которой меньше проблем
fun saveMinimalGameState() {
    val state = buildJsonObject {
        put("level", currentLevel)
        put("score", playerScore)
        putJsonArray("completed") {
            completedLevels.forEach { add(it) }
        }
    }
    saveToLocalStorage("gameState", state.toString())
}

// В Kotlin/Wasm
interface User {
  val name: String
  val age: Int
}
 
// В TypeScript такой код будет работать:
// const user = { name: "John", age: 25, extra: true }; // Ок для TS
// В Kotlin - не ок, нужно точное соответствие интерфейсу

external interface ThreeJsScene {
  fun add(object: ThreeJsObject)
  fun render()
  // И еще сотня методов для полноценной работы
}

fun setupClickHandlers() {
  document.getElementById("game-board")?.addEventListener("click", { event ->
    // Здесь event - это динамический JS-объект
    // Как получить из него координаты в типобезопасном стиле?
    val x = (event.clientX as Double) - (event.target.offsetLeft as Double)
    val y = (event.clientY as Double) - (event.target.offsetTop as Double)
    handleGameClick(x, y)
  })
}

fun saveGameState() {
  val stateJson = Json.encodeToString(gameState)
  localStorage.setItem("gameState", stateJson)
  // Но откуда взять localStorage? Это JS API!
}

external interface Scene {
    fun add(object: Object3D)
    fun remove(object: Object3D)
    // И еще сотни методов, которые нужно определить вручную
}
 
external interface Object3D {
    var position: Vector3
    var rotation: Euler
    // А тут еще больше методов и свойств
}

// Каждый такой вызов - дорогая операция пересечения границы Wasm/JS
scene.add(mesh)
renderer.render(scene, camera)
material.opacity = 0.5

external class AudioContext {
    val currentTime: Double
    fun createOscillator(): OscillatorNode
    fun createGain(): GainNode
    // И еще десятки методов, которые нужно объявить
}
 
fun playSound(soundId: String) {
    // Как получить доступ к предзагруженным звукам?
    // Как управлять громкостью, панорамой, эффектами?
    js("document.getElementById('sound-$soundId').play()")
}

fun initAudio() {
    // Создаем невидимую кнопку для инициализации аудио
    document.body?.appendChild(createInitAudioButton())
    // А теперь ждем, пока пользователь кликнет...
}

fun loadImage(path: String): Promise<HTMLImageElement> {
  return Promise { resolve, reject ->
    val img = js("new Image()")
    img.onload = { resolve(img) }
    img.onerror = { reject(Exception("Не удалось загрузить $path")) }
    img.src = path
  }
}

fun cacheResource(key: String, data: ArrayBuffer) {
  js("""
    const db = // Открытие базы данных
    // Транзакция
    // Сохранение
    // Обработка ошибок
    // И все это на чистом JavaScript, потому что нет нормальной обертки!
  """)
}

// Мечта, которая не сбудется:
@ExportToUnity
class KotlinGameLogic {
  fun calculateNextMove(): Move {
    // Логика на Kotlin
  }
}

external interface PixiApplication {
  fun ticker(callback: () -> Unit)
  // Десятки других методов, которые нужно объявить
}
 
fun initPixi(): PixiApplication {
  return js("new PIXI.Application()")
}

fun generateChallenge(): Challenge {
println("Starting challenge generation...")
try {
  val fruits = generateRandomFruits(5)
  println("Generated fruits: $fruits")
  val operations = selectRandomOperations(2)
  println("Selected operations: $operations") // Отладка через логи - единственный вариант
  return Challenge(fruits, operations, calculateResult(fruits, operations))
} catch (e: Exception) {
  println("ERROR in generation: ${e.message}")
  println("Stack trace: ${e.stackTraceToString()}") // А толку от стектрейса почти нет
  return fallbackChallenge()
}
}

fun measurePerformance(action: () -> Unit): Double {
val start = js("performance.now()")
action()
val end = js("performance.now()")
return end - start
}

fun debugKotlinObject(obj: MyClass) {
  // Хочешь увидеть содержимое obj? Забудь!
  // Единственный способ - явно вывести каждое поле в консоль
  console.log("obj.field1 = ${obj.field1}")
  console.log("obj.field2 = ${obj.field2}")
  // И так для каждого свойства...
}

fun profilingSandbox() {
  js("console.time")("generate-challenge")
  val challenge = generateChallenge()
  js("console.timeEnd")("generate-challenge")
  return challenge
}

// Было в Kotlin - медленно
val result = list.filter { it.value > threshold }.map { process(it) }
 
// Стало с JavaScript - быстрее
val jsArray = list.toJsArray()
val filtered = js("jsArray.filter(x => x.value > threshold)")
val processed = js("filtered.map(x => window.processItem(x))")

fun sendTaskToWorker(worker: Worker, task: ComplexTask) {
  // После этой строки профилировщик теряет след
  worker.postMessage(task.toJsObject())
}

fun sendTask(worker: Worker, task: ComplexTask) {
  val id = generateUniqueId()
  val start = js("performance.now()")
  pendingTasks[id] = start
  worker.postMessage(json { "id" to id; "data" to task.toJson() })
}
 
fun handleResponse(response: dynamic) {
  val id = response.id as String
  val start = pendingTasks.remove(id) ?: return
  console.log("Task took ${js("performance.now()") - start} ms")
}

// Моя "оптимизированная" реализация на Kotlin/Wasm
fun updateSprites(sprites: List<Sprite>, deltaTime: Float) {
  // Для каждого спрайта обновляем позицию
  sprites.forEach { sprite ->
    sprite.x += sprite.velocityX * deltaTime
    sprite.y += sprite.velocityY * deltaTime
    if (sprite.x < 0 || sprite.x > canvas.width) sprite.velocityX *= -1
    if (sprite.y < 0 || sprite.y > canvas.height) sprite.velocityY *= -1
  }
  
  // Простая проверка коллизий
  for (i in sprites.indices) {
    for (j in i + 1 until sprites.size) {
      checkCollision(sprites[i], sprites[j])
    }
  }
}

// Плохо: много пересечений границы
fun updateUI() {
  js("document.getElementById('score').textContent = $score")
  js("document.getElementById('lives').textContent = $lives")
  js("document.getElementById('level').textContent = $level")
}

// Лучше: одно пересечение
fun updateUI() {
  js("""
    document.getElementById('score').textContent = $score;
    document.getElementById('lives').textContent = $lives;
    document.getElementById('level').textContent = $level;
  """)
}

class ResultCache<K, V>(private val timeToLive: Long = 60000) {
  private val cache = mutableMapOf<K, Pair<V, Long>>()
  
  fun get(key: K, compute: () -> V): V {
    val now = js("Date.now()") as Long
    val cached = cache[key]
    
    return if (cached != null && now - cached.second < timeToLive) {
      cached.first
    } else {
      val fresh = compute()
      cache[key] = fresh to now
      fresh
    }
  }
}

// Вместо этого (создает новые объекты)
fun updateSprites(sprites: List<Sprite>, delta: Float): List<Sprite> {
  return sprites.map { it.copy(x = it.x + it.vx * delta, y = it.y + it.vy * delta) }
}
 
// Делал так (модифицирует существующие)
fun updateSprites(sprites: List<Sprite>, delta: Float) {
  sprites.forEach { 
    it.x += it.vx * delta
    it.y += it.vy * delta
  }
}

// Было - красиво и идиоматично, но медленно
class Fruit(var name: String, var color: String, var weight: Int)
val fruits = List(100) { Fruit("Фрукт $it", getRandomColor(), getRandomWeight()) }
 
// Стало - страшно, но быстрее в 3-4 раза
val names = Array(100) { "Фрукт $it" }
val colors = Array(100) { getRandomColor() }
val weights = IntArray(100) { getRandomWeight() }

class FruitPool(size: Int) {
private val pool = Array(size) { Fruit() }
private var index = 0
 
fun obtain(): Fruit = if (index < pool.size) pool[index++] else Fruit()
fun release(fruit: Fruit) { if (index > 0) pool[--index] = fruit }
}

// Было - элегантно, но в Wasm тормозило
val result = fruits
.filter { it.weight > minWeight }
.map { transformFruit(it) }
 
// Стало - уродливо, зато быстро
val result = ArrayList<TransformedFruit>()
for (i in 0 until fruits.size) {
if (fruits[i].weight > minWeight) {
  result.add(transformFruit(fruits[i]))
}
}

// Компоненты - только данные, без логики
data class PositionComponent(var x: Float, var y: Float)
data class VelocityComponent(var vx: Float, var vy: Float)
 
// Сущность - просто контейнер для компонентов
class Entity(val id: Int) {
  val components = mutableMapOf<KClass<*>, Any>()
  inline fun <reified T> get(): T? = components[T::class] as? T
  inline fun <reified T> add(component: T) { components[T::class] = component }
}
 
// Система обрабатывает все сущности с нужными компонентами
class MovementSystem {
  fun update(entities: List<Entity>, deltaTime: Float) {
    entities.forEach { entity ->
      val position = entity.get<PositionComponent>() ?: return@forEach
      val velocity = entity.get<VelocityComponent>() ?: return@forEach
      position.x += velocity.vx * deltaTime
      position.y += velocity.vy * deltaTime
    }
  }
}

class FruitPool {
  private val active = mutableSetOf<Fruit>()
  private val inactive = mutableListOf<Fruit>()
  
  fun obtain(): Fruit {
    val fruit = if (inactive.isEmpty()) Fruit() else inactive.removeAt(inactive.size - 1)
    active.add(fruit)
    return fruit
  }
  
  fun release(fruit: Fruit) {
    if (active.remove(fruit)) {
      fruit.reset()
      inactive.add(fruit)
    }
  }
}

sealed class GameState {
  object Loading : GameState()
  data class Playing(val level: Int, val score: Int) : GameState()
  object Paused : GameState()
  object GameOver : GameState()
  
  // Каждое состояние знает, как обрабатывать события
  open fun onUpdate(delta: Float): GameState = this
  open fun onUserInput(input: UserInput): GameState = this
}

sealed class GameCommand {
  data class Move(val x: Float, val y: Float) : GameCommand()
  object Jump : GameCommand()
  data class SelectFruit(val fruitId: Int) : GameCommand()
}

interface AudioFacade {
  fun playSound(soundId: String, volume: Float = 1.0f)
  fun stopAllSounds()
  fun setMasterVolume(volume: Float)
}
 
// Реализация содержит всю боль работы с JS
actual class WebAudioFacade : AudioFacade {
  // Тут весь грязный код взаимодействия с JavaScript
}

object ResourceCache {
  private val imageCache = mutableMapOf<String, HTMLImageElement>()
  private val soundCache = mutableMapOf<String, AudioBuffer>()
  
  suspend fun getImage(path: String): HTMLImageElement {
    return imageCache.getOrPut(path) {
      suspendCoroutine { continuation ->
        val img = js("new Image()")
        img.onload = { continuation.resume(img) }
        img.src = path
      }
    }
  }
}

fun preloadCriticalResources(): Promise<Unit> {
  val critical = listOf("player.png", "tiles.png", "main_theme.mp3")
  return Promise.all(critical.map { ResourceCache.prefetch(it) })
}
 
fun preloadSecondaryInBackground() {
  launch {
    val secondary = listOf("enemy1.png", "enemy2.png", "explosion.mp3")
    secondary.forEach { ResourceCache.prefetch(it) }
  }
}

external object StorageHelper {
  fun cacheResource(key: String, data: ArrayBuffer): Promise<Unit>
  fun loadCachedResource(key: String): Promise<ArrayBuffer?>
}
 
suspend fun loadResourceWithCache(url: String): ByteArray {
  // Сначала проверяем кэш, потом грузим по сети
  val cached = StorageHelper.loadCachedResource(url).await()
  if (cached != null) return cached.toByteArray()
  
  val fresh = fetchResource(url)
  StorageHelper.cacheResource(url, fresh.toTypedArray())
  return fresh
}

val GAME_VERSION = "1.2.3"
fun versionedUrl(path: String) = "$path?v=$GAME_VERSION"

fun initResourceLoading() {
  launch {
    // Первый этап - только самое необходимое
    val criticalResources = listOf("ui.png", "level1.json", "player.png")
    loadResources(criticalResources, onProgress = { showLoadingProgress(it) })
    
    // Показываем игру, можно начинать
    showGameInterface()
    
    // Второй этап - загрузка в фоне
    launch(Dispatchers.Default) {
      val secondaryResources = listOf("level2.json", "level3.json", "enemies.png")
      loadResources(secondaryResources)
    }
  }
}

suspend fun streamLevel(levelId: String): Level {
  val level = Level()
  
  // Загружаем основные метаданные
  val meta = fetchLevelMeta(levelId)
  level.applyMeta(meta)
  
  // Запускаем потоковую загрузку тайлов
  streamLevelTiles(levelId) { chunk, isLast ->
    level.addTiles(chunk)
    if (!isLast) {
      // Обновляем отображаемую область по мере загрузки
      updateVisibleArea(level)
    }
  }
  
  return level
}

fun getOrGenerateTile(x: Int, y: Int): Tile {
  val key = "$x:$y"
  return tileCache.getOrPut(key) {
    // Генерируем тайл только когда он нужен
    generateTileForPosition(x, y, seed)
  }
}

val gameState = MutableStateFlow(initialState)
 
fun setupGameLoop() {
gameState
  .debounce(16) // ~60 FPS макс
  .onEach { state -> 
    updateGameLogic(state)
    render(state)
  }
  .launchIn(scope)
}
 
fun handleInput(input: UserInput) {
gameState.update { state -> state.applyInput(input) }
}

var processingStage = 0
val stages = 4 // Количество стадий обработки
 
fun gameFrame(timestamp: Double) {
val currentStage = processingStage
when (currentStage) {
  0 -> updatePhysics()
  1 -> updateAI()
  2 -> processCollisions()
  3 -> render()
}
processingStage = (currentStage + 1) % stages
js("requestAnimationFrame")(::gameFrame)
}

suspend fun gameLoop() {
while (isActive) {
  val frameStart = currentTime()
  updateGame()
  render()
  val frameTime = currentTime() - frameStart
  val sleepTime = maxOf(0, 16 - frameTime.toInt())
  delay(sleepTime.toLong())
}
}