TicTacToe Clon - Programm macht was es will - Hilfe zum Buch "C++ für Spieleprogrammierer" von Heiko Kalista

TicTacToe Clon - Programm macht was es will

Werbeanzeige

raXor

Alter Hase

Beiträge: 688

25.01.2008, 16:54

TicTacToe Clon - Programm macht was es will

Hallo liebe Programmierer. Um mein Problem zu verstehen, muss ich euch einen Einblick in meine PC Nutzung und Hardware geben:
Ich habe ein
- Laptop mit Windows Vista
- PC mit Windows XP

Auf dem Laptop habe ich mein erstes Spiel geschrieben, kurz TucTacToe.
Ich hab es kompiliert und es geht einwandfrei. Alle Funktionen gehen, die Optionen, indenen man einstellen kann wer anfangen soll, der Computerspieler, alles geht. Natürlich will ich nicht alleine auf dem Spiel versauern, also hab ich es an einen Freund gesendet (XP User). Als er es dann geladen und entpackt hat, trifft ihn der Schlag:

Zitat

Die Anwendugskonfiguration konnte nicht geladen werden. Neuinstallation könnte das Problem beheben

Kurzerhand hab ich das Spiel mal auf mein PC geladen und das gleiche passiert... Jetzt hab ich einfach mal den Quellcode vom Laptop auf meinen PC kopiert und Kompiliert. Ich habs mit 2 verschiedenen versucht, aber beidemal das gleiche Ergebniss:
Optionen zu konfigurieren geht nicht, Wenn ich ein Kreuz setzen will flackert alles etc etc...

Jetzt meine Fragen an euch:
1. An was kann das liegen, dass das Spiel unter XP kompiliert herumspinnt
2. Wie könnte man das beheben
3. Warum geht das auf Vista kompilierte Spiel nicht auf XP Rechnern?

Hier mal der Downloadlink für meine "Vista Version": http://game-community.org/downloads//RixRaxRoe_v.0.6.rar

und hier der Quellcode des gesamten Spiels:

C-/C++-Quelltext

/////////////////////////////////////////

//////////TicTacToe - The Game///////////

//////////////////V 0.1//////////////////

/////////////////By raXor////////////////

/////////////////////////////////////////



#include <iostream>
#include <limits>
#include <windows.h>

using namespace std;

#pragma comment (lib, "winmm.lib")

// Strukturen

//

struct S_Besetzt
{
    int Besetzt;
};

// Globale (WÜRG) Variablen

//

const int  Breite = 3;  // Breite des Feldes

const int Hoehe = 3;    // Hoehe des Feldes


S_Besetzt Spielfeld[Breite][Hoehe];

// Prototypen

//

void SpielStarten1 (int *ppruefe);
void SpielStarten2 (int *ppruefe);
void DatenEingebenSpieler1 ();
void DatenEingebenSpieler2 ();
void DatenEingebenPC ();
int Optionen (int SpielerComputer);
void Info ();
void Beenden ();
void SpielfeldAnzeigen ();
void PruefeSieger (int *ppruefe);

/////////////////////

// Hauptprogramm   //

/////////////////////

