169 lines
4.2 KiB
Rust
169 lines
4.2 KiB
Rust
//bevy system signatures often violate these rules
|
|
#![allow(clippy::type_complexity)]
|
|
#![allow(clippy::too_many_arguments)]
|
|
|
|
use std::time::Duration;
|
|
|
|
use bevy::prelude::*;
|
|
use state::{AppState, GameSystemSet};
|
|
|
|
pub struct ResourcesPlugin;
|
|
|
|
impl Plugin for ResourcesPlugin {
|
|
fn build(&self, app: &mut App) {
|
|
app.add_systems(OnEnter(AppState::Game), setup)
|
|
.add_systems(FixedUpdate, tick_harvest.in_set(GameSystemSet::Execute))
|
|
.insert_resource(AvailableWorkers(1))
|
|
.add_observer(on_harvest);
|
|
}
|
|
}
|
|
|
|
fn setup(mut commands: Commands) {
|
|
commands.insert_resource(Resources(Quantity {
|
|
souls: 10,
|
|
bones: 10,
|
|
}));
|
|
}
|
|
|
|
#[derive(Resource, Default, Deref, DerefMut)]
|
|
pub struct Resources(pub Quantity);
|
|
|
|
impl Resources {
|
|
pub fn buy(&mut self, cost: &Cost) -> bool {
|
|
if !self.can_buy(cost.0) {
|
|
return false;
|
|
}
|
|
self.0 = self.0 - cost.0;
|
|
true
|
|
}
|
|
}
|
|
|
|
#[derive(Component, Default, Deref, DerefMut)]
|
|
pub struct Cost(pub Quantity);
|
|
|
|
#[derive(Default, Clone, Copy, PartialEq, Eq)]
|
|
pub struct Quantity {
|
|
pub souls: u32,
|
|
pub bones: u32,
|
|
}
|
|
|
|
impl Quantity {
|
|
pub fn to_string(self) -> String {
|
|
let souls_text = if self.souls > 0 {
|
|
format!("{} souls", self.souls)
|
|
} else {
|
|
"".to_string()
|
|
};
|
|
let divider_text = if self.souls > 0 && self.bones > 0 {
|
|
", "
|
|
} else if self.souls == 0 && self.bones == 0 {
|
|
"FREE!!!"
|
|
} else {
|
|
""
|
|
};
|
|
let bones_text = if self.bones > 0 {
|
|
format!("{} bones", self.bones)
|
|
} else {
|
|
"".to_string()
|
|
};
|
|
format!("{}{}{}", souls_text, divider_text, bones_text)
|
|
}
|
|
|
|
pub fn can_buy(self, product: Quantity) -> bool {
|
|
self.bones >= product.bones && self.souls >= product.souls
|
|
}
|
|
}
|
|
|
|
impl std::ops::Mul<u32> for Quantity {
|
|
type Output = Quantity;
|
|
|
|
fn mul(self, rhs: u32) -> Self::Output {
|
|
Self {
|
|
souls: self.souls.saturating_mul(rhs),
|
|
bones: self.bones.saturating_mul(rhs),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl std::ops::Add<Quantity> for Quantity {
|
|
type Output = Quantity;
|
|
|
|
fn add(self, rhs: Quantity) -> Self::Output {
|
|
Quantity {
|
|
souls: self.souls.saturating_add(rhs.souls),
|
|
bones: self.bones.saturating_add(rhs.bones),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl std::ops::Sub<Quantity> for Quantity {
|
|
type Output = Quantity;
|
|
|
|
fn sub(self, rhs: Quantity) -> Self::Output {
|
|
Quantity {
|
|
souls: self.souls.saturating_sub(rhs.souls),
|
|
bones: self.bones.saturating_sub(rhs.bones),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Component)]
|
|
pub struct Drops {
|
|
pub souls: u32,
|
|
}
|
|
|
|
impl Default for Drops {
|
|
fn default() -> Self {
|
|
Self { souls: 1 }
|
|
}
|
|
}
|
|
|
|
#[derive(Component, Default)]
|
|
#[require(Transform, Name)]
|
|
pub struct ResourceDeposit {
|
|
pub bounty: Quantity,
|
|
pub level: u32,
|
|
pub harvest_time: Duration,
|
|
pub max_workers: u32,
|
|
// todo - add finite resources and refresh timer
|
|
}
|
|
|
|
#[derive(Component, Default)]
|
|
#[require(ResourceDeposit)]
|
|
pub struct WorkedResourceDeposit {
|
|
pub workers: u32,
|
|
pub worked_duration: Duration,
|
|
}
|
|
|
|
#[derive(Event)]
|
|
pub struct Harvested;
|
|
|
|
fn tick_harvest(
|
|
mut commands: Commands,
|
|
mut deposit_query: Query<(Entity, &ResourceDeposit, &mut WorkedResourceDeposit)>,
|
|
time: Res<Time>,
|
|
) {
|
|
let delta = time.delta();
|
|
for (entity, deposit, mut worked) in deposit_query.iter_mut() {
|
|
worked.worked_duration += delta;
|
|
if worked.worked_duration >= deposit.harvest_time {
|
|
commands.trigger_targets(Harvested, entity);
|
|
worked.worked_duration -= deposit.harvest_time;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn on_harvest(
|
|
trigger: Trigger<Harvested>,
|
|
deposit_query: Query<(&ResourceDeposit, &WorkedResourceDeposit)>,
|
|
mut resources: ResMut<Resources>,
|
|
) {
|
|
let Ok((deposit, worked)) = deposit_query.get(trigger.target()) else {
|
|
error!("harvested something that was not a resource deposit or not worked OwO");
|
|
return;
|
|
};
|
|
resources.0 = resources.0 + deposit.bounty * worked.workers;
|
|
}
|
|
|
|
#[derive(Resource)]
|
|
pub struct AvailableWorkers(pub u32);
|