gered/ggdt
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

update example project entity system component store usage

Browse source 
i think i prefer this style. it's not _technically_ as safe as it was
before, but i prefer the explicitness of it (and it results in a little
bit less nesting in system functions which is nice).

i don't much like the need for an explicit `unwrap()` call however
but that's the tradeoff!
This commit is contained in:
Gered 2023-01-01 12:22:03 -05:00
parent 2b33a64120
commit ed754cb9ac
4 changed files with 389 additions and 371 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

33
examples/balls_v2/src/entities.rs
View file

@ -95,7 +95,7 @@ fn new_ball_entity(entities: &mut Entities) {
}
fn update_system_movement(context: &mut Context) {
if let Some(mut positions) = context.entities.components_mut::<Position>() {
let mut positions = context.entities.components_mut::<Position>().unwrap();
let velocities = context.entities.components::<Velocity>();
for (entity, position) in positions.iter_mut() {
@ -104,14 +104,13 @@ fn update_system_movement(context: &mut Context) {
}
}
}
}
fn update_system_collision(context: &mut Context) {
if let Some(bounceable) = context.entities.components::<BouncesAgainstEdge>() {
let bounceables = context.entities.components::<BouncesAgainstEdge>().unwrap();
let mut positions = context.entities.components_mut::<Position>();
let mut velocities = context.entities.components_mut::<Velocity>();
for (entity, _) in bounceable.iter() {
for (entity, _) in bounceables.iter() {
let mut position = positions.get_mut(&entity).unwrap();
let mut velocity = velocities.get_mut(&entity).unwrap();
@ -131,10 +130,9 @@ fn update_system_collision(context: &mut Context) {
}
}
}
}
fn update_system_lifetime(context: &mut Context) {
if let Some(mut lifetimes) = context.entities.components_mut::<LifeLeft>() {
let mut lifetimes = context.entities.components_mut::<LifeLeft>().unwrap();
for (entity, lifetime) in lifetimes.iter_mut() {
lifetime.life -= context.delta;
if lifetime.life < 0.0 {
@ -142,11 +140,9 @@ fn update_system_lifetime(context: &mut Context) {
}
}
}
}
fn update_system_leave_particle_trail(context: &mut Context) {
if let Some(mut leaves_trails) = context.entities.components_mut::<LeavesTrail>() {
let mut leaves_trails = context.entities.components_mut::<LeavesTrail>().unwrap();
let positions = context.entities.components::<Position>();
for (entity, leaves_trail) in leaves_trails.iter_mut() {
@ -162,11 +158,9 @@ fn update_system_leave_particle_trail(context: &mut Context) {
}
}
}
}
fn render_system_sprites(context: &mut Context) {
if let Some(sprite_indices) = context.entities.components::<SpriteIndex>() {
let sprite_indices = context.entities.components::<SpriteIndex>().unwrap();
let positions = context.entities.components::<Position>();
for (entity, sprite_index) in sprite_indices.iter() {
@ -179,11 +173,9 @@ fn render_system_sprites(context: &mut Context) {
);
}
}
}
fn render_system_particles(context: &mut Context) {
if let Some(particles) = context.entities.components::<Particle>() {
let particles = context.entities.components::<Particle>().unwrap();
let positions = context.entities.components::<Position>();
let colors = context.entities.components::<Color>();
let colors_by_lifetime = context.entities.components::<ColorByLifeTime>();
@ -218,7 +210,6 @@ fn render_system_particles(context: &mut Context) {
}
}
}
}
fn event_handler(event: &Event, context: &mut Context) -> bool {
match event {
@ -241,6 +232,16 @@ fn event_handler(event: &Event, context: &mut Context) -> bool {
}
pub fn init_entities(entities: &mut Entities) {
entities.init_components::<Position>();
entities.init_components::<Velocity>();
entities.init_components::<SpriteIndex>();
entities.init_components::<BouncesAgainstEdge>();
entities.init_components::<Particle>();
entities.init_components::<Color>();
entities.init_components::<LifeLeft>();
entities.init_components::<LeavesTrail>();
entities.init_components::<ColorByLifeTime>();
entities.remove_all_entities();
for _ in 0..NUM_BALLS {
new_ball_entity(entities);

37
examples/slimed/src/entities/mod.rs
View file

@ -395,12 +395,45 @@ pub fn init_everything(context: &mut Game, map_file: &Path, min_spawn_time: f32,
}
pub fn init_entities(entities: &mut Entities) {
entities.remove_all_entities();
entities.init_components::<Weapon>();
entities.init_components::<Player>();
entities.init_components::<Slime>();
entities.init_components::<Activity>();
entities.init_components::<AnimationDef>();
entities.init_components::<AnimationInstance>();
entities.init_components::<AnimateByActivity>();
entities.init_components::<KillWhenAnimationFinishes>();
entities.init_components::<Position>();
entities.init_components::<Velocity>();
entities.init_components::<Forces>();
entities.init_components::<Bounds>();
entities.init_components::<FacingDirection>();
entities.init_components::<IgnoresCollision>();
entities.init_components::<IgnoresFriction>();
entities.init_components::<Particle>();
entities.init_components::<LifeTime>();
entities.init_components::<Pixel>();
entities.init_components::<Sprite>();
entities.init_components::<RandomlyWalksAround>();
entities.init_components::<WalkingTime>();
entities.init_components::<MovementSpeed>();
entities.init_components::<World>();
entities.init_components::<SpawnTimer>();
entities.init_components::<Camera>();
entities.init_components::<Pushable>();
entities.init_components::<Pusher>();
entities.init_components::<AttachedTo>();
entities.init_components::<Attachment>();
entities.init_components::<AttachmentOffset>();
entities.init_components::<AttachmentOffsetByDirection>();
entities.init_components::<Attackable>();
entities.init_components::<SpriteIndexByDirection>();
entities.init_components::<Weapon>();
entities.init_components::<Life>();
entities.init_components::<TimedFlicker>();
entities.init_components::<HitParticleColor>();
entities.init_components::<Pickupable>();
entities.init_components::<Pickuper>();
entities.remove_all_entities();
}
///////////////////////////////////////////////////////////////////////////////////////////////////

57
examples/slimed/src/entities/systems.rs
View file

@ -267,7 +267,7 @@ pub fn pickup(context: &mut Core, picked_up_by: EntityId, picked_up: EntityId) {
///////////////////////////////////////////////////////////////////////////////////////////////////
fn update_system_movement(context: &mut Core) {
if let Some(mut positions) = context.entities.components_mut::<Position>() {
let mut positions = context.entities.components_mut::<Position>().unwrap();
let velocities = context.entities.components::<Velocity>();
let forces = context.entities.components::<Forces>();
let bounds = context.entities.components::<Bounds>();
@ -295,10 +295,9 @@ fn update_system_movement(context: &mut Core) {
}
}
}
}
fn update_system_friction(context: &mut Core) {
if let Some(mut velocities) = context.entities.components_mut::<Velocity>() {
let mut velocities = context.entities.components_mut::<Velocity>().unwrap();
let ignores_friction = context.entities.components::<IgnoresFriction>();
for (entity, velocity) in velocities.iter_mut() {
@ -310,15 +309,13 @@ fn update_system_friction(context: &mut Core) {
}
}
}
}
fn update_system_force_decay(context: &mut Core) {
if let Some(mut forces) = context.entities.components_mut::<Forces>() {
let mut forces = context.entities.components_mut::<Forces>().unwrap();
for (_, force) in forces.iter_mut() {
force.decay();
}
}
}
fn update_system_pushing(context: &mut Core) {
let positions = context.entities.components::<Position>();
@ -355,7 +352,7 @@ fn update_system_pushing(context: &mut Core) {
}
fn update_system_lifetime(context: &mut Core) {
if let Some(mut lifetimes) = context.entities.components_mut::<LifeTime>() {
let mut lifetimes = context.entities.components_mut::<LifeTime>().unwrap();
for (entity, lifetime) in lifetimes.iter_mut() {
lifetime.0 -= context.delta;
if lifetime.0 < 0.0 {
@ -363,10 +360,9 @@ fn update_system_lifetime(context: &mut Core) {
}
}
}
}
fn update_system_animation(context: &mut Core) {
if let Some(mut animations) = context.entities.components_mut::<AnimationInstance>() {
let mut animations = context.entities.components_mut::<AnimationInstance>().unwrap();
let kill_when_animation_finishes = context.entities.components::<KillWhenAnimationFinishes>();
for (entity, animation) in animations.iter_mut() {
@ -403,10 +399,9 @@ fn update_system_animation(context: &mut Core) {
}
}
}
}
fn update_system_set_sprite_index_from_animation(context: &mut Core) {
if let Some(animations) = context.entities.components::<AnimationInstance>() {
let animations = context.entities.components::<AnimationInstance>().unwrap();
let mut sprites = context.entities.components_mut::<Sprite>();
let facing_directions = context.entities.components::<FacingDirection>();
@ -426,10 +421,9 @@ fn update_system_set_sprite_index_from_animation(context: &mut Core) {
}
}
}
}
fn update_system_set_sprite_index_by_direction(context: &mut Core) {
if let Some(sprite_index_by_directions) = context.entities.components::<SpriteIndexByDirection>() {
let sprite_index_by_directions = context.entities.components::<SpriteIndexByDirection>().unwrap();
let mut sprites = context.entities.components_mut::<Sprite>();
let facing_directions = context.entities.components::<FacingDirection>();
@ -441,10 +435,9 @@ fn update_system_set_sprite_index_by_direction(context: &mut Core) {
}
}
}
}
fn update_system_walking_time(context: &mut Core) {
if let Some(mut walking_times) = context.entities.components_mut::<WalkingTime>() {
let mut walking_times = context.entities.components_mut::<WalkingTime>().unwrap();
let activities = context.entities.components::<Activity>();
for (entity, walking_time) in walking_times.iter_mut() {
@ -463,10 +456,9 @@ fn update_system_walking_time(context: &mut Core) {
// remove walking time components whose timers have elapsed
walking_times.retain(|_, comp| comp.0 > 0.0);
}
}
fn update_system_randomly_walk_around(context: &mut Core) {
if let Some(mut randomly_walk_arounds) = context.entities.components_mut::<RandomlyWalksAround>() {
let mut randomly_walk_arounds = context.entities.components_mut::<RandomlyWalksAround>().unwrap();
let activities = context.entities.components::<Activity>();
let mut walking_times = context.entities.components_mut::<WalkingTime>().unwrap();
@ -491,10 +483,9 @@ fn update_system_randomly_walk_around(context: &mut Core) {
}
}
}
}
fn update_system_current_entity_activity(context: &mut Core) {
if let Some(activities) = context.entities.components::<Activity>() {
let activities = context.entities.components::<Activity>().unwrap();
let velocities = context.entities.components::<Velocity>();
for (entity, activity) in activities.iter() {
@ -517,7 +508,6 @@ fn update_system_current_entity_activity(context: &mut Core) {
}
}
}
}
fn update_system_randomly_spawn_slimes(context: &mut Core) {
if let Some((entity, _)) = context.entities.components::<World>().single() {
@ -557,7 +547,7 @@ fn update_system_camera_follows_player(context: &mut Core) {
}
fn update_system_turn_attached_entities(context: &mut Core) {
if let Some(attachments) = context.entities.components::<Attachment>() {
let attachments = context.entities.components::<Attachment>().unwrap();
let mut facing_directions = context.entities.components_mut::<FacingDirection>();
for (parent_entity, attachment) in attachments.iter() {
@ -576,10 +566,9 @@ fn update_system_turn_attached_entities(context: &mut Core) {
}
}
}
}
fn update_system_position_attached_entities(context: &mut Core) {
if let Some(attachments) = context.entities.components::<Attachment>() {
let attachments = context.entities.components::<Attachment>().unwrap();
let mut positions = context.entities.components_mut::<Position>();
let facing_directions = context.entities.components::<FacingDirection>();
let offsets = context.entities.components::<AttachmentOffset>();
@ -611,20 +600,17 @@ fn update_system_position_attached_entities(context: &mut Core) {
}
}
}
}
fn update_system_timed_flicker(context: &mut Core) {
if let Some(mut timed_flicker) = context.entities.components_mut::<TimedFlicker>() {
for (_, flicker) in timed_flicker.iter_mut() {
let mut timed_flickers = context.entities.components_mut::<TimedFlicker>().unwrap();
for (_, flicker) in timed_flickers.iter_mut() {
flicker.update(context.delta);
}
timed_flicker.retain(|_, flicker| flicker.timer > 0.0);
}
timed_flickers.retain(|_, flicker| flicker.timer > 0.0);
}
fn update_system_pickups(context: &mut Core) {
if let Some(mut pickupables) = context.entities.components_mut::<Pickupable>() {
let mut pickupables = context.entities.components_mut::<Pickupable>().unwrap();
let pickupers = context.entities.components::<Pickuper>().unwrap();
let positions = context.entities.components::<Position>();
let bounds = context.entities.components::<Bounds>();
@ -664,18 +650,17 @@ fn update_system_pickups(context: &mut Core) {
}
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
fn render_system_sprites(context: &mut Core) {
context.sprite_render_list.clear();
if let Some(sprites) = context.entities.components::<Sprite>() {
if let Some((_, camera)) = context.entities.components::<Camera>().single() {
let sprites = context.entities.components::<Sprite>().unwrap();
let positions = context.entities.components::<Position>().unwrap();
let timed_flickers = context.entities.components::<TimedFlicker>().unwrap();
if let Some((_, camera)) = context.entities.components::<Camera>().single() {
// build up list of entities to be rendered with their positions so we can sort them
// and render these entities with a proper y-based sort order
for (entity, _) in sprites.iter() {
@ -717,13 +702,12 @@ fn render_system_sprites(context: &mut Core) {
}
}
}
}
fn render_system_pixels(context: &mut Core) {
if let Some(pixels) = context.entities.components::<Pixel>() {
if let Some((_, camera)) = context.entities.components::<Camera>().single() {
let pixels = context.entities.components::<Pixel>().unwrap();
let positions = context.entities.components::<Position>();
if let Some((_, camera)) = context.entities.components::<Camera>().single() {
for (entity, pixel) in pixels.iter() {
if let Some(position) = positions.get(entity) {
context.system.video.set_pixel(
@ -735,7 +719,6 @@ fn render_system_pixels(context: &mut Core) {
}
}
}
}
pub fn init_component_system(cs: &mut ComponentSystems<Core, Core>) {
cs.reset();

13
examples/template_complicated/src/main.rs
View file

@ -50,7 +50,7 @@ pub struct Color(u8);
//////////////////////////////////////////////////////////////////////////////////////////////////
pub fn update_system_movement(context: &mut Core) {
if let Some(mut positions) = context.entities.components_mut::<Position>() {
let mut positions = context.entities.components_mut::<Position>().unwrap();
let velocities = context.entities.components::<Velocity>().unwrap();
for (entity, position) in positions.iter_mut() {
@ -58,20 +58,18 @@ pub fn update_system_movement(context: &mut Core) {
position.0 += velocity.0 * context.delta;
}
}
}
pub fn update_system_remove_offscreen(context: &mut Core) {
if let Some(positions) = context.entities.components::<Position>() {
let positions = context.entities.components::<Position>().unwrap();
for (entity, position) in positions.iter() {
if !context.system.video.is_xy_visible(position.0.x as i32, position.0.y as i32) {
context.event_publisher.queue(Event::Remove(*entity));
}
}
}
}
pub fn render_system_pixels(context: &mut Core) {
if let Some(positions) = context.entities.components::<Position>() {
let positions = context.entities.components::<Position>().unwrap();
let colors = context.entities.components::<Color>().unwrap();
for (entity, position) in positions.iter() {
@ -79,7 +77,6 @@ pub fn render_system_pixels(context: &mut Core) {
context.system.video.set_pixel(position.0.x as i32, position.0.y as i32, color.0);
}
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////
@ -87,6 +84,10 @@ pub struct DemoState;
impl DemoState {
fn init(&mut self, context: &mut Game) {
context.core.entities.init_components::<Position>();
context.core.entities.init_components::<Velocity>();
context.core.entities.init_components::<Color>();
context.component_systems.reset();
context.component_systems.add_update_system(update_system_movement);
context.component_systems.add_update_system(update_system_remove_offscreen);