public PVSEntityPacket(IEntityManager entityManager, EntityUid uid)
{
TransformComponent = entityManager.GetComponent <TransformComponent>(uid);
MetaDataComponent = entityManager.GetComponent <MetaDataComponent>(uid);
entityManager.TryGetComponent(uid, out VisibilityComponent);
entityManager.TryGetComponent(uid, out ContainerManagerComponent);
}
public void SubscribeCompEvent()
{
// Arrange
var entUid = new EntityUid(7);
var compInstance = new MetaDataComponent();
var compRegistration = new Mock <IComponentRegistration>();
var entManMock = new Mock <IEntityManager>();
var compManMock = new Mock <IComponentManager>();
var compFacMock = new Mock <IComponentFactory>();
compRegistration.Setup(m => m.References).Returns(new List <Type> {
typeof(MetaDataComponent)
});
compFacMock.Setup(m => m.GetRegistration(typeof(MetaDataComponent))).Returns(compRegistration.Object);
compManMock.Setup(m => m.ComponentFactory).Returns(compFacMock.Object);
IComponent?outIComponent = compInstance;
compManMock.Setup(m => m.TryGetComponent(entUid, typeof(MetaDataComponent), out outIComponent))
.Returns(true);
compManMock.Setup(m => m.GetComponent(entUid, typeof(MetaDataComponent)))
.Returns(compInstance);
entManMock.Setup(m => m.ComponentManager).Returns(compManMock.Object);
var bus = new EntityEventBus(entManMock.Object);
// Subscribe
int calledCount = 0;
bus.SubscribeLocalEvent <MetaDataComponent, TestEvent>(HandleTestEvent);
// add a component to the system
entManMock.Raise(m => m.EntityAdded += null, entManMock.Object, entUid);
compManMock.Raise(m => m.ComponentAdded += null, new AddedComponentEventArgs(compInstance, entUid));
// Raise
var evntArgs = new TestEvent(5);
bus.RaiseLocalEvent(entUid, evntArgs);
// Assert
Assert.That(calledCount, Is.EqualTo(1));
void HandleTestEvent(EntityUid uid, MetaDataComponent component, TestEvent args)
{
calledCount++;
Assert.That(uid, Is.EqualTo(entUid));
Assert.That(component, Is.EqualTo(compInstance));
Assert.That(args.TestNumber, Is.EqualTo(5));
}
}
public VerbMenuPopup([CanBeNull] MetaDataComponent entityMetaData)
{
RobustXamlLoader.Load(this);
if (entityMetaData != null && !string.IsNullOrEmpty(entityMetaData.EntityDescription))
{
DescLabel.Margin = new Thickness(4, 0, 4, 0);
DescLabel.Text = entityMetaData.EntityDescription;
}
else
{
Desc.Visible = false;
}
}
private void OnMetaDataHandle(EntityUid uid, MetaDataComponent component, ref ComponentHandleState args)
{
if (args.Current is not MetaDataComponentState state)
{
return;
}
component._entityName = state.Name;
component._entityDescription = state.Description;
if (state.PrototypeId != null)
{
component._entityPrototype = _proto.Index <EntityPrototype>(state.PrototypeId);
}
}
public void SubscribeCompLifeEvent()
{
// Arrange
var entUid = new EntityUid(7);
var compInstance = new MetaDataComponent();
var mockEnt = new Mock <IEntity>();
mockEnt.SetupGet(m => m.Uid).Returns(entUid);
compInstance.Owner = mockEnt.Object;
var entManMock = new Mock <IEntityManager>();
var compManMock = new Mock <IComponentManager>();
IComponent?outIComponent = compInstance;
compManMock.Setup(m => m.TryGetComponent(entUid, typeof(MetaDataComponent), out outIComponent))
.Returns(true);
compManMock.Setup(m => m.GetComponent(entUid, typeof(MetaDataComponent)))
.Returns(compInstance);
entManMock.Setup(m => m.ComponentManager).Returns(compManMock.Object);
var bus = new EntityEventBus(entManMock.Object);
// Subscribe
int calledCount = 0;
bus.SubscribeLocalEvent <MetaDataComponent, ComponentInit>(HandleTestEvent);
// add a component to the system
entManMock.Raise(m => m.EntityAdded += null, entManMock.Object, entUid);
compManMock.Raise(m => m.ComponentAdded += null, new AddedComponentEventArgs(compInstance, entUid));
// Raise
bus.RaiseComponentEvent(compInstance, new ComponentInit());
// Assert
Assert.That(calledCount, Is.EqualTo(1));
void HandleTestEvent(EntityUid uid, MetaDataComponent component, ComponentInit args)
{
calledCount++;
Assert.That(uid, Is.EqualTo(entUid));
Assert.That(component, Is.EqualTo(compInstance));
}
}
public void UnsubscribeCompEvent()
{
// Arrange
var entUid = new EntityUid(7);
var compInstance = new MetaDataComponent();
var entManMock = new Mock <IEntityManager>();
var compManMock = new Mock <IComponentManager>();
IComponent?outIComponent = compInstance;
compManMock.Setup(m => m.TryGetComponent(entUid, typeof(MetaDataComponent), out outIComponent))
.Returns(true);
compManMock.Setup(m => m.GetComponent(entUid, typeof(MetaDataComponent)))
.Returns(compInstance);
entManMock.Setup(m => m.ComponentManager).Returns(compManMock.Object);
var bus = new EntityEventBus(entManMock.Object);
// Subscribe
int calledCount = 0;
bus.SubscribeLocalEvent <MetaDataComponent, TestEvent>(HandleTestEvent);
bus.UnsubscribeLocalEvent <MetaDataComponent, TestEvent>();
// add a component to the system
entManMock.Raise(m => m.EntityAdded += null, entManMock.Object, entUid);
compManMock.Raise(m => m.ComponentAdded += null, new AddedComponentEventArgs(compInstance, entUid));
// Raise
var evntArgs = new TestEvent(5);
bus.RaiseLocalEvent(entUid, evntArgs);
// Assert
Assert.That(calledCount, Is.EqualTo(0));
void HandleTestEvent(EntityUid uid, MetaDataComponent component, TestEvent args)
{
calledCount++;
}
}
public async Task PuddlePauseTest()
{
var server = StartServer();
await server.WaitIdleAsync();
var sMapManager = server.ResolveDependency <IMapManager>();
var sTileDefinitionManager = server.ResolveDependency <ITileDefinitionManager>();
var sGameTiming = server.ResolveDependency <IGameTiming>();
var entityManager = server.ResolveDependency <IEntityManager>();
MapId sMapId = default;
IMapGrid sGrid;
GridId sGridId = default;
EntityUid sGridEntity = default;
EntityCoordinates sCoordinates = default;
// Spawn a paused map with one tile to spawn puddles on
await server.WaitPost(() =>
{
sMapId = sMapManager.CreateMap();
sMapManager.SetMapPaused(sMapId, true);
sGrid = sMapManager.CreateGrid(sMapId);
sGridId = sGrid.Index;
sGridEntity = sGrid.GridEntityId;
entityManager.GetComponent <MetaDataComponent>(sGridEntity).EntityPaused = true; // See https://github.com/space-wizards/RobustToolbox/issues/1444
var tileDefinition = sTileDefinitionManager["underplating"];
var tile = new Tile(tileDefinition.TileId);
sCoordinates = sGrid.ToCoordinates();
sGrid.SetTile(sCoordinates, tile);
});
// Check that the map and grid are paused
await server.WaitAssertion(() =>
{
Assert.True(sMapManager.IsGridPaused(sGridId));
Assert.True(sMapManager.IsMapPaused(sMapId));
});
float evaporateTime = default;
PuddleComponent puddle = null;
MetaDataComponent meta = null;
EvaporationComponent evaporation;
var amount = 2;
var entitySystemManager = server.ResolveDependency <IEntitySystemManager>();
var spillSystem = entitySystemManager.GetEntitySystem <SpillableSystem>();
// Spawn a puddle
await server.WaitAssertion(() =>
{
var solution = new Solution("Water", FixedPoint2.New(amount));
puddle = spillSystem.SpillAt(solution, sCoordinates, "PuddleSmear");
meta = entityManager.GetComponent <MetaDataComponent>(puddle.Owner);
// Check that the puddle was created
Assert.NotNull(puddle);
evaporation = entityManager.GetComponent <EvaporationComponent>(puddle.Owner);
meta.EntityPaused = true; // See https://github.com/space-wizards/RobustToolbox/issues/1445
Assert.True(meta.EntityPaused);
// Check that the puddle is going to evaporate
Assert.Positive(evaporation.EvaporateTime);
// Should have a timer component added to it for evaporation
Assert.That(evaporation.Accumulator, Is.EqualTo(0f));
evaporateTime = evaporation.EvaporateTime;
});
// Wait enough time for it to evaporate if it was unpaused
var sTimeToWait = (5 + (int)Math.Ceiling(amount * evaporateTime * sGameTiming.TickRate));
await server.WaitRunTicks(sTimeToWait);
// No evaporation due to being paused
await server.WaitAssertion(() =>
{
Assert.True(meta.EntityPaused);
// Check that the puddle still exists
Assert.False(meta.EntityDeleted);
});
// Unpause the map
await server.WaitPost(() => { sMapManager.SetMapPaused(sMapId, false); });
// Check that the map, grid and puddle are unpaused
await server.WaitAssertion(() =>
{
Assert.False(sMapManager.IsMapPaused(sMapId));
Assert.False(sMapManager.IsGridPaused(sGridId));
Assert.False(meta.EntityPaused);
// Check that the puddle still exists
Assert.False(meta.EntityDeleted);
});
// Wait enough time for it to evaporate
await server.WaitRunTicks(sTimeToWait);
// Puddle evaporation should have ticked
await server.WaitAssertion(() =>
{
// Check that puddle has been deleted
Assert.True(puddle.Deleted);
});
}
private void OnMetaDataGetState(EntityUid uid, MetaDataComponent component, ref ComponentGetState args)
{
args.State = new MetaDataComponentState(component._entityName, component._entityDescription, component._entityPrototype?.ID);
}
