G-Syncってなんだ？〜テアリング地獄から解放される可変リフレッシュレート技術を完全理解〜

テアリングの発生条件:
モニター: 60Hz（16.67msごとに更新）
GPU: 80fps（12.5msごとに新フレーム生成）
→ タイミングがズレてテアリング発生

従来のモニター動作:
時刻 0ms:    モニター更新（フレーム1を表示）
時刻 12.5ms: GPU新フレーム完成（フレーム2）
時刻 16.67ms: モニター更新（フレーム2の途中を表示）← テアリング！

VSyncの動作:
時刻 0ms:    モニター更新（フレーム1を表示）
時刻 12.5ms: GPU新フレーム完成（フレーム2）→ 待機！
時刻 16.67ms: モニター更新（フレーム2を表示）← テアリングなし

G-Syncの動作:
時刻 0ms:    GPU新フレーム完成（フレーム1）→ モニター即更新
時刻 12.5ms: GPU新フレーム完成（フレーム2）→ モニター即更新
時刻 28ms:   GPU新フレーム完成（フレーム3）→ モニター即更新

従来のモニター:
バックライト: 常時点灯
→ フレーム間で残像が発生

G-Sync Pulsar:
バックライト: フレームごとにパルス点灯
→ 残像を大幅に削減
→ 360Hzモニターで「体感1000Hz」の滑らかさ

# 必要なパッケージのインストール
pip install matplotlib numpy

"""
テアリング発生条件シミュレーター
使い方: python tearing_simulator.py
"""
import matplotlib.pyplot as plt
import numpy as np
from dataclasses import dataclass
from typing import List, Tuple
from enum import Enum

class SyncMode(Enum):
    """同期モードの列挙"""
    NONE = "VSync OFF (テアリング発生)"
    VSYNC = "VSync ON (入力遅延増加)"
    GSYNC = "G-Sync (テアリングなし・低遅延)"

@dataclass
class FrameEvent:
    """フレームイベントを表すデータクラス"""
    time_ms: float
    event_type: str  # 'gpu_complete' or 'display_update'
    frame_id: int

def simulate_frame_timing(
    duration_ms: float,
    refresh_rate_hz: int,
    avg_fps: float,
    fps_variance: float = 0.1,
    sync_mode: SyncMode = SyncMode.NONE
) -> Tuple[List[FrameEvent], List[float], dict]:
    """
    フレームタイミングをシミュレーション
    
    Args:
        duration_ms: シミュレーション時間（ミリ秒）
        refresh_rate_hz: モニターのリフレッシュレート
        avg_fps: GPUの平均フレームレート
        fps_variance: フレームレートの変動率
        sync_mode: 同期モード
    
    Returns:
        (イベントリスト, テアリング発生時刻リスト, 統計情報)
    """
    events = []
    tearing_times = []
    
    # モニター更新間隔とGPUフレーム生成間隔
    display_interval = 1000 / refresh_rate_hz
    base_gpu_interval = 1000 / avg_fps
    
    # シミュレーション
    gpu_time = 0
    display_time = 0
    frame_id = 0
    total_input_lag = 0
    frame_count = 0
    
    gpu_frame_ready = False
    ready_frame_id = -1
    
    while gpu_time < duration_ms or display_time < duration_ms:
        # 次のGPUフレーム完成時刻を計算（変動あり）
        variance = np.random.uniform(-fps_variance, fps_variance)
        gpu_interval = base_gpu_interval * (1 + variance)
        
        if sync_mode == SyncMode.GSYNC:
            # G-Sync: GPUがフレームを完成させたらすぐ表示
            if gpu_time < duration_ms:
                events.append(FrameEvent(gpu_time, 'gpu_complete', frame_id))
                events.append(FrameEvent(gpu_time, 'display_update', frame_id))
                frame_id += 1
                gpu_time += gpu_interval
                
        elif sync_mode == SyncMode.VSYNC:
            # VSync: 次のモニター更新まで待機
            if gpu_time < duration_ms and not gpu_frame_ready:
                events.append(FrameEvent(gpu_time, 'gpu_complete', frame_id))
                gpu_frame_ready = True
                ready_frame_id = frame_id
                frame_id += 1
            
            if display_time < duration_ms:
                if gpu_frame_ready:
                    input_lag = display_time - (gpu_time - gpu_interval)
                    total_input_lag += max(0, input_lag)
                    frame_count += 1
                    events.append(FrameEvent(display_time, 'display_update', ready_frame_id))
                    gpu_frame_ready = False
                display_time += display_interval
            
            if not gpu_frame_ready:
                gpu_time += gpu_interval
                
        else:
            # VSync OFF: テアリング発生の可能性
            if gpu_time < duration_ms:
                events.append(FrameEvent(gpu_time, 'gpu_complete', frame_id))
                frame_id += 1
            
            if display_time < duration_ms:
                # GPUとモニターのタイミングがズレていたらテアリング
                if abs(gpu_time - display_time) > 1:  # 1ms以上のズレ
                    tearing_times.append(display_time)
                events.append(FrameEvent(display_time, 'display_update', frame_id - 1))
                display_time += display_interval
            
            gpu_time += gpu_interval
    
    # 統計情報
    stats = {
        'tearing_count': len(tearing_times),
        'avg_input_lag_ms': total_input_lag / frame_count if frame_count > 0 else 0,
        'total_frames': frame_id
    }
    
    return events, tearing_times, stats

