wowlab_engine_sim/telemetry/

encode.rs

//! Protobuf encoding of accumulated telemetry into a `ChunkTelemetry` message.

use hdrhistogram::{
    Histogram,
    serialization::{Serializer, V2Serializer},
};
use itertools::Itertools;
use prost::Message;
use wowlab_types::{
    constants::{PROTO_DPS_SCALE, PROTO_RESOURCE_SCALE},
    numeric::{f64_to_u32_saturating_round, f64_to_u64_saturating_round},
    proto,
    sim::{ActorId, FastMap, IntMap, TargetIdx},
};

use super::{
    ActionAggregateKey, AuraAggregate, AuraAggregateKey, CooldownAggregate, ResourceAggregate,
    SpellAggregate, TIMELINE_BUCKET_MS, TelemetryAccumulator, actor_sort_key,
    representative::RepresentativeTimeline,
};

impl TelemetryAccumulator {
    /// Encode accumulated telemetry as protobuf bytes.
    pub fn encode(self, chunk_index: u32, permutation_index: Option<u64>) -> Vec<u8> {
        let n = self.iteration_count;

        if n == 0 {
            return proto::ChunkTelemetry {
                chunk_index,
                permutation_index,
                ..Default::default()
            }
            .encode_to_vec();
        }

        let nf = f64::from(n);
        let mean_dps = self.dps_sum / nf;
        let mean_dps_x10 = dps_to_x10(mean_dps);
        let min_dps_x10 = dps_to_x10(self.dps_min);
        let max_dps_x10 = dps_to_x10(self.dps_max);

        let m2_dps_bits = self.dps_m2.to_bits();

        let total_fight_time_ms = f64_to_u64_saturating_round(self.total_duration_ms);
        let histogram = serialize_histogram(&self.dps_histogram);

        let actions = build_actions(&self.spell_totals);
        let auras = build_auras(&self.aura_totals);
        let resources = build_resources(&self.resource_totals);
        let cooldowns = build_cooldowns(&self.cooldown_totals);

        let execution = Some(proto::ExecutionData {
            active_time_ms: 0,
            idle_time_ms: 0,
            gcd_locked_time_ms: f64_to_u64_saturating_round(self.gcd_locked_ms_total),
            idle_gcd_count: 0,
            queue_lag_sum_ms: 0,
            queue_lag_count: 0,
            action_count_per_bucket: vec![],
            action_bucket_samples: vec![],
        });

        let damage_profile = Some(build_damage_profile(
            self.direct_damage_total,
            self.periodic_damage_total,
            self.pet_damage_total,
            &self.damage_by_target,
        ));

        let dps_bucket_sums_x10: Vec<u64> = self
            .bucket_sums
            .iter()
            .map(|&v| f64_to_u64_saturating_round(v * PROTO_DPS_SCALE))
            .collect();
        let dps_bucket_samples = self.bucket_samples;

        let representative_dps_x10 = self.representative_dps.map_or(0, dps_to_x10);

        let representative = self.representative_sink.as_ref().map(build_representative);
        let dictionary = Some(build_dictionary(
            &actions,
            &auras,
            representative.as_ref(),
            &self.targets,
        ));

        let instrumentation_coverage = Some(proto::InstrumentationCoverage {
            has_resource_cap_time: false,
            has_resource_starvation_time: false,
            has_cooldown_drift: false,
            has_phase_markers: false,
            has_proc_aggregates: false,
        });

        let telemetry = proto::ChunkTelemetry {
            chunk_index,
            iterations: n,
            total_fight_time_ms,
            mean_dps_x10,
            m2_dps_bits,
            min_dps_x10,
            max_dps_x10,
            histogram: Some(histogram),
            actions,
            auras,
            resources,
            cooldowns,
            execution,
            damage_profile,
            dps_bucket_sums_x10,
            dps_bucket_samples,
            bucket_ms: TIMELINE_BUCKET_MS,
            representative,
            representative_dps_x10,
            dictionary,
            instrumentation_coverage,
            permutation_index,
        };

        telemetry.encode_to_vec()
    }
}

fn dps_to_x10(dps: f64) -> u32 {
    if dps.is_nan() || dps <= 0.0 {
        0
    } else if dps * PROTO_DPS_SCALE >= f64::from(u32::MAX) {
        u32::MAX
    } else {
        f64_to_u32_saturating_round(dps * PROTO_DPS_SCALE)
    }
}

