Golang

 

Introduction

The Pong game is a classic arcade game that simulates table tennis. The objective is to control a paddle and hit a ball back and forth across the screen, preventing the ball from passing your paddle. The game ends when one player fails to hit the ball, and the opponent scores a point. In this tutorial, we will learn how to implement a simple Pong game using the Go programming language, leveraging the github.com/hajimehoshi/ebiten package for rendering and game mechanics.

Objective

The goal of this project is to create a basic Pong game where two players can control paddles, try to score points by bouncing a ball back and forth, and see the result on the screen. You will learn how to set up a Go project, use external libraries for game development, and manage game logic like collision detection and scoring.

Go Pong Game Code


        package main

        import (
            "github.com/hajimehoshi/ebiten/v2"
            "github.com/hajimehoshi/ebiten/v2/ebitenutil"
            "image/color"
            "log"
            "math"
        )

        const (
            screenWidth  = 640
            screenHeight = 480
        )

        type Game struct {
            paddle1Y, paddle2Y float64
            paddleSpeed        float64
            ballX, ballY       float64
            ballDX, ballDY     float64
            score1, score2     int
        }

        func (g *Game) Update() error {
            // Handle paddle movement
            if ebiten.IsKeyPressed(ebiten.KeyW) {
                g.paddle1Y -= g.paddleSpeed
            }
            if ebiten.IsKeyPressed(ebiten.KeyS) {
                g.paddle1Y += g.paddleSpeed
            }
            if ebiten.IsKeyPressed(ebiten.KeyArrowUp) {
                g.paddle2Y -= g.paddleSpeed
            }
            if ebiten.IsKeyPressed(ebiten.KeyArrowDown) {
                g.paddle2Y += g.paddleSpeed
            }

            // Ball movement
            g.ballX += g.ballDX
            g.ballY += g.ballDY

            // Ball collision with top and bottom
            if g.ballY <= 0 || g.ballY >= screenHeight {
                g.ballDY = -g.ballDY
            }

            // Ball collision with paddles
            if (g.ballX <= 10 && g.ballY >= g.paddle1Y && g.ballY <= g.paddle1Y+60) || (g.ballX >= screenWidth-20 && g.ballY >= g.paddle2Y && g.ballY <= g.paddle2Y+60) {
                g.ballDX = -g.ballDX
            }

            // Scoring
            if g.ballX <= 0 { g.score2++ g.resetBall() } else if g.ballX >= screenWidth {
                g.score1++
                g.resetBall()
            }

            return nil
        }

        func (g *Game) resetBall() {
            g.ballX = screenWidth / 2
            g.ballY = screenHeight / 2
            g.ballDX = -g.ballDX
            g.ballDY = 2 * (math.Rand.Float64() - 0.5) * 2
        }

        func (g *Game) Draw(screen *ebiten.Image) {
            screen.Fill(color.Black)

            // Draw paddles
            ebitenutil.DrawRect(screen, 10, g.paddle1Y, 10, 60, color.White)
            ebitenutil.DrawRect(screen, screenWidth-20, g.paddle2Y, 10, 60, color.White)

            // Draw ball
            ebitenutil.DrawRect(screen, g.ballX, g.ballY, 10, 10, color.White)

            // Draw scores
            ebitenutil.DebugPrintAt(screen, "Player 1: "+strconv.Itoa(g.score1), 10, 10)
            ebitenutil.DebugPrintAt(screen, "Player 2: "+strconv.Itoa(g.score2), screenWidth-120, 10)
        }

        func (g *Game) Layout(outsideWidth, outsideHeight int) (int, int) {
            return screenWidth, screenHeight
        }

        func main() {
            g := &Game{
                paddleSpeed: 4,
                ballX:       screenWidth / 2,
                ballY:       screenHeight / 2,
                ballDX:      2,
                ballDY:      2,
            }

            ebiten.SetWindowSize(screenWidth, screenHeight)
            ebiten.SetWindowTitle("Pong Game in Go")
            if err := ebiten.RunGame(g); err != nil {
                log.Fatal(err)
            }
        }
        

Program Structure and How to Run the Program

This Pong game is structured into different sections to handle game mechanics, rendering, and user inputs:

  • Game struct: This holds the variables like paddle positions, ball position, speed, and scores.
  • Update method: This handles the main game logic like paddle movement, ball movement, collision detection, and scoring.
  • Draw method: This renders the paddles, ball, and score on the screen.
  • resetBall method: This resets the ball’s position after a point is scored.
  • Main function: This initializes the game and runs the game loop using the Ebiten library.

To run the program:

  1. Ensure you have Go installed on your system.
  2. Install the Ebiten library with the command: go get github.com/hajimehoshi/ebiten/v2
  3. Create a new Go file and paste the code provided above.
  4. Run the program with the command: go run .go

The game will open in a new window where you can use the W/S keys to move the left paddle and the Up/Down Arrow keys to move the right paddle. The ball will bounce back and forth between the paddles, and you will score a point when the ball passes the opponent’s paddle.

© 2025 Learn Programming

 

By Aditya Bhuyan

I work as a cloud specialist. In addition to being an architect and SRE specialist, I work as a cloud engineer and developer. I have assisted my clients in converting their antiquated programmes into contemporary microservices that operate on various cloud computing platforms such as AWS, GCP, Azure, or VMware Tanzu, as well as orchestration systems such as Docker Swarm or Kubernetes. For over twenty years, I have been employed in the IT sector as a Java developer, J2EE architect, scrum master, and instructor. I write about Cloud Native and Cloud often. Bangalore, India is where my family and I call home. I maintain my physical and mental fitness by doing a lot of yoga and meditation.

Leave a Reply

Your email address will not be published. Required fields are marked *

error

Enjoy this blog? Please spread the word :)