4 files changed, 75 insertions(+), 95 deletions(-)

M server/src/main.rs
A server/src/mathutil.rs
M starkingdoms-client/src/hub.ts
M starkingdoms-client/src/rendering.ts

@@ 1,8 1,9 @@
 use std::net::Ipv4Addr;
 
+use crate::mathutil::{rot2d, v3_to_v2};
+use bevy::math::{vec2, vec3};
 use bevy::utils::tracing;
 use bevy::{ecs::event::ManualEventReader, prelude::*};
-use bevy::math::{vec2, vec3};
 use bevy_rapier2d::prelude::*;
 use bevy_twite::{twite::frame::MessageType, ServerEvent, TwiteServerConfig, TwiteServerPlugin};
 use component::*;


@@ 11,6 12,7 @@ use rand::Rng;
 
 pub mod component;
 pub mod macros;
+pub mod mathutil;
 pub mod packet;
 
 const SCALE: f32 = 10.0;


@@ 34,7 36,7 @@ fn main() {
         })
         .add_plugins(MinimalPlugins)
         .insert_resource(RapierConfiguration {
-            gravity: Vect { x: 0., y: 0. },
+            gravity: Vect { x: 0.0, y: 0.0 },
             ..Default::default()
         })
         .add_plugins(RapierPhysicsPlugin::<NoUserData>::pixels_per_meter(SCALE))


@@ 46,14 48,14 @@ fn main() {
         .add_systems(FixedUpdate, on_position_change)
         .add_systems(FixedUpdate, gravity_update)
         .add_systems(FixedUpdate, player_input_update)
-        //.insert_resource(Time::<Fixed>::from_seconds(1./20.))
+        //.insert_resource(Time::<Fixed>::from_seconds(1.0/20.0))
         .run();
 
     info!("Goodbye!");
 }
 
 fn setup_integration_parameters(mut context: ResMut<RapierContext>) {
-    context.integration_parameters.dt = 1./20.;
+    context.integration_parameters.dt = 1.0 / 20.0;
     context.integration_parameters.joint_erp = 0.2;
     context.integration_parameters.erp = 0.5;
     context.integration_parameters.max_stabilization_iterations = 16;


@@ 93,8 95,8 @@ fn on_message(
                         rng.gen::<f32>() * std::f32::consts::PI * 2.
                     };
                     let mut transform = Transform::from_xyz(
-                        angle.cos() * 1100. / SCALE,
-                        angle.sin() * 1100. / SCALE,
+                        angle.cos() * 1100.0 / SCALE,
+                        angle.sin() * 1100.0 / SCALE,
                         0.0,
                     );
                     transform.rotate_z(angle);


@@ 110,15 112,18 @@ fn on_message(
                                 input: component::Input::default(),
                             },
                         })
-                        .insert(Collider::cuboid(PART_HALF_SIZE / SCALE, PART_HALF_SIZE / SCALE))
+                        .insert(Collider::cuboid(
+                            PART_HALF_SIZE / SCALE,
+                            PART_HALF_SIZE / SCALE,
+                        ))
                         .insert(AdditionalMassProperties::MassProperties(MassProperties {
-                            local_center_of_mass: vec2(0., 0.),
+                            local_center_of_mass: vec2(0.0, 0.0),
                             mass: 0.0001,
                             principal_inertia: 0.005,
                         }))
                         .insert(ExternalImpulse {
                             impulse: Vec2::ZERO,
-                            torque_impulse: 0.,
+                            torque_impulse: 0.0,
                         })
                         .insert(ExternalForce::default())
                         .insert(ReadMassProperties::default())


