public Oppai.pp_calc GetIfFcPP(ModsInfo mods, int n300, int n100, int n50, OsuPlayMode mode)
{
bool need_update = false;
need_update = need_update || _fc_n100 != n100;
need_update = need_update || _fc_n50 != n50;
if (need_update)
{
_fc_n100 = n100;
_fc_n50 = n50;
Oppai.rtpp_params args;
args.combo = Oppai.FULL_COMBO;
args.mods = (uint)mods.Mod;
args.n100 = n100;
args.n50 = n50;
args.nmiss = 0;
args.mode = (uint)mode;
Oppai.get_ppv2(Beatmap.RawData, (uint)Beatmap.RawData.Length, ref args, true, m_cache, ref _fc_result);
}
return(_fc_result);
}
private PerformanceCalculatorBase GetCalculator(OsuPlayMode mode)
{
switch (mode)
{
case OsuPlayMode.Osu:
_stdPpCalculator = _stdPpCalculator ?? new StdPerformanceCalculator();
return(_stdPpCalculator);
case OsuPlayMode.Taiko:
_taikoPpCalculator = _taikoPpCalculator ?? new TaikoPerformanceCalculator();
return(_taikoPpCalculator);
case OsuPlayMode.Mania:
_maniaPpCalculator = _maniaPpCalculator ?? new ManiaPerformanceCalculator();
return(_maniaPpCalculator);
case OsuPlayMode.CatchTheBeat:
_ctbPpCalculator = _ctbPpCalculator ?? new CatchTheBeatPerformanceCalculator();
return(_ctbPpCalculator);
default:
CurrentIO.WriteColor($"[RealTimePPDisplay]Unknown Mode! Mode:0x{(int)mode:X8}", ConsoleColor.Red);
return(null);
}
}
protected PPTuple GetPPFromOppai(ModsInfo mods, OsuPlayMode mode)
{
if (Beatmap == null)
{
return(PPTuple.Empty);
}
Oppai.Beatmap = Beatmap;
PPTuple pp_tuple;
var result = Oppai.GetMaxPP(mods, mode);
pp_tuple.MaxPP = result.total;
pp_tuple.MaxAimPP = result.aim;
pp_tuple.MaxSpeedPP = result.speed;
pp_tuple.MaxAccuracyPP = result.acc;
AccuracyRound(Accuracy, Beatmap.ObjectsCount, CountMiss, out int n300, out int n100, out int n50);
result = Oppai.GetIfFcPP(mods, n300, n100, n50, mode);
pp_tuple.FullComboPP = result.total;
pp_tuple.FullComboAimPP = result.aim;
pp_tuple.FullComboSpeedPP = result.speed;
pp_tuple.FullComboAccuracyPP = result.acc;
result = Oppai.GetRealTimePP(Time, mods, Count100, Count50, CountMiss, MaxCombo, mode);
pp_tuple.RealTimePP = result.total;
pp_tuple.RealTimeAimPP = result.aim;
pp_tuple.RealTimeSpeedPP = result.speed;
pp_tuple.RealTimeAccuracyPP = result.acc;
return(pp_tuple);
}
public pp_calc GetIfFcPP(ModsInfo mods, int n300, int n100, int n50, OsuPlayMode mode)
{
var needUpdate = _fcN100 != n100;
needUpdate = needUpdate || _fcN50 != n50;
if (needUpdate)
{
_fcN100 = n100;
_fcN50 = n50;
rtpp_params args;
args.combo = FULL_COMBO;
args.mods = (uint)mods.Mod;
args.n100 = n100;
args.n50 = n50;
args.nmiss = 0;
args.mode = (uint)mode;
get_ppv2(Beatmap.RawData, (uint)Beatmap.RawData.Length, ref args, true, _cache, ref _fcResult);
}
return(_fcResult);
}
public ExtraApis(Plugin ortdp, Plugin rtppd)
{
_ortdp = ortdp as OsuRTDataProviderPlugin;
_rtppd = rtppd as RealTimePPDisplayerPlugin;
_ortdp.ListenerManager.OnPlayModeChanged += (l, c) => _mode = c;
_ortdp.ListenerManager.OnModsChanged += (c) => _mods = (uint)c.Mod;
_ortdp.ListenerManager.OnBeatmapChanged += (b) => _beatmap = b;
}
public BeatmapReader(OsuRTDataProvider.BeatmapInfo.Beatmap beatmap, OsuPlayMode mode = OsuPlayMode.Unknown)
{
m_beatmap_header_span.Offset = 0;
m_beatmap_header_span.Length = 0;
Mode = mode;
using (var fs = File.OpenRead(beatmap.FilenameFull))
{
RawData = new byte[fs.Length];
fs.Read(RawData, 0, (int)fs.Length);
}
Parse();
}
internal GameNode(string json) : base(json)
{
StatusEnum = GetEnum <OsuStatus>("status");
PlayMode = GetEnum <OsuPlayMode>("playMode");
HP = GetFloat("hp");
Accuracy = GetFloat("accuracy");
Combo = GetInt("combo");
Count50 = GetInt("count50");
Count100 = GetInt("count100");
Count200 = GetInt("count200");
Count300 = GetInt("count300");
CountKatu = GetInt("countKatu");
CountGeki = GetInt("countGeki");
CountMiss = GetInt("countMiss");
}
public BeatmapReader(OsuRTDataProvider.BeatmapInfo.Beatmap beatmap, OsuPlayMode mode = OsuPlayMode.Unknown)
{
OrtdpBeatmap = beatmap;
_beatmapHeaderSpan.Offset = 0;
_beatmapHeaderSpan.Length = 0;
Mode = mode;
StringBuilder sb = new StringBuilder();
foreach (var line in File.ReadAllLines(beatmap.FilenameFull))
{
sb.Append($"{line}\r\n");
}
RawData = Encoding.UTF8.GetBytes(sb.ToString());
Parse();
}
private void RtppOnPlayModeChanged(OsuPlayMode last, OsuPlayMode mode)
{
Task.Run(() =>
{
bool @lock = _time > _beatmapReader?.BeatmapDuration / 4;
if (@lock)
{
_playStatusLocker.WaitOne();
}
_mode = mode;
if (@lock)
{
_playStatusLocker.ReleaseMutex();
}
});
}
public pp_calc GetMaxPP(ModsInfo mods, OsuPlayMode mode)
{
bool needUpdate = mods != _maxMods;
if (needUpdate)
{
_maxMods = mods;
rtpp_params args;
args.combo = FULL_COMBO;
args.mods = (uint)mods.Mod;
args.n100 = 0;
args.n50 = 0;
args.nmiss = 0;
args.mode = (uint)mode;
//Cache Beatmap
get_ppv2(Beatmap.RawData, (uint)Beatmap.RawData.Length, ref args, false, _cache, ref _maxResult);
}
return(_maxResult);
}
private void ListenerManagerOnPlayModeChanged(OsuPlayMode last, OsuPlayMode mode)
{
GameMode.CurrentMode = Game.Modes.GameMode.FromLegacyMode((OsuGameMode)mode);
GameMode.LastMode = Game.Modes.GameMode.FromLegacyMode((OsuGameMode)last);
if (Beatmap.Mode == OsuGameMode.Osu)
{
if (CurrentMode is IHasPerformanceCalculator has && CurrentStatus == OsuGameStatus.SelectSong)
{
PreCalculatedPp = has.GetMaxPerformance(this);
}
}
if (CurrentMode is ILegacyMode legacyMode)
{
var val = _osuBeatmap?.ModStarPair.GetStars(legacyMode.LegacyMode, Mods.ToIntMod());
if (Beatmap.Mode == OsuGameMode.Osu)
{
Beatmap.Stars = val.GetValueOrDefault();
}
}
}
public pp_calc GetMaxPP(ModsInfo mods, OsuPlayMode mode)
{
bool need_update = false;
need_update = need_update || mods != _max_mods;
if (need_update)
{
_max_mods = mods;
Oppai.rtpp_params args;
args.combo = Oppai.FULL_COMBO;
args.mods = (uint)mods.Mod;
args.n100 = 0;
args.n50 = 0;
args.nmiss = 0;
args.mode = (uint)mode;
//Cache Beatmap
Oppai.get_ppv2(Beatmap.RawData, (uint)Beatmap.RawData.Length, ref args, false, m_cache, ref _max_result);
}
return(_max_result);
}
private void RtppOnPlayModeChanged(OsuPlayMode last, OsuPlayMode mode)
{
if (_status == OsuStatus.Playing)
{
_tmpLastPpCalculator = _ppCalculator;
}
switch (mode)
{
case OsuPlayMode.Osu:
_ppCalculator = new StdPerformanceCalculator(); break;
case OsuPlayMode.Taiko:
_ppCalculator = new TaikoPerformanceCalculator(); break;
case OsuPlayMode.Mania:
_ppCalculator = new ManiaPerformanceCalculator(); break;
default:
CurrentIO.WriteColor("[RealTimePPDisplayer]Unsupported Mode", ConsoleColor.Red);
_ppCalculator = null; break;
}
_mode = mode;
}
private PerformanceCalculatorBase GetCalculator(OsuPlayMode mode)
{
PerformanceCalculatorBase calculator;
switch (mode)
{
case OsuPlayMode.Osu:
_stdPpCalculator = _stdPpCalculator ?? new StdPerformanceCalculator();
calculator = _stdPpCalculator;
break;
case OsuPlayMode.Taiko:
_taikoPpCalculator = _taikoPpCalculator ?? new TaikoPerformanceCalculator();
calculator = _taikoPpCalculator;
break;
case OsuPlayMode.Mania:
_maniaPpCalculator = _maniaPpCalculator ?? new ManiaPerformanceCalculator();
calculator = _maniaPpCalculator;
break;
case OsuPlayMode.CatchTheBeat:
_ctbPpCalculator = _ctbPpCalculator ?? new CatchTheBeatPerformanceCalculator();
calculator = _ctbPpCalculator;
break;
default:
Sync.Tools.IO.CurrentIO.WriteColor($"[ReplayPPDisplay]Unknown Mode! Mode:0x{(int)mode:X8}", ConsoleColor.Red);
calculator = null;
break;
}
calculator?.ClearCache();
return(calculator);
}
public void Parse()
{
int bias = 2;
int pos = Array.IndexOf(RawData, (byte)'\n');
if (RawData[pos - 1] != '\r')
{
bias = 1;
}
pos = 0;
using (var ms = new MemoryStream(RawData))
{
using (var sr = new StreamReader(ms))
{
string block_name = "";
while (!sr.EndOfStream)
{
string raw_line = sr.ReadLine();
int raw_line_len = Encoding.UTF8.GetByteCount(raw_line) + bias;
string line = raw_line.Trim();
if (line.StartsWith("["))
{
block_name = line.Substring(1, line.Length - 2).Trim();
if (block_name == "HitObjects")
{
m_beatmap_header_span.Length = pos + raw_line_len;
}
}
else if (!string.IsNullOrEmpty(line) && (block_name == "General" || block_name == "Difficulty"))
{
GetPropertyString(line, out var prop, out var val);
switch (prop)
{
case "Mode":
OsuPlayMode mode = (OsuPlayMode)int.Parse(val);
if (mode != OsuPlayMode.Mania && Mode == OsuPlayMode.Mania)
{
Sync.Tools.IO.CurrentIO.WriteColor($"[RTPPD::Beatmap]Only support mania beatmap.", ConsoleColor.Yellow);
Mode = mode;
}
else if (mode == OsuPlayMode.Mania && Mode != OsuPlayMode.Mania)
{
Mode = mode;
}
break;
case "OverallDifficulty":
OverallDifficulty = double.Parse(val, CultureInfo.InvariantCulture);
break;
case "HPDrainRate":
HPDrainRate = double.Parse(val, CultureInfo.InvariantCulture);
break;
case "CircleSize":
CircleSize = double.Parse(val, CultureInfo.InvariantCulture);
if (Mode == OsuPlayMode.Mania)
{
KeyCount = int.Parse(val);
}
break;
}
}
else if (!string.IsNullOrEmpty(line) && block_name == "HitObjects")
{
BeatmapObject obj;
if (Mode != OsuPlayMode.Mania)
{
obj = new BeatmapObject(line, pos, raw_line_len, this);
}
else
{
obj = new ManiaBeatmapObject(line, pos, raw_line_len, this);
}
Objects.Add(obj);
}
pos += raw_line_len;
}
}
}
if (Mode == OsuPlayMode.Mania)
{
Objects.Sort((a, b) => a.StartTime - b.StartTime);
}
}
public pp_calc GetRealTimePP(int endTime, ModsInfo mods, int n100, int n50, int nmiss, int maxCombo, OsuPlayMode mode)
{
int pos = GetPosition(endTime, out int nobject);
var needUpdate = false;
needUpdate = _pos != pos;
needUpdate = needUpdate || _n100 != n100;
needUpdate = needUpdate || _n50 != n50;
needUpdate = needUpdate || _nmiss != nmiss;
needUpdate = needUpdate || _maxCombo != maxCombo;
if (needUpdate)
{
_pos = pos;
_n100 = n100;
_n50 = n50;
_nmiss = nmiss;
_maxCombo = maxCombo;
rtpp_params args;
args.combo = maxCombo;
args.mods = (uint)mods.Mod;
args.n100 = n100;
args.n50 = n50;
args.nmiss = nmiss;
args.mode = (uint)mode;
if (!get_ppv2(Beatmap.RawData, (uint)pos, ref args, false, _realTimeData, ref _rtppResult))
{
return(pp_calc.Empty);
}
}
return(_rtppResult);
}
public Oppai.pp_calc GetRealTimePP(int end_time, ModsInfo mods, int n100, int n50, int nmiss, int max_combo, OsuPlayMode mode)
{
int pos = GetPosition(end_time, out int nobject);
bool need_update = false;
need_update = need_update || _pos != pos;
need_update = need_update || _n100 != n100;
need_update = need_update || _n50 != n50;
need_update = need_update || _nmiss != nmiss;
need_update = need_update || _max_combo != max_combo;
if (need_update)
{
_pos = pos;
_n100 = n100;
_n50 = n50;
_nmiss = nmiss;
_max_combo = max_combo;
Oppai.rtpp_params args;
args.combo = max_combo;
args.mods = (uint)mods.Mod;
args.n100 = n100;
args.n50 = n50;
args.nmiss = nmiss;
args.mode = (uint)mode;
if (!Oppai.get_ppv2(Beatmap.RawData, (uint)pos, ref args, false, m_real_time_data, ref _rtpp_result))
{
return(Oppai.pp_calc.Empty);
}
}
return(_rtpp_result);
}
public void Parse()
{
int bias = 1;
int pos = 0;
using (var ms = new MemoryStream(RawData))
{
using (var sr = new StreamReader(ms))
{
string blockName = "";
while (!sr.EndOfStream)
{
string rawLine = sr.ReadLine();
Debug.Assert(rawLine != null, nameof(rawLine) + " != null");
int rawLineLen = Encoding.UTF8.GetByteCount(rawLine) + bias;
string line = rawLine.Trim();
if (line.StartsWith("["))
{
blockName = line.Substring(1, line.Length - 2).Trim();
if (blockName == "HitObjects")
{
_beatmapHeaderSpan.Length = pos + rawLineLen;
}
}
else if (!string.IsNullOrEmpty(line) && (blockName == "General" || blockName == "Difficulty"))
{
GetPropertyString(line, out var prop, out var val);
switch (prop)
{
case "Mode":
OsuPlayMode mode = (OsuPlayMode)int.Parse(val);
if (mode != OsuPlayMode.Mania && Mode == (int)OsuPlayMode.Mania)
{
Sync.Tools.IO.CurrentIO.WriteColor("[RTPPD::Beatmap]Only support mania beatmap.", ConsoleColor.Yellow);
Mode = (int)mode;
}
else if (mode == OsuPlayMode.Mania && Mode != (int)OsuPlayMode.Mania)
{
Mode = (int)mode;
}
break;
case "ApproachRate":
ApproachRate = double.Parse(val, CultureInfo.InvariantCulture);
break;
case "OverallDifficulty":
OverallDifficulty = double.Parse(val, CultureInfo.InvariantCulture);
break;
case "HPDrainRate":
HpDrainRate = double.Parse(val, CultureInfo.InvariantCulture);
break;
case "CircleSize":
CircleSize = double.Parse(val, CultureInfo.InvariantCulture);
if (Mode == (int)OsuPlayMode.Mania)
{
KeyCount = int.Parse(val);
}
break;
}
}
else if (!string.IsNullOrEmpty(line) && blockName == "HitObjects")
{
BeatmapObject obj;
switch (Mode)
{
case (int)OsuPlayMode.Mania:
obj = new ManiaBeatmapObject(line, pos, rawLineLen, this);
break;
case (int)OsuPlayMode.CatchTheBeat:
case (int)OsuPlayMode.Osu:
case (int)OsuPlayMode.Taiko:
obj = new BeatmapObject(line, pos, rawLineLen, this);
break;
default:
obj = null;
break;
}
Objects.Add(obj);
}
pos += rawLineLen;
}
}
}
if (Mode == (int)OsuPlayMode.Mania)
{
Objects.Sort((a, b) => a.StartTime - b.StartTime);
}
}
private void ListenLoopUpdate()
{
OsuStatus status = GetCurrentOsuStatus();
if (status == OsuStatus.NoFoundProcess)
{
m_osu_process = null;
m_play_finder = null;
m_status_finder = null;
m_beatmap_finder = null;
m_mode_finder = null;
m_hit_event_finder = null;
FindOsuProcess();
}
//Waiting for osu to start
if (status != OsuStatus.NoFoundProcess && status != OsuStatus.Unkonwn)
{
//Wait for player to playing
if (status == OsuStatus.Playing)
{
if (m_play_finder == null)
{
m_play_finder = InitFinder <OsuPlayFinder>(LANG_INIT_PLAY_FINDER_SUCCESS, LANG_INIT_PLAY_FINDER_FAILED);
}
if (Setting.GameMode == "Auto" && m_mode_finder == null)
{
m_mode_finder = InitFinder <OsuPlayModeFinder>(LANG_INIT_MODE_FINDER_SUCCESS, LANG_INIT_MODE_FINDER_FAILED);
}
if (m_hit_event_finder == null)
{
m_hit_event_finder = InitFinder <OsuHitEventFinder>(LANG_INIT_HIT_EVENT_SUCCESS, LANG_INIT_HIT_EVENT_FAIL);
}
}
if (m_beatmap_finder == null)
{
m_beatmap_finder = InitFinder <OsuBeatmapFinder>(LANG_INIT_BEATMAP_FINDER_SUCCESS, LANG_INIT_BEATMAP_FINDER_FAILED);
}
if (m_mode_finder != null)
{
OsuPlayMode mode = OsuPlayMode.Osu;
if (OnPlayModeChanged != null)
{
mode = m_mode_finder.GetMode();
}
if (m_last_mode != mode)
{
OnPlayModeChanged?.Invoke(m_last_mode, mode);
}
m_last_mode = mode;
}
else
{
if (Setting.GameMode != "Auto")
{
if (s_game_mode_map.TryGetValue(Setting.GameMode, out var mode))
{
if (m_last_mode != mode)
{
OnPlayModeChanged?.Invoke(m_last_mode, mode);
}
}
m_last_mode = mode;
}
}
if (OnHitEventsChanged != null && m_hit_event_finder != null)
{
// Hit events should work with playing time
if (OnPlayingTimeChanged == null)
{
OnPlayingTimeChanged += (t) => { }
}
;
bool hasChanged;
m_hit_event_finder.GetHitEvents(status, m_playing_time, out m_play_type, out m_hit_events, out hasChanged);
if (hasChanged)
{
OnHitEventsChanged?.Invoke(m_play_type, m_hit_events);
}
}
if (m_play_finder != null)
{
Beatmap beatmap = Beatmap.Empty;
ModsInfo mods = ModsInfo.Empty;
ErrorStatisticsResult error_statistics = ErrorStatisticsResult.Empty;
int cb = 0;
int pt = 0;
int n300 = 0;
int n100 = 0;
int n50 = 0;
int ngeki = 0;
int nkatu = 0;
int nmiss = 0;
int score = 0;
double hp = 0.0;
double acc = 0.0;
string playername = Setting.Username;
try
{
if (OnPlayingTimeChanged != null)
{
pt = m_play_finder.GetPlayingTime();
}
if (OnBeatmapChanged != null)
{
beatmap = m_beatmap_finder.GetCurrentBeatmap(m_osu_id);
}
if (Setting.EnableModsChangedAtListening && status != OsuStatus.Playing)
{
if (OnModsChanged != null)
{
mods = m_play_finder.GetCurrentModsAtListening();
}
}
if (beatmap != Beatmap.Empty && beatmap != m_last_beatmap)
{
OnBeatmapChanged?.Invoke(beatmap);
}
if (status == OsuStatus.Playing)
{
if (OnErrorStatisticsChanged != null)
{
error_statistics = m_play_finder.GetUnstableRate();
}
if (OnModsChanged != null)
{
mods = m_play_finder.GetCurrentMods();
}
if (OnComboChanged != null)
{
cb = m_play_finder.GetCurrentCombo();
}
if (OnCount300Changed != null)
{
n300 = m_play_finder.Get300Count();
}
if (OnCount100Changed != null)
{
n100 = m_play_finder.Get100Count();
}
if (OnCount50Changed != null)
{
n50 = m_play_finder.Get50Count();
}
if (OnCountGekiChanged != null)
{
ngeki = m_play_finder.GetGekiCount();
}
if (OnCountKatuChanged != null)
{
nkatu = m_play_finder.GetKatuCount();
}
if (OnCountMissChanged != null)
{
nmiss = m_play_finder.GetMissCount();
}
if (OnAccuracyChanged != null)
{
acc = m_play_finder.GetCurrentAccuracy();
}
if (OnHealthPointChanged != null)
{
hp = m_play_finder.GetCurrentHP();
}
if (OnScoreChanged != null)
{
score = m_play_finder.GetCurrentScore();
}
if (OnPlayerChanged != null)
{
playername = m_play_finder.GetCurrentPlayerName();
}
}
if (status != m_last_osu_status)
{
OnStatusChanged?.Invoke(m_last_osu_status, status);
}
if (mods != ModsInfo.Empty && !ModsInfo.VaildMods(mods))
{
mods = m_last_mods;
}
if (mods != m_last_mods)
{
OnModsChanged?.Invoke(mods);
}
if (hp != m_last_hp)
{
OnHealthPointChanged?.Invoke(hp);
}
if (acc != m_last_acc)
{
OnAccuracyChanged?.Invoke(acc);
}
if (!error_statistics.Equals(m_last_error_statistics))
{
OnErrorStatisticsChanged?.Invoke(error_statistics);
}
if (playername != m_last_playername)
{
OnPlayerChanged(playername);
}
if (score != m_last_score)
{
OnScoreChanged?.Invoke(score);
}
if (n300 != m_last_300)
{
OnCount300Changed?.Invoke(n300);
}
if (n100 != m_last_100)
{
OnCount100Changed?.Invoke(n100);
}
if (n50 != m_last_50)
{
OnCount50Changed?.Invoke(n50);
}
if (ngeki != m_last_geki)
{
OnCountGekiChanged?.Invoke(ngeki);
}
if (nkatu != m_last_katu)
{
OnCountKatuChanged?.Invoke(nkatu);
}
if (nmiss != m_last_miss)
{
OnCountMissChanged?.Invoke(nmiss);
}
if (cb != m_last_combo)
{
OnComboChanged?.Invoke(cb);
}
if (pt != m_playing_time)
{
OnPlayingTimeChanged?.Invoke(pt);
}
}
catch (Exception e)
{
Logger.Error(e.ToString());
}
m_last_beatmap = beatmap;
m_last_mods = mods;
m_last_hp = hp;
m_last_acc = acc;
m_last_error_statistics = error_statistics;
m_last_combo = cb;
m_playing_time = pt;
m_last_300 = n300;
m_last_100 = n100;
m_last_50 = n50;
m_last_geki = ngeki;
m_last_katu = nkatu;
m_last_miss = nmiss;
m_last_score = score;
m_last_osu_status = status;
m_last_playername = playername;
}
}
}
static void listener_OnPlayModeChanged(OsuPlayMode last, OsuPlayMode mode)
{
update_display();
}
public static List <BeatPerformance> GetBp(string player, OsuPlayMode mode)
{
HttpWebRequest req;
if (Setting.ByCuteSyncProxy)
{
if (publicOsuBotTransferWarpper == null)
{
publicOsuBotTransferWarpper = new PublicOsuBotTransferWarpper();
if (!publicOsuBotTransferWarpper.Init())
{
return(null);
}
}
if (publicOsuBotTransferWarpper.Username != player)
{
Sync.Tools.IO.DefaultIO.WriteColor(DefaultLanguage.HINT_CANNOT_WATCH_OTHER_PLAYER, ConsoleColor.Yellow);
return(null);
}
if (string.IsNullOrEmpty(publicOsuBotTransferWarpper.Token))
{
return(null);
}
req = (HttpWebRequest)WebRequest.Create($"https://osubot.kedamaovo.moe/osuapi/bp?k={publicOsuBotTransferWarpper.Token}&u={player}&type=string&limit=100&m={(uint)mode}");
}
else
{
req = (HttpWebRequest)WebRequest.Create($"https://osu.ppy.sh/api/get_user_best?k={Setting.ApiKey}&u={player}&type=string&limit=100&m={(uint)mode}");
}
req.Timeout = 5000;
List <BeatPerformance> result = new List <BeatPerformance>();
Stream stream = null;
try
{
HttpWebResponse resp = (HttpWebResponse)req.GetResponse();
stream = resp.GetResponseStream();
using (StreamReader sr = new StreamReader(stream))
{
var json = sr.ReadToEnd();
var objs = Newtonsoft.Json.JsonConvert.DeserializeObject <List <Dictionary <string, string> > >(json);
foreach (var obj in objs)
{
BeatPerformance bp = new BeatPerformance();
bp.BeatmapID = int.Parse(obj["beatmap_id"]);
bp.Score = int.Parse(obj["score"]);
bp.ScoreID = obj["score_id"];
bp.MaxCombo = int.Parse(obj["maxcombo"]);
bp.Count50 = int.Parse(obj["count50"]);
bp.Count100 = int.Parse(obj["count100"]);
bp.Count300 = int.Parse(obj["count300"]);
bp.CountMiss = int.Parse(obj["countmiss"]);
bp.CountKatu = int.Parse(obj["countkatu"]);
bp.CountGeki = int.Parse(obj["countgeki"]);
bp.Perfect = obj["perfect"] == "1";
Enum.TryParse <ModsInfo.Mods>(obj["enabled_mods"], out var mods);
bp.EnabledMods = new ModsInfo()
{
Mod = mods
};
bp.UserID = obj["user_id"];
bp.Date = DateTime.Parse(obj["date"]);
bp.Rank = obj["rank"];
bp.PP = double.Parse(obj["pp"]);
result.Add(bp);
}
}
}
catch
{
return(null);
}
finally
{
stream?.Close();
}
result.Sort((a, b) => b.PP.CompareTo(a.PP));
return(result);
}
public static UserInfo GetPlayerInfo(string player, OsuPlayMode mode)
{
HttpWebRequest req;
if (Setting.ByCuteSyncProxy)
{
return(null);
}
else
{
req = (HttpWebRequest)WebRequest.Create($"https://osu.ppy.sh/api/get_user?k={Setting.ApiKey}&u={player}&type=string&m={(uint)mode}");
}
req.Timeout = 5000;
UserInfo result = new UserInfo();
Stream stream = null;
try
{
HttpWebResponse resp = (HttpWebResponse)req.GetResponse();
stream = resp.GetResponseStream();
using (StreamReader sr = new StreamReader(stream))
{
var json = sr.ReadToEnd();
JArray jObject = JArray.Parse(json);
JToken obj = jObject[0];
result.Accuracy = double.Parse(obj["accuracy"].Value <string>());
result.Count50 = uint.Parse(obj["count50"].Value <string>());
result.Count100 = uint.Parse(obj["count100"].Value <string>());
result.Count300 = uint.Parse(obj["count300"].Value <string>());
result.CountA = uint.Parse(obj["count_rank_a"].Value <string>());
result.CountS = uint.Parse(obj["count_rank_s"].Value <string>());
result.CountSH = uint.Parse(obj["count_rank_sh"].Value <string>());
result.CountSS = uint.Parse(obj["count_rank_ss"].Value <string>());
result.CountSSH = uint.Parse(obj["count_rank_ssh"].Value <string>());
result.Country = obj["country"].Value <string>();
result.JoinDate = obj["join_date"].Value <string>();
result.Level = double.Parse(obj["level"].Value <string>());
result.PlayCount = uint.Parse(obj["playcount"].Value <string>());
result.PPRank = uint.Parse(obj["pp_rank"].Value <string>());
result.PPRankCountry = uint.Parse(obj["pp_country_rank"].Value <string>());
result.RankedScore = obj["ranked_score"].Value <string>();
result.TotalScore = obj["total_score"].Value <string>();
result.TotalSecondsPlayed = obj["total_seconds_played"].Value <string>();
result.UserID = obj["user_id"].Value <string>();
result.Username = obj["username"].Value <string>();
result.TotalPP = double.Parse(obj["pp_raw"].Value <string>());
}
}
catch (Exception e)
{
IO.CurrentIO.WriteColor(e.ToString(), ConsoleColor.Red);
return(null);
}
finally
{
stream?.Close();
}
return(result);
}
/// <summary>
/// 使用两个<see cref="OsuRTDataProvider.Listen.OsuPlayMode" />构造一个GMMode
/// </summary>
/// <param name="lastMode"></param>
/// <param name="nowMode"></param>
public GmMode(OsuPlayMode lastMode, OsuPlayMode nowMode)
{
LastMode = GameMode.FromLegacyMode((OsuGameMode)lastMode);
CurrentMode = GameMode.FromLegacyMode((OsuGameMode)nowMode);
}
public PPControl(OsuListenerManager mamger, int?id)
{
m_listener_manager = mamger;
m_listener_manager.OnModsChanged += (mods) => { m_cur_mods = mods; m_pp_calculator.ClearCache(); };
m_listener_manager.OnCount300Changed += c => m_n300 = c;
m_listener_manager.OnCountGekiChanged += c => m_ngeki = c;
m_listener_manager.OnCountKatuChanged += c => m_nkatu = c;
m_listener_manager.OnCount100Changed += c => m_n100 = c;
m_listener_manager.OnCount50Changed += c => m_n50 = c;
m_listener_manager.OnCountMissChanged += c => m_nmiss = c;
m_listener_manager.OnScoreChanged += s => m_score = s;
m_listener_manager.OnPlayModeChanged += (last, mode) =>
{
switch (mode)
{
case OsuPlayMode.Osu:
m_pp_calculator = new StdPPCalculator(); break;
case OsuPlayMode.Taiko:
m_pp_calculator = new TaikoPerformanceCalculator(); break;
case OsuPlayMode.Mania:
m_pp_calculator = new ManiaPerformanceCalculator(); break;
default:
Sync.Tools.IO.CurrentIO.WriteColor("[RealTimePPDisplayer]Unsupported Mode", ConsoleColor.Red);
m_pp_calculator = null; break;
}
m_mode = mode;
};
m_listener_manager.OnStatusChanged += (last, cur) =>
{
m_status = cur;
if (cur == OsuStatus.Listening || cur == OsuStatus.Editing)//Clear Output
{
m_combo = 0;
m_max_combo = 0;
m_n100 = 0;
m_n50 = 0;
m_nmiss = 0;
foreach (var p in m_displayers)
{
p.Value.Clear();
}
}
};
m_listener_manager.OnComboChanged += (combo) =>
{
if (m_status != OsuStatus.Playing)
{
return;
}
if (combo <= ((m_pp_calculator as OppaiPerformanceCalculator)?.Oppai.FullCombo ?? 20000))
{
m_combo = combo;
m_max_combo = Math.Max(m_max_combo, m_combo);
}
};
m_listener_manager.OnBeatmapChanged += RTPPOnBeatmapChanged;
m_listener_manager.OnPlayingTimeChanged += RTPPOnPlayingTimeChanged;
}
public void OnPlayModeChanged(OsuPlayMode lastMode, OsuPlayMode mode)
{
// todo
}
