wowlab_engine_domain/rotation/buffer/

layout.rs

// #t(file: rust_duplicate_strings) Rust attributes require the repeated literal reason at every field they govern.

//! Frozen dense-buffer layout and construction-validated slot handles.

use std::{fmt::Write as _, sync::Arc};

use wowlab_types::{
    combat::ResourceType,
    sim::{AuraKey, AuraProjectionKey, FastSet, SpellIdx},
};

use super::{
    AuraSlot, BufferOffsets, ByteOffset, CooldownSlot, DefaultValue, EquipmentSlot, HeroTreeSlot,
    HistorySlot, ItemSlot, ResourceSlot, SetBonusSlot, SpellSlot, StandaloneDefault, SwingSlot,
    TalentSlot, UnitSlot, WeaponImbueSlot,
};

fn valid_slot<T>(offset: ByteOffset, byte_len: usize) -> bool {
    offset.as_usize().is_multiple_of(align_of::<T>())
        && offset
            .as_usize()
            .checked_add(size_of::<T>())
            .is_some_and(|end| end <= byte_len)
}

macro_rules! slot_handle {
    ($name:ident) => {
        #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
        #[must_use]
        pub struct $name(ByteOffset);

        impl $name {
            pub(crate) const fn offset(self) -> ByteOffset {
                self.0
            }
        }
    };
}

slot_handle!(SpellSlotHandle);
slot_handle!(AuraSlotHandle);
slot_handle!(AuraProjectionSlotHandle);
slot_handle!(CooldownSlotHandle);
slot_handle!(HistorySlotHandle);
slot_handle!(ResourceSlotHandle);
slot_handle!(UnitSlotHandle);
slot_handle!(TalentSlotHandle);
slot_handle!(HeroTreeSlotHandle);
slot_handle!(ItemSlotHandle);
slot_handle!(SwingSlotHandle);
slot_handle!(EquipmentSlotHandle);
slot_handle!(SetBonusSlotHandle);
slot_handle!(WeaponImbueSlotHandle);

/// Deterministic identity of one complete frozen buffer layout.
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
#[must_use]
pub struct LayoutFingerprint(u64);

impl LayoutFingerprint {
    #[must_use]
    pub const fn as_u64(&self) -> u64 {
        self.0
    }
}

/// Additional runtime identities that must exist independently of rotation reads.
#[derive(Clone, Debug, Default)]
pub struct BufferRequirements {
    pub(crate) cooldowns: Vec<SpellIdx>,
    cooldown_set: FastSet<SpellIdx>,
    pub(crate) auras: Vec<AuraKey>,
    aura_set: FastSet<AuraKey>,
    pub(crate) resources: Vec<ResourceType>,
    resource_set: FastSet<ResourceType>,
    pub(crate) spells: Vec<SpellIdx>,
    spell_set: FastSet<SpellIdx>,
    pub(crate) talents: Vec<Box<str>>,
    pub(crate) hero_trees: Vec<Box<str>>,
    pub(crate) items: Vec<Box<str>>,
    pub(crate) swings: Vec<Box<str>>,
    pub(crate) history: Vec<SpellIdx>,
    history_set: FastSet<SpellIdx>,
    pub(crate) equipment: Vec<Box<str>>,
    pub(crate) set_bonuses: Vec<Box<str>>,
    pub(crate) units: Vec<Box<str>>,
    pub(crate) weapon_imbues: Vec<Box<str>>,
}

macro_rules! add_copy_requirement {
    ($name:ident, $field:ident, $set:ident, $Key:ty) => {
        pub fn $name(&mut self, key: $Key) {
            if self.$set.insert(key) {
                self.$field.push(key);
            }
        }
    };
}

macro_rules! add_named_requirement {
    ($name:ident, $field:ident) => {
        pub fn $name(&mut self, key: impl Into<Box<str>>) {
            let key = key.into();

            if !self.$field.contains(&key) {
                self.$field.push(key);
            }
        }
    };
}