@@ 363,21 368,23 @@ fn player_input_update(
     mut player_and_body_query: Query<(Entity, &mut Player, &mut ExternalForce, &Transform)>,
 ) {
     for (_, player, mut forces, transform) in &mut player_and_body_query {
-        forces.torque = 0.;
+        forces.torque = 0.0;
         forces.force = Vec2::ZERO;
-        if !(player.input.up || player.input.down || player.input.right || player.input.left) { continue; }
+        if !(player.input.up || player.input.down || player.input.right || player.input.left) {
+            continue;
+        }
 
         let mut fmul_bottom_left_thruster: f32 = 0.0;
         let mut fmul_bottom_right_thruster: f32 = 0.0;
         let mut fmul_top_left_thruster: f32 = 0.0;
         let mut fmul_top_right_thruster: f32 = 0.0;
         if player.input.up {
-            fmul_bottom_left_thruster -= 1.0;
-            fmul_bottom_right_thruster -= 1.0;
+            fmul_bottom_left_thruster += 1.0;
+            fmul_bottom_right_thruster += 1.0;
         }
         if player.input.down {
-            fmul_top_left_thruster += 1.0;
-            fmul_top_right_thruster += 1.0;
+            fmul_top_left_thruster -= 1.0;
+            fmul_top_right_thruster -= 1.0;
         }
         if player.input.left {
             fmul_top_left_thruster += 1.0;


@@ 388,65 395,46 @@ fn player_input_update(
             fmul_bottom_left_thruster -= 1.0;
         }
         fmul_top_left_thruster = fmul_top_left_thruster.clamp(-1.0, 1.0);
-        fmul_top_right_thruster = fmul_top_right_thruster.clamp(-1., 1.);
-        fmul_bottom_left_thruster = fmul_bottom_left_thruster.clamp(-1., 1.);
-        fmul_bottom_right_thruster = fmul_bottom_right_thruster.clamp(-1., 1.);
-
-        let rot = transform.rotation.to_euler(EulerRot::ZYX).0;
-
-        if fmul_bottom_left_thruster != 0. {
-            // we are applying a force to the bottom left thruster, so do the math to figure out where it is
-            let bl_thruster_uncast = vec3(-PART_HALF_SIZE/SCALE, -PART_HALF_SIZE/SCALE, 0.0);
-            // so it turns out nalgeba is useless. because bevy. bevy makes everything difficult for physics
-            let bl_thruster_cast = vec2(bl_thruster_uncast.x * rot.cos() - bl_thruster_uncast.y * rot.sin(),
-                                        bl_thruster_uncast.x * rot.sin() + bl_thruster_uncast.y * rot.cos());
-            let bl_thruster_cast = bl_thruster_cast + transform.translation.xy();
-
-            let bl_thruster_force = fmul_bottom_left_thruster * THRUSTER_FORCE;
-            
-            let bl_thruster_vec = vec2(-bl_thruster_force / SCALE * rot.sin(), bl_thruster_force  / SCALE * rot.cos());
-            let bl_force = ExternalForce::at_point(bl_thruster_vec, bl_thruster_cast, transform.translation.xy());
-            forces.force += bl_force.force;
-            forces.torque += bl_force.torque;
+        fmul_top_right_thruster = fmul_top_right_thruster.clamp(-1.0, 1.0);
+        fmul_bottom_left_thruster = fmul_bottom_left_thruster.clamp(-1.0, 1.0);
+        fmul_bottom_right_thruster = fmul_bottom_right_thruster.clamp(-1.0, 1.0);
+        if player.input.up {
+            fmul_bottom_left_thruster -= 100.0;
+            fmul_bottom_right_thruster -= 100.0;
         }
-        if fmul_bottom_right_thruster != 0. {
-            let br_thruster_uncast = vec3(PART_HALF_SIZE/SCALE, -PART_HALF_SIZE/SCALE, 0.0);
-            let br_thruster_cast = vec2(br_thruster_uncast.x * rot.cos() - br_thruster_uncast.y * rot.sin(),
-                                        br_thruster_uncast.x * rot.sin() + br_thruster_uncast.y * rot.cos());
-            let br_thruster_cast = br_thruster_cast + transform.translation.xy();
-
-            let br_thruster_force = fmul_bottom_right_thruster * THRUSTER_FORCE;
-
-            let br_thruster_vec = vec2(-br_thruster_force / SCALE * rot.sin(), br_thruster_force / SCALE * rot.cos());
-            let br_force = ExternalForce::at_point(br_thruster_vec, br_thruster_cast, transform.translation.xy());
-            forces.force += br_force.force;
-            forces.torque += br_force.torque;
+        if player.input.down {
+            fmul_top_left_thruster += 100.0;
+            fmul_top_right_thruster += 100.0;
         }
-        if fmul_top_left_thruster != 0. {
-            let tl_thruster_uncast = vec3(-PART_HALF_SIZE/SCALE, PART_HALF_SIZE/SCALE, 0.0);
-            let tl_thruster_cast = vec2(tl_thruster_uncast.x * rot.cos() - tl_thruster_uncast.y * rot.sin(),
-                                        tl_thruster_uncast.x * rot.sin() + tl_thruster_uncast.y * rot.cos());
-            let tl_thruster_cast = tl_thruster_cast + transform.translation.xy();
-            let tl_thruster_force = fmul_top_left_thruster * THRUSTER_FORCE;
 
-            let tl_thruster_vec = vec2(-tl_thruster_force / SCALE * rot.sin(), tl_thruster_force / SCALE * rot.cos());
-            let tl_force = ExternalForce::at_point(tl_thruster_vec, tl_thruster_cast, transform.translation.xy());
-            forces.force += tl_force.force;
-            forces.torque += tl_force.torque;
-        }
-        if fmul_top_right_thruster != 0. {
-            let tr_thruster_uncast = vec3(PART_HALF_SIZE/SCALE, PART_HALF_SIZE/SCALE, 0.0);
-            let tr_thruster_cast = vec2(tr_thruster_uncast.x * rot.cos() - tr_thruster_uncast.y * rot.sin(),
-                                        tr_thruster_uncast.x * rot.sin() + tr_thruster_uncast.y * rot.cos());
-            let tr_thruster_cast = tr_thruster_cast + transform.translation.xy();
-            let tr_thruster_force = fmul_top_right_thruster * THRUSTER_FORCE;
+        let rot = transform.rotation.to_euler(EulerRot::ZYX).0;
 
-            let tr_thruster_vec = vec2(-tr_thruster_force / SCALE * rot.sin(), tr_thruster_force / SCALE * rot.cos());
-            let tr_force = ExternalForce::at_point(tr_thruster_vec, tr_thruster_cast, transform.translation.xy());
-            forces.force += tr_force.force;
-            forces.torque += tr_force.torque;
+        let thrusters = [
+            (fmul_bottom_left_thruster, -PART_HALF_SIZE, -PART_HALF_SIZE),
+            (fmul_bottom_right_thruster, PART_HALF_SIZE, -PART_HALF_SIZE),
+            (fmul_top_left_thruster, -PART_HALF_SIZE, PART_HALF_SIZE),
+            (fmul_top_right_thruster, PART_HALF_SIZE, PART_HALF_SIZE),
+        ];
+
+        for (force_multiplier, x_offset, y_offset) in thrusters {
+            if force_multiplier != 0.0 {
+                let thruster_pos_uncast = vec2(x_offset / SCALE, y_offset / SCALE);
+                let thruster_pos_cast =
+                    rot2d(thruster_pos_uncast, rot) + transform.translation.xy();
+                let thruster_force = force_multiplier * THRUSTER_FORCE;
+                let thruster_vec = vec2(
+                    -thruster_force / SCALE * rot.sin(),
+                    thruster_force / SCALE * rot.cos(),
+                );
+                let thruster_force = ExternalForce::at_point(
+                    thruster_vec,
+                    thruster_pos_cast,
+                    transform.translation.xy(),
+                );
+                forces.force += thruster_force.force;
+                forces.torque += thruster_force.torque;
+            }
         }
-
     }
 }
 

@@ 0,0 1,12 @@
+use bevy::math::{vec2, Vec2, Vec3};
+
+pub fn rot2d(uncast: Vec2, angle: f32) -> Vec2 {
+    vec2(
+        uncast.x * angle.cos() - uncast.y * angle.sin(),
+        uncast.x * angle.sin() + uncast.y * angle.cos(),
+    )
+}
+
+pub fn v3_to_v2(downgrade: Vec3) -> Vec2 {
+    vec2(downgrade.x, downgrade.y)
+}

@@ 196,10 196,12 @@ export async function hub_connect(
           }*/
           global.parts_map.set(id, new_part);
           if (id === global.me?.part_id) {
-            document.getElementById("pos-val-x")!.innerText =
-              Math.round(new_part.transform.x).toString();
-            document.getElementById("pos-val-y")!.innerText =
-              Math.round(new_part.transform.y).toString();
+            document.getElementById("pos-val-x")!.innerText = Math.round(
+              new_part.transform.x,
+            ).toString();
+            document.getElementById("pos-val-y")!.innerText = Math.round(
+              new_part.transform.y,
+            ).toString();
           }
         }
       } else if (packet.t == PacketType.PlayerLeave) {

@@ 80,27 80,5 @@ export function startRender() {
       planet_sprite.y = planet.transform.y;
       planet_sprite.rotation = planet.transform.rot;
     }
-    /*
-    // RENDER STAGE 1: UPDATE PARTS
-    for (let [id, part] of global.parts_map) {
-      let part_sprite;
-
-      if (global.rendering!.part_sprite_map.has(id)) {
-        part_sprite = global.rendering!.part_sprite_map.get(id)!;
-      } else {
-        part_sprite = PIXI.Sprite.from(part_texture_url(part.part_type));
-        global.rendering!.part_sprite_map.set(id, part_sprite);
-        console.log("adding part sprite");
-        global.rendering!.app.stage.addChild(part_sprite);
-      }
-
-      part_sprite.height = PART_HEIGHT;
-      part_sprite.width = PART_WIDTH;
-      part_sprite.x = part.transform.x - PART_WIDTH;
-      part_sprite.y = part.transform.y - PART_HEIGHT;
-      part_sprite.rotation = part.transform.rot;
-    }
-
- */
   });
 }