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 GuidedMissileLauncher(WeaponTargeting weapon)
{
m_weaponTarget = weapon;
FuncBlock = CubeBlock as IMyFunctionalBlock;
myLogger = new Logger("GuidedMissileLauncher", CubeBlock);
var defn = 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 * CubeBlock.GetCubeBlockDefinition().Size.Y * CubeBlock.CubeGrid.GridSize + forwardAdjust;
MissileSpawnBox = BoundingBox.CreateFromPoints(points);
if (m_weaponTarget.myTurret != null)
{
myLogger.debugLog("original box: " + MissileSpawnBox, "GuidedMissileLauncher()");
MissileSpawnBox.Inflate(CubeBlock.CubeGrid.GridSize * 2f);
}
myLogger.debugLog("MissileSpawnBox: " + MissileSpawnBox, "GuidedMissileLauncher()");
myInventory = (CubeBlock as Interfaces.IMyInventoryOwner).GetInventory(0);
Registrar.Add(weapon.FuncBlock, this);
m_weaponTarget.GuidedLauncher = true;
}
private void LoadSaveData(Builder_ArmsData data)
{
if (data == null)
{
Logger.DebugLog("No data to load");
return;
}
#pragma warning disable 612, 618
if (Comparer <Version> .Default.Compare(data.ArmsVersion, default(Version)) == 0)
{
Logger.DebugLog("Old version: " + data.ModVersion);
data.ArmsVersion = new Version(data.ModVersion);
}
#pragma warning restore 612, 618
Logger.AlwaysLog("Save version: " + data.ArmsVersion, Rynchodon.Logger.severity.INFO);
// relay
Dictionary <Message.Builder_Message, Message> messages = MyAPIGateway.Multiplayer.IsServer ? new Dictionary <Message.Builder_Message, Message>() : null;
SerializableGameTime.Adjust = new TimeSpan(data.SaveTime);
foreach (RelayStorage.Builder_NetworkStorage bns in data.AntennaStorage)
{
RelayNode node;
if (!Registrar.TryGetValue(bns.PrimaryNode, out node))
{
Logger.AlwaysLog("Failed to get node for: " + bns.PrimaryNode, Rynchodon.Logger.severity.WARNING);
continue;
}
RelayStorage store = node.Storage;
if (store == null) // probably always true
{
node.ForceCreateStorage();
store = node.Storage;
if (store == null)
{
Logger.AlwaysLog("failed to create storage for " + node.DebugName, Rynchodon.Logger.severity.ERROR);
continue;
}
}
foreach (LastSeen.Builder_LastSeen bls in bns.LastSeenList)
{
LastSeen ls = new LastSeen(bls);
if (ls.IsValid)
{
store.Receive(ls);
}
else
{
Logger.AlwaysLog("failed to create a valid last seen from builder for " + bls.EntityId, Rynchodon.Logger.severity.WARNING);
if (m_failedLastSeen == null)
{
m_failedLastSeen = new CachingDictionary <long, CachingList <LastSeen.Builder_LastSeen> >();
UpdateManager.Register(100, RetryLastSeen);
}
CachingList <LastSeen.Builder_LastSeen> list;
if (!m_failedLastSeen.TryGetValue(bns.PrimaryNode, out list))
{
list = new CachingList <LastSeen.Builder_LastSeen>();
m_failedLastSeen.Add(bns.PrimaryNode, list, true);
}
list.Add(bls);
list.ApplyAdditions();
}
}
Logger.DebugLog("added " + bns.LastSeenList.Length + " last seen to " + store.PrimaryNode.DebugName, Rynchodon.Logger.severity.DEBUG);
// messages in the save file belong on the server
if (messages == null)
{
continue;
}
foreach (Message.Builder_Message bm in bns.MessageList)
{
Message msg;
if (!messages.TryGetValue(bm, out msg))
{
msg = new Message(bm);
messages.Add(bm, msg);
}
else
{
Logger.DebugLog("found linked message", Rynchodon.Logger.severity.TRACE);
}
if (msg.IsValid)
{
store.Receive(msg);
}
else
{
Logger.AlwaysLog("failed to create a valid message from builder for " + bm.DestCubeBlock + "/" + bm.SourceCubeBlock, Rynchodon.Logger.severity.WARNING);
}
}
Logger.DebugLog("added " + bns.MessageList.Length + " message to " + store.PrimaryNode.DebugName, Rynchodon.Logger.severity.DEBUG);
}
// past this point, only synchronized data
if (!MyAPIGateway.Multiplayer.IsServer)
{
data = null;
return;
}
// system disruption
foreach (Disruption.Builder_Disruption bd in data.SystemDisruption)
{
Disruption disrupt;
switch (bd.Type)
{
case "AirVentDepressurize":
disrupt = new AirVentDepressurize();
break;
case "CryoChamberMurder":
disrupt = new CryoChamberMurder();
break;
case "DisableTurret":
disrupt = new DisableTurret();
break;
case "DoorLock":
disrupt = new DoorLock();
break;
case "EMP":
disrupt = new EMP();
break;
case "GravityReverse":
disrupt = new GravityReverse();
break;
case "JumpDriveDrain":
disrupt = new JumpDriveDrain();
break;
case "MedicalRoom":
disrupt = new MedicalRoom();
break;
case "TraitorTurret":
disrupt = new TraitorTurret();
break;
default:
Logger.AlwaysLog("Unknown disruption: " + bd.Type, Rynchodon.Logger.severity.WARNING);
continue;
}
disrupt.Start(bd);
}
// autopilot
if (data.Autopilot != null)
{
foreach (ShipAutopilot.Builder_Autopilot ba in data.Autopilot)
{
ShipAutopilot autopilot;
if (Registrar.TryGetValue(ba.AutopilotBlock, out autopilot))
{
autopilot.ResumeFromSave(ba);
}
else
{
Logger.AlwaysLog("failed to find autopilot block " + ba.AutopilotBlock, Rynchodon.Logger.severity.WARNING);
}
}
}
// programmable block
if (data.ProgrammableBlock != null)
{
foreach (ProgrammableBlock.Builder_ProgrammableBlock bpa in data.ProgrammableBlock)
{
ProgrammableBlock pb;
if (Registrar.TryGetValue(bpa.BlockId, out pb))
{
pb.ResumeFromSave(bpa);
}
else
{
Logger.AlwaysLog("failed to find programmable block " + bpa.BlockId, Rynchodon.Logger.severity.WARNING);
}
}
}
// text panel
if (data.TextPanel != null)
{
foreach (TextPanel.Builder_TextPanel btp in data.TextPanel)
{
TextPanel panel;
if (Registrar.TryGetValue(btp.BlockId, out panel))
{
panel.ResumeFromSave(btp);
}
else
{
Logger.AlwaysLog("failed to find text panel " + btp.BlockId, Rynchodon.Logger.severity.WARNING);
}
}
}
// weapon
if (data.Weapon != null)
{
foreach (WeaponTargeting.Builder_WeaponTargeting bwt in data.Weapon)
{
WeaponTargeting targeting;
if (WeaponTargeting.TryGetWeaponTargeting(bwt.WeaponId, out targeting))
{
targeting.ResumeFromSave(bwt);
}
else
{
Logger.AlwaysLog("failed to find weapon " + bwt.WeaponId, Rynchodon.Logger.severity.WARNING);
}
}
}
// entity values
if (data.EntityValues != null)
{
UpgradeEntityValue.Load(data.EntityValues);
}
// sync
if (data.Sync != null)
{
ASync.SetBuilder(data.Sync);
}
data = null;
}
/// <summary>
/// Scripts that use UpdateManager and run on clients as well as on server shall be added here.
/// </summary>
private void RegisterScripts_ClientAndServer()
{
#region Attached
RegisterForBlock(new MyObjectBuilderType[] { typeof(MyObjectBuilder_MotorStator), typeof(MyObjectBuilder_MotorAdvancedStator), typeof(MyObjectBuilder_MotorSuspension) },
block => RegisterForUpdates(100, (new StatorRotor.Stator(block)).Update, block));
RegisterForBlock(typeof(MyObjectBuilder_ExtendedPistonBase), (block) => {
Piston.PistonBase pistonBase = new Piston.PistonBase(block);
RegisterForUpdates(100, pistonBase.Update, block);
});
RegisterForBlock(typeof(MyObjectBuilder_ShipConnector), (block) => {
Connector conn = new Connector(block);
RegisterForUpdates(10, conn.Update, block);
});
RegisterForBlock(typeof(MyObjectBuilder_LandingGear), (block) => {
if (!Hacker.IsHacker(block))
{
new LandingGear(block);
}
});
#endregion
#region Antenna Communication
Action <IMyCubeBlock> nodeConstruct = block => {
RelayNode node = new RelayNode(block);
RegisterForUpdates(100, node.Update100, block);
};
RegisterForBlock(typeof(MyObjectBuilder_Beacon), nodeConstruct);
RegisterForBlock(typeof(MyObjectBuilder_LaserAntenna), nodeConstruct);
RegisterForBlock(typeof(MyObjectBuilder_RadioAntenna), nodeConstruct);
RegisterForCharacter(character => {
if (character.IsPlayer)
{
RelayNode node = new RelayNode(character);
RegisterForUpdates(100, node.Update100, (IMyEntity)character);
}
});
RegisterForBlock(typeof(MyObjectBuilder_MyProgrammableBlock), block => {
ProgrammableBlock pb = new ProgrammableBlock(block);
if (MyAPIGateway.Multiplayer.IsServer)
{
RegisterForUpdates(100, pb.Update100, block);
}
});
RegisterForBlock(typeof(MyObjectBuilder_TextPanel), block => {
TextPanel tp = new TextPanel(block);
if (MyAPIGateway.Multiplayer.IsServer)
{
RegisterForUpdates(100, tp.Update100, block);
}
});
RegisterForBlock(typeof(MyObjectBuilder_Projector), block => {
Projector p = new Projector(block);
if (MyAPIGateway.Session.Player != null)
{
RegisterForUpdates(100, p.Update100, block);
RegisterForUpdates(1, p.Update1, block);
}
});
if (MyAPIGateway.Session.Player != null)
{
new Player();
}
#endregion
#region Autopilot
if (!MyAPIGateway.Multiplayer.IsServer)
{
//RadarEquipment.Definition apRadar = new RadarEquipment.Definition()
//{
// Radar = true,
// LineOfSight = false,
// MaxTargets_Tracking = 3,
// MaxPowerLevel = 1000
//};
Action <IMyCubeBlock> apConstruct = (block) => {
if (ShipAutopilot.IsAutopilotBlock(block))
{
nodeConstruct(block);
new AutopilotTerminal(block);
//RadarEquipment r = new RadarEquipment(block, apRadar, block);
//RegisterForUpdates(100, r.Update100, block);
}
};
if (ServerSettings.GetSetting <bool>(ServerSettings.SettingName.bUseRemoteControl))
{
RegisterForBlock(typeof(MyObjectBuilder_RemoteControl), apConstruct);
}
RegisterForBlock(typeof(MyObjectBuilder_Cockpit), apConstruct);
}
if (ServerSettings.GetSetting <bool>(ServerSettings.SettingName.bAirResistanceBeta))
{
RegisterForGrid(grid => {
AeroEffects aero = new AeroEffects(grid);
RegisterForUpdates(1, aero.Update1, grid);
if (MyAPIGateway.Multiplayer.IsServer)
{
RegisterForUpdates(100, aero.Update100, grid);
}
});
RegisterForBlock(typeof(MyObjectBuilder_Cockpit), block => RegisterForUpdates(1, (new CockpitTerminal(block)).Update1, block));
}
#endregion
#region Radar
if (ServerSettings.GetSetting <bool>(ServerSettings.SettingName.bAllowRadar))
{
RegisterForBlock(typeof(MyObjectBuilder_Beacon), (block) => {
if (RadarEquipment.IsDefinedRadarEquipment(block))
{
new RadarEquipment(block);
}
});
RegisterForBlock(typeof(MyObjectBuilder_RadioAntenna), (block) => {
if (RadarEquipment.IsDefinedRadarEquipment(block))
{
new RadarEquipment(block);
}
});
RegisterForUpdates(100, RadarEquipment.UpdateAll);
}
#endregion
#region Terminal Control
RegisterForBlock(new MyObjectBuilderType[] { typeof(MyObjectBuilder_RadioAntenna), typeof(MyObjectBuilder_LaserAntenna) }, block => new ManualMessage(block));
#endregion Terminal Control
#region Weapon Control
if (ServerSettings.GetSetting <bool>(ServerSettings.SettingName.bAllowWeaponControl))
{
#region Turrets
Action <IMyCubeBlock> constructor;
if (ServerSettings.GetSetting <bool>(ServerSettings.SettingName.bAllowGuidedMissile))
{
constructor = block => {
if (!WeaponTargeting.ValidWeaponBlock(block))
{
return;
}
Turret t = new Turret(block);
RegisterForUpdates(1, t.Update_Targeting, block);
if (GuidedMissileLauncher.IsGuidedMissileLauncher(block))
{
GuidedMissileLauncher gml = new GuidedMissileLauncher(t);
RegisterForUpdates(1, gml.Update1, block);
}
}
}
;
else
{
constructor = block => {
if (!WeaponTargeting.ValidWeaponBlock(block))
{
return;
}
Turret t = new Turret(block);
RegisterForUpdates(1, t.Update_Targeting, block);
}
};
RegisterForBlock(typeof(MyObjectBuilder_LargeGatlingTurret), constructor);
RegisterForBlock(typeof(MyObjectBuilder_LargeMissileTurret), constructor);
RegisterForBlock(typeof(MyObjectBuilder_InteriorTurret), constructor);
#endregion
#region Fixed
if (ServerSettings.GetSetting <bool>(ServerSettings.SettingName.bAllowGuidedMissile))
{
constructor = block => {
if (!WeaponTargeting.ValidWeaponBlock(block))
{
return;
}
FixedWeapon w = new FixedWeapon(block);
RegisterForUpdates(1, w.Update_Targeting, block);
if (GuidedMissileLauncher.IsGuidedMissileLauncher(block))
{
GuidedMissileLauncher gml = new GuidedMissileLauncher(w);
RegisterForUpdates(1, gml.Update1, block);
}
};
}
else
{
constructor = block => {
if (!WeaponTargeting.ValidWeaponBlock(block))
{
return;
}
FixedWeapon w = new FixedWeapon(block);
RegisterForUpdates(1, w.Update_Targeting, block);
}
};
RegisterForBlock(typeof(MyObjectBuilder_SmallGatlingGun), constructor);
RegisterForBlock(typeof(MyObjectBuilder_SmallMissileLauncher), constructor);
RegisterForBlock(typeof(MyObjectBuilder_SmallMissileLauncherReload), constructor);
#endregion
// apparently missiles do not have their positions synced
RegisterForUpdates(1, GuidedMissile.Update1);
RegisterForUpdates(10, GuidedMissile.Update10);
RegisterForUpdates(100, GuidedMissile.Update100);
}
else
{
Log.DebugLog("Weapon Control is disabled", Logger.severity.INFO);
}
#endregion
#region Solar
if (!MyAPIGateway.Multiplayer.IsServer)
{
RegisterForBlock(typeof(MyObjectBuilder_OxygenFarm), (block) => new Solar(block));
RegisterForBlock(typeof(MyObjectBuilder_SolarPanel), (block) => new Solar(block));
}
#endregion
new ChatHandler();
Globals.Update100();
RegisterForUpdates(100, Globals.Update100);
Action <IMyCubeBlock> act = (block) => MainCockpitFix.AddController((IMyShipController)block);
RegisterForBlock(typeof(MyObjectBuilder_Cockpit), act);
RegisterForBlock(typeof(MyObjectBuilder_RemoteControl), act);
}
/// <summary>
/// Finds a primary weapon for m_weapon_primary and m_weapon_primary_pseudo.
/// A primary weapon can be any working weapon with ammo.
/// Preference is given to fixed weapons and weapons with targets.
/// If no weapons have ammo, m_weapon_primary and m_weapon_primary_pseudo will be null.
/// </summary>
private void GetPrimaryWeapon()
{
if (m_weapon_primary != null && m_weapon_primary.CubeBlock.IsWorking && m_weapon_primary.CurrentTarget.Entity != null)
{
return;
}
WeaponTargeting weapon_primary = null;
bool removed = false;
foreach (FixedWeapon weapon in m_weapons_fixed)
{
if (weapon.CubeBlock.IsWorking)
{
if (weapon.HasAmmo)
{
weapon_primary = weapon;
if (weapon.CurrentTarget.Entity != null)
{
Log.DebugLog("has target: " + weapon.CubeBlock.DisplayNameText);
break;
}
}
else
{
Log.DebugLog("no ammo: " + weapon.CubeBlock.DisplayNameText);
}
}
else
{
Log.DebugLog("not working: " + weapon.CubeBlock.DisplayNameText);
m_weapons_fixed.Remove(weapon);
weapon.EngagerReleaseControl();
removed = true;
}
}
if (weapon_primary == null)
{
foreach (WeaponTargeting weapon in m_weapons_all)
{
if (weapon.CubeBlock.IsWorking)
{
if (weapon.HasAmmo)
{
weapon_primary = weapon;
if (weapon.CurrentTarget.Entity != null)
{
Log.DebugLog("has target: " + weapon.CubeBlock.DisplayNameText);
break;
}
}
else
{
Log.DebugLog("no ammo: " + weapon.CubeBlock.DisplayNameText);
}
}
else
{
Log.DebugLog("not working: " + weapon.CubeBlock.DisplayNameText);
m_weapons_all.Remove(weapon);
removed = true;
}
}
}
if (removed)
{
m_weapons_fixed.ApplyRemovals();
m_weapons_all.ApplyRemovals();
m_weaponDataDirty = true;
}
if (weapon_primary == null)
{
m_weapon_primary = null;
m_weapon_primary_pseudo = null;
return;
}
if (m_weapon_primary != weapon_primary)
{
m_weapon_primary = weapon_primary;
IMyCubeBlock faceBlock;
FixedWeapon fixedWeapon = weapon_primary as FixedWeapon;
if (fixedWeapon != null && fixedWeapon.CubeBlock.CubeGrid != m_controlBlock.CubeGrid)
{
faceBlock = fixedWeapon.MotorTurretFaceBlock();
Log.DebugLog("MotorTurretFaceBlock == null", Logger.severity.FATAL, condition: faceBlock == null);
}
else
{
faceBlock = weapon_primary.CubeBlock;
}
if (m_mover.SignificantGravity())
{
if (m_mover.Thrust.Standard.LocalMatrix.Forward == faceBlock.LocalMatrix.Forward)
{
Log.DebugLog("primary forward matches Standard forward");
Matrix localMatrix = m_mover.Thrust.Standard.LocalMatrix;
localMatrix.Translation = faceBlock.LocalMatrix.Translation;
m_weapon_primary_pseudo = new PseudoBlock(() => faceBlock.CubeGrid, localMatrix);
return;
}
if (m_mover.Thrust.Gravity.LocalMatrix.Forward == faceBlock.LocalMatrix.Forward)
{
Log.DebugLog("primary forward matches Gravity forward");
Matrix localMatrix = m_mover.Thrust.Gravity.LocalMatrix;
localMatrix.Translation = faceBlock.LocalMatrix.Translation;
m_weapon_primary_pseudo = new PseudoBlock(() => faceBlock.CubeGrid, localMatrix);
return;
}
Log.DebugLog("cannot match primary forward to a standard flight matrix. primary forward: " + faceBlock.LocalMatrix.Forward +
", Standard forward: " + m_mover.Thrust.Standard.LocalMatrix.Forward + ", gravity forward: " + m_mover.Thrust.Gravity.LocalMatrix.Forward);
}
m_weapon_primary_pseudo = new PseudoBlock(faceBlock);
}
}
