On va suivre ton projet avec attention ;).

Tu t'embête avec une gestion de souris alors que c'est inutile. Aucune souris sur cpc n'est pratique. De plus dessiner à la souris c'est juste une horreur sur nos vieilles machines. Le top reste le curseur du clavier. D'ailleurs sous ocp c'était ce que quasi toutes les personnes faisant du graphisme utilisaient. On maudissait le curseur souris ^^

Sinon c'est très sympa ce que tu fais.

Salut! Je n'ai jamais eu de souris AMX mais franchement là çà marche très bien sur l'émulateur... C'est quasiment comme sous Windows. Je change mes plans et vais publier une première version sans gestion d'une biblio de sprite. J'en ai besoin de suite lol. Ca génére du code (pascal, mais ca serait tres simple de générer des DATAS basic) en entrée-sortie. Il y a deux paramètres optionnels quand on lance le prog en CPM :

TPSPRITE  [ Nom sprite (ou big sprite)] [ Vitesse souris ]

Si pas de nom de fichier ce sera "default", et Vitesse 'normale' de souris. Si vitesse  de souris à zéro = pas de souris. Une vitesse de 100 correspond à un CPC+, si émulateur x3 mettre 300 etc... Faut que je trouve 1 heure donc probablement pas avant le prochain WE.

Bonsoir...
Voilà la version v0.5 Beta est publiable ;D

https://youtu.be/StP5k_xZC-o

Je mettrai l'image de la disquette et les sources demain vue l'heure tardive.

EDIT :

Lien téléchargement image disque 3" : https://drive.google.com/file/d/1-zmAB6J06yNmFXEGLsINCaY04Fqs6qGR/view?usp=sharing

(Egalement téléchargé sur Amstrad.eu mais je le vois pas ?)

La disquette inclue une version CPM+ qui gère un drive b: de 720ko et un Ram Disk c: de 440 ko. Sur émulateur je conseille WINAPE en activant l'option ASIC. N'ayant pas de souris sur mon CPC+, je ne sais pas ce que ca donne en 'réel'. Tous les sources y sont, y compris la police vectorielle et proportionnelle  ;D Si vous jetez un oeil dessus ça peut faire peur lol. Ca prouve au moins que le TP3 est très stable... Les bibliothèques ont sensiblement évoluées, ca devient de fait la v1.0 de TP Tools.

Ajout depuis la video :
- Ctrl C : dessine cercle plein
- R : Rectangle
- Ctrl R : Rectangle plein

Limitations :
- La fonction de remplissage de surface tient en 4 lignes mais est massivement récursive (vraiment LOL ) . J'ai bloqué la profondeur de récursivité à 500, il donc normal que les surfaces ne sont pas toujours totalement remplies.  A améliorer dans les prochaines version avec un algo moins bourrin;D
- Pas d'option de désactivation de la souris. Mais comme elle est compatible JoyStick, vous pouvez la déplcer dans un coin de l'écran

Je n'ai pas repéré de bug majeur.

Dernière beta avant la v1. Le lien précédent contient la nouvelle version 0.9b
L'ajout principal est la gestion des cycles d'animation.
https://youtu.be/5E5j3V7UEPM

Ton projet avance bien, c'est cool 😉

Version v1 de TP-Sprite finalisée ;D Ca marche très bien sur mon CPC 6128+.

Plus de nouveautés que prévu :

• Gestion du copier-coller avec CONTROL-COPY et SHIFT-COPY (y compris dans des images différentes)
• Déplacement au pixel du sprite (touches 2, 4, 6,8)
• Symétries horizontale et verticale (pour 'retourner' un sprite)
• Aide intégrée (tapez juste TPSPRITE)
• Création/modification de Sprite par TPSPRITE NOM du fichier
• Gestion de la souris améliorée (plus de pb de double clic)
• etc... (voir l'aide en tapant TPSPRITE)

Pour clarifier les choses j'ai séparé le programme et les sources :

Le programme (inclus CPM et quelques sprite .SPR) : https://drive.google.com/file/d/1Qb456fYpwZvTMCrWT_n0H4SEuLeJY33E/view?usp=sharing

pour lancer : ùcpm puis TPSPRITE nomfichier à modifier ou créer ou juste TPSPRITE

Les sources :  https://drive.google.com/file/d/1es--IFfKCQEUaP-iZUbeGT6wGTDqIDeY/view?usp=sharing

Petite vidéo des nouveautés :  https://youtu.be/Dd5Jzzogqdg

Je viens de faire une petite news de ton projet 😉

Merci Phenix... Je viens d'ajouter une fonction UNDO (Control ESC) bien pratique quand un remplissage avec une commande (F)ill déborde ou autre par exemple. Et correction d'un bug cosmétique qui initialisait mal le dernier octet sprites d'où des points fantômes parfois. Je vais rajouter la possibilité de charger un autre sprite (Control L)  depuis le programme ce qui permettra des copier-coller d'un sprite à un autre sprite même de taille différente.  Quand tout çà sera OK ca fera une v1.01.

Sur le vrai CPC, il serait beaucoup plus rapide de sauvegarder/charger les sprites en binaire et avoir des fonctions IMPORT/EXPORT plutôt que  des conversion systèmatiques en ASCII qui prennent beaucoup de temps sur disquette mais là on est dans la partie cerise du gateau ;D. Ca permettrait d'avoir plusieurs formats d'import-export. Mais ce sera dans une éventuelle v1.1

WoW ! c'est top ! sacré boulot

Si j'ai compris, tu as écrit le code en Pascal ? ça me rappelle de bons souvenirs (codage en Borland Pascal sur XT-AT)

Mais je suppose que certaines routines sont écrites en Assembleur ? Ou le tout est-il codé en pascal ?

En tout cas bravo, et merci pour ton partage 🙂

Hello. Oui c'est du Turbo Pascal v3. Il y a un peu d'assembleur mais ca se résume a des appels du Firmware avec des commades de type Inline. C'est du natif Pascal à 99%

Pour te donner un idée, voilà à quoi ressemble les procédures pour gérer l'ASIC  et gérer des "big sprites" (par exemple 32x48 pixels), aussi facilement que des sprites hardwares 16x16.

Les routines graphiques sont essentiellement des appels au firmware (voir l'unité UGraph dans les sources)

{ ========================================================================
TP-TOOLS v0.3 pour Turbo Pascal CPC+/CPM+. !!Uniquement pour CPC Plus!!
Unite UAsic. Gestion de l'ASIC du CPC+  By Nemo (2021)
-------------------------------------------------------------------------}
Type
{ Decription de la structure memoire de l'ASIC }
TSpr = Array[0..$f, 0..$f] Of Byte;
TScrPal= Array[0..$f] Of Integer; { SCReen PALette }
TSprPal= Array[1..$f] Of Integer; { SPRite PALette. 0-> Transparence }
TxySpr = Record x,y : Integer End;
TSprPos= Record xy : TxySpr; z: Byte; Bazar: Array[1..3] Of Byte End;
TBigSpr= Record Lrg, Htr, LxH, z: Byte End;

Const
Zy1=1; Zy2=2; Zy4=3;Zx1=4; Zx2=8; Zx4=12; { Zooms x et y }

Var
TbSpr : Array[0..15] Of TSpr Absolute $4000; { Les 16 sprites hard }
TbSprPos : Array[0..15] Of TSprPos Absolute $6000; { Position des 16 sprites }
TbScrPal : TScrPal Absolute $6400; { Palette 16 couleurs ecran }
ColBdr : Integer Absolute $6420; { Couleur du bord }
TbSprPal : TSprPal Absolute $6422; { Palette 15 coulleurs sprites }
RstIntLin: Byte Absolute $6800; { Raster Interrupt Line}
SplScrLin: Byte Absolute $6801; { Split Screen Line }
SplScrAdr: Integer Absolute $6802; { Split Screen sec. Addr.}

TbBigSpr: Array[0..15] Of TBigSpr; { Big sprites }
iSpr,jSpr : Byte;

Procedure DlkAsic; { Delock ASIC }
Type TCode = Array[1..17] Of Byte;
Const Code:TCode=($ff,$00,$ff,$77,$b3,$51,$a8,$d4,$62,$39,$9c,$46,$2b,$15,$8a,$cd,$ee);
Begin For iSpr:=1 To 17 Do Port[$bc00]:=Code[iSpr]; End;

Procedure OpnAsic; Begin Port[$7f00]:=$b8 End;

Procedure CloAsic; Begin Port[$7f00]:=$a0 End;

Procedure SetAsicPalMod1(a,b,c,d:Integer);
Begin
OpnAsic;
TbScrPal[0]:=a;TbScrPal[1]:=b;TbScrPal[2]:=c;TbScrPal[3]:=d;
CloAsic;
End;

Procedure HidAllSpr;
Begin OpnAsic; For iSpr:=0 To 15 Do TbSprPos[iSpr].z:=0; CloAsic; End;

Procedure SetBigSpr(nr,a,b,zoom: Byte);
Begin
OpnAsic;
With TbBigSpr[nr] Do Begin Lrg:=a; Htr:=b; LxH:=a*b; z:=Zoom End;
For iSpr:=nr To a*b+nr-1 Do TbSprPos[iSpr].z:=zoom;
CloAsic;
End;

Procedure SetZoomBigSpr(Spr,Zoom:Byte);
Var n:Byte;
Begin
OpnAsic;
For n:=Spr To TbBigSpr[Spr].LxH Do TbSprPos[n].z:=Zoom;
CloAsic;
End;

Procedure MovAbsBigSpr(n:Byte; xBig, yBig: Integer);
Var Largeur,ZoomX,ZoomY:Byte;
Begin
OpnAsic;
Largeur:=TbBigSpr[n].Lrg;
Case TbBigSpr[n].z Of
5 : Begin ZoomY:=16; ZoomX:=16; End;
9 : Begin ZoomY:=16; ZoomX:=32; End;
13: Begin ZoomY:=16; ZoomX:=64; End;
6 : Begin ZoomY:=32; ZoomX:=16; End;
10: Begin ZoomY:=32; ZoomX:=32; End;
14: Begin ZoomY:=32; ZoomX:=64; End;
7 : Begin ZoomY:=64; ZoomX:=16; End;
11: Begin ZoomY:=64; ZoomX:=32; End;
15: Begin ZoomY:=64; ZoomX:=64; End;
End;

For iSpr:=0 To (TbBigSpr[n].LxH)-1 Do Begin
With TbSprPos[n+iSpr] Do Begin
xy.x:=xBig+(iSpr Mod Largeur)*ZoomX;
xy.y:=yBig+(iSpr Div Largeur)*ZoomY;
End;
End;
CloAsic;
End;

Procedure MovRelBigSpr(n:Byte; DeltaX, DeltaY: Integer);
Begin
OpnAsic;
For iSpr:=0 To TbBigSpr[n].LxH-1 Do Begin
With TbSprPos[n+iSpr] Do Begin
xy.x:=xy.x+DeltaX;
xy.y:=xy.y+DeltaY;
End;
End;
CloAsic;
End;

Procedure SetPal4096;
Begin OpnAsic; Inline($21/$b7f9/$cd/$fc5a/$bcdd); CloAsic; End;

Function GetScrNumPal(n:Byte):Integer;
Begin OpnAsic; GetScrNumPal:=TbScrPal[n]; CloAsic; End;

Procedure SetPalBdr(n:Integer);
Begin OpnAsic; ColBdr:=n; CloAsic; End;

Procedure CpySprToAsic(Src:TSpr; Dst:Byte);
Begin OpnAsic; TbSpr[Dst]:=Src; CloAsic; End;

Procedure SetZoomSpr(Spr,Zoom:Byte);
Begin OpnAsic; TbSprPos[Spr].z:=Zoom; CloAsic; End;

Procedure MovSpr(Spr:Byte; xs,ys: Integer);
Begin
OpnAsic;
TbSprPos[Spr].xy.x:=xs; TbSprPos[Spr].xy.y:=ys;
CloAsic;
End;

Procedure SetScrInkPal(n:Byte; c:Integer);
Begin OpnAsic; TbScrPal[n]:=c; CloAsic; End;

Procedure GetScrPal( Var Pal:TScrPal);
Var Temp:TScrPal;
Begin
OpnAsic; Temp:=TbScrPal; CloAsic;
Pal:=Temp;
End;

Procedure GetSprPal( Var Pal:TSprPal);
Var Temp:TSprPal;
Begin
OpnAsic; Temp:=TbSprPal; CloAsic;
Pal:=Temp;
End;

Procedure SetSprPal(Pal:TSprPal);
Begin OpnAsic; TbSprPal:=Pal; CloAsic; End;

Procedure CpyScrPalToSpr;
Begin
OpnAsic;
Move(TbScrPal[1], TbSprPal[1],30);
CloAsic;
End;

Procedure CpySprPalToScr;
Begin
OpnAsic;
Move(TbSprPal[1], TbScrPal[1],30);
CloAsic;
End;

Procedure SetSprPxl(n,x,y,e:Byte);
Begin OpnAsic; TbSpr[n][x,y]:=e; CloAsic; End;

Procedure SetBigSprPxl(n,x,y,e:Byte);
Var ns,xs,ys : Integer;
Begin
OpnAsic;
ns:= 1 + x Div 16 * TbBigSpr[1].Lrg + (y Div 16) ;
xs:=x Mod 16;
ys:=y Mod 16;
TbSpr[ns,xs,ys]:=e;
CloAsic;
End;

Function GetSprPxl(n,x,y:Byte):Byte;
Var e:Byte;
Begin OpnAsic; e:=TbSpr[n][x,y]; CloAsic; GetSprPxl:=e; End;

Procedure GetSprPos(n:Byte; Var x,y:Integer);
Begin
OpnAsic;
x:=TbSprPos[n].xy.x;
y:=TbSprPos[n].xy.y;
CloAsic;
End;

Function GetBigSprPxl(n,x,y:Byte):Byte;
Var ns,xs,ys : Integer;
Begin
OpnAsic;
ns:= 1 + x Div 16 * TbBigSpr[1].Lrg + (y Div 16) ;
xs:=x Mod 16;
ys:=y Mod 16;
GetBigSprPxl:=TbSpr[ns,xs,ys];
CloAsic;
End;

J'ai poussé la version 1.01 qui écrase la v1.0 dans le lien google drive. Ca ajoute les sauvegardes/chargements, les Undo  et le copier-coller entre différents sprites (ou animation) qui ne fonctionnaient pas bien en v1.

PS : je ne vois pas d'option pour pousser des textes formatés dans le forum... J'ai loupé un truc?

Tu attaques l'ASIC directement en définissant bien la structure mémoire de l'ASIC... pour gérer les sprite grâce à des tableaux ARRAY.OF...

trop fort 🙂

C'est un sacré boulot. J'ai hâte de tester lorsque mon 6128+ sera nettoyé.

Petite question : Pascal pour CPC n'utilise pas de pointeur (POINTER) ? (genre ^Tspr) pour pointer directement à la bonne adresse ?

Oui. Tu peux utiliser des pointeurs. J'en ai même des tonnes dans le programmes ;D Pour gérer les UNDO par exemple.

En fait le turbo PASCAL v3 pour CPC est exactement le même que le Turbo Pascal v3 MSDOS à quelques détails près.

Pour l'utilisation des pointeurs j'en parle dans cette vidéo :  https://youtu.be/4CbTHgYUyeY

On peut faire des trucs très rapide sans assembleur. 

Ah oui, en effet, j'avais pourtant regardé ta vidéo mais je n'avais pas capté que tu utilises les pointeurs (notamment par le mot DISPOSE, qui aurait dû me faire comprendre 😉 )

Et je suis d'accord avec toi, le Pascal permet une exécution hyper rapide (pas autant que l'assembleur certes... mais pas loin 😉

A l'époque j'avais toujours été subjugué par la rapidité d'exécution d'un EXE compilé depuis Turbo Pascal. Ceci dit, c'est compilé, et non interprété, donc forcément c'est rapide à l'exécution 😉 D'ailleurs j'ai installé une DosBOX spécialement pour coder en Borland Pascal 16 bit, juste pour le fun 😉

J'apprécie spécialement le langage Pascal, il est structuré, puissant, et permet de programmer tout ce qu'on veut. Sur le PC, l'avantage de Borland Pascal, c'est qu'on peut directement coder en assembleur dans le code Pascal (procédure truc; assembler; asm... instructions assembleur ...end;) il faut juste faire attention à bien sauvegarder les registres, mais à part ça c'est du tout cuit.

Mais je suis un peu hors sujet là... désolé... revenons à nos Amstrad 😉

Je n'ai jamais codé en Pascal sur CPC, va falloir que je franchisse le pas.

Encore bravo pour ce que tu as fait, et merci de le partager