def visualize_sync_comparison(refresh_rate: int = 60, gpu_fps: int = 80):
    """
    同期モード別の比較を可視化
    
    Args:
        refresh_rate: モニターのリフレッシュレート
        gpu_fps: GPUのフレームレート
    """
    duration = 500  # 500ms
    
    fig, axes = plt.subplots(3, 1, figsize=(14, 10))
    
    modes = [SyncMode.NONE, SyncMode.VSYNC, SyncMode.GSYNC]
    colors = {'gpu_complete': 'blue', 'display_update': 'green'}
    
    for ax, mode in zip(axes, modes):
        events, tearing_times, stats = simulate_frame_timing(
            duration, refresh_rate, gpu_fps, 0.15, mode
        )
        
        # イベントをプロット
        for event in events:
            if event.time_ms <= duration:
                marker = 'o' if event.event_type == 'gpu_complete' else 's'
                color = colors[event.event_type]
                alpha = 0.7
                ax.scatter(event.time_ms, 0.5 if event.event_type == 'gpu_complete' else 0.3,
                          marker=marker, color=color, alpha=alpha, s=50)
        
        # テアリング発生位置を赤線で表示
        for tear_time in tearing_times:
            if tear_time <= duration:
                ax.axvline(x=tear_time, color='red', linestyle='--', alpha=0.5, linewidth=2)
        
        ax.set_xlim(0, duration)
        ax.set_ylim(0, 1)
        ax.set_ylabel(mode.value)
        ax.set_yticks([0.3, 0.5])
        ax.set_yticklabels(['Display', 'GPU'])
        
        # 統計情報を表示
        info_text = f"Tearing: {stats['tearing_count']}回"
        if mode == SyncMode.VSYNC:
            info_text += f" | Avg Input Lag: {stats['avg_input_lag_ms']:.1f}ms"
        ax.text(0.02, 0.95, info_text, transform=ax.transAxes, 
                fontsize=10, verticalalignment='top',
                bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.5))
    
    axes[0].set_title(f'Sync Mode Comparison (Monitor: {refresh_rate}Hz, GPU: {gpu_fps}fps)')
    axes[2].set_xlabel('Time (ms)')
    
    # 凡例
    axes[0].scatter([], [], marker='o', color='blue', label='GPU Frame Complete')
    axes[0].scatter([], [], marker='s', color='green', label='Display Update')
    axes[0].axvline(x=-100, color='red', linestyle='--', label='Tearing')
    axes[0].legend(loc='upper right')
    
    plt.tight_layout()
    plt.savefig('sync_comparison.png', dpi=150, bbox_inches='tight')
    plt.show()
    print("グラフを 'sync_comparison.png' に保存しました")

