/// <summary>
/// Inserts storeable entities into this storage container if possible, otherwise return to the hand of the user
/// </summary>
/// <param name="user"></param>
/// <param name="attackwith"></param>
/// <returns></returns>
public bool AttackBy(AttackByEventArgs eventArgs)
{
_ensureInitialCalculated();
Logger.DebugS("Storage", "Storage (UID {0}) attacked by user (UID {1}) with entity (UID {2}).", Owner.Uid, eventArgs.User.Uid, eventArgs.AttackWith.Uid);
if (Owner.TryGetComponent <PlaceableSurfaceComponent>(out var placeableSurfaceComponent))
{
return(false);
}
if (!eventArgs.User.TryGetComponent(out HandsComponent hands))
{
return(false);
}
//Check that we can drop the item from our hands first otherwise we obviously cant put it inside
if (CanInsert(hands.GetActiveHand.Owner) && hands.Drop(hands.ActiveIndex))
{
if (Insert(eventArgs.AttackWith))
{
return(true);
}
}
else
{
Owner.PopupMessage(eventArgs.User, "Can't insert.");
}
return(false);
}
public bool AttackBy(AttackByEventArgs eventArgs)
{
if (!eventArgs.AttackWith.TryGetComponent <WelderComponent>(out var welder))
{
return(false);
}
if (welder.TryUse(5.0f))
{
// Repair generator
var damagable = Owner.GetComponent <DamageableComponent>();
var breakable = Owner.GetComponent <BreakableComponent>();
damagable.HealAllDamage();
breakable.broken = false;
_intact = true;
var entitySystemManager = IoCManager.Resolve <IEntitySystemManager>();
var notifyManager = IoCManager.Resolve <IServerNotifyManager>();
entitySystemManager.GetEntitySystem <AudioSystem>().Play("/Audio/items/welder2.ogg", Owner);
notifyManager.PopupMessage(Owner, eventArgs.User, Loc.GetString("You repair the gravity generator with the welder"));
return(true);
}
else
{
return(false);
}
}
bool IAttackBy.AttackBy(AttackByEventArgs eventArgs)
{
if (!eventArgs.AttackWith.HasComponent <PowerCellComponent>())
{
return(false);
}
if (Cell != null)
{
return(false);
}
var handsComponent = eventArgs.User.GetComponent <IHandsComponent>();
if (!handsComponent.Drop(eventArgs.AttackWith, _cellContainer))
{
return(false);
}
if (Owner.TryGetComponent(out SoundComponent soundComponent))
{
soundComponent.Play("/Audio/items/weapons/pistol_magin.ogg");
}
return(true);
}
public bool AttackBy(AttackByEventArgs eventArgs)
{
if (eventArgs.AttackWith.TryGetComponent(out WirecutterComponent wirecutter))
{
Owner.Delete();
return(true);
}
return(false);
}
/// <summary>
/// Inserts storeable entities into this storage container if possible, otherwise return to the hand of the user
/// </summary>
/// <param name="user"></param>
/// <param name="attackwith"></param>
/// <returns></returns>
public bool AttackBy(AttackByEventArgs eventArgs)
{
Logger.DebugS("Storage", "Storage (UID {0}) attacked by user (UID {1}) with entity (UID {2}).", Owner.Uid, eventArgs.User.Uid, eventArgs.AttackWith.Uid);
if(Owner.TryGetComponent<PlaceableSurfaceComponent>(out var placeableSurfaceComponent))
{
return false;
}
return PlayerInsertEntity(eventArgs.User);
}
public bool AttackBy(AttackByEventArgs eventArgs)
{
var playerEntity = eventArgs.User;
var interactionSystem = _entitySystemManager.GetEntitySystem <InteractionSystem>();
if (!interactionSystem.InRangeUnobstructed(playerEntity.Transform.MapPosition, Owner.Transform.WorldPosition, ignoredEnt: Owner, insideBlockerValid: Prototype.CanBuildInImpassable))
{
_notifyManager.PopupMessage(Owner.Transform.GridPosition, playerEntity,
_localizationManager.GetString("You can't reach there!"));
return(false);
}
var stage = Prototype.Stages[Stage];
if (TryProcessStep(stage.Forward, eventArgs.AttackWith))
{
Stage++;
if (Stage == Prototype.Stages.Count - 1)
{
// Oh boy we get to finish construction!
var entMgr = IoCManager.Resolve <IServerEntityManager>();
var ent = entMgr.SpawnEntity(Prototype.Result, Transform.GridPosition);
ent.GetComponent <ITransformComponent>().LocalRotation = Transform.LocalRotation;
Owner.Delete();
return(true);
}
stage = Prototype.Stages[Stage];
if (stage.Icon != null)
{
Sprite.LayerSetSprite(0, stage.Icon);
}
}
else if (TryProcessStep(stage.Backward, eventArgs.AttackWith))
{
Stage--;
if (Stage == 0)
{
// Deconstruction complete.
Owner.Delete();
return(true);
}
stage = Prototype.Stages[Stage];
if (stage.Icon != null)
{
Sprite.LayerSetSprite(0, stage.Icon);
}
}
return(true);
}
bool IAttackBy.AttackBy(AttackByEventArgs eventArgs)
{
var result = TryInsertItem(eventArgs.AttackWith);
if (!result)
{
var localizationManager = IoCManager.Resolve <ILocalizationManager>();
eventArgs.User.PopupMessage(Owner, localizationManager.GetString("Unable to insert capacitor"));
}
return(result);
}
public bool AttackBy(AttackByEventArgs eventArgs)
{
var itemEntity = eventArgs.User.GetComponent <HandsComponent>().GetActiveHand.Owner;
if (itemEntity.TryGetComponent <PourableComponent>(out var attackPourable))
{
//Get target and check if it can be poured into
if (!Owner.TryGetComponent <SolutionComponent>(out var mySolution) ||
!mySolution.CanPourIn)
{
return(false);
}
if (!itemEntity.TryGetComponent <SolutionComponent>(out var attackSolution) ||
!attackSolution.CanPourOut)
{
return(false);
}
//Get transfer amount. May be smaller than _transferAmount if not enough room
var realTransferAmount = ReagentUnit.Min(attackPourable.TransferAmount, mySolution.EmptyVolume);
if (realTransferAmount <= 0) //Special message if container is full
{
_notifyManager.PopupMessage(Owner.Transform.GridPosition, eventArgs.User,
Loc.GetString("Container is full"));
return(false);
}
//Move units from attackSolution to targetSolution
var removedSolution = attackSolution.SplitSolution(realTransferAmount);
if (!mySolution.TryAddSolution(removedSolution))
{
return(false);
}
_notifyManager.PopupMessage(Owner.Transform.GridPosition, eventArgs.User,
Loc.GetString("Transferred {0}u", removedSolution.TotalVolume));
return(true);
}
if (!itemEntity.TryGetComponent(typeof(FoodComponent), out var food))
{
return(false);
}
var ent = food.Owner; //Get the entity of the ItemComponent.
_storage.Insert(ent);
UpdateUserInterface();
return(true);
}
public bool AttackBy(AttackByEventArgs eventArgs)
{
if (!eventArgs.AttackWith.TryGetComponent(out PowerStorageComponent component))
{
return(false);
}
if (capacitorComponent.Full)
{
Owner.PopupMessage(eventArgs.User, "Capacitor at max charge");
return(false);
}
capacitorComponent.FillFrom(component);
return(true);
}
public bool AttackBy(AttackByEventArgs eventArgs)
{
if (!eventArgs.AttackWith.HasComponent <WriteComponent>())
{
return(false);
}
if (!eventArgs.User.TryGetComponent(out IActorComponent actor))
{
return(false);
}
_mode = PaperAction.Write;
UpdateUserInterface();
_userInterface.Open(actor.playerSession);
return(true);
}
public bool AttackBy(AttackByEventArgs eventArgs)
{
if (eventArgs.AttackWith.TryGetComponent(out WirecutterComponent wirecutter))
{
Owner.Delete();
var droppedEnt = Owner.EntityManager.SpawnEntity("CableStack", eventArgs.ClickLocation);
if (droppedEnt.TryGetComponent <StackComponent>(out var stackComp))
{
stackComp.Count = 1;
}
return(true);
}
return(false);
}
bool IAttackBy.AttackBy(AttackByEventArgs eventArgs)
{
if (!eventArgs.AttackWith.HasComponent <PowerCellComponent>())
{
return(false);
}
if (Cell != null)
{
return(false);
}
eventArgs.User.GetComponent <IHandsComponent>().Drop(eventArgs.AttackWith, _cellContainer);
return(_cellContainer.Insert(eventArgs.AttackWith));
}
public bool AttackBy(AttackByEventArgs eventArgs)
{
if (!eventArgs.AttackWith.HasComponent <WrenchComponent>())
{
return(false);
}
if (!Owner.TryGetComponent(out PhysicsComponent physics))
{
return(false);
}
physics.Anchored = !physics.Anchored;
_audioSystem.Play("/Audio/items/ratchet.ogg", Owner);
return(true);
}
public bool AttackBy(AttackByEventArgs eventArgs)
{
if (!eventArgs.AttackWith.TryGetComponent(out BallisticMagazineComponent component))
{
return(false);
}
if (Magazine != null)
{
Owner.PopupMessage(eventArgs.User, "Already got a magazine.");
return(false);
}
if (!MagazineTypes.Contains(component.MagazineType))
{
Owner.PopupMessage(eventArgs.User, "Magazine doesn't fit.");
return(false);
}
return(InsertMagazine(eventArgs.AttackWith));
}
bool IAttackBy.AttackBy(AttackByEventArgs eventArgs)
{
if (!Owner.TryGetComponent(out MaterialStorageComponent storage) ||
!eventArgs.AttackWith.TryGetComponent(out MaterialComponent material))
{
return(false);
}
var multiplier = 1;
if (eventArgs.AttackWith.TryGetComponent(out StackComponent stack))
{
multiplier = stack.Count;
}
var totalAmount = 0;
// Check if it can insert all materials.
foreach (var mat in material.MaterialTypes.Values)
{
// TODO: Change how MaterialComponent works so this is not hard-coded.
if (!storage.CanInsertMaterial(mat.ID, VolumePerSheet * multiplier))
{
return(false);
}
totalAmount += VolumePerSheet * multiplier;
}
// Check if it can take ALL of the material's volume.
if (storage.CanTakeAmount(totalAmount))
{
return(false);
}
foreach (var mat in material.MaterialTypes.Values)
{
storage.InsertMaterial(mat.ID, VolumePerSheet * multiplier);
}
eventArgs.AttackWith.Delete();
return(false);
}
public bool AttackBy(AttackByEventArgs eventArgs)
{
var stage = Prototype.Stages[Stage];
if (TryProcessStep(stage.Forward, eventArgs.AttackWith))
{
Stage++;
if (Stage == Prototype.Stages.Count - 1)
{
// Oh boy we get to finish construction!
var entMgr = IoCManager.Resolve <IServerEntityManager>();
var ent = entMgr.SpawnEntity(Prototype.Result, Transform.GridPosition);
ent.GetComponent <ITransformComponent>().LocalRotation = Transform.LocalRotation;
Owner.Delete();
return(true);
}
stage = Prototype.Stages[Stage];
if (stage.Icon != null)
{
Sprite.LayerSetSprite(0, stage.Icon);
}
}
else if (TryProcessStep(stage.Backward, eventArgs.AttackWith))
{
Stage--;
if (Stage == 0)
{
// Deconstruction complete.
Owner.Delete();
return(true);
}
stage = Prototype.Stages[Stage];
if (stage.Icon != null)
{
Sprite.LayerSetSprite(0, stage.Icon);
}
}
return(true);
}
bool IAttackBy.AttackBy(AttackByEventArgs eventArgs)
{
var item = eventArgs.AttackWith;
if (!item.TryGetComponent(out MeleeWeaponComponent meleeWeaponComponent))
{
return(false);
}
Owner.GetComponent <DamageableComponent>().TakeDamage(DamageType.Brute, meleeWeaponComponent.Damage, item, eventArgs.User);
if (!item.TryGetComponent(out PickaxeComponent pickaxeComponent))
{
return(true);
}
if (!string.IsNullOrWhiteSpace(pickaxeComponent.MiningSound) &&
item.TryGetComponent <SoundComponent>(out var soundComponent))
{
soundComponent.Play(pickaxeComponent.MiningSound, AudioParams.Default);
}
return(true);
}
/// <summary>
/// Called when you click the owner entity with something in your active hand. If the entity in your hand
/// contains a <see cref="SolutionComponent"/>, if you have hands, and if the dispenser doesn't already
/// hold a container, it will be added to the dispenser.
/// </summary>
/// <param name="args">Data relevant to the event such as the actor which triggered it.</param>
/// <returns></returns>
bool IAttackBy.AttackBy(AttackByEventArgs args)
{
if (!args.User.TryGetComponent(out IHandsComponent hands))
{
_notifyManager.PopupMessage(Owner.Transform.GridPosition, args.User,
_localizationManager.GetString("You have no hands."));
return(true);
}
var activeHandEntity = hands.GetActiveHand.Owner;
if (activeHandEntity.TryGetComponent <SolutionComponent>(out var solution))
{
if (HasBeaker)
{
_notifyManager.PopupMessage(Owner.Transform.GridPosition, args.User,
_localizationManager.GetString("This dispenser already has a container in it."));
}
else if ((solution.Capabilities & SolutionCaps.FitsInDispenser) == 0)
{
//If it can't fit in the dispenser, don't put it in. For example, buckets and mop buckets can't fit.
_notifyManager.PopupMessage(Owner.Transform.GridPosition, args.User,
_localizationManager.GetString("That can't fit in the dispenser."));
}
else
{
_beakerContainer.Insert(activeHandEntity);
Solution.SolutionChanged += HandleSolutionChangedEvent;
UpdateUserInterface();
}
}
else
{
_notifyManager.PopupMessage(Owner.Transform.GridPosition, args.User,
_localizationManager.GetString("You can't put this in the dispenser."));
}
return(true);
}
bool IAttackBy.AttackBy(AttackByEventArgs eventArgs)
{
var ammoMagTransfer = CanTransferFrom(eventArgs.AttackWith);
if (ammoMagTransfer.Result)
{
IEntity bullet;
if (eventArgs.AttackWith.TryGetComponent(out BallisticMagazineComponent magazineComponent))
{
int fillCount = Math.Min(magazineComponent.CountLoaded, Capacity - CountLoaded);
for (int i = 0; i < fillCount; i++)
{
bullet = magazineComponent.TakeBullet();
AddBullet(bullet);
}
eventArgs.User.PopupMessage(eventArgs.User, $"Transferred {fillCount} rounds");
return(true);
}
if (eventArgs.AttackWith.TryGetComponent(out AmmoBoxComponent boxComponent))
{
int fillCount = Math.Min(boxComponent.CountLeft, Capacity - CountLoaded);
for (int i = 0; i < fillCount; i++)
{
bullet = boxComponent.TakeBullet();
AddBullet(bullet);
}
eventArgs.User.PopupMessage(eventArgs.User, $"Transferred {fillCount} rounds");
return(true);
}
}
else
{
eventArgs.User.PopupMessage(eventArgs.User, ammoMagTransfer.Message);
}
return(false);
}
public bool AttackBy(AttackByEventArgs eventArgs)
{
return(InsertBulb(eventArgs.AttackWith));
}
