static void Main(string[] args)
{
PreparationProcess.Run();
Memory.Run(PreparationProcess.Handle.Id);
var threadManager = new ThreadManager();
threadManager.Add(OffsetReader.Run);
threadManager.Add(ConfigReader.Run);
threadManager.Add(Aimbot.Run);
threadManager.Add(Triggerbot.Run);
threadManager.Add(WallBeeper.Run);
//threadManager.Add(DefuseScanner.Run);
//threadManager.Add(BombTimeScanner.Run);
threadManager.StartAll();
}
private static void Main(string[] args)
{
CommandHandler.Setup();
ThreadManager.Add(new ThreadFunction("CommandHandler", CommandHandler.Worker));
ThreadManager.Add(new ThreadFunction("DrawingLoop", DrawingLoop));
//ThreadManager.Add(new ThreadFunction("Collector", Collector));
AttachToGame();
}
private static void Main(string[] args)
{
CommandHandler.Setup();
ThreadManager.Add(new ThreadFunction("CommandHandler", CommandHandler.Worker));
ThreadManager.Add(new ThreadFunction("AttachToGame", AttachToGame));
ThreadManager.Add(new ThreadFunction("Example", Example));
ThreadManager.Run("AttachToGame");
}
private static void Main(string[] args)
{
CommandHandler.Setup();
ThreadManager.Add(new ThreadFunction("CommandHandler", CommandHandler.Worker));
ThreadManager.Add(new ThreadFunction("MainLoop", MainLoop));
ThreadManager.Add(new ThreadFunction("MiscLoop", MiscLoop));
ThreadManager.Add(new ThreadFunction("AimbotLoop", AimbotLoop));
ThreadManager.Add(new ThreadFunction("SoundESPLoop", SoundESPLoop));
ThreadManager.Add(new ThreadFunction("DrawingLoop", DrawingLoop));
ThreadManager.Add(new ThreadFunction("GetMapLoop", GetMapLoop));
AttachToGame();
}
public int LaunchSuspended(string server, IDebugPort2 port, string exe, string args, string directory, string environment, string options, enum_LAUNCH_FLAGS launchFlags, uint standardInput, uint standardOutput, uint standardError, IDebugEventCallback2 callback, out IDebugProcess2 process)
{
waiter = new AutoResetEvent(false);
settings = MonoDebuggerSettings.Parse(options);
Task.Run(() =>
{
var outputWindow = (IVsOutputWindow)Microsoft.VisualStudio.Shell.Package.GetGlobalService(typeof(SVsOutputWindow));
var generalPaneGuid = VSConstants.GUID_OutWindowDebugPane;
outputWindow.GetPane(ref generalPaneGuid, out this.outputWindow);
// Upload the contents of the output folder to the target directory
if (connection == null)
{
connection = ConnectionManager.Get(settings);
if (!connection.IsConnected)
{
Log("Connecting SSH and SFTP...");
// Debugger.Launch();
connection.Connect();
Log("Connected");
}
}
Log("Uploading program...");
// Ensure target directory exists:
var targetDirectories = directory.Split('/');
foreach (var part in targetDirectories)
{
if (!connection.Sftp.Exists(part))
{
connection.Sftp.CreateDirectory(part);
}
connection.Sftp.ChangeDirectory(part);
}
foreach (var _ in targetDirectories)
{
connection.Sftp.ChangeDirectory("..");
}
var outputDirectory = new DirectoryInfo(Path.GetDirectoryName(exe));
foreach (var file in outputDirectory.EnumerateFiles().Where(x => x.Extension == ".dll" || x.Extension == ".mdb" || x.Extension == ".exe"))
{
using (var stream = file.OpenRead())
{
connection.Sftp.UploadFile(stream, $"{directory}/{file.Name}", true);
}
Log($"Uploaded {file.FullName}");
}
Log("Done");
var targetExe = directory + "/" + Path.GetFileName(exe);
connection.Ssh.RunCommand("cd ~");
Log("Launching application");
var commandText = $"mono --debug=mdb-optimizations --debugger-agent=transport=dt_socket,address=0.0.0.0:6438,server=y {targetExe}";
connection.Ssh.RunCommand("kill $(ps auxww | grep '" + commandText + "' | awk '{print $2}')", this.outputWindow, null);
runCommand = connection.Ssh.BeginCommand(commandText, this.outputWindow, out runCommandAsyncResult);
// Trigger that the app is now running for whomever might be waiting for that signal
waiter.Set();
});
Session = new SoftDebuggerSession();
Session.TargetReady += (sender, eventArgs) =>
{
var activeThread = Session.ActiveThread;
ThreadManager.Add(activeThread, new MonoThread(this, activeThread));
// Session.Stop();
};
Session.ExceptionHandler = exception => true;
Session.TargetExited += (sender, x) =>
{
// runCommand.EndExecute(runCommandAsyncResult);
Send(new MonoProgramDestroyEvent((uint?)x.ExitCode ?? 0), MonoProgramDestroyEvent.IID, null);
};
Session.TargetUnhandledException += (sender, x) =>
{
Send(new MonoExceptionEvent(x.Backtrace.GetFrame(0))
{
IsUnhandled = true
}, MonoExceptionEvent.IID, ThreadManager[x.Thread]);
};
Session.LogWriter = (stderr, text) => Console.WriteLine(text);
Session.OutputWriter = (stderr, text) => Console.WriteLine(text);
Session.TargetThreadStarted += (sender, x) => ThreadManager.Add(x.Thread, new MonoThread(this, x.Thread));
Session.TargetThreadStopped += (sender, x) =>
{
ThreadManager.Remove(x.Thread);
};
Session.TargetStopped += (sender, x) => Console.WriteLine(x.Type);
Session.TargetStarted += (sender, x) => Console.WriteLine();
Session.TargetSignaled += (sender, x) => Console.WriteLine(x.Type);
Session.TargetInterrupted += (sender, x) => Console.WriteLine(x.Type);
Session.TargetExceptionThrown += (sender, x) =>
{
Send(new MonoExceptionEvent(x.Backtrace.GetFrame(0)), MonoExceptionEvent.IID, ThreadManager[x.Thread]);
};
Session.TargetHitBreakpoint += (sender, x) =>
{
var breakpoint = x.BreakEvent as Breakpoint;
var pendingBreakpoint = breakpointManager[breakpoint];
Send(new MonoBreakpointEvent(new MonoBoundBreakpointsEnum(pendingBreakpoint.BoundBreakpoints)), MonoBreakpointEvent.IID, ThreadManager[x.Thread]);
};
processId = new AD_PROCESS_ID();
processId.ProcessIdType = (uint)enum_AD_PROCESS_ID.AD_PROCESS_ID_GUID;
processId.guidProcessId = Guid.NewGuid();
EngineUtils.CheckOk(port.GetProcess(processId, out process));
Callback = callback;
return(VSConstants.S_OK);
}
private static int OpenPoseTutorialThread3()
{
try
{
OpenPose.Log("Starting OpenPose demo...", Priority.High);
var timeBegin = new Stopwatch();
timeBegin.Start();
// ------------------------- INITIALIZATION -------------------------
// Step 1 - Set logging level
// - 0 will output all the logging messages
// - 255 will output nothing
OpenPose.Check(0 <= Flags.LoggingLevel && Flags.LoggingLevel <= 255, "Wrong logging_level value.");
ConfigureLog.PriorityThreshold = (Priority)Flags.LoggingLevel;
// Step 2 - Setting thread workers && manage
using (var threadManager = new ThreadManager <Datum>())
{
// Step 3 - Initializing the worker classes
// Frames producer (e.g., video, webcam, ...)
using (var wUserInput = new StdSharedPtr <UserWorkerProducer <Datum> >(new WUserInput(Flags.ImageDir)))
{
// Processing
using (var wUserProcessing = new StdSharedPtr <UserWorker <Datum> >(new WUserPostProcessing()))
{
// GUI (Display)
using (var wUserOutput = new StdSharedPtr <UserWorkerConsumer <Datum> >(new WUserOutput()))
{
// ------------------------- CONFIGURING THREADING -------------------------
// In this simple multi-thread example, we will do the following:
// 3 (virtual) queues: 0, 1, 2
// 1 real queue: 1. The first and last queue ids (in this case 0 and 2) are not actual queues, but the
// beginning and end of the processing sequence
// 2 threads: 0, 1
// wUserInput will generate frames (there is no real queue 0) and push them on queue 1
// wGui will pop frames from queue 1 and process them (there is no real queue 2)
var threadId = 0UL;
var queueIn = 0UL;
var queueOut = 1UL;
threadManager.Add(threadId++, wUserInput, queueIn++, queueOut++); // Thread 0, queues 0 -> 1
threadManager.Add(threadId++, wUserProcessing, queueIn++, queueOut++); // Thread 1, queues 1 -> 2
threadManager.Add(threadId++, wUserOutput, queueIn++, queueOut++); // Thread 2, queues 2 -> 3
// ------------------------- STARTING AND STOPPING THREADING -------------------------
OpenPose.Log("Starting thread(s)...", Priority.High);
// Two different ways of running the program on multithread environment
// Option a) Using the main thread (this thread) for processing (it saves 1 thread, recommended)
threadManager.Exec();
// Option b) Giving to the user the control of this thread
// // VERY IMPORTANT NOTE: if OpenCV is compiled with Qt support, this option will not work. Qt needs the main
// // thread to plot visual results, so the final GUI (which uses OpenCV) would return an exception similar to:
// // `QMetaMethod::invoke: Unable to invoke methods with return values in queued connections`
// // Start threads
// threadManager.start();
// // Keep program alive while running threads. Here the user could perform any other desired function
// while (threadManager.isRunning())
// std::this_thread::sleep_for(std::chrono::milliseconds{33});
// // Stop and join threads
// op::log("Stopping thread(s)", op::Priority::High);
// threadManager.stop();
}
}
}
}
// ------------------------- CLOSING -------------------------
// Measuring total time
timeBegin.Stop();
var totalTimeSec = timeBegin.ElapsedMilliseconds / 1000d;
var message = $"OpenPose demo successfully finished. Total time: {totalTimeSec} seconds.";
OpenPose.Log(message, Priority.High);
// Return successful message
return(0);
}
catch (Exception e)
{
OpenPose.Error(e.Message, -1, nameof(OpenPoseTutorialThread3));
return(-1);
}
}
private static int TutorialDeveloperThread1()
{
try
{
OpenPose.Log("Starting OpenPose demo...", Priority.High);
var timeBegin = new Stopwatch();
timeBegin.Start();
// ------------------------- INITIALIZATION -------------------------
// Step 1 - Set logging level
// - 0 will output all the logging messages
// - 255 will output nothing
OpenPose.Check(0 <= Flags.LoggingLevel && Flags.LoggingLevel <= 255, "Wrong logging_level value.");
ConfigureLog.PriorityThreshold = (Priority)Flags.LoggingLevel;
// Step 2 - Read GFlags (user defined configuration)
// cameraSize
var cameraSize = OpenPose.FlagsToPoint(Flags.CameraResolution, "-1x-1");
// outputSize
var outputSize = OpenPose.FlagsToPoint(Flags.OutputResolution, "-1x-1");
// producerType
var tie = OpenPose.FlagsToProducer(Flags.ImageDir, Flags.Video, Flags.IpCamera, Flags.Camera, Flags.FlirCamera, Flags.FlirCameraIndex);
var producerType = tie.Item1;
var producerString = tie.Item2;
var displayProducerFpsMode = Flags.ProcessRealTime ? ProducerFpsMode.OriginalFps : ProducerFpsMode.RetrievalFps;
using (var producerSharedPtr = OpenPose.CreateProducer(producerType,
cameraSize,
producerString,
Flags.CameraParameterPath,
Flags.FrameUndistort,
Flags.Views3D))
{
producerSharedPtr.Get().SetProducerFpsMode(displayProducerFpsMode);
OpenPose.Log("", Priority.Low);
// Step 3 - Setting producer
//var videoSeekSharedPtr = std::make_shared<std::pair<std::atomic<bool>, std::atomic<int>>>();
//videoSeekSharedPtr->first = false;
//videoSeekSharedPtr->second = 0;
// Step 4 - Setting thread workers && manager
// Note:
// nativeDebugging may occur crash
using (var threadManager = new ThreadManager <Datum>())
{
// Step 5 - Initializing the worker classes
// Frames producer (e.g., video, webcam, ...)
using (var datumProducer = new StdSharedPtr <DatumProducer <Datum> >(new DatumProducer <Datum>(producerSharedPtr)))
using (var wDatumProducer = new StdSharedPtr <WDatumProducer <Datum> >(new WDatumProducer <Datum>(datumProducer)))
{
// GUI (Display)
using (var gui = new StdSharedPtr <Gui>(new Gui(outputSize, Flags.FullScreen, threadManager.GetIsRunningSharedPtr())))
using (var wGui = new StdSharedPtr <WGui <Datum> >(new WGui <Datum>(gui)))
{
// ------------------------- CONFIGURING THREADING -------------------------
// In this simple multi-thread example, we will do the following:
// 3 (virtual) queues: 0, 1, 2
// 1 real queue: 1. The first and last queue ids (in this case 0 and 2) are not actual queues, but the
// beginning and end of the processing sequence
// 2 threads: 0, 1
// wDatumProducer will generate frames (there is no real queue 0) and push them on queue 1
// wGui will pop frames from queue 1 and process them (there is no real queue 2)
var threadId = 0UL;
var queueIn = 0UL;
var queueOut = 1UL;
threadManager.Add(threadId++, wDatumProducer, queueIn++, queueOut++); // Thread 0, queues 0 -> 1
threadManager.Add(threadId++, wGui, queueIn++, queueOut++); // Thread 1, queues 1 -> 2
// Equivalent single-thread version (option a)
// const auto threadId = 0ull;
// auto queueIn = 0ull;
// auto queueOut = 1ull;
// threadManager.add(threadId, wDatumProducer, queueIn++, queueOut++); // Thread 0, queues 0 -> 1
// threadManager.add(threadId, wGui, queueIn++, queueOut++); // Thread 0, queues 1 -> 2
// Equivalent single-thread version (option b)
// const auto threadId = 0ull;
// const auto queueIn = 0ull;
// const auto queueOut = 1ull;
// threadManager.add(threadId, {wDatumProducer, wGui}, queueIn, queueOut); // Thread 0, queues 0 -> 1
// ------------------------- STARTING AND STOPPING THREADING -------------------------
OpenPose.Log("Starting thread(s)...", Priority.High);
// Two different ways of running the program on multithread environment
// Option a) Using the main thread (this thread) for processing (it saves 1 thread, recommended)
threadManager.Exec();
// Option b) Giving to the user the control of this thread
// // VERY IMPORTANT NOTE: if OpenCV is compiled with Qt support, this option will not work. Qt needs the main
// // thread to plot visual results, so the final GUI (which uses OpenCV) would return an exception similar to:
// // `QMetaMethod::invoke: Unable to invoke methods with return values in queued connections`
// // Start threads
// threadManager.start();
// // Keep program alive while running threads. Here the user could perform any other desired function
// while (threadManager.isRunning())
// std::this_thread::sleep_for(std::chrono::milliseconds{33});
// // Stop and join threads
// op::log("Stopping thread(s)", op::Priority::High);
// threadManager.stop();
}
}
}
}
// ------------------------- CLOSING -------------------------
// Measuring total time
timeBegin.Stop();
var totalTimeSec = timeBegin.ElapsedMilliseconds / 1000d;
var message = $"OpenPose demo successfully finished. Total time: {totalTimeSec} seconds.";
OpenPose.Log(message, Priority.High);
// Return successful message
return(0);
}
catch (Exception e)
{
OpenPose.Error(e.Message, -1, nameof(TutorialDeveloperThread1));
return(-1);
}
}
private static void Main(string[] args)
{
Offsets.FetchOffsets();
Offsets.UpdateOffsets();
Console.Title = Misc.RandomString(64);
Globals.Proc.Process = Extensions.Proc.WaitForProcess(Globals.Proc.Name);
Extensions.Proc.WaitForModules(Globals.Proc.Modules, Globals.Proc.Name);
MemoryManager.Initialize(Globals.Proc.Process.Id);
Globals.Proc.UpdateResolution();
Config.Load();
//Settings.ESP.DebugStrings.Add("Debug String 1");
//Settings.ESP.DebugStrings.Add("Debug String 1");
//Settings.ESP.DebugStrings.Add("Debug String 1");
//Settings.ESP.DebugStrings.Add("Debug String 1");
Extensions.Information("-----------------------------------------------]", true);
Extensions.Information("[TempMessage] Config Save: F4", true);
Extensions.Information("[TempMessage] Config Load: F5", true);
Extensions.Information("-----------------------------------------------]", true);
Extensions.Information("[FEATURE] Toggle Bunnyhop: F6", true);
Extensions.Information("[FEATURE] Toggle Trigger: F7", true);
Extensions.Information("[FEATURE] Toggle Glow: F8", true);
Extensions.Information("[FEATURE] Toggle Radar: F9", true);
Extensions.Information("[FEATURE] Toggle Aimbot: F10", true);
Extensions.Information("[FEATURE] Toggle Chams: F11", true);
Extensions.Information("[FEATURE] Toggle ESP: F3", true);
Extensions.Information("[FEATURE] Toggle FOV Changer: F2", true);
Extensions.Information("[FEATURE] Toggle Standalone RCS: F1", true);
Extensions.Information("[FEATURE] Toggle AutoPistol: <NO KEY YET>", true);
Extensions.Information("[FEATURE] Toggle No_Flash: <NO KEY YET>", true);
Extensions.Information("-----------------------------------------------]", true);
ThreadManager.Add("Watcher", Watcher.Run);
ThreadManager.Add("Reader", Reader.Run);
ThreadManager.Add("Bunnyhop", Bunnyhop.Run);
ThreadManager.Add("Trigger", Trigger.Run);
ThreadManager.Add("Glow", Glow.Run);
ThreadManager.Add("Radar", Radar.Run);
ThreadManager.Add("Aimbot", Aimbot.Run);
ThreadManager.Add("FOVChanger", FOVChanger.Run);
ThreadManager.Add("StandaloneRCS", StandaloneRCS.Run);
ThreadManager.Add("AutoPistol", AutoPistol.Run);
ThreadManager.Add("No_Flash", No_Flash.Run);
ThreadManager.Add("SkinChanger", SkinChanger.Run);
ThreadManager.ToggleThread("Watcher");
ThreadManager.ToggleThread("Reader");
if (Settings.Bunnyhop.Enabled) ThreadManager.ToggleThread("Bunnyhop");
if (Settings.Trigger.Enabled) ThreadManager.ToggleThread("Trigger");
if (Settings.Glow.Enabled) ThreadManager.ToggleThread("Glow");
if (Settings.Radar.Enabled) ThreadManager.ToggleThread("Radar");
if (Settings.Aimbot.Enabled) ThreadManager.ToggleThread("Aimbot");
if (Settings.Chams.Enabled) ThreadManager.ToggleThread("Chams");
if (Settings.FOVChanger.Enabled || Settings.FOVChanger.ViewModelFov.Enabled) ThreadManager.ToggleThread("FOVChanger");
if (Settings.No_Flash.Enabled) ThreadManager.ToggleThread("No_Flash");
if (Settings.StandaloneRCS.Enabled) ThreadManager.ToggleThread("StandaloneRCS");
if (Settings.AutoPistol.Enabled) ThreadManager.ToggleThread("AutoPistol");
if (Settings.SkinChanger.Enabled) ThreadManager.ToggleThread("SkinChanger");
if (ESP == null && Settings.ESP.Enabled)
{
Extensions.Information("[ThreadManager][Started] ESP", true);
ESP = new ESPOverlay(Globals.Proc.Process.MainWindowHandle); // Attach it to CSGO main window handle
ESP.Initialize();
ESP.Run();
}
}
public ProcessManager()
{
ThreadManager threadManager = new ThreadManager();
threadManager.Add("ProcessManager_CheckLive", CheckLive, IsBackGround: true);
}
public int LaunchSuspended(string server, IDebugPort2 port, string exe, string args, string directory, string environment, string options, enum_LAUNCH_FLAGS launchFlags, uint standardInput, uint standardOutput, uint standardError, IDebugEventCallback2 callback, out IDebugProcess2 process)
{
waiter = new AutoResetEvent(false);
settings = MonoDebuggerSettings.Load(options);
Task.Run(() => {
var outputWindow = (IVsOutputWindow)Microsoft.VisualStudio.Shell.Package.GetGlobalService(typeof(SVsOutputWindow));
var generalPaneGuid = VSConstants.GUID_OutWindowDebugPane;
outputWindow.GetPane(ref generalPaneGuid, out this.outputWindow);
settings.Launcher.Launch();
// Trigger that the app is now running for whomever might be waiting for that signal
waiter.Set();
});
Session = new SoftDebuggerSession();
Session.TargetReady += (sender, eventArgs) => {
var activeThread = Session.ActiveThread;
ThreadManager.Add(activeThread, new MonoThread(this, activeThread));
// Session.Stop();
};
Session.ExceptionHandler = exception => true;
Session.TargetExited += (sender, x) => {
// runCommand.EndExecute(runCommandAsyncResult);
Send(new MonoProgramDestroyEvent((uint?)x.ExitCode ?? 0), MonoProgramDestroyEvent.IID, null);
};
Session.TargetUnhandledException += (sender, x) => {
Send(new MonoExceptionEvent(x.Backtrace.GetFrame(0))
{
IsUnhandled = true
}, MonoExceptionEvent.IID, ThreadManager[x.Thread]);
};
Session.LogWriter = (stderr, text) => Console.WriteLine(text);
Session.OutputWriter = (stderr, text) => Console.WriteLine(text);
Session.TargetThreadStarted += (sender, x) => ThreadManager.Add(x.Thread, new MonoThread(this, x.Thread));
Session.TargetThreadStopped += (sender, x) => {
ThreadManager.Remove(x.Thread);
};
Session.TargetStopped += (sender, x) => Console.WriteLine(x.Type);
Session.TargetStarted += (sender, x) => Console.WriteLine();
Session.TargetSignaled += (sender, x) => Console.WriteLine(x.Type);
Session.TargetInterrupted += (sender, x) => Console.WriteLine(x.Type);
Session.TargetExceptionThrown += (sender, x) => {
Send(new MonoExceptionEvent(x.Backtrace.GetFrame(0)), MonoExceptionEvent.IID, ThreadManager[x.Thread]);
};
Session.TargetHitBreakpoint += (sender, x) => {
var breakpoint = x.BreakEvent as Breakpoint;
var pendingBreakpoint = breakpointManager[breakpoint];
Send(new MonoBreakpointEvent(new MonoBoundBreakpointsEnum(pendingBreakpoint.BoundBreakpoints)), MonoBreakpointEvent.IID, ThreadManager[x.Thread]);
};
processId = new AD_PROCESS_ID();
processId.ProcessIdType = (uint)enum_AD_PROCESS_ID.AD_PROCESS_ID_GUID;
processId.guidProcessId = Guid.NewGuid();
EngineUtils.CheckOk(port.GetProcess(processId, out process));
Callback = callback;
return(VSConstants.S_OK);
}
static void Main(string[] args)
{
Console.Title = $"1488";
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("LOOK FOR HL.EXE");
Process[] process = Process.GetProcessesByName("hl");
while (process.Length < 1)
{
process = Process.GetProcessesByName("hl");
Thread.Sleep(250);
}
Globals.Proc.Process = process[0];
Console.WriteLine("PROCCES FOUND!");
List <string> loadedModules = new List <string>(Globals.Proc.Modules.Length);
while (loadedModules.Count < Globals.Proc.Modules.Length)
{
process = Process.GetProcessesByName("hl");
if (process.Length < 1)
{
continue;
}
foreach (ProcessModule module in process[0].Modules)
{
if (Globals.Proc.Modules.Contains(module.ModuleName) && !loadedModules.Contains(module.ModuleName))
{
loadedModules.Add(module.ModuleName);
switch (module.ModuleName)
{
case "client.dll":
Globals.Proc.Client = module.BaseAddress;
break;
case "hw.dll":
Globals.Proc.HW = module.BaseAddress;
break;
default:
break;
}
}
}
Thread.Sleep(250);
}
Console.WriteLine("MODULES FOUND");
Console.Clear();
MemoryManager.Initialize(Globals.Proc.Process.Id);
Console.WriteLine("MEMORY INITIALIZATHION SUCCESFULL");
ThreadManager.Add("Reader", Reader.Run);
ThreadManager.Add("Updater", Updater.Run);
ThreadManager.Add("Trigger", Trigger.Run);
ThreadManager.Add("Air", Air.Run);
ThreadManager.ToggleThread("Reader");
ThreadManager.ToggleThread("Updater");
ThreadManager.ToggleThread("Air");
ThreadManager.ToggleThread("Trigger");
// Application.EnableVisualStyles();
// Application.Run(new DirectX_Renderer.Overlay());
}
static void Main(string[] args)
{
Console.Title = $"Externalio - Build ({ Extensions.AssemblyCreationDate() })";
Globals.Proc.Process = Extensions.Proc.WaitForProcess(Globals.Proc.Name);
Extensions.Proc.WaitForModules(Globals.Proc.Modules, Globals.Proc.Name);
MemoryManager.Initialize(Globals.Proc.Process.Id);
List <string> outdatedSignatures = Offsets.ScanPatterns();
if (outdatedSignatures.Count > 0)
{
foreach (string sig in outdatedSignatures)
{
Extensions.Error($"> Outdated Signature: { sig }", 0, false);
}
Console.ReadKey();
Environment.Exit(0);
}
Config.Load();
/* Temp */
Extensions.Information("---------------------------------------------]", true);
Extensions.Information("[TempMessage] Config Save: F4", true);
Extensions.Information("[TempMessage] Config Load: F5", true);
Extensions.Information("---------------------------------------------]", true);
Extensions.Information("[TempMessage] Toggle Bunnyhop: F6", true);
Extensions.Information("[TempMessage] Toggle Trigger: F7", true);
Extensions.Information("[TempMessage] Toggle Glow: F8", true);
Extensions.Information("[TempMessage] Toggle Radar: F9", true);
Extensions.Information("[TempMessage] Toggle Aimbot: F10", true);
Extensions.Information("[TempMessage] Toggle Chams: F11", true);
Extensions.Information("---------------------------------------------]", true);
ThreadManager.Add("Watcher", Watcher.Run);
ThreadManager.Add("Reader", Reader.Run);
ThreadManager.Add("Bunnyhop", Bunnyhop.Run);
ThreadManager.Add("Trigger", Trigger.Run);
ThreadManager.Add("Glow", Glow.Run);
ThreadManager.Add("Radar", Radar.Run);
ThreadManager.Add("Aimbot", Aimbot.Run);
ThreadManager.Add("Chams", Chams.Run);
ThreadManager.ToggleThread("Watcher");
ThreadManager.ToggleThread("Reader");
if (Settings.Bunnyhop.Enabled)
{
ThreadManager.ToggleThread("Bunnyhop");
}
if (Settings.Trigger.Enabled)
{
ThreadManager.ToggleThread("Trigger");
}
if (Settings.Glow.Enabled)
{
ThreadManager.ToggleThread("Glow");
}
if (Settings.Radar.Enabled)
{
ThreadManager.ToggleThread("Radar");
}
if (Settings.Aimbot.Enabled)
{
ThreadManager.ToggleThread("Aimbot");
}
if (Settings.Chams.Enabled)
{
ThreadManager.ToggleThread("Chams");
}
}