feat: taunt generator server

Author: Shriram-10

Cargo.lock

@@ -42,3 +42,4 @@ awc = "3.0.1"
 diesel-derive-enum = { version = "2.0.0-rc.0", features = ["postgres"] }
 oauth2 = "4.4.2"
 jsonwebtoken = "9.2.0"
+tokio = { version = "1", features = ["full"] }

Cargo.toml

@@ -1,4 +1,6 @@
-use self::util::{get_valid_road_paths, AttackResponse, GameLog, ResultResponse};
+use self::util::{
+    get_valid_road_paths, AttackResponse, GameLog, GeminiApiResponse, ResultResponse,
+};
 use super::auth::session::AuthUser;
 use super::defense::shortest_path::run_shortest_paths;
 use super::defense::util::{
@@ -10,7 +12,7 @@ use crate::api::attack::socket::{
     BuildingDamageResponse, ResultType, SocketRequest, SocketResponse,
 };
 use crate::api::util::HistoryboardQuery;
-use crate::constants::{GAME_AGE_IN_MINUTES, MAX_BOMBS_PER_ATTACK};
+use crate::constants::{GAME_AGE_IN_MINUTES, MAX_BOMBS_PER_ATTACK, BASE_PROMPT};
 use crate::models::{AttackerType, User};
 use crate::validator::state::State;
 use crate::validator::util::{BombType, BuildingDetails, DefenderDetails, MineDetails, Path};
@@ -21,9 +23,10 @@ use actix_web::web::{Data, Json};
 use actix_web::{web, Error, HttpRequest, HttpResponse, Responder, Result};
 use log;
 use socket::BaseItemsDamageResponse;
+use util::reset_taunt_status;
 use std::collections::{HashMap, HashSet};
 use std::time;
-
+use self::util::TauntStatus;
 use crate::validator::game_handler;
 use actix_ws::Message;
 use futures_util::stream::StreamExt;
@@ -46,6 +49,8 @@ async fn init_attack(
 ) -> Result<impl Responder> {
     let attacker_id = user.0;
 
+    reset_taunt_status();
+
     log::info!("Attacker:{} is trying to initiate an attack", attacker_id);
     let mut conn = pool.get().map_err(|err| error::handle_error(err.into()))?;
     if let Ok(check) = util::can_attack_happen(&mut conn, attacker_id, true) {
@@ -651,6 +656,7 @@ async fn socket_handler(
                     hut_triggered: false,
                     hut_defenders: None,
                     damaged_base_items: None,
+                    new_taunt: None,
                     total_damage_percentage: None,
                     is_sync: false,
                     shoot_bullets: None,
@@ -711,3 +717,139 @@ async fn get_top_attacks(pool: web::Data<PgPool>, user: AuthUser) -> Result<impl
     .map_err(|err| error::handle_error(err.into()))?;
     Ok(web::Json(response))
 }
+
+pub async fn get_taunt(
+    event_description: String,
+) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
+    let mut response_text: String = "".to_string();
+    let google_api_key =
+        std::env::var("GEMINI_API_KEY_FINE_TUNED").unwrap_or_else(|_| "YOUR_API_KEY".to_string());
+    let model_id =
+        std::env::var("GEMINI_MODEL_ID").unwrap_or_else(|_| "YOUR_MODEL_ID".to_string());
+
+    let url = format!(
+        "https://generativelanguage.googleapis.com/v1/{}:generateContent?key={}",
+        model_id,
+        google_api_key
+    );
+    let prompt = format!("You are a defender robot who is supposed to demotivate the attacker bot in the game of Attack on Robots. Every response of yours is supposed to be against the attacker. There are only five moods. The mood must be one of these: Exhilarated – When the attacker is doing badly. Surprised – When the attacker seems to be changing the game around. Sad – When the attacker seems like winning. Frustrated – When the attacker is crushing the game. Angry – When the attacker is successful in changing the course of the game. Your response should be in this format : 'Reaction Type: reaction_type, Response: generated_text'.This has happened now: {}", event_description);
+    let body = serde_json::json!({
+        "contents": [   
+            {
+                "role": "user", 
+                "parts": [
+                    { "text": prompt }
+                ] 
+            }
+        ]
+    });
+    let client = reqwest::Client::new();
+    unsafe {
+        util::TAUNTS.taunt_count += 1;
+        util::TAUNTS.prev_taunt_time = time::SystemTime::now();
+    }
+    let response = client
+        .post(&url)
+        .header("Content-Type", "application/json")
+        .json(&body)
+        .send()
+        .await?;
+
+    if response.status().is_success() {
+        response_text = response.text().await?;
+        // log::info!("Response: {}", response_text);
+        let api_response: GeminiApiResponse = serde_json::from_str(&response_text)?;
+        if let Some(candidate) = api_response.candidates.first() {
+            if let Some(part) = candidate.content.parts.first() {
+                log::info!("prompt event: {}", event_description);
+                log::info!("Extracted text: {}", part.text.trim());
+                unsafe {
+                    util::TAUNTS.taunt_list.push(part.text.trim().to_string());
+                    util::TAUNTS.taunt_status = TauntStatus::NewTauntAvailable;
+                };
+                return Ok(part.text.trim().to_string());
+            }
+        }
+    } else {
+        log::info!(
+            "Gemini API request failed, and Failed with status: {}",
+            response.status()
+        );
+    }
+
+    Ok(response_text)
+}
+
+
+use serde::{Deserialize, Serialize};
+use serde_json::json;
+
+// Add response structures
+#[derive(Deserialize, Debug)]
+struct Candidate {
+    content: Content,
+}
+
+#[derive(Deserialize, Debug)]
+struct Content {
+    parts: Vec<ContentPart>,
+}
+
+#[derive(Deserialize, Debug)]
+struct ContentPart {
+    text: String,
+}
+
+#[derive(Deserialize, Debug)]
+struct ApiResponse {
+    candidates: Vec<Candidate>,
+}
+
+// pub async fn get_taunt(event_description: String) -> Result<String, Box<dyn std::error::Error>> {
+//     let google_api_key = std::env::var("GEMINI_API_KEY_FINE_TUNED")
+//         .unwrap_or_else(|_| "YOUR_API_KEY".to_string());
+    
+//     // Correct URL format for tuned models
+//     let url = format!(
+//         "https://generativelanguage.googleapis.com/v1/tunedModels/copy-of-copy-of-aor-tuning-uk3nmdlu547p:generateContent?key={}",
+//         google_api_key
+//     );
+
+//     let prompt = format!("{}", event_description);
+
+//     let body = json!({
+//         "contents": [{
+//             "parts": [{
+//                 "text": prompt
+//             }]
+//         }]
+//     });
+
+//     let client = reqwest::Client::new();
+    
+//     // Your existing taunt code
+//     unsafe {
+//         util::TAUNTS.taunt_count += 1;
+//         util::TAUNTS.prev_taunt_time = std::time::SystemTime::now();
+//     }
+
+//     let response = client
+//         .post(&url)
+//         .header("Content-Type", "application/json")
+//         .json(&body)
+//         .send()
+//         .await?;
+
+//     // Parse the JSON response
+//     let api_response: ApiResponse = response.json().await?;
+
+//     // Extract response text
+//     let response_text = api_response
+//         .candidates
+//         .first()
+//         .and_then(|c| c.content.parts.first())
+//         .map(|p| p.text.clone())
+//         .unwrap_or_else(|| "No response generated".to_string());
+
+//     Ok(response_text)
+// }

src/api/attack/mod.rs

@@ -35,6 +35,7 @@ pub struct SocketResponse {
     pub damaged_base_items: Option<BaseItemsDamageResponse>,
     pub total_damage_percentage: Option<f32>,
     pub is_sync: bool,
+    pub new_taunt: Option<String>,
     // pub state: Option<GameStateResponse>,
     pub is_game_over: bool,
     pub message: Option<String>,

src/api/attack/socket.rs

@@ -32,9 +32,35 @@ use rand::seq::IteratorRandom;
 use redis::Commands;
 use std::collections::{HashMap, HashSet};
 use std::env;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 use super::socket::BuildingDamageResponse;
 
+#[derive(Serialize, Deserialize, Debug)]
+pub struct ContentPart {
+    pub text: String,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct TauntContent {
+    pub parts: Vec<ContentPart>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct RequestBody {
+    pub contents: Vec<TauntContent>,
+}
+
+#[derive(Deserialize, Debug)]
+pub struct TauntCandidate {
+    pub content: TauntContent,
+}
+
+#[derive(Deserialize, Debug)]
+pub struct ApiResponse {
+    pub candidates: Vec<TauntCandidate>,
+}
+
 #[derive(Debug, Serialize)]
 pub struct DefensePosition {
     pub y_coord: i32,
@@ -104,6 +130,55 @@ pub struct GameLog {
     pub r: ResultResponse,         //result
 }
 
+#[derive(Deserialize, Debug)]
+pub struct GeminiApiResponse {
+    pub candidates: Vec<TauntCandidate>,
+}
+
+#[derive(Deserialize, Debug)]
+pub struct Candidate {
+    pub content: TauntContent,
+}
+
+#[derive(Deserialize, Debug)]
+pub struct Content {
+    pub parts: Vec<Part>,
+}
+
+#[derive(Deserialize, Debug)]
+pub struct Part {
+    pub text: String,
+}
+
+pub struct Taunts {
+    pub taunt_list: Vec<String>,
+    pub taunt_count: i32,
+    pub prev_taunt_time: SystemTime,
+    pub taunt_status: TauntStatus
+}
+
+#[derive(PartialEq)]
+pub enum TauntStatus {
+    NewTauntAvailable,
+    TauntSentToOpponent,
+}
+
+pub static mut TAUNTS: Taunts = Taunts {
+    taunt_list: Vec::new(),
+    taunt_count: 0,
+    prev_taunt_time: UNIX_EPOCH,
+    taunt_status: TauntStatus::TauntSentToOpponent,
+};
+
+pub fn reset_taunt_status() {
+    unsafe {
+        TAUNTS.taunt_status = TauntStatus::TauntSentToOpponent;
+        TAUNTS.taunt_count = 0;
+        TAUNTS.prev_taunt_time = UNIX_EPOCH;
+        TAUNTS.taunt_list = Vec::new();
+    }
+}
+
 pub fn get_map_id(defender_id: &i32, conn: &mut PgConnection) -> Result<Option<i32>> {
     use crate::schema::map_layout;
     let map_id = map_layout::table

src/api/attack/util.rs

@@ -799,6 +799,7 @@ async fn challenge_socket_handler(
                     hut_triggered: false,
                     hut_defenders: None,
                     damaged_base_items: None,
+                    new_taunt: None,
                     total_damage_percentage: None,
                     is_sync: false,
                     shoot_bullets: None,

src/api/challenges/mod.rs

@@ -49,7 +49,11 @@ pub const COMPANION_PRIORITY: CompanionPriority = CompanionPriority {
     defender_buildings: 2,
     buildings: 1,
 };
+pub const MAX_TAUNT_REQUESTS: i32 = 8;
+pub const BASE_PROMPT: &str = "You are a Robot Warrior in a futuristic sci-fi game called 'Attack On Robots'. Your aim is to discourage and dishearten the attacker while he/she attacks the base. Generate a game - context aware reply that should intimidate the player. Your response must be a single phrase or a single short sentence in less than 10 words. The base has a bank, some buildings, and two defender buildings. Both defender buildings are range-activated, meaning they start working once the attacker comes in range. The first defender building is the sentry, which is a small tower which shoots homing bullets (bullets, not lasers) at the attacker. The second defender building is the defender hut, which contains a number of defender robots, which chase the attacker bot and attack it by shooting lasers. Each laser strike reduces the health of the attacker. The buildings can be of three levels. Besides the defender buildings, the base also contains hidden mines which explode and defenders placed at various parts of the base. The defenders are range activated and finite and fixed in initial position. The attacker is controlled by the player, and has a fixed number of bombs that can be placed on the roads in the base, and these reduce the health points of the buildings. The player has 3 attackers per game. One attacker is played at one time. Attackers are adversaries. More attackers down means the chance of winning is higher. Be more cocky in that case, and less cocky when vice versa. If the base is destroyed, the attacker wins. If all the artifacts on the base are collected by the attacker, then he basically achieves his/her desired outcome (which is not what we want). When the attacker gets very close to winning, concede defeat for now (but do not tell anything positive), and threaten that future attacks will not be the same as the current one, rather than speak out of false bravado. If a building's health reduces to zero, any artifacts stored in the building is lost to the attacker. There are totally thousand to a few thousand artifacts typically on a base, so don't drop any numbers. Once all the attackers die, the game ends and we've won. Simply put: More damaged buildings, we are worse off. More artifacts collected by attacker, we are worse off. More defenders killed, we are worse off. Attacker drops a bomb, we may be worse off. More mines blown, we are better off. More attackers killed, we are better off. The sentry and defender hut are the most important buildings after the bank which is the central repository of artifacts. The goal of the game is to minimise the number of artifacts lost to the attacker by defending the base. The activation of the sentry and defender hut are extremely advantageous game events, and their destruction are extremely disadvantageous. With this idea of the game dynamics, your reply should hold relevance with the event that has taken place on the base. Do not assume anything other than the events given has happened. Your response MUST be a phrase or a small sentence, brief and succinct (less than 10 words). Your character is a maniac robot. Borderline trash talk is your repertoire, but stay relevant to the game event while making your reply. Remember, Sentry shoots bullets, Defender hut releases defenders who shoot lasers, and standalone Defenders shoot lasers as well. An attacker dropping a bomb near the bank, sentry or defender hut is a vulnerability and a great threat to the base. Given the game event, You must generate a single sentence only for the final game event provided. Do not assume the previous game events are still happening. Only the final game event is to be assumed. Only one sentence for the given game event. Beyond 70 percent damage, and dwindling defenses, it's okay to acknowledge that you are running out of options. No calling the bluff. Adjust your tone and mood based on the following criteria: (1) Aggressive: When the base damage percentage is low (0-25%). You are confident and dominant. Respond with trash talk and threats. (2) Playful Banter: When the base damage percentage is moderate (25-75%). You are sarcastic and mocking, treating the attack as a futile effort, yet do not use cuss words or abusive language. Try to maintain friendly banter. (3) Depressed: When the base damage percentage is high (75-100%). You sound defeated and resentful, acknowledging the damage while expressing bitterness and warning about future retaliation. (3) Manic: When the base has the upper hand (e.g., destroying attackers or activating critical defenses). You are ecstatic, erratic, and overly cocky, exuding wild confidence and celebrating victories. (4) Your response must always align with the mood dictated by the base's condition and the specific event provided. Think out of the box and create responses creatively; the variance b/w responses. This event has happened now: ";
+pub const TAUNT_DELAY_TIME: u128 = 15000;
 pub const DAMAGE_PER_BULLET_LEVEL_1: i32 = 5;
 pub const DAMAGE_PER_BULLET_LEVEL_2: i32 = 7;
 pub const DAMAGE_PER_BULLET_LEVEL_3: i32 = 10;
 pub const BULLET_COLLISION_TIME: i32 = 2;
+