Avertissement :Il s'agit d'une page optimisée pour la navigation mobile. Voir la
page originale.
*NEW* Cubefield en assembleur (ION) - Page 1 / 2
-Coco- le 10/12/2011 à 21:26
Salut à tous !
/!\ Ceci est un programme en ASSEMBLEUR. Si vous n'avez pas le câble ou pas d'émulateur, passez votre chemin, pas la peine de me demander un code en basic.
Voici...
CUBEFIELD !
En assembleur total et absolu (Eh ouais j'utilise pas de convertisseur moi xd).
Cela fonctionne sous ION, si vous ne l'avez pas, et que vous avez le câble (nécessaire), rendez vous ici :
http://tout82.free.fr/forum/sujet.php?sujet=2522
Voici les liens de téléchargement :
Ti 82 stats/82 stats fr/83 :
Télécharger (mediafire)
Ti 83 + :
Télécharger (mediafire)
Taille : 693 octets
Petit conseil : normalement il n'y a aucune raison que ça plante mortellement et que ça reset la RAM de votre TI, mais je vous conseille tout de même de sauvegarder vos programmes importants sur votre ordinateur avant de tester celui là (on ne sait jamais)
Petit screenshot :
Image manquante
Le jeu tourne à peu près à 60 FPS (sans déconner ^^)
touches :
[gauche],[droite] : se mouvoir
[annul] : quitter à tout moment
[mode] : mettre en pause / reprendre lorsque le jeu est en pause
[2nde] : sortir du jeu lorsque l'on a perdu (important) / sortir de la pause
But du jeu :
Eviter les cubes.
A noter qu'il existe un High score (non nominatif)
Pour les curieux, voici le code en assembleur (note : les fonctions telles que Putsprite n'existent pas en assembleur, je les ai codés moi même à coup de define)
Code
;File generated by Z80Generator by -Coco-
#define TI83
.nolist
#include "ion.inc"
.list
#include "Ionsim.z80"
;variables here
vx = saferam1
vy = vx+1
delay = vy+1
tempdelay = delay+1
cx = tempdelay+1
cy = cx+1
nbcubes = cy+1
score = nbcubes+1
speed = score+2
#ifdef TI83P
.org progstart-2
.db $BB,$6D
#else
.org progstart
#endif
ret
jr nc, start_program
.db "Champ de cubes",0
start_program:
Clearbuf
Defvar(vx,45)
Defvar(vy,54)
Defvar(delay,50)
Defvar(tempdelay,30)
Defvar(cy,0)
Defvar(nbcubes,0)
ld hl,score
ld (hl),0
inc hl
ld (hl),0
Defvar(speed,1)
set textwrite,(iy+sgrflags)
ld hl,str_parcoco
ld de,(15*256)+30
ld (pencol),de
bcall(_vputs)
ld hl,str_ctr1
ld de,(35*256)+5
ld (pencol),de
bcall(_vputs)
ld hl,str_ctr2
ld de,(42*256)+5
ld (pencol),de
bcall(_vputs)
Flipbuf
set textinverse,(iy+textflags)
ld hl,str_cubefield ; write cubefield invert
ld de,0
ld (currow),de
bcall(_puts)
res textinverse,(iy+textflags)
Clearbuf
res textwrite,(iy+sgrflags)
menuwait:
ld de,(56*256)+10
ld (pencol),de
bcall(_vputs)
Getkey
cp gk_clear
jp z,stop
cp gk_seconde
jr z,loop
jr menuwait
loop:
Putsprite(vx,sp_vaiss,6)
Flipbuf
Putsprite(vx,sp_vaiss,6)
ld a,$FF ;
out (1),a ;
ld a,$FE ;
out (1),a ;
in a,(1) ;
bit 1,a ; [(left)]
call z,moveleft ;
bit 2,a ; [(right)]
call z,moveright ;
ld a,(vx)
cp 5
call z,moveright
cp 85
call z,moveleft
ld hl,(tempdelay)
dec hl
ld (tempdelay),hl
ld a,(tempdelay)
cp 0
call z,putBlock
ld a,(nbcubes)
cp 20
call z,decdelay
;;;;;;;;pixel test;;;;;;;;;;;;;
ld a,(vy) ;
ld e,a ;
ld a,(vx) ;
add a,3
call ionGetPixel ;
ld a,(hl) ;
or a ;
jr nz,dead
call scroll
suit:
cp 0
jr nz,st
st:
ld hl,(score)
inc hl
ld (score),hl
Getkey
cp gk_clear
jp z,stop
cp gk_mode
call z,pause
jp loop ;;;;;;;;;;endloop
dead:
Putsprite(vx,sp_boum,7)
Flipbuf
ld de,0
ld (currow),de
ld hl,str_youaredead
bcall(_puts)
bcall(_newline)
ld hl,str_score
bcall(_puts)
bcall(_newline)
ld hl,(score)
bcall(_disphl)
bcall(_newline)
ld hl,(var_hscore)
ld de,(score)
bcall(_cphlde)
jp p,disphigh
ld hl,str_newhigh
bcall(_puts)
ld hl,(score)
ld (var_hscore),hl
jr finish
disphigh:
ld hl,str_high
bcall(_puts)
bcall(_newline)
ld hl,(var_hscore)
bcall(_disphl)
finish:
Getkey
cp gk_seconde
jp z,stop
jr finish
moveleft:
ld hl,(vx)
dec hl
ld (vx),hl
ret
moveright:
ld hl,(vx)
inc hl
ld (vx),hl
ret
decdelay:
ld a,(delay)
dec a
dec a
ld (delay),a
xor a
ld (nbcubes),a
ret
putBlock:
ld a,(nbcubes)
inc a
ld (nbcubes),a
ld a,(delay)
ld b,a
call ionrandom
add a,3
ld (tempdelay),a
Random(90)
ld (cx),a
Random(2)
cp 0
jr z,pb2
Putsprite(cx,sp_cube_1,6)
ret
pb2:
Putsprite(cx,sp_cube_2,6)
ret
scroll: ld hl,grbuf+(62*12) ;
ld de,grbuf+(63*12) ;
ld bc,756 ;
lddr ;
ld h,d ;
ld l,e ;
inc e ;
ld (hl),b ;
ld c,11 ;
lddr ;
ret ;
pause:
ld hl,str_pause
ld de,$0604
ld (currow),de
bcall(_puts)
p2:
Getkey
cp gk_seconde
ret z
cp gk_mode
ret z
jr p2
stop:
ret
sp_vaiss:
.db %00110000
.db %00110000
.db %01111000
.db %01111000
.db %11111100
.db %11111100
sp_cube_1:
.db %11111100
.db %11111100
.db %11111100
.db %11111100
.db %11111100
.db %11111100
.db %11111100
sp_cube_2:
.db %11111100
.db %10000100
.db %10000100
.db %10000100
.db %10000100
.db %11111100
sp_boum:
.db %10010010
.db %01010100
.db %00111000
.db %11111110
.db %00111000
.db %01010100
.db %10010010
var_hscore:
.dw 0
str_cubefield:
.db " Cube Field ",0
str_parCoco:
.db "Par -Coco-",0
str_ctr1:
.db "2nde : Play",0
str_ctr2:
.db "Clear : Quit",0
str_youaredead:
.db " You are dead. ",0
str_score:
.db "Score:",0
str_high:
.db "High score:",0
str_newhigh:
.db "New high!",0
str_pause:
.db "Pause",0
.end
Rien à voir avec le BASIC n'est ce pas ? ^^
Autre note : Ce code est là également pour vous montrer à quel point c'est galère à relire, donc ne me demandez pas de mettre 36 améliorations :p
NB :
Très léger problème de collision, du au pixel test de ION, il arrive (très rarement) de mourir à 2 pixels d'un cube...
snap le 10/12/2011 à 22:41
Sympa
Mais le probleme des pixel revient quand meme souvent c'est dommage^^
J'adore l'asm
tu m'apprendra a programmer hein? XD
The K le 11/12/2011 à 10:59
Citation
(note : les fonctions telles que Putsprite n'existent pas en assembleur, je les ai codés moi même à coup de define)
Amusant ... je ne vois pourtant qu'un seul define.
ET au vu des quelques rudiments que j'ai en assembleur, je n'en ai vu qu'un, et je croyais que c'était une autre instruction, du genre ... je sais plus quoi, mais pas un define
Par ailleurs une autre question si je veux recopier ça (la question n'est pas où, ça je sais xD), il faut que je saute les lignes et que je marque tout au caratère près même la ligne avec le pixel test et tous les points virgule ?
Sinon, belle réussite coco, vraiment
-Coco- le 11/12/2011 à 14:50
En fait les defines sont dans le fichier "Ionsim.z80" (pour ion simple :p), que j'ai inclus au début du code...
Voici le code de Ionsim.z80 pour les intéressés, ça peut aider :
Code
;marche avec Ion !
;------------------------Les principales fonctions simplifiées-------------------------------
;----------------et leur définition ensuite------------------
#define Clear bcall(_clrlcdf) ;efface l'écran
#define Def(mm,val) ld mm,var ;correspond à un ld
#define Defvar(var,val) ld a,val \ ld hl,var \ ld (hl),a
#define Defvar16(var,val) ld hl,val \ ld d,h \ ld e,l \ ld hl,var \ ld (hl),de ;pour assigner une valeur à une adresse RAM
#define Text(tx,ty,tv) ld de,(tx*256)+ty \ ld (currow),de \ ld hl,tv \ bcall(_puts) ;Texte type output( en x,y tv est une etiquette
#define Vtext(tx,ty,tv) ld de,(tx*256)+ty \ ld (pencol),de \ ld hl,tv \ bcall(_vputs) ;texte type Texte( en x,y
#define Random(rx) ld b,rx \ call ionrandom ;nombre aléatoire entre 0 et rx stocké dans a.
#define Pixel(px,py,et) ld bc,(px*256)+py \ ld d,et \ bcall(_ipoint) ;pixel en (x,y) et non (y,x)
#define Pixelv(var,et) ld hl,(var) \ ld b,h \ ld c,l \ ld d,et \ bcall(_ipoint)
#define Line(lx,ly,lxx,lyy,et) ld bc,(lx*256)+ly \ ld de,(lxx*256)+lyy \ ld a,et \ bcall(_iline) ;ligne de (lx,ly) à (lxx,lyy)
#define Dispvalue(val) ld hl,val \ bcall(_disphl) ; indiquer une valeur. ne convient pas aux registres 16 bits.
#define Dispvalue16(val,vall) ld h,val \ ld l,vall \ bcall(_disphl) ;pour les registres 16 bits, exemple Dispvalue16(b,c)
#define Darkline(lx,ly,lxx,lyy) ld bc,(lx*256)+ly \ ld de,(lxx*256)+lyy \ bcall(_darkline) ;ligne type PxlLigne
#define Getkey bcall(_getk) ;correspond au getkey du BASIC
#define Waitkey bcall(_getkey) ;attend l'appui d'une touche
#define Putspritea(sx,sy,sp,lin) ld a,sy \ ld l,a \ ld a,sx \ ld b,lin \ ld ix,sp \ call ionputsprite
;crée un sprite de 8*lin pixels aux coordonnées x,y
#define Putsprite(var,sp,lin) ld hl,var \ ld a,(hl) \ inc hl \ ld l,(hl) \ ld b,lin \ ld ix,sp \ call ionputsprite
;crée un sprite de 8*lin pixels aux coordonnées d'un 16 bits : ex Putsprite((coordonnees),sprite,8)
#define Largesprite(var,sp,lin,col) ld hl,var \ ld c,col \ ld a,(hl) \ inc hl \ ld l,(hl) \ ld b,lin \ ld ix,sp \ call ionlargesprite
#define Clearbuf bcall(_grbufclr) ;efface le graph buffer
#define Flipbuf call ionfastcopy ;affiche le graph buffer
;-----------------Les Getkey----------------
;---ceux du Waitkey---
wk_clear .equ 9
wk_right .equ 1
wk_up .equ 3
wk_left .equ 2
wh_down .equ 4
wk_enter .equ 5
wk_mode .equ 69
wk_del .equ 10
;---ceux de Getkey---
gk_left .equ 2
gk_right .equ 3
gk_up .equ 4
gk_down .equ 1
gk_enter .equ 9
gk_seconde .equ 54
gk_alpha .equ 48
gk_clear .equ 15
gk_mode .equ 55
Moi perso ça me sert beaucoup (après je crois que je suis un des rares programmeurs en ASM ici :p)
Sinon snap je serais totalement incapable de t'apprendre l'assembleur, en fait j'ai appris plus ou moins tout seul avec des trucs sur internette. Mais souvent on ne trouve que des bribes de code, comme 'exemple d'utilisation de ionputsprite, mais avec de l'entraînement ça finit par rentrer.
En fait on apprend pas mal en regardant le code de programmes en assembleur déjà faits (par exemple j'ai énormément appris de Falldown). En tout cas si vous voulez vous y mettre bon courage, il en faut ^^
calcugeek le 11/12/2011 à 16:22
Est ce que c'est possible d'avoir un équivalent en hexadécimal? J'ai pas le cable
-Coco- le 11/12/2011 à 16:24
Si tu es prêt à recopier 1000 petits caractères sans aucune erreur autorisée (sinon mémoire cleaered), tu peux toujours tenter de l'ouvrir avec un éditeur hexadécimal et le recopier.
Personnellement, je pense que c'est une mauvais idée :pcalcugeek le 11/12/2011 à 16:29
euh ouais. O_o sinon tu peux me donner un exemple d'editeur?-Coco- le 11/12/2011 à 16:40
D'éditeur pour écrire en assembleur ?
Ben... Bloc-notes !
Ce programme est largement suffisant.
Personnellement j'utilise Notepad++ qui est une version améliorée de Bloc-notes, que je trouve plus pratique.
Après pour compiler et tout ça, il existe des programmes spéciaux.
Si vous voulez avoir des petites notions, allez voir sur :
http://www.siteduzero.com/tuto[...]80-pour-ti.html
Bon c'est pour Ti 83 +, et il faut utiliser un émulateur (sauf si vous avez une Ti 83+, mais si vous débutez en assembleur je vous conseille vivement d'utiliser un émulateur). Mais vous avez tous els outils de compilation, dont ceux pour ti 83, si vous êtes un peu débrouillards
snap le 12/12/2011 à 21:04
Petite question pour -coco- (oui je sais je suis très énervant
)
Dans un tuto pour z80 le mec dit sa
mec qui dit sa a écrit :
Logiquement, ils peuvent donc contenir des valeurs de %00000000 à %11111111, c'est-à-dire entre 0 et 255. Votre programme ne sera pas compilé en cas de dépassement.
Mais le truc que j'ai pas compris c'est comment on reconnait les valeur. Comment on peut savoir que %11111111 c'est 255?
linkakro le 12/12/2011 à 21:46
C'est le language binaire.
1001 base 2 = 2^3+2^0 = 9
1011 base 2 = 2^3+2^1+2^0 = 11
11111111 base 2 = 2^8-1 = 255
Le 2^8-1 c'est pour éviter 2^7+2^6+...+2^0snap le 12/12/2011 à 21:57
OK merci beaucoup! Et sa sert à quelque chose de savoir sa pour le z80?linkakro le 12/12/2011 à 22:06
C'est indispensable pour manipuler des languages de bas niveau comme l'assembleur. Ne serait-ce que pour comprendre ce que fait ton compilateur.
Je te rappelles que toute l'électronique se sert du language binaire.
Une TI en assembleur c'est comme un microcontrôleur : tu as des périphériques et des adresses mémoire numérotées en hexadécimal voire en binaire.snap le 12/12/2011 à 23:20
OK. Et encore une question : 200 = 11001000b = C8h
C'est bien joli mais pourquoi? C'est quoi ce C8h xDPersalteas le 12/12/2011 à 23:56
Je vais peut être dire une énorme connerie, mais je me permets d'émmettre une hypothèse:
le h se retrouve souvent après des "trucs" en ASM, je ne sais pas trop quoi, et il ne sert apparement pas.
Il se pourrait que C8 soit la traduction hexadécimale de 11001000, même si ça m'étonnerait, j'aurais dit plus (au moins E8 ou plus...)cKZO le 13/12/2011 à 08:58
le prblm c que bcp de programmes sont ac "ion mais je sais pas comment ça marche
domage il a l'air bien ton prgm
linkakro le 13/12/2011 à 12:26
Le h signifie hexadécimal et b binaire.
C8 hexa = 12*16+8 = 200
11001000 bin = 128+64+8 = 200
Si tu as du mal avec les calculs ou si tu n'as jamais eu de cours, utilise la calculatrice windows en mode programmeur pour convertir toutes les bases 2,8,10,16.
( ou bien utilise ta TI avec
mon programme de convertion 
)
----
ION est écrit en assembleur classique. Il permet de lire des programmes écris dans un language différent et surtout compilés autrement qu'en hexadécimal habituel.
Persalteas le 13/12/2011 à 15:56
Pour savoir comment installer ION, regarde dans ce topic...
http://tout82.free.fr/forum/sujet.php?sujet=2522
plus précisément cette partie:
Persalteas a écrit :
téléchargez ion ici (utilisez les progs en 83p !!). les 3 programmes indispensables sont ION, IONZ et ZMINFO. le reste c'est des modules facultatifs.(n'utilsez pas celui apellé "minuscules", c'est pour les 83+ ! erreur de rangement de ma part !
une fois les progs dans votre TI, éxécutez ION. ça écrit "ION Installed" et deux programmes A et thêtaION se créent.
Vous pouvez supprimmer ION et IONZ pour gagner de la place, mais conservez les deux autres (ou alors supprimez A et faites un nouveau prog du nom de votre choix en écrivant:
:Envoi(9prgm@ION
:EffEcr
envoyez ensuite vos progs en ASM, et quand vous éxécutez A, il apparait une liste de vos programmes en ASM.Quittez ION en faisant [2nd][mode].
snap le 13/12/2011 à 22:18
A ok merci linkakro. Mais par contre j'ai pas compris ton calcul xDThe K le 14/12/2011 à 13:59
Quand on a compris c'est simple sur le principe ne t'en fais pas
Toi tu comptes en base 10, base décimale, avec des nombres variant de 0 à 10.
Le binaire est en base 2, avec des 0 et des 1.
Le nombre 00110101 sera donc égal à (en partant de la droite) :
1*2^1 + 0*2² + 1*2^3 + 0*2^4 + 1*2^5 + 1*2^6 + 0*2^7 + 0*2^8
Soit : 1 + 0 + 8 + 0 + 32 + 64 + 0 + 0
= 105
Voila !
Le calcul en hexa reprend les mêmes bases, sauf qu'avec des 1 et des 0, on a 0123456789ABCDEF, avec A=10,B=11, etc jusqu'à F=15.
Je t'invite à aller voir ceci si tu n'as pas tout compris :
http://www.siteduzero.com/tuto[...]ecomposeur.html
En espérant t'avoir aidé
Avertissement :Il s'agit d'une page optimisée pour la navigation mobile. Voir la
page originale.
