vendredi 30 novembre 2012

Revival Chase

Ca y est, le site de Revival étant à jour, je peux en parler !! Dans le cadre du n° 50 de Revival, j'ai participé au "bonus" de ce n° à savoir un jeu PCEngine CD-ROM. Mais pour plus de détail voici tout d'abord le teaser de ce Revival 50 :


Ainsi qu'une fiche un peu plus détaillée du jeu à cette adresse : Revival Chase.

Pour encore plus de détail, un making-of croustillant, une seule solution, précommandez votre n° de Revival n° 50 !!!! :) :)

No News ... Good News ?

Un petit post pour dire que je n'ai pas abandonné les tutos MSX. Il y en à 2 autres à paraitre mais ils seront publiés quand j'aurais déménagé les précédents sur bfg-le-site.fr.

Je n'ai par contre, toujours pas trouvé comment adresser en C, les 32 ko octets de ROM possible, je suis toujours limité à 16ko, ce qui fait qu'il m'est impossible, pour le moment, de porter les jeux Coleco sur MSX. Dommage, car à part ce soucis, la conversion des jeux est possible à 100% avec excessivement peu de modifications ...

Et au passage, dans les jours qui arrivent attendez vous à une grosse annonce :)

Restez à l'écoute !! ;)

jeudi 22 novembre 2012

QuizWiz

J'ai découvert grace à allgamers, que CollectorVision distribuait la rom QuizWiz que j'avais commencé à développer. Il semblerait que si vous avez bon aux 30 questions, que vous pouvez gagner un cadeau ici  ...

Par contre il vend la chose en cartouche pour 30$ ... Soyons clair (mais il le précise dans son post), cette rom n'est pas terminée, c'est de l'alpha version, sans son, sans musique, sans animation, rien que 30 questions. Quand je vois sur le forum AtariAge des gens qui la commande en disant que ça à l'air d'être super cool, je crois que je vais commencer à développer des Pong au lieu de tenter de faire des bons trucs, car on à les mêmes encouragements dans tout les cas :) :) Sérieusement, n'achetez pas ce truc, c'est ridicule.

Sinon, la rom est disponible à cette adresse : http://bfg-le-site.fr/tele_quizz.html

mercredi 7 novembre 2012

Création de jeux sous MSX : Affichage de sprites.





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

Implémentation :

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 8*8 ou 16*16 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

Les sprites : la théorie

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

 1 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)
 1 Zone mémoire attribut 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.

Les sprites : la pratique

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. On apprendra à créer ces images dans un autre tutorial, à la main, et avec des utilitaires qui vont bien :)

// 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 0xc000 --code-loc 0x4020 --no-std-crt0 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 !!!!

Dans le prochain tuto, on va faire bouger tout ça... A la manette !!

mardi 6 novembre 2012

Pang Coleco en version RC2.0


C'est en se mouchant qu'on devient moucheron, c'est en codant, qu'on s'améliore :)

Fort de ma nouvelle expérience sur un jeu qui sera dévoilé certainement en Décembre, j'ai réussit à éliminer 99% des ralentissements sur la version Colecovision de Pang et ce en ... 5 lignes de codes !!!

La rom partait chez le fabricant en fin de semaine, et je viens de modifier, tester et envoyer la RC2.0, version optimisée de Pang sur Colecovision à CollectorVision !! Juste à temps.

Si seulement les patchs existaient sur cartouche, j'aurais pu utiliser la même technique sur Ozma Wars Coleco, hélas, à l'époque je ramait encore sur la machine ...

Il y à bien entendu encore des ralentissements en particulier sur le niveau en entête de ce message, mais ces ralentissement ne surviennent que dans un cas très particulier, qui je pense n'est même pas possible sans utiliser un cheat qui transformerait les 2 grosses balles directement en toutes petites. (Ce que j'utilise pour mon "stress" test :) ). En gros, quelqu'un qui joue normalement, ne devrait plus ressentir de ralentissements ! (En toute cas dans les 2 heures que je viens de passer à jouer, je n'ai rien ressentit de tel.)

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 :


