[VB2005] Spiel

IntelligenzBestie

Grünschnabel
Ich spiele derzeit Oblivion und will meine Fertigkeiten verbessern.
Da man dafür wie ein Bekloppter immer die selben Tasten drücken muss, um zb zu schleichen oder Zauber zu benutzen, dachte ich mir, das geht auch einfacher :).
Habs so versucht:
Code:
Private Sub Timer1_Tick(ByVal sender As Object, ByVal e As System.EventArgs) Handles Timer1.Tick                                   
        Dim generator As New Random
        Dim randomValue As Integer
        randomValue = generator.Next(1, 4)
        If randomValue < 2 Then
            SendKeys.Send("W")
        Else
            SendKeys.Send("S")
        End If

    End Sub
End Class

Allerdings funtkioniert das irgendwie immer nur unter normal Windows. Sobald ich ins Spiel wechsel, läuft das ganze wieder nicht. Was mache ich falsch?
 
http://crawlmsdn.microsoft.com/de-de/library/system.windows.forms.sendkeys.send(VS.80).aspx hat gesagt.:
SendKeys.Send-Methode
Sendet Tastatureingaben an die aktive Anwendung.

Du musst die Tastaturkeys an die Entsprechende Anwendung schicken. Dies geht mittels der Methode SendInput() aus der user32.dll. Dies musst du über Native-Calls lösen:
C#:
using System;
using System.ComponentModel;
using System.Runtime.InteropServices;

namespace KeyPressDemo
{
    /// <summary>
    /// Eine Helferklasse welche Methoden zur Verfügung stellt 
    /// um einen Tastendruck an das aktuell aktive Programm zu senden.
    /// </summary>
    public class KeyPressHelper
    {
        /// <summary>
        /// Sendet einen Tastendruck an die Aktuell aktive Anwendung.
        /// </summary>
        /// <param name="oKeyToPress">Die Taste welche an die Anwendung geschickt werden soll.</param>
        public static void DoKeyPress(Win32.VK oKeyToPress)
        {
            uint iReturn;
            // Neues Input-Signal
            Win32.INPUT oInput = new Win32.INPUT();
            // Als Tastaturinput definieren
            oInput.type = Win32.INPUT_KEYBOARD;
            // Welche Taste?
            oInput.ki.wScan = (ushort)oKeyToPress;
            // Zeit selbst generieren
            oInput.ki.time = 0;
            // Keine Zusatzinformationen
            oInput.ki.dwExtraInfo = IntPtr.Zero;


            //-------------------
            // Taste Drücken
            //-------------------
            oInput.ki.dwFlags = Win32.KEYEVENTF_KEYDOWN;
            // 1.Param --> Anzahl Structs(Inputs) in der Liste
            // 2.Param --> Inputs welche zu senden sind
            // 3.Param --> Größe der Inputs in Bytes
            iReturn = Win32.SendInput(1, new Win32.INPUT[] { oInput }, Marshal.SizeOf(oInput));

            // Fehler beim Drücken?
            if (iReturn != 0)
            {
                throw new Win32Exception(Marshal.GetLastWin32Error());
            }
            //-------------------
            // Taste Loslassen
            //-------------------
            oInput.ki.dwFlags = Win32.KEYEVENTF_KEYUP;
            iReturn = Win32.SendInput(1, new Win32.INPUT[] { oInput }, Marshal.SizeOf(oInput));

            // Fehler beim Loslassen?
            if (iReturn != 0)
            {
                throw new Win32Exception(Marshal.GetLastWin32Error());
            }
        }

    }

    public class Win32
    {
        #region INPUT - Type Werte

        public const int INPUT_MOUSE = 0;
        public const int INPUT_KEYBOARD = 1;
        public const int INPUT_HARDWARE = 2;

        #endregion

        #region KEYBDINPUT - dwFlags Werte
        public const ushort KEYEVENTF_KEYDOWN = 0x0000;
        public const ushort KEYEVENTF_KEYUP = 0x0002;
        #endregion

        #region KEYBDINPUT - wVK Werte
        public enum VK
        {
            /*
    * Virtual Keys, Standard Set */
            VK_LBUTTON = 0x01,
            VK_RBUTTON = 0x02,
            VK_CANCEL = 0x03,
            VK_MBUTTON = 0x04,    /* NOT contiguous with L & RBUTTON */

            VK_XBUTTON1 = 0x05,    /* NOT contiguous with L & RBUTTON */
            VK_XBUTTON2 = 0x06,    /* NOT contiguous with L & RBUTTON */

            /*
    * 0x07 : unassigned */
            VK_BACK = 0x08,
            VK_TAB = 0x09,

