Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

TicTacToe für die Konsole [Teil 3]

Werbeanzeige

Anonymous

unregistriert

1

04.09.2006, 16:22

TicTacToe für die Konsole [Teil 3]

So, da bin ich wieder. Dieses Tutorial wird etwas länger werden, da sich
einiges geändert hat. In diesem Teil wird das Spiel fertig programmiert.
Es könnte sein, dass der Code ein wenig kompliziert ist, aber wenn Ihr
euch damit ein wenig länger beschäftigt, solltet Ihr ihn verstehen können,
gerade weil ich das alles ja so schön kommentiere. ;)

Okay, dann fangen wir mal an. An der draw_field Funktion hat sich nichts
geändert, aber wie ich bereits angekündigt habe, habe ich die Tastatur-
abfrage überarbeitet. Diese ist nun viel kleiner und der 2. Spieler wird
hier implementiert. Okay, los gehts mit der neuen key_input Funktion:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

char key_input (char *field)
{
    char input           = ' '; // Eingabe Buffer

    char sign            = ' '; // Das Zeichen, welches in die jeweiligen Felder platziert werden soll (X oder O)

    static bool player_1 = true; // Ist der 1. Spieler dran? Dies ist nur eine Hilfsvariable...


    if (player_1) // Ist der 1. Spieler dran?

    {
        std::cout << std::endl << std::endl << "Spieler 1: "; // Dann gib "Spieler 1:" aus und setzte das Zeichen

        sign = 'X';                                           // das dem erstens Spieler gehört der "sign" Variablen zu

    }
    else // Doch 2. Spieler?

    {
        // Genau das gleiche für den 2. Spieler machen:

        std::cout << std::endl << std::endl << "Spieler 2: ";
        sign = 'O';
    }

    std::cin >> input; // Auf eine Eingabe warten


    // In dieser if Abfrage wird folgendes abgefragt: 

    // Wenn "input" kleiner oder gleich dem Zeichen 0 oder größer als das Zeichen 9 und nicht gleich "q" ist, tue das:

    if ((input <= '0') || (input > '9') && input != 'q') 
    {
        std::cin.sync ();
        std::cout << std::endl << "Falsche Eingabe!";
        std::cin.get ();
    }

    // Ähnliche if Abfrage, nur andersrum: Wenn irgendwas zwischen 1 und 9 gedrückt wurde, tu folgendes:

    if ((input > '0') && (input <= '9'))
    {
        // Erstmal abfragen, ob ein Feld schon ein "X" oder ein "O" beinhaltet.

        // Da der ASCII Code für 1-9 von 49-57 geht und die field Variable nur Felder von 1-9 hat, sollten wir die input Variable, die wir

        // dem Feld übergeben mit 48 subtrahieren.

        if (field[input - 48] == 'X' || 
            field[input - 48] == 'O') 
        {
            // Sollte klar sein

            std::cin.sync ();
            std::cout << std::endl << "Dieses Feld ist bereits belegt!";
            std::cin.get ();
        }
        else
        {
            field[input - 48] = sign; // Das Zeichen des jeweiligen Spielers auf dem jeweiligem Feld ausgeben

            player_1 = !player_1; // Wert der bool Variablen umdrehen

        }
    }

    return input; // "input" zurückgeben und fertig ist die Funktion =)

}


So, ich hoffe das ist verständlich genug kommentiert. Im grunde ist es
ganz einfach, man muss es nur verstehen und sich lange genug damit
auseinander setzen.

Nun schreiben wir uns noch eine Funktion, die bei jedem Durchlauf über-
prüft, ob jemand gewonnen hat. Ich werde euch hier 2 Möglichkeiten
zeigen, die mir in den Sinn gekommen sind. (Bitte um Feedback!)

Erste Möglichkeit:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

bool winner (char *field)
{
    for (int i = 1; i < 9; i += 3) // Vertikal

        if ((field[i] == 'X') && (field[i+1] == 'X') && (field[i+2] == 'X')) // X überprüfen

        {
            std::cout << std::endl << std::endl << "Spieler 1 hat gewonnen!";
            std::cin.sync ();
            std::cin.get  ();

            return false;
        }
        else if ((field[i] == 'O') && (field[i+1] == 'O') && (field[i+2] == 'O')) // O überprüfen

        {
            std::cout << std::endl << std::endl << "Spieler 2 hat gewonnen!";
            std::cin.sync ();
            std::cin.get  ();

            return false;
        }

    for (int i = 1; i < 4; ++i) // Horzontal

        if ((field[i] == 'X') && (field[i+3] == 'X') && (field[i+6] == 'X')) // X überprüfen

        {
            std::cout << std::endl << std::endl << "Spieler 1 hat gewonnen!";
            std::cin.sync ();
            std::cin.get  ();

            return false;
        }
        else if ((field[i] == 'O') && (field[i+3] == 'O') && (field[i+6] == 'O')) // O überprüfen

        {
            std::cout << std::endl << std::endl << "Spieler 2 hat gewonnen!";
            std::cin.sync ();
            std::cin.get  ();

            return false;
        }

    // Diagonal für X überprüfen

    if ((field[1] == 'X') && (field[5] == 'X') && (field[9] == 'X') ||
        (field[3] == 'X') && (field[5] == 'X') && (field[7] == 'X'))
    {
        std::cout << std::endl << std::endl << "Spieler 1 hat gewonnen!";
        std::cin.sync ();
        std::cin.get  ();

        return false;
    }
    // Diagonal für O überprüfen

    else if ((field[1] == 'X') && (field[5] == 'X') && (field[9] == 'X') ||
             (field[3] == 'X') && (field[5] == 'X') && (field[7] == 'X'))
    {
        std::cout << std::endl << std::endl << "Spieler 2 hat gewonnen!";
        std::cin.sync ();
        std::cin.get  ();

        return false;
    }
    // Unentschieden? Hier wird überprüft, ob irgendein Feld noch frei ist

    // Wenn nicht, und kein Spieler gewonnen hat, wir "Unentschieden!" ausgegeben.

    else if ((field[1] != ' ') && (field[2] != ' ') && (field[3] != ' ') &&
              (field[4] != ' ') && (field[5] != ' ') && (field[6] != ' ') &&
              (field[7] != ' ') && (field[8] != ' ') && (field[9] != ' '))
    {
        std::cout << std::endl << std::endl << "Unentschieden!";
        std::cin.sync ();
        std::cin.get  ();

        return false;
    }


    return true; // Falls alles gut lief, true zurückgeben.

}


Ich glaube, da gibt es nicht sonderlich viel zu kommentieren. Mit ein
wenig denken kommt ihr drauf. ;)

2. Möglichkeit (deutlich kleiner, aber dafür irgendwie häßlicher):

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

