public KMHoldableCommander(FloatingHoldable holdable)
{
Holdable = holdable;
Selectable = Holdable.GetComponent <Selectable>();
FloatingHoldable = Holdable.GetComponent <FloatingHoldable>();
Handler = HoldableFactory.CreateHandler(this, holdable);
}
public IEnumerator Hold(bool frontFace = true)
{
FloatingHoldable holdable = FloatingHoldable.GetComponent <FloatingHoldable>();
FloatingHoldable.HoldStateEnum holdState = holdable.HoldState;
bool doForceRotate = false;
if (holdState != global::FloatingHoldable.HoldStateEnum.Held)
{
SelectObject(Selectable.GetComponent <Selectable>());
doForceRotate = true;
}
else if (frontFace != _heldFrontFace)
{
doForceRotate = true;
}
if (!doForceRotate)
{
yield break;
}
float holdTime = holdable.PickupTime;
IEnumerator forceRotationCoroutine = ForceHeldRotation(frontFace, holdTime);
while (forceRotationCoroutine.MoveNext())
{
yield return(forceRotationCoroutine.Current);
}
}
public static void InitializePage(FloatingHoldable holdable)
{
Selectable holdableSelectable = holdable.GetComponent <Selectable>();
var currentPage = holdable.GetComponentsInChildren <Selectable>(false).FirstOrDefault(x => x != holdableSelectable);
_currentSelectable = currentPage?.GetCurrentChild();
_currentSelectable?.HandleSelect(true);
_currentSelectables = currentPage?.Children;
_currentSelectableIndex = _currentSelectables?.IndexOf(sel => sel == _currentSelectable) ?? -1;
}
public TwitchHoldable(FloatingHoldable holdable, Type commandType = null, bool allowModded = false, string id = null)
{
Holdable = holdable;
CommandType = commandType;
_defaultId = id ?? holdable.name.ToLowerInvariant().Replace("(clone)", "");
if (TwitchGame.BombActive)
{
var gameCommands = holdable.GetComponent <KMGameCommands>();
if (gameCommands != null)
{
gameCommands.OnCauseStrike += OnStrike;
}
}
if (allowModded)
{
// Find a suitable ProcessTwitchCommand method
foreach (var component in holdable.GetComponentsInChildren <Component>(true))
{
if (component == null)
{
continue;
}
var type = component.GetType();
var candidateMethod = type.GetMethod("ProcessTwitchCommand", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
if (candidateMethod == null)
{
continue;
}
if (ValidateMethodCommandMethod(type, candidateMethod))
{
HandlerMethod = candidateMethod;
CommandComponent = component;
HelpMessageField = type.GetField("TwitchHelpMessage", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
// Find a suitable TwitchShouldCancelCommand boolean field
FieldInfo f;
if ((f = type.GetField("TwitchShouldCancelCommand", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)) != null && f.FieldType == typeof(bool))
{
CancelBool = f;
}
break;
}
}
if (HandlerMethod == null)
{
// No method found.
LogAllComponentTypes(holdable);
}
}
}
public static IEnumerator StartAdvanced(FloatingHoldable holdable, [Group(1)] string command, [Group(2)] string parameters, string user, bool isWhisper)
{
if (parameters.RegexMatch(out Match m, @"(\d):(\d{1,3}):(\d{2})"))
{
var e = SetBombTimer(holdable, int.Parse(m.Groups[1].Value), int.Parse(m.Groups[2].Value), int.Parse(m.Groups[3].Value));
while (e.MoveNext())
{
yield return(e.Current);
}
}
else if (parameters.RegexMatch(out m, @"(\d{1,3}):(\d{2})"))
{
var e = SetBombTimer(holdable, 0, int.Parse(m.Groups[1].Value), int.Parse(m.Groups[2].Value));
while (e.MoveNext())
{
yield return(e.Current);
}
}
if (MultipleBombs.Installed() && parameters.RegexMatch(out m, @"(\d+) +bombs"))
{
var e = ChangeBombCount(holdable, int.Parse(m.Groups[1].Value));
while (e.MoveNext())
{
yield return(e.Current);
}
}
if (parameters.RegexMatch(out m, @"(\d+) +modules"))
{
var e = ChangeModuleCount(holdable, int.Parse(m.Groups[1].Value));
while (e.MoveNext())
{
yield return(e.Current);
}
}
yield return(null);
SetSetting(holdable, parameters.Contains("hardcore"), user, isWhisper, s => s.IsHardCore, s => s.HardcoreToggle, TwitchPlaySettings.data.EnableFreeplayHardcore, TwitchPlaySettings.data.FreePlayHardcoreDisabled);
yield return(null);
SetSetting(holdable, parameters.Contains("modsonly"), user, isWhisper, s => s.OnlyMods, s => s.ModsOnly, TwitchPlaySettings.data.EnableFreeplayModsOnly, TwitchPlaySettings.data.FreePlayModsOnlyDisabled);
yield return(null);
SetSetting(holdable, parameters.Contains("needy") || parameters.Contains("needies"), user, isWhisper, s => s.HasNeedy, s => s.NeedyToggle, TwitchPlaySettings.data.EnableFreeplayNeedy, TwitchPlaySettings.data.FreePlayNeedyDisabled);
yield return(null);
if (command.EqualsIgnoreCase("start"))
{
holdable.GetComponent <FreeplayDevice>().StartButton.GetComponent <Selectable>().Trigger();
}
}
private static void SetSetting(FloatingHoldable holdable, bool on, string user, bool isWhisper, Func <FreeplaySettings, bool> getCurrent, Func <FreeplayDevice, ToggleSwitch> toggle, bool settingAllowed, string disabledMessage)
{
if (settingAllowed || !on || UserAccess.HasAccess(user, AccessLevel.Admin, true) || TwitchPlaySettings.data.AnarchyMode)
{
var device = holdable.GetComponent <FreeplayDevice>();
if (on != getCurrent(device.CurrentSettings))
{
toggle(device).GetComponent <Selectable>().Trigger();
}
}
else
{
IRCConnection.SendMessage(string.Format(disabledMessage, user), user, !isWhisper);
}
}
public IRCConnectionManagerHandler(KMHoldableCommander commander, FloatingHoldable holdable) : base(commander, holdable)
{
_connectButton = holdable.GetComponent <IRCConnectionManagerHoldable>().ConnectButton;
_elevatorSwitch = TPElevatorSwitch.Instance;
HelpMessage = "Disconnect the IRC from twitch plays with !{0} disconnect. For obvious reasons, only the streamer may do this.";
if (_elevatorSwitch?.gameObject.activeInHierarchy ?? false)
{
HelpMessage += " Turn the elevator on with !{0} elevator on. Turn the Elevator off with !{0} elevator off. Flip the elevator on/off with !{0} elevator toggle";
}
if (commander != null)
{
commander.ID = "ircmanager";
}
Instance = this;
}
protected HoldableHandler(KMHoldableCommander commander, FloatingHoldable holdable)
{
HoldableCommander = commander;
Holdable = holdable;
if (!BombMessageResponder.BombActive)
{
return;
}
KMGameCommands gameCommands = holdable.GetComponent <KMGameCommands>();
if (gameCommands == null)
{
return;
}
gameCommands.OnCauseStrike += OnStrike;
}
public static IEnumerator Throw(FloatingHoldable holdable, [Group(1)] int?optionalStrength = 3)
{
int strength = optionalStrength ?? 3;
holdable.Pause();
Rigidbody rigidbody = holdable.GetComponent <Rigidbody>();
rigidbody.isKinematic = false;
rigidbody.useGravity = true;
rigidbody.velocity = Random.onUnitSphere * rigidbody.mass * strength;
rigidbody.angularVelocity = Random.onUnitSphere * rigidbody.mass * strength;
rigidbody.maxAngularVelocity = 100f;
yield return(new WaitForSeconds(2));
rigidbody.isKinematic = true;
rigidbody.useGravity = false;
holdable.Resume();
}
public static IEnumerator ChangeModuleCount(FloatingHoldable holdable, [Group(1)] int moduleCount)
{
var device = holdable.GetComponent <FreeplayDevice>();
int currentModuleCount = device.CurrentSettings.ModuleCount;
var button = (moduleCount > currentModuleCount ? device.ModuleCountIncrement : device.ModuleCountDecrement).GetComponent <Selectable>();
for (int hitCount = 0; hitCount < Mathf.Abs(moduleCount - currentModuleCount); ++hitCount)
{
int lastModuleCount = device.CurrentSettings.ModuleCount;
button.Trigger();
yield return(new WaitForSeconds(0.01f));
if (lastModuleCount == device.CurrentSettings.ModuleCount)
{
yield break;
}
}
}
public IEnumerator LetGoBomb()
{
if (FloatingHoldable.GetComponent <FloatingHoldable>().HoldState != global::FloatingHoldable.HoldStateEnum.Held)
{
yield break;
}
IEnumerator turnCoroutine = Hold(true);
while (turnCoroutine.MoveNext())
{
yield return(turnCoroutine.Current);
}
while (FloatingHoldable.GetComponent <FloatingHoldable>().HoldState == global::FloatingHoldable.HoldStateEnum.Held)
{
DeselectObject(Selectable.GetComponent <Selectable>());
yield return(new WaitForSeconds(0.1f));
}
}
private static IEnumerator SetBombTimer(FloatingHoldable holdable, int hours, int minutes, int seconds)
{
if (seconds >= 60)
{
yield break;
}
var device = holdable.GetComponent <FreeplayDevice>();
int timeIndex = (hours * 120) + (minutes * 2) + (seconds / 30);
DebugHelper.Log("Freeplay time doubling section");
//Double the available free play time. (The doubling stacks with the Multiple bombs module installed)
float originalMaxTime = FreeplayDevice.MAX_SECONDS_TO_SOLVE;
int maxModules = (int)_maxModuleField.GetValue(device);
int multiplier = MultipleBombs.Installed() ? (MultipleBombs.GetMaximumBombCount() * 2) - 1 : 1;
float newMaxTime = 600f + (maxModules - 1) * multiplier * 60;
FreeplayDevice.MAX_SECONDS_TO_SOLVE = newMaxTime;
DebugHelper.Log("Freeplay settings reading section");
float currentTime = device.CurrentSettings.Time;
int currentTimeIndex = Mathf.FloorToInt(currentTime) / 30;
KeypadButton button = timeIndex > currentTimeIndex ? device.TimeIncrement : device.TimeDecrement;
Selectable buttonSelectable = button.GetComponent <Selectable>();
DebugHelper.Log("Freeplay time setting section");
for (int hitCount = 0; hitCount < Mathf.Abs(timeIndex - currentTimeIndex); ++hitCount)
{
currentTime = device.CurrentSettings.Time;
buttonSelectable.Trigger();
yield return(new WaitForSeconds(0.01f));
if (Mathf.FloorToInt(currentTime) == Mathf.FloorToInt(device.CurrentSettings.Time))
{
break;
}
}
//Restore original max time, just in case Multiple bombs module was NOT installed, to avoid false detection.
FreeplayDevice.MAX_SECONDS_TO_SOLVE = originalMaxTime;
}
public static HoldableHandler CreateHandler(KMHoldableCommander commander, FloatingHoldable holdable)
{
if (commander != null)
{
commander.ID = holdable.name.ToLowerInvariant().Replace("(clone)", "");
}
foreach (Type type in ModHoldableTypes)
{
if (type?.FullName == null)
{
continue;
}
if (holdable.GetComponent(type) == null || !ModHoldableCreators.ContainsKey(type.FullName))
{
continue;
}
return(ModHoldableCreators[type.FullName](commander, holdable));
}
return(CreateModComponentSolver(commander, holdable));
}
public static IEnumerator ChangeBombCount(FloatingHoldable holdable, [Group(1)] int bombCount)
{
if (!MultipleBombs.Installed())
{
yield break;
}
int currentBombCount = MultipleBombs.GetFreePlayBombCount();
var buttonSelectable = holdable.GetComponent <Selectable>().Children[bombCount > currentBombCount ? 3 : 2];
for (int hitCount = 0; hitCount < Mathf.Abs(bombCount - currentBombCount); ++hitCount)
{
int lastBombCount = MultipleBombs.GetFreePlayBombCount();
buttonSelectable.Trigger();
yield return(new WaitForSeconds(0.01f));
// Stop here if we hit a maximum or minimum
if (lastBombCount == MultipleBombs.GetFreePlayBombCount())
{
yield break;
}
}
}
public static void Start(FloatingHoldable holdable) => holdable.GetComponent <FreeplayDevice>().StartButton.GetComponent <Selectable>().Trigger();
private static bool FindCancelBool(FloatingHoldable holdable, Type holdableType, out FieldInfo CancelField)
{
CancelField = holdableType.GetField("TwitchShouldCancelCommand", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
return(CancelField?.GetValue(holdable.GetComponent(holdableType)) is bool);
}