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!

Tic Tac Toe - Konsolenspiel # Bitte um Feedback

Werbeanzeige

Meldorian

Frischling

  • »Meldorian« ist der Autor dieses Themas

Beiträge: 9

Wohnort: Bielefeld

  • Private Nachricht senden

1

21.08.2014, 20:30

Tic Tac Toe - Konsolenspiel # Bitte um Feedback

Hallo Community,

seit einiger Zeit bin ich dabei C++ mit Hilfe von "C++ für Spieleprogrammierer" zu erlernen. Zur Festigung der Basics nahm ich entsprechenden Rat wahr und habe mit einem kleinen Spiel angefangen: Tic Tac Toe als Konsolenanwendung. Ich würde mich freuen, wenn sich jemand die Zeit nimmt und den Quellcode durchstöbert, so dass ich entsprechendes Feedback bzgl. Stil, ungarische Notation, Aufbau etc. erhalte. Im Anhang befindet sich die *.sln sowie die Release Version.

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13

class CSpieler
{
    public:
    
        //Membervariablen
        char m_Name[30];
        char m_Symbol;

        //Memberfunktionen
        void NameAbfragen ();
        void SymbolAbfragen ();
        void ZeigeDaten ();
};


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

#include <iostream>
#include "CSpieler.hpp"
#include "CSpielfeld.hpp"

using namespace std;

//NameAbfragen
//
//Aufgabe: Fragt die Spielernamen ab
//
void CSpieler::NameAbfragen ()
{
    cout << "Bitte Namen eingeben: ";
    cin.ignore();
    cin.get (m_Name,29);
} //NameAbfragen

//SymbolAbfragen
//
//Aufgabe: Fragt das Spielersymbol ab
//
void CSpieler::SymbolAbfragen ()
{
    do
    {
        cout << "Bitte gewuenschtes Spielsymbol angeben ('.' und '#' nicht erlaubt): ";
        cin >> m_Symbol;
    } while (m_Symbol == '.' || m_Symbol == '#');
} //SymbolAbfragen

//ZeigeDaten
//
//Aufgaben: Zeigt die Spielerdaten an
//
void CSpieler::ZeigeDaten ()
{
    cout << "|Name: " << m_Name << endl;
    cout << "|Symbol: " << m_Symbol << endl;
    cout << "----------------" << endl;
} //ZeigeDaten


C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

//Klasse CSpielfeld
class CSpielfeld
{
    public:

        //Strukturen
        struct S_FeldInfo
        {
            bool Besetzt;
            char Name;
        };

        //Variablen
        S_FeldInfo Spielfeld[3][3];

        //Funktionen
        void LoescheSpielfeld ();
        void SpielfeldAnzeigen ();
};


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

#include <iostream>
#include "CSpielfeld.hpp"

using namespace std;

//LoescheSpielfeld
//
//Aufgabe: Spielfeld löschen/initialisieren
//
void CSpielfeld::LoescheSpielfeld ()
{
    for (int y = 0; y < 3; y++)
    {
        for (int x = 0; x < 3; x++)
        {
            Spielfeld[x][y].Besetzt = false;
        }
    }

    cout << "\nSpielfeld wurde erfolgreich initialisiert." << endl;

} //LoescheSpielfeld

//SpielfeldAnzeigen
//
//Aufgabe: Zeigt das aktuelle Spielfeld an
//
void CSpielfeld::SpielfeldAnzeigen ()
{
    cout << "\nSpielfeld" << endl;
    
    cout << "#####" << endl;
    for (int y = 0; y < 3; y++)
    {
        cout << "#";
        for (int x = 0; x < 3; x++)
        {
            if (Spielfeld[x][y].Besetzt == false)
            {
                cout << ".";
            }
            else
            {
                cout << Spielfeld[x][y].Name;
            }
        }
        cout << "#" << endl;
    }
    cout << "#####" << endl;

    cout << endl;
} //SpielfeldAnzeigen


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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345

