void DisablePaintGunVanillaShoot()
{
// make the paintgun (which is a rifle) not be able to shoot normally, to avoid needing to add ammo back and skips that stupid hardcoded screen shake
MyWeaponDefinition weaponDef = MyDefinitionManager.Static.GetWeaponDefinition(new MyDefinitionId(typeof(MyObjectBuilder_WeaponDefinition), Constants.PAINTGUN_WEAPONID));
for (int i = 0; i < weaponDef.WeaponAmmoDatas.Length; i++)
{
MyWeaponDefinition.MyWeaponAmmoData ammoData = weaponDef.WeaponAmmoDatas[i];
if (ammoData != null)
{
ammoData.ShootIntervalInMiliseconds = int.MaxValue;
}
}
}
public override bool SwitchToNextAmmoMagazine()
{
MyWeaponDefinition weaponDefinition = WeaponProperties.WeaponDefinition;
int currentIndex = weaponDefinition.GetAmmoMagazineIdArrayIndex(CurrentAmmoMagazineId);
int ammoMagazinesCount = weaponDefinition.AmmoMagazinesId.Length;
currentIndex += 1;
if (currentIndex == ammoMagazinesCount)
{
currentIndex = 0;
}
return(SwitchAmmoMagazine(weaponDefinition.AmmoMagazinesId[currentIndex]));
}
public override bool SwitchAmmoMagazineToNextAvailable()
{
MyWeaponDefinition weaponDefinition = WeaponProperties.WeaponDefinition;
if (!weaponDefinition.HasAmmoMagazines())
{
return(false);
}
int currentIndex = weaponDefinition.GetAmmoMagazineIdArrayIndex(CurrentAmmoMagazineId);
int ammoMagazinesCount = weaponDefinition.AmmoMagazinesId.Length;
for (int i = currentIndex + 1, j = 0; j != ammoMagazinesCount; i++, j++)
{
if (i == ammoMagazinesCount)
{
i = 0; // reset counter to not overflow
}
if (weaponDefinition.AmmoMagazinesId[i].SubtypeId != CurrentAmmoMagazineId.SubtypeId)
{
if (MySession.Static.CreativeMode)
{
return(SwitchAmmoMagazine(weaponDefinition.AmmoMagazinesId[i]));
}
else
{
int remainingAmmo = 0;
if (m_remainingAmmos.TryGetValue(weaponDefinition.AmmoMagazinesId[i], out remainingAmmo))
{
if (remainingAmmo > 0)
{
return(SwitchAmmoMagazine(weaponDefinition.AmmoMagazinesId[i]));
}
}
if (m_user.AmmoInventory.GetItemAmount(weaponDefinition.AmmoMagazinesId[i]) > 0)
{
return(SwitchAmmoMagazine(weaponDefinition.AmmoMagazinesId[i]));
}
}
}
}
return(false);
}
public virtual void GetWeaponDefinition(IMyTerminalBlock weapon)
{
MyWeaponBlockDefinition weaponBlockDef;
if (!Utilities.WeaponBlockReferences.TryGetValue(weapon.SlimBlock.BlockDefinition.Id, out weaponBlockDef))
{
Logger.MsgDebug("No Weapon Definition Found For: " + weapon.SlimBlock.BlockDefinition.Id.ToString(), DebugTypeEnum.Weapon);
}
MyWeaponDefinition weaponDef;
if (!MyDefinitionManager.Static.TryGetWeaponDefinition(weaponBlockDef.WeaponDefinitionId, out weaponDef))
{
Logger.MsgDebug("Weapon Def Null", DebugTypeEnum.Weapon);
return;
}
_weaponDefinition = weaponDef;
}
public override void OnAddedToContainer()
{
base.OnAddedToContainer();
_weapon = WeaponShortcuts.GetWeaponDefinition(Entity);
if (_weapon != null && _weapon.HasAmmoMagazines())
{
_weaponAmmoMags = new MyObjectBuilder_PhysicalObject[_weapon.AmmoMagazinesId.Length];
for (var i = 0; i < _weaponAmmoMags.Length; i++)
{
_weaponAmmoMags[i] =
new MyObjectBuilder_AmmoMagazine()
{
SubtypeName = _weapon.AmmoMagazinesId[i].SubtypeName
}
}
;
}
NeedsUpdate = MyEntityUpdateEnum.EACH_10TH_FRAME;
}
private static List <MyDefinitionId> GetWeaponAmmoList(MyObjectBuilder_CubeBlock cube)
{
List <MyDefinitionId> ammoSubTypeIds = new List <MyDefinitionId>();
try
{
MyWeaponDefinition myWeapon = MyDefinitionManager.Static.GetWeaponDefinition(((MyWeaponBlockDefinition)
MyDefinitionManager.Static.GetCubeBlockDefinition(cube.GetId())).WeaponDefinitionId);
if (myWeapon == null)
{
return(ammoSubTypeIds);
}
ammoSubTypeIds.AddRange(myWeapon.AmmoMagazinesId);
}
catch (Exception e)
{
Core.GeneralLog.WriteToLog("GetWeaponAmmoList", $"Exception getting ammo list! {e}");
}
return(ammoSubTypeIds);
}
public virtual void Init(MyWeaponPropertiesWrapper weaponProperties, string modelName, bool spherePhysics = true, bool capsulePhysics = false, bool bulletType = false)
{
System.Diagnostics.Debug.Assert(MyEntityIdentifier.AllocationSuspended == false, "Allocation was not suspended in MyAmmoBase.Init(...)");
bool oldSuspend = MyEntityIdentifier.AllocationSuspended;
MyEntityIdentifier.AllocationSuspended = true;
base.Init(null, modelName, null, null, null);
m_weaponDefinition = weaponProperties.WeaponDefinition;
// Collision skin
if (spherePhysics)
{
this.InitSpherePhysics(MyMaterialType.AMMO, Model, 100,
MyPerGameSettings.DefaultLinearDamping,
MyPerGameSettings.DefaultAngularDamping, MyPhysics.AmmoLayer,
bulletType ? RigidBodyFlag.RBF_BULLET : RigidBodyFlag.RBF_DEFAULT);
}
if (capsulePhysics)
{
this.InitCapsulePhysics(MyMaterialType.AMMO, new Vector3(0, 0, -Model.BoundingBox.HalfExtents.Z * 0.8f),
new Vector3(0, 0, Model.BoundingBox.HalfExtents.Z * 0.8f), 0.1f, 10, 0, 0, MyPhysics.AmmoLayer,
bulletType ? RigidBodyFlag.RBF_BULLET : RigidBodyFlag.RBF_DEFAULT);
m_ammoOffsetSize = Model.BoundingBox.HalfExtents.Z * 0.8f + 0.1f;
}
else
{
this.InitBoxPhysics(MyMaterialType.AMMO, Model, 1,
MyPerGameSettings.DefaultAngularDamping, MyPhysics.AmmoLayer,
bulletType ? RigidBodyFlag.RBF_BULLET : RigidBodyFlag.RBF_DEFAULT);
}
NeedsUpdate = MyEntityUpdateEnum.EACH_FRAME;
Render.CastShadows = false;
Closed = true; //Because ammobase instance is going to pool. It is started by Start()
Physics.RigidBody.ContactPointCallbackEnabled = true;
Physics.ContactPointCallback += listener_ContactPointCallback;
MyEntityIdentifier.AllocationSuspended = oldSuspend;
}
public bool SwitchAmmoMagazineToFirstAvailable()
{
MyWeaponDefinition weaponDefinition = WeaponProperties.WeaponDefinition;
for (int i = 0; i < WeaponProperties.AmmoMagazinesCount; i++)
{
int remainingAmmo = 0;
if (m_remainingAmmos.TryGetValue(weaponDefinition.AmmoMagazinesId[i], out remainingAmmo))
{
if (remainingAmmo > 0)
{
return(SwitchAmmoMagazine(weaponDefinition.AmmoMagazinesId[i]));
}
}
if (m_user.AmmoInventory.GetItemAmount(weaponDefinition.AmmoMagazinesId[i]) > 0)
{
return(SwitchAmmoMagazine(weaponDefinition.AmmoMagazinesId[i]));
}
}
return(false);
}
private WeaponDefinitionExpanded(MyWeaponDefinition weaponDefn)
{
this.WeaponDefinition = weaponDefn;
for (int i = 0; i < weaponDefn.WeaponAmmoDatas.Length; i++)
{
if (weaponDefn.WeaponAmmoDatas[i] != null)
{
AmmoType = (MyAmmoType)i;
FirstAmmo = Ammo.GetAmmo(WeaponDefinition.AmmoMagazinesId[0]);
RequiredAccuracyRadians = FirstAmmo.Description != null ?
0.15f : // fire guided missile with less accuracy, despite slower RoF
0.02f + Math.Min(weaponDefn.WeaponAmmoDatas[i].RateOfFire, 1000) / 72000f;
RequiredAccuracyCos = (float)Math.Cos(RequiredAccuracyRadians);
return;
}
}
AmmoType = MyAmmoType.Unknown;
RequiredAccuracyCos = 2f;
}
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);
}
}
/// <summary>
/// This converts keens definitions into mostly identical copies that are used within the system.
/// </summary>
private static void LoadKeenDefinitions()
{
KeenAmmoDefinitions.Clear();
KeenWeaponDefinitions.Clear();
Type ammoType = typeof(AmmoDefinition);
Type weaponType = typeof(WeaponDefinition);
foreach (MyDefinitionBase def in MyDefinitionManager.Static.GetAllDefinitions())
{
try
{
if (def is MyAmmoMagazineDefinition)
{
MyAmmoDefinition ammo = MyDefinitionManager.Static.GetAmmoDefinition((def as MyAmmoMagazineDefinition).AmmoDefinitionId);
if (ammo.IsExplosive)
{
Tools.Info($"Skipping keen ammo definition: {ammo.Id}");
continue;
}
else
{
Tools.Info($"Loading keen ammo definition: {ammo.Id}");
}
AmmoDefinition a = AmmoDefinition.CreateFromKeenDefinition(ammo as MyProjectileAmmoDefinition);
KeenAmmoDefinitions.Add(a);
string filename = $"Ammo_{a.SubtypeId}";
if (Static.WriteDefaultDefinitionsToFile && !FileExistsInWorldStorage(filename, ammoType))
{
try
{
AmmoDefinition ca = a.Clone();
ca.Enabled = false;
TextWriter writer = MyAPIGateway.Utilities.WriteFileInWorldStorage(filename, ammoType);
writer.Write(MyAPIGateway.Utilities.SerializeToXML(ca));
writer.Close();
}
catch
{
Tools.Error($"Unable to write to file {a.SubtypeId}");
}
}
}
else if (def is MyWeaponBlockDefinition)
{
MyWeaponBlockDefinition block = def as MyWeaponBlockDefinition;
MyWeaponDefinition weaponDef = MyDefinitionManager.Static.GetWeaponDefinition(block.WeaponDefinitionId);
if (weaponDef.HasMissileAmmoDefined)
{
Tools.Info($"Skipping keen weapon definition: {block.WeaponDefinitionId}");
continue;
}
else
{
Tools.Info($"Loading keen weapon definition: {block.WeaponDefinitionId}");
}
// stop vanilla projectile from firing
// Thanks for the help Digi
for (int i = 0; i < weaponDef.WeaponAmmoDatas.Length; i++)
{
var ammoData = weaponDef.WeaponAmmoDatas[i];
if (ammoData == null)
{
continue;
}
ammoData.ShootIntervalInMiliseconds = int.MaxValue;
}
WeaponDefinition w = WeaponDefinition.CreateFromKeenDefinition(block, weaponDef);
KeenWeaponDefinitions.Add(w);
string filename = $"Weapon_{w.SubtypeId}";
if (Static.WriteDefaultDefinitionsToFile && !FileExistsInWorldStorage(filename, weaponType))
{
try
{
WeaponDefinition cw = w.Clone();
cw.Enabled = false;
TextWriter writer = MyAPIGateway.Utilities.WriteFileInWorldStorage(filename, weaponType);
writer.Write(MyAPIGateway.Utilities.SerializeToXML(cw));
writer.Close();
}
catch
{
Tools.Error($"Unable to write to file {w.SubtypeId}");
}
}
}
}
catch (Exception e)
{
Tools.Error($"Failed to load definition: {def.Id}\n{e}");
}
}
}
public MyWeaponPropertiesWrapper(MyDefinitionId weaponDefinitionId)
{
WeaponDefinitionId = weaponDefinitionId;
m_weaponDefinition = MyDefinitionManager.Static.GetWeaponDefinition(WeaponDefinitionId);
}
public static WeaponDefinition CreateFromKeenDefinition(MyWeaponBlockDefinition b, MyWeaponDefinition w)
{
if (b is MyLargeTurretBaseDefinition)
{
MyLargeTurretBaseDefinition lb = b as MyLargeTurretBaseDefinition;
return(new WeaponDefinition {
Enabled = true,
SubtypeId = w.Id.SubtypeId.String,
DeviateShotAngle = w.DeviateShotAngle,
ReloadTime = w.ReloadTime,
ReleaseTimeAfterFire = w.ReleaseTimeAfterFire,
//PhysicalMaterial = w.PhysicalMaterial,
MuzzleFlashLifeSpan = w.MuzzleFlashLifeSpan,
MuzzleFlashSpriteName = "Muzzle_Flash_Large",
NoAmmoSound = w.NoAmmoSound.SoundId.ToString(),
ReloadSound = w.ReloadSound.SoundId.ToString(),
SecondarySound = w.SecondarySound.SoundId.ToString(),
NoAmmoSoundPair = w.NoAmmoSound,
ReloadSoundPair = w.ReloadSound,
SecondarySoundPair = w.SecondarySound,
AmmoData = WeaponAmmoDefinition.CreateFromKeenDefinition(w.WeaponAmmoDatas[0]),
AiEnabled = lb.AiEnabled,
MinElevationDegrees = lb.MinElevationDegrees,
MaxElevationDegrees = lb.MaxElevationDegrees,
MinAzimuthDegrees = lb.MinAzimuthDegrees,
MaxAzimuthDegrees = lb.MaxAzimuthDegrees,
IdleRotation = lb.IdleRotation,
MaxRangeMeters = lb.MaxRangeMeters,
RotationSpeed = lb.RotationSpeed,
ElevationSpeed = lb.ElevationSpeed,
MinFov = lb.MinFov,
MaxFov = lb.MaxFov,
AmmoPullAmount = lb.AmmoPullAmount,
InventoryFillFactorMin = lb.InventoryFillFactorMin,
});
}
else
{
return(new WeaponDefinition {
Enabled = true,
SubtypeId = w.Id.SubtypeId.String,
DeviateShotAngle = w.DeviateShotAngle,
ReloadTime = w.ReloadTime,
ReleaseTimeAfterFire = w.ReleaseTimeAfterFire,
//PhysicalMaterial = w.PhysicalMaterial,
MuzzleFlashLifeSpan = w.MuzzleFlashLifeSpan,
MuzzleFlashSpriteName = "Muzzle_Flash_Large",
NoAmmoSound = w.NoAmmoSound.SoundId.ToString(),
ReloadSound = w.ReloadSound.SoundId.ToString(),
SecondarySound = w.SecondarySound.SoundId.ToString(),
NoAmmoSoundPair = w.NoAmmoSound,
ReloadSoundPair = w.ReloadSound,
SecondarySoundPair = w.SecondarySound,
AmmoData = WeaponAmmoDefinition.CreateFromKeenDefinition(w.WeaponAmmoDatas[0]),
InventoryFillFactorMin = b.InventoryFillFactorMin,
});
}
}