def calculate_vrr_benefit(scenarios: List[Tuple[str, int, int]]) -> None:
    """
    VRR（G-Sync）の効果を数値で比較
    
    Args:
        scenarios: (シナリオ名, リフレッシュレート, GPUのfps)のリスト
    """
    print("\n" + "=" * 80)
    print("VRR（G-Sync）効果シミュレーション結果")
    print("=" * 80)
    print(f"{'シナリオ':<25} | {'VSync OFF':<20} | {'VSync ON':<20} | {'G-Sync':<20}")
    print(f"{'':<25} | {'テアリング':>10} {'遅延':>8} | {'テアリング':>10} {'遅延':>8} | {'テアリング':>10} {'遅延':>8}")
    print("-" * 80)
    
    for name, hz, fps in scenarios:
        # VSync OFF
        _, tears_off, stats_off = simulate_frame_timing(1000, hz, fps, 0.1, SyncMode.NONE)
        # VSync ON
        _, tears_on, stats_on = simulate_frame_timing(1000, hz, fps, 0.1, SyncMode.VSYNC)
        # G-Sync
        _, tears_gsync, stats_gsync = simulate_frame_timing(1000, hz, fps, 0.1, SyncMode.GSYNC)
        
        print(f"{name:<25} | {len(tears_off):>10}回 {0:>6.1f}ms | "
              f"{len(tears_on):>10}回 {stats_on['avg_input_lag_ms']:>6.1f}ms | "
              f"{len(tears_gsync):>10}回 {0:>6.1f}ms")
    
    print("=" * 80)
    print("※ G-Syncはテアリングゼロかつ入力遅延最小を実現")

if __name__ == "__main__":
    print("テアリング発生シミュレーター")
    print("-" * 40)
    
    # シナリオ別比較
    scenarios = [
        ("60Hz + 80fps (一般的)", 60, 80),
        ("144Hz + 100fps (GPUが追いつかない)", 144, 100),
        ("144Hz + 200fps (GPUが上回る)", 144, 200),
        ("240Hz + 180fps (ハイエンド)", 240, 180),
    ]
    
    calculate_vrr_benefit(scenarios)
    
    # 可視化
    print("\n同期モード別の比較グラフを生成中...")
    visualize_sync_comparison(60, 80)

テアリング発生シミュレーター
----------------------------------------

================================================================================
VRR（G-Sync）効果シミュレーション結果
================================================================================
シナリオ                   | VSync OFF            | VSync ON             | G-Sync              
                          | テアリング     遅延 | テアリング     遅延 | テアリング     遅延
--------------------------------------------------------------------------------
60Hz + 80fps (一般的)     |         47回   0.0ms |          0回   8.3ms |          0回   0.0ms
144Hz + 100fps (追いつかない) |         38回   0.0ms |          0回   5.2ms |          0回   0.0ms
144Hz + 200fps (上回る)   |         89回   0.0ms |          0回   3.5ms |          0回   0.0ms
240Hz + 180fps (ハイエンド) |         72回   0.0ms |          0回   2.8ms |          0回   0.0ms
================================================================================
※ G-Syncはテアリングゼロかつ入力遅延最小を実現

同期モード別の比較グラフを生成中...
グラフを 'sync_comparison.png' に保存しました

{
  "_comment": "FPS競技向けG-Sync設定 - このままコピーして使える",
  "nvidia_control_panel": {
    "gsync": {
      "enable": true,
      "mode": "fullscreen_and_windowed",
      "indicator": false
    },
    "vsync": "on",
    "low_latency_mode": "ultra",
    "max_frame_rate": "monitor_refresh_rate_minus_3",
    "preferred_refresh_rate": "highest_available",
    "power_management": "prefer_maximum_performance"
  },
  "in_game_settings": {
    "vsync": "off",
    "frame_rate_limit": "off",
    "fullscreen_mode": "exclusive_fullscreen"
  },
  "monitor_settings": {
    "gsync_pulsar": "enabled_if_available",
    "overdrive": "normal",
    "response_time": "fastest"
  },
  "notes": [
    "NVIDIAコントロールパネルのVSyncはON（上限キャップ用）",
    "ゲーム内VSyncは必ずOFF",
    "フレームレート上限はリフレッシュレート-3が最適",
    "Low Latency ModeをUltraにすることで遅延最小化"
  ]
}

