【備忘録】Bevy + Lightyear におけるパフォーマンス最適化

// 共有コンポーネント — レプリケーション対象
#[derive(Component, Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct ServerPosition {
    pub x: f32,
    pub y: f32,
    pub z: f32,
}
// サーバー: 毎ティック Transform → ServerPosition にコピー
fn sync_server_position(
    mut query: Query<(&Transform, &mut ServerPosition), Changed<Transform>>
) {
    for (transform, mut server_pos) in query.iter_mut() {
        let t = transform.translation;
        server_pos.x = t.x;
        server_pos.y = t.y;
        server_pos.z = t.z;
    }
}
// クライアント: ServerPosition の変更を検知 → 補間バッファに格納
// Transform はクライアントが完全に制御（Lightyear による上書きなし）
pub fn capture_server_position(
    mut query: Query<(&ServerPosition, &mut ServerTarget), Changed<ServerPosition>>,
    time: Res<Time>,
) { ... }

ReplicationSender::new(
    Duration::from_millis(50), // 50msバッチ（20Hz）
    SendUpdatesMode::SinceLastAck,
    false,
)

// ビューポート半径 = カメラズームに合わせて質量で動的計算
pub fn viewport_radius_for_mass(total_mass: f32) -> f32 {
    let base_viewport = 640.0;
    let scale = (1.0 + (total_mass / 500.0).sqrt()).clamp(1.0, 5.0);
    base_viewport * scale * 1.5  // 1.5倍マージンでエッジのチラつき防止
}

fn rebuild_interest_grid(mut grid: ResMut<InterestGrid>, ..., mut tick: Local<u32>) {
    *tick += 1;
    if *tick % 6 != 0 { return; }  // 5Hzに間引き
    // グリッド再構築...
}

struct InterestState {
    prev: HashMap<u64, HashSet<Entity>>,  // 前回の可視エンティティ
    curr: HashMap<u64, HashSet<Entity>>,  // 今回の可視エンティティ
}

// Phase 2: 差分検出
for &entity in visible_set {
    let was_visible = prev_set.map_or(false, |prev| prev.contains(&entity));
    if !was_visible {
        rs.gain_visibility(sender_entity);  // 新しく見えた
    }
}
for &entity in prev {
    if !visible_set.contains(&entity) {
        rs.lose_visibility(sender_entity);  // 見えなくなった
    }
}

// HashSet のメモリを解放せず、prev ↔ curr をスワップして再利用
std::mem::swap(&mut s.prev, &mut s.curr);

pub struct SpatialGrid {
    buckets: Vec<Vec<Entity>>,
    dirty: Vec<usize>,  // 書き込まれたバケットのインデックスのみ記録
}

impl SpatialGrid {
    // 全バケットではなく、使用されたバケットのみクリア
    pub fn clear(&mut self) {
        for &idx in &self.dirty {
            self.buckets[idx].clear();
        }
        self.dirty.clear();
    }
}

// Vec を返すのではなく、コールバックで呼び出し元に直接渡す
pub fn query_aabb_cb(&self, center: Vec2, radius: f32, mut f: impl FnMut(Entity)) {
    // ...
    for &entity in &self.buckets[idx] {
        f(entity);  // アロケーションなし
    }
}

let mut nearby = Vec::new();  // ループ外で宣言（再利用）
for ... {
    nearby.clear();
    grid.0.query_aabb_cb(pos, radius, |e| nearby.push(e));
}

#[derive(Resource, Default)]
pub struct OwnerIndex {
    pub map: HashMap<u64, Vec<(Entity, Vec2, f32)>>,
}

fn rebuild_owner_index(mut index: ResMut<OwnerIndex>, cells: Query<...>) {
    index.map.clear();
    for (entity, transform, cell, pc) in cells.iter() {
        index.map.entry(pc.owner_id).or_default().push((
            entity, transform.translation.truncate(), cell.mass,
        ));
    }
}

#[derive(Default)]
pub(crate) struct EatCellsState {
    cells: Vec<(Entity, Vec2, f32, f32, Option<u64>, bool)>,
    entity_map: HashMap<Entity, usize>,
    eaten: HashSet<Entity>,
    mass_gains: Vec<(Entity, f32)>,
    nearby: Vec<Entity>,
}

pub fn eat_cells(
    ...,
    mut state: Local<EatCellsState>,  // ティック間で再利用
) {
    let s = &mut *state;
    s.cells.clear();       // Vec の容量は保持（再アロケーションなし）
    s.entity_map.clear();
    s.eaten.clear();
    s.mass_gains.clear();
    // ...
}

// sqrt を避けて閾値も二乗で比較
let dist_sq = cell_pos.distance_squared(food_pos);
let threshold = cell_r + FOOD_RADIUS;
if dist_sq < threshold * threshold {
    // 衝突
}

// 食べ物: 15ティックごと（約0.5秒）
pub fn respawn_food(..., mut tick: Local<u32>) {
    *tick += 1;
    if *tick % 15 != 0 { return; }
    // カウント → 不足分をスポーン
}

// ボット: 30ティックごと（約1秒）
pub fn respawn_bots(..., mut tick: Local<u32>) {
    *tick += 1;
    if *tick % 30 != 0 { return; }
    // ...
}