            /*
    * 0x0A - 0x0B : reserved */
            VK_CLEAR = 0x0C,
            VK_RETURN = 0x0D,

            VK_SHIFT = 0x10,
            VK_CONTROL = 0x11,
            VK_MENU = 0x12,
            VK_PAUSE = 0x13,
            VK_CAPITAL = 0x14,

            VK_KANA = 0x15,
            VK_HANGEUL = 0x15,  /* old name - should be here for compatibility */
            VK_HANGUL = 0x15,
            VK_JUNJA = 0x17,
            VK_FINAL = 0x18,
            VK_HANJA = 0x19,
            VK_KANJI = 0x19,

            VK_ESCAPE = 0x1B,

            VK_CONVERT = 0x1C,
            VK_NONCONVERT = 0x1D,
            VK_ACCEPT = 0x1E,
            VK_MODECHANGE = 0x1F,

            VK_SPACE = 0x20,
            VK_PRIOR = 0x21,
            VK_NEXT = 0x22,
            VK_END = 0x23,
            VK_HOME = 0x24,
            VK_LEFT = 0x25,
            VK_UP = 0x26,
            VK_RIGHT = 0x27,
            VK_DOWN = 0x28,
            VK_SELECT = 0x29,
            VK_PRINT = 0x2A,
            VK_EXECUTE = 0x2B,
            VK_SNAPSHOT = 0x2C,
            VK_INSERT = 0x2D,
            VK_DELETE = 0x2E,
            VK_HELP = 0x2F,

            /*
    * VK_0 - VK_9 are the same as ASCII '0' - '9' (0x30 - 0x39) * 0x40 : unassigned * VK_A - VK_Z are the same as ASCII 'A' - 'Z' (0x41 - 0x5A) */
            VK_LWIN = 0x5B,
            VK_RWIN = 0x5C,
            VK_APPS = 0x5D,

            /*
    * 0x5E : reserved */
            VK_SLEEP = 0x5F,

            VK_NUMPAD0 = 0x60,
            VK_NUMPAD1 = 0x61,
            VK_NUMPAD2 = 0x62,
            VK_NUMPAD3 = 0x63,
            VK_NUMPAD4 = 0x64,
            VK_NUMPAD5 = 0x65,
            VK_NUMPAD6 = 0x66,
            VK_NUMPAD7 = 0x67,
            VK_NUMPAD8 = 0x68,
            VK_NUMPAD9 = 0x69,
            VK_MULTIPLY = 0x6A,
            VK_ADD = 0x6B,
            VK_SEPARATOR = 0x6C,
            VK_SUBTRACT = 0x6D,
            VK_DECIMAL = 0x6E,
            VK_DIVIDE = 0x6F,
            VK_F1 = 0x70,
            VK_F2 = 0x71,
            VK_F3 = 0x72,
            VK_F4 = 0x73,
            VK_F5 = 0x74,
            VK_F6 = 0x75,
            VK_F7 = 0x76,
            VK_F8 = 0x77,
            VK_F9 = 0x78,
            VK_F10 = 0x79,
            VK_F11 = 0x7A,
            VK_F12 = 0x7B,
            VK_F13 = 0x7C,
            VK_F14 = 0x7D,
            VK_F15 = 0x7E,
            VK_F16 = 0x7F,
            VK_F17 = 0x80,
            VK_F18 = 0x81,
            VK_F19 = 0x82,
            VK_F20 = 0x83,
            VK_F21 = 0x84,
            VK_F22 = 0x85,
            VK_F23 = 0x86,
            VK_F24 = 0x87,

            /*
    * 0x88 - 0x8F : unassigned */
            VK_NUMLOCK = 0x90,
            VK_SCROLL = 0x91,

            /*
    * VK_L* & VK_R* - left and right Alt, Ctrl and Shift virtual keys. * Used only as parameters to GetAsyncKeyState() and GetKeyState(). * No other API or message will distinguish left and right keys in this way. */
            VK_LSHIFT = 0xA0,
            VK_RSHIFT = 0xA1,
            VK_LCONTROL = 0xA2,
            VK_RCONTROL = 0xA3,
            VK_LMENU = 0xA4,
            VK_RMENU = 0xA5,

            VK_BROWSER_BACK = 0xA6,
            VK_BROWSER_FORWARD = 0xA7,
            VK_BROWSER_REFRESH = 0xA8,
            VK_BROWSER_STOP = 0xA9,
            VK_BROWSER_SEARCH = 0xAA,
            VK_BROWSER_FAVORITES = 0xAB,
            VK_BROWSER_HOME = 0xAC,

