Mensajes

[Rasdial]

Una vez hice un VPN, usando servidores publicos. para conectarme use una API llamada Rasdial .

acerca de la API de Mega , ni idea , nunca la he usado.

[HLPCE es un lanzador y navegador de servidores para Halo CE y PC.]

HLPCE es un lanzador y navegador de servidores para Halo CE y PC.

Puede configurar las opciones del argumento.

Puedes poner tus fotos de fondo, solo tienes que poner tus imágenes en la carpeta "Background".



Caracteristicas :

• Navegador del servidor | Usando la API de GameTracker
• Sistema de invitación al servidor.
• ¡Noticias y actualizaciones del sistema!
• Información completa del servidor.
• Sistema de lista de servidores favoritos.
• Importar y explorar la lista de servidores.
• Interfaz súper moderna y agradable, personalizable con imágenes de fondo que decidas poner.
• Windowed Mode[modo de ventana]
• FullScreen Mode [Modo de pantalla completa]
• Fake FullScreen [Modo falso de pantalla completa] - [Te permite superponer otras aplicaciones [que tienen activa la propiedad TopMost] en la parte superior del juego]
• Consola habilitada
• Capturas de pantalla habilitadas
• DevMode
• Sin Gamma
• Sin sonido
• No hay video
• Sin joystick
• Modo seguro
• Es muy, muy ligero.

Puedes Descargar la Aplicacion y Si quieren mas Info visiten el repositorio :

Descargar : http://www.mediafire.com/file/bqkix7s1fzxwpvp/HLPCEv1.0.3.zip/file

Imagenes :

Porfavor Comentar ! gracias  

tengo una pc de bajos recursos un procesador i3 de 4ta generacion 8gb de ram y 2gb de video gddr5 gt 710 nvidia uso windows 7 me iria bien el windows 10?

jajajaja bajos recursos? . alv entonces donde quedo yo ? con mi PC  , Procesador Intel Pentium 4 , 1gb de ram . sin grafica, ni tarjeta de red.

Bueno Felicidades. Esperare el post de cuando rompan , nada es infinito (sig eterno), excepto tal vez la estupidez humana. dijo el albert!  

[Para trabajar tienes que declarar una nueva instancia. Te explico con codigo vb.net.]

hola a migos buen dia, hoy les traigo una inquietud y es que no encuentro como hacer funcionar este codigo.

Código [Seleccionar] Expandir

string ruta = Environment.CurrentDirectory + "\\" + "r.rar";
           RarArchive archive = RarArchive.Open(ruta);

           foreach (RarArchiveEntry item in archive.Entries)
           {
               string path = Path.Combine(Path.GetFileName(item.FilePath));
               item.WriteToFile(path);
           }

el error que me arroja es:

System.NullReferenceException: 'Referencia a objeto no establecida como instancia de un objeto.' (Eto ocurre al entrar al foreach en la instancia archive.Entries)

Es obio, el error esta en esta declaracion :

Código [Seleccionar] Expandir

RarArchive archive = RarArchive.Open(ruta);

Para trabajar tienes que declarar una nueva instancia. Te explico con codigo vb.net.




Basicamente declaras una nueva instancia de RarArchive , usando (new) , quedaria asi :

Código (vbnet) [Seleccionar] Expandir

  Dim ruta As String = Environment.CurrentDirectory & "\" & "r.rar"

   Dim archiveInstance As new RarArchive
    Dim archive = archiveInstance.Open(ruta)

   For Each item As RarArchiveEntry In archive.Entries
       Dim path As String = Path.Combine(Path.GetFileName(item.FilePath))
       item.WriteToFile(path)
   Next

No se que tipo devuelve .Open(ruta) en caso de que sea string. ponedlo en la variable archive.



Asi quedaria tu code :

Código [Seleccionar] Expandir

{
   string ruta = Environment.CurrentDirectory + @"\" + "r.rar";

   RarArchive archiveInstance = new RarArchive();
   var archive = archiveInstance.Open(ruta);

   foreach (RarArchiveEntry item in archive.Entries)
   {
       string path = Path.Combine(Path.GetFileName(item.FilePath));
       item.WriteToFile(path);
   }
}

[Desktop Organizer]

Hola, Bueno hoy hago este post para compartir . publicitar mi aplicacion.

Siempre descargo cosas y muchas veces termino llenando mi escritorio. por eso cree Desktop Organizer.

Introducion :  


En Windows, un escritorio desordenado puede ser agotador y destruir la productividad. A menudo, la mayoría de los usuarios llenan sus escritorios con toneladas de aplicaciones descargadas y archivos creados por ellos mismos hasta que la pantalla se convierte en una especie de vertedero lleno de iconos que apenas permiten ver la imagen de fondo. Con Desktop Organizer, puede organizar su escritorio instantáneamente con un solo click.


Además de limpiar el escritorio, Desktop Organizer también proporciona varias herramientas para ayudarle a trabajar de forma más inteligente.

Si tienen Ideas de que tipo de Herramienta / mejora , hacerle , Comenten .

[Pantalla Completa]

Hola , A todos. Algunos ya sabran que es Imposible Superponer tu Aplicación sobre un Juego que trabaja con Direcx y que esta en Pantalla Completa.

Bien Empecemos !



Introduccion :

     Es un Problema muy Común que cuando algún Programador en .Net , (Que haga Cheats) para juegos.
     Cuando quiera superponer su Applicacion sobre el juego en pantalla completa no lo logre. ya que basicamente El Juego "Secuestra la pantalla".

     En este caso , hago este Post , para Compartir "Mi" solución a este Problema.


     Cabe Resaltar que :

     

•      Los Juegos que Usan Como motor OPENGL, No tienen este Problema. Se puede superponer facilmente otra Applicacion sobre ellos.
•      No todos Los juegos Direcx tienen este Problema, Por Ejemplo Operation7, WolfTeam, Swat4 ,Entre Otros...
•      La mayoría de Juegos creados con Unity Tampoco tienen este Problema.

     Entonces Empecemos...



    Primero que todo Mi solución no fue Intentar Forzar de alguna manera la superposición. ya que no lo logre.

     Quiero resaltar que hay un método que funciona, pero No muy Practico a mi parecer. Basicamente tienes que Conectar con EndScene .

     Basicamente usando SlimDX y EasyHook, Aca un Breve tutorial : [Tutorial] How to become an EndScene() hooker

     Por que no es muy Practico? , No lo es ya que Este metodo es facilmente Detectado por los AC (Anti-Cheats).




Solución :

     Bien mi Método , Fue una Solucion facil , Si no puedo Superponer sobre un Juego en pantalla Completa. Entonces :

     - EMULARE EL MODO PANTALLA COMPLETA.

     Básicamente Hacemos esto :


     1) Corremos Nuestro Juego en modo ventana, Algunos traen la opción en el Apartado de Configuración - Video.

     En caso de que No traiga esta Opción , Tienes que Crear un Acceso Directo, Abrir las Propiedades del Acceso Directo y Colocar al final el Parámetro : "-window"
     De todos modos aquí dejo un Tutorial Sobre esto : Play a Computer Game in Windowed Mode

     2) Emulamos / Forzamos El modo FullScreen. Para Ello Hacemos :


      Paso 1 : Agregamos a Su Proyecto Las Clases SetWindowStyle.vb y SetWindowState.vb.


SetWindowStyle.vb

Código (vbnet) [Seleccionar] Expandir

' ***********************************************************************
' Author           : Destroyer
' Last Modified On : 29-09-2020
' ***********************************************************************
' <copyright file="SetWindowStyle.vb" company="Elektro Studios">
'     Copyright (c) All rights reserved.
' </copyright>
' ***********************************************************************

#Region " Usage Examples "

'Dim HWND As IntPtr = Process.GetProcessesByName("devenv").First.MainWindowHandle
'
'SetWindowState.SetWindowStyle(HWND, SetWindowStyle.WindowStyles.WS_BORDER)
'SetWindowState.SetWindowStyle("devenv", SetWindowStyle.WindowStyles.WS_BORDER, Recursivity:=False)

#End Region

#Region " Imports "

Imports System.Runtime.InteropServices

#End Region

''' <summary>
''' Sets the style of a window.
''' </summary>
Public NotInheritable Class SetWindowStyle

#Region " P/Invoke "

    ''' <summary>
    ''' Platform Invocation methods (P/Invoke), access unmanaged code.
    ''' This class does not suppress stack walks for unmanaged code permission.
    ''' <see cref="System.Security.SuppressUnmanagedCodeSecurityAttribute"/>  must not be applied to this class.
    ''' This class is for methods that can be used anywhere because a stack walk will be performed.
    ''' MSDN Documentation: http://msdn.microsoft.com/en-us/library/ms182161.aspx
    ''' </summary>
    Protected NotInheritable Class NativeMethods

