Giochino per voi

[cn73]

EHm...non avevo molto da fare oggi al lavoro

Quanti punti riuscite a fare??
Se interessa posto anche il codice java.

Nuova versione col codice di cionci!

[cn73]

Ecco il mio record!

[cionci]

Assasssssinoooo !!! :o Non riesco a smettere di giocarci

Per ora sono arrivato a 39...già lì se te ne tocca uno sul bordo è finita !!!

[cn73]

Dai che dopo 32 mele mangiate la velocità si blocca (vedi output della console java ) Il record attuale è di 59 fatto da un mio amico

[Louder Than Hell]

eeh..cavolo che invidia voi vi mettete a fare giochi quando non avete niente da fare tanto per..........

[cn73]

Mi ripago delle 40 ore di straordinario fatte il mese scorso...

[recoil]

carino dai :-)

dimenticavo, io ho fatto 32 punti ma ci ho giocato solo un paio di volte
se metti il codice java modifico qualcosa e lo rallento un attimo perché diventa veramente troppo veloce poi...

[cn73]

Si lo scopo era proprio quello di commentare il codice e migliorarlo Anche la mela, non mi piace quadrata! DOmani lo posto.

[cionci]

C'è un bug...se la mela appare sotto il serpente resta un po' bruttina

[cn73]

Ecco il codice... la classe java.awt.Graphics2D permetterebbe di usare "effetti" grafici migliori, ma la Microsoft JVM non supporta il jdk 1.2 (Brava Microsoft! :mad)

E' sicuramente migliorabile, possiamo divertirci a farlo se volete!

import java.awt.*;
import java.awt.event.*;
import java.applet.*;
import java.awt.Graphics;
//import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Event;

public class Snake extends Applet implements Runnable{

	static final int rows = 15;
	static final int columns = 25;
	
	static final Font font = new Font("Arial",Font.BOLD, 12);
  
  boolean gioco = false, mangiato=false, gioco2=false, playing=false;
  int size, hsize=0, speed=200;

  Point[] posizioni = new Point[374];

  int direzione = 0;  // 0 - destra
			                // 1 - sinistra
			                // 2 - su
			                // 3 - giù

  Point mela = new Point(12,7);

  Thread runner;

  public void init() {
  	
  	System.out.println("Init applet -> keyEvent added");
  	
  	KeyListener keyListener = new KeyAdapter() {
     
			public void keyPressed(KeyEvent keyEvent) {
					
			 
			 int key = keyEvent.getKeyCode();
			 //System.out.println("Key Pressed : "+ key);
			         
			 if(key == KeyEvent.VK_RIGHT && posizioni[1].x!=posizioni[0].x+1) { direzione=0; gioco=true; playing=true;  }
			 else if(key == KeyEvent.VK_LEFT && posizioni[1].x!=posizioni[0].x-1) { direzione=1; gioco=true; playing=true;  }
			 else if(key == KeyEvent.VK_UP && posizioni[1].y!=posizioni[0].y-1) { direzione=2; gioco=true; playing=true;  }
			 else if(key == KeyEvent.VK_DOWN && posizioni[1].y!=posizioni[0].y+1) { direzione=3; gioco=true; playing=true;  }
			 else if(key == KeyEvent.VK_ESCAPE) 
			   playing=false;
      
      }
		};
  	
  	addKeyListener(keyListener);
  	
    size=3;

    for(int i=0; i<374; i++)
     posizioni[i] = new Point(0,0);

    posizioni[0].move(3,rows);
    posizioni[1].move(2,rows);
    posizioni[2].move(1,rows);          
  }

  public void start() {
    if(runner==null) {
    	runner = new Thread(this);
      runner.start();
     }
  }

  public void stop() {
    runner = null;
  }

  public void run() {
          
    Thread thisThread = Thread.currentThread();
    while (thisThread == runner){
    
     // Il gioco finisce se si sbatte contro il muro oppure ci si morde la coda
     for(int i=5; i<size; i++)
       if(posizioni[0].x == posizioni[i].x && posizioni[0].y == posizioni[i].y)
          gioco2 = true;

     if(( (gioco2) || (direzione==0 && posizioni[0].x==columns) 
     		|| (direzione==1 && posizioni[0].x==1) || (direzione==2 && posizioni[0].y==1) 
     			|| (direzione==3 && posizioni[0].y==rows))) {
            // risetta gli start points
         gioco = false;
         gioco2 = false;
         if(size>hsize) hsize=size;
         size=3;
         posizioni[2].move(1,rows);
         posizioni[1].move(2,rows);
         posizioni[0].move(3,rows);
         mela.move(12,7);
     }

     repaint();
     
          	
     try{
      
     //setta la velocità del serpente.
       	Thread.sleep(speed);      
     }
     catch(InterruptedException e) { }

    }
  }

