Go Down

Topic: 3 en raya o Tic Tac Toe (Read 997 times) previous topic - next topic

hombrelobo

Dec 27, 2010, 02:52 am Last Edit: Dec 27, 2010, 03:01 am by hombrelobo Reason: 1
Pues aqui esta el tres en raya para arduino, implementando el potenciometro que explique anteayer como modo de seleccion.

De momento es para dos jugadores, mientras me curro como hacer que el bicho elija en condiciones.

Pero bueno, por lo menos el juego funciona y es solo implementar la funcion de la IA.

Graficos en
Code: [Select]
http://rapidshare.com/files/439430584/tic_tac_toe.zip

Video en:
Code: [Select]
http://www.youtube.com/watch?v=qVByAYkbA9U

Parte 1:
Code: [Select]
/*
 3 en raya or TIC TAC TOE
 You can play against other Human Player. Select Circle or X pushing one
button and twisting a potenciometer.
 
 Hardware needed:
 - push button in digital pin 12
 - potenciometer in analog pin 0
 - 128x64 LCD with glcd library
 - Another Human to play!
 
 - Graphics in: http://rapidshare.com/files/439430584/tic_tac_toe.zip
 - Demo video in: http://www.youtube.com/watch?v=qVByAYkbA9U
 
 In a near future, I will create a new game against the machine! :)

 This code is in the public domain.
 Code by Hombrelobo, Timosoft Team. www.mundobocata.com

*/

#include <glcd.h>
#include "fonts/Arial14.h"         // proportional font
#include "fonts/SystemFont5x7.h"   // system font
#include "bitmaps/tic_tac_toe_logo.h"     // comienzo
#include "bitmaps/player1win.h"  
#include "bitmaps/player2win.h"  
#include "bitmaps/blanco.h"  //blanco para limpiar celdas
#include "bitmaps/o.h"     // circulo
#include "bitmaps/x.h"  //equis


int marcadorJugador1;
int marcadorJugador2;
int fichaJugador1;
int fichaJugador2;
int nowPlaying; // donde almaceno que ficha esta jugando ahora.
int fichas=0; //eleccion de fichas
int zumbador =12; // salida 12 digital   zumbador
int boton=11;     // salida 11 digital  boton de ok
int election;// donde guardo el valor que decida con el boton ok.
int celdas[] = {
 2,2,2,2,2,2,2,2,2}; // declaro el array de 9 posiciones
int selectVal;
int val1;


void setup()
{
 pinMode(boton, INPUT);
 pinMode(zumbador, OUTPUT);
 digitalWrite (zumbador, HIGH);
 GLCD.Init(NON_INVERTED);   // initialise the library
 GLCD.SelectFont(System5x7);       // select fixed width system font
 GLCD.ClearScreen();
 digitalWrite (zumbador,LOW);// apago el zumbador
}


void loop ()
{
 if (fichas==0)
 {

   GLCD.CursorTo(2,0);               // for LCD
   GLCD.Puts("Select Who Starts");  // for LCD
   GLCD.CursorTo(0,5);               // for LCD
   GLCD.Puts("Move the Potenciom.");
   GLCD.CursorTo(0,6);               // for LCD
   GLCD.Puts("LEFT RIGHT to Choose");
   GLCD.CursorTo(0,7);               // for LCD
   GLCD.Puts("Push Button to Select");
   selectVal = map(analogRead(0), 0, 512, 0, 1); // Map an analog value to 2 numbers ( 0 to 1)
   delay(500);
   if (selectVal==0)  //si el valor del potenciometro es 0
   {
     GLCD.DrawBitmap(o, 50,15, BLACK); //muestra la ficha 0
     if (digitalRead(12)==HIGH)   // y si pulso el boton, fijo el valor
     {
       nowPlaying=0;  //elijo la ficha o
       fichas=1;
       fichaJugador1=0;
       fichaJugador2=1;
       GLCD.ClearScreen();
       GLCD.DrawBitmap(tic_tac_toe_logo, 0,0, BLACK); // pinta en pantalla el logo del juego
       delay(3000);
       GLCD.ClearScreen();
     }
   }
   else{
     GLCD.DrawBitmap(x, 50,15, BLACK);
     if (digitalRead(12)==HIGH) {
       nowPlaying=1;
       fichas=1;
       fichaJugador1=1;
       fichaJugador2=0;
       GLCD.ClearScreen();
       GLCD.DrawBitmap(tic_tac_toe_logo, 0,0, BLACK); // pinta en pantalla el logo del juego
       delay(3000);
       GLCD.ClearScreen();
     }
   }
 }
 else{
   marcador();
 }
}

/*********************************************************/
/*************comprobacion de marcadores******************/
/*********************************************************/
void marcador()  //comprueba el marcador del juego y si nadie ha ganado pinta la tabla.
{
 if (marcadorJugador1==3)
 {
   GLCD.ClearScreen();
      GLCD.DrawBitmap(player1win, 0,0, BLACK); //ganaste!
   return;
 }
 else if (marcadorJugador2==3){
   GLCD.ClearScreen();
      GLCD.DrawBitmap(player2win, 0,0, BLACK); // perdiste!
   return;
 }
 else{
   pintaJuego(); // pinto escenario
   pintaMarcador(); //pinto marcadores
   elijeCelda(); //elijo celda
   victoriaCirculo(); //chequeo la victoria de Circulo
   victoriaEquis(); //chequeo la victoria de equis
 }
}

/*********************************************************/
/***************pintando el escenario*********************/
/*********************************************************/
void pintaJuego() // queda libre del pixel x 67 en adelante para texto
{
 //pintamos el tablero de juego
 GLCD.DrawLine( 0, 0, 0, 63, BLACK);  //marco izquierdo
 GLCD.DrawLine( 22, 0, 22, 63, BLACK);//linea Vertical 1
 GLCD.DrawLine( 44, 0, 44, 63, BLACK);//linea Vertical 2
 GLCD.DrawLine( 66, 0, 66, 63, BLACK);//marco derecho
 GLCD.DrawLine( 0, 0, 66, 0, BLACK);//marco superior
 GLCD.DrawLine( 0, 21, 66, 21, BLACK);//linea Horizontal 1
 GLCD.DrawLine( 0, 43, 66, 43, BLACK);//linea Horizontal 2
 GLCD.DrawLine( 0, 63, 66, 63, BLACK);//marco inferior
 // pintando el cuadro del jugador activo
 GLCD.DrawLine( 102, 40, 126, 40, BLACK);//linea Horizontal 1 cuadrito activo
 GLCD.DrawLine( 102, 62, 126, 62, BLACK);//linea Horizontal 2 cuadrito activo
 GLCD.DrawLine( 102, 40, 102, 62, BLACK);//linea Vertical 1 cuadrito activo
 GLCD.DrawLine( 126, 40, 126, 62, BLACK);//linea Vertical 2 cuadrito activo
}

/*********************************************************/
/*****************pintando marcador***********************/
/*********************************************************/
void pintaMarcador() // queda libre del pixel x 67 en adelante para texto
{
 GLCD.CursorTo(12,0);               // for LCD
 GLCD.Puts("Score1:");              // for LCD
 GLCD.PrintNumber(marcadorJugador1); // for LCD
 GLCD.CursorTo(12,1);               // for LCD
 GLCD.Puts("Score2:");              // for LCD
 GLCD.PrintNumber(marcadorJugador2); // for LCD
 GLCD.CursorTo(12,3);               // for LCD
 GLCD.Puts("Poten:");              // for LCD
 GLCD.PrintNumber(val1); // for LCD
 GLCD.CursorTo(13,6);               // for LCD
 GLCD.Puts("NOW");              // for LCD

 // pintando el jugador activo en el cuadrito
 if (nowPlaying==0)
 {
   GLCD.DrawBitmap(o, 105,41, BLACK);
 }
 else{
   GLCD.DrawBitmap(x, 105,41, BLACK);
 }
}

hombrelobo

Parte 2:
Code: [Select]

/*********************************************************/
/****eleccion de celda pintando el valor en la celda******/
/************************* *******************************/

void elijeCelda()
{
 val1 = map(analogRead(0), 0, 1023, 0, 9);
 // Map an analog value to 10 (0 a 9) numbers (pongo 9 porque al pulsar el boton, el tramo superior me lo asimila al anterior
 if
   // Celda 0
 (val1==0 && celdas[0]==2)   //si el potenciometro esta en la posicion 0, y el array me dice que no tengo un valor asignado
 {
   if (nowPlaying==0) // y estoy jugando con los ceros,
   {
     GLCD.DrawBitmap(o, 2,1, BLACK); //pinto el dibujo del 0 de forma TEMPORAL
     delay(1000);
     GLCD.DrawBitmap(blanco, 2,1, BLACK); //borro el dibujo del 0
     if (digitalRead(12)==HIGH) // y si pulso, lo fijo en su lugar.
     {
       GLCD.DrawBitmap(o, 2,1, BLACK); //pinto el dibujo del 0 de forma FIJA
       nowPlaying=1;
       celdas[0]=0;
       delay(1000);
     }
     else{
     }

   }
   else if (nowPlaying==1) // y estoy jugando con las equis, repito lo mismo.
   {

     GLCD.DrawBitmap(x, 2,1, BLACK);
     delay(1000);
     GLCD.DrawBitmap(blanco, 2,1, BLACK);
     if (digitalRead(12)==HIGH)
     {
       GLCD.DrawBitmap(x, 2,1, BLACK);
       nowPlaying=0;
       celdas[0]=1;
       delay(1000);
     }
   }
 }
 // Celda 1
 else if
   (val1==1 && celdas[1]==2)  
 {
   if (nowPlaying==0)
   {
     GLCD.DrawBitmap(o, 24,1, BLACK);
     delay(1000);
     GLCD.DrawBitmap(blanco, 24,1, BLACK);
     if (digitalRead(12)==HIGH)
     {
       GLCD.DrawBitmap(o, 24,1, BLACK);
       nowPlaying=1;
       celdas[1]=0;
       delay(1000);
     }
     else{
     }
   }
   else if (nowPlaying==1)
   {
     GLCD.DrawBitmap(x, 24,1, BLACK);
     delay(1000);
     GLCD.DrawBitmap(blanco, 24,1, BLACK);
     if (digitalRead(12)==HIGH)
     {
       GLCD.DrawBitmap(x, 24,1, BLACK);
       nowPlaying=0;
       celdas[1]=1;
       delay(1000);
     }
   }
 }
 // Celda 2
 else if
   (val1==2 && celdas[2]==2)  
 {

   if (nowPlaying==0)
   {
     GLCD.DrawBitmap(o, 46,1, BLACK);
     delay(1000);
     GLCD.DrawBitmap(blanco, 46,1, BLACK);
     if (digitalRead(12)==HIGH)
     {
       GLCD.DrawBitmap(o, 46,1, BLACK);
       nowPlaying=1;
       celdas[2]=0;
       delay(1000);
     }
     else{
     }
   }
   else if (nowPlaying==1)
   {
     GLCD.DrawBitmap(x, 46,1, BLACK);
     delay(1000);
     GLCD.DrawBitmap(blanco, 46,1, BLACK);
     if (digitalRead(12)==HIGH)
     {
       GLCD.DrawBitmap(x, 46,1, BLACK);
       nowPlaying=0;
       celdas[2]=1;
       delay(1000);
     }
   }
 }
 // Celda 3
 else if
   (val1==3 && celdas[3]==2)  
 {
   if (nowPlaying==0)
   {
     GLCD.DrawBitmap(o, 2,22, BLACK);
     delay(1000);
     GLCD.DrawBitmap(blanco, 2,22, BLACK);
     if (digitalRead(12)==HIGH)
     {
       GLCD.DrawBitmap(o, 2,22, BLACK);
       nowPlaying=1;
       celdas[3]=0;
       delay(1000);
     }
     else{
     }
   }
   else if (nowPlaying==1)
   {
     GLCD.DrawBitmap(x, 2,22, BLACK);
     delay(1000);
     GLCD.DrawBitmap(blanco, 2,22, BLACK);
     if (digitalRead(12)==HIGH)
     {
       GLCD.DrawBitmap(x, 2,22, BLACK);
       nowPlaying=0;
       celdas[3]=1;
       delay(1000);
     }
   }
 }
 // Celda 4  
 else if
   (val1==4 && celdas[4]==2)  
 {
   if (nowPlaying==0)
   {
     GLCD.DrawBitmap(o, 24,22, BLACK);
     delay(1000);
     GLCD.DrawBitmap(blanco, 24,22, BLACK);
     if (digitalRead(12)==HIGH)
     {
       GLCD.DrawBitmap(o, 24,22, BLACK);
       nowPlaying=1;
       celdas[4]=0;
       delay(1000);
     }
     else{
     }
   }
   else if (nowPlaying==1)
   {
     GLCD.DrawBitmap(x, 24,22, BLACK);
     delay(1000);
     GLCD.DrawBitmap(blanco, 24,22, BLACK);
     if (digitalRead(12)==HIGH)
     {
       GLCD.DrawBitmap(x, 24,22, BLACK);
       nowPlaying=0;
       celdas[4]=1;
       delay(1000);
     }
   }
 }
 // Celda 5
 else if
   (val1==5 && celdas[5]==2)  
 {
   if (nowPlaying==0)
   {
     GLCD.DrawBitmap(o, 46,22, BLACK);
     delay(1000);
     GLCD.DrawBitmap(blanco, 46,22, BLACK);
     if (digitalRead(12)==HIGH)
     {
       GLCD.DrawBitmap(o, 46,22, BLACK);
       nowPlaying=1;
       celdas[5]=0;
       delay(1000);
     }
     else{
     }
   }
   else if (nowPlaying==1)
   {
     GLCD.DrawBitmap(x, 46,22, BLACK);
     delay(1000);
     GLCD.DrawBitmap(blanco, 46,22, BLACK);
     if (digitalRead(12)==HIGH)
     {
       GLCD.DrawBitmap(x, 46,22, BLACK);
       nowPlaying=0;
       celdas[5]=1;
       delay(1000);
     }
   }
 }
 // Celda 6
 else if
   (val1==6 && celdas[6]==2)  
 {
   if (nowPlaying==0)
   {
     GLCD.DrawBitmap(o, 2,44, BLACK);
     delay(1000);
     GLCD.DrawBitmap(blanco, 2,44, BLACK);
     if (digitalRead(12)==HIGH)
     {
       GLCD.DrawBitmap(o, 2,44, BLACK);
       nowPlaying=1;
       celdas[6]=0;
       delay(1000);
     }
     else{
     }
   }
   else if (nowPlaying==1)
   {
     GLCD.DrawBitmap(x, 2,44, BLACK);
     delay(1000);
     GLCD.DrawBitmap(blanco, 2,44, BLACK);
     if (digitalRead(12)==HIGH)
     {
       GLCD.DrawBitmap(x, 2,44, BLACK);
       nowPlaying=0;
       celdas[6]=1;
       delay(1000);
     }
   }
 }
 // Celda 7
 else if
   (val1==7 && celdas[7]==2)  
 {
   if (nowPlaying==0)
   {
     GLCD.DrawBitmap(o, 24,44, BLACK);
     delay(1000);
     GLCD.DrawBitmap(blanco, 24,44, BLACK);
     if (digitalRead(12)==HIGH)
     {
       GLCD.DrawBitmap(o, 24,44, BLACK);
       nowPlaying=1;
       celdas[7]=0;
       delay(1000);
     }
     else{
     }
   }
   else if (nowPlaying==1)
   {
     GLCD.DrawBitmap(x, 24,44, BLACK);
     delay(1000);
     GLCD.DrawBitmap(blanco, 24,44, BLACK);
     if (digitalRead(12)==HIGH)
     {
       GLCD.DrawBitmap(x, 24,44, BLACK);
       nowPlaying=0;
       celdas[7]=1;
       delay(1000);
     }
   }
 }
 // Celda 8 y la 9 porque me asimila el ultimo valor al anterior, y entonces el 8 me lo asimilaria al 7
 else if
   (val1==8  && celdas[8]==2 || val1==9 && celdas[8]==2)  
 {
   if (nowPlaying==0)
   {
     GLCD.DrawBitmap(o, 46,44, BLACK);
     delay(1000);
     GLCD.DrawBitmap(blanco, 46,44, BLACK);
     if (digitalRead(12)==HIGH)
     {
       GLCD.DrawBitmap(o, 46,44, BLACK);
       nowPlaying=1;
       celdas[8]=0;
       delay(1000);
     }
     else{
     }
   }
   else if (nowPlaying==1)
   {
     GLCD.DrawBitmap(x, 46,44, BLACK);
     delay(1000);
     GLCD.DrawBitmap(blanco, 46,44, BLACK);
     if (digitalRead(12)==HIGH)
     {
       GLCD.DrawBitmap(x, 46,44, BLACK);
       nowPlaying=0;
       celdas[8]=1;
       delay(1000);
     }
   }
 }


}

hombrelobo

Parte 3
Code: [Select]



/*********************************************************/
/***************condiciones de victoria*******************/
/*********************************************************/
void victoriaCirculo()
{
 if (
 celdas[0]==0 &&
   celdas[1]==0 &&
   celdas[2]==0
   ||
   celdas[3]==0 &&
   celdas[4]==0 &&
   celdas[5]==0
   ||
   celdas[6]==0 &&
   celdas[7]==0 &&
   celdas[8]==0
   ) // las lineas horizontales
 {
   dequieneselpuntoCirculo();
 }
 else if
   (
 celdas[0]==0 &&
   celdas[3]==0 &&
   celdas[6]==0
   ||
   celdas[1]==0 &&
   celdas[4]==0 &&
   celdas[7]==0
   ||
   celdas[2]==0 &&
   celdas[5]==0 &&
   celdas[8]==0
   ) // las lineas verticales
 {
   dequieneselpuntoCirculo();
 }
 else if
   ( celdas[0]==0 &&
   celdas[4]==0 &&
   celdas[8]==0
   ||
   celdas[2]==0 &&
   celdas[4]==0 &&
   celdas[6]==0
   ) // las lineas diagonales
 {
   dequieneselpuntoCirculo();
 }
}


void victoriaEquis()
{
 if (
 celdas[0]==1 &&
   celdas[1]==1 &&
   celdas[2]==1
   ||
   celdas[3]==1 &&
   celdas[4]==1 &&
   celdas[5]==1
   ||
   celdas[6]==1 &&
   celdas[7]==1 &&
   celdas[8]==1
   ) // las lineas horizontales
 {
   dequieneselpuntoEquis();
 }
 else if
   (
 celdas[0]==1 &&
   celdas[3]==1 &&
   celdas[6]==1
   ||
   celdas[1]==1 &&
   celdas[4]==1 &&
   celdas[7]==1
   ||
   celdas[2]==1 &&
   celdas[5]==1 &&
   celdas[8]==1
   ) // las lineas verticales
 {
   dequieneselpuntoEquis();
 }
 else if
   ( celdas[0]==1 &&
   celdas[4]==1 &&
   celdas[8]==1
   ||
   celdas[2]==1 &&
   celdas[4]==1 &&
   celdas[6]==1
   ) // las lineas diagonales
 {
   dequieneselpuntoEquis();
 }
}

