Fix : Laser attacks companion now

Dockerfile

@@ -1,4 +1,4 @@
-FROM rust:1.78.0-slim AS base
+FROM rust:1.82.0-slim AS base
 WORKDIR /usr/src/aot-backend
 RUN apt-get update -y && apt-get install -y \
     libpq-dev \

dummy_data.sql

@@ -32,7 +32,7 @@ COPY public.levels_fixture FROM stdin;
 \.
 
 COPY public.user FROM stdin;
-1	Bot	[email protected]	bot	true	0	0	1000	0	500
+1	Bot	[email protected]	bot	true	0	0	1000	0	500	false
 \.
 
 COPY public.map_layout FROM stdin;

migrations/2025-01-29-161348_challenges_migration/down.sql

@@ -0,0 +1,5 @@
+-- This file should undo anything in `up.sql`
+DROP TABLE IF EXISTS challenges;
+DROP TABLE IF EXISTS challenge_maps;
+DROP TABLE IF EXISTS challenges_responses;
+ALTER TABLE "user" DROP COLUMN is_mod;

migrations/2025-01-29-161348_challenges_migration/up.sql

@@ -0,0 +1,34 @@
+-- Your SQL goes here
+CREATE TABLE challenges
+(
+    id SERIAL PRIMARY KEY,
+    "name" VARCHAR(255) NOT NULL,
+    "start" TIMESTAMP NOT NULL,
+    "end" TIMESTAMP NOT NULL
+);
+
+CREATE TABLE challenge_maps
+(
+    id SERIAL PRIMARY KEY,
+    challenge_id INTEGER NOT NULL,
+    user_id INTEGER NOT NULL,
+    map_id INTEGER NOT NULL,
+    CONSTRAINT fk_chall_map_challenge FOREIGN KEY (challenge_id) REFERENCES challenges(id),
+    CONSTRAINT fk_chall_map_user FOREIGN KEY (user_id) REFERENCES "user"(id),
+    CONSTRAINT fk_chall_map_maplayout FOREIGN KEY (map_id) REFERENCES map_layout(id)
+);
+
+CREATE TABLE challenges_responses
+(
+    id SERIAL PRIMARY KEY,
+    attacker_id INTEGER NOT NULL,
+    challenge_id INTEGER NOT NULL,
+    map_id INTEGER NOT NULL,
+    score INTEGER NOT NULL,
+    CONSTRAINT chall_response_attacker FOREIGN KEY (attacker_id) REFERENCES "user"(id),
+    CONSTRAINT chall_response_challenge FOREIGN KEY (challenge_id) REFERENCES challenges(id),
+    CONSTRAINT chall_response_mapid FOREIGN KEY (map_id) REFERENCES map_layout(id),
+    CONSTRAINT unique_attacker_challenge UNIQUE (attacker_id, challenge_id)
+);
+
+ALTER TABLE "user" ADD COLUMN is_mod BOOLEAN NOT NULL;

src/api/attack/mod.rs

@@ -394,6 +394,7 @@ async fn socket_handler(
             nd: 0,
             oa: 0,
             od: 0,
+            sc: 0,
         },
     };
 
@@ -424,6 +425,7 @@ async fn socket_handler(
             hut_defenders,
             mines,
             buildings,
+            None,
         );
         game_state.set_total_hp_buildings();
         game_state.get_sentries();
