Tetris Programmierung

07/04/2011 16:01 Coding Lounge#1
Hey Leute, ich muss in der Schule bis Freitag ein Tetris programmiert haben (In C).
Ich habe jedenfalls ein paar Probleme damit. Bisheriger Programmcode:


Ich check nicht wie ich hier weiterkomme, kann mir wer helfen, bzw. mir den Programmcode seines oder eines anderen Tetris in dieser Art schicken?

Würde mich sehr darüber freuen

Mfg

TheSidewinder
07/04/2011 16:05 Obilee#2
Quote:
spielfeld[1][12] = 0;
spielfeld[2][12] = 0;
spielfeld[3][12] = 0;
spielfeld[4][12] = 0;
spielfeld[5][12] = 0;
spielfeld[6][12] = 0;
spielfeld[7][12] = 0;
spielfeld[8][12] = 0;
spielfeld[9][12] = 0;
spielfeld[10][12] = 0;
spielfeld[11][12] = 0;
spielfeld[12][12] = 0;
spielfeld[13][12] = 0;
Wenn ich schon sowas sehe wird mir schlecht. Schleifen 4tw ? :O

#moved
07/04/2011 16:33 S7ZY#3
Quote:
Originally Posted by Obilee View Post
Wenn ich schon sowas sehe wird mir schlecht. Schleifen 4tw ? :O

#moved
Obi bist du wirklich krank?

wieso movst du diesen Thread in den OT?
ab damit in die Coder-section LOL
07/04/2011 16:51 Obilee#4
Der ist in der Coder Sektion und wurde vom OT hierher gemoved. Das was du im OT siehst ist nur ein Temporärer Verweis...


@TE: ein paar comments im code wären gut und sagen wo du genau nicht weiter kommst.
07/04/2011 17:23 Coding Lounge#5
Quote:
Originally Posted by Obilee View Post
Wenn ich schon sowas sehe wird mir schlecht. Schleifen 4tw ? :O
Das mit den Schleifen hab ich schon korrigert. Mir geht es mehr darum wo die Blöcke runterfallen, dass die unten anhalten und son zeugs

Quote:
@TE: ein paar comments im code wären gut und sagen wo du genau nicht weiter kommst.
Kommentare folgen noch, zuerst will ich, dass das Programm steht
07/04/2011 17:57 Endtothenight#6
Quote:
Originally Posted by TheSidewinder View Post
Kommentare folgen noch, zuerst will ich, dass das Programm steht
Nur mal so am Rande, wenn man will, dass das Program läuft braucht man ein bischen Überblick und dazu braucht man Kommentare.

Kommentare sind der erste Schritt zur Lösung...
07/04/2011 18:07 Coding Lounge#7
Quote:
Originally Posted by Endtothenight View Post
Nur mal so am Rande, wenn man will, dass das Program läuft braucht man ein bischen Überblick und dazu braucht man Kommentare.

Kommentare sind der erste Schritt zur Lösung...
Wo du recht hast hast du recht ;)

Ich hab den Quelltext mal grob kommentiert also die wichtigsten Sachen:

Code:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>

#define UP 0 
#define RIGHT 1
#define DOWN 2
#define LEFT 3

char direction;

int gedreht;
int spielfeld[13][13];
int punkte = 0;
int i,p;

/* Checkt ob der Spieler einen Punkt macht und setzt es also das Array wieder auf 0. Schleife später*/

