Some more (Messy) star event code

src/router.rs

@@ -82,8 +82,8 @@ async fn api_req(req: HttpRequest, body: String) -> HttpResponse {
             "/api/event/ranking" => event::ranking(req, body),
             "/api/event_star_live/change_target_music" => event::change_target_music(req, body),
             "/api/event_star_live/start" => live::event_start(req, body),
-            "/api/event_star_live/end" => live::event_end(req, body),
+            "/api/event_star_live/end" => event::event_end(req, body),
-            //"/api/event_star_live/skip" => live::event_skip(req, body),
+            "/api/event_star_live/skip" => event::event_skip(req, body),
             "/api/live/start" => live::start(req, body),
             "/api/live/end" => live::end(req, body),
             "/api/live/skip" => live::skip(req, body),

src/router/event.rs

@@ -1,4 +1,4 @@
-use json::{JsonValue, object};
+use json::{JsonValue, object, array};
 use actix_web::HttpRequest;
 use rand::Rng;
 
@@ -6,16 +6,28 @@ use crate::encryption;
 use crate::include_file;
 use crate::router::{userdata, global, databases};
 
+// I believe(?) this is all?
+const STAR_EVENT_IDS: [u32; 3] = [127, 135, 139];
+
 fn get_event_data(key: &str, event_id: u32) -> JsonValue {
     let mut event = userdata::get_acc_event(key);
+    let is_star_event = STAR_EVENT_IDS.contains(&event_id);
+    println!("is_star_event: {}, {}", is_star_event, event_id);
 
     if event[event_id.to_string()].is_empty() {
         event[event_id.to_string()] = json::parse(&include_file!("src/router/userdata/new_user_event.json")).unwrap();
+        if is_star_event {
             let mut ev = event[event_id.to_string()].clone();
             init_star_event(&mut ev);
             save_event_data(key, event_id, ev);
             event = userdata::get_acc_event(key);
         }
+    }
+
+    if is_star_event && event["star_last_reset"][event_id.to_string()].as_u64().unwrap_or(0) <= global::timestamp_since_midnight() {
+        event["star_last_reset"][event_id.to_string()] = (global::timestamp_since_midnight() + (24 * 60 * 60)).into();
+        event[event_id.to_string()]["star_event"]["star_event_bonus_daily_count"] = 0.into();
+    }
     event[event_id.to_string()].clone()
 }
 
@@ -149,6 +161,94 @@ pub fn ranking(_req: HttpRequest, _body: String) -> Option<JsonValue> {
     })
 }
 
+const POINTS_PER_LEVEL: i64 = 55;
+
+fn get_star_rank(points: i64) -> i64 {
+    ((points - (points % POINTS_PER_LEVEL)) / POINTS_PER_LEVEL) + 1
+}
+
+pub fn event_live(req: HttpRequest, body: String, skipped: bool) -> Option<JsonValue> {
+    let key = global::get_login(req.headers(), &body);
+    let body_temp = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+    let event_id = if skipped {
+        body_temp["master_event_id"].as_u32().unwrap()
+    } else {
+        crate::router::live::get_end_live_event_id(&key, &body_temp)?
+    };
+
+    let mut resp = crate::router::live::live_end(&req, &body, skipped);
+    let key = global::get_login(req.headers(), &body);
+    let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+    let mut event = get_event_data(&key, event_id);
+
+    let live_id = databases::LIVE_LIST[body["master_live_id"].to_string()]["masterMusicId"].as_i64().unwrap();
+    let raw_score = body["live_score"]["score"].as_u64().unwrap_or(resp["high_score"].as_u64().unwrap());
+
+    let bonus_event = event["star_event"]["star_event_bonus_daily_count"].as_u64().unwrap();
+    let bonus_play_times = event["star_event"]["star_event_play_times_bonus_count"].as_u64().unwrap();
+    let score = raw_score + (raw_score * bonus_event) + (raw_score * bonus_play_times);
+
+    let mut all_clear = 1;
+    let mut cleared = false;
+    for data in event["star_event"]["star_music_list"].members_mut() {
+        if data["master_music_id"] == live_id && score >= data["goal_score"].as_u64().unwrap() {
+            data["is_cleared"] = 1.into();
+            cleared = true;
+        }
+        if data["is_cleared"] == 0 {
+            all_clear = 0;
+        }
+    }
+
+    if cleared {
+        event["star_event"]["star_event_bonus_daily_count"] = (event["star_event"]["star_event_bonus_daily_count"].as_u32().unwrap() + 1).into();
+        event["star_event"]["star_event_bonus_count"] = (event["star_event"]["star_event_bonus_count"].as_u32().unwrap() + 1).into();
+        event["star_event"]["star_event_play_times_bonus_count"] = (event["star_event"]["star_event_play_times_bonus_count"].as_u32().unwrap() + 1).into();
+
+
+        event["point_ranking"]["point"] = (event["point_ranking"]["point"].as_i64().unwrap_or(0) + 31).into();
+        event["star_event"]["star_level"] = get_star_rank(event["point_ranking"]["point"].as_i64().unwrap()).into();
+    }
+
+    resp["star_event_bonus_list"] = object!{
+        "star_event_bonus": bonus_event,
+        "star_event_bonus_score": bonus_event * raw_score,
+        "star_play_times_bonus": bonus_play_times,
+        "star_play_times_bonus_score": bonus_play_times * raw_score,
+        "card_bonus": 0,
+        "card_bonus_score": 0
+    };
+
+    resp["event_point_list"] = array![];
+    resp["event_ranking_data"] = object! {
+        "event_point_rank": event["point_ranking"]["point"].clone(),
+        "next_reward_rank_point": 0,
+        "event_score_rank": 0,
+        "next_reward_rank_score": 0,
+        "next_reward_rank_level": 0
+    };
+
+
+    resp["is_star_all_clear"] = all_clear.into();
+    resp["star_level"] = event["star_event"]["star_level"].clone();
+    resp["music_data"] = event["star_event"]["star_music_list"].clone();
+    resp["total_score"] = score.into();
+    resp["star_event"] = event["star_event"].clone();
+
+    save_event_data(&key, event_id, event);
+
+    println!("{}", resp);
+    Some(resp)
+}
+
+pub fn event_end(req: HttpRequest, body: String) -> Option<JsonValue> {
+    event_live(req, body, false)
+}
+
+pub fn event_skip(req: HttpRequest, body: String) -> Option<JsonValue> {
+    event_live(req, body, true)
+}
+
 // Start request structs
 // These start with CJsonSendParam in the source
 