pub fn enforce_bounds(mut cell_q: Query<&mut Transform, ...>) {
    for mut transform in cell_q.iter_mut() {
        let t = &transform.translation;
        // 範囲外の場合のみ Transform に書き込み
        if t.x < -hw || t.x > hw || t.y < -hh || t.y > hh {
            clamp_to_map(&mut transform.translation);
        }
    }
}

#[derive(Resource)]
pub struct SharedMeshes {
    pub unit_circle: Handle<Mesh>,   // 半径1の円（セル・射出質量が共有）
    pub food_circle: Handle<Mesh>,   // 食べ物専用の小さい円
}

pub fn update_cell_sizes(
    mut query: Query<(&Cell, &mut Transform), Changed<Cell>>,
) {
    for (cell, mut transform) in query.iter_mut() {
        let radius = mass_to_radius(cell.mass);
        transform.scale = Vec3::splat(radius);  // メッシュは unit circle のまま
    }
}

// Cell コンポーネントが変更された場合のみ、名前テキストの位置を再計算
pub fn sync_cell_visuals(
    query: Query<(&Cell, &Children), (Changed<Cell>, ...)>,
    ...
) { ... }

// Cell コンポーネントが変更された場合のみ、Transform::scale を更新
pub fn update_cell_sizes(
    mut query: Query<(&Cell, &mut Transform), (Changed<Cell>, ...)>,
) { ... }

// capture_server_position: 新しい ServerPosition を受信したら prev/curr を更新
target.prev_pos = target.curr_pos;
target.curr_pos = new_pos;

// apply_interpolation: 経過時間に基づいて prev → curr を補間
let elapsed = now - target.update_time;
let t = (elapsed / target.update_interval).clamp(0.0, 1.0);
let interpolated = target.prev_pos.lerp(target.curr_pos, t);

let smooth_t = 1.0 - (-15.0 * dt).exp();
transform.translation = current.lerp(interpolated, smooth_t);

// ステップ1: ローカル予測（サーバーと同じ物理）
let speed = max_speed(cell.mass);
let factor = (dist / CURSOR_SLOW_DISTANCE).min(1.0);
let delta = dir * speed * factor * dt;
transform.translation.x += delta.x;
transform.translation.y += delta.y;

// ステップ2: 穏やかなサーバー補正（rate=2）
let correction_rate = if drift > 100.0 { 10.0 } else { 2.0 };
let correction_t = 1.0 - (-correction_rate * dt).exp();
transform.translation = transform.translation.lerp(server_interpolated, correction_t);

// カメラ追従: 0.65^(dt*60) ベース
let lerp = 1.0 - 0.65_f32.powf(dt * 60.0);

// カメラズーム: 0.9^(dt*60) ベース
let lerp = 1.0 - 0.9_f32.powf(dt * 60.0);

let interval = now - target.update_time;
if interval > 0.01 && interval < 0.5 {
    // EMA（指数移動平均）で間隔を推定、0.5/0.5 の重みで ~5更新で収束
    target.update_interval = target.update_interval * 0.5 + interval * 0.5;
}

// サーバー・クライアント両方で設定
.insert_resource(Time::<Virtual>::from_max_delta(Duration::from_millis(66)))

// 1ms スリープで CPU を他プロセスに譲る
.add_plugins(MinimalPlugins.set(
    ScheduleRunnerPlugin::run_loop(Duration::from_millis(1))
))

// サーバー: Input → AI → Movement → Collision → PostCollision
.configure_sets(FixedUpdate, (
    GamePhase::Input,
    GamePhase::AI.after(GamePhase::Input),
    GamePhase::Movement.after(GamePhase::AI),
    GamePhase::Collision.after(GamePhase::Movement),
    GamePhase::PostCollision.after(GamePhase::Collision),
))

// クライアント: input → interpolation → rendering → camera
.add_systems(Update, (
    input::capture_input,
    interpolation::apply_interpolation,
).chain())

// protocol.rs — InputPlugin の代わりに直接メッセージ登録
app.register_message::<PlayerInput>()
    .add_direction(NetworkDirection::ClientToServer);

// client/input.rs — MessageSender で直接送信
for mut sender in senders.iter_mut() {
    let _ = sender.send::<UnreliableChannel>(PlayerInput {
        mouse_world_pos: world_pos,
        actions: net_input.actions.clone(),
    });
}

// server/network.rs — LatestInputs リソースで受信・保持
#[derive(Resource, Default)]
pub struct LatestInputs(pub HashMap<u64, PlayerInput>);

fn receive_player_inputs(
    mut receivers: Query<(Entity, &mut MessageReceiver<PlayerInput>), With<LinkOf>>,
    mut latest: ResMut<LatestInputs>,
) {
    for (client_entity, mut receiver) in receivers.iter_mut() {
        let client_id = client_entity.to_bits();
        for msg in receiver.receive() {
            latest.0.insert(client_id, msg);
        }
    }
}

// Update: メッセージを受信して LatestInputs に格納
app.add_systems(Update, receive_player_inputs);

// FixedUpdate: LatestInputs を読み取ってゲームに適用
app.add_systems(FixedUpdate, (
    process_player_inputs,
    handle_split_action,
    handle_eject_action,
).chain().in_set(GamePhase::Input));