public override bool AddItems(MyDefinitionId id, int amount, NewItemParams parameters = NewItemParams.None)
{
if (amount == 0)
{
return(false);
}
var item = MyInventoryItem.Create(id, amount);
return(item != null && Add(item, parameters));
}
protected override void Hit()
{
if (!MyAPIGateway.Session.IsServerDecider())
{
return;
}
var player = MyAPIGateway.Players.GetPlayerControllingEntity(Holder);
if (player == null)
{
return;
}
if (!HasPermission(MyPermissionsConstants.Mining))
{
player.ShowNotification("You don't have permission to terraform here.", 2000, null, new Vector4(1, 0, 0, 1));
return;
}
bool isExcavating = ActiveAction == MyHandItemActionEnum.Primary;
var radius = isExcavating ? Definition.ExcavateRadius : Definition.FillRadius;
uint availableForDeposit;
StringBuilder requiredMaterials = null;
if (isExcavating)
{
availableForDeposit = 0;
}
else
{
availableForDeposit = Definition.FillVolume;
var andHead = -1;
var missing = 0;
if (!player.IsCreative())
{
foreach (var item in Definition.FillMaterial.MinedItems)
{
var amount = 0;
foreach (var inv in Holder.Components.GetComponents <MyInventoryBase>())
{
amount += inv.GetItemAmountFuzzy(item.Key);
}
amount = amount * Definition.FillMaterial.Volume / item.Value;
if (amount == 0)
{
if (requiredMaterials == null)
{
requiredMaterials = new StringBuilder("You require ");
}
var itemDef = MyDefinitionManager.Get <MyInventoryItemDefinition>(item.Key);
andHead = requiredMaterials.Length;
missing++;
requiredMaterials.Append(itemDef?.DisplayNameOf() ?? item.Key.ToString()).Append(", ");
}
availableForDeposit = (uint)Math.Min(availableForDeposit, amount);
}
}
if (missing > 0 && requiredMaterials != null)
{
if (andHead != -1 && missing >= 2)
{
requiredMaterials.Insert(andHead, "and ");
}
requiredMaterials.Remove(requiredMaterials.Length - 2, 2);
}
}
var availableForExcavate = isExcavating ? Definition.ExcavateVolume : 0;
uint totalDeposited;
uint totalExcavated;
bool triedToChange;
bool intersectedDynamic;
var result = RailGraderSystem.DoGrading(_gradeComponents, Target.Position, radius, availableForDeposit,
availableForExcavate, _excavated, Definition.FillMaterial.Material.Index,
out totalDeposited, out totalExcavated, testDynamic: true,
triedToChange: out triedToChange, intersectedDynamic: out intersectedDynamic);
#region Give Items
var ranOutOfInventorySpace = false;
if (triedToChange && isExcavating && !player.IsCreative())
{
for (var i = 0; i < _excavated.Length; i++)
{
if (_excavated[i] == 0)
{
continue;
}
MyVoxelMiningDefinition.MiningEntry einfo;
if (Definition.ExcavateDefinition == null || !Definition.ExcavateDefinition.MiningEntries.TryGetValue(i, out einfo))
{
continue;
}
var outputInventory = Holder.GetInventory(MyCharacterConstants.MainInventory);
var count = (int)Math.Floor(_excavated[i] / (float)einfo.Volume);
if (count == 0)
{
continue;
}
_excavated[i] -= (uint)Math.Max(0, count * einfo.Volume);
foreach (var k in einfo.MinedItems)
{
var amount = k.Value * count;
if (outputInventory != null && outputInventory.AddItems(k.Key, amount))
{
continue;
}
ranOutOfInventorySpace = true;
var pos = MyAPIGateway.Entities.FindFreePlace(Target.Position, radius) ?? Target.Position;
MySession.Static.Components.Get <MyFloatingObjects>()
?.Spawn(MyInventoryItem.Create(k.Key, amount), MatrixD.CreateTranslation(pos), null);
}
}
}
if (ranOutOfInventorySpace)
{
player.ShowNotification("Inventory is full", color: new Vector4(1, 0, 0, 1));
}
#endregion
#region Take Items
_depositAccumulation += (int)totalDeposited;
if (!player.IsCreative())
{
if (_depositAccumulation > 0 && !isExcavating && Definition.FillMaterial.MinedItems != null)
{
int amnt = (int)Math.Floor(_depositAccumulation / (float)Definition.FillMaterial.Volume);
_depositAccumulation -= amnt * Definition.FillMaterial.Volume;
if (amnt > 0)
{
foreach (var k in Definition.FillMaterial.MinedItems)
{
var required = amnt * k.Value;
if (required == 0)
{
return;
}
foreach (var inv in Holder.Components.GetComponents <MyInventoryBase>())
{
var count = Math.Min(required, inv.GetItemAmountFuzzy(k.Key));
if (count > 0 && inv.RemoveItemsFuzzy(k.Key, count))
{
required -= count;
}
}
}
}
}
}
#endregion
if (totalDeposited > 0 || totalExcavated > 0)
{
var duraCost = (int)Math.Round(totalDeposited * Definition.FillDurabilityPerVol + totalExcavated * Definition.ExcavateDurabilityPerVol);
if (duraCost > 0)
{
UpdateDurability(-duraCost);
}
GraderUsed?.Invoke(this, _gradeComponents, totalDeposited, totalExcavated);
RailGraderSystem.RaiseDoGrade(_gradeComponents, Target.Position, radius, availableForDeposit, availableForExcavate,
Definition.FillMaterial.Material.Index, totalExcavated, totalDeposited);
return;
}
if (!isExcavating && intersectedDynamic && triedToChange)
{
player.ShowNotification("Cannot fill where there are players or dynamic grids", color: new Vector4(1, 0, 0, 1));
}
if (!isExcavating && requiredMaterials != null && triedToChange)
{
player.ShowNotification(requiredMaterials?.ToString(), color: new Vector4(1, 0, 0, 1));
}
}
