Beispiel #1
0
        public void askChat(CSteamID steamID, byte mode, string text)
        {
            // Set the variables
            bool           cancel = false;
            UnturnedPlayer player = UnturnedPlayer.Get(steamID);

            // Run methods
            ChatEvents.RunChatted(ref player, ref mode, ref text, ref cancel);

            // Do checks
            if (player?.SteamID == null || player.SteamID == CSteamID.Nil)
            {
                return;
            }
            if (string.IsNullOrEmpty(text))
            {
                return;
            }
            if (cancel)
            {
                return;
            }

            // Restore original
            DetourManager.CallOriginal(typeof(CM).GetMethod("askChat", BindingFlags.Public | BindingFlags.Instance), CM.instance, player.SteamID, mode, text);
        }
Beispiel #2
0
 /// <summary>
 /// Creates a new instance of the <see cref="Magic"/> class.
 /// </summary>
 public Magic()
 {
     Process.EnterDebugMode();
     _win32    = new Win32(IntPtr.Zero);
     _detours  = new DetourManager(_win32);
     _patches  = new PatchManager(_win32);
     _patterns = new PatternManager(_win32);
 }
Beispiel #3
0
        /// <summary>
        /// Creates a new instance of the <see cref="ProcessInject"/> class.
        /// </summary>
        public ProcessInject(uint dwDesiredAccess, int dwProcessId)
        {
            Process.EnterDebugMode();
            mWin32    = new Win32(dwDesiredAccess, dwProcessId);
            mDetours  = new DetourManager(mWin32);
            mPatches  = new PatchManager(mWin32);
            mPatterns = new PatternManager(mWin32);

            mInstance = this;
        }
Beispiel #4
0
 public Onyx(Process _targetProcess)
 {
     if (_targetProcess == null)
     {
         throw new ArgumentNullException(nameof(_targetProcess));
     }
     m_targetProcess = _targetProcess;
     m_memory        = new OnyxMemory(_targetProcess.Id);
     m_detours       = new DetourManager();
 }
        public static void askRepair(this Barricade barricade, ushort amount)
        {
            // Set the variables
            bool cancel = false;

            // Run the events
            BarricadeEvents.RunBarricadeRepair(UnturnedBarricade.FindBarricade(barricade), ref amount, ref cancel);

            // Run the original function
            if (!cancel)
            {
                DetourManager.CallOriginal(typeof(Barricade).GetMethod("askRepair", BindingFlags.Instance | BindingFlags.Public), barricade, amount);
            }
        }
Beispiel #6
0
        public static void askRepair(this Structure stru, ushort amount)
        {
            // Set the events
            bool cancel = false;

            // Run the events
            StructureEvents.RunRepairStructure(UnturnedStructure.FindStructure(stru), ref amount, ref cancel);

            // Run the original function
            if (!cancel)
            {
                DetourManager.CallOriginal(typeof(Structure).GetMethod("askRepair", BindingFlags.Instance | BindingFlags.Public), stru, amount);
            }
        }
        public static void askRepair(this InteractableVehicle Vehicle, ushort amount)
        {
            if (amount == 0 || Vehicle.isExploded)
            {
                return;
            }

            UnturnedVehicle vehicle = UnturnedServer.Vehicles.FirstOrDefault(v => v.InstanceID == Vehicle.instanceID);

            VehicleEvents.RunVehicleRepair(vehicle, amount);

            DetourManager.CallOriginal(typeof(InteractableVehicle).GetMethod("askRepair", BindingFlags.Public | BindingFlags.Instance),
                                       Vehicle, amount);
        }
Beispiel #8
0
        public void tellVehicleDestroy(CSteamID steamID, uint instanceID)
        {
            if (VehicleManager.instance.channel.checkServer(steamID))
            {
                InteractableVehicle vehicle = VehicleManager.vehicles.FirstOrDefault(a => a.instanceID == instanceID);

                if (vehicle == null)
                {
                    return;
                }

                ServerEvents.RunVehicleRemoved(vehicle);
            }

            DetourManager.CallOriginal(typeof(VehicleManager).GetMethod("tellVehicleDestroy", BindingFlags.Instance | BindingFlags.Public), VehicleManager.instance, steamID, instanceID);
        }
Beispiel #9
0
        public void askSalvageBarricade(CSteamID steamID, byte x, byte y, ushort plant, ushort index)
        {
            BarricadeRegion barricadeRegion;
            bool            cancel = false;

            if (BarricadeManager.tryGetRegion(x, y, plant, out barricadeRegion))
            {
                BarricadeData data = barricadeRegion.barricades[(int)index];

                BarricadeEvents.RunBarricadeSalvage(UnturnedBarricade.Create(data), ref cancel);
            }

            if (!cancel)
            {
                DetourManager.CallOriginal(typeof(BarricadeManager).GetMethod("askSalvageBarricade", BindingFlags.Public | BindingFlags.Instance), BarricadeManager.instance, steamID, x, y, plant, index);
            }
        }
        public void askSalvageStructure(CSteamID steamID, byte x, byte y, ushort index)
        {
            StructureRegion structureRegion;
            bool            cancel = false;

            if (StructureManager.tryGetRegion(x, y, out structureRegion))
            {
                StructureData data = structureRegion.structures[(int)index];

                StructureEvents.RunSalvageStructure(UnturnedStructure.Create(data), ref cancel);
            }

            if (!cancel)
            {
                DetourManager.CallOriginal(typeof(StructureManager).GetMethod("askSalvageStructure", BindingFlags.Instance | BindingFlags.Public), StructureManager.instance, steamID, x, y, index);
            }
        }
        public static void askDamageTire(this InteractableVehicle Vehicle, int index)
        {
            if (index < 0)
            {
                return;
            }

            if (Vehicle.asset != null && !Vehicle.asset.canTiresBeDamaged)
            {
                return;
            }

            UnturnedVehicle UVehicle = UnturnedServer.Vehicles.FirstOrDefault(vehicle => vehicle.InstanceID == Vehicle.instanceID);

            VehicleEvents.RunVehicleTireDamage(UVehicle, index);

            DetourManager.CallOriginal(typeof(InteractableVehicle).GetMethod("askDamageTire", BindingFlags.Public | BindingFlags.Instance), Vehicle, index);
        }
