(1)Introduzione agli ARRAY – Tressette, Briscola, Poker - Prof

(1)

Introduzione agli ARRAY – Tressette, Briscola, Poker - Prof. Claudio Maccherani - Perugia - 2005 / 2006 Pag. 1 a.s. 2005 / 2006

ARRAY 1 TRESSETTE 2 BRISCOLA 4 POKER 6

ARRAY

Una VARIABILE SEMPLICE è una “scatola” che può contenere un oggetto alla volta. La variabile è caratterizzata dal proprio nome (che la identifica univocamente), dal tipo di dato che può contenere e dalla lunghezza (numero di byte che occupa in memoria centrale).

A

Un ARRAY è una VARIABILE STRUTTURATA caratterizzata dal proprio nome, dal tipo di dato di ogni suo elemento, dal numero di dimensioni (o indici), dal dominio di ogni indice. Ogni elemento dell’array viene individuato specificando il nome dell’array e, tra parentesi, le coordinate di ciascun indice. Il VETTORE è un array a una dimensione, la MATRICE è un array a due dimensioni.

VETTORE MATRICE

V M ¹ ² ³

1 345 ¹ ITA STO ITA

2 8200 ² MAT ING ITA

3 55 ³ INF INF MAT

4 33 ⁴ RAG INF RAG

5 120 ⁵ TEC EDF TEC

ARRAY a 3 DIMENSIONI

V(2) individua l’elemento di indice 2 il cui valore è 8200.

M(4,2) individua l’elemento di riga 4 e colonna 2 il cui valore è "INF".

Se l’array ha tre dimensioni si specifica prima la riga, poi la colonna ed infine la profondità.

In generale, per array a n dimensioni, si specifica, nell’ordine, la coordinata di ciascuna dimensione.

358

(2)

Introduzione agli ARRAY – Tressette, Briscola, Poker - Prof. Claudio Maccherani - Perugia - 2005 / 2006 Pag. 2 Esempio 1:

TRESSETTE

Per comprendere l’utilità "informatica" degli array immaginiamo di voler realizzare un programma Visual Basic che giochi a TRESSETTE, limitandoci alla sola distribuzione delle carte e alla verifica dell’eventuale accuso.

Il tressette è un gioco di carte che si fa in quattro giocatori, suddivisi in due squadre contrapposte, utilizzando le 40 carte "napoletane" o "piacentine". Si distribuiscono 10 carte per ogni giocatore e, dopo aver verificato se i giocatori accusano, si inizia la mano.

Le carte interessate all’accuso sono gli Assi, i Due e i Tre. Si accu sa solo se si hanno tre o quattro Assi (rispettivamente tre e quattro punti), tre o quattro Due e tre o quattro Tre. Si accusano inoltre tre punti per ogni eventuale "napoletana", costituita da Asse, Due e Tre dello stesso seme.

GC

0 0 0 0

MAZZO 0 0 0 0 0 CARTA

1 2 3 4 0 0 0 0 0 0 1 Asse ¹ 0 1 1 0 ¹ 1 0 0 1 0 0 0 2 Due ² 1 1 1 0 ² 0 0 0 1 0 0 0 3 Tre ³ 0 1 1 1 ³ 1 0 0 0 0 0 0 4 Quattro ⁴ 0 1 1 1 ⁴ 1 0 0 0 0 0 0 5 Cinque ⁵ 1 1 1 1 ⁵ 0 0 0 0 0 0 0

6 Sei ⁶ 1 0 1 1 ⁶ 0 1 0 0 0 0 0 GIOCATORE 7 Sette ⁷ 1 1 0 1 ⁷ 0 0 1 0 0 0 0 ⁴ Anna ⁴ 8 Fante ⁸ 1 1 1 0 ⁸ 0 0 0 1 0 0 ³ Claudio ³ 9 Cavallo ⁹ 0 1 1 1 ⁹ 1 0 0 0 0 ² Mario ² 10 Re ¹⁰ 0 1 1 1 ¹⁰ 1 0 0 0 ¹ Vera ¹

¹ ² ³ ⁴

Spadi Coppe Denari Bastoni

1 2 3 4 SEME

(3)

Introduzione agli ARRAY – Tressette, Briscola, Poker - Prof. Claudio Maccherani - Perugia - 2005 / 2006 Pag. 3 Per simulare il mazzo si può utilizzare una matrice numerica MAZZO di 10 righe, tante quante sono le carte, da 1 (asse) a 10 (re), e 4 colonne, una per ciascuno dei quattro semi. Ogni elemento di questa matrice può assumere il valore 1 - carta presente - o il valore 0 - carta non più nel mazzo.

Per i nomi delle carte e dei semi possiamo utilizzare il vettore stringa CARTA di 10 elementi (contenente i nomi delle carte) ed il vettore stringa SEME di 4 elementi (con i nomi dei semi).

Per i giocatori si utilizza il vettore stringa GIOCATORE di 4 elementi, contenente i nomi dei giocatori.

Per simulare le carte ricevute da ciascun giocatore possiamo utilizzare l’array a tre dimensi oni CG (carte giocatori) di 10 righe, tante quante sono le carte, da 1 (asse) a 10 (re), 4 colonne, una per ciascuno dei quattro semi e 4 livelli di profondità, uno per ciascun giocatore. Ogni elemento di questo array può assumere il valore 1 - carta in possesso del giocatore - o il valore 0 - carta non in possesso del giocatore.

Per la distribuzione casuale delle carte si utilizza l’istruzione RANDOMIZE TIMER e la funzione RND, opportunamente "lavorata", per estrarre casualmente la carta (da 1 a 10) ed il seme (da 1 a 4).

Per distribuire effettivamente la carta occorre verificare che sia ancora presente nel MAZZO, cioè che il relativo elemento valga 1. La distribuzione consisterà nel porre a 0 l’elemento della matrice MAZZO associato alla carta e a 1 l’e lemento dell’array CG associato al giocatore.

Per visualizzare le carte ricevute da ciascun giocatore si può utilizzare una cosiddetta "matrice" di controlli di tipo list box [lstG] di quattro elementi – proprietà index da 1 a 4, una per ciascun giocatore. Tale list box sarà riempita in base alle carte del giocatore – array CG – "ricostruendo" opportunamente la dicitura completa con l’ausilio dei vettori CARTA e SEME.

Se si volessero utilizzare le carte "vere", queste potrebbero essere memorizzate in una matrice di controlli di tipo image [imgCarta], di 40 elementi, tanti quante le carte, utilizzando opportunamente la proprietà index

(Spadi nei primi 10 elementi, poi Coppe, poi Denari ed infine Bastoni) e quindi assegnate ai giocatori al momento della distribuzione. Per questo occorre prevedere un’altra matrice di controlli di tipo image [imgGio], di 40 elementi, tanti quante le carte distribuite ai giocatori, utilizzando opportunamente la proprietà index (i primi 10 elementi rappresenteranno le carte del primo giocatore, da’’11° al 20° elemento le carte del secondo giocatore, e così di seguito).

(4)

BRISCOLA

Restando in un ambito “ludico-informatico" dell’applicazione degli array, vediamo come si potrebbe realizzare un programma Visual Basic che giochi a BRISCOLA, una partita a due, tra un giocatore e il computer.

La briscola è un gioco di carte che si fa in quattro giocatori, suddivisi in due squadre contrapposte, utilizzando le 40 carte "napoletane" o "piacentine", ma che si può giocare anche in due. Si distribuiscono 3 carte per ogni giocatore e, dopo aver scoperto la briscola, si inizia il gioco. Non è obbligatorio rispondere.

Le carte che contano sono Assi (11 punti), Tre (10 punti), Re (4 punti), Cavallo (3 punti) e Fante (2 punti).

CARTA MAZZO MAZZOC MAZZOG 1 2 3 4 1 2 3 4 1 2 3 4 1 Asse ¹ 0 1 0 0 ¹ 1 0 0 1 ¹ 0 0 1 0 2 Due ² 0 0 1 0 ² 0 0 0 1 ² 1 1 0 0 3 Tre ³ 0 0 1 0 ³ 1 0 0 0 ³ 0 0 0 0 4 Quattro ⁴ 0 1 0 1 ⁴ 1 0 0 0 ⁴ 0 0 0 0 5 Cinque ⁵ 1 0 0 1 ⁵ 0 0 0 0 ⁵ 0 1 1 0 6 Sei ⁶ 1 0 0 0 ⁶ 0 1 0 0 ⁶ 0 0 1 1 7 Sette ⁷ 0 0 0 1 ⁷ 0 0 1 0 ⁷ 0 0 0 ⁰ 8 Fante ⁸ 1 0 0 0 ⁸ 0 0 0 1 ⁸ 0 1 1 0 9 Cavallo ⁹ 0 0 1 0 ⁹ 1 0 0 0 ⁹ 0 1 0 0 10 Re ¹⁰ 0 1 0 0 ¹⁰ 1 0 0 0 ¹⁰ 0 0 1 1

1 3 2 ¹ 3 4 2 4 3 ² 7 2 3 7 1 ³ 9 4 Spadi Coppe Denari Bastoni _{1 2}

1 2 1 2 3 4 CARTEC CARTEG

SEME

Per simulare il mazzo si può utilizzare una matrice numerica MAZZO di 10 righe, tante quante sono le carte, da 1 (asse) a 10 (re), e 4 colonne, una per ciascuno dei quattro semi. Ogni elemento di questa matrice può assumere il valore 1 - carta presente - o il valore 0 - carta non più nel mazzo.

(5)

Introduzione agli ARRAY – Tressette, Briscola, Poker - Prof. Claudio Maccherani - Perugia - 2005 / 2006 Pag. 5 Per le carte acquisite giocando possiamo utilizzare le matrici MAZZOC e MAZZOG, rispettivamente per il computer e per il giocatore, strutture simili alla matrice MAZZO.

Per le carte "in mano" al giocatore ed al computer usiamo le matrici CARTEC e CARTEG, di 3 righe - tante quante le tre carte in mano - e due colonne: la prima colonna individua la carta (numero da 1 a 10), la seconda colonna individua il seme (numero da 1 a 4).

Nell’esempio di cui sopra risulta che il computer ha Tre di Coppe, Quattro di Denari e Sette di Spadi, mentre il giocatore ha Tre di Bastoni, Sette di Coppe e Cavallo di Bastoni.

Per la distribuzione casuale delle carte si utilizza l’istruzione RANDOMIZE TIMER e la funzione RND, opportunamente "lavorata", per estrarre casualmente la carta (da 1 a 10) ed il seme (da 1 a 4).

Per distribuire effettivamente la carta occorre verificare che sia ancora presente nel MAZZO, cioè che il relativo elemento valga 1. La distribuzione consisterà nel porre a 0 l’elemento della matrice MAZZO associato alla carta e aggiornare opportunamente - con numero carta e numero seme - le matrici CARTEC e CARTEG nella distribuzione delle carte e quindi aggiornare opportunamente ad 1 le matrici MAZZOC e MAZZOG al momento della "presa".

Per visualizzare le carte "vere" esse si memorizzano in una matrice di controlli di tipo image [imgCarta], di 40 elementi, tanti quante le carte, utilizzando opportunamente la proprietà index (Spadi nei primi 10 elementi, poi Coppe, poi Denari ed infine Bastoni) e quindi assegnarle ai giocatori al momento della distribuzione e delle "prese". Per questo occorre prevedere altre matrici di controlli di tipo image quali [imgGio] e [imgCom], di 3 elementi, tanti quante le carte in mano a ciascun giocatore.

Il programma prevede la possibilità di giocare "a carte coperte" o "a carte scoperte" - per verificare come gioca il programma - e in modo "automatico" - è il programma che sceglie quale carta far giocare al computer - o "manuale" - è il giocatore che sceglie anche per il computer.

(6)

POKER

