public OszArchiveReader(Stream archiveStream)
{
this.archiveStream = archiveStream;
archive = ZipFile.Read(archiveStream);
beatmaps = archive.Entries.Where(e => e.FileName.EndsWith(@".osu"))
.Select(e => e.FileName).ToArray();
if (beatmaps.Length == 0)
throw new FileNotFoundException(@"This directory contains no beatmaps");
using (var stream = new StreamReader(GetStream(beatmaps[0])))
{
var decoder = BeatmapDecoder.GetDecoder(stream);
firstMap = decoder.Decode(stream);
}
}
public void SetDefaults(TaikoHitObject hitObject, Beatmap <TaikoHitObject> beatmap)
{
}
private void generateRotatingSplitText(double startTime, double endTime, double textEndTime, string text1, string text2, float fontScale, int angle, int offsetTopY, int offsetBottomY, FontGenerator font)
{
// preconfigured options
var beat = Beatmap.GetTimingPointAt(965).BeatDuration;
var timeStep = beat / 8;
var radius = 150;
var angleStep = angle / ((endTime - startTime) / timeStep);
var t = (int)((endTime - startTime) / timeStep);
var textPadding = 10;
// text1
var text1Postition = new Vector2(320, 240) - new Vector2(radius, offsetTopY);
var time = startTime;
var numberOfLetters = text1.Replace("\n", "").Length;
int lineOrder = 0;
foreach (var line in text1.Split('\n'))
{
var lineWidth = 0f;
var lineHeight = 0f;
int letterOrder = line.Length;
var textureWidth = 0f;
foreach (var letter in line)
{
var texture = font.GetTexture(letter.ToString());
textureWidth = texture.BaseWidth * fontScale;
lineWidth += texture.BaseWidth * fontScale + textPadding;
lineHeight = Math.Max(texture.BaseHeight * fontScale, lineHeight);
}
var letterX = text1Postition.X - lineWidth - textureWidth;
var letterY = text1Postition.Y;
foreach (var letter in line)
{
var texture = font.GetTexture(letter.ToString());
if (!texture.IsEmpty)
{
var position = new Vector2(letterX, letterY) + texture.OffsetFor(OsbOrigin.CentreRight) * fontScale;
var sprite = GetLayer("lyrics-on-circle").CreateSprite(texture.Path, OsbOrigin.CentreRight, position);
sprite.Scale(startTime, fontScale);
if (time != startTime)
{
sprite.Fade(startTime, 0);
}
sprite.Fade(time, 1);
sprite.Fade(endTime, 0);
sprite.Color(startTime, Random(0, 2) == 0 ? redColor : blueColor);
// loop
var currentTime = startTime;
var currentAngle = 0 + angleStep;
var currentPosition = position;
for (int i = 0; i < t; i++)
{
var targetPosition = new Vector2();
targetPosition.X = (float)(320 - (radius + letterOrder * (20 + textPadding)) * Math.Cos(MathHelper.DegreesToRadians(currentAngle)) + (lineOrder * (20 + textPadding)) * Math.Sin(MathHelper.DegreesToRadians(currentAngle)));
targetPosition.Y = (float)((240 - offsetTopY) + (radius + letterOrder * (20 + textPadding)) * Math.Sin(MathHelper.DegreesToRadians(currentAngle)) + (lineOrder * (20 + textPadding)) * Math.Cos(MathHelper.DegreesToRadians(currentAngle)));
sprite.Move(currentTime, currentTime + timeStep, currentPosition, targetPosition);
sprite.Rotate(currentTime, MathHelper.DegreesToRadians(-currentAngle));
currentTime += timeStep;
currentAngle += angleStep;
currentPosition = targetPosition;
}
letterX -= (texture.BaseWidth * fontScale + textPadding);
time += (double)(((textEndTime - startTime) / 2 - beat / 2) / numberOfLetters);
letterOrder--;
}
}
text1Postition.Y += (lineHeight + textPadding);
lineOrder++;
}
// text2
var text2Postition = new Vector2(320, 240) + new Vector2(radius, offsetBottomY);
numberOfLetters = text2.Replace("\n", "").Length;
lineOrder = 0;
foreach (var line in text2.Split('\n'))
{
var lineWidth = 0f;
var lineHeight = 0f;
int letterOrder = 0;
foreach (var letter in line)
{
var texture = font.GetTexture(letter.ToString());
lineWidth += texture.BaseWidth * fontScale + textPadding;
lineHeight = Math.Max(texture.BaseHeight * fontScale, lineHeight);
}
var letterX = text2Postition.X;
var letterY = text2Postition.Y;
foreach (var letter in line)
{
var texture = font.GetTexture(letter.ToString());
if (!texture.IsEmpty)
{
var position = new Vector2(letterX, letterY) + texture.OffsetFor(OsbOrigin.CentreLeft) * fontScale;
var sprite = GetLayer("lyrics-on-circle").CreateSprite(texture.Path, OsbOrigin.CentreLeft, position);
sprite.Scale(startTime, fontScale);
sprite.Fade(startTime, 0);
sprite.Fade(time, 1);
sprite.Fade(endTime, 0);
sprite.Color(startTime, Random(0, 2) == 0 ? redColor : blueColor);
// loop
var currentTime = startTime;
var currentAngle = 0 + angleStep;
var currentPosition = position;
for (int i = 0; i < t; i++)
{
var targetPosition = new Vector2();
targetPosition.X = (float)(320 + (radius + letterOrder * (20 + textPadding)) * Math.Cos(MathHelper.DegreesToRadians(currentAngle)) + (lineOrder * (20 + textPadding)) * Math.Sin(MathHelper.DegreesToRadians(currentAngle)));
targetPosition.Y = (float)((240 + offsetBottomY) - (radius + letterOrder * (20 + textPadding)) * Math.Sin(MathHelper.DegreesToRadians(currentAngle)) + (lineOrder * (20 + textPadding)) * Math.Cos(MathHelper.DegreesToRadians(currentAngle)));
sprite.Move(currentTime, currentTime + timeStep, currentPosition, targetPosition);
sprite.Rotate(currentTime, MathHelper.DegreesToRadians(-currentAngle));
currentTime += timeStep;
currentAngle += angleStep;
currentPosition = targetPosition;
}
Log(letterY.ToString());
letterX += (texture.BaseWidth * fontScale + textPadding);
time += (double)(((textEndTime - startTime) / 2 - beat / 2) / numberOfLetters);
letterOrder++;
}
}
text2Postition.Y += (lineHeight + textPadding);
lineOrder++;
}
}
private void load(BeatmapListingOverlay beatmapListing, SettingsOverlay settings, RankingsOverlay rankings, OsuConfigManager config, SessionStatics statics)
{
holdDelay = config.GetBindable <float>(OsuSetting.UIHoldActivationDelay);
loginDisplayed = statics.GetBindable <bool>(Static.LoginOverlayDisplayed);
if (host.CanExit)
{
AddInternal(exitConfirmOverlay = new ExitConfirmOverlay
{
Action = () =>
{
if (holdDelay.Value > 0)
{
confirmAndExit();
}
else
{
this.Exit();
}
}
});
}
AddRangeInternal(new[]
{
buttonsContainer = new ParallaxContainer
{
ParallaxAmount = 0.01f,
Children = new Drawable[]
{
buttons = new ButtonSystem
{
OnEdit = delegate
{
Beatmap.SetDefault();
this.Push(new Editor());
},
OnSolo = onSolo,
OnMulti = delegate { this.Push(new TimeshiftMultiplayer()); },
OnExit = confirmAndExit,
}
}
},
sideFlashes = new MenuSideFlashes(),
songTicker = new SongTicker
{
Anchor = Anchor.TopRight,
Origin = Anchor.TopRight,
Margin = new MarginPadding {
Right = 15, Top = 5
}
},
exitConfirmOverlay?.CreateProxy() ?? Drawable.Empty()
});
buttons.StateChanged += state =>
{
switch (state)
{
case ButtonSystemState.Initial:
case ButtonSystemState.Exit:
Background.FadeColour(Color4.White, 500, Easing.OutSine);
break;
default:
Background.FadeColour(OsuColour.Gray(0.8f), 500, Easing.OutSine);
break;
}
};
buttons.OnSettings = () => settings?.ToggleVisibility();
buttons.OnBeatmapListing = () => beatmapListing?.ToggleVisibility();
buttons.OnChart = () => rankings?.ShowSpotlights();
LoadComponentAsync(background = new BackgroundScreenDefault());
preloadSongSelect();
}
private void HandleReplayChanged(Replay r, Beatmap b)
{
Chart.SuspendLayout();
Chart.Series.Clear();
Chart.ChartAreas[0].AxisX.ScaleView.ZoomReset(0);
Chart.ChartAreas[0].AxisY.ScaleView.ZoomReset(0);
int currentSpinnerNumber = 1;
foreach (var spinner in b.HitObjects.Where(o => o.GetType() == typeof(SpinnerObject)))
{
Point2 currentPosition = new Point2(-500, -500);
Dictionary<double, int> RPMCount = new Dictionary<double, int>();
double currentTime = 0;
foreach (ReplayInfo repPoint in r.ReplayFrames.Where(repPoint => repPoint.Time < ((SpinnerObject)spinner).EndTime && repPoint.Time > spinner.StartTime))
{
if ((int)currentPosition.X == -500)
{
currentPosition.X = repPoint.X;
currentPosition.Y = repPoint.Y;
}
else
{
currentTime += repPoint.TimeDiff;
if (RPMCount.Keys.Contains(currentTime))
continue;
double ptsDist = currentPosition.DistanceTo(new Point2(repPoint.X, repPoint.Y));
double p1CDist = currentPosition.DistanceTo(spinner.Location);
double p2CDist = new Point2(repPoint.X, repPoint.Y).DistanceTo(spinner.Location);
double travelDegrees = Math.Acos((Math.Pow(p1CDist, 2) + Math.Pow(p2CDist, 2) - Math.Pow(ptsDist, 2)) / (2 * p1CDist * p2CDist)) * (180 / Math.PI);
RPMCount.Add(currentTime, (int)Math.Min((travelDegrees / (0.006 * repPoint.TimeDiff)), 477));
currentPosition.X = repPoint.X;
currentPosition.Y = repPoint.Y;
}
}
int count = 0;
int valueAmnt = 0;
Series spinnerSeries = new Series
{
ChartType = SeriesChartType.Spline,
BorderWidth = 2,
Name = oRA.Data.Language["oRA_Spinner"] + " " + currentSpinnerNumber
};
foreach (var frame in RPMCount)
{
valueAmnt += frame.Value;
count += 1;
if (count == 5)
{
spinnerSeries.Points.AddXY(frame.Key, Convert.ToInt32(valueAmnt / count));
count = 0;
valueAmnt = 0;
}
}
Chart.Series.Add(spinnerSeries);
currentSpinnerNumber += 1;
}
Chart.ResumeLayout();
}
private void handleTimingPoints(Beatmap beatmap, string val)
{
ControlPoint cp = null;
string[] split = val.Split(',');
if (split.Length > 2)
{
int kiai_flags = split.Length > 7 ? Convert.ToInt32(split[7], NumberFormatInfo.InvariantInfo) : 0;
double beatLength = double.Parse(split[1].Trim(), NumberFormatInfo.InvariantInfo);
cp = new ControlPoint
{
Time = double.Parse(split[0].Trim(), NumberFormatInfo.InvariantInfo),
BeatLength = beatLength > 0 ? beatLength : 0,
VelocityAdjustment = beatLength < 0 ? -beatLength / 100.0 : 1,
TimingChange = split.Length <= 6 || split[6][0] == '1',
};
}
if (cp != null)
beatmap.ControlPoints.Add(cp);
}
private void handleEditor(Beatmap beatmap, string key, string val)
{
switch (key)
{
case @"Bookmarks":
beatmap.BeatmapInfo.StoredBookmarks = val;
break;
case @"DistanceSpacing":
beatmap.BeatmapInfo.DistanceSpacing = double.Parse(val, NumberFormatInfo.InvariantInfo);
break;
case @"BeatDivisor":
beatmap.BeatmapInfo.BeatDivisor = int.Parse(val);
break;
case @"GridSize":
beatmap.BeatmapInfo.GridSize = int.Parse(val);
break;
case @"TimelineZoom":
beatmap.BeatmapInfo.TimelineZoom = double.Parse(val, NumberFormatInfo.InvariantInfo);
break;
}
}
public static void ReadDb(string file)
{
using (System.IO.FileStream fs = new System.IO.FileStream(file, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite))
{
BinaryReader reader = new BinaryReader(fs);
int dbversion = reader.ReadInt32();
int stash = reader.ReadInt32(); //folders
stash = reader.ReadInt32();
stash = reader.ReadInt32();
stash = reader.ReadByte();
string stashs = reader.ReadString(); //player
bool stashb = false;
int mapcount = reader.ReadInt32();
Beatmap tmpbm = new Beatmap();
BeatmapSet tmpset = new BeatmapSet();
for (int i = 0; i < mapcount; i++)
{
tmpbm.ArtistRomanized = reader.ReadString();
stashs = reader.ReadString();
if (stashs != "") { tmpbm.Artist = stashs; }
tmpbm.TitleRomanized = reader.ReadString();
stashs = reader.ReadString();
if (stashs != "") { tmpbm.Title = stashs; }
tmpbm.Creator = reader.ReadString();
tmpbm.Version = reader.ReadString();
tmpbm.Audio = reader.ReadString();
tmpbm.hash = reader.ReadString();
tmpbm.Name = reader.ReadString();
stash = reader.ReadByte(); //4=ranked 5=app 2=Unranked
tmpbm.totalhitcount = reader.ReadUInt16(); //circles
tmpbm.totalhitcount += reader.ReadUInt16(); //sliders
tmpbm.totalhitcount += reader.ReadUInt16(); //spinners
Int64 stashB = reader.ReadInt64(); //最后编辑
stash = reader.ReadByte(); //AR
stash = reader.ReadByte(); //CS
stash = reader.ReadByte(); //HP
stash = reader.ReadByte(); //OD
double stashD = reader.ReadDouble(); //SV
stash = reader.ReadInt32(); //playtime
stash = reader.ReadInt32(); //totaltime
stash = reader.ReadInt32(); //preview
stash = reader.ReadInt32(); //timting points 数
for (int j = 0; j < stash; j++)
{
stashD = reader.ReadDouble(); //bpm
stashD = reader.ReadDouble(); //offset
stashb = reader.ReadBoolean();//红线
}
tmpbm.beatmapId = reader.ReadInt32();
tmpbm.beatmapsetId = reader.ReadInt32();
stash = reader.ReadInt32(); //threadid
stash = reader.ReadByte();//Ranking osu
stash = reader.ReadByte();//Ranking taiko
stash = reader.ReadByte();//Ranking ctb
stash = reader.ReadByte();//Ranking mania
tmpbm.offset = reader.ReadInt16();
stashD = reader.ReadSingle(); //stack
tmpbm.mode = reader.ReadByte();
tmpbm.Source = reader.ReadString();
tmpbm.tags = reader.ReadString();
stash = reader.ReadInt16();//online-offset
if (tmpbm.offset == 0 && stash != 0) { tmpbm.offset = stash; }
stashs = reader.ReadString(); //title-font
stashb = reader.ReadBoolean(); //unplayed
stashB = reader.ReadInt64(); //last_play
stashb = reader.ReadBoolean(); //osz2
tmpbm.Location = Path.Combine(Core.osupath, reader.ReadString());
stashB = reader.ReadInt64(); //最后同步
stashb = reader.ReadBoolean(); //忽略音效
stashb = reader.ReadBoolean(); //忽略皮肤
stashb = reader.ReadBoolean(); //禁用sb
stash = reader.ReadByte(); //背景淡化
stashB = reader.ReadInt64();
if (tmpset.count == 0) { tmpset.add(tmpbm); }
else
{
if (tmpset.Contains(tmpbm)) { tmpset.add(tmpbm); }
else
{
Core.allsets.Add(tmpset);
tmpset = new BeatmapSet();
tmpset.add(tmpbm);
}
}
tmpbm = new Beatmap();
}
}
}
private string TransformProperties(PropertyTransformerVm vm, BackgroundWorker worker, DoWorkEventArgs _)
{
bool doFilterMatch = vm.MatchFilter != -1 && vm.EnableFilters;
bool doFilterRange = (vm.MinTimeFilter != -1 || vm.MaxTimeFilter != -1) && vm.EnableFilters;
double min = vm.MinTimeFilter == -1 ? double.NegativeInfinity : vm.MinTimeFilter;
double max = vm.MaxTimeFilter == -1 ? double.PositiveInfinity : vm.MaxTimeFilter;
var reader = EditorReaderStuff.GetFullEditorReaderOrNot();
foreach (string path in vm.ExportPaths)
{
Editor editor;
if (Path.GetExtension(path) == ".osb")
{
editor = new StoryboardEditor(path);
}
else
{
editor = EditorReaderStuff.GetNewestVersionOrNot(path, reader);
}
if (editor is BeatmapEditor beatmapEditor)
{
Beatmap beatmap = beatmapEditor.Beatmap;
List <TimingPointsChange> timingPointsChanges = new List <TimingPointsChange>();
foreach (TimingPoint tp in beatmap.BeatmapTiming.TimingPoints)
{
// Offset
if (vm.TimingpointOffsetMultiplier != 1 || vm.TimingpointOffsetOffset != 0)
{
if (Filter(tp.Offset, tp.Offset, doFilterMatch, doFilterRange, vm.MatchFilter, min, max))
{
tp.Offset = Math.Round(tp.Offset * vm.TimingpointOffsetMultiplier +
vm.TimingpointOffsetOffset);
}
}
// BPM
if (vm.TimingpointBPMMultiplier != 1 || vm.TimingpointBPMOffset != 0)
{
if (tp.Uninherited)
{
if (Filter(tp.GetBpm(), tp.Offset, doFilterMatch, doFilterRange, vm.MatchFilter, min,
max))
{
double newBPM = tp.GetBpm() * vm.TimingpointBPMMultiplier + vm.TimingpointBPMOffset;
newBPM = vm.ClipProperties
? MathHelper.Clamp(newBPM, 15, 10000)
: newBPM; // Clip the value if specified
tp.MpB = 60000 / newBPM;
}
}
}
// Slider Velocity
if (vm.TimingpointSVMultiplier != 1 || vm.TimingpointSVOffset != 0)
{
if (Filter(beatmap.BeatmapTiming.GetSvMultiplierAtTime(tp.Offset), tp.Offset, doFilterMatch,
doFilterRange, vm.MatchFilter, min, max))
{
TimingPoint tpchanger = tp.Copy();
double newSV =
beatmap.BeatmapTiming.GetSvMultiplierAtTime(tp.Offset) *
vm.TimingpointSVMultiplier + vm.TimingpointSVOffset;
newSV = vm.ClipProperties
? MathHelper.Clamp(newSV, 0.1, 10)
: newSV; // Clip the value if specified
tpchanger.MpB = -100 / newSV;
timingPointsChanges.Add(new TimingPointsChange(tpchanger, mpb: true));
}
}
// Index
if (vm.TimingpointIndexMultiplier != 1 || vm.TimingpointIndexOffset != 0)
{
if (Filter(tp.SampleIndex, tp.Offset, doFilterMatch, doFilterRange, vm.MatchFilter, min,
max))
{
int newIndex =
(int)Math.Round(tp.SampleIndex * vm.TimingpointIndexMultiplier +
vm.TimingpointIndexOffset);
tp.SampleIndex = vm.ClipProperties ? MathHelper.Clamp(newIndex, 0, int.MaxValue) : newIndex;
}
}
// Volume
if (vm.TimingpointVolumeMultiplier != 1 || vm.TimingpointVolumeOffset != 0)
{
if (Filter(tp.Volume, tp.Offset, doFilterMatch, doFilterRange, vm.MatchFilter, min, max))
{
int newVolume =
(int)Math.Round(tp.Volume * vm.TimingpointVolumeMultiplier +
vm.TimingpointVolumeOffset);
tp.Volume = vm.ClipProperties ? MathHelper.Clamp(newVolume, 5, 100) : newVolume;
}
}
}
UpdateProgressBar(worker, 20);
// Hitobject time
if (vm.HitObjectTimeMultiplier != 1 || vm.HitObjectTimeOffset != 0)
{
foreach (HitObject ho in beatmap.HitObjects)
{
// Get the end time early because the start time gets modified
double oldEndTime = ho.GetEndTime(false);
if (Filter(ho.Time, ho.Time, doFilterMatch, doFilterRange, vm.MatchFilter, min, max))
{
ho.Time = Math.Round(ho.Time * vm.HitObjectTimeMultiplier + vm.HitObjectTimeOffset);
}
// Transform end time of hold notes and spinner
if ((ho.IsHoldNote || ho.IsSpinner) &&
Filter(oldEndTime, oldEndTime, doFilterMatch, doFilterRange, vm.MatchFilter, min, max))
{
ho.EndTime = Math.Round(oldEndTime * vm.HitObjectTimeMultiplier + vm.HitObjectTimeOffset);
}
}
}
UpdateProgressBar(worker, 30);
// Bookmark time
if (vm.BookmarkTimeMultiplier != 1 || vm.BookmarkTimeOffset != 0)
{
List <double> newBookmarks = new List <double>();
List <double> bookmarks = beatmap.GetBookmarks();
foreach (double bookmark in bookmarks)
{
if (Filter(bookmark, bookmark, doFilterMatch, doFilterRange, vm.MatchFilter, min, max))
{
newBookmarks.Add(
Math.Round(bookmark * vm.BookmarkTimeMultiplier + vm.BookmarkTimeOffset));
}
else
{
newBookmarks.Add(bookmark);
}
}
beatmap.SetBookmarks(newBookmarks);
}
UpdateProgressBar(worker, 40);
// Storyboarded event time
if (vm.SBEventTimeMultiplier != 1 || vm.SBEventTimeOffset != 0)
{
foreach (Event ev in beatmap.StoryboardLayerBackground.Concat(beatmap.StoryboardLayerFail)
.Concat(beatmap.StoryboardLayerPass).Concat(beatmap.StoryboardLayerForeground)
.Concat(beatmap.StoryboardLayerOverlay))
{
TransformEventTime(ev, vm.SBEventTimeMultiplier, vm.SBEventTimeOffset, doFilterMatch,
doFilterRange, vm.MatchFilter, min, max);
}
}
UpdateProgressBar(worker, 50);
// Storyboarded sample time
if (vm.SBSampleTimeMultiplier != 1 || vm.SBSampleTimeOffset != 0)
{
foreach (StoryboardSoundSample ss in beatmap.StoryboardSoundSamples)
{
if (Filter(ss.StartTime, ss.StartTime, doFilterMatch, doFilterRange, vm.MatchFilter, min,
max))
{
ss.StartTime =
(int)Math.Round(ss.StartTime * vm.SBSampleTimeMultiplier + vm.SBSampleTimeOffset);
}
}
}
UpdateProgressBar(worker, 60);
// Break time
if (vm.BreakTimeMultiplier != 1 || vm.BreakTimeOffset != 0)
{
foreach (Break br in beatmap.BreakPeriods)
{
if (Filter(br.StartTime, br.StartTime, doFilterMatch, doFilterRange, vm.MatchFilter, min,
max))
{
br.StartTime =
(int)Math.Round(br.StartTime * vm.BreakTimeMultiplier + vm.BreakTimeOffset);
}
if (Filter(br.EndTime, br.EndTime, doFilterMatch, doFilterRange, vm.MatchFilter, min,
max))
{
br.EndTime = (int)Math.Round(br.EndTime * vm.BreakTimeMultiplier + vm.BreakTimeOffset);
}
}
}
UpdateProgressBar(worker, 70);
// Video start time
if (vm.VideoTimeMultiplier != 1 || vm.VideoTimeOffset != 0)
{
foreach (Event ev in beatmap.BackgroundAndVideoEvents)
{
if (ev is Video video)
{
if (Filter(video.StartTime, video.StartTime, doFilterMatch, doFilterRange,
vm.MatchFilter, min, max))
{
video.StartTime =
(int)Math.Round(video.StartTime * vm.VideoTimeMultiplier + vm.VideoTimeOffset);
}
}
}
}
UpdateProgressBar(worker, 80);
// Preview point time
if (vm.PreviewTimeMultiplier != 1 || vm.PreviewTimeOffset != 0)
{
if (beatmap.General.ContainsKey("PreviewTime") &&
beatmap.General["PreviewTime"].IntValue != -1)
{
var previewTime = beatmap.General["PreviewTime"].DoubleValue;
if (Filter(previewTime, previewTime, doFilterMatch, doFilterRange, vm.MatchFilter, min,
max))
{
var newPreviewTime =
Math.Round(previewTime * vm.PreviewTimeMultiplier + vm.PreviewTimeOffset);
beatmap.General["PreviewTime"].SetDouble(newPreviewTime);
}
}
}
UpdateProgressBar(worker, 90);
TimingPointsChange.ApplyChanges(beatmap.BeatmapTiming, timingPointsChanges);
// Save the file
beatmapEditor.SaveFile();
UpdateProgressBar(worker, 100);
}
else if (editor is StoryboardEditor storyboardEditor)
{
StoryBoard storyboard = storyboardEditor.StoryBoard;
// Storyboarded event time
if (vm.SBEventTimeMultiplier != 1 || vm.SBEventTimeOffset != 0)
{
foreach (Event ev in storyboard.StoryboardLayerBackground.Concat(storyboard.StoryboardLayerFail)
.Concat(storyboard.StoryboardLayerPass).Concat(storyboard.StoryboardLayerForeground)
.Concat(storyboard.StoryboardLayerOverlay))
{
TransformEventTime(ev, vm.SBEventTimeMultiplier, vm.SBEventTimeOffset, doFilterMatch,
doFilterRange, vm.MatchFilter, min, max);
}
}
UpdateProgressBar(worker, 50);
// Storyboarded sample time
if (vm.SBSampleTimeMultiplier != 1 || vm.SBSampleTimeOffset != 0)
{
foreach (StoryboardSoundSample ss in storyboard.StoryboardSoundSamples)
{
if (Filter(ss.StartTime, ss.StartTime, doFilterMatch, doFilterRange, vm.MatchFilter, min,
max))
{
ss.StartTime =
(int)Math.Round(ss.StartTime * vm.SBSampleTimeMultiplier + vm.SBSampleTimeOffset);
}
}
}
UpdateProgressBar(worker, 70);
// Video start time
if (vm.VideoTimeMultiplier != 1 || vm.VideoTimeOffset != 0)
{
foreach (Event ev in storyboard.BackgroundAndVideoEvents)
{
if (ev is Video video)
{
if (Filter(video.StartTime, video.StartTime, doFilterMatch, doFilterRange,
vm.MatchFilter, min, max))
{
video.StartTime =
(int)Math.Round(video.StartTime * vm.VideoTimeMultiplier + vm.VideoTimeOffset);
}
}
}
}
UpdateProgressBar(worker, 90);
// Save the file
storyboardEditor.SaveFile();
UpdateProgressBar(worker, 100);
}
}
return("Done!");
}
public void ApplyToBeatmap(Beatmap <ManiaHitObject> beatmap)
{
var availableColumns = ((ManiaBeatmap)beatmap).TotalColumns;
beatmap.HitObjects.OfType <ManiaHitObject>().ForEach(h => h.Column = availableColumns - 1 - h.Column);
}
public async Task <Replay> GetReplayFromOnlineId(string onlineId, string mods, Beatmap beatmap)
{
string file = Path.Combine(serverFolder, "replays", $"{onlineId}.osr");
Replay replay = null;
if (!File.Exists(file))
{
Logger.Log(Logging.ReplaysCacheMiss);
await Logger.WriteLine("replay not found, downloading...");
var data = await api.DownloadReplayFromId(onlineId);
if (data != null)
{
replay = new Replay();
replay.Mods = ConvertMods.StringToMods(mods);
replay.headerLoaded = true;
using (MemoryStream ms = new MemoryStream())
using (BinaryWriter bw = new BinaryWriter(ms))
{
bw.WriteNullableString(string.Empty);
bw.Write(DateTime.UtcNow.Ticks);
bw.Write(data.Length);
bw.Write(data);
bw.Write(ulong.Parse(onlineId));
ms.Seek(0, SeekOrigin.Begin);
using (BinaryReader reader = new BinaryReader(ms))
{
replay.replayReader = reader;
replay.Load();
}
}
replay.Save(file);
}
}
else
{
replay = new Replay(file);
Logger.Log(Logging.ReplaysCacheHit);
}
return(replay);
}
protected override IEnumerable <ManiaHitObject> ConvertHitObject(HitObject original, Beatmap beatmap)
{
var maniaOriginal = original as ManiaHitObject;
if (maniaOriginal != null)
{
yield return(maniaOriginal);
yield break;
}
var objects = isForCurrentRuleset ? generateSpecific(original) : generateConverted(original);
if (objects == null)
{
yield break;
}
foreach (ManiaHitObject obj in objects)
{
yield return(obj);
}
}
public SpecificBeatmapPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, int availableColumns, Pattern previousPattern)
: base(random, hitObject, beatmap, availableColumns, previousPattern)
{
}
public TaikoAutoGenerator(Beatmap <TaikoHitObject> beatmap)
: base(beatmap)
{
Replay = new Replay();
}
public override void Generate()
{
var endTime = Math.Min(EndTime, (int)AudioDuration);
var startTime = Math.Min(StartTime, endTime);
var bitmap = GetMapsetBitmap(SpritePath);
var heightKeyframes = new KeyframedValue <float> [BarCount];
for (var i = 0; i < BarCount; i++)
{
heightKeyframes[i] = new KeyframedValue <float>(null);
heightKeyframes[i].Add(StartTime, MinimalHeight);
}
var fftTimeStep = Beatmap.GetTimingPointAt(startTime).BeatDuration / BeatDivisor;
var fftOffset = fftTimeStep * 0.2;
for (var time = (double)startTime + fftTimeStep; time < endTime + tick(0, 1); time += fftTimeStep)
{
var fft = GetFft(time + fftOffset, BarCount, null, FftEasing);
for (var i = 0; i < BarCount; i++)
{
var height = (float)Math.Log10(1 + fft[i] * LogScale) * Scale.Y / bitmap.Height;
if (height < MinimalHeight)
{
height = MinimalHeight;
}
heightKeyframes[i].Add(time, height);
}
}
var layer = GetLayer("Spectrum");
var barWidth = Width / BarCount;
for (var i = 0; i < BarCount; i++)
{
var keyframes = heightKeyframes[i];
keyframes.Simplify1dKeyframes(Tolerance, h => h);
var bar = layer.CreateSprite(SpritePath, OsbOrigin.BottomCentre, new Vector2((float)(Position.X + radius * Math.Cos(i * 2 * Math.PI / BarCount)), (float)(Position.Y + radius * Math.Sin(i * 2 * Math.PI / BarCount))));
//bar.Additive(startTime, endTime);
bar.Rotate(startTime, i * 2 * Math.PI / BarCount + Math.PI / 2);
var scaleX = Scale.X * barWidth / bitmap.Width;
scaleX = (float)Math.Floor(scaleX * 10) / 10.0f;
var hasScale = false;
keyframes.ForEachPair(
(start, end) =>
{
hasScale = true;
bar.ScaleVec(start.Time, end.Time,
scaleX, start.Value,
scaleX, end.Value);
},
MinimalHeight,
s => (float)Math.Round(s, CommandDecimals)
);
var colors = "0,330,0.8,1,0.8,1";
var colorOne = int.Parse(colors.Split(',')[0], System.Globalization.CultureInfo.InvariantCulture);
var colorTwo = int.Parse(colors.Split(',')[1], System.Globalization.CultureInfo.InvariantCulture);
var colorOneSa = double.Parse(colors.Split(',')[2], System.Globalization.CultureInfo.InvariantCulture);
var colorOneBra = double.Parse(colors.Split(',')[3], System.Globalization.CultureInfo.InvariantCulture);
var colorTwoSa = double.Parse(colors.Split(',')[4], System.Globalization.CultureInfo.InvariantCulture);
var colorTwoBra = double.Parse(colors.Split(',')[5], System.Globalization.CultureInfo.InvariantCulture);
if (i % 2 == 0)
{
bar.ColorHsb(startTime, colorOne, colorOneSa, colorOneBra);
}
else
{
bar.ColorHsb(startTime, colorTwo, colorTwoSa, colorTwoBra);
}
if (!hasScale)
{
bar.ScaleVec(startTime, scaleX, MinimalHeight);
}
bar.Fade(EndTime, EndTime + tick(0, 1), 1, 0);
}
}
private void UpdateSuggestionsAsync(double minPp, int gameMode)
{
scoreSugDisplay = new SortableBindingList<ScoreInfo>();
beatmapCache = new Dictionary<int, Beatmap>();
for (int index = 0; index < currentUser.BestScores.Count; index++)
{
var score = currentUser.BestScores[index];
beatmapCache.Add(score.Beatmap_Id, null);
}
string statsjson = "";
Debug.WriteLine(@"http://osustats.ezoweb.de/API/osuTrainer.php?mode=" + gameMode + @"&pp_value=" + (int)minPp + @"&mod_only_selected=" + ExclusiveCB.Checked.ToString().ToLower() + @"&mod_string=" + SelectedModsToString());
try
{
statsjson = client.DownloadString(@"http://osustats.ezoweb.de/API/osuTrainer.php?mode=" + gameMode + @"&pp_value=" + (int)minPp + @"&mod_only_selected=" + ExclusiveCB.Checked.ToString().ToLower() + @"&mod_string=" + SelectedModsToString());
}
catch (Exception)
{
return;
}
if (statsjson.Length < 3) return;
var osuStatsScores = JsonSerializer.DeserializeFromString<List<OsuStatsScores>>(statsjson);
osuStatsScores =
osuStatsScores.GroupBy(e => new { e.Beatmap_Id, e.Enabled_Mods }).Select(g => g.First()).ToList();
for (int i = 0; i < osuStatsScores.Count; i++)
{
if (beatmapCache.ContainsKey((osuStatsScores[i].Beatmap_Id))) continue;
var dtmodifier = 1.0;
var beatmap = new Beatmap
{
Beatmap_id = osuStatsScores[i].Beatmap_Id,
BeatmapSet_id = osuStatsScores[i].Beatmap_SetId,
Total_length = osuStatsScores[i].Beatmap_Total_Length,
Hit_length = osuStatsScores[i].Beatmap_Hit_Length,
Version = osuStatsScores[i].Beatmap_Version,
Artist = osuStatsScores[i].Beatmap_Artist,
Title = osuStatsScores[i].Beatmap_Title,
Creator = osuStatsScores[i].Beatmap_Creator,
Bpm = osuStatsScores[i].Beatmap_Bpm,
Difficultyrating = osuStatsScores[i].Beatmap_Diffrating,
Url = GlobalVars.Beatmap + osuStatsScores[i].Beatmap_Id,
BloodcatUrl = GlobalVars.Bloodcat + osuStatsScores[i].Beatmap_SetId,
ThumbnailUrl = @"http://b.ppy.sh/thumb/" + osuStatsScores[i].Beatmap_SetId + @"l.jpg"
};
beatmapCache[osuStatsScores[i].Beatmap_Id] = beatmap;
if (osuStatsScores[i].Enabled_Mods.HasFlag(GlobalVars.Mods.DT) || osuStatsScores[i].Enabled_Mods.HasFlag(GlobalVars.Mods.NC))
{
dtmodifier = 1.5;
}
scoreSugDisplay.Add(new ScoreInfo
{
Mods = (osuStatsScores[i].Enabled_Mods & ~GlobalVars.Mods.Autoplay),
BeatmapName = osuStatsScores[i].Beatmap_Title,
Version = osuStatsScores[i].Beatmap_Version,
Creator = osuStatsScores[i].Beatmap_Creator,
Artist = osuStatsScores[i].Beatmap_Artist,
BPM = (int)Math.Truncate(beatmap.Bpm * dtmodifier),
ppRaw = (int)Math.Truncate(osuStatsScores[i].PP_Value),
RankImage = GetRankImage(osuStatsScores[i].Rank),
BeatmapId = osuStatsScores[i].Beatmap_Id
});
Invoke((MethodInvoker)delegate
{
if (progressBar1.Value < pbMax)
{
progressBar1.Value++;
}
ScoresAddedLbl.Text = Convert.ToString(scoreSugDisplay.Count);
});
}
}
public bool Contains(Beatmap tmpbm)
{
if (location == tmpbm.Location) { return true; } else { return false; }
/* if (setid == -1) {
if (name==tmpbm.ArtistRomanized + " - " + tmpbm.TitleRomanized){return true;}else{return false;}
}
if (tmpbm.beatmapsetId == setid) { return true; }
return false;*/
}
private void beginHandlingTrack()
{
Beatmap.BindValueChanged(updateTrack, true);
}
private void handleColours(Beatmap beatmap, string key, string val)
{
string[] split = val.Split(',');
if (split.Length != 3)
throw new InvalidOperationException($@"Color specified in incorrect format (should be R,G,B): {val}");
byte r, g, b;
if (!byte.TryParse(split[0], out r) || !byte.TryParse(split[1], out g) || !byte.TryParse(split[2], out b))
throw new InvalidOperationException($@"Color must be specified with 8-bit integer components");
// Note: the combo index specified in the beatmap is discarded
beatmap.ComboColors.Add(new Color4
{
R = r / 255f,
G = g / 255f,
B = b / 255f,
A = 1f,
});
}
private string Adjust_Timing(TimingHelperVm arg, BackgroundWorker worker, DoWorkEventArgs _)
{
// Count
int redlinesAdded = 0;
var reader = EditorReaderStuff.GetFullEditorReaderOrNot();
foreach (string path in arg.Paths)
{
// Open beatmap
var editor = EditorReaderStuff.GetNewestVersionOrNot(path, reader);
Beatmap beatmap = editor.Beatmap;
Timing timing = beatmap.BeatmapTiming;
// Get all the times to snap
List <Marker> markers = new List <Marker>();
if (arg.Objects)
{
markers.AddRange(beatmap.HitObjects.Select(ho => new Marker(ho.Time)));
}
if (arg.Bookmarks)
{
markers.AddRange(beatmap.GetBookmarks().Select(time => new Marker(time)));
}
if (arg.Greenlines)
{
// Get the offsets of greenlines
markers.AddRange(from tp in timing.TimingPoints where !tp.Uninherited select new Marker(tp.Offset));
}
if (arg.Redlines)
{
// Get the offsets of redlines
markers.AddRange(from tp in timing.TimingPoints where tp.Uninherited select new Marker(tp.Offset));
}
// Update progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(20);
}
// Sort the markers
markers = markers.OrderBy(o => o.Time).ToList();
// Calculate the beats between time and the last time or redline for each time
// Time the same is 0
// Time a little after is smallest snap
foreach (var marker in markers)
{
double time = marker.Time;
TimingPoint redline = timing.GetRedlineAtTime(time - 1);
// Resnap to that redline only
double resnappedTime = timing.Resnap(time, arg.Snap1, arg.Snap2, false, redline);
// Calculate beats from the redline
double beatsFromRedline = (resnappedTime - redline.Offset) / redline.MpB;
// Avoid problems
if (MathHelper.ApproximatelyEquivalent(beatsFromRedline, 0, 0.0001))
{
beatsFromRedline = 1d / Math.Max(arg.Snap1, arg.Snap2);
}
if (time == redline.Offset)
{
beatsFromRedline = 0;
}
// Initialize the beats from last marker
double beatsFromLastMarker = beatsFromRedline;
// Get the times between redline and this time
List <Marker> timesBefore = markers.Where(o => o.Time <time && o.Time> redline.Offset).ToList();
if (timesBefore.Count > 0)
{
// Get the last time info
double lastTime = timesBefore.Last().Time;
double resnappedTimeL = timing.Resnap(lastTime, arg.Snap1, arg.Snap2, false);
// Change the beats from last marker
beatsFromLastMarker = (resnappedTime - resnappedTimeL) / redline.MpB;
// Avoid problems
if (MathHelper.ApproximatelyEquivalent(beatsFromLastMarker, 0, 0.0001))
{
beatsFromLastMarker = 1f / Math.Max(arg.Snap1, arg.Snap2);
}
if (lastTime == time)
{
beatsFromLastMarker = 0;
}
}
// Set the variable
marker.BeatsFromLastMarker = beatsFromLastMarker;
}
// Remove redlines except the first redline
if (!arg.Redlines)
{
var first = timing.TimingPoints.FirstOrDefault(o => o.Uninherited);
timing.TimingPoints.RemoveAll(o => o.Uninherited && o != first);
}
// Update progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(40);
}
// Loop through all the markers
for (int i = 0; i < markers.Count; i++)
{
Marker marker = markers[i];
double time = marker.Time;
TimingPoint redline = timing.GetRedlineAtTime(time - 1);
double beatsFromLastMarker = arg.BeatsBetween != -1 ? arg.BeatsBetween : marker.BeatsFromLastMarker;
// Skip if 0 beats from last marker
if (beatsFromLastMarker == 0)
{
continue;
}
// Get the times between redline and this time including this time
List <Marker> markersBefore = markers.Where(o => o.Time <time && o.Time> redline.Offset).ToList();
markersBefore.Add(marker);
// Calculate MpB
// Average MpB from timesBefore and use time from redline
double mpb = 0;
double beatsFromRedline = 0;
foreach (Marker markerB in markersBefore)
{
beatsFromRedline += markerB.BeatsFromLastMarker;
mpb += GetMpB(markerB.Time - redline.Offset, beatsFromRedline, 0);
}
mpb /= markersBefore.Count;
// Check if this MpB doesn't make the markers go offsnap too far
bool canChangeRedline = CheckMpB(mpb, markersBefore, redline, arg);
// Make changes
if (canChangeRedline)
{
// Round the MpB to human values first
mpb = HumanRoundMpB(mpb, markersBefore, redline, arg);
// Change the MpB of the redline
redline.MpB = mpb;
}
else
{
// Get the last time info and not the current
markersBefore.Remove(marker);
double lastTime = markersBefore.Last().Time;
// Make new redline
TimingPoint newRedline = redline.Copy();
TimingPoint lastHitsounds = timing.GetTimingPointAtTime(lastTime + 5);
newRedline.Offset = lastTime;
newRedline.OmitFirstBarLine = arg.OmitBarline; // Set omit to the argument
newRedline.Kiai = lastHitsounds.Kiai;
newRedline.SampleIndex = lastHitsounds.SampleIndex;
newRedline.SampleSet = lastHitsounds.SampleSet;
newRedline.Volume = lastHitsounds.Volume;
timing.TimingPoints.Add(newRedline);
timing.Sort();
// Set the MpB
newRedline.MpB = GetMpB(time - lastTime, beatsFromLastMarker, arg.Leniency);
// Update the counter
redlinesAdded++;
}
// Update progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(i * 60 / markers.Count + 40);
}
}
// Save the file
editor.SaveFile();
}
// Complete progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(100);
}
// Do QuickRun stuff
if (arg.Quick)
{
RunFinished?.Invoke(this, new RunToolCompletedEventArgs(true, reader != null));
}
// Make an accurate message
string message = "Successfully added ";
message += redlinesAdded;
if (Math.Abs(redlinesAdded) == 1)
{
message += " redlines!";
}
else
{
message += " redlines!";
}
return(arg.Quick ? string.Empty : message);
}
private void handleGeneral(Beatmap beatmap, string key, string val)
{
var metadata = beatmap.BeatmapInfo.Metadata;
switch (key)
{
case @"AudioFilename":
metadata.AudioFile = val;
break;
case @"AudioLeadIn":
beatmap.BeatmapInfo.AudioLeadIn = int.Parse(val);
break;
case @"PreviewTime":
metadata.PreviewTime = int.Parse(val);
break;
case @"Countdown":
beatmap.BeatmapInfo.Countdown = int.Parse(val) == 1;
break;
case @"SampleSet":
beatmap.BeatmapInfo.SampleSet = (SampleSet)Enum.Parse(typeof(SampleSet), val);
break;
case @"StackLeniency":
beatmap.BeatmapInfo.StackLeniency = float.Parse(val, NumberFormatInfo.InvariantInfo);
break;
case @"Mode":
beatmap.BeatmapInfo.Mode = (PlayMode)int.Parse(val);
break;
case @"LetterboxInBreaks":
beatmap.BeatmapInfo.LetterboxInBreaks = int.Parse(val) == 1;
break;
case @"SpecialStyle":
beatmap.BeatmapInfo.SpecialStyle = int.Parse(val) == 1;
break;
case @"WidescreenStoryboard":
beatmap.BeatmapInfo.WidescreenStoryboard = int.Parse(val) == 1;
break;
}
}
public WaveformTestBeatmap(AudioManager audioManager, Beatmap beatmap)
: base(beatmap.BeatmapInfo, audioManager)
{
this.beatmap = beatmap;
trackStore = audioManager.GetTrackStore(getZipReader());
}
private void UpdateSuggestionsAsync(double minPp, int gameMode)
{
int[] userids;
int startid;
switch (gameMode)
{
case 0:
userids = standardids;
startid = currentUser.PpRaw < 200 ? 12843 :
currentUser.PpRank < 5001 ? currentUser.PpRank - 2 :
FindStartingUser(currentUser.PpRaw, gameMode, userids);
break;
case 1:
userids = taikoids;
startid = currentUser.PpRaw < 200 ? 6806 :
currentUser.PpRank < 5001 ? currentUser.PpRank - 2 :
FindStartingUser(currentUser.PpRaw, gameMode, userids);
break;
case 2:
userids = ctbids;
startid = currentUser.PpRaw < 200 ? 7638 :
currentUser.PpRank < 5001 ? currentUser.PpRank - 2 :
FindStartingUser(currentUser.PpRaw, gameMode, userids);
break;
case 3:
userids = maniaids;
startid = currentUser.PpRaw < 200 ? 7569 :
currentUser.PpRank < 5001 ? currentUser.PpRank - 2 :
FindStartingUser(currentUser.PpRaw, gameMode, userids);
break;
default:
return;
}
scoreSugDisplay = new SortableBindingList<ScoreInfo>();
beatmapCache = new Dictionary<int, Beatmap>();
var modsAndNv = mods | GlobalVars.Mods.NV;
foreach (var score in currentUser.BestScores)
{
beatmapCache.Add(score.Beatmap_Id, null);
}
var pChecked = 0;
var sw = Stopwatch.StartNew();
Parallel.For(0, 999, (i, state) =>
{
while (sw.Elapsed < maxDuration)
{
var json = "";
lock (firstLock)
{
if (startid < 0)
{
state.Break();
return;
}
json = client.DownloadString(GlobalVars.UserBestAPI + userids[startid] + GlobalVars.Mode + gameMode);
startid -= skippedIds;
pChecked++;
int @checked = pChecked;
Invoke((MethodInvoker)delegate
{
PlayersCheckedLbl.Text = @checked.ToString(CultureInfo.InvariantCulture);
});
}
var userBestList = JsonSerializer.DeserializeFromString<List<UserBest>>(json);
for (var j = 0; j < userBestList.Count; j++)
{
if (userBestList[j].PP < minPp)
{
break;
}
if ((!ExclusiveCB.Checked ||
(userBestList[j].Enabled_Mods != modsAndNv && userBestList[j].Enabled_Mods != mods)) &&
(ExclusiveCB.Checked || !userBestList[j].Enabled_Mods.HasFlag(mods))) continue;
lock (secondLock)
{
if (beatmapCache.ContainsKey(userBestList[j].Beatmap_Id)) continue;
var beatmap = new Beatmap(userBestList[j].Beatmap_Id);
var dtmodifier = 1.0;
if (userBestList[j].Enabled_Mods.HasFlag(GlobalVars.Mods.DT) || userBestList[j].Enabled_Mods.HasFlag(GlobalVars.Mods.NC))
{
dtmodifier = 1.5;
}
beatmapCache[beatmap.Beatmap_id] = beatmap;
scoreSugDisplay.Add(new ScoreInfo
{
BeatmapName = beatmap.Title,
Version = beatmap.Version,
Creator = beatmap.Creator,
Artist = beatmap.Artist,
Mods = userBestList[j].Enabled_Mods,
BPM = (int)Math.Truncate(beatmap.Bpm * dtmodifier),
ppRaw = (int)Math.Truncate(userBestList[j].PP),
RankImage = GetRankImage(userBestList[j].Rank),
BeatmapId = beatmap.Beatmap_id
});
Invoke((MethodInvoker)delegate
{
if (progressBar1.Value < pbMax)
{
progressBar1.Value++;
}
ScoresAddedLbl.Text = Convert.ToString(scoreSugDisplay.Count);
});
}
}
}
state.Break();
});
}
public LOsuDatabaseLoader(IMapDataManager mapDataStorer, Beatmap tempBeatmap) : base(mapDataStorer, tempBeatmap)
{
}
protected override IEnumerable <ManiaBaseHit> ConvertHitObject(HitObject original, Beatmap beatmap)
{
yield return(null);
}
public static PhigrosBeatmapData Stager_to_Phigros(Beatmap sMap)
{
if (sMap == null)
{
return(null);
}
sMap.SortNotesByTime();
var pMap = new PhigrosBeatmapData()
{
formatVersion = 1,
offset = 0f,
numOfNotes = sMap.Notes.Count,
judgeLineList = new JudgelineData[sMap.Stages.Count],
};
float spb = 60f / sMap.BPM;
for (int stageIndex = 0; stageIndex < sMap.Stages.Count; stageIndex++)
{
var noteAbove = new List <Note>();
var noteBelow = new List <Note>();
float maxNoteTime = 0f;
foreach (var note in sMap.Notes)
{
if (note.TrackIndex == stageIndex * 2)
{
// Above
noteAbove.Add(new Note()
{
type = note.ItemType + 1,
time = (int)(note.Time * 100),
holdTime = (note.ItemType + 1) == (int)NoteType.Hold ? (int)(note.Duration * 100) : 0,
positionX = Util.Remap(0f, 1f, -10f, 10f, note.X),
floorPosition = 25f / 8f * note.Time * spb,
speed = 1f,
});
}
else if (note.TrackIndex == stageIndex * 2 + 1)
{
// Below
noteAbove.Add(new Note()
{
type = note.ItemType + 1,
time = (int)(note.Time * 100),
holdTime = (note.ItemType + 1) == (int)NoteType.Hold ? (int)(note.Duration * 100) : 0,
positionX = Util.Remap(0f, 1f, -10f, 10f, note.X),
floorPosition = 25f / 8f * note.Time * spb,
speed = 1f,
});
}
maxNoteTime = Mathf.Max(maxNoteTime, note.Time + note.Duration);
}
var stage = sMap.Stages[stageIndex];
pMap.judgeLineList[stageIndex] = new JudgelineData()
{
bpm = sMap.BPM,
numOfNotes = noteAbove.Count + noteBelow.Count,
numOfNotesAbove = noteAbove.Count,
numOfNotesBelow = noteBelow.Count,
notesAbove = noteAbove.ToArray(),
notesBelow = noteBelow.ToArray(),
judgeLineDisappearEvents = GetDisappears(stage.Colors, maxNoteTime, stage.Time),
judgeLineMoveEvents = GetMoves(stage.Positions, maxNoteTime, stage.Time),
judgeLineRotateEvents = GetRotations(stage.Rotations, maxNoteTime, stage.Time),
speedEvents = new SpeedEvent[1] {
new SpeedEvent()
{
startTime = -1,
endTime = (int)(maxNoteTime * 100),
value = 1f,
}
},
};
}
return(pMap);
}
private void generateVerticalStripeTransition(double startTime, int thickness, Color4 color, int angle, bool rightToLeft = false)
{
Assert((angle < 90 && angle >= 0) || (angle > -90 && angle <= 0), "Parameter angle of generateVerticalStripeTransition() can only accept value from -90 to 90 degree.");
var beat = Beatmap.GetTimingPointAt(965).BeatDuration;
var actualLength = 854 + 480 * Math.Tan(MathHelper.DegreesToRadians(Math.Abs(angle)));
var spriteLength = (float)(Math.Sqrt(Math.Pow(854, 2) + Math.Pow(480, 2)) + thickness * Math.Tan(MathHelper.DegreesToRadians(Math.Abs(angle))));
if (angle < 90 && angle >= 0)
{
var openOrigin = rightToLeft ? OsbOrigin.TopRight : OsbOrigin.TopLeft;
var closeOrigin = rightToLeft ? OsbOrigin.TopLeft : OsbOrigin.TopRight;
var openX = rightToLeft
? (float)(-107 + thickness / Math.Cos(MathHelper.DegreesToRadians(angle)))
: (float)(-107 + thickness * (1 / Math.Sin(MathHelper.DegreesToRadians(angle)) - Math.Cos(MathHelper.DegreesToRadians(angle))));
var openY = rightToLeft
? 0f
: (float)(0 - thickness * Math.Sin(MathHelper.DegreesToRadians(angle)));
var closeX = rightToLeft
? (float)(openX - thickness * Math.Cos(MathHelper.DegreesToRadians(angle)))
: (float)(-107 + thickness / Math.Cos(MathHelper.DegreesToRadians(angle)));
var closeY = rightToLeft
? (float)(0 - thickness * Math.Sin(MathHelper.DegreesToRadians(angle)))
: 0f;
for (int i = 0; i <= (int)(actualLength / (thickness / Math.Cos(MathHelper.DegreesToRadians(angle)))); i++)
{
var openSprite = GetLayer("transition").CreateSprite("sb/common/pixel.png", openOrigin, new Vector2(openX, openY));
openSprite.Color(startTime, color);
openSprite.Rotate(startTime, MathHelper.DegreesToRadians(angle));
openSprite.ScaleVec(OsbEasing.OutExpo, startTime, startTime + beat, new Vector2(0, spriteLength), new Vector2(thickness, spriteLength));
openSprite.Fade(startTime, 1);
openSprite.Fade(startTime + beat, 0);
var closeSprite = GetLayer("transition").CreateSprite("sb/common/pixel.png", closeOrigin, new Vector2(closeX, closeY));
closeSprite.Color(startTime + beat, color);
closeSprite.Rotate(startTime + beat, MathHelper.DegreesToRadians(angle));
closeSprite.ScaleVec(OsbEasing.OutCirc, startTime + beat, startTime + beat * 2, new Vector2(thickness, spriteLength), new Vector2(0, spriteLength));
closeSprite.Fade(startTime + beat, 1);
closeSprite.Fade(startTime + beat * 2, 0);
openX += (float)(thickness / Math.Cos(MathHelper.DegreesToRadians(angle)));
closeX += (float)(thickness / Math.Cos(MathHelper.DegreesToRadians(angle)));
}
}
else if (angle > -90 && angle <= 0)
{
var openOrigin = rightToLeft ? OsbOrigin.BottomRight : OsbOrigin.BottomLeft;
var closeOrigin = rightToLeft ? OsbOrigin.BottomLeft : OsbOrigin.BottomRight;
var openX = rightToLeft
? (float)(-107 + thickness / Math.Cos(MathHelper.DegreesToRadians(angle)))
: (float)(-107 + thickness * (1 / Math.Sin(MathHelper.DegreesToRadians(Math.Abs(angle))) - Math.Cos(MathHelper.DegreesToRadians(angle))));
var openY = rightToLeft
? 480f
: (float)(480 + thickness * Math.Sin(MathHelper.DegreesToRadians(Math.Abs(angle))));
var closeX = rightToLeft
? (float)(openX - thickness * Math.Cos(MathHelper.DegreesToRadians(angle)))
: (float)(-107 + thickness / Math.Cos(MathHelper.DegreesToRadians(angle)));
var closeY = rightToLeft
? (float)(480 + thickness * Math.Sin(MathHelper.DegreesToRadians(Math.Abs(angle))))
: 480f;
for (int i = 0; i <= (int)(actualLength / (thickness / Math.Cos(MathHelper.DegreesToRadians(angle)))); i++)
{
var openSprite = GetLayer("open-stripe").CreateSprite("sb/common/pixel.png", openOrigin, new Vector2(openX, openY));
openSprite.Color(startTime, color);
openSprite.Rotate(startTime, MathHelper.DegreesToRadians(angle));
openSprite.ScaleVec(OsbEasing.OutExpo, startTime, startTime + beat, new Vector2(0, spriteLength), new Vector2(thickness, spriteLength));
openSprite.Fade(startTime, 1);
openSprite.Fade(startTime + beat, 0);
var closeSprite = GetLayer("close-stripe").CreateSprite("sb/common/pixel.png", closeOrigin, new Vector2(closeX, closeY));
closeSprite.Color(startTime + beat, color);
closeSprite.Rotate(startTime + beat, MathHelper.DegreesToRadians(angle));
closeSprite.ScaleVec(OsbEasing.OutCirc, startTime + beat, startTime + beat * 2, new Vector2(thickness, spriteLength), new Vector2(0, spriteLength));
closeSprite.Fade(startTime + beat, 1);
closeSprite.Fade(startTime + beat * 2, 0);
openX += (float)(thickness / Math.Cos(MathHelper.DegreesToRadians(angle)));
closeX += (float)(thickness / Math.Cos(MathHelper.DegreesToRadians(angle)));
}
}
}
// API
public static Beatmap Phigros_to_Stager(PhigrosBeatmapData pMap)
{
if (pMap == null || pMap.judgeLineList == null || pMap.judgeLineList.Length == 0)
{
return(null);
}
var sMap = new Beatmap()
{
Tag = "Phigros",
Level = 1,
BPM = (int)pMap.judgeLineList[0].bpm,
Ratio = 880f / 520f,
CreatedTime = System.DateTime.Now.Ticks,
Shift = 0f,
Stages = { },
Tracks = { },
Notes = { },
Timings = { },
};
float spb = 60f / sMap.bpm;
for (int index = 0; index < pMap.judgeLineList.Length; index++)
{
var jLine = pMap.judgeLineList[index];
// Stages
float time = -1f;
float duration = -1f;
foreach (var d in jLine.judgeLineDisappearEvents)
{
if (Mathf.Max(d.startTime, 0) >= d.endTime)
{
continue;
}
if (d.start == 1)
{
// Time
if (time < -0.5f)
{
time = GetRealTime(d.startTime, spb);
}
// Duration
duration = Mathf.Max(GetRealTime(d.endTime, spb) - time, duration);
}
}
sMap.Stages.Add(new Beatmap.Stage()
{
Time = time,
Duration = duration > 0f ? duration : float.MaxValue,
Height = 520f / 880f,
ItemType = 0,
Rotation = 0f,
Speed = 1f,
Width = 1f,
X = 0f,
Y = 0f,
Color = 0,
Positions = GetStagePositions(jLine.judgeLineMoveEvents, -time, spb),
Rotations = GetStageRotations(jLine.judgeLineRotateEvents, -time, spb),
Colors = GetStageColors(jLine.judgeLineDisappearEvents, -time, spb),
Widths = { },
Heights = { },
});
// Tracks
sMap.Tracks.Add(new Beatmap.Track()
{
StageIndex = index,
Angle = 0f,
X = 0.5f,
Time = time,
Duration = duration > 0f ? duration : float.MaxValue,
Color = 0,
HasTray = false,
ItemType = 0,
Width = 1f,
Speed = 1f,
Widths = { },
Xs = { },
Angles = { },
Colors = { },
});
sMap.Tracks.Add(new Beatmap.Track()
{
StageIndex = index,
Angle = 180f,
X = 0.5f,
Time = time,
Duration = duration > 0f ? duration : float.MaxValue,
Color = 0,
HasTray = false,
ItemType = 0,
Width = 1f,
Speed = 1f,
Widths = { },
Xs = { },
Angles = { },
Colors = { },
});
// Notes
foreach (var note in jLine.notesAbove)
{
sMap.Notes.Add(new Beatmap.Note()
{
TrackIndex = index * 2,
Time = GetRealTime(note.time, spb),
X = Util.Remap(-10f, 10f, 0f, 1f, note.positionX),
Duration = note.type == (int)NoteType.Hold ? GetRealTime(note.holdTime, spb) : 0f,
Speed = note.speed,
ClickSoundIndex = 0,
ItemType = note.type - 1,
LinkedNoteIndex = -1,
Width = 1f / 7f,
Z = 0f,
SoundFxIndex = 0,
SoundFxParamA = 0,
SoundFxParamB = 0,
});
}
foreach (var note in jLine.notesBelow)
{
sMap.Notes.Add(new Beatmap.Note()
{
TrackIndex = index * 2 + 1,
Time = GetRealTime(note.time, spb),
X = Util.Remap(-10f, 10f, 0f, 1f, note.positionX),
Duration = note.type == (int)NoteType.Hold ? GetRealTime(note.holdTime, spb) : 0f,
Speed = note.speed,
ClickSoundIndex = 0,
ItemType = note.type - 1,
LinkedNoteIndex = -1,
Width = 1f / 7f,
Z = 0f,
SoundFxIndex = 0,
SoundFxParamA = 0,
SoundFxParamB = 0,
});
}
// Timings
foreach (var sEvent in jLine.speedEvents)
{
sMap.Timings.Add(new Beatmap.Timing(Mathf.Max(sEvent.startTime / 100f, 0f), sEvent.value));
}
}
return(sMap);
}
private void applyStacking(Beatmap <OsuHitObject> beatmap, int startIndex, int endIndex)
{
if (startIndex > endIndex)
{
throw new ArgumentOutOfRangeException(nameof(startIndex), $"{nameof(startIndex)} cannot be greater than {nameof(endIndex)}.");
}
if (startIndex < 0)
{
throw new ArgumentOutOfRangeException(nameof(startIndex), $"{nameof(startIndex)} cannot be less than 0.");
}
if (endIndex < 0)
{
throw new ArgumentOutOfRangeException(nameof(endIndex), $"{nameof(endIndex)} cannot be less than 0.");
}
int extendedEndIndex = endIndex;
if (endIndex < beatmap.HitObjects.Count - 1)
{
// Extend the end index to include objects they are stacked on
for (int i = endIndex; i >= startIndex; i--)
{
int stackBaseIndex = i;
for (int n = stackBaseIndex + 1; n < beatmap.HitObjects.Count; n++)
{
OsuHitObject stackBaseObject = beatmap.HitObjects[stackBaseIndex];
if (stackBaseObject is Spinner)
{
break;
}
OsuHitObject objectN = beatmap.HitObjects[n];
if (objectN is Spinner)
{
continue;
}
double endTime = (stackBaseObject as IHasEndTime)?.EndTime ?? stackBaseObject.StartTime;
double stackThreshold = objectN.TimePreempt * beatmap.BeatmapInfo.StackLeniency;
if (objectN.StartTime - endTime > stackThreshold)
{
//We are no longer within stacking range of the next object.
break;
}
if (Vector2Extensions.Distance(stackBaseObject.Position, objectN.Position) < stack_distance ||
stackBaseObject is Slider && Vector2Extensions.Distance(stackBaseObject.EndPosition, objectN.Position) < stack_distance)
{
stackBaseIndex = n;
// HitObjects after the specified update range haven't been reset yet
objectN.StackHeight = 0;
}
}
if (stackBaseIndex > extendedEndIndex)
{
extendedEndIndex = stackBaseIndex;
if (extendedEndIndex == beatmap.HitObjects.Count - 1)
{
break;
}
}
}
}
//Reverse pass for stack calculation.
int extendedStartIndex = startIndex;
for (int i = extendedEndIndex; i > startIndex; i--)
{
int n = i;
/* We should check every note which has not yet got a stack.
* Consider the case we have two interwound stacks and this will make sense.
*
* o <-1 o <-2
* o <-3 o <-4
*
* We first process starting from 4 and handle 2,
* then we come backwards on the i loop iteration until we reach 3 and handle 1.
* 2 and 1 will be ignored in the i loop because they already have a stack value.
*/
OsuHitObject objectI = beatmap.HitObjects[i];
if (objectI.StackHeight != 0 || objectI is Spinner)
{
continue;
}
double stackThreshold = objectI.TimePreempt * beatmap.BeatmapInfo.StackLeniency;
/* If this object is a hitcircle, then we enter this "special" case.
* It either ends with a stack of hitcircles only, or a stack of hitcircles that are underneath a slider.
* Any other case is handled by the "is Slider" code below this.
*/
if (objectI is HitCircle)
{
while (--n >= 0)
{
OsuHitObject objectN = beatmap.HitObjects[n];
if (objectN is Spinner)
{
continue;
}
double endTime = (objectN as IHasEndTime)?.EndTime ?? objectN.StartTime;
if (objectI.StartTime - endTime > stackThreshold)
{
//We are no longer within stacking range of the previous object.
break;
}
// HitObjects before the specified update range haven't been reset yet
if (n < extendedStartIndex)
{
objectN.StackHeight = 0;
extendedStartIndex = n;
}
/* This is a special case where hticircles are moved DOWN and RIGHT (negative stacking) if they are under the *last* slider in a stacked pattern.
* o==o <- slider is at original location
* o <- hitCircle has stack of -1
* o <- hitCircle has stack of -2
*/
if (objectN is Slider && Vector2Extensions.Distance(objectN.EndPosition, objectI.Position) < stack_distance)
{
int offset = objectI.StackHeight - objectN.StackHeight + 1;
for (int j = n + 1; j <= i; j++)
{
//For each object which was declared under this slider, we will offset it to appear *below* the slider end (rather than above).
OsuHitObject objectJ = beatmap.HitObjects[j];
if (Vector2Extensions.Distance(objectN.EndPosition, objectJ.Position) < stack_distance)
{
objectJ.StackHeight -= offset;
}
}
//We have hit a slider. We should restart calculation using this as the new base.
//Breaking here will mean that the slider still has StackCount of 0, so will be handled in the i-outer-loop.
break;
}
if (Vector2Extensions.Distance(objectN.Position, objectI.Position) < stack_distance)
{
//Keep processing as if there are no sliders. If we come across a slider, this gets cancelled out.
//NOTE: Sliders with start positions stacking are a special case that is also handled here.
objectN.StackHeight = objectI.StackHeight + 1;
objectI = objectN;
}
}
}
else if (objectI is Slider)
{
/* We have hit the first slider in a possible stack.
* From this point on, we ALWAYS stack positive regardless.
*/
while (--n >= startIndex)
{
OsuHitObject objectN = beatmap.HitObjects[n];
if (objectN is Spinner)
{
continue;
}
if (objectI.StartTime - objectN.StartTime > stackThreshold)
{
//We are no longer within stacking range of the previous object.
break;
}
if (Vector2Extensions.Distance(objectN.EndPosition, objectI.Position) < stack_distance)
{
objectN.StackHeight = objectI.StackHeight + 1;
objectI = objectN;
}
}
}
}
}
private string Copy_Timing(TimingCopierVm arg, BackgroundWorker worker, DoWorkEventArgs _)
{
string[] paths = arg.ExportPath.Split('|');
int mapsDone = 0;
var reader = EditorReaderStuff.GetFullEditorReaderOrNot();
foreach (string exportPath in paths)
{
var editorTo = EditorReaderStuff.GetNewestVersionOrNot(exportPath, reader);
var editorFrom = EditorReaderStuff.GetNewestVersionOrNot(arg.ImportPath, reader);
Beatmap beatmapTo = editorTo.Beatmap;
Beatmap beatmapFrom = editorFrom.Beatmap;
Timing timingTo = beatmapTo.BeatmapTiming;
Timing timingFrom = beatmapFrom.BeatmapTiming;
// Get markers for hitobjects if mode 1 is used
List <Marker> markers = new List <Marker>();
if (arg.ResnapMode == "Number of beats between objects stays the same")
{
markers = GetMarkers(beatmapTo, timingTo);
}
// Rid the beatmap of redlines
// If a greenline exists at the same time as a redline then the redline ceizes to exist
// Else convert the redline to a greenline: Inherited = false & MpB = -100
List <TimingPoint> removeList = new List <TimingPoint>();
foreach (TimingPoint redline in timingTo.Redlines)
{
TimingPoint greenlineHere = timingTo.GetGreenlineAtTime(redline.Offset);
if (greenlineHere.Offset != redline.Offset)
{
var newGreenline = redline.Copy();
newGreenline.Uninherited = false;
newGreenline.MpB = -100;
timingTo.Add(newGreenline);
}
removeList.Add(redline);
}
foreach (TimingPoint tp in removeList)
{
timingTo.Remove(tp);
}
// Make new timing points changes
List <TimingPointsChange> timingPointsChanges = new List <TimingPointsChange>();
// Add redlines
var redlines = timingFrom.Redlines;
foreach (TimingPoint tp in redlines)
{
timingPointsChanges.Add(new TimingPointsChange(tp, mpb: true, meter: true, unInherited: true, omitFirstBarLine: true, fuzzyness: Precision.DOUBLE_EPSILON));
}
// Apply timing changes
TimingPointsChange.ApplyChanges(timingTo, timingPointsChanges);
if (arg.ResnapMode == "Number of beats between objects stays the same")
{
redlines = timingTo.Redlines;
List <double> newBookmarks = new List <double>();
double lastTime = redlines.FirstOrDefault().Offset;
foreach (Marker marker in markers)
{
// Get redlines between this and last marker
TimingPoint redline = timingTo.GetRedlineAtTime(lastTime, redlines.FirstOrDefault());
double beatsFromLastTime = marker.BeatsFromLastMarker;
while (true)
{
List <TimingPoint> redlinesBetween = redlines.Where(o => o.Offset <= lastTime + redline.MpB * beatsFromLastTime && o.Offset > lastTime).ToList();
if (redlinesBetween.Count == 0)
{
break;
}
TimingPoint first = redlinesBetween.First();
double diff = first.Offset - lastTime;
beatsFromLastTime -= diff / redline.MpB;
redline = first;
lastTime = first.Offset;
}
// Last time is the time of the last redline in between
double newTime = lastTime + redline.MpB * beatsFromLastTime;
newTime = timingTo.Resnap(newTime, arg.BeatDivisors, firstTp: redlines.FirstOrDefault());
marker.Time = newTime;
lastTime = marker.Time;
}
// Add the bookmarks
foreach (Marker marker in markers)
{
// Check whether the marker is a bookmark
if (marker.Object is double)
{
// Don't resnap bookmarks
newBookmarks.Add((double)marker.Object);
}
}
beatmapTo.SetBookmarks(newBookmarks);
}
else if (arg.ResnapMode == "Just resnap")
{
// Resnap hitobjects
foreach (HitObject ho in beatmapTo.HitObjects)
{
ho.ResnapSelf(timingTo, arg.BeatDivisors, firstTp: redlines.FirstOrDefault());
ho.ResnapEnd(timingTo, arg.BeatDivisors, firstTp: redlines.FirstOrDefault());
}
// Resnap greenlines
foreach (TimingPoint tp in timingTo.Greenlines)
{
tp.ResnapSelf(timingTo, arg.BeatDivisors, firstTP: redlines.FirstOrDefault());
}
timingTo.Sort();
}
else
{
// Don't move objects
}
// Save the file
editorTo.SaveFile();
// Update progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(++mapsDone * 100 / paths.Length);
}
}
// Make an accurate message
string message = $"Successfully copied timing to {mapsDone} {(mapsDone == 1 ? "beatmap" : "beatmaps")}!";
return(message);
}
public void PostProcess(Beatmap <TaikoHitObject> beatmap)
{
}
public override void Update(GameTime gameTime)
{
if (!BanchoClient.Connected && GameBase.FadeState == FadeStates.Idle)
{
GameBase.ChangeMode(Modes.Menu);
GameBase.ShowMessage("Multiplayer will not work unless Bancho is connected!");
}
if (Match == null)
{
if (GameBase.FadeState == FadeStates.Idle)
{
GameBase.ChangeMode(Modes.Menu);
}
return;
}
if (GameBase.FadeState == FadeStates.FadeOut)
{
return;
}
if (!paused && AudioEngine.AudioState == AudioEngine.AudioStates.Stopped && GameBase.FadeState == FadeStates.Idle &&
BeatmapManager.Current != null)
{
AudioEngine.LoadAndPreviewMp3(BeatmapManager.Current.AudioFilename, true);
paused = false;
}
if (UpdatePending)
{
int uid = Match.findPlayerFromId(GameBase.User.Id);
if (uid < 0)
{
LeaveGame();
return;
}
detailsGameName.Box.Text = Match.gameName;
if (Match.slotReadyCount == Match.slotUsedCount != allReady)
{
allReady = Match.slotReadyCount == Match.slotUsedCount;
if (allReady)
{
AudioEngine.PlaySample("match-confirm");
}
}
if (allReady && IsHost && Match.slotReadyCount > 1)
{
buttonStart.Text.Text = "Start Game!";
}
else if (Match.slotStatus[uid] == SlotStatus.NotReady)
{
if (buttonStart.Text.Text != "Ready!")
{
buttonStart.Text.Text = "Ready!";
AudioEngine.PlaySample("match-notready");
}
}
else
{
if (buttonStart.Text.Text != "Not Ready")
{
buttonStart.Text.Text = "Not Ready";
AudioEngine.PlaySample("match-ready");
}
}
for (int i = 0; i < 8; i++)
{
if ((Match.slotStatus[i] & SlotStatus.CompHasPlayer) > 0)
{
User u = BanchoClient.GetUserById(Match.slotId[i]);
if (u == null)
{
continue;
}
slotText[i].Text = u.Name;
slotTextInfo[i].Text = string.Format("Acc:{0:0.00}%\nRank:#{1}", u.Accuracy, u.Rank);
slotLock[i].ToolTip = "";
slotLock[i].Texture = content.Load <Texture2D>(IsHost ? "lobby-boot" : "lobby-unlock");
slotLock[i].ToolTip = "Kick this player and lock the slot.";
}
else
{
slotTextInfo[i].Text = "";
}
switch (Match.slotStatus[i])
{
case SlotStatus.Open:
slotText[i].Text = "Open";
slotLock[i].Texture = content.Load <Texture2D>("lobby-unlock");
slotLock[i].ToolTip = "Lock this slot.";
slotStatus[i].StartColour = Color.White;
slotBackground[i].StartColour = Color.White;
break;
case SlotStatus.Locked:
slotText[i].Text = "Locked";
slotLock[i].Texture = content.Load <Texture2D>("lobby-lock");
slotLock[i].ToolTip = "Unlock this slot.";
slotStatus[i].StartColour = Color.Black;
slotBackground[i].StartColour = Color.Black;
break;
case SlotStatus.NotReady:
slotStatus[i].StartColour = Color.White;
slotBackground[i].StartColour = Color.White;
break;
case SlotStatus.Ready:
slotStatus[i].StartColour = Color.YellowGreen;
slotBackground[i].StartColour = Color.YellowGreen;
break;
case SlotStatus.NoMap:
slotStatus[i].StartColour = Color.OrangeRed;
slotBackground[i].StartColour = Color.OrangeRed;
slotText[i].Text += " [no map]";
break;
}
}
UpdatePending = false;
if (SongChangePending)
{
Beatmap map = BeatmapManager.GetBeatmapByChecksum(Match.beatmapChecksum);
if (map != null)
{
BeatmapManager.ProcessHeaders(map);
}
hasSong = map != null && map.BeatmapChecksum == Match.beatmapChecksum;
if (treeItem != null)
{
treeItem.SpriteCollection.ForEach(s =>
{
s.FadeOut(400);
s.AlwaysDraw = false;
});
}
if (!hasSong)
{
buttonStart.Hide();
BeatmapManager.Current = BeatmapManager.GetBeatmapById(Match.beatmapId);
AudioEngine.Stop();
Beatmap bm = new Beatmap();
bm.SortTitle = Match.beatmapName;
bm.BeatmapPresent = true;
bm.Title = "h";
bm.Creator = BeatmapManager.Current != null
? "Click here to update this map to the latest"
: Match.beatmapId > 0
? "Click to download this map"
: "You don't have this map";
treeItem = new BeatmapTreeItem(bm, 0, null);
treeItem.SpriteCollection[0].StartColour = Color.OrangeRed;
if (Match.beatmapId > 0)
{
treeItem.SpriteCollection[0].IsClickable = true;
treeItem.SpriteCollection[0].OnClick += DownloadMap;
treeItem.SpriteCollection[0].HoverEffect =
new Transformation(treeItem.SpriteCollection[0].StartColour, Color.YellowGreen, 0, 100);
}
else
{
treeItem.SpriteCollection[0].IsClickable = false;
}
BanchoClient.SendRequest(RequestType.Osu_MatchNoBeatmap, null);
((pText)treeItem.SpriteCollection[2]).TextBold = true;
}
else
{
if (Match.slotStatus[uid] == SlotStatus.NoMap)
{
BanchoClient.SendRequest(RequestType.Osu_MatchHasBeatmap, null);
}
buttonStart.Show();
BeatmapManager.Current = map;
treeItem = new BeatmapTreeItem(BeatmapManager.Current, 0, null);
treeItem.SpriteCollection[1].Text = BeatmapManager.Current.DisplayTitle;
if (!IsHost)
{
treeItem.SpriteCollection[0].IsClickable = false;
}
treeItem.SpriteCollection[0].OnClick += OnSelectBeatmap;
treeItem.SpriteCollection[0].HoverEffect =
new Transformation(treeItem.SpriteCollection[0].StartColour, Color.Orange, 0, 100);
}
if (map != null)
{
AudioEngine.LoadAndPreviewMp3(map.AudioFilename, true);
paused = false;
}
treeItem.SpriteCollection.ForEach(
delegate(pSprite s)
{
s.CurrentPosition = new Vector2(600, 165);
s.MoveTo(new Vector2(300, 165), 500, EasingTypes.In);
});
spriteManager.Add(treeItem.SpriteCollection);
//detailsBeatmap.Text = "Beatmap: " + Match.beatmapName;
SongChangePending = false;
}
if (HostChangePending)
{
SetHost();
}
}
if (ModChangePending)
{
ModChangePending = false;
ModManager.ModStatus = Match.activeMods | (ModManager.ModStatus & Mods.NoVideo);
modSprites.ForEach(
delegate(pSprite s)
{
s.FadeOut(400);
s.MoveToRelative(new Vector2(0, 20), 400, EasingTypes.Out);
s.AlwaysDraw = false;
});
modSprites.Clear();
int time = 0;
float dep = 0;
int x = 330;
foreach (Mods m in Enum.GetValues(typeof(Mods)))
{
if (ModManager.CheckActive(ModManager.ModStatus, m))
{
Transformation t2 =
new Transformation(TransformationType.Scale, 2, 1, GameBase.Time + time,
GameBase.Time + time + 400);
Transformation t3 =
new Transformation(TransformationType.Fade, 0, 1, GameBase.Time + time,
GameBase.Time + time + 400);
t2.Easing = EasingTypes.In;
t3.Easing = EasingTypes.In;
pSprite p =
new pSprite(SkinManager.Load("selection-mod-" + m.ToString().ToLower()),
FieldTypes.Window,
OriginTypes.Centre,
ClockTypes.Game,
new Vector2(x, 250), 0.92F + dep, true,
Color.TransparentWhite);
p.Transformations.Add(t2);
p.Transformations.Add(t3);
spriteManager.Add(p);
modSprites.Add(p);
time += 200;
dep += 0.00001f;
x += 20;
}
}
//detailsMods.Text = "Mods: " + ModManager.Format(ModManager.ModStatus, true);
}
base.Update(gameTime);
}
public void add(Beatmap tmpbm)
{
if (count == 0)
{
location = tmpbm.Location;
name = tmpbm.Artist + " - " + tmpbm.Title;
setid = tmpbm.beatmapsetId;
tags = tmpbm.tags;
tags += " " + tmpbm.ArtistRomanized;
tags += " " + tmpbm.TitleRomanized;
tags += " " + tmpbm.Creator;
tags += " " + tmpbm.Source;
}
count++;
Diffs.Add(tmpbm);
md5.Add(tmpbm.GetHash());
tags += " " + tmpbm.Version;
}
public TestWorkingBeatmap(Beatmap beatmap)
: base(beatmap.BeatmapInfo, beatmap.BeatmapInfo.BeatmapSet)
{
Beatmap = beatmap;
}
public static void ReadDb(string file)
{
using (var fs = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
var reader = new BinaryReader(fs);
reader.ReadInt32(); //version
reader.ReadInt32(); //folders
reader.ReadInt32();
reader.ReadInt32();
reader.ReadByte();
reader.ReadString(); //player
string stashs;
int stash;
int mapcount = reader.ReadInt32();
var tmpbm = new Beatmap();
var tmpset = new BeatmapSet();
for (int i = 0; i < mapcount; i++)
{
tmpbm.ArtistRomanized = reader.ReadString();
stashs = reader.ReadString();
if (stashs != "")
{
tmpbm.Artist = stashs;
}
tmpbm.TitleRomanized = reader.ReadString();
stashs = reader.ReadString();
if (stashs != "")
{
tmpbm.Title = stashs;
}
tmpbm.Creator = reader.ReadString();
tmpbm.Version = reader.ReadString();
tmpbm.Audio = reader.ReadString();
tmpbm.Hash = reader.ReadString();
tmpbm.Name = reader.ReadString();
reader.ReadByte(); //4=ranked 5=app 2=Unranked
tmpbm.Totalhitcount = reader.ReadUInt16(); //circles
tmpbm.Totalhitcount += reader.ReadUInt16(); //sliders
tmpbm.Totalhitcount += reader.ReadUInt16(); //spinners
reader.ReadInt64(); //最后编辑
reader.ReadByte(); //AR
reader.ReadByte(); //CS
reader.ReadByte(); //HP
reader.ReadByte(); //OD
reader.ReadDouble(); //SV
reader.ReadInt32(); //playtime
reader.ReadInt32(); //totaltime
reader.ReadInt32(); //preview
stash = reader.ReadInt32(); //timting points 数
for (int j = 0; j < stash; j++)
{
reader.ReadDouble(); //bpm
reader.ReadDouble(); //offset
reader.ReadBoolean(); //红线
}
tmpbm.beatmapId = reader.ReadInt32();
tmpbm.beatmapsetId = reader.ReadInt32();
reader.ReadInt32(); //threadid
reader.ReadByte(); //Ranking osu
reader.ReadByte(); //Ranking taiko
reader.ReadByte(); //Ranking ctb
reader.ReadByte(); //Ranking mania
tmpbm.Offset = reader.ReadInt16();
reader.ReadSingle(); //stack
tmpbm.mode = reader.ReadByte();
tmpbm.Source = reader.ReadString();
tmpbm.tags = reader.ReadString();
stash = reader.ReadInt16(); //online-offset
if (tmpbm.Offset == 0 && stash != 0)
{
tmpbm.Offset = stash;
}
reader.ReadString(); //title-font
reader.ReadBoolean(); //unplayed
reader.ReadInt64(); //last_play
reader.ReadBoolean(); //osz2
tmpbm.Location = Path.Combine(Settings.Default.OSUpath, reader.ReadString());
reader.ReadInt64(); //最后同步
reader.ReadBoolean(); //忽略音效
reader.ReadBoolean(); //忽略皮肤
reader.ReadBoolean(); //禁用sb
reader.ReadByte(); //背景淡化
reader.ReadInt64();
if (tmpset.count == 0)
{
tmpset.add(tmpbm);
}
else
{
if (tmpset.Contains(tmpbm))
{
tmpset.add(tmpbm);
}
else
{
Core.allsets.Add(tmpset);
tmpset = new BeatmapSet();
tmpset.add(tmpbm);
}
}
tmpbm = new Beatmap();
}
}
}
public override void Reset()
{
base.Reset();
WorkingBeatmap beatmap = null;
var beatmapInfo = db.Query <BeatmapInfo>().Where(b => b.Mode == PlayMode.Osu).FirstOrDefault();
if (beatmapInfo != null)
{
beatmap = db.GetWorkingBeatmap(beatmapInfo);
}
if (beatmap?.Track == null)
{
var objects = new List <HitObject>();
int time = 1500;
for (int i = 0; i < 50; i++)
{
objects.Add(new HitCircle
{
StartTime = time,
Position = new Vector2(i % 4 == 0 || i % 4 == 2 ? 0 : 512,
i % 4 < 2 ? 0 : 384),
NewCombo = i % 4 == 0
});
time += 500;
}
var decoder = new ConstructableBeatmapDecoder();
Beatmap b = new Beatmap
{
HitObjects = objects,
BeatmapInfo = new BeatmapInfo
{
Metadata = new BeatmapMetadata
{
Artist = @"Unknown",
Title = @"Sample Beatmap",
Author = @"peppy",
}
}
};
decoder.Process(b);
beatmap = new TestWorkingBeatmap(b);
}
Add(new Box
{
RelativeSizeAxes = Framework.Graphics.Axes.Both,
Colour = Color4.Black,
});
Add(new PlayerLoader(Player = CreatePlayer(beatmap))
{
Beatmap = beatmap
});
}
private void Scanforset(string path)
{
string[] osufiles = Directory.GetFiles(path, "*.osu");
if (osufiles.Length != 0)
{
foreach (var osufile in osufiles)
{
Beatmap tmp = new Beatmap(osufile, path);
tmpbms.Add(tmp);
}
this.BackgroundWorker1.ReportProgress(0);
}
else
{
string[] tmpfolder = Directory.GetDirectories(path);
all += tmpfolder.Length;
this.BackgroundWorker1.ReportProgress(0);
foreach (string subfolder in tmpfolder)
{
Scanforset(subfolder);
}
}
ok++;
}
public static Beatmap KSM_to_Stager(string kMap)
{
if (string.IsNullOrEmpty(kMap))
{
return(null);
}
var sMap = new Beatmap()
{
CreatedTime = System.DateTime.Now.Ticks,
BPM = -1,
Ratio = 1.5f,
Shift = 0f,
Level = 1,
Tag = "KShootMania",
Stages =
{
new Beatmap.Stage()
{
X = 0.5f,
Y = 0f,
Duration = float.MaxValue,
Height = 1.8f,
Rotation = 0f,
Speed = 0.6f,
Time = 0f,
Width = 0.618f,
Widths = { },
Heights = { },
Positions ={ },
Rotations ={ },
}, new Beatmap.Stage()
{
X = 0.5f,
Y = 0f,
Duration = float.MaxValue,
Height = 1.8f,
Rotation = 0f,
Speed = 0.6f,
Time = 0f,
Width = 0.618f,
Widths = { },
Heights = { },
Positions ={ },
Rotations ={ },
}, new Beatmap.Stage()
{
X = 0.5f,
Y = 0f,
Duration = float.MaxValue,
Height = 1.8f,
Rotation = 0f,
Speed = 0.6f,
Time = 0f,
Width = 0.618f,
Widths = { },
Heights = { },
Positions ={ },
Rotations ={ },
},
},
Tracks =
{
// 0
new Beatmap.Track()
{
X = 1f / 8f,
Width = 0.25f,
Angle = 45f,
StageIndex = 0,
Time = 0f,
Duration = float.MaxValue,
Color = 0,
HasTray = false,
Speed = 1f,
Colors = { },
Xs = { },
Angles = { },
Widths = { },
},
// 1
new Beatmap.Track()
{
X = 3f / 8f,
Width = 0.25f,
Angle = 45f,
StageIndex = 0,
Time = 0f,
Duration = float.MaxValue,
Color = 0,
HasTray = false,
Speed = 1f,
Colors = { },
Xs = { },
Angles = { },
Widths = { },
},
// 2
new Beatmap.Track()
{
X = 5f / 8f,
Width = 0.25f,
Angle = 45f,
StageIndex = 0,
Time = 0f,
Duration = float.MaxValue,
Color = 0,
HasTray = false,
Speed = 1f,
Colors = { },
Xs = { },
Angles = { },
Widths = { },
},
// 3
new Beatmap.Track()
{
X = 7f / 8f,
Width = 0.25f,
Angle = 45f,
StageIndex = 0,
Time = 0f,
Duration = float.MaxValue,
Color = 0,
HasTray = false,
Speed = 1f,
Colors = { },
Xs = { },
Angles = { },
Widths = { },
},
// 4
new Beatmap.Track()
{
X = 1f / 4f,
Width = 0.5f,
Angle = 45f,
StageIndex = 1,
Time = 0f,
Duration = float.MaxValue,
Color = 0,
HasTray = false,
Speed = 1f,
Colors = { },
Xs = { },
Angles = { },
Widths = { },
},
// 5
new Beatmap.Track()
{
X = 3f / 4f,
Width = 0.5f,
Angle = 45f,
StageIndex = 1,
Time = 0f,
Duration = float.MaxValue,
Color = 0,
HasTray = false,
Speed = 1f,
Colors = { },
Xs = { },
Angles = { },
Widths = { },
},
// 6
new Beatmap.Track()
{
X = 0.5f,
Width = 1f,
Angle = 45f,
StageIndex = 2,
Time = 0f,
Duration = float.MaxValue,
Color = 1,
HasTray = false,
Speed = 1f,
Colors = { },
Xs = { },
Angles = { },
Widths = { },
},
},
Notes = { },
Timings = { new Beatmap.Timing(0f, 1f) },
};
// String >> Cache
float timeOffset = 0f;
float currentBPM = 120f;
var strs = kMap.Replace("\r\n", "\n").Split('\n');
int index = 0;
// Header
for (; index < strs.Length; index++)
{
var str = strs[index];
if (str.StartsWith("--"))
{
break;
}
switch (str)
{
case var _ when str.StartsWith("//"):
break;
case var _ when str.StartsWith("t="):
if (str.IndexOf('-') < 0)
{
if (float.TryParse(str.Substring(2), out float _bpm))
{
currentBPM = _bpm;
if (sMap.BPM < 0)
{
sMap.BPM = (int)_bpm;
}
}
}
break;
case var _ when str.StartsWith("o="):
if (int.TryParse(str.Substring(2), out int _offset))
{
timeOffset = _offset / -1000f;
}
break;
case var _ when str.StartsWith("level="):
if (int.TryParse(str.Substring(6), out int _level))
{
sMap.Level = _level;
}
break;
}
}
// Chart
float nextBeatAmount = 1f;
var chartCaches = new List <ChartData>();
float cacheTimeStart = 0f;
var longBtStarts = new float[4] {
-1f, -1f, -1f, -1f
};
var longFxStarts = new float[2] {
-1f, -1f
};
var longSfxIndexs = new byte[2] {
0, 0
};
var longSfxParams = new int[2] {
0, 0
};
var prevLzIndex = new int[2] {
-1, -1
};
var fxTypes = new FxType[2] {
FxType.None, FxType.None
};
var fxParams = new int[2] {
-1, -1
};
for (; index < strs.Length; index++)
{
var str = strs[index];
switch (str)
{
case var _ when str.StartsWith("//"):
break;
case var _ when str.StartsWith("t="):
if (str.IndexOf('-') < 0)
{
if (float.TryParse(str.Substring(2), out float _bpm))
{
currentBPM = _bpm;
if (sMap.BPM < 0)
{
sMap.BPM = (int)_bpm;
}
}
}
break;
case var _ when str.StartsWith("beat="):
var str2 = str.Substring(5).Split('/');
if (str2 != null && str2.Length >= 2 && int.TryParse(str2[0], out int _b0) && int.TryParse(str2[1], out int _b1))
{
nextBeatAmount = (float)_b0 / _b1;
}
break;
case var _ when str.Length >= 10 && str[4] == '|' && str[7] == '|':
chartCaches.Add(new ChartData()
{
BT0 = ChartData.Char_to_Int_BT(str[0]),
BT1 = ChartData.Char_to_Int_BT(str[1]),
BT2 = ChartData.Char_to_Int_BT(str[2]),
BT3 = ChartData.Char_to_Int_BT(str[3]),
FX0 = ChartData.Char_to_Int_FX(str[5]),
FX1 = ChartData.Char_to_Int_FX(str[6]),
Lazer0 = ChartData.Char_to_Int_LAZER(str[8]),
Lazer1 = ChartData.Char_to_Int_LAZER(str[9]),
FxType0 = fxTypes[0],
FxType1 = fxTypes[1],
FxParam0 = fxParams[0],
FxParam1 = fxParams[1],
});
fxTypes[0] = fxTypes[1] = FxType.None;
fxParams[0] = fxParams[1] = -1;
break;
case var _ when str.StartsWith("fx-l="):
case var _ when str.StartsWith("fx-r="):
var _str = str.Substring(5);
int lrIndex = str[3] == 'l' ? 0 : 1;
switch (_str)
{
default:
fxTypes[lrIndex] = FxType.None;
fxParams[lrIndex] = -1;
break;
case var _ when _str.StartsWith("Retrigger;"):
fxTypes[lrIndex] = FxType.Retrigger;
if (!int.TryParse(_str.Substring(10), out fxParams[lrIndex]))
{
fxParams[lrIndex] = 8;
}
break;
case var _ when _str.StartsWith("Gate;"):
fxTypes[lrIndex] = FxType.Gate;
if (!int.TryParse(_str.Substring(5), out fxParams[lrIndex]))
{
fxParams[lrIndex] = 4;
}
break;
case var _ when _str.StartsWith("Flanger"):
fxTypes[lrIndex] = FxType.Flanger;
fxParams[lrIndex] = -1;
break;
case var _ when _str.StartsWith("PitchShift;"):
fxTypes[lrIndex] = FxType.PitchShift;
if (!int.TryParse(_str.Substring(11), out fxParams[lrIndex]))
{
fxParams[lrIndex] = 12;
}
break;
case var _ when _str.StartsWith("BitCrusher;"):
fxTypes[lrIndex] = FxType.BitCrusher;
if (!int.TryParse(_str.Substring(11), out fxParams[lrIndex]))
{
fxParams[lrIndex] = 5;
}
break;
case var _ when _str.StartsWith("Phaser"):
fxTypes[lrIndex] = FxType.Phaser;
fxParams[lrIndex] = -1;
break;
case var _ when _str.StartsWith("Wobble;"):
fxTypes[lrIndex] = FxType.Wobble;
if (!int.TryParse(_str.Substring(7), out fxParams[lrIndex]))
{
fxParams[lrIndex] = 12;
}
break;
case var _ when _str.StartsWith("TapeStop;"):
fxTypes[lrIndex] = FxType.TapeStop;
if (!int.TryParse(_str.Substring(9), out fxParams[lrIndex]))
{
fxParams[lrIndex] = 50;
}
break;
case var _ when _str.StartsWith("Echo;"):
fxTypes[lrIndex] = FxType.Echo;
if (!int.TryParse(_str.Substring(5), out fxParams[lrIndex]))
{
fxParams[lrIndex] = 4;
}
break;
case var _ when _str.StartsWith("SideChain"):
fxTypes[lrIndex] = FxType.SideChain;
fxParams[lrIndex] = -1;
break;
}
break;
case var _ when str.StartsWith("--"):
if (chartCaches.Count == 0)
{
break;
}
float cacheDuration = 60f / currentBPM * 4f * nextBeatAmount;
for (int i = 0; i < chartCaches.Count; i++)
{
var cache = chartCaches[i];
float time = cacheTimeStart + i / (chartCaches.Count - 1f) * cacheDuration + timeOffset;
// BT
for (int trackIndex = 0; trackIndex < 4; trackIndex++)
{
int bt = cache[0, trackIndex];
bool tryEndLong = bt != 2 || i == chartCaches.Count - 1;
if (bt == 1)
{
// BT Chip
sMap.Notes.Add(new Beatmap.Note()
{
Time = time,
X = 0.5f,
Z = 0f,
Width = 1f,
ItemType = (int)NoteType.BtChip,
ClickSoundIndex = 0,
Duration = 0,
LinkedNoteIndex = -1,
TrackIndex = trackIndex,
});
}
if (bt == 2)
{
// Start Long
if (longBtStarts[trackIndex] < 0f)
{
longBtStarts[trackIndex] = time;
}
}
// End Long
if (tryEndLong && longBtStarts[trackIndex] >= 0f)
{
sMap.Notes.Add(new Beatmap.Note()
{
Time = longBtStarts[trackIndex],
X = 0.5f,
Z = 0f,
Width = 1f,
ItemType = (int)NoteType.BtLong,
ClickSoundIndex = 0,
Duration = time - longBtStarts[trackIndex],
LinkedNoteIndex = -1,
TrackIndex = trackIndex,
});
longBtStarts[trackIndex] = -1f;
}
}
// FX
for (int trackIndex = 0; trackIndex < 2; trackIndex++)
{
int fx = cache[1, trackIndex];
bool tryEndLong = fx != 2 || i == chartCaches.Count - 1;
if (fx == 1)
{
// FX Chip
sMap.Notes.Add(new Beatmap.Note()
{
Time = time,
X = 0.5f,
Z = 0f,
Width = 1f,
ItemType = (int)NoteType.FxChip,
Speed = 1f,
ClickSoundIndex = 0,
Duration = 0,
LinkedNoteIndex = -1,
TrackIndex = trackIndex,
});
}
if (fx == 2)
{
// Start FX Long
if (longFxStarts[trackIndex] < 0f)
{
longFxStarts[trackIndex] = time;
longSfxIndexs[trackIndex] = (byte)ChartData.Fx_to_StagerFxType(cache[3, trackIndex]);
longSfxParams[trackIndex] = ChartData.Param_to_StagerParam(
cache[3, trackIndex], cache[4, trackIndex]
);
}
}
// End Long
if (tryEndLong && longFxStarts[trackIndex] >= 0f)
{
sMap.Notes.Add(new Beatmap.Note()
{
Time = longFxStarts[trackIndex],
X = 0.5f,
Z = 0f,
Width = 1f,
ItemType = (int)NoteType.FxLong,
ClickSoundIndex = 0,
Speed = 1f,
Duration = time - longFxStarts[trackIndex],
LinkedNoteIndex = -1,
TrackIndex = trackIndex + 4,
SoundFxIndex = longSfxIndexs[trackIndex],
SoundFxParamA = longSfxParams[trackIndex],
});
longFxStarts[trackIndex] = -1f;
}
}
// LZ
for (int trackIndex = 0; trackIndex < 2; trackIndex++)
{
var lz = cache[2, trackIndex];
if (lz >= 0)
{
// New
int noteIndex = sMap.Notes.Count;
sMap.Notes.Add(new Beatmap.Note()
{
Time = time,
X = trackIndex == 0 ? cache.Lazer0_01 : cache.Lazer1_01,
Z = 0f,
Width = 0.2f,
Speed = 1f,
ItemType = (int)NoteType.LazerBlue + trackIndex,
ClickSoundIndex = 0,
Duration = 0,
LinkedNoteIndex = -1,
TrackIndex = 6,
});
if (prevLzIndex[trackIndex] >= 0)
{
sMap.Notes[prevLzIndex[trackIndex]].LinkedNoteIndex = noteIndex;
}
prevLzIndex[trackIndex] = noteIndex;
}
if (lz == -1)
{
// End
prevLzIndex[trackIndex] = -1;
}
}
}
cacheTimeStart += cacheDuration;
chartCaches.Clear();
break;
}
}
// Final
return(sMap);
}
private void handleDifficulty(Beatmap beatmap, string key, string val)
{
var difficulty = beatmap.BeatmapInfo.BaseDifficulty;
switch (key)
{
case @"HPDrainRate":
difficulty.DrainRate = float.Parse(val, NumberFormatInfo.InvariantInfo);
break;
case @"CircleSize":
difficulty.CircleSize = float.Parse(val, NumberFormatInfo.InvariantInfo);
break;
case @"OverallDifficulty":
difficulty.OverallDifficulty = float.Parse(val, NumberFormatInfo.InvariantInfo);
break;
case @"ApproachRate":
difficulty.ApproachRate = float.Parse(val, NumberFormatInfo.InvariantInfo);
break;
case @"SliderMultiplier":
difficulty.SliderMultiplier = float.Parse(val, NumberFormatInfo.InvariantInfo);
break;
case @"SliderTickRate":
difficulty.SliderTickRate = float.Parse(val, NumberFormatInfo.InvariantInfo);
break;
}
}
public static string Stager_to_KSM(Beatmap sMap, string title)
{
sMap.SortNotesByTime();
// Stager >> Charts
float lastNoteTime = 0f;
foreach (var note in sMap.Notes)
{
lastNoteTime = Mathf.Max(note.Time + note.Duration, lastNoteTime);
}
float barDuration = 60f / sMap.BPM / 4f;
int barCount = Mathf.CeilToInt(lastNoteTime / barDuration);
var charts = new ChartData[barCount * 32];
for (int i = 0; i < charts.Length; i++)
{
charts[i] = new ChartData();
}
foreach (var note in sMap.Notes)
{
int barIndex0 = Mathf.FloorToInt(note.Time / barDuration * 32f);
int barIndex1 = Mathf.FloorToInt((note.Time + note.Duration) / barDuration * 32f);
for (int _b = barIndex0; _b <= barIndex1; _b++)
{
if (_b < 0 || _b >= charts.Length)
{
continue;
}
var chart = charts[_b];
if (note.TrackIndex < 4)
{
// BT
chart[0, note.TrackIndex] = barIndex0 == barIndex1 ? 1 : 2;
}
else if (note.TrackIndex < 6)
{
// FX
chart[1, note.TrackIndex - 4] = barIndex0 == barIndex1 ? 1 : 2;
if (_b == barIndex0)
{
chart[3, note.TrackIndex - 4] = ChartData.StagerFxType_to_Fx(note.SoundFxIndex);
chart[4, note.TrackIndex - 4] = ChartData.StagerParam_to_Param(note.SoundFxIndex, note.SoundFxParamA);
}
}
else if (note.TrackIndex == 6 && _b == barIndex0)
{
if (note.ItemType == 4 || note.ItemType == 5)
{
// LZ
chart[2, note.ItemType - 4] = (int)Util.Remap(0f, 1f, 0, 51, Mathf.Clamp01(note.X));
if (note.LinkedNoteIndex >= 0 && note.LinkedNoteIndex < sMap.Notes.Count)
{
var nextNote = sMap.Notes[note.LinkedNoteIndex];
int barIndex_Next = Mathf.FloorToInt(nextNote.Time / barDuration * 32f);
if (barIndex_Next >= 0 && barIndex_Next < charts.Length)
{
for (int i = _b + 1; i < barIndex_Next; i++)
{
charts[i][2, note.ItemType - 4] = -2;
}
}
}
}
}
}
}
// Charts >> Fixed Charts
for (int i = 0; i < barCount; i++)
{
bool allSame = true;
for (int j = 0; j < 31; j++)
{
if (!ChartData.Same(charts[i * 32 + j], charts[i * 32 + j + 1]))
{
allSame = false;
break;
}
}
if (allSame)
{
for (int j = 1; j < 32; j++)
{
charts[i * 32 + j] = null;
}
}
}
// Fixed Charts >> String
var builder = new StringBuilder();
builder.AppendLine($"title={title}");
builder.AppendLine($"jacket=bg0.png");
builder.AppendLine($"difficulty=infinite");
builder.AppendLine($"level={sMap.Level}");
builder.AppendLine($"t={sMap.BPM}");
builder.AppendLine($"m=bgm.ogg");
builder.AppendLine($"o=0");
builder.AppendLine($"bg=bg1.png");
builder.AppendLine($"layer=layer.gif");
builder.AppendLine($"po=0");
builder.AppendLine($"filtertype=peak");
builder.AppendLine($"chokkakuautovol=0");
builder.AppendLine($"chokkakuvol=50");
for (int index = 0; index < charts.Length; index++)
{
// Bar Line
if (index % 32 == 0)
{
builder.AppendLine($"--");
if (index == 0)
{
builder.AppendLine($"beat=4/4");
}
}
var chart = charts[index];
if (chart == null)
{
continue;
}
// FX
if (chart.FxType0 != FxType.None)
{
builder.Append($"fx-l={chart.FxType0.ToString()};");
if (chart.FxParam0 >= 0)
{
builder.Append(chart.FxParam0.ToString());
}
builder.AppendLine();
}
if (chart.FxType1 != FxType.None)
{
builder.Append($"fx-r={chart.FxType1.ToString()};");
if (chart.FxParam1 >= 0)
{
builder.Append(chart.FxParam1.ToString());
}
builder.AppendLine();
}
// Chart
for (int i = 0; i < 4; i++)
{
int bt = chart[0, i];
builder.Append(bt == 0 ? '0' : bt == 1 ? '1' : '2');
}
builder.Append('|');
for (int i = 0; i < 2; i++)
{
int fx = chart[1, i];
builder.Append(fx == 0 ? '0' : fx == 1 ? '2' : '1');
}
builder.Append('|');
for (int i = 0; i < 2; i++)
{
int lz = chart[2, i];
builder.Append(ChartData.Int_to_Char_LAZER(lz));
}
builder.AppendLine();
}
builder.AppendLine($"--");
return(builder.ToString());
}
private void handleEvents(Beatmap beatmap, string val)
{
if (val.StartsWith(@"//"))
return;
if (val.StartsWith(@" "))
return; // TODO
string[] split = val.Split(',');
EventType type;
int _type;
if (!int.TryParse(split[0], out _type))
{
if (!Enum.TryParse(split[0], out type))
throw new InvalidDataException($@"Unknown event type {split[0]}");
}
else
type = (EventType)_type;
// TODO: Parse and store the rest of the event
if (type == EventType.Background)
beatmap.BeatmapInfo.Metadata.BackgroundFile = split[2].Trim('"');
}
private void load(FrameworkConfigManager frameworkConfig)
{
this.frameworkConfig = frameworkConfig;
if (!Host.IsPrimaryInstance && !DebugUtils.IsDebugBuild)
{
Logger.Log(@"osu! does not support multiple running instances.", LoggingTarget.Runtime, LogLevel.Error);
Environment.Exit(0);
}
if (args?.Length > 0)
{
var paths = args.Where(a => !a.StartsWith(@"-")).ToArray();
if (paths.Length > 0)
{
Task.Run(() => Import(paths));
}
}
dependencies.CacheAs(this);
dependencies.Cache(SentryLogger);
dependencies.Cache(osuLogo = new OsuLogo {
Alpha = 0
});
// bind config int to database RulesetInfo
configRuleset = LocalConfig.GetBindable <int>(OsuSetting.Ruleset);
Ruleset.Value = RulesetStore.GetRuleset(configRuleset.Value) ?? RulesetStore.AvailableRulesets.First();
Ruleset.ValueChanged += r => configRuleset.Value = r.NewValue.ID ?? 0;
// bind config int to database SkinInfo
configSkin = LocalConfig.GetBindable <int>(OsuSetting.Skin);
SkinManager.CurrentSkinInfo.ValueChanged += skin => configSkin.Value = skin.NewValue.ID;
configSkin.ValueChanged += skinId =>
{
var skinInfo = SkinManager.Query(s => s.ID == skinId.NewValue);
if (skinInfo == null)
{
switch (skinId.NewValue)
{
case -1:
skinInfo = DefaultLegacySkin.Info;
break;
default:
skinInfo = SkinInfo.Default;
break;
}
}
SkinManager.CurrentSkinInfo.Value = skinInfo;
};
configSkin.TriggerChange();
IsActive.BindValueChanged(active => updateActiveState(active.NewValue), true);
Audio.AddAdjustment(AdjustableProperty.Volume, inactiveVolumeFade);
SelectedMods.BindValueChanged(modsChanged);
Beatmap.BindValueChanged(beatmapChanged, true);
}
private void handleMetadata(Beatmap beatmap, string key, string val)
{
var metadata = beatmap.BeatmapInfo.Metadata;
switch (key)
{
case @"Title":
metadata.Title = val;
break;
case @"TitleUnicode":
metadata.TitleUnicode = val;
break;
case @"Artist":
metadata.Artist = val;
break;
case @"ArtistUnicode":
metadata.ArtistUnicode = val;
break;
case @"Creator":
metadata.Author = val;
break;
case @"Version":
beatmap.BeatmapInfo.Version = val;
break;
case @"Source":
beatmap.BeatmapInfo.Metadata.Source = val;
break;
case @"Tags":
beatmap.BeatmapInfo.Metadata.Tags = val;
break;
case @"BeatmapID":
beatmap.BeatmapInfo.OnlineBeatmapID = int.Parse(val);
break;
case @"BeatmapSetID":
beatmap.BeatmapInfo.OnlineBeatmapSetID = int.Parse(val);
metadata.OnlineBeatmapSetID = int.Parse(val);
break;
}
}
protected override void ParseFile(TextReader stream, Beatmap beatmap)
{
throw new NotImplementedException();
}
protected override Beatmap ParseFile(TextReader stream)
{
var beatmap = new Beatmap
{
HitObjects = new List<HitObject>(),
ControlPoints = new List<ControlPoint>(),
ComboColors = new List<Color4>(),
BeatmapInfo = new BeatmapInfo
{
Metadata = new BeatmapMetadata(),
BaseDifficulty = new BaseDifficulty(),
},
};
HitObjectParser parser = null;
var section = Section.None;
string line;
while (true)
{
line = stream.ReadLine();
if (line == null)
break;
if (string.IsNullOrEmpty(line))
continue;
if (line.StartsWith(@"osu file format v"))
continue;
if (line.StartsWith(@"[") && line.EndsWith(@"]"))
{
if (!Enum.TryParse(line.Substring(1, line.Length - 2), out section))
throw new InvalidDataException($@"Unknown osu section {line}");
continue;
}
string val = line, key = null;
if (section != Section.Events && section != Section.TimingPoints && section != Section.HitObjects)
{
key = val.Remove(val.IndexOf(':')).Trim();
val = val.Substring(val.IndexOf(':') + 1).Trim();
}
switch (section)
{
case Section.General:
handleGeneral(beatmap, key, val);
parser = Ruleset.GetRuleset(beatmap.BeatmapInfo.Mode).CreateHitObjectParser();
break;
case Section.Editor:
handleEditor(beatmap, key, val);
break;
case Section.Metadata:
handleMetadata(beatmap, key, val);
break;
case Section.Difficulty:
handleDifficulty(beatmap, key, val);
break;
case Section.Events:
handleEvents(beatmap, val);
break;
case Section.TimingPoints:
handleTimingPoints(beatmap, val);
break;
case Section.Colours:
handleColours(beatmap, key, val);
break;
case Section.HitObjects:
var obj = parser?.Parse(val);
if (obj != null)
{
obj.SetDefaultsFromBeatmap(beatmap);
beatmap.HitObjects.Add(obj);
}
break;
}
}
return beatmap;
}
double tick(double start, double divisor)
{
return(Beatmap.GetTimingPointAt((int)start).BeatDuration / divisor);
}
public static void ReadDb(string file)
{
using (var fs = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
var reader = new BinaryReader(fs);
var version = reader.ReadInt32(); //version
reader.ReadInt32(); //folders
reader.ReadInt32();
reader.ReadInt32();
reader.ReadByte();
reader.ReadString(); //player
int mapcount = reader.ReadInt32();
var tmpbm = new Beatmap();
var tmpset = new BeatmapSet();
for (int i = 0; i < mapcount; i++)
{
tmpbm.ArtistRomanized = reader.ReadString();
string stashs = reader.ReadString();
if (stashs != "")
{
tmpbm.Artist = stashs;
}
tmpbm.TitleRomanized = reader.ReadString();
stashs = reader.ReadString();
if (stashs != "")
{
tmpbm.Title = stashs;
}
tmpbm.Creator = reader.ReadString();
tmpbm.Version = reader.ReadString();
tmpbm.Audio = reader.ReadString();
tmpbm.Hash = reader.ReadString();
tmpbm.Name = reader.ReadString();
reader.ReadByte(); //4=ranked 5=app 2=Unranked
tmpbm.Totalhitcount = reader.ReadUInt16(); //circles
tmpbm.Totalhitcount += reader.ReadUInt16(); //sliders
tmpbm.Totalhitcount += reader.ReadUInt16(); //spinners
reader.ReadInt64(); //最后编辑
if (version >= 20140612)
{
reader.ReadSingle();
reader.ReadSingle();
reader.ReadSingle();
reader.ReadSingle();
}
else
{
reader.ReadByte(); //AR
reader.ReadByte(); //CS
reader.ReadByte(); //HP
reader.ReadByte(); //OD
}
reader.ReadDouble(); //SV
if (version >= 20140609)
{
for (int k = 0; k < 4; k++)
{
var num = reader.ReadInt32();
if (num >= 0)
{
for (int xxoo = 0; xxoo < num; xxoo++)
{
reader.ReadVar();
reader.ReadVar();
}
}
}
}
reader.ReadInt32(); //playtime
reader.ReadInt32(); //totaltime
reader.ReadInt32(); //preview
int stash = reader.ReadInt32();
for (int j = 0; j < stash; j++)
{
reader.ReadDouble(); //bpm
reader.ReadDouble(); //offset
reader.ReadBoolean(); //红线
}
tmpbm.BeatmapID = reader.ReadInt32();
tmpbm.BeatmapsetID = reader.ReadInt32();
reader.ReadInt32(); //threadid
reader.ReadByte(); //Ranking osu
reader.ReadByte(); //Ranking taiko
reader.ReadByte(); //Ranking ctb
reader.ReadByte(); //Ranking mania
tmpbm.Offset = reader.ReadInt16();
reader.ReadSingle(); //stack
tmpbm.Mode = (Modes)reader.ReadByte();
tmpbm.Source = reader.ReadString();
tmpbm.Tags = reader.ReadString();
stash = reader.ReadInt16(); //online-offset
if (tmpbm.Offset == 0 && stash != 0)
{
tmpbm.Offset = stash;
}
reader.ReadString(); //title-font
reader.ReadBoolean(); //unplayed
reader.ReadInt64(); //last_play
reader.ReadBoolean(); //osz2
tmpbm.Location = reader.ReadString();
reader.ReadInt64(); //最后同步
reader.ReadBoolean(); //忽略音效
reader.ReadBoolean(); //忽略皮肤
reader.ReadBoolean(); //禁用sb
reader.ReadBoolean(); //禁用视频
reader.ReadBoolean();//VisualSettingsOverride
if (version < 20140608)
{
reader.ReadInt16();//背景淡化
}
reader.ReadInt32();//LastEditTime
reader.ReadByte();//ManiaSpeed
if (tmpset.count == 0)
{
tmpset.Add(tmpbm);
}
else
{
if (tmpset.Contains(tmpbm))
{
tmpset.Add(tmpbm);
}
else
{
if (!Core.Allsets.ContainsKey(tmpset.GetHash())) Core.Allsets.Add(tmpset.GetHash(), tmpset);
else
{
Core.Allsets[tmpset.GetHash()]= tmpset;
}
tmpset = new BeatmapSet();
tmpset.Add(tmpbm);
}
}
tmpbm = new Beatmap();
}
}
}
public override void Generate()
{
var layer = GetLayer("Kiai");
var BGbitmap = GetMapsetBitmap(BlurBG);
var crazyBG = layer.CreateSprite(CrazyBG, OsbOrigin.Centre);
crazyBG.Scale(StartTime, 480.0f / BGbitmap.Height);
var bgSprite = layer.CreateSprite(BlurBG, OsbOrigin.Centre);
bgSprite.Scale(StartTime, 480.0f / BGbitmap.Height);
var flash = layer.CreateSprite(Flash, OsbOrigin.Centre);
var flashBG = layer.CreateSprite(LightBG, OsbOrigin.Centre);
var endTime = Math.Min(EndTime, (int)AudioDuration);
var startTime = Math.Min(StartTime, endTime);
var bitmap = GetMapsetBitmap(SpritePath);
var heightKeyframes = new KeyframedValue <float> [BarCount];
for (var i = 0; i < BarCount; i++)
{
heightKeyframes[i] = new KeyframedValue <float>(null);
}
var fftTimeStep = Beatmap.GetTimingPointAt(startTime).BeatDuration / BeatDivisor;
var fftOffset = fftTimeStep * 0.2;
for (var time = (double)startTime; time < endTime; time += fftTimeStep)
{
var fft = GetFft(time + fftOffset, BarCount, null, FftEasing);
for (var i = 0; i < BarCount; i++)
{
var height = (float)Math.Log10(1 + fft[i] * LogScale) * Scale.Y / bitmap.Height;
if (height < MinimalHeight)
{
height = MinimalHeight;
}
heightKeyframes[i].Add(time, height);
}
}
var spectrumDropTwoBeats = new List <int>();
var spectrumDropOneBeat = new List <int>();
var spectrumDropOneMidBeat = new List <int>();
var spectrumDropMidBeat = new List <int>();
var pumpBG = new List <int>();
var flashSnare = new List <int>();
if (StartTime == 63581)
{
spectrumDropTwoBeats.Add(63581);
spectrumDropTwoBeats.Add(64993);
spectrumDropTwoBeats.Add(66405);
spectrumDropTwoBeats.Add(69228);
spectrumDropTwoBeats.Add(70640);
spectrumDropTwoBeats.Add(72052);
spectrumDropTwoBeats.Add(74875);
spectrumDropTwoBeats.Add(76287);
spectrumDropTwoBeats.Add(80522);
spectrumDropOneBeat.Add(82287);
spectrumDropTwoBeats.Add(83346);
pumpBG.Add(67463);
pumpBG.Add(67816);
pumpBG.Add(68081);
pumpBG.Add(68346);
pumpBG.Add(68522);
pumpBG.Add(68787);
pumpBG.Add(69052);
pumpBG.Add(73111);
pumpBG.Add(73463);
pumpBG.Add(73993);
pumpBG.Add(74169);
pumpBG.Add(74699);
pumpBG.Add(77699);
pumpBG.Add(78052);
pumpBG.Add(78405);
pumpBG.Add(78758);
pumpBG.Add(79111);
pumpBG.Add(79346);
pumpBG.Add(79816);
pumpBG.Add(80169);
pumpBG.Add(81581);
pumpBG.Add(82287);
pumpBG.Add(82640);
pumpBG.Add(82905);
pumpBG.Add(83169);
flashSnare.Add(65699);
flashSnare.Add(67111);
flashSnare.Add(69934);
flashSnare.Add(71346);
flashSnare.Add(72758);
flashSnare.Add(75581);
flashSnare.Add(76993);
flashSnare.Add(78405);
flashSnare.Add(79816);
flashSnare.Add(81228);
flashSnare.Add(84052);
}
if (StartTime == 125699)
{
spectrumDropTwoBeats.Add(125699);
spectrumDropOneBeat.Add(127463);
spectrumDropTwoBeats.Add(128522);
spectrumDropOneBeat.Add(129581);
spectrumDropOneBeat.Add(130287);
spectrumDropOneMidBeat.Add(130816);
spectrumDropTwoBeats.Add(131346);
spectrumDropOneBeat.Add(133111);
spectrumDropTwoBeats.Add(134169);
spectrumDropOneBeat.Add(135228);
spectrumDropOneBeat.Add(135934);
for (double x = 136287; x <= 138287; x += tick(0, 3))
{
spectrumDropMidBeat.Add((int)x);
}
spectrumDropOneBeat.Add(138758);
spectrumDropOneMidBeat.Add(139816);
spectrumDropOneBeat.Add(140875);
spectrumDropOneBeat.Add(141581);
spectrumDropOneMidBeat.Add(142111);
spectrumDropTwoBeats.Add(142640);
spectrumDropOneBeat.Add(144405);
spectrumDropTwoBeats.Add(145464);
spectrumDropOneBeat.Add(146522);
for (double x = 143346; x <= 144052; x += tick(0, 3))
{
spectrumDropMidBeat.Add((int)x);
}
for (double x = 146875; x <= 148170; x += tick(0, 3))
{
spectrumDropMidBeat.Add((int)x);
}
pumpBG.Add(126758);
pumpBG.Add(127463);
pumpBG.Add(127993);
pumpBG.Add(128346);
pumpBG.Add(129581);
pumpBG.Add(130287);
pumpBG.Add(130816);
pumpBG.Add(131169);
pumpBG.Add(132405);
pumpBG.Add(133111);
pumpBG.Add(133640);
pumpBG.Add(133993);
pumpBG.Add(135228);
pumpBG.Add(135934);
pumpBG.Add(135934);
for (double x = 136287; x <= 138052; x += tick(0, 3))
{
pumpBG.Add((int)x);
}
pumpBG.Add(138758);
pumpBG.Add(139287);
pumpBG.Add(139640);
pumpBG.Add(139816);
pumpBG.Add(140875);
pumpBG.Add(141228);
pumpBG.Add(141581);
pumpBG.Add(141758);
pumpBG.Add(142111);
pumpBG.Add(142464);
pumpBG.Add(143699);
pumpBG.Add(144405);
pumpBG.Add(144934);
pumpBG.Add(145287);
pumpBG.Add(146522);
pumpBG.Add(147228);
flashSnare.Add(126405);
flashSnare.Add(127816);
flashSnare.Add(129228);
flashSnare.Add(130640);
flashSnare.Add(132052);
flashSnare.Add(133464);
flashSnare.Add(134875);
flashSnare.Add(136287);
flashSnare.Add(137699);
flashSnare.Add(139111);
flashSnare.Add(140522);
flashSnare.Add(141934);
flashSnare.Add(143346);
flashSnare.Add(144758);
flashSnare.Add(146169);
flashSnare.Add(147581);
}
else
{
spectrumDropTwoBeats.Add(204758);
spectrumDropOneBeat.Add(206522);
spectrumDropTwoBeats.Add(207581);
spectrumDropOneBeat.Add(208640);
spectrumDropOneBeat.Add(209346);
spectrumDropOneMidBeat.Add(209875);
spectrumDropTwoBeats.Add(210405);
spectrumDropOneBeat.Add(212169);
spectrumDropTwoBeats.Add(213228);
spectrumDropOneBeat.Add(214287);
spectrumDropOneBeat.Add(214993);
for (double x = 215346; x <= 217287; x += tick(0, 3))
{
spectrumDropMidBeat.Add((int)x);
}
spectrumDropOneBeat.Add(217816);
spectrumDropOneMidBeat.Add(218875);
spectrumDropOneBeat.Add(219934);
spectrumDropOneBeat.Add(220640);
spectrumDropOneMidBeat.Add(221169);
spectrumDropTwoBeats.Add(221699);
for (double x = 222405; x <= 223111; x += tick(0, 3))
{
spectrumDropMidBeat.Add((int)x);
}
spectrumDropOneBeat.Add(223464);
spectrumDropTwoBeats.Add(224522);
spectrumDropOneBeat.Add(225581);
for (double x = 225934; x <= 227346; x += tick(0, 3))
{
spectrumDropMidBeat.Add((int)x);
}
pumpBG.Add(205816);
pumpBG.Add(206522);
pumpBG.Add(207052);
pumpBG.Add(207405);
pumpBG.Add(208640);
pumpBG.Add(209346);
pumpBG.Add(209875);
pumpBG.Add(210228);
pumpBG.Add(211464);
pumpBG.Add(212169);
pumpBG.Add(212699);
pumpBG.Add(213052);
pumpBG.Add(214287);
pumpBG.Add(214993);
for (double x = 215346; x <= 217111; x += tick(0, 3))
{
pumpBG.Add((int)x);
}
pumpBG.Add(217816);
pumpBG.Add(218346);
pumpBG.Add(218699);
pumpBG.Add(218875);
pumpBG.Add(219934);
pumpBG.Add(220287);
pumpBG.Add(220640);
pumpBG.Add(220816);
pumpBG.Add(221169);
pumpBG.Add(221522);
pumpBG.Add(222758);
pumpBG.Add(223464);
pumpBG.Add(223993);
pumpBG.Add(224346);
pumpBG.Add(225581);
pumpBG.Add(226287);
flashSnare.Add(205464);
flashSnare.Add(206875);
flashSnare.Add(208287);
flashSnare.Add(209699);
flashSnare.Add(211111);
flashSnare.Add(212522);
flashSnare.Add(213934);
flashSnare.Add(215346);
flashSnare.Add(216758);
flashSnare.Add(218169);
flashSnare.Add(219581);
flashSnare.Add(220993);
flashSnare.Add(222405);
flashSnare.Add(223816);
flashSnare.Add(225228);
flashSnare.Add(226640);
}
foreach (int flashtime in spectrumDropTwoBeats)
{
flash.Fade(flashtime, flashtime + tick(0, (double)1 / (double)2), 0.6, 0);
flashBG.Fade(flashtime, flashtime + tick(0, (double)1 / (double)2), 0.6, 0);
flashBG.Scale(flashtime, flashtime + tick(0, (double)1 / (double)2), 480.0f / BGbitmap.Height, 520.0f / BGbitmap.Height);
bgSprite.Fade(flashtime, 0.4);
crazyBG.Fade(flashtime, 0);
bgSprite.Fade((OsbEasing)4, flashtime + tick(0, (double)1 / (double)2), flashtime + tick(0, (double)1 / (double)4), 0.5, 0.25);
}
bgSprite.Fade(EndTime - tick(0, (double)1 / (double)4) + 1, EndTime, 0.5, 0);
foreach (int pump in pumpBG)
{
crazyBG.Fade((OsbEasing)4, pump, pump + tick(0, 2), 0.35, 0);
}
foreach (int flashtick in flashSnare)
{
flash.Fade((OsbEasing)4, flashtick, flashtick + tick(0, 2), 0.35, 0);
}
if (StartTime == 204758)
{
flash.Fade((OsbEasing)3, EndTime, EndTime + tick(0, (double)1 / (double)2), 1, 0);
}
if (StartTime != 63581)
{
flash.Fade((OsbEasing)3, EndTime - tick(0, (double)1 / (double)4), EndTime, 0, 1);
}
var barWidth = Width / BarCount;
for (var i = 0; i < BarCount; i++)
{
var keyframes = heightKeyframes[i];
keyframes.Simplify1dKeyframes(Tolerance, h => h);
var actual_x = Position.X + i * barWidth;
//Log($"{actual_x}, {(float)Math.Sin(actual_x)}");
//Log($"{barWidth}");
List <double> curveCircle = CalculateCurve(0, 0, 30.0);
int run = 0;
var bar = layer.CreateSprite(SpritePath, SpriteOrigin);
var startBar = StartTime - (float)tick(0, (double)1 / (double)2) + ((float)tick(0, (double)1 / (double)2) / BarCount) * i;
bar.Fade(OsbEasing.InQuad, startBar, StartTime, 0, 1);
bar.Rotate(startBar, 0);
for (float x = StartTime - (float)tick(0, (double)1 / (double)2); x <= EndTime; x += 30.0f)
{
var actual_y = (float)Math.Sin(MathHelper.DegreesToRadians(actual_x / 2) + 0.0025 * x);
var after_y = (float)Math.Sin(MathHelper.DegreesToRadians(actual_x / 2) + 0.0025 * x + 0.0025);
bar.Move(x, x + 30, new Vector2(actual_x, Position.Y + actual_y * 35) + new Vector2((float)curveCircle[run], (float)curveCircle[run + 1]), new Vector2(actual_x, Position.Y + after_y * 35) + new Vector2((float)curveCircle[run + 2], (float)curveCircle[run + 3]));
run += 2;
if (run == 356)
{
run = 0;
}
}
var scaleX = Scale.X * barWidth / bitmap.Width;
scaleX = (float)Math.Floor(scaleX * 10) / 10.0f;
if (StartTime == 125699)
{
bar.ScaleVec(139111 - (int)tick(0, 4), 139111, scaleX, scaleX * 1.5, scaleX, scaleX);
bar.Rotate(139111, 0);
bar.ScaleVec(144758 - (int)tick(0, 4), 144758, scaleX, scaleX * 1.5, scaleX, scaleX);
bar.Rotate(144758, 0);
}
if (StartTime == 204758)
{
bar.ScaleVec(218169 - (int)tick(0, 4), 218169, scaleX, scaleX * 1.5, scaleX, scaleX);
bar.Rotate(218169, 0);
bar.ScaleVec(223816 - (int)tick(0, 4), 223816, scaleX, scaleX * 1.5, scaleX, scaleX);
bar.Rotate(223816, 0);
}
var hasScale = false;
var lastMid = scaleX;
keyframes.ForEachPair(
(start, end) =>
{
var random_angle = Random(-10, 10);
if (spectrumDropTwoBeats.Contains((int)start.Time) || spectrumDropTwoBeats.Contains((int)start.Time + 1) || spectrumDropTwoBeats.Contains((int)start.Time - 1))
{
bar.ScaleVec((OsbEasing)19, start.Time, start.Time + tick(0, 1),
scaleX, scaleX,
scaleX, start.Value);
bar.ScaleVec((OsbEasing)19, start.Time + tick(0, (double)6 / (double)8), start.Time + tick(0, (double)1 / (double)2),
scaleX, start.Value,
scaleX, scaleX);
bar.Rotate(start.Time, MathHelper.DegreesToRadians(random_angle));
bar.Rotate(start.Time + tick(0, (double)6 / (double)8), start.Time + tick(0, (double)1 / (double)2), MathHelper.DegreesToRadians(random_angle), 0);
}
if (spectrumDropOneBeat.Contains((int)start.Time) || spectrumDropOneBeat.Contains((int)start.Time + 1) || spectrumDropOneBeat.Contains((int)start.Time - 1))
{
bar.ScaleVec((OsbEasing)19, start.Time, start.Time + tick(0, 2),
scaleX, scaleX,
scaleX, start.Value);
bar.ScaleVec((OsbEasing)19, start.Time + tick(0, (double)4 / (double)3), start.Time + tick(0, 1),
scaleX, start.Value,
scaleX, scaleX);
bar.Rotate(start.Time, MathHelper.DegreesToRadians(random_angle));
bar.Rotate(start.Time + tick(0, (double)4 / (double)3), start.Time + tick(0, 1), MathHelper.DegreesToRadians(random_angle), 0);
}
if (spectrumDropOneMidBeat.Contains((int)start.Time) || spectrumDropOneMidBeat.Contains((int)start.Time + 1) || spectrumDropOneMidBeat.Contains((int)start.Time - 1))
{
bar.ScaleVec((OsbEasing)19, start.Time, start.Time + tick(0, 2),
scaleX, scaleX,
scaleX, start.Value);
bar.ScaleVec((OsbEasing)19, start.Time + tick(0, (double)5 / (double)6), start.Time + tick(0, 1) + tick(0, 2),
scaleX, start.Value,
scaleX, scaleX);
bar.Rotate(start.Time, MathHelper.DegreesToRadians(random_angle));
bar.Rotate(start.Time + tick(0, (double)5 / (double)6), start.Time + tick(0, 1) + tick(0, 2), MathHelper.DegreesToRadians(random_angle), 0);
}
if (spectrumDropMidBeat.Contains((int)start.Time) || spectrumDropMidBeat.Contains((int)start.Time + 1) || spectrumDropMidBeat.Contains((int)start.Time - 1))
{
if (lastMid == scaleX)
{
lastMid = start.Value;
}
bar.ScaleVec((OsbEasing)19, start.Time, start.Time + tick(0, 3), scaleX, lastMid, scaleX, start.Value);
bar.Rotate(start.Time, MathHelper.DegreesToRadians(random_angle));
}
},
MinimalHeight,
s => (float)Math.Round(s, CommandDecimals)
);
var colors = "0,330,0.8,1,0.8,1";
var colorOne = int.Parse(colors.Split(',')[0], System.Globalization.CultureInfo.InvariantCulture);
var colorTwo = int.Parse(colors.Split(',')[1], System.Globalization.CultureInfo.InvariantCulture);
var colorOneSa = double.Parse(colors.Split(',')[2], System.Globalization.CultureInfo.InvariantCulture);
var colorOneBra = double.Parse(colors.Split(',')[3], System.Globalization.CultureInfo.InvariantCulture);
var colorTwoSa = double.Parse(colors.Split(',')[4], System.Globalization.CultureInfo.InvariantCulture);
var colorTwoBra = double.Parse(colors.Split(',')[5], System.Globalization.CultureInfo.InvariantCulture);
if (i % 2 == 0)
{
bar.ColorHsb(startTime, colorOne, colorOneSa, colorOneBra);
}
else
{
bar.ColorHsb(startTime, colorTwo, colorTwoSa, colorTwoBra);
}
bar.Additive(startTime, endTime);
bar.Fade((OsbEasing)6, endTime - tick(0, (double)1 / (double)4), endTime, 1, 0);
}
}
