Diese Seite ist unverschlüsselt! Um sicherzustellen, das Ihr Passwort nicht ausgelesen werden kann, sollten Sie auf die verschlüsselte Seite wechseln!

    Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (WinAPI, Konsole) » 4 Gewinnt in C - Hilfe bei KI
Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
20.06.2009, 15:04 Uhr
~JOe
Gast


Hallo, ich habe ein 4 gewinnt spiel in C programmiert. Dies funktioniert auch sehr gut. Jetzt aber möchte ich eine KI in mein Programm einbauen, aber ich weiss nicht wie ich das machen soll. Vllt. kann ja mal ein guter Programmierer über meine Quelltexte gucken, wie ich da eine KI am besten einbaue.

hier dier link zu meinen Projekt http://uploaded.to/file/tjuvbi

JOe
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
20.06.2009, 15:05 Uhr
~JOe
Gast


mein main:

C++:
#include "allgFkt.h"

#define ZL 8
#define SP 8

void main(void) {
    int spieler, zug_auswahl, zl, sp, pruef, voll_temp, win_temp, i, runde;
    int stats1[3], stats2[3];                                            // Hier werden die Spiele mit W / U / N gespeichert.
    char matrix[SP][ZL];                                                // Spielfeld
    char symbol, wdh, voll;                                                // Spielstein, Wiederholung, Variable für Spielfeld voll
    
    i=0;
    runde=1;
    
    while(i < 3) {
        stats1[i]=0;
        stats2[i]=0;
        ++i;
    }

    do{
        do{
            zl=sp=pruef=voll_temp=win_temp=zug_auswahl=0;
            system("cls");

            statistik(stats1, stats2);

            SetXY(65, 2); printf("Runde: %i",runde);                                            // Rundenanzahl

            SetXY(20, 1); printf(" *-------------------------------------*");
            SetXY(20, 2); printf("*-------------- "); textcolor(WHITE); printf("4 Gewinnt"); textcolor(LIGHTGRAY); printf(" --------------*");
            SetXY(20, 3); printf(" *-------------------------------------*\n\n");

            printf("Wer beginnt ");
            textcolor(LIGHTGREEN); printf("1=Gruen");
            textcolor(LIGHTGRAY); printf(" | ");
            textcolor(YELLOW); printf("2=Gelb");
            textcolor(LIGHTGRAY); printf(" ?: ");
            spieler=getch()-48;

            if (spieler==1)
                symbol='X';
            else
                symbol='O';

        }while(spieler!=1 && spieler!=2);

        for(zl=0 ; zl<8; zl++)
            for(sp=0 ; sp<8; sp++)
                matrix[sp][zl]='.';

        voll=0;

        do{
            textcolor(BLACK); SetXY(0, 5); printf("Wer beginnt 1=Gruen | 2=Gelb?  ");

            spielfeld(matrix);

            if(voll==0)
                win_temp=gewinnpruefung(matrix, symbol, zug_auswahl-1, zl);

            if(spieler==1 && win_temp==0) {
                do {
                    textcolor(LIGHTGREEN);
                    symbol='X';
                    SetXY(3, 6); printf("Gruen = X ist an der Reihe!");
                    SetXY(53, 6); set_cursortype(NORMALCURSOR); printf("Auswahl: ");
                    set_cursortype(SOLIDCURSOR); zug_auswahl=getch()-48;
                    if(zug_auswahl>=1 && zug_auswahl<=8) {
                        textcolor(WHITE); printf("%i", zug_auswahl);
                    }

                    textcolor(BLACK);
                    SetXY(53, 8); printf("Ungueltige Eingabe!");
                    SetXY(53, 9); printf("Erneute Eingabe!   ");

                    if(zug_auswahl>8 || zug_auswahl<1) {
                        textcolor(LIGHTRED);
                        SetXY(53, 8); printf("Ungueltige Eingabe!");
                        SetXY(53, 9); printf("Erneute Eingabe!   ");
                    }
                    else {
                        voll=0;
                        zl=0;
                        while(matrix[zug_auswahl-1][zl]=='X' && zl<8 || matrix[zug_auswahl-1][zl]=='O' && zl<8)
                            ++zl;
                            if(zl==8) {
                                textcolor(LIGHTRED);
                                SetXY(53, 8); printf("Kein Platz Mehr!   ");
                                SetXY(53, 9); printf("Erneute Eingabe!   ");
                                voll=1;
                            }
                            else
                                matrix[zug_auswahl-1][zl]='X';
                                symbol='X';

                            if(FeldVoll(matrix)==1)
                                break;
                        }
                } while(zug_auswahl>8 || zug_auswahl<1);

                    if(zug_auswahl<=8 && zug_auswahl>0 && voll==0) {
                        spieler=2;
                        voll=0;
                    }
                }
                
                else if(spieler==2 && win_temp==0) {
                    do {
                        textcolor(YELLOW);
                        symbol='O';
                        SetXY(3, 6); printf("Gelb = O ist an der Reihe! ");
                        SetXY(53, 6); set_cursortype(NORMALCURSOR); printf("Auswahl: ");
                        set_cursortype(SOLIDCURSOR); zug_auswahl=getch()-48;
                        if(zug_auswahl>=1 && zug_auswahl<=8) {
                            textcolor(WHITE); printf("%i", zug_auswahl);
                        }

                        textcolor(BLACK);
                        SetXY(53, 8); printf("Ungueltige Eingabe!");
                        SetXY(53, 9); printf("Erneute Eingabe!   ");

                        if(zug_auswahl>8 || zug_auswahl<1) {
                            textcolor(LIGHTRED);
                            SetXY(53, 8); printf("Ungueltige Eingabe!");
                            SetXY(53, 9); printf("Erneute Eingabe!   ");
                        }
                        else {
                            voll=0;
                            zl=0;
                            while(matrix[zug_auswahl-1][zl]=='X' && zl<8 || matrix[zug_auswahl-1][zl]=='O' && zl<8)
                                ++zl;
                            if(zl==8) {
                                textcolor(LIGHTRED);
                                SetXY(53, 8); printf("Kein Platz Mehr!   ");
                                SetXY(53, 9); printf("Erneute Eingabe!   ");
                                voll=1;
                            }
                            else
                                matrix[zug_auswahl-1][zl]='O';
                                symbol='O';
                        }
                    } while(zug_auswahl>8 || zug_auswahl<1);

                    if(zug_auswahl<=8 && zug_auswahl>0 && voll==0) {
                        spieler=1;
                        voll=0;
                    }
                }

                if(win_temp==1 && spieler==2) {
                    textcolor(LIGHTGREEN);
                    SetXY(53, 8); printf("Glueckwunsch!    ");
                    SetXY(53, 9); printf("Gruen hat gewonnen!    ");
                    stats1[0]+=1; stats2[2]+=1; ++runde;
                    break;
                }
                else if(win_temp==1 && spieler==1) {
                    textcolor(YELLOW);
                    SetXY(53, 8); printf("Glueckwunsch!    ");
                    SetXY(53, 9); printf("Gelb hat gewonnen!     ");
                    stats1[2]+=1; stats2[0]+=1; ++runde;
                    break;
                }
                    
                voll_temp=FeldVoll(matrix);

                if(voll_temp==8) {
                    textcolor(LIGHTCYAN);
                    SetXY(53, 8); printf("Spielfeld Voll!    ");
                    SetXY(53, 9); printf("UNENTSCHIEDEN!     ");
                    stats1[1]+=1; stats2[1]+=1; ++runde;
                    break;
                }
        } while(1);

        statistik(stats1, stats2);
        
        spielfeld(matrix);

        SetXY(2,23); textcolor(LIGHTGRAY); printf ("Neues Spiel starten(j/n)? "); set_cursortype(NORMALCURSOR);
        do {
            wdh=getch();
        } while(wdh != 'j' && wdh !='n');
        SetXY(2,24);
    }while(wdh == 'j');
}
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
20.06.2009, 15:05 Uhr
~JOe
Gast


meine Header:

C++:
#ifndef __STRICT_ANSI__
#include <io.h>
#endif

#ifndef ALLGFKT_H
#define ALLGFKT_H

#include   <stdio.h>
#include  <stdlib.h>
#include  <string.h>
#include    <time.h>
#include   <conio.h>
#include   <ctype.h>
#include <windows.h>
#pragma warning(disable:4996)

#define BLACK         0        
#define BLUE          1
#define GREEN         2
#define CYAN          3
#define RED           4
#define MAGENTA       5
#define BROWN         6
#define LIGHTGRAY     7                      
#define DARKGRAY      8  
#define LIGHTBLUE     9
#define LIGHTGREEN   10
#define LIGHTCYAN    11
#define LIGHTRED     12
#define LIGHTMAGENTA 13
#define YELLOW       14
#define WHITE        15

#define NOCURSOR      0
#define SOLIDCURSOR   1
#define NORMALCURSOR  2

#define M_E            2.71828182845904523536
#define M_LOG2E        1.44269504088896340736
#define M_LOG10E    0.434294481903251827651
#define M_LN2        0.693147180559945309417
#define M_LN10        2.30258509299404568402
#define M_PI        3.14159265358979323846
#define M_PI_2        1.57079632679489661923
#define M_PI_4        0.785398163397448309116
#define M_1_PI        0.318309886183790671538
#define M_2_PI        0.636619772367581343076
#define M_1_SQRTPI    0.564189583547756286948
#define M_2_SQRTPI    1.12837916709551257390
#define M_SQRT2        1.41421356237309504880
#define M_SQRT_2    0.707106781186547524401

#define BLINK         0x80

#define BREITE        8
#define HOEHE        8
#define GEWONNEN    4


struct text_info
{
    int winleft;        // unsigned char
    int wintop;
    int winright;
    int winbottom;
    int attribute;
    int normattr;
    int currmode;
    int screenheight;
    int screenwidth;
    int curx;
    int cury;
};

#endif ALLGEMEIN_H


void          SetXY         (int  x , int  y);
void          GetXY         (int *x , int *y);
int           getxpos       (void);
int           getypos       (void);
void          highvideo     (void);
void          set_textattr  (int  attr);
int           get_textattr  (int x, int y);
void          textbackground(int  color);
void          textcolor     (int  color);
void          set_cursortype(int  type);
int           get_cursortype(void);

int  FeldVoll       (char matrix[][8]);
int  gewinnpruefung(char matrix[][8], char symbol, int zug_auswahl, int zl);
int  ZeileSuchen   (char matrix[][8], int spalte);
int  gewinnpruefung(char matrix[][8], char symbol, int spalte, int zeile);
void spielfeld     (char matrix[][8]);
void statistik       (int gruen[], int gelb[]);
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
20.06.2009, 15:06 Uhr
~JOe
Gast


meine funktionen:

C++:
#include "allgFkt.h"


static int _foreground = LIGHTGRAY;
static int _background = BLACK;

static int save_attr;


void SetXY (int x, int y)     // SetXY() setzt den Cursor
{
//    COORD CPos = {x,y};           // auf Position X horizontal (Zählung 0 .. 79) und Y vertikal (0 .. 24)
    COORD CurPos;
    CurPos.X = x;                    // Element der Struktur COORD    
    CurPos.Y = y;    
    SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), CurPos);
}


void GetXY (int *x, int*y)
{
    CONSOLE_SCREEN_BUFFER_INFO Scr_Buf_info;
    GetConsoleScreenBufferInfo(GetStdHandle (STD_OUTPUT_HANDLE), &Scr_Buf_info);
    *x = Scr_Buf_info.dwCursorPosition.X;
    *y = Scr_Buf_info.dwCursorPosition.Y;
}


void set_textattr(int attr)
{
    if (!save_attr)
        save_attr = (_background<<4) | _foreground;

    _background = attr>>4;

    _foreground = attr & 0x0f;

    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), (WORD) attr);
}


int get_textattr(int x, int y)
{
    unsigned short attr;
    unsigned long  n;

    COORD gc = {(short)x,(short)y};
    ReadConsoleOutputAttribute(GetStdHandle (STD_OUTPUT_HANDLE), &attr, 1, gc, &n);
    return attr;
}


void highvideo()
{
  if (_foreground <= BROWN)
     textcolor (_foreground + 9);

  if (_background <= BROWN)
     textbackground (_background + 9);
}


void textbackground(int color)
{                                    
    if (!save_attr)
        save_attr=(_background<<4)|_foreground;

    if (color == BLINK)
        color = WHITE;

    _background = color;

    set_textattr (_foreground | (color << 4));
}


void textcolor(int color)      
{                                  
    if (!save_attr)
        save_attr = (_background<<4)|_foreground;

    if(color == BLINK)
        color = WHITE;

    _foreground = color;

    set_textattr(color | (_background<<4));
}


void set_cursortype(int type)
{
  CONSOLE_CURSOR_INFO Info;
  Info.bVisible = TRUE;

  if (type == NOCURSOR)
     Info.bVisible = FALSE;
  else if (type == SOLIDCURSOR)
     Info.dwSize = 100;
  else if (type == NORMALCURSOR)
     Info.dwSize = 1;

  SetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE), &Info);
}


