Der Anfänger Thread



  • Schau Dich bei Deinem "Werkzeug" genau im Menü um, sonst wirst Du ständig solche Pannen erleben.



  • ich benütze Borland C++Builder.

    die cd de beim Buch dabei war...



  • Mit welchen dateien müsste ich den die windows.h, include\genesis.h und Skelett.h verknüpfen?

    ed



  • Hallo

    Das sollte doch alles in deinem Buch stehen.

    chrische



  • Hallo,
    Nö im Buch steht nichts über das verknüpfen.



  • so ich habs jetzt weiter gemacht aber kann mir jemand verraten warum das Programm manchmal geht manchmal nicht???

    bin total ratlos.

    //HEADER---------------------------------------------------------------------
    #include <iostream.h>
    #include <iomanip.h>
    #include <conio.h>
    #include <math.h>
    //VOID-Deklaration-----------------------------------------------------------
    void feld (void);
    //MAIN-----------------------------------------------------------------------
    
    int main()
    {
    
     feld();
    
    }
    //Spielfeld------------------------------------------------------------------
    void feld (void)
    {
    char w=205,s=186,k=206,elo=201,elu=200,ero=187,eru=188,sou=203,soo=202,sol=185,sor=204,l=255;
    char eingabe=0;
    int groesse=0,richtungseingabe=0,zeile=10,spalte=2,zeilenbegrenzunglinks=0;
    int zeilenbegrenzungrechts=0,spaltenbegrenzungunten=0,spaltenbegrenzungoben=0;
    int schiffanzahleinser=0,schiffanzahlzweier=0;
    int schiffanzahldreier=0,schiffanzahlvierer=0,schiffanzahlfuenfer=0,feldgroesse=0;
    int feld[12][12]={NULL};
    
     //Ascii- Tabelle
     /*char linie=0;
     for(int i=0;i<265;i++)
       {
        linie=i;
        cout<<i<<" = "<<linie<<endl<<endl;
       }
     getchar();*/
    
     /*Werte der ASCII Zeichen des Spielfeldes
       Ergebnis
       leer=255                                     l
       doppellinie waagrecht=205                    w
       doppellinie senkrecht=186                    s
       doppellinie kreuz=206                        k
       doppellinie ecke links oben=201              elo
       doppellinie ecke links unten=200             elu
       doppellinie ecke rechts oben=187             ero
       doppellinie ecke rechts unten=188            eru
       doppellinie seitenteil Oeffnung unten=203    sou
       doppellinie seitenteil Oeffnung oben=202     soo
       doppellinie seitenteil Oeffnung links=185    sol
       doppellinie seitenteil Oeffnung rechts=204   sor
     */
    
     do
       {
        clrscr();
        cout<<"\n\tWaehlen Sie Ihren gewuenschten Schwierigkeitsgrad aus:"
            <<"\n\n\n\n\tFuer leicht (Feld:  8x 8) druecken Sie die Taste\t[l] bzw. [L]"
            <<"\n\tFuer mittel (Feld: 10x10) druecken Sie die Taste\t[m] bzw. [M]"
            <<"\n\tFuer schwer (Feld: 12x12) druecken Sie die Taste\t[s] bzw. [S]"
            <<"\n\n\tFuer die Hilfe druecken Sie die Taste\t\t\t[h] bzw. [H]";
        gotoxy(64,2);
        eingabe=getch();
    
        switch(eingabe)   //Auswahl des Schwierigkeitsgrades
           {
            case'l':
            case'L':   zeilenbegrenzunglinks=10;     //Begrenzung des Spielfeldes
                       zeilenbegrenzungrechts=29;
                       spaltenbegrenzungunten=15;
                       spaltenbegrenzungoben=2;
    
                       schiffanzahleinser=0;
                       schiffanzahlzweier=2;
                       schiffanzahldreier=2;
                       schiffanzahlvierer=1;
                       schiffanzahlfuenfer=0;
                       feldgroesse=5;
                       groesse=8;                    //Breite und Hoehe des Spielfeldes
                       break;
    
            case'm':
            case'M':   zeilenbegrenzunglinks=10;     //Begrenzung des Spielfeldes
                       zeilenbegrenzungrechts=36;
                       spaltenbegrenzungunten=19;
                       spaltenbegrenzungoben=2;
    
                       schiffanzahleinser=2;
                       schiffanzahlzweier=2;
                       schiffanzahldreier=2;
                       schiffanzahlvierer=1;
                       schiffanzahlfuenfer=0;
                       feldgroesse=7;
                       groesse=10;                   //Breite und Hoehe des Spielfeldes
                       break;
    
            case's':
            case'S':   zeilenbegrenzunglinks=10;     //Begrenzung des Spielfeldes
                       zeilenbegrenzungrechts=41;
                       spaltenbegrenzungunten=23;
                       spaltenbegrenzungoben=2;
    
                       schiffanzahleinser=4;
                       schiffanzahlzweier=3;
                       schiffanzahldreier=2;
                       schiffanzahlvierer=1;
                       schiffanzahlfuenfer=1;
                       feldgroesse=9;
                       groesse=12;                   //Breite und Hoehe des Spielfeldes
                       break;
    
            case'h':
            case'H':
                       clrscr();
                       cout<<"\n\tHilfe";
                       getchar();
                       eingabe='a';                  //Schleife kann nicht beendet werden (variable 'eingabe' ist nicht 'l', 'L', 'm', 'M', 's', 'S', 'h' oder 'H' sondern 'a')
                       break;
    
           }
        }while(eingabe!='l' && eingabe!='L' && eingabe!='m' && eingabe!='M' && eingabe!='s' && eingabe!='S' && eingabe!='h' && eingabe!='H');
    
    //---------------------------------------------------------------------------
    //---------------------------------------------------------------------------
    //---------------------------------------------------------------------------
    randomize();
    
    if(schiffanzahleinser!=0)
     {
     for(int zahl=0;zahl<schiffanzahleinser;zahl++)
        {
         int w=random(feldgroesse), s=random(feldgroesse); //Prueft ob platz schon belegt ist
    
             if(feld[w][s]==0)
               {
                int richtungswahl=random(2);
                if(richtungswahl==0)           //schiff in die waagerechte
                  {
                   feld[w][s]=1;
                  }
    
                if(richtungswahl==1)           //schiff in die senkrechte
                  {
                   feld[w][s]=1;
                  }
               }
    
             else
               {
                zahl--;
               }
    
        }
     }
    
    if(schiffanzahlzweier!=0)
     {
     for(int zahl=0;zahl<schiffanzahlzweier;zahl++)
        {
         int w=random(feldgroesse), s=random(feldgroesse);
    
             if(feld[w][s]==0&&feld[w+1][s]==0&&feld[w-1][s]==0&&feld[w][s+1]==0&&feld[w][s-1]==0) //Prueft ob platz schon belegt ist
               {
                int richtungswahl=random(2);
                if(richtungswahl==0)           //schiff in die waagerechte
                  {
                   feld[w][s]=1;
                   feld[w+1][s]=1;
                  }
    
                if(richtungswahl==1)           //schiff in die senkrechte
                  {
                   feld[w][s]=1;
                   feld[w][s+1]=1;
                  }
               }
    
             else
               {
                zahl--;
               }
    
        }
     }
    
    if(schiffanzahldreier!=0)
     {
     for(int zahl=0;zahl<schiffanzahldreier;zahl++)
        {
         int w=random(feldgroesse), s=random(feldgroesse);
    
             if(feld[w][s]==0&&feld[w+1][s]==0&&feld[w+2][s]==0&&feld[w-1][s]==0&&feld[w-2][s]==0&&feld[w][s+1]==0&&feld[w][s+2]==0&&feld[w][s-1]==0&&feld[w][s-2]==0) //Prueft ob platz schon belegt ist
               {
                int richtungswahl=random(2);
                if(richtungswahl==0)           //schiff in die waagerechte
                  {
                   feld[w][s]=1;
                   feld[w+1][s]=1;
                   feld[w+2][s]=1;
                  }
    
                if(richtungswahl==1)           //schiff in die senkrechte
                  {
                   feld[w][s]=1;
                   feld[w][s+1]=1;
                   feld[w][s+2]=1;
                  }
               }
    
             else
               {
                zahl--;
               }
    
        }
     }
    
    if(schiffanzahlvierer!=0)
     {
     for(int zahl=0;zahl<schiffanzahlvierer;zahl++)
        {
         int w=random(feldgroesse), s=random(feldgroesse);
    
             if(feld[w][s]==0&&feld[w+1][s]==0&&feld[w+2][s]==0&&feld[w+3][s]==0&&feld[w-1][s]==0&&feld[w-2][s]==0&&feld[w-3][s]==0&&feld[w][s+1]==0&&feld[w][s+2]==0&&feld[w][s+3]==0&&feld[w][s-1]==0&&feld[w][s-2]==0&&feld[w][s-3]==0) //Prueft ob platz schon belegt ist
               {
                int richtungswahl=random(2);
                if(richtungswahl==0)           //schiff in die waagerechte
                  {
                   feld[w][s]=1;
                   feld[w+1][s]=1;
                   feld[w+2][s]=1;
                   feld[w+3][s]=1;
                  }
    
                if(richtungswahl==1)           //schiff in die senkrechte
                  {
                   feld[w][s]=1;
                   feld[w][s+1]=1;
                   feld[w][s+2]=1;
                   feld[w][s+3]=1;
                  }
               }
    
             else
               {
                zahl--;
               }
    
        }
     }
    
    if(schiffanzahlfuenfer!=0)
     {
     for(int zahl=0;zahl<schiffanzahlfuenfer;zahl++)
        {
         int w=random(feldgroesse), s=random(feldgroesse);
    
             if(feld[w][s]==0&&feld[w+1][s]==0&&feld[w+2][s]==0&&feld[w+3][s]==0&&feld[w+4][s]==0&&feld[w-1][s]==0&&feld[w-2][s]==0&&feld[w-3][s]==0&&feld[w-4][s]==0&&feld[w][s+1]==0&&feld[w][s+2]==0&&feld[w][s+3]==0&&feld[w][s+4]==0&&feld[w][s-1]==0&&feld[w][s-2]==0&&feld[w][s-3]==0&&feld[w][s-4]==0) //Prueft ob platz schon belegt ist
               {
                int richtungswahl=random(2);
                if(richtungswahl==0)           //schiff in die waagerechte
                  {
                   feld[w][s]=1;
                   feld[w+1][s]=1;
                   feld[w+2][s]=1;
                   feld[w+3][s]=1;
                   feld[w+4][s]=1;
                  }
    
                if(richtungswahl==1)           //schiff in die senkrechte
                  {
                   feld[w][s]=1;
                   feld[w][s+1]=1;
                   feld[w][s+2]=1;
                   feld[w][s+3]=1;
                   feld[w][s+4]=1;
                  }
               }
    
             else
               {
                zahl--;
               }
    
        }
     }
    //---------------------------------------------------------------------------
    //---------------------------------------------------------------------------
    //---------------------------------------------------------------------------
    
     clrscr();
     //kopfzeile des Spielfeldes
     cout<<"\t"<<elo;
     for (int a=0;a<groesse-1;a++)
         {
          cout<<w<<w<<sou;
    
         }
     cout<<w<<w<<ero<<endl;
     //innere flaeche des Spielfeldes
     for(int zeile=0;zeile<groesse-1;zeile++)
        {
         cout<<"\t"<<s;
         for(int spalte=0;spalte<groesse;spalte++)
            {
             cout<<l<<l<<s;
            }
         cout<<endl<<"\t"<<sor;
    
         for(int spalte2=0;spalte2<groesse-1;spalte2++)
            {
             cout<<w<<w<<k;
            }
         cout<<w<<w<<sol<<endl;
    
        }
     //fusszeile des Spielfeldes
     cout<<"\t"<<s;
         for(int spalte=0;spalte<groesse;spalte++)
            {
             cout<<l<<l<<s;
            }
    
     cout<<endl<<"\t"<<elu;
     for(int b=0;b<groesse-1;b++)
        {
         cout<<w<<w<<soo;
        }
     cout<<w<<w<<eru;
    
     gotoxy(zeile,spalte);      //geht ins erste Kaestchen des Spielfeldes (Wertzuweisung oben)
    
     int zaehlerzeile=0,zaehlerspalte=0;
     do
       {
        gotoxy(60,2);
        cout<<"Koordinate";
        gotoxy(60,5);
        cout<<"Spalte:"<<setw(3)<<zaehlerspalte+1;
        gotoxy(60,6);
        cout<<"Zeile:"<<setw(4)<<zaehlerzeile+1;
    
        gotoxy(zeile,spalte);
    
        int richtung=getch();
    
        if(richtung==77)        //schritt nach rechts
          {
           if(zeile<zeilenbegrenzungrechts)
             {
              zeile=zeile+3;
              zaehlerspalte++;  //setzt aktuelle Possition im Array
             }
          }
        else if(richtung==75)   //schritt nach links
          {
           if(zeile>zeilenbegrenzunglinks)
             {
              zeile=zeile-3;
              zaehlerspalte--;  //setzt aktuelle Possition im Array
             }
          }
        else if(richtung==80)   //schritt nach unten
          {
           if(spalte<spaltenbegrenzungunten)
             {
              spalte=spalte+2;
              zaehlerzeile++;   //setzt aktuelle Possition im Array
             }
          }
        else if(richtung==72)   //schritt nach oben
          {
           if(spalte>spaltenbegrenzungoben)
             {
              spalte=spalte-2;
              zaehlerzeile--;   //setzt aktuelle Possition im Array
             }
          }
    
        if(richtung==13)
          {
           if(feld[zaehlerspalte][zaehlerzeile]==1)
             {
              cout<<"X";
             }
    
           else if(feld[zaehlerspalte][zaehlerzeile]==0)
             {
              cout<<'~';
             }
          }
    
       }while(richtungseingabe!=120 && richtungseingabe!=88); //das druecken der Taste X beendet die richtungsauswahl
    }
    //---------------------------------------------------------------------------
    


  • Ich denke, hier wird sich niemand einen 400-Zeilen-Quelltext ansehen, nur um herauszufinden, wo etwas "manchmal nicht geht" - da solltest du dir schon etwas mehr Mühe damit geben, das Problem einzugrenzen.



  • dann sagt mir wenigstens warum das net funktioniert ...
    ab und zu gehts mal und dann auch NUR Mittel oder Schwer

    //---------------------------------------------------------------------------
    
    #include <iostream.h>
    #include <conio.h>
    
    //---------------------------------------------------------------------------
    
    int main()
    {
     int feld[12][12]={NULL};
     char eingabe=0;
     int schiffanzahleinser=0,schiffanzahlzweier=0;
     int schiffanzahldreier=0,schiffanzahlvierer=0,schiffanzahlfuenfer=0,feldgroesse=0;
    
     cout<<"leicht\t= l\nmittel\t= m\nschwer\t= s\n\n";
    
     eingabe=getch();
    
     switch(eingabe)
       {
        case 'l':
    
                    schiffanzahlzweier=2;
                    schiffanzahldreier=2;
                    schiffanzahlvierer=1;
                    feldgroesse=5;
                    break;
    
        case 'm':
    
                    schiffanzahleinser=2;
                    schiffanzahlzweier=2;
                    schiffanzahldreier=2;
                    schiffanzahlvierer=1;
                    feldgroesse=7;
                    break;
    
        case 's':
    
                    schiffanzahleinser=4;
                    schiffanzahlzweier=3;
                    schiffanzahldreier=2;
                    schiffanzahlvierer=1;
                    schiffanzahlfuenfer=1;
                    feldgroesse=9;
                    break;
    
       }
    
     randomize();
    
     for(int zahl=0;zahl<schiffanzahleinser;zahl++)
        {
         int w=random(feldgroesse), s=random(feldgroesse);
    
             if(feld[w][s]==0)
               {
                int richtungswahl=random(2);
                if(richtungswahl==0)           //schiff in die waagerechte
                  {
                   feld[w][s]=1;
                  }
    
                if(richtungswahl==1)           //schiff in die senkrechte
                  {
                   feld[w][s]=1;
                  }
               }
    
             else
               {
                zahl--;
               }
    
        }
    
     for(int zahl=0;zahl<schiffanzahlzweier;zahl++)
        {
         int w=random(feldgroesse), s=random(feldgroesse);
    
             if(feld[w][s]==0&&feld[w+1][s]==0&&feld[w-1][s]==0&&feld[w][s+1]==0&&feld[w][s-1]==0)
               {
                int richtungswahl=random(2);
                if(richtungswahl==0)           //schiff in die waagerechte
                  {
                   feld[w][s]=1;
                   feld[w+1][s]=1;
                  }
    
                if(richtungswahl==1)           //schiff in die senkrechte
                  {
                   feld[w][s]=1;
                   feld[w][s+1]=1;
                  }
               }
    
             else
               {
                zahl--;
               }
    
        }
    
     for(int zahl=0;zahl<schiffanzahldreier;zahl++)
        {
         int w=random(feldgroesse), s=random(feldgroesse);
    
             if(feld[w][s]==0&&feld[w+1][s]==0&&feld[w+2][s]==0&&feld[w-1][s]==0&&feld[w-2][s]==0&&feld[w][s+1]==0&&feld[w][s+2]==0&&feld[w][s-1]==0&&feld[w][s-2]==0)
               {
                int richtungswahl=random(2);
                if(richtungswahl==0)           //schiff in die waagerechte
                  {
                   feld[w][s]=1;
                   feld[w+1][s]=1;
                   feld[w+2][s]=1;
                  }
    
                if(richtungswahl==1)           //schiff in die senkrechte
                  {
                   feld[w][s]=1;
                   feld[w][s+1]=1;
                   feld[w][s+2]=1;
                  }
               }
    
             else
               {
                zahl--;
               }
    
        }
    
     for(int zahl=0;zahl<schiffanzahlvierer;zahl++)
        {
         int w=random(feldgroesse), s=random(feldgroesse);
    
             if(feld[w][s]==0&&feld[w+1][s]==0&&feld[w+2][s]==0&&feld[w+3][s]==0&&feld[w-1][s]==0&&feld[w-2][s]==0&&feld[w-3][s]==0&&feld[w][s+1]==0&&feld[w][s+2]==0&&feld[w][s+3]==0&&feld[w][s-1]==0&&feld[w][s-2]==0&&feld[w][s-3]==0)
               {
                int richtungswahl=random(2);
                if(richtungswahl==0)           //schiff in die waagerechte
                  {
                   feld[w][s]=1;
                   feld[w+1][s]=1;
                   feld[w+2][s]=1;
                   feld[w+3][s]=1;
                  }
    
                if(richtungswahl==1)           //schiff in die senkrechte
                  {
                   feld[w][s]=1;
                   feld[w][s+1]=1;
                   feld[w][s+2]=1;
                   feld[w][s+3]=1;
                  }
               }
    
             else
               {
                zahl--;
               }
    
        }
    
     for(int zahl=0;zahl<schiffanzahlfuenfer;zahl++)
        {
         int w=random(feldgroesse), s=random(feldgroesse);
    
             if(feld[w][s]==0&&feld[w+1][s]==0&&feld[w+2][s]==0&&feld[w+3][s]==0&&feld[w+4][s]==0&&feld[w-1][s]==0&&feld[w-2][s]==0&&feld[w-3][s]==0&&feld[w-4][s]==0&&feld[w][s+1]==0&&feld[w][s+2]==0&&feld[w][s+3]==0&&feld[w][s+4]==0&&feld[w][s-1]==0&&feld[w][s-2]==0&&feld[w][s-3]==0&&feld[w][s-4]==0)
               {
                int richtungswahl=random(2);
                if(richtungswahl==0)           //schiff in die waagerechte
                  {
                   feld[w][s]=1;
                   feld[w+1][s]=1;
                   feld[w+2][s]=1;
                   feld[w+3][s]=1;
                   feld[w+4][s]=1;
                  }
    
                if(richtungswahl==1)           //schiff in die senkrechte
                  {
                   feld[w][s]=1;
                   feld[w][s+1]=1;
                   feld[w][s+2]=1;
                   feld[w][s+3]=1;
                   feld[w][s+4]=1;
                  }
               }
    
             else
               {
                zahl--;
               }
    
        }
    
     for(int zeile=0;zeile<feldgroesse+3;zeile++)
        {
         for(int spalte=0;spalte<feldgroesse+3;spalte++)
            {
             cout<<feld[spalte][zeile];
            }
         cout<<endl;
        }
           getchar();
    }
    //---------------------------------------------------------------------------
    


  • Search&Destroy schrieb:

    dann sagt mir wenigstens warum das net funktioniert ...

    Weil du irgendwo Mist gebaut hast.

    (Sorry, wenn du dir keine Mühe gibst und nur ellenlange Quelltexte mit einem "das klappt nicht" reinstellst, wird dir hier NIEMAND helfen. Schau dir den Quelltext genauer an und dann versuch erstmal selber herauszufinden, wo ungefähr der Fehler auftritt (und vor allem, wie er sich äußert) - dann können wir hier vielleicht weitersehen)



  • gudens. hab kein dummy forum für cpp gefunden. also
    ich überschreibe einen operator() für die berechnung des ywertes in einem polynom.
    in dieser methode laufe ich mit einem iterator eine liste entlang.
    double Polynomial::operator()(double x)
    {
    double y;
    std::list<Polynomial>::iterator it;
    for (it=polynom.begin();it!=polynom.end();it++)
    {
    .....
    }
    }
    in der zeile in der ich den iterator deklariere erhalte ich folgende eclipsemeldung:

    ../Polynomial.cpp:9: error: no match for 'operator!=' in 'it != ((Polynomial*)this)->Polynomial::polynom. std::list<_Tp, _Alloc>::end [with _Tp = Monomial, _Alloc = std::allocator<Monomial>]()'
    /usr/lib/gcc/i486-linux-gnu/4.0.3/../../../../include/c++/4.0.3/bits/stl_list.h:172: note: candidates are: bool std::_List_iterator<_Tp>::operator!=(const std::_List_iterator<_Tp>&) const [with _Tp = Polynomial]

    für mich als laien relativ wirr, das ganze.
    kann es sein, dass ich die beiden operatoren = und != auch überladen muss, da es sich bei der liste um einen selbstdefinierten datentyp handelt?

    an die, die sich die mühe machen und das durchlesen

    vielen dank
    gruß
    philipp



  • Nimm mal einen const_iterator.
    Was hat diese Frage hier eigentlich zu suchen?



  • Naja, sieh dir den Titel an, ergo passts eigentlich.



  • //-----------------------------------------------------------------------------
     //Header mit Klassendeklaration von G3DGame
     //-----------------------------------------------------------------------------
     #include <windows.h>
     #include "Game1.h"
    
     class TGame
     {
     public:
       //Eigenschaften
       geEngine      *Engine;
       geWorld       *World;
       geCamera      *Camera;
       geDriver      *Driver;
       geDriver_Mode *DMode;
       geXForm3d      XForm;
       bool           isRunning;
       //Methoden
       void CreateGame   (void);
       void RunGame      (void);
       void FreeGame     (void);
       void SetDriver    (void);
       void ExitError    (char *Txt);
     };
    
     //Pfad- und Dateinamen
     const char *Pfad      = ".\\levels\\";
     const char *BSP_Datei = "World0.bsp";
     const char *GVersion  = "GPlay1";
     const int MaxWidth    = 800;
     const int MaxHeight   = 600;
    
     HWND GHandle; TGame Game; geRect WorldScreen; char WorldName[64];
     geVFile *WorldFile;
    
     void TGame::CreateGame (void)
     {
       geRect   WorldScreen;
       char     WorldName[64];
       geVFile *WorldFile;
       Engine = geEngine_Create (GHandle, GVersion, ".");
       if (!Engine) ExitError
         ("3D-Engine kann nicht gestartet werden!");
       geEngine_EnableFrameRateCounter(Engine, GE_FALSE);
       SetDriver ();
       WorldScreen.Left  = 0;
       WorldScreen.Right  = MaxWidth  -1;
       WorldScreen.Top  = 0;
       WorldScreen.Bottom  = MaxHeight -1;
       geXFrom3d_SetIdentity (&XForm);
       Camera = geCamera_Create (2.0, &WorldScreen);
       if (!Camera) ExitError
         ("Kamera kann nicht installiert werden!");
       strcpy (WorldName, Pfad);
       strcat (WorldName, BSP_Datei);
       WorldFile = geVFile_OpenNewSystem (NULL,
         GE_VFILE_TYPE_DOS, WorldName, NULL,
         GE_VFILE_OPEN_READONLY);
       if (WorldFile)
       {
        World = geWorld_Create(WorldFile);
        geVFile_Close(WorldFile);
       );
       if (!World) ExitError
         ("Welt/Level lässt sich nicht erzeugen!");
       if (!geEngine_AddWorld(Engine, World)) ExitError
         ("Welt/Level lässt sich nicht einbinden!");
       }
       Engine = geEngine_Create (GHandle, GVersion, ".");
       if (!Engine) ExitError ()
         ("3D-Engine kann nciht gestartet werden!");
    
     geRect WorldScreen; char WorldName[64]; geVFile *WorldFile;
    
     #include "Skelett.h"
     LRESULT CALLBACK WndProc (HWND hWnd,
      UNIT iMessage, WPARAM wParam, LPARAM lParam);
     {
      switch (iMessage)
      {
       case WM_KEYDOWN;
       {
        switch (wParam)
        {
         case VK_ESCAPE:
         {
          PostMessage(hWnd, WM_QUIT, 0, 0);
         }
        }
       }
       default:
        return DefWindowProc
         (hWnd, iMessage, wParam, lParam);
      }
      return 0;
     }
    
     int WINAPI WinMain
    (HINSTANCE hInstance, HINSTANCE hPrevInstance,
     LPSTR lpCmdLine, int nCmdShow)
    {
     WNDCLASS Win;
     MSG      msg;
     Win.cbClsExtra = 0;
     Win.cbWndExtra = 0;
     Win.hInstance = hInstance;
     Win.hIcon = LoadIcon(hInstance, IDI_APPLICATION);
     Win.hCursor = LoadCursor(NULL, IDC_ARROW);
     Win.hbrBackground =
     (HBRUSH)GetStockObject (BLACK_BRUSH);
     Win.style = CS_HREDRAW | CS_VREDRAW;
     Win.lpfnWndProc = WndProc;
     Win.lpszClassName = "???";
     Win.lpszMenuName = NULL;
     RegisterClass (&Win);
     GHandle = CreateWindow (Win.lpszClassName,
       "Windows Minimum - [Esc]=Ende", WS_TILED,
       CW_USEDEFAULT, CW_USEDEFAULT, MaxWidth,
       MaxHeight, NULL, NULL, hInstance, NULL);
     if (!GHandle)
     {
      return 0;
     }
     ShowWindow  (GHandle, nCmdShow);
     UpdateWindow (GHandle);
     isRunning = true;
     while (isRunning)
     {
     while
      (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))
     {
      if (!GetMessage(&msg, NULL, 0, 0))
      {
       isRunning = false;
       break;
      }
      TranslateMessage (&msg);
      DispatchMessage  (&msg);
      }
     }
     return 1;
    }
    
    void TGame::ExitError (char *Txt)
    {
     MessageBox (NULL, Txt, "Fehler, 48);
     FreeGame();
     _exit (EXIT_FAILURE);
    }
    
    void TGame::RunGame (void)
    {
     geXForm3d_SetIdentity (&XForm);
     geXForm3d_RotateX (&XForm, 0.0);
     geXForm3d_RotateY (&XForm, 0.0);
     geXForm3d_RotateZ (&XForm, 0.0);
     geXForm3d_Translate (&XForm, 0.0, 0.0, 0.0);
     geCamera_SetWorldSpaceXForm (Camera, &XForm);
     if (!geEngine_BeginFrame(Engine, Camera, GE_TRUE))
       ExitError ("BeginFrame gescheitert!");
       if (!geEngine_RenderWorld
          (Engine, World, Camera, 0.0)) ExitError
            ("Rendering gescheitert!");
     if (!geEngine_endFrame(Engine)) ExitError
        ("EndFrame sescheitert!");
    }
    
    void TGame::FreeGame (void)
    {
     if (Camera) geCamera_Destroy (&Camera);
     if (World) geWorld_Free (World);
     if (Engine)
     {
       geEngine_ShutdownDriver(Engine);
       geEngine_Free (Engine);
     }
     Camera = NULL; World = NULL; Engine = NULL;
     }
    
     void TGame::SetDriver (void)
     {
      geDriver_System *DriverSystem; long Breite, Hoehe;
      DriverSystem = geEngine_GetDriverSystem (Engine);
      if (!DriverSystem)
        ExitError ("Kein Treibersystem gefunden!");
      Driver = geDriver_SystemGetNextDriver
       (DriverSystem, NULL);
      if (!Driver) ExitError ("Treiber nicht gefunden!");
      DMode = geDriver_GetNextMode (Driver, NULL)
      while(true)
      {
       if (!DMode) ExitError ("Falscher Treibermodus!");
       geDriver_ModeGetWidthHeight
         (DMode, &Breite, &Hoehe);
       if (Breite == MaxWidth && Hoehe == MaxHeight) break;
       DMode = geDriver_GetNextMode (Driver, DMode);
      }
       if ((!Driver) || (!DMode)) ExitError
         ("Kein passender Grafiktreiber/modus!");
       if (!geEngine_SetDriverAndMode
          (Engine, Driver, DMode)) ExitError
           ("Grafikinitialisirung fehlgeschlagen!");
      }
    
      GHandle = CreateWindow (Win.lpszClassName,
       " Genesis3d - [Esc]=Ende", WS_Tiled,
       CW_USEDEFAULT, CW_USEDEFAULT, MaxWidth,
       MaxHeight, NULL, NULL, hInstance, NULL);
       ShowCursor (false);
       ShowWindow (GHandle, nCmdShow);
       UpdateWindow (GHandle);
       Game.CreateGame ();
       Game.isRunning = true;
       while (Game.isRunning)
       {
        while (PeekMessage
         (&msg, NULL, 0, 0, PM_NOREMOVE))
    
        {
         Game.RunGame();
         if (!GetMessage(&msg, NULL, 0, 0 ))
         {
          Game.isRunning = false;
          break;
         }
         TranslateMessage (&msg);
         DispatchMessage  (&msg);
         }
        }
        Game.FreeGame ();
        return 1;
    

    das wäre mein etwas weiterentwikelter quelltext(ich bin Neuling9099)
    kann mir jemand sagen wo der text

    GHandle = CreateWindow (Win.lpszClassName,
       " Genesis3d - [Esc]=Ende", WS_Tiled,
       CW_USEDEFAULT, CW_USEDEFAULT, MaxWidth,
       MaxHeight, NULL, NULL, hInstance, NULL);
       ShowCursor (false);
       ShowWindow (GHandle, nCmdShow);
       UpdateWindow (GHandle);
       Game.CreateGame ();
       Game.isRunning = true;
       while (Game.isRunning)
       {
        while (PeekMessage
         (&msg, NULL, 0, 0, PM_NOREMOVE))
    
        {
         Game.RunGame();
         if (!GetMessage(&msg, NULL, 0, 0 ))
         {
          Game.isRunning = false;
          break;
         }
         TranslateMessage (&msg);
         DispatchMessage  (&msg);
         }
        }
        Game.FreeGame ();
        return 1;
    

    hinkommt?

    danke im voraus



  • hi,
    ich hab ein Programm mit mehreren Formen und Units erstellt. Jetzt versuche ich eine Varieable in mehreren Units zu verwenden. Kann mir jemand sagen, wie ich das machen kann.

    mfg


Anmelden zum Antworten