public bool Serialize(MouseData packet)
    {
        // 各要素を順番にシリアライズします.
        // retはreturnの略なのね
        bool ret = true;
        // ret = ret && Serialize(...); と同じ意味
        // 全ての処理がtrueを返した時だけ ret = true となる。
        ret &= Serialize(packet.frame);
        ret &= Serialize(packet.mouseButtonLeft);
        ret &= Serialize(packet.mouseButtonRight);
        ret &= Serialize(packet.mousePositionX);
        ret &= Serialize(packet.mousePositionY);
        ret &= Serialize(packet.mousePositionZ);

        return ret;
    }

if ((loopCounter % bufferNum / 2) != 0)
{
    // 送信するフレームではない.
    return;
}

.
├── AsciiCharacter.cs
├── BallScript.cs
├── BarScript.cs
├── BGM.cs
├── BlockCreator.cs
├── BlockScript.cs
├── DebugPrint.cs
├── DebugScript.cs
├── EffectControl.cs
├── GameController.cs
├── InputManager.cs
├── InputSerializer.cs
├── NetworkController.cs
├── NetworkDef.cs
├── Number.cs
├── PacketQueue.cs
├── PingPong.cs
├── PlayerInfo.cs
├── ResultController.cs
├── ResultScore.cs
├── ScoreSushi.cs
├── Serializer.cs
├── Sushi.cs
├── TransportUDP.cs
└── UserScore.cs

┌───────────────┐
│  プレイヤー1のバー（上） │
│                         │
│       ボール            │
│                         │
│     ブロック群（中央）   │
│                         │
│       ボール            │
│                         │
│  プレイヤー2のバー（下） │
└───────────────┘

extends Node
# Autoload: TransportUDP
# Uses internal UDPClientNode and UDPServerNode to abstract roles

signal data_received(data: PackedByteArray)
signal send_failed(error: int)
signal connection_confirmed
signal connection_lost

var _is_server := false
var _server_node: UDPServerNode = null
var _client_node: UDPClientNode = null

var _last_addr := ""
var _last_port := 0

var _ping_sent := false
var _connection_confirmed := false

## Life cycle

func _ready():
    pass


func _process(_delta: float) -> void:
    if _is_server and _server_node:
        _server_node._process(_delta)
    elif not _is_server and _client_node:
        _client_node._process(_delta)

## Method

func start_server():
    _server_node = UDPServerNode.new()
    add_child(_server_node)
    _server_node.packet_received.connect(_on_server_packet)
    _is_server = true


func connect_to_host(ip_address: String):
    _client_node = UDPClientNode.new()
    add_child(_client_node)
    _client_node.packet_received.connect(_on_client_packet)
    _client_node.start(ip_address)
    _ping_sent = true
    _connection_confirmed = false
    _client_node.send_packet("ping".to_utf8_buffer())
    _is_server = false


func disconnect_host():
    if _is_server and _server_node:
        _server_node.queue_free()
        _server_node = null
    elif _client_node:
        _client_node.queue_free()
        _client_node = null
    connection_lost.emit()


func send(data: PackedByteArray):
    if _is_server and _server_node and _last_addr != "" and _last_port != 0:
        var err = _server_node.send_to(_last_addr, _last_port, data)
        if err != OK:
            send_failed.emit(err)
    elif _client_node:
        var err = _client_node.send_packet(data)
        if err != OK:
            send_failed.emit(err)


## Signal

func _on_server_packet(data: PackedByteArray, addr: String, port: int):
    _last_addr = addr
    _last_port = port
    var msg := data.get_string_from_utf8()
    if msg == "ping":
        _server_node.send_to(addr, port, "pong".to_utf8_buffer())
    else:
        data_received.emit(data)


func _on_client_packet(data: PackedByteArray):
    var msg := data.get_string_from_utf8()
    if msg == "pong" and _ping_sent and not _connection_confirmed:
        _connection_confirmed = true
        connection_confirmed.emit()
    else:
        data_received.emit(data)

class_name UDPServerNode
extends Node

signal packet_received(data: PackedByteArray, addr: String, port: int)

var server = UDPServer.new()
var peers: Dictionary = {}  # key = "ip:port", value = PacketPeerUDP

func _ready():
    server.listen(NetworkConfig.UDP_PORT)


func _process(delta):
    server.poll() # Important!
    # 新しいパケットを受け取った時に呼ばれる.
    receive()


## Method

