👨🏿‍🔧 😼 👱 प्रभावशाली सोलिड्स: ओपनजीएल, भाग I के तहत C # में एक गेम बनाना 🍖 💆 💠

वन्स अपॉन ए टाइम इन अमेरिका

एक बार, 2002 में, अमेजिंग ब्लॉक्स नामक एक दिलचस्प खिलौना ने मेरे कंप्यूटर को हिट किया। एक गेम, बोलने के लिए, एक टेट्रिस क्लास (गेमप्ले का विस्तृत विवरण नीचे दिया गया है); वह मेरी मां के बहुत शौकीन थे, जिन्होंने इस खेल को घंटों खेला। हालांकि, एक दुर्भाग्यपूर्ण कमी थी: ऐसा लगता है, 10 शुरू होने के बाद, खेल को पंजीकरण की आवश्यकता शुरू हुई, जो आश्चर्यजनक रूप से, नि: शुल्क था, लेकिन इंटरनेट के माध्यम से, जो, ज़ाहिर है, एक दुर्गम बाधा थी, क्योंकि तब हमारे भागों में कोई इंटरनेट नहीं था। , हालांकि उन्होंने सुना कि ऐसा कुछ है। मुझे लगातार पुनर्स्थापित करना पड़ा।

तीन साल बाद, जब इंटरनेट पहले से ही पूरा हो गया था, और गेम शेयरवेयर बनने में कामयाब हो गया और पंजीकरण के लिए कुछ पैसे मांगने लगा, मैंने इसे रजिस्टर करने की कोशिश की, हालांकि, निर्माता की वेबसाइट उस समय तक जीवित रहने की तुलना में अधिक मृत थी और, जाहिर है, ऐसा ही रहता है आज तक। गेम के शेयरवेयर संस्करण को इंटरनेट पर ढूंढना आसान है, कई हैं, मैं शब्द से डरता नहीं हूं, कीजेंस, जो वास्तव में ट्रोजन हैं, और गेम को पंजीकृत करने का एक भी अवसर नहीं है ताकि माँ इसे पूरी तरह से कंप्यूटर पर खेल सकें। कुछ बिंदु पर, मैंने सोचा: क्यों न केवल एक समान खेल खुद बनाया जाए और जिससे कली में समस्या का समाधान हो? उसी समय, कुछ प्रकार की नमस्ते-दुनिया आधुनिक परिस्थितियों में एक साधारण पीसी गेम विकसित करने से बाहर आ सकती है - जिसे मैं पाठकों के ध्यान में लाता हूं।

तो हम किस तरह का खेल करने जा रहे हैं? बात यह है। एक आयताकार ग्लास 7 × 13 में, एक क्षैतिज छड़ी गिरती है, जिसमें 3 रंग ब्लॉक होते हैं (कुल 5 रंग होते हैं)। आंदोलन के दौरान, इसे दाएं-बाएं स्थानांतरित किया जा सकता है, साथ ही दाएं से बाएं (लाल, हरा, नीला → हरा, नीला, लाल) के रोटेशन में स्वैप ब्लॉक किया जा सकता है। जैसे ही छड़ी कांच के फर्श को छूती है या ग्लास में किसी भी स्थिर ब्लॉक को नियंत्रित नहीं किया जाता है। स्टिक बनाने वाले ब्लॉक अलग-अलग गिरने लगते हैं जब तक कि वे एक निश्चित ब्लॉक या आधा गिलास पर न हों। उसके बाद, यह जांचा जाता है कि क्या कांच में एक ही रंग के तीन या अधिक ब्लॉक की एक क्षैतिज, ऊर्ध्वाधर या विकर्ण रेखा है; ऐसी लाइनें नष्ट हो जाती हैं। यदि नष्ट लाइन के शीर्ष पर ब्लॉक थे, तो वे खाली जगह पर स्लाइड करते हैं जो कि बनाई जाती है, जिसके बाद गठित लाइनें फिर से नष्ट हो जाती हैं। जब सब कुछ शांत हो जाता है, तो ऊपर से एक नई छड़ी गिरने लगती है। नष्ट हो चुकी लाइनों के निर्माण के लिए खिलाड़ी अंक प्राप्त करता है। ग्लास ऊपर से भर जाने पर खेल समाप्त हो जाता है।

प्रौद्योगिकी। हम खेल को सी # में करेंगे (मैं लंबे समय से देखना चाहता हूं कि यह क्या है), ओपनजीएल (डायरेक्टएक्स केवल विंडोज के तहत काम करता है, और मुझे लिनक्स अधिक पसंद है), संस्करण नियंत्रण के लिए मर्क्यूरियल (वीसीएस के बिना कोड लिखना अपने आप में अपमानजनक है)।

गेम को इम्प्रेसिव सॉलिड्स कहा जाएगा।

आरंभ

विंडोज के लिए विकास Microsoft Visual C # 2010 एक्सप्रेस (निशुल्क वितरित) में आयोजित किया जाएगा। हमें Mercurial संस्करण नियंत्रण प्रणाली के विंडोज क्लाइंट TortoiseHg की भी आवश्यकता है। लिनक्स-आधारित सिस्टम के लिए हम MonoDevelop और कंसोल hg का उपयोग करेंगे।

OpenGL कनेक्ट करने के लिए हम बाइंडिंग OpenTK का उपयोग करते हैं । आपको नवीनतम नाइटली बिल्ड (लेखन के समय: 2011-12-03) डाउनलोड करने की आवश्यकता है।

ImpressiveSolids नामक Visual C # Express में एक नया खाली प्रोजेक्ट बनाएँ। सहेजें। फिर परियोजना निर्देशिका खोलें, इसके लिए संदर्भ मेनू को कॉल करें और TortoiseHg → क्रिएट रिपॉजिटरी यहां चुनें। हम .hignore फ़ाइल बनाने और प्रारंभ करने के बाद कार्यक्षेत्र खोलने के बिंदुओं को चिह्नित करते हैं।

Visual C # एक्सप्रेस में .hgignore फ़ाइल खोलें और उसमें निम्न पंक्तियाँ लिखें। यह आवश्यक है ताकि संस्करण नियंत्रण प्रणाली अनावश्यक बाइनरी फ़ाइलों को ध्यान में न रखे।