// #t(fn: rust_cyclomatic_complexity) flat exhaustive match over the ResourceType discriminants.
fn resource_type_slug(rt: u8) -> &'static str {
    use wowlab_types::combat::ResourceType as R;

    match R::try_from(rt) {
        Ok(R::Mana) => "mana",
        Ok(R::Rage) => "rage",
        Ok(R::Focus) => "focus",
        Ok(R::Energy) => "energy",
        Ok(R::ComboPoints) => "combo_points",
        Ok(R::Runes) => "runes",
        Ok(R::RunicPower) => "runic_power",
        Ok(R::SoulShards) => "soul_shards",
        Ok(R::LunarPower) => "astral_power",
        Ok(R::HolyPower) => "holy_power",
        Ok(R::Maelstrom) => "maelstrom",
        Ok(R::Chi) => "chi",
        Ok(R::Insanity) => "insanity",
        Ok(R::ArcaneCharges) => "arcane_charges",
        Ok(R::Fury) => "fury",
        Ok(R::Pain) => "pain",
        Ok(R::Essence) => "essence",
        Ok(R::Alternate) => "alternate",
        Ok(R::AlternateQuest) => "alternate_quest",
        Ok(R::AlternateEncounter) => "alternate_encounter",
        Ok(R::AlternateMount) => "alternate_mount",
        Err(_) => "",
    }
}

pub(crate) fn serialize_histogram(hdr: &Histogram<u64>) -> proto::HistogramData {
    let mut out = Vec::new();
    let mut ser = V2Serializer::new();
    let hdr_v2 = match ser.serialize(hdr, &mut out) {
        Ok(_) => out,
        Err(e) => {
            tracing::warn!(error = %e, "histogram serialization failed, returning empty");

            vec![]
        }
    };

    proto::HistogramData { hdr_v2 }
}

#[derive(Clone, Copy)]
struct ProtoActorIdentity {
    kind: i32,
    id: u32,
}

fn actor_proto_identity(actor: ActorId) -> ProtoActorIdentity {
    match actor {
        ActorId::Player | ActorId::External => ProtoActorIdentity {
            kind: proto::ActorKind::Player as i32,
            id: 0,
        },
        ActorId::Pet(pet) => ProtoActorIdentity {
            kind: proto::ActorKind::Pet as i32,
            id: u32::from(pet.0),
        },
        ActorId::Enemy(enemy) => ProtoActorIdentity {
            kind: proto::ActorKind::Enemy as i32,
            id: u32::from(enemy.0),
        },
    }
}

const fn action_source(actor: ActorId) -> i32 {
    match actor {
        ActorId::Player | ActorId::External => proto::ActionSource::Player as i32,
        ActorId::Pet(_) => proto::ActionSource::Pet as i32,
        ActorId::Enemy(_) => proto::ActionSource::Enemy as i32,
    }
}

fn build_actions(
    spell_totals: &FastMap<ActionAggregateKey, SpellAggregate>,
) -> Vec<proto::ActionRow> {
    spell_totals
        .iter()
        .sorted_by_key(|(key, _)| {
            (
                key.spell_id,
                key.scope.target,
                actor_sort_key(key.scope.source),
                key.scope.pull,
                key.scope.group,
            )
        })
        .map(|(key, agg)| {
            let source = actor_proto_identity(key.scope.source);

            proto::ActionRow {
                spell_id: key.spell_id,
                target_id: u32::from(key.scope.target.0),
                source: action_source(key.scope.source),
                source_kind: source.kind,
                source_id: source.id,
                pull_id: Some(u32::from(key.scope.pull.0)),
                group_id: Some(u32::from(key.scope.group.0)),
                casts: u64::from(agg.casts),
                direct_hits: u64::from(agg.hits),
                ticks: u64::from(agg.ticks),
                crits: u64::from(agg.crits),
                misses: 0,
                dodges: 0,
                parries: 0,
                total_damage_x10: f64_to_u64_saturating_round(agg.damage * PROTO_DPS_SCALE),
                execute_time_ms: 0,
                resource_spent_x100: 0,
                resource_gained_x100: 0,
            }
        })
        .collect()
}