# 受け取る.
func receive():
    if not server.is_connection_available():
        return
    var peer = server.take_connection()
    var packet = peer.get_packet()
    var address = peer.get_packet_ip()
    var port = peer.get_packet_port()
    var key = "%s:%s" % [address, port]

    if not peers.has(key):
        print("新しいクライアントを記録: ", key)
        peers[key] = peer

    print("Received from %s: %s" % [key, packet.get_string_from_utf8()])
    packet_received.emit(packet, address, port)


# 送信する.
func send_to(address: String, port: int, data: PackedByteArray):
    var key = "%s:%s" % [address, port]
    if peers.has(key):
        var peer = peers[key]
        peer.put_packet(data)
    else:
        print("送信先が peers に存在しません: ", key)

class_name UDPClientNode
extends Node

signal packet_received(data: PackedByteArray)

var udp = PacketPeerUDP.new()
var connected = false
var ip_address = "127.0.0.1"

## Life cycle

func _process(delta):
    if !connected:
        # 繋がるまでpingを送る
        # ここ微妙かも?
        udp.put_packet("ping".to_utf8_buffer())
    if udp.get_available_packet_count() > 0:
        var pkt = udp.get_packet()
        packet_received.emit(pkt)
        connected = true

## Method

func start(ip: String):
    ip_address = ip
    # 実際にはコネクションレスである
    connected = (udp.connect_to_host(ip_address, NetworkConfig.UDP_PORT) == OK)
    return connected


func send_packet(data: PackedByteArray) -> Error:
    return udp.put_packet(data)


func disconnect_from_host():
    udp.close()
    connected = false

func update_result():
    # クリアしているかどうか判定する.
    var ball = get_node("BreakoutBall")
    if ball != null:
        ball.queue_free()
        return

 E 0:27:49:303   breakout.gd:100 @ update_result(): Node not found: "BreakoutBall" (relative to "/root/Breakout").
  <C++ Error>   Method/function failed. Returning: nullptr
  <C++ Source>  scene/main/node.cpp:1878 @ get_node()
  <Stack Trace> breakout.gd:100 @ update_result()            breakout.gd:60 @ _process()

func receive():
    while server.is_connection_available():
        var peer = server.take_connection()
        if peer == null:
            continue

        var packet = peer.get_packet()
        var address = peer.get_packet_ip()
        var port = peer.get_packet_port()
        var key = "%s:%s" % [address, port]

        if not peers.has(key):
            print("新しいクライアントを記録: ", key)
            peers[key] = peer

        print("Received from %s: %s" % [key, packet.get_string_from_utf8()])
        _recv_queue.append([packet, address, port])
        packet_received.emit(packet, address, port)

func receive():
    # 新規接続がある場合は take_connection() で取得
    while server.is_connection_available():
        var peer = server.take_connection()
        if peer == null:
            continue

        var address = peer.get_packet_ip()
        var port = peer.get_packet_port()
        var key = "%s:%s" % [address, port]

        if not peers.has(key):
            print("新しいクライアントを記録: ", key)
            peers[key] = peer
        else:
            # 重複接続（再接続）であれば古い peer を置き換える
            peers[key] = peer

    # 登録済みの peer から受信処理を行う
    for key in peers.keys():
        var peer: PacketPeerUDP = peers[key]
        while peer.get_available_packet_count() > 0:
            var packet = peer.get_packet()
            var parts = key.split(":")
            var address = parts[0]
            var port = int(parts[1])
            print("Received from %s: %s" % [key, packet.get_string_from_utf8()])
            _recv_queue.append([packet, address, port])
            packet_received.emit(packet, address, port)

func update(shot_pressed: bool):
    current_frame += 1
    # 自分の入力を取得
    var local_input := get_local_input(shot_pressed)
    # 自分の入力を送信
    send_input(current_frame, local_input)
    # 自分の入力をバッファに入れる
    buffer_input(current_frame, local_input)
    
    # 入力が揃っていれば進む
    if can_step():
        var inputs := step()
        inputs_ready.emit(current_frame, inputs)
        # 進められた場合はcurrent_frameを0に戻すことで同期がうまくいった。
        current_frame = 0
        print("進められるよ！", local_player_id)
    else:
        print("進められないよ", local_player_id)

