330 lines
9.2 KiB
Rust
330 lines
9.2 KiB
Rust
use super::{BackbackSwapEvent, Backpack, BackpackHead};
|
|
use crate::heads_ui::HeadsImages;
|
|
use bevy::prelude::*;
|
|
|
|
static HEAD_SLOTS: usize = 5;
|
|
|
|
#[derive(Event, Clone, Copy, Reflect, PartialEq)]
|
|
pub enum BackpackAction {
|
|
Left,
|
|
Right,
|
|
Swap,
|
|
OpenClose,
|
|
}
|
|
|
|
#[derive(Component, Default)]
|
|
struct BackpackMarker;
|
|
|
|
#[derive(Component, Default)]
|
|
struct BackpackCountText;
|
|
|
|
#[derive(Component, Default)]
|
|
struct HeadSelector(pub usize);
|
|
|
|
#[derive(Component, Default)]
|
|
struct HeadImage(pub usize);
|
|
|
|
#[derive(Component, Default)]
|
|
struct HeadDamage(pub usize);
|
|
|
|
#[derive(Resource, Default, Debug)]
|
|
struct BackpackUiState {
|
|
heads: [Option<BackpackHead>; 5],
|
|
scroll: usize,
|
|
count: usize,
|
|
current_slot: usize,
|
|
open: bool,
|
|
}
|
|
|
|
impl BackpackUiState {
|
|
fn relative_current_slot(&self) -> usize {
|
|
self.current_slot.saturating_sub(self.scroll)
|
|
}
|
|
}
|
|
|
|
pub fn plugin(app: &mut App) {
|
|
app.init_resource::<BackpackUiState>();
|
|
app.add_systems(Startup, setup);
|
|
app.add_systems(
|
|
Update,
|
|
(update, sync_on_change, update_visibility, update_count),
|
|
);
|
|
app.add_observer(swap_head_inputs);
|
|
}
|
|
|
|
fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
|
|
let bg = asset_server.load("ui/head_bg.png");
|
|
let regular = asset_server.load("ui/head_regular.png");
|
|
let damage = asset_server.load("ui/head_damage.png");
|
|
let selector = asset_server.load("ui/selector.png");
|
|
|
|
commands
|
|
.spawn((
|
|
Name::new("backpack"),
|
|
BackpackMarker,
|
|
Visibility::Hidden,
|
|
Node {
|
|
position_type: PositionType::Absolute,
|
|
top: Val::Px(20.0),
|
|
right: Val::Px(20.0),
|
|
height: Val::Px(74.0),
|
|
..default()
|
|
},
|
|
))
|
|
.with_children(|parent| {
|
|
for i in 0..HEAD_SLOTS {
|
|
spawn_head_ui(
|
|
parent,
|
|
bg.clone(),
|
|
regular.clone(),
|
|
selector.clone(),
|
|
damage.clone(),
|
|
i,
|
|
);
|
|
}
|
|
});
|
|
|
|
commands.spawn((
|
|
Text::new("0"),
|
|
BackpackCountText,
|
|
TextFont {
|
|
font: asset_server.load("font.ttf"),
|
|
font_size: 34.0,
|
|
..default()
|
|
},
|
|
TextColor(Color::Srgba(Srgba::rgb(0., 1., 0.))),
|
|
TextLayout::new_with_justify(JustifyText::Center),
|
|
Node {
|
|
position_type: PositionType::Absolute,
|
|
top: Val::Px(20.0),
|
|
right: Val::Px(20.0),
|
|
..default()
|
|
},
|
|
));
|
|
}
|
|
|
|
fn spawn_head_ui(
|
|
parent: &mut ChildBuilder,
|
|
bg: Handle<Image>,
|
|
regular: Handle<Image>,
|
|
selector: Handle<Image>,
|
|
damage: Handle<Image>,
|
|
head_slot: usize,
|
|
) {
|
|
const SIZE: f32 = 90.0;
|
|
const DAMAGE_SIZE: f32 = 74.0;
|
|
|
|
parent
|
|
.spawn((Node {
|
|
position_type: PositionType::Relative,
|
|
justify_content: JustifyContent::Center,
|
|
align_items: AlignItems::Center,
|
|
width: Val::Px(SIZE),
|
|
..default()
|
|
},))
|
|
.with_children(|parent| {
|
|
parent.spawn((
|
|
Name::new("selector"),
|
|
Node {
|
|
position_type: PositionType::Absolute,
|
|
bottom: Val::Px(-30.0),
|
|
..default()
|
|
},
|
|
Visibility::Hidden,
|
|
ImageNode::new(selector).with_flip_y(),
|
|
HeadSelector(head_slot),
|
|
));
|
|
parent.spawn((
|
|
Name::new("bg"),
|
|
Node {
|
|
position_type: PositionType::Absolute,
|
|
..default()
|
|
},
|
|
ImageNode::new(bg),
|
|
));
|
|
parent.spawn((
|
|
Name::new("head"),
|
|
Node {
|
|
position_type: PositionType::Absolute,
|
|
..default()
|
|
},
|
|
ImageNode::default(),
|
|
Visibility::Hidden,
|
|
HeadImage(head_slot),
|
|
));
|
|
parent.spawn((
|
|
Name::new("rings"),
|
|
Node {
|
|
position_type: PositionType::Absolute,
|
|
..default()
|
|
},
|
|
ImageNode::new(regular),
|
|
));
|
|
parent
|
|
.spawn((
|
|
Name::new("health"),
|
|
Node {
|
|
height: Val::Px(DAMAGE_SIZE),
|
|
width: Val::Px(DAMAGE_SIZE),
|
|
..default()
|
|
},
|
|
))
|
|
.with_children(|parent| {
|
|
parent
|
|
.spawn((
|
|
Name::new("damage_ring"),
|
|
HeadDamage(head_slot),
|
|
Node {
|
|
position_type: PositionType::Absolute,
|
|
display: Display::Block,
|
|
overflow: Overflow::clip(),
|
|
top: Val::Px(0.),
|
|
left: Val::Px(0.),
|
|
right: Val::Px(0.),
|
|
height: Val::Percent(25.),
|
|
..default()
|
|
},
|
|
))
|
|
.with_child(ImageNode::new(damage));
|
|
});
|
|
});
|
|
}
|
|
|
|
fn update_visibility(
|
|
state: Res<BackpackUiState>,
|
|
mut backpack: Query<&mut Visibility, (With<BackpackMarker>, Without<BackpackCountText>)>,
|
|
mut count: Query<&mut Visibility, (Without<BackpackMarker>, With<BackpackCountText>)>,
|
|
) {
|
|
if state.is_changed() {
|
|
for mut vis in backpack.iter_mut() {
|
|
*vis = if state.open {
|
|
Visibility::Visible
|
|
} else {
|
|
Visibility::Hidden
|
|
};
|
|
}
|
|
|
|
for mut vis in count.iter_mut() {
|
|
*vis = if !state.open {
|
|
Visibility::Visible
|
|
} else {
|
|
Visibility::Hidden
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
fn update_count(
|
|
state: Res<BackpackUiState>,
|
|
text: Query<Entity, With<BackpackCountText>>,
|
|
mut writer: TextUiWriter,
|
|
) {
|
|
if state.is_changed() {
|
|
let Some(text) = text.iter().next() else {
|
|
return;
|
|
};
|
|
|
|
*writer.text(text, 0) = state.count.to_string();
|
|
}
|
|
}
|
|
|
|
fn update(
|
|
state: Res<BackpackUiState>,
|
|
heads_images: Res<HeadsImages>,
|
|
mut head_image: Query<(&HeadImage, &mut Visibility, &mut ImageNode), Without<HeadSelector>>,
|
|
mut head_damage: Query<(&HeadDamage, &mut Node), Without<HeadSelector>>,
|
|
mut head_selector: Query<(&HeadSelector, &mut Visibility), Without<HeadImage>>,
|
|
) {
|
|
if state.is_changed() {
|
|
for (HeadImage(head), mut vis, mut image) in head_image.iter_mut() {
|
|
if let Some(head) = &state.heads[*head] {
|
|
*vis = Visibility::Inherited;
|
|
image.image = heads_images.heads[head.head].clone();
|
|
} else {
|
|
*vis = Visibility::Hidden;
|
|
}
|
|
}
|
|
for (HeadDamage(head), mut node) in head_damage.iter_mut() {
|
|
if let Some(head) = &state.heads[*head] {
|
|
node.height = Val::Percent(head.damage() * 100.0);
|
|
}
|
|
}
|
|
|
|
for (HeadSelector(head), mut vis) in head_selector.iter_mut() {
|
|
*vis = if *head == state.relative_current_slot() {
|
|
Visibility::Inherited
|
|
} else {
|
|
Visibility::Hidden
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
fn swap_head_inputs(
|
|
trigger: Trigger<BackpackAction>,
|
|
backpack: Res<Backpack>,
|
|
mut commands: Commands,
|
|
mut state: ResMut<BackpackUiState>,
|
|
) {
|
|
if state.count == 0 {
|
|
return;
|
|
}
|
|
|
|
let action = *trigger.event();
|
|
if action == BackpackAction::OpenClose {
|
|
state.open = !state.open;
|
|
}
|
|
|
|
if !state.open {
|
|
return;
|
|
}
|
|
|
|
let mut changed = false;
|
|
if action == BackpackAction::Left {
|
|
if state.current_slot > 0 {
|
|
state.current_slot -= 1;
|
|
changed = true;
|
|
}
|
|
}
|
|
if action == BackpackAction::Right {
|
|
if state.current_slot < state.count.saturating_sub(1) {
|
|
state.current_slot += 1;
|
|
changed = true;
|
|
}
|
|
}
|
|
if action == BackpackAction::Swap {
|
|
commands.trigger(BackbackSwapEvent(state.current_slot));
|
|
}
|
|
|
|
if changed {
|
|
sync(&backpack, &mut state);
|
|
}
|
|
}
|
|
|
|
fn sync_on_change(backpack: Res<Backpack>, mut state: ResMut<BackpackUiState>) {
|
|
if backpack.is_changed() {
|
|
sync(&backpack, &mut state);
|
|
}
|
|
}
|
|
|
|
fn sync(backpack: &Res<Backpack>, state: &mut ResMut<BackpackUiState>) {
|
|
state.count = backpack.heads.len();
|
|
|
|
state.scroll = state.scroll.min(state.count.saturating_sub(HEAD_SLOTS));
|
|
|
|
if state.current_slot >= state.scroll + HEAD_SLOTS {
|
|
state.scroll = state.current_slot.saturating_sub(HEAD_SLOTS - 1);
|
|
}
|
|
if state.current_slot < state.scroll {
|
|
state.scroll = state.current_slot;
|
|
}
|
|
|
|
for i in 0..HEAD_SLOTS {
|
|
if let Some(head) = backpack.heads.get(i + state.scroll) {
|
|
state.heads[i] = Some(*head);
|
|
} else {
|
|
state.heads[i] = None;
|
|
}
|
|
}
|
|
}
|