public bool Execute(IDebugConsole console, params string[] args)
{
var componentManager = IoCManager.Resolve <IComponentManager>();
var mechanisms = componentManager.EntityQuery <IMechanism>();
foreach (var mechanism in mechanisms)
{
if (!mechanism.Owner.TryGetComponent(out SpriteComponent sprite))
{
continue;
}
sprite.ContainerOccluded = false;
var tempParent = mechanism.Owner;
while (ContainerHelpers.TryGetContainer(tempParent, out var container))
{
if (!container.ShowContents)
{
sprite.ContainerOccluded = true;
break;
}
tempParent = container.Owner;
}
}
IoCManager.Resolve <IClientConsole>().ProcessCommand("hidecontainedcontext");
return(false);
}
public override float GetScore(Blackboard context)
{
var target = context.GetState <TargetEntityState>().GetValue();
if (target == null)
{
return(0.0f);
}
if (ContainerHelpers.TryGetContainer(target, out var container))
{
if (container.Owner.TryGetComponent(out EntityStorageComponent storageComponent))
{
if (storageComponent.IsWeldedShut && !storageComponent.Open)
{
return(0.0f);
}
}
else
{
// If we're in a container (e.g. held or whatever) then we probably can't get it. Only exception
// Is a locker / crate
return(0.0f);
}
}
return(1.0f);
}
public override Outcome Execute(float frameTime)
{
if (!ContainerHelpers.TryGetContainer(_target, out var container))
{
return(Outcome.Success);
}
if (!InteractionChecks.InRangeUnobstructed(_owner, container.Owner.Transform.MapPosition, ignoredEnt: container.Owner))
{
return(Outcome.Failed);
}
if (!container.Owner.TryGetComponent(out EntityStorageComponent? storageComponent) ||
storageComponent.IsWeldedShut)
{
return(Outcome.Failed);
}
if (!storageComponent.Open)
{
var activateArgs = new ActivateEventArgs {
User = _owner, Target = _target
};
storageComponent.Activate(activateArgs);
}
var blackboard = UtilityAiHelpers.GetBlackboard(_owner);
blackboard?.GetState <LastOpenedStorageState>().SetValue(container.Owner);
return(Outcome.Success);
}
protected override float GetScore(Blackboard context)
{
var target = context.GetState <TargetEntityState>().GetValue();
if (target == null)
{
return(0.0f);
}
if (ContainerHelpers.TryGetContainer(target, out var container))
{
if (container.Owner.TryGetComponent(out EntityStorageComponent storageComponent))
{
if (storageComponent.IsWeldedShut && !storageComponent.Open)
{
return(0.0f);
}
}
else
{
// If we're in a container (e.g. held or whatever) then we probably can't get it. Only exception
// Is a locker / crate
return(0.0f);
}
}
var owner = context.GetState <SelfState>().GetValue();
return(EntitySystem.Get <AiReachableSystem>().CanAccess(owner, target, SharedInteractionSystem.InteractionRange) ? 1.0f : 0.0f);
}
protected static bool CanExamine(IEntity examiner, IEntity examined)
{
if (!examiner.TryGetComponent(out ExaminerComponent examinerComponent))
{
return(false);
}
if (!examinerComponent.DoRangeCheck)
{
return(true);
}
if (examiner.Transform.MapID != examined.Transform.MapID)
{
return(false);
}
Ignored predicate = entity => entity == examiner || entity == examined;
if (ContainerHelpers.TryGetContainer(examiner, out var container))
{
predicate += entity => entity == container.Owner;
}
return(InRangeUnOccluded(
examiner.Transform.MapPosition,
examined.Transform.MapPosition,
ExamineRange,
predicate: predicate,
ignoreInsideBlocker: true));
}
private InternalsComponent?GetInternalsComponent(IEntity?owner = null)
{
if (owner != null)
{
return(owner.GetComponentOrNull <InternalsComponent>());
}
return(ContainerHelpers.TryGetContainer(Owner, out var container)
? container.Owner.GetComponentOrNull <InternalsComponent>()
: null);
}
public static bool VerbContainerCheck(IEntity user, IEntity target)
{
if (!user.IsInSameOrNoContainer(target))
{
if (!ContainerHelpers.TryGetContainer(target, out var container) ||
container.Owner != user)
{
return(false);
}
}
return(true);
}
public void Receive(string message, int channel, IEntity source)
{
if (ContainerHelpers.TryGetContainer(Owner, out var container))
{
if (!container.Owner.TryGetComponent(out IActorComponent actor))
{
return;
}
var playerChannel = actor.playerSession.ConnectedClient;
var msg = _netManager.CreateNetMessage <MsgChatMessage>();
msg.Channel = ChatChannel.Radio;
msg.Message = message;
msg.MessageWrap = Loc.GetString("[{0}] {1} says, \"{{0}}\"", channel, source.Name);
_netManager.ServerSendMessage(msg, playerChannel);
}
}
private static void UpdateEntity(IEntity entity)
{
if (!entity.TryGetComponent(out SpriteComponent sprite))
{
return;
}
sprite.ContainerOccluded = false;
// We have to recursively scan for containers upwards in case of nested containers.
var tempParent = entity;
while (ContainerHelpers.TryGetContainer(tempParent, out var container))
{
if (!container.ShowContents)
{
sprite.ContainerOccluded = true;
return;
}
}
}
public bool CanSeeOnContextMenu(IEntity entity)
{
if (!entity.TryGetComponent(out SpriteComponent sprite) || !sprite.Visible)
{
return(false);
}
if (entity.GetAllComponents <IShowContextMenu>().Any(s => !s.ShowContextMenu(entity)))
{
return(false);
}
if (!_playerCanSeeThroughContainers &&
ContainerHelpers.TryGetContainer(entity, out var container) &&
!container.ShowContents)
{
return(false);
}
return(true);
}
private void ContainerModifiedReAttach(BuckleComponent buckle, StrapComponent?strap)
{
if (strap == null)
{
return;
}
var contained = ContainerHelpers.TryGetContainer(buckle.Owner, out var ownContainer);
var strapContained = ContainerHelpers.TryGetContainer(strap.Owner, out var strapContainer);
if (contained != strapContained || ownContainer != strapContainer)
{
buckle.TryUnbuckle(buckle.Owner, true);
return;
}
if (!contained)
{
buckle.ReAttach(strap);
}
}
public bool Explode()
{
// If we're in a locker or whatever then can't flash anything
ContainerHelpers.TryGetContainer(Owner, out var container);
if (container == null || !container.Owner.HasComponent <EntityStorageComponent>())
{
FlashableComponent.FlashAreaHelper(Owner, _range, _duration);
}
if (_sound != null)
{
EntitySystem.Get <AudioSystem>().PlayAtCoords(_sound, Owner.Transform.GridPosition);
}
if (_deleteOnFlash && !Owner.Deleted)
{
Owner.Delete();
}
return(true);
}
public override float GetScore(Blackboard context)
{
var target = context.GetState <TargetEntityState>().GetValue();
if (target == null)
{
return(0.0f);
}
if (ContainerHelpers.TryGetContainer(target, out var container))
{
if (container.Owner.TryGetComponent(out EntityStorageComponent storageComponent))
{
if (storageComponent.IsWeldedShut && !storageComponent.Open)
{
return(0.0f);
}
}
}
return(1.0f);
}
private static void UpdateEntity(IEntity entity)
{
if (entity.TryGetComponent(out SpriteComponent? sprite))
{
sprite.ContainerOccluded = false;
// We have to recursively scan for containers upwards in case of nested containers.
var tempParent = entity;
while (ContainerHelpers.TryGetContainer(tempParent, out var container))
{
if (!container.ShowContents)
{
sprite.ContainerOccluded = true;
break;
}
tempParent = container.Owner;
}
}
if (entity.TryGetComponent(out PointLightComponent? light))
{
light.ContainerOccluded = false;
// We have to recursively scan for containers upwards in case of nested containers.
var tempParent = entity;
while (ContainerHelpers.TryGetContainer(tempParent, out var container))
{
if (container.OccludesLight)
{
light.ContainerOccluded = true;
break;
}
tempParent = container.Owner;
}
}
}
protected override List <IEntity> GetTrueValue()
{
var result = new List <IEntity>();
if (!Owner.TryGetComponent(out AiControllerComponent controller))
{
return(result);
}
foreach (var entity in Visibility
.GetNearestEntities(Owner.Transform.Coordinates, typeof(DrinkComponent), controller.VisionRadius))
{
if (ContainerHelpers.TryGetContainer(entity, out var container))
{
if (!container.Owner.HasComponent <EntityStorageComponent>())
{
continue;
}
}
result.Add(entity);
}
return(result);
}
public void Render()
{
var size = ScreenSize;
if (size.X == 0 || size.Y == 0)
{
return;
}
_debugStats.Reset();
// Basic pre-render busywork.
// Clear screen to black.
ClearFramebuffer(Color.Black);
// Update shared UBOs.
_updateUniformConstants();
SetSpaceFull(CurrentSpace.ScreenSpace);
// Short path to render only the splash.
if (_drawingSplash)
{
_drawSplash(_renderHandle);
FlushRenderQueue();
SwapBuffers();
return;
}
void RenderOverlays(OverlaySpace space)
{
using (DebugGroup($"Overlays: {space}"))
{
foreach (var overlay in _overlayManager.AllOverlays
.Where(o => o.Space == space)
.OrderBy(o => o.ZIndex))
{
overlay.ClydeRender(_renderHandle);
}
FlushRenderQueue();
}
}
RenderOverlays(OverlaySpace.ScreenSpaceBelowWorld);
SetSpaceFull(CurrentSpace.WorldSpace);
// Calculate world-space AABB for camera, to cull off-screen things.
var eye = _eyeManager.CurrentEye;
var worldBounds = Box2.CenteredAround(eye.Position.Position,
_screenSize / EyeManager.PIXELSPERMETER * eye.Zoom);
using (DebugGroup("Lights"))
{
_drawLights(worldBounds);
}
using (DebugGroup("Grids"))
{
_drawGrids(worldBounds);
}
using (DebugGroup("Entities"))
{
_sortingSpritesList.Clear();
var map = _eyeManager.CurrentMap;
// So we could calculate the correct size of the entities based on the contents of their sprite...
// Or we can just assume that no entity is larger than 10x10 and get a stupid easy check.
// TODO: Make this check more accurate.
var widerBounds = worldBounds.Enlarged(5);
foreach (var sprite in _componentManager.GetAllComponents <SpriteComponent>())
{
var entity = sprite.Owner;
if (entity.Transform.MapID != map || !widerBounds.Contains(entity.Transform.WorldPosition) || !sprite.Visible)
{
continue;
}
if (ContainerHelpers.TryGetContainer(entity, out var container) && !container.ShowContents)
{
continue;
}
_sortingSpritesList.Add(sprite);
}
_sortingSpritesList.Sort((a, b) =>
{
var cmp = ((int)a.DrawDepth).CompareTo((int)b.DrawDepth);
if (cmp != 0)
{
return(cmp);
}
cmp = a.RenderOrder.CompareTo(b.RenderOrder);
if (cmp != 0)
{
return(cmp);
}
return(a.Owner.Uid.CompareTo(b.Owner.Uid));
});
foreach (var sprite in _sortingSpritesList)
{
Vector2i roundedPos = default;
if (sprite.PostShader != null)
{
_renderHandle.UseRenderTarget(EntityPostRenderTarget);
_renderHandle.Clear(new Color());
// Calculate viewport so that the entity thinks it's drawing to the same position,
// which is necessary for light application,
// but it's ACTUALLY drawing into the center of the render target.
var spritePos = sprite.Owner.Transform.WorldPosition;
var screenPos = _eyeManager.WorldToScreen(spritePos);
var(roundedX, roundedY) = roundedPos = (Vector2i)screenPos;
var flippedPos = new Vector2i(roundedX, ScreenSize.Y - roundedY);
flippedPos -= EntityPostRenderTarget.Size / 2;
_renderHandle.Viewport(Box2i.FromDimensions(-flippedPos, ScreenSize));
}
sprite.OpenGLRender(_renderHandle.DrawingHandleWorld);
if (sprite.PostShader != null)
{
_renderHandle.UseRenderTarget(null);
_renderHandle.Viewport(Box2i.FromDimensions(Vector2i.Zero, ScreenSize));
_renderHandle.UseShader(sprite.PostShader);
_renderHandle.SetSpace(CurrentSpace.ScreenSpace);
_renderHandle.SetModelTransform(Matrix3.Identity);
var rounded = roundedPos - EntityPostRenderTarget.Size / 2;
var box = UIBox2i.FromDimensions(rounded, EntityPostRenderTarget.Size);
_renderHandle.DrawTexture(EntityPostRenderTarget.Texture, box.BottomLeft,
box.TopRight, Color.White, null, 0);
_renderHandle.SetSpace(CurrentSpace.WorldSpace);
_renderHandle.UseShader(null);
}
}
FlushRenderQueue();
}
RenderOverlays(OverlaySpace.WorldSpace);
_lightingReady = false;
SetSpaceFull(CurrentSpace.ScreenSpace);
RenderOverlays(OverlaySpace.ScreenSpace);
using (DebugGroup("UI"))
{
_userInterfaceManager.Render(_renderHandle);
FlushRenderQueue();
}
// And finally, swap those buffers!
SwapBuffers();
}
private void Cycle(bool manual = false)
{
if (BoltOpen)
{
return;
}
var chamberEntity = _chamberContainer.ContainedEntity;
if (chamberEntity != null)
{
_chamberContainer.Remove(chamberEntity);
var ammoComponent = chamberEntity.GetComponent <AmmoComponent>();
if (!ammoComponent.Caseless)
{
EjectCasing(chamberEntity);
}
}
// Try and pull a round from the magazine to replace the chamber if possible
var magazine = _magazineContainer.ContainedEntity;
var nextRound = magazine?.GetComponent <RangedMagazineComponent>().TakeAmmo();
if (nextRound != null)
{
// If you're really into gunporn you could put a sound here
_chamberContainer.Insert(nextRound);
}
var soundSystem = EntitySystem.Get <AudioSystem>();
if (_autoEjectMag && magazine != null && magazine.GetComponent <RangedMagazineComponent>().ShotsLeft == 0)
{
if (_soundAutoEject != null)
{
soundSystem.PlayAtCoords(_soundAutoEject, Owner.Transform.GridPosition, AudioParams.Default.WithVolume(-2));
}
_magazineContainer.Remove(magazine);
SendNetworkMessage(new MagazineAutoEjectMessage());
}
if (nextRound == null && !BoltOpen)
{
if (_soundBoltOpen != null)
{
soundSystem.PlayAtCoords(_soundBoltOpen, Owner.Transform.GridPosition, AudioParams.Default.WithVolume(-5));
}
if (ContainerHelpers.TryGetContainer(Owner, out var container))
{
Owner.PopupMessage(container.Owner, Loc.GetString("Bolt open"));
}
BoltOpen = true;
Dirty();
UpdateAppearance();
return;
}
if (manual)
{
if (_soundRack != null)
{
soundSystem.PlayAtCoords(_soundRack, Owner.Transform.GridPosition, AudioParams.Default.WithVolume(-2));
}
}
Dirty();
UpdateAppearance();
}