#include <iostream>												// librerias necesarias para el programa.
#include <stdlib.h>
#include <string>
#include <unistd.h>

const string arr_partidas[20]={									//Comienzos guerdados
	" 78412635","128763 54","1526 3487","52 687431","86542 731",
	"321 48657","3652874 1","8137 6254","51 237468","34562871 ",
	"652 38174","57 684213","72143856 "," 16753284"," 38745261",
	"8 5236471","3457 8621","72643 815","8712 6435","654 82731"
								};
const int arr_eval[192][3]=											// arreglo de evaluacion
{
	{0,0,0}, {0,0,1}, {0,0,2}, {0,0,3}, {0,1,0}, {0,1,1}, {0,1,2}, {0,1,3}, {0,2,0}, {0,2,1}, {0,2,2}, {0,2,3}, {0,3,0}, {0,3,1}, {0,3,2}, {0,3,3}, {0,4,0}, {0,4,1}, {0,4,2}, {0,4,3}, {0,5,0}, {0,5,1}, {0,5,2}, {0,5,3},
	{1,0,0}, {1,0,1}, {1,0,2}, {1,0,3}, {1,1,0}, {1,1,1}, {1,1,2}, {1,1,3}, {1,2,0}, {1,2,1}, {1,2,2}, {1,2,3}, {1,3,0}, {1,3,1}, {1,3,2}, {1,3,3}, {1,4,0}, {1,4,1}, {1,4,2}, {1,4,3}, {1,5,0}, {1,5,1}, {1,5,2}, {1,5,3},
	{2,0,0}, {2,0,1}, {2,0,2}, {2,0,3}, {2,1,0}, {2,1,1}, {2,1,2}, {2,1,3}, {2,2,0}, {2,2,1}, {2,2,2}, {2,2,3}, {2,3,0}, {2,3,1}, {2,3,2}, {2,3,3}, {2,4,0}, {2,4,1}, {2,4,2}, {2,4,3}, {2,5,0}, {2,5,1}, {2,5,2}, {2,5,3},
	{3,0,0}, {3,0,1}, {3,0,2}, {3,0,3}, {3,1,0}, {3,1,1}, {3,1,2}, {3,1,3}, {3,2,0}, {3,2,1}, {3,2,2}, {3,2,3}, {3,3,0}, {3,3,1}, {3,3,2}, {3,3,3}, {3,4,0}, {3,4,1}, {3,4,2}, {3,4,3}, {3,5,0}, {3,5,1}, {3,5,2}, {3,5,3},
	{4,0,0}, {4,0,1}, {4,0,2}, {4,0,3}, {4,1,0}, {4,1,1}, {4,1,2}, {4,1,3}, {4,2,0}, {4,2,1}, {4,2,2}, {4,2,3}, {4,3,0}, {4,3,1}, {4,3,2}, {4,3,3}, {4,4,0}, {4,4,1}, {4,4,2}, {4,4,3}, {4,5,0}, {4,5,1}, {4,5,2}, {4,5,3},
	{5,0,0}, {5,0,1}, {5,0,2}, {5,0,3}, {5,1,0}, {5,1,1}, {5,1,2}, {5,1,3}, {5,2,0}, {5,2,1}, {5,2,2}, {5,2,3}, {5,3,0}, {5,3,1}, {5,3,2}, {5,3,3}, {5,4,0}, {5,4,1}, {5,4,2}, {5,4,3}, {5,5,0}, {5,5,1}, {5,5,2}, {5,5,3},
	{6,0,0}, {6,0,1}, {6,0,2}, {6,0,3}, {6,1,0}, {6,1,1}, {6,1,2}, {6,1,3}, {6,2,0}, {6,2,1}, {6,2,2}, {6,2,3}, {6,3,0}, {6,3,1}, {6,3,2}, {6,3,3}, {6,4,0}, {6,4,1}, {6,4,2}, {6,4,3}, {6,5,0}, {6,5,1}, {6,5,2}, {6,5,3},
	{7,0,0}, {7,0,1}, {7,0,2}, {7,0,3}, {7,1,0}, {7,1,1}, {7,1,2}, {7,1,3}, {7,2,0}, {7,2,1}, {7,2,2}, {7,2,3}, {7,3,0}, {7,3,1}, {7,3,2}, {7,3,3}, {7,4,0}, {7,4,1}, {7,4,2}, {7,4,3}, {7,5,0}, {7,5,1}, {7,5,2}, {7,5,3}
	};


const string arr_resp[192]=											// arreglo de respuestas
	{
	"666","000","001","001","000","001","010","010","010","001","012","022","010","001","022","023","010","001","022","033","010","001","022","033",
	"000","001","100","100","010","110","111","111","100","111","022","122","100","111","122","033","100","111","132","123","100","111","132","123",
	"100","001","102","202","010","111","202","212","210","220","202","220","220","221","202","033","220","231","202","213","220","231","202","213",
	"100","001","202","303","010","111","212","303","220","221","022","123","230","330","330","303","330","321","312","303","330","321","312","303",
	"100","001","202","303","010","111","312","213","220","321","022","123","330","231","132","033","340","440","440","440","440","431","451","451",
	"100","001","202","303","010","111","312","213","220","321","022","123","330","231","132","033","440","441","541","541","450","550","550","550",
	"100","001","202","303","010","111","312","213","220","321","022","123","330","231","132","033","440","541","542","642","550","451","642","652",
	"100","001","202","303","010","111","312","213","220","321","022","123","330","231","132","033","440","541","642","643","550","451","652","666"
	};

class matrix													// Definicion de la clase matrix que contiene
	{															// los registros del juegos y el diseņo.

		public:													// funciones publicas
			matrix();											// constructor
			virtual ~matrix();									// destructor
			virtual bool validar_jugada(int);					// valida la jugada del humano.
			virtual void registrar_jugada(int);					// registra la jugada del humano.
			virtual void desplegar_juego();				        // muestra en consola el juego actualizado.
			virtual void mensajes(int);
			int			 final();
					
		private:												// variables que registran el juego.
			char		 arr_matrix[9];							// estado de la matrix.
			
	};

class palito													// Definicion de la clase palito que contiene
	{															// los registros del juegos y el diseņo.

		public:													// funciones publicas
			palito();											// constructor
			virtual ~palito();									// destructor
			virtual bool validar_jugada(string);				// valida la jugada del humano.
			virtual void registrar_jugada(string);				// registra la jugada del humano.
			virtual void desplegar_juego(string,string);	    // muestra en consola el juego actualizado.
			virtual void mensajes(int);							// retorna diversos mensajes.
			int          estado();								// retorna el estado del juego.
			void		 inicial();								// jugada inicial de la maquina.
			string		 cerebro();								// logica de evaluacion.

		private:												// variables que registran el juego.
			int			 arr_filas[3];							// estado de las filas.
			string		 arr_palitos;							// estado individual.
	};

//end libreria.h