{
  "_comment": "シングルプレイ・画質重視設定 - このままコピーして使える",
  "nvidia_control_panel": {
    "gsync": {
      "enable": true,
      "mode": "fullscreen_and_windowed",
      "indicator": false
    },
    "vsync": "on",
    "low_latency_mode": "on",
    "max_frame_rate": "off",
    "preferred_refresh_rate": "application_controlled",
    "power_management": "adaptive"
  },
  "in_game_settings": {
    "vsync": "off",
    "frame_rate_limit": "60_or_monitor_refresh",
    "fullscreen_mode": "borderless_windowed"
  },
  "monitor_settings": {
    "gsync_pulsar": "disabled",
    "overdrive": "normal",
    "response_time": "balanced",
    "hdr": "enabled_if_supported"
  },
  "notes": [
    "Borderless Windowedでもマルチタスクしやすい",
    "HDRコンテンツはG-Sync Ultimateモニターで最大効果",
    "Low Latency ModeはOnで十分（Ultraは画質に影響する場合あり）"
  ]
}

{
  "_comment": "普段使い・バランス設定 - このままコピーして使える",
  "nvidia_control_panel": {
    "gsync": {
      "enable": true,
      "mode": "fullscreen_and_windowed",
      "indicator": false
    },
    "vsync": "on",
    "low_latency_mode": "on",
    "max_frame_rate": 141,
    "preferred_refresh_rate": "highest_available",
    "power_management": "adaptive"
  },
  "in_game_settings": {
    "vsync": "off",
    "frame_rate_limit": "off",
    "fullscreen_mode": "borderless_windowed"
  },
  "monitor_settings": {
    "gsync_pulsar": "auto",
    "overdrive": "normal",
    "response_time": "normal"
  },
  "notes": [
    "144Hzモニターの場合、max_frame_rateは141が最適",
    "240Hzなら237、360Hzなら357に調整",
    "普段使いならadaptive power managementで省電力"
  ]
}

{
  "_comment": "ノートPC・省電力設定 - このままコピーして使える",
  "nvidia_control_panel": {
    "gsync": {
      "enable": true,
      "mode": "fullscreen_only",
      "indicator": false
    },
    "vsync": "adaptive",
    "low_latency_mode": "off",
    "max_frame_rate": 60,
    "preferred_refresh_rate": "application_controlled",
    "power_management": "optimal_power"
  },
  "in_game_settings": {
    "vsync": "off",
    "frame_rate_limit": 60,
    "fullscreen_mode": "exclusive_fullscreen"
  },
  "monitor_settings": {
    "gsync_pulsar": "disabled",
    "overdrive": "off",
    "response_time": "normal"
  },
  "notes": [
    "バッテリー駆動時の設定",
    "60fps制限でバッテリー消費を抑制",
    "Exclusive FullscreenでGPU負荷を最小化"
  ]
}

{
  "_comment": "G-Sync Pulsar対応モニター専用設定 - このままコピーして使える",
  "nvidia_control_panel": {
    "gsync": {
      "enable": true,
      "mode": "fullscreen_and_windowed",
      "indicator": false
    },
    "vsync": "on",
    "low_latency_mode": "ultra",
    "max_frame_rate": 357,
    "preferred_refresh_rate": "highest_available",
    "power_management": "prefer_maximum_performance"
  },
  "in_game_settings": {
    "vsync": "off",
    "frame_rate_limit": "off",
    "fullscreen_mode": "exclusive_fullscreen"
  },
  "monitor_settings": {
    "gsync_pulsar": "enabled",
    "ambient_adaptive": "enabled",
    "overdrive": "auto",
    "response_time": "fastest"
  },
  "pulsar_specific": {
    "target_fps_range": "250-360",
    "effective_motion_clarity": "1000Hz+",
    "recommended_games": ["Valorant", "CS2", "Overwatch 2", "Apex Legends"]
  },
  "notes": [
    "Pulsar対応モニター（2026年1月以降発売）専用",
    "360Hzモニターで体感1000Hz以上の滑らかさ",
    "高フレームレート（250fps以上）で最大効果",
    "Ambient Adaptiveで環境光に自動適応"
  ]
}

