#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <conio.h>
#include <dos.h>
#include <iostream.h>
#include <string.h>
#include <math.h>
#include <alloc.h>
#include <fstream.h>
#include <strstrea.h>

//El operador delete [] no funciona en este compilador

class cursor;
class ruleta;
int leecadenaxy(int x, int y, char * &caracteres);
void errormemoria();

inline void waitRetrace()
{
while(inportb(0x3da)&8)
	;
while(!(inportb(0x3da)&8))
	;
}

void desactivacursor(void);
void activacursor(void);
int iniciamouse(void);
void vismouse(void);
void novismouse(void);
void mouse();
void versolocursor();
void posactualmouse(void);
void setposmouse(int x, int y);
void infopulsa(void);
void infoliberacion(void);
void waitForPressedLeftButton();
void excluyemouse(int x1, int y1, int x2, int y2);

class ruleta	{
	unsigned char far *imagen;
	int radio;
	public:
	ruleta(int r=105): imagen(0), radio(r) {}
	~ruleta() { if(imagen) farfree(imagen); }
	void creaimagen(int numsector);
	void guardaimagen();
	void visualizaimagen(int x, int y);
};

void ruleta::creaimagen(int numsector)
{
int color,i;

for(i=1; i<=22; i++)
	{
	if(i<=12)
		{
		if((i==1) || (i==12))
			color=2; //2 verde
		else if(!(i%2))
			color=4; //4 rojo
		else if(i%2)
			color=0; //0 negro
		}
	else
		{
		if(!(i%2))
			color=0;
		else if(i%2)
			color=4;
		}
	setfillstyle(SOLID_FILL,color);
	pieslice(radio,radio,(numsector+i-2)*360/22,(numsector+i-1)*360/22,radio);
	}
}

void ruleta::guardaimagen()
{
int bytes;
bytes=imagesize(0,0,2*radio,2*radio);
imagen=(unsigned char far *) farmalloc(bytes);
if(!imagen)
	{
	closegraph();
	cout<<"No se obtuvo memoria para la imagen...";
	getch();
	exit(1);
	}
getimage(0,0,2*radio,2*radio,imagen);
}

void ruleta::visualizaimagen(int x, int y)
{
putimage(x-radio,y-radio,imagen,COPY_PUT);
}

//*** Clase encargada de colocar el cursor en pantalla, para la edición
class cursor	{
	unsigned char *imagenant, *imagencursor;
	public:
		cursor();
		~cursor() { if(imagencursor) delete imagencursor; }
		void obtenimagen(int x, int y);
		void poncursor(int x, int y);
		void ponimagen(int x, int y);
		void liberamemoria() { if(imagenant) delete imagenant; }
};

cursor::cursor()
{
int bytes;
imagencursor=0;
bytes=imagesize(0,0,8,1);
imagencursor=new unsigned char[bytes];
if(!imagencursor)
	{
	errormemoria();
	}
getimage(0,0,8,1,imagencursor);
for(int i=4; i<bytes; ++i)
	imagencursor[i]=0;
}

void cursor::obtenimagen(int x, int y)
{
int bytes;
imagenant=NULL;
bytes=imagesize(x,y,x+8,y+1);
imagenant=new unsigned char[bytes];
if(!imagenant)
	{
	closegraph();
	cout<<"No se obtuvo memoria para la imagen...";
	getch();
	return;
	}
getimage(x,y,x+8,y+1,imagenant);
}

void cursor::poncursor(int x, int y)
{
putimage(x,y,imagencursor,COPY_PUT);
}

void cursor::ponimagen(int x, int y)
{
novismouse();
putimage(x,y,imagenant,COPY_PUT);
vismouse();
}

//***** Gestor de ventanas ***
class app	{

};

class juego;

enum bool {true,false};

class point	{
public:
	int x;
	int y;
	point(int cx, int cy): x(cx), y(cy)
		{
		}
};

