[Communication] PR1: Added Base Files for Mailbox

Assets/Scripts/Communication/IMessagePayload.cs

@@ -0,0 +1,3 @@
+// Interface for a message payload.
+
+public interface IMessagePayload {}

Assets/Scripts/Communication/Message.cs

@@ -0,0 +1,61 @@
+// The message is a base class for the different types of messages being sent and received among the
+// agents. It always carries a sender, a receiver, a message type, and a payload.
+
+using System;
+
+// Message type enumeration that defines the message payload.
+public enum MessageType {
+  AssignTargetRequest,
+  AssignTargetResponse,
+  ReassignTargetRequest,
+}
+
+public abstract class Message {
+  public IAgent Sender { get; }
+  public IAgent Receiver { get; }
+  public MessageType Type { get; }
+
+  public abstract IMessagePayload Payload { get; }
+
+  protected Message(IAgent sender, IAgent receiver, MessageType type) {
+    Sender = sender ?? throw new ArgumentNullException(nameof(sender));
+    Receiver = receiver ?? throw new ArgumentNullException(nameof(receiver));
+    Type = type;
+  }
+}
+
+// Generic message that stores a payload. The generic type refers to the payloa type.
+public abstract class Message<TPayload> : Message
+    where TPayload : class, IMessagePayload {
+  public TPayload PayloadData { get; }
+  public sealed override IMessagePayload Payload => PayloadData;
+  protected Message(IAgent sender, IAgent receiver, MessageType type, TPayload payload)
+      : base(sender, receiver, type) {
+    PayloadData = payload ?? throw new ArgumentNullException(nameof(payload));
+  }
+}
+
+// This message is sent upwards to a parent interceptor or IADS when a sub-interceptor has no target
+// and is requesting a new target.
+public sealed class AssignTargetRequestMessage : Message<AssignTargetRequestPayload> {
+  public AssignTargetRequestMessage(IAgent sender, IAgent receiver, IInterceptor subInterceptor)
+      : base(sender, receiver, MessageType.AssignTargetRequest,
+             new AssignTargetRequestPayload(subInterceptor)) {}
+}
+
+// This message is sent downwards from the IADS or a parent interceptor to inform the
+// sub-interceptor of a new target.
+public sealed class AssignTargetResponseMessage : Message<AssignTargetResponsePayload> {
+  public AssignTargetResponseMessage(IAgent sender, IAgent receiver, IHierarchical target)
+      : base(sender, receiver, MessageType.AssignTargetResponse,
+             new AssignTargetResponsePayload(target)) {}
+}
+
+// This message is sent upwards to a parent interceptor or IADS when a sub-interceptor can no longer
+// pursue the current target and is requesting the parent interceptor or IADS to reassign that
+// target elsewhere.
+public sealed class ReassignTargetRequestMessage : Message<ReassignTargetRequestPayload> {
+  public ReassignTargetRequestMessage(IAgent sender, IAgent receiver, IHierarchical target)
+      : base(sender, receiver, MessageType.ReassignTargetRequest,
+             new ReassignTargetRequestPayload(target)) {}
+}

Assets/Scripts/Communication/MessagePayload.cs

@@ -0,0 +1,33 @@
+// The message payload defines different types of payloads carried by messages.
+
+using System;
+
+// The payload carries the sub-interceptor that is requesting a parent interceptor or IADS for a new
+// target assignment.
+public sealed class AssignTargetRequestPayload : IMessagePayload {
+  public IInterceptor SubInterceptor { get; }
+
+  public AssignTargetRequestPayload(IInterceptor subInterceptor) {
+    SubInterceptor = subInterceptor ?? throw new ArgumentNullException(nameof(subInterceptor));
+  }
+}
+
+// The payload carries the target that a parent interceptor or IADS has selected for a requesting
+// sub-interceptor.
+public sealed class AssignTargetResponsePayload : IMessagePayload {
+  public IHierarchical Target { get; }
+
+  public AssignTargetResponsePayload(IHierarchical target) {
+    Target = target ?? throw new ArgumentNullException(nameof(target));
+  }
+}
+
+// The payload carries the target that a sub-interceptor is requesting its parent interceptor or
+// IADS to reassign.
+public sealed class ReassignTargetRequestPayload : IMessagePayload {
+  public IHierarchical Target { get; }
+
+  public ReassignTargetRequestPayload(IHierarchical target) {
+    Target = target ?? throw new ArgumentNullException(nameof(target));
+  }
+}

Assets/Scripts/Communication/PendingMessage.cs

@@ -0,0 +1,27 @@
+// The pending message is the mailbox's internal queue item. It stores the message object and the
+// scheduled delivery time in simulation seconds. The mailbox dequeues this item once the simulation
+// time reaches the deliver at time.
+
+using System;
+
+public readonly struct PendingMessage : IComparable<PendingMessage> {
+  public Message Message { get; }
+
+  // Absolute simulation time in seconds when the mailbox should deliver this message.
+  public float DeliverAt { get; }
+
+  public IAgent Sender => Message?.Sender;
+  public IAgent Receiver => Message?.Receiver;
+
+  public PendingMessage(Message message, float deliverAt) {
+    if (float.IsNaN(deliverAt) || float.IsInfinity(deliverAt) || deliverAt < 0f) {
+      throw new ArgumentOutOfRangeException(nameof(deliverAt), deliverAt,
+                                            "DeliverAt must be finite and non-negative.");
+    }
+    Message = message ?? throw new ArgumentNullException(nameof(message));
+    DeliverAt = deliverAt;
+  }
+
+  // Pending messages are sorted based on the deliver at time.
+  public int CompareTo(PendingMessage other) => DeliverAt.CompareTo(other.DeliverAt);
+}

ProjectSettings/Packages/com.unity.testtools.codecoverage/Settings.json

@@ -33,4 +33,4 @@
             }
         ]
     }
-}
+}