The great componentification

Author: benfrankel

src/animation/transition.rs

@@ -3,7 +3,6 @@ use pyri_state::prelude::*;
 
 use crate::core::PostColorSet;
 use crate::screen::Screen;
-use crate::util::despawn::LateDespawn;
 use crate::util::prelude::*;
 
 pub(super) fn plugin(app: &mut App) {

src/game/actor.rs

@@ -27,7 +27,9 @@ use crate::game::actor::movement::OldMovementController;
 use crate::game::card::deck::Deck;
 use crate::game::combat::death::DespawnOnDeath;
 use crate::game::combat::hit::Hurtbox;
+use crate::game::level::xp::Xp;
 use crate::game::level::xp::XpReward;
+use crate::game::level::Level;
 use crate::game::sprite::SpriteAnimation;
 use crate::util::prelude::*;
 
@@ -138,8 +140,8 @@ impl EntityCommand for Actor {
                     // TODO: Death animation instead, despawn when it's finished.
                     DespawnOnDeath,
                 ),
-                self.xp_reward,
-                self.deck,
+                // Inventory:
+                (Level::default(), Xp::default(), self.xp_reward, self.deck),
             ))
             .with_children(|children| {
                 children

src/game/card/deck.rs

@@ -95,9 +95,7 @@ fn advance_deck(
 
 #[derive(Component, Reflect)]
 #[reflect(Component)]
-struct IsDeckDisplay {
-    target: Entity,
-}
+struct IsDeckDisplay;
 
 impl Configure for IsDeckDisplay {
     fn configure(app: &mut App) {
@@ -112,14 +110,6 @@ impl Configure for IsDeckDisplay {
     }
 }
 
-impl Default for IsDeckDisplay {
-    fn default() -> Self {
-        Self {
-            target: Entity::PLACEHOLDER,
-        }
-    }
-}
-
 /// Clear deck display on any change.
 fn clear_deck_display(
     mut commands: Commands,
@@ -171,7 +161,8 @@ pub fn deck_display(player: Entity) -> impl EntityCommand {
                 },
                 ..default()
             },
-            IsDeckDisplay { target: player },
+            IsDeckDisplay,
+            Selection(player),
         ));
     }
 }

src/game/level.rs

@@ -37,8 +37,8 @@ pub struct LevelData {
     pub xp_cost: f32,
 }
 