Come ultimo esempio di applicazione degli array in applicazioni informatiche vediamo come potrebbe essere un programma Visual Basic che giochi a POKER, limitandoci alla distribuzione delle carte, al loro cambio e alla definizione del "punto" risultante.

Il poker è un gioco che si fa in più giocatori, ciascuno dei quali punta, bluffa e rilancia in base alle carte e all’ispi razione del momento. Inizialmente si prendono cinque carte, dopo di che se ne possono cambiare alcune, quindi si gioca. I "punti" sono, in ordine decrescente: Scala Reale (tutte le carte dello stesso seme in ordine crescente); Poker (quattro carte uguali); Colore (cinque carte dello stesso seme); Full (un tris ed una coppia), Scala (tutte le carte in ordine crescente), Tris (tre carte uguali), Doppia Coppia (due coppie), Coppia (due carte uguali).

MAZZO GIOCO

CARTA 1 2 3 4 1 2 3 4 vC vS 1 Sei ¹ 1 1 1 1 ¹0 0 0 0 ¹ 3 ¹ 1 2 Sette ² 1 1 1 1 ²0 0 0 0 ² 6 ² 2 3 Otto ³ 0 1 1 1 ³1 0 0 0 ³ 8 ³ 2 4 Nove ⁴ 1 1 1 1 ⁴0 0 0 0 ⁴ 8 ⁴ 3 5 Dieci ⁵ 1 1 1 1 ⁵0 0 0 0 ⁵ 9 ⁵ 4 6 Jack ⁶ 1 0 1 1 ⁶0 1 0 0 7 Donna ⁷ 1 1 1 1 ⁷0 0 0 0 8 Re ⁸ 1 0 0 1 ⁸0 1 1 0 9 Asse ⁹ 1 1 1 0 ⁹0 0 0 1

1 3 1

2 6 2

3 8 2

Fiori Quadri Cuori Picche

4 8 3

1 2 3 4 ⁵ 9 4

SEME ^{1 2} CARTEC

Per simulare il mazzo si può utilizzare una matrice numerica MAZZO di 9 righe, tante quante sono le carte, da 1 (sei) a 9 (asse), e 4 colonne, una per ciascuno dei quattro semi. Ogni elemento di questa matrice può assumere il valore 1 - carta presente - o il valore 0 - carta non più nel mazzo.

Per le carte acquisite dal giocatore possiamo usare la matrice GIOCO, simile a MAZZO.

(7)

Introduzione agli ARRAY – Tressette, Briscola, Poker - Prof. Claudio Maccherani - Perugia - 2005 / 2006 Pag. 7 Per le carte "in mano" al giocatore si usa la CARGIO, di 5 righe - tante quante le cinque carte in mano - e due colonne: la prima colonna individua la carta (numero da 1 a 9), la seconda colonna individua il seme (numero da 1 a 4).

Nell’esempio di cui sopra risulta che il giocatore ha in mano Otto di Fiori, Jack di Quadri, Re di Quadri, Re di Cuori e Asse di Picche.

Per la distribuzione casuale delle carte si utilizza l’istruzione RAND OMIZE TIMER e la funzione RND, opportunamente "lavorata", per estrarre casualmente la carta (da 1 a 9) ed il seme (da 1 a 4).

Per distribuire effettivamente la carta occorre verificare che sia ancora presente nel MAZZO, cioè che il relativo elemento valga 1. La distribuzione consisterà nel porre a 0 l’elemento della matrice MAZZO associato alla carta e aggiornare opportunamente - con numero carta e numero seme - la matrici CARGIO nella distribuzione delle carte e quindi aggiornare opportunamente ad 1 la matrice GIOCO al momento dell’acquisizione delle carte.

Per visualizzare le carte "vere" si usa la libreria di sistema CARDS32.DLL, la stessa dalla quale

"pescano" le carte tutti i giochi di carte forniti con Windows (Heart, Solitario, Spider, etc.).

Il programma prevede la possibilità di acquisire le prime cinque carte, verificare il "punto"

realizzato, cambiare una o più carte, verificare il "punto" definitivo realizzato.