int punkt()
{
 if(spielfeld[1][13] == 1 && spielfeld[2][13] == 1 && spielfeld[3][13] == 1 && spielfeld[4][13] == 1 && spielfeld[5][13] == 1 && spielfeld[6][13] == 1 && spielfeld[7][13] == 1 && spielfeld[8][13] == 1 && spielfeld[9][13] == 1 && spielfeld[10][13] == 1 && spielfeld[11][13] == 1 && spielfeld[12][13] == 1 && spielfeld[13][13] == 1)
 {
 spielfeld[1][13] = 0;
 spielfeld[2][13] = 0;
 spielfeld[3][13] = 0;
 spielfeld[4][13] = 0;
 spielfeld[5][13] = 0;
 spielfeld[6][13] = 0;
 spielfeld[7][13] = 0;
 spielfeld[8][13] = 0;
 spielfeld[9][13] = 0;
 spielfeld[10][13] = 0;
 spielfeld[11][13] = 0;
 spielfeld[12][13] = 0;
 spielfeld[13][13] = 0; 
 punkte + 100;                   
 }  
 else if(spielfeld[1][12] == 1 && spielfeld[2][12] == 1 && spielfeld[3][12] == 1 && spielfeld[4][12] == 1 && spielfeld[5][12] == 1 && spielfeld[6][12] == 1 && spielfeld[7][12] == 1 && spielfeld[8][12] == 1 && spielfeld[9][12] == 1 && spielfeld[10][12] == 1 && spielfeld[11][12] == 1 && spielfeld[12][12] == 1 && spielfeld[13][12] == 1)
 {
 spielfeld[1][12] = 0;
 spielfeld[2][12] = 0;
 spielfeld[3][12] = 0;
 spielfeld[4][12] = 0;
 spielfeld[5][12] = 0;
 spielfeld[6][12] = 0;
 spielfeld[7][12] = 0;
 spielfeld[8][12] = 0;
 spielfeld[9][12] = 0;
 spielfeld[10][12] = 0;
 spielfeld[11][12] = 0;
 spielfeld[12][12] = 0;
 spielfeld[13][12] = 0; 
 punkte + 100;                  
 }
  else if(spielfeld[1][11] == 1 && spielfeld[2][11] == 1 && spielfeld[3][11] == 1 && spielfeld[4][11] == 1 && spielfeld[5][11] == 1 && spielfeld[6][11] == 1 && spielfeld[7][11] == 1 && spielfeld[8][11] == 1 && spielfeld[9][11] == 1 && spielfeld[10][11] == 1 && spielfeld[11][11] == 1 && spielfeld[12][11] == 1 && spielfeld[13][11] == 1)
 {
 spielfeld[1][11] = 0;
 spielfeld[2][11] = 0;
 spielfeld[3][11] = 0;
 spielfeld[4][11] = 0;
 spielfeld[5][11] = 0;
 spielfeld[6][11] = 0;
 spielfeld[7][11] = 0;
 spielfeld[8][11] = 0;
 spielfeld[9][11] = 0;
 spielfeld[10][11] = 0;
 spielfeld[11][11] = 0;
 spielfeld[12][11] = 0;
 spielfeld[13][11] = 0; 
 punkte + 100;                  
 } 
  else if(spielfeld[1][12] == 1 && spielfeld[2][12] == 1 && spielfeld[3][12] == 1 && spielfeld[4][12] == 1 && spielfeld[5][12] == 1 && spielfeld[6][12] == 1 && spielfeld[7][12] == 1 && spielfeld[8][12] == 1 && spielfeld[9][12] == 1 && spielfeld[10][12] == 1 && spielfeld[11][12] == 1 && spielfeld[12][12] == 1 && spielfeld[13][12] == 1)
 {
 spielfeld[1][12] = 0;
 spielfeld[2][12] = 0;
 spielfeld[3][12] = 0;
 spielfeld[4][12] = 0;
 spielfeld[5][12] = 0;
 spielfeld[6][12] = 0;
 spielfeld[7][12] = 0;
 spielfeld[8][12] = 0;
 spielfeld[9][12] = 0;
 spielfeld[10][12] = 0;
 spielfeld[11][12] = 0;
 spielfeld[12][12] = 0;
 spielfeld[13][12] = 0; 
 punkte + 100;                 
 } 
  else if(spielfeld[1][10] == 1 && spielfeld[2][10] == 1 && spielfeld[3][10] == 1 && spielfeld[4][10] == 1 && spielfeld[5][10] == 1 && spielfeld[6][10] == 1 && spielfeld[7][10] == 1 && spielfeld[8][10] == 1 && spielfeld[9][10] == 1 && spielfeld[10][10] == 1 && spielfeld[11][10] == 1 && spielfeld[12][10] == 1 && spielfeld[13][10] == 1)
 {
 spielfeld[1][10] = 0;
 spielfeld[2][10] = 0;
 spielfeld[3][10] = 0;
 spielfeld[4][10] = 0;
 spielfeld[5][10] = 0;
 spielfeld[6][10] = 0;
 spielfeld[7][10] = 0;
 spielfeld[8][10] = 0;
 spielfeld[9][10] = 0;
 spielfeld[10][10] = 0;
 spielfeld[11][10] = 0;
 spielfeld[12][10] = 0;
 spielfeld[13][10] = 0; 
 punkte + 100;                    
 } 
  else if(spielfeld[1][9] == 1 && spielfeld[2][9] == 1 && spielfeld[3][9] == 1 && spielfeld[4][9] == 1 && spielfeld[5][9] == 1 && spielfeld[6][9] == 1 && spielfeld[7][9] == 1 && spielfeld[8][9] == 1 && spielfeld[9][9] == 1 && spielfeld[10][9] == 1 && spielfeld[11][9] == 1 && spielfeld[12][9] == 1 && spielfeld[13][9] == 1)
 {
 spielfeld[1][9] = 0;
 spielfeld[2][9] = 0;
 spielfeld[3][9] = 0;
 spielfeld[4][9] = 0;
 spielfeld[5][9] = 0;
 spielfeld[6][9] = 0;
 spielfeld[7][9] = 0;
 spielfeld[8][9] = 0;
 spielfeld[9][9] = 0;
 spielfeld[10][9] = 0;
 spielfeld[11][9] = 0;
 spielfeld[12][9] = 0;
 spielfeld[13][9] = 0; 
 punkte + 100;                  
 } 
  else if(spielfeld[1][8] == 1 && spielfeld[2][8] == 1 && spielfeld[3][8] == 1 && spielfeld[4][8] == 1 && spielfeld[5][8] == 1 && spielfeld[6][8] == 1 && spielfeld[7][8] == 1 && spielfeld[8][8] == 1 && spielfeld[9][8] == 1 && spielfeld[10][8] == 1 && spielfeld[11][8] == 1 && spielfeld[12][8] == 1 && spielfeld[13][8] == 1)
 {
 spielfeld[1][8] = 0;
 spielfeld[2][8] = 0;
 spielfeld[3][8] = 0;
 spielfeld[4][8] = 0;
 spielfeld[5][8] = 0;
 spielfeld[6][8] = 0;
 spielfeld[7][8] = 0;
 spielfeld[8][8] = 0;
 spielfeld[9][8] = 0;
 spielfeld[10][8] = 0;
 spielfeld[11][8] = 0;
 spielfeld[12][8] = 0;
 spielfeld[13][8] = 0; 
 punkte + 100;                
 } 
  else if(spielfeld[1][7] == 1 && spielfeld[2][7] == 1 && spielfeld[3][7] == 1 && spielfeld[4][7] == 1 && spielfeld[5][7] == 1 && spielfeld[6][7] == 1 && spielfeld[7][7] == 1 && spielfeld[8][7] == 1 && spielfeld[9][7] == 1 && spielfeld[10][7] == 1 && spielfeld[11][7] == 1 && spielfeld[12][7] == 1 && spielfeld[13][7] == 1)
 {
 spielfeld[1][7] = 0;
 spielfeld[2][7] = 0;
 spielfeld[3][7] = 0;
 spielfeld[4][7] = 0;
 spielfeld[5][7] = 0;
 spielfeld[6][7] = 0;
 spielfeld[7][7] = 0;
 spielfeld[8][7] = 0;
 spielfeld[9][7] = 0;
 spielfeld[10][7] = 0;
 spielfeld[11][7] = 0;
 spielfeld[12][7] = 0;
 spielfeld[13][7] = 0; 
 punkte + 100;               
 }
  else if(spielfeld[1][6] == 1 && spielfeld[2][6] == 1 && spielfeld[3][6] == 1 && spielfeld[4][6] == 1 && spielfeld[5][6] == 1 && spielfeld[6][6] == 1 && spielfeld[7][6] == 1 && spielfeld[8][6] == 1 && spielfeld[9][6] == 1 && spielfeld[10][6] == 1 && spielfeld[11][6] == 1 && spielfeld[12][6] == 1 && spielfeld[13][6] == 1)
 {
 spielfeld[1][6] = 0;
 spielfeld[2][6] = 0;
 spielfeld[3][6] = 0;
 spielfeld[4][6] = 0;
 spielfeld[5][6] = 0;
 spielfeld[6][6] = 0;
 spielfeld[7][6] = 0;
 spielfeld[8][6] = 0;
 spielfeld[9][6] = 0;
 spielfeld[10][6] = 0;
 spielfeld[11][6] = 0;
 spielfeld[12][6] = 0;
 spielfeld[13][6] = 0; 
 punkte + 100;                 
 } 
  else if(spielfeld[1][5] == 1 && spielfeld[2][5] == 1 && spielfeld[3][5] == 1 && spielfeld[4][5] == 1 && spielfeld[5][5] == 1 && spielfeld[6][5] == 1 && spielfeld[7][5] == 1 && spielfeld[8][5] == 1 && spielfeld[9][5] == 1 && spielfeld[10][5] == 1 && spielfeld[11][5] == 1 && spielfeld[12][5] == 1 && spielfeld[13][5] == 1)
 {
 spielfeld[1][5] = 0;
 spielfeld[2][5] = 0;
 spielfeld[3][5] = 0;
 spielfeld[4][5] = 0;
 spielfeld[5][5] = 0;
 spielfeld[6][5] = 0;
 spielfeld[7][5] = 0;
 spielfeld[8][5] = 0;
 spielfeld[9][5] = 0;
 spielfeld[10][5] = 0;
 spielfeld[11][5] = 0;
 spielfeld[12][5] = 0;
 spielfeld[13][5] = 0; 
 punkte + 100;                  
 } 
  else if(spielfeld[1][4] == 1 && spielfeld[2][4] == 1 && spielfeld[3][4] == 1 && spielfeld[4][4] == 1 && spielfeld[5][4] == 1 && spielfeld[6][4] == 1 && spielfeld[7][4] == 1 && spielfeld[8][4] == 1 && spielfeld[9][4] == 1 && spielfeld[10][4] == 1 && spielfeld[11][4] == 1 && spielfeld[12][4] == 1 && spielfeld[13][4] == 1)
 {
 spielfeld[1][4] = 0;
 spielfeld[2][4] = 0;
 spielfeld[3][4] = 0;
 spielfeld[4][4] = 0;
 spielfeld[5][4] = 0;
 spielfeld[6][4] = 0;
 spielfeld[7][4] = 0;
 spielfeld[8][4] = 0;
 spielfeld[9][4] = 0;
 spielfeld[10][4] = 0;
 spielfeld[11][4] = 0;
 spielfeld[12][4] = 0;
 spielfeld[13][4] = 0; 
 punkte + 100;                   
 } 
  else if(spielfeld[1][3] == 1 && spielfeld[2][3] == 1 && spielfeld[3][3] == 1 && spielfeld[4][3] == 1 && spielfeld[5][3] == 1 && spielfeld[6][3] == 1 && spielfeld[7][3] == 1 && spielfeld[8][3] == 1 && spielfeld[9][3] == 1 && spielfeld[10][3] == 1 && spielfeld[11][3] == 1 && spielfeld[12][3] == 1 && spielfeld[13][3] == 1)
 {
 spielfeld[1][3] = 0;
 spielfeld[2][3] = 0;
 spielfeld[3][3] = 0;
 spielfeld[4][3] = 0;
 spielfeld[5][3] = 0;
 spielfeld[6][3] = 0;
 spielfeld[7][3] = 0;
 spielfeld[8][3] = 0;
 spielfeld[9][3] = 0;
 spielfeld[10][3] = 0;
 spielfeld[11][3] = 0;
 spielfeld[12][3] = 0;
 spielfeld[13][3] = 0; 
 punkte + 100;                   
 } 
  else if(spielfeld[1][2] == 1 && spielfeld[2][2] == 1 && spielfeld[3][2] == 1 && spielfeld[4][2] == 1 && spielfeld[5][2] == 1 && spielfeld[6][2] == 1 && spielfeld[7][2] == 1 && spielfeld[8][2] == 1 && spielfeld[9][2] == 1 && spielfeld[10][2] == 1 && spielfeld[11][2] == 1 && spielfeld[12][2] == 1 && spielfeld[13][2] == 1)
 {
 spielfeld[1][2] = 0;
 spielfeld[2][2] = 0;
 spielfeld[3][2] = 0;
 spielfeld[4][2] = 0;
 spielfeld[5][2] = 0;
 spielfeld[6][2] = 0;
 spielfeld[7][2] = 0;
 spielfeld[8][2] = 0;
 spielfeld[9][2] = 0;
 spielfeld[10][2] = 0;
 spielfeld[11][2] = 0;
 spielfeld[12][2] = 0;
 spielfeld[13][2] = 0; 
 punkte + 100;                   
 } 
  else if(spielfeld[1][1] == 1 && spielfeld[2][1] == 1 && spielfeld[3][1] == 1 && spielfeld[4][1] == 1 && spielfeld[5][1] == 1 && spielfeld[6][1] == 1 && spielfeld[7][1] == 1 && spielfeld[8][1] == 1 && spielfeld[9][1] == 1 && spielfeld[10][1] == 1 && spielfeld[11][1] == 1 && spielfeld[12][1] == 1 && spielfeld[13][1] == 1)
 {
 spielfeld[1][1] = 0;
 spielfeld[2][1] = 0;
 spielfeld[3][1] = 0;
 spielfeld[4][1] = 0;
 spielfeld[5][1] = 0;
 spielfeld[6][1] = 0;
 spielfeld[7][1] = 0;
 spielfeld[8][1] = 0;
 spielfeld[9][1] = 0;
 spielfeld[10][1] = 0;
 spielfeld[11][1] = 0;
 spielfeld[12][1] = 0;
 spielfeld[13][1] = 0; 
 punkte + 100;                 
 }    
}