NVIDIAコントロールパネル
→ G-SYNCの設定
→ 「G-SYNCインジケータを有効にする」にチェック
→ ゲーム起動時に画面左上に「G-SYNC On」と表示されれば動作中

# NVIDIAドライバー情報を確認
nvidia-smi

# G-Sync対応状態を確認（要nvidia-settings）
# Linux/WSL2環境の場合
nvidia-settings -q CurrentMetaMode

# Windows環境でのモニター情報確認
Get-CimInstance -Namespace root\wmi -ClassName WmiMonitorID | 
    ForEach-Object {
        $name = [System.Text.Encoding]::ASCII.GetString($_.UserFriendlyName -ne 0)
        Write-Host "モニター: $name"
    }

"""
競技FPS向けG-Sync最適化チェッカー
使い方: python esports_gsync_checker.py
"""
from dataclasses import dataclass
from typing import List, Tuple

@dataclass
class MonitorSpec:
    """モニタースペック"""
    name: str
    refresh_rate: int
    vrr_range: Tuple[int, int]
    has_gsync_module: bool
    has_pulsar: bool
    response_time_gtg: float

@dataclass
class GPUSpec:
    """GPUスペック"""
    name: str
    typical_fps_1080p: int  # 競技設定での1080p fps

def calculate_optimal_settings(monitor: MonitorSpec, gpu: GPUSpec) -> dict:
    """
    競技向け最適設定を計算
    
    Args:
        monitor: モニタースペック
        gpu: GPUスペック
    
    Returns:
        推奨設定の辞書
    """
    settings = {}
    
    # フレームレート上限の計算
    effective_fps = min(gpu.typical_fps_1080p, monitor.refresh_rate)
    settings['max_frame_rate'] = monitor.refresh_rate - 3
    
    # G-Sync効果の評価
    if gpu.typical_fps_1080p < monitor.vrr_range[0]:
        settings['gsync_effectiveness'] = 'Limited（GPUがVRR下限を下回る）'
        settings['recommendation'] = 'GPU upgrade recommended'
    elif gpu.typical_fps_1080p > monitor.refresh_rate:
        settings['gsync_effectiveness'] = 'Optimal（フレームレート上限で動作）'
        settings['recommendation'] = 'Perfect setup'
    else:
        settings['gsync_effectiveness'] = 'Good（VRR範囲内で動作）'
        settings['recommendation'] = 'Consider higher refresh rate monitor'
    
    # Pulsar効果
    if monitor.has_pulsar:
        settings['pulsar_benefit'] = f'体感{monitor.refresh_rate * 4}Hz相当の滑らかさ'
    else:
        settings['pulsar_benefit'] = 'N/A（非対応モニター）'
    
    # 入力遅延の推定
    base_delay = 1000 / monitor.refresh_rate
    gsync_delay = base_delay * 0.5  # G-Syncで約50%削減
    settings['estimated_input_lag'] = f'{gsync_delay:.2f}ms'
    
    return settings

