17075858891

Committed 19 Aug 2025 04:31PM UTC coverage: 51.198% (-0.4%) from 51.621%

Build # 17075858891

Build Type

push

github

Committed by

Xevion

Commit Message

refactor: update debug state management and rendering systems

Run Details

1 of 75 new or added lines in 4 files covered. (1.33%)

4 existing lines in 2 files now uncovered.

1047 of 2045 relevant lines covered (51.2%)

1101.58 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/systems/render.rs

use crate::error::{GameError, TextureError};
use crate::map::builder::Map;
use crate::systems::components::{DeltaTime, DirectionalAnimated, RenderDirty, Renderable};
use crate::systems::movement::{Position, Velocity};
use crate::texture::sprite::SpriteAtlas;
use bevy_ecs::entity::Entity;
use bevy_ecs::event::EventWriter;
use bevy_ecs::prelude::{Changed, Or, RemovedComponents};
use bevy_ecs::system::{NonSendMut, Query, Res, ResMut};
use sdl2::rect::{Point, Rect};
use sdl2::render::{Canvas, Texture};
use sdl2::video::Window;

#[allow(clippy::type_complexity)]
pub fn dirty_render_system(
    mut dirty: ResMut<RenderDirty>,
    changed_renderables: Query<(), Or<(Changed<Renderable>, Changed<Position>)>>,
    removed_renderables: RemovedComponents<Renderable>,
) {
    if !changed_renderables.is_empty() || !removed_renderables.is_empty() {
        dirty.0 = true;
    }
}

/// Updates the directional animated texture of an entity.
///
/// This runs before the render system so it can update the sprite based on the current direction of travel, as well as whether the entity is moving.
pub fn directional_render_system(
    dt: Res<DeltaTime>,
    mut renderables: Query<(&Position, &Velocity, &mut DirectionalAnimated, &mut Renderable)>,
    mut errors: EventWriter<GameError>,
) {
    for (position, velocity, mut texture, mut renderable) in renderables.iter_mut() {
        let stopped = matches!(position, Position::Stopped { .. });
        let current_direction = velocity.direction;

        let texture = if stopped {
            texture.stopped_textures[current_direction.as_usize()].as_mut()
        } else {
            texture.textures[current_direction.as_usize()].as_mut()
        };

        if let Some(texture) = texture {
            if !stopped {
                texture.tick(dt.0);
            }
            let new_tile = *texture.current_tile();
            if renderable.sprite != new_tile {
                renderable.sprite = new_tile;
            }
        } else {
            errors.write(TextureError::RenderFailed("Entity has no texture".to_string()).into());
            continue;
        }
    }
}

