mirror of
https://github.com/ServUO/ServUO
synced 2026-08-11 20:23:04 -04:00
978 lines
23 KiB
C#
978 lines
23 KiB
C#
#region References
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Runtime;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
|
|
using Server.Network;
|
|
#endregion
|
|
|
|
namespace Server
|
|
{
|
|
public delegate void Slice();
|
|
|
|
public static class Core
|
|
{
|
|
static Core()
|
|
{
|
|
DataDirectories = new List<string>();
|
|
|
|
GlobalMaxUpdateRange = 24;
|
|
GlobalUpdateRange = 18;
|
|
GlobalRadarRange = 40;
|
|
}
|
|
|
|
public static Action<CrashedEventArgs> CrashedHandler { get; set; }
|
|
|
|
public static bool Crashed => _Crashed;
|
|
|
|
private static bool _Crashed;
|
|
private static Thread _TimerThread;
|
|
private static string _BaseDirectory;
|
|
private static string _ExePath;
|
|
|
|
private static bool _Cache = true;
|
|
|
|
private static bool _Profiling;
|
|
private static DateTime _ProfileStart;
|
|
private static TimeSpan _ProfileTime;
|
|
|
|
public static MessagePump MessagePump { get; set; }
|
|
|
|
public static Slice Slice;
|
|
|
|
public static bool Profiling
|
|
{
|
|
get => _Profiling;
|
|
set
|
|
{
|
|
if (_Profiling == value)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_Profiling = value;
|
|
|
|
if (_ProfileStart > DateTime.MinValue)
|
|
{
|
|
_ProfileTime += DateTime.UtcNow - _ProfileStart;
|
|
}
|
|
|
|
_ProfileStart = _Profiling ? DateTime.UtcNow : DateTime.MinValue;
|
|
}
|
|
}
|
|
|
|
public static TimeSpan ProfileTime
|
|
{
|
|
get
|
|
{
|
|
if (_ProfileStart > DateTime.MinValue)
|
|
{
|
|
return _ProfileTime + (DateTime.UtcNow - _ProfileStart);
|
|
}
|
|
|
|
return _ProfileTime;
|
|
}
|
|
}
|
|
|
|
public static bool Service { get; private set; }
|
|
|
|
public static bool NoConsole { get; private set; }
|
|
public static bool Debug { get; private set; }
|
|
|
|
public static bool HaltOnWarning { get; private set; }
|
|
public static bool VBdotNet { get; private set; }
|
|
|
|
public static List<string> DataDirectories { get; private set; }
|
|
|
|
public static Assembly Assembly { get; set; }
|
|
|
|
public static Version Version => Assembly.GetName().Version;
|
|
|
|
public static Process Process { get; private set; }
|
|
public static Thread Thread { get; private set; }
|
|
|
|
public static MultiTextWriter MultiConsoleOut { get; private set; }
|
|
|
|
/*
|
|
* DateTime.Now and DateTime.UtcNow are based on actual system clock time.
|
|
* The resolution is acceptable but large clock jumps are possible and cause issues.
|
|
* GetTickCount and GetTickCount64 have poor resolution.
|
|
* GetTickCount64 is unavailable on Windows XP and Windows Server 2003.
|
|
* Stopwatch.GetTimestamp() (QueryPerformanceCounter) is high resolution, but
|
|
* somewhat expensive to call because of its defference to DateTime.Now,
|
|
* which is why Stopwatch has been used to verify HRT before calling GetTimestamp(),
|
|
* enabling the usage of DateTime.UtcNow instead.
|
|
*/
|
|
|
|
private static readonly bool _HighRes = Stopwatch.IsHighResolution;
|
|
|
|
private static readonly double _HighFrequency = 1000.0 / Stopwatch.Frequency;
|
|
private const double _LowFrequency = 1000.0 / TimeSpan.TicksPerSecond;
|
|
|
|
private static bool _UseHRT;
|
|
|
|
public static bool UsingHighResolutionTiming => _UseHRT && _HighRes && !Unix;
|
|
|
|
public static long TickCount => (long)Ticks;
|
|
|
|
public static double Ticks
|
|
{
|
|
get
|
|
{
|
|
if (_UseHRT && _HighRes && !Unix)
|
|
{
|
|
return Stopwatch.GetTimestamp() * _HighFrequency;
|
|
}
|
|
|
|
return DateTime.UtcNow.Ticks * _LowFrequency;
|
|
}
|
|
}
|
|
|
|
public static readonly bool Is64Bit = Environment.Is64BitProcess;
|
|
|
|
public static bool MultiProcessor { get; private set; }
|
|
public static int ProcessorCount { get; private set; }
|
|
|
|
public static bool Unix { get; private set; }
|
|
|
|
public static string FindDataFile(string path)
|
|
{
|
|
if (DataDirectories.Count == 0)
|
|
{
|
|
throw new InvalidOperationException("Attempted to FindDataFile before DataDirectories list has been filled.");
|
|
}
|
|
|
|
string fullPath = null;
|
|
|
|
foreach (var p in DataDirectories)
|
|
{
|
|
fullPath = Path.Combine(p, path);
|
|
|
|
if (File.Exists(fullPath))
|
|
{
|
|
break;
|
|
}
|
|
|
|
fullPath = null;
|
|
}
|
|
|
|
return fullPath;
|
|
}
|
|
|
|
public static string FindDataFile(string format, params object[] args)
|
|
{
|
|
return FindDataFile(String.Format(format, args));
|
|
}
|
|
|
|
#region Expansions
|
|
public static Expansion Expansion => Expansion.EJ;
|
|
|
|
public static bool T2A => Expansion >= Expansion.T2A;
|
|
public static bool UOR => Expansion >= Expansion.UOR;
|
|
public static bool UOTD => Expansion >= Expansion.UOTD;
|
|
public static bool LBR => Expansion >= Expansion.LBR;
|
|
public static bool AOS => Expansion >= Expansion.AOS;
|
|
public static bool SE => Expansion >= Expansion.SE;
|
|
public static bool ML => Expansion >= Expansion.ML;
|
|
public static bool SA => Expansion >= Expansion.SA;
|
|
public static bool HS => Expansion >= Expansion.HS;
|
|
public static bool TOL => Expansion >= Expansion.TOL;
|
|
public static bool EJ => Expansion >= Expansion.EJ;
|
|
#endregion
|
|
|
|
public static string ExePath => _ExePath ?? (_ExePath = Assembly.Location);
|
|
|
|
public static string BaseDirectory
|
|
{
|
|
get
|
|
{
|
|
if (_BaseDirectory == null)
|
|
{
|
|
try
|
|
{
|
|
_BaseDirectory = ExePath;
|
|
|
|
if (_BaseDirectory.Length > 0)
|
|
{
|
|
_BaseDirectory = Path.GetDirectoryName(_BaseDirectory);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
_BaseDirectory = "";
|
|
}
|
|
}
|
|
|
|
return _BaseDirectory;
|
|
}
|
|
}
|
|
|
|
private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
|
|
{
|
|
Console.WriteLine(e.IsTerminating ? "Error:" : "Warning:");
|
|
Console.WriteLine(e.ExceptionObject);
|
|
|
|
if (e.IsTerminating)
|
|
{
|
|
_Crashed = true;
|
|
|
|
var close = false;
|
|
|
|
var args = new CrashedEventArgs(e.ExceptionObject as Exception);
|
|
|
|
try
|
|
{
|
|
EventSink.InvokeCrashed(args);
|
|
close = args.Close;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Diagnostics.ExceptionLogging.LogException(ex);
|
|
}
|
|
|
|
if (CrashedHandler != null)
|
|
{
|
|
try
|
|
{
|
|
CrashedHandler(args);
|
|
close = args.Close;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Diagnostics.ExceptionLogging.LogException(ex);
|
|
}
|
|
}
|
|
|
|
if (!close && !Service)
|
|
{
|
|
try
|
|
{
|
|
foreach (var l in MessagePump.Listeners)
|
|
{
|
|
l.Dispose();
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
|
|
Console.WriteLine("This exception is fatal, press return to exit");
|
|
Console.ReadLine();
|
|
}
|
|
|
|
Kill();
|
|
}
|
|
}
|
|
|
|
private enum ConsoleEventType
|
|
{
|
|
CTRL_C_EVENT,
|
|
CTRL_BREAK_EVENT,
|
|
CTRL_CLOSE_EVENT,
|
|
CTRL_LOGOFF_EVENT = 5,
|
|
CTRL_SHUTDOWN_EVENT
|
|
}
|
|
|
|
private delegate bool ConsoleEventHandler(ConsoleEventType type);
|
|
|
|
private static ConsoleEventHandler m_ConsoleEventHandler;
|
|
|
|
private static class UnsafeNativeMethods
|
|
{
|
|
[DllImport("Kernel32")]
|
|
public static extern bool SetConsoleCtrlHandler(ConsoleEventHandler callback, bool add);
|
|
}
|
|
|
|
private static bool OnConsoleEvent(ConsoleEventType type)
|
|
{
|
|
if (World.Saving || (Service && type == ConsoleEventType.CTRL_LOGOFF_EVENT))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
Kill(); //Kill -> HandleClosed will handle waiting for the completion of flushing to disk
|
|
|
|
return true;
|
|
}
|
|
|
|
private static void CurrentDomain_ProcessExit(object sender, EventArgs e)
|
|
{
|
|
HandleClosed();
|
|
}
|
|
|
|
public static bool Closing { get; private set; }
|
|
|
|
private static int _CycleIndex = 1;
|
|
private static readonly float[] _CyclesPerSecond = new float[100];
|
|
|
|
public static float CyclesPerSecond => _CyclesPerSecond[(_CycleIndex - 1) % _CyclesPerSecond.Length];
|
|
|
|
public static float AverageCPS => _CyclesPerSecond.Take(_CycleIndex).Average();
|
|
|
|
public static void Kill()
|
|
{
|
|
Kill(false);
|
|
}
|
|
|
|
#if MONO
|
|
private static string[] SupportedTerminals => new string[]
|
|
{
|
|
"xfce4-terminal", "gnome-terminal", "xterm"
|
|
};
|
|
|
|
private static void RebootTerminal(int i = 0)
|
|
{
|
|
if(SupportedTerminals.Length > i)
|
|
{
|
|
try {
|
|
if(SupportedTerminals[i] != "xterm")
|
|
Process.Start(SupportedTerminals[i], $"--working-directory={BaseDirectory} -x ./ServUO.sh");
|
|
else
|
|
Process.Start(SupportedTerminals[i], $"-lcc {BaseDirectory} -e ./ServUO.sh");
|
|
Thread.Sleep(500); // a sleep here to not close the programm to quick, so that the new windows cant start.
|
|
}
|
|
catch(System.ComponentModel.Win32Exception)
|
|
{
|
|
RebootTerminal(i+1);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
public static void Kill(bool restart)
|
|
{
|
|
HandleClosed();
|
|
|
|
if (restart)
|
|
{
|
|
#if MONO
|
|
RebootTerminal();
|
|
Environment.Exit(0);
|
|
}
|
|
#else
|
|
Process.Start(ExePath, Arguments);
|
|
}
|
|
Process.Kill();
|
|
#endif
|
|
}
|
|
|
|
private static void HandleClosed()
|
|
{
|
|
if (Closing)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Closing = true;
|
|
|
|
if (Debug)
|
|
Console.Write("Exiting...");
|
|
|
|
World.WaitForWriteCompletion();
|
|
|
|
if (!_Crashed)
|
|
{
|
|
EventSink.InvokeShutdown(new ShutdownEventArgs());
|
|
}
|
|
|
|
Timer.TimerThread.Set();
|
|
|
|
if (Debug)
|
|
Console.WriteLine("done");
|
|
}
|
|
|
|
private static readonly AutoResetEvent _Signal = new AutoResetEvent(true);
|
|
|
|
public static void Set()
|
|
{
|
|
_Signal.Set();
|
|
}
|
|
|
|
public static void Setup(string[] args)
|
|
{
|
|
#if DEBUG
|
|
Debug = true;
|
|
#endif
|
|
|
|
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
|
|
AppDomain.CurrentDomain.ProcessExit += CurrentDomain_ProcessExit;
|
|
|
|
foreach (var a in args)
|
|
{
|
|
if (Insensitive.Equals(a, "-debug"))
|
|
{
|
|
Debug = true;
|
|
}
|
|
else if (Insensitive.Equals(a, "-service"))
|
|
{
|
|
Service = true;
|
|
}
|
|
else if (Insensitive.Equals(a, "-profile"))
|
|
{
|
|
Profiling = true;
|
|
}
|
|
else if (Insensitive.Equals(a, "-nocache"))
|
|
{
|
|
_Cache = false;
|
|
}
|
|
else if (Insensitive.Equals(a, "-haltonwarning"))
|
|
{
|
|
HaltOnWarning = true;
|
|
}
|
|
else if (Insensitive.Equals(a, "-vb"))
|
|
{
|
|
VBdotNet = true;
|
|
}
|
|
else if (Insensitive.Equals(a, "-usehrt"))
|
|
{
|
|
_UseHRT = true;
|
|
}
|
|
else if (Insensitive.Equals(a, "-noconsole"))
|
|
{
|
|
NoConsole = true;
|
|
}
|
|
else if (Insensitive.Equals(a, "-h") || Insensitive.Equals(a, "-help"))
|
|
{
|
|
Console.WriteLine("An Ultima Online server emulator written in C# - Visit https://www.servuo.com for more information.\n\n");
|
|
Console.WriteLine(AppDomain.CurrentDomain.FriendlyName + " [Parameter]\n\n");
|
|
Console.WriteLine(" -debug Starting ServUO in Debug Mode. Debug Mode is being used in Core and Scripts to give extended inforamtion during runtime.");
|
|
Console.WriteLine(" -haltonwarning ServUO halts if any warning is raised during compilation of scripts.");
|
|
Console.WriteLine(" -h or -help Displays this help text.");
|
|
Console.WriteLine(" -nocache No known effect.");
|
|
Console.WriteLine(" -noconsole No user interaction during startup and runtime.");
|
|
Console.WriteLine(" -profile Enables profiling allowing to get performance diagnostic information of packets, timers etc. in AdminGump -> Maintenance. Use with caution. This increases server load.");
|
|
Console.WriteLine(" -service This parameter should be set if you're running ServUO as a Windows Service. No user interaction. *Windows only*");
|
|
Console.WriteLine(" -usehrt Enables High Resolution Timing if requirements are met. Increasing the resolution of the timer. *Windows only*");
|
|
Console.WriteLine(" -vb Enables compilation of VB.NET Scripts. Without this option VB.NET Scripts are skipped.");
|
|
|
|
Environment.Exit(0);
|
|
}
|
|
}
|
|
|
|
if (!Environment.UserInteractive || Service)
|
|
{
|
|
NoConsole = true;
|
|
}
|
|
|
|
try
|
|
{
|
|
if (Service)
|
|
{
|
|
if (!Directory.Exists("Logs"))
|
|
{
|
|
Directory.CreateDirectory("Logs");
|
|
}
|
|
|
|
Console.SetOut(MultiConsoleOut = new MultiTextWriter(new FileLogger("Logs/Console.log")));
|
|
}
|
|
else
|
|
{
|
|
Console.SetOut(MultiConsoleOut = new MultiTextWriter(Console.Out));
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Diagnostics.ExceptionLogging.LogException(e);
|
|
}
|
|
|
|
Thread = Thread.CurrentThread;
|
|
Process = Process.GetCurrentProcess();
|
|
Assembly = Assembly.GetEntryAssembly();
|
|
|
|
if (Thread != null)
|
|
{
|
|
Thread.Name = "Core Thread";
|
|
}
|
|
|
|
if (BaseDirectory.Length > 0)
|
|
{
|
|
Directory.SetCurrentDirectory(BaseDirectory);
|
|
}
|
|
|
|
var ttObj = new Timer.TimerThread();
|
|
|
|
_TimerThread = new Thread(ttObj.TimerMain)
|
|
{
|
|
Name = "Timer Thread"
|
|
};
|
|
|
|
var ver = Assembly.GetName().Version;
|
|
var buildDate = new DateTime(2000, 1, 1).AddDays(ver.Build).AddSeconds(ver.Revision * 2);
|
|
|
|
Utility.PushColor(ConsoleColor.Cyan);
|
|
#if DEBUG
|
|
Console.WriteLine(
|
|
"ServUO - [https://www.servuo.com] Version {0}.{1}, Build {2}.{3} - Build on {4} UTC - Debug",
|
|
ver.Major,
|
|
ver.Minor,
|
|
ver.Build,
|
|
ver.Revision,
|
|
buildDate);
|
|
#else
|
|
Console.WriteLine(
|
|
"ServUO - [https://www.servuo.com] Version {0}.{1}, Build {2}.{3} - Build on {4} UTC - Release",
|
|
ver.Major,
|
|
ver.Minor,
|
|
ver.Build,
|
|
ver.Revision,
|
|
buildDate);
|
|
#endif
|
|
Utility.PopColor();
|
|
|
|
var s = Arguments;
|
|
|
|
if (s.Length > 0)
|
|
{
|
|
Utility.PushColor(ConsoleColor.Yellow);
|
|
Console.WriteLine("Core: Running with arguments: {0}", s);
|
|
Utility.PopColor();
|
|
}
|
|
|
|
ProcessorCount = Environment.ProcessorCount;
|
|
|
|
if (ProcessorCount > 1)
|
|
{
|
|
MultiProcessor = true;
|
|
}
|
|
|
|
if (MultiProcessor || Is64Bit)
|
|
{
|
|
Utility.PushColor(ConsoleColor.Green);
|
|
Console.WriteLine(
|
|
"Core: Optimizing for {0} {2}processor{1}",
|
|
ProcessorCount,
|
|
ProcessorCount == 1 ? "" : "s",
|
|
Is64Bit ? "64-bit " : "");
|
|
Utility.PopColor();
|
|
}
|
|
|
|
string dotnet = null;
|
|
|
|
if (Type.GetType("Mono.Runtime") != null)
|
|
{
|
|
var displayName = Type.GetType("Mono.Runtime").GetMethod("GetDisplayName", BindingFlags.NonPublic | BindingFlags.Static);
|
|
|
|
if (displayName != null)
|
|
{
|
|
dotnet = displayName.Invoke(null, null).ToString();
|
|
|
|
Utility.PushColor(ConsoleColor.Yellow);
|
|
Console.WriteLine("Core: Unix environment detected");
|
|
Utility.PopColor();
|
|
|
|
Unix = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_ConsoleEventHandler = OnConsoleEvent;
|
|
UnsafeNativeMethods.SetConsoleCtrlHandler(m_ConsoleEventHandler, true);
|
|
}
|
|
|
|
#if NETFX_472
|
|
dotnet = "4.7.2";
|
|
#endif
|
|
|
|
#if NETFX_48
|
|
dotnet = "4.8";
|
|
#endif
|
|
|
|
if (String.IsNullOrEmpty(dotnet))
|
|
dotnet = "MONO/CSC/Unknown";
|
|
|
|
Utility.PushColor(ConsoleColor.Green);
|
|
Console.WriteLine("Core: Compiled for " + (Unix ? "MONO and running on {0}" : ".NET {0}"), dotnet);
|
|
Utility.PopColor();
|
|
|
|
if (GCSettings.IsServerGC)
|
|
{
|
|
Utility.PushColor(ConsoleColor.Green);
|
|
Console.WriteLine("Core: Server garbage collection mode enabled");
|
|
Utility.PopColor();
|
|
}
|
|
|
|
if (_UseHRT)
|
|
{
|
|
Utility.PushColor(ConsoleColor.DarkYellow);
|
|
Console.WriteLine(
|
|
"Core: Requested high resolution timing ({0})",
|
|
UsingHighResolutionTiming ? "Supported" : "Unsupported");
|
|
Utility.PopColor();
|
|
}
|
|
|
|
Utility.PushColor(ConsoleColor.DarkYellow);
|
|
Console.WriteLine("RandomImpl: {0} ({1})", RandomImpl.Type.Name, RandomImpl.IsHardwareRNG ? "Hardware" : "Software");
|
|
Utility.PopColor();
|
|
|
|
Utility.PushColor(ConsoleColor.Green);
|
|
Console.WriteLine("Core: Loading config...");
|
|
Config.Load();
|
|
Utility.PopColor();
|
|
|
|
while (!ScriptCompiler.Compile(Debug, _Cache))
|
|
{
|
|
Utility.PushColor(ConsoleColor.Red);
|
|
Console.WriteLine("Scripts: One or more scripts failed to compile or no script files were found.");
|
|
Utility.PopColor();
|
|
|
|
if (Service)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Console.WriteLine(" - Press return to exit, or R to try again.");
|
|
|
|
if (Console.ReadKey(true).Key != ConsoleKey.R)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
ScriptCompiler.Invoke("Configure");
|
|
|
|
Region.Load();
|
|
World.Load();
|
|
|
|
ScriptCompiler.Invoke("Initialize");
|
|
|
|
MessagePump = new MessagePump();
|
|
|
|
foreach (var m in Map.AllMaps)
|
|
{
|
|
m.Tiles.Force();
|
|
}
|
|
|
|
NetState.Initialize();
|
|
}
|
|
|
|
public static void Run()
|
|
{
|
|
EventSink.InvokeServerStarted();
|
|
|
|
_TimerThread.Start();
|
|
|
|
try
|
|
{
|
|
long now, last = TickCount;
|
|
|
|
const int sampleInterval = 100;
|
|
const float ticksPerSecond = 1000.0f * sampleInterval;
|
|
|
|
long sample = 0;
|
|
|
|
while (!Closing)
|
|
{
|
|
_Signal.WaitOne();
|
|
|
|
Mobile.ProcessDeltaQueue();
|
|
Item.ProcessDeltaQueue();
|
|
|
|
Timer.Slice();
|
|
MessagePump.Slice();
|
|
|
|
NetState.FlushAll();
|
|
NetState.ProcessDisposedQueue();
|
|
|
|
if (Slice != null)
|
|
{
|
|
Slice();
|
|
}
|
|
|
|
if (sample++ % sampleInterval != 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
now = TickCount;
|
|
_CyclesPerSecond[_CycleIndex++ % _CyclesPerSecond.Length] = ticksPerSecond / (now - last);
|
|
last = now;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
CurrentDomain_UnhandledException(null, new UnhandledExceptionEventArgs(e, true));
|
|
}
|
|
}
|
|
|
|
public static string Arguments
|
|
{
|
|
get
|
|
{
|
|
var sb = new StringBuilder();
|
|
|
|
if (Debug)
|
|
{
|
|
Utility.Separate(sb, "-debug", " ");
|
|
}
|
|
|
|
if (Service)
|
|
{
|
|
Utility.Separate(sb, "-service", " ");
|
|
}
|
|
|
|
if (Profiling)
|
|
{
|
|
Utility.Separate(sb, "-profile", " ");
|
|
}
|
|
|
|
if (!_Cache)
|
|
{
|
|
Utility.Separate(sb, "-nocache", " ");
|
|
}
|
|
|
|
if (HaltOnWarning)
|
|
{
|
|
Utility.Separate(sb, "-haltonwarning", " ");
|
|
}
|
|
|
|
if (VBdotNet)
|
|
{
|
|
Utility.Separate(sb, "-vb", " ");
|
|
}
|
|
|
|
if (_UseHRT)
|
|
{
|
|
Utility.Separate(sb, "-usehrt", " ");
|
|
}
|
|
|
|
if (NoConsole)
|
|
{
|
|
Utility.Separate(sb, "-noconsole", " ");
|
|
}
|
|
|
|
return sb.ToString();
|
|
}
|
|
}
|
|
|
|
public static int GlobalUpdateRange { get; set; }
|
|
public static int GlobalMaxUpdateRange { get; set; }
|
|
public static int GlobalRadarRange { get; set; }
|
|
|
|
private static int m_ItemCount, m_MobileCount, m_CustomsCount;
|
|
|
|
public static int ScriptItems => m_ItemCount;
|
|
public static int ScriptMobiles => m_MobileCount;
|
|
public static int ScriptCustoms => m_CustomsCount;
|
|
|
|
public static void VerifySerialization()
|
|
{
|
|
m_ItemCount = 0;
|
|
m_MobileCount = 0;
|
|
m_CustomsCount = 0;
|
|
|
|
VerifySerialization(Assembly.GetCallingAssembly());
|
|
|
|
foreach (var a in ScriptCompiler.Assemblies)
|
|
{
|
|
VerifySerialization(a);
|
|
}
|
|
}
|
|
|
|
private static readonly Type[] m_SerialTypeArray = { typeof(Serial) };
|
|
|
|
private static void VerifyType(Type t)
|
|
{
|
|
var isItem = t.IsSubclassOf(typeof(Item));
|
|
|
|
if (isItem || t.IsSubclassOf(typeof(Mobile)))
|
|
{
|
|
if (isItem)
|
|
{
|
|
Interlocked.Increment(ref m_ItemCount);
|
|
}
|
|
else
|
|
{
|
|
Interlocked.Increment(ref m_MobileCount);
|
|
}
|
|
|
|
StringBuilder warningSb = null;
|
|
|
|
try
|
|
{
|
|
if (t.GetConstructor(m_SerialTypeArray) == null)
|
|
{
|
|
warningSb = new StringBuilder();
|
|
|
|
warningSb.AppendLine(" - No serialization constructor");
|
|
}
|
|
|
|
if (
|
|
t.GetMethod(
|
|
"Serialize",
|
|
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly) == null)
|
|
{
|
|
if (warningSb == null)
|
|
{
|
|
warningSb = new StringBuilder();
|
|
}
|
|
|
|
warningSb.AppendLine(" - No Serialize() method");
|
|
}
|
|
|
|
if (
|
|
t.GetMethod(
|
|
"Deserialize",
|
|
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly) == null)
|
|
{
|
|
if (warningSb == null)
|
|
{
|
|
warningSb = new StringBuilder();
|
|
}
|
|
|
|
warningSb.AppendLine(" - No Deserialize() method");
|
|
}
|
|
|
|
if (warningSb != null && warningSb.Length > 0)
|
|
{
|
|
Utility.PushColor(ConsoleColor.Yellow);
|
|
Console.WriteLine("Warning: {0}\n{1}", t, warningSb);
|
|
Utility.PopColor();
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
Utility.PushColor(ConsoleColor.Yellow);
|
|
Console.WriteLine("Warning: Exception in serialization verification of type {0}", t);
|
|
Utility.PopColor();
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void VerifySerialization(Assembly a)
|
|
{
|
|
if (a != null)
|
|
{
|
|
Parallel.ForEach(a.GetTypes(), VerifyType);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class FileLogger : TextWriter
|
|
{
|
|
public const string DateFormat = "[MMMM dd hh:mm:ss.f tt]: ";
|
|
|
|
private bool _NewLine;
|
|
|
|
public string FileName { get; private set; }
|
|
|
|
public FileLogger(string file)
|
|
: this(file, false)
|
|
{ }
|
|
|
|
public FileLogger(string file, bool append)
|
|
{
|
|
FileName = file;
|
|
|
|
using (
|
|
var writer =
|
|
new StreamWriter(
|
|
new FileStream(FileName, append ? FileMode.Append : FileMode.Create, FileAccess.Write, FileShare.Read)))
|
|
{
|
|
writer.WriteLine(">>>Logging started on {0:f}.", DateTime.Now);
|
|
//f = Tuesday, April 10, 2001 3:51 PM
|
|
}
|
|
|
|
_NewLine = true;
|
|
}
|
|
|
|
public override void Write(char ch)
|
|
{
|
|
using (var writer = new StreamWriter(new FileStream(FileName, FileMode.Append, FileAccess.Write, FileShare.Read)))
|
|
{
|
|
if (_NewLine)
|
|
{
|
|
writer.Write(DateTime.UtcNow.ToString(DateFormat));
|
|
_NewLine = false;
|
|
}
|
|
|
|
writer.Write(ch);
|
|
}
|
|
}
|
|
|
|
public override void Write(string str)
|
|
{
|
|
using (var writer = new StreamWriter(new FileStream(FileName, FileMode.Append, FileAccess.Write, FileShare.Read)))
|
|
{
|
|
if (_NewLine)
|
|
{
|
|
writer.Write(DateTime.UtcNow.ToString(DateFormat));
|
|
_NewLine = false;
|
|
}
|
|
|
|
writer.Write(str);
|
|
}
|
|
}
|
|
|
|
public override void WriteLine(string line)
|
|
{
|
|
using (var writer = new StreamWriter(new FileStream(FileName, FileMode.Append, FileAccess.Write, FileShare.Read)))
|
|
{
|
|
if (_NewLine)
|
|
{
|
|
writer.Write(DateTime.UtcNow.ToString(DateFormat));
|
|
}
|
|
|
|
writer.WriteLine(line);
|
|
_NewLine = true;
|
|
}
|
|
}
|
|
|
|
public override Encoding Encoding => Encoding.Default;
|
|
}
|
|
|
|
public class MultiTextWriter : TextWriter
|
|
{
|
|
private readonly List<TextWriter> _Streams;
|
|
|
|
public MultiTextWriter(params TextWriter[] streams)
|
|
{
|
|
_Streams = new List<TextWriter>(streams);
|
|
|
|
if (_Streams.Count < 0)
|
|
{
|
|
throw new ArgumentException("You must specify at least one stream.");
|
|
}
|
|
}
|
|
|
|
public void Add(TextWriter tw)
|
|
{
|
|
_Streams.Add(tw);
|
|
}
|
|
|
|
public void Remove(TextWriter tw)
|
|
{
|
|
_Streams.Remove(tw);
|
|
}
|
|
|
|
public override void Write(char ch)
|
|
{
|
|
foreach (var t in _Streams)
|
|
{
|
|
t.Write(ch);
|
|
}
|
|
}
|
|
|
|
public override void WriteLine(string line)
|
|
{
|
|
foreach (var t in _Streams)
|
|
{
|
|
t.WriteLine(line);
|
|
}
|
|
}
|
|
|
|
public override void WriteLine(string line, params object[] args)
|
|
{
|
|
WriteLine(String.Format(line, args));
|
|
}
|
|
|
|
public override Encoding Encoding => Encoding.Default;
|
|
}
|
|
}
|