bool winner (char *field)
{
    // Alle Möglichkeiten für X abfragen

    if ((field[1] == 'X') && (field[2] == 'X') && (field[3] == 'X') ||
        (field[4] == 'X') && (field[5] == 'X') && (field[6] == 'X') ||
        (field[7] == 'X') && (field[8] == 'X') && (field[9] == 'X') ||
        (field[1] == 'X') && (field[4] == 'X') && (field[7] == 'X') ||
        (field[2] == 'X') && (field[5] == 'X') && (field[8] == 'X') ||
        (field[3] == 'X') && (field[6] == 'X') && (field[9] == 'X') ||
        (field[1] == 'X') && (field[5] == 'X') && (field[9] == 'X') ||
        (field[3] == 'X') && (field[5] == 'X') && (field[7] == 'X'))
    {
        std::cout << std::endl << std::endl << "Spieler 1 hat gewonnen!";
        std::cin.sync ();
        std::cin.get  ();

        return false;
    }
    // Alle Möglichkeiten für O abfragen

    else if ((field[1] == 'O') && (field[2] == 'O') && (field[3] == 'O') ||
             (field[4] == 'O') && (field[5] == 'O') && (field[6] == 'O') ||
             (field[7] == 'O') && (field[8] == 'O') && (field[9] == 'O') ||
             (field[1] == 'O') && (field[4] == 'O') && (field[7] == 'O') ||
             (field[2] == 'O') && (field[5] == 'O') && (field[8] == 'O') ||
             (field[3] == 'O') && (field[6] == 'O') && (field[9] == 'O') ||
             (field[1] == 'O') && (field[5] == 'O') && (field[9] == 'O') ||
             (field[3] == 'O') && (field[5] == 'O') && (field[7] == 'O'))
    {
        std::cout << std::endl << std::endl << "Spieler 2 hat gewonnen!";
        std::cin.sync ();
        std::cin.get  ();

        return false;
    }
    // Unentschieden?

    else if ((field[1] != ' ') && (field[2] != ' ') && (field[3] != ' ') &&
              (field[4] != ' ') && (field[5] != ' ') && (field[6] != ' ') &&
              (field[7] != ' ') && (field[8] != ' ') && (field[9] != ' '))
    {
        std::cout << std::endl << std::endl << "Unentschieden!";
        std::cin.sync ();
        std::cin.get  ();

        return false;
    }

    return true; // Falls alles gut lief, true zurückgeben.

}


Hier gibts wieder nicht viel zu erklären. Ich persönlich bevorzuge im
Moment noch die erste Möglichkeit. Bin gespannt auf Ideen von euch.
Vielleicht kommt ja auch noch ein Geistesblitz meinerseits. ;)

Wir sind jetzt fast durch, aber irgendwas fehlt doch noch.... Genau!
Die Main Funktion müssen wir natürlich noch anpassen. ;)

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

int main ()
{
    SetConsoleTitleW (L"Tic Tac Toe");

    bool quit  = true; // Variable zum abfragen, ob das Programm geschlossen werden soll

    char input = ' ';

    char field[10];
    for (int i = 0; i < 10; ++i) 
        field[i] = ' ';

    while (input != 'q')
    {
        draw_field (field);
        quit = winner (field); // "winner" liefert einen Wert zurück, den wir abfangen, um im Falle eines Sieges

                               // das Programm beenden zu können.


        if (!quit) // Wenn "quit" gleich "false" ist, dann...

            break; // Springe aus der while Schleife, wo in diesem Falle das Programm beendet wird.


        // Nun geben wir die Beschreibung aus. Sogar mit Umlauten ;)

        std::cout << std::endl << std::endl
                  << "Geben Sie eine Zahl zwischen 1 und 9 ein, um ein Feld auszuw\204hlen" << std::endl
                  << "oder geben Sie \"q\" ein, um das Programm zu beenden.";

        // Der Rest sollte klar sein.

        input = key_input (field);
        std::cin.sync ();
    }

    return 0;
}


Nun nochmal alles zusammen ohne Kommentare und okay, ich nehme
jetzt doch einfach mal die 2. Möglichkeit der "winner" Funktion, da diese
leichter verständlich sein sollte:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

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

void draw_field (char *field)
{
    system ("cls");

    std::cout << std::endl << std::endl << std::endl
              << "     " << field[1] << " | " << field[2] << " | " << field[3] << std::endl
              << "    ---|---|---" << std::endl
              << "     " << field[4] << " | " << field[5] << " | " << field[6] << std::endl
              << "    ---|---|---" << std::endl
              << "     " << field[7] << " | " << field[8] << " | " << field[9] << std::endl;
}