#Region " Methods "

        ''' <summary>
        ''' Retrieves a handle to the top-level window whose class name and window name match the specified strings.
        ''' This function does not search child windows.
        ''' This function does not perform a case-sensitive search.
        ''' To search child windows, beginning with a specified child window, use the FindWindowEx function.
        ''' MSDN Documentation: http://msdn.microsoft.com/en-us/library/windows/desktop/ms633499%28v=vs.85%29.aspx
        ''' </summary>
        ''' <param name="lpClassName">The class name.
        ''' If this parameter is NULL, it finds any window whose title matches the lpWindowName parameter.</param>
        ''' <param name="lpWindowName">The window name (the window's title).
        ''' If this parameter is NULL, all window names match.</param>
        ''' <returns>If the function succeeds, the return value is a handle to the window that has the specified class name and window name.
        ''' If the function fails, the return value is NULL.</returns>
        <DllImport("user32.dll", SetLastError:=False, CharSet:=CharSet.Auto, BestFitMapping:=False)>
        Friend Shared Function FindWindow(
           ByVal lpClassName As String,
           ByVal lpWindowName As String
        ) As IntPtr
        End Function

        ''' <summary>
        ''' Retrieves a handle to a window whose class name and window name match the specified strings.
        ''' The function searches child windows, beginning with the one following the specified child window.
        ''' This function does not perform a case-sensitive search.
        ''' MSDN Documentation: http://msdn.microsoft.com/en-us/library/windows/desktop/ms633500%28v=vs.85%29.aspx
        ''' </summary>
        ''' <param name="hwndParent">
        ''' A handle to the parent window whose child windows are to be searched.
        ''' If hwndParent is NULL, the function uses the desktop window as the parent window.
        ''' The function searches among windows that are child windows of the desktop.
        ''' </param>
        ''' <param name="hwndChildAfter">
        ''' A handle to a child window.
        ''' The search begins with the next child window in the Z order.
        ''' The child window must be a direct child window of hwndParent, not just a descendant window.
        ''' If hwndChildAfter is NULL, the search begins with the first child window of hwndParent.
        ''' </param>
        ''' <param name="strClassName">
        ''' The window class name.
        ''' </param>
        ''' <param name="strWindowName">
        ''' The window name (the window's title).
        ''' If this parameter is NULL, all window names match.
        ''' </param>
        ''' <returns>
        ''' If the function succeeds, the return value is a handle to the window that has the specified class and window names.
        ''' If the function fails, the return value is NULL.
        ''' </returns>
        <DllImport("User32.dll", SetLastError:=False, CharSet:=CharSet.Auto, BestFitMapping:=False)>
        Friend Shared Function FindWindowEx(
           ByVal hwndParent As IntPtr,
           ByVal hwndChildAfter As IntPtr,
           ByVal strClassName As String,
           ByVal strWindowName As String
        ) As IntPtr
        End Function

        ''' <summary>
        ''' Retrieves the identifier of the thread that created the specified window
        ''' and, optionally, the identifier of the process that created the window.
        ''' MSDN Documentation: http://msdn.microsoft.com/en-us/library/windows/desktop/ms633522%28v=vs.85%29.aspx
        ''' </summary>
        ''' <param name="hWnd">A handle to the window.</param>
        ''' <param name="ProcessId">
        ''' A pointer to a variable that receives the process identifier.
        ''' If this parameter is not NULL, GetWindowThreadProcessId copies the identifier of the process to the variable;
        ''' otherwise, it does not.
        ''' </param>
        ''' <returns>The identifier of the thread that created the window.</returns>
        <DllImport("user32.dll")>
        Friend Shared Function GetWindowThreadProcessId(
            ByVal hWnd As IntPtr,
            ByRef ProcessId As Integer
        ) As Integer
        End Function

        <System.Runtime.InteropServices.DllImport("user32.dll", EntryPoint:="SetWindowLong")> _
        Friend Shared Function SetWindowLong32(ByVal hWnd As IntPtr, <MarshalAs(UnmanagedType.I4)> nIndex As WindowLongFlags, ByVal dwNewLong As Integer) As Integer
        End Function

        <System.Runtime.InteropServices.DllImport("user32.dll", EntryPoint:="SetWindowLongPtr")> _
        Friend Shared Function SetWindowLongPtr64(ByVal hWnd As IntPtr, <MarshalAs(UnmanagedType.I4)> nIndex As WindowLongFlags, ByVal dwNewLong As IntPtr) As IntPtr
        End Function

        Friend Shared Function SetWindowLongPtr(ByVal hWnd As IntPtr, nIndex As WindowLongFlags, ByVal dwNewLong As IntPtr) As IntPtr
            If IntPtr.Size = 8 Then
                Return SetWindowLongPtr64(hWnd, nIndex, dwNewLong)
            Else
                Return New IntPtr(SetWindowLong32(hWnd, nIndex, dwNewLong.ToInt32))
            End If
        End Function

#End Region

    End Class

#End Region

#Region " Enumerations "

    Public Enum WindowLongFlags As Integer
        GWL_EXSTYLE = -20
        GWLP_HINSTANCE = -6
        GWLP_HWNDPARENT = -8
        GWL_ID = -12
        GWL_STYLE = -16
        GWL_USERDATA = -21
        GWL_WNDPROC = -4
        DWLP_USER = &H8
        DWLP_MSGRESULT = &H0
        DWLP_DLGPROC = &H4
    End Enum

   <FlagsAttribute()> _
  Public Enum WindowStyles As Long

        Todo1 = 2
        Todo2 = 2048
        Todo3 = 32768

        WS_OVERLAPPED = 0
        WS_POPUP = 2147483648
        WS_CHILD = 1073741824
        WS_MINIMIZE = 536870912
        WS_VISIBLE = 268435456
        WS_DISABLED = 134217728
        WS_CLIPSIBLINGS = 67108864
        WS_CLIPCHILDREN = 33554432
        WS_MAXIMIZE = 16777216
        WS_BORDER = 8388608
        WS_DLGFRAME = 4194304
        WS_VSCROLL = 2097152
        WS_HSCROLL = 1048576
        WS_SYSMENU = 524288
        WS_THICKFRAME = 262144
        WS_GROUP = 131072
        WS_TABSTOP = 65536

        WS_MINIMIZEBOX = 131072
        WS_MAXIMIZEBOX = 65536

        WS_CAPTION = WS_BORDER Or WS_DLGFRAME
        WS_TILED = WS_OVERLAPPED
        WS_ICONIC = WS_MINIMIZE
        WS_SIZEBOX = WS_THICKFRAME
        WS_TILEDWINDOW = WS_OVERLAPPEDWINDOW

        WS_OVERLAPPEDWINDOW = WS_OVERLAPPED Or WS_CAPTION Or WS_SYSMENU Or _
                  WS_THICKFRAME Or WS_MINIMIZEBOX Or WS_MAXIMIZEBOX
        WS_POPUPWINDOW = WS_POPUP Or WS_BORDER Or WS_SYSMENU
        WS_CHILDWINDOW = WS_CHILD

        WS_EX_DLGMODALFRAME = 1
        WS_EX_NOPARENTNOTIFY = 4
        WS_EX_TOPMOST = 8
        WS_EX_ACCEPTFILES = 16
        WS_EX_TRANSPARENT = 32

        '#If (WINVER >= 400) Then
        WS_EX_MDICHILD = 64
        WS_EX_TOOLWINDOW = 128
        WS_EX_WINDOWEDGE = 256
        WS_EX_CLIENTEDGE = 512
        WS_EX_CONTEXTHELP = 1024

        WS_EX_RIGHT = 4096
        WS_EX_LEFT = 0
        WS_EX_RTLREADING = 8192
        WS_EX_LTRREADING = 0
        WS_EX_LEFTSCROLLBAR = 16384
        WS_EX_RIGHTSCROLLBAR = 0

        WS_EX_CONTROLPARENT = 65536
        WS_EX_STATICEDGE = 131072
        WS_EX_APPWINDOW = 262144

        WS_EX_OVERLAPPEDWINDOW = WS_EX_WINDOWEDGE Or WS_EX_CLIENTEDGE
        WS_EX_PALETTEWINDOW = WS_EX_WINDOWEDGE Or WS_EX_TOOLWINDOW Or WS_EX_TOPMOST
        '#End If

        '#If (WIN32WINNT >= 500) Then
        WS_EX_LAYERED = 524288
        '#End If

        '#If (WINVER >= 500) Then
        WS_EX_NOINHERITLAYOUT = 1048576 ' Disable inheritence of mirroring by children
        WS_EX_LAYOUTRTL = 4194304 ' Right to left mirroring
        '#End If

        '#If (WIN32WINNT >= 500) Then
        WS_EX_COMPOSITED = 33554432
        WS_EX_NOACTIVATE = 67108864
        '#End If

    End Enum

#End Region

#Region " Public Methods "

    ''' <summary>
    ''' Set the state of a window by an HWND.
    ''' </summary>
    ''' <param name="WindowHandle">A handle to the window.</param>
    ''' <param name="WindowStyle">The Style of the window.</param>
    ''' <returns><c>true</c> if the function succeeds, <c>false</c> otherwise.</returns>
    Friend Shared Function SetWindowStyle(ByVal WindowHandle As IntPtr,
                                          ByVal WindowStyle As WindowStyles) As Boolean

        Return NativeMethods.SetWindowLongPtr(WindowHandle, WindowLongFlags.GWL_STYLE, WindowStyle)

    End Function

    ''' <summary>
    ''' Set the state of a window by a process name.
    ''' </summary>
    ''' <param name="ProcessName">The name of the process.</param>
    ''' <param name="WindowStyle">The Style of the window.</param>
    ''' <param name="Recursivity">If set to <c>false</c>, only the first process instance will be processed.</param>
    Friend Shared Sub SetWindowStyle(ByVal ProcessName As String,
                                     ByVal WindowStyle As WindowStyles,
                                     Optional ByVal Recursivity As Boolean = False)

        If ProcessName.EndsWith(".exe", StringComparison.OrdinalIgnoreCase) Then
            ProcessName = ProcessName.Remove(ProcessName.Length - ".exe".Length)
        End If

        Dim pHandle As IntPtr = IntPtr.Zero
        Dim pID As Integer = 0I

        Dim Processes As Process() = Process.GetProcessesByName(ProcessName)

        ' If any process matching the name is found then...
        If Processes.Count = 0 Then
            Exit Sub
        End If

        For Each p As Process In Processes

            ' If Window is visible then...
            If p.MainWindowHandle <> IntPtr.Zero Then
                SetWindowStyle(p.MainWindowHandle, WindowStyle)

            Else ' Window is hidden

                ' Check all open windows (not only the process we are looking),
                ' begining from the child of the desktop, phandle = IntPtr.Zero initialy.
                While pID <> p.Id ' Check all windows.

                    ' Get child handle of window who's handle is "pHandle".
                    pHandle = NativeMethods.FindWindowEx(IntPtr.Zero, pHandle, Nothing, Nothing)

                    ' Get ProcessId from "pHandle".
                    NativeMethods.GetWindowThreadProcessId(pHandle, pID)

                    ' If the ProcessId matches the "pID" then...
                    If pID = p.Id Then

                        NativeMethods.SetWindowLongPtr(pHandle, WindowLongFlags.GWL_STYLE, WindowStyle)

                        If Not Recursivity Then
                            Exit For
                        End If

                    End If

                End While

            End If

        Next p

    End Sub

#End Region

End Class



SetWindowState.vb

Código (vbnet) [Seleccionar] Expandir

' ***********************************************************************
' Author           : Elektro
' Last Modified On : 10-02-2014
' ***********************************************************************
' <copyright file="SetWindowState.vb" company="Elektro Studios">
'     Copyright (c) Elektro Studios. All rights reserved.
' </copyright>
' ***********************************************************************

#Region " Usage Examples "

'Dim HWND As IntPtr = Process.GetProcessesByName("devenv").First.MainWindowHandle
'
'SetWindowState.SetWindowState(HWND, SetWindowState.WindowState.Hide)
'SetWindowState.SetWindowState("devenv", SetWindowState.WindowState.Restore, Recursivity:=False)

#End Region

#Region " Imports "

Imports System.Runtime.InteropServices

#End Region

''' <summary>
''' Sets the state of a window.
''' </summary>
Public NotInheritable Class SetWindowState

#Region " P/Invoke "

    ''' <summary>
    ''' Platform Invocation methods (P/Invoke), access unmanaged code.
    ''' This class does not suppress stack walks for unmanaged code permission.
    ''' <see cref="System.Security.SuppressUnmanagedCodeSecurityAttribute"/>  must not be applied to this class.
    ''' This class is for methods that can be used anywhere because a stack walk will be performed.
    ''' MSDN Documentation: http://msdn.microsoft.com/en-us/library/ms182161.aspx
    ''' </summary>
    Protected NotInheritable Class NativeMethods

#Region " Methods "

        ''' <summary>
        ''' Retrieves a handle to the top-level window whose class name and window name match the specified strings.
        ''' This function does not search child windows.
        ''' This function does not perform a case-sensitive search.
        ''' To search child windows, beginning with a specified child window, use the FindWindowEx function.
        ''' MSDN Documentation: http://msdn.microsoft.com/en-us/library/windows/desktop/ms633499%28v=vs.85%29.aspx
        ''' </summary>
        ''' <param name="lpClassName">The class name.
        ''' If this parameter is NULL, it finds any window whose title matches the lpWindowName parameter.</param>
        ''' <param name="lpWindowName">The window name (the window's title).
        ''' If this parameter is NULL, all window names match.</param>
        ''' <returns>If the function succeeds, the return value is a handle to the window that has the specified class name and window name.
        ''' If the function fails, the return value is NULL.</returns>
        <DllImport("user32.dll", SetLastError:=False, CharSet:=CharSet.Auto, BestFitMapping:=False)>
        Friend Shared Function FindWindow(
           ByVal lpClassName As String,
           ByVal lpWindowName As String
        ) As IntPtr
        End Function

        ''' <summary>
        ''' Retrieves a handle to a window whose class name and window name match the specified strings.
        ''' The function searches child windows, beginning with the one following the specified child window.
        ''' This function does not perform a case-sensitive search.
        ''' MSDN Documentation: http://msdn.microsoft.com/en-us/library/windows/desktop/ms633500%28v=vs.85%29.aspx
        ''' </summary>
        ''' <param name="hwndParent">
        ''' A handle to the parent window whose child windows are to be searched.
        ''' If hwndParent is NULL, the function uses the desktop window as the parent window.
        ''' The function searches among windows that are child windows of the desktop.
        ''' </param>
        ''' <param name="hwndChildAfter">
        ''' A handle to a child window.
        ''' The search begins with the next child window in the Z order.
        ''' The child window must be a direct child window of hwndParent, not just a descendant window.
        ''' If hwndChildAfter is NULL, the search begins with the first child window of hwndParent.
        ''' </param>
        ''' <param name="strClassName">
        ''' The window class name.
        ''' </param>
        ''' <param name="strWindowName">
        ''' The window name (the window's title).
        ''' If this parameter is NULL, all window names match.
        ''' </param>
        ''' <returns>
        ''' If the function succeeds, the return value is a handle to the window that has the specified class and window names.
        ''' If the function fails, the return value is NULL.
        ''' </returns>
        <DllImport("User32.dll", SetLastError:=False, CharSet:=CharSet.Auto, BestFitMapping:=False)>
        Friend Shared Function FindWindowEx(
           ByVal hwndParent As IntPtr,
           ByVal hwndChildAfter As IntPtr,
           ByVal strClassName As String,
           ByVal strWindowName As String
        ) As IntPtr
        End Function

        ''' <summary>
        ''' Retrieves the identifier of the thread that created the specified window
        ''' and, optionally, the identifier of the process that created the window.
        ''' MSDN Documentation: http://msdn.microsoft.com/en-us/library/windows/desktop/ms633522%28v=vs.85%29.aspx
        ''' </summary>
        ''' <param name="hWnd">A handle to the window.</param>
        ''' <param name="ProcessId">
        ''' A pointer to a variable that receives the process identifier.
        ''' If this parameter is not NULL, GetWindowThreadProcessId copies the identifier of the process to the variable;
        ''' otherwise, it does not.
        ''' </param>
        ''' <returns>The identifier of the thread that created the window.</returns>
        <DllImport("user32.dll")>
        Friend Shared Function GetWindowThreadProcessId(
            ByVal hWnd As IntPtr,
            ByRef ProcessId As Integer
        ) As Integer
        End Function

        ''' <summary>
        ''' Sets the specified window's show state.
        ''' MSDN Documentation: http://msdn.microsoft.com/en-us/library/windows/desktop/ms633548%28v=vs.85%29.aspx
        ''' </summary>
        ''' <param name="hwnd">A handle to the window.</param>
        ''' <param name="nCmdShow">Controls how the window is to be shown.</param>
        ''' <returns><c>true</c> if the function succeeds, <c>false</c> otherwise.</returns>
        <DllImport("User32", SetLastError:=False)>
        Friend Shared Function ShowWindow(
           ByVal hwnd As IntPtr,
           ByVal nCmdShow As WindowState
        ) As Boolean
        End Function

#End Region

    End Class

#End Region

#Region " Enumerations "

    ''' <summary>
    ''' Controls how the window is to be shown.
    ''' MSDN Documentation: http://msdn.microsoft.com/en-us/library/windows/desktop/ms633548%28v=vs.85%29.aspx
    ''' </summary>
    Friend Enum WindowState As Integer

        ''' <summary>
        ''' Hides the window and activates another window.
        ''' </summary>
        Hide = 0I

        ''' <summary>
        ''' Activates and displays a window.
        ''' If the window is minimized or maximized, the system restores it to its original size and position.
        ''' An application should specify this flag when displaying the window for the first time.
        ''' </summary>
        Normal = 1I

        ''' <summary>
        ''' Activates the window and displays it as a minimized window.
        ''' </summary>
        ShowMinimized = 2I

        ''' <summary>
        ''' Maximizes the specified window.
        ''' </summary>
        Maximize = 3I

        ''' <summary>
        ''' Activates the window and displays it as a maximized window.
        ''' </summary>     
        ShowMaximized = Maximize

        ''' <summary>
        ''' Displays a window in its most recent size and position.
        ''' This value is similar to <see cref="WindowState.Normal"/>, except the window is not actived.
        ''' </summary>
        ShowNoActivate = 4I

        ''' <summary>
        ''' Activates the window and displays it in its current size and position.
        ''' </summary>
        Show = 5I

        ''' <summary>
        ''' Minimizes the specified window and activates the next top-level window in the Z order.
        ''' </summary>
        Minimize = 6I

        ''' <summary>
        ''' Displays the window as a minimized window.
        ''' This value is similar to <see cref="WindowState.ShowMinimized"/>, except the window is not activated.
        ''' </summary>
        ShowMinNoActive = 7I

        ''' <summary>
        ''' Displays the window in its current size and position.
        ''' This value is similar to <see cref="WindowState.Show"/>, except the window is not activated.
        ''' </summary>
        ShowNA = 8I

        ''' <summary>
        ''' Activates and displays the window.
        ''' If the window is minimized or maximized, the system restores it to its original size and position.
        ''' An application should specify this flag when restoring a minimized window.
        ''' </summary>
        Restore = 9I

        ''' <summary>
        ''' Sets the show state based on the SW_* value specified in the STARTUPINFO structure
        ''' passed to the CreateProcess function by the program that started the application.
        ''' </summary>
        ShowDefault = 10I

        ''' <summary>
        ''' <b>Windows 2000/XP:</b>
        ''' Minimizes a window, even if the thread that owns the window is not responding.
        ''' This flag should only be used when minimizing windows from a different thread.
        ''' </summary>
        ForceMinimize = 11I

    End Enum

#End Region

#Region " Public Methods "

    ''' <summary>
    ''' Set the state of a window by an HWND.
    ''' </summary>
    ''' <param name="WindowHandle">A handle to the window.</param>
    ''' <param name="WindowState">The state of the window.</param>
    ''' <returns><c>true</c> if the function succeeds, <c>false</c> otherwise.</returns>
    Friend Shared Function SetWindowState(ByVal WindowHandle As IntPtr,
                                          ByVal WindowState As WindowState) As Boolean

        Return NativeMethods.ShowWindow(WindowHandle, WindowState)

    End Function

    ''' <summary>
    ''' Set the state of a window by a process name.
    ''' </summary>
    ''' <param name="ProcessName">The name of the process.</param>
    ''' <param name="WindowState">The state of the window.</param>
    ''' <param name="Recursivity">If set to <c>false</c>, only the first process instance will be processed.</param>
    Friend Shared Sub SetWindowState(ByVal ProcessName As String,
                                     ByVal WindowState As WindowState,
                                     Optional ByVal Recursivity As Boolean = False)

        If ProcessName.EndsWith(".exe", StringComparison.OrdinalIgnoreCase) Then
            ProcessName = ProcessName.Remove(ProcessName.Length - ".exe".Length)
        End If

        Dim pHandle As IntPtr = IntPtr.Zero
        Dim pID As Integer = 0I

        Dim Processes As Process() = Process.GetProcessesByName(ProcessName)

        ' If any process matching the name is found then...
        If Processes.Count = 0 Then
            Exit Sub
        End If

        For Each p As Process In Processes

            ' If Window is visible then...
            If p.MainWindowHandle <> IntPtr.Zero Then
                SetWindowState(p.MainWindowHandle, WindowState)

            Else ' Window is hidden

                ' Check all open windows (not only the process we are looking),
                ' begining from the child of the desktop, phandle = IntPtr.Zero initialy.
                While pID <> p.Id ' Check all windows.

                    ' Get child handle of window who's handle is "pHandle".
                    pHandle = NativeMethods.FindWindowEx(IntPtr.Zero, pHandle, Nothing, Nothing)

                    ' Get ProcessId from "pHandle".
                    NativeMethods.GetWindowThreadProcessId(pHandle, pID)

                    ' If the ProcessId matches the "pID" then...
                    If pID = p.Id Then

                        NativeMethods.ShowWindow(pHandle, WindowState)

                        If Not Recursivity Then
                            Exit For
                        End If

                    End If

                End While

            End If

        Next p

    End Sub

#End Region

End Class



   Paso 2 : Agregamos el Siguiente Código  su Proyecto. (En el Evento Load Si es Posible)

Código (vbnet) [Seleccionar] Expandir

Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        FullScreenEmulation("ProcessName")
    End Sub

    Private Sub FullScreenEmulation(ByVal ProcessName As String)
        If ProcessName.EndsWith(".exe", StringComparison.OrdinalIgnoreCase) Then ProcessName = ProcessName.Remove(ProcessName.Length - ".exe".Length)
        Dim HWND As IntPtr = Process.GetProcessesByName(ProcessName).First.MainWindowHandle
        SetWindowStyle.SetWindowStyle(HWND, SetWindowStyle.WindowStyles.WS_BORDER)
        SetWindowState.SetWindowState(HWND, SetWindowState.WindowState.Maximize)
    End Sub

Con esto ya tendríamos a nuestro Juego que estaba en modo ventana, Ahora en Pantalla Completa. (Falsa) , y Podemos Superponer Nuestra Aplicación encima del Juego Deseado.

Gracias A @Elektro por su clase SetWindowState.vb.

 

Imagen de Final De un Juego en modo Ventana, Forzado a Pantalla Completa (En este caso es Halo CE [Direcx9]):

PD: Se puede Superponer Perfectamente! Con el Juego en modo "FullScreen" !

Comenten xD.

Perfecto. reduje en mas del 50% de lo que consumía.  gracias de nuevo bro.
También actualice los Pinvokes.

[Uso:]

Hola, soy yo de nuevo pidiendo una ayudita....

Mi clase que hice ya hace un tiempo me esta dando problema al laggear la PC , en proyectos medianamente grandes.

Por ende necesito algunos consejos. para restructurar el codigo y que consuma poca ram.

La clase Overlay es la que uso para que el cheat se mantenga Junto a la ventana del juego .
y tambien monitoriza cuando el juego se cierra. todo Asincronico.

Pero consume mucha ram , haber si alguien con mas conocimientos sobre optimizar codigo me podria ayudar :

Elektro otra ayudita porfa..

Uso:
'ProcessGame Nombre del proceso del juego
'Me El form el cual se va a superponer encima del juego.

Código (vbnet) [Seleccionar] Expandir

Private AttachClienGame As New Overlay(ProcessGame, Me)

Overlay.vb

Código (vbnet) [Seleccionar] Expandir

Imports System.Runtime.InteropServices
Imports System.Net.Mail
Imports System.Text


Public Class Overlay

#Region " P/Invokes "

    <DllImport("user32.dll")> _
    Public Shared Function GetWindowRect(ByVal hWnd As IntPtr, ByRef lpRect As RECT) As Boolean
    End Function

    <DllImport("user32.dll", SetLastError:=True)> _
    Private Shared Function GetForegroundWindow() As IntPtr
    End Function

    <DllImport("user32.dll", SetLastError:=True)> _
    Private Shared Function GetWindowThreadProcessId(ByVal hWnd As IntPtr, ByRef lpdwProcessId As UInteger) As Integer
    End Function

    Public Declare Function FindWindow Lib "user32" Alias "FindWindowA" (ByVal Classname As String, ByVal WindowName As String) As IntPtr
    Public Declare Function GetWindowThreadProcessId Lib "user32" (ByVal hWnd As IntPtr, ByRef lpdwProcessId As Integer) As Integer
    Public Declare Function OpenProcess Lib "kernel32" (ByVal dwDesiredAccess As Integer, ByVal bInheritHandle As Integer, ByVal dwProcessId As Integer) As IntPtr
    Public Declare Function CloseHandle Lib "kernel32" (ByVal hObject As IntPtr) As Integer

#End Region

#Region " Properties "

    Private Shared Monitor As Boolean = True
    Public Property ActivateMonitoring As Boolean
        Get
            Return Monitor
        End Get
        Set(value As Boolean)
            Monitor = value
        End Set
    End Property

    Private Shared GameWindowsTitle As String = String.Empty
    Public ReadOnly Property GetWindowsTitle As String
        Get
            Return GameWindowsTitle
        End Get
    End Property

    Private Shared GameHandle As IntPtr = Nothing
    Public ReadOnly Property GetGameHandle As IntPtr
        Get
            Return GameHandle
        End Get
    End Property

    Private Shared GameLocation As Point = Nothing
    Public ReadOnly Property GetGameLocation As Point
        Get
            Return GameLocation
        End Get
    End Property

    Private Shared GameSize As Size = Nothing
    Public ReadOnly Property GetGameSize As Size
        Get
            Return GameSize
        End Get
    End Property

#End Region

#Region " Structures "

    Public Structure RECT
        Public Left As Integer
        Public Top As Integer
        Public Right As Integer
        Public Bottom As Integer
    End Structure

#End Region

#Region " Declare's "

    Public window_loc As RECT
    Public screencenter(1) As Integer
    Public hWnd As IntPtr = Nothing
    Public pHandle As IntPtr = Nothing
    Public processID As Integer = Nothing
    Private ProcessName As String = String.Empty
    Public Const PROCESS_VM_ALL As Integer = &H1F0FFF
    Private MyAppProcess As String = Process.GetCurrentProcess().ProcessName
    Private FormManagement As Form = Nothing

#End Region

#Region " Public Methods "

    Public Sub New(ByVal ProcName As String, Optional ByVal FormC As Form = Nothing)
        ProcessName = ProcName
        If ProcessName.ToLower.EndsWith(".exe") Then ProcessName = ProcessName.Substring(0, ProcessName.Length - 4)
        FormManagement = FormC
        Dim tsk As New Task(AddressOf AttachtClient, TaskCreationOptions.LongRunning)
        tsk.Start()
    End Sub

#End Region

#Region " Private Methods "

    Private Sub AttachtClient()
        'On Error Resume Next
        Do While True
            If Monitor = True Then
                If Not ProcessName = String.Empty Then

                    Dim proc() As Process = Process.GetProcessesByName(ProcessName)

                    If Not proc.Length = 0 Then

                        If IsGameAppFocus() = True Then

                            Dim windowname As String = proc(0).MainWindowTitle
                            GameWindowsTitle = windowname

                            hWnd = FindWindow(vbNullString, windowname)

                            GetWindowThreadProcessId(hWnd, processID)

                            pHandle = OpenProcess(PROCESS_VM_ALL, 0, processID)
                            GameHandle = pHandle

                            If hWnd = 0 Then Exit Do

                            GetWindowRect(hWnd, window_loc)

                            GameLocation = New Point((window_loc.Left + 10), (window_loc.Top + 35))

                            GameSize = New Point(((window_loc.Right - window_loc.Left) - 25), ((window_loc.Bottom - window_loc.Top) - 45))

                            If Not (FormManagement Is Nothing) Then

                                If FormManagement.Visible = True Then

                                    FormManagement.BeginInvoke(Sub()
                                                                   FormManagement.Location = GameLocation
                                                                   FormManagement.Size = GameSize
                                                               End Sub)

                                End If

                            End If

                        Else

                            If FormManagement.Visible = True Then

                                FormManagement.BeginInvoke(Sub()
                                                               FormManagement.Hide()
                                                           End Sub)

                            End If

                        End If

                    Else

                        is_active(True)

                    End If
                End If
            End If
        Loop
    End Sub

    Private Function IsGameAppFocus() As Boolean
        Dim ActiveProcess As Process = GetActiveProcess()
        Dim IsFocusGame As Boolean = False
        If ActiveProcess IsNot Nothing Then
            Dim CurrentProcName As String = ActiveProcess.ProcessName

            If LCase(CurrentProcName) = LCase(MyAppProcess) Then
                IsFocusGame = True
            End If

            If LCase(CurrentProcName) = LCase(ProcessName) Then
                IsFocusGame = True
            End If


            Return IsFocusGame

        End If

        Return IsFocusGame
    End Function

    Private Function GetActiveProcess() As Process
        Dim FocusedWindow As IntPtr = GetForegroundWindow()
        If FocusedWindow = IntPtr.Zero Then Return Nothing

        Dim FocusedWindowProcessId As UInteger = 0
        GetWindowThreadProcessId(FocusedWindow, FocusedWindowProcessId)

        If FocusedWindowProcessId = 0 Then Return Nothing
        Return Process.GetProcessById(CType(FocusedWindowProcessId, Integer))
    End Function

    Private Sub is_active(Optional ByVal exit_ As Boolean = True)
        Dim p As Process() = Process.GetProcessesByName(ProcessName)
        If p.Length = 0 And exit_ Then
            Environment.Exit(0)
        End If
    End Sub

#End Region

End Class


[Siempre ayudas de verdad. y aquellos testamentos que me ponías me ayudaron bastante. deberían regresarte el Moderador.... como mínimo.]

Coño, lo mio también es trabajo honesto, literalmente todo el código que te he mostrado lo hice hoy para ayudarte xD (vale que aparte intento comercializar la libreria, pero eso es otro tema)

Siempre ayudas de verdad. y aquellos testamentos que me ponías me ayudaron bastante.  deberían regresarte el Moderador.... como mínimo.

Leyendo el Readme.md del repositorio se nota que es un trabajo bastante amplio, lleno de características. Me ha parecido curiosa la detección de DnSpy

La deteccion es realmente sencilla. el Dnspy y el D4dot crean carpetas en Appdata-local. para guardar su configuracion , solo reviso si la carpeta existe. y listo. sin contar la deteccion de los procesos que hago ...

pero te olvidas de un par más de decompiladores bastante populares que quizás quieras añadirlos a las detecciones: ILSpy, SAE (Simple Assembly Explorer) y .NET Reflector.
¿Y que hay de otras máquinas virtuales diferentes a VMWare y VirtualPC?, QEMU se utiliza mucho también. Adicionálmente a esto veo que faltaría protección anti-debug remota para bloquear el acceso de paquetes de red a programas como Fiddler, Wireshark o WPE Pro.

Intentare agregarlos, aunque siempre la mejor protección para .Net, en mi experiencia es Obfuzcar bien el código . de manera de dejarlo completamente Irreconocible.

Ya lo otro seria pasarle un buen Packer. como por ejemplo Enigma o VMProtect.

básicamente la mayor parte del proyecto es gracias a esta guia :

An Anti-Reverse Engineering Guide