Si, es que... pff, ese post es del año 2013, creo que por aquél entonces solo llevaba 1 año o quizás menos con .NET, algún fallo tendrá ese código si dices que no funciona correctamente (aunque yo todo lo que publiqué también lo testeé).


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)


Bueno, aunque también he curioseado con metodologías anti-debugger y anti-virtualization y tengo hechas algunas implementaciones en .NET (bastante básicas), lo cierto es que la protección de código / ingeniería inversa no es mi especialidad así que lo que yo pueda opinar no haría suficiente mérito a tu labor.

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, 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.

Solo son ideas que lanzo. Gran trabajo.

Saludos!

No me suena la extensión CDT, perfectamente podría ser un formato privativo... y en ese caso olvídate de hallar una herramienta para desempacar el contenido.

Saludos!

PauseProcessObject.vb

Imports DevCase.Core.IPC.Tools
Imports Microsoft.Win32.SafeHandles
 
Namespace DevCase.Core.IPC
 
    ''' ----------------------------------------------------------------------------------------------------
    ''' <summary>
    ''' Represents the return value as a result of a call to 
    ''' <see cref="UIAutomationUtil.PauseProcess(Integer)"/> and
    ''' <see cref="UIAutomationUtil.PauseThread"/> functions.
    ''' </summary>
    ''' ----------------------------------------------------------------------------------------------------
    Public NotInheritable Class PauseProcessObject : Implements IDisposable
 
#Region " Properties "
 
        ''' <summary>
        ''' Gets the process id. (PID)
        ''' </summary>
        <Browsable(True)>
        Public ReadOnly Property PID As Integer
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' A collection of openthread-handles that points to the suspended thread handles of the process.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        <Browsable(False)>
        Friend handles_ As Collection(Of SafeAccessTokenHandle)
 
#End Region
 
#Region " Constructors "
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Prevents a default instance of the <see cref="UIAutomationUtil"/> class from being created.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        <DebuggerNonUserCode>
        Private Sub New()
        End Sub
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Initializes a new instance of the <see cref="PauseProcessObject"/> class.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        <Browsable(False)>
        <DebuggerStepThrough>
        Friend Sub New(pid As Integer)
            Me.PID = pid
            Me.handles_ = New Collection(Of SafeAccessTokenHandle)
        End Sub
 
#End Region
 
#Region " IDisposable Implementation "
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Flag to detect redundant calls when disposing.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        Private isDisposed As Boolean = False
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Releases all the resources used by this instance.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        <DebuggerStepThrough>
        Public Sub Dispose() Implements IDisposable.Dispose
            Me.Dispose(isDisposing:=True)
            GC.SuppressFinalize(Me)
        End Sub
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <param name="isDisposing">
        ''' <see langword="True"/>  to release both managed and unmanaged resources; 
        ''' <see langword="False"/> to release only unmanaged resources.
        ''' </param>
        ''' ----------------------------------------------------------------------------------------------------
        <DebuggerStepThrough>
        Private Sub Dispose(isDisposing As Boolean)
            If (Not Me.isDisposed) AndAlso (isDisposing) Then
                For Each item As SafeAccessTokenHandle In Me.handles_
                    If Not item?.IsClosed Then
                        Try : item.Close() : Catch : End Try
                    End If
                Next
                Me.handles_.Clear()
                Me.handles_ = Nothing
            End If
            Me.isDisposed = True
        End Sub
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        Protected Overrides Sub Finalize()
            Me.Dispose(False)
            MyBase.Finalize()
        End Sub
 
#End Region
 
    End Class
 
End Namespace

Modo de empleo:

Dim pid As Integer = Process.GetProcessesByName("hearthstone").Single().Id
 
' Pause the process.
Console.WriteLine($"Pausing process with PID: {pid}")
Using ppo As PauseProcessObject = UIAutomationUtil.PauseProcess(pid)
    ' Wait 5 seconds to let you observe that the process is paused...
    Console.WriteLine($"Sleeping for 5 seconds...")
    Thread.Sleep(5000)
 
    ' Resume the process.
    Console.WriteLine($"Resuming process with PID: {ppo.PID}")
    UIAutomationUtil.ResumeProcess(ppo)
End Using

Saludos.

¿Pero lo estás jugando a pantalla completa dedicada, o ventana sin bordes?...

De todas formas si ese problema es tal y como dices, entonces lo más simple para prevenirlo sería desarrollar un cheat sin interfaz gráfica y así evitar el problema. Si no puedes vencer a tu enemigo, acomódate a él. xD

