652 lines
28 KiB
Python
652 lines
28 KiB
Python
#!/usr/bin/env python3
|
||
# -*- coding: utf-8 -*-
|
||
"""舞萌DX 谱面达成率 / DX 分计算器。
|
||
|
||
正向：给 谱面 + 各判定数量 -> 算达成率与 DX 分
|
||
反向：给 谱面 + 目标达成率 -> 倒算所有可行的判定组合与 DX 分
|
||
|
||
只依赖 Python 标准库。
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import argparse
|
||
import json
|
||
import os
|
||
import re
|
||
import sys
|
||
from fractions import Fraction
|
||
from typing import Dict, List, Optional
|
||
|
||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||
|
||
from ma2 import (DIFFICULTY_NAMES, GROUP_LABEL, GROUP_ORDER, Chart,
|
||
chart_path, find_music_dir, level_display, parse_difficulty,
|
||
parse_ma2, parse_music_xml)
|
||
from score import (CLASS_LABEL, CLASS_ORDER, CLASS_WEIGHT, DX_PER, JUDGE_LABEL,
|
||
JUDGMENTS, Theory, class_capacity, dx_score,
|
||
reference_achievement, solve_exact, solve_forward,
|
||
solve_reverse, theory_from_chart)
|
||
|
||
try: # 中文输出到管道时避免 UnicodeEncodeError
|
||
sys.stdout.reconfigure(errors="replace")
|
||
sys.stderr.reconfigure(errors="replace")
|
||
except Exception: # noqa: BLE001
|
||
pass
|
||
|
||
LINE = "-" * 60
|
||
|
||
|
||
def pct(value) -> str:
|
||
return "%.4f%%" % float(value)
|
||
|
||
|
||
def die(msg: str, code: int = 2) -> "None":
|
||
print("[错误] " + msg, file=sys.stderr)
|
||
raise SystemExit(code)
|
||
|
||
|
||
# --------------------------------------------------------------- 载入谱面
|
||
def _enrich(chart: Chart, path: str) -> Chart:
|
||
"""从同目录的 Music.xml 补全曲名 / 难度 / 等级（拿不到就跳过）。"""
|
||
base = os.path.basename(path)
|
||
stem = os.path.splitext(base)[0]
|
||
if "_" in stem:
|
||
left, right = stem.split("_", 1)
|
||
try:
|
||
chart.music_id = int(left)
|
||
chart.difficulty_index = int(right)
|
||
chart.difficulty_name = DIFFICULTY_NAMES[chart.difficulty_index]
|
||
except (ValueError, IndexError):
|
||
pass
|
||
xml_path = os.path.join(os.path.dirname(path), "Music.xml")
|
||
if os.path.isfile(xml_path):
|
||
info = parse_music_xml(xml_path)
|
||
chart.song_name = info.get("name") or chart.song_name
|
||
notes = info.get("notes") or []
|
||
idx = chart.difficulty_index
|
||
if idx is not None and 0 <= idx < len(notes):
|
||
entry = notes[idx]
|
||
chart.level_text = level_display(entry.get("level"), entry.get("levelDecimal"))
|
||
try:
|
||
chart.max_notes_xml = int(entry.get("maxNotes") or 0)
|
||
except (TypeError, ValueError):
|
||
chart.max_notes_xml = None
|
||
return chart
|
||
|
||
|
||
def load_from_file(path: str) -> Chart:
|
||
path = os.path.abspath(os.path.expanduser(path))
|
||
if not os.path.isfile(path):
|
||
die("谱面文件不存在：%s" % path)
|
||
return _enrich(parse_ma2(path), path)
|
||
|
||
|
||
def load_from_game(game_path: str, music_id: int, difficulty: int) -> Chart:
|
||
music_dir = find_music_dir(game_path)
|
||
path = chart_path(music_dir, music_id, difficulty)
|
||
if not os.path.isfile(path):
|
||
alt = os.path.join(music_dir, "music%06d" % music_id)
|
||
hint = ""
|
||
if os.path.isdir(alt):
|
||
have = sorted(f for f in os.listdir(alt) if f.lower().endswith(".ma2"))
|
||
hint = "；该曲目现有谱面：" + (", ".join(have) if have else "无")
|
||
die("找不到谱面：%s%s" % (path, hint))
|
||
chart = parse_ma2(path)
|
||
chart.music_id = music_id
|
||
chart.difficulty_index = difficulty
|
||
chart.difficulty_name = DIFFICULTY_NAMES[difficulty] if 0 <= difficulty <= 4 else "?"
|
||
chart = _enrich(chart, path)
|
||
chart.difficulty_index = difficulty
|
||
chart.difficulty_name = DIFFICULTY_NAMES[difficulty] if 0 <= difficulty <= 4 else "?"
|
||
return chart
|
||
|
||
|
||
# ------------------------------------------------------------------ 展示
|
||
def print_chart(chart: Chart, th: Theory) -> None:
|
||
print(LINE)
|
||
print("谱面")
|
||
print(" 文件 %s" % chart.path)
|
||
if chart.song_name:
|
||
print(" 曲目 %s" % chart.song_name)
|
||
if chart.music_id is not None:
|
||
print(" 编号 %d" % chart.music_id)
|
||
if chart.difficulty_name:
|
||
print(" 难度 %s (%d)" % (chart.difficulty_name.upper(),
|
||
chart.difficulty_index if chart.difficulty_index is not None else 0))
|
||
if chart.level_text:
|
||
print(" 等级 %s" % chart.level_text)
|
||
parts = []
|
||
for g in GROUP_ORDER:
|
||
n = th.counts.get(g, 0)
|
||
if n:
|
||
parts.append("%s %d" % (GROUP_LABEL[g], n))
|
||
print(" 音符 %s" % " · ".join(parts))
|
||
print(" 合计 %d 个计分音符" % th.total_notes)
|
||
if chart.connect_count:
|
||
print(" （另有 %d 个接续滑条节点，不计分）" % chart.connect_count)
|
||
bonus = " + 绝赞奖励 %d" % th.break_bonus_score if th.break_bonus_score else ""
|
||
print(" 理论分 %d%s" % (th.all_perfect_score, bonus))
|
||
print(" 理论DX %d" % th.max_dx)
|
||
print(" 满分 %s" % pct(th.max_achievement))
|
||
for w in chart.warnings:
|
||
print(" [警告] %s" % w)
|
||
declared = chart.totals.get("TTM_SCR_SS")
|
||
if declared is not None and declared != th.all_perfect_score:
|
||
print(" [警告] 谱面自带 TTM_SCR_SS=%d 与计算出的理论分 %d 不一致"
|
||
% (declared, th.all_perfect_score))
|
||
|
||
|
||
def print_forward(chart: Chart, result) -> None:
|
||
th = result.theory
|
||
print(LINE)
|
||
print("判定输入（汇总）")
|
||
for j in JUDGMENTS:
|
||
print(" %-18s %d" % (JUDGE_LABEL[j], result.judges.get(j, 0)))
|
||
print(" %-18s %d / %d" % ("合计", sum(result.judges.values()), th.total_notes))
|
||
print(LINE)
|
||
print("结果")
|
||
exact = result.achievement_min == result.achievement_max
|
||
if exact:
|
||
print(" 达成率 %s （确切值）" % pct(result.achievement_min))
|
||
else:
|
||
print(" 达成率 %s （按音符类别比例分摊的估计值）" % pct(result.achievement_ref))
|
||
print(" 区间 %s ~ %s"
|
||
% (pct(result.achievement_min), pct(result.achievement_max)))
|
||
print(" DX 分 %d / %d (%.2f%%)"
|
||
% (result.dx, th.max_dx, 100.0 * result.dx / th.max_dx if th.max_dx else 0.0))
|
||
if not exact:
|
||
print()
|
||
print(" 说明：只给汇总判定数时，达成率取决于 Great/Good/Miss 落在哪类音符上——")
|
||
print(" 区间下界 = 扣分都落在权重最高的音符上，上界 = 都落在权重最低的音符上。")
|
||
print(" 想要一个确切数值：用 --tap / --hold / --slide / --break 按类别给判定数。")
|
||
print(LINE)
|
||
|
||
|
||
_EXACT_KEYS = ("cp", "perfect", "perfect50", "great", "great40", "great50", "good", "miss")
|
||
_EXACT_KEY_LABEL = {
|
||
"cp": "CP", "perfect": "Perfect", "perfect50": "Perfect(50)",
|
||
"great": "Great", "great40": "Great(40%)", "great50": "Great(50%)",
|
||
"good": "Good", "miss": "Miss",
|
||
}
|
||
# 打印时用纯 ASCII，避免中文宽字符把表格撑歪
|
||
_EXACT_CLASS_TITLE = {
|
||
"tap": "Tap/Star/Touch/EX", "hold": "Hold", "slide": "Slide", "break": "Break",
|
||
}
|
||
|
||
|
||
def print_exact(chart: Chart, result) -> None:
|
||
th = result.theory
|
||
print(LINE)
|
||
print("判定输入（按音符类别；Break = 绝赞；没给的部分按 CP 算）")
|
||
for cls in CLASS_ORDER:
|
||
cap = class_capacity(th, cls)
|
||
if not cap:
|
||
continue
|
||
parts = []
|
||
for key in _EXACT_KEYS:
|
||
n = result.spec.get(cls, {}).get(key, 0)
|
||
if n:
|
||
parts.append("%s %d" % (_EXACT_KEY_LABEL[key], n))
|
||
print(" %-24s %4d 个：%s"
|
||
% ("%s (%d)" % (_EXACT_CLASS_TITLE[cls], CLASS_WEIGHT[cls]), cap,
|
||
" · ".join(parts) if parts else "-"))
|
||
print(LINE)
|
||
print("结果")
|
||
print(" 达成率 %s （确切值）" % pct(result.achievement))
|
||
print(" DX 分 %d / %d (%.2f%%)"
|
||
% (result.dx, th.max_dx, 100.0 * result.dx / th.max_dx if th.max_dx else 0.0))
|
||
if th.all_perfect_score:
|
||
print(" 失分 %d / %d (%.4f%%)"
|
||
% (result.loss_total, th.all_perfect_score,
|
||
100.0 * result.loss_total / th.all_perfect_score))
|
||
if th.break_bonus_score:
|
||
print(" 绝赞奖励 %d / %d (%.4f%%)"
|
||
% (result.bonus_total, th.break_bonus_score,
|
||
100.0 * result.bonus_total / th.break_bonus_score))
|
||
print(LINE)
|
||
|
||
|
||
def print_reverse(chart: Chart, outcome) -> None:
|
||
th = outcome["theory"]
|
||
rows = outcome["rows"]
|
||
mode = outcome.get("mode", "exact")
|
||
print(LINE)
|
||
print("目标达成率 %s [%s]" % (pct(outcome["target"]),
|
||
"精确模式" if mode == "exact" else "区间模式"))
|
||
note = outcome.get("note")
|
||
if note:
|
||
print(" [说明] %s" % note)
|
||
if not rows:
|
||
if mode == "exact":
|
||
cap = outcome.get("exact_cap") or 0
|
||
print(" （在严格验证范围内没有找到解：坏音符 ≤ %d 的组合里没有能精确打出该值的）" % cap)
|
||
if outcome.get("more_unverified"):
|
||
print(" [注意] 坏音符超过 %d 个的候选组合没有验证（不保证那里没有解）" % cap)
|
||
else:
|
||
print(" （无解：该达成率在这个谱面上打不出来）")
|
||
print(LINE)
|
||
return
|
||
if mode == "exact":
|
||
print(" Miss Good Great CP+P CP 范围 DX 分范围")
|
||
else:
|
||
print(" Miss Good Great CP+P CP 范围 达成率范围 DX 分范围")
|
||
for r in rows:
|
||
cp_range = "%d~%d" % (r.cp_min, r.cp_max) if r.cp_min != r.cp_max else str(r.cp_min)
|
||
dx_range = "%d~%d" % (r.dx_min, r.dx_max) if r.dx_min != r.dx_max else str(r.dx_min)
|
||
if mode == "exact":
|
||
print(" %4d %4d %5d %4d %-11s %s"
|
||
% (r.miss, r.good, r.great, r.cp_plus_perfect, cp_range, dx_range))
|
||
else:
|
||
ach = "%s ~ %s" % (pct(r.achievement_min), pct(r.achievement_max))
|
||
print(" %4d %4d %5d %4d %-11s %-24s %s"
|
||
% (r.miss, r.good, r.great, r.cp_plus_perfect, cp_range, ach, dx_range))
|
||
print()
|
||
if mode == "exact":
|
||
print(" 共 %d 组能精确打出 %s 的判定组合（CP+P = Critical Perfect 与 Perfect 之和）"
|
||
% (len(rows), pct(outcome["target"])))
|
||
cap = outcome.get("exact_cap") or 0
|
||
print(" 已逐个严格验证 Miss+Good+Great ≤ %d 的组合；每个组合都真的能打出该达成率" % cap)
|
||
if outcome.get("unverified"):
|
||
print(" [注意] 另有 %d 组候选（坏音符超过 %d 个）未做精确验证，未列入结果"
|
||
% (outcome["unverified"], cap))
|
||
if outcome.get("more_unverified"):
|
||
print(" [注意] 坏音符超过 %d 个的候选组合没有验证（不保证那里没有解）" % cap)
|
||
else:
|
||
print(" 共 %d 组可行组合（CP+P = Critical Perfect 与 Perfect 之和）" % len(rows))
|
||
print(" 区间模式：只保证达成率落在这个范围内，不保证能恰好打出目标值")
|
||
if outcome["truncated"]:
|
||
print(" [注意] 结果被 --limit / 扫描上限截断，可能还有更多组合")
|
||
print(" DX 分 = 3*CP + 2*Perfect + 1*Great；CP 越靠范围上端，DX 分越高")
|
||
print(LINE)
|
||
|
||
|
||
# ------------------------------------------------------------------ JSON
|
||
def to_json(chart: Chart, th: Theory, payload: Dict) -> str:
|
||
data = {
|
||
"chart": {
|
||
"path": chart.path,
|
||
"music_id": chart.music_id,
|
||
"song_name": chart.song_name,
|
||
"difficulty": chart.difficulty_name,
|
||
"difficulty_index": chart.difficulty_index,
|
||
"level_text": chart.level_text,
|
||
"notes": th.counts,
|
||
"total_notes": th.total_notes,
|
||
"connect_slide": chart.connect_count,
|
||
"all_perfect_score": th.all_perfect_score,
|
||
"break_bonus_score": th.break_bonus_score,
|
||
"max_dx": th.max_dx,
|
||
"max_achievement": float(th.max_achievement),
|
||
"warnings": chart.warnings,
|
||
},
|
||
}
|
||
data.update(payload)
|
||
return json.dumps(data, ensure_ascii=False, indent=2)
|
||
|
||
|
||
# ------------------------------------------------------------------ 交互
|
||
def ask(prompt: str, default: str = "") -> str:
|
||
try:
|
||
text = input(prompt).strip()
|
||
except EOFError:
|
||
text = ""
|
||
return text or default
|
||
|
||
|
||
def ask_int(prompt: str, default: Optional[int] = None) -> Optional[int]:
|
||
while True:
|
||
raw = ask(prompt, "" if default is None else str(default))
|
||
if raw == "" and default is None:
|
||
return None
|
||
try:
|
||
return int(raw)
|
||
except ValueError:
|
||
print(" 请输入整数")
|
||
|
||
|
||
def interactive(args) -> None:
|
||
print("=" * 60)
|
||
print("舞萌DX 谱面达成率 / DX 分 计算器")
|
||
print("=" * 60)
|
||
chart = None
|
||
while chart is None:
|
||
mode = ask("谱面来源：1) .ma2 文件路径 2) 游戏路径 + musicid [1]: ", "1")
|
||
if mode.startswith("2"):
|
||
game = ask("游戏路径（Sinmai_Data 目录）: ")
|
||
if not game:
|
||
continue
|
||
mid = ask_int("musicid: ")
|
||
if mid is None:
|
||
continue
|
||
diff = ask("难度 0=BASIC 1=ADVANCED 2=EXPERT 3=MASTER 4=RE:MASTER [3]: ", "3")
|
||
try:
|
||
chart = load_from_game(game, mid, parse_difficulty(diff))
|
||
except SystemExit:
|
||
chart = None
|
||
else:
|
||
path = ask("谱面文件路径: ")
|
||
if not path:
|
||
continue
|
||
try:
|
||
chart = load_from_file(path)
|
||
except SystemExit:
|
||
chart = None
|
||
th = theory_from_chart(chart)
|
||
print_chart(chart, th)
|
||
|
||
mode = ask("计算模式：1) 汇总判定数（估计值 + 区间） 2) 按音符类别给判定数（确切值）"
|
||
" 3) 由达成率倒算判定数 [1]: ", "1")
|
||
if mode.startswith("3"):
|
||
while True:
|
||
raw = ask("目标达成率（如 99.5 或 100.5）: ")
|
||
if not raw:
|
||
return
|
||
try:
|
||
target = Fraction(raw.rstrip("%"))
|
||
break
|
||
except (ValueError, ZeroDivisionError):
|
||
print(" 请输入数字")
|
||
mode = ask("反算方式：1) 精确（只列真能打出该达成率的组合） 2) 区间（判定数只是估算时用） [1]: ", "1")
|
||
args.mode = "range" if mode.startswith("2") else "exact"
|
||
run_reverse(chart, th, target, args)
|
||
elif mode.startswith("2"):
|
||
spec = {}
|
||
for cls in CLASS_ORDER:
|
||
cap = class_capacity(th, cls)
|
||
if not cap:
|
||
continue
|
||
raw = ask(" %s（%d 个）CP/Perfect/Great/Good/Miss [%d/0/0/0/0]: "
|
||
% (CLASS_LABEL[cls], cap, cap))
|
||
if not raw:
|
||
continue
|
||
try:
|
||
spec[cls] = parse_class_counts(raw, cls)
|
||
except ValueError as exc:
|
||
print(" [错误] %s" % exc)
|
||
run_exact(chart, th, spec, args)
|
||
else:
|
||
values = {}
|
||
for j in JUDGMENTS:
|
||
if j == "miss":
|
||
continue
|
||
values[j] = ask_int(" %s 数 [0]: " % JUDGE_LABEL[j], 0) or 0
|
||
values["miss"] = ask_int(" Miss 数（留空 = 总数减去以上判定）: ")
|
||
run_forward(chart, th, values, args)
|
||
|
||
|
||
# ------------------------------------------------------------------ 执行
|
||
def normalize_judges(th: Theory, raw: Dict[str, Optional[int]]) -> Dict[str, int]:
|
||
given = {j: int(raw.get(j) or 0) for j in JUDGMENTS}
|
||
if raw.get("miss") is None:
|
||
given["miss"] = th.total_notes - sum(given[j] for j in JUDGMENTS if j != "miss")
|
||
if given["miss"] < 0:
|
||
die("CP+Perfect+Great+Good 合计 %d 超过了音符总数 %d"
|
||
% (sum(given[j] for j in JUDGMENTS if j != "miss"), th.total_notes))
|
||
total = sum(given.values())
|
||
if total != th.total_notes:
|
||
die("判定数之和 %d 与音符总数 %d 不一致（Miss 请留空自动补足）" % (total, th.total_notes))
|
||
return given
|
||
|
||
|
||
_CLASS_KEYS = ("cp", "perfect", "great", "good", "miss")
|
||
|
||
|
||
def parse_class_counts(text: str, cls: str) -> Dict[str, int]:
|
||
"""把 "CP/Perfect/Great/Good/Miss"（斜杠、逗号或空格分隔）解析成判定数字典。"""
|
||
parts = [p for p in re.split(r"[\/,\s]+", str(text).strip()) if p]
|
||
if len(parts) > len(_CLASS_KEYS):
|
||
raise ValueError("%s 最多 %d 个数（CP/Perfect/Great/Good/Miss）：%s"
|
||
% (CLASS_LABEL[cls], len(_CLASS_KEYS), text))
|
||
out: Dict[str, int] = {}
|
||
for key, raw in zip(_CLASS_KEYS, parts):
|
||
try:
|
||
n = int(raw)
|
||
except ValueError:
|
||
raise ValueError("%s 里的「%s」不是整数：%s" % (CLASS_LABEL[cls], raw, text))
|
||
if n < 0:
|
||
raise ValueError("%s 里不能有负数：%s" % (CLASS_LABEL[cls], text))
|
||
if n:
|
||
out[key] = n
|
||
return out
|
||
|
||
|
||
def build_spec(args) -> Dict[str, Dict[str, int]]:
|
||
"""把 --tap/--hold/--slide/--break 以及绝赞档位参数拼成 solve_exact 的输入。"""
|
||
spec: Dict[str, Dict[str, int]] = {}
|
||
for cls in CLASS_ORDER:
|
||
text = getattr(args, cls, None)
|
||
if text:
|
||
spec[cls] = parse_class_counts(text, cls)
|
||
brk = dict(spec.get("break") or {})
|
||
perfect_total = brk.get("perfect", 0)
|
||
great_total = brk.get("great", 0)
|
||
p50 = int(args.break_perfect50 or 0)
|
||
g40 = int(args.break_great40 or 0)
|
||
g50 = int(args.break_great50 or 0)
|
||
if p50 or g40 or g50:
|
||
if p50 > perfect_total:
|
||
raise ValueError("--break-perfect50 %d 超过绝赞 Perfect 总数 %d"
|
||
"（先在 --break 里写 CP/Perfect/Great/Good/Miss）" % (p50, perfect_total))
|
||
if g40 + g50 > great_total:
|
||
raise ValueError("--break-great40 + --break-great50 = %d 超过绝赞 Great 总数 %d"
|
||
% (g40 + g50, great_total))
|
||
if p50:
|
||
brk["perfect"] = perfect_total - p50
|
||
brk["perfect50"] = p50
|
||
if g40:
|
||
brk["great40"] = g40
|
||
if g50:
|
||
brk["great50"] = g50
|
||
if great_total - g40 - g50:
|
||
brk["great"] = great_total - g40 - g50
|
||
else:
|
||
brk.pop("great", None)
|
||
brk = {k: v for k, v in brk.items() if v}
|
||
spec["break"] = brk
|
||
return spec
|
||
|
||
|
||
def run_exact(chart: Chart, th: Theory, spec: Dict[str, Dict[str, int]], args) -> None:
|
||
try:
|
||
result = solve_exact(th, spec)
|
||
except ValueError as exc:
|
||
die(str(exc))
|
||
if args.json:
|
||
print(to_json(chart, th, {
|
||
"mode": "forward_exact",
|
||
"judges_by_class": result.spec,
|
||
"achievement": float(result.achievement),
|
||
"dx_score": result.dx,
|
||
"loss_total": result.loss_total,
|
||
"bonus_total": result.bonus_total,
|
||
}))
|
||
return
|
||
print_chart(chart, th)
|
||
print_exact(chart, result)
|
||
|
||
|
||
def run_forward(chart: Chart, th: Theory,
|
||
raw: Dict[str, Optional[int]], args) -> None:
|
||
judges = normalize_judges(th, raw)
|
||
result = solve_forward(th, judges)
|
||
if args.json:
|
||
print(to_json(chart, th, {
|
||
"mode": "forward",
|
||
"judges": judges,
|
||
"achievement_min": float(result.achievement_min),
|
||
"achievement_max": float(result.achievement_max),
|
||
"achievement_reference": float(result.achievement_ref),
|
||
"dx_score": result.dx,
|
||
}))
|
||
return
|
||
print_chart(chart, th)
|
||
print_forward(chart, result)
|
||
|
||
|
||
def run_reverse(chart: Chart, th: Theory,
|
||
target: Fraction, args) -> None:
|
||
outcome = solve_reverse(th, target, limit=args.limit, mode=args.mode)
|
||
if args.json:
|
||
print(to_json(chart, th, {
|
||
"mode": "reverse",
|
||
"search_mode": outcome["mode"],
|
||
"target": float(target),
|
||
"truncated": outcome["truncated"],
|
||
"exact_cap": outcome.get("exact_cap"),
|
||
"unverified": outcome.get("unverified", 0),
|
||
"more_unverified": outcome.get("more_unverified", False),
|
||
"note": outcome.get("note"),
|
||
"solutions": [{
|
||
"miss": r.miss, "good": r.good, "great": r.great,
|
||
"critical_perfect_plus_perfect": r.cp_plus_perfect,
|
||
"critical_perfect_min": r.cp_min, "critical_perfect_max": r.cp_max,
|
||
"achievement_min": float(r.achievement_min),
|
||
"achievement_max": float(r.achievement_max),
|
||
"dx_min": r.dx_min, "dx_max": r.dx_max,
|
||
} for r in outcome["rows"]],
|
||
}))
|
||
return
|
||
print_chart(chart, th)
|
||
print_reverse(chart, outcome)
|
||
|
||
|
||
def build_parser() -> argparse.ArgumentParser:
|
||
p = argparse.ArgumentParser(
|
||
prog="chart_achievement.py",
|
||
description="舞萌DX 谱面达成率 / DX 分计算器（正向计算 + 由达成率倒算判定数）",
|
||
formatter_class=argparse.RawDescriptionHelpFormatter,
|
||
epilog="""示例:
|
||
# 直接给谱面文件，正向计算（汇总判定数 -> 估计值 + 区间）
|
||
python chart_achievement.py --chart "D:\\SDGB2026\\Package\\Sinmai_Data\\StreamingAssets\\A000\\music\\music000008\\000008_03.ma2" --cp 290 --perfect 10 --great 2
|
||
|
||
# 按音符类别给判定数 -> 确切的达成率（CP/Perfect/Great/Good/Miss，可省略后面的）
|
||
python chart_achievement.py --chart "D:\\SDGB2026\\Package\\Sinmai_Data\\StreamingAssets\\A000\\music\\music000008\\000008_03.ma2" --tap 260/0/3 --break 6
|
||
|
||
# 给游戏路径 + musicid + 难度（难度用游戏里的数字：0=BASIC 1=ADVANCED 2=EXPERT 3=MASTER 4=RE:MASTER）
|
||
python chart_achievement.py --game "D:\\SDGB2026\\Package\\Sinmai_Data" --music-id 8 --level 3 --cp 300 --perfect 2
|
||
|
||
# 由达成率倒算判定组合（精确模式：只列真能打出该值的组合）
|
||
python chart_achievement.py --game "D:\\SDGB2026\\Package\\Sinmai_Data" --music-id 8 --level 3 --achievement 99.5
|
||
|
||
# 判定数只是估算时，用区间模式
|
||
python chart_achievement.py --game "D:\\SDGB2026\\Package\\Sinmai_Data" --music-id 8 --level 3 --achievement 99.5 --mode range
|
||
""")
|
||
src = p.add_argument_group("谱面来源（二选一）")
|
||
src.add_argument("--chart", metavar="PATH", help=".ma2 谱面文件路径")
|
||
src.add_argument("--game", metavar="PATH", help="游戏目录（Sinmai_Data / StreamingAssets / A000 / music 均可）")
|
||
src.add_argument("--music-id", type=int, metavar="ID", help="曲目编号（配合 --game 使用）")
|
||
src.add_argument("--level", "--difficulty", dest="level", default=None, metavar="D",
|
||
help="谱面难度，用游戏里的数字：0=BASIC 1=ADVANCED 2=EXPERT "
|
||
"3=MASTER 4=RE:MASTER（也可直接写名字；默认 3=MASTER）")
|
||
|
||
fw = p.add_argument_group("正向计算（汇总）：只给总判定数，得到估计值 + 区间")
|
||
fw.add_argument("--cp", type=int, metavar="N", help="Critical Perfect 个数")
|
||
fw.add_argument("--perfect", type=int, metavar="N", help="Perfect 个数")
|
||
fw.add_argument("--great", type=int, metavar="N", help="Great 个数")
|
||
fw.add_argument("--good", type=int, metavar="N", help="Good 个数")
|
||
fw.add_argument("--miss", type=int, metavar="N", help="Miss 个数（留空 = 总数减去其它判定）")
|
||
|
||
ex = p.add_argument_group(
|
||
"正向计算（精确）：按音符类别给判定数，得到确切的达成率",
|
||
"每个类别写 CP/Perfect/Great/Good/Miss 五个数（斜杠或空格分隔，后面可以省略），"
|
||
"没给满的部分按 CP 算。")
|
||
ex.add_argument("--tap", metavar="CP/P/G/GD/M",
|
||
help="Tap/Star/Touch/EX 类（权重 500）")
|
||
ex.add_argument("--hold", metavar="CP/P/G/GD/M", help="Hold 系（权重 1000）")
|
||
ex.add_argument("--slide", metavar="CP/P/G/GD/M", help="Slide 系（权重 1500）")
|
||
ex.add_argument("--break", dest="break", metavar="CP/P/G/GD/M",
|
||
help="绝赞（权重 2500；Great/Perfect 档位见下面三个参数）")
|
||
ex.add_argument("--break-perfect50", type=int, metavar="N",
|
||
help="绝赞 Perfect 里奖励分只有 50 的个数（Perfect2nd）")
|
||
ex.add_argument("--break-great40", type=int, metavar="N",
|
||
help="绝赞 Great 里失分 40%% 的个数（Great2nd）")
|
||
ex.add_argument("--break-great50", type=int, metavar="N",
|
||
help="绝赞 Great 里失分 50%% 的个数（Great3rd）")
|
||
|
||
rv = p.add_argument_group("反向计算：已知达成率")
|
||
rv.add_argument("--achievement", metavar="A", help="目标达成率（如 99.5 / 100.5）")
|
||
rv.add_argument("--mode", choices=("exact", "range"), default="exact",
|
||
help="exact（默认）：只列真的能打出该达成率的组合；"
|
||
"range：列出达成率区间覆盖该值的组合（更快，输入不精确时用）")
|
||
rv.add_argument("--limit", type=int, default=200, metavar="N",
|
||
help="反向计算最多输出多少组解（默认 200）")
|
||
|
||
p.add_argument("--json", action="store_true", help="以 JSON 输出结果")
|
||
return p
|
||
|
||
|
||
def main(argv: Optional[List[str]] = None) -> int:
|
||
args = build_parser().parse_args(argv)
|
||
|
||
if args.chart and args.game:
|
||
die("--chart 与 --game 只能给一个")
|
||
if not args.chart and not args.game:
|
||
interactive(args)
|
||
return 0
|
||
if args.chart:
|
||
chart = load_from_file(args.chart)
|
||
if args.level is not None:
|
||
try:
|
||
want = parse_difficulty(args.level)
|
||
except ValueError as exc:
|
||
die(str(exc))
|
||
if chart.difficulty_index is not None and want != chart.difficulty_index:
|
||
print("[注意] --level 给的是 %s，但谱面文件名里是 %s，按文件名算"
|
||
% (DIFFICULTY_NAMES[want], DIFFICULTY_NAMES[chart.difficulty_index]),
|
||
file=sys.stderr)
|
||
else:
|
||
if args.music_id is None:
|
||
die("使用 --game 时必须同时给 --music-id")
|
||
if args.level is None:
|
||
print("[提示] 没有给 --level，按默认难度 3（MASTER）计算"
|
||
"（0=BASIC 1=ADVANCED 2=EXPERT 3=MASTER 4=RE:MASTER）", file=sys.stderr)
|
||
try:
|
||
difficulty = parse_difficulty(args.level if args.level is not None else "master")
|
||
except ValueError as exc:
|
||
die(str(exc))
|
||
chart = load_from_game(args.game, args.music_id, difficulty)
|
||
|
||
th = theory_from_chart(chart)
|
||
if th.total_notes == 0:
|
||
die("谱面里没有解析到任何计分音符：%s" % chart.path)
|
||
|
||
if args.achievement:
|
||
try:
|
||
target = Fraction(str(args.achievement).rstrip("%"))
|
||
except (ValueError, ZeroDivisionError):
|
||
die("--achievement 需要是数字，如 99.5")
|
||
if target > th.max_achievement:
|
||
die("目标达成率 %s 超过该谱面上限 %s" % (pct(target), pct(th.max_achievement)))
|
||
if target < 0:
|
||
die("目标达成率不能为负")
|
||
run_reverse(chart, th, target, args)
|
||
return 0
|
||
|
||
class_flags = {"tap": args.tap, "hold": args.hold, "slide": args.slide,
|
||
"break": getattr(args, "break", None),
|
||
"perfect50": args.break_perfect50,
|
||
"great40": args.break_great40, "great50": args.break_great50}
|
||
if any(v for v in class_flags.values()):
|
||
if any(v is not None for v in (args.cp, args.perfect, args.great, args.good, args.miss)):
|
||
die("汇总判定数（--cp/--perfect/--great/--good/--miss）"
|
||
"和按类别判定数（--tap/--hold/--slide/--break）只能给一种")
|
||
try:
|
||
spec = build_spec(args)
|
||
except ValueError as exc:
|
||
die(str(exc))
|
||
run_exact(chart, th, spec, args)
|
||
return 0
|
||
|
||
raw = {"cp": args.cp, "perfect": args.perfect, "great": args.great,
|
||
"good": args.good, "miss": args.miss}
|
||
if all(v is None for v in raw.values()):
|
||
die("请给判定数：汇总用 --cp/--perfect/--great/--good，"
|
||
"精确用 --tap/--hold/--slide/--break；或用 --achievement 做反向计算")
|
||
run_forward(chart, th, raw, args)
|
||
return 0
|
||
|
||
|
||
if __name__ == "__main__":
|
||
raise SystemExit(main())
|