Introduction to the Hello World Series...
In this series of tutorials we create the classic 'Hello World' program... a basic program to just show a text message onscreen!... each example will be a single ASM file (with font where required) and we'll look at the stages required to compile the ASM, and get it onto a disk or cartridge.

Once we've got 'hello world' working, we'll extend it, adding a 'Monitor' to show registers, and MemDump, to display part of the RAM to the screen... these are a useful starting point if you're building something new.

When it comes to printing a character to the screen, we're going to use a system call... We'll use Trap #1 (Gemdos) and Function #2 (Console Out) First we push the Character number onto the stack... then we push the function number #2... finally we use the Trap #1 command. The Character will be printed to the screen, we now need to remove the two words off the stack before returning.
We'll extend our Print Char function to print chr 255 terminated strings
We can start a new line by printing Characters 13 and 10 to the screen
Our program starts with a 'Text' Section - this defines the area as being program code. We can load the address of our string to show... and use our function. If we just RETurned straight away, our output would only appear for a moment - so we'll pause a moment for a keypress.. We use Trap #1 - Function #1 (ConIn) to read in a key from the console first... this will pause for a moment for us to admire our work!
Our 'Hello World' message will be shown to screen.

We build our file with Vasm - Vasm has support for the special Xfile format used by the x68 for executable files... I use this build command in my batch files. We need to specify the source asm file to compile We're specifying that VASM should ignore case, and check if labels look like commands (in case we forgot our tab on a command) I define a couple of symbols, but you won't need them for the simple example... We're telling VASM to output a listing. This is a text file which shows how the asm commands convert to bytecode... We don't need it - but it may help us if we have problems! We need to tell vasm to build an ELF - We'll need to link this later Finally, we specify a filename for the output file
We need to 'Link' the ELF file to convert it into an executable We specify the source ELF from the last assembly step We specify an output file in TOS format (Atari executable). We need to specify the file format as AtariTos
We can use a folder on our windows machine as a hard drive - we've mapped the folder \RelAST to the C drive
Any files we put in this folder will appear as a drive on our machine

As part of my tutorials, I wrote some simple 'Monitor Tools' which will help with debugging By including a few extra files we can use those tools with this example.
These tools provide two useful functions... "Monitor" will show the register contents to the screen "Memdump" Will output some lines of memory to the screen from the specified memory address
The registers and requested memory area will be shown to the screen.

We're just using Text console mode in this example... if you want to see the same functions in bitmap mode, please see the platform specific series. That's probably what you'll want to do if you're writing a game... unless it's a text adventure!

Lesson H3 -  Hello World on the NeoGeo The NeoGeo  uses 5 bits per channel, has 16 colors per palette, and up to 256 palettes! Lets learn how to set the colors on the Neo Geo!

NEO_HelloWorld.asm

First we're going to define some symbols pointing to RAM - we're going to need a few bytes for our code.
The start of our cartridge needs to contain the 'Traps' - these handle CPU and system events - we need to point them to the bios These won't need changing for a simple program
We now need the actual 'Cartridge header' This has a few system parameters, and links to settings and subroutines for system events You probably won't need to change this
We need to define a bank of settings for the 'Dip Switches'
We need some functions to handle system events. The VBlank one here is one you may wish to change, this occurs every frame redraw, so can be useful for controlling game speed - but you don't need to worry about it when you're just starting out. Phew! that's the end of the 'header'... Lets start writing our code!

We build our file with Vasm - Vasm has support for the special Xfile format used by the x68 for executable files... I use this build command in my batch files. We need to specify the source asm file to compile We're specifying that VASM should ignore case, and check if labels look like commands (in case we forgot our tab on a command) I'm specifying to output 68000 CPU code I define a couple of symbols, but you won't need them for the simple example... We're telling VASM to output a listing. This is a text file which shows how the asm commands convert to bytecode... We don't need it - but it may help us if we have problems! We need to tell vasm to build an BINary file Our source sample will only compile correctly in DevPac mode Finally, we specify a filename for the output file

Our File is built, but we need to do more, we need to convert the byte data into the correct format for the NeoGeo by swaing the byte pairs... we also need to pad the file

We need to make sure the SIZE, CRC and SHA are correct in the XML for each file... I've written a little program to calculate the hashes If your hashes are wrong, MAME will whine... if your Size is wrong MAME may crash!

Finally, we can load  MAME and start our game.

Monitor Tools

We're going to use an OS trap to draw characters to the screen Trap #3 - Function #5 (In D0) will send a byte to the screen... we need to set the Timeout (D3) and Channel ID (A0) as well... and make sure the character code is in D0
We're going to extend our PrintChar routine into a PrintString Routine - it'll use Char 255 terminated strings. We just send each character to PrintChar until we get to the 255
We can start a new line by printing a character 10 to the screen.
Let's start our program! We load the address of our string into A3, before calling Printstring Before we return to basic we need to load D0 with zero - otherwise basic will complain!
And here's the result!

We build our file with Vasm - Vasm has support for the special Xfile format used by the x68 for executable files... I use this build command in my batch files. We need to specify the source asm file to compile We're specifying that VASM should ignore case, and check if labels look like commands (in case we forgot our tab on a command) I define a couple of symbols, but you won't need them for the simple example... We're telling VASM to output a listing. This is a text file which shows how the asm commands convert to bytecode... We don't need it - but it may help us if we have problems! We need to tell vasm to build an BIN file Finally, we specify a filename for the output file
We need to set up QemuLator to use the destination directory as a drive... we do this by right clicking on a drive number, and Attaching Directiory
We need to create a startup file called BOOT on drive WIN1... this will cause our program to launch with the emulator. The basic program to the right will load the program to ram address 32768 and launch it. This program can be saved with the command "save win1_BOOT"
We can save a settings file with correct settings for the disk image, and load it on the commandline with QemuLator
Our program will run as soon as the emulator starts (after we select monitor type with F2)

Monitor Tools

s part of my tutorials, I wrote some simple 'Monitor Tools' which will help with debugging By including a few extra files we can use those tools with this example.
These tools provide two useful functions... "Monitor" will show the register contents to the screen "Memdump" Will output some lines of memory to the screen from the specified memory address
The registers and requested memory area will be shown to the screen.

We've only used the basic text mode, which isn't too useful for gaming... Take a look at the 'Platform Specific' series, where we covered the bitmap modes for more 'useful' code!

We build our file with Vasm - Vasm has support for the special Xfile format used by the x68 for executable files... I use this build command in my batch files. We need to specify the source asm file to compile We're specifying that VASM should ignore case, and check if labels look like commands (in case we forgot our tab on a command) I define a couple of symbols, but you won't need them for the simple example... We're telling VASM to output a listing. This is a text file which shows how the asm commands convert to bytecode... We don't need it - but it may help us if we have problems! We need to tell vasm to build an BIN file Finally, we specify a filename for the output file

We can start Fusion with the cartridge specified on the command line

Monitor Tools

s part of my tutorials, I wrote some simple 'Monitor Tools' which will help with debugging By including a few extra files we can use those tools with this example.
These tools provide two useful functions... "Monitor" will show the register contents to the screen "Memdump" Will output some lines of memory to the screen from the specified memory address
The registers and requested memory area will be shown to the screen.