Some minor fixes

Author: Leinnan

Cargo.lock

@@ -1,3 +1,5 @@
+_list:
+    just --list
 
 # build web version and put it out directory
 web_build:
@@ -16,10 +18,10 @@ check:
 # self host web version
 web_host:
 	lwa_simple_server out
-	
+
 gen_cards:
 	cargo run -p utils_svg_cards_gen
-	
+
 # installs used cli tools
 prepare:
 	cargo install lwa_simple_server

justfile

@@ -191,8 +191,8 @@ fn update_card_color(
     for (mut sprite, action, can_throw) in q.iter_mut() {
         sprite.color = match (action, can_throw.is_some()) {
             (ActionToPerform::Use, true) => tailwind::AMBER_300.into(),
-            (ActionToPerform::Discard, _) => Color::linear_rgb(1.0, 0.6, 0.6),
-            (_, false) => Color::WHITE.darker(0.4),
+            (ActionToPerform::Discard, _) => Color::linear_rgba(1.0, 0.6, 0.6, 0.7),
+            (_, false) => Color::WHITE.darker(0.7),
             (_, _) => Color::WHITE,
         };
     }

src/components/card_display.rs

@@ -50,6 +50,10 @@ pub struct UiValueAnimator {
     pub negative: AnimationNodeIndex,
 }
 
+#[derive(Reflect, Resource, Deref)]
+#[reflect(Resource)]
+pub struct PlayerUiAnimationInfo(pub AnimationInfo);
+
 #[derive(Component, Default, Reflect, Serialize, Deserialize, Debug)]
 #[require(Text, UiValueAnimator)]
 pub struct PlayerUiValue(pub i32);
@@ -121,47 +125,46 @@ impl Plugin for PlayerUiPlugin {
             Update,
             (update_created_player_ui, update_player_ui).run_if(in_state(GameState::Game)),
         )
+        .register_type::<PlayerUiAnimationInfo>()
+        .add_systems(PostStartup, create_player_anim)
         .add_systems(
             OnEnter(GameState::Game),
             (setup_player_ui).after(game::init_players),
         );
     }
 }
 