-#[derive(Resource, Reflect, Default)]
-#[reflect(Resource)]
+#[derive(Component, Reflect, Default)]
+#[reflect(Component)]
 pub struct Level {
     /// The current level.
     pub current: usize,
@@ -49,7 +49,6 @@ pub struct Level {
 impl Configure for Level {
     fn configure(app: &mut App) {
         app.register_type::<Self>();
-        app.init_resource::<Self>();
     }
 }
 
@@ -65,13 +64,14 @@ impl Configure for IsLevelIndicator {
 }
 
 fn update_level_indicator(
-    level: Res<Level>,
-    mut indicator_query: Query<&mut Text, With<IsLevelIndicator>>,
+    mut indicator_query: Query<(&mut Text, &Selection), With<IsLevelIndicator>>,
+    level_query: Query<&Level>,
 ) {
-    let level = level.current + level.up;
-    let level = level.to_string();
+    for (mut text, selection) in &mut indicator_query {
+        let level = c!(level_query.get(selection.0));
+        let level = level.current + level.up;
+        let level = level.to_string();
 
-    for mut text in &mut indicator_query {
         for section in &mut text.sections {
             section.value.clone_from(&level);
         }

src/game/level/up.rs

@@ -11,9 +11,9 @@ pub(super) fn plugin(app: &mut App) {
     app.configure::<LevelUp>();
 }
 
-/// A buffered event sent when the player levels up.
+/// A buffered event sent when an actor levels up.
 #[derive(Event)]
-pub struct LevelUp;
+pub struct LevelUp(#[allow(unused)] Entity);
 
 impl Configure for LevelUp {
     fn configure(app: &mut App) {
@@ -32,29 +32,37 @@ impl Configure for LevelUp {
 
 fn update_level_up_from_xp(
     config: ConfigRef<LevelConfig>,
-    mut level: ResMut<Level>,
-    mut xp: ResMut<Xp>,
+    mut level_query: Query<(&mut Level, &mut Xp)>,
 ) {
     let config = r!(config.get());
     if config.levels.is_empty() {
         return;
     }
 
-    loop {
-        let xp_cost = config.level(level.current + level.up).xp_cost;
-        if xp.0 < xp_cost {
-            break;
-        }
+    for (mut level, mut xp) in &mut level_query {
+        loop {
+            let level_cost = config.level(level.current + level.up).xp_cost;
+            if xp.relative < level_cost {
+                break;
+            }
 
-        xp.0 -= xp_cost;
-        level.up += 1;
+            xp.relative -= level_cost;
+            level.up += 1;
+        }
     }
 }
 
-fn trigger_level_up(mut level_up_events: EventWriter<LevelUp>, mut level: ResMut<Level>) {
-    if level.up > 0 {
+fn trigger_level_up(
+    mut level_up_events: EventWriter<LevelUp>,
+    mut level_query: Query<(Entity, &mut Level)>,
+) {
+    for (entity, mut level) in &mut level_query {
+        if level.up <= 0 {
+            continue;
+        }
+
         level.up -= 1;
         level.current += 1;
-        level_up_events.send(LevelUp);
+        level_up_events.send(LevelUp(entity));
     }
 }

src/game/level/xp.rs

@@ -11,37 +11,51 @@ use crate::ui::prelude::*;
 use crate::util::prelude::*;
 
 pub(super) fn plugin(app: &mut App) {
-    app.configure::<(Xp, OnReceiveXp, XpReward, IsXpBarFill)>();
+    app.configure::<(Xp, OnXpReward, XpReward, IsXpBarFill)>();
 }
 
-/// The player's XP relative to the current level.
-#[derive(Resource, Reflect, Default)]
-#[reflect(Resource)]
-pub struct Xp(pub f32);
+#[derive(Component, Reflect, Default)]
+#[reflect(Component)]
+pub struct Xp {
+    /// The total amount of XP.
+    pub total: f32,
+    /// The amount of XP relative to the current level.
+    pub relative: f32,
+}
 
 impl Configure for Xp {
     fn configure(app: &mut App) {
         app.register_type::<Self>();
-        app.init_resource::<Self>();
     }
 }
 
-/// An observable event triggered when the player receives XP.
+impl Xp {
+    pub fn gain(&mut self, amount: f32) {
+        self.total += amount;
+        self.relative += amount;
+    }
+}
+
+/// An observable event triggered when an entity receives XP.
 #[derive(Event)]
-pub struct OnReceiveXp(pub f32);
+pub struct OnXpReward(pub f32);
 
-impl Configure for OnReceiveXp {
+impl Configure for OnXpReward {
     fn configure(app: &mut App) {
         app.add_event::<Self>();
         app.observe(receive_xp);
     }
 }
 
-fn receive_xp(trigger: Trigger<OnReceiveXp>, mut xp: ResMut<Xp>) {
-    xp.0 += trigger.event().0;
+fn receive_xp(trigger: Trigger<OnXpReward>, mut xp_query: Query<&mut Xp>) {
+    let entity = r!(trigger.get_entity());
+    let mut xp = r!(xp_query.get_mut(entity));
+    xp.gain(trigger.event().0);
 }
 
-/// Experience rewarded to the player on death.
+// TODO: Not needed for this jam game, but it would be "more correct" to track
+//       the owner of the projectile that killed the actor with the `XpReward`.
+/// Experience rewarded to player entities on death.
 #[derive(Component, Reflect, Serialize, Deserialize, Copy, Clone)]
 #[reflect(Component)]
 #[serde(transparent)]
@@ -69,7 +83,7 @@ fn apply_xp_reward(
     let (faction, reward) = r!(death_query.get(entity));
 
     if faction.is_enemy() {
-        commands.trigger(OnReceiveXp(reward.0));
+        commands.trigger(OnXpReward(reward.0));
     }
 }
 
@@ -86,18 +100,18 @@ impl Configure for IsXpBarFill {
 
 fn update_xp_bar_fill(
     config: ConfigRef<LevelConfig>,
-    level: Res<Level>,
-    xp: Res<Xp>,
-    mut xp_bar_fill_query: Query<&mut Style, With<IsXpBarFill>>,
+    level_query: Query<(&Level, &Xp)>,
+    mut xp_bar_fill_query: Query<(&mut Style, &Selection), With<IsXpBarFill>>,
 ) {
     let config = r!(config.get());
     if config.levels.is_empty() {
         return;
     }
-    let xp_cost = config.level(level.current + level.up).xp_cost;
-    let width = Percent(xp.0 / xp_cost * 100.0);
 
-    for mut style in &mut xp_bar_fill_query {
-        style.width = width;
+    for (mut style, selection) in &mut xp_bar_fill_query {
+        let (level, xp) = r!(level_query.get(selection.0));
+        let level_cost = config.level(level.current + level.up).xp_cost;
+
+        style.width = Percent(xp.relative / level_cost * 100.0);
     }
 }

src/game/wave.rs

@@ -30,8 +30,6 @@ pub struct WaveConfig {
 impl Config for WaveConfig {
     const PATH: &'static str = "config/wave.ron";
     const EXTENSION: &'static str = "wave.ron";
-
-    fn on_load(&mut self, _world: &mut World) {}
 }
 
 #[derive(Asset, Reflect, Serialize, Deserialize)]
@@ -53,14 +51,13 @@ enum SpawnCondition {
     LessThan(usize),
 }
 
-#[derive(Resource, Reflect, Default)]
-#[reflect(Resource)]
+#[derive(Component, Reflect, Default)]
+#[reflect(Component)]
 struct Wave(usize);
 
 impl Configure for Wave {
     fn configure(app: &mut App) {
         app.register_type::<Self>();
-        app.init_resource::<Self>();
         app.add_systems(
             Update,
             Screen::Playing.on_update(
@@ -75,26 +72,29 @@ impl Configure for Wave {
 fn spawn_wave_enemies(
     mut commands: Commands,
     config: ConfigRef<WaveConfig>,
-    mut wave: ResMut<Wave>,
     camera_root: Res<CameraRoot>,
     camera_query: Query<&GlobalTransform>,
-    level: Res<Level>,
+    mut wave_query: Query<(&mut Wave, &Selection)>,
+    level_query: Query<&Level>,
 ) {
     let config = r!(config.get());
     let camera_gt = r!(camera_query.get(camera_root.primary));
     let center = camera_gt.translation().xy();
 
-    wave.0 = wave.0.wrapping_add(1);
-    if wave.0 % config.spawn_cadence != 0 {
-        return;
-    }
+    for (mut wave, selection) in &mut wave_query {
+        let level = c!(level_query.get(selection.0));
+
+        wave.0 = wave.0.wrapping_add(1);
+        if wave.0 % config.spawn_cadence != 0 {
+            return;
+        }
 
-    let mut rng = rand::thread_rng();
-    let spawn_count = (level.current / config.spawn_count_scale)
-        .max(1)
-        .min(config.max_spawn_count);
-    for _ in 0..spawn_count {
-        let available_actors = config
+        let mut rng = rand::thread_rng();
+        let spawn_count = (level.current / config.spawn_count_scale)
+            .max(1)
+            .min(config.max_spawn_count);
+        for _ in 0..spawn_count {
+            let available_actors = config
             .enemies
             .iter()
             // Flatten each spawn_info with its actor key.
@@ -103,14 +103,15 @@ fn spawn_wave_enemies(
                 info.condition.is_empty() || any_condition_met(&info.condition, &level.current)
             });
 
-        if let Some((key, _)) = available_actors.choose(&mut rng) {
-            let offset =
-                Annulus::new(config.min_distance, config.max_distance).sample_interior(&mut rng);
-            let spawn_point = center + offset;
+            if let Some((key, _)) = available_actors.choose(&mut rng) {
+                let offset = Annulus::new(config.min_distance, config.max_distance)
+                    .sample_interior(&mut rng);
+                let spawn_point = center + offset;
 
-            commands
-                .spawn_with(enemy(key))
-                .insert(Transform::from_translation(spawn_point.extend(0.0)));
+                commands
+                    .spawn_with(enemy(key))
+                    .insert(Transform::from_translation(spawn_point.extend(0.0)));
+            }
         }
     }
 }