ABS
Another brick shooter


To view this content, you need to install Java from java.com

Il gioco ha una lontanissima parentela con BrickShooter
Mouse
seleziona e lancia il pezzo
Regole del gioco
  1. Devi eliminare i quadrati colorati presenti all'interno della tavola 8x8 utilizzando i quadrati dello stesso colore nelle 2 cornici esterne
  2. Solo i quadrati nella cornice interna possono essere utilizzati mentre quelli nella cornice esterna prendono il loro posto
  3. Dopo aver lanciato un quadrato esso si muove sulle caselle vuote e si ferma appena trova un ostacolo
  4. Le configurazioni con 3 o più quadrati dello stesso colore all'interno del quadrato 3x3 con al centro il quadrato appena lanciato scompaiono
  5. A ogni livello (20) aumentano i quadrati da eliminare o il numero di colori

I pezzi sono disegnati come rettangoli colorati... la versione successiva utilizzerà delle piacevoli immagini.

Codice
final int numELEM=12, maXCOLORI=6, livMAX=18,
          SPENTO=0, ACCESO=1,
          noDIR=-1, NS=1, EO=2, SN=3, OE=4;
boolean   LANCIABILE;
int       passoELEM, RIGA, COLONNA,
          numCOLORI, numLIVELLO;
         
char      VUOTO=' ', PIENO='#';

color     cVUOTO, cATTIVATO, cACCESO, cSPENTO, cMESSAGGI;
color[]   COLORI=new color[maXCOLORI];

cubo[][]  GIOCO=new cubo[numELEM][numELEM];

int[]     livCUBI  = new int[livMAX];
int       livCONT;
int[]     livCOLORI= new int[livMAX];
int       Xtesto;
PFont     FONT;

void setup()
{
  size(481, 481); rectMode(CORNER); smooth();

  LANCIABILE=false;
//  FONT=loadFont("Meta-Bold.vlw.gz"); textFont(FONT, 24);

  // dimensioni varie
  passoELEM=height/numELEM; Xtesto=height+30;
 
  numLIVELLO=0; numCOLORI=livCOLORI[numLIVELLO];
 
  livCUBI[0 ]=1;   livCUBI[1 ]=2;   livCUBI[2 ]=3;   livCUBI[3 ]=3;   livCUBI[ 4]=4;   livCUBI[ 5]=5;
  livCUBI[6 ]=5;   livCUBI[7 ]=6;   livCUBI[8 ]=7;   livCUBI[9 ]=7;   livCUBI[10]=8;   livCUBI[11]=9;
  livCUBI[12]=9;   livCUBI[13]=10;  livCUBI[14]=10;  livCUBI[15]=10;  livCUBI[16]=10;  livCUBI[17]=10;  
 
  livCOLORI[0 ]=1; livCOLORI[1 ]=1; livCOLORI[2 ]=1; livCOLORI[3 ]=2; livCOLORI[ 4]=2; livCOLORI[ 5]=2;
  livCOLORI[6 ]=3; livCOLORI[7 ]=3; livCOLORI[8 ]=3; livCOLORI[9 ]=4; livCOLORI[10]=4; livCOLORI[11]=4;
  livCOLORI[12]=5; livCOLORI[13]=5; livCOLORI[14]=5; livCOLORI[15]=6; livCOLORI[16]=6; livCOLORI[17]=6;
 
  cVUOTO=color(0, 0, 0); cATTIVATO=color(255, 255, 255); cACCESO=color(150, 150, 150); cSPENTO=color(50, 50, 50);
  cMESSAGGI=color(200, 200, 200);

  COLORI[0]=color(255,   0, 0); COLORI[1]=color(  0, 0, 255); COLORI[2]=color(0, 255,   0);
  COLORI[3]=color(255, 255, 0); COLORI[4]=color(0, 255, 255); COLORI[5]=color(255, 0, 255);

  // parti...
  creaGIOCO();

  LANCIABILE=true;
}