//Tic Tac Toe in C++ - Konsolenanwendung
#include <iostream>
#include "CSpieler.hpp"
#include "CSpielfeld.hpp"

using namespace std;

//Funktionsprototypen
void ErstelleSpieler (CSpieler *pSpieler1, CSpieler *pSpieler2);
void SpielBeenden ();
void ZeichenSetzen (CSpieler *pSpieler1, CSpieler *pSpieler2, int *pAktiverSpieler, CSpielfeld *pSpielfeld, int *pFeldBelegt);
void SpielGewinnen (CSpieler *pSpieler1, CSpieler *pSpieler2, char *pchAuswahl, int *pAktiverSpieler, CSpielfeld *pSpielfeld, int *pFeldBelegt);

//Hauptprogramm
int main ()
{
    //Spieler erstellen
    CSpieler *pSpieler1 = NULL;
    CSpieler *pSpieler2 = NULL;
    pSpieler1 = new CSpieler;
    pSpieler2 = new CSpieler;

    //Spielfeld erstellen
    CSpielfeld *pSpielfeld = NULL;
    pSpielfeld = new CSpielfeld;

    //Variablen
    int AktiverSpieler = 0;
    int *pAktiverSpieler = &AktiverSpieler;
    char chAuswahl = '0';
    char *pchAuswahl = &chAuswahl;
    bool SpielInitialisierd = false;
    int FeldBelegt = 0;
    int *pFeldBelegt = &FeldBelegt;
    
    //Hauptmenü
    //
    //Aufgabe: Zeigt das Hauptmenü an
    //

    //Spielstart
    if (SpielInitialisierd == false)
    {
        cout << "#################TIC-TAC-TOE#################" << endl;
        cout << "#Das klassische TTT als Konsolenanwendung   #" << endl;
        cout << "#fuer Zwei Spieler. Viel Spass beim Spielen!#" << endl;
        cout << "#############################################" << endl;

        do
        {
            cout << "1 - Spiel initialisieren" << endl;
            cout << "2 - Spiel beenden" << endl;

            cout << "\nIhre Auswahl: ";
            cin >> chAuswahl;

            switch (chAuswahl)
            {
                case ('1'):
                {
                    cout << "\nSpiel wird initialisiert\n" << endl;
                    
                    ErstelleSpieler (pSpieler1, pSpieler2);
                    pSpielfeld->LoescheSpielfeld ();

                    SpielInitialisierd = true;              
                } break;
                case ('2'):
                {
                    SpielBeenden ();
                } break;
                default:
                {
                    cout <<"\nUngueltige Eingabe. Bitte erneut waehlen.\n" << endl;
                }
            }

        } while ((chAuswahl != '1') && (chAuswahl != '2'));

        if (chAuswahl == 1)
        {
            chAuswahl = 0;
        }
        else
        {
            chAuswahl = 2;
        }
    }
    
    if ((SpielInitialisierd == true) || (chAuswahl == 0))
    {   
        //Spielmenü
        do
        {
            pSpielfeld->SpielfeldAnzeigen ();

            cout << "---Tic---Tac---Toe---" << endl;
            cout << "1 - Zeichen setzen" << endl;
            cout << "2 - Spiel beenden" << endl;
            cout << "---------------------" << endl;

            cout << "\nIhre Auswahl: ";
            cin >> chAuswahl;

            switch (chAuswahl)
            {
                case ('1'):
                {
                    ZeichenSetzen (pSpieler1, pSpieler2, pAktiverSpieler, pSpielfeld, pFeldBelegt);
                    SpielGewinnen (pSpieler1, pSpieler2, pchAuswahl, pAktiverSpieler, pSpielfeld, pFeldBelegt);
                } break;
                case ('2'):
                {
                    SpielBeenden ();
                } break;
                default:
                {
                    cout <<"\nUngueltige Eingabe. Bitte erneut waehlen.\n" << endl;
                }
            }   

        } while (chAuswahl != '2');
    }

    //Daten löschen
    delete pSpieler1;
    pSpieler1 = NULL;
    delete pSpieler2;
    pSpieler2 = NULL;
    delete pAktiverSpieler;
    pAktiverSpieler = NULL;
    delete pSpielfeld;
    pSpielfeld = NULL;
    delete pchAuswahl;
    pchAuswahl = NULL;

    return 0;
}

