public FileTimeSystemUseEntry(byte[] data, int offset)
{
byte len = data[offset + 2];
Name = "TF";
Version = data[offset + 3];
CheckLengthAndVersion(len, 5, 1);
byte flags = data[offset + 4];
bool longForm = (flags & 0x80) != 0;
int fieldLen = longForm ? 17 : 7;
TimestampsPresent = (Timestamps)(flags & 0x7F);
int pos = offset + 5;
CreationTime = ReadTimestamp(Timestamps.Creation, data, longForm, ref pos);
ModifyTime = ReadTimestamp(Timestamps.Modify, data, longForm, ref pos);
AccessTime = ReadTimestamp(Timestamps.Access, data, longForm, ref pos);
AttributesTime = ReadTimestamp(Timestamps.Attributes, data, longForm, ref pos);
BackupTime = ReadTimestamp(Timestamps.Backup, data, longForm, ref pos);
ExpirationTime = ReadTimestamp(Timestamps.Expiration, data, longForm, ref pos);
EffectiveTime = ReadTimestamp(Timestamps.Effective, data, longForm, ref pos);
}
public Timestamps NewTimestamp(DateTime?start)
{
Timestamps timestamp = new Timestamps();
try
{
timestamp.Start = start;
}
catch
{
timestamp.Start = null;
}
return(timestamp);
}
/// <summary>
/// Saves the XML document.
/// </summary>
public static void SaveXml()
{
using (XmlWriter writer = XmlWriter.Create(Paths.CreateOSPath("settings.xml"), XmlWriterSettings))
{
writer.WriteStartDocument();
writer.WriteStartElement("Options");
writer.WriteStartElement("General");
writer.WriteElementString("AutoSave", AutoSave.ToString());
writer.WriteElementString("AutoSaveSpeed", AutoSaveSpeed.ToString());
writer.WriteElementString("AutoScroll", AutoScroll.ToString());
writer.WriteElementString("Music", Music.ToString());
writer.WriteElementString("NpcBar", NpcBar.ToString());
writer.WriteElementString("NpcDamage", NpcDamage.ToString());
writer.WriteElementString("NpcName", NpcName.ToString());
writer.WriteElementString("PlayerBar", PlayerBar.ToString());
writer.WriteElementString("PlayerDamage", PlayerDamage.ToString());
writer.WriteElementString("PlayerName", PlayerName.ToString());
writer.WriteElementString("SavedAccount", SavedAccount);
writer.WriteElementString("SavedPassword", SavedPassword);
writer.WriteElementString("Sound", Sound.ToString());
writer.WriteElementString("SpeechBubbles", SpeechBubbles.ToString());
writer.WriteElementString("Timestamps", Timestamps.ToString());
writer.WriteElementString("ActiveSkin", ActiveSkin);
writer.WriteElementString("LastClientUpdateTime", LastClientUpdateTime.ToBinary().ToString());
writer.WriteElementString("LastGFXUpdateTime", LastGFXUpdateTime.ToBinary().ToString());
writer.WriteEndElement();
writer.WriteStartElement("ConnectionInfo");
writer.WriteElementString("Port", ConnectionPort.ToString());
writer.WriteElementString("Server", ConnectionIP);
writer.WriteElementString("UpdateLink", UpdateAddress);
writer.WriteElementString("SFXLink", SoundAddress);
writer.WriteElementString("MusicLink", MusicAddress);
writer.WriteEndElement();
writer.WriteStartElement("Editor");
writer.WriteElementString("MapGrid", MapGrid.ToString());
writer.WriteElementString("DisplayAttributes", DisplayAttributes.ToString());
writer.WriteElementString("DragAndPlace", DragAndPlace.ToString());
writer.WriteEndElement();
writer.WriteEndElement();
writer.WriteEndDocument();
}
}
private void SetDiscordStatus(string state)
{
var t = new Timestamps();
client.SetPresence(new RichPresence()
{
State = state,
Assets = new Assets()
{
LargeImageKey = "daigaku",
LargeImageText = "だいがく",
}
});
}
public List <Joint> RasterizeAnimation()
{
List <Joint> theSkeleton = new List <Joint>();
for (int i = 0; i < Skeleton.Count; i++)
{
theSkeleton.Add(new Joint());
theSkeleton[i].Sid = Skeleton[i].Sid;
}
float maximumTimestamp = (float)(Math.Ceiling(Timestamps.Max() * Constants.INSTANCES_PER_SECOND) / Constants.INSTANCES_PER_SECOND);
for (float rasterizedCurrentFrame = 0f; rasterizedCurrentFrame <= maximumTimestamp; rasterizedCurrentFrame += 1f / Constants.INSTANCES_PER_SECOND)
{
float smallerTimestamp = (from timestamp in Timestamps
where timestamp <= rasterizedCurrentFrame
select timestamp).Max();
float biggerTimestamp = smallerTimestamp;
List <float> biggerTimestamps = (from timestamp in Timestamps
where timestamp >= rasterizedCurrentFrame
select timestamp).ToList();
if (biggerTimestamps.Count > 0)
{
biggerTimestamp = biggerTimestamps.Min();
}
float blend = 0f;
if (smallerTimestamp != biggerTimestamp)
{
blend = (rasterizedCurrentFrame - smallerTimestamp) / (biggerTimestamp - smallerTimestamp);
}
InterpolateSkeleton(smallerTimestamp, biggerTimestamp, blend);
InterpolateSkeletonQuaternions(smallerTimestamp, biggerTimestamp, blend);
for (int i = 0; i < Skeleton.Count; i++)
{
theSkeleton[i].PoseOrigins[rasterizedCurrentFrame] = Skeleton[i].InterpolatedPoseOrigin;
theSkeleton[i].PoseQuaternions[rasterizedCurrentFrame] = Skeleton[i].InterpolatedQuaternion;
}
}
latestFrameIndex = Timestamps.Count() - 1;
return(theSkeleton);
}
private void timer1_Tick(object sender, EventArgs e)
{
Process[] ps = Process.GetProcesses();
bool isZoomClassing = false;
foreach (Process p in ps)
{
try
{
if ((p.MainWindowTitle.Contains("Zoom Meeting") ||
p.MainWindowTitle.Contains("Zoom Webinar") ||
p.MainWindowTitle.Contains("Zoom ミーティング") ||
p.MainWindowTitle.Contains("Zoom ウェビナー") ||
p.ProcessName.Equals("CptHost")) &&
!p.ProcessName.Equals("ZoomInClass"))
{
isZoomClassing = true;
}
}
catch (Exception ex)
{
Console.WriteLine("Error: {0}", ex.Message);
}
}
Console.WriteLine("isZoomClassing: {0}", isZoomClassing);
if (isZoomClassing)
{
if (ts == null)
{
ts = Timestamps.Now;
}
client.SetPresence(new RichPresence()
{
Details = "In Meeting",
Assets = new Assets()
{
LargeImageKey = "logo",
},
Timestamps = ts
});
}
else
{
client.ClearPresence();
ts = null;
}
}
static void InitializeRichPresence()
{
Logger.Debug("Initializing Rich Presence");
var start = DateTime.UtcNow;
string getJoined()
{
return($"{RafflesJoined} " + "raffle".Pluralize(RafflesJoined) + " joined!");
};
string details = "Scrap.TF Raffle Bot";
var timestamps = new Timestamps
{
Start = start
};
var assets = new Assets
{
LargeImageKey = "scraps",
LargeImageText = "github.com/depthbomb/scraps"
};
RpcTimer = new Timer
{
Interval = TimeSpan.FromSeconds(7.5).TotalMilliseconds, // Presence updates are only updated every 15 seconds, but send more frequently so we ensure the latest data is available
Enabled = false
};
RpcClient = new DiscordRpcClient("789333681998397460");
RpcClient.Initialize();
RpcClient.SetPresence(new RichPresence
{
Details = details,
State = getJoined(),
Timestamps = timestamps,
Assets = assets
});
RpcTimer.Elapsed += (sender, e) =>
{
RpcClient.SetPresence(new RichPresence
{
Details = details,
State = getJoined(),
Timestamps = timestamps,
Assets = assets
});
};
RpcTimer.Start();
Logger.Debug("Rich Presence update timer started");
}
private static void DataListen()
{
while (true)
{
try
{
byte[] bytes = Utils.ReceiveExactly(client);
Title title = new Title(bytes);
if (title.Magic == 0xffaadd23)
{
if (LastProgramName != title.Name)
{
time = Timestamps.Now;
}
if ((rpc != null && rpc.CurrentPresence == null) || LastProgramName != title.Name)
{
if (Arguments.IgnoreHomeScreen && title.Name == "Home Menu")
{
rpc.ClearPresence();
}
else
{
rpc.SetPresence(Utils.CreateDiscordPresence(title, time));
}
LastProgramName = title.Name;
}
}
else
{
if (rpc != null && !rpc.IsDisposed)
{
rpc.ClearPresence();
}
client.Close();
return;
}
}
catch (SocketException)
{
if (rpc != null && !rpc.IsDisposed)
{
rpc.ClearPresence();
}
client.Close();
return;
}
}
}
static void Init()
{
if (Initialized)
{
return;
}
Presence = new DiscordRpcClient("579791801527959592");
Presence.Initialize();
Time = new Timestamps(DateTime.UtcNow);
Initialized = true;
Refresh();
courier.Start();
}
public static void setPresence(string a, string b, double c, string d, string e, string f)
{
client.SetPresence(new RichPresence()
{
Details = a,
State = "By: " + b,
Timestamps = Timestamps.FromTimeSpan(c / 1000),
Assets = new Assets()
{
LargeImageKey = d,
LargeImageText = e,
SmallImageKey = f,
}
});
}
public override int GetHashCode()
{
int hashcode = 157;
unchecked {
hashcode = (hashcode * 397) + SessionId.GetHashCode();
hashcode = (hashcode * 397) + DeviceId.GetHashCode();
hashcode = (hashcode * 397) + TCollections.GetHashCode(Measurements);
hashcode = (hashcode * 397) + Values.GetHashCode();
hashcode = (hashcode * 397) + Timestamps.GetHashCode();
hashcode = (hashcode * 397) + TCollections.GetHashCode(Types);
hashcode = (hashcode * 397) + Size.GetHashCode();
}
return(hashcode);
}
public static void Initialize()
{
discordClient = new DiscordRpcClient("798016065870495744");
discordClient.Logger = new ConsoleLogger()
{
Level = LogLevel.Warning
};
discordClient.OnReady += (sender, e) => { Console.WriteLine($"[Discord] Received ready from {e.User.Username}!"); };
discordClient.OnPresenceUpdate += (sender, e) => { /*Console.WriteLine("[Discord] Received presence update!");*/ };
if (elapsedTime == null)
{
//Only Define Timestamp Once - Fix For Time Resetting To 00:00 Each Update - Only Done Once Project Is Opened And File Is Selected
elapsedTime = Timestamps.Now;
}
discordClient.Initialize();
}
/// <summary>
/// Deletes the values at specific times for a for a set of items.
/// </summary>
public TsCHdaResultCollection[] DeleteAtTime(TsCHdaItem[] items)
{
TsCHdaItemTimeCollection[] times = new TsCHdaItemTimeCollection[items.Length];
for (int ii = 0; ii < items.Length; ii++)
{
times[ii] = (TsCHdaItemTimeCollection)Timestamps.Clone();
times[ii].ItemName = items[ii].ItemName;
times[ii].ItemPath = items[ii].ItemPath;
times[ii].ClientHandle = items[ii].ClientHandle;
times[ii].ServerHandle = items[ii].ServerHandle;
}
return(_server.DeleteAtTime(times));
}
static void BasicExample()
{
// == Create the client
var client = new DiscordRpcClient("424087019149328395", pipe: discordPipe)
{
Logger = new Logging.ConsoleLogger(logLevel, true)
};
// == Subscribe to some events
client.OnReady += (sender, msg) =>
{
//Create some events so we know things are happening
Console.WriteLine("Connected to discord with user {0}", msg.User.Username);
};
client.OnPresenceUpdate += (sender, msg) =>
{
//The presence has updated
Console.WriteLine("Presence has been updated! ");
};
// == Initialize
client.Initialize();
// == Set the presence
client.SetPresence(new RichPresence()
{
Details = "A Basic Example",
State = "In Game",
Timestamps = Timestamps.FromTimeSpan(10),
Buttons = new Button[]
{
new Button()
{
Label = "Fish", Url = "https://lachee.dev/"
}
}
});
// == Do the rest of your program.
//Simulated by a Console.ReadKey
// etc...
Console.ReadKey();
// == At the very end we need to dispose of it
client.Dispose();
}
private static void DataListen()
{
while (true)
{
try
{
byte[] bytes = new byte[600];
int cnt = client.Receive(bytes);
Console.WriteLine("'" + System.Text.Encoding.UTF8.GetString(bytes) + "' received...");
Title title = new Title(bytes);
if (title.Magic == 0xCAFECAFE)
{
if (LastGame != title.TitleID)
{
time = Timestamps.Now;
}
if ((rpc != null && rpc.CurrentPresence == null) || LastGame != title.TitleID)
{
rpc.SetPresence(Utils.CreateDiscordPresence(title, time));
LastGame = title.TitleID;
}
}
else
{
if (rpc != null && !rpc.IsDisposed)
{
rpc.ClearPresence();
}
client.Close();
return;
}
}
catch (SocketException)
{
if (rpc != null && !rpc.IsDisposed)
{
rpc.ClearPresence();
}
client.Close();
return;
}
}
}
public static void GetTimestamps(ref RichPresence richPresence)
{
if (!timeStampSet)
{
timeStampSet = true;
Timestamps timestamp = new Timestamps();
timestamp.Start = Timestamps.Now.Start;
richPresence.Timestamps = timestamp;
StartTime = timestamp.Start.Value;
}
else
{
Timestamps timestamp = new Timestamps();
timestamp.Start = StartTime;
richPresence.Timestamps = timestamp;
}
}
public virtual void EnterWorldRP()
{
timestamp = Timestamps.Now;
client.SetPresence(new RichPresence()
{
Details = "In-Game",
State = "Playing v0.4.1",
Assets = new Assets()
{
LargeImageKey = "largeimage2",
LargeImageText = "Terramon Mod",
SmallImageKey = "pokeball",
SmallImageText = "No Pokémon Selected"
},
Timestamps = timestamp
});
}
public Pb.Filter ConvertToPBFilter()
{
var internalFilter = new Pb.TimestampsFilter();
if (Timestamps?.Any() == true)
{
internalFilter.Timestamps.AddRange(Timestamps);
}
var filter = new Pb.Filter
{
Name = Name,
SerializedFilter = internalFilter.ToByteString()
};
return(filter);
}
static void Issue104()
{
// == Create the client
var client = new DiscordRpcClient("424087019149328395", pipe: discordPipe)
{
Logger = new Logging.ConsoleLogger(logLevel, true)
};
// == Subscribe to some events
client.OnReady += (sender, msg) =>
{
//Create some events so we know things are happening
Console.WriteLine("Connected to discord with user {0}", msg.User.Username);
};
client.OnPresenceUpdate += (sender, msg) =>
{
//The presence has updated
Console.WriteLine("Presence has been updated! ");
};
// == Initialize
client.Initialize();
// Set the first presence
Console.WriteLine("=================== SET 1 ===================");
client.SetPresence(new RichPresence()
{
Details = "A Basic Example",
State = "In Game",
Timestamps = Timestamps.FromTimeSpan(10)
});
// Wait arbitary amount of time
Thread.Sleep(3000);
//Set the presence again, but with UpdateState
Console.WriteLine("=================== SET 2 ===================");
client.UpdateState("Another Status");
// == At the very end we need to dispose of it
Console.ReadKey();
client.Dispose();
}
internal static void SetupRpc()
{
client = new DiscordRpcClient("652538071530864653");
client.Initialize();
Secrets secrets = new Secrets()
{
JoinSecret = "MTI4NzM0OjFpMmhuZToxMjMxMjM",
SpectateSecret = "MTIzNDV8MTIzNDV8MTMyNDU0"
};
Party party = new Party()
{
ID = Secrets.CreateFriendlySecret(new Random()),
Size = 1,
Max = 64
};
//Give the game some time so we have a nice countdown
Timestamps timestamps = new Timestamps()
{
Start = DateTime.UtcNow
};
client.RegisterUriScheme("652538071530864653");
client.SetSubscription(EventType.Join | EventType.Spectate | EventType.JoinRequest);
client.SetPresence(new RichPresence()
{
Details = "Sunucuya Bağlanıyor.",
State = "Launcher Giriş Ekranında...",
Assets = new Assets()
{
LargeImageKey = "fadesx",
LargeImageText = "khchosting.com",
SmallImageKey = "tikfade",
SmallImageText = "discord.gg/adonisrp"
},
Secrets = secrets,
Party = party,
Timestamps = timestamps
});
}
/*
* ------------------
* Core Functionality
* ------------------
*/
public void SetPresence()
{
// Contains the Stage Name
string currentDetails = GetCurrentDetails();
// Contains Stage Details
string currentGameState = GetGameState();
// Contains the start of current action.
Timestamps timeStamps = new Timestamps();
long timeStamp = 0;
// Images
Assets assets = new Assets();
// Set timestamp.
if ((!_heroes.IsInMainMenu()) && (!_heroes.IsPaused()) && (!_heroes.IsWatchingIngameEvent()))
{
// TODO: Bug Here with Seconds
// Do not set timestamp if paused.
TimeSpan sinceEpoch = DateTime.UtcNow - new DateTime(1970, 1, 1);
;
timeStamp = (long)(sinceEpoch.TotalSeconds - (*_heroes.CurrentStageTime).GetTotalSeconds());
timeStamps.Start = Timestamps.FromUnixTime(timeStamp);
}
// Get Image
if (!_heroes.IsInMainMenu())
{
if (_heroes.ImageTranslationDictionary.StageNameTranslator.TryGetValue(*_heroes.StageID, out string stageAssetName))
{
assets.LargeImageKey = stageAssetName;
}
}
// Send to Discord
_client.SetPresence(new RichPresence()
{
Details = currentDetails,
Timestamps = timeStamps,
State = currentGameState,
Assets = assets
});
}
public void ClearDataOlderThan(TimeSpan span)
{
if (Timestamps.Count == 0)
{
return;
}
var currentTimestamp = Timestamps.Last();
var numToSkip = Timestamps.FindIndex(t => t + span >= currentTimestamp);
//Log.Debug(_tag, $"At {currentTimestamp}, clearing out {numToSkip} data points, keeping as of {Timestamps.Skip(numToSkip).First()}.");
//Provider.Deactivate();
AllowDataUpdates = false;
LoggedData = LoggedData.Skip(numToSkip).ToList();
Intervals = Intervals.Skip(numToSkip).ToList();
Timestamps = Timestamps.Skip(numToSkip).ToList();
AllowDataUpdates = true;
//Provider.Activate();
}
public void Reset()
{
BinaryFormatter bF = new BinaryFormatter();
FileStream file;
file = File.Open(Application.persistentDataPath + "/SavedData/Timestamps.txt", FileMode.Open);
Timestamps emptyTimestamps = new Timestamps()
{
S1T = "Empty",
S2T = "Empty",
S3T = "Empty",
S4T = "Empty"
};
bF.Serialize(file, emptyTimestamps);
file.Close();
}
public virtual void EnterWorldRP()
{
#if DEBUG
return;
#endif
timestamp = Timestamps.Now;
client.SetPresence(new RichPresence()
{
Details = "In-Game",
State = $"Playing v{ModContent.GetInstance<TerramonMod>().Version}",
Assets = new Assets()
{
LargeImageKey = "largeimage2",
LargeImageText = "Terramon Mod",
},
Timestamps = timestamp
});
}
private void AppendSample(ElectrodeFrame[] samples, int length)
{
float[,] vReData = new float[length, samples[0].ComplexVoltageMatrix.Length];
float[,] vImData = new float[length, samples[0].ComplexVoltageMatrix.Length];
float[,] cReData = new float[length, samples[0].ComplexCurrentMatrix.Length];
float[,] cImData = new float[length, samples[0].ComplexCurrentMatrix.Length];
ulong[,] saturationData = new ulong[length, 1];
long[,] timestampData = new long[length, 1];
// Write packet id, kalpa clock only if exist => value != Uint64.MaxValue (default value)
ulong[,] packetIdData = samples[0].PacketId == UInt64.MaxValue ? null : new ulong[length, 1];
for (var i = 0; i < length; i++)
{
ElectrodeFrame electrodeFrame = samples[i];
for (int j = 0; j < electrodeFrame.ComplexVoltageMatrix.Length; j++)
{
vReData[i, j] = electrodeFrame.ComplexVoltageMatrix[j].Re;
vImData[i, j] = electrodeFrame.ComplexVoltageMatrix[j].Im;
}
for (int j = 0; j < electrodeFrame.ComplexCurrentMatrix.Length; j++)
{
cReData[i, j] = electrodeFrame.ComplexCurrentMatrix[j].Re;
cImData[i, j] = electrodeFrame.ComplexCurrentMatrix[j].Im;
}
saturationData[i, 0] = electrodeFrame.SaturationMask;
timestampData[i, 0] = electrodeFrame.timestamp;
if (packetIdData != null)
{
packetIdData[i, 0] = electrodeFrame.PacketId;
}
}
VoltagesReal.AppendOrCreateDataset(vReData);
VoltagesIm.AppendOrCreateDataset(vImData);
CurrentsReal.AppendOrCreateDataset(cReData);
CurrentsIm.AppendOrCreateDataset(cImData);
Saturation.AppendOrCreateDataset(saturationData);
Timestamps.AppendOrCreateDataset(timestampData);
if (packetIdData != null)
{
PacketIds.AppendOrCreateDataset(packetIdData);
}
}
private static void DataListen()
{
while (true)
{
try
{
byte[] bytes = new byte[600];
int cnt = client.Receive(bytes);
Title title = new Title(bytes);
if (title.Magic == 0xffaadd23)
{
if (LastGame != title.Name)
{
time = Timestamps.Now;
}
if ((rpc != null && rpc.CurrentPresence == null) || LastGame != title.Name)
{
rpc.SetPresence(Utils.CreateDiscordPresence(title, time));
LastGame = title.Name;
}
}
else
{
if (rpc != null && !rpc.IsDisposed)
{
rpc.ClearPresence();
}
client.Close();
return;
}
}
catch (SocketException)
{
if (rpc != null && !rpc.IsDisposed)
{
rpc.ClearPresence();
}
client.Close();
return;
}
}
}
/// <summary>
/// </summary>
/// <param name="snapId"></param>
/// <param name="username"></param>
/// <param name="authToken"></param>
/// <returns></returns>
public static async Task <byte[]> GetBlob(string snapId, string username, string authToken)
{
long timestamp = Timestamps.GenerateRetardedTimestamp();
var postData = new Dictionary <string, string>
{
{ "id", snapId },
{ "username", username },
{ "timestamp", timestamp.ToString(CultureInfo.InvariantCulture) }
};
HttpResponseMessage response =
await WebRequests.Post("blob", postData, authToken, timestamp.ToString(CultureInfo.InvariantCulture));
switch (response.StatusCode)
{
case HttpStatusCode.OK:
{
byte[] data = await response.Content.ReadAsByteArrayAsync();
// Validate Blob Shit
byte[] decryptedBlob = null;
if (Blob.ValidateMediaBlob(data))
{
decryptedBlob = data;
}
else
{
data = Blob.DecryptBlob(data);
if (Blob.ValidateMediaBlob(data))
{
decryptedBlob = data;
}
}
return(decryptedBlob);
}
default:
// Well, f**k
return(null);
}
}
/// <inheritdoc />
public FileTimestamps GetFileTimestamps(string path, bool followSymlink)
{
Timestamps buffer = new Timestamps();
unsafe
{
int result = GetTimeStampsForFilePath(path, followSymlink, &buffer);
if (result != 0)
{
throw new BuildXLException("Failed to open a file to get its timestamps - error: " + Marshal.GetLastWin32Error());
}
}
return(new FileTimestamps(
creationTime: buffer.CreationTime.ToUtcTime(),
lastChangeTime: buffer.ChangeTime.ToUtcTime(),
lastWriteTime: buffer.ModificationTime.ToUtcTime(),
accessTime: buffer.AcessTime.ToUtcTime()));
}
/// <summary>
/// </summary>
/// <param name="username"></param>
/// <param name="password"></param>
public static async Task <Tuple <TempEnumHolder.LoginStatus, Account> > Login(string username, string password)
{
long timestamp = Timestamps.GenerateRetardedTimestamp();
var postData = new Dictionary <string, string>
{
{ "password", password },
{ "username", username },
{ "timestamp", timestamp.ToString(CultureInfo.InvariantCulture) }
};
HttpResponseMessage response =
await WebRequests.Post("login", postData, KeyVault.StaticToken, timestamp.ToString(CultureInfo.InvariantCulture));
switch (response.StatusCode)
{
case HttpStatusCode.OK:
{
// Http Request Worked
string data = await response.Content.ReadAsStringAsync();
Account parsedData = await JsonConvert.DeserializeObjectAsync <Account>(data);
// Check if we were logged in
if (!parsedData.Logged)
{
return
(new Tuple <TempEnumHolder.LoginStatus, Account>(
TempEnumHolder.LoginStatus.InvalidCredentials, parsedData));
}
// Yup, save the data and return true
return
(new Tuple <TempEnumHolder.LoginStatus, Account>(
TempEnumHolder.LoginStatus.Success, parsedData));
}
default:
// Well, f**k
return
(new Tuple <TempEnumHolder.LoginStatus, Account>(
TempEnumHolder.LoginStatus.ServerError, null));
}
}
public void Load(int slot)
{
timestamps = GetTimestamps();
if (slot == 1 && timestamps.S1T == "Empty")
{
L1T.color = emptyC;
StartCoroutine(Shake(L1T.gameObject, defaultC));
}
else if (slot == 2 && timestamps.S2T == "Empty")
{
L2T.color = emptyC;
StartCoroutine(Shake(L2T.gameObject, defaultC));
}
else if (slot == 3 && timestamps.S3T == "Empty")
{
L3T.color = emptyC;
StartCoroutine(Shake(L3T.gameObject, defaultC));
}
else if (slot == 4 && timestamps.S4T == "Empty")
{
Debug.Log("empty");
}
else
{
if (slot == 1)
{
OpenConfirmPanel(true, false, slot, timestamps.S1T);
}
else if (slot == 2)
{
OpenConfirmPanel(true, false, slot, timestamps.S2T);
}
else if (slot == 3)
{
OpenConfirmPanel(true, false, slot, timestamps.S3T);
}
else if (slot == 4)
{
OpenConfirmPanel(true, false, slot, timestamps.S4T);
}
}
}
private DateTime ReadTimestamp(Timestamps timestamp, byte[] data, bool longForm, ref int pos)
{
DateTime result = DateTime.MinValue;
if ((TimestampsPresent & timestamp) != 0)
{
if (longForm)
{
result = IsoUtilities.ToDateTimeFromVolumeDescriptorTime(data, pos);
pos += 17;
}
else
{
result = IsoUtilities.ToUTCDateTimeFromDirectoryTime(data, pos);
pos += 7;
}
}
return(result);
}
private DateTime ReadTimestamp(Timestamps timestamp, byte[] data, bool longForm, ref int pos)
{
DateTime result = DateTime.MinValue;
if ((TimestampsPresent & timestamp) != 0)
{
if (longForm)
{
result = IsoUtilities.ToDateTimeFromVolumeDescriptorTime(data, pos);
pos += 17;
}
else
{
result = IsoUtilities.ToUTCDateTimeFromDirectoryTime(data, pos);
pos += 7;
}
}
return result;
}
private static void DumpTimestamps(Timestamps.Framework.ITimestampable foo)
{
Console.WriteLine("Created: {0}", foo.Created);
Console.WriteLine("Updated: {0}", foo.Updated);
}
