4. C Bitte Helfen... Problem mit mehreren Schleifen...

C Bitte Helfen... Problem mit mehreren Schleifen...

  • S

    Ich habe vor ein paar Tagen das gleiche für ein Bild gewollt, das die aktuell
    gedrückte Richtung anzeigt (links,rechts,oben,unten), allerdings nicht mit ANSI C,
    aber das Prinzip könntest du auch für dein Vorhaben verwenden du musst die
    cases nur entsprechend anpassen, da ich mit Allegro gearbeitet habe.

    int fixKey (int keycode) {
	static int key = 0; // Enthält die derzeit gedrückte Position, 0 stellt die Normalstellung dar

	switch (keycode) {

		case KEY_UP:
			if (key == KEY_UP)
				key = 0;
			else
				key = KEY_UP;
			break;

		case KEY_DOWN:
			if (key == KEY_DOWN)
				key = 0;
			else
				key = KEY_DOWN;
			break;

		case KEY_LEFT:
			if (key == KEY_LEFT)
				key = 0;
			else
				key = KEY_LEFT;
			break;

		case KEY_RIGHT:
			if (key == KEY_RIGHT)
				key = 0;
			else 
				key = KEY_RIGHT;
			break;
	}
	return key; // Neue Position zurückgeben
}

				int scancode = readkey () >> 8;
				int key = fixKey (scancode);
				clear_keybuf ();
				switch (key) {
					case KEY_UP:
						curImage = 3;
						break;

					case KEY_DOWN:
						curImage = 4;
						break;

					case KEY_LEFT:
						curImage = 1;
						break;

					case KEY_RIGHT:
						curImage = 2;
						break;

					default:
						curImage = 0;
				}

    Du musst halt die Tastaturabfragen auf die dir zur Verfügung stehenden Mittel
    ändern. Und evt. das Verhalten da es bei einem Snake ja kein Stillstand gibt
    wie bei mir die Normalposition (zentriert).
    Aber dazu muss ja nur der default-Fall entfernt werden und durch erneutes
    Drücken das ändern der Key-Variable auf 0.

    0
  • N

    [PSEUDO]
    while(tru)
    {
    richtung=links

    if taste=cursor
    richtung=cursor.richtung

    bewege in richtung

    warte 1 sekunde

    }
    [/PSEUDO]

    So ungefähr?

    0
  • V

    Eine große Schleife für eine endende Abbruchbedingung, z.B. wenn das 'x' eine bestimmte Anzahl an "Schritten gelaufen" ist. Dazu 4 Schleifen für jede Richtungstaste eine. Und solange laufen lassen bis eine neue gedrückt wurde, danach abbrechen und zu der Schleife der zuletzt getippten Taste.
    Hoffe das war verständlich so.

    Code-Hacker

    0
  • C

    Also so siehts im moment aus....

    Der erste Teil ist dafür das das "x" gesteuert wird

    Der zweite Teil dafür was passieren soll wenn das "x" in ein Feld kommt wo schon etwas drinen ist

    Und der dritte Teil ist halt dafür da das das "x" auch geschrieben wird

    Kann man darum nicht ne schleife machen, so dass der erste Teil (mit der richtungs abfrage) nur dann kommt wenn die richtung die vorhergedrückt wurde nicht mehr stimmt?

    vielleicht dass dann da irgendwie "kbhit" reinkommt?

    do {
        	alt_posx = posx;
                alt_posy = posy;
                pieps = 20;
                wahl = getch();
                switch (wahl){
                 case 0 : wahl =getch();                     //lese auswahl
                 	switch(wahl){                              //auswahl
                         case 77 : if (posx < 79) posx++;    //cursor rechts
                         break;
			       case 75 : if (posx > 2) posx--;     //cursor links
                         break;
                         case 80 : if (posy < 24) posy++;    //cursor unten
                         break;
                         case 72 : if (posy > 2) posy--;     //cursor hoch                   			break;
                 }
                 break;
        }

//-----------------------------------------------------------------------------

        gettext (posx, posy, posx, posy, &inhalt);
        switch (inhalt [0]) {
        case 'K' :posx = alt_posx; //wenn im Feld "K":neue position=alte positi
        	posy = alt_posy;
                pieps = 200;       //setze Pieps auf 200
                punkte-=10;        //und rechne zur punktzahl -10
                break;
        case '^' : pieps = 3000    //wenn im Feld "^"dinnen ist:pieps auf 3000
       	 	punkte+=10;      //und rechne zur punktzahl +10
                break;
        case '+' :pieps = 500;     //wenn im Feld "+"dinnen ist:pieps auf 500
        	punkte-=10;            //und rechne zur punktzahl -10
        	break;
        case 'O' : pieps = 4999;   
                break;

//-----------------------------------------------------------------------------

        }
        gotoxy (alt_posx, alt_posy);    //gehe zur alten position
        printf(" ");                    //überschreibe alte position mit leer
        gotoxy (posx, posy);            //gehe zur neuen Position
        printf("x");                    //schreibe das X
        sound (pieps);                  //Piepse
        delay (40);                     //kurze pause bevor nächstem befehl
        nosound();                      //spiele keinen sound
        gotoxy (2,1);                   //gehe nach oben links
        printf ("Punkte:%4i", punkte);  // Schreibe neue Punktzahl
        } while (wahl != 27);           //solange nicht Esc gedrückt wird
}
    0
  • D
     

    do { 
        pieps = 20;

        if(kbhit()) {
            wahl = getch();
            if(wahl == 0) {
                wahl =getch();
                switch(wahl){                            
                    case 77 : speedx=1; speedy=0; break; 
                    case 75 : speedx=-1; speedy=0; break; 
                    case 80 : speedy=1; speedx=0; break; 
                    case 72 : speedy=-1; speedx=0;
                } 
            }
        }

        gotoxy (posx, posy);
        printf(" ");
        posx+=speedx;
        posy+=speedy;

        if (posx >= 79 || posx <= 2 || posy >= 24 || posy <= 2) ... ; //Game Over

//----------------------------------------------------------------------------- 

        gettext (posx, posy, posx, posy, &inhalt); 
        switch (inhalt [0]) { 
        case 'K' :posx = alt_posx; //wenn im Feld "K":neue position=alte positi 
            posy = alt_posy; 
                pieps = 200;       //setze Pieps auf 200 
                punkte-=10;        //und rechne zur punktzahl -10 
                break; 
        case '^' : pieps = 3000    //wenn im Feld "^"dinnen ist:pieps auf 3000 
                punkte+=10;      //und rechne zur punktzahl +10 
                break; 
        case '+' :pieps = 500;     //wenn im Feld "+"dinnen ist:pieps auf 500 
            punkte-=10;            //und rechne zur punktzahl -10 
            break; 
        case 'O' : pieps = 4999;    
                break; 

//----------------------------------------------------------------------------- 

        }

        gotoxy (posx, posy);
        printf("x");           

        sound (pieps);                  //Piepse 
        delay (200);                     //kurze pause bevor nächstem befehl 
        nosound();                      //spiele keinen sound 
        gotoxy (2,1);                   //gehe nach oben links 
        printf ("Punkte:%4i", punkte);  // Schreibe neue Punktzahl 
        } while (wahl != 27);           //solange nicht Esc gedrückt wird 
}
    0
  • H
     

    #pragma hdrstop
#pragma argsused

#include <stdio.h>
#include <conio.h>
#include <iostream.h>

void zeichnen(int *x_ptr, int *y_ptr)
 {
  clrscr();
  gotoxy(*x_ptr,*y_ptr);
  cout << '#';
 }

int runter(int *x_ptr, int *y_ptr)
{
 int i;
 long zeitverzoegerung;

 while(!kbhit())
  {
    i = *y_ptr;
    *y_ptr = i+1;
    for (zeitverzoegerung=0; zeitverzoegerung<99999999; zeitverzoegerung++);
    zeichnen(x_ptr,y_ptr);
  }
 i = getch();
 return(i);
}

int rauf(int *x_ptr, int *y_ptr)
{
 int i;
 long zeitverzoegerung;

 while(!kbhit())
  {
    i = *y_ptr;
    *y_ptr = i-1;
    for (zeitverzoegerung=0; zeitverzoegerung<99999999; zeitverzoegerung++);
    zeichnen(x_ptr,y_ptr);
  }
 i = getch();
 return(i);
}

int links(int *x_ptr, int *y_ptr)
{
 int i;
 long zeitverzoegerung;

 while(!kbhit())
  {
    i = *x_ptr;
    *x_ptr = i-1;
    for (zeitverzoegerung=0; zeitverzoegerung<99999999; zeitverzoegerung++);
    zeichnen(x_ptr,y_ptr);
  }
 i = getch();
 return(i);
}

int rechts(int *x_ptr, int *y_ptr)
{
 int i;
 long zeitverzoegerung;

 while(!kbhit())
  {
    i = *x_ptr;
    *x_ptr = i+1;
    for (zeitverzoegerung=0; zeitverzoegerung<99999999; zeitverzoegerung++);
    zeichnen(x_ptr,y_ptr);
  }
 i = getch();
 return(i);
}

