कंसोल ऐप माउस-क्लिक एक्स वाई कोऑर्डिनेट डिटेक्शन/तुलना

Question

मेरे पास एक गेम है जो मैं एक सी # कंसोल एप्लिकेशन में काम कर रहा हूं, पूरी तरह से बेहतर तरीके से आगे बढ़ने से पहले अभ्यास के रूप में। विंडोज फॉर्म ऐप जैसे कुछ का उपयोग करने के विरोध में, जिसमें बटन कार्यक्षमता निर्मित है, मैं कर्सर की स्थिति को पकड़ने का प्रयास कर रहा हूं (जो मुझे पता है कि कैसे करना है) और इसे कंसोल एप्लिकेशन के अंदर कई क्षेत्रों में तुलना करें, जैसा कि परिभाषित किया गया है शायद पिक्सेल स्थान, लेकिन मुझे यह भी नहीं पता कि पिक्सेल के अलावा अंतरिक्ष की इकाई में कुछ प्रकार का निर्माण किया गया है (यह आखिरी बिट वह हिस्सा है जिसे मैं समझने में असमर्थ हूं)।

पीएस मुझे पता है कि यह सामान्य शब्दों में है, बिना किसी कोड के पहले से ही प्रदान किया गया है, लेकिन मुझे नहीं लगता कि इसकी आवश्यकता है क्योंकि मैं जो कुछ भी मांग रहा हूं वह एक कंसोल एप्लिकेशन के अंदर XY निर्देशांक को कैसे पकड़ना है, और उन्हें int चर में चिपकाने का संक्षिप्त विवरण है ।

अग्रिम में बहुत धन्यवाद! : डी

Answer 1

क्या @ फ्रैंक क्रूगर ने कहा। क्या आप वास्तव में ऐसा करना चाहते हैं? विंडोज फॉर्म को यह अधिक आसान बनाने के लिए डिज़ाइन किया गया है।

यदि आप करते हैं, तो आपको निम्न स्तर के विंडोज एपीआई में PInvoke का उपयोग करने की आवश्यकता होगी। शुरुआती बिंदु के रूप में this आज़माएं - लेकिन ध्यान रखें कि यह विंडोज फॉर्म एप्लिकेशन की तुलना में काफी जटिल है।

Answer 2

जब आप घटनाओं का उपयोग किये बिना गेम लिखते हैं ... आप वास्तव में इसे स्वयं क्रियाओं को लागू कर रहे हैं। यह फायदेमंद है, क्योंकि आप अपनी भाषा की अंतर्निहित घटनाओं का उपयोग करके इसे और अधिक कुशल बना सकते हैं। यदि आप जानते हैं कि आप क्या कर रहे हैं तो इस तरह से लिखे गए गेम कम त्रुटि प्रवण हैं।

उदाहरण के लिए, जब मैं अपने भाई को सिखाने की कोशिश कर रहा था कि गेम कैसे लिखे गए हैं, मैंने उनके लिए एक सरल सांप गेम लिखा था। मेरे पास धागे में मुख्य पाश था, सांप को ले जाएं और इसे चक्र में अपनी नई स्थिति पर खींचें। मेरे पास एक ही समय में एक थ्रेड चल रहा होगा जो लगातार 4 चीजों की जांच करता है:

1) यदि सांप अपने आप में दुर्घटनाग्रस्त हो जाता है (गेम ओवर); यदि खेल खत्म होता है, तो मुख्य थ्रेड को रोकें जो सांप की मुख्य स्थिति को अद्यतन करता है, स्क्रीन पर गेम प्रिंट करें, कुंजी इनपुट का इंतजार करें, फिर गेम को पुनरारंभ करें।

2) यदि सांप ने एक सेब खा लिया था; काउंटर वेरिएबल को बढ़ाएं जो कहता है कि कितने सेब खाए गए हैं, और स्क्रीन पर इस नए मूल्य को प्रिंट करें, पहले से क्या लिख ​​रहा था।

3) यदि सांप 10 से विभाज्य सेब की राशि खाया था (साँप 1 सेल द्वारा बढ़ता है, एक प्रतीक्षा चर का कहना है कि कितना समय प्रत्येक आंदोलन साँप बनाता है)