int main ()
{
    // Variablen

    // 

    int iAuswahl;
    int ppruefe;
    int SpielerComputer = 1;

    // Zufallsgenerator initialisieren

    srand (timeGetTime ());
    
    cout << "\n ~ ~ Willkommen bei RixRaxRoe ~ ~ " << endl;
    cout << "\n   -> One Clone of TicTacToe <-   " << endl;
    cout << "      ----------------------" << endl;
    do
    {
        // Hauptmenü

        
        cout << "\n ~ ~ Hauptmenue ~ ~\n" << endl;
        cout << "       1 - Spiel Starten - 1" << endl;
        cout << "       2 -    Optionen   - 2" << endl;
        cout << "       3 - Informationen - 3" << endl;
        cout << "       4 - Spiel beenden - 4" << endl;
        cout << "         Auswahl ";
        cin >> iAuswahl;
         while (! cin ) // Nutzereingabe wiederholen, wenn sie nicht korrekt war 

      { 
        cin.clear(); 
        cin.ignore(); 
        system("cls");
        cout << "\n Nur 1, 2, 3 und 4 sind gueltige Eingaben!\n"; 
        cout << "\n ~ ~ Hauptmenue ~ ~\n" << endl;
        cout << "       1 - Spiel Starten - 1" << endl;
        cout << "       2 -    Optionen   - 2" << endl;
        cout << "       3 - Informationen - 3" << endl;
        cout << "       4 - Spiel beenden - 4" << endl;
        cout << "         Auswahl ";
        cin >> iAuswahl;
      }
        cout << "\n\n";

        switch (iAuswahl)
        {

        case (1):
            {
                if (SpielerComputer == 1)
                SpielStarten1 (&ppruefe);

                else
                SpielStarten2 (&ppruefe);
            }   break;

        case (2):
            {
                Optionen (SpielerComputer);
            }   break;

        case (3):
            {
                Info ();
            }   break;

        case (4):
            {
                Beenden ();
            }   break;

        default:
            {
            system("cls");
            cout << "   Nur 1, 2, 3 und 4 sind gueltige Eingaben" << endl;
            }   break;
        }
    }   while (iAuswahl != 4);

    return 0;
}   // main Funktion Ende

    ////////////////////////



///////////////////////////////////////////////////////////////////////

// PruefeSieger Funktion                                             //

// Aufgabe: Überprüfung ob Gewinn eines Spielers oder Unentschieden    //

///////////////////////////////////////////////////////////////////////

void PruefeSieger (int *ppruefe)
{

    if (Spielfeld[1-1][1-1].Besetzt == 1 && Spielfeld[1-1][2-1].Besetzt == 1 && Spielfeld[1-1][3-1].Besetzt == 1 ||
        Spielfeld[2-1][1-1].Besetzt == 1 && Spielfeld[2-1][2-1].Besetzt == 1 && Spielfeld[2-1][3-1].Besetzt == 1 ||
        Spielfeld[3-1][1-1].Besetzt == 1 && Spielfeld[3-1][2-1].Besetzt == 1 && Spielfeld[3-1][3-1].Besetzt == 1 ||
        Spielfeld[1-1][1-1].Besetzt == 1 && Spielfeld[2-1][1-1].Besetzt == 1 && Spielfeld[3-1][1-1].Besetzt == 1 ||
        Spielfeld[1-1][2-1].Besetzt == 1 && Spielfeld[2-1][2-1].Besetzt == 1 && Spielfeld[3-1][2-1].Besetzt == 1 ||
        Spielfeld[1-1][3-1].Besetzt == 1 && Spielfeld[2-1][3-1].Besetzt == 1 && Spielfeld[3-1][3-1].Besetzt == 1 ||
        Spielfeld[1-1][1-1].Besetzt == 1 && Spielfeld[2-1][2-1].Besetzt == 1 && Spielfeld[3-1][3-1].Besetzt == 1 ||
        Spielfeld[3-1][1-1].Besetzt == 1 && Spielfeld[2-1][2-1].Besetzt == 1 && Spielfeld[1-1][3-1].Besetzt == 1)
    {
        *ppruefe = 1;
    }

    else if (Spielfeld[1-1][1-1].Besetzt == 2 && Spielfeld[1-1][2-1].Besetzt == 2 && Spielfeld[1-1][3-1].Besetzt == 2 ||
            Spielfeld[2-1][1-1].Besetzt == 2 && Spielfeld[2-1][2-1].Besetzt == 2 && Spielfeld[2-1][3-1].Besetzt == 2 ||
            Spielfeld[3-1][1-1].Besetzt == 2 && Spielfeld[3-1][2-1].Besetzt == 2 && Spielfeld[3-1][3-1].Besetzt == 2 ||
            Spielfeld[1-1][1-1].Besetzt == 2 && Spielfeld[2-1][1-1].Besetzt == 2 && Spielfeld[3-1][1-1].Besetzt == 2 ||
            Spielfeld[1-1][2-1].Besetzt == 2 && Spielfeld[2-1][2-1].Besetzt == 2 && Spielfeld[3-1][2-1].Besetzt == 2 ||
            Spielfeld[1-1][3-1].Besetzt == 2 && Spielfeld[2-1][3-1].Besetzt == 2 && Spielfeld[3-1][3-1].Besetzt == 2 ||
            Spielfeld[1-1][1-1].Besetzt == 2 && Spielfeld[2-1][2-1].Besetzt == 2 && Spielfeld[3-1][3-1].Besetzt == 2 ||
            Spielfeld[3-1][1-1].Besetzt == 2 && Spielfeld[2-1][2-1].Besetzt == 2 && Spielfeld[1-1][3-1].Besetzt == 2)

    {
        *ppruefe = 2;
    }

    else 
    {
        *ppruefe = 0;
    }
}   // PruefeSieger Funktion Ende

    //////////////////////////////