char key_input (char *field)
{
    char input           = ' ';
    char sign            = ' ';
    static bool player_1 = true;

    if (player_1)
    {
        std::cout << std::endl << std::endl << "Spieler 1: ";
        sign = 'X';
    }
    else
    {
        std::cout << std::endl << std::endl << "Spieler 2: ";
        sign = 'O';
    }

    std::cin >> input;

    if ((input <= '0') || (input > '9') && input != 'q') 
    {
        std::cin.sync ();
        std::cout << std::endl << "Falsche Eingabe!";
        std::cin.get ();
    }

    if ((input > '0') && (input <= '9')) 
    {
        if (field[input - 48] == 'X' || 
            field[input - 48] == 'O') 
        {
            std::cin.sync ();
            std::cout << std::endl << "Dieses Feld ist bereits belegt!";
            std::cin.get ();
        }
        else
        {
            field[input - 48] = sign;
            player_1 = !player_1;
        }
    }

    return input;
}

bool winner (char *field)
{
    if ((field[1] == 'X') && (field[2] == 'X') && (field[3] == 'X') ||
        (field[4] == 'X') && (field[5] == 'X') && (field[6] == 'X') ||
        (field[7] == 'X') && (field[8] == 'X') && (field[9] == 'X') ||
        (field[1] == 'X') && (field[4] == 'X') && (field[7] == 'X') ||
        (field[2] == 'X') && (field[5] == 'X') && (field[8] == 'X') ||
        (field[3] == 'X') && (field[6] == 'X') && (field[9] == 'X') ||
        (field[1] == 'X') && (field[5] == 'X') && (field[9] == 'X') ||
        (field[3] == 'X') && (field[5] == 'X') && (field[7] == 'X'))
    {
        std::cout << std::endl << std::endl << "Spieler 1 hat gewonnen!";
        std::cin.sync ();
        std::cin.get  ();

        return false;
    }
    else if ((field[1] == 'O') && (field[2] == 'O') && (field[3] == 'O') ||
             (field[4] == 'O') && (field[5] == 'O') && (field[6] == 'O') ||
             (field[7] == 'O') && (field[8] == 'O') && (field[9] == 'O') ||
             (field[1] == 'O') && (field[4] == 'O') && (field[7] == 'O') ||
             (field[2] == 'O') && (field[5] == 'O') && (field[8] == 'O') ||
             (field[3] == 'O') && (field[6] == 'O') && (field[9] == 'O') ||
             (field[1] == 'O') && (field[5] == 'O') && (field[9] == 'O') ||
             (field[3] == 'O') && (field[5] == 'O') && (field[7] == 'O'))
    {
        std::cout << std::endl << std::endl << "Spieler 2 hat gewonnen!";
        std::cin.sync ();
        std::cin.get  ();

        return false;
    }
    else if ((field[1] != ' ') && (field[2] != ' ') && (field[3] != ' ') &&
             (field[4] != ' ') && (field[5] != ' ') && (field[6] != ' ') &&
             (field[7] != ' ') && (field[8] != ' ') && (field[9] != ' '))
    {
        std::cout << std::endl << std::endl << "Unentschieden!";
        std::cin.sync ();
        std::cin.get  ();

        return false;
    }

    return true;
}
int main ()
{
    SetConsoleTitleW (L"Tic Tac Toe");

    bool quit  = true;
    char input = ' ';

    char field[10];
    for (int i = 0; i < 10; ++i) 
        field[i] = ' ';

    while (input != 'q')
    {
        draw_field (field);
        quit = winner (field);

        if (!quit)
            break;

        std::cout << std::endl << std::endl
                  << "Geben Sie eine Zahl zwischen 1 und 9 ein, um ein Feld auszuw\204hlen" << std::endl
                  << "oder geben Sie \"q\" ein, um das Programm zu beenden.";

        input = key_input (field);
        std::cin.sync ();
    }

    return 0;
}


