NoPaste

Labyrinth-Methoden

von heinz

SNIPPET_TEXT:
  1. /*
  2.   hero_quest
  3.   12.12.2021
  4. */
  5.  
  6. // Labyrinth ---------------------------------------------------------------------------------------
  7.  
  8. labyrinTh::labyrinTh(int B,int H,koordinateN SP,koordinateN EP)//(breite, hoehe, startpos, endpos)
  9. {
  10.         breite=B;
  11.         hoehe=H;
  12.         startpos=SP;
  13.         endpos=EP;
  14.  
  15.         lab_feldliste=NULL;
  16.         lab_feldmenge=breite*hoehe;
  17.  
  18.         gelaufener_weg=NULL;
  19.         lifo=new weg_liFo;
  20.  
  21.  
  22.         Labyrinth_erzeugen(breite,hoehe,startpos,endpos);
  23.  
  24. #if DEBUG
  25.         printf("Labyrinth gestartet.\n");
  26. #endif
  27. }
  28.  
  29.  
  30.  
  31.  
  32.  
  33.  
  34.  
  35.  
  36. #if DEBUG
  37. void labyrinTh::Testausgabe_ascii()
  38. {
  39.         if(lab_feldliste==NULL)
  40.         {
  41.                 fprintf(stderr,"\a\nKein Labyrinth vorhanden!\n");
  42.                 return;
  43.         }
  44.  
  45.  
  46.         for(int y=0;y<hoehe;y++)
  47.         {
  48.                 for(int x=0;x<breite;x++)
  49.                 {
  50.                         char text[L_ASCI_LAENGE]={""};
  51.                         switch(lab_feldliste[y*breite+x]->art)
  52.                         {
  53.                                 case L_WAND:
  54.                                         sprintf(text,"%s",L_ASCI_WAND);
  55.                                 break;
  56.                                 case L_WEG:
  57.                                         sprintf(text,"%s",L_ASCI_WEG);
  58.                                 break;
  59.                                 case L_TUER_OFFEN:
  60.                                         sprintf(text,"%s",L_ASCI_TUER_OFFEN);
  61.                                 break;
  62.                                 case L_TUER_ZU:
  63.                                         sprintf(text,"%s",L_ASCI_TUER_ZU);
  64.                                 break;
  65.                                 case L_EINGANG:
  66.                                         sprintf(text,"%s",L_ASCI_EINGANG);
  67.                                 break;
  68.                                 case L_AUSGANG:
  69.                                         sprintf(text,"%s",L_ASCI_AUSGANG);
  70.                                 break;
  71.                                 case L_SCHATZ_GOLD:
  72.                                         sprintf(text,"%s",L_ASCI_SCHATZ_GOLD);
  73.                                 break;
  74.                                 case L_SCHATZ_ITEM:
  75.                                         sprintf(text,"%s",L_ASCI_SCHATZ_ITEM);
  76.                                 break;
  77.                                 case L_SCHLUESSEL:
  78.                                         sprintf(text,"%s",L_ASCI_SCHLUESSEL);
  79.                                 break;
  80.                                 case L_GEGNER:
  81.                                         sprintf(text,"%s",L_ASCI_GEGNER);
  82.                                 break;
  83.                         }
  84.                         printf("%s",text);
  85.                 }
  86.                 printf("\n");
  87.         }
  88.         printf("\n");
  89. }
  90.  
  91.  
  92.  
  93.  
  94.  
  95.  
  96.  
  97.  
  98.  
  99. void labyrinTh::Testausgabe_sdl(bool MIT_WEG)// (mit Weg)
  100. {
  101.         if(lab_feldliste==NULL)
  102.         {
  103.                 fprintf(stderr,"\a\nKein Labyrinth vorhanden!\n");
  104.                 return;
  105.         }
  106.  
  107.         bool weg_zeichnen=false;
  108.         if(gelaufener_weg!=NULL&&MIT_WEG)
  109.         {
  110.                 weg_zeichnen=true;
  111.         }
  112.  
  113.  
  114.         for(int y=0;y<hoehe;y++)
  115.         {
  116.                 for(int x=0;x<breite;x++)
  117.                 {
  118.                         int kachelnummer=0;
  119.                         int feldart=lab_feldliste[y*breite+x]->art;
  120.                         int code=lab_feldliste[y*breite+x]->code;
  121.                         if(feldart==L_WAND)
  122.                                 {kachelnummer=0;}
  123.                         if(feldart==L_WEG)
  124.                                 {kachelnummer=1;}
  125.                         if(feldart==L_TUER_OFFEN)
  126.                                 {kachelnummer=2;}
  127.                         if(feldart==L_TUER_ZU)
  128.                                 {kachelnummer=3;}
  129.                         if(feldart==L_EINGANG)
  130.                                 {kachelnummer=4;}
  131.                         if(feldart==L_AUSGANG)
  132.                                 {kachelnummer=5;}
  133.                         if(feldart==L_SCHATZ_GOLD)
  134.                                 {kachelnummer=6;}
  135.                         if(feldart==L_SCHATZ_ITEM)
  136.                                 {kachelnummer=7;}
  137.                         if(feldart==L_SCHLUESSEL)
  138.                                 {kachelnummer=8;}
  139.                         if(feldart==L_GEGNER)
  140.                                 {kachelnummer=9;}
  141.  
  142.                         sge_Blit(kachelbilder_klein[kachelnummer],display,0,0,x*KLEINE_KACHELGROESSE,y*KLEINE_KACHELGROESSE,KLEINE_KACHELGROESSE,KLEINE_KACHELGROESSE);
  143.  
  144.                         if(weg_zeichnen)
  145.                         {
  146.                                 if(*gelaufener_weg[y*breite+x])
  147.                                 {
  148.                                         boxColor(display,x*KLEINE_KACHELGROESSE,y*KLEINE_KACHELGROESSE,x*KLEINE_KACHELGROESSE+KLEINE_KACHELGROESSE,y*KLEINE_KACHELGROESSE+KLEINE_KACHELGROESSE,0x00ff0050);
  149.                                 }
  150.                         }
  151.  
  152. //                      if(feldart==L_TUER_ZU||feldart==L_SCHLUESSEL)
  153.                         if(code>=0)
  154.                         {
  155.                                 char text[20]={""};
  156.                                 sprintf(text,"%i",code);
  157.                                 stringColor(display,x*KLEINE_KACHELGROESSE+5,y*KLEINE_KACHELGROESSE+5,text,0xffffffff);
  158.                         }
  159.                 }
  160.         }
  161.  
  162. #if DEBUG
  163.         lifo->Zeichnen();
  164. #endif
  165.  
  166.         SDL_Flip(display);
  167. }
  168. #endif
  169.  
  170.  
  171.  
  172.  
  173.  
  174.  
  175.  
  176.  
  177. /*
  178. void labyrinTh::Zeichnen()
  179. {
  180.         if(lab_feldliste==NULL)
  181.         {
  182.                 fprintf(stderr,"\a\nKein Labyrinth vorhanden!\n");
  183.                 return;
  184.         }
  185.  
  186.         for(int y=0;y<hoehe;y++)
  187.         {
  188.                 for(int x=0;x<breite;x++)
  189.                 {
  190.                         int kachelnummer=0;
  191.                         int feldart=lab_feldliste[y*breite+x]->art;
  192.                         int code=lab_feldliste[y*breite+x]->code;
  193.                         if(feldart==L_WAND)
  194.                                 {kachelnummer=0;}
  195.                         if(feldart==L_WEG)
  196.                                 {kachelnummer=1;}
  197.                         if(feldart==L_TUER_OFFEN)
  198.                                 {kachelnummer=2;}
  199.                         if(feldart==L_TUER_ZU)
  200.                                 {kachelnummer=3;}
  201.                         if(feldart==L_EINGANG)
  202.                                 {kachelnummer=4;}
  203.                         if(feldart==L_AUSGANG)
  204.                                 {kachelnummer=5;}
  205.                         if(feldart==L_SCHATZ_GOLD)
  206.                                 {kachelnummer=6;}
  207.                         if(feldart==L_SCHATZ_ITEM)
  208.                                 {kachelnummer=7;}
  209.                         if(feldart==L_SCHLUESSEL)
  210.                                 {kachelnummer=8;}
  211.                         if(feldart==L_GEGNER)
  212.                                 {kachelnummer=9;}
  213.  
  214.                         sge_Blit(kachelbilder_klein[kachelnummer],display,0,0,x*KLEINE_KACHELGROESSE,y*KLEINE_KACHELGROESSE,KLEINE_KACHELGROESSE,KLEINE_KACHELGROESSE);
  215.                 }
  216.         }
  217. }
  218. */
  219.  
  220.  
  221.  
  222.  
  223.  
  224.  
  225.  
  226.  
  227. void labyrinTh::Labyrinth_erzeugen(int B,int H,koordinateN SP,koordinateN EP)//(breite, hoehe, startpos, endpos)
  228. {
  229.         breite=B;
  230.         hoehe=H;
  231.         startpos=SP;
  232.         endpos=EP;
  233.  
  234. #if DEBUG
  235.         printf("Labyrinth erzeugen gestartet. (Breite=%i, Hoehe=%i, Eing.=%ix%i, Ausg.=%ix%i)\n",breite,hoehe,startpos.x,startpos.y,endpos.x,endpos.y);
  236. #endif
  237.  
  238. // Wenn bereits ein Labyrinth existiert, dann erst loeschen.
  239.         if(lab_feldliste!=NULL){Labyrinth_loeschen();}
  240.  
  241. // Array erzeugen --------------------------------------------------------------
  242.         lab_feldmenge=breite*hoehe;
  243.  
  244.         lab_feldliste=(lab_felD**)calloc(lab_feldmenge,sizeof(lab_felD*));
  245.         if(lab_feldliste==NULL)
  246.         {
  247.                 fprintf(stderr,"\a\nKonnte keinen Speicher fuer das Array bekommen!\n");
  248.                 return;
  249.         }
  250.  
  251.         for(int z=0;z<lab_feldmenge;z++)
  252.         {
  253.                 lab_feldliste[z]=new lab_felD;
  254.                 lab_feldliste[z]->art=L_WEG;
  255.                 lab_feldliste[z]->code=-1;
  256.         }
  257.  
  258.  
  259. // Labyrinth erzeugen ----------------------------------------------------------
  260. // Erzeuge Aussenwand
  261.         for(int x=0;x<breite;x++)
  262.         {
  263.                 lab_feldliste[x]->art=L_WAND;
  264.                 lab_feldliste[(hoehe-1)*breite+x]->art=L_WAND;
  265.         }
  266.         for(int y=0;y<hoehe;y++)
  267.         {
  268.                 lab_feldliste[y*breite]->art=L_WAND;
  269.                 lab_feldliste[y*breite+(breite-1)]->art=L_WAND;
  270.         }
  271.  
  272. // Ein-/Ausgang hinzufuegen ----------------------------------------------------
  273. // Sind Ein-/Ausgaenge korrekt?
  274.         bool sok=false;
  275.         bool eok=false;
  276.         if(startpos.x==0||startpos.x==breite-1)
  277.         {
  278.                 if(startpos.y>0&&startpos.y<hoehe)
  279.                 {sok=true;}
  280.         }
  281.         else if(startpos.y==0||startpos.y==hoehe-1)
  282.         {
  283.                 if(startpos.x>0&&startpos.x<breite)
  284.                 {sok=true;}
  285.         }
  286.  
  287.         if(endpos.x==0||endpos.x==breite-1)
  288.         {
  289.                 if(endpos.y>0&&endpos.y<hoehe)
  290.                 {eok=true;}
  291.         }
  292.         else if(endpos.y==0||endpos.y==hoehe-1)
  293.         {
  294.                 if(endpos.x>0&&endpos.x<breite)
  295.                 {eok=true;}
  296.         }
  297.  
  298.         if(!sok)
  299.         {fprintf(stderr,"\a\nStartpos (%ix%i) ist fehlerhaft!\n",startpos.x,startpos.y);return;}
  300.         if(!eok)
  301.         {fprintf(stderr,"\a\nEndpos (%ix%i) ist fehlerhaft!\n",endpos.x,endpos.y);return;}
  302.  
  303.  
  304.         lab_feldliste[startpos.y*breite+startpos.x]->art=L_EINGANG;
  305.         lab_feldliste[endpos.y*breite+endpos.x]->art=L_AUSGANG;
  306.  
  307.  
  308. // Raeume hinzufuegen 1 ("Raumsamen" setzen) -----------------------------------
  309.         int anzahl_raumsamen=rand()%6+2;
  310.         for(int rs=0;rs<anzahl_raumsamen;rs++)
  311.         {
  312.                 int zx=rand()%(breite-6)+3;
  313.                 int zy=rand()%(hoehe-6)+3;
  314.                 lab_feldliste[zy*breite+zx]->art=L_WAND;
  315.                 lab_feldliste[zy*breite+zx]->code=0;
  316.         }
  317.  
  318.  
  319. // Startwaende hinzufuegen -----------------------------------------------------
  320.         int startwaende=rand()%10+4;
  321.         for(int sw=0;sw<startwaende;sw++)
  322.         {
  323.                 bool ok=false;
  324.                 while(!ok)
  325.                 {
  326. // Zufallsposition
  327.                         int zx=rand()%(breite-2)+1;
  328.                         int zy=rand()%(hoehe-2)+1;
  329.  
  330. // Ist Position am Rand?
  331.                         if(zy==1||zy==hoehe-2)
  332.                         {
  333.                                 ok=true;
  334.                         }
  335.                         else if(zx==1||zx==breite-2)
  336.                         {
  337.                                 ok=true;
  338.                         }
  339.  
  340. // Ist Position vor einem Ein-/Ausgang?
  341.                         if(ok)
  342.                         {
  343.                                 if(lab_feldliste[(zy-1)*breite+zx]->art==L_EINGANG||
  344.                                          lab_feldliste[(zy+1)*breite+zx]->art==L_EINGANG||
  345.                                          lab_feldliste[zy*breite+zx-1]->art==L_EINGANG||
  346.                                          lab_feldliste[zy*breite+zx+1]->art==L_EINGANG||
  347.                                          lab_feldliste[(zy-1)*breite+zx]->art==L_AUSGANG||
  348.                                          lab_feldliste[(zy+1)*breite+zx]->art==L_AUSGANG||
  349.                                          lab_feldliste[zy*breite+zx-1]->art==L_AUSGANG||
  350.                                          lab_feldliste[zy*breite+zx+1]->art==L_AUSGANG)
  351.                                 {
  352.                                         ok=false;
  353.                                 }
  354.                         }
  355.  
  356. // Ist hier noch keine Startwand? Dann Wand setzen
  357.                         if(ok)
  358.                         {
  359.                                 if(lab_feldliste[zy*breite+zx]->art!=L_WAND)
  360.                                 {
  361.                                         lab_feldliste[zy*breite+zx]->art=L_WAND;
  362.                                 }
  363.                                 else
  364.                                 {
  365.                                         ok=false;
  366.                                 }
  367.                         }
  368.                 }
  369.         }
  370.  
  371.  
  372.  
  373. // Zufaellig Waende hinzufuegen, die eine Wand beruehren -----------------------
  374.         int testmenge=0;
  375.         int durchlaeufe=0;
  376.         int gesetzte_waende=breite*2+hoehe*2-4;
  377.         while(testmenge<1000000)
  378.         {
  379.                 durchlaeufe++;
  380.  
  381. // Zufallsposition
  382.                 int zx=rand()%(breite-1)+1;
  383.                 int zy=rand()%(hoehe-1)+1;
  384.  
  385. // Auf gueltigkeit pruefen
  386.                 if(zy*breite+zx<lab_feldmenge)
  387.                 {
  388.                         if(lab_feldliste[zy*breite+zx]->art!=L_WAND)
  389.                         {
  390.                                 testmenge++;
  391.  
  392.                                 int angrenzungen=0;
  393.                                 bool raumsamen=false;
  394.                                 for(int y=-1;y<2;y++)
  395.                                 {
  396.                                         for(int x=-1;x<2;x++)
  397.                                         {
  398.                                                 int pos=(zy+y)*breite+zx+x;
  399.                                                 if(pos>0&&pos<lab_feldmenge-1)
  400.                                                 {
  401.                                                         if(lab_feldliste[pos]->art==L_WAND)
  402.                                                                 {angrenzungen++;}
  403.                                                         if(lab_feldliste[pos]->code!=-1)
  404.                                                                 {raumsamen=true;}
  405.                                                 }
  406.                                         }
  407.                                 }
  408.  
  409. // Wand setzen
  410. //                              if(angrenzungen<=2&&angrenzungen>=1)
  411.                                 if(angrenzungen==1&&!raumsamen)
  412.                                 {
  413.                                         lab_feldliste[zy*breite+zx]->art=L_WAND;
  414.                                         gesetzte_waende++;
  415.                                 }
  416.                         }
  417.                 }
  418.  
  419. //              printf("\e[%iA",hoehe+2);
  420. //              Testausgabe_ascii();
  421. //              Testausgabe_sdl();
  422. //              printf("z=%3ix%3i, TM=%i, GW=%i, DL=%i, SW=%i \n",zx,zy,testmenge,gesetzte_waende,durchlaeufe,startwaende);
  423. //              if(Auf_tastendruck_warten(5)){printf("Abbruch!\n");break;}// (millisekunden) Gibt "Taste gedrueckt" zurueck
  424.         }
  425.  
  426.  
  427.  
  428. // Raeume hinzufuegen 2 ("Raumsamen" entfernen) --------------------------------
  429.         for(int z=0;z<lab_feldmenge;z++)
  430.         {
  431.                 if(lab_feldliste[z]->code==0)
  432.                 {
  433.                         lab_feldliste[z]->code=-1;
  434.                         lab_feldliste[z]->art=L_WEG;
  435. //                      lab_feldliste[z]->art=L_GEGNER;
  436.                 }
  437.         }
  438.  
  439.  
  440.  
  441.  
  442. // Tueren verteilen ------------------------------------------------------------
  443.         int tuermenge=rand()%6+4;
  444.         int tatsaechlich_gesetzte_tueren=0;
  445.         int tatsaechlich_gesetzte_schluessel=0;
  446.         for(int tm=0;tm<tuermenge;tm++)
  447.         {
  448. // Tuere setzen
  449. #if DEBUG
  450.                 printf("Suche Platz fuer Tuere #%i...\n",tm);
  451. #endif
  452. // Leere Stellen mit 2 gegenueberliegenden Waenden suchen
  453.                 bool tuerplatz_gefunden=false;
  454.                 int sicherheitsbegrenzer=1000000;
  455.                 while(sicherheitsbegrenzer>0)
  456.                 {
  457. // Zufallsposition
  458.                         int zx=rand()%(breite-1)+1;
  459.                         int zy=rand()%(hoehe-1)+1;
  460. // Gueltiges Feld?
  461.                         int feld=zy*breite+zx;
  462.                         if(feld>=0&&feld<lab_feldmenge-1)
  463.                         {
  464. // Leere Stelle?
  465.                                 if(lab_feldliste[feld]->art==L_WEG)
  466.                                 {
  467. // Links und rechts eine Wand?
  468.                                         if(zx+1<breite-2&&zx-1>=1)
  469.                                         {
  470.                                                 if(lab_feldliste[feld+1]->art==L_WAND&&lab_feldliste[feld-1]->art==L_WAND)
  471.                                                 {
  472. // Oben und unten frei?
  473.                                                         if(zy+1<hoehe-2&&zy-1>=1)
  474.                                                         {
  475.                                                                 if(lab_feldliste[feld+breite]->art==L_WEG&&lab_feldliste[feld-breite]->art==L_WEG)
  476.                                                                 {
  477. // Platz fuer Tuere gefunden. Tuere einbauen
  478. #if DEBUG
  479.                                                                         printf("Platz fuer Tuere #%i gefunden. (%ix%i)\n",tm,zx,zy);
  480. #endif
  481.                                                                         lab_feldliste[feld]->art=L_TUER_ZU;
  482.                                                                         lab_feldliste[feld]->code=tm;
  483.                                                                         tuerplatz_gefunden=true;
  484.                                                                 }
  485.                                                         }
  486.                                                 }
  487.                                         }
  488.                                 }
  489.                         }
  490.  
  491.                         if(tuerplatz_gefunden){break;}
  492.  
  493.                         sicherheitsbegrenzer--;
  494.                 }
  495.  
  496. // Schluessel verstecken -------------------------------------------------------
  497.                 if(tuerplatz_gefunden)
  498.                 {
  499.                         tatsaechlich_gesetzte_tueren++;
  500.  
  501. // Schluessel plazieren
  502. #if DEBUG
  503.                         printf("Suche Platz fuer Schluessel #%i...\n",tm);
  504. #endif
  505.  
  506.                         Weg_ablaeufer();
  507.  
  508.                         bool schluesselplatz_gefunden=false;
  509.                         int notabschaltung=1000000;
  510.                         while(notabschaltung>0)
  511.                         {
  512. // Zufallsposition
  513.                                 int zx=rand()%(breite-1)+1;
  514.                                 int zy=rand()%(hoehe-1)+1;
  515.                                 int feld=zy*breite+zx;
  516.  
  517.                                 if(*gelaufener_weg[feld])
  518.                                 {
  519. #if DEBUG
  520.                                         printf("Platz fuer Schluessel #%i gefunden. (%ix%i)\n",tm,zx,zy);
  521. #endif
  522.                                         lab_feldliste[feld]->art=L_SCHLUESSEL;
  523.                                         lab_feldliste[feld]->code=tm;
  524.                                         schluesselplatz_gefunden=true;
  525.                                         tatsaechlich_gesetzte_schluessel++;
  526.                                         break;
  527.                                 }
  528.  
  529.                                 notabschaltung--;
  530.                         }
  531.  
  532.                         if(!schluesselplatz_gefunden)
  533.                         {
  534. #if DEBUG
  535.                                 printf("\a\nPlatz fuer Schluessel %i nicht gefunden!",tm);
  536. #endif
  537.                                 return;
  538.                         }
  539.  
  540.  
  541.                 }
  542.                 else
  543.                 {
  544. #if DEBUG
  545.                         printf("\a\nPlatz fuer Tuere %i nicht gefunden!",tm);
  546. #endif
  547.                         return;
  548.                 }
  549.         }
  550.  
  551.  
  552.  
  553.  
  554.  
  555.  
  556. // Fertig ----------------------------------------------------------------------
  557.         if(tatsaechlich_gesetzte_tueren!=tatsaechlich_gesetzte_schluessel)
  558.         {
  559.                 fprintf(stderr,"\a\nAchtung! Labyrinth ist fehlerhaft! (#%i Tueren und #%i Schloesser)\n",tatsaechlich_gesetzte_tueren,tatsaechlich_gesetzte_schluessel);
  560.         }
  561.  
  562.  
  563. #if DEBUG
  564.         printf("Labyrinth erzeugen beendet.\n");
  565.         printf("Gesetzte Waende=%i, Startwaende=%i, Raeume=%i, Tueren=%i, Schluessel=%i\n",gesetzte_waende,startwaende,anzahl_raumsamen,tatsaechlich_gesetzte_tueren,tatsaechlich_gesetzte_schluessel);
  566. //      Testausgabe_ascii();
  567.         Testausgabe_sdl(false);
  568. #endif
  569. }
  570.  
  571.  
  572.  
  573.  
  574.  
  575.  
  576.  
  577.  
  578.  
  579. void labyrinTh::Weg_ablaeufer()
  580. {
  581.         if(gelaufener_weg!=NULL)
  582.         {
  583.                 for(int z=0;z<lab_feldmenge;z++)
  584.                 {
  585.                         delete(gelaufener_weg[z]);
  586.                 }
  587.                 free(gelaufener_weg);
  588.                 gelaufener_weg=NULL;
  589.         }
  590.  
  591.  
  592. // Weglisten anlegen
  593.         gelaufener_weg=(bool**)calloc(lab_feldmenge,sizeof(bool*));
  594.         if(gelaufener_weg==NULL)
  595.         {
  596.                 fprintf(stderr,"\a\nKonnte keinen Speicher fuer das Array >gelaufener_weg< bekommen!\n");
  597.                 return;
  598.         }
  599.  
  600.         for(int z=0;z<lab_feldmenge;z++)
  601.         {
  602.                 gelaufener_weg[z]=new bool;
  603.                 *gelaufener_weg[z]=false;
  604.         }
  605.  
  606.  
  607. // Loslaufen
  608.         koordinateN pos=startpos;
  609.  
  610.         bool erledigt=false;
  611.         *gelaufener_weg[pos.y*breite+pos.x]=true;
  612.         lifo->Ablegen(pos);
  613.  
  614. #if WEG_DEBUG
  615.         printf("Suche Weg... Startpos=%ix%i\n",pos.x,pos.y);
  616. #endif
  617.  
  618.         while(!erledigt)
  619.         {
  620. // Weiterlaufen
  621.                 int neupos=0;
  622.                 bool gelaufen=false;
  623.  
  624.                 for(int richtung=0;richtung<4;richtung++)
  625.                 {
  626. // Richtung festlegen
  627.                         switch(richtung)
  628.                         {
  629.                                 case 0:// nach oben
  630.                                         neupos=(pos.y-1)*breite+pos.x;
  631. #if WEG_DEBUG
  632.                                         printf("Nach oben...\n");
  633. #endif
  634.                                 break;
  635.                                 case 1:// nach rechts
  636.                                         neupos=pos.y*breite+pos.x+1;
  637. #if WEG_DEBUG
  638.                                         printf("Nach rechts...\n");
  639. #endif
  640.                                 break;
  641.                                 case 2:// nach unten
  642.                                         neupos=(pos.y+1)*breite+pos.x;
  643. #if WEG_DEBUG
  644.                                         printf("Nach unten...\n");
  645. #endif
  646.                                 break;
  647.                                 case 3:// nach links
  648.                                         neupos=pos.y*breite+pos.x-1;
  649. #if WEG_DEBUG
  650.                                         printf("Nach links...\n");
  651. #endif
  652.                                 break;
  653.                         }
  654.  
  655. // Ist die Position gueltig?
  656.                         if(neupos>=0&&neupos<lab_feldmenge)
  657.                         {
  658. // Ist das Feld frei und wurde noch nicht betreten?
  659.                                 if((lab_feldliste[neupos]->art==L_WEG||lab_feldliste[neupos]->art==L_SCHLUESSEL)&&!*gelaufener_weg[neupos])
  660.                                 {
  661. // Neues Feld Feld betreten
  662.                                         lifo->Ablegen(pos);
  663.                                         pos.y=neupos/breite;
  664.                                         pos.x=neupos-pos.y*breite;
  665.                                         *gelaufener_weg[neupos]=true;
  666.                                         lifo->Ablegen(pos);
  667.                                         gelaufen=true;
  668. #if WEG_DEBUG
  669.                                         printf("OK. Neue Position=%ix%i\n",pos.x,pos.y);
  670. #endif
  671.                                         break;
  672.                                 }
  673.                         }
  674. #if WEG_DEBUG
  675.                         else
  676.                         {
  677.                                 printf("Position ist ungueltig! (%ix%i)\n",pos.x,pos.y);
  678.                         }
  679. #endif
  680.                 }
  681.  
  682. // Weg zuruecklaufen
  683.                 if(!gelaufen)
  684.                 {
  685. #if WEG_DEBUG
  686.                         printf("Sackgasse. (%ix%i) Zurueck gehen.\n",pos.x,pos.y);
  687. #endif
  688.                         pos=lifo->Abfragen(&erledigt);
  689.                 }
  690.  
  691.  
  692. #if WEG_DEBUG
  693.                 Testausgabe_sdl(true);
  694. #endif
  695.         }
  696.  
  697.  
  698. #if DEBUG
  699.         printf("Weg vor Tuere gefunden.\n");
  700. #endif
  701. }
  702.  
  703.  
  704.  
  705.  
  706.  
  707.  
  708.  
  709.  
  710.  
  711. void labyrinTh::Labyrinth_loeschen()
  712. {
  713.         for(int z=0;z<lab_feldmenge;z++)
  714.         {
  715.                 delete(lab_feldliste[z]);
  716.         }
  717.         lab_feldliste=NULL;
  718.  
  719. #if DEBUG
  720.         printf("Vorhandenes Labyrinth geloescht.\n");
  721. #endif
  722. }
  723.  
  724.  
  725.  
  726.  
  727.  
  728.  
  729.  
  730.  
  731.  
  732. void labyrinTh::Ende()
  733. {
  734.         Labyrinth_loeschen();
  735.  
  736.         if(gelaufener_weg!=NULL)
  737.         {
  738.                 for(int z=0;z<lab_feldmenge;z++)
  739.                 {
  740.                         delete(gelaufener_weg[z]);
  741.                 }
  742.                 free(gelaufener_weg);
  743.         }
  744.  
  745.         delete(lifo);
  746.  
  747. #if DEBUG
  748.         printf("Labyrinth beendet.\n");
  749. #endif
  750. }
  751.  
  752.  
  753.  
  754.  
  755.  
  756.  
  757.  
  758.  
  759.  
  760. // Weg-LIFO ----------------------------------------------------------------------------------------
  761.  
  762. weg_liFo::weg_liFo()
  763. {
  764.         stapel=NULL;
  765.         stapellaenge=0;
  766.  
  767. #if DEBUG
  768.         printf("Weg-LIFO gestartet...\n");
  769. #endif
  770. }
  771.  
  772.  
  773.  
  774.  
  775.  
  776.  
  777.  
  778.  
  779.  
  780. void weg_liFo::Ablegen(koordinateN K)// (betretenes Feld)
  781. {
  782.         if(stapel!=NULL)
  783.         {
  784.                 if(stapel[stapellaenge-1]->x==K.x&&stapel[stapellaenge-1]->y==K.y)
  785.                 {
  786. #if LIFO_DEBUG
  787.                         printf("Koordinaten (%i,%i) sind schon abgelegt bei #%i.\n",stapel[stapellaenge-1]->x,stapel[stapellaenge-1]->y,stapellaenge);
  788. #endif
  789.                         return;
  790.                 }
  791.         }
  792.  
  793.         stapel=(koordinateN**)realloc(stapel,(stapellaenge+1)*sizeof(koordinateN*));
  794.         stapel[stapellaenge]=new koordinateN;
  795.         *stapel[stapellaenge]=K;
  796.         stapellaenge++;
  797.  
  798. #if LIFO_DEBUG
  799.         printf("#%i Koordinaten (%i,%i) in Weg-LIFO abgelegt.\n",stapellaenge,stapel[stapellaenge-1]->x,stapel[stapellaenge-1]->y);
  800. #endif
  801. }
  802.  
  803.  
  804.  
  805.  
  806.  
  807.  
  808.  
  809.  
  810.  
  811. koordinateN weg_liFo::Abfragen(bool* SL)// (Wird auf true gesetzt, wenn Stapel leer.) Gibt zuletzt abgelegte Koordinaten zurueck.
  812. {
  813.         koordinateN merker={-1,-1};
  814.  
  815.         if(stapellaenge<1)
  816.         {
  817.                 *SL=true;
  818.  
  819. #if LIFO_DEBUG
  820.                 printf("Weg-LIFO ist leer!\n");
  821. #endif
  822.                 return(merker);
  823.         }
  824.  
  825.         stapellaenge--;
  826.         merker=*stapel[stapellaenge];
  827.         delete(stapel[stapellaenge]);
  828.         stapel=(koordinateN**)realloc(stapel,(stapellaenge)*sizeof(koordinateN*));
  829.  
  830. #if LIFO_DEBUG
  831.         printf("#%i Koordinaten (%i,%i) aus Weg-LIFO abgefragt. Stapellaenge=",stapellaenge+1,merker.x,merker.y);
  832. #endif
  833.  
  834.         *SL=false;
  835.         if(stapellaenge==0)
  836.         {
  837.                 *SL=true;
  838.                 stapel=NULL;
  839.  
  840. #if LIFO_DEBUG
  841.                 printf("leer!\n");
  842. #endif
  843.         }
  844. #if LIFO_DEBUG
  845.         else
  846.         {
  847.                 printf("%i.\n",stapellaenge);
  848.         }
  849. #endif
  850.  
  851.         return(merker);
  852. }
  853.  
  854.  
  855.  
  856.  
  857.  
  858.  
  859.  
  860.  
  861.  
  862. #if DEBUG
  863. void weg_liFo::Zeichnen()
  864. {
  865.         if(stapel!=NULL)
  866.         {
  867.                 for(int p=0;p<stapellaenge;p++)
  868.                 {
  869.                         boxColor(display,stapel[p]->x*KLEINE_KACHELGROESSE,stapel[p]->y*KLEINE_KACHELGROESSE,stapel[p]->x*KLEINE_KACHELGROESSE+KLEINE_KACHELGROESSE,stapel[p]->y*KLEINE_KACHELGROESSE+KLEINE_KACHELGROESSE,0x0000ff50);
  870.                 }
  871.         }
  872. }
  873. #endif
  874.  
  875.  
  876.  
  877.  
  878.  
  879.  
  880.  
  881.  
  882.  
  883.  
  884. void weg_liFo::Ende()
  885. {
  886.         for(int z=0;z<stapellaenge;z++)
  887.         {
  888.                 delete(stapel[z]);
  889.         }
  890.         free(stapel);
  891.  
  892. #if LIFO_DEBUG
  893.         printf("Weg-LIFO beendet.\n");
  894. #endif
  895. }
  896.  
  897.  
  898.  
  899.  
  900.  
  901.  
  902.  
  903.  
  904.  
  905.  
  906.  
  907.  
  908.  
  909.  
  910.  
  911.  
  912.  
  913.  
  914.  

Quellcode

Hier kannst du den Code kopieren und ihn in deinen bevorzugten Editor einfügen. PASTEBIN_DOWNLOAD_SNIPPET_EXPLAIN