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

टेट्रिस-जैसे गेम प्रभावशाली सोलिड्स के विकास के पहले भाग में , हमने गेमप्ले के थोक को लागू किया, आवेदन की उपस्थिति पर न्यूनतम ध्यान दिया। हमने ओपनजीएल का उपयोग लगभग नहीं किया है, हमने सिर्फ एक रंगीन आयत बनाकर किया है। यह डिजाइन में शामिल होने का समय है, साथ ही स्कोरिंग को लागू करने और एक उच्च स्कोर रखने के लिए। खैर, आगे चलते हैं।

यह चित्र

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

लेकिन पहले, मैं एक बहुत महत्वपूर्ण बारीकियों पर ध्यान देता हूं। OpenGL 2.0 से पहले, प्रत्येक बनावट का आकार दो की शक्ति के बराबर होना था (यानी 64 × 64, 512 × 256; ये POT बनावट हैं, दो की अंग्रेजी शक्ति से)। यदि वीडियो कार्ड या वीडियो कार्ड ड्राइवर द्वारा मनमाने आकार (एनपीओटी बनावट) के बनावट का समर्थन नहीं किया जाता है, तो ऐसी बनावट काम नहीं करेगी। यह मामला है, उदाहरण के लिए, विंडोज एक्सपी के तहत इंटेल एकीकृत वीडियो कार्ड के लिए।

यह सुनिश्चित करने के लिए कि आप इस समस्या से सुरक्षित हैं, सबसे आसान और सबसे सुविधाजनक समाधान हमेशा पॉट बनावट का उपयोग करना है। हालांकि, यह हमेशा संभव नहीं होता है, और आगे, जब हम पाठ के निष्कर्ष पर पहुंचते हैं, तो हमें इस क्षण से निपटना होगा।

इसलिए, हम GIMP में एक खाली (सफेद) छवि 512 × 512 बनाते हैं, फिर: फिल्टर → कलात्मक → कैनवस लागू करें, फिर: फ़िल्टर → मानचित्र → निर्बाध बनाएं। सब कुछ, background.png तैयार है।

हम ब्लॉकों को संगमरमर की गेंदों के रूप में चित्रित करने की कोशिश करेंगे, डैनियल केचम हमें इसमें मदद करेंगे । 300 × 300 कहीं पारदर्शी छवि बनाएं, कैनवास के पूरे व्यास के लिए एक गोल चयन करें। टूल बकेट भरण → पैटर्न भरण → चयन बनावट संगमरमर # 1, सर्कल भरें। अगला: फ़िल्टर्स → डिस्टॉर्ट → लेंस विरूपण, मुख्य को अधिकतम और एज को न्यूनतम, ठीक है। फिर: फ़िल्टर्स → लाइट एंड शैडो → लाइटिंग इफेक्ट्स, तीन-आयामी गेंद के प्रभाव को बनाने के लिए लाइट सेट करें। फसल ताकि खाली खेत न हों। 256 × 256 के आकार के पैमाने। फिर, कलर्स → Colorize का उपयोग करते हुए, पांच अलग-अलग रंगों (Hue) को बनाएं और 0.png, 1.png ... 4.png के रूप में सहेजें (याद रखें कि गेम मॉडल में हमने ब्लॉकों के विभिन्न रंगों को शून्य से शुरू होने वाले पूर्णांक के रूप में नामित करने का निर्णय लिया था)।

अब हमें इन फाइलों को विजुअल C # एक्सप्रेस / मोनो-डिवेलप प्रोजेक्ट में लाने की जरूरत है। सबसे पहले, संदर्भ मेनू के माध्यम से, बनावट नामक एक नया फ़ोल्डर बनाएं, और इसमें - ठोस। फाइल मैनेजर के माध्यम से, हम बैकग्राउंड.पिंग फाइल को टेक्सचर और 0.png ... 4.Png फाइल को टेक्सचर / सॉलिड में रखते हैं। विकास वातावरण में संदर्भ मेनू का उपयोग करके, इन फ़ाइलों को उचित फ़ोल्डर में प्रोजेक्ट में जोड़ें।

उसके बाद, सभी * .png फ़ाइलों के लिए प्रोजेक्ट में, गुण खोलें और सेट करें क्रिया: सामग्री; आउटपुट निर्देशिका की प्रतिलिपि: यदि नया है तो कॉपी करें।