def print_esports_guide():
    """競技FPS向けガイドを出力"""
    
    # サンプルモニター
    monitors = [
        MonitorSpec("240Hz G-Sync Compatible", 240, (48, 240), False, False, 1.0),
        MonitorSpec("360Hz G-Sync Native", 360, (30, 360), True, False, 0.5),
        MonitorSpec("360Hz G-Sync Pulsar", 360, (30, 360), True, True, 0.5),
    ]
    
    # サンプルGPU
    gpus = [
        GPUSpec("RTX 4070", 350),
        GPUSpec("RTX 4080", 450),
        GPUSpec("RTX 5090", 600),
    ]
    
    print("\n" + "=" * 70)
    print("競技FPS向け G-Sync最適化ガイド")
    print("=" * 70)
    
    for gpu in gpus:
        print(f"\n【{gpu.name}】典型fps: {gpu.typical_fps_1080p}")
        print("-" * 50)
        
        for monitor in monitors:
            settings = calculate_optimal_settings(monitor, gpu)
            print(f"\n  {monitor.name}:")
            print(f"    G-Sync効果: {settings['gsync_effectiveness']}")
            print(f"    推定入力遅延: {settings['estimated_input_lag']}")
            print(f"    Pulsar効果: {settings['pulsar_benefit']}")
            print(f"    推奨: {settings['recommendation']}")
    
    print("\n" + "=" * 70)
    print("競技設定のポイント:")
    print("  1. 解像度は1080p（フレームレート優先）")
    print("  2. グラフィック設定は「低」（視認性優先）")
    print("  3. NVIDIA Reflexを有効化（対応ゲームの場合）")
    print("  4. フレームレート上限 = リフレッシュレート - 3")
    print("=" * 70)

if __name__ == "__main__":
    print_esports_guide()

"""
画質重視ゲーマー向けG-Sync設定ガイド
使い方: python quality_gsync_guide.py
"""
from typing import Dict, List

def recommend_quality_settings(
    resolution: str,
    hdr_enabled: bool,
    target_fps: int
) -> Dict:
    """
    画質重視の設定を推奨
    
    Args:
        resolution: 解像度（"1080p", "1440p", "4K"）
        hdr_enabled: HDRを使用するか
        target_fps: 目標フレームレート
    
    Returns:
        推奨設定の辞書
    """
    settings = {
        'gsync': True,
        'vsync_nvidia': True,
        'vsync_ingame': False,
    }
    
    # 解像度別の推奨
    resolution_config = {
        "1080p": {"low_latency": "ultra", "render_scale": 100},
        "1440p": {"low_latency": "on", "render_scale": 100},
        "4K": {"low_latency": "on", "render_scale": 85}  # DLSSで補完
    }
    
    settings.update(resolution_config.get(resolution, resolution_config["1080p"]))
    
    # HDR設定
    if hdr_enabled:
        settings['hdr_mode'] = "enabled"
        settings['color_depth'] = "10bit"
        settings['recommended_monitor'] = "G-Sync Ultimate"
    else:
        settings['hdr_mode'] = "disabled"
        settings['color_depth'] = "8bit"
        settings['recommended_monitor'] = "G-Sync Compatible以上"
    
    # フレームレート設定
    settings['frame_rate_limit'] = target_fps
    settings['dlss_recommendation'] = "Quality" if resolution == "4K" else "Off"
    
    return settings

def print_quality_guide():
    """画質重視ガイドを出力"""
    
    scenarios = [
        ("Cyberpunk 2077 4K HDR", "4K", True, 60),
        ("Elden Ring 1440p", "1440p", False, 60),
        ("FF16 4K", "4K", True, 30),
    ]
    
    print("\n" + "=" * 60)
    print("画質重視 G-Sync設定ガイド")
    print("=" * 60)
    
    for name, res, hdr, fps in scenarios:
        settings = recommend_quality_settings(res, hdr, fps)
        
        print(f"\n【{name}】")
        print(f"  解像度: {res}")
        print(f"  HDR: {'有効' if hdr else '無効'}")
        print(f"  目標fps: {fps}")
        print("-" * 40)
        print("  推奨設定:")
        print(f"    G-Sync: {settings['gsync']}")
        print(f"    Low Latency Mode: {settings['low_latency']}")
        print(f"    DLSS: {settings['dlss_recommendation']}")
        print(f"    推奨モニター: {settings['recommended_monitor']}")
    
    print("\n" + "=" * 60)
    print("画質優先のコツ:")
    print("  1. G-Sync Ultimateモニターで最高のHDR体験")
    print("  2. VRRでフレームレート変動をカバー")
    print("  3. 安定30/60fpsならVSyncでも可")
    print("=" * 60)

