public void ChangeAmmoMagazine(MyDefinitionId newAmmoMagazineId)
{
MyDebug.AssertDebug(WeaponDefinition.IsAmmoMagazineCompatible(newAmmoMagazineId), "Ammo magazine is changed to not compatible one");
AmmoMagazineId = newAmmoMagazineId;
m_ammoMagazineDefinition = MyDefinitionManager.Static.GetAmmoMagazineDefinition(AmmoMagazineId);
AmmoDefinitionId = AmmoMagazineDefinition.AmmoDefinitionId;
m_ammoDefinition = MyDefinitionManager.Static.GetAmmoDefinition(AmmoDefinitionId);
}
private Ammo(MyAmmoMagazineDefinition ammoMagDef)
{
MyAmmoDefinition ammoDef = MyDefinitionManager.Static.GetAmmoDefinition(ammoMagDef.AmmoDefinitionId);
this.AmmoDefinition = ammoDef;
this.MissileDefinition = AmmoDefinition as MyMissileAmmoDefinition;
this.MagazineDefinition = ammoMagDef;
if (MissileDefinition != null && !MissileDefinition.MissileSkipAcceleration)
{
this.TimeToMaxSpeed = (MissileDefinition.DesiredSpeed - MissileDefinition.MissileInitialSpeed) / MissileDefinition.MissileAcceleration;
this.DistanceToMaxSpeed = (MissileDefinition.DesiredSpeed + MissileDefinition.MissileInitialSpeed) / 2 * TimeToMaxSpeed;
}
else
{
this.TimeToMaxSpeed = 0;
this.DistanceToMaxSpeed = 0;
}
Description = AmmoDescription.CreateFrom(AmmoDefinition);
if (Description == null)
{
return;
}
if (Description.ClusterCooldown > 0f)
{
Log.DebugLog("Is a cluster missile");
IsCluster = true;
}
if (!string.IsNullOrWhiteSpace(Description.Radar))
{
try
{
RadarDefinition = new RadarEquipment.Definition();
XML_Amendments <RadarEquipment.Definition> ammender = new XML_Amendments <RadarEquipment.Definition>(RadarDefinition);
ammender.primarySeparator = new char[] { ',' };
ammender.AmendAll(Description.Radar, true);
RadarDefinition = ammender.Deserialize();
Log.DebugLog("Loaded description for radar", Logger.severity.DEBUG);
}
catch (Exception ex)
{
Logger.DebugNotify("Failed to load radar description for an ammo", 10000, Logger.severity.ERROR);
Log.AlwaysLog("Failed to load radar description for an ammo", Logger.severity.ERROR);
Log.AlwaysLog("Exception: " + ex, Logger.severity.ERROR);
RadarDefinition = null;
}
}
}
public InventoryItemDialog()
{
//Populate the static list with the ids from the items
if (_idList == null)
{
_idList = new List <MyDefinitionId>();
DictionaryValuesReader <MyDefinitionId, MyDefinitionBase> allDefinitions = MyDefinitionManager.Static.GetAllDefinitions();
foreach (MyDefinitionBase definition in allDefinitions)
{
MyPhysicalItemDefinition def = definition as MyPhysicalItemDefinition;
if (def != null)
{
_idList.Add(def.Id);
}
}
foreach (MyDefinitionBase definition in allDefinitions)
{
MyComponentDefinition def = definition as MyComponentDefinition;
if (def != null)
{
_idList.Add(def.Id);
}
}
foreach (MyDefinitionBase definition in allDefinitions)
{
MyAmmoMagazineDefinition def = definition as MyAmmoMagazineDefinition;
if (def != null)
{
_idList.Add(def.Id);
}
}
}
InitializeComponent();
CMB_ItemType.BeginUpdate();
foreach (var entry in _idList)
{
CMB_ItemType.Items.Add(entry);
}
CMB_ItemType.EndUpdate();
TXT_ItemAmount.Text = "0.0";
}
private static void ProcessSmallMissileLauncherReload(MyObjectBuilder_CubeBlock block, Options options, MyCubeSize size)
{ // Has it's own inventory, supporting function to add inventory doesn't work on this block
if (!options.Restock)
{
return;
}
try
{
List <MyDefinitionId> ammoSubTypeIds = GetItemDefinitionList(block);
if (ammoSubTypeIds == null || ammoSubTypeIds.Count == 0)
{
return;
}
((MyObjectBuilder_SmallMissileLauncherReload)block).Inventory.Clear();
MyDefinitionId ammoSubType = ammoSubTypeIds[Core.Random.Next(0, ammoSubTypeIds.Count)];
MyAmmoMagazineDefinition myAmmo = MyDefinitionManager.Static.GetAmmoMagazineDefinition(ammoSubType);
((MyObjectBuilder_SmallMissileLauncherReload)block).Inventory.Items.Add(new MyObjectBuilder_InventoryItem
{
Amount = GetAmount(GetMaxVolume(block, size), myAmmo.Volume),
PhysicalContent = new MyObjectBuilder_AmmoMagazine()
{
SubtypeName = ammoSubType.SubtypeName
}
});
//foreach (MyDefinitionId ammoSubType in ammoSubTypeIds)
//{
// MyAmmoMagazineDefinition myAmmo = MyDefinitionManager.Static.GetAmmoMagazineDefinition(ammoSubType);
// int amountToAdd = (int)(GetMaxVolume(block, size) / myAmmo.Volume) / ammoSubTypeIds.Count;
// Core.GeneralLog.WriteToLog("ProcessSmallMissileLauncherReload", $"Adding to inventory:\t{ammoSubType.SubtypeName}: {amountToAdd}");
// ((MyObjectBuilder_SmallMissileLauncherReload)block).Inventory.Items.Add(new MyObjectBuilder_InventoryItem
// {
// Amount = amountToAdd,
// PhysicalContent = new MyObjectBuilder_AmmoMagazine() { SubtypeName = ammoSubType.SubtypeName }
// });
//}
}
catch (Exception e)
{
Core.GeneralLog.WriteToLog("ProcessWeaponRestocking", $"Exception! {e}");
}
}
public static Ammo GetAmmo(MyDefinitionId magazineId)
{
Ammo value;
if (KnownDefinitions_Ammo.TryGetValue(magazineId, out value))
{
return(value);
}
MyAmmoMagazineDefinition magDef = MyDefinitionManager.Static.GetAmmoMagazineDefinition(magazineId);
if (magDef == null)
{
throw new InvalidOperationException("not a magazine: " + magazineId);
}
value = new Ammo(magDef);
KnownDefinitions_Ammo.Add(magazineId, value);
return(value);
}
public virtual void RefreshAmmoDetails()
{
var timeSpan = MyAPIGateway.Session.GameDateTime - _lastAmmoRefresh;
if (timeSpan.TotalMilliseconds < 500)
{
return;
}
_lastAmmoRefresh = MyAPIGateway.Session.GameDateTime;
if (_gunBase?.GunBase == null)
{
_maxAmmoTrajectory = 0;
_maxAmmoSpeed = 0;
return;
}
_ammoMagazineDefinition = _gunBase.GunBase.CurrentAmmoMagazineDefinition;
_ammoDefinition = _gunBase.GunBase.CurrentAmmoDefinition;
if (_ammoDefinition != null)
{
_maxAmmoTrajectory = _ammoDefinition.MaxTrajectory;
_maxAmmoSpeed = _ammoDefinition.DesiredSpeed;
}
if (_ammoMagazineDefinition != null)
{
_currentAmmoCount = _gunBase.GunBase.CurrentAmmo + (_ammoMagazineDefinition.Capacity * CountItemsInInventory(_ammoMagazineDefinition.Id));
}
if (_currentAmmoCount == 0 && _weaponSystem.UseAmmoReplenish)
{
if (_ammoMagazinesReloads < _weaponSystem.MaxAmmoReplenishments || _weaponSystem.MaxAmmoReplenishments == -1)
{
_ammoMagazinesReloads++;
_ammoReloadPending = true;
}
}
}
private static void ProcessWeaponRestocking(MyObjectBuilder_CubeBlock block, Options options, MyCubeSize size)
{
try
{
List <MyDefinitionId> ammoSubTypeIds = GetItemDefinitionList(block);
if (ammoSubTypeIds == null || ammoSubTypeIds.Count == 0)
{
return;
}
ClearInventory(block.ComponentContainer);
MyDefinitionId ammoSubType = ammoSubTypeIds[Core.Random.Next(0, ammoSubTypeIds.Count)];
MyAmmoMagazineDefinition myAmmo = MyDefinitionManager.Static.GetAmmoMagazineDefinition(ammoSubType);
int amountToAdd = GetAmount(GetMaxVolume(block, size), myAmmo.Volume);
if (options.MaxAmmo != 0 && amountToAdd > options.MaxAmmo)
{
amountToAdd = options.MaxAmmo;
}
AddToInventory(block.ComponentContainer, new MyObjectBuilder_AmmoMagazine()
{
SubtypeName = ammoSubType.SubtypeName
}, amountToAdd, false);
//foreach (MyDefinitionId ammoSubType in ammoSubTypeIds)
//{
// MyAmmoMagazineDefinition myAmmo = MyDefinitionManager.Static.GetAmmoMagazineDefinition(ammoSubType);
// //int amountToAdd = (int)Math.Ceiling((GetMaxVolume(block, size) / myAmmo.Volume) / ammoSubTypeIds.Count);
// int amountToAdd = GetAmount(GetMaxVolume(block, size), myAmmo.Volume, ammoSubTypeIds.Count);
// Core.GeneralLog.WriteToLog("ProcessWeaponRestocking", $"Adding to inventory:\t{ammoSubType.SubtypeName}: {amountToAdd}");
// AddToInventory(block.ComponentContainer, new MyObjectBuilder_AmmoMagazine() {SubtypeName = ammoSubType.SubtypeName}, amountToAdd, false);
//}
}
catch (Exception e)
{
Core.GeneralLog.WriteToLog("ProcessWeaponRestocking", $"Exception! {e}");
}
}
private void Init(IMyEntity Entity)
{
try
{
m_entity = Entity;
m_entityId = Entity.EntityId;
Entity.NeedsUpdate |= MyEntityUpdateEnum.EACH_100TH_FRAME;
m_functionalBlock = Entity as IMyFunctionalBlock;
m_cubeBlock = Entity as IMyCubeBlock;
m_myCubeBlock = Entity as MyCubeBlock;
CubeGrid = m_myCubeBlock.CubeGrid;
_cubeGridEntityId = CubeGrid.EntityId;
m_terminalBlock = Entity as IMyTerminalBlock;
m_gunObject = m_cubeBlock as IMyGunObject <MyGunBase>;
MyWeaponBlockDefinition weaponBlockDef = null; Debug.Write($"def == null ? {weaponBlockDef == null}", 1, debug);
MyDefinitionManager.Static.TryGetDefinition <MyWeaponBlockDefinition>(new SerializableDefinitionId(m_functionalBlock.BlockDefinition.TypeId, m_functionalBlock.BlockDefinition.SubtypeId), out weaponBlockDef);
m_weaponDef = MyDefinitionManager.Static.GetWeaponDefinition(weaponBlockDef.WeaponDefinitionId); Debug.Write($"weaponDef == null ? {m_weaponDef == null}", 1, debug);
Debug.Write($"Attempting to get magDefId from {m_weaponDef.AmmoMagazinesId[0]} ...", 1, debug);
m_magDefId = m_weaponDef.AmmoMagazinesId[0]; Debug.Write($"Complete. magDefId == null ? {m_magDefId == null}", 1, debug);
m_magDef = MyDefinitionManager.Static.GetAmmoMagazineDefinition(m_magDefId); Debug.Write($"m_magDef == null ? {m_magDef == null}", 1, debug);
Debug.Write($"m_weaponDef.WeaponAmmoDatas == null ? {m_weaponDef.WeaponAmmoDatas == null}", 1, debug);
Debug.Write($"m_weaponDef.WeaponAmmoDatas.Count == {m_weaponDef.WeaponAmmoDatas.Count()}", 1, debug);
MyWeaponDefinition.MyWeaponAmmoData data = null;
var i = -1;
while (i < m_weaponDef.WeaponAmmoDatas.Count() - 1)
{
i++;
Debug.Write($"m_weaponDef.WeaponAmmoDatas[{i}] == null ? {m_weaponDef.WeaponAmmoDatas[i] == null }", 1, debug);
if (m_weaponDef.WeaponAmmoDatas[i] == null)
{
continue;
}
data = m_weaponDef.WeaponAmmoDatas[i];
break;
}
m_timeoutMult = 60f / data.RateOfFire;
m_chargeDefinitionId = m_magDefId;
Debug.Write($"Attempting to get ammoDef from {m_magDef.AmmoDefinitionId} ...", 1, debug);
var ammoDef = MyDefinitionManager.Static.GetAmmoDefinition(m_magDef.AmmoDefinitionId);
Debug.Write($"Complete. ammoDef == null ? {ammoDef == null}", 1, debug);
var damagePerShot = ammoDef.GetDamageForMechanicalObjects();
Debug.Write($"Damage per shot = {damagePerShot}", 1, debug);
m_heatPerShot = (damagePerShot + ammoDef.MaxTrajectory + ammoDef.DesiredSpeed) * 0.01f;
m_heatMax = m_cubeBlock.SlimBlock.MaxIntegrity;
Debug.Write($"m_heatMax/m_heatPerShot = {m_heatMax}/{m_heatPerShot} = {m_heatMax / m_heatPerShot} shots", 1, debug);
m_operationalPower = m_heatPerShot * 0.01f;
m_maxAmmo = (int)(m_heatMax / m_heatPerShot);
m_inventory = ((Sandbox.ModAPI.Ingame.IMyTerminalBlock)(Entity)).GetInventory(0) as IMyInventory;
m_resourceSink = Entity.Components.Get <MyResourceSinkComponent>();
if (!LogicCore.Instance.BeamLogics.ContainsKey(Entity.EntityId))
{
LogicCore.Instance.BeamLogics.Add(Entity.EntityId, this);
Debug.Write("Added new beamlogic to BeamLogics dictionary.", 1, debug);
}
MyAPIGateway.Utilities.InvokeOnGameThread(() => RemoveSmokeEffects());
m_terminalBlock.AppendingCustomInfo += AppendCustomInfo;
m_initialized = true;
Debug.Write("Weapon initialization complete.", 1, debug);
}
catch (Exception e)
{
Debug.HandleException(e);
MyAPIGateway.Parallel.Sleep(1000);
Init(Entity);
}
}
public AmmoConstants(WeaponAmmoTypes ammo, WeaponDefinition wDef, Session session, WeaponSystem system)
{
MyInventory.GetItemVolumeAndMass(ammo.AmmoDefinitionId, out MagMass, out MagVolume);
MagazineDef = MyDefinitionManager.Static.GetAmmoMagazineDefinition(ammo.AmmoDefinitionId);
TracerMaterial = MyStringId.GetOrCompute(ammo.AmmoDef.AmmoGraphics.Lines.TracerMaterial);
TrailMaterial = MyStringId.GetOrCompute(ammo.AmmoDef.AmmoGraphics.Lines.Trail.Material);
if (ammo.AmmoDefinitionId.SubtypeId.String != "Energy" || ammo.AmmoDefinitionId.SubtypeId.String == string.Empty)
{
AmmoItem = new MyPhysicalInventoryItem()
{
Amount = 1, Content = MyObjectBuilderSerializer.CreateNewObject <MyObjectBuilder_AmmoMagazine>(ammo.AmmoDefinitionId.SubtypeName)
}
}
;
for (int i = 0; i < wDef.Ammos.Length; i++)
{
var ammoType = wDef.Ammos[i];
if (ammoType.AmmoRound.Equals(ammo.AmmoDef.Shrapnel.AmmoRound))
{
ShrapnelId = i;
}
}
IsMine = ammo.AmmoDef.Trajectory.Guidance == DetectFixed || ammo.AmmoDef.Trajectory.Guidance == DetectSmart || ammo.AmmoDef.Trajectory.Guidance == DetectTravelTo;
IsField = ammo.AmmoDef.Trajectory.FieldTime > 0;
IsHybrid = ammo.AmmoDef.HybridRound;
IsTurretSelectable = !ammo.IsShrapnel || ammo.AmmoDef.HardPointUsable;
AmmoParticle = ammo.AmmoDef.AmmoGraphics.Particles.Ammo.Name != string.Empty;
AmmoParticleShrinks = ammo.AmmoDef.AmmoGraphics.Particles.Ammo.ShrinkByDistance;
HitParticleShrinks = ammo.AmmoDef.AmmoGraphics.Particles.Hit.ShrinkByDistance;
HitParticle = ammo.AmmoDef.AmmoGraphics.Particles.Hit.Name != string.Empty;
DrawLine = ammo.AmmoDef.AmmoGraphics.Lines.Tracer.Enable;
LineColorVariance = ammo.AmmoDef.AmmoGraphics.Lines.ColorVariance.Start > 0 && ammo.AmmoDef.AmmoGraphics.Lines.ColorVariance.End > 0;
LineWidthVariance = ammo.AmmoDef.AmmoGraphics.Lines.WidthVariance.Start > 0 || ammo.AmmoDef.AmmoGraphics.Lines.WidthVariance.End > 0;
SpeedVariance = ammo.AmmoDef.Trajectory.SpeedVariance.Start > 0 || ammo.AmmoDef.Trajectory.SpeedVariance.End > 0;
RangeVariance = ammo.AmmoDef.Trajectory.RangeVariance.Start > 0 || ammo.AmmoDef.Trajectory.RangeVariance.End > 0;
TrailWidth = ammo.AmmoDef.AmmoGraphics.Lines.Trail.CustomWidth > 0 ? ammo.AmmoDef.AmmoGraphics.Lines.Trail.CustomWidth : ammo.AmmoDef.AmmoGraphics.Lines.Tracer.Width;
TargetOffSet = ammo.AmmoDef.Trajectory.Smarts.Inaccuracy > 0;
TargetLossTime = ammo.AmmoDef.Trajectory.TargetLossTime > 0 ? ammo.AmmoDef.Trajectory.TargetLossTime : int.MaxValue;
CanZombie = TargetLossTime > 0 && TargetLossTime != int.MaxValue && !IsMine;
MaxLifeTime = ammo.AmmoDef.Trajectory.MaxLifeTime > 0 ? ammo.AmmoDef.Trajectory.MaxLifeTime : int.MaxValue;
MaxChaseTime = ammo.AmmoDef.Trajectory.Smarts.MaxChaseTime > 0 ? ammo.AmmoDef.Trajectory.Smarts.MaxChaseTime : int.MaxValue;
MaxObjectsHit = ammo.AmmoDef.ObjectsHit.MaxObjectsHit > 0 ? ammo.AmmoDef.ObjectsHit.MaxObjectsHit : int.MaxValue;
BaseDamage = ammo.AmmoDef.BaseDamage;
MaxTargets = ammo.AmmoDef.Trajectory.Smarts.MaxTargets;
TargetLossDegree = ammo.AmmoDef.Trajectory.TargetLossDegree > 0 ? (float)Math.Cos(MathHelper.ToRadians(ammo.AmmoDef.Trajectory.TargetLossDegree)) : 0;
ShieldModifier = ammo.AmmoDef.DamageScales.Shields.Modifier > 0 ? ammo.AmmoDef.DamageScales.Shields.Modifier : 1;
ShieldBypassMod = ammo.AmmoDef.DamageScales.Shields.BypassModifier > 0 && ammo.AmmoDef.DamageScales.Shields.BypassModifier < 1 ? ammo.AmmoDef.DamageScales.Shields.BypassModifier : 1;
AmmoSkipAccel = ammo.AmmoDef.Trajectory.AccelPerSec <= 0;
FeelsGravity = ammo.AmmoDef.Trajectory.GravityMultiplier > 0;
MaxTrajectory = ammo.AmmoDef.Trajectory.MaxTrajectory;
MaxTrajectorySqr = MaxTrajectory * MaxTrajectory;
HasBackKickForce = ammo.AmmoDef.BackKickForce > 0;
MaxLateralThrust = MathHelperD.Clamp(ammo.AmmoDef.Trajectory.Smarts.MaxLateralThrust, 0.000001, 1);
Fields(ammo.AmmoDef, out PulseInterval, out PulseChance, out Pulse);
AreaEffects(ammo.AmmoDef, out AreaEffect, out AreaEffectDamage, out AreaEffectSize, out DetonationDamage, out AmmoAreaEffect, out AreaRadiusSmall, out AreaRadiusLarge, out DetonateRadiusSmall, out DetonateRadiusLarge, out Ewar, out EwarEffect, out EwarTriggerRange);
DamageScales(ammo.AmmoDef, out DamageScaling, out FallOffScaling, out ArmorScaling, out CustomDamageScales, out CustomBlockDefinitionBasesToScales, out SelfDamage, out VoxelDamage);
Beams(ammo.AmmoDef, out IsBeamWeapon, out VirtualBeams, out RotateRealBeam, out ConvergeBeams, out OneHitParticle, out OffsetEffect);
CollisionShape(ammo.AmmoDef, out CollisionIsLine, out CollisionSize, out TracerLength);
SmartsDelayDistSqr = (CollisionSize * ammo.AmmoDef.Trajectory.Smarts.TrackingDelay) * (CollisionSize * ammo.AmmoDef.Trajectory.Smarts.TrackingDelay);
PrimeEntityPool = Models(ammo.AmmoDef, wDef, out PrimeModel, out TriggerModel, out ModelPath);
Energy(ammo, system, wDef, out EnergyAmmo, out MustCharge, out Reloadable, out EnergyMagSize, out BurstMode, out HasShotReloadDelay);
Sound(ammo.AmmoDef, session, out HitSound, out AmmoTravelSound, out HitSoundDistSqr, out AmmoTravelSoundDistSqr, out AmmoSoundMaxDistSqr);
MagazineSize = EnergyAmmo ? EnergyMagSize : MagazineDef.Capacity;
GetPeakDps(ammo, system, wDef, out PeakDps, out ShotsPerSec, out BaseDps, out AreaDps, out DetDps);
DesiredProjectileSpeed = (float)(!IsBeamWeapon ? ammo.AmmoDef.Trajectory.DesiredSpeed : MaxTrajectory * MyEngineConstants.UPDATE_STEPS_PER_SECOND);
Trail = ammo.AmmoDef.AmmoGraphics.Lines.Trail.Enable;
}
public override void RefreshAmmoDetails()
{
var timeSpan = MyAPIGateway.Session.GameDateTime - _lastAmmoRefresh;
if (timeSpan.TotalMilliseconds < 500)
{
return;
}
_lastAmmoRefresh = MyAPIGateway.Session.GameDateTime;
var ammo = RAI_SessionCore.Instance.WeaponCore.GetActiveAmmo(_weaponBlock, _weaponIndex);
if (string.IsNullOrWhiteSpace(ammo) && _weaponCoreAmmoDefinition.AmmoMagazine != "Energy")
{
Logger.MsgDebug("Ammo Is Null", DebugTypeEnum.WeaponCore);
return;
}
if (ammo != _weaponCoreAmmoMagazineId || string.IsNullOrWhiteSpace(_weaponCoreAmmoMagazineId))
{
foreach (var ammoDef in _weaponCoreDefinition.Ammos)
{
if (ammoDef.AmmoMagazine == "Energy")
{
ammo = "Energy";
}
if (ammoDef.AmmoMagazine == ammo)
{
_weaponCoreAmmoMagazineId = ammo;
_weaponCoreAmmoDefinition = ammoDef;
break;
}
}
}
_weaponCurrentRange = _weaponCoreAmmoDefinition.Trajectory.MaxTrajectory;
_weaponRateOfFire = _weaponCoreDefinition.HardPoint.Loading.RateOfFire;
if (ammo == "Energy")
{
_currentAmmoCount = 1;
}
else
{
GetTypesOfAmmoInInventory();
var ammoId = new MyDefinitionId(typeof(MyObjectBuilder_AmmoMagazine), ammo);
if (_ammoSubtypesInInventory.Contains(ammo))
{
_currentAmmoCount = CountItemsInInventory(ammoId);
}
else
{
_currentAmmoCount = 0;
if (_weaponSystem.UseAmmoReplenish && _ammoMagazinesReloads < _weaponSystem.MaxAmmoReplenishments)
{
MyAmmoMagazineDefinition ammoMagDef = null;
if (Utilities.NormalAmmoMagReferences.TryGetValue(ammoId, out ammoMagDef))
{
_ammoMagazineDefinition = ammoMagDef;
_ammoReloadPending = true;
}
}
}
}
}
