C++ :: Aufgabe #39

2 Lösungen Lösungen öffentlich
#39

4 Gewinnt für die Konsole

Anfänger - C++ von Gustl - 05.01.2013 um 16:57 Uhr
Es soll 4 Gewinnt für die Konsole programmiert werden.
2 Spieler spielen gegeneinander, ohne Computergegner (ohne künstliche Intelligenz), spielen können.

Optional mit Computergegner, aber bitte in der Beschreibung dann angeben.
Bitte melden Sie sich an um zur Aufgabenbeschreibung eine Frage zu stellen.
Frage stellen
Bitte melden Sie sich an um eine Lösung einzureichen.
Lösung einreichen
Votes: 0 Admin: 0

Lösungen:

#1
vote_ok
von incocnito (700 Punkte) - 05.01.2013 um 17:23 Uhr
Quellcode ausblenden C-Code
#include <iostream>
#include <conio.h>
#include <array>
#include <vector>
#include <windows.h>
#include <cassert>

namespace con
{
    enum Color
    {
        BLACK, //schwarz
        BLUEBLACK, //dunkelblau
        DARKGREEN, //dunkelgruen
        TEAL, //blaugruen
        DARKRED, //dunkelrot
        PURPLE, //lila
        OCHER, //ocker
        LIGHTGREY, //hellgrau
        GREY, //dunkelgrau
        BLUE, //blau
        GREEN, //gruen
        LIGHTBLUE, //hellblau
        RED, //rot
        MAGENTA, //magenta
        YELLOW, //gelb
        WHITE //weiss
    };
    enum Key
    {
        ARROW_UP = 72,
        ARROW_DOWN = 80,
        ARROW_LEFT = 75,
        ARROW_RIGHT = 77,
        ESCAPE = 27,
        SPACE = 32,
        ENTF = 83,
        ENTER = 13,
        BACK = 8,
        TAB = 9
    };
    inline void gotoxy(int Y, int X)
    {
        HANDLE hCon = GetStdHandle(STD_OUTPUT_HANDLE);
        COORD pos;
        pos.Y = Y;
        pos.X = X;
        SetConsoleCursorPosition(hCon, pos);
    }
    inline void color(const int COLOR)
    {
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), COLOR);
    }
    template<typename T>
    inline void print(const int& Ypos, const int& Xpos, const T& s, int c = WHITE)
    {
        assert(Ypos >= 0 && Xpos >= 0);
        gotoxy(Ypos, Xpos);
        color(c);
        std::cout << s;
        color(WHITE);
    }
    inline void blinking_cursor(bool on)
    {
        CONSOLE_CURSOR_INFO inf;
        inf.dwSize = 15;
        if(!on) inf.bVisible = false;
        else inf.bVisible = true;
        SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE),&inf);
    }
}

const int SPIELFELD_HOEHE = 6;
const int SPIELFELD_BREITE = 7;

typedef const std::array<std::array<int, SPIELFELD_BREITE>, SPIELFELD_HOEHE> constFeldTyp;
typedef std::array<std::array<int, SPIELFELD_BREITE>, SPIELFELD_HOEHE> feldTyp;

struct Pfeil
{
    int Ypos, Xpos, positionsWert; //positionswert gleich wert der x-achse
    Pfeil() : Ypos(20), Xpos(26), positionsWert(0) {}
    void operator++()
    {
        if(Xpos < 44 && Xpos > 25)
        {
            ausgeben(true); //alten Pfeil loeschen
            Xpos += 3;
            ausgeben(false); //neuen malen
            ++positionsWert; //wir sind jetzt bei spielfeldMatrix[hoehe][++psw]
        }
    }
    void operator--() //naja alles wie bei ++ nur andersrum
    {
        if(Xpos > 28)
        {
            ausgeben(true);
            Xpos -= 3;
            ausgeben(false);
            --positionsWert;
        }
    }
    void ausgeben(bool leeren)
    {
        con::print(Ypos, Xpos, leeren? ' ' : '^');
        con::print(Ypos+1, Xpos, leeren? ' ' : '|');
    }
};