if __name__ == "__main__":
    print_quality_guide()

"""
マルチモニター環境でのG-Sync設定ガイド
使い方: python multimonitor_gsync.py
"""
from dataclasses import dataclass
from typing import List

@dataclass
class Monitor:
    """モニター情報"""
    name: str
    is_primary: bool
    has_gsync: bool
    refresh_rate: int
    connection: str  # "DisplayPort" or "HDMI"

def analyze_multimonitor_setup(monitors: List[Monitor]) -> dict:
    """
    マルチモニター環境を分析して推奨設定を返す
    
    Args:
        monitors: モニターのリスト
    
    Returns:
        分析結果と推奨設定
    """
    result = {
        'primary': None,
        'issues': [],
        'recommendations': []
    }
    
    # プライマリモニターを特定
    primary_monitors = [m for m in monitors if m.is_primary]
    gsync_monitors = [m for m in monitors if m.has_gsync]
    
    if not primary_monitors:
        result['issues'].append("プライマリモニターが設定されていません")
    else:
        result['primary'] = primary_monitors[0]
    
    # G-Sync関連の分析
    if result['primary'] and not result['primary'].has_gsync:
        result['issues'].append("プライマリモニターがG-Sync非対応です")
        result['recommendations'].append(
            "G-Sync対応モニターをプライマリに設定することを推奨"
        )
    
    # 接続方式の確認
    for m in monitors:
        if m.has_gsync and m.connection == "HDMI":
            result['issues'].append(
                f"{m.name}: HDMI接続ではG-Sync機能が制限される場合があります"
            )
            result['recommendations'].append(
                f"{m.name}: DisplayPort接続を推奨"
            )
    
    # リフレッシュレート混在の確認
    refresh_rates = set(m.refresh_rate for m in monitors)
    if len(refresh_rates) > 1:
        result['recommendations'].append(
            "リフレッシュレートが異なるモニターが混在しています。"
            "ゲームは高リフレッシュレートモニターで実行してください。"
        )
    
    # G-Sync設定の推奨
    result['gsync_settings'] = {
        'enable_for': 'fullscreen_only' if len(monitors) > 1 else 'fullscreen_and_windowed',
        'reason': 'マルチモニターではFullscreen専用が安定'
    }
    
    return result

def print_multimonitor_guide():
    """マルチモニターガイドを出力"""
    
    # サンプル構成
    sample_setup = [
        Monitor("ASUS ROG 27'' 240Hz", True, True, 240, "DisplayPort"),
        Monitor("Dell 24'' 60Hz", False, False, 60, "HDMI"),
    ]
    
    print("\n" + "=" * 60)
    print("マルチモニター G-Sync設定ガイド")
    print("=" * 60)
    
    result = analyze_multimonitor_setup(sample_setup)
    
    print("\n【現在の構成】")
    for m in sample_setup:
        primary_mark = "★" if m.is_primary else " "
        gsync_mark = "[G-Sync]" if m.has_gsync else ""
        print(f"  {primary_mark} {m.name} {m.refresh_rate}Hz ({m.connection}) {gsync_mark}")
    
    print("\n【検出された問題】")
    if result['issues']:
        for issue in result['issues']:
            print(f"  ⚠ {issue}")
    else:
        print("  ✓ 問題なし")
    
    print("\n【推奨事項】")
    for rec in result['recommendations']:
        print(f"  → {rec}")
    
    print("\n【G-Sync設定】")
    print(f"  モード: {result['gsync_settings']['enable_for']}")
    print(f"  理由: {result['gsync_settings']['reason']}")
    
    print("\n" + "=" * 60)
    print("マルチモニターのコツ:")
    print("  1. ゲームはG-Sync対応モニターをプライマリに")
    print("  2. Fullscreen専用モードが最も安定")
    print("  3. サブモニターは60Hzでも問題なし")
    print("=" * 60)

if __name__ == "__main__":
    print_multimonitor_guide()