/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



//Ausgabe des Spielfelds

int ausgabe()
{
 printf("_______________\n");
 for(i = 0; i < 10; i++)
 {
 printf("|");
         for(p = 0; p < 13; p++)
         {
                 printf("%d", spielfeld[i][p]);                   
         }
 printf("|\n");
         }
 printf("_______________\n");  
}




//Zufallsgeneratoren der Blöcke

int zufall()
{
    
 int z;
 
 srand(time(0));
 
 z = (rand() % 1 + 1); //Zuerst soll nur der eine Block ausgegeben werden ->Test
 
 if(z == 1)
 
 {
      
  int j,k;
  
  k = 0;
  
  for(j = 0; k = 13 ; j++)
  
  {
        
  spielfeld[j][k] = 1; //setze auf 1
  
  j++; //erhöhe -> für senkrechten Block
  
  spielfeld[j][k] = 1;//setze auf 1
  
  j++;//erhöhe -> für senkrechten Block
  
  spielfeld[j][k] = 1;//setze auf 1
  
  if(spielfeld[8][k] == 1)
  break;
  
  scanf("%c", &direction); //muss später noch zu case umgeformt werden
  if(direction == 'd')
  {
  k++;
  break;
}
  if(direction == 'a')
  {
  k--;
  break;
}
}  
  Sleep(500); //warte bis Block einen Block weiter nach unten
  
  system("cls");
  
  ausgabe();
  
  spielfeld[j][k] = 0;
  
  j++;
  
  
}
      
 else if(z == 2)
  {
  spielfeld[0][1] = 1;
  spielfeld[1][1] = 1;
  spielfeld[2][1] = 1; //Blöcke für später
  spielfeld[3][1] = 1;
  spielfeld[3][2] = 1;
  
      
 }
 else if(z == 3)
  {
  spielfeld[0][0] = 1;
  spielfeld[0][1] = 1;//Blöcke für später
  spielfeld[1][0] = 1;
  spielfeld[1][1] = 1;
      
 }
 else if(z == 4)
  {
  spielfeld[0][1] = 1;
  spielfeld[1][0] = 1;//Blöcke für später
  spielfeld[1][1] = 1;
  spielfeld[1][2] = 1;
      
 }   
}