void gebeSpielfeldAus()
{
    con::gotoxy(1, 1);
    std::cout <<
              "\n\n\n\n\n\n"
              "\t\t\t|--|--|--|--|--|--|--|\n"
              "\t\t\t|  |  |  |  |  |  |  |\n"
              "\t\t\t|--|--|--|--|--|--|--|\n"
              "\t\t\t|  |  |  |  |  |  |  |\n"
              "\t\t\t|--|--|--|--|--|--|--|\n"
              "\t\t\t|  |  |  |  |  |  |  |\n"
              "\t\t\t|--|--|--|--|--|--|--|\n"
              "\t\t\t|  |  |  |  |  |  |  |\n"
              "\t\t\t|--|--|--|--|--|--|--|\n"
              "\t\t\t|  |  |  |  |  |  |  |\n"
              "\t\t\t|--|--|--|--|--|--|--|\n"
              "\t\t\t|  |  |  |  |  |  |  |\n"
              "\t\t\t|--|--|--|--|--|--|--|\n";
}

void aktualisiereSpielfeld(int spieler, int hoehe, int position)
{
    if(spieler == 1)
        con::print(18-(hoehe*2), position, 'X', con::RED);
    else
        con::print(18-(hoehe*2), position, 'O', con::GREEN);
}

bool checkeHorizontalUndVertikal(constFeldTyp& spielfeldMatrix, bool vertikal)
{
    for(int check = 1; check <= 2; ++check)
        for(int i = 0; i < (vertikal? 7 : 6); ++i)
        {
            int anzahlGleicher = 0;
            for(int j = 0; j < (vertikal? 6 : 7); ++j)
                if(spielfeldMatrix[(vertikal? j : i)][(vertikal? i : j)] == check)
                {
                    if(++anzahlGleicher == 4)
                        return true;
                }
                else
                    anzahlGleicher = 0;
        }
    return false;
}

bool checkeDiagonal(constFeldTyp& spielfeldMatrix, bool linksZuRechts)
{
	for(int check = 1; check <= 2; ++check)
	{
		int maxHoehe[] = { 5, 5, 4, 3 };
		for(int i = 0; i <= 3; ++i)
		{
			int anzahlGleicher = 0;
			int j = 6-i;
			if(linksZuRechts)
				j = i;
			for(int k = 0; k <= maxHoehe[i]; ++k)
			{
				if(spielfeldMatrix[k][j] == check)
				{
					if(++anzahlGleicher == 4)
						return true;
				}
				else
					anzahlGleicher = 0;
				if(linksZuRechts)
					++j;
				else
					--j;
			}
		}
	}
	return false;
}

bool checkeDiagonalExtra(constFeldTyp& spielfeldMatrix, bool linksZuRechts)
{
	for(int k = 1; k <= 2; ++k)
	{
        for(int check = 1; check <= 2; ++check)
        {
            int anzahlGleicher = 0;
            int j = 6;
            if(linksZuRechts)
                j = 0;
            for(int i = k; i <= 5; ++i)
            {
                if(spielfeldMatrix[i][j] == check)
                {
                    if(++anzahlGleicher == 4)
                        return true;
                }
                else
                    anzahlGleicher = 0;
                if(linksZuRechts)
                    ++j;
                else
                    --j;
            }
        }
	}
	return false;
}

bool geloest(constFeldTyp& spielfeldMatrix)
{
    return checkeHorizontalUndVertikal(spielfeldMatrix, true) ||
           checkeHorizontalUndVertikal(spielfeldMatrix, false) ||
           checkeDiagonal(spielfeldMatrix, true) ||
           checkeDiagonal(spielfeldMatrix, false) ||
           checkeDiagonalExtra(spielfeldMatrix, true) ||
           checkeDiagonalExtra(spielfeldMatrix, false);
}

bool unentschieden(constFeldTyp& spielfeldMatrix)
{
    for(int i = 0; i < 6; ++i)
        for(int j = 0; j < 7; ++j)
            if(spielfeldMatrix[i][j] == 0) //wenns irgendwo ein leeres feld gibt
                return false; //kann man noch spielen
    return true;
}

