Bitwise Bytefoolish

Introduction

In Bitwise Bytefoolish two players (or one player against an computer played oppenent) will in turn manipulate a byte to match their goal value. Once the byte matches the goal value of a player that player wins the game!

Project set up

When developing for the gameboy you can choose between two languages: C and assembly.¹ Most compilers will compile assmebly to the machine language understood by the gameboy. The Small Device C Compiler (SDCC) used by GBDK2020 is no different.² However, the output of the compiler in this project will not be the complete game just yet. In the old days it was common to split the compilation of your application in parts called object files. Those object files would then be linked into one whole application by a linker. The adventage of this method is that when the developer makes a small change in the code only that part of the application had to be compiled again. That was a huge timesaver back in the day!

For this project I have choosen to use GBDK2020. It is the current goto for C programming on the gameboy. Using a higher level language like C lowers the entry bar not only for me, but also for many other developers that might want to join. And when the abstraction of the C language poses technical difficulties writing optimized assembly is still an option.

First I have installed GBDK2020 locally. Secondly I configured my IDE VS Code. It is important is to include the path to the GBDK2020 libraries. Otherwise IntelliSense will not understand what I am doing.

    {
        "configurations": [
            {
                "name": "Win32",
                "includePath": [
                    "${workspaceFolder}/**",
                    "c:/path_to_gbdk/include/**"
                ],
                "defines": [
                    "_DEBUG",
                    "UNICODE",
                    "_UNICODE"
                ],
                "windowsSdkVersion": "x.x.x.x",
                "compilerPath": "C:/Program Files (x86)/Microsoft Visual Studio/20xx/BuildTools/VC/Tools/MSVC/xx.xx.xx/bin/Hostx64/x64/cl.exe",
                "cStandard": "c17",
                "cppStandard": "c++17",
                "intelliSenseMode": "windows-msvc-x64"
            }
        ],
        "version": 4
    }
                        

Thirdly I created the make.bat file. For each C or assembly file a line like below is used to compile it into an object file.

d:\gbdk\bin\lcc -Wa-l -Wl-m -Wl-j -DUSE_SFR_FOR_REG -c -o main.o main.c

The instruction can be broken down as follow:

d:\gbdk\bin\lcc

Location of the lcc compiler. It is found in the bin folder of your GBDK2020 installation. It is this application we do a call upon.

-Wa-l

Generate assemlber listing file.

-Wl-m

Generate linker map file.

-Wl-j

Enables NoICE output for sdldgb: the SDCC linker for the gameboy.

-DUSE_SFR_FOR_REG

Don't use a Special Functions Registry for registry.

-c

Compile only

-o

Leave the output in 'file'

main.c

Path to the C or assembly file

main.o

Path to the object file

At the last line we link all object files together into one .gb file. Note that there is no -c parameter. The object files already contain the to machine language compiled code.

d:\gbdk\bin\lcc -Wa-l -Wl-m -Wl-j -DUSE_SFR_FOR_REG -o main.gb main.o room.o seed.o deck.o byte.o menu.o credits.o manual.o titlescreen.o board.o text.o

Fourthly I created the .gitignore file. In the make.bat we instruct lcc to generate lots of files. Most of them are for debugging purposes. Let's exclude those from source control. It can always be generated anew when needed.

*.o
    *.lst
    *.map
    *.sym
    *.gb
    *.gbc
    *.asm
    *.ihx
    *.noi
    .vscode/**/*

Fifthly I added a package.json. I already had Node.js installed on my local machine and so do many other developers with VS Code. I added the make.bat as compile script. Self made pre-compile scripts can later be added when the necessity arises.

First iteration

[...]