# IProjectileFactoryCollisionReceiver
The `IProjectileFactoryCollisionReceiver` interface can be used to ensure that collisions executed by non-physics based methods such as `ProjectileRaycastHitDetector` or `InstantHitForward` properly know they've been hit.
{% hint style="info" %}
Each of the main demo projectiles has various ways of colliding, to demonstrate the various behaviors that can be used. For objects such as the cubes and spheres in the [**Juicy Actions Integration**](https://infinitypbr.gitbook.io/magic-pig-games/juicy-actions/integrations/projectile-factory), these are "simple" objects — they don't have an `Actor` component on them or anything like the enemy characters do.
They utilize the `ActionOnPhysicsEvent` component, which handles both `Trigger` and `Collider`, but those won't fire when the collision from the projectile doesn't use triggers or colliders via physics. We can use this interface to pass information along, and handle it accordingly, i.e. calling the proper `ActionExecutor`.
{% endhint %}
This interface has one method:
```csharp
OnProjectileFactoryCollisionEnter(in ProjectileCollisionMessage message)
```
When `ProjectileRaycastHitDetector` or `InstantHitForward` have the optional `sendCollisionEnterToCollider`, then any object that was detected will have this method called if the interface is present.
## Projectile Collision Message
The struct ProjectileCollisionMessage contains data about the collision which an be used similar to a normal collision.
```csharp
public struct ProjectileCollisionMessage
{
public Projectile projectile;
public Collider collider;
public Vector3 point;
public Vector3 normal;
public Vector3 incomingDirection;
public float distance;
}
```
{% hint style="success" %}
You will need to write a custom handler that implements `IProjectileFactoryCollisionReceiver`, or add the interface to an existing class. Then you can choose what to do with it.
{% endhint %}
## Example Implementation
In the [**Juicy Actions Integration**](https://infinitypbr.gitbook.io/magic-pig-games/juicy-actions/integrations/projectile-factory) for Projectile Factory, the cubes and spheres are basic objects without any fancy `actor` type class on them. Since each demo projectile has differnet collision behaviors, we want the sphere and cube to react properly.
```csharp
public class ProjectileFactoryCollisionHandler : MonoBehaviour, IProjectileFactoryCollisionReceiver
{
public ActionOnPhysicsEvent actionOnPhysicsEvent;
public void OnProjectileFactoryCollisionEnter(in ProjectileCollisionMessage message)
=> actionOnPhysicsEvent.HandleTriggerEnter(null);
private void OnValidate()
{
if (actionOnPhysicsEvent == null)
actionOnPhysicsEvent = GetComponent();
}
}
```
In this class, which ships with the integration package, we call `HandleTriggerEnter(null)` when the `OnProectileFactoryCollisionEnter` event is received. This calls the `OnEnter` actions.
Note that to make this work the projectiles must have the option enabled to send this data, and the `ActionOnCollision`, `ActionOnTrigger`, or `ActionOnPhysicsEvent` components must allow `null` colliders.
{% hint style="info" %}
In your custom handling, you can make use of the `ProjectileCollisionMessage` data. This example does not.
{% endhint %}
With those set, our sphere and cube objects now have Juicy Actions when they're hit by *any* projectile.
