Project Overview

C# Space Shooter with BrainPad Pulse

Embark on an exciting journey into the Games domain with our C# Space Shooter, seamlessly integrated with the BrainPad Pulse microcomputer. This project showcases the compatibility between C# programming and BrainPad microcomputers, bringing the game development field’s timeless excitement with the electronic circuits and microcomputers.

How It Works

the spaceship will move on the X-axis, navigating randomly while taking on three aliens. Armed with one bullet at a time, you must shoot the aliens to prevent them from reaching your space. Be cautious; each alien breach costs you one of your three lives.

Hardware Requirements

The Enjoy a straightforward setup with minimal hardware requirements – all you need is a BrainPad Pulse and a standard USB cable for a quick and easy connection.

Software Requirements

Executing this project successfully requires installing the DUE Link library, from NuGet.org so go to Package Manager Console then using the command:

install-package GHIElectronics.DUELink

The provided library is implemented in C#, but the user can use any .NET system, such as Visual Basic, Visual Studio.

Code Overview

The first C# module named Sprite.cs within the SpriteMasterGame namespace. Let’s break down the key components of this class:

Properties:

  • Name: A property representing the name of the sprite.
  • X and Y: Properties representing the coordinates of the sprite on a 2D plane.
  • Height and Width: Properties representing the height and width of the sprite.
  • Image: An array of integers representing the image data of the sprite.
  • Character: A property representing a character associated with the sprite.

Constructors:

  • Sprite(): Default constructor with no parameters.
  • Sprite(string name, int x, int y, int height, int width, int[] image): A constructor with parameters to initialize the Name, X, Y, Height, Width, and Image properties.
  • Sprite(string name, int x, int y, int height, int width): Another constructor with parameters to initialize Name, X, Y, Height, and Width properties. However, it does not initialize the Image property.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SpriteMasterGame
{
    internal class Sprite
    {
        public string Name { get; set; }
        public int X { get; set; }
        public int Y { get; set; }

        public int Height { get; set; }
        public int Width { get; set; }

        public int[] Image { get; set; }

        public char Character { get; set; }

        public Sprite() { }

        public Sprite(string name, int x, int y, int height, int width, int[] image)

        {
            name = Name;
            x = X;
            y = Y;
            height = Height;
            width = Width;

        }
        public Sprite(string name, int x, int y, int height, int width)

        {
            name = Name;
            x = X;
            y = Y;
            height = Height;
            width = Width;

        }
    }
}

The second module is SpriteMaster.cs within the SpriteMasterGame namespace

using GHIElectronics.DUELink This statement includes the necessary namespace for the DUELink library.

Fields:

  • DUELinkController BP: An instance of the DUELinkController class, which is presumably used for controlling hardware components.
  • SpriteMaster(DUELinkController bp): Constructor that takes a DUELinkController instance as a parameter and initializes the BP field with it.

Methods:

  • DoGame(): The main method that runs the game loop.
  • DrawSprite(Sprite sprite): A method for drawing a sprite on the display.

Static Fields:

  • enemy, enemy2, enemy3: Static instances of the Sprite class representing enemy sprites.
  • enemyAlive, enemyAlive2, enemyAlive3: Boolean flags indicating whether the corresponding enemy sprites are alive.
  • bullet: Static instance of the Sprite class representing the player’s bullet.
  • player: Static instance of the Sprite class representing the player.
  • score: An integer representing the player’s score.
  • white and black: Colors represented as unsigned integers.
  • BulletIsOut: Boolean flag indicating whether the bullet is currently in motion.
  • enemySpeed1, enemySpeed2, enemySpeed3: Integers representing the speed of the enemy sprites.
  • lives: Integer representing the player’s remaining lives.

Game Logic:

  • The DoGame() method implements the game logic within a while loop. Here’s a summary of the key elements:

Initialization:

  • Initialization of various sprites, including player, enemies, bullets, and their corresponding attributes.
  • Setting up initial positions, dimensions, and images for each sprite.

Game Loop:

  • Continuously runs the game loop as long as the player has lives (lives > 0).
  • Clears the display and draws the game elements, including the player’s lives and score.
  • Processes the bullet movement, collision detection with enemies, and updates the score.
  • Handles the movement and behavior of enemy sprites.
  • Checks for collisions with the player and updates the player’s position.
  • Updates the display and continues the loop.
