/// <summary>
/// StartReplayService method implementation
/// </summary>
private void StartReplayService()
{
try
{
_svchost.StartService(this);
ReplayClient replaymanager = new ReplayClient();
replaymanager.Initialize();
try
{
IReplay client = replaymanager.Open();
try
{
client.WarmUp();
}
catch (Exception e)
{
this.EventLog.WriteEntry(string.Format("Error on WarmUp ReplayService : {0}.", e.Message), EventLogEntryType.Error, 1001);
}
finally
{
replaymanager.Close(client);
}
}
finally
{
replaymanager.UnInitialize();
}
}
catch (Exception e)
{
this.EventLog.WriteEntry(string.Format("Error when starting ReplayService : {0}.", e.Message), EventLogEntryType.Error, 1001);
}
}
public ReplayStats(IReplay replayer)
{
_replayer = replayer;
_vectors = replayer.Vectors.ToList();
TotalSegments = _vectors.Count();
StartTime = _vectors[0].Time;
EndTime = _vectors[TotalSegments - 1].Time;
TotalTime = EndTime - StartTime;
Velocities = new List <double>();
Velocities.Add(0);
for (var i = 1; i < TotalSegments; i++)
{
var distance = _vectors[i].Vector.magnitude;
var time = (_vectors[i].Time - _vectors[i - 1].Time).TotalMilliseconds;
if (time == 0)
{
Velocities.Add(0);
}
else
{
Velocities.Add(distance / time);
}
}
var sortedVelocities = Velocities.OrderBy(x => x).ToList();
MaxVelocity = sortedVelocities.Last();
MinVelocity = sortedVelocities.First();
TotalDistance = _vectors.Aggregate(0f, (x, y) => y.Vector.magnitude);
AverageVelocity = Velocities.Aggregate(0f, (x, y) => (float)(x + y)) / Velocities.Count;
}
public ReplayStats(IReplay replayer)
{
_replayer = replayer;
_vectors = replayer.Vectors.ToList();
TotalSegments = _vectors.Count();
StartTime = _vectors[0].Time;
EndTime = _vectors[TotalSegments - 1].Time;
TotalTime = EndTime - StartTime;
Velocities = new List<double>();
Velocities.Add(0);
for (var i = 1; i < TotalSegments; i++)
{
var distance = _vectors[i].Vector.magnitude;
var time = (_vectors[i].Time - _vectors[i - 1].Time).TotalMilliseconds;
if (time == 0)
Velocities.Add(0);
else
Velocities.Add(distance / time);
}
var sortedVelocities = Velocities.OrderBy(x => x).ToList ();
MaxVelocity = sortedVelocities.Last();
MinVelocity = sortedVelocities.First();
TotalDistance = _vectors.Aggregate(0f, (x, y) => y.Vector.magnitude);
AverageVelocity = Velocities.Aggregate(0f, (x, y) => (float)(x + y)) / Velocities.Count;
}
// All players should execute build actions, train/morph units while observers can not.
public static IEnumerable <IPlayer> ExtractObservers(IReplay replay)
{
IList <IPlayer> players = new List <IPlayer>(replay.Players);
foreach (IAction action in replay.Actions)
{
// make collection of actions instead + what is ActionType.Target ?? how is A-Move recorded? Which actions can and can't observers do???
if (action.ActionType == ActionType.Build || action.ActionType == ActionType.Train || action.ActionType == ActionType.UnitMorph || action.ActionType == ActionType.BuildingMorph || action.ActionType == ActionType.Research || action.ActionType == ActionType.UseCheat)
{
if (players.Count > 0)
{
players.Remove(action.Player);
}
else
{
break;
}
//return null;
}
}
foreach (var player in players)
{
player.IsObserver = true;
}
return(players);
}
/// <summary>
/// Decompress and retrieve the <see cref="ReplayMoveData"/> from the current replay.
/// </summary>
/// <param name="replay">Instance of the replay.</param>
public static IReadOnlyList <ReplayMoveData> GetReplayMoveData(this IReplay replay)
{
if (replay == null)
{
throw new ArgumentNullException(nameof(replay));
}
var decompressedData = SevenZipLZMAHelper.Decompress(replay.CompressedReplayData.ToArray());
var decompressedDataString = Encoding.UTF8.GetString(decompressedData);
var moveData = new List <ReplayMoveData>();
foreach (var replayData in decompressedDataString.Split(','))
{
var contents = replayData.Split('|');
if (contents.Length < 4)
{
continue;
}
moveData.Add(new ReplayMoveData(long.Parse(contents[0]), float.Parse(contents[1]), float.Parse(contents[2]), int.Parse(contents[3])));
}
return(moveData.AsReadOnly());
}
/// <summary>
/// Close method implementation
/// </summary>
public void Close(IReplay client)
{
if (client != null)
{
((IClientChannel)client).Close();
}
}
public static IPlayer ExtractWinner(IReplay replay)
{
IList <IPlayer> players = new List <IPlayer>(replay.Players);
foreach (IAction action in replay.Actions)
{
if (action.ActionType == ActionType.LeaveGame)
{
LeaveGameAction a = (LeaveGameAction)action;
switch (a.LeaveGameType)
{
case LeaveGameType.Dropped:
return(null);
case LeaveGameType.Quit:
players.Remove(a.Player);
break;
default:
throw new InvalidOperationException();
}
}
}
if (players.Count() == 1)
{
return(players[0]);
}
return(null);
}
public static void PrintActionType <T>(IReplay replay)
{
var actions1 = replay.Actions.Where(x => x is T)
.OrderBy(x => x.Frame)
.ToList <IAction>();
foreach (var a in actions1)
{
if (typeof(T) == typeof(BuildAction))
{
System.Console.Write("{0,10} - {2,-15} - {1,10}", a.Frame, a.ActionType, a.Player.Name);
System.Console.Write(" - {0}", ((BuildAction)a).ObjectType);
}
else if (typeof(T) == typeof(GenericObjectTypeAction))
{
System.Console.Write("{0,10} - {2,-15} - {1,10}", a.Frame, a.ActionType, a.Player.Name);
System.Console.Write(" - {0}", ((GenericObjectTypeAction)a).ObjectType);
}
else
{
System.Console.Write(a);
}
System.Console.WriteLine();
}
}
public void RealTimeReplay(string saveStateFile)
{
var savedState = VirtualProfilerSaveState.LoadFromFile(saveStateFile);
Global.Launcher.SaveState = savedState;
if (Objects.ReplayController == null) throw new ApplicationException("No replay adapter found.");
_activeReplayer = new RealTimeReplayer(Objects.ReplayController.LineRenderer, SubjectLogger.Load(savedState.RunSettings.SubjectPositionPath));
Objects.ReplayController.StartReplay(_activeReplayer);
}
public void StopReplay()
{
if (Objects.ReplayController != null)
Objects.ReplayController.StopReplay();
Objects.ReplayCamera.enabled = false;
Objects.RuntimeCamera.enabled = true;
_activeReplayer = null;
}
public bool Equals(IReplay other)
{
var v = other as Event;
if (v == null)
{
return(false);
}
return(_id == v._id && _name == v._name && _eventAttributes == v._eventAttributes && _type == v._type);
}
public bool Equals(IReplay other)
{
var v = other as Field;
if (v == null)
{
return(false);
}
return(_id == v._id && _name == v._name && _type == v._type && _fieldAttributes == v._fieldAttributes);
}
public bool Equals(IReplay other)
{
var v = other as Constructor;
if (v == null)
{
return(false);
}
return(_id == v._id && _parameters.SequenceEqual(v._parameters) && _ilGen.Equals(v._ilGen));
}
public bool Equals(IReplay other)
{
var v = other as MethodOverride;
if (v == null)
{
return(false);
}
return(_id == v._id && _methodBuilder.Equals(v._methodBuilder) && _baseMethod == v._baseMethod);
}
public static IReplay Read(OsuBinaryReader reader, IReplay outobj = null, bool minimalLoad = true, int?version = null)
{
if (outobj == null)
{
outobj = new Replay();
}
outobj.PlayMode = (PlayMode)reader.ReadByte();
outobj.Version = reader.ReadInt32();
outobj.MapHash = reader.ReadString();
outobj.PlayerName = reader.ReadString();
outobj.ReplayHash = reader.ReadString();
outobj.C300 = reader.ReadInt16();
outobj.C100 = reader.ReadInt16();
outobj.C50 = reader.ReadInt16();
outobj.Geki = reader.ReadInt16();
outobj.Katu = reader.ReadInt16();
outobj.Miss = reader.ReadInt16();
outobj.TotalScore = reader.ReadInt32();
outobj.MaxCombo = reader.ReadInt16();
outobj.Perfect = reader.ReadBoolean();
outobj.Mods = reader.ReadInt32();
outobj.ReplayData = reader.ReadString();
outobj.DateTicks = reader.ReadInt64();
outobj.Date = GetDate(outobj.DateTicks);
outobj.CompressedReplayLength = reader.ReadInt32();
if (outobj.CompressedReplayLength > 0)
{
if (minimalLoad)
{
reader.ReadBytes(outobj.CompressedReplayLength);
}
else
{
outobj.CompressedReplay = reader.ReadBytes(outobj.CompressedReplayLength);
}
}
version = version ?? outobj.Version;
if (version >= 20140721)
{
outobj.OnlineScoreId = reader.ReadInt64();
}
else if (version >= 20121008)
{
outobj.OnlineScoreId = reader.ReadInt32();
}
if ((((Mods)outobj.Mods) & DataTypes.Mods.Tp) != 0)
{
outobj.AdditionalMods = reader.ReadDouble();
}
return(outobj);
}
public void InstantReplay(string saveStateFile)
{
var savedState = VirtualProfilerSaveState.LoadFromFile(saveStateFile);
Global.Launcher.SaveState = savedState;
if (Objects.ReplayController == null)
{
throw new ApplicationException("No replay adapter found.");
}
_activeReplayer = new InstantReplayer(Objects.ReplayController.LineRenderer, SubjectLogger.Load(savedState.RunSettings.SubjectPositionPath));
Objects.ReplayController.StartReplay(_activeReplayer);
}
public void StopReplay()
{
if (Objects.ReplayController != null)
{
Objects.ReplayController.StopReplay();
}
Objects.ReplayCamera.enabled = false;
Objects.RuntimeCamera.enabled = true;
_activeReplayer = null;
}
/// <summary>
/// CheckForReplay method implementation
/// </summary>
public bool Check(List <string> servernames, ReplayRecord record)
{
bool tempresult = false;
try
{
lock (_lock)
{
tempresult = _manager.AddToReplay(record);
if (tempresult)
{
if ((record.MustDispatch) && (servernames != null))
{
foreach (string fqdn in servernames)
{
ReplayClient replaymanager = new ReplayClient();
try
{
replaymanager.Initialize(fqdn);
IReplay client = replaymanager.Open();
try
{
record.MustDispatch = false;
tempresult = client.Check(servernames, record);
}
catch (Exception e)
{
_log.WriteEntry(string.Format("Error on Check Remote Service method : {0} => {1}.", fqdn, e.Message), EventLogEntryType.Error, 1011);
}
finally
{
replaymanager.Close(client);
}
}
catch (Exception e)
{
_log.WriteEntry(string.Format("Error on Check Remote Service method : {0} => {1}.", fqdn, e.Message), EventLogEntryType.Error, 1011);
}
}
}
}
}
}
catch (Exception e)
{
_log.WriteEntry(string.Format("Error on Check Service method : {0}.", e.Message), EventLogEntryType.Error, 1010);
}
return(tempresult);
}
public bool Equals(IReplay other)
{
var v = other as Method;
if (v == null)
{
return(false);
}
return(_id == v._id &&
_name == v._name &&
_returns == v._returns &&
_methodAttributes == v._methodAttributes &&
_parameters.SequenceEqual(v._parameters) &&
_ilGen.Equals(v._ilGen));
}
/// <summary>
/// Reset method implementation
/// </summary>
public void Reset(List <string> servernames)
{
try
{
lock (_lock)
{
_manager.Reset();
}
if (servernames != null)
{
foreach (string fqdn in servernames)
{
ReplayClient replaymanager = new ReplayClient();
try
{
replaymanager.Initialize(fqdn);
IReplay client = replaymanager.Open();
try
{
client.Reset(null);
}
catch (Exception e)
{
_log.WriteEntry(string.Format("Error on Check Remote Service method : {0} => {1}.", fqdn, e.Message), EventLogEntryType.Error, 1011);
}
finally
{
replaymanager.Close(client);
}
}
catch (Exception e)
{
_log.WriteEntry(string.Format("Error on Check Remote Service method : {0} => {1}.", fqdn, e.Message), EventLogEntryType.Error, 1011);
}
}
}
}
catch (Exception e)
{
_log.WriteEntry(string.Format("Error on Reset Service method : {0}.", e.Message), EventLogEntryType.Error, 1011);
}
}
private IEnumerable <IPlayer> GetPlayers(PlayerType type, IReplay replay)
{
switch ((int)type)
{
// none
case 0:
return(Enumerable.Empty <IPlayer>());
// winners
case 1:
return(replay.Winners);
// losers
case 2:
return(replay.Players.Except(replay.Observers).Except(replay.Winners));
// winners + losers
case 3:
return(replay.Players.Except(replay.Observers));
// observers
case 4:
return(replay.Observers);
// winners + observers
case 5:
return(replay.Observers.Union(replay.Winners));
// losers + observers
case 6:
return(replay.Players.Except(replay.Winners));
// winners + losers + observers
case 7:
return(replay.Players);
default:
throw new Exception();
}
}
/// <summary>
/// Pause method iplementation
/// </summary>
public static void Reset(List <string> computers)
{
ReplayClient manager = new ReplayClient();
manager.Initialize();
try
{
IReplay client = manager.Open();
try
{
client.Reset(computers);
}
finally
{
manager.Close(client);
}
}
finally
{
manager.UnInitialize();
}
}
/// <summary>
/// Continue method iplementation
/// </summary>
public static bool Check(List <string> computers, ReplayRecord record)
{
ReplayClient manager = new ReplayClient();
manager.Initialize();
try
{
IReplay client = manager.Open();
try
{
return(client.Check(computers, record));
}
finally
{
manager.Close(client);
}
}
finally
{
manager.UnInitialize();
}
}
public static void Write(this IReplay replay, OsuBinaryWriter writer, bool dbMode = true)
{
if (dbMode)
{
replay.OsuOldReplayFix();
}
writer.Write((byte)replay.PlayMode);
writer.Write(replay.Version);
writer.Write(replay.MapHash);
writer.Write(replay.PlayerName);
writer.Write(replay.ReplayHash);
writer.Write(replay.C300);
writer.Write(replay.C100);
writer.Write(replay.C50);
writer.Write(replay.Geki);
writer.Write(replay.Katu);
writer.Write(replay.Miss);
writer.Write(replay.TotalScore);
writer.Write(replay.MaxCombo);
writer.Write(replay.Perfect);
writer.Write(replay.Mods);
writer.Write(dbMode ? "" : replay.ReplayData);
writer.Write(replay.Date.Ticks);
if (dbMode)
{
writer.Write(-1);
}
else
{
writer.Write(replay.CompressedReplayLength);
if (replay.CompressedReplayLength > 0)
{
writer.Write(replay.ReplayData);
}
}
writer.Write(replay.OnlineScoreId);
}
/// <summary>
///
/// </summary>
/// <rant>For whatever reason all of my replays before around 2015(mind you, I still have my 2011 replays)
/// were treated by osu! as invalid, with as it turns out, invalidated whole database.</rant>
/// <param name="replay"></param>
private static void OsuOldReplayFix(this IReplay replay)
{
replay.Version = 20170503;
}
public static Beatmap GetMap(this IReplay replay, IMapDataManager mapCacher)
{
return(mapCacher.GetByHash(replay.MapHash));
}
private ReplayDecorator(File <IReplay> replayFile)
{
_replayFile = replayFile;
_replay = replayFile.Content;
}
public void StartReplay(IReplay replayer)
{
_replayer = replayer;
_isStarted = true;
}
public MethodOverride(int id, IILMethod methodBuilder, MethodInfo baseMethod)
{
_id = id;
_methodBuilder = (IReplay)methodBuilder;
_baseMethod = baseMethod;
}
public void SetAddOnMethod(IILMethod method)
{
_addOnMethod = (IReplay)method;
}
public void SetRemoveOnMethod(IILMethod method)
{
_removeOnMethod = (IReplay)method;
}
public void StartReplay(IReplay replayer)
{
_replayer = replayer;
_isStarted = true;
}
//public static IPlayer ExtractWinner(IReplay replay)
//{
// IList<IPlayer> players = new List<IPlayer>(replay.Players);
// foreach (IAction action in replay.Actions) {
// if (action.ActionType == ActionType.LeaveGame) {
// LeaveGameAction a = (LeaveGameAction)action;
// switch (a.LeaveGameType) {
// case LeaveGameType.Dropped:
// return null;
// case LeaveGameType.Quit:
// players.Remove(a.Player);
// break;
// default:
// throw new InvalidOperationException();
// }
// }
// }
// if (players.Count() == 1) {
// return players[0];
// }
// return null;
//}
// What about OBSERVERS?? They don't have to leave the game or don't get dropped before it ends?? Do they remain in the players list??
// yes observers stay in the list... Have to find a way to remove them, how?
public static IEnumerable <IPlayer> ExtractWinners(IReplay replay)
{
IList <IPlayer> players = new List <IPlayer>(replay.Players);
IList <IPlayer> observers = new List <IPlayer>(replay.Observers);
foreach (IAction action in replay.Actions)
{
if (action.ActionType == ActionType.LeaveGame)
{
LeaveGameAction a = (LeaveGameAction)action;
switch (a.LeaveGameType)
{
case LeaveGameType.Dropped:
players.Remove(a.Player);
// once I get player teams to work, I have to only add this to players of the other team obviously...
foreach (var aPlayer in players)
{
aPlayer.OpponentDropped = true;
}
break;
case LeaveGameType.Quit:
players.Remove(a.Player);
break;
default:
players.Remove(a.Player);
break;
// why throw an exception if the actiontype has been identified to be leavegame? Maybe there are other possible values for the type of leavegame action...
//throw new InvalidOperationException();
}
}
//if (action.ActionType == ActionType.Build)
//{
// BuildAction a = (BuildAction)action;
// if (a.Player.IsObserver == null)
// {
// a.Player.IsObserver = false;
// }
//}
}
// your code for IsObserver doesn't make much sense, it's not remembered past this function!!
if (players.Count() == 0)
{
return(players.AsEnumerable());
}
//for (int i = players.Count - 1; i >= 0; i--)
//{
// if (players[i].IsObserver == null)
// {
// players[i].IsObserver = true;
// players.RemoveAt(i);
// }
//}
for (int i = players.Count - 1; i >= 0; i--)
{
if (observers.Contains(players[i]))
{
players.RemoveAt(i);
}
}
if (players.Count() == 0)
{
return(players.AsEnumerable());
}
// should be ExtractWinnerSSSS => what about 2v2, 3v3, 4v4 !!?
return(players.AsEnumerable <IPlayer>());
}
