/// <summary>
/// Creates a new <see cref="DataReader" /> with the desired QoS policies and attaches to it the specified <see cref="DataReaderListener" />.
/// </summary>
/// <remarks>
/// <para>The returned <see cref="DataReader" /> will be attached and belong to the <see cref="Subscriber" />.</para>
/// <para>The <see cref="ITopicDescription"/> passed to this operation must have been created from the same <see cref="DomainParticipant" /> that was used to
/// create this <see cref="Subscriber" />. If the <see cref="ITopicDescription"/> was created from a different <see cref="DomainParticipant" />, the operation will fail and
/// return a <see langword="null"/> result.</para>
/// </remarks>
/// <param name="topicDescription">The <see cref="ITopicDescription" /> that the <see cref="DataReader" /> will be associated with.</param>
/// <param name="qos">The <see cref="DataReaderQos" /> policies to be used for creating the new <see cref="DataReader" />.</param>
/// <param name="listener">The <see cref="DataReaderListener" /> to be attached to the newly created <see cref="DataReader" />.</param>
/// <param name="statusMask">The <see cref="StatusMask" /> of which status changes the listener should be notified.</param>
/// <returns>The newly created <see cref="DataReader" /> on success, otherwise <see langword="null"/>.</returns>
public DataReader CreateDataReader(ITopicDescription topicDescription, DataReaderQos qos, DataReaderListener listener, StatusMask statusMask)
{
if (topicDescription is null)
{
throw new ArgumentNullException(nameof(topicDescription));
}
DataReaderQosWrapper qosWrapper = default;
if (qos is null)
{
qos = new DataReaderQos();
var ret = GetDefaultDataReaderQos(qos);
if (ret == ReturnCode.Ok)
{
qosWrapper = qos.ToNative();
}
}
else
{
qosWrapper = qos.ToNative();
}
IntPtr nativeListener = IntPtr.Zero;
if (listener != null)
{
nativeListener = listener.ToNative();
}
IntPtr td = topicDescription.ToNativeTopicDescription();
IntPtr native = UnsafeNativeMethods.CreateDataReader(_native, td, qosWrapper, nativeListener, statusMask);
qos.Release();
if (native.Equals(IntPtr.Zero))
{
return(null);
}
var dr = new DataReader(native)
{
Listener = listener,
};
EntityManager.Instance.Add((dr as Entity).ToNative(), dr);
ContainedEntities.Add(dr);
return(dr);
}
/// <summary>
/// This operation deletes all the entities that were created by means of the "create" operations on the <see cref="Publisher" />. That is, it deletes
/// all contained <see cref="DataWriter" /> objects.
/// </summary>
/// <remarks>
/// <para>The operation will return <see cref="ReturnCode.PreconditionNotMet" /> if the any of the contained entities is in a state where it cannot be deleted.</para>
/// <para>Once DeleteContainedEntities returns successfully, the application may delete the <see cref="Publisher" /> knowing that it has no
/// contained <see cref="DataWriter" /> objects.</para>
/// </remarks>
/// <returns>The <see cref="ReturnCode" /> that indicates the operation result.</returns>
public ReturnCode DeleteContainedEntities()
{
ReturnCode ret = UnsafeNativeMethods.DeleteContainedEntities(_native);
if (ret == ReturnCode.Ok)
{
foreach (Entity e in ContainedEntities)
{
EntityManager.Instance.Remove(e.ToNative());
}
ContainedEntities.Clear();
}
return(ret);
}
/// <summary>
/// Deletes a <see cref="DataReader" /> that belongs to the <see cref="Subscriber" />.
/// </summary>
/// <remarks>
/// <para>If the <see cref="DataReader" /> does not belong to the <see cref="Subscriber" />, the operation returns the error <see cref="ReturnCode.PreconditionNotMet" />.</para>
/// <para>The deletion of a <see cref="DataReader" /> is not allowed if there are any existing <see cref="ReadCondition" /> or <see cref="QueryCondition" /> objects that are
/// attached to the <see cref="DataReader" />. If the DeleteDataReader operation is called on a <see cref="DataReader" /> with any of these existing objects
/// attached to it, it will return <see cref="ReturnCode.PreconditionNotMet" />.</para>
/// <para>The DeleteDataReader operation must be called on the same <see cref="Subscriber" /> object used to create the <see cref="DataReader" />. If
/// DeleteDataReader is called on a different <see cref="Subscriber" />, the operation will have no effect and it will return
/// <see cref="ReturnCode.PreconditionNotMet" />.</para>
/// </remarks>
/// <param name="dataReader">The <see cref="DataReader" /> to be deleted.</param>
/// <returns>The <see cref="ReturnCode" /> that indicates the operation result.</returns>
public ReturnCode DeleteDataReader(DataReader dataReader)
{
if (dataReader == null)
{
return(ReturnCode.Ok);
}
ReturnCode ret = UnsafeNativeMethods.DeleteDataReader(_native, dataReader.ToNative());
if (ret == ReturnCode.Ok)
{
EntityManager.Instance.Remove((dataReader as Entity).ToNative());
ContainedEntities.Remove(dataReader);
}
return(ret);
}
public override void HandleComponentState(dynamic state)
{
var theState = state as InventoryComponentState;
var stateChanged = false;
if (MaxSlots != theState.MaxSlots)
{
MaxSlots = theState.MaxSlots;
stateChanged = true;
}
var newEntities = new List <int>(theState.ContainedEntities);
var toRemove = new List <IEntity>();
foreach (var e in ContainedEntities)
{
if (newEntities.Contains(e.Uid))
{
newEntities.Remove(e.Uid);
}
else
{
toRemove.Add(e);
}
}
stateChanged = stateChanged || toRemove.Any() || newEntities.Any();
foreach (var e in toRemove)
{
ContainedEntities.Remove(e);
}
foreach (var uid in newEntities)
{
ContainedEntities.Add(Owner.EntityManager.GetEntity(uid));
}
if (stateChanged && Changed != null)
{
Changed(this, MaxSlots, ContainedEntities);
}
}
private void UnpackListing(IncomingEntityComponentMessage msg)
{
MaxSlots = (int)msg.MessageParameters[1];
ContainedEntities.Clear();
for (int i = 0; i < (int)msg.MessageParameters[2]; i++)
{
int msgPos = 3 + i;
Entity entity = Owner.EntityManager.GetEntity((int)msg.MessageParameters[msgPos]);
if (entity != null)
{
ContainedEntities.Add(entity);
}
}
if (Changed != null)
{
Changed(this, MaxSlots, ContainedEntities);
}
}
private async Task <IEntity?> Construct(IEntity user, string materialContainer, ConstructionGraphPrototype graph, ConstructionGraphEdge edge, ConstructionGraphNode targetNode)
{
// We need a place to hold our construction items!
var container = ContainerManagerComponent.Ensure <Container>(materialContainer, user, out var existed);
if (existed)
{
user.PopupMessageCursor(Loc.GetString("You can't start another construction now!"));
return(null);
}
var containers = new Dictionary <string, Container>();
var doAfterTime = 0f;
// HOLY SHIT THIS IS SOME HACKY CODE.
// But I'd rather do this shit than risk having collisions with other containers.
Container GetContainer(string name)
{
if (containers !.ContainsKey(name))
{
return(containers[name]);
}
while (true)
{
var random = _robustRandom.Next();
var c = ContainerManagerComponent.Ensure <Container>(random.ToString(), user !, out var existed);
if (existed)
{
continue;
}
containers[name] = c;
return(c);
}
}
void FailCleanup()
{
foreach (var entity in container !.ContainedEntities.ToArray())
{
container.Remove(entity);
}
foreach (var cont in containers !.Values)
{
foreach (var entity in cont.ContainedEntities.ToArray())
{
cont.Remove(entity);
}
}
// If we don't do this, items are invisible for some f*****g reason. Nice.
Timer.Spawn(1, ShutdownContainers);
}
void ShutdownContainers()
{
container !.Shutdown();
foreach (var c in containers !.Values.ToArray())
{
c.Shutdown();
}
}
var failed = false;
var steps = new List <ConstructionGraphStep>();
foreach (var step in edge.Steps)
{
doAfterTime += step.DoAfter;
var handled = false;
switch (step)
{
case MaterialConstructionGraphStep materialStep:
foreach (var entity in EnumerateNearby(user))
{
if (!materialStep.EntityValid(entity, out var sharedStack))
{
continue;
}
var stack = (StackComponent)sharedStack;
if (!stack.Split(materialStep.Amount, user.ToCoordinates(), out var newStack))
{
continue;
}
if (string.IsNullOrEmpty(materialStep.Store))
{
if (!container.Insert(newStack))
{
continue;
}
}
else if (!GetContainer(materialStep.Store).Insert(newStack))
{
continue;
}
handled = true;
break;
}
break;
case ComponentConstructionGraphStep componentStep:
foreach (var entity in EnumerateNearby(user))
{
if (!componentStep.EntityValid(entity))
{
continue;
}
if (string.IsNullOrEmpty(componentStep.Store))
{
if (!container.Insert(entity))
{
continue;
}
}
else if (!GetContainer(componentStep.Store).Insert(entity))
{
continue;
}
handled = true;
break;
}
break;
case PrototypeConstructionGraphStep prototypeStep:
foreach (var entity in EnumerateNearby(user))
{
if (!prototypeStep.EntityValid(entity))
{
continue;
}
if (string.IsNullOrEmpty(prototypeStep.Store))
{
if (!container.Insert(entity))
{
continue;
}
}
else if (!GetContainer(prototypeStep.Store).Insert(entity))
{
continue;
}
handled = true;
break;
}
break;
}
if (handled == false)
{
failed = true;
break;
}
steps.Add(step);
}
if (failed)
{
user.PopupMessageCursor(Loc.GetString("You don't have the materials to build that!"));
FailCleanup();
return(null);
}
var doAfterSystem = Get <DoAfterSystem>();
var doAfterArgs = new DoAfterEventArgs(user, doAfterTime)
{
BreakOnDamage = true,
BreakOnStun = true,
BreakOnTargetMove = false,
BreakOnUserMove = true,
NeedHand = true,
};
if (await doAfterSystem.DoAfter(doAfterArgs) == DoAfterStatus.Cancelled)
{
FailCleanup();
return(null);
}
var newEntity = EntityManager.SpawnEntity(graph.Nodes[edge.Target].Entity, user.Transform.Coordinates);
// Yes, this should throw if it's missing the component.
var construction = newEntity.GetComponent <ConstructionComponent>();
// We attempt to set the pathfinding target.
construction.Target = targetNode;
// We preserve the containers...
foreach (var(name, cont) in containers)
{
var newCont = ContainerManagerComponent.Ensure <Container>(name, newEntity);
foreach (var entity in cont.ContainedEntities.ToArray())
{
cont.ForceRemove(entity);
newCont.Insert(entity);
}
}
// We now get rid of all them.
ShutdownContainers();
// We have step completed steps!
foreach (var step in steps)
{
foreach (var completed in step.Completed)
{
await completed.PerformAction(newEntity, user);
}
}
// And we also have edge completed effects!
foreach (var completed in edge.Completed)
{
await completed.PerformAction(newEntity, user);
}
return(newEntity);
}
public IEntity GetEntity(string templatename)
{
return(ContainedEntities.FirstOrDefault(x => x.Prototype.ID == templatename));
}
public bool ContainsEntity(string templatename)
{
return(ContainedEntities.Exists(x => x.Prototype.ID == templatename));
}
public bool ContainsEntity(IEntity entity)
{
return(ContainedEntities.Contains(entity));
}
public Entity GetEntity(string templatename)
{
return(ContainedEntities.Exists(x => x.Template.Name == templatename)
? ContainedEntities.First(x => x.Template.Name == templatename)
: null);
}
public bool ContainsEntity(string templatename)
{
return(ContainedEntities.Exists(x => x.Template.Name == templatename));
}
public VersaDescription GetDefaultDescription() =>
ContainedEntities.Any()
? Description + "\n" + ContainedEntities.Select(c => c.Description).Aggregate(new StringBuilder(),
(stringBuilder, entityDescription) =>
stringBuilder.AppendFormat("A creature: {0}", entityDescription).AppendLine()).ToString()
: Description;
