public DetailForm(ReplayFile replayFile, RequestManager requestManager, ExeManager exeManager, ReplayPlayer replayPlayer, Scribe scribe)
{
_replayFile = replayFile;
_requestManager = requestManager;
_exeManager = exeManager;
_replayPlayer = replayPlayer;
_logger = scribe;
InitializeComponent();
// Load split button menu for game executables
LeagueExecutable[] listOfExecs = _exeManager.GetExecutables();
// No items? Don't load the menu
if (listOfExecs.Count() > 0)
{
var execMenu = new ContextMenuStrip
{
ShowCheckMargin = false,
ShowImageMargin = false,
};
execMenu.ItemClicked += new ToolStripItemClickedEventHandler(GeneralStartReplayMenuItem_Click);
foreach (var item in listOfExecs)
{
execMenu.Items.Add(item.Name);
}
this.GeneralPlayReplaySplitButton.Menu = execMenu;
}
}
private void CheckFileReference(ReplayFile file)
{
if (file == null || String.IsNullOrEmpty(file.Location) || String.IsNullOrEmpty(file.Name))
{
throw new ArgumentNullException($"{exceptionOriginName} - File reference is null");
}
}
public ReplayPreview(ReplayFile replayFile, DateTimeOffset creationDate, bool newFile = false)
{
if (replayFile == null)
{
throw new ArgumentNullException(nameof(replayFile));
}
// Copy all the replay file fields
Name = replayFile.Name;
GameDuration = replayFile.GameDuration;
GameVersion = replayFile.GameVersion;
MatchId = replayFile.MatchId;
MapName = replayFile.MapName;
IsBlueVictorious = replayFile.IsBlueVictorious;
Location = replayFile.Location;
// Set new fields
CreationDate = creationDate;
IsNewFile = newFile;
BluePreviewPlayers = (from bplayer in replayFile.BluePlayers
select new PlayerPreview(bplayer)).ToList();
RedPreviewPlayers = (from rplayer in replayFile.RedPlayers
select new PlayerPreview(rplayer)).ToList();
}
private InferredData InferData(ReplayFile file)
{
return(new InferredData()
{
MapID = InferMap(file.Data.MatchMetadata)
});
}
private void CheckFileExistence(ReplayFile file)
{
if (!File.Exists(file.Location))
{
throw new FileNotFoundException($"{exceptionOriginName} - File path not found, does the file exist?");
}
}
public static string ConstructJsonString(ReplayFile replay, List <ExportSelectItem> LevelOneItems, List <ExportSelectItem> LevelTwoItems, List <ExportSelectItem> LevelThreeItems)
{
if (replay == null)
{
throw new ArgumentNullException(nameof(replay));
}
if (LevelOneItems == null)
{
throw new ArgumentNullException(nameof(LevelOneItems));
}
if (LevelTwoItems == null)
{
throw new ArgumentNullException(nameof(LevelTwoItems));
}
if (LevelThreeItems == null)
{
throw new ArgumentNullException(nameof(LevelThreeItems));
}
JObject result = new JObject();
JsonSerializeLevelOne(result, LevelOneItems);
JsonSerializeLevelTwo(result, LevelTwoItems);
JsonSerializeLevelThree(result, replay, LevelThreeItems);
return(result.ToString(Newtonsoft.Json.Formatting.Indented));
}
public ReplaySubmitResponse SubmitReplayFile([FromForm] ReplaySubmission replaySubmission)
{
ReplaySubmitResponse response = new ReplaySubmitResponse();
Game game = Game.GetById(Database.Connection, replaySubmission.GameId);
if (game == null)
{
response.Success = false;
response.Message = String.Format("No matching game found for that replay. Replay {0} NOT uploaded.", replaySubmission.File.FileName);
return(response);
}
ReplayFile replayFile = ReplayFile.GetByGameIdUploaderId(Database.Connection, game.Id, replaySubmission.UploaderId);
if (replayFile != null)
{
response.Success = true;
response.Message = String.Format("A matching replay for Game #{0} was already found. Replay {1} NOT uploaded.", game.Id, replaySubmission.File.FileName);
return(response);
}
replayFile = new ReplayFile(replaySubmission.File, game.Id);
replayFile.Save(Database.Connection);
response.Success = true;
response.Message = String.Format("Replay successfully saved for Game #{0}", game.Id);
return(response);
}
public static void ReplayMenuInit(WndTopLevelWindow window, Game game)
{
var listBox = (WndWindowListBox)window.Root.FindChild("ReplayMenu.wnd:ListboxReplayFiles");
using (var fileSystem = GetReplaysFileSystem(game))
{
listBox.ListBoxItems.Clear();
foreach (var file in fileSystem.Files)
{
var replayFile = ReplayFile.FromFileSystemEntry(file, onlyHeader: true);
listBox.ListBoxItems.Add(new WndListBoxItem
{
DataItem = file.FilePath,
ColumnData = new[]
{
replayFile.Header.Filename, // Path.GetFileNameWithoutExtension(file.FilePath),
$"{replayFile.Header.Timestamp.Hour.ToString("D2")}:{replayFile.Header.Timestamp.Minute.ToString("D2")}",
replayFile.Header.Version,
replayFile.Header.Metadata.MapFile.Replace("maps/", string.Empty)
}
});
}
}
}
public static void ReplayMenuInit(Window window, Game game)
{
var listBox = (ListBox)window.Controls.FindControl("ReplayMenu.wnd:ListboxReplayFiles");
using (var fileSystem = GetReplaysFileSystem(game))
{
var newItems = new List <ListBoxDataItem>();
foreach (var file in fileSystem.Files)
{
var replayFile = ReplayFile.FromFileSystemEntry(file, onlyHeader: true);
newItems.Add(new ListBoxDataItem(
file.FilePath,
new[]
{
replayFile.Header.Filename, // Path.GetFileNameWithoutExtension(file.FilePath),
$"{replayFile.Header.Timestamp.Hour.ToString("D2")}:{replayFile.Header.Timestamp.Minute.ToString("D2")}",
replayFile.Header.Version,
replayFile.Header.Metadata.MapFile.Replace("maps/", string.Empty)
}));
}
listBox.Items = newItems.ToArray();
}
}
private void WriteOrders(ReplayFile replayFile)
{
foreach (var chunk in replayFile.Chunks)
{
_output.WriteLine($"{chunk.Header.Timecode.ToString().PadLeft(5, ' ')}, {chunk.Header.Number}. {chunk.Order}");
}
}
public ReplayConnection(ReplayFile replayFile)
{
foreach (var chunk in replayFile.Chunks)
{
_chunks.Enqueue(chunk);
}
}
private void SwitchKey0And1BecauseOsuSucks()
{
for (int i = 0; i < ReplayFile.Count(); i++)
{
if (ReplayFile[i].Key == 1)
{
ReplayFile[i].Key = -1;
}
if (ReplayFile[i].Key == 0)
{
ReplayFile[i].Key = -2;
}
}
for (int i = 0; i < ReplayFile.Count(); i++)
{
if (ReplayFile[i].Key == -1)
{
ReplayFile[i].Key = 0;
}
if (ReplayFile[i].Key == -2)
{
ReplayFile[i].Key = 1;
}
}
}
/// <summary>
/// Given non-null ReplayFile object with valid Location, Name, and Type -
/// Returns ReplayFile object with filled out Data.
/// </summary>
/// <param name="file"></param>
/// <returns></returns>
public async Task <ReplayFile> ReadFile(ReplayFile file)
{
CheckInput(file);
file.Data = await ParseFile(file);
file.Data.InferredData = InferData(file);
return(file);
}
private static ReplayFile LoadReplayFile([CallerMemberName] string testName = null)
{
using (var fileSystem = new DiskFileSystem(Path.Combine(Environment.CurrentDirectory, "Data", "Rep", "Assets")))
{
var entry = fileSystem.GetFile(testName + ".rep");
return(ReplayFile.FromFileSystemEntry(entry));
}
}
private async Task <ReplayHeader> ParseFile(ReplayFile file)
{
IReplayParser parser = SelectParser(file);
using (FileStream fs = new FileStream(file.Location, FileMode.Open))
{
return(await parser.ReadReplayAsync(fs));
}
}
public static string ConstructCsvString(ReplayFile replay, List <ExportSelectItem> LevelTwoItems, List <ExportSelectItem> LevelThreeItems)
{
if (replay == null)
{
throw new ArgumentNullException(nameof(replay));
}
if (LevelTwoItems == null)
{
throw new ArgumentNullException(nameof(LevelTwoItems));
}
if (LevelThreeItems == null)
{
throw new ArgumentNullException(nameof(LevelThreeItems));
}
List <string> lines = new List <string>();
bool doneOnce = false;
// Add empty line for column index
lines.Add("PLAYER");
// Create enough strings for all the players
foreach (var playerName in LevelTwoItems)
{
if (!playerName.Checked)
{
continue;
}
// Get the player in question
var player = replay.Players.First(x => x.NAME.Equals(playerName.Name, StringComparison.OrdinalIgnoreCase));
var playerString = playerName.Name;
// Load property values for player
foreach (var prop in LevelThreeItems)
{
if (!prop.Checked)
{
continue;
}
// Add property name
if (!doneOnce)
{
lines[0] += "," + prop.Name;
}
// Add property value to player
playerString += "," + player.GetType().GetProperty(prop.Name).GetValue(player)?.ToString();;
}
doneOnce = true; // do not add props to the index more than once
lines.Add(playerString);
}
return(String.Join("\n", lines));
}
public ReplayPacketProvider(string path) : base(path)
{
Replay = ReplayFile.FromJson(File.ReadAllText(path));
for (uint pktId = 0; pktId < Replay.Messages.Length; pktId++)
{
var msg = Replay.Messages[pktId];
ProcessRawUnet(pktId, msg.Timestamp, PacketDirection.FromServer, UNetMessage.Serialize(msg.Data));
}
}
private Task DoPause(object o)
{
return(Task.Factory.StartNew(() =>
{
ReplayFile file = o as ReplayFile;
Parent.SyncContext.Post(c =>
{
file.IsPaused = true;
}, null);
}));
}
public FileResult(ReplayFileInfo fileInfo, ReplayFile replayFile)
{
FileInfo = fileInfo ?? throw new ArgumentNullException(nameof(fileInfo));
ReplayFile = replayFile ?? throw new ArgumentNullException(nameof(replayFile));
Id = FileInfo.Path;
FileName = FileInfo.Name;
FileSizeBytes = FileInfo.FileSizeBytes;
FileCreationTime = FileInfo.CreationTime;
PlayerNames = string.Join("|", ReplayFile.Players.Select(x => x.NAME.ToUpper(CultureInfo.InvariantCulture)));
ChampionNames = string.Join("|", ReplayFile.Players.Select(x => x.SKIN.ToUpper(CultureInfo.InvariantCulture)));
}
public void LoadReplay()
{
replayLoader = new ReplayLoader();
string replayName = loader.gamepath + "/" + Globals.modname.Text + "/jumpdemo/" + Globals.map.Text + "_388.dj3";
replay = replayLoader.LoadReplay(replayName, Globals.scale.Value);
if (replay == null)
{
Console.DebugLog("Goblin replay not found! " + replayName);
}
}
public IActionResult Index(int id)
{
GameIndexViewModel viewModel = new GameIndexViewModel();
viewModel.Game = Game.GetById(Database.Connection, id);
if (viewModel.Game == null)
{
return(RedirectToAction(nameof(HomeController.Index), "Home"));
}
viewModel.ReplayFile = ReplayFile.GetByGameId(Database.Connection, viewModel.Game.Id);
return(View(viewModel));
}
public void LoadReplayFile(FileSystemEntry replayFileEntry)
{
var replayFile = ReplayFile.FromFileSystemEntry(replayFileEntry);
var mapFilename = replayFile.Header.Metadata.MapFile.Replace("userdata", _userDataFileSystem?.RootDirectory);
mapFilename = FileSystem.NormalizeFilePath(mapFilename);
var mapName = mapFilename.Substring(mapFilename.LastIndexOf(Path.DirectorySeparatorChar));
var pSettings = ParseReplayMetaToPlayerSettings(replayFile.Header.Metadata.Slots);
StartMultiPlayerGame(
mapFilename + mapName + ".map",
new ReplayConnection(replayFile),
pSettings.ToArray(),
0);
}
public void LoadReplayFile(FileSystemEntry replayFileEntry)
{
var replayFile = ReplayFile.FromFileSystemEntry(replayFileEntry);
// TODO: This probably isn't right.
var mapFilenameParts = replayFile.Header.Metadata.MapFile.Split('/');
var mapFilename = $"Maps\\{mapFilenameParts[1]}\\{mapFilenameParts[1]}.map";
var pSettings = ParseReplayMetaToPlayerSettings(replayFile.Header.Metadata.Slots);
StartMultiPlayerGame(
mapFilename,
new ReplayConnection(replayFile),
pSettings.ToArray(),
0);
}
public static void ReplayMenuSystem(Control control, WndWindowMessage message, ControlCallbackContext context)
{
switch (message.MessageType)
{
case WndWindowMessageType.SelectedButton:
switch (message.Element.Name)
{
case "ReplayMenu.wnd:ButtonLoadReplay":
// TODO: Handle no selected item.
var listBox = (ListBox)control.Window.Controls.FindControl("ReplayMenu.wnd:ListboxReplayFiles");
ReplayFile replayFile;
using (var fileSystem = GetReplaysFileSystem(context.Game))
{
var replayFileEntry = fileSystem.GetFile((string)listBox.Items[listBox.SelectedIndex].DataItem);
replayFile = ReplayFile.FromFileSystemEntry(replayFileEntry);
}
// TODO: This probably isn't right.
var mapFilenameParts = replayFile.Header.Metadata.MapFile.Split('/');
var mapFilename = $"Maps\\{mapFilenameParts[1]}\\{mapFilenameParts[1]}.map";
context.Game.Scene2D.WndWindowManager.PopWindow();
// TODO: set the correct factions & colors
PlayerSetting[] pSettings = new[]
{
new PlayerSetting("America", new ColorRgb(255, 0, 0)),
new PlayerSetting("Observer", new ColorRgb(255, 255, 255)),
};
context.Game.StartMultiPlayerGame(
mapFilename,
new ReplayConnection(replayFile),
pSettings,
0);
break;
case "ReplayMenu.wnd:ButtonBack":
context.WindowManager.SetWindow(@"Menus\MainMenu.wnd");
// TODO: Go back to Replay sub-menu
break;
}
break;
}
}
/// <summary>
/// Given replay path, construct ReplayFile with all properties initialized
/// </summary>
/// <param name="replayPath"></param>
/// <returns></returns>
private static async Task <ReplayFile> SetupReplayFileAsync(string replayPath)
{
var fileInfo = new ReplayFile
{
Location = replayPath,
Name = Path.GetFileName(replayPath),
};
switch (Path.GetExtension(replayPath))
{
case ".rofl":
fileInfo.Type = REPLAYTYPES.ROFL;
break;
case ".lrf":
MessageBox.Show($"{fileInfo.Name} is a old LoLReplay file.\nROFLPlayer will try to open this file in compatibility mode, some data or features may be missing.", "Compatibility Mode", MessageBoxButtons.OK, MessageBoxIcon.Warning);
fileInfo.Type = REPLAYTYPES.LRF;
break;
case ".lpr":
MessageBox.Show($"{fileInfo.Name} is a old BaronReplay file. ROFLPlayer does not support opening this file.", "Compatibility Mode", MessageBoxButtons.OK, MessageBoxIcon.Error);
fileInfo.Type = REPLAYTYPES.LPR;
Environment.Exit(1);
break;
default:
MessageBox.Show($"{fileInfo.Name} is not a supported file type", "Unsupported File", MessageBoxButtons.OK, MessageBoxIcon.Error);
Environment.Exit(1);
break;
}
var replayReader = new ReplayReader();
try
{
fileInfo = await replayReader.ReadFile(fileInfo);
}
catch (Exception ex)
{
MessageBox.Show($"Exception occured when parsing file:\n{ex.Message}", "Parsing Exception", MessageBoxButtons.OK, MessageBoxIcon.Error);
Environment.Exit(1);
}
return(fileInfo);
}
public IActionResult DownloadReplay(int gameId)
{
Game game = Game.GetById(Database.Connection, gameId);
if (game == null)
{
return(RedirectToAction(nameof(HomeController.Index), "Home"));
}
ReplayFile replayFile = ReplayFile.GetByGameId(Database.Connection, gameId);
if (replayFile == null)
{
return(RedirectToAction(nameof(Index), new { id = gameId }));
}
return(File(replayFile.FileData, "application/x-msdownload", String.Format("replay{0}.slp", gameId)));
}
public FileResult(ReplayFileInfo fileInfo, ReplayFile replayFile)
{
FileInfo = fileInfo ?? throw new ArgumentNullException(nameof(fileInfo));
ReplayFile = replayFile ?? throw new ArgumentNullException(nameof(replayFile));
Id = FileInfo.Path;
SearchKeywords = $"{FileInfo.Name.ToUpper(CultureInfo.InvariantCulture)};" +
$"{ReplayFile.AlternativeName.ToUpper(CultureInfo.InvariantCulture)};" +
$"{string.Join("|", ReplayFile.Players.Select(x => x.NAME.ToUpper(CultureInfo.InvariantCulture)))};" +
$"{string.Join("|", ReplayFile.Players.Select(x => x.SKIN.ToUpper(CultureInfo.InvariantCulture)))}";
FileName = FileInfo.Name;
AlternativeName = replayFile.AlternativeName;
FileSizeBytes = FileInfo.FileSizeBytes;
FileCreationTime = FileInfo.CreationTime;
//PlayerNames = string.Join("|", ReplayFile.Players.Select(x => x.NAME.ToUpper(CultureInfo.InvariantCulture)));
//ChampionNames = string.Join("|", ReplayFile.Players.Select(x => x.SKIN.ToUpper(CultureInfo.InvariantCulture)));
}
private void OnExecute()
{
Application.Init();
var app = new Application("EvoS.PacketInspector", GLib.ApplicationFlags.NonUnique);
app.Register(GLib.Cancellable.Current);
// We require data from the game assets, so ensure we have a valid data path
if (!AssetLoader.FindAssetRoot(Settings.AtlasReactorData))
{
using var settingsUi = new SettingsUi();
settingsUi.Show();
app.AddWindow(settingsUi);
var x = (ResponseType)settingsUi.Run();
if (x != ResponseType.Ok)
{
return;
}
}
HashResolver.Init(AssetLoader.BasePath);
Patcher.ResolveSyncListFields();
Patcher.PatchAll();
var win = new MainWindow();
if (!PacketsDir.IsNullOrEmpty())
{
win.LoadPacketDump(PacketDumpType.PacketDirectory, PacketsDir);
}
else if (!ReplayFile.IsNullOrEmpty())
{
win.LoadPacketDump(PacketDumpType.ReplayFile, ReplayFile);
}
app.AddWindow(win);
win.Show();
Application.Run();
}
/// <summary>
/// Given non-null ReplayFile object with valid Location, Name, and Type -
/// Returns ReplayFile object with filled out Data.
/// </summary>
/// <param name="file"></param>
/// <returns></returns>
public async Task <ReplayFile> ReadFile(ReplayFile file)
{
if (file == null || String.IsNullOrEmpty(file.Location) || String.IsNullOrEmpty(file.Name))
{
throw new ArgumentNullException($"{exceptionOriginName} - File reference is null");
}
if (!File.Exists(file.Location))
{
throw new FileNotFoundException($"{exceptionOriginName} - File path not found, does the file exist?");
}
switch (file.Type)
{
case REPLAYTYPES.ROFL:
file.Data = await ReadROFL(file.Location);
break;
case REPLAYTYPES.LRF:
file.Data = await ReadLRF(file.Location);
break;
case REPLAYTYPES.LPR:
file.Data = await ReadLPR(file.Location);
break;
}
// Make some educated guesses
GameDetailsInferrer detailsInferrer = new GameDetailsInferrer();
file.Data.InferredData = new InferredData()
{
MapID = detailsInferrer.InferMap(file.Data.MatchMetadata)
};
return(file);
}
private static void JsonSerializeLevelThree(JObject result, ReplayFile replay, List <ExportSelectItem> selectItems)
{
// if there is no player property, we cant populate it
if (!result.ContainsKey("Players"))
{
return;
}
// If there are no players, we cannot populate them
if (!result["Players"].Any())
{
return;
}
JArray populatedPlayers = new JArray();
foreach (var playerName in result["Players"])
{
// Get the player in question
var player = replay.Players.First(x => x.NAME.Equals(playerName.ToString(), StringComparison.OrdinalIgnoreCase));
JObject jsonPlayer = new JObject();
foreach (var item in selectItems)
{
if (!item.Checked)
{
continue;
}
// Get the real value
var value = player.GetType().GetProperty(item.Name).GetValue(player)?.ToString();
jsonPlayer[item.Name] = value;
}
// Add player to array
populatedPlayers.Add(jsonPlayer);
}
result["Players"] = populatedPlayers;
}
