Coder en C sur MSX, les bases

Ce billet de blog est un mise à jour des tutoriaux qui se trouvaient sur mes anciens blogs.

Vous allez ici apprendre à :

  • mettre en place les outils de compilation
  • développer une librairie de jeu vidéo pour MSX, compatible au maximum avec la librairie
    existante sur Colecovision (par Daniel Bienvenu)
  • tester cette librairie au fur et à mesure pour voir si tout ce passe bien 🙂
  • Le tout avec les URLS des outils et sources à télécharger, mis à jour !

NOTE : Ces tutoriaux n’auraient jamais pu voir le jour sans les références suivantes :

http://andrear.altervista.org/contents/msx/inertia/

Je vais commencer par vous expliquer les outils à mettre en place pour compiler une rom MSX.

A télécharger :

  • SDCC : http://sdcc.sourceforge.net/ SDCC est ce que l’on appelle un cross compiler. Il permet à partir d’un code source en C de générer de l’assembleur pour un autre processeur. Le pack SDCC contient également de quoi compiler l’assembleur généré. (Pour ce tuto je vous conseille de télécharger une ancienne version de SDCC, du genre une 3.2.x qui contient sdasz80.exe)
  • OBJCOPY : http://perso.numericable.fr/michel.louvet/files/objcopy.exe OBJCOPY permet de transformer le binaire généré par SDCC en rom lisible par un émulateur, ou la console/ordinateur réel. Gardez bien ce fichier, il nous reservira plus tard !

Mettre en place notre environnement :

Installez SDCC, par exemple dans C:\DEV\SDCC, puis mettez dans le PATH Windows le répertoire d’éxécutable de SDCC à savoir C:\DEV\SDCC\BIN pour que le compilateur soit accessible partout.

Créez un répertoire TUTORIAL_SOURCE par exemple, et à l’intérieur copiez le OBJCOPY.EXE . Ou bien vous pouvez copier cet éxécutable dans le répertoire BIN de SDCC pour qu’il soit executable de partout …

Test de l’environnement :

On attaque tout de suite les choses sérieuses. Une rom MSX pour qu’elle soit reconnu tel quel à besoin d’un HEADER, d’une signature (pour simplifier) si vous préférez. Nous allons créer cette signature. Dans votre répertoire TUTORIAL_SOURCE, créez un fichier texte appelé crt0msx.s. Et copier coller le code source suivant à l’intérieur :

 ;; Generic crt0.s for a Z80
    .globl    _main
    .area _HEADER (ABS)
    ;; Reset vector
        .org    0x4000
        .db     0x41
        .db     0x42
        .dw     init
        .dw     0x0000
        .dw     0x0000
        .dw     0x0000
        .dw     0x0000
        .dw     0x0000
        .dw     0x0000
init:
    ;; Stack at the top of memory.
        ld      sp,(0xfc4a)       
        ;; Initialise global variables
    call    _main
    ;; Ordering of segments for the linker.
    .area    _CODE
        .area   _GSINIT
        .area   _GSFINAL
        .area    _DATA
        .area   _BSS
        .area   _CODE
        ;; Special RLE decoder used for initing global data
__initrleblock::
        ;; Pull the destination address out
        ld      c,l
        ld      b,h
        ;; Pop the return address
        pop     hl
1$:
        ;; Fetch the run
        ld      e,(hl)
        inc     hl
        ;; Negative means a run
        bit     7,e
        jp      z,2$
        ;; Code for expanding a run
        ld      a,(hl)
        inc     hl
3$:
        ld      (bc),a
        inc     bc
        inc     e
        jp      nz,3$
        jp      1$
2$:
        ;; Zero means end of a block
        xor     a
        or      e
        jp      z,4$
        ;; Code for expanding a block
5$:    
        ld      a,(hl)       
        inc     hl
        ld      (bc),a
        inc     bc
        dec     e
        jp      nz,5$
        jp      1$
4$:    
        ;; Push the return address back onto the stack
        push    hl
        ret
        .area   _GSINIT
gsinit::   
        .area   _GSFINAL
        ret
		

Nous allons compiler ce charabia. Ouvez une ligne de commande DOS, allez dans le répertoire TUTORIAL SOURCE et taper :

sdasz80 -o crt0.rel crt0msx.s

Si tout ce passe bien, rien ne doit s’afficher, et vous devez avoir en bonus un fichier crt0.rel qui est apparu dans votre répertoire. Vous avez votre signature de rom.

Nous allons créer et compiler une première brique qui s’appelle tools.c. Cette première brique va contenir des fonctions génériques qui nous servirons plus tard.

Dans le répertoire TUTORIAL_TEST créez 2 fichiers textes, à savoir tools.c et tools.h.

En C, les .c contiennent les procédures et fonctions, et les .h, uniquement les signatures des procédures et fonctions.
Ainsi dans votre programme PRINCIPAL vous incluez les .h et le compilateur sait que les procédures et fonctions existe, et donc ne renvoit pas d’erreur.

Mais pour le moment, concentrons nous à créer la librairie « outils », première brique de notre librairie de jeu.

Pour ce tutorial, nous allons créer les procédures :

char peek(int address) : Lecture d'un octet en mémoire (8 bits)
int peek_word(int address) : Lecture d'un mot en mémoire (16 bits)

Dans tools.c, copiez collez le code suivant :

#include "tools.h"
#include <stdio.h>
#include <string.h>

char peek(int address){
  __asm
    ld l,4(ix) ; Charger le paramêtre (16 bits) dans HL
    ld h,5(ix)
    ld l,(hl)  ; Récuperer la valeur (8 bits) à l'adresse en la mettre dans H
    ld h,#0x00 ; Mettre à 0 H (car HL = 16 bits et on à un resultat 8 bits)
  __endasm;
}

int peek_word(int address){
  return
    ((int)peek(address)&0xff) |
    (peek(address+1)<<8) ;
}


Tout d’abord, la routine peek. Elle prend en entrée l’adresse en mémoire que l’on veut lire. En sortie, on à un octet. Le code est du pur assembleur, mais en gros, on charge le paramètre address dans le registre 16bits HL, on lit la valeur à cette adresse et on là revoie de nouveau dans HL qui est notre char de retour.

Le peek_word appelle 2 fois le peek. En effet on veut récupérer à une adresse une valeur 16bits. Soit 8bits à l’adresse « address » et 8bits à l’adresse « address »+1.

Dans tools.h copiez collez le code suivant :

#ifndef ___MSX_H___
#define ___MSX_H___

char peek(int address);
int peek_word(int address);

#endif

Ce sont juste les signatures des fonctions que l’ont à créé.

Maintenant, on va compiler ça. Dans une ligne de commande lancez :

sdcc -mz80 -c tools.c

Attention !! Si vous utilisez une version plus récente de SDCC la directive devient :

sdcc -mz80 -c –oldralloc tools.c

Vous allez avoir de beaux message de WARNING (et pas d’erreur),

I:\CODING\Sources\MSX\TUTO_SOURCES>sdcc -mz80 -c tools.c
tools.c:7: warning 59: function ‘peek’ must return value
tools.c:7: warning 85: in function peek unreferenced function argument : ‘address’

car le compilateur n’apprécie que moyennement le mélance C/Assembleur. Mais pas de panique, ça fonctionne. D’ailleurs, vous avez maintenant dans votre répertoire un fichier tools.rel.

On va mettre maintenant en place la seconde brique de notre librairie de jeu. Nous allons créer et compiler video.c.

Dans le répertoire TUTORIAL_TEST créez 2 fichiers, à savoir video.c et video.h.

Pour ce tutorial, nous allons créer les procédures :

void screen_mode_2() : pour passer le MSX en mode vidéo 2 (mode graphique identique à celui de la COLECO)
void put_vram(void* block,int vramaddr,int size) : pour écrire un bloc de la RAM vers la VRAM   

Un mot sur le mode 2 du MSX :

Le mode Vidéo 2 du MSX est le mode vidéo qui se rapproche le plus de celui de la Coleco. Ce mode vidéo est composé :

- d'un écran de 32*24 caractères
- de 3 tables de 255 caractères
- de 3 tables de codes couleurs pour chaque caractères

Si on découpe l’écran en 3 de manière horizontale, la 1ere table de caractère est pour le tiers haut. (y = 0 à 7). La seconde table de caractère est pour le tiers du milieu, la troisième table de caractère est pour le tiers bas.

Par exemple, si on affiche le caractère 10 en position x=10,y=5, on se trouve dans le 1er tiers de l’écran, on affichera donc le dessin du caractère 10 stocké dans la 1ere table de caractère/couleur.
Si on affiche le caractère 10 en position x=10,y=20 , on se trouve dans le 3ème tiers de l’écran, on affichera donc le dessin du caractère 10 stocké dans la 3ème table de caractère/couleur.

Si le caractère 10 doit représenter le même caractères avec la même couleur partour sur l’écran alors sa définition doit être identique dans chaque table caractère/couleur.

Pour connaitre l’emplacement en mémoire VRAM (vidéo) de l’écran, du début des tables de caractères, et du début des tables de couleurs, il faut lire les adresses suivantes :

0xF3C7 : Pour récupérer l'adresse de début de l'écran
0xF3CB : Pour récupérer l'adresse de début des tables de définition des caractères
0xF3C9 : Pour récupérer l'adresse de début des tables de définition des couleurs de caractères

Grâce à la commande peek_word que bous avons implémenté dans le précédent tuto, on va pouvoir récupérer les adresses ou écrire en vidéo.

int adresse_ecran;
int adresse_car;
int adresse_col;

adresse_ecran = peek_word(0xF3C7);
adresse_car = peek_word(0xF3CB);
adresse_col = peek_word(0xF3C9);

mais je tergiverse, implémentons, mes amis, implémentons.

Dans video.c, copiez collez le code suivant :

/*
GRPNAM 2 Adresse ou lire pour avoir l'adresse de la table des noms en mode 2
GRPCOL 2 Adresse ou lire pour avoir l'adresse de la table des couleurs en mode 2
GRPCGP 2 Adresse ou lire pour avoir l'adresse de la table des formes en mode 2
GRPATR 2 ou lire pour avoir l'adresse Adresse de la table des attributs de sprites en mode 2
GRPPAT 2 ou lire pour avoir l'adresse Adresse de la table des formes de sprites en mode 2
*/

#define GRPNAM 0xF3C7
#define GRPCGP 0xF3CB
#define GRPCOL 0xF3C9
#define GRPATR 0xF3CD
#define GRPPAT 0xF3CF

/* Passe en vidéo mode 2, 32 sprites actifs */
/**/
void screen_mode_2()
{
  __asm
  
   call 0x0072
  
  __endasm;
}

void put_vram(void* block,int vramaddr,int size)
{
   __asm
  
   ld l,4(ix);
   ld h,5(ix);
   ld e,6(ix);
   ld d,7(ix);
   ld c,8(ix);
   ld b,9(ix);
   call 0x005c;
  
   __endasm;
}

Tout d’abord, la routine screen_mode2 : on ne peux pas faire plus con, on appelle une routine du bios qui fait le travail. La routine du bios se trouve à l’adresse 0x0072.

La routine put_vram est un tout petit peut plus complexe. Cette routine va charger un tableau de données « block », à une adresse dans la vram « vramaddr », pour un nombre d’octet « size ». Son implémentation fait également appel à une routine du bios MSX qui prend les paramètres suivants en entrée :

registres
HL <– Adresse de début des données à écrire
DE <– Adresse VRAM ou écrire ces données
BC <– Nombre d’octer à écrire
0x005c <– Adresse de la fonction BIOS put vram

Dans video.h copiez collez le code suivant :

#ifndef ___MSXVIDEO_H___
#define ___MSXVIDEO_H___

void screen_mode_2();
void put_vram(void* block,int vramaddr,int size);

#endif

Ce sont juste les signatures des fonctions que l’ont à créé.

Maintenant, on va compiler ça. Dans une ligne de commande lancez :

sdcc -mz80 -c video.c

ou

sdcc -mz80 -c –oldralloc video.c

Vous allez avoir de beaux message de WARNING (et pas d’erreur),

I:\CODING\Sources\MSX\TUTO_SOURCES>sdcc -mz80 -c video.c
video.c:40: warning 85: in function put_vram unreferenced function argument : ‘block’
video.c:40: warning 85: in function put_vram unreferenced function argument : ‘vramaddr’
video.c:40: warning 85: in function put_vram unreferenced function argument : ‘size’

car le compilateur n’apprécie que moyennement le mélance C/Assembleur. Mais ça, vous le savez déja…

Maintenant, on va tester si ça marche dans un programme !!

Créez un fichier main.c et copier/coller dedans le code suivant :

#include "tools.h"
#include "video.h"

void main(void)
{
    screen_mode_2();
    while(1){};
}

Maintenant, on va le compiler :

sdcc -mz80 --std-c99 --data-loc 0x8048 --code-loc 0x4020 --no-std-crt0 crt0.rel -main.ihx tools.rel video.rel main.c
ou
sdcc -mz80 --std-c99 --data-loc 0x8048 --code-loc 0x4020 --no-std-crt0 --oldralloc crt0.rel -main.ihx tools.rel video.rel main.c

Alors les paramêtres :

-mz80 –> Compile en assembleur z80
–std-c99 –> Type de vérification syntaxique du C (on s’en occupe pas de ce paramêtre)

–data-loc –> Adresse des datas en rom (J’ai mis en 8048h pour avoir accès aux 32 ko, ça fonctionne pour le tuto et ça semble fonctionner pour mon Lock’n Chase, stay tuned 🙂 )
–code-loc –> Adresse du code en rom
–no-std-crt0 crt0.rel –> Spécifie de ne pas utiliser l’header par défaut, mais celui compilé dans le tuto n°1
-main.ihx –> Nom du fichier en sortie


Les derniers paramètres c’est la liste des fichiers qui vont former la rom, ici à savoir la version compilée de la librairie tools, la version compilée de la librairie video ainsi que le code source de notre programme principal (main.c)

Lancez la commande, il ne doit y avoir aucun message. Dans le répertoire vous devez trouver un fichier main.ihx. Nous allons maintenant transformer ce fichier en rom avec la commande :

objcopy --input-target=ihex --output-target=binary main.ihx result.rom

Pareil, pas de message, mais un fichier result.rom doit être généré.

Maintenant, téléchargez BlueMsx, et charger la rom dans un mode MSX ou MSX2. Lancer là. En base de l’écran BlueMsx, vous allez voir SCREEN n, n étant le mode écran qui est actuellement utilisé. Par exemple en MSX2, on passe de SCREEN 0 à SCREEN 6, et au final si tout c’est bien passé, cela doit afficher SCREEN 2.

Si c’est le cas, vous avez compilé et compilé votre premier programme MSX avec succès !!

Je vous sens pressé d’afficher quelque chose sur l’écran … héhéhéhé. Et bien, affichons des sprites !

Pour rappel , un sprite est une image qui possède une transparence et qui peut être déplacée dans l’écran.
Nous allons, pour faire apparaitre ces sprites, implémenter les fonctions suivantes :

void setup_sprites(char spritesize, char zoom); : Va initialiser le type de sprite que l’on veut : de taille 8*8 ou 16*16, zoomé ou non …

Hé oui, nous avons quasiment déja tout ce qu’il faut pour afficher des sprites !! Etonnant non ?!

Ouvrez le fichier video.c et ajouter la méthode suivante :

/* Définit les attribut général des sprites */
/* spritesize : SPRITE8X8
                SPRITE16X16
   zoom :       SPRITE_NO_ZOOM
                SPRITE_ZOOM    1            */
/**/
void setup_sprites(char spritesize, char zoom){
  __asm
 
  ld b,#0x00
  ld a,4(ix)
  and #0x0f
  cp #0x08
  jr z,$1
  set 1,b ; --- si 16x16 allume bit 1
$1:
  ld a,5(ix)
  cp #0x00
  jr z, $2
  set 0,b ; --- si sprite zoomé => allume bit 0
$2:
  ld hl,#0xf3e0 ;
  ld a,(hl)
  and #0xfc
  or b
  ld (hl),a
  call 0x007e ; --- Change le registre
 
  ld a,#0x01
  ld hl,#0xfcaf
  ld (hl),a
  call 0x0069 ; --- reset la table des attributs de sprites

  __endasm;
}

Alors sans entrer dans les détails, on va mettre certains bit de registre vidéo à 1 ou à 0 pour dire que les sprites font 88 ou 1616 ou si ils sont zoomé ou non.

On modifie le video.h ainsi :

#ifndef ___MSXVIDEO_H___
#define ___MSXVIDEO_H___

#define SPRITE8X8      8
#define SPRITE16X16   32

#define SPRITE_NO_ZOOM 0
#define SPRITE_ZOOM    1

void screen_mode_2();
void put_vram(unsigned char* block,int vramaddr,int size);
void setup_sprites(char spritesize, char zoom);

#endif

Et on le compile avec :

sdcc -mz80 -c video.c

ou

sdcc -mz80 -c –oldralloc video.c

Les sprites sur Coleco/Msx, c’est 2 zone mémoires.

Une zone mémoire image, qui va contenir toute les représentations des sprites. Le début de l’adresse de cette zone est à peek_word(0xF3CF)
Une zone mémoire attributs qui va contenir pour chaque sprite : sa position x,sa position y,le n° de son image,sa couleur (0 à 15). Le début de l’adresse de cette zone est à peek_word(0xF3CD).

Comme vous pouvez de suite le voir, un sprite = 1 seule couleur.

Pour affiche un sprite à l’écran, on va donc les initialiser. Ici on va utiliser le cas le plus complexe, les sprites de 16*16. On décidera de ne pas zoomer.

setup_sprites(SPRITE16X16, SPRITE_NO_ZOOM);

Pourquoi le plus compliqué ? Pour calculer le n° d’image d’un sprite de 8*8 pixels c’est simple, si on veut l’image 0, c’est 0, si on veut l’image 1, c’est 1 … Un sprite de 16*16 est composé de 4 images de 8*8. Et donc le début de l’image 0 = 0, le début de l’image 1 = 1*4 = 4 et le début de l’image 2 = 2*4 etc etc …

Dans ce tutorial, je vais vous donner le code de 3 images, un carré, un triangle et un rond.

// Size = 3 sprites * 4 caractères
//      = 3 sprites * (4*8) octets = 96 octets
//
// pattern de début Carré = image 0 * 4 = 0
// pattern de début Triangle = image 1 * 4 = 4
// pattern de début Rond = image 2 * 4 = 8
const unsigned char SPATTERN[] = {
  0x00, 0x00, 0x00, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x00, 0x00, 0x00,    // Carré
  0x00, 0x00, 0x00, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00,   // Triangle
  0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x01, 0x03, 0x07, 0x0F, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   // Rond
  0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0xC0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

Voilà, on va maintenant charger ces images de sprites à l’adresse mémoire des images de sprites.

 int addr_sprite_pattern;

 addr_sprite_pattern = peek_word(0xF3CF);

 put_vram(SPATTERN,addr_sprite_pattern,96);

Charger les images ne suffit pas … Il faut pour afficher des sprites leur définir une image,une couleur et une position. (A savoir qu’une position de 204 en y par exemple positionne le sprite en dehors de l’écran et le rend donc invisible). ATTENTION, si par exemple le sprite 2 à une position y de 208, les sprites après le sprite 2 ne seront pas affiché !! La valeur 208 est une valeur spéciale.

On sa créer une structure en C, et un tableau de 32 « sprites ».

 typedef struct
{
 unsigned char y;
 unsigned char x;
 unsigned char pattern;
 unsigned char colour;
} sprite_t;

sprite_t sprites[32];

Et maintenant on va définir nos sprites en mémoire RAM :

// Carré
sprites[0].x=10;
sprites[0].y=10;
sprites[0].pattern=0; // Image 0*4
sprites[0].colour=2;
// Triangle
sprites[1].x=42;
sprites[1].y=42;
sprites[1].pattern=4; // Image 1*4
sprites[1].colour=3;
// Rond
sprites[2].x=42+32;
sprites[2].y=42+32;
sprites[2].pattern=8; // Image 2*4
sprites[2].colour=4;

Mais cela ne suffit pas … Il faut maintenant copier cette table d’attribut en VRAM pour activer l’affichage.

addr_sprite_attr = peek_word(0xF3CD);
put_vram(sprites,addr_sprite_attr,4*32);

Compilez avec :

sdcc -mz80 --std-c99 --data-loc 0x8048 --code-loc 0x4020 --no-std-crt0 crt0.rel -main.ihx tools.rel video.rel main.c
ou
sdcc -mz80 --std-c99 --data-loc 0x8048 --code-loc 0x4020 --no-std-crt0 --oldralloc crt0.rel -main.ihx tools.rel video.rel main.c

et

objcopy --input-target=ihex --output-target=binary main.ihx result.rom

Voici le code source complet pour ceux qui sont un peu perdu

#include "tools.h"
#include "video.h"

// Size = 3 sprites * 4 caractères
//      = 3 sprites * (4*8) octets = 96 octets
//
// pattern de début Carré = image 0 * 4 = 0
// pattern de début Triangle = image 1 * 4 = 4
// pattern de début Rond = image 2 * 4 = 8
const unsigned char SPATTERN[] = {
  0x00, 0x00, 0x00, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x00, 0x00, 0x00,    // Carré
  0x00, 0x00, 0x00, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00,   // Triangle
  0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x01, 0x03, 0x07, 0x0F, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   // Rond
  0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0xC0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

typedef struct
{
  char y;
  char x;
  char pattern;
  char colour;
} sprite_t;

sprite_t bsprites[32];

void main(void)
{
    int addr_sprite_pattern;
    int addr_sprite_attr;   
   
    screen_mode_2();
    setup_sprites(SPRITE16X16, SPRITE_NO_ZOOM);
   
    addr_sprite_pattern = peek_word(0xF3CF);
    put_vram(SPATTERN,addr_sprite_pattern,96);
       
    // Carré
    bsprites[0].x=10;
    bsprites[0].y=10;
    bsprites[0].pattern=0; // Image 0*4
    bsprites[0].colour=2;
    // Triangle
    bsprites[1].x=60;
    bsprites[1].y=60;
    bsprites[1].pattern=4; // Image 1*4
    bsprites[1].colour=2;
    // Rond
    bsprites[2].x=42+32;
    bsprites[2].y=42+32;
    bsprites[2].pattern=8; // Image 2*4
    bsprites[2].colour=2;

    addr_sprite_attr = peek_word(0xF3CD);
    put_vram(bsprites,addr_sprite_attr,4*32);

   
    while(1){};
}

Lancez la rom dans un émulateur et … admirez !!!!

Maintenant que vous avez fait tout ça, c’est que vous avez compris les bases pour coder un jeu sur MSX. Je vais maintenant vous simplifier grandement la vie.

Je suis heureux de partager avec vous cette librairie de jeu, qui est téléchargeable à cette adresse :
http://perso.numericable.fr/michel.louvet/files/MSXLIB_OK.zip

Cette librairie contient ce qu’il faut pour piloter la manette et plein d’autres choses pour coder un jeu sur MSX, en plus de ce que nous venons de voir pour comprendre un peu mieux comment on code un jeu sur MSX.

La documentation d’installation est assez sommaire (Readme.txt), et il n’y à pas de documentation « technique » sur la structure mémoire vidéo du MSX.

Par contre, chaque procédure et fonction est documentée dans les .h de l’archive.

En gros cela contient tout ce que je vous ais expliqué plus haut sans avoir normalement à vous prendre la tête. Plus qu’à l’utiliser et à faire vos propre jeu. Elle contient un exemple pour afficher une image, et jouer de la musique en la déclenchant avec la manette. Vous pouvez bien entendu utiliser les sprites comme vu ci dessus, la méthode setup_sprite étant déjà dans la librairie.

Voilà avec les bases du tutos + la librairie technique vous devriez être en mesure de créer des programmes de 32ko sur MSX ! Amusez vous bien !

Votre commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l’aide de votre compte WordPress.com. Déconnexion /  Changer )

Photo Google

Vous commentez à l’aide de votre compte Google. Déconnexion /  Changer )

Image Twitter

Vous commentez à l’aide de votre compte Twitter. Déconnexion /  Changer )

Photo Facebook

Vous commentez à l’aide de votre compte Facebook. Déconnexion /  Changer )

Connexion à %s