func update(shot_pressed: bool, retry_pressed: bool):
    # 自分の入力を取得
    var local_input := get_local_input(shot_pressed, retry_pressed)
    # 自分の入力を送信
    send_input(current_frame, local_input)
    # 自分の入力をバッファに入れる
    buffer_input(current_frame, local_input)
    
    # 入力が揃っていれば進む
    if can_step():
        var inputs := step()
        inputs_ready.emit(current_frame, inputs)
        current_frame += 1

    if Input.is_mouse_button_pressed(MOUSE_BUTTON_LEFT):
        var pos = get_viewport().get_mouse_position()
        var screen_width = get_viewport().size.x
        print("pos.x:", pos.x, " / viewport width:", screen_width)
        
        if pos.x < screen_width / 2:
            print("← 左判定")
            move_dir -= 1
        else:
            print("→ 右判定")
            move_dir += 1

    # タッチ/マウスによる移動
    if Input.is_mouse_button_pressed(MOUSE_BUTTON_LEFT):
        var pos = get_viewport().get_mouse_position()
        var screen_size = get_viewport().size
        var screen_scale = DisplayServer.screen_get_scale()
        if pos.x < screen_size.x / screen_scale / 2:
            move_dir -= 1
        else:
            move_dir += 1
        print("pos.x:", pos.x, " / viewport width:", get_viewport().size.x)

func move(dir: int):
    # お互いの端末で get_process_delta_time() の値が違うのでズレる
    var new_x = position.x + dir * speed * get_process_delta_time()
    position.x = clamp(new_x, 8 + BAR_WIDTH * 0.5, stage_size.x + 8 - BAR_WIDTH * 0.5)

var hoge = 0

func update_playing():
    if shot_ball_button.visible:
        shot_ball_button.visible = false

    hoge += 1
    if hoge % 500 != 0:
        return
    # 入力の送信
    lockstep.update(false, false)
    ball.update(lockstep.current_frame, stage.blocks_root.get_children(), bar1, bar2)

### STEP: 1
---> id: 1 current_frame: 430
---> current_frame 430 id: 0 input move_dir: 0
---> current_frame 430 id: 1 input move_dir: 0
---> id: 1 bar1 (242.0, 160.0) bar2 (270.0, 800.0)
### STEP: 0
---> id: 0 current_frame: 430
---> current_frame 430 id: 0 input move_dir: 0
---> current_frame 430 id: 1 input move_dir: 0
---> id: 0 bar1 (298.0, 160.0) bar2 (270.0, 800.0)
---> id: 1 bar1 (242.0, 160.0) bar2 (270.0, 800.0)

### STEP: 0
---> id: 0 current_frame: 451
---> current_frame 451 id: 1 input move_dir: 0
---> current_frame 451 id: 0 input move_dir: 0
---> id: 0 bar1 (298.0, 160.0) bar2 (270.0, 800.0)
---> id: 0 ball (298.0, 309.2001)
### STEP: 1
---> id: 1 current_frame: 451
---> current_frame 451 id: 1 input move_dir: 0
---> current_frame 451 id: 0 input move_dir: 0
---> id: 1 bar1 (242.0, 160.0) bar2 (270.0, 800.0)
---> id: 1 ball (242.0, 309.2001)

### STEP: 0
---> id: 0 current_frame: 523
---> current_frame 523 id: 1 input move_dir: 0
---> current_frame 523 id: 0 input move_dir: 0
---> id: 0 bar1 (298.0, 160.0) bar2 (270.0, 800.0)
---> id: 0 ball (298.0, 654.8015)
### STEP: 1
---> id: 1 current_frame: 523
---> current_frame 523 id: 1 input move_dir: 0
---> current_frame 523 id: 0 input move_dir: 0
---> id: 1 bar1 (242.0, 160.0) bar2 (270.0, 800.0)
---> id: 1 ball (242.0, 654.8015)
---> SKIP
---> id: 0 bar1 (298.0, 160.0) bar2 (270.0, 800.0)
---> id: 0 ball (298.0, 658.0015)
### STEP: 1
---> id: 1 current_frame: 524
---> current_frame 524 id: 0 input move_dir: 0
---> current_frame 524 id: 1 input move_dir: 0
---> id: 1 bar1 (242.0, 160.0) bar2 (270.0, 800.0)
---> id: 1 ball (242.0, 658.0015)
### STEP: 0
---> id: 0 current_frame: 524
---> current_frame 524 id: 0 input move_dir: 0
---> current_frame 524 id: 1 input move_dir: 0
---> id: 0 bar1 (298.0, 160.0) bar2 (270.0, 800.0)
---> id: 0 ball (298.0, 661.2015)
---> SKIP
---> id: 1 bar1 (242.0, 160.0) bar2 (270.0, 800.0)
---> id: 1 ball (242.0, 661.2015)

