mirror of
https://github.com/asphyxia-core/plugins.git
synced 2026-03-24 02:44:38 -05:00
c17ee88eff
Add support for Cat Progress(Stair) Add/Fix some fields that Forte needs. Add Missing RouteHandler that causing massive reqs. And Fix saving issue too. This is not tested on Op.2. Should test it between games.
618 lines
20 KiB
TypeScript
618 lines
20 KiB
TypeScript
// import { EAHandler } from '../../util/EAHandler';
|
|
// import { get, _.isArray } from 'lodash';
|
|
// import { Logger } from '../../util/Logger';
|
|
import { Profile } from '../models/profile';
|
|
import { Scores } from '../models/scores';
|
|
import { permitted_list, forte_permitted_list } from './common';
|
|
// import { getValue, getArray, getAttr, getStr, getBigInt } from '../../util/Helper';
|
|
|
|
|
|
// export const event_list = {
|
|
// event: {
|
|
// '@attr': {
|
|
// index: 1,
|
|
// },
|
|
// 'status': K.ITEM('s8', 1),
|
|
// 'start_time': K.ITEM('u64', BigInt(0)),
|
|
// 'end_time': K.ITEM('u64', BigInt(0)),
|
|
// },
|
|
// };
|
|
|
|
const getEventInfo = (isForte: boolean) => {
|
|
const event: any[] = [];
|
|
const event_num = isForte ? 10 : 17
|
|
for (let i = 1; i <= event_num; ++i) {
|
|
event.push({
|
|
type: K.ITEM('s32', 4),
|
|
index: K.ITEM('s32', i),
|
|
status: K.ITEM('s8', 1),
|
|
start_time: K.ITEM('u64', BigInt(0)),
|
|
end_time: K.ITEM('u64', BigInt(0)),
|
|
param1: K.ITEM('u64', BigInt(0)),
|
|
param2: K.ITEM('u64', BigInt(0)),
|
|
});
|
|
}
|
|
return event;
|
|
};
|
|
|
|
const getPlayerData = async (refid: string, info: EamuseInfo, name?: string) => {
|
|
const p = await readProfile(refid);
|
|
const isForte = !info.method.includes("op")
|
|
|
|
if (name && name.length > 0) {
|
|
p.name = name;
|
|
await writeProfile(refid, p);
|
|
}
|
|
|
|
const param: any[] = [];
|
|
for (const t in p.params) {
|
|
const para = p.params[t];
|
|
param.push(K.ATTR({type: t}, {
|
|
count: K.ITEM('s32', para.length),
|
|
params_array: K.ARRAY('s32', para),
|
|
}));
|
|
}
|
|
|
|
const brooch: any[] = [];
|
|
for (const b in p.brooches) {
|
|
if (isForte && parseInt(b, 10) > 147) continue; // Forte Brooch is ~147.
|
|
const bData = p.brooches[b];
|
|
brooch.push(K.ATTR({ index: b }, {
|
|
watch_count: K.ITEM('s32', bData.watch),
|
|
level: K.ITEM('s8', bData.level),
|
|
invested_steps: K.ITEM('s32', bData.steps),
|
|
is_new_brooch: K.ITEM('bool', bData.new),
|
|
}));
|
|
}
|
|
|
|
// Unlock brooches
|
|
for (let i = 101; i <= 124; ++i) {
|
|
brooch.push(K.ATTR({ index: `${i}` }, {
|
|
'watch_count': K.ITEM('s32', 0),
|
|
'level': K.ITEM('s8', 1),
|
|
'invested_steps': K.ITEM('s32', 0),
|
|
'is_new_brooch': K.ITEM('bool', 0),
|
|
}));
|
|
}
|
|
|
|
// Forte
|
|
const stairs: any[] = [];
|
|
for (const s in (p.cat_stairs || defaultProfile.cat_stairs)) {
|
|
const stair = (p.cat_stairs || defaultProfile.cat_stairs)[s];
|
|
|
|
stairs.push(K.ATTR({ index: s }, {
|
|
total_steps: K.ITEM("s32", stair.total),
|
|
chapter_index: K.ITEM("s32", stair.index),
|
|
chapter_steps: K.ITEM("s32", stair.steps),
|
|
chapter_goal: K.ITEM("s32", stair.goal)
|
|
}));
|
|
}
|
|
|
|
// >= Op2
|
|
const kentei_record: any[] = [];
|
|
for (const k in p.kentei) {
|
|
const kentei = p.kentei[k];
|
|
|
|
kentei_record.push({
|
|
stage_prog: K.ITEM('s8', kentei.stage),
|
|
kentei_index: K.ITEM('s32', parseInt(k, 10)),
|
|
score: K.ARRAY('s32', kentei.score),
|
|
clear_rate: K.ITEM('s32', kentei.rate),
|
|
clear_flag: K.ITEM('u32', kentei.flag),
|
|
play_count: K.ITEM('s32', kentei.count),
|
|
});
|
|
}
|
|
|
|
// >= Op2
|
|
const island_progress: any[] = [];
|
|
for (const i in p.islands) {
|
|
const island = p.islands[i];
|
|
|
|
const container: any[] = [];
|
|
for (const c in island.containers) {
|
|
const cont = island.containers[c];
|
|
|
|
const reward: any[] = [];
|
|
for (const r in cont.rewards) {
|
|
const rew = cont.rewards[r];
|
|
|
|
reward.push({
|
|
reward_index: K.ITEM('s32', parseInt(r, 10)),
|
|
point: K.ITEM('s32', rew),
|
|
});
|
|
}
|
|
|
|
container.push({
|
|
container_no: K.ITEM('s32', parseInt(c, 10)),
|
|
movie_prog: K.ITEM('s8', cont.prog),
|
|
reward,
|
|
});
|
|
}
|
|
|
|
island_progress.push(K.ATTR({ index: i }, {
|
|
lookUnlockWin: K.ITEM('s32', island.look),
|
|
select_container: K.ITEM('s32', island.select),
|
|
travelledTime: K.ITEM('u32', island.time),
|
|
container,
|
|
}));
|
|
}
|
|
|
|
const correct_permitted_list = !isForte ? permitted_list : forte_permitted_list
|
|
const correct_music_list = !isForte ? [
|
|
K.ARRAY('s32', p.musicList.type_0, { sheet_type: '0' }),
|
|
K.ARRAY('s32', p.musicList.type_1, { sheet_type: '1' }),
|
|
K.ARRAY('s32', p.musicList.type_2, { sheet_type: '2' }),
|
|
K.ARRAY('s32', p.musicList.type_3, { sheet_type: '3' }),
|
|
] : [
|
|
K.ARRAY('s32', p.musicList.type_0, { sheet_type: '0' }),
|
|
K.ARRAY('s32', p.musicList.type_1, { sheet_type: '1' }),
|
|
K.ARRAY('s32', p.musicList.type_2, { sheet_type: '2' }),
|
|
];
|
|
const correct_music_list2 = !isForte ? [
|
|
K.ARRAY('s32', p.musicList2.type_0, { sheet_type: '0' }),
|
|
K.ARRAY('s32', p.musicList2.type_1, { sheet_type: '1' }),
|
|
K.ARRAY('s32', p.musicList2.type_2, { sheet_type: '2' }),
|
|
K.ARRAY('s32', p.musicList2.type_3, { sheet_type: '3' }),
|
|
] : [
|
|
K.ARRAY('s32', p.musicList2.type_0, { sheet_type: '0' }),
|
|
K.ARRAY('s32', p.musicList2.type_1, { sheet_type: '1' }),
|
|
K.ARRAY('s32', p.musicList2.type_2, { sheet_type: '2' }),
|
|
];
|
|
|
|
return {
|
|
name: K.ITEM('str', p.name),
|
|
play_count: K.ITEM('s32', p.playCount),
|
|
today_play_count: K.ITEM('s32', p.todayPlayCount),
|
|
permitted_list: correct_permitted_list,
|
|
event_info_list: { event: getEventInfo(isForte) }, // Op2
|
|
event_control_list: { event: getEventInfo(isForte) }, // Forte
|
|
music_list: {
|
|
flag: correct_music_list,
|
|
},
|
|
free_for_play_music_list: {
|
|
flag:correct_music_list2,
|
|
},
|
|
last: {
|
|
music_index: K.ITEM('s32', forteNumericHandler(p.music, 195, 0)),
|
|
sheet_type: K.ITEM('s8', forteNumericHandler(p.sheet, 3, 0)),
|
|
brooch_index: K.ITEM('s32', forteNumericHandler(p.brooch, 147, 0)),
|
|
hi_speed_level: K.ITEM('s32', p.hispeed),
|
|
beat_guide: K.ITEM('s8', p.beatGuide),
|
|
headphone_volume: K.ITEM('s8', p.headphone),
|
|
judge_bar_pos: K.ITEM('s32', p.judgeBar),
|
|
music_group: K.ITEM('s32', p.group),
|
|
hands_mode: isForte ? K.ITEM('s32', p.mode) : K.ITEM('s8', p.mode),
|
|
near_setting: K.ITEM('s8', p.near),
|
|
judge_delay_offset: isForte ? K.ITEM('s32', p.offset) : K.ITEM('s8', p.offset),
|
|
bingo_index: K.ITEM('s32', p.bingo),
|
|
total_skill_value: K.ITEM('u64', BigInt(p.skill)),
|
|
key_beam_level: K.ITEM('s8', p.keyBeam),
|
|
orbit_type: K.ITEM('s8', p.orbit),
|
|
note_height: K.ITEM('s8', p.noteHeight),
|
|
note_width: K.ITEM('s8', p.noteWidth),
|
|
judge_width_type: K.ITEM('s8', p.judgeWidth),
|
|
beat_guide_volume: K.ITEM('s8', p.beatVolume),
|
|
beat_guide_type: K.ITEM('s8', p.beatType),
|
|
key_volume_offset: K.ITEM('s8', p.keyVolume),
|
|
bgm_volume_offset: K.ITEM('s8', p.bgmVolume),
|
|
note_disp_type: K.ITEM('s8', p.note),
|
|
slow_fast: K.ITEM('s8', p.sf),
|
|
judge_effect_adjust: K.ITEM('s8', p.judgeFX),
|
|
simple_bg: K.ITEM('s8', p.simple),
|
|
},
|
|
// TODO: Full unlock instead of saving?
|
|
cat_progress: {
|
|
stair: stairs
|
|
},
|
|
brooch_list: { brooch },
|
|
extra_param: { param },
|
|
present_list: {},
|
|
various_music_list: {
|
|
data: [
|
|
K.ATTR({ list_type: '0' }, {
|
|
cond_flag: K.ITEM('s32', 0),
|
|
flag: K.ITEM('s32', 0, { sheet_type: '0' }),
|
|
}),
|
|
],
|
|
},
|
|
island_progress_list: { island_progress },
|
|
player_information_list: {},
|
|
kentei_record_list: { kentei_record },
|
|
linkage_data_list: {},
|
|
travel: {
|
|
money: K.ITEM('s32', p.money),
|
|
fame: K.ITEM('s32', p.fame),
|
|
fame_index: K.ITEM('s32', p.fameId),
|
|
island_id: K.ITEM('s32', p.island),
|
|
},
|
|
};
|
|
};
|
|
|
|
export const regist_playdata: EPR = async (info, data, send) => {
|
|
const refid = $(data).str('refid');
|
|
if (!refid) return send.deny();
|
|
|
|
const name = $(data).str('name');
|
|
console.debug(`nos op2 regist: ${name}`);
|
|
|
|
send.object(await getPlayerData(refid, info, name));
|
|
};
|
|
|
|
export const get_playdata: EPR = async (info, data, send) => {
|
|
const refid = $(data).str('refid');
|
|
if (!refid) return send.deny();
|
|
|
|
send.object(await getPlayerData(refid, info));
|
|
};
|
|
|
|
// export const set_stage_result: EPR = async (info, data, send) => {
|
|
// return send.object();
|
|
// };
|
|
|
|
export const set_total_result: EPR = async (info, data, send) => {
|
|
const refid = $(data).str('refid');
|
|
if (!refid) return send.deny();
|
|
|
|
const isForte = !info.method.includes("op")
|
|
const p = await readProfile(refid);
|
|
|
|
p.playCount = $(data).number('play_count', p.playCount);
|
|
p.todayPlayCount = $(data).number('today_play_count', p.todayPlayCount);
|
|
|
|
const last = $(data).element('last');
|
|
|
|
p.music = last.number('music_index', p.music);
|
|
p.sheet = last.number('sheet_type', p.sheet);
|
|
p.brooch = last.number('brooch_index', p.brooch);
|
|
p.hispeed = last.number('hi_speed_level', p.hispeed);
|
|
p.beatGuide = last.number('beat_guide', p.beatGuide);
|
|
p.headphone = last.number('headphone_volume', p.headphone);
|
|
p.judgeBar = last.number('judge_bar_pos', p.judgeBar);
|
|
p.group = last.number('music_group', p.group);
|
|
p.mode = last.number('hands_mode', p.mode);
|
|
p.near = last.number('near_setting', p.near);
|
|
p.offset = last.number('judge_delay_offset', p.offset);
|
|
p.bingo = last.number('bingo_index', p.bingo);
|
|
p.skill = `${last.bigint('total_skill_value') || p.skill}`;
|
|
p.keyBeam = last.number('key_beam_level', p.keyBeam);
|
|
p.orbit = last.number('orbit_type', p.orbit);
|
|
p.noteHeight = last.number('note_height', p.noteHeight);
|
|
p.noteWidth = last.number('note_width', p.noteWidth);
|
|
p.judgeWidth = last.number('judge_width_type', p.judgeWidth);
|
|
p.beatVolume = last.number('beat_guide_volume', p.beatVolume);
|
|
p.beatType = last.number('beat_guide_type', p.beatType);
|
|
p.keyVolume = last.number('key_volume_offset', p.keyVolume);
|
|
p.bgmVolume = last.number('bgm_volume_offset', p.bgmVolume);
|
|
p.note = last.number('note_disp_type', p.note);
|
|
p.sf = last.number('slow_fast', p.sf);
|
|
p.judgeFX = last.number('judge_effect_adjust', p.judgeFX);
|
|
p.simple = last.number('simple_bg', p.simple);
|
|
|
|
p.money = $(data).number('travel.money', p.money);
|
|
p.fame = $(data).number('travel.fame', p.fame);
|
|
p.fameId = $(data).number('travel.fame_index', p.fameId);
|
|
p.island = $(data).number('travel.island_id', p.island);
|
|
|
|
let flags = _.get($(data).obj, 'music_list.flag', []);
|
|
if (!_.isArray(flags)) flags = [flags];
|
|
for (const flag of flags) {
|
|
const sheet = _.get(flag, '@attr.sheet_type', -1);
|
|
if (sheet == '0') {
|
|
p.musicList.type_0 = _.get(flag, '@content', p.musicList.type_0);
|
|
} else if (sheet == '1') {
|
|
p.musicList.type_1 = _.get(flag, '@content', p.musicList.type_1);
|
|
} else if (sheet == '2') {
|
|
p.musicList.type_2 = _.get(flag, '@content', p.musicList.type_2);
|
|
} else if (sheet == '3') {
|
|
p.musicList.type_3 = _.get(flag, '@content', p.musicList.type_3);
|
|
}
|
|
}
|
|
|
|
let freeFlags = _.get($(data).obj, 'free_for_play_music_list.flag', []);
|
|
if (!_.isArray(freeFlags)) freeFlags = [freeFlags];
|
|
for (const flag of freeFlags) {
|
|
const sheet = _.get(flag, '@attr.sheet_type', -1);
|
|
if (sheet == '0') {
|
|
p.musicList2.type_0 = _.get(flag, '@content', p.musicList2.type_0);
|
|
} else if (sheet == '1') {
|
|
p.musicList2.type_1 = _.get(flag, '@content', p.musicList2.type_1);
|
|
} else if (sheet == '2') {
|
|
p.musicList2.type_2 = _.get(flag, '@content', p.musicList2.type_2);
|
|
} else if (sheet == '3') {
|
|
p.musicList2.type_3 = _.get(flag, '@content', p.musicList2.type_3);
|
|
}
|
|
}
|
|
|
|
// KENTEI
|
|
let kenteis = $(data).elements('kentei_result_list.kentei_result');
|
|
for (const kentei of kenteis) {
|
|
const index = kentei.number('kentei_index', -1);
|
|
if (index < 0) continue;
|
|
|
|
const clearRate = kentei.number('clear_rate', 0);
|
|
const oldClearRate = _.get(p, `kentei.${index}.rate`, 0);
|
|
const isHigh = clearRate >= oldClearRate;
|
|
|
|
p.kentei[index] = {
|
|
rate: isHigh ? clearRate : oldClearRate,
|
|
score: isHigh ? kentei.number('score', 0) : _.get(p, `kentei.${index}.score`, 0),
|
|
stage: Math.max(kentei.number('stage_prog', 0), _.get(p, `kentei.${index}.stage`, 0)),
|
|
flag: Math.max(kentei.number('clear_flag', 0), _.get(p, `kentei.${index}.flag`, 0)),
|
|
count: Math.max(kentei.number('play_count', 0), _.get(p, `kentei.${index}.count`, 0)),
|
|
};
|
|
}
|
|
|
|
// PARAMS
|
|
let params = $(data).elements('extra_param.param');
|
|
for (const param of params) {
|
|
const type = param.attr().type;
|
|
const parray = param.numbers('params_array');
|
|
if (type == null || parray == null) continue;
|
|
|
|
p.params[type] = parray;
|
|
}
|
|
|
|
// BROOCHES
|
|
let broochs = $(data).elements('brooch_list.brooch');
|
|
for (const brooch of broochs) {
|
|
const index = parseInt(brooch.attr().index || '-1');
|
|
if (index < 0) continue;
|
|
|
|
p.brooches[index] = {
|
|
watch: brooch.number('watch_count', 0),
|
|
level: brooch.number('level', 1),
|
|
steps: brooch.number('invested_steps', 0),
|
|
new: brooch.number('is_new_brooch', 0),
|
|
};
|
|
}
|
|
|
|
// ISLAND
|
|
let islands = $(data).elements('island_progress_list.island_progress');
|
|
for (const island of islands) {
|
|
const index = parseInt(island.attr().index || '-1');
|
|
if (index < 0) continue;
|
|
|
|
const containers: Profile['islands']['0']['containers'] = {};
|
|
let conts = $(data).elements('container');
|
|
for (const cont of conts) {
|
|
const index = cont.number('container_no', -1);
|
|
if (index < 0) continue;
|
|
|
|
const rewards: { [key: string]: number } = {};
|
|
let rews = $(data).elements('reward');
|
|
for (const rew of rews) {
|
|
const index = rew.number('reward_index', -1);
|
|
if (index < 0) continue;
|
|
rewards[index] = rew.number('point', 0);
|
|
}
|
|
|
|
containers[index] = {
|
|
prog: cont.number('movie_prog', 1),
|
|
rewards,
|
|
};
|
|
}
|
|
|
|
p.islands[index] = {
|
|
look: island.number('lookUnlockWin', 0),
|
|
select: island.number('select_container', 0),
|
|
time: island.number('travelledTime', 0),
|
|
containers,
|
|
};
|
|
}
|
|
|
|
// CAT STAIR
|
|
let stairs = $(data).elements('cat_progress.stair');
|
|
if (!p.cat_stairs) {
|
|
p.cat_stairs = defaultProfile.cat_stairs
|
|
}
|
|
for (const stair of stairs) {
|
|
const index = parseInt(stair.attr().index || '-1');
|
|
if (index < 0) continue;
|
|
|
|
p.cat_stairs[index] = {
|
|
total: stair.number('total_steps', 0),
|
|
index: stair.number('chapter_index', 1),
|
|
steps: stair.number('chapter_steps', 0),
|
|
goal: stair.number('chapter_goal', 0),
|
|
};
|
|
}
|
|
|
|
await writeProfile(refid, p);
|
|
|
|
const scoreData = await readScores(refid);
|
|
// Save Scores
|
|
let stages = $(data).elements('stageinfo.stage');
|
|
for (const stage of stages) {
|
|
const mid = stage.attr().music_index
|
|
const type = stage.attr().sheet_type
|
|
|
|
const key = `${mid}:${type}`;
|
|
const c = isForte ? stage : stage.element('common');
|
|
const o = _.get(scoreData, `scores.${key}`, {});
|
|
const isHigh = c.number('score', 0) >= _.get(o, 'score', 0);
|
|
scoreData.scores[key] = {
|
|
score: Math.max(c.number('score', 0), _.get(o, 'score', 0)),
|
|
grade: Math.max(Math.max(c.number('grade_basic', 0), c.number('evaluation', 0)), _.get(o, 'grade', 0)),
|
|
recital: Math.max(c.number('grade_recital', 0), _.get(o, 'recital', 0)),
|
|
mode: isHigh ? c.number('hands_mode', 0) : _.get(o, 'mode', 0),
|
|
count: Math.max(c.number('play_count', 0), _.get(o, 'count', 1)),
|
|
clear: c.number('clear_count', _.get(o, 'clear', 0)),
|
|
multi: c.number('multi_count', _.get(o, 'multi', 0)),
|
|
flag: Math.max(c.number('clear_flag', 0), _.get(o, 'flag', 0)),
|
|
};
|
|
}
|
|
|
|
// Save Recitals
|
|
const rInfo = $(data).element('recital_info.recital');
|
|
if (rInfo){
|
|
const rIndex = rInfo.number('recital_index', -1);
|
|
if (rIndex >= 0) {
|
|
const r = rInfo.element('result');
|
|
const o = _.get(scoreData, `recitals.${rIndex}`);
|
|
const isHigh = r.number('total_score', 0) >= _.get(o, 'score', 0);
|
|
scoreData.recitals[rIndex] = {
|
|
count: Math.max(rInfo.number('recital_count', 0), _.get(o, 'count', 1)),
|
|
hall: isHigh ? rInfo.number('hall_index') : _.get(o, 'hall', 0),
|
|
cat: isHigh ? rInfo.numbers('cat_index') : _.get(o, 'cat', [3, 7, 9, 5, 16]),
|
|
audience: isHigh ? r.number('audience') : _.get(o, 'audience', 0),
|
|
money: isHigh ? r.number('money') : _.get(o, 'money', 0),
|
|
fame: isHigh ? r.number('fame') : _.get(o, 'fame', 0),
|
|
player: isHigh ? r.number('player_fame') : _.get(o, 'player', 0),
|
|
score: isHigh ? r.number('total_score', 0) : _.get(o, 'score', 0),
|
|
start: (isHigh ? r.number('recital_start_time', 0) : _.get(o, 'start', 0)).toString(),
|
|
end: (isHigh ? r.number('recital_end_time', 0) : _.get(o, 'end', 0)).toString(),
|
|
};
|
|
}
|
|
}
|
|
|
|
await writeScores(refid, scoreData);
|
|
|
|
send.success()
|
|
};
|
|
|
|
export const get_musicdata: EPR = async (info, data, send) => {
|
|
const refid = $(data).str('refid');
|
|
if (!refid) return send.deny();
|
|
|
|
const scoreData = await readScores(refid);
|
|
|
|
const recital_record: any[] = [];
|
|
const music: any[] = [];
|
|
|
|
for (const r in scoreData.recitals) {
|
|
const reci = scoreData.recitals[r];
|
|
recital_record.push({
|
|
recital_index: K.ITEM('s32', parseInt(r, 10)),
|
|
recital_count: K.ITEM('s32', reci.count),
|
|
hall_index: K.ITEM('s8', reci.hall),
|
|
cat_index: K.ARRAY('s16', reci.cat),
|
|
audience: K.ITEM('s32', reci.audience),
|
|
money: K.ITEM('s32', reci.money),
|
|
fame: K.ITEM('s32', reci.fame),
|
|
player_fame: K.ITEM('s32', reci.player),
|
|
total_score: K.ITEM('s32', reci.score),
|
|
total_base_score: K.ITEM('s32', reci.score),
|
|
best_start_time: K.ITEM('u64', BigInt(reci.start)),
|
|
best_end_time: K.ITEM('u64', BigInt(reci.end)),
|
|
});
|
|
}
|
|
|
|
for (const m in scoreData.scores) {
|
|
const mdata = m.split(':');
|
|
const musi = scoreData.scores[m];
|
|
|
|
music.push(K.ATTR({
|
|
music_index: mdata[0],
|
|
sheet_type: mdata[1],
|
|
}, {
|
|
score: K.ITEM('s32', musi.score),
|
|
evaluation: K.ITEM('u32', musi.grade), // Forte
|
|
grade_basic: K.ITEM('u32', musi.grade),
|
|
grade_recital: K.ITEM('u32', musi.recital),
|
|
play_count: K.ITEM('s32', musi.count),
|
|
clear_count: K.ITEM('s32', musi.clear),
|
|
multi_count: K.ITEM('s32', musi.multi),
|
|
hands_mode: K.ITEM('s8', musi.mode),
|
|
clear_flag: K.ITEM('s32', musi.flag),
|
|
}));
|
|
}
|
|
|
|
send.object({
|
|
recital_record,
|
|
music,
|
|
});
|
|
};
|
|
|
|
function forteNumericHandler(input: number, max: number, def: number = 0) {
|
|
return input > max ? def : input;
|
|
}
|
|
|
|
async function readProfile(refid: string): Promise<Profile> {
|
|
const profile = await DB.FindOne<Profile>(refid, { collection: 'profile'} )
|
|
return profile || defaultProfile
|
|
}
|
|
|
|
async function writeProfile(refid: string, profile: Profile) {
|
|
await DB.Upsert<Profile>(refid, { collection: 'profile'}, profile)
|
|
}
|
|
|
|
async function readScores(refid: string): Promise<Scores> {
|
|
const score = await DB.FindOne<Scores>(refid, { collection: 'scores'} )
|
|
return score || { collection: 'scores', recitals: {}, scores: {}}
|
|
}
|
|
|
|
async function writeScores(refid: string, scores: Scores) {
|
|
await DB.Upsert<Scores>(refid, { collection: 'scores'}, scores)
|
|
}
|
|
|
|
const defaultProfile: Profile = {
|
|
collection: 'profile',
|
|
|
|
name: 'GUEST',
|
|
music: 0,
|
|
sheet: 0,
|
|
brooch: 0,
|
|
hispeed: 0,
|
|
beatGuide: 1,
|
|
headphone: 0,
|
|
judgeBar: 250,
|
|
group: 0,
|
|
mode: 0,
|
|
near: 0,
|
|
offset: 0,
|
|
bingo: 0,
|
|
skill: '0',
|
|
playCount: 0,
|
|
todayPlayCount: 0,
|
|
keyBeam: 0,
|
|
orbit: 0,
|
|
noteHeight: 10,
|
|
noteWidth: 0,
|
|
judgeWidth: 0,
|
|
beatVolume: 0,
|
|
beatType: 0,
|
|
keyVolume: 0,
|
|
bgmVolume: 0,
|
|
note: 0,
|
|
sf: 0,
|
|
judgeFX: 0,
|
|
simple: 0,
|
|
money: 0,
|
|
fame: 0,
|
|
fameId: 0,
|
|
island: 0,
|
|
brooches: {
|
|
'1': {
|
|
level: 1,
|
|
watch: 0,
|
|
steps: 0,
|
|
new: 0,
|
|
},
|
|
},
|
|
islands: {},
|
|
kentei: {},
|
|
cat_stairs:{
|
|
'0' : {
|
|
total: 0,
|
|
index: 0,
|
|
steps: 0,
|
|
goal: 0
|
|
}
|
|
},
|
|
params: {
|
|
'1': [0],
|
|
},
|
|
musicList: {
|
|
type_0: Array(32).fill(-1),
|
|
type_1: Array(32).fill(-1),
|
|
type_2: Array(32).fill(-1),
|
|
type_3: Array(32).fill(-1),
|
|
},
|
|
musicList2: {
|
|
type_0: Array(32).fill(-1),
|
|
type_1: Array(32).fill(-1),
|
|
type_2: Array(32).fill(-1),
|
|
type_3: Array(32).fill(-1),
|
|
},
|
|
}
|