impl BufferRequirements {
    #[must_use]
    pub fn new() -> Self {
        Self {
            cooldowns: Vec::new(),
            cooldown_set: FastSet::default(),
            auras: Vec::new(),
            aura_set: FastSet::default(),
            resources: Vec::new(),
            resource_set: FastSet::default(),
            spells: Vec::new(),
            spell_set: FastSet::default(),
            talents: Vec::new(),
            hero_trees: Vec::new(),
            items: Vec::new(),
            swings: Vec::new(),
            history: Vec::new(),
            history_set: FastSet::default(),
            equipment: Vec::new(),
            set_bonuses: Vec::new(),
            units: Vec::new(),
            weapon_imbues: Vec::new(),
        }
    }

    #[must_use]
    pub fn aura_keys(&self) -> &[AuraKey] {
        &self.auras
    }
    #[must_use]
    pub fn resource_keys(&self) -> &[ResourceType] {
        &self.resources
    }
    add_copy_requirement!(cooldown, cooldowns, cooldown_set, SpellIdx);
    add_copy_requirement!(aura, auras, aura_set, AuraKey);
    add_copy_requirement!(resource, resources, resource_set, ResourceType);
    add_copy_requirement!(spell, spells, spell_set, SpellIdx);
    add_copy_requirement!(history, history, history_set, SpellIdx);
    add_named_requirement!(talent, talents);
    add_named_requirement!(hero_tree, hero_trees);
    add_named_requirement!(item, items);
    add_named_requirement!(swing, swings);
    add_named_requirement!(equipment, equipment);
    add_named_requirement!(set_bonus, set_bonuses);

    add_named_requirement!(unit, units);

    add_named_requirement!(weapon_imbue, weapon_imbues);
}

/// Immutable slot layout shared by a combat program and its runtime buffer.
#[derive(Debug)]
pub(crate) struct FrozenBufferLayout {
    pub(crate) offsets: BufferOffsets,
    byte_len: usize,
    standalone_defaults: Box<[(ByteOffset, &'static DefaultValue)]>,
    bindings: FrozenBufferBindings,
    history: Box<[HistorySlotHandle]>,
    fingerprint: LayoutFingerprint,
}

/// Construction-validated bindings with stable traversal and no keyed lookup.
#[derive(Debug)]
pub(crate) struct FrozenBufferBindings {
    #[cfg_attr(
        not(test),
        expect(
            dead_code,
            reason = "retained for complete schema construction and layout tests"
        )
    )]
    concrete_auras: Box<[(AuraKey, AuraSlotHandle)]>,
    aura_projections: Box<[(AuraProjectionKey, AuraProjectionSlotHandle)]>,
    spells: Box<[(SpellIdx, SpellSlotHandle)]>,
    cooldowns: Box<[(SpellIdx, CooldownSlotHandle)]>,
    #[cfg_attr(
        not(test),
        expect(
            dead_code,
            reason = "retained for complete schema construction and layout tests"
        )
    )]
    history: Box<[(SpellIdx, HistorySlotHandle)]>,
    resources: Box<[(ResourceType, ResourceSlotHandle)]>,
    #[cfg_attr(
        not(test),
        expect(
            dead_code,
            reason = "retained for complete schema construction and layout tests"
        )
    )]
    hero_trees: Box<[(Box<str>, HeroTreeSlotHandle)]>,
    items: Box<[(Box<str>, ItemSlotHandle)]>,
    swings: Box<[(Box<str>, SwingSlotHandle)]>,
    #[cfg_attr(
        not(test),
        expect(
            dead_code,
            reason = "retained for complete schema construction and layout tests"
        )
    )]
    equipment: Box<[(Box<str>, EquipmentSlotHandle)]>,
    #[cfg_attr(
        not(test),
        expect(
            dead_code,
            reason = "retained for complete schema construction and layout tests"
        )
    )]
    set_bonuses: Box<[(Box<str>, SetBonusSlotHandle)]>,
    units: Box<[(Box<str>, UnitSlotHandle)]>,
    weapon_imbues: Box<[(Box<str>, WeaponImbueSlotHandle)]>,
}

macro_rules! copy_bindings {
    ($name:ident, $Key:ty, $Handle:ty, $field:ident) => {
        pub(crate) fn $name(&self) -> impl ExactSizeIterator<Item = ($Key, $Handle)> + '_ {
            self.$field.iter().copied()
        }
    };
}

macro_rules! named_bindings {
    ($name:ident, $Handle:ty, $field:ident) => {
        pub(crate) fn $name(&self) -> impl ExactSizeIterator<Item = (&str, $Handle)> + '_ {
            self.$field
                .iter()
                .map(|(key, handle)| (key.as_ref(), *handle))
        }
    };
}

impl FrozenBufferBindings {
    #[cfg(test)]
    copy_bindings!(auras, AuraKey, AuraSlotHandle, concrete_auras);
    copy_bindings!(
        aura_projections,
        AuraProjectionKey,
        AuraProjectionSlotHandle,
        aura_projections
    );
    copy_bindings!(spells, SpellIdx, SpellSlotHandle, spells);
    copy_bindings!(cooldowns, SpellIdx, CooldownSlotHandle, cooldowns);
    #[cfg(test)]
    copy_bindings!(history, SpellIdx, HistorySlotHandle, history);
    copy_bindings!(resources, ResourceType, ResourceSlotHandle, resources);
    #[cfg(test)]
    named_bindings!(hero_trees, HeroTreeSlotHandle, hero_trees);
    named_bindings!(items, ItemSlotHandle, items);
    named_bindings!(swings, SwingSlotHandle, swings);
    #[cfg(test)]
    named_bindings!(equipment, EquipmentSlotHandle, equipment);
    #[cfg(test)]
    named_bindings!(set_bonuses, SetBonusSlotHandle, set_bonuses);
    named_bindings!(units, UnitSlotHandle, units);
    named_bindings!(weapon_imbues, WeaponImbueSlotHandle, weapon_imbues);
}

impl FrozenBufferLayout {
    #[must_use]
    pub(crate) const fn byte_len(&self) -> usize {
        self.byte_len
    }

    pub(crate) const fn fingerprint(&self) -> LayoutFingerprint {
        self.fingerprint
    }

    pub(crate) fn history_handles(&self) -> &[HistorySlotHandle] {
        &self.history
    }

    pub(crate) const fn bindings(&self) -> &FrozenBufferBindings {
        &self.bindings
    }

    pub(crate) fn spell_handle(&self, key: SpellIdx) -> Option<SpellSlotHandle> {
        wowlab_types::bench_metrics::record_keyed_lookup();

        self.offsets
            .slots
            .spells
            .get(&key)
            .copied()
            .filter(|&offset| valid_slot::<SpellSlot>(offset, self.byte_len))
            .map(SpellSlotHandle)
    }

    pub(crate) fn aura_handle(&self, key: AuraKey) -> Option<AuraSlotHandle> {
        wowlab_types::bench_metrics::record_keyed_lookup();

        self.offsets
            .slots
            .auras
            .get(&key)
            .copied()
            .filter(|&offset| valid_slot::<AuraSlot>(offset, self.byte_len))
            .map(AuraSlotHandle)
    }

    pub(crate) fn cooldown_handle(&self, key: SpellIdx) -> Option<CooldownSlotHandle> {
        wowlab_types::bench_metrics::record_keyed_lookup();

        self.offsets
            .slots
            .cooldowns
            .get(&key)
            .copied()
            .filter(|&offset| valid_slot::<CooldownSlot>(offset, self.byte_len))
            .map(CooldownSlotHandle)
    }

    pub(crate) fn history_handle(&self, key: SpellIdx) -> Option<HistorySlotHandle> {
        wowlab_types::bench_metrics::record_keyed_lookup();

        self.offsets
            .slots
            .history
            .get(&key)
            .copied()
            .filter(|&offset| valid_slot::<HistorySlot>(offset, self.byte_len))
            .map(HistorySlotHandle)
    }

