Tutoriels Master System

Développer sur Master System en assembleur

05 décembre 2020 7 min de lecture

La SEGA Master System appelée également SMS est une console 8-bit commercialisée au Japon en 1985 avant d’être disponible un an plus tard en France. Malgré un succès moindre que fut celui de la NES de Nintendo, la Master System avait le mérite de détenir un matériel nettement supérieur face à sa rivale notamment grâce à son processeur Zilog Z80 de 3,58MHz, une mémoire interne de 8KB, une mémoire vidéo de 16KB et la possibilité d’afficher jusqu’à 32 couleurs sur une palette de 64.

Ces atouts font de la Master System une console fort intéressante en ce qui concerne le développement de jeux vidéo rétros, mais pour espérer afficher bon nombre sprites à l’écran avec une action frénétique à la manière des jeux sur PC Engine, il sera nécessaire d’écrire son programme en langage assembleur et maîtriser parfaitement le fonctionnement de la machine. Alors si programmer en assembleur ne vous effraie pas, je vous invite à suivre ce tutoriel expliquant comment mettre en place un environnement de développement pour la Master System sous Linux avec WLA DX.

Installation de WLA DX

Pour créer un programme sur Master System, il nous faut un assembleur qui s’occupera d’interpréter les lignes de code en langage machine. Il existe une multitude d’assembleurs de qualité pour le Z80, mais le plus complet est indéniablement WLA DX. Crée par Ville Helin, WLA DX est en réalité un Multi Cross Platform Assembler Package, ce qui signifie qu’il embarque plusieurs assembleurs et il vous sera donc possible d’écrire du code pour d’autres consoles comme la Super Nintendo ou bien la PC Engine mais ce qui nous intéresse ici c’est la Master System et donc le Z80 !

Pour installer WLA DX, il faudra compiler les sources et il faudra donc disposer du toolchain gcc ainsi que des paquets cmake, git et sphinx.

Commencez par récupérer les sources depuis le dépôt hébergé sur GitHub :

git clone https://github.com/vhelin/wla-dx.git
cd wla-dx

Créez le dossier build qui servira à compiler WLA DX puis exécutez cmake à l’intérieur pour une première configuration et lancez la commande make -j{n} où {n} correspond au nombre de cores que dispose votre processeur :

mkdir build
cd build
cmake -G "Unix Makefiles" ..
make -j{n}

Si vous souhaitez installer WLA DX localement (/usr/local), exécutez à nouveau cmake :

cmake -P cmake_install.cmake

Dans le cas où vous souhaitez utiliser uniquement le Z80, copiez uniquement les binaires wla-z80 et wla-link :

cd binaries
cp wla-z80 /usr/local/bin
cp wla-link /usr/local/bin

Une alternative consiste à installer WLA DX dans le dossier utilisateur, ce qui peut s’avérer fort pratique si vous ne disposez pas des droits administrateur ou que vous souhaitez restreindre son utilisation :

cd binaries
mkdir -p ~/.local/bin
cp wla-z80 ~/.local/bin
cp wla-link ~/.local/bin

Si vous utilisez WLA DX dans le dossier utilisateur, il faudra modifier le fichier ~/.shellrc afin d’y ajouter cette ligne :

echo export 'PATH=$HOME/.local/bin:$PATH' >> ~/.bashrc
source ~/.shellrc

Makefile

Afin de compiler facilement et rapidement vos projets, je vous propose ce Makefile que j’utilise pour mes programmes :

############################################
# Makefile for SEGA MASTER SYSTEM Z80 WLA DX
# Date: December 5, 2020
# Author: Jacques Belosoukinski <kentosama>
# Github: https://github.com/kentosama
############################################

# Recursive wildcard
rwildcard = $(foreach d,$(wildcard $1*),$(call rwildcard,$d/,$2) $(filter $(subst *,%,$2),$d))

ASM=wla-z80
ASFLAGS= -o
LD=wlalink
LDFLAGS = -v -r
OUT_DIR=out
CPUS?=$(shell nproc)
MAKEFLAGS:=--jobs=$(CPUS)

SRC_DIR:=src
SRC:=src/main.asm


OBJ:=$(SRC:.asm=.rel)
OBJS:=$(addprefix $(OUT_DIR)/, $(OBJ))

BIN=rom.sms
EMULATOR=meka

START:= mkdir -p $(OUT_DIR) && echo '[objects]' > $(OUT_DIR)/tmp

release: prebuild $(OUT_DIR)/$(BIN)

all: release

.PHONY: clean

run: release
	$(EMULATOR) $(OUT_DIR)/$(BIN)

clean:
	@rm -rf $(OUT_DIR)