void creaGIOCO()
{
  // TUTTI VUOTI...
  for(int r=0; r < numELEM; r++)
  for(int c=0; c < numELEM; c++)
    GIOCO[r][c]=new cubo(r, c, cVUOTO, VUOTO, SPENTO);

  // 1°, 2° ... colonne
  for(int r=2; r < numELEM-2; r++)
  {
    GIOCO[r][0        ]=new cubo(r, 0,         COLORI[(int)random(0, livCOLORI[numLIVELLO])], PIENO, SPENTO);
    GIOCO[r][1        ]=new cubo(r, 1,         COLORI[(int)random(0, livCOLORI[numLIVELLO])], PIENO, SPENTO);
    GIOCO[r][numELEM-2]=new cubo(r, numELEM-2, COLORI[(int)random(0, livCOLORI[numLIVELLO])], PIENO, SPENTO);
    GIOCO[r][numELEM-1]=new cubo(r, numELEM-1, COLORI[(int)random(0, livCOLORI[numLIVELLO])], PIENO, SPENTO);
  }
  // 1°, 2°, ... righe
  for(int c=2; c < numELEM-2; c++)
  {
    GIOCO[0        ][c]=new cubo(0,         c, COLORI[(int)random(0, livCOLORI[numLIVELLO])], PIENO, SPENTO);
    GIOCO[1        ][c]=new cubo(1,         c, COLORI[(int)random(0, livCOLORI[numLIVELLO])], PIENO, SPENTO);
    GIOCO[numELEM-2][c]=new cubo(numELEM-2, c, COLORI[(int)random(0, livCOLORI[numLIVELLO])], PIENO, SPENTO);
    GIOCO[numELEM-1][c]=new cubo(numELEM-1, c, COLORI[(int)random(0, livCOLORI[numLIVELLO])], PIENO, SPENTO);
  }

  livCONT=livCUBI[numLIVELLO];
 
  for(int i=1; i <= livCONT; i++)
  {
      int r, c;
     
      do{
         r=(int)random(3, numELEM-3);
         c=(int)random(3, numELEM-3);
      }while(GIOCO[r][c].tipo != VUOTO);
     
      GIOCO[r][c]=new cubo(r, c, COLORI[(int)random(0, livCOLORI[numLIVELLO])], PIENO, SPENTO);
  }    

  // il primo cubo acceso...
  RIGA=0; COLONNA=0;
  GIOCO[RIGA][COLONNA].accendi();
 
  LANCIABILE=true;
}

