XNA Projects - ITA

Prato Fiorito

2013-03-31T21:10:00.003+02:00

Beh, non tutti sanno giocare al fantastico gioco Prato Fiorito. Questa è una versione basilare, ma completamente funzionane in linea di comando programmata in C.

Non sono riuscito a farla nella libreria standard, la funzione gotoxy non è presente nella libreria conio.h ma in conio2.h. Io non sono riuscito ad installarla sul Dev quindo per utilizzare la funzione gotoxy l'ho dovuta scrivere usando delle API di windows. Un altro intoppo per la portabilità è il cambio di colore nella linea di comando, supportato solo dalla libreria 'windows.h'

Credo che sia meglio fare una piccola introduzione al gioco del Prato Fiorito. Il gioco si svolge in una tabella (nel nostro caso 9x9) dove sono presenti alcuni fiori nascosti, l'obbiettivo è identificare la loro posizione senza cliccarli. Per fare ciò il gioco prevede che le caselle che non contengano un fiore, contengano un numero. Questo numero identifica il numero di fiori attorno a quella casella.

I comando per giocare a questo gioco su windows sono basilari (punti e clicchi con il mouse). A linea di comando invece è meno intuitivo. Le frecce spostano il cursore, con 'a' si segna o si toglie il segno dalla posizione come fiore, con 'b' si apre e si legge il contenuto della casella. Il senso di segnare i fiori con 'a' è quello di non premerli per errore, infatti, se una casella è segnata non si può aprire.
Passiamo ora al funzionamento. Il sistema della grafica è lo stesso identico del Tetris: scrive su una matrice quello da stampare nelle coordinate esatte. Ad ogni ciclo pulisce la console e stampa carattere a carattere il contenuto della matrice.
La gestione dell'input è abbastanza semplice, associa al codice delle frecce lo spostamento del cursore (tramite gotoxy). La posizione viene gestita semplicemente da due interi curX e curY che rappresentano ovviamente le coordinate del cursore. La funzione 'generateBoard' viene chiamata solo dopo aver aperto la prima casella, in modo tale da non perdere al primo turno. La board vera e propria vene memorizzata in una matrice (in questo caso 9x9), un fiore ha codice 0, una casella che è vicina ad n blocchi ha codice n, una casella che non è adiacente ad alcun blocco ha codice -1. Tramite questa matrice diventa veramente facile gestire l'input, quando viene aperta una casella, se è 0 il gioco termina perché è un fiore, se è un numero positivo apre la casella e visualizza il numero, se è -1 apre tutte le caselle attorno a quella con un funzione ricorsiva. Questa funzione può sembrare complicata perché è ricorsiva, in realtà è veramente semplice, ripete semplicemente la stessa operazione per tutte le caselle attorno. Non può uscire dalla matrice con gli indici perché vengono verificati con una serie di if, non può nemmeno aprire un fiore perché attorno ad una casella con codice -1 non ci sono fiori. Appena più complicata è la funzione di generazione della board, il funzionamento però è facile da comprendere leggendo i commenti. Inizialmente imposta la matrice con soli valori -1. Poi genera a caso il numero deciso di fiori, evita che due fiori si sovrappongano e che il fiore venga generato nella posizione del cursore (per evitare una sconfitta al primo turno). Ora inizia un ciclo che scorre tutte le caselle della board: se il contenuto è zero ignora la cella (un fiore ha distanza zero), se è -1 (non è un fiore) allora conta quanti fiori ci sono attorno e salva il valore nella cella. Appena viene concluso il ciclo per debug salva il contenuto della board in un file. Sarà facile capire cosa c'è dentro ogni singola cella in caso di crash o di bug...
La funzione che controlla la vittoria e quindi la fine del gioco è molto semplice, scorre tutte le caselle del modello e della board, se una casella che non è un fiore è ancora chiusa allora la partita non è terminata. Per uscire rapidamente dai due cicli ho usato un goto...
Quando il gioco si conclude mostra la board con segnate le posizioni dei fiori. Per questioni estetiche ho anche messo i colori alla linea di comando... La funzione che imposta il colore della console non l'ho scritta io ma l'ho cercata su google... Non è difficile da comprendere, ottiene l'handle dell'stdout e chiama la funzione 'SetConsoleTextAttribute' della libreria 'wincon.h' che imposta le proprietà della linea di comando. L'intero color a parametro è definito in 'wincon.h' e può essere: FOREGROUND_XXX dove XXX può essere RED, GREEN, BLUE, INTENSITY. Eventualmente i colori possono essere uniti con l'operatore |.
Per il disegno della board ho usato un piccolo trucco che mi hanno suggerito: ho disegnato la board in un file di testo (board9x9.txt) e il suo contenuto l'ho caricato nel modello... Il file contiene anche delle informazioni sulla board, la prima linea contiene cinque numeri: la larghezza del campo di gioco, la sua altezza, la coordinata x della prima casella, la sua y, ed il numero di fiori. Non ho ancora provato, ma si potrebbe provare a modificare il file board9x9 per aggiungere altri livelli di difficoltà con più fiori e più caselle.

DOWNLOAD:

SCREEN:

Tetris

2013-03-30T19:38:00.002+01:00

Ecco a vuoi un giochino programmato in C. Si tratta del famosissimo tetris!

Questa è la seconda versione che ho scritto del tetris. La prima era solo per sperimentare il disegno su console con un model e la gestione dell'input. Apprese queste conoscenze ed altre ho scritto una versione seria di questo gioco.

Penso non sia necessario spiegare che cosa sia il tetris, quindi passiamo subito al funzionamento.

Il tetris che ho programmato è una versione Multiplayer su console. I due giocatori giocano su una stessa tastiera premendo i caratteri per spostare il proprio tetramino. Chi fa più punti vince.

Nelle versioni precedenti dei giochi su console che ho programmato si manifestava un problema: ad ogni aggiornamento della grafica del gioco (ad ogni ciclo del while) tutto lo schermo veniva cancellato e riscritto. Questa operazione ha dei tempi non lunghissimi ma non invisibili. Per evitare questo problema ho pensato di utilizzare uno stack ed un buffer per gestire la console. Lo schermo viene quasi mai riscritto completamente, quando si deve fare una modifica allo schermo viene chiamata la funzione editBuffer che, come spiegato nei commenti, scrive nello stack la modifica da fare; quando si finisce di modificare il buffer si chiama flush che si occupa di disegnare solo le modifiche fatte nello stack. Gran parte dello schermo quindi non viene quasi mai modificata. Però un approccio del genere darebbe seri problemi a gestire le collisioni del blocco che scende. Per il blocco in caduta ho usato un approccio un po' diverso: memorizzo la posizione del blocco, il suo id e la sua forma (in una matrice 4x4). Per disegnare questo blocco non uso il buffer ma una funzione indipendente. Questa funzione stampa semplicemente nello schermo il tetramino. Non è sufficiente stamparlo così come ci capita, bisogna anche fare delle considerazioni: non si devono stampare gli spazi, infatti, andrebbero a sostituire dei caratteri che non vanno modificati; per questioni di sicurezza non scrive nulla se nel carattere di destinazione c'è già qualcosa. Per questioni puramente estetiche ho aggiunto anche la possibilità di cambiare il colore di ciò che viene disegnato con questo metodo. Se si deve spostare il blocco (ad esempio un po' più in basso) è necessario cancellare il blocco attuale per poi ridisegnare quello nuovo. Per eseguire ciò ho scritto anche un'altra funzione che fa proprio questo, riceve in input un blocco e cancella dallo schermo i caratteri che nel blocco sono diversi dallo spazio. Gli spazi nel blocco potrebbero infatti non essere spazi nello schermo...

Sinteticamente questo è il funzionamento della grafica del gioco...

Passiamo ora all'analisi del main. L'inizializzazione del gioco è abbastanza semplice. Pulisce il buffer dello schermo e ci inserisce la board. Non sarebbe necessario cancellare il buffer perché viene comunque sostituito dal file letto. Non è garantito però che il file sia perfetto, quindi per sicurezza è meglio spendere qualche millisecondo in più... ;)

Ora che il gioco è pronto bisogna iniziare la partita: si crea un nuovo blocco per A e per B.

Inizia quindi il ciclo del gioco, il quale continua finché almeno un giocatore sta giocando. Il ciclo è strutturato per funzionare anche se un giocatore ha perso. Non spendo troppo tempo a spiegarlo qui dato che è commentato bene ed è abbastanza semplice.

Un altro passo fondamentale per capire questo programma è l'analisi del metodo che gestisce le collisioni. I commenti ci sono ma credo sia meglio spendere un paio di parole in più su ciò.

La funzione riceva da input due interi: dX e dY (delta-x e delta-y). Con ciò intendo lo spostamento che avrebbero i blocchi. Restituisce un valore che è zero se non ci sono collisioni, uno altrimenti. Per verificare ciò è necessario scorrere tutte le caselle del blocco. Nel codice questo è rappresentato da un ciclo for annidato in un altro. Viene quindi dichiarato un carattere (a) che rappresenta il carattere letto dal blocco ed un carattere (b) che rappresenta il corrispondente carattere del buffer dello schermo. Se il carattere del blocco e/o il carattere dello schermo sono spazi allora non c'è collisione. Infatti la collisizone avviene solo se entrambi i caratteri non sono degli spazi.

La gestione dell'input non è difficile da capire, fatta eccezione per il meccanismo di rotazione del blocco. Il metodo che ho usato non è forse il migliore ma il più semplice che mi è venuto in mente... per prima cosa salva il blocco attuale in una variabile di backup nel caso si dovesse ripristinare. Effettua la rotazione del blocco cambiano il suo id e il suo buffer. Ora controlla se nella nuova posizione avviene una collisione, se dovesse esserci allora ripristina il backup che aveva fatto, annullando quindi la modifica. Per lo spostamento a destra e a sinistra il funzionamento è più semplice: controlla la collisione si si spostasse di dX, sposta il blocco solo ne non si sovrapporrebbe a nulla.

Il prossimo passo è comprendere come funziona il metodo update. Non è difficile: se abbassando il blocco non c'è collisione allora è possibile farlo scendere. Se dovesse sovrapporsi allora il blocco è arrivato a fine corsa ed è necessario generarne un'altro. Il metodo update però ha anche un'altra funzione: quella di controllare se si ha riempito una riga e quindi di cancellarla. Per fare ciò controlla tutte le righe partendo dall'ultima e se ne trova una completa sposta tutto quello sopra di lui verso il basso di uno. E' necessario ripetere la verifica un'altra volta su questa riga dato che se non si facesse, il controllo verrebbe effettuato una riga sopra, la quale però è stata spostata verso il basso, quindi verrebbe saltata un'intera riga...

Per generare un nuovo blocco è necessario stampare nel model quello vecchio, per fare ciò ho usato lo stack del buffer dello schermo che avevo scritto. Scorre tutte le caselle del blocco e stampa nel buffer solo quelle diverse dallo spazio. Chiamando la funzione flush vengono rese definitive le modifiche. Per generare a caso il blocco ho usato la funzione rand per la x e per il tipo di blocco, per la y il valore è costante (4). Questo perché l'altezza di caduta dei blocchi è sempre la stessa. La chiave di questa funzione stà nell'eseguire il controllo di collisione: se nella posizione generato, il blocco generato dovesse collidere allora il gioco per quel giocatore finisce.