            VK_VOLUME_MUTE = 0xAD,
            VK_VOLUME_DOWN = 0xAE,
            VK_VOLUME_UP = 0xAF,
            VK_MEDIA_NEXT_TRACK = 0xB0,
            VK_MEDIA_PREV_TRACK = 0xB1,
            VK_MEDIA_STOP = 0xB2,
            VK_MEDIA_PLAY_PAUSE = 0xB3,
            VK_LAUNCH_MAIL = 0xB4,
            VK_LAUNCH_MEDIA_SELECT = 0xB5,
            VK_LAUNCH_APP1 = 0xB6,
            VK_LAUNCH_APP2 = 0xB7,

            /*
    * 0xB8 - 0xB9 : reserved */
            VK_OEM_1 = 0xBA,   // ';:' for US
            VK_OEM_PLUS = 0xBB,   // '+' any country
            VK_OEM_COMMA = 0xBC,   // ',' any country
            VK_OEM_MINUS = 0xBD,   // '-' any country
            VK_OEM_PERIOD = 0xBE,   // '.' any country
            VK_OEM_2 = 0xBF,   // '/?' for US
            VK_OEM_3 = 0xC0,   // '`~' for US

            /*
    * 0xC1 - 0xD7 : reserved */
            /*
    * 0xD8 - 0xDA : unassigned */
            VK_OEM_4 = 0xDB,  //  '[{' for US
            VK_OEM_5 = 0xDC,  //  '\|' for US
            VK_OEM_6 = 0xDD,  //  ']}' for US
            VK_OEM_7 = 0xDE,  //  ''"' for US
            VK_OEM_8 = 0xDF

            /*
    * 0xE0 : reserved */

        }
        #endregion

        #region INPUT - Definitionen
        [StructLayout(LayoutKind.Sequential)]
        public struct MOUSEINPUT
        {
            public int dx;
            public int dy;
            public uint mouseData;
            public uint dwFlags;
            public uint time;
            public IntPtr dwExtraInfo;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct KEYBDINPUT
        {
            public ushort wVk;
            public ushort wScan;
            public uint dwFlags;
            public uint time;
            public IntPtr dwExtraInfo;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct HARDWAREINPUT
        {
            public uint uMsg;
            public ushort wParamL;
            public ushort wParamH;
        }

        [StructLayout(LayoutKind.Explicit)]
        public struct INPUT
        {
            [FieldOffset(0)]
            public int type;
            [FieldOffset(4)] //*
            public MOUSEINPUT mi;
            [FieldOffset(4)] //*
            public KEYBDINPUT ki;
            [FieldOffset(4)] //*
            public HARDWAREINPUT hi;
        }
        #endregion

        [DllImport("user32.dll", SetLastError = true)]
        public static extern uint SendInput(uint nInputs, INPUT[] pInputs, int cbSize);
    }
}

VB.net
Visual Basic:
Imports System
Imports System.ComponentModel
Imports System.Runtime.InteropServices

Namespace KeyPressDemo
    ''' <summary>
    ''' Eine Helferklasse welche Methoden zur Verfügung stellt 
    ''' um einen Tastendruck an das aktuell aktive Programm zu senden.
    ''' </summary>
    Public Class KeyPressHelper
        ''' <summary>
        ''' Sendet einen Tastendruck an die Aktuell aktive Anwendung.
        ''' </summary>
        ''' <param name="oKeyToPress">Die Taste welche an die Anwendung geschickt werden soll.</param>
        Public Shared Sub DoKeyPress(ByVal oKeyToPress As Win32.VK)
            Dim iReturn As UInteger
            ' Neues Input-Signal
            Dim oInput As New Win32.INPUT()
            ' Als Tastaturinput definieren
            oInput.type = Win32.INPUT_KEYBOARD
            ' Welche Taste?
            oInput.ki.wScan = CUShort(oKeyToPress)
            ' Zeit selbst generieren
            oInput.ki.time = 0
            ' Keine Zusatzinformationen
            oInput.ki.dwExtraInfo = IntPtr.Zero
            
            
            '-------------------
            ' Taste Drücken
            '-------------------
            oInput.ki.dwFlags = Win32.KEYEVENTF_KEYDOWN
            ' 1.Param --> Anzahl Structs(Inputs) in der Liste
            ' 2.Param --> Inputs welche zu senden sind
            ' 3.Param --> Größe der Inputs in Bytes
            iReturn = Win32.SendInput(1, New Win32.INPUT() {oInput}, Marshal.SizeOf(oInput))
            
