public Issue Create(HitObject hitobject, HitObject nextHitobject)
{
var hitobjects = new List <HitObject> {
hitobject, nextHitobject
};
return(new Issue(hitobjects, this, hitobject.GetType().Name, nextHitobject.GetType().Name)
{
Time = nextHitobject.StartTime
});
}
public override bool Remove(HitObject h)
{
switch (h)
{
case BarLine barLine:
return(barLinePlayfield.Remove(barLine));
case TaikoHitObject taikoHitObject:
return(base.Remove(taikoHitObject));
default:
throw new ArgumentException($"Unsupported {nameof(HitObject)} type: {h.GetType()}");
}
}
public Issue Create(HitObject hitobject, double unsnap, double time, string postfix = "")
{
string objectName = hitobject.GetType().Name;
if (!string.IsNullOrEmpty(postfix))
{
objectName += " " + postfix;
}
return(new Issue(hitobject, this, objectName, unsnap)
{
Time = time
});
}
DrawableHitObject IPooledHitObjectProvider.GetPooledDrawableRepresentation(HitObject hitObject, DrawableHitObject parent)
{
var lookupType = hitObject.GetType();
IDrawablePool pool;
// Tests may add derived hitobject instances for which pools don't exist. Try to find any applicable pool and dynamically assign the type if the pool exists.
if (!pools.TryGetValue(lookupType, out pool))
{
foreach (var(t, p) in pools)
{
if (!t.IsInstanceOfType(hitObject))
{
continue;
}
pools[lookupType] = pool = p;
break;
}
}
return((DrawableHitObject)pool?.Get(d =>
{
var dho = (DrawableHitObject)d;
if (!dho.IsInitialized)
{
onNewDrawableHitObject(dho);
// If this is the first time this DHO is being used, then apply the DHO mods.
// This is done before Apply() so that the state is updated once when the hitobject is applied.
if (mods != null)
{
foreach (var m in mods.OfType <IApplicableToDrawableHitObjects>())
{
m.ApplyToDrawableHitObjects(dho.Yield());
}
}
}
if (!lifetimeEntryMap.TryGetValue(hitObject, out var entry))
{
lifetimeEntryMap[hitObject] = entry = CreateLifetimeEntry(hitObject);
}
dho.ParentHitObject = parent;
dho.Apply(entry);
}));
}
public override bool Remove(HitObject h)
{
switch (h)
{
case Lyric _:
return(LyricPlayfield.Remove(h));
case Note _:
case BarLine _:
return(NotePlayfield.Remove(h));
default:
throw new ArgumentException($"Unsupported {nameof(HitObject)} type: {h.GetType()}");
}
}
public override void Add(HitObject h)
{
switch (h)
{
case BarLine barLine:
barLinePlayfield.Add(barLine);
break;
case TaikoHitObject taikoHitObject:
base.Add(taikoHitObject);
break;
default:
throw new ArgumentException($"Unsupported {nameof(HitObject)} type: {h.GetType()}");
}
}
public override void Add(HitObject h)
{
switch (h)
{
case Lyric _:
LyricPlayfield.Add(h);
break;
case Note _:
case BarLine _:
NotePlayfield.Add(h);
break;
default:
throw new ArgumentException($"Unsupported {nameof(HitObject)} type: {h.GetType()}");
}
}
public override void Add(HitObject h)
{
switch (h)
{
case Lyric _:
LyricPlayfield.Add(h);
break;
case Note _:
case BarLine _:
// hidden the note playfield until receive any note.
NotePlayfield.Alpha = 1;
NotePlayfield.Add(h);
break;
default:
throw new ArgumentException($"Unsupported {nameof(HitObject)} type: {h.GetType()}");
}
}
/// <inheritdoc />
protected override HitObject HitObjectWithMods(HitObject baseHitObject, Mods mods)
{
var hitObject = Activator.CreateInstance(baseHitObject.GetType()) as HitObject;
hitObject.Time = (int)Math.Round(baseHitObject.Time / Utils.ModClockRate(mods));
hitObject.X = baseHitObject.X;
hitObject.Y = mods.HasFlag(Mods.HardRock) ? -baseHitObject.Y + 384 : baseHitObject.Y;
hitObject.NewCombo = baseHitObject.NewCombo;
hitObject.Difficulty = new BeatmapDifficulty
{
AR = Utils.ModApproachRate(baseHitObject.Difficulty.AR, mods),
CS = Utils.ModCircleSize(baseHitObject.Difficulty.CS, mods),
HP = baseHitObject.Difficulty.HP, // not important
OD = Utils.ModOverallDifficulty(baseHitObject.Difficulty.OD, mods),
SliderMultiplier = baseHitObject.Difficulty.SliderMultiplier, // not important yet
SliderTickRate = baseHitObject.Difficulty.SliderTickRate, // not important yet
};
if (hitObject is Slider)
{
foreach (var curvePoint in ((Slider)baseHitObject).CurvePoints.ToArray())
{
((Slider)hitObject).CurvePoints.Add(new CurvePoint
{
type = curvePoint.type,
x = curvePoint.x,
y = mods.HasFlag(Mods.HardRock) ? -curvePoint.y + 384 : curvePoint.y
});
}
((Slider)hitObject).EndTime = (int)Math.Round(((Slider)baseHitObject).EndTime / Utils.ModClockRate(mods));
((Slider)hitObject).PixelLength = ((Slider)baseHitObject).PixelLength;
((Slider)hitObject).Repeat = ((Slider)baseHitObject).Repeat;
((Slider)hitObject).SliderType = ((Slider)baseHitObject).SliderType;
}
if (hitObject is Spinner)
{
((Spinner)hitObject).EndTime = (int)Math.Round(((Spinner)baseHitObject).EndTime / Utils.ModClockRate(mods));
}
return(hitObject);
}
public void Init(ColliderType type, HitObject src)
{
if (src.ItemIndex == 0 && src.ItemVersion == 0)
{
throw new InvalidOperationException("Entity of " + type + " " + src.GetType().Name + " is null!");
}
Type = type;
ItemType = src.ObjType;
Id = src.Id;
Entity = new Entity {
Index = src.ItemIndex, Version = src.ItemVersion
};
Material = new PhysicsMaterialData {
Elasticity = src.Elasticity,
ElasticityFalloff = src.ElasticityFalloff,
Friction = src.Friction,
Scatter = src.Scatter,
};
Threshold = src.Threshold;
FireEvents = src.FireEvents;
IsEnabled = src.IsEnabled;
}
private IDrawablePool prepareDrawableHitObjectPool(HitObject hitObject)
{
var lookupType = hitObject.GetType();
IDrawablePool pool;
// Tests may add derived hitobject instances for which pools don't exist. Try to find any applicable pool and dynamically assign the type if the pool exists.
if (!pools.TryGetValue(lookupType, out pool))
{
foreach (var(t, p) in pools)
{
if (!t.IsInstanceOfType(hitObject))
{
continue;
}
pools[lookupType] = pool = p;
break;
}
}
return(pool);
}
public static void Create(BlobBuilder builder, HitObject src, ref BlobPtr <Collider> dest)
{
switch (src)
{
case KickerHit kickerHit:
CircleCollider.Create(builder, kickerHit, ref dest, ColliderType.KickerCircle);
break;
case TriggerHitCircle triggerHitCircle:
CircleCollider.Create(builder, triggerHitCircle, ref dest, ColliderType.TriggerCircle);
break;
case TriggerHitLineSeg triggerHitLine:
LineCollider.Create(builder, triggerHitLine, ref dest, ColliderType.TriggerLine);
break;
case BumperHit bumperHit:
CircleCollider.Create(builder, bumperHit, ref dest, ColliderType.Bumper);
break;
case HitCircle hitCircle:
CircleCollider.Create(builder, hitCircle, ref dest);
break;
case LineSegSlingshot lineSegSlingshot:
LineSlingshotCollider.Create(builder, lineSegSlingshot, ref dest);
break;
case FlipperHit flipperHit:
FlipperCollider.Create(builder, flipperHit, ref dest);
break;
case GateHit gateHit:
GateCollider.Create(builder, gateHit, ref dest);
break;
case LineSeg lineSeg:
LineCollider.Create(builder, lineSeg, ref dest);
break;
case HitLine3D hitLine3D:
Line3DCollider.Create(builder, hitLine3D, ref dest);
break;
case HitLineZ hitLineZ:
LineZCollider.Create(builder, hitLineZ, ref dest);
break;
case HitPoint hitPoint:
PointCollider.Create(builder, hitPoint, ref dest);
break;
case HitPlane hitPlane:
PlaneCollider.Create(builder, hitPlane, ref dest);
break;
case PlungerHit plungerCollider:
PlungerCollider.Create(builder, plungerCollider, ref dest);
break;
case SpinnerHit spinnerHit:
SpinnerCollider.Create(builder, spinnerHit, ref dest);
break;
case HitTriangle hitTriangle:
TriangleCollider.Create(builder, hitTriangle, ref dest);
break;
default:
Logger.Warn("Unsupported collider {0}, skipping.", src.GetType().Name);
break;
}
}
protected override IEnumerable <CytusHitObject> ConvertHitObject(HitObject original, IBeatmap beatmap)
{
if (!(original is IHasXPosition))
{
throw new Exception($"This hitobject of type {original.GetType().Name} is not a {nameof(IHasXPosition)}!");
}
double time = original.StartTime;
float x = ((IHasXPosition)original).X;
float y = beatmap.GetScanPosition(original.StartTime, Constants.BeatsPerScan);
// we have to determine if this is a slider or normal hitobject
// TODO: check for IHasRepeats
if (original is IHasCurve ihc)
{
CytusSliderTick lastTick;
double endTime = ihc.EndTime;
var tp = beatmap.ControlPointInfo.TimingPointAt(time);
double tickInterval = tp.BeatLength / (int)tp.TimeSignature;
SliderCurve curve = ihc.Curve ?? new SliderCurve {
ControlPoints = ihc.ControlPoints,
CurveType = ihc.CurveType,
Distance = ihc.Distance,
Offset = Vector2.Zero
};
var end = lastTick = new CytusSliderEnd(endTime, x + curve.PositionAt(1).X, beatmap.GetScanPosition(endTime, Constants.BeatsPerScan))
{
Samples = original.Samples,
SampleControlPoint = original.SampleControlPoint
};
var ticks = new List <CytusSliderTick>();
for (double i = endTime - tickInterval; i >= time + tickInterval / 2; i -= tickInterval)
{
ticks.Add(lastTick = new CytusSliderTick(i, x + curve.PositionAt((i - time) / (endTime - time)).X, beatmap.GetScanPosition(i, Constants.BeatsPerScan), lastTick)
{
Samples = original.Samples,
SampleControlPoint = original.SampleControlPoint
});
}
var start = new CytusSliderHead(original.StartTime, x, y, lastTick)
{
Samples = original.Samples,
SampleControlPoint = original.SampleControlPoint
};
yield return(start);
foreach (var tick in ticks)
{
yield return(tick);
}
yield return(end);
}
else
{
// This is a normal note
yield return(new CytusNote(time, x, y)
{
Samples = original.Samples,
SampleControlPoint = original.SampleControlPoint
});
}
}
public Issue Create(HitObject hitobject, double duration) => new Issue(hitobject, this, hitobject.GetType(), duration);