mercredi 26 septembre 2012

Expérimentation : Alim PC sur ColecoVision


Avertissement : ceci n'est pas un tuto, mais une expérimentation. Vous pouvez suivre ce que je fais, mais je ne suis pas responsable des résultats.

Je possède 2 Colecovision, dont une qui à un transfo qui fait que l'image n'arrête pas de sauter. Le transfo Coleco est quasi impossible à démonter, et même après ça, je vois pas ce que je pourrais réparer la dedans.

J'ai donc tenté d'alimenter la Coleco avec une alimentation de PC. Pour cette expérience il m'a fallu :

 - une alimentation PC capable de délivrer du +5 Volts, -5 Volts, + 12Volts, et 2 masses. Bref une ancienne alim PC devrait faire l'affaire.
- Un transfo Coleco (Pas obligatoire, mais ça évitera de souder directement sur la console)
- Un multimètre (Voltmètre et continuité)
- Un fer à souder et de l'étain
- Une pince à couper
- Une pince à dénuder
- Un trombone en métal
- Un disque dur ... (Ou un ventilo, ...) vous verrez pourquoi.


Voici ce qu'il faut en tension pour alimenter une Colecovision :



     + 5 Volt sur la PIN 1
     - 5 Volt sur la PIN 2
     +12 Volts sur la PIN 3

Mais commençons par le commencement. Il va falloir bidouiller la prise principale du transfo PC. C'est celle en photo ci dessous :


Et voici ce que représente chacun des pin de cette prise (mon détrompeur en haut est représenté à droite sur le schéma) :



Tout d'abord, il faut savoir qu'une alim PC ne s'allume pas si les PIN PS_ON et COM ne sont pas reliés. Donc, on peut soit, avec un trombone, relier PS_ON et COM sur la fiche, soit, comme moi, couper le fil vert de PS_ON, le fil noir du COM et les souder ensemble.

Ceci fait, mettre en route l'alim, et mesurer la tension +12VDC par exemple en mettant le multimètre sur +12VDC et sur un COM restant. Soit il y à du jus (et normalement le ventilo de l'alim devrait déja tourner), soit non.

Dans ce cas, il faut brancher un disque dur par exemple sur une autre des autres prises de l'alimentation. Le transfo ayant une charge, le courant va être "débloqué" (Désolé de ne pas savoir être plus précis, je ne suis pas du tout spécialiste).

Bref, dès que vous arrivez à mesurer le +12,-5,+5, vous avez quasiment terminé. Coupez, dénudez et mettez de l'étain sur chacun de ces fils. Chez moi les couleurs des fils étaient :

 Noir pour la masse
Jaune pour le +12 V
Blanc pour le - 5V
Orange/Rouge pour le +5V

Prenez votre alim Coleco, et coupez le cable de sorti (couper pour avoir un long fil !!) :


Dans ce cable, on trouve 4 autres petits cables à dénuder et mettez de l'étain. Chez moi :

Bleu pour la masse
Rouge pour le +12V
Jaune pour le-5Volt
Blanc pour le +5Volt.

Vérifiez absolument la continuité sur votre cable Coleco . Mettre une des extrémité de votre testeur de continuité dans un des trou de la prise, et l'autre extrémité sur un des fils. Si le testeur réagit, c'est que ça communique.

Maintenant, il faut soudes les fils entre eux. A savoir.

Bleu Coleco sur Noir PC
Rouge Coleco sur Jaune PC
Jaune Coleco sur Blanc PC
Blanc Coleco sur Orange/Rouge PC 