fn build_auras(aura_totals: &FastMap<AuraAggregateKey, AuraAggregate>) -> Vec<proto::AuraRow> {
    aura_totals
        .iter()
        .sorted_by_key(|(key, _)| {
            (
                key.aura_id,
                actor_sort_key(key.scope.affected),
                actor_sort_key(key.scope.source),
                key.scope.pull,
                key.scope.group,
            )
        })
        .map(|(key, aggregate)| {
            let source = actor_proto_identity(key.scope.source);
            let affected = actor_proto_identity(key.scope.affected);

            proto::AuraRow {
                aura_id: key.aura_id,
                uptime_ms: f64_to_u64_saturating_round(aggregate.uptime_ms),
                applications: aggregate.applications,
                refreshes: aggregate.refreshes,
                stack_seconds_x100: 0,
                target_id: match key.scope.affected {
                    ActorId::Enemy(enemy) => u32::from(enemy.0),
                    ActorId::Player | ActorId::External | ActorId::Pet(_) => 0,
                },
                source_kind: source.kind,
                source_id: source.id,
                affected_kind: affected.kind,
                affected_id: affected.id,
                pull_id: Some(u32::from(key.scope.pull.0)),
                group_id: key.scope.group.map(|group| u32::from(group.0)),
            }
        })
        .collect()
}

fn build_resources(resource_totals: &IntMap<u8, ResourceAggregate>) -> Vec<proto::ResourceRow> {
    resource_totals
        .iter()
        .sorted_by_key(|&(&resource_type, _)| resource_type)
        .map(|(&resource_type, agg)| proto::ResourceRow {
            resource_type: u32::from(resource_type),
            gained_x100: f64_to_u64_saturating_round(agg.total_gained * PROTO_RESOURCE_SCALE),
            spent_x100: f64_to_u64_saturating_round(agg.total_spent * PROTO_RESOURCE_SCALE),
            wasted_x100: f64_to_u64_saturating_round(
                agg.total_wasted.max(0.0) * PROTO_RESOURCE_SCALE,
            ),
            time_at_cap_ms: 0,
            starved_time_ms: 0,
            by_source: agg
                .gained_by_source
                .iter()
                .sorted_by_key(|&(&source, _)| source)
                .map(|(&source_spell_id, aggregate)| proto::ResourceSourceRow {
                    source_spell_id,
                    gained_x100: f64_to_u64_saturating_round(
                        aggregate.gained * PROTO_RESOURCE_SCALE,
                    ),
                    wasted_x100: f64_to_u64_saturating_round(
                        aggregate.wasted.max(0.0) * PROTO_RESOURCE_SCALE,
                    ),
                })
                .collect(),
        })
        .collect()
}

fn build_cooldowns(cooldown_totals: &IntMap<u32, CooldownAggregate>) -> Vec<proto::CooldownRow> {
    cooldown_totals
        .iter()
        .sorted_by_key(|&(&spell_id, _)| spell_id)
        .map(|(&spell_id, agg)| proto::CooldownRow {
            spell_id,
            uses: u64::from(agg.total_uses),
            possible_uses: 0,
            drift_sum_ms: 0,
            max_drift_ms: 0,
        })
        .collect()
}

fn build_damage_profile(
    direct: f64,
    periodic: f64,
    pet: f64,
    damage_by_target: &FastMap<wowlab_types::sim::EnemyIdx, f64>,
) -> proto::DamageProfileData {
    let by_target = damage_by_target
        .iter()
        .sorted_by_key(|(target, _)| **target)
        .map(|(target, damage)| proto::DamageByTarget {
            target_id: u32::from(target.0),
            total_damage_x10: f64_to_u64_saturating_round(damage * PROTO_DPS_SCALE),
        })
        .collect();

    if direct + periodic + pet > 0.0 {
        proto::DamageProfileData {
            direct_damage_x10: f64_to_u64_saturating_round(direct * PROTO_DPS_SCALE),
            periodic_damage_x10: f64_to_u64_saturating_round(periodic * PROTO_DPS_SCALE),
            pet_damage_x10: f64_to_u64_saturating_round(pet * PROTO_DPS_SCALE),
            by_target,
        }
    } else {
        proto::DamageProfileData::default()
    }
}

