private void Update()
{
MainThreadQueue.ProcessQueue();
if (Input.GetKey(KeyCode.Escape))
{
InputInterceptor.EnableInput();
TwitchGame.ModuleCameras?.DisableCameraWall();
}
if (Input.GetKeyDown(DebugSequence[_debugSequenceIndex].ToString()))
{
_debugSequenceIndex++;
if (_debugSequenceIndex != DebugSequence.Length)
{
return;
}
TwitchPlaySettings.data.TwitchPlaysDebugEnabled = !TwitchPlaySettings.data.TwitchPlaysDebugEnabled;
TwitchPlaySettings.WriteDataToFile();
chatSimulator.SetActive(TwitchPlaySettings.data.TwitchPlaysDebugEnabled);
_debugSequenceIndex = 0;
UserAccess.AddUser("_TPDEBUG".ToLowerInvariant(), AccessLevel.Streamer | AccessLevel.SuperUser | AccessLevel.Admin | AccessLevel.Mod);
UserAccess.WriteAccessList();
}
else if (Input.anyKeyDown)
{
_debugSequenceIndex = 0;
}
}
private void Update()
{
if (Input.GetKey(KeyCode.Escape))
{
InputInterceptor.EnableInput();
}
if (Input.GetKeyDown(debugSequence[debugSequenceIndex].ToString()))
{
debugSequenceIndex++;
if (debugSequenceIndex != debugSequence.Length)
{
return;
}
TwitchPlaySettings.data.TwitchPlaysDebugEnabled = !TwitchPlaySettings.data.TwitchPlaysDebugEnabled;
TwitchPlaySettings.WriteDataToFile();
debugSequenceIndex = 0;
UserAccess.AddUser("_TPDEBUG".ToLowerInvariant(), AccessLevel.Streamer | AccessLevel.SuperUser | AccessLevel.Admin | AccessLevel.Mod);
UserAccess.WriteAccessList();
}
else if (Input.anyKeyDown)
{
debugSequenceIndex = 0;
}
}
public static void EnableTwitchPlays()
{
IRCConnection.SendMessage("Twitch Plays Enabled");
TwitchPlaySettings.data.EnableTwitchPlaysMode = true;
TwitchPlaySettings.WriteDataToFile();
TwitchGame.EnableDisableInput();
}
public static void DisableInteractiveMode()
{
IRCConnection.SendMessage("Interactive Mode Disabled");
TwitchPlaySettings.data.EnableInteractiveMode = false;
TwitchPlaySettings.WriteDataToFile();
TwitchGame.EnableDisableInput();
}
private void OnGUI()
{
if (!TwitchPlaySettings.data.TwitchPlaysDebugEnabled)
{
return;
}
GUILayout.BeginArea(new Rect(50, Screen.height - 75, (Screen.width - 50) * 0.2f, 25));
GUILayout.BeginHorizontal();
inputCommand = GUILayout.TextField(inputCommand, GUILayout.MinWidth(50));
if ((GUILayout.Button("Send") || Event.current.keyCode == KeyCode.Return) && inputCommand.Length != 0)
{
if (inputCommand.Equals(debugSequence))
{
TwitchPlaySettings.data.TwitchPlaysDebugEnabled = !TwitchPlaySettings.data.TwitchPlaysDebugEnabled;
TwitchPlaySettings.WriteDataToFile();
inputCommand = "";
GUILayout.EndHorizontal();
GUILayout.EndArea();
return;
}
IRCConnection.Instance.SetDebugUsername();
IRCConnection.Instance.SendMessage(inputCommand);
IRCConnection.Instance.OnMessageReceived.Invoke(IRCConnection.Instance.UserNickName, IRCConnection.Instance.CurrentColor, inputCommand, false);
inputCommand = "";
}
GUILayout.EndHorizontal();
GUILayout.EndArea();
}
private bool HandleKey(string[] modulesBefore, string[] modulesAfter, FieldInfo keyTurned, FieldInfo otherKeyTurned, FieldInfo beforeKeyField, MethodInfo onKeyTurn)
{
if (!GetValue(_activatedField) || GetValue(keyTurned))
{
return(false);
}
KMBombInfo bombInfo = BombComponent.GetComponent <KMBombInfo>();
KMBombModule bombModule = BombComponent.GetComponent <KMBombModule>();
if (TwitchPlaySettings.data.EnforceSolveAllBeforeTurningKeys &&
modulesAfter.Any(x => bombInfo.GetSolvedModuleNames().Count(x.Equals) != bombInfo.GetSolvableModuleNames().Count(x.Equals)))
{
bombModule.HandleStrike();
return(false);
}
beforeKeyField.SetValue(null, TwitchPlaySettings.data.DisableTurnTheKeysSoftLock ? new string[0] : modulesBefore);
onKeyTurn.Invoke(BombComponent.GetComponent(_componentType), null);
if (GetValue(keyTurned))
{
//Check to see if any forbidden modules for this key were solved.
if (TwitchPlaySettings.data.DisableTurnTheKeysSoftLock && bombInfo.GetSolvedModuleNames().Any(modulesBefore.Contains))
{
bombModule.HandleStrike(); //If so, Award a strike for it.
}
if (GetValue(otherKeyTurned))
{
int modules = bombInfo.GetSolvedModuleNames().Count(x => RightAfterA.Contains(x) || LeftAfterA.Contains(x));
TwitchPlaySettings.AddRewardBonus(2 * modules);
IRCConnection.SendMessage("Reward increased by {0} for defusing module !{1} ({2}).", modules * 2, Code, bombModule.ModuleDisplayName);
}
}
return(false);
}
private MessageResponder GetActiveResponder(KMGameInfo.State state)
{
switch (state)
{
case KMGameInfo.State.Gameplay:
DefaultCamera();
return(bombMessageResponder);
case KMGameInfo.State.Setup:
DefaultCamera();
_coroutinesToStart.Enqueue(VanillaRuleModifier.Refresh());
_coroutinesToStart.Enqueue(MultipleBombs.Refresh());
_coroutinesToStart.Enqueue(FactoryRoomAPI.Refresh());
_coroutinesToStart.Enqueue(CreateSolversForAllBombComponents());
return(missionMessageResponder);
case KMGameInfo.State.PostGame:
DefaultCamera();
return(postGameMessageResponder);
case KMGameInfo.State.Transitioning:
ModuleData.LoadDataFromFile();
TwitchPlaySettings.LoadDataFromFile();
return(null);
default:
return(null);
}
}
private static void SetTimeModeTimeLimit(object timeLimit)
{
if (timeLimit is int intTimeLimit)
{
TwitchPlaySettings.data.TimeModeStartingTime = intTimeLimit;
TwitchPlaySettings.WriteDataToFile();
}
}
public TwitchPlaysProperties()
{
AddProperty("TimeMode", new Property(() => OtherModes.TimeModeOn, x => OtherModes.TimeModeOn = (bool)x));
AddProperty("ZenMode", new Property(() => OtherModes.ZenModeOn, x => OtherModes.ZenModeOn = (bool)x));
AddProperty("TimeModeTimeLimit", new Property(() => TwitchPlaySettings.data.TimeModeStartingTime, SetTimeModeTimeLimit));
AddProperty("ircConnectionSendMessage", new Property(null, x => IRCConnection.Instance.SendMessage((string)x)));
AddProperty("Reward", new Property(() => TwitchPlaySettings.GetRewardBonus(), x => TwitchPlaySettings.SetRewardBonus((int)x)));
AddProperty("CauseFakeStrike", new Property(null, CauseFakeStrike));
}
private void OnStateChange(KMGameInfo.State state)
{
CurrentState = state;
if (!transform.gameObject.activeInHierarchy)
{
return;
}
StartCoroutine(StopEveryCoroutine());
if (state != KMGameInfo.State.PostGame && _leaderboardDisplay != null)
{
DestroyObject(_leaderboardDisplay);
_leaderboardDisplay = null;
}
twitchGame?.gameObject.SetActive(state == KMGameInfo.State.Gameplay);
OtherModes.RefreshModes(state);
// Automatically check for updates after a round is finished or when entering the setup state but never more than once per hour.
bool hourPassed = DateTime.Now.Subtract(Updater.LastCheck).TotalHours >= 1;
if ((state == KMGameInfo.State.PostGame || state == KMGameInfo.State.Setup) && hourPassed && !Updater.UpdateAvailable)
{
_coroutinesToStart.Enqueue(AutomaticUpdateCheck());
}
switch (state)
{
case KMGameInfo.State.Gameplay:
DefaultCamera();
break;
case KMGameInfo.State.Setup:
DefaultCamera();
_coroutinesToStart.Enqueue(VanillaRuleModifier.Refresh());
_coroutinesToStart.Enqueue(MultipleBombs.Refresh());
_coroutinesToStart.Enqueue(FactoryRoomAPI.Refresh());
_coroutinesToStart.Enqueue(FindSupportedModules());
break;
case KMGameInfo.State.PostGame:
DefaultCamera();
if (_leaderboardDisplay == null)
{
_leaderboardDisplay = Instantiate(TwitchLeaderboardPrefab);
}
Leaderboard.Instance.SaveDataToFile();
break;
case KMGameInfo.State.Transitioning:
ModuleData.LoadDataFromFile();
TwitchPlaySettings.LoadDataFromFile();
break;
}
}
private void Start()
{
_gameInfo = GetComponent <KMGameInfo>();
_gameInfo.OnStateChange += OnStateChange;
_modSettings = GetComponent <KMModSettings>();
ModSettingsJSON settings = JsonConvert.DeserializeObject <ModSettingsJSON>(_modSettings.Settings);
if (settings == null)
{
DebugHelper.LogError("Failed to read connection settings from mod settings.");
return;
}
DebugMode = (settings.debug == true);
_ircConnection = new IRCConnection(settings.authToken, settings.userName, settings.channelName, settings.serverName, settings.serverPort);
_ircConnection.Connect();
_coroutineCanceller = new CoroutineCanceller();
_coroutineQueue = GetComponent <CoroutineQueue>();
_coroutineQueue.coroutineCanceller = _coroutineCanceller;
logUploader = GetComponent <LogUploader>();
logUploader.ircConnection = _ircConnection;
urlHelper = GetComponent <UrlHelper>();
urlHelper.ChangeMode(settings.shortUrls == true);
_leaderboard = new Leaderboard();
_leaderboard.LoadDataFromFile();
ModuleData.LoadDataFromFile();
ModuleData.WriteDataToFile();
TwitchPlaySettings.LoadDataFromFile();
UserAccess.AddUser(settings.userName, AccessLevel.Streamer | AccessLevel.SuperUser | AccessLevel.Admin | AccessLevel.Mod);
UserAccess.AddUser(settings.channelName.Replace("#", ""), AccessLevel.Streamer | AccessLevel.SuperUser | AccessLevel.Admin | AccessLevel.Mod);
UserAccess.WriteAccessList();
SetupResponder(bombMessageResponder);
SetupResponder(postGameMessageResponder);
SetupResponder(missionMessageResponder);
SetupResponder(miscellaneousMessageResponder);
bombMessageResponder.leaderboard = _leaderboard;
postGameMessageResponder.leaderboard = _leaderboard;
miscellaneousMessageResponder.leaderboard = _leaderboard;
bombMessageResponder.parentService = this;
}
public void ProcessResponse(CommandResponse response, int value)
{
switch (response)
{
case CommandResponse.Start:
StopAllCoroutines();
StartCoroutine(DoBackgroundColorChange(highlightColor));
break;
case CommandResponse.EndNotComplete:
StopAllCoroutines();
StartCoroutine(DoBackgroundColorChange(normalColor));
break;
case CommandResponse.EndComplete:
StopAllCoroutines();
StartCoroutine(DoBackgroundColorChange(completeColor));
if (leaderboard != null)
{
leaderboard.AddSolve(userName, userColor);
if (!UserAccess.HasAccess(userName, AccessLevel.NoPoints))
{
leaderboard.AddScore(userName, userColor, value);
}
else
{
TwitchPlaySettings.AddRewardBonus(value);
}
}
break;
case CommandResponse.EndError:
StopAllCoroutines();
StartCoroutine(DoBackgroundColorChange(errorColor));
leaderboard?.AddStrike(userName, userColor, TwitchPlaySettings.data.EnableRewardMultipleStrikes ? value : 1);
break;
case CommandResponse.NoResponse:
StopAllCoroutines();
StartCoroutine(DoBackgroundColorChange(ignoreColor));
break;
case CommandResponse.EndErrorSubtractScore:
if (!UserAccess.HasAccess(userName, AccessLevel.NoPoints))
{
leaderboard?.AddScore(userName, userColor, value);
}
break;
default:
break;
}
}
public static IEnumerator Retry(string user, bool isWhisper)
{
if (!TwitchPlaySettings.data.EnableRetryButton)
{
IRCConnection.SendMessage(TwitchPlaySettings.data.RetryInactive, user, isWhisper);
return(doButton(Object.FindObjectOfType <ResultPage>().ContinueButton));
}
else
{
TwitchPlaySettings.SetRetryReward();
return(doButton(Object.FindObjectOfType <ResultPage>().RetryButton));
}
}
private IEnumerator RefreshIRCBackground()
{
yield return(null);
if (_imageLoadingDisabled)
{
yield break;
}
yield return(null);
IRCText.color = TwitchPlaySettings.data.IRCManagerTextColor;
try
{
#pragma warning disable IDE0031 // Use null propagation
MeshRenderer background = _newImageGameObject != null?_newImageGameObject.GetComponent <MeshRenderer>() : null;
#pragma warning restore IDE0031 // Use null propagation
//Image loading at runtime found at https://forum.unity.com/threads/solved-apply-image-to-plane-primitive.320489/
if (background == null || !File.Exists(TwitchPlaySettings.data.IRCManagerBackgroundImage))
{
_originalImageGameObject.SetActive(true);
if (_newImageGameObject != null)
{
_newImageGameObject.SetActive(false);
}
yield break;
}
_originalImageGameObject.SetActive(false);
if (_newImageGameObject != null)
{
_newImageGameObject.SetActive(true);
}
byte[] bytes = File.ReadAllBytes(TwitchPlaySettings.data.IRCManagerBackgroundImage);
Texture2D tex = new Texture2D(1, 1);
tex.LoadImage(bytes);
background.material.mainTexture = tex;
}
catch (Exception ex)
{
DebugHelper.LogException(ex, "Could NOT set a custom background image due to an exception. Feature is being disabled for the rest of this session:");
_imageLoadingDisabled = true;
TwitchPlaySettings.WriteDataToFile();
_originalImageGameObject.SetActive(true);
if (_newImageGameObject != null)
{
_newImageGameObject.SetActive(false);
}
}
}
private void OnStateChange(KMGameInfo.State state)
{
CurrentState = state;
if (!transform.gameObject.activeInHierarchy)
{
return;
}
StartCoroutine(StopEveryCoroutine());
if (state != KMGameInfo.State.PostGame && _leaderboardDisplay != null)
{
DestroyObject(_leaderboardDisplay);
_leaderboardDisplay = null;
}
twitchGame?.gameObject.SetActive(state == KMGameInfo.State.Gameplay);
OtherModes.RefreshModes(state);
switch (state)
{
case KMGameInfo.State.Gameplay:
DefaultCamera();
break;
case KMGameInfo.State.Setup:
DefaultCamera();
_coroutinesToStart.Enqueue(VanillaRuleModifier.Refresh());
_coroutinesToStart.Enqueue(MultipleBombs.Refresh());
_coroutinesToStart.Enqueue(FactoryRoomAPI.Refresh());
_coroutinesToStart.Enqueue(FindSupportedModules());
break;
case KMGameInfo.State.PostGame:
DefaultCamera();
if (_leaderboardDisplay == null)
{
_leaderboardDisplay = Instantiate(TwitchLeaderboardPrefab);
}
Leaderboard.Instance.SaveDataToFile();
break;
case KMGameInfo.State.Transitioning:
ModuleData.LoadDataFromFile();
TwitchPlaySettings.LoadDataFromFile();
break;
}
}
private void Start()
{
Instance = this;
transform.Find("Prefabs").gameObject.SetActive(false);
twitchGame = GetComponentInChildren <TwitchGame>(true);
twitchGame.twitchBombPrefab = GetComponentInChildren <TwitchBomb>(true);
twitchGame.twitchModulePrefab = GetComponentInChildren <TwitchModule>(true);
twitchGame.moduleCamerasPrefab = GetComponentInChildren <ModuleCameras>(true);
TwitchGame.Instance = twitchGame;
GameRoom.InitializeSecondaryCamera();
_gameInfo = GetComponent <KMGameInfo>();
_gameInfo.OnStateChange += OnStateChange;
CoroutineQueue = GetComponent <CoroutineQueue>();
Leaderboard.Instance.LoadDataFromFile();
LeaderboardController.Install();
ModuleData.LoadDataFromFile();
ModuleData.WriteDataToFile();
AuditLog.SetupLog();
MainThreadQueue.Initialize();
TwitchPlaySettings.LoadDataFromFile();
MusicPlayer.LoadMusic();
IRCConnection.Instance.OnMessageReceived.AddListener(OnMessageReceived);
twitchGame.ParentService = this;
GameObject infoObject = new GameObject("TwitchPlays_Info");
infoObject.transform.parent = gameObject.transform;
_publicProperties = infoObject.AddComponent <TwitchPlaysProperties>();
_publicProperties.TwitchPlaysService = this; // TODO: Useless variable?
if (TwitchPlaySettings.data.SkipModManagerInstructionScreen || IRCConnection.Instance.State == IRCConnectionState.Connected)
{
ModManagerManualInstructionScreen.HasShownOnce = true;
}
UpdateUiHue();
SetupChatSimulator();
}
public IceCreamConfirm(BombCommander bombCommander, BombComponent bombComponent) :
base(bombCommander, bombComponent)
{
_settings = new Settings();
modInfo = ComponentSolverFactory.GetModuleInfo(GetModuleType(), ShimData.HelpMessage + " Check the opening hours with !{0} hours.");
KMModSettings modSettings = bombComponent.GetComponent <KMModSettings>();
try
{
_settings = JsonConvert.DeserializeObject <Settings>(modSettings.Settings);
}
catch (Exception ex)
{
DebugHelper.LogException(ex, "Could not deserialize ice cream settings:");
TwitchPlaySettings.data.ShowHours = false;
TwitchPlaySettings.WriteDataToFile();
}
}
private void SetupChatSimulator()
{
chatSimulator.SetActive(TwitchPlaySettings.data.TwitchPlaysDebugEnabled);
var num = MouseControls.SCREEN_BOUNDARY_PERCENT * Screen.height + 5;
chatSimulator.transform.position = new Vector3(num, num, 0);
var messageInput = chatSimulator.Traverse <InputField>("MessageInput");
var sendButton = chatSimulator.Traverse <Button>("SendButton");
messageInput.onEndEdit.AddListener(_ =>
{
if (Input.GetKey(KeyCode.Return))
{
sendButton.onClick.Invoke();
messageInput.ActivateInputField();
}
});
sendButton.onClick.AddListener(() =>
{
var message = messageInput.text;
if (string.IsNullOrEmpty(message))
{
return;
}
if (message.Equals(DebugSequence))
{
TwitchPlaySettings.data.TwitchPlaysDebugEnabled = !TwitchPlaySettings.data.TwitchPlaysDebugEnabled;
TwitchPlaySettings.WriteDataToFile();
chatSimulator.SetActive(TwitchPlaySettings.data.TwitchPlaysDebugEnabled);
}
else
{
IRCConnection.SetDebugUsername();
IRCConnection.SendMessage(message);
IRCConnection.ReceiveMessage(IRCConnection.Instance.UserNickName, IRCConnection.Instance.CurrentColor, message);
}
messageInput.text = "";
});
}
private void Start()
{
transform.Find("Prefabs").gameObject.SetActive(false);
bombMessageResponder = GetComponentInChildren <BombMessageResponder>(true);
postGameMessageResponder = GetComponentInChildren <PostGameMessageResponder>(true);
missionMessageResponder = GetComponentInChildren <MissionMessageResponder>(true);
miscellaneousMessageResponder = GetComponentInChildren <MiscellaneousMessageResponder>(true);
bombMessageResponder.twitchBombHandlePrefab = GetComponentInChildren <TwitchBombHandle>(true);
bombMessageResponder.twitchComponentHandlePrefab = GetComponentInChildren <TwitchComponentHandle>(true);
bombMessageResponder.moduleCamerasPrefab = GetComponentInChildren <ModuleCameras>(true);
BombMessageResponder.Instance = bombMessageResponder;
GameRoom.InitializeSecondaryCamera();
_gameInfo = GetComponent <KMGameInfo>();
_gameInfo.OnStateChange += OnStateChange;
_coroutineQueue = GetComponent <CoroutineQueue>();
Leaderboard.Instance.LoadDataFromFile();
ModuleData.LoadDataFromFile();
ModuleData.WriteDataToFile();
TwitchPlaySettings.LoadDataFromFile();
SetupResponder(bombMessageResponder);
SetupResponder(postGameMessageResponder);
SetupResponder(missionMessageResponder);
SetupResponder(miscellaneousMessageResponder);
bombMessageResponder.parentService = this;
GameObject infoObject = new GameObject("TwitchPlays_Info");
infoObject.transform.parent = gameObject.transform;
_publicProperties = infoObject.AddComponent <TwitchPlaysProperties>();
_publicProperties.TwitchPlaysService = this;
if (TwitchPlaySettings.data.SkipModManagerInstructionScreen || IRCConnection.Instance.State == IRCConnectionState.Connected)
{
ModManagerManualInstructionScreen.HasShownOnce = true;
}
}
private bool HandleKey(string[] modulesBefore, IEnumerable <string> modulesAfter, FieldInfo keyTurned, FieldInfo otherKeyTurned, FieldInfo beforeKeyField, MethodInfo onKeyTurn, FieldInfo animatorField)
{
if (!GetValue(ActivatedField) || GetValue(keyTurned))
{
return(false);
}
KMBombInfo bombInfo = Module.BombComponent.GetComponent <KMBombInfo>();
KMBombModule bombModule = Module.BombComponent.GetComponent <KMBombModule>();
KMAudio bombAudio = Module.BombComponent.GetComponent <KMAudio>();
Animator keyAnimator = (Animator)animatorField.GetValue(Module.BombComponent.GetComponent(ComponentType));
if (TwitchPlaySettings.data.EnforceSolveAllBeforeTurningKeys &&
modulesAfter.Any(x => bombInfo.GetSolvedModuleNames().Count(x.Equals) != bombInfo.GetSolvableModuleNames().Count(x.Equals)))
{
keyAnimator.SetTrigger("WrongTurn");
bombAudio.PlaySoundAtTransform("WrongKeyTurnFK", Module.transform);
bombModule.HandleStrike();
return(false);
}
beforeKeyField.SetValue(null, TwitchPlaySettings.data.DisableTurnTheKeysSoftLock ? new string[0] : modulesBefore);
onKeyTurn.Invoke(Module.BombComponent.GetComponent(ComponentType), null);
if (GetValue(keyTurned))
{
//Check to see if any forbidden modules for this key were solved.
if (TwitchPlaySettings.data.DisableTurnTheKeysSoftLock && bombInfo.GetSolvedModuleNames().Any(modulesBefore.Contains))
{
bombModule.HandleStrike(); //If so, Award a strike for it.
}
if (!GetValue(otherKeyTurned))
{
return(false);
}
int modules = bombInfo.GetSolvedModuleNames().Count(x => RightAfterA.Contains(x) || LeftAfterA.Contains(x));
TwitchPlaySettings.AddRewardBonus((2 * modules * OtherModes.ScoreMultiplier).RoundToInt());
IRCConnection.SendMessage($"Reward increased by {modules * 2} for defusing module !{Code} ({bombModule.ModuleDisplayName}).");
}
else
{
keyAnimator.SetTrigger("WrongTurn");
bombAudio.PlaySoundAtTransform("WrongKeyTurnFK", Module.transform);
}
return(false);
}
private void AwardSolve(string userNickName, int ComponentValue)
{
if (OtherModes.ZenModeOn)
{
ComponentValue = (int)Math.Ceiling(ComponentValue * 0.20f);
}
if (userNickName == null)
{
TwitchPlaySettings.AddRewardBonus(ComponentValue);
}
else
{
string headerText = UnsupportedModule ? modInfo.moduleDisplayName : BombComponent.GetModuleDisplayName();
IRCConnection.Instance.SendMessage(TwitchPlaySettings.data.AwardSolve, Code, userNickName, ComponentValue, headerText);
string RecordMessageTone = $"Module ID: {Code} | Player: {userNickName} | Module Name: {headerText} | Value: {ComponentValue}";
Leaderboard.Instance?.AddSolve(userNickName);
if (!UserAccess.HasAccess(userNickName, AccessLevel.NoPoints))
{
Leaderboard.Instance?.AddScore(userNickName, ComponentValue);
}
else
{
TwitchPlaySettings.AddRewardBonus(ComponentValue);
}
TwitchPlaySettings.AppendToSolveStrikeLog(RecordMessageTone);
TwitchPlaySettings.AppendToPlayerLog(userNickName);
}
if (OtherModes.TimeModeOn)
{
float time = OtherModes.GetAdjustedMultiplier() * ComponentValue;
if (time < TwitchPlaySettings.data.TimeModeMinimumTimeGained)
{
BombCommander.timerComponent.TimeRemaining = BombCommander.CurrentTimer + TwitchPlaySettings.data.TimeModeMinimumTimeGained;
IRCConnection.Instance.SendMessage("Bomb time increased by the minimum {0} seconds!", TwitchPlaySettings.data.TimeModeMinimumTimeGained);
}
else
{
BombCommander.timerComponent.TimeRemaining = BombCommander.CurrentTimer + time;
IRCConnection.Instance.SendMessage("Bomb time increased by {0} seconds!", Math.Round(time, 1));
}
OtherModes.SetMultiplier(OtherModes.GetMultiplier() + TwitchPlaySettings.data.TimeModeSolveBonus);
}
}
public static void Status(TwitchBomb bomb, string user, bool isWhisper)
{
int currentReward = TwitchPlaySettings.GetRewardBonus();
if (OtherModes.TimeModeOn)
{
IRCConnection.SendMessage(string.Format(TwitchPlaySettings.data.BombStatusTimeMode, bomb.GetFullFormattedTime, bomb.GetFullStartingTime,
OtherModes.GetAdjustedMultiplier(), bomb.BombSolvedModules, bomb.BombSolvableModules, currentReward), user, !isWhisper);
}
else if (OtherModes.VSModeOn)
{
IRCConnection.SendMessage(string.Format(TwitchPlaySettings.data.BombStatusVsMode, bomb.GetFullFormattedTime,
bomb.GetFullStartingTime, OtherModes.goodHealth, OtherModes.evilHealth, currentReward), user, !isWhisper);
}
else
{
IRCConnection.SendMessage(string.Format(TwitchPlaySettings.data.BombStatus, bomb.GetFullFormattedTime, bomb.GetFullStartingTime,
bomb.StrikeCount, bomb.StrikeLimit, bomb.BombSolvedModules, bomb.BombSolvableModules, currentReward), user, !isWhisper);
}
}
public static IEnumerator Retry(string user, bool isWhisper)
{
var resultPage = Object.FindObjectOfType <ResultPage>();
if (!TwitchGame.RetryAllowed)
{
IRCConnection.SendMessage(TwitchPlaySettings.data.RetryModeOrProfileChange, user, isWhisper);
return(DoButton(resultPage.ContinueButton));
}
if (!TwitchPlaySettings.data.EnableRetryButton || resultPage.RetryButton == null)
{
IRCConnection.SendMessage(TwitchPlaySettings.data.RetryInactive, user, isWhisper);
return(DoButton(resultPage.ContinueButton));
}
else
{
TwitchPlaySettings.SetRetryReward();
return(DoButton(resultPage.RetryButton));
}
}
public void UpdateConfidence()
{
if (OtherModes.TimeModeOn)
{
float timedMultiplier = OtherModes.GetAdjustedMultiplier();
ConfidencePrefab.color = Color.yellow;
string conf = "x" + $"{timedMultiplier:0.0}";
string pts = "+" + $"{TwitchPlaySettings.GetRewardBonus():0}";
ConfidencePrefab.text = pts;
StrikesPrefab.color = Color.yellow;
StrikesPrefab.text = conf;
}
else if (OtherModes.ZenModeOn)
{
ConfidencePrefab.color = Color.yellow;
string pts = "+" + $"{TwitchPlaySettings.GetRewardBonus():0}";
ConfidencePrefab.text = pts;
StrikesPrefab.color = Color.red;
if (_currentBomb != null)
{
StrikesPrefab.text = _currentBomb.StrikeCount.ToString();
}
}
else if (OtherModes.VSModeOn)
{
int bossHealth = OtherModes.GetEvilHealth();
int teamHealth = OtherModes.GetGoodHealth();
StrikesPrefab.color = Color.cyan;
ConfidencePrefab.color = Color.red;
StrikesPrefab.text = $"{teamHealth} HP";
ConfidencePrefab.text = $"{bossHealth} HP";
}
else
{
ConfidencePrefab.color = Color.yellow;
string pts = $"+{TwitchPlaySettings.GetRewardBonus():0}";
ConfidencePrefab.text = pts;
}
}
private void AwardSolve(string userNickName, ICommandResponseNotifier responseNotifier, int ComponentValue)
{
string headerText = UnsupportedModule ? modInfo.moduleDisplayName : BombComponent.GetModuleDisplayName();
IRCConnection.SendMessage(TwitchPlaySettings.data.AwardSolve, Code, userNickName, ComponentValue, headerText);
string RecordMessageTone = $"Module ID: {Code} | Player: {userNickName} | Module Name: {headerText} | Value: {ComponentValue}";
responseNotifier.ProcessResponse(CommandResponse.EndComplete, ComponentValue);
TwitchPlaySettings.AppendToSolveStrikeLog(RecordMessageTone);
TwitchPlaySettings.AppendToPlayerLog(userNickName);
if (OtherModes.timedModeOn)
{
float multiplier = OtherModes.getMultiplier();
float time = multiplier * ComponentValue;
BombCommander.timerComponent.TimeRemaining = BombCommander.CurrentTimer + time;
IRCConnection.SendMessage("Bomb time increased by {0} seconds!", Math.Round(time, 1));
if (multiplier < 10)
{
multiplier = multiplier + 0.1f;
OtherModes.setMultiplier(multiplier);
}
}
}
public IEnumerator RespondToCommand(string userNickName, string message, ICommandResponseNotifier responseNotifier, bool isWhisper = false)
{
Selectable button = null;
message = message.ToLowerInvariant().Trim();
if (message.EqualsAny("!continue", "!back"))
{
button = ContinueButton;
}
else if (message.Equals("!retry"))
{
if (!TwitchPlaySettings.data.EnableRetryButton)
{
IRCConnection.Instance.SendMessage(TwitchPlaySettings.data.RetryInactive, userNickName, !isWhisper);
}
else
{
TwitchPlaySettings.SetRetryReward();
}
button = TwitchPlaySettings.data.EnableRetryButton ? RetryButton : ContinueButton;
}
if (button == null)
{
yield break;
}
// Press the button twice, in case the first is too early and skips the message instead
for (int i = 0; i < 2; i++)
{
DoInteractionStart(button);
yield return(new WaitForSeconds(0.1f));
DoInteractionEnd(button);
}
}
public static void NewBomb(string user, bool isWhisper)
{
if (!OtherModes.ZenModeOn)
{
IRCConnection.SendMessage($"Sorry {user}, the newbomb command is only allowed in Zen mode.", user, !isWhisper);
return;
}
if (isWhisper)
{
IRCConnection.SendMessage($"Sorry {user}, the newbomb command is not allowed in whispers.", user, !isWhisper);
return;
}
Leaderboard.Instance.GetRank(user, out var entry);
if (entry.SolveScore < TwitchPlaySettings.data.MinScoreForNewbomb && !UserAccess.HasAccess(user, AccessLevel.Defuser, true))
{
IRCConnection.SendMessage($"Sorry {user}, you don’t have enough points to use the newbomb command.");
}
else
{
TwitchPlaySettings.AddRewardBonus(-TwitchPlaySettings.GetRewardBonus());
foreach (var bomb in TwitchGame.Instance.Bombs.Where(x => GameRoom.Instance.IsCurrentBomb(x.BombID)))
{
bomb.Bomb.GetTimer().StopTimer();
}
foreach (var module in TwitchGame.Instance.Modules.Where(x => GameRoom.Instance.IsCurrentBomb(x.BombID)))
{
if (!module.Solved)
{
module.SolveSilently();
}
}
}
}
private MessageResponder GetActiveResponder(KMGameInfo.State state)
{
switch (state)
{
case KMGameInfo.State.Gameplay:
return(bombMessageResponder);
case KMGameInfo.State.Setup:
StartCoroutine(VanillaRuleModifier.Refresh());
StartCoroutine(MultipleBombs.Refresh());
return(missionMessageResponder);
case KMGameInfo.State.PostGame:
return(postGameMessageResponder);
case KMGameInfo.State.Transitioning:
ModuleData.LoadDataFromFile();
TwitchPlaySettings.LoadDataFromFile();
return(null);
default:
return(null);
}
}
public override IEnumerator ReportBombStatus()
{
if (_gameroom.GetType() == _factoryStaticModeType)
{
IEnumerator baseIEnumerator = base.ReportBombStatus();
while (baseIEnumerator.MoveNext())
{
yield return(baseIEnumerator.Current);
}
yield break;
}
InitializeOnLightsOn = false;
TwitchBomb bombHandle = TwitchGame.Instance.Bombs[0];
bombHandle.BombName = _infiniteMode ? "Infinite bombs incoming" : $"{BombCount} bombs incoming";
yield return(new WaitUntil(() => GetBomb != null || bombHandle.Bomb.HasDetonated));
if (bombHandle.Bomb.HasDetonated && !_zenMode)
{
yield break;
}
float currentBombTimer = bombHandle.CurrentTimer + 5;
int currentBombID = 1;
while (GetBomb != null)
{
Object currentBomb = GetBomb;
TimerComponent timerComponent = bombHandle.Bomb.GetTimer();
yield return(new WaitUntil(() => timerComponent.IsActive));
if (Math.Abs(currentBombTimer - bombHandle.CurrentTimer) > 1f)
{
yield return(null);
InitializeGameModes(true);
}
bool enableCameraWall = OtherModes.TrainingModeOn && IRCConnection.Instance.State == IRCConnectionState.Connected && TwitchPlaySettings.data.EnableFactoryTrainingModeCameraWall;
if (enableCameraWall != TwitchGame.ModuleCameras.CameraWallEnabled)
{
if (enableCameraWall)
{
TwitchGame.ModuleCameras.EnableCameraWall();
}
else
{
TwitchGame.ModuleCameras.DisableCameraWall();
}
}
bombHandle.BombName = $"Bomb {currentBombID} of {(_infiniteMode ? "∞" : BombCount.ToString())}";
IRCConnection.SendMessage($"Bomb {currentBombID++} of {(_infiniteMode ? "∞" : BombCount.ToString())} is now live.");
if (TwitchPlaySettings.data.EnableAutomaticEdgework)
{
bombHandle.FillEdgework();
}
else
{
bombHandle.EdgeworkText.text = TwitchPlaySettings.data.BlankBombEdgework;
}
if (OtherModes.Unexplodable)
{
bombHandle.StrikeLimit += bombHandle.StrikeCount;
}
IEnumerator bombHold = bombHandle.HoldBomb();
while (bombHold.MoveNext())
{
yield return(bombHold.Current);
}
Bomb bomb1 = (Bomb)_internalBombProperty.GetValue(currentBomb, null);
yield return(new WaitUntil(() =>
{
bool result = bomb1.HasDetonated || bomb1.IsSolved() || !TwitchGame.BombActive;
if (!result || OtherModes.TimeModeOn)
{
currentBombTimer = bomb1.GetTimer().TimeRemaining;
}
return result;
}));
if (!TwitchGame.BombActive)
{
yield break;
}
IRCConnection.SendMessage(TwitchGame.Instance.GetBombResult(false));
TwitchPlaySettings.SetRetryReward();
foreach (TwitchModule handle in TwitchGame.Instance.Modules)
{
//If the camera is still attached to the bomb component when the bomb gets destroyed, then THAT camera is destroyed as wel.
TwitchGame.ModuleCameras.UnviewModule(handle);
}
if (TwitchPlaySettings.data.EnableFactoryAutomaticNextBomb)
{
bombHold = bombHandle.LetGoBomb();
while (bombHold.MoveNext())
{
yield return(bombHold.Current);
}
yield return(new WaitForSeconds(1.0f));
//If for some reason we are somehow still holding the bomb, then the Let go did not register.
//Try again exactly one more time.
if (currentBomb == GetBomb)
{
bombHold = bombHandle.HoldBomb();
while (bombHold.MoveNext())
{
yield return(bombHold.Current);
}
yield return(new WaitForSeconds(0.10f));
bombHold = bombHandle.LetGoBomb();
while (bombHold.MoveNext())
{
yield return(bombHold.Current);
}
}
}
//If we are still holding the bomb, wait for it to actually be put down manually, or by a Twitch plays Drop bomb command.
while (currentBomb == GetBomb)
{
yield return(new WaitForSeconds(0.1f));
}
bombHandle.StartCoroutine(DestroyBomb(currentBomb));
if (GetBomb == null)
{
continue;
}
Bomb bomb = (Bomb)_internalBombProperty.GetValue(GetBomb, null);
InitializeBomb(bomb, true);
}
}
public string GetBombResult(bool lastBomb = true)
{
bool hasDetonated = false;
bool hasBeenSolved = true;
float timeStarting = float.MaxValue;
float timeRemaining = float.MaxValue;
string timeRemainingFormatted = "";
foreach (TwitchBomb bomb in Bombs)
{
if (bomb == null)
{
continue;
}
hasDetonated |= bomb.Bomb.HasDetonated;
hasBeenSolved &= bomb.IsSolved;
if (timeRemaining > bomb.CurrentTimer)
{
timeStarting = bomb.BombStartingTimer;
timeRemaining = bomb.CurrentTimer;
}
if (!string.IsNullOrEmpty(timeRemainingFormatted))
{
timeRemainingFormatted += ", " + bomb.GetFullFormattedTime;
}
else
{
timeRemainingFormatted = bomb.GetFullFormattedTime;
}
}
string bombMessage = "";
if (OtherModes.VSModeOn && (hasDetonated || hasBeenSolved))
{
OtherModes.Team winner = OtherModes.Team.Good;
if (OtherModes.GetGoodHealth() == 0)
{
winner = OtherModes.Team.Evil;
bombMessage = TwitchPlaySettings.data.VersusEvilHeader;
}
else if (OtherModes.GetEvilHealth() == 0)
{
winner = OtherModes.Team.Good;
bombMessage = TwitchPlaySettings.data.VersusGoodHeader;
}
bombMessage += string.Format(TwitchPlaySettings.data.VersusEndMessage,
winner == OtherModes.Team.Good ? "good" : "evil", timeRemainingFormatted);
bombMessage += TwitchPlaySettings.GiveBonusPoints();
if (winner == OtherModes.Team.Good)
{
bombMessage += TwitchPlaySettings.data.VersusGoodFooter;
}
else if (winner == OtherModes.Team.Evil)
{
bombMessage += TwitchPlaySettings.data.VersusEvilFooter;
}
if (lastBomb && hasBeenSolved)
{
Leaderboard.Instance.Success = true;
}
}
else if (hasDetonated)
{
bombMessage = string.Format(TwitchPlaySettings.data.BombExplodedMessage, timeRemainingFormatted);
Leaderboard.Instance.BombsExploded += Bombs.Count;
if (!lastBomb)
{
return(bombMessage);
}
Leaderboard.Instance.Success = false;
TwitchPlaySettings.ClearPlayerLog();
}
else if (hasBeenSolved)
{
bombMessage = string.Format(TwitchPlaySettings.data.BombDefusedMessage, timeRemainingFormatted);
Leaderboard.Instance.BombsCleared += Bombs.Count;
bombMessage += TwitchPlaySettings.GiveBonusPoints();
if (lastBomb)
{
Leaderboard.Instance.Success = true;
}
if (Leaderboard.Instance.CurrentSolvers.Count != 1)
{
return(bombMessage);
}
float elapsedTime = timeStarting - timeRemaining;
string userName = "";
foreach (string uName in Leaderboard.Instance.CurrentSolvers.Keys)
{
userName = uName;
break;
}
if (Leaderboard.Instance.CurrentSolvers[userName] == Leaderboard.RequiredSoloSolves * Bombs.Count && OtherModes.currentMode == TwitchPlaysMode.Normal)
{
Leaderboard.Instance.AddSoloClear(userName, elapsedTime, out float previousRecord);
if (TwitchPlaySettings.data.EnableSoloPlayMode)
{
//Still record solo information, should the defuser be the only one to actually defuse a 11 * bomb-count bomb, but display normal leaderboards instead if
//solo play is disabled.
TimeSpan elapsedTimeSpan = TimeSpan.FromSeconds(elapsedTime);
string soloMessage = string.Format(TwitchPlaySettings.data.BombSoloDefusalMessage, Leaderboard.Instance.SoloSolver.UserName, (int)elapsedTimeSpan.TotalMinutes, elapsedTimeSpan.Seconds);
if (elapsedTime < previousRecord)
{
TimeSpan previousTimeSpan = TimeSpan.FromSeconds(previousRecord);
soloMessage += string.Format(TwitchPlaySettings.data.BombSoloDefusalNewRecordMessage, (int)previousTimeSpan.TotalMinutes, previousTimeSpan.Seconds);
}
soloMessage += TwitchPlaySettings.data.BombSoloDefusalFooter;
ParentService.StartCoroutine(SendDelayedMessage(1.0f, soloMessage));
}
else
{
Leaderboard.Instance.ClearSolo();
}
}
else
{
Leaderboard.Instance.ClearSolo();
}
}
else
{
bombMessage = string.Format(TwitchPlaySettings.data.BombAbortedMessage, timeRemainingFormatted);
Leaderboard.Instance.Success = false;
TwitchPlaySettings.ClearPlayerLog();
}
return(bombMessage);
}
