FreeBASIC – libreria statica

Nel precedente articolo abbiamo avuto modo di dare un primo sguardo alla teoria che riguarda le librerie.

Oggi passeremo alla pratica realizzando la nostra prima libreria statica.

Una libreria statica è un file contenente del codice compilato che svolge diversi compiti. Questo codice può essere utilizzato nel proprio progetto e quindi aggiunto staticamente durante la creazione del file eseguibile.

Facciamo quindi un semplice esempio creando una libreria che contiene un unico modulo con un’unica funzione:

Modulo libreria

''nome del file: libreria.bas

''funzione per il calcolo dell'area di un triangolo
public function area(byval b as integer, _
                     byval h as integer) as integer
  return b * h / 2
end function

A questo punto dobbiamo compilare il file specificando al compilatore FreeBASIC che vogliamo creare una libreria e non un eseguibile:

fbc -lib libreria.bas

Noteremo che nella stessa cartella del modulo compare ora il file liblibreria.a che è il file archivio contenente la nostra libreria.

Un archivio può contenere più moduli.

Interfaccia

Per facilitare l’uso della nostra libreria è bene creare una interfaccia (API) che permetta ad un qualsiasi programmatore interessato di accedere facilmente alle varie funzioni messe a disposizione.

In FreeBASIC per creare una interfaccia, non facciamo altro che scrivere un file di intestazione.

''nome del file: libreria.bi

#inclib "libreria" ''include il modulo libreria

declare function area(byval b as integer, _
                      byval h as integer) as integer

Programma

Immaginiamo ora di essere un programmatore che voglia utilizzare la funzione area della nostra libreria.

Scriviamo quindi questo semplice programma:

''nome file: test.bas

#include "libreria.bi" ''include il file di intestazione

'stampa l'area del triangolo
print "L'area del triangolo vale: "; area(4, 5)

A questo punto si compila il modulo del programma (test.bas) e si ottiene il file eseguibile che ingloba anche la libreria.

Nel prossimo articolo creeremo invece una libreria dinamica.

FreeBASIC – salvare e caricare immagini

Dopo aver imparato come creare una immagine, oggi vedremo come salvarla in un file utilizzando il formato bitmap e quindi come poterla caricare per usi successivi.

Come salvare una immagine

L’istruzione per salvare una qualsiasi immagine è la funzione bsave.

La funzione restituisce il valore 0 (zero) se il salvataggio è andato a buon fine, altrimenti viene restituito un codice di errore.

Vediamo l’uso di questa istruzione con un semplice esempio:

screen 19, 32, 1

''dimensiona la variabile per gestire il
''valore restituito dalla funzione bsave
dim risultato as long

''dimensiona la variabile di tipo puntatore
''per l'indirizzo di memoria
dim immagine1 as any ptr

''crea l'immagine
immagine1 = imagecreate(200, 200, rgb(255,0,0))
if immagine1 = 0 then
  print "Creazione dell'immagine non riuscita!"
  sleep
else
  ''disegna un cerchio verde al centro
  circle immagine1, (100, 100), 50, rgb(0,255,0)
  ''inserisce l'immagine all'interno
  ''della finestra grafica
  put(150, 150), immagine1
end if

print "Premi un tasto per salvare l'immagine."
sleep

''salva l'immagine
risultato = bsave("immagine.bmp", immagine1)
if risultato <> 0 then
  print "Salvataggio dell'immagine non riuscito!"
else
  print "L'immagine e' stata correttamente salvata."
end if

sleep

Ora, se il salvataggio è riuscito, andiamo a rinominare il file della nostra immagine modificandolo poi con un qualsiasi programma di grafica prima di provare a caricarlo.

Come caricare una immagine

L’istruzione per caricare le immagini è bload.

Aggiungiamo ora questo blocco di codice in fondo al programma che abbiamo appena provato:

print "Premi un tasto per caricare l'immagine"
print "modificata in una nuova posizione."
sleep

risultato = bload("immagine2.bmp", immagine1)
if risultato <> 0 then
  print "Caricamento dell'immagine non riuscito!"
  sleep
else
  print "L'immagine e' stata correttamente caricata."
  ''inserisce l'immagine all'interno
  ''della finestra grafica
  put(300, 50), immagine1
  print "Premi un tasto per uscire."
  sleep
  ''distrugge l'immagine per liberare la memoria
  imagedestroy immagine1
end if

Se tutto è andato a buon fine dovremmo essere riusciti a visualizzare, in una diversa posizione dello schermo, la nostra immagine modificata.

Bene. Anche per oggi possiamo ritenerci soddisfatti. Un altro piccolo passo è stato fatto nel percorso di apprendimento del FreeBASIC. 🙂

FreeBASIC – creare una immagine

Spesso può rivelarsi utile creare una immagine in memoria invece che disegnarla direttamente sullo schermo grafico.

Poi, una volta creata, sarà possibile richiamarla attraverso il suo indirizzo di memoria.

Questo procedimento, oltre a velocizzare il disegno delle immagini, rende possibile vari effetti grafici che possono migliorare l’efficacia e la qualità dei nostri programmi.

Possiamo immaginare ciascuna immagine come una tela contenuta all’interno di una cornice avente delle specifiche dimensioni (larghezza e altezza); la tela potrà essere colorata o trasparente.

Come creare una immagine

La funzione che ci permette di creare un’immagine è imagecreate disponibile in due versioni:

screen 19, 32, 1

''dimensiona due variabili di tipo puntatore
''per gli indirizzi di memoria
dim immagine1 as any ptr
dim immagine2 as any ptr

''I versione con i seguenti argomenti:
''- larghezza
''- altezza
''- colore dello sfondo
immagine1 = imagecreate(200, 200, rgb(255,0,0))
if immagine1 = 0 then
  print "Creazione dell'immagine 1 non riuscita!"
  sleep
else
  ''disegna un cerchio verde al centro
  circle immagine1, (100, 100), 50, rgb(0,255,0)
  ''inserisce l'immagine all'interno
  ''della finestra grafica
  put(150, 150), immagine1
  ''distrugge l'immagine per liberare la memoria
  imagedestroy immagine1
end if

''II versione con l'aggiunta di un quarto argomento:
''- profondità di colore
immagine2 =imagecreate(200, 200, rgb(0,255,0), 32)
if immagine2 = 0 then
  print "Creazione dell'immagine 2 non riuscita!"
  sleep
else
  ''disegna un cerchio rosso al centro
  circle immagine2, (100, 100), 50, rgb(255,0,0)
  ''inserisce l'immagine all'interno
  ''della finestra grafica
  put(300, 300), immagine2
  ''distrugge l'immagine per liberare la memoria
  imagedestroy immagine2
end if

sleep

Note sulla istruzione imagecreate

  • L’istruzione va utilizzata soltanto dopo aver definito la modalità grafica: e quindi sia la risoluzione dello schermo che la risoluzione grafica.
  • Se il colore dello sfondo non viene specificato, il valore predefinito sarà trasparente e quindi in pratica sarà visibile il colore di sfondo della finestra grafica.
  • Se l’istruzione dovesse fallire, viene restituito il valore null (0), altrimenti viene restituito l’indirizzo di memoria dell’immagine.

Per fare le cose per bene, occorre anche ricordarsi di distruggere le immagini create in modo tale da liberare la memoria. Per farlo si utilizza l’istruzione imagedestroy.

Bene. Per oggi possiamo fermarci qui. Nel prossimo articolo impareremo a salvare e caricare le immagini.

FreeBASIC – il cerchio

Nei precedenti articoli abbiamo lavorato con il punto e la linea, oggi lavoreremo con il cerchio e l’ellisse.

Istruzione circle

L’istruzione che impareremo ad usare per disegnare cerchi ed ellissi è circle.

Come abbiamo fatto per il punto e per la linea, anche in questo caso scriveremo un semplice programma per esplorare le potenzialità di questa istruzione.

''definizione della costante pi greco
const pi = 3.14159

screen 19, 32
color(rgb(0,0,0),rgb(255,255,255))
cls

''cerchio color giallo con centro identificato
''da coordinate assolute
circle (100,100), 50, rgb(255,255,0)

''cerchio color ciano con centro identificato
''da coordinate relative
circle step (50,50), 50, rgb(0,255,255)

''arco color magenta con estremi a 0 rad e pi/2 rad
circle step (50,50), 50, rgb(255,0,255), 0, (90*pi/180)

''ellisse color rosso
circle step (50,50), 50, rgb(255,0,0),,,0.5

''ellisse color verde piena
circle step (50,50), 50, rgb(0,255,0),,,0.25,F

sleep

Con l’aiuto dei commenti il codice è abbastanza intuitivo.

Gli unici aspetti dell’istruzione che meritano qualche nota in più sono:

  • i due argomenti che gestiscono gli estremi dell’arco che devono essere espressi in radianti (più sotto un utile schema per la conversione gradi/radianti);
  • l’argomento che gestisce la proporzione tra l’altezza e la larghezza dell’ellisse (nel caso del cerchio varrà ovviamente 1.0).

Schema per la conversione gradi/radianti

Degree-Radian Conversion it.svg

Fonte: Wikipedia (pubblico dominio, collegamento al file)

Bene. Per oggi ci fermiamo qui. 🙂

FreeBASIC – la linea

Dopo aver visto come lavorare con il punto, con questo articolo vedremo come lavorare con un altro ente geometrico fondamentale di Euclide: la linea retta.

In realtà ciò che potremo effettivamente disegnare a video sarà soltanto una parte della linea retta: ovvero un segmento.

L’istruzione che utilizzeremo ci permetterà di costruire anche due figure geometriche: il quadrato e il rettangolo.

Istruzione line

In freeBASIC per tracciare un segmento si usa l’istruzione line.

Vediamo in un semplice programma i diversi modi di utilizzo.

screen 19, 32

''primo piano nero, sfondo bianco
color (rgb(0,0,0),rgb(255,255,255))

cls

locate 1: print "Istruzione line"

''1) segmento rosso orizzontale continuo 
locate 3: print "1)"
line (25,40)-(500,40),rgb(255,0,0)

''2) segmento blu orizzontale con tratteggio irregolare 
locate 5: print "2)" 
line (25,70)-(300,70),rgb(0,0,255),,&b1110010011100100

''3) rettangolo verde vuoto con tratteggio regolare
locate 7: print "3)"
line (25,100)-(125,120),rgb(0,255,0),B,&b1111111100000000

''4) quadrato giallo pieno con le coordinate del
''   secondo vertice relative a quelle del primo vertice
''   e diagonale magenta tratteggiata
locate 9: print "4)"
line (25,130)-step(100,100),rgb(255,255,0),BF
line (25,130)-step(100,100),rgb(255,0,255),,&b1100110011001100

sleep

Il codice più sopra riportato si spiega in gran parte da sé, ma forse è bene chiarire il funzionamento di due argomenti di questa istruzione:

  • il primo riguarda il parametro B o BF: in pratica se si vuole disegnare soltanto il perimetro della figura si indica la lettera B che sta per box (scatola), mentre se si vuole colorare l’intera figura si indicano le lettere BF che stanno per box filled (scatola riempita);
  • il secondo è quello che specifica lo stile del segmento. Lo si fa scrivendo un letterale numerico intero in forma binaria con 16 bits. Questo valore rappresenta una maschera di bits (bitmask) dove al valore 1 corrisponde un pixel acceso e al valore 0 un pixel spento. La maschera viene ripetuta per tutta la lunghezza del segmento.

Bene. Per oggi ci fermiamo qui. Nel prossimo articolo vedremo come lavorare con il cerchio e l’ellisse. 🙂

FreeBASIC – il punto

Oggi parleremo del punto.

In geometria il punto è una entità adimensionale che esiste soltanto in quanto è identificabile attraverso delle coordinate che ne specificano la posizione su un piano.

Come entità adimensionale possiamo dire che il punto fisicamente non esiste, ma, nonostante questo, il pensiero può lo stesso concepirlo concettualmente.

Nella grafica computerizzata il punto diventa invece un oggetto reale: il singolo pixel.

In FreeBASIC per disegnare un punto si utilizza l’istruzione pset.

Disegnare un pixel con pset

Vediamo un semplice esempio per disegnare tre pixels colorati:

''definisce una risoluzione dello schermo 100x100px
''con risoluzione grafica 32bpp
screenres 400, 200, 32

''definisce il colore bianco per il primo piano e il
''colore nero per lo sfondo
color(rgb(255,255,255),rgb(0,0,0))

''pulisce lo schermo grafico per rendere attivi i colori
''definiti con l'istruzione color
cls

''messaggio
locate 1: print "3 pixels"

''disegna tre pixels
pset(180,100), rgb(255,0,0) ''disegna un pixel rosso
pset(200,100), rgb(0,255,0) ''disegna un pixel verde 
pset(220,100), rgb(0,0,255) ''disegna un pixel blu 

sleep 

Coordinate relative con pset step

Abbiamo visto come disegnare tre pixels specificando per ciascuno le proprie coordinate assolute.

In FreeBASIC abbiamo però anche la possibilità di disegnare un pixel specificando delle coordinate relative all’ultimo pixel disegnato:

screen 14, 32
color(rgb(0,0,0),rgb(255,255,255))
cls
pset(40,40), rgb(255,0,0)
for i as integer = 1 to 39
  pset step(1,1), rgb(255,0,0)
next i
for i as integer = 1 to 40
  pset step(1,-1), rgb(0,255,0)
next i
for i as integer = 1 to 80
  pset step(-1,0), rgb(0,0,255)
next i
sleep

Per oggi ci fermiamo qui. Nel prossimo articolo parleremo della linea. 🙂

FreeBASIC – colori

In questo nuovo articolo andremo alla scoperta di come si può lavorare con i colori in FreeBASIC.

Funzione color

La prima funzione che incontriamo è la funzione color che ci permette di fare tre cose:

  • impostare il colore del primo piano (foreground)
  • impostare il colore dello sfondo (background)
  • ottenere i colori correnti del primo piano e dello sfondo

Impostare i colori del primo piano e dello sfondo

L’impostazione del colore del primo piano e dello sfondo, oltre ad avere diretto effetto sullo schermo grafico, ha effetto anche sulle figure che vengono su questo disegnate, per esempio con le funzioni line o circle, se non si specifica con queste istruzioni l’attributo relativo al loro colore.

Definire un colore con la funzione rgb

La funzione rgb permette di valorizzare distintamente i tre colori primari percepiti dal nostro occhio per sintesi additiva: rosso (red), verde (green) e blu (blue).

Nel mondo dei computer si fa largo uso del modello di colori RGB.

Vediamo un esempio:

''imposta la risoluzione dello schermo e quella grafica
screen 19, 32

''imposta il colore rosso per il primo piano e
''il colore zafferano per lo sfondo
color(rgb(255,0,0), rgb(244,196,48))

''pulisce lo schermo per rendere visibile il
''colore dello sfondo appena impostato
cls

print "Cosa sono i colori?"

sleep

Su Wikipedia è disponibile una lista dei colori molto utile per il programmatore.

Definire un colore con la tavolozza dei colori predefinita

In FreeBASIC è disponibile una tavolozza dei colori predefinita (default pallettes) che raggruppa una serie di colori visualizzabili in base alla modalità grafica scelta.

Per impostare uno di questi colori basterà specificare il relativo valore associato.

screen 12
color(1, 5) ''primo piano blu e sfondo rosa
cls
print "ciao"
sleep

In FreeBASIC è anche possibile cambiare la tavolozza dei colori attraverso l’istruzione palette, ma questa possibilità non verrà esplorata in questo articolo.

Ottenere il colore del primo piano e dello sfondo

La funzione color restituisce un valore ulong (ovvero un valore di tipo long senza però il segno) che contiene l’informazione dei valori del primo piano e dello sfondo correnti:

dim c as ulong
c = color()
print "Colori della console:"
print "primo piano:"; loword(c)
print "sfondo:"; hiword(c)

Ottenere il colore di un pixel

Oltre al colore del primo piano e dello sfondo, potremmo essere interessati a conoscere il colore di uno specifico punto dello schermo (pixel).

Per fare questo possiamo utilizzare la funzione point:

screen 12
color(1, 5) ''primo piano blu e sfondo rosa 
cls
line(10,10)-(40,10), 2 ''disegna una linea verde
locate 4,1: print "colore dello sfondo:"; point(5,5)
locate 5,1: print "colore di un pixel della linea:"; point(20,10)
sleep

Bene! Come introduzione al mondo dei colori in FreeBASIC possiamo fermarci qui.

A presto. 🙂

FreeBASIC – tastiera

Dopo aver visto come lavorare con il mouse, oggi impareremo a lavorare con la tastiera (keyboard).

Funzione multikey

Il nome della funzione che utilizzeremo è multikey.

In quest’altro articolo viene invece descritto l’uso della funzione getkey.

Funzionamento

Questa funzione necessita come argomento del valore del codice del tasto che si vuole verificare se è stato premuto. Se il tasto viene effettivamente premuto la funzione restituisce il valore -1 (true), altrimenti 0 (false).

Sul sito ufficiale di FreeBASIC è presente la lista dei codici dei tasti.

A ciascun codice corrisponde una costante.

La collezione dei nomi di queste costanti rientra nello spazio dei nomi (namespace) identificato dalla sigla FB che va quindi anteposta al nome della costante attraverso la notazione puntata. Per esempio: FB.SC_ESCAPE (per indicare il tasto ‘Esc’).

Questi valori costanti sono definiti all’interno del file di intestazione fbgfx.bi che fa parte della libreria grafica di FreeBASIC.

Ciò comporta che all’inizio del modulo dovremo includere la libreria grafica attraverso l’istruzione #include.

Esempio

#include "fbgfx.bi"

dim as integer x, y
screen 19
x = 300: y = 200

''continua il ciclo sino alla pressione del tasto 'Esc' (esci)
do
  ''verifica se vengono premuti i tasti freccia
  if multikey(FB.SC_LEFT) then x = x - 1
  if multikey(FB.SC_RIGHT) then x = x + 1
  if multikey(FB.SC_UP) then y = y - 1
  if multikey(FB.SC_DOWN) then y = y + 1
  ''pulisce lo schermo e disegna il cerchio alle nuove coordinate
  cls
  circle(x, y), 30
  sleep 15, 1
loop until multikey(FB.SC_ESCAPE)

Il secondo parametro (1) della funzione sleep comunica al compilatore FreeBASIC che la pausa di 15 ms non può essere interrotta dalla pressione di un qualsiasi tasto.

Bene. Anche oggi abbiamo fatto un piccolo passo in avanti. 🙂

FreeBASIC – Modello MVC

In questo articolo scopriremo uno dei modi per organizzare il codice in maniera efficace ed efficiente.

Per fare questo sfrutteremo il Modello Architetturale MVC (Model-View-Controller).

Modello Architetturale MVC

In pratica ciò che occorre fare per seguire questo schema di progettazione è raccogliere logicamente i moduli del nostro codice nelle 3 componenti del modello MVC che differiscono per scopo e logica di funzionamento. Vediamole in sintesi:

  • Il componente Modello – che rappresenta il cuore del nostro programma – è quella parte del codice che contiene tutte quelle procedure (subroutines e funzioni) per la gestione delle informazioni secondo le regole e la logica decise dal programmatore. In pratica è questo componente che determina il vero e proprio comportamento del programma.
  • Il componente Vista contiene tutta quella parte del codice concepita per la gestione della grafica e del testo. Questo modulo si occupa sia della visualizzazione dei risultati delle elaborazioni avvenute nel componente Modello (output), sia della visualizzazione di quegli elementi grafici e testuali che permettono all’utilizzatore di interagire con il programma (input).
  • Il componente Controllore si occupa invece della fasi di interlavoro con le altre due componenti: una parte del suo codice permette a questo componente di mettersi in ascolto degli input dell’utilizzatore provenienti dal componente Vista, per poi attivare le relative procedure del componente Modulo, da cui raccoglierà i risultati elaborati per attivare le relative procedure del componente Vista che si occuperà infine di trasformare i dati elaborati in oggetti grafici o testuali.

Forse uno schema può aiutarci a capire ancora meglio ciò che abbiamo provato a descrivere più sopra.

Schema del Modello Architetturale MVC

Di Wdror-wsu-ap and Regis Frey – Opera propria, Pubblico dominio, Collegamento

Per non lasciare tutto questo soltanto ad un livello teorico, scriveremo un programma per disegnare dei quadrati rossi, selezionarli o deselezionarli, e spostarli a video.

Programma di esempio

Volendo seguire lo schema di progettazione MVC, scriveremo un modulo per ciascun componente di questo Modello Architetturale. In aggiunta prepareremo anche un file di intestazione per organizzare meglio le dichiarazioni delle procedure e del tipo di dato creato ad hoc per l’occasione, così come si usa fare in FreeBASIC.

Una volta preparati e salvati i 4 files, si dovrà compilare il file sorgente modulo_controllore.bas e quindi eseguire il file compilato.

File di intestazione

''nome file: intestazione.bas
''sito web: https://ciucoinformatico.home.blog/
''ultimo aggiornamento: 04/08/2019

/' DESCRIZIONE
File di intestazione per la dichiarazione del tipo di dato
creato ad hoc e delle procedure contenute negli altri moduli.
'/

''definizione del tipo di dato figura
type figura
  tipo as string
  coord_x as integer
  coord_y as integer
  dimensione as integer
  colore(1 to 3) as integer
  selezione as boolean
  selezione_x as integer
  selezione_y as integer
end type

''dimensiona un array fisso del tipo figura
dim figure(1 to 10) as figura

/'
Componente VISTA
'/

''procedura per stampare a video il menu
declare sub stampa_menu()

''procedura per visualizzare le informazioni del mouse
declare sub info_mouse(x as integer, y as integer, r as integer)

''procedura per visualizzare il numero delle figure create
declare sub stampa_tot_figure(n as integer)

''procedura per disegnare le figure
declare sub disegna_figura(f() as figura)

/'
Componente MODELLO
'/

''procedura per la creazione di una figure geometrica
declare sub crea_figura(x as integer, y as integer, r as integer, n as integer, f() as figura)

''procedura per la selezione di una o più figure
declare sub seleziona(x as integer, y as integer, f() as figura)

''procedura per lo spostamento delle figure
declare function sposta(x as integer, y as integer, f() as figura) as boolean

Modulo Controllore

''nome file: controllore.bas
''architettura MVC (Model-View-Controller): componente CONTROLLORE
''sito web: https://ciucoinformatico.home.blog/
''ultimo aggiornamento: 04/08/2019

/' DESCRIZIONE
Componente CONTROLLO: modulo per l'ascolto degli input
dell'utilizzatore che tramite il mouse interagisce con lo
schermo, e dispaccio degli eventi generati dall'utilizzatore
alle procedure del componente MODELLO e chiamata alle
procedure di visualizzazione del componente VISTA.
'/

#include once "file_intestazione.bi"
#include once "modulo_vista.bas"
#include once "modulo_modello.bas"

''dimensiona una variabile per ricevere il valore
''restituito dalla funzione getmouse
dim as long verifica_mouse

''dimensiona quattro variabili per ricevere le
''informazioni provenienti dal mouse
dim as integer mouse_x, mouse_y, mouse_ruota, mouse_pulsante

''variabile per il conteggio delle figure
dim num_figura as integer
num_figura = 0

''Visualizza il menu
stampa_menu()

''ciclo per l'ascolto degli input (informazioni dal mouse)
do
  verifica_mouse = getmouse(mouse_x, mouse_y, mouse_ruota, mouse_pulsante)
  if verifica_mouse = 0 then
    ''visualizza a video le informazioni del mouse
    info_mouse(mouse_x, mouse_y, mouse_ruota)
  else
    ''non fare nulla
  end if
  if mouse_pulsante = 1 then
    ''tasto sinistro del mouse
    seleziona(mouse_x, mouse_y, figure())
    disegna_figura(figure())
    stampa_menu()
    stampa_tot_figure(num_figura)
  elseif mouse_pulsante = 4 then
    ''tasto centrale del mouse
    if sposta(mouse_x, mouse_y, figure()) then
      disegna_figura(figure())
      stampa_menu()
      stampa_tot_figure(num_figura)
      sleep 200
    else
    end if
  elseif mouse_pulsante = 2 then
    ''tasto destro del mouse
    if num_figura < 10 then
      num_figura = num_figura + 1
      crea_figura(mouse_x, mouse_y, mouse_ruota, num_figura, figure())
      disegna_figura(figure())
      stampa_menu()
      stampa_tot_figure(num_figura)
      sleep 200
    else
      beep
    end if
  else
    ''non fare nulla
  end if
loop until verifica_mouse = 1

Modulo Vista

''nome file: vista.bas
''architettura MVC (Model-View-Controller): componente VISTA
''sito web: https://ciucoinformatico.home.blog/
''ultimo aggiornamento: 03/08/2019

/' DESCRIZIONE
Componente VISTA: modulo per la rappresentazione a video
del testo e delle figure.
'/

''Imposta una pagina video con la modalità grafica 19 per
''una risoluzione dello schermo di 800x600 pixels, una
''dimenzione testuale di 100 colonne x 37 righe e
''una profondità di colore a 32bpp.
screen 19, 32, 1

''posiziona il mouse al centro
setmouse 400, 300

''procedura per stampare a video il menu
sub stampa_menu()
  locate 1,1: print "Mouse:"
  locate 2, 1: print "tasto sinistro = seleziona le figure"
  locate 3, 1: print "tasto centrale = sposta le figure selezionate"
  locate 4, 1: print "tasto destro = crea una figura"
  locate 5, 1: print "Nota:"
  locate 6, 1: print "Per ingrandire o rimpicciolire la figura, prima"
  locate 7, 1: print "di crearla, usa la ruota."
  locate 36, 1: print "Per uscire dal programma porta il puntatore del";
  print " mouse fuori dalla finestra grafica."
end sub

''procedura per visualizzare il numero delle figure create
sub stampa_tot_figure(n as integer)
  locate 8, 1: print "Totale figure create:"; n; _
                     " (al massimo ne puoi creare 10)"
end sub

''procedura per visualizzare le informazioni del mouse
sub info_mouse(x as integer, y as integer, r as integer)
  locate 9, 1
  print "x:"; x; " y:"; y; " ruota:"; r
end sub

''procedura per disegnare le figure
sub disegna_figura(f() as figura)
  cls 1
  ''itera gli elementi del contenitore delle figure
  for i as integer = lbound(f) to ubound(f)
    if f(i).tipo = "quadrato" then
      line(f(i).coord_x, f(i).coord_y)-(f(i).coord_x + f(i).dimensione, f(i).coord_y), rgb(f(i).colore(1),f(i).colore(2),f(1).colore(3))
      line(f(i).coord_x + f(i).dimensione, f(i).coord_y)-(f(i).coord_x + f(i).dimensione, f(i).coord_y + f(i).dimensione), rgb(f(i).colore(1),f(i).colore(2),f(i).colore(3))
      line(f(i).coord_x + f(i).dimensione, f(i).coord_y + f(i).dimensione)-(f(i).coord_x, f(i).coord_y + f(i).dimensione), rgb(f(i).colore(1),f(i).colore(2),f(i).colore(3))
      line(f(i).coord_x, f(i).coord_y + f(i).dimensione)-(f(i).coord_x, f(i).coord_y), rgb(f(i).colore(1),f(i).colore(2),f(1).colore(3))
    end if
  next i
end sub

Modulo Modello

''nome file: modello.bas
''architettura MVC (Model-View-Controller): componente MODELLO
''sito web: https://ciucoinformatico.home.blog/
''ultimo aggiornamento: 03/08/2019

/' DESCRIZIONE
Modulo contenente le procedure per la gestione dei dati
e la logica di funzionamento del programma.
'/

''procedura per la creazione di una figure geometrica
sub crea_figura(x as integer, y as integer, r as integer, n as integer, f() as figura)
  f(n).tipo = "quadrato"
  f(n).coord_x = x
  f(n).coord_y = y
  f(n).dimensione = 80 + r
  f(n).colore(1) = 255
  f(n).colore(2) = 0
  f(n).colore(3) = 0
  f(n).selezione = false
end sub

''procedura per la selezione di una o più figure
sub seleziona(x as integer, y as integer, f() as figura)
  ''itera gli elementi del contenitore delle figure
  for i as integer = lbound(f) to ubound(f)
    if x >= f(i).coord_x and x <= (f(i).coord_x + f(i).dimensione) and y >= f(i).coord_y and y <= (f(i).coord_y + f(i).dimensione) then
       f(i).colore(2) = 255
       f(i).selezione = true
       f(i).selezione_x = x - f(i).coord_x
       f(i).selezione_y = y - f(i).coord_y
    else
      f(i).colore(2) = 0
      f(i).selezione = false
      f(i).selezione_x = 0
      f(i).selezione_y = 0       
    end if
  next i
end sub

''procedura per lo spostamento delle figure
function sposta(x as integer, y as integer, f() as figura) as boolean
  dim controllo as boolean
  controllo = false
  ''itera gli elementi del contenitore delle figure
  for i as integer = lbound(f) to ubound(f)
    if f(i).selezione = true then
      f(i).coord_x = x - f(i).selezione_x
      f(i).coord_y = y - f(i).selezione_y
      ''deselezione
      f(i).colore(2) = 0
      f(i).selezione = false
      f(i).selezione_x = 0
      f(i).selezione_y = 0       
      controllo = true     
    else
      ''non fare nulla
    end if
  next i
  return controllo 
end function

Bene. Per oggi ci fermiamo qui.

A rileggerci tra circa una settimana. 🙂