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!

Kleine Erfolgskontrolle

Werbeanzeige

rootnode

Frischling

Beiträge: 92

Wohnort: Aachen, Pontstraße

Beruf: Student

  • Private Nachricht senden

21

31.12.2007, 11:10

Schau in mein Posting, da dürftest du einen Tip dazu finden.
http://www.ohloh.net/p/mosa-project/widgets/project_partner_badge.gif

raXor

Alter Hase

  • »raXor« ist der Autor dieses Themas

Beiträge: 688

  • Private Nachricht senden

22

31.12.2007, 11:50

Ja, ich kann die while schleife verändern wie ich will...
nichts

grek40

Alter Hase

Beiträge: 1 491

Wohnort: Dresden

  • Private Nachricht senden

23

31.12.2007, 13:57

Es steht wirklich eindeutig bei rootnode drin ;)

Immer dran denken, es gibt = und es gibt ==

= steht immer für eine Zuweisung, auch wenn es in einer while Bedingung steht - while (variable = false) ist also immer false


Allgemein nochmal:
die Klasse war echt nich allzu sinnvoll, is schon ok das in Funktionen zu machen, man könnte es aber auch richtig als Klasse machen^^

Frage: warum hast du Spieler1 und Spieler2, anstatt einfach ein int Array namens Spielfeld zu nehmen, wobei der Wert 0 für ein freies Feld, der Wert 1 für Spieler 1 und der Wert 2 für Spieler 2 steht ;)

Außerdem solltest du deine Spielfelder, egal ob Spieler1, Spieler2 oder Spielfeld immer initialisieren (also Startwerte zuweisen) -> ich gehe mal davon aus, dass du dir nicht bewusst bist, warum das im Moment funktioniert.

raXor

Alter Hase

  • »raXor« ist der Autor dieses Themas

Beiträge: 688

  • Private Nachricht senden

24

03.01.2008, 18:59

Hallo, da bin ich wieder ;)
Bin jetzt schon eigentlich relativ weit mit meiner Erfolgskontrolle (dank grek40) . Ich hab auf jedenfall festgestellt, dass ich viel nachholbefarf habe.

Was jetzt noch nicht funktioniert ist die Abfrage wann, wer gewonnen hat. Das will irgendwie nicht Funktionieren:

Der gesamte Quellcode:

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

/*
TicTacToe - The Game
V 0.1
By raXor
*/

#include <iostream>
#include <windows.h>
using namespace std;

// 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 SpielStarten (int *ppruefe);
void DatenEingebenSpieler1 ();
void DatenEingebenSpieler2 ();
void Optionen ();
void Info ();
void Beenden ();
void SpielfeldAnzeigen ();
void PruefeSieger (int *ppruefe);

// Hauptprogramm

//

int main ()
{
    // Variablen

    // 

    int iAuswahl;
    int ppruefe;

    cout << "\n ~ ~ Willkommen bei TicTacToe ~ ~ " << 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;
        cout << "\n\n";

        switch (iAuswahl)
        {

        case (1):
            {
                SpielStarten (&ppruefe);
            }   break;

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

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

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

        default:
            {
            cout << "Ungueltige Eingabe" << endl;
            }   break;
        }
    }   while (iAuswahl != 4);

    return 0;
}

// PruefeSieger Funktion (HIER MUSS IRGENDWO DER FEHLER SEIN)

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

void PruefeSieger (int *ppruefe)
{

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

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

    else 
    {
        *ppruefe = 0;
    }
}

// SpielStarten Funktion

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

void SpielStarten (int *ppruefe)
{
int counter = 9;

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

do 
{
SpielfeldAnzeigen ();
DatenEingebenSpieler1 ();
-- counter;

PruefeSieger (ppruefe);
if (counter == 0 || *ppruefe != 0)
break;
SpielfeldAnzeigen ();
DatenEingebenSpieler2 ();
-- counter;
PruefeSieger (ppruefe);
} while (*ppruefe == 0 && counter != 0);

if (*ppruefe == 0)
    cout << "   Unentschieden" << endl;
else if (*ppruefe == 1)
    cout << "Spieler 1 hat gewonnen! Glueckwunsch!" << endl;
else if (*ppruefe == 2)
    cout << "Spieler 2 hat gewonnen! Glueckwunsch!" << endl;


// Sieger laut ppruefe festlegen

} // SpielStarten Funktion Ende


// SpielfeldAnzeigen Funktion

// Aufgabe: Spielfeld zeichnen