OpenGL में बनावट सक्षम करें। OpenGL स्वयं ग्राफिक फ़ाइलों के साथ काम नहीं करता है, आपको अपने स्वयं के साधनों का उपयोग करने की आवश्यकता है ( System.Drawing.Bitmap मदद करेगा), मेमोरी में बनावट को लोड करने के लिए, इससे बाइनरी बिटमैप प्राप्त करें और इसे OpenGL में स्थानांतरित करें, जो इसकी मेमोरी में बनावट को बचाएगा। भविष्य में, आप पूर्णांक हैंडल के माध्यम से बनावट तक पहुंच सकते हैं (जिसे पहले आरक्षित होना चाहिए)।

इस तंत्र को एक नए Texture वर्ग के रूप में समझाया गया है।

 using System; using System.Drawing; using System.Drawing.Imaging; using OpenTK.Graphics.OpenGL; namespace ImpressiveSolids { public class Texture : IDisposable { public int GlHandle { get; protected set; } public int Width { get; protected set; } public int Height { get; protected set; } public Texture(Bitmap Bitmap) { GlHandle = GL.GenTexture(); Bind(); Width = Bitmap.Width; Height = Bitmap.Height; var BitmapData = Bitmap.LockBits(new Rectangle(0, 0, Bitmap.Width, Bitmap.Height), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb); GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, BitmapData.Width, BitmapData.Height, 0, OpenTK.Graphics.OpenGL.PixelFormat.Bgra, PixelType.UnsignedByte, BitmapData.Scan0); Bitmap.UnlockBits(BitmapData); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear); } public void Bind() { GL.BindTexture(TextureTarget.Texture2D, GlHandle); } #region Disposable private bool Disposed = false; public void Dispose() { Dispose(true); GC.SuppressFinalize(this); } protected virtual void Dispose(bool Disposing) { if (!Disposed) { if (Disposing) { GL.DeleteTexture(GlHandle); } Disposed = true; } } ~Texture() { Dispose(false); } #endregion } } 

