Java pour Sega Mega Drive : Guide technique

Développer des jeux pour Sega Mega Drive en Java : un guide technique

Oui, il est possible de développer des jeux pour la Sega Mega Drive en utilisant Java. Cela est rendu possible par le projet Java Grinder — un traducteur qui convertit le bytecode JVM en assembleur Motorola 68000. Bien que la plateforme soit obsolète, l'intérêt pour le développement rétro reste élevé chez les ingénieurs, en particulier avec des méthodes non conventionnelles pour interagir avec du matériel ancien.

Configuration de l'environnement

Java Grinder a été initialement développé pour Linux, donc sous Windows, il est recommandé d'utiliser WSL. Vous devez installer le compilateur javac (par exemple, via OpenJDK) et l'utilitaire make. Ensuite, suivez ces étapes :

• Cloner le dépôt Java Grinder et compiler l'exécutable java_grinder.
• Générer la bibliothèque JavaGrinder.jar en utilisant la commande make java.
• Compiler l'assembleur naken_asm et le placer dans le répertoire Java Grinder.
• Utiliser un projet template (par exemple, Empty-project-Java-Grinder) comme base pour votre nouveau jeu.

Tous ces composants forment une chaîne d'outils minimale pour traduire du code Java en une image ROM compatible avec les émulateurs ou la console originale.

Travail avec les graphismes

La Sega Mega Drive utilise un système graphique basé sur des tuiles : l'écran est construit à partir de blocs de 8×8 pixels. Chaque tuile occupe 32 octets en mémoire vidéo (VRAM), et la couleur de chaque pixel est déterminée par un indice dans une palette de 16 couleurs. La palette est stockée en CRAM (Color RAM) et se compose de valeurs sur 9 bits.

Exemple de déclaration de palette :

public static short[] palette = {
  0xECE, 0x0A0, 0x0C0, 0x080, 0xEEE, 0x88C, 0xAAE, 0x246,
  0x8AE, 0x68C, 0x66A, 0xE80, 0xEA0, 0xC60, 0xC40, 0xA00
};

Les couleurs sont spécifiées dans un format de palette 9 bits, où chaque canal (R, G, B) est représenté par 3 bits. La conversion depuis RGB utilise cette formule :

((B >> 5) << 9) | ((G >> 5) << 5) | ((R >> 5) << 1)

La conversion inverse est imprécise en raison de la perte d'information due au décalage.

Arrière-plan et sprites

L'arrière-plan se compose de trois composants :

• Palette — tableau short[].
• Tuiles — tableau int[] pattern contenant les données de pixels encodées.
• Carte de tuiles — tableau int[] image indiquant quelles tuiles afficher et dans quel ordre.

Le chargement de l'arrière-plan se fait via l'API :

SegaGenesis.setPaletteColors(palette);
SegaGenesis.setPatternTable(pattern);
SegaGenesis.setImageData(image);

Les sprites fonctionnent de manière similaire, mais sans carte de tuiles. Chaque sprite est chargé directement en VRAM, ce qui est moins efficace mais plus simple à implémenter. Le contrôle des sprites utilise ces méthodes :

• setSpritePosition(index, x, y) — définit les coordonnées.
• setSpriteConfig1() et setSpriteConfig2() — définissent la taille, la palette, l'adresse VRAM et les drapeaux de réflexion.

Important : Les sprites sont rendus dans un système de coordonnées 512×512, où le coin supérieur gauche de l'écran correspond au point (128, 128).

Entrée manette

L'API fournit la méthode SegaGenesis.getJoypadValuePort1(), qui retourne un masque de bits des états des boutons. Constantes pour la vérification :

public static final int JOYPAD_UP    = 0x0001;
public static final int JOYPAD_DOWN  = 0x0002;
public static final int JOYPAD_LEFT  = 0x0004;
public static final int JOYPAD_RIGHT = 0x0008;
public static final int JOYPAD_B     = 0x0010;
public static final int JOYPAD_C     = 0x0020;
public static final int JOYPAD_A     = 0x1000;
public static final int JOYPAD_START = 0x2000;

La vérification correcte d'appui sur les boutons nécessite des opérations bit à bit :

int state = SegaGenesis.getJoypadValuePort1();
if ((state & SegaGenesis.JOYPAD_A) != 0) {
  // Gérer l'appui sur le bouton A
}

Cela permet une gestion correcte des appuis simultanés sur plusieurs boutons.

Limitations et fonctionnalités

• Seul l'alphabet latin en majuscules est pris en charge pour la sortie de texte.
• Les fonctions print() ne font pas d'enroulement automatique de ligne.
• La police occupe une plage fixe en VRAM (0x0460–0x0479) — elle ne peut pas être écrasée.
• Taille maximale de palette : 16 couleurs par élément (arrière-plan ou sprite).
• Les sprites ont des emplacements de palette séparés (indices 16–63 en CRAM).

Points clés

• Java Grinder traduit le bytecode JVM en assembleur 68K, permettant l'utilisation de Java sur des plateformes rétro.
• Les graphismes sont basés sur des tuiles 8×8 avec une palette 16 couleurs 9 bits.
• L'entrée nécessite une vérification bit à bit de l'état de la manette.
• L'arrière-plan et les sprites sont chargés séparément, avec des limites mémoire différentes.
• La reproduction exacte des couleurs RGB est impossible sans table de correspondance.

— Editorial Team