void main(void)
{
 int i=1;
 int x,y;
 int *x_ptr=&x;
 int *y_ptr=&y;

 x=y=1;
 char zeichen;

 zeichnen(x_ptr,y_ptr);

 while (!kbhit())
  {
   i++;
   zeichen = getch();
   while(i!=2)        // sonst hats probleme mit den funktionen gegeben o_0
                      // beim rücksprung von rauf/links... man musste dann 2 mal
                      // druecken damit er wieder weitergemacht hat
    {
     if(zeichen=='w'){ zeichen=rauf(x_ptr,y_ptr); i=1;};
     if(zeichen=='a'){ zeichen=links(x_ptr,y_ptr); i=1;};
     if(zeichen=='s'){ zeichen=runter(x_ptr,y_ptr); i=1;};
     if(zeichen=='d'){ zeichen=rechts(x_ptr,y_ptr); i=1;};
    }
  }

}

    so ich hab mich auch eben mal dran versucht

    und wenn ich schon dabei bin 😛

    es taucht des öfteren folgendes auf:

    i = *y_ptr;
    *y_ptr = i+1;

    ich wollte nur die variable Y aus dem hauptprogramm erhöhen

    und das über den zeiger

    aber

    *y_ptr++; ging nicht
    jetzt musste ich es so machen

    gibts da ne einfachere möglichkeit

    thx

    0
  • C

    @ h3nky

    Das Programm soll komplet in C geschrieben werden beim compailieren kommt aber leider die meldung dass ich c++ für die iostrem benutzen muss... 😞

    0
  • H

    dann schreibst halt die cout um in printf und fertig

    ich bin nur zu faul immer das lange wort printf hinzuschreiben :>

    0
  • C

    ^^ oka werds nachher mal ausprobiern 😃

    die isostream dann einfach rauswerfen?

    0
  • H
     

    //---------------------------------------------------------------------------
#include <stdio.h>
#include <conio.h>

#pragma hdrstop
#pragma argsused

void rahmen(void)
 {
  int x;
  for(x=1;x<80;x++)
   {
     gotoxy(x,1);
     printf("*");
     gotoxy(x,25);
     printf("*");
   }
  for(x=2;x<25; x++)
   {
    gotoxy(1,x);
    printf("*");
    gotoxy(79,x);
    printf("*");
   }
 }

void gameover_screen(void)
 {
  clrscr();
  rahmen();
  gotoxy(35,12);
  printf("GAME OVER");
  gotoxy(27,14);
  printf("Powered by c-plusplus.net");
 }

int gameover(int x, int y)
 {
   if( (x==1) || (x==79) || (y==1) || (y==25) )
    return(999);   // GAMEOVER
   else
    return(1);     // GAME NOT OVER
 }

void loeschen(void)
 {
  window(2,2,78,24);
  clrscr();
  window(1,1,79,25);
 }

void zeichnen(int *snake_x, int *snake_y)
{
 int i;
 loeschen();
 for(i=0; i<10; i++)
  {
   if( (*(snake_x+i)) == 0 || (*(snake_y+i)) == 0) {}
    else
      {
       gotoxy(*(snake_x+i),*(snake_y+i));
       printf("#");
      }
  }
}

int bewegen(int *snake_x, int *snake_y, int richtung)
{
 int i;
 long zeitverzoegerung;

 while(!kbhit())
  {
    for(i=0; i<9; i++)
      {
        if( (*(snake_x+i+1)) == 0) { break; }
        else
         {
          *(snake_x+i) = *(snake_x+i+1);
          *(snake_y+i) = *(snake_y+i+1);
         }

      }

    // RICHTUNG 0=rechts 1=links 2=hoch 3=runter
    switch(richtung)
     {
      case 0: {
                (*(snake_x+i))++;
                 break;
              }
      case 1: {
                (*(snake_x+i))--;
                break;
              }
      case 2: {
                (*(snake_y+i))--;
                break;
              }
      case 3: {
                (*(snake_y+i))++;
                break;
              }
     }

    i = gameover( (*(snake_x+i)),(*(snake_y+i)) );
    if(i==999)  return(i);
    else
     {
      zeichnen(snake_x,snake_y);
      for (zeitverzoegerung=0; zeitverzoegerung<99999999; zeitverzoegerung++);
     }
  }
  return(getch());
}

void main(void)
{
  int snake_x[10];
  int snake_y[10];
  int zeichen;

  int i;

  for(i=0; i<10; i++)
   {
     snake_x[i] = 0;
     snake_y[i] = 0;
   }

  rahmen();

  // Schlage erzeugen;
  snake_x[0] = 5;
  snake_x[1] = 6;
  snake_x[2] = 7;
  snake_y[0] = 5;
  snake_y[1] = 5;
  snake_y[2] = 5;

  zeichnen(snake_x,snake_y);
  i = 1;

  while (!kbhit())
  {

   zeichen = getch();
     while(i!=2)
    {

     if(zeichen=='w'){ i=bewegen(snake_x,snake_y,2);};  // hoch
     if(zeichen=='a'){ i=bewegen(snake_x,snake_y,1);};  // links
     if(zeichen=='s'){ i=bewegen(snake_x,snake_y,3);};  // RUNTER
     if(zeichen=='d'){ i=bewegen(snake_x,snake_y,0);};  // RECHTS
     zeichen=i;
     if(i==999) break;

    }
        if(i==999) break;
  }

  gameover_screen();
  fflush(stdin);
  getch();

}
//---------------------------------------------------------------------------

    so hab das ganze nochmal angepasst .. mom ist die schlange schon 3 zeichen lang o_0

    sie bewegt sich selbstständig
    und wenn man gegen die mauer fährt is spiel aus

    hf

    0
Anmelden zum Antworten