Re: [ Demo Disponible !] - Papi Commando Tennis Megadrive - SGDK

[xtopher]

Vraiment cool la planche des personnages ! Fais en des agrandissements pour mettre derrière ton futur stand Vetea.

Lorsqu'on joue en mode robot d'entrainement. Parfois, on voit une bulle (un phylactère) comme si le robot disait quelque chose; chez moi il n'y a que le bas qui apparait; même si Papi monte au filet. Il y est écrit quelque chose normalement? Une engueulade du genre "bouge ton corps de vieux bourré de rhumatismes !!!" ou "#$%@¨!!!!" ?

Sinon, j'ai enfin compris la relation entre l'angle de tir et la longueur de l'appui de la touche avant le coup. La puissance de la balle, une fois compris le principe des trois zones horizontales dans le camp adverse, c'est bon aussi !

[Invité]

Ah ah !!
Le robot informe juste quand la balle est "Faute !!"



Et oui, le gameplay est un tantinet technique bien qu'il soit encore que provisoire.
Le temps d'appui de touche ne joue en rien !
Pour jouer avec les longueurs, il faut utiliser les touches Haut et Bas ou "sans" !

[drfloyd]

Il faudra peut etre un rapide mode démo pour expliquer les bases du gameplay, c'est important, car c'est subtil.

[Invité]

Bonjour à tous,

Depuis quelques temps, je travaille sur les planches principales des joueurs P1 & P2 !
Actuellement, j'ai terminé les vues de base pour mes deux starts du moment : Papi Commando & "Le Doc" !





A la base de mon moteur en jeu, je ne charge que 3 frames pour chaque sprite en VRAM et en fonction du coup, je charge les 3 frames correspondantes pendant le Vblank, ce qui me permet d'économiser ma VRAM pour d'autres trucs.


Tous les coups du tennis sont pratiquement modélisés !! De quoi faire pour les prochains travaux !!
De plus, je suis en plein reprise de l'apprentissage du C pour pouvoir utiliser la SGDK ce qui aussi, me permettra de réaliser des jeux rétros pour d'autres consoles rétros puisque le C est assez répandu. ( satanée ";" ) !!

A bientôt !!

[uran]

Ca serait bien d'ajouter un sprite de dos avec le short qui tombe un peu, genre un animation quand le joueur du bas de l'écran est gentiment mené au score pour souligner qu'il a les boules.

Vas-y SGDK est fantastique

[Invité]

Ouiiiii excellente idée !
J'ai pensé réaliser pour la suite, des animations de célébrations lors d'une victoire ou point victorieux, et de colère lors de défaite ou faute grossière.
Mais là, je me tiens à l'essentiel pour réaliser un jeu de tennis avec règles officielles.

Pour la SGDK, que le ciel t'entende ... faudra me rappeller ces histoires de pointeurs, que je sais utiliser en assembleur 68000, mais dont je n'ai toujours pas compris le sens en C. D'ou mon "blocage" intellectuel.

Tu as une variable Sprite_X, tu lui stocke une valeur entière.
Tu l'as pointe sur une adresse, donc au lieu de passer par la variable, on passe par son adresse pour aller plus vite.
C'est ça, j'ai bon ??

[uran]

.. au lieu de passer par la variable, on passe par son adresse pour aller plus vite.

ça oui, c'est un peu le principe

[Invité]

Merci mon ami.

Defois on se fait des films alors que c'est juste de la série B ...

[Invité]

L'avantage du pointeur est de pouvoir atteindre d'autres espaces mémoire de façon dynamique en changeant juste l'adresse à laquelle tu veux pointer,mais avec juste une seule variable(le pointeur donc) ..

[uran]

D'ailleurs les pointeurs ne sont pas l'apanage unique du C, mais tous les langages n'y ont pas accès. Ca a disparu sur le C#, et je ne pense pas que ça existe sur du basic à part comme pièce rapportée.

[Invité]

Ça se déclare comment ??
Mavariable* ??
Et après ?? 
Tout le monde sait qu'une variable a une adresse mémoire allouée ... 
Bref, je bloque sur ça avec ce foutu C ... Un suppo a la glycérine pourrait régler ça sans doute. :)

[Invité]

Bonjour à tous,