También puedes probar a utilizar la función de Windows 'SetWindowLongPtr' sobre la ventana de tu aplicación:
https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setwindowlongptra

con la combinación de estilos extendidos de ventana: WS_EX_TOPMOST + WS_EX_NOACTIVATE:
https://docs.microsoft.com/en-us/windows/win32/winmsg/extended-window-styles

Teoricamente con esa combinación de estilos puedes superponer una ventana sobre las demás (top most) sin activar el foco de entrada de dicha ventana.

---

No se a que clase te refieres, pero esto te debería servir para suspender y reanudar el proceso:

https://foro.elhacker.net/net_c_vbnet_asp/libreria_de_snippets_para_vbnet_compartan_aqui_sus_snippets-t378770.0.html;msg1859297#msg1859297

Aquí te dejo una actualización del código:

UIAutomationUtil.vb

Imports DevCase.Interop.Unmanaged.Win32
Imports DevCase.Interop.Unmanaged.Win32.Enums
Imports Microsoft.Win32.SafeHandles
 
Namespace DevCase.Core.IPC.Tools
 
    ''' ----------------------------------------------------------------------------------------------------
    ''' <summary>
    ''' Contains related UI automation utilities.
    ''' </summary>
    ''' ----------------------------------------------------------------------------------------------------
    <ImmutableObject(True)>
    Public NotInheritable Class UIAutomationUtil
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Prevents a default instance of the <see cref="UIAutomationUtil"/> class from being created.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        <DebuggerNonUserCode>
        Private Sub New()
        End Sub
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Pauses the execution of all the threads of the specified process.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <example> This is a code example.
        ''' <code>
        ''' ' Create and run a CMD process.
        ''' Dim p As New Process
        ''' p.StartInfo.FileName = "cmd.exe"
        ''' p.StartInfo.Arguments = "/C ""Dir /B /S /A C:\*"""
        ''' p.Start()
        '''
        ''' Thread.Sleep(2000) ' Let the CMD run the job for some seconds...
        ''' 
        ''' ' Pause the process.
        ''' Using ppo As PauseProcessObject = UIAutomationUtil.PauseProcess(p.Id)
        '''     ' Wait 5 seconds to let you observe that the process is paused...
        '''     Thread.Sleep(5000)
        ''' 
        '''     ' Resume the process.
        '''     UIAutomationUtil.ResumeProcess(ppo)
        ''' End Using
        ''' </code>
        ''' </example>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <param name="pid">
        ''' The process id (PID).
        ''' </param>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <returns>
        ''' The return value is a collection of openthread-handles to the thread handles of the process.
        ''' <para></para>
        ''' An openthread-handle could be used to suspend, resume or terminate a thread that the openthread-handle refers to.
        ''' </returns>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <remarks>
        ''' After pausing the threads of a process, call <see cref="ResumeProcess(PauseProcessObject)"/> function 
        ''' to resume their threads.
        ''' <para></para>
        ''' To manually resume an openthread-handle, call <see cref="ResumeThread"/> function.
        ''' </remarks>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <exception cref="Win32Exception">
        ''' </exception>
        ''' ----------------------------------------------------------------------------------------------------
        <DebuggerStepThrough>
        Public Shared Function PauseProcess(pid As Integer) As PauseProcessObject
 
            Dim ppo As New PauseProcessObject(pid)
            For Each thread As ProcessThread In Process.GetProcessById(pid).Threads()
                ppo.handles_.Add(UIAutomationUtil.PauseThread(thread.Id))
            Next thread
 
            Return ppo
 
        End Function
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Resumes the execution of all the threads for the specified process.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <example> This is a code example.
        ''' <code>
        ''' ' Create and run a CMD process.
        ''' Dim p As New Process
        ''' p.StartInfo.FileName = "cmd.exe"
        ''' p.StartInfo.Arguments = "/C ""Dir /B /S /A C:\*"""
        ''' p.Start()
        '''
        ''' Thread.Sleep(2000) ' Let the CMD run the job for some seconds...
        ''' 
        ''' ' Pause the process.
        ''' Using ppo As PauseProcessObject = UIAutomationUtil.PauseProcess(p.Id)
        '''     ' Wait 5 seconds to let you observe that the process is paused...
        '''     Thread.Sleep(5000)
        ''' 
        '''     ' Resume the process.
        '''     UIAutomationUtil.ResumeProcess(ppo)
        ''' End Using
        ''' </code>
        ''' </example>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <param name="ppo">
        ''' A <see cref="PauseProcessObject"/> object containing all the process thread-handles.
        ''' </param>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <remarks>
        ''' After resuming the threads of a process, call the <see cref="PauseProcessObject.Dispose()"/> method 
        ''' of the <paramref name="ppo"/> parameter to close their openthread-handles.
        ''' <para></para>
        ''' To manually close an openthread-handle, call <see cref="NativeMethods.CloseHandle(IntPtr)"/> function.
        ''' </remarks>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <exception cref="Win32Exception">
        ''' </exception>
        ''' ----------------------------------------------------------------------------------------------------
        <DebuggerStepThrough>
        Public Shared Sub ResumeProcess(ppo As PauseProcessObject)
 
            For Each safeOpenThreadHandle As SafeAccessTokenHandle In ppo.handles_
                UIAutomationUtil.ResumeThread(safeOpenThreadHandle)
            Next safeOpenThreadHandle
 
        End Sub
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Pauses the execution of the specified thread.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <example> This is a code example.
        ''' <code>
        ''' Dim threadId As ProcessThread = Process.GetProcessesByName("cmd.exe").FirstOrDefault.Threads(0).Id
        '''
        ''' Dim openThreadHandle As SafeAccessTokenHandle = PauseThread(threadId)
        '''
        ''' ' ResumeThread(openThreadHandle)
        ''' </code>
        ''' </example>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <param name="threadId">
        ''' The thread identifier.
        ''' </param>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <returns>
        ''' The return value is an openthread-handle to the thread handle.
        ''' <para></para>
        ''' An openthread-handle could be used to suspend, resume or terminate a thread that the open-handle refers to.
        ''' </returns>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <remarks>
        ''' After pausing a thread, call <see cref="ResumeThread"/> function to resume the thread and close the openthread-handle.
        ''' <para></para>
        ''' To manually close an openthread-handle, call <see cref="NativeMethods.CloseHandle(IntPtr)"/> function.
        ''' </remarks>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <exception cref="Win32Exception">
        ''' </exception>
        ''' ----------------------------------------------------------------------------------------------------
        <DebuggerStepThrough>
        Public Shared Function PauseThread(threadId As Integer) As SafeAccessTokenHandle
 
            Const threadAccessRights As ThreadAccessRights = ThreadAccessRights.SuspendResume Or ThreadAccessRights.Terminate
            Dim safeOpenThreadHandle As SafeAccessTokenHandle = NativeMethods.OpenThread(threadAccessRights, True, CUInt(threadId))
            Dim win32Err As Integer = Marshal.GetLastWin32Error()
 
            If safeOpenThreadHandle.IsInvalid() Then
                Throw New Win32Exception(win32Err)
            Else
                NativeMethods.SuspendThread64(safeOpenThreadHandle)
                Return safeOpenThreadHandle
            End If
 
        End Function
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Pauses the execution of the specified thread.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <example> This is a code example.
        ''' <code>
        ''' Dim thread As ProcessThread = Process.GetProcessesByName("cmd.exe").FirstOrDefault.Threads(0)
        ''' Dim safeOpenThreadHandle As SafeAccessTokenHandle = PauseThread(thread)
        '''
        ''' ' ResumeThread(openThreadHandle)
        ''' </code>
        ''' </example>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <param name="thread">
        ''' The thread.
        ''' </param>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <returns>
        ''' The return value is an openthread-handle to the thread handle.
        ''' <para></para>
        ''' An openthread-handle could be used to suspend, resume or terminate a thread that the open-handle refers to.
        ''' </returns>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <remarks>
        ''' After pausing a thread, call <see cref="ResumeThread"/> function to resume the thread and close the openthread-handle.
        ''' <para></para>
        ''' To manually close an openthread-handle, call <see cref="NativeMethods.CloseHandle(SafeHandle)"/> function.
        ''' </remarks>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <exception cref="Win32Exception">
        ''' </exception>
        ''' ----------------------------------------------------------------------------------------------------
        <DebuggerStepThrough>
        Public Shared Function PauseThread(thread As ProcessThread) As SafeAccessTokenHandle
 
            Return UIAutomationUtil.PauseThread(thread.Id)
 
        End Function
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Resumes the execution of the specified thread.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <param name="safeOpenThreadHandle">
        ''' An open thread handle.
        ''' <para></para>
        ''' This handle can be obtained by calling the <see cref="UIAutomationUtil.PauseThread"/> 
        ''' or <see cref="NativeMethods.OpenThread(ThreadAccessRights, Boolean, UInteger)"/> functions.
        ''' </param>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <exception cref="Win32Exception">
        ''' </exception>
        ''' ----------------------------------------------------------------------------------------------------
        <DebuggerStepThrough>
        Public Shared Sub ResumeThread(safeOpenThreadHandle As SafeAccessTokenHandle)
 
            Dim result As Integer
            Dim win32Err As Integer
 
            If safeOpenThreadHandle.IsInvalid Then
                Throw New NullReferenceException("Handle is invalid.")
            End If
 
            result = NativeMethods.ResumeThread(safeOpenThreadHandle)
            win32Err = Marshal.GetLastWin32Error()
 
            If (result = -1) Then
                Throw New Win32Exception(win32Err)
            End If
 
        End Sub
 
    End Class
 
End Namespace
 

NativeMethods.vb

Imports Microsoft.Win32.SafeHandles
Imports System.Runtime.ConstrainedExecution
Imports System.Security
 
Imports DevCase.Interop.Unmanaged.Win32.Enums
 
Namespace DevCase.Interop.Unmanaged.Win32
 
    ''' ----------------------------------------------------------------------------------------------------
    ''' <summary>
    ''' Platform Invocation methods (P/Invoke), access unmanaged code.
    ''' <para></para>
    ''' This class does not suppress stack walks for unmanaged code permission.
    ''' <see cref="Security.SuppressUnmanagedCodeSecurityAttribute"/> must not be applied to this class.
    ''' <para></para>
    ''' This class is for methods that can be used anywhere because a stack walk will be performed.
    ''' </summary>
    ''' ----------------------------------------------------------------------------------------------------
    ''' <remarks>
    ''' <see href="https://msdn.microsoft.com/en-us/library/ms182161.aspx"/>
    ''' </remarks>
    ''' ----------------------------------------------------------------------------------------------------
    Friend NotInheritable Class NativeMethods
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Prevents a default instance of the <see cref="NativeMethods"/> class from being created.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        <DebuggerNonUserCode>
        Private Sub New()
        End Sub
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Closes the specified object handle.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <remarks>
        ''' <see href="https://msdn.microsoft.com/es-es/library/windows/desktop/ms724211%28v=vs.85%29.aspx"/>
        ''' </remarks>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <param name="hObject">
        ''' The handle to the object being closed.
        ''' </param>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <returns>
        ''' If the function succeeds, the return value is <see langword="True"/>.
        ''' <para></para>
        ''' If the function fails, the return value is <see langword="False"/>.
        ''' <para></para>
        ''' To get extended error information, call <see cref="Marshal.GetLastWin32Error"/>.
        ''' </returns>
        ''' ----------------------------------------------------------------------------------------------------
        <SuppressUnmanagedCodeSecurity>
        <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
        <DllImport("Kernel32.dll", SetLastError:=True)>
        Friend Shared Function CloseHandle(hObject As SafeHandle
        ) As <MarshalAs(UnmanagedType.Bool)> Boolean
        End Function
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Opens an existing thread object.
        ''' <para></para>
        ''' When done, don't forget to call <see cref="NativeMethods.CloseHandle"/> function.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <remarks>
        ''' <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms684335%28v=vs.85%29.aspx"/>
        ''' </remarks>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <param name="desiredAccess">
        ''' The access to the thread object.
        ''' <para></para>
        ''' This access right is checked against the security descriptor for the thread.
        ''' </param>
        '''
        ''' <param name="inheritHandle">
        ''' If this value is <see langword="True"/>, processes created by this process will inherit the handle.
        ''' <para></para>
        ''' Otherwise, the processes do not inherit this handle.
        ''' </param>
        '''
        ''' <param name="threadId">
        ''' The identifier of the thread to be opened.
        ''' </param>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <returns>
        ''' If the function succeeds, the return value is an open handle to the specified thread.
        ''' <para></para>
        ''' If the function fails, the return value is <see cref="IntPtr.Zero"/>.
        ''' <para></para>
        ''' To get extended error information, call <see cref="Marshal.GetLastWin32Error"/>.
        ''' </returns>
        ''' ----------------------------------------------------------------------------------------------------
        <DllImport("Kernel32.dll", SetLastError:=True)>
        Friend Shared Function OpenThread(desiredAccess As ThreadAccessRights,
          <MarshalAs(UnmanagedType.Bool)> inheritHandle As Boolean,
                                          threadId As UInteger
        ) As SafeAccessTokenHandle
        End Function
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Decrements a thread's suspend count.
        ''' <para></para>
        ''' When the suspend count is decremented to zero, the execution of the thread is resumed.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <remarks>
        ''' <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms685086%28v=vs.85%29.aspx"/>
        ''' </remarks>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <param name="hThread">
        ''' A handle to the thread to be resumed.
        ''' <para></para>
        ''' The handle must have the <see cref="ThreadAccessRights.SuspendResume"/> access right
        ''' </param>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <returns>
        ''' If the function succeeds, the return value is the thread's previous suspend count; otherwise, it is <c>-1</c>.
        ''' <para></para>
        ''' To get extended error information, call <see cref="Marshal.GetLastWin32Error"/>.
        ''' </returns>
        ''' ----------------------------------------------------------------------------------------------------
        <DllImport("Kernel32.dll", SetLastError:=True)>
        Friend Shared Function ResumeThread(hThread As SafeAccessTokenHandle
        ) As Integer
        End Function
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Suspends the specified 32-Bit thread.
        ''' <para></para>
        ''' A 32-bit application can suspend a 64-Bit thread using the <see cref="NativeMethods.SuspendThread64"/> function.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <remarks>
        ''' <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms687400%28v=vs.85%29.aspx"/>
        ''' </remarks>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <param name="hThread">
        ''' A handle to the thread that is to be suspended.
        ''' <para></para>
        ''' The handle must have the <see cref="ThreadAccessRights.SuspendResume"/> access right
        ''' </param>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <returns>
        ''' If the function succeeds, the return value is the thread's previous suspend count; otherwise, it is <c>-1</c>.
        ''' <para></para>
        ''' To get extended error information, call <see cref="Marshal.GetLastWin32Error"/>.
        ''' </returns>
        ''' ----------------------------------------------------------------------------------------------------
        <DllImport("Kernel32.dll", EntryPoint:="Wow64SuspendThread", SetLastError:=True)>
        Friend Shared Function SuspendThread32(hThread As SafeAccessTokenHandle
        ) As Integer
        End Function
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Suspends the specified 64-Bit thread.
        ''' <para></para>
        ''' A 64-bit application can suspend a 32-Bit thread using the <see cref="NativeMethods.SuspendThread32"/> function.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <remarks>
        ''' <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms686345%28v=vs.85%29.aspx"/>
        ''' </remarks>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <param name="hThread">
        ''' A handle to the thread that is to be suspended.
        ''' <para></para>
        ''' The handle must have the <see cref="ThreadAccessRights.SuspendResume"/> access right
        ''' </param>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <returns>
        ''' If the function succeeds, the return value is the thread's previous suspend count; otherwise, it is <c>-1</c>.
        ''' <para></para>
        ''' To get extended error information, call <see cref="Marshal.GetLastWin32Error"/>.
        ''' </returns>
        ''' ----------------------------------------------------------------------------------------------------
        <DllImport("Kernel32.dll", EntryPoint:="SuspendThread", SetLastError:=True)>
        Friend Shared Function SuspendThread64(hThread As SafeAccessTokenHandle
        ) As Integer
        End Function
 
    End Class
 
End Namespace

ThreadAccessRights .vb

#Region " Thread Access-Rights "
 
Namespace DevCase.Interop.Unmanaged.Win32.Enums
 
    ''' ----------------------------------------------------------------------------------------------------
    ''' <summary>
    ''' Specifies thread-specific access rights.
    ''' </summary>
    ''' ----------------------------------------------------------------------------------------------------
    ''' <remarks>
    ''' <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms686769%28v=vs.85%29.aspx"/>
    ''' </remarks>
    ''' ----------------------------------------------------------------------------------------------------
    <Flags>
    Public Enum ThreadAccessRights As Integer
 
        ''' <summary>
        ''' Required to delete the object.
        ''' </summary>
        Delete = CInt(StandardAccessRights.Delete)
 
        ''' <summary>
        ''' Required to read information in the security descriptor for the object, not including the information in the <c>SACL</c>.
        ''' <para></para>
        ''' To read or write the <c>SACL</c>, you must request the <c>ACCESS_SYSTEM_SECURITY</c> access right.
        ''' </summary>
        ReadControl = CInt(StandardAccessRights.ReadControl)
 
        ''' <summary>
        ''' Required to modify the <c>DACL</c> in the security descriptor for the object.
        ''' </summary>
        WriteDac = CInt(StandardAccessRights.WriteDac)
 
        ''' <summary>
        ''' Required to change the owner in the security descriptor for the object.
        ''' </summary>
        WriteOwner = CInt(StandardAccessRights.WriteOwner)
 
        ''' <summary>
        ''' The right to use the object for synchronization. 
        ''' <para></para>
        ''' This enables a thread to wait until the object is in the signaled state.
        ''' </summary>
        Synchronize = CInt(StandardAccessRights.Synchronize)
 
        ''' <summary>
        ''' Required to terminate a thread 
        ''' using <see cref="NativeMethods.TerminateThread"/> function.
        ''' </summary>
        Terminate = &H1
 
        ''' <summary>
        ''' Required to suspend or resume a thread 
        ''' using <see cref="NativeMethods.SuspendThread32"/>, 
        ''' <see cref="NativeMethods.SuspendThread64"/> and <see cref="NativeMethods.ResumeThread"/> functions.
        ''' </summary>
        SuspendResume = &H2
 
        ''' <summary>
        ''' Required to read the context of a thread using <c>GetThreadContext</c> function.
        ''' </summary>
        GetContext = &H8
 
        ''' <summary>
        ''' Required to write the context of a thread using <c>SetThreadContext</c> function.
        ''' </summary>
        SetContext = &H10
 
        ''' <summary>
        ''' Required to set certain information in the thread object.
        ''' </summary>
        SetInformation = &H20
 
        ''' <summary>
        ''' Required to read certain information from the thread object, 
        ''' such as the exit code using <see cref="NativeMethods.GetExitCodeThread"/> function.
        ''' </summary>
        QueryInformation = &H40
 
        ''' <summary>
        ''' Required to set the impersonation token for a thread 
        ''' using <c>SetThreadToken</c> function.
        ''' </summary>
        SetThreadToken = &H80
 
        ''' <summary>
        ''' Required to use a thread's security information directly without calling it by using a 
        ''' communication mechanism that provides impersonation services.
        ''' </summary>
        Impersonate = &H100
 
        ''' <summary>
        ''' Required for a server thread that impersonates a client.
        ''' </summary>
        DirectImpersonation = &H200
 
        ''' <summary>
        ''' Required to set certain information in the thread object.
        ''' <para></para>
        ''' A handle that has the <see cref="ThreadAccessRights.SetInformation"/> access right 
        ''' is automatically granted <see cref="ThreadAccessRights.SetLimitedInformation"/>.
        ''' </summary>
        SetLimitedInformation = &H400
 
        ''' <summary>
        ''' Required to read certain information from the thread objects. 
        ''' <para></para>
        ''' A handle that has the <see cref="ThreadAccessRights.QueryInformation"/> access right 
        ''' is automatically granted <see cref="ThreadAccessRights.QueryLimitedInformation"/>.
        ''' </summary>
        QueryLimitedInformation = &H800
 
    End Enum
 
End Namespace
 
#End Region

StandardAccessRights .vb

#Region " Standard Access Rights "
 
Namespace DevCase.Interop.Unmanaged.Win32.Enums
 
    ''' ----------------------------------------------------------------------------------------------------
    ''' <summary>
    ''' Specifies the access rights that correspond to operations specific to a standard object type.
    ''' </summary>
    ''' ----------------------------------------------------------------------------------------------------
    ''' <remarks>
    ''' <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/aa379607(v=vs.85).aspx"/>
    ''' </remarks>
    ''' ----------------------------------------------------------------------------------------------------
    <Flags>
    Public Enum StandardAccessRights As UInteger
 
        ''' <summary>
        ''' The right to delete the object.
        ''' </summary>
        Delete = &H10000
 
        ''' <summary>
        ''' The right to read the information in the object's security descriptor, 
        ''' not including the information in the system access control list (SACL).
        ''' </summary>
        ReadControl = &H20000
 
        ''' <summary>
        ''' The right to modify the discretionary access control list (DACL) in the object's security descriptor.
        ''' </summary>
        WriteDac = &H40000
 
        ''' <summary>
        ''' The right to change the owner in the object's security descriptor.
        ''' </summary>
        WriteOwner = &H80000
 
        ''' <summary>
        ''' The right to use the object for synchronization. 
        ''' <para></para>
        ''' This enables a thread to wait until the object is in the signaled state. 
        ''' <para></para>
        ''' Some object types do not support this access right.
        ''' </summary>
        Synchronize = &H100000
 
        ''' <summary>
        ''' Combines <see cref="StandardAccessRights.Delete"/>, 
        ''' <see cref="StandardAccessRights.ReadControl"/>, <see cref="StandardAccessRights.WriteDac"/>, and
        ''' <see cref="StandardAccessRights.WriteOwner"/> access.
        ''' </summary>
        StandardRightsRequired = &HF0000
 
        ''' <summary>
        ''' Same as <see cref="StandardAccessRights.ReadControl"/>.
        ''' </summary>
        StandardRightsRead = StandardAccessRights.ReadControl
 
        ''' <summary>
        ''' Same as <see cref="StandardAccessRights.ReadControl"/>.
        ''' </summary>
        StandardRightsWrite = StandardAccessRights.ReadControl
 
        ''' <summary>
        ''' Same as <see cref="StandardAccessRights.ReadControl"/>.
        ''' </summary>
        StandardRightsExecute = StandardAccessRights.ReadControl
 
        ''' <summary>
        ''' Combines <see cref="StandardAccessRights.Delete"/>, 
        ''' <see cref="StandardAccessRights.ReadControl"/>, <see cref="StandardAccessRights.WriteDac"/>,
        ''' <see cref="StandardAccessRights.WriteOwner"/>, and <see cref="StandardAccessRights.Synchronize"/> access.
        ''' </summary>
        StandardRightsAll = &H1F0000
 
    End Enum
 
End Namespace
 
#End Region
 

PauseProcessObject.vb

Indicios de vida microbana en Venus...

Ahora cobra algo de sentido ese loco y surrealista proyecto de la NASA de hace algunos años (2014):

-> La NASA quiere colonizar Venus con una ciudad flotante
-> La NASA se plantea la posibilidad de enviar humanos a Venus, para vivir en dirigibles flotantes
-> Este es el plan de la NASA para explorar y colonizar Venus
-> High Altitude Venus Operational Concept (HAVOC)

MkcSys, tu intención es buena y te lo agradezco, pero no es un método viable. Te explico, si tuviera que editar los videos lo haría, pero es que estamos hablando de 153 capítulos, y practicamente todos ellos (o la inmensa mayoría) tienen escenas en japonés, y yo no se en que partes del video están, logicamente no voy a ponerme a ver la serie completa (o en su defecto leerme todos los subítulos forzados) cientos de horas para encontrar cada escena e ir editando cada video... es algo inviable.

---

Yo también vi la serie en mi infancia, sabes que tengo una edad.

Y bueno, me estás ofendiendo bastante pero por más que insistas con aquel otro anime no voy a ponerme a discutir contigo explicándote que lo que tu llamas "tiquismiquismo" o "cosas raras" se llama tener los sentidos agudizados y ser algo exigente, y si un anime tiene un HORRIBLE efecto de luz blanquecina en todas las escenas que no pega ni con cola y que es muy molesto, pues lo digo, yo no trago ese efecto, me resulta muy molesto para la vista, igual que en los años 2000 se hacia un abuso desmedido de los filtros de colores en las películas, y no me gusta ver una película en color sepia, pero a mucha gente le da igual y algunos ni son capaces de notarlo.
En fin, y que digas que los problemas están en mi cabeza... no, los problemas son reales y te los he explicado punto por punto en mi comentario anterior en lo que conlleva la transición de 4:3 a 16:9, que tampoco es que haga falta explicarlo por que lo sabes de sobra.

Por mucho 16:9 y mayor resolución que sea, la fuente de la imagen es LA MISMA a 4:3, así que a mayor resolución no significa mejor nivel de detalle, de hecho el nivel de detalle, exceptuando que los colores son más vivos, es mucho peor (ya expliqué punto por punto por que es peor) al ser un reescalado.

Y no puede ser de otra forma por que por aquella época no se digitalizaban los dibujos de la misma manera en que se hace hoy en día. Logicamente en la remasterización hay un gran trabajo de edición digitalizada sobre la imagen original en 4:3, pero basicamente estiran la imagen y la recortan, la recolorean digitalmente y ale, no se que mejora ves tu en eso, yo prefiero mil veces poder ver todos los detalles del metraje, a perderlos por la conversión de la relación de aspecto, y el problema del pincel gordo negro que eso es con lo que no puedo tragar, se ve horrible.



Saludos.

Ya puestos mejor cataloguemos todas las noticias por categorias en distintos subforos: noticias científicas, informáticas, políticas, deportes, coronavirus... si no lo hacen así estarían discriminando al resto de noticias...

MALA IDEA

esto no s un protal de noticias como el abc.es donde todo está perfectamente organizado. En el foro libre están bien como están todas las noticias no-informáticas, puesto que ya es el lugar que corresponde para publicar temas "off-topic" como su propio nombre indica. Pero bueno, que me importará a mi lo que decidan hacer y como lo quieran organizar, si despues de todo lo que me hicieron yo ya solo me paso por aquí para estar un rato en el foro libre y opinar en algunos temas, abrir un par de temas por interés propio, y poco o nada más.

"Tema serio" dice... el primer mensaje en el foro de un individuo que tiene el síndrome de Sherlock Holmes. (Peligro, troll a la vista.)

Y digo yo, ¿PARA QUÉ ESTÁ LA POLICIA DE VERDAD?, ellos son los que montan operativos y tienen policias incubiertos en chats para cazar delincuentes, ya sea pedófilos o de toda índole. Lo vi en un documental. De todas formas creo que siempre pueden ayudar a la Policia proporcionándole datos de posibles sospechosos para que la Policia lo pueda investigar, de lo contrario mejor déjenles hacer su trabajo, que para eso está la Policia.

4:3 = Imagen original en su totalidad, no hay mucho más que decir.

16:9 = imagen estirada y recortada de todos los laterales, arriba abajo izquierda y derecha, pierdes la visión de detalles de los escenarios y la imagen en general se ve como más "grande" (por que está estirada)... es una sensación anómala y bastante incómoda, y el pincel negro, el que utilizan para dibujar los contornos de los personajes y de los objetos y de practicamente todo es bastante más gordo (supongo que por haber estitrado la imagen) y ese pincel queda HORRIBLE si comparas la misma imagen a 4:3 con la imagen a 16:9, insisto en que los personajes parecen cagarros negros, sobre todo cuando están lejos en el horirzonte, no se les distingue la cara ni nada, lo que por supuesto no ocurre con la serie a 4:3 original, el pincel negro es más fino y se aprecia mucho mejor TODO y cada uno de los detalles de cada fotograma, a pesar de tener una resolución menor.

Si esto para ti son "gustos raros", pues perfecto, yo opino lo mismo de quien con cierta edad haya tenido la oportunidad de ver la serie en su formato original a 4:3, y aun así prefiera estas "remasterizaciones" a 1080p, donde se pierden detalles, todo se vuelve más grande de forma anómala y los contornos negros demasiado gruesos hace que no se distingan a los personajes cuando están a lo lejos.

Saludos

No si encontrarla es muy facil, ahora, encontrar los capítulos íntegros sin escenas en japonés, eso si que está dificil.


Yo me he descargado un montaje en x265, se ve de lujo y no pesa demasiado. El canal de telegram:

https://t.me/joinchat/AAAAAE8xycoDHHPfo3JN4A

Por cierto también tienen la serie de DB, DBZ y DBGT a 1080p y en x265 por si te interesa, pero a mi no me gusta en esa relación de aspecto, la imagen se ve demasaido "grande" ya que la estiran.

Es lo malo de estas remasterizaciones que ha hecho selecta vision, no se como la puedes ver a 1080p SonGoku. Fíjate que además abusan del color del pincel negro y cuando los personajes están lejos parecen cagarros, monigotes muy muy negros que no se les distingue ni la cara, no se, se ve raro en general a 1080p, al menos yo lo veo así, no me gusta nada, lo prefiero en 4:3.


Quizás contaste mal, pero de todas formas te digo que son 291 capítulos, sin contar las 4 OVAs en japonés, las 15 películas (o 13 si no contamos las 2 más modernas) y los 2 especiales de TV (que se distribuyeron en VHS y DVD como si fuesen películas) en Español.

De dragon Ball son 153 capítulos, 2 especiales de TV en japonés (pero que no interesan, son educativos, de bomberos y cosas así) y 4 películas en Español.

(de DBZ me dejo sin contar un especial que solo la hicieron para una consola, y otro que dura apenas 2 minutos y no vale pa nah)


Imagino que a SonGoku no le importaria, y dicho sea de paso que sería algo de agradecer, pero es que yo la busco en relación 4:3, en 16:9 no me interesa.

Encontré un montaje 4:3 a 1440p en Español que se ve de lujo y un reescalado 4:3 a 960p que también, pero por supuesto ambos montajes incluyen las escenas en japonés que te saltan en mitad de cada capítulo... que dolor de muelas.