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);