dependencies:
  flutter:
    sdk: flutter
  flutter_unity_widget: ^2022.2.1

environment:
  sdk: ">=3.4.0 <4.0.0"
  flutter: ">=3.22.0"

dependencies:
  flutter:
    sdk: flutter
  unity_kit: ^2.0.3

UnityWidget(
  onUnityCreated: (controller) => _controller = controller,
  onUnityMessage: (message) => debugPrint('From Unity: $message'),
  onUnitySceneLoaded: (scene) => debugPrint('Scene: ${scene?.name}'),
  onUnityUnloaded: () => debugPrint('Unloaded'),
  fullscreen: false,
  hideStatus: false,
  runImmediately: true,
  unloadOnDispose: true,
  useAndroidViewSurface: true,
  enablePlaceholder: true,
  placeholder: const Center(child: CircularProgressIndicator()),
)

UnityView(
  // Pass the bridge you created above. An external bridge is NEVER disposed
  // by the widget. Omit it and the widget creates + owns an internal one.
  bridge: bridge,
  config: const UnityConfig(
    sceneName: 'MainScene',
    fullscreen: false,
    hideStatusBar: false,
    runImmediately: true,
    unloadOnDispose: true,
    targetFrameRate: 60,
  ),
  placeholder: const Center(child: CircularProgressIndicator()),
  onReady: (bridge) => bridge.send(UnityMessage.command('StartGame')),
  onMessage: (message) => debugPrint('${message.type} ${message.data}'),
  onSceneLoaded: (scene) => debugPrint('Scene: ${scene.name}'),
  onEvent: (event) => debugPrint('Lifecycle: ${event.type}'),
)

_controller.postMessage('GameManager', 'RotateCube', '360');
_controller.postJsonMessage('Player', 'TakeDamage', {'amount': 10});

// Same UnitySendMessage(gameObject, method) target as postMessage:
await bridge.send(UnityMessage.to('GameManager', 'RotateCube', {'angle': 360}));

// Sent before Unity is up? Queued by the readiness guard, flushed on ready:
await bridge.sendWhenReady(
  UnityMessage.to('Player', 'TakeDamage', {'amount': 10}),
);

// Routed through FlutterBridge + MessageRouter, no GameObject lookup needed:
await bridge.sendWhenReady(
  UnityMessage.routed('InventoryManager', 'AddItem', {'id': 'sword'}),
);

// High-frequency traffic (input, transforms): compact binary frame, not JSON:
await bridge.sendBinary(UnityMessage.command('Move', {'x': 1.0, 'y': 0.0}));

onUnityMessage: (dynamic message) {
  // message is dynamic: usually a String, sometimes an @UnityMessage@ envelope
  final raw = message.toString();
  if (raw.startsWith('score:')) {
    setState(() => _score = int.parse(raw.split(':').last));
  }
}

// Option A: the widget callback, typed
onMessage: (UnityMessage message) {
  switch (message.type) {
    case 'score_updated':
      setState(() => _score = message.data?['score'] as int? ?? 0);
    case 'game_over':
      _navigateToSummary();
  }
}

// Option B: subscribe anywhere, because the bridge outlives the widget
final subscription = bridge.messageStream
    .where((message) => message.type == 'score_updated')
    .listen((message) => scoreCubit.update(message.data?['score'] as int? ?? 0));

// Other typed streams, no polling required:
bridge.sceneStream.listen((SceneInfo scene) => ...);
bridge.eventStream.listen((UnityEvent event) => ...);
bridge.lifecycleStream.listen((UnityLifecycleState state) => ...);
bridge.performanceStream.listen((UnityPerformanceStats stats) => ...);

final ready = await _controller.isReady();
final paused = await _controller.isPaused();
final loaded = await _controller.isLoaded();
final background = await _controller.inBackground();

await _controller.pause();
await _controller.resume();
await _controller.unload();
await _controller.quit();
_controller.dispose();

final ready = bridge.isReady;                          // sync getter, no await
final state = bridge.currentState;                     // UnityLifecycleState
final paused = state == UnityLifecycleState.paused;

await bridge.pause();
await bridge.resume();
await bridge.unload();
await bridge.dispose();

// Instead of polling three futures, listen to the state machine:
bridge.lifecycleStream.listen((state) {
  if (state == UnityLifecycleState.ready) _onUnityUp();
});

using FlutterUnityIntegration;   // ships JsonDotNet (Newtonsoft)

public class GameManager : MonoBehaviour
{
    // Invoked by UnitySendMessage, receives the raw string from postMessage
    public void RotateCube(string message)
    {
        var degrees = float.Parse(message);   // "360"
    }

    private void OnWaveCleared()
    {
        UnityMessageManager.Instance.SendMessageToFlutter("wave_cleared");
    }
}

using UnityKit;   // no Newtonsoft, UnityKit uses JsonUtility

public class GameManager : FlutterMonoBehaviour
{
    // One entry point instead of one public method per command.
    // Auto-registers with MessageRouter under TargetName (GameObject name
    // by default, or the Target Name field in the inspector).
    protected override void OnFlutterMessage(string method, string data)
    {
        switch (method)
        {
            case "RotateCube":
                // data is the JSON payload: {"angle":360}
                var request = JsonUtility.FromJson<RotateRequest>(data);
                break;
        }
    }

    private void OnWaveCleared()
    {
        // Scalar payload: arrives in Dart as message.data['value']
        SendToFlutter("wave_cleared", "3");

        // Structured payload: build the full envelope yourself
        NativeAPI.SendToFlutter("{\"type\":\"score_updated\",\"data\":{\"score\":1500}}");
    }

    [System.Serializable]
    private class RotateRequest { public float angle; }
}