class frame	{
protected:
	app *pApp;
	int left, top, right, bottom;
	int color;
	bool visible;
	unsigned char *imagenant;
	public:
		frame(app *pa, int l, int t, int r, int b, int c=LIGHTGRAY): pApp(pa),
		left(l), top(t), right(r), bottom(b), color(c), visible(true), imagenant(0)
			{
			}
		virtual ~frame()
			{
			delete imagenant;
			}
		virtual void draw()
			{
			if(visible==true)
				{
				setfillstyle(SOLID_FILL,color);
				bar(left,top,right,bottom);
				}
			}
		virtual void click(const point &p)
			{
			}
		void getImage()
			{
			int bytes;
			delete imagenant;
			imagenant=0;
			bytes=imagesize(left,top,right,bottom);
			imagenant=new unsigned char[bytes];
			if(!imagenant)
				{
				cout<<"No se obtuvo memoria para la imagen...";
				}
			else
				getimage(left,top,right,bottom,imagenant);
			}
		void putImage()
			{
			if(imagenant)
				{
				novismouse();
				putimage(left,top,imagenant,COPY_PUT);
				vismouse();
				delete imagenant;
				imagenant=0;
				}
			}

};

class wnd: public frame	{
	bool active;
	bool ontop;
	frame *pChildren[100];
	int nChildren;
	char far *caption;
	public:
		wnd(app *pa, int l, int t, int r, int b, char far *c, int color=LIGHTGRAY): frame(pa,l,t,r,b,color),
		active(false), nChildren(0), caption(c)
			{
			}
		virtual ~wnd()
			{
			for(int i=0; i<nChildren; ++i)
				{
				delete pChildren[i];
				}
			}
		void addChild(frame *p)
			{//sólo 100*****
			pChildren[nChildren]=p;
			++nChildren;
			}
		virtual void click(const point &p)
			{
			for(int i=0; i<nChildren; ++i)
				{
				pChildren[i]->click(p);
				}
			}
		virtual void draw()
			{
/*			setfillstyle(SOLID_FILL,3);
			line(left-1,top-1,right+1,top-1);
			line(left-1,top,left-1,bottom+1);
			setfillstyle(SOLID_FILL,1);
			bar(left,top,right,bottom);
			outtextxy((right-left)/2-(strlen((char near *)caption)*8/2)+left,top+7,caption); //640 X 350 pix.
*/
			novismouse();
			frame::draw();
			for(int i=0; i<nChildren; ++i)
				pChildren[i]->draw();
			vismouse();
			}
};

class messageBox: public frame	{
	char far *message;
	public:
		messageBox(app *pa, int l, int t, int r, int b, char far *m, int color=LIGHTGRAY): frame(pa,l,t,r,b,color),
		message(m)
			{
			}
		virtual ~messageBox()
			{
			}
		virtual void draw()
			{
			int lastColor=getcolor();
			getImage();
			frame::draw();

			setcolor(WHITE);
			line(left,top,right,top);
			line(left,top,left,bottom);
			setcolor(BLACK);
			line(left+1,bottom,right,bottom);
			line(right,top+1,right,bottom);
			setcolor(lastColor);

			outtextxy((right-left)/2-(strlen((char near *)message)*8/2)+left,top+7,message);
			getch();
			putImage();
			}

};

class button: public frame	{
	char far *caption;
	public:
		button(app *pa, int l, int t, int r, int b, char far *c, int color=LIGHTGRAY): frame(pa,l,t,r,b,color), caption(c)
			{
			}
		virtual ~button()
			{
			}
		virtual void draw()
			{
			int lastColor=getcolor();
			//setlinestyle(SOLID_LINE,WHITE,NORM_WIDTH);
			setcolor(WHITE);
			line(left,top,right,top);
			line(left,top,left,bottom);
			//setlinestyle(SOLID_FILL,BLACK,NORM_WIDTH);
			setcolor(BLACK);
			line(left+1,bottom,right,bottom);
			line(right,top+1,right,bottom);
			setcolor(lastColor);
			setfillstyle(SOLID_FILL,color);
			bar(left+1,top+1,right-1,bottom-1);
			outtextxy((right-left)/2-(strlen((char near *)caption)*8/2)+left,top+7,caption); //640 X 350 pix.
			}

};

class editBox: public frame	{
	char far *caption;
	char *text;
	public:
		editBox(app *pa, int l, int t, int r, int b, char far *c, int color=LIGHTGRAY): frame(pa,l,t,r,b,color), caption(c),
		text(0)
			{
			}
		virtual ~editBox()
			{
			delete text;
			}
		virtual void draw()
			{
			int lastColor=getcolor();
			getImage();
			setcolor(BLACK);
			line(left,top,right,top);
			line(left,top,left,bottom);
			setcolor(WHITE);
			line(left+1,bottom,right,bottom);
			line(right,top+1,right,bottom);
			setcolor(lastColor);
			setfillstyle(SOLID_FILL,color);
			bar(left+1,top+1,right-1,bottom-1);
			//outtextxy((right-left)/2-(strlen((char near *)caption)*8/2)+left,top+7,caption);
			}
		virtual void read()
			{
			delete text;
			leecadenaxy(left+10,top+15,text);
			putImage();
			}

		char *getText()
			{
			return text;
			}

};

class label: public frame	{
	char far *caption;
	public:
		label(app *pa, int l, int t, int r, int b, char far *c, int color=LIGHTGRAY): frame(pa,l,t,r,b,color), caption(c)
			{
			}
		virtual ~label()
			{
			}
		virtual void draw()
			{
//			int lastColor=getcolor();
//			setcolor(lastColor);
			setfillstyle(SOLID_FILL,color);
			bar(left+1,top+1,right-1,bottom-1);
			outtextxy((right-left)/2-(strlen((char near *)caption)*8/2)+left,top+7,caption);
			}
};

class barra: public frame	{
	frame *pChildren[100];
	int nChildren;
	public:
		barra(app *pa, int l, int t, int r, int b, int color=LIGHTGRAY): frame(pa,l,t,r,b,color),
		nChildren(0)
			{
			}
		virtual ~barra()
			{
			for(int i=0; i<nChildren; ++i)
				{
				delete pChildren[i];
				}
			}
		virtual void draw()
			{
			setfillstyle(SOLID_FILL,3);
			line(left-1,top-1,right+1,top-1);//??
			line(left-1,top,left-1,bottom+1);
			frame::draw();
			for(int i=0; i<nChildren; ++i)
				pChildren[i]->draw();
			}
		void addChild(frame *p)
			{//sólo 100*****
			pChildren[nChildren]=p;
			++nChildren;
			}
};

class clock: public frame	{
	char far *caption;
	unsigned int horas, minutos;
	public:
		clock(app *pa, int l, int t, int r, int b, char far *c, int color=LIGHTGRAY): frame(pa,l,t,r,b,color), caption(0),
		horas(0), minutos(0)
			{
			}
		virtual ~clock()
			{
			}
		virtual void draw();
};

		void clock::draw()
			{
			ostrstream os;
			unsigned int h=0,m=0;

			asm	{
			mov ah,2ch
			int 21h
			mov h,ch
			mov m,cl
			}

			if(h!=horas || m!=minutos)
				{
				horas=h;
				minutos=m;
				os<<horas<<':'<<minutos<<'\0';
				caption=os.str();
				setfillstyle(SOLID_FILL,color);
				int lastcolor=getcolor();
				setcolor(BLACK);
				bar(left+1,top+1,right-1,bottom-1);
				outtextxy((right-left)/2-(strlen((char near *)caption)*8/2)+left,top+7,caption);
				delete caption;
				caption=0;
				setcolor(lastcolor);
				}
			}

class windowManager	{
	wnd *pWindows[100];
	int nWindows;
	public:
		windowManager(): nWindows(0)
			{
			}
		~windowManager()
			{
			for(int i=0; i<nWindows; ++i)
				{
				delete pWindows[i];
				}
			}
		void addWindow(wnd *p)
			{
			pWindows[nWindows]=p;
			++nWindows;
			}
};

