Struct ActionPath 

pub struct ActionPath { /* private fields */ }

Detailed action representation with full path information for UI applications.

This stores the complete path of squares visited during a move, which is necessary to generate proper algebraic notation (especially for multi-capture sequences). Use this for UI display, move history, and game notation.

For high-speed simulations (perft, AI training), use Action instead.

Notation Format (Section 10 of rules)

• Non-capturing move: from-to (e.g., d3-d4)
• Single capture: fromxto (e.g., d4xd6)
• Multi-capture: fromxmidxto (e.g., d4xd6xf6)
• Promotion: from-to=K (e.g., d7-d8=K)
• Capture with promotion: fromxto=K (e.g., c7xc8=K)

Implementations

impl ActionPath

pub const fn new_move(src: Square, dest: Square, is_promotion: bool) -> Self

Creates a new non-capturing move.

pub fn new_capture(src: Square, landings: &[Square], is_promotion: bool) -> Self

Creates a new capture with a path of landing squares.

Arguments

• src - The source square
• landings - Slice of landing squares (where the piece lands after each capture)
• is_promotion - Whether the piece is promoted at the end

pub const fn source(&self) -> Square

Returns the source square.

pub const fn destination(&self) -> Square

Returns the destination (final) square.

pub const fn is_capture(&self) -> bool

Returns true if this is a capture action.

pub const fn is_promotion(&self) -> bool

Returns true if this action results in promotion.

pub const fn path_len(&self) -> usize

Returns the number of squares in the path.

pub fn path(&self) -> &[Square]

Returns the path as a slice.

pub fn to_notation(&self) -> String

Converts the action to its notation string.

Performance

This method is optimized to avoid heap allocations where possible by writing directly to a fixed-size buffer. The maximum notation length is:

• 2 chars per square × 17 squares = 34 chars
• 16 separators (- or x) = 16 chars
• “=K” suffix = 2 chars
• Total: 52 chars max

pub fn write_notation(&self, buf: &mut [u8]) -> usize

Writes the notation directly to a byte buffer without allocation.

This is a performance optimization for batch processing scenarios where you need to generate many notations without heap allocations. For most use cases, prefer to_notation instead.

Returns the number of bytes written.

Panics

In debug builds, panics if the buffer is smaller than 52 bytes.

Example

use kish::{ActionPath, Square};

let action = ActionPath::new_move(Square::E3, Square::E4, false);
let mut buf = [0u8; 52];
let len = action.write_notation(&mut buf);
let notation = std::str::from_utf8(&buf[..len]).unwrap();
assert_eq!(notation, "e3-e4");

Trait Implementations

impl Clone for ActionPath

fn clone(&self) -> ActionPath

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ActionPath

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for ActionPath

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for ActionPath

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ActionPath

fn eq(&self, other: &ActionPath) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for ActionPath

impl Eq for ActionPath

impl StructuralPartialEq for ActionPath