Problem

Hallo
Ich hab ein Problem mit meinem Programm das in C geschrieben ist.
Es geht um ein Mühlespiel.Man darf sein Stein ja nur 1 Feld verschieben.Wie kann ich jetzt das überprüfen das das auch nur 1 Feld verschoben wird?
Braucht ihr noch den code?
gruss stefan

Poste mal den Code.

#include <stdio.h>

#define LEER ' '
#define CLEAR system("cls");
char Muhle[7][7] = { {' ',' ',' ',' ',' ',' ',' '},
                         {' ',' ',' ',' ',' ',' ',' '},
                         {' ',' ',' ',' ',' ',' ',' '},
                         {' ',' ',' ',' ',' ',' ',' '},
                         {' ',' ',' ',' ',' ',' ',' '},
                         {' ',' ',' ',' ',' ',' ',' '},
                         {' ',' ',' ',' ',' ',' ',' '} };

                         char Spieler1 = '\x01';
                         char Spieler2 = '\x02';

                         unsigned int felder = 24 ;
                         void print_spielfeld(void);

void spielfeld(char *spieler1,char *spieler2) {
   int i,i_wahl;

   printf("\n   %c------------------------%c------------------------%c",Muhle[0][0],Muhle[0][3],Muhle[0][6]);
   printf("\n   |                        |                        |");
   printf("\n   |                        |                        |");
   printf("\n   |     %c------------------%c------------------%c     |",Muhle[1][1],Muhle[1][3],Muhle[1][5]);
   printf("\n   |     |                  |                  |     |");
   printf("\n   |     |                  |                  |     |");
   printf("\n   |     |                  |                  |     |");
   printf("\n   |     |                  |                  |     |");
   printf("\n   |     |      %c-----------%c-----------%c      |     |",Muhle[2][2],Muhle[2][3],Muhle[2][4]);
   printf("\n   |     |      |                       |      |     |");
   printf("\n   |     |      |                       |      |     |");
   printf("\n   |     |      |                       |      |     |");
   printf("\n   |     |      |                       |      |     |");
   printf("\n   |     |      |  %s \x01              |      |     |",spieler1);
   printf("\n   %c-----%c------%c                       %c------%c-----%c",Muhle[3][0],Muhle[3][1],Muhle[3][2],Muhle[3][4],Muhle[3][5],Muhle[3][6]);
   printf("\n   |     |      |  %s \x02              |      |     |",spieler2);
   printf("\n   |     |      |                       |      |     |");
   printf("\n   |     |      |                       |      |     |");
   printf("\n   |     |      |                       |      |     |");
   printf("\n   |     |      |                       |      |     |");
   printf("\n   |     |      %c-----------%c-----------%c      |     |",Muhle[4][2],Muhle[4][3],Muhle[4][4]);
   printf("\n   |     |                  |                  |     |");
   printf("\n   |     |                  |                  |     |");
   printf("\n   |     |                  |                  |     |");
   printf("\n   |     |                  |                  |     |");
   printf("\n   |     %c------------------%c------------------%c     |",Muhle[5][1],Muhle[5][3],Muhle[5][5]);
   printf("\n   |                        |                        |");
   printf("\n   |                        |                        |");
   printf("\n   %c------------------------%c------------------------%c",Muhle[6][0],Muhle[6][3],Muhle[6][6]);

}  
int muhle1(char *spieler1,char *spieler2) {
    int zeil,spalt;
  /* Zuerst Spieler1 'X' */
  if(Muhle[0][0] == Spieler1 &&
     Muhle[0][3] == Spieler1 &&
     Muhle[0][6] == Spieler1 ||
     Muhle[1][2] == Spieler1 &&
     Muhle[1][3] == Spieler1 &&
     Muhle[1][5] == Spieler1 ||
     Muhle[2][2] == Spieler1 &&
     Muhle[2][3] == Spieler1 &&
     Muhle[2][4] == Spieler1 ||
     Muhle[3][0] == Spieler1 &&
     Muhle[3][1] == Spieler1 &&
     Muhle[3][2] == Spieler1 ||
     Muhle[3][4] == Spieler1 &&
     Muhle[3][5] == Spieler1 &&
     Muhle[3][6] == Spieler1 ||
     Muhle[4][2] == Spieler1 &&
     Muhle[4][3] == Spieler1 &&
     Muhle[4][4] == Spieler1 ||
     Muhle[5][1] == Spieler1 &&
     Muhle[5][3] == Spieler1 &&
     Muhle[5][5] == Spieler1 ||
     Muhle[6][0] == Spieler1 &&
     Muhle[6][3] == Spieler1 &&
     Muhle[6][6] == Spieler1 ||
     Muhle[0][0] == Spieler1 &&
     Muhle[3][0] == Spieler1 &&
     Muhle[6][0] == Spieler1 ||
     Muhle[1][1] == Spieler1 &&
     Muhle[3][1] == Spieler1 &&
     Muhle[5][1] == Spieler1 ||
     Muhle[2][3] == Spieler1 &&
     Muhle[3][3] == Spieler1 &&
     Muhle[4][3] == Spieler1 ||
     Muhle[0][3] == Spieler1 &&
     Muhle[1][3] == Spieler1 &&
     Muhle[2][3] == Spieler1 ||
     Muhle[4][3] == Spieler1 &&
     Muhle[5][3] == Spieler1 &&
     Muhle[6][3] == Spieler1 || 
     Muhle[2][4] == Spieler1 &&
     Muhle[3][4] == Spieler1 &&
     Muhle[4][4] == Spieler1 ||
     Muhle[1][5] == Spieler1 &&
     Muhle[3][5] == Spieler1 &&
     Muhle[5][5] == Spieler1 ||
     Muhle[0][6] == Spieler1 &&
     Muhle[3][6] == Spieler1 &&
     Muhle[6][6] == Spieler1  ){
      printf("%s hat Mühle\n",spieler1);
              back:
                  CLEAR;
                  spielfeld(spieler1,spieler2);
              printf("\n%s,welchen Stein von %s m\x94\x63htest du aus dem Spiel nehmen?",spieler1,spieler2);
              printf("\nZeile (1 bis 7): ");
              scanf("%d",&zeil);
              printf("\nSpalte (1 bis 7): ");
              scanf("%d",&spalt);
              if(Muhle[zeil-1][spalt-1] == LEER){
                  printf("\n\tFalsche Angabe!");
                  sleep(5000);
                  CLEAR;
                  spielfeld(spieler1,spieler2);
                  goto back;
              }
              if(Muhle[zeil-1][spalt-1] == '\x01'){
           printf("\n\tFalsche Angabe!");
                  sleep(5000);
                  CLEAR;
                  spielfeld(spieler1,spieler2);
                  goto back;   
              }    
              if(Muhle[zeil-1][spalt-1]=='\x02'){
                  Muhle[zeil-1][spalt-1] = ' ';

                  CLEAR;
                  spielfeld(spieler1,spieler2);
                  sleep(5000);
              }
  }
}  
  /* Jetzt Spieler2 'O' */
  int muhle2(char *spieler2,char *spieler1) {
    int zeil,spalt;
   if(Muhle[0][0] == Spieler2 &&
     Muhle[0][3] == Spieler2 &&
     Muhle[0][6] == Spieler2 ||
     Muhle[1][2] == Spieler2 &&
     Muhle[1][3] == Spieler2 &&
     Muhle[1][5] == Spieler2 ||
     Muhle[2][2] == Spieler2 &&
     Muhle[2][3] == Spieler2 &&
     Muhle[2][4] == Spieler2 ||
     Muhle[3][0] == Spieler2 &&
     Muhle[3][1] == Spieler2 &&
     Muhle[3][2] == Spieler2 ||
     Muhle[3][4] == Spieler2 &&
     Muhle[3][5] == Spieler2 &&
     Muhle[3][6] == Spieler2 ||
     Muhle[4][2] == Spieler2 &&
     Muhle[4][3] == Spieler2 &&
     Muhle[4][4] == Spieler2 ||
     Muhle[5][1] == Spieler2 &&
     Muhle[5][3] == Spieler2 &&
     Muhle[5][5] == Spieler2 ||
     Muhle[6][0] == Spieler2 &&
     Muhle[6][3] == Spieler2 &&
     Muhle[6][6] == Spieler2 ||
     Muhle[0][0] == Spieler2 &&
     Muhle[3][0] == Spieler2 &&
     Muhle[6][0] == Spieler2 ||
     Muhle[1][1] == Spieler2 &&
     Muhle[3][1] == Spieler2 &&
     Muhle[5][1] == Spieler2 ||
     Muhle[2][3] == Spieler2 &&
     Muhle[3][3] == Spieler2 &&
     Muhle[4][3] == Spieler2 ||
     Muhle[0][3] == Spieler2 &&
     Muhle[1][3] == Spieler2 &&
     Muhle[2][3] == Spieler2 ||
     Muhle[4][3] == Spieler2 &&
     Muhle[5][3] == Spieler2 &&
     Muhle[6][3] == Spieler2 || 
     Muhle[2][4] == Spieler2 &&
     Muhle[3][4] == Spieler2 &&
     Muhle[4][4] == Spieler2 ||
     Muhle[1][5] == Spieler2 &&
     Muhle[3][5] == Spieler2 &&
     Muhle[5][5] == Spieler2 ||
     Muhle[0][6] == Spieler2 &&
     Muhle[3][6] == Spieler2 &&
     Muhle[6][6] == Spieler2 ){
              printf("%s hat Mühle\n",spieler2);
              backk:
                  CLEAR;
                  spielfeld(spieler1,spieler2);
              printf("\n%s,welchen Stein von %s m\x94\x63htest sie aus dem Spiel nehmen?",spieler2,spieler1);
              printf("\nZeile (1 bis 7): ");
              scanf("%d",&zeil);
              printf("\nSpalte (1 bis 7): ");
              scanf("%d",&spalt);
              if(Muhle[zeil-1][spalt-1] == LEER){
                  printf("\n\tFalsche Angabe!");
                  sleep(5000);
                  CLEAR;
                  spielfeld(spieler1,spieler2);
                  goto back;
              }
              if(Muhle[zeil-1][spalt-1] == '\x02'){
           printf("\n\tFalsche Angabe!");
                  sleep(5000);
                  CLEAR;
                  spielfeld(spieler1,spieler2);
                  goto back;   
              }    
              if(Muhle[zeil-1][spalt-1]=='\x01'){
                  Muhle[zeil-1][spalt-1] = ' ';

                  CLEAR;
                  spielfeld(spieler1,spieler2);
                  sleep(5000);
              }

   }

}