La funzione per la stampa dei punteggi è abbastanza semplice. Con degli if stabilisce quale giocatore stà vincendo ed imposta il colore del punteggio in base a ciò.

Per il comparto grafico vi do qualche cenno. Il file board.txt contiene lo schermo per tutta la durata del gioco. Viene infatti disegnata la board e le scritte in base a quel file.

Lo stack e le funzioni pop e push sono semplici e ben commentate e non richiedono particolare spiegazione. La funzione writeWithoutBuf e molte altre funzioni utilizzano gotoxy(int x, int y) la quale è definita in conio2.h. Questa libreria però non è presente in quelle del mio compilaotre quindi ho cercato una versione da mettere nel programma senza includere questo file. Come per setColor si basa su delle API della console di Windows, quindi non sono compatibili con altri sistemi operativi. Il programma l'ho testato sotto windows 7 e windows 8 a 64 bit. Compilato con il DevC++ versione 4.9.9.2 (portatile).

Normalmente uso la versione 5.4.0 di questo compilatore, ma per qualche strana ragione l'output con questa versione mi pesa quasi due megabyte mentre con quella precedente solo una ventina di kilobyte...

Download:

Screen:

Risolutore di equazioni

2012-05-30T19:39:00.001+02:00

Ho scritto un (assolutamente non) semplice programma che risolve equazioni fino al terzo grado sia in R che in C.

Come avevo già scritto tempo fa (parte in grigio in fondo) sto lavorando ad una libreria per creare giochi in XNA 4.0. Questa libreria curerà molto l'aspetto matematico della creazione di giochi e non solo, la parte più completa che ho prodotto è sicuramente quella riguardo le espressioni con le lettere. Questa libreria supporta i seguenti elementi matematici:

Lettere: variabile con relativo esponente (inutile o quasi da sola...) formato: "a^2"
Monomi: aggregati di lettere e un coefficiente. Formato: "-3a^2bc"
Polinomi: aggregati di monomi. Formato: "3a^2bc-5a+6bc"
Parentesi: classe per la gestione dei prodotti. Formate da un coefficiente, il contenuto della parentesi e l'esponente della parentesi. Formato: "5ab(7ab+3bc)^2"
Espressione: aggregato di valori*
Equazione: uguaglianza di due valori* (risoluzione fino al terzo grado)
(update) Disequazione: disuguaglianza di due valori* (primo grado sicuramente funzionante, altri gradi non è garantito...)

*Con valore intendo la classe astratta Valore da cui derivano tutti gli elementi precedenti (ad esclusione delle lettere e delle equazioni)

Inoltre la classe possiede un primo approccio alle frazioni. Se la stringa da convertire in un valore contenesse una scrittura di questo genere "[5/3]" verrebbe interpretata come 5 diviso 3 quindi 1.6666666...

Con le classi derivate da Valore (Monomio, Polinomio, Parentesi, Espressione) è possibile effettuare le operazioni normali come somma o differenza oppure prodotto... Non è possibile effettuare ancora la divisione di due polinomi....(devo ancora studiare la divisione di Ruffini....), invece le operazioni più comuni sono disponibili. Inoltre qualunque valore può essere trasformato in un Polinomio avviando la funzione Semplifica() che esegue i calcoli... E' possibile inoltre se si sta programmando un gioco avere un impatto grafico superiore utilizzando la funzione Draw(...) che disegna sullo schermo il valore (compresi esponenti e quant'altro).

Per coloro che non hanno le capacità tecniche di scriversi un programma per provare la libreria, ho scritto una semplice applicazione che risolve le equazioni (fino al terzo grado) sia nell'insieme R (numeri reali) che nell'insieme C (numeri complessi).

DOWNLOAD:

SCREEN:

VECCHIO:

Salve a tutti!!
In questo periodo sto lavorando ad una libreria (in realtà questa è solo una parte...) che serve ad aiutare a creare giochi in XNA. Questa parte della libreria si occupa di gestione di monomi e polinomi.
In questo momento non ho molto tempo di scrivere, quindi aggiornerò questa pagina tra qualche giorno... per ora ecco i sorgenti e la dll.

DOWNLOAD
DLL
Source

HowSecureIsYourPassword?

2012-04-20T18:02:00.002+02:00

Con questo semplice programma è possibile scoprire quanto tempo è necessario ad un hacker per scoprire la vostra password.
Un'oretta di tempo per programmare una semplice applicazione praticamente inutile...
Online esistono servizi che calcolano il tempo necessario a trovare una password tramite un BruteForceAttack come ad esempio l'ottimo howsecureismypassword.net, il mio programma è una semplice versione per Windows.
Il Brute Force o attacco a forza bruta è un metodo con il quale trovare una password. Il BF funziona provando tutte le combinazioni di caratteri del charset (caratteri consentiti). Ovviamente da più tipi di caratteri è composta la password più questa sarà robusta. Per questioni di semplicità ho sintetizzato il charset in questo modo:
- 26 caratteri minuscoli (obbligatori)
- 26 caratteri maiuscoli
- 10 cifre
- 170 simboli e caratteri speciali
Se la password contiene almeno un carattere maiuscolo, un numero oppure un simbolo il charset conterrà l'intera categoria di appartenenza.
Il primo obbiettivo del programma è calcolare la lunghezza del charset. Tramite questa informazione è possibile risalire al numero totale di combinazioni. Per fare ciò bisogna applicare la seguente formula