4) के बीच पास करना चाहिए से घटाना यदि एक तीर कुंजी दबा दी गई है। यदि छोड़ा गया है, तो 0 पर स्थानांतरित करें, यदि दाएं सेट को 1 पर ले जाएं, तो डाउन सेट 2 पर ले जाएं, अगर सेट 3 पर ले जाएं। जिस int में यह संग्रहीत है वह 4 प्रतिनिधिों की एक सरणी के लिए सूचक है जो सांप को स्थानांतरित करते हैं सही दिशा में।

सांप की स्थिति को अद्यतन करने वाला मुख्य लूप यह बताएगा कि सांप क्या कर रहा है, इन 4 चीजों की जांच थ्रेड को बताएगा। जिस तरह से मैं यह करता हूं कि मेरे पास स्क्रीन पर हर सेल है कि सांप का सिर प्रतिनिधियों के 2-आयामी सरणी को संदर्भित करता है। प्रतिनिधियों के इस सरणी के बारे में:

गेम कंसोल मोड में लिखा गया है, और कंसोल रंगों का उपयोग करता है। कंसोल 80x50 वर्णों पर सेट है। निम्नानुसार एक प्रतिनिधि: "प्रतिनिधि शून्य पीआरटी()"; तो मैं सरणी बना देता हूं: "पीआरटी [,] pos = new ptr [80,50]"। कहें कि सांप का सिर स्क्रीन पर स्थिति (4,5) पर है, वहां जाने के बाद मुख्य लूप "pos [4,5] .vvoke();" निष्पादित करेगा।

उनमें से एक: जब सांप एक नई स्थिति में जाता है, तो मुख्य लूप थ्रेड स्क्रीन पर सांप को कवर करने वाले प्रत्येक सेल को प्राप्त करेगा, और उस स्थिति में प्रतिनिधि को "शून्य गेमओवर" नामक फ़ंक्शन को इंगित करने के लिए सेट करेगा।() "जो gameover_ चर को सत्य पर सेट करेगा। तो जब लूप थ्रेड गेम गेम के लिए गेम चेक की स्थिति की जांच करता है, तो यह गेम को फ्रीज करता है और स्क्रीन पर गेम प्रिंट करता है।

अन्य: जब स्क्रीन पर एक सेब खींचा जाता है, तो प्रतिनिधि स्थिति (जिसे यादृच्छिक है) पर खींचा जाता है, "शून्य वृद्धिशील_एपल()" को इंगित करने के लिए सेट किया जाता है जो सेब काउंटर को बढ़ाता है, वर्तमान सेब को हटा देता है देखें, और स्क्रीन पर एक नया सेब खींचता है, पुरानी सेब स्थिति को "शून्य शून्य()" पर इंगित करने के लिए सेट करता है जो कुछ भी नहीं करता है, और नई सेब स्थिति "void increment_apple()" को इंगित करने के लिए।

यह मूल रूप से गेम कैसे काम करता है। जैसा कि आप देख सकते हैं, सांप स्क्रीन पर इन पदों पर चलता है, और यह "अगर (snake_position == some_position)" जैसी कोई स्पष्ट जांच किए बिना, गेम स्वचालित रूप से गेम में होने वाली हर चीज के लिए जो कुछ भी माना जाता है, वह करता है, जब आप किसी फॉर्म पर किसी बटन पर क्लिक करते हैं, तो उस ईवेंट को असाइन की गई कार्रवाई स्वचालित रूप से निष्पादित की जाती है, बिना किसी ईवेंट को जांचने के।

तो आप देखते हैं, मैं एक फॉर्म और डिफ़ॉल्ट घटनाओं का उपयोग कर सकता था जो सी # प्रदान करता है, लेकिन मैंने नहीं किया। मैंने कंसोल इंटरफ़ेस का उपयोग किया, और अपनी खुद की घटना प्रणाली लागू की।

