Fragen zu einer 2D tabelle char Char[32][32];



  • Nun ich baue zurzeit an einen programm mit A.I. das folgendes macht ein weg in einen lapyrint findet von selber:

    nun das geht am einfachsten mit einer 2D tabelle also tabelle[][].

    Nun ich stose auf folgente probellemme:

    1)Ich will ein string von buchstabenn in der tabelle abspeichern wie mache ich es, um genau zu sein will ich das abspeichern ist das richtig oder nicht?

    z.b.
    ****************
    **======
    =======***======
    ****************

    Wie speicher ich die erst zeile ab so oder ohne die ' ' dinga oder ohne , oder ohne kommas???Ich denke ohne beides, was ist richtig.
    beispiel 1 zeile:

    TempMap[0][]={'','','','','','','','','','','*','\0'};

    2)Wen ich dan '\0' eingebe dann wird die eingabe doch beended oder.

    1. Ich mus eine routine entwikeln die den Anfang/ende des Tunels abspeichert wie gebe ich die daten den an einer 2D-Variable ab??? also int Var[0][0]???

    4)Wenn ich die gesammten inhalt von z.b char Var[256][256] auf NULL stellen will, wie mache ich das?? Ich habe mir das mit zwei for schleifen ausgedacht oder geht das einfacher???



  • Naja ich verstehe jetzt nicht so ganz deine Probleme. habe aber einmal ein Hamsterprogramm geschrieben. vielleicht hilft es dir vielleicht nicht aber hier bitte der Code: 😉

    #include <fstream.h>//wird eingebunden für das Laden der Datei
    #include <conio.h>//wird eingebunden für _kbhit und getch
    #include <windows.h>//wird eingebunden für system und sleep
    #include <stdio.h>//wird eingebunden für printf
    
    #define MAXBREITE 100//Maximale Breite des Labyrinths
    #define MAXHOEHE 100//Maximale Hoehe des Labyrinths
    
    #define RECHTS 0//Richtungen des Hamsters
    #define OBEN 1
    #define LINKS 2
    #define UNTEN 3
    
    struct Labyrinth
    {
    	int EingPosX;//Position X(Breite) des Eingangs
    	int EingPosY;//Position Y(Hoehe) des Eingangs
    	int AusgPosX;//Position X des Ausgangs
    	int AusgPosY;//Position Y des Ausgangs
    	int Breite,Hoehe;
    	char Felder[MAXHOEHE][MAXBREITE];//2D Array in dem gespeichert wird ob es
    		//sich um eine Mauer, einen Weg, Ausgang oder Eingang handelt
    }Labyrinth;
    
    class Hamster//Unsere Hamsterklasse Einfachheitshalber alles public
    {
    public:
    	int Sucht; //Sucht=1 wenn Hamster gerade sucht ansonsten Sucht=0
    	int AusgangGef; //AusgangGef=1 Wenn Ausgang gefunden
    	int PosX,PosY; //Positon des Hamsters
    	int Richtung;//0,1,2,3 -> rechts,oben,links,unten
    
    public:
    	Hamster();
    	void Initiallisieren(void);//Hamster wird vorbereitet = beginnt zu suchen
    	void Vor(void);
    	void LinksUm(void);
    	void RechtsUm(void);
    	int WandVoraus(void);//Testet ob Wand vor Hamster wenn ja Rückgabe=1
    	void AusgangSuchen(void);//Hauptfunktion 
    
    }Hamster;
    
    Hamster::Hamster()
    {
    	AusgangGef=0;
    	PosX=PosY=0;
    	Richtung=0;
    	Sucht=0;
    }
    
    void Hamster::Initiallisieren(void)
    {
    	AusgangGef=0;
    	PosX=Labyrinth.EingPosX;
    	PosY=Labyrinth.EingPosY;
    	Richtung=0;
    	Sucht=1;
    }
    
    void Hamster::Vor(void)
    {
    	if(Richtung==RECHTS)
    	{
    		PosX+=1;
    	}
    	if(Richtung==OBEN)
    	{
    		PosY-=1;
    	}
    	if(Richtung==LINKS)
    	{
    		PosX-=1;
    	}
    	if(Richtung==UNTEN)
    	{
    		PosY+=1;
    	}
    }
    
    void Hamster::LinksUm(void)//Dreht sich links
    {
    	Richtung+=1;
    	if(Richtung>=4)
    		Richtung=0;
    }
    void Hamster::RechtsUm(void)//Dreht sich rechts
    {
    	Richtung-=1;
    	if(Richtung<0)
    		Richtung=4;
    }
    
    int Hamster::WandVoraus(void)
    {
    	if(Richtung==RECHTS)//Ist eine Wand Rechts?
    	{
    		if(PosX<(Labyrinth.Breite-1))//Testen ob Hamster am Rand
    		{
    			if(Labyrinth.Felder[PosY][PosX+1]=='0'||//Ist Feld voraus Weg,
    				Labyrinth.Felder[PosY][PosX+1]=='A'||//Ausgang
    				Labyrinth.Felder[PosY][PosX+1]=='E')//oder Eingang also keine Wand 0 zurückgeben
    				return 0;
    			else
    				return 1;
    		}
    		else
    			return 1;
    	}
    	if(Richtung==OBEN)//Ist eine Wand Oben
    	{
    		if(PosY>0)//Testen ob Hamster am Rand
    		{
    			if(Labyrinth.Felder[PosY-1][PosX]=='0'||
    				Labyrinth.Felder[PosY-1][PosX]=='A'||
    				Labyrinth.Felder[PosY-1][PosX]=='E')
    				return 0;
    			else
    				return 1;
    		}
    		else
    			return 1;
    	}
    	if(Richtung==LINKS)//Ist eine Wand Links
    	{
    		if(PosX>0)//Testen ob Hamster am Rand
    		{
    			if(Labyrinth.Felder[PosY][PosX-1]=='0'||
    				Labyrinth.Felder[PosY][PosX-1]=='A'||
    				Labyrinth.Felder[PosY][PosX-1]=='E')
    				return 0;
    			else
    				return 1;
    		}
    		else
    			return 1;
    	}
    	if(Richtung==UNTEN)//Ist eine Wand Unten
    	{
    		if(PosY<(Labyrinth.Hoehe-1))//Testen ob Hamster am Rand
    		{
    			if(Labyrinth.Felder[PosY+1][PosX]=='0'||
    				Labyrinth.Felder[PosY+1][PosX]=='A'||
    				Labyrinth.Felder[PosY+1][PosX]=='E')
    				return 0;
    			else
    				return 1;
    		}
    		else 
    			return 1;
    	}
    	return 1;
    }
    
    //Hamster sucht Ausgang-> Hamster dreht sich solange bis keine Wand vor ihm
    //ist dann geht er vor. Zuerst testet er links, dann vor, dann rechts von
    //und sonst dreht er sich um
    //---------------------------------------------------------------------------
    void Hamster::AusgangSuchen(void)
    {
    	if(!AusgangGef)//Ist Ausgang schon gefunden? Wenn nicht weiter
    	{
    		if(PosX==Labyrinth.AusgPosX&&PosY==Labyrinth.AusgPosY)//Ist Hamster auf Ausgang?
    		{
    			AusgangGef=1;
    		}
    		else//Hamster nicht auf Ausgang -> sucht
    		{
    			LinksUm();//Links drehen
    			if(!WandVoraus())//Keine Wand Voraus
    			{
    				Vor();
    			}
    			else
    			{
    				RechtsUm();
    				if(!WandVoraus())
    				{
    					Vor();
    				}
    				else
    				{
    					RechtsUm();
    					if(!WandVoraus())
    					{
    						Vor();
    					}
    					else
    					{
    						RechtsUm();
    						if(!WandVoraus())
    						{
    							Vor();
    						}
    					}
    				}
    
    			}
    
    		}
    	}
    }
    //---------------------------------------------------------------------------
    
    int LabyrinthLaden(void)
    {
    	ifstream Laden;
    	Laden.open("Labyrinth.txt",ios::in);
    	Laden>>Labyrinth.Breite;
    	Laden>>Labyrinth.Hoehe;
    
    	int EingangGesetzt=0;
    	int AusgangGesetzt=0;
    	for(int y=0; y<Labyrinth.Hoehe; y++)
    	{
    		for(int x=0; x<Labyrinth.Breite; x++)
    		{
    			Laden>>Labyrinth.Felder[y][x];
    
    			if(Labyrinth.Felder[y][x]=='E'||//Testen ob richtige Datei
    				Labyrinth.Felder[y][x]=='A'||
    				Labyrinth.Felder[y][x]=='x'||
    				Labyrinth.Felder[y][x]=='0')
    			{}
    			else
    			{
    				return 0;
    			}
    
    			if (Labyrinth.Felder[y][x]=='E')
    			{
    				if(EingangGesetzt)
    					return 0;//Es gibt mehr als einen Eingang
    				EingangGesetzt=1;
    				Labyrinth.EingPosX=x;
    				Labyrinth.EingPosY=y;
    			}
    			if (Labyrinth.Felder[y][x]=='A')
    			{
    				if(AusgangGesetzt)
    					return 0;//Es gibt mehr als einen Ausgang
    				AusgangGesetzt=1;
    				Labyrinth.AusgPosX=x;
    				Labyrinth.AusgPosY=y;
    			}
    		}
    	}
    	Laden.close();
    
    	return 1;
    }
    
    void TitelAusgeben(void)
    {	
    	printf("Hamster sucht Ausgang in einem Labyrinth\n\n");
    }
    
    void LabyrinthZeichnen(void)
    {
    	printf("x=Wand 0=Weg E=Eingang A=Ausgang\n");
    	for(int x=0; x<Labyrinth.Breite*2+2; x++)
    	{
    		printf("-");
    	}
    	printf("\n");
    	for(int y=0; y<Labyrinth.Hoehe; y++)
    	{
    		printf("|");
    		for(int x=0; x<Labyrinth.Breite; x++)
    		{
    			if(Hamster.Sucht)
    			{
    				if(Hamster.PosX==x&&Hamster.PosY==y)
    					printf("H ");
    				else
    					printf("%c ",Labyrinth.Felder[y][x]);
    			}
    			else
    				printf("%c ",Labyrinth.Felder[y][x]);
    		}
    		printf("|\n");
    	}
    	for(x=0; x<Labyrinth.Breite*2+2; x++)
    	{
    		printf("-");
    	}
    }
    
    void MenuAusgeben(void)
    {
    	printf("\n\n");
    	if(!Hamster.Sucht)
    	{
    		printf("1... Hamster soll suchen\n");
    		printf("2... Beenden\n");
    	}
    	if(Hamster.Sucht)
    	{
    		printf("1... Schneller suchen\n");
    		printf("2... Langsamer suchen\n");
    		printf("3... Beenden\n");
    
    	}
    
    }
    
    void main(void)
    {
    	if(LabyrinthLaden())//Labyrinth aus Datei Labyrinth.txt laden	
    	{
    		int Ende=0;
    		int Warten=1000;//1 Sekunde warten bis nächster Durchlauf beginnt
    		while(!Ende)
    		{		
    			system("cls");//Bildschirm löschen
    			//Alles ausgeben
    			TitelAusgeben();
    			LabyrinthZeichnen();
    
    			if(Hamster.AusgangGef==1)
    				printf("\n\nHamster hat Ausgang gefunden");
    
    			MenuAusgeben();
    
    			if(Hamster.Sucht)
    			{			
    				Hamster.AusgangSuchen();
    				if(Hamster.AusgangGef==1)
    				{
    					Hamster.Sucht=0;
    					Warten=1000;//Wieder Durchlauf normal schalten
    				}
    			}
    
    			//Warten
    			Sleep(Warten);	
    
    			if(_kbhit()) //Tastatureingabe prüffen
    			{
    				int Eingabe=getch();
    				if(!Hamster.Sucht)
    				{
    					if(Eingabe=='1')//Hamster soll Ausgang suchen
    					{
    						Warten=1000;
    						Hamster.Initiallisieren();
    					}
    					if(Eingabe=='2')//Beenden
    						Ende=1;
    				}
    				if(Hamster.Sucht)
    				{
    					if(Eingabe=='1')//Schneller suchen
    					{
    						Warten-=100;
    						if(Warten<=0)
    							Warten=0;
    					}
    					if(Eingabe=='2')//Langsamer suchen
    					{
    						Warten+=100;					
    					}
    					if(Eingabe=='3')
    						Ende=1;
    
    				}
    
    			}
    		}
    	}
    	else
    	{
    		int Ende;
    		printf("Laden der Datei schlug fehl!!!\nPruefe Datei auf richtige Eingabe!!!");
    		cin >> Ende;
    	}
    }
    


  • ach ja die datei labyrinth.txt muss auch im gleichen ordner sein in der folgendes stehen muss: 😃

    15 10
    x x x x x x x x x x x x x x x
    E 0 0 x x x x x x x x x 0 0 0
    0 x 0 x 0 0 0 x x 0 0 0 0 x 0
    0 x 0 0 0 x x x x 0 x x 0 x 0
    0 x x x 0 x x x x 0 0 x 0 x 0
    0 0 0 x 0 x 0 x x x 0 x x x 0
    x x 0 x x x 0 0 0 x 0 0 0 x 0
    0 x 0 0 0 x 0 x 0 0 0 x 0 x x
    0 0 0 x 0 x 0 x x 0 x x 0 0 A
    x x x x 0 0 0 0 0 0 x x x x x


Anmelden zum Antworten