/////////////////////////////////////////////////////////////

// SpielStarten1 Funktion                                  //

// Aufgabe: Startet das Spiel und ruft die Spieldaten ab   //

/////////////////////////////////////////////////////////////

void SpielStarten1 (int *ppruefe)
{
int counter = 9;
int Auswahl;

// Spielfeld vor jeder Runde löschen

for (int y=0; y<Hoehe; y++)
{
    for (int x=0; x<Breite; x++)
    {
        Spielfeld[x][y].Besetzt = false;
    }
}

// Spieler gegen Spieler oder Spieler gegen PC?


do 
        {
            system ("cls");
            cout << "\n ~ ~  RixRaxRoe - neues Spiel  ~ ~ \n" << endl;
            cout << "   1 -    Spieler gegen Spieler   - 1" << endl;
            cout << "   2 - Spieler gegen den Computer - 2" << endl;
            cout << "   3 -   Zurueck zum Hauptmenue   - 3" << endl;
            cout << "            Auswahl ";
            cin >> Auswahl;
             while  (! cin) 
              { 
                  cin.clear(); 
                  cin.ignore(); 
                  system ("cls");
                  cout << "\n   Nur 1, 2 und 3 sind gueltige Eingaben\n"; 
                  cout << "\n   ~ ~  RixRaxRoe - neues Spiel  ~ ~ \n" << endl;
                  cout << " 1 -    Spieler gegen Spieler   - 1" << endl;
                  cout << " 2 - Spieler gegen den Computer - 2" << endl;
                  cout << " 3 -   Zurueck zum Hauptmenue   - 3" << endl;
                  cout << "          Auswahl ";
                  cin >> Auswahl;
              }

        }   while (Auswahl < 1 || Auswahl > 3);

    switch (Auswahl)
    {

    // Spieler gegen Spieler ausgewählt

    case (1):
        {
            system ("cls");
            cout << "\n ~ ~  RixRaxRoe - Spieler gegen Spieler  ~ ~ \n" << endl;

        // Schleife solange auführen, bis ein Sieger feststeht

        do 
        {
            SpielfeldAnzeigen (); 
            DatenEingebenSpieler1 (); system ("cls");
        
            -- counter;

            PruefeSieger (ppruefe);
            if (counter == 0 || *ppruefe != 0)
            break;
            SpielfeldAnzeigen ();
            DatenEingebenSpieler2 (); system ("cls");
        
            -- counter;
            PruefeSieger (ppruefe);
        } while (*ppruefe == 0 && counter != 0);
    
        SpielfeldAnzeigen ();
    if (*ppruefe == 0)
        cout << "   \n  Unentschieden" << endl;
    else if (*ppruefe == 1)
        cout << "   \n  Spieler 1 hat gewonnen! Glueckwunsch!" << endl;
    else if (*ppruefe == 2)
        cout << "   \n  Spieler 2 hat gewonnen! Glueckwunsch!" << endl;
        // Sieger laut ppruefe festlegen

        }   break;

        // Spieler gegen Computer Ausgewählt:

        case (2):
        {
            system ("cls");
            cout << "\n ~ ~  RixRaxRoe - Spieler gegen Computer  ~ ~ \n" << endl;
            // Schleife solange auführen, bis ein Sieger feststeht

        do 
        {
            SpielfeldAnzeigen ();
            DatenEingebenSpieler1 (); system ("cls");
        
            -- counter;

            PruefeSieger (ppruefe);
            if (counter == 0 || *ppruefe != 0)
            break;
            DatenEingebenPC(); system ("cls");
        
            -- counter;
            
            PruefeSieger (ppruefe);
            SpielfeldAnzeigen ();
            system ("cls");
        } while (*ppruefe == 0 && counter != 0);
            
            system ("cls");
            SpielfeldAnzeigen ();

    if (*ppruefe == 0)
        cout << "   \n  Unentschieden" << endl;
    else if (*ppruefe == 1)
        cout << "   \n  Du hast hat gewonnen! Glueckwunsch!" << endl;
    else if (*ppruefe == 2)
        cout << "   \n  Der Computer hat das Spiel gewonnen" << endl;
    // Sieger laut ppruefe festlegen

        }   break;

        case (3):
            {
                system ("cls");
                int main();
            } break;

    system ("cls");

    }

}   // SpielStarten Funktion Ende

    ///////////////////////////////