इस तरह यह दृश्यों के पीछे काम करता है: आपके फॉर्म ऐप के लिए मुख्य लूप एक थ्रेड में चलाएगा जो स्क्रीन पर सभी बटनों से इनपुट के लिए जांच करता है। इनमें से प्रत्येक आइटम एक बुलियन वैरिएबल सेट करेगा जो वे सच में उपयोग करते हैं। जब आप इस बटन पर क्लिक करते हैं, तो एक लूप चलाने वाला एक और थ्रेड जो आपने दबाया है, जांचता है, और कहता है कि आपने "बटन 1" नामक एक बटन दबाया है, उस बटन को एक प्रतिनिधि सौंपा गया होगा; तब उस प्रतिनिधि को जो कुछ भी इंगित करता है उसके साथ निष्पादित किया जाता है।

समझाने के लिए कड़ी मेहनत की, लेकिन क्या यह आपको समझ में आता है?

Answer 3

इसके अलावा, कंसोल केवल टेक्स्ट प्रोसेसिंग के लिए नहीं है। आप इसके लिए सुंदर सभ्य खिड़की प्रबंधक लिख सकते हैं। आप इसके साथ कुछ भी कर सकते हैं। यह बस कठिन है।

हालांकि यह धीमा है। मैंने उपयोगकर्ता इंटरफ़ेस के लिए कंसोल का उपयोग करके सी # में वर्चुअल मशीन लागू की। यह दूसरे के बाद पाठ की रेखाओं को मुद्रित नहीं करता है; यह [इंटरफेस] एक जीयूआई की तरह काम करता है। एक लंबे समय मैं अंत में पाया this example खोजने के बाद http://blogs.msdn.com/b/toub/archive/2006/05/03/589468.aspx?PageIndex=2#comments

Answer 4

:

आप कंसोल पर माउस इनपुट चाहते हैं, इस हुक का प्रयास करें। पृष्ठ पर example program डाउनलोड करें। यह आपको अन्य चीजों के अलावा, कंसोल विंडो (चरित्र-आधारित) में माउस स्थान देता है।

संपादित करें: यह (मेरे NativeMethods वर्ग का हिस्सा) के साथ मेरी ConsoleListener वर्ग है।
आप MouseEvent पर एक हैंडलर संलग्न कर सकते हैं (Start() विधि को कॉल करने के बाद)।

using System; 
using System.Runtime.InteropServices; 
using System.Threading; 
using static ConsoleLib.NativeMethods; 

namespace ConsoleLib 
{ 
    public static class ConsoleListener 
    { 
     public static event ConsoleMouseEvent MouseEvent; 

     public static event ConsoleKeyEvent KeyEvent; 

     public static event ConsoleWindowBufferSizeEvent WindowBufferSizeEvent; 

     private static bool Run = false; 


     public static void Start() 
     { 
      if (!Run) 
      { 
       Run = true; 
       IntPtr handleIn = GetStdHandle(STD_INPUT_HANDLE); 
       new Thread(() => 
       { 
        while (true) 
        { 
         uint numRead = 0; 
         INPUT_RECORD[] record = new INPUT_RECORD[1]; 
         record[0] = new INPUT_RECORD(); 
         ReadConsoleInput(handleIn, record, 1, ref numRead); 
         if (Run) 
          switch (record[0].EventType) 
          { 
           case INPUT_RECORD.MOUSE_EVENT: 
            MouseEvent?.Invoke(record[0].MouseEvent); 
            break; 
           case INPUT_RECORD.KEY_EVENT: 
            KeyEvent?.Invoke(record[0].KeyEvent); 
            break; 
           case INPUT_RECORD.WINDOW_BUFFER_SIZE_EVENT: 
            WindowBufferSizeEvent?.Invoke(record[0].WindowBufferSizeEvent); 
            break; 
          } 
         else 
         { 
          uint numWritten = 0; 
          WriteConsoleInput(handleIn, record, 1, ref numWritten); 
          return; 
         } 
        } 
       }).Start(); 
      } 
     } 

     public static void Stop() => Run = false; 


     public delegate void ConsoleMouseEvent(MOUSE_EVENT_RECORD r); 

     public delegate void ConsoleKeyEvent(KEY_EVENT_RECORD r); 