  public void update(Graphics g) {
  				
  	//Graphics2D g = (Graphics2D)g1;
  	
  	//g.setBackground(Color.black);
  			
  	g.setColor(Color.red);
    g.fill3DRect(mela.x*20-20,mela.y*20-20,19,19,false);
    if(gioco)     {
			g.setColor(Color.blue);
      if(posizioni[0].x==mela.x && posizioni[0].y==mela.y) {
        mangiato=true;
        size++;
        
        g.clearRect(0,0,getSize().width,12);
      }
      // Disegna la nuova posizione e cancella quella vecchia

      g.clearRect(posizioni[size-1].x*20-20,posizioni[size-1].y*20-20,21,21);

      if(posizioni[size-1].x == mela.x && posizioni[size-1].y == mela.y)
       	g.drawRoundRect(mela.x*20-20,mela.y*20-20,19,19,19,19);
              

      if(playing) {
      	for(int i=size; i>0; i--)
        	posizioni[i].move(posizioni[i-1].x, posizioni[i-1].y);

	      switch(direzione) {
	      	case 0: posizioni[0].x = posizioni[0].x+1; break;
	        case 1: posizioni[0].x = posizioni[0].x-1; break;
	        case 2: posizioni[0].y = posizioni[0].y-1; break;
	        case 3: posizioni[0].y = posizioni[0].y+1; break;
	      }
      }

      // Controllo se la mela è stata mangiata
      									
      for(int i=0; i<size; i++)                  				
      	g.fillOval(posizioni[i].x*20-20,posizioni[i].y*20-20,20,20);
              
      if(mangiato) {
      	mangiato = false;
        g.clearRect(mela.x*20-20,mela.y*20-20,21,21);
        mela.x=(int)(Math.random()*24+1);
        mela.y=(int)(Math.random()*14+1);
        //g.drawRoundRect(mela.x*20-20,mela.y*20-20,19,19,19,19);
        g.setColor(Color.red);
        g.fill3DRect(mela.x*20-20,mela.y*20-20,19,19,false);
        if (speed >= 50){
        	speed -=5;
        	System.out.println("curr speed: "+ speed);
        }	
                
      }        
     }
     else {
     	// Pulisci schermo e inizializza gli oggetti
      g.clearRect(0,0,getSize().width,getSize().height);
			
			g.setColor(Color.blue);
      for(int i=0; i<size; i++)
              g.fillOval(posizioni[i].x*20-20,posizioni[i].y*20-20,20,20);
			g.setColor(Color.red);
      //g.drawRect(mela.x*20-20,mela.y*20-20,19,19);
      g.fill3DRect(mela.x*20-20,mela.y*20-20,19,19,false);
      speed = 200;
      
     }
     g.setFont(font);
     g.setColor(Color.magenta);
     g.drawString("Punteggio: "+ (size -3) + (hsize == 0 ? "" : ("           Miglior Punteggio: "+ (hsize-3))) ,10,10);    
          
          
  } 			

}

[cn73]

Originally posted by "cionci"

C'è un bug...se la mela appare sotto il serpente resta un po' bruttina

Hai ragione! Chi lo risolve??

[recoil]

io proprio non ho tempo in sti giorni :-(
in ogni caso la mela non dovrebbe proprio comparire sotto il serpente, almeno nello snake dei nokia non è così...

[Cimmo]

Originally posted by "cn73"



Hai ragione! Chi lo risolve??

Non e' la soluzione + bella del mondo, ma dovrebbe ri-randomizzare il punto della mela se ne viene beccato uno dove c'e' gia' il serpente.
Va' al posto dei 2 random che generano un punto a caso per la nuova mela...il repeat until io l'ho scritto in C, e' uguale in Java che non lo so?

do
{
	int flag=0;

	mela.x=(int)(Math.random()*24+1); 
	mela.y=(int)(Math.random()*14+1);

	for (int i=0; i<size; i++)
		if ((mela.x==posizioni[i].x) && (mela.y==posizioni[i].y))
			flag=1;

} while (flag==1);

[cn73]

Oh scusa me l'ero persa!
Si e è la soluzione + semplice, ma secondo me si può fare qualcosa di meglio

[cionci]

Originally posted by "cn73"

Si e è la soluzione + semplice, ma secondo me si può fare qualcosa di meglio

In teoria (lo so ceh è contro le leggi della probabilità), con un ciclod el genere potrebbe looppare infinitamente (Murphy docet)...
Quindi è meglio non prendere nuovamente numeri casuali, ma fare la ricerca di una posizione libera...ad esempio spostandosi in diagonale fino a quando non si trova una posizione libera...

[cionci]

Una cosa del genere direi...

mela.x=(int)(Math.random()*24+1); 
mela.y=(int)(Math.random()*14+1);
do
{
	int flag = 0;
	for (int i=0; i<size && !flag; i++)
		if ((mela.x==posizioni[i].x) && (mela.y==posizioni[i].y))
			flag=1;

	if(flag)
	{
		mela.x = (mela.x % 24) + 1;
		mela.y = (mela.y % 14) + 1;
	}
} while (flag);

[Cimmo]

Se non lo becca al primo colpo va' in loop quel codice...

[cionci]

Originally posted by "Cimmo"

Se non lo becca al primo colpo va' in loop quel codice...

Dettagli...avevo tolto "int flag=0" dal ciclo...

[cionci]

Questo è un ottimo metodo...per altro esaustivo...

	int startx = mela.x=(int)(Math.random()*24+1); 
	int starty = mela.y=(int)(Math.random()*14+1); 
	const int szx = 24, szy = 14;
	
	do {
		int flag = 0; 
		for (int i=0; i<size && !flag; i++) 
			if ((mela.x==posizioni[i].x) && (mela.y==posizioni[i].y)) 
				flag=1; 
		if(flag)
		{
			mela.x--;
			mela.y++;
			if(mela.x < 1 || mela.y > szy)
			{
				int z = mela.x + mela.y + 1;
				if(z > (szx+szy))
				{
					mela.x = 1;
					mela.y = 1;
				}
				else if(z > szx)
				{
					mela.x = szx;
					mela.y = z - mela.x;
				}
				else
				{
					mela.y = 1;
					mela.x = z - 1;
				}
			}
			if(startx == mela.x && starty == mela.y)
				throw //una eccezione
		}
	}while(flag);

[cn73]

HAi ragione coinci...anche se è praticamente impossibile (un po' come vincere al supoerenalotto ogni settimana 2 volte per tutta la vita ) non conviene usare quel codice... Il tuo sistema mi pare il migliore... Ma senti qua: ipotizziamo che nello schermo non esstano celle libere