//////////////////////////////////////////////////////////

// SpielStarten2 Funktion                               //

// Aufgabe: Startet das Spiel und ruft die Spieldaten ab//

//////////////////////////////////////////////////////////

void SpielStarten2 (int *ppruefe)
{
int counter = 9;
int Auswahl;

// Spielfeld vor jeder Runde löschen

for (int y=0; y<Hoehe; y++)
{
    for (int x=0; x<Breite; x++)
    {
        Spielfeld[x][y].Besetzt = false;
    }
}

// Spieler gegen Spieler oder Spieler gegen PC?


do 
        {
            system ("cls");
            cout << "\n ~ ~  RixRaxRoe - neues Spiel  ~ ~ \n" << endl;
            cout << "   1 -    Spieler gegen Spieler   - 1" << endl;
            cout << "   2 - Spieler gegen den Computer - 2" << endl;
            cout << "   3 -   Zurueck zum Hauptmenue   - 3" << endl;
            cout << "            Auswahl ";
            cin >> Auswahl;
             while  (! cin) 
              { 
                  cin.clear(); 
                  cin.ignore(); 
                  system ("cls");
                  cout << "\n   Nur 1, 2 und 3 sind gueltige Eingaben\n"; 
                  cout << "\n   ~ ~  RixRaxRoe - neues Spiel  ~ ~ \n" << endl;
                  cout << " 1 -    Spieler gegen Spieler   - 1" << endl;
                  cout << " 2 - Spieler gegen den Computer - 2" << endl;
                  cout << " 3 -   Zurueck zum Hauptmenue   - 3" << endl;
                  cout << "          Auswahl ";
                  cin >> Auswahl;
              }

        }   while (Auswahl < 1 || Auswahl > 3);

    switch (Auswahl)
    {

    // Spieler gegen Spieler ausgewählt

    case (1):
        {
            system ("cls");
            cout << "\n ~ ~  RixRaxRoe - Spieler gegen Spieler  ~ ~ \n" << endl;

        // Schleife solange auführen, bis ein Sieger feststeht

        do 
        {
            SpielfeldAnzeigen (); 
            DatenEingebenSpieler1 (); system ("cls");
        
            -- counter;

            PruefeSieger (ppruefe);
            if (counter == 0 || *ppruefe != 0)
            break;
            SpielfeldAnzeigen ();
            DatenEingebenSpieler2 (); system ("cls");
            
            -- counter;
            PruefeSieger (ppruefe);
        } while (*ppruefe == 0 && counter != 0);
    
        SpielfeldAnzeigen ();
    if (*ppruefe == 0)
        cout << "   \n  Unentschieden" << endl;
    else if (*ppruefe == 1)
        cout << "   \n  Spieler 1 hat gewonnen! Glueckwunsch!" << endl;
    else if (*ppruefe == 2)
        cout << "   \n  Spieler 2 hat gewonnen! Glueckwunsch!" << endl;
        // Sieger laut ppruefe festlegen

        }   break;

        // Spieler gegen Computer Ausgewählt:

        case (2):
        {
            system ("cls");
            cout << "\n ~ ~  RixRaxRoe - Spieler gegen Computer  ~ ~ \n" << endl;
            // Schleife solange auführen, bis ein Sieger feststeht

        do 
        {
            SpielfeldAnzeigen ();
            DatenEingebenPC(); system ("cls");
            SpielfeldAnzeigen (); 
            
            -- counter;

            PruefeSieger (ppruefe);
            if (counter == 0 || *ppruefe != 0)
            break;
            DatenEingebenSpieler1 (); system ("cls");
            SpielfeldAnzeigen (); 
            -- counter;
            
            PruefeSieger (ppruefe);
            SpielfeldAnzeigen ();
            system ("cls");
            SpielfeldAnzeigen (); 
        } while (*ppruefe == 0 && counter != 0);
            
            system ("cls");
            SpielfeldAnzeigen ();

    if (*ppruefe == 0)
        cout << "   \n  Unentschieden" << endl;
    else if (*ppruefe == 1)
        cout << "   \n  Du hast hat gewonnen! Glueckwunsch!" << endl;
    else if (*ppruefe == 2)
        cout << "   \n  Der Computer hat das Spiel gewonnen" << endl;
    // Sieger laut ppruefe festlegen

        }   break;

        case (3):
            {
                system ("cls");
                int main();
            } break;

    system ("cls");

    }

}   // SpielStarten2 Funktion Ende

    ////////////////////////////////



