Der Anfänger Thread

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.

Search*amp*Destroy

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
}
//---------------------------------------------------------------------------

CStoll

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.

Search*amp*Destroy

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();
}
//---------------------------------------------------------------------------

CStoll

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)

desperate dusch

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

Braunstein

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

Shinja

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

fatderda

//-----------------------------------------------------------------------------
 //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

the_hammer

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