Finalement, après de longues heures pénibles de réflexion, de recherches, de milles et un essais, voici donc officiellement lancé le portage du projet avec la SGDK de Stef !

Qu'ai je fait donc de nouveau ??

Et bien tout est dans cette ROM toute simple :
https://dl.dropboxusercontent.com/u/108143465/SGDK_Ex1.bin



Et oui, le fameux logo Studio Vetea & Gamopat Studio un poil retravaillé.
Après avoir potassé la Documentation, j'ai pu faire même un effet de Fading ( et oui c'est intégré ! ), de même que chargé une image dans la VRAM, l'afficher dans le plan B, etc ...

La plus grande difficulté a été l'usage de Rescomp .. Le Readme.txt n'est vraiment pas clair pour moi !
Après avoir faillit foutu la SGDK à la poubelle, j'ai compris qu'il fallait créer un fichier *.res dans lequel, il faut écrire les commandes dédiées ... Et oui, je suis loin d'être une lumière. 

Par la suite, j'ai aussi compris que bon nombre d'instructions dédiées et variables sont "Case sensitive", gaffe aux minuscules / majuscules, le compilateur n'aime vraiment pas.

J'ai aussi compris comment fonctionne le fichier de ressources qui est ensuite crée et comment il interagit avec les classes du Kit.
Le fichier .S est de type assembleur et donne toutes les informations de notre ressource, par contre il ne faut pas le laisser dans le même répertoire que *.res, le compilateur n'aime pas non plus !

Après concernant la syntaxe, je n'ai pas fait grand chose au niveau de la logique, la boucle principale est vide pour le moment ! 

Mais je compte ajouter les différentes screens du jeu d'origine.

J'aimerai aussi re-créer mon effet de transition d'image ... A voir si j'arrive à faire ça avec SGDK.

Bon, ben voila .. Alea jacta est.

[uran]

nb: d'où sors-tu l'image de SGDK du début de ton post ?

[Invité]

Ben j'ai tapé "SGDK Stef" sous google puis ensuite "Images" et la tu auras l'embarras du choix !!

Sinon je viens de comprendre comment convertir des nombres en texte !
Avec la commande sprintf !!

Bon du coup, je commence déjà à taper du code !
A part les ";" que j'oublie souvent et puis le "Case sensitive" à respecter.

[uran]

A part les ";" que j'oublie souvent et puis le "Case sensitive" à respecter.

les ';' c'est juste un reflexe à prendre.
Par contre le "case sensitve" il n'y a pas que le C qui y est sensible, t'avais pas ça en basic même PC ou en assembleur 68K ?

L'avantage de certaines éditeurs c'est qu'ils intègrent l'auto-complétion. Notepad++ le fait aussi, CB doit le faire je pense, après je reste sur Sublim text pour ce genre de truc sympa entre autre :)

[Invité]

Avec Bex, on pouvait y aller sans problème !
En Assembleur, oui tout à fait !
Avec Code::Blocks, sans doute qu'il y a un truc à régler .. A voir !

[Invité]

Et voila !
J'ai réussi à intégrer du son et a coder mes premières routines en C ...

MaJ de la Rom :
https://dl.dropboxusercontent.com/u/108143465/SGDK_Ex1.bin

Bon ben finalement, c'est parti !

[uran]

Et voila !
J'ai réussi à intégrer du son et a coder mes premières routines en C ...

MaJ de la Rom :
https://dl.dropboxusercontent.com/u/108143465/SGDK_Ex1.bin

Bon ben finalement, c'est parti !

bis

[Spirale]

C'est cool.

Si tu partages l'avancement de ton travail avec autant d'enthousiasme que tes autres projets, tu va finir par convertir d'autres personnes au SGDK. (déjà très nombreux apparemment)

Du coup, tu abandonnes Bex ?

Au plaisir de te lire ici.

[upsilandre]

Vetea en phase de professionnalisation en passant du basic au C, mais jusqu'ou ira t'il? bientot on retrouvera la marque Vetea entre Activision et EA.

[Invité]

Merci Mick' !