void bewegePfeil(Pfeil& p, char eingabe)
{
    if(eingabe == con::ARROW_RIGHT || eingabe == 'd')
        ++p;
    else if(eingabe == con::ARROW_LEFT || eingabe == 'a')
        --p;
}

bool spielEnde(constFeldTyp& spielfeldMatrix)
{
    if(geloest(spielfeldMatrix))
    {
        con::print(12, 60, "hat gewonnen!!", con::GREEN);
        return true;
    }
    if(unentschieden(spielfeldMatrix))
    {
        con::print(12, 60, "setzte den letzten", con::YELLOW);
        con::print(13, 60, "Stein zum ", con::YELLOW);
        con::print(14, 60, "Unentschieden!", con::YELLOW);
        return true;
    }
    return false;
}

int main()
{
    feldTyp spielfeldMatrix = {{{{0}}}};
    con::blinking_cursor(false);
    con::color(con::WHITE);
    Pfeil pfeil; //zeichnet schonmal einen
    pfeil.ausgeben(false);
    gebeSpielfeldAus();
    enum
    {
        SPIELER_1,
        SPIELER_2
    };
    bool aktuellerSpieler = SPIELER_1;
    do
    {
        con::print(12, 50, "Spieler ");
        std::cout << int(aktuellerSpieler)+1; //false = 0, 0 + 1 = 1

        char eingabe;
        do
        {
            eingabe = getch();
			if(eingabe == con::ESCAPE)
				return 0;
            bewegePfeil(pfeil, eingabe);
        }
        while(eingabe != con::ENTER && eingabe != con::SPACE);

        int hoehe = 0; //wird errechnet aus der position des pfeils und dem inhalt des arrays
        for(int i = 0; i < SPIELFELD_HOEHE; ++i) //laeuft von der pfeilposition an einmal nach oben durch
            if(spielfeldMatrix[i][pfeil.positionsWert] != 0)//und wenn da schon was ist, muss das naechte objekt darueber
                ++hoehe;
        if(hoehe < SPIELFELD_HOEHE)
            spielfeldMatrix[hoehe][pfeil.positionsWert] = (aktuellerSpieler == 0? 1 : 2);
        else //es wird gar nix gesetzt und
            continue; //kein Spielerwechsel

        aktualisiereSpielfeld(aktuellerSpieler, hoehe, pfeil.Xpos); //uerbtraegt den Inhalt des Arrays aufs Spielfeld

        aktuellerSpieler ^= 1; //wechselt den Spieler

    } while(!spielEnde(spielfeldMatrix));
    std::cin.get();
}
Bitte melden Sie sich an um eine Kommentar zu schreiben.
Kommentar schreiben
Admin: 0
#2
vote_ok
von Gustl (6560 Punkte) - 05.01.2013 um 17:45 Uhr
Man kann zwar zwischen Player vs Player und Player vs Computer auswählen, aber der Computer hat keine KI, sondern Random zwischen 1-7.

Bestimmt keine elegante Lösung, aber das war meine damals. :)

main.cpp
Quellcode ausblenden C-Code
#include <iostream>

using namespace std;

#include "viergewinnt.h"
int main(int argc, char *argv[])
{   viergewinnt spiel;
    int wahl, wahlpc;
    spiel.matrix();
    cout<<"    Player vs Player?   - 1"<<endl<<"    Player vs Computer? - 2  ";
    cin>>wahlpc;
    switch(wahlpc)
    {
        case 1: while (spiel.win() != 1)
                {  
                    if(spiel.nextP()) { spiel.setFW(12); cout<<endl<<"       Spieler 1 (1-7): ";}
                    else {spiel.setFW(10);cout<<endl<<"       Spieler 2 (1-7): ";}
                    cin>>wahl;
                    system("cls");
                    if(spiel.nextP())spiel.setP1(wahl);
                    else spiel.setP2(wahl);
                    spiel.matrix();
       
                }
    
                if(spiel.win() == 1)if(spiel.nextP())  {spiel.setFW(10); cout<<endl<<endl<<"        Spieler 2";spiel.setFW(9);cout<<" WIN!";}
                else { spiel.setFW(12);cout<<endl<<endl<<"        Spieler 1";spiel.setFW(9);cout<<" WIN!";}
                break;
        case 2: while (spiel.win() != 1)
                {  
                    if(spiel.nextP()) { spiel.setFW(12); cout<<endl<<"       Spieler 1 (1-7): ";}
                    else {spiel.setFW(10);cout<<endl<<"       Comp 2 (1-7): ";}
                    if(spiel.nextP())cin>>wahl;
                    system("cls");
                    if(spiel.nextP())spiel.setP1(wahl);
                    else spiel.setP2(spiel.zugPC());
                    spiel.matrix();
       
                }
    
                if(spiel.win() == 1)if(spiel.nextP())  {spiel.setFW(10); cout<<endl<<endl<<"        Computer";spiel.setFW(9);cout<<" WIN!";}
                else { spiel.setFW(12);cout<<endl<<endl<<"        Spieler 1";spiel.setFW(9);cout<<" WIN!";}
                break;
    
    }
   
    spiel.ruecksetzten();
    
    system("PAUSE>NUL");
    return EXIT_SUCCESS;
}


viergewinnt.cpp
Quellcode ausblenden C-Code
#include <iostream>
#include "viergewinnt.h"
#include <windows.h> 
#include <math.h>
using namespace std;

viergewinnt::viergewinnt()
{  s=0;
   for(int i=0; i<7; i++)
      for(int i2=0; i2<5; i2++)
      p[i][i2]=0;
}
void viergewinnt::ruecksetzten()
{  s=0;
   for(int i=0; i<7; i++)
      for(int i2=0; i2<5; i2++)
      p[i][i2]=0;
}
bool viergewinnt::nextP()
{
    if(s==0)return true;
    else return false; 
}
void viergewinnt::setP1(int wahl)
{  if(wahl >=1 && wahl <=7)
   { 
     switch(wahl)
    {
        case 1:if     (p[0][0]==0){p[0][0]=1;s=1;}
               else if(p[0][1]==0){p[0][1]=1;s=1;}
               else if(p[0][2]==0){p[0][2]=1;s=1;}
               else if(p[0][3]==0){p[0][3]=1;s=1;}
               else if(p[0][4]==0){p[0][4]=1;s=1;}break;
        case 2:if     (p[1][0]==0){p[1][0]=1;s=1;}
               else if(p[1][1]==0){p[1][1]=1;s=1;}
               else if(p[1][2]==0){p[1][2]=1;s=1;}
               else if(p[1][3]==0){p[1][3]=1;s=1;}
               else if(p[1][4]==0){p[1][4]=1;s=1;}break;
        case 3:if     (p[2][0]==0){p[2][0]=1;s=1;}
               else if(p[2][1]==0){p[2][1]=1;s=1;}
               else if(p[2][2]==0){p[2][2]=1;s=1;}
               else if(p[2][3]==0){p[2][3]=1;s=1;}
               else if(p[2][4]==0){p[2][4]=1;s=1;}break;
        case 4:if     (p[3][0]==0){p[3][0]=1;s=1;}
               else if(p[3][1]==0){p[3][1]=1;s=1;}
               else if(p[3][2]==0){p[3][2]=1;s=1;}
               else if(p[3][3]==0){p[3][3]=1;s=1;}
               else if(p[3][4]==0){p[3][4]=1;s=1;}break;
        case 5:if     (p[4][0]==0){p[4][0]=1;s=1;}
               else if(p[4][1]==0){p[4][1]=1;s=1;}
               else if(p[4][2]==0){p[4][2]=1;s=1;}
               else if(p[4][3]==0){p[4][3]=1;s=1;}
               else if(p[4][4]==0){p[4][4]=1;s=1;}break;
        case 6:if     (p[5][0]==0){p[5][0]=1;s=1;}
               else if(p[5][1]==0){p[5][1]=1;s=1;}
               else if(p[5][2]==0){p[5][2]=1;s=1;}
               else if(p[5][3]==0){p[5][3]=1;s=1;}
               else if(p[5][4]==0){p[5][4]=1;s=1;}break;
        case 7:if     (p[6][0]==0){p[6][0]=1;s=1;}
               else if(p[6][1]==0){p[6][1]=1;s=1;}
               else if(p[6][2]==0){p[6][2]=1;s=1;}
               else if(p[6][3]==0){p[6][3]=1;s=1;}
               else if(p[6][4]==0){p[6][4]=1;s=1;}break;
    }
    }     
}