//Funktionen

//ErstelleSpieler
//
//Aufgabe: Fragt die Spielernamen und das gewünschte Symbol ab.
//
void ErstelleSpieler(CSpieler *pSpieler1, CSpieler *pSpieler2)
{
    //Name und Symbol erfragen
    pSpieler1->NameAbfragen ();
    pSpieler1->SymbolAbfragen ();

    cout << endl;
    
    pSpieler2->NameAbfragen ();
    do
    {
        pSpieler2->SymbolAbfragen ();
    } while (pSpieler2->m_Symbol == pSpieler1->m_Symbol);

    //Daten Korrekt?
    cout << "\nAktive Spieler" << endl;
    cout << "----------------" << endl;
    pSpieler1->ZeigeDaten ();
    pSpieler2->ZeigeDaten ();

} //ErstelleSpieler

//ZeichenSetzen
//
//Aufgabe: Feld mit Wert füllen
//
void ZeichenSetzen (CSpieler *pSpieler1, CSpieler *pSpieler2, int *pAktiverSpieler, CSpielfeld *pSpielfeld, int *pFeldBelegt)
{
    //Aktiven Spieler ausgeben
    if (*pAktiverSpieler == 0)
    {
        *pAktiverSpieler = 1;
    }

    if (*pAktiverSpieler == 1)
    {
        cout << "\nAktiver Spieler: " << pSpieler1->m_Name << endl;
        cout << "--------------------------------------" << endl;
    }
    else if (*pAktiverSpieler == 2)
    {
        cout << "\nAktiver Spieler: " << pSpieler2->m_Name << endl;
        cout << "--------------------------------------" << endl;
    }

    //Variablen
    int x = 0;
    int y = 0;

    //Koordinaten abfragen
    do
    {
        cout << "Bitte x-Position angeben (1-3): ";
        cin >> x;
    } while ((x < 1) || (x > 3));

    do
    {
        cout << "Bitte y-Position angeben (1-3): ";
        cin >> y;
    } while ((y < 1) || (y > 3));

    cout << "--------------------------------------" << endl;

    //Koordinaten korrigieren
    x -= 1;
    y -= 1;

    //Spielfeld Wert ändern
    if (pSpielfeld->Spielfeld[x][y].Besetzt == false)
    {
        pSpielfeld->Spielfeld[x][y].Besetzt = true;
        *pFeldBelegt += 1;
        
        if (*pAktiverSpieler == 1)
        {
            pSpielfeld->Spielfeld[x][y].Name = pSpieler1->m_Symbol;
            *pAktiverSpieler += 1;
        }
        else if (*pAktiverSpieler == 2)
        {
            pSpielfeld->Spielfeld[x][y].Name = pSpieler2->m_Symbol;
            *pAktiverSpieler -= 1;
        }
    }
    else
    {
        cout << "#####################################################" << endl;
        cout << "#Spielfeld belegt. Bitte Koordinaten erneut angeben.#\n" << endl;
        cout << "#####################################################" << endl;
    }
} //ZeichenSetzen

