First we need to clean up the raylib code and draw a blue background

in main after the close window lets make a dark blue color and assign it to a new variable

1
2

    // dark Blue
    backgroundColor := rl.NewColor(44, 44, 127, 255)

You could also use one of the predefined colors that RayLib offers.

• lets remove the old text
• and instead of clearing the screen with white, we will use our new background color

1

		rl.ClearBackground(backgroundColor)

One more thing. We will rename our window to ‘Tetris’

1

rl.InitWindow(800, 450, "Tetris")

run it to view your changes and also see if you have errors.

The next thing we do is to draw the grid with code very similar to the print grid we already have. We wont be print a line at a time either, we will draw each cell as a rectangle with a COLOR in it.

Just below the Grid definition we need to define a color for each number ‘value’ we use.

1

var Colors [8]rl.Color

And below the Background color definition

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

	darkGrey := rl.NewColor(26, 31, 40, 255)
	green := rl.NewColor(47, 230, 23, 255)
	red := rl.NewColor(232, 18, 18, 255)
	orange := rl.NewColor(226, 116, 17, 255)
	yellow := rl.NewColor(237, 234, 4, 255)
	purple := rl.NewColor(166, 0, 247, 255)
	cyan := rl.NewColor(21, 204, 209, 255)
	blue := rl.NewColor(13, 64, 216, 255)

	Colors = [8]rl.Color{
		darkGrey,
		green,
		red,
		orange,
		yellow,
		purple,
		cyan,
		blue,
	}

A function to GET a value at a position

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

func getValAt(x, y int) (int, error) {
	if x >= NumCols || x < 0 {
		return x, errors.New("x position out of range")
	}
	if y >= NumRows || y < 0 {
		return y, errors.New("y position out of range")
	}
	pos := y*NumCols + x
	return Grid[pos], nil
}

and then the draw code.

1
2
3
4
5
6
7
8

func Draw(){
    for r := 0; r < NumRows; r++ {
        for c := 0; c < NumCols; c++ {
            value,_ := getValAt(c,r)
            rl.DrawRectangle((int32)(c * CellSize + 1), (int32)(r * CellSize + 1), (int32)(CellSize - 1), (int32)(CellSize - 1), Colors[value])
        }
    }
}

And finally call our new draw function just below the clear-background-color and before end-drawing

1

Draw()

Run the code and you should now see

Thoughts

Functions are used to keep the main function ‘clean’. I find that if there is too much code in one area then I start having difficulty figuring out what is going on. the same can be said for indirection and ‘clever’ programming.

Go is faster than Java and definitely way faster that JavaScript. If you need the extra performance then I suggest you have a ‘clean’ master/main branch in your git and keep your performance ‘patches’ for the version branches. This keeps Adding new code simple.

Note: I do not advocate low performance, nor do I advocate ‘Messy Code’. High performance AND Bug free makes a huge difference to your client base.

I suggest you find a balance that best suits you.

Keep in mind messy code:

• slows the work down
• is difficult to add new code
• no Developer wants to touch it
• encourages hacking (to add new code)
• encourages bugs