ADSF

Author: mahi97

src/dan.rs

@@ -4,15 +4,35 @@ struct DAN {
 
 impl DAN {
     fn dan_to_plane(point: &Vec3, point_on_plane: &Vec3, plane_normal: &Vec3) -> (f64,Vec3) {
-        ((*point - *point_on_plane).inner_product(&plane_normal) , *plane_normal)
+        let pn = Vec3 {
+            x: plane_normal.x,
+            y: plane_normal.h,
+            h: plane_normal.y,
+        };
+        let pop = Vec3 {
+            x: point_on_plane.x,
+            y: point_on_plane.h,
+            h: point_on_plane.y,
+        };
+        ((*point - pop).inner_product(&pn) ,pn)
     }
 
     fn dan_to_sphere_inner(point: &Vec3, sphere_center: &Vec3, sphere_radius: &f64) -> (f64,Vec3) {
-        (sphere_radius - (*point - *sphere_center).len(),(*sphere_center - *point).normalize())
+        let sc = Vec3 {
+            x: sphere_center.x,
+            y: sphere_center.h,
+            h: sphere_center.y,
+        };
+        (sphere_radius - (*point - sc).len(),(sc - *point).normalize())
     }
 
     fn dan_to_sphere_outer(point: &Vec3, sphere_center: &Vec3, sphere_radius: &f64) -> (f64,Vec3) {
-        ((*point - *sphere_center).len() - sphere_radius,(*point - *sphere_center).normalize())
+        let sc = Vec3 {
+            x: sphere_center.x,
+            y: sphere_center.h,
+            h: sphere_center.y,
+        };
+        ((*point - sc).len() - sphere_radius,(*point - sc).normalize())
 
     }
 

src/my_strategy.rs

@@ -24,7 +24,6 @@ pub struct MyStrategy{
     rules: Rules,
     game: Game,
     action: Action,
-    posPID : PID
 }
 
 impl Default for MyStrategy {
@@ -35,7 +34,6 @@ impl Default for MyStrategy {
             rules: Rules{..Default::default()},
             game: Game{..Default::default()},
             action: Action{..Default::default()},
-            posPID: PID::new(5.0,0.0,0.0),
         }
     }
 }
@@ -83,37 +81,71 @@ fn get_bisect(seg: &Seg2, vec: &Vec2) -> Seg2{
 
 impl MyStrategy {
 
+    fn will_hit_the_ball(&self) -> bool{
+        let mut me = self.me.clone();
+        let mut ball = self.game.ball.clone();
+        let mut action = self.action;
+        let r = &self.rules;
+        for _ in 0..100 {
+            Self::pure_gk(&me, &ball, r, &mut action, true);
+            let (col, vel) = Simulation::tick(&mut me, &mut ball, &action, &self.rules);
+            if col && vel.y > 1.0 {
+                println!("COL: {}, {:?}", col, vel);
+                return true
+            }
+        }
+        false
+    }
 
-    fn gk(&mut self) {
-        let y_goal = self.rules.arena.depth/-2.0 + 3.0;
-        let ball_pos = self.game.ball.position();
+    fn pure_gk(me: &Robot, ball: &Ball, rules:&Rules, action: &mut Action, s: bool) {
+        let y_goal = rules.arena.depth/-2.0 + 3.0;
+        let ball_pos = ball.position();
         let goal_line = Seg2{
-            origin:   Vec2{x: self.rules.arena.goal_width/2.0, y:y_goal},
-            terminal: Vec2{x:self.rules.arena.goal_width/-2.0, y:y_goal}
+            origin:   Vec2{x: rules.arena.goal_width/ 2.0, y:y_goal},
+            terminal: Vec2{x: rules.arena.goal_width/-2.0, y:y_goal}
         };
-        let ball_seg = Seg2::new(self.game.ball.position(), self.game.ball.velocity()*100.0);
+        let ball_seg = Seg2::new(ball.position(), ball.velocity()*100.0);
         let biset = get_bisect(&goal_line, &ball_pos);
         let mut target = biset.terminal();
-        if self.game.ball.velocity().y < -1.0 { // KICK
-            target = goal_line.intersection(ball_seg);
+        if ball.velocity().y < -1.0 { // KICK
+            // if ball.position().y < -15.0 {
+            //     target = ball.position();
+            // } else {
+                target = goal_line.intersection(ball_seg);
+            // }
             if !target.is_valid() {
                 target = Vec2::new(ball_pos.x, y_goal);
             }
-        } else if self.game.ball.position().y  < 0.0 {
-            target = Vec2{x:self.game.ball.position().x, y:y_goal};
+        } else if ball.position().y  < 0.0 {
+            target = Vec2{x: ball.position().x, y:y_goal};
         }
-        if target.x < self.rules.arena.goal_width/-2.0 + 1.5 {
-            target.x =self.rules.arena.goal_width/-2.0 + 1.5;
-        } else if target.x > self.rules.arena.goal_width/2.0 - 1.5{
-            target.x = self.rules.arena.goal_width/2.0 - 1.5;
+        if target.x < rules.arena.goal_width/-2.0 + 1.5 {
+            target.x =rules.arena.goal_width/-2.0 + 1.5;
+        } else if target.x > rules.arena.goal_width/2.0 - 1.5{
+            target.x = rules.arena.goal_width/2.0 - 1.5;
         }
 
-        self.gtp(&target);
-        self.action.jump_speed = 0.0;
-        if ball_pos.dist(self.me.position()) < 3.0 && self.game.ball.height() > 2.5 {
-            self.action.jump_speed = self.rules.ROBOT_MAX_JUMP_SPEED;
+        Self::gtp(&target, me, rules, action);
+
+        if s {
+            action.jump_speed = rules.ROBOT_MAX_JUMP_SPEED;
+            action.target_velocity_y = action.jump_speed;
+        } else {
+            action.jump_speed = 0.0;
+            action.target_velocity_y = action.jump_speed;
         }
+    }
 
+    fn gk(&mut self) {
+        let y_goal = self.rules.arena.depth/-2.0 + 3.0;
+        if self.game.ball.position().y < self.me.position().y {
+                self.kick(&Vec2::new(0.0, -y_goal));
+        } else {
+            Self::pure_gk(&self.me, &self.game.ball, &self.rules,&mut self.action, false);
+            if self.will_hit_the_ball() {
+                self.action.jump_speed = self.rules.ROBOT_MAX_JUMP_SPEED;
+            }
+        }
     }
 
     fn ballTouchPrediction(&mut self) -> Vec2 {
@@ -184,14 +216,13 @@ impl MyStrategy {
             if robotvel.len() > 25.0 {
                 jump = self.game.ball.height() *4.0;
             }
-            self.set_robot_vel(idealPath*3.1415/180.0 , 100.0 ,jump);
+            Self::set_robot_vel(idealPath*3.1415/180.0 , 100.0 ,jump, &mut self.action);
         } else {
         /////
             if self.game.ball.height() >= 6.0 {
                 let touchPrediction = self.ballTouchPrediction();
                 let mut locationByPredict = touchPrediction + (touchPrediction - *target).normalize() * (0.1 + self.me.radius + self.game.ball.radius + (self.game.ball.height() - self.game.ball.radius) * 0.2) + ballVel * 0.05;
-
-                self.gtp(&locationByPredict);
+                Self::gtp(&locationByPredict, &self.me, &self.rules, &mut self.action);
             } else {
 
 ////// New prediction
@@ -233,7 +264,7 @@ impl MyStrategy {
                 }
 
 
-                self.set_robot_vel(idealPath*DEG2RAD ,100.0,jump);
+                Self::set_robot_vel(idealPath*DEG2RAD ,100.0,jump, &mut self.action);
             }
         }
 
@@ -244,36 +275,34 @@ fn pm(&mut self, target: &Vec2) {
 
 }
 
-fn gtp(&mut self, targetMain: & Vec2) {
+fn gtp(targetMain: & Vec2, me: &Robot, _rules: &Rules, action: &mut Action) {
 
     let mut target = *targetMain;
-    if (target).y > self.rules.arena.depth / 2.0 {
-        (target).y = self.rules.arena.depth / 2.0;
+    if (target).y > _rules.arena.depth / 2.0 {
+        (target).y = _rules.arena.depth / 2.0;
     }
-    if target.y < self.rules.arena.depth / -2.0 {
-        target.y = self.rules.arena.depth / -2.0;
+    if target.y < _rules.arena.depth / -2.0 {
+        target.y = _rules.arena.depth / -2.0;
     }
-    if target.x > self.rules.arena.width / 2.0 {
-        target.x = self.rules.arena.width / 2.0;
+    if target.x > _rules.arena.width / 2.0 {
+        target.x = _rules.arena.width / 2.0;
     }
-    if target.x < self.rules.arena.width / -2.0 {
-        target.x = self.rules.arena.width / -2.0;
+    if target.x < _rules.arena.width / -2.0 {
+        target.x = _rules.arena.width / -2.0;
     }
 
-    let dist = self.me.position().dist(target);
-    let diff = target - self.me.position();
+    let dist = me.position().dist(target);
+    let diff = target - me.position();
     let angle = (diff.y).atan2(diff.x);
-    let a  = self.posPID.run(dist);
-    println!("{}**{}**{}", dist, angle, a);
-    self.set_robot_vel(angle, a , 0.0);
+    Self::set_robot_vel(angle, 5.0 * dist , 0.0, action);
 
 
 }
 
-fn set_robot_vel(&mut self, angle : f64, vel: f64, jump : f64) {
-    self.action = Action {
+fn set_robot_vel(angle : f64, vel: f64, jump : f64, action: &mut Action) {
+    *action = Action {
         target_velocity_x: vel*angle.cos(),
-        target_velocity_y: 0.0,
+        target_velocity_y: 15.0,
         target_velocity_z: vel*angle.sin(),
         jump_speed: jump,
         use_nitro: false,

src/simulation.rs

@@ -1,5 +1,5 @@
+#[derive(Copy, Clone, Debug, Default)]
 struct Simulation {
-
 }
 
 impl Simulation {
@@ -11,7 +11,7 @@ impl Simulation {
         *_v
     }
 
-    fn collide_entities(_a: &mut Entity3, _b: &mut Entity3, _radius_change_speed: f64, _rules: &Rules) {
+    fn collide_entities(_a: &mut Entity3, _b: &mut Entity3, _radius_change_speed: f64, _rules: &Rules, col:&mut(&mut bool, &mut Vec3)) {
         let delta_position = _b.position3() - _a.position3();
         let distance = delta_position.len();
         let penetration = _a.radius() + _b.radius() - distance;
@@ -31,6 +31,8 @@ impl Simulation {
                 let impulse = normal * (1.0 + (_rules.MIN_HIT_E + _rules.MAX_HIT_E)/2.0) * delta_vel;
                 _a.set_velocity(&(a_vel + (impulse * k_a)));
                 _b.set_velocity(&(b_vel - (impulse * k_b)));
+                *col.0 = true;
+                *col.1 = *col.1 * 0.2 + _b.velocity3() * 0.8;
             }
         }
     }
@@ -64,22 +66,23 @@ impl Simulation {
         _e.set_height(h - (_rules.GRAVITY * delta_time));
     }
 
-    fn update(_me : &mut Robot, _ball: &mut Ball, _action: &Action, _rules: &Rules, delta_time: f64) {
+    fn update(_me : &mut Robot, _ball: &mut Ball, _action: &Action, _rules: &Rules, delta_time: f64, col:&mut(&mut bool, &mut Vec3)) {
             if _me.touch {
                 let mut target_vel = Self::clamp(&_action.target_vel(), _rules.ROBOT_MAX_GROUND_SPEED);
                 target_vel -= _me.touch_normal() * _me.touch_normal().inner_product(&target_vel);
                 let target_vel_change = target_vel - _me.velocity3();
                 if target_vel_change.len() > 0.0 {
                     let acc = _rules.ROBOT_ACCELERATION * _me.touch_normal_y.unwrap().max(0.0);
                     let robot_vel = _me.velocity3();
-                    _me.set_velocity(&(robot_vel + Self::clamp(&(_action.target_vel() * acc * delta_time), target_vel_change.len())));
+                    _me.set_velocity(&(robot_vel + Self::clamp(&(target_vel_change.normalize() * acc * delta_time), target_vel_change.len())));
                 }
                 // TODO : USE NITRO
-                Self::move_e(_me, delta_time, _rules);
-                _me.radius = _rules.ROBOT_MIN_RADIUS + (_rules.ROBOT_MAX_RADIUS - _rules.ROBOT_MIN_RADIUS) * _action.jump_speed / _rules.ROBOT_MAX_JUMP_SPEED;
             }
+            Self::move_e(_me, delta_time, _rules);
+            _me.radius = _rules.ROBOT_MIN_RADIUS + (_rules.ROBOT_MAX_RADIUS - _rules.ROBOT_MIN_RADIUS) * _action.jump_speed / _rules.ROBOT_MAX_JUMP_SPEED;
+
             Self::move_e(_ball, delta_time, _rules);
-            Self::collide_entities(_me, _ball, _action.jump_speed, _rules);
+            Self::collide_entities(_me, _ball, _action.jump_speed, _rules, col);
             let collision_normal = Self::collide_with_arena(_me, _action.jump_speed, _rules);
             if ! collision_normal.is_valid() {
                 _me.touch = false;
@@ -90,11 +93,21 @@ impl Simulation {
             Self::collide_with_arena(_ball, 0.0, _rules);
     }
 
-    fn tick(_me : &mut Robot, _ball: &mut Ball, _action: &Action, _rules: &Rules) {
+    fn tick(_me : &mut Robot, _ball: &mut Ball, _action: &Action, _rules: &Rules) -> (bool, Vec3){
         let delta_time = 1.0 / _rules.TICKS_PER_SECOND as f64;
-        for _ in 0 .. _rules.MICROTICKS_PER_TICK - 1 {
-            Self::update(_me, _ball, _action, _rules, delta_time / _rules.MICROTICKS_PER_TICK as f64);
+        let mut c = 0;
+        let mut v = Vec3::default();
+        for _ in 0 .. 99 {
+            let mut collide = false;
+            let mut col_vel = Vec3::default();
+            Self::update(_me, _ball, _action, _rules, delta_time / 100.0 as f64, &mut (&mut collide, &mut col_vel));
+            if collide {
+                println!("COL: {:?}", _action);
+                c += 1;
+                v += col_vel;
+            }
         }
+        (c > 20, v * (1.0 / f64::from(c)))
     }
 
     fn update_ball(_ball: &mut Ball, _rules: &Rules, delta_time: f64) {

src/vec3.rs

@@ -65,6 +65,13 @@ impl std::ops::Add for Vec3 {
     }
 }
 
+// Addition for vectors
+impl std::ops::AddAssign for Vec3 {
+    fn add_assign(&mut self, b: Self) {
+        *self = Self::new(self.x + b.x, self.y + b.y, self.h + b.h);
+    }
+}
+
 // Multiplying vector by a number
 impl std::ops::Mul<f64> for Vec3 {
     type Output = Self;