using GHIElectronics.DUELink;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace SpriteMasterGame
{
    public class SpriteMaster
    {
        DUELinkController BP;
      
        public SpriteMaster(DUELinkController bp)
        {
            this.BP = bp;
        }
        public void DoGame()
        {
            int[] frame1 = new int[] { 1,0,0,1,1,1,1,1,0,
                                       0,1,1,1,1,1,1,1,1,
                                       1,0,0,0,0,1,0,0,0,
                                       1,1,1,1,1,1,1,1,1,
                                       0,0,1,0,0,0,0,0,1
            };
            int[] frame2 = new int[] { 1,0,0,1,1,1,1,1,0,
                                       0,1,1,1,1,1,1,1,1,
                                       1,0,1,0,0,1,1,0,0,
                                       1,1,1,1,1,1,1,1,1,
                                       0,0,1,0,0,0,0,0,1
            };

            int[] bulletImage = new int[] {1, 0,
                                           0, 1,
                                           1, 0,
                                           0, 1
            };


            int[] playerImage = new int[] {0,0,0,1,1,1,1,0,0,0,0,
                                           0,0,0,1,1,1,1,0,0,0,0,
                                           1,1,1,1,1,1,1,1,1,1,1,
                                           1,1,1,1,1,1,1,1,1,1,1
            };

            bullet.X = 150;
            bullet.Y = 150;
            bullet.Width = 2;
            bullet.Height = 4;
            bullet.Image = bulletImage;

            enemy.X = 10;
            enemy.Y = 10;
            enemy.Width = 9;
            enemy.Height = 5;
            enemy.Image = frame1;

            enemy2.X = 20;
            enemy2.Y = 10;
            enemy2.Width = 9;
            enemy2.Height = 5;
            enemy2.Image = frame2;

            enemy3.X = 30;
            enemy3.Y = 10;
            enemy3.Width = 9;
            enemy3.Height = 5;
            enemy3.Image = frame1;

            player.X = 75;
            player.Y = 60;
            player.Width = 11;
            player.Height = 4;
            player.Image = playerImage;

            var start = DateTime.Now.Ticks;
            var end = DateTime.Now.Ticks;

            while (lives > 0)
            {
                start = DateTime.Now.Ticks;
                BP.Display.Clear(0);
                BP.Display.DrawLine(white, 103, 0, 103, 64);

                for (var i = 0; i < lives; i++)
                {
                    BP.Display.DrawText("^", white, 110, i * 10);
                }

                BP.Display.DrawText(score.ToString(), white, 110, 55);

                if (BulletIsOut)
                {
                    bullet.Y -= 12;

                    if (bullet.Y < 0)
                    {
                        BulletIsOut = false;
                    }
                    else
                    {
                        DrawSprite(bullet);
                    }

                    if (bullet.X >= enemy.X - 3 && bullet.X <= enemy.X + enemy.Width + 3 &&
                        bullet.Y >= enemy.Y - 3 && bullet.Y <= enemy.Y + enemy.Height + 3)
                    {
                        score += 10;
                        enemyAlive = false;
                    }
                    if (bullet.X >= enemy2.X - 3 && bullet.X <= enemy2.X + enemy2.Width + 3 &&
                       bullet.Y >= enemy2.Y - 3 && bullet.Y <= enemy2.Y + enemy2.Height + 3)
                    {
                        score += 10;
                        enemyAlive2 = false;
                    }

                    if (bullet.X >= enemy3.X - 3 && bullet.X <= enemy3.X + enemy3.Width + 3 &&
                      bullet.Y >= enemy3.Y - 3 && bullet.Y <= enemy3.Y + enemy3.Height + 3)
                    {
                        score += 10;
                        enemyAlive3 = false;
                    }
                    if (enemyAlive == false)
                    {
                        enemyAlive = true;
                        enemy.X = 10;
                        enemy.Y = 10;
                    }
                    if (enemyAlive2 == false)
                    {
                        enemyAlive2 = true;
                        enemy2.X = 20;
                        enemy2.Y = 10;
                    }
                    if (enemyAlive3 == false)
                    {
                        enemyAlive3 = true;
                        enemy3.X = 30;
                        enemy3.Y = 10;
                    }
                }
                else
                {
                    var buttonshotB = BP.Button.JustPressed('b');

                    if (buttonshotB)
                    {
                        BP.System.Beep('p', 80, 100);
                        bullet.Y = 64;

                        bullet.X = player.X + 5;

                        BulletIsOut = true;
                    }
                }

                if (enemyAlive) DrawSprite(enemy);
                if (enemyAlive2) DrawSprite(enemy2);
                if (enemyAlive3) DrawSprite(enemy3);
                DrawSprite(player);

                var random_rocket = new Random();

                var rockerX = random_rocket.Next(0, 100);

                if (rockerX < 50) player.X += 5;
                if (rockerX > 50) player.X -= 5;


                if (player.X < 0) player.X = 0;
                if (player.X > 90) player.X = 90;

                enemy.X += enemySpeed1;
                enemy2.X += enemySpeed2;
                enemy3.X += enemySpeed3;


                if (enemy.X < 5 || enemy.X > 85)
                {
                    enemySpeed1 *= -1;
                    enemy.Y += 5;
                }
                if (enemy2.X < 5 || enemy2.X > 85)
                {
                    enemySpeed2 *= -1;
                    enemy2.Y += 5;
                }
                if (enemy3.X < 5 || enemy3.X > 85)
                {
                    enemySpeed3 *= -1;
                    enemy3.Y += 5;
                }

                if (enemy.Y > 56)
                {
                    lives--;
                    enemy.X = 10;
                    enemy.Y = 10;
                }
                if (enemy2.Y > 56)
                {
                    lives--;
                    enemy2.X = 20;
                    enemy2.Y = 10;
                }
                if (enemy3.Y > 56)
                {
                    lives--;
                    enemy3.X = 30;
                    enemy3.Y = 10;
                }
                BP.Display.Show();             
            }
        }

        void DrawSprite(Sprite sprite)
        {
            var index = 0;
            while (index <= sprite.Image.Length - 1)
            {
                for (int y = 0; y < sprite.Height; y++)
                {
                    for (int x = 0; x <= sprite.Width - 1; x++)
                    {
                        if (sprite.Image[index] == 1)
                        {
                            BP.Display.SetPixel(white, sprite.X + x, sprite.Y + row);
                        }
                        else
                        {
                            BP.Display.SetPixel(black, sprite.X + x, sprite.Y + row);
                        }
                        index++;
                    }
                    row++;
                }
                row = 0;
            }

        }
        static int row = 0;
        static Sprite enemy = new Sprite();
        static Sprite enemy2 = new Sprite();
        static Sprite enemy3 = new Sprite();
        static bool enemyAlive = true;
        static bool enemyAlive2 = true;
        static bool enemyAlive3 = true;
        static Sprite bullet = new Sprite();
        static Sprite player = new Sprite();
        static int score = 0;
        static uint white = 1;
        static uint black = 0;
        static bool BulletIsOut = false;
        static int enemySpeed1 = 5;
        static int enemySpeed2 = 5;
        static int enemySpeed3 = 5;
        static int lives = 3;
    }
}
        