Mettez du chatterton autour de chaque soudure, pour éviter que tout cela se touche entre eux. (Et j'ai ajouté du chatterton autour les 4 chatterton)

Dans mon cas, je branche la prise Coleco sur la Coleco, le disque dur sur l'alim PC, j'allume l'alim PC et la Coleco ensuite et ... tadadada !! Ca marche ! Bien que le ventilo de l'alim PC ne tourne pas ...

Bon, bref voilà ce que j'ai fait pour que ça fonctionne. Maintenant, si quelqu'un peut expliquer clairement ce qu'il faut mettre pour éviter d'avoir un disque dur pour faire fonctionner le truc, je suis preneur !!

@++



vendredi 21 septembre 2012

Lock'n chase RC2.7 envoyé à CollectorVision

Daniel Bienvenu étant loin de la scène ColecoVision, j'ai donc sonorisé moi même Lock'n Chase sur Coleco avec de nouvelles routines sonores. J'en ai profiter pour changer le système de flickering, (mon tout premier) qui était quand même disons le ... maladroit (voire pourri) :)

La Release Candidate 2.7 (!!!) est donc dans les mains de CollectorVision, et je l'espère pour acceptation.


mercredi 19 septembre 2012

Tutorial : Overlay Data et images sur PCEngine

NOTE : Tout les outils de création d'overlay data et de conversion d'images se trouvent à cette adresse : http://onorisoft.free.fr/pce/pce.htm 
 
Dans le 1er tuto, on a vu comment utiliser les Overlay d'execution.Voici maintenant comment utiliser les overlay de données.

Imaginons par exemple qu'on veut faire un slideshow de 20 images (16 couleurs les images). On va éviter de mettre ces images directement en statique dans le 1er overlay d'execution (En effet, si je ne dis pas de bétise, le 1er overlay est limité à 192 ko tandis que les autres à 256 ko.), et on va plutôt charger les images à partir du CDROM pour éviter de faire exploser la mémoire.

1) Convertir des images BMP en format PCEngine

Prenons l'exemple d'une image BMP 16 couleurs de résolution 256*224. On va passer ceci à la moulinette de BMP2PCE.
Sous DOS il faut taper :

bmp2pce BG monImage.bmp

Ceci va générer 3 fichiers :

monImage.pal
monImage.gfx
monImage.map

que l'on va renommer ainsi :

monImage_pal.bin --> Contient la palette de l'image
monImage_gfx.bin --> Contient des données graphiques
monImage_map.bin --> Contient la map de l'image

2) Un mot sur le mode graphique de la PCEngine

La PC engine utilise un mode graphique appelé PLANAR. Une image se découpe en petit bloc de 8*8 pixels. le fichier gfx contient ces petits blocs uniques.

Exemple j'ai une image ainsi :

AAAAAAA
BBBBBBB
CCAAACC

Le fichier gfx ne contiendra que les blocs graphique représentant A,B et C. On gagne donc en place graphique.

Le fichier MAP contiendra lui l'endroit ou affiche ces blocs.
Si A=1 B=2 C=3 la map contiendra pour simplifier

111111
222222
331133

avec pour fichier graphique ABC. Ce qui est moins lourd que de stocker tout l'image. (A = 8*8 word, et 1 = 1 word pour simplifier ... c'est un peu plus complexe.)

3) Réunir les fichiers images

Voilà, maintenant qu'on à nos 3 fichiers il faut les réunir dans un seul overlay, avec la commande DOS suivante :

pcecdpak.exe 0 imagesovl.bin imagesovl.h monImage_gfx.bin monImage_map.bin monImage_pal.bin

En gros, nos 3 fichiers vont se retrouver dans un seul fichier imagesovl.bin, et en bonus on aura un fichier imagesovl.h qui nous donnera l'endroit exact ou chercher les données.

4) Le fichier .h

Ce .h contient pour chaque fichier de l'ovl, l'adresse de départ ou se trouve le fichier,ainsi que sa taille. On pourra passer ça ensuite simplement en paramêtre des fonctions de chargement.

#define OFS_monImage_gfx_bin 0 --> Position du fichier monImage_gfx.bin
#define SIZE_monImage_gfx_bin 13664 --> Taille du fichier monImage_gfx.bin
#define OFS_monImage_map_bin 7 --> etc etc ...
#define SIZE_monImage_map_bin 1792
#define OFS_monImage_pal_bin 8
#define SIZE_monImage_pal_bin 32


5) Afficher les images.