fn build_representative(rep: &RepresentativeTimeline) -> proto::TimelineSnapshot {
    let mut prev_ms: u32 = 0;
    let markers: Vec<proto::TimelineMarker> = rep
        .markers
        .iter()
        .map(|m| {
            let delta = m.time_ms.saturating_sub(prev_ms);

            prev_ms = m.time_ms;

            proto::TimelineMarker {
                delta_time_ms: delta,
                sequence: m.sequence,
                kind: m.kind as i32,
                spell_or_aura_id: m.spell_or_aura_id,
                target_id: m.target,
                amount: m.amount,
                is_crit: m.is_crit,
                source_kind: m
                    .source
                    .map_or(proto::ActorKind::Unspecified as i32, |source| {
                        actor_proto_identity(source).kind
                    }),
                source_id: m.source.map_or(0, |source| actor_proto_identity(source).id),
                pull_id: m.pull.map(|pull| u32::from(pull.0)),
                group_id: m.group.map(|group| u32::from(group.0)),
            }
        })
        .collect();

    let aura_windows: Vec<proto::AuraWindow> = rep
        .aura_windows
        .iter()
        .map(|w| proto::AuraWindow {
            aura_id: w.aura_id,
            target_id: w.target,
            start_ms: w.start_ms,
            end_ms: w.end_ms,
            source_kind: w
                .source
                .map_or(proto::ActorKind::Unspecified as i32, |source| {
                    actor_proto_identity(source).kind
                }),
            source_id: w.source.map_or(0, |source| actor_proto_identity(source).id),
            affected_kind: w
                .affected
                .map_or(proto::ActorKind::Unspecified as i32, |affected| {
                    actor_proto_identity(affected).kind
                }),
            affected_id: w
                .affected
                .map_or(0, |affected| actor_proto_identity(affected).id),
            pull_id: w.pull.map(|pull| u32::from(pull.0)),
            group_id: w.group.map(|group| u32::from(group.0)),
        })
        .collect();

    let cooldown_windows: Vec<proto::CooldownWindow> = rep
        .cooldown_windows
        .iter()
        .map(|w| proto::CooldownWindow {
            spell_id: w.spell_id,
            start_ms: w.start_ms,
            duration_ms: w.duration_ms,
        })
        .collect();

    let resource_samples: Vec<proto::ResourceSampleProto> = rep
        .resource_samples
        .iter()
        .map(|s| proto::ResourceSampleProto {
            time_ms: s.time_ms,
            resource_name: resource_type_slug(s.resource_type).to_string(),
            current: s.current,
            max: s.max,
            gain: s.gain,
            loss: s.loss,
        })
        .collect();

    let aura_intervals: Vec<proto::AuraIntervalProto> = rep
        .aura_intervals
        .iter()
        .map(|i| proto::AuraIntervalProto {
            start_ms: i.start_ms,
            end_ms: i.end_ms,
            open_ended: i.open_ended,
            aura_slug: i.aura_id.to_string(),
            source: match i.source {
                ActorId::Player => "player",
                ActorId::External => "external",
                ActorId::Pet(_) => "pet",
                ActorId::Enemy(_) => "enemy",
            }
            .to_string(),
            target_id: match i.affected {
                ActorId::Enemy(enemy) => u32::from(enemy.0),
                ActorId::Player | ActorId::External | ActorId::Pet(_) => 0,
            },
            source_kind: actor_proto_identity(i.source).kind,
            source_id: actor_proto_identity(i.source).id,
            affected_kind: actor_proto_identity(i.affected).kind,
            affected_id: actor_proto_identity(i.affected).id,
            pull_id: Some(u32::from(i.pull.0)),
            group_id: i.group.map(|group| u32::from(group.0)),
        })
        .collect();

    let encounter_events = build_encounter_events(&rep.encounter_events);

    proto::TimelineSnapshot {
        markers,
        aura_windows,
        cooldown_windows,
        phase_markers: vec![],
        resource_samples,
        aura_intervals,
        encounter_events,
    }
}