+fn create_player_anim(
+    mut animation_graphs: ResMut<Assets<AnimationGraph>>,
+    mut animation_clips: ResMut<Assets<AnimationClip>>,
+    mut commands: Commands,
+) {
+    let anim = AnimationInfo::create(&mut animation_graphs, &mut animation_clips, "UiTarget");
+    commands.insert_resource(PlayerUiAnimationInfo(anim));
+}
+
 #[derive(Component, Reflect, Serialize, Deserialize, Deref, Default, Debug)]
 #[require(AnimationPlayer)]
 pub struct PlayerUi(pub PlayerNumber);
 
 fn update_created_player_ui(
     mut ui_query: Query<TextUiPlayerElements, Added<PlayerTextInterface>>,
     player_query: Players,
-    mut animation_graphs: ResMut<Assets<AnimationGraph>>,
-    mut animation_clips: ResMut<Assets<AnimationClip>>,
+    anim_info: Res<PlayerUiAnimationInfo>,
     mut commands: Commands,
 ) {
     for mut el in ui_query.iter_mut() {
         if let Some(player) = player_query.get_player(el.target.0) {
-            let AnimationInfo {
-                target_name: animation_target_name,
-                target_id: animation_target_id,
-                graph: animation_graph,
-                pos_node_index,
-                neg_node_index,
-            } = AnimationInfo::create(
-                &mut animation_graphs,
-                &mut animation_clips,
-                format!("Ui{:?}", el.element),
-            );
             el.update(&player);
-            el.anim_config.positive = pos_node_index;
-            el.anim_config.negative = neg_node_index;
+            el.anim_config.positive = anim_info.pos_node_index;
+            el.anim_config.negative = anim_info.neg_node_index;
             commands.entity(el.entity).insert((
-                AnimationGraphHandle(animation_graph),
+                AnimationGraphHandle(anim_info.graph.clone()),
                 AnimationTarget {
-                    id: animation_target_id,
+                    id: anim_info.target_id,
                     player: el.entity,
                 },
-                animation_target_name,
+                anim_info.target_name.clone(),
             ));
         }
     }
@@ -220,11 +223,20 @@ fn setup_player_ui(mut commands: Commands, asset_server: Res<AssetServer>, playe
     ] {
         let player_info = player_query.get_player(player).expect("ERROR");
         let avatar_path = player_info.details.avatar_path();
+        let order = if player == PlayerNumber::First {
+            FlexDirection::Row
+        } else {
+            FlexDirection::RowReverse
+        };
         commands
             .spawn((style.clone(), GameObject))
             .insert(Name::new(format!("Ui{:?}", player)))
             .with_children(|p| {
-                p.spawn((
+                p.spawn(Node {
+                    flex_direction: order,
+                    ..default()
+                })
+                .with_child((
                     ImageNode {
                         image: asset_server.load(avatar_path),
                         ..default()
@@ -236,33 +248,24 @@ fn setup_player_ui(mut commands: Commands, asset_server: Res<AssetServer>, playe
                         ..default()
                     },
                 ))
-                .with_children(|p| {
-                    p.spawn((
-                        ImageNode {
-                            image: asset_server.load("img/player_frame_name.png"),
-                            flip_x: right_align,
-                            ..default()
-                        },
-                        Node {
-                            padding: UiRect::all(Val::Px(8.0)),
-                            position_type: PositionType::Absolute,
-                            bottom: Val::Px(0.0),
-                            ..default()
-                        },
-                    ))
-                    .with_children(|name| {
-                        name.spawn((
-                            Text::new(player_info.details.name.clone()),
-                            header_style.clone(),
-                            TextLayout::new_with_justify(if right_align {
-                                JustifyText::Right
-                            } else {
-                                JustifyText::Left
-                            }),
-                        ))
-                        .insert(PlayerUi(player));
-                    });
-                });
+                .with_child((
+                    ImageNode {
+                        image: asset_server.load("img/player_frame_name.png"),
+                        flip_x: right_align,
+                        ..default()
+                    },
+                    Node {
+                        padding: UiRect::axes(Val::Px(12.0), Val::Px(0.0)),
+                        height: Val::Px(64.0),
+                        align_items: AlignItems::Center,
+                        ..default()
+                    },
+                    children![(
+                        Text::new(player_info.details.name.clone()),
+                        header_style.clone(),
+                        PlayerUi(player)
+                    )],
+                ));
                 p.spawn((
                     ImageNode::new(asset_server.load("img/player_frame_resources.png")),
                     Node {
@@ -303,9 +306,9 @@ fn setup_player_ui(mut commands: Commands, asset_server: Res<AssetServer>, playe
                             margin: UiRect::bottom(Val::Px(5.0)),
                             ..default()
                         },
+                        children![ImageNode::new(asset_server.load("img/resource_frame.png"))],
                     ))
                     .with_children(|p| {
-                        p.spawn(ImageNode::new(asset_server.load("img/resource_frame.png")));
                         p.spawn(Node {
                             position_type: PositionType::Absolute,
                             top: Val::Px(0.0),

src/components/player_ui.rs

@@ -40,7 +40,7 @@ impl CardInfo<'_> {
 }
 
 impl HandQueryReadItem<'_> {
-    pub fn card_info_array(&self) -> Vec<CardInfo> {
+    pub fn card_info_array(&'_ self) -> Vec<CardInfo<'_>> {
         self.cards
             .iter()
             .enumerate()

src/data/deck.rs

@@ -195,7 +195,7 @@ impl Plugin for GamePlugin {
 fn end_game(query: Query<&PlayerHealth, With<HumanPlayer>>, mut commands: Commands) -> Result {
     let player = query.single()?;
     let player_won = player.has_max_possible_tower() || player.is_alive();
-    info!("PLAYER WON? {}", player_won);
+    // info!("PLAYER WON? {}", player_won);
     let sound = if player_won {
         "snd/game_won.ogg"
     } else {
@@ -358,7 +358,7 @@ fn esc_to_menu(
     mut query: Query<&mut Node, With<HelpDisplay>>,
 ) {
     if keys.just_released(KeyCode::Escape) {
-        next_state.set(GameState::AssetsLoading);
+        next_state.set(GameState::Menu);
         // keys.reset(KeyCode::Escape);
     } else if keys.just_released(KeyCode::KeyH) {
         for mut style in &mut query {
@@ -376,10 +376,10 @@ fn handle_card_events(
     any_action: Query<&ActionTaken>,
     mut next_state: ResMut<NextState<GameTurnSteps>>,
 ) {
-    let Ok(action_to_do) = any_action.single() else {
+    let Ok(_action_to_do) = any_action.single() else {
         return;
     };
-    info!("{:#?}", action_to_do);
+    // info!("{:#?}", action_to_do);
     next_state.set(GameTurnSteps::PerformAction);
 }
 

src/states/game.rs

@@ -116,7 +116,7 @@ fn setup_menu(mut commands: Commands, asset_server: Res<AssetServer>) {
                 font_size: 30.0,
                 ..default()
             };
-            let clr = TextColor(Color::linear_rgb(0.7, 0.7, 0.7));
+            let clr = TextColor(Color::linear_rgb(0.65, 0.6, 0.6));
             let mut start_time_ms = 500;
 
             for (text, margin, observer) in [
@@ -180,7 +180,7 @@ fn setup_menu(mut commands: Commands, asset_server: Res<AssetServer>) {
                         },
                         Node {
                             margin,
-                            padding: UiRect::all(Val::Px(15.0)),
+                            padding: UiRect::axes(Val::Px(25.0), Val::Px(20.0)),
                             align_items: AlignItems::Center,
                             justify_content: JustifyContent::Center,
                             ..default()

src/states/menu.rs

@@ -128,6 +128,15 @@ fn setup_ui(mut commands: Commands, asset_server: Res<AssetServer>, pkv: Res<Pkv
             ));
             // .insert(Class::new("menu_background"));
 
+            let init_scale = Vec3::splat(0.01);
+            let tween_scale = Tween::new(
+                EaseFunction::QuadraticInOut,
+                Duration::from_millis(500),
+                TransformScaleLens {
+                    start: init_scale,
+                    end: Vec3::ONE,
+                },
+            );
             parent
                 .spawn((
                     ImageNode {
@@ -141,29 +150,28 @@ fn setup_ui(mut commands: Commands, asset_server: Res<AssetServer>, pkv: Res<Pkv
                         color: Color::srgb_u8(110, 116, 77),
                         ..default()
                     },
+                    Animator::new(tween_scale),
                     Node {
-                        padding: UiRect::all(Val::Px(20.0)),
+                        padding: UiRect::axes(Val::Px(30.0), Val::Px(40.0)),
                         flex_direction: FlexDirection::Column,
+                        align_items: AlignItems::Center,
                         row_gap: Val::Px(10.0),
                         ..default()
                     },
                     Name::new("profile_edit"),
                     // Class::new("popup_window"),
                 ))
                 .with_children(|parent| {
-                    parent
-                        .spawn(Node::default())
-                        .with_child(Text::new("Edit profile"));
-
-                    let init_scale = Vec3::splat(0.01);
-                    let tween_scale = Tween::new(
-                        EaseFunction::QuadraticInOut,
-                        Duration::from_millis(500),
-                        TransformScaleLens {
-                            start: init_scale,
-                            end: Vec3::ONE,
+                    parent.spawn(Node::default()).with_child((
+                        Text::new("Edit profile"),
+                        TextFont {
+                            font: asset_server.load(consts::LABEL_FONT),
+                            font_size: 45.0,
+                            ..default()
                         },
-                    );
+                        TextColor(Color::linear_rgb(0.8, 0.7, 0.7)),
+                    ));
+
                     parent.spawn((
                         BorderColor(Srgba::hex("fcfd9e").unwrap().into()),
                         BackgroundColor(Srgba::hex("2c422e").unwrap().into()),
@@ -198,7 +206,6 @@ fn setup_ui(mut commands: Commands, asset_server: Res<AssetServer>, pkv: Res<Pkv
                         .spawn((
                             ImageNode::new(asset_server.load(avatar_path)),
                             Name::new("avatar"),
-                            Animator::new(tween_scale),
                             AvatarDisplay { id: avatar_id },
                             Node {
                                 width: Val::Px(100.0),

src/states/profile_selection.rs

@@ -46,9 +46,9 @@ impl AnimationInfo {
                 AnimatableCurve::new(
                     animated_field!(Transform::scale),
                     AnimatableKeyframeCurve::new(
-                        [0.0, 0.2, 0.6, 0.8]
+                        [0.0, 0.2, 0.6, 0.7, 0.8]
                             .into_iter()
-                            .zip([Vec3::splat(1.0),Vec3::splat(0.3),Vec3::splat(0.3), Vec3::splat(1.0)]),
+                            .zip([Vec3::splat(1.0),Vec3::splat(0.3),Vec3::splat(0.3),Vec3::splat(1.3),Vec3::splat(1.0)]),
                     )
                         .expect(
                             "should be able to build translation curve because we pass in valid samples",
@@ -100,12 +100,12 @@ pub struct TextColorProperty;
 impl AnimatableProperty for TextColorProperty {
     type Property = Srgba;
 
-    fn evaluator_id(&self) -> EvaluatorId {
-        EvaluatorId::Type(TypeId::of::<Self>())
+    fn evaluator_id(&'_ self) -> EvaluatorId<'_> {
+        EvaluatorId::Type(TypeId::of::<TextColorProperty>())
     }
 
     fn get_mut<'a>(
-        &self,
+        &'_ self,
         entity: &'a mut AnimationEntityMut,
     ) -> Result<&'a mut Self::Property, AnimationEvaluationError> {
         let text_color = entity