mirror of
https://git.ethanthesleepy.one/ethanaobrien/ew
synced 2026-08-26 15:02:18 +08:00
853 lines
32 KiB
Rust
853 lines
32 KiB
Rust
use jzon::{array, object, JsonValue};
|
|
use actix_web::{web, HttpRequest, Responder};
|
|
use rand::RngExt;
|
|
use lazy_static::lazy_static;
|
|
|
|
use crate::router::{databases, global, items, userdata, Login, Session, Api};
|
|
use crate::router::clear_rate::live_completed;
|
|
use crate::router::tools::guest;
|
|
|
|
pub fn routes(cfg: &mut web::ServiceConfig) {
|
|
cfg.service(
|
|
web::scope("/live")
|
|
.route("/guest", web::post().to(guest))
|
|
.route("/mission", web::post().to(mission))
|
|
.route("/ranking", web::post().to(crate::router::clear_rate::ranking))
|
|
.route("/clearRate", web::get().to(crate::router::clear_rate::clearrate))
|
|
.route("/start", web::post().to(start))
|
|
.route("/end", web::post().to(end))
|
|
.route("/skip", web::post().to(skip))
|
|
.route("/retire", web::post().to(retire))
|
|
.route("/continue", web::post().to(continuee))
|
|
.route("/reward", web::post().to(reward))
|
|
);
|
|
}
|
|
|
|
|
|
async fn retire(Session { key, body }: Session) -> impl Responder {
|
|
live_retire(&key, &body);
|
|
if body["live_score"]["play_time"].as_i64().unwrap_or(0) > 5 {
|
|
live_completed(body["master_live_id"].as_i64().unwrap(), body["level"].as_i32().unwrap(), true, 0, 0);
|
|
}
|
|
Api(Some(object!{
|
|
"stamina": {},
|
|
"item_list": [],
|
|
"event_point_list": []
|
|
}))
|
|
}
|
|
|
|
async fn reward(Session { key, body }: Session) -> impl Responder {
|
|
let user = userdata::get_acc(&key);
|
|
let live_id = body["master_live_id"].as_i64().unwrap();
|
|
let cleared = get_clear_count(live_id, &user) > 0;
|
|
|
|
let mut ensured_list = array![];
|
|
let mut random_list = array![];
|
|
for data in databases::CLEAR_REWARD.members() {
|
|
if data["masterLiveId"].as_i64().unwrap() != live_id {
|
|
continue;
|
|
}
|
|
if data["getableCount"].as_i64().unwrap() == 0 {
|
|
continue;
|
|
}
|
|
let entry = object!{
|
|
master_live_clear_reward_id: data["id"].clone(),
|
|
type: data["type"].clone(),
|
|
value: data["value"].clone(),
|
|
amount: data["amount"].clone(),
|
|
getable_count: data["getableCount"].clone(),
|
|
received_count: if data["type"] == 1 && cleared { 1 } else { 0 }
|
|
};
|
|
if data["type"] == 1 {
|
|
ensured_list.push(entry).unwrap();
|
|
} else {
|
|
random_list.push(entry).unwrap();
|
|
}
|
|
}
|
|
|
|
Api(Some(object!{
|
|
"ensured_list": ensured_list,
|
|
"random_list": random_list
|
|
}))
|
|
}
|
|
|
|
fn random_number(lowest: usize, highest: usize) -> usize {
|
|
if lowest == highest {
|
|
return lowest;
|
|
}
|
|
assert!(lowest < highest);
|
|
|
|
rand::rng().random_range(lowest..highest + 1)
|
|
}
|
|
|
|
async fn guest(req: HttpRequest, Login(key): Login) -> impl Responder {
|
|
let custom_cards = crate::router::card::client_supports_custom_cards(&req);
|
|
let user_id = userdata::get_acc(&key)["user"]["id"].as_i64().unwrap();
|
|
let friends = userdata::get_acc_friends(&key);
|
|
let user = userdata::get_acc(&key);
|
|
|
|
let mut guest_list = array![];
|
|
if user["tutorial_step"].as_i32().unwrap() != 130 {
|
|
guest_list.push(object!{
|
|
"user": {
|
|
"name": "A VERY Nice Guest",
|
|
"comment": "Enjoy your first live show!",
|
|
"exp": 900,
|
|
"main_deck_slot": 1,
|
|
"favorite_master_card_id": 10010013,
|
|
"favorite_card_evolve": 0,
|
|
"guest_smile_master_card_id": 10010013,
|
|
"guest_cool_master_card_id": 10010013,
|
|
"guest_pure_master_card_id": 10010013,
|
|
"friend_request_disabled": 1,
|
|
"master_title_ids": [3000001,0],
|
|
"profile_settings": [1,2,3,4,5,6,7],
|
|
"last_login_time": 1708699449
|
|
},
|
|
"favorite_card": {
|
|
"id": 0,
|
|
"master_card_id": 10010013,
|
|
"exp": 1025,
|
|
"skill_exp": 0,
|
|
"evolve": []
|
|
},
|
|
"guest_smile_card": {
|
|
"id": 0,
|
|
"master_card_id": 10010013,
|
|
"exp": 1025,
|
|
"skill_exp": 0,
|
|
"evolve": []
|
|
},
|
|
"guest_cool_card": {
|
|
"id": 0,
|
|
"master_card_id": 10010013,
|
|
"exp": 1025,
|
|
"skill_exp": 0,
|
|
"evolve": []
|
|
},
|
|
"guest_pure_card": {
|
|
"id": 0,
|
|
"master_card_id": 10010013,
|
|
"exp": 1025,
|
|
"skill_exp": 0,
|
|
"evolve": []
|
|
},
|
|
"status":0
|
|
}).unwrap();
|
|
} else {
|
|
if !friends["friend_user_id_list"].is_empty() {
|
|
guest_list.push(guest::get_user(friends["friend_user_id_list"][random_number(0, friends["friend_user_id_list"].len() - 1)].as_i64().unwrap(), &friends, guest::UserView::Card, custom_cards)).unwrap();
|
|
}
|
|
let expected: usize = 5;
|
|
if guest_list.len() < expected {
|
|
let mut random = userdata::get_random_uids((expected-guest_list.len()) as i32);
|
|
let index = random.members().position(|r| *r.to_string() == user_id.to_string());
|
|
if index.is_some() {
|
|
random.array_remove(index.unwrap());
|
|
}
|
|
|
|
for uid in random.members() {
|
|
let guest = guest::get_user(uid.as_i64().unwrap(), &friends, guest::UserView::Card, custom_cards);
|
|
if guest["user"]["friend_request_disabled"] == 1 || guest.is_empty() {
|
|
continue;
|
|
}
|
|
guest_list.push(guest).unwrap();
|
|
}
|
|
}
|
|
if guest_list.is_empty() {
|
|
guest_list.push(object!{
|
|
"user": {
|
|
"name": "A sad Guest",
|
|
"comment": "Cant believe you're the only person on this server!",
|
|
"exp": 900,
|
|
"main_deck_slot": 1,
|
|
"favorite_master_card_id": 10010013,
|
|
"favorite_card_evolve": 0,
|
|
"guest_smile_master_card_id": 10010013,
|
|
"guest_cool_master_card_id": 10010013,
|
|
"guest_pure_master_card_id": 10010013,
|
|
"friend_request_disabled": 1,
|
|
"master_title_ids": [3000001,0],
|
|
"profile_settings": [1,2,3,4,5,6,7],
|
|
"last_login_time": 1708699449
|
|
},
|
|
"favorite_card": {
|
|
"id": 0,
|
|
"master_card_id": 10010013,
|
|
"exp": 1025,
|
|
"skill_exp": 0,
|
|
"evolve": []
|
|
},
|
|
"guest_smile_card": {
|
|
"id": 0,
|
|
"master_card_id": 10010013,
|
|
"exp": 1025,
|
|
"skill_exp": 0,
|
|
"evolve": []
|
|
},
|
|
"guest_cool_card": {
|
|
"id": 0,
|
|
"master_card_id": 10010013,
|
|
"exp": 1025,
|
|
"skill_exp": 0,
|
|
"evolve": []
|
|
},
|
|
"guest_pure_card": {
|
|
"id": 0,
|
|
"master_card_id": 10010013,
|
|
"exp": 1025,
|
|
"skill_exp": 0,
|
|
"evolve": []
|
|
},
|
|
"status":0
|
|
}).unwrap();
|
|
}
|
|
}
|
|
|
|
Api(Some(object!{
|
|
"guest_list": guest_list
|
|
}))
|
|
}
|
|
|
|
async fn mission() -> impl Responder {
|
|
//todo
|
|
Api(Some(object!{
|
|
"score_ranking": "",
|
|
"combo_ranking": "",
|
|
"clear_count_ranking": ""
|
|
}))
|
|
}
|
|
|
|
fn check_for_stale_data(server_data: &mut JsonValue, live_id: i64) {
|
|
let mut expired = array![];
|
|
let curr_time = global::timestamp();
|
|
for (i, live) in server_data["last_live_started"].members().enumerate() {
|
|
if live["expire_date_time"].as_u64().unwrap() < curr_time || live["master_live_id"] == live_id {
|
|
expired.push(i).unwrap();
|
|
}
|
|
if live["expire_date_time"].as_u64().unwrap() < curr_time {
|
|
// User closed game after losing. Count this as a fail.
|
|
live_completed(live["master_live_id"].as_i64().unwrap(), live["level"].as_i32().unwrap(), true, 0, 0);
|
|
}
|
|
}
|
|
for i in expired.members() {
|
|
server_data["last_live_started"].array_remove(i.as_usize().unwrap());
|
|
}
|
|
}
|
|
|
|
fn get_end_live_deck_id(login_token: &str, body: &JsonValue) -> Option<i32> {
|
|
let mut server_data = userdata::get_server_data(login_token);
|
|
if server_data["last_live_started"].is_null() {
|
|
server_data["last_live_started"] = array![];
|
|
}
|
|
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]["deck_slot"].as_i32()?;
|
|
|
|
check_for_stale_data(&mut server_data, body["master_live_id"].as_i64().unwrap());
|
|
userdata::save_server_data(login_token, server_data);
|
|
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());
|
|
userdata::save_server_data(login_token, server_data);
|
|
}
|
|
|
|
fn start_live(login_token: &str, body: &JsonValue) {
|
|
let mut server_data = userdata::get_server_data(login_token);
|
|
if server_data["last_live_started"].is_null() {
|
|
server_data["last_live_started"] = array![];
|
|
}
|
|
check_for_stale_data(&mut server_data, body["master_live_id"].as_i64().unwrap());
|
|
let mut to_save = body.clone();
|
|
// The user has 1 hour to complete a live
|
|
to_save["expire_date_time"] = (global::timestamp() + (1 * 60 * 60)).into();
|
|
server_data["last_live_started"].push(to_save).unwrap();
|
|
|
|
userdata::save_server_data(login_token, server_data);
|
|
}
|
|
|
|
async fn start(Session { key, body }: Session) -> impl Responder {
|
|
start_live(&key, &body);
|
|
Api(Some(array![]))
|
|
}
|
|
|
|
pub async fn event_start(Session { key, body }: Session) -> impl Responder {
|
|
start_live(&key, &body);
|
|
Api(Some(array![]))
|
|
}
|
|
|
|
async fn continuee(Login(key): Login) -> impl Responder {
|
|
let mut user = userdata::get_acc(&key);
|
|
|
|
items::remove_gems(&mut user, 100);
|
|
|
|
userdata::save_acc(&key, user.clone());
|
|
|
|
Api(Some(object!{
|
|
gem: user["gem"].clone()
|
|
}))
|
|
}
|
|
|
|
fn get_clear_count(id: i64, user: &JsonValue) -> i64 {
|
|
let mut rv = 0;
|
|
for current in user["live_list"].members() {
|
|
if current["master_live_id"] == id {
|
|
rv += current["clear_count"].as_i64().unwrap();
|
|
}
|
|
}
|
|
rv
|
|
}
|
|
|
|
pub fn update_live_data(user: &mut JsonValue, data: &JsonValue, add: bool) -> JsonValue {
|
|
if user["tutorial_step"].as_i32().unwrap() < 130 {
|
|
return JsonValue::Null;
|
|
}
|
|
|
|
let mut rv = object!{
|
|
"master_live_id": data["master_live_id"].as_i64().unwrap(),
|
|
"level": data["level"].as_i64().unwrap(),
|
|
"clear_count": 1,
|
|
"high_score": data["live_score"]["score"].as_i64().unwrap(),
|
|
"max_combo": data["live_score"]["max_combo"].as_i64().unwrap(),
|
|
"auto_enable": 1, //whats this?
|
|
"updated_time": global::timestamp()
|
|
};
|
|
|
|
let mut has = false;
|
|
for current in user["live_list"].members_mut() {
|
|
if current["master_live_id"] == rv["master_live_id"] && (current["level"] == rv["level"] || data["level"].as_i32().unwrap() == 0) {
|
|
has = true;
|
|
if add {
|
|
rv["clear_count"] = (current["clear_count"].as_i64().unwrap() + 1).into();
|
|
}
|
|
current["clear_count"] = rv["clear_count"].clone();
|
|
|
|
if rv["high_score"].as_i64().unwrap() > current["high_score"].as_i64().unwrap() {
|
|
current["high_score"] = rv["high_score"].clone();
|
|
} else {
|
|
rv["high_score"] = current["high_score"].clone();
|
|
}
|
|
|
|
if rv["max_combo"].as_i64().unwrap() > current["max_combo"].as_i64().unwrap() {
|
|
current["max_combo"] = rv["max_combo"].clone();
|
|
} else {
|
|
rv["max_combo"] = current["max_combo"].clone();
|
|
}
|
|
current["updated_time"] = rv["updated_time"].clone();
|
|
rv["level"] = current["level"].clone();
|
|
if data["level"].as_i32().unwrap() != 0 {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if !has {
|
|
user["live_list"].push(rv.clone()).unwrap()
|
|
}
|
|
rv
|
|
}
|
|
pub fn update_live_mission_data(user: &mut JsonValue, data: &JsonValue) {
|
|
if user["tutorial_step"].as_i32().unwrap() < 130 {
|
|
return;
|
|
}
|
|
|
|
let rv = object!{
|
|
"master_live_id": data["master_live_id"].as_i64().unwrap(),
|
|
"clear_master_live_mission_ids": data["clear_master_live_mission_ids"].clone()
|
|
};
|
|
|
|
for current in user["live_mission_list"].members_mut() {
|
|
if current["master_live_id"] == rv["master_live_id"] {
|
|
for id in data["clear_master_live_mission_ids"].members() {
|
|
if !current["clear_master_live_mission_ids"].contains(id.as_i32().unwrap()) {
|
|
current["clear_master_live_mission_ids"].push(id.as_i32().unwrap()).unwrap();
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
user["live_mission_list"].push(rv.clone()).unwrap();
|
|
}
|
|
|
|
fn get_live_mission_completed_ids(user: &JsonValue, live_id: i64, score: i64, combo: i64, clear_count: i64, level: i64, full_combo: bool, all_perfect: bool) -> Option<JsonValue> {
|
|
let live_info = &databases::LIVE_LIST[live_id.to_string()];
|
|
let mut out = array![];
|
|
let combo_info = &databases::MISSION_COMBO_DATA[live_info["masterMusicId"].to_string()];
|
|
|
|
for data in databases::MISSION_DATA.members() {
|
|
match data["type"].as_i32()? {
|
|
1 => {
|
|
if live_info[&format!("score{}", data["value"])].as_i64()? <= score {
|
|
out.push(data["id"].as_i32()?).ok()?;
|
|
}
|
|
},
|
|
2 => {
|
|
if combo_info["valueList"][data["value"].to_string().parse::<usize>().ok()?].as_i64()? <= combo {
|
|
out.push(data["id"].as_i32()?).ok()?;
|
|
}
|
|
},
|
|
3 => {
|
|
if full_combo && data["level"].as_i64()? == level {
|
|
out.push(data["id"].as_i32()?).ok()?;
|
|
}
|
|
},
|
|
4 => {
|
|
if clear_count >= data["value"].to_string().parse::<i64>().ok()? {
|
|
out.push(data["id"].as_i32()?).ok()?;
|
|
}
|
|
},
|
|
5 => {
|
|
if full_combo && all_perfect && data["level"].as_i64()? == level {
|
|
out.push(data["id"].as_i32()?).ok()?;
|
|
}
|
|
},
|
|
_ => {}
|
|
}
|
|
}
|
|
let mut rv = array![];
|
|
for current in user["live_mission_list"].members() {
|
|
if current["master_live_id"] == live_id {
|
|
for id in out.members() {
|
|
if !current["clear_master_live_mission_ids"].contains(id.as_i32().unwrap()) {
|
|
rv.push(id.as_i32().unwrap()).unwrap();
|
|
}
|
|
}
|
|
return Some(rv);
|
|
}
|
|
}
|
|
Some(out)
|
|
}
|
|
|
|
fn mission_reward_reason(mission_type: i64, jp: bool) -> &'static str {
|
|
match mission_type {
|
|
1 => if jp { "楽曲のスコアランク達成報酬です。" } else { "Song Score Rank reward." },
|
|
2 => if jp { "楽曲のコンボ達成報酬です。" } else { "Song Combo reward." },
|
|
3 => if jp { "楽曲のフルコンボ達成報酬です。" } else { "Song Full Combo reward." },
|
|
_ => if jp { "楽曲のクリア回数達成報酬です。" } else { "Song Clear Count reward." },
|
|
}
|
|
}
|
|
|
|
fn give_mission_rewards(user: &mut JsonValue, home: &mut JsonValue, missions: &JsonValue, user_missions: &mut JsonValue, cleared_missions: &mut JsonValue, chats: &mut JsonValue, multiplier: i64, jp: bool) -> JsonValue {
|
|
let mut rv = array![];
|
|
for data in databases::MISSION_DATA.members() {
|
|
if !missions.contains(data["id"].as_i32().unwrap()) {
|
|
continue;
|
|
}
|
|
if data["masterLiveMissionRewardId"].as_i64().unwrap() == 0 {
|
|
continue;
|
|
}
|
|
let reward = databases::MISSION_REWARD_DATA[data["masterLiveMissionRewardId"].to_string()].clone();
|
|
let reason = mission_reward_reason(data["type"].as_i64().unwrap_or(0), jp);
|
|
items::gift_item_basic(reward["value"].as_i32().unwrap(), reward["amount"].as_i64().unwrap(), reward["type"].as_i32().unwrap(), reason, home);
|
|
}
|
|
if items::give_gift_basic(3, 16005001, 5 * multiplier, user, user_missions, cleared_missions, chats) {
|
|
rv.push(object!{"type":3,"value":16005001,"level":0,"amount":5 * multiplier}).unwrap();
|
|
}
|
|
if items::give_gift_basic(3, 17001001, 1, user, user_missions, cleared_missions, chats) {
|
|
rv.push(object!{"type":3,"value":17001001,"level":0,"amount":1}).unwrap();
|
|
}
|
|
rv
|
|
}
|
|
pub fn get_master_num(id: i64) -> i64 {
|
|
let id = id.to_string();
|
|
let mut masterid = 0;
|
|
if id.starts_with('2') {
|
|
masterid += 9;
|
|
} else if id.starts_with('3') {
|
|
masterid += 9 + 9;
|
|
} else if id.starts_with('4') {
|
|
masterid += 9 + 9 + 12;
|
|
}
|
|
masterid
|
|
}
|
|
|
|
pub fn get_master_id(id: i64) -> i64 {
|
|
get_master_num(id) + id.to_string().char_indices().last().unwrap().1.to_string().parse::<i64>().unwrap()
|
|
}
|
|
|
|
const MAX_BOND: i64 = 500000;
|
|
|
|
lazy_static! {
|
|
static ref BOND_WEIGHT: JsonValue = {
|
|
array![1, 1, 2, 2, 5, 2, 2, 1, 1]
|
|
};
|
|
static ref CHATS: JsonValue = {
|
|
array![1, 1000, 2000, 3500, 5000, 6000, 7000, 8000, 9000, 10000, 11000, 12500, 13000, 13500, 15000]
|
|
};
|
|
}
|
|
|
|
fn character_bond(character_list: &JsonValue, character: i64) -> i64 {
|
|
for c in character_list.members() {
|
|
if c["master_character_id"].as_i64() == Some(character) {
|
|
return c["exp"].as_i64().unwrap_or(0);
|
|
}
|
|
}
|
|
0
|
|
}
|
|
|
|
fn set_character_bond(character_list: &mut JsonValue, character: i64, exp: i64) {
|
|
for c in character_list.members_mut() {
|
|
if c["master_character_id"].as_i64() == Some(character) {
|
|
c["exp"] = exp.into();
|
|
return;
|
|
}
|
|
}
|
|
character_list.push(object!{
|
|
master_character_id: character,
|
|
exp: exp
|
|
}).unwrap();
|
|
}
|
|
|
|
fn get_live_character_list(lp_used: i32, deck_id: i32, user: &mut JsonValue, missions: &mut JsonValue, completed_missions: &mut JsonValue, chats: &mut JsonValue) -> JsonValue {
|
|
let card_list = user["card_list"].clone();
|
|
let deck = user["deck_list"][(deck_id - 1) as usize]["main_card_ids"].clone();
|
|
let tutorial_step = user["tutorial_step"].as_i32().unwrap();
|
|
let mut character_list = user["character_list"].clone();
|
|
|
|
// [1,1,2,2,5,2,2,1,1]
|
|
let mut chars: Vec<i64> = vec![];
|
|
let mut gains: Vec<i64> = vec![];
|
|
for data in card_list.members() {
|
|
let id = data["id"].as_i64().unwrap_or(0);
|
|
let mcid = data["master_card_id"].as_i64().unwrap_or(0);
|
|
let index = match deck.members().position(|r| r.as_i64() == Some(id) || r.as_i64() == Some(mcid)) {
|
|
Some(x) => x,
|
|
None => continue
|
|
};
|
|
let character = match databases::CARD_LIST[mcid.to_string()]["masterCharacterId"].as_i64() {
|
|
Some(c) => c,
|
|
None => continue
|
|
};
|
|
// Tutorial lives award no bond.
|
|
let weight = if tutorial_step >= 130 {
|
|
BOND_WEIGHT[index].as_i64().unwrap_or(0) * (lp_used as i64 / 10)
|
|
} else {
|
|
0
|
|
};
|
|
if let Some(p) = chars.iter().position(|c| *c == character) {
|
|
gains[p] += weight;
|
|
} else {
|
|
chars.push(character);
|
|
gains.push(weight);
|
|
}
|
|
}
|
|
|
|
let mut rv = array![];
|
|
for (idx, &character) in chars.iter().enumerate() {
|
|
let before = character_bond(&character_list, character);
|
|
let after = (before + gains[idx]).min(MAX_BOND);
|
|
set_character_bond(&mut character_list, character, after);
|
|
|
|
if gains[idx] > 0 {
|
|
let mut mission_id = 1158000 + get_master_id(character);
|
|
let mut limit = 1500;
|
|
let mut status = items::get_mission_status(mission_id, missions);
|
|
if status.is_empty() {
|
|
mission_id += 39;
|
|
limit *= 10;
|
|
status = items::get_mission_status(mission_id, missions);
|
|
}
|
|
if status["status"].as_i32().unwrap_or(0) <= 1 {
|
|
let completed = after >= limit;
|
|
if let Some(m) = items::update_mission_status(mission_id, 0, completed, false, gains[idx], missions) {
|
|
completed_missions.push(m).unwrap();
|
|
}
|
|
}
|
|
}
|
|
|
|
rv.push(object!{
|
|
master_character_id: character,
|
|
exp: after,
|
|
before_exp: before
|
|
}).unwrap();
|
|
}
|
|
|
|
if tutorial_step >= 130 {
|
|
for data in rv.members() {
|
|
for chat in CHATS.members() {
|
|
if chat.as_i64().unwrap() > data["exp"].as_i64().unwrap() {
|
|
break;
|
|
}
|
|
if crate::router::chat::add_chat(data["master_character_id"].as_i64().unwrap(), 1, chats) {
|
|
let mission_id = 1958000 + (get_master_id(data["master_character_id"].as_i64().unwrap()) * CHATS.len() as i64);
|
|
items::update_mission_status(mission_id, 0, true, true, 1, missions);
|
|
completed_missions.push(mission_id).unwrap();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
user["character_list"] = character_list;
|
|
rv
|
|
}
|
|
|
|
pub fn live_end(req: &HttpRequest, key: &str, body: &JsonValue, skipped: bool) -> JsonValue {
|
|
let mut user2 = userdata::get_acc_home(&key);
|
|
let mut user = userdata::get_acc(&key);
|
|
let mut user_missions = userdata::get_acc_missions(&key);
|
|
let mut chats = userdata::get_acc_chats(&key);
|
|
|
|
let jp = items::get_region(req.headers());
|
|
let first_clear = !skipped
|
|
&& user["tutorial_step"].as_i32().unwrap() >= 130
|
|
&& get_clear_count(body["master_live_id"].as_i64().unwrap(), &user) == 0;
|
|
|
|
let live = if skipped {
|
|
items::use_item(&object!{
|
|
value: 21000001,
|
|
amount: 1,
|
|
consumeType: 4
|
|
}, body["live_boost"].as_i64().unwrap(), &mut user);
|
|
update_live_data(&mut user, &object!{
|
|
master_live_id: body["master_live_id"].clone(),
|
|
level: 0,
|
|
live_score: {
|
|
score: 1,
|
|
max_combo: 1
|
|
}
|
|
}, false)
|
|
} else {
|
|
update_live_data(&mut user, &body, true)
|
|
};
|
|
|
|
//1273009, 1273010, 1273011, 1273012
|
|
let mut cleared_missions = items::advance_variable_mission(1105001, 1105017, 1, &mut user_missions);
|
|
if body["master_live_id"].to_string().len() > 1 {
|
|
let id = body["master_live_id"].to_string().split("").collect::<Vec<_>>()[2].parse::<i64>().unwrap_or(0);
|
|
if (1..=4).contains(&id) {
|
|
let to_push = items::completed_daily_mission(1273009 + id - 1, &mut user_missions);
|
|
for data in to_push.members() {
|
|
cleared_missions.push(data.as_i32().unwrap()).unwrap();
|
|
}
|
|
}
|
|
}
|
|
|
|
let missions;
|
|
if skipped {
|
|
live_completed(body["master_live_id"].as_i64().unwrap(), live["level"].as_i32().unwrap(), false, live["high_score"].as_i64().unwrap(), user["user"]["id"].as_i64().unwrap());
|
|
let clear_count = get_clear_count(body["master_live_id"].as_i64().unwrap(), &user);
|
|
|
|
missions = get_live_mission_completed_ids(&user, body["master_live_id"].as_i64().unwrap(), live["high_score"].as_i64().unwrap(), live["max_combo"].as_i64().unwrap(), clear_count, live["level"].as_i64().unwrap(), false, false).unwrap_or(array![]);
|
|
} else {
|
|
live_completed(body["master_live_id"].as_i64().unwrap(), body["level"].as_i32().unwrap(), false, body["live_score"]["score"].as_i64().unwrap(), user["user"]["id"].as_i64().unwrap());
|
|
let clear_count = get_clear_count(body["master_live_id"].as_i64().unwrap(), &user);
|
|
|
|
let is_full_combo = (body["live_score"]["good"].as_i32().unwrap_or(1) + body["live_score"]["bad"].as_i32().unwrap_or(1) + body["live_score"]["miss"].as_i32().unwrap_or(1)) == 0;
|
|
|
|
let is_perfect = is_full_combo && body["live_score"]["great"].as_i32().unwrap_or(1) == 0;
|
|
|
|
missions = get_live_mission_completed_ids(&user, body["master_live_id"].as_i64().unwrap(), body["live_score"]["score"].as_i64().unwrap(), body["live_score"]["max_combo"].as_i64().unwrap(), clear_count, body["level"].as_i64().unwrap(), is_full_combo, is_perfect).unwrap_or(array![]);
|
|
|
|
if is_full_combo {
|
|
if items::advance_mission(1176001, 1, 1, &mut user_missions).is_some() {
|
|
cleared_missions.push(1176001).unwrap();
|
|
}
|
|
if items::advance_mission(1176002, 1, 100, &mut user_missions).is_some() {
|
|
cleared_missions.push(1176002).unwrap();
|
|
}
|
|
if items::advance_mission(1176003, 1, 200, &mut user_missions).is_some() {
|
|
cleared_missions.push(1176003).unwrap();
|
|
}
|
|
if items::advance_mission(1176004, 1, 300, &mut user_missions).is_some() {
|
|
cleared_missions.push(1176004).unwrap();
|
|
}
|
|
if items::advance_mission(1176005, 1, 400, &mut user_missions).is_some() {
|
|
cleared_missions.push(1176005).unwrap();
|
|
}
|
|
if items::advance_mission(1176006, 1, 500, &mut user_missions).is_some() {
|
|
cleared_missions.push(1176006).unwrap();
|
|
}
|
|
}
|
|
if is_perfect && items::advance_mission(1177001, 1, 1, &mut user_missions).is_some() {
|
|
cleared_missions.push(1177001).unwrap();
|
|
}
|
|
if is_perfect && body["level"].as_i32().unwrap() == 4 && items::advance_mission(1177002, 1, 1, &mut user_missions).is_some() {
|
|
cleared_missions.push(1177002).unwrap();
|
|
}
|
|
}
|
|
|
|
update_live_mission_data(&mut user, &object!{
|
|
master_live_id: body["master_live_id"].as_i64().unwrap(),
|
|
clear_master_live_mission_ids: missions.clone()
|
|
});
|
|
|
|
let lp_used: i32 = body["use_lp"].as_i32().unwrap_or(10 * body["live_boost"].as_i32().unwrap_or(0));
|
|
|
|
let mut reward_list = give_mission_rewards(&mut user, &mut user2, &missions, &mut user_missions, &mut cleared_missions, &mut chats, (lp_used / 10) as i64, jp);
|
|
|
|
items::lp_modification(&mut user, lp_used as u64, true);
|
|
|
|
items::give_exp(lp_used, &mut user, &mut user_missions, &mut cleared_missions);
|
|
|
|
items::give_points(1, 75 * lp_used as i64, &mut user, &mut user_missions, &mut cleared_missions);
|
|
|
|
if first_clear {
|
|
items::give_primogems(60, &mut user);
|
|
user["gem"]["total"] = (user["gem"]["charge"].as_i64().unwrap() + user["gem"]["free"].as_i64().unwrap()).into();
|
|
reward_list.push(object!{
|
|
type: 1,
|
|
value: 1,
|
|
level: 0,
|
|
amount: 60,
|
|
drop_info: {
|
|
first_reward: 1,
|
|
getable_count: 1,
|
|
remaining_getable_count: 0
|
|
}
|
|
}).unwrap();
|
|
}
|
|
|
|
let deck_slot = get_end_live_deck_id(&key, &body).unwrap_or(body["deck_slot"].as_i32().unwrap_or(user["user"]["main_deck_slot"].as_i32().unwrap()));
|
|
let characters = get_live_character_list(lp_used, deck_slot, &mut user, &mut user_missions, &mut cleared_missions, &mut chats);
|
|
|
|
userdata::save_acc(&key, user.clone());
|
|
userdata::save_acc_home(&key, user2.clone());
|
|
userdata::save_acc_missions(&key, user_missions);
|
|
userdata::save_acc_chats(&key, chats);
|
|
|
|
let mut rv = object!{
|
|
"item_list": user["item_list"].clone(),
|
|
"point_list": user["point_list"].clone(),
|
|
"live": live.clone(),
|
|
"clear_master_live_mission_ids": missions,
|
|
"user": user["user"].clone(),
|
|
"stamina": user["stamina"].clone(),
|
|
"character_list": characters,
|
|
"reward_list": reward_list,
|
|
"gift_list": user2["home"]["gift_list"].clone(),
|
|
"clear_mission_ids": cleared_missions,
|
|
"event_point_reward_list": [],
|
|
"ranking_change": [],
|
|
"event_member": [],
|
|
"event_ranking_data": []
|
|
};
|
|
if first_clear {
|
|
rv["gem"] = user["gem"].clone();
|
|
}
|
|
if skipped {
|
|
rv["high_score"] = live["high_score"].clone();
|
|
}
|
|
rv
|
|
}
|
|
|
|
async fn end(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
|
|
Api(Some(live_end(&req, &key, &body, false)))
|
|
}
|
|
|
|
async fn skip(req: HttpRequest, Session { key, body }: Session) -> impl Responder {
|
|
Api(Some(live_end(&req, &key, &body, true)))
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use actix_web::test::TestRequest;
|
|
|
|
const STOCK_LIVE_ID: i64 = 1100101;
|
|
|
|
fn register_account(token: &str) {
|
|
let mut user = userdata::get_acc(token);
|
|
user["tutorial_step"] = 130.into();
|
|
userdata::save_acc(token, user);
|
|
}
|
|
|
|
fn record_clear(token: &str, live_id: i64, level: i64, score: i64, combo: i64) {
|
|
let mut user = userdata::get_acc(token);
|
|
update_live_data(&mut user, &object!{
|
|
master_live_id: live_id,
|
|
level: level,
|
|
live_score: { score: score, max_combo: combo }
|
|
}, true);
|
|
userdata::save_acc(token, user);
|
|
}
|
|
|
|
fn pulled_clear_count(token: &str, live_id: i64) -> i64 {
|
|
get_clear_count(live_id, &userdata::get_acc(token))
|
|
}
|
|
|
|
#[test]
|
|
fn clear_count_persists_with_custom_songs_disabled() {
|
|
let _lock = crate::runtime::lock_test_data_path();
|
|
crate::runtime::set_enable_custom_songs(false);
|
|
|
|
let token = "cc_control_disabled";
|
|
register_account(token);
|
|
|
|
record_clear(token, STOCK_LIVE_ID, 4, 500000, 320);
|
|
assert_eq!(pulled_clear_count(token, STOCK_LIVE_ID), 1);
|
|
|
|
record_clear(token, STOCK_LIVE_ID, 4, 480000, 300);
|
|
assert_eq!(pulled_clear_count(token, STOCK_LIVE_ID), 2);
|
|
|
|
let user = userdata::get_acc(token);
|
|
let live = user["live_list"].members().find(|l| l["master_live_id"] == STOCK_LIVE_ID).unwrap();
|
|
assert_eq!(live["clear_count"], 2);
|
|
assert_eq!(live["high_score"], 500000);
|
|
}
|
|
|
|
#[test]
|
|
fn clear_count_survives_custom_songs_enabled() {
|
|
let _lock = crate::runtime::lock_test_data_path();
|
|
crate::runtime::set_enable_custom_songs(true);
|
|
|
|
let token = "cc_custom_enabled";
|
|
register_account(token);
|
|
|
|
record_clear(token, STOCK_LIVE_ID, 4, 500000, 320);
|
|
assert_eq!(pulled_clear_count(token, STOCK_LIVE_ID), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn custom_song_cleanup_keeps_stock_lives() {
|
|
let _lock = crate::runtime::lock_test_data_path();
|
|
crate::runtime::set_enable_custom_songs(true);
|
|
|
|
let token = "cc_mixed_ids";
|
|
register_account(token);
|
|
|
|
record_clear(token, STOCK_LIVE_ID, 4, 500000, 320);
|
|
record_clear(token, crate::database::custom_song::FIRST_MUSIC_ID, 1, 100, 10);
|
|
|
|
let user = userdata::get_acc(token);
|
|
assert_eq!(get_clear_count(STOCK_LIVE_ID, &user), 1);
|
|
}
|
|
|
|
fn asset_gate(version: &str, platform: &str, hash: &str) -> Option<i32> {
|
|
let mut rb = TestRequest::default()
|
|
.insert_header(("aoharu-asset-version", version.to_string()))
|
|
.insert_header(("aoharu-platform", platform.to_string()));
|
|
if !hash.is_empty() {
|
|
rb = rb.insert_header(("aoharu-asset-hash", hash.to_string()));
|
|
}
|
|
let req = rb.to_http_request();
|
|
global::check_asset_headers(req.headers(), true)
|
|
}
|
|
|
|
#[test]
|
|
fn asset_gate_is_platform_conditional() {
|
|
let _lock = crate::runtime::lock_test_data_path();
|
|
let current = "ced44f266b4e4c8eb05fe417fd5f3d1b";
|
|
let stock = "4c921d2443335e574a82e04ec9ea243c";
|
|
|
|
assert_eq!(asset_gate(current, "Windows", ""), None);
|
|
assert_eq!(asset_gate(current, "android", ""), None);
|
|
assert_eq!(asset_gate(current, "ios", ""), None);
|
|
|
|
assert_eq!(asset_gate(stock, "android", ""), None);
|
|
assert_eq!(asset_gate(stock, "ios", ""), None);
|
|
assert_eq!(asset_gate(stock, "Windows", ""), None);
|
|
}
|
|
}
|