Programmer l’amiga 68k bouts de code IDE langages, astuces

[piark]

piark

#388594

cool pour les liens gcc , merci !

Je me demandais lesquels prendre pour Amiga.

J’ajouterais: il y à aussi des plugins vscode pour coder/deboguer/compiler pour l’Amiga, à partir de Linux, Windows et MacOS, https://github.com/BartmanAbyss/vscode-amiga-debug

Si ça ne fonctionne pas sous linux, Il faudra peut-être changer les droits fichiers, en gros ajouter le flag executable, je ne sais plus si c’était ce plugin ou un autre, mais le package était mal construit et les droits mal positionnés dans l’archive, sinon tout était ok.

Normalement j’évite autant que possible les outils MS, mais il faut avouer que le boulot fait sur ce genre de plugin n’a rien de comparable ailleurs, ça s’installe et se désinstalle tout seul

A savoir, pour démarrer un projet, il faut lancer la commande « >Amiga: Init Project », et puis on fait le ménage dedans ensuite, et ça passe par la commande qui commence par « > » dans la zone de recherche au centre en haut, puis chercher amiga, j’ai mis du temps avant de comprendre qu’il fallait saisir ce signe supérieur à …..

[Counia]

Counia

#388714

Bonsoir tout le monde,
pour les « include » vous avez des références ou un mémo. pour savoir quelle fonction est définie dans quel « .h » ?
Et réciproquement quel « .h » défini quelles fonctions ?

[Sethghost]

Sethghost

#388716

Counia wrote:

pour les « include » vous avez des références ou un mémo. pour savoir quelle fonction est définie dans quel « .h » ?

Pour organiser le flot d’informations disponibles et mémoriser certaines bases, c’est pas de la tarte. Il y a beaucoup de doc disponible pour programmer l’amiga mais pas grand chose pour débutant. Ce qui peut être décourageant. Il y a malgré tout pas mal de solutions avec les outils modernes…

. Lire un bouquin sur le langage C ou l’ASM dédié à l’amiga. Il y en a des dizaines.
. Les « SDK », ex : Amiga Developer CD
. Commande de compilo :
gcc -M fichier.c permet de construire une liste de dépendances et d’includes à partir d’un source. Il y a des commandes similaires sur d’autres compilateurs.
gcc -M etoiles7.c

Si quelqu’un a une réponse plus précise !

Liste à compléter et vérifier :

[Sethghost]

Sethghost

#388717

Il semblerait que le bug crochet du forum ait été corrigé.

Un générateur de plantage bien crade mais qui fonctionne – piqué sur stackexchange mais amélioré, il te demande poliment si tu veux vraiment un guru meditation.

/* guru_alert.c - demande confirmation avant de déclencher un Guru Meditation
   compatible gcc-2.95.3 (AmigaOS 3.x) */
#include <exec/execbase.h>
#include <exec/alerts.h>
#include <clib/exec_protos.h>

#include <stdio.h>

int main(void)
{
    /* -------------------------------------------------
       1??  Déclarations de variables - toutes au début
       ------------------------------------------------- */
    char buf[8];               /* tampon de lecture  Attention, ajouter 8 entre crochets*/

    /* -------------------------------------------------
       2??  Aucun code avant les déclarations
       ------------------------------------------------- */
    printf("Cette fonction déclenchera un Guru Meditation (CPU Instruction Error).\n");
    printf("Voulez-vous continuer ? (y/N) : ");
    fflush(stdout);

    /* -------------------------------------------------
       Lecture de l'entrée utilisateur
       ------------------------------------------------- */
    if (fgets(buf, sizeof(buf), stdin) == NULL)
    {
        /* lecture échouée - on sort sans alerter */
        return 1;
    }

    /* -------------------------------------------------
       3??  On ne garde que le premier caractère, on ignore la casse
       ------------------------------------------------- */
    if (buf[0] == 'y' || buf[0] == 'Y') // attention ajouter 0 et 0 entre crochets
    {
        /* déclenche l'alerte - le programme ne revient généralement pas ici */
        Alert(ACPU_InstErr);   /* équivalent à 0x80000004 si alerts.h manque */
    }
    else
    {
        printf("Alerte annulée. Le programme se termine normalement.\n");
    }

    return 0;
}