            ' Fehler beim Drücken?
            If iReturn <> 0 Then
                Throw New Win32Exception(Marshal.GetLastWin32Error())
            End If
            '-------------------
            ' Taste Loslassen
            '-------------------
            oInput.ki.dwFlags = Win32.KEYEVENTF_KEYUP
            iReturn = Win32.SendInput(1, New Win32.INPUT() {oInput}, Marshal.SizeOf(oInput))
            
            ' Fehler beim Loslassen?
            If iReturn <> 0 Then
                Throw New Win32Exception(Marshal.GetLastWin32Error())
            End If
        End Sub
        
    End Class
    
    Public Class Win32
        #Region "INPUT - Type Werte"
        
        Public Const INPUT_MOUSE As Integer = 0
        Public Const INPUT_KEYBOARD As Integer = 1
        Public Const INPUT_HARDWARE As Integer = 2
        
        #End Region
        
        #Region "KEYBDINPUT - dwFlags Werte"
        Public Const KEYEVENTF_KEYDOWN As UShort = 0
        Public Const KEYEVENTF_KEYUP As UShort = 2
        #End Region
        
        #Region "KEYBDINPUT - wVK Werte"
        Public Enum VK
            '
'    * Virtual Keys, Standard Set 
            
            VK_LBUTTON = 1
            VK_RBUTTON = 2
            VK_CANCEL = 3
            VK_MBUTTON = 4
            ' NOT contiguous with L & RBUTTON 
            
            VK_XBUTTON1 = 5
            ' NOT contiguous with L & RBUTTON 
            VK_XBUTTON2 = 6
            ' NOT contiguous with L & RBUTTON 
            
            '
'    * 0x07 : unassigned 
            
            VK_BACK = 8
            VK_TAB = 9
            
            '
'    * 0x0A - 0x0B : reserved 
            
            VK_CLEAR = 12
            VK_RETURN = 13
            
            VK_SHIFT = 16
            VK_CONTROL = 17
            VK_MENU = 18
            VK_PAUSE = 19
            VK_CAPITAL = 20
            
            VK_KANA = 21
            VK_HANGEUL = 21
            ' old name - should be here for compatibility 
            VK_HANGUL = 21
            VK_JUNJA = 23
            VK_FINAL = 24
            VK_HANJA = 25
            VK_KANJI = 25
            
            VK_ESCAPE = 27
            
            VK_CONVERT = 28
            VK_NONCONVERT = 29
            VK_ACCEPT = 30
            VK_MODECHANGE = 31
            
            VK_SPACE = 32
            VK_PRIOR = 33
            VK_NEXT = 34
            VK_END = 35
            VK_HOME = 36
            VK_LEFT = 37
            VK_UP = 38
            VK_RIGHT = 39
            VK_DOWN = 40
            VK_SELECT = 41
            VK_PRINT = 42
            VK_EXECUTE = 43
            VK_SNAPSHOT = 44
            VK_INSERT = 45
            VK_DELETE = 46
            VK_HELP = 47
            
            '
'    * VK_0 - VK_9 are the same as ASCII '0' - '9' (0x30 - 0x39) * 0x40 : unassigned * VK_A - VK_Z are the same as ASCII 'A' - 'Z' (0x41 - 0x5A) 
            
            VK_LWIN = 91
            VK_RWIN = 92
            VK_APPS = 93
            
            '
'    * 0x5E : reserved 
            
            VK_SLEEP = 95
            
            VK_NUMPAD0 = 96
            VK_NUMPAD1 = 97
            VK_NUMPAD2 = 98
            VK_NUMPAD3 = 99
            VK_NUMPAD4 = 100
            VK_NUMPAD5 = 101
            VK_NUMPAD6 = 102
            VK_NUMPAD7 = 103
            VK_NUMPAD8 = 104
            VK_NUMPAD9 = 105
            VK_MULTIPLY = 106
            VK_ADD = 107
            VK_SEPARATOR = 108
            VK_SUBTRACT = 109
            VK_DECIMAL = 110
            VK_DIVIDE = 111
            VK_F1 = 112
            VK_F2 = 113
            VK_F3 = 114
            VK_F4 = 115
            VK_F5 = 116
            VK_F6 = 117
            VK_F7 = 118
            VK_F8 = 119
            VK_F9 = 120
            VK_F10 = 121
            VK_F11 = 122
            VK_F12 = 123
            VK_F13 = 124
            VK_F14 = 125
            VK_F15 = 126
            VK_F16 = 127
            VK_F17 = 128
            VK_F18 = 129
            VK_F19 = 130
            VK_F20 = 131
            VK_F21 = 132
            VK_F22 = 133
            VK_F23 = 134
            VK_F24 = 135
            
