Développer du homebrew en langage basic aujourd'hui... c'est possible

[drfloyd]

Si dans les années 80 et 90 développer un jeu en basic était un loisir purement personnel sans grandes possibilités de faire quelque chose de correct...

Aujourd'hui il y a des outils incroyables qui permettent d'envisager de programmer en basic des jeux de bonne qualité.



Pour PC

Il y en a beaucoup, voici les plus célèbres à mon sens :

GFA BASIC 32 (version 2021)
Version PC du cultissime langage qui a revolutionné le basic sur Atari ST
http://www.gratilog.net/xoops/modules/mydownloads/singlefile.php?cid=72&lid=3257

QB64 qui permet de faire de belles choses ! Un basic Microsoft hyper standard, une évolution du Quick Basic qui etait livré avec MSDOS. Seul l'editeur est un peu austère, c'est le meme que dans les années 80 ! Entierement gratuit.
Nouvelle version en 2019 : https://www.portal.qb64.org/

BLITZ MAX / BLITZ 3D surement le plus accessible et simple l'utilisation ! Il est dsormais assez ancien et se trouve gratuitement.

DARK BASIC PRO
Anciennemnt payant, gratuit désormais
Vieux mais excellent, très très simple d'utilisation (proche de Blitz)
On en discute encore sur les forums, il n'est pas mort
https://github.com/LeeBamberTGC/Dark-Basic-Pro

PUREBASIC, j'ai essayé, je n'ai pas aimé : ca s'éloigne du basic standard, c'est austère... mais il y a des fans

GL BASIC, très proche de BLITZ, et multiplaforme, jusque Android er iOS (voire Xbox), mais payant

FREEBASIC, le successeur de Quick Basic / QB64

NAALAA
http://www.naalaa.com
Les instructions:
http://www.naalaa.com/Documentation/index.html
Très bon petit langage basic, avec un interface dédié hyper simple

APP GAME KIT, le successeur de DARK BASIC et DARK BASIC PRO
s'éloigne trop des standards du basic hélas... je déteste, dommage, car c'est un langage tout neuf
https://www.appgamekit.com/

SPECBAS, issu du basic Sinclair !!! (Spectrum et ZX81), mais avec des rajouts énormes...
https://sites.google.com/site/pauldunn/

RC BASIC en cours d'éval (commandes très sympa en tout cas) Gros avantage : toujours soutenu par son développeur

SMALL BASIC non testé

SDL BASIC pas mal mais vraiment à l'abandon et très ancien

IW BASIC (ex EMERGENCE BASIC)ancien aussi, et payant... une version 64bit serait malgré tout en préparation. J'ai testé, c'est très très bon, proche de la phylosophie de BLITZ, des commandes simples
https://www.ionicwind.com/iwbasic.html

Pour CONSOLES & MICRO

Le GFA BASIC 3.5 pour ATARI ST
Culte de chez culte. Un interface revolutionnaire pour les années 80 ! Lié à un compilateur puissant.

BATARI BASIC pour Atari 2600. De nombreuses cartouches homebrew ont été mise au point avec ce langage !
http://bataribasic.com/

RAPTOR Basic pour Atari Jaguar
http://reboot.atari.org/new-reboot/rbplus/index.html

BasiEgaXorz pour Sega Megadrive "BEX"
Sur notre forum FL a déjà programmé Barbarian, et Vetea Papy Commando. Ce basic est très puissant, aucun doute possible !

Et Second Dimension, basé sur BEX :
http://www.second-dimension.com/second-basic

ZXbasic pour Master System
Un projet abandonné ?????
http://www.smspower.org/forums/12902-ZXBasicForSegaMasterSystem
Mais il faut aussi programmer en assembleur de toute façon, donc trop austère....

A priori on pourrait aussi faire des jeux Colecovision avec le module Coleco du ZX Basic :
http://www.boriel.com/wiki/en/index.php/ZX_BASIC:Released_Programs_-_ColecoVision