src/router/live.rs

@@ -201,6 +201,17 @@ fn get_end_live_deck_id(login_token: &str, body: &JsonValue) -> Option<i32> {
     Some(rv)
 }
 
+pub fn get_end_live_event_id(login_token: &str, body: &JsonValue) -> Option<u32> {
+    let server_data = userdata::get_server_data(login_token);
+    if server_data["last_live_started"].is_null() {
+        return None;
+    }
+    let index = server_data["last_live_started"].members().position(|r| r["master_live_id"] == body["master_live_id"])?;
+    let rv = server_data["last_live_started"][index]["master_event_id"].as_u32()?;
+
+    Some(rv)
+}
+
 fn live_retire(login_token: &str, body: &JsonValue) {
     let mut server_data = userdata::get_server_data(login_token);
     check_for_stale_data(&mut server_data, body["master_live_id"].as_i64().unwrap());
@@ -228,8 +239,8 @@ pub fn start(req: HttpRequest, body: String) -> Option<JsonValue> {
     Some(array![])
 }
 
-pub fn event_start(_req: HttpRequest, _body: String) -> Option<JsonValue> {
+pub fn event_start(req: HttpRequest, body: String) -> Option<JsonValue> {
-    Some(array![])
+    start(req, body)
 }
 
 pub fn continuee(req: HttpRequest, body: String) -> Option<JsonValue> {
@@ -515,7 +526,7 @@ fn get_live_character_list(lp_used: i32, deck_id: i32, user: &JsonValue, mission
     rv
 }
 
-fn live_end(req: &HttpRequest, body: &str, skipped: bool) -> JsonValue {
+pub fn live_end(req: &HttpRequest, body: &str, skipped: bool) -> JsonValue {
     let key = global::get_login(req.headers(), body);
     let body = json::parse(&encryption::decrypt_packet(body).unwrap()).unwrap();
     let user2 = userdata::get_acc_home(&key);
@@ -644,52 +655,3 @@ pub fn end(req: HttpRequest, body: String) -> Option<JsonValue> {
 pub fn skip(req: HttpRequest, body: String) -> Option<JsonValue> {
     Some(live_end(&req, &body, true))
 }
-
-pub fn event_end(req: HttpRequest, body: String) -> Option<JsonValue> {
-    let mut resp = live_end(&req, &body, false);
-    let key = global::get_login(req.headers(), &body);
-    let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
-    let mut event = userdata::get_acc_event(&key);
-    
-    let live_id = databases::LIVE_LIST[body["master_live_id"].to_string()]["masterMusicId"].as_i64().unwrap();
-    
-    let mut all_clear = 1;
-    for data in event["event_data"]["star_event"]["star_music_list"].members_mut() {
-        if data["master_music_id"].as_i64().unwrap() == live_id {
-            data["is_cleared"] = 1.into();
-        }
-        if !data["is_cleared"].as_i32().unwrap() == 0 {
-            all_clear = 0;
-        }
-    }
-    
-    resp["event_point_list"] = array![];
-    resp["event_ranking_data"] = object!{
-        "event_point_rank": event["event_data"]["point_ranking"]["point"].clone(),
-        "next_reward_rank_point": 0,
-        "event_score_rank": 0,
-        "next_reward_rank_score": 0,
-        "next_reward_rank_level": 0
-    };
-    resp["star_level"] = event["event_data"]["star_event"]["star_level"].clone();
-    resp["music_data"] = event["event_data"]["star_event"]["star_music_list"].clone();
-    resp["is_star_all_clear"] = all_clear.into();
-    resp["star_event_bonus_list"] = object!{
-        "star_event_bonus": 0,
-        "star_event_bonus_score": 0,
-        "star_play_times_bonus": 0,
-        "star_play_times_bonus_score": 0,
-        "card_bonus": 0,
-        "card_bonus_score": 0
-    };
-    resp["total_score"] = body["live_score"]["score"].clone();
-    resp["star_event"] = object!{
-        "star_event_bonus_daily_count": event["event_data"]["point_ranking"]["star_event_bonus_daily_count"].clone(),
-        "star_event_bonus_count": event["event_data"]["point_ranking"]["star_event_bonus_count"].clone(),
-        "star_event_play_times_bonus_count": event["event_data"]["point_ranking"]["star_event_play_times_bonus_count"].clone()
-    };
-    
-    userdata::save_acc_event(&key, event);
-    
-    Some(resp)
-}