Implement IIDX 30 RESIDENT

This commit is contained in:
drmext 2022-10-21 01:23:54 +00:00
parent 6354361db2
commit ff13f9c22d
No known key found for this signature in database
GPG Key ID: F1ED48FFE79A6961
10 changed files with 1892 additions and 1 deletions

View File

@ -19,4 +19,5 @@ Edit services url and enable url_slash
- IIDX 19 Lincle
- IIDX 20 tricoro
- IIDX 29 CastHour
- IIDX 30 RESIDENT
- SDVX 6 Exceed Gear

View File

@ -50,7 +50,9 @@ async def core_get_game_version_from_software_version(software_version):
_, model, dest, spec, rev, ext = software_version
ext = int(ext)
if model == 'LDJ' and ext >= 2021101300:
if model == 'LDJ' and ext >= 2022101700:
return 30
elif model == 'LDJ' and ext in range(2021101300, 2022101500):
return 29
elif model == 'JDZ' and ext == 2011071200:
return 18

View File

@ -29,6 +29,7 @@ async def iidx29gamesystem_systeminfo(request: Request):
E.gradeOpenPhase(val=2),
E.isEiseiOpenFlg(val=1),
E.WorldTourismOpenList(val=1),
E.BPLBattleOpenPhase(val=2),
*[E.music_open(
E.music_id(s, __type="s32"),
E.kind(0, __type="s32"),

View File

@ -0,0 +1,77 @@
import config
from fastapi import APIRouter, Request, Response
from core_common import core_process_request, core_prepare_response, E
router = APIRouter(prefix="/local2", tags=["local2"])
router.model_whitelist = ["LDJ"]
@router.post('/{gameinfo}/IIDX30gameSystem/systemInfo')
async def iidx30gamesystem_systeminfo(request: Request):
request_info = await core_process_request(request)
unlock = () #(28008, 28065, 28073, 28088, 28089, 29027, 29094, 29095)
sp_dp = (0, 1)
response = E.response(
E.IIDX30gameSystem(
E.arena_schedule(
E.phase(2, __type="u8"),
E.start(1605784800, __type="u32"),
E.end(1605871200, __type="u32"),
),
E.CommonBossPhase(val=0),
E.Event1InternalPhase(val=0),
E.ExtraBossEventPhase(val=0),
E.isNewSongAnother12OpenFlg(val=1),
E.gradeOpenPhase(val=2),
E.isEiseiOpenFlg(val=1),
E.WorldTourismOpenList(val=1),
E.BPLBattleOpenPhase(val=2),
*[E.music_open(
E.music_id(s, __type="s32"),
E.kind(0, __type="s32"),
) for s in unlock],
*[E.arena_reward(
E.index(unlock.index(s), __type="s32"),
E.cube_num((unlock.index(s) + 1) * 50, __type="s32"),
E.kind(0, __type="s32"),
E.value(s, __type="str"),
) for s in unlock],
*[E.arena_music_difficult(
E.play_style(s, __type="s32"),
E.arena_class(-1, __type="s32"),
E.low_difficult(1, __type="s32"),
E.high_difficult(12, __type="s32"),
E.is_leggendaria(1, __type="bool"),
E.force_music_list_id(0, __type="s32"),
) for s in sp_dp],
*[E.arena_cpu_define(
E.play_style(s, __type="s32"),
E.arena_class(-1, __type="s32"),
E.grade_id(18, __type="s32"),
E.low_music_difficult(8, __type="s32"),
E.high_music_difficult(12, __type="s32"),
E.is_leggendaria(0, __type="bool"),
) for s in sp_dp],
*[E.maching_class_range(
E.play_style(s[0], __type="s32"),
E.matching_class(s[1], __type="s32"),
E.low_arena_class(0, __type="s32"),
E.high_arena_class(19, __type="s32"),
) for s in ((0, 2), (0, 1), (1, 2), (1, 1))],
*[E.arena_force_music(
E.play_style(s, __type="s32"),
E.force_music_list_id(0, __type="s32"),
E.index(0, __type="s32"),
E.music_id(1000, __type="s32"),
E.note_grade(0, __type="s32"),
E.is_active(s, __type="bool"),
) for s in sp_dp],
)
)
response_body, response_headers = await core_prepare_response(request, response)
return Response(content=response_body, headers=response_headers)

122
modules/iidx/iidx30grade.py Normal file
View File

@ -0,0 +1,122 @@
import time
from tinydb import Query, where
from fastapi import APIRouter, Request, Response
from core_common import core_process_request, core_prepare_response, E
from core_database import get_db
router = APIRouter(prefix="/local2", tags=["local2"])
router.model_whitelist = ["LDJ"]
def get_profile(iidx_id):
return get_db().table('iidx_profile').get(
where('iidx_id') == iidx_id
)
@router.post('/{gameinfo}/IIDX30grade/raised')
async def iidx30grade_raised(request: Request):
request_info = await core_process_request(request)
game_version = request_info['game_version']
timestamp = time.time()
iidx_id = int(request_info['root'][0].attrib['iidxid'])
achi = int(request_info['root'][0].attrib['achi'])
cstage = int(request_info['root'][0].attrib['cstage'])
gid = int(request_info['root'][0].attrib['gid'])
gtype = int(request_info['root'][0].attrib['gtype'])
is_ex = int(request_info['root'][0].attrib['is_ex'])
is_mirror = int(request_info['root'][0].attrib['is_mirror'])
db = get_db()
db.table('iidx_class').insert(
{
'timestamp': timestamp,
'game_version': game_version,
'iidx_id': iidx_id,
'achi': achi,
'cstage': cstage,
'gid': gid,
'gtype': gtype,
'is_ex': is_ex,
'is_mirror': is_mirror,
},
)
profile = get_profile(iidx_id)
game_profile = profile['version'].get(str(game_version), {})
best_class = db.table('iidx_class_best').get(
(where('iidx_id') == iidx_id)
& (where('game_version') == game_version)
& (where('gid') == gid)
& (where('gtype') == gtype)
)
best_class = {} if best_class is None else best_class
best_class_data = {
'game_version': game_version,
'iidx_id': iidx_id,
'achi': max(achi, best_class.get('achi', achi)),
'cstage': max(cstage, best_class.get('cstage', cstage)),
'gid': gid,
'gtype': gtype,
'is_ex': is_ex,
'is_mirror': is_mirror,
}
db.table('iidx_class_best').upsert(
best_class_data,
(where('iidx_id') == iidx_id)
& (where('game_version') == game_version)
& (where('gid') == gid)
& (where('gtype') == gtype)
)
best_class_plays = db.table('iidx_class_best').search(
(where('game_version') == game_version)
& (where('iidx_id') == iidx_id)
)
grades = []
for record in best_class_plays:
grades.append([
record['gtype'],
record['gid'],
record['cstage'],
record['achi']
])
game_profile['grade_values'] = grades
grade_sp = db.table('iidx_class_best').search(
(where('iidx_id') == iidx_id)
& (where('gtype') == 0)
& (where('cstage') == 4)
)
game_profile['grade_single'] = max([x['gid'] for x in grade_sp], default=-1)
grade_dp = db.table('iidx_class_best').search(
(where('iidx_id') == iidx_id)
& (where('gtype') == 1)
& (where('cstage') == 4)
)
game_profile['grade_double'] = max([x['gid'] for x in grade_dp], default=-1)
profile['version'][str(game_version)] = game_profile
db.table('iidx_profile').upsert(profile, where('game_version') == game_version)
response = E.response(
E.IIDX30grade(
pnum=1
)
)
response_body, response_headers = await core_prepare_response(request, response)
return Response(content=response_body, headers=response_headers)

View File

@ -0,0 +1,75 @@
import config
from fastapi import APIRouter, Request, Response
from core_common import core_process_request, core_prepare_response, E
router = APIRouter(prefix="/local2", tags=["local2"])
router.model_whitelist = ["LDJ"]
@router.post('/{gameinfo}/IIDX30lobby/entry')
async def iidx30lobby_entry(request: Request):
request_info = await core_process_request(request)
response = E.response(
E.IIDX30lobby()
)
response_body, response_headers = await core_prepare_response(request, response)
return Response(content=response_body, headers=response_headers)
@router.post('/{gameinfo}/IIDX30lobby/update')
async def iidx30lobby_update(request: Request):
request_info = await core_process_request(request)
response = E.response(
E.IIDX30lobby()
)
response_body, response_headers = await core_prepare_response(request, response)
return Response(content=response_body, headers=response_headers)
@router.post('/{gameinfo}/IIDX30lobby/delete')
async def iidx30lobby_delete(request: Request):
request_info = await core_process_request(request)
response = E.response(
E.IIDX30lobby()
)
response_body, response_headers = await core_prepare_response(request, response)
return Response(content=response_body, headers=response_headers)
@router.post('/{gameinfo}/IIDX30lobby/bplbattle_entry')
async def iidx30lobby_bplbattle_entry(request: Request):
request_info = await core_process_request(request)
response = E.response(
E.IIDX30lobby()
)
response_body, response_headers = await core_prepare_response(request, response)
return Response(content=response_body, headers=response_headers)
@router.post('/{gameinfo}/IIDX30lobby/bplbattle_update')
async def iidx30lobby_bplbattle_update(request: Request):
request_info = await core_process_request(request)
response = E.response(
E.IIDX30lobby()
)
response_body, response_headers = await core_prepare_response(request, response)
return Response(content=response_body, headers=response_headers)
@router.post('/{gameinfo}/IIDX30lobby/bplbattle_delete')
async def iidx30lobby_bplbattle_delete(request: Request):
request_info = await core_process_request(request)
response = E.response(
E.IIDX30lobby()
)
response_body, response_headers = await core_prepare_response(request, response)
return Response(content=response_body, headers=response_headers)

458
modules/iidx/iidx30music.py Normal file
View File

@ -0,0 +1,458 @@
import time
from enum import IntEnum
from fastapi import APIRouter, Request, Response
from tinydb import where
from core_common import core_process_request, core_prepare_response, E
from core_database import get_db
import config
router = APIRouter(prefix='/local2', tags=['local2'])
router.model_whitelist = ['LDJ']
class ClearFlags(IntEnum):
NO_PLAY = 0
FAILED = 1
ASSIST_CLEAR = 2
EASY_CLEAR = 3
CLEAR = 4
HARD_CLEAR = 5
EX_HARD_CLEAR = 6
FULL_COMBO = 7
@router.post('/{gameinfo}/IIDX30music/getrank')
async def iidx30music_getrank(request: Request):
request_info = await core_process_request(request)
game_version = request_info['game_version']
iidxid = int(request_info['root'][0].attrib['iidxid'])
play_style = int(request_info['root'][0].attrib['cltype'])
all_scores = {}
db = get_db()
profile = db.table('iidx_profile').get(where('iidx_id') == iidxid)['version'][str(game_version)]
if play_style == 0:
rivals = [
profile.get("sp_rival_1_iidx_id", 0),
profile.get("sp_rival_2_iidx_id", 0),
profile.get("sp_rival_3_iidx_id", 0),
profile.get("sp_rival_4_iidx_id", 0),
profile.get("sp_rival_5_iidx_id", 0),
]
elif play_style == 1:
rivals = [
profile.get("dp_rival_1_iidx_id", 0),
profile.get("dp_rival_2_iidx_id", 0),
profile.get("dp_rival_3_iidx_id", 0),
profile.get("dp_rival_4_iidx_id", 0),
profile.get("dp_rival_5_iidx_id", 0),
]
for record in db.table('iidx_scores_best').search(
(where('music_id') < (game_version + 1) * 1000)
& (where('play_style') == play_style)
):
if record['iidx_id'] == iidxid:
rival_idx = -1
elif record['iidx_id'] in rivals:
rival_idx = rivals.index(record['iidx_id'])
else:
continue
music_id = record['music_id']
clear_flg = record['clear_flg']
ex_score = record['ex_score']
miss_count = record['miss_count']
chart_id = record['chart_id']
if (rival_idx, music_id) not in all_scores:
all_scores[rival_idx, music_id] = {
0: {'clear_flg': -1, 'ex_score': -1, 'miss_count': -1},
1: {'clear_flg': -1, 'ex_score': -1, 'miss_count': -1},
2: {'clear_flg': -1, 'ex_score': -1, 'miss_count': -1},
3: {'clear_flg': -1, 'ex_score': -1, 'miss_count': -1},
4: {'clear_flg': -1, 'ex_score': -1, 'miss_count': -1},
}
all_scores[rival_idx, music_id][chart_id]['clear_flg'] = clear_flg
all_scores[rival_idx, music_id][chart_id]['ex_score'] = ex_score
all_scores[rival_idx, music_id][chart_id]['miss_count'] = miss_count
top_scores = {}
for record in db.table('iidx_scores_best').search(
(where('music_id') < (game_version + 1) * 1000)
& (where('play_style') == play_style)
):
music_id = record['music_id']
ex_score = record['ex_score']
chart_id = record['chart_id']
iidx_id = record['iidx_id']
if music_id not in top_scores:
top_scores[music_id] = {
0: {'djname': "", 'clear_flg': -1, 'ex_score': -1},
1: {'djname': "", 'clear_flg': -1, 'ex_score': -1},
2: {'djname': "", 'clear_flg': -1, 'ex_score': -1},
3: {'djname': "", 'clear_flg': -1, 'ex_score': -1},
4: {'djname': "", 'clear_flg': -1, 'ex_score': -1},
}
if ex_score > top_scores[music_id][chart_id]['ex_score']:
top_name = db.table('iidx_profile').get(where('iidx_id') == iidx_id)['version'][str(game_version)]['djname']
top_scores[music_id][chart_id]['djname'] = top_name
top_scores[music_id][chart_id]['clear_flg'] = 1
top_scores[music_id][chart_id]['ex_score'] = ex_score
response = E.response(
E.IIDX30music(
E.style(type=play_style),
*[E.m([
i,
k,
*[all_scores[i, k][d]['clear_flg'] for d in range(5)],
*[all_scores[i, k][d]['ex_score'] for d in range(5)],
*[all_scores[i, k][d]['miss_count'] for d in range(5)],
], __type='s16') for i, k in all_scores],
*[E.top(
E.detail([
k,
*[top_scores[k][d]['clear_flg'] for d in range(5)],
*[top_scores[k][d]['ex_score'] for d in range(5)],
], __type='s16'),
name0=top_scores[k][0]['djname'],
name1=top_scores[k][1]['djname'],
name2=top_scores[k][2]['djname'],
name3=top_scores[k][3]['djname'],
name4=top_scores[k][4]['djname']
) for k in top_scores]
)
)
assert (response is not None)
response_body, response_headers = await core_prepare_response(request, response)
return Response(content=response_body, headers=response_headers)
@router.post('/{gameinfo}/IIDX30music/crate')
async def iidx30music_crate(request: Request):
request_info = await core_process_request(request)
game_version = request_info['game_version']
db = get_db()
all_score_stats = db.table('iidx_score_stats').search(
(where('music_id') < (game_version + 1) * 1000)
)
crate = {}
fcrate = {}
for stat in all_score_stats:
if stat['music_id'] not in crate:
crate[stat['music_id']] = [1001] * 10
if stat['music_id'] not in fcrate:
fcrate[stat['music_id']] = [1001] * 10
if stat['play_style'] == 1:
dp_idx = 5
else:
dp_idx = 0
crate[stat['music_id']][stat['chart_id'] + dp_idx] = int(stat['clear_rate'])
fcrate[stat['music_id']][stat['chart_id'] + dp_idx] = int(stat['fc_rate'])
response = E.response(
E.IIDX30music(
*[E.c(crate[k] + fcrate[k], mid=k, __type="s32") for k in crate]
)
)
response_body, response_headers = await core_prepare_response(request, response)
return Response(content=response_body, headers=response_headers)
@router.post('/{gameinfo}/IIDX30music/reg')
async def iidx30music_reg(request: Request):
request_info = await core_process_request(request)
game_version = request_info['game_version']
timestamp = time.time()
log = request_info['root'][0].find('music_play_log')
clear_flg = int(request_info['root'][0].attrib['cflg'])
clid = int(request_info['root'][0].attrib['clid'])
is_death = int(request_info['root'][0].attrib['is_death'])
pid = int(request_info['root'][0].attrib['pid'])
play_style = int(log.attrib['play_style'])
ex_score = int(log.attrib['ex_score'])
folder_type = int(log.attrib['folder_type'])
gauge_type = int(log.attrib['gauge_type'])
graph_type = int(log.attrib['graph_type'])
great_num = int(log.attrib['great_num'])
iidx_id = int(log.attrib['iidx_id'])
miss_num = int(log.attrib['miss_num'])
mode_type = int(log.attrib['mode_type'])
music_id = int(log.attrib['music_id'])
note_id = int(log.attrib['note_id'])
option1 = int(log.attrib['option1'])
option2 = int(log.attrib['option2'])
pgreat_num = int(log.attrib['pgreat_num'])
ghost = log.find("ghost").text
ghost_gauge = log.find("ghost_gauge").text
db = get_db()
db.table('iidx_scores').insert(
{
'timestamp': timestamp,
'game_version': game_version,
'iidx_id': iidx_id,
'pid': pid,
'clear_flg': clear_flg,
'is_death': is_death,
'music_id': music_id,
'play_style': play_style,
'chart_id': note_id,
'pgreat_num': pgreat_num,
'great_num': great_num,
'ex_score': ex_score,
'miss_count': miss_num,
'folder_type': folder_type,
'gauge_type': gauge_type,
'graph_type': graph_type,
'mode_type': mode_type,
'option1': option1,
'option2': option2,
'ghost': ghost,
'ghost_gauge': ghost_gauge,
},
)
best_score = db.table('iidx_scores_best').get(
(where('iidx_id') == iidx_id)
& (where('play_style') == play_style)
& (where('music_id') == music_id)
& (where('chart_id') == note_id)
)
best_score = {} if best_score is None else best_score
if clear_flg < ClearFlags.EASY_CLEAR:
miss_num = -1
best_miss_count = best_score.get('miss_count', miss_num)
if best_miss_count == -1:
miss_count = max(miss_num, best_miss_count)
elif clear_flg > ClearFlags.ASSIST_CLEAR:
miss_count = min(miss_num, best_miss_count)
else:
miss_count = best_miss_count
best_ex_score = best_score.get('ex_score', ex_score)
best_score_data = {
'game_version': game_version,
'iidx_id': iidx_id,
'pid': pid,
'play_style': play_style,
'music_id': music_id,
'chart_id': note_id,
'miss_count': miss_count,
'ex_score': max(ex_score, best_ex_score),
'ghost': ghost if ex_score >= best_ex_score else best_score.get('ghost', ghost),
'ghost_gauge': ghost_gauge if ex_score >= best_ex_score else best_score.get('ghost_gauge', ghost_gauge),
'clear_flg': max(clear_flg, best_score.get('clear_flg', clear_flg)),
'gauge_type': gauge_type if ex_score >= best_ex_score else best_score.get('gauge_type', gauge_type),
}
db.table('iidx_scores_best').upsert(
best_score_data,
(where('iidx_id') == iidx_id)
& (where('play_style') == play_style)
& (where('music_id') == music_id)
& (where('chart_id') == note_id)
)
score_stats = db.table('iidx_score_stats').get(
(where('music_id') == music_id)
& (where('play_style') == play_style)
& (where('chart_id') == note_id)
)
score_stats = {} if score_stats is None else score_stats
score_stats['game_version'] = game_version
score_stats['play_style'] = play_style
score_stats['music_id'] = music_id
score_stats['chart_id'] = note_id
score_stats['play_count'] = score_stats.get('play_count', 0) + 1
score_stats['fc_count'] = score_stats.get('fc_count', 0) + (1 if clear_flg == ClearFlags.FULL_COMBO else 0)
score_stats['clear_count'] = score_stats.get('clear_count', 0) + (1 if clear_flg >= ClearFlags.EASY_CLEAR else 0)
score_stats['fc_rate'] = int((score_stats['fc_count'] / score_stats['play_count']) * 1000)
score_stats['clear_rate'] = int((score_stats['clear_count'] / score_stats['play_count']) * 1000)
db.table('iidx_score_stats').upsert(
score_stats,
(where('music_id') == music_id)
& (where('play_style') == play_style)
& (where('chart_id') == note_id)
)
ranklist_data = []
ranklist_scores = db.table('iidx_scores_best').search(
(where('play_style') == play_style)
& (where('music_id') == music_id)
& (where('chart_id') == note_id)
)
ranklist_scores = [] if ranklist_scores is None else ranklist_scores
ranklist_scores_ranked = []
for score in ranklist_scores:
profile = db.table('iidx_profile').get(where('iidx_id') == score['iidx_id'])
if profile is None or str(game_version) not in profile['version']:
continue
game_profile = profile['version'][str(game_version)]
ranklist_scores_ranked.append({
'opname': config.arcade,
'name': game_profile['djname'],
'pid': game_profile['region'],
'body': game_profile['body'],
'face': game_profile['face'],
'hair': game_profile['hair'],
'hand': game_profile['hand'],
'head': game_profile['head'],
'dgrade': game_profile['grade_double'],
'sgrade': game_profile['grade_single'],
'score': score['ex_score'],
'iidx_id': score['iidx_id'],
'clflg': score['clear_flg'],
'myFlg': score['iidx_id'] == iidx_id
})
ranklist_scores_ranked = sorted(ranklist_scores_ranked, key=lambda x: (x['clflg'], x['score']), reverse=True)
myRank = 0
for rnum, score in enumerate(ranklist_scores_ranked):
r = E.data(
rnum=rnum + 1,
opname=score['opname'],
name=score['name'],
pid=score['pid'],
body=score['body'],
face=score['face'],
hair=score['hair'],
hand=score['hand'],
head=score['head'],
dgrade=score['dgrade'],
sgrade=score['sgrade'],
score=score['score'],
iidx_id=score['iidx_id'],
clflg=score['clflg'],
myFlg=score['myFlg'],
achieve=0,
)
ranklist_data.append(r)
if score['myFlg']:
myRank = rnum + 1
response = E.response(
E.IIDX30music(
E.ranklist(
*ranklist_data,
total_user_num=len(ranklist_data)
),
E.shopdata(
rank=myRank
),
clid=clid,
crate=score_stats['clear_rate'],
frate=score_stats['fc_rate'],
mid=music_id,
)
)
response_body, response_headers = await core_prepare_response(request, response)
return Response(content=response_body, headers=response_headers)
@router.post('/{gameinfo}/IIDX30music/appoint')
async def iidx30music_appoint(request: Request):
request_info = await core_process_request(request)
root = request_info['root'][0]
iidxid = int(root.attrib['iidxid'])
music_id = int(root.attrib['mid'])
chart_id = int(root.attrib['clid'])
ctype = int(root.attrib['ctype'])
subtype = root.attrib['subtype']
db = get_db()
record = db.table('iidx_scores_best').get(
(where('iidx_id') == iidxid)
& (where('music_id') == music_id)
& (where('chart_id') == chart_id)
)
vals = []
if record is not None:
vals.append(E.mydata(
record['ghost'],
score=record['ex_score'],
__type="bin",
__size=len(record['ghost']) // 2,
))
if ctype == 1:
sdata = db.table('iidx_scores_best').get(
(where('iidx_id') == int(subtype))
& (where('music_id') == music_id)
& (where('chart_id') == chart_id)
)
elif ctype in (2, 4, 10):
sdata = {
'game_version': 29,
'ghost': "",
'ex_score': 0,
'iidx_id': 0,
'name': "",
'pid': 13
}
for record in db.table('iidx_scores_best').search(
(where('music_id') == music_id)
& (where('chart_id') == chart_id)
):
if record['ex_score'] > sdata['ex_score']:
sdata['game_version'] = record['game_version']
sdata['ghost'] = record['ghost']
sdata['ex_score'] = record['ex_score']
sdata['iidx_id'] = record['iidx_id']
sdata['pid'] = record['pid']
if ctype in (1, 2, 4, 10) and sdata['ex_score'] != 0:
vals.append(E.sdata(
sdata['ghost'],
score=sdata['ex_score'],
name=db.table('iidx_profile').get(where('iidx_id') == sdata['iidx_id'])['version'][str(sdata['game_version'])]['djname'],
pid=sdata['pid'],
__type="bin",
__size=len(sdata['ghost']) // 2,
))
response = E.response(
E.IIDX30music(
*vals
)
)
response_body, response_headers = await core_prepare_response(request, response)
return Response(content=response_body, headers=response_headers)

1066
modules/iidx/iidx30pc.py Normal file

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,20 @@
import config
from fastapi import APIRouter, Request, Response
from core_common import core_process_request, core_prepare_response, E
router = APIRouter(prefix="/local2", tags=["local2"])
router.model_whitelist = ["LDJ"]
@router.post('/{gameinfo}/IIDX30ranking/getranker')
async def iidx30ranking_getranker(request: Request):
request_info = await core_process_request(request)
response = E.response(
E.IIDX30ranking()
)
response_body, response_headers = await core_prepare_response(request, response)
return Response(content=response_body, headers=response_headers)

View File

@ -0,0 +1,69 @@
import config
from fastapi import APIRouter, Request, Response
from core_common import core_process_request, core_prepare_response, E
router = APIRouter(prefix="/local2", tags=["local2"])
router.model_whitelist = ["LDJ"]
@router.post('/{gameinfo}/IIDX30shop/getname')
async def iidx30shop_getname(request: Request):
request_info = await core_process_request(request)
response = E.response(
E.IIDX30shop(
cls_opt=0,
opname=config.arcade,
pid=13,
)
)
response_body, response_headers = await core_prepare_response(request, response)
return Response(content=response_body, headers=response_headers)
@router.post('/{gameinfo}/IIDX30shop/getconvention')
async def iidx30shop_getconvention(request: Request):
request_info = await core_process_request(request)
response = E.response(
E.IIDX30shop(
E.valid(1, __type="bool"),
music_0=-1,
music_1=-1,
music_2=-1,
music_3=-1,
start_time=0,
end_time=0,
)
)
response_body, response_headers = await core_prepare_response(request, response)
return Response(content=response_body, headers=response_headers)
@router.post('/{gameinfo}/IIDX30shop/sentinfo')
async def iidx30shop_sentinfo(request: Request):
request_info = await core_process_request(request)
response = E.response(
E.IIDX30shop()
)
response_body, response_headers = await core_prepare_response(request, response)
return Response(content=response_body, headers=response_headers)
@router.post('/{gameinfo}/IIDX30shop/sendescapepackageinfo')
async def iidx30shop_sendescapepackageinfo(request: Request):
request_info = await core_process_request(request)
response = E.response(
E.IIDX30shop(
expire=1200
)
)
response_body, response_headers = await core_prepare_response(request, response)
return Response(content=response_body, headers=response_headers)