DRAGON basic pour GBA
Abandonné. j'ai trouvé un lien :
http://www.gbadev.org/tools.php?showinfo=195
documentation : [url=http://ric.san.free.fr/_donnees/dragon basic.pdf]http://ric.san.free.fr/_donnees/dragon%20basic.pdf[/url]

KUN BASIC pour MSX
Qui permet de booster le basic MSX1 et compiler le programme... mais trop rudimentaire (il n'utilise que les instructions du basic classique MSX 1)

LE BLITZ BASIC POUR AMIGA
Langage fabuleux (adapté ensuite sur PC)
http://ubb.plus/
https://github.com/AmiBlitz/AmiBlitz3

Par contre Amiblitz3 c'est quoi ? Nouvelle version ?

CHIPMUNK BASIC pour Playstation 1
Attente infos
Le site : http://psxbasic.sourceforge.net/

INTY BASIC pour Intellivision
http://atariage.com/forums/topic/222570-intybasic-compiler-v05/page-6

Un projet non commencé de BASICVISION sur Colecovision par Pixelboy :
http://atariage.com/forums/topic/158528-basicvision-official-development-thread/page-2

7800BASIC, Un basic pour l'ATARI 7800 basé sur Batari :
http://www.randomterrain.com/7800basic.html#introduction

GAME BASIC pour Sega Saturn, avec des exemples impressionnants !
ici un lien vers plein de programmes exemples/demo/jeux :
https://www.satakore.com/sega-saturn-complete-game-basic,,1,,1.html

FAST BASIC sur ATARI XL
Qui semble bien puissant.
https://github.com/dmsc/fastbasic/blob/master/manual.md

XC Basic pour C64
Semble facile d'accès et puissant
https://xc-basic.net/doku.php

UGBasic pour la plupart des micro 8bit ! C64, Atari XL, Spectrum, Vic 20, MSX, (bientot Amstrad, Coleco)
Basic compilé (PC/linux) au code source unique pour tous le supports ! Un basic simple façon BLITZ/GFA avec un IDE moderne et pratique.
Encore en cours d'amélioration et de rajout de nouveaux supports (début 2022)
https://ugbasic.iwashere.eu/

CPC BASIC 3 CROSS COMPILER
Super interface pour coder en un clone proche du Locomotive Basic, mais bien plus rapide et compilé direct en .BIN ou en .DSK !
http://cpcbasic.webcindario.com/CPCBasicEn.html

TURBO RASCAL
Pour developper en pascal sur quasi tous les micro ! Ok c'est pas du basic, mais ca ressemble
https://lemonspawn.com/turbo-rascal-syntax-error-expected-but-begin/

En pascal il y a aussi MAD PASCAL pour Atari 8bit :
https://forums.atariage.com/topic/240919-mad-pascal/

VISION BASIC C64
Un basic super amélioré pour le C64
https://visionbasic.net/

SPEEDY WONDER
Compilateur basic pour micro Thomson
http://dcmoto.free.fr/programmes/speedy-wonder/index.html

BOING BASIC
En cours de dev pour Colecovision, par NanoChess, l'auteur de Intybasic
https://forums.atariage.com/topic/362182-colecovision-basic-compiler-cvbasic-v010/


Pour Android

Basic!
http://rfobasic.freeforums.org/


Vous en connaissez d'autres ? Listons ici tous ces outils !!!!

[drfloyd]

UP

[F.L]

il y a eu un debut de compileur basic pour master system :
http://www.smspower.org/forums/12902-ZXBasicForSegaMasterSystem
par contre, je ne suis meme pas arrivé à lancer le programme 
apparement, le projet est en stand-by depuis le temps, voire abandonné
dommage, car j'etais fortement interessé
si quelqu'un ici a des nouvelles, ou bien s'il arrive a lancer le programme, ça serait sympa de le dire

[drfloyd]

merci pour l'info, je le rajoute à la liste en tout cas.

Pour Coleco, Gameboy, MSX et Nes ca serait top....

D'ailleurs pour MSX2 je crois me souvenir qu'il y a un utilitaire qui booste les perfs du basic standard.... pour en faire un basic ultra rapide. Faut que je redemande à Ericb59.

[drfloyd]

il y a eu un debut de projet d'idée pour un basic Coleco par PIXELBOY :

http://atariage.com/forums/topic/197428-colecovision-basic/

[drfloyd]

il existerai un Dragon basic sur GBA.....

[F.L]

il existerai un Dragon basic sur GBA.....

interessant ça
je vais tester ce soir !
@+

[tfdi]

Au risque de dire une conner** ...  ... j'ai jeté un coup d'œil rapide au ZXB (le compilateur basic pour la master system), chez moi ca fonctionne.

Je compile et j'obtiens un BIN. Bon après je n'ai pas de quoi tester ce bin, il faut utiliser un émulateur pour la master system ou une cartouche spéciale sur une master d'origine ?

C'est un compilateur en ligne, qui fonctionne sous la console.

Pour compiler, tu passes en mode console ms-dos, tu vas dans le sous-dossier bin, et tu tapes "zxb fichier.bas", ca te génère un fichier bin.

Pour compiler les exemples, tu peux donc faire (toujours en console ms-dos), dans le dossier de l'exe:

zxb examples\circle.bas

Ca te génère bien un circle.bin dans le dossier ou te te trouve quand tu tapes la commande. Les sources .bas sont éditables avec un simple editeur texte, j'utilise Notepad ++, ca fonctionne impec.

Après, il faut creuser pour voir les possibilités, mais à priori, ce n'est qu'une alpha.

[Fabf]

D'ailleurs pour MSX2 je crois me souvenir qu'il y a un utilitaire qui booste les perfs du basic standard.... pour en faire un basic ultra rapide. Faut que je redemande à Ericb59.

C'est le KunBasic.

Sur MSX il existe un compilateur Basic mais il est plutôt rudimentaire niveau graphiques et ne supporte que les instructions MSX1.

Sinon il y a aussi 2 utilitaires qui permettent de faire une ROM (et donc une cartouche) à partir d'un programme Basic.
Limitation à 16ko.

Au sujet du Basic, il y a souvent des concours de prog avec des productions étonnantes :
http://www.msx.org/news/en/new-msx-basic-contest-and-magazine

[goux.m]

Pour PC, il y a Naalaa

http://www.naalaa.com/

"NaaLaa stands for 'Not An Advanced Language At All'. It's a very easy to learn programming language for beginners interested in retro style game development. NaaLaa is free to use and you may do whatever you want with the programs you create with it. As it is, NaaLaa only runs on and compiles for Windows desktop"

[F.L]

Au risque de dire une conner** ...  ... j'ai jeté un coup d'œil rapide au ZXB (le compilateur basic pour la master system), chez moi ca fonctionne.

Je compile et j'obtiens un BIN. Bon après je n'ai pas de quoi tester ce bin, il faut utiliser un émulateur pour la master system ou une cartouche spéciale sur une master d'origine ?

C'est un compilateur en ligne, qui fonctionne sous la console.

Pour compiler, tu passes en mode console ms-dos, tu vas dans le sous-dossier bin, et tu tapes "zxb fichier.bas", ca te génère un fichier bin.

Pour compiler les exemples, tu peux donc faire (toujours en console ms-dos), dans le dossier de l'exe:

zxb examples\circle.bas

Ca te génère bien un circle.bin dans le dossier ou te te trouve quand tu tapes la commande. Les sources .bas sont éditables avec un simple editeur texte, j'utilise Notepad ++, ca fonctionne impec.

Après, il faut creuser pour voir les possibilités, mais à priori, ce n'est qu'une alpha.

merci beaucoup pour les infos !!
j'ai du basic à tester ce soir !!

[tfdi]

De rien

[drfloyd]

Pour PC, il y a Naalaa

http://www.naalaa.com/

"NaaLaa stands for 'Not An Advanced Language At All'. It's a very easy to learn programming language for beginners interested in retro style game development. NaaLaa is free to use and you may do whatever you want with the programs you create with it. As it is, NaaLaa only runs on and compiles for Windows desktop"

tiens...

mais c'est du pur basic ? impossible a trouver des exemples ou la liste des commandes.... Le site est vraiment dépouillé !

[F.L]

Au risque de dire une conner** ...  ... j'ai jeté un coup d'œil rapide au ZXB (le compilateur basic pour la master system), chez moi ca fonctionne.

Je compile et j'obtiens un BIN. Bon après je n'ai pas de quoi tester ce bin, il faut utiliser un émulateur pour la master system ou une cartouche spéciale sur une master d'origine ?

C'est un compilateur en ligne, qui fonctionne sous la console.

Pour compiler, tu passes en mode console ms-dos, tu vas dans le sous-dossier bin, et tu tapes "zxb fichier.bas", ca te génère un fichier bin.

Pour compiler les exemples, tu peux donc faire (toujours en console ms-dos), dans le dossier de l'exe:

zxb examples\circle.bas

Ca te génère bien un circle.bin dans le dossier ou te te trouve quand tu tapes la commande. Les sources .bas sont éditables avec un simple editeur texte, j'utilise Notepad ++, ca fonctionne impec.

Après, il faut creuser pour voir les possibilités, mais à priori, ce n'est qu'une alpha.

merci pour ton aide, je viens enfin de compiler cette fameuse rom circle.bin !!
j'ai testé vite fait avec kega fusion, ça ne marche pas. il faut que je teste ça plus serieusement
@+

[dub]

Pour zxb-sms !

J'ai juste fait un petit test. Y a des erreurs de compil mais j'ai pas eut le temps de regarder le code. j'ai utilisé l'alpha 0.04 et testé avec l'example de base et celui sur example src

1. Compiler en assembleur, dans le rép exemple, lancer build.bat (ou copier build.bat dans un rép source avec un fichier .zxb et modifier le fichier build.bat pour le chemin et nom du fichier). On obtient plein de files mais surtout un .zxi
2. Compiler pour sms. %PATH%\zxb-sms-alpha-0.04\bin\zxb test.zxi
On obtient un .sms

D'après les infos, on doit toujours coder une partie en asm.

[goux.m]

tiens...

mais c'est du pur basic ? impossible a trouver des exemples ou la liste des commandes.... Le site est vraiment dépouillé !

Quand tu as téléchargé le basic, tu as accès à la doc via le menu Help/Documentation

Sur le forum, il y a pas mal d'exemples.
Ca à l'air simple, mais j'ai pas eu le temps de m'y intéresser ... Je suis sur autre chose en ce moment

[tfdi]

F.L.: En fouillant un peu, je suis tombé sur ca :

"At the moment, ZXB-SMS doesn't support many of Boriel's ZX Basic features, so multiplication, division, string manipulation, sound/graphical commands, etc. simply wouldn't work, but they could be made to work in the future."

Si t'es anglophobe, ca indique en clair que l'outils de conversion en SMS ne supporte pas certaines commandes du Boriel's ZX Basic, comme les multiplications, divisions, commandes de manipulation des chaines de caractères, commandes de son / graphiques, etc. Une grosse partie donc doit toujours être programmée en asembleur, comme le dit Dub.

J'ai téléchargé la derniere version du Zxb, version 1.4.0s1902, l'outil de conversion zxb-sms a disparu, il n'est plus fourni avec le basic.

[F.L]

merci pour les expliquations, tfdi
ça faisait un moment que ce zxbasic m'intrigait et il me semblait plein de promesses car j'aurais bien aimé faire un jeu sur une autre console que la megadrive.
hela pour moi je ne connais pas l'assembleur...
il ne me reste plus qu'a attendre que raptorbasic sur jaguar soit fini (un jour) ou essayer dragonbasic pour gba (enfin je viens de lire qu'il fonctionne de maniere procedurale et donc on ne peux pas utiliser ni goto ni gosub... ça commence mal)
plus je galere à trouver des compileurs basic qui fonctionnent vraiment en basic, plus j'aime BEX
Doc, en haut de page, tu as oublié de mentionner Bonaf qui a aussi fait un jeu avec Bex sur ce forum
@+

[dub]

J'ai vu aussi un basic pour PSX mais pas testé : PSX Chipmunk BASIC

Pour le zxb-sms faut voir, la partie assembleur semble déjà codé par pas de monde est limité à pariori pour le hard genre pour lire les pads ou updatesprite :

Code:


sub fastcall UpdateSprites()
   asm
      ; Since it's a fastcall function, you can do that.
      jp UpdateSprites ; Jumps directly to the actual asm routine
   end asm
end sub

sub fastcall WaitForVBlankNoInt()
   asm
      ; Since it's a fastcall function, you can do that.
      jp WaitForVBlankNoInt ; Jumps directly to the actual asm routine
   end asm
end sub

sub fastcall SetSprite(num as UByte, x as UByte, y as UByte, tile as UByte)
   asm
      exx
      pop hl ; ret addr
      exx

      ld d, 0
      ld e, a      ; de = num
      pop bc      ; b = x
      
      ld hl, hw_sprites_y
      add hl, de
      pop af
      ld (hl), a   ; hw_sprites_y[num] = y

      ld hl, hw_sprites_xc      
      add hl, de
      add hl, de
      ld (hl), b   ; hw_sprites_xc[num << 1] = x
      
      inc hl
      pop af
      ld (hl), a   ; hw_sprites_xc[(num << 1) + 1] = tile

      exx
      push hl ; stores ret addr back
      exx
   end asm
end sub

const joyUpMask    as UByte = 1
const joyDownMask  as UByte = 2
const joyLeftMask  as UByte = 4
const joyRightMask as UByte = 8
const joyFireAMask as UByte = 16
const joyFireBMask as UByte = 32

function fastcall ReadJoypad1() as UByte
   asm
      in   a, ($dc)   ; Reads joystick 1
      cpl         ; Inverts all bits
   end asm
end function

function fastcall ReadJoypad2() as UByte
   asm
      in   a, ($dc)   ; Reads UP and DOWN
      cpl         ; Inverts all bits
      rla
      rla
      rla         ; Puts them into the 2 lower bits
      and   $03      ; Masks them
      ld   l, a
      in   a, ($dd)   ; Reads the remaining bits
      cpl         ; Inverts all bits
      add   a, a
      add   a, a      ; Shifts them to the correct position
      or   l      ; Groups them with the first two
   end asm
end function


Sinon le code source du jeu que j'ai mis en images au dessus avec le lien vers les "examples src" :

Code:

#include "hardware.zxi"
#include "sprite.zxi"
#include "random.zxi"
#include "test.zxi"

dim joy as UByte
dim frameTimer as UInteger

const VisibleMinX   as UByte = 16
const VisibleMaxX   as UByte = 256 - 16
const VisibleMinY   as UByte = 0
const VisibleMaxY   as UByte = 192

const VisibleTilesMaxY   as UByte = (VisibleMaxY - VisibleMinY) / 16


const BackgroundCharMaxY   as UByte = 28
const BackgroundPixelMaxY   as UByte = BackgroundCharMaxY * 8


const ActorMinX         as UByte = 8
const ActorMaxX       as UByte = 256 - 8
const ActorFrameTile   as UByte = 4
const ActorDirTile      as UByte = 8
const ActorTileShift   as UByte = 4


const ScoreBaseTile      as UInteger = 0
const ScoreTileCount   as UByte = 20


const LaneCount         as UByte = 7
const LaneCharHeight   as UByte = 3
const LaneTop         as UByte = 1
const LaneBottom      as UByte = LaneTop + LaneCount * LaneCharHeight
const LanePixelTopLimit   as UByte = LaneTop * 8 + 8
const LanePixelHeight   as UByte = LaneCharHeight * 8
const LaneBaseTile      as UByte = $B0

const PlayerMinY      as UByte = LanePixelTopLimit
const PlayerCenterX      as UByte = 128

const PlayerWidth   as UByte = 16
const PlayerHeight   as UByte = 16

const PlayerBaseTile   as UByte = 16

dim playerX, playerY, playerFrame as UByte
dim playerFireDelay as UByte
dim playerCurrentLane, playerTargetLane as UByte
dim playerTargetY as UByte
dim playerLookingLeft as UByte


const ShotMemSize   as UByte = 2
const ShotMemShift   as UByte = 1
const ShotXOfs      as UByte = 0
const ShotFlagOfs   as UByte = 1

const ShotFlagLeft   as UByte = 1
const ShotFlagRight   as UByte = 2

const ShotBaseTile   as UByte = 32

dim shots(1 to LaneCount * ShotMemSize) as UByte


const EnemyMemSize   as UByte = 4
const EnemyMemShift   as UByte = 2
const EnemyXOfs      as UByte = 0
const EnemySpdOfs   as UByte = 1
const EnemyTypeOfs   as UByte = 2
const EnemyTimerOfs   as UByte = 3

const EnemyBaseTile   as UByte = 48

const EnemyTypeMask      as UByte = 7
const EnemyTypeSlow      as UByte = 0
const EnemyTypeMedium   as UByte = 1
const EnemyTypeFast      as UByte = 2
const EnemyTypePellet   as UByte = 3
const EnemyTypeBall      as UByte = 4
const EnemyTypeArrow   as UByte = 5
const EnemyTypeTank      as UByte = 6
const EnemyTypePhantom   as UByte = 7


dim enemies(1 to LaneCount * EnemyMemSize) as UByte


asm
    ld a,%11100110
;          |||| |`- Zoomed sprites -> 16x16 pixels
;          |||| `-- Doubled sprites -> 2 tiles per sprite, 8x16
;          |||`---- 30 row/240 line mode
;          ||`----- 28 row/224 line mode
;          |`------ VBlank interrupts
;          `------- Enable display
    out ($bf),a
    ld a,$81
    out ($bf),a
end asm


sub DrawShip(x as UByte, y as UByte, baseTile as UByte, facingRight as UByte)
   if frameTimer band $10 then
      baseTile = baseTile + ActorFrameTile
   end if

   if facingRight then
      baseTile = baseTile + ActorDirTile
   end if
   
   AddDoubleSprite(x, y, baseTile)
end sub


sub DrawPlayerShip()
   DrawShip(playerX, playerY, PlayerBaseTile, not playerLookingLeft)
end sub

sub DrawLanes()
   dim i as UByte
   dim p, p2 as UInteger
   dim y as UInteger
   dim buffer(0 to 31) as UInteger
   
   p = @buffer
   p2 = p + 62

   ' Yeah, I'm too lazy to draw an actual background.
   for i = 0 to 4
      poke UInteger p, LaneBaseTile
      poke UInteger p2, LaneBaseTile
      p = p + 2
      p2 = p2 - 2
   next
   
   for i = 4 to 8
      poke UInteger p, LaneBaseTile + 1
      poke UInteger p2, LaneBaseTile + 1
      p = p + 2
      p2 = p2 - 2
   next
   
   for i = 9 to 15
      poke UInteger p, LaneBaseTile + 2
      poke UInteger p2, LaneBaseTile + 2
      p = p + 2
      p2 = p2 - 2
   next
   
   SetBkgData(@buffer, 0, LaneTop, 32, 1)
   SetBkgData(@buffer, 0, LaneBottom, 32, 1)
   
   poke UInteger @buffer + 28, LaneBaseTile + 3
   poke UInteger @buffer + 30, 0
   poke UInteger @buffer + 32, 0
   poke UInteger @buffer + 34, LaneBaseTile + 4
   
   y = LaneTop + LaneCharHeight
   for i = 2 to LaneCount
      SetBkgData(@buffer, 0, y, 32, 1)      
      y = y + LaneCharHeight
   next
end sub


function fastcall LaneCoord(laneNumber as UInteger) as UByte
   asm         
      ld de, LaneCoords
      add hl, de         ; HL now points to the corresponding element on the table
      ld a, (hl)
   end asm
end function

sub ChangeLane()
   playerTargetY = LaneCoord(playerTargetLane) + LanePixelTopLimit
end sub


sub InitShots()
   dim i as UByte
   dim p as UInteger
   
   p = @shots
   for i = 0 to LaneCount - 1
      poke p + ShotFlagOfs, 0
   next
end sub

function ShotAddr(laneNumber as UByte) as UInteger
   return @shots + (laneNumber << ShotMemShift)
end function

sub DrawShot(baseAddr as UInteger, y as UByte)
   if peek(baseAddr + ShotFlagOfs) then
      DrawShip(peek(baseAddr + ShotXOfs), y, ShotBaseTile, peek(baseAddr + ShotFlagOfs) = ShotFlagRight)
   end if
end sub

sub DrawShots()
   dim i, y as UByte
   dim p as UInteger
   
   p = @shots
   y = LanePixelTopLimit
   for i = 1 to LaneCount
      DrawShot(p, y)
      y = y + LanePixelHeight
      p = p + ShotMemSize
   next
end sub

sub MoveShot(baseAddr as UInteger)
   dim x, flags as UByte

   x = peek(baseAddr + ShotXOfs)
   flags = peek(baseAddr + ShotFlagOfs)
   if flags then
      if flags = ShotFlagLeft then
         x = x - 6
      else
         x = x + 6
      end if
      
      if (x <= ActorMinX) or (x >= ActorMaxX) then
         poke baseAddr + ShotFlagOfs, 0
      end if
      
      poke baseAddr + ShotXOfs, x
   end if
end sub

sub MoveShots()
   dim i as UByte
   dim p as UInteger
   
   p = @shots
   for i = 1 to LaneCount
      MoveShot(p)
      p = p + ShotMemSize
   next
end sub

sub Fire()
   dim p as UInteger
   
   p = ShotAddr(playerCurrentLane)
   if peek(p + ShotFlagOfs) = 0 then
      poke p + ShotXOfs, PlayerCenterX
   
      if playerLookingLeft then
         poke p + ShotFlagOfs, ShotFlagLeft
      else
         poke p + ShotFlagOfs, ShotFlagRight
      end if
   end if
end sub


sub InitEnemies()
   dim i as UByte
   dim p as UInteger
   
   p = @enemies
   for i = 0 to LaneCount - 1
      poke p + EnemySpdOfs, 0
      p = p + EnemyMemSize
   next
end sub

sub DrawEnemy(baseAddr as UInteger, y as UByte)
'   if peek(baseAddr + ShotFlagOfs) then
'      AddDoubleSprite(peek(baseAddr + ShotXOfs), y, ShotBaseTile)
'   end if   
   if peek(baseAddr + EnemySpdOfs) then
      DrawShip(peek(baseAddr + EnemyXOfs), y, EnemyBaseTile + (peek(baseAddr + EnemyTypeOfs) << ActorTileShift), peek(Byte, baseAddr + EnemySpdOfs) > 0)
   end if
end sub

sub DrawEnemies()
   dim i, y as UByte
   dim p as UInteger
   
   p = @enemies
   y = LanePixelTopLimit
   for i = 0 to LaneCount - 1
      DrawEnemy(p, y)
      y = y + LanePixelHeight
      p = p + EnemyMemSize
   next
end sub

sub CollideEnemy(enemyAddr as UInteger, lane as UByte)
   dim shotAddr as UInteger
   dim shotX, enemyX as UInteger
   dim enemyType, shotFlag as UByte
   
   enemyType = peek(enemyAddr + EnemyTypeOfs)
   if enemyType = EnemyTypePhantom then
      ' Phantom ships are invulnerable.
      return
   end if

   shotAddr = ShotAddr(lane)
   shotFlag = peek(shotAddr + ShotFlagOfs)
   if shotFlag then
      shotX = peek(shotAddr + ShotXOfs)
      enemyX = peek(enemyAddr + EnemyXOfs)
      
      if (shotX - enemyX <= 16) or (enemyX - shotX <= 16) then
         poke shotAddr + ShotFlagOfs, 0
         if enemyType = EnemyTypeTank then
            ' Tanks can only be hit from the back
            if peek(Byte, enemyAddr + EnemySpdOfs) < 0 then
               if shotFlag = ShotFlagLeft then
                  ' Both facing left? Blam!
                  poke enemyAddr + EnemySpdOfs, 0
               end if
            else
               if shotFlag = ShotFlagRight then
                  ' Both facing right? Blam!
                  poke enemyAddr + EnemySpdOfs, 0
               end if
            end if
         else
            poke enemyAddr + EnemySpdOfs, 0
         end if
      end if
   end if
end sub

sub MoveEnemies()
   dim i as UByte
   dim x, type as UByte
   dim spd, timer as Byte
   dim p as UInteger
   
   p = @enemies
   for i = 0 to LaneCount - 1
      x = peek(p + EnemyXOfs)
      spd = peek(p + EnemySpdOfs)
      type = peek(p + EnemyTypeOfs)
      timer = peek(p + EnemyTimerOfs)
      
      if spd = 0 then
         if (Random() band $1F) = 1 then
            ' Spawns a new enemy
         
            if Random() band 1 then
               x = ActorMinX + 1
               spd = 12
            else
               x = ActorMaxX - 1
               spd = -12
            end if
            
            poke p + EnemyXOfs, x
            poke p + EnemySpdOfs, spd
            poke p + EnemyTypeOfs, Random() band 7
         end if
      else
         CollideEnemy(p, i)

         if type = EnemyTypePellet then
            timer = 1
         else
            timer = timer + spd
            x = x + (timer >> 4)
            timer = timer band $F
            
            poke p + EnemyXOfs, x
            poke p + EnemyTimerOfs, timer
         end if

         if (x <= ActorMinX) or (x >= ActorMaxX) then ' Enemy moved out?
            if type = EnemyTypeBall or type = EnemyTypeTank or type = EnemyTypeArrow then
               ' Turn around
               if spd < 0 then
                  x = ActorMinX + 1
               else
                  x = ActorMaxX - 1
               end if
               
               spd = -spd
               poke p + EnemyXOfs, x
               poke p + EnemySpdOfs, spd
               
               if type = EnemyTypeArrow then
                  ' Become a tank
                  poke p + EnemyTypeOfs, EnemyTypeTank
               end if
            else
               ' Disappear
               poke p + EnemySpdOfs, 0
            end if
         end if
         
         CollideEnemy(p, i)
      end if      
   
      p = p + EnemyMemSize
   next
end sub


' LoadPalette(ResourceAddr(ForestPal), 16, 0)
' LoadPalette(ResourceAddr(MManiaPal), 16, 16)

' LoadTiles(ScoreBaseTile, ResourceAddr(ScoreTil), ScoreTileCount, 4)
' LoadTiles(PlayerBaseTile, ResourceAddr(MManiaTil), PlayerTileCount, 4)
' LoadTiles(ShotBaseTile, ResourceAddr(PlayerShotTil), ShotTileCount, 4)
' LoadTiles(256, ResourceAddr(DefaultBkgTil), 64, 4)
' LoadTiles(MapBaseTile, ResourceAddr(ForestTil), 64, 4)


playerX = PlayerCenterX
playerY = PlayerMinY
playerCurrentLane = 0
playerTargetLane = 0

' Background palette
LoadPalette(ResourceAddr(ShipPal), 16, 0)
' Ship palette
LoadPalette(ResourceAddr(ShipPal), 16, 16)
' Tileset
LoadTiles(0, ResourceAddr(ShipTil), 256, 4)

DrawLanes()
InitEnemies()
InitShots()

do
   ' *** Player ***
   
   joy = ReadJoypad1()   
   
   if joy band joyLeftMask then
      playerLookingLeft = 1
   elseif joy band joyRightMask then
      playerLookingLeft = 0
   end if

   if playerCurrentLane = playerTargetLane then
      if (joy band joyUpMask) and (playerCurrentLane > 0) then
         playerTargetLane = playerTargetLane - 1
         ChangeLane()
      elseif (joy band joyDownMask) and (playerCurrentLane < LaneCount - 1) then
         playerTargetLane = playerTargetLane + 1
         ChangeLane()
      end if
   else
      if playerY <> playerTargetY then
         if playerY < playerTargetY then
            playerY = playerY + 12
         else
            playerY = playerY - 12
         end if
      else
         playerCurrentLane = playerTargetLane
      end if
   end if
   
'   if joy band (joyFireAMask bor joyFireBMask) then
      Fire()
'   end if

   if playerFireDelay then
      playerFireDelay = playerFireDelay - 1
   end if
   
   ' *** Shots ***
   
   MoveShots()
   MoveEnemies()
      
   ' *** Draw ***

   ResetSprites()   
   DrawPlayerShip()
   DrawShots()
   DrawEnemies()
   FinishSprites()
   
   WaitForVBlankNoInt()
   UpdateSprites()
   
   frameTimer = frameTimer + 1
loop


asm

LaneCoords:
   .db 0*24, 1*24, 2*24, 3*24, 4*24, 5*24, 6*24

end asm

[tfdi]

Quand on commence à avoir des peeks et des pokes en pagaille, avec des routines asm, tu peux passer à l'assembleur direct :) .... on sort de la simplicité du basic, et je trouve plus facile à lire un listing assembleur pur qu'un mélange de routine basic/peek/poke/asm.

Sans parler de toutes les astuces qu'on apprend en asm, les trucs pas documentés, le reverse engineering sur les programmes des autres, etc ...

Désolé pour le HS du post initial ...

[drfloyd]

oui peek & poke = mauvais basic.

[drfloyd]

Il y a sinon INTY Basic pour Intellivision

http://atariage.com/forums/topic/222570-intybasic-compiler-v05/page-6

Pas trouvé de guide/manuel pour l'instant.

[philip]

Amos basic pour l'Amiga, j'ai fait mon premier jeu dessus, envoyé par courrier postal, l'éditeur via son programmeur m'a gentilment répondu en me conseillant l'assembleur... toute une époque !

[drfloyd]

oui apres apres il y a les basics alternatifs sur ST et Amiga bien sur....

[F.L]

salut
quelqu'un ici a déja testé dragon basic , le basic pour gba ?
il a l'air abouti et fonctionnel , mais....
j'ai donc installé le logiciel, reglé les parametres grosso modo au lancement (le probleme vient peut etre de là)
mais je n'arrive pas à compiler la moindre ligne de code..... meme pas un "print 0"
si quelqu'un peut m'aider ou me conseiller un tuto ou un forum ça serait cool
merci d'avance

[drfloyd]

ne me dis pas que tu as l'idée de porter BARBARIAN sur GameBoy ????

[dub]

J'ai juste installé DragonBasic pour tester et chez moi ça fonctionne. Enfin ça compile et la rom marche, après ... dans le code y a des peek et des poke alors ... OK je sors

J'ai configuré le lien vers le compilateur au démarrage du prog comme toi je pense, après je suis pas allé voir les autres paramètres.

Pour la doc : http://ric.san.free.fr/_donnees/dragon%20basic.pdf
et d'autres infos http://ric.san.free.fr/gba.htm

Pour des Src : http://homepages.manx.net/bootlegger/gba_programming.html

Et pour les tutos : http://members.home.nl/penpvdbs/Downloads/DB.rar
Dedans il y a des tutos de base. Le 1er affiche un hello world avec compteur, bien documenté dans le source code.

[F.L]

J'ai juste installé DragonBasic pour tester et chez moi ça fonctionne. Enfin ça compile et la rom marche, après ... dans le code y a des peek et des poke alors ... OK je sors

J'ai configuré le lien vers le compilateur au démarrage du prog comme toi je pense, après je suis pas allé voir les autres paramètres.

Pour la doc : http://ric.san.free.fr/_donnees/dragon%20basic.pdf
et d'autres infos http://ric.san.free.fr/gba.htm

Pour des Src : http://homepages.manx.net/bootlegger/gba_programming.html

Et pour les tutos : http://members.home.nl/penpvdbs/Downloads/DB.rar
Dedans il y a des tutos de base. Le 1er affiche un hello world avec compteur, bien documenté dans le source code.

merci beaucoup dub !
je vais regarder tout ça.
j'aimerais au moins compiler une rom pour voir

ne me dis pas que tu as l'idée de porter BARBARIAN sur GameBoy ????

si justement. depuis quelques temps, je cherche une autre console qui acceuillerait mes codes en basic de Barbarian. mais ça ne court pas les rues et il faut que la console soit assez "puissante" quand meme.
mais bon, si il y a de peek et des pokes je decroche vite 

[tfdi]

J'ai juste installé DragonBasic pour tester et chez moi ça fonctionne. Enfin ça compile et la rom marche, après ... dans le code y a des peek et des poke alors ... OK je sors

[drfloyd]

peek et poke et colegram....