Schleife?

Megawurrrm

Hey Leute,

Ich schreibe gerade Tetris um mal zu gucken wie die Array Feld[x][y] sich verhält
bis jetzt klappt alles ganz gut außer das hier:

for(y=2;y<=19;y++)
     {
      if(
      feld [2][y]==4 && 
      feld [3][y]==4 && 
      feld [4][y]==4 && 
      feld [5][y]==4 && 
      feld [6][y]==4 && 
      feld [7][y]==4 && 
      feld [8][y]==4 && 
      feld [9][y]==4 && 
      feld [10][y]==4 && 
      feld [11][y]==4 && 
      feld [12][y]==4 && 
      feld [13][y]==4 && 
      feld [14][y]==4 && 
      feld [15][y]==4 && 
      feld [16][y]==4 && 
      feld [17][y]==4 && 
      feld [18][y]==4 && 
      feld [19][y]==4)
       { 
         score++;                
         for(x=2;x<=19;x++)
           {
             feld[x][y]=1;
           }
      }
     }

Er schaut ob in meinem Spielfeld x>2 bis x<19 alle felder ==4 sind (4 heist einfach nur belegt) wenn das der Fall ist setzt er einen Punkt (score) hoch und setzt das Feld auf 'Leer'(==1)

in der untersten Reihe funktioniert das super nur in sonst keiner weiteren

mfg
Megawurrrm

DarkShadow44

Hm anhand dieses Codestücks kann ich das nicht sagen. Es sieht aber danach aus dass du über die Arraygrenzen hinausgehst:

Spielfeld x>2 bis x<19

aber

for(x=2;x<=19;x++)

Und diese große if-Abfrage würde ich auch mit ner Schleife vereinfachen.

Megawurrrm

die Grenze ist 20

ja das mit der Schlreife ist noch so ein Problem

ziemlich knifflieger fehler^^

#include <cstdlib>
#include <iostream>
#include <conio2.h>
#include <windows.h>

using namespace std;
int feld[20][20];
int x=1;
int y=1;
int stein_x=10;
int stein_y=2;
char tastendruck;
int score=1;
int x2=19;
int y2=19;

void null_setzen()
  {
    for(x=1;x<=20;x++)
    {
      for(y=1;y<=20;y++)
      {
        feld[x][y]=1;
      }
    }
  }
void spielfeld()
  {
    for (x=1;x<=20;x++)
    {
        feld[x][1]=2;
        feld[x][20]=2;
    }
    for (y=1;y<=20;y++)
    {
        feld[1][y]=3;
        feld[20][y]=3;
    }
  }
void darstellen()
  {
    gotoxy(40,10);
    cprintf("score: %i ",score);
    gotoxy(40,11);
    cprintf("stein_x: %i ",stein_x);
    gotoxy(40,12);
    cprintf("stein_y: %i ",stein_y);
    for(x=1;x<=20;x++)
    {
      for(y=1;y<=20;y++)
      {
        gotoxy(x,y);
        if (feld[x][y]==1)
          {
            cprintf(" ");
          }
        if (feld[x][y]==2)
          {
            cprintf("-");
          }
        if (feld[x][y]==3)
          {
            cprintf("|");
          }
        if (feld[x][y]==4)
          {
            cprintf("#");
          }
      }
    }
  }
void reihe()
  {
    for(y=2;y<=19;y++)
     {
      if(
      feld [2][y]==4 && 
      feld [3][y]==4 && 
      feld [4][y]==4 && 
      feld [5][y]==4 && 
      feld [6][y]==4 && 
      feld [7][y]==4 && 
      feld [8][y]==4 && 
      feld [9][y]==4 && 
      feld [10][y]==4 && 
      feld [11][y]==4 && 
      feld [12][y]==4 && 
      feld [13][y]==4 && 
      feld [14][y]==4 && 
      feld [15][y]==4 && 
      feld [16][y]==4 && 
      feld [17][y]==4 && 
      feld [18][y]==4 && 
      feld [19][y]==4)
       { 
         score++;                
         for(x=2;x<=19;x++)
           {
             feld[x][stein_y]=1;
           }
      }
     }
  }
void stein1()
  {
    stein_x=10;
    stein_y=3;
    while(stein_y!=19)
      {
       if(feld[stein_x][stein_y+1]==1 || feld[stein_x][stein_y+1]==2)
        {
         feld[stein_x][stein_y]=1;
         stein_y++;
         feld[stein_x][stein_y]=4;
         darstellen();
         if(kbhit() && stein_y<19  )
           {
             tastendruck=getch();
             switch(tastendruck)
               {
                  case'a':
                          feld[stein_x][stein_y]=1;
                          stein_x--;
                          if (stein_x<=1)
                            {
                              stein_x++;
                            }
                       break;
                  case'd':
                          feld[stein_x][stein_y]=1;
                          stein_x++;
                          if (stein_x>=20)
                            {
                              stein_x--;
                            }
                       break;
                  case 'c':
                        for(x2=2;x2<=18;x2++)
                          {
                             feld[x2][y2]=4;
                          }
                          y2--;
                       break;
                  default:
                          while(tastendruck != 'a' && tastendruck != 'd')
                            {
                               gotoxy(8,10);
                               cprintf("<<Pause>>");
                               tastendruck=getch();
                            }
                       break;
               }
           }
         Sleep(50);
        }
       else
        {
          stein_x=10;
          stein_y=3;
        }
      }
  }

int main(int argc, char *argv[])
{
  null_setzen();
  spielfeld();
  int x2=5;
  while(x2==5)
    {
      stein1(); 
      reihe();
    }
    getch();
    system("PAUSE");
    return EXIT_SUCCESS;
}

Bei einem Array mit 20 Elementen dürfen die Indexe von 0 bis 19 laufen. Und die Laufvariable einer for-Schleife global zu definieren ist auch eine ziemlich dumme Idee!

for( int x = 0; x < 20; ++x)

Megawurrrm

k habe die array auf 25 gesetzt da tut sich aber nichts
- bei einer lokalen difinition verändert sich auch nichts

habt ihr vielleicht eine idee wie ich alternativ die reihen überprüfen könnte?
dan kann ich mir dieses Gravurstück vielleicht sparen ^^

danke für die hilfe

Alter, ersetz mal die riesige if abfrage durch eine Funktion

Megawurrrm

gerne welche funktion ?

Eine selbst geschriebene.

Megawurrrm

davon mal abgesehen weiß ich leider noch nciht wirklich wo das problem mit den reihen ist