/// <summary>
/// Ctor -
/// </summary>
/// <param name="map"></param>
/// <param name="md5"></param>
/// <param name="scores"></param>
/// <param name="replay"></param>
public GameplayScreen(Qua map, string md5, List<Score> scores, Replay replay = null)
{
TimePlayed = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
Map = map;
LocalScores = scores;
MapHash = md5;
LoadedReplay = replay;
Timing = new GameplayAudioTiming(this);
// Remove paused modifier if enabled.
if (ModManager.IsActivated(ModIdentifier.Paused))
ModManager.RemoveMod(ModIdentifier.Paused);
// Handle autoplay replays.
if (ModManager.IsActivated(ModIdentifier.Autoplay))
LoadedReplay = ReplayHelper.GeneratePerfectReplay(map, MapHash);
// Determine if we're in replay mode.
if (LoadedReplay != null)
{
InReplayMode = true;
AddModsFromReplay();
}
// Create the current replay that will be captured.
ReplayCapturer = new ReplayCapturer(this);
SetRuleset();
SetRichPresence();
AudioTrack.AllowPlayback = true;
View = new GameplayScreenView(this);
}
public FileProvider(ILogger <DirectoryProvider> logger, IOptions <Settings> settings, ReplayHelper replayHelper)
{
this.logger = logger;
this.settings = settings.Value;
this.replayHelper = replayHelper;
queue = new Queue <string>(new[] { settings.Value.ReplaySource });
}
public StormPlayerTool(ILogger <StormPlayerTool> logger, StormReplayAnalyzer analyzer, IOptions <Settings> settings, ReplayHelper replayHelper)
{
this.logger = logger;
this.analyzer = analyzer;
this.replayHelper = replayHelper;
this.settings = settings.Value;
}
/// <summary>
/// Ctor -
/// </summary>
/// <param name="map"></param>
/// <param name="md5"></param>
/// <param name="scores"></param>
/// <param name="replay"></param>
/// <param name="isPlayTesting"></param>
/// <param name="playTestTime"></param>
/// <param name="isCalibratingOffset"></param>
public GameplayScreen(Qua map, string md5, List <Score> scores, Replay replay = null, bool isPlayTesting = false, double playTestTime = 0,
bool isCalibratingOffset = false)
{
TimePlayed = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
if (isPlayTesting)
{
var testingQua = ObjectHelper.DeepClone(map);
testingQua.HitObjects.RemoveAll(x => x.StartTime < playTestTime);
Map = testingQua;
OriginalEditorMap = map;
}
else
{
Map = map;
}
LocalScores = scores;
MapHash = md5;
LoadedReplay = replay;
IsPlayTesting = isPlayTesting;
PlayTestAudioTime = playTestTime;
IsCalibratingOffset = isCalibratingOffset;
Timing = new GameplayAudioTiming(this);
// Remove paused modifier if enabled.
if (ModManager.IsActivated(ModIdentifier.Paused))
{
ModManager.RemoveMod(ModIdentifier.Paused);
}
// Handle autoplay replays.
if (ModManager.IsActivated(ModIdentifier.Autoplay))
{
LoadedReplay = ReplayHelper.GeneratePerfectReplay(map, MapHash);
}
// Determine if we're in replay mode.
if (LoadedReplay != null)
{
InReplayMode = true;
}
// Create the current replay that will be captured.
ReplayCapturer = new ReplayCapturer(this);
SetRuleset();
SetRichPresence();
AudioTrack.AllowPlayback = true;
if (IsCalibratingOffset)
{
Metronome = new Metronome(map);
}
View = new GameplayScreenView(this);
}
public AnalyzerTests()
{
IOptions <Settings> options = new OptionsWrapper <Settings>(new Settings {
});
ReplayHelper helper = new ReplayHelper(new NullLogger <ReplayHelper>(), options, new GameDataService());
this.analyzer = new StormReplayAnalyzer(new NullLogger <StormReplayAnalyzer>(), options, helper);
}
public StubOfTheStorm(
ILogger <HeroesOfTheStorm> logger,
IOptions <Settings> settings,
CancellationTokenProvider tokenProvider,
CaptureStrategy captureStrategy,
ReplayHelper replayHelper) : base(logger, settings, tokenProvider, captureStrategy)
{
this.replayHelper = replayHelper;
this.timer = TimeSpan.Zero;
}
public ReplayRunner(
ILogger <ReplayRunner> logger,
HeroesOfTheStorm process,
StormReplaySpectator spectator,
IOptions <Settings> settings,
ReplayHelper replayHelper)
{
this.logger = logger;
this.process = process;
this.spectator = spectator;
this.replayHelper = replayHelper;
this.settings = settings.Value;
}
public static string replaceXMLSpecialChar(string toReplace)
{
if (toReplace != null)
{
toReplace = ReplayHelper.ReplaceUTF8InString(toReplace);
toReplace = toReplace.Replace("&", "&");
toReplace = toReplace.Replace("<", "<");
toReplace = toReplace.Replace(">", ">");
toReplace = toReplace.Replace("\"", """);
toReplace = toReplace.Replace("'", "'");
toReplace = toReplace.Replace(" ", " ");
}
return(toReplace);
}
public string LookupISN(string isn)
{
byte[] bytes;
string text4;
string plainText = "isn=" + isn;
string text2 = ReplayHelper.ByteArrayToHexString(ReplayCrypt.RDDNSEncrypt(plainText)).ToLower();
string requestUri = string.Format("http://{0}/rd/servlet/gu?q={1}", this.rddnsServer, text2);
ZoggrLogger.DebugLog("requestUri: " + requestUri);
try
{
bytes = ReplayCrypt.RDDNSDecrypt(HTTPClient.Get(requestUri));
text4 = Encoding.Default.GetString(bytes);
}
catch
{
Console.WriteLine("RDDNS Lookup Failed");
return(null);
}
if (text4.IndexOf("ReplayError") >= 0)
{
char[] separator = new char[] { ' ' };
string[] textArray = text4.Split(separator);
char[] trimChars = new char[] { '"' };
string text5 = textArray[2].Substring(5).Trim(trimChars);
char[] chArray3 = new char[] { '"' };
string text6 = textArray[3].Substring(3).Trim(chArray3);
if (!text5.Equals("SERVER") || !text6.Equals("-1"))
{
return(text4);
}
text2 = ReplayHelper.ByteArrayToHexString(ReplayCrypt.RDDNSEncrypt(plainText)).ToLower();
requestUri = string.Format("http://{0}/rd/servlet/gu?q={1}", this.rddnsServer, text2);
ZoggrLogger.DebugLog("requestUri: " + requestUri);
try
{
bytes = ReplayCrypt.RDDNSDecrypt(HTTPClient.Get(requestUri));
text4 = Encoding.Default.GetString(bytes);
}
catch
{
Console.WriteLine("RDDNS Lookup Failed");
return(null);
}
}
return(text4);
}
void IGameUi.OnResult(Game.Result result, ReplayHelper replayHelper)
{
EnableRenderer(false);
ProgressBar.Visibility = Visibility.Collapsed;
var time = result?.GetExtraByType <Game.ResultExtraBestLap>()?.Time;
if (!time.HasValue || time.Value == TimeSpan.Zero)
{
_bestLapTime = null;
RevertUi(true);
}
else
{
_resultShown = true;
_bestLapTime = time;
LoadingText.Visibility = Visibility.Visible;
LoadingText.FontSize = 20d;
LoadingText.Text = "Best time: " + string.Format("{0:mm}:{0:ss}:{0:fff}", time.Value);
GameResultOk.Visibility = Visibility.Visible;
PlayerNamePanel.Visibility = Visibility.Visible;
}
}
public DebugTool(ILogger <DebugTool> logger, ReplayHelper replayHelper)
{
this.logger = logger;
this.replayHelper = replayHelper;
}
public StormReplayAnalyzer(ILogger <StormReplayAnalyzer> logger, IOptions <Settings> settings, ReplayHelper replayHelper)
{
this.logger = logger;
this.replayHelper = replayHelper;
this.settings = settings.Value;
}
static void Main(string[] args)
{
Console.WriteLine("Select the replay file.");
OpenFileDialog ofd = new OpenFileDialog();
ofd.Filter = "Osu Replay Files|*.osr";
if (ofd.ShowDialog() != DialogResult.OK)
{
return;
}
Console.Clear();
Console.WriteLine("Loading replay...");
ReplayFile replay = ReplayHelper.ReadFile(ofd.FileName);
OsuHelper.Mods modsBefore = (OsuHelper.Mods)replay.UsedMods;
List <(string fullname, string shortname, int priority, OsuHelper.Mods mod, char key)> availableMods = new List <(string fullname, string shortname, int priority, OsuHelper.Mods mod, char key)>()
{ // RXEZFLHRHDHTDTNCNF
("Relax", "RX", 0, OsuHelper.Mods.Relax, '1'),
("Double Time", "DT", 6, OsuHelper.Mods.DoubleTime, '2'),
("Hidden", "HD", 4, OsuHelper.Mods.Hidden, '3'),
("Hard Rock", "HR", 3, OsuHelper.Mods.HardRock, '4'),
("Nightcore", "NC", 6, OsuHelper.Mods.Nightcore, '5'),
("Flashlight", "FL", 2, OsuHelper.Mods.Flashlight, '6'),
("Easy", "EZ", 1, OsuHelper.Mods.Easy, '7'),
("No Fail", "NF", 7, OsuHelper.Mods.NoFail, '8'),
("Half Time", "HT", 5, OsuHelper.Mods.HalfTime, '9'),
};
List <(string fullname, string shortname, int priority, OsuHelper.Mods mod, char key)> selectedMods = new List <(string fullname, string shortname, int priority, OsuHelper.Mods mod, char key)>();
selectedMods.AddRange(availableMods.Where(x => (x.mod & (OsuHelper.Mods)replay.UsedMods) != 0));
Console.Clear();
while (true)
{
Console.SetCursorPosition(0, 0);
Console.WriteLine("Select the mods. Press enter to continue.");
Console.WriteLine();
string[] mods = selectedMods.OrderBy(x => x.priority).Select(x => x.shortname).ToArray();
mods = mods.Where(x => x != "DT" || !mods.Contains("NC")).ToArray(); // remove DT if NC is enabled so it doesn't show "DTNC"
string strSelectedMods = string.Join("", mods);
Console.WriteLine(("Selected mods: " + strSelectedMods).PadRight(Console.WindowWidth - 1));
Console.WriteLine();
for (int i = 0; i < availableMods.Count; i++)
{
Console.ForegroundColor = ConsoleColor.Gray;
if (selectedMods.Contains(availableMods[i]))
{
Console.ForegroundColor = ConsoleColor.Green;
}
Console.WriteLine($"[{availableMods[i].key}] ({availableMods[i].shortname}) {availableMods[i].fullname}");
Console.ForegroundColor = ConsoleColor.Gray;
}
ConsoleKeyInfo cki = Console.ReadKey(true);
if (cki.Key == ConsoleKey.Enter)
{
break;
}
else
{
var selectedMod = availableMods.FirstOrDefault(x => x.key == cki.KeyChar);
if (selectedMod.fullname != "")
{
if (selectedMod.mod == OsuHelper.Mods.Nightcore && selectedMods.Any(x => x.mod == OsuHelper.Mods.DoubleTime))
{
selectedMods.Remove(availableMods.First(x => x.mod == OsuHelper.Mods.DoubleTime));
}
if (selectedMod.mod == OsuHelper.Mods.DoubleTime && selectedMods.Any(x => x.mod == OsuHelper.Mods.Nightcore))
{
selectedMods.Remove(availableMods.First(x => x.mod == OsuHelper.Mods.Nightcore));
}
if (selectedMods.Contains(selectedMod))
{
selectedMods.Remove(selectedMod);
}
else
{
if (selectedMod.mod == OsuHelper.Mods.Nightcore && !selectedMods.Any(x => x.mod == OsuHelper.Mods.DoubleTime))
{
selectedMods.Add(availableMods.First(x => x.mod == OsuHelper.Mods.DoubleTime));
}
selectedMods.Add(selectedMod);
}
}
}
}
replay.UsedMods = (int)OsuHelper.Mods.None;
foreach (var selectedMod in selectedMods)
{
replay.UsedMods |= (int)selectedMod.mod;
}
if (((OsuHelper.Mods)replay.UsedMods & OsuHelper.Mods.HardRock) != (modsBefore & OsuHelper.Mods.HardRock))
{
replay = flipNotes(replay);
}
Console.Clear();
Console.WriteLine("Select a path for the new replay file.");
SaveFileDialog sfd = new SaveFileDialog();
sfd.Filter = "Osu Replay Files|*.osr";
if (sfd.ShowDialog() != DialogResult.OK)
{
return;
}
if (File.Exists(sfd.FileName))
{
File.Delete(sfd.FileName);
}
Console.Clear();
Console.WriteLine("Saving replay...");
replay.ReplayDate = DateTime.UtcNow; // fix replay data cache problem
replay.ReplayHash = ReplayHelper.GetReplayHash(replay);
ReplayHelper.SaveFile(sfd.FileName, replay);
}
/// <summary>
/// Handles the input of the game + individual game modes.
/// </summary>
/// <param name="gameTime"></param>
private void HandleInput(GameTime gameTime)
{
if (Exiting)
{
return;
}
var dt = gameTime.ElapsedGameTime.TotalMilliseconds;
// Handle pausing
if (!Failed && !IsPlayComplete)
{
HandlePauseInput(gameTime);
}
// Show/hide scoreboard.
if (KeyboardManager.IsUniqueKeyPress(ConfigManager.KeyScoreboardVisible.Value))
{
ConfigManager.ScoreboardVisible.Value = !ConfigManager.ScoreboardVisible.Value;
}
// CTRL+ input while play testing
if (IsPlayTesting && (KeyboardManager.CurrentState.IsKeyDown(Keys.LeftControl) ||
KeyboardManager.CurrentState.IsKeyDown(Keys.RightControl)))
{
if (KeyboardManager.IsUniqueKeyPress(Keys.P))
{
if (!AudioEngine.Track.IsDisposed)
{
if (AudioEngine.Track.IsPlaying)
{
AudioEngine.Track.Pause();
IsPaused = true;
}
else
{
AudioEngine.Track.Play();
IsPaused = false;
}
}
}
}
// Handle the restarting of the map.
HandlePlayRestart(dt);
// Everything after this point is applicable to gameplay ONLY.
if (IsPaused || Failed)
{
return;
}
if (!IsPlayComplete && !IsCalibratingOffset || IsMultiplayerGame)
{
if (KeyboardManager.IsUniqueKeyPress(ConfigManager.KeyQuickExit.Value))
{
HandleQuickExit();
}
}
if (!IsPlayComplete && !IsCalibratingOffset)
{
if (KeyboardManager.IsUniqueKeyPress(ConfigManager.KeySkipIntro.Value))
{
SkipToNextObject();
}
// Go back to editor at the same time
if (IsPlayTesting && KeyboardManager.IsUniqueKeyPress(Keys.F2))
{
if (AudioEngine.Track.IsPlaying)
{
AudioEngine.Track.Pause();
}
Exit(() => new EditorScreen(OriginalEditorMap));
}
// Handle play test autoplay input.
if (IsPlayTesting && KeyboardManager.IsUniqueKeyPress(Keys.Tab))
{
var inputManager = (KeysInputManager)Ruleset.InputManager;
if (LoadedReplay == null)
{
LoadedReplay = ReplayHelper.GeneratePerfectReplay(Map, MapHash);
inputManager.ReplayInputManager = new ReplayInputManagerKeys(this);
inputManager.ReplayInputManager.HandleSkip();
inputManager.ReplayInputManager.CurrentFrame++;
}
InReplayMode = !InReplayMode;
inputManager.ReplayInputManager.HandleSkip();
inputManager.ReplayInputManager.CurrentFrame++;
if (!InReplayMode)
{
for (var i = 0; i < Map.GetKeyCount(); i++)
{
inputManager.ReplayInputManager.UniquePresses[i] = false;
inputManager.ReplayInputManager.UniqueReleases[i] = true;
inputManager.BindingStore[i].Pressed = false;
var playfield = (GameplayPlayfieldKeys)Ruleset.Playfield;
playfield.Stage.HitLightingObjects[i].StopHolding();
playfield.Stage.SetReceptorAndLightingActivity(i, inputManager.BindingStore[i].Pressed);
}
inputManager.HandleInput(gameTime.ElapsedGameTime.TotalMilliseconds);
}
NotificationManager.Show(NotificationLevel.Info, $"Autoplay has been turned {(InReplayMode ? "on" : "off")}");
}
// Only allow offset changes if the map hasn't started or if we're on a break
if (Ruleset.Screen.Timing.Time <= 5000 || Ruleset.Screen.EligibleToSkip)
{
var change = 5;
if (KeyboardManager.CurrentState.IsKeyDown(Keys.LeftControl) ||
KeyboardManager.CurrentState.IsKeyDown(Keys.RightControl))
{
change = 1;
}
// Handle offset +
if (KeyboardManager.IsUniqueKeyPress(ConfigManager.KeyIncreaseMapOffset.Value))
{
MapManager.Selected.Value.LocalOffset += change;
NotificationManager.Show(NotificationLevel.Success, $"Local map offset is now: {MapManager.Selected.Value.LocalOffset} ms");
MapDatabaseCache.UpdateMap(MapManager.Selected.Value);
}
// Handle offset -
if (KeyboardManager.IsUniqueKeyPress(ConfigManager.KeyDecreaseMapOffset.Value))
{
MapManager.Selected.Value.LocalOffset -= change;
NotificationManager.Show(NotificationLevel.Success, $"Local map offset is now: {MapManager.Selected.Value.LocalOffset} ms");
MapDatabaseCache.UpdateMap(MapManager.Selected.Value);
}
}
}
// Handle input per game mode.
Ruleset.HandleInput(gameTime);
}
/// <summary>
/// Ctor -
/// </summary>
/// <param name="map"></param>
/// <param name="md5"></param>
/// <param name="scores"></param>
/// <param name="replay"></param>
/// <param name="isPlayTesting"></param>
/// <param name="playTestTime"></param>
/// <param name="isCalibratingOffset"></param>
/// <param name="spectatorClient"></param>
public GameplayScreen(Qua map, string md5, List <Score> scores, Replay replay = null, bool isPlayTesting = false, double playTestTime = 0,
bool isCalibratingOffset = false, SpectatorClient spectatorClient = null)
{
TimePlayed = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
if (isPlayTesting)
{
var testingQua = ObjectHelper.DeepClone(map);
testingQua.HitObjects.RemoveAll(x => x.StartTime < playTestTime);
Qua.RestoreDefaultValues(testingQua);
Map = testingQua;
OriginalEditorMap = map;
}
else
{
Map = map;
}
LocalScores = scores;
MapHash = md5;
LoadedReplay = replay;
IsPlayTesting = isPlayTesting;
PlayTestAudioTime = playTestTime;
IsCalibratingOffset = isCalibratingOffset;
IsMultiplayerGame = OnlineManager.CurrentGame != null;
SpectatorClient = spectatorClient;
if (SpectatorClient != null)
{
LoadedReplay = SpectatorClient.Replay;
}
if (IsMultiplayerGame)
{
OnlineManager.Client.OnUserJoinedGame += OnUserJoinedGame;
OnlineManager.Client.OnUserLeftGame += OnUserLeftGame;
OnlineManager.Client.OnAllPlayersLoaded += OnAllPlayersLoaded;
OnlineManager.Client.OnAllPlayersSkipped += OnAllPlayersSkipped;
}
Timing = new GameplayAudioTiming(this);
// Initialize the custom audio sample cache and the sound effect index.
if (!IsCalibratingOffset)
{
CustomAudioSampleCache.LoadSamples(MapManager.Selected.Value, MapHash);
}
NextSoundEffectIndex = 0;
UpdateNextSoundEffectIndex();
// Remove paused modifier if enabled.
if (ModManager.IsActivated(ModIdentifier.Paused))
{
ModManager.RemoveMod(ModIdentifier.Paused);
}
// Handle autoplay replays.
if (ModManager.IsActivated(ModIdentifier.Autoplay))
{
LoadedReplay = ReplayHelper.GeneratePerfectReplay(map, MapHash);
}
// Determine if we're in replay mode.
if (LoadedReplay != null)
{
InReplayMode = true;
}
// Create the current replay that will be captured.
ReplayCapturer = new ReplayCapturer(this);
SetRuleset();
SetRichPresence();
AudioTrack.AllowPlayback = true;
if (IsCalibratingOffset)
{
Metronome = new Metronome(map);
}
View = new GameplayScreenView(this);
}
public HeroesProfileService(ILogger <HeroesProfileService> logger, Settings settings, ReplayHelper replayHelper)
{
this.logger = logger;
this.settings = settings.HeroesProfileApi;
this.replayHelper = replayHelper;
}
public ReplayDetailsWriter(ILogger <ReplayDetailsWriter> logger, IOptions <Settings> settings, ReplayHelper replayHelper, HeroesProfileService heroesProfileService, GameDataService gameDataService)
{
this.logger = logger;
this.heroesProfileService = heroesProfileService;
this.gameDataService = gameDataService;
this.settings = settings.Value;
}
public HeroesProfileService(ILogger <HeroesProfileService> logger, IOptions <Settings> settings, ReplayHelper replayHelper)
{
this.logger = logger;
this.settings = settings.Value;
this.replayHelper = replayHelper;
}
public DirectoryProvider(ILogger <DirectoryProvider> logger, IOptions <Settings> settings, ReplayHelper replayHelper)
{
this.logger = logger;
this.replayHelper = replayHelper;
queue = new Queue <string>(Directory.GetFiles(settings.Value.ReplaySource, Constants.STORM_REPLAY_WILDCARD, SearchOption.AllDirectories).OrderBy(GetCreationTime));
}
void IGameUi.OnResult(Game.Result result, ReplayHelper replayHelper)
{
if (result != null && result.NumberOfSessions == 1 && result.Sessions.Length == 1 &&
result.Sessions[0].Type == Game.SessionType.Practice && SettingsHolder.Drive.SkipPracticeResults ||
_properties?.ReplayProperties != null || _properties?.BenchmarkProperties != null)
{
Close();
return;
}
/* save replay button * /
* Func<string> buttonText = () => replayHelper?.IsReplayRenamed == true ?
* AppStrings.RaceResult_UnsaveReplay : AppStrings.RaceResult_SaveReplay;
*
* var saveReplayButton = CreateExtraDialogButton(buttonText(), () => {
* if (replayHelper == null) {
* Logging.Warning("ReplayHelper=<NULL>");
* return;
* }
*
* replayHelper.IsReplayRenamed = !replayHelper.IsReplayRenamed;
* });
*
* if (replayHelper == null) {
* saveReplayButton.IsEnabled = false;
* } else {
* replayHelper.PropertyChanged += (sender, args) => {
* if (args.PropertyName == nameof(ReplayHelper.IsReplayRenamed)) {
* saveReplayButton.Content = buttonText();
* }
* };
* }
*
* /* save replay alt button */
ButtonWithComboBox saveReplayButton;
if (replayHelper != null)
{
Func <string> buttonText = () => replayHelper.IsRenamed ?
AppStrings.RaceResult_UnsaveReplay : AppStrings.RaceResult_SaveReplay;
Func <string> saveAsText = () => string.Format(replayHelper.IsRenamed ? "Saved as “{0}”" : "Save as “{0}”",
replayHelper.Name);
saveReplayButton = new ButtonWithComboBox {
Margin = new Thickness(4, 0, 0, 0),
MinHeight = 21,
MinWidth = 65,
Content = ToolsStrings.Shared_Replay,
Command = new AsyncCommand(replayHelper.Play),
MenuItems =
{
new MenuItem {
Header = saveAsText(), Command = new DelegateCommand(() =>{
var newName = Prompt.Show("Save replay as:", "Replay Name", replayHelper.Name, "?", required: true);
if (!string.IsNullOrWhiteSpace(newName))
{
replayHelper.Name = newName;
}
replayHelper.IsRenamed = true;
})
},
new MenuItem {
Header = buttonText(), Command = new DelegateCommand(replayHelper.Rename)
},
new Separator(),
new MenuItem {
Header = "Share Replay",
Command = new AsyncCommand(() =>{
var car = _properties?.BasicProperties?.CarId == null ? null :
CarsManager.Instance.GetById(_properties.BasicProperties.CarId);
var track = _properties?.BasicProperties?.TrackId == null ? null :
TracksManager.Instance.GetById(_properties.BasicProperties.TrackId);
return(SelectedReplayPage.ShareReplay(replayHelper.Name, replayHelper.Filename, car, track));
})
},
}
};
replayHelper.PropertyChanged += (sender, args) => {
if (args.PropertyName == nameof(ReplayHelper.IsRenamed))
{
((MenuItem)saveReplayButton.MenuItems[0]).Header = saveAsText();
((MenuItem)saveReplayButton.MenuItems[1]).Header = buttonText();
}
};
}
else
{
saveReplayButton = null;
}
var tryAgainButton = CreateExtraDialogButton(AppStrings.RaceResult_TryAgain, () => {
CloseWithResult(MessageBoxResult.None);
GameWrapper.StartAsync(_properties).Forget();
});
Button fixButton = null;
if (result == null || !result.IsNotCancelled)
{
Model.CurrentState = ViewModel.State.Cancelled;
var whatsGoingOn = _properties?.GetAdditional <WhatsGoingOn>();
fixButton = this.CreateFixItButton(whatsGoingOn?.Solution);
Model.ErrorMessage = whatsGoingOn?.GetDescription();
}
else
{
try {
Model.CurrentState = ViewModel.State.Finished;
Model.FinishedData = GetFinishedData(_properties, result);
} catch (Exception e) {
Logging.Warning(e);
Model.CurrentState = ViewModel.State.Error;
Model.ErrorMessage = AppStrings.RaceResult_ResultProcessingError;
Buttons = new[] { CloseButton };
return;
}
}
Buttons = new[] {
fixButton,
fixButton == null ? saveReplayButton : null,
fixButton == null ? tryAgainButton : null,
CloseButton
};
}
public GameStateTool(ILogger <GameStateTool> logger, HeroesOfTheStorm heroesOfTheStorm, ReplayHelper replayHelper)
{
this.logger = logger;
this.heroesOfTheStorm = heroesOfTheStorm;
this.replayHelper = replayHelper;
}
public GamePanelTool(StormReplayAnalyzer analyzer, ReplayHelper replayHelper)
{
this.analyzer = analyzer;
this.replayHelper = replayHelper;
}