void SpielfeldAnzeigen ()
{
        // Variablen

    int j = 1;
    
    cout << "       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;
    }
    
}


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


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

void Optionen ()
{
    cout << "Optionen werden abgerufen" << endl;
}   // Optionen Funktion Ende


// Info Funktion

// Aufgabe: Ausgabe der Informationen

void Info ()
{
    cout << "Informationen werden abgerufen" << endl;
}   // Info Funktion Ende


// Beenden Funktion

// Aufgabe: Spiel beenden

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

grek40

Alter Hase

Beiträge: 1 491

Wohnort: Dresden

  • Private Nachricht senden

25

03.01.2008, 19:30

is nur ne Kleinigkeit in der PruefeSieger Funktion -> Arrays werden von 0 bis (größe) -1 referenziert und nicht von 1 bis (größe)

raXor

Alter Hase

  • »raXor« ist der Autor dieses Themas

Beiträge: 688

  • Private Nachricht senden

26

03.01.2008, 23:09

Also immer

C-/C++-Quelltext

 
1

Spielfeld[x-1][y-1].Besetzt == 1

?

raXor

Alter Hase

  • »raXor« ist der Autor dieses Themas

Beiträge: 688

  • Private Nachricht senden

27

03.01.2008, 23:24

Hammer, es funktioniert.
Hätte ich die Variable aber nich gleich bei der Eingabe der X-Y Position dekrementieren können? Dann hätte ich nicht alles ersetzen müssen.

So, jetzt steht eine "KI" und eine vereinfachte Steuerung an :D

raXor

Alter Hase

  • »raXor« ist der Autor dieses Themas

Beiträge: 688

  • Private Nachricht senden

28

04.01.2008, 17:06

OK. Ich hab jetzt mal die "KI" geschrieben, glaub aber, dass es eine bessere Lösung geben muss. Ich hab es mal folgendermaßen ausprobiert.

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

void DatenEingebenPC()
{
    // Variablen

    //

    int x, y;

    if (Spielfeld[1][1].Besetzt == 1)
    { 
         Spielfeld[1][2].Besetzt = 2 | Spielfeld[1][3].Besetzt = 2 | 
         Spielfeld[2][1].Besetzt = 2 | Spielfeld[2][2].Besetzt = 2 | Spielfeld[2][3].Besetzt = 2 || 
         Spielfeld[3][1].Besetzt = 2 | Spielfeld[3][2].Besetzt = 2 | Spielfeld[3][3].Besetzt = 2;
    }
    
    else if (Spielfeld[1][2].Besetzt == 1)
    { 
        Spielfeld[1][1].Besetzt = 2 | Spielfeld[1][3].Besetzt = 2 | 
        Spielfeld[2][1].Besetzt = 2 | Spielfeld[2][2].Besetzt = 2 | Spielfeld[2][3].Besetzt = 2 || 
        Spielfeld[3][1].Besetzt = 2 | Spielfeld[3][2].Besetzt = 2 | Spielfeld[3][3].Besetzt = 2;
    }

    else if (Spielfeld[1][3].Besetzt == 1)
    { 
         Spielfeld[1][1].Besetzt = 2 | Spielfeld[1][2].Besetzt = 2 | 
         Spielfeld[2][1].Besetzt = 2 | Spielfeld[2][2].Besetzt = 2 | Spielfeld[2][3].Besetzt = 2 | 
         Spielfeld[3][1].Besetzt = 2 | Spielfeld[3][2].Besetzt = 2 | Spielfeld[3][3].Besetzt = 2;
    }

    else if (Spielfeld[2][1].Besetzt == 1)
    { 
         Spielfeld[1][1].Besetzt = 2 | Spielfeld[1][2].Besetzt = 2 | Spielfeld[1][3].Besetzt = 2 | 
         Spielfeld[2][2].Besetzt = 2 | Spielfeld[2][3].Besetzt = 2 | 
         Spielfeld[3][1].Besetzt = 2 | Spielfeld[3][2].Besetzt = 2 | Spielfeld[3][3].Besetzt = 2;
    }

    else if (Spielfeld[2][2].Besetzt == 1)
    { 
         Spielfeld[1][1].Besetzt = 2 | Spielfeld[1][2].Besetzt = 2 | Spielfeld[1][3].Besetzt = 2 | 
         Spielfeld[2][1].Besetzt = 2 | Spielfeld[2][3].Besetzt = 2 | 
         Spielfeld[3][1].Besetzt = 2 | Spielfeld[3][2].Besetzt = 2 | Spielfeld[3][3].Besetzt = 2;
    }

    else if (Spielfeld[2][3].Besetzt == 1)
    { 
         Spielfeld[1][1].Besetzt = 2 | Spielfeld[1][2].Besetzt = 2 | Spielfeld[1][3].Besetzt = 2 | 
         Spielfeld[2][1].Besetzt = 2 | Spielfeld[2][2].Besetzt = 2 | 
         Spielfeld[3][1].Besetzt = 2 | Spielfeld[3][2].Besetzt = 2 | Spielfeld[3][3].Besetzt = 2;
    }

    else if (Spielfeld[3][1].Besetzt == 1)
    { 
         Spielfeld[1][1].Besetzt = 2 | Spielfeld[1][2].Besetzt = 2 | Spielfeld[1][3].Besetzt = 2 | 
         Spielfeld[2][1].Besetzt = 2 | Spielfeld[2][2].Besetzt = 2 | Spielfeld[2][3].Besetzt = 2 | 
         Spielfeld[3][2].Besetzt = 2 | Spielfeld[3][3].Besetzt = 2;
    }

    else if (Spielfeld[3][2].Besetzt == 1)
    { 
         Spielfeld[1][1].Besetzt = 2 | Spielfeld[1][2].Besetzt = 2 | Spielfeld[1][3].Besetzt = 2 | 
         Spielfeld[2][1].Besetzt = 2 | Spielfeld[2][2].Besetzt = 2 | Spielfeld[2][3].Besetzt = 2 | 
         Spielfeld[3][1].Besetzt = 2 | Spielfeld[3][3].Besetzt = 2;
    }

    else if (Spielfeld[3][3].Besetzt == 1)
    { 
         Spielfeld[1][1].Besetzt = 2 | Spielfeld[1][2].Besetzt = 2 | Spielfeld[1][3].Besetzt = 2 | 
         Spielfeld[2][1].Besetzt = 2 | Spielfeld[2][2].Besetzt = 2 | Spielfeld[2][3].Besetzt = 2 | 
         Spielfeld[3][1].Besetzt = 2 | Spielfeld[3][2].Besetzt = 2;
    }
    

}   // Ende DatenEingebenPC


Was mir eigentlich schon klar war, dass das nicht funktioniert.
Der Gedanke ist, dass der PC überprüft, welches Kreuz der menschliche Gegner gesetzt hat und dann überprüft ob es schon besetzt ist. Dazu stehen die "|" / "||" Operatoren.
Dann geht er alle Möglichkeiten durch und markiert das passende Feld mit '2'.

Also das Prinip ist mir klar, nur an der Umsetzung hakt es.
Ich könnte es ja mal mit verschachtelten if Bedingungen machen. Das wäre meiner Meinung nach ziemlich wirkungsvoll aber dafür ein Overkill Code und nicht sauber.

Das Gurke

Community-Fossil

Beiträge: 1 996

Wohnort: Pinneberg

Beruf: Schüler

  • Private Nachricht senden

29

04.01.2008, 17:10

Du könntest alle Felder durchgehen, gucken welche "Gewinnchancen" jedes Feld bietet und dir ein Scoringsystem zusammenlegen. So habe ich das damals, in etwa, gemacht.

Du musst dir dann halt Kriterien überlegen, mit denen du die Effektivität eines Zuges bewerten kannst. Das einfachste ist sicherlich, wieviele mögliche "Gewinnreihen" sich von diesem Feld ausgehend bilden lassen. So als Ansatz für dich ;)

Auf das Feld mit dem höchsten Score platziert die KI dann ihren Stein.
http://trash.gurxite.de/userbarmarcusbloggt.png
http://img.flowergame.net/flower/77.pnghttp://img.flowergame.net/flower/221.pnghttp://img.flowergame.net/flower/223.png

drakon

Supermoderator

Beiträge: 6 513

Wohnort: Schweiz

Beruf: Entrepreneur

  • Private Nachricht senden

30

04.01.2008, 17:53

Also diesen Code könntest du noch einiges mit Schlaufen verbessern.
Hast ja immer die gleichen Zahlen in dem Array.

Dann wäre es auch gleich einfacher und übersichtlicher..

Was genau hast du mit den | / || - Operatoren vor???
http://www.drakon.ch | Weltweit 31. Bester Solitär Spieler (Standard XP)

Werbeanzeige