    pub(crate) fn resource_handle(&self, key: ResourceType) -> Option<ResourceSlotHandle> {
        wowlab_types::bench_metrics::record_keyed_lookup();

        self.offsets
            .slots
            .resources
            .get(&key)
            .copied()
            .filter(|&offset| valid_slot::<ResourceSlot>(offset, self.byte_len))
            .map(ResourceSlotHandle)
    }

    pub(crate) fn unit_handle(&self, key: &str) -> Option<UnitSlotHandle> {
        wowlab_types::bench_metrics::record_keyed_lookup();

        self.offsets
            .slots
            .units
            .get(key)
            .copied()
            .filter(|&offset| valid_slot::<UnitSlot>(offset, self.byte_len))
            .map(UnitSlotHandle)
    }

    pub(crate) fn talent_handle(&self, key: &str) -> Option<TalentSlotHandle> {
        wowlab_types::bench_metrics::record_keyed_lookup();

        self.offsets
            .slots
            .talents
            .get(key)
            .copied()
            .filter(|&offset| valid_slot::<TalentSlot>(offset, self.byte_len))
            .map(TalentSlotHandle)
    }

    pub(crate) fn freeze(offsets: BufferOffsets, byte_len: usize) -> Arc<Self> {
        let mut standalone_defaults = Vec::with_capacity(offsets.standalone.len());

        for (&descriptor_id, &offset) in &offsets.standalone {
            if let Some(default) = inventory::iter::<StandaloneDefault>
                .into_iter()
                .find(|default| (default.matches)(descriptor_id))
            {
                standalone_defaults.push((offset, &default.value));
            }
        }

        let mut concrete_auras: Vec<_> = offsets
            .slots
            .auras
            .iter()
            .filter(|&(_, &offset)| valid_slot::<AuraSlot>(offset, byte_len))
            .map(|(&key, &offset)| (key, AuraSlotHandle(offset)))
            .collect();

        concrete_auras.sort_unstable_by_key(|(_, handle)| *handle);

        let mut aura_projections: Vec<_> = offsets
            .slots
            .aura_projections
            .iter()
            .filter(|&(_, &offset)| valid_slot::<AuraSlot>(offset, byte_len))
            .map(|(&key, &offset)| (key, AuraProjectionSlotHandle(offset)))
            .collect();

        aura_projections.sort_unstable_by_key(|(_, handle)| *handle);

        let mut spells: Vec<_> = offsets
            .slots
            .spells
            .iter()
            .filter(|&(_, &offset)| valid_slot::<SpellSlot>(offset, byte_len))
            .map(|(&key, &offset)| (key, SpellSlotHandle(offset)))
            .collect();

        spells.sort_unstable_by_key(|(_, handle)| *handle);

        let mut cooldowns: Vec<_> = offsets
            .slots
            .cooldowns
            .iter()
            .filter(|&(_, &offset)| valid_slot::<CooldownSlot>(offset, byte_len))
            .map(|(&key, &offset)| (key, CooldownSlotHandle(offset)))
            .collect();

        cooldowns.sort_unstable_by_key(|(_, handle)| *handle);

        let mut history_bindings: Vec<_> = offsets
            .slots
            .history
            .iter()
            .filter(|&(_, &offset)| valid_slot::<HistorySlot>(offset, byte_len))
            .map(|(&key, &offset)| (key, HistorySlotHandle(offset)))
            .collect();

        history_bindings.sort_unstable_by_key(|(_, handle)| *handle);
        let history = history_bindings
            .iter()
            .map(|(_, handle)| *handle)
            .collect::<Vec<_>>();
        let mut resources: Vec<_> = offsets
            .slots
            .resources
            .iter()
            .filter(|&(_, &offset)| valid_slot::<ResourceSlot>(offset, byte_len))
            .map(|(&key, &offset)| (key, ResourceSlotHandle(offset)))
            .collect();

        resources.sort_unstable_by_key(|(_, handle)| *handle);

        let mut units: Vec<_> = offsets
            .slots
            .units
            .iter()
            .filter(|&(_, &offset)| valid_slot::<UnitSlot>(offset, byte_len))
            .map(|(key, &offset)| (Box::<str>::from(key.as_str()), UnitSlotHandle(offset)))
            .collect();

        units.sort_unstable_by_key(|(_, handle)| *handle);

        macro_rules! collect_named {
            ($map:expr, $Slot:ty, $Handle:ident) => {{
                let mut entries: Vec<_> = $map
                    .iter()
                    .filter(|&(_, &offset)| valid_slot::<$Slot>(offset, byte_len))
                    .map(|(key, &offset)| (Box::<str>::from(key.as_str()), $Handle(offset)))
                    .collect();

                entries.sort_unstable_by_key(|(_, handle)| *handle);
                entries.into_boxed_slice()
            }};
        }

        let hero_trees =
            collect_named!(&offsets.slots.hero_trees, HeroTreeSlot, HeroTreeSlotHandle);
        let items = collect_named!(&offsets.slots.items, ItemSlot, ItemSlotHandle);
        let swings = collect_named!(&offsets.slots.swings, SwingSlot, SwingSlotHandle);
        let equipment =
            collect_named!(&offsets.slots.equipment, EquipmentSlot, EquipmentSlotHandle);
        let set_bonuses =
            collect_named!(&offsets.slots.set_bonuses, SetBonusSlot, SetBonusSlotHandle);
        let weapon_imbues = collect_named!(
            &offsets.slots.weapon_imbues,
            WeaponImbueSlot,
            WeaponImbueSlotHandle
        );

        let fingerprint = fingerprint(&offsets, byte_len);

        Arc::new(Self {
            offsets,
            byte_len,
            standalone_defaults: standalone_defaults.into_boxed_slice(),
            bindings: FrozenBufferBindings {
                concrete_auras: concrete_auras.into_boxed_slice(),
                aura_projections: aura_projections.into_boxed_slice(),
                spells: spells.into_boxed_slice(),
                cooldowns: cooldowns.into_boxed_slice(),
                history: history_bindings.into_boxed_slice(),
                resources: resources.into_boxed_slice(),
                hero_trees,
                items,
                swings,
                equipment,
                set_bonuses,
                units: units.into_boxed_slice(),
                weapon_imbues,
            },
            history: history.into_boxed_slice(),
            fingerprint,
        })
    }

    pub(crate) fn standalone_defaults(&self) -> &[(ByteOffset, &'static DefaultValue)] {
        &self.standalone_defaults
    }
}

fn fingerprint(offsets: &BufferOffsets, byte_len: usize) -> LayoutFingerprint {
    const FNV_OFFSET_BASIS: u64 = 0xcbf2_9ce4_8422_2325;
    const FNV_PRIME: u64 = 0x0000_0100_0000_01b3;

    let mut entries = Vec::new();

    macro_rules! add_entries {
        ($tag:literal, $map:expr) => {
            for (key, offset) in $map {
                let mut entry = String::new();
                let _ = write!(&mut entry, "{}:{:?}:{}", $tag, key, offset.as_usize());
                entries.push(entry);
            }
        };
    }

    add_entries!("cooldown", &offsets.slots.cooldowns);
    add_entries!("aura", &offsets.slots.auras);
    add_entries!("projection", &offsets.slots.aura_projections);
    add_entries!("resource", &offsets.slots.resources);
    add_entries!("spell", &offsets.slots.spells);
    add_entries!("talent", &offsets.slots.talents);
    add_entries!("hero_tree", &offsets.slots.hero_trees);
    add_entries!("item", &offsets.slots.items);
    add_entries!("swing", &offsets.slots.swings);
    add_entries!("history", &offsets.slots.history);
    add_entries!("equipment", &offsets.slots.equipment);
    add_entries!("set_bonus", &offsets.slots.set_bonuses);
    add_entries!("unit", &offsets.slots.units);
    add_entries!("weapon_imbue", &offsets.slots.weapon_imbues);
    add_entries!("standalone", &offsets.standalone);
    entries.sort_unstable();

    let mut hash = FNV_OFFSET_BASIS;
    let mut feed = |bytes: &[u8]| {
        for byte in bytes {
            hash ^= u64::from(*byte);
            hash = hash.wrapping_mul(FNV_PRIME);
        }
    };

    feed(&byte_len.to_le_bytes());
    feed(&offsets.player.as_usize().to_le_bytes());
    feed(&offsets.combat.as_usize().to_le_bytes());
    feed(&offsets.pet.as_usize().to_le_bytes());

    for entry in entries {
        feed(entry.as_bytes());
        feed(&[0]);
    }

    LayoutFingerprint(hash)
}

#[cfg(test)]
mod tests {
    use googletest::prelude::*;
    use wowlab_types::sim::{ActorId, AuraIdx, AuraOn};