func _on_inputs_ready(frame: int, inputs: Array):
    for input_data in inputs:
        if input_data.player_id == 0:
            if is_server:
                bar1.move(input_data.move_dir)
            else:
                # 反転させる.  <- これが余計かも
                bar1.move(-input_data.move_dir)
                if input_data.retry_pressed:
                    opponent_retry_pressed = true
        elif input_data.player_id == 1:
            if is_server:
                # 反転させる. <- これが余計かも
                bar2.move(-input_data.move_dir)
                if input_data.retry_pressed:
                    opponent_retry_pressed = true
            else:
                bar2.move(input_data.move_dir)

        if input_data.shot_pressed:
            fire_ball_for(input_data.player_id)

    if ball:
        ball.update(frame, stage.blocks_root.get_children(), bar1, bar2)

func _on_inputs_ready(frame: int, inputs: Array):
    for input_data in inputs:
        if input_data.player_id == 0:
            bar1.move(input_data.move_dir)
            if input_data.retry_pressed:
                opponent_retry_pressed = true
        elif input_data.player_id == 1:
            bar2.move(input_data.move_dir)
            if input_data.retry_pressed:
                opponent_retry_pressed = true

        if input_data.shot_pressed:
            fire_ball_for(input_data.player_id)

    if ball:
        ball.update(frame, stage.blocks_root.get_children(), bar1, bar2)

W 0:00:32:365   udp_client_node.gd:27 @ receive(): Buffer full, dropping packets!
  <C++ Source>  core/io/packet_peer_udp.cpp:319 @ _poll()
  <Stack Trace> udp_client_node.gd:27 @ receive()
                udp_client_node.gd:16 @ _process()
                transport_udp.gd:36 @ _process()

func receive():
    # ×: if peer.get_available_packet_count() > 0:
    while peer.get_available_packet_count() > 0:
        var pkt = peer.get_packet()
        _recv_queue.append(pkt)
        packet_received.emit(pkt)
        connected = true

func update_game_over():
    if not game_over_panel.visible:
        game_over_panel.visible = true
    # local_retry_pressed というフラグにした
    lockstep.update(false, local_retry_pressed)
    
    print("# RETRY id: %d, local: %s  opponent %s" % [local_id, retry_pressed1, retry_pressed2])
    # ローカルの入力も即時ではなくステップが実行される時にtrueにする
    if retry_pressed1 and retry_pressed2:
        retry_game()

func update(shot_pressed: bool, retry_pressed: bool):
    # 自分の入力を取得
    var local_input := get_local_input(shot_pressed, retry_pressed)
    # 自分の入力を送信
    send_input(current_frame, local_input)
    # 自分の入力をバッファに入れる
    buffer_input(current_frame, local_input)
    
    # 入力が揃っていれば進む
    if can_step():
        var inputs := step()
        inputs_ready.emit(current_frame, inputs)
        #print("---> id: %d current_frame: %d" % [local_player_id, current_frame])
        #for input in inputs:
        #	print("---> current_frame %d id: %d input move_dir: %d" % [current_frame, input.player_id , input.move_dir])
        current_frame += 1
        if is_stalled:
            is_stalled = false
            lockstep_resumed.emit()
        wait_frame_counter = 0
    else:
        wait_frame_counter += 1
        if not is_stalled and wait_frame_counter >= MAX_WAIT_FRAMES:
            is_stalled = true
            lockstep_stalled.emit()

func update(shot_pressed: bool, retry_pressed: bool):
    var local_input := get_local_input(shot_pressed, retry_pressed)
    local_input.frame_number = current_frame

    send_input(current_frame, local_input)
    buffer_input(current_frame, local_input)

    var step_frame = current_frame - buffer_delay
    if step_frame >= 0 and can_step(step_frame):
        var inputs := step(step_frame)
        inputs_ready.emit(step_frame, inputs)
        if is_stalled:
            is_stalled = false
            lockstep_resumed.emit()
        wait_frame_counter = 0
    else:
        wait_frame_counter += 1
        if not is_stalled and wait_frame_counter >= MAX_WAIT_FRAMES:
            is_stalled = true
            lockstep_stalled.emit()

    current_frame += 1