     public delegate void ConsoleWindowBufferSizeEvent(WINDOW_BUFFER_SIZE_RECORD r); 

    } 


    public static class NativeMethods 
    { 
     public struct COORD 
     { 
      public short X; 
      public short Y; 

      public COORD(short x, short y) 
      { 
       X = x; 
       Y = y; 
      } 
     } 

     [StructLayout(LayoutKind.Explicit)] 
     public struct INPUT_RECORD 
     { 
      public const ushort KEY_EVENT = 0x0001, 
       MOUSE_EVENT = 0x0002, 
       WINDOW_BUFFER_SIZE_EVENT = 0x0004; //more 

      [FieldOffset(0)] 
      public ushort EventType; 
      [FieldOffset(4)] 
      public KEY_EVENT_RECORD KeyEvent; 
      [FieldOffset(4)] 
      public MOUSE_EVENT_RECORD MouseEvent; 
      [FieldOffset(4)] 
      public WINDOW_BUFFER_SIZE_RECORD WindowBufferSizeEvent; 
      /* 
      and: 
      MENU_EVENT_RECORD MenuEvent; 
      FOCUS_EVENT_RECORD FocusEvent; 
      */ 
     } 

     public struct MOUSE_EVENT_RECORD 
     { 
      public COORD dwMousePosition; 

      public const uint FROM_LEFT_1ST_BUTTON_PRESSED = 0x0001, 
       FROM_LEFT_2ND_BUTTON_PRESSED = 0x0004, 
       FROM_LEFT_3RD_BUTTON_PRESSED = 0x0008, 
       FROM_LEFT_4TH_BUTTON_PRESSED = 0x0010, 
       RIGHTMOST_BUTTON_PRESSED = 0x0002; 
      public uint dwButtonState; 

      public const int CAPSLOCK_ON = 0x0080, 
       ENHANCED_KEY = 0x0100, 
       LEFT_ALT_PRESSED = 0x0002, 
       LEFT_CTRL_PRESSED = 0x0008, 
       NUMLOCK_ON = 0x0020, 
       RIGHT_ALT_PRESSED = 0x0001, 
       RIGHT_CTRL_PRESSED = 0x0004, 
       SCROLLLOCK_ON = 0x0040, 
       SHIFT_PRESSED = 0x0010; 
      public uint dwControlKeyState; 

      public const int DOUBLE_CLICK = 0x0002, 
       MOUSE_HWHEELED = 0x0008, 
       MOUSE_MOVED = 0x0001, 
       MOUSE_WHEELED = 0x0004; 
      public uint dwEventFlags; 
     } 

     [StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode)] 
     public struct KEY_EVENT_RECORD 
     { 
      [FieldOffset(0)] 
      public bool bKeyDown; 
      [FieldOffset(4)] 
      public ushort wRepeatCount; 
      [FieldOffset(6)] 
      public ushort wVirtualKeyCode; 
      [FieldOffset(8)] 
      public ushort wVirtualScanCode; 
      [FieldOffset(10)] 
      public char UnicodeChar; 
      [FieldOffset(10)] 
      public byte AsciiChar; 

      public const int CAPSLOCK_ON = 0x0080, 
       ENHANCED_KEY = 0x0100, 
       LEFT_ALT_PRESSED = 0x0002, 
       LEFT_CTRL_PRESSED = 0x0008, 
       NUMLOCK_ON = 0x0020, 
       RIGHT_ALT_PRESSED = 0x0001, 
       RIGHT_CTRL_PRESSED = 0x0004, 
       SCROLLLOCK_ON = 0x0040, 
       SHIFT_PRESSED = 0x0010; 
      [FieldOffset(12)] 
      public uint dwControlKeyState; 
     } 

     public struct WINDOW_BUFFER_SIZE_RECORD 
     { 
      public COORD dwSize; 
     } 

     public const uint STD_INPUT_HANDLE = unchecked((uint)-10), 
      STD_OUTPUT_HANDLE = unchecked((uint)-11), 
      STD_ERROR_HANDLE = unchecked((uint)-12); 