So. Jetzt habt ihr wahrscheinlich euer erstes Spiel geschrieben. Wie gesagt
bringt es überhaupt nichts, wenn ihr den Code einfach nur kopiert und
kompiliert. Ihr solltet auf jeden Fall versuchen zu verstehen, wie das alles
abläuft, damit ihr demnächst auch ganz alleine ein Spiel programmieren
könnt. Ich hoffe es hat euch gefallen. Dies war der vorerst letzte Teil.

Feedback ist wie gesagt erwünscht, denn ich will den Neulingen ja auch
ordentliche Sachen mit auf dem Weg geben und nicht irgendeinen Schwach-
sinn, den ich vielleicht übersehen habe. ;)

Weiterführende Links:

Teil 1
Teil 2

Frede

Treue Seele

Beiträge: 259

Wohnort: Hameln

Beruf: Schüler

  • Private Nachricht senden

2

04.09.2006, 17:09

Nicht schlecht! ;)

Ich hätte da ein paar Verbesserungen, die mir persönlich besser gefallen:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

// 1. Die bool player bereits in der main()-Funktion deklarieren

// 2. key_input und winner bekommen ein bool bPlayer1-Parameter dazu, 

//    key_input wurd  dann entsprechend verändert (static bool gleich "weg" und Parameter verwenden!).


// Hier: Brauch ich einen Zeiger auf die bool, weil wir sie dann später umkehren wollen(siehe unten!)

char key_input (char *field, bool *bPlayer1) 
{ 
    char input             = ' '; 
    char sign             = ' '; 

    if (bPlayer1) 
    { 
        std::cout << std::endl << std::endl << "Spieler 1: "; 
        sign = 'X'; 
    } 
    else 
    { 
        std::cout << std::endl << std::endl << "Spieler 2: "; 
        sign = 'O'; 
    } 

    std::cin >> input; 

    if ((input < 49) || (input > 57) && input != 113) 
    { 
        std::cin.sync (); 
        std::cout << std::endl << "Falsche Eingabe!"; 
        std::cin.get (); 
    } 

    if ((input > 48) && (input < 58)) 
    { 
        if (field[input - 48] == 'X' || 
            field[input - 48] == 'O') 
        { 
            std::cin.sync (); 
            std::cout << std::endl << "Dieses Feld ist bereits belegt!"; 
            std::cin.get (); 
        } 
        else 
        { 
            field[input - 48] = sign; 
            bPlayer1 = !bPlayer1; 
        } 
    } 

    return input; 
} 

bool winner (char *field, bool bPlayer1) 
{ 
    // Alle Möglichkeiten für X abfragen 

    if ((field[1] == field[2]) && (field[3] == field[2]) || 
        (field[4] == field[5]) && (field[6] == field[5]) || 
        (field[7] == field[8]) && (field[9] == field[8]) || 
        (field[1] == field[4]) && (field[7] == field[4]) || 
        (field[2] == field[5]) && (field[8] == field[5]) || 
        (field[3] == field[6]) && (field[9] == field[6]) || 
        (field[1] == field[5]) && (field[9] == field[5]) || 
        (field[3] == field[5]) && (field[7] == field[5])) 
    { 
        if(bPlayer1 == true)
        {
              std::cout << std::endl << std::endl << "Spieler 1 hat gewonnen!"; 
              std::cin.sync (); 
              std::cin.get  (); 

              return false; 
        } 
        else
        {
              std::cout << std::endl << std::endl << "Spieler 2 hat gewonnen!"; 
              std::cin.sync (); 
              std::cin.get  (); 

              return false; 
        } 

    return true; // Falls alles gut lief, true zurückgeben. 

}

int main () 
{ 
    SetConsoleTitleW (L"Tic Tac Toe"); 

    bool quit  = true; // Variable zum abfragen, ob das Programm geschlossen werden soll 

    char input = ' '; 
    bool bPlayer1 = true;

    char field[10]; 
    for (int i = 0; i < 10; ++i) 
        field[i] = ' '; 

    while (input != 'q') 
    { 
        draw_field (field); 
        quit = winner (field, bPlayer1); // "winner" liefert einen Wert zurück, den wir abfangen, um im Falle eines Sieges 

                               // das Programm beenden zu können. 


        if (!quit) // Wenn "quit" gleich "false" ist, dann... 

            break; // Springe aus der while Schleife, wo in diesem Falle das Programm beendet wird. 


        // Nun geben wir die Beschreibung aus. Sogar mit Umlauten ;) 

        std::cout << std::endl << std::endl 
                  << "Geben Sie eine Zahl zwischen 1 und 9 ein, um ein Feld auszuw\204hlen" << std::endl 
                  << "oder geben Sie \"q\" ein, um das Programm zu beenden."; 

        // Der Rest sollte klar sein. 

        input = key_input (field, &bPlayer1); 
        std::cin.sync (); 
    } 

    return 0; 
}


Bei Fehlern bin ich untröstlich :p

mfg Frede

Anonymous

unregistriert

3

04.09.2006, 17:16

Ja dann teste das Programm von dir doch mal. Du wirst schnell merken,
wo der Haken ist. ;)