Je n'abandonne pas totalement Bex, mais j'avais envie de me lancer un petit défi avec SGDK et une technologie avec laquelle j'ai beaucoup de mal.
Après, si l'expérience se révèle positive, et bien oui, je pourrai poursuivre l'aventure avec SGDK, voire étendre mes jeux sur d'autres consoles puisque le C est partout !
Et en plus, ça peut m'être bénéfique pour d'autres choses ...

[Stef]

Vetea> Content de te voir sauter le pas, félicitations :)
Concernant les fichiers, en fait SGDK préconise l'organisation suivante :

• files (C, S, ASM, S80): root directory or src directory
  
• includes files (H, INC): root directory or inc directory
  
• primary resource files (C, S, RC, RES): root directory or res directory
  
• others resources files (TFC, TFD, PCM, RAW, WAV, BIN, BMP, PNG): can be wherever you want while you are referring them correctly in your resource definition files
  

En gros pour ton projet tu peux faire des sous répertoires comme suit :
- 'src' : contient tes fichiers sources .c, .s ou .s80 (assembleur z80)
- 'inc' : contient les fichiers headers .h
- res : contient les fichiers ressources .res (et normalement ce qui y est rattaché comme .png, .wav etc...)

Ca structure un peu le projet mais ce n'est pas obligatoire, on peut tout aussi mettre dans le répertoire de base et ça marche =)

[uran]

cool, demain matin je vais pouvoir tester le 1er niveau de papi commando tennis au boulot

[Invité]

Ah ah ...
Déjà, j'affiche une image sur un plan avec un effet de Fading IN/OUT ! 

La je sèche à charger une image "Tileset" de 5 Tiles de 32x32.


- J'ai compris qu'il fallait une palette indexée avec plus de 4 couleurs, c'est fait !