charset è la lunghezza del charset, lenght è la lunghezza della password.
I numeri risultanti da questa operazione sono enormi, per gestirli un long non basterebbe. Mi sono appoggiato a BigInteger (System.Numerics). Un tipo di intero che non ha limite di dimensione.
Ok, si hanno tutte le password possibili, non resta che dividere per il numero di password al secondo per ottenere quanto tempo è necessario. Il risultato sarà ovviamente in secondi... Per dare un piccolo tocco grafico ho scritto una funzione che converte i secondi in minuti, ore, giorni, mesi, anni ecc..
Il codice è semplicissimo, gli unici commenti che ho inserito sono quelli per i codici ASCII dei simboli che potrebbero non essere immediati...

Download:

Screen:

Numeri primi

2012-04-10T17:47:00.002+02:00

Ecco un'altro programma in stile benchmark. Effettua alcuni calcoli e mostra a linea di comando i numeri primi minore di un numero in input.

Questo programma l'ho scritto perché dovevo fare pratica con un sistema multi-thread. In input questo programma chiede quanti thread utilizzare e un limite massimo da non superare.
Credo si meglio fare delle piccole precisazioni riguardo i numeri primi. Un numero primo è un numero che si può dividere interamente solo per 1 e per se stesso. Ne deriva che l'unico numero primo pari è 2. Si può anche dimostrare che se un numero ha dei fattori almeno uno di questi è minore o uguale alla radice del numero.
Con queste considerazioni si può scrivere il programma. Il linguaggio che ho utilizzato è il C# dato che ha delle utili funzioni che permettono semplicemente la manipolazione dei thread. Ogni funzione eseguita da un thread ha un parametro, il numero da cui iniziare. Questo serve per evitare che i thread facciano più volte lo stesso lavoro dato che possiedono lo stesso incremento non si sovrapporranno mai.
Per verificare la primitività del numero ogni thread chiama una funzione che calcola il resto della divisione del numero per tutti i numeri dispari (escluso 1) minori o uguali della radice del numero, se dovesse risultare resto 0 allora il numero non è primo.
Inoltre salva il risultato nel file "file.txt" nel caso si dovessero fare dei calcoli a parte.
Appena ha finito di eseguire i calcoli mostra il tempo impiegato ad eseguirli, la precisione è forse eccessiva (decimi di microsecondo...)
Nel programma ho anche inserito una funzione che effettua la scomposizione di un numero in fattori primi. Accetta numeri anche abbastanza grandi, la dimensione di un long.

DOWNLOAD:

SCREEN:

AnoniMail

2012-04-10T17:19:00.001+02:00

Ho scritto un programma che permette di inviare delle email tramite SMTP.
Il vantaggio (?) di questo programma è quello di poter inviare email anche con un indirizzo di posta inventato o non esistente anche senza avere la password. Questo perché si basa sulla tecnologia SMTP, la quale non richiede un login. Il funzionamento del programma è veramente banale dato che il .Net Framework integra delle funzioni apposite.
Il cuore del programma è la variabile di tipo SmtpClient. Questa variabile fa appunto da tramite tra il server SMTP e il computer. Il primo passo da fare è impostare l'host del server, per fare ciò basta assegnare un valore alla proprietà smtp.Host. Si può anche abilitare la crittografia SSL (facoltativo). Il passo successivo è creare il messaggio email da inviare. Per fare ciò serve un oggetto di tipo MailMessage inizializzato così:

MailMessage message = new MailMessage(mittente, destinatario);
message.Subject = oggetto;
message.Body = corpo;

Si può anche aggiungere qualche allegato al messaggio con la funzione

message.Attachments.Add(new Attachment(path));

path è il percorso del file da allegare.

Per inviare il messaggio ci sono due metodi: quello classico con smtp.Send(message) oppure uno asincrono. Io ho utilizzato il secondo per il semplice motivo che non blocca il programma durante l'invio del messaggio. Infatti l'invio viene eseguito in un thread separato da quello principale, in questo modo se si preme sul pulsante annulla viene bloccato il thread secondario e si può fermare l'invio del messaggio. Appena viene inviato il messaggio verrà chiamato l'evento smtp.SendCompleted, il quale ho intercettato all'inizio del programma. Appena il messaggio viene inviato verrà mostrato un messaggio di riuscito inoltro.

DOWNLOAD:

SCREEN:

100

2012-04-09T20:25:00.001+02:00

Chi ha mai giocato a "100"? Quel gioco dove rispettando delle regole si deve riempire la tabella di numeri progressivi.

Il nome originale non lo conosco, io l'ho chiamato 100 perché è una tabella 10x10 e quindi ci sono 100 caselle...
Le regole del gioco sono molto semplici. L'obiettivo del gioco è appunto riempire la tabella di numeri. Per farlo bisogna rispettare queste regole:
- Si può iniziare da una casella qualsiasi
- La casella successiva deve essere distante 3 caselle in orizzontale o verticale oppure 2 caselle in diagonale
Ricordarsi queste regole non è necessario dato che il programma vi aiuta a scegliere tra le caselle selezionabili da quelle non selezionabili. E' infatti possibile premere solo le caselle che appaiono di colore verde cioè quelle che rispettano le regole. Il gioco termina quando non ci sono più caselle selezionabili oppure appena si completa la tabella. Ovviamente meno tempo ci si impiega a finire meglio è!
Ho inserito anche la funzione undo che permette di tornare indietro se si commettono degli errori.

Il funzionamento è abbastanza semplice. Ovviamente non ho creato 100 Button, o preferito usare una funzione (Initialize) che mi crea una matrice di pulsanti automaticamente all'avvio del gioco. Questi pulsanti sono accessibili tramite la proprietà Controls del Form. Quando vengono premuti chiamano tutti lo stesso metodo che ricava la posizione del button tramite le sue coordinate. E' così possibile operare sulla matrice 10x10 di caselle che rappresenta lo stato del gioco.
Per la funzione undo ho usato un approccio facile ma dispendioso. Ogni volta che viene premuta una casella salva lo stato della board in una lista. Se viene premuto UNDO ripristina lo stato salvato e lo cancella dalla lista.