fn build_encounter_events(
    events: &[super::representative::RepresentativeEncounterEvent],
) -> Vec<proto::EncounterTimelineEvent> {
    events
        .iter()
        .map(|captured| {
            let event = &captured.event;
            let actor = actor_proto_identity(event.actor);
            let (x, y, heading, layer_id) =
                event
                    .transform
                    .map_or((None, None, None, None), |transform| {
                        (
                            Some(transform.position.x),
                            Some(transform.position.y),
                            Some(transform.heading),
                            Some(u32::from(transform.layer.0)),
                        )
                    });

            proto::EncounterTimelineEvent {
                kind: match event.kind {
                    wowlab_engine_telemetry::EncounterTelemetryEventKind::Spawn => {
                        proto::EncounterEventKind::Spawn as i32
                    }
                    wowlab_engine_telemetry::EncounterTelemetryEventKind::Movement => {
                        proto::EncounterEventKind::Movement as i32
                    }
                    wowlab_engine_telemetry::EncounterTelemetryEventKind::Death => {
                        proto::EncounterEventKind::Death as i32
                    }
                    wowlab_engine_telemetry::EncounterTelemetryEventKind::Despawn => {
                        proto::EncounterEventKind::Despawn as i32
                    }
                    wowlab_engine_telemetry::EncounterTelemetryEventKind::TargetChange => {
                        proto::EncounterEventKind::TargetChange as i32
                    }
                    wowlab_engine_telemetry::EncounterTelemetryEventKind::PullTransition => {
                        proto::EncounterEventKind::PullTransition as i32
                    }
                },
                time_ms: event.time_ms,
                actor_kind: actor.kind,
                actor_id: actor.id,
                previous_target_id: event.previous_target.map(|target| u32::from(target.0)),
                target_id: event.target.map(|target| u32::from(target.0)),
                pull_id: u32::from(event.pull.0),
                group_id: event.group.map(|group| u32::from(group.0)),
                x,
                y,
                heading,
                layer_id,
                sequence: captured.sequence,
            }
        })
        .collect()
}

fn build_dictionary(
    actions: &[proto::ActionRow],
    auras: &[proto::AuraRow],
    representative: Option<&proto::TimelineSnapshot>,
    targets: &FastMap<TargetIdx, wowlab_engine_telemetry::TargetMetadata>,
) -> proto::DictionaryView {
    let mut spell_ids = std::collections::BTreeSet::new();
    let mut aura_ids = std::collections::BTreeSet::new();

    for row in actions {
        if row.spell_id != 0 {
            spell_ids.insert(row.spell_id);
        }
    }

    for row in auras {
        if row.aura_id != 0 {
            aura_ids.insert(row.aura_id);
        }
    }

    if let Some(snap) = representative {
        for m in &snap.markers {
            spell_ids.insert(m.spell_or_aura_id);
        }

        for w in &snap.aura_windows {
            aura_ids.insert(w.aura_id);
        }

        for w in &snap.cooldown_windows {
            spell_ids.insert(w.spell_id);
        }
    }

    let target_entries: Vec<_> = targets
        .iter()
        .sorted_by_key(|(id, _)| **id)
        .map(|(id, target)| proto::TargetEntry {
            id: id.0.into(),
            label: target.display_name.clone(),
            npc_id: target.npc_id,
            group_id: Some(u32::from(target.group.0)),
            enemy_tags: target.enemy_tags.iter().map(ToString::to_string).collect(),
            group_tags: target.group_tags.iter().map(ToString::to_string).collect(),
        })
        .collect();
    let mut units = std::collections::BTreeSet::new();

    units.insert((proto::ActorKind::Player as i32, 0));

    for target in targets.keys() {
        units.insert((proto::ActorKind::Enemy as i32, u32::from(target.0)));
    }

    for action in actions {
        units.insert((action.source_kind, action.source_id));
    }

    for aura in auras {
        units.insert((aura.source_kind, aura.source_id));
        units.insert((aura.affected_kind, aura.affected_id));
    }

    let unit_entries = units
        .into_iter()
        .filter(|(kind, _)| *kind != proto::ActorKind::Unspecified as i32)
        .map(|(kind, id)| {
            let target = (kind == proto::ActorKind::Enemy as i32)
                .then(|| {
                    u16::try_from(id)
                        .ok()
                        .and_then(|id| targets.get(&TargetIdx(id)))
                })
                .flatten();

            proto::UnitEntry {
                kind,
                id,
                label: target.map_or_else(
                    || match proto::ActorKind::try_from(kind) {
                        Ok(proto::ActorKind::Player) => "Player".to_string(),
                        Ok(proto::ActorKind::Pet) => format!("Pet {id}"),
                        Ok(proto::ActorKind::Enemy) => format!("Enemy {id}"),
                        Ok(proto::ActorKind::Unspecified) | Err(_) => "Unknown".to_string(),
                    },
                    |target| target.display_name.clone(),
                ),
                target_id: (kind == proto::ActorKind::Enemy as i32).then_some(id),
            }
        })
        .collect();

    proto::DictionaryView {
        spell_ids: spell_ids.into_iter().collect(),
        aura_ids: aura_ids.into_iter().collect(),
        targets: target_entries,
        units: unit_entries,
    }
}