void spegnitutti(int r, int c)
{
  int cont=1;
  color co=GIOCO[r][c].colore;
  boolean[] vicini={false, false, false, false, false, false, false, false};

  if(GIOCO[r-1][c-1].colore==co && !GIOCO[r-1][c-1].attivabile) { cont++; vicini[0]=true; }
  if(GIOCO[r-1][c  ].colore==co && !GIOCO[r-1][c  ].attivabile) { cont++; vicini[1]=true; }
  if(GIOCO[r-1][c+1].colore==co && !GIOCO[r-1][c+1].attivabile) { cont++; vicini[2]=true; }
  if(GIOCO[r  ][c-1].colore==co && !GIOCO[r  ][c-1].attivabile) { cont++; vicini[3]=true; }
  if(GIOCO[r  ][c+1].colore==co && !GIOCO[r  ][c+1].attivabile) { cont++; vicini[4]=true; }
  if(GIOCO[r+1][c-1].colore==co && !GIOCO[r+1][c-1].attivabile) { cont++; vicini[5]=true; }
  if(GIOCO[r+1][c  ].colore==co && !GIOCO[r+1][c  ].attivabile) { cont++; vicini[6]=true; }
  if(GIOCO[r+1][c+1].colore==co && !GIOCO[r+1][c+1].attivabile) { cont++; vicini[7]=true; }

  if(cont >= 3)
  {
    GIOCO[r][c]=new cubo(r, c, cVUOTO, VUOTO, SPENTO);

    if(vicini[0]) GIOCO[r-1][c-1]=new cubo(r-1, c-1, cVUOTO, VUOTO, SPENTO);
    if(vicini[1]) GIOCO[r-1][c  ]=new cubo(r-1, c  , cVUOTO, VUOTO, SPENTO);
    if(vicini[2]) GIOCO[r-1][c+1]=new cubo(r-1, c+1, cVUOTO, VUOTO, SPENTO);
    if(vicini[3]) GIOCO[r  ][c-1]=new cubo(r  , c-1, cVUOTO, VUOTO, SPENTO);
    if(vicini[4]) GIOCO[r  ][c+1]=new cubo(r  , c+1, cVUOTO, VUOTO, SPENTO);
    if(vicini[5]) GIOCO[r+1][c-1]=new cubo(r+1, c-1, cVUOTO, VUOTO, SPENTO);
    if(vicini[6]) GIOCO[r+1][c  ]=new cubo(r+1, c  , cVUOTO, VUOTO, SPENTO);
    if(vicini[7]) GIOCO[r+1][c+1]=new cubo(r+1, c+1, cVUOTO, VUOTO, SPENTO);
   
    livCONT-=cont;
  }
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class cubo
{
  int riga, colonna; color colore; char tipo; int stato; boolean attivabile; int dir;

  cubo(int ri, int co, color c, char ti, int s)
  {
    riga=ri;  colonna=co; colore=c; tipo=ti; stato=s;

    attivabile= (riga == 1 || riga == numELEM-2) && (colonna >  1 && colonna <  numELEM-2)
    || (riga >  1 && riga <  numELEM-2) && (colonna == 1 || colonna == numELEM-2);

    dir=noDIR;
  }

  //////////////////////////////////////////////////////// usata per il debugging...
  void dump()
  {
    print("\n" + riga + ", " + colonna + ": colore " + colore +
          " tipo " + tipo + " stato " + stato + " att " + attivabile + " dir " + dir);
  }
  ///////////////////////////////////////////////////////////////////////////////////
 
  void setdir(int d) { dir=d;        }
  int  getdir()      { return dir;   }
  void accendi()     { stato=ACCESO; }
  void spegni()      { stato=SPENTO; }

  void lancia()
  {
    int  newR, newC, newDIR,
    oldR, oldC;
    cubo newCU, oldCU;
   
    newR=riga; newC=colonna; newDIR=noDIR;
    if(riga==1)                  { newR=2;         newDIR=NS; }
    else if(riga==numELEM-2)     { newR=riga-1;    newDIR=SN; }
    else if(colonna==1)          { newC=2;         newDIR=OE; }
    else if(colonna==numELEM-2)  { newC=colonna-1; newDIR=EO; }

    if(GIOCO[newR][newC].tipo==VUOTO)
    {
      GIOCO[newR][newC]=new cubo(newR, newC, colore, PIENO, SPENTO);
      GIOCO[newR][newC].setdir(newDIR);
      oldR=riga; oldC=colonna;
      switch(newDIR)
      {
        case NS: oldR=riga-1;    break;
        case SN: oldR=riga+1;    break;
        case OE: oldC=colonna-1; break;
        case EO: oldC=colonna+1; break;
        default: println("errore..................");
      }
      GIOCO[riga][colonna]=new cubo(riga, colonna, GIOCO[oldR][oldC].colore, PIENO, ACCESO);
      accendi();
      GIOCO[oldR][oldC]=new cubo(oldR, oldC, COLORI[(int)random(0, livCOLORI[numLIVELLO])], PIENO, SPENTO);
     
      livCONT++;
    }
  }

  void aggiorna()
  {
    int newR=riga; int newC=colonna;

    if(dir==NS)      { newR=riga+1;    }
    else if(dir==SN) { newR=riga-1;    }
    else if(dir==OE) { newC=colonna+1; }
    else if(dir==EO) { newC=colonna-1; }

    if(GIOCO[newR][newC].tipo==VUOTO)
    {
      GIOCO[newR][newC]=new cubo(newR, newC, colore, PIENO, SPENTO);
      GIOCO[newR][newC].setdir(getdir());
      GIOCO[riga][colonna]=new cubo(riga, colonna, cVUOTO, VUOTO, SPENTO);
    }
    else
    {
      setdir(noDIR);
      spegnitutti(riga, colonna);
    }
  }

  void draw()
  {
    fill(colore);
    if(tipo==VUOTO)
    {
      if(stato==ACCESO) stroke(cACCESO);
      else              stroke(cSPENTO);
      rect(passoELEM*colonna+2, passoELEM*riga+2, passoELEM-4, passoELEM-4);
    }
    else if(attivabile)
    {
      if(stato==ACCESO){stroke(cATTIVATO); rect(passoELEM*colonna, passoELEM*riga, passoELEM, passoELEM);        }
      else             {stroke(cSPENTO);   rect(passoELEM*colonna+2, passoELEM*riga+2, passoELEM-4, passoELEM-4);}
    }
    else
    {
      if(stato==ACCESO){stroke(cACCESO);   rect(passoELEM*colonna+1, passoELEM*riga+1, passoELEM-2, passoELEM-2);}
      else             {stroke(cSPENTO);   rect(passoELEM*colonna+2, passoELEM*riga+2, passoELEM-4, passoELEM-4);}
    }
  }
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void draw()
{
  if(livCONT==0)
  {
     if(numLIVELLO < livMAX-1)
        numLIVELLO++;
     creaGIOCO();
  }  

  GIOCO[RIGA][COLONNA].spegni();
  RIGA=constrain(mouseY/passoELEM, 0, numELEM-1);
  COLONNA=constrain(mouseX/passoELEM, 0, numELEM-1);
  GIOCO[RIGA][COLONNA].accendi();
               
  background(0);
  for(int r=0; r < numELEM; r++)
  for(int c=0; c < numELEM; c++)
    if(GIOCO[r][c].getdir() != noDIR)
       GIOCO[r][c].aggiorna();

  for(int r=0; r < numELEM; r++)
  for(int c=0; c < numELEM; c++)
    GIOCO[r][c].draw();
/*    
  fill(cMESSAGGI);
  text("Livello: " + (numLIVELLO+1)       , Xtesto, +60);
  text("Colori: "  + livCOLORI[numLIVELLO], Xtesto, +90);
  text("Pezzi: "   + livCONT              , Xtesto, +120);
*/

}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void mousePressed()
{
  if(LANCIABILE)
  {    
     if(GIOCO[RIGA][COLONNA].attivabile)
     {
        LANCIABILE=false;
        GIOCO[RIGA][COLONNA].lancia();
        LANCIABILE=true;
     }
       
  }
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
There are no comments on this page.
Valid XHTML :: Valid CSS: :: Powered by WikkaWiki