Fix angle

src/inputs.rs

@@ -54,7 +54,7 @@ pub fn handle_keypress(
     }
     let (mut player_opt, mut tank_opt) = (None, None);
     for (player, tank) in query.iter() {
-        if player.is_active {
+        if state.active_player == player.player_number {
             player_opt = Some(player);
             tank_opt = Some(tank);
         }

src/main.rs

@@ -5,11 +5,12 @@ use bevy::{
     prelude::*,
     render::{mesh::PrimitiveTopology, render_asset::RenderAssetUsages},
     sprite::{MaterialMesh2dBundle, Mesh2dHandle},
+    utils::HashMap,
 };
 
 use bevy_iced::{IcedContext, IcedPlugin};
-use bullets::{Bullet, BulletType, NORMAL_BULLET};
-use inputs::{handle_keypress, KeyMap};
+use bullets::{Bullet, BulletCount, BulletType};
+use inputs::handle_keypress;
 use tank::{Tank, TankBundle};
 use ui::{
     battle::{update_battle_ui, view_battle_ui, BattleMessage},
@@ -44,14 +45,7 @@ fn main() {
         .add_event::<EndTurnEvent>()
         .add_event::<ResetEvent>()
         .add_event::<PlayerKillEvent>()
-        .insert_resource::<GameState>(GameState {
-            firing: false,
-            mode: GameMode::StartMenu,
-            player_count_input: "2".into(),
-            player_count: 2,
-            player_count_parse_error: false,
-            wind: random_wind(),
-        })
+        .insert_resource::<GameState>(GameState::default())
         .add_systems(Startup, setup)
         .add_systems(Update, update_ui)
         .add_systems(Update, reset_players)
@@ -72,6 +66,7 @@ struct Wall {}
 #[allow(clippy::too_many_arguments)]
 pub fn update_ui(
     mut messages: EventReader<UiMessage>,
+    time: Res<Time>,
     commands: Commands,
     materials: ResMut<Assets<ColorMaterial>>,
     meshes: ResMut<Assets<Mesh>>,
@@ -89,6 +84,7 @@ pub fn update_ui(
     match state.mode {
         utils::GameMode::Battle => update_battle_ui(
             new_messages,
+            time,
             commands,
             materials,
             meshes,
@@ -97,7 +93,7 @@ pub fn update_ui(
             reset_writer,
             asset_server,
         ),
-        utils::GameMode::Shop => update_shop_ui(new_messages, query, end_turn_writer),
+        utils::GameMode::Shop => update_shop_ui(new_messages, state, query, end_turn_writer),
         utils::GameMode::StartMenu => update_startmenu_ui(new_messages, state, reset_writer),
     }
 }
@@ -109,7 +105,7 @@ pub fn view_ui(
 ) {
     match state.mode {
         utils::GameMode::Battle => view_battle_ui(state, player_query, ctx),
-        utils::GameMode::Shop => view_shop_ui(player_query, ctx),
+        utils::GameMode::Shop => view_shop_ui(state, player_query, ctx),
         utils::GameMode::StartMenu => view_startmenu_ui(state, ctx),
     }
 }
@@ -123,6 +119,7 @@ fn setup(
     let rand: f32 = 0.5;
     let mut vertices = Vec::new();
     let mut i = -1920;
+    // TODO make this use a proper curve
     for _ in -1920..1920 {
         vertices.push([i as f32, 0.0, 0.0]);
         let two = [i as f32, polynomial(i, rand), 0.0];
@@ -171,7 +168,10 @@ fn reset_players(
 ) {
     if reader.read().next().is_some() {
         state.wind = random_wind();
-        for (entity, _) in query.iter() {
+        state.active_player = 0;
+        let mut previous_player_states = Vec::<(u32, HashMap<BulletType, BulletCount>)>::new();
+        for (entity, player) in query.iter() {
+            previous_player_states.push((player.money, player.inventory.clone()));
             commands.entity(entity).despawn_recursive();
         }
         for i in 0..state.player_count {
@@ -204,17 +204,7 @@ fn reset_players(
                     shooting_direction: tank::Angle::default(),
                     shooting_velocity: Vec2::new(1.0, 1.0),
                 },
-                player: Player {
-                    player_number: i,
-                    inventory: BulletType::init_bullets(),
-                    health: 100,
-                    fuel: 100,
-                    money: 0,
-                    key_map: KeyMap::default_keymap(),
-                    selected_bullet: (BulletType::RegularBullet, NORMAL_BULLET),
-                    is_active: i == 0,
-                    fire_velocity: 1.0,
-                },
+                player: Player::from_previous_or_initial(i, previous_player_states.get(i as usize)),
             });
         }
     }
@@ -225,8 +215,8 @@ fn move_bullets(
     state: Res<GameState>,
     mut query: Query<(&mut Bullet, &mut Transform)>,
 ) {
+    let delta = time.delta_seconds();
     for (mut bullet, mut transform) in &mut query {
-        let delta = time.delta_seconds();
         let wind = state.wind;
 
         // s0 + v0 + 0.5 * a * t * t
@@ -240,7 +230,11 @@ fn move_bullets(
         // x
         transform.translation.x =
             transform.translation.x + bullet.velocity_shot.x + 0.5 * wind * delta * delta;
-        bullet.velocity_shot.x = (delta * wind + bullet.velocity_shot.x).clamp(0.0, 1000.0);
+        //if bullet.velocity_shot.x > 0.0 {
+        //    bullet.velocity_shot.x = (/*delta * wind +*/bullet.velocity_shot.x).clamp(0.0, 1000.0);
+        //} else {
+        //    bullet.velocity_shot.x = (/*delta * wind +*/bullet.velocity_shot.x).clamp(-1000.0, 0.0);
+        //}
 
         // TODO do we want air resistance?
         //if bullet.velocity_shot.x > 0.0 {
@@ -343,36 +337,22 @@ fn swap_player(
     mut reset_writer: EventWriter<ResetEvent>,
     mut players: Query<(Entity, &mut Player, &mut Tank, &mut Transform, &mut Sprite)>,
 ) {
-    let mut end_game = false;
     if state.mode == GameMode::Battle && players.iter().len() < 2 {
         ui_writer.send(UiMessage::SetSceneMessage(GameMode::Shop));
         reset_writer.send(ResetEvent {});
-        end_game = true;
+        state.firing = false;
     }
     for _ in reader.read() {
         state.wind = random_wind();
-        let (_, mut player, _, _, _) = if let Some(props) = get_current_player_props(&mut players) {
-            props
-        } else {
-            return;
-        };
+        let (_, player, _, _, _) =
+            if let Some(props) = get_current_player_props(state.active_player, &mut players) {
+                props
+            } else {
+                return;
+            };
         if state.mode == GameMode::Shop && player.player_number == state.player_count - 1 {
             ui_writer.send(UiMessage::SetSceneMessage(GameMode::Battle));
         }
-        player.is_active = false;
-        let is_highest = player.player_number == state.player_count - 1;
-        let previous = player.player_number;
-        for (_, mut player, _, _, _) in &mut players {
-            // The round is over, start at 0 again
-            if end_game {
-                if player.player_number == 0 {
-                    player.is_active = true;
-                }
-            } else if is_highest && player.player_number == 0
-                || player.player_number == previous + 1
-            {
-                player.is_active = true;
-            }
-        }
+        state.increment_player();
     }
 }

src/tank.rs

@@ -1,3 +1,5 @@
+use core::f32;
+
 use bevy::{
     math::Vec2,
     prelude::{Bundle, Component},
@@ -34,6 +36,10 @@ impl Angle {
         self.value
     }
 
+    //pub fn get_degrees(&self) -> f32 {
+    //    self.value * (180.0 / f32::consts::PI)
+    //}
+
     pub fn set(&mut self, value: f32) {
         if Self::check(value) {
             self.value = value;

src/ui/battle.rs

@@ -6,6 +6,7 @@ use bevy::{
     math::Vec2,
     prelude::{Commands, Entity, EventWriter, Mesh, Query, Res, ResMut, Transform},
     sprite::{ColorMaterial, Sprite},
+    time::Time,
 };
 use bevy_iced::{
     iced::{
@@ -52,7 +53,7 @@ pub fn view_battle_ui(
     let shop_button = button(text("shop")).on_press(UiMessage::SetSceneMessage(GameMode::Shop));
     let (mut current_player_opt, mut player_tank_opt) = (None, None);
     for (player, tank) in player_query.iter() {
-        if player.is_active {
+        if state.active_player == player.player_number {
             current_player_opt = Some(player);
             player_tank_opt = Some(tank);
         }
@@ -79,6 +80,7 @@ pub fn view_battle_ui(
 #[allow(clippy::too_many_arguments)]
 pub fn update_battle_ui<'a>(
     messages: impl Iterator<Item = &'a UiMessage>,
+    time: Res<Time>,
     mut commands: Commands,
     mut materials: ResMut<Assets<ColorMaterial>>,
     mut meshes: ResMut<Assets<Mesh>>,
@@ -102,7 +104,7 @@ pub fn update_battle_ui<'a>(
         return;
     }
     let (_, mut player, mut tank, mut transform, _) =
-        if let Some(props) = get_current_player_props(&mut query) {
+        if let Some(props) = get_current_player_props(state.active_player, &mut query) {
             props
         } else {
             // TODO this is not good
@@ -113,20 +115,20 @@ pub fn update_battle_ui<'a>(
             }
             return;
         };
+    let delta = time.delta_seconds();
     for msg in msgs {
         match msg {
             BattleMessage::Reset => {
                 reset_writer.send(ResetEvent {});
             }
             BattleMessage::MoveRight => {
-                player.fuel -= 10;
-                transform.translation.x += 10.0;
+                transform.translation.x += player.drive(10) * delta;
             }
             BattleMessage::MoveLeft => {
-                player.fuel -= 10;
-                transform.translation.x -= 10.0;
+                transform.translation.x -= player.drive(10) * delta;
             }
             BattleMessage::Fire => {
+                state.firing = true;
                 let bullet_type = player.selected_bullet.0;
                 let count_type = *player
                     .inventory
@@ -143,10 +145,11 @@ pub fn update_battle_ui<'a>(
                     }
                 }
                 let angle = &tank.shooting_direction.get();
+                let x_unit_vec = (angle).cos() * -1.0;
                 let info = BulletInfo {
                     velocity: &Vec2 {
-                        x: (180.0 - angle).cos() * player.fire_velocity,
-                        y: (180.0 - angle).sin() * player.fire_velocity,
+                        x: x_unit_vec * player.fire_velocity,
+                        y: (angle).sin() * player.fire_velocity,
                     },
                     origin: &transform.translation,
                     owner: player.player_number,
@@ -158,7 +161,6 @@ pub fn update_battle_ui<'a>(
                     &asset_server,
                     &info,
                 );
-                state.firing = true;
             }
             BattleMessage::SetVelocity(velocity) => {
                 player.fire_velocity = *velocity;
@@ -213,7 +215,7 @@ fn firing(player: &Player, tank: &Tank) -> impl Into<IcedElement> {
     row![
         column![
             text(format!(
-                "Angle: {}",
+                "Angle: {:.0}",
                 current_angle * 180.0 / f32::consts::PI
             )),
             slider(angle_range, current_angle, |val| wrap(
@@ -222,7 +224,7 @@ fn firing(player: &Player, tank: &Tank) -> impl Into<IcedElement> {
             .step(0.01),
         ],
         column![
-            text(format!("Velocity: {}", current_velocity)),
+            text(format!("Velocity: {:.0}", current_velocity)),
             slider(velocity_range, current_velocity, |val| wrap(
                 BattleMessage::SetVelocity(val)
             ))
@@ -236,7 +238,7 @@ fn firing(player: &Player, tank: &Tank) -> impl Into<IcedElement> {
 fn info_box(wind: f32, player: &Player) -> impl Into<IcedElement> {
     // TODO display properly
     column![
-        text(format!("Wind: {}", wind)),
+        text(format!("Wind: {:.2}", wind)),
         text(format!("Player: {}", player.player_number)),
         text(format!("Health: {}", player.health)),
         text(format!("Money: {}", player.money)),

src/ui/shop.rs

@@ -1,5 +1,5 @@
 use bevy::{
-    prelude::{Entity, EventWriter, Query, Transform},
+    prelude::{Entity, EventWriter, Query, Res, ResMut, Transform},
     sprite::Sprite,
 };
 use bevy_iced::{
@@ -14,7 +14,7 @@ use enum_iterator::all;
 use crate::{
     bullets::{BulletCount, BulletType},
     tank::Tank,
-    utils::{EndTurnEvent, Player},
+    utils::{EndTurnEvent, GameState, Player},
     UiMessage,
 };
 
@@ -28,6 +28,7 @@ pub enum ShopMessage {
 
 pub fn update_shop_ui<'a>(
     messages: impl Iterator<Item = &'a UiMessage>,
+    state: ResMut<GameState>,
     mut query: Query<(Entity, &mut Player, &mut Tank, &mut Transform, &mut Sprite)>,
     mut end_turn_writer: EventWriter<EndTurnEvent>,
 ) {
@@ -39,7 +40,7 @@ pub fn update_shop_ui<'a>(
         .collect();
     let mut current_player_opt = None;
     for (_, player, _, _, _) in &mut query {
-        if player.is_active {
+        if state.active_player == player.player_number {
             current_player_opt = Some(player);
         }
     }
@@ -63,11 +64,15 @@ pub fn update_shop_ui<'a>(
     }
 }
 
-pub fn view_shop_ui(player_query: Query<(&Player, &Tank)>, mut ctx: IcedContext<UiMessage>) {
+pub fn view_shop_ui(
+    state: Res<GameState>,
+    player_query: Query<(&Player, &Tank)>,
+    mut ctx: IcedContext<UiMessage>,
+) {
     let wrap = UiMessage::ShopMessage;
     let mut current_player_opt = None;
     for (player, _) in player_query.iter() {
-        if player.is_active {
+        if state.active_player == player.player_number {
             current_player_opt = Some(player);
         }
     }

src/ui/startmenu.rs

@@ -1,6 +1,9 @@
 use bevy::prelude::{EventWriter, Res, ResMut};
 use bevy_iced::{
-    iced::widget::{button, column, container, text, text_input},
+    iced::{
+        alignment::{Horizontal, Vertical},
+        widget::{button, column, container, row, text, text_input},
+    },
     IcedContext,
 };
 
@@ -54,19 +57,27 @@ pub fn update_startmenu_ui<'a>(
 
 pub fn view_startmenu_ui(state: Res<GameState>, mut ctx: IcedContext<UiMessage>) {
     let wrap = UiMessage::StartMenuMessage;
-    let title = text("Tankrs").height(300);
+    let title = text("Tankrs");
     let start_button = button("Start").on_press_maybe(if state.player_count_parse_error {
         None
     } else {
         Some(UiMessage::SetSceneMessage(GameMode::Battle))
     });
     let input = text_input("Player Count", &state.player_count_input)
         .on_input(|count| wrap(StartMenuMessage::ChoosePlayerCount(count)));
+    let content_container =
+        container(column![title, row![input, start_button].spacing(5)].spacing(10))
+            .width(300)
+            .height(600)
+            .align_x(Horizontal::Center)
+            .align_y(Vertical::Center);
     ctx.display(
-        container(column![title, input, start_button])
+        container(content_container)
             .padding(10)
             .width(5000)
             .height(5000)
+            .align_x(Horizontal::Center)
+            .align_y(Vertical::Center)
             .style(get_custom_container_style()),
     )
 }