////////////////////////////////

// SpielfeldAnzeigen Funktion //

// Aufgabe: Spielfeld zeichnen//

////////////////////////////////

void SpielfeldAnzeigen ()
{
        // Variablen

    int j = 1;
    
    cout << "\n     1     2     3\n" << endl;
    // Feld zeichnen

    for (int y=0; y<Hoehe; y++)
    {
        cout << "   " << j++;
        for (int x=0; x<Breite; x++)
        {   
            if (Spielfeld[x][y].Besetzt == 1 )
                cout << "  [X] ";
            else if (Spielfeld[x][y].Besetzt == 2)
                cout << "  [O] ";
            else 
                cout << "  [ ] ";
        }
    
        cout << endl;
    }
}   // SpielfeldAnzeigen Funktion Ende

    //////////////////////////////////


///////////////////////////////////////

// DatenEingebenSpieler1 Funktion:   //

// Aufgabe: Eingabe für den Spieler1 //

///////////////////////////////////////

void DatenEingebenSpieler1()
{
    // Variablen

    //

    char x, y;
    int _x, _y;
    do
    {
        cout << "   \n  Spieler 1, bitte gebe die Koordinaten fuer dein Kreuz ein:" << endl;
        do
        {
            cout << "   X Position eingeben ";
            cin >> x;
        } while (x<'1' || x>'3');
        do
        {
            cout << "   Y Position eingeben ";
            cin >> y;
        } while (y<'1' || y>'3');
    _x = x - '1';
    _y = y - '1';
    } while (Spielfeld[_x][_y].Besetzt != 0);
    Spielfeld[_x][_y].Besetzt = 1;

}   // Ende DatenEingebenSpieler1

    /////////////////////////////



/////////////////////////////////

// DatenEingebenPC Funktion:   //

// Aufgabe: Eingabe für den PC //

/////////////////////////////////

void DatenEingebenPC()
{
    
    // Variablen

    //

    int xz, yz;     // Zufallszahl deklarieren

    
    do
    {   
        
        xz = (rand()%3)+1;  // Zufallszahl X definieren

        yz = (rand()%3)+1;  // Zufallszahl Y definieren



    } while (Spielfeld[xz-1][yz-1].Besetzt != 0);

    Spielfeld[xz-1][yz-1].Besetzt = 2;


}   // Ende DatenEingebenPC

    ////////////////////////



////////////////////////////////////////

// DatenEingeben Funktion:            //

// Aufgabe: Eingabe für den Spieler2  //

////////////////////////////////////////

void DatenEingebenSpieler2()
{
    // Variablen

    //

    char x, y;
    int _x, _y;
    do
    {   cout << "   \n  Spieler 2, bitte gebe die Koordinaten fuer dein Kreuz ein:" << endl;
        do
        {
            cout << "   X Position eingeben ";
            cin >> x;
        } while (x<'1' || x>'3');
        do
        {
            cout << "   Y Position eingeben ";
            cin >> y;
        } while (y<'1' || y>'3');
    _x = x - '1';
    _y = y - '1';
    } while (Spielfeld[_x][_y].Besetzt != 0);
    Spielfeld[_x][_y].Besetzt = 2;

}   // Ende DatenEingeben Spieler 2

    ///////////////////////////////



/////////////////////////////////////////////

// Optionen Funktion                       //

// Aufgabe: Zur vornahme von Einstellungen //

/////////////////////////////////////////////

int Optionen (int SpielerComputer)
{
    int Auswahl;

    do 
    {
        system ("cls");
        cout << "\n ~ ~  Optionen  ~ ~ \n" << endl;
        cout << "   Wer soll bei einer Spieler gegen den Computer Partie anfangen?\n" << endl;
         cout << "  1 -    Der Computergegner    - 1" << endl;
        cout << "   2 -        Der Spieler       - 2" << endl;
        cout << "   3 -  Zurueck zum Hauptmenue  - 3" << endl;
        cout << "            Auswahl ";
        cin >> Auswahl;

         while  (! cin) 
         { 
              cin.clear(); 
              cin.ignore(); 
              system ("cls");
              cout << "\n   Nur 1, 2 und 3 sind gueltige Eingaben\n"; 
              cout << "\n   ~ ~  Optionen  ~ ~ \n" << endl;
              cout << " Wer soll bei einer Spieler gegen den Computer Partie anfangen?\n" << endl;
              cout << " 1 -    Der Computergegner    - 1" << endl;
              cout << " 2 -        Der Spieler       - 2" << endl;
              cout << " 3 -  Zurueck zum Hauptmenue  - 3" << endl;
              cout << "          Auswahl ";
              cin >> Auswahl;
             }

        }   while (Auswahl < 1 || Auswahl > 3);

        // Je nach Option verzweigen

        switch (Auswahl)
        {
        case (1):
            {   
                SpielerComputer = 1;
                cout << "\n Optionen wurden angepasst" << endl;
            } break;
        case (2):
            {
                SpielerComputer = 2;
                cout << "\n Optionen wurden angepasst" << endl;
            } break;

        case (3):
            {
                system ("cls");
                int main();
            } break;
        }

        return SpielerComputer;

}   // Optionen Funktion Ende

    ///////////////////////////



///////////////////////////////////////////

// Info Funktion                         //

// Aufgabe: Ausgabe der Informationen    //

///////////////////////////////////////////

void Info ()
{
    system ("cls");
    cout << "\nRixRaxRoe v.0.5 - Updates unter www.game-community.org" << endl;
    cout << "\nRegeln: Ziel des Spiels ist es\n3 seiner Markierungen in einer Reihe zu platzieren. \nDazu zaehlen auch die queren Reihen!\n" << endl;
    cout << "\nFalls ihr Hilfe braucht, Bugs gefunden habt oder andere Probleme habt, \nmeldet euch unter www.game-community.org oder per E-Mail an uwe@collmer.net.\n "<< endl; 
    cout << "Viel Spass mit meinem Game!\n" << endl;
    cout << "(c) by RAX Software entertainment (www.uwe-collmer.de & www.game-community.org)\nits illegal to sell this Game. All rights reserved.\nDer Autor uebernimmt keinerlei Garantie\nund ist fuer eventuelle Schaeden nicht haftbar.\n\n";
}   // Info Funktion Ende

    ////////////////////////