- Maintenant, j'utilise donc Rescomp avec mon Gfx.res ou je configure le tout :
TILESET Eclat_Image "gfx/Eclat.png" -1
( j'ai mis -1, c'est compressé ... après je sais pas si c'est utile ici ... )

- Maintenant, tout est compilé correctement ( merci #include "gfx.h" ! )

- Après je voudrais charger mes 5 tiles dans ma VRAM.
Pour cela, il y a : VDP_LoadTileSet ( ou bien que ce soit VDP_LoadTileData ?! )
Bon, à partir de la, je bidouille un peu, ça compile correctement, mais je ne retrouve pas mon TileSet dans la VRAM ( avec Gens KMOD )

En fait, je voudrais utiliser des Tiles ( au lieu de Sprite ) et faire une petite animation d'éclat sur l'une des lettres du logo, en chargeant toutes les xFrames les 5 images de mon TileSet.
En Bex, c'est super simple, mais là je ne vois pas comment faire ... :)

[uran]

Et avec VDP_setTileMapXY ?

[Invité]

En fait, je crois que je vais utiliser une solution un peu plus "Bas Niveau" ( comme le mien  ) !
Déclarer manuellement mon TileSet ... 

Il y a un exemple qui explique bien la méthode : Hs_Effect !
Je testerai ça dans la semaine ! :)

[Stef]

Normalement c'est bien VDP_loadTileSet(..) si tu utilises directement la ressource Eclat_Image.
Par contre, faut bien voir que tu envois juste un ensemble de tiles en VRAM et un tile c'est toujours du 8x8 quoiqu'il arrive Après bien sur ils seront chargés selon l'ordre de l'image.

Si je peux te donner un conseil sur comment faire ça :
Déclare ta ressource comme une image et non pas comme un tileset.
La différence c'est que l'image contient en interne un tileset + un tilemap + une palette.

Ensuite tu fais ça :

Code:

// chargement des tiles à la position TILE_USER_INDEX (defaut)
VDP_loadTileSet(Eclat_Image.tileset, TILE_USER_INDEX, TRUE);
// chargement de la palette
VDP_setPalette(PAL0, Eclat_Image.palette->data)
// affichage d'une portion de l'image à une position donnée
VDP_setMapEx(PLAN_A, Eclat.map, TILE_ATTR(PAL0, FALSE, FALSE, FALSE, TILE_USER_INDEX), x, y, xmap, ymap, wmap, hmap);

xmap, ymap & wmap, hmap indique la region de l'image d'origine que tu souhaite afficher.
Dans ton cas pour ton animation tu devras faire  :

Code:

VDP_setMapEx(PLAN_A, Eclat.map, TILE_ATTR(PAL0, FALSE, FALSE, FALSE, TILE_USER_INDEX), x, y, 0, 0, 4, 4);

Code:

VDP_setMapEx(PLAN_A, Eclat.map, TILE_ATTR(PAL0, FALSE, FALSE, FALSE, TILE_USER_INDEX), x, y, 0, 4, 4, 4);

Code:

VDP_setMapEx(PLAN_A, Eclat.map, TILE_ATTR(PAL0, FALSE, FALSE, FALSE, TILE_USER_INDEX), x, y, 0, 8, 4, 4);

Code:

VDP_setMapEx(PLAN_A, Eclat.map, TILE_ATTR(PAL0, FALSE, FALSE, FALSE, TILE_USER_INDEX), x, y, 0, 12, 4, 4);

[Invité]

Merci Stef !

J'étais parti sur une solution "tout à la main", mais je n'arrivais pas à charger des Tiles de 16x16 un peu comme ça :

Code:

const u32 Eclat_Image[NumeroTileEclat*32] =
{
   0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000080, 0x00000008,
   0x00000080, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
   0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x80000000, 0x00000000,
   0x80000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
   0x00000000, 0x00000000, 0x00000000, 0x00080000, 0x00000000, 0x00000800, 0x00000088, 0x00000088,
   0x00000088, 0x00000800, 0x00000000, 0x00080000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
   0x00000000, 0x00000000, 0x00000000, 0x00800000, 0x00000000, 0x08000000, 0x80000000, 0x80000000,
   0x80000000, 0x08000000, 0x00000000, 0x00080000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
   0x00000000, 0x00000000, 0x00800008, 0x00080008, 0x00000000, 0x00000880, 0x00000888, 0x00880088,
   0x00000888, 0x00000880, 0x00000000, 0x00080008, 0x00800008, 0x00000000, 0x00000000, 0x00000000,
   0x00000000, 0x00000000, 0x00080000, 0x00800000, 0x00000000, 0x88000000, 0x88000000, 0x80088000,
   0x88000000, 0x88000000, 0x00000000, 0x00080000, 0x00008000, 0x00000000, 0x00000000, 0x00000000,
   0x80000008, 0x00000000, 0x00800008, 0x00080008, 0x00000088, 0x00000888, 0x00008888, 0x80888888,
   0x00008888, 0x00000888, 0x00000088, 0x00080008, 0x00800008, 0x00000000, 0x80000008, 0x00000000,
   0x00000800, 0x00000000, 0x00080000, 0x00800000, 0x80000000, 0x88000000, 0x88800000, 0x88888080,
   0x88800000, 0x88000000, 0x80000000, 0x00080000, 0x00008000, 0x00000000, 0x00000080, 0x00000000,
};

TileEclat est un TileSet de 4 Tiles de 16x16 ( soit 2x8 + 2x8 = 32 )
J'avais pensé ensuite chargé le tout avec :

Code:

    VDP_loadTileData(Eclat_Image, TILE_USERINDEX, 4, 1);

Par contre, je ne sais pas si je met 4 ou bien 4*32 ( ou 4*16 )
Ou peut être que je me gourre complétement !

Dans tous les cas, merci pour ton exemple, je regarderai ça demain, car la il faut se coucher et demain je me lève à 4h45 ... 

[Stef]

Quand tu manipules des tiles, il faut toujours considérer des tiles de 8x8, donc dans ton cas si tu as 4 tiles de 16x16, ça signifie que tu as 16 tiles de 8x8.

Donc ça sera :

Code:

VDP_loadTileData(Eclat_Image, TILE_USERINDEX, 16, TRUE);

[Invité]

Mercii Stef pour ta disponibilité !!

[Invité]

Re moi !!

Et bien, j'aurai une autre question relatif à ma précédente ...
Toujours en utilisant ma déclaration "à la main", et aprés avoir chargé mes TileData dans la VRAM ( ils y sont ! ), comment puis je les afficher à l'écran ?!

VDP_DrawImage ne semble pas adapté avec ce genre de méthode, à moins qu'il faille déclarer un pointeur sur mon Tile Eclat_Image ... 
Désolé si je n'utilise pas les bons termes pour les puristes ...

Merci !