レガシー第19章：リアルタイム通信とパケットシリアライズ

• 即時性 vs 信頼性のトレードオフ: リアルタイムアクションゲームでは「古いデータが確実に届く」ことよりも「最新データが今すぐ届く」即時性が最優先される。
• ヘッドオブラインブロッキングの回避: TCPの再送待ちによる全停止を避けるため、ゲーム同期にはUDPをベースに採用するのが商用エンジンの標準。

### エンディアン（バイト順）の恐怖

例えば 32ビット整数「0x12345678」（10進数で 305419896）をメモリに置くとき：

- **リトルエンディアン（PC/x86/現代のスマホ）**: [78] [56] [34] [12] （下位バイトから順に格納）
- **ビッグエンディアン（ネットワークバイトオーダー/旧PowerPC等）**: [12] [34] [56] [78] （上位バイトから順に格納）

ネットワークに流すデータは必ず【ネットワークバイトオーダー（ビッグエンディアン）】に変換する規格になっています。
これを変換するのが以下の標準関数です：

- htonl() : Host to Network Long (32bit)
- ntohl() : Network to Host Long (32bit)
- htons() : Host to Network Short (16bit)
- ntohs() : Network to Host Short (16bit)

さらに、構造体をそのままバイナリ送信する場合、コンパイラが勝手に挟む【パディング（隙間）】を「#pragma pack(push, 1)」で詰める必要があります。

#ifndef PACKET_DEFINITION_HPP
#define PACKET_DEFINITION_HPP

#include <iostream>
#include <cstring>
#include <cstdint>

#if defined(_WIN32)
#include <winsock2.h>
#else
#include <arpa/inet.h>
#endif

// 構造体のパディング（アライメントの隙間）を強制的に1バイト単位に詰める
#pragma pack(push, 1)

// 自機・敵の座標同期パケット
struct PlayerSyncPacket {
    uint8_t packetType;  // 1: 位置同期
    uint32_t sequenceId; // パケット通し番号
    int16_t posX;        // X座標
    int16_t posY;        // Y座標
    uint8_t inputBits;   // キー入力フラグ（L16のビットフラグ！）
};

#pragma pack(pop)

// パケットのシリアライズ（送信前のバイト順変換）
inline void serializePlayerPacket(const PlayerSyncPacket& src, char* buffer) {
    PlayerSyncPacket netPacket;
    netPacket.packetType = src.packetType;
    netPacket.sequenceId = htonl(src.sequenceId);
    netPacket.posX = (int16_t)htons((uint16_t)src.posX);
    netPacket.posY = (int16_t)htons((uint16_t)src.posY);
    netPacket.inputBits = src.inputBits;
    
    std::memcpy(buffer, &netPacket, sizeof(PlayerSyncPacket));
}

// パケットのデシリアライズ（受信後のホストバイト順変換）
inline void deserializePlayerPacket(const char* buffer, PlayerSyncPacket& dst) {
    PlayerSyncPacket netPacket;
    std::memcpy(&netPacket, buffer, sizeof(PlayerSyncPacket));
    
    dst.packetType = netPacket.packetType;
    dst.sequenceId = ntohl(netPacket.sequenceId);
    dst.posX = (int16_t)ntohs((uint16_t)netPacket.posX);
    dst.posY = (int16_t)ntohs((uint16_t)netPacket.posY);
    dst.inputBits = netPacket.inputBits;
}

#endif

• htonl / ntohl の徹底: ネットワークを流れる整数データは必ずネットワークバイト順（ビッグエンディアン）に変換して送受する。
• #pragma pack(push, 1) による構造体パッキング: コンパイラやOSによって異なるパディングバイトの混入を防ぐため、通信用パケットはアライメントを1バイトに固定する。

#include <iostream>

struct Vector2D {
    float x;
    float y;
};

// 線形補間（Lerp: AからBへ t (0.0〜1.0) の割合で補間）
inline float lerp(float a, float b, float t) {
    return a + (b - a) * t;
}

class NetworkEntity {
public:
    Vector2D currentPos;   // 現在画面に表示している補間座標
    Vector2D targetPos;    // 最後にネットワークから受信した真の目標座標
    Vector2D velocity;     // 推測航法用の速度ベクトル
    
    NetworkEntity() {
        currentPos.x = 0; currentPos.y = 0;
        targetPos.x = 0; targetPos.y = 0;
        velocity.x = 0; velocity.y = 0;
    }

    // パケット受信時に呼ばれる
    void onReceivePacket(float newX, float newY, float vx, float vy) {
        targetPos.x = newX;
        targetPos.y = newY;
        velocity.x = vx;
        velocity.y = vy;
    }

    // 毎フレーム（60FPS / 16.6ms）呼ばれる描画更新
    void update(float deltaTime) {
        // 目標地点へ少しずつ滑らかに寄せていく（補間係数 0.15）
        currentPos.x = lerp(currentPos.x, targetPos.x, 0.15f);
        currentPos.y = lerp(currentPos.y, targetPos.y, 0.15f);

        // さらに推測航法：次のパケットが来るまで速度分だけ目標座標を進める
        targetPos.x += velocity.x * deltaTime;
        targetPos.y += velocity.y * deltaTime;
    }
};

int main() {
    NetworkEntity remotePlayer;
    
    // 相手が座標(100, 50)へ速度(10, 0)で移動中というパケットを受信
    remotePlayer.onReceivePacket(100.0f, 50.0f, 10.0f, 0.0f);

    std::cout << "--- 60FPS 補間シミュレーション開始 ---" << std::endl;
    for (int frame = 1; frame <= 5; ++frame) {
        remotePlayer.update(0.0166f); // 16.6ms
        std::cout << "Frame " << frame << ": Current Screen Pos = (" 
                  << remotePlayer.currentPos.x << ", " 
                  << remotePlayer.currentPos.y << ")" << std::endl;
    }

    return 0;
}

• 線形補間（Lerp）による瞬間移動の解消: 受信した座標に即座にオブジェクトをジャンプさせず、現在座標から徐々に近づけることで滑らかな描画を実現する。
• 推測航法（Dead Reckoning）: パケットの到着頻度が低くても、速度ベクトルを掛けて未来位置を予測シミュレーションすることで遅延を感じさせない。

• ノンブロッキングI/Oの必須性: ゲームループは16.6ms周期で回り続けなければならないため、通信受信待ちでブロックされるソケットは絶対に使用してはならない。

• 1. UDPのほうが暗号化が強固だから
• 2. TCPではパケットが1つ欠落すると後続パケットの処理が全てブロックされる（Head-of-Line Blocking）ため、リアルタイム性が失われるから
• 3. UDPを使うとインターネット料金が半額になるから
• 4. TCPはC++で使えないから

正解と解説を見る

正解：TCPではパケットが1つ欠落すると後続パケットの処理が全てブロックされる（Head-of-Line Blocking）ため、リアルタイム性が失われるから
TCPの信頼性保証機構はパケット損失時に再送完了まで後続を止めてしまうため、リアルタイムゲームでは最新パケットを即時処理できるUDPが必須となります。

• 1. malloc() / free()
• 2. htonl() / ntohl()
• 3. printf() / scanf()
• 4. std::sort()

正解と解説を見る

正解：htonl() / ntohl()
htonl（ホスト→ネットワーク）および ntohl（ネットワーク→ホスト）を使用することで、リトルエンディアンとビッグエンディアンの差異を自動吸収して正しい数値を送受できます。

• 1. メモリリーク検知器とクラッシュダンプ
• 2. 線形補間（Lerp）と推測航法（Dead Reckoning）
• 3. 仮想関数テーブルと菱形多重継承
• 4. ビットフラグとstd::stringstream

正解と解説を見る

正解：線形補間（Lerp）と推測航法（Dead Reckoning）
線形補間（Lerp）で過去から目標位置へ滑らかに繋ぎ、推測航法（Dead Reckoning）でパケット間隔中の未来移動を予測することで、遅延のない滑らかな同期を実現します。

• 1. データが届くまでスレッドを永久停止させるブロッキングモード
• 2. パケットが届いていない場合は待機せず即座に制御を戻すノンブロッキングモード（Non-blocking I/O）
• 3. ソケットのバッファサイズを0バイトにする設定
• 4. 毎フレームソケットを close() して再作成する設定

正解と解説を見る

正解：パケットが届いていない場合は待機せず即座に制御を戻すノンブロッキングモード（Non-blocking I/O）
ノンブロッキングモードに設定しないと、相手からパケットが届かないフレームで recv が止まり、ゲームループの60FPS描画がフリーズしてしまいます。