D'abord dans notre programme on va inclure les .h qui vont bien à savoir :

#include "huc.h"
#include "imagesovl.h"


On va déclarer en RAM une zone tampon pour la palette :

char palTmp[32];

Et voici notre programme principal :

main() {
            /* On initialise la sortie graphique */
           set_screen_size(SCR_SIZE_32x32);
           init_satb(); disp_on(); /* Active la sortie ecran */

           /* On charge la palette dans la zone tampon RAM */
           cd_loaddata(2, OFS_monImage_pal_bin, palTmp, SIZE_monImage_pal_bin); /* On spécifie à la PC Engine qu'on utilise cette zone en RAM comme palette */
           set_bgpal(0, palTmp);

           /* On charge la map en vram à l'adresse 0X0000 = Adresse de la map en VRAM */
           cd_loadvram( 2,OFS_monImage_map_bin , 0x0000 , SIZE_monImage_map_bin); /*map*/

           /* On charge les tiles = données graphiques en vram à l'adresse 0X1000 = Adresse de la map en VRAM */
          cd_loadvram( 2,OFS_monImage_gfx_bin , 0x1000 , SIZE_monImage_gfx_bin); /*tile*/

          while (!(joy(0)&JOY_STRT)){}
          cls();
}


cd_loaddata va chercher dans le second overlay (le 1er étant ce programme) le fichier monImage_pal.bin pour le transférer dans le tableau palTmp. Ensuite on explique à la PCEngine que c'est cette palette qui va servir pour l'image. (set_bgpal)

cd_loadvram lui, charge directement les données en VRAM.

Par exemple :

          cd_loadvram( 2,OFS_monImage_map_bin , 0x0000 , SIZE_monImage_map_bin); /*map*/ va chercher dans l'overlay 2 le fichier monImage_map.bin et va le balancer à l'adresse VRAM 0x0000, à l'endroit ou la PCEngine va chercher ses maps.

Idem pour les gfx, sauf à l'adresse 0X1000.

6) Création de l'iso.

Comme dans le 1er tuto on va créer notre iso avec les commandes :

Compilation et création de l'overlay du programme principal

bin\huc.exe -over -cd testImage.c
bin\pceas.exe -over -cd testImage.s


Création de l'iso

bin\isolink.exe testImage.iso testImage.ovl imagesovl.bin

L'overlay d'execution principal doit être en 1ere position, puis vient les overlay de data. Les overlay de data doivent IMPERATIVEMENT avoir l'extension .bin. (et .ovl pour ceux d'execution).

7) Conclusion

Je sais que je fais des tutos rapide, mais si vous cherchez ce genre d'infos c'est que avez déja les mains dans le camboui, et de la graisse jusqu'au cou ! :) Donc je ne pense pas qu'il soit nécessaire de détailler plus, ou de vous prendre par la main, et que devriez être capable maintenant non seulement d'afficher des images, mais de stocker tout et n'importe quoi dans les overlays (fichiers textes, musique, ...). Si je trouve de nombreuses heures libres, je ferais peut-être un tuto plus générique pour démarrer la programmation PCEngine, mais on trouve ce genre de tuto je pense en grand nombre déja sur la toile.

8) Remerciements :

Merci à TOUKO pour sa patience face à mes incompréhesions. Sans lui je n'aurais pas pigé grand chose à l'affichage d'image à partir d'Overlay sur PCEngine ! Merci énormément !

mardi 18 septembre 2012

Starcom : la vidéo


Maintenant que les exemplaires de Starcom ont été distribué, je pense avoir l'autorisation de montrer plus de chose sur ce jeu. Donc voici une vidéo ingame, capturée à partir de mon petit PC, donc le jeu est plus fluide sur le hardware original, mais cela donne quand même une idée du jeu.


Tutorial : Utilisation des Overlay d'execution sur PCEngine

Retrouvez dorénavant ce tutorial à cette adresse : http://bfg-le-site.fr/pcengine/overlay1.html

lundi 3 septembre 2012

Précision sur la distribution de Starcom