    use super::*;
    use crate::rotation::buffer::SlotMaps;

    fn base_offsets(slots: SlotMaps<ByteOffset>) -> BufferOffsets {
        BufferOffsets {
            slots,
            player: ByteOffset::new(0),
            combat: ByteOffset::new(0),
            pet: ByteOffset::new(0),
            standalone: wowlab_types::sim::FastMap::default(),
        }
    }

    #[gtest]
    fn every_slot_kind_binds_only_after_bounds_validation() -> Result<()> {
        #[cfg(feature = "bench-metrics")]
        wowlab_types::bench_metrics::reset();

        let spell = SpellIdx::from_raw(7);
        let aura = AuraKey::new(AuraIdx(8), ActorId::Player, ActorId::Player, AuraOn::Player);
        let projection = AuraProjectionKey::new(AuraIdx(8), AuraOn::Player);
        let mut slots = SlotMaps::default();
        let mut offset = 0;

        macro_rules! insert {
            ($map:ident, $key:expr, $Slot:ty) => {{
                slots.$map.insert($key, ByteOffset::new(offset));
                offset += size_of::<$Slot>();
            }};
        }

        insert!(spells, spell, SpellSlot);
        insert!(auras, aura, AuraSlot);
        insert!(aura_projections, projection, AuraSlot);
        insert!(cooldowns, spell, CooldownSlot);
        insert!(history, spell, HistorySlot);
        insert!(resources, ResourceType::Mana, ResourceSlot);
        insert!(units, "target".to_string(), UnitSlot);
        insert!(talents, "talent".to_string(), TalentSlot);
        insert!(hero_trees, "hero".to_string(), HeroTreeSlot);
        insert!(items, "item".to_string(), ItemSlot);
        insert!(swings, "swing".to_string(), SwingSlot);
        insert!(equipment, "equipment".to_string(), EquipmentSlot);
        insert!(set_bonuses, "set".to_string(), SetBonusSlot);
        insert!(weapon_imbues, "imbue".to_string(), WeaponImbueSlot);

        let layout = FrozenBufferLayout::freeze(base_offsets(slots), offset);

        verify_that!(layout.spell_handle(spell), some(anything()))?;
        verify_that!(layout.aura_handle(aura), some(anything()))?;
        verify_true!(
            layout
                .bindings()
                .aura_projections()
                .any(|(key, _)| key == projection)
        )?;
        verify_that!(layout.cooldown_handle(spell), some(anything()))?;
        verify_true!(layout.bindings().history().any(|(key, _)| key == spell))?;
        verify_that!(layout.resource_handle(ResourceType::Mana), some(anything()))?;
        verify_that!(layout.unit_handle("target"), some(anything()))?;
        verify_that!(layout.talent_handle("talent"), some(anything()))?;
        verify_true!(layout.bindings().hero_trees().any(|(key, _)| key == "hero"))?;
        verify_true!(layout.bindings().items().any(|(key, _)| key == "item"))?;
        verify_true!(layout.bindings().swings().any(|(key, _)| key == "swing"))?;
        verify_true!(
            layout
                .bindings()
                .equipment()
                .any(|(key, _)| key == "equipment")
        )?;
        verify_true!(layout.bindings().set_bonuses().any(|(key, _)| key == "set"))?;

        verify_true!(
            layout
                .bindings()
                .weapon_imbues()
                .any(|(key, _)| key == "imbue")
        )?;

        #[cfg(feature = "bench-metrics")]
        verify_that!(wowlab_types::bench_metrics::snapshot().keyed_lookups, eq(6))?;

        Ok(())
    }