prebuild:
	@$(START)
	
$(OUT_DIR)/$(BIN): $(OBJS)
	$(LD) $(LDFLAGS) $(OUT_DIR)/tmp $(OUT_DIR)/$(BIN)
	@rm -rf $(OUT_DIR)/tmp
	
	
$(OUT_DIR)/%.rel: %.asm
	@mkdir -p $(@D)
	echo $@ >> $(OUT_DIR)/tmp
	$(ASM) $(ASFLAGS) $@ $^

Installation de MEKA

Crée par Omar Cornut “Bock”, MEKA est un émulateur muti-machine compatible Windows et Linux. Il émule donc plusieurs systèmes tels que le SG-1000, SC-3000, SF-7000, SEGA Mark III, SEGA Master System, SEGA Game Gear, bref que des consoles SEGA basées sur le même hardware si on omet la ColecoVision et l’Othello Multivision.

L’avantage de MEKA par rapport à d’autres émulateurs, c’est qu’il fonctionne parfaitement sous Linux et qu’il permet de lire dans les entrailles de la machine grâce à ses nombreux outils pour déboguer. Avec MEKA, vous serez en mesure de lire la RAM et la VRAM, de vérifier frame par frame chaque instruction exécutée par le Z80, mais aussi le visualiser le tilemap et de voir les valeurs contenues dans chaque registre que se soit pour le Z80 ou le VDP.

Attention, si vous songez à utiliser la version Windows, sachez qu’il y a un bug sur l’interface empêchant de cliquer sur les différents boutons de certaines fenêtres.

Comme pour WLA DX, il faudra compiler les sources à partir du dépôt hébergé sur GitHub :

git clone https://github.com/ocornut/meka
cd meka/meka/src
make -j{n}

Par la suite, vous êtes libre d’installer MEKA où bon vous semble, mais comme pour WLA DX, je vous recommande une installation dans le dossier /usr/local ou dans votre dossier utilisateur ~/.local :

cd ..
sudo mkdir -p /usr/local/games/meka
sudo chown {nom_utilisateur}:{nom_utilisateur} /usr/local/games/meka
cp * /usr/local/games/meka
cd /usr/local/games/meka
rm -R srcs
rm -R tools

Ici nous avons crée le répertoire meka dans /usr/local/games puis nous avons défini l’utilisateur propriétaire du dossier afin d’y copier tous les fichiers de l’émulateur. Nous avons supprimé les dossiers srcs et tools contenant chacun des fichiers inutiles pour notre usage.

A ce stade, si vous essayez de démarrer MEKA depuis la ligne de commande, vous obtiendrez un message d’erreur puisque l’émulateur à besoin d’être lancé depuis son répertoire. Pour évitez de devoir changer de répertoire à chaque exécution, nous devons écrire un simple script shell dans /usr/local/games/meka que nous appellerons run.sh :

#!/bin/bash
BIN=$PWD/$1
cd /usr/local/games/meka
if [ -z "$1" ]; then
	./meka
else
	./meka ${BIN}
fi

Puis autorisez l’exécution et créez un lien symbolique :

chmod a+x run.sh
sudo ln -s /usr/local/games/meka/run.sh /usr/local/bin/meka

Maintenant, en exécutant la commande meka, l’émulateur devrait se lancer et afficher une jolie interface. Profitez-en pour désactiver le lancement systématique du bios et l’affichage plein écran via le menu des options.

Compiler un programme

Pour nous assurer que tout fonctionne correctement, nous allons compiler un simple exemple puis l’essayer avec MEKA ou tout autre émulateur capable d’émuler la Master System (Blastem, KEGA Fusion, Mednafen…).

Le plus simple et le plus rapide est de récupérer sur GitHub un squelette que j’utilise pour mes projets en assembleur Z80 :

git clone https://github.com/kentosama/sms-skeleton
cd sms-skeleton
make run

Si tout fonctionne convenablement, la ROM a été générée dans le dossier out et l’émulateur MEKA s’est lancé. Si l’écran de la Master System est noir, c’est normal, mais si vous regardez au niveau de la fenêtre des messages, vous devrez être en mesure de lire quelques informations utiles. Il s’agit du nom de l’auteur et la description de la ROM. Ici, vous devriez lire “Kentosama” pour l’auteur et “Sample Program for SEGA Master System » pour la description.

Il ne vous reste plus qu’à utiliser ce squelette ou bien de créer le votre en fonction de vos besoin afin de commencer à programmer sur Master System !

Pour en savoir plus sur l’assembleur et la Master System, je vous recommande vivement de consulter la documentation officielle du Z80, mais aussi de visiter le site SMS Power !.