//SpielGewinnen
//
//Aufgabe: Prüft, ob das Spiel gewonnen wurde
//
void SpielGewinnen (CSpieler *pSpieler1, CSpieler *pSpieler2, char *pchAuswahl, int *pAktiverSpieler, CSpielfeld *pSpielfeld, int *pFeldBelegt)
{
    //Senkrecht
    for (int x = 0; x < 3; x++)
    {
        if ((pSpielfeld->Spielfeld[x][0].Name == pSpielfeld->Spielfeld[x][1].Name) && (pSpielfeld->Spielfeld[x][1].Name == pSpielfeld->Spielfeld[x][2].Name) &&
            (pSpielfeld->Spielfeld[x][0].Besetzt == true) && (pSpielfeld->Spielfeld[x][1].Besetzt == true) && (pSpielfeld->Spielfeld[x][2].Besetzt == true))
        {
            cout << "\nDas Spiel ist vorbei. ";
            if (*pAktiverSpieler == 1)
            {
                cout << pSpieler2->m_Name;
            }
            else if (*pAktiverSpieler == 2)
            {
                cout << pSpieler1->m_Name;
            }
            cout << " hat gewonnen." << endl;
            pSpielfeld->SpielfeldAnzeigen ();
            *pchAuswahl = '2';
            SpielBeenden ();
        }
    }

    //Waagerecht
    for (int y = 0; y < 3; y++)
    {
        if ((pSpielfeld->Spielfeld[0][y].Name == pSpielfeld->Spielfeld[1][y].Name) && (pSpielfeld->Spielfeld[1][y].Name == pSpielfeld->Spielfeld[2][y].Name) &&
            (pSpielfeld->Spielfeld[0][y].Besetzt == true) && (pSpielfeld->Spielfeld[1][y].Besetzt == true) && (pSpielfeld->Spielfeld[2][y].Besetzt == true))
        {
            cout << "\nDas Spiel ist vorbei. ";
            if (*pAktiverSpieler == 1)
            {
                cout << pSpieler2->m_Name;
            }
            else if (*pAktiverSpieler == 2)
            {
                cout << pSpieler1->m_Name;
            }
            cout << " hat gewonnen." << endl;
            pSpielfeld->SpielfeldAnzeigen ();
            *pchAuswahl = '2';
            SpielBeenden ();
        }
    }
    
    //Diagonalen
    if ((pSpielfeld->Spielfeld[0][0].Name == pSpielfeld->Spielfeld[1][1].Name) && (pSpielfeld->Spielfeld[1][1].Name == pSpielfeld->Spielfeld[2][2].Name) &&
        (pSpielfeld->Spielfeld[0][0].Besetzt == true) && (pSpielfeld->Spielfeld[1][1].Besetzt == true) && (pSpielfeld->Spielfeld[2][2].Besetzt == true))
    {
        cout << "\nDas Spiel ist vorbei. ";
        if (*pAktiverSpieler == 1)
        {
            cout << pSpieler2->m_Name;
        }
        else if (*pAktiverSpieler == 2)
        {
            cout << pSpieler1->m_Name;
        }
        cout << " hat gewonnen." << endl;
        pSpielfeld->SpielfeldAnzeigen ();
        *pchAuswahl = '2';
        SpielBeenden ();
    }

    if ((pSpielfeld->Spielfeld[2][0].Name == pSpielfeld->Spielfeld[1][1].Name) && (pSpielfeld->Spielfeld[1][1].Name == pSpielfeld->Spielfeld[2][0].Name) &&
        (pSpielfeld->Spielfeld[2][0].Besetzt == true) && (pSpielfeld->Spielfeld[1][1].Besetzt == true) && (pSpielfeld->Spielfeld[2][0].Besetzt == true))
    {
        cout << "\nDas Spiel ist vorbei. ";
        if (*pAktiverSpieler == 1)
        {
            cout << pSpieler2->m_Name;
        }
        else if (*pAktiverSpieler == 2)
        {
            cout << pSpieler1->m_Name;
        }
        cout << " hat gewonnen." << endl;
        pSpielfeld->SpielfeldAnzeigen ();
        *pchAuswahl = '2';
        SpielBeenden ();
    }

    if (*pFeldBelegt == 9)
    {
        cout << endl;
        cout << "#####################################################" << endl;
        cout << "--------------U-N-E-N-T-S-C-H-I-E-D-E-N-------------#" << endl;
        cout << "#####################################################" << endl;
        pSpielfeld->SpielfeldAnzeigen ();
        *pchAuswahl = '2';
        SpielBeenden ();
    }
} //SpielGewinnen

//SpielBeenden
//
//Aufgabe: Beendet das Spiel
//
void SpielBeenden ()
{
    cout << "\nSpiel wird beendet.\n" << endl;
} //SpielBeenden
»Meldorian« hat folgende Datei angehängt:
  • TicTacToe.rar (6,65 kB - 52 mal heruntergeladen - zuletzt: 20.04.2024, 07:20)

Roflo

Alter Hase

Beiträge: 955

  • Private Nachricht senden

2

21.08.2014, 21:14

Ich habe nicht alles angesehen, aber du solltest lieber die Stringklasse statt char-Arrays verwenden. Außerdem solltest du nicht alles public machen. m_Symbol ind der Spielerklasse kann z.B. nur '#' oder '.' sein, dort sollte ein entsprechner setter implementiert werden, der die Gültigkeit überprüft. Genauso mit der Spielfeldklasse und dem Member Spielfeld. Mit Getter und Setter ist das viel ansprechener und Fehler bei falscher benutzung lassen sich vermeiden. Klassen musst du nicht unbedingt mit new anlegen. Vielleicht solltest du auch Logik und Ausgabe trennen, so solltest du die Siegesüberprüfung in die Spielfeldklasse tun. Ein bisschen 'const' hier und da kann auch nicht schaden ;)

Checkmateing

Community-Fossil

Beiträge: 2 218

  • Private Nachricht senden

3

22.08.2014, 00:03

Für den Anfang ok. Stilistisch nicht sehr schön und auch sonst stellenweise recht umständlich gelöst, aber nujo.
Probier dich einfach weiter aus. :)

MfG
Check
Das gibt Übersicht! Stay gold.

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »Checkmateing« (22.08.2014, 00:08)

thilo5

Frischling

Beiträge: 12

Beruf: Schüler

  • Private Nachricht senden

4

22.08.2014, 14:38

Ich habe das Spiel nur kurz getestet, mir ist aber aufgefallen, dass die ständige Abfrage, ob man das Spiel beenden will oder ob man ein Zeichen setzten will unnötig ist, da man zum Beenden Alt+F4 verwenden kann oder das Konsolenfenster einfach schließt. Außerdem schließt sich das Spiel einfach, wenn ein Spieler gewonnen hat.
Ansonsten habe ich nichts zu bemängeln, gute Arbeit! 8)

2310

Frischling

Beiträge: 72

  • Private Nachricht senden

5

23.08.2014, 14:37

Genau, das mit der Frage ob ich das Fenster schließen will ist dumm und wenn man gewonnen hat, dass sich das Fenster gleich schleißt (kleiner Tipp) System("pause") Also unter MS Windows ;) Ansonsten für ein Konsolenspiel ganz gut :thumbsup:
http://www.stupidedia.org/stupi/Programmierer

NachoMan

Community-Fossil

Beiträge: 3 885

Wohnort: Berlin

Beruf: (Nachhilfe)Lehrer (Mathematik, C++, Java, C#)

  • Private Nachricht senden

6

23.08.2014, 16:16

Zitat von »2310«

(kleiner Tipp) System("pause")

Schlechter Tipp. std::cin.get(); tuts auch.
"Der erste Trunk aus dem Becher der Erkenntnis macht einem zum Atheist, doch auf dem Grund des Bechers wartet Gott." - Werner Heisenberg
Biete Privatunterricht in Berlin und Online.
Kommt jemand mit Nach oMan?

Werbeanzeige

Ähnliche Themen