Petite précision sur le mode de distribution de Starcom. En effet je me prends pas mal de remarque dans la tronche. JE NE GERE PAS LA DISTRIBUTION ET LA VENTE DES JEUX !

Starcom à été une demande de CollectorVision pour les 30 ans de la ColecoVision. CollectorVision n'avait jamais caché qu'il désirait avec ce jeu, financer la création d'un moule permettant la création des cartouches. (Ce qui coûte bonbon).

<MODE RAS LES COUILLES ON>
Pour toute réclamation, écrivez à CollectorVision, ou écrivez aux personnes qui sont prêtes à mettre plus de 450$ dans un jeu homebrew. (J'ai déja du mal à mettre 20 Euros dans une mégadrive ...).

De plus, pour certains jaloux qui m'ont déja incendiés, que les 30 jeux se vendent 10000$, 15000$ ou un milliard de dollar, je ne toucherais pas un seul copec de bonus ou quoi que ce soit. Si vous croyez que coder des homebrews rend riche, n'hésitez pas, mes tutoriaux pour faire des jeux Coleco sont dispo sur ce blog, ainsi que les sources de quelques jeux ! Il ne vous restera plus qu'à passer entre 200 et 250 heures de coding pour faire rentrer un jeu comme Starcom dans 1ko de RAM et 32ko de ROM.

BON COURAGE !

<MODE RAS LES COUILLES OFF>

Voilou, quelquefoit, il faut juste que ça sorte ... Je retourne tenter de niquer ce @#! de dernier boss à PainKiller ...

dimanche 2 septembre 2012

Retour de la braderie de Lille 2012


Après 3 jours et d'innombrables kilomètres, voici le bilan de ma braderie de Lille 2010. La braderie commence officiellement Samedi, en fin de matinée, mais les affaires se font généralement dès Vendredi matin.

De mon coté ça à commencé

- Vendredi soir : prêt de l'esplanade

Je jette mon dévolue sur des jeux Atari 2600, hélas, à 5 Euros pièces, les jeux en loose, je laisse tomber. Ça commence bien ... Ensuite je vois un vendeur avec des 32X en boite, des neogeo CDZ en boite. Il me dit qu'il à vendu déjà 7 32X depuis ce matin !! Un de ces collègues arrive d'ailleurs avec d'autres 32X en boite et autre CDZ. Les prix sont corrects, mais hélas je ne trouve pas mon bonheur (pas intéressé par la Jaguar, la 3DO, la 32X ... les consoles de la loose quoi :D :D)

Finalement, je rencontre un petit vendeur d'une 10 aines d'années déja très pro et très sympa et je lui achète de quoi nourrir ma Mégadrive avec :

 - Strider en boite US (sans notice)
- Turbo outrun (sans notice)
- Steel empire (loose) : un très chouette shoot em up
- Time Killer (loose) : un jeu de baston que je ne connaissais pas, et que j'aurais mieux fait d'éviter :) :)


Et chez un brocanteur ou il n'y avait pas de jeu vidéo, j'ai quand même dégoté un Croisière pour un cadavre version Amiga complet !!



En passant, je vois une SNES en boite ... 100 Euros. No comment.

C'est finit pour Vendredi

- Samedi à partir de 11 heures c'est rue d'Arras, de Cambrai et le boulevard Victor Hugo

Alors là, c'est de la science fiction. Les "caves à Momo" sont là, avec leurs jeux vidéo à étiquette délavé, poussiéreux et foutu en vrac. Le prix cette année d'un quelconque jeu NES en loose est de ... 20 Euros !!! (Véridique !!!!!! Demandez à ma femme si vous ne me croyez pas).
Rue de Cambrai, un jolie stock de bon jeu, mais avec des prix également élevé. (Mais j'y suis retourné Dimanche ...) Plus loin quelques jeux Atari 2600 pas trop cher, mais je n'étais plus motivé :) J'ai recontré un autre collectionneur qui ma filé son mail, il me donnera la liste de ces doubles. 

Par désespoir j'ai récupéré ça :


- Need for speed pour me remémoré le plaisir que j'avais eu avec ce jeu sur PC ... C'est raté, c'est à chier sur Psone
- Destruction dervy 2 : je ne sais plus ou est mon exemplaire : je suis toujours aussi mauvais.
- Circus Maximus : Parce que je voulais le tester ...
- Hulk (Xbox 360) : Pas sur la photo, pour avoir un simulateur de destruction massive :)

Puis retour rue d'Arras pour se reposer à la maison un peu avant d'y retourner, je tombe sur ça :



Une mégadrive 2 avec 2 manettes, cable et transfo pour ... 5 Euros !! Bien entendu, je n'ai pas hésité 2 secondes, n'ayant plus depuis belle lurette de modèle 2 chez moi ...

La journée passe et j'arrive dans le vieux Lille, ou je croise le stand du Monsieur de la Madame qui tiens le magasin génération 80 à Bruay. Il m'avait déja acheté des trucs lors d'une broc, et il exposait. Les prix étant juste, voire même intéressant, j'ai opté pour ceci :


- Super mangentic Neo version JAP sur Dreamcast, avec sa pochette ou les ronds sont des autocollants :)
- James Bond, pour nourrir MES mégadrive :)
- Une compil Starblade Alpha et Twisted metal sur Psone
- Et surtout : Tail Concerto !! Yes, j'avais revendu ce jeu comme un crétin, cet exemplaire restera chez moi !!

- Dimanche matin, on à prévue Gambetta, quelques rues dont je ne connais pas le nom puis retour sur Victor Hugo.

Rien à Gambetta, un vendeur plus loin qui vendait Mortal Kombat Mégadrive en loose à ... 12 Euros !! Parce que : "sur cette version il y à le sang !!". Ouais, enfin comme sur toutes les version Mégadrive hein ducon ... (En pensée hein !! :) ). Bref, je passe mon chemin rapidement (et bizarrement je n'étais pas le seul ...).

Bref, j'abrège, sur le chemin je trouve ça :



Des Bds qui sont sorties en kiosque il y à à peine 3 mois, liquidés à 1 Euros pièces. Je ne les avais pas acheté neuve car ça me faisait trop de magazine à suivre (5.90 Euros le mag ...) Bref, je suis content.

Ensuite je trouve ça :


Des magazines Banzaï en forme de "journal". Les 8 pour 6 Euros. Hélas il manque certaines pages, mais bon ...

Puis :


Je suis retourné rue de Cambrai au gros vendeur bien cher, j'ai du craquer sur Demon Attack sur Atari 2600. Les prix des jeux 2600 étant raisonnable. Plus loin, j'ai craqué sur Centipède ...

Et au final :


Ce que vous ne voyez pas sur la photos c'est que pour 2 Euros le jeu + 5 Euros j'ai eu la Super Nes qui va avec, 2 manettes, 1 adaptateur US/EURO et 3 transfos ... dont pas un seul ne marche :) La console fonctionne bien par contre avec un autre de mes transfos SNES, bref une bonne affaire.

C'est finit tout court, j'ai mal partout, je suis crevé, et pour une fois pas mécontent. Bref comme toujours, ne pas céder aux sirènes des vendeurs pro et être patient. Une MD + une SNES pour 10 Euros, en sachant qu'en moyenne je les ais vue à 40 Euros pièce en loose, je suis content !!! En plus j'ai trouvé Demon attack ... JOIE !! Reste plus que Stampede et Pitfall 1 et 2 et je pense avoir tout ce que j'ai envie sur 2600.

Voilou !!

vendredi 31 août 2012

Starcom : visuel 3d de la boite

J'ai découvert ce jour que la vente des 30 exemplaires de starcom avait commencé sur Ebay par CollectorVision. Voici donc pour commencer le visuel de la boite, toujours créée par Crapahute !


Puis 2 extraits de la doc toujours made in Crapahute.



samedi 28 juillet 2012

Consécration !!


Je suis interviewé dans le PIX'N LOVE 21, dans le cadre des 30 ans de la Colecovision. Hélas, je suis crédité pour Chack'n pop, jeu Coleco que je n'ai absolument pas développé ... Si j'avais pu relire l'interview avant publication, j'aurais pu leur éviter cette erreur ... tant pis :)

Sinon à part cette erreur, le Mock est toujours aussi bon, intéressant, coloré ... bref PIX'N LOVE c'est que de la balle bébé !!

mardi 24 juillet 2012

Adamcon 2012

Voici en vidéo la présentation de CollectorVision au cour de l'Adamcon 2012. Vous pourrez y voir Starcom, le jeu secret enfin dévoilé, ainsi que la présentation du stick arcade pour Coleco, Zombie Near et un jeu d'échec.



lundi 23 juillet 2012

Tutorial : Musique sur Coleco partie 2

Réclamé à corps et à cri par MO5.com :) :) voici la seconde et dernière partie du
tutorial pour faire de la musique sur Coleco.
Je vais tout de suite faire un disclaimer, c'est la partie que je maitrise le moins. Ce que je vais vous expliquer fonctionne quand on le mets en place, mais techniquement je n'entrerais pas dans les détails, car je ne suis pas capable de donner d'explications techniques.

Rappel :

On à créé nos partitions et nos bruitages, reste plus qu'à les jouer.
La musique et les bruitages se jouent de 2 manières différentes. Prenons l'exemple suivant :

2 bruitages : un tir et une explosion
1 musique avec 2 voix

On déclare comme on l'a vue dans le précédent tutorial.

    .module sounds

   
    ; ********************
    ;  DECLARE GLOBAL TABLES
    ; ********************
   
    .globl  _snd_table
    .globl  _music2
   
    .area _CODE
   
; bruitage de tir
shoot:
.db 0x41, 0x20, 0x30, 0x03, 0x11, 0x10
.db 0x41, 0x20, 0x60, 0x03, 0x11, 0x10
.db 0x41, 0x20, 0x90, 0x03, 0x11, 0x10
.db 0x50 ; Fin channel 3
   
;bruitage d'explosion
explode :
    .db 0x00,0x00,0x07,0x08, 0x02,0x77,0x08,0x18,0x11
    .db 0x10

;partition de game over channel 1
gameOver_ch1:
.db 0x40,0xA0,0x00,36;,0x61 ; F-4
.db 0x40,0xAA,0x00,36;,0x61 ; E-4
.db 0x40,0xD6,0x00,24;,0x61 ; C-4
.db 0x40,0xBE,0x00,36;,0x61 ; D-4
.db 0x40,0xD6,0x00,60;,0x61 ; C-4
.db 0x40,0xAA,0x00,48;,0x61 ; E-4
.db 0x50


;partition de game over channel 2
gameOver_ch2:
.db 0x80,0x7F,0x00,36;,0xA1 ; A-4
.db 0x80,0x8F,0x00,24;,0xA1 ; G-4
.db 0x80,0x8F,0x00,36;,0xA1 ; G-4
.db 0x80,0xA0,0x00,36;,0xA1 ; F-4
.db 0x80,0xAA,0x00,57;,0xA1 ; E-4
.db 0x80,0xB4,0x00,9;,0xA1 ; D#4
.db 0x80,0x71,0x00,42;,0xA1 ; B-4
.db 0x90

vide:
    .db 0x50



Maintenant, on va déclarer tout ça dans un tableau de "partition" (sound table)

_snd_table:
    .dw    #vide,0x702b                    ; = 1
    .dw    #explode,0x702b+40            ; = 2
    .dw    #shoot,0x702b+40            ; = 3
    .dw    #vide,0x702b+40          ; = 4
    .dw    #vide,0x702b+50          ; = 5
    .dw    #vide,0x702b+10               ; = 6
    .dw    #vide,0x702b+20               ; = 7
    .dw    #vide,0x702b+10            ; = 8
    .dw    #vide,0x702b+20         ; = 9   
    .dw    #gameOver_ch1,0x702b+10          ; = A
    .dw    #gameOver_ch2,0x702b+20          ; = B
    .dw    #vide,0x702b+10           ; = C
    .dw    #vide,0x702b+20           ; = D
    .dw    #vide,0x702b+30           ; = E
    .dw    #vide,0x702b+30            ; = F
    .dw    #vide,0x702b+30               ; = 10
    .dw    #vide,0x702b+30          ; = 11
    .dw    #vide,0x702b+40                  ; = 12
    .dw    #vide,0x702b+20                  ; = 13
    .dw    #vide,0x702b+20                  ; = 14



La partition ou bruitage 1 de cette liste doit être mis à vide (pourquoi ? Je ne sais pas mais ça évite certains plantage).
Le premier paramétre déclaré est la partition et le bruitage, puis sa "priorité".

exemple : .dw #explode,0x702b+40 ; le + 40 donne la priorité du bruitage explode.

La rêgle la plus simple est la suivante : Une partition de voix 1 --> +10 de voix 2 --> + 20 etc etc et les bruitages, + 40
Il est donc conseiller de mettre la rythmique de votre musique dans la voix 3, car la Coleco ne sachant que jouer 3 voix à la fois, si vous déclenchez le buitage, ça sera donc la rythmique qui ne s'entendra plus le temps du bruitage, au lieu de la mélodie.

Avec cette "table", on est déja capable de jouer les bruitages dans notre programme principal avec

stop_sound(2);play_sound(2);

pour jouer le bruitage de l'explosion par exemple.

Pour jouer une musique à 2 voix, il faut déclarer autre chose, à savoir la "séquence musicale" (music sequence)
Une "séquence musicale" est un enchainement/mixage de partition.

_music2:
    .dw 0x00c0     ; On joue la musique pendant combien de temps ?
    .db 0x4a,0x0b ; Voir description
    .dw 0x0000 ; Stop à la fin de la partition
    .dw _music2 ; Boucle à _music2, mais comme il y à un stop ça sert à rien.

   
Alors, ça à l'air compliquer mais c'est pas compliqué. :) :)

    .dw 0x00c0 : donne le temps MAXIMUM qu'on joue la musique. Si la musique dure 3 secondes, et qu'on lui dit de la jouer pendant 5 secondes, on aura 3 secondes de musique et 2 secondes de silence avant d'enchainer un autre ensemble de partition ou de boucler le cas échéant. La valeur est à tester par rapport à la longueur de votre composition, je n'ai pas d'équivalence valeur/nb de secondes en tête. (D'ailleurs ce n'est pas des secondes mais des Ticks, car la valeur reste la même en 50Hz et 60hz, pas besoin d'avoir 2 versions de votre musique)
   
    .db 0x4a,0x0b : Signale qu'on va jouer la partition 0x0a ET la partition 0x0b dans la snd_table en même temps.

    Si on veut jouer 3 voix simultanément on mettre
    .db 0x8a,0x0b,0x0c : Pour jouer 0x0a et 0x0b et 0x0c en même temps
   
    Pour jouer une seule voix, c'est simple
    .db 0x0a pour jouer la partition 0x0a dans la snd_table
   
    .dw 0x0000 : Pour dire que la musique s'arrête
    ou
    .dw _music2 : Permet de rejouer au début.

Rien ne vous empêche d'enchainer les partitions

exemple :

_music_test:
    .dw 0x00c0
    .dw 0x0a    ; Joue la partition 0x0a pendant 0x00c0 temps
    .dw 0x00c0
    .dw 0x0b    ; puis joue la partition 0x0b pendant 0x00c0 temps
    .dw 0x0000    ; stop


   
Maintenant, pour jouer votre musique INGAME. Pour cela, dans la NMI ajouter la chose suivante :

void nmi(void)
{
    update_music();
}

Puis dans le jeu :

play_music(music);

ou

stop_music(); 

pour tout stopper.

Voilà, vous avez de quoi bidouiller et faire vos propres essais musicaux sur Colecovision. Pour plus de détail, n'hésitez pas à me contacter !