public override void Consume(ActiveCollisionPublisher publisher, CollisionNotifier.EventData currentCollision)
{
if (isActiveAndEnabled)
{
received = true;
}
}
public void ExtractFromConsumerEvent()
{
UnityEventListenerMock extractedMock = new UnityEventListenerMock();
subject.Extracted.AddListener(extractedMock.Listen);
GameObject publisherSource = new GameObject();
GameObject publisherChild = new GameObject();
publisherChild.transform.SetParent(publisherSource.transform);
ActiveCollisionPublisher publisher = publisherChild.AddComponent <ActiveCollisionPublisher>();
publisher.sourceContainer = publisherSource;
ActiveCollisionConsumer.EventData eventData = new ActiveCollisionConsumer.EventData();
eventData.Set(publisher, null);
Assert.IsNull(subject.SourceContainer);
Assert.IsFalse(extractedMock.Received);
subject.Extract(eventData);
Assert.AreEqual(publisherSource, subject.SourceContainer);
Assert.IsTrue(extractedMock.Received);
}
public void Consume()
{
UnityEventListenerMock consumedMock = new UnityEventListenerMock();
UnityEventListenerMock clearedMock = new UnityEventListenerMock();
subject.Consumed.AddListener(consumedMock.Listen);
subject.Cleared.AddListener(clearedMock.Listen);
GameObject publisherObject = new GameObject();
ActiveCollisionPublisher publisher = publisherObject.AddComponent <ActiveCollisionPublisher>();
publisher.sourceContainer = publisherObject;
Assert.IsFalse(consumedMock.Received);
Assert.IsFalse(clearedMock.Received);
Assert.IsNull(subject.PublisherSource);
subject.Consume(publisher, null);
Assert.IsTrue(consumedMock.Received);
Assert.IsFalse(clearedMock.Received);
Assert.AreEqual(publisher, subject.PublisherSource);
Object.DestroyImmediate(publisherObject);
}
protected virtual void ProcessGrabAction(ActiveCollisionPublisher publisher, bool actionState)
{
if (grabAction?.Value != actionState)
{
grabAction?.Receive(actionState);
}
else
{
publisher?.Publish();
}
}
/// <summary>
/// Extracts the source container from the given publisher.
/// </summary>
/// <param name="publisher">The publisher to extract from.</param>
/// <returns>The source container within the publisher.</returns>
public virtual GameObject Extract(ActiveCollisionPublisher publisher)
{
if (!isActiveAndEnabled || publisher == null)
{
SourceContainer = null;
return(null);
}
SourceContainer = publisher.sourceContainer;
Extracted?.Invoke(SourceContainer);
return(SourceContainer);
}
protected virtual void ProcessGrabAction(ActiveCollisionPublisher publisher, bool actionState)
{
precognitionTimer.enabled = false;
if (grabAction.Value != actionState)
{
grabAction.Receive(actionState);
}
if (grabAction.Value)
{
publisher.Publish();
}
precognitionTimer.enabled = true;
}
/// <summary>
/// Processes the given collision data into a grab action based on the given state.
/// </summary>
/// <param name="publisher">The collision data to process.</param>
/// <param name="actionState">The grab state to check against.</param>
protected virtual void ProcessGrabAction(ActiveCollisionPublisher publisher, bool actionState)
{
InstantGrabProcessor.SetActive(false);
PrecognitionGrabProcessor.SetActive(false);
if (GrabAction.Value != actionState)
{
GrabAction.Receive(actionState);
}
if (GrabAction.Value)
{
publisher.Publish();
}
ChooseGrabProcessor();
}
public void CreateAndClear()
{
UnityEventListenerMock createdMock = new UnityEventListenerMock();
UnityEventListenerMock clearedMock = new UnityEventListenerMock();
subject.Created.AddListener(createdMock.Listen);
subject.Destroyed.AddListener(clearedMock.Listen);
GameObject publisherObject = new GameObject();
ActiveCollisionPublisher publisher = publisherObject.AddComponent <ActiveCollisionPublisher>();
publisher.sourceContainer = publisherObject;
publisherObject.transform.position = Vector3.one;
GameObject collisionNotifierContainer;
CollisionNotifier.EventData collisionNotifierEventData = CollisionNotifierHelper.GetEventData(out collisionNotifierContainer);
collisionNotifierContainer.transform.position = Vector3.one * 2f;
collisionNotifierContainer.transform.rotation = Quaternion.Euler(Vector3.forward * 90f);
ActiveCollisionConsumer.EventData eventData = new ActiveCollisionConsumer.EventData();
eventData.Set(publisher, collisionNotifierEventData);
Assert.IsFalse(createdMock.Received);
Assert.IsFalse(clearedMock.Received);
Assert.IsNull(subject.Container);
subject.Create(eventData);
Assert.IsTrue(createdMock.Received);
Assert.IsFalse(clearedMock.Received);
Assert.IsNotNull(subject.Container);
Assert.AreEqual(publisherObject.transform.position.ToString(), subject.Container.transform.position.ToString());
Assert.AreEqual(publisherObject.transform.rotation.ToString(), subject.Container.transform.rotation.ToString());
Assert.AreEqual(Vector3.one, subject.Container.transform.localScale);
createdMock.Reset();
clearedMock.Reset();
subject.Destroy();
Assert.IsFalse(createdMock.Received);
Assert.IsTrue(clearedMock.Received);
Assert.IsNull(subject.Container);
Object.DestroyImmediate(publisherObject);
Object.DestroyImmediate(collisionNotifierContainer);
}
public void ExtractInvalidPublisher()
{
UnityEventListenerMock extractedMock = new UnityEventListenerMock();
subject.Extracted.AddListener(extractedMock.Listen);
ActiveCollisionPublisher publisher = null;
Assert.IsNull(subject.SourceContainer);
Assert.IsFalse(extractedMock.Received);
subject.Extract(publisher);
Assert.IsNull(subject.SourceContainer);
Assert.IsFalse(extractedMock.Received);
}
public void ConsumeExclusion()
{
UnityEventListenerMock consumedMock = new UnityEventListenerMock();
UnityEventListenerMock clearedMock = new UnityEventListenerMock();
subject.Consumed.AddListener(consumedMock.Listen);
subject.Cleared.AddListener(clearedMock.Listen);
GameObject publisherObject = new GameObject();
ActiveCollisionPublisher publisher = publisherObject.AddComponent <ActiveCollisionPublisher>();
publisher.sourceContainer = publisherObject;
publisherObject.AddComponent <RuleStub>();
NegationRule negationRule = containingObject.AddComponent <NegationRule>();
AnyComponentTypeRule anyComponentTypeRule = containingObject.AddComponent <AnyComponentTypeRule>();
anyComponentTypeRule.componentTypes.Add(typeof(RuleStub));
negationRule.rule = new RuleContainer
{
Interface = anyComponentTypeRule
};
subject.publisherValidity = new RuleContainer
{
Interface = negationRule
};
Assert.IsFalse(consumedMock.Received);
Assert.IsFalse(clearedMock.Received);
Assert.IsNull(subject.PublisherSource);
subject.Consume(publisher, null);
Assert.IsFalse(consumedMock.Received);
Assert.IsFalse(clearedMock.Received);
Assert.IsNull(subject.PublisherSource);
Object.DestroyImmediate(publisherObject);
}
public void ExtractInactiveGameObject()
{
UnityEventListenerMock extractedMock = new UnityEventListenerMock();
subject.Extracted.AddListener(extractedMock.Listen);
GameObject publisherSource = new GameObject();
GameObject publisherChild = new GameObject();
publisherChild.transform.SetParent(publisherSource.transform);
ActiveCollisionPublisher publisher = publisherChild.AddComponent <ActiveCollisionPublisher>();
publisher.sourceContainer = publisherSource;
Assert.IsNull(subject.SourceContainer);
Assert.IsFalse(extractedMock.Received);
subject.gameObject.SetActive(false);
subject.Extract(publisher);
Assert.IsNull(subject.SourceContainer);
Assert.IsFalse(extractedMock.Received);
}
public void SetUp()
{
containingObject = new GameObject();
subject = containingObject.AddComponent <ActiveCollisionPublisher>();
}
/// <summary>
/// Extracts the source container from the given publisher.
/// </summary>
/// <param name="publisher">The publisher to extract from.</param>
public virtual void DoExtract(ActiveCollisionPublisher publisher)
{
Extract(publisher);
}