DOWNLOAD:

SCREEN:

Parametri in MODBUS

2012-01-10T17:04:00.002+01:00

Un giorno mi serviva inviare ad un dispositivo bluetooth delle stringhe in Modbus ASCII Allora mi sono messo a scrivere un'interfaccia grafica che mi facilitasse il compito...
Il dispositivo che avevo costruito era un "semplice" termometro sonda con molte funzioni. Si interfacciava con alcune (mi sembra 4) termometri e con diversi relè che permettevano di controllare il sistema di riscaldamento/raffreddamento di qualsiasi cosa. A questo dispositivo avevo connesso un'interfaccia seriale Bluetooth. Tramite questa porta seriale era possibile configurare ed utilizzare questo dispositivo. Ad esempio inviando una certa stringa nella porta COM esatta era possibile ricevere come risposta la temperatura della prima sonda. Era anche possibile configurare il comportamento nel caso in cui la temperatura superasse certe soglie ad esempio accendendo una ventola.
Non tratterò la codifica dei messaggi perché è per voi totalmente inutile dato che codifica dei dati in input (decimali) e li formatta in esadecimale e calcola i relativi checksum per inviare al dispositivo una stringa corretta.
Più interessante è invece il sistema di invio/ricezione tramite una porta COM seriale. In questo caso si tratta di una Bluetooth ma il funzionamento è assolutamente identico ad una porta cablata (dato che il dispositivo bluetooth crea una connessione seriale standard).
Il primo passo necessario per fare tutto ciò è creare un oggetto di tipo SerialPort. Questa classe gestisce la comunicazione attraverso una porta seriale e tutte le funzioni che ne derivano.
Appena si ha creato una porta seriale è necessario configurare le impostazioni di base. Tali impostazioni sono :
- PortName (la porta COM)
- BaudRate (la velocità della porta in baud)
- DataBits (la lunghezza standard di bit in ogni byte di dati)
- StopBits (il numero di bit di stop per ogni byte)
- Parity (il protocollo di controllo della parità)
- ReadTimeout (il timeout in lettura)
- WriteTimeout (il timeout in scrittura)

Bene ora che la nostra porta è configurata bisogna aprirla. Basta chiamare

portaSeriale.Open();

Ok, la connessione è stata aperta, ora è possibile leggere e scrivere attraverso questa porta.
Per scrivere del testo basta eseguire un

text è la stringa di caratteri ASCII da inviare. E' bene ricordare che nella maggior parte dei casi per funzionare text deve terminare con CRLF (Carriage Return e Line Feed). Per inserire questi codici basta modificare text così:

text + "\r\n"

Il sistema di lettura è anch'esso molto semplice. Chiamando la funzione

msgTextRx = portaSeriale.ReadExisting();

Si assegna a msgTextRx il contenuto del buffer di lettura della porta seriale.
Basta per quanto riguarda l'apparato di invio/ricezione seriale è tutto.

Tutto ciò però è abbastanza scomodo da usare: bisognerebbe premere ogni volta "Calcola e invia" per leggere la temperatura. Allora ho pensato di aggiungere una funzione molto interessante: Esegue un loop e ogni n secondi esegue la lettura della temperatura e la scrive in un file Excel (o un altro formato). Il vantaggio di questo metodo è quello di avere un file Excel con i valori delle temperature, diventa quindi semplicissimo creare un grafico che rappresenta l'andamento termico delle sonde.
Per creare, modificare e salvare un file in formato Excel mi sono appoggiato alla libreria GemBoxSpreadsheet. Tramite questa libreria si può accedere ad una tabella tramite le coordinate delle celle, rendendo la modifica dei valori una vera sciocchezza. Il primo passo da compiere è dichiarare un'oggetto di tipo ExcelFile, il quale conterrà il nostro file. Poi bisogna creare un foglio di lavoro per farlo bisogna chiamare:

excelFile.Worksheets.Add("Data");

Verrà quindi creato un foglio di nome "Data". In questo foglio ho aggiunto la prima linea che contiene le intestazioni delle colonne:

excelFile.Worksheets.ActiveWorksheet.Cells["A1"].Value = "Ora";
excelFile.Worksheets.ActiveWorksheet.Cells["B1"].Value = "Indirizzo";
excelFile.Worksheets.ActiveWorksheet.Cells["C1"].Value = "Funzione";
excelFile.Worksheets.ActiveWorksheet.Cells["D1"].Value = "Valore";
excelFile.Worksheets.ActiveWorksheet.Cells["E1"].Value = "Data";

Sulle celle identificate da A1, B1, C1... sono stati scritti i valori corrispondenti. In ogni riga sotto verranno inserite le informazioni relative ai dati letti:

excelFile.Worksheets.ActiveWorksheet.Cells["A" + i.ToString()].Value = ora;
excelFile.Worksheets.ActiveWorksheet.Cells["B" + i.ToString()].Value = indirizzo;
excelFile.Worksheets.ActiveWorksheet.Cells["C" + i.ToString()].Value = funzione;
excelFile.Worksheets.ActiveWorksheet.Cells["D" + i.ToString()].Value = valore;
excelFile.Worksheets.ActiveWorksheet.Cells["E" + i.ToString()].Value = data;

Incrementando i si andrà a scrivere una riga sotto.
Non resta altro che salvare il file. I formati supportati sono Csv, Html, Ods, Xls, Xlsx. Per salvare in un file Excel 2010 (o 2007) basta chiamare:

excelFile.SaveXlsx("file.xlsx");

Tutto qua, questa libreria è davvero utile e semplice da usare. Nel mio programma la ho usata per salvare il file in tutti i formati supportati, basta scegliere dal menu opzioni quello desiderato. Le opzioni vengono salvate in un file ini. Per leggere e scrivere in questo file mi sono basto sulla libreria kernel32 di windows. Il file di impostazioni è salvato in "D:/settings.ini".

DOWNLOAD:

SCREEN:

Fibonacci

2012-01-09T20:59:00.002+01:00

Siete curiosi di sapere la sequenza di Fibonacci fino al 10000 elemento?

Ho scritto un semplice programma che calcola e trova i primi 10000 numeri della sequenza di Fibonacci. La sequenza di Fibonacci è una successione di numeri tali che:
- Il primo elemento è 0
- Il secondo è 1
- I successivi sono la somma dei due che li precedono
La sequenza inizia quindi così: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34...
Questa sequenza apparentemente banale ed inutile nascone alcune importati proprietà nascoste. Una delle quali è lo stretto legame con il numero d'oro (sezione aurea: 1.6180339...). Spiegarle tutte sarebbe un lavoro eterno ed inutile dato che sono dettagliatamente trattate su Wikipedia a questo indirizzo. Una delle proprietà più interessanti è quella che riguarda la sezione aurea. In questa successione il rapporto tra due elementi consecutivi della successione si avvicina sempre di più a questa costante.

Ovviamente un semplice intero o anche un long non può contenere dei numeri così grandi (stiamo parlando di oltre duemila cifre all'elemento 10000). Per risolvere questo problema mi sono affidato ad un tipo di intero diverso: il BigInteger (presente in System.Numerics)
Questo tipo di numero non ho un limite per la sua grandezza, l'unico limite è la memoria di sistema!
Bene ora è tutto più semplice, basta iterare la funzione che calcola il numero sommando i due precedenti ed il gioco è fatto!

Non credo sia necessario commentare il codice vista la sua semplicità (anche se devo ammettere che l'ho scritto parecchio male....). Nel codice è presente un solo commento. Se togliete il commento animerete la ListBox che focalizzerà sempre l'ultimo numero della sequenza senza bloccarsi. Quando finisce di calcolare la sequenza il programma vi mostrerà un messaggio che vi dice quanto tempo ci ha messo (molto preciso...) e quante cifre ha l'ultimo termine della sequenza.
A chi interessasse questo software può essere usato come benchmark ritoccando ed ottimizzando il codice. Per il calcolo del tempo impiegato ho usato una classe che è precisa al decimo di microsecondo... Forse un po' troppo...
Il mio computer ha un Intel Core i5 2500K da 3.3GHz e per eseguire questo calcolo impiega 22.5669408 secondi.

DOWNLOAD

SCREEN:

Jumping Jump

2012-01-09T20:27:00.000+01:00

Ecco a voi uno dei miei più grandi progetti. Si tratta di un clone del gioco DoodleJump. E' stato programmato in XNA 4.0 e C#.

Per chi avesse visto il post nella vecchia versione (che lascio disponibile a questo indirizzo) ecco un changelog:
- Supporto al mouse
- Salvataggio della classifica e delle statistiche di gioco
- Implementate quelle che chiamavo tabelle (le spiego più giù...)
- Aggiornata la funzione che fa rimbalzare il doodle
- Migliorata la grafica e la "schermata" iniziale
- Aggiunti i nemici
- Aggiunti gli oggetti bonus
- Aggiunti vari tipi di piattaforme
- Aggiunto file di configurazione
- Aggiunto menu di pausa
- Rewrite completo del codice e rimosse le inutili librerie che avevo messo per separare le funzioni
- E forse altro ancora...

Ok come ho già detto si tratta di un gioco clone di DoodleJump sulla piattaforma PC. Non avendo trovato questo gioco per computer ho pensato di iniziare a programmarlo io...
Per creare JumpingJump ho utilizzato:
- Microsoft Visual Studio 2010 Express
- Microsoft XNA 4.0
- Programmi di grafica (Paint.net e altri...)
- Mia cugina (grazie Anna!)
- Tanta pazienza e voglia di pensare ed impegnarsi (e di sbattere la testa sulle funzioni matematiche....)

Bene, chi non avesse mai giocato a DoodleJump l'obbiettivo è quello di raggiungere un punto più alto possibile. Per farlo bisogna spostare il personaggio a destra e a sinistra per farlo saltare su delle piattaforme sempre più rare e difficili da raggiungere. Come se non bastasse ci sono anche dei mostri alieni che ostacolano il percorso, bisogna ucciderli per non rischiare di morire... fortunatamente il nostro doodle spara delle micidiali palline di gomma (lo so, ho una grande fantasia.... xD ). Ci sono vari tipi di nemici, da quelli più semplici, per cui basta un proiettile, a quelli più impegnativi, ai quali ne servono di più. Ad ulteriore difficoltà i blocchi non sono tutti uguali. Ci sono vari tipi di blocchi: quelli solidi, dove ci si può saltare quanto si vuole, quelli meno solidi, ci si può saltare solo un numero limitato di volte, quelli falsi, sui quali è inutile provare a saltare, quelli che si spostano orizzontalmente e verticalmente, e quelli fragili, ci si può saltare solo una volta.
La grafica non è ai livelli dell'originale, ma rimane comunque interessante, tutto merito del team grafico (io e mia cugina...). Ci sono anche dei bonus che si possono incontrare durante il gioco: un cappellino che ti permette di volare per brevi tratti, un piccolo jetpack che ti fa risalire in fretta, una molla che ti fa compiere un balzo verso l'alto, ed infine un mega razzo, con il quale puoi percorrere molta più strada...

Dopo questa spiegazione teorica passiamo ai fatti: come funziona?
Ovviamente se spiegassi passo per passo tutto il funzionamento diventeremmo tutti vecchi, parlerò quindi delle strategie più interessanti e delle funzioni clou.
Il primo problema che mi si è presentato quando ho iniziato a programmare la prima versione di questo gioco è stato quello di far saltare il nostro doodle. Mi serviva una funzione matematica che mi facesse muovere fluidamente e come volevo il personaggio. Quello che mi interessava era farlo salire partendo da una certa velocità fino ad una certa altezza, farlo poi scendere con velocità sempre maggiore. Quando ho programmato questa funzione ero ancora in prima superiore e non conoscevo bene le parabole e le loro applicazioni, quindi il metodo che ho usato è abbastanza sbagliato. Vabbè. Allora, ho diviso il movimento in due parti. La prima è la salita, la seconda la discesa. Per salire avevo usato un pezzo della funzione seno (in realtà coseno...). Precisamente un quarto di quella funzione, quella di risalita. Ripensandoci era meglio usare anche qui una parabola... Ok, non è difficile adesso, arrivarci alcuni anni fa invece lo è stato un po' di più. Per la discesa non potevo usare ancora il seno, se lo avessi usato avrei ottenuto un movimento fluido ma che si sarebbe fermato in caduta per poi risalire e continuare ciclicamente. Allora ho dovuto cambiare funzione. Per la discesa ho utilizzato la funzione della parabola. Il suo funzionamento è abbastanza ovvio e non mi dilungherò. Per quanto riguarda i salti penso che basti così, non c'è molto altro da dire.
Un altro grande problema che dovevo risolvere era quello di evitare che il player possa uscire dalla parte superiore dello schermo. Per fare ciò mi sono messo a giocare a DoodleJump e ho cercato di capire come i creatori possano aver risolto questo grande problema. Devo dire che hanno avuto un'idea veramente geniale. Ci ho messo un po' a capirla dato che è stata realizzata veramente benissimo. Il concetto è semplice, far salire il giocatore, se non c'è spazio allora facciamo scendere il resto... Quando l'ho capito sono rimasto veramente stupefatto, è assolutamente un'idea geniale... Applicare questa soluzione è stato abbastanza facile. Appena il giocatore arriva ad una quota limite il suo spostamento viene reindirizzato al mondo che lo circonda con segno opposto. Il risultato è un'illusione ottica veramente ottima.
Il problema più grande che affliggeva la versione precedente era quello delle piattaforme che si sovrapponevano e che si mettevano come gli pareva... Per risolvere ho dovuto adottare una strtegia un po' scomoda. Dentro la cartella Content/Data/Posizioni ci sono dei file in formato pck che contengono delle informazioni riguardo le piattaforme e i nemici. Se ci fossero molti di questi file il le posizioni delle piattaforme apparirebbero come generate a caso dato che non sarebbero facilmente distinguibili. Per generare questi file è necessario un altro programma che ho scritto, si tratta di "JumpingJump Piattaforme". Questo editor si aggancia all'eseguibile del gioco per creare e visualizzare i livelli. Forse il programma non è proprio intuitivo e forse non funziona troppo bene, ma il grande del suo lavoro la fa bene (si spera...). Devo ancora ringraziare mia cugina che mi ha dato una mano a creare un po di file di piattaforme... Se vi dovesse interessare come sono strutturati i file pck non vi preoccupate, il funzionamento è banale. In realtà sono file zip che contengono un file omonimo in un formato diverso. Il file decompresso è un XML generato da JumpingJump Piattaorme... Li ho compressi per due ragioni: risparmiare spazio (falso! hanno un peso irrisorio!) e per avere dei file impacchettati e difficilmente modificabili...
Ho scritto anche un altro programmino per i devloper di questo gioco, si chiama JumpingJumpIniEditor, è solo un editor che permette di editare il file settings.ini con un GUI... praticamente inutile ma utile (xD)
Per gli appassionati del cheating ho inserito anche un file (GodMode.bat) che permette di avviare il gioco in modalità immortale (easteregg anche qua...). Praticamente quando si cade sotto il limite inferiore non si perde ma si viene teletrasportati più in alto. Ha solo un misero e insignificante problema... quando si avvia questa modalità non carica le posizioni dei blocchi e quindi è totalmente inutile.... xD

Mi sembra di aver detto tutto quello che era importante sapere, ovviamente vi do anche l'intero codice sorgente. I commenti non sono completi, tutte le funzioni ed i campi pubblici hanno un commento che ne descrive la funzione.
Ah si la cosa più importante... 8300 righe di codice!!!! xD xD

DOWNLOAD:

SCREEN:

Schermata principale

In gioco

Nel menu della classifica

Nel menu delle statistiche

AudioTest

2012-01-09T19:49:00.003+01:00

Un altro progetto banale... Oggi vi presento come aggiungere dell'audio di sottofondo (e non solo) nei vostri giochi XNA.
Ok, forse per molti di voi tutto quello che sto per dire è inutile, io però ci ho perso un po' per capire come aggiungere dell'audio in sottofondo. Quindi non fa male a nessuno se condivido i risultati delle mie ricerche.
Per scrivere questo "gioco" ho utilizzato:
- Microsoft Visual C# 2010 Express
- Microsoft XNA Framework 4.0

Allora, per iniziare, è necessario aggiungere un riferimento:

using Microsoft.Xna.Framework.Audio;

Bene, fatto ciò bisogna creare una variabile di tipo SoundEffect. Questa variabile conterrà la nostra canzone che verrà riprodotto quando daremo il Play.

SoundEffect sound;

E' il momento di compilare la nostra canzone aggiungendo il file wav nel progetto content. Mi sembra che il file debba essere un PCM wave, ma non vorrei dire una castroneria, prendete questa affermazione con le pinze...
Il passo successivo è caricare la canzone nel gioco. Per fare ciò bisogna aggiungere nel LoadContent l'istruzione che carica il file "Sonoro" (il nome del file audio)

sound = Content.Load<SoundEffect>("Sonoro");

Poi bisogna avviare la riproduzione della canzone con il comando:

sound.Play();

Ho anche scritto questo programmino se qualcuno volesse sperimentarlo...

DOWNLOAD:

Fisica

2011-12-21T15:16:00.000+01:00

Un programmino che effettua alcuni semplicissimi calcoli fisici come il peso o la forza d'attrito. Inutile dal punto di vista pratico ma interessante per iniziare a programmare.
Questo programma è stato sviluppato soprattutto per i ragazzi delle scuole superiori che hanno problemi con i compiti di fisica... (o di informatica?)
Ho sviluppato un piccolo programmino in C++ che vi aiuta a CONTROLLARE (e non a svolgere) gli esercizi di fisica. Attualmente lo sto facendo per divertimento e per sperimentare le funzioni di seno e coseno in C++...
Il programma è di una banalità assurda, lo ho fatto anche per ripassare la lezione di fisica di ieri e per poter controllare se eseguivo correttamente i calcoli.
Passiamo al dunque, il programma alla versione attuale permette solo di applicare 2 formule fisiche. La prima trasforma la massa in input in peso, con gravità predefinita (9.81 m/s^2) oppure con una gravità a piacere.
Questa prima parte del programma la ho scritta in 10 minuti scarsi per dedicarmi al lavoro sulla seconda: calcolare la forza che bisogna applicare ad un corpo per non farlo scivolare da un piano inclinato. Nel programma questa forza la ho chiamata forse impropriamente attrito, perché era il vicino termine che mi veniva in mente.
Ho utilizzato molto più tempo per lavorare su questa funzione, infatti è "molto" più complessa ed elaborata. Inizialmente il programma chiede di inserire il peso (oppure la massa selezionando l'apposita funzione), poi si devi indicare l'inclinazione del piano. Questo è possibile farlo inserendo: l'ampiezza in gradi, l'ampiezza in radianti, oppure la lunghezza del piano e il relativo dislivello.
Basta, tutto qui. In circa 30-60 minuti ho finito questo programma che a molti più essere utile per ripassare fisica.
Il link al file rar contiene anche il file sorgente main.cpp
Chiunque essendo un progettino banale è libero di effettuare modifiche al codice senza problemi.. ;)

CIAO E SPERO CHE VI SIA UTILE!!

DOWNLOAD:

SCREEN:

Computers Invaders

2011-12-15T19:35:00.001+01:00

Primo gioco in XNA!!!
Salve gente, questo è il primo progetto che pubblico sull'XNA framework. Si tratta di un giochino in stile space invaders...
Software utilizzato:
- Microsoft Visual C# 2010 Express
- Microsoft XNA Framework 4.0
- Software di disegno per le immagini (paint, gimp, ....)

Per chi non lo sapesse, XNA sono delle librerie Microsoft per i programmatori di videogiochi. Sono state sviluppate in diverse versioni, XNA 3.0 è quella più ampiamente argomentata nel web, si utilizza con vecchie versioni di Visual Studio che non sono molto diverse dall'ultima disponibile, ma io preferisco tenermi aggiornato, quindi io userò le librerie XNA aggiornate all'ultima versione disponibile, la 4.0 installate all'interno di Visual Studio 2010. Tutto il software che ho utilizzato è gratuito, quindi spesa per programmare anche giochi di successo uguale zero.

Arriviamo subito al dunque. Computers Invaders è un piccolo progetto che ho intrapreso qualche mese fa per scopo autodidattico (ehh sì, mi sarebbe piaciuto programmare videogiochi). Ora non ci lavoro più perchè stò lavorando su un altro progetto che presto pubblicherò. Beh comunque, tutti avrete già sicuramente sentito parlare di Space Invaders quel vecchissimo gioco dove tu devi evitare dei blocchi (solitamente asteroidi) che scendevano dalla parte superiore dello schermo. Praticamente è il suo clone in una versione completamente programmata e disegnata da me.

Ci avrò messo un paio di settimante in tutto tra disegni e codice. Solitamente sono abbastanza disordinato nel codice, molto raramente metto i commenti, quindi eviterò di pubblicare i file sorgente per non complicare la vita dei più inesperti. Ma se proprio siete curiosi, siete dei temerari e non vi interessa il mio disordine, fatemi una richiesta (con un commento sotto) e vedrò di pubblicare anche i file del codice.

Perchè Computers Invaders? Forse qualcuno di voi si sarà fatto questa domanda e anche provando il gioco non avrà trovato una risposta. Molto semplice, perchè quando ho iniziato a programmare ho preferito (essendo da solo) partire direttamente con il codice, e guarda che ironia, la prima cosa che ti chiede Visual Studio è di inserire il nome dell'applicazione, io non volendo perdere del tempo a disegnare tutte le immagini che ci sono, ho fatto riferimento a delle immagini che avevo già. Queste immagini erano proprio immagini di piccoli computer che mi sembravano perfetti per cominciare. E quindi è questo il motivo del nome....

DOWNLOAD:

Ovviamente per funzionare si deve avere installato il .Net Framework 4 e XNA Framework 4.0

Se avete domante, fatele!!

SCREEN:

Un, due, tre, prova

2011-12-14T18:42:00.000+01:00

:)
Primo post di prova...