     [DllImport("kernel32.dll")] 
     public static extern IntPtr GetStdHandle(uint nStdHandle); 


     public const uint ENABLE_MOUSE_INPUT = 0x0010, 
      ENABLE_QUICK_EDIT_MODE = 0x0040, 
      ENABLE_EXTENDED_FLAGS = 0x0080, 
      ENABLE_ECHO_INPUT = 0x0004, 
      ENABLE_WINDOW_INPUT = 0x0008; //more 

     [DllImportAttribute("kernel32.dll")] 
     public static extern bool GetConsoleMode(IntPtr hConsoleInput, ref uint lpMode); 

     [DllImportAttribute("kernel32.dll")] 
     public static extern bool SetConsoleMode(IntPtr hConsoleInput, uint dwMode); 


     [DllImportAttribute("kernel32.dll", CharSet = CharSet.Unicode)] 
     public static extern bool ReadConsoleInput(IntPtr hConsoleInput, [Out] INPUT_RECORD[] lpBuffer, uint nLength, ref uint lpNumberOfEventsRead); 

     [DllImportAttribute("kernel32.dll", CharSet = CharSet.Unicode)] 
     public static extern bool WriteConsoleInput(IntPtr hConsoleInput, INPUT_RECORD[] lpBuffer, uint nLength, ref uint lpNumberOfEventsWritten); 

    } 
} 

वह ठीक से काम करने के लिए आप शायद पहली बार इस कोड को निष्पादित करना चाहते हैं, इस फ़ाइल शीर्षक के साथ

IntPtr inHandle = GetStdHandle(STD_INPUT_HANDLE); 
uint mode = 0; 
GetConsoleMode(inHandle, ref mode); 
mode &= ~ENABLE_QUICK_EDIT_MODE; //disable 
mode |= ENABLE_WINDOW_INPUT; //enable (if you want) 
mode |= ENABLE_MOUSE_INPUT; //enable 
SetConsoleMode(inHandle, mode); 

:,

using System; 
using static ConsoleLib.NativeMethods; 

Answer 5

ज्यादा अध्ययन करने के बाद मैं एक समाधान मिला। बटन वर्ग और जीयूआई जो मैंने बनाया है, बटन बनाना संभव है, और इसे क्लिक किया गया है या माउस (यह पूरी तरह से काम नहीं करता है)। और आपको System.Windows.Forms और System आयात करने की आवश्यकता है। ड्रॉइंग।

Answer 6

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Threading.Tasks; 
using Traingames.NetElements; 
//using System.Windows.Forms; 
using System.Drawing; 

namespace ConsoleTools.NET 
{ 
class Program 
{ 
    static ConsoleFramework c = new ConsoleFramework(); 
    static public Point MousePos; 
    static Button One = new Button(); 
    static Pixel Mouse = new Pixel(); 

    static void Main(string[] args) 
    { 
     Console.ForegroundColor = ConsoleColor.White; 
     // t.Draw(10, 40, ConsoleColor.Gray); 
     One.Set(0, 10, "░░1░░", ConsoleColor.Gray); 

     GUI.Add(One); 
     GUI.CalculateOnStart(); 
     for (;;) 
     { 
      MousePos = new Point(System.Windows.Forms.Control.MousePosition.X/(Console.LargestWindowWidth/24), System.Windows.Forms.Control.MousePosition.Y/(Console.LargestWindowHeight/7)); 
      if (One.Pressed(MousePos)) 
      { 
       Console.Write("1"); 
      } 
      // Console.Clear(); 
     } 
    } 
} 
} 

namespace Traingames.NetElements 
{ 
    public class ConsoleFramework 
    { 
    public char[] chars = { '█', '▓', '▒', '░' }; 

    Point MousePos() 
    { 
     return new Point((System.Windows.Forms.Control.MousePosition.X/(Console.LargestWindowWidth/24)) - 100, System.Windows.Forms.Control.MousePosition.Y/(Console.LargestWindowHeight/7)); 
    } 

