protected override List <ICommand> GetCommandsConsidered()
{
var commands = new List <ICommand>();
var checkNotEnoughAmount = new CheckNotEnoughAmount(InputData.DataInventory, InputData.Id, InputData.AmountWantRemove);
CausesCheckAndAdd.AddInCausesIfNecessary(checkNotEnoughAmount);
if (checkNotEnoughAmount.IsActual())
{
return(commands);
}
var entitiesWithId = DatabaseReadOnly.GetEntitiesWithId(InputData.DataInventory, InputData.Id);
var lostRemove = InputData.AmountWantRemove;
foreach (var dataEntity in entitiesWithId)
{
var amountInEntity = dataEntity.Amount;
var remove = Math.Min(lostRemove, amountInEntity);
var removeCommand = CreateCommand <RemoveCommand>().EnterData(new RemoveInputData(dataEntity, remove));
commands.Add(removeCommand);
lostRemove -= remove;
if (lostRemove == 0)
{
break;
}
}
return(commands);
}
public SwapPrimaryInputData([NotNull] DataEntity entityDisplacing, [NotNull] DataSlot slotNewPositionEntityDisplacing,
[NotNull] DataEntity entityTarget, [NotNull] DataSlot slotNewPositionEntityTarget) : base(entityDisplacing, slotNewPositionEntityDisplacing)
{
SlotNewPositionEntityTarget = slotNewPositionEntityTarget;
SlotOldPositionEntityDisplacing = DatabaseReadOnly.GetSlotOrNull(entityDisplacing);
EntityTarget = entityTarget;
}
public override IEnumerable <CauseFailureCommand> GetActualCauses()
{
var result = new List <CauseFailureCommand>();
var checkOutBorderFirst = new CheckOutBorder(First, SlotFirst);
var checkOutBorderSecond = new CheckOutBorder(Second, SlotSecond);
result.AddRange(checkOutBorderFirst.GetActualCauses());
result.AddRange(checkOutBorderSecond.GetActualCauses());
if (checkOutBorderFirst.IsActual() || checkOutBorderSecond.IsActual())
{
return(result);
}
var slotsNewPositionEntity = DatabaseReadOnly.GetSlotsForEntityInInventory(First, SlotFirst).ToArray();
var slotsNewPositionOtherEntity = DatabaseReadOnly.GetSlotsForEntityInInventory(Second, SlotSecond).ToArray();
var isIntersection = slotsNewPositionEntity.Intersect(slotsNewPositionOtherEntity).Any();
if (isIntersection)
{
result.Add(new CauseIntersectionOfPositions(First, SlotFirst, Second, SlotSecond));
}
return(result);
}
private void PutHandInSlotTryData([NotNull] DataSlot slotLeftTop)
{
if (slotLeftTop.DataInventory == null)
{
throw GetExceptionUnBindInventoryComponent();
}
var entitySource = HandData.EntitySource;
var amountWantPut = HandData.DataEntityHand.Amount;
HandData.ReturnAmountInSource();
var slotLeftTopPrevious = DatabaseReadOnly.GetSlotOrNull(entitySource);
if (slotLeftTopPrevious != slotLeftTop)
{
var command = Commands.CreateForHand <PutCommand>()
.EnterData(new PutInputData(entitySource, slotLeftTop, amountWantPut));
var success = command.ExecuteTry();
if (!success)
{
var noValidOnlyForFilters = FactoryCommandNoValidOnlyForFilters.Create(command);
// event
if (noValidOnlyForFilters.IsCommandNoValidOnlyForFilters)
{
NoValidFiltersEvent.Invoke(noValidOnlyForFilters.GetImpossibleOnlyForThisFilters());
}
}
}
HandData.Clear();
StatusWasChanged.Invoke();
}
public bool TakeEntityOnPositionInHandTry(DataSlot slot, Vector2 positionCreateHand)
{
if (slot == null)
{
throw new ArgumentNullException(nameof(slot));
}
var entitySource = DatabaseReadOnly.GetEntityOrNull(slot);
if (entitySource == null)
{
return(false);
}
if (Debug.DebugMode)
{
_point = Debug.PointForDebug.InstantiateOnRootCanvas().transform;
_point.SetAsLastSibling();
}
TakeEntityInHand(entitySource);
var entityComponent = _bindComponentToDataDbRead.GetEntityComponent(entitySource);
_handView = new HandView(entityComponent, HandData.DataEntityHand);
_handView.PositionSet(positionCreateHand);
return(true);
}
public override IEnumerable <CauseFailureCommand> GetActualCauses()
{
var result = new List <CauseFailureCommand>();
var checkOutBorder = new CheckOutBorder(Entity, Slot);
result.AddRange(checkOutBorder.GetActualCauses());
// cant get TargetSlots if IsOutBorder
if (checkOutBorder.IsActual())
{
return(result);
}
var targetSlots = DatabaseReadOnly.GetSlotsForEntityInInventory(Slot.DataInventory, Slot.Vector2Int, Entity).ToList();
var noValidEntities = DatabaseReadOnly.EntitiesInTargetSlotsWithoutExcluded(Entity, AmountWantPut, targetSlots,
ValidEntities).ToList();
if (noValidEntities.Count == 1)
{
var entity = noValidEntities.Single();
var cause = new CauseIsSingleNoValidEntityInSlots(entity, targetSlots);
result.Add(cause);
}
if (noValidEntities.Count > 1)
{
var cause = new CauseIsMoreOneNoValidEntityInSlots(noValidEntities, targetSlots);
result.Add(cause);
}
return(result);
}
private List <DataSlot> BusySlotsAdd(List <DataSlot> busySlots, DataEntity entity, DataSlot slot)
{
var slotsBusy = DatabaseReadOnly.GetSlotsForEntityInInventory(entity, slot);
busySlots.AddRange(slotsBusy);
return(busySlots);
}
public SwapInputData([NotNull] DataEntity entityDisplacing,
[NotNull] DataSlot slotNewPositionEntityDisplacing, [NotNull] DataEntity entityTarget, [CanBeNull] IComparer <DataSlot> comparer = null)
: base(entityDisplacing, slotNewPositionEntityDisplacing)
{
SlotOldPositionEntityDisplacing = DatabaseReadOnly.GetSlotOrNull(entityDisplacing);
EntityTarget = entityTarget;
Comparer = comparer ?? DatabaseReadOnly.ComparerSlotsDefault;
}
public override IEnumerable <CauseFailureCommand> GetActualCauses()
{
var result = new List <CauseFailureCommand>();
var isOutBorder = DatabaseReadOnly.IsOutBorderInventory(DataSlot.DataInventory, DataEntity, DataSlot.Vector2Int);
if (isOutBorder)
{
result.Add(new CauseIsOutBorder(DataEntity, DataSlot));
}
return(result);
}
public override IEnumerable <CauseFailureCommand> GetActualCauses()
{
var result = new List <CauseFailureCommand>();
var amountCanTake = DatabaseReadOnly.GetEntitiesWithId(InventoryFrom, IdEntity).Sum(entity => entity.Amount);
if (amountCanTake < AmountWantTake)
{
result.Add(new CauseNoRequiredAmountInSourceInventory(InventoryFrom, IdEntity, AmountWantTake, amountCanTake));
}
return(result);
}
public override IEnumerable <CauseFailureCommand> GetActualCauses()
{
var result = new List <CauseFailureCommand>();
var entitiesWithId = DatabaseReadOnly.GetEntitiesWithId(DataInventory, Id);
var sumInInventory = entitiesWithId.Sum(entity => entity.Amount);
if (sumInInventory < AmountWantRemove)
{
result.Add(new CauseNotEnoughAmount(DataInventory, Id, AmountWantRemove));
}
return(result);
}
public override IEnumerable <CauseFailureCommand> GetActualCauses()
{
var result = new List <CauseFailureCommand>();
var isEntitiesMayBeStack = DatabaseReadOnly.IsEntitiesMayBeStack(Source, Target);
if (!isEntitiesMayBeStack)
{
result.Add(new CauseEntitiesCannotStack(Source, Target));
}
return(result);
}
private IEnumerable <DataSlot> GetWishSlotsForSwap()
{
var entityDisplacing = InputData.EntitySource;
var entityTarget = InputData.EntityTarget;
var comparer = InputData.Comparer;
var displacingInventory = entityDisplacing.DataInventory;
var displacingEntityPreviousPosition =
DatabaseReadOnly.GetSlotsForEntityInInventory(displacingInventory,
DatabaseReadOnly.GetSlotOrNull(entityDisplacing).Vector2Int, entityDisplacing).ToArray();
var wishSlots = new List <DataSlot>();
if (displacingInventory.TypeInventory == DataInventory.TypeInventoryEnum.GridSupportMultislotEntity)
{
int widthEntityForWishSlots = entityTarget.Dimensions.x;
int heightEntityForWishSlots = entityTarget.Dimensions.y;
Vector2Int maxCoordinateWishSlots = new Vector2Int
{
x = displacingEntityPreviousPosition.Max(slot => slot.Vector2Int.x),
y = displacingEntityPreviousPosition.Max(slot => slot.Vector2Int.y)
};
Vector2Int minCoordinateWishSlots = new Vector2Int
{
x = displacingEntityPreviousPosition.Min(slot => slot.Vector2Int.x) -
widthEntityForWishSlots + 1,
y = displacingEntityPreviousPosition.Min(slot => slot.Vector2Int.y) -
heightEntityForWishSlots + 1
};
var wishSlotsPositions = Vector2IntExtension.GetArea(minCoordinateWishSlots, maxCoordinateWishSlots);
wishSlots = DatabaseReadOnly.GetSlots(displacingInventory, wishSlotsPositions).ToList();
}
else
{
wishSlots.Add(DatabaseReadOnly.GetSlotOrNull(entityDisplacing));
}
wishSlots = wishSlots.OrderBy(slot => slot, comparer).ToList();
return(wishSlots);
}
protected override List <ICommand> GetCommandsConsidered()
{
var resultList = new List <ICommand>();
var slotsFree = DatabaseReadOnly.SlotsFree(InputData.Inventory).ToArray();
var busySlots = new List <DataSlot>();
foreach (var entity in InputData.Entities)
{
foreach (var slot in slotsFree)
{
if (busySlots.Contains(slot))
{
continue;
}
var command = CreateCommand <CreateCommand>();
command.EnterData(new CreateInputData(entity, slot));
if (command.IsCanExecute)
{
var slotsBusy = DatabaseReadOnly.GetSlotsForEntityInInventory(entity, slot);
busySlots.AddRange(slotsBusy);
}
resultList.Add(command);
if (command.IsCanExecute)
{
break;
}
}
}
var checkNotFreeSlotsInventoryForCreateEntities = new CheckNotFreeSlotsInventoryForCreateEntities(InputData.Inventory, InputData.Entities
, resultList);
CausesCheckAndAdd.AddInCausesIfNecessary(checkNotFreeSlotsInventoryForCreateEntities);
return(resultList);
}
protected override List <ICommand> GetCommandsConsidered()
{
var idEntity = InputData.IdEntity;
var fromInventory = InputData.FromInventory;
var toInventory = InputData.ToInventory;
var amount = InputData.Amount;
var resultList = new List <ICommand>();
var checkNoRequiredAmountInSourceInventory = new CheckNoRequiredAmountInSourceInventory(fromInventory, idEntity, amount);
CausesCheckAndAdd.AddInCausesIfNecessary(checkNoRequiredAmountInSourceInventory);
if (checkNoRequiredAmountInSourceInventory.IsActual())
{
return(resultList);
}
var entitiesWithId = DatabaseReadOnly.GetEntitiesWithId(fromInventory, idEntity);
var totalLeftToPut = amount;
var slotsToInventory = DatabaseReadOnly.GetInventoryStructure(toInventory).Slots;
var busySlots = new List <DataSlot>();
foreach (var entityFrom in entitiesWithId)
{
var takeFromThisEntity = Math.Min(totalLeftToPut, entityFrom.Amount);
var leftToPutFromThisEntity = takeFromThisEntity;
foreach (var slot in slotsToInventory)
{
if (busySlots.Contains(slot))
{
continue;
}
var wasPut = 0;
// empty slots try
var moveCommand = (MoveCommand)CreateCommand <MoveCommand>().EnterData(new MoveInputData(entityFrom, slot, leftToPutFromThisEntity));
ICommand command = moveCommand;
if (moveCommand.IsCanExecute)
{
wasPut = moveCommand.InputData.AmountWantPut;
busySlots = BusySlotsAdd(busySlots, entityFrom, slot);
}
else
{
if (moveCommand.IsCanTryStackOrSwap)
{
// stack
var entityInSlot = moveCommand.CausesFailure.GetCauseFirstOrDefault <CauseIsSingleNoValidEntityInSlots>().Entity;
var stackCommand = CreateCommand <StackCommand>(FilterCollection);
stackCommand.EnterData(new StackInputData(entityFrom, entityInSlot, leftToPutFromThisEntity));
command = stackCommand;
if (stackCommand.IsCanExecute)
{
wasPut = stackCommand.InputData.AmountWantPut;
busySlots = BusySlotsAdd(busySlots, entityFrom, slot);
}
else
{
var isCanTryWithOtherAmount = stackCommand.IsCanTryWithOtherAmount();
if (isCanTryWithOtherAmount.sucess)
{
var amountCanPut = isCanTryWithOtherAmount.amountCanPut;
var stackCommandOtherAmount = stackCommand.EnterData(new StackInputData(entityFrom, entityInSlot, amountCanPut));
if (stackCommandOtherAmount.IsCanExecute)
{
wasPut = stackCommandOtherAmount.InputData.AmountWantPut;
busySlots = BusySlotsAdd(busySlots, entityFrom, slot);
command = stackCommandOtherAmount;
}
}
}
}
}
resultList.Add(command);
leftToPutFromThisEntity -= wasPut;
totalLeftToPut -= wasPut;
if (leftToPutFromThisEntity == 0)
{
break;
}
}
if (totalLeftToPut == 0)
{
break;
}
}
var checkTargetInventoryIsOverflow = new CheckTargetInventoryIsOverflow(InputData.ToInventory,
InputData.IdEntity, InputData.Amount, totalLeftToPut);
CausesCheckAndAdd.AddInCausesIfNecessary(checkTargetInventoryIsOverflow);
return(resultList);
}
private int GetSumCoins(DataInventory inventory) => DatabaseReadOnly.GetEntitiesWithId(inventory, InputData.IdCoins).Sum(data => data.Amount);
