Esempio n. 1
0
        protected override void AddDrawable(HitObjectLifetimeEntry entry, DrawableHitObject drawable)
        {
            if (nonPooledDrawableMap.ContainsKey(entry))
            {
                return;
            }

            addDrawable(drawable);
            HitObjectUsageBegan?.Invoke(entry.HitObject);
        }
Esempio n. 2
0
        /// <summary>
        /// Registers a <see cref="Playfield"/> as a nested <see cref="Playfield"/>.
        /// This does not add the <see cref="Playfield"/> to the draw hierarchy.
        /// </summary>
        /// <param name="otherPlayfield">The <see cref="Playfield"/> to add.</param>
        protected void AddNested(Playfield otherPlayfield)
        {
            otherPlayfield.DisplayJudgements.BindTo(DisplayJudgements);

            otherPlayfield.NewResult              += (d, r) => NewResult?.Invoke(d, r);
            otherPlayfield.RevertResult           += (d, r) => RevertResult?.Invoke(d, r);
            otherPlayfield.HitObjectUsageBegan    += h => HitObjectUsageBegan?.Invoke(h);
            otherPlayfield.HitObjectUsageFinished += h => HitObjectUsageFinished?.Invoke(h);

            nestedPlayfields.Value.Add(otherPlayfield);
        }
Esempio n. 3
0
 private void onHitObjectUsageBegan(HitObject hitObject)
 {
     if (usageFinishedHitObjects.Remove(hitObject))
     {
         HitObjectUsageTransferred?.Invoke(hitObject, playfield.AllHitObjects.Single(d => d.HitObject == hitObject));
     }
     else
     {
         HitObjectUsageBegan?.Invoke(hitObject);
     }
 }
Esempio n. 4
0
        /// <summary>
        /// Creates a new <see cref="Playfield"/>.
        /// </summary>
        protected Playfield()
        {
            RelativeSizeAxes = Axes.Both;

            hitObjectContainerLazy = new Lazy <HitObjectContainer>(() => CreateHitObjectContainer().With(h =>
            {
                h.NewResult              += (d, r) => NewResult?.Invoke(d, r);
                h.RevertResult           += (d, r) => RevertResult?.Invoke(d, r);
                h.HitObjectUsageBegan    += o => HitObjectUsageBegan?.Invoke(o);
                h.HitObjectUsageFinished += o => HitObjectUsageFinished?.Invoke(o);
            }));
        }
Esempio n. 5
0
        private void addDrawable(HitObjectLifetimeEntry entry)
        {
            Debug.Assert(!drawableMap.ContainsKey(entry));

            var drawable = pooledObjectProvider.GetPooledDrawableRepresentation(entry.HitObject);

            if (drawable == null)
            {
                throw new InvalidOperationException($"A drawable representation could not be retrieved for hitobject type: {entry.HitObject.GetType().ReadableName()}.");
            }

            drawable.OnNewResult    += onNewResult;
            drawable.OnRevertResult += onRevertResult;

            bindStartTime(drawable);
            AddInternal(drawableMap[entry] = drawable, false);

            HitObjectUsageBegan?.Invoke(entry.HitObject);
        }