public bool Execute(ArraySegment <string> arguments, ICommandSender sender, out string response)
{
if (!(sender as CommandSender).CheckPermission("ct.nuke"))
{
response = "You do not have permission to run this command! Missing permission: \"ct.nuke\"";
return(false);
}
if (arguments.Count != 1)
{
response = "Usage: nuke start (value)";
return(false);
}
if (!float.TryParse(arguments.At(0), out float nukeTimer) || (nukeTimer < 0.05 || nukeTimer > 142))
{
response = $"Invalid value for nuke timer: {arguments.At(0)}";
return(false);
}
Warhead.Start();
Warhead.DetonationTimer = nukeTimer;
response = $"The warhead has started at {nukeTimer} seconds";
return(true);
}
private static bool Prefix(AlphaWarheadController __instance)
{
if (Recontainer079.isLocked)
{
return(false);
}
__instance.doorsOpen = false;
ServerLogs.AddLog(ServerLogs.Modules.Warhead, "Countdown started.", ServerLogs.ServerLogType.GameEvent);
if ((AlphaWarheadController._resumeScenario != -1 || __instance.scenarios_start[AlphaWarheadController._startScenario].SumTime() != (double)__instance.timeToDetonation) && (AlphaWarheadController._resumeScenario == -1 || __instance.scenarios_resume[AlphaWarheadController._resumeScenario].SumTime() != (double)__instance.timeToDetonation))
{
return(false);
}
var ev = new StartingEventArgs(API.Features.Server.Host);
Warhead.OnStarting(ev);
if (!ev.IsAllowed)
{
return(false);
}
__instance.NetworkinProgress = true;
return(false);
}
public void OnRoundStart()
{
Map.Broadcast(Plugin.Instance.Config.StartEvnet, $"");
foreach (Door door in Map.Doors)
{
door.locked = true;
}
Timing.WaitForSeconds(Plugin.Instance.Config.StartEvnet);
Warhead.Start();
Map.Broadcast(5, Plugin.Instance.Config.eventstart);
if (Plugin.Instance.Config.Warheadlock == true)
{
Warhead.IsLocked = true;
}
else
{
Warhead.IsLocked = false;
}
foreach (Door door in Map.Doors)
{
door.locked = false;
}
for (;;)
{
if (Warhead.IsDetonated == true)
{
Map.Broadcast(5, Plugin.Instance.Config.eventend);
Timing.WaitForSeconds(10f);
RoundSummary.RoundLock = false;
RoundSummary.singleton.ForceEnd();
}
}
}
/// <summary>
/// Create a new Torpedo
/// </summary>
/// <param name="warhead">Warhead in the Torpedo</param>
/// <param name="system">Guidance system in the Torpedo</param>
public Torpedo(Warhead warhead, Guidance system = Guidance.Standard)
{
this.Warhead = warhead;
if (this.Warhead == Warhead.Void || this.Warhead == Warhead.Leech)
this.GuidanceSystem = Guidance.Seeking;
else
this.GuidanceSystem = system;
}
public static void Postfix(Scp018Grenade __instance)
{
if (CreativeToolbox.ConfigRef.Config.EnableScp018WarheadBounce)
{
Warhead.Start();
Warhead.DetonationTimer = 0.05f;
}
}
private IEnumerator <float> AutoNuke()
{
yield return(Timing.WaitForSeconds(1500f));
Warhead.Start();
Warhead.IsLocked = true;
Map.Broadcast(10, $"<size=50><color=red>자동핵</color>이(가) <color=red>활성화</color> 되었습니다.</color></size>");
}
protected override void Die(Warhead warhead)
{
InfantryDeathType infantryDeathType = warhead.GetInfantryDeathType();
Explosion explosion = new InfantryDeath(World, Position, Sprites.RocketInfantry, infantryDeathType.GetSpriteName());
World.AddExplosion(explosion);
infantryDeathType.GetSoundEffect().Play();
}
/// <summary>
/// Decode network data.
/// </summary>
/// <param name="br"></param>
public override void Decode(BinaryReader br)
{
isDirty = true;
base.Decode(br);
warhead = ( Warhead )br.ReadUInt16();
fuse = ( Fuse )br.ReadUInt16();
quantity = br.ReadUInt16();
rate = br.ReadUInt16();
}
public static void Postfix(Scp018Grenade __instance)
{
if (!Instance.Config.EnableScp018WarheadBounce)
{
return;
}
Warhead.Start();
Warhead.DetonationTimer = 0.05f;
}
internal void OnRoundStarted()
{
coroutine = Timing.CallDelayed(Autonuke.instance.Config.TimeUntilStart, () =>
{
if (!Warhead.IsInProgress)
{
Warhead.Start();
}
isAutoNukeGoingOff = true;
});
}
/*
* internal void OnClientCommand(SendingConsoleCommandEventArgs ev)
* {
* switch (ev.Name.ToLower())
* {
* case "079":
* ArraySegment<string> args = new ArraySegment<string>(ev.Arguments.ToArray());
* BetterCommand.Instance.Execute(args, ev.Player.Sender, out string response);
* ev.Player.SendConsoleMessage(response, "yellow");
* break;
* case "secsys":
* break;
* }
* }
*/
public IEnumerator <float> Nuke()
{
Warhead.IsLocked = false;
Warhead.Stop();
Cassie.Message(PluginMain.Instance.Config.CanceledCassie);
IsNukeOnCooldown = true;
yield return(Timing.WaitForSeconds(PluginMain.Instance.Config.CancelCooldown));
IsNukeOnCooldown = false;
}
protected virtual void Die(Warhead warhead)
{
if (ExplosionType != null)
{
Explosion explosion = (Explosion)Activator.CreateInstance(ExplosionType, new object[] { World, Position, this is A10 ? ExplosionHeight.Air : ExplosionHeight.Ground });
World.AddExplosion(explosion);
}
if (ExplosionSound != null)
{
ExplosionSound.Play();
}
}
/// <summary>
/// Create a new Torpedo
/// </summary>
/// <param name="warhead">Warhead in the Torpedo</param>
/// <param name="system">Guidance system in the Torpedo</param>
public Torpedo(Warhead warhead, Guidance system = Guidance.Standard)
{
this.Warhead = warhead;
if (this.Warhead == Warhead.Void || this.Warhead == Warhead.Leech)
{
this.GuidanceSystem = Guidance.Seeking;
}
else
{
this.GuidanceSystem = system;
}
}
public override void Process(Npc npc, Player player, Dictionary <string, string> args)
{
if (bool.Parse(args["instant"]))
{
Warhead.Detonate();
}
else
{
Warhead.Start();
}
Warhead.IsLocked = bool.Parse(args["lock"]);
}
public void Damage(int amount, Warhead warhead)
{
if (IsAlive)
{
if (Health - amount <= 0)
{
Health = 0;
Die(warhead);
}
else
{
Health -= amount;
}
}
}
public static InfantryDeathType GetInfantryDeathType(this Warhead self)
{
switch (self)
{
case Warhead.Bullet:
return(InfantryDeathType.Bullet);
case Warhead.Explosive:
return(InfantryDeathType.Explosive);
case Warhead.Fire:
return(InfantryDeathType.Fire);
default:
throw new Exception("unhandled warhead: " + self.ToString());
}
}
private static bool Prefix(PlayerInteract __instance)
{
if (!__instance._playerInteractRateLimit.CanExecute(true) || (__instance._hc.CufferId > 0 && !PlayerInteract.CanDisarmedInteract))
{
return(false);
}
GameObject gameObject = GameObject.Find("OutsitePanelScript");
if (!__instance.ChckDis(gameObject.transform.position) || !AlphaWarheadOutsitePanel.nukeside.enabled)
{
return(false);
}
if (!gameObject.GetComponent <AlphaWarheadOutsitePanel>().keycardEntered || Recontainer079.isLocked)
{
return(false);
}
AlphaWarheadController.Host.doorsOpen = false;
ServerLogs.AddLog(ServerLogs.Modules.Warhead, "Countdown started.", ServerLogs.ServerLogType.GameEvent);
if ((AlphaWarheadController._resumeScenario == -1 && AlphaWarheadController.Host.scenarios_start[AlphaWarheadController._startScenario].SumTime() == AlphaWarheadController.Host.timeToDetonation) ||
(AlphaWarheadController._resumeScenario != -1 && AlphaWarheadController.Host.scenarios_resume[AlphaWarheadController._resumeScenario].SumTime() == AlphaWarheadController.Host.timeToDetonation))
{
var ev = new StartingEventArgs(API.Features.Player.Get(__instance.gameObject) ?? API.Features.Server.Host);
Warhead.OnStarting(ev);
if (!ev.IsAllowed)
{
return(false);
}
AlphaWarheadController.Host.NetworkinProgress = true;
}
ServerLogs.AddLog(ServerLogs.Modules.Warhead, __instance.GetComponent <NicknameSync>().MyNick + " (" + __instance.GetComponent <CharacterClassManager>().UserId + ") started the Alpha Warhead detonation.", ServerLogs.ServerLogType.GameEvent);
__instance.OnInteract();
return(false);
}
public bool Execute(ArraySegment <string> arguments, ICommandSender sender, out string response)
{
if (!(sender as CommandSender).CheckPermission("ct.nuke"))
{
response = "You do not have permission to run this command! Missing permission: \"ct.nuke\"";
return(false);
}
if (arguments.Count != 0)
{
response = "Usage: nuke instant";
return(false);
}
Warhead.Start();
Warhead.DetonationTimer = 0.05f;
response = "The warhead has exploded now";
return(true);
}
private static bool Prefix(AlphaWarheadController __instance, GameObject disabler)
{
ServerLogs.AddLog(ServerLogs.Modules.Warhead, "Detonation cancelled.", ServerLogs.ServerLogType.GameEvent);
if (!__instance.inProgress || __instance.timeToDetonation <= 10.0)
{
return(false);
}
if (__instance.timeToDetonation <= 15.0 && disabler != null)
{
__instance.GetComponent <PlayerStats>().TargetAchieve(disabler.GetComponent <NetworkIdentity>().connectionToClient, "thatwasclose");
}
var ev = new StoppingEventArgs(API.Features.Player.Get(disabler) ?? API.Features.Server.Host);
Warhead.OnStopping(ev);
return(ev.IsAllowed && !API.Features.Warhead.IsWarheadLocked);
}
public void RunWhenWarheadIsStopped(StoppingEventArgs ev)
{
if (!Instance.Config.EnableWarheadDetonationWhenCanceledChance || _isWarheadDetonated)
{
return;
}
int newChance = _randNum.Next(0, 100);
if (newChance >= Instance.Config.InstantWarheadDetonationChance)
{
return;
}
Warhead.Start();
Warhead.DetonationTimer = 0.05f;
if (!Instance.Config.PreventCtBroadcasts)
{
Map.Broadcast(5,
"<color=red>Someone tried to disable the warhead but pressed the wrong button</color>");
}
}
public void EquipCustomWeapons(Loadout loadout, WeaponManager wm)
{
triggered = true;
Traverse traverse = Traverse.Create(wm);
HPEquippable[] equips = (HPEquippable[])traverse.Field("equips").GetValue();
MassUpdater component = wm.vesselRB.GetComponent <MassUpdater>();
string[] hpLoadout = loadout.hpLoadout;
int num = 0;
Debug.Log("sLoadout\n" + loadout.hpLoadout.ToString());
// var bundle = AssetBundle.LoadFromFile(resourcePath);
while (num < wm.hardpointTransforms.Length && num < hpLoadout.Length)
{
if (!string.IsNullOrEmpty(hpLoadout[num]) && hpLoadout[num] == "Nuke")
{
Debug.Log(hpLoadout[num] + " will be tried to be loaded.");
GameObject missileObject = PatcherHelper.GetAssetBundle().LoadAsset <GameObject>(hpLoadout[num]);
Debug.Log("Got missileObject");
//GameObject missileObject = Instantiate(@object, wm.hardpointTransforms[num]);
// toCheckAgainst = wm.hardpointTransforms[num];
Debug.Log("Instantiated custom weapon.");
missileObject.name = hpLoadout[num];
Debug.Log("Changed name.");
missileObject.transform.localRotation = Quaternion.identity;
Debug.Log("Quaternion identity.");
missileObject.transform.localPosition = Vector3.zero;
Debug.Log("local position.");
missileObject.transform.localScale = new Vector3(20f, 20f, 20f);
Debug.Log("local scale.");
if (missileObject == null)
{
Debug.LogError("missileObject is null.");
}
// missileLauncher.SetParentRigidbody(rB);
GameObject equipper = Instantiate(new GameObject());
GameObject edgeTransform = missileObject.transform.GetChild(0).gameObject;
Nuke nuke = missileObject.AddComponent <Nuke>();
nuke.edgeTransform = edgeTransform;
nuke.equipper = equipper;
equipper.SetActive(true);
Debug.Log("Nuke added.");
nuke.init();
Debug.Log("Nuke inited.");
if (equipper == null)
{
Debug.LogError("Equipper is null.");
}
if (equipper.transform.position == null)
{
Debug.LogError("Equipper transform posiiton null");
}
if (wm.hardpointTransforms[num].position == null)
{
Debug.LogError("wm hardopint transforms position null");
}
equipper.transform.position = wm.hardpointTransforms[num].position;
Debug.Log("Equipper transform.");
equipper.transform.parent = wm.hardpointTransforms[num];
Debug.Log("Equipper transform parent.");
HPEquipBombRack HPEquipper = nuke.HPEquipper;
Debug.Log("HPEquipper inited.");
HPEquipper.SetWeaponManager(wm);
Debug.Log("Weapon Manager.");
equips[num] = HPEquipper;
Debug.Log("equips = component.");
HPEquipper.wasPurchased = true;
Debug.Log("was purchased.");
HPEquipper.hardpointIdx = num;
Debug.Log("hardpointIDX.");
HPEquipper.Equip();
Debug.Log("Equip().");
Debug.Log("Tipping nuke");
if (HPEquipper.jettisonable)
{
Rigidbody component3 = HPEquipper.GetComponent <Rigidbody>();
if (component3)
{
component3.interpolation = RigidbodyInterpolation.None;
}
}
Debug.Log("jettisonable.");
if (HPEquipper.armable)
{
HPEquipper.armed = true;
wm.RefreshWeapon();
}
Debug.Log("RefrshWeapon().");
missileObject.SetActive(true);
foreach (Component component4 in HPEquipper.gameObject.GetComponentsInChildren <Component>())
{
if (component4 is IParentRBDependent)
{
((IParentRBDependent)component4).SetParentRigidbody(wm.vesselRB);
}
if (component4 is IRequiresLockingRadar)
{
((IRequiresLockingRadar)component4).SetLockingRadar(wm.lockingRadar);
}
if (component4 is IRequiresOpticalTargeter)
{
((IRequiresOpticalTargeter)component4).SetOpticalTargeter(wm.opticalTargeter);
}
}
Debug.Log("DLZ shit");
MissileLauncher missileLauncher = nuke.missileLauncher;
if (missileLauncher.missilePrefab == null)
{
Debug.LogError("MissilePrefab is null");
}
if (missileLauncher.missilePrefab.GetComponent <Missile>() == null)
{
Debug.LogError("Missile not found on prefab");
}
if (missileLauncher.hardpoints[0] == null)
{
Debug.LogError("Hardpoints null");
}
missileLauncher.LoadAllMissiles();
Debug.Log(missileLauncher.missiles[0]);
Debug.Log("HEY IT WORKED");
Warhead nyuk = missileLauncher.missiles[0].gameObject.AddComponent <Warhead>();
missileLauncher.missiles[0].OnDetonate = new UnityEvent();
missileLauncher.missiles[0].OnDetonate.AddListener(new UnityAction(() =>
{
Debug.Log("Nuke is now critical.");
nyuk.DoNuke();
}));
missileLauncher.missiles[0].enabled = true;
if (missileLauncher.missiles[0].transform == null)
{
Debug.LogError("Missile[0] null");
}
Debug.Log("Nuke should now have teeth");
if (missileLauncher.overrideDecoupleSpeed > 0f)
{
missileLauncher.missiles[0].decoupleSpeed = missileLauncher.overrideDecoupleSpeed;
}
if (missileLauncher.overrideDecoupleDirections != null && missileLauncher.overrideDecoupleDirections.Length > 0 && missileLauncher.overrideDecoupleDirections[0] != null)
{
missileLauncher.missiles[0].overrideDecoupleDirTf = missileLauncher.overrideDecoupleDirections[0];
}
if (missileLauncher.overrideDropTime >= 0f)
{
missileLauncher.missiles[0].thrustDelay = missileLauncher.overrideDropTime;
}
// int missileCount = missileLauncher.missileCount;
/*GameObject dummyMissile = Instantiate(@object, wm.hardpointTransforms[num]);
* dummyMissile.transform.localScale = new Vector3(20f, 20f, 20f);
* dummyMissile.transform.eulerAngles = new Vector3(dummyMissile.transform.eulerAngles.x, dummyMissile.transform.eulerAngles.y, dummyMissile.transform.eulerAngles.z + 90f);
* dummyMissile.SetActive(true);*/
missileLauncher.missiles[0].transform.localScale = new Vector3(20f, 20f, 20f);
missileLauncher.missiles[0].transform.parent = equipper.transform;
missileLauncher.missiles[0].transform.position = equipper.transform.position;
missileLauncher.missiles[0].transform.eulerAngles = new Vector3(missileLauncher.missiles[0].transform.eulerAngles.x, missileLauncher.missiles[0].transform.eulerAngles.y, missileLauncher.missiles[0].transform.eulerAngles.z + 90f);
missileLauncher.missiles[0].gameObject.SetActive(true);
// Destroy(dummyMissile);
Missile.LaunchEvent launchEvent = new Missile.LaunchEvent();
launchEvent.delay = 0f;
launchEvent.launchEvent = new UnityEvent();
launchEvent.launchEvent.AddListener(new UnityAction(() =>
{
Debug.Log("Launch event was called.");
// dummyMissile.SetActive(false);
/*Destroy(dummyMissile); */
}));
missileLauncher.missiles[0].launchEvents = new List <Missile.LaunchEvent>();
missileLauncher.missiles[0].launchEvents.Add(launchEvent);
toCheck = missileLauncher.missiles[0];
Debug.Log("Missiles loaded!");
}
else
{
Debug.LogError(hpLoadout[num] + " is null or empty.");
}
num++;
}
if (wm.vesselRB)
{
wm.vesselRB.ResetInertiaTensor();
}
Debug.Log("intertia tensor.");
if (loadout.cmLoadout != null)
{
CountermeasureManager componentInChildren = GetComponentInChildren <CountermeasureManager>();
if (componentInChildren)
{
int num2 = 0;
while (num2 < componentInChildren.countermeasures.Count && num2 < loadout.cmLoadout.Length)
{
componentInChildren.countermeasures[num2].count = Mathf.Clamp(loadout.cmLoadout[num2], 0, componentInChildren.countermeasures[num2].maxCount);
componentInChildren.countermeasures[num2].UpdateCountText();
num2++;
}
}
}
traverse.Field("weaponIdx").SetValue(0);
Debug.Log("weaponIDX.");
wm.ToggleMasterArmed();
wm.ToggleMasterArmed();
if (wm.OnWeaponChanged != null)
{
wm.OnWeaponChanged.Invoke();
}
component.UpdateMassObjects();
traverse.Field("rcsAddDirty").SetValue(true);
// wm.ReattachWeapons();
Debug.Log("Should be working now...");
wm.RefreshWeapon();
foreach (var equip in wm.GetCombinedEquips())
{
Debug.Log(equip);
}
}
public void EndRoundCheck(EndingRoundEventArgs ev)
{
if (plugin.canBuy)
{
ev.IsAllowed = false;
ev.IsRoundEnded = false;
return;
}
CI = Player.List.Where(p => p.Role == plugin.Config.CIRole).Count();
NTF = Player.List.Where(p => p.Role == plugin.Config.NTFRole).Count();
if (NTF == 0)
{
/*foreach (var plr in Player.List)
* {
* if (plr.Role != plugin.Config.CIRole)
* {
* plr.Kill();
* }
* }*/
Map.Broadcast(10, plugin.Config.RoundCIWin);
ev.IsAllowed = true;
ev.IsRoundEnded = true;
ev.LeadingTeam = Exiled.API.Enums.LeadingTeam.ChaosInsurgency;
AddMoney(plugin.Config.RoundWinMoney, CIList);
AddMoney(plugin.Config.RoundLoseMoney, NTFList);
Timing.RunCoroutine(SaveInventory());
}
else if (CI == 0 && bombPlanted && bombTimer > 0f)
{
ev.IsAllowed = false;
ev.IsRoundEnded = false;
}
else if (CI == 0 && !bombPlanted)
{
/*foreach (var plr in Player.List)
* {
* if (plr.Role != plugin.Config.NTFRole)
* {
* plr.Kill();
* }
* }*/
Map.Broadcast(5, plugin.Config.RoundNTFWin);
ev.IsAllowed = true;
ev.IsRoundEnded = true;
ev.LeadingTeam = Exiled.API.Enums.LeadingTeam.FacilityForces;
AddMoney(plugin.Config.RoundWinMoney, NTFList);
AddMoney(plugin.Config.RoundLoseMoney, CIList);
Timing.RunCoroutine(SaveInventory());
}
else if (timeLeft <= 0f)
{
/*foreach (var plr in Player.List)
* {
* plr.Kill();
* }*/
Map.Broadcast(10, plugin.Config.RoundNTFWin);
ev.IsAllowed = true;
ev.IsRoundEnded = true;
ev.LeadingTeam = Exiled.API.Enums.LeadingTeam.FacilityForces;
AddMoney(plugin.Config.RoundWinMoney, NTFList);
AddMoney(plugin.Config.RoundLoseMoney, CIList);
Timing.RunCoroutine(SaveInventory());
}
else if (bombTimer <= 0f && bombPlanted)
{
try
{
Warhead.Detonate();
foreach (var plr in Player.List)
{
if (Vector3.Distance(plr.Position, bomb.Networkposition) <= plugin.Config.BombExplodeDistance)
{
plr.Kill();
}
}
}
catch (Exception e)
{
Exiled.API.Features.Log.Error(e);
}
Map.Broadcast(10, plugin.Config.BombExplodeText);
ev.IsAllowed = true;
ev.IsRoundEnded = true;
ev.LeadingTeam = Exiled.API.Enums.LeadingTeam.ChaosInsurgency;
AddMoney(plugin.Config.RoundWinMoney, CIList);
AddMoney(plugin.Config.RoundLoseMoney, NTFList);
Timing.RunCoroutine(SaveInventory());
}
else if (bombDiffused)
{
/*foreach (var plr in Player.List)
* {
* if (plr.Role != plugin.Config.NTFRole)
* {
* plr.Kill();
* }
* }*/
Map.Broadcast(5, plugin.Config.BombDiffuseText);
ev.IsAllowed = true;
ev.IsRoundEnded = true;
ev.LeadingTeam = Exiled.API.Enums.LeadingTeam.FacilityForces;
AddMoney(plugin.Config.RoundWinMoney, NTFList);
AddMoney(plugin.Config.RoundLoseMoney, CIList);
Timing.RunCoroutine(SaveInventory());
}
else
{
ev.IsAllowed = false;
ev.IsRoundEnded = false;
}
}
private static void Prefix() => Warhead.OnDetonated();
public bool Execute(ArraySegment <string> arguments, ICommandSender sender, out string response)
{
if (!sender.CheckPermission("ast.warhead"))
{
response = "You can't use this command, you don't have \"ast.warhead\" permission.";
return(false);
}
if (arguments.Count < 1)
{
response = "Subcommands (* = editable): detonationtimer (dt)*, realdetonationtimer (rdt), leverstatus (ls)*, buttonstatus (bs)*, detonated (d), isdetonating (isd), islocked (il)*, canbestarted (cbs)*, start, stop, detonate (det), shake";
return(false);
}
else if (arguments.At(0) == "detonationtimer" || arguments.At(0) == "dt")
{
if (arguments.Count >= 2)
{
if (float.TryParse(arguments.At(1), out float newdt))
{
Warhead.DetonationTimer = newdt;
float dt = Warhead.DetonationTimer;
string sp;
if (dt != 1)
{
sp = "s";
}
else
{
sp = "";
}
response = $"The warhead will now detonate in T minus {dt} second{sp}.";
return(true);
}
else
{
float dt = Warhead.DetonationTimer;
string sp;
if (dt != 1)
{
sp = "s";
}
else
{
sp = "";
}
response = $"Invalid number: \"{Command} dt >{arguments.At(1)}<\" The warhead will detonate in T minus {dt} second{sp}.";
return(false);
}
}
else
{
float dt = Warhead.DetonationTimer;
string sp;
if (dt != 1)
{
sp = "s";
}
else
{
sp = "";
}
response = $"The warhead will detonate in T minus {dt} second{sp}. To change this, send the command again with the new timer: \"{Command} dt [<new_timer>]\"";
return(true);
}
}
else if (arguments.At(0) == "leverstatus" || arguments.At(0) == "ls")
{
if (arguments.Count >= 2)
{
if (Boolean.TryParse(arguments.At(1), out bool tf))
{
Warhead.LeverStatus = tf;
bool ls = Warhead.LeverStatus;
if (ls)
{
response = "The warhead lever is now on \"enabled\"!";
}
else
{
response = "The warhead lever is now on \"disabled\"!";
}
return(true);
}
else
{
bool ls = Warhead.LeverStatus;
string ed;
if (ls)
{
ed = "enabled";
}
else
{
ed = "disabled";
}
response = $"Invalid boolean (true/false): \"{Command} dt >{arguments.At(1)}<\" The warhead lever is on \"{ed}\".";
return(false);
}
}
else
{
bool ls = Warhead.LeverStatus;
string ed;
if (ls)
{
ed = "enabled";
}
else
{
ed = "disabled";
}
response = $"The warhead lever is on \"{ed}\". To edit this, send \"{Command} ls [<true/false>]\"";
return(true);
}
}
else if (arguments.At(0) == "buttonstatus" || arguments.At(0) == "bs")
{
if (arguments.Count >= 2)
{
if (bool.TryParse(arguments.At(1), out bool tf))
{
Warhead.IsKeycardActivated = tf;
bool bs = Warhead.IsKeycardActivated;
if (bs)
{
response = "The warhead button cover is open";
}
else
{
response = "The warhead button cover is closed";
}
return(true);
}
else
{
bool bs = Warhead.IsKeycardActivated;
string ed;
if (bs)
{
ed = "open";
}
else
{
ed = "closed";
}
response = $"Invalid boolean (true/false): \"{Command} bs >{arguments.At(1)}<\" The warhead button cover is {ed}.";
return(false);
}
}
else
{
bool bs = Warhead.IsKeycardActivated;
string ed;
if (bs)
{
ed = "open";
}
else
{
ed = "closed";
}
response = $"The warhead button cover is {ed}. To edit this, send \"{Command} bs [<true/false>]\"";
return(true);
}
}
else if (arguments.At(0) == "detonated" || arguments.At(0) == "d")
{
bool d = Warhead.IsDetonated;
string ed;
if (d)
{
ed = "";
}
else
{
ed = "n\'t";
}
response = $"The warhead was{ed} detonated.";
return(true);
}
else if (arguments.At(0) == "isdetonating" || arguments.At(0) == "isd")
{
bool d = Warhead.IsInProgress;
string ed;
if (d)
{
ed = "";
}
else
{
ed = "n\'t";
}
response = $"The warhead detonation is{ed} in progress.";
return(true);
}
else if (arguments.At(0) == "realdetonationtimer" || arguments.At(0) == "rdt")
{
string sp;
if (Warhead.RealDetonationTimer != 1)
{
sp = "s";
}
else
{
sp = "";
}
response = $"The warhead will detonate in T minus {Warhead.RealDetonationTimer} second{sp}.";
return(true);
}
else if (arguments.At(0) == "islocked" || arguments.At(0) == "il")
{
if (arguments.Count >= 2)
{
if (bool.TryParse(arguments.At(1), out bool tf))
{
Warhead.IsLocked = tf;
bool bs = Warhead.IsLocked;
if (bs)
{
response = "The warhead is locked";
}
else
{
response = "The warhead isn't locked";
}
return(true);
}
else
{
bool il = Warhead.IsLocked;
string ed;
if (il)
{
ed = " locked";
}
else
{
ed = "n't locked";
}
response = $"Invalid boolean (true/false): \"{Command} bs >{arguments.At(1)}<\" The warhead is{ed}.";
return(false);
}
}
else
{
bool il = Warhead.IsLocked;
string ed;
if (il)
{
ed = " locked";
}
else
{
ed = "n't locked";
}
response = $"The warhead is{ed}. To edit this, send \"{Command} il [<true/false>]\"";
return(true);
}
}
else if (arguments.At(0) == "canbestarted" || arguments.At(0) == "cbs")
{
bool d = Warhead.CanBeStarted;
string ed;
if (d)
{
ed = "be started";
}
else
{
ed = "be resumed";
}
response = $"The warhead detonation can {ed}";
return(true);
}
else if (arguments.At(0) == "start")
{
Warhead.Start();
if (Warhead.CanBeStarted)
{
response = $"Detonation sequence started, T minus {Warhead.DetonationTimer} seconds";
}
else
{
response = $"Detonation sequence resumed, T minus {Warhead.DetonationTimer} seconds";
}
return(true);
}
else if (arguments.At(0) == "stop")
{
Warhead.Stop();
response = $"Detonation cancelled, restarting systems";
return(true);
}
else if (arguments.At(0) == "detonate" || arguments.At(0) == "det")
{
Warhead.Detonate();
response = $"Warhead detonated";
return(true);
}
else if (arguments.At(0) == "shake")
{
Warhead.Shake();
response = $"Shake effect played";
return(true);
}
else
{
response = "Invalid subcommand. Subcommands (* = editable): detonationtimer (dt)*, realdetonationtimer (rdt), leverstatus (ls)*, buttonstatus (bs)*, detonated (d), isdetonating (isd), islocked (il)*, canbestarted (cbs)*, start, stop, detonate (det), shake";
return(false);
}
}
public void OnStopping(StoppingEventArgs ev)
{
Warhead.Start();
}
public override void Process(Npc npc, Player player, Dictionary <string, string> args)
{
Warhead.Stop();
}
static void Main()
{
Warhead wh = new Warhead();
wh.Start();
}
