Overwrite

Complete Overwrite of the Folder with the free shard. ServUO 57.3 has been added.

Scripts/SubSystem/VitaNex/Core/Misc/TimeStamp.cs

@@ -0,0 +1,599 @@
+#region Header
+//               _,-'/-'/
+//   .      __,-; ,'( '/
+//    \.    `-.__`-._`:_,-._       _ , . ``
+//     `:-._,------' ` _,`--` -: `_ , ` ,' :
+//        `---..__,,--'  (C) 2023  ` -'. -'
+//        #  Vita-Nex [http://core.vita-nex.com]  #
+//  {o)xxx|===============-   #   -===============|xxx(o}
+//        #                                       #
+#endregion
+
+#region References
+using System;
+
+using Server;
+#endregion
+
+namespace VitaNex
+{
+	public struct TimeStamp
+		: IComparable<TimeStamp>,
+		  IComparable<DateTime>,
+		  IComparable<TimeSpan>,
+		  IComparable<double>,
+		  IComparable<long>,
+		  IEquatable<TimeStamp>,
+		  IEquatable<DateTime>,
+		  IEquatable<TimeSpan>,
+		  IEquatable<double>,
+		  IEquatable<long>
+	{
+		public static readonly DateTime Origin = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified);
+
+		public static TimeStamp Zero => Origin;
+
+		public static TimeStamp Now => DateTime.Now;
+		public static TimeStamp UtcNow => DateTime.UtcNow;
+
+		public static TimeStamp FromTicks(long value)
+		{
+			return new TimeStamp(value);
+		}
+
+		public static TimeStamp FromTicks(long value, DateTimeKind kind)
+		{
+			return new TimeStamp(value, kind);
+		}
+
+		public static TimeStamp FromMilliseconds(double value)
+		{
+			return new TimeStamp(value / 1000.0);
+		}
+
+		public static TimeStamp FromMilliseconds(double value, DateTimeKind kind)
+		{
+			return new TimeStamp(value / 1000.0, kind);
+		}
+
+		public static TimeStamp FromSeconds(double value)
+		{
+			return new TimeStamp(value);
+		}
+
+		public static TimeStamp FromSeconds(double value, DateTimeKind kind)
+		{
+			return new TimeStamp(value, kind);
+		}
+
+		public static TimeStamp FromMinutes(double value)
+		{
+			return new TimeStamp(value * 60);
+		}
+
+		public static TimeStamp FromMinutes(double value, DateTimeKind kind)
+		{
+			return new TimeStamp(value * 60, kind);
+		}
+
+		public static TimeStamp FromHours(double value)
+		{
+			return new TimeStamp(value * 3600);
+		}
+
+		public static TimeStamp FromHours(double value, DateTimeKind kind)
+		{
+			return new TimeStamp(value * 3600, kind);
+		}
+
+		public static TimeStamp FromDays(double value)
+		{
+			return new TimeStamp(value * 86400);
+		}
+
+		public static TimeStamp FromDays(double value, DateTimeKind kind)
+		{
+			return new TimeStamp(value * 86400, kind);
+		}
+
+		public static TimeStamp FromDateTime(DateTime date)
+		{
+			return new TimeStamp(date);
+		}
+
+		public static int Compare(TimeStamp l, TimeStamp r)
+		{
+			return l.CompareTo(r);
+		}
+
+		public DateTimeKind Kind { get; private set; }
+		public DateTime Value { get; private set; }
+		public double Stamp { get; private set; }
+
+		public long Ticks => Value.Ticks;
+
+		public TimeStamp(DateTime date)
+			: this(date.Kind)
+		{
+			Value = date;
+			Stamp = ResolveStamp();
+		}
+
+		public TimeStamp(TimeSpan time)
+			: this(time, DateTimeKind.Unspecified)
+		{ }
+
+		public TimeStamp(TimeSpan time, DateTimeKind kind)
+			: this(kind)
+		{
+			Stamp = time.TotalSeconds;
+			Value = ResolveDate();
+		}
+
+		public TimeStamp(double stamp)
+			: this(stamp, DateTimeKind.Unspecified)
+		{ }
+
+		public TimeStamp(double stamp, DateTimeKind kind)
+			: this(kind)
+		{
+			Stamp = stamp;
+			Value = ResolveDate();
+		}
+
+		public TimeStamp(long ticks)
+			: this(ticks, DateTimeKind.Unspecified)
+		{ }
+
+		public TimeStamp(long ticks, DateTimeKind kind)
+			: this(kind)
+		{
+			Value = new DateTime(ticks, kind);
+			Stamp = ResolveStamp();
+		}
+
+		public TimeStamp(DateTimeKind kind)
+			: this()
+		{
+			Kind = kind;
+		}
+
+		public TimeStamp(GenericReader reader)
+			: this(Origin)
+		{
+			Deserialize(reader);
+		}
+
+		private DateTime ResolveDate()
+		{
+			var dt = new DateTime(
+				Origin.Year,
+				Origin.Month,
+				Origin.Day,
+				Origin.Hour,
+				Origin.Minute,
+				Origin.Second,
+				Origin.Millisecond,
+				Kind);
+
+			return dt.AddSeconds(Stamp);
+		}
+
+		private double ResolveStamp()
+		{
+			return Value.Subtract(Origin).TotalSeconds;
+		}
+
+		public TimeStamp Add(TimeSpan ts)
+		{
+			return Stamp + ts.TotalSeconds;
+		}
+
+		public TimeStamp Subtract(TimeSpan ts)
+		{
+			return Stamp - ts.TotalSeconds;
+		}
+
+		public override int GetHashCode()
+		{
+			return Stamp.GetHashCode();
+		}
+
+		public override bool Equals(object obj)
+		{
+			return (obj is TimeStamp && Equals((TimeStamp)obj)) //
+				   || (obj is DateTime && Equals((DateTime)obj)) //
+				   || (obj is TimeSpan && Equals((TimeSpan)obj)) //
+				   || (obj is double && Equals((double)obj)) //
+				   || (obj is long && Equals((long)obj));
+		}
+
+		public bool Equals(TimeStamp t)
+		{
+			return Stamp == t.Stamp;
+		}
+
+		public bool Equals(DateTime d)
+		{
+			return Value == d;
+		}
+
+		public bool Equals(TimeSpan t)
+		{
+			return Stamp == t.TotalSeconds;
+		}
+
+		public bool Equals(double stamp)
+		{
+			return Stamp == stamp;
+		}
+
+		public bool Equals(long ticks)
+		{
+			return Ticks == ticks;
+		}
+
+		public int CompareTo(TimeStamp t)
+		{
+			return Stamp.CompareTo(t.Stamp);
+		}
+
+		public int CompareTo(DateTime d)
+		{
+			return Value.CompareTo(d);
+		}
+
+		public int CompareTo(TimeSpan t)
+		{
+			return Stamp.CompareTo(t.TotalSeconds);
+		}
+
+		public int CompareTo(double stamp)
+		{
+			return Stamp.CompareTo(stamp);
+		}
+
+		public int CompareTo(long ticks)
+		{
+			return Ticks.CompareTo(ticks);
+		}
+
+		public override string ToString()
+		{
+			return String.Format("{0:F2}", Stamp);
+		}
+
+		public void Serialize(GenericWriter writer)
+		{
+			var version = writer.SetVersion(1);
+
+			switch (version)
+			{
+				case 1:
+					writer.WriteFlag(Kind);
+					goto case 0;
+				case 0:
+					writer.Write(Stamp);
+					break;
+			}
+		}
+
+		public void Deserialize(GenericReader reader)
+		{
+			var version = reader.GetVersion();
+
+			switch (version)
+			{
+				case 1:
+					Kind = reader.ReadFlag<DateTimeKind>();
+					goto case 0;
+				case 0:
+				{
+					Stamp = reader.ReadDouble();
+					Value = ResolveDate();
+				}
+				break;
+			}
+		}
+
+		#region TimeStamp Equality
+		public static bool operator ==(TimeStamp l, TimeStamp r)
+		{
+			return l.Stamp.Equals(r.Stamp);
+		}
+
+		public static bool operator !=(TimeStamp l, TimeStamp r)
+		{
+			return !l.Stamp.Equals(r.Stamp);
+		}
+
+		public static bool operator >(TimeStamp l, TimeStamp r)
+		{
+			return l.Stamp > r.Stamp;
+		}
+
+		public static bool operator <(TimeStamp l, TimeStamp r)
+		{
+			return l.Stamp < r.Stamp;
+		}
+
+		public static bool operator >=(TimeStamp l, TimeStamp r)
+		{
+			return l.Stamp >= r.Stamp;
+		}
+
+		public static bool operator <=(TimeStamp l, TimeStamp r)
+		{
+			return l.Stamp <= r.Stamp;
+		}
+		#endregion
+
+		#region DateTime Equality
+		public static bool operator ==(TimeStamp l, DateTime r)
+		{
+			return l.Ticks.Equals(r.Ticks);
+		}
+
+		public static bool operator !=(TimeStamp l, DateTime r)
+		{
+			return !l.Ticks.Equals(r.Ticks);
+		}
+
+		public static bool operator >(TimeStamp l, DateTime r)
+		{
+			return l.Ticks > r.Ticks;
+		}
+
+		public static bool operator <(TimeStamp l, DateTime r)
+		{
+			return l.Ticks < r.Ticks;
+		}
+
+		public static bool operator >=(TimeStamp l, DateTime r)
+		{
+			return l.Ticks >= r.Ticks;
+		}
+
+		public static bool operator <=(TimeStamp l, DateTime r)
+		{
+			return l.Ticks <= r.Ticks;
+		}
+
+		public static bool operator ==(DateTime l, TimeStamp r)
+		{
+			return l.Ticks.Equals(r.Ticks);
+		}
+
+		public static bool operator !=(DateTime l, TimeStamp r)
+		{
+			return !l.Ticks.Equals(r.Ticks);
+		}
+
+		public static bool operator >(DateTime l, TimeStamp r)
+		{
+			return l.Ticks > r.Ticks;
+		}
+
+		public static bool operator <(DateTime l, TimeStamp r)
+		{
+			return l.Ticks < r.Ticks;
+		}
+
+		public static bool operator >=(DateTime l, TimeStamp r)
+		{
+			return l.Ticks >= r.Ticks;
+		}
+
+		public static bool operator <=(DateTime l, TimeStamp r)
+		{
+			return l.Ticks <= r.Ticks;
+		}
+		#endregion
+
+		#region TimeSpan Equality
+		public static bool operator ==(TimeStamp l, TimeSpan r)
+		{
+			return l.Stamp.Equals(r.TotalSeconds);
+		}
+
+		public static bool operator !=(TimeStamp l, TimeSpan r)
+		{
+			return !l.Stamp.Equals(r.TotalSeconds);
+		}
+
+		public static bool operator >(TimeStamp l, TimeSpan r)
+		{
+			return l.Stamp > r.TotalSeconds;
+		}
+
+		public static bool operator <(TimeStamp l, TimeSpan r)
+		{
+			return l.Stamp < r.TotalSeconds;
+		}
+
+		public static bool operator >=(TimeStamp l, TimeSpan r)
+		{
+			return l.Stamp >= r.TotalSeconds;
+		}
+
+		public static bool operator <=(TimeStamp l, TimeSpan r)
+		{
+			return l.Stamp <= r.TotalSeconds;
+		}
+
+		public static bool operator ==(TimeSpan l, TimeStamp r)
+		{
+			return l.TotalSeconds.Equals(r.Stamp);
+		}
+
+		public static bool operator !=(TimeSpan l, TimeStamp r)
+		{
+			return !l.TotalSeconds.Equals(r.Stamp);
+		}
+
+		public static bool operator >(TimeSpan l, TimeStamp r)
+		{
+			return l.TotalSeconds > r.Stamp;
+		}
+
+		public static bool operator <(TimeSpan l, TimeStamp r)
+		{
+			return l.TotalSeconds < r.Stamp;
+		}
+
+		public static bool operator >=(TimeSpan l, TimeStamp r)
+		{
+			return l.TotalSeconds >= r.Stamp;
+		}
+
+		public static bool operator <=(TimeSpan l, TimeStamp r)
+		{
+			return l.TotalSeconds <= r.Stamp;
+		}
+		#endregion
+
+		#region Stamp Equality
+		public static bool operator ==(TimeStamp l, double r)
+		{
+			return l.Stamp.Equals(r);
+		}
+
+		public static bool operator !=(TimeStamp l, double r)
+		{
+			return !l.Stamp.Equals(r);
+		}
+
+		public static bool operator >(TimeStamp l, double r)
+		{
+			return l.Stamp > r;
+		}
+
+		public static bool operator <(TimeStamp l, double r)
+		{
+			return l.Stamp < r;
+		}
+
+		public static bool operator >=(TimeStamp l, double r)
+		{
+			return l.Stamp >= r;
+		}
+
+		public static bool operator <=(TimeStamp l, double r)
+		{
+			return l.Stamp <= r;
+		}
+
+		public static bool operator ==(double l, TimeStamp r)
+		{
+			return l.Equals(r.Stamp);
+		}
+
+		public static bool operator !=(double l, TimeStamp r)
+		{
+			return !l.Equals(r.Stamp);
+		}
+
+		public static bool operator >(double l, TimeStamp r)
+		{
+			return l > r.Stamp;
+		}
+
+		public static bool operator <(double l, TimeStamp r)
+		{
+			return l < r.Stamp;
+		}
+
+		public static bool operator >=(double l, TimeStamp r)
+		{
+			return l >= r.Stamp;
+		}
+
+		public static bool operator <=(double l, TimeStamp r)
+		{
+			return l <= r.Stamp;
+		}
+		#endregion
+
+		#region Ticks Equality
+		public static bool operator ==(TimeStamp l, long r)
+		{
+			return l.Ticks.Equals(r);
+		}
+
+		public static bool operator !=(TimeStamp l, long r)
+		{
+			return !l.Ticks.Equals(r);
+		}
+
+		public static bool operator >(TimeStamp l, long r)
+		{
+			return l.Ticks > r;
+		}
+
+		public static bool operator <(TimeStamp l, long r)
+		{
+			return l.Ticks < r;
+		}
+
+		public static bool operator >=(TimeStamp l, long r)
+		{
+			return l.Ticks >= r;
+		}
+
+		public static bool operator <=(TimeStamp l, long r)
+		{
+			return l.Ticks <= r;
+		}
+
+		public static bool operator ==(long l, TimeStamp r)
+		{
+			return l.Equals(r.Ticks);
+		}
+
+		public static bool operator !=(long l, TimeStamp r)
+		{
+			return !l.Equals(r.Ticks);
+		}
+
+		public static bool operator >(long l, TimeStamp r)
+		{
+			return l > r.Ticks;
+		}
+
+		public static bool operator <(long l, TimeStamp r)
+		{
+			return l < r.Ticks;
+		}
+
+		public static bool operator >=(long l, TimeStamp r)
+		{
+			return l >= r.Ticks;
+		}
+
+		public static bool operator <=(long l, TimeStamp r)
+		{
+			return l <= r.Ticks;
+		}
+		#endregion
+
+		public static implicit operator TimeStamp(DateTime date)
+		{
+			return new TimeStamp(date);
+		}
+
+		public static implicit operator TimeStamp(TimeSpan time)
+		{
+			return new TimeStamp(time);
+		}
+
+		public static implicit operator TimeStamp(double stamp)
+		{
+			return new TimeStamp(stamp);
+		}
+
+		public static implicit operator TimeStamp(long ticks)
+		{
+			return new TimeStamp(ticks);
+		}
+	}
+}