Frede

Treue Seele

Beiträge: 259

Wohnort: Hameln

Beruf: Schüler

  • Private Nachricht senden

4

04.09.2006, 18:23

Jep, vergessen das wenn die Felder unbesetzt sind (praktisch am anfang) sind alle Felder auch schon gleich..... Öops :oops:
Außerdem ist der Zeiger vollig sinnlos. Die Umkehreung von bPlayer1 kann man ebenso nach dem Aufruf der key_input-funktion in main() machen..........

ich bin untröstlich

Trotzdem wars kürzer als deine Methode :D (<- Doofer Witz)
mfg Frede

Anonymous

unregistriert

5

04.09.2006, 18:26

Zitat von »"Frede"«

Die Umkehreung von bPlayer1 kann man ebenso nach dem Aufruf der key_input-funktion in main() machen..........


Nö, denk mal nach. ;)

WarMuuh!!

Treue Seele

Beiträge: 170

  • Private Nachricht senden

6

04.09.2006, 19:12

nur der vollständigkeit halber:

C-/C++-Quelltext

 
1

statt input > 48 && input < 57
kann man auch

C-/C++-Quelltext

 
1

input > '0' && input <= '9'
schreiben, da 'x' als zahlenwert behandelt wird. is eventuell einfacher lesbar und man muss sich nich mit den ascii-codes rumschlagen

Anonymous

unregistriert

7

04.09.2006, 19:16

Jop, da muss ich WarMuuh!! zustimmen! Magic Numbers haben mehr Nachteile als Vorteile ;)

Frede

Treue Seele

Beiträge: 259

Wohnort: Hameln

Beruf: Schüler

  • Private Nachricht senden

8

04.09.2006, 19:21

@ Riddick:
N anderen Fehler gibts nicht. Mein Code war nur leider nicht spielfähig, weil Spieler1 von Anfang an schon gewonnen hatte (was ich aber auch schon erwähnt hatte).
Wenns noch was gibt.... Verrats mir :roll:
bidde

mfg frede

grek40

Alter Hase

Beiträge: 1 491

Wohnort: Dresden

  • Private Nachricht senden

9

04.09.2006, 19:31

Du kehrst mit

C-/C++-Quelltext

 
1

bPlayer1 = !bPlayer1;
keineswegs den boolschen Wert von bPlayer1 um sondern den Wert des Pointers ;)
auch an anderen Stellen nutzt du den Pointer und nicht den Wert für alles mögliche^^

Anonymous

unregistriert

10

04.09.2006, 20:23

So, schonmal danke für das Feedback, habe diese Dinge kurz gefixed.
Wenn ihr noch was findet -> Bitte Bescheid sagen ;)

@ grek40: Er soll doch selber denken. ;)

Werbeanzeige