syntax: glob *.suo *.pidb ImpressiveSolids/bin/* ImpressiveSolids/obj/*

समाधान निर्देशिका के अंदर (प्रोजेक्ट नहीं; जहां .hignignore निहित है), OpenTK उपनिर्देशिका बनाएं और OpenTK * OpenTK \ OpenTK \ रिलीज़ \ डायरेक्टरी से OpenTK *। Dll और OpenTK *। Dll.config फ़ाइलों की प्रतिलिपि बनाएँ।

विज़ुअल सी # एक्सप्रेस में, संदर्भ मेनू संदर्भ → संदर्भ जोड़ें → ब्राउज़ करें। चुनें ../OpenTK/OpenTK.dll। इसके अलावा, आपको .NET टैब से System.Drawing के संदर्भ को जोड़ना होगा।

एक नया Game क्लास बनाएं। यह कार्यक्रम का मुख्य वर्ग है, इसमें प्रवेश बिंदु शामिल है, और वह OpenTK.GameWindow का उत्तराधिकारी है और खेल की स्थिति ( OnUpdateFrame ) और redrawing ( OnUpdateFrame ) को अपडेट करने के लिए जिम्मेदार है। अब यह सिर्फ एक काली खिड़की होगी।

  using System; using OpenTK; using OpenTK.Graphics; using OpenTK.Graphics.OpenGL; namespace ImpressiveSolids { class Game : GameWindow { [STAThread] static void Main() { using (var Game = new Game()) { Game.Run(30); } } public Game() : base(700, 500, GraphicsMode.Default, "Impressive Solids") { VSync = VSyncMode.On; } protected override void OnLoad(EventArgs E) { base.OnLoad(E); } protected override void OnResize(EventArgs E) { base.OnResize(E); GL.Viewport(ClientRectangle.X, ClientRectangle.Y, ClientRectangle.Width, ClientRectangle.Height); } protected override void OnUpdateFrame(FrameEventArgs E) { base.OnUpdateFrame(E); } protected override void OnRenderFrame(FrameEventArgs E) { base.OnRenderFrame(E); GL.ClearColor(Color4.Black); GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit); SwapBuffers(); } } }

प्रोजेक्ट प्रॉपर्टीज़ पर जाएं (प्रोजेक्ट → इम्प्रेसिवसोलिड्स प्रॉपर्टीज़) और टारगेट फ्रेमवर्क निर्दिष्ट करें: .NET फ्रेमवर्क 2.0; आउटपुट प्रकार: विंडोज एप्लीकेशन; स्टार्टअप ऑब्जेक्ट: ImpressiveSolids.Game।

आप सहेज सकते हैं और चला सकते हैं, "प्रभावशाली सॉलिड्स" शीर्षक के साथ 700 × 500 के आकार के साथ एक काली खिड़की दिखाई देनी चाहिए।

यदि सब कुछ सुचारू रूप से चला, तो कछुआ हॉग वर्कबेन्च पर जाएं और "प्रारंभिक गेम विंडो" चिह्न के साथ सब कुछ करें।

गिरना

हमें छड़ी के नियंत्रित गिरने का एहसास होता है। ऐसा करने के लिए, आपको सबसे पहले स्टिक की वर्तमान स्थिति का मॉडल सेट करना होगा। सबसे पहले, स्थिति। डिफ़ॉल्ट रूप से - कांच के शीर्ष पर। हम मानते हैं कि (0; 0) कांच के ऊपरी बाएं कोने से मेल खाती है। वैसे, आपको इसके आयाम MapWidth , MapHeight सेट करने की आवश्यकता है। ब्लॉक के रंग जो स्टिक बनाते हैं, उन्हें पूर्णांक के एक सरणी के रूप में संग्रहीत किया जाएगा; रंग के संभावित रंगों की संख्या निर्धारित करें और इस बात से सहमत हों कि रंग को 0 से ColorsCount − 1 पूर्णांक मान से दर्शाया गया है।

गेम क्लास में नई विधि जोड़ें और इसे ओनलॉड से कॉल करें। इस पद्धति में, हम यादृच्छिक रंगों के ब्लॉक से एक छड़ी के निर्माण को लागू करते हैं।

  private Random Rand; private const int MapWidth = 7; private const int MapHeight = 13; private const int StickLength = 3; private int[] StickColors; private Vector2 StickPosition; private const int ColorsCount = 5; protected override void OnLoad(EventArgs E) { base.OnLoad(E); New(); } private void New() { Rand = new Random(); StickColors = new int[StickLength]; for (var i = 0; i < StickLength; i++) { StickColors[i] = Rand.Next(ColorsCount); } StickPosition.X = (float)Math.Floor((MapWidth - StickLength) / 2d); StickPosition.Y = 0; }

आइए स्क्रीन पर हमारी छड़ी को प्रदर्शित करने का प्रयास करें, जबकि सबसे आदिम संस्करण में (हम एक रंगीन आयत के साथ ब्लॉक खींचते हैं, हम खिड़की के ऊपरी बाएं कोने में सही ग्लास शुरू करते हैं)। हम कोड में कुछ बदलाव करेंगे।

  private const int NominalWidth = 700; private const int NominalHeight = 500; private float ProjectionWidth; private float ProjectionHeight; private const int SolidSize = 35; private Color4[] Colors = {Color4.PaleVioletRed, Color4.LightSeaGreen, Color4.CornflowerBlue, Color4.RosyBrown, Color4.LightGoldenrodYellow}; public Game() : base(NominalWidth, NominalHeight, GraphicsMode.Default, "Impressive Solids") { VSync = VSyncMode.On; } protected override void OnResize(EventArgs E) { base.OnResize(E); GL.Viewport(ClientRectangle.X, ClientRectangle.Y, ClientRectangle.Width, ClientRectangle.Height); ProjectionWidth = NominalWidth; ProjectionHeight = (float)ClientRectangle.Height / (float)ClientRectangle.Width * ProjectionWidth; if (ProjectionHeight < NominalHeight) { ProjectionHeight = NominalHeight; ProjectionWidth = (float)ClientRectangle.Width / (float)ClientRectangle.Height * ProjectionHeight; } } protected override void OnRenderFrame(FrameEventArgs E) { base.OnRenderFrame(E); GL.ClearColor(Color4.Black); GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit); var Projection = Matrix4.CreateOrthographic(-ProjectionWidth, -ProjectionHeight, -1, 1); GL.MatrixMode(MatrixMode.Projection); GL.LoadMatrix(ref Projection); GL.Translate(ProjectionWidth / 2, -ProjectionHeight / 2, 0); var Modelview = Matrix4.LookAt(Vector3.Zero, Vector3.UnitZ, Vector3.UnitY); GL.MatrixMode(MatrixMode.Modelview); GL.LoadMatrix(ref Modelview); GL.Begin(BeginMode.Quads); for (var i = 0; i < StickLength; i++) { RenderSolid(StickPosition.X + i, StickPosition.Y, StickColors[i]); } GL.End(); SwapBuffers(); } private void RenderSolid(float X, float Y, int Color) { GL.Color4(Colors[Color]); GL.Vertex2(X * SolidSize, Y * SolidSize); GL.Vertex2((X + 1) * SolidSize, Y * SolidSize); GL.Vertex2((X + 1) * SolidSize, (Y + 1) * SolidSize); GL.Vertex2(X * SolidSize, (Y + 1) * SolidSize); }

विंडो के आकार के पैमाने के लिए Nominal/Projection Width/Height साथ ट्रिक्स Nominal/Projection Width/Height आवश्यकता थी, लेकिन एक ही समय में, अनुपात विकृत नहीं थे।

अब अंत में स्टिक फॉल करें और ’s, →, (कीज़ वर्क (कलर रोटेशन) करें।

  public Game() : base(NominalWidth, NominalHeight, GraphicsMode.Default, "Impressive Solids") { VSync = VSyncMode.On; Keyboard.KeyDown += new EventHandler<KeyboardKeyEventArgs>(OnKeyDown); } protected override void OnUpdateFrame(FrameEventArgs E) { base.OnUpdateFrame(E); StickPosition.Y += 0.02f; } protected void OnKeyDown(object Sender, KeyboardKeyEventArgs E) { if (Key.Left == E.Key) { --StickPosition.X; } else if (Key.Right == E.Key) { ++StickPosition.X; } else if (Key.Up == E.Key) { var T = StickColors[0]; for (var i = 0; i < StickLength - 1; i++) { StickColors[i] = StickColors[i + 1]; } StickColors[StickLength - 1] = T; } }

सभी परिवर्तन करें: "छड़ी, गिरने और नियंत्रण करने योग्य"।

जैसा कि आप देख सकते हैं, कांच की सीमाओं से परे जाने के लिए कोई जांच नहीं है। हम भविष्य में इस चूक को सुधारेंगे।

दुनिया का एक नक्शा

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

हम पूर्णांक के दो आयामी सरणी के रूप में कांच की स्थिति का अनुकरण करते हैं। निर्देशांक कांच के चेकर ग्रिड के अनुरूप होंगे, मान दिए गए सेल में ब्लॉक का रंग होगा - या सेल खाली होने पर एक ऋणात्मक संख्या।

यहां पहले से ही कांच से परे जाने के लिए छड़ी के लिए एक चेक शुरू करना आवश्यक होगा, अन्यथा गैर-मौजूद सूचक द्वारा सरणी पर कॉल आएंगे।

  private int[,] Map; private void New() { Rand = new Random(); Map = new int[MapWidth, MapHeight]; for (var X = 0; X < MapWidth; X++) { for (var Y = 0; Y < MapHeight; Y++) { Map[X, Y] = -1; } } StickColors = new int[StickLength]; GenerateNextStick(); } private void GenerateNextStick() { for (var i = 0; i < StickLength; i++) { StickColors[i] = Rand.Next(ColorsCount); } StickPosition.X = (float)Math.Floor((MapWidth - StickLength) / 2d); StickPosition.Y = 0; } protected override void OnUpdateFrame(FrameEventArgs E) { base.OnUpdateFrame(E); StickPosition.Y += 0.02f; var FellOnFloor = (StickPosition.Y >= MapHeight - 1); var FellOnBlock = false; if (!FellOnFloor) { var Y = (int)Math.Floor(StickPosition.Y + 1); for (var i = 0; i < StickLength; i++) { var X = (int)StickPosition.X + i; if (Map[X, Y] >= 0) { FellOnBlock = true; break; } } } if (FellOnFloor || FellOnBlock) { var Y = (int)Math.Floor(StickPosition.Y); for (var i = 0; i < StickLength; i++) { var X = (int)StickPosition.X + i; Map[X, Y] = StickColors[i]; } GenerateNextStick(); } } protected void OnKeyDown(object Sender, KeyboardKeyEventArgs E) { if ((Key.Left == E.Key) && (StickPosition.X > 0)) { --StickPosition.X; } else if ((Key.Right == E.Key) && (StickPosition.X + StickLength < MapWidth)) { ++StickPosition.X; } else if (Key.Up == E.Key) { // . . . } } protected override void OnRenderFrame(FrameEventArgs E) { // . . . GL.Begin(BeginMode.Quads); for (var X = 0; X < MapWidth; X++) { for (var Y = 0; Y < MapHeight; Y++) { if (Map[X, Y] >= 0) { RenderSolid(X, Y, Map[X, Y]); } } } for (var i = 0; i < StickLength; i++) { RenderSolid(StickPosition.X + i, StickPosition.Y, StickColors[i]); } GL.End(); SwapBuffers(); }

अब आप जल्दी से ब्लॉक को बहुत ऊपर तक स्केच कर सकते हैं, जैसे कि अच्छे पुराने टेट्रिस में। परीक्षण के लिए, आप 0.02f साथ 0.2f को प्रतिस्थापित करके गिरावट की दर बढ़ा सकते हैं, लेकिन सामान्य तौर पर। कुंजी दबाकर इसे तेज करना संभव होगा।

मरकरी रिपॉजिटरी में बदलाव करना न भूलें: "स्टिक गिरने के बाद फिक्सिंग ब्लॉक"।

दोहरा असर

अगली चीज जो हमें करने की ज़रूरत है वह यह सुनिश्चित करना है कि ब्लॉक हवा में लटका न दें, लेकिन जब तक वे आराम नहीं करते तब तक नीचे गिरते रहें। इस अवधि के दौरान, स्क्रीन पर कोई छड़ी नहीं है, आप कुछ भी नियंत्रित नहीं कर सकते। इस संबंध में, हम खेल में राज्य की अवधारणा को पेश करते हैं।

किसी भी समय खेल निम्नलिखित राज्यों में से एक में है:

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

हम कोड में संबंधित घोषणाएँ करेंगे।

  private enum GameStateEnum { Fall, Impact, GameOver } private GameStateEnum GameState; private void New() { // . . . GenerateNextStick(); GameState = GameStateEnum.Fall; } protected override void OnUpdateFrame(FrameEventArgs E) { base.OnUpdateFrame(E); if (GameStateEnum.Fall == GameState) { StickPosition.Y += 0.2f; // . . . if (FellOnFloor || FellOnBlock) { var Y = (int)Math.Floor(StickPosition.Y); for (var i = 0; i < StickLength; i++) { var X = (int)StickPosition.X + i; Map[X, Y] = StickColors[i]; } GameState = GameStateEnum.Impact; } } else if (GameStateEnum.Impact == GameState) { var Stabilized = true; // TODO   if (Stabilized) { GenerateNextStick(); GameState = GameStateEnum.Fall; } } }

ब्लॉकों के एक चिकनी गिरावट को चित्रित करने और कांच ( Map ) के मॉडल को जटिल नहीं करने के लिए, हम चाल का सहारा लेते हैं। सेल (X; Y) से सेल में आने वाले ब्लॉक (X; Y + 1) को जाने दें - और उसे और कहां गिरना चाहिए? - सेल में सूचीबद्ध (एक्स; वाई) निचले सेल में अंतिम हिट के क्षण तक; और हम अतिरिक्त रूप से ब्लॉक के आंशिक ऊर्ध्वाधर विस्थापन को संग्रहीत करेंगे, जो धीरे-धीरे बढ़ेगा जब तक कि यह एकता से अधिक न हो जाए। यही है, ब्लॉक के वास्तविक निर्देशांक नहीं होंगे (एक्स; वाई), लेकिन (एक्स; वाई + Δ), इसे OnRenderFrame में OnRenderFrame में रखना होगा।

  private const float FallSpeed = 0.2f; private float[,] ImpactFallOffset; private void New() { // . . . ImpactFallOffset = new float[MapWidth, MapHeight]; } protected override void OnUpdateFrame(FrameEventArgs E) { base.OnUpdateFrame(E); if (GameStateEnum.Fall == GameState) { StickPosition.Y += FallSpeed; // . . . } else if (GameStateEnum.Impact == GameState) { var Stabilized = true; for (var X = 0; X < MapWidth; X++) { for (var Y = MapHeight - 2; Y >= 0; Y--) { if ((Map[X, Y] >= 0) && ((Map[X, Y + 1] < 0) || (ImpactFallOffset[X, Y + 1] > 0))) { Stabilized = false; ImpactFallOffset[X, Y] += FallSpeed; if (ImpactFallOffset[X, Y] >= 1) { Map[X, Y + 1] = Map[X, Y]; Map[X, Y] = -1; ImpactFallOffset[X, Y] = 0; } } } } if (Stabilized) { GenerateNextStick(); GameState = GameStateEnum.Fall; } } } protected override void OnRenderFrame(FrameEventArgs E) { // . . . GL.Begin(BeginMode.Quads); for (var X = 0; X < MapWidth; X++) { for (var Y = 0; Y < MapHeight; Y++) { if (Map[X, Y] >= 0) { RenderSolid(X, Y + ImpactFallOffset[X, Y], Map[X, Y]); } } } if (GameStateEnum.Fall == GameState) { for (var i = 0; i < StickLength; i++) { RenderSolid(StickPosition.X + i, StickPosition.Y, StickColors[i]); } } GL.End(); SwapBuffers(); }

ब्लॉक के एक पूरे स्तंभ को गिराने के लिए जिसके तहत एक छेद गिर सकता है, हम नीचे से ऊपर की ओर मैप सेल को सॉर्ट करते हैं (निचला ब्लॉक ऊपरी भाग को वहन करता है) और न केवल सेल के शून्य को ध्यान में रखना चाहिए, बल्कि ImpactFallOffset स्थिति (क्योंकि एक सकारात्मक संख्या का मतलब है कि यह ब्लॉक नीचे गिरता है) )।

प्रतिबद्ध को चिह्नित किया जाता है: "स्थिर होने तक ब्लॉक प्रभाव में आते हैं।"

सामूहिक विनाश का हथियार

अंततः गेमप्ले के मुख्य तत्व से निपटने का समय आ गया है: एक ही रंग की पंक्तिबद्ध लाइनों का विनाश। न्यूनतम लाइन की लंबाई निर्धारित करें। यह उन सभी कोशिकाओं से गुजरने के लिए पर्याप्त है जिनमें ब्लॉक हैं, और प्रत्येक से चार संभावित दिशाओं (क्षैतिज, ऊर्ध्वाधर और दो विकर्ण) में से एक में एक लाइन बनाने की कोशिश की जाती है। यदि पर्याप्त लंबाई के एक रंग की एक रेखा का पता लगाया जाता है, तो प्रत्येक घटक ब्लॉक को स्टैक पर धकेल दिया जाता है। पूरे कार्ड की जांच करने के बाद, हम स्टैक पर सभी ब्लॉकों को नष्ट कर देते हैं और अस्थिर स्थिति को चिह्नित करते हैं।

  private const int DestroyableLength = 3; private Stack<Vector2> Destroyables = new Stack<Vector2>(); protected override void OnUpdateFrame(FrameEventArgs E) { // . . . } else if (GameStateEnum.Impact == GameState) { // . . . if (Stabilized) { Destroyables.Clear(); for (var X = 0; X < MapWidth; X++) { for (var Y = 0; Y < MapHeight; Y++) { CheckDestroyableLine(X, Y, 1, 0); CheckDestroyableLine(X, Y, 0, 1); CheckDestroyableLine(X, Y, 1, 1); CheckDestroyableLine(X, Y, 1, -1); } } if (Destroyables.Count > 0) { foreach (var Coords in Destroyables) { Map[(int)Coords.X, (int)Coords.Y] = -1; } Stabilized = false; } } if (Stabilized) { GenerateNextStick(); GameState = GameStateEnum.Fall; } } } private void CheckDestroyableLine(int X1, int Y1, int DeltaX, int DeltaY) { if (Map[X1, Y1] < 0) { return; } int X2 = X1, Y2 = Y1; var LineLength = 0; while ((X2 >= 0) && (Y2 >= 0) && (X2 < MapWidth) && (Y2 < MapHeight) && (Map[X2, Y2] == Map[X1, Y1])) { ++LineLength; X2 += DeltaX; Y2 += DeltaY; } if (LineLength >= DestroyableLength) { for (var i = 0; i < LineLength; i++) { Destroyables.Push(new Vector2(X1 + i * DeltaX, Y1 + i * DeltaY)); } } }

रिपॉजिटरी में हम चिह्नित करते हैं: "एक ही रंग की लाइनों को नष्ट करना"।

खेल खत्म

आपने संभवतः ग्लास के शीर्ष पर पहुंचने पर गेम के मज़ेदार व्यवहार पर ध्यान दिया: शीर्ष पर वे अलग-अलग रंगों में निमिष करने लगते हैं, एक दूसरे की जगह, अंतहीन रूप से दिखने और तुरंत चिपक जाती हैं। चलो हारने की स्थिति को संभालें: जब तक उपयोगकर्ता Enter कुंजी दबाता है तब तक कुछ भी नहीं होगा।

यहां सब कुछ सरल है।

  protected override void OnUpdateFrame(FrameEventArgs E) { // . . . } else if (GameStateEnum.Impact == GameState) { // . . . if (Stabilized) { var GameOver = false; for (var X = 0; X < MapWidth; X++) { if (Map[X, 0] >= 0) { GameOver = true; break; } } if (GameOver) { GameState = GameStateEnum.GameOver; } else { GenerateNextStick(); GameState = GameStateEnum.Fall; } } } } protected void OnKeyDown(object Sender, KeyboardKeyEventArgs E) { if (GameStateEnum.Fall == GameState) { if ((Key.Left == E.Key) && (StickPosition.X > 0)) { --StickPosition.X; } else if ((Key.Right == E.Key) && (StickPosition.X + StickLength < MapWidth)) { ++StickPosition.X; } else if (Key.Up == E.Key) { var T = StickColors[0]; for (var i = 0; i < StickLength - 1; i++) { StickColors[i] = StickColors[i + 1]; } StickColors[StickLength - 1] = T; } } else if (GameStateEnum.GameOver == GameState) { if ((Key.Enter == E.Key) || (Key.KeypadEnter == E.Key)) { New(); } } }

प्रतिबद्ध, बिना आगे की हलचल के, हस्ताक्षर करके: "गेम ओवर।"

इस पर, विकास का पहला भाग पूरा हो गया है। हमारे हाथों में एक पूरी तरह कार्यात्मक खेल है जिसे आप अभी खेल सकते हैं। दूसरे भाग में हम डिजाइन में लगे रहेंगे। हम बनावट लगाते हैं, हम वर्तमान स्कोर, एक रिकॉर्ड स्कोर दिखाएंगे; छड़ी जो अगले गिर जाएगी। अंत में, हम गेम विंडो में ग्लास की छवि को केंद्र में रखते हैं, इसकी सीमाओं को चित्रित करते हैं। सामान्य तौर पर, हम सब कुछ दिमाग में लाएंगे।

परियोजना पर उपलब्ध है ~~Google प्रोजेक्ट होस्टिंग~~ Bitbucket , वहां आप अंतिम स्रोत कोड देख सकते हैं, संग्रह को चलाने के लिए तैयार निष्पादन योग्य डाउनलोड कर सकते हैं।

प्रभावशाली सोलिड्स: ओपनजीएल, भाग I के तहत C # में एक गेम बनाना