int main()
{

/* TETRIS SONG ;)*/
int C = 261;
int Cis = 277;
int D = 293;
int Dis = 311;
int E = 329;
 int F = 349;
 int Fis = 369;
 int G = 391;
 int Gis = 415;
 int A = 440;
 int Ais = 466;
 int H = 493;
 int Takt = 1300;
Sleep(Takt / 4);
Beep(E * 2, Takt / 4);
Beep(H * 1, Takt / 8);
Beep(C * 2, Takt / 8);
Beep(D * 2, Takt / 4);
Beep(C * 2, Takt / 8);
Beep(H * 1, Takt / 8);
Beep(A * 1, Takt / 4);
Beep(A * 1, Takt / 8);
Beep(C * 2, Takt / 8);
Beep(E * 2, Takt / 8);
Beep(E * 2, Takt / 8);
Beep(D * 2, Takt / 8);
Beep(C * 2, Takt / 8);
Beep(H * 1, Takt / 2);
Beep(C * 2, Takt / 8);
Beep(D * 2, Takt / 4);
Beep(E * 2, Takt / 4);
Beep(C * 2, Takt / 4);
Beep(A * 1, Takt / 4);
Beep(A * 1, Takt / 4);
Sleep(Takt / (8 / 3));
Beep(D * 2, Takt / 3);
Beep(F * 2, Takt / 8);
Beep(A * 2, Takt / 8);
Beep(A * 2, Takt / 8);
Beep(G * 2, Takt / 8);
Beep(F * 2, Takt / 8);
Beep(E * 2, Takt / 3);
Beep(C * 2, Takt / 8);
Beep(E * 2, Takt / 8);
Beep(E * 2, Takt / 8);
Beep(D * 2, Takt / 8);
Beep(C * 2, Takt / 8);
Beep(H * 1, Takt / 4);
Beep(H * 1, Takt / 8);
Beep(C * 2, Takt / 8);
Beep(D * 2, Takt / 4);
Beep(E * 2, Takt / 4);
Beep(C * 2, Takt / 4);
Beep(A * 1, Takt / 4);
Beep(A * 1, Takt / 4);


 printf("Willkommen bei Tetris");
 Sleep(600);
 system("cls");
 ausgabe(); //Funktion
 getchar(); 
 system("cls");
 zufall(); //Funktion
  system("cls");
 ausgabe(); //Funktion
 getchar();   
 getchar(); 
}
Wenn ihr mehr Kommentare Braucht oder Fragen habt...

Falls wer ein FAST fertiges Tetris sucht: