// Die Felder anlegen. Später wird dort je nachdem welcher Spieler es gefüllt
// hat 'x' oder 'o' stehen.
char fields[3][3] = { 0 };
 
// Hier speichern wir welcher Spieler aktuell an der Reihe ist. (Es beginnt
// demnach der Spieler der die X setzt)
char turn = 'x';
 
bool running = true;
SDL_Event event;
 
// Events abarbeiten
while( running && SDL_WaitEvent(&event) )
{
  switch( event.type )
  {
    // Programm sollte beendet werden ('x' im Fenster wurde geklickt)
    case SDL_QUIT:
      running = false;
      break;
    case SDL_MOUSEBUTTONDOWN:
      if(event.button.button == SDL_BUTTON_LEFT)
      {
        // Überprüfen ob das Spiel bereits beendet wurde
        if( !turn )
          break;
 
        Sint16 x = event.button.x * 3./SIZE,
               y = event.button.y * 3./SIZE;
 
        // Wenn das Feld bereits besetzt ist brauchen wir nichts machen
        if( fields[x][y] )
          break;
 
        SDL_Rect position = { x * SIZE/3. + LINE_WIDTH/2. + 0.5,
                              y * SIZE/3. + LINE_WIDTH/2. + 0.5 };
 
        SDL_BlitSurface
        (
          (turn == 'x') ? cross : circle, // Je nachdem welcher Spieler an
                                          // der Reihe ist ein Kreuz
          NULL,                           // oder einen Kreis zeichnen
          screen,
          &position
        );
 
        // Merken das der aktuelle Spieler eine Symbol gesetzt hat
        fields[x][y] = turn;
 
        //--------------------------------------------------------------------
        // Jetzt überprüfen wir ob ein Spieler gewonnen hat
 
        // Falls wer gewonnen hat merken wir uns hier welche drei Felder
        // die Gewinnfelder sind
        bool winning_fields[3][3] = { false };
 
        // Diagonalen überprüfen
        if(    fields[0][0]
            && fields[1][1] == fields[0][0]
            && fields[2][2] == fields[0][0] )
        {
          for(size_t i = 0; i < 3; ++i)
            winning_fields[i][i] = true;
 
          turn = 0;
        }
        else if(    fields[0][2]
                 && fields[1][1] == fields[0][2]
                 && fields[2][0] == fields[0][2] )
        {
          for(size_t i = 0; i < 3; ++i)
            winning_fields[i][2 - i] = true;
 
          turn = 0;
        }
        else
        {
          // Linien in y-Richtung überprüfen
          for(size_t x = 0; x < 3; ++x)
            if(    fields[x][0]
                && fields[x][1] == fields[x][0]
                && fields[x][2] == fields[x][0] )
            {
              for(size_t y = 0; y < 3; ++y)
                winning_fields[x][y] = true;
 
              turn = 0;
              break;
            }
 
          if( turn )
          {
            // Linien in x-Richtung überprüfen
            for(size_t y = 0; y < 3; ++y)
              if(    fields[0][y]
                  && fields[1][y] == fields[0][y]
                  && fields[2][y] == fields[0][y] )
              {
                for(size_t x = 0; x < 3; ++x)
                  winning_fields[x][y] = true;
 
                turn = 0;
                break;
              }
          }
        }
 
        if( !turn )
        {
          // Gewinnfelder markieren
 
          for(size_t x = 0; x < 3; ++x)
            for(size_t y = 0; y < 3; ++y)
            {
              if( !winning_fields[x][y] )
                continue;
 
              // Die Felder einfach mit einem farbigen Rechteck markieren
              SDL_Rect marker = { (x + 0.5) * SIZE/3. - MARKER_SIZE/2.,
                                  (y + 0.5) * SIZE/3. - MARKER_SIZE/2.,
                                  MARKER_SIZE,
                                  MARKER_SIZE };
              SDL_FillRect
              (
                screen,
                &marker,
                SDL_MapRGB(screen->format, 255, 0, 0)
              );
            }
        }
        else
          turn = (turn == 'x') ? 'o' : 'x';
 
        SDL_Flip(screen);
      }
      break;
  }
}

← Spielsteine Laden und Anzeigen ← | ↑ Tic-Tac-Toe mit der SDL ↑ | → ??? →