Struct GridEngine

pub struct GridEngine { /* private fields */ }

The main engine for managing a 2D grid system.

GridEngine provides functionality for:

• Adding items to specific grid positions
• Moving items while handling collisions
• Removing items from the grid
• Tracking changes through an event system
• Expand the grid dynamically on the y axis

When items collide during placement or movement, the engine automatically repositions affected items to prevent overlapping, the default is to move the collided items down, increasing their y axis.

Implementations

impl GridEngine

pub fn new(rows: usize, cols: usize) -> GridEngine

Creates a new GridEngine with specified dimensions.

Arguments

• rows - Initial number of rows in the grid
• cols - Initial number of columns in the grid

Example

use grid_engine::grid_engine::GridEngine;

let grid = GridEngine::new(10, 10); // Creates a 10x10 grid

Examples found in repository

examples/managing_grid.rs (line 56)

fn main() {
    println!("Grid App");

    let mut grid = GridEngine::new(10, 12);

    grid.events_mut().add_changes_listener(Box::new(|event| {
        println!("Event triggered: {:#?}", event);
    }));

    grid.add_item("a".to_string(), 2, 2, 2, 4).unwrap();
    print_grid(&grid);
    grid.add_item("b".to_string(), 4, 2, 2, 4).unwrap();
    print_grid(&grid);
    grid.add_item("c".to_string(), 0, 2, 2, 2).unwrap();
    print_grid(&grid);
    grid.remove_item("b").unwrap();
    print_grid(&grid);
    grid.move_item("a", 1, 0).unwrap();
    print_grid(&grid);
}

pub fn get_nodes(&self) -> Vec<Node>

Get the nodes sorted by id

Example

use grid_engine::grid_engine::GridEngine;

let mut grid = GridEngine::new(10, 10);
grid.add_item("b".to_string(), 0, 0, 2, 2).unwrap();
grid.add_item("a".to_string(), 0, 2, 2, 2).unwrap();

let nodes = grid.get_nodes();
assert_eq!(nodes.len(), 2);
assert_eq!(nodes[0].id(), "a");
assert_eq!(nodes[1].id(), "b");

pub fn get_inner_grid(&self) -> &InnerGrid

Gets a reference to the underlying grid structure.

This provides access to the raw grid data for inspection purposes. Note that modifications should be made through GridEngine’s public methods rather than directly manipulating the inner grid.

Returns

A reference to the InnerGrid instance

Example

use grid_engine::grid_engine::GridEngine;
use std::error::Error;

let grid = GridEngine::new(10, 10);
let inner_grid = grid.get_inner_grid();
assert_eq!(inner_grid.rows(), 10);
assert_eq!(inner_grid.cols(), 10);

Examples found in repository

examples/managing_grid.rs (line 25)

fn print_grid(grid: &GridEngine) {
    let mut grid_str_formatted = String::new();
    grid_str_formatted.push_str("  ");
    for i in 0..grid.get_inner_grid().cols() {
        grid_str_formatted.push_str(&format!(" {} ", i));
    }
    grid_str_formatted.push('\n');

    grid.get_inner_grid()
        .iter_rows()
        .enumerate()
        .for_each(|(row_number, row)| {
            row.enumerate().for_each(|(index, cell)| {
                if index == 0 {
                    grid_str_formatted.push_str(&format!("{:0>2}", row_number));
                }
                match cell {
                    Some(item) => {
                        grid_str_formatted.push_str(&format!("[{}]", item));
                    }
                    None => {
                        grid_str_formatted.push_str(&format!("[{}]", " "));
                    }
                };
            });
            grid_str_formatted.push('\n');
        });

    println!("{}", grid_str_formatted);
}

pub fn add_item( &mut self, id: String, x: usize, y: usize, w: usize, h: usize, ) -> Result<&Node, GridEngineError>

Adds an item to the grid at the specified position.

If the new item would collide with existing items, those items are automatically repositioned to avoid overlap.

Arguments

• id - Unique identifier for the item
• x - X coordinate (column) for item placement
• y - Y coordinate (row) for item placement
• w - Width of the item in grid cells
• h - Height of the item in grid cells

Returns

• Ok(&Node) - Reference to the newly added node
• Err(GridEngineError) - If item already exists or placement fails

Example

use grid_engine::grid_engine::GridEngine;
use std::error::Error;

let mut grid = GridEngine::new(10, 10);
grid.add_item("box1".to_string(), 0, 0, 2, 2)?; // 2x2 item at top-left

// Check if the item was added correctly
let item = grid.get_nodes();
assert_eq!(item.len(), 1);
assert_eq!(item[0].id(), "box1");

Examples found in repository

examples/managing_grid.rs (line 62)