char spielstein(char *spieler1,char *spieler2){

    int x;
    unsigned int zeile,spalte;
    for(x=1; x<=3; x=x+1){
        zurck:

    printf("\n%s,wo m\x94\x63hten du den %i.Spielstein setzen?",spieler1,x);
    printf("\nZeile (1 bis 7): ");
    scanf("%d",&zeile);
    printf("\nSpalte (1 bis 7): ");
    scanf("%d",&spalte);

    if(Muhle[zeile-1][spalte-1] == LEER && zeile <= 7 && spalte <=7){
       Muhle[zeile-1][spalte-1] = '\x01';
     CLEAR;
       spielfeld(spieler1,spieler2);

  }  

  else {

      printf("\n!!! Feld ist bereits besetzt !!!\n");
      sleep(5000);
      CLEAR;
      spielfeld(spieler1,spieler2);
      goto zurck;

}  
zuruck:
printf("\n%s,wo m\x94\x63htest du den %i.Spielstein setzen?",spieler2,x);

    printf("\nZeile (1 bis 7): ");
    scanf("%d",&zeile);
    printf("\nSpalte (1 bis 7): ");
    scanf("%d",&spalte);
    if(Muhle[zeile-1][spalte-1] == LEER && zeile <= 7 && spalte <=7){
       Muhle[zeile-1][spalte-1] = '\x02';
      CLEAR;
      spielfeld(spieler1,spieler2);

  }  
  else {

      printf("\n!!! Feld ist bereits besetzt !!!\n");
      sleep(5000);
      CLEAR;
      spielfeld(spieler1,spieler2);
      goto zuruck;
}  
}
}
int spielzug(char *spieler1,char *spieler2){
    int zeile,spalte;

        CLEAR;
        spielfeld(spieler1,spieler2);
    printf("\n%s,welchen Stein m\x94\x63htest du verschieben?",spieler1);
    printf("\nZeile (1 bis 7): ");
    scanf("%d",&zeile);
    printf("\nSpalte (1 bis 7): ");
    scanf("%d",&spalte);
    Muhle[zeile-1][spalte-1] = ' ';
    CLEAR;
    spielfeld(spieler1,spieler2);
    back:
    printf("\nWohin m\x94\x63htest du den Stein verschieben?");
    printf("\nZeile (1 bis 7): ");
    scanf("%d",&zeile);
    printf("\nSpalte (1 bis 7): ");
    scanf("%d",&spalte);
    if(Muhle[zeile-1][spalte-1] == ' '){
    Muhle[zeile-1][spalte-1] = '\x01';
}
else{
    printf("Falsche Angabe!"); 
    sleep(30000);
    goto back;
}       
spielfeld(spieler1,spieler2);
muhle1(spieler1,spieler2);

        CLEAR
        spielfeld(spieler1,spieler2);
    printf("\n%s,welchen Stein m\x94\x63htest du verschieben?",spieler2);
    printf("\nZeile (1 bis 7): ");
    scanf("%d",&zeile);
    printf("\nSpalte (1 bis 7): ");
    scanf("%d",&spalte);
    Muhle[zeile-1][spalte-1] = ' ';
    spielfeld(spieler1,spieler2);
    backk:
        CLEAR;
    printf("\n\nWohin m\x94\x63htest du den Stein verschieben?");
    printf("\nZeile (1 bis 7): ");
    scanf("%d",&zeile);
    printf("\nSpalte (1 bis 7): ");
    scanf("%d",&spalte);
    if(Muhle[zeile-1][spalte-1] == ' '){
    Muhle[zeile-1][spalte-1] = '\x02';
}
else{
    printf("Falsche Angabe!"); 
    sleep(30000);
    goto backk;

}    
spielfeld(spieler1,spieler2);
    muhle2(spieler1,spieler2);
}
int main(void)
{
char spieler1[21],spieler2[21];
char spielen;

        CLEAR;
       start: 
printf("M\x94\x63htet Ihr M\x81\x68le spielen?");
scanf("%s",&spielen);

if(spielen == 'j')
{
printf("Der Name des 1. Spieler lautet:");
        scanf("%s",&spieler1);
        printf("Der Name des 2. Spieler lautet:");
        scanf("%s",&spieler2);

        CLEAR;

        spielfeld(spieler1,spieler2);
        sleep(5000);
        spielstein(spieler1,spieler2);
        sleep(5000);
        spielzug(spieler1,spieler2);

}

if(spielen == 'n')
{
printf("\nWarum haben Sie das Programm \x81\x62\x65rhaupt gestartet?");
sleep(30000);
}

else{
    printf("Sie m\x81\x73sen j oder n antworten!");

    sleep(5000);
    CLEAR;
    goto start;

}

}

1. wie würdest du dein problem den normal, wenn du selber spielst, lösen? was denkst du den dabei? -genau so würde ich das dann implementieren.

2. wie kommst du eig. drauf "goto" benutzen zu müssen?

3. wieso gibt der dir keine fehlermeldung raus, wenn du sleep benutzt? bei mir funzts jedenfalls net...

ronny

der code ist grob grauenhaft
schonmal was von schleifen gehört ?

DerLateinProfi

Das mit sleep ist schon komisch!
Normalerweise funktioniert sleep nur wenn man windows.h einbindet.
Also wie du das hingekriegt hast ist mir ein Rätsel.
Wenn du's weißt schreib mal! Würd mich interessieren! Das würde
Programme von mir einfacher machen!^^ Da mein Compiler ein Problem mit windows.h hat!

Also Das ist irgendwie genial!

MFG:DerLateinProfi

mein compiler ist dev-c++ ich weis auch nicht was ich da gemacht habe

also als ich noch vor ner weile unter windose geprogt hatte, hatte ich den dev-cpp 4.9.9.2 oda so benutzt...da hatte sleep net gefunzt...
vllt hast du deine file ja als cpp-file und nicht als c-file angelegt, glaub in cpp is das etwas einfacher/anders als in c

ist in C

kann mir niemand helfen?