Transcript Relazione Play Game - Università degli Studi di Napoli

Università degli Studi di Napoli “Parthenope”
Facoltà di Scienze e Tecnologie
Corso di Laurea in Informatica Generale
Progetto realizzato per l’esame di Programmazione
III e Laboratorio di Programmazione III.
Prof.: Raffaele Montella
1
Studente: Vitiello Pier Angelo
Matricola: 0124000485
Il linguaggio utilizzato per realizzare questo progetto è
Java, esso è un linguaggio di programmazione orientato
agli oggetti.
Le sue caratteristiche principali sono:
 Semplice e OO
 Sicuro
 Elevate Prestazioni
 Robusto
Ci sto 3 paradigmi principali da sapere sulla Programmazione ad
Oggetti:
 Ereditarieta: ci permette di derivare nuove classi a
partire da classi già definite.
 Incapsulamento: indica la proprietà degli oggetti di
incorporare al loro interno sia gli attributi che i
metodi, cioè le caratteristiche e i comportamenti
dell’oggetto. I vantaggi principali portati
dall'incapsulamento sono robustezza, indipendenza e
l'estrema riusabilità degli oggetti creati.
 Polimorfismo : Il polimorfismo indica la possibilità per i
metodi di assumere più forme, cioè implementazioni
diverse, all’interno della gerarchia delle classi.
I programmi scritti in linguaggio Java sono lanciati su una Java
Virtual Machine e avranno accesso alle API della libreria
standard.
L’ambiente di sviluppo utilizzato per lo sviluppo di questo
progetto è Eclipse Java EE IDE , applicando un tool (Window
Builder Editor)per lo sviluppo delle interfaccie grafiche per
agevolare le implementazioni dello sviluppatore.
2
Play Game è un gioco, come abbiamo detto in precedenza,
progettato in Java, il giocatore può scegliere tra 3 giochi
differenti: Roulette, BlackJack e Memory , più avanti
parleremo in modo specifico di tutti e 3.
L’applicazione è stata implementata mediante le librerie
SWING e AWT .
Tutte le interfaccie grafiche del progetto sono costituite da
dei JFRAME costituiti da oggetti che permettono all’utente di
interagire con l’applicazione.
Suddivisione dei Frame:
Il primo Frame è l’interfaccia principale il cosiddetto Menu.
L’implementazione è abbastanza semplice, un immagine di
sfondo costituita da due Jbutton che al click cambiano Frame
3
buttonGioca.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
Scelta s = new Scelta();
s.setVisible(true);
setVisible(false);
}
});
buttonIstruzioni.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
Istruzioni i = new Istruzioni();
i.setVisible(true);
}
});
dal codice incollato sopra notiamo subito che se l’utente
clicca sul jbutton GIOCA viene chiuso il frame e ne viene
aperto uno nuovo, invece al cliccare del jbutton ISTRUZIONI
viene aperto un secondo frame senza chiudere quello
precedente.
4
JFrame Istruzioni:
Come vediamo nell’immagine il frame appena aperto si
sovrappone a quello precedente, e alla sua chiusura viene
chiuso solo il frame delle istruzioni, cosi l’utente può tornare
al menu principale.
Qui un nuovo utente scopre le regole dei giochi prima di
iniziare a giocare.
Quindi al click di uno dei seguenti jbutton viene chiuso il
frame istruzioni e viene aperto un nuovo frame in base alla
scelta dell’utente sul quale jbutton cliccare.
Sotto ci sono i 3 frame dei regolamenti dei giochi, e in ognuno
di essi c’è un jbutton per tornare al frame precedente, cioè
quello di istruzioni:
5
RegolamentoRoulette
RegolamentoBlackJack
6
RegolamentoMemory
Ora passiamo al momento in cui il giocatore clicca sul jbutton
GIOCA nel menu principale, viene visualizzato il frame della
scelta del gioco:
7
Qui il giocatore digita il proprio nome o qualsiasi alias con cui
vuole giocare, dopodiché sceglie il suo personaggio, alla
scelta del personaggio, l’immagine raffigurante il personaggio
scelto diventa più chiara, ad esempio:
Il giocatore ha scelto Jack, se vuole cambiare idea basta
selezionare un'altra immagine.
Riguardo l’implementazione basta dire che ogni immagine
corrisponde ad un jbutton, e al click di uno di questi viene
settata la visibilità del jbutton scelto e quella degli altri.
public void actionPerformed(ActionEvent arg0) {
imgGiocatore1.setEnabled(false);
imgGiocatore2.setEnabled(true);
imgGiocatore3.setEnabled(true);
imgGiocatore4.setEnabled(true);
indicePersonaggiScelto=0;
controlloSelezioneImmagineGiocatore++;
. . . .
. . . .
Il codice che vediamo corrisponde a quello che abbiamo
detto precedentemente, in più vediamo alcune variabili che ci
servono nelle implementazioni successive dei giochi.
8
Come abbiamo visto nello screenshot sopra, l’utente può
visionare ancora i frame delle istruzioni.
Adesso che il giocatore ha scelto il suo alias e il suo
personaggio, non rimane che scegliere il gioco.
Queste è una delle implementazioni dei 3 pulsanti:
public void actionPerformed(ActionEvent arg0) {
nomeUtente=nomeInserito.getText();
if(nomeUtente.isEmpty()){
nomeUtente="Player_1";
}
mDn= new MazzoDeathNote();
utente=Method.creazioneUtente(nomeUtente,personaggi,indicePersonaggiScelto,0);
Memory i = new Memory();
i.dispose();
i.setVisible(true);
setVisible(false);
}
Come vediamo dal codice se l’utente non inserisce il suo
nome gli viene dato un nome di default.
In più viene creato l’oggetto utente che corrisponde
all’immagine scelta dal giocatore e al suo interno viene
settato un suo saldo di gioco.
Come abbiamo detto precedentemente le scelte sono 3:
Roulette, BlackJack e Memory, adesso parliamo
specificatamente di ognuno dei 3.
9
Roulette:
quando viene scelto il gioco della roulette vengono creati
anche 3 oggetti che corrispondono a 3 giocatori avversari.
Questa è la schermata del gioco della Roulette, prima cosa da
dire prima di postare il codice è che ci sono varie logiche che
gestiscono i numeri , le scommesse e gli aggiornamenti del
saldo dei giocatori.
In questo frame ci sono solo 2 jbutton, uno per uscire dal
gioco e tornare al menu e un jbutton per girare la roulette e
far partire tutte le logiche implementate.
La roulette al centro del frame è una semplice jlabel
rappresentata da una gif animata.
10
Le implementazioni significative del frame, escludendo i vari
Object sparsi per il frame, sono le logiche delle scommesse e
del saldo dei giocatori.
Le prime logiche partono quando vengono scelti in maniera
random le scommesse degli avversari, i numeri scelti , il
colore scelto e se il numero che esce dalla roulette è pari o
dispari.
Tutte queste scelte sono limitate agli stessi limiti che ha
l’utente, ad esempio la scommessa non può superare il saldo
e il numero su cui puntare la scommessa deve essere un
numero esistente sulla roulette, e molte altre ancora.
Sotto alcune implementazioni di queste logiche:
for(int i=0;i<nomiPersonaggi.size();i++){
if(i==Scelta.indicePersonaggiScelto){
nomiPersonaggi.get(i).setText(Scelta.utente.getNomeUtente());
nomeGiocatore = new JLabel(Scelta.utente.getNomeUtente());
if(i==0){
nomeImgGiocatore1= new JLabel(Scelta.utente.getNomeUtente());
nomeImgGiocatore2= new JLabel(Scelta.avversario1.getNomeAvversario());
nomeImgGiocatore3= new JLabel(Scelta.avversario2.getNomeAvversario());
nomeImgGiocatore4= new JLabel(Scelta.avversario3.getNomeAvversario());
Quella nell’if è la variabile che è stata settata all’inizio nel
frame precedente che serve a riconosce a quale giocatore
corrisponde l’utente.
11
if((Scelta.utente.getSaldo())<=0){
importoInseritoGiocatore1.setText("Saldo Esaurito");
importoInseritoGiocatore1.setEditable(false);
jTFNumSceltoDaGiocatore1.setEditable(false);
jTFNumSceltoDaGiocatore1.setText("0");
colore1.setSelectedIndex(0);
colore1.enable(false);
pariDispari1.setSelectedIndex(0);
pariDispari1.enable(false);
}
if((Scelta.avversario1.getSaldo())<=0){
importoInseritoGiocatore2.setText("Saldo Esaurito");
importoInseritoGiocatore2.setEditable(false);
jTFNumSceltoDaGiocatore2.setEditable(false);
jTFNumSceltoDaGiocatore2.setText("0");
colore2.setSelectedIndex(0);
colore2.enable(false);
pariDispari2.setSelectedIndex(0);
pariDispari2.enable(false);
}
Con questi codici vediamo che il giocatore(che sia l’utente
o l’avversario) non partecipa più al gioco se il suo saldo è
minore di 0, e vengono disabilitate tutti gli Object collegati
a lui.
Le logiche importanti partono quando l’utente clicca sul
jbutton RUOTA, ad esempio alcune di questo sono:
Controlla che l’utente non abbia scommesso più di quanto
possiede nel suo saldo;
12
Controlla che l’utente abbia inserito un numero valido (da
0 a 36);
Vengono salvate tutte le scommesse dei giocatori e
quando viene calcolato il numero estratto dalla roulette
vengono fatte le appropriate logiche per vedere se è il
proprio colore e se è pari o dispari.
Le vincite sono calcolate in base alle scommesse fatte:
Se si indovina il numero estratto dalla roulette si vince il
doppio della puntata.
13
Lo stesso per i colori e se è pari o dispari, ad esempio:
Adesso vi mostriamo le logiche per vedere se l’utente ha
perso o ha vinto:
14
Questa è invece la schermata dopo aver premuto il jbutton
RUOTA:
Il giocatore ha puntato 50 $ sul 18 ed ha selezionato Dispari,
pari e dispari e la selezione del colore, sono una seconda
possibilità per il giocatore, perché abbiamo detto che se
indovina il numero vince il doppio della puntata, se indovina
se è pari o dispari o il colore vince la sua puntata + 5 $, quindi
adesso ha perso i 50 $ perché il numero non era quello da lui
scelto, ma li recupera + 5$ perché è uscito dispari.
Come si vede nello screenshot gli object degli avversari sono
disabilitati cosi l’utente non può modificarli.
Adesso sotto vengono mostrate 3 schermate in base alla fine
del gioco, come abbiamo visto nel codice implementato
sopra, può vincere sia l’utente sia un avversario, ma può
anche capitare ,raramente, che vinca il banco, cioè tutti
perdono i loro soldi.
15
Vittoria Utente
In questo frame il giocatore può scegliere di tornare al menu.
Vittoria Avversario
Viene visualizzato il nome dell’avversario che ha vinto.
Quando l’utente perde, viene calcolato un avversario random
e un saldo random da visualizzare in questo frame, anche qui
l’utente può scegliere di tornare al menu.
16
Vittoria Banco
Questo frame viene visualizzato quando vince il banco.
17
BlackJack:
Questa è la schermata iniziale del gioco, ci sono due
jbutton che permettono all’utente di tornare al menu
principale e di visionare nuovamente le istruzioni ,visto che
le regole non sono come quelle del BlackJack solito ,ci sono
punteggi diversi per tutte le carte e il limite da non
superare non è 21 ma 33, in più se il giocatore arriva ad un
punteggio di 27, ha la possibilità di modificare la propria
scommessa.
Le implementazioni logiche avvengono tutte quando si
clicca su ancora o su stop.
18
Ad esempio questa è l’implementazione di quando si
estraggono le carte dal mazzo:
Vengono fatti i controlli se l’utente ha superato 33 oppure
no.
19
Facciamo che l’utente ha cliccato varie volte sul jbutton
ancora:
In questo caso l’utente ha raggiunto il punteggio di 27,
quindi può modificare la sua scommessa, infatti vediamo
che è stata abilitata la JTextField precedentemente
disabilitata.
Se clicchiamo il jbutton stop vengono estratte le carte per
il dealer e si vedrà se quest’ultimo avrà punteggio
maggiore o minore del giocatore, se il punteggio è uguale
ed entrambi arrivano a 33, esiste il pareggio, e il giocatore
vince la metà della sua scommessa.
20
Adesso clicchiamo stop:
Il dealer ha superato 33 quindi esce un apposita JDialog
per avvertire l’utente che ha vinto e incassa la propria
scommessa, e al premere ok ricomincia il gioco.
21
Memory:
La realizzazione di questo gioco è ispirata al manga
giapponese DeathNote, come possiamo leggere nelle
istruzioni del gioco , lo scopo è abbinare tutte le carte nel
limite di tempo previsto e nelle possibilità date.
Le logiche sono semplici, basta giocare sulla visibilità dei
pulsanti e delle jlabel, ed effettuare i vari calcoli per vedere
se i lavori delle carte sono uguali(valori settati di default).
Questo è il frame del gioco,con l’apposito pulsante per
tornare al menu e le 12 carte.
22
Sotto alcune delle logiche implementate:
23
Al cliccare del jbutton carta1 vengono effettuate tute queste
logiche , cosi anche per le altre carte.
Questa è la schermata dopo alcune azioni da parte
dell’utente.
In questo caso l’utente ha abbinato 3 coppie di carte, ma se
fa scadere il tempo esce una JDialog che avverte che il tempo
è scaduto e ti fa scegliere se continuare o no, lo stesso accade
se esaurisci le possibilità.
Se abbini tutte le carte entro il tempo e le possibilità date il
tuo saldo aumenta di 30 , altrimenti diminuisce di 20.
24
Avverte che il tempo è scaduto.
A te la scelta se continuare a giocare o tornare al menu.
25
In futuro saranno fatte modifiche sull’applicazione in modo
che i giochi possino divenire multiplayer.
26