//****
class juego: public app	{
	int fondos, apuesta, numcolor, active, bandactiva;
	int contsector, xcentral, ycentral, i, j, k, lentitud;
	char numeros[6], banderadetencion;
	ruleta *ruletaptr[11];
	public:
		juego(): fondos(0), apuesta(0), numcolor(0), active(1),
		bandactiva(0), contsector(0), i(0), j(0), k(0),
		lentitud(0), xcentral(getmaxx()/2), ycentral(getmaxy()/2), banderadetencion(0)
			{
			for(int j=0; j<11; j++)
				{
				ruletaptr[j]=new ruleta;
				ruletaptr[j]->creaimagen(j+1);
				ruletaptr[j]->guardaimagen();
				}
			}
		~juego()
			{
			for(int j=0; j<11; j++)
				delete ruletaptr[j];
			}

		void ffondos(void)
			{
			int x1,y1,x2,y2;
			char texto[]="¨Cu nto posees? ";
			x1=1.0/3*getmaxx();
			y1=4.0/10*getmaxy();
			x2=2.0/3*getmaxx();
			y2=5.0/10*getmaxy();
			novismouse();
			editBox eb1(this,x1,y1,x2,y2,"Fondo");
			eb1.draw();
			eb1.read();

			fondos=atoi(eb1.getText());
			vismouse();
			}

		void fapuesta(void)
			{
			int x1,y1,x2,y2;
			char texto[]="¨Cu nto apuestas? ";
			x1=1.0/3*getmaxx();
			y1=4.0/10*getmaxy();
			x2=2.0/3*getmaxx();
			y2=5.0/10*getmaxy();
			novismouse();
			editBox eb1(this,x1,y1,x2,y2,"Apuesta");
			eb1.draw();
			eb1.read();

			apuesta=atoi(eb1.getText());
			vismouse();
			}

		void fnumcolor(void)
			{
			int x1,y1,x2,y2;
			char texto[]="¨Color (0=negro/1=rojo)? ";
			x1=1.0/3*getmaxx();
			y1=4.0/10*getmaxy();
			x2=2.0/3*getmaxx();
			y2=5.0/10*getmaxy();
			novismouse();
			editBox eb1(this,x1,y1,x2,y2,"Color");
			eb1.draw();
			eb1.read();

			numcolor=atoi(eb1.getText());
			vismouse();
			}

		void fayuda()
			{
			char caracter, cad[2];
			cad[0]=0;
			cad[1]=0;
			int x=0,y=0;
			
			ifstream entrada("ruleta.ayd", ios::binary | ios::in);
			novismouse();
			//cleardevice();
			while(entrada.get(caracter))
				{
				if(!iscntrl(caracter))
					{
					cad[0]=caracter;
					outtextxy(x,y,cad);
					x+=8;
					}
				if(caracter=='\r')
					{
					y+=8;
					x=0;
					}
				}
			entrada.close();
			getch();
			vismouse();
			}

		void about()
			{
			messageBox m(this,1.0/3*getmaxx(),4.0/10*getmaxy(),2.0/3*getmaxx(),5.0/10*getmaxy(),"Autor: Ariel Medina");
			m.draw();
			}

		void activar(void)
			{
			bandactiva=1;
			banderadetencion=1;
			if((fondos<=0)||(!apuesta))
				{
				bandactiva=0;
				banderadetencion=0;
				messageBox m(this,1.0/3*getmaxx(),4.0/10*getmaxy(),2.0/3*getmaxx(),5.0/10*getmaxy(),"No hay fondos o apuesta...");
				m.draw();
				}
			}

		void detener(void)
			{
			bandactiva=0;
			if(banderadetencion)
				{
				if(contsector!=11)
					{
					if(!(contsector%2))
						{
//						rojo=0;
//						negro=1;
						if(numcolor)
							fondos+=apuesta;
						else
							fondos-=apuesta;
						}
					else if(contsector%2)
						{
//						negro=0;
//						rojo=1;
						if(numcolor)
							fondos-=apuesta;
						else
							fondos+=apuesta;
						}
					}
				}
			if((fondos>0)&&(banderadetencion))
				{
				setfillstyle(SOLID_FILL,0);
				bar(30,2*ycentral-50,150,2*ycentral-40);
				outtextxy(30,2*ycentral-50,"Saldo:");
				outtextxy(80,2*ycentral-50,itoa(fondos,numeros,10));
				//getch();
				banderadetencion=0;
				strcpy(numeros,"");
				}
			else if(fondos<=0 && banderadetencion)
				{
				banderadetencion=0;
				messageBox m(this,1.0/3*getmaxx(),4.0/10*getmaxy(),2.0/3*getmaxx(),5.0/10*getmaxy(),"Has quebrado...");
				m.draw();
				}
			}