void viergewinnt::setP2(int wahl)
{  
   if(wahl >=1 && wahl <=7)
   { 
   switch(wahl)
    {
        case 1:if     (p[0][0]==0){p[0][0]=2;s=0;}
               else if(p[0][1]==0){p[0][1]=2;s=0;}
               else if(p[0][2]==0){p[0][2]=2;s=0;}
               else if(p[0][3]==0){p[0][3]=2;s=0;}
               else if(p[0][4]==0){p[0][4]=2;s=0;}break;
        case 2:if     (p[1][0]==0){p[1][0]=2;s=0;}
               else if(p[1][1]==0){p[1][1]=2;s=0;}
               else if(p[1][2]==0){p[1][2]=2;s=0;}
               else if(p[1][3]==0){p[1][3]=2;s=0;}
               else if(p[1][4]==0){p[1][4]=2;s=0;}break;
        case 3:if     (p[2][0]==0){p[2][0]=2;s=0;}
               else if(p[2][1]==0){p[2][1]=2;s=0;}
               else if(p[2][2]==0){p[2][2]=2;s=0;}
               else if(p[2][3]==0){p[2][3]=2;s=0;}
               else if(p[2][4]==0){p[2][4]=2;s=0;}break;
        case 4:if     (p[3][0]==0){p[3][0]=2;s=0;}
               else if(p[3][1]==0){p[3][1]=2;s=0;}
               else if(p[3][2]==0){p[3][2]=2;s=0;}
               else if(p[3][3]==0){p[3][3]=2;s=0;}
               else if(p[3][4]==0){p[3][4]=2;s=0;}break;
        case 5:if     (p[4][0]==0){p[4][0]=2;s=0;}
               else if(p[4][1]==0){p[4][1]=2;s=0;}
               else if(p[4][2]==0){p[4][2]=2;s=0;}
               else if(p[4][3]==0){p[4][3]=2;s=0;}
               else if(p[4][4]==0){p[4][4]=2;s=0;}break;
        case 6:if     (p[5][0]==0){p[5][0]=2;s=0;}
               else if(p[5][1]==0){p[5][1]=2;s=0;}
               else if(p[5][2]==0){p[5][2]=2;s=0;}
               else if(p[5][3]==0){p[5][3]=2;s=0;}
               else if(p[5][4]==0){p[5][4]=2;s=0;}break;
        case 7:if     (p[6][0]==0){p[6][0]=2;s=0;}
               else if(p[6][1]==0){p[6][1]=2;s=0;}
               else if(p[6][2]==0){p[6][2]=2;s=0;}
               else if(p[6][3]==0){p[6][3]=2;s=0;}
               else if(p[6][4]==0){p[6][4]=2;s=0;}break;
    }
    }      
}

char viergewinnt::getm(int x, int y)
{   if(p[x][y] == 2){setFW(10);return 219;}
    if(p[x][y] == 1){setFW(12);return 219;}
    if(p[x][y] == 0)return ' ';
}

void viergewinnt::setFW(int farbe)
{
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), farbe);     
}