/// A non-send resource for the map texture. This just wraps the texture with a type so it can be differentiated when exposed as a resource.
pub struct MapTextureResource(pub Texture<'static>);

/// A non-send resource for the backbuffer texture. This just wraps the texture with a type so it can be differentiated when exposed as a resource.
pub struct BackbufferResource(pub Texture<'static>);

#[allow(clippy::too_many_arguments)]
pub fn render_system(
    mut canvas: NonSendMut<&mut Canvas<Window>>,
    map_texture: NonSendMut<MapTextureResource>,
    mut backbuffer: NonSendMut<BackbufferResource>,
    mut atlas: NonSendMut<SpriteAtlas>,
    map: Res<Map>,
    dirty: Res<RenderDirty>,
    renderables: Query<(Entity, &Renderable, &Position)>,
    mut errors: EventWriter<GameError>,
) {
    if !dirty.0 {
        return;
    }
    // Render to backbuffer
    canvas
        .with_texture_canvas(&mut backbuffer.0, |backbuffer_canvas| {
            // Clear the backbuffer
            backbuffer_canvas.set_draw_color(sdl2::pixels::Color::BLACK);
            backbuffer_canvas.clear();

            // Copy the pre-rendered map texture to the backbuffer
            if let Err(e) = backbuffer_canvas.copy(&map_texture.0, None, None) {
                errors.write(TextureError::RenderFailed(e.to_string()).into());
            }

            // Render all entities to the backbuffer
            for (_, renderable, position) in renderables
                .iter()
                .sort_by_key::<(Entity, &Renderable, &Position), _>(|(_, renderable, _)| renderable.layer)
                .rev()
            {
                if !renderable.visible {
                    continue;
                }

                let pos = position.get_pixel_position(&map.graph);
                match pos {
                    Ok(pos) => {
                        let dest = Rect::from_center(
                            Point::from((pos.x as i32, pos.y as i32)),
                            renderable.sprite.size.x as u32,
                            renderable.sprite.size.y as u32,
                        );

                        renderable
                            .sprite
                            .render(backbuffer_canvas, &mut atlas, dest)
                            .err()
                            .map(|e| errors.write(TextureError::RenderFailed(e.to_string()).into()));
                    }
                    Err(e) => {
                        errors.write(e);
                    }
                }
            }
        })
        .err()
        .map(|e| errors.write(TextureError::RenderFailed(e.to_string()).into()));

    canvas.copy(&backbuffer.0, None, None).unwrap();
}

1	use crate::error::{GameError, TextureError};
2	use crate::map::builder::Map;
3	use crate::systems::components::{DeltaTime, DirectionalAnimated, RenderDirty, Renderable};
4	use crate::systems::movement::{Position, Velocity};
5	use crate::texture::sprite::SpriteAtlas;
6	use bevy_ecs::entity::Entity;
7	use bevy_ecs::event::EventWriter;
8	use bevy_ecs::prelude::{Changed, Or, RemovedComponents};
9	use bevy_ecs::system::{NonSendMut, Query, Res, ResMut};
10	use sdl2::rect::{Point, Rect};
11	use sdl2::render::{Canvas, Texture};
12	use sdl2::video::Window;
13
14	#[allow(clippy::type_complexity)]
15	pub fn dirty_render_system(	×
16	mut dirty: ResMut<RenderDirty>,	×
17	changed_renderables: Query<(), Or<(Changed<Renderable>, Changed<Position>)>>,	×
18	removed_renderables: RemovedComponents<Renderable>,	×
19	) {	×
20	if !changed_renderables.is_empty() \|\| !removed_renderables.is_empty() {	×
21	dirty.0 = true;	×
22	}	×
23	}	×
24
25	/// Updates the directional animated texture of an entity.
26	///
27	/// This runs before the render system so it can update the sprite based on the current direction of travel, as well as whether the entity is moving.
28	pub fn directional_render_system(	×
29	dt: Res<DeltaTime>,	×
30	mut renderables: Query<(&Position, &Velocity, &mut DirectionalAnimated, &mut Renderable)>,	×
31	mut errors: EventWriter<GameError>,	×
32	) {	×
33	for (position, velocity, mut texture, mut renderable) in renderables.iter_mut() {	×
34	let stopped = matches!(position, Position::Stopped { .. });	×
35	let current_direction = velocity.direction;	×
36
37	let texture = if stopped {	×
38	texture.stopped_textures[current_direction.as_usize()].as_mut()	×
39	} else {
40	texture.textures[current_direction.as_usize()].as_mut()	×
41	};
42
43	if let Some(texture) = texture {	×
44	if !stopped {	×
45	texture.tick(dt.0);	×
46	}	×
47	let new_tile = *texture.current_tile();	×
48	if renderable.sprite != new_tile {	×
49	renderable.sprite = new_tile;	×
50	}	×
51	} else {
52	errors.write(TextureError::RenderFailed("Entity has no texture".to_string()).into());	×
53	continue;	×
54	}
55	}
56	}	×
57
58	/// A non-send resource for the map texture. This just wraps the texture with a type so it can be differentiated when exposed as a resource.
59	pub struct MapTextureResource(pub Texture<'static>);
60
61	/// A non-send resource for the backbuffer texture. This just wraps the texture with a type so it can be differentiated when exposed as a resource.
62	pub struct BackbufferResource(pub Texture<'static>);
63
64	#[allow(clippy::too_many_arguments)]
65	pub fn render_system(	×
66	mut canvas: NonSendMut<&mut Canvas<Window>>,	×
67	map_texture: NonSendMut<MapTextureResource>,	×
68	mut backbuffer: NonSendMut<BackbufferResource>,	×
69	mut atlas: NonSendMut<SpriteAtlas>,	×
70	map: Res<Map>,	×
71	dirty: Res<RenderDirty>,	×
72	renderables: Query<(Entity, &Renderable, &Position)>,	×
73	mut errors: EventWriter<GameError>,	×
74	) {	×
75	if !dirty.0 {	×
76	return;	×
77	}	×
78	// Render to backbuffer	×
79	canvas	×
80	.with_texture_canvas(&mut backbuffer.0, \|backbuffer_canvas\| {	×
81	// Clear the backbuffer	×
82	backbuffer_canvas.set_draw_color(sdl2::pixels::Color::BLACK);	×
83	backbuffer_canvas.clear();	×
84
85	// Copy the pre-rendered map texture to the backbuffer
86	if let Err(e) = backbuffer_canvas.copy(&map_texture.0, None, None) {	×
87	errors.write(TextureError::RenderFailed(e.to_string()).into());	×
88	}	×
89
90	// Render all entities to the backbuffer
91	for (_, renderable, position) in renderables	×
92	.iter()	×
93	.sort_by_key::<(Entity, &Renderable, &Position), _>(\|(_, renderable, _)\| renderable.layer)	×
94	.rev()	×
95	{
96	if !renderable.visible {	×
97	continue;	×
98	}	×
99		×
100	let pos = position.get_pixel_position(&map.graph);	×
101	match pos {	×
102	Ok(pos) => {	×
103	let dest = Rect::from_center(	×
104	Point::from((pos.x as i32, pos.y as i32)),	×
105	renderable.sprite.size.x as u32,	×
106	renderable.sprite.size.y as u32,	×
107	);	×
108		×
109	renderable	×
110	.sprite	×
111	.render(backbuffer_canvas, &mut atlas, dest)	×
112	.err()	×
113	.map(\|e\| errors.write(TextureError::RenderFailed(e.to_string()).into()));	×
114	}	×
115	Err(e) => {	×
116	errors.write(e);	×
117	}	×
118	}
119	}
120	})	×
121	.err()	×
122	.map(\|e\| errors.write(TextureError::RenderFailed(e.to_string()).into()));	×
NEW 123		×
NEW 124	canvas.copy(&backbuffer.0, None, None).unwrap();	×
UNCOV 125	}	×

Xevion / Pac-Man / 17075858891

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous