private static MyObjectBuilder_CubeBlock ProcessWeaponBlock(MyObjectBuilder_CubeBlock block, Options options, MyCubeSize size)
{ // LargeTurretBase
try
{
MyWeaponBlockDefinition myWeaponBlock = (MyWeaponBlockDefinition)MyDefinitionManager.Static.GetCubeBlockDefinition(block.GetId());
List <BlockSideEnum> mountPoints = myWeaponBlock.MountPoints.Select(myMountPoint => myMountPoint.GetObjectBuilder(myMountPoint.Normal).Side).ToList();
List <WeaponInformation> replacementOptions = LargeGridWeaponBlocks.FindAll(x =>
//x.ModName != "Vanilla" &&
x.SubtypeId != block.SubtypeId &&
x.MountPoints.Intersect(mountPoints).Any() &&
x.SizeX == myWeaponBlock.Size.X &&
x.SizeY == myWeaponBlock.Size.Y &&
x.SizeZ <= myWeaponBlock.Size.Z //+ 1
);
if (replacementOptions.Count == 0)
{
return(block);
}
block = CreateReplacementWeaponBlock(replacementOptions[Core.Random.Next(0, replacementOptions.Count)], block, size, myWeaponBlock);
}
catch (Exception e)
{
Core.GeneralLog.WriteToLog("WeaponSwapper-ProcessWeaponBlock", $"Exception!\t{e}");
}
return(block);
}
public GuidedMissileLauncher(WeaponTargeting weapon)
{
m_weaponTarget = weapon;
m_relayPart = RelayClient.GetOrCreateRelayPart(m_weaponTarget.CubeBlock);
this._initialTarget = NoTarget.Instance;
MyWeaponBlockDefinition defn = (MyWeaponBlockDefinition)CubeBlock.GetCubeBlockDefinition();
Vector3[] points = new Vector3[3];
Vector3 forwardAdjust = Vector3.Forward * WeaponDescription.GetFor(CubeBlock).MissileSpawnForward;
points[0] = CubeBlock.LocalAABB.Min + forwardAdjust;
points[1] = CubeBlock.LocalAABB.Max + forwardAdjust;
points[2] = CubeBlock.LocalAABB.Min + Vector3.Up * defn.Size.Y * CubeBlock.CubeGrid.GridSize + forwardAdjust;
MissileSpawnBox = BoundingBox.CreateFromPoints(points);
if (m_weaponTarget.myTurret != null)
{
Log.TraceLog("original box: " + MissileSpawnBox);
MissileSpawnBox.Inflate(CubeBlock.CubeGrid.GridSize * 2f);
}
Log.TraceLog("MissileSpawnBox: " + MissileSpawnBox);
myInventory = ((MyEntity)CubeBlock).GetInventoryBase(0);
Registrar.Add(weapon.CubeBlock, this);
m_weaponTarget.GuidedLauncher = true;
m_gameCooldownTime = TimeSpan.FromSeconds(60d / MyDefinitionManager.Static.GetWeaponDefinition(defn.WeaponDefinitionId).WeaponAmmoDatas[(int)MyAmmoType.Missile].RateOfFire);
Log.TraceLog("m_gameCooldownTime: " + m_gameCooldownTime);
CubeBlock.AppendingCustomInfo += CubeBlock_AppendingCustomInfo;
}
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,
});
}
}
/// <summary>
/// Updates the definition when syncing to the server
/// </summary>
public virtual void SystemRestart()
{
//Tools.Debug($"Restarting Weapon Logic {Entity.EntityId}");
MyWeaponBlockDefinition blockDef = ((CubeBlock as IMyFunctionalBlock).SlimBlock.BlockDefinition as MyWeaponBlockDefinition);
WeaponDefinition d = Settings.WeaponDefinitionLookup[blockDef.WeaponDefinitionId.SubtypeId.String];
Copy(d);
CurrentShotInBurst = 0;
CurrentIdleReloadTime = 0;
InitializeSound();
}
public void Init(MyObjectBuilder_GunBase objectBuilder, MyCubeBlockDefinition cubeBlockDefinition, IMyGunBaseUser gunBaseUser)
{
if (cubeBlockDefinition is MyWeaponBlockDefinition)
{
MyWeaponBlockDefinition weaponBlockDefinition = cubeBlockDefinition as MyWeaponBlockDefinition;
Init(objectBuilder, weaponBlockDefinition.WeaponDefinitionId, gunBaseUser);
}
else
{
// Backward compatibility
MyDefinitionId weaponDefinitionId = GetBackwardCompatibleDefinitionId(cubeBlockDefinition.Id.TypeId);
Init(objectBuilder, weaponDefinitionId, gunBaseUser);
}
}
public WeaponInformation(List <BlockSideEnum> mountPoints, MyCubeSize myCubeSize, int sizeX, int sizeY, int sizeZ,
MyStringHash subtypeId, string subtypeName, MyObjectBuilderType typeId, string modName, string id, MyWeaponBlockDefinition myWeaponBlock = null, MyLargeTurretBaseDefinition myLargeTurret = null)
{
MountPoints = mountPoints;
MyCubeSize = myCubeSize;
SizeX = sizeX;
SizeY = sizeY;
SizeZ = sizeZ;
SubtypeId = subtypeId;
SubtypeName = subtypeName;
TypeId = typeId;
ModName = modName;
Id = id;
MyWeaponBlock = myWeaponBlock;
MyLargeTurret = myLargeTurret;
}
private static void ProcessWeaponBlock(MyDefinitionBase myDefinition)
{
try
{
if (WeaponIgnoreList.Contains(myDefinition.Id.SubtypeId) || !myDefinition.Public)
{
return;
}
//MyCubeBlockDefinition myCubeBlock = MyDefinitionManager.Static.GetCubeBlockDefinition(myDefinition.Id);
MyWeaponBlockDefinition myWeaponBlock = (MyWeaponBlockDefinition)MyDefinitionManager.Static.GetCubeBlockDefinition(myDefinition.Id);
List <BlockSideEnum> mountPoints = myWeaponBlock.MountPoints.Select(myMountPoint => myMountPoint.GetObjectBuilder(myMountPoint.Normal).Side).ToList();
WeaponInformation myWeaponInformation = new WeaponInformation(
mountPoints,
myWeaponBlock.CubeSize,
myWeaponBlock.Size.X,
myWeaponBlock.Size.Y,
myWeaponBlock.Size.Z,
myDefinition.Id.SubtypeId,
myDefinition.Id.SubtypeName,
myDefinition.Id.TypeId,
myDefinition.Context?.ModName ?? "Vanilla",
myDefinition.Id.ToString(),
myWeaponBlock
);
if (myWeaponBlock.CubeSize == MyCubeSize.Large)
{
LargeGridWeaponBlocks.Add(myWeaponInformation);
}
else
{
SmallGridWeaponBlocks.Add(myWeaponInformation);
}
//Core.GeneralLog.WriteToLog("ProcessWeaponBlock", myWeaponInformation.ToString());
}
catch (Exception e)
{
Core.GeneralLog.WriteToLog("ProcessWeaponBlock", $"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);
}
}
/// <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}");
}
}
}
private static MyObjectBuilder_CubeBlock CreateReplacementWeaponBlock(WeaponInformation weaponInformation, MyObjectBuilder_CubeBlock block, MyCubeSize size, MyWeaponBlockDefinition myWeaponBlock)
{
int zOffset = Math.Abs(myWeaponBlock.Size.Z) - Math.Abs(weaponInformation.SizeZ);
MyObjectBuilder_CubeBlock myNewWeapon = MyObjectBuilderSerializer.CreateNewObject(
weaponInformation.TypeId, weaponInformation.SubtypeName) as MyObjectBuilder_CubeBlock;
if (myNewWeapon == null)
{
Core.GeneralLog.WriteToLog("CreateReplacementWeaponBlock", $"Replacement came up null...");
return(block);
}
((MyObjectBuilder_UserControllableGun)myNewWeapon).EntityId = block.EntityId;
((MyObjectBuilder_UserControllableGun)myNewWeapon).SubtypeName = weaponInformation.SubtypeName;
((MyObjectBuilder_UserControllableGun)myNewWeapon).IntegrityPercent = block.IntegrityPercent;
((MyObjectBuilder_UserControllableGun)myNewWeapon).BuildPercent = block.BuildPercent;
((MyObjectBuilder_UserControllableGun)myNewWeapon).Orientation = block.Orientation;
((MyObjectBuilder_UserControllableGun)myNewWeapon).BlockOrientation = block.BlockOrientation;
((MyObjectBuilder_UserControllableGun)myNewWeapon).ColorMaskHSV = block.ColorMaskHSV;
((MyObjectBuilder_UserControllableGun)myNewWeapon).Min = block.Min;
if (zOffset != 0 && block.Min.Z < 0)
{
((MyObjectBuilder_UserControllableGun)myNewWeapon).Min.Z += zOffset;
}
((MyObjectBuilder_UserControllableGun)myNewWeapon).ShowInTerminal = true;
((MyObjectBuilder_UserControllableGun)myNewWeapon).ShowOnHUD = false;
((MyObjectBuilder_UserControllableGun)myNewWeapon).Enabled = ((MyObjectBuilder_UserControllableGun)block).Enabled;
if (weaponInformation.TypeId == typeof(MyObjectBuilder_SmallMissileLauncherReload) || weaponInformation.TypeId == typeof(MyObjectBuilder_SmallMissileLauncher))
{
if (weaponInformation.TypeId == typeof(MyObjectBuilder_SmallMissileLauncherReload))
{
((MyObjectBuilder_SmallMissileLauncherReload)myNewWeapon).Inventory = new MyObjectBuilder_Inventory();
}
else
{
((MyObjectBuilder_SmallMissileLauncher)myNewWeapon).Inventory = new MyObjectBuilder_Inventory();
}
return(myNewWeapon);
}
((MyObjectBuilder_UserControllableGun)myNewWeapon).ComponentContainer = new MyObjectBuilder_ComponentContainer()
{
Components = new List <MyObjectBuilder_ComponentContainer.ComponentData>()
{
new MyObjectBuilder_ComponentContainer.ComponentData()
{
TypeId = "MyInventoryBase",
Component = new MyObjectBuilder_Inventory()
{
InventoryFlags = MyInventoryFlags.CanReceive,
RemoveEntityOnEmpty = false,
}
}
}
};
return(myNewWeapon);
}