void viergewinnt::matrix()
{  setFW(15);
   cout<<endl<<"    1   2   3   4   5   6   7 "<<endl;
   //cout<<"  "<<(char)201<<(char)205<<(char)205<<(char)205<<"+---+---+---+---+---+---+"<<endl;
   for(int i=4; i>=0; i--)
   { 
      cout<<"  "<<(char)204<<(char)205<<(char)205<<(char)205<<(char)206<<(char)205<<(char)205<<(char)205<<(char)206<<(char)205<<(char)205<<(char)205<<(char)206<<(char)205<<(char)205<<(char)205<<(char)206<<(char)205<<(char)205<<(char)205<<(char)206<<(char)205<<(char)205<<(char)205<<(char)206<<(char)205<<(char)205<<(char)205<<(char)185<<endl;
       cout<<"  "<<(char)186<<" ";setFW(15);
       cout<<getm(0,i);
       setFW(15);cout<<" "<<(char)186<<" ";
       cout<<getm(1,i);
       setFW(15);cout<<" "<<(char)186<<" ";
       cout<<getm(2,i);
       setFW(15);cout<<" "<<(char)186<<" ";
       cout<<getm(3,i);
       setFW(15);cout<<" "<<(char)186<<" ";
       cout<<getm(4,i);
       setFW(15);cout<<" "<<(char)186<<" ";
       cout<<getm(5,i);
       setFW(15);cout<<" "<<(char)186<<" ";
       cout<<getm(6,i);
       setFW(15);cout<<" "<<(char)186<<" "<<endl;
       
}
cout<<"  "<<(char)200<<(char)205<<(char)205<<(char)205<<(char)202<<(char)205<<(char)205<<(char)205<<(char)202<<(char)205<<(char)205<<(char)205<<(char)202<<(char)205<<(char)205<<(char)205<<(char)202<<(char)205<<(char)205<<(char)205<<(char)202<<(char)205<<(char)205<<(char)205<<(char)202<<(char)205<<(char)205<<(char)205<<(char)188<<endl;
//cout<<"  +---+---+---+---+---+---+---+"<<endl;
}

int viergewinnt::win()
{  for(int i=1; i<3; i++)
  {if(p[0][0] == i && p[0][1] == i && p[0][2] == i && p[0][3] == i)return 1;
   if(p[0][1] == i && p[0][2] == i && p[0][3] == i && p[0][4] == i)return 1;
   if(p[1][0] == i && p[1][1] == i && p[1][2] == i && p[1][3] == i)return 1;
   if(p[1][1] == i && p[1][2] == i && p[1][3] == i && p[1][4] == i)return 1;
   if(p[2][0] == i && p[2][1] == i && p[2][2] == i && p[2][3] == i)return 1;
   if(p[2][1] == i && p[2][2] == i && p[2][3] == i && p[2][4] == i)return 1;
   if(p[3][0] == i && p[3][1] == i && p[3][2] == i && p[3][3] == i)return 1;
   if(p[3][1] == i && p[3][2] == i && p[3][3] == i && p[3][4] == i)return 1;
   if(p[4][0] == i && p[4][1] == i && p[4][2] == i && p[4][3] == i)return 1;
   if(p[4][1] == i && p[4][2] == i && p[4][3] == i && p[4][4] == i)return 1;
   if(p[5][0] == i && p[5][1] == i && p[5][2] == i && p[5][3] == i)return 1;
   if(p[5][1] == i && p[5][2] == i && p[5][3] == i && p[5][4] == i)return 1;
   if(p[6][0] == i && p[6][1] == i && p[6][2] == i && p[6][3] == i)return 1;
   if(p[6][1] == i && p[6][2] == i && p[6][3] == i && p[6][4] == i)return 1;
   
   if(p[0][0] == i && p[1][0] == i && p[2][0] == i && p[3][0] == i)return 1;
   if(p[1][0] == i && p[2][0] == i && p[3][0] == i && p[4][0] == i)return 1;
   if(p[2][0] == i && p[3][0] == i && p[4][0] == i && p[5][0] == i)return 1;
   if(p[3][0] == i && p[4][0] == i && p[5][0] == i && p[6][0] == i)return 1;
   
   if(p[0][1] == i && p[1][1] == i && p[2][1] == i && p[3][1] == i)return 1;
   if(p[1][1] == i && p[2][1] == i && p[3][1] == i && p[4][1] == i)return 1;
   if(p[2][1] == i && p[3][1] == i && p[4][1] == i && p[5][1] == i)return 1;
   if(p[3][1] == i && p[4][1] == i && p[5][1] == i && p[6][1] == i)return 1;
   
   if(p[0][2] == i && p[1][2] == i && p[2][2] == i && p[3][2] == i)return 1;
   if(p[1][2] == i && p[2][2] == i && p[3][2] == i && p[4][2] == i)return 1;
   if(p[2][2] == i && p[3][2] == i && p[4][2] == i && p[5][2] == i)return 1;
   if(p[3][2] == i && p[4][2] == i && p[5][2] == i && p[6][2] == i)return 1;
   
   if(p[0][3] == i && p[1][3] == i && p[2][3] == i && p[3][3] == i)return 1;
   if(p[1][3] == i && p[2][3] == i && p[3][3] == i && p[4][3] == i)return 1;
   if(p[2][3] == i && p[3][3] == i && p[4][3] == i && p[5][3] == i)return 1;
   if(p[3][3] == i && p[4][3] == i && p[5][3] == i && p[6][3] == i)return 1;
   
   if(p[0][4] == i && p[1][4] == i && p[2][4] == i && p[3][4] == i)return 1;
   if(p[1][4] == i && p[2][4] == i && p[3][4] == i && p[4][4] == i)return 1;
   if(p[2][4] == i && p[3][4] == i && p[4][4] == i && p[5][4] == i)return 1;
   if(p[3][4] == i && p[4][4] == i && p[5][4] == i && p[6][4] == i)return 1;
   
   
   if(p[0][0] == i && p[1][1] == i && p[2][2] == i && p[3][3] == i)return 1;
   if(p[0][1] == i && p[1][2] == i && p[2][3] == i && p[3][4] == i)return 1;
   if(p[1][1] == i && p[2][2] == i && p[3][3] == i && p[4][4] == i)return 1;
   if(p[1][0] == i && p[2][1] == i && p[3][2] == i && p[4][3] == i)return 1;
   if(p[2][1] == i && p[3][2] == i && p[4][3] == i && p[5][4] == i)return 1;
   if(p[2][0] == i && p[3][1] == i && p[4][2] == i && p[5][3] == i)return 1;
   if(p[3][1] == i && p[4][2] == i && p[5][3] == i && p[6][4] == i)return 1;
   if(p[3][0] == i && p[4][1] == i && p[5][2] == i && p[6][3] == i)return 1;
   
   if(p[6][1] == i && p[5][2] == i && p[4][3] == i && p[3][4] == i)return 1;
   if(p[6][0] == i && p[5][1] == i && p[4][2] == i && p[3][3] == i)return 1;
   if(p[5][1] == i && p[4][2] == i && p[3][3] == i && p[2][4] == i)return 1;
   if(p[5][0] == i && p[4][1] == i && p[3][2] == i && p[2][3] == i)return 1;
   if(p[4][1] == i && p[3][2] == i && p[2][3] == i && p[1][4] == i)return 1;
   if(p[4][0] == i && p[3][1] == i && p[2][2] == i && p[1][3] == i)return 1;
   if(p[3][1] == i && p[2][2] == i && p[1][3] == i && p[0][4] == i)return 1;
   if(p[3][0] == i && p[2][1] == i && p[1][2] == i && p[0][3] == i)return 1;
   }
   
}


int viergewinnt::zugPC()
{  srand (time(NULL));
    return rand()%7;
}


viergewinnt.h
Quellcode ausblenden C-Code
class viergewinnt
{  int p[7][5];
   int s;
   int chance;
   public:
        viergewinnt();
        void setP1(int wahl);
        void setP2(int wahl);
        void matrix();
        char getm(int x, int y);
        void ruecksetzten();
        bool nextP(); 
        int win();
        void setFW(int farbe);
        int zugPC();    
};

Bitte melden Sie sich an um eine Kommentar zu schreiben.
Kommentar schreiben
viergewinnt.zip viergewinnt.jpg Admin: 0
2107412

Du scheinst einen AdBlocker zu nutzen. Ich würde mich freuen, wenn du ihn auf dieser Seite deaktivierst und dich davon überzeugst, dass die Werbung hier nicht störend ist.