PongFE/PongFE/Engines/CollisionEngine.cs

using Encompass;
using PongFE.Components;
using PongFE.Enums;
using PongFE.Messages;

namespace PongFE.Engines
{
    [Reads(
        typeof(CanCauseBounceComponent),
        typeof(CanCauseAngledBounceComponent),
        typeof(CanBeBouncedComponent),
        typeof(CanDestroyComponent),
        typeof(CanBeDestroyedComponent)
    )]
    [Receives(typeof(CollisionMessage))]
    [Sends(
        typeof(BounceMessage),
        typeof(AngledBounceMessage),
        typeof(DestroyMessage)
    )]
    public class CollisionEngine : Engine
    {
        public override void Update(double dt)
        {
            foreach (ref readonly var message in ReadMessages<CollisionMessage>())
            {
                CheckBounce(message.EntityA, message.EntityB, message.HitOrientation);
                CheckBounce(message.EntityB, message.EntityA, message.HitOrientation);

                CheckAngledBounce(message.EntityA, message.EntityB, message.HitOrientation);
                CheckAngledBounce(message.EntityB, message.EntityA, message.HitOrientation);

                CheckDestroy(message.EntityA, message.EntityB);
                CheckDestroy(message.EntityB, message.EntityA);
            }
        }

        private void CheckBounce(Entity a, Entity b, HitOrientation hitOrientation)
        {
            if (HasComponent<CanCauseBounceComponent>(a))
            {
                if (HasComponent<CanBeBouncedComponent>(b))
                {
                    SendMessage(new BounceMessage(b, hitOrientation));
                }
            }
        }

        private void CheckAngledBounce(Entity a, Entity b, HitOrientation hitOrientation)
        {
            if (HasComponent<CanCauseAngledBounceComponent>(a))
            {
                if (HasComponent<CanBeBouncedComponent>(b))
                {
                    SendMessage(new AngledBounceMessage(a, b, hitOrientation));
                }
            }
        }

        private void CheckDestroy(Entity a, Entity b)
        {
            if (HasComponent<CanDestroyComponent>(a))
            {
                if (HasComponent<CanBeDestroyedComponent>(b))
                {
                    SendMessage(new DestroyMessage(b, a));
                }
            }
        }
    }
}