Unity × Gemini Multimodal Complete Implementation — Advanced Code Collection

public class StreamingDownloadHandler : DownloadHandlerScript
{
    private Action<string> _onChunkReceived;
    private StringBuilder _buffer = new StringBuilder();
 
    public StreamingDownloadHandler(Action<string> onChunkReceived)
    {
        _onChunkReceived = onChunkReceived;
    }
 
    protected override bool ReceiveData(byte[] data, int dataLength)
    {
        var chunk = Encoding.UTF8.GetString(data, 0, dataLength);
        ProcessStreamChunk(chunk);
        return true;
    }
 
    private void ProcessStreamChunk(string chunk)
    {
        var lines = chunk.Split('\n');
 
        foreach (var line in lines)
        {
            if (string.IsNullOrWhiteSpace(line))
                continue;
 
            if (line.StartsWith("data: "))
            {
                var jsonPart = line.Substring(6);
 
                try
                {
                    var response = JsonUtility.FromJson<StreamResponse>(jsonPart);
 
                    if (response?.candidates?.Length > 0)
                    {
                        var candidate = response.candidates[0];
                        if (candidate.content?.parts?.Length > 0)
                        {
                            var text = candidate.content.parts[0].text;
                            if (!string.IsNullOrEmpty(text))
                            {
                                _onChunkReceived?.Invoke(text);
                                _buffer.Append(text);
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    Debug.LogWarning($"Parse error: {ex.Message}");
                }
            }
        }
    }
 
    [System.Serializable]
    private class StreamResponse { public Candidate[] candidates; }
 
    [System.Serializable]
    private class Candidate { public Content content; }
 
    [System.Serializable]
    private class Content { public Part[] parts; }
 
    [System.Serializable]
    private class Part { public string text; }
}
 
public class GeminiStreamingClient
{
    private const string API_URL =
        "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:streamGenerateContent";
 
    public void StreamGenerateContent(
        string prompt,
        Action<string> onChunkReceived,
        Action<string> onComplete)
    {
        // Coroutine implementation for streaming
    }
}

public class NPCDialogController : MonoBehaviour
{
    [SerializeField] private TextMeshProUGUI _dialogText;
    [SerializeField] private float _characterDisplaySpeed = 0.05f;
 
    private string _currentFullText = "";
    private float _lastCharTime = 0;
    private int _displayedCharCount = 0;
    private bool _isStreaming = false;
 
    public void StartDialog(string prompt)
    {
        if (_isStreaming) return;
 
        _currentFullText = "";
        _displayedCharCount = 0;
        _dialogText.text = "";
        _isStreaming = true;
 
        var config = new GeminiRequestConfig
        {
            Temperature = 0.7f,
            MaxOutputTokens = 512
        };
 
        _geminiClient.StreamGenerateContent(
            prompt: prompt,
            onChunkReceived: OnChunkReceived,
            onComplete: OnDialogComplete
        );
    }
 
    private void OnChunkReceived(string text)
    {
        _currentFullText += text;
    }
 
    private void Update()
    {
        if (_isStreaming && _displayedCharCount < _currentFullText.Length)
        {
            if (Time.time - _lastCharTime >= _characterDisplaySpeed)
            {
                _displayedCharCount++;
                _dialogText.text = _currentFullText.Substring(0, _displayedCharCount);
                _lastCharTime = Time.time;
            }
        }
    }
 
    private void OnDialogComplete(string fullText)
    {
        _isStreaming = false;
        Debug.Log("Dialog complete!");
    }
}

public class GameScreenshotAnalyzer : MonoBehaviour
{
    private GeminiStreamingClient _geminiClient;
 
    public void AnalyzeCurrentGameState(
        Action<string> onAnalysisComplete,
        Action<string> onError)
    {
        var screenshotPath = CaptureScreenshot();
        AnalyzeScreenshot(screenshotPath, onAnalysisComplete, onError);
    }
 
    private string CaptureScreenshot()
    {
        var filename = Path.Combine(
            Application.persistentDataPath,
            $"screenshot_{System.DateTime.Now:yyyy-MM-dd_HH-mm-ss}.png"
        );
 
        ScreenCapture.CaptureScreenshot(filename);
        return filename;
    }
 
    private void AnalyzeScreenshot(
        string imagePath,
        Action<string> onAnalysisComplete,
        Action<string> onError)
    {
        StartCoroutine(AnalyzeScreenshotCoroutine(imagePath, onAnalysisComplete, onError));
    }
 
    private IEnumerator AnalyzeScreenshotCoroutine(
        string imagePath,
        Action<string> onAnalysisComplete,
        Action<string> onError)
    {
        // Wait for file to exist
        float waitTime = 0;
        while (!File.Exists(imagePath) && waitTime < 3f)
        {
            yield return new WaitForSeconds(0.1f);
            waitTime += 0.1f;
        }
 
        if (!File.Exists(imagePath))
        {
            onError?.Invoke("Screenshot not found");
            yield break;
        }
 
        // Encode to Base64
        var imageBytes = File.ReadAllBytes(imagePath);
        var base64Image = System.Convert.ToBase64String(imageBytes);
 
        var request = new VisionRequest
        {
            contents = new[] {
                new Content {
                    role = "user",
                    parts = new[] {
                        new Part { text = "Analyze this game screenshot:\n1. What's happening?\n2. Visible NPCs/enemies?\n3. Suggested next action?\n4. Danger level 1-10?" },
                        new Part { inlineData = new InlineData { mimeType = "image/png", data = base64Image } }
                    }
                }
            }
        };
 
        var jsonPayload = JsonUtility.ToJson(request);
 
        using (var www = new UnityWebRequest(
            "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent",
            "POST"))
        {
            www.uploadHandler = new UploadHandlerRaw(Encoding.UTF8.GetBytes(jsonPayload));
            www.downloadHandler = new DownloadHandlerBuffer();
            www.SetRequestHeader("Content-Type", "application/json");
            www.SetRequestHeader("x-goog-api-key", GetApiKey());
 
            yield return www.SendWebRequest();
 
            if (www.result == UnityWebRequest.Result.Success)
            {
                var response = JsonUtility.FromJson<VisionResponse>(www.downloadHandler.text);
                var analysisText = response.candidates[0].content.parts[0].text;
                onAnalysisComplete?.Invoke(analysisText);
            }
            else
            {
                onError?.Invoke($"API Error: {www.error}");
            }
        }
    }
 
    [System.Serializable]
    private class VisionRequest { public Content[] contents; }
 
    [System.Serializable]
    private class InlineData { public string mimeType; public string data; }
 
    // Additional classes omitted for brevity
}

public class VoiceDialogueEngine : MonoBehaviour
{
    [SerializeField] private AudioSource _audioSource;
    [SerializeField] private int _sampleRate = 16000;
 
    public void StartVoiceDialog()
    {
        StartCoroutine(VoiceDialogueCoroutine());
    }
 
    private IEnumerator VoiceDialogueCoroutine()
    {
        // Step 1: Record audio (5 seconds)
        Debug.Log("Recording... speak now!");
        _recordingClip = Microphone.Start(null, false, 5, _sampleRate);
        yield return new WaitForSeconds(5f);
        Microphone.End(null);
 
        var audioBytes = ConvertAudioToWav(_recordingClip);
 
        // Step 2: Speech-to-Text
        string userText = null;
        yield return StartCoroutine(
            SpeechToTextCoroutine(audioBytes, result => userText = result)
        );
 
        if (string.IsNullOrEmpty(userText))
        {
            Debug.LogError("Speech recognition failed");
            yield break;
        }
 
        Debug.Log($"Recognized: {userText}");
 
        // Step 3: Gemini API response
        string geminiResponse = "";
        _geminiClient.StreamGenerateContent(
            prompt: userText,
            onChunkReceived: chunk => geminiResponse += chunk,
            onComplete: _ => { }
        );
 
        yield return new WaitUntil(() => !string.IsNullOrEmpty(geminiResponse));
 
        // Step 4: Text-to-Speech
        yield return StartCoroutine(
            TextToSpeechCoroutine(geminiResponse, audioClip =>
            {
                _audioSource.clip = audioClip;
                _audioSource.Play();
            })
        );
    }
 
    private byte[] ConvertAudioToWav(AudioClip clip)
    {
        var samples = new float[clip.samples * clip.channels];
        clip.GetData(samples, 0);
 
        var bytesPerSample = 2;
        var dataSize = samples.Length * bytesPerSample;
 
        using (var memoryStream = new System.IO.MemoryStream(44 + dataSize))
        using (var writer = new System.IO.BinaryWriter(memoryStream))
        {
            // WAV header
            writer.Write(System.Text.Encoding.ASCII.GetBytes("RIFF"));
            writer.Write(36 + dataSize);
            writer.Write(System.Text.Encoding.ASCII.GetBytes("WAVE"));
            writer.Write(System.Text.Encoding.ASCII.GetBytes("fmt "));
            writer.Write(16);
            writer.Write((ushort)1);
            writer.Write((ushort)clip.channels);
            writer.Write(_sampleRate);
            writer.Write(_sampleRate * clip.channels * bytesPerSample);
            writer.Write((ushort)(clip.channels * bytesPerSample));
            writer.Write((ushort)(bytesPerSample * 8));
            writer.Write(System.Text.Encoding.ASCII.GetBytes("data"));
            writer.Write(dataSize);
 
            foreach (var sample in samples)
            {
                writer.Write((short)(sample * 32767f));
            }
 
            return memoryStream.ToArray();
        }
    }
 
    // Speech-to-Text and Text-to-Speech implementations follow similar patterns
}

public class ConversationContextManager
{
    private const int MAX_CONTEXT_TOKENS = 6000;
    private List<ConversationTurn> _conversationHistory;
    private int _totalTokensUsed = 0;
 
    public void AddMessage(string role, string content)
    {
        var estimatedTokens = EstimateTokens(content);
 
        if (_totalTokensUsed + estimatedTokens > MAX_CONTEXT_TOKENS)
        {
            PruneOldMessages(estimatedTokens);
        }
 
        _conversationHistory.Add(new ConversationTurn
        {
            role = role,
            content = content,
            estimatedTokens = estimatedTokens
        });
 
        _totalTokensUsed += estimatedTokens;
        Debug.Log($"Tokens: {_totalTokensUsed}/{MAX_CONTEXT_TOKENS}");
    }
 
    public GeminiStreamingClient.Content[] GetContextForAPI()
    {
        return _conversationHistory
            .Select(turn => new GeminiStreamingClient.Content
            {
                role = turn.role,
                parts = new[] { new GeminiStreamingClient.Part { text = turn.content } }
            })
            .ToArray();
    }
 
    private void PruneOldMessages(int requiredTokens)
    {
        while (_conversationHistory.Count > 1 &&
               _totalTokensUsed + requiredTokens > MAX_CONTEXT_TOKENS)
        {
            var oldMessage = _conversationHistory[0];
            _totalTokensUsed -= oldMessage.estimatedTokens;
            _conversationHistory.RemoveAt(0);
        }
    }
 
    private int EstimateTokens(string text)
    {
        return Mathf.CeilToInt(text.Length / 4f);
    }
 
    [System.Serializable]
    private class ConversationTurn
    {
        public string role;
        public string content;
        public int estimatedTokens;
    }
}