Implement base star event handler

src/main.rs

@@ -64,6 +64,11 @@ async fn request(req: HttpRequest, body: String) -> HttpResponse {
             "/api/live/mission" => router::live::mission(req, body),
             "/api/live/ranking" => router::clear_rate::ranking(req, body),
             "/api/event" => router::event::event(req, body),
+            "/api/event/star_event" => router::event::star_event(req, body),
+            "/api/event_star_live/change_target_music" => router::event::change_target_music(req, body),
+            "/api/event_star_live/start" => router::live::event_start(req, body),
+            "/api/event_star_live/end" => router::live::event_end(req, body),
+//            "/api/event_star_live/skip" => router::live::event_skip(req, body),
             "/api/live/start" => router::live::start(req, body),
             "/api/live/end" => router::live::end(req, body),
             "/api/live/skip" => router::live::skip(req, body),
@@ -74,6 +79,7 @@ async fn request(req: HttpRequest, body: String) -> HttpResponse {
             "/api/lottery/get_tutorial" => router::lottery::tutorial(req, body),
             "/api/lottery" => router::lottery::lottery_post(req, body),
             "/api/login_bonus" => router::login::bonus(req, body),
+            "/api/login_bonus/event" => router::login::bonus_event(req, body),
             "/api/notice/reward" => router::notice::reward_post(req, body),
             "/api/user/getmigrationcode" => router::user::get_migration_code(req, body),
             "/api/user/registerpassword" => router::user::register_password(req, body),

src/router/clear_rate.rs

@@ -138,7 +138,7 @@ lazy_static! {
         info
     };
 }
-fn get_live_id(id: i64) -> i64 {
+pub fn get_live_id(id: i64) -> i64 {
     LIVE_LIST[id.to_string()].as_i64().unwrap()
 }
 

src/router/event.rs

@@ -1,14 +1,79 @@
-use json::object;
+use json::{JsonValue, object};
 use actix_web::{HttpResponse, HttpRequest};
 
-use crate::router::global;
+use crate::router::{userdata, global};
 
-pub fn event(_req: HttpRequest, _body: String) -> HttpResponse {
+pub fn event(req: HttpRequest, body: String) -> HttpResponse {
+    let key = global::get_login(req.headers(), &body);
+    let mut event = userdata::get_acc_event(&key);
+    
+    init_star_event(&mut event);
+    
+    userdata::save_acc_event(&key, event.clone());
     
     let resp = object!{
         "code": 0,
         "server_time": global::timestamp(),
-        "data":{"point_ranking":{"point":0},"score_ranking":[],"member_ranking":[],"lottery_box":[],"mission_list":[],"policy_agreement":0,"incentive_lottery":0,"star_event":{"star_level":0,"last_event_star_level":0,"star_music_list":[],"is_star_event_update":1,"music_change_count":0,"star_event_bonus_daily_count":0,"star_event_bonus_count":0,"star_event_play_times_bonus_count":0,"star_assist_bonus":1}}
+        "data": event["event_data"].clone()
+    };
+    global::send(resp)
+}
+
+fn switch_music(event: &mut JsonValue, music_id: i32, target_score: i64, index: i32) {
+    if index <= 4 {
+        //todo
+    }
+    let to_push = object!{
+        master_music_id: music_id,
+        position: event["event_data"]["star_event"]["star_music_list"].len(),
+        is_cleared: 0,
+        goal_score: target_score
+    };
+    event["event_data"]["star_event"]["star_music_list"].push(to_push).unwrap();
+}
+
+fn init_star_event(event: &mut JsonValue) {
+    if event["event_data"]["star_event"]["star_level"].as_i32().unwrap() != 0 {
+        return;
+    }
+    event["event_data"]["star_event"]["star_level"] = 1.into();
+    switch_music(event, 1014, 53407, 5);
+    switch_music(event, 2101, 34557, 5);
+    switch_music(event, 2120, 38222, 5);
+    switch_music(event, 2151, 46076, 5);
+    switch_music(event, 2160, 21991, 5);
+}
+
+pub fn star_event(req: HttpRequest, body: String) -> HttpResponse {
+    let key = global::get_login(req.headers(), &body);
+    let mut event = userdata::get_acc_event(&key);
+    init_star_event(&mut event);
+    
+    userdata::save_acc_event(&key, event.clone());
+    
+    let resp = object!{
+        "code": 0,
+        "server_time": global::timestamp(),
+        "data": {
+            star_event: event["event_data"]["star_event"].clone(),
+            gift_list: [],
+            reward_list: []
+        }
+    };
+    global::send(resp)
+}
+
+//todo - randomize
+pub fn change_target_music(req: HttpRequest, body: String) -> HttpResponse {
+    let key = global::get_login(req.headers(), &body);
+    let event = userdata::get_acc_event(&key);
+    
+    //event["star_event"]["music_change_count"] += 1;
+    
+    let resp = object!{
+        "code": 0,
+        "server_time": global::timestamp(),
+        "data": event["event_data"]["star_event"].clone()
     };
     global::send(resp)
 }

src/router/live.rs

@@ -188,6 +188,15 @@ pub fn start(_req: HttpRequest, _body: String) -> HttpResponse {
     global::send(resp)
 }
 
+pub fn event_start(_req: HttpRequest, _body: String) -> HttpResponse {
+    let resp = object!{
+        "code": 0,
+        "server_time": global::timestamp(),
+        "data": []
+    };
+    global::send(resp)
+}
+
 pub fn continuee(req: HttpRequest, body: String) -> HttpResponse {
     let key = global::get_login(req.headers(), &body);
     let mut user = userdata::get_acc(&key);
@@ -374,9 +383,9 @@ fn give_mission_rewards(user: &mut JsonValue, missions: &JsonValue, multiplier:
     rv
 }
 
-pub fn end(req: HttpRequest, body: String) -> HttpResponse {
+fn live_end(req: &HttpRequest, body: &String) -> JsonValue {
-    let key = global::get_login(req.headers(), &body);
+    let key = global::get_login(req.headers(), body);
-    let body = json::parse(&encryption::decrypt_packet(&body).unwrap()).unwrap();
+    let body = json::parse(&encryption::decrypt_packet(body).unwrap()).unwrap();
     let user2 = userdata::get_acc_home(&key);
     let mut user = userdata::get_acc(&key);
     let live = update_live_data(&mut user, &body, true);
@@ -400,7 +409,7 @@ pub fn end(req: HttpRequest, body: String) -> HttpResponse {
     
     userdata::save_acc(&key, user.clone());
     
-    let resp = object!{
+    object!{
         "code": 0,
         "server_time": global::timestamp(),
         "data": {
@@ -421,7 +430,60 @@ pub fn end(req: HttpRequest, body: String) -> HttpResponse {
             "event_member": [],
             "event_ranking_data": []
         }
+    }
+}
+
+pub fn end(req: HttpRequest, body: String) -> HttpResponse {
+    let resp = live_end(&req, &body);
+    global::send(resp)
+}
+
+pub fn event_end(req: HttpRequest, body: String) -> HttpResponse {
+    let mut resp = live_end(&req, &body);
+    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 = crate::router::clear_rate::get_live_id(body["master_live_id"].as_i64().unwrap());
+    
+    let mut all_clear = 1;
+    for (_i, data) in event["event_data"]["star_event"]["star_music_list"].members_mut().enumerate() {
+        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);
+    
     global::send(resp)
 }
 

src/router/login.rs

@@ -51,17 +51,8 @@ pub fn get_login_bonus_info(id: i64) -> JsonValue {
     LOTTERY_INFO[id.to_string()].clone()
 }
 
-pub fn bonus(req: HttpRequest, body: String) -> HttpResponse {
+fn do_bonus(user_home: &mut JsonValue, bonuses: &mut JsonValue) -> JsonValue {
-    let key = global::get_login(req.headers(), &body);
-    let user = userdata::get_acc(&key);
-    let mut user_home = userdata::get_acc_home(&key);
-    
     let last_reset = global::timestamp_since_midnight();
-    let mut bonuses = userdata::get_acc_loginbonus(&key);
-    if bonuses["bonus_list"].is_empty() {
-        global::start_login_bonus(1, &mut bonuses);
-    }
-    
     let to_send;
     if bonuses["last_rewarded"].as_u64().unwrap() < last_reset {
         let mut to_rm = array![];
@@ -77,19 +68,58 @@ pub fn bonus(req: HttpRequest, body: String) -> HttpResponse {
             }
             let item_id = crate::router::user::get_info_from_id(info["days"][current]["masterLoginBonusRewardId"].as_i64().unwrap());
             
-            items::gift_item(&item_id, &format!("Login bonus day {}!", current+1), &mut user_home);
+            items::gift_item(&item_id, &format!("Event login bonus day {}!", current+1), user_home);
             data["day_counts"].push(current + 1).unwrap();
         }
         for (i, data) in to_rm.members().enumerate() {
             bonuses["bonus_list"].array_remove(data.as_usize().unwrap() - i);
         }
         bonuses["last_rewarded"] = last_reset.into();
-        userdata::save_acc_loginbonus(&key, bonuses.clone());
         to_send = bonuses["bonus_list"].clone();
     } else {
         to_send = array![];
     }
+    to_send
+}
+
+pub fn bonus(req: HttpRequest, body: String) -> HttpResponse {
+    let key = global::get_login(req.headers(), &body);
+    let user = userdata::get_acc(&key);
+    let mut user_home = userdata::get_acc_home(&key);
     
+    let mut bonuses = userdata::get_acc_loginbonus(&key);
+    if bonuses["bonus_list"].is_empty() {
+        global::start_login_bonus(1, &mut bonuses);
+    }
+    let to_send = do_bonus(&mut user_home, &mut bonuses);
+    
+    userdata::save_acc_loginbonus(&key, bonuses.clone());
+    userdata::save_acc_home(&key, user_home);
+    
+    let resp = object!{
+        "code": 0,
+        "server_time": global::timestamp(),
+        "data": {
+            "login_bonus_list": to_send,
+            "start_time": bonuses["start_time"].clone(),
+            "clear_mission_ids": user["clear_mission_ids"].clone()
+        }
+    };
+    global::send(resp)
+}
+
+pub fn bonus_event(req: HttpRequest, body: String) -> HttpResponse {
+    let key = global::get_login(req.headers(), &body);
+    let user = userdata::get_acc(&key);
+    let mut user_home = userdata::get_acc_home(&key);
+    
+    let mut bonuses = userdata::get_acc_eventlogin(&key);
+    if bonuses["bonus_list"].is_empty() {
+        global::start_login_bonus(20039, &mut bonuses);
+    }
+    let to_send = do_bonus(&mut user_home, &mut bonuses);
+    
+    userdata::save_acc_eventlogin(&key, bonuses.clone());
     userdata::save_acc_home(&key, user_home);
     
     let resp = object!{

src/router/userdata/mod.rs

@@ -26,14 +26,17 @@ fn setup_tables(conn: &SQLite) {
         password  TEXT NOT NULL
     )");
     conn.create_store_v2("CREATE TABLE IF NOT EXISTS users (
-        user_id         BIGINT NOT NULL PRIMARY KEY,
+        user_id          BIGINT NOT NULL PRIMARY KEY,
-        userdata        TEXT NOT NULL,
+        userdata         TEXT NOT NULL,
-        userhome        TEXT NOT NULL,
+        userhome         TEXT NOT NULL,
-        missions        TEXT NOT NULL,
+        missions         TEXT NOT NULL,
-        loginbonus      TEXT NOT NULL,
+        loginbonus       TEXT NOT NULL,
-        sifcards        TEXT NOT NULL,
+        sifcards         TEXT NOT NULL,
-        friends         TEXT NOT NULL,
+        friends          TEXT NOT NULL,
-        friend_request_disabled  INT NOT NULL
+        friend_request_disabled  INT NOT NULL,
+        event            TEXT NOT NULL,
+        eventloginbonus  TEXT NOT NULL,
+        server_data      TEXT NOT NULL
     )");
 }
 
@@ -75,7 +78,7 @@ fn create_acc(uid: i64, login: &str) {
     new_user["user"]["id"] = uid.into();
     new_user["stamina"]["last_updated_time"] = global::timestamp().into();
     
-    DATABASE.lock_and_exec("INSERT INTO users (user_id, userdata, userhome, missions, loginbonus, sifcards, friends, friend_request_disabled) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)", params!(
+    DATABASE.lock_and_exec("INSERT INTO users (user_id, userdata, userhome, missions, loginbonus, sifcards, friends, friend_request_disabled, event, eventloginbonus, server_data) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11)", params!(
         uid,
         json::stringify(new_user),
         include_str!("new_user_home.json"),
@@ -83,7 +86,10 @@ fn create_acc(uid: i64, login: &str) {
         format!(r#"{{"last_rewarded": 0, "bonus_list": [], "start_time": {}}}"#, global::timestamp()),
         "[]",
         r#"{"friend_user_id_list":[],"request_user_id_list":[],"pending_user_id_list":[]}"#,
-        0
+        0,
+        include_str!("new_user_event.json"),
+        format!(r#"{{"last_rewarded": 0, "bonus_list": [], "start_time": {}}}"#, global::timestamp()),
+        "{}"
     ));
     
     DATABASE.lock_and_exec("DELETE FROM tokens WHERE token=?1", params!(login));
@@ -175,6 +181,16 @@ pub fn get_acc_sif(auth_key: &str) -> JsonValue {
 pub fn get_acc_friends(auth_key: &str) -> JsonValue {
     get_data(auth_key, "friends")
 }
+pub fn get_acc_event(auth_key: &str) -> JsonValue {
+    let event = get_data(auth_key, "event");
+    if event.is_empty() {
+        return json::parse(include_str!("new_user_event.json")).unwrap();
+    }
+    event
+}
+pub fn get_acc_eventlogin(auth_key: &str) -> JsonValue {
+    get_data(auth_key, "eventloginbonus")
+}
 
 pub fn save_data(auth_key: &str, row: &str, data: JsonValue) {
     let key = get_key(&auth_key);
@@ -198,6 +214,12 @@ pub fn save_acc_loginbonus(auth_key: &str, data: JsonValue) {
 pub fn save_acc_friends(auth_key: &str, data: JsonValue) {
     save_data(auth_key, "friends", data);
 }
+pub fn save_acc_event(auth_key: &str, data: JsonValue) {
+    save_data(auth_key, "event", data);
+}
+pub fn save_acc_eventlogin(auth_key: &str, data: JsonValue) {
+    save_data(auth_key, "eventloginbonus", data);
+}
 
 fn generate_salt() -> Vec<u8> {
     let mut rng = rand::thread_rng();

src/router/userdata/new_user_event.json

@@ -0,0 +1,24 @@
+{
+    "event_data": {
+        "point_ranking": {
+            "point": 0
+        },
+        "score_ranking": [],
+        "member_ranking": [],
+        "lottery_box": [],
+        "mission_list": [],
+        "policy_agreement": 0,
+        "incentive_lottery": 0,
+        "star_event": {
+            "star_level": 0,
+            "last_event_star_level": 0,
+            "star_music_list": [],
+            "music_change_count": 0,
+            "star_event_bonus_daily_count": 0,
+            "star_event_bonus_count": 0,
+            "star_event_play_times_bonus_count": 0,
+            "star_assist_bonus": 1
+        }
+    },
+    "server_event_data": {}
+}