@@ -545,6 +547,15 @@ async fn socket_handler(
                                         if session_clone1.text(response_json).await.is_err() {
                                             return;
                                         }
+                                    } else if response.result_type == ResultType::BulletHit {
+                                        if session_clone1.text(response_json).await.is_err() {
+                                            return;
+                                        }
+                                    }
+                                    else if response.result_type == ResultType::UAV {
+                                        if session_clone1.text(response_json).await.is_err() {
+                                            return;
+                                        }
                                     } else if response.result_type == ResultType::Nothing
                                         && session_clone1.text(response_json).await.is_err()
                                     {
@@ -581,6 +592,9 @@ async fn socket_handler(
                     }
                 }
                 Message::Close(_s) => {
+                    if game_logs.d.is_pragyan {
+                        //challenge game terminate
+                    }
                     if util::terminate_game(
                         game_logs,
                         &mut conn,
@@ -643,6 +657,9 @@ async fn socket_handler(
                     is_game_over: true,
                     message: Some("Connection timed out".to_string()),
                     companion: None,
+                    challenge: None,
+                    bullet_hits: None,
+                    revealed_mines: None,
                 })
                 .unwrap();
                 if session_clone2.text(response_json).await.is_err() {

src/api/attack/socket.rs

@@ -40,6 +40,13 @@ pub struct SocketResponse {
     pub message: Option<String>,
     pub shoot_bullets: Option<Vec<BulletSpawnResponse>>,
     pub companion: Option<CompanionResult>,
+    pub challenge: Option<ChallengeResponse>,
+    pub bullet_hits: Option<Vec<BulletHit>>,
+    pub revealed_mines: Option<Vec<MineDetails>>,
+}
+#[derive(Serialize, Deserialize, Debug)]
+pub struct ChallengeResponse {
+    pub score: i32,
 }
 
 #[derive(Debug, Serialize, Deserialize, PartialEq)]
@@ -52,6 +59,8 @@ pub enum ActionType {
     Idle,
     Terminate,
     SelfDestruct,
+    CheckBullets,
+    UavStatus,
 }
 
 #[derive(Debug, Serialize, Deserialize, PartialEq)]
@@ -65,6 +74,8 @@ pub enum ResultType {
     PlacedAttacker,
     PlacedCompanion,
     Nothing,
+    BulletHit,
+    UAV,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -125,3 +136,11 @@ pub struct GameStateResponse {
     pub buildings: Vec<BuildingDetails>,
     pub total_hp_buildings: i32,
 }
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct BulletHit {
+    pub defender_id: i32,
+    pub target_id: i32,
+    pub damage: i32,
+    pub position: Coords,
+}

src/api/attack/util.rs

@@ -20,8 +20,8 @@ use crate::models::{
 };
 use crate::schema::{block_type, building_type, defender_type, map_layout, map_spaces, prop, user};
 use crate::util::function;
-use crate::validator::util::Coords;
 use crate::validator::util::{BombType, BuildingDetails, DefenderDetails, MineDetails};
+use crate::validator::util::{Coords, HutDefenderDetails};
 use ::serde::{Deserialize, Serialize};
 use anyhow::Result;
 use chrono;
@@ -91,6 +91,7 @@ pub struct ResultResponse {
     pub nd: i32, //new_defender_trophies
     pub oa: i32, //old_attacker_trophies
     pub od: i32, //old_defender_trophies
+    pub sc: i32, //challenge_score
 }
 
 #[derive(Serialize, Clone)]
@@ -553,6 +554,7 @@ pub fn get_mines(conn: &mut PgConnection, map_id: i32) -> Result<Vec<MineDetails
                 x: map_space.x_coordinate,
                 y: map_space.y_coordinate,
             },
+            name: mine_type.name,
         })
         .collect();
 
@@ -650,6 +652,9 @@ pub fn get_defenders(
             level: defender.level,
             current_health: defender.max_health,
             max_health: defender.max_health,
+            range: prop.range,
+            frequency: prop.frequency,
+            last_attack: 0,
         })
     }
     // Sorted to handle multiple defenders attack same attacker at same frame
@@ -732,6 +737,9 @@ pub fn get_hut_defender(
             level: defender_type.level,
             current_health: defender_type.max_health,
             max_health: defender_type.max_health,
+            range: 0,
+            frequency: 0,
+            last_attack:0 ,
         });
         log::info!("hut_defenders {:?}", i);
     }
@@ -767,6 +775,45 @@ pub fn get_hut_defender(
     Ok(hut_defenders_res)
 }
 
+pub fn get_hut_defender_types(conn: &mut PgConnection) -> Result<Vec<DefenderDetails>> {
+    let joined_table = block_type::table
+        .inner_join(defender_type::table)
+        .inner_join(prop::table.on(defender_type::prop_id.eq(prop::id)))
+        .filter(defender_type::name.eq("Hut_Defender"));
+    let hut_defenders = joined_table
+        .load::<(BlockType, DefenderType, Prop)>(conn)
+        .map_err(|err| DieselError {
+            table: "defender_type",
+            function: function!(),
+            error: err,
+        })?
+        .into_iter();
+    let mut hut_defender_array: Vec<DefenderDetails> = Vec::new();
+    for (i, (block_type, defender_type, prop)) in hut_defenders.enumerate() {
+        hut_defender_array.push(DefenderDetails {
+            map_space_id: -1,
+            name: defender_type.name.clone(),
+            radius: prop.range,
+            speed: defender_type.speed,
+            damage: defender_type.damage,
+            defender_pos: Coords { x: 0, y: 0 },
+            is_alive: true,
+            damage_dealt: false,
+            target_id: None,
+            path_in_current_frame: Vec::new(),
+            block_id: block_type.id,
+            level: defender_type.level,
+            current_health: defender_type.max_health,
+            max_health: defender_type.max_health,
+            frequency: prop.frequency,
+            range: prop.range,
+            last_attack: 0,
+        });
+        log::info!("hut_defenders {:?}", i);
+    }
+    Ok(hut_defender_array)
+}
+
 pub fn get_bomb_types(conn: &mut PgConnection) -> Result<Vec<BombType>> {
     use crate::schema::emp_type::dsl::*;
     let bomb_types = emp_type

src/api/auth/mod.rs

@@ -33,6 +33,7 @@ pub struct LoginResponse {
     pub artifacts: i32,
     pub email: String,
     pub token: Option<String>,
+    pub is_mod: bool,
 }
 
 #[derive(Debug, Deserialize)]
@@ -158,6 +159,7 @@ async fn login(
             artifacts: user.artifacts,
             email: user.email,
             token: Some(token),
+            is_mod: user.is_mod,
         })))
 }