    public void SetPixel(int x, int Y, ConsoleColor color) 
    { 
     int y = (int)Math.Floor(Y/1.5f); 

     for (int i = 0; i < y; i++) 
     { 
      Console.WriteLine(""); 
     } 

     for (int i = 0; i < x - 1; i++) 
     { 
      Console.Write(" "); 
     } 
     Console.BackgroundColor = color; 
     Console.Write(" "); 
     Console.BackgroundColor = ConsoleColor.Black; 
    } 
} 

public class Pixel : GUI 
{ 
    public void Set(int X, int Y, string text) 
    { 
     ConsoleColor backColor = ConsoleColor.Black; 
     BackColor = backColor; 
     int yyyyyy = (int)Math.Floor(Y/1.5f); 
     Text = text; 
     y = Y; 
     x = X; 
    } 
} 

public class GUI 
{ 
    public int x, y; 
    public static GUI[,] GraphicalUserInterfaces = new GUI[1000, 1000]; 
    public ConsoleColor BackColor; 
    public string Text; 

    public void Draw() 
    { 
     int X = x; 
     int Y = y; 
     ConsoleColor backColor = BackColor; 
     string text = Text; 


     for (int i = 0; i < y; i++) 
     { 
      Console.WriteLine(""); 
     } 

     for (int i = 0; i < x - 1; i++) 
     { 
      Console.Write(" "); 
     } 
     Console.BackgroundColor = BackColor; 
     Console.Write("[" + text + "]"); 
     Console.BackgroundColor = ConsoleColor.Black; 
     Point M = ConsoleTools.NET.Program.MousePos; 

     // return M.X >= xx && M.X <= (xx + Text.Length + 1) && M.Y >= yy && M.Y <= yy + 2 && Control.MouseButtons == MouseButtons.Left; 
    } 
    static GUI Last; 
    public static void Add(GUI gui) 
    { 
     GraphicalUserInterfaces[gui.x, gui.y] = gui; 
    } 

    public static void CalculateOnStart() 
    { 
     for (int x = 0; x < 1000; x++) 
     { 
      for (int y = 0; y < 1000; y++) 
      { 
       if (GraphicalUserInterfaces[x, y] != null) 
       { 

        if (Last != null && y < Last.y) 
        { 
         GraphicalUserInterfaces[x, y].x = Last.x - GraphicalUserInterfaces[x, y].x; 
         GraphicalUserInterfaces[x, y].y = Last.y - GraphicalUserInterfaces[x, y].y; 
        } 
        GraphicalUserInterfaces[x, y].Draw(); 
        GraphicalUserInterfaces[x, y].x = x; 
        GraphicalUserInterfaces[x, y].y = y; 
        Last = GraphicalUserInterfaces[x, y]; 
       } 

      } 
     } 
    } 

} 

public class Button : GUI 
{ 

    public bool Over(Point M) 
    { 
     int yy = ((y * 2) - y/3) + 2; 

     int xx = (x/(Console.LargestWindowWidth/24)) + Text.Length; 

     if (M.X >= xx && M.X <= (xx + Text.Length + 1) && M.Y >= yy && M.Y <= yy + 2) 
      Console.BackgroundColor = ConsoleColor.DarkBlue; 

     return M.X >= xx && M.X <= (xx + Text.Length + 1) && M.Y >= yy && M.Y <= yy + 2; 
    } 

    public bool Pressed(Point M) 
    { 
     int yy = ((y * 2) - y/3) + 1; 

     int xx = (x/(Console.LargestWindowWidth/24)); 

     return M.X >= xx && M.X <= (xx + Text.Length * 1.5f) && M.Y >= yy && M.Y <= yy + 2 && System.Windows.Forms.Control.MouseButtons == System.Windows.Forms.MouseButtons.Left; 
    } 

    public void CalculateClick(Point M) 
    { 
     if (Pressed(M)) 
     { 
      Console.Clear(); 
      Draw(); 
     } 
    } 

    public void Set(int X, int Y, string text, ConsoleColor backColor) 
    { 
     BackColor = backColor; 
     int yyyyyy = (int)Math.Floor(Y/1.5f); 
     Text = text; 
     y = Y; 
     x = X; 

     int xx = (x/(Console.LargestWindowWidth/24)) + Text.Length; 
    } 

} 
}