mercredi 31 octobre 2012

Création de jeux sous MSX : Création de la librairie graphique



Aujourd'hui, on va mettre 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 :

#include "video.h"

/*
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(unsigned char* 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

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, si vous avez suivi le précédent tuto ... 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

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 !!
Allez, dans le prochain tuto, on essayera d'affiche un sprite, ça sera plus excitant :)




mardi 30 octobre 2012

Début de conversion de Lock'n Chase sur MSX

Les tutos vont continuer, mais de mon coté je tente d'adapter la librairie Coleco au MSX. Et finalement, ce n'est pas ça le plus problématique.

Je suis parti de mon code source de Lock'n Chase sur Coleco que j'ai recompilé tel quel sur MSX, en ayant pris soin d'adapter les portions de librairies nécessaire bien sur. 2 gros problèmes sont apparus ...

Le modulo (%) qui fonctionne sur Coleco (mais est gourmand en processeur) ne fonctionne pas sur MSX ... Je ne vois vraiment pas pourquoi ... Je n'ai pas analyser la source assembleur, j'ai plutôt remplacer par l'opérateur AND qui est plus rapide et faire la même chose bien utilisé. Exemple :

if ((mavariable%8))==0 {} est remplaçable par if  (mavariable&7))==0 {} hélas, j'avais un modulo 10, que je ne peux pas remplacer comme cela. L'animation devra être plus rapide car j'ai utilsé un &7.

Ensuite, j'ai l'impression que je ne dispose pas de 32 ko de rom mais peut être uniquement de 16 ko ... En effet, si j'ai le titre du jeu en mémoire, le personnage passe à travers la zone du bas du labyrinthe, comme si elle n'était pas chargé, ou accessible en ROM ... Je ne sais pas pour le moment comment régler le problème...

Sinon voici en vidéo ce que ça donne pour le moment.


jeudi 25 octobre 2012

Création de jeux sous MSX : Création de la librairie "Outils"



Aujourd'hui, on va mettre en place la première brique de notre librairie de jeu. Nous allons créer et compiler 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

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.

Voici la fin de ce tutorial, pour l'instant rien de bien excitant, mais encore quelques épisodes et on rentrera dans le vif du sujet :)

Création de jeux sous MSX : Mise en place des outils



Bienvenue dans ce premier tutorial sur la programmation de jeux sous MSX.
Dans cette série de tutoriaux, vous allez apprendre en même temps que moi à :

- 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 :)


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

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

Dans cette première partie, je vais 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 apelle 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é
 
 - OBJCOPY : http://www.ccjvq.com/newcoleco/

  OBJCOPY est à récupérer dans le pack de Daniel Bienvenu, cela 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 pack, 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 du kit de développement de Daniel Bienvenu (Il se trouve dans : z80/tools/System). 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




Ne me demandez pas une explication de ce code, j'avoue ne pas avoir la maitrise de cette partie ... Si jamais quelqu'un qui maitrise veut bien expliquer la chose en commentaire, j'en serais fort aise :)

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.

Voilà, on s'arrête ici pour cette première partie, dans la prochaine, on va commencer à développer notre librairie de jeu pour MSX.

mercredi 24 octobre 2012

Bidouille ... Grenouille.


Les quelques personnes qui suivent mon blog reconnaîtrons dans l'image ci dessus un des fonds de Youki pour la version Coleco de Bomb Jack. Sauf que ... ceci tourne sur ... MSX !

Concrètement, je suis en train d'adapter la librairie Coleco de Daniel Bienvenue sur MSX. Alors pour le moment, c'est hyper lent, mais j'arrive déja à afficher les fonds non compressé, à partir de l'outil graphique Coleco, ainsi qu'à afficher des sprites.

J'ai encore plein d'interrogations, mais je pense que je ferais des petits tutos pour expliquer comment développer en C sur MSX avec quasiment tout les mêmes outils que sur la Coleco. 

Et au passage, j'ai du me mettre quelquepeut à l'assembleur :) :)

mardi 23 octobre 2012

Attack wave editor


Lors du développement d'Ozma Wars, une des difficultés à été de copier les mouvements des ennemis de la version Arcade, à la version Coleco. J'ai du tout me taper à la main, dans une structure en C du genre :

 Pendant 3 mouvement tu vas faire x=x-1 et y=y+1
 Pendant 5 mouvement tu va faire y=y+1
 Boucle

Depuis pas mal de temps je me disais que je devais coder quelquechose qui permettait de définir graphiquement ces mouvement d'ennemis, et c'est maintenant fait :) Le seul éditeur de ce genre que je connaisse est dans "Shoot em up construction Kit" sur C64 ou on définissait les vagues d'attaques à la manette.

Ici vous vous servirez du clavier de de la souris. C'est très "roots", ça à été codé en quelques heures, mais dans l'archive que vous trouverez plus bas, il y à le code source, si vous désirez améliorer la chose. Attention, le code source n'est pas du tout "propre" et vraiment codé à l'arrache ...

Voici les commandes :


Liste des touches :

F1 - Sauvegarder l'attack wave (QuickSave)
F2 - Charger l'attack wave (QuickLoad)
N - Tout effacer et recommencer une attack wave (New)
T - (T)ester l'attack wave --> Démarre l'attaque wave à la position de la souris
Curseur Droite et gauche - Se déplacer dans les points pivots
Suppr - (S)upprimer un point pivot
R - (R)etracer l'attaque wave
P - Voir les (P)ivots
D - (D)iviser le nombre de pivot par 2

C - passer en mode modification point pivot / quitter le mode modification point pivot (Change)
Curseur Haut / Bas / Gauche / Droite - Bouger un point pivot

Echap - Quitter l'application et générer le code source dans stdout.txt qui se trouve dans le répertoire du logiciel.

Fichier stdout.txt
------------------

Il contient 2 définitions d'attaque wave :

1)
const char awc[] --> Contient les mouvement relatif.

Ex :

2,0,1, --> Faire 2 fois x = x + (+0) et y = y + (+1)
1,-1,-1, --> Faire 1 fois x = x + (-1) et y = y + (-1)

2)
const char aw_pivot[] --> Contient les positions absolues des points pivots (x,y).

A utiliser pour d'autres algorithmes de type Bresenham.

Voici maintenant le fichier à télécharger : http://dl.free.fr/uvb04qEqB

Ce fichier restera actif pendant 30 jours, après cela, envoyez moi un mail pour récupérer le logiciel ;)
Bonne bidouille !

mardi 16 octobre 2012

WIP d'Ozma Wars PC Engine

Voici une vidéo d'Ozma Wars PC Engine, avec intégration des graphismes retravaillés par Crapahute. Ce n'est pas encore la dernière version des graphismes. Les sprites s'accorderont mieux avec le fond.


jeudi 11 octobre 2012

BFG Bulletin news 12/10/2012

Plusieurs annonces que je regroupe dans un seul billet.

- Je "quitte" CollectorVision. Ce qui ne veut pas dire que je n'éditerais plus de jeu chez CollectorVision, mais que je pourrais monter mes propres équipes de beta test et éventuellement bosser sur des projets qu'on me propose. Ma décision à été mûrement réfléchit et j'ai prévenu CollectorVision il y à une demi heure.

- Je continue à développer sur Colecovision. Je m'ennuyais, je ne savais pas quoi coder, puis encore une fois, ma petite routine de boule de pang à encore frappé, les fonds graphiques de Youki aussi et voici le résultat en vidéo :



Le sprite devrait changer au final, pour quelquechose de plus lisible en 2 couleurs. Le fond des bombes va également changer dans certains nivaux. Bref, il y à encore énormément de travail à effectuer, et ça sera certainement pour l'année prochaine.

- En parallèle je continue à bidouiller sur la PCEngine, même si pour le moment c'est plus pour le fun que pour une distribution physique. Le portage à été fait en un temps record de quelques heures :) :



Voilà, c'est tout pour le billet du jour :)

mardi 9 octobre 2012

Pacman Collection offert par OPCODE !!


Le sublime Pac-man collection d'OPCODE sur Colecovision est offert à cette adresse : http://www.atariage.com/forums/topic/131570-pac-man-collection-colecovision-completed-going-beta-test/page__st__700#entry2615022 à condition d'être inscrit sur Atariage.

C'est OPCODE lui même qui offre cette rom. Pour la tester, un seul émulateur est capable de la faire tourner, c'est BlueMsx. Lors de l'ouverture de la rom, il faut choisir dans la liste déroulante du dessous l'option "Colecovision Megacart(r)"


Bon amusement, car ce portage est tout simplement FABULEUX !

Lock'n chase RC2.8 envoyé à CollectorVision


On va y arriver !! La release candidate 2.8 à été envoyé à CollectorVision. Quoi de plus dedans ? Et bien carrément un mode de jeu "inédit" à la Colecovision. Au lieu de toujours tourner sur le même labyrinthe, il y en aura d'autres !! (2 laby de plus). Pourquoi cela risque d'être la toute dernière release, parce qu'il ne reste que 700 octets dans la rom pour corriger des bugs le cas échéant, et que j'ai décidé qu'il n'y aura plus d'évolutif sur ce jeu, qui je pense est relativement addictif si on cherche à scorer !

EDIT :

L'extended mode en vidéo :