		void acelerar(void)
			{
			if(lentitud && bandactiva)
				{
				lentitud-=20;
				k=lentitud;
				}
			}

		void ralentizar(void)
			{
			if(bandactiva)
				{
				lentitud+=20;
				k=lentitud;
				}
			}

		void quit(void)
			{
			active=0;
			}
		int isActive() const
			{
			return active;
			}

		void animate()
			{
			if(bandactiva)
				{
				if(k)
					{
					--k;
					return;
					}
				waitRetrace();
				ruletaptr[i]->visualizaimagen(xcentral,ycentral);
				contsector++;
				if(contsector>11)
					contsector=1;
				if(lentitud<220)
					sound(220-lentitud);
		//		delay(lentitud);
				nosound();
				i++;
				if(i==11)
					i=0;
				j++;
				if(j==11)
					{
					lentitud+=20;
					k=lentitud;
					j=0;
					}
				else
					k=lentitud;
				}
			}

		void animateFromPort()
			{
			if(bandactiva)
				{
				waitRetrace();
				ruletaptr[i]->visualizaimagen(xcentral,ycentral);
				contsector++;
				if(contsector>11)
					contsector=1;
				if(lentitud<220)
					sound(220-lentitud);
		//		delay(lentitud);
				nosound();
				i++;
				if(i==11)
					i=0;
				j++;
				if(j==11)
					{
					lentitud+=1;
					j=0;
					}
				}
			}

};

//****

class buttonFondos: public button	{
	public:
		buttonFondos(app *pa, int l, int t, int r, int b, char far *c, int color=LIGHTGRAY): button(pa,l,t,r,b,c,color)
			{
			}
		virtual ~buttonFondos()
			{
			}
		virtual void click(const point &p)
			{
			if(p.x>=left && p.x<=right && p.y>=top && p.y<=bottom)
				{
				juego *pj=(juego *)pApp;
				pj->ffondos();
				}
			}
};

class buttonApuesta: public button	{
	public:
		buttonApuesta(app *pa, int l, int t, int r, int b, char far *c, int color=LIGHTGRAY): button(pa,l,t,r,b,c,color)
			{
			}
		virtual ~buttonApuesta()
			{
			}
		virtual void click(const point &p)
			{
			if(p.x>=left && p.x<=right && p.y>=top && p.y<=bottom)
				{
				juego *pj=(juego *)pApp;
				pj->fapuesta();
				}
			}
};

class buttonColor: public button	{
	public:
		buttonColor(app *pa, int l, int t, int r, int b, char far *c, int color=LIGHTGRAY): button(pa,l,t,r,b,c,color)
			{
			}
		virtual ~buttonColor()
			{
			}
		virtual void click(const point &p)
			{
			if(p.x>=left && p.x<=right && p.y>=top && p.y<=bottom)
				{
				juego *pj=(juego *)pApp;
				pj->fnumcolor();
				}
			}
};

class buttonAyuda: public button	{
	public:
		buttonAyuda(app *pa, int l, int t, int r, int b, char far *c, int color=LIGHTGRAY): button(pa,l,t,r,b,c,color)
			{
			}
		virtual ~buttonAyuda()
			{
			}
		virtual void click(const point &p)
			{
			if(p.x>=left && p.x<=right && p.y>=top && p.y<=bottom)
				{
				juego *pj=(juego *)pApp;
				pj->fayuda();
				}
			}
};

class buttonAbout: public button	{
	public:
		buttonAbout(app *pa, int l, int t, int r, int b, char far *c, int color=LIGHTGRAY): button(pa,l,t,r,b,c,color)
			{
			}
		virtual ~buttonAbout()
			{
			}
		virtual void click(const point &p)
			{
			if(p.x>=left && p.x<=right && p.y>=top && p.y<=bottom)
				{
				juego *pj=(juego *)pApp;
				pj->about();
				}
			}
};