    #[gtest]
    fn wrong_kind_misaligned_and_out_of_bounds_bindings_are_rejected() -> Result<()> {
        let wrong_kind = SpellIdx::from_raw(9);
        let misaligned = SpellIdx::from_raw(10);
        let out_of_bounds = SpellIdx::from_raw(11);
        let mut slots = SlotMaps::default();

        slots.cooldowns.insert(wrong_kind, ByteOffset::new(0));
        slots.spells.insert(misaligned, ByteOffset::new(1));
        slots.spells.insert(out_of_bounds, ByteOffset::new(64));
        let layout = FrozenBufferLayout::freeze(base_offsets(slots), 64);

        verify_that!(layout.spell_handle(wrong_kind), none())?;
        verify_that!(layout.cooldown_handle(wrong_kind), some(anything()))?;
        verify_that!(layout.spell_handle(misaligned), none())?;

        verify_that!(layout.spell_handle(out_of_bounds), none())
    }

    #[gtest]
    fn concrete_projection_and_history_arrays_are_stable_by_offset() -> Result<()> {
        let first = AuraKey::new(
            AuraIdx(20),
            ActorId::Player,
            ActorId::Player,
            AuraOn::Player,
        );
        let second = AuraKey::new(
            AuraIdx(21),
            ActorId::Player,
            ActorId::Player,
            AuraOn::Player,
        );
        let first_projection = AuraProjectionKey::new(AuraIdx(20), AuraOn::Player);
        let second_projection = AuraProjectionKey::new(AuraIdx(21), AuraOn::Player);
        let mut slots = SlotMaps::default();

        slots.auras.insert(first, ByteOffset::new(AuraSlot::SIZE));
        slots.auras.insert(second, ByteOffset::new(0));
        slots
            .aura_projections
            .insert(first_projection, ByteOffset::new(AuraSlot::SIZE * 3));
        slots
            .aura_projections
            .insert(second_projection, ByteOffset::new(AuraSlot::SIZE * 2));
        slots.history.insert(
            SpellIdx::from_raw(1),
            ByteOffset::new(AuraSlot::SIZE * 4 + HistorySlot::SIZE),
        );
        slots
            .history
            .insert(SpellIdx::from_raw(2), ByteOffset::new(AuraSlot::SIZE * 4));
        let byte_len = AuraSlot::SIZE * 4 + HistorySlot::SIZE * 2;
        let layout = FrozenBufferLayout::freeze(base_offsets(slots), byte_len);
        let aura_offsets: Vec<_> = layout
            .bindings()
            .auras()
            .map(|(_, handle)| handle.offset().as_usize())
            .collect();
        let projection_offsets: Vec<_> = layout
            .bindings()
            .aura_projections()
            .map(|(_, handle)| handle.offset().as_usize())
            .collect();
        let history_offsets: Vec<_> = layout
            .history_handles()
            .iter()
            .map(|handle| handle.offset().as_usize())
            .collect();

        verify_that!(aura_offsets, eq(&vec![0, AuraSlot::SIZE]))?;
        verify_that!(
            projection_offsets,
            eq(&vec![AuraSlot::SIZE * 2, AuraSlot::SIZE * 3])
        )?;

        verify_that!(
            history_offsets,
            eq(&vec![
                AuraSlot::SIZE * 4,
                AuraSlot::SIZE * 4 + HistorySlot::SIZE
            ])
        )
    }
}