Game बनावट लोड करें।

 using System.Drawing; // . . . private Texture TextureBackground; private Texture[] ColorTextures = new Texture[ColorsCount]; public Game() : base(NominalWidth, NominalHeight, GraphicsMode.Default, "Impressive Solids") { VSync = VSyncMode.On; Keyboard.KeyDown += new EventHandler<KeyboardKeyEventArgs>(OnKeyDown); TextureBackground = new Texture(new Bitmap("textures/background.png")); for (var i = 0; i < ColorsCount; i++) { ColorTextures[i] = new Texture(new Bitmap("textures/solids/" + i + ".png")); } } 

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

 protected override void OnLoad(EventArgs E) { base.OnLoad(E); GL.Enable(EnableCap.Texture2D); GL.Enable(EnableCap.Blend); GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha); New(); } protected override void OnRenderFrame(FrameEventArgs E) { // . . . GL.LoadMatrix(ref Modelview); RenderBackground(); 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]); } } SwapBuffers(); } private void RenderBackground() { TextureBackground.Bind(); GL.Color4(Color4.White); GL.Begin(BeginMode.Quads); GL.TexCoord2(0, 0); GL.Vertex2(0, 0); GL.TexCoord2((float)ClientRectangle.Width / TextureBackground.Width, 0); GL.Vertex2(ProjectionWidth, 0); GL.TexCoord2((float)ClientRectangle.Width / TextureBackground.Width, (float)ClientRectangle.Height / TextureBackground.Height); GL.Vertex2(ProjectionWidth, ProjectionHeight); GL.TexCoord2(0, (float)ClientRectangle.Height / TextureBackground.Height); GL.Vertex2(0, ProjectionHeight); GL.End(); } private void RenderSolid(float X, float Y, int Color) { ColorTextures[Color].Bind(); GL.Color4(Color4.White); GL.Begin(BeginMode.Quads); GL.TexCoord2(0, 0); GL.Vertex2(X * SolidSize, Y * SolidSize); GL.TexCoord2(1, 0); GL.Vertex2((X + 1) * SolidSize, Y * SolidSize); GL.TexCoord2(1, 1); GL.Vertex2((X + 1) * SolidSize, (Y + 1) * SolidSize); GL.TexCoord2(0, 1); GL.Vertex2(X * SolidSize, (Y + 1) * SolidSize); GL.End(); } 

दिए गए रंग, जैसा कि यह था, रंग, बनावट को टोन करते हैं, इसलिए हम एक सफेद रंग निर्दिष्ट करते हैं।

महान, बनावट काम करते हैं। प्रतिबद्ध: "बनावट पृष्ठभूमि और ठोस"।

मुख्य सड़क

अब आपको कांच की पहचान करने की आवश्यकता है। इसे खिड़की की पृष्ठभूमि पर सिर्फ एक काला आयत होने दें, लेकिन ब्लॉक के पीछे।

 private void RenderPipe() { GL.Disable(EnableCap.Texture2D); GL.Color4(Color4.Black); GL.Begin(BeginMode.Quads); GL.Vertex2(0, 0); GL.Vertex2(MapWidth * SolidSize, 0); GL.Vertex2(MapWidth * SolidSize, MapHeight * SolidSize); GL.Vertex2(0, MapHeight * SolidSize); GL.End(); GL.Enable(EnableCap.Texture2D); } protected override void OnRenderFrame(FrameEventArgs E) { // . . . RenderBackground(); RenderPipe(); // . . . } 

कांच की स्थिति। इसे खिड़की के किनारों से थोड़ा सा इंडेंटेशन के साथ बाईं ओर होने दें। ग्लास के दाईं ओर बाद में हम अतिरिक्त इंटरफ़ेस तत्व (खाता, आदि) रखेंगे। हालांकि, अगर खिड़की को चौड़ाई में बढ़ाया जाता है, तो कांच को खिड़की के केंद्र की ओर दाईं ओर बढ़ाएं, अन्यथा दाईं ओर बहुत अधिक खाली जगह होगी। अंत में, हम विंडो को NominalWidth × NominalHeight (यह, हालांकि, एक्स विंडो सिस्टम के तहत काम नहीं करेगा) से छोटा बनाने पर NominalWidth ।

 private const int NominalWidth = 500; private const int NominalHeight = 500; protected override void OnResize(EventArgs E) { // . . . if (ClientSize.Width < NominalWidth) { ClientSize = new Size(NominalWidth, ClientSize.Height); } if (ClientSize.Height < NominalHeight) { ClientSize = new Size(ClientSize.Width, NominalHeight); } } protected override void OnRenderFrame(FrameEventArgs E) { // . . . RenderBackground(); var PipeMarginY = (ProjectionHeight - MapHeight * SolidSize) / 2f; var PipeMarginX = (NominalHeight - MapHeight * SolidSize) / 2f; var Overwidth = ProjectionWidth - ProjectionHeight * (float)NominalWidth / NominalHeight; if (Overwidth > 0) { GL.Translate(Math.Min(Overwidth, (ProjectionWidth - MapWidth * SolidSize) / 2f), PipeMarginY, 0); } else { GL.Translate(PipeMarginX, PipeMarginY, 0); } RenderPipe(); // . . . } 

प्रतिबद्ध: "स्थिति और रेंडर पाइप"।

दीवार पर लिखना

कांच के दाईं ओर क्या होगा? चार तत्व: अगली छड़ी; खेल की स्थिति (एक संदेश "बजाना", "रुका हुआ" या "गेम ओवर" होगा); चालू खाता; रिकॉर्ड स्कोर।

इसमें से अधिकांश पाठ है, इसलिए हमें यह जानने की आवश्यकता है कि ओपनग्ल का उपयोग करके पाठ को कैसे आउटपुट किया जाए। OpenGL स्वयं नहीं करता है। अक्सर इस तथ्य के संदर्भ होते हैं कि ओपनटीके के पास इस उद्देश्य के लिए एक सुविधाजनक TextPrinter क्लास है। यह बहुत पहले की बात है और सच नहीं है। अब पाठ प्रदर्शित करने के लिए अनुशंसित विधि इस प्रकार है: पाठ के साथ एक बिटमैप बनाओ ( System.Drawing.Graphics.DrawString या अन्य साधनों का System.Drawing.Graphics.DrawString करके) और इसे एक बनावट की तरह खींचें।

चलिए अपना खुद का TextRenderer क्लास TextRenderer , जो एक Bitmap और फिर उसके आधार पर एक TextRenderer बनाएगा। लेकिन सबसे पहले, आपको एनपीओटी-आयामी बनावट की उपरोक्त समस्या के बारे में चिंता करनी होगी, क्योंकि हम पहले से नहीं जानते हैं कि गतिशील रूप से निर्मित शिलालेख किस आकार का मिलेगा। विधि काफी सरल है: यदि एनपीओटी बनावट का समर्थन नहीं किया जाता है, तो आपको चित्र लोड करते समय पॉट-आकार की बनावट बनाने की आवश्यकता होती है, जैसे कि खेतों के साथ। उदाहरण के लिए, यदि हम 300 × 200 चित्र अपलोड करते हैं, तो हम एक 512 × 256 बनावट उत्पन्न करते हैं, जिस पर हमारा चित्र ऊपरी बाएँ कोने में होगा, और शेष स्थान खाली होगा। और बनावट को लागू करते समय, यह ध्यान रखना आवश्यक होगा कि तस्वीर के निचले बाएं कोने में निर्देशांक नहीं है (1; 1), लेकिन (300/512; 200/256)।

 public class Texture : IDisposable { public int GlHandle { get; protected set; } public int Width { get; protected set; } public int Height { get; protected set; } #region NPOT private static bool? CalculatedSupportForNpot; public static bool NpotIsSupported { get { if (!CalculatedSupportForNpot.HasValue) { CalculatedSupportForNpot = false; int ExtensionsCount; GL.GetInteger(GetPName.NumExtensions, out ExtensionsCount); for (var i = 0; i < ExtensionsCount; i++) { if ("GL_ARB_texture_non_power_of_two" == GL.GetString(StringName.Extensions, i)) { CalculatedSupportForNpot = true; break; } } } return CalculatedSupportForNpot.Value; } } public int PotWidth { get { return NpotIsSupported ? Width : (int)Math.Pow(2, Math.Ceiling(Math.Log(Width, 2))); } } public int PotHeight { get { return NpotIsSupported ? Height : (int)Math.Pow(2, Math.Ceiling(Math.Log(Height, 2))); } } #endregion public Texture(Bitmap Bitmap) { // . . . var BitmapData = Bitmap.LockBits(new Rectangle(0, 0, Bitmap.Width, Bitmap.Height), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb); GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, PotWidth, PotHeight, 0, OpenTK.Graphics.OpenGL.PixelFormat.Bgra, PixelType.UnsignedByte, IntPtr.Zero); GL.TexSubImage2D(TextureTarget.Texture2D, 0, 0, 0, BitmapData.Width, BitmapData.Height, OpenTK.Graphics.OpenGL.PixelFormat.Bgra, PixelType.UnsignedByte, BitmapData.Scan0); Bitmap.UnlockBits(BitmapData); // . . . } // . . . } 

अब - TextRenderer । कोड लंबा लगता है, लेकिन यह वास्तव में सरल है। यहां हम चार बुनियादी चीजें करते हैं: पाठ मापदंडों को सेट करें, इसके आकार को मापें, पाठ को बनावट में खींचें और अंत में, बनावट को एक पारदर्शी आयत पर थोपें।

 using System; using System.Drawing; using System.Drawing.Text; using OpenTK.Graphics; using OpenTK.Graphics.OpenGL; namespace ImpressiveSolids { class TextRenderer { private Font FontValue; private string LabelValue; private bool NeedToCalculateSize, NeedToRenderTexture; private Texture Texture; private int CalculatedWidth, CalculatedHeight; public Font Font { get { return FontValue; } set { FontValue = value; NeedToCalculateSize = true; NeedToRenderTexture = true; } } public string Label { get { return LabelValue; } set { if (value != LabelValue) { LabelValue = value; NeedToCalculateSize = true; NeedToRenderTexture = true; } } } public int Width { get { if (NeedToCalculateSize) { CalculateSize(); } return CalculatedWidth; } } public int Height { get { if (NeedToCalculateSize) { CalculateSize(); } return CalculatedHeight; } } public Color4 Color = Color4.Black; public TextRenderer(Font Font) { this.Font = Font; } public TextRenderer(Font Font, Color4 Color) { this.Font = Font; this.Color = Color; } public TextRenderer(Font Font, string Label) { this.Font = Font; this.Label = Label; } public TextRenderer(Font Font, Color4 Color, string Label) { this.Font = Font; this.Color = Color; this.Label = Label; } private void CalculateSize() { using (var Bitmap = new Bitmap(1, 1)) { using (Graphics Graphics = Graphics.FromImage(Bitmap)) { var Measures = Graphics.MeasureString(Label, Font); CalculatedWidth = (int)Math.Ceiling(Measures.Width); CalculatedHeight = (int)Math.Ceiling(Measures.Height); } } NeedToCalculateSize = false; } public void Render() { if ((null == Label) || ("" == Label)) { return; } if (NeedToRenderTexture) { using (var Bitmap = new Bitmap(Width, Height)) { var Rectangle = new Rectangle(0, 0, Bitmap.Width, Bitmap.Height); using (Graphics Graphics = Graphics.FromImage(Bitmap)) { Graphics.Clear(System.Drawing.Color.Transparent); Graphics.TextRenderingHint = TextRenderingHint.AntiAliasGridFit; Graphics.DrawString(Label, Font, Brushes.White, Rectangle); if (null != Texture) { Texture.Dispose(); } Texture = new Texture(Bitmap); } } NeedToRenderTexture = false; } Texture.Bind(); GL.Color4(Color); GL.Begin(BeginMode.Quads); GL.TexCoord2(0, 0); GL.Vertex2(0, 0); GL.TexCoord2((float)Texture.Width / Texture.PotWidth, 0); GL.Vertex2(Width, 0); GL.TexCoord2((float)Texture.Width / Texture.PotWidth, (float)Texture.Height / Texture.PotHeight); GL.Vertex2(Width, Height); GL.TexCoord2(0, (float)Texture.Height / Texture.PotHeight); GL.Vertex2(0, Height); GL.End(); } } } 

हम कांच के दाईं ओर कुछ निकालते हैं।

 using System.Drawing.Text; // . . . private int Score; private int HighScore; private TextRenderer NextStickLabel, ScoreLabel, ScoreRenderer, HighScoreLabel, HighScoreRenderer, GameOverLabel, GameOverHint; public Game() // . . . var LabelFont = new Font(new FontFamily(GenericFontFamilies.SansSerif), 20, GraphicsUnit.Pixel); var LabelColor = Color4.SteelBlue; NextStickLabel = new TextRenderer(LabelFont, LabelColor, "Next"); ScoreLabel = new TextRenderer(LabelFont, LabelColor, "Score"); HighScoreLabel = new TextRenderer(LabelFont, LabelColor, "High score"); var ScoreFont = new Font(new FontFamily(GenericFontFamilies.SansSerif), 50, GraphicsUnit.Pixel); var ScoreColor = Color4.Tomato; ScoreRenderer = new TextRenderer(ScoreFont, ScoreColor); HighScoreRenderer = new TextRenderer(ScoreFont, ScoreColor); var GameStateFont = new Font(new FontFamily(GenericFontFamilies.SansSerif), 30, GraphicsUnit.Pixel); var GameStateColor = Color4.Tomato; GameOverLabel = new TextRenderer(GameStateFont, GameStateColor, "Game over"); var GameStateHintFont = new Font(new FontFamily(GenericFontFamilies.SansSerif), 25, GraphicsUnit.Pixel); var GameStateHintColor = Color4.SteelBlue; GameOverHint = new TextRenderer(GameStateHintFont, GameStateHintColor, "Press Enter"); } protected override void OnRenderFrame(FrameEventArgs E) { // . . . GL.Translate(MapWidth * SolidSize + PipeMarginX, 0, 0); NextStickLabel.Render(); // TODO   next stick GL.Translate(0, MapHeight * SolidSize / 4f, 0); if (GameStateEnum.GameOver == GameState) { GameOverLabel.Render(); GL.Translate(0, GameOverLabel.Height, 0); GameOverHint.Render(); GL.Translate(0, -GameOverLabel.Height, 0); } GL.Translate(0, MapHeight * SolidSize / 4f, 0); ScoreLabel.Render(); GL.Translate(0, ScoreLabel.Height, 0); ScoreRenderer.Label = Score.ToString(); ScoreRenderer.Render(); GL.Translate(0, -ScoreLabel.Height, 0); GL.Translate(0, MapHeight * SolidSize / 4f, 0); HighScoreLabel.Render(); GL.Translate(0, HighScoreLabel.Height, 0); HighScoreRenderer.Label = HighScore.ToString(); HighScoreRenderer.Render(); SwapBuffers(); } 

MapHeight * SolidSize / 4f कांच की ऊंचाई का एक चौथाई है, हर बार जब हम चार इंटरफ़ेस तत्वों में से एक को चित्रित करने के लिए इस दूरी को कम करते हैं। इसके अलावा, शिलालेख प्रदर्शित करते हुए, हम इसकी ऊंचाई तक जाते हैं, और फिर शुरुआती बिंदु पर वापस चढ़ना नहीं भूलते हैं।

प्रतिबद्ध: "पाठ जीयूआई"।

अगला

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

 private int[] NextStickColors; private void GenerateNextStick() { for (var i = 0; i < StickLength; i++) { StickColors[i] = NextStickColors[i]; NextStickColors[i] = Rand.Next(ColorsCount); } StickPosition.X = (float)Math.Floor((MapWidth - StickLength) / 2d); StickPosition.Y = 0; } private void New() { // . . . StickColors = new int[StickLength]; NextStickColors = new int[StickLength]; GenerateNextStick(); GenerateNextStick(); // because 1st call makes current stick all zeros GameState = GameStateEnum.Fall; } 

प्रदर्शित करने के लिए, हम RenderSolid विधि का उपयोग करते हैं, सब कुछ बहुत सरल है।

 protected override void OnRenderFrame(FrameEventArgs E) { // . . . NextStickLabel.Render(); GL.Translate(0, NextStickLabel.Height, 0); RenderNextStick(); GL.Translate(0, -NextStickLabel.Height, 0); // . . . } public void RenderNextStick() { GL.Disable(EnableCap.Texture2D); GL.Color4(Color4.Black); GL.Begin(BeginMode.Quads); GL.Vertex2(0, 0); GL.Vertex2(StickLength * SolidSize, 0); GL.Vertex2(StickLength * SolidSize, SolidSize); GL.Vertex2(0, SolidSize); GL.End(); GL.Enable(EnableCap.Texture2D); for (var i = 0; i < StickLength; i++) { RenderSolid(i, 0, NextStickColors[i]); } } 

किया, प्रतिबद्ध: "अगली छड़ी छड़ी"।

स्कोर

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

नीचे दिए गए फ़ार्मुलों को ऑफ़हैंड प्रदर्शित किया गया है, निश्चित रूप से, उन्हें खिलाड़ी की समीक्षाओं को देखने के लिए बीटा परीक्षण चरण में जांचना होगा।

 private int TotalDestroyedThisMove; private void New() { // . . . Score = 0; TotalDestroyedThisMove = 0; } protected override void OnUpdateFrame(FrameEventArgs E) { // . . . if (Destroyables.Count > 0) { foreach (var Coords in Destroyables) { Map[(int)Coords.X, (int)Coords.Y] = -1; } Score += (int)Math.Ceiling(Destroyables.Count + Math.Pow(1.5, Destroyables.Count - 3) - 1) + TotalDestroyedThisMove; TotalDestroyedThisMove += Destroyables.Count; Stabilized = false; } // . . . GenerateNextStick(); TotalDestroyedThisMove = 0; GameState = GameStateEnum.Fall; // . . . } 

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

 using System.IO; // . . . private string HighScoreFilename; public Game() { // . . . var ConfigDirectory = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + Path.DirectorySeparatorChar + "ImpressiveSolids"; if (!Directory.Exists(ConfigDirectory)) { Directory.CreateDirectory(ConfigDirectory); } HighScoreFilename = ConfigDirectory + Path.DirectorySeparatorChar + "HighScore.dat"; if (File.Exists(HighScoreFilename)) { using (var Stream = new FileStream(HighScoreFilename, FileMode.Open)) { using (var Reader = new BinaryReader(Stream)) { try { HighScore = Reader.ReadInt32(); } catch (IOException) { HighScore = 0; } } } } else { HighScore = 0; } } protected override void OnUpdateFrame(FrameEventArgs E) { // . . . if (GameOver) { GameState = GameStateEnum.GameOver; if (Score > HighScore) { HighScore = Score; using (var Stream = new FileStream(HighScoreFilename, FileMode.Create)) { using (var Writer = new BinaryWriter(Stream)) { Writer.Write(HighScore); } } } } else { // . . . } 

प्रतिबद्ध: "स्कोर की गणना, उच्च स्कोर का भंडारण।"

स्वर्ग ठहर सकता है

अंत में, हम खेल को रोकना संभव बना देंगे।

आप एक राज्य ( GameStateEnum ) के रूप में विराम देने में सक्षम नहीं होंगे, क्योंकि आप स्टिक के गिरने ( Fall ) के दौरान और Impact दौरान दोनों खेल को रोक सकते हैं, और विराम से खेल को राज्य में वापस आ जाना चाहिए।

इसलिए, हम OnUpdateFrame , OnKeyDown , OnKeyDown में अतिरिक्त OnUpdateFrame ध्वज और इसके प्रसंस्करण का परिचय देते हैं।

 private bool Paused; private TextRenderer PauseLabel, UnpauseHint, PlayingGameLabel, PauseHint; public Game() // . . . var GameStateFont = new Font(new FontFamily(GenericFontFamilies.SansSerif), 30, GraphicsUnit.Pixel); var GameStateColor = Color4.Tomato; GameOverLabel = new TextRenderer(GameStateFont, GameStateColor, "Game over"); PauseLabel = new TextRenderer(GameStateFont, GameStateColor, "Pause"); PlayingGameLabel = new TextRenderer(GameStateFont, GameStateColor, "Playing"); var GameStateHintFont = new Font(new FontFamily(GenericFontFamilies.SansSerif), 25, GraphicsUnit.Pixel); var GameStateHintColor = Color4.SteelBlue; GameOverHint = new TextRenderer(GameStateHintFont, GameStateHintColor, "Press Enter"); UnpauseHint = new TextRenderer(GameStateHintFont, GameStateHintColor, "Press Space"); PauseHint = new TextRenderer(GameStateHintFont, GameStateHintColor, "Space pauses"); } protected override void OnLoad(EventArgs E) { base.OnLoad(E); GL.Enable(EnableCap.Texture2D); GL.Enable(EnableCap.Blend); GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha); New(); Paused = true; } protected override void OnUpdateFrame(FrameEventArgs E) { base.OnUpdateFrame(E); if (Paused) { return; } // . . . } protected void OnKeyDown(object Sender, KeyboardKeyEventArgs E) { if ((GameStateEnum.Fall == GameState) && !Paused) { // . . . } if (((GameStateEnum.Fall == GameState) || (GameStateEnum.Impact == GameState)) && (Key.Space == E.Key)) { Paused = !Paused; } } protected override void OnRenderFrame(FrameEventArgs E) { // . . . GL.Translate(0, MapHeight * SolidSize / 4f, 0); if (GameStateEnum.GameOver == GameState) { GameOverLabel.Render(); GL.Translate(0, GameOverLabel.Height, 0); GameOverHint.Render(); GL.Translate(0, -GameOverLabel.Height, 0); } else if (Paused) { PauseLabel.Render(); GL.Translate(0, PauseLabel.Height, 0); UnpauseHint.Render(); GL.Translate(0, -PauseLabel.Height, 0); } else { PlayingGameLabel.Render(); GL.Translate(0, PlayingGameLabel.Height, 0); PauseHint.Render(); GL.Translate(0, -PlayingGameLabel.Height, 0); } // . . . } 

आवेदन शुरू करते समय, यह एक नया खेल शुरू करने के लिए सुविधाजनक है (खिलाड़ी के लिए) जब इसे रोका जाता है।

हम एक स्थान का उपयोग करते हैं, न कि ठहराव कुंजी, क्योंकि ठहराव के विपरीत, अंतरिक्ष अधिक सुविधाजनक और हमेशा याद किया जाता है, जिसके बारे में बहुत से लोगों को पता भी नहीं है। इसके अलावा, उत्तरार्द्ध के साथ समस्याएं हैं, विशेष रूप से पुंटो स्विचर का उपयोग करते समय।

प्रतिबद्ध: "रोकें"।

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

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