|
|||||||
|
|
|
 |
|
|
Strumenti |
19-05-2005, 01:35
|
#1 |
|
Senior Member
Iscritto dal: Jan 2005
Città: A casa mia
Messaggi: 825
|
Datemi un Parere
Ecco finito dopo un 1 settimana di lavoro,ecco il mio bello snakuccio...
qualcuno lo prova e mi dice le sue impressioni per favore..anke per sapere se si adatta bene alle varie risoluzioni dei desktop ad esempio! Critiche,soprattutto critiche al codice!grazie a tutti in anticipo  PS: VA compilato con JAva 5.0 con la 1.4.2 da errore nella classe Panels.java alla riga corrispondente al codice: Codice:
add(panel); Codice:
import javax.swing.*;
import java.awt.*;
import java.util.*;
import java.awt.event.*;
import java.awt.geom.*;
public class DrawFrame
{
public static void main (String[] args)
{
SnakeFrame frame = new SnakeFrame(); //Inizializzo il frame
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //Dico al frame cosa deve fare quando chiudo la fienstra
frame.setVisible(true); //Dico alla finestra di essere visibile
}
}
class SnakeFrame extends JFrame
{
public SnakeFrame()
{
Toolkit kit = Toolkit.getDefaultToolkit(); //inizializzo un oggetto kit ke acquisisce tutte le informazioni relative al Desktop
Dimension screenSize = kit.getScreenSize(); //assegno le dimesioni dello schermo utente
int screenHeight = screenSize.height;
int screenWidth = screenSize.width;
setSize(screenWidth / 2,screenHeight / 2);
setLocation (screenWidth / 4, screenHeight / 4);
setTitle("Snake Beta Vers. 0.1 By Valerio Bignardi");
Panels panel = new Panels(); //Inizializzo il panello
add(panel); //Aggiugno il pannello al Frame
}
}
Codice:
import javax.swing.*;
import javax.swing.Timer;
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.lang.*;
//--------------------------------------------------------
// La classe in questione si occupa di disegnare tutti gli oggetti
// e di aggiornare il disegno e le relative interazioni tra gli oggetti
// Funzionamento tipico:
// -Il metodo paintComponent disegna tutti gli oggetti
// -Grazie alla classe ThreadMove creo un Thread ke automatizza il movimento
// -Il Timer serve per Disegnare ogni 7 secondi (e per tener visibili per 7 secondi)
// le palline blue
// Grazie all'implementazione dell'interfaccia KeyListener ottengo la coda degli eventi
// della tastiera e a seconda dei tasti schiacciati Muovo il serpente.
// Il controllo della logica è delegato parte agli oggetti stessi e parte alla classe panel
// Sostanzialmente gli urti tra oggetti (mappa - serpente, serpente - ball , ball - mappa)
// è gestita dai singoli oggetti,mentre invece la logica di controllo relativo alla posizione ove
// vengono creati i nuovi oggetti
//-------------------------------------------------------------------------------------------------------
public class Panels extends JPanel implements KeyListener
{
public int keyCode; //Assegno al valore della tastiera il valore 1 (1 = UP)
private Nodo temp; //inizializzo un nodo temporaneo
private Snake snake; //Variabile snake
private Mappa mappa; //Variabile mappa
private Status status;
private Ball ball; //Variabile ball
private Punteggio points;
private SpecialBall sball;
private int screenHeight; //Variabile contenente l'altezza del Desktop
private int screenWidth; //VAriabile contenente la larghezza del Desktop
private boolean VK_UP = false; //Valori booleani ke indicano la direzione precedente
private boolean VK_DOWN = false; //alla nuova direzione scelta dall'utente
private boolean VK_LEFT = false;
private boolean VK_RIGHT = false;
private boolean time;
Graphics2D g2; //Oggetto grafico
Graphics g;
//ThreadSball specialBall;
private boolean eat = false;
private boolean Seat = false;
private boolean hit = false;
//----------------------------
// Name : Panels
// Desc : Costruttore
// ToDo : Nulla
//------------------------------------
public Panels()
{
addKeyListener(this); // registrazione del listener
setFocusable(true); // Fa acquisire il fuoco al pannello
status = new Status(); //Rendo vivo il serpente
points = new Punteggio(); //Inizializzo il punteggio
init(); //Inizializzo l'area di gioco
ThreadMove move = new ThreadMove(temp,snake); //creo un nuovo Thread per il movimento automatizzato
move.start(); //Faccio partire il Thread che automatizza il movimento
ActionListener listener = new Timeout(); //Creo un ascoltatore per il Timer
Timer Tout = new Timer (7000,listener); //faccio partire il Timer ke mi esegue il listener ogni 7 secondi
Tout.start(); //Faccio partire il Timer
}
//---------------------------------
// Name : init()
// Desc : Questo metodo Inizializza tutto gli oggetti di gioco e gli oggetti accessori al gioco
// come kit necessario per creare un frame "standard" su qualsiasi tipo di risoluzione del
// Desktop
// ToDo : Nulla ;)
//------------------------------------------------------------------------
public void init ()
{
//------- ACQUISISCO INFORMAZIONI SCHERMO UTENTE ----------
Toolkit kit = Toolkit.getDefaultToolkit();
Dimension screenSize = kit.getScreenSize();
screenHeight = screenSize.height;
screenWidth = screenSize.width;
//------------- CREO LA MAPPA ----------------
int map_leftX =(screenWidth / 8) -60;
int map_topY =(screenHeight / 8) -50;
int map_width = screenWidth / 3;
int map_height = screenHeight / 3;
mappa = new Mappa(map_leftX,map_topY,map_width,map_height);
//------------- CREO IL SERPENTE --------------
int S_width = 10;
int S_height = 10;
int S_leftX = screenWidth / 4 - 30;
int S_topY = screenHeight / 4 - 40;
snake = new Snake(S_width,S_height,S_leftX,S_topY,ball);
snake.Create_Snake(5,snake.testa(),S_leftX,S_topY);
//------------- INIZIALIZZO I TEMPI DELLE PALLINE SPECIALI -------------
time = false;
//------------- CREO LA PALLINA -----------------
ball = new Ball(10,10);
ball.Gen_Coo(snake.testa(),5,mappa,screenWidth / 3,screenHeight / 3);
//------------ CREO LE PALLINE SPECIALI -----------------
sball = new SpecialBall(10,10,ball);
} //End init
//--------------------------------------
// Name : paintComponent
// Desc : Esegue il primo disegno del Frame e ne permette i successivi aggioranmenti
// ToDo : Abbellire la grafica :(
//------------------------------------------------------------
public void paintComponent(Graphics g)
{
super.paintComponent(g);
//-----------------INIZIALIZZAZIONE AREA DI GIOCO-----------------
g2 = (Graphics2D) g;
g2.drawString("SNAKE Alpha Vers. 0.1 Valerio Bignardi",20,20);
g2.drawString("PUNTEGGIO: "+points.points(),80,35);
//--------DISEGNO LA MAPPA-----------
Rectangle2D map = new Rectangle.Double(mappa.leftX(),mappa.topY(),mappa.width(),mappa.height());
g2.setPaint(Color.WHITE);
g2.fill(map);
g2.draw(map);
//--------DISEGNO IL SERPENTE-------------
temp = snake.testa();
while (temp.succ() != null)
{
Rectangle2D rect = new Rectangle2D.Double(temp.leftX(),temp.topY(),temp.width(),temp.height());
g2.setPaint(Color.BLACK);
g2.fill(rect);
g2.draw(rect);
temp = temp.succ();
}//end while
//----------DISEGNO LE PALLINE-----
Rectangle2D bal = new Rectangle2D.Double(ball.leftX(),ball.topY(),ball.width(),ball.height());
g2.setPaint(Color.RED);
g2.fill(bal); //Riempio di colore la pallina
g2.draw(bal);
//--------- DISEGNO LE PALLINE SPECIALI ---------------
if(time) //Se Il timer ha dato l'ok per disegnare la pallina speciale
{
if (sball.leftX() != 0 && sball.topY() != 0) //Verifico se la pallina non ha coordinate
{
Rectangle2D sbal = new Rectangle2D.Double(sball.leftX(),sball.topY(),sball.width(),sball.height());
g2.setPaint(Color.BLUE);
g2.fill(sbal); //Riempio di colore la pallina
g2.draw(sbal);
}
}
//g2.setPaint(Color.BLUE);
g2.drawString("Legenda: - Pallina Rossa 3 punti",80,mappa.topY() + mappa.height() + 30);
g2.drawString("- Pallina Blue 10 punti",135,mappa.topY() + mappa.height() + 40);
}
//-------------------------------------------
// Name : enjoy()
// Desc : Questo metodo prende come parametri il serpente attuale e il nodo temporaneo attuale
// Successivamente viene eseguito il pezzo di codice relativo al movimento scelto
// Una volta deciso il movimento viene eseguito il MoveTo ke muove il serpente
// e in parallelo vengo controllati diversi fattori : 1. Se sono fuori dalla mappa
// 2. Se mi sono autocolpito
// 3. Se ho mangiato una pallina
// ToDo : Ottimizzare, decentralizzando tutto il codice condizionale di questo metodo
// ad altri metodi
//-------------------------------------------------------------------------------------------
public void enjoy(Nodo temp,Snake snake)
{
this.temp = temp;
this.snake = snake;
temp = snake.testa();
//Reimposto a false tutte le direzioni
VK_UP = false;
VK_DOWN = false;
VK_LEFT = false;
VK_RIGHT = false;
//a seconda della direzione muovo il serpente
switch (keyCode)
{ //Mi sposto in ALTO
case KeyEvent.VK_UP : //Muro Sx //Muro destro - pixel //Parete superiore //Parete inferiore //Colpito me stesso
if ( temp.leftX() < mappa.leftX() || temp.leftX() + 10 > (mappa.leftX() + mappa.width() ) || temp.topY() < mappa.topY() || temp.topY() + 10 > (mappa.topY() + mappa.height() ) )
{
System.out.println("Game Over... "); //Comunico a shell ke ho Perso
status.Dead(points); //invio il segnale di termine programma e comunico putneggio ottenuto
}
else //se non sono morto
{
temp = snake.moveto(1,snake); //Muovo il serpente e ritorno a temp la nuova testa
snake.HitMySelf(temp,points); //verifico se mi sono colpito da solo
}
//-----------AGGIORNO IL DISEGNO DEL SERPENTE--------------
while (temp.succ() != null)
{
Rectangle2D rect = new Rectangle2D.Double(temp.leftX(),temp.topY(),temp.width(),temp.height());
g2.setPaint(Color.BLACK);
g2.draw(rect);
repaint(0,0,1280,1024);
temp = temp.succ();
}
VK_UP = true; //Comunico di aver appena eseguito la direzione verso l alto
break;
//MI SPOSTO IN GIU
case KeyEvent.VK_DOWN : //Muro Sx //Muro destro + 10 pixel //Parete superiore //Parete inferiore
if ( temp.leftX() < mappa.leftX() || temp.leftX() + 10 > (mappa.leftX() + mappa.width() ) || temp.topY() < mappa.topY() || temp.topY() + 10 > (mappa.topY() + mappa.height() ) )
{
System.out.println("Game Over...");
status.Dead(points);
}
else
{
temp = snake.moveto(2,snake);
snake.HitMySelf(temp,points);
}
while (temp.succ() != null)
{
Rectangle2D rect = new Rectangle2D.Double(temp.leftX(),temp.topY(),temp.width(),temp.height());
g2.setPaint(Color.BLACK);
g2.draw(rect);
repaint(0,0,1280,1024);
temp = temp.succ();
}
VK_DOWN = true;
break;
//MI SPOSTO A SX
case KeyEvent.VK_LEFT : //Muro Sx //Muro destro - pixel //Parete superiore //Parete inferiore
if ( temp.leftX() < mappa.leftX() || temp.leftX() + 10 > (mappa.leftX() + mappa.width() ) || temp.topY() < mappa.topY() || temp.topY() + 10> (mappa.topY() + mappa.height() ) )
{
System.out.println("Game Over...");
status.Dead(points);
}
else
{
temp = snake.moveto(3,snake);
snake.HitMySelf(temp,points);
}
while (temp.succ() != null)
{
Rectangle2D rect = new Rectangle2D.Double(temp.leftX(),temp.topY(),temp.width(),temp.height());
g2.setPaint(Color.BLACK);
g2.draw(rect);
repaint(0,0,1280,1024);
temp = temp.succ();
}
VK_LEFT = true;
break;
//MI SPOSTO A DX
case KeyEvent.VK_RIGHT : //Muro Sx //Muro destro - pixel //Parete superiore //Parete inferiore
if ( temp.leftX() < mappa.leftX() || temp.leftX() + 10 > (mappa.leftX() + mappa.width() ) || temp.topY() < mappa.topY() || temp.topY() + 10> (mappa.topY() + mappa.height() ) )
{
System.out.println("Game Over...");
status.Dead(points);
}
else
{
temp = snake.moveto(4,snake);
snake.HitMySelf(temp,points);
}
while (temp.succ() != null)
{
Rectangle2D rect = new Rectangle2D.Double(temp.leftX(),temp.topY(),temp.width(),temp.height());
g2.setPaint(Color.BLACK);
g2.draw(rect);
repaint(0,0,1280,1024);
temp = temp.succ();
}
VK_RIGHT = true;
break;
}//End switch
////////////////// Aggiorno lo scenario di Gioco dopo il Movimento//////////////////
//Vedo se in questo istante la pallina speciale è visibile
if (time == true) // se il timer ha dato l'ok al disegno delle palle speciali
Seat = snake.SEat(sball,snake.testa()); //vefrifico se ho mangiato la palla speciale
if (time == true) // Se il timer ha dato l'ok al disegno delle palle speciali
{
if (sball.generato() == false) //Se non ho gia' Creato le coordinate della pallina speciale
sball.Gen_Coo(snake.testa(),5,mappa,screenWidth / 3,screenHeight / 3,ball); //Se non le ho gia create genero una nuova pallina
Rectangle2D sbal = new Rectangle2D.Double(ball.leftX(),ball.topY(),ball.width(),ball.height()); // Disegno la pallina
g2.setPaint(Color.BLUE); //Imposto il colore
g2.fill(sbal); //Riempio la pallina
g2.draw(sbal); //Disegno la pallina
}
if (time == true) // Se il timer ha dato l'ok al disegno delle palle speciali
if (Seat == true) // Se l ho mangiata
{
sball.Gen_Coo(snake.testa(),5,mappa,screenWidth / 3,screenHeight / 3,ball); //genero una nuova pallina
Rectangle2D sbal = new Rectangle2D.Double(ball.leftX(),ball.topY(),ball.width(),ball.height());
g2.setPaint(Color.BLUE);
g2.fill(sbal);
g2.draw(sbal);
points.MorePoints(10); //Incremento il punteggio
time = false; //reimposto la pallina come non Visibile
Seat = false; //Re-Imposto la pallina come non mangiata
}
eat = snake.Eat(ball,snake.testa()); //assegno a eat il valore booleano restituito da Eat() per sapere se ho mangiato 1 pallina
if (eat == true) //Se l ho mangiata
{
snake.Add(); //Aggiungo un Nodo al Serpente
points.MorePoints(3); //incremento il punteggio
ball.Gen_Coo(snake.testa(),5,mappa,screenWidth / 3,screenHeight / 3); //genero una nuova pallina
Rectangle2D bal = new Rectangle2D.Double(ball.leftX(),ball.topY(),ball.width(),ball.height()); //Disegno la nuova pallina
g2.setPaint(Color.RED);
g2.fill(bal);
g2.draw(bal);
eat = false;
//repaint(0,0,1280,1024);
//Disegno il Nuovo Serpente
while (temp.succ() != null)
{
Rectangle2D rect = new Rectangle2D.Double(temp.leftX(),temp.topY(),temp.width(),temp.height());
g2.setPaint(Color.BLACK);
g2.draw(rect);
repaint(0,0,1280,1024);
temp = temp.succ();
}
g2.drawString("PUNTEGGIO: "+points.points(),80,30);
}
temp = snake.testa(); // riassegno a temp la testa del serpente
}
//---------------------------------------
// Name : ParserMove
// Desc : Verifica che il movimento corrente non sia opposto a quello precedente,se si
// ignora il nuovo movimento continuando il precedente
// ToDo : Nulla ;)
//------------------------------------------------------------------
public void ParserMove()
{
if (keyCode == KeyEvent.VK_UP) //Verifico se Vengo dal Basso
if (VK_DOWN == true)
keyCode = KeyEvent.VK_DOWN;
if (keyCode == KeyEvent.VK_DOWN) //Verifico se vengo dall'alt0
if (VK_UP == true)
keyCode = KeyEvent.VK_UP;
if (keyCode == KeyEvent.VK_LEFT) //Verifico se vengo da Dx
if (VK_RIGHT == true)
keyCode = KeyEvent.VK_RIGHT;
if (keyCode == KeyEvent.VK_RIGHT) //Verifico se vengo da Sx
if (VK_LEFT == true)
keyCode = KeyEvent.VK_LEFT;
}
/* implementazione del listener */
public void keyPressed (KeyEvent event) {
keyCode = event.getKeyCode(); //Acquisisco il tasto premuto
ParserMove(); //test sul controllo della mossa
} //End KeyPressed
public void keyTyped(KeyEvent e) { }
public void keyReleased(KeyEvent e) { }
//---------------- CLASSE PRIVATA CHE ISTANZIA UN NUOVO THREAD ----------------
private class ThreadMove extends Thread
{
private Nodo testa;
private Nodo temp;
private Snake snake;
public ThreadMove(Nodo temp,Snake snake)
{
this.temp = temp;
this.snake = snake;
}
public void run()
{
for (;;) // Ciclo INFINITO
{
enjoy(temp,snake); //Richiamo la funzione automa
try {
Thread.sleep(90); //faccio riposare per 80 ms il thread corrente per permettere a PaintComponent Di lavorare
}catch (InterruptedException e){
System.out.println(e);
}
}
}
}
class Timeout implements ActionListener
{
public void actionPerformed(ActionEvent event)
{
if (time == false) //Se lo stato precedente era di pallina speciale non visibile
time = true; //Imposto lo stato della pallina Visibile
else
{
time = false; //Imposto lo stato della pallina speciale come invisibile
sball.C_generato(false); //Visto ke è appena scomparsa la pallina precedente,ne devo creare una nuova quindi imposto su Non generate le Coordinate della pallina speciale
}
}
}
}
Codice:
public class Punteggio
{
// instance variables - replace the example below with your own
private int points;
/**
* Constructor for objects of class Punteggio
*/
public Punteggio()
{
points = 0;
}
public void MorePoints(int y)
{
points += y;
}
public int points()
{
return points;
}
}
Codice:
public class Status
{
// instance variables - replace the example below with your own
private boolean alive;
private Punteggio points;
public Status()
{
}
public void Dead (Punteggio points)
{
System.out.println("GAME OVER...");
System.out.println("Punteggio Totalizzato: "+points.points());
System.exit(0);
}
}
Codice:
import javax.swing.*;
import javax.swing.Timer;
import java.awt.*;
import java.util.*;
import java.awt.event.*;
import java.awt.geom.*;
//----------------------------------
// Questa pallina rimane visibile solo 7 secondi
// e da 10 punti se mangiata
// Potevo ereditare i metodi e le variabili dalla classe
// Ball ma ho preferito scindere le due cose per rendere nella classe
// Panels.java il codice piu leggibile
//----------------------------------------------
public class SpecialBall
{
private int leftX;
private int topY;
private int width;
private int height;
private Ball ball;
private boolean generato = false;
private Nodo temp;
RandomGenerator r = new RandomGenerator(123456789);
public SpecialBall(int width,int height,Ball ball)
{
this.width = width;
this.height = height;
this.ball = ball;
leftX = 0;
topY = 0;
}
public void Gen_Coo(Nodo nodo,int max,Mappa mappa,int screenWidth,int screenHeight,Ball ball)
{
this.temp = nodo; // Nodo temp necessario per scorrere la lista dei nodi del serpente
boolean Coo_ok = true; //inzializzo a true la variabile
leftX = (int)(Math.round(r.get() * 800));//Genero le coordinate con la funzione random
topY = (int)(Math.round(r.get() * 800 ));
//normalizzo le coordinate su una "teorica" Griglia di 10 x 10 pixel
if (leftX % 10 >= 0)
leftX -= leftX % 10;
if (topY % 10 >= 0)
topY -= topY % 10;
do
{
do
{ // Muro Sx // Muro Dx //Soffitto //Base //Coordinate Snake = Ball // Coordinate special ball = ball
if ( leftX <= mappa.leftX() || leftX >= (mappa.leftX() + mappa.width() - 8 ) || topY <= mappa.topY() || topY >= (mappa.topY() + mappa.height()) || (leftX == temp.leftX() && topY == temp.topY()) || (leftX == ball.leftX() && topY == ball.topY()) )
{
Coo_ok = false; // assegna condizione di falsita
leftX = (int)(Math.round(r.get() * 800)); // rigenera le coordinate
topY = (int)(Math.round(r.get() * 800)); //rigenera le coordinate
//Normalizzo in una griglia di 10 x 10 pixel le coordinate
if (leftX % 10 >= 0)
leftX -= leftX % 10;
if (topY % 10 >= 0){
topY -= topY % 10;
}
}//End if
else //altrimenti dai il nulla hosta per uscire dal ciclo
Coo_ok = true;
}while (Coo_ok != true); //continua fino a quando le coordinate non sono corrette
temp = temp.succ(); //Passo all'elemento successivo del serpente
}while (temp.succ() != null); //fino a quando non arrivo alla fine della lista cicla
generato = true; //Comunico di aver appena generato le palline
}//End Gen_Coo
public int height(){
return height;
}
public int width(){
return width;
}
public int leftX(){
return leftX;
}
public int topY(){
return topY;
}
public boolean generato(){
return generato;
}
public void C_generato(boolean value){
generato = value;
}
}
Codice:
public class Mappa
{
private int height;//ALtezza
private int width;//larghezza
private int leftX;//Coordinata X angolo sx superiore
private int topY;
public Mappa(int leftX,int topY,int width,int height)
{ //Normalizzo la Mappa ad un Griglia "teorica" di 10 x 10 pixel
if (leftX % 10 != 0)
leftX -= leftX % 10;
if (topY % 10 != 0)
topY -= topY % 10;
if (width % 10 != 0)
width -= width % 10;
if (height % 10 != 0)
height -= height % 10;
this.leftX = leftX;
this.topY = topY;
this.width = width;
this.height = height;
}
public int leftX()
{
// put your code here
return leftX;
}
public int topY()
{
// put your code here
return topY;
}
public int width()
{
// put your code here
return width;
}
public int height()
{
// put your code here
return height;
}
}
Codice:
import javax.swing.*;
import javax.swing.Timer;
import java.awt.*;
import java.util.*;
import java.awt.event.*;
import java.awt.geom.*;
public class Ball
{
private int leftX;
private int topY;
private int width;
private int height;
private int k; //contatore del numero di palline generate
private Nodo temp;
private long t0;
private long t1;
RandomGenerator r = new RandomGenerator(123456789);
public Ball(int width,int height)
{
this.width = width;
this.height = height;
leftX = 0;
topY = 0;
k = 0;
}
//--------------------------------------------------------
// Name : Gen_Coo
// Desc : Genera delle Coordinate Random per le palline
// Inoltre ad ogni generazione viene controllato ke le coordinate non corrispondano con un nodo
// dello snake e ke le coordinate non siano fuori dall'area della Mappa
// ToDo : Nulla ;)
// Vers : 1.0
// Bugs : Per Ora nulla :D
//-------------------------------------------------------------------------------------------
public void Gen_Coo(Nodo nodo,int max,Mappa mappa,int screenWidth,int screenHeight)
{
this.temp = nodo; // Nodo temp necessario per scorrere la lista dei nodi del serpente
boolean Coo_ok = true; //inzializzo a true la variabile
leftX = (int)(Math.round(r.get() * 800));//Genero le coordinate con la funzione random
topY = (int)(Math.round(r.get() * 800 ));
if (leftX % 10 >= 0)
leftX -= leftX % 10;
if (topY % 10 >= 0)
topY -= topY % 10;
do
{
do
{ // Muro Sx // Muro Dx //Soffitto //Base //Coordinate Snake = Ball
if ( leftX <= mappa.leftX() || leftX >= (mappa.leftX() + mappa.width() - 8 ) || topY <= mappa.topY() || topY >= (mappa.topY() + mappa.height()) || (leftX == temp.leftX() && topY == temp.topY()) )
{
Coo_ok = false; // assegna condizione di falsita
leftX = (int)(Math.round(r.get() * 800)); // rigenera le coordinate
topY = (int)(Math.round(r.get() * 800)); //rigenera le coordinate
//Normalizzo in una griglia di 10 x 10 pixel le coordinate
if (leftX % 10 >= 0)
leftX -= leftX % 10;
if (topY % 10 >= 0){
topY -= topY % 10;
}
}//End if
else//altrimenti dai il nulla hosta per uscire dal ciclo
Coo_ok = true;
}while (Coo_ok != true); //continua fino a quando le coordinate non sono corrette
temp = temp.succ();//Passo all'elemento successivo del serpente
}while (temp.succ() != null); //fino a quando non arrivo alla fine della lista cicla
//conto il numero di palline generate a buon fine
if (k <= 5)
k++;
else
k = 0 ;
}//End Gen_Coo
//procedura ke decide se la pallina è viva o meno
public int height(){
return height;
}
public int width(){
return width;
}
public int leftX(){
return leftX;
}
public int k(){
return k;
}
public void C_k(int x){
k = x;
}
public int topY(){
return topY;
}
}
Codice:
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Snake extends Nodo
{
private Nodo testa; //inizializzo un oggetto testa di tipo Nodo
private Nodo temp;
private Nodo temp1;
private Ball ball;
private SpecialBall sball;
private Status status;
private boolean hit = false;
private boolean I_eat = false;
private boolean I_seat = false;
public Snake(int width,int height,int leftX,int topY,Ball ball)
{
super(width,height,leftX,topY); //richiamo il costruttore della superclasse
Nodo nodo = new Nodo(width,height,leftX,topY); //Creo un nuovo nodo
//Normalizzo le Coordinate come in una teorica grigli di 10 x 10 pixel
if (leftX % 10 != 0)
leftX -= leftX % 10;
if (topY % 10 != 0)
topY -= topY % 10;
nodo.C_leftX(leftX); //Imposto le nuove Coordinate leftX
nodo.C_topY(topY); //Imposto le nuove Coordinate topY
testa = nodo; //assegno a testa lo stesso reference di nodo cosi entrambi puntano allo stesso indiz. d memoria
temp = testa; //faccio puntare a temp alla testa del serpente
this.ball = ball;
}
//////////////////////////// CREAZIONE E MODIFICA SERPENTE /////////////////////////////////////
//-------------------------------------------------
// Idea della struttura del serpente
// |------------ | | ----------- |
// |testa | succ | -> | nodo | succ | -> null
// |-------------| | ----------- |
//
//-------------------------------------------------
//------------------------------------------
// Name : Create_Snake
// Desc : Crea un serpente iniziale di 5 elementi
// ToDo : Nulla
//--------------------------------------------------
public void Create_Snake(int max,Nodo temp,int leftX,int topY){
for (int i = 1;i<=max;i++){
if (leftX % 10 != 0)
leftX -= leftX % 10;
if (topY % 10 != 0)
topY -= topY % 10;
temp.C_leftX(leftX + temp.width()*i);//imposto il nodo successivo adiacente al nodo precedente
temp.C_succ(new Nodo(10,10,leftX,topY));//assegno al puntatore del nodo successivo un nuovo Nodo
temp = temp.succ();//faccio diventare temp il nuovo nodo
}
temp = testa;
}//End Create_Snake
//------------------------------
// Name : Add
// Desc : Aggiunge una Nodo al serpente.Il nuovo nodo viene aggiunto
// come nuova coda
// ToDo : Nulla ;)
//--------------------------------------------------------------
public void Add ()
{
if (I_eat == true) //Se ho effettivamente mangiato
{
temp = testa; //inizializzo temp a testa
temp1 = temp.succ(); //temp1 al successivo di temp
do
{ //Scorro il serpente fino alla fine
temp = temp.succ();
temp1 = temp1.succ();
}while (temp1.succ() != null);
if (temp1.succ() == null) //Se l'iesimo elemento + 2 punta a nulla
{
if (temp.leftX() == temp1.leftX())//se siamo su un piano verticale
{
if (temp.leftX() < temp1.leftX()){ // Se Vado da Dx a Sx
temp1.C_succ(new Nodo(10,10,temp1.leftX() + 10,temp1.topY()));
}
else{ //Se Vado da Sx a Dx
temp1.C_succ(new Nodo(10,10,temp1.leftX() - 10,temp1.topY()));
}
}
if (temp.topY() == temp1.topY())//se siamo su un piano orizzontale
{
if (temp.topY() < temp1.topY()) {// Vado da Down a UP
temp1.C_succ(new Nodo(10,10,temp1.leftX(),temp1.topY()+10));
}
else{ // Vado da Up a Down
temp1.C_succ(new Nodo(10,10,temp1.leftX(),temp1.topY()-10));
}
}
}//end if fine coda
}//end if eat
}
//////////////////////////////////// MOVIMENTO //////////////////////////////////////////////
//-----------------------------------------
// Name : moveto
// Desc : Funzione ke muove il serpente tramite lo switch sull variabile direction
// Legenda : direction : 1 = SU
// 2 = GIU
// 3 = SX
// 4 = DX
// ToDo : terminare di implementare il movimento
//----------------------------------------------------------------
public Nodo moveto(int direction,Snake snake)
{
temp = snake.testa();
Nodo temp1 = temp.succ();
switch (direction)
{
case 1 :
if ((temp. topY() - 10) != temp1.topY() ) //se il NON serpente si sviluppa verso l'alto
{
snake.testa = new Nodo(10,10,temp.leftX(),temp.topY() - 10); //Alla testa assegno un nuovo nodo
snake.testa.C_succ(temp);//faccio puntare alla nuova testa la vecchia testa
temp = snake.testa;//assegno a temp la nuova testa
temp1 = temp.succ();//assegno a temp1 il successivo a temp
while (temp1.succ() != null)
{
temp = temp.succ(); //passa all'elenmento i-esimo + 1
temp1 = temp1.succ();//passa all'elemento i-esimo + 2
//cancellazione nodo coda
if (temp1.succ() == null)
temp.C_succ(null);
}
temp = snake.testa();
}
break;
case 2:
if ((temp.topY() + 10) != temp1.topY()) //se il NON serpente si sviluppa verso il basso
{
snake.testa = new Nodo(10,10,temp.leftX(),temp.topY()+ 10); //Alla testa assegno un nuovo nodo
snake.testa.C_succ(temp);//faccio puntare alla nuova testa la vecchia testa
temp = snake.testa;//assegno a temp la nuova testa
temp1 = temp.succ();//assegno a temp1 il successivo a temp
while (temp1.succ() != null)
{
temp = temp.succ();
temp1 = temp1.succ();
if (temp1.succ() == null)
temp.C_succ(null);
}
temp = snake.testa();
}break;
case 3:
if ((temp.leftX() - 10) != temp1.leftX()) //se il NON serpente si sviluppa verso sx
{
snake.testa = new Nodo(10,10,temp.leftX() - 10,temp.topY()); //Alla testa assegno un nuovo nodo
snake.testa.C_succ(temp);//faccio puntare alla nuova testa la vecchia testa
temp = snake.testa;//assegno a temp la nuova testa
temp1 = temp.succ();//assegno a temp1 il successivo a temp
while (temp1.succ() != null)
{
temp = temp.succ();
temp1 = temp1.succ();
if (temp1.succ() == null)
temp.C_succ(null);
}
temp = snake.testa();
}
break;
case 4:
if ((temp.leftX() + 10) != temp1.leftX()) //se il NON serpente si sviluppa verso dx
{
snake.testa = new Nodo(10,10,temp.leftX() + 10,temp.topY()); //Alla testa assegno un nuovo nodo
snake.testa.C_succ(temp);//faccio puntare alla nuova testa la vecchia testa
temp = snake.testa;//assegno a temp la nuova testa
temp1 = temp.succ();//assegno a temp1 il successivo a temp
while (temp1.succ() != null)
{
temp = temp.succ();
temp1 = temp1.succ();
if (temp1.succ() == null)
temp.C_succ(null);
}
temp = snake.testa();
}
break;
}//End switch
return temp;
}
////////////////////////////////////// LOGICA DI CONTROLLO ////////////////////////////////////////
//---------------------------------
// Name : Eat
// Desc : Controlla se ho mangiato una pallina
// ToDo : Nulla :D
//------------------------------------------------
public boolean Eat (Ball ball,Nodo testa)
{
if ( (ball.leftX() == testa.leftX()) && (ball.topY() == testa.topY()) )
I_eat = true;
else
I_eat = false;
return I_eat;
}
//-------------------------------------
// Name : SEat
// Desc : Controlla se ho mangiato una pallina Speciale
// ToDo : Cambiare nome al metodo,non vorrei mai mi facessero causa per pubblicita' occuolta :D :D
//-----------------------------------------------------------------------------------------------------
public boolean SEat (SpecialBall sball,Nodo testa)
{
if ( (sball.leftX() == testa.leftX()) && (sball.topY() == testa.topY()) )
I_seat = true;
else
I_seat = false;
return I_seat;
}
//-----------------------------------------
// Name : HitMySelf
// Desc : Controlla se non mi sono colpito da solo
// ToDo : Nulla
//------------------------------------------------------
public void HitMySelf(Nodo testa,Punteggio points)
{
temp = testa.succ();
status = new Status();
do
{
if (testa.leftX() == temp.leftX() && testa.topY() == temp.topY() )
{
temp = temp.succ();
hit = true;
status.Dead(points);
}
else
{
temp = temp.succ();
hit = false;
}
}while (temp.succ() != null);
}
//////////////////////// Funzioni ke ritornano i Value delle variabili Private ////////////////////////////
public void C_testa(Nodo nodo)
{
this.testa = nodo;
}
public Nodo testa()
{
return testa;
}
public void C_hit(boolean value)
{
hit = value;
}
public boolean hit()
{
return hit;
}
}
Codice:
public class Nodo{
private int height;//ALtezza
private int width;//larghezza
private int leftX;//Coordinata X angolo sx superiore
private int topY;//Coordinata angolo SX superiore
private Nodo succ; // Puntatore a Nodo successivo
public Nodo(int width,int height,int leftX,int topY)
{
this.leftX = leftX;
this.topY = topY;
this.height = height;
this.width = width;
this.succ = null; //inizializzo a null il puntatore all'oggetto successivo
}//End void Nodo()
//------------------------------
// Name : C_Height
// Desc : cambia il valore della variabile height
// ToDo : Nulla ;)
//------------------------------------------------
public void C_height(int height){
this.height = height;
}
//------------------------------
// Name : C_width
// Desc : cambia il valore della variabile width
// ToDo : Nulla ;)
//------------------------------------------------
public void C_width(int width){
this.width = width;
}
//------------------------------
// Name : C_left
// Desc : cambia il valore della variabile leftX
// ToDo : Nulla ;)
//------------------------------------------------
public void C_leftX(int leftX){
this.leftX = leftX;
}
//------------------------------
// Name : C_topY
// Desc : cambia il valore della variabile topY
// ToDo : Nulla ;)
//------------------------------------------------
public void C_topY(int topY){
this.topY = topY;
}
//------------------------------
// Name : C_succ
// Desc : Cambia l'indirizzo di memoria al quale punta succ
// ToDo : Nulla ;)
//------------------------------------------------
public void C_succ(Nodo succ){
this.succ = succ;
}
//FUNZIONI KE RITORNATO I VALORI DELLE VARIABILI PRIVATE
public int height(){
return height;
}
public int width(){
return width;
}
public int leftX(){
return leftX;
}
public int topY(){
return topY;
}
public Nodo succ(){
return succ;
}
}//End class Nodo
Codice:
//
// Classe che genera numeri casuali,
// migliore del random di sistema
//
public class RandomGenerator {
//
// get(): restituisce un numero compreso tra 0 e 1
//
public double get()
{
//
// Costanti
//
final int a = 16087;
final int m = 2147483647;
final int q = 127773;
final int r = 2836;
//
// Variabili
//
double lo, hi, test;
hi = Math.ceil(seed / q);
lo = seed - q * hi;
test = a * lo - r * hi;
if (test < 0.0) {
seed = test + m;
} else {
seed = test;
} /* endif */
return seed / m;
}
//
// getSeed(): restituisce il valore corrente del seme
//
public double getSeed()
{
return seed;
}
//
// setSeed(s): imposta il valore del seme a s
//
public void setSeed(double s)
{
seed = s;
}
//
// costruttore della classe, genera un'istanza di RandomGenerator,
// fissando il seme iniziale a s.
//
public RandomGenerator(double s)
{
seed = s;
}
private double seed;
}
3NiGm@666 Ultima modifica di 3nigma666 : 19-05-2005 alle 10:25. |
|
|
|
19-05-2005, 08:55
|
#2 |
|
Senior Member
Iscritto dal: Jan 2001
Città: Milano
Messaggi: 5707
|
hai messo due volte il sorgente di SpecialBall.java e mai quello di Mappa.java.
Ma non potevi fare uno zip e allegarlo, son 5 minuti che copioincollo  
|
|
|
|
|
19-05-2005, 10:23
|
#3 |
|
Senior Member
Iscritto dal: Jan 2005
Città: A casa mia
Messaggi: 825
|
corretta il problema di 2 specialball e niente mappa..come facci oad allegare sul forum il file??ci avevo pensato anke io..ma nn sapevo come fare..
|
|
|
|
|
|
| Strumenti | |
|
|
Tutti gli orari sono GMT +1. Ora sono le: 16:49.
