traaains/sim/track/node/

mod.rs

//! A node in the physical track graph.

use bevy::{
    asset::Handle,
    ecs::{
        component::Component,
        entity::Entity,
        event::EntityEvent,
        observer::{ObserverSystemExt, On},
        system::{Commands, ResMut},
    },
    mesh::{Mesh, Mesh2d},
    picking::events::PointerPress,
    sprite_render::{ColorMaterial, MeshMaterial2d},
    state::{condition::in_state, state::NextState},
    transform::components::Transform,
};
use smallvec::SmallVec;

use crate::{editor::EditorState, ui::UiState, utils::alloc_map::AllocMap};

mod commands;
mod connection;
mod manager;

pub use commands::RemoveConnectionFor;
pub use connection::{Connection, ConnectionLocation};

const MAX_CONNECTIONS: usize = 32;
const STATIC_CONNECTIONS: usize = 3;

// I do have some doubts about this. Point was to have really quick lookup times for other sides of active connections, which currently it is O(1).
// Inserting a node is at most times O(log n), however sometimes it is required to reallocate the inner smallvec, which makes the operation more
// expensive. Finding a specific connection for a given segment is O(n), not just respective to the number of tracked connections, but to the size
// of the inner smallvec.
// TODO: Implement resizing of the inner smallvec
//
// Of course, it would be easy to just keep the connections in some version of a BST keyed by the connection's segment Entity.
// This version has the added benefit that most nodes, having only two to three connections, fit on the stack.
///
/// Keeps track of node connections. Stores them in a vector, with `alloc_map` keeping track of which spaces in the vector
/// are allocated and which are not. Empty spaces are marked with [Option::None] in the inner vector.
#[derive(Clone, Default)]
pub struct NodeConnections {
    inner: SmallVec<[Option<Connection>; STATIC_CONNECTIONS]>,
    alloc_map: AllocMap<MAX_CONNECTIONS>,
    count: usize,

    /// Indices of connections which make up an active connection.
    /// Stored in order, meaning a\[0\] < a\[1\] (a\[0\] != a\[1\], an active connection cannot be between itself).
    active: Option<(usize, usize)>,
}

impl NodeConnections {
    fn find_first_two(&self) -> Option<[usize; 2]> {
        // find the allocated connections and activate them
        let mut conns = self
            .inner
            .iter()
            .enumerate()
            .filter_map(|(i, c)| if c.is_some() { Some(i) } else { None });

        Some([conns.next()?, conns.next()?])
    }

    /// Tries to add the connection. If the allocation succeded, returns the connections ID.
    /// If there is no space left, returns the connection wrapped in an error.
    pub fn add(&mut self, c: Connection) -> Result<usize, Connection> {
        match self.alloc_map.allocate() {
            Some(index) => {
                // if the index is larger then the inner smallvec's length, then we want to push it, otherwise set it to index
                // index > self.inner.len() can never happen, because the allocation map always returns minimum
                if index == self.inner.len() {
                    self.inner.push(Some(c));
                } else {
                    self.inner[index] = Some(c);
                }

                self.count += 1;

                if self.count == 2 {
                    let [c0, c1] = self.find_first_two().unwrap();
                    self.activate(c0, c1);
                }

                Ok(index)
            }
            None => Err(c),
        }
    }

    /// Attempts to remove the given connection.
    /// If no such connection exists, returns false, otherwise returns true.
    pub fn remove(&mut self, index: usize) -> bool {
        if !self.alloc_map.is_allocated(index) {
            return false;
        }

        self.inner[index] = None;
        self.alloc_map.deallocate(index);
        self.count -= 1;

        if let Some(ac) = self.active
            && (ac.0 == index || ac.1 == index)
        {
            self.deactivate();
        }

        true
    }

    /// Attempts to remove a connection with the given segment
    /// If no such connection exists, returns false, otherwise returns true.
    pub fn remove_for(&mut self, segment: Entity) -> bool {
        for (i, c) in self.inner.iter().enumerate() {
            if let Some(conn) = c
                && conn.segment == segment
            {
                return self.remove(i);
            }
        }

        false
    }

    /// Whether the backing store has any more free spaces.
    pub fn has_free(&self) -> bool {
        self.alloc_map.has_free()
    }

    /// Returns an iterator over the inner connections
    pub fn iter(&self) -> impl Iterator<Item = &Connection> {
        self.inner.iter().filter_map(|c| c.as_ref())
    }

    /// Returns the number of connections
    pub fn len(&self) -> usize {
        self.count
    }

    /// Returns whether there are no connections, similar to [Vec::is_empty()]
    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }

    /// Sets connections with indices `c0` and `c1` as active.
    pub fn activate(&mut self, mut c0: usize, mut c1: usize) {
        assert!(c0 != c1);

        if c0 > c1 {
            (c0, c1) = (c1, c0);
        }

        self.active = Some((c0, c1));
    }

    /// Removes the active connection.
    pub fn deactivate(&mut self) {
        self.active = None;
    }

    /// Returns the active connection.
    pub fn active(&self) -> Option<(&Connection, &Connection)> {
        Some((
            self.inner[self.active?.0].as_ref().unwrap(),
            self.inner[self.active?.1].as_ref().unwrap(),
        ))
    }

    fn advance(c0: &mut usize, c1: &mut usize, len: usize) {
        if *c1 + 1 < len {
            *c1 += 1;
        } else {
            if *c0 + 2 < len {
                *c0 += 1;
            } else {
                *c0 = 0;
            }
            *c1 = *c0 + 1;
        }
    }

    /// Does nothing if there aren't enough connections present (n < 2).
    pub fn activate_next(&mut self) {
        match self.active {
            Some((sc0, sc1)) => {
                let len = self.inner.len();
                let (mut c0, mut c1) = (sc0, sc1);
                NodeConnections::advance(&mut c0, &mut c1, len);

                loop {
                    if self.inner[c1].is_some() {
                        self.activate(c0, c1);
                        return;
                    }

                    NodeConnections::advance(&mut c0, &mut c1, len);

                    if (c0, c1) == (sc0, sc1) {
                        return;
                    }
                }
            }
            None => {
                if let Some([c0, c1]) = self.find_first_two() {
                    self.activate(c0, c1);
                }
            }
        }
    }

    /// Returns the other side of the active connection for the `segment`.
    /// None if `segment` isn't part of the active connection.
    pub fn get_active_for(&self, segment: Entity) -> Option<&Connection> {
        if self.inner[self.active?.0].as_ref().unwrap().segment == segment {
            return self.inner[self.active?.1].as_ref();
        }

        if self.inner[self.active?.1].as_ref().unwrap().segment == segment {
            return self.inner[self.active?.0].as_ref();
        }

        None
    }
}

/// A node in the physical track graph.
#[derive(Clone, Default, Component)]
pub struct TrackNode {
    pub connections: NodeConnections,
}

impl TrackNode {
    pub fn spawn(
        cmd: &mut Commands,
        transform: Transform,
        mesh: Handle<Mesh>,
        mat: Handle<ColorMaterial>,
    ) -> Entity {
        cmd.spawn((
            TrackNode::default(),
            transform,
            Mesh2d(mesh),
            MeshMaterial2d(mat),
        ))
        .observe(on_node_press_window.run_if(in_state(EditorState::Viewing)))
        .id()
    }
}

/// Observer that listens for pointer presses on nodes and opens editing windows
pub fn on_node_press_window(e: On<PointerPress>, mut next_state: ResMut<NextState<UiState>>) {
    next_state.set(UiState::NodeWindow {
        target: e.event_target(),
    });
}