            '
'    * 0x88 - 0x8F : unassigned 
            
            VK_NUMLOCK = 144
            VK_SCROLL = 145
            
            '
'    * VK_L* & VK_R* - left and right Alt, Ctrl and Shift virtual keys. * Used only as parameters to GetAsyncKeyState() and GetKeyState(). * No other API or message will distinguish left and right keys in this way. 
            
            VK_LSHIFT = 160
            VK_RSHIFT = 161
            VK_LCONTROL = 162
            VK_RCONTROL = 163
            VK_LMENU = 164
            VK_RMENU = 165
            
            VK_BROWSER_BACK = 166
            VK_BROWSER_FORWARD = 167
            VK_BROWSER_REFRESH = 168
            VK_BROWSER_STOP = 169
            VK_BROWSER_SEARCH = 170
            VK_BROWSER_FAVORITES = 171
            VK_BROWSER_HOME = 172
            
            VK_VOLUME_MUTE = 173
            VK_VOLUME_DOWN = 174
            VK_VOLUME_UP = 175
            VK_MEDIA_NEXT_TRACK = 176
            VK_MEDIA_PREV_TRACK = 177
            VK_MEDIA_STOP = 178
            VK_MEDIA_PLAY_PAUSE = 179
            VK_LAUNCH_MAIL = 180
            VK_LAUNCH_MEDIA_SELECT = 181
            VK_LAUNCH_APP1 = 182
            VK_LAUNCH_APP2 = 183
            
            '
'    * 0xB8 - 0xB9 : reserved 
            
            VK_OEM_1 = 186
            ' ';:' for US
            VK_OEM_PLUS = 187
            ' '+' any country
            VK_OEM_COMMA = 188
            ' ',' any country
            VK_OEM_MINUS = 189
            ' '-' any country
            VK_OEM_PERIOD = 190
            ' '.' any country
            VK_OEM_2 = 191
            ' '/?' for US
            VK_OEM_3 = 192
            ' '`~' for US
            '
'    * 0xC1 - 0xD7 : reserved 
            
            '
'    * 0xD8 - 0xDA : unassigned 
            
            VK_OEM_4 = 219
            '  '[{' for US
            VK_OEM_5 = 220
            '  '\|' for US
            VK_OEM_6 = 221
            '  ']}' for US
            VK_OEM_7 = 222
            '  ''"' for US
            VK_OEM_8 = 223
            
            '
'    * 0xE0 : reserved 
            
            
        End Enum
        #End Region
        
        #Region "INPUT - Definitionen"
        <StructLayout(LayoutKind.Sequential)> _
        Public Structure MOUSEINPUT
            Public dx As Integer
            Public dy As Integer
            Public mouseData As UInteger
            Public dwFlags As UInteger
            Public time As UInteger
            Public dwExtraInfo As IntPtr
        End Structure
        
        <StructLayout(LayoutKind.Sequential)> _
        Public Structure KEYBDINPUT
            Public wVk As UShort
            Public wScan As UShort
            Public dwFlags As UInteger
            Public time As UInteger
            Public dwExtraInfo As IntPtr
        End Structure
        
        <StructLayout(LayoutKind.Sequential)> _
        Public Structure HARDWAREINPUT
            Public uMsg As UInteger
            Public wParamL As UShort
            Public wParamH As UShort
        End Structure
        
        <StructLayout(LayoutKind.Explicit)> _
        Public Structure INPUT
            <FieldOffset(0)> _
            Public type As Integer
            '*
            <FieldOffset(4)> _
            Public mi As MOUSEINPUT
            '*
            <FieldOffset(4)> _
            Public ki As KEYBDINPUT
            '*
            <FieldOffset(4)> _
            Public hi As HARDWAREINPUT
        End Structure
        #End Region
        
        <DllImport("user32.dll", SetLastError := True)> _
        Public Shared Function SendInput(ByVal nInputs As UInteger, ByVal pInputs As INPUT(), ByVal cbSize As Integer) As UInteger
        End Function
    End Class
End Namespace

Habe den Code nicht getestet. Sollte aber funktionieren. Spiele sollte man generell ehrlich spielen, wo bleibt da der Spaß wenn Bots und Hilfsprogramme für dich spielen? :rolleyes:

Gruß Daniel
 
Danke für die Antwort, werde es gleich testen.
Mir ging es eigentlich auch nur ums programmieren, sonst hätte ich mir ja gleich Cheates etc raussuchen können, desweiteren spiele ich im Singleplayer.
 

Neue Beiträge

Zurück