class buttonActivar: public button	{
	public:
		buttonActivar(app *pa, int l, int t, int r, int b, char far *c, int color=LIGHTGRAY): button(pa,l,t,r,b,c,color)
			{
			}
		virtual ~buttonActivar()
			{
			}
		virtual void click(const point &p)
			{
			if(p.x>=left && p.x<=right && p.y>=top && p.y<=bottom)
				{
				juego *pj=(juego *)pApp;
				pj->activar();
				}
			}
};

class buttonDetener: public button	{
	public:
		buttonDetener(app *pa, int l, int t, int r, int b, char far *c, int color=LIGHTGRAY): button(pa,l,t,r,b,c,color)
			{
			}
		virtual ~buttonDetener()
			{
			}
		virtual void click(const point &p)
			{
			if(p.x>=left && p.x<=right && p.y>=top && p.y<=bottom)
				{
				juego *pj=(juego *)pApp;
				pj->detener();
				}
			}
};

class buttonAcelerar: public button	{
	public:
		buttonAcelerar(app *pa, int l, int t, int r, int b, char far *c, int color=LIGHTGRAY): button(pa,l,t,r,b,c,color)
			{
			}
		virtual ~buttonAcelerar()
			{
			}
		virtual void click(const point &p)
			{
			if(p.x>=left && p.x<=right && p.y>=top && p.y<=bottom)
				{
				juego *pj=(juego *)pApp;
				pj->acelerar();
				}
			}
};

class buttonRalentizar: public button	{
	public:
		buttonRalentizar(app *pa, int l, int t, int r, int b, char far *c, int color=LIGHTGRAY): button(pa,l,t,r,b,c,color)
			{
			}
		virtual ~buttonRalentizar()
			{
			}
		virtual void click(const point &p)
			{
			if(p.x>=left && p.x<=right && p.y>=top && p.y<=bottom)
				{
				juego *pj=(juego *)pApp;
				pj->ralentizar();
				}
			}
};

class buttonQuit: public button	{
	public:
		buttonQuit(app *pa, int l, int t, int r, int b, char far *c, int color=LIGHTGRAY): button(pa,l,t,r,b,c,color)
			{
			}
		virtual ~buttonQuit()
			{
			}
		virtual void click(const point &p)
			{
			if(p.x>=left && p.x<=right && p.y>=top && p.y<=bottom)
				{
				juego *pj=(juego *)pApp;
				pj->quit();
				}
			}
};

//**********

/*
setcolor(3);
setfillstyle(SOLID_FILL,3);
setlinestyle(SOLID_LINE,3,NORM_WIDTH);
outtextxy(getmaxx()/2-125,getmaxy()/2-8,"->");
*/

/***************************************************************************/
/************************* Programa principal ******************************/
/***************************************************************************/

