From e2e03d21dca76138ce195d27598fe167732be31a Mon Sep 17 00:00:00 2001 From: kasi777 <44654531+kasi777@users.noreply.github.com> Date: Thu, 1 Nov 2018 00:26:21 +0100 Subject: [PATCH 001/278] Add files via upload --- PBChance.dll | Bin 18432 -> 47616 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/PBChance.dll b/PBChance.dll index aa2b3b2bdffb242a6e85d916325d9dd1025ca88a..de437782d174176499a88a6c86707edf2575a301 100644 GIT binary patch literal 47616 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 Ue}*Ky0rzjhssHc9zg7hP52dn-!vFvP From 071b8d1869969f00ed610be353ad361f7b443387 Mon Sep 17 00:00:00 2001 From: kasi777 <44654531+kasi777@users.noreply.github.com> Date: Thu, 1 Nov 2018 01:21:00 +0100 Subject: [PATCH 002/278] Update README.md --- README.md | 45 ++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 42 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 6a57fec..d29e622 100644 --- a/README.md +++ b/README.md @@ -3,7 +3,7 @@ PBChance Component for LiveSplit ## What it is: -PBChance is a LiveSplit component that displays the chance of obtaining a PB on your current run. Whenever you reset or split, it runs 10,000 simulations by randomly drawing the remaining splits from your splits in previous attempts, and computes how many of those would result in a PB. +PBChance is a LiveSplit component that displays the chance of obtaining a PB on your current run. Whenever you reset or split, it runs a variable number (100,000 recomended) of simulations by randomly drawing the remaining splits from your splits in previous attempts, and computes how many of those would result in a PB. ## Installation: @@ -12,6 +12,45 @@ PBChance is a LiveSplit component that displays the chance of obtaining a PB on 3. You can configure how many of your most recent attempts will be used to calculate the PB chance. Go to Layout Settings and click on the PB Chance tab. You can either have it use a percentage of your most recent attempts, or just a fixed number of your most recent attempts. 4. Speedrun! +## Features + +1. The calculation will perform in background in an own thread. Even if the number of calculations is set to a high number, LiveSplit will not stop during the calculation. +2. Debug file. To retrace the calculation. This includes: Headerdata, Failed Runs, clipped splits, added times, count of times per split, first generated route, results of successfully runs and 10 failures if possible and the result. + +## Advanced Settings: + +1. Consider at least # times per split. +This will fill up times, if there are not enough because of the Setting "Use the most recent [x] attempts." +Valid values: 1-999 Suggestion: 10-25 +2. Random sample survey # combinations. +The number of calculations. A lower number will calculate faster, a higher number gives a more stable result. +Valid values: 1-999,999 Suggestion: 100,000 +3. Update automatically every # seconds when the chance drops +During a run, PBChance compares the current split time with the best split time. If it's slower, and the chance is above zero, PBChance calculate in background the chance. If that chance becomes lower than the displayed one, the chance will be updated automatically every # seconds. 0 means as fast as possible. +Valid values: 0-999 Suggestion: 1 +4. Display survival chance +This will add percent number. The formula is [successfully runs]/[total remaining runs]. +5. # Newer split times are more important than old ones +Newer attempts will be selected more often during a simulated run. +Valid values: 0-100 Suggestion: 100 +6. Malus on failures # seconds +For each discontinued run, a failed split will be generated. It's added every time to a simulated run, if a failed split is selected. +Valid values: 0-999 Suggestion: it depends. Can be set to 0, if "Display survical chance" is set. +7. Only consider splits, which are faster than {bestSplit[s] x # percent} +Very slow split times will be eliminated. Should set to a number, which are clearly to slow for a normal run. Should be checked with the debug file (clipped splits), for the correct setting and result. +Valid values: 100-999 Suggestion: 150-250 + +## Debuging settings (should be 0 during regular runs) + +1. Timedifference # seconds +This will simply adds to the pb-time. +Valid values: -86400-86400 (24h) +2. Skip the newest attempts # +To see how high the chance was before. +Valid values: 0-99999 +3. Only calc to split # +The calculation will stop at split #, if it's not set to 0. + ## Pictures: [The component in action.](http://i.imgur.com/YIjln5P.png) @@ -20,6 +59,6 @@ PBChance is a LiveSplit component that displays the chance of obtaining a PB on ## Troubleshooting: -**It always displays "0%" or "-"** +**It displays E# no times found / too many failure attempts in S# [Segment name]* -You may need to configure the plugin to use a different number of attempts. For instance, it may not be reading any attempts in which you've completed a run. Additionally, you may have reset your split data at some point, which will remove the data necessary for PBChance to calculate its probability. If you want to debug the issue, try opening your splits file in a text editor (it's XML formatted). You may be able to spot missing splits, and it will inform you how to configure the PBChance component. +PBChance can't find historical times. This can in certain circumstances happen, if the Setting "Only consider splits, which are faster than {best Split x X percent" is set too low. Please set it to a higher number, eg. 200%. Skip the newest attempts should be set to 0. From d1e579e26367de187c0b5f321de21c04124f9dfc Mon Sep 17 00:00:00 2001 From: kasi777 <44654531+kasi777@users.noreply.github.com> Date: Thu, 1 Nov 2018 01:21:46 +0100 Subject: [PATCH 003/278] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index d29e622..ae8f87b 100644 --- a/README.md +++ b/README.md @@ -30,7 +30,7 @@ During a run, PBChance compares the current split time with the best split time. Valid values: 0-999 Suggestion: 1 4. Display survival chance This will add percent number. The formula is [successfully runs]/[total remaining runs]. -5. # Newer split times are more important than old ones +5. Newer split times are more important than old ones Newer attempts will be selected more often during a simulated run. Valid values: 0-100 Suggestion: 100 6. Malus on failures # seconds From d2649e9b4ce1d1ef809d4384ba4cf7a34ddbda47 Mon Sep 17 00:00:00 2001 From: kasi777 <44654531+kasi777@users.noreply.github.com> Date: Thu, 1 Nov 2018 01:23:32 +0100 Subject: [PATCH 004/278] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index ae8f87b..ab7dd7b 100644 --- a/README.md +++ b/README.md @@ -14,7 +14,7 @@ PBChance is a LiveSplit component that displays the chance of obtaining a PB on ## Features -1. The calculation will perform in background in an own thread. Even if the number of calculations is set to a high number, LiveSplit will not stop during the calculation. +1. The calculation will perform in background in an own thread. Even if the number of calculations is set to a high number, LiveSplit will not be stopped during the calculation. 2. Debug file. To retrace the calculation. This includes: Headerdata, Failed Runs, clipped splits, added times, count of times per split, first generated route, results of successfully runs and 10 failures if possible and the result. ## Advanced Settings: From 463fc245d43c8ab24a5d9d74856b7d10082a79cb Mon Sep 17 00:00:00 2001 From: kasi777 <44654531+kasi777@users.noreply.github.com> Date: Thu, 1 Nov 2018 01:24:55 +0100 Subject: [PATCH 005/278] Update README.md --- README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index ab7dd7b..992dc41 100644 --- a/README.md +++ b/README.md @@ -10,7 +10,8 @@ PBChance is a LiveSplit component that displays the chance of obtaining a PB on 1. Place PBChance.dll into the Components directory of your LiveSplit installation. 2. Open LiveSplit. Right click -> Edit Layout -> [Giant "+" Button] -> Information -> PB Chance 3. You can configure how many of your most recent attempts will be used to calculate the PB chance. Go to Layout Settings and click on the PB Chance tab. You can either have it use a percentage of your most recent attempts, or just a fixed number of your most recent attempts. -4. Speedrun! +4. For advanced setting read bellow. +5. Speedrun! ## Features From 715c7820e306ba3132085dfbd886b2a03e270f2a Mon Sep 17 00:00:00 2001 From: kasi777 <44654531+kasi777@users.noreply.github.com> Date: Thu, 1 Nov 2018 01:29:06 +0100 Subject: [PATCH 006/278] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 992dc41..51f450c 100644 --- a/README.md +++ b/README.md @@ -30,7 +30,7 @@ Valid values: 1-999,999 Suggestion: 100,000 During a run, PBChance compares the current split time with the best split time. If it's slower, and the chance is above zero, PBChance calculate in background the chance. If that chance becomes lower than the displayed one, the chance will be updated automatically every # seconds. 0 means as fast as possible. Valid values: 0-999 Suggestion: 1 4. Display survival chance -This will add percent number. The formula is [successfully runs]/[total remaining runs]. +This will display in addition a percent number. The formula is simply [successfully runs]/[total remaining runs]. 5. Newer split times are more important than old ones Newer attempts will be selected more often during a simulated run. Valid values: 0-100 Suggestion: 100 From f6942b66cfb1fa4def5d658f6e0bf639e2821a2a Mon Sep 17 00:00:00 2001 From: kasi777 <44654531+kasi777@users.noreply.github.com> Date: Thu, 1 Nov 2018 01:36:44 +0100 Subject: [PATCH 007/278] Update README.md --- README.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 51f450c..f823744 100644 --- a/README.md +++ b/README.md @@ -16,7 +16,7 @@ PBChance is a LiveSplit component that displays the chance of obtaining a PB on ## Features 1. The calculation will perform in background in an own thread. Even if the number of calculations is set to a high number, LiveSplit will not be stopped during the calculation. -2. Debug file. To retrace the calculation. This includes: Headerdata, Failed Runs, clipped splits, added times, count of times per split, first generated route, results of successfully runs and 10 failures if possible and the result. +2. Debug file. To retrace the calculation. This includes: Headerdata, Failed Runs, clipped splits, added times, count of times per split, first generated route, results of successfully runs and 10 failures if possible, the result, the detailed split times and the execution time. ## Advanced Settings: @@ -51,6 +51,8 @@ To see how high the chance was before. Valid values: 0-99999 3. Only calc to split # The calculation will stop at split #, if it's not set to 0. +4. Generate Debug File +This will generate a debug file "pbchance_debug.txt", and will be saved in your LiveSplit folder. You can open it with any text editor. See Features 2. for more information. ## Pictures: From adb1355d6e94a171b4aae7eab8f3b12158c6f0e1 Mon Sep 17 00:00:00 2001 From: kasi777 <44654531+kasi777@users.noreply.github.com> Date: Thu, 1 Nov 2018 01:37:58 +0100 Subject: [PATCH 008/278] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index f823744..accb070 100644 --- a/README.md +++ b/README.md @@ -26,7 +26,7 @@ Valid values: 1-999 Suggestion: 10-25 2. Random sample survey # combinations. The number of calculations. A lower number will calculate faster, a higher number gives a more stable result. Valid values: 1-999,999 Suggestion: 100,000 -3. Update automatically every # seconds when the chance drops +3. Update automatically every # seconds when the chance drops. During a run, PBChance compares the current split time with the best split time. If it's slower, and the chance is above zero, PBChance calculate in background the chance. If that chance becomes lower than the displayed one, the chance will be updated automatically every # seconds. 0 means as fast as possible. Valid values: 0-999 Suggestion: 1 4. Display survival chance From e52a90b5b30e7d46bf38342a97bee231cadd8191 Mon Sep 17 00:00:00 2001 From: kasi777 <44654531+kasi777@users.noreply.github.com> Date: Thu, 1 Nov 2018 01:38:32 +0100 Subject: [PATCH 009/278] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index accb070..b374ff2 100644 --- a/README.md +++ b/README.md @@ -10,7 +10,7 @@ PBChance is a LiveSplit component that displays the chance of obtaining a PB on 1. Place PBChance.dll into the Components directory of your LiveSplit installation. 2. Open LiveSplit. Right click -> Edit Layout -> [Giant "+" Button] -> Information -> PB Chance 3. You can configure how many of your most recent attempts will be used to calculate the PB chance. Go to Layout Settings and click on the PB Chance tab. You can either have it use a percentage of your most recent attempts, or just a fixed number of your most recent attempts. -4. For advanced setting read bellow. +4. Read bellow for advanced settings. 5. Speedrun! ## Features From 14cdc13d8793c0cb50122200f82ce47b52d9ef0a Mon Sep 17 00:00:00 2001 From: kasi777 <44654531+kasi777@users.noreply.github.com> Date: Thu, 1 Nov 2018 01:41:11 +0100 Subject: [PATCH 010/278] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index b374ff2..6ce39b1 100644 --- a/README.md +++ b/README.md @@ -27,7 +27,7 @@ Valid values: 1-999 Suggestion: 10-25 The number of calculations. A lower number will calculate faster, a higher number gives a more stable result. Valid values: 1-999,999 Suggestion: 100,000 3. Update automatically every # seconds when the chance drops. -During a run, PBChance compares the current split time with the best split time. If it's slower, and the chance is above zero, PBChance calculate in background the chance. If that chance becomes lower than the displayed one, the chance will be updated automatically every # seconds. 0 means as fast as possible. +During a run, PBChance compares the current split time with the best split time. If it's slower, and the chance is above zero, PBChance calculate in background the chance. If that chance becomes lower than the displayed one, the chance will be updated automatically. 0 means as fast as possible. Valid values: 0-999 Suggestion: 1 4. Display survival chance This will display in addition a percent number. The formula is simply [successfully runs]/[total remaining runs]. From a175bede378993a857c42f40326f2ad84d47eebc Mon Sep 17 00:00:00 2001 From: kasi777 <44654531+kasi777@users.noreply.github.com> Date: Thu, 1 Nov 2018 01:49:15 +0100 Subject: [PATCH 011/278] Update README.md --- README.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 6ce39b1..ed1f8fe 100644 --- a/README.md +++ b/README.md @@ -36,11 +36,13 @@ Newer attempts will be selected more often during a simulated run. Valid values: 0-100 Suggestion: 100 6. Malus on failures # seconds For each discontinued run, a failed split will be generated. It's added every time to a simulated run, if a failed split is selected. -Valid values: 0-999 Suggestion: it depends. Can be set to 0, if "Display survical chance" is set. +Valid values: 0-999 Suggestion: it depends. Can be set to 0, if "Display survival chance" is set. 7. Only consider splits, which are faster than {bestSplit[s] x # percent} Very slow split times will be eliminated. Should set to a number, which are clearly to slow for a normal run. Should be checked with the debug file (clipped splits), for the correct setting and result. Valid values: 100-999 Suggestion: 150-250 +Hint: The displaying chance on the start should be realistic. But rather too small than too high, for more motivation during a run. Try with these settings to optimize the chance estimation. + ## Debuging settings (should be 0 during regular runs) 1. Timedifference # seconds From 77cc27a509bb2a21b63a29a11f5a37d03bdaa7dc Mon Sep 17 00:00:00 2001 From: kasi777 <44654531+kasi777@users.noreply.github.com> Date: Thu, 1 Nov 2018 02:15:56 +0100 Subject: [PATCH 012/278] Add files via upload --- PBChance/UI/Components/PBChanceComponent.cs | 409 ++++++++-- .../Components/PBChanceSettings.Designer.cs | 771 +++++++++++++++++- PBChance/UI/Components/PBChanceSettings.cs | 112 ++- 3 files changed, 1174 insertions(+), 118 deletions(-) diff --git a/PBChance/UI/Components/PBChanceComponent.cs b/PBChance/UI/Components/PBChanceComponent.cs index faf895c..e54b0d2 100644 --- a/PBChance/UI/Components/PBChanceComponent.cs +++ b/PBChance/UI/Components/PBChanceComponent.cs @@ -9,6 +9,8 @@ using System.Drawing; using System.Windows.Forms; using System.Xml; +using System.Threading; + namespace PBChance.UI.Components { @@ -19,6 +21,12 @@ class PBChanceComponent : IComponent protected LiveSplitState State; protected Random rand; protected string category; + protected Thread thread; + protected bool KeepAlive; + protected double fLiveChanceAct; + protected double fLiveChanceAvg; + protected double fLastUpdate; + protected bool bCheckUpdate; string IComponent.ComponentName => "PB Chance"; @@ -48,10 +56,18 @@ void IComponent.SetSettings(XmlNode settings) Settings.SetSettings(settings); } + double factorial(int x) + { + double factorial = 1; + for (int i = 2; i <= x; i++) + factorial *= i; + return factorial; + } + public PBChanceComponent(LiveSplitState state) { State = state; - InternalComponent = new InfoTextComponent("PB Chance .", "0.0%") + InternalComponent = new InfoTextComponent("PB Chance", "0.0%") { AlternateNameText = new string[] { @@ -71,50 +87,92 @@ public PBChanceComponent(LiveSplitState state) state.OnStart += OnStart; state.RunManuallyModified += OnRunManuallyModified; - Recalculate(); + StartRecalculate(true); } private void OnRunManuallyModified(object sender, EventArgs e) { - Recalculate(); + StartRecalculate(true); } private void OnSettingChanged(object sender, EventArgs e) { - Recalculate(); + StartRecalculate(true); } private void OnStart(object sender, EventArgs e) { - Recalculate(); + StartRecalculate(true); } protected void OnUndoSplit(object sender, EventArgs e) { - Recalculate(); + StartRecalculate(true); } protected void OnSkipSplit(object sender, EventArgs e) { - Recalculate(); + StartRecalculate(true); } protected void OnReset(object sender, TimerPhase value) { - Recalculate(); + StartRecalculate(true); } protected void OnSplit(object sender, EventArgs e) { - Recalculate(); + StartRecalculate(true); + } + + protected void StartRecalculate(bool bForceNewcalc) + { + if (thread != null) + if (thread.ThreadState == ThreadState.Running) + { + if (!bForceNewcalc) return; + KeepAlive = false; + thread.Join(); + } + KeepAlive = true; + bCheckUpdate = false; + fLiveChanceAvg = 0; + thread = new Thread(new ThreadStart(Recalculate)); + thread.Start(); } protected void Recalculate() { + int iSurvicalFailure = 0, iSurvicalSuccess = 0, iMaxAtempts, iCurrentSplitIndex = State.CurrentSplitIndex < 0 ? 0 : State.CurrentSplitIndex, iMaxSplit, i, iLastSegment, iAttempt; //, aktSurvival, sumSurvival = 0; + double fSec; + string text = ""; var watch = System.Diagnostics.Stopwatch.StartNew(); + System.String sWriteDebug1="", sWriteDebug2=""; + Time? split; + + if (Settings.SamplesCount == 0) // not configured, load default values + { + Settings.UsePercentOfAttempts = false; + Settings.UseFixedAttempts = true; + Settings.IgnoreRunCount = false; + Settings.AttemptCount = 50; + Settings.MalusCount = 30; + Settings.SplitclipCount = 150; + Settings.TimediffCount = 0; + Settings.SamplesCount = 100000; + Settings.iMinTimes = 20; + Settings.iUpdate = 1; + Settings.iSplitsvalue = 100; + } + + if (Settings.iCalcToSplit == 0 || Settings.iCalcToSplit > State.Run.Count) iMaxSplit = State.Run.Count; else iMaxSplit = Settings.iCalcToSplit; + + // Array of the count of valid split times per split (without failing attemps) + int[] lCountSplits = new int[iMaxSplit]; + // Get the current Personal Best, if it exists Time pb = State.Run.Last().PersonalBestSplitTime; - - if(pb[State.CurrentTimingMethod] == TimeSpan.Zero) + + if (pb[State.CurrentTimingMethod] == TimeSpan.Zero) { // No personal best, so any run will PB InternalComponent.InformationValue = "100%"; @@ -122,126 +180,276 @@ protected void Recalculate() } // Create the lists of split times - List[] splits = new List[State.Run.Count]; - for(int i=0; i[] splits = new List[iMaxSplit]; + for (i = 0; i < iMaxSplit; i++) splits[i] = new List(); - } // Find the range of attempts to gather times from - int lastAttempt = State.Run.AttemptHistory.Count; - int runCount = State.Run.AttemptHistory.Count; + int firstAttempt = 1, lastAttempt = State.Run.AttemptHistory.Count - Settings.iSkipNewest; if (!Settings.IgnoreRunCount) { - runCount = State.Run.AttemptCount; - if (runCount > State.Run.AttemptHistory.Count) + if (Settings.UseFixedAttempts) // Fixed number of attempts { - runCount = State.Run.AttemptHistory.Count; + firstAttempt = lastAttempt - Settings.AttemptCount + 1; + if (firstAttempt < 1) firstAttempt = 1; } - } - int firstAttempt = lastAttempt / 2; - if(Settings.UseFixedAttempts) - { - // Fixed number of attempts - firstAttempt = lastAttempt - Settings.AttemptCount; - - if (firstAttempt < State.Run.GetMinSegmentHistoryIndex()) + else // Percentage of attempts { - firstAttempt = State.Run.GetMinSegmentHistoryIndex(); + firstAttempt = lastAttempt - lastAttempt * (Settings.AttemptCount - 1 - Settings.iSkipNewest) / 100; + if (firstAttempt < 1) firstAttempt = 1; } } - else + + if (Settings.bDebug) { - // Percentage of attempts - firstAttempt = lastAttempt - runCount * Settings.AttemptCount / 100; - if(firstAttempt < State.Run.GetMinSegmentHistoryIndex()) - { - firstAttempt = State.Run.GetMinSegmentHistoryIndex(); - } + System.IO.File.WriteAllText(@"pbchance_Debug.txt", "AdjustedStartTime: " + State.AdjustedStartTime + " AttemptEnded: " + State.AttemptEnded + " AttemptStarted: " + State.AttemptStarted + " \r\nCurrentAttemptDuration: " + State.CurrentAttemptDuration + " CurrentComparison: " + State.CurrentComparison + " CurrentPhase: " + State.CurrentPhase + "\r\n");//" CurrentHotkeyProfile: " + State.CurrentHotkeyProfile.ToString() + System.IO.File.AppendAllText(@"pbchance_Debug.txt", "CurrentSplit: " + State.CurrentSplit + " CurrentSplitIndex: " + State.CurrentSplitIndex + " CurrentTime: " + State.CurrentTime + " \r\nCurrentTimingMethod: " + State.CurrentTimingMethod + " GameTimePauseTime: " + State.GameTimePauseTime + " IsGameTimeInitialized: " + State.IsGameTimeInitialized + " \r\nIsGameTimePaused: " + State.IsGameTimePaused + " Layout: " + State.Layout + " LayoutSettings: " + State.LayoutSettings + " \r\nLoadingTimes: " + State.LoadingTimes + " PauseTime: " + State.PauseTime + " Run: " + State.Run + " Settings: " + State.Settings + " \r\nStartTime: " + State.StartTime + " StartTimeWithOffset: " + State.StartTimeWithOffset + " TimePausedAt: " + State.TimePausedAt + "\r\n"); + System.IO.File.AppendAllText(@"pbchance_Debug.txt", "Attempts: " + firstAttempt + " to " + lastAttempt + " Malus: " + Settings.MalusCount + " Splitclip: " + Settings.SplitclipCount + " Timediff: " + Settings.TimediffCount + " Samples: " + Settings.SamplesCount + " Survival: " + Settings.bSurvival + " Rebalancing: " + Settings.iOptimistic + "\r\n"); + System.IO.File.AppendAllText(@"pbchance_Debug.txt", "bValueRuns: " + Settings.bValueRuns + " Min Times per Split: " + Settings.iMinTimes + " Automatic Update every: " + Settings.iUpdate + "s More Value on newer Splits: " + Settings.iSplitsvalue + " Skip newest Splits: " + Settings.iSkipNewest + "\r\n\r\n--- Failed Runs --- " + watch.ElapsedMilliseconds + "ms\r\n"); } // Gather split times - for (int a = firstAttempt; a < lastAttempt; a++) + for (int a = firstAttempt; a <= lastAttempt; a++) { - int lastSegment = -1; + iLastSegment = -1; - // Get split times from a single attempt - for (int segment = 0; segment < State.Run.Count; segment++) + for (int segment = iCurrentSplitIndex; segment < iMaxSplit; segment++) { if (State.Run[segment].SegmentHistory == null || State.Run[segment].SegmentHistory.Count == 0) { - InternalComponent.InformationValue = "-"; - return; + if (State.Run[segment].BestSegmentTime[State.CurrentTimingMethod].HasValue) + { + splits[segment].Add(State.Run[segment].BestSegmentTime); // no split times available, take the best split time, display a warning + InternalComponent.InformationValue = "E1 not times found in S" + (1 + segment) + " " + State.Run[segment].Name; + } + else + { + InternalComponent.InformationValue = "E2 not best time found in S" + (1 + segment) + " " + State.Run[segment].Name; + return; + } } - - if (State.Run[segment].SegmentHistory.ContainsKey(a) && State.Run[segment].SegmentHistory[a][State.CurrentTimingMethod] > TimeSpan.Zero) + else if (State.Run[segment].SegmentHistory.ContainsKey(a) && State.Run[segment].SegmentHistory[a][State.CurrentTimingMethod] > TimeSpan.Zero) { - splits[segment].Add(State.Run[segment].SegmentHistory[a]); - lastSegment = segment; + if (State.Run[segment].BestSegmentTime[State.CurrentTimingMethod].HasValue) + { + if ((State.Run[segment].SegmentHistory[a][State.CurrentTimingMethod].Value.TotalSeconds <= Settings.SplitclipCount * 0.01 * State.Run[segment].BestSegmentTime[State.CurrentTimingMethod].Value.TotalSeconds)) // | (State.Run[segment].BestSegmentTime[State.CurrentTimingMethod].Value.TotalSeconds < 60)) + { + splits[segment].Add(State.Run[segment].SegmentHistory[a]); // add a valid split time + lCountSplits[segment]++; + } + else + if (Settings.bDebug) sWriteDebug2 += "Segment: " + segment.ToString("00") + " Attempt: " + a.ToString("0000") + " Factor: " + Math.Round(State.Run[segment].SegmentHistory[a][State.CurrentTimingMethod].Value.TotalSeconds / State.Run[segment].BestSegmentTime[State.CurrentTimingMethod].Value.TotalSeconds, 2).ToString("0.00") + " Best: " + State.Run[segment].BestSegmentTime[State.CurrentTimingMethod].Value.TotalSeconds.ToString("000.000") + " Time: " + State.Run[segment].SegmentHistory[a][State.CurrentTimingMethod].Value.TotalSeconds.ToString("0000.000") + " Name: " + State.Run[segment].Name + "\r\n"; + } + else // no Best Time, then allways add + { + splits[segment].Add(State.Run[segment].SegmentHistory[a]); + lCountSplits[segment]++; + } + iLastSegment = segment; } } - - if (lastSegment < State.Run.Count - 1) - { - // Run didn't finish, add "reset" for the last known split - splits[lastSegment + 1].Add(null); + if (iMaxSplit > 1 && ((iLastSegment < iMaxSplit - 1 && iLastSegment >= iCurrentSplitIndex) || (iLastSegment == -1 && iCurrentSplitIndex == 0))) + { // Run didn't finish, add a failure for the last known split + if (iLastSegment == -1) iLastSegment = 0; + splits[iLastSegment + 1].Add(null); + iSurvicalFailure++; + if (Settings.bDebug) sWriteDebug1 += "#" + iSurvicalFailure.ToString("00") + ": Attempt: " + a.ToString("00") + " Segment: " + (iLastSegment + 1).ToString("00") + " LastSegment: " + iLastSegment.ToString("00") + "\r\n"; } + else + if (iLastSegment >= 0) iSurvicalSuccess++; } - // Calculate probability of PB - int success = 0; - for (int i = 0; i < 10000; i++) + if (Settings.bDebug) { - // Get current time as a baseline - Time test = State.CurrentTime; - if (test[State.CurrentTimingMethod] < TimeSpan.Zero) - { - test[State.CurrentTimingMethod] = TimeSpan.Zero; - } + System.IO.File.AppendAllText(@"pbchance_Debug.txt", sWriteDebug1 + "\r\n--- Clipping segments --- " + watch.ElapsedMilliseconds + "ms\r\n" + sWriteDebug2); + sWriteDebug1 = "\r\n--- Added times --- " + watch.ElapsedMilliseconds + "ms\r\n"; + } - // Add random split times for each remaining segment - for (int segment = 0; segment < State.Run.Count; segment++) + // add older split times, if there are not enough (Setting: at least X split times) + for (int segment = iCurrentSplitIndex; segment < iMaxSplit; segment++) + if (lCountSplits[segment] < Settings.iMinTimes) // splits[segment].Count contains also failures, lCountSplits[] contains no failures { - if (segment < State.CurrentSplitIndex) - { - continue; + for (i = firstAttempt - 1; i >= 0 && lCountSplits[segment] < Settings.iMinTimes; i--) + if (State.Run[segment].BestSegmentTime[State.CurrentTimingMethod].HasValue) + if (State.Run[segment].SegmentHistory.ContainsKey(i) && State.Run[segment].SegmentHistory[i][State.CurrentTimingMethod] > TimeSpan.Zero) + if (State.Run[segment].BestSegmentTime[State.CurrentTimingMethod].HasValue) + if ((State.Run[segment].SegmentHistory[i][State.CurrentTimingMethod].Value.TotalSeconds <= Settings.SplitclipCount * 0.01 * State.Run[segment].BestSegmentTime[State.CurrentTimingMethod].Value.TotalSeconds)) // | (State.Run[segment].BestSegmentTime[State.CurrentTimingMethod].Value.TotalSeconds < 60)) + if (State.Run[segment].SegmentHistory[i][State.CurrentTimingMethod].HasValue) // valid split time found + { + splits[segment].Insert(0, State.Run[segment].SegmentHistory[i]); + if (Settings.bDebug) sWriteDebug1 += "Segment: " + segment.ToString("00") + " Attempt: " + i.ToString("0000") + " Added Time: " + State.Run[segment].SegmentHistory[i][State.CurrentTimingMethod].Value.ToString() + " Count of Valid/Total Times: " + lCountSplits[segment].ToString("0000") + "/" + splits[segment].Count.ToString("0000") + " Name: " + State.Run[segment].Name + "\r\n"; + lCountSplits[segment]++; + } + if (splits[segment].Count == 0 && State.Run[segment].BestSegmentTime[State.CurrentTimingMethod].HasValue) + { // no times found, but at least a best split time, display a warning, take the best split time + InternalComponent.InformationValue = "E3 no times found in S" + (1 + segment) + " " + State.Run[segment].Name; + splits[segment].Add(State.Run[segment].BestSegmentTime); } + } + if (KeepAlive == false) return; // cancel calculation if new thread is requested + + if (Settings.bDebug) // Count of Times per Split + { + System.IO.File.AppendAllText(@"pbchance_Debug.txt", sWriteDebug1); + sWriteDebug1 = "\r\n--- Count of Times per Split --- " + watch.ElapsedMilliseconds + "ms\r\n"; + for (int segment = iCurrentSplitIndex; segment < iMaxSplit; segment++) + sWriteDebug1+="Segment: " + segment.ToString("00") + " Count of Valid/Total Times: " + lCountSplits[segment].ToString("0000") + "/" + splits[segment].Count.ToString("0000") + " Name: " + State.Run[segment].Name + "\r\n"; + System.IO.File.AppendAllText(@"pbchance_Debug.txt", sWriteDebug1); + + //Write all Split Times + sWriteDebug2 = "\r\n\r\n\r\n--- Detailed Split Times ---\r\n"; + for (int segment = iCurrentSplitIndex; segment < iMaxSplit; segment++) + for (int attempt = 0; attempt < splits[segment].Count; attempt++) + if (splits[segment][attempt].HasValue) + sWriteDebug2 += "Segment: " + segment + " Attempt:" + attempt.ToString("000") + " Time:" + splits[segment][attempt].Value[State.CurrentTimingMethod].Value + "\r\n"; + } + + // Calculate probability of PB + if (Settings.bDebug) sWriteDebug1 = "\r\n--- First generated Route (" + Settings.SamplesCount + " Routes in total) --- " + watch.ElapsedMilliseconds + "ms\r\n"; + int iFaster = 0, iSlower = 0, iCountMalus = 0; + double fSecStart = 0, fSecMalus, fTotalBestTime = 0; + + // Total Best Time + for (int segment = iCurrentSplitIndex; segment < iMaxSplit; segment++) + fTotalBestTime += State.Run[segment].BestSegmentTime[State.CurrentTimingMethod].Value.TotalMilliseconds / 1000; - if(splits[segment].Count == 0) + // Get current time as a baseline + Time test = State.CurrentTime; + + if (bCheckUpdate) iCurrentSplitIndex++; // background calculation, then calculate starting next split + + if (State.CurrentSplitIndex > 0) + { + if (test.RealTime == null) test = State.CurrentTime; + test = State.Run[iCurrentSplitIndex - 1].SplitTime; + } + else + test[State.CurrentTimingMethod] = TimeSpan.Zero; + + if (test[State.CurrentTimingMethod].HasValue && !bCheckUpdate) // split hasn't skipped + fSecStart = test[State.CurrentTimingMethod].Value.TotalMilliseconds / 1000; + else // use the actual time, possible to read the skipping time? + fSecStart = State.CurrentTime[State.CurrentTimingMethod].Value.TotalMilliseconds / 1000; + + for (i = 0; i < Settings.SamplesCount; i++) + { + if (KeepAlive == false) return; // cancel calculation if new thread is requested + fSecMalus = 0; + fSec = 0; + iAttempt = 0; + + // Add random split times for each remaining segment + for (int segment = iCurrentSplitIndex; segment < iMaxSplit; segment++) + { + if (splits[segment].Count == 0) // This split contains no split times, so we cannot calculate a probability { - // This split contains no split times, so we cannot calculate a probability - InternalComponent.InformationValue = "-"; + InternalComponent.InformationValue = "E4 no times found in S" + (1 + segment) + " " + State.Run[segment].Name; // + " split contains no times" return; } - int attempt = rand.Next(splits[segment].Count); - Time? split = splits[segment][attempt]; - if (split == null) + iMaxAtempts = 10000; // max tries to catch a valid time + do + { + iMaxAtempts--; + do { // select newer attempts more often + iAttempt = rand.Next(splits[segment].Count); + //} while (Math.Pow((attempt+1)/(splits[segment].Count * 1.0), Settings.iSplitsvalue * .05) < rand.Next(100) * .01); // exponential, maybe as an option, but this is slower + } while ((iAttempt + 1) / (splits[segment].Count * 1.0) < rand.Next(Settings.iSplitsvalue) * .01); // linear + + split = splits[segment][iAttempt]; + + if (split == null) // split is a failure, add a malus + { + fSecMalus += Settings.MalusCount; + iCountMalus++; + if (Settings.bDebug && i == 0) sWriteDebug1 += "Segment: " + segment.ToString("00") + " Attempt: " + iAttempt.ToString("0000") + " Route: " + i + " Name: " + State.Run[segment].Name + " Failure " + iCountMalus + " add " + Settings.MalusCount + "s\r\n"; + } + } while (split == null & iMaxAtempts > 0); + if (split != null) // found split times { - // Split is a reset, so count it as a failure - test += pb; - break; + //test += split.Value; + iAttempt++; + + if (split.Value[State.CurrentTimingMethod].HasValue) // add the time + fSec += split.Value[State.CurrentTimingMethod].Value.TotalMilliseconds / 1000; + + if (Settings.bDebug && i == 0) sWriteDebug1 += "Segment: " + segment.ToString("00") + " Attempt: " + iAttempt.ToString("0000") + " Route: " + i + " Duration: " + split.Value.RealTime.ToString() + " = " + (split.Value.RealTime.Value.TotalMilliseconds / 1000).ToString("000.000") + "ms" + " --- BestTime=" + State.Run[segment].BestSegmentTime[State.CurrentTimingMethod].Value.TotalSeconds.ToString("000.000") + " Name: " + State.Run[segment].Name + "\r\n"; } else { - // Add the split time - test += split.Value; + InternalComponent.InformationValue = "E5 too many failure attempts S" + (1 + segment) + " " + State.Run[segment].Name; // + " split contains no times" + return; } } + if (Settings.bDebug && i == 0) System.IO.File.AppendAllText(@"pbchance_Debug.txt", sWriteDebug1); + if (Settings.bDebug && i == 0) sWriteDebug1 = "\r\n--- Results of successfully runs and 10 failures if possible --- " + watch.ElapsedMilliseconds + "ms\r\n"; - if (test[State.CurrentTimingMethod] < pb[State.CurrentTimingMethod]) + // Check if the time is faster than pb + if (fSec + fSecStart + fSecMalus <= pb[State.CurrentTimingMethod].Value.TotalMilliseconds / 1000 + Settings.TimediffCount) + { + iFaster++; + if (Settings.bDebug && iFaster <= 10) // write first ten faster times + sWriteDebug1 += "Run: " + i.ToString("00000") + " Total Time: (" + fSec.ToString("0000.000") + "+" + fSecStart.ToString() + "+" + fSecMalus.ToString("0000.000") + ") = " + (fSec + fSecStart + fSecMalus).ToString("0.000") + " < " + (pb[State.CurrentTimingMethod].Value.TotalMilliseconds / 1000 + Settings.TimediffCount * fSec / (fSec + fSecStart)).ToString("0.00") + " = (" + pb[State.CurrentTimingMethod].Value.TotalMilliseconds / 1000 + " + " + (Settings.TimediffCount * fSec / (fSec + fSecStart)).ToString("0.00") + ") success" + (Settings.iOptimistic == 0 ? "\r\n" : ""); + } + else { - success++; + iSlower++; + if (Settings.bDebug && iSlower <= 10) // write first ten slower times + sWriteDebug1 += "Run: " + i.ToString("00000") + " Total Time: (" + fSec.ToString("0000.000") + "+" + fSecStart.ToString() + "+" + fSecMalus.ToString("0000.000") + ") = " + (fSec + fSecStart + fSecMalus).ToString("0.000") + " > " + (pb[State.CurrentTimingMethod].Value.TotalMilliseconds / 1000 + Settings.TimediffCount * fSec / (fSec + fSecStart)).ToString("0.00") + " = (" + pb[State.CurrentTimingMethod].Value.TotalMilliseconds / 1000 + " + " + (Settings.TimediffCount * fSec / (fSec + fSecStart)).ToString("0.00") + ") failure" + (Settings.iOptimistic == 0 ? "\r\n" : ""); } } - double prob = success / 10000.0; - string text = (prob * 100.0).ToString() + "%"; - if (Settings.DisplayOdds && prob > 0) + if (iFaster == 0 & iSlower == 0) // no more remaining times, check for a new pb { - text += " (1 in " + Math.Round(1 / prob, 2).ToString() + ")"; + if (fSecStart < pb[State.CurrentTimingMethod].Value.TotalMilliseconds/1000) + InternalComponent.InformationValue = "100% PB"; + else + InternalComponent.InformationValue = "0%"; + return; + } + else // display results + { + double fProb = iFaster / (iFaster + iSlower + 0.0); + if (bCheckUpdate) { // background calculation + if (fLiveChanceAvg>0) fLiveChanceAvg = (fLiveChanceAvg + fProb) * .5; + else fLiveChanceAvg = fProb; + //InternalComponent.InformationValue = fProb + "|" + fLiveChanceAvg + "|" + fLiveChanceAct; + if (fProb > fLiveChanceAvg || fLiveChanceAvg > fLiveChanceAct) // do not display, if chance is higher than the displaying chance //&& !(fProb==0 && fLiveChanceAvg==0 && fLiveChanceAct>0) + return; + + if (fProb > 0) + { + if (fProb > .1 && fProb < .9) // round a place behind the comma, in the range of 10%-90% + fProb = Math.Round(fLiveChanceAvg, 3); + else + fProb = fLiveChanceAvg; + } + } + fLiveChanceAct = fProb; + + if (fProb == 0) text += "0%"; // Zero success, display 0% instead of 0.00%. 0.00% will be displayed if count of samples are >> 10,000 and only a few successes + else text += (fProb * 100).ToString("0.00") + "%"; + + if (Settings.DisplayOdds && fProb > 0) // Displaying odds + text += " (1 in " + Math.Round(1 / fProb, 1).ToString() + ")"; + + if (Settings.bSurvival) // Calculate survival chance + { + text += " / " + Math.Round(iSurvicalSuccess / (iSurvicalSuccess + iSurvicalFailure + .0) * 100, 0).ToString() + "%"; + if (InternalComponent.InformationName != "PB / Survival Chance") + InternalComponent.InformationName = "PB / Survival Chance"; + } else if (InternalComponent.InformationName != "PB Chance") + InternalComponent.InformationName = "PB Chance"; + + if (Settings.bDebug) + { + sWriteDebug1 += "\r\n\r\n" + InternalComponent.InformationName + ": " + text + " SuccessCount: " + iFaster + " FailCount: " + iSlower + " MalusCount: " + iCountMalus + "\r\n\r\nExecution time: " + watch.ElapsedMilliseconds + "ms"; + System.IO.File.AppendAllText(@"pbchance_Debug.txt", sWriteDebug1 + sWriteDebug2); + Settings.bDebug = false; + } + + InternalComponent.InformationValue = text; } - InternalComponent.InformationValue = text; } void IComponent.DrawHorizontal(Graphics g, LiveSplitState state, float height, Region clipRegion) @@ -256,7 +464,7 @@ void IComponent.DrawVertical(Graphics g, LiveSplitState state, float width, Regi PrepareDraw(state, LayoutMode.Vertical); InternalComponent.DrawVertical(g, state, width, clipRegion); } - + void PrepareDraw(LiveSplitState state, LayoutMode mode) { InternalComponent.NameLabel.ForeColor = state.LayoutSettings.TextColor; @@ -269,16 +477,43 @@ void IComponent.Update(IInvalidator invalidator, LiveSplitState state, float wid string newCategory = State.Run.GameName + State.Run.CategoryName; if (newCategory != category) { - Recalculate(); + StartRecalculate(true); category = newCategory; } - + + // check the update frequency + if (Math.Abs(fLastUpdate - State.CurrentTime[State.CurrentTimingMethod].Value.TotalMilliseconds) >= Settings.iUpdate * 1000) + { + double fTimer=0; + int iCurrentSplitIndex = State.CurrentSplitIndex - 1; + fLastUpdate = State.CurrentTime[State.CurrentTimingMethod].Value.TotalMilliseconds; + + if (iCurrentSplitIndex > 0) // calculate the actual split time + if (State.Run[iCurrentSplitIndex].SplitTime[State.CurrentTimingMethod].HasValue) + //if (State.CurrentTime[State.CurrentTimingMethod].HasValue) // seems this is not necessary + if (iCurrentSplitIndex >= 0) + fTimer = State.CurrentAttemptDuration.TotalMilliseconds - State.Run[iCurrentSplitIndex].SplitTime[State.CurrentTimingMethod].Value.TotalMilliseconds; + else fTimer = State.CurrentAttemptDuration.TotalMilliseconds; + else fTimer = 999999999999999999999999999999999999999999999999999999.9; // determination of split time isn't possible now + else fTimer = State.CurrentAttemptDuration.TotalMilliseconds; + + // background calculation, if actual split time is slower than best split time, and the actual chance is > 0 + if (fTimer > State.Run[iCurrentSplitIndex + 1].BestSegmentTime[State.CurrentTimingMethod].Value.TotalMilliseconds && fLiveChanceAct > 0) + if (thread == null || thread.ThreadState != ThreadState.Running) // do it if the thread isn't running + { + KeepAlive = true; + bCheckUpdate = true; // tell Recalculate(), that's a background calculation + thread = new Thread(new ThreadStart(Recalculate)); + thread.Start(); + } + } + InternalComponent.Update(invalidator, state, width, height, mode); } void IDisposable.Dispose() { - + } } } diff --git a/PBChance/UI/Components/PBChanceSettings.Designer.cs b/PBChance/UI/Components/PBChanceSettings.Designer.cs index 8b0c2b5..533ea6c 100644 --- a/PBChance/UI/Components/PBChanceSettings.Designer.cs +++ b/PBChance/UI/Components/PBChanceSettings.Designer.cs @@ -35,13 +35,72 @@ private void InitializeComponent() this.CreditsLabel = new System.Windows.Forms.Label(); this.DisplayOddsCheckbox = new System.Windows.Forms.CheckBox(); this.IgnoreRunCountBox = new System.Windows.Forms.CheckBox(); + this.MalusCountBox = new System.Windows.Forms.NumericUpDown(); + this.SplitclipCountBox = new System.Windows.Forms.NumericUpDown(); + this.label3 = new System.Windows.Forms.Label(); + this.label4 = new System.Windows.Forms.Label(); + this.label5 = new System.Windows.Forms.Label(); + this.label6 = new System.Windows.Forms.Label(); + this.label7 = new System.Windows.Forms.Label(); + this.TimediffCountBox = new System.Windows.Forms.NumericUpDown(); + this.label8 = new System.Windows.Forms.Label(); + this.label9 = new System.Windows.Forms.Label(); + this.label10 = new System.Windows.Forms.Label(); + this.label11 = new System.Windows.Forms.Label(); + this.label12 = new System.Windows.Forms.Label(); + this.label13 = new System.Windows.Forms.Label(); + this.label14 = new System.Windows.Forms.Label(); + this.SamplesCountBox = new System.Windows.Forms.NumericUpDown(); + this.label15 = new System.Windows.Forms.Label(); + this.chkSurvival = new System.Windows.Forms.CheckBox(); + this.label16 = new System.Windows.Forms.Label(); + this.btnDebug = new System.Windows.Forms.Button(); + this.label17 = new System.Windows.Forms.Label(); + this.label18 = new System.Windows.Forms.Label(); + this.label20 = new System.Windows.Forms.Label(); + this.RebalanceCountBox = new System.Windows.Forms.NumericUpDown(); + this.label21 = new System.Windows.Forms.Label(); + this.label22 = new System.Windows.Forms.Label(); + this.chkRebalance = new System.Windows.Forms.CheckBox(); + this.label19 = new System.Windows.Forms.Label(); + this.MinTimesCountBox = new System.Windows.Forms.NumericUpDown(); + this.label24 = new System.Windows.Forms.Label(); + this.label25 = new System.Windows.Forms.Label(); + this.label26 = new System.Windows.Forms.Label(); + this.SplitsvalueCountBox = new System.Windows.Forms.NumericUpDown(); + this.label27 = new System.Windows.Forms.Label(); + this.UpdateCountBox = new System.Windows.Forms.NumericUpDown(); + this.label28 = new System.Windows.Forms.Label(); + this.label1 = new System.Windows.Forms.Label(); + this.chkValueRuns = new System.Windows.Forms.CheckBox(); + this.label23 = new System.Windows.Forms.Label(); + this.label29 = new System.Windows.Forms.Label(); + this.label30 = new System.Windows.Forms.Label(); + this.SkipNewestCountBox = new System.Windows.Forms.NumericUpDown(); + this.label2 = new System.Windows.Forms.Label(); + this.label31 = new System.Windows.Forms.Label(); + this.label32 = new System.Windows.Forms.Label(); + this.CalcToSplitUpDown = new System.Windows.Forms.NumericUpDown(); + this.label33 = new System.Windows.Forms.Label(); + this.label34 = new System.Windows.Forms.Label(); + this.label35 = new System.Windows.Forms.Label(); ((System.ComponentModel.ISupportInitialize)(this.AttemptCountBox)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.MalusCountBox)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.SplitclipCountBox)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.TimediffCountBox)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.SamplesCountBox)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.RebalanceCountBox)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.MinTimesCountBox)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.SplitsvalueCountBox)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.UpdateCountBox)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.SkipNewestCountBox)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.CalcToSplitUpDown)).BeginInit(); this.SuspendLayout(); // // RecentLabel // this.RecentLabel.AutoSize = true; - this.RecentLabel.Location = new System.Drawing.Point(3, 41); + this.RecentLabel.Location = new System.Drawing.Point(14, 55); this.RecentLabel.Name = "RecentLabel"; this.RecentLabel.Size = new System.Drawing.Size(87, 13); this.RecentLabel.TabIndex = 1; @@ -51,18 +110,18 @@ private void InitializeComponent() // this.PercentOfAttempts.AutoSize = true; this.PercentOfAttempts.Checked = true; - this.PercentOfAttempts.Location = new System.Drawing.Point(150, 32); + this.PercentOfAttempts.Location = new System.Drawing.Point(148, 41); this.PercentOfAttempts.Name = "PercentOfAttempts"; - this.PercentOfAttempts.Size = new System.Drawing.Size(118, 17); + this.PercentOfAttempts.Size = new System.Drawing.Size(117, 17); this.PercentOfAttempts.TabIndex = 2; this.PercentOfAttempts.TabStop = true; - this.PercentOfAttempts.Text = "Percent of Attempts"; + this.PercentOfAttempts.Text = "Percent of attempts"; this.PercentOfAttempts.UseVisualStyleBackColor = true; // // FixedAttempts // this.FixedAttempts.AutoSize = true; - this.FixedAttempts.Location = new System.Drawing.Point(150, 55); + this.FixedAttempts.Location = new System.Drawing.Point(148, 60); this.FixedAttempts.Name = "FixedAttempts"; this.FixedAttempts.Size = new System.Drawing.Size(66, 17); this.FixedAttempts.TabIndex = 3; @@ -72,9 +131,9 @@ private void InitializeComponent() // // AttemptCountBox // - this.AttemptCountBox.Location = new System.Drawing.Point(93, 39); + this.AttemptCountBox.Location = new System.Drawing.Point(102, 48); this.AttemptCountBox.Maximum = new decimal(new int[] { - 999999, + 9999, 0, 0, 0}); @@ -84,7 +143,7 @@ private void InitializeComponent() 0, 0}); this.AttemptCountBox.Name = "AttemptCountBox"; - this.AttemptCountBox.Size = new System.Drawing.Size(51, 20); + this.AttemptCountBox.Size = new System.Drawing.Size(40, 20); this.AttemptCountBox.TabIndex = 1; this.AttemptCountBox.Value = new decimal(new int[] { 50, @@ -96,36 +155,653 @@ private void InitializeComponent() // this.CreditsLabel.AutoSize = true; this.CreditsLabel.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0))); - this.CreditsLabel.Location = new System.Drawing.Point(3, 13); + this.CreditsLabel.Location = new System.Drawing.Point(11, 18); this.CreditsLabel.Name = "CreditsLabel"; - this.CreditsLabel.Size = new System.Drawing.Size(141, 13); + this.CreditsLabel.Size = new System.Drawing.Size(235, 13); this.CreditsLabel.TabIndex = 4; - this.CreditsLabel.Text = "PBChance by SethBling"; + this.CreditsLabel.Tag = ""; + this.CreditsLabel.Text = "PBChance by SethBling*"; // // DisplayOddsCheckbox // this.DisplayOddsCheckbox.AutoSize = true; - this.DisplayOddsCheckbox.Location = new System.Drawing.Point(6, 72); + this.DisplayOddsCheckbox.Location = new System.Drawing.Point(272, 42); this.DisplayOddsCheckbox.Name = "DisplayOddsCheckbox"; - this.DisplayOddsCheckbox.Size = new System.Drawing.Size(125, 17); + this.DisplayOddsCheckbox.Size = new System.Drawing.Size(123, 17); this.DisplayOddsCheckbox.TabIndex = 5; - this.DisplayOddsCheckbox.Text = "Display Odds (1 in N)"; + this.DisplayOddsCheckbox.Text = "Display odds (1 in N)"; this.DisplayOddsCheckbox.UseVisualStyleBackColor = true; // // IgnoreRunCountBox // this.IgnoreRunCountBox.AutoSize = true; - this.IgnoreRunCountBox.Location = new System.Drawing.Point(6, 95); + this.IgnoreRunCountBox.Location = new System.Drawing.Point(272, 60); this.IgnoreRunCountBox.Name = "IgnoreRunCountBox"; - this.IgnoreRunCountBox.Size = new System.Drawing.Size(205, 17); + this.IgnoreRunCountBox.Size = new System.Drawing.Size(81, 17); this.IgnoreRunCountBox.TabIndex = 6; - this.IgnoreRunCountBox.Text = "Use All Runs (Ignore Attempt Counter)"; + this.IgnoreRunCountBox.Text = "Use all runs"; this.IgnoreRunCountBox.UseVisualStyleBackColor = true; // + // MalusCountBox + // + this.MalusCountBox.Location = new System.Drawing.Point(102, 307); + this.MalusCountBox.Maximum = new decimal(new int[] { + 999, + 0, + 0, + 0}); + this.MalusCountBox.Name = "MalusCountBox"; + this.MalusCountBox.Size = new System.Drawing.Size(40, 20); + this.MalusCountBox.TabIndex = 7; + this.MalusCountBox.Value = new decimal(new int[] { + 30, + 0, + 0, + 0}); + // + // SplitclipCountBox + // + this.SplitclipCountBox.Increment = new decimal(new int[] { + 5, + 0, + 0, + 0}); + this.SplitclipCountBox.Location = new System.Drawing.Point(291, 356); + this.SplitclipCountBox.Maximum = new decimal(new int[] { + 999, + 0, + 0, + 0}); + this.SplitclipCountBox.Minimum = new decimal(new int[] { + 100, + 0, + 0, + 0}); + this.SplitclipCountBox.Name = "SplitclipCountBox"; + this.SplitclipCountBox.Size = new System.Drawing.Size(40, 20); + this.SplitclipCountBox.TabIndex = 8; + this.SplitclipCountBox.Value = new decimal(new int[] { + 200, + 0, + 0, + 0}); + // + // label3 + // + this.label3.AutoSize = true; + this.label3.Location = new System.Drawing.Point(14, 314); + this.label3.Name = "label3"; + this.label3.Size = new System.Drawing.Size(86, 13); + this.label3.TabIndex = 11; + this.label3.Text = "Malus on failures"; + // + // label4 + // + this.label4.AutoSize = true; + this.label4.Location = new System.Drawing.Point(148, 314); + this.label4.Name = "label4"; + this.label4.Size = new System.Drawing.Size(47, 13); + this.label4.TabIndex = 12; + this.label4.Text = "seconds"; + // + // label5 + // + this.label5.AutoSize = true; + this.label5.Location = new System.Drawing.Point(14, 363); + this.label5.Name = "label5"; + this.label5.Size = new System.Drawing.Size(271, 13); + this.label5.TabIndex = 13; + this.label5.Text = "Only consider splits, which are faster than {bestSplit[s] x"; + // + // label6 + // + this.label6.AutoSize = true; + this.label6.Location = new System.Drawing.Point(337, 363); + this.label6.Name = "label6"; + this.label6.Size = new System.Drawing.Size(47, 13); + this.label6.TabIndex = 14; + this.label6.Text = "percent}"; + // + // label7 + // + this.label7.AutoSize = true; + this.label7.Location = new System.Drawing.Point(14, 432); + this.label7.Name = "label7"; + this.label7.Size = new System.Drawing.Size(77, 13); + this.label7.TabIndex = 15; + this.label7.Text = "Timedifference"; + // + // TimediffCountBox + // + this.TimediffCountBox.Location = new System.Drawing.Point(92, 425); + this.TimediffCountBox.Maximum = new decimal(new int[] { + 86400, + 0, + 0, + 0}); + this.TimediffCountBox.Minimum = new decimal(new int[] { + 86400, + 0, + 0, + -2147483648}); + this.TimediffCountBox.Name = "TimediffCountBox"; + this.TimediffCountBox.Size = new System.Drawing.Size(60, 20); + this.TimediffCountBox.TabIndex = 9; + // + // label8 + // + this.label8.AutoSize = true; + this.label8.Location = new System.Drawing.Point(158, 432); + this.label8.Name = "label8"; + this.label8.Size = new System.Drawing.Size(47, 13); + this.label8.TabIndex = 17; + this.label8.Text = "seconds"; + // + // label9 + // + this.label9.AutoSize = true; + this.label9.ForeColor = System.Drawing.SystemColors.AppWorkspace; + this.label9.Location = new System.Drawing.Point(15, 445); + this.label9.Name = "label9"; + this.label9.Size = new System.Drawing.Size(244, 13); + this.label9.TabIndex = 18; + this.label9.Text = "higher number -> higher chance. Can be negative."; + // + // label10 + // + this.label10.AutoSize = true; + this.label10.ForeColor = System.Drawing.SystemColors.AppWorkspace; + this.label10.Location = new System.Drawing.Point(14, 182); + this.label10.Name = "label10"; + this.label10.Size = new System.Drawing.Size(247, 13); + this.label10.TabIndex = 19; + this.label10.Text = "higher number -> smaller variance. Default 100000."; + // + // label11 + // + this.label11.AutoSize = true; + this.label11.ForeColor = System.Drawing.SystemColors.AppWorkspace; + this.label11.Location = new System.Drawing.Point(14, 376); + this.label11.Name = "label11"; + this.label11.Size = new System.Drawing.Size(222, 13); + this.label11.TabIndex = 20; + this.label11.Text = "higher number -> lower chance. Default 150%"; + // + // label12 + // + this.label12.AutoSize = true; + this.label12.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.label12.Location = new System.Drawing.Point(11, 97); + this.label12.Name = "label12"; + this.label12.Size = new System.Drawing.Size(177, 13); + this.label12.TabIndex = 21; + this.label12.Text = "Advanced settings by kasi777"; + // + // label13 + // + this.label13.AutoSize = true; + this.label13.Location = new System.Drawing.Point(14, 168); + this.label13.Name = "label13"; + this.label13.Size = new System.Drawing.Size(117, 13); + this.label13.TabIndex = 22; + this.label13.Text = "Random sample survey"; + // + // label14 + // + this.label14.AutoSize = true; + this.label14.ForeColor = System.Drawing.SystemColors.AppWorkspace; + this.label14.Location = new System.Drawing.Point(14, 327); + this.label14.Name = "label14"; + this.label14.Size = new System.Drawing.Size(372, 13); + this.label14.TabIndex = 23; + this.label14.Text = "It\'s added every time to a simulated run, if a failed split is selected. Default " + + "30s"; + // + // SamplesCountBox + // + this.SamplesCountBox.Increment = new decimal(new int[] { + 1000, + 0, + 0, + 0}); + this.SamplesCountBox.Location = new System.Drawing.Point(137, 161); + this.SamplesCountBox.Maximum = new decimal(new int[] { + 999999, + 0, + 0, + 0}); + this.SamplesCountBox.Minimum = new decimal(new int[] { + 1, + 0, + 0, + 0}); + this.SamplesCountBox.Name = "SamplesCountBox"; + this.SamplesCountBox.Size = new System.Drawing.Size(60, 20); + this.SamplesCountBox.TabIndex = 10; + this.SamplesCountBox.Value = new decimal(new int[] { + 100000, + 0, + 0, + 0}); + // + // label15 + // + this.label15.AutoSize = true; + this.label15.Location = new System.Drawing.Point(203, 168); + this.label15.Name = "label15"; + this.label15.Size = new System.Drawing.Size(69, 13); + this.label15.TabIndex = 25; + this.label15.Text = "combinations"; + // + // chkSurvival + // + this.chkSurvival.AutoSize = true; + this.chkSurvival.Location = new System.Drawing.Point(17, 233); + this.chkSurvival.Name = "chkSurvival"; + this.chkSurvival.Size = new System.Drawing.Size(138, 17); + this.chkSurvival.TabIndex = 27; + this.chkSurvival.Text = "Display survival chance"; + this.chkSurvival.UseVisualStyleBackColor = true; + // + // label16 + // + this.label16.AutoSize = true; + this.label16.ForeColor = System.Drawing.SystemColors.AppWorkspace; + this.label16.Location = new System.Drawing.Point(14, 248); + this.label16.Name = "label16"; + this.label16.Size = new System.Drawing.Size(238, 13); + this.label16.TabIndex = 28; + this.label16.Text = "Formula: [successfully runs]/[total remaining runs]"; + // + // btnDebug + // + this.btnDebug.Location = new System.Drawing.Point(14, 479); + this.btnDebug.Name = "btnDebug"; + this.btnDebug.Size = new System.Drawing.Size(66, 45); + this.btnDebug.TabIndex = 29; + this.btnDebug.Text = "Generate Debug File"; + this.btnDebug.UseVisualStyleBackColor = true; + this.btnDebug.Click += new System.EventHandler(this.btnDebug_Click); + // + // label17 + // + this.label17.AutoSize = true; + this.label17.Location = new System.Drawing.Point(86, 483); + this.label17.Name = "label17"; + this.label17.Size = new System.Drawing.Size(131, 13); + this.label17.TabIndex = 30; + this.label17.Text = "To retrace the calculation."; + // + // label18 + // + this.label18.AutoSize = true; + this.label18.Location = new System.Drawing.Point(86, 496); + this.label18.Name = "label18"; + this.label18.Size = new System.Drawing.Size(127, 13); + this.label18.TabIndex = 31; + this.label18.Text = "See pbchance_debug.txt"; + // + // label20 + // + this.label20.AutoSize = true; + this.label20.Location = new System.Drawing.Point(195, 0); + this.label20.Name = "label20"; + this.label20.Size = new System.Drawing.Size(167, 13); + this.label20.TabIndex = 33; + this.label20.Text = "Optimistic / Pesimistic rebalancing"; + this.label20.Visible = false; + // + // RebalanceCountBox + // + this.RebalanceCountBox.Location = new System.Drawing.Point(368, -7); + this.RebalanceCountBox.Maximum = new decimal(new int[] { + 999, + 0, + 0, + 0}); + this.RebalanceCountBox.Minimum = new decimal(new int[] { + 999, + 0, + 0, + -2147483648}); + this.RebalanceCountBox.Name = "RebalanceCountBox"; + this.RebalanceCountBox.Size = new System.Drawing.Size(40, 20); + this.RebalanceCountBox.TabIndex = 32; + this.RebalanceCountBox.Value = new decimal(new int[] { + 10, + 0, + 0, + 0}); + this.RebalanceCountBox.Visible = false; + // + // label21 + // + this.label21.AutoSize = true; + this.label21.ForeColor = System.Drawing.SystemColors.AppWorkspace; + this.label21.Location = new System.Drawing.Point(158, 0); + this.label21.Name = "label21"; + this.label21.Size = new System.Drawing.Size(213, 13); + this.label21.TabIndex = 35; + this.label21.Text = "0 = neutral, >0 = optimistic, <0 = pessimistic."; + this.label21.Visible = false; + // + // label22 + // + this.label22.AutoSize = true; + this.label22.ForeColor = System.Drawing.SystemColors.AppWorkspace; + this.label22.Location = new System.Drawing.Point(130, 0); + this.label22.Name = "label22"; + this.label22.Size = new System.Drawing.Size(265, 13); + this.label22.TabIndex = 36; + this.label22.Text = "Gives a lower weighting for slower splits if it\'s optimistic."; + this.label22.Visible = false; + // + // chkRebalance + // + this.chkRebalance.AutoSize = true; + this.chkRebalance.Location = new System.Drawing.Point(159, -2); + this.chkRebalance.Name = "chkRebalance"; + this.chkRebalance.Size = new System.Drawing.Size(194, 17); + this.chkRebalance.TabIndex = 38; + this.chkRebalance.Text = "Display chance without rebalancing"; + this.chkRebalance.UseVisualStyleBackColor = true; + this.chkRebalance.Visible = false; + // + // label19 + // + this.label19.AutoSize = true; + this.label19.ForeColor = System.Drawing.SystemColors.AppWorkspace; + this.label19.Location = new System.Drawing.Point(14, 458); + this.label19.Name = "label19"; + this.label19.Size = new System.Drawing.Size(242, 13); + this.label19.TabIndex = 39; + this.label19.Text = "Use it for building scenarios or to shift the PB-time."; + // + // MinTimesCountBox + // + this.MinTimesCountBox.Location = new System.Drawing.Point(106, 120); + this.MinTimesCountBox.Maximum = new decimal(new int[] { + 999, + 0, + 0, + 0}); + this.MinTimesCountBox.Minimum = new decimal(new int[] { + 1, + 0, + 0, + 0}); + this.MinTimesCountBox.Name = "MinTimesCountBox"; + this.MinTimesCountBox.Size = new System.Drawing.Size(40, 20); + this.MinTimesCountBox.TabIndex = 40; + this.MinTimesCountBox.Value = new decimal(new int[] { + 10, + 0, + 0, + 0}); + // + // label24 + // + this.label24.AutoSize = true; + this.label24.Location = new System.Drawing.Point(15, 127); + this.label24.Name = "label24"; + this.label24.Size = new System.Drawing.Size(85, 13); + this.label24.TabIndex = 41; + this.label24.Text = "Consider at least"; + // + // label25 + // + this.label25.AutoSize = true; + this.label25.Location = new System.Drawing.Point(152, 127); + this.label25.Name = "label25"; + this.label25.Size = new System.Drawing.Size(73, 13); + this.label25.TabIndex = 42; + this.label25.Text = "times per split."; + // + // label26 + // + this.label26.AutoSize = true; + this.label26.Location = new System.Drawing.Point(58, 274); + this.label26.Name = "label26"; + this.label26.Size = new System.Drawing.Size(251, 13); + this.label26.TabIndex = 44; + this.label26.Text = "Newer splits times are more important than old ones."; + // + // SplitsvalueCountBox + // + this.SplitsvalueCountBox.Location = new System.Drawing.Point(17, 274); + this.SplitsvalueCountBox.Name = "SplitsvalueCountBox"; + this.SplitsvalueCountBox.Size = new System.Drawing.Size(40, 20); + this.SplitsvalueCountBox.TabIndex = 43; + this.SplitsvalueCountBox.Value = new decimal(new int[] { + 100, + 0, + 0, + 0}); + // + // label27 + // + this.label27.AutoSize = true; + this.label27.Location = new System.Drawing.Point(14, 208); + this.label27.Name = "label27"; + this.label27.Size = new System.Drawing.Size(135, 13); + this.label27.TabIndex = 47; + this.label27.Text = "Update automatically every"; + // + // UpdateCountBox + // + this.UpdateCountBox.Location = new System.Drawing.Point(151, 201); + this.UpdateCountBox.Maximum = new decimal(new int[] { + 999, + 0, + 0, + 0}); + this.UpdateCountBox.Name = "UpdateCountBox"; + this.UpdateCountBox.Size = new System.Drawing.Size(40, 20); + this.UpdateCountBox.TabIndex = 46; + this.UpdateCountBox.Value = new decimal(new int[] { + 5, + 0, + 0, + 0}); + // + // label28 + // + this.label28.AutoSize = true; + this.label28.Location = new System.Drawing.Point(197, 208); + this.label28.Name = "label28"; + this.label28.Size = new System.Drawing.Size(165, 13); + this.label28.TabIndex = 48; + this.label28.Text = "seconds when the chance drops."; + // + // label1 + // + this.label1.AutoSize = true; + this.label1.BackColor = System.Drawing.SystemColors.Control; + this.label1.ForeColor = System.Drawing.SystemColors.AppWorkspace; + this.label1.Location = new System.Drawing.Point(288, 75); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(116, 13); + this.label1.TabIndex = 49; + this.label1.Text = "Ignore Attempt Counter"; + // + // chkValueRuns + // + this.chkValueRuns.AutoSize = true; + this.chkValueRuns.Location = new System.Drawing.Point(200, -2); + this.chkValueRuns.Name = "chkValueRuns"; + this.chkValueRuns.Size = new System.Drawing.Size(162, 17); + this.chkValueRuns.TabIndex = 50; + this.chkValueRuns.Text = "More value for \"newer runs\"."; + this.chkValueRuns.UseVisualStyleBackColor = true; + this.chkValueRuns.Visible = false; + // + // label23 + // + this.label23.AutoSize = true; + this.label23.ForeColor = System.Drawing.SystemColors.AppWorkspace; + this.label23.Location = new System.Drawing.Point(225, 2); + this.label23.Name = "label23"; + this.label23.Size = new System.Drawing.Size(128, 13); + this.label23.TabIndex = 51; + this.label23.Text = "Highest priority. Default: 5"; + this.label23.Visible = false; + // + // label29 + // + this.label29.AutoSize = true; + this.label29.ForeColor = System.Drawing.SystemColors.AppWorkspace; + this.label29.Location = new System.Drawing.Point(58, 287); + this.label29.Name = "label29"; + this.label29.Size = new System.Drawing.Size(359, 13); + this.label29.TabIndex = 52; + this.label29.Text = "Newer attempts be selected more often during a simulated run. Default 100"; + // + // label30 + // + this.label30.AutoSize = true; + this.label30.ForeColor = System.Drawing.SystemColors.AppWorkspace; + this.label30.Location = new System.Drawing.Point(14, 340); + this.label30.Name = "label30"; + this.label30.Size = new System.Drawing.Size(277, 13); + this.label30.TabIndex = 53; + this.label30.Text = "For each discontinued run, a failed split will be generated."; + // + // SkipNewestCountBox + // + this.SkipNewestCountBox.Location = new System.Drawing.Point(378, 479); + this.SkipNewestCountBox.Maximum = new decimal(new int[] { + 99999, + 0, + 0, + 0}); + this.SkipNewestCountBox.Name = "SkipNewestCountBox"; + this.SkipNewestCountBox.Size = new System.Drawing.Size(40, 20); + this.SkipNewestCountBox.TabIndex = 54; + // + // label2 + // + this.label2.AutoSize = true; + this.label2.Location = new System.Drawing.Point(242, 486); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(129, 13); + this.label2.TabIndex = 55; + this.label2.Text = "Skip the newest attempts:"; + // + // label31 + // + this.label31.AutoSize = true; + this.label31.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.label31.ForeColor = System.Drawing.SystemColors.ControlText; + this.label31.Location = new System.Drawing.Point(11, 405); + this.label31.Name = "label31"; + this.label31.Size = new System.Drawing.Size(296, 13); + this.label31.TabIndex = 56; + this.label31.Text = "For debuging only, should be 0 during regular runs."; + // + // label32 + // + this.label32.AutoSize = true; + this.label32.Location = new System.Drawing.Point(282, 507); + this.label32.Name = "label32"; + this.label32.Size = new System.Drawing.Size(89, 13); + this.label32.TabIndex = 58; + this.label32.Text = "Only calc to Split:"; + // + // CalcToSplitUpDown + // + this.CalcToSplitUpDown.Location = new System.Drawing.Point(378, 505); + this.CalcToSplitUpDown.Maximum = new decimal(new int[] { + 99999, + 0, + 0, + 0}); + this.CalcToSplitUpDown.Name = "CalcToSplitUpDown"; + this.CalcToSplitUpDown.Size = new System.Drawing.Size(40, 20); + this.CalcToSplitUpDown.TabIndex = 57; + // + // label33 + // + this.label33.AutoSize = true; + this.label33.ForeColor = System.Drawing.SystemColors.AppWorkspace; + this.label33.Location = new System.Drawing.Point(15, 141); + this.label33.Name = "label33"; + this.label33.Size = new System.Drawing.Size(254, 13); + this.label33.TabIndex = 59; + this.label33.Text = "Missing times will be filled with older ones. Default 20"; + // + // label34 + // + this.label34.AutoSize = true; + this.label34.Location = new System.Drawing.Point(86, 509); + this.label34.Name = "label34"; + this.label34.Size = new System.Drawing.Size(113, 13); + this.label34.TabIndex = 60; + this.label34.Text = "in your LiveSplit folder."; + // + // label35 + // + this.label35.AutoSize = true; + this.label35.BackColor = System.Drawing.SystemColors.Control; + this.label35.ForeColor = System.Drawing.SystemColors.AppWorkspace; + this.label35.Location = new System.Drawing.Point(424, 509); + this.label35.Name = "label35"; + this.label35.Size = new System.Drawing.Size(35, 13); + this.label35.TabIndex = 61; + this.label35.Text = "0 = all"; + // // PBChanceSettings // this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.Controls.Add(this.label35); + this.Controls.Add(this.label34); + this.Controls.Add(this.label33); + this.Controls.Add(this.label32); + this.Controls.Add(this.CalcToSplitUpDown); + this.Controls.Add(this.label31); + this.Controls.Add(this.label2); + this.Controls.Add(this.SkipNewestCountBox); + this.Controls.Add(this.label30); + this.Controls.Add(this.label29); + this.Controls.Add(this.label23); + this.Controls.Add(this.chkValueRuns); + this.Controls.Add(this.label1); + this.Controls.Add(this.label28); + this.Controls.Add(this.label27); + this.Controls.Add(this.UpdateCountBox); + this.Controls.Add(this.label26); + this.Controls.Add(this.SplitsvalueCountBox); + this.Controls.Add(this.label25); + this.Controls.Add(this.label24); + this.Controls.Add(this.MinTimesCountBox); + this.Controls.Add(this.label19); + this.Controls.Add(this.chkRebalance); + this.Controls.Add(this.label22); + this.Controls.Add(this.label21); + this.Controls.Add(this.label20); + this.Controls.Add(this.RebalanceCountBox); + this.Controls.Add(this.label18); + this.Controls.Add(this.label17); + this.Controls.Add(this.btnDebug); + this.Controls.Add(this.label16); + this.Controls.Add(this.chkSurvival); + this.Controls.Add(this.label15); + this.Controls.Add(this.SamplesCountBox); + this.Controls.Add(this.label14); + this.Controls.Add(this.label13); + this.Controls.Add(this.label12); + this.Controls.Add(this.label11); + this.Controls.Add(this.label10); + this.Controls.Add(this.label9); + this.Controls.Add(this.label8); + this.Controls.Add(this.TimediffCountBox); + this.Controls.Add(this.label7); + this.Controls.Add(this.label6); + this.Controls.Add(this.label5); + this.Controls.Add(this.label4); + this.Controls.Add(this.label3); + this.Controls.Add(this.SplitclipCountBox); + this.Controls.Add(this.MalusCountBox); this.Controls.Add(this.IgnoreRunCountBox); this.Controls.Add(this.DisplayOddsCheckbox); this.Controls.Add(this.CreditsLabel); @@ -134,8 +810,18 @@ private void InitializeComponent() this.Controls.Add(this.PercentOfAttempts); this.Controls.Add(this.RecentLabel); this.Name = "PBChanceSettings"; - this.Size = new System.Drawing.Size(289, 121); + this.Size = new System.Drawing.Size(464, 536); ((System.ComponentModel.ISupportInitialize)(this.AttemptCountBox)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.MalusCountBox)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.SplitclipCountBox)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.TimediffCountBox)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.SamplesCountBox)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.RebalanceCountBox)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.MinTimesCountBox)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.SplitsvalueCountBox)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.UpdateCountBox)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.SkipNewestCountBox)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.CalcToSplitUpDown)).EndInit(); this.ResumeLayout(false); this.PerformLayout(); @@ -149,5 +835,54 @@ private void InitializeComponent() private System.Windows.Forms.Label CreditsLabel; private System.Windows.Forms.CheckBox DisplayOddsCheckbox; private System.Windows.Forms.CheckBox IgnoreRunCountBox; + private System.Windows.Forms.NumericUpDown MalusCountBox; + private System.Windows.Forms.NumericUpDown SplitclipCountBox; + private System.Windows.Forms.Label label3; + private System.Windows.Forms.Label label4; + private System.Windows.Forms.Label label5; + private System.Windows.Forms.Label label6; + private System.Windows.Forms.Label label7; + private System.Windows.Forms.NumericUpDown TimediffCountBox; + private System.Windows.Forms.Label label8; + private System.Windows.Forms.Label label9; + private System.Windows.Forms.Label label10; + private System.Windows.Forms.Label label11; + private System.Windows.Forms.Label label12; + private System.Windows.Forms.Label label13; + private System.Windows.Forms.Label label14; + private System.Windows.Forms.NumericUpDown SamplesCountBox; + private System.Windows.Forms.Label label15; + private System.Windows.Forms.CheckBox chkSurvival; + private System.Windows.Forms.Label label16; + private System.Windows.Forms.Button btnDebug; + private System.Windows.Forms.Label label17; + private System.Windows.Forms.Label label18; + private System.Windows.Forms.Label label20; + private System.Windows.Forms.NumericUpDown RebalanceCountBox; + private System.Windows.Forms.Label label21; + private System.Windows.Forms.Label label22; + private System.Windows.Forms.CheckBox chkRebalance; + private System.Windows.Forms.Label label19; + private System.Windows.Forms.NumericUpDown MinTimesCountBox; + private System.Windows.Forms.Label label24; + private System.Windows.Forms.Label label25; + private System.Windows.Forms.Label label26; + private System.Windows.Forms.NumericUpDown SplitsvalueCountBox; + private System.Windows.Forms.Label label27; + private System.Windows.Forms.NumericUpDown UpdateCountBox; + private System.Windows.Forms.Label label28; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.CheckBox chkValueRuns; + private System.Windows.Forms.Label label23; + private System.Windows.Forms.Label label29; + private System.Windows.Forms.Label label30; + private System.Windows.Forms.NumericUpDown SkipNewestCountBox; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.Label label31; + private System.Windows.Forms.Label label32; + private System.Windows.Forms.NumericUpDown CalcToSplitUpDown; + private System.Windows.Forms.Label label33; + private System.Windows.Forms.Label label34; + private System.Windows.Forms.Label label35; } } diff --git a/PBChance/UI/Components/PBChanceSettings.cs b/PBChance/UI/Components/PBChanceSettings.cs index 2004488..774271c 100644 --- a/PBChance/UI/Components/PBChanceSettings.cs +++ b/PBChance/UI/Components/PBChanceSettings.cs @@ -17,8 +17,27 @@ public partial class PBChanceSettings : UserControl public Boolean UsePercentOfAttempts { get; set; } public Boolean UseFixedAttempts { get; set; } public int AttemptCount { get; set; } + public int MalusCount { get; set; } + public int SplitclipCount { get; set; } + public int TimediffCount { get; set; } + public int SamplesCount { get; set; } public bool DisplayOdds { get; set; } public bool IgnoreRunCount { get; set; } + public bool bDebug { get; set; } + public int iOptimistic { get; set; } + public bool bRebalance { get; set; } + public bool bValueRuns { get; set; } + public int iMinTimes { get; set; } + public int iUpdate { get; set; } + public int iSplitsvalue { get; set; } + + public Boolean bSurvival { get; set; } + + public int iSkipNewest { get; set; } + public int iCalcToSplit { get; set; } + + + public event EventHandler SettingChanged; @@ -26,15 +45,45 @@ public PBChanceSettings() { InitializeComponent(); - UsePercentOfAttempts = true; - UseFixedAttempts = false; + UsePercentOfAttempts = false; + UseFixedAttempts = true; + IgnoreRunCount = false; AttemptCount = 50; + MalusCount = 30; + SplitclipCount = 150; + TimediffCount = 0; + SamplesCount = 100000; + bSurvival = false; + bDebug = false; + iOptimistic = 0; + bRebalance = false; + bValueRuns = false; + iMinTimes = 20; + iUpdate = 1; + iSplitsvalue = 20; + iSkipNewest = 0; + iCalcToSplit = 0; + + PercentOfAttempts.DataBindings.Add("Checked", this, "UsePercentOfAttempts", false, DataSourceUpdateMode.OnPropertyChanged).BindingComplete += OnSettingChanged; + FixedAttempts.DataBindings.Add("Checked", this, "UseFixedAttempts", false, DataSourceUpdateMode.OnPropertyChanged).BindingComplete += OnSettingChanged; + AttemptCountBox.DataBindings.Add("Value", this, "AttemptCount", false, DataSourceUpdateMode.OnPropertyChanged).BindingComplete += OnSettingChanged; + DisplayOddsCheckbox.DataBindings.Add("Checked", this, "DisplayOdds", false, DataSourceUpdateMode.OnPropertyChanged).BindingComplete += OnSettingChanged; + IgnoreRunCountBox.DataBindings.Add("Checked", this, "IgnoreRunCount", false, DataSourceUpdateMode.OnPropertyChanged).BindingComplete += OnSettingChanged; + MalusCountBox.DataBindings.Add("Value", this, "MalusCount", false, DataSourceUpdateMode.OnPropertyChanged).BindingComplete += OnSettingChanged; + SplitclipCountBox.DataBindings.Add("Value", this, "SplitclipCount", true, DataSourceUpdateMode.OnPropertyChanged).BindingComplete += OnSettingChanged; + TimediffCountBox.DataBindings.Add("Value", this, "TimediffCount", false, DataSourceUpdateMode.OnPropertyChanged).BindingComplete += OnSettingChanged; + SamplesCountBox.DataBindings.Add("Value", this, "SamplesCount", false, DataSourceUpdateMode.OnPropertyChanged).BindingComplete += OnSettingChanged; + chkSurvival.DataBindings.Add("Checked", this, "bSurvival", false, DataSourceUpdateMode.OnPropertyChanged).BindingComplete += OnSettingChanged; + //chkRebalance.DataBindings.Add("Checked", this, "bRebalance", false, DataSourceUpdateMode.OnPropertyChanged).BindingComplete += OnSettingChanged; + //RebalanceCountBox.DataBindings.Add("Value", this, "iOptimistic", false, DataSourceUpdateMode.OnPropertyChanged).BindingComplete += OnSettingChanged; + + //chkValueRuns.DataBindings.Add("Checked", this, "bValueRuns", false, DataSourceUpdateMode.OnPropertyChanged).BindingComplete += OnSettingChanged; + MinTimesCountBox.DataBindings.Add("Value", this, "iMinTimes", false, DataSourceUpdateMode.OnPropertyChanged).BindingComplete += OnSettingChanged; + UpdateCountBox.DataBindings.Add("Value", this, "iUpdate", false, DataSourceUpdateMode.OnPropertyChanged).BindingComplete += OnSettingChanged; + SplitsvalueCountBox.DataBindings.Add("Value", this, "iSplitsvalue", false, DataSourceUpdateMode.OnPropertyChanged).BindingComplete += OnSettingChanged; - PercentOfAttempts.DataBindings.Add("Checked", this, "UsePercentOfAttempts", true, DataSourceUpdateMode.OnPropertyChanged).BindingComplete += OnSettingChanged; - FixedAttempts.DataBindings.Add("Checked", this, "UseFixedAttempts", true, DataSourceUpdateMode.OnPropertyChanged).BindingComplete += OnSettingChanged; - AttemptCountBox.DataBindings.Add("Value", this, "AttemptCount", true, DataSourceUpdateMode.OnPropertyChanged).BindingComplete += OnSettingChanged; - DisplayOddsCheckbox.DataBindings.Add("Checked", this, "DisplayOdds", true, DataSourceUpdateMode.OnPropertyChanged).BindingComplete += OnSettingChanged; - IgnoreRunCountBox.DataBindings.Add("Checked", this, "IgnoreRunCount", true, DataSourceUpdateMode.OnPropertyChanged).BindingComplete += OnSettingChanged; + SkipNewestCountBox.DataBindings.Add("Value", this, "iSkipNewest", false, DataSourceUpdateMode.OnPropertyChanged).BindingComplete += OnSettingChanged; + CalcToSplitUpDown.DataBindings.Add("Value", this, "iCalcToSplit", false, DataSourceUpdateMode.OnPropertyChanged).BindingComplete += OnSettingChanged; } private void OnSettingChanged(object sender, BindingCompleteEventArgs e) @@ -53,21 +102,58 @@ internal XmlNode GetSettings(XmlDocument document) private int CreateSettingsNode(XmlDocument document, XmlElement parent) { - return SettingsHelper.CreateSetting(document, parent, "Version", "0.1") ^ + //UsePercentOfAttempts = false; + //UseFixedAttempts = true; + //AttemptCount = 50; + //MalusCount = 30; + //SplitclipCount = 150; + //TimediffCount = 0; + //SamplesCount = 10000; + + return SettingsHelper.CreateSetting(document, parent, "Version", "0.4") ^ SettingsHelper.CreateSetting(document, parent, "AttemptCount", AttemptCount) ^ SettingsHelper.CreateSetting(document, parent, "UsePercentOfAttempts", UsePercentOfAttempts) ^ SettingsHelper.CreateSetting(document, parent, "UseFixedAttempts", UseFixedAttempts) ^ SettingsHelper.CreateSetting(document, parent, "DisplayOdds", DisplayOdds) ^ - SettingsHelper.CreateSetting(document, parent, "IgnoreRunCount", IgnoreRunCount); + SettingsHelper.CreateSetting(document, parent, "IgnoreRunCount", IgnoreRunCount) ^ + SettingsHelper.CreateSetting(document, parent, "MalusCount", MalusCount) ^ + SettingsHelper.CreateSetting(document, parent, "SplitclipCount", SplitclipCount) ^ + //SettingsHelper.CreateSetting(document, parent, "TimediffCount", TimediffCount) ^ + SettingsHelper.CreateSetting(document, parent, "SamplesCount", SamplesCount) ^ + SettingsHelper.CreateSetting(document, parent, "iOptimistic", iOptimistic) ^ + SettingsHelper.CreateSetting(document, parent, "chkRebalance", bRebalance) ^ + SettingsHelper.CreateSetting(document, parent, "chkSurvival", bSurvival) ^ + SettingsHelper.CreateSetting(document, parent, "bValueRuns", bValueRuns) ^ + SettingsHelper.CreateSetting(document, parent, "iMinTimes", iMinTimes) ^ + SettingsHelper.CreateSetting(document, parent, "iUpdate", iUpdate) ^ + SettingsHelper.CreateSetting(document, parent, "iSplitsvalue", iSplitsvalue); } internal void SetSettings(XmlNode settings) { - AttemptCount = SettingsHelper.ParseInt(settings["AttemptCount"]); + AttemptCount = SettingsHelper.ParseInt (settings["AttemptCount"]); UsePercentOfAttempts = SettingsHelper.ParseBool(settings["UsePercentOfAttempts"]); - UseFixedAttempts = SettingsHelper.ParseBool(settings["UseFixedAttempts"]); - DisplayOdds = SettingsHelper.ParseBool(settings["DisplayOdds"]); - IgnoreRunCount = SettingsHelper.ParseBool(settings["IgnoreRunCount"]); + UseFixedAttempts = SettingsHelper.ParseBool(settings["UseFixedAttempts"]); + DisplayOdds = SettingsHelper.ParseBool(settings["DisplayOdds"]); + IgnoreRunCount = SettingsHelper.ParseBool(settings["IgnoreRunCount"]); + MalusCount = SettingsHelper.ParseInt (settings["MalusCount"]); + SplitclipCount = SettingsHelper.ParseInt (settings["SplitclipCount"]); + //TimediffCount = SettingsHelper.ParseInt (settings["TimediffCount"]); + SamplesCount = SettingsHelper.ParseInt (settings["SamplesCount"]); + iOptimistic = SettingsHelper.ParseInt(settings["iOptimistic"]); + bSurvival = SettingsHelper.ParseBool(settings["chkSurvival"]); + bRebalance = SettingsHelper.ParseBool(settings["chkRebalance"]); + + bValueRuns = SettingsHelper.ParseBool(settings["bValueRuns"]); + iMinTimes = SettingsHelper.ParseInt(settings["iMinTimes"]); + iUpdate = SettingsHelper.ParseInt(settings["iUpdate"]); + iSplitsvalue = SettingsHelper.ParseInt(settings["iSplitsvalue"]); + } + + private void btnDebug_Click(object sender, EventArgs e) + { + bDebug = true; + SettingChanged?.Invoke(this, e); } } } From 7b5f34d3992fe4d05b1b6b3f754568fdafabb2b5 Mon Sep 17 00:00:00 2001 From: kasi777 <44654531+kasi777@users.noreply.github.com> Date: Thu, 1 Nov 2018 02:23:41 +0100 Subject: [PATCH 013/278] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index ed1f8fe..0c6718f 100644 --- a/README.md +++ b/README.md @@ -60,7 +60,7 @@ This will generate a debug file "pbchance_debug.txt", and will be saved in your [The component in action.](http://i.imgur.com/YIjln5P.png) -[The configuration screen.](http://i.imgur.com/CgUuB46.png) +[The configuration screen.](https://ibb.co/hcZFV0) ## Troubleshooting: From 6a3e068b21b86b52362783f659d5f1fd43281c19 Mon Sep 17 00:00:00 2001 From: kasi777 <44654531+kasi777@users.noreply.github.com> Date: Thu, 1 Nov 2018 02:27:56 +0100 Subject: [PATCH 014/278] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 0c6718f..946e683 100644 --- a/README.md +++ b/README.md @@ -3,7 +3,7 @@ PBChance Component for LiveSplit ## What it is: -PBChance is a LiveSplit component that displays the chance of obtaining a PB on your current run. Whenever you reset or split, it runs a variable number (100,000 recomended) of simulations by randomly drawing the remaining splits from your splits in previous attempts, and computes how many of those would result in a PB. +PBChance is a LiveSplit component that displays the chance of obtaining a PB on your current run. Whenever you reset, split or the run becomes slow, it runs a variable number (100,000 recomended) of simulations by randomly drawing the remaining splits from your splits in previous attempts, and computes how many of those would result in a PB. ## Installation: From 96ef6f3b1a429389919369033f9293de7b17f4b0 Mon Sep 17 00:00:00 2001 From: kasi777 <44654531+kasi777@users.noreply.github.com> Date: Thu, 1 Nov 2018 02:29:13 +0100 Subject: [PATCH 015/278] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 946e683..becbd5c 100644 --- a/README.md +++ b/README.md @@ -16,7 +16,7 @@ PBChance is a LiveSplit component that displays the chance of obtaining a PB on ## Features 1. The calculation will perform in background in an own thread. Even if the number of calculations is set to a high number, LiveSplit will not be stopped during the calculation. -2. Debug file. To retrace the calculation. This includes: Headerdata, Failed Runs, clipped splits, added times, count of times per split, first generated route, results of successfully runs and 10 failures if possible, the result, the detailed split times and the execution time. +2. Debug file. To retrace the calculation. This includes: Headerdata, Failed Runs, clipped splits, added times, count of times per split, first generated route, results of successfully runs and 10 failures if possible, the results, the detailed split times and the execution time. ## Advanced Settings: From 2e8f5cee036e0920bfafb837e2917e35d52ea4f0 Mon Sep 17 00:00:00 2001 From: kasi777 <44654531+kasi777@users.noreply.github.com> Date: Thu, 1 Nov 2018 02:31:43 +0100 Subject: [PATCH 016/278] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index becbd5c..bd4f23a 100644 --- a/README.md +++ b/README.md @@ -38,7 +38,7 @@ Valid values: 0-100 Suggestion: 100 For each discontinued run, a failed split will be generated. It's added every time to a simulated run, if a failed split is selected. Valid values: 0-999 Suggestion: it depends. Can be set to 0, if "Display survival chance" is set. 7. Only consider splits, which are faster than {bestSplit[s] x # percent} -Very slow split times will be eliminated. Should set to a number, which are clearly to slow for a normal run. Should be checked with the debug file (clipped splits), for the correct setting and result. +Very slow split times will be eliminated. Should set to a number, which are clearly too slow for a normal run. Should be checked with the debug file (clipped splits), for the correct setting and result. Valid values: 100-999 Suggestion: 150-250 Hint: The displaying chance on the start should be realistic. But rather too small than too high, for more motivation during a run. Try with these settings to optimize the chance estimation. From ecfa44c5b51295911b808794b6b944df1f5225c9 Mon Sep 17 00:00:00 2001 From: kasi777 <44654531+kasi777@users.noreply.github.com> Date: Thu, 1 Nov 2018 02:37:57 +0100 Subject: [PATCH 017/278] Update README.md --- README.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index bd4f23a..67d60ef 100644 --- a/README.md +++ b/README.md @@ -16,7 +16,8 @@ PBChance is a LiveSplit component that displays the chance of obtaining a PB on ## Features 1. The calculation will perform in background in an own thread. Even if the number of calculations is set to a high number, LiveSplit will not be stopped during the calculation. -2. Debug file. To retrace the calculation. This includes: Headerdata, Failed Runs, clipped splits, added times, count of times per split, first generated route, results of successfully runs and 10 failures if possible, the results, the detailed split times and the execution time. +2. Autoupdate. The chance will be automatically updated if the chance drops during the run. +3. Debug file. To retrace the calculation. This includes: Headerdata, Failed Runs, clipped splits, added times, count of times per split, first generated route, results of successfully runs and 10 failures if possible, the results, the detailed split times and the execution time. ## Advanced Settings: @@ -54,7 +55,7 @@ Valid values: 0-99999 3. Only calc to split # The calculation will stop at split #, if it's not set to 0. 4. Generate Debug File -This will generate a debug file "pbchance_debug.txt", and will be saved in your LiveSplit folder. You can open it with any text editor. See Features 2. for more information. +This will generate a debug file "pbchance_debug.txt", and will be saved in your LiveSplit folder. You can open it with any text editor. See Features 3. for more information. ## Pictures: From ad0d91628d37d67ca20679f417a73d7cdeddb1ba Mon Sep 17 00:00:00 2001 From: kasi777 <44654531+kasi777@users.noreply.github.com> Date: Thu, 1 Nov 2018 02:47:20 +0100 Subject: [PATCH 018/278] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 67d60ef..671e8be 100644 --- a/README.md +++ b/README.md @@ -28,7 +28,7 @@ Valid values: 1-999 Suggestion: 10-25 The number of calculations. A lower number will calculate faster, a higher number gives a more stable result. Valid values: 1-999,999 Suggestion: 100,000 3. Update automatically every # seconds when the chance drops. -During a run, PBChance compares the current split time with the best split time. If it's slower, and the chance is above zero, PBChance calculate in background the chance. If that chance becomes lower than the displayed one, the chance will be updated automatically. 0 means as fast as possible. +During a run, PBChance compares the current split time with the best split time. If it's slower, and the chance is above zero, PBChance calculates in background the chance. If that chance becomes lower than the displayed one, the chance will be updated automatically. 0 means as fast as possible. Valid values: 0-999 Suggestion: 1 4. Display survival chance This will display in addition a percent number. The formula is simply [successfully runs]/[total remaining runs]. From 7f1a697a67c0b37d86ef5922e101edff99cab18a Mon Sep 17 00:00:00 2001 From: kasi777 <44654531+kasi777@users.noreply.github.com> Date: Thu, 1 Nov 2018 03:02:23 +0100 Subject: [PATCH 019/278] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 671e8be..cb997b3 100644 --- a/README.md +++ b/README.md @@ -31,7 +31,7 @@ Valid values: 1-999,999 Suggestion: 100,000 During a run, PBChance compares the current split time with the best split time. If it's slower, and the chance is above zero, PBChance calculates in background the chance. If that chance becomes lower than the displayed one, the chance will be updated automatically. 0 means as fast as possible. Valid values: 0-999 Suggestion: 1 4. Display survival chance -This will display in addition a percent number. The formula is simply [successfully runs]/[total remaining runs]. +This will display in addition a percent number. The formula is simply [finished runs]/[total remaining runs]. 5. Newer split times are more important than old ones Newer attempts will be selected more often during a simulated run. Valid values: 0-100 Suggestion: 100 From 685f078cff5a9ab36a382b75e700e7fb663bea31 Mon Sep 17 00:00:00 2001 From: kasi777 <44654531+kasi777@users.noreply.github.com> Date: Thu, 1 Nov 2018 03:21:38 +0100 Subject: [PATCH 020/278] Update README.md --- README.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index cb997b3..c02d2fa 100644 --- a/README.md +++ b/README.md @@ -46,15 +46,15 @@ Hint: The displaying chance on the start should be realistic. But rather too sma ## Debuging settings (should be 0 during regular runs) -1. Timedifference # seconds +1. Timedifference # seconds. This will simply adds to the pb-time. Valid values: -86400-86400 (24h) -2. Skip the newest attempts # +2. Skip the newest attempts #. To see how high the chance was before. Valid values: 0-99999 -3. Only calc to split # +3. Only calc to split #. The calculation will stop at split #, if it's not set to 0. -4. Generate Debug File +4. Generate Debug File. This will generate a debug file "pbchance_debug.txt", and will be saved in your LiveSplit folder. You can open it with any text editor. See Features 3. for more information. ## Pictures: @@ -67,4 +67,4 @@ This will generate a debug file "pbchance_debug.txt", and will be saved in your **It displays E# no times found / too many failure attempts in S# [Segment name]* -PBChance can't find historical times. This can in certain circumstances happen, if the Setting "Only consider splits, which are faster than {best Split x X percent" is set too low. Please set it to a higher number, eg. 200%. Skip the newest attempts should be set to 0. +PBChance can't find historical times. This can in certain circumstances happen, if the Setting "Only consider splits, which are faster than {best Split x X percent" is set too low. Please set it to a higher number, >120%. Skip the newest attempts should be set to 0. From 6583e97037c124c3a29b170efcb1d8d95249fec6 Mon Sep 17 00:00:00 2001 From: kasi777 <44654531+kasi777@users.noreply.github.com> Date: Thu, 1 Nov 2018 03:26:20 +0100 Subject: [PATCH 021/278] Update README.md --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index c02d2fa..24f7745 100644 --- a/README.md +++ b/README.md @@ -32,10 +32,10 @@ During a run, PBChance compares the current split time with the best split time. Valid values: 0-999 Suggestion: 1 4. Display survival chance This will display in addition a percent number. The formula is simply [finished runs]/[total remaining runs]. -5. Newer split times are more important than old ones +5. Newer split times are more important than old ones. Newer attempts will be selected more often during a simulated run. Valid values: 0-100 Suggestion: 100 -6. Malus on failures # seconds +6. Malus on failures # seconds. For each discontinued run, a failed split will be generated. It's added every time to a simulated run, if a failed split is selected. Valid values: 0-999 Suggestion: it depends. Can be set to 0, if "Display survival chance" is set. 7. Only consider splits, which are faster than {bestSplit[s] x # percent} From e6871b9a2814fe1fb5d3604bd7c1dfed6f146ad6 Mon Sep 17 00:00:00 2001 From: kasi777 <44654531+kasi777@users.noreply.github.com> Date: Thu, 1 Nov 2018 03:27:53 +0100 Subject: [PATCH 022/278] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 24f7745..f31ee71 100644 --- a/README.md +++ b/README.md @@ -40,7 +40,7 @@ For each discontinued run, a failed split will be generated. It's added every ti Valid values: 0-999 Suggestion: it depends. Can be set to 0, if "Display survival chance" is set. 7. Only consider splits, which are faster than {bestSplit[s] x # percent} Very slow split times will be eliminated. Should set to a number, which are clearly too slow for a normal run. Should be checked with the debug file (clipped splits), for the correct setting and result. -Valid values: 100-999 Suggestion: 150-250 +Valid values: 100-999 Suggestion: 150-200 Hint: The displaying chance on the start should be realistic. But rather too small than too high, for more motivation during a run. Try with these settings to optimize the chance estimation. From 096e975d1e93596e958ca708b16f32de88c0d26f Mon Sep 17 00:00:00 2001 From: kasi777 <44654531+kasi777@users.noreply.github.com> Date: Thu, 1 Nov 2018 20:17:19 +0100 Subject: [PATCH 023/278] Add files via upload --- PBChance.dll | Bin 47616 -> 48640 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/PBChance.dll b/PBChance.dll index de437782d174176499a88a6c86707edf2575a301..eada7080b02f5e55e594686d9f94edded18a3d97 100644 GIT binary patch delta 12557 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 s|53eU_8nI<2akF|yS8LmY2bLo{CK| Date: Fri, 2 Nov 2018 01:50:28 +0100 Subject: [PATCH 024/278] Add files via upload --- PBChance.dll | Bin 48640 -> 48640 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/PBChance.dll b/PBChance.dll index eada7080b02f5e55e594686d9f94edded18a3d97..1000291227facff5d4227d72e9dbde4bccc9d0b7 100644 GIT binary patch delta 1626 zcmZA1du&rx90&04IlaBTTi0!OecW#C)(v6L4$5F#*A3}-7Tk0)LEr7gXG5?s9oULkW%MGiMsoEN+HJm2_EbVo& zAy=jJ1)pi+N7s5Ob_+wUX)NWIB>Sy_QZ2{|3ai+pyG?qGiY2AmbUW`L*BMo#EftjQ z@+^>b-a?>|{py|0#yvf@FJ){Tm{Df#ko^sr9r70OtxMUrsw4Nd`i1@Q&V)C4UjyO#2Hg#L2LMH_H>DpZl^3+awB&WFV^Gi40jT? z&*ztGjM{VATfVLT)qTy^z#b^fanNo2B%}=?-mTif9#ljBtDFXMSh>Gadwp_hO6}lv zbf_I>9bIZyBr&Pq@2{l9$M%*TBU|*^z-bH7_3>#jDYxFHx_EVU#G}uvddH%V*QS~h zzc1tM;0jsiSON{|@~q0ad}uSZ8^Mwc4Im}5t;*e~Kyzny=DmuHN<>Uu%W1TgbF~YN z7Z{2OE%U9HDse|vWK`M6)twOGak(5-SS!>^46PGNnR-&_nSy7fDr_;8^ln#WK67VQ z$`x0JR3RyJ)8*#bL7`JTtH!HB=Xq9*{?3HaMN%m(j*}X^DZ-h>1T}b1Xv!NWwfI0N zpJ%oBROl4X>Tp)*te2n;qe4&dEQpIj37!RURp=X@)nmL9#{Nm=Cmz=0x(El<44H|4 zgx*)(m9=M`1KLISuGNhOEEihLk8KWC2(9GDHV12k4i&}8Ts$JwUqmn$JwgLYoHSyy&KBVsKI!#VVQ7l?%Xb+Y+qga3s@5yGWqt&tymrR|(dc}>!aIG>k{raQ6 zWrb74`(6u_wMUQoj^=M^K9+m6%4^Y6+4^1iMrM z(OOfsL(;@*Qa9}%Hl=MkWZ{p-BSB3n!D!Jm+9qw%)Fbt1Vhkc-{mtydNp>=y_kHj8 z=DnGnsV!k@OPG60$mtH8$Q0b`fs0SY|9lhZ1|4^SaYG;{*~}12y!tKRPy!*RGRO)A z&!X}sJC^TQ*LngS^b=r2-#Bo75MX*Mu<;GBOoK|*9^t+q9L`tkj9)O}!(4USBuUbl zbm~{XVo>H1tjeEpQEEv-yU}^uNUd_b?4B2j41noqE1kAQOM~3t+NWo-ZO~$@KSZI@ zYquy@lM6)04t`4>7S9U*Cyyy}R#AL*ry;}UR1y*km2GRIxJ-AckI%5>nP~+v7LV+4 zjWJ~^rA0DPm=*u7TWQX*D0fmO3g3>xNH9NByRTEtw8GH^BSwl|p<%)Ntmx6t^*Ad= zaoW>k%%lHMNbRvyKaIsHN9@lC$F|fP_F}=)pQtU*Z5yz-Ww$KS!rJ9_w{_dU7m=!CX}nxvYd zN$q04yx%oLX{OTe7*|F!@@<}QI4pZO~Rp#ZUV+vrEphvlgZ#dw}8Z1=Geyu=kxSqVnDmMAO5>s&YN45gUndYLjO-r@37 z=EOYL9m>k^z8Bj3v(oPrmf->qgK~(KV}a|MY(+UjTmgHCRp4W;^L8sL@FmyZ<`ApI z*IX>tib~w#T4g@A3wOD0GlpIGg+%kuO6QCrR)t4AykfMX3Y%Q5v~AT8x+443N845n zGuP=PAFF|d>s%5;4IErS$;WDu$8}j^s6`o9h1tjIP^-yL(|hQnREIr0oR15!-Du+q z##yl&-CRC;O!esJnxIEfkLS2zZ9eA0i(DBt1{cP5BzyojE^$?o8gO5iKk^DS;)Pyq zg~!n*ydgGXLf5SHm2pPggK1sU(z@{k>10H(S*oxXi+r5TG$(rS*8#1{G}hhOS<#A>NT#+PPVY=S65k}ZG<@H7cH_*G^V@5+>d2LOlQXCL$EURd z^k0R8zF@2L(Oz8y4jg>q;99OfH2LX3bI^4<`iIV;8MQJbv82Rxt$*Yw(XO)tIVpl; cT^U-sq-J05VQT#Hra@?|QRVA@us~(he>dGz=>Px# From 748a3fec057ce9f3c4af0e00aba5bada4b57e7f1 Mon Sep 17 00:00:00 2001 From: kasi777 <44654531+kasi777@users.noreply.github.com> Date: Fri, 2 Nov 2018 02:05:10 +0100 Subject: [PATCH 025/278] Update README.md --- README.md | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index f31ee71..9a3d3bc 100644 --- a/README.md +++ b/README.md @@ -65,6 +65,10 @@ This will generate a debug file "pbchance_debug.txt", and will be saved in your ## Troubleshooting: -**It displays E# no times found / too many failure attempts in S# [Segment name]* +**It displays E3 no times found in S# [Segment name] for a moment* -PBChance can't find historical times. This can in certain circumstances happen, if the Setting "Only consider splits, which are faster than {best Split x X percent" is set too low. Please set it to a higher number, >120%. Skip the newest attempts should be set to 0. +PBChance can't find historical times, gives a warning and uses best split time instead. This can happen, if "Skip the newest attempts" is set (or in rare cases the split file contains a negative number