fn main() {
    println!("Grid App");

    let mut grid = GridEngine::new(10, 12);

    grid.events_mut().add_changes_listener(Box::new(|event| {
        println!("Event triggered: {:#?}", event);
    }));

    grid.add_item("a".to_string(), 2, 2, 2, 4).unwrap();
    print_grid(&grid);
    grid.add_item("b".to_string(), 4, 2, 2, 4).unwrap();
    print_grid(&grid);
    grid.add_item("c".to_string(), 0, 2, 2, 2).unwrap();
    print_grid(&grid);
    grid.remove_item("b").unwrap();
    print_grid(&grid);
    grid.move_item("a", 1, 0).unwrap();
    print_grid(&grid);
}

pub fn remove_item(&mut self, id: &str) -> Result<Node, GridEngineError>

Removes an item from the grid by its ID.

Arguments

• id - ID of the item to remove

Returns

• Ok(Node) - The removed node
• Err(GridEngineError) - If item doesn’t exist

Example

use grid_engine::grid_engine::GridEngine;
use std::error::Error;


let mut grid = GridEngine::new(10, 10);
grid.add_item("box1".to_string(), 0, 0, 2, 2)?;
grid.remove_item("box1")?; // Removes the item

Examples found in repository

examples/managing_grid.rs (line 68)

fn main() {
    println!("Grid App");

    let mut grid = GridEngine::new(10, 12);

    grid.events_mut().add_changes_listener(Box::new(|event| {
        println!("Event triggered: {:#?}", event);
    }));

    grid.add_item("a".to_string(), 2, 2, 2, 4).unwrap();
    print_grid(&grid);
    grid.add_item("b".to_string(), 4, 2, 2, 4).unwrap();
    print_grid(&grid);
    grid.add_item("c".to_string(), 0, 2, 2, 2).unwrap();
    print_grid(&grid);
    grid.remove_item("b").unwrap();
    print_grid(&grid);
    grid.move_item("a", 1, 0).unwrap();
    print_grid(&grid);
}

pub fn move_item( &mut self, id: &str, new_x: usize, new_y: usize, ) -> Result<(), GridEngineError>

Moves an existing item to a new position in the grid.

If the move would cause collisions, affected items are automatically repositioned to prevent overlap.

Arguments

• id - ID of the item to move
• new_x - New X coordinate
• new_y - New Y coordinate

Returns

• Ok(()) - If move successful
• Err(GridEngineError) - If item doesn’t exist or move invalid

Example

use grid_engine::grid_engine::GridEngine;


let mut grid = GridEngine::new(10, 10);
grid.add_item("box1".to_string(), 0, 0, 2, 2)?;
grid.move_item("box1", 2, 2)?; // Moves box to position 2,2

// Check if the item was moved correctly
let item = grid.get_nodes();
assert_eq!(item.len(), 1);
assert_eq!(item[0].x(), &2);
assert_eq!(item[0].y(), &2);

Examples found in repository

examples/managing_grid.rs (line 70)

fn main() {
    println!("Grid App");

    let mut grid = GridEngine::new(10, 12);

    grid.events_mut().add_changes_listener(Box::new(|event| {
        println!("Event triggered: {:#?}", event);
    }));

    grid.add_item("a".to_string(), 2, 2, 2, 4).unwrap();
    print_grid(&grid);
    grid.add_item("b".to_string(), 4, 2, 2, 4).unwrap();
    print_grid(&grid);
    grid.add_item("c".to_string(), 0, 2, 2, 2).unwrap();
    print_grid(&grid);
    grid.remove_item("b").unwrap();
    print_grid(&grid);
    grid.move_item("a", 1, 0).unwrap();
    print_grid(&grid);
}

pub fn events(&self) -> &GridEvents

Returns a reference to the grid events system.

pub fn events_mut(&mut self) -> &mut GridEvents

Returns a mutable reference to the grid events system.

Examples found in repository

examples/managing_grid.rs (line 58)

fn main() {
    println!("Grid App");

    let mut grid = GridEngine::new(10, 12);

    grid.events_mut().add_changes_listener(Box::new(|event| {
        println!("Event triggered: {:#?}", event);
    }));

    grid.add_item("a".to_string(), 2, 2, 2, 4).unwrap();
    print_grid(&grid);
    grid.add_item("b".to_string(), 4, 2, 2, 4).unwrap();
    print_grid(&grid);
    grid.add_item("c".to_string(), 0, 2, 2, 2).unwrap();
    print_grid(&grid);
    grid.remove_item("b").unwrap();
    print_grid(&grid);
    grid.move_item("a", 1, 0).unwrap();
    print_grid(&grid);
}

Trait Implementations

impl Debug for GridEngine

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

Formats the value using the given formatter.