void dequieneselpuntoCirculo(){
 if (fichaJugador1==0){  //si el jugador 1 tiene el circulo, punto
   marcadorJugador1=marcadorJugador1+1; // sumo punto a marcador
   celdas[0]=2; // reinicio array
   celdas[1]=2;
   celdas[2]=2;
   celdas[3]=2;
   celdas[4]=2;
   celdas[5]=2;
   celdas[6]=2;
   celdas[7]=2;
   celdas[8]=2;
   GLCD.ClearScreen();

 }
 else{//si el jugador 2 tiene el circulo, punto
   marcadorJugador2=marcadorJugador2+1;
   celdas[0]=2;
   celdas[1]=2;
   celdas[2]=2;
   celdas[3]=2;
   celdas[4]=2;
   celdas[5]=2;
   celdas[6]=2;
   celdas[7]=2;
   celdas[8]=2;
   GLCD.ClearScreen();
 }
}

void dequieneselpuntoEquis(){//si el jugador 1 tiene la equis, punto
 if (fichaJugador1==1){
   marcadorJugador1=marcadorJugador1+1;
   celdas[0]=2;
   celdas[1]=2;
   celdas[2]=2;
   celdas[3]=2;
   celdas[4]=2;
   celdas[5]=2;
   celdas[6]=2;
   celdas[7]=2;
   celdas[8]=2;
   GLCD.ClearScreen();
 }
 else{//si el jugador 2 tiene la equis, punto
   marcadorJugador2=marcadorJugador2+1;
   celdas[0]=2;
   celdas[1]=2;
   celdas[2]=2;
   celdas[3]=2;
   celdas[4]=2;
   celdas[5]=2;
   celdas[6]=2;
   celdas[7]=2;
   celdas[8]=2;
   GLCD.ClearScreen();
 }
}



Go Up