int get_cursortype(void)
{
  CONSOLE_CURSOR_INFO Info;
  GetConsoleCursorInfo(GetStdHandle (STD_OUTPUT_HANDLE), &Info);

  if (Info.dwSize  ==    1)    return NORMALCURSOR;
  if (Info.dwSize  ==  100)    return SOLIDCURSOR;
  if (Info.bVisible==FALSE) return NOCURSOR;

  return NORMALCURSOR;
}

int gewinnpruefung(char matrix[][8], char symbol, int spalte, int zeile) {
    
    int i, j, win;

    /* senkrecht */
    win=1;
    for(j=zeile-1; j>=   0 && matrix[spalte][j]==symbol; --j, ++win);
    if(win==GEWONNEN)
        return 1;

    /* waagerecht */
    win=1;
    for(i=spalte-1; i>=    0 && matrix[i][zeile]==symbol; --i, ++win);
    for(i=spalte+1; i<BREITE && matrix[i][zeile]==symbol; ++i, ++win);
    if(win>=GEWONNEN)
        return 1;

    /* diagonal / */
    win=1;
    for(i=spalte-1, j=zeile-1; i>=    0 && j>=   0 && matrix[i][j]==symbol; --i, --j, ++win);
    for(i=spalte+1, j=zeile+1; i<BREITE && j<HOEHE && matrix[i][j]==symbol; ++i, ++j, ++win);
    if(win>=GEWONNEN)
        return 1;

    /* diagonal \ */
    win=1;
    for(i=spalte-1, j=zeile+1; i>=    0 && j<HOEHE && matrix[i][j]==symbol; --i, ++j, ++win);
    for(i=spalte+1, j=zeile-1; i<BREITE && j>=   0 && matrix[i][j]==symbol; ++i, --j, ++win);
    if(win >= GEWONNEN)
        return 1;

    return 0;
}


int FeldVoll(char matrix[][8])    {
    
    int spalte=0, zeile=7, i=0;

    while(spalte<=7) {
        if(matrix[spalte][zeile]=='X' || matrix[spalte][zeile]=='O')
            ++i;
        ++spalte;
    }
    return i;
}

int ZeileSuchen(char matrix[][8], int spalte) {

    int zl=0;
        
    while(matrix[spalte-1][zl]=='X' && zl<8 || matrix[spalte-1][zl]=='O' && zl<8)
        ++zl;

    return zl;
}

void spielfeld(char matrix[][8]) {

    int zl, ausrichtung, sp, i;

    textcolor(LIGHTGRAY);
    SetXY (32, 5); printf(" 1 2 3 4 5 6 7 8 \n");
    SetXY (32, 6); for(i=0; i<=16; ++i) printf("%c", 205); printf("\n");

    for(zl=7, ausrichtung=7; zl>=0; --zl) {
        SetXY(32, ausrichtung);
        for(sp=0 ; sp<8; ++sp) {
            if(matrix[sp][zl]=='X') {
                textcolor(LIGHTGREEN); printf(" %c", matrix[sp][zl]);
                if(sp==7)
                    ++ausrichtung;
            }
            else if(matrix[sp][zl]=='O') {
                textcolor(YELLOW); printf(" %c", matrix[sp][zl]);
                if(sp==7)
                    ++ausrichtung;
            }
            else {
                textcolor(LIGHTGRAY); printf(" %c", matrix[sp][zl]);
                if(sp==7)
                    ++ausrichtung;
            }
        }
        if(ausrichtung>14)
            ausrichtung=7;
    }
}

void statistik(int gruen[], int gelb[]) {

    textcolor(LIGHTGRAY);
    SetXY(2, 1); printf("Stat.: W | D | L ");
    SetXY(2, 2); textcolor(LIGHTGREEN); printf("Gruen: "); textcolor(LIGHTGRAY); printf("%i | %i | %i ", gruen[0], gruen[1], gruen[2]);
    SetXY(2, 3); textcolor(YELLOW); printf("Gelb : "); textcolor(LIGHTGRAY); printf("%i | %i | %i ", gelb[0], gelb[1], gelb[2]);
}
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
21.07.2009, 17:44 Uhr
~NoBodyIsPerfekt
Gast


beschreib doch dein Problem mal etwas näher, einen solchen Quellcode wird sich kaum einer wirklich genau angucken..
ich würde einfach irgendwo einbauen :

wenn Stelle x und Stelle y besetzt ist setze an stelle Z

aber generell versteh ich deiin problem nicht und deinen ellenlangen Quellcode les ich betimmt nicht!
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ C / C++ (WinAPI, Konsole) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: