bevy_entitiles 0.2.7

A 2d tilemap library for bevy. With many useful algorithms/tools built in.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use bevy::{ecs::system::Query, gizmos::gizmos::Gizmos, math::Vec2, render::color::Color};

use crate::{
    math::{aabb::Aabb2d, CameraAabb2d},
    tilemap::map::{TilePivot, TilemapSlotSize, TilemapStorage, TilemapTransform, TilemapType},
};

#[cfg(feature = "algorithm")]
use crate::algorithm::pathfinding::Path;

#[cfg(feature = "debug")]
pub fn draw_chunk_aabb(
    mut gizmos: Gizmos,
    tilemaps: Query<(
        &TilemapType,
        &TilePivot,
        &TilemapSlotSize,
        &TilemapTransform,
        &TilemapStorage,
    )>,
) {
    for (ty, tile_pivot, slot_size, transform, storage) in tilemaps.iter() {
        storage.storage.chunks.keys().for_each(|chunk| {
            let aabb = Aabb2d::from_tilemap(
                *chunk,
                storage.storage.chunk_size,
                *ty,
                tile_pivot.0,
                slot_size.0,
                *transform,
            );
            gizmos.rect_2d(
                aabb.center(),
                0.,
                Vec2::new(aabb.width(), aabb.height()),
                Color::GREEN,
            );
        });
    }
}

#[cfg(feature = "algorithm")]
pub fn draw_path(
    mut gizmos: Gizmos,
    path_query: Query<&Path>,
    tilemaps: Query<(
        &TilemapType,
        &TilemapTransform,
        &TilePivot,
        &TilemapSlotSize,
    )>,
) {
    for path in path_query.iter() {
        let (ty, transform, pivot, slot_size) = tilemaps.get(path.get_target_tilemap()).unwrap();

        for node in path.iter() {
            gizmos.circle_2d(
                crate::tilemap::coordinates::index_to_world(*node, ty, transform, pivot, slot_size),
                10.,
                Color::YELLOW_GREEN,
            );
        }
    }
}

pub fn draw_axis(mut gizmos: Gizmos) {
    gizmos.line_2d(Vec2::NEG_X * 1e10, Vec2::X * 1e10, Color::RED);
    gizmos.line_2d(Vec2::NEG_Y * 1e10, Vec2::Y * 1e10, Color::GREEN);
}

pub fn draw_camera_aabb(mut gizmos: Gizmos, camera_aabb: Query<&CameraAabb2d>) {
    camera_aabb.for_each(|aabb| {
        gizmos.rect_2d(
            aabb.0.center(),
            0.,
            Vec2::new(aabb.0.width(), aabb.0.height()),
            Color::BLUE,
        );
    });
}

#[cfg(feature = "serializing")]
pub fn draw_updater_aabbs(
    mut gizmos: Gizmos,
    cameras_query: Query<(
        &CameraAabb2d,
        &crate::tilemap::chunking::camera::CameraChunkUpdater,
    )>,
) {
    cameras_query.for_each(|(cam_aabb, cam_updater)| {
        let detect_aabb = cam_aabb
            .0
            .with_scale(Vec2::splat(cam_updater.detect_scale), Vec2::splat(0.5));
        let update_aabb = cam_aabb
            .0
            .with_scale(Vec2::splat(cam_updater.update_scale), Vec2::splat(0.5));

        gizmos.rect_2d(
            detect_aabb.center(),
            0.,
            Vec2::new(detect_aabb.width(), detect_aabb.height()),
            Color::FUCHSIA,
        );
        gizmos.rect_2d(
            update_aabb.center(),
            0.,
            Vec2::new(update_aabb.width(), update_aabb.height()),
            Color::SILVER,
        );
    });
}