Beispiel #12
0
        private static void doDamage(this PlayerLife life, byte amount, Vector3 newRagdoll, EDeathCause newCause, ELimb newLimb, CSteamID newKiller, out EPlayerKill kill)
        {
            UnturnedPlayer ply    = UnturnedPlayer.Get(newKiller);
            bool           cancel = false;

            kill = EPlayerKill.NONE;

            PlayerEvents.RunPlayerHurt(life.channel.owner, ref amount, ref newCause, ref newLimb, ref ply, ref cancel);

            if (cancel)
            {
                return;
            }

            object[] paramaters = new object[] { amount, newRagdoll, newCause, newLimb, newKiller, null };
            DetourManager.CallOriginal(typeof(PlayerLife).GetMethod("doDamage", BindingFlags.NonPublic | BindingFlags.Instance), life, paramaters);
            kill = (EPlayerKill)paramaters[5];
        }
        public static void tellSkill(this PlayerSkills Skills, CSteamID steamID, byte speciality, byte index, byte level)
        {
            if (!Skills.channel.checkServer(steamID))
            {
                return;
            }
            if (index >= Skills.skills[speciality].Length)
            {
                return;
            }

            UnturnedPlayer Player = UnturnedPlayer.Get(Skills.player);

            PlayerEvents.RunPlayerSkillUpgrade(Player, speciality, index, level);

            DetourManager.CallOriginal(typeof(PlayerSkills).GetMethod("tellSkill", BindingFlags.Instance | BindingFlags.Public),
                                       Skills, steamID, speciality, index, level);
        }
Beispiel #14
0
        private void Start()
        {
            foreach (Type _class in Assembly.GetExecutingAssembly().GetTypes())
            {
                if (!_class.IsClass)
                {
                    continue;
                }

                // Service and menu checks
                if (MenuManager.IsMenu(_class))
                {
                    MenuManager.LoadClass(_class);
                }
                else if (ServiceManager.IsService(_class))
                {
                    IService service = ServiceManager.LoadClass(_class);

                    ServiceManager.Start(service);
                }

                // Detour checks
                foreach (MethodInfo method in _class.GetMethods(BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
                {
                    DetourAttribute detour = (DetourAttribute)Attribute.GetCustomAttribute(method, typeof(DetourAttribute));
                    if (detour != null)
                    {
                        if (detour.Modified == null)
                        {
                            detour.Modified = method;
                        }

                        DetourManager.Detour(detour.Original, detour.Modified);
                    }
                }
            }

            _ticker = new Thread(new ThreadStart(Tick));
            _ticker.Start();
        }
Beispiel #15
0
        public void tellExitVehicle(CSteamID steamID, uint instanceID, byte seat, Vector3 point, byte angle, bool forceUpdate)
        {
            if (!VehicleManager.instance.channel.checkServer(steamID))
            {
                return;
            }

            for (int i = 0; i < VehicleManager.vehicles.Count; i++)
            {
                if (VehicleManager.vehicles[i].instanceID != instanceID)
                {
                    continue;
                }

                UnturnedVehicle Vehicle = UnturnedServer.Vehicles.FirstOrDefault(vehicle => vehicle.InstanceID == instanceID);

                VehicleEvents.RunVehicleExit(Vehicle, seat, point, angle, forceUpdate);

                break;
            }

            DetourManager.CallOriginal(typeof(VehicleManager).GetMethod("tellExitVehicle", BindingFlags.Public | BindingFlags.Instance),
                                       VehicleManager.instance, steamID, instanceID, seat, point, angle, forceUpdate);
        }
Beispiel #16
0
 /// <summary>
 ///     Initializes a new instance of the <see cref="MemoryPlus" /> class.
 /// </summary>
 /// <param name="proc">The process.</param>
 /// <remarks>
 ///     Created 2012-02-15
 /// </remarks>
 public MemoryPlus(Process proc) : base(proc)
 {
     Factories.Add(Detours = new DetourManager(this));
     Factories.Add(Hooks   = new HookManager());
 }
        public static void init(this InteractableVehicle vehicle)
        {
            ServerEvents.RunVehicleCreated(vehicle);

            DetourManager.CallOriginal(typeof(InteractableVehicle).GetMethod("init"), vehicle, new object[0]);
        }