The last module is the program.cs

Main Method:

  • Main(string[] args): The entry point of the program.
  • DUELinkController.GetConnectionPort(): Retrieves the connection port for the DUELink controller.
  • new DUELinkController(availablePort): Initializes a new instance of the DUELinkController class with the obtained connection port.
  • BP.Button.Enable(‘b’, true): Enables the ‘b’ button on the brainpad controller for use in the game.

Game Initialization:

  • var spritemasterdisplay = new SpriteMaster(BP) Creates a new instance of the SpriteMaster class, passing the DUELinkController instance (BP) to it.

Game Execution:

  • spritemasterdisplay.DoGame(): Calls the DoGame() method on the SpriteMaster instance to start the game loop.
  • Thread.Sleep(-1) Pauses the program indefinitely, allowing the game loop to continue running until manually interrupted.
using GHIElectronics.DUELink;

namespace SpriteMasterGame
{
    public class Program
    {
        static DUELinkController BP;
        static void Main(string[] args)
        {
            var availablePort = DUELinkController.GetConnectionPort();
            var BP = new DUELinkController(availablePort);

            BP.Button.Enable('b', true);

            var spritemasterdisplay = new SpriteMaster(BP);

            spritemasterdisplay.DoGame();

            Thread.Sleep(-1);
        }
    }
}

Customization:

  • Enhance Game Ending:

After losing all three lives, let’s make something special happen in the game—like showing the final score and playing a sound. Check out the .NET DUE library here.

  • Change Spaceship Movement:

Instead of moving randomly, let’s add buttons to control the spaceship. Connect them using alligator clips to the edge connector. this way, players can enjoy a more interactive gaming experience. See the BrainClip kit here for reference.

  • Explore Different Programming Languages with BrainPad Pulse:

If C# and .NET aren’t your go-to choices, you can create the same game using alternative languages such as Python, JavaScript, Due, and more. Discover the various coding options available here.