/////////////////////////////

// Beenden Funktion        //

// Aufgabe: Spiel beenden  //

/////////////////////////////

void Beenden ()
{   
    system ("cls");
    cout << "\n Spiel wird beendet..." << endl;
    Sleep (1000);
    cout << "\n Bis zum naechsten Mal!" << endl;
    Sleep (500);
}   // Beenden Funktion Ende

    ////////////////////////

Ich hoffe mir kann jmd. helfen

Danke

Zum Seitenanfang

BlackSnake

Community-Fossil

Beiträge: 1 549

Beruf: Student

25.01.2008, 17:21

dein gezeigter code ist ein wenig sehr lang. da hat niemand lust den durchzulesen

Zum Seitenanfang

grek40

Alter Hase

Beiträge: 1 491

Wohnort: Dresden

25.01.2008, 17:45

BlackSnake bringt es auf den Punkt.

Was du mal tun solltest: dein XP-Kompilat im Debugmodus durchchecken (Haltepunkte, schrittweise Ausführung, Variablenüberwachung und alles was man so tun kann). Wenn du dann weisst, in welchem Codebereich der Fehler liegt und trotzdem nicht selbst drauf kommst dann meld dich nochma und stell nur den betroffenen Codeausschnitt rein.

Das andere Problem 'Anwendungskonfiguration ...' lässt sich lösen, indem du die VC++ Laufzeitbibliotheken mitlieferst - wenn du VS Standard oder höher hast einfach mal im Programmordner nach redist suchen, wenn du Express hast musste mal schaun, wo du die sonst gescheit herbekommst.

Zum Seitenanfang

raXor

Alter Hase

Beiträge: 688

25.01.2008, 17:56

Sorry, aber ich versteh kein einzges Wort...

Zum Seitenanfang

drakon

Supermoderator

Beiträge: 6 513

Wohnort: Schweiz

Beruf: Entrepreneur

25.01.2008, 18:20

Na, er meint dein Programm zu debuggen, als Schrittweise durchgehen und kontrollieren, was er macht. Dann findest du dein Logik Problem.

http://www.drakon.ch | Weltweit 31. Bester Solitär Spieler (Standard XP)

Zum Seitenanfang

DennY

Frischling

Beiträge: 22

Wohnort: Zwickau<---

Beruf: Schüler

25.01.2008, 19:37

Hi,
ich verwende XP und konnte deine Vista version auch nicht spielen!
Ich weiß auch nicht warum aber vielleicht (ich kenn mich nich so gut aus) wird bei Vista irgendetwas anders verlinkt als bei XP.
Dann hab ich mir den Quellcode hier rauskoppiert, compiliert und das ganze mal getestet. Es funktioniert einwandfrei, nur dass der Computergegner extrem dumm ist.

mfG DennY

Zum Seitenanfang

David Scherfgen

Administrator

Beiträge: 10 382

Wohnort: Hildesheim

Beruf: Wissenschaftlicher Mitarbeiter

25.01.2008, 21:17

Die Fehlermeldung hat nichts mit dem Quelltext zu tun.
Das liegt an den fehlenden Runtime-Dateien für Visual C++.
Hatten wir schon 100 mal hier.
Also benutz die Suchfunktion oder Google.

David Scherfgens Website | Konzentrationstest Polizei

Zum Seitenanfang

Werbeanzeige

spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

TicTacToe Clon - Programm macht was es will

TicTacToe Clon - Programm macht was es will

Zitat

C-/C++-Quelltext