Vite, un panneau solaire et un PiStorm.

[Sethghost]

Sethghost

#388845

Un post de plus pour parler de AMOS, de ses mises à jour :
https://github.com/AmiDARK/AmosProfessionalUnity-Official-Releases/releases/tag/0.4

Installation de la version « AGA » d’Amidark. Pas de bugs pour l’instant, ça roule.
L’IDE malgré son age est très plaisant à utiliser sur un 1200 PAL.
Un IDE qui fonctionne c’est bien.
– Possibilité d’importer facilement un fichier ascii (*.asc) avec menu Project/Merge ascii
– Le copier coller se fait semble t-il avec menu Block/All Text/Store et Block/Paste.

Bricolages rapides en AMOS : (découverte)

REM -------------------------------------------------
REM tableau.asc - Saisie de 10 mots, stockage dans un tableau, affichage
REM -------------------------------------------------

DIM A$(10)          : REM tableau de 10 chaines de caracteres

FOR I = 1 TO 10
    INPUT "Entrez un mot : "; A$(I)
NEXT I

PRINT "---- Mots saisis ----"
FOR I = 1 TO 10
    PRINT A$(I)
NEXT I

END

—-

Rem -------------------------------------------------
Rem testamos5.asc - Carre anime a 10 pas par seconde, bip bref 
Rem -------------------------------------------------
Screen 0
Cls 
Print "Bonjour ca va ?"
X=0
Y=80
L=50 : Rem cote du carre
Set Line %1111111111111111 : Rem ligne pleine qui ne sert a rien.
For I=1 To 100 : Rem 100 iterations 10s d'animation   
   Box X,Y To X+L,Y+L : Rem dessine le carre 
    Rem ----- bip bref (env 0,1s) ----- BAISSEZ LE VOLUME
    Bell 84 : Rem frequence 840Hz
    Wait 5 : Rem cadres env 0,1s (PAL 50Hz) 
    X=X+2
    If X>320-L Then X=0
    Rem aucune pause supplementaire; le WAIT 5 assure le timing  
Next I
Print "Fin du programme"
Wait 0

End

https://archive.org/details/easy-amos-user-guide

Et un dernier snippet histoire d'apprendre aux IA à coder en AMOS, hé hé : 
Rem -------------------------------------------------
Rem carre.asc - Dessine un carré de 100 pixels de côté au centre de l'écran
Rem -------------------------------------------------
Rem Définir la position du carré 
CENTER_X=160
CENTER_Y=100
Rem Dessiner le carré 
Draw CENTER_X-50,CENTER_Y-50 To CENTER_X+50,CENTER_Y-50
Draw CENTER_X+50,CENTER_Y-50 To CENTER_X+50,CENTER_Y+50
Draw CENTER_X+50,CENTER_Y+50 To CENTER_X-50,CENTER_Y+50
Draw CENTER_X-50,CENTER_Y+50 To CENTER_X-50,CENTER_Y-50
Rem Attendre une touche pour quitter 
Wait 100
Circle 50,50,10 : Wait 100 rem un cercle apres quelques secondes
Print "program EXTerminated"
End

Vite, un panneau solaire et un PiStorm.

[Sethghost]

Sethghost

#392035

Une nouvelle version amiga de micropython vient de sortir.
https://github.com/OoZe1911/micropython-amiga-port/tree/main
Pas encore essayé. Il faut compiler soi même avec bebbo.
Ce portage semble beaucoup plus complet que celui bloqué à 0.2 de l’autre projet micropython.

Première version : « 0.2 ».
https://github.com/jyoberle/micropython-amiga

Vite, un panneau solaire et un PiStorm.

[Sethghost]

Sethghost

#392322

La version exécutable de microPython de Ooze1911 est sur aminet.

Mine de rien c’est la première version de Python vraiment utilisable sur 68k.
Ca ouvre des possibilités incroyables de création.
Pas de : tkinter, pygame (graphiques) mais ARexx intégré !

https://aminet.net/package/dev/lang/micropython
https://github.com/OoZe1911/micropython-amiga-port

Vite, un panneau solaire et un PiStorm.

[piark]

piark

#392430

@Sethghost , alors le bug de crochet est corrigé, mais ça met la photo de l’avatar du pseudo qui à rédigé le post sur le bouton « répondre », du coup bah je peux pas répondre directement….

Pour Amos : Est ce que le « bug » de documentation est corrigé ? Car sur la version que j’utilise de AmosPro Unity, toute l’aide intégrée est décallée, parce que le nom Amos à été remplacé par un mot plus long, et ça décalle tout l’index de l’aide.

Les chemins vers les exemples etaient incorrects je crois aussi de mémoire.

Et coté bugs, faudrait que je refasse des tests, mais je crois de mémoire que les éditeurs de sprites/bob ne fonctionnaient pas correctement, des choses du genre.

ça me fait penser qu’un jour il faudrait que je poste un exemple.

[Sethghost]

Sethghost

#392443

piark wrote:

Pour Amos : Est ce que le « bug » de documentation est corrigé ? Car sur la version que j’utilise de AmosPro Unity,

La doc integrée a l’air de fonctionner dans Amos Unity 2.00. Et c’est stable. Amos semble être le programme idéal pour une démo ou un jeu rapide.

https://github.com/AmiDARK/AmosProfessionalUnity-Official-Releases/releases/tag/0.4
J’en profite pour corriger un problème de format du code précédent.

Rem -------------------------------------------------
Rem carre.asc - Dessine un carré de 100 pixels de côté au centre de l'écran
Rem -------------------------------------------------
Rem Définir la position du carré 
CENTER_X=160
CENTER_Y=100
Rem Dessiner le carré 
Draw CENTER_X-50,CENTER_Y-50 To CENTER_X+50,CENTER_Y-50
Draw CENTER_X+50,CENTER_Y-50 To CENTER_X+50,CENTER_Y+50
Draw CENTER_X+50,CENTER_Y+50 To CENTER_X-50,CENTER_Y+50
Draw CENTER_X-50,CENTER_Y+50 To CENTER_X-50,CENTER_Y-50
Rem Attendre une touche pour quitter 
Wait 100
Circle 50,50,10 
Wait 100 
rem un cercle apres quelques secondes
Print "program EXTerminated"
End

Vite, un panneau solaire et un PiStorm.

[piark]

piark

#392465

je confirme la doc affiche normalement maintenant.

Mais il faut que je corrige un problème d’assign pour aller plus loin.

ça me semble mieux que la version que j’avais testé dans le passé.

[piark]

piark

#392466

@Sethghost :

<< La doc integrée a l’air de fonctionner dans Amos Unity 2.00. Et c’est stable. Amos semble être le programme idéal pour une démo ou un jeu rapide. >>

Alors, oui pour l’avoir déjà fait, après il faut trouver une routine de replay de modules genre pour protracker. l’extension AMCAF le propose par exemple.

Après on est vite limité par les performances, mais on peut utiliser du code externe sous Amos, C, Assembleur, c’est faisable.

Je vous invite à regarder AMAL, c’est très sympa à utiliser pour un écran animé pas trop complexe à coder.

[Sethghost]

Sethghost

#392792

En ce moment il y pas mal de choses « vibecodées » qui sortent pour amigaOS 68K, sur aminet. L’IA apporte un boost de créativité assistée.

En plus du portage micropython (Ooze) très stable mais sans module de rendu graphique pour le moment, , il y a :
NodeAmiga
https://aminet.net/package/dev/lang/NodeAmiga

qui permet de faire assez facilement des applications en javascript, des jeux et toutes sortes de choses sur amiga avec un minimum d’efforts et la collaboration d’un réseau neuronal artificiel par exemple.
Quelle époque ! terrible et fascinante à la fois.

Vite, un panneau solaire et un PiStorm.

[Sethghost]

Sethghost

#393436

Etude de la fonction Draw. Fonction Draw() de graphics library.
https://amigadev.elowar.com/read/ADCD_2.1/

Ou plutôt, comment à partir d’une interrogation sur la fonction Draw(), nous initions un raz de marée d’informations à emmagasiner afin de comprendre comment créer une application de dessin.

Comment procéder quand on est brouillon et débutant allergique à toute méthode d’apprentissage ?
. Il faut au minimum un cerveau biologique avec de la mémoire, une capacité d’attention ! et la volonté de dépasser certaines limites, qu’elles soient structurelles ou PSYCHIQUES (« je ne suis pas capable, ce n’est pas pour moi, je suis trop encombré pour emmagasiner, trop de problèmes » etc.).
—
REQUIS : S’INTÉRESSER AU LANGAGE C, C ANSI.
—
Draw().
https://amigadev.elowar.com/read/ADCD_2.1/Includes_and_Autodocs_2._guide/node0436.html
Sur AmigaOS 3.x, Draw() est une primitive graphique très bas niveau. Elle ne permet pas de faire un “programme de dessin” comme on pourrait le faire rapidement en Python avec une bibliothèque moderne.

Donc, pour concevoir un programme permettant de dessiner à la souris, il faut se taper la doc sur les fenêtres, et en gros cet inventaire de mots clés :
. Intuition, les RastPorts, les messages, les gadgets, les écrans, les layers, les pointeurs, *, les bibliothèques système.

1. Qu’est-ce qu’Intuition ?
Intuition.library est : le système de fenêtres, l’interface graphique native, le gestionnaire des événements utilisateur.
C’est lui qui gère : les fenêtres, les écrans, les menus, les gadgets, la souris, le clavier, les messages IDCMP, le multitâche graphique.
– Intuition est le “chef d’orchestre” du GUI Amiga.
Sans Intuition : pas de fenêtre, pas de souris, pas d’événements.

2. Qu’est-ce que BOOPSI ?
BOOPSI signifie : Basic Object Oriented Programming System for Intuition
Introduit avec AmigaOS 2.x.
C’est une couche orientée objet ajoutée à Intuition.

Avant BOOPSI :
les gadgets étaient fixes, procéduraux, difficiles à étendre.

Avec BOOPSI :
les gadgets deviennent des classes, avec héritage, méthodes, dispatch de messages.
Exemples de classes :
button.gadget, string.gadget, listview.gadget, scroller.gadget
BOOPSI est l’ancêtre des toolkits GUI modernes.

3. Qu’est-ce que GadTools ?
GadTools est une bibliothèque de simplification.
Elle sert à : créer rapidement des gadgets standard, éviter la complexité brute de BOOPSI.
GadTools fournit : boutons, listes, menus, chaînes de texte, checkboxes, sliders.
Par exemple :
CreateGadget(…)
au lieu de construire manuellement une structure Intuition énorme.
GadTools est : plus simple, mais moins flexible que BOOPSI.

4. Intuition : la première vraie brique
tout commence par un écran ou une fenêtre.
Avant de dessiner : il faut un contexte graphique, donc une fenêtre, donc Intuition.

5. Écran vs Fenêtre
Écran (Screen)
Un écran est : une surface vidéo complète, avec son mode vidéo, sa palette, sa résolution.
Exemple :
Workbench est un Screen.
Fonctions : OpenScreen(), OpenScreenTags()

Fenêtre (Window)
Une fenêtre appartient à un écran.
Fonctions : OpenWindow(), OpenWindowTags()
Et c’est dans la fenêtre que l’on dessine.

6. Les bibliothèques indispensables
intuition.library
La plus importante.
Ouverture :
struct IntuitionBase *IntuitionBase;

IntuitionBase =
(struct IntuitionBase *)
OpenLibrary(« intuition.library »,0);
Includes
#include <intuition/intuition.h>
#include <intuition/intuitionbase.h>
#include <intuition/screens.h>
#include <intuition/gadgetclass.h>
#include <intuition/icclass.h>

Fonctions essentielles
Fenêtres :OpenWindow(), OpenWindowTags(), CloseWindow()
Écrans : OpenScreen(), OpenScreenTags(), CloseScreen()
Messages : GetMsg(), ReplyMsg(), WaitPort()
Menus : SetMenuStrip(), ClearMenuStrip()

graphics.library
Le moteur graphique.
Includes
#include <graphics/gfx.h>
#include <graphics/rastport.h>
#include <graphics/view.h>
#include <graphics/gfxbase.h>
Fonctions fondamentales
Dessin : Move(), Draw(), WritePixel(), ReadPixel(), RectFill(), PolyDraw(), Text()

Gestion graphique
SetAPen()
SetBPen()
SetDrMd()
InitRastPort()

Bitmaps : AllocBitMap(), FreeBitMap(), BltBitMap()

layers.library
Très importante pour les fenêtres.
Les Layers : gèrent les zones visibles, le clipping, les recouvrements de fenêtres.
Includes
#include <libraries/layers.h>
#include <libraries/layersbase.h>
Fonctions : BeginUpdate(), EndUpdate(), LockLayer(), UnlockLayer()

gadtools.library
Pour les widgets standards.
Includes
#include <libraries/gadtools.h>
Fonctions : CreateContext(), CreateGadget(), FreeGadgets(), GT_GetIMsg(), GT_ReplyIMsg()

utility.library
Petite bibliothèque d’outils système.
Includes
#include <libraries/utility.h>
Fonctions : tags, listes, hooks, chaînes.

Très utilisée indirectement.
. dos.library
Pour : fichiers, sauvegarde, chargement d’images.
Includes
#include <dos/dos.h>
Fonctions : Open(), Close(), Read(), Write()

7. Structures fondamentales à connaître
Window, struct Window
Contient :
le RastPort, les dimensions, les ports de messages, les gadgets, les flags. RastPort struct RastPort

Le contexte de dessin.
Screen, struct Screen

L’écran vidéo.
IntuiMessage, struct IntuiMessage, les événements souris/clavier.

8. Les événements fondamentaux
Pour un programme de dessin :
IDCMP_MOUSEMOVE
IDCMP_MOUSEBUTTONS
IDCMP_RAWKEY
IDCMP_CLOSEWINDOW
IDCMP_REFRESHWINDOW

9. Les pointeurs et leur importance
* la compréhension des pointeurs est ABSOLUMENT essentielle. AmigaOS est écrit en C système pur.

Exemple :
win->RPort
signifie : accéder au RastPort contenu dans la structure Window.
Sans maîtrise des pointeurs, structures, adresses mémoire, la programmation Amiga devient presque impossible.

10. La base minimale d’un programme graphique Amiga

Ordre réel :
Étape 1 – Ouvrir les bibliothèques.
Étape 2 – Créer écran ou utiliser Workbench.
Étape 3 – Créer une fenêtre Intuition.
Étape 4 – Récupérer le RastPort.
Étape 5 – Entrer dans la boucle événementielle.
Étape 6 – Traiter souris/clavier.
Étape 7 – Dessiner avec graphics.library.

11. Le cœur réel : la boucle IDCMP
Le vrai “moteur” d’une application Amiga :

while(running)
{
    WaitPort(win->UserPort);

    while(msg = GetMsg(win->UserPort))
    {
        switch(msg->Class)
        {
            case IDCMP_MOUSEMOVE:
            break;

            case IDCMP_CLOSEWINDOW:
                running = FALSE;
            break;
        }

        ReplyMsg(msg);
    }
}

C’est cela l’âme d’Intuition, la programmation événementielle Amiga.

12. Ce qu’il faut connaître ABSOLUMENT
Niveau débutant sérieux : C ANSI, pointeurs, structures, Intuition, RastPort, IDCMP, graphics.library.
Niveau intermédiaire : GadTools, menus, double buffering, BitMaps, Blitter
Niveau avancé : BOOPSI, custom gadgets, layers, ASL requester, CyberGraphX (obsolète…), datatypes, intuition hooks

Conclusion
Pour écrire un logiciel de dessin sous AmigaOS 3.x, il faut comprendre :
Intuition → GUI et événements
Graphics → dessin
RastPort → contexte graphique
IDCMP → messages
pointeurs C → accès aux structures système
éventuellement BOOPSI/GadTools → interface moderne

Donc : pour un programme de dessin tout commence par un rastport (*), écran, fenêtre Intuition. (On ne parlera pas de Reaction introduit dans le 3.5).

Définition fondamentale : RASTPORT
RastPort signifie : Raster Port
Autrement dit : un “port d’accès au raster graphique”.
Le “raster” désigne : la surface vidéo, les pixels, les bitplanes.

. Exemple concret : draw.c

/* Dessiner dans une fenêtre du workbench */

#include <proto/exec.h>
#include <proto/dos.h>
#include <proto/graphics.h>
#include <proto/intuition.h>

int main (void)

{
struct Window *win;
struct IntuiMessage *mess;
BOOL cont;
BOOL lbutton;
BOOL rbutton;
long old_x;
long old_y;
long x;
long y;

win = OpenWindowTags (NULL,
		WA_Left,112,
		WA_Top,84,
		WA_Width,480,
		WA_Height,300,
		WA_Flags,WFLG_CLOSEGADGET | WFLG_DRAGBAR | WFLG_DEPTHGADGET | WFLG_SIZEGADGET | WFLG_RMBTRAP | WFLG_REPORTMOUSE | WFLG_ACTIVATE | WFLG_GIMMEZEROZERO | WFLG_NOCAREREFRESH,
		WA_IDCMP,IDCMP_CLOSEWINDOW | IDCMP_VANILLAKEY | IDCMP_MOUSEBUTTONS | IDCMP_MOUSEMOVE,
		WA_MinWidth,80,WA_MinHeight,40,
		WA_MaxWidth,-1,WA_MaxHeight,-1,
		TAG_END);

if (!win)
	{
	Printf ("cannot open window\n");
	return (RETURN_FAIL);
	}

rbutton = FALSE;
lbutton = FALSE;
x = win->MouseX;
y = win->MouseY;
old_x = x;
old_y = y;

cont = TRUE;
do	{
	if (Wait ((1L << win->UserPort->mp_SigBit) | SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C)
		cont = FALSE;

	while (mess = (struct IntuiMessage *) GetMsg (win->UserPort))
		{
		switch (mess->Class)
			{
		case IDCMP_MOUSEMOVE:
			x = mess->MouseX - win->BorderLeft;;
			y = mess->MouseY - win->BorderTop;
			break;
		case IDCMP_MOUSEBUTTONS:
			switch (mess->Code)
				{
			case SELECTDOWN:
				lbutton = TRUE;
				break;
			case SELECTUP:
				lbutton = FALSE;
				break;
			case MENUDOWN:
				rbutton = TRUE;
				break;
			case MENUUP:
				rbutton = FALSE;
				break;
				}
			break;
		case IDCMP_VANILLAKEY:
			if (mess->Code == 0x1b) /* Esc */
				cont = FALSE;
			break;
		case IDCMP_CLOSEWINDOW:
			cont = FALSE;
			break;
			}
		ReplyMsg ((struct Message *)mess);
		}

	if (x != old_x || y != old_y)
		{
		if (rbutton && lbutton)
			{
			SetAPen (win->RPort,3);
			Move (win->RPort,old_x,old_y);
			Draw (win->RPort,x,y);
			}
		else if (rbutton)
			{
			SetAPen (win->RPort,2);
			Move (win->RPort,old_x,old_y);
			Draw (win->RPort,x,y);
			}
		else if (lbutton)
			{
			SetAPen (win->RPort,1);
			Move (win->RPort,old_x,old_y);
			Draw (win->RPort,x,y);
			}
		old_x = x;
		old_y = y;
		}
	}
while (cont);

CloseWindow (win);

return (RETURN_OK);
}

Vite, un panneau solaire et un PiStorm.

[thellier]

thellier

#393438

Bonjour
Je dois admettre qu’on peut utiliser ChatGPT pour faire une fonction C : « Langage C/AmigaOS 3 68k : fais moi un prog qui fait ceci »
J’ai pas confiance sur un programme complet mais pour lui faire écrire une fonction d’une centaine de ligne ça marche pas mal genre « prog qui ouvre une window de 640×480 »
Après si on bute sur une erreur de compil gcc on peut lui copier/coller la partie de listing concerné précédée par un message du genre « J’ai l’erreur gcc « xxxx » dans la partie de code pour AmigaOS 3 68k qui suit:  »
Ca marche avec le ChatGPT anonyme/gratuit

Quelqu’un avait demandé comment trouver quel include pour tel fonction ? : Moi j’utilise un prog de recherche de fichier (genre AgentRanSack sur Windows) et lui demande trouve les fichier dans /include qui contienne « OpenLibrary » nommé « *.h »

[thellier]

thellier

#393439

Dans le même ordre d’idée: pour savoir quel .library (s) un prog binaire Amiga a besoin j’ouvre le binaire avec un editeur de texte et je cherche « .library »