main()
{
int xcentral, ycentral;
int manejador=DETECT, modo;
int x,y,boton;

if(!iniciamouse())
	{
	cout<<"No hay dispositivo de rat¢n instalado...";
	getch();
	return 1;
	}
if(registerbgidriver(EGAVGA_driver)<0)
	{
	cout<<"Error de gr ficos";
	getch();
	exit(1);
	}
initgraph(&manejador, &modo,"");
if(graphresult() != grOk)
	{
	cout<<"No hay gr ficos\n";
	exit(1);
	}

xcentral=getmaxx()/2;
ycentral=getmaxy()/2;

//*********
barra *p;
button *pb;
clock *pClock;

juego myj;
wnd w1(&myj,0,0,getmaxx(),getmaxy(),"La ventanita del amor",CYAN);

w1.addChild(new buttonFondos(&myj,40,100,140,120,"Fondos"));
w1.addChild(new buttonApuesta(&myj,40,130,140,150,"Apuesta"));
w1.addChild(new buttonColor(&myj,40,160,140,180,"Color"));
w1.addChild(new buttonAyuda(&myj,40,190,140,210,"Ayuda"));
w1.addChild(new buttonAbout(&myj,40,220,140,240,"Acerca de"));
w1.addChild(new buttonActivar(&myj,500,100,600,120,"Activar"));
w1.addChild(new buttonDetener(&myj,500,130,600,150,"Detener"));
w1.addChild(new buttonAcelerar(&myj,500,160,600,180,"Acelerar"));
w1.addChild(new buttonRalentizar(&myj,500,190,600,210,"Ralentizar"));
w1.addChild(new buttonQuit(&myj,500,220,600,240,"Salir"));
w1.addChild(new label(&myj,30,2*ycentral-100,80,2*ycentral-50,"Salir"));
w1.addChild(p=new barra(&myj,0,getmaxy()-20,getmaxx(),getmaxy(),BLUE));
p->addChild(new button(&myj,5,getmaxy()-20,80,getmaxy(),"Principal"));
p->addChild(pClock=new clock(&myj,getmaxx()-100,getmaxy()-20,getmaxx()-5,getmaxy(),"HORA"));

//**********
mouse();

//****************

w1.draw();

do
	{
	x=y=boton=0;
	
	asm mov ax,0x3
	asm int 0x33
	asm mov x,cx
	asm mov y,dx
	asm mov boton,bx
	if(boton==1)
		{
		waitForPressedLeftButton();
		w1.click(point(x,y));
		}
	myj.animate();
	pClock->draw();

	}while(myj.isActive());
nosound();
//getch();

closegraph();
versolocursor();
return 0;
}

/************************* Funciones **************************************/

int leecadenaxy(int x, int y, char * &caracteres)
{
static cursor cursor1;
ostrstream os;

char caracter, cadcarac[2];
cadcarac[0]=' ';
cadcarac[1]=0;
do
	{
	caracter='\0';
	cursor1.obtenimagen(x,y+5);
	do
		{
		cursor1.poncursor(x,y+5);
		delay(100);
		cursor1.ponimagen(x,y+5);
		delay(100);
		}while(!kbhit());
	caracter=getch();
	cursor1.liberamemoria();
	if(isdigit(caracter))
		{
		cadcarac[0]=caracter;
		outtextxy(x,y,cadcarac);
		x+=8;
		os<<caracter;
		}
	}while(caracter!='\r');
os<<'\0';
caracteres=os.str();

return 0;
}

void errormemoria()
{
closegraph();
cout<<"Error de asignaci¢n de memoria...";
getch();
exit(1);
}

//******* Funciones para el ratón *****************

void desactivacursor(void)
{
asm mov ch,0x20;
asm mov cl,0x20;
asm mov ah,0x1;
asm int 0x10;
}

void activacursor(void)
{
asm mov ch,0x6;
asm mov cl,0x7;
asm mov ah,0x1;
asm int 0x10;
}

int iniciamouse(void)
{
int bytebandera=0;
asm mov ax,0x0;
asm int 0x33;
asm mov bytebandera,ax;
return bytebandera;
}

void vismouse(void)
{
asm mov ax,0x1;
asm int 0x33;
}

void novismouse(void)
{
asm mov ax,0x2;
asm int 0x33;
}

void posactualmouse(void)
{
asm mov ax,0x3;
asm int 0x33;
}

void setposmouse(int x, int y)
{
asm mov ax,0x4;
asm mov cx,x;
asm mov dx,y;
asm int 0x33;
}

void infopulsa(void)
{
asm mov ax,0x5;
asm mov bx,0;
asm int 0x33;
}

void infoliberacion(void)
{
asm mov ax,0x6;
asm mov bx,0;
asm int 0x33;
}

void waitForPressedLeftButton()
{
int boton;
do
	{
	asm mov ax,0x3
	asm int 0x33
	asm mov boton,bx
	}while(boton==1);
}

void mouse(void)
{
desactivacursor();
vismouse();
}

void versolocursor(void)
{
novismouse();
activacursor();
}

void excluyemouse(int x1, int y1, int x2, int y2)
{
asm mov ax,0x10
asm mov cx,x1
asm mov dx,y1
asm mov si,x2
asm mov di,y2
asm int 0x33
}