public DrawableBarLineMajor(BarLine barLine)
: base(barLine)
{
Add(triangleContainer = new Container
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
RelativeSizeAxes = Axes.Both,
Children = new[]
{
new EquilateralTriangle
{
Name = "Top",
Anchor = Anchor.TopCentre,
Origin = Anchor.TopCentre,
Position = new Vector2(0, -triangle_offfset),
Size = new Vector2(-triangle_size),
EdgeSmoothness = new Vector2(1),
},
new EquilateralTriangle
{
Name = "Bottom",
Anchor = Anchor.BottomCentre,
Origin = Anchor.TopCentre,
Position = new Vector2(0, triangle_offfset),
Size = new Vector2(triangle_size),
EdgeSmoothness = new Vector2(1),
}
}
});
Tracker.Alpha = 1f;
}
public DrawableBarLine(BarLine barLine)
{
BarLine = barLine;
Anchor = Anchor.CentreLeft;
Origin = Anchor.Centre;
RelativePositionAxes = Axes.X;
RelativeSizeAxes = Axes.Y;
Width = 2f;
Children = new[]
{
Tracker = new Box
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
RelativeSizeAxes = Axes.Both,
EdgeSmoothness = new Vector2(0.5f, 0),
Alpha = 0.75f
}
};
}
public DrawableBarLine(BarLine barLine)
{
BarLine = barLine;
Anchor = Anchor.CentreLeft;
Origin = Anchor.Centre;
RelativePositionAxes = Axes.X;
RelativeSizeAxes = Axes.Y;
Width = tracker_width;
Children = new[]
{
Tracker = new Box
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
RelativeSizeAxes = Axes.Both,
EdgeSmoothness = new Vector2(0.5f, 0),
Alpha = 0.75f
}
};
LifetimeStart = BarLine.StartTime - BarLine.ScrollTime * 2;
LifetimeEnd = BarLine.StartTime + BarLine.ScrollTime;
}
private void addBarLine(bool major, double delay = scroll_time)
{
BarLine bl = new BarLine {
StartTime = drawableRuleset.Playfield.Time.Current + delay
};
drawableRuleset.Playfield.Add(major ? new DrawableBarLineMajor(bl) : new DrawableBarLine(bl));
}
private void addBarLine(bool major, double delay = scroll_time)
{
BarLine bl = new BarLine
{
StartTime = playfield.Time.Current + delay,
ScrollTime = scroll_time
};
playfield.AddBarLine(major ? new DrawableBarLineMajor(bl) : new DrawableBarLine(bl));
}
private void addBarLine(bool major, double delay = scroll_time)
{
BarLine bl = new BarLine
{
StartTime = DrawableRuleset.Playfield.Time.Current + delay,
Major = major
};
DrawableRuleset.Playfield.Add(bl);
}
private void loadBarLines()
{
var taikoPlayfield = Playfield as TaikoPlayfield;
if (taikoPlayfield == null)
{
return;
}
TaikoHitObject lastObject = Beatmap.HitObjects[Beatmap.HitObjects.Count - 1];
double lastHitTime = 1 + (lastObject as IHasEndTime)?.EndTime ?? lastObject.StartTime;
var timingPoints = Beatmap.ControlPointInfo.TimingPoints.ToList();
if (timingPoints.Count == 0)
{
return;
}
int currentIndex = 0;
int currentBeat = 0;
double time = timingPoints[currentIndex].Time;
while (time <= lastHitTime)
{
int nextIndex = currentIndex + 1;
if (nextIndex < timingPoints.Count && time > timingPoints[nextIndex].Time)
{
currentIndex = nextIndex;
time = timingPoints[currentIndex].Time;
currentBeat = 0;
}
var currentPoint = timingPoints[currentIndex];
var barLine = new BarLine
{
StartTime = time,
};
barLine.ApplyDefaults(Beatmap.ControlPointInfo, Beatmap.BeatmapInfo.Difficulty);
bool isMajor = currentBeat % (int)currentPoint.TimeSignature == 0;
taikoPlayfield.AddBarLine(isMajor ? new DrawableBarLineMajor(barLine) : new DrawableBarLine(barLine));
double bl = currentPoint.BeatLength;
if (bl < 800)
{
bl *= (int)currentPoint.TimeSignature;
}
time += bl;
currentBeat++;
}
}
private void createBar(bool isMajor, double increaseTime = 2000)
{
notePlayfields.ForEach(x =>
{
var bar = new BarLine {
StartTime = Time.Current + increaseTime, Major = isMajor
};
bar.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
x.Add(bar);
});
}
private void addBarLine()
{
bool isMajor = RNG.Next(8) == 0;
BarLine bl = new BarLine
{
StartTime = Time.Current + 1000,
PreEmpt = 1000
};
playfield.AddBarLine(isMajor ? new DrawableMajorBarLine(bl) : new DrawableBarLine(bl));
}
private void WriteAlternative(BarLine barline)
{
if (barline.Alternatives.Count > 0)
{
lilyString += "\\alternative {\r\n";
foreach (Note note in barline.Alternatives)
{
currentDuration = 0;
lilyString += "{ ";
WriteSection(note);
lilyString += "}\r\n";
}
lilyString += "}\r\n";
}
}
private void createBarLine(bool major)
{
foreach (var stage in stages)
{
var obj = new BarLine
{
StartTime = Time.Current + 2000,
Major = major,
};
obj.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
stage.Add(obj);
}
}
private BarLine createBarLineAtCurrentTime(bool major = false)
{
var barLine = new BarLine
{
Major = major,
StartTime = Time.Current + 2000,
};
var cpi = new ControlPointInfo();
cpi.Add(0, new TimingControlPoint {
BeatLength = 500
});
barLine.ApplyDefaults(cpi, new BeatmapDifficulty());
return(barLine);
}
public DrawableBarLine(BarLine barLine)
: base(barLine)
{
BarLine = barLine;
Anchor = Anchor.CentreLeft;
Origin = Anchor.Centre;
RelativeSizeAxes = Axes.Y;
Width = tracker_width;
AddInternal(Tracker = new Box
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
RelativeSizeAxes = Axes.Both,
EdgeSmoothness = new Vector2(0.5f, 0),
Alpha = 0.75f
});
}
private LilypondToken SetRepeat(LilypondToken startToken)
{
LilypondToken currentToken = startToken.NextToken.NextToken.NextToken;
BarLine firstBarline = new BarLine {
Type = BarLine.TYPE.START
};
BarLine lastBarline = new BarLine
{
Type = BarLine.TYPE.REPEAT,
Buddy = firstBarline
};
LilypondToken lastToken = FindSection(currentToken);
SetNextSymbol(symbols, firstBarline);
Symbol[] newSymbols = FindNoteSection(currentToken, lastToken);
SetNextSymbol(symbols, newSymbols[0]);
symbols[1] = newSymbols[1];
SetNextSymbol(symbols, lastBarline);
return(lastToken);
}
private LilypondToken SetAlternitive(LilypondToken startToken)
{
LilypondToken currentToken = startToken.NextToken;
LilypondToken lastToken = FindSection(currentToken);
Symbol prevSymbol = symbols[1];
if (prevSymbol.GetType() == typeof(BarLine))
{
BarLine barline = prevSymbol as BarLine;
while (currentToken != lastToken && currentToken.NextToken != lastToken)
{
currentToken = currentToken.NextToken;
LilypondToken templastToken = FindSection(currentToken);
Note tempRoot = FindNoteSection(currentToken, templastToken)[0];
currentToken = templastToken;
barline.Alternatives.Add(tempRoot);
}
}
return(currentToken);
}
public DrawableBarLine(BarLine barLine)
: base(barLine)
{
BarLine = barLine;
Anchor = Anchor.CentreLeft;
Origin = Anchor.Centre;
RelativeSizeAxes = Axes.Y;
Width = tracker_width;
AddInternal(Line = new SkinnableDrawable(new TaikoSkinComponent(TaikoSkinComponents.BarLine), _ => new Box
{
RelativeSizeAxes = Axes.Both,
EdgeSmoothness = new Vector2(0.5f, 0),
})
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Alpha = 0.75f,
});
}
public void handleBarline(BarLine barLine)
{
if (activeBarline != barLine)
{
activeBarline = barLine;
alternativeCount = 0;
}
else
{
alternativeCount++;
}
if (alternativeCount > barLine.Alternatives.Count - 1)
{
return;
}
readSymbolTillNull(barLine.Alternatives[alternativeCount]);
if (alternativeCount > barLine.Alternatives.Count - 2)
{
return;
}
readSymbolTillNull(barLine.Buddy.nextSymbol);
}
public void Add(BarLine barLine) => base.Add(new DrawableBarLine(barLine));
public void DrawBarLine(BarLine line, double x, double y)
=> this.InvokeRenderMethod("drawBarLine", (int)line, x, y);
public void Add(BarLine barLine) => stages.ForEach(s => s.Add(barLine));
public DrawableBarLine([CanBeNull] BarLine barLine)
: base(barLine)
{
}
public void Add(BarLine barLine)
{
NotePlayfield.Add(barLine);
}
private void loadBarLines()
{
var taikoPlayfield = Playfield as TaikoPlayfield;
if (taikoPlayfield == null)
{
return;
}
TaikoHitObject lastObject = Beatmap.HitObjects[Beatmap.HitObjects.Count - 1];
double lastHitTime = 1 + (lastObject as IHasEndTime)?.EndTime ?? lastObject.StartTime;
var timingPoints = Beatmap.TimingInfo.ControlPoints.FindAll(cp => cp.TimingChange);
if (timingPoints.Count == 0)
{
return;
}
int currentIndex = 0;
while (currentIndex < timingPoints.Count && Precision.AlmostEquals(timingPoints[currentIndex].BeatLength, 0))
{
currentIndex++;
}
double time = timingPoints[currentIndex].Time;
double measureLength = timingPoints[currentIndex].BeatLength * (int)timingPoints[currentIndex].TimeSignature;
// Find the bar line time closest to 0
time -= measureLength * (int)(time / measureLength);
// Always start barlines from a positive time
while (time < 0)
{
time += measureLength;
}
int currentBeat = 0;
while (time <= lastHitTime)
{
ControlPoint current = timingPoints[currentIndex];
if (time > current.Time || current.OmitFirstBarLine)
{
bool isMajor = currentBeat % (int)current.TimeSignature == 0;
var barLine = new BarLine
{
StartTime = time,
};
barLine.ApplyDefaults(Beatmap.TimingInfo, Beatmap.BeatmapInfo.Difficulty);
taikoPlayfield.AddBarLine(isMajor ? new DrawableBarLineMajor(barLine) : new DrawableBarLine(barLine));
currentBeat++;
}
double bl = current.BeatLength;
if (bl < 800)
{
bl *= (int)current.TimeSignature;
}
time += bl;
if (currentIndex + 1 >= timingPoints.Count || time < timingPoints[currentIndex + 1].Time)
{
continue;
}